starmath/inc/node.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #ifndef INCLUDED_STARMATH_INC_NODE_HXX
  21 #define INCLUDED_STARMATH_INC_NODE_HXX
  22
  23 #include <vector>
  24 #include <ostream>
  25
  26 #include "types.hxx"
  27 #include "token.hxx"
  28 #include "error.hxx"
  29 #include "rect.hxx"
  30 #include "format.hxx"
  31 #include <boost/ptr_container/ptr_deque.hpp>
  32 #include <memory>
  33
  34 #define ATTR_BOLD       0x0001
  35 #define ATTR_ITALIC     0x0002
  36
  37
  38 enum class FontSizeType {
  39   ABSOLUT  = 1,
  40   PLUS     = 2,
  41   MINUS    = 3,
  42   MULTIPLY = 4,
  43   DIVIDE   = 5
  44 };
  45
  46 // flags to interdict respective status changes
  47 #define FLG_FONT        0x0001
  48 #define FLG_SIZE        0x0002
  49 #define FLG_BOLD        0x0004
  50 #define FLG_ITALIC      0x0008
  51 #define FLG_COLOR       0x0010
  52 #define FLG_VISIBLE     0x0020
  53 #define FLG_HORALIGN    0x0040
  54
  55
  56 extern SmFormat *pActiveFormat;
  57
  58 class SmVisitor;
  59 class SmDocShell;
  60 class SmNode;
  61 class SmStructureNode;
  62
  63 typedef std::shared_ptr<SmNode> SmNodePointer;
  64 typedef boost::ptr_deque<SmNode> SmNodeStack;
  65 typedef std::vector< SmNode * > SmNodeArray;
  66 typedef std::vector< SmStructureNode * > SmStructureNodeArray;
  67
  68 template < typename T >
  69 T* popOrZero( boost::ptr_deque<T> & rStack )
  70 {
  71     if (rStack.empty())
  72         return 0;
  73     auto pTmp = rStack.pop_front();
  74     return pTmp.release();
  75 }
  76
  77 enum SmScaleMode    { SCALE_NONE, SCALE_WIDTH, SCALE_HEIGHT };
  78
  79 enum SmNodeType
  80 {
  81 /* 0*/ NTABLE,         NBRACE,         NBRACEBODY,     NOPER,          NALIGN,
  82 /* 5*/ NATTRIBUT,      NFONT,          NUNHOR,         NBINHOR,        NBINVER,
  83 /*10*/ NBINDIAGONAL,   NSUBSUP,        NMATRIX,        NPLACE,         NTEXT,
  84 /*15*/ NSPECIAL,       NGLYPH_SPECIAL, NMATH,          NBLANK,         NERROR,
  85 /*20*/ NLINE,          NEXPRESSION,    NPOLYLINE,      NROOT,          NROOTSYMBOL,
  86 /*25*/ NRECTANGLE,  NVERTICAL_BRACE, NMATHIDENT,  NDYNINT, NDYNINTSYMBOL
  87 };
  88
  89
  90
  91
  92
  93 class SmNode : public SmRect
  94 {
  95     SmFace      aFace;
  96
  97     SmToken     aNodeToken;
  98     SmNodeType      eType;
  99     SmScaleMode     eScaleMode;
 100     RectHorAlign    eRectHorAlign;
 101     sal_uInt16          nFlags,
 102                     nAttributes;
 103     bool            bIsPhantom,
 104                     bIsDebug;
 105
 106     bool            bIsSelected;
 107
 108 protected:
 109     SmNode(SmNodeType eNodeType, const SmToken &rNodeToken);
 110
 111     // index in accessible text -1 if not (yet) applicable
 112     sal_Int32       nAccIndex;
 113
 114 public:
 115     virtual             ~SmNode();
 116
 117     virtual bool        IsVisible() const;
 118
 119     virtual sal_uInt16      GetNumSubNodes() const;
 120     virtual SmNode *    GetSubNode(sal_uInt16 nIndex);
 121             const SmNode * GetSubNode(sal_uInt16 nIndex) const
 122             {
 123                 return const_cast<SmNode *>(this)->GetSubNode(nIndex);
 124             }
 125
 126     virtual SmNode *       GetLeftMost();
 127             const SmNode * GetLeftMost() const
 128             {
 129                 return const_cast<SmNode *>(this)->GetLeftMost();
 130             }
 131
 132             sal_uInt16 &    Flags() { return nFlags; }
 133             sal_uInt16 &    Attributes() { return nAttributes; }
 134
 135             bool IsDebug() const { return bIsDebug; }
 136             bool IsPhantom() const { return bIsPhantom; }
 137             void SetPhantom(bool bIsPhantom);
 138             void SetColor(const Color &rColor);
 139
 140             void SetAttribut(sal_uInt16 nAttrib);
 141             void ClearAttribut(sal_uInt16 nAttrib);
 142
 143             const SmFace & GetFont() const { return aFace; };
 144                   SmFace & GetFont()       { return aFace; };
 145
 146             void SetFont(const SmFace &rFace);
 147             void SetFontSize(const Fraction &rRelSize, FontSizeType nType);
 148             void SetSize(const Fraction &rScale);
 149
 150     virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell);
 151     void PrepareAttributes();
 152
 153     sal_uInt16 FindIndex() const;
 154
 155 #if OSL_DEBUG_LEVEL
 156             void ToggleDebug() const;
 157 #endif
 158
 159     void         SetRectHorAlign(RectHorAlign eHorAlign, bool bApplyToSubTree = true );
 160     RectHorAlign GetRectHorAlign() const { return eRectHorAlign; }
 161
 162     const SmRect & GetRect() const { return *this; }
 163           SmRect & GetRect()       { return *this; }
 164
 165     void Move(const Point &rPosition);
 166     void MoveTo(const Point &rPosition) { Move(rPosition - GetTopLeft()); }
 167     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat);
 168     virtual void CreateTextFromNode(OUString &rText);
 169
 170     virtual void    GetAccessibleText( OUStringBuffer &rText ) const;
 171     sal_Int32       GetAccessibleIndex() const { return nAccIndex; }
 172     const SmNode *  FindNodeWithAccessibleIndex(sal_Int32 nAccIndex) const;
 173
 174     sal_uInt16  GetRow() const    { return (sal_uInt16)aNodeToken.nRow; }
 175     sal_uInt16  GetColumn() const { return (sal_uInt16)aNodeToken.nCol; }
 176
 177     SmScaleMode     GetScaleMode() const { return eScaleMode; }
 178     void            SetScaleMode(SmScaleMode eMode) { eScaleMode = eMode; }
 179
 180     virtual void AdaptToX(const OutputDevice &rDev, sal_uLong nWidth);
 181     virtual void AdaptToY(const OutputDevice &rDev, sal_uLong nHeight);
 182
 183     SmNodeType      GetType() const  { return eType; }
 184     const SmToken & GetToken() const { return aNodeToken; }
 185
 186     const SmNode *  FindTokenAt(sal_uInt16 nRow, sal_uInt16 nCol) const;
 187     const SmNode *  FindRectClosestTo(const Point &rPoint) const;
 188
 189     virtual long    GetFormulaBaseline() const;
 190
 191     /** Accept a visitor
 192      * Calls the method for this class on the visitor
 193      */
 194     virtual void Accept(SmVisitor* pVisitor);
 195
 196     /** True if this node is selected */
 197     bool IsSelected() const {return bIsSelected;}
 198     void SetSelected(bool Selected = true) {bIsSelected = Selected;}
 199
 200 #ifdef DEBUG_ENABLE_DUMPASDOT
 201     /** The tree as dot graph for graphviz, usable for debugging
 202      * Convert the output to a image using $ dot graph.gv -Tpng > graph.png
 203      */
 204     inline void DumpAsDot(std::ostream &out, OUString* label = NULL) const{
 205         int id = 0;
 206         DumpAsDot(out, label, -1, id, -1);
 207     }
 208 #endif /* DEBUG_ENABLE_DUMPASDOT */
 209
 210     /** Get the parent node of this node */
 211     SmStructureNode* GetParent(){ return aParentNode; }
 212     const SmStructureNode* GetParent() const { return aParentNode; }
 213     /** Set the parent node */
 214     void SetParent(SmStructureNode* parent){
 215         aParentNode = parent;
 216     }
 217
 218     /** Get the index of a child node
 219      *
 220      * Returns -1, if pSubNode isn't a subnode of this.
 221      */
 222     int IndexOfSubNode(SmNode* pSubNode){
 223         sal_uInt16 nSize = GetNumSubNodes();
 224         for(sal_uInt16 i = 0; i < nSize; i++)
 225             if(pSubNode == GetSubNode(i))
 226                 return i;
 227         return -1;
 228     }
 229     /** Set the token for this node */
 230     void SetToken(SmToken& token){
 231         aNodeToken = token;
 232     }
 233 protected:
 234     /** Sets parent on children of this node */
 235     inline void ClaimPaternity();
 236 private:
 237     SmStructureNode* aParentNode;
 238     void DumpAsDot(std::ostream &out, OUString* label, int number, int& id, int parent) const;
 239 };
 240
 241
 242
 243 /** A simple auxiliary iterator class for SmNode
 244  *
 245  * Example of iteration over children of pMyNode:
 246  * \code
 247  *  //Node to iterate over:
 248  *  SmNode* pMyNode = 0;// A pointer from somewhere
 249  *  //The iterator:
 250  *  SmNodeIterator it(pMyNode);
 251  *  //The iteration:
 252  *  while(it.Next()) {
 253  *      it->SetSelected(true);
 254  *  }
 255  * \endcode
 256  */
 257 class SmNodeIterator{
 258 public:
 259     SmNodeIterator(SmNode* node, bool bReverse = false){
 260         pNode = node;
 261         nSize = pNode->GetNumSubNodes();
 262         nIndex = 0;
 263         pChildNode = NULL;
 264         bIsReverse = bReverse;
 265     }
 266     /** Get the subnode or NULL if none */
 267     SmNode* Next(){
 268         while(!bIsReverse && nIndex < nSize){
 269             if(NULL != (pChildNode = pNode->GetSubNode(nIndex++)))
 270                 return pChildNode;
 271         }
 272         while(bIsReverse && nSize > 0){
 273             if(NULL != (pChildNode = pNode->GetSubNode((nSize--)-1)))
 274                 return pChildNode;
 275         }
 276         pChildNode = NULL;
 277         return NULL;
 278     }
 279     /** Get the current child node, NULL if none */
 280     SmNode* Current(){
 281         return pChildNode;
 282     }
 283     /** Get the current child node, NULL if none */
 284     SmNode* operator->(){
 285         return pChildNode;
 286     }
 287 private:
 288     /** Current child */
 289     SmNode* pChildNode;
 290     /** Node whos children we're iterating over */
 291     SmNode* pNode;
 292     /** Size of the node */
 293     sal_uInt16 nSize;
 294     /** Current index in the node */
 295     sal_uInt16 nIndex;
 296     /** Move reverse */
 297     bool bIsReverse;
 298 };
 299
 300
 301
 302 /** Abstract baseclass for all composite node
 303  *
 304  * Subclasses of this class can have subnodes. Nodes that doesn't derivate from
 305  * this class does not have subnodes.
 306  */
 307 class SmStructureNode : public SmNode
 308 {
 309     SmNodeArray  aSubNodes;
 310
 311 protected:
 312     SmStructureNode(SmNodeType eNodeType, const SmToken &rNodeToken)
 313     :   SmNode(eNodeType, rNodeToken)
 314     {}
 315
 316 public:
 317             SmStructureNode( const SmStructureNode &rNode );
 318     virtual ~SmStructureNode();
 319
 320     virtual bool        IsVisible() const SAL_OVERRIDE;
 321
 322     virtual sal_uInt16      GetNumSubNodes() const SAL_OVERRIDE;
 323             void        SetNumSubNodes(sal_uInt16 nSize) { aSubNodes.resize(nSize); }
 324
 325     using   SmNode::GetSubNode;
 326     virtual SmNode *    GetSubNode(sal_uInt16 nIndex) SAL_OVERRIDE;
 327             void SetSubNodes(SmNode *pFirst, SmNode *pSecond, SmNode *pThird = NULL);
 328             void SetSubNodes(const SmNodeArray &rNodeArray);
 329
 330     SmStructureNode & operator = ( const SmStructureNode &rNode );
 331
 332     virtual void  GetAccessibleText( OUStringBuffer &rText ) const SAL_OVERRIDE;
 333
 334     void SetSubNode(size_t nIndex, SmNode* pNode)
 335     {
 336         size_t size = aSubNodes.size();
 337         if (size <= nIndex)
 338         {
 339             //Resize subnodes array
 340             aSubNodes.resize(nIndex + 1);
 341             //Set new slots to NULL
 342             for (size_t i = size; i < nIndex+1; i++)
 343                 aSubNodes[i] = NULL;
 344         }
 345         aSubNodes[nIndex] = pNode;
 346         ClaimPaternity();
 347     }
 348 };
 349
 350 inline void SmNode::ClaimPaternity() {
 351     SmNode* pNode;
 352     sal_uInt16  nSize = GetNumSubNodes();
 353     for (sal_uInt16 i = 0;  i < nSize;  i++)
 354         if (NULL != (pNode = GetSubNode(i)))
 355             pNode->SetParent(static_cast<SmStructureNode*>(this)); //Cast is valid if we have children
 356 }
 357
 358 /** Abstract base class for all visible node
 359  *
 360  * Nodes that doesn't derivate from this class doesn't draw anything, but their
 361  * children.
 362  */
 363 class SmVisibleNode : public SmNode
 364 {
 365 protected:
 366     SmVisibleNode(SmNodeType eNodeType, const SmToken &rNodeToken)
 367     :   SmNode(eNodeType, rNodeToken)
 368     {}
 369
 370 public:
 371
 372     virtual bool        IsVisible() const SAL_OVERRIDE;
 373     virtual sal_uInt16      GetNumSubNodes() const SAL_OVERRIDE;
 374     using   SmNode::GetSubNode;
 375     virtual SmNode *    GetSubNode(sal_uInt16 nIndex) SAL_OVERRIDE;
 376 };
 377
 378
 379
 380
 381
 382 class SmGraphicNode : public SmVisibleNode
 383 {
 384 protected:
 385     SmGraphicNode(SmNodeType eNodeType, const SmToken &rNodeToken)
 386     :   SmVisibleNode(eNodeType, rNodeToken)
 387     {}
 388
 389 public:
 390
 391     virtual void  GetAccessibleText( OUStringBuffer &rText ) const SAL_OVERRIDE;
 392 };
 393
 394
 395
 396
 397 /** Draws a rectangle
 398  *
 399  * Used for drawing the line in the OVER and OVERSTRIKE commands.
 400  */
 401 class SmRectangleNode : public SmGraphicNode
 402 {
 403     Size  aToSize;
 404
 405 public:
 406     SmRectangleNode(const SmToken &rNodeToken)
 407     :   SmGraphicNode(NRECTANGLE, rNodeToken)
 408     {}
 409
 410     virtual void AdaptToX(const OutputDevice &rDev, sal_uLong nWidth) SAL_OVERRIDE;
 411     virtual void AdaptToY(const OutputDevice &rDev, sal_uLong nHeight) SAL_OVERRIDE;
 412
 413     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat) SAL_OVERRIDE;
 414
 415     void CreateTextFromNode(OUString &rText) SAL_OVERRIDE;
 416     void Accept(SmVisitor* pVisitor) SAL_OVERRIDE;
 417 };
 418
 419
 420
 421
 422 /** Polygon line node
 423  *
 424  * Used to draw the slash of the WIDESLASH command by SmBinDiagonalNode.
 425  */
 426 class SmPolyLineNode : public SmGraphicNode
 427 {
 428     Polygon     aPoly;
 429     Size        aToSize;
 430     long        nWidth;
 431
 432 public:
 433     SmPolyLineNode(const SmToken &rNodeToken);
 434
 435     long         GetWidth() const { return nWidth; }
 436     Size         GetToSize() const { return aToSize; }
 437     Polygon     &GetPolygon() { return aPoly; }
 438
 439     virtual void AdaptToX(const OutputDevice &rDev, sal_uLong nWidth) SAL_OVERRIDE;
 440     virtual void AdaptToY(const OutputDevice &rDev, sal_uLong nHeight) SAL_OVERRIDE;
 441
 442     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat) SAL_OVERRIDE;
 443
 444     void Accept(SmVisitor* pVisitor) SAL_OVERRIDE;
 445 };
 446
 447
 448
 449
 450 /** Text node
 451  *
 452  * @remarks This class also serves as baseclass for all nodes that contains text.
 453  */
 454 class SmTextNode : public SmVisibleNode
 455 {
 456     OUString   aText;
 457     sal_uInt16      nFontDesc;
 458     /** Index within text where the selection starts
 459      * @remarks Only valid if SmNode::IsSelected() is true
 460      */
 461     sal_Int32  nSelectionStart;
 462     /** Index within text where the selection ends
 463      * @remarks Only valid if SmNode::IsSelected() is true
 464      */
 465     sal_Int32  nSelectionEnd;
 466
 467 protected:
 468     SmTextNode(SmNodeType eNodeType, const SmToken &rNodeToken, sal_uInt16 nFontDescP );
 469
 470 public:
 471     SmTextNode(const SmToken &rNodeToken, sal_uInt16 nFontDescP );
 472
 473     sal_uInt16              GetFontDesc() const { return nFontDesc; }
 474     void                SetText(const OUString &rText) { aText = rText; }
 475     const OUString &    GetText() const { return aText; }
 476     /** Change the text of this node, including the underlying token */
 477     void                ChangeText(const OUString &rText) {
 478         aText = rText;
 479         SmToken token = GetToken();
 480         token.aText = rText;
 481         SetToken(token); //TODO: Merge this with AdjustFontDesc for better performance
 482         AdjustFontDesc();
 483     }
 484     /** Try to guess the correct FontDesc, used during visual editing */
 485     void                AdjustFontDesc();
 486     /** Index within GetText() where the selection starts
 487      * @remarks Only valid of SmNode::IsSelected() is true
 488      */
 489     sal_Int32           GetSelectionStart() const {return nSelectionStart;}
 490     /** Index within GetText() where the selection end
 491      * @remarks Only valid of SmNode::IsSelected() is true
 492      */
 493     sal_Int32           GetSelectionEnd() const {return nSelectionEnd;}
 494     /** Set the index within GetText() where the selection starts */
 495     void                SetSelectionStart(sal_Int32 index) {nSelectionStart = index;}
 496     /** Set the index within GetText() where the selection end */
 497     void                SetSelectionEnd(sal_Int32 index) {nSelectionEnd = index;}
 498
 499     virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell) SAL_OVERRIDE;
 500     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat) SAL_OVERRIDE;
 501     virtual void CreateTextFromNode(OUString &rText) SAL_OVERRIDE;
 502
 503     virtual void  GetAccessibleText( OUStringBuffer &rText ) const SAL_OVERRIDE;
 504     void Accept(SmVisitor* pVisitor) SAL_OVERRIDE;
 505     /**
 506       Converts the character from StarMath's private area symbols to a matching Unicode
 507       character, if necessary. To be used when converting GetText() to a normal text.
 508     */
 509     static sal_Unicode ConvertSymbolToUnicode(sal_Unicode nIn);
 510 };
 511
 512
 513
 514
 515 /** Special node for user defined characters
 516  *
 517  * Node used for pre- and user-defined characters from:
 518  * officecfg/registry/data/org/openoffice/Office/Math.xcu
 519  *
 520  * This is just single characters, I think.
 521  */
 522 class SmSpecialNode : public SmTextNode
 523 {
 524     bool    bIsFromGreekSymbolSet;
 525
 526 protected:
 527     SmSpecialNode(SmNodeType eNodeType, const SmToken &rNodeToken, sal_uInt16 _nFontDesc);
 528
 529 public:
 530     SmSpecialNode(const SmToken &rNodeToken);
 531
 532     virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell) SAL_OVERRIDE;
 533     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat) SAL_OVERRIDE;
 534
 535     void Accept(SmVisitor* pVisitor) SAL_OVERRIDE;
 536 };
 537
 538
 539
 540
 541 /** Glyph node for custom operators
 542  *
 543  * This node is used with commands: oper, uoper and boper.
 544  * E.g. in "A boper op B", "op" will be an instance of SmGlyphSpecialNode.
 545  * "boper" simply inteprets "op", the following token, as an binary operator.
 546  * The command "uoper" interprets the following token as unary operator.
 547  * For these commands an instance of SmGlyphSpecialNode is used for the
 548  * operator token, following the command.
 549  */
 550 class SmGlyphSpecialNode : public SmSpecialNode
 551 {
 552 public:
 553     SmGlyphSpecialNode(const SmToken &rNodeToken)
 554     :   SmSpecialNode(NGLYPH_SPECIAL, rNodeToken, FNT_MATH)
 555     {}
 556
 557     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat) SAL_OVERRIDE;
 558     void Accept(SmVisitor* pVisitor) SAL_OVERRIDE;
 559 };
 560
 561
 562
 563
 564 /** Math symbol node
 565  *
 566  * Use for math symbols such as plus, minus and integrale in the INT command.
 567  */
 568 class SmMathSymbolNode : public SmSpecialNode
 569 {
 570 protected:
 571     SmMathSymbolNode(SmNodeType eNodeType, const SmToken &rNodeToken)
 572     :   SmSpecialNode(eNodeType, rNodeToken, FNT_MATH)
 573     {
 574         sal_Unicode cChar = GetToken().cMathChar;
 575         if ((sal_Unicode) '\0' != cChar)
 576             SetText(OUString(cChar));
 577     }
 578
 579 public:
 580     SmMathSymbolNode(const SmToken &rNodeToken);
 581
 582     virtual void AdaptToX(const OutputDevice &rDev, sal_uLong nWidth) SAL_OVERRIDE;
 583     virtual void AdaptToY(const OutputDevice &rDev, sal_uLong nHeight) SAL_OVERRIDE;
 584
 585     virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell) SAL_OVERRIDE;
 586     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat) SAL_OVERRIDE;
 587     void CreateTextFromNode(OUString &rText) SAL_OVERRIDE;
 588     void Accept(SmVisitor* pVisitor) SAL_OVERRIDE;
 589 };
 590
 591
 592
 593 /** Math Identifier
 594  *
 595  * This behaves essentially the same as SmMathSymbolNode and is only used to
 596  * represent math symbols that should be exported as <mi> elements rather than
 597  * <mo> elements.
 598  */
 599 class SmMathIdentifierNode : public SmMathSymbolNode
 600 {
 601 public:
 602     SmMathIdentifierNode(const SmToken &rNodeToken)
 603     :   SmMathSymbolNode(NMATHIDENT, rNodeToken) {}
 604 };
 605
 606
 607
 608 /** Root symbol node
 609  *
 610  * Root symbol node used by SmRootNode to create the root symbol, in front of
 611  * the line with the line above. I don't think this node should be used for
 612  * anything else.
 613  */
 614 class SmRootSymbolNode : public SmMathSymbolNode
 615 {
 616     sal_uLong  nBodyWidth;  // width of body (argument) of root sign
 617
 618 public:
 619     SmRootSymbolNode(const SmToken &rNodeToken)
 620         : SmMathSymbolNode(NROOTSYMBOL, rNodeToken)
 621         , nBodyWidth(0)
 622     {
 623     }
 624
 625     sal_uLong GetBodyWidth() const {return nBodyWidth;};
 626     virtual void AdaptToX(const OutputDevice &rDev, sal_uLong nHeight) SAL_OVERRIDE;
 627     virtual void AdaptToY(const OutputDevice &rDev, sal_uLong nHeight) SAL_OVERRIDE;
 628
 629     void Accept(SmVisitor* pVisitor) SAL_OVERRIDE;
 630 };
 631
 632
 633 /** Dynamic Integral symbol node
 634  *
 635  * Node for drawing dynamically sized integral symbols.
 636  *
 637  * TODO: It might be created a parent class SmDynamicSizedNode
 638         (for both dynamic integrals, roots and other dynamic symbols)
 639
 640  */
 641 class SmDynIntegralSymbolNode : public SmMathSymbolNode
 642 {
 643
 644
 645 public:
 646     SmDynIntegralSymbolNode(const SmToken &rNodeToken)
 647     :   SmMathSymbolNode(NDYNINTSYMBOL, rNodeToken)
 648     {}
 649
 650     virtual void AdaptToY(const OutputDevice &rDev, sal_uLong nHeight) SAL_OVERRIDE;
 651
 652     void Accept(SmVisitor* pVisitor) SAL_OVERRIDE;
 653 };
 654
 655
 656
 657
 658 /** Place node
 659  *
 660  * Used to create the <?> command, that denotes place where something can be
 661  * written.
 662  * It is drawn as a square with a shadow.
 663  */
 664 class SmPlaceNode : public SmMathSymbolNode
 665 {
 666 public:
 667     SmPlaceNode(const SmToken &rNodeToken)
 668     :   SmMathSymbolNode(NPLACE, rNodeToken)
 669     {
 670     }
 671     SmPlaceNode() : SmMathSymbolNode(NPLACE, SmToken(TPLACE, MS_PLACE, "<?>")) {};
 672
 673     virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell) SAL_OVERRIDE;
 674     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat) SAL_OVERRIDE;
 675     void Accept(SmVisitor* pVisitor) SAL_OVERRIDE;
 676 };
 677
 678
 679
 680
 681 /** Error node, for parsing errors
 682  *
 683  * This node is used for parsing errors and draws an questionmark turned upside
 684  * down (inverted question mark).
 685  */
 686 class SmErrorNode : public SmMathSymbolNode
 687 {
 688 public:
 689     SmErrorNode(SmParseError /*eError*/, const SmToken &rNodeToken)
 690     :   SmMathSymbolNode(NERROR, rNodeToken)
 691     {
 692         SetText(OUString(MS_ERROR));
 693     }
 694
 695     virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell) SAL_OVERRIDE;
 696     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat) SAL_OVERRIDE;
 697     void Accept(SmVisitor* pVisitor) SAL_OVERRIDE;
 698 };
 699
 700
 701
 702
 703 /** Table node
 704  *
 705  * This is the root node for the formula tree. This node is also used for the
 706  * STACK and BINOM commands. When used for root node, its
 707  * children are instances of SmLineNode, and in some obscure cases the a child
 708  * can be an instance of SmExpressionNode, mainly when errors occur.
 709  */
 710 class SmTableNode : public SmStructureNode
 711 {
 712     long nFormulaBaseline;
 713 public:
 714     SmTableNode(const SmToken &rNodeToken)
 715         :   SmStructureNode(NTABLE, rNodeToken)
 716         , nFormulaBaseline(0)
 717     {
 718     }
 719
 720     using   SmNode::GetLeftMost;
 721     virtual SmNode * GetLeftMost() SAL_OVERRIDE;
 722
 723     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat) SAL_OVERRIDE;
 724     virtual long GetFormulaBaseline() const SAL_OVERRIDE;
 725
 726     void Accept(SmVisitor* pVisitor) SAL_OVERRIDE;
 727 };
 728
 729
 730
 731
 732 /** A line
 733  *
 734  * Used as child of SmTableNode when the SmTableNode is the root node of the
 735  * formula tree.
 736  */
 737 class SmLineNode : public SmStructureNode
 738 {
 739     bool  bUseExtraSpaces;
 740
 741 protected:
 742     SmLineNode(SmNodeType eNodeType, const SmToken &rNodeToken)
 743     :   SmStructureNode(eNodeType, rNodeToken)
 744     {
 745         bUseExtraSpaces = true;
 746     }
 747
 748 public:
 749     SmLineNode(const SmToken &rNodeToken)
 750     :   SmStructureNode(NLINE, rNodeToken)
 751     {
 752         bUseExtraSpaces = true;
 753     }
 754
 755     void  SetUseExtraSpaces(bool bVal) { bUseExtraSpaces = bVal; }
 756     bool  IsUseExtraSpaces() const { return bUseExtraSpaces; };
 757
 758     virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell) SAL_OVERRIDE;
 759     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat) SAL_OVERRIDE;
 760     void Accept(SmVisitor* pVisitor) SAL_OVERRIDE;
 761 };
 762
 763
 764
 765
 766 /** Expression node
 767  *
 768  * Used whenever you have an expression such as "A OVER {B + C}", here there is
 769  * an expression node that allows "B + C" to be the denominator of the
 770  * SmBinVerNode, that the OVER command creates.
 771  */
 772 class SmExpressionNode : public SmLineNode
 773 {
 774 public:
 775     SmExpressionNode(const SmToken &rNodeToken)
 776     :   SmLineNode(NEXPRESSION, rNodeToken)
 777     {}
 778
 779     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat) SAL_OVERRIDE;
 780     void CreateTextFromNode(OUString &rText) SAL_OVERRIDE;
 781     void Accept(SmVisitor* pVisitor) SAL_OVERRIDE;
 782 };
 783
 784
 785
 786
 787 /** Unary horizontal node
 788  *
 789  * The same as SmBinHorNode except this is for unary operators.
 790  */
 791 class SmUnHorNode : public SmStructureNode
 792 {
 793 public:
 794     SmUnHorNode(const SmToken &rNodeToken)
 795     :   SmStructureNode(NUNHOR, rNodeToken)
 796     {
 797         SetNumSubNodes(2);
 798     }
 799
 800     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat) SAL_OVERRIDE;
 801     void Accept(SmVisitor* pVisitor) SAL_OVERRIDE;
 802 };
 803
 804
 805
 806
 807 /** Root node
 808  *
 809  * Used for create square roots and other roots, example:
 810  * \f$ \sqrt[\mbox{[Argument]}]{\mbox{[Body]}} \f$.
 811  *
 812  * Children:<BR>
 813  * 0: Argument (optional)<BR>
 814  * 1: Symbol (instance of SmRootSymbolNode)<BR>
 815  * 2: Body<BR>
 816  * Where argument is optional and may be NULL.
 817  */
 818 class SmRootNode : public SmStructureNode
 819 {
 820 protected:
 821     static void  GetHeightVerOffset(const SmRect &rRect,
 822                               long &rHeight, long &rVerOffset);
 823     static Point GetExtraPos(const SmRect &rRootSymbol, const SmRect &rExtra);
 824
 825 public:
 826     SmRootNode(const SmToken &rNodeToken)
 827     :   SmStructureNode(NROOT, rNodeToken)
 828     {
 829         SetNumSubNodes(3);
 830     }
 831
 832     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat) SAL_OVERRIDE;
 833     void CreateTextFromNode(OUString &rText) SAL_OVERRIDE;
 834     void Accept(SmVisitor* pVisitor) SAL_OVERRIDE;
 835
 836     SmNode* Argument();
 837     const SmNode* Argument() const;
 838     SmRootSymbolNode* Symbol();
 839     const SmRootSymbolNode* Symbol() const;
 840     SmNode* Body();
 841     const SmNode* Body() const;
 842 };
 843
 844
 845 /** Dynamic Integral node
 846  *
 847  * Used to create Dynamically sized integrals
 848  *
 849  * Children:<BR>
 850  * 0: Symbol (instance of DynIntegralSymbolNode)<BR>
 851  * 1: Body<BR>
 852  */
 853 class SmDynIntegralNode : public SmStructureNode
 854 {
 855 protected:
 856     void   GetHeightVerOffset(const SmRect &rRect,
 857                               long &rHeight, long &rVerOffset) const;
 858
 859 public:
 860     SmDynIntegralNode(const SmToken &rNodeToken)
 861     :   SmStructureNode(NDYNINT, rNodeToken)
 862     {
 863         SetNumSubNodes(2);
 864     }
 865
 866     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat) SAL_OVERRIDE;
 867     void CreateTextFromNode(OUString &rText) SAL_OVERRIDE;
 868     void Accept(SmVisitor* pVisitor) SAL_OVERRIDE;
 869
 870     SmDynIntegralSymbolNode* Symbol();
 871     const SmDynIntegralSymbolNode* Symbol() const;
 872     SmNode* Body();
 873     const SmNode* Body() const;
 874 };
 875
 876
 877
 878
 879 /** Binary horizontal node
 880  *
 881  * This node is used for binary operators. In a formula such as "A + B".
 882  *
 883  * Children:<BR>
 884  * 0: Left operand<BR>
 885  * 1: Binary operator<BR>
 886  * 2: Right operand<BR>
 887  *
 888  * None of the children may be NULL.
 889  */
 890 class SmBinHorNode : public SmStructureNode
 891 {
 892 public:
 893     SmBinHorNode(const SmToken &rNodeToken)
 894     :   SmStructureNode(NBINHOR, rNodeToken)
 895     {
 896         SetNumSubNodes(3);
 897     }
 898
 899     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat) SAL_OVERRIDE;
 900     void Accept(SmVisitor* pVisitor) SAL_OVERRIDE;
 901
 902     SmMathSymbolNode* Symbol();
 903     const SmMathSymbolNode* Symbol() const;
 904     SmNode* LeftOperand();
 905     const SmNode* LeftOperand() const;
 906     SmNode* RightOperand();
 907     const SmNode* RightOperand() const;
 908 };
 909
 910
 911
 912
 913 /** Binary horizontal node
 914  *
 915  * This node is used for creating the OVER command, consider the formula:
 916  * "numerator OVER denominator", which looks like
 917  * \f$ \frac{\mbox{numerator}}{\mbox{denominator}} \f$
 918  *
 919  * Children:<BR>
 920  * 0: Numerator<BR>
 921  * 1: Line (instance of SmRectangleNode)<BR>
 922  * 2: Denominator<BR>
 923  * None of the children may be NULL.
 924  */
 925 class SmBinVerNode : public SmStructureNode
 926 {
 927 public:
 928     SmBinVerNode(const SmToken &rNodeToken)
 929     :   SmStructureNode(NBINVER, rNodeToken)
 930     {
 931         SetNumSubNodes(3);
 932     }
 933
 934     using   SmNode::GetLeftMost;
 935     virtual SmNode * GetLeftMost() SAL_OVERRIDE;
 936
 937     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat) SAL_OVERRIDE;
 938     void CreateTextFromNode(OUString &rText) SAL_OVERRIDE;
 939     void Accept(SmVisitor* pVisitor) SAL_OVERRIDE;
 940 };
 941
 942
 943
 944
 945 /** Binary diagonal node
 946  *
 947  * Used for implementing the WIDESLASH command, example: "A WIDESLASH B".
 948  *
 949  * Children:<BR>
 950  * 0: Left operand<BR>
 951  * 1: right operand<BR>
 952  * 2: Line (instance of SmPolyLineNode).<BR>
 953  * None of the children may be NULL.
 954  */
 955 class SmBinDiagonalNode : public SmStructureNode
 956 {
 957     bool    bAscending;
 958
 959     void    GetOperPosSize(Point &rPos, Size &rSize,
 960                            const Point &rDiagPoint, double fAngleDeg) const;
 961
 962 public:
 963     SmBinDiagonalNode(const SmToken &rNodeToken);
 964
 965     bool    IsAscending() const { return bAscending; }
 966     void    SetAscending(bool bVal)  { bAscending = bVal; }
 967
 968     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat) SAL_OVERRIDE;
 969     void Accept(SmVisitor* pVisitor) SAL_OVERRIDE;
 970 };
 971
 972
 973
 974
 975
 976 /** Enum used to index sub-/supscripts in the 'aSubNodes' array
 977  * in 'SmSubSupNode'
 978  *
 979  * See graphic for positions at char:
 980  *
 981  * \code
 982  *      CSUP
 983  *
 984  * LSUP H  H RSUP
 985  *      H  H
 986  *      HHHH
 987  *      H  H
 988  * LSUB H  H RSUB
 989  *
 990  *      CSUB
 991  * \endcode
 992  */
 993 enum SmSubSup
 994 {   CSUB, CSUP, RSUB, RSUP, LSUB, LSUP
 995 };
 996
 997 /** numbers of entries in the above enum (that is: the number of possible
 998  * sub-/supscripts)
 999  */
1000 #define SUBSUP_NUM_ENTRIES 6
1001
1002 /** Super- and subscript node
1003  *
1004  * Used for creating super- and subscripts for commands such as:
1005  * "^", "_", "lsup", "lsub", "csup" and "csub".
1006  * Example: "A^2" which looks like: \f$ A^2 \f$
1007  *
1008  * This node is also used for creating limits on SmOperNode, when
1009  * "FROM" and "TO" commands are used with "INT", "SUM" or similar.
1010  *
1011  * Children of this node can be enumerated using the SmSubSup enum.
1012  * Please note that children may be NULL, except for the body.
1013  * It is recommended that you access children using GetBody() and
1014  * GetSubSup().
1015  */
1016 class SmSubSupNode : public SmStructureNode
1017 {
1018     bool  bUseLimits;
1019
1020 public:
1021     SmSubSupNode(const SmToken &rNodeToken)
1022     :   SmStructureNode(NSUBSUP, rNodeToken)
1023     {
1024         SetNumSubNodes(1 + SUBSUP_NUM_ENTRIES);
1025         bUseLimits = false;
1026     }
1027
1028     /** Get body (Not NULL) */
1029     SmNode *       GetBody()    { return GetSubNode(0); }
1030     /** Get body (Not NULL) */
1031     const SmNode * GetBody() const
1032     {
1033         return const_cast<SmSubSupNode *>(this)->GetBody();
1034     }
1035
1036     void  SetUseLimits(bool bVal) { bUseLimits = bVal; }
1037     bool  IsUseLimits() const { return bUseLimits; };
1038
1039     /** Get super- or subscript
1040      * @remarks this method may return NULL.
1041      */
1042     SmNode * GetSubSup(SmSubSup eSubSup) { return GetSubNode( sal::static_int_cast< sal_uInt16 >(1 + eSubSup) ); };
1043     const SmNode * GetSubSup(SmSubSup eSubSup) const { return const_cast< SmSubSupNode* >( this )->GetSubSup( eSubSup ); }
1044
1045     /** Set the body */
1046     void SetBody(SmNode* pBody) { SetSubNode(0, pBody); }
1047     void SetSubSup(SmSubSup eSubSup, SmNode* pScript) { SetSubNode( 1 + eSubSup, pScript); }
1048
1049     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat) SAL_OVERRIDE;
1050     void CreateTextFromNode(OUString &rText) SAL_OVERRIDE;
1051     void Accept(SmVisitor* pVisitor) SAL_OVERRIDE;
1052
1053 };
1054
1055
1056
1057
1058 /** Node for brace construction
1059  *
1060  * Used for "lbrace [body] rbrace" and similar constructions.
1061  * Should look like \f$ \{\mbox{[body]}\} \f$
1062  *
1063  * Children:<BR>
1064  * 0: Opening brace<BR>
1065  * 1: Body (usually SmBracebodyNode)<BR>
1066  * 2: Closing brace<BR>
1067  * None of the children can be NULL.
1068  *
1069  * Note that child 1 (Body) is usually SmBracebodyNode, but it can also be e.g. SmExpressionNode.
1070  */
1071 class SmBraceNode : public SmStructureNode
1072 {
1073 public:
1074     SmBraceNode(const SmToken &rNodeToken)
1075     :   SmStructureNode(NBRACE, rNodeToken)
1076     {
1077         SetNumSubNodes(3);
1078     }
1079
1080     SmMathSymbolNode* OpeningBrace();
1081     const SmMathSymbolNode* OpeningBrace() const;
1082     SmNode* Body();
1083     const SmNode* Body() const;
1084     SmMathSymbolNode* ClosingBrace();
1085     const SmMathSymbolNode* ClosingBrace() const;
1086
1087     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat) SAL_OVERRIDE;
1088     void CreateTextFromNode(OUString &rText) SAL_OVERRIDE;
1089     void Accept(SmVisitor* pVisitor) SAL_OVERRIDE;
1090 };
1091
1092
1093
1094
1095 /** Body of an SmBraceNode
1096  *
1097  * This usually only has one child an SmExpressionNode, however, it can also
1098  * have other children.
1099  * Consider the formula "lbrace [body1] mline [body2] rbrace", looks like:
1100  * \f$ \{\mbox{[body1] | [body2]}\} \f$.
1101  * In this case SmBracebodyNode will have three children, "[body1]", "|" and
1102  * [body2].
1103  */
1104 class SmBracebodyNode : public SmStructureNode
1105 {
1106     long  nBodyHeight;
1107
1108 public:
1109     inline SmBracebodyNode(const SmToken &rNodeToken);
1110
1111     virtual void    Arrange(const OutputDevice &rDev, const SmFormat &rFormat) SAL_OVERRIDE;
1112     long            GetBodyHeight() const { return nBodyHeight; }
1113     void Accept(SmVisitor* pVisitor) SAL_OVERRIDE;
1114 };
1115
1116
1117 inline SmBracebodyNode::SmBracebodyNode(const SmToken &rNodeToken) :
1118     SmStructureNode(NBRACEBODY, rNodeToken)
1119 {
1120     nBodyHeight = 0;
1121 }
1122
1123
1124
1125
1126 /** Node for vertical brace construction
1127  *
1128  * Used to implement commands "[body] underbrace [script]" and
1129  * "[body] overbrace [script]".
1130  * Underbrace should look like this \f$ \underbrace{\mbox{body}}_{\mbox{script}}\f$.
1131  *
1132  * Children:<BR>
1133  * 0: body<BR>
1134  * 1: brace<BR>
1135  * 2: script<BR>
1136  * (None of these children are optional, e.g. they must all be not NULL).
1137  */
1138 class SmVerticalBraceNode : public SmStructureNode
1139 {
1140 public:
1141     inline SmVerticalBraceNode(const SmToken &rNodeToken);
1142
1143     SmNode* Body();
1144     const SmNode* Body() const;
1145     SmMathSymbolNode* Brace();
1146     const SmMathSymbolNode* Brace() const;
1147     SmNode* Script();
1148     const SmNode* Script() const;
1149
1150     virtual void    Arrange(const OutputDevice &rDev, const SmFormat &rFormat) SAL_OVERRIDE;
1151     void Accept(SmVisitor* pVisitor) SAL_OVERRIDE;
1152 };
1153
1154
1155 inline SmVerticalBraceNode::SmVerticalBraceNode(const SmToken &rNodeToken) :
1156     SmStructureNode(NVERTICAL_BRACE, rNodeToken)
1157 {
1158     SetNumSubNodes(3);
1159 }
1160
1161
1162
1163
1164
1165 /** Operation Node
1166  *
1167  * Used for commands like SUM, INT and similar.
1168  *
1169  * Children:<BR>
1170  * 0: Operation (instance of SmMathSymbolNode or SmSubSupNode)<BR>
1171  * 1: Body<BR>
1172  * None of the children may be NULL.
1173  *
1174  */
1175 class SmOperNode : public SmStructureNode
1176 {
1177 public:
1178     SmOperNode(const SmToken &rNodeToken)
1179     :   SmStructureNode(NOPER, rNodeToken)
1180     {
1181         SetNumSubNodes(2);
1182     }
1183
1184     SmNode *       GetSymbol();
1185     const SmNode * GetSymbol() const
1186     {
1187         return const_cast<SmOperNode *>(this)->GetSymbol();
1188     }
1189
1190     long CalcSymbolHeight(const SmNode &rSymbol, const SmFormat &rFormat) const;
1191
1192     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat) SAL_OVERRIDE;
1193     void Accept(SmVisitor* pVisitor) SAL_OVERRIDE;
1194 };
1195
1196
1197
1198
1199 /** Node used for alignment
1200  */
1201 class SmAlignNode : public SmStructureNode
1202 {
1203 public:
1204     SmAlignNode(const SmToken &rNodeToken)
1205     :   SmStructureNode(NALIGN, rNodeToken)
1206     {}
1207
1208     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat) SAL_OVERRIDE;
1209     void Accept(SmVisitor* pVisitor) SAL_OVERRIDE;
1210 };
1211
1212
1213
1214
1215 /** Attribute node
1216  *
1217  * Used to give an attribute to another node. Used for commands such as:
1218  * UNDERLINE, OVERLINE, OVERSTRIKE, WIDEVEC, WIDEHAT and WIDETILDE.
1219  *
1220  * Children:<BR>
1221  * 0: Attribute<BR>
1222  * 1: Body<BR>
1223  * None of these may be NULL.
1224  */
1225 class SmAttributNode : public SmStructureNode
1226 {
1227 public:
1228     SmAttributNode(const SmToken &rNodeToken)
1229     :   SmStructureNode(NATTRIBUT, rNodeToken)
1230     {}
1231
1232     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat) SAL_OVERRIDE;
1233     void CreateTextFromNode(OUString &rText) SAL_OVERRIDE;
1234     void Accept(SmVisitor* pVisitor) SAL_OVERRIDE;
1235
1236     SmNode* Attribute();
1237     const SmNode* Attribute() const;
1238     SmNode* Body();
1239     const SmNode* Body() const;
1240 };
1241
1242
1243
1244
1245 /** Font node
1246  *
1247  * Used to change the font of its children.
1248  */
1249 class SmFontNode : public SmStructureNode
1250 {
1251     FontSizeType nSizeType;
1252     Fraction    aFontSize;
1253
1254 public:
1255     SmFontNode(const SmToken &rNodeToken)
1256     :   SmStructureNode(NFONT, rNodeToken)
1257     {
1258         nSizeType = FontSizeType::MULTIPLY;
1259         aFontSize = Fraction(1L);
1260     }
1261
1262     void SetSizeParameter(const Fraction &rValue, FontSizeType nType);
1263     const Fraction & GetSizeParameter() const {return aFontSize;}
1264     const FontSizeType& GetSizeType() const {return nSizeType;}
1265
1266     virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell) SAL_OVERRIDE;
1267     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat) SAL_OVERRIDE;
1268     void CreateTextFromNode(OUString &rText) SAL_OVERRIDE;
1269     void Accept(SmVisitor* pVisitor) SAL_OVERRIDE;
1270 };
1271
1272
1273
1274
1275 /** Matrix node
1276  *
1277  * Used to implement the MATRIX command, example:
1278  * "matrix{ 1 # 2 ## 3 # 4}".
1279  */
1280 class SmMatrixNode : public SmStructureNode
1281 {
1282     sal_uInt16  nNumRows,
1283             nNumCols;
1284
1285 public:
1286     SmMatrixNode(const SmToken &rNodeToken)
1287     :   SmStructureNode(NMATRIX, rNodeToken)
1288     {
1289         nNumRows = nNumCols = 0;
1290     }
1291
1292     sal_uInt16 GetNumRows() const {return nNumRows;}
1293     sal_uInt16 GetNumCols() const {return nNumCols;}
1294     void SetRowCol(sal_uInt16 nMatrixRows, sal_uInt16 nMatrixCols);
1295
1296     using   SmNode::GetLeftMost;
1297     virtual SmNode * GetLeftMost() SAL_OVERRIDE;
1298
1299     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat) SAL_OVERRIDE;
1300     void CreateTextFromNode(OUString &rText) SAL_OVERRIDE;
1301     void Accept(SmVisitor* pVisitor) SAL_OVERRIDE;
1302 };
1303
1304
1305
1306
1307 /** Node for whitespace
1308  *
1309  * Used to implement the "~" command. This node is just a blank space.
1310  */
1311 class SmBlankNode : public SmGraphicNode
1312 {
1313     sal_uInt16  nNum;
1314
1315 public:
1316     SmBlankNode(const SmToken &rNodeToken)
1317     :   SmGraphicNode(NBLANK, rNodeToken)
1318     {
1319         nNum = 0;
1320     }
1321
1322     void         IncreaseBy(const SmToken &rToken);
1323     void         Clear() { nNum = 0; }
1324     sal_uInt16       GetBlankNum() const { return nNum; }
1325     void         SetBlankNum(sal_uInt16 nNumber) { nNum = nNumber; }
1326
1327     virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell) SAL_OVERRIDE;
1328     virtual void Arrange(const OutputDevice &rDev, const SmFormat &rFormat) SAL_OVERRIDE;
1329     void Accept(SmVisitor* pVisitor) SAL_OVERRIDE;
1330 };
1331
1332
1333
1334
1335
1336 inline SmNode* SmRootNode::Argument()
1337 {
1338     OSL_ASSERT( GetNumSubNodes() > 0 );
1339     return GetSubNode( 0 );
1340 }
1341 inline const SmNode* SmRootNode::Argument() const
1342 {
1343     return const_cast< SmRootNode* >( this )->Argument();
1344 }
1345 inline SmRootSymbolNode* SmRootNode::Symbol()
1346 {
1347     OSL_ASSERT( GetNumSubNodes() > 1 && GetSubNode( 1 )->GetType() == NROOTSYMBOL );
1348     return static_cast< SmRootSymbolNode* >( GetSubNode( 1 ));
1349 }
1350 inline const SmRootSymbolNode* SmRootNode::Symbol() const
1351 {
1352     return const_cast< SmRootNode* >( this )->Symbol();
1353 }
1354 inline SmNode* SmRootNode::Body()
1355 {
1356     OSL_ASSERT( GetNumSubNodes() > 2 );
1357     return GetSubNode( 2 );
1358 }
1359 inline const SmNode* SmRootNode::Body() const
1360 {
1361     return const_cast< SmRootNode* >( this )->Body();
1362 }
1363
1364
1365
1366 inline SmDynIntegralSymbolNode* SmDynIntegralNode::Symbol()
1367 {
1368     OSL_ASSERT( GetNumSubNodes() > 0 && GetSubNode( 0 )->GetType() == NDYNINTSYMBOL );
1369     return static_cast< SmDynIntegralSymbolNode* >( GetSubNode( 0 ));
1370 }
1371 inline const SmDynIntegralSymbolNode* SmDynIntegralNode::Symbol() const
1372 {
1373     return const_cast< SmDynIntegralNode* >( this )->Symbol();
1374 }
1375 inline SmNode* SmDynIntegralNode::Body()
1376 {
1377     OSL_ASSERT( GetNumSubNodes() > 1 );
1378     return GetSubNode( 1 );
1379 }
1380 inline const SmNode* SmDynIntegralNode::Body() const
1381 {
1382     return const_cast< SmDynIntegralNode* >( this )->Body();
1383 }
1384
1385
1386 inline SmMathSymbolNode* SmBinHorNode::Symbol()
1387 {
1388     OSL_ASSERT( GetNumSubNodes() > 1 && GetSubNode( 1 )->GetType() == NMATH );
1389     return static_cast< SmMathSymbolNode* >( GetSubNode( 1 ));
1390 }
1391 inline const SmMathSymbolNode* SmBinHorNode::Symbol() const
1392 {
1393     return const_cast< SmBinHorNode* >( this )->Symbol();
1394 }
1395 inline SmNode* SmBinHorNode::LeftOperand()
1396 {
1397     OSL_ASSERT( GetNumSubNodes() > 0 );
1398     return GetSubNode( 0 );
1399 }
1400 inline const SmNode* SmBinHorNode::LeftOperand() const
1401 {
1402     return const_cast< SmBinHorNode* >( this )->LeftOperand();
1403 }
1404 inline SmNode* SmBinHorNode::RightOperand()
1405 {
1406     OSL_ASSERT( GetNumSubNodes() > 2 );
1407     return GetSubNode( 2 );
1408 }
1409 inline const SmNode* SmBinHorNode::RightOperand() const
1410 {
1411     return const_cast< SmBinHorNode* >( this )->RightOperand();
1412 }
1413
1414 inline SmNode* SmAttributNode::Attribute()
1415 {
1416     OSL_ASSERT( GetNumSubNodes() > 0 );
1417     return GetSubNode( 0 );
1418 }
1419 inline const SmNode* SmAttributNode::Attribute() const
1420 {
1421     return const_cast< SmAttributNode* >( this )->Attribute();
1422 }
1423 inline SmNode* SmAttributNode::Body()
1424 {
1425     OSL_ASSERT( GetNumSubNodes() > 1 );
1426     return GetSubNode( 1 );
1427 }
1428 inline const SmNode* SmAttributNode::Body() const
1429 {
1430     return const_cast< SmAttributNode* >( this )->Body();
1431 }
1432
1433 inline SmMathSymbolNode* SmBraceNode::OpeningBrace()
1434 {
1435     OSL_ASSERT( GetNumSubNodes() > 0 && GetSubNode( 0 )->GetType() == NMATH );
1436     return static_cast< SmMathSymbolNode* >( GetSubNode( 0 ));
1437 }
1438 inline const SmMathSymbolNode* SmBraceNode::OpeningBrace() const
1439 {
1440     return const_cast< SmBraceNode* >( this )->OpeningBrace();
1441 }
1442 inline SmNode* SmBraceNode::Body()
1443 {
1444     OSL_ASSERT( GetNumSubNodes() > 1 );
1445     return GetSubNode( 1 );
1446 }
1447 inline const SmNode* SmBraceNode::Body() const
1448 {
1449     return const_cast< SmBraceNode* >( this )->Body();
1450 }
1451 inline SmMathSymbolNode* SmBraceNode::ClosingBrace()
1452 {
1453     OSL_ASSERT( GetNumSubNodes() > 2 && GetSubNode( 2 )->GetType() == NMATH );
1454     return static_cast< SmMathSymbolNode* >( GetSubNode( 2 ));
1455 }
1456 inline const SmMathSymbolNode* SmBraceNode::ClosingBrace() const
1457 {
1458     return const_cast< SmBraceNode* >( this )->ClosingBrace();
1459 }
1460
1461 inline SmNode* SmVerticalBraceNode::Body()
1462 {
1463     OSL_ASSERT( GetNumSubNodes() > 0 );
1464     return GetSubNode( 0 );
1465 }
1466 inline const SmNode* SmVerticalBraceNode::Body() const
1467 {
1468     return const_cast< SmVerticalBraceNode* >( this )->Body();
1469 }
1470 inline SmMathSymbolNode* SmVerticalBraceNode::Brace()
1471 {
1472     OSL_ASSERT( GetNumSubNodes() > 1 && GetSubNode( 1 )->GetType() == NMATH );
1473     return static_cast< SmMathSymbolNode* >( GetSubNode( 1 ));
1474 }
1475 inline const SmMathSymbolNode* SmVerticalBraceNode::Brace() const
1476 {
1477     return const_cast< SmVerticalBraceNode* >( this )->Brace();
1478 }
1479 inline SmNode* SmVerticalBraceNode::Script()
1480 {
1481     OSL_ASSERT( GetNumSubNodes() > 2 );
1482     return GetSubNode( 2 );
1483 }
1484 inline const SmNode* SmVerticalBraceNode::Script() const
1485 {
1486     return const_cast< SmVerticalBraceNode* >( this )->Script();
1487 }
1488
1489 #endif
1490
1491
1492 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */