4dbe4a9313
Change-Id: I4f01eb3842ef198f02af274f54afb2760c820a4b Reviewed-on: https://gerrit.libreoffice.org/c/core/+/120655 Tested-by: Jenkins Reviewed-by: Noel Grandin <noel.grandin@collabora.co.uk>
2109 lines
57 KiB
C++
2109 lines
57 KiB
C++
/* -*- 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: */
|