binfilter/inc/bf_starmath/node.hxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: node.hxx,v $
  10  * $Revision: 1.6 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31
  32 #ifndef NODE_HXX
  33 #define NODE_HXX
  34
  35
  36 #ifndef _DYNARY_HXX //autogen
  37 #include <tools/dynary.hxx>
  38 #endif
  39
  40 #include "parse.hxx"
  41 #include "types.hxx"
  42 #include "rect.hxx"
  43 #include "format.hxx"
  44 namespace binfilter {
  45
  46
  47 #define ATTR_BOLD               0x0001
  48 #define ATTR_ITALIC             0x0002
  49
  50 #define FNTSIZ_ABSOLUT  1
  51 #define FNTSIZ_PLUS     2
  52 #define FNTSIZ_MINUS    3
  53 #define FNTSIZ_MULTIPLY 4
  54 #define FNTSIZ_DIVIDE   5
  55
  56 // flags to interdict respective status changes
  57 #define FLG_FONT                0x0001
  58 #define FLG_SIZE                0x0002
  59 #define FLG_BOLD                0x0004
  60 #define FLG_ITALIC              0x0008
  61 #define FLG_COLOR               0x0010
  62 #define FLG_VISIBLE             0x0020
  63 #define FLG_HORALIGN    0x0040
  64
  65
  66 extern SmFormat *pActiveFormat;
  67
  68 class SmDocShell;
  69
  70 class SmNode;
  71 DECLARE_DYNARRAY(SmNodeArray, SmNode *)//STRIP008 ;
  72
  73 ////////////////////////////////////////////////////////////////////////////////
  74
  75 enum SmScaleMode        { SCALE_NONE, SCALE_WIDTH, SCALE_HEIGHT };
  76
  77 enum SmNodeType
  78 {
  79     NTABLE,                     NBRACE,                 NBRACEBODY,             NOPER,                  NALIGN,
  80     NATTRIBUT,          NFONT,                  NUNHOR,                 NBINHOR,                NBINVER,
  81     NBINDIAGONAL,       NSUBSUP,                NMATRIX,                NPLACE,                 NTEXT,
  82     NSPECIAL,           NGLYPH_SPECIAL, NMATH,                  NBLANK,                 NERROR,
  83     NLINE,          NEXPRESSION,    NPOLYLINE,      NROOT,          NROOTSYMBOL,
  84     NRECTANGLE,     NVERTICAL_BRACE
  85 };
  86
  87
  88 ////////////////////////////////////////////////////////////////////////////////
  89
  90
  91 class SmNode : public SmRect
  92 {
  93     SmFace          aFace;
  94
  95     SmToken                     aNodeToken;
  96     SmNodeType          eType;
  97     SmScaleMode         eScaleMode;
  98     RectHorAlign        eRectHorAlign;
  99     USHORT                      nFlags,
 100                     nAttributes;
 101     BOOL                        bIsPhantom,
 102                     bIsDebug;
 103 protected:
 104     SmNode(SmNodeType eNodeType, const SmToken &rNodeToken);
 105
 106     // index in accessible text -1 if not (yet) applicable
 107     sal_Int32       nAccIndex;
 108
 109 public:
 110     virtual                     ~SmNode();
 111
 112     virtual BOOL        IsVisible() const;
 113
 114     virtual USHORT      GetNumSubNodes() const;
 115     virtual SmNode *    GetSubNode(USHORT nIndex);
 116             const SmNode * GetSubNode(USHORT nIndex) const
 117             {
 118                 return ((SmNode *) this)->GetSubNode(nIndex);
 119             }
 120
 121     virtual SmNode *       GetLeftMost();
 122             const SmNode * GetLeftMost() const
 123             {
 124                 return ((SmNode *) this)->GetLeftMost();
 125             }
 126
 127             USHORT &    Flags() { return nFlags; }
 128             USHORT &    Attributes() { return nAttributes; }
 129
 130             BOOL IsDebug() const { return bIsDebug; }
 131             BOOL IsPhantom() const { return bIsPhantom; }
 132             void SetPhantom(BOOL bIsPhantom);
 133             void SetColor(const Color &rColor);
 134
 135             void SetAttribut(USHORT nAttrib);
 136             void ClearAttribut(USHORT nAttrib);
 137
 138             const SmFace & GetFont() const { return aFace; };
 139                   SmFace & GetFont()       { return aFace; };
 140
 141             void SetFont(const SmFace &rFace);
 142             void SetFontSize(const Fraction &rRelSize, USHORT nType);
 143             void SetSize(const Fraction &rScale);
 144
 145     virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell);
 146     virtual void PrepareAttributes();
 147
 148
 149     void         SetRectHorAlign(RectHorAlign eHorAlign, BOOL bApplyToSubTree = TRUE );
 150     RectHorAlign GetRectHorAlign() const { return eRectHorAlign; }
 151
 152     const SmRect & GetRect() const { return *this; }
 153           SmRect & GetRect()       { return *this; }
 154
 155     virtual void Move(const Point &rPosition);
 156     void MoveTo(const Point &rPosition) { Move(rPosition - GetTopLeft()); }
 157     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat);
 158     virtual void CreateTextFromNode(String &rText);
 159
 160     virtual void Draw(OutputDevice &rDev, const Point &rPosition) const;
 161
 162
 163     USHORT      GetRow() const    { return (USHORT)aNodeToken.nRow; }
 164     USHORT      GetColumn() const { return (USHORT)aNodeToken.nCol; }
 165
 166     SmScaleMode         GetScaleMode() const { return eScaleMode; }
 167     void                        SetScaleMode(SmScaleMode eMode) { eScaleMode = eMode; }
 168
 169     virtual void AdaptToX(const OutputDevice &rDev, ULONG nWidth);
 170     virtual void AdaptToY(const OutputDevice &rDev, ULONG nHeight);
 171
 172     SmNodeType          GetType() const  { return eType; }
 173     const SmToken &     GetToken() const { return aNodeToken; }
 174
 175     const SmNode *      FindTokenAt(USHORT nRow, USHORT nCol) const;
 176 };
 177
 178
 179 ////////////////////////////////////////////////////////////////////////////////
 180
 181 class SmStructureNode;
 182
 183 DECLARE_DYNARRAY(SmStructureNodeArray, SmStructureNode *)//STRIP008 ;
 184
 185 class SmStructureNode : public SmNode
 186 {
 187     SmNodeArray  aSubNodes;
 188
 189 protected:
 190     SmStructureNode(SmNodeType eNodeType, const SmToken &rNodeToken)
 191     :   SmNode(eNodeType, rNodeToken)
 192     {}
 193
 194 public:
 195              SmStructureNode( const SmStructureNode &rNode );
 196     virtual ~SmStructureNode();
 197
 198     virtual BOOL                IsVisible() const;
 199
 200     virtual USHORT              GetNumSubNodes() const;
 201             void                SetNumSubNodes(USHORT nSize) { aSubNodes.SetSize(nSize); }
 202
 203     virtual     SmNode *        GetSubNode(USHORT nIndex);
 204             void SetSubNodes(SmNode *pFirst, SmNode *pSecond,
 205                                 SmNode *pThird = NULL);
 206             void SetSubNodes(const SmNodeArray &rNodeArray);
 207
 208      virtual SmStructureNode & operator = ( const SmStructureNode &rNode );
 209
 210 };
 211
 212
 213 ////////////////////////////////////////////////////////////////////////////////
 214
 215
 216 class SmVisibleNode : public SmNode
 217 {
 218 protected:
 219     SmVisibleNode(SmNodeType eNodeType, const SmToken &rNodeToken)
 220     :   SmNode(eNodeType, rNodeToken)
 221     {}
 222
 223 public:
 224
 225     virtual BOOL                IsVisible() const;
 226     virtual     USHORT          GetNumSubNodes() const;
 227     virtual SmNode *    GetSubNode(USHORT nIndex);
 228 };
 229
 230
 231 ////////////////////////////////////////////////////////////////////////////////
 232
 233
 234 class SmGraphicNode : public SmVisibleNode
 235 {
 236 protected:
 237     SmGraphicNode(SmNodeType eNodeType, const SmToken &rNodeToken)
 238     :   SmVisibleNode(eNodeType, rNodeToken)
 239     {}
 240
 241 public:
 242
 243 };
 244
 245
 246 ////////////////////////////////////////////////////////////////////////////////
 247
 248
 249 class SmRectangleNode : public SmGraphicNode
 250 {
 251     Size  aToSize;
 252
 253 public:
 254     SmRectangleNode(const SmToken &rNodeToken)
 255     :   SmGraphicNode(NRECTANGLE, rNodeToken)
 256     {}
 257
 258     virtual void AdaptToX(const OutputDevice &rDev, ULONG nWidth);
 259     virtual void AdaptToY(const OutputDevice &rDev, ULONG nHeight);
 260
 261     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat);
 262     virtual void Draw(OutputDevice &rDev, const Point &rPosition) const;
 263 };
 264
 265
 266 ////////////////////////////////////////////////////////////////////////////////
 267
 268
 269 class SmPolyLineNode : public SmGraphicNode
 270 {
 271     Polygon             aPoly;
 272     Size                aToSize;
 273     long                nWidth;
 274
 275 public:
 276     SmPolyLineNode(const SmToken &rNodeToken);
 277
 278     long                 GetWidth() const { return nWidth; }
 279
 280     virtual void AdaptToX(const OutputDevice &rDev, ULONG nWidth);
 281     virtual void AdaptToY(const OutputDevice &rDev, ULONG nHeight);
 282
 283     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat);
 284     virtual void Draw(OutputDevice &rDev, const Point &rPosition) const;
 285 };
 286
 287
 288 ////////////////////////////////////////////////////////////////////////////////
 289
 290
 291 class SmTextNode : public SmVisibleNode
 292 {
 293     XubString   aText;
 294     USHORT      nFontDesc;
 295
 296 protected:
 297     SmTextNode(SmNodeType eNodeType, const SmToken &rNodeToken, USHORT nFontDescP)
 298     :   SmVisibleNode(eNodeType, rNodeToken)
 299     {
 300         nFontDesc = nFontDescP;
 301     }
 302
 303 public:
 304     SmTextNode(const SmToken &rNodeToken, USHORT nFontDescP)
 305     :   SmVisibleNode(NTEXT, rNodeToken)
 306     {
 307         nFontDesc = nFontDescP;
 308     }
 309
 310
 311     USHORT                              GetFontDesc() const { return nFontDesc; }
 312     void                                SetText(const XubString &rText) { aText = rText; }
 313     const XubString &   GetText() const { return aText; }
 314
 315     virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell);
 316     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat);
 317
 318     virtual void Draw(OutputDevice &rDev, const Point &rPosition) const;
 319
 320 };
 321
 322
 323 ////////////////////////////////////////////////////////////////////////////////
 324
 325
 326 class SmSpecialNode : public SmTextNode
 327 {
 328 protected:
 329     SmSpecialNode(SmNodeType eNodeType, const SmToken &rNodeToken, USHORT nFontDesc)
 330     :   SmTextNode(eNodeType, rNodeToken, nFontDesc)
 331     {}
 332
 333 public:
 334     SmSpecialNode(const SmToken &rNodeToken)
 335     :   SmTextNode(NSPECIAL, rNodeToken, FNT_MATH)      //! default Font nicht immer richtig
 336     {}
 337
 338     virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell);
 339     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat);
 340     virtual void Draw(OutputDevice &rDev, const Point &rPosition) const;
 341 };
 342
 343
 344 ////////////////////////////////////////////////////////////////////////////////
 345
 346
 347 class SmGlyphSpecialNode : public SmSpecialNode
 348 {
 349 public:
 350     SmGlyphSpecialNode(const SmToken &rNodeToken)
 351     :   SmSpecialNode(NGLYPH_SPECIAL, rNodeToken, FNT_MATH)
 352     {}
 353
 354     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat);
 355 };
 356
 357
 358 ////////////////////////////////////////////////////////////////////////////////
 359
 360
 361 class SmMathSymbolNode : public SmSpecialNode
 362 {
 363 protected:
 364     SmMathSymbolNode(SmNodeType eNodeType, const SmToken &rNodeToken)
 365     :   SmSpecialNode(eNodeType, rNodeToken, FNT_MATH)
 366     {
 367         xub_Unicode cChar = GetToken().cMathChar;
 368         if ((xub_Unicode) '\0' != cChar)
 369             SetText( cChar );
 370     }
 371
 372 public:
 373     SmMathSymbolNode(const SmToken &rNodeToken);
 374
 375     virtual void AdaptToX(const OutputDevice &rDev, ULONG nWidth);
 376     virtual void AdaptToY(const OutputDevice &rDev, ULONG nHeight);
 377
 378     virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell);
 379     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat);
 380 };
 381
 382
 383 ////////////////////////////////////////////////////////////////////////////////
 384
 385
 386 class SmRootSymbolNode : public SmMathSymbolNode
 387 {
 388     ULONG  nBodyWidth;  // width of body (argument) of root sign
 389
 390 public:
 391     SmRootSymbolNode(const SmToken &rNodeToken)
 392     :   SmMathSymbolNode(NROOTSYMBOL, rNodeToken)
 393     {}
 394
 395     virtual void AdaptToX(const OutputDevice &rDev, ULONG nWidth);
 396     virtual void AdaptToY(const OutputDevice &rDev, ULONG nHeight);
 397
 398     virtual void Draw(OutputDevice &rDev, const Point &rPosition) const;
 399 };
 400
 401
 402 ////////////////////////////////////////////////////////////////////////////////
 403
 404
 405 class SmPlaceNode : public SmMathSymbolNode
 406 {
 407 public:
 408     SmPlaceNode(const SmToken &rNodeToken)
 409     :   SmMathSymbolNode(NPLACE, rNodeToken)
 410     {
 411         SetText((xub_Unicode) MS_PLACE);
 412     }
 413
 414     virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell);
 415     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat);
 416 };
 417
 418
 419 ////////////////////////////////////////////////////////////////////////////////
 420
 421
 422 class SmErrorNode : public SmMathSymbolNode
 423 {
 424 public:
 425     SmErrorNode(SmParseError eError, const SmToken &rNodeToken)
 426     :   SmMathSymbolNode(NERROR, rNodeToken)
 427     {
 428         SetText((xub_Unicode) MS_ERROR);
 429     }
 430
 431     virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell);
 432     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat);
 433 };
 434
 435
 436 ////////////////////////////////////////////////////////////////////////////////
 437
 438
 439 class SmTableNode : public SmStructureNode
 440 {
 441 public:
 442     SmTableNode(const SmToken &rNodeToken)
 443     :   SmStructureNode(NTABLE, rNodeToken)
 444     {}
 445
 446     virtual SmNode * GetLeftMost();
 447
 448     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat);
 449 };
 450
 451
 452 ////////////////////////////////////////////////////////////////////////////////
 453
 454
 455 class SmLineNode : public SmStructureNode
 456 {
 457 protected:
 458     SmLineNode(SmNodeType eNodeType, const SmToken &rNodeToken)
 459     :   SmStructureNode(eNodeType, rNodeToken)
 460     {}
 461
 462 public:
 463     SmLineNode(const SmToken &rNodeToken)
 464     :   SmStructureNode(NLINE, rNodeToken)
 465     {}
 466
 467     virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell);
 468     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat);
 469 };
 470
 471
 472 ////////////////////////////////////////////////////////////////////////////////
 473
 474
 475 class SmExpressionNode : public SmLineNode
 476 {
 477 public:
 478     SmExpressionNode(const SmToken &rNodeToken)
 479     :   SmLineNode(NEXPRESSION, rNodeToken)
 480     {}
 481
 482     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat);
 483 };
 484
 485
 486 ////////////////////////////////////////////////////////////////////////////////
 487
 488
 489 class SmUnHorNode : public SmStructureNode
 490 {
 491 public:
 492     SmUnHorNode(const SmToken &rNodeToken)
 493     :   SmStructureNode(NUNHOR, rNodeToken)
 494     {
 495         SetNumSubNodes(2);
 496     }
 497
 498     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat);
 499 };
 500
 501
 502 ////////////////////////////////////////////////////////////////////////////////
 503
 504
 505 class SmRootNode : public SmStructureNode
 506 {
 507 protected:
 508     void   GetHeightVerOffset(const SmRect &rRect,
 509                               long &rHeight, long &rVerOffset) const;
 510     Point  GetExtraPos(const SmRect &rRootSymbol, const SmRect &rExtra) const;
 511
 512 public:
 513     SmRootNode(const SmToken &rNodeToken)
 514     :   SmStructureNode(NROOT, rNodeToken)
 515     {
 516         SetNumSubNodes(3);
 517     }
 518
 519     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat);
 520 };
 521
 522
 523 ////////////////////////////////////////////////////////////////////////////////
 524
 525
 526 class SmBinHorNode : public SmStructureNode
 527 {
 528 public:
 529     SmBinHorNode(const SmToken &rNodeToken)
 530     :   SmStructureNode(NBINHOR, rNodeToken)
 531     {
 532         SetNumSubNodes(3);
 533     }
 534
 535     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat);
 536 };
 537
 538
 539 ////////////////////////////////////////////////////////////////////////////////
 540
 541
 542 class SmBinVerNode : public SmStructureNode
 543 {
 544 public:
 545     SmBinVerNode(const SmToken &rNodeToken)
 546     :   SmStructureNode(NBINVER, rNodeToken)
 547     {
 548         SetNumSubNodes(3);
 549     }
 550
 551     virtual SmNode * GetLeftMost();
 552
 553     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat);
 554 };
 555
 556
 557 ////////////////////////////////////////////////////////////////////////////////
 558
 559
 560 class SmBinDiagonalNode : public SmStructureNode
 561 {
 562    BOOL    bAscending;
 563
 564    void    GetOperPosSize(Point &rPos, Size &rSize,
 565                           const Point &rDiagPoint, double fAngleDeg) const;
 566
 567 public:
 568    SmBinDiagonalNode(const SmToken &rNodeToken);
 569
 570    BOOL    IsAscending() const { return bAscending; }
 571    void    SetAscending(BOOL bVal)  { bAscending = bVal; }
 572
 573    virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat);
 574 };
 575
 576
 577 ////////////////////////////////////////////////////////////////////////////////
 578
 579
 580 // enums used to index sub-/supscripts in the 'aSubNodes' array
 581 // in 'SmSubSupNode'
 582 // See graphic for positions at char:
 583 //
 584 //              CSUP
 585 //
 586 // LSUP H  H RSUP
 587 //              H  H
 588 //              HHHH
 589 //              H  H
 590 // LSUB H  H RSUB
 591 //
 592 //              CSUB
 593 //
 594 enum SmSubSup
 595 {       CSUB, CSUP, RSUB, RSUP, LSUB, LSUP
 596 };
 597
 598 // numbers of entries in the above enum (that is: the number of possible
 599 // sub-/supscripts)
 600 #define SUBSUP_NUM_ENTRIES 6
 601
 602
 603 class SmSubSupNode : public SmStructureNode
 604 {
 605     BOOL  bUseLimits;
 606
 607 public:
 608     SmSubSupNode(const SmToken &rNodeToken)
 609     :   SmStructureNode(NSUBSUP, rNodeToken)
 610     {
 611         SetNumSubNodes(1 + SUBSUP_NUM_ENTRIES);
 612         bUseLimits = FALSE;
 613     }
 614
 615     SmNode *       GetBody()    { return GetSubNode(0); }
 616     const SmNode * GetBody() const
 617     {
 618         return ((SmSubSupNode *) this)->GetBody();
 619     }
 620
 621     void  SetUseLimits(BOOL bVal) { bUseLimits = bVal; }
 622     BOOL  IsUseLimits() const { return bUseLimits; };
 623
 624     SmNode * GetSubSup(SmSubSup eSubSup) { return GetSubNode(1 + eSubSup); };
 625
 626     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat);
 627
 628 };
 629
 630
 631 ////////////////////////////////////////////////////////////////////////////////
 632
 633
 634 class SmBraceNode : public SmStructureNode
 635 {
 636 public:
 637     SmBraceNode(const SmToken &rNodeToken)
 638     :   SmStructureNode(NBRACE, rNodeToken)
 639     {
 640         SetNumSubNodes(3);
 641     }
 642
 643     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat);
 644 };
 645
 646
 647 ////////////////////////////////////////////////////////////////////////////////
 648
 649
 650 class SmBracebodyNode : public SmStructureNode
 651 {
 652     long  nBodyHeight;
 653
 654 public:
 655     inline SmBracebodyNode(const SmToken &rNodeToken);
 656
 657     virtual void        Arrange(const OutputDevice &rDev, const SmFormat &rFormat);
 658     long                    GetBodyHeight() const { return nBodyHeight; }
 659 };
 660
 661
 662 inline SmBracebodyNode::SmBracebodyNode(const SmToken &rNodeToken) :
 663     SmStructureNode(NBRACEBODY, rNodeToken)
 664 {
 665     nBodyHeight = 0;
 666 }
 667
 668
 669 ////////////////////////////////////////////////////////////////////////////////
 670
 671
 672 class SmVerticalBraceNode : public SmStructureNode
 673 {
 674 public:
 675     inline SmVerticalBraceNode(const SmToken &rNodeToken);
 676
 677     virtual void    Arrange(const OutputDevice &rDev, const SmFormat &rFormat);
 678 };
 679
 680
 681 inline SmVerticalBraceNode::SmVerticalBraceNode(const SmToken &rNodeToken) :
 682     SmStructureNode(NVERTICAL_BRACE, rNodeToken)
 683 {
 684     SetNumSubNodes(3);
 685 }
 686
 687
 688 ////////////////////////////////////////////////////////////////////////////////
 689
 690
 691 class SmOperNode : public SmStructureNode
 692 {
 693 public:
 694     SmOperNode(const SmToken &rNodeToken)
 695     :   SmStructureNode(NOPER, rNodeToken)
 696     {
 697         SetNumSubNodes(2);
 698     }
 699
 700     SmNode *       GetSymbol();
 701     const SmNode * GetSymbol() const
 702     {
 703         return ((SmOperNode *) this)->GetSymbol();
 704     }
 705
 706     long CalcSymbolHeight(const SmNode &rSymbol, const SmFormat &rFormat) const;
 707
 708     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat);
 709 };
 710
 711
 712 ////////////////////////////////////////////////////////////////////////////////
 713
 714
 715 class SmAlignNode : public SmStructureNode
 716 {
 717 public:
 718     SmAlignNode(const SmToken &rNodeToken)
 719     :   SmStructureNode(NALIGN, rNodeToken)
 720     {}
 721
 722     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat);
 723 };
 724
 725
 726 ////////////////////////////////////////////////////////////////////////////////
 727
 728
 729 class SmAttributNode : public SmStructureNode
 730 {
 731 public:
 732     SmAttributNode(const SmToken &rNodeToken)
 733     :   SmStructureNode(NATTRIBUT, rNodeToken)
 734     {}
 735
 736     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat);
 737 };
 738
 739
 740 ////////////////////////////////////////////////////////////////////////////////
 741
 742
 743 class SmFontNode : public SmStructureNode
 744 {
 745     USHORT              nSizeType;
 746     Fraction    aFontSize;
 747
 748 public:
 749     SmFontNode(const SmToken &rNodeToken)
 750     :   SmStructureNode(NFONT, rNodeToken)
 751     {
 752         nSizeType = FNTSIZ_MULTIPLY;
 753         aFontSize = Fraction(1L);
 754     }
 755
 756     void SetSizeParameter(const Fraction &rValue, USHORT nType);
 757     const Fraction & GetSizeParameter() const {return aFontSize;}
 758     const USHORT& GetSizeType() const {return nSizeType;}
 759
 760     virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell);
 761     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat);
 762 };
 763
 764
 765 ////////////////////////////////////////////////////////////////////////////////
 766
 767
 768 class SmMatrixNode : public SmStructureNode
 769 {
 770     USHORT      nNumRows,
 771             nNumCols;
 772
 773 public:
 774     SmMatrixNode(const SmToken &rNodeToken)
 775     :   SmStructureNode(NMATRIX, rNodeToken)
 776     {
 777         nNumRows = nNumCols = 0;
 778     }
 779
 780     USHORT GetNumRows() const {return nNumRows;}
 781     USHORT GetNumCols() const {return nNumCols;}
 782     void SetRowCol(USHORT nMatrixRows, USHORT nMatrixCols);
 783
 784     virtual SmNode * GetLeftMost();
 785
 786     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat);
 787 };
 788
 789
 790 ////////////////////////////////////////////////////////////////////////////////
 791
 792
 793 class SmBlankNode : public SmGraphicNode
 794 {
 795     USHORT      nNum;
 796
 797 public:
 798     SmBlankNode(const SmToken &rNodeToken)
 799     :   SmGraphicNode(NBLANK, rNodeToken)
 800     {
 801         nNum = 0;
 802     }
 803
 804     void         IncreaseBy(const SmToken &rToken);
 805     void                 Clear() { nNum = 0; }
 806
 807     virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell);
 808     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat);
 809 };
 810
 811
 812 ////////////////////////////////////////////////////////////////////////////////
 813
 814 } //namespace binfilter
 815 #endif
 816
 817