node.hxx

Go to the documentation of this file.

/* -*- 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 .
 */
 
#pragma once
 
#include "types.hxx"
#include "token.hxx"
#include "rect.hxx"
#include "format.hxx"
#include "nodetype.hxx"
 
#include <editeng/editdata.hxx>
#include <rtl/ustrbuf.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, SmToken aNodeToken);
 
public:
    SmNode(const SmNode&) = delete;
    SmNode& operator=(const SmNode&) = delete;
 
    virtual ~SmNode();
 
    virtual bool IsVisible() const = 0;
 
    virtual size_t GetNumSubNodes() const = 0;
 
    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;
 
    FontChangeMask &Flags() { return mnFlags; }
 
    FontAttribute &Attributes() { return mnAttributes; }
 
    bool IsPhantom() const { return mbIsPhantom; }
 
    void SetPhantom(bool bIsPhantom);
 
    void SetColor(const Color &rColor);
 
    void SetAttribute(FontAttribute nAttrib);
 
    void ClearAttribute(FontAttribute nAttrib);
 
    const SmFace & GetFont() const { return maFace; };
          SmFace & GetFont()       { return maFace; };
 
    void SetFont(const SmFace &rFace);
 
    void SetFontSize(const Fraction &rRelSize, FontSizeType nType);
 
    void SetSize(const Fraction &rScale);
 
    virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell, int nDepth);
 
    void PrepareAttributes();
 
    void SetRectHorAlign(RectHorAlign eHorAlign, bool bApplyToSubTree = true );
 
    RectHorAlign GetRectHorAlign() const { return meRectHorAlign; }
 
    const SmRect & GetRect() const { return *this; }
 
    void Move(const Point &rVector);
 
    void MoveTo(const Point &rPoint) { Move(rPoint - GetTopLeft()); }
 
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) = 0;
 
    virtual void GetAccessibleText( OUStringBuffer &rText ) const = 0;
 
    sal_Int32 GetAccessibleIndex() const { return mnAccIndex; }
 
    void SetAccessibleIndex(sal_Int32 nAccIndex) { mnAccIndex = nAccIndex; }
 
    const SmNode * FindNodeWithAccessibleIndex(sal_Int32 nAccIndex) const;
 
    sal_uInt16 GetRow() const { return sal::static_int_cast<sal_uInt16>(m_aESelection.nStartPara); }
 
    sal_uInt16 GetColumn() const { return sal::static_int_cast<sal_uInt16>(m_aESelection.nStartPos); }
 
    SmScaleMode GetScaleMode() const { return meScaleMode; }
 
    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);
 
    SmNodeType GetType() const  { return meType; }
 
    const SmToken & GetToken() const { return maNodeToken; }
          SmToken & GetToken()       { return maNodeToken; }
 
    const ESelection& GetSelection() const { return m_aESelection; }
 
    void SetSelection(ESelection aESelection) { m_aESelection = aESelection; }
 
    const SmNode *  FindTokenAt(sal_uInt16 nRow, sal_uInt16 nCol) const;
 
    const SmNode *  FindRectClosestTo(const Point &rPoint) const;
 
    virtual void Accept(SmVisitor* pVisitor) = 0;
 
    bool IsSelected() const {return mbIsSelected;}
 
    void SetSelected(bool Selected) {mbIsSelected = Selected;}
 
    const SmStructureNode* GetParent() const { return mpParentNode; }
          SmStructureNode* GetParent()       { return mpParentNode; }
 
    void SetParent(SmStructureNode* parent){ mpParentNode = parent; }
 
    void SetToken(SmToken const & token){ maNodeToken = token; }
 
private:
    SmStructureNode* mpParentNode;
};
 
 
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;
 
    virtual bool IsVisible() const override;
 
    virtual size_t GetNumSubNodes() const override;
 
    using   SmNode::GetSubNode;
    virtual SmNode * GetSubNode(size_t nIndex) override;
 
    SmNode * GetSubNodeBinMo(size_t nIndex) const;
 
    void ClearSubNodes();
 
    void SetSubNodes(std::unique_ptr<SmNode> pFirst, std::unique_ptr<SmNode> pSecond,
                     std::unique_ptr<SmNode> pThird = nullptr);
 
    void SetSubNodes(SmNode* pFirst, SmNode* pSecond, SmNode* pThird);
 
    void SetSubNodesBinMo(std::unique_ptr<SmNode> pFirst, std::unique_ptr<SmNode> pSecond,
                          std::unique_ptr<SmNode> pThird = nullptr);
 
    void SetSubNodes(SmNodeArray&& rNodeArray);
 
    virtual void  GetAccessibleText( OUStringBuffer &rText ) const override;
 
    SmNodeArray::iterator begin() {return maSubNodes.begin();}
 
    SmNodeArray::iterator end() {return maSubNodes.end();}
 
    SmNodeArray::reverse_iterator rbegin() {return maSubNodes.rbegin();}
 
    SmNodeArray::reverse_iterator rend() {return maSubNodes.rend();}
 
    int IndexOfSubNode(SmNode const * pSubNode);
 
    void SetSubNode(size_t nIndex, SmNode* pNode);
 
private:
    void ClaimPaternity();
};
 
 
class SmVisibleNode : public SmNode
{
protected:
    SmVisibleNode(SmNodeType eNodeType, const SmToken &rNodeToken)
    :   SmNode(eNodeType, rNodeToken) {}
 
public:
 
    virtual bool        IsVisible() const override;
 
    virtual size_t      GetNumSubNodes() const override;
 
    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:
 
    virtual void  GetAccessibleText( OUStringBuffer &rText ) const override;
};
 
 
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;
 
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
 
    void Accept(SmVisitor* pVisitor) override;
};
 
 
class SmPolyLineNode final : public SmGraphicNode
{
    tools::Polygon maPoly;
    Size maToSize;
    tools::Long mnWidth;
 
public:
    explicit SmPolyLineNode(const SmToken &rNodeToken);
 
    tools::Long GetWidth() const { return mnWidth; }
 
    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;
 
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
 
    void Accept(SmVisitor* pVisitor) override;
};
 
 
class SmTextNode : public SmVisibleNode
{
    OUString   maText;
    sal_uInt16 mnFontDesc;
    sal_Int32  mnSelectionStart;
    sal_Int32  mnSelectionEnd;
 
protected:
    SmTextNode(SmNodeType eNodeType, const SmToken &rNodeToken, sal_uInt16 nFontDescP );
 
public:
    SmTextNode(const SmToken &rNodeToken, sal_uInt16 nFontDescP );
 
    sal_uInt16 GetFontDesc() const { return mnFontDesc; }
 
    void SetText(const OUString &rText) { maText = rText; }
 
    const OUString & GetText() const { return maText; }
          OUString & GetText()       { return maText; }
 
    void ChangeText(const OUString &rText);
 
    void AdjustFontDesc();
 
    sal_Int32 GetSelectionStart() const { return mnSelectionStart; }
 
    sal_Int32 GetSelectionEnd() const  {return mnSelectionEnd; }
 
    void SetSelectionStart(sal_Int32 index) {mnSelectionStart = index;}
 
    void SetSelectionEnd(sal_Int32 index) {mnSelectionEnd = index;}
 
    virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell,
                         int nDepth) override;
 
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
 
    virtual void  GetAccessibleText( OUStringBuffer &rText ) const override;
 
    void Accept(SmVisitor* pVisitor) override;
 
    static sal_Unicode ConvertSymbolToUnicode(sal_Unicode nIn);
};
 
 
class SmSpecialNode : public SmTextNode
{
    bool mbIsFromGreekSymbolSet;
 
protected:
    SmSpecialNode(SmNodeType eNodeType, const SmToken &rNodeToken, sal_uInt16 _nFontDesc);
 
public:
    explicit SmSpecialNode(const SmToken &rNodeToken);
 
    virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell,
                         int nDepth) override;
 
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
 
    void Accept(SmVisitor* pVisitor) override;
};
 
 
class SmGlyphSpecialNode final : public SmSpecialNode
{
public:
    explicit SmGlyphSpecialNode(const SmToken &rNodeToken)
        : SmSpecialNode(SmNodeType::GlyphSpecial, rNodeToken, FNT_MATH)
    {}
 
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
 
    void Accept(SmVisitor* pVisitor) override;
};
 
 
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;
 
    virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell,
                         int nDepth) override;
 
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
 
    void Accept(SmVisitor* pVisitor) override;
};
 
 
class SmMathIdentifierNode final : public SmMathSymbolNode
{
public:
    explicit SmMathIdentifierNode(const SmToken &rNodeToken)
        : SmMathSymbolNode(SmNodeType::MathIdent, rNodeToken) {}
};
 
 
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) { }
 
    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;
 
    void Accept(SmVisitor* pVisitor) override;
};
 
 
class SmPlaceNode final : public SmMathSymbolNode
{
public:
    explicit SmPlaceNode(const SmToken &rNodeToken)
        : SmMathSymbolNode(SmNodeType::Place, rNodeToken) { }
    SmPlaceNode() : SmMathSymbolNode(SmNodeType::Place, SmToken(TPLACE, MS_PLACE, "<?>")) { };
 
    virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell,
                         int nDepth) override;
 
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
 
    void Accept(SmVisitor* pVisitor) override;
};
 
 
class SmErrorNode final : public SmMathSymbolNode
{
public:
    explicit SmErrorNode(const SmToken &rNodeToken)
                : SmMathSymbolNode(SmNodeType::Error, rNodeToken) { SetText(OUString(MS_ERROR)); }
 
    virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell,
                         int nDepth) override;
 
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
 
    void Accept(SmVisitor* pVisitor) override;
};
 
 
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;
 
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
 
    tools::Long GetFormulaBaseline() const;
 
    void Accept(SmVisitor* pVisitor) override;
};
 
 
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) { }
 
    void  SetUseExtraSpaces(bool bVal) { mbUseExtraSpaces = bVal; }
 
    bool  IsUseExtraSpaces() const { return mbUseExtraSpaces; };
 
    virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell,
                         int nDepth) override;
 
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
 
    void Accept(SmVisitor* pVisitor) override;
};
 
 
class SmExpressionNode final : public SmLineNode
{
public:
    explicit SmExpressionNode(const SmToken &rNodeToken)
        : SmLineNode(SmNodeType::Expression, rNodeToken) { }
 
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
 
    void Accept(SmVisitor* pVisitor) override;
};
 
 
class SmUnHorNode final : public SmStructureNode
{
public:
    explicit SmUnHorNode(const SmToken &rNodeToken)
        : SmStructureNode(SmNodeType::UnHor, rNodeToken, 2) { }
 
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
 
    void Accept(SmVisitor* pVisitor) override;
};
 
 
class SmRootNode final : public SmStructureNode
{
public:
    explicit SmRootNode(const SmToken &rNodeToken)
        : SmStructureNode(SmNodeType::Root, rNodeToken, 3) { }
 
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
 
    void Accept(SmVisitor* pVisitor) override;
 
    const SmNode* Argument() const { return const_cast<SmRootNode *>(this)->Argument(); }
          SmNode* Argument()       { assert( GetNumSubNodes() == 3 ); return GetSubNode( 0 ); }
 
    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 )); }
 
    const SmNode* Body() const { return const_cast<SmRootNode *>(this)->Body(); }
          SmNode* Body()       { assert( GetNumSubNodes() == 3 ); return GetSubNode( 2 ); }
 
};
 
 
class SmBinHorNode final : public SmStructureNode
{
public:
    explicit SmBinHorNode(const SmToken &rNodeToken)
        : SmStructureNode(SmNodeType::BinHor, rNodeToken, 3) { }
 
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
 
    void Accept(SmVisitor* pVisitor) override;
 
    const SmNode* Symbol() const { return const_cast<SmBinHorNode *>(this)->Symbol(); }
          SmNode* Symbol()       { assert( GetNumSubNodes() == 3 ); return GetSubNode( 1 ); }
 
    const SmNode* LeftOperand() const { return const_cast<SmBinHorNode *>(this)->LeftOperand(); }
          SmNode* LeftOperand()       { assert( GetNumSubNodes() == 3 ); return GetSubNode( 0 ); }
 
    const SmNode* RightOperand() const { return const_cast<SmBinHorNode *>(this)->RightOperand(); }
          SmNode* RightOperand()       { assert( GetNumSubNodes() == 3 ); return GetSubNode( 2 ); }
};
 
 
class SmBinVerNode final : public SmStructureNode
{
public:
    explicit SmBinVerNode(const SmToken &rNodeToken)
        : SmStructureNode(SmNodeType::BinVer, rNodeToken, 3) { }
 
    virtual const SmNode * GetLeftMost() const override;
 
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
 
    void Accept(SmVisitor* pVisitor) override;
};
 
 
class SmBinDiagonalNode final : public SmStructureNode
{
    bool mbAscending;
 
    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) { }
 
    bool    IsAscending() const { return mbAscending; }
 
    void    SetAscending(bool bVal)  { mbAscending = bVal; }
 
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
 
    void Accept(SmVisitor* pVisitor) override;
};
 
 
enum SmSubSup
{   CSUB, CSUP, RSUB, RSUP, LSUB, LSUP
};
 
#define SUBSUP_NUM_ENTRIES 6
 
class SmSubSupNode final : public SmStructureNode
{
    bool mbUseLimits;
 
public:
    explicit SmSubSupNode(const SmToken &rNodeToken)
        : SmStructureNode(SmNodeType::SubSup, rNodeToken, 1 + SUBSUP_NUM_ENTRIES)
        , mbUseLimits(false) { }
 
    const SmNode * GetBody() const { return const_cast<SmSubSupNode *>(this)->GetBody(); }
          SmNode * GetBody()       { return GetSubNode(0); }
 
    bool  IsUseLimits() const { return mbUseLimits; };
 
    void  SetUseLimits(bool bVal) { mbUseLimits = bVal; }
 
     const SmNode * GetSubSup(SmSubSup eSubSup) const { return const_cast< SmSubSupNode* >
                                                            ( this )->GetSubSup( eSubSup ); }
           SmNode * GetSubSup(SmSubSup eSubSup)       { return GetSubNode(1 + eSubSup); };
 
    void SetBody(SmNode* pBody) { SetSubNode(0, pBody); }
 
    void SetSubSup(SmSubSup eSubSup, SmNode* pScript) { SetSubNode( 1 + eSubSup, pScript); }
 
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
 
    void Accept(SmVisitor* pVisitor) override;
 
};
 
 
class SmBraceNode final : public SmStructureNode
{
public:
    explicit SmBraceNode(const SmToken &rNodeToken)
        : SmStructureNode(SmNodeType::Brace, rNodeToken, 3) { }
 
    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 )); }
 
    const SmNode* Body() const { return const_cast<SmBraceNode *>(this)->Body(); }
    SmNode* Body()             { assert( GetNumSubNodes() == 3 ); return GetSubNode( 1 ); }
 
    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 )); }
 
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
 
    void Accept(SmVisitor* pVisitor) override;
};
 
 
class SmBracebodyNode final : public SmStructureNode
{
    tools::Long mnBodyHeight;
 
public:
    explicit SmBracebodyNode(const SmToken &rNodeToken)
        : SmStructureNode(SmNodeType::Bracebody, rNodeToken)
        , mnBodyHeight(0) { }
 
    virtual void    Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
    tools::Long GetBodyHeight() const { return mnBodyHeight; }
 
    void Accept(SmVisitor* pVisitor) override;
};
 
 
class SmVerticalBraceNode final : public SmStructureNode
{
public:
    explicit SmVerticalBraceNode(const SmToken &rNodeToken)
    : SmStructureNode(SmNodeType::VerticalBrace, rNodeToken, 3) { }
 
