AbiWord: fp_Run.h Source File

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