LCOV - code coverage report
Current view: top level - libreoffice/starmath/inc - node.hxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 263 285 92.3 %
Date: 2012-12-27 Functions: 150 172 87.2 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10