Logo Search packages:      
Sourcecode: ted version File versions

docNotes.c

/************************************************************************/
/*                                                    */
/*  Manage fields.                                          */
/*                                                    */
/************************************************************************/

#   include "tedConfig.h"

#   include <stdlib.h>
#   include <string.h>
#   include <stdio.h>
#   include <limits.h>

#   include <appDebugon.h>

#   include <appUnit.h>
#   include "docBuf.h"
#   include "docEdit.h"

/************************************************************************/
/*                                                    */
/*  Manage Footnotes/Endnotes.                                    */
/*                                                    */
/************************************************************************/

void docInitNote(       DocumentNote *          dn )
    {
    docInitExternalItem( &(dn->dnExternalItem) );

    dn->dnNoteNumber= 0;

    dn->dnReferringPage= -1;
    dn->dnReferringColumn= -1;
    dn->dnSectNr= -1;
    dn->dnParaNr= -1;
    dn->dnStroff= -1;

    dn->dnExternalItemKind= DOCinFOOTNOTE;
    dn->dnAutoNumber= 1;

    return;
    }

void docCleanNote(            BufferDocument *  bd,
                        DocumentNote *          dn )
    {
    docCleanExternalItem( bd, &(dn->dnExternalItem) );

    return;
    }

/************************************************************************/
/*                                                    */
/*  Insert a Footnote/Endnote in a BufferItem.                    */
/*                                                    */
/*  1)  Look for a note or the place to insert a new one.         */
/*    NOTE that positions with a negative paragraph number are always   */
/*    skipped.                                        */
/*    NOTE that when a position for a new note is found, its index      */
/*    is that of its successor, that usually will be shifted away.      */
/*  2)  When the previous position is an empty hole, use it in stead    */
/*    of shifting the successors away.                      */
/*  3)  Make a guess about the note number. If the guess is wrong, it   */
/*    fixed later. Fixing can involve a reformat, so making not too     */
/*    bad a guess here does help.                           */
/*                                                    */
/************************************************************************/

/*  1  */
static int docGetNoteIndex(         int *             pFound,
                              const BufferDocument *  bd,
                              int               paraNr,
                              int               stroff )
    {
    DocumentNote *      dn;
    int                 note;

    dn= bd->bdNotes;
    for ( note= 0; note < bd->bdNoteCount; dn++, note++ )
      {
      if  ( dn->dnParaNr < paraNr )
          { continue;   }
      if  ( dn->dnParaNr > paraNr )
          { break;      }

      if  ( dn->dnStroff < stroff )
          { continue;   }
      if  ( dn->dnStroff > stroff )
          { break;      }

      *pFound= 1; return note;
      }

    *pFound= 0; return note;
    }

int docInsertNote(                  DocumentNote **         pDn,
                              BufferDocument *  bd,
                              BufferItem *            paraBi,
                              int               stroff,
                              int               autoNumber )
    {
    int                 paraNr;
    int                 noteIndex;
    int                 found;

    BufferItem *  sectBi;
    DocumentNote *      fresh;

    int                 i;

    if  ( paraBi->biLevel != DOClevPARA         ||
        paraBi->biInExternalItem != DOCinBODY   )
      {
      SLDEB(docLevelStr(paraBi->biLevel),paraBi->biInExternalItem);
      return -1;
      }

    paraNr= docNumberOfParagraph( paraBi );
    if  ( paraNr < 0 )
      { LDEB(paraNr); return -1;    }

    sectBi= paraBi;
    while( sectBi && sectBi->biLevel != DOClevSECT )
      { sectBi= sectBi->biParent;   }

    if  ( ! sectBi )
      { XDEB(sectBi); return -1;    }

    fresh= realloc( bd->bdNotes, ( bd->bdNoteCount+ 1 )* sizeof(DocumentNote) );
    if  ( ! fresh )
      { LXDEB(bd->bdNoteCount,fresh); return -1;      }
    bd->bdNotes= fresh;

    noteIndex= docGetNoteIndex( &found, bd, paraNr, stroff );
    if  ( found )
      { LDEB(found);    }

    /*  2  */
    if  ( noteIndex > 0 && fresh[noteIndex-1].dnParaNr < 0 )
      { noteIndex--;    }
    else{
      for ( i= bd->bdNoteCount; i > noteIndex; i-- )
          {
          fresh[i]= fresh[i-1];

          if  ( fresh[i].dnExternalItem.eiItem )
            {
            fresh[i].dnExternalItem.eiItem->
                            biSectSelectionScope.ssNoteArrayIndex= i;
            }
          }
      }

    docInitNote( fresh+ noteIndex );

    /*  3  */
    if  ( autoNumber )
      { fresh[noteIndex].dnNoteNumber= noteIndex;     }
    else{ fresh[noteIndex].dnNoteNumber= 0;           }

    fresh[noteIndex].dnSectNr= sectBi->biNumberInParent;
    fresh[noteIndex].dnParaNr= paraNr;
    fresh[noteIndex].dnStroff= stroff;
    fresh[noteIndex].dnAutoNumber= autoNumber;

    bd->bdNoteCount++;

    *pDn= fresh+ noteIndex; return noteIndex;
    }

/************************************************************************/
/*                                                    */
/*  Retrieve the note corresponding to the current position.            */
/*                                                    */
/*  1)  It is either the note the current posion refers to,       */
/*  2)  Or the note that contains the current position.                 */
/*                                                    */
/************************************************************************/

int docGetNote(         DocumentNote **         pDn,
                  const BufferDocument *  bd,
                  const BufferItem *      paraBi,
                  int               stroff )
    {
    int                 paraNr;
    int                 noteIndex;
    int                 found;

    if  ( paraBi->biLevel != DOClevPARA )
      {
      SLDEB(docLevelStr(paraBi->biLevel),paraBi->biInExternalItem);
      return -1;
      }

    /*  1  */
    if  ( paraBi->biInExternalItem == DOCinBODY )
      {
      paraNr= docNumberOfParagraph( paraBi );
      if  ( paraNr < 0 )
          { LDEB(paraNr); return -1;      }

      noteIndex= docGetNoteIndex( &found, bd, paraNr, stroff );
      if  ( ! found )
          {
          /* LLLDEB(paraNr,stroff,found); docListNotes( bd ); */
          return -1;
          }

      *pDn= bd->bdNotes+ noteIndex;
      return noteIndex;
      }

    /*  2  */
    if  ( paraBi->biInExternalItem == DOCinFOOTNOTE   ||
        paraBi->biInExternalItem == DOCinENDNOTE      )
      {
      const BufferItem *      noteSectBi;

      noteSectBi= paraBi;
      while( noteSectBi && noteSectBi->biLevel != DOClevSECT )
          { noteSectBi= noteSectBi->biParent;   }

      if  ( ! noteSectBi )
          { XDEB(noteSectBi); return -1;  }

      noteIndex= noteSectBi->biSectSelectionScope.ssNoteArrayIndex;

      *pDn= bd->bdNotes+ noteIndex;
      return noteIndex;
      }

    /*
    SLDEB(docLevelStr(paraBi->biLevel),paraBi->biInExternalItem);
    */
    return -1;
    }

/************************************************************************/
/*                                                    */
/*  Count the number f notes in the document.                     */
/*                                                    */
/************************************************************************/

int docCountNotes(            const BufferDocument *  bd )
    {
    int                 count= 0;

    int                 i;
    DocumentNote *      dn;

    dn= bd->bdNotes;
    for ( i= 0; i < bd->bdNoteCount; dn++, i++ )
      {
      if  ( dn->dnParaNr < 0 )
          { continue;   }

      count++;
      }

    return count;
    }

/************************************************************************/
/*                                                    */
/*  Return the first note on a page.                              */
/*                                                    */
/************************************************************************/

int docGetFirstNoteFromPage(  DocumentNote **         pDn,
                        const BufferDocument *  bd,
                        int               page,
                        int               extItKind )
    {
    int                 i;
    DocumentNote *      dn;

    dn= bd->bdNotes;
    for ( i= 0; i < bd->bdNoteCount; dn++, i++ )
      {
      if  ( dn->dnParaNr < 0 )
          { continue;   }
      if  ( dn->dnExternalItemKind != extItKind )
          { continue;   }

      if  ( dn->dnReferringPage == page )
          { *pDn= dn; return i;     }
      }

    return -1;
    }

int docGetFirstNoteOnPage(    DocumentNote **         pDn,
                        const BufferDocument *  bd,
                        int               page,
                        int               extItKind )
    {
    int                 i;
    DocumentNote *      dn;

    dn= bd->bdNotes;
    for ( i= 0; i < bd->bdNoteCount; dn++, i++ )
      {
      ExternalItem *    ei= &(dn->dnExternalItem);

      if  ( dn->dnParaNr < 0 )
          { continue;   }
      if  ( dn->dnExternalItemKind != extItKind )
          { continue;   }

      if  ( ei->eiPageFormattedFor == page )
          { *pDn= dn; return i;     }
      }

    return -1;
    }

int docGetFirstNoteOfSection( DocumentNote **         pDn,
                        const BufferDocument *  bd,
                        int               sect,
                        int               extItKind )
    {
    int                 i;
    DocumentNote *      dn;

    dn= bd->bdNotes;
    for ( i= 0; i < bd->bdNoteCount; dn++, i++ )
      {
      if  ( dn->dnParaNr < 0 )
          { continue;   }
      if  ( dn->dnExternalItemKind != extItKind )
          { continue;   }

      if  ( dn->dnSectNr == sect )
          { *pDn= dn; return i;     }
      }

    return -1;
    }

int docGetFirstNoteOfDocument(      DocumentNote **         pDn,
                        const BufferDocument *  bd,
                        int               extItKind )
    {
    int                 i;
    DocumentNote *      dn;

    dn= bd->bdNotes;
    for ( i= 0; i < bd->bdNoteCount; dn++, i++ )
      {
      if  ( dn->dnParaNr < 0 )
          { continue;   }
      if  ( dn->dnExternalItemKind != extItKind )
          { continue;   }

      *pDn= dn; return i;
      }

    return -1;
    }

/************************************************************************/
/*                                                    */
/*  Renumber the notes of a document.                             */
/*                                                    */
/************************************************************************/

void docRenumberNotes(        int *             pChanged,
                        BufferDocument *  bd )
    {
    const DocumentProperties *      dp= &(bd->bdProperties);
    const NotesProperties *   np;

    int                       footN= 0;
    int                       endN= 0;

    int                       page= -1;
    int                       sect= -1;

    int                       i;
    DocumentNote *            dn;

    dn= bd->bdNotes;
    for ( i= 0; i < bd->bdNoteCount; dn++, i++ )
      {
      if  ( dn->dnParaNr < 0 )
          { continue;   }

      if  ( ! dn->dnAutoNumber )
          {
          if  ( dn->dnNoteNumber != 0 )
            { *pChanged= 1;   }

          dn->dnNoteNumber= 0;
          continue;
          }

      /****/
      np= &(dp->dpFootnoteProperties);

      if  ( np->npRestart == FTN_RST_PER_SECTION      &&
            dn->dnSectNr != sect                )
          { footN= 0;   }

      if  ( np->npRestart == FTN_RST_PER_PAGE   &&
            dn->dnReferringPage != page         )
          { footN= 0;   }

      /****/
      np= &(dp->dpEndnoteProperties);

      if  ( np->npRestart == FTN_RST_PER_SECTION      &&
            dn->dnSectNr != sect                )
          { endN= 0;    }

      if  ( np->npRestart == FTN_RST_PER_PAGE   &&
            dn->dnReferringPage != page         )
          { endN= 0;    }

      /****/

      switch( dn->dnExternalItemKind )
          {
          case DOCinFOOTNOTE:
            if  ( dn->dnNoteNumber != footN )
                { dn->dnNoteNumber=   footN; *pChanged= 1;  }
            footN++;
            break;

          case DOCinENDNOTE:
            if  ( dn->dnNoteNumber != endN )
                { dn->dnNoteNumber=   endN; *pChanged= 1;   }
            endN++;
            break;

          default:
            LLDEB(i,dn->dnExternalItemKind);
            break;
          }

      sect= dn->dnSectNr;
      page= dn->dnReferringPage;
      }

    return;
    }

/************************************************************************/
/*                                                    */
/*  Adapt references from notes to the text because the number of */
/*  paragraphs changed in the document.                           */
/*                                                    */
/*  1)  Paranoia check. Skipping the paragraphs before the forst one    */
/*    also skips the deleted paragraphs with dn->dnParaNr == -1.  */
/*                                                    */
/************************************************************************/

void docShiftNoteReferences(        BufferDocument *  bd,
                              int               paraFrom,
                              int               stroffFrom,
                              int               sectShift,
                              int               paraShift,
                              int               stroffShift )
    {
    DocumentNote *      dn;
    int                 i;

    /*  1  */
    if  ( paraFrom < 1 )
      { LDEB(paraFrom); return;     }

    dn= bd->bdNotes;
    for ( i= 0; i < bd->bdNoteCount; dn++, i++ )
      {
      /*  1  */
      if  ( dn->dnParaNr < paraFrom )
          { continue;   }

      if  ( dn->dnParaNr > paraFrom )
          {
          if  ( sectShift == 0 && paraShift == 0 )
            { break;    }

          dn->dnSectNr += sectShift;
          dn->dnParaNr += paraShift;

          if  ( dn->dnExternalItem.eiItem )
            {
            dn->dnExternalItem.eiItem->
                  biSectSelectionScope.ssSectNrExternalTo= dn->dnSectNr;
            }

          continue;
          }

      if  ( dn->dnStroff < stroffFrom )
          { continue;   }
      if  ( dn->dnStroff > stroffFrom )
          {
          dn->dnSectNr += sectShift;
          dn->dnParaNr += paraShift;
          dn->dnStroff += stroffShift;

          if  ( dn->dnExternalItem.eiItem )
            {
            dn->dnExternalItem.eiItem->
                  biSectSelectionScope.ssSectNrExternalTo= dn->dnSectNr;
            }

          continue;
          }
      }

    return;
    }

/************************************************************************/
/*                                                    */
/*  Make a note at the given position.                            */
/*                                                    */
/*  1)  Claim memory for a note.                            */
/*  2)  Insert a particule that refers to the note.               */
/*  4)  Insert an empty paragraph in the note to begin with.            */
/*  5)  Make a chftn field to represent the note in the external  */
/*    paragraph.                                      */
/*  6)  Insert a space after the note number field. This also is to     */
/*    work around a bug in the editing around fields.             */
/*                                                    */
/*  !)  The chftn field that precedes the note was inserted by the      */
/*    caller.                                               */
/*                                                    */
/************************************************************************/

int docMakeNote(  DocumentNote **               pDn,
                  BufferDocument *        bd,
                  BufferItem *                  paraBi,
                  int                     part,
                  int                     stroff,
                  int                     extItKind )
    {
    TextParticule *     tp;
    TextAttribute ta;
    int                 textAttributeNumberPlain;
    int                 textAttributeNumberSuper;

    DocumentNote *      dn;

    int                 noteIndex;

    int                 stroffShift= 0;
    const int           autoNumber= 1;

    BufferItem *  noteParaBi;

    if  ( paraBi->biInExternalItem != DOCinBODY )
      { LDEB(paraBi->biInExternalItem); return -1;    }

    /*  1  */
    noteIndex= docInsertNote( &dn, bd, paraBi, stroff, autoNumber );
    if  ( noteIndex < 0 )
      { LDEB(noteIndex); return -1; }

    dn->dnExternalItemKind= extItKind;

    if  ( part > 0 )
      { tp= paraBi->biParaParticules+ part- 1;  }
    else{ tp= paraBi->biParaParticules+ part;         }

    utilGetTextAttributeByNumber( &ta,
            &(bd->bdTextAttributeList), tp->tpTextAttributeNumber );
    ta.taSuperSub= DOCfontREGULAR;
    textAttributeNumberPlain=
            utilTextAttributeNumber( &(bd->bdTextAttributeList), &ta );

    /*  2  */
    tp= docInsertTextParticule( paraBi, part+ 1,
                  stroff, 0, DOCkindNOTE, textAttributeNumberPlain );
    if  ( ! tp )
      { LDEB(paraBi->biParaParticuleCount); return -1; }

    /*  4  */
    noteParaBi= docMakeExternalparagraph( bd, &(dn->dnExternalItem),
                              paraBi, textAttributeNumberPlain,
                              noteIndex, DOCinFOOTNOTE );
    if  ( ! noteParaBi )
      { XDEB(noteParaBi); return -1;      }

    {
    TextAttribute taSet;

    taSet= ta;

    taSet.taSuperSub= DOCfontSUPERSCRIPT;

    textAttributeNumberSuper=
            utilTextAttributeNumber( &(bd->bdTextAttributeList), &taSet );
    }

    /*  5  */
    if  ( docInsertParaHeadField( noteParaBi, bd,
                            DOCfkCHFTN, textAttributeNumberSuper ) )
      { LDEB(1); return -1;   }

    /*  6  */
    if  ( docParaStringReplace( &stroffShift, noteParaBi,
                      noteParaBi->biParaStrlen, noteParaBi->biParaStrlen,
                      (const unsigned char *)" ", 1 ) )
      { LDEB(noteParaBi->biParaStrlen); return -1; }

    tp= docInsertTextParticule( noteParaBi, noteParaBi->biParaParticuleCount,
                      noteParaBi->biParaStrlen- 1, 1,
                      DOCkindTEXT, textAttributeNumberPlain );
    if  ( ! tp )
      { LDEB(noteParaBi->biParaParticuleCount); return -1; }

    *pDn= dn; return 0;
    }

/************************************************************************/
/*                                                    */
/*  Delete the note that corresponds to a particule.              */
/*                                                    */
/************************************************************************/

int docDeleteNoteOfParticule(       BufferDocument *  bd,
                              const BufferItem *      paraBi,
                              const TextParticule *   tp )
    {
    DocumentNote *      dn;

    if  ( docGetNote( &dn, bd, paraBi, tp->tpStroff ) < 0 )
      { LDEB(tp->tpStroff); return -1;    }

    docCleanNote( bd, dn );
    docInitNote( dn );

    return 0;
    }

/************************************************************************/
/*                                                    */
/*  Get the note corresponding to a selection.                    */
/*                                                    */
/*  1)  Get the note. Outside the note itself, only notes that are      */
/*    exactly the end position of the selection are found. In the */
/*    note itself, the note is returned.                    */
/*  2)  In body?                                      */
/*  3)  If the selection spans more than one paragraph, it does not     */
/*    qualify as the selection of exactly the bote refrence.            */
/*  4)  For a range selection, see whether the selection exactly covers */
/*    the note number.                                */
/*  5)  Look for the beginning of a note field at the beginning of the  */
/*    selection.                                      */
/*  6)  Does the same note field end at the end of the selection? */
/*  A)  Look for a note number field that ends at the IBar.       */
/*  B)  Look for the beginning of the field.                      */
/*  a)  Look for a note number field at the beginning of the note item. */
/*  b)  Look for the end of the field.                            */
/*                                                    */
/************************************************************************/

void docNoteGetTextBefore(    unsigned char *         fixedText,
                        int *             pFixedLen,
                        int *             pTextAttrNr,
                        int               fixedTextSize,
                        const BufferItem *      paraBi,
                        int               stroff )
    {
    int                       part;
    const TextParticule *     tp= paraBi->biParaParticules+ part;

    if  ( docFindParticule( &part, paraBi, stroff, 1 ) )
      { LDEB(stroff); fixedText[0]= '\0'; return;     }

    while( part >= 0 )
      {
      if  ( tp->tpStroff+ tp->tpStrlen < stroff )
          { break;      }

      if  ( tp->tpKind == DOCkindTEXT           &&
            tp->tpStroff < stroff         )
          {
          int           from= tp->tpStroff;
          int           len= tp->tpStrlen;

          if  ( len > fixedTextSize )
            { len= fixedTextSize; from += len- fixedTextSize; }

          *pFixedLen= len;
          *pTextAttrNr= tp->tpTextAttributeNumber;

          strncpy( (char *)fixedText,
                  (char *)paraBi->biParaString+ from, len )[len]= '\0';
          return;
          }

      part--; tp--;
      }

    fixedText[0]= '\0';
    return;
    }

void docNoteGetTextAtHead(    unsigned char *         fixedText,
                        int *             pFixedLen,
                        int               fixedTextSize,
                        const BufferItem *      paraBi )
    {
    const int                 partB= 0;
    const int                 stroff= 0;
    int                       part= partB;
    const TextParticule *     tp= paraBi->biParaParticules+ part;

    while( part >= 0 )
      {
      if  ( tp->tpStroff > stroff )
          { break;      }

      if  ( tp->tpKind == DOCkindTEXT                 &&
            tp->tpStroff+ tp->tpStrlen > stroff )
          {
          int           len= tp->tpStrlen;

          if  ( len > fixedTextSize )
            { len= fixedTextSize;   }

          *pFixedLen= len;
          strncpy( (char *)fixedText,
            (char *)paraBi->biParaString+ tp->tpStroff, len )[len]= '\0';
          return;
          }

      part++; tp++;
      }

    *pFixedLen= 0;
    fixedText[0]= '\0';
    return;
    }

int docDelimitNoteReference(  int *             pFieldNr,
                        int *             pPartBegin,
                        int *             pPartEnd,
                        int *             pStroffBegin,
                        int *             pStroffEnd,
                        const BufferItem *      paraBi,
                        int               stroff,
                        const BufferDocument *  bd )
    {
    const TextParticule *     tp;

    int                       fieldNr= -1;
    int                       partBegin= -1;
    int                       partEnd= -1;
    int                       stroffBegin= -1;
    int                       stroffEnd= -1;

    if  ( docFindParticule( &partEnd, paraBi, stroff, 1 ) )
      { LDEB(stroff); return -1;    }

    /*  A  */
    tp= paraBi->biParaParticules+ partEnd;
    while( partEnd >= 0             &&
         tp->tpStroff == stroff     )
      {
      if  ( tp->tpKind == DOCkindFIELDEND )
          {
          const DocumentField *     df;

          df= bd->bdFieldList.dflFields+ tp->tpObjectNumber;
          if  ( df->dfKind == DOCfkCHFTN )
            {
            fieldNr= tp->tpObjectNumber;
            stroffEnd= tp->tpStroff;
            break;
            }
          }

      partEnd--; tp--;
      }

    /*  B  */
    if  ( fieldNr >= 0 )
      {
      partBegin= partEnd;
      partBegin--; tp--;

      while( partBegin >= 0 )
          {
          if  ( tp->tpKind == DOCkindFIELDSTART &&
              tp->tpObjectNumber == fieldNr           )
            {
            stroffBegin= tp->tpStroff;
            break;
            }

          partBegin--; tp--;
          }

      if  ( partBegin < 0 )
          { fieldNr= -1;      }
      }

    if  ( fieldNr < 0 )
      { return 1; }

    *pFieldNr= fieldNr;
    *pPartBegin= partBegin;
    *pPartEnd= partEnd;
    *pStroffBegin= stroffBegin;
    *pStroffEnd= stroffEnd;

    return 0;
    }

int docGetSelectedNote(       DocumentNote **               pDn,
                        int *                   pFieldNr,
                        unsigned char *               fixedText,
                        int                     fixedTextSize,
                        BufferDocument *        bd,
                        const DocumentSelection *     ds )
    {
    DocumentNote *            dn;
    int                       noteIndex;

    const BufferItem *        paraBi;

    int                       fieldNr= -1;
    int                       partBegin= -1;
    int                       partEnd= -1;
    int                       stroffBegin= -1;
    int                       stroffEnd= -1;

    /*  1  */
    noteIndex= docGetNote( &dn, bd, ds->dsEnd.dpBi, ds->dsEnd.dpStroff );
    if  ( noteIndex < 0 )
      { return noteIndex;     }

    /*  2  */
    if  ( ds->dsSelectionScope.ssInExternalItem == DOCinFOOTNOTE  ||
        ds->dsSelectionScope.ssInExternalItem == DOCinENDNOTE           )
      {
      DocumentPosition  dpBegin;

      if  ( docFirstPosition( &dpBegin, dn->dnExternalItem.eiItem ) )
          { LDEB(1); return -1;     }

      paraBi= dpBegin.dpBi;

      if  ( docDelimitParaHeadField( &fieldNr, &partBegin, &partEnd,
                            &stroffBegin, &stroffEnd, paraBi, bd ) )
          {
          if  ( fixedTextSize > 0 )
            {
            int   fixedLen= 0;

            docNoteGetTextAtHead( fixedText, &fixedLen, fixedTextSize,
                                                    paraBi );
            }
          }
      else{
          if  ( fixedTextSize > 0 )
            { fixedText[0]= '\0'; }
          }
      }
    else{
      paraBi= ds->dsBegin.dpBi;

      /*  3  */
      if  ( ! docIsParaSelection( ds ) )
          { return -1;  }

      if  ( ! docDelimitNoteReference( &fieldNr, &partBegin, &partEnd,
            &stroffBegin, &stroffEnd, paraBi, ds->dsEnd.dpStroff, bd ) )
          {
          if  ( ! docIsIBarSelection( ds )            &&
              ds->dsBegin.dpStroff != stroffBegin     )
            { return 1; }
          }

      if  ( fixedTextSize > 0 )
          {
          if  ( fieldNr >= 0 )
            { fixedText[0]= '\0'; }
          else{
            int   fixedLen= 0;
            int   textAttrNr;

            docNoteGetTextBefore( fixedText, &fixedLen, &textAttrNr,
                        fixedTextSize, paraBi, ds->dsEnd.dpStroff );
            }
          }
      }

    *pDn= dn;
    *pFieldNr= fieldNr;
    return noteIndex;
    }

/************************************************************************/
/*                                                    */
/*  Verify that a certain kind of notes separator exists. Make it if    */
/*  not.                                              */
/*                                                    */
/*  1)  Correctly handeled by docTextAttributeNumber().                 */
/*                                                    */
/************************************************************************/

int docCheckNoteSeparatorItem(            BufferDocument *  bd,
                              int               extItKind )
    {
    ExternalItem *      ei;
    int                 particuleKind;

    switch( extItKind )
      {
      case DOCinFTNSEP:
      case DOCinAFTNSEP:
          particuleKind= DOCkindCHFTNSEP;
          break;

      case DOCinFTNSEPC:
      case DOCinAFTNSEPC:
          particuleKind= DOCkindCHFTNSEPC;
          break;

      default:
          LDEB(extItKind);
          particuleKind= DOCkindCHFTNSEP;
          break;
      }

    ei= docDocumentNoteSeparator( bd, extItKind );
    if  ( ! ei )
      { LXDEB(extItKind,ei); return -1;   }

    if  ( ! ei->eiItem )
      {
      const int         noteIndex= -1;
      int               attributeNumber;

      BufferItem *      bi;
      TextAttribute     ta;

      utilInitTextAttribute( &ta );
      ta.taFontNumber= -1; /*  1  */
      ta.taFontSizeHalfPoints= 24;

      attributeNumber= docTextAttributeNumber( bd, &ta );
      if  ( attributeNumber < 0 )
          { LDEB(attributeNumber); return -1;   }

      bi= docMakeExternalparagraph( bd, ei, &(bd->bdItem), attributeNumber,
                                        noteIndex, extItKind );
      if  ( ! bi )
          { XDEB(bi);   }
      else{
          if  ( docInflateTextString( bi, 1 ) )
            { LDEB(bi->biParaStrlen);     }
          else{
            TextParticule *   tp= bi->biParaParticules;

            tp->tpKind= particuleKind;
            tp->tpStrlen= 1;
            bi->biParaStrlen++;
            }
          }
      }

    return 0;
    }

/************************************************************************/
/*                                                    */
/*  Return the position in the document body where a note is            */
/*  referenced.                                             */
/*                                                    */
/************************************************************************/

int docGetNotePosition(       DocumentPosition *            dp,
                        BufferDocument *        bd,
                        const DocumentNote *          dn )
    {
    BufferItem *  paraBi;

    paraBi= docGetParagraphByNumber( &(bd->bdItem), dn->dnParaNr );
    if  ( ! paraBi )
      { LXDEB(dn->dnParaNr,paraBi); return -1;  }

    if  ( docSetDocumentPosition( dp, paraBi, dn->dnStroff ) )
      { LLDEB(paraBi->biParaStrlen,dn->dnStroff); return -1;      }

    return 0;
    }

Generated by  Doxygen 1.6.0   Back to index