path: root/starmath/inc/node.hxx

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */

/** The SmNode is the basic structure of formula data.
  *
  * Each token is stored in one node of specific kind.
  * They can have SmNodeType. It allows to identify node type after abstraction.
  * Here goes the subclasses tree:
  *
  * SmRect
  *     SmNode
  *         SmStructureNode                             Head of tree diagram
  *             SmTableNode                             binom
  *             SmLineNode                              A line
  *                 SmExpressionNode                    { content }
  *             SmUnHorNode                             unary operators +-; -+; +x; -x; ...
  *             SmRootNode                              Root structure
  *             SmBinHorNode                            binary operators A + B
  *             SmBinVerNode                            over; frac; ...
  *             SmBinDiagonalNode                       wideslash
  *             SmSubSupNode                            csub, csup, lsub, from, to, ...
  *             SmBraceNode                             (); []; left lbrace right rbrace; ...
  *             SmBracebodyNode                         ( content ); [ content ]; ...
  *             SmVerticalBraceNode                     overbrace; underbrace;
  *             SmOperNode                              sum from to; int from to;
  *             SmAlignNode                             text alignment
  *             SmAttributeNode                         font attributes; bold;
  *             SmFontNode                              font serif; ...
  *             SmMatrixNode                            matrix
  *         SmVisibleNode                               drawable node
  *             SmGraphicNode                           graphics display
  *                 SmRectangleNode
  *                 SmPolyLineNode                      overline; underline; widehat; ...
  *                 SmBlankNode                         blank space; ~; ...
  *             SmTextNode                              "text"; func functname; ...
  *                 SmSpecialNode
  *                     SmGlyphSpecialNode              %symbolname
  *                     SmMathSymbolNode                math symbols
  *                         SmMathIdentifierNode        variable
  *                         SmRootSymbolNode            root symbol
  *                         SmPlaceNode                 <?>
  *                         SmErrorNode                 red ? for errors
  *
  */

#pragma once

#include "types.hxx"
#include "token.hxx"
#include "rect.hxx"
#include "format.hxx"
#include "nodetype.hxx"

#include <editeng/editdata.hxx>

enum class FontAttribute {
    None   = 0x0000,
    Bold   = 0x0001,
    Italic = 0x0002
};

namespace o3tl
{
    template<> struct typed_flags<FontAttribute> : is_typed_flags<FontAttribute, 0x0003> {};
}


enum class FontSizeType {
  ABSOLUT  = 1,
  PLUS     = 2,
  MINUS    = 3,
  MULTIPLY = 4,
  DIVIDE   = 5
};

// flags to interdict respective status changes
enum class FontChangeMask {
    None     = 0x0000,
    Face     = 0x0001,
    Size     = 0x0002,
    Bold     = 0x0004,
    Italic   = 0x0008,
    Color    = 0x0010,
    Phantom  = 0x0020
};

namespace o3tl
{
    template<> struct typed_flags<FontChangeMask> : is_typed_flags<FontChangeMask, 0x003f> {};
}


class SmVisitor;
class SmDocShell;
class SmNode;
class SmStructureNode;

typedef std::vector< SmNode * > SmNodeArray;

enum class SmScaleMode
{
    None,
    Width,
    Height
};

class SmNode : public SmRect
{
    // Rendering info for SmRect
    SmFace          maFace;
    // Anclage to the code
    SmToken         maNodeToken;
    ESelection      m_aESelection;
    // Node information
    SmNodeType      meType;
    SmScaleMode     meScaleMode;
    RectHorAlign    meRectHorAlign;
    FontChangeMask  mnFlags;
    FontAttribute   mnAttributes;
    bool            mbIsPhantom;
    bool            mbIsSelected;
    // index in accessible text; -1 if not (yet) applicable
    sal_Int32       mnAccIndex;

protected:
    SmNode(SmNodeType eNodeType, const SmToken &rNodeToken);

public:
    SmNode(const SmNode&) = delete;
    SmNode& operator=(const SmNode&) = delete;

    virtual ~SmNode();

    /**
     * Checks node visibility.
     * Returns true if this is an instance of SmVisibleNode's subclass, false otherwise.
     * @return node visibility
     */
    virtual bool IsVisible() const = 0;

    /**
     * Gets the number of subnodes.
     * @return number of subnodes
     */
    virtual size_t GetNumSubNodes() const = 0;

    /**
     * Gets the subnode of index nIndex.
     * @param nIndex
     * @return subnode of index nIndex
     */
    virtual SmNode * GetSubNode(size_t nIndex) = 0;
    const   SmNode * GetSubNode(size_t nIndex) const
                     { return const_cast<SmNode *>(this)->GetSubNode(nIndex); }

    virtual const SmNode * GetLeftMost() const;

    /**
     * Gets the FontChangeMask flags.
     * @return FontChangeMask flags
     */
    FontChangeMask &Flags() { return mnFlags; }

    /**
     * Gets the font attributes.
     * @return font attributes
     */
    FontAttribute &Attributes() { return mnAttributes; }

    /**
     * Checks if it is a visible node rendered invisible.
     * @return rendered visibility
     */
    bool IsPhantom() const { return mbIsPhantom; }

    /**
     * Sets the render visibility of a visible node to bIsPhantom.
     * @param bIsPhantom
     * @return
     */
    void SetPhantom(bool bIsPhantom);

    /**
     * Sets the font color.
     * @param rColor
     * @return
     */
    void SetColor(const Color &rColor);

    /**
     * Sets the font attribute nAttrib.
     * Check FontAttribute class.
     * @param nAttrib
     * @return
     */
    void SetAttribute(FontAttribute nAttrib);

    /**
     * Clears the font attribute nAttrib.
     * Check FontAttribute class.
     * @param nAttrib
     * @return
     */
    void ClearAttribute(FontAttribute nAttrib);

    /**
     * Gets the font.
     * @return font
     */
    const SmFace & GetFont() const { return maFace; };
          SmFace & GetFont()       { return maFace; };

    /**
     * Sets the font to rFace.
     * @param rFace
     * @return
     */
    void SetFont(const SmFace &rFace);

    /**
     * Sets the font size to rRelSize with type nType.
     * Check FontSizeType for details.
     * @param rRelSize
     * @param nType
     * @return
     */
    void SetFontSize(const Fraction &rRelSize, FontSizeType nType);

    /**
     * Sets the font size to rRelSize with type FontSizeType::ABSOLUT.
     * @param rScale
     * @return
     */
    void SetSize(const Fraction &rScale);

    /**
     * Prepare preliminary settings about font and text
     * (e.g. maFace, meRectHorAlign, mnFlags, mnAttributes, etc.)
     * @param rFormat
     * @param rDocShell
     * @param nDepth
     * @return
     */
    virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell, int nDepth);

    /**
     * Prepare preliminary font attributes
     * Called on Prepare(...).
     * @return
     */
    void PrepareAttributes();

    /**
     * Sets the alignment of the text.
     * Check RectHorAlign class for details.
     * The subtrees will be affected if bApplyToSubTree.
     * @param eHorAlign
     * @param bApplyToSubTree
     * @return
     */
    void SetRectHorAlign(RectHorAlign eHorAlign, bool bApplyToSubTree = true );

    /**
     * Gets the alignment of the text.
     * @return alignment of the text
     */
    RectHorAlign GetRectHorAlign() const { return meRectHorAlign; }

    /**
     * Parses itself to SmRect.
     * @return this
     */
    const SmRect & GetRect() const { return *this; }

    /**
     * Moves the rectangle by rVector.
     * @param rVector
     * @return
     */
    void Move(const Point &rVector);

    /**
     * Moves the rectangle to rPoint, being the top left corner the origin.
     * @param rPoint
     * @return
     */
    void MoveTo(const Point &rPoint) { Move(rPoint - GetTopLeft()); }

    /**
     * Prepares the SmRect to render.
     * @param rDev
     * @param rFormat
     * @return
     */
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) = 0;

    /**
     * Appends to rText the node text.
     * @param rText
     * @return
     */
    virtual void GetAccessibleText( OUStringBuffer &rText ) const = 0;

    /**
     * Gets the node accessible index.
     * Used for visual editing.
     * @return node accessible index
     */
    sal_Int32 GetAccessibleIndex() const { return mnAccIndex; }

    /**
     * Sets the node accessible index to nAccIndex.
     * Used for visual editing.
     * @param nAccIndex
     * @return
     */
    void SetAccessibleIndex(sal_Int32 nAccIndex) { mnAccIndex = nAccIndex; }

    /**
     * Finds the node with accessible index nAccIndex.
     * Used for visual editing.
     * @param nAccIndex
     * @return node with accessible index nAccIndex
     */
    const SmNode * FindNodeWithAccessibleIndex(sal_Int32 nAccIndex) const;

    /**
     * Gets the line in the text where the node is located.
     * It is used to do the visual <-> text correspondence.
     * @return line
     */
    sal_uInt16 GetRow() const { return sal::static_int_cast<sal_uInt16>(m_aESelection.nStartPara); }

    /**
     * Gets the column of the line in the text where the node is located.
     * It is used to do the visual <-> text correspondence.
     * @return column
     */
    sal_uInt16 GetColumn() const { return sal::static_int_cast<sal_uInt16>(m_aESelection.nStartPos); }

    /**
     * Gets the scale mode.
     * @return scale mode
     */
    SmScaleMode GetScaleMode() const { return meScaleMode; }

    /**
     * Sets the scale mode to eMode.
     * @param eMode
     * @return
     */
    void SetScaleMode(SmScaleMode eMode) { meScaleMode = eMode; }

    //visual stuff TODO comment
    virtual void AdaptToX(OutputDevice &rDev, sal_uLong nWidth);
    virtual void AdaptToY(OutputDevice &rDev, sal_uLong nHeight);

    /**
     * Gets the node type.
     * @return node type
     */
    SmNodeType GetType() const  { return meType; }

    /**
     * Gets the token.
     * The token contains the data extracted from the text mode.
     * Ej: text, type (sub, sup, int,...), row and column,...
     * @return node type
     */
    const SmToken & GetToken() const { return maNodeToken; }
          SmToken & GetToken()       { return maNodeToken; }

    /**
     * Gets node position in input text.
     * @return node position in input text
     */
    const ESelection& GetSelection() const { return m_aESelection; }

    /**
     * Gets node position in input text.
     * @param aESelection
     */
    void SetSelection(ESelection aESelection) { m_aESelection = aESelection; }

    /**
     * Finds the node from the position in the text.
     * It is used to do the visual <-> text correspondence.
     * @param nRow
     * @param nCol
     * @return the given node
     */
    const SmNode *  FindTokenAt(sal_uInt16 nRow, sal_uInt16 nCol) const;

    /**
     * Finds the closest rectangle in the screen.
     * @param rPoint
     * @return the given node
     */
    const SmNode *  FindRectClosestTo(const Point &rPoint) const;

    /**
     * Accept a visitor.
     * Calls the method for this class on the visitor.
     * @param pVisitor
     * @return
     */
    virtual void Accept(SmVisitor* pVisitor) = 0;

    /**
     * Checks if the node is selected.
     * @return the node is selected
     */
    bool IsSelected() const {return mbIsSelected;}

    /**
     * Sets the node to Selected.
     * @param Selected
     * @return
     */
    void SetSelected(bool Selected) {mbIsSelected = Selected;}

    /**
     * Gets the parent node of this node.
     * @return parent node
     */
    const SmStructureNode* GetParent() const { return mpParentNode; }
          SmStructureNode* GetParent()       { return mpParentNode; }

    /**
     * Sets the parent node.
     * @param parent
     * @return
     */
    void SetParent(SmStructureNode* parent){ mpParentNode = parent; }

    /**
     * Sets the token for this node.
     * @param token
     * @return
     */
    void SetToken(SmToken const & token){ maNodeToken = token; }

private:
    SmStructureNode* mpParentNode;
};


/** Abstract baseclass for all composite node
 *
 * Subclasses of this class can have subnodes. Nodes that doesn't derivate from
 * this class does not have subnodes.
 */
class SmStructureNode : public SmNode
{
    SmNodeArray maSubNodes;

protected:
    SmStructureNode(SmNodeType eNodeType, const SmToken &rNodeToken, size_t nSize = 0)
        : SmNode(eNodeType, rNodeToken)
        , maSubNodes(nSize) {}

public:
    virtual ~SmStructureNode() override;

    /**
     * Checks node visibility.
     * Returns true if this is an instance of SmVisibleNode's subclass, false otherwise.
     * @return node visibility
     */
    virtual bool IsVisible() const override;

    /**
     * Gets the number of subnodes.
     * @return number of subnodes
     */
    virtual size_t GetNumSubNodes() const override;

    /**
     * Gets the subnode of index nIndex.
     * @param nIndex
     * @return subnode of index nIndex
     */
    using   SmNode::GetSubNode;
    virtual SmNode * GetSubNode(size_t nIndex) override;

    /**
     * Gets the subnode of index nIndex, used for operators.
     * @param nIndex
     * @return subnode of index nIndex
     */
    SmNode * GetSubNodeBinMo(size_t nIndex) const;

    /**
     * Does the cleaning of the subnodes.
     * @return
     */
    void ClearSubNodes();

    /**
     * Sets subnodes, used for operators.
     * @param pFirst
     * @param pSecond
     * @param pThird
     * @return
     */
    void SetSubNodes(std::unique_ptr<SmNode> pFirst, std::unique_ptr<SmNode> pSecond,
                     std::unique_ptr<SmNode> pThird = nullptr);

    /**
     * Sets subnodes.
     * @param pFirst
     * @param pSecond
     * @param pThird
     * @return
     */
    void SetSubNodes(SmNode* pFirst, SmNode* pSecond, SmNode* pThird);

    /**
     * Sets subnodes, used for operators.
     * The data is reordered so the items are correctly ordered.
     * @param pFirst
     * @param pSecond
     * @param pThird
     * @return
     */
    void SetSubNodesBinMo(std::unique_ptr<SmNode> pFirst, std::unique_ptr<SmNode> pSecond,
                          std::unique_ptr<SmNode> pThird = nullptr);

    /**
     * Sets subnodes, used for operators.
     * The data is reordered so the items are correctly ordered.
     * @param pFirst
     * @param pSecond
     * @param pThird
     * @return
     */
    void SetSubNodesBinMo(SmNode* pFirst, SmNode* pSecond, SmNode* pThird);

    /**
     * Sets subnodes.
     * @param rNodeArray
     * @return
     */
    void SetSubNodes(SmNodeArray&& rNodeArray);

    /**
     * Appends to rText the node text.
     * @param rText
     * @return
     */
    virtual void  GetAccessibleText( OUStringBuffer &rText ) const override;

    /**
     * Gets the first subnode.
     * @return first subnode
     */
    SmNodeArray::iterator begin() {return maSubNodes.begin();}

    /**
     * Gets the last subnode.
     * @return last subnode
     */
    SmNodeArray::iterator end() {return maSubNodes.end();}

    /**
     * Gets the last subnode.
     * @return last subnode
     */
    SmNodeArray::reverse_iterator rbegin() {return maSubNodes.rbegin();}

    /**
     * Gets the first subnode.
     * @return first subnode
     */
    SmNodeArray::reverse_iterator rend() {return maSubNodes.rend();}

    /**
     * Get the index of the child node pSubNode.
     * Returns -1, if pSubNode isn't a subnode of this.
     * @param pSubNode
     * @return index of the child node
     */
    int IndexOfSubNode(SmNode const * pSubNode);

    /**
     * Sets the subnode pNode at nIndex.
     * If necessary increases the subnodes length.
     * @param nIndex
     * @param pNode
     * @return
     */
    void SetSubNode(size_t nIndex, SmNode* pNode);

private:
    /** Sets parent on children of this node */
    void ClaimPaternity();
};


/** Abstract base class for all visible node
 *
 * Nodes that doesn't derivate from this class doesn't draw anything, but their
 * children.
 */
class SmVisibleNode : public SmNode
{
protected:
    SmVisibleNode(SmNodeType eNodeType, const SmToken &rNodeToken)
    :   SmNode(eNodeType, rNodeToken) {}

public:

    /**
     * Checks node visibility.
     * Returns true if this is an instance of SmVisibleNode's subclass, false otherwise.
     * @return node visibility
     */
    virtual bool        IsVisible() const override;

    /**
     * Gets the number of subnodes.
     * @return number of subnodes
     */
    virtual size_t      GetNumSubNodes() const override;

    /**
     * Gets the subnode of index nIndex.
     * @param nIndex
     * @return subnode of index nIndex
     */
    using   SmNode::GetSubNode;
    virtual SmNode *    GetSubNode(size_t nIndex) override;
};


class SmGraphicNode : public SmVisibleNode
{
protected:
    SmGraphicNode(SmNodeType eNodeType, const SmToken &rNodeToken)
    :   SmVisibleNode(eNodeType, rNodeToken) {}

public:

    /**
     * Appends to rText the node text.
     * @param rText
     * @return
     */
    virtual void  GetAccessibleText( OUStringBuffer &rText ) const override;
};


/** Draws a rectangle
 *
 * Used for drawing the line in the OVER and OVERSTRIKE commands.
 */
class SmRectangleNode final : public SmGraphicNode
{
    Size maToSize;

public:
    explicit SmRectangleNode(const SmToken &rNodeToken)
        : SmGraphicNode(SmNodeType::Rectangle, rNodeToken)
    {}

    //visual stuff TODO comment
    virtual void AdaptToX(OutputDevice &rDev, sal_uLong nWidth) override;
    virtual void AdaptToY(OutputDevice &rDev, sal_uLong nHeight) override;

    /**
     * Prepares the SmRect to render.
     * @param rDev
     * @param rFormat
     * @return
     */
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;

    /**
     * Accept a visitor.
     * Calls the method for this class on the visitor.
     * @param pVisitor
     * @return
     */
    void Accept(SmVisitor* pVisitor) override;
};


/** Polygon line node
 *
 * Used to draw the slash of the WIDESLASH command by SmBinDiagonalNode.
 */
class SmPolyLineNode final : public SmGraphicNode
{
    tools::Polygon maPoly;
    Size maToSize;
    tools::Long mnWidth;

public:
    explicit SmPolyLineNode(const SmToken &rNodeToken);

    /**
     * Gets the width of the rect.
     * @return width
     */
    tools::Long GetWidth() const { return mnWidth; }

    /**
     * Gets the polygon to draw the node.
     * @return polygon
     */
    tools::Polygon &GetPolygon()  { return maPoly; }

    //visual stuff TODO comment
    virtual void AdaptToX(OutputDevice &rDev, sal_uLong nWidth) override;
    virtual void AdaptToY(OutputDevice &rDev, sal_uLong nHeight) override;

    /**
     * Prepares the SmRect to render.
     * @param rDev
     * @param rFormat
     * @return
     */
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;

    /**
     * Accept a visitor.
     * Calls the method for this class on the visitor.
     * @param pVisitor
     * @return
     */
    void Accept(SmVisitor* pVisitor) override;
};


/** Text node
 *
 * @remarks This class also serves as baseclass for all nodes that contains text.
 */
class SmTextNode : public SmVisibleNode
{

protected:
    OUString   maText;
    sal_uInt16 mnFontDesc;
    /** Index within text where the selection starts
     * @remarks Only valid if SmNode::IsSelected() is true
     */
    sal_Int32  mnSelectionStart;
    /** Index within text where the selection ends
     * @remarks Only valid if SmNode::IsSelected() is true
     */
    sal_Int32  mnSelectionEnd;

protected:
    SmTextNode(SmNodeType eNodeType, const SmToken &rNodeToken, sal_uInt16 nFontDescP );

public:
    SmTextNode(const SmToken &rNodeToken, sal_uInt16 nFontDescP );

    /**
     * Returns the font type being used (text, variable, symbol, ...).
     * @return font type
     */
    sal_uInt16 GetFontDesc() const { return mnFontDesc; }

    /**
     * Sets the node text to rText.
     * @param rText
     * @return
     */
    void SetText(const OUString &rText) { maText = rText; }

    /**
     * Gets the node text.
     * @return node text
     */
    const OUString & GetText() const { return maText; }
          OUString & GetText()       { return maText; }

    /**
     * Change the text of this node, including the underlying token to rText.
     * @param rText
     * @return
     */
    void ChangeText(const OUString &rText);

    /**
     * Try to guess the correct FontDesc, used during visual editing
     * @return
     */
    void AdjustFontDesc();

    /**
     * Index within GetText() where the selection starts.
     * @remarks Only valid of SmNode::IsSelected() is true.
     * @return index.
     */
    sal_Int32 GetSelectionStart() const { return mnSelectionStart; }

    /**
     * Index within GetText() where the selection ends.
     * @remarks Only valid of SmNode::IsSelected() is true.
     * @return index.
     */
    sal_Int32 GetSelectionEnd() const  {return mnSelectionEnd; }

    /**
     * Sets the index within GetText() where the selection starts to index.
     * @param index
     * @return
     */
    void SetSelectionStart(sal_Int32 index) {mnSelectionStart = index;}

    /**
     * Sets the index within GetText() where the selection ends to index.
     * @param index
     * @return
     */
    void SetSelectionEnd(sal_Int32 index) {mnSelectionEnd = index;}

    /**
     * Prepare preliminary settings about font and text
     * (e.g. maFace, meRectHorAlign, mnFlags, mnAttributes, etc.)
     * @param rFormat
     * @param rDocShell
     * @param nDepth
     * @return
     */
    virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell,
                         int nDepth) override;

    /**
     * Prepares the SmRect to render.
     * @param rDev
     * @param rFormat
     * @return
     */
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;

    /**
     * Appends to rText the node text.
     * @param rText
     * @return
     */
    virtual void  GetAccessibleText( OUStringBuffer &rText ) const override;

    /**
     * Accept a visitor.
     * Calls the method for this class on the visitor.
     * @param pVisitor
     * @return
     */
    void Accept(SmVisitor* pVisitor) override;

    /**
     * Converts the character from StarMath's private area symbols to a matching Unicode
     * character, if necessary. To be used when converting GetText() to a normal text.
     * @param nIn
     * @return unicode char
     */
    static sal_Unicode ConvertSymbolToUnicode(sal_Unicode nIn);
};


/** Special node for user defined characters
 *
 * Node used for pre- and user-defined characters from:
 * officecfg/registry/data/org/openoffice/Office/Math.xcu
 *
 * This is just single characters, I think.
 */
class SmSpecialNode : public SmTextNode
{
    bool mbIsFromGreekSymbolSet;

protected:
    SmSpecialNode(SmNodeType eNodeType, const SmToken &rNodeToken, sal_uInt16 _nFontDesc);

public:
    explicit SmSpecialNode(const SmToken &rNodeToken);

    /**
     * Prepare preliminary settings about font and text
     * (e.g. maFace, meRectHorAlign, mnFlags, mnAttributes, etc.)
     * @param rFormat
     * @param rDocShell
     * @param nDepth
     * @return
     */
    virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell,
                         int nDepth) override;

    /**
     * Prepares the SmRect to render.
     * @param rDev
     * @param rFormat
     * @return
     */
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;

    /**
     * Accept a visitor.
     * Calls the method for this class on the visitor.
     * @param pVisitor
     * @return
     */
    void Accept(SmVisitor* pVisitor) override;
};


/** Glyph node for custom operators
 *
 * This node is used with commands: oper, uoper and boper.
 * E.g. in "A boper op B", "op" will be an instance of SmGlyphSpecialNode.
 * "boper" simply interprets "op", the following token, as a binary operator.
 * The command "uoper" interprets the following token as unary operator.
 * For these commands an instance of SmGlyphSpecialNode is used for the
 * operator token, following the command.
 */
class SmGlyphSpecialNode final : public SmSpecialNode
{
public:
    explicit SmGlyphSpecialNode(const SmToken &rNodeToken)
        : SmSpecialNode(SmNodeType::GlyphSpecial, rNodeToken, FNT_MATH)
    {}

    /**
     * Prepares the SmRect to render.
     * @param rDev
     * @param rFormat
     * @return
     */
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;

    /**
     * Accept a visitor.
     * Calls the method for this class on the visitor.
     * @param pVisitor
     * @return
     */
    void Accept(SmVisitor* pVisitor) override;
};


/** Math symbol node
 *
 * Use for math symbols such as plus, minus and integral in the INT command.
 */
class SmMathSymbolNode : public SmSpecialNode
{
protected:
    SmMathSymbolNode(SmNodeType eNodeType, const SmToken &rNodeToken)
    :   SmSpecialNode(eNodeType, rNodeToken, FNT_MATH)
    {
        SetText(GetToken().cMathChar);
    }

public:
    explicit SmMathSymbolNode(const SmToken &rNodeToken);

    //visual stuff TODO comment
    virtual void AdaptToX(OutputDevice &rDev, sal_uLong nWidth) override;
    virtual void AdaptToY(OutputDevice &rDev, sal_uLong nHeight) override;

    /**
     * Prepare preliminary settings about font and text
     * (e.g. maFace, meRectHorAlign, mnFlags, mnAttributes, etc.)
     * @param rFormat
     * @param rDocShell
     * @param nDepth
     * @return
     */
    virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell,
                         int nDepth) override;

    /**
     * Prepares the SmRect to render.
     * @param rDev
     * @param rFormat
     * @return
     */
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;

    /**
     * Accept a visitor.
     * Calls the method for this class on the visitor.
     * @param pVisitor
     * @return
     */
    void Accept(SmVisitor* pVisitor) override;
};


/** Math Identifier
 *
 * This behaves essentially the same as SmMathSymbolNode and is only used to
 * represent math symbols that should be exported as <mi> elements rather than
 * <mo> elements.
 */
class SmMathIdentifierNode final : public SmMathSymbolNode
{
public:
    explicit SmMathIdentifierNode(const SmToken &rNodeToken)
        : SmMathSymbolNode(SmNodeType::MathIdent, rNodeToken) {}
};


/** Root symbol node
 *
 * Root symbol node used by SmRootNode to create the root symbol, in front of
 * the line with the line above. I don't think this node should be used for
 * anything else.
 */
class SmRootSymbolNode final : public SmMathSymbolNode
{
    sal_uLong mnBodyWidth;  // width of body (argument) of root sign

public:
    explicit SmRootSymbolNode(const SmToken &rNodeToken)
        : SmMathSymbolNode(SmNodeType::RootSymbol, rNodeToken)
        , mnBodyWidth(0) { }

    /**
     * Gets the body width.
     * Allows to know how long is the root and paint it.
     * @return body width
     */
    sal_uLong GetBodyWidth() const {return mnBodyWidth;};

    //visual stuff TODO comment
    virtual void AdaptToX(OutputDevice &rDev, sal_uLong nHeight) override;
    virtual void AdaptToY(OutputDevice &rDev, sal_uLong nHeight) override;

    /**
     * Accept a visitor.
     * Calls the method for this class on the visitor.
     * @param pVisitor
     * @return
     */
    void Accept(SmVisitor* pVisitor) override;
};


/** Place node
 *
 * Used to create the <?> command, that denotes place where something can be
 * written.
 * It is drawn as a square with a shadow.
 */
class SmPlaceNode final : public SmMathSymbolNode
{
public:
    explicit SmPlaceNode(const SmToken &rNodeToken)
        : SmMathSymbolNode(SmNodeType::Place, rNodeToken) { }
    SmPlaceNode() : SmMathSymbolNode(SmNodeType::Place, SmToken(TPLACE, MS_PLACE, "<?>")) { };

    /**
     * Prepare preliminary settings about font and text
     * (e.g. maFace, meRectHorAlign, mnFlags, mnAttributes, etc.)
     * @param rFormat
     * @param rDocShell
     * @param nDepth
     * @return
     */
    virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell,
                         int nDepth) override;

    /**
     * Prepares the SmRect to render.
     * @param rDev
     * @param rFormat
     * @return
     */
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;

    /**
     * Accept a visitor.
     * Calls the method for this class on the visitor.
     * @param pVisitor
     * @return
     */
    void Accept(SmVisitor* pVisitor) override;
};


/** Error node, for parsing errors
 *
 * This node is used for parsing errors and draws a questionmark turned upside
 * down (inverted question mark).
 */
class SmErrorNode final : public SmMathSymbolNode
{
public:
    explicit SmErrorNode(const SmToken &rNodeToken)
                : SmMathSymbolNode(SmNodeType::Error, rNodeToken) { SetText(OUString(MS_ERROR)); }

    /**
     * Prepare preliminary settings about font and text
     * (e.g. maFace, meRectHorAlign, mnFlags, mnAttributes, etc.)
     * @param rFormat
     * @param rDocShell
     * @param nDepth
     * @return
     */
    virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell,
                         int nDepth) override;

    /**
     * Prepares the SmRect to render.
     * @param rDev
     * @param rFormat
     * @return
     */
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;

    /**
     * Accept a visitor.
     * Calls the method for this class on the visitor.
     * @param pVisitor
     * @return
     */
    void Accept(SmVisitor* pVisitor) override;
};


/** Table node
 *
 * This is the root node for the formula tree. This node is also used for the
 * STACK and BINOM commands. When used for root node, its
 * children are instances of SmLineNode, and in some obscure cases the child
 * can be an instance of SmExpressionNode, mainly when errors occur.
 */
class SmTableNode final : public SmStructureNode
{
    tools::Long mnFormulaBaseline;
public:
    explicit SmTableNode(const SmToken &rNodeToken)
        : SmStructureNode(SmNodeType::Table, rNodeToken)
        , mnFormulaBaseline(0) { }

    virtual const SmNode * GetLeftMost() const override;

    /**
     * Prepares the SmRect to render.
     * @param rDev
     * @param rFormat
     * @return
     */
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;

    /**
     * Gets the formula baseline.
     * @return formula baseline
     */
    tools::Long GetFormulaBaseline() const;

    /**
     * Accept a visitor.
     * Calls the method for this class on the visitor.
     * @param pVisitor
     * @return
     */
    void Accept(SmVisitor* pVisitor) override;
};


/** A line
 *
 * Used as child of SmTableNode when the SmTableNode is the root node of the
 * formula tree.
 */
class SmLineNode : public SmStructureNode
{
    bool mbUseExtraSpaces;

protected:
    SmLineNode(SmNodeType eNodeType, const SmToken &rNodeToken)
        : SmStructureNode(eNodeType, rNodeToken)
        , mbUseExtraSpaces(true) { }

public:
    explicit SmLineNode(const SmToken &rNodeToken)
        : SmStructureNode(SmNodeType::Line, rNodeToken)
        , mbUseExtraSpaces(true) { }

    /**
     * Sets if it going to use extra spaces.
     * It is used to set if there has to be space between node while rendering.
     * By default it is true.
     * @param bVal
     * @return
     */
    void  SetUseExtraSpaces(bool bVal) { mbUseExtraSpaces = bVal; }

    /**
     * Checks if it is using extra spaces.
     * It is used for calculating space between nodes when rendering.
     * By default it is true.
     * @return is using extra spaces
     */
    bool  IsUseExtraSpaces() const { return mbUseExtraSpaces; };

    /**
     * Prepare preliminary settings about font and text
     * (e.g. maFace, meRectHorAlign, mnFlags, mnAttributes, etc.)
     * @param rFormat
     * @param rDocShell
     * @param nDepth
     * @return
     */
    virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell,
                         int nDepth) override;

    /**
     * Prepares the SmRect to render.
     * @param rDev
     * @param rFormat
     * @return
     */
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;

    /**
     * Accept a visitor.
     * Calls the method for this class on the visitor.
     * @param pVisitor
     * @return
     */
    void Accept(SmVisitor* pVisitor) override;
};


/** Expression node
 *
 * Used whenever you have an expression such as "A OVER {B + C}", here there is
 * an expression node that allows "B + C" to be the denominator of the
 * SmBinVerNode, that the OVER command creates.
 */
class SmExpressionNode final : public SmLineNode
{
public:
    explicit SmExpressionNode(const SmToken &rNodeToken)
        : SmLineNode(SmNodeType::Expression, rNodeToken) { }

    /**
     * Prepares the SmRect to render.
     * @param rDev
     * @param rFormat
     * @return
     */
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;

    /**
     * Accept a visitor.
     * Calls the method for this class on the visitor.
     * @param pVisitor
     * @return
     */
    void Accept(SmVisitor* pVisitor) override;
};


/** Unary horizontal node
 *
 * The same as SmBinHorNode except this is for unary operators.
 */
class SmUnHorNode final : public SmStructureNode
{
public:
    explicit SmUnHorNode(const SmToken &rNodeToken)
        : SmStructureNode(SmNodeType::UnHor, rNodeToken, 2) { }

    /**
     * Prepares the SmRect to render.
     * @param rDev
     * @param rFormat
     * @return
     */
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;

    /**
     * Accept a visitor.
     * Calls the method for this class on the visitor.
     * @param pVisitor
     * @return
     */
    void Accept(SmVisitor* pVisitor) override;
};


/** Root node
 *
 * Used for create square roots and other roots, example:
 * \f$ \sqrt[\mbox{[Argument]}]{\mbox{[Body]}} \f$.
 *
 * Children:<BR>
 * 0: Argument (optional)<BR>
 * 1: Symbol (instance of SmRootSymbolNode)<BR>
 * 2: Body<BR>
 * Where argument is optional and may be NULL.
 */
class SmRootNode final : public SmStructureNode
{
public:
    explicit SmRootNode(const SmToken &rNodeToken)
        : SmStructureNode(SmNodeType::Root, rNodeToken, 3) { }

    /**
     * Prepares the SmRect to render.
     * @param rDev
     * @param rFormat
     * @return
     */
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;

    /**
     * Accept a visitor.
     * Calls the method for this class on the visitor.
     * @param pVisitor
     * @return
     */
    void Accept(SmVisitor* pVisitor) override;

    /**
     * Returns the node containing the data of the order of the root.
     * @return order data
     */
    const SmNode* Argument() const { return const_cast<SmRootNode *>(this)->Argument(); }
          SmNode* Argument()       { assert( GetNumSubNodes() == 3 ); return GetSubNode( 0 ); }

    /**
     * Returns the node containing the data of the character used for the root.
     * @return symbol data
     */
    const SmRootSymbolNode* Symbol() const { return const_cast<SmRootNode *>(this)->Symbol(); }
          SmRootSymbolNode* Symbol()       { assert( GetNumSubNodes() == 3 );
                                             assert( GetSubNode( 1 )->GetType()
                                                        == SmNodeType::RootSymbol );
                                             return static_cast< SmRootSymbolNode* >
                                                ( GetSubNode( 1 )); }

    /**
     * Returns the node containing the data inside the root.
     * @return body data
     */
    const SmNode* Body() const { return const_cast<SmRootNode *>(this)->Body(); }
          SmNode* Body()       { assert( GetNumSubNodes() == 3 ); return GetSubNode( 2 ); }

};


/** Binary horizontal node
 *
 * This node is used for binary operators. In a formula such as "A + B".
 *
 * Children:<BR>
 * 0: Left operand<BR>
 * 1: Binary operator<BR>
 * 2: Right operand<BR>
 *
 * None of the children may be NULL.
 */
class SmBinHorNode final : public SmStructureNode
{
public:
    explicit SmBinHorNode(const SmToken &rNodeToken)
        : SmStructureNode(SmNodeType::BinHor, rNodeToken, 3) { }

    /**
     * Prepares the SmRect to render.
     * @param rDev
     * @param rFormat
     * @return
     */
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;

    /**
     * Accept a visitor.
     * Calls the method for this class on the visitor.
     * @param pVisitor
     * @return
     */
    void Accept(SmVisitor* pVisitor) override;

    /**
     * Returns the node containing the data of the binary operator.
     * @return symbol data
     */
    const SmNode* Symbol() const { return const_cast<SmBinHorNode *>(this)->Symbol(); }
          SmNode* Symbol()       { assert( GetNumSubNodes() == 3 ); return GetSubNode( 1 ); }

    /**
     * Returns the node containing the data of the left operand.
     * @return left operand data
     */
    const SmNode* LeftOperand() const { return const_cast<SmBinHorNode *>(this)->LeftOperand(); }
          SmNode* LeftOperand()       { assert( GetNumSubNodes() == 3 ); return GetSubNode( 0 ); }

    /**
     * Returns the node containing the data of the right operand.
     * @return right operand data
     */
    const SmNode* RightOperand() const { return const_cast<SmBinHorNode *>(this)->RightOperand(); }
          SmNode* RightOperand()       { assert( GetNumSubNodes() == 3 ); return GetSubNode( 2 ); }
};


/** Binary horizontal node
 *
 * This node is used for creating the OVER command, consider the formula:
 * "numerator OVER denominator", which looks like
 * \f$ \frac{\mbox{numerator}}{\mbox{denominator}} \f$
 *
 * Children:<BR>
 * 0: Numerator<BR>
 * 1: Line (instance of SmRectangleNode)<BR>
 * 2: Denominator<BR>
 * None of the children may be NULL.
 */
class SmBinVerNode final : public SmStructureNode
{
public:
    explicit SmBinVerNode(const SmToken &rNodeToken)
        : SmStructureNode(SmNodeType::BinVer, rNodeToken, 3) { }

    virtual const SmNode * GetLeftMost() const override;

    /**
     * Prepares the SmRect to render.
     * @param rDev
     * @param rFormat
     * @return
     */
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;

    /**
     * Accept a visitor.
     * Calls the method for this class on the visitor.
     * @param pVisitor
     * @return
     */
    void Accept(SmVisitor* pVisitor) override;
};


/** Binary diagonal node
 *
 * Used for implementing the WIDESLASH command, example: "A WIDESLASH B".
 *
 * Children:<BR>
 * 0: Left operand<BR>
 * 1: right operand<BR>
 * 2: Line (instance of SmPolyLineNode).<BR>
 * None of the children may be NULL.
 */
class SmBinDiagonalNode final : public SmStructureNode
{
    bool mbAscending;

    /**
     * Returns the position and size of the diagonal line by reference.
     * @param rPos
     * @param rSize
     * @param rDiagPoint
     * @param fAngleDeg
     * @return position and size of the diagonal line
     */
    void GetOperPosSize(Point &rPos, Size &rSize, const Point &rDiagPoint, double fAngleDeg) const;

public:
    explicit SmBinDiagonalNode(const SmToken &rNodeToken)
        : SmStructureNode(SmNodeType::BinDiagonal, rNodeToken, 3)
        , mbAscending(false) { }

    /**
     * Checks if it is of ascending type.
     * Ascending:
     *     / b
     *    /
     * a /
     * Descending:
     * a \
     *    \
     *     \ b
     * @return ascending.
     */
    bool    IsAscending() const { return mbAscending; }

    /**
     * Sets if the wideslash is ascending to bVal.
     * @param bVal
     * @return
     */
    void    SetAscending(bool bVal)  { mbAscending = bVal; }

    /**
     * Prepares the SmRect to render.
     * @param rDev
     * @param rFormat
     * @return
     */
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;

    /**
     * Accept a visitor.
     * Calls the method for this class on the visitor.
     * @param pVisitor
     * @return
     */
    void Accept(SmVisitor* pVisitor) override;
};


/** Enum used to index sub-/supscripts in the 'maSubNodes' array
 * in 'SmSubSupNode'
 *
 * See graphic for positions at char:
 *
 * \code
 *      CSUP
 *
 * LSUP H  H RSUP
 *      H  H
 *      HHHH
 *      H  H
 * LSUB H  H RSUB
 *
 *      CSUB
 * \endcode
 */
enum SmSubSup
{   CSUB, CSUP, RSUB, RSUP, LSUB, LSUP
};

/** numbers of entries in the above enum (that is: the number of possible
 * sub-/supscripts)
 */
#define SUBSUP_NUM_ENTRIES 6

/** Super- and subscript node
 *
 * Used for creating super- and subscripts for commands such as:
 * "^", "_", "lsup", "lsub", "csup" and "csub".
 * Example: "A^2" which looks like: \f$ A^2 \f$
 *
 * This node is also used for creating limits on SmOperNode, when
 * "FROM" and "TO" commands are used with "INT", "SUM" or similar.
 *
 * Children of this node can be enumerated using the SmSubSup enum.
 * Please note that children may be NULL, except for the body.
 * It is recommended that you access children using GetBody() and
 * GetSubSup().
 */
class SmSubSupNode final : public SmStructureNode
{
    bool mbUseLimits;

public:
    explicit SmSubSupNode(const SmToken &rNodeToken)
        : SmStructureNode(SmNodeType::SubSup, rNodeToken, 1 + SUBSUP_NUM_ENTRIES)
        , mbUseLimits(false) { }

    /**
     * Returns the node with the data of what has to be superindex or subindex.
     * @return body data
     */
    const SmNode * GetBody() const { return const_cast<SmSubSupNode *>(this)->GetBody(); }
          SmNode * GetBody()       { return GetSubNode(0); }

    /**
     * Checks if it is going to be used for a limit.
     * Example lim from { x toward 0 } { {sin x}over x } = 1
     * @return is a limit
     */
    bool  IsUseLimits() const { return mbUseLimits; };

    /**
     * Sets if it is going to be used for a limit to bVal.
     * @param bVal
     * @return
     */
    void  SetUseLimits(bool bVal) { mbUseLimits = bVal; }

    /**
     * Gets the node with the data of what has to be superindex or subindex.
     * The position to check is given by eSubSup.
     * @remarks this method may return NULL.
     * @param eSubSup
     * @return body data
     */
     const SmNode * GetSubSup(SmSubSup eSubSup) const { return const_cast< SmSubSupNode* >
                                                            ( this )->GetSubSup( eSubSup ); }
           SmNode * GetSubSup(SmSubSup eSubSup)       { return GetSubNode(1 + eSubSup); };

    /**
     * Sets the node with the data of what has to be superindex or subindex.
     * @param pScript
     */
    void SetBody(SmNode* pBody) { SetSubNode(0, pBody); }

     /**
     * Sets the node with the data of what has to be superindex or subindex.
     * The position to check is given by eSubSup.
     * @param eSubSup
     * @param pScript
     */
    void SetSubSup(SmSubSup eSubSup, SmNode* pScript) { SetSubNode( 1 + eSubSup, pScript); }

    /**
     * Prepares the SmRect to render.
     * @param rDev
     * @param rFormat
     * @return
     */
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;

    /**
     * Accept a visitor.
     * Calls the method for this class on the visitor.
     * @param pVisitor
     * @return
     */
    void Accept(SmVisitor* pVisitor) override;

};


/** Node for brace construction
 *
 * Used for "lbrace [body] rbrace" and similar constructions.
 * Should look like \f$ \{\mbox{[body]}\} \f$
 *
 * Children:<BR>
 * 0: Opening brace<BR>
 * 1: Body (usually SmBracebodyNode)<BR>
 * 2: Closing brace<BR>
 * None of the children can be NULL.
 *
 * Note that child 1 (Body) is usually SmBracebodyNode, but it can also be e.g. SmExpressionNode.
 */
class SmBraceNode final : public SmStructureNode
{
public:
    explicit SmBraceNode(const SmToken &rNodeToken)
        : SmStructureNode(SmNodeType::Brace, rNodeToken, 3) { }

    /**
     * Returns the node containing the data of the opening brace.
     * @return opening brace data
     */
    const SmMathSymbolNode* OpeningBrace() const { return const_cast<SmBraceNode *>
                                                       (this)->OpeningBrace(); }
    SmMathSymbolNode* OpeningBrace()             { assert( GetNumSubNodes() == 3 );
                                                   assert( GetSubNode( 0 )->GetType()
                                                               == SmNodeType::Math );
                                                   return static_cast< SmMathSymbolNode* >
                                                       ( GetSubNode( 0 )); }

    /**
     * Returns the node containing the data of what is between braces.
     * @return body data
     */
    const SmNode* Body() const { return const_cast<SmBraceNode *>(this)->Body(); }
    SmNode* Body()             { assert( GetNumSubNodes() == 3 ); return GetSubNode( 1 ); }

    /**
     * Returns the node containing the data of the closing brace.
     * @return closing brace data
     */
    const SmMathSymbolNode* ClosingBrace() const { return const_cast<SmBraceNode *>
                                                       (this)->ClosingBrace(); }
    SmMathSymbolNode* ClosingBrace()             { assert( GetNumSubNodes() == 3 );
                                                   assert( GetSubNode( 2 )->GetType()
                                                               == SmNodeType::Math );
                                                   return static_cast< SmMathSymbolNode* >
                                                       ( GetSubNode( 2 )); }

    /**
     * Prepares the SmRect to render.
     * @param rDev
     * @param rFormat
     * @return
     */
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;

    /**
     * Accept a visitor.
     * Calls the method for this class on the visitor.
     * @param pVisitor
     * @return
     */
    void Accept(SmVisitor* pVisitor) override;
};


/** Body of an SmBraceNode
 *
 * This usually only has one child an SmExpressionNode, however, it can also
 * have other children.
 * Consider the formula "lbrace [body1] mline [body2] rbrace", looks like:
 * \f$ \{\mbox{[body1] | [body2]}\} \f$.
 * In this case SmBracebodyNode will have three children, "[body1]", "|" and
 * [body2].
 */
class SmBracebodyNode final : public SmStructureNode
{
    tools::Long mnBodyHeight;

public:
    explicit SmBracebodyNode(const SmToken &rNodeToken)
        : SmStructureNode(SmNodeType::Bracebody, rNodeToken)
        , mnBodyHeight(0) { }

    /**
     * Prepares the SmRect to render.
     * @param rDev
     * @param rFormat
     * @return
     */
    virtual void    Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
    tools::Long GetBodyHeight() const { return mnBodyHeight; }

    /**
     * Accept a visitor.
     * Calls the method for this class on the visitor.
     * @param pVisitor
     * @return
     */
    void Accept(SmVisitor* pVisitor) override;
};


/** Node for vertical brace construction
 *
 * Used to implement commands "[body] underbrace [script]" and
 * "[body] overbrace [script]".
 * Underbrace should look like this \f$ \underbrace{\mbox{body}}_{\mbox{script}}\f$.
 *
 * Children:<BR>
 * 0: body<BR>
 * 1: brace<BR>
 * 2: script<BR>
 * (None of these children are optional, e.g. they must all be not NULL).
 */
class SmVerticalBraceNode final : public SmStructureNode
{
public:
    explicit SmVerticalBraceNode(const SmToken &rNodeToken)
    : SmStructureNode(SmNodeType::VerticalBrace, rNodeToken, 3) { }

    /**
     * Returns the node containing the data of what the brace is pointing for.
     * body { script }
     * @return body data
     */
    const SmNode* Body() const { return const_cast<SmVerticalBraceNode *>(this)->Body(); }
    SmNode* Body()             { assert( GetNumSubNodes() == 3 ); return GetSubNode( 0 ); }

    /**
     * Returns the node containing the data of the brace.
     * @return brace data
     */
    const SmMathSymbolNode* Brace() const { return const_cast<SmVerticalBraceNode *>
                                                (this)->Brace(); }
          SmMathSymbolNode* Brace()       { assert( GetNumSubNodes() == 3 );
                                            assert( GetSubNode( 1 )->GetType()
                                                        == SmNodeType::Math );
                                            return static_cast< SmMathSymbolNode* >
                                                ( GetSubNode( 1 )); }

    /**
     * Returns the node containing the data of what is in the brace.
     * body { script }
     * @return opening brace data
     */
    const SmNode* Script() const { return const_cast<SmVerticalBraceNode *>(this)->Script(); }
          SmNode* Script()       { assert( GetNumSubNodes() == 3 ); return GetSubNode( 2 ); }

    /**
     * Prepares the SmRect to render.
     * @param rDev
     * @param rFormat
     * @return
     */
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;

    /**
     * Accept a visitor.
     * Calls the method for this class on the visitor.
     * @param pVisitor
     * @return
     */
    void Accept(SmVisitor* pVisitor) override;
};

/** Operation Node
 *
 * Used for commands like SUM, INT and similar.
 *
 * Children:<BR>
 * 0: Operation (instance of SmMathSymbolNode or SmSubSupNode)<BR>
 * 1: Body<BR>
 * None of the children may be NULL.
 *
 */
class SmOperNode final : public SmStructureNode
{
public:
    explicit SmOperNode(const SmToken &rNodeToken)
        : SmStructureNode(SmNodeType::Oper, rNodeToken, 2) { }

    /**
     * Returns the node with the operator data
     * @return operator data
     */
    const SmNode * GetSymbol() const { return const_cast<SmOperNode *>(this)->GetSymbol(); }
          SmNode * GetSymbol();

    /**
     * Returns the height of the node in base to the symbol
     * ( rSymbol contains the operator data )
     * and the font format ( rFormat ).
     * @param rSymbol
     * @param rFormat
     * @return node's height
     */
    tools::Long CalcSymbolHeight(const SmNode &rSymbol, const SmFormat &rFormat) const;

    /**
     * Prepares the SmRect to render.
     * @param rDev
     * @param rFormat
     * @return
     */
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;

    /**
     * Accept a visitor.
     * Calls the method for this class on the visitor.
     * @param pVisitor
     * @return
     */
    void Accept(SmVisitor* pVisitor) override;
};


/** Node used for alignment
 *
 * This node has exactly one child at index 0.
 */
class SmAlignNode final : public SmStructureNode
{
public:
    explicit SmAlignNode(const SmToken &rNodeToken)
        : SmStructureNode(SmNodeType::Align, rNodeToken) { }

    /**
     * Prepares the SmRect to render.
     * @param rDev
     * @param rFormat
     * @return
     */
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;

    /**
     * Accept a visitor.
     * Calls the method for this class on the visitor.
     * @param pVisitor
     * @return
     */
    void Accept(SmVisitor* pVisitor) override;
};


/** Attribute node
 *
 * Used to give an attribute to another node. Used for commands such as:
 * UNDERLINE, OVERLINE, OVERSTRIKE, WIDEVEC, WIDEHARPOON, WIDEHAT and WIDETILDE.
 *
 * Children:<BR>
 * 0: Attribute<BR>
 * 1: Body<BR>
 * None of these may be NULL.
 */
class SmAttributeNode final : public SmStructureNode
{
public:
    explicit SmAttributeNode(const SmToken &rNodeToken)
        : SmStructureNode(SmNodeType::Attribute, rNodeToken, 2) {}

    /**
     * Prepares the SmRect to render.
     * @param rDev
     * @param rFormat
     * @return
     */
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;

    /**
     * Accept a visitor.
     * Calls the method for this class on the visitor.
     * @param pVisitor
     * @return
     */
    void Accept(SmVisitor* pVisitor) override;

    /**
     * Gets the attribute data.
     * @return attribute data
     */
    const SmNode* Attribute() const { return const_cast<SmAttributeNode *>(this)->Attribute(); }
          SmNode* Attribute()       { assert( GetNumSubNodes() == 2 ); return GetSubNode( 0 ); }

    /**
     * Gets the body data ( the nodes affected by the attribute ).
     * @return body data
     */
    const SmNode* Body() const { return const_cast<SmAttributeNode *>(this)->Body(); }
          SmNode* Body()      { assert( GetNumSubNodes() == 2 ); return GetSubNode( 1 ); }
};


/** Font node
 *
 * Used to change the font of its children.
 */
class SmFontNode final : public SmStructureNode
{
    FontSizeType meSizeType;
    Fraction     maFontSize;

public:
    explicit SmFontNode(const SmToken &rNodeToken)
        : SmStructureNode(SmNodeType::Font, rNodeToken)
        , meSizeType(FontSizeType::MULTIPLY)
        , maFontSize(1) { }

    /**
     * Sets font size to rValue in nType mode.
     * Check FontSizeType for details.
     * @param rValue
     * @param nType
     * @return
     */
    void SetSizeParameter(const Fraction &rValue, FontSizeType nType)
                            { meSizeType = nType; maFontSize = rValue; }

    /**
     * Returns the font size.
     * @return font size.
     */
    const Fraction & GetSizeParameter() const {return maFontSize;}

    /**
     * Returns the font size type.
     * Check FontSizeType for details.
     * @return font size type.
     */
    FontSizeType GetSizeType() const {return meSizeType;}

    /**
     * Prepare preliminary settings about font and text
     * (e.g. maFace, meRectHorAlign, mnFlags, mnAttributes, etc.)
     * @param rFormat
     * @param rDocShell
     * @param nDepth
     * @return
     */
    virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell,
                         int nDepth) override;

    /**
     * Prepares the SmRect to render.
     * @param rDev
     * @param rFormat
     * @return
     */
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;

    /**
     * Accept a visitor.
     * Calls the method for this class on the visitor.
     * @param pVisitor
     * @return
     */
    void Accept(SmVisitor* pVisitor) override;
};


/** Matrix node
 *
 * Used to implement the MATRIX command, example:
 * "matrix{ 1 # 2 ## 3 # 4}".
 */
class SmMatrixNode final : public SmStructureNode
{
    sal_uInt16 mnNumRows,
               mnNumCols;

public:
    explicit SmMatrixNode(const SmToken &rNodeToken)
        : SmStructureNode(SmNodeType::Matrix, rNodeToken)
        , mnNumRows(0)
        , mnNumCols(0) { }

    /**
     * Gets the number of rows of the matrix.
     * @return rows number
     */
    sal_uInt16 GetNumRows() const {return mnNumRows;}

    /**
     * Gets the number of columns of the matrix.
     * @return columns number
     */
    sal_uInt16 GetNumCols() const {return mnNumCols;}

    /**
     * Sets the dimensions of the matrix.
     * @param nMatrixRows
     * @param nMatrixCols
     * @return
     */
    void SetRowCol(sal_uInt16 nMatrixRows, sal_uInt16 nMatrixCols)
                     { mnNumRows = nMatrixRows; mnNumCols = nMatrixCols; }

    virtual const SmNode * GetLeftMost() const override;

    /**
     * Prepares the SmRect to render.
     * @param rDev
     * @param rFormat
     * @return
     */
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;

    /**
     * Accept a visitor.
     * Calls the method for this class on the visitor.
     * @param pVisitor
     * @return
     */
    void Accept(SmVisitor* pVisitor) override;
};


/** Node for whitespace
 *
 * Used to implement the commands "~" and "`". This node is just a blank space.
 */
class SmBlankNode final : public SmGraphicNode
{
    sal_uInt16 mnNum;

public:
    explicit SmBlankNode(const SmToken &rNodeToken)
        : SmGraphicNode(SmNodeType::Blank, rNodeToken)
        , mnNum(0) { }

    void         IncreaseBy(const SmToken &rToken, sal_uInt32 nMultiplyBy = 1);
    void         Clear() { mnNum = 0; }
    sal_uInt16   GetBlankNum() const { return mnNum; }
    void         SetBlankNum(sal_uInt16 nNumber) { mnNum = nNumber; }

    /**
     * Prepare preliminary settings about font and text
     * (e.g. maFace, meRectHorAlign, mnFlags, mnAttributes, etc.)
     * @param rFormat
     * @param rDocShell
     * @param nDepth
     * @return
     */
    virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell,
                         int nDepth) override;

    /**
     * Prepares the SmRect to render.
     * @param rDev
     * @param rFormat
     * @return
     */
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;

    /**
     * Accept a visitor.
     * Calls the method for this class on the visitor.
     * @param pVisitor
     * @return
     */
    void Accept(SmVisitor* pVisitor) override;

};

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */