starmath/inc/node.hxx | 1560 +++++++++++++++++------- starmath/inc/visitors.hxx | 26 starmath/qa/cppunit/test_cursor.cxx | 8 starmath/qa/cppunit/test_nodetotextvisitors.cxx | 32 starmath/qa/extras/mmlimport-test.cxx | 46 starmath/source/mathmlimport.cxx | 9 starmath/source/node.cxx | 593 --------- starmath/source/parse.cxx | 3 starmath/source/visitors.cxx | 509 +++++++ 9 files changed, 1787 insertions(+), 999 deletions(-)
New commits: commit 8c716704df4aaa83fcd198cc8d92cd3e1e542de9 Author: dante <[email protected]> AuthorDate: Wed Jul 15 02:58:57 2020 +0200 Commit: Noel Grandin <[email protected]> CommitDate: Tue Sep 22 11:46:45 2020 +0200 tdf#38885 Remove createTextFromNode Change-Id: I85df73e498d61b976ddb908ab1b9c5e368d178cf Reviewed-on: https://gerrit.libreoffice.org/c/core/+/98795 Tested-by: Jenkins Reviewed-by: Noel Grandin <[email protected]> diff --git a/starmath/inc/node.hxx b/starmath/inc/node.hxx index 1e301369c592..c0320e6bef5e 100644 --- a/starmath/inc/node.hxx +++ b/starmath/inc/node.hxx @@ -95,9 +95,9 @@ enum class SmNodeType class SmNode : public SmRect { - SmFace maFace; - SmToken maNodeToken; + SmFace maFace; + SmToken maNodeToken; SmNodeType meType; SmScaleMode meScaleMode; RectHorAlign meRectHorAlign; @@ -115,96 +115,304 @@ public: SmNode(const SmNode&) = delete; SmNode& operator=(const SmNode&) = delete; - virtual ~SmNode(); + 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; + 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); - } + /** + * 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; - FontChangeMask &Flags() { return mnFlags; } - FontAttribute &Attributes() { return mnAttributes; } + /** + * Gets the FontChangeMask flags. + * @return FontChangeMask flags + */ + FontChangeMask &Flags() { return mnFlags; } - bool IsPhantom() const { return mbIsPhantom; } - void SetPhantom(bool bIsPhantom); - void SetColor(const Color &rColor); + /** + * Gets the font attributes. + * @return font attributes + */ + FontAttribute &Attributes() { return mnAttributes; } - void SetAttribut(FontAttribute nAttrib); - void ClearAttribut(FontAttribute nAttrib); + /** + * Checks if it is a visible node rendered invisible. + * @return rendered visibility + */ + bool IsPhantom() const { return mbIsPhantom; } - const SmFace & GetFont() const { return maFace; }; - SmFace & GetFont() { return maFace; }; + /** + * Sets the render visibility of a visible node to bIsPhantom. + * @param bIsPhantom + * @return + */ + void SetPhantom(bool bIsPhantom); - void SetFont(const SmFace &rFace); - void SetFontSize(const Fraction &rRelSize, FontSizeType nType); - void SetSize(const Fraction &rScale); + /** + * Sets the font color. + * @param rColor + * @return + */ + void SetColor(const Color &rColor); - /** Prepare preliminary settings about font and text - * (e.g. maFace, meRectHorAlign, mnFlags, mnAttributes, etc.) + /** + * Sets the font attribute nAttrib. + * Check FontAttribute class. + * @param nAttrib + * @return + */ + void SetAttribut(FontAttribute nAttrib); + + /** + * Clears the font attribute nAttrib. + * Check FontAttribute class. + * @param nAttrib + * @return + */ + void ClearAttribut(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(); - void SetRectHorAlign(RectHorAlign eHorAlign, bool bApplyToSubTree = true ); + /** + * 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; } - void Move(const Point &rPosition); - void MoveTo(const Point &rPosition) { Move(rPosition - GetTopLeft()); } + /** + * 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; - virtual void CreateTextFromNode(OUStringBuffer &rText); - 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; + /** + * 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>(maNodeToken.nRow); } - sal_uInt16 GetRow() const { return sal::static_int_cast<sal_uInt16>(maNodeToken.nRow); } - sal_uInt16 GetColumn() const { return sal::static_int_cast<sal_uInt16>(maNodeToken.nCol); } + /** + * Gets the colum of the line in the text where the node is located. + * It is used to do the visual <-> text correspondence. + * @return colum + */ + sal_uInt16 GetColumn() const { return sal::static_int_cast<sal_uInt16>(maNodeToken.nCol); } - SmScaleMode GetScaleMode() const { return meScaleMode; } - void SetScaleMode(SmScaleMode eMode) { meScaleMode = eMode; } + /** + * 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); - SmNodeType GetType() const { return meType; } + /** + * 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; } + /** + * 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 + /** + * Accept a visitor. + * Calls the method for this class on the visitor. + * @param pVisitor + * @return */ virtual void Accept(SmVisitor* pVisitor) = 0; - /** True if this node is selected */ + /** + * 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;} - /** Get the parent node of this node */ - SmStructureNode* GetParent(){ return mpParentNode; } + /** + * Gets the parent node of this node. + * @return parent node + */ const SmStructureNode* GetParent() const { return mpParentNode; } - /** Set the parent node */ - void SetParent(SmStructureNode* parent){ - mpParentNode = parent; - } + SmStructureNode* GetParent() { return mpParentNode; } - /** Set the token for this node */ - void SetToken(SmToken const & token){ - maNodeToken = token; - } + /** + * 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; @@ -223,57 +431,102 @@ class SmStructureNode : public SmNode protected: SmStructureNode(SmNodeType eNodeType, const SmToken &rNodeToken, size_t nSize = 0) : SmNode(eNodeType, rNodeToken) - , maSubNodes(nSize) - {} + , maSubNodes(nSize) {} public: virtual ~SmStructureNode() override; - virtual bool IsVisible() const 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; - virtual size_t GetNumSubNodes() 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; + virtual SmNode * GetSubNode(size_t nIndex) override; + + /** + * Does the cleaning of the subnodes. + * @return + */ void ClearSubNodes(); - void SetSubNodes(std::unique_ptr<SmNode> pFirst, std::unique_ptr<SmNode> pSecond, std::unique_ptr<SmNode> pThird = nullptr); - void SetSubNodes(SmNodeArray&& rNodeArray); + /** + * Sets subnodes, used for opperators. + * @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 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 a child node - * + /** + * 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) - { - size_t nSize = GetNumSubNodes(); - for (size_t i = 0; i < nSize; i++) - if (pSubNode == GetSubNode(i)) - return i; - return -1; - } + int IndexOfSubNode(SmNode const * pSubNode); - void SetSubNode(size_t nIndex, SmNode* pNode) - { - size_t size = maSubNodes.size(); - if (size <= nIndex) - { - //Resize subnodes array - maSubNodes.resize(nIndex + 1); - //Set new slots to NULL except at nIndex - for (size_t i = size; i < nIndex; i++) - maSubNodes[i] = nullptr; - } - maSubNodes[nIndex] = pNode; - if (pNode) - pNode->SetParent(this); - } + /** + * 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 */ @@ -290,13 +543,28 @@ class SmVisibleNode : public SmNode { protected: SmVisibleNode(SmNodeType eNodeType, const SmToken &rNodeToken) - : SmNode(eNodeType, 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; }; @@ -306,11 +574,15 @@ class SmGraphicNode : public SmVisibleNode { protected: SmGraphicNode(SmNodeType eNodeType, const SmToken &rNodeToken) - : SmVisibleNode(eNodeType, rNodeToken) - {} + : SmVisibleNode(eNodeType, rNodeToken) {} public: + /** + * Appends to rText the node text. + * @param rText + * @return + */ virtual void GetAccessibleText( OUStringBuffer &rText ) const override; }; @@ -328,12 +600,24 @@ public: : 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; - void CreateTextFromNode(OUStringBuffer &rText) override; + /** + * Accept a visitor. + * Calls the method for this class on the visitor. + * @param pVisitor + * @return + */ void Accept(SmVisitor* pVisitor) override; }; @@ -351,14 +635,36 @@ class SmPolyLineNode final : public SmGraphicNode public: explicit SmPolyLineNode(const SmToken &rNodeToken); - long GetWidth() const { return mnWidth; } - tools::Polygon &GetPolygon() { return maPoly; } + /** + * Gets the width of the rect. + * @return width + */ + 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; }; @@ -369,6 +675,8 @@ public: */ class SmTextNode : public SmVisibleNode { + +protected: OUString maText; sal_uInt16 mnFontDesc; /** Index within text where the selection starts @@ -386,42 +694,115 @@ protected: 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; } - /** Change the text of this node, including the underlying token */ - void ChangeText(const OUString &rText) { - maText = rText; - SmToken token = GetToken(); - token.aText = rText; - SetToken(token); //TODO: Merge this with AdjustFontDesc for better performance - AdjustFontDesc(); - } - /** Try to guess the correct FontDesc, used during visual editing */ - void AdjustFontDesc(); - /** Index within GetText() where the selection starts - * @remarks Only valid of SmNode::IsSelected() is true - */ - sal_Int32 GetSelectionStart() const {return mnSelectionStart;} - /** Index within GetText() where the selection end - * @remarks Only valid of SmNode::IsSelected() is true - */ - sal_Int32 GetSelectionEnd() const {return mnSelectionEnd;} - /** Set the index within GetText() where the selection starts */ - void SetSelectionStart(sal_Int32 index) {mnSelectionStart = index;} - /** Set the index within GetText() where the selection end */ - void SetSelectionEnd(sal_Int32 index) {mnSelectionEnd = index;} - - virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell, int nDepth) override; + /** + * Returns the font type being used (text, variabla, symbol, ...). + * @retutn font type + */ + sal_uInt16 GetFontDesc() const { return mnFontDesc; } + + /** + * Sets the font type to fontdesc. + * Definitions are on format.hxx. + * @param fontdesc + * @return + */ + void SetFontDesc(sal_uInt16 fontdesc) { mnFontDesc=fontdesc; } + + /** + * 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; - virtual void CreateTextFromNode(OUStringBuffer &rText) 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. - */ + * 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); }; @@ -443,9 +824,31 @@ protected: public: explicit SmSpecialNode(const SmToken &rNodeToken); - virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell, int nDepth) 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; }; @@ -466,7 +869,20 @@ public: : 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; }; @@ -482,19 +898,41 @@ protected: : SmSpecialNode(eNodeType, rNodeToken, FNT_MATH) { sal_Unicode cChar = GetToken().cMathChar; - if (u'\0' != cChar) - SetText(OUString(cChar)); + if (u'\0' != cChar) SetText(OUString(cChar)); } 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; + /** + * 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; - void CreateTextFromNode(OUStringBuffer &rText) override; + + /** + * Accept a visitor. + * Calls the method for this class on the visitor. + * @param pVisitor + * @return + */ void Accept(SmVisitor* pVisitor) override; }; @@ -526,14 +964,25 @@ class SmRootSymbolNode final : public SmMathSymbolNode public: explicit SmRootSymbolNode(const SmToken &rNodeToken) : SmMathSymbolNode(SmNodeType::RootSymbol, rNodeToken) - , mnBodyWidth(0) - { - } + , 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; }; @@ -548,13 +997,34 @@ class SmPlaceNode final : public SmMathSymbolNode { public: explicit SmPlaceNode(const SmToken &rNodeToken) - : SmMathSymbolNode(SmNodeType::Place, rNodeToken) - { - } - SmPlaceNode() : SmMathSymbolNode(SmNodeType::Place, SmToken(TPLACE, MS_PLACE, "<?>")) {}; + : SmMathSymbolNode(SmNodeType::Place, rNodeToken) { } + SmPlaceNode() : SmMathSymbolNode(SmNodeType::Place, SmToken(TPLACE, MS_PLACE, "<?>")) { }; - virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell, int nDepth) 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; }; @@ -568,13 +1038,33 @@ class SmErrorNode final : public SmMathSymbolNode { public: explicit SmErrorNode(const SmToken &rNodeToken) - : SmMathSymbolNode(SmNodeType::Error, rNodeToken) - { - SetText(OUString(MS_ERROR)); - } + : 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; - 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; }; @@ -592,15 +1082,30 @@ class SmTableNode final : public SmStructureNode public: explicit SmTableNode(const SmToken &rNodeToken) : SmStructureNode(SmNodeType::Table, rNodeToken) - , mnFormulaBaseline(0) - { - } + , 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 + */ long GetFormulaBaseline() const; + /** + * Accept a visitor. + * Calls the method for this class on the visitor. + * @param pVisitor + * @return + */ void Accept(SmVisitor* pVisitor) override; }; @@ -617,22 +1122,55 @@ class SmLineNode : public SmStructureNode protected: SmLineNode(SmNodeType eNodeType, const SmToken &rNodeToken) : SmStructureNode(eNodeType, rNodeToken) - , mbUseExtraSpaces(true) - { - } + , mbUseExtraSpaces(true) { } public: explicit SmLineNode(const SmToken &rNodeToken) : SmStructureNode(SmNodeType::Line, rNodeToken) - , mbUseExtraSpaces(true) - { - } + , 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; }; - virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell, int nDepth) 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; }; @@ -647,11 +1185,22 @@ class SmExpressionNode final : public SmLineNode { public: explicit SmExpressionNode(const SmToken &rNodeToken) - : SmLineNode(SmNodeType::Expression, rNodeToken) - {} + : SmLineNode(SmNodeType::Expression, rNodeToken) { } + /** + * Prepares the SmRect to render. + * @param rDev + * @param rFormat + * @return + */ virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override; - void CreateTextFromNode(OUStringBuffer &rText) override; + + /** + * Accept a visitor. + * Calls the method for this class on the visitor. + * @param pVisitor + * @return + */ void Accept(SmVisitor* pVisitor) override; }; @@ -664,11 +1213,22 @@ class SmUnHorNode final : public SmStructureNode { public: explicit SmUnHorNode(const SmToken &rNodeToken) - : SmStructureNode(SmNodeType::UnHor, rNodeToken, 2) - { - } + : 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; }; @@ -688,20 +1248,49 @@ class SmRootNode final : public SmStructureNode { public: explicit SmRootNode(const SmToken &rNodeToken) - : SmStructureNode(SmNodeType::Root, rNodeToken, 3) - { - } + : SmStructureNode(SmNodeType::Root, rNodeToken, 3) { } + /** + * Prepares the SmRect to render. + * @param rDev + * @param rFormat + * @return + */ virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override; - void CreateTextFromNode(OUStringBuffer &rText) override; + + /** + * Accept a visitor. + * Calls the method for this class on the visitor. + * @param pVisitor + * @return + */ void Accept(SmVisitor* pVisitor) override; - SmNode* Argument(); - const SmNode* Argument() const; - SmRootSymbolNode* Symbol(); - const SmRootSymbolNode* Symbol() const; - SmNode* Body(); - const SmNode* Body() const; + /** + * 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 ); } + }; @@ -720,19 +1309,44 @@ class SmBinHorNode final : public SmStructureNode { public: explicit SmBinHorNode(const SmToken &rNodeToken) - : SmStructureNode(SmNodeType::BinHor, rNodeToken, 3) - { - } + : 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; - SmNode* Symbol(); - const SmNode* Symbol() const; - SmNode* LeftOperand(); - const SmNode* LeftOperand() const; - SmNode* RightOperand(); - const SmNode* RightOperand() const; + /** + * Returns the node containing the data of the binary opperator. + * @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 opperand. + * @return left opperand 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 opperand. + * @return right opperand data + */ + const SmNode* RightOperand() const { return const_cast<SmBinHorNode *>(this)->RightOperand(); } + SmNode* RightOperand() { assert( GetNumSubNodes() == 3 ); return GetSubNode( 2 ); } }; @@ -752,14 +1366,24 @@ class SmBinVerNode final : public SmStructureNode { public: explicit SmBinVerNode(const SmToken &rNodeToken) - : SmStructureNode(SmNodeType::BinVer, rNodeToken, 3) - { - } + : 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; - void CreateTextFromNode(OUStringBuffer &rText) override; + + /** + * Accept a visitor. + * Calls the method for this class on the visitor. + * @param pVisitor + * @return + */ void Accept(SmVisitor* pVisitor) override; }; @@ -778,20 +1402,56 @@ class SmBinDiagonalNode final : public SmStructureNode { bool mbAscending; - void GetOperPosSize(Point &rPos, Size &rSize, - const Point &rDiagPoint, double fAngleDeg) const; + /** + * 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) - { - } + , 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; }; @@ -843,33 +1503,68 @@ class SmSubSupNode final : public SmStructureNode public: explicit SmSubSupNode(const SmToken &rNodeToken) : SmStructureNode(SmNodeType::SubSup, rNodeToken, 1 + SUBSUP_NUM_ENTRIES) - , mbUseLimits(false) - { - } + , mbUseLimits(false) { } - /** Get body (Not NULL) */ - SmNode * GetBody() { return GetSubNode(0); } - /** Get body (Not NULL) */ - const SmNode * GetBody() const - { - return const_cast<SmSubSupNode *>(this)->GetBody(); - } + /** + * 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); } - void SetUseLimits(bool bVal) { mbUseLimits = bVal; } + /** + * Checks if it is going to be used for a limit. + * Example lim from { x towar 0 } { {sin x}over x } = 1 + * @return is a limit + */ bool IsUseLimits() const { return mbUseLimits; }; - /** Get super- or subscript + /** + * 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 */ - SmNode * GetSubSup(SmSubSup eSubSup) { return GetSubNode(1 + eSubSup); }; - const SmNode * GetSubSup(SmSubSup eSubSup) const { return const_cast< SmSubSupNode* >( this )->GetSubSup( eSubSup ); } + const SmNode * GetSubSup(SmSubSup eSubSup) const { return const_cast< SmSubSupNode* > + ( this )->GetSubSup( eSubSup ); } + SmNode * GetSubSup(SmSubSup eSubSup) { return GetSubNode(1 + eSubSup); }; - /** Set the body */ + /** + * 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; - void CreateTextFromNode(OUStringBuffer &rText) override; + + /** + * Accept a visitor. + * Calls the method for this class on the visitor. + * @param pVisitor + * @return + */ void Accept(SmVisitor* pVisitor) override; }; @@ -892,19 +1587,53 @@ class SmBraceNode final : public SmStructureNode { public: explicit SmBraceNode(const SmToken &rNodeToken) - : SmStructureNode(SmNodeType::Brace, rNodeToken, 3) - { - } + : 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 )); } - SmMathSymbolNode* OpeningBrace(); - const SmMathSymbolNode* OpeningBrace() const; - SmNode* Body(); - const SmNode* Body() const; - SmMathSymbolNode* ClosingBrace(); - const SmMathSymbolNode* ClosingBrace() const; + /** + * 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; - void CreateTextFromNode(OUStringBuffer &rText) override; + + /** + * Accept a visitor. + * Calls the method for this class on the visitor. + * @param pVisitor + * @return + */ void Accept(SmVisitor* pVisitor) override; }; @@ -925,12 +1654,23 @@ class SmBracebodyNode final : public SmStructureNode public: explicit SmBracebodyNode(const SmToken &rNodeToken) : SmStructureNode(SmNodeType::Bracebody, rNodeToken) - , mnBodyHeight(0) - { - } + , mnBodyHeight(0) { } + /** + * Prepares the SmRect to render. + * @param rDev + * @param rFormat + * @return + */ virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override; 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; }; @@ -950,25 +1690,53 @@ public: class SmVerticalBraceNode final : public SmStructureNode { public: - explicit inline SmVerticalBraceNode(const SmToken &rNodeToken); + explicit SmVerticalBraceNode(const SmToken &rNodeToken) + : SmStructureNode(SmNodeType::VerticalBrace, rNodeToken, 3) { } - SmNode* Body(); - const SmNode* Body() const; - SmMathSymbolNode* Brace(); - const SmMathSymbolNode* Brace() const; - SmNode* Script(); - const SmNode* Script() const; + /** + * 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 ); } - virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override; - void Accept(SmVisitor* pVisitor) override; -}; + /** + * 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 ); } -inline SmVerticalBraceNode::SmVerticalBraceNode(const SmToken &rNodeToken) - : SmStructureNode(SmNodeType::VerticalBrace, 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; +}; /** Operation Node * @@ -984,19 +1752,39 @@ class SmOperNode final : public SmStructureNode { public: explicit SmOperNode(const SmToken &rNodeToken) - : SmStructureNode(SmNodeType::Oper, rNodeToken, 2) - { - } + : SmStructureNode(SmNodeType::Oper, rNodeToken, 2) { } - SmNode * GetSymbol(); - const SmNode * GetSymbol() const - { - return const_cast<SmOperNode *>(this)->GetSymbol(); - } + /** + * Returns the node with the opperator data + * @return opperator 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 opperator data ) + * and the font format ( rFormat ). + * @param rSymbol + * @param rFormat + * @return node's height + */ 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; }; @@ -1009,10 +1797,22 @@ class SmAlignNode final : public SmStructureNode { public: explicit SmAlignNode(const SmToken &rNodeToken) - : SmStructureNode(SmNodeType::Align, 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; }; @@ -1031,17 +1831,37 @@ class SmAttributNode final : public SmStructureNode { public: explicit SmAttributNode(const SmToken &rNodeToken) - : SmStructureNode(SmNodeType::Attribut, rNodeToken, 2) - {} + : SmStructureNode(SmNodeType::Attribut, rNodeToken, 2) {} + /** + * Prepares the SmRect to render. + * @param rDev + * @param rFormat + * @return + */ virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override; - void CreateTextFromNode(OUStringBuffer &rText) override; + + /** + * Accept a visitor. + * Calls the method for this class on the visitor. + * @param pVisitor + * @return + */ void Accept(SmVisitor* pVisitor) override; - SmNode* Attribute(); - const SmNode* Attribute() const; - SmNode* Body(); - const SmNode* Body() const; + /** + * Gets the attribute data. + * @return attribute data + */ + const SmNode* Attribute() const { return const_cast<SmAttributNode *>(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<SmAttributNode *>(this)->Body(); } + SmNode* Body() { assert( GetNumSubNodes() == 2 ); return GetSubNode( 1 ); } }; @@ -1058,17 +1878,56 @@ public: explicit SmFontNode(const SmToken &rNodeToken) : SmStructureNode(SmNodeType::Font, rNodeToken) , meSizeType(FontSizeType::MULTIPLY) - , maFontSize(1) - { - } + , 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; } - void SetSizeParameter(const Fraction &rValue, FontSizeType nType); + /** + * 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;} - virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell, int nDepth) 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; - void CreateTextFromNode(OUStringBuffer &rText) override; + + /** + * Accept a visitor. + * Calls the method for this class on the visitor. + * @param pVisitor + * @return + */ void Accept(SmVisitor* pVisitor) override; }; @@ -1087,18 +1946,45 @@ public: explicit SmMatrixNode(const SmToken &rNodeToken) : SmStructureNode(SmNodeType::Matrix, rNodeToken) , mnNumRows(0) - , mnNumCols(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;} - void SetRowCol(sal_uInt16 nMatrixRows, sal_uInt16 nMatrixCols); + + /** + * 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; - void CreateTextFromNode(OUStringBuffer &rText) override; + + /** + * Accept a visitor. + * Calls the method for this class on the visitor. + * @param pVisitor + * @return + */ void Accept(SmVisitor* pVisitor) override; }; @@ -1114,157 +2000,41 @@ class SmBlankNode final : public SmGraphicNode public: explicit SmBlankNode(const SmToken &rNodeToken) : SmGraphicNode(SmNodeType::Blank, rNodeToken) - , mnNum(0) - { - } + , 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; - virtual void CreateTextFromNode(OUStringBuffer &rText) override; -}; - - -inline SmNode* SmRootNode::Argument() -{ - assert( GetNumSubNodes() == 3 ); - return GetSubNode( 0 ); -} -inline const SmNode* SmRootNode::Argument() const -{ - return const_cast< SmRootNode* >( this )->Argument(); -} -inline SmRootSymbolNode* SmRootNode::Symbol() -{ - assert( GetNumSubNodes() == 3 ); - assert( GetSubNode( 1 )->GetType() == SmNodeType::RootSymbol ); - return static_cast< SmRootSymbolNode* >( GetSubNode( 1 )); -} -inline const SmRootSymbolNode* SmRootNode::Symbol() const -{ - return const_cast< SmRootNode* >( this )->Symbol(); -} -inline SmNode* SmRootNode::Body() -{ - assert( GetNumSubNodes() == 3 ); - return GetSubNode( 2 ); -} -inline const SmNode* SmRootNode::Body() const -{ - return const_cast< SmRootNode* >( this )->Body(); -} - - -inline SmNode* SmBinHorNode::Symbol() -{ - assert( GetNumSubNodes() == 3 ); - return GetSubNode( 1 ); -} -inline const SmNode* SmBinHorNode::Symbol() const -{ - return const_cast< SmBinHorNode* >( this )->Symbol(); -} -inline SmNode* SmBinHorNode::LeftOperand() -{ - assert( GetNumSubNodes() == 3 ); - return GetSubNode( 0 ); -} -inline const SmNode* SmBinHorNode::LeftOperand() const -{ - return const_cast< SmBinHorNode* >( this )->LeftOperand(); -} -inline SmNode* SmBinHorNode::RightOperand() -{ - assert( GetNumSubNodes() == 3 ); - return GetSubNode( 2 ); -} -inline const SmNode* SmBinHorNode::RightOperand() const -{ - return const_cast< SmBinHorNode* >( this )->RightOperand(); -} + /** + * 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; -inline SmNode* SmAttributNode::Attribute() -{ - assert( GetNumSubNodes() == 2 ); - return GetSubNode( 0 ); -} -inline const SmNode* SmAttributNode::Attribute() const -{ - return const_cast< SmAttributNode* >( this )->Attribute(); -} -inline SmNode* SmAttributNode::Body() -{ - assert( GetNumSubNodes() == 2 ); - return GetSubNode( 1 ); -} -inline const SmNode* SmAttributNode::Body() const -{ - return const_cast< SmAttributNode* >( this )->Body(); -} + /** + * Prepares the SmRect to render. + * @param rDev + * @param rFormat + * @return + */ + virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override; -inline SmMathSymbolNode* SmBraceNode::OpeningBrace() -{ - assert( GetNumSubNodes() == 3 ); - assert( GetSubNode( 0 )->GetType() == SmNodeType::Math ); - return static_cast< SmMathSymbolNode* >( GetSubNode( 0 )); -} -inline const SmMathSymbolNode* SmBraceNode::OpeningBrace() const -{ - return const_cast< SmBraceNode* >( this )->OpeningBrace(); -} -inline SmNode* SmBraceNode::Body() -{ - assert( GetNumSubNodes() == 3 ); - return GetSubNode( 1 ); -} -inline const SmNode* SmBraceNode::Body() const -{ - return const_cast< SmBraceNode* >( this )->Body(); -} -inline SmMathSymbolNode* SmBraceNode::ClosingBrace() -{ - assert( GetNumSubNodes() == 3 ); - assert( GetSubNode( 2 )->GetType() == SmNodeType::Math ); - return static_cast< SmMathSymbolNode* >( GetSubNode( 2 )); -} -inline const SmMathSymbolNode* SmBraceNode::ClosingBrace() const -{ - return const_cast< SmBraceNode* >( this )->ClosingBrace(); -} + /** + * Accept a visitor. + * Calls the method for this class on the visitor. + * @param pVisitor + * @return + */ + void Accept(SmVisitor* pVisitor) override; -inline SmNode* SmVerticalBraceNode::Body() -{ - assert( GetNumSubNodes() == 3 ); - return GetSubNode( 0 ); -} -inline const SmNode* SmVerticalBraceNode::Body() const -{ - return const_cast< SmVerticalBraceNode* >( this )->Body(); -} -inline SmMathSymbolNode* SmVerticalBraceNode::Brace() -{ - assert( GetNumSubNodes() == 3 ); - assert( GetSubNode( 1 )->GetType() == SmNodeType::Math ); - return static_cast< SmMathSymbolNode* >( GetSubNode( 1 )); -} -inline const SmMathSymbolNode* SmVerticalBraceNode::Brace() const -{ - return const_cast< SmVerticalBraceNode* >( this )->Brace(); -} -inline SmNode* SmVerticalBraceNode::Script() -{ - assert( GetNumSubNodes() == 3 ); - return GetSubNode( 2 ); -} -inline const SmNode* SmVerticalBraceNode::Script() const -{ - return const_cast< SmVerticalBraceNode* >( this )->Script(); -} +}; #endif diff --git a/starmath/inc/visitors.hxx b/starmath/inc/visitors.hxx index 3f903aba8820..1591d3757860 100644 --- a/starmath/inc/visitors.hxx +++ b/starmath/inc/visitors.hxx @@ -438,21 +438,37 @@ public: void Visit( SmRectangleNode* pNode ) override; void Visit( SmVerticalBraceNode* pNode ) override; private: - /** Extract text from a pNode that constitutes a line */ + + /** + * Extract text from a pNode that constitutes a line. + * @param pNode + * @return + */ void LineToText( SmNode* pNode ) { Separate( ); - if( pNode ) - pNode->Accept( this ); + if( pNode ) pNode->Accept( this ); Separate( ); } + + /** + * Appends rText to the OUStringBuffer ( maCmdText ). + * @param rText + * @return + */ void Append( const OUString &rText ) { maCmdText.append( rText ); } - /** Append a blank for separation, if needed */ + + /** + * Append a blank for separation, if needed. + * It is needed if last char is not ' '. + * @return + */ void Separate( ){ - if( maCmdText.isEmpty() || maCmdText[ maCmdText.getLength() - 1 ] != ' ' ) + if( !maCmdText.isEmpty() && maCmdText[ maCmdText.getLength() - 1 ] != ' ' ) maCmdText.append(' '); } + /** Output text generated from the pNodes */ OUStringBuffer maCmdText; }; diff --git a/starmath/qa/cppunit/test_cursor.cxx b/starmath/qa/cppunit/test_cursor.cxx index 200af93f2849..8cf0bced8eb8 100644 --- a/starmath/qa/cppunit/test_cursor.cxx +++ b/starmath/qa/cppunit/test_cursor.cxx @@ -84,7 +84,7 @@ void Test::testCopyPaste() aCursor.Move(pOutputDevice, MoveRight); aCursor.Paste(); - CPPUNIT_ASSERT_EQUAL(OUString(" { a * b + c * b } "), xDocShRef->GetText()); + CPPUNIT_ASSERT_EQUAL(OUString("{ a * b + c * b }"), xDocShRef->GetText()); } void Test::testCopySelectPaste() @@ -110,7 +110,7 @@ void Test::testCopySelectPaste() aCursor.Move(pOutputDevice, MoveRight, false); aCursor.Paste(); - CPPUNIT_ASSERT_EQUAL(OUString(" { b + c * b + c } "), xDocShRef->GetText()); + CPPUNIT_ASSERT_EQUAL(OUString("{ b + c * b + c }"), xDocShRef->GetText()); } void Test::testCutPaste() @@ -132,7 +132,7 @@ void Test::testCutPaste() aCursor.Move(pOutputDevice, MoveRight); aCursor.Paste(); - CPPUNIT_ASSERT_EQUAL(OUString(" { a + c * b } "), xDocShRef->GetText()); + CPPUNIT_ASSERT_EQUAL(OUString("{ a + c * b }"), xDocShRef->GetText()); } void Test::testCutSelectPaste() @@ -158,7 +158,7 @@ void Test::testCutSelectPaste() aCursor.Move(pOutputDevice, MoveRight, false); aCursor.Paste(); - CPPUNIT_ASSERT_EQUAL(OUString(" { b + c * } "), xDocShRef->GetText()); + CPPUNIT_ASSERT_EQUAL(OUString("{ b + c * }"), xDocShRef->GetText()); } CPPUNIT_TEST_SUITE_REGISTRATION(Test); diff --git a/starmath/qa/cppunit/test_nodetotextvisitors.cxx b/starmath/qa/cppunit/test_nodetotextvisitors.cxx index 0faf69ee9d87..72a78abaf1d5 100644 --- a/starmath/qa/cppunit/test_nodetotextvisitors.cxx +++ b/starmath/qa/cppunit/test_nodetotextvisitors.cxx @@ -114,16 +114,16 @@ void Test::SimpleUnaryOp() parseandparseagain("-+4", "Minus/plus"); parseandparseagain("neg a", "Boolean 'not'"); parseandparseagain("fact a", "Factorial"); - parseandparseagain(" - { 1 over 2 } ", "BinVer in Unary 1"); - ParseAndCheck(" - { 1 over 2 } ", " - { 1 over 2 } ", "BinVer in Unary 1"); - parseandparseagain(" { - { 1 over 2 } } ", "BinVer in Unary 2"); - parseandparseagain(" - 1 over 2 ", "Unary in BinVer as numerator 1"); - parseandparseagain(" { - 1 } over 2 ", "Unary in BinVer as numerator 2"); - parseandparseagain(" 1 over - 2 ", "Unary in BinVer as denominator 1"); - parseandparseagain(" 1 over { - 2 } ", "Unary in BinVer as denominator 2"); - parseandparseagain(" 2 { - 1 over 2 } ", "Mixed number with Unary in denominator 1"); - parseandparseagain(" 2 { - 1 } over 2 ", "Mixed number with Unary in denominator 2"); - parseandparseagain(" - 1 + 2 ", "Unary in BinHor"); + parseandparseagain("- { 1 over 2 }", "BinVer in Unary 1"); + ParseAndCheck("- { 1 over 2 }", "- { 1 over 2 }", "BinVer in Unary 1"); + parseandparseagain("{- { 1 over 2 } }", "BinVer in Unary 2"); + parseandparseagain("- 1 over 2", "Unary in BinVer as numerator 1"); + parseandparseagain("{ - 1 } over 2", "Unary in BinVer as numerator 2"); + parseandparseagain("1 over - 2", "Unary in BinVer as denominator 1"); + parseandparseagain("1 over { - 2 }", "Unary in BinVer as denominator 2"); + parseandparseagain("2 { - 1 over 2 }", "Mixed number with Unary in denominator 1"); + parseandparseagain("2 { - 1 } over 2", "Mixed number with Unary in denominator 2"); + parseandparseagain("- 1 + 2", "Unary in BinHor"); } void Test::SimpleBinaryOp() @@ -227,8 +227,8 @@ void Test::SimpleOperators() parseandparseagain("prod{a}", "Product"); parseandparseagain("coprod{a}", "Coproduct"); parseandparseagain("int from {r_0} to {r_t} a", "Upper and lower bounds shown with integral (from & to)"); - ParseAndCheck("int csup {r_0} csub {r_t} a", "int csup { r _ 0 } csub { r _ t } a ", "Upper and lower bounds shown with integral (csub & csup)"); - ParseAndCheck("sum csup { size 8 { x - 1 } } csub { size 8 a } b ", "sum csup { size 8 { x - 1 } } csub { size 8 a } b ", "Sum with sized upper and lower bounds"); + ParseAndCheck("int csup {r_0} csub {r_t} a", "int csup { r _ 0 } csub { r _ t } a", "Upper and lower bounds shown with integral (csub & csup)"); + ParseAndCheck("sum csup { size 8 { x - 1 } } csub { size 8 a } b", "sum csup { size 8 { x - 1 } } csub { size 8 a } b", "Sum with sized upper and lower bounds"); parseandparseagain("int{a}", "Integral"); parseandparseagain("intd_{1}^{2}{x dx}", "Dynamically-sized integral"); parseandparseagain("iint{a}", "Double integral"); @@ -523,7 +523,7 @@ void Test::testBinomInBinHor() aCursor.InsertElement(PlusElement); aCursor.InsertText("d"); - sExpected += " { { binom a b + c } + d } "; + sExpected += "{ { binom a b + c } + d }"; CPPUNIT_ASSERT_EQUAL_MESSAGE("Binom Node in BinHor Node", sExpected, xDocShRef->GetText()); } @@ -551,7 +551,7 @@ void Test::testBinVerInUnary() aCursor.Move(pOutputDevice, MoveDown); aCursor.InsertText("2"); - sExpected += " - { 1 over 2 } "; + sExpected += "- { 1 over 2 }"; CPPUNIT_ASSERT_EQUAL_MESSAGE("Binary Vertical in Unary Operator", sExpected, xDocShRef->GetText()); } @@ -576,7 +576,7 @@ void Test::testBinHorInSubSup() aCursor.InsertElement(PlusElement); aCursor.InsertText("d"); - CPPUNIT_ASSERT_EQUAL_MESSAGE("BinHor in SubSup", OUString(" { a ^ { b + c } + d } "), xDocShRef->GetText()); + CPPUNIT_ASSERT_EQUAL_MESSAGE("BinHor in SubSup", OUString("{ a ^ { b + c } + d }"), xDocShRef->GetText()); } void Test::testUnaryInMixedNumberAsNumerator() @@ -615,7 +615,7 @@ void Test::testUnaryInMixedNumberAsNumerator() aCursor.InsertElement(PlusElement); aCursor.InsertText("4"); - CPPUNIT_ASSERT_EQUAL_MESSAGE("Unary in mixed number as Numerator", OUString(" { 2 { - 1 over 2 } + 4 } "), xDocShRef->GetText()); + CPPUNIT_ASSERT_EQUAL_MESSAGE("Unary in mixed number as Numerator", OUString("{ 2 { - 1 over 2 } + 4 }"), xDocShRef->GetText()); } void Test::testMiscEquivalent() diff --git a/starmath/qa/extras/mmlimport-test.cxx b/starmath/qa/extras/mmlimport-test.cxx index 5ed9bc86f50a..279dbd56e4ad 100644 --- a/starmath/qa/extras/mmlimport-test.cxx +++ b/starmath/qa/extras/mmlimport-test.cxx @@ -96,66 +96,66 @@ void Test::tearDown() void Test::testColor() { loadURL(m_directories.getURLFromSrc("starmath/qa/extras/data/color.mml")); - CPPUNIT_ASSERT_EQUAL(OUString("{{color black b}" - " {color white w}" - " {color red r}" - " {color green g}" - " {color blue b}" - " {color yellow y}" - " {color silver s}" - " {color gray g}" - " {color maroon m}" - " {color purple p}" - " {color lime l}" - " {color olive o}" - " {color navy n}" - " {color teal t}" - " {color aqua a}" - " {color fuchsia f}}"), + CPPUNIT_ASSERT_EQUAL(OUString("{ color black b" + " color white w" + " color red r" + " color green g" + " color blue b" + " color yellow y" + " color silver s" + " color gray g" + " color maroon m" + " color purple p" + " color lime l" + " color olive o" + " color navy n" + " color teal t" + " color aqua a" + " color fuchsia f }"), mxDocShell->GetText()); } void Test::testSimple() { loadURL(m_directories.getURLFromSrc("starmath/qa/extras/data/simple.mml")); - CPPUNIT_ASSERT_EQUAL_MESSAGE("loaded text", OUString("left ( {a + b} right )^2"), mxDocShell->GetText()); + CPPUNIT_ASSERT_EQUAL_MESSAGE("loaded text", OUString("left ( { a + b } right ) ^ 2"), mxDocShell->GetText()); } void Test::testNsPrefixMath() { loadURL(m_directories.getURLFromSrc("starmath/qa/extras/data/ns-prefix-math.mml")); - CPPUNIT_ASSERT_EQUAL_MESSAGE("loaded text", OUString("left ( {a + b} right )^2"), mxDocShell->GetText()); + CPPUNIT_ASSERT_EQUAL_MESSAGE("loaded text", OUString("left ( { a + b } right ) ^ 2"), mxDocShell->GetText()); } void Test::testMaction() { loadURL(m_directories.getURLFromSrc("starmath/qa/extras/data/maction.mml")); - CPPUNIT_ASSERT_EQUAL_MESSAGE("loaded text", OUString("matrix {1 ## 2 ## 3}"), mxDocShell->GetText()); + CPPUNIT_ASSERT_EQUAL_MESSAGE("loaded text", OUString("matrix{ 1 ## 2 ## 3 }"), mxDocShell->GetText()); } void Test::testMspace() { loadURL(m_directories.getURLFromSrc("starmath/qa/extras/data/mspace.mml")); - CPPUNIT_ASSERT_EQUAL(OUString("{a b ~ c ~~``` d}"), mxDocShell->GetText()); + CPPUNIT_ASSERT_EQUAL(OUString("{ a b ~ c ~~``` d }"), mxDocShell->GetText()); } void Test::testtdf99556() { loadURL(m_directories.getURLFromSrc("starmath/qa/extras/data/tdf99556-1.mml")); - CPPUNIT_ASSERT_EQUAL_MESSAGE("loaded text", OUString("sqrt { {} }"), mxDocShell->GetText()); + CPPUNIT_ASSERT_EQUAL_MESSAGE("loaded text", OUString("sqrt { }"), mxDocShell->GetText()); } void Test::testTdf103430() { loadURL(m_directories.getURLFromSrc("starmath/qa/extras/data/tdf103430.mml")); - CPPUNIT_ASSERT_EQUAL(OUString("{{nitalic d}^2 {nitalic {color blue y}}} over {{nitalic d} {font sans {bold {italic {color red x}}}}}"), + CPPUNIT_ASSERT_EQUAL(OUString("{ { nitalic d ^ 2 nitalic color blue y } over { nitalic d font sans bold italic color red x } }"), mxDocShell->GetText()); } void Test::testTdf103500() { loadURL(m_directories.getURLFromSrc("starmath/qa/extras/data/tdf103500.mml")); - CPPUNIT_ASSERT_EQUAL(OUString("{{ int csub a csup b {1 over x ` {nitalic d} x}} = {intd csub a csup b {1 over y ` {nitalic d} y}}}"), + CPPUNIT_ASSERT_EQUAL(OUString("{ { int csup b csub a { { 1 over x } ` nitalic d x } } = { intd csup b csub a { { 1 over y } ` nitalic d y } } }"), mxDocShell->GetText()); } diff --git a/starmath/source/mathmlimport.cxx b/starmath/source/mathmlimport.cxx index b367b9943374..76b82a5d519b 100644 --- a/starmath/source/mathmlimport.cxx +++ b/starmath/source/mathmlimport.cxx @@ -71,6 +71,7 @@ one go*/ #include <smdll.hxx> #include <unomodel.hxx> #include <utility.hxx> +#include <visitors.hxx> using namespace ::com::sun::star::beans; using namespace ::com::sun::star::container; @@ -462,17 +463,13 @@ void SmXMLImport::endDocument() if (pModel) { - SmDocShell *pDocShell = - static_cast<SmDocShell*>(pModel->GetObjectShell()); + SmDocShell *pDocShell = static_cast<SmDocShell*>(pModel->GetObjectShell()); auto pTreeTmp = pTree.get(); pDocShell->SetFormulaTree(static_cast<SmTableNode *>(pTree.release())); if (aText.isEmpty()) //If we picked up no annotation text { - OUStringBuffer aStrBuf; // Get text from imported formula - pTreeTmp->CreateTextFromNode(aStrBuf); - aStrBuf.stripEnd(' '); - aText = aStrBuf.makeStringAndClear(); + SmNodeToTextVisitor tmpvisitor( pTreeTmp, aText ); } // Convert symbol names diff --git a/starmath/source/node.cxx b/starmath/source/node.cxx index 526b2e3ee010..e894ad84b6d8 100644 --- a/starmath/source/node.cxx +++ b/starmath/source/node.cxx @@ -140,7 +140,6 @@ void SmNode::SetFont(const SmFace &rFace) { if (!(Flags() & FontChangeMask::Face)) GetFont() = rFace; - ForEachNonNull(this, [&rFace](SmNode *pNode){pNode->SetFont(rFace);}); } @@ -244,27 +243,14 @@ void SmNode::Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell, int n ForEachNonNull(this, [&rFormat, &rDocShell, nDepth](SmNode *pNode){pNode->Prepare(rFormat, rDocShell, nDepth + 1);}); } -void SmNode::Move(const Point& rPosition) +void SmNode::Move(const Point& rVector) { - if (rPosition.X() == 0 && rPosition.Y() == 0) + if (rVector.X() == 0 && rVector.Y() == 0) return; - SmRect::Move(rPosition); + SmRect::Move(rVector); - ForEachNonNull(this, [&rPosition](SmNode *pNode){pNode->Move(rPosition);}); -} - -void SmNode::CreateTextFromNode(OUStringBuffer &rText) -{ - auto nSize = GetNumSubNodes(); - if (nSize > 1) - rText.append("{"); - ForEachNonNull(this, [&rText](SmNode *pNode){pNode->CreateTextFromNode(rText);}); - if (nSize > 1) - { - rText.stripEnd(' '); - rText.append("} "); - } + ForEachNonNull(this, [&rVector](SmNode *pNode){pNode->Move(rVector);}); } void SmNode::AdaptToX(OutputDevice &/*rDev*/, sal_uLong /*nWidth*/) @@ -441,6 +427,31 @@ void SmStructureNode::ClaimPaternity() ForEachNonNull(this, [this](SmNode *pNode){pNode->SetParent(this);}); } +int SmStructureNode::IndexOfSubNode(SmNode const * pSubNode) +{ + size_t nSize = GetNumSubNodes(); + for (size_t i = 0; i < nSize; i++) + if (pSubNode == GetSubNode(i)) + return i; + return -1; +} + +void SmStructureNode::SetSubNode(size_t nIndex, SmNode* pNode) +{ + size_t size = maSubNodes.size(); + if (size <= nIndex) + { + //Resize subnodes array + maSubNodes.resize(nIndex + 1); + //Set new slots to NULL except at nIndex + for (size_t i = size; i < nIndex; i++) + maSubNodes[i] = nullptr; + } + maSubNodes[nIndex] = pNode; + if (pNode) + pNode->SetParent(this); +} + bool SmVisibleNode::IsVisible() const { return true; @@ -461,32 +472,6 @@ void SmGraphicNode::GetAccessibleText( OUStringBuffer &rText ) const rText.append(GetToken().aText); } -void SmExpressionNode::CreateTextFromNode(OUStringBuffer &rText) -{ - size_t nSize = GetNumSubNodes(); - if (nSize > 1) - rText.append("{"); - for (size_t i = 0; i < nSize; ++i) - { - SmNode *pNode = GetSubNode(i); - if (pNode) - { - pNode->CreateTextFromNode(rText); - //Just a bit of foo to make unary +asd -asd +-asd -+asd look nice - if (pNode->GetType() == SmNodeType::Math) - if ((nSize != 2) || rText.isEmpty() || - (rText[rText.getLength() - 1] != '+' && rText[rText.getLength() - 1] != '-') ) - rText.append(" "); - } - } - - if (nSize > 1) - { - rText.stripEnd(' '); - rText.append("} "); - } -} - void SmTableNode::Arrange(OutputDevice &rDev, const SmFormat &rFormat) // arranges all subnodes in one column { @@ -760,27 +745,6 @@ void SmRootNode::Arrange(OutputDevice &rDev, const SmFormat &rFormat) ExtendBy(*pExtra, RectCopyMBL::This, true); } - -void SmRootNode::CreateTextFromNode(OUStringBuffer &rText) -{ - SmNode *pExtra = GetSubNode(0); - if (pExtra) - { - rText.append("nroot "); - pExtra->CreateTextFromNode(rText); - } - else - rText.append("sqrt "); - - if (!pExtra && GetSubNode(2)->GetNumSubNodes() > 1) - rText.append("{ "); - - GetSubNode(2)->CreateTextFromNode(rText); - - if (!pExtra && GetSubNode(2)->GetNumSubNodes() > 1) - rText.append("} "); -} - /**************************************************************************/ @@ -880,15 +844,6 @@ void SmBinVerNode::Arrange(OutputDevice &rDev, const SmFormat &rFormat) ExtendBy(*pDenom, RectCopyMBL::None).ExtendBy(*pLine, RectCopyMBL::None, pLine->GetCenterY()); } -void SmBinVerNode::CreateTextFromNode(OUStringBuffer &rText) -{ - SmNode *pNum = GetSubNode(0), - *pDenom = GetSubNode(2); - pNum->CreateTextFromNode(rText); - rText.append("over "); - pDenom->CreateTextFromNode(rText); -} - const SmNode * SmBinVerNode::GetLeftMost() const { return this; @@ -1256,100 +1211,8 @@ void SmSubSupNode::Arrange(OutputDevice &rDev, const SmFormat &rFormat) } } -void SmSubSupNode::CreateTextFromNode(OUStringBuffer &rText) -{ - SmNode *pNode; - GetSubNode(0)->CreateTextFromNode(rText); - - if (nullptr != (pNode = GetSubNode(LSUB+1))) - { - rText.append("lsub "); - pNode->CreateTextFromNode(rText); - } - if (nullptr != (pNode = GetSubNode(LSUP+1))) - { - rText.append("lsup "); - pNode->CreateTextFromNode(rText); - } - if (nullptr != (pNode = GetSubNode(CSUB+1))) - { - rText.append("csub "); - pNode->CreateTextFromNode(rText); - } - if (nullptr != (pNode = GetSubNode(CSUP+1))) - { - rText.append("csup "); - pNode->CreateTextFromNode(rText); - } - if (nullptr != (pNode = GetSubNode(RSUB+1))) - { - rText.stripEnd(' '); - rText.append("_"); - pNode->CreateTextFromNode(rText); - } - if (nullptr != (pNode = GetSubNode(RSUP+1))) - { - rText.stripEnd(' '); - rText.append("^"); - pNode->CreateTextFromNode(rText); - } -} - - /**************************************************************************/ -void SmBraceNode::CreateTextFromNode(OUStringBuffer &rText) -{ - if (GetScaleMode() == SmScaleMode::Height) - rText.append("left "); - { - OUStringBuffer aStrBuf; - OpeningBrace()->CreateTextFromNode(aStrBuf); - OUString aStr = aStrBuf.makeStringAndClear(); - aStr = comphelper::string::strip(aStr, ' '); - aStr = comphelper::string::stripStart(aStr, '\\'); - if (!aStr.isEmpty()) - { - if (aStr == "divides") - rText.append("lline"); - else if (aStr == "parallel") - rText.append("ldline"); - else if (aStr == "<") - rText.append("langle"); - else - rText.append(aStr); - rText.append(" "); - } - else - rText.append("none "); - } - Body()->CreateTextFromNode(rText); - if (GetScaleMode() == SmScaleMode::Height) - rText.append("right "); - { - OUStringBuffer aStrBuf; - ClosingBrace()->CreateTextFromNode(aStrBuf); - OUString aStr = aStrBuf.makeStringAndClear(); - aStr = comphelper::string::strip(aStr, ' '); - aStr = comphelper::string::stripStart(aStr, '\\'); - if (!aStr.isEmpty()) - { - if (aStr == "divides") - rText.append("rline"); - else if (aStr == "parallel") - rText.append("rdline"); - else if (aStr == ">") - rText.append("rangle"); - else - rText.append(aStr); - rText.append(" "); - } - else - rText.append("none "); - } - rText.append(" "); -} - void SmBraceNode::Arrange(OutputDevice &rDev, const SmFormat &rFormat) { SmNode *pLeft = OpeningBrace(), @@ -1716,144 +1579,6 @@ void SmAttributNode::Arrange(OutputDevice &rDev, const SmFormat &rFormat) ExtendBy(*pAttr, RectCopyMBL::This, true); } -void SmFontNode::CreateTextFromNode(OUStringBuffer &rText) -{ - rText.append("{"); - sal_Int32 nc,r,g,b; - - switch (GetToken().eType) - { - case TBOLD: - rText.append("bold "); - break; - case TNBOLD: - rText.append("nbold "); - break; - case TITALIC: - rText.append("italic "); - break; - case TNITALIC: - rText.append("nitalic "); - break; - case TPHANTOM: - rText.append("phantom "); - break; - case TSIZE: - { - rText.append("size "); - switch (meSizeType) - { - case FontSizeType::PLUS: - rText.append("+"); - break; - case FontSizeType::MINUS: - rText.append("-"); - break; - case FontSizeType::MULTIPLY: - rText.append("*"); - break; - case FontSizeType::DIVIDE: - rText.append("/"); - break; - case FontSizeType::ABSOLUT: - default: - break; - } - rText.append(::rtl::math::doubleToUString( - static_cast<double>(maFontSize), - rtl_math_StringFormat_Automatic, - rtl_math_DecimalPlaces_Max, '.', true)); - rText.append(" "); - } - break; - case TBLACK: - rText.append("color black "); - break; - case TWHITE: - rText.append("color white "); - break; - case TRED: - rText.append("color red "); - break; - case TGREEN: - rText.append("color green "); - break; - case TBLUE: - rText.append("color blue "); - break; - case TCYAN: - rText.append("color cyan "); - break; - case TMAGENTA: - rText.append("color magenta "); - break; - case TYELLOW: - rText.append("color yellow "); - break; - case TTEAL: - rText.append("color teal "); - break; - case TSILVER: - rText.append("color silver "); - break; - case TGRAY: - rText.append("color gray "); - break; - case TMAROON: - rText.append("color maroon "); - break; - case TPURPLE: - rText.append("color purple "); - break; - case TLIME: - rText.append("color lime "); - break; - case TOLIVE: - rText.append("color olive "); - break; - case TNAVY: - rText.append("color navy "); - break; - case TAQUA: - rText.append("color aqua "); - break; - case TFUCHSIA: - rText.append("color fuchsia "); - break; - case TRGB: - rText.append("color rgb "); - nc = GetToken().aText.toInt32(); - b = nc % 256; - nc /= 256; - g = nc % 256; - nc /= 256; - r = nc % 256; - rText.append(r); - rText.append(" "); - rText.append(g); - rText.append(" "); - rText.append(b); - rText.append(" "); - break; - case TSANS: - rText.append("font sans "); - break; - case TSERIF: - rText.append("font serif "); - break; - case TFIXED: - rText.append("font fixed "); - break; - default: - break; - } - if (GetNumSubNodes() > 1) - GetSubNode(1)->CreateTextFromNode(rText); - - rText.stripEnd(' '); - rText.append("} "); -} - void SmFontNode::Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell, int nDepth) { //! prepare subnodes first @@ -1883,7 +1608,7 @@ void SmFontNode::Arrange(OutputDevice &rDev, const SmFormat &rFormat) SmNode *pNode = GetSubNode(1); assert(pNode); sal_Int32 nc; - Color col_perso_rgb_color (0); + Color col_perso_rgb_color = COL_AUTO; switch (GetToken().eType) { case TSIZE : @@ -1902,23 +1627,23 @@ void SmFontNode::Arrange(OutputDevice &rDev, const SmFormat &rFormat) case TNBOLD : ClearAttribut(FontAttribute::Bold); break; case TNITALIC : ClearAttribut(FontAttribute::Italic); break; - case TBLACK : SetColor(COL_BLACK); break; - case TWHITE : SetColor(COL_WHITE); break; + case TBLACK : SetColor(COL_BLACK); break; + case TWHITE : SetColor(COL_WHITE); break; case TRED : SetColor(COL_LIGHTRED); break; - case TGREEN : SetColor(COL_GREEN); break; + case TGREEN : SetColor(COL_GREEN); break; case TBLUE : SetColor(COL_LIGHTBLUE); break; case TCYAN : SetColor(COL_LIGHTCYAN); break; // as in Calc case TMAGENTA : SetColor(COL_LIGHTMAGENTA); break; // as in Calc - case TYELLOW : SetColor(COL_YELLOW); break; - case TTEAL : SetColor(COL_CYAN); break; - case TSILVER : SetColor(COL_LIGHTGRAY); break; - case TGRAY : SetColor(COL_GRAY); break; - case TMAROON : SetColor(COL_RED); break; - case TPURPLE : SetColor(COL_MAGENTA); break; - case TLIME : SetColor(COL_LIGHTGREEN); break; - case TOLIVE : SetColor(COL_BROWN); break; - case TNAVY : SetColor(COL_BLUE); break; - case TAQUA : SetColor(COL_LIGHTCYAN); break; + case TYELLOW : SetColor(COL_YELLOW); break; + case TTEAL : SetColor(COL_CYAN); break; + case TSILVER : SetColor(COL_LIGHTGRAY); break; + case TGRAY : SetColor(COL_GRAY); break; + case TMAROON : SetColor(COL_RED); break; + case TPURPLE : SetColor(COL_MAGENTA); break; + case TLIME : SetColor(COL_LIGHTGREEN); break; + case TOLIVE : SetColor(COL_BROWN); break; + case TNAVY : SetColor(COL_BLUE); break; + case TAQUA : SetColor(COL_LIGHTCYAN); break; case TFUCHSIA : SetColor(COL_LIGHTMAGENTA); break; case TRGB : nc = GetToken().aText.toInt32(); @@ -1939,14 +1664,6 @@ void SmFontNode::Arrange(OutputDevice &rDev, const SmFormat &rFormat) SmRect::operator = (pNode->GetRect()); } - -void SmFontNode::SetSizeParameter(const Fraction& rValue, FontSizeType eType) -{ - meSizeType = eType; - maFontSize = rValue; -} - - /**************************************************************************/ @@ -2085,6 +1802,12 @@ SmTextNode::SmTextNode( const SmToken &rNodeToken, sal_uInt16 nFontDescP ) { } +void SmTextNode::ChangeText(const OUString &rText) { + maText = rText; + GetToken().aText = rText; + AdjustFontDesc(); +} + void SmTextNode::Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell, int nDepth) { SmNode::Prepare(rFormat, rDocShell, nDepth); @@ -2125,52 +1848,6 @@ void SmTextNode::Arrange(OutputDevice &rDev, const SmFormat &rFormat) SmRect::operator = (SmRect(aTmpDev, &rFormat, maText, GetFont().GetBorderWidth())); } -void SmTextNode::CreateTextFromNode(OUStringBuffer &rText) -{ - bool bQuoted=false; - if (GetToken().eType == TTEXT) - { - rText.append("\""); - bQuoted=true; - } - else - { - SmParser aParseTest; - auto pTable = aParseTest.Parse(GetToken().aText); - assert(pTable->GetType() == SmNodeType::Table); - bQuoted=true; - if (pTable->GetNumSubNodes() == 1) - { - SmNode *pResult = pTable->GetSubNode(0); - if ( (pResult->GetType() == SmNodeType::Line) && - (pResult->GetNumSubNodes() == 1) ) - { - pResult = pResult->GetSubNode(0); - if (pResult->GetType() == SmNodeType::Text) - bQuoted=false; - } - } - - if ((GetToken().eType == TIDENT) && (GetFontDesc() == FNT_FUNCTION)) - { - //Search for existing functions and remove extraneous keyword - rText.append("func "); - } - else if (bQuoted) - rText.append("italic "); - - if (bQuoted) - rText.append("\""); - - } - - rText.append(GetToken().aText); - - if (bQuoted) - rText.append("\""); - rText.append(" "); -} - void SmTextNode::GetAccessibleText( OUStringBuffer &rText ) const { rText.append(maText); @@ -2183,27 +1860,23 @@ void SmTextNode::AdjustFontDesc() else if(GetToken().eType == TFUNC) mnFontDesc = FNT_FUNCTION; else { - SmTokenType nTok; const SmTokenTableEntry *pEntry = SmParser::GetTokenTableEntry( maText ); if (pEntry && pEntry->nGroup == TG::Function) { - nTok = pEntry->eType; + GetToken().eType = pEntry->eType; mnFontDesc = FNT_FUNCTION; } else { sal_Unicode firstChar = maText[0]; if( ('0' <= firstChar && firstChar <= '9') || firstChar == '.' || firstChar == ',') { mnFontDesc = FNT_NUMBER; - nTok = TNUMBER; + GetToken().eType = TNUMBER; } else if (maText.getLength() > 1) { mnFontDesc = FNT_VARIABLE; - nTok = TIDENT; + GetToken().eType = TIDENT; } else { mnFontDesc = FNT_VARIABLE; - nTok = TCHARACTER; + GetToken().eType = TCHARACTER; } } - SmToken tok = GetToken(); - tok.eType = nTok; - SetToken(tok); } } @@ -2242,26 +1915,6 @@ sal_Unicode SmTextNode::ConvertSymbolToUnicode(sal_Unicode nIn) /**************************************************************************/ -void SmMatrixNode::CreateTextFromNode(OUStringBuffer &rText) -{ - rText.append("matrix {"); - for (size_t i = 0; i < mnNumRows; ++i) - { - for (size_t j = 0; j < mnNumCols; ++j) - { - SmNode *pNode = GetSubNode(i * mnNumCols + j); - if (pNode) - pNode->CreateTextFromNode(rText); - if (j != mnNumCols - 1U) - rText.append("# "); - } - if (i != mnNumRows - 1U) - rText.append("## "); - } - rText.stripEnd(' '); - rText.append("} "); -} - void SmMatrixNode::Arrange(OutputDevice &rDev, const SmFormat &rFormat) { SmNode *pNode; @@ -2360,14 +2013,6 @@ void SmMatrixNode::Arrange(OutputDevice &rDev, const SmFormat &rFormat) } } - -void SmMatrixNode::SetRowCol(sal_uInt16 nMatrixRows, sal_uInt16 nMatrixCols) -{ - mnNumRows = nMatrixRows; - mnNumCols = nMatrixCols; -} - - const SmNode * SmMatrixNode::GetLeftMost() const { return this; @@ -2481,124 +2126,6 @@ void SmMathSymbolNode::Arrange(OutputDevice &rDev, const SmFormat &rFormat) SmRect::operator = (SmRect(aTmpDev, &rFormat, rText, GetFont().GetBorderWidth())); } -void SmMathSymbolNode::CreateTextFromNode(OUStringBuffer &rText) -{ - sal_Unicode cChar = GetToken().cMathChar; - if (cChar == MS_INT && GetScaleMode() == SmScaleMode::Height) - rText.append("intd "); - else - MathType::LookupChar(cChar, rText, 3); -} - -void SmRectangleNode::CreateTextFromNode(OUStringBuffer &rText) -{ - switch (GetToken().eType) - { - case TUNDERLINE: - rText.append("underline "); - break; - case TOVERLINE: - rText.append("overline "); - break; - case TOVERSTRIKE: - rText.append("overstrike "); - break; - default: - break; - } -} - -void SmAttributNode::CreateTextFromNode(OUStringBuffer &rText) -{ - SmNode *pNode; - assert(GetNumSubNodes() == 2); - rText.append("{"); - sal_Unicode nLast=0; - if (nullptr != (pNode = Attribute())) - { - OUStringBuffer aStr; - pNode->CreateTextFromNode(aStr); - if (aStr.getLength() > 1) - rText.append(aStr); - else - { - nLast = aStr[0]; - switch (nLast) - { - case MS_BAR: // MACRON - rText.append("overline "); - break; - case MS_DOT: // DOT ABOVE - rText.append("dot "); - break; - case 0x2dc: // SMALL TILDE - rText.append("widetilde "); - break; - case MS_DDOT: // DIAERESIS - rText.append("ddot "); - break; - case 0xE082: - break; - case 0xE09B: - case MS_DDDOT: // COMBINING THREE DOTS ABOVE - rText.append("dddot "); - break; - case MS_ACUTE: // ACUTE ACCENT - case MS_COMBACUTE: // COMBINING ACUTE ACCENT - rText.append("acute "); - break; - case MS_GRAVE: // GRAVE ACCENT - case MS_COMBGRAVE: // COMBINING GRAVE ACCENT - rText.append("grave "); - break; - case MS_CHECK: // CARON - case MS_COMBCHECK: // COMBINING CARON - rText.append("check "); - break; - case MS_BREVE: // BREVE - case MS_COMBBREVE: // COMBINING BREVE - rText.append("breve "); - break; - case MS_CIRCLE: // RING ABOVE - case MS_COMBCIRCLE: // COMBINING RING ABOVE - rText.append("circle "); - break; - case MS_RIGHTARROW: // RIGHTWARDS ARROW - case MS_VEC: // COMBINING RIGHT ARROW ABOVE - rText.append("vec "); - break; - case MS_HARPOON: // COMBINING RIGHT HARPOON ABOVE - rText.append("harpoon "); - break; - case MS_TILDE: // TILDE - case MS_COMBTILDE: // COMBINING TILDE - rText.append("tilde "); - break; - case MS_HAT: // CIRCUMFLEX ACCENT - case MS_COMBHAT: // COMBINING CIRCUMFLEX ACCENT - rText.append("hat "); - break; - case MS_COMBBAR: // COMBINING MACRON - rText.append("bar "); - break; - default: - rText.append(OUStringChar(nLast)); - break; - } - } - } - - if (nullptr != (pNode = Body())) - pNode->CreateTextFromNode(rText); - - rText.stripEnd(' '); - - if (nLast == 0xE082) - rText.append(" overbrace {}"); - - rText.append("} "); -} - /**************************************************************************/ static bool lcl_IsFromGreekSymbolSet( const OUString &rTokenText ) @@ -2812,20 +2339,6 @@ void SmBlankNode::Arrange(OutputDevice &rDev, const SmFormat &rFormat) SetWidth(nSpace); } -void SmBlankNode::CreateTextFromNode(OUStringBuffer &rText) -{ - if (mnNum <= 0) - return; - sal_uInt16 nWide = mnNum / 4; - sal_uInt16 nNarrow = mnNum % 4; - for (sal_uInt16 i = 0; i < nWide; i++) - rText.append("~"); - for (sal_uInt16 i = 0; i < nNarrow; i++) - rText.append("`"); - rText.append(" "); -} - - /**************************************************************************/ //Implementation of all accept methods for SmVisitor diff --git a/starmath/source/parse.cxx b/starmath/source/parse.cxx index a51d65fbbc94..e931c494b649 100644 --- a/starmath/source/parse.cxx +++ b/starmath/source/parse.cxx @@ -1681,8 +1681,8 @@ std::unique_ptr<SmNode> SmParser::DoOper() case TOPER : NextToken(); - OSL_ENSURE(m_aCurToken.eType == TSPECIAL, "Sm: wrong token"); + m_aCurToken.eType = TOPER; pNode.reset(new SmGlyphSpecialNode(m_aCurToken)); break; @@ -2176,6 +2176,7 @@ std::unique_ptr<SmTextNode> SmParser::DoFunction() { case TFUNC: NextToken(); // skip "FUNC"-statement + m_aCurToken.eType = TFUNC; [[fallthrough]]; case TSIN : diff --git a/starmath/source/visitors.cxx b/starmath/source/visitors.cxx index 5362551fe5f8..f663dcfb2d27 100644 --- a/starmath/source/visitors.cxx +++ b/starmath/source/visitors.cxx @@ -15,6 +15,7 @@ #include "tmpdevice.hxx" #include <cursor.hxx> #include <cassert> +#include "mathtype.hxx" // SmDefaultingVisitor @@ -1918,6 +1919,7 @@ void SmSelectionDrawingVisitor::Visit( SmTextNode* pNode ) SmNodeToTextVisitor::SmNodeToTextVisitor( SmNode* pNode, OUString &rText ) { pNode->Accept( this ); + maCmdText.stripEnd(' '); rText = maCmdText.makeStringAndClear(); } ... etc. - the rest is truncated _______________________________________________ Libreoffice-commits mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/libreoffice-commits