    const SmNode* Body() const { return const_cast<SmVerticalBraceNode *>(this)->Body(); }
    SmNode* Body()             { assert( GetNumSubNodes() == 3 ); return GetSubNode( 0 ); }
 
    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 )); }
 
    const SmNode* Script() const { return const_cast<SmVerticalBraceNode *>(this)->Script(); }
          SmNode* Script()       { assert( GetNumSubNodes() == 3 ); return GetSubNode( 2 ); }
 
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
 
    void Accept(SmVisitor* pVisitor) override;
};
 
class SmOperNode final : public SmStructureNode
{
public:
    explicit SmOperNode(const SmToken &rNodeToken)
        : SmStructureNode(SmNodeType::Oper, rNodeToken, 2) { }
 
    const SmNode * GetSymbol() const { return const_cast<SmOperNode *>(this)->GetSymbol(); }
          SmNode * GetSymbol();
 
    tools::Long CalcSymbolHeight(const SmNode &rSymbol, const SmFormat &rFormat) const;
 
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
 
    void Accept(SmVisitor* pVisitor) override;
};
 
 
class SmAlignNode final : public SmStructureNode
{
public:
    explicit SmAlignNode(const SmToken &rNodeToken)
        : SmStructureNode(SmNodeType::Align, rNodeToken) { }
 
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
 
    void Accept(SmVisitor* pVisitor) override;
};
 
 
class SmAttributeNode final : public SmStructureNode
{
public:
    explicit SmAttributeNode(const SmToken &rNodeToken)
        : SmStructureNode(SmNodeType::Attribute, rNodeToken, 2) {}
 
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
 
    void Accept(SmVisitor* pVisitor) override;
 
    const SmNode* Attribute() const { return const_cast<SmAttributeNode *>(this)->Attribute(); }
          SmNode* Attribute()       { assert( GetNumSubNodes() == 2 ); return GetSubNode( 0 ); }
 
    const SmNode* Body() const { return const_cast<SmAttributeNode *>(this)->Body(); }
          SmNode* Body()      { assert( GetNumSubNodes() == 2 ); return GetSubNode( 1 ); }
};
 
 
class SmFontNode final : public SmStructureNode
{
    FontSizeType meSizeType;
    Fraction     maFontSize;
 
public:
    explicit SmFontNode(const SmToken &rNodeToken)
        : SmStructureNode(SmNodeType::Font, rNodeToken)
        , meSizeType(FontSizeType::MULTIPLY)
        , maFontSize(1) { }
 
    void SetSizeParameter(const Fraction &rValue, FontSizeType nType)
                            { meSizeType = nType; maFontSize = rValue; }
 
    const Fraction & GetSizeParameter() const {return maFontSize;}
 
    FontSizeType GetSizeType() const {return meSizeType;}
 
    virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell,
                         int nDepth) override;
 
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
 
    void Accept(SmVisitor* pVisitor) override;
};
 
 
class SmMatrixNode final : public SmStructureNode
{
    sal_uInt16 mnNumRows,
               mnNumCols;
 
public:
    explicit SmMatrixNode(const SmToken &rNodeToken)
        : SmStructureNode(SmNodeType::Matrix, rNodeToken)
        , mnNumRows(0)
        , mnNumCols(0) { }
 
    sal_uInt16 GetNumRows() const {return mnNumRows;}
 
    sal_uInt16 GetNumCols() const {return mnNumCols;}
 
    void SetRowCol(sal_uInt16 nMatrixRows, sal_uInt16 nMatrixCols)
                     { mnNumRows = nMatrixRows; mnNumCols = nMatrixCols; }
 
    virtual const SmNode * GetLeftMost() const override;
 
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
 
    void Accept(SmVisitor* pVisitor) override;
};
 
 
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; }
 
    virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell,
                         int nDepth) override;
 
    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
 
    void Accept(SmVisitor* pVisitor) override;
 
};
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */