1 /* -*- mode: C++; tab-width: 4; c-basic-offset: 4; -*- */ 2 3 /* AbiWord 4 * Copyright (C) 1998,1999 AbiSource, Inc. 5 * Copyright (c) 2001,2002 Tomas Frydrych 6 * 7 * This program is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU General Public License 9 * as published by the Free Software Foundation; either version 2 10 * of the License, or (at your option) any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 20 * 02110-1301 USA. 21 */ 22 23 24 25 #ifndef FP_RUN_H 26 #define FP_RUN_H 27 28 #ifdef FMT_TEST 29 #include <stdio.h> 30 #endif 31 32 #include "ut_types.h" 33 #include "ut_misc.h" 34 #include "pt_Types.h" 35 #include "ut_assert.h" 36 #include "xap_Strings.h" 37 #include "fl_BlockLayout.h" 38 #include "pp_Revision.h" 39 #include "ut_string_class.h" 40 #include "fp_ContainerObject.h" 41 42 class UT_GrowBuf; 43 class fp_Line; 44 class GR_Graphics; 45 class GR_Font; 46 class GR_Image; 47 class PD_Document; 48 class PP_AttrProp; 49 struct dg_DrawArgs; 50 class fl_CharWidths; 51 class fd_Field; 52 class fp_HyperlinkRun; 53 class fp_AnnotationRun; 54 class fp_RDFAnchorRun; 55 56 struct fp_RunSplitInfo 57 { 58 UT_sint32 iLeftWidth; 59 UT_sint32 iRightWidth; 60 UT_sint32 iOffset; 61 }; 62 63 // TODO The break type is not used. Is it put here looking forward, 64 // TODO or is it left from some earlier experiments? 65 enum FP_RUN_BREAK_TYPE 66 { 67 BREAK_AUTO = 0, 68 BREAK_AVOID = 1, 69 BREAK_ALWAYS = 2 70 }; 71 72 enum FP_RUN_TYPE 73 { 74 FPRUN__FIRST__ = 1, 75 FPRUN_TEXT = 1, 76 FPRUN_IMAGE = 2, 77 FPRUN_TAB = 3, 78 FPRUN_FORCEDLINEBREAK = 4, 79 FPRUN_FORCEDCOLUMNBREAK = 5, 80 FPRUN_FORCEDPAGEBREAK = 6, 81 FPRUN_FIELD = 7, 82 FPRUN_FMTMARK = 8, 83 FPRUN_FIELDSTARTRUN = 9, 84 FPRUN_FIELDENDRUN = 10, 85 FPRUN_ENDOFPARAGRAPH = 11, 86 FPRUN_BOOKMARK = 12, 87 FPRUN_HYPERLINK = 13, 88 FPRUN_DIRECTIONMARKER = 14, 89 FPRUN_DUMMY = 15, 90 FPRUN_MATH = 16, 91 FPRUN_EMBED = 17, 92 FPRUN__LAST__ = 18 93 }; 94 95 enum FP_HYPERLINK_TYPE 96 { 97 HYPERLINK_NORMAL =1, 98 HYPERLINK_ANNOTATION = 2, 99 HYPERLINK_RDFANCHOR = 3 100 }; 101 102 // specifies how setX should handle screen clearing 103 enum FPRUN_CLEAR_SCREEN 104 { 105 FP_CLEARSCREEN_AUTO, 106 FP_CLEARSCREEN_FORCE, 107 FP_CLEARSCREEN_NEVER 108 }; 109 110 111 /* 112 fp_Run represents a contiguous homogenous chunk on a single line. 113 This file also defines the following subclasses: 114 115 fp_TabRun 116 fp_ForcedLineBreakRun 117 fp_ForcedColumnBreakRun 118 fp_ForcedPageBreakRun 119 fp_ImageRun 120 fp_FieldRun 121 fp_FmtMarkRun 122 fp_FieldStartRun 123 fp_FieldEndRun 124 fp_BookmarkRun 125 fp_HyperlinkRun 126 fp_AnnotationRun 127 fp_RDFAnchorRun 128 fp_DummyRun 129 130 As far as the formatter's concerned, each subclass behaves somewhat 131 differently, but they can all be treated like rectangular blocks to 132 be arranged. 133 134 Convention: _setFoo(bar) is just this.foo = bar; 135 setFoo(bar) sets this.foo to bar, 136 but may also do other processing to maintain 137 internal state. 138 */ 139 class ABI_EXPORT fp_Run : fp_ContainerObject 140 { 141 friend class fg_FillType; 142 public: 143 fp_Run(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, 144 UT_uint32 iLen, FP_RUN_TYPE iType); 145 virtual ~fp_Run(); 146 147 // inline getter member functions 148 getType()149 FP_RUN_TYPE getType() const { return m_iType; } getLine()150 fp_Line* getLine() const { return m_pLine; } getBlock()151 fl_BlockLayout* getBlock() const { return m_pBL; } getX()152 UT_sint32 getX() const { return m_iX; } getY()153 UT_sint32 getY() const { return m_iY; } 154 155 UT_sint32 getHeight() const; 156 UT_sint32 getWidth() const; 157 UT_uint32 getAscent() const; 158 UT_uint32 getDescent() const; 159 virtual UT_sint32 getDrawingWidth() const; 160 getNextRun()161 fp_Run* getNextRun() const { return m_pNext; } getPrevRun()162 fp_Run* getPrevRun() const { return m_pPrev; } 163 bool isInSelectedTOC(void); getNext(void)164 virtual fp_ContainerObject * getNext(void) const { return NULL;} getPrev(void)165 virtual fp_ContainerObject * getPrev(void) const { return NULL;} getNextContainerInSection(void)166 virtual fp_Container * getNextContainerInSection(void) const { return NULL;} getPrevContainerInSection(void)167 virtual fp_Container * getPrevContainerInSection(void) const { return NULL;} setNext(fp_ContainerObject *)168 virtual void setNext(fp_ContainerObject * /*pNull*/) {} setPrev(fp_ContainerObject *)169 virtual void setPrev(fp_ContainerObject * /*pNull*/) {} draw(GR_Graphics *)170 virtual void draw(GR_Graphics * /*pG*/) {} 171 getBlockOffset()172 UT_uint32 getBlockOffset() const { return m_iOffsetFirst; } getLength()173 UT_uint32 getLength() const { return m_iLen; } 174 GR_Graphics* getGraphics() const; getHyperlink()175 fp_HyperlinkRun * getHyperlink() const { return m_pHyperlink;} 176 #if DEBUG printText(void)177 virtual void printText(void) {}; 178 #endif 179 180 void getSpanAP(const PP_AttrProp * &pSpanAP); 181 const PP_AttrProp * getSpanAP(void); 182 183 getBlockAP(const PP_AttrProp * & pBlockAP)184 inline void getBlockAP(const PP_AttrProp * &pBlockAP) 185 {getBlock()->getAP(pBlockAP);} 186 187 188 void insertIntoRunListBeforeThis(fp_Run& newRun); 189 void insertIntoRunListAfterThis(fp_Run& newRun); getField(void)190 fd_Field* getField(void) const { return m_pField; } isField(void)191 bool isField(void) const { return (bool) (m_pField != NULL); } 192 void unlinkFromRunList(); 193 194 const UT_RGBColor getFGColor(void) const; 195 196 virtual bool hasLayoutProperties(void) const; 197 198 void setLine(fp_Line*); setBlock(fl_BlockLayout * pBL)199 void setBlock(fl_BlockLayout * pBL) { _setBlock(pBL); } 200 virtual void setX(UT_sint32 x, bool bDontClearIfNeeded = false); 201 void Run_setX(UT_sint32, FPRUN_CLEAR_SCREEN eClearScreen = FP_CLEARSCREEN_AUTO); 202 virtual void setY(UT_sint32); 203 void setBlockOffset(UT_uint32); 204 void setLength(UT_uint32 iLen, bool bRefresh = true); 205 void setNextRun(fp_Run*, bool bRefresh = true); 206 void setPrevRun(fp_Run*, bool bRefresh = true); 207 void setHyperlink(fp_HyperlinkRun * pH); markWidthDirty()208 void markWidthDirty() {m_bRecalcWidth = true;} 209 bool isFirstRunOnLine(void) const; 210 bool isLastRunOnLine(void) const; 211 bool isOnlyRunOnLine(void) const; 212 bool isFirstVisRunOnLine(void) const; 213 bool isLastVisRunOnLine(void) const; markDrawBufferDirty()214 void markDrawBufferDirty() 215 {m_eRefreshDrawBuffer = GRSR_Unknown;} orDrawBufferDirty(GRShapingResult eR)216 void orDrawBufferDirty(GRShapingResult eR) 217 { 218 m_eRefreshDrawBuffer = (GRShapingResult)((UT_uint32)m_eRefreshDrawBuffer 219 |(UT_uint32)eR); 220 } isPrinting(void)221 bool isPrinting(void) const 222 { return m_bPrinting;} 223 virtual void draw(dg_DrawArgs*); 224 virtual void clearScreen(void); 225 void Run_ClearScreen(bool bFullLineHeightRect = false); setWidth(UT_sint32)226 virtual void setWidth(UT_sint32 /*iW*/) {} setHeight(UT_sint32)227 virtual void setHeight(UT_sint32 /*iH*/) {} isVBreakable(void)228 virtual bool isVBreakable(void) {return false;} isHBreakable(void)229 virtual bool isHBreakable(void) {return false;} wantVBreakAt(UT_sint32 i)230 virtual UT_sint32 wantVBreakAt(UT_sint32 i) {return i;} wantHBreakAt(UT_sint32 i)231 virtual UT_sint32 wantHBreakAt(UT_sint32 i) {return i;} VBreakAt(UT_sint32)232 virtual fp_ContainerObject * VBreakAt(UT_sint32) { return NULL;} HBreakAt(UT_sint32)233 virtual fp_ContainerObject * HBreakAt(UT_sint32) { return NULL;} 234 235 void markAsDirty(void); 236 void setCleared(void); isDirty(void)237 bool isDirty(void) const { return m_bDirty; } 238 bool canContainPoint(void) const; 239 bool recalcWidth(void); 240 virtual void updateOnDelete(UT_uint32 offset, UT_uint32 iLen); 241 virtual void updateVerticalMetric(); 242 243 virtual UT_Rect * getScreenRect(); 244 virtual void markDirtyOverlappingRuns(UT_Rect & recScreen); 245 246 virtual void _draw(dg_DrawArgs*) = 0; 247 void _drawTextLine(UT_sint32, UT_sint32, UT_uint32, UT_uint32, UT_UCSChar *); 248 virtual void _clearScreen(bool bFullLineHeightRect) = 0; 249 virtual bool canBreakAfter(void) const = 0; 250 virtual bool canBreakBefore(void) const = 0; 251 bool letPointPass(void) const; isForcedBreak(void)252 virtual bool isForcedBreak(void) const { return false; } alwaysFits(void)253 virtual bool alwaysFits(void) const { return false; } 254 virtual bool findMaxLeftFitSplitPoint(UT_sint32 iMaxLeftWidth, fp_RunSplitInfo& si, 255 bool bForce=false); 256 void clearPrint(void); findTrailingSpaceDistance(void)257 virtual UT_sint32 findTrailingSpaceDistance(void) const { return 0; } findFirstNonBlankSplitPoint(fp_RunSplitInfo &)258 virtual bool findFirstNonBlankSplitPoint(fp_RunSplitInfo& /*si*/) { return false; } 259 virtual void mapXYToPosition(UT_sint32 xPos, UT_sint32 yPos, 260 PT_DocPosition& pos, bool& bBOL, bool& bEOL, bool & isTOC) = 0; 261 262 virtual void findPointCoords(UT_uint32 iOffset, UT_sint32& x, UT_sint32& y, 263 UT_sint32& x2, UT_sint32& y2, UT_sint32& height, 264 bool& bDirection) = 0; 265 266 void lookupProperties(GR_Graphics * pG=NULL); doesContainNonBlankData(void)267 virtual bool doesContainNonBlankData(void) const { return true; } // Things like text whould return false if it is all spaces. 268 void drawDecors(UT_sint32 xoff, UT_sint32 yoff, GR_Graphics * pG); isSuperscript(void)269 virtual bool isSuperscript(void) const { return false; } isSubscript(void)270 virtual bool isSubscript(void) const { return false; } 271 bool isUnderline(void) const ; 272 bool isOverline(void) const ; 273 bool isStrikethrough(void) const ; 274 bool isTopline(void) const ; 275 bool isBottomline(void) const ; 276 void setLinethickness(UT_sint32 max_linethickness); 277 UT_sint32 getLinethickness(void) const; 278 void setUnderlineXoff(UT_sint32 xoff); 279 UT_sint32 getUnderlineXoff(void) const; 280 void setOverlineXoff(UT_sint32 xoff) ; 281 UT_sint32 getOverlineXoff(void) const; 282 void setMaxUnderline(UT_sint32 xoff) ; 283 UT_sint32 getMaxUnderline(void) const; 284 void setMinOverline(UT_sint32 xoff) ; 285 UT_sint32 getMinOverline(void) const; 286 UT_sint32 getToplineThickness(void) const; 287 getDirection()288 virtual UT_BidiCharType getDirection() const { return m_iDirection; }; 289 UT_BidiCharType getVisDirection() const; 290 virtual void setDirection(UT_BidiCharType iDirection = UT_BIDI_WS); 291 void setVisDirection(UT_BidiCharType iDir); 292 UT_uint32 getVisPosition(UT_uint32 ilogPos) const; 293 UT_uint32 getVisPosition(UT_uint32 iLogPos, UT_uint32 iLen) const; 294 UT_uint32 getOffsetFirstVis() const; 295 UT_uint32 getOffsetLog(UT_uint32 iVisOff) const; 296 fp_Run * getNextVisual(); // FIXME make const 297 fp_Run * getPrevVisual(); // FIXME make const getAuthorNum(void)298 UT_sint32 getAuthorNum(void) const 299 { return m_iAuthorColor;}; setAuthorNum(UT_sint32 i)300 void setAuthorNum(UT_sint32 i) 301 { m_iAuthorColor=i;}; 302 adjustCaretPosition(UT_uint32 iDocumentPosition,bool)303 virtual UT_uint32 adjustCaretPosition(UT_uint32 iDocumentPosition, bool /*bForward*/) 304 { return iDocumentPosition;} 305 adjustDeletePosition(UT_uint32 &,UT_uint32 &)306 virtual void adjustDeletePosition(UT_uint32 & /*pos1*/, 307 UT_uint32 & /*count*/) {} 308 containsRevisions()309 bool containsRevisions() const {return (m_pRevisions != NULL);} 310 // would prefer to make the return value const, but the 311 // getLastRevision() and related functions use internal cache so 312 // they could not be called getRevisions()313 PP_RevisionAttr * getRevisions() const {return m_pRevisions;} getVisibility()314 FPVisibility getVisibility() const {return m_eVisibility;} isHidden()315 bool isHidden() const {return _wouldBeHidden(m_eVisibility);} 316 void setVisibility(FPVisibility eVis); 317 void Fill(GR_Graphics * pG, UT_sint32 x, UT_sint32 y, 318 UT_sint32 width, UT_sint32 height); 319 320 fg_FillType & getFillType(void); 321 const fg_FillType & getFillType(void) const; getTmpLine(void)322 fp_Line * getTmpLine(void) const 323 { return m_pTmpLine;} setTmpLine(fp_Line * pLine)324 void setTmpLine(fp_Line * pLine) 325 { m_pTmpLine = pLine;} getTmpX(void)326 UT_sint32 getTmpX(void) const 327 { return m_iTmpX;} setTmpX(UT_sint32 iX)328 void setTmpX(UT_sint32 iX) 329 { m_iTmpX = iX;} getTmpY(void)330 UT_sint32 getTmpY(void) const 331 { return m_iTmpY;} setTmpY(UT_sint32 iY)332 void setTmpY(UT_sint32 iY) 333 { m_iTmpY = iY;} getTmpWidth(void)334 UT_sint32 getTmpWidth(void) const 335 { return m_iTmpWidth;} setTmpWidth(UT_sint32 iWidth)336 void setTmpWidth(UT_sint32 iWidth) 337 { m_iTmpWidth = iWidth;} 338 bool clearIfNeeded(void); 339 340 // Indicates that if insertion point is placed at a position belonging to the run 341 // and delete command is issued, it should apply to the following run (or previous 342 // in case of backspace). This is used with invisible runs, such as hyperlinks, 343 // bookmarks, and hidden hidden text, to ensure that these are not deleted behind 344 // the users backs. 345 bool deleteFollowingIfAtInsPoint() const; 346 347 bool displayAnnotations(void) const; 348 bool displayRDFAnchors(void) const; 349 // Methods for selection drawing 350 void setSelectionMode(PT_DocPosition posLow, PT_DocPosition posHigh); 351 void clearSelectionMode(void); 352 bool isSelectionDraw(void) const; 353 PT_DocPosition posSelLow(void) const; 354 PT_DocPosition posSelHigh(void) const; _getColorFG(void)355 UT_RGBColor _getColorFG(void) const { return m_pColorFG; } 356 357 #ifdef FMT_TEST 358 virtual void __dump(FILE * fp) const; 359 #endif setMustClearScreen(void)360 void setMustClearScreen(void) 361 { m_bMustClearScreen = true;} getMustClearScreen(void)362 bool getMustClearScreen(void) 363 {return m_bMustClearScreen;} 364 365 protected: 366 virtual bool _deleteFollowingIfAtInsPoint() const; 367 void _inheritProperties(void); 368 fp_Run* _findPrevPropertyRun(void) const; 369 _getView(void)370 FV_View* _getView(void) const { return getBlock()->getView(); } 371 // By convention, _getFoo and _setFoo have no side effects. 372 // They can easily be inlined by a smart compiler. _getColorPG(void)373 UT_RGBColor _getColorPG(void) const { return m_pColorPG; } _getColorHL(void)374 UT_RGBColor _getColorHL(void) const { return m_pColorHL; } _setColorFG(UT_RGBColor c)375 void _setColorFG(UT_RGBColor c) { m_pColorFG = c; } _setColorHL(UT_RGBColor c)376 void _setColorHL(UT_RGBColor c) { m_pColorHL = c; } _setColorHL(const char * pszColor)377 void _setColorHL(const char *pszColor) 378 { m_pColorHL.setColor(pszColor); } 379 _setLine(fp_Line * pLine)380 void _setLine(fp_Line* pLine) { m_pLine = pLine; } _setHeight(UT_sint32 iHeight)381 void _setHeight(UT_sint32 iHeight) 382 { m_iHeight = iHeight;} _setWidth(UT_sint32 iWidth)383 virtual void _setWidth(UT_sint32 iWidth) 384 { m_iWidth = iWidth; } 385 386 // use these with great care -- most of the time we need to use 387 // getWidth() and getHeight() which deal with 388 // visibility/hiddenness issues _getWidth()389 UT_sint32 _getWidth() {return m_iWidth;} _getHeight()390 UT_sint32 _getHeight(){return m_iHeight;} 391 _setBlock(fl_BlockLayout * pBL)392 void _setBlock(fl_BlockLayout * pBL) { m_pBL = pBL; } _setAscent(int iAscent)393 void _setAscent(int iAscent) { m_iAscent = iAscent; } _setDescent(int iDescent)394 void _setDescent(int iDescent) {m_iDescent = iDescent;} _setX(int iX)395 void _setX(int iX) { m_iX = iX; } _setY(int iY)396 void _setY(int iY) { m_iY = iY; } _setDirection(UT_BidiCharType c)397 void _setDirection(UT_BidiCharType c) { m_iDirection = c; } _getDirection(void)398 UT_BidiCharType _getDirection(void) const { return m_iDirection; } _getVisDirection(void)399 UT_BidiCharType _getVisDirection(void) const { return m_iVisDirection; } 400 const GR_Font * _getFont(void) const; 401 void _setFont(const GR_Font * f); _getDecorations(void)402 unsigned char _getDecorations(void) const { return m_fDecorations; } _setDecorations(unsigned char d)403 void _setDecorations(unsigned char d) {m_fDecorations = d;} 404 _orDecorations(unsigned char d)405 void _orDecorations(unsigned char d) { m_fDecorations |= d; } _getLineWidth(void)406 UT_sint32 _getLineWidth(void) { return m_iLineWidth; } _setLineWidth(UT_sint32 w)407 bool _setLineWidth(UT_sint32 w) 408 { 409 UT_sint32 o = m_iLineWidth; 410 m_iLineWidth = w; 411 return o != w; 412 } _setLength(UT_uint32 l)413 void _setLength(UT_uint32 l) { m_iLen = l; } _setRevisions(PP_RevisionAttr * p)414 void _setRevisions(PP_RevisionAttr * p) { m_pRevisions = p; } 415 void _setDirty(bool b); _setField(fd_Field * fd)416 void _setField(fd_Field * fd) { m_pField = fd; } _setHyperlink(fp_HyperlinkRun * pH)417 void _setHyperlink(fp_HyperlinkRun * pH) { m_pHyperlink = pH; } _getRecalcWidth(void)418 bool _getRecalcWidth(void) const { return m_bRecalcWidth; } _setRecalcWidth(bool b)419 void _setRecalcWidth(bool b) { m_bRecalcWidth = b; } 420 _getRefreshDrawBuffer(void)421 GRShapingResult _getRefreshDrawBuffer(void) const { return m_eRefreshDrawBuffer; } _setRefreshDrawBuffer(GRShapingResult eR)422 void _setRefreshDrawBuffer(GRShapingResult eR) 423 { m_eRefreshDrawBuffer = eR; } 424 virtual void _lookupProperties(const PP_AttrProp * pSpanAP, 425 const PP_AttrProp * pBlockAP, 426 const PP_AttrProp * pSectionAP, 427 GR_Graphics * pG = NULL) = 0; 428 429 virtual bool _canContainPoint(void) const; 430 virtual bool _letPointPass(void) const; 431 virtual bool _recalcWidth(void); 432 bool _wouldBeHidden(FPVisibility eVis) const; 433 // 434 // Variables to draw underlines for all runs 435 // 436 enum 437 { 438 TEXT_DECOR_UNDERLINE = 0x01, 439 TEXT_DECOR_OVERLINE = 0x02, 440 TEXT_DECOR_LINETHROUGH = 0x04, 441 TEXT_DECOR_TOPLINE = 0x08, 442 TEXT_DECOR_BOTTOMLINE = 0x10 443 }; 444 445 private: 446 fp_Run(const fp_Run&); // no impl. 447 void operator=(const fp_Run&); // no impl. 448 449 FP_RUN_TYPE m_iType; 450 fp_Line* m_pLine; 451 fl_BlockLayout* m_pBL; 452 fp_Run* m_pNext; 453 fp_Run* m_pPrev; 454 UT_sint32 m_iX; 455 UT_sint32 m_iOldX; 456 UT_sint32 m_iY; 457 UT_sint32 m_iWidth; 458 UT_sint32 m_iHeight; 459 UT_uint32 m_iAscent; 460 UT_uint32 m_iDescent; 461 462 UT_uint32 m_iOffsetFirst; 463 UT_uint32 m_iLen; 464 bool m_bDirty; // run erased @ old coords, needs to be redrawn 465 fd_Field* m_pField; 466 UT_BidiCharType m_iDirection; //#TF direction of the run 0 for left-to-right, 1 for right-to-left 467 UT_BidiCharType m_iVisDirection; 468 GRShapingResult m_eRefreshDrawBuffer; 469 470 // the run highlight color. If the property is transparent use the page color 471 UT_RGBColor m_pColorHL; 472 473 const GR_Font * m_pFont; 474 475 bool m_bRecalcWidth; 476 477 unsigned char m_fDecorations; 478 UT_sint32 m_iLineWidth; 479 UT_sint32 m_iLinethickness; 480 UT_sint32 m_iUnderlineXoff; 481 UT_sint32 m_imaxUnderline; 482 UT_sint32 m_iminOverline; 483 UT_sint32 m_iOverlineXoff; 484 fp_HyperlinkRun * m_pHyperlink; 485 PP_RevisionAttr * m_pRevisions; 486 487 // A local cache of the page color. This makes clearscreen() a bit faster 488 UT_RGBColor m_pColorPG; 489 UT_RGBColor m_pColorFG; 490 FPVisibility m_eVisibility; 491 bool m_bIsCleared; 492 fg_FillType m_FillType; 493 bool m_bPrinting; 494 UT_sint32 m_iTmpX; 495 UT_sint32 m_iTmpY; 496 UT_sint32 m_iTmpWidth; 497 fp_Line * m_pTmpLine; 498 499 // Variables for selection drawing 500 bool m_bDrawSelection; 501 PT_DocPosition m_iSelLow; 502 PT_DocPosition m_iSelHigh; 503 bool m_bMustClearScreen; 504 UT_sint32 m_iAuthorColor; 505 #ifdef DEBUG 506 UT_uint32 m_iFontAllocNo; 507 #endif 508 }; 509 510 class ABI_EXPORT fp_TabRun : public fp_Run 511 { 512 public: 513 fp_TabRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 514 virtual void mapXYToPosition(UT_sint32 xPos, UT_sint32 yPos, PT_DocPosition& pos, bool& bBOL, bool& bEOL, bool & isTOC); 515 virtual void findPointCoords(UT_uint32 iOffset, UT_sint32& x, UT_sint32& y, UT_sint32& x2, UT_sint32& y2, UT_sint32& height, bool& bDirection); 516 virtual bool canBreakAfter(void) const; 517 virtual bool canBreakBefore(void) const; 518 virtual bool hasLayoutProperties(void) const; 519 void setTabWidth(UT_sint32); 520 void setLeader(eTabLeader iTabType); 521 eTabLeader getLeader(void); 522 void setTabType(eTabType iTabType); 523 eTabType getTabType(void) const; 524 bool isTOCTab(void); setTOCTab(void)525 void setTOCTab(void) 526 { m_bIsTOC = true;} 527 void setTOCTabListLabel(void); isTOCTabListLabel(void)528 bool isTOCTabListLabel(void) const 529 { return m_bIsTOCListLabel;} 530 531 protected: 532 virtual void _drawArrow(UT_uint32 iLeft,UT_uint32 iTop,UT_uint32 iWidth, UT_uint32 iHeight); 533 virtual void _draw(dg_DrawArgs*); 534 virtual void _clearScreen(bool bFullLineHeightRect); 535 virtual void _lookupProperties(const PP_AttrProp * pSpanAP, 536 const PP_AttrProp * pBlockAP, 537 const PP_AttrProp * pSectionAP, 538 GR_Graphics * pG = NULL); 539 540 virtual bool _letPointPass(void) const; 541 542 private: 543 //UT_RGBColor m_colorFG; 544 private: 545 eTabLeader m_leader; 546 eTabType m_TabType; 547 bool m_bIsTOC; 548 bool m_bIsTOCListLabel; 549 }; 550 551 class ABI_EXPORT fp_ForcedLineBreakRun : public fp_Run 552 { 553 public: 554 fp_ForcedLineBreakRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 555 virtual void mapXYToPosition(UT_sint32 xPos, UT_sint32 yPos, PT_DocPosition& pos, bool& bBOL, bool& bEOL, bool & isTOC); 556 virtual void findPointCoords(UT_uint32 iOffset, UT_sint32& x, UT_sint32& y, UT_sint32& x2, UT_sint32& y2, UT_sint32& height, bool& bDirection); 557 virtual bool canBreakAfter(void) const; 558 virtual bool canBreakBefore(void) const; isForcedBreak(void)559 virtual bool isForcedBreak(void) const { return true; } 560 protected: 561 virtual void _lookupProperties(const PP_AttrProp * pSpanAP, 562 const PP_AttrProp * pBlockAP, 563 const PP_AttrProp * pSectionAP, 564 GR_Graphics * pG = NULL); 565 566 virtual void _draw(dg_DrawArgs*); 567 virtual void _clearScreen(bool bFullLineHeightRect); 568 virtual bool _letPointPass(void) const; 569 }; 570 571 class ABI_EXPORT fp_FieldStartRun : public fp_Run 572 { 573 public: 574 fp_FieldStartRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 575 virtual void mapXYToPosition(UT_sint32 xPos, UT_sint32 yPos, PT_DocPosition& pos, bool& bBOL, bool& bEOL, bool & isTOC); 576 virtual void findPointCoords(UT_uint32 iOffset, UT_sint32& x, UT_sint32& y, UT_sint32& x2, UT_sint32& y2, UT_sint32& height, bool& bDirection); 577 virtual bool canBreakAfter(void) const; 578 virtual bool canBreakBefore(void) const; isForcedBreak(void)579 virtual bool isForcedBreak(void) const { return true; } 580 protected: 581 virtual void _lookupProperties(const PP_AttrProp * pSpanAP, 582 const PP_AttrProp * pBlockAP, 583 const PP_AttrProp * pSectionAP, 584 GR_Graphics * pG = NULL); 585 586 virtual void _draw(dg_DrawArgs*); 587 virtual void _clearScreen(bool bFullLineHeightRect); 588 virtual bool _letPointPass(void) const; 589 }; 590 591 class ABI_EXPORT fp_FieldEndRun : public fp_Run 592 { 593 public: 594 fp_FieldEndRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 595 virtual void mapXYToPosition(UT_sint32 xPos, UT_sint32 yPos, PT_DocPosition& pos, bool& bBOL, bool& bEOL, bool & isTOC); 596 virtual void findPointCoords(UT_uint32 iOffset, UT_sint32& x, UT_sint32& y, UT_sint32& x2, UT_sint32& y2, UT_sint32& height, bool& bDirection); 597 virtual bool canBreakAfter(void) const; 598 virtual bool canBreakBefore(void) const; isForcedBreak(void)599 virtual bool isForcedBreak(void) const { return true; } 600 protected: 601 virtual void _lookupProperties(const PP_AttrProp * pSpanAP, 602 const PP_AttrProp * pBlockAP, 603 const PP_AttrProp * pSectionAP, 604 GR_Graphics * pG = NULL); 605 606 virtual void _draw(dg_DrawArgs*); 607 virtual void _clearScreen(bool bFullLineHeightRect); 608 virtual bool _letPointPass(void) const; 609 }; 610 611 class ABI_EXPORT fp_ForcedColumnBreakRun : public fp_Run 612 { 613 public: 614 fp_ForcedColumnBreakRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 615 616 virtual void mapXYToPosition(UT_sint32 xPos, UT_sint32 yPos, PT_DocPosition& pos, bool& bBOL, bool& bEOL, bool & isTOC); 617 virtual void findPointCoords(UT_uint32 iOffset, UT_sint32& x, UT_sint32& y, UT_sint32& x2, UT_sint32& y2, UT_sint32& height, bool& bDirection); 618 virtual bool canBreakAfter(void) const; 619 virtual bool canBreakBefore(void) const; isForcedBreak(void)620 virtual bool isForcedBreak(void) const { return true; } 621 protected: 622 virtual void _lookupProperties(const PP_AttrProp * pSpanAP, 623 const PP_AttrProp * pBlockAP, 624 const PP_AttrProp * pSectionAP, 625 GR_Graphics * pG = NULL); 626 627 virtual void _draw(dg_DrawArgs*); 628 virtual void _clearScreen(bool bFullLineHeightRect); 629 virtual bool _letPointPass(void) const; 630 }; 631 632 class ABI_EXPORT fp_ForcedPageBreakRun : public fp_Run 633 { 634 public: 635 fp_ForcedPageBreakRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 636 virtual void mapXYToPosition(UT_sint32 xPos, UT_sint32 yPos, PT_DocPosition& pos, bool& bBOL, bool& bEOL, bool & isTOC); 637 virtual void findPointCoords(UT_uint32 iOffset, UT_sint32& x, UT_sint32& y, UT_sint32& x2, UT_sint32& y2, UT_sint32& height, bool& bDirection); 638 virtual bool canBreakAfter(void) const; 639 virtual bool canBreakBefore(void) const; isForcedBreak(void)640 virtual bool isForcedBreak(void) const { return true; } 641 642 protected: 643 virtual void _lookupProperties(const PP_AttrProp * pSpanAP, 644 const PP_AttrProp * pBlockAP, 645 const PP_AttrProp * pSectionAP, 646 GR_Graphics * pG = NULL); 647 648 virtual void _draw(dg_DrawArgs*); 649 virtual void _clearScreen(bool bFullLineHeightRect); 650 virtual bool _letPointPass(void) const; 651 }; 652 653 class ABI_EXPORT fp_EndOfParagraphRun : public fp_Run 654 { 655 public: 656 fp_EndOfParagraphRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 657 658 virtual void mapXYToPosition(UT_sint32 xPos, UT_sint32 yPos, PT_DocPosition& pos, bool& bBOL, bool& bEOL, bool &isToc); 659 virtual void findPointCoords(UT_uint32 iOffset, UT_sint32& x, UT_sint32& y, UT_sint32& x2, UT_sint32& y2, UT_sint32& height, bool& bDirection); 660 virtual bool canBreakAfter(void) const; 661 virtual bool canBreakBefore(void) const; getDrawingWidth()662 virtual UT_sint32 getDrawingWidth() const { return static_cast<UT_sint32>(m_iDrawWidth);} 663 664 // 665 // Tomas this breaks line breaking.... 666 // virtual bool doesContainNonBlankData(void) const { return false; } // Things like text whould return false if it is all spaces. 667 668 protected: 669 virtual void _lookupProperties(const PP_AttrProp * pSpanAP, 670 const PP_AttrProp * pBlockAP, 671 const PP_AttrProp * pSectionAP, 672 GR_Graphics * pG = NULL); 673 674 virtual void _draw(dg_DrawArgs*); 675 virtual void _clearScreen(bool bFullLineHeightRect); 676 virtual bool _letPointPass(void) const; 677 virtual bool _recalcWidth(void); 678 679 private: 680 UT_uint32 m_iXoffText; 681 UT_uint32 m_iYoffText; 682 UT_uint32 m_iDrawWidth; 683 684 }; 685 686 class ABI_EXPORT fp_BookmarkRun : public fp_Run 687 { 688 public: 689 fp_BookmarkRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 690 isStartOfBookmark()691 bool isStartOfBookmark() const {return m_bIsStart;}; getName()692 const gchar * getName() const {return m_pName;}; 693 bool isComrade(fp_BookmarkRun *pBR) const; 694 695 virtual bool canBreakAfter(void) const; 696 virtual bool canBreakBefore(void) const; 697 698 virtual void mapXYToPosition(UT_sint32 x, 699 UT_sint32 y, 700 PT_DocPosition& pos, 701 bool& bBOL, 702 bool& bEOL, 703 bool & isTOC); 704 705 virtual void findPointCoords(UT_uint32 iOffset, 706 UT_sint32& x, 707 UT_sint32& y, 708 UT_sint32& x2, 709 UT_sint32& y2, 710 UT_sint32& height, 711 bool& bDirection); hasLayoutProperties(void)712 virtual bool hasLayoutProperties(void) const 713 { return false; } 714 715 // for the purposes of linebreaking, just whitespace doesContainNonBlankData(void)716 virtual bool doesContainNonBlankData(void) const { return false; } 717 718 UT_uint32 getBookmarkedDocPosition(bool bAfter) const; 719 720 721 private: 722 virtual void _lookupProperties(const PP_AttrProp * pSpanAP, 723 const PP_AttrProp * pBlockAP, 724 const PP_AttrProp * pSectionAP, 725 GR_Graphics * pG = NULL); 726 727 virtual void _clearScreen(bool /* bFullLineHeightRect */); 728 virtual void _draw(dg_DrawArgs* /*pDA */); 729 virtual bool _letPointPass(void) const; 730 virtual bool _canContainPoint(void) const; 731 virtual bool _deleteFollowingIfAtInsPoint() const; 732 733 bool m_bIsStart; 734 #define BOOKMARK_NAME_SIZE 30 735 gchar m_pName[BOOKMARK_NAME_SIZE + 1]; 736 po_Bookmark * m_pBookmark; 737 }; 738 739 class ABI_EXPORT fp_HyperlinkRun : public fp_Run 740 { 741 public: 742 fp_HyperlinkRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 743 virtual ~fp_HyperlinkRun(); getHyperlinkType(void)744 virtual FP_HYPERLINK_TYPE getHyperlinkType(void) const { return HYPERLINK_NORMAL;} isStartOfHyperlink()745 bool isStartOfHyperlink() const {return m_bIsStart;}; getTarget()746 const gchar * getTarget() const {return static_cast<const gchar *>(m_pTarget);}; getTitle()747 const gchar * getTitle() const {return static_cast<const gchar *>(m_pTitle);}; 748 749 virtual bool canBreakAfter(void) const; 750 virtual bool canBreakBefore(void) const; 751 752 virtual void mapXYToPosition(UT_sint32 x, 753 UT_sint32 y, 754 PT_DocPosition& pos, 755 bool& bBOL, 756 bool& bEOL, 757 bool &isTOC); 758 759 virtual void findPointCoords(UT_uint32 iOffset, 760 UT_sint32& x, 761 UT_sint32& y, 762 UT_sint32& x2, 763 UT_sint32& y2, 764 UT_sint32& height, 765 bool& bDirection); 766 hasLayoutProperties(void)767 virtual bool hasLayoutProperties(void) const 768 { return false; } 769 770 // for the purposes of linebreaking, just whitespace doesContainNonBlankData(void)771 virtual bool doesContainNonBlankData(void) const { return false; } 772 773 protected: 774 virtual void _lookupProperties(const PP_AttrProp * pSpanAP, 775 const PP_AttrProp * pBlockAP, 776 const PP_AttrProp * pSectionAP, 777 GR_Graphics * pG = NULL); 778 779 virtual void _clearScreen(bool /* bFullLineHeightRect */); 780 virtual void _draw(dg_DrawArgs* /*pDA */); 781 virtual bool _letPointPass(void) const; 782 virtual bool _canContainPoint(void) const; 783 virtual bool _deleteFollowingIfAtInsPoint() const; 784 void _setTarget( const gchar * pTarget ); 785 void _setTitle( const gchar * pTitle ); 786 void _setTargetFromAPAttribute( const gchar* pAttrName ); 787 void _setTitleFromAPAttribute( const gchar* pAttrName ); 788 bool m_bIsStart; 789 gchar * m_pTarget; 790 gchar * m_pTitle; 791 }; 792 793 794 795 class ABI_EXPORT fp_AnnotationRun : public fp_HyperlinkRun 796 { 797 public: 798 fp_AnnotationRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 799 virtual ~fp_AnnotationRun(); getHyperlinkType(void)800 virtual FP_HYPERLINK_TYPE getHyperlinkType(void) const { return HYPERLINK_ANNOTATION; } getPID(void)801 UT_uint32 getPID(void) { return m_iPID;} 802 const char * getValue(void); 803 void recalcValue(void); 804 virtual bool canBreakAfter(void) const; 805 virtual bool canBreakBefore(void) const; getRealWidth(void)806 UT_sint32 getRealWidth(void) const {return m_iRealWidth;} 807 void cleanDraw(dg_DrawArgs*); 808 UT_sint32 calcWidth(void); 809 810 protected: 811 virtual void _draw(dg_DrawArgs*); 812 virtual void _clearScreen(bool bFullLineHeightRect); 813 virtual bool _recalcWidth(void); 814 bool _setValue(void); 815 virtual void _setWidth(UT_sint32 iWidth); 816 virtual bool _letPointPass(void) const; 817 virtual bool _canContainPoint(void) const; 818 virtual void _lookupProperties(const PP_AttrProp * pSpanAP, 819 const PP_AttrProp * pBlockAP, 820 const PP_AttrProp * pSectionAP, 821 GR_Graphics * pG); 822 private: 823 UT_uint32 m_iPID; 824 UT_UTF8String m_sValue; 825 UT_sint32 m_iRealWidth; 826 }; 827 828 class ABI_EXPORT fp_RDFAnchorRun : public fp_HyperlinkRun 829 { 830 public: 831 fp_RDFAnchorRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 832 virtual ~fp_RDFAnchorRun(); getHyperlinkType(void)833 virtual FP_HYPERLINK_TYPE getHyperlinkType(void) const { return HYPERLINK_RDFANCHOR; } getPID(void)834 UT_uint32 getPID(void) { return m_iPID;} 835 const char * getValue(void); 836 void recalcValue(void); 837 virtual bool canBreakAfter(void) const; 838 virtual bool canBreakBefore(void) const; getRealWidth(void)839 UT_sint32 getRealWidth(void) const {return m_iRealWidth;} 840 void cleanDraw(dg_DrawArgs*); 841 UT_sint32 calcWidth(void); 842 843 std::string getXMLID(); 844 845 protected: 846 virtual void _draw(dg_DrawArgs*); 847 virtual void _clearScreen(bool bFullLineHeightRect); 848 virtual bool _recalcWidth(void); 849 bool _setValue(void); 850 virtual void _setWidth(UT_sint32 iWidth); 851 virtual bool _letPointPass(void) const; 852 virtual bool _canContainPoint(void) const; 853 virtual void _lookupProperties(const PP_AttrProp * pSpanAP, 854 const PP_AttrProp * pBlockAP, 855 const PP_AttrProp * pSectionAP, 856 GR_Graphics * pG); 857 private: 858 UT_uint32 m_iPID; 859 UT_UTF8String m_sValue; 860 UT_sint32 m_iRealWidth; 861 }; 862 863 class ABI_EXPORT fp_ImageRun : public fp_Run 864 { 865 public: 866 fp_ImageRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen, FG_Graphic * pGraphic, pf_Frag_Object* oh); 867 virtual ~fp_ImageRun(); 868 869 virtual void mapXYToPosition(UT_sint32 xPos, UT_sint32 yPos, PT_DocPosition& pos, bool& bBOL, bool& bEOL, bool & isTOC); 870 virtual void findPointCoords(UT_uint32 iOffset, UT_sint32& x, UT_sint32& y, UT_sint32& x2, UT_sint32& y2, UT_sint32& height, bool& bDirection); 871 virtual bool canBreakAfter(void) const; 872 virtual bool canBreakBefore(void) const; 873 const char * getDataId(void) const; 874 virtual bool hasLayoutProperties(void) const; 875 virtual GR_Image * getImage(); 876 void regenerateImage(GR_Graphics * pG); getPointHeight(void)877 UT_sint32 getPointHeight(void) 878 { return m_iPointHeight;} 879 protected: 880 virtual void _lookupProperties(const PP_AttrProp * pSpanAP, 881 const PP_AttrProp * pBlockAP, 882 const PP_AttrProp * pSectionAP, 883 GR_Graphics * pG = NULL); 884 885 virtual void _draw(dg_DrawArgs*); 886 virtual void _clearScreen(bool bFullLineHeightRect); 887 virtual bool _letPointPass(void) const; 888 889 private: 890 FG_Graphic * m_pFGraphic; 891 GR_Image* m_pImage; 892 UT_sint32 m_iImageWidth; 893 UT_sint32 m_iImageHeight; 894 UT_String m_sCachedWidthProp; 895 UT_String m_sCachedHeightProp; 896 UT_sint32 m_iPointHeight; 897 const PP_AttrProp * m_pSpanAP; 898 UT_uint32 m_iGraphicTick; 899 bool m_bImageForPrinter; 900 pf_Frag_Object* m_OH; 901 }; 902 903 #define FPFIELD_MAX_LENGTH 127 904 905 #define _FIELD(type,desc,tag) /*nothing*/ 906 #define _FIELDTYPE(type,desc) FPFIELDTYPE_##type, 907 908 enum fp_FieldTypesEnum { FPFIELDTYPE_START, 909 910 #include "fp_Fields.h" 911 912 FPFIELDTYPE_END }; 913 914 #undef _FIELD 915 #undef _FIELDTYPE 916 917 #define _FIELD(type,desc,tag) FPFIELD_##tag, 918 #define _FIELDTYPE(type,desc) /*nothing*/ 919 920 enum fp_FieldsEnum { FPFIELD_start, 921 922 #include "fp_Fields.h" 923 924 FPFIELD_end }; 925 926 #undef _FIELD 927 #undef _FIELDTYPE 928 929 930 struct fp_FieldTypeData 931 { 932 fp_FieldTypesEnum m_Type; 933 const char* m_Desc; 934 XAP_String_Id m_DescId; 935 }; 936 937 struct fp_FieldData 938 { 939 fp_FieldTypesEnum m_Type; 940 fp_FieldsEnum m_Num; 941 const char* m_Desc; 942 const char* m_Tag; 943 XAP_String_Id m_DescId; 944 }; 945 946 947 extern fp_FieldTypeData fp_FieldTypes[]; 948 extern fp_FieldData fp_FieldFmts[]; 949 950 // these constants define how frequently our fields get updated 951 // (in 1/2 seconds) 952 // you know, we should be able to not have to scan for endnote changes; 953 // they should be told to us. 954 #define FIELD_UPDATE_ENDNOTE 3 955 #define FIELD_UPDATE_TIME 1 956 #define FIELD_UPDATE_DATE 240 957 #define FIELD_UPDATE_PAGE 20 958 #define FIELD_UPDATE_LINE_COUNT 10 959 #define FIELD_UPDATE_WORD_COUNT 4 960 #define FIELD_UPDATE_PARA_COUNT 20 961 #define FIELD_UPDATE_META 10 962 #define FIELD_UPDATE_MAILMERGE 10 963 964 class ABI_EXPORT fp_FieldRun : public fp_Run 965 { 966 public: 967 fp_FieldRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 968 virtual ~fp_FieldRun(); 969 970 virtual void mapXYToPosition(UT_sint32 xPos, UT_sint32 yPos, PT_DocPosition& pos, bool& bBOL, bool& bEOL, bool &isTOC); 971 virtual void findPointCoords(UT_uint32 iOffset, UT_sint32& x, UT_sint32& y, UT_sint32& x2, UT_sint32& y2, UT_sint32& height, bool& bDirection); 972 virtual bool canBreakAfter(void) const; 973 virtual fp_FieldsEnum getFieldType(void) const; 974 virtual bool canBreakBefore(void) const; 975 virtual bool hasLayoutProperties(void) const; 976 977 virtual bool isSuperscript(void) const; 978 virtual bool isSubscript(void) const; 979 980 bool _setValue(const UT_UCSChar *p_new_value); 981 982 virtual bool calculateValue(void); getValue(void)983 virtual const UT_UCSChar * getValue(void) const { return reinterpret_cast<const UT_UCS4Char *>(m_sFieldValue);} needsFrequentUpdates()984 virtual UT_uint32 needsFrequentUpdates() {return 0;} 985 986 protected: 987 virtual void _lookupProperties(const PP_AttrProp * pSpanAP, 988 const PP_AttrProp * pBlockAP, 989 const PP_AttrProp * pSectionAP, 990 GR_Graphics * pG = NULL); 991 _draw(dg_DrawArgs *)992 virtual void _draw(dg_DrawArgs*) {}; 993 virtual void _defaultDraw(dg_DrawArgs*); 994 virtual void _clearScreen(bool bFullLineHeightRect); _getParameter()995 const gchar * _getParameter() const { return m_pParameter; } 996 virtual bool _letPointPass(void) const; 997 virtual bool _recalcWidth(void); 998 999 private: 1000 1001 //UT_RGBColor m_colorFG; 1002 UT_RGBColor m_colorBG; 1003 UT_UCS4Char m_sFieldValue[FPFIELD_MAX_LENGTH]; 1004 fp_FieldsEnum m_iFieldType; 1005 const gchar * m_pParameter; 1006 enum 1007 { 1008 TEXT_POSITION_NORMAL, 1009 TEXT_POSITION_SUPERSCRIPT, 1010 TEXT_POSITION_SUBSCRIPT 1011 }; 1012 UT_Byte m_fPosition; 1013 }; 1014 1015 1016 class ABI_EXPORT fp_FieldEndnoteRefRun : public fp_FieldRun 1017 { 1018 public: 1019 1020 fp_FieldEndnoteRefRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 1021 ~fp_FieldEndnoteRefRun()1022 virtual ~fp_FieldEndnoteRefRun(){} 1023 1024 virtual bool calculateValue(void); 1025 virtual bool canBreakBefore(void) const; _draw(dg_DrawArgs * pDA)1026 virtual void _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); } needsFrequentUpdates()1027 virtual UT_uint32 needsFrequentUpdates(){return FIELD_UPDATE_ENDNOTE;}; getPID()1028 UT_uint32 getPID() const {return m_iPID;} 1029 1030 private: 1031 UT_uint32 m_iPID; 1032 }; 1033 1034 1035 class ABI_EXPORT fp_FieldEndnoteAnchorRun : public fp_FieldRun 1036 { 1037 public: 1038 1039 fp_FieldEndnoteAnchorRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 1040 ~fp_FieldEndnoteAnchorRun()1041 virtual ~fp_FieldEndnoteAnchorRun() {} 1042 1043 virtual bool calculateValue(void); _draw(dg_DrawArgs * pDA)1044 virtual void _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); } needsFrequentUpdates()1045 virtual UT_uint32 needsFrequentUpdates(){return FIELD_UPDATE_ENDNOTE;}; getPID()1046 UT_uint32 getPID() const {return m_iPID;} 1047 1048 private: 1049 UT_uint32 m_iPID; 1050 }; 1051 1052 class ABI_EXPORT fp_FieldFootnoteRefRun : public fp_FieldRun 1053 { 1054 public: 1055 1056 fp_FieldFootnoteRefRun(fl_BlockLayout* pBL,UT_uint32 iOffsetFirst, UT_uint32 iLen); 1057 ~fp_FieldFootnoteRefRun()1058 virtual ~fp_FieldFootnoteRefRun(){} 1059 1060 virtual bool calculateValue(void); 1061 virtual bool canBreakBefore(void) const; _draw(dg_DrawArgs * pDA)1062 virtual void _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); } needsFrequentUpdates()1063 virtual UT_uint32 needsFrequentUpdates(){return FIELD_UPDATE_ENDNOTE;}; getPID()1064 UT_uint32 getPID() const {return m_iPID;} 1065 1066 private: 1067 UT_uint32 m_iPID; 1068 }; 1069 1070 class ABI_EXPORT fp_FieldFootnoteAnchorRun : public fp_FieldRun 1071 { 1072 public: 1073 1074 fp_FieldFootnoteAnchorRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 1075 ~fp_FieldFootnoteAnchorRun()1076 virtual ~fp_FieldFootnoteAnchorRun() {} 1077 1078 virtual bool calculateValue(void); _draw(dg_DrawArgs * pDA)1079 virtual void _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); } needsFrequentUpdates()1080 virtual UT_uint32 needsFrequentUpdates(){return FIELD_UPDATE_ENDNOTE;}; getPID()1081 UT_uint32 getPID() const {return m_iPID;} 1082 1083 private: 1084 UT_uint32 m_iPID; 1085 }; 1086 1087 class ABI_EXPORT fp_FieldTimeRun : public fp_FieldRun 1088 { 1089 public: 1090 1091 fp_FieldTimeRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 1092 ~fp_FieldTimeRun()1093 virtual ~fp_FieldTimeRun(){} 1094 1095 virtual bool calculateValue(void); _draw(dg_DrawArgs * pDA)1096 virtual void _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); } needsFrequentUpdates()1097 virtual UT_uint32 needsFrequentUpdates(){return FIELD_UPDATE_TIME;}; 1098 }; 1099 1100 class ABI_EXPORT fp_FieldPageNumberRun : public fp_FieldRun 1101 { 1102 public: 1103 1104 fp_FieldPageNumberRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 1105 ~fp_FieldPageNumberRun()1106 virtual ~fp_FieldPageNumberRun() {} 1107 1108 virtual bool calculateValue(void); _draw(dg_DrawArgs * pDA)1109 virtual void _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); } needsFrequentUpdates()1110 virtual UT_uint32 needsFrequentUpdates(){return FIELD_UPDATE_PAGE;}; 1111 }; 1112 1113 class ABI_EXPORT fp_FieldPageReferenceRun : public fp_FieldRun 1114 { 1115 public: 1116 1117 fp_FieldPageReferenceRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 1118 ~fp_FieldPageReferenceRun()1119 virtual ~fp_FieldPageReferenceRun() {} 1120 1121 virtual bool calculateValue(void); _draw(dg_DrawArgs * pDA)1122 virtual void _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); } needsFrequentUpdates()1123 virtual UT_uint32 needsFrequentUpdates(){return FIELD_UPDATE_PAGE;}; 1124 }; 1125 1126 class ABI_EXPORT fp_FieldPageCountRun : public fp_FieldRun 1127 { 1128 public: 1129 1130 fp_FieldPageCountRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 1131 ~fp_FieldPageCountRun()1132 virtual ~fp_FieldPageCountRun() {} 1133 1134 virtual bool calculateValue(void); _draw(dg_DrawArgs * pDA)1135 virtual void _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); } needsFrequentUpdates()1136 virtual UT_uint32 needsFrequentUpdates(){return FIELD_UPDATE_PAGE;}; 1137 }; 1138 1139 class ABI_EXPORT fp_FieldDateRun : public fp_FieldRun 1140 { 1141 public: 1142 fp_FieldDateRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 1143 ~fp_FieldDateRun()1144 virtual ~fp_FieldDateRun() {} 1145 1146 virtual bool calculateValue(void); _draw(dg_DrawArgs * pDA)1147 virtual void _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); } needsFrequentUpdates()1148 virtual UT_uint32 needsFrequentUpdates(){return FIELD_UPDATE_DATE;}; 1149 }; 1150 1151 1152 class ABI_EXPORT fp_FieldFileNameRun : public fp_FieldRun 1153 { 1154 public: 1155 fp_FieldFileNameRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 1156 ~fp_FieldFileNameRun()1157 virtual ~fp_FieldFileNameRun() {} 1158 1159 virtual bool calculateValue(void); _draw(dg_DrawArgs * pDA)1160 virtual void _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); } 1161 }; 1162 1163 class ABI_EXPORT fp_FieldShortFileNameRun : public fp_FieldRun 1164 { 1165 public: 1166 fp_FieldShortFileNameRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 1167 ~fp_FieldShortFileNameRun()1168 virtual ~fp_FieldShortFileNameRun() {} 1169 1170 virtual bool calculateValue(void); _draw(dg_DrawArgs * pDA)1171 virtual void _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); } 1172 }; 1173 1174 // BEGIN DOM 1175 1176 // document-related information fields 1177 1178 // count of characters in the document 1179 // including white spaces 1180 class ABI_EXPORT fp_FieldCharCountRun : public fp_FieldRun 1181 { 1182 public: 1183 fp_FieldCharCountRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 1184 ~fp_FieldCharCountRun()1185 virtual ~fp_FieldCharCountRun() {} 1186 1187 virtual bool calculateValue(void); _draw(dg_DrawArgs * pDA)1188 virtual void _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); } needsFrequentUpdates()1189 virtual UT_uint32 needsFrequentUpdates(){return FIELD_UPDATE_TIME;}; 1190 }; 1191 1192 // count of the non-blank characters 1193 // in the document 1194 class ABI_EXPORT fp_FieldNonBlankCharCountRun : public fp_FieldRun 1195 { 1196 public: 1197 fp_FieldNonBlankCharCountRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 1198 ~fp_FieldNonBlankCharCountRun()1199 virtual ~fp_FieldNonBlankCharCountRun(){} 1200 1201 virtual bool calculateValue(void); _draw(dg_DrawArgs * pDA)1202 virtual void _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); } needsFrequentUpdates()1203 virtual UT_uint32 needsFrequentUpdates(){return FIELD_UPDATE_TIME;}; 1204 }; 1205 1206 // count of the #lines in the document 1207 class ABI_EXPORT fp_FieldLineCountRun : public fp_FieldRun 1208 { 1209 public: 1210 fp_FieldLineCountRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 1211 ~fp_FieldLineCountRun()1212 virtual ~fp_FieldLineCountRun(){} 1213 1214 virtual bool calculateValue(void); _draw(dg_DrawArgs * pDA)1215 virtual void _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); } needsFrequentUpdates()1216 virtual UT_uint32 needsFrequentUpdates(){return FIELD_UPDATE_LINE_COUNT;}; 1217 }; 1218 1219 1220 // Sum the contents of the row of a table 1221 class ABI_EXPORT fp_FieldTableSumRows : public fp_FieldRun 1222 { 1223 public: 1224 fp_FieldTableSumRows(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 1225 ~fp_FieldTableSumRows()1226 virtual ~fp_FieldTableSumRows(){} 1227 1228 virtual bool calculateValue(void); _draw(dg_DrawArgs * pDA)1229 virtual void _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); } needsFrequentUpdates()1230 virtual UT_uint32 needsFrequentUpdates(){return FIELD_UPDATE_WORD_COUNT;}; 1231 }; 1232 1233 1234 // Sum the contents of the row of a table 1235 class ABI_EXPORT fp_FieldTableSumCols : public fp_FieldRun 1236 { 1237 public: 1238 fp_FieldTableSumCols(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 1239 ~fp_FieldTableSumCols()1240 virtual ~fp_FieldTableSumCols(){} 1241 1242 virtual bool calculateValue(void); _draw(dg_DrawArgs * pDA)1243 virtual void _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); } needsFrequentUpdates()1244 virtual UT_uint32 needsFrequentUpdates(){return FIELD_UPDATE_WORD_COUNT;}; 1245 }; 1246 1247 // count of the #para in the document 1248 class ABI_EXPORT fp_FieldParaCountRun : public fp_FieldRun 1249 { 1250 public: 1251 fp_FieldParaCountRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 1252 ~fp_FieldParaCountRun()1253 virtual ~fp_FieldParaCountRun(){} 1254 1255 virtual bool calculateValue(void); _draw(dg_DrawArgs * pDA)1256 virtual void _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); } needsFrequentUpdates()1257 virtual UT_uint32 needsFrequentUpdates(){return FIELD_UPDATE_PARA_COUNT;}; 1258 }; 1259 1260 // count of #words in the document 1261 class ABI_EXPORT fp_FieldWordCountRun : public fp_FieldRun 1262 { 1263 public: 1264 fp_FieldWordCountRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 1265 ~fp_FieldWordCountRun()1266 virtual ~fp_FieldWordCountRun(){} 1267 1268 virtual bool calculateValue(void); _draw(dg_DrawArgs * pDA)1269 virtual void _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); } needsFrequentUpdates()1270 virtual UT_uint32 needsFrequentUpdates(){return FIELD_UPDATE_WORD_COUNT;}; 1271 }; 1272 1273 1274 // date-releated fields 1275 1276 // Americans - mm/dd/yy 1277 class ABI_EXPORT fp_FieldMMDDYYRun : public fp_FieldRun 1278 { 1279 public: 1280 fp_FieldMMDDYYRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 1281 ~fp_FieldMMDDYYRun()1282 virtual ~fp_FieldMMDDYYRun(){} 1283 1284 virtual bool calculateValue(void); _draw(dg_DrawArgs * pDA)1285 virtual void _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); } needsFrequentUpdates()1286 virtual UT_uint32 needsFrequentUpdates(){return FIELD_UPDATE_DATE;}; 1287 }; 1288 1289 // most of the world - dd/mm/yy 1290 class ABI_EXPORT fp_FieldDDMMYYRun : public fp_FieldRun 1291 { 1292 public: 1293 fp_FieldDDMMYYRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 1294 ~fp_FieldDDMMYYRun()1295 virtual ~fp_FieldDDMMYYRun(){} 1296 1297 virtual bool calculateValue(void); _draw(dg_DrawArgs * pDA)1298 virtual void _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); } needsFrequentUpdates()1299 virtual UT_uint32 needsFrequentUpdates(){return FIELD_UPDATE_DATE;}; 1300 }; 1301 1302 // April 18, 1979 1303 class ABI_EXPORT fp_FieldMonthDayYearRun : public fp_FieldRun 1304 { 1305 public: 1306 fp_FieldMonthDayYearRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 1307 ~fp_FieldMonthDayYearRun()1308 virtual ~fp_FieldMonthDayYearRun(){} 1309 1310 virtual bool calculateValue(void); _draw(dg_DrawArgs * pDA)1311 virtual void _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); } needsFrequentUpdates()1312 virtual UT_uint32 needsFrequentUpdates(){return FIELD_UPDATE_DATE;}; 1313 }; 1314 1315 // Apr. 18, 1979 1316 class ABI_EXPORT fp_FieldMthDayYearRun : public fp_FieldRun 1317 { 1318 public: 1319 fp_FieldMthDayYearRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 1320 ~fp_FieldMthDayYearRun()1321 virtual ~fp_FieldMthDayYearRun (){} 1322 1323 virtual bool calculateValue(void); _draw(dg_DrawArgs * pDA)1324 virtual void _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); } needsFrequentUpdates()1325 virtual UT_uint32 needsFrequentUpdates(){return FIELD_UPDATE_DATE;}; 1326 }; 1327 1328 // default representation for your locale. includes time too 1329 class ABI_EXPORT fp_FieldDefaultDateRun : public fp_FieldRun 1330 { 1331 public: 1332 fp_FieldDefaultDateRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 1333 ~fp_FieldDefaultDateRun()1334 virtual ~fp_FieldDefaultDateRun(){} 1335 1336 virtual bool calculateValue(void); _draw(dg_DrawArgs * pDA)1337 virtual void _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); } needsFrequentUpdates()1338 virtual UT_uint32 needsFrequentUpdates(){return FIELD_UPDATE_TIME;}; 1339 }; 1340 1341 // default for your locale, not appending the time 1342 class ABI_EXPORT fp_FieldDefaultDateNoTimeRun : public fp_FieldRun 1343 { 1344 public: 1345 fp_FieldDefaultDateNoTimeRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 1346 ~fp_FieldDefaultDateNoTimeRun()1347 virtual ~fp_FieldDefaultDateNoTimeRun(){} 1348 1349 virtual bool calculateValue(void); _draw(dg_DrawArgs * pDA)1350 virtual void _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); } needsFrequentUpdates()1351 virtual UT_uint32 needsFrequentUpdates(){return FIELD_UPDATE_DATE;}; 1352 }; 1353 1354 // day of the week (Wednesday) 1355 class ABI_EXPORT fp_FieldWkdayRun : public fp_FieldRun 1356 { 1357 public: 1358 fp_FieldWkdayRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 1359 ~fp_FieldWkdayRun()1360 virtual ~fp_FieldWkdayRun(){} 1361 1362 virtual bool calculateValue(void); _draw(dg_DrawArgs * pDA)1363 virtual void _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); } needsFrequentUpdates()1364 virtual UT_uint32 needsFrequentUpdates(){return FIELD_UPDATE_DATE;}; 1365 }; 1366 1367 // day of year (i.e. 72) 1368 class ABI_EXPORT fp_FieldDOYRun : public fp_FieldRun 1369 { 1370 public: 1371 fp_FieldDOYRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 1372 ~fp_FieldDOYRun()1373 virtual ~fp_FieldDOYRun(){} 1374 1375 virtual bool calculateValue(void); _draw(dg_DrawArgs * pDA)1376 virtual void _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); } needsFrequentUpdates()1377 virtual UT_uint32 needsFrequentUpdates(){return FIELD_UPDATE_DATE;}; 1378 }; 1379 1380 // military (zulu) time 1381 class ABI_EXPORT fp_FieldMilTimeRun : public fp_FieldRun 1382 { 1383 public: 1384 fp_FieldMilTimeRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 1385 ~fp_FieldMilTimeRun()1386 virtual ~fp_FieldMilTimeRun(){} 1387 1388 virtual bool calculateValue(void); _draw(dg_DrawArgs * pDA)1389 virtual void _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); } needsFrequentUpdates()1390 virtual UT_uint32 needsFrequentUpdates(){return FIELD_UPDATE_TIME;}; 1391 }; 1392 1393 // prints am or pm 1394 class ABI_EXPORT fp_FieldAMPMRun : public fp_FieldRun 1395 { 1396 public: 1397 fp_FieldAMPMRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 1398 ~fp_FieldAMPMRun()1399 virtual ~fp_FieldAMPMRun(){} 1400 1401 virtual bool calculateValue(void); _draw(dg_DrawArgs * pDA)1402 virtual void _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); } needsFrequentUpdates()1403 virtual UT_uint32 needsFrequentUpdates(){return FIELD_UPDATE_DATE;}; 1404 }; 1405 1406 // milliseconds since the epoch, for you geeks out there :-) 1407 class ABI_EXPORT fp_FieldTimeEpochRun : public fp_FieldRun 1408 { 1409 public: 1410 fp_FieldTimeEpochRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 1411 ~fp_FieldTimeEpochRun()1412 virtual ~fp_FieldTimeEpochRun(){} 1413 1414 virtual bool calculateValue(void); _draw(dg_DrawArgs * pDA)1415 virtual void _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); } needsFrequentUpdates()1416 virtual UT_uint32 needsFrequentUpdates(){return FIELD_UPDATE_TIME;}; 1417 }; 1418 1419 class ABI_EXPORT fp_FieldDateTimeCustomRun : public fp_FieldRun 1420 { 1421 public: 1422 fp_FieldDateTimeCustomRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 1423 ~fp_FieldDateTimeCustomRun()1424 virtual ~fp_FieldDateTimeCustomRun(){} 1425 1426 virtual bool calculateValue(void); _draw(dg_DrawArgs * pDA)1427 virtual void _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); } needsFrequentUpdates()1428 virtual UT_uint32 needsFrequentUpdates(){return FIELD_UPDATE_TIME;}; 1429 }; 1430 1431 // your time zone (EST, for example) 1432 class ABI_EXPORT fp_FieldTimeZoneRun : public fp_FieldRun 1433 { 1434 public: 1435 fp_FieldTimeZoneRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 1436 ~fp_FieldTimeZoneRun()1437 virtual ~fp_FieldTimeZoneRun(){} 1438 1439 virtual bool calculateValue(void); _draw(dg_DrawArgs * pDA)1440 virtual void _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); } 1441 }; 1442 1443 // application runs 1444 1445 // build id 1446 class ABI_EXPORT fp_FieldBuildIdRun : public fp_FieldRun 1447 { 1448 public: 1449 fp_FieldBuildIdRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 1450 ~fp_FieldBuildIdRun()1451 virtual ~fp_FieldBuildIdRun(){} 1452 1453 virtual bool calculateValue(void); _draw(dg_DrawArgs * pDA)1454 virtual void _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); } 1455 }; 1456 1457 // build version (i.e. 0.7.13) 1458 class ABI_EXPORT fp_FieldBuildVersionRun : public fp_FieldRun 1459 { 1460 public: 1461 fp_FieldBuildVersionRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 1462 ~fp_FieldBuildVersionRun()1463 virtual ~fp_FieldBuildVersionRun(){} 1464 1465 virtual bool calculateValue(void); _draw(dg_DrawArgs * pDA)1466 virtual void _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); } 1467 }; 1468 1469 class ABI_EXPORT fp_FieldBuildOptionsRun : public fp_FieldRun 1470 { 1471 public: 1472 fp_FieldBuildOptionsRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 1473 ~fp_FieldBuildOptionsRun()1474 virtual ~fp_FieldBuildOptionsRun(){} 1475 1476 virtual bool calculateValue(void); _draw(dg_DrawArgs * pDA)1477 virtual void _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); } 1478 }; 1479 1480 class ABI_EXPORT fp_FieldBuildTargetRun : public fp_FieldRun 1481 { 1482 public: 1483 fp_FieldBuildTargetRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 1484 ~fp_FieldBuildTargetRun()1485 virtual ~fp_FieldBuildTargetRun(){} 1486 1487 virtual bool calculateValue(void); _draw(dg_DrawArgs * pDA)1488 virtual void _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); } 1489 }; 1490 1491 class ABI_EXPORT fp_FieldBuildCompileDateRun : public fp_FieldRun 1492 { 1493 public: 1494 fp_FieldBuildCompileDateRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 1495 ~fp_FieldBuildCompileDateRun()1496 virtual ~fp_FieldBuildCompileDateRun (){} 1497 1498 virtual bool calculateValue(void); _draw(dg_DrawArgs * pDA)1499 virtual void _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); } 1500 }; 1501 1502 class ABI_EXPORT fp_FieldBuildCompileTimeRun : public fp_FieldRun 1503 { 1504 public: 1505 fp_FieldBuildCompileTimeRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 1506 ~fp_FieldBuildCompileTimeRun()1507 virtual ~fp_FieldBuildCompileTimeRun(){} 1508 1509 virtual bool calculateValue(void); _draw(dg_DrawArgs * pDA)1510 virtual void _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); } 1511 }; 1512 1513 class ABI_EXPORT fp_FieldMailMergeRun : public fp_FieldRun 1514 { 1515 public: 1516 fp_FieldMailMergeRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); 1517 ~fp_FieldMailMergeRun()1518 virtual ~fp_FieldMailMergeRun(){} 1519 1520 virtual bool calculateValue(void); _draw(dg_DrawArgs * pDA)1521 virtual void _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); } 1522 needsFrequentUpdates()1523 virtual UT_uint32 needsFrequentUpdates(){ return FIELD_UPDATE_MAILMERGE; } 1524 }; 1525 1526 class ABI_EXPORT fp_FieldMetaRun : public fp_FieldRun 1527 { 1528 public: 1529 fp_FieldMetaRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen, const char * which); 1530 ~fp_FieldMetaRun()1531 virtual ~fp_FieldMetaRun(){} 1532 1533 virtual bool calculateValue(void); _draw(dg_DrawArgs * pDA)1534 virtual void _draw(dg_DrawArgs* pDA) { _defaultDraw(pDA); } 1535 needsFrequentUpdates()1536 virtual UT_uint32 needsFrequentUpdates(){ return FIELD_UPDATE_META;} 1537 1538 private: 1539 std::string m_which; 1540 }; 1541 1542 class ABI_EXPORT fp_FieldMetaTitleRun : public fp_FieldMetaRun 1543 { 1544 public: 1545 fp_FieldMetaTitleRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); ~fp_FieldMetaTitleRun()1546 virtual ~fp_FieldMetaTitleRun(){} 1547 }; 1548 1549 class ABI_EXPORT fp_FieldMetaCreatorRun : public fp_FieldMetaRun 1550 { 1551 public: 1552 fp_FieldMetaCreatorRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); ~fp_FieldMetaCreatorRun()1553 virtual ~fp_FieldMetaCreatorRun(){} 1554 }; 1555 1556 class ABI_EXPORT fp_FieldMetaSubjectRun : public fp_FieldMetaRun 1557 { 1558 public: 1559 fp_FieldMetaSubjectRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); ~fp_FieldMetaSubjectRun()1560 virtual ~fp_FieldMetaSubjectRun(){} 1561 }; 1562 1563 class ABI_EXPORT fp_FieldMetaPublisherRun : public fp_FieldMetaRun 1564 { 1565 public: 1566 fp_FieldMetaPublisherRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); ~fp_FieldMetaPublisherRun()1567 virtual ~fp_FieldMetaPublisherRun(){} 1568 }; 1569 1570 class ABI_EXPORT fp_FieldMetaDateRun : public fp_FieldMetaRun 1571 { 1572 public: 1573 fp_FieldMetaDateRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); ~fp_FieldMetaDateRun()1574 virtual ~fp_FieldMetaDateRun(){} 1575 }; 1576 1577 class ABI_EXPORT fp_FieldMetaDateLastChangedRun : public fp_FieldMetaRun 1578 { 1579 public: 1580 fp_FieldMetaDateLastChangedRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); ~fp_FieldMetaDateLastChangedRun()1581 virtual ~fp_FieldMetaDateLastChangedRun(){} 1582 }; 1583 1584 class ABI_EXPORT fp_FieldMetaTypeRun : public fp_FieldMetaRun 1585 { 1586 public: 1587 fp_FieldMetaTypeRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); ~fp_FieldMetaTypeRun()1588 virtual ~fp_FieldMetaTypeRun(){} 1589 }; 1590 1591 class ABI_EXPORT fp_FieldMetaLanguageRun : public fp_FieldMetaRun 1592 { 1593 public: 1594 fp_FieldMetaLanguageRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); ~fp_FieldMetaLanguageRun()1595 virtual ~fp_FieldMetaLanguageRun(){} 1596 }; 1597 1598 class ABI_EXPORT fp_FieldMetaRightsRun : public fp_FieldMetaRun 1599 { 1600 public: 1601 fp_FieldMetaRightsRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); ~fp_FieldMetaRightsRun()1602 virtual ~fp_FieldMetaRightsRun(){} 1603 }; 1604 1605 class ABI_EXPORT fp_FieldMetaKeywordsRun : public fp_FieldMetaRun 1606 { 1607 public: 1608 fp_FieldMetaKeywordsRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); ~fp_FieldMetaKeywordsRun()1609 virtual ~fp_FieldMetaKeywordsRun(){} 1610 }; 1611 1612 class ABI_EXPORT fp_FieldMetaContributorRun : public fp_FieldMetaRun 1613 { 1614 public: 1615 fp_FieldMetaContributorRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); ~fp_FieldMetaContributorRun()1616 virtual ~fp_FieldMetaContributorRun(){} 1617 }; 1618 1619 class ABI_EXPORT fp_FieldMetaCoverageRun : public fp_FieldMetaRun 1620 { 1621 public: 1622 fp_FieldMetaCoverageRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); ~fp_FieldMetaCoverageRun()1623 virtual ~fp_FieldMetaCoverageRun(){} 1624 }; 1625 1626 class ABI_EXPORT fp_FieldMetaDescriptionRun : public fp_FieldMetaRun 1627 { 1628 public: 1629 fp_FieldMetaDescriptionRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst, UT_uint32 iLen); ~fp_FieldMetaDescriptionRun()1630 virtual ~fp_FieldMetaDescriptionRun(){} 1631 }; 1632 1633 // END DOM 1634 1635 class ABI_EXPORT fp_FmtMarkRun : public fp_Run 1636 { 1637 public: 1638 fp_FmtMarkRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst); 1639 1640 virtual void mapXYToPosition(UT_sint32 xPos, UT_sint32 yPos, PT_DocPosition& pos, bool& bBOL, bool& bEOL, bool & isTOC); 1641 virtual void findPointCoords(UT_uint32 iOffset, UT_sint32& x, UT_sint32& y, UT_sint32& x2, UT_sint32& y2, UT_sint32& height, bool& bDirection); 1642 virtual bool canBreakAfter(void) const; 1643 virtual bool canBreakBefore(void) const; 1644 virtual bool isSuperscript(void) const ; 1645 virtual bool isSubscript(void) const; hasLayoutProperties(void)1646 virtual bool hasLayoutProperties(void) const {return true;} 1647 1648 protected: 1649 virtual void _lookupProperties(const PP_AttrProp * pSpanAP, 1650 const PP_AttrProp * pBlockAP, 1651 const PP_AttrProp * pSectionAP, 1652 GR_Graphics * pG = NULL); 1653 1654 virtual void _draw(dg_DrawArgs*); 1655 virtual void _clearScreen(bool bFullLineHeightRect); 1656 virtual bool _letPointPass(void) const; 1657 1658 private: 1659 enum 1660 { 1661 TEXT_POSITION_NORMAL, 1662 TEXT_POSITION_SUPERSCRIPT, 1663 TEXT_POSITION_SUBSCRIPT 1664 }; 1665 UT_Byte m_fPosition; 1666 }; 1667 1668 1669 class ABI_EXPORT fp_DummyRun : public fp_Run 1670 { 1671 public: 1672 fp_DummyRun(fl_BlockLayout* pBL, UT_uint32 iOffsetFirst); 1673 1674 virtual void mapXYToPosition(UT_sint32 xPos, UT_sint32 yPos, PT_DocPosition& pos, bool& bBOL, bool& bEOL, bool &isTOC); 1675 virtual void findPointCoords(UT_uint32 iOffset, UT_sint32& x, UT_sint32& y, UT_sint32& x2, UT_sint32& y2, UT_sint32& height, bool& bDirection); 1676 virtual bool canBreakAfter(void) const; 1677 virtual bool canBreakBefore(void) const; 1678 virtual bool isSuperscript(void) const ; 1679 virtual bool isSubscript(void) const; hasLayoutProperties(void)1680 virtual bool hasLayoutProperties(void) const {return false;} 1681 1682 protected: 1683 virtual void _lookupProperties(const PP_AttrProp * pSpanAP, 1684 const PP_AttrProp * pBlockAP, 1685 const PP_AttrProp * pSectionAP, 1686 GR_Graphics * pG = NULL); 1687 1688 virtual void _draw(dg_DrawArgs*); 1689 virtual void _clearScreen(bool bFullLineHeightRect); 1690 virtual bool _letPointPass(void) const; 1691 }; 1692 1693 #endif /* FP_RUN_H */ 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704