AbiWord: fp_Run.h Source File

00001 /* -*- mode: C++; tab-width: 4; c-basic-offset: 4; -*- */
00002 
00003 /* AbiWord
00004  * Copyright (C) 1998,1999 AbiSource, Inc.
00005  * Copyright (c) 2001,2002 Tomas Frydrych
00006  *
00007  * This program is free software; you can redistribute it and/or
00008  * modify it under the terms of the GNU General Public License
00009  * as published by the Free Software Foundation; either version 2
00010  * of the License, or (at your option) any later version.
00011  *
00012  * This program is distributed in the hope that it will be useful,
00013  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00014  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00015  * GNU General Public License for more details.
00016  *
00017  * You should have received a copy of the GNU General Public License
00018  * along with this program; if not, write to the Free Software
00019  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
00020  * 02111-1307, USA.
00021  */
00022 
00023 
00024 
00025 #ifndef FP_RUN_H
00026 #define FP_RUN_H
00027 
00028 #ifdef FMT_TEST
00029 #include <stdio.h>
00030 #endif
00031 
00032 #include "ut_types.h"
00033 #include "ut_misc.h"
00034 #include "pt_Types.h"
00035 #include "ut_assert.h"
00036 #include "xap_Strings.h"
00037 #include "fl_BlockLayout.h"
00038 #include "pp_Revision.h"
00039 #include "ut_string_class.h"
00040 #include "fp_ContainerObject.h"
00041 
00042 class UT_GrowBuf;
00043 class fp_Line;
00044 class GR_Graphics;
00045 class GR_Font;
00046 class GR_Image;
00047 class PD_Document;
00048 class PP_AttrProp;
00049 struct dg_DrawArgs;
00050 class fl_CharWidths;
00051 class fd_Field;
00052 class fp_HyperlinkRun;
00053 class fp_AnnotationRun;
00054 
00055 struct fp_RunSplitInfo
00056 {
00057     UT_sint32 iLeftWidth;
00058     UT_sint32 iRightWidth;
00059     UT_sint32 iOffset;
00060 };
00061 
00062 // TODO The break type is not used. Is it put here looking forward,
00063 // TODO or is it left from some earlier experiments?
00064 enum FP_RUN_BREAK_TYPE
00065 {
00066     BREAK_AUTO          = 0,
00067     BREAK_AVOID         = 1,
00068     BREAK_ALWAYS        = 2
00069 };
00070 
00071 enum FP_RUN_TYPE
00072 {
00073     FPRUN__FIRST__                  = 1,
00074     FPRUN_TEXT                      = 1,
00075     FPRUN_IMAGE                     = 2,
00076     FPRUN_TAB                       = 3,
00077     FPRUN_FORCEDLINEBREAK           = 4,
00078     FPRUN_FORCEDCOLUMNBREAK         = 5,
00079     FPRUN_FORCEDPAGEBREAK           = 6,
00080     FPRUN_FIELD                     = 7,
00081     FPRUN_FMTMARK                   = 8,
00082     FPRUN_FIELDSTARTRUN             = 9,
00083     FPRUN_FIELDENDRUN               = 10,
00084     FPRUN_ENDOFPARAGRAPH            = 11,
00085     FPRUN_BOOKMARK                  = 12,
00086     FPRUN_HYPERLINK                 = 13,
00087     FPRUN_DIRECTIONMARKER           = 14,
00088     FPRUN_DUMMY                     = 15,
00089     FPRUN_MATH                      = 16,
00090     FPRUN_EMBED                      = 17,
00091     FPRUN__LAST__                   = 18
00092 };
00093 
00094 enum FP_HYPERLINK_TYPE
00095 {
00096     HYPERLINK_NORMAL =1,
00097     HYPERLINK_ANNOTATION = 2
00098 };
00099 
00100 // specifies how setX should handle screen clearing
00101 enum FPRUN_CLEAR_SCREEN
00102 {
00103     FP_CLEARSCREEN_AUTO,
00104     FP_CLEARSCREEN_FORCE,
00105     FP_CLEARSCREEN_NEVER
00106 };
00107 
00108 
00109 /*
00110     fp_Run represents a contiguous homogenous chunk on a single line.
00111     This file also defines the following subclasses:
00112 
00113         fp_TabRun
00114         fp_ForcedLineBreakRun
00115         fp_ForcedColumnBreakRun
00116         fp_ForcedPageBreakRun
00117         fp_ImageRun
00118         fp_FieldRun
00119         fp_FmtMarkRun
00120         fp_FieldStartRun
00121         fp_FieldEndRun
00122         fp_BookmarkRun
00123         fp_HyperlinkRun
00124         fp_AnnotationRun
00125         fp_DummyRun
00126 
00127     As far as the formatter's concerned, each subclass behaves somewhat
00128     differently, but they can all be treated like rectangular blocks to
00129     be arranged.
00130 
00131     Convention: _setFoo(bar) is just this.foo = bar;
00132                  setFoo(bar) sets this.foo to bar,
00133                                but may also do other processing to maintain
00134                                internal state.
00135 */
00136 class ABI_EXPORT fp_Run : fp_ContainerObject
00137 {
00138     friend class fg_FillType;
00139 public:
00140     fp_Run(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst,
00141            UT_uint32 iLen, FP_RUN_TYPE iType);
00142     virtual ~fp_Run();
00143 
00144     // inline getter member functions
00145 
00146     FP_RUN_TYPE             getType() const                 { return m_iType; }
00147     fp_Line*                getLine() const                 { return m_pLine; }
00148     fl_BlockLayout*         getBlock() const                { return m_pBL; }
00149     UT_sint32               getX() const                    { return m_iX; }
00150     UT_sint32               getY() const                    { return m_iY; }
00151 
00152     UT_sint32               getHeight() const;
00153     UT_sint32               getWidth() const;
00154     UT_uint32               getAscent() const;
00155     UT_uint32               getDescent() const;
00156     virtual UT_sint32       getDrawingWidth() const;
00157     
00158     fp_Run*                 getNextRun() const                  { return m_pNext; }
00159     fp_Run*                 getPrevRun() const                  { return m_pPrev; }
00160     bool                    isInSelectedTOC(void);
00161     virtual fp_ContainerObject * getNext(void) const { return NULL;}
00162     virtual fp_ContainerObject * getPrev(void) const { return NULL;}
00163     virtual fp_Container *       getNextContainerInSection(void) const { return NULL;}
00164     virtual fp_Container *       getPrevContainerInSection(void) const { return NULL;}
00165     virtual void                 setNext(fp_ContainerObject * /*pNull*/) {}
00166     virtual void                 setPrev(fp_ContainerObject * /*pNull*/) {}
00167     virtual void                 draw(GR_Graphics * /*pG*/) {}
00168 
00169     UT_uint32           getBlockOffset() const          { return m_iOffsetFirst; }
00170     UT_uint32           getLength() const               { return m_iLen; }
00171     GR_Graphics*        getGraphics() const;
00172     fp_HyperlinkRun *   getHyperlink() const            { return m_pHyperlink;}
00173 #if DEBUG
00174     virtual void        printText(void) {};
00175 #endif
00176 
00177     void                getSpanAP(const PP_AttrProp * &pSpanAP);
00178     const PP_AttrProp * getSpanAP(void);
00179 
00180     
00181     inline void         getBlockAP(const PP_AttrProp * &pBlockAP)
00182                                          {getBlock()->getAP(pBlockAP);}
00183         
00184     
00185     void                insertIntoRunListBeforeThis(fp_Run& newRun);
00186     void                insertIntoRunListAfterThis(fp_Run& newRun);
00187     fd_Field*           getField(void) const { return m_pField; }
00188     bool                isField(void) const { return (bool) (m_pField != NULL); }
00189     void                unlinkFromRunList();
00190 
00191     const UT_RGBColor   getFGColor(void) const;
00192 
00193     virtual bool        hasLayoutProperties(void) const;
00194 
00195     void                setLine(fp_Line*);
00196     void                setBlock(fl_BlockLayout * pBL) { _setBlock(pBL); }
00197     virtual void        setX(UT_sint32 x, bool bDontClearIfNeeded = false);
00198     void                Run_setX(UT_sint32, FPRUN_CLEAR_SCREEN eClearScreen = FP_CLEARSCREEN_AUTO);
00199     virtual void        setY(UT_sint32);
00200     void                setBlockOffset(UT_uint32);
00201     void                setLength(UT_uint32 iLen, bool bRefresh = true);
00202     void                setNextRun(fp_Run*, bool bRefresh = true);
00203     void                setPrevRun(fp_Run*, bool bRefresh = true);
00204     void                setHyperlink(fp_HyperlinkRun * pH);
00205     void                markWidthDirty() {m_bRecalcWidth = true;}
00206     bool                isFirstRunOnLine(void) const;
00207     bool                isLastRunOnLine(void) const;
00208     bool                isOnlyRunOnLine(void) const;
00209     bool                isFirstVisRunOnLine(void) const;
00210     bool                isLastVisRunOnLine(void) const;
00211     void                markDrawBufferDirty()
00212                             {m_eRefreshDrawBuffer = GRSR_Unknown;}
00213     void                orDrawBufferDirty(GRShapingResult eR)
00214                         {
00215                             m_eRefreshDrawBuffer = (GRShapingResult)((UT_uint32)m_eRefreshDrawBuffer
00216                                                                      |(UT_uint32)eR);
00217 }
00218     bool                isPrinting(void) const
00219     { return m_bPrinting;}
00220     virtual void        draw(dg_DrawArgs*);
00221     virtual void        clearScreen(void);
00222     void                Run_ClearScreen(bool bFullLineHeightRect = false);
00223     virtual void        setWidth(UT_sint32 /*iW*/) {}
00224     virtual void        setHeight(UT_sint32 /*iH*/) {}
00225     virtual bool        isVBreakable(void) {return false;}
00226     virtual bool        isHBreakable(void) {return false;}
00227     virtual UT_sint32   wantVBreakAt(UT_sint32 i) {return i;}
00228     virtual UT_sint32   wantHBreakAt(UT_sint32 i) {return i;}
00229     virtual fp_ContainerObject * VBreakAt(UT_sint32) { return NULL;}
00230     virtual fp_ContainerObject * HBreakAt(UT_sint32) { return NULL;}
00231 
00232     void                markAsDirty(void);
00233     void                setCleared(void);
00234     bool                isDirty(void) const { return m_bDirty; }
00235     bool                canContainPoint(void) const;
00236     bool                recalcWidth(void);
00237     virtual void        updateOnDelete(UT_uint32 offset, UT_uint32 iLen);
00238     virtual void        updateVerticalMetric();
00239 
00240     virtual UT_Rect *   getScreenRect();
00241     virtual void        markDirtyOverlappingRuns(UT_Rect & recScreen);
00242 
00243     virtual void        _draw(dg_DrawArgs*) = 0;
00244     void                _drawTextLine(UT_sint32, UT_sint32, UT_uint32, UT_uint32, UT_UCSChar *);
00245     virtual void        _clearScreen(bool bFullLineHeightRect) = 0;
00246     virtual bool        canBreakAfter(void) const = 0;
00247     virtual bool        canBreakBefore(void) const = 0;
00248     bool                letPointPass(void) const;
00249     virtual bool        isForcedBreak(void) const { return false; }
00250     virtual bool        alwaysFits(void) const { return false; }
00251     virtual bool        findMaxLeftFitSplitPoint(UT_sint32 iMaxLeftWidth, fp_RunSplitInfo& si,
00252                                                  bool bForce=false);
00253     void                clearPrint(void);
00254     virtual UT_sint32   findTrailingSpaceDistance(void) const { return 0; }
00255     virtual bool        findFirstNonBlankSplitPoint(fp_RunSplitInfo& /*si*/) { return false; }
00256     virtual void        mapXYToPosition(UT_sint32 xPos, UT_sint32 yPos,
00257                                         PT_DocPosition& pos, bool& bBOL, bool& bEOL, bool & isTOC) = 0;
00258     
00259     virtual void        findPointCoords(UT_uint32 iOffset, UT_sint32& x, UT_sint32& y,
00260                                         UT_sint32& x2, UT_sint32& y2, UT_sint32& height,
00261                                         bool& bDirection) = 0;
00262     
00263     void                lookupProperties(GR_Graphics * pG=NULL);
00264     virtual bool        doesContainNonBlankData(void) const { return true; }    // Things like text whould return false if it is all spaces.
00265     void                drawDecors(UT_sint32 xoff, UT_sint32 yoff, GR_Graphics * pG);
00266     virtual bool        isSuperscript(void) const { return false; }
00267     virtual bool        isSubscript(void) const { return false; }
00268     bool                isUnderline(void) const ;
00269     bool                isOverline(void) const ;
00270     bool                isStrikethrough(void) const ;
00271     bool                isTopline(void) const ;
00272     bool                isBottomline(void) const ;
00273     void                setLinethickness(UT_sint32 max_linethickness);
00274     UT_sint32           getLinethickness(void) ;
00275     void                setUnderlineXoff(UT_sint32 xoff);
00276     UT_sint32           getUnderlineXoff(void);
00277     void                setOverlineXoff(UT_sint32 xoff) ;
00278     UT_sint32           getOverlineXoff(void) ;
00279     void                setMaxUnderline(UT_sint32 xoff) ;
00280     UT_sint32           getMaxUnderline(void) ;
00281     void                setMinOverline(UT_sint32 xoff) ;
00282     UT_sint32           getMinOverline(void) ;
00283     UT_sint32           getToplineThickness(void);
00284 
00285     virtual UT_BidiCharType getDirection() const { return m_iDirection; };
00286     UT_BidiCharType     getVisDirection();
00287     virtual void        setDirection(UT_BidiCharType iDirection = UT_BIDI_WS);
00288     void                setVisDirection(UT_BidiCharType iDir);
00289     UT_uint32           getVisPosition(UT_uint32 ilogPos);
00290     UT_uint32           getVisPosition(UT_uint32 iLogPos, UT_uint32 iLen);
00291     UT_uint32           getOffsetFirstVis();
00292     UT_uint32           getOffsetLog(UT_uint32 iVisOff);
00293     fp_Run *            getNextVisual();
00294     fp_Run *            getPrevVisual();
00295     UT_sint32           getAuthorNum(void) const
00296     { return m_iAuthorColor;};
00297     void                setAuthorNum(UT_sint32 i)
00298     { m_iAuthorColor=i;};
00299 
00300     virtual UT_uint32   adjustCaretPosition(UT_uint32 iDocumentPosition, bool /*bForward*/)
00301                                { return iDocumentPosition;}
00302 
00303     virtual void        adjustDeletePosition(UT_uint32 & /*pos1*/, 
00304                                              UT_uint32 & /*count*/) {}
00305 
00306     bool                containsRevisions(){return (m_pRevisions != NULL);}
00307     // would prefer to make the return value const, but the
00308     // getLastRevision() and related functions use internal cache so
00309     // they could not be called
00310     PP_RevisionAttr *   getRevisions() const {return m_pRevisions;}
00311     FPVisibility        getVisibility() const {return m_eVisibility;}
00312     bool         isHidden() const {return _wouldBeHidden(m_eVisibility);}
00313     void                setVisibility(FPVisibility eVis);
00314     void                Fill(GR_Graphics * pG, UT_sint32 x, UT_sint32 y,
00315                              UT_sint32 width, UT_sint32 height);
00316     
00317     fg_FillType *       getFillType(void);            
00318     fp_Line *           getTmpLine(void) const
00319     { return m_pTmpLine;}
00320     void                setTmpLine(fp_Line * pLine)
00321     { m_pTmpLine = pLine;}
00322     UT_sint32           getTmpX(void) const
00323     { return m_iTmpX;}
00324     void                setTmpX(UT_sint32 iX)
00325     { m_iTmpX = iX;}
00326     UT_sint32           getTmpY(void) const
00327     { return m_iTmpY;}
00328     void                setTmpY(UT_sint32 iY)
00329     { m_iTmpY = iY;}
00330     UT_sint32           getTmpWidth(void) const
00331     { return m_iTmpWidth;}
00332     void                setTmpWidth(UT_sint32 iWidth)
00333     { m_iTmpWidth = iWidth;}
00334     bool                clearIfNeeded(void);
00335 
00336     // Indicates that if insertion point is placed at a position belonging to the run
00337     // and delete command is issued, it should apply to the following run (or previous
00338     // in case of backspace). This is used with invisible runs, such as hyperlinks,
00339     // bookmarks, and hidden hidden text, to ensure that these are not deleted behind
00340     // the users backs.
00341     bool        deleteFollowingIfAtInsPoint() const;
00342 
00343     bool        displayAnnotations(void);
00344     // Methods for selection drawing
00345     void                 setSelectionMode(PT_DocPosition posLow, PT_DocPosition posHigh);
00346     void                 clearSelectionMode(void);
00347     bool                 isSelectionDraw(void) const;
00348     PT_DocPosition       posSelLow(void) const;
00349     PT_DocPosition       posSelHigh(void) const;
00350     UT_RGBColor         _getColorFG(void) const { return m_pColorFG; }
00351 
00352 #ifdef FMT_TEST
00353     virtual void        __dump(FILE * fp) const;
00354 #endif
00355     void               setMustClearScreen(void)
00356     { m_bMustClearScreen = true;}
00357     bool               getMustClearScreen(void)
00358     {return m_bMustClearScreen;}
00359 
00360 protected:
00361     virtual bool        _deleteFollowingIfAtInsPoint() const;
00362     void                _inheritProperties(void);
00363     fp_Run*             _findPrevPropertyRun(void) const;
00364 
00365     FV_View*            _getView(void) const { return getBlock()->getView(); }
00366     // By convention, _getFoo and _setFoo have no side effects.
00367     // They can easily be inlined by a smart compiler.
00368     UT_RGBColor         _getColorPG(void) const { return m_pColorPG; }
00369     UT_RGBColor         _getColorHL(void) const { return m_pColorHL; }
00370     void                _setColorFG(UT_RGBColor c) { m_pColorFG = c; }
00371     void                _setColorHL(UT_RGBColor c) { m_pColorHL = c; }
00372     void                _setColorHL(const char *pszColor)
00373         { m_pColorHL.setColor(pszColor); }
00374     
00375     void                _setLine(fp_Line* pLine) { m_pLine = pLine; }
00376     void                _setHeight(UT_sint32 iHeight)
00377                             { m_iHeight = iHeight;}
00378     virtual void        _setWidth(UT_sint32 iWidth)
00379                             { m_iWidth = iWidth; }
00380 
00381     // use these with great care -- most of the time we need to use
00382     // getWidth() and getHeight() which deal with
00383     // visibility/hiddenness issues
00384     UT_sint32           _getWidth() {return m_iWidth;}
00385     UT_sint32           _getHeight(){return m_iHeight;}
00386     
00387     void                _setBlock(fl_BlockLayout * pBL) { m_pBL = pBL; }
00388     void                _setAscent(int iAscent) { m_iAscent = iAscent; }
00389     void                _setDescent(int iDescent) {m_iDescent = iDescent;}
00390     void                _setX(int iX) { m_iX = iX; }
00391     void                _setY(int iY) { m_iY = iY; }
00392     void                _setDirection(UT_BidiCharType c) { m_iDirection = c; }
00393     UT_BidiCharType     _getDirection(void) const { return m_iDirection; }
00394     UT_BidiCharType     _getVisDirection(void) const { return m_iVisDirection; }
00395     const GR_Font *         _getFont(void) const;
00396     void                _setFont(const GR_Font * f);
00397     unsigned char       _getDecorations(void) const { return m_fDecorations; }
00398     void                _setDecorations(unsigned char d) {m_fDecorations = d;}
00399     
00400     void                _orDecorations(unsigned char d) { m_fDecorations |= d; }
00401     UT_sint32           _getLineWidth(void) { return m_iLineWidth; }
00402     bool                _setLineWidth(UT_sint32 w)
00403                              {
00404                                  UT_sint32 o = m_iLineWidth;
00405                                  m_iLineWidth = w;
00406                                  return o != w;
00407                              }
00408     void                _setLength(UT_uint32 l) { m_iLen = l; }
00409     void                _setRevisions(PP_RevisionAttr * p) { m_pRevisions = p; }
00410     void                _setDirty(bool b);
00411     void                _setField(fd_Field * fd) { m_pField = fd; }
00412     void                _setHyperlink(fp_HyperlinkRun * pH) { m_pHyperlink = pH; }
00413     bool                _getRecalcWidth(void) const { return m_bRecalcWidth; }
00414     void                _setRecalcWidth(bool b) { m_bRecalcWidth = b; }
00415 
00416     GRShapingResult     _getRefreshDrawBuffer(void) const { return m_eRefreshDrawBuffer; }
00417     void                _setRefreshDrawBuffer(GRShapingResult eR)
00418                              { m_eRefreshDrawBuffer = eR; }
00419     virtual void        _lookupProperties(const PP_AttrProp * pSpanAP,
00420                                           const PP_AttrProp * pBlockAP,
00421                                           const PP_AttrProp * pSectionAP, 
00422                                           GR_Graphics * pG = NULL) = 0;
00423 
00424     virtual bool        _canContainPoint(void) const;
00425     virtual bool        _letPointPass(void) const;
00426     virtual bool        _recalcWidth(void);
00427     bool         _wouldBeHidden(FPVisibility eVis) const;
00428 //
00429 // Variables to draw underlines for all runs
00430 //
00431     enum
00432     {
00433         TEXT_DECOR_UNDERLINE =      0x01,
00434         TEXT_DECOR_OVERLINE =       0x02,
00435         TEXT_DECOR_LINETHROUGH =    0x04,
00436         TEXT_DECOR_TOPLINE =        0x08,
00437         TEXT_DECOR_BOTTOMLINE =     0x10
00438     };
00439 
00440 private:
00441     fp_Run(const fp_Run&);          // no impl.
00442     void operator=(const fp_Run&);  // no impl.
00443 
00444     FP_RUN_TYPE             m_iType;
00445     fp_Line*                m_pLine;
00446     fl_BlockLayout*         m_pBL;
00447     fp_Run*                 m_pNext;
00448     fp_Run*                 m_pPrev;
00449     UT_sint32               m_iX;
00450     UT_sint32               m_iOldX;
00451     UT_sint32               m_iY;
00452     UT_sint32               m_iWidth;
00453     UT_sint32               m_iHeight;
00454     UT_uint32               m_iAscent;
00455     UT_uint32               m_iDescent;
00456 
00457     UT_uint32               m_iOffsetFirst;
00458     UT_uint32               m_iLen;
00459     bool                    m_bDirty;       // run erased @ old coords, needs to be redrawn
00460     fd_Field*               m_pField;
00461     UT_BidiCharType         m_iDirection;   //#TF direction of the run 0 for left-to-right, 1 for right-to-left
00462     UT_BidiCharType         m_iVisDirection;
00463     GRShapingResult         m_eRefreshDrawBuffer;
00464 
00465     // the run highlight color. If the property is transparent use the page color
00466     UT_RGBColor             m_pColorHL;
00467 
00468     const GR_Font *         m_pFont;
00469 
00470     bool                    m_bRecalcWidth;
00471 
00472     unsigned char           m_fDecorations;
00473     UT_sint32               m_iLineWidth;
00474     UT_sint32               m_iLinethickness;
00475     UT_sint32               m_iUnderlineXoff;
00476     UT_sint32               m_imaxUnderline;
00477     UT_sint32               m_iminOverline;
00478     UT_sint32               m_iOverlineXoff;
00479     fp_HyperlinkRun *       m_pHyperlink;
00480     PP_RevisionAttr *       m_pRevisions;
00481 
00482     // A local cache of the page color. This makes clearscreen() a bit faster
00483     UT_RGBColor             m_pColorPG;
00484     UT_RGBColor             m_pColorFG;
00485     FPVisibility            m_eVisibility;
00486     bool                    m_bIsCleared;
00487     fg_FillType             m_FillType;
00488     bool                    m_bPrinting;
00489     UT_sint32               m_iTmpX;
00490     UT_sint32               m_iTmpY;
00491     UT_sint32               m_iTmpWidth;
00492     fp_Line *               m_pTmpLine;
00493 
00494     // Variables for selection drawing
00495     bool                    m_bDrawSelection;
00496     PT_DocPosition          m_iSelLow;
00497     PT_DocPosition          m_iSelHigh;
00498     bool                    m_bMustClearScreen;
00499     UT_sint32               m_iAuthorColor;
00500 #ifdef DEBUG
00501     UT_uint32               m_iFontAllocNo;
00502 #endif
00503 };
00504 
00505 class ABI_EXPORT fp_TabRun : public fp_Run
00506 {
00507 public:
00508     fp_TabRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
00509     virtual void            mapXYToPosition(UT_sint32 xPos, UT_sint32 yPos, PT_DocPosition& pos, bool& bBOL, bool& bEOL, bool & isTOC);
00510     virtual void            findPointCoords(UT_uint32 iOffset, UT_sint32& x, UT_sint32& y, UT_sint32& x2, UT_sint32& y2, UT_sint32& height, bool& bDirection);
00511     virtual bool            canBreakAfter(void) const;
00512     virtual bool            canBreakBefore(void) const;
00513     virtual bool            hasLayoutProperties(void) const;
00514     void                    setTabWidth(UT_sint32);
00515     void                    setLeader(eTabLeader iTabType);
00516     eTabLeader              getLeader(void);
00517     void                    setTabType(eTabType iTabType);
00518     eTabType                getTabType(void) const;
00519     bool                    isTOCTab(void);
00520     void                    setTOCTab(void)
00521     { m_bIsTOC = true;}
00522     void                    setTOCTabListLabel(void);
00523     bool                    isTOCTabListLabel(void) const
00524     { return m_bIsTOCListLabel;}
00525 
00526 protected:
00527     virtual void            _drawArrow(UT_uint32 iLeft,UT_uint32 iTop,UT_uint32 iWidth, UT_uint32 iHeight);
00528     virtual void            _draw(dg_DrawArgs*);
00529     virtual void            _clearScreen(bool bFullLineHeightRect);
00530     virtual void            _lookupProperties(const PP_AttrProp * pSpanAP,
00531                                               const PP_AttrProp * pBlockAP,
00532                                               const PP_AttrProp * pSectionAP,
00533                                               GR_Graphics * pG = NULL);
00534 
00535     virtual bool            _letPointPass(void) const;
00536 
00537 private:
00538     //UT_RGBColor               m_colorFG;
00539 private:
00540     eTabLeader              m_leader;
00541     eTabType                m_TabType;
00542     bool                    m_bIsTOC;
00543     bool                    m_bIsTOCListLabel;
00544 };
00545 
00546 class ABI_EXPORT fp_ForcedLineBreakRun : public fp_Run
00547 {
00548 public:
00549     fp_ForcedLineBreakRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
00550     virtual void            mapXYToPosition(UT_sint32 xPos, UT_sint32 yPos, PT_DocPosition& pos, bool& bBOL, bool& bEOL, bool & isTOC);
00551     virtual void            findPointCoords(UT_uint32 iOffset, UT_sint32& x, UT_sint32& y, UT_sint32& x2, UT_sint32& y2, UT_sint32& height, bool& bDirection);
00552     virtual bool            canBreakAfter(void) const;
00553     virtual bool            canBreakBefore(void) const;
00554     virtual bool            isForcedBreak(void) const { return true; }
00555 protected:
00556     virtual void            _lookupProperties(const PP_AttrProp * pSpanAP,
00557                                               const PP_AttrProp * pBlockAP,
00558                                               const PP_AttrProp * pSectionAP,
00559                                               GR_Graphics * pG = NULL);
00560 
00561     virtual void            _draw(dg_DrawArgs*);
00562     virtual void            _clearScreen(bool bFullLineHeightRect);
00563     virtual bool            _letPointPass(void) const;
00564 };
00565 
00566 class ABI_EXPORT fp_FieldStartRun : public fp_Run
00567 {
00568 public:
00569     fp_FieldStartRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
00570     virtual void            mapXYToPosition(UT_sint32 xPos, UT_sint32 yPos, PT_DocPosition& pos, bool& bBOL, bool& bEOL, bool & isTOC);
00571     virtual void            findPointCoords(UT_uint32 iOffset, UT_sint32& x, UT_sint32& y, UT_sint32& x2, UT_sint32& y2, UT_sint32& height, bool& bDirection);
00572     virtual bool            canBreakAfter(void) const;
00573     virtual bool            canBreakBefore(void) const;
00574     virtual bool            isForcedBreak(void) const { return true; }
00575 protected:
00576     virtual void            _lookupProperties(const PP_AttrProp * pSpanAP,
00577                                               const PP_AttrProp * pBlockAP,
00578                                               const PP_AttrProp * pSectionAP,
00579                                               GR_Graphics * pG = NULL);
00580 
00581     virtual void            _draw(dg_DrawArgs*);
00582     virtual void            _clearScreen(bool bFullLineHeightRect);
00583     virtual bool            _letPointPass(void) const;
00584 };
00585 
00586 class ABI_EXPORT fp_FieldEndRun : public fp_Run
00587 {
00588 public:
00589     fp_FieldEndRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
00590     virtual void            mapXYToPosition(UT_sint32 xPos, UT_sint32 yPos, PT_DocPosition& pos, bool& bBOL, bool& bEOL, bool & isTOC);
00591     virtual void            findPointCoords(UT_uint32 iOffset, UT_sint32& x, UT_sint32& y, UT_sint32& x2, UT_sint32& y2, UT_sint32& height, bool& bDirection);
00592     virtual bool            canBreakAfter(void) const;
00593     virtual bool            canBreakBefore(void) const;
00594     virtual bool            isForcedBreak(void) const { return true; }
00595 protected:
00596     virtual void            _lookupProperties(const PP_AttrProp * pSpanAP,
00597                                               const PP_AttrProp * pBlockAP,
00598                                               const PP_AttrProp * pSectionAP,
00599                                               GR_Graphics * pG = NULL);
00600 
00601     virtual void            _draw(dg_DrawArgs*);
00602     virtual void            _clearScreen(bool bFullLineHeightRect);
00603     virtual bool            _letPointPass(void) const;
00604 };
00605 
00606 class ABI_EXPORT fp_ForcedColumnBreakRun : public fp_Run
00607 {
00608 public:
00609     fp_ForcedColumnBreakRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
00610 
00611     virtual void            mapXYToPosition(UT_sint32 xPos, UT_sint32 yPos, PT_DocPosition& pos, bool& bBOL, bool& bEOL, bool & isTOC);
00612     virtual void            findPointCoords(UT_uint32 iOffset, UT_sint32& x, UT_sint32& y, UT_sint32& x2, UT_sint32& y2, UT_sint32& height, bool& bDirection);
00613     virtual bool            canBreakAfter(void) const;
00614     virtual bool            canBreakBefore(void) const;
00615     virtual bool            isForcedBreak(void) const { return true; }
00616 protected:
00617     virtual void            _lookupProperties(const PP_AttrProp * pSpanAP,
00618                                               const PP_AttrProp * pBlockAP,
00619                                               const PP_AttrProp * pSectionAP,
00620                                               GR_Graphics * pG = NULL);
00621 
00622     virtual void            _draw(dg_DrawArgs*);
00623     virtual void            _clearScreen(bool bFullLineHeightRect);
00624     virtual bool            _letPointPass(void) const;
00625 };
00626 
00627 class ABI_EXPORT fp_ForcedPageBreakRun : public fp_Run
00628 {
00629 public:
00630     fp_ForcedPageBreakRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
00631     virtual void            mapXYToPosition(UT_sint32 xPos, UT_sint32 yPos, PT_DocPosition& pos, bool& bBOL, bool& bEOL, bool & isTOC);
00632     virtual void            findPointCoords(UT_uint32 iOffset, UT_sint32& x, UT_sint32& y, UT_sint32& x2, UT_sint32& y2, UT_sint32& height, bool& bDirection);
00633     virtual bool            canBreakAfter(void) const;
00634     virtual bool            canBreakBefore(void) const;
00635     virtual bool            isForcedBreak(void) const { return true; }
00636 
00637 protected:
00638     virtual void            _lookupProperties(const PP_AttrProp * pSpanAP,
00639                                               const PP_AttrProp * pBlockAP,
00640                                               const PP_AttrProp * pSectionAP,
00641                                               GR_Graphics * pG = NULL);
00642 
00643     virtual void            _draw(dg_DrawArgs*);
00644     virtual void            _clearScreen(bool bFullLineHeightRect);
00645     virtual bool            _letPointPass(void) const;
00646 };
00647 
00648 class ABI_EXPORT fp_EndOfParagraphRun : public fp_Run
00649 {
00650 public:
00651     fp_EndOfParagraphRun(fl_BlockLayout* pBL,  UT_uint32 iOffsetFirst, UT_uint32 iLen);
00652 
00653     virtual void            mapXYToPosition(UT_sint32 xPos, UT_sint32 yPos, PT_DocPosition& pos, bool& bBOL, bool& bEOL, bool &isToc);
00654     virtual void            findPointCoords(UT_uint32 iOffset, UT_sint32& x, UT_sint32& y, UT_sint32& x2, UT_sint32& y2, UT_sint32& height, bool& bDirection);
00655     virtual bool            canBreakAfter(void) const;
00656     virtual bool            canBreakBefore(void) const;
00657     virtual UT_sint32       getDrawingWidth() const { return static_cast<UT_sint32>(m_iDrawWidth);}
00658 
00659 //
00660 // Tomas this breaks line breaking....
00661 //  virtual bool            doesContainNonBlankData(void) const { return false; }   // Things like text whould return false if it is all spaces.
00662 
00663 protected:
00664     virtual void            _lookupProperties(const PP_AttrProp * pSpanAP,
00665                                               const PP_AttrProp * pBlockAP,
00666                                               const PP_AttrProp * pSectionAP,
00667                                               GR_Graphics * pG = NULL);
00668 
00669     virtual void            _draw(dg_DrawArgs*);
00670     virtual void            _clearScreen(bool bFullLineHeightRect);
00671     virtual bool            _letPointPass(void) const;
00672     virtual bool            _recalcWidth(void);
00673 
00674 private:
00675     UT_uint32               m_iXoffText;
00676     UT_uint32               m_iYoffText;
00677     UT_uint32               m_iDrawWidth;
00678 
00679 };
00680 
00681 class ABI_EXPORT fp_BookmarkRun : public fp_Run
00682 {
00683 public:
00684     fp_BookmarkRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
00685 
00686     bool                isStartOfBookmark() const {return m_bIsStart;};
00687     const gchar *   getName() const {return m_pName;};
00688     bool                isComrade(fp_BookmarkRun *pBR) const;
00689 
00690     virtual bool canBreakAfter(void) const;
00691     virtual bool canBreakBefore(void) const;
00692 
00693     virtual void mapXYToPosition(UT_sint32 x,
00694                                  UT_sint32 y,
00695                                  PT_DocPosition& pos,
00696                                  bool& bBOL,
00697                                  bool& bEOL,
00698                                  bool & isTOC);
00699 
00700     virtual void findPointCoords(UT_uint32 iOffset,
00701                                  UT_sint32& x,
00702                                  UT_sint32& y,
00703                                  UT_sint32& x2,
00704                                  UT_sint32& y2,
00705                                  UT_sint32& height,
00706                                  bool& bDirection);
00707     virtual bool hasLayoutProperties(void) const
00708     { return false; }
00709 
00710     // for the purposes of linebreaking, just whitespace
00711     virtual bool doesContainNonBlankData(void) const { return false; }
00712 
00713     UT_uint32 getBookmarkedDocPosition(bool bAfter) const;
00714     
00715     
00716 private:
00717     virtual void            _lookupProperties(const PP_AttrProp * pSpanAP,
00718                                               const PP_AttrProp * pBlockAP,
00719                                               const PP_AttrProp * pSectionAP,
00720                                               GR_Graphics * pG = NULL);
00721 
00722     virtual void _clearScreen(bool /* bFullLineHeightRect */);
00723     virtual void _draw(dg_DrawArgs* /*pDA */);
00724     virtual bool _letPointPass(void) const;
00725     virtual bool _canContainPoint(void) const;
00726     virtual bool _deleteFollowingIfAtInsPoint() const;
00727 
00728     bool m_bIsStart;
00729     #define BOOKMARK_NAME_SIZE 30
00730     gchar       m_pName[BOOKMARK_NAME_SIZE + 1];
00731     po_Bookmark     * m_pBookmark;
00732 };
00733 
00734 class ABI_EXPORT fp_HyperlinkRun : public fp_Run
00735 {
00736 public:
00737     fp_HyperlinkRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
00738     virtual ~fp_HyperlinkRun();
00739     virtual FP_HYPERLINK_TYPE    getHyperlinkType(void)
00740     { return HYPERLINK_NORMAL;}
00741 
00742     bool                isStartOfHyperlink() const {return m_bIsStart;};
00743     const gchar *   getTarget() const {return static_cast<const gchar *>(m_pTarget);};
00744 
00745     virtual bool canBreakAfter(void) const;
00746     virtual bool canBreakBefore(void) const;
00747 
00748     virtual void mapXYToPosition(UT_sint32 x,
00749                                  UT_sint32 y,
00750                                  PT_DocPosition& pos,
00751                                  bool& bBOL,
00752                                  bool& bEOL,
00753                                  bool &isTOC);
00754 
00755     virtual void findPointCoords(UT_uint32 iOffset,
00756                                  UT_sint32& x,
00757                                  UT_sint32& y,
00758                                  UT_sint32& x2,
00759                                  UT_sint32& y2,
00760                                  UT_sint32& height,
00761                                  bool& bDirection);
00762 
00763     virtual bool hasLayoutProperties(void) const
00764     { return false; }
00765 
00766     // for the purposes of linebreaking, just whitespace
00767     virtual bool doesContainNonBlankData(void) const { return false; }
00768     
00769 protected:
00770     virtual void            _lookupProperties(const PP_AttrProp * pSpanAP,
00771                                               const PP_AttrProp * pBlockAP,
00772                                               const PP_AttrProp * pSectionAP,
00773                                               GR_Graphics * pG = NULL);
00774 
00775     virtual void _clearScreen(bool /* bFullLineHeightRect */);
00776     virtual void _draw(dg_DrawArgs* /*pDA */);
00777     virtual bool _letPointPass(void) const;
00778     virtual bool _canContainPoint(void) const;
00779     virtual bool _deleteFollowingIfAtInsPoint() const;
00780     
00781     bool m_bIsStart;
00782     gchar *     m_pTarget;
00783 };
00784 
00785 
00786 
00787 class ABI_EXPORT fp_AnnotationRun : public fp_HyperlinkRun
00788 {
00789 public:
00790     fp_AnnotationRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
00791     virtual ~fp_AnnotationRun();
00792     virtual FP_HYPERLINK_TYPE    getHyperlinkType(void)
00793     {
00794         return HYPERLINK_ANNOTATION;
00795     }
00796     UT_uint32 getPID(void) { return m_iPID;}
00797     const char * getValue(void);
00798     void         recalcValue(void);
00799     virtual bool canBreakAfter(void) const;
00800     virtual bool canBreakBefore(void) const;
00801     UT_sint32    getRealWidth(void) const {return m_iRealWidth;}
00802     void         cleanDraw(dg_DrawArgs*);
00803     UT_sint32    calcWidth(void);
00804 
00805  protected:
00806     virtual void            _draw(dg_DrawArgs*);
00807     virtual void            _clearScreen(bool bFullLineHeightRect);
00808     virtual bool            _recalcWidth(void);
00809     bool                    _setValue(void);
00810     virtual void            _setWidth(UT_sint32 iWidth);
00811     virtual bool _letPointPass(void) const;
00812     virtual bool _canContainPoint(void) const;
00813     virtual void _lookupProperties(const PP_AttrProp * pSpanAP,
00814                                     const PP_AttrProp * pBlockAP,
00815                                     const PP_AttrProp * pSectionAP,
00816                                    GR_Graphics * pG);
00817  private:
00818     UT_uint32               m_iPID;
00819     UT_UTF8String           m_sValue;
00820     UT_sint32               m_iRealWidth;
00821 };
00822 
00823 class ABI_EXPORT fp_ImageRun : public fp_Run
00824 {
00825 public:
00826     fp_ImageRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen, FG_Graphic * pGraphic,  PL_ObjectHandle oh);
00827     virtual ~fp_ImageRun();
00828 
00829     virtual void            mapXYToPosition(UT_sint32 xPos, UT_sint32 yPos, PT_DocPosition& pos, bool& bBOL, bool& bEOL, bool & isTOC);
00830     virtual void            findPointCoords(UT_uint32 iOffset, UT_sint32& x, UT_sint32& y, UT_sint32& x2, UT_sint32& y2, UT_sint32& height, bool& bDirection);
00831     virtual bool            canBreakAfter(void) const;
00832     virtual bool            canBreakBefore(void) const;
00833     const char *            getDataId(void) const;
00834     virtual bool            hasLayoutProperties(void) const;
00835     virtual GR_Image *              getImage();
00836     void                     regenerateImage(GR_Graphics * pG);
00837     UT_sint32               getPointHeight(void)
00838     { return m_iPointHeight;}
00839 protected:
00840     virtual void            _lookupProperties(const PP_AttrProp * pSpanAP,
00841                                               const PP_AttrProp * pBlockAP,
00842                                               const PP_AttrProp * pSectionAP,
00843                                               GR_Graphics * pG = NULL);
00844 
00845     virtual void            _draw(dg_DrawArgs*);
00846     virtual void            _clearScreen(bool bFullLineHeightRect);
00847     virtual bool            _letPointPass(void) const;
00848 
00849 private:
00850     FG_Graphic *             m_pFGraphic;
00851     GR_Image*               m_pImage;
00852     UT_sint32               m_iImageWidth;
00853     UT_sint32               m_iImageHeight;
00854     UT_String               m_sCachedWidthProp;
00855     UT_String               m_sCachedHeightProp;
00856     UT_sint32               m_iPointHeight;
00857     const PP_AttrProp *     m_pSpanAP;
00858     UT_uint32               m_iGraphicTick;
00859     bool                    m_bImageForPrinter;
00860     PL_ObjectHandle         m_OH;
00861 };
00862 
00863 #define FPFIELD_MAX_LENGTH  127
00864 
00865 #define  _FIELD(type,desc,tag)  /*nothing*/
00866 #define  _FIELDTYPE(type,desc)  FPFIELDTYPE_##type,
00867 
00868 enum fp_FieldTypesEnum { FPFIELDTYPE_START,
00869 
00870 #include "fp_Fields.h"
00871 
00872                          FPFIELDTYPE_END };
00873 
00874 #undef  _FIELD
00875 #undef  _FIELDTYPE
00876 
00877 #define  _FIELD(type,desc,tag)  FPFIELD_##tag,
00878 #define  _FIELDTYPE(type,desc)  /*nothing*/
00879 
00880 enum fp_FieldsEnum { FPFIELD_start,
00881 
00882 #include "fp_Fields.h"
00883 
00884                      FPFIELD_end };
00885 
00886 #undef  _FIELD
00887 #undef  _FIELDTYPE
00888 
00889 
00890 struct fp_FieldTypeData
00891 {
00892     fp_FieldTypesEnum   m_Type;
00893     const char*         m_Desc;
00894     XAP_String_Id       m_DescId;
00895 };
00896 
00897 struct fp_FieldData
00898 {
00899     fp_FieldTypesEnum   m_Type;
00900     fp_FieldsEnum       m_Num;
00901     const char*         m_Desc;
00902     const char*         m_Tag;
00903     XAP_String_Id       m_DescId;
00904 };
00905 
00906 
00907 extern fp_FieldTypeData fp_FieldTypes[];
00908 extern fp_FieldData fp_FieldFmts[];
00909 
00910 // these constants define how frequently our fields get updated
00911 // (in 1/2 seconds)
00912 // you know, we should be able to not have to scan for endnote changes;
00913 // they should be told to us.
00914 #define FIELD_UPDATE_ENDNOTE       3
00915 #define FIELD_UPDATE_TIME          1
00916 #define FIELD_UPDATE_DATE        240
00917 #define FIELD_UPDATE_PAGE         20
00918 #define FIELD_UPDATE_LINE_COUNT   10
00919 #define FIELD_UPDATE_WORD_COUNT    4
00920 #define FIELD_UPDATE_PARA_COUNT   20
00921 #define FIELD_UPDATE_META         10
00922 #define FIELD_UPDATE_MAILMERGE    10
00923 
00924 class ABI_EXPORT fp_FieldRun : public fp_Run
00925 {
00926 public:
00927     fp_FieldRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
00928     virtual ~fp_FieldRun();
00929 
00930     virtual void            mapXYToPosition(UT_sint32 xPos, UT_sint32 yPos, PT_DocPosition& pos, bool& bBOL, bool& bEOL, bool &isTOC);
00931     virtual void            findPointCoords(UT_uint32 iOffset, UT_sint32& x, UT_sint32& y, UT_sint32& x2, UT_sint32& y2, UT_sint32& height, bool& bDirection);
00932     virtual bool            canBreakAfter(void) const;
00933     virtual fp_FieldsEnum   getFieldType(void) const;
00934     virtual bool            canBreakBefore(void) const;
00935     virtual bool            hasLayoutProperties(void) const;
00936 
00937     virtual bool            isSuperscript(void) const;
00938     virtual bool            isSubscript(void) const;
00939 
00940     bool                    _setValue(const UT_UCSChar *p_new_value);
00941 
00942     virtual bool            calculateValue(void);
00943     virtual const UT_UCSChar *    getValue(void) const { return reinterpret_cast<const UT_UCS4Char *>(m_sFieldValue);}
00944     virtual UT_uint32       needsFrequentUpdates() {return 0;}
00945 
00946 protected:
00947     virtual void            _lookupProperties(const PP_AttrProp * pSpanAP,
00948                                               const PP_AttrProp * pBlockAP,
00949                                               const PP_AttrProp * pSectionAP,
00950                                               GR_Graphics * pG = NULL);
00951 
00952     virtual void            _draw(dg_DrawArgs*) {};
00953     virtual void            _defaultDraw(dg_DrawArgs*);
00954     virtual void            _clearScreen(bool bFullLineHeightRect);
00955     const gchar *       _getParameter() const { return m_pParameter; }
00956     virtual bool            _letPointPass(void) const;
00957     virtual bool            _recalcWidth(void);
00958 
00959 private:
00960 
00961     //UT_RGBColor               m_colorFG;
00962     UT_RGBColor             m_colorBG;
00963     UT_UCS4Char             m_sFieldValue[FPFIELD_MAX_LENGTH];
00964     fp_FieldsEnum           m_iFieldType;
00965     const gchar *       m_pParameter;
00966     enum
00967     {
00968         TEXT_POSITION_NORMAL,
00969         TEXT_POSITION_SUPERSCRIPT,
00970         TEXT_POSITION_SUBSCRIPT
00971     };
00972     UT_Byte                 m_fPosition;
00973 };
00974 
00975 
00976 class ABI_EXPORT fp_FieldEndnoteRefRun : public fp_FieldRun
00977 {
00978 public:
00979 
00980     fp_FieldEndnoteRefRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
00981 
00982     virtual ~fp_FieldEndnoteRefRun(){}
00983 
00984     virtual bool            calculateValue(void);
00985     virtual bool            canBreakBefore(void) const;
00986     virtual void            _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); }
00987     virtual UT_uint32       needsFrequentUpdates(){return FIELD_UPDATE_ENDNOTE;};
00988     UT_uint32               getPID() const {return m_iPID;}
00989 
00990 private:
00991     UT_uint32 m_iPID;
00992 };
00993 
00994 
00995 class ABI_EXPORT fp_FieldEndnoteAnchorRun : public fp_FieldRun
00996 {
00997 public:
00998 
00999     fp_FieldEndnoteAnchorRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01000 
01001     virtual ~fp_FieldEndnoteAnchorRun() {}
01002 
01003     virtual bool            calculateValue(void);
01004     virtual void            _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); }
01005     virtual UT_uint32       needsFrequentUpdates(){return FIELD_UPDATE_ENDNOTE;};
01006     UT_uint32               getPID() const {return m_iPID;}
01007 
01008 private:
01009     UT_uint32 m_iPID;
01010 };
01011 
01012 class ABI_EXPORT fp_FieldFootnoteRefRun : public fp_FieldRun
01013 {
01014 public:
01015 
01016     fp_FieldFootnoteRefRun(fl_BlockLayout* pBL,UT_uint32 iOffsetFirst, UT_uint32 iLen);
01017 
01018     virtual ~fp_FieldFootnoteRefRun(){}
01019 
01020     virtual bool            calculateValue(void);
01021     virtual bool            canBreakBefore(void) const;
01022     virtual void            _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); }
01023     virtual UT_uint32       needsFrequentUpdates(){return FIELD_UPDATE_ENDNOTE;};
01024     UT_uint32               getPID() const {return m_iPID;}
01025 
01026 private:
01027     UT_uint32 m_iPID;
01028 };
01029 
01030 class ABI_EXPORT fp_FieldFootnoteAnchorRun : public fp_FieldRun
01031 {
01032 public:
01033 
01034     fp_FieldFootnoteAnchorRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01035 
01036     virtual ~fp_FieldFootnoteAnchorRun() {}
01037 
01038     virtual bool            calculateValue(void);
01039     virtual void            _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); }
01040     virtual UT_uint32       needsFrequentUpdates(){return FIELD_UPDATE_ENDNOTE;};
01041     UT_uint32               getPID() const {return m_iPID;}
01042 
01043 private:
01044     UT_uint32 m_iPID;
01045 };
01046 
01047 class ABI_EXPORT fp_FieldTimeRun : public fp_FieldRun
01048 {
01049 public:
01050 
01051     fp_FieldTimeRun(fl_BlockLayout* pBL,  UT_uint32 iOffsetFirst, UT_uint32 iLen);
01052 
01053     virtual ~fp_FieldTimeRun(){}
01054 
01055     virtual bool            calculateValue(void);
01056     virtual void            _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); }
01057     virtual UT_uint32       needsFrequentUpdates(){return FIELD_UPDATE_TIME;};
01058 };
01059 
01060 class ABI_EXPORT fp_FieldPageNumberRun : public fp_FieldRun
01061 {
01062 public:
01063 
01064     fp_FieldPageNumberRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01065 
01066     virtual ~fp_FieldPageNumberRun() {}
01067 
01068     virtual bool            calculateValue(void);
01069     virtual void            _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); }
01070     virtual UT_uint32       needsFrequentUpdates(){return FIELD_UPDATE_PAGE;};
01071 };
01072 
01073 class ABI_EXPORT fp_FieldPageReferenceRun : public fp_FieldRun
01074 {
01075 public:
01076 
01077     fp_FieldPageReferenceRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01078 
01079     virtual ~fp_FieldPageReferenceRun() {}
01080 
01081     virtual bool            calculateValue(void);
01082     virtual void            _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); }
01083     virtual UT_uint32       needsFrequentUpdates(){return FIELD_UPDATE_PAGE;};
01084 };
01085 
01086 class ABI_EXPORT fp_FieldPageCountRun : public fp_FieldRun
01087 {
01088 public:
01089 
01090     fp_FieldPageCountRun(fl_BlockLayout* pBL,  UT_uint32 iOffsetFirst, UT_uint32 iLen);
01091 
01092     virtual ~fp_FieldPageCountRun() {}
01093 
01094     virtual bool            calculateValue(void);
01095     virtual void            _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); }
01096     virtual UT_uint32       needsFrequentUpdates(){return FIELD_UPDATE_PAGE;};
01097 };
01098 
01099 class ABI_EXPORT fp_FieldDateRun : public fp_FieldRun
01100 {
01101 public:
01102     fp_FieldDateRun(fl_BlockLayout* pBL,  UT_uint32 iOffsetFirst, UT_uint32 iLen);
01103 
01104     virtual ~fp_FieldDateRun() {}
01105 
01106     virtual bool            calculateValue(void);
01107     virtual void            _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); }
01108     virtual UT_uint32       needsFrequentUpdates(){return FIELD_UPDATE_DATE;};
01109 };
01110 
01111 
01112 class ABI_EXPORT fp_FieldFileNameRun : public fp_FieldRun
01113 {
01114 public:
01115     fp_FieldFileNameRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01116 
01117     virtual ~fp_FieldFileNameRun() {}
01118 
01119     virtual bool            calculateValue(void);
01120     virtual void            _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); }
01121 };
01122 
01123 // BEGIN DOM
01124 
01125 // document-related information fields
01126 
01127 // count of characters in the document
01128 // including white spaces
01129 class ABI_EXPORT fp_FieldCharCountRun : public fp_FieldRun
01130 {
01131 public:
01132     fp_FieldCharCountRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01133 
01134     virtual ~fp_FieldCharCountRun() {}
01135 
01136     virtual bool            calculateValue(void);
01137     virtual void            _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); }
01138     virtual UT_uint32       needsFrequentUpdates(){return FIELD_UPDATE_TIME;};
01139 };
01140 
01141 // count of the non-blank characters
01142 // in the document
01143 class ABI_EXPORT fp_FieldNonBlankCharCountRun : public fp_FieldRun
01144 {
01145 public:
01146     fp_FieldNonBlankCharCountRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01147 
01148     virtual ~fp_FieldNonBlankCharCountRun(){}
01149 
01150     virtual bool            calculateValue(void);
01151     virtual void            _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); }
01152     virtual UT_uint32       needsFrequentUpdates(){return FIELD_UPDATE_TIME;};
01153 };
01154 
01155 // count of the #lines in the document
01156 class ABI_EXPORT fp_FieldLineCountRun : public fp_FieldRun
01157 {
01158 public:
01159     fp_FieldLineCountRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01160 
01161     virtual ~fp_FieldLineCountRun(){}
01162 
01163     virtual bool            calculateValue(void);
01164     virtual void            _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); }
01165     virtual UT_uint32       needsFrequentUpdates(){return FIELD_UPDATE_LINE_COUNT;};
01166 };
01167 
01168 
01169 // Sum the contents of the row of a table
01170 class ABI_EXPORT fp_FieldTableSumRows : public fp_FieldRun
01171 {
01172 public:
01173     fp_FieldTableSumRows(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01174 
01175     virtual ~fp_FieldTableSumRows(){}
01176 
01177     virtual bool            calculateValue(void);
01178     virtual void            _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); }
01179     virtual UT_uint32       needsFrequentUpdates(){return FIELD_UPDATE_WORD_COUNT;};
01180 };
01181 
01182 
01183 // Sum the contents of the row of a table
01184 class ABI_EXPORT fp_FieldTableSumCols : public fp_FieldRun
01185 {
01186 public:
01187     fp_FieldTableSumCols(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01188 
01189     virtual ~fp_FieldTableSumCols(){}
01190 
01191     virtual bool            calculateValue(void);
01192     virtual void            _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); }
01193     virtual UT_uint32       needsFrequentUpdates(){return FIELD_UPDATE_WORD_COUNT;};
01194 };
01195 
01196 // count of the #para in the document
01197 class ABI_EXPORT fp_FieldParaCountRun : public fp_FieldRun
01198 {
01199 public:
01200     fp_FieldParaCountRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01201 
01202     virtual ~fp_FieldParaCountRun(){}
01203 
01204     virtual bool            calculateValue(void);
01205     virtual void            _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); }
01206     virtual UT_uint32       needsFrequentUpdates(){return FIELD_UPDATE_PARA_COUNT;};
01207 };
01208 
01209 // count of #words in the document
01210 class ABI_EXPORT fp_FieldWordCountRun : public fp_FieldRun
01211 {
01212 public:
01213     fp_FieldWordCountRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01214 
01215     virtual ~fp_FieldWordCountRun(){}
01216 
01217     virtual bool            calculateValue(void);
01218     virtual void            _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); }
01219     virtual UT_uint32       needsFrequentUpdates(){return FIELD_UPDATE_WORD_COUNT;};
01220 };
01221 
01222 
01223 // date-releated fields
01224 
01225 // Americans - mm/dd/yy
01226 class ABI_EXPORT fp_FieldMMDDYYRun : public fp_FieldRun
01227 {
01228 public:
01229     fp_FieldMMDDYYRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01230 
01231     virtual ~fp_FieldMMDDYYRun(){}
01232 
01233     virtual bool            calculateValue(void);
01234     virtual void            _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); }
01235     virtual UT_uint32       needsFrequentUpdates(){return FIELD_UPDATE_DATE;};
01236 };
01237 
01238 // most of the world - dd/mm/yy
01239 class ABI_EXPORT fp_FieldDDMMYYRun : public fp_FieldRun
01240 {
01241 public:
01242     fp_FieldDDMMYYRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01243 
01244     virtual ~fp_FieldDDMMYYRun(){}
01245 
01246     virtual bool            calculateValue(void);
01247     virtual void            _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); }
01248     virtual UT_uint32       needsFrequentUpdates(){return FIELD_UPDATE_DATE;};
01249 };
01250 
01251 // April 18, 1979
01252 class ABI_EXPORT fp_FieldMonthDayYearRun : public fp_FieldRun
01253 {
01254 public:
01255     fp_FieldMonthDayYearRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01256 
01257     virtual ~fp_FieldMonthDayYearRun(){}
01258 
01259     virtual bool            calculateValue(void);
01260     virtual void            _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); }
01261     virtual UT_uint32       needsFrequentUpdates(){return FIELD_UPDATE_DATE;};
01262 };
01263 
01264 // Apr. 18, 1979
01265 class ABI_EXPORT fp_FieldMthDayYearRun : public fp_FieldRun
01266 {
01267 public:
01268     fp_FieldMthDayYearRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01269 
01270     virtual ~fp_FieldMthDayYearRun (){}
01271 
01272     virtual bool            calculateValue(void);
01273     virtual void            _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); }
01274     virtual UT_uint32       needsFrequentUpdates(){return FIELD_UPDATE_DATE;};
01275 };
01276 
01277 // default representation for your locale. includes time too
01278 class ABI_EXPORT fp_FieldDefaultDateRun : public fp_FieldRun
01279 {
01280 public:
01281     fp_FieldDefaultDateRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01282 
01283     virtual ~fp_FieldDefaultDateRun(){}
01284 
01285     virtual bool            calculateValue(void);
01286     virtual void            _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); }
01287     virtual UT_uint32       needsFrequentUpdates(){return FIELD_UPDATE_TIME;};
01288 };
01289 
01290 // default for your locale, not appending the time
01291 class ABI_EXPORT fp_FieldDefaultDateNoTimeRun : public fp_FieldRun
01292 {
01293 public:
01294     fp_FieldDefaultDateNoTimeRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01295 
01296     virtual ~fp_FieldDefaultDateNoTimeRun(){}
01297 
01298     virtual bool            calculateValue(void);
01299     virtual void            _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); }
01300     virtual UT_uint32       needsFrequentUpdates(){return FIELD_UPDATE_DATE;};
01301 };
01302 
01303 // day of the week (Wednesday)
01304 class ABI_EXPORT fp_FieldWkdayRun : public fp_FieldRun
01305 {
01306 public:
01307     fp_FieldWkdayRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01308 
01309     virtual ~fp_FieldWkdayRun(){}
01310 
01311     virtual bool            calculateValue(void);
01312     virtual void            _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); }
01313     virtual UT_uint32       needsFrequentUpdates(){return FIELD_UPDATE_DATE;};
01314 };
01315 
01316 // day of year (i.e. 72)
01317 class ABI_EXPORT fp_FieldDOYRun : public fp_FieldRun
01318 {
01319 public:
01320     fp_FieldDOYRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01321 
01322     virtual ~fp_FieldDOYRun(){}
01323 
01324     virtual bool            calculateValue(void);
01325     virtual void            _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); }
01326     virtual UT_uint32       needsFrequentUpdates(){return FIELD_UPDATE_DATE;};
01327 };
01328 
01329 // military (zulu) time
01330 class ABI_EXPORT fp_FieldMilTimeRun : public fp_FieldRun
01331 {
01332 public:
01333     fp_FieldMilTimeRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01334 
01335     virtual ~fp_FieldMilTimeRun(){}
01336 
01337     virtual bool            calculateValue(void);
01338     virtual void            _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); }
01339     virtual UT_uint32       needsFrequentUpdates(){return FIELD_UPDATE_TIME;};
01340 };
01341 
01342 // prints am or pm
01343 class ABI_EXPORT fp_FieldAMPMRun : public fp_FieldRun
01344 {
01345 public:
01346     fp_FieldAMPMRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01347 
01348     virtual ~fp_FieldAMPMRun(){}
01349 
01350     virtual bool            calculateValue(void);
01351     virtual void            _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); }
01352     virtual UT_uint32       needsFrequentUpdates(){return FIELD_UPDATE_DATE;};
01353 };
01354 
01355 // milliseconds since the epoch, for you geeks out there :-)
01356 class ABI_EXPORT fp_FieldTimeEpochRun : public fp_FieldRun
01357 {
01358 public:
01359     fp_FieldTimeEpochRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01360 
01361     virtual ~fp_FieldTimeEpochRun(){}
01362 
01363     virtual bool            calculateValue(void);
01364     virtual void            _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); }
01365     virtual UT_uint32       needsFrequentUpdates(){return FIELD_UPDATE_TIME;};
01366 };
01367 
01368 class ABI_EXPORT fp_FieldDateTimeCustomRun : public fp_FieldRun
01369 {
01370 public:
01371     fp_FieldDateTimeCustomRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01372 
01373     virtual ~fp_FieldDateTimeCustomRun(){}
01374 
01375     virtual bool            calculateValue(void);
01376     virtual void            _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); }
01377     virtual UT_uint32       needsFrequentUpdates(){return FIELD_UPDATE_TIME;};
01378 };
01379 
01380 // your time zone (EST, for example)
01381 class ABI_EXPORT fp_FieldTimeZoneRun : public fp_FieldRun
01382 {
01383 public:
01384     fp_FieldTimeZoneRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01385 
01386     virtual ~fp_FieldTimeZoneRun(){}
01387 
01388     virtual bool            calculateValue(void);
01389     virtual void            _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); }
01390 };
01391 
01392 // application runs
01393 
01394 // build id
01395 class ABI_EXPORT fp_FieldBuildIdRun : public fp_FieldRun
01396 {
01397 public:
01398     fp_FieldBuildIdRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01399 
01400     virtual ~fp_FieldBuildIdRun(){}
01401 
01402     virtual bool            calculateValue(void);
01403     virtual void            _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); }
01404 };
01405 
01406 // build version (i.e. 0.7.13)
01407 class ABI_EXPORT fp_FieldBuildVersionRun : public fp_FieldRun
01408 {
01409 public:
01410     fp_FieldBuildVersionRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01411 
01412     virtual ~fp_FieldBuildVersionRun(){}
01413 
01414     virtual bool            calculateValue(void);
01415     virtual void            _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); }
01416 };
01417 
01418 class ABI_EXPORT fp_FieldBuildOptionsRun : public fp_FieldRun
01419 {
01420 public:
01421     fp_FieldBuildOptionsRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01422 
01423     virtual ~fp_FieldBuildOptionsRun(){}
01424 
01425     virtual bool            calculateValue(void);
01426     virtual void            _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); }
01427 };
01428 
01429 class ABI_EXPORT fp_FieldBuildTargetRun : public fp_FieldRun
01430 {
01431 public:
01432     fp_FieldBuildTargetRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01433 
01434     virtual ~fp_FieldBuildTargetRun(){}
01435 
01436     virtual bool            calculateValue(void);
01437     virtual void            _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); }
01438 };
01439 
01440 class ABI_EXPORT fp_FieldBuildCompileDateRun : public fp_FieldRun
01441 {
01442 public:
01443     fp_FieldBuildCompileDateRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01444 
01445     virtual ~fp_FieldBuildCompileDateRun (){}
01446 
01447     virtual bool            calculateValue(void);
01448     virtual void            _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); }
01449 };
01450 
01451 class ABI_EXPORT fp_FieldBuildCompileTimeRun : public fp_FieldRun
01452 {
01453 public:
01454     fp_FieldBuildCompileTimeRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01455 
01456     virtual ~fp_FieldBuildCompileTimeRun(){}
01457 
01458     virtual bool            calculateValue(void);
01459     virtual void            _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); }
01460 };
01461 
01462 class ABI_EXPORT fp_FieldMailMergeRun : public fp_FieldRun
01463 {
01464  public:
01465   fp_FieldMailMergeRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01466 
01467   virtual ~fp_FieldMailMergeRun(){}
01468   
01469   virtual bool          calculateValue(void);
01470   virtual void          _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); }
01471 
01472   virtual UT_uint32     needsFrequentUpdates(){ return FIELD_UPDATE_MAILMERGE; }
01473 };
01474 
01475 class ABI_EXPORT fp_FieldMetaRun : public fp_FieldRun
01476 {
01477  public:
01478   fp_FieldMetaRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen, const char * which);
01479 
01480   virtual ~fp_FieldMetaRun(){}
01481   
01482   virtual bool          calculateValue(void);
01483   virtual void          _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); }
01484 
01485   virtual UT_uint32     needsFrequentUpdates(){ return FIELD_UPDATE_META;}
01486 
01487  private:
01488   UT_String m_which;
01489 };
01490 
01491 class ABI_EXPORT fp_FieldMetaTitleRun : public fp_FieldMetaRun
01492 {
01493  public:
01494   fp_FieldMetaTitleRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01495   virtual ~fp_FieldMetaTitleRun(){}
01496 };
01497 
01498 class ABI_EXPORT fp_FieldMetaCreatorRun : public fp_FieldMetaRun
01499 {
01500  public:
01501   fp_FieldMetaCreatorRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01502   virtual ~fp_FieldMetaCreatorRun(){}
01503 };
01504 
01505 class ABI_EXPORT fp_FieldMetaSubjectRun : public fp_FieldMetaRun
01506 {
01507  public:
01508   fp_FieldMetaSubjectRun(fl_BlockLayout* pBL,  UT_uint32 iOffsetFirst, UT_uint32 iLen);
01509   virtual ~fp_FieldMetaSubjectRun(){}
01510 };
01511 
01512 class ABI_EXPORT fp_FieldMetaPublisherRun : public fp_FieldMetaRun
01513 {
01514  public:
01515   fp_FieldMetaPublisherRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01516   virtual ~fp_FieldMetaPublisherRun(){}
01517 };
01518 
01519 class ABI_EXPORT fp_FieldMetaDateRun : public fp_FieldMetaRun
01520 {
01521  public:
01522   fp_FieldMetaDateRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01523   virtual ~fp_FieldMetaDateRun(){}
01524 };
01525 
01526 class ABI_EXPORT fp_FieldMetaTypeRun : public fp_FieldMetaRun
01527 {
01528  public:
01529   fp_FieldMetaTypeRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01530   virtual ~fp_FieldMetaTypeRun(){}
01531 };
01532 
01533 class ABI_EXPORT fp_FieldMetaLanguageRun : public fp_FieldMetaRun
01534 {
01535  public:
01536   fp_FieldMetaLanguageRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01537   virtual ~fp_FieldMetaLanguageRun(){}
01538 };
01539 
01540 class ABI_EXPORT fp_FieldMetaRightsRun : public fp_FieldMetaRun
01541 {
01542  public:
01543   fp_FieldMetaRightsRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01544   virtual ~fp_FieldMetaRightsRun(){}
01545 };
01546 
01547 class ABI_EXPORT fp_FieldMetaKeywordsRun : public fp_FieldMetaRun
01548 {
01549  public:
01550   fp_FieldMetaKeywordsRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01551   virtual ~fp_FieldMetaKeywordsRun(){}
01552 };
01553 
01554 class ABI_EXPORT fp_FieldMetaContributorRun : public fp_FieldMetaRun
01555 {
01556  public:
01557   fp_FieldMetaContributorRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01558   virtual ~fp_FieldMetaContributorRun(){}
01559 };
01560 
01561 class ABI_EXPORT fp_FieldMetaCoverageRun : public fp_FieldMetaRun
01562 {
01563  public:
01564   fp_FieldMetaCoverageRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01565   virtual ~fp_FieldMetaCoverageRun(){}
01566 };
01567 
01568 class ABI_EXPORT fp_FieldMetaDescriptionRun : public fp_FieldMetaRun
01569 {
01570  public:
01571   fp_FieldMetaDescriptionRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen);
01572   virtual ~fp_FieldMetaDescriptionRun(){}
01573 };
01574 
01575 // END DOM
01576 
01577 class ABI_EXPORT fp_FmtMarkRun : public fp_Run
01578 {
01579 public:
01580     fp_FmtMarkRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst);
01581 
01582     virtual void            mapXYToPosition(UT_sint32 xPos, UT_sint32 yPos, PT_DocPosition& pos, bool& bBOL, bool& bEOL, bool & isTOC);
01583     virtual void            findPointCoords(UT_uint32 iOffset, UT_sint32& x, UT_sint32& y, UT_sint32& x2, UT_sint32& y2, UT_sint32& height, bool& bDirection);
01584     virtual bool            canBreakAfter(void) const;
01585     virtual bool            canBreakBefore(void) const;
01586     virtual bool            isSuperscript(void) const ;
01587     virtual bool            isSubscript(void)  const;
01588     virtual bool            hasLayoutProperties(void) const {return true;}
01589 
01590 protected:
01591     virtual void            _lookupProperties(const PP_AttrProp * pSpanAP,
01592                                               const PP_AttrProp * pBlockAP,
01593                                               const PP_AttrProp * pSectionAP,
01594                                               GR_Graphics * pG = NULL);
01595 
01596     virtual void            _draw(dg_DrawArgs*);
01597     virtual void            _clearScreen(bool bFullLineHeightRect);
01598     virtual bool            _letPointPass(void) const;
01599 
01600 private:
01601     enum
01602     {
01603         TEXT_POSITION_NORMAL,
01604         TEXT_POSITION_SUPERSCRIPT,
01605         TEXT_POSITION_SUBSCRIPT
01606     };
01607     UT_Byte                 m_fPosition;
01608 };
01609 
01610 
01611 class ABI_EXPORT fp_DummyRun : public fp_Run
01612 {
01613 public:
01614     fp_DummyRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst);
01615 
01616     virtual void            mapXYToPosition(UT_sint32 xPos, UT_sint32 yPos, PT_DocPosition& pos, bool& bBOL, bool& bEOL, bool &isTOC);
01617     virtual void            findPointCoords(UT_uint32 iOffset, UT_sint32& x, UT_sint32& y, UT_sint32& x2, UT_sint32& y2, UT_sint32& height, bool& bDirection);
01618     virtual bool            canBreakAfter(void) const;
01619     virtual bool            canBreakBefore(void) const;
01620     virtual bool            isSuperscript(void) const ;
01621     virtual bool            isSubscript(void)  const;
01622     virtual bool            hasLayoutProperties(void) const {return false;}
01623 
01624 protected:
01625     virtual void            _lookupProperties(const PP_AttrProp * pSpanAP,
01626                                               const PP_AttrProp * pBlockAP,
01627                                               const PP_AttrProp * pSectionAP,
01628                                               GR_Graphics * pG = NULL);
01629 
01630     virtual void            _draw(dg_DrawArgs*);
01631     virtual void            _clearScreen(bool bFullLineHeightRect);
01632     virtual bool            _letPointPass(void) const;
01633 };
01634 
01635 #endif /* FP_RUN_H */
01636 
01637 
01638 
01639 
01640 
01641 
01642 
01643 
01644 
01645