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 /** The SmNode is the basic structure of formula data.
  21   *
  22   * Each token is stored in one node of specific kind.
  23   * They can have SmNodeType. It allows to identify node type after abstraction.
  24   * Here goes the subclasses tree:
  25   *
  26   * SmRect
  27   *     SmNode
  28   *         SmStructureNode                             Head of tree diagram
  29   *             SmTableNode                             binom
  30   *             SmLineNode                              A line
  31   *                 SmExpressionNode                    { content }
  32   *             SmUnHorNode                             unary operators +-; -+; +x; -x; ...
  33   *             SmRootNode                              Root structure
  34   *             SmBinHorNode                            binary operators A + B
  35   *             SmBinVerNode                            over; frac; ...
  36   *             SmBinDiagonalNode                       wideslash
  37   *             SmSubSupNode                            csub, csup, lsub, from, to, ...
  38   *             SmBraceNode                             (); []; left lbrace right rbrace; ...
  39   *             SmBracebodyNode                         ( content ); [ content ]; ...
  40   *             SmVerticalBraceNode                     overbrace; underbrace;
  41   *             SmOperNode                              sum from to; int from to;
  42   *             SmAlignNode                             text alignment
  43   *             SmAttributeNode                         font attributes; bold;
  44   *             SmFontNode                              font serif; ...
  45   *             SmMatrixNode                            matrix
  46   *         SmVisibleNode                               drawable node
  47   *             SmGraphicNode                           graphics display
  48   *                 SmRectangleNode
  49   *                 SmPolyLineNode                      overline; underline; widehat; ...
  50   *                 SmBlankNode                         blank space; ~; ...
  51   *             SmTextNode                              "text"; func functname; ...
  52   *                 SmSpecialNode
  53   *                     SmGlyphSpecialNode              %symbolname
  54   *                     SmMathSymbolNode                math symbols
  55   *                         SmMathIdentifierNode        variable
  56   *                         SmRootSymbolNode            root symbol
  57   *                         SmPlaceNode                 <?>
  58   *                         SmErrorNode                 red ? for errors
  59   *
  60   */
  61
  62 #pragma once
  63
  64 #include "types.hxx"
  65 #include "token.hxx"
  66 #include "rect.hxx"
  67 #include "format.hxx"
  68 #include "nodetype.hxx"
  69
  70 #include <editeng/editdata.hxx>
  71 #include <rtl/ustrbuf.hxx>
  72
  73 enum class FontAttribute {
  74     None   = 0x0000,
  75     Bold   = 0x0001,
  76     Italic = 0x0002
  77 };
  78
  79 namespace o3tl
  80 {
  81     template<> struct typed_flags<FontAttribute> : is_typed_flags<FontAttribute, 0x0003> {};
  82 }
  83
  84
  85 enum class FontSizeType {
  86   ABSOLUT  = 1,
  87   PLUS     = 2,
  88   MINUS    = 3,
  89   MULTIPLY = 4,
  90   DIVIDE   = 5
  91 };
  92
  93 // flags to interdict respective status changes
  94 enum class FontChangeMask {
  95     None     = 0x0000,
  96     Face     = 0x0001,
  97     Size     = 0x0002,
  98     Bold     = 0x0004,
  99     Italic   = 0x0008,
 100     Color    = 0x0010,
 101     Phantom  = 0x0020
 102 };
 103
 104 namespace o3tl
 105 {
 106     template<> struct typed_flags<FontChangeMask> : is_typed_flags<FontChangeMask, 0x003f> {};
 107 }
 108
 109
 110 class SmVisitor;
 111 class SmDocShell;
 112 class SmNode;
 113 class SmStructureNode;
 114
 115 typedef std::vector< SmNode * > SmNodeArray;
 116
 117 enum class SmScaleMode
 118 {
 119     None,
 120     Width,
 121     Height
 122 };
 123
 124 class SmNode : public SmRect
 125 {
 126     // Rendering info for SmRect
 127     SmFace          maFace;
 128     // Anclage to the code
 129     SmToken         maNodeToken;
 130     ESelection      m_aESelection;
 131     // Node information
 132     SmNodeType      meType;
 133     SmScaleMode     meScaleMode;
 134     RectHorAlign    meRectHorAlign;
 135     FontChangeMask  mnFlags;
 136     FontAttribute   mnAttributes;
 137     bool            mbIsPhantom;
 138     bool            mbIsSelected;
 139     // index in accessible text; -1 if not (yet) applicable
 140     sal_Int32       mnAccIndex;
 141
 142 protected:
 143     SmNode(SmNodeType eNodeType, SmToken aNodeToken);
 144
 145 public:
 146     SmNode(const SmNode&) = delete;
 147     SmNode& operator=(const SmNode&) = delete;
 148
 149     virtual ~SmNode();
 150
 151     /**
 152      * Checks node visibility.
 153      * Returns true if this is an instance of SmVisibleNode's subclass, false otherwise.
 154      * @return node visibility
 155      */
 156     virtual bool IsVisible() const = 0;
 157
 158     /**
 159      * Gets the number of subnodes.
 160      * @return number of subnodes
 161      */
 162     virtual size_t GetNumSubNodes() const = 0;
 163
 164     /**
 165      * Gets the subnode of index nIndex.
 166      * @param nIndex
 167      * @return subnode of index nIndex
 168      */
 169     virtual SmNode * GetSubNode(size_t nIndex) = 0;
 170     const   SmNode * GetSubNode(size_t nIndex) const
 171                      { return const_cast<SmNode *>(this)->GetSubNode(nIndex); }
 172
 173     virtual const SmNode * GetLeftMost() const;
 174
 175     /**
 176      * Gets the FontChangeMask flags.
 177      * @return FontChangeMask flags
 178      */
 179     FontChangeMask &Flags() { return mnFlags; }
 180
 181     /**
 182      * Gets the font attributes.
 183      * @return font attributes
 184      */
 185     FontAttribute &Attributes() { return mnAttributes; }
 186
 187     /**
 188      * Checks if it is a visible node rendered invisible.
 189      * @return rendered visibility
 190      */
 191     bool IsPhantom() const { return mbIsPhantom; }
 192
 193     /**
 194      * Sets the render visibility of a visible node to bIsPhantom.
 195      * @param bIsPhantom
 196      * @return
 197      */
 198     void SetPhantom(bool bIsPhantom);
 199
 200     /**
 201      * Sets the font color.
 202      * @param rColor
 203      * @return
 204      */
 205     void SetColor(const Color &rColor);
 206
 207     /**
 208      * Sets the font attribute nAttrib.
 209      * Check FontAttribute class.
 210      * @param nAttrib
 211      * @return
 212      */
 213     void SetAttribute(FontAttribute nAttrib);
 214
 215     /**
 216      * Clears the font attribute nAttrib.
 217      * Check FontAttribute class.
 218      * @param nAttrib
 219      * @return
 220      */
 221     void ClearAttribute(FontAttribute nAttrib);
 222
 223     /**
 224      * Gets the font.
 225      * @return font
 226      */
 227     const SmFace & GetFont() const { return maFace; };
 228           SmFace & GetFont()       { return maFace; };
 229
 230     /**
 231      * Sets the font to rFace.
 232      * @param rFace
 233      * @return
 234      */
 235     void SetFont(const SmFace &rFace);
 236
 237     /**
 238      * Sets the font size to rRelSize with type nType.
 239      * Check FontSizeType for details.
 240      * @param rRelSize
 241      * @param nType
 242      * @return
 243      */
 244     void SetFontSize(const Fraction &rRelSize, FontSizeType nType);
 245
 246     /**
 247      * Sets the font size to rRelSize with type FontSizeType::ABSOLUT.
 248      * @param rScale
 249      * @return
 250      */
 251     void SetSize(const Fraction &rScale);
 252
 253     /**
 254      * Prepare preliminary settings about font and text
 255      * (e.g. maFace, meRectHorAlign, mnFlags, mnAttributes, etc.)
 256      * @param rFormat
 257      * @param rDocShell
 258      * @param nDepth
 259      * @return
 260      */
 261     virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell, int nDepth);
 262
 263     /**
 264      * Prepare preliminary font attributes
 265      * Called on Prepare(...).
 266      * @return
 267      */
 268     void PrepareAttributes();
 269
 270     /**
 271      * Sets the alignment of the text.
 272      * Check RectHorAlign class for details.
 273      * The subtrees will be affected if bApplyToSubTree.
 274      * @param eHorAlign
 275      * @param bApplyToSubTree
 276      * @return
 277      */
 278     void SetRectHorAlign(RectHorAlign eHorAlign, bool bApplyToSubTree = true );
 279
 280     /**
 281      * Gets the alignment of the text.
 282      * @return alignment of the text
 283      */
 284     RectHorAlign GetRectHorAlign() const { return meRectHorAlign; }
 285
 286     /**
 287      * Parses itself to SmRect.
 288      * @return this
 289      */
 290     const SmRect & GetRect() const { return *this; }
 291
 292     /**
 293      * Moves the rectangle by rVector.
 294      * @param rVector
 295      * @return
 296      */
 297     void Move(const Point &rVector);
 298
 299     /**
 300      * Moves the rectangle to rPoint, being the top left corner the origin.
 301      * @param rPoint
 302      * @return
 303      */
 304     void MoveTo(const Point &rPoint) { Move(rPoint - GetTopLeft()); }
 305
 306     /**
 307      * Prepares the SmRect to render.
 308      * @param rDev
 309      * @param rFormat
 310      * @return
 311      */
 312     virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) = 0;
 313
 314     /**
 315      * Appends to rText the node text.
 316      * @param rText
 317      * @return
 318      */
 319     virtual void GetAccessibleText( OUStringBuffer &rText ) const = 0;
 320
 321     /**
 322      * Gets the node accessible index.
 323      * Used for visual editing.
 324      * @return node accessible index
 325      */
 326     sal_Int32 GetAccessibleIndex() const { return mnAccIndex; }
 327
 328     /**
 329      * Sets the node accessible index to nAccIndex.
 330      * Used for visual editing.
 331      * @param nAccIndex
 332      * @return
 333      */
 334     void SetAccessibleIndex(sal_Int32 nAccIndex) { mnAccIndex = nAccIndex; }
 335
 336     /**
 337      * Finds the node with accessible index nAccIndex.
 338      * Used for visual editing.
 339      * @param nAccIndex
 340      * @return node with accessible index nAccIndex
 341      */
 342     const SmNode * FindNodeWithAccessibleIndex(sal_Int32 nAccIndex) const;
 343
 344     /**
 345      * Gets the line in the text where the node is located.
 346      * It is used to do the visual <-> text correspondence.
 347      * @return line
 348      */
 349     sal_uInt16 GetRow() const { return sal::static_int_cast<sal_uInt16>(m_aESelection.nStartPara); }
 350
 351     /**
 352      * Gets the column of the line in the text where the node is located.
 353      * It is used to do the visual <-> text correspondence.
 354      * @return column
 355      */
 356     sal_uInt16 GetColumn() const { return sal::static_int_cast<sal_uInt16>(m_aESelection.nStartPos); }
 357
 358     /**
 359      * Gets the scale mode.
 360      * @return scale mode
 361      */
 362     SmScaleMode GetScaleMode() const { return meScaleMode; }
 363
 364     /**
 365      * Sets the scale mode to eMode.
 366      * @param eMode
 367      * @return
 368      */
 369     void SetScaleMode(SmScaleMode eMode) { meScaleMode = eMode; }
 370
 371     //visual stuff TODO comment
 372     virtual void AdaptToX(OutputDevice &rDev, sal_uLong nWidth);
 373     virtual void AdaptToY(OutputDevice &rDev, sal_uLong nHeight);
 374
 375     /**
 376      * Gets the node type.
 377      * @return node type
 378      */
 379     SmNodeType GetType() const  { return meType; }
 380
 381     /**
 382      * Gets the token.
 383      * The token contains the data extracted from the text mode.
 384      * Ej: text, type (sub, sup, int,...), row and column,...
 385      * @return node type
 386      */
 387     const SmToken & GetToken() const { return maNodeToken; }
 388           SmToken & GetToken()       { return maNodeToken; }
 389
 390     /**
 391      * Gets node position in input text.
 392      * @return node position in input text
 393      */
 394     const ESelection& GetSelection() const { return m_aESelection; }
 395
 396     /**
 397      * Gets node position in input text.
 398      * @param aESelection
 399      */
 400     void SetSelection(ESelection aESelection) { m_aESelection = aESelection; }
 401
 402     /**
 403      * Finds the node from the position in the text.
 404      * It is used to do the visual <-> text correspondence.
 405      * @param nRow
 406      * @param nCol
 407      * @return the given node
 408      */
 409     const SmNode *  FindTokenAt(sal_uInt16 nRow, sal_uInt16 nCol) const;
 410
 411     /**
 412      * Finds the closest rectangle in the screen.
 413      * @param rPoint
 414      * @return the given node
 415      */
 416     const SmNode *  FindRectClosestTo(const Point &rPoint) const;
 417
 418     /**
 419      * Accept a visitor.
 420      * Calls the method for this class on the visitor.
 421      * @param pVisitor
 422      * @return
 423      */
 424     virtual void Accept(SmVisitor* pVisitor) = 0;
 425
 426     /**
 427      * Checks if the node is selected.
 428      * @return the node is selected
 429      */
 430     bool IsSelected() const {return mbIsSelected;}
 431
 432     /**
 433      * Sets the node to Selected.
 434      * @param Selected
 435      * @return
 436      */
 437     void SetSelected(bool Selected) {mbIsSelected = Selected;}
 438
 439     /**
 440      * Gets the parent node of this node.
 441      * @return parent node
 442      */
 443     const SmStructureNode* GetParent() const { return mpParentNode; }
 444           SmStructureNode* GetParent()       { return mpParentNode; }
 445
 446     /**
 447      * Sets the parent node.
 448      * @param parent
 449      * @return
 450      */
 451     void SetParent(SmStructureNode* parent){ mpParentNode = parent; }
 452
 453     /**
 454      * Sets the token for this node.
 455      * @param token
 456      * @return
 457      */
 458     void SetToken(SmToken const & token){ maNodeToken = token; }
 459
 460 private:
 461     SmStructureNode* mpParentNode;
 462 };
 463
 464
 465 /** Abstract baseclass for all composite node
 466  *
 467  * Subclasses of this class can have subnodes. Nodes that doesn't derivate from
 468  * this class does not have subnodes.
 469  */
 470 class SmStructureNode : public SmNode
 471 {
 472     SmNodeArray maSubNodes;
 473
 474 protected:
 475     SmStructureNode(SmNodeType eNodeType, const SmToken &rNodeToken, size_t nSize = 0)
 476         : SmNode(eNodeType, rNodeToken)
 477         , maSubNodes(nSize) {}
 478
 479 public:
 480     virtual ~SmStructureNode() override;
 481
 482     /**
 483      * Checks node visibility.
 484      * Returns true if this is an instance of SmVisibleNode's subclass, false otherwise.
 485      * @return node visibility
 486      */
 487     virtual bool IsVisible() const override;
 488
 489     /**
 490      * Gets the number of subnodes.
 491      * @return number of subnodes
 492      */
 493     virtual size_t GetNumSubNodes() const override;
 494
 495     /**
 496      * Gets the subnode of index nIndex.
 497      * @param nIndex
 498      * @return subnode of index nIndex
 499      */
 500     using   SmNode::GetSubNode;
 501     virtual SmNode * GetSubNode(size_t nIndex) override;
 502
 503     /**
 504      * Gets the subnode of index nIndex, used for operators.
 505      * @param nIndex
 506      * @return subnode of index nIndex
 507      */
 508     SmNode * GetSubNodeBinMo(size_t nIndex) const;
 509
 510     /**
 511      * Does the cleaning of the subnodes.
 512      * @return
 513      */
 514     void ClearSubNodes();
 515
 516     /**
 517      * Sets subnodes, used for operators.
 518      * @param pFirst
 519      * @param pSecond
 520      * @param pThird
 521      * @return
 522      */
 523     void SetSubNodes(std::unique_ptr<SmNode> pFirst, std::unique_ptr<SmNode> pSecond,
 524                      std::unique_ptr<SmNode> pThird = nullptr);
 525
 526     /**
 527      * Sets subnodes.
 528      * @param pFirst
 529      * @param pSecond
 530      * @param pThird
 531      * @return
 532      */
 533     void SetSubNodes(SmNode* pFirst, SmNode* pSecond, SmNode* pThird);
 534
 535     /**
 536      * Sets subnodes, used for operators.
 537      * The data is reordered so the items are correctly ordered.
 538      * @param pFirst
 539      * @param pSecond
 540      * @param pThird
 541      * @return
 542      */
 543     void SetSubNodesBinMo(std::unique_ptr<SmNode> pFirst, std::unique_ptr<SmNode> pSecond,
 544                           std::unique_ptr<SmNode> pThird = nullptr);
 545
 546     /**
 547      * Sets subnodes.
 548      * @param rNodeArray
 549      * @return
 550      */
 551     void SetSubNodes(SmNodeArray&& rNodeArray);
 552
 553     /**
 554      * Appends to rText the node text.
 555      * @param rText
 556      * @return
 557      */
 558     virtual void  GetAccessibleText( OUStringBuffer &rText ) const override;
 559
 560     /**
 561      * Gets the first subnode.
 562      * @return first subnode
 563      */
 564     SmNodeArray::iterator begin() {return maSubNodes.begin();}
 565
 566     /**
 567      * Gets the last subnode.
 568      * @return last subnode
 569      */
 570     SmNodeArray::iterator end() {return maSubNodes.end();}
 571
 572     /**
 573      * Gets the last subnode.
 574      * @return last subnode
 575      */
 576     SmNodeArray::reverse_iterator rbegin() {return maSubNodes.rbegin();}
 577
 578     /**
 579      * Gets the first subnode.
 580      * @return first subnode
 581      */
 582     SmNodeArray::reverse_iterator rend() {return maSubNodes.rend();}
 583
 584     /**
 585      * Get the index of the child node pSubNode.
 586      * Returns -1, if pSubNode isn't a subnode of this.
 587      * @param pSubNode
 588      * @return index of the child node
 589      */
 590     int IndexOfSubNode(SmNode const * pSubNode);
 591
 592     /**
 593      * Sets the subnode pNode at nIndex.
 594      * If necessary increases the subnodes length.
 595      * @param nIndex
 596      * @param pNode
 597      * @return
 598      */
 599     void SetSubNode(size_t nIndex, SmNode* pNode);
 600
 601 private:
 602     /** Sets parent on children of this node */
 603     void ClaimPaternity();
 604 };
 605
 606
 607 /** Abstract base class for all visible node
 608  *
 609  * Nodes that doesn't derivate from this class doesn't draw anything, but their
 610  * children.
 611  */
 612 class SmVisibleNode : public SmNode
 613 {
 614 protected:
 615     SmVisibleNode(SmNodeType eNodeType, const SmToken &rNodeToken)
 616     :   SmNode(eNodeType, rNodeToken) {}
 617
 618 public:
 619
 620     /**
 621      * Checks node visibility.
 622      * Returns true if this is an instance of SmVisibleNode's subclass, false otherwise.
 623      * @return node visibility
 624      */
 625     virtual bool        IsVisible() const override;
 626
 627     /**
 628      * Gets the number of subnodes.
 629      * @return number of subnodes
 630      */
 631     virtual size_t      GetNumSubNodes() const override;
 632
 633     /**
 634      * Gets the subnode of index nIndex.
 635      * @param nIndex
 636      * @return subnode of index nIndex
 637      */
 638     using   SmNode::GetSubNode;
 639     virtual SmNode *    GetSubNode(size_t nIndex) override;
 640 };
 641
 642
 643 class SmGraphicNode : public SmVisibleNode
 644 {
 645 protected:
 646     SmGraphicNode(SmNodeType eNodeType, const SmToken &rNodeToken)
 647     :   SmVisibleNode(eNodeType, rNodeToken) {}
 648
 649 public:
 650
 651     /**
 652      * Appends to rText the node text.
 653      * @param rText
 654      * @return
 655      */
 656     virtual void  GetAccessibleText( OUStringBuffer &rText ) const override;
 657 };
 658
 659
 660 /** Draws a rectangle
 661  *
 662  * Used for drawing the line in the OVER and OVERSTRIKE commands.
 663  */
 664 class SmRectangleNode final : public SmGraphicNode
 665 {
 666     Size maToSize;
 667
 668 public:
 669     explicit SmRectangleNode(const SmToken &rNodeToken)
 670         : SmGraphicNode(SmNodeType::Rectangle, rNodeToken)
 671     {}
 672
 673     //visual stuff TODO comment
 674     virtual void AdaptToX(OutputDevice &rDev, sal_uLong nWidth) override;
 675     virtual void AdaptToY(OutputDevice &rDev, sal_uLong nHeight) override;
 676
 677     /**
 678      * Prepares the SmRect to render.
 679      * @param rDev
 680      * @param rFormat
 681      * @return
 682      */
 683     virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
 684
 685     /**
 686      * Accept a visitor.
 687      * Calls the method for this class on the visitor.
 688      * @param pVisitor
 689      * @return
 690      */
 691     void Accept(SmVisitor* pVisitor) override;
 692 };
 693
 694
 695 /** Polygon line node
 696  *
 697  * Used to draw the slash of the WIDESLASH command by SmBinDiagonalNode.
 698  */
 699 class SmPolyLineNode final : public SmGraphicNode
 700 {
 701     tools::Polygon maPoly;
 702     Size maToSize;
 703     tools::Long mnWidth;
 704
 705 public:
 706     explicit SmPolyLineNode(const SmToken &rNodeToken);
 707
 708     /**
 709      * Gets the width of the rect.
 710      * @return width
 711      */
 712     tools::Long GetWidth() const { return mnWidth; }
 713
 714     /**
 715      * Gets the polygon to draw the node.
 716      * @return polygon
 717      */
 718     tools::Polygon &GetPolygon()  { return maPoly; }
 719
 720     //visual stuff TODO comment
 721     virtual void AdaptToX(OutputDevice &rDev, sal_uLong nWidth) override;
 722     virtual void AdaptToY(OutputDevice &rDev, sal_uLong nHeight) override;
 723
 724     /**
 725      * Prepares the SmRect to render.
 726      * @param rDev
 727      * @param rFormat
 728      * @return
 729      */
 730     virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
 731
 732     /**
 733      * Accept a visitor.
 734      * Calls the method for this class on the visitor.
 735      * @param pVisitor
 736      * @return
 737      */
 738     void Accept(SmVisitor* pVisitor) override;
 739 };
 740
 741
 742 /** Text node
 743  *
 744  * @remarks This class also serves as baseclass for all nodes that contains text.
 745  */
 746 class SmTextNode : public SmVisibleNode
 747 {
 748     OUString   maText;
 749     sal_uInt16 mnFontDesc;
 750     /** Index within text where the selection starts
 751      * @remarks Only valid if SmNode::IsSelected() is true
 752      */
 753     sal_Int32  mnSelectionStart;
 754     /** Index within text where the selection ends
 755      * @remarks Only valid if SmNode::IsSelected() is true
 756      */
 757     sal_Int32  mnSelectionEnd;
 758
 759 protected:
 760     SmTextNode(SmNodeType eNodeType, const SmToken &rNodeToken, sal_uInt16 nFontDescP );
 761
 762 public:
 763     SmTextNode(const SmToken &rNodeToken, sal_uInt16 nFontDescP );
 764
 765     /**
 766      * Returns the font type being used (text, variable, symbol, ...).
 767      * @return font type
 768      */
 769     sal_uInt16 GetFontDesc() const { return mnFontDesc; }
 770
 771     /**
 772      * Sets the node text to rText.
 773      * @param rText
 774      * @return
 775      */
 776     void SetText(const OUString &rText) { maText = rText; }
 777
 778     /**
 779      * Gets the node text.
 780      * @return node text
 781      */
 782     const OUString & GetText() const { return maText; }
 783           OUString & GetText()       { return maText; }
 784
 785     /**
 786      * Change the text of this node, including the underlying token to rText.
 787      * @param rText
 788      * @return
 789      */
 790     void ChangeText(const OUString &rText);
 791
 792     /**
 793      * Try to guess the correct FontDesc, used during visual editing
 794      * @return
 795      */
 796     void AdjustFontDesc();
 797
 798     /**
 799      * Index within GetText() where the selection starts.
 800      * @remarks Only valid of SmNode::IsSelected() is true.
 801      * @return index.
 802      */
 803     sal_Int32 GetSelectionStart() const { return mnSelectionStart; }
 804
 805     /**
 806      * Index within GetText() where the selection ends.
 807      * @remarks Only valid of SmNode::IsSelected() is true.
 808      * @return index.
 809      */
 810     sal_Int32 GetSelectionEnd() const  {return mnSelectionEnd; }
 811
 812     /**
 813      * Sets the index within GetText() where the selection starts to index.
 814      * @param index
 815      * @return
 816      */
 817     void SetSelectionStart(sal_Int32 index) {mnSelectionStart = index;}
 818
 819     /**
 820      * Sets the index within GetText() where the selection ends to index.
 821      * @param index
 822      * @return
 823      */
 824     void SetSelectionEnd(sal_Int32 index) {mnSelectionEnd = index;}
 825
 826     /**
 827      * Prepare preliminary settings about font and text
 828      * (e.g. maFace, meRectHorAlign, mnFlags, mnAttributes, etc.)
 829      * @param rFormat
 830      * @param rDocShell
 831      * @param nDepth
 832      * @return
 833      */
 834     virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell,
 835                          int nDepth) override;
 836
 837     /**
 838      * Prepares the SmRect to render.
 839      * @param rDev
 840      * @param rFormat
 841      * @return
 842      */
 843     virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
 844
 845     /**
 846      * Appends to rText the node text.
 847      * @param rText
 848      * @return
 849      */
 850     virtual void  GetAccessibleText( OUStringBuffer &rText ) const override;
 851
 852     /**
 853      * Accept a visitor.
 854      * Calls the method for this class on the visitor.
 855      * @param pVisitor
 856      * @return
 857      */
 858     void Accept(SmVisitor* pVisitor) override;
 859
 860     /**
 861      * Converts the character from StarMath's private area symbols to a matching Unicode
 862      * character, if necessary. To be used when converting GetText() to a normal text.
 863      * @param nIn
 864      * @return unicode char
 865      */
 866     static sal_Unicode ConvertSymbolToUnicode(sal_Unicode nIn);
 867 };
 868
 869
 870 /** Special node for user defined characters
 871  *
 872  * Node used for pre- and user-defined characters from:
 873  * officecfg/registry/data/org/openoffice/Office/Math.xcu
 874  *
 875  * This is just single characters, I think.
 876  */
 877 class SmSpecialNode : public SmTextNode
 878 {
 879     bool mbIsFromGreekSymbolSet;
 880
 881 protected:
 882     SmSpecialNode(SmNodeType eNodeType, const SmToken &rNodeToken, sal_uInt16 _nFontDesc);
 883
 884 public:
 885     explicit SmSpecialNode(const SmToken &rNodeToken);
 886
 887     /**
 888      * Prepare preliminary settings about font and text
 889      * (e.g. maFace, meRectHorAlign, mnFlags, mnAttributes, etc.)
 890      * @param rFormat
 891      * @param rDocShell
 892      * @param nDepth
 893      * @return
 894      */
 895     virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell,
 896                          int nDepth) override;
 897
 898     /**
 899      * Prepares the SmRect to render.
 900      * @param rDev
 901      * @param rFormat
 902      * @return
 903      */
 904     virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
 905
 906     /**
 907      * Accept a visitor.
 908      * Calls the method for this class on the visitor.
 909      * @param pVisitor
 910      * @return
 911      */
 912     void Accept(SmVisitor* pVisitor) override;
 913 };
 914
 915
 916 /** Glyph node for custom operators
 917  *
 918  * This node is used with commands: oper, uoper and boper.
 919  * E.g. in "A boper op B", "op" will be an instance of SmGlyphSpecialNode.
 920  * "boper" simply interprets "op", the following token, as a binary operator.
 921  * The command "uoper" interprets the following token as unary operator.
 922  * For these commands an instance of SmGlyphSpecialNode is used for the
 923  * operator token, following the command.
 924  */
 925 class SmGlyphSpecialNode final : public SmSpecialNode
 926 {
 927 public:
 928     explicit SmGlyphSpecialNode(const SmToken &rNodeToken)
 929         : SmSpecialNode(SmNodeType::GlyphSpecial, rNodeToken, FNT_MATH)
 930     {}
 931
 932     /**
 933      * Prepares the SmRect to render.
 934      * @param rDev
 935      * @param rFormat
 936      * @return
 937      */
 938     virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
 939
 940     /**
 941      * Accept a visitor.
 942      * Calls the method for this class on the visitor.
 943      * @param pVisitor
 944      * @return
 945      */
 946     void Accept(SmVisitor* pVisitor) override;
 947 };
 948
 949
 950 /** Math symbol node
 951  *
 952  * Use for math symbols such as plus, minus and integral in the INT command.
 953  */
 954 class SmMathSymbolNode : public SmSpecialNode
 955 {
 956 protected:
 957     SmMathSymbolNode(SmNodeType eNodeType, const SmToken &rNodeToken)
 958     :   SmSpecialNode(eNodeType, rNodeToken, FNT_MATH)
 959     {
 960         SetText(GetToken().cMathChar);
 961     }
 962
 963 public:
 964     explicit SmMathSymbolNode(const SmToken &rNodeToken);
 965
 966     //visual stuff TODO comment
 967     virtual void AdaptToX(OutputDevice &rDev, sal_uLong nWidth) override;
 968     virtual void AdaptToY(OutputDevice &rDev, sal_uLong nHeight) override;
 969
 970     /**
 971      * Prepare preliminary settings about font and text
 972      * (e.g. maFace, meRectHorAlign, mnFlags, mnAttributes, etc.)
 973      * @param rFormat
 974      * @param rDocShell
 975      * @param nDepth
 976      * @return
 977      */
 978     virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell,
 979                          int nDepth) override;
 980
 981     /**
 982      * Prepares the SmRect to render.
 983      * @param rDev
 984      * @param rFormat
 985      * @return
 986      */
 987     virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
 988
 989     /**
 990      * Accept a visitor.
 991      * Calls the method for this class on the visitor.
 992      * @param pVisitor
 993      * @return
 994      */
 995     void Accept(SmVisitor* pVisitor) override;
 996 };
 997
 998
 999 /** Math Identifier
1000  *
1001  * This behaves essentially the same as SmMathSymbolNode and is only used to
1002  * represent math symbols that should be exported as <mi> elements rather than
1003  * <mo> elements.
1004  */
1005 class SmMathIdentifierNode final : public SmMathSymbolNode
1006 {
1007 public:
1008     explicit SmMathIdentifierNode(const SmToken &rNodeToken)
1009         : SmMathSymbolNode(SmNodeType::MathIdent, rNodeToken) {}
1010 };
1011
1012
1013 /** Root symbol node
1014  *
1015  * Root symbol node used by SmRootNode to create the root symbol, in front of
1016  * the line with the line above. I don't think this node should be used for
1017  * anything else.
1018  */
1019 class SmRootSymbolNode final : public SmMathSymbolNode
1020 {
1021     sal_uLong mnBodyWidth;  // width of body (argument) of root sign
1022
1023 public:
1024     explicit SmRootSymbolNode(const SmToken &rNodeToken)
1025         : SmMathSymbolNode(SmNodeType::RootSymbol, rNodeToken)
1026         , mnBodyWidth(0) { }
1027
1028     /**
1029      * Gets the body width.
1030      * Allows to know how long is the root and paint it.
1031      * @return body width
1032      */
1033     sal_uLong GetBodyWidth() const {return mnBodyWidth;};
1034
1035     //visual stuff TODO comment
1036     virtual void AdaptToX(OutputDevice &rDev, sal_uLong nHeight) override;
1037     virtual void AdaptToY(OutputDevice &rDev, sal_uLong nHeight) override;
1038
1039     /**
1040      * Accept a visitor.
1041      * Calls the method for this class on the visitor.
1042      * @param pVisitor
1043      * @return
1044      */
1045     void Accept(SmVisitor* pVisitor) override;
1046 };
1047
1048
1049 /** Place node
1050  *
1051  * Used to create the <?> command, that denotes place where something can be
1052  * written.
1053  * It is drawn as a square with a shadow.
1054  */
1055 class SmPlaceNode final : public SmMathSymbolNode
1056 {
1057 public:
1058     explicit SmPlaceNode(const SmToken &rNodeToken)
1059         : SmMathSymbolNode(SmNodeType::Place, rNodeToken) { }
1060     SmPlaceNode() : SmMathSymbolNode(SmNodeType::Place, SmToken(TPLACE, MS_PLACE, "<?>")) { };
1061
1062     /**
1063      * Prepare preliminary settings about font and text
1064      * (e.g. maFace, meRectHorAlign, mnFlags, mnAttributes, etc.)
1065      * @param rFormat
1066      * @param rDocShell
1067      * @param nDepth
1068      * @return
1069      */
1070     virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell,
1071                          int nDepth) override;
1072
1073     /**
1074      * Prepares the SmRect to render.
1075      * @param rDev
1076      * @param rFormat
1077      * @return
1078      */
1079     virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
1080
1081     /**
1082      * Accept a visitor.
1083      * Calls the method for this class on the visitor.
1084      * @param pVisitor
1085      * @return
1086      */
1087     void Accept(SmVisitor* pVisitor) override;
1088 };
1089
1090
1091 /** Error node, for parsing errors
1092  *
1093  * This node is used for parsing errors and draws a questionmark turned upside
1094  * down (inverted question mark).
1095  */
1096 class SmErrorNode final : public SmMathSymbolNode
1097 {
1098 public:
1099     explicit SmErrorNode(const SmToken &rNodeToken)
1100                 : SmMathSymbolNode(SmNodeType::Error, rNodeToken) { SetText(OUString(MS_ERROR)); }
1101
1102     /**
1103      * Prepare preliminary settings about font and text
1104      * (e.g. maFace, meRectHorAlign, mnFlags, mnAttributes, etc.)
1105      * @param rFormat
1106      * @param rDocShell
1107      * @param nDepth
1108      * @return
1109      */
1110     virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell,
1111                          int nDepth) override;
1112
1113     /**
1114      * Prepares the SmRect to render.
1115      * @param rDev
1116      * @param rFormat
1117      * @return
1118      */
1119     virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
1120
1121     /**
1122      * Accept a visitor.
1123      * Calls the method for this class on the visitor.
1124      * @param pVisitor
1125      * @return
1126      */
1127     void Accept(SmVisitor* pVisitor) override;
1128 };
1129
1130
1131 /** Table node
1132  *
1133  * This is the root node for the formula tree. This node is also used for the
1134  * STACK and BINOM commands. When used for root node, its
1135  * children are instances of SmLineNode, and in some obscure cases the child
1136  * can be an instance of SmExpressionNode, mainly when errors occur.
1137  */
1138 class SmTableNode final : public SmStructureNode
1139 {
1140     tools::Long mnFormulaBaseline;
1141 public:
1142     explicit SmTableNode(const SmToken &rNodeToken)
1143         : SmStructureNode(SmNodeType::Table, rNodeToken)
1144         , mnFormulaBaseline(0) { }
1145
1146     virtual const SmNode * GetLeftMost() const override;
1147
1148     /**
1149      * Prepares the SmRect to render.
1150      * @param rDev
1151      * @param rFormat
1152      * @return
1153      */
1154     virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
1155
1156     /**
1157      * Gets the formula baseline.
1158      * @return formula baseline
1159      */
1160     tools::Long GetFormulaBaseline() const;
1161
1162     /**
1163      * Accept a visitor.
1164      * Calls the method for this class on the visitor.
1165      * @param pVisitor
1166      * @return
1167      */
1168     void Accept(SmVisitor* pVisitor) override;
1169 };
1170
1171
1172 /** A line
1173  *
1174  * Used as child of SmTableNode when the SmTableNode is the root node of the
1175  * formula tree.
1176  */
1177 class SmLineNode : public SmStructureNode
1178 {
1179     bool mbUseExtraSpaces;
1180
1181 protected:
1182     SmLineNode(SmNodeType eNodeType, const SmToken &rNodeToken)
1183         : SmStructureNode(eNodeType, rNodeToken)
1184         , mbUseExtraSpaces(true) { }
1185
1186 public:
1187     explicit SmLineNode(const SmToken &rNodeToken)
1188         : SmStructureNode(SmNodeType::Line, rNodeToken)
1189         , mbUseExtraSpaces(true) { }
1190
1191     /**
1192      * Sets if it going to use extra spaces.
1193      * It is used to set if there has to be space between node while rendering.
1194      * By default it is true.
1195      * @param bVal
1196      * @return
1197      */
1198     void  SetUseExtraSpaces(bool bVal) { mbUseExtraSpaces = bVal; }
1199
1200     /**
1201      * Checks if it is using extra spaces.
1202      * It is used for calculating space between nodes when rendering.
1203      * By default it is true.
1204      * @return is using extra spaces
1205      */
1206     bool  IsUseExtraSpaces() const { return mbUseExtraSpaces; };
1207
1208     /**
1209      * Prepare preliminary settings about font and text
1210      * (e.g. maFace, meRectHorAlign, mnFlags, mnAttributes, etc.)
1211      * @param rFormat
1212      * @param rDocShell
1213      * @param nDepth
1214      * @return
1215      */
1216     virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell,
1217                          int nDepth) override;
1218
1219     /**
1220      * Prepares the SmRect to render.
1221      * @param rDev
1222      * @param rFormat
1223      * @return
1224      */
1225     virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
1226
1227     /**
1228      * Accept a visitor.
1229      * Calls the method for this class on the visitor.
1230      * @param pVisitor
1231      * @return
1232      */
1233     void Accept(SmVisitor* pVisitor) override;
1234 };
1235
1236
1237 /** Expression node
1238  *
1239  * Used whenever you have an expression such as "A OVER {B + C}", here there is
1240  * an expression node that allows "B + C" to be the denominator of the
1241  * SmBinVerNode, that the OVER command creates.
1242  */
1243 class SmExpressionNode final : public SmLineNode
1244 {
1245 public:
1246     explicit SmExpressionNode(const SmToken &rNodeToken)
1247         : SmLineNode(SmNodeType::Expression, rNodeToken) { }
1248
1249     /**
1250      * Prepares the SmRect to render.
1251      * @param rDev
1252      * @param rFormat
1253      * @return
1254      */
1255     virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
1256
1257     /**
1258      * Accept a visitor.
1259      * Calls the method for this class on the visitor.
1260      * @param pVisitor
1261      * @return
1262      */
1263     void Accept(SmVisitor* pVisitor) override;
1264 };
1265
1266
1267 /** Unary horizontal node
1268  *
1269  * The same as SmBinHorNode except this is for unary operators.
1270  */
1271 class SmUnHorNode final : public SmStructureNode
1272 {
1273 public:
1274     explicit SmUnHorNode(const SmToken &rNodeToken)
1275         : SmStructureNode(SmNodeType::UnHor, rNodeToken, 2) { }
1276
1277     /**
1278      * Prepares the SmRect to render.
1279      * @param rDev
1280      * @param rFormat
1281      * @return
1282      */
1283     virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
1284
1285     /**
1286      * Accept a visitor.
1287      * Calls the method for this class on the visitor.
1288      * @param pVisitor
1289      * @return
1290      */
1291     void Accept(SmVisitor* pVisitor) override;
1292 };
1293
1294
1295 /** Root node
1296  *
1297  * Used for create square roots and other roots, example:
1298  * \f$ \sqrt[\mbox{[Argument]}]{\mbox{[Body]}} \f$.
1299  *
1300  * Children:<BR>
1301  * 0: Argument (optional)<BR>
1302  * 1: Symbol (instance of SmRootSymbolNode)<BR>
1303  * 2: Body<BR>
1304  * Where argument is optional and may be NULL.
1305  */
1306 class SmRootNode final : public SmStructureNode
1307 {
1308 public:
1309     explicit SmRootNode(const SmToken &rNodeToken)
1310         : SmStructureNode(SmNodeType::Root, rNodeToken, 3) { }
1311
1312     /**
1313      * Prepares the SmRect to render.
1314      * @param rDev
1315      * @param rFormat
1316      * @return
1317      */
1318     virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
1319
1320     /**
1321      * Accept a visitor.
1322      * Calls the method for this class on the visitor.
1323      * @param pVisitor
1324      * @return
1325      */
1326     void Accept(SmVisitor* pVisitor) override;
1327
1328     /**
1329      * Returns the node containing the data of the order of the root.
1330      * @return order data
1331      */
1332     const SmNode* Argument() const { return const_cast<SmRootNode *>(this)->Argument(); }
1333           SmNode* Argument()       { assert( GetNumSubNodes() == 3 ); return GetSubNode( 0 ); }
1334
1335     /**
1336      * Returns the node containing the data of the character used for the root.
1337      * @return symbol data
1338      */
1339     const SmRootSymbolNode* Symbol() const { return const_cast<SmRootNode *>(this)->Symbol(); }
1340           SmRootSymbolNode* Symbol()       { assert( GetNumSubNodes() == 3 );
1341                                              assert( GetSubNode( 1 )->GetType()
1342                                                         == SmNodeType::RootSymbol );
1343                                              return static_cast< SmRootSymbolNode* >
1344                                                 ( GetSubNode( 1 )); }
1345
1346     /**
1347      * Returns the node containing the data inside the root.
1348      * @return body data
1349      */
1350     const SmNode* Body() const { return const_cast<SmRootNode *>(this)->Body(); }
1351           SmNode* Body()       { assert( GetNumSubNodes() == 3 ); return GetSubNode( 2 ); }
1352
1353 };
1354
1355
1356 /** Binary horizontal node
1357  *
1358  * This node is used for binary operators. In a formula such as "A + B".
1359  *
1360  * Children:<BR>
1361  * 0: Left operand<BR>
1362  * 1: Binary operator<BR>
1363  * 2: Right operand<BR>
1364  *
1365  * None of the children may be NULL.
1366  */
1367 class SmBinHorNode final : public SmStructureNode
1368 {
1369 public:
1370     explicit SmBinHorNode(const SmToken &rNodeToken)
1371         : SmStructureNode(SmNodeType::BinHor, rNodeToken, 3) { }
1372
1373     /**
1374      * Prepares the SmRect to render.
1375      * @param rDev
1376      * @param rFormat
1377      * @return
1378      */
1379     virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
1380
1381     /**
1382      * Accept a visitor.
1383      * Calls the method for this class on the visitor.
1384      * @param pVisitor
1385      * @return
1386      */
1387     void Accept(SmVisitor* pVisitor) override;
1388
1389     /**
1390      * Returns the node containing the data of the binary operator.
1391      * @return symbol data
1392      */
1393     const SmNode* Symbol() const { return const_cast<SmBinHorNode *>(this)->Symbol(); }
1394           SmNode* Symbol()       { assert( GetNumSubNodes() == 3 ); return GetSubNode( 1 ); }
1395
1396     /**
1397      * Returns the node containing the data of the left operand.
1398      * @return left operand data
1399      */
1400     const SmNode* LeftOperand() const { return const_cast<SmBinHorNode *>(this)->LeftOperand(); }
1401           SmNode* LeftOperand()       { assert( GetNumSubNodes() == 3 ); return GetSubNode( 0 ); }
1402
1403     /**
1404      * Returns the node containing the data of the right operand.
1405      * @return right operand data
1406      */
1407     const SmNode* RightOperand() const { return const_cast<SmBinHorNode *>(this)->RightOperand(); }
1408           SmNode* RightOperand()       { assert( GetNumSubNodes() == 3 ); return GetSubNode( 2 ); }
1409 };
1410
1411
1412 /** Binary horizontal node
1413  *
1414  * This node is used for creating the OVER command, consider the formula:
1415  * "numerator OVER denominator", which looks like
1416  * \f$ \frac{\mbox{numerator}}{\mbox{denominator}} \f$
1417  *
1418  * Children:<BR>
1419  * 0: Numerator<BR>
1420  * 1: Line (instance of SmRectangleNode)<BR>
1421  * 2: Denominator<BR>
1422  * None of the children may be NULL.
1423  */
1424 class SmBinVerNode final : public SmStructureNode
1425 {
1426 public:
1427     explicit SmBinVerNode(const SmToken &rNodeToken)
1428         : SmStructureNode(SmNodeType::BinVer, rNodeToken, 3) { }
1429
1430     virtual const SmNode * GetLeftMost() const override;
1431
1432     /**
1433      * Prepares the SmRect to render.
1434      * @param rDev
1435      * @param rFormat
1436      * @return
1437      */
1438     virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
1439
1440     /**
1441      * Accept a visitor.
1442      * Calls the method for this class on the visitor.
1443      * @param pVisitor
1444      * @return
1445      */
1446     void Accept(SmVisitor* pVisitor) override;
1447 };
1448
1449
1450 /** Binary diagonal node
1451  *
1452  * Used for implementing the WIDESLASH command, example: "A WIDESLASH B".
1453  *
1454  * Children:<BR>
1455  * 0: Left operand<BR>
1456  * 1: right operand<BR>
1457  * 2: Line (instance of SmPolyLineNode).<BR>
1458  * None of the children may be NULL.
1459  */
1460 class SmBinDiagonalNode final : public SmStructureNode
1461 {
1462     bool mbAscending;
1463
1464     /**
1465      * Returns the position and size of the diagonal line by reference.
1466      * @param rPos
1467      * @param rSize
1468      * @param rDiagPoint
1469      * @param fAngleDeg
1470      * @return position and size of the diagonal line
1471      */
1472     void GetOperPosSize(Point &rPos, Size &rSize, const Point &rDiagPoint, double fAngleDeg) const;
1473
1474 public:
1475     explicit SmBinDiagonalNode(const SmToken &rNodeToken)
1476         : SmStructureNode(SmNodeType::BinDiagonal, rNodeToken, 3)
1477         , mbAscending(false) { }
1478
1479     /**
1480      * Checks if it is of ascending type.
1481      * Ascending:
1482      *     / b
1483      *    /
1484      * a /
1485      * Descending:
1486      * a \
1487      *    \
1488      *     \ b
1489      * @return ascending.
1490      */
1491     bool    IsAscending() const { return mbAscending; }
1492
1493     /**
1494      * Sets if the wideslash is ascending to bVal.
1495      * @param bVal
1496      * @return
1497      */
1498     void    SetAscending(bool bVal)  { mbAscending = bVal; }
1499
1500     /**
1501      * Prepares the SmRect to render.
1502      * @param rDev
1503      * @param rFormat
1504      * @return
1505      */
1506     virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
1507
1508     /**
1509      * Accept a visitor.
1510      * Calls the method for this class on the visitor.
1511      * @param pVisitor
1512      * @return
1513      */
1514     void Accept(SmVisitor* pVisitor) override;
1515 };
1516
1517
1518 /** Enum used to index sub-/supscripts in the 'maSubNodes' array
1519  * in 'SmSubSupNode'
1520  *
1521  * See graphic for positions at char:
1522  *
1523  * \code
1524  *      CSUP
1525  *
1526  * LSUP H  H RSUP
1527  *      H  H
1528  *      HHHH
1529  *      H  H
1530  * LSUB H  H RSUB
1531  *
1532  *      CSUB
1533  * \endcode
1534  */
1535 enum SmSubSup
1536 {   CSUB, CSUP, RSUB, RSUP, LSUB, LSUP
1537 };
1538
1539 /** numbers of entries in the above enum (that is: the number of possible
1540  * sub-/supscripts)
1541  */
1542 #define SUBSUP_NUM_ENTRIES 6
1543
1544 /** Super- and subscript node
1545  *
1546  * Used for creating super- and subscripts for commands such as:
1547  * "^", "_", "lsup", "lsub", "csup" and "csub".
1548  * Example: "A^2" which looks like: \f$ A^2 \f$
1549  *
1550  * This node is also used for creating limits on SmOperNode, when
1551  * "FROM" and "TO" commands are used with "INT", "SUM" or similar.
1552  *
1553  * Children of this node can be enumerated using the SmSubSup enum.
1554  * Please note that children may be NULL, except for the body.
1555  * It is recommended that you access children using GetBody() and
1556  * GetSubSup().
1557  */
1558 class SmSubSupNode final : public SmStructureNode
1559 {
1560     bool mbUseLimits;
1561
1562 public:
1563     explicit SmSubSupNode(const SmToken &rNodeToken)
1564         : SmStructureNode(SmNodeType::SubSup, rNodeToken, 1 + SUBSUP_NUM_ENTRIES)
1565         , mbUseLimits(false) { }
1566
1567     /**
1568      * Returns the node with the data of what has to be superindex or subindex.
1569      * @return body data
1570      */
1571     const SmNode * GetBody() const { return const_cast<SmSubSupNode *>(this)->GetBody(); }
1572           SmNode * GetBody()       { return GetSubNode(0); }
1573
1574     /**
1575      * Checks if it is going to be used for a limit.
1576      * Example lim from { x toward 0 } { {sin x}over x } = 1
1577      * @return is a limit
1578      */
1579     bool  IsUseLimits() const { return mbUseLimits; };
1580
1581     /**
1582      * Sets if it is going to be used for a limit to bVal.
1583      * @param bVal
1584      * @return
1585      */
1586     void  SetUseLimits(bool bVal) { mbUseLimits = bVal; }
1587
1588     /**
1589      * Gets the node with the data of what has to be superindex or subindex.
1590      * The position to check is given by eSubSup.
1591      * @remarks this method may return NULL.
1592      * @param eSubSup
1593      * @return body data
1594      */
1595      const SmNode * GetSubSup(SmSubSup eSubSup) const { return const_cast< SmSubSupNode* >
1596                                                             ( this )->GetSubSup( eSubSup ); }
1597            SmNode * GetSubSup(SmSubSup eSubSup)       { return GetSubNode(1 + eSubSup); };
1598
1599     /**
1600      * Sets the node with the data of what has to be superindex or subindex.
1601      * @param pScript
1602      */
1603     void SetBody(SmNode* pBody) { SetSubNode(0, pBody); }
1604
1605      /**
1606      * Sets the node with the data of what has to be superindex or subindex.
1607      * The position to check is given by eSubSup.
1608      * @param eSubSup
1609      * @param pScript
1610      */
1611     void SetSubSup(SmSubSup eSubSup, SmNode* pScript) { SetSubNode( 1 + eSubSup, pScript); }
1612
1613     /**
1614      * Prepares the SmRect to render.
1615      * @param rDev
1616      * @param rFormat
1617      * @return
1618      */
1619     virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
1620
1621     /**
1622      * Accept a visitor.
1623      * Calls the method for this class on the visitor.
1624      * @param pVisitor
1625      * @return
1626      */
1627     void Accept(SmVisitor* pVisitor) override;
1628
1629 };
1630
1631
1632 /** Node for brace construction
1633  *
1634  * Used for "lbrace [body] rbrace" and similar constructions.
1635  * Should look like \f$ \{\mbox{[body]}\} \f$
1636  *
1637  * Children:<BR>
1638  * 0: Opening brace<BR>
1639  * 1: Body (usually SmBracebodyNode)<BR>
1640  * 2: Closing brace<BR>
1641  * None of the children can be NULL.
1642  *
1643  * Note that child 1 (Body) is usually SmBracebodyNode, but it can also be e.g. SmExpressionNode.
1644  */
1645 class SmBraceNode final : public SmStructureNode
1646 {
1647 public:
1648     explicit SmBraceNode(const SmToken &rNodeToken)
1649         : SmStructureNode(SmNodeType::Brace, rNodeToken, 3) { }
1650
1651     /**
1652      * Returns the node containing the data of the opening brace.
1653      * @return opening brace data
1654      */
1655     const SmMathSymbolNode* OpeningBrace() const { return const_cast<SmBraceNode *>
1656                                                        (this)->OpeningBrace(); }
1657     SmMathSymbolNode* OpeningBrace()             { assert( GetNumSubNodes() == 3 );
1658                                                    assert( GetSubNode( 0 )->GetType()
1659                                                                == SmNodeType::Math );
1660                                                    return static_cast< SmMathSymbolNode* >
1661                                                        ( GetSubNode( 0 )); }
1662
1663     /**
1664      * Returns the node containing the data of what is between braces.
1665      * @return body data
1666      */
1667     const SmNode* Body() const { return const_cast<SmBraceNode *>(this)->Body(); }
1668     SmNode* Body()             { assert( GetNumSubNodes() == 3 ); return GetSubNode( 1 ); }
1669
1670     /**
1671      * Returns the node containing the data of the closing brace.
1672      * @return closing brace data
1673      */
1674     const SmMathSymbolNode* ClosingBrace() const { return const_cast<SmBraceNode *>
1675                                                        (this)->ClosingBrace(); }
1676     SmMathSymbolNode* ClosingBrace()             { assert( GetNumSubNodes() == 3 );
1677                                                    assert( GetSubNode( 2 )->GetType()
1678                                                                == SmNodeType::Math );
1679                                                    return static_cast< SmMathSymbolNode* >
1680                                                        ( GetSubNode( 2 )); }
1681
1682     /**
1683      * Prepares the SmRect to render.
1684      * @param rDev
1685      * @param rFormat
1686      * @return
1687      */
1688     virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
1689
1690     /**
1691      * Accept a visitor.
1692      * Calls the method for this class on the visitor.
1693      * @param pVisitor
1694      * @return
1695      */
1696     void Accept(SmVisitor* pVisitor) override;
1697 };
1698
1699
1700 /** Body of an SmBraceNode
1701  *
1702  * This usually only has one child an SmExpressionNode, however, it can also
1703  * have other children.
1704  * Consider the formula "lbrace [body1] mline [body2] rbrace", looks like:
1705  * \f$ \{\mbox{[body1] | [body2]}\} \f$.
1706  * In this case SmBracebodyNode will have three children, "[body1]", "|" and
1707  * [body2].
1708  */
1709 class SmBracebodyNode final : public SmStructureNode
1710 {
1711     tools::Long mnBodyHeight;
1712
1713 public:
1714     explicit SmBracebodyNode(const SmToken &rNodeToken)
1715         : SmStructureNode(SmNodeType::Bracebody, rNodeToken)
1716         , mnBodyHeight(0) { }
1717
1718     /**
1719      * Prepares the SmRect to render.
1720      * @param rDev
1721      * @param rFormat
1722      * @return
1723      */
1724     virtual void    Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
1725     tools::Long GetBodyHeight() const { return mnBodyHeight; }
1726
1727     /**
1728      * Accept a visitor.
1729      * Calls the method for this class on the visitor.
1730      * @param pVisitor
1731      * @return
1732      */
1733     void Accept(SmVisitor* pVisitor) override;
1734 };
1735
1736
1737 /** Node for vertical brace construction
1738  *
1739  * Used to implement commands "[body] underbrace [script]" and
1740  * "[body] overbrace [script]".
1741  * Underbrace should look like this \f$ \underbrace{\mbox{body}}_{\mbox{script}}\f$.
1742  *
1743  * Children:<BR>
1744  * 0: body<BR>
1745  * 1: brace<BR>
1746  * 2: script<BR>
1747  * (None of these children are optional, e.g. they must all be not NULL).
1748  */
1749 class SmVerticalBraceNode final : public SmStructureNode
1750 {
1751 public:
1752     explicit SmVerticalBraceNode(const SmToken &rNodeToken)
1753     : SmStructureNode(SmNodeType::VerticalBrace, rNodeToken, 3) { }
1754
1755     /**
1756      * Returns the node containing the data of what the brace is pointing for.
1757      * body { script }
1758      * @return body data
1759      */
1760     const SmNode* Body() const { return const_cast<SmVerticalBraceNode *>(this)->Body(); }
1761     SmNode* Body()             { assert( GetNumSubNodes() == 3 ); return GetSubNode( 0 ); }
1762
1763     /**
1764      * Returns the node containing the data of the brace.
1765      * @return brace data
1766      */
1767     const SmMathSymbolNode* Brace() const { return const_cast<SmVerticalBraceNode *>
1768                                                 (this)->Brace(); }
1769           SmMathSymbolNode* Brace()       { assert( GetNumSubNodes() == 3 );
1770                                             assert( GetSubNode( 1 )->GetType()
1771                                                         == SmNodeType::Math );
1772                                             return static_cast< SmMathSymbolNode* >
1773                                                 ( GetSubNode( 1 )); }
1774
1775     /**
1776      * Returns the node containing the data of what is in the brace.
1777      * body { script }
1778      * @return opening brace data
1779      */
1780     const SmNode* Script() const { return const_cast<SmVerticalBraceNode *>(this)->Script(); }
1781           SmNode* Script()       { assert( GetNumSubNodes() == 3 ); return GetSubNode( 2 ); }
1782
1783     /**
1784      * Prepares the SmRect to render.
1785      * @param rDev
1786      * @param rFormat
1787      * @return
1788      */
1789     virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
1790
1791     /**
1792      * Accept a visitor.
1793      * Calls the method for this class on the visitor.
1794      * @param pVisitor
1795      * @return
1796      */
1797     void Accept(SmVisitor* pVisitor) override;
1798 };
1799
1800 /** Operation Node
1801  *
1802  * Used for commands like SUM, INT and similar.
1803  *
1804  * Children:<BR>
1805  * 0: Operation (instance of SmMathSymbolNode or SmSubSupNode)<BR>
1806  * 1: Body<BR>
1807  * None of the children may be NULL.
1808  *
1809  */
1810 class SmOperNode final : public SmStructureNode
1811 {
1812 public:
1813     explicit SmOperNode(const SmToken &rNodeToken)
1814         : SmStructureNode(SmNodeType::Oper, rNodeToken, 2) { }
1815
1816     /**
1817      * Returns the node with the operator data
1818      * @return operator data
1819      */
1820     const SmNode * GetSymbol() const { return const_cast<SmOperNode *>(this)->GetSymbol(); }
1821           SmNode * GetSymbol();
1822
1823     /**
1824      * Returns the height of the node in base to the symbol
1825      * ( rSymbol contains the operator data )
1826      * and the font format ( rFormat ).
1827      * @param rSymbol
1828      * @param rFormat
1829      * @return node's height
1830      */
1831     tools::Long CalcSymbolHeight(const SmNode &rSymbol, const SmFormat &rFormat) const;
1832
1833     /**
1834      * Prepares the SmRect to render.
1835      * @param rDev
1836      * @param rFormat
1837      * @return
1838      */
1839     virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
1840
1841     /**
1842      * Accept a visitor.
1843      * Calls the method for this class on the visitor.
1844      * @param pVisitor
1845      * @return
1846      */
1847     void Accept(SmVisitor* pVisitor) override;
1848 };
1849
1850
1851 /** Node used for alignment
1852  *
1853  * This node has exactly one child at index 0.
1854  */
1855 class SmAlignNode final : public SmStructureNode
1856 {
1857 public:
1858     explicit SmAlignNode(const SmToken &rNodeToken)
1859         : SmStructureNode(SmNodeType::Align, rNodeToken) { }
1860
1861     /**
1862      * Prepares the SmRect to render.
1863      * @param rDev
1864      * @param rFormat
1865      * @return
1866      */
1867     virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
1868
1869     /**
1870      * Accept a visitor.
1871      * Calls the method for this class on the visitor.
1872      * @param pVisitor
1873      * @return
1874      */
1875     void Accept(SmVisitor* pVisitor) override;
1876 };
1877
1878
1879 /** Attribute node
1880  *
1881  * Used to give an attribute to another node. Used for commands such as:
1882  * UNDERLINE, OVERLINE, OVERSTRIKE, WIDEVEC, WIDEHARPOON, WIDEHAT and WIDETILDE.
1883  *
1884  * Children:<BR>
1885  * 0: Attribute<BR>
1886  * 1: Body<BR>
1887  * None of these may be NULL.
1888  */
1889 class SmAttributeNode final : public SmStructureNode
1890 {
1891 public:
1892     explicit SmAttributeNode(const SmToken &rNodeToken)
1893         : SmStructureNode(SmNodeType::Attribute, rNodeToken, 2) {}
1894
1895     /**
1896      * Prepares the SmRect to render.
1897      * @param rDev
1898      * @param rFormat
1899      * @return
1900      */
1901     virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
1902
1903     /**
1904      * Accept a visitor.
1905      * Calls the method for this class on the visitor.
1906      * @param pVisitor
1907      * @return
1908      */
1909     void Accept(SmVisitor* pVisitor) override;
1910
1911     /**
1912      * Gets the attribute data.
1913      * @return attribute data
1914      */
1915     const SmNode* Attribute() const { return const_cast<SmAttributeNode *>(this)->Attribute(); }
1916           SmNode* Attribute()       { assert( GetNumSubNodes() == 2 ); return GetSubNode( 0 ); }
1917
1918     /**
1919      * Gets the body data ( the nodes affected by the attribute ).
1920      * @return body data
1921      */
1922     const SmNode* Body() const { return const_cast<SmAttributeNode *>(this)->Body(); }
1923           SmNode* Body()      { assert( GetNumSubNodes() == 2 ); return GetSubNode( 1 ); }
1924 };
1925
1926
1927 /** Font node
1928  *
1929  * Used to change the font of its children.
1930  */
1931 class SmFontNode final : public SmStructureNode
1932 {
1933     FontSizeType meSizeType;
1934     Fraction     maFontSize;
1935
1936 public:
1937     explicit SmFontNode(const SmToken &rNodeToken)
1938         : SmStructureNode(SmNodeType::Font, rNodeToken)
1939         , meSizeType(FontSizeType::MULTIPLY)
1940         , maFontSize(1) { }
1941
1942     /**
1943      * Sets font size to rValue in nType mode.
1944      * Check FontSizeType for details.
1945      * @param rValue
1946      * @param nType
1947      * @return
1948      */
1949     void SetSizeParameter(const Fraction &rValue, FontSizeType nType)
1950                             { meSizeType = nType; maFontSize = rValue; }
1951
1952     /**
1953      * Returns the font size.
1954      * @return font size.
1955      */
1956     const Fraction & GetSizeParameter() const {return maFontSize;}
1957
1958     /**
1959      * Returns the font size type.
1960      * Check FontSizeType for details.
1961      * @return font size type.
1962      */
1963     FontSizeType GetSizeType() const {return meSizeType;}
1964
1965     /**
1966      * Prepare preliminary settings about font and text
1967      * (e.g. maFace, meRectHorAlign, mnFlags, mnAttributes, etc.)
1968      * @param rFormat
1969      * @param rDocShell
1970      * @param nDepth
1971      * @return
1972      */
1973     virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell,
1974                          int nDepth) override;
1975
1976     /**
1977      * Prepares the SmRect to render.
1978      * @param rDev
1979      * @param rFormat
1980      * @return
1981      */
1982     virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
1983
1984     /**
1985      * Accept a visitor.
1986      * Calls the method for this class on the visitor.
1987      * @param pVisitor
1988      * @return
1989      */
1990     void Accept(SmVisitor* pVisitor) override;
1991 };
1992
1993
1994 /** Matrix node
1995  *
1996  * Used to implement the MATRIX command, example:
1997  * "matrix{ 1 # 2 ## 3 # 4}".
1998  */
1999 class SmMatrixNode final : public SmStructureNode
2000 {
2001     sal_uInt16 mnNumRows,
2002                mnNumCols;
2003
2004 public:
2005     explicit SmMatrixNode(const SmToken &rNodeToken)
2006         : SmStructureNode(SmNodeType::Matrix, rNodeToken)
2007         , mnNumRows(0)
2008         , mnNumCols(0) { }
2009
2010     /**
2011      * Gets the number of rows of the matrix.
2012      * @return rows number
2013      */
2014     sal_uInt16 GetNumRows() const {return mnNumRows;}
2015
2016     /**
2017      * Gets the number of columns of the matrix.
2018      * @return columns number
2019      */
2020     sal_uInt16 GetNumCols() const {return mnNumCols;}
2021
2022     /**
2023      * Sets the dimensions of the matrix.
2024      * @param nMatrixRows
2025      * @param nMatrixCols
2026      * @return
2027      */
2028     void SetRowCol(sal_uInt16 nMatrixRows, sal_uInt16 nMatrixCols)
2029                      { mnNumRows = nMatrixRows; mnNumCols = nMatrixCols; }
2030
2031     virtual const SmNode * GetLeftMost() const override;
2032
2033     /**
2034      * Prepares the SmRect to render.
2035      * @param rDev
2036      * @param rFormat
2037      * @return
2038      */
2039     virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
2040
2041     /**
2042      * Accept a visitor.
2043      * Calls the method for this class on the visitor.
2044      * @param pVisitor
2045      * @return
2046      */
2047     void Accept(SmVisitor* pVisitor) override;
2048 };
2049
2050
2051 /** Node for whitespace
2052  *
2053  * Used to implement the commands "~" and "`". This node is just a blank space.
2054  */
2055 class SmBlankNode final : public SmGraphicNode
2056 {
2057     sal_uInt16 mnNum;
2058
2059 public:
2060     explicit SmBlankNode(const SmToken &rNodeToken)
2061         : SmGraphicNode(SmNodeType::Blank, rNodeToken)
2062         , mnNum(0) { }
2063
2064     void         IncreaseBy(const SmToken &rToken, sal_uInt32 nMultiplyBy = 1);
2065     void         Clear() { mnNum = 0; }
2066     sal_uInt16   GetBlankNum() const { return mnNum; }
2067     void         SetBlankNum(sal_uInt16 nNumber) { mnNum = nNumber; }
2068
2069     /**
2070      * Prepare preliminary settings about font and text
2071      * (e.g. maFace, meRectHorAlign, mnFlags, mnAttributes, etc.)
2072      * @param rFormat
2073      * @param rDocShell
2074      * @param nDepth
2075      * @return
2076      */
2077     virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell,
2078                          int nDepth) override;
2079
2080     /**
2081      * Prepares the SmRect to render.
2082      * @param rDev
2083      * @param rFormat
2084      * @return
2085      */
2086     virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
2087
2088     /**
2089      * Accept a visitor.
2090      * Calls the method for this class on the visitor.
2091      * @param pVisitor
2092      * @return
2093      */
2094     void Accept(SmVisitor* pVisitor) override;
2095
2096 };
2097
2098 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */