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