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