Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

31 files changed, 6662 insertions, 0 deletions

diff --git a/starmath/inc/AccessibleSmElement.hxx b/starmath/inc/AccessibleSmElement.hxx
new file mode 100644
index 000000000..202de6690
--- /dev/null
+++ b/starmath/inc/AccessibleSmElement.hxx
@@ -0,0 +1,105 @@
+/* -*- 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 .
+ */
+#ifndef INCLUDED_STARMATH_INC_ACCESSIBLESMELEMENT_HXX
+#define INCLUDED_STARMATH_INC_ACCESSIBLESMELEMENT_HXX
+
+#include <com/sun/star/accessibility/XAccessible.hpp>
+#include <com/sun/star/accessibility/XAccessibleAction.hpp>
+#include <com/sun/star/accessibility/XAccessibleComponent.hpp>
+#include <com/sun/star/accessibility/XAccessibleContext.hpp>
+#include <com/sun/star/accessibility/XAccessibleStateSet.hpp>
+#include <com/sun/star/awt/Rectangle.hpp>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <cppuhelper/implbase3.hxx>
+#include <comphelper/accessiblecomponenthelper.hxx>
+#include <sal/types.h>
+#include <vcl/vclptr.hxx>
+
+class SmElementsControl;
+
+typedef ::cppu::ImplHelper3<css::lang::XServiceInfo, css::accessibility::XAccessible,
+                            css::accessibility::XAccessibleAction>
+    AccessibleSmElement_BASE;
+
+class AccessibleSmElement final : public comphelper::OAccessibleComponentHelper,
+                                  public AccessibleSmElement_BASE
+{
+    SmElementsControl* m_pSmElementsControl;
+    const sal_Int32 m_nIndexInParent; ///< index in the parent XAccessible
+    const sal_uInt16 m_nItemId; ///< index in the SmElementsControl
+    bool m_bHasFocus;
+    sal_Int16 m_nRole;
+
+    ~AccessibleSmElement() override;
+    void SAL_CALL disposing() override;
+    css::awt::Rectangle implGetBounds() override;
+
+    void testAction(sal_Int32) const;
+
+public:
+    explicit AccessibleSmElement(SmElementsControl* pSmElementsControl, sal_uInt16 nItemId,
+                                 sal_Int32 nIndexInParent);
+
+    void SetFocus(bool _bFocus);
+    sal_uInt16 itemId() const { return m_nItemId; }
+
+    DECLARE_XINTERFACE()
+    DECLARE_XTYPEPROVIDER()
+
+    // XAccessible
+    css::uno::Reference<css::accessibility::XAccessibleContext>
+        SAL_CALL getAccessibleContext() override;
+
+    // XServiceInfo
+    OUString SAL_CALL getImplementationName() override;
+    sal_Bool SAL_CALL supportsService(const OUString& rServiceName) override;
+    css::uno::Sequence<OUString> SAL_CALL getSupportedServiceNames() override;
+
+    // XAccessibleContext
+    sal_Int32 SAL_CALL getAccessibleChildCount() override;
+    css::uno::Reference<css::accessibility::XAccessible>
+        SAL_CALL getAccessibleChild(sal_Int32 i) override;
+    css::uno::Reference<css::accessibility::XAccessible> SAL_CALL getAccessibleParent() override;
+    sal_Int32 SAL_CALL getAccessibleIndexInParent() override;
+    sal_Int16 SAL_CALL getAccessibleRole() override;
+    OUString SAL_CALL getAccessibleDescription() override;
+    OUString SAL_CALL getAccessibleName() override;
+    css::uno::Reference<css::accessibility::XAccessibleRelationSet>
+        SAL_CALL getAccessibleRelationSet() override;
+    css::uno::Reference<css::accessibility::XAccessibleStateSet>
+        SAL_CALL getAccessibleStateSet() override;
+
+    // XAccessibleComponent
+    css::uno::Reference<css::accessibility::XAccessible>
+        SAL_CALL getAccessibleAtPoint(const css::awt::Point& aPoint) override;
+    void SAL_CALL grabFocus() override;
+    sal_Int32 SAL_CALL getForeground() override;
+    sal_Int32 SAL_CALL getBackground() override;
+
+    // XAccessibleAction
+    sal_Int32 SAL_CALL getAccessibleActionCount() override;
+    sal_Bool SAL_CALL doAccessibleAction(sal_Int32 nIndex) override;
+    OUString SAL_CALL getAccessibleActionDescription(sal_Int32 nIndex) override;
+    css::uno::Reference<css::accessibility::XAccessibleKeyBinding>
+        SAL_CALL getAccessibleActionKeyBinding(sal_Int32 nIndex) override;
+};
+
+#endif // INCLUDED_STARMATH_INC_ACCESSIBLESMELEMENT_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/starmath/inc/AccessibleSmElementsControl.hxx b/starmath/inc/AccessibleSmElementsControl.hxx
new file mode 100644
index 000000000..66cbd80bc
--- /dev/null
+++ b/starmath/inc/AccessibleSmElementsControl.hxx
@@ -0,0 +1,108 @@
+/* -*- 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 .
+ */
+#ifndef INCLUDED_STARMATH_INC_ACCESSIBLESMELEMENTSCONTROL_HXX
+#define INCLUDED_STARMATH_INC_ACCESSIBLESMELEMENTSCONTROL_HXX
+
+#include <comphelper/accessiblecomponenthelper.hxx>
+#include <com/sun/star/accessibility/XAccessibleSelection.hpp>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <cppuhelper/implbase3.hxx>
+#include <vcl/vclptr.hxx>
+
+#include <vector>
+
+class AccessibleSmElement;
+class SmElementsControl;
+
+typedef ::cppu::ImplHelper3<css::lang::XServiceInfo, css::accessibility::XAccessible,
+                            css::accessibility::XAccessibleSelection>
+    AccessibleSmElementsControl_BASE;
+
+class AccessibleSmElementsControl final : public comphelper::OAccessibleComponentHelper,
+                                          public AccessibleSmElementsControl_BASE
+{
+    std::vector<rtl::Reference<AccessibleSmElement>> m_aAccessibleChildren;
+    SmElementsControl* m_pControl;
+
+    void UpdateFocus(sal_uInt16);
+    inline void TestControl();
+
+    ~AccessibleSmElementsControl() override;
+    void SAL_CALL disposing() override;
+    css::awt::Rectangle implGetBounds() override;
+
+public:
+    AccessibleSmElementsControl(SmElementsControl& rControl);
+
+    void ReleaseAllItems();
+    void AddAllItems();
+    inline void AcquireFocus();
+    inline void ReleaseFocus(sal_uInt16);
+
+    DECLARE_XINTERFACE()
+    DECLARE_XTYPEPROVIDER()
+
+    // XAccessible
+    css::uno::Reference<css::accessibility::XAccessibleContext>
+        SAL_CALL getAccessibleContext() override;
+
+    // XServiceInfo
+    OUString SAL_CALL getImplementationName() override;
+    sal_Bool SAL_CALL supportsService(const OUString& ServiceName) override;
+    css::uno::Sequence<OUString> SAL_CALL getSupportedServiceNames() override;
+
+    // XAccessibleComponent
+    sal_Bool SAL_CALL containsPoint(const css::awt::Point& aPoint) override;
+    css::uno::Reference<css::accessibility::XAccessible>
+        SAL_CALL getAccessibleAtPoint(const css::awt::Point& aPoint) override;
+    void SAL_CALL grabFocus() override;
+    sal_Int32 SAL_CALL getForeground() override;
+    sal_Int32 SAL_CALL getBackground() override;
+
+    // XAccessibleContext
+    sal_Int32 SAL_CALL getAccessibleChildCount() override;
+    css::uno::Reference<css::accessibility::XAccessible>
+        SAL_CALL getAccessibleChild(sal_Int32 i) override;
+    css::uno::Reference<css::accessibility::XAccessible> SAL_CALL getAccessibleParent() override;
+    sal_Int16 SAL_CALL getAccessibleRole() override;
+    OUString SAL_CALL getAccessibleDescription() override;
+    OUString SAL_CALL getAccessibleName() override;
+    css::uno::Reference<css::accessibility::XAccessibleRelationSet>
+        SAL_CALL getAccessibleRelationSet() override;
+    css::uno::Reference<css::accessibility::XAccessibleStateSet>
+        SAL_CALL getAccessibleStateSet() override;
+
+    // XAccessibleSelection
+    void SAL_CALL selectAccessibleChild(sal_Int32 nChildIndex) override;
+    sal_Bool SAL_CALL isAccessibleChildSelected(sal_Int32 nChildIndex) override;
+    void SAL_CALL clearAccessibleSelection() override;
+    void SAL_CALL selectAllAccessibleChildren() override;
+    sal_Int32 SAL_CALL getSelectedAccessibleChildCount() override;
+    css::uno::Reference<css::accessibility::XAccessible>
+        SAL_CALL getSelectedAccessibleChild(sal_Int32 nSelectedChildIndex) override;
+    void SAL_CALL deselectAccessibleChild(sal_Int32 nChildIndex) override;
+};
+
+void AccessibleSmElementsControl::AcquireFocus() { UpdateFocus(SAL_MAX_UINT16); }
+
+void AccessibleSmElementsControl::ReleaseFocus(sal_uInt16 nPos) { UpdateFocus(nPos); }
+
+#endif // INCLUDED_STARMATH_INC_ACCESSIBLESMELEMENTSCONTROL_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/starmath/inc/ElementsDockingWindow.hxx b/starmath/inc/ElementsDockingWindow.hxx
new file mode 100644
index 000000000..e10273b88
--- /dev/null
+++ b/starmath/inc/ElementsDockingWindow.hxx
@@ -0,0 +1,199 @@
+/* -*- 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 .
+ */
+
+#ifndef INCLUDED_STARMATH_INC_ELEMENTSDOCKINGWINDOW_HXX
+#define INCLUDED_STARMATH_INC_ELEMENTSDOCKINGWINDOW_HXX
+
+#include <sfx2/dockwin.hxx>
+#include <vcl/customweld.hxx>
+#include <vcl/weld.hxx>
+
+#include "format.hxx"
+#include <memory>
+#include <tuple>
+
+#include "AccessibleSmElementsControl.hxx"
+
+class SmDocShell;
+class SmNode;
+class SmParser;
+
+class SmElement
+{
+    std::unique_ptr<SmNode> mpNode;
+    OUString                maText;
+    OUString                maHelpText;
+
+public:
+    Point mBoxLocation;
+    Size  mBoxSize;
+
+    SmElement(std::unique_ptr<SmNode>&& pNode, const OUString& aText, const OUString& aHelpText);
+    virtual ~SmElement();
+
+    const std::unique_ptr<SmNode>& getNode() const;
+    const OUString& getText() const { return maText; }
+    const OUString& getHelpText() const { return maHelpText; }
+
+    virtual bool isSeparator() const { return false; }
+};
+
+class SmElementSeparator final : public SmElement
+{
+public:
+    SmElementSeparator();
+
+    bool isSeparator() const override { return true; }
+};
+
+typedef std::pair<const char*, const char*> SmElementDescr;
+
+class SmElementsControl : public weld::CustomWidgetController
+{
+    friend class ElementSelectorUIObject;
+    friend class ElementUIObject;
+
+    static const SmElementDescr m_aUnaryBinaryOperatorsList[];
+    static const SmElementDescr m_aRelationsList[];
+    static const SmElementDescr m_aSetOperationsList[];
+    static const SmElementDescr m_aFunctionsList[];
+    static const SmElementDescr m_aOperatorsList[];
+    static const SmElementDescr m_aAttributesList[];
+    static const SmElementDescr m_aBracketsList[];
+    static const SmElementDescr m_aFormatsList[];
+    static const SmElementDescr m_aOthersList[];
+    static const SmElementDescr m_aExamplesList[];
+    static const std::tuple<const char*, const SmElementDescr*, size_t> m_aCategories[];
+    static const size_t m_aCategoriesSize;
+
+    virtual void Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle&) override;
+    virtual bool MouseButtonDown(const MouseEvent& rMEvt) override;
+    virtual bool MouseMove(const MouseEvent& rMEvt) override;
+    virtual OUString RequestHelp(tools::Rectangle& rRect) override;
+    virtual void Resize() override;
+    virtual void GetFocus() override;
+    virtual void LoseFocus() override;
+    virtual bool KeyInput(const KeyEvent& rKEvt) override;
+    css::uno::Reference<css::accessibility::XAccessible> CreateAccessible() override;
+
+    SmDocShell*   mpDocShell;
+    SmFormat      maFormat;
+    OString       msCurrentSetId;
+    sal_uInt16    m_nCurrentElement;
+    sal_uInt16    m_nCurrentRolloverElement;
+    sal_uInt16 m_nCurrentOffset;
+    Link<SmElement&,void> maSelectHdlLink;
+
+    std::vector< std::unique_ptr<SmElement> > maElementList;
+    Size          maMaxElementDimensions;
+    bool          mbVerticalMode;
+    std::unique_ptr<weld::ScrolledWindow> mxScroll;
+    bool m_bFirstPaintAfterLayout;
+    rtl::Reference<AccessibleSmElementsControl> m_xAccessible;
+
+    void addElement(SmParser &rParser, const OUString& aElementVisual, const OUString& aElementSource, const OUString& aHelpText);
+    void addElements(const SmElementDescr aElementsArray[], sal_uInt16 size);
+    SmElement* current() const;
+    void setCurrentElement(sal_uInt16);
+    bool hasRollover() const { return m_nCurrentRolloverElement != SAL_MAX_UINT16; }
+
+    void stepFocus(const bool bBackward);
+    void pageFocus(const bool bBackward);
+    // common code of page and step focus
+    inline void scrollToElement(const bool, const SmElement*);
+    inline sal_uInt16 nextElement(const bool, const sal_uInt16, const sal_uInt16);
+
+    void build();
+
+    //if bDraw is true, then draw, otherwise just layout
+    void LayoutOrPaintContents(vcl::RenderContext& rContext, bool bDraw);
+
+public:
+    explicit SmElementsControl(std::unique_ptr<weld::ScrolledWindow> xScrolledWindow);
+    virtual ~SmElementsControl() override;
+
+    static const auto& categories() { return m_aCategories; }
+    static size_t categoriesSize() { return m_aCategoriesSize; }
+    const OString& elementSetId() const { return msCurrentSetId; }
+    void setElementSetId(const char* pSetId);
+
+    void setVerticalMode(bool bVertical);
+
+    sal_uInt16 itemCount() const;
+    sal_uInt16 itemHighlighted() const;
+    sal_uInt16 itemAtPos(const Point& rPos) const;
+    tools::Rectangle itemPosRect(sal_uInt16) const;
+    bool itemIsSeparator(sal_uInt16) const;
+    bool itemIsVisible(sal_uInt16) const;
+    OUString itemName(sal_uInt16) const;
+    bool itemTrigger(sal_uInt16);
+    void setItemHighlighted(sal_uInt16);
+    sal_uInt16 itemOffset() const { return m_nCurrentOffset; }
+
+    virtual void SetDrawingArea(weld::DrawingArea* pDrawingArea) override;
+
+    DECL_LINK( ScrollHdl, weld::ScrolledWindow&, void );
+
+    void SetSelectHdl(const Link<SmElement&,void>& rLink) { maSelectHdlLink = rLink; }
+
+    rtl::Reference<AccessibleSmElementsControl> GetAccessible() const { return m_xAccessible; }
+    static Color GetTextColor();
+    static Color GetControlBackground();
+
+    virtual FactoryFunction GetUITestFactory() const override;
+};
+
+class SmElementsDockingWindow final : public SfxDockingWindow
+{
+    std::unique_ptr<SmElementsControl> mxElementsControl;
+    std::unique_ptr<weld::CustomWeld> mxElementsControlWin;
+    std::unique_ptr<weld::ComboBox> mxElementListBox;
+
+    virtual void Resize() override;
+    SmViewShell* GetView();
+
+    DECL_LINK(SelectClickHandler, SmElement&, void);
+    DECL_LINK(ElementSelectedHandle, weld::ComboBox&, void);
+
+public:
+
+    SmElementsDockingWindow( SfxBindings* pBindings,
+                             SfxChildWindow* pChildWindow,
+                             vcl::Window* pParent );
+    virtual ~SmElementsDockingWindow() override;
+    virtual void dispose() override;
+
+    virtual void EndDocking( const tools::Rectangle& rReactangle, bool bFloatMode) override;
+    virtual void ToggleFloatingMode() override;
+};
+
+class SmElementsDockingWindowWrapper final : public SfxChildWindow
+{
+    SFX_DECL_CHILDWINDOW_WITHID(SmElementsDockingWindowWrapper);
+
+    SmElementsDockingWindowWrapper( vcl::Window* pParentWindow,
+                                    sal_uInt16 nId,
+                                    SfxBindings* pBindings,
+                                    SfxChildWinInfo* pInfo );
+    virtual ~SmElementsDockingWindowWrapper() override;
+};
+
+#endif // INCLUDED_STARMATH_INC_ELEMENTSDOCKINGWINDOW_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/starmath/inc/action.hxx b/starmath/inc/action.hxx
new file mode 100644
index 000000000..cb4a4eddf
--- /dev/null
+++ b/starmath/inc/action.hxx
@@ -0,0 +1,45 @@
+/* -*- 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 .
+ */
+#ifndef INCLUDED_STARMATH_INC_ACTION_HXX
+#define INCLUDED_STARMATH_INC_ACTION_HXX
+
+#include <svl/undo.hxx>
+#include "format.hxx"
+
+class SmDocShell;
+
+
+class SmFormatAction final : public SfxUndoAction
+{
+    SmDocShell  *pDoc;
+    SmFormat    aOldFormat;
+    SmFormat    aNewFormat;
+
+public:
+    SmFormatAction(SmDocShell *pDocSh, const SmFormat& rOldFormat, const SmFormat& rNewFormat);
+
+    virtual void Undo() override;
+    virtual void Redo() override;
+    virtual void Repeat(SfxRepeatTarget& rDocSh) override;
+    virtual OUString GetComment() const override;
+};
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/starmath/inc/caret.hxx b/starmath/inc/caret.hxx
new file mode 100644
index 000000000..327ee1d6e
--- /dev/null
+++ b/starmath/inc/caret.hxx
@@ -0,0 +1,428 @@
+/* -*- 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/.
+ */
+#ifndef INCLUDED_STARMATH_INC_CARET_HXX
+#define INCLUDED_STARMATH_INC_CARET_HXX
+
+#include <sal/config.h>
+
+#include "node.hxx"
+
+#include <cassert>
+#include <memory>
+#include <vector>
+
+/** Representation of caret position with an equation */
+struct SmCaretPos{
+    SmCaretPos(SmNode* selectedNode = nullptr, int iIndex = 0)
+        : pSelectedNode(selectedNode)
+        , nIndex(iIndex)
+    {
+        assert(nIndex >= 0);
+    }
+
+    /** Selected node */
+    SmNode* pSelectedNode;
+
+    /** Index (invariant: non-negative) within the selected node
+     *
+     * 0: Position in front of a node
+     * 1: Position after a node or after first char in SmTextNode
+     * n: Position after n char in SmTextNode
+     *
+     * Notice how there's special cases for SmTextNode.
+     */
+    //TODO: Special cases for SmBlankNode is needed
+    //TODO: Consider forgetting about the todo above... As it's really unpleasant.
+    int nIndex;
+
+    /** True, if this is a valid caret position */
+    bool IsValid() const { return pSelectedNode != nullptr; }
+    bool operator==(const SmCaretPos &pos) const {
+        return pos.pSelectedNode == pSelectedNode && nIndex == pos.nIndex;
+    }
+    /** Get the caret position after pNode, regardless of pNode
+     *
+     * Gets the caret position following pNode, this is SmCaretPos(pNode, 1).
+     * Unless pNode is an instance of SmTextNode, then the index is the text length.
+     */
+    static SmCaretPos GetPosAfter(SmNode* pNode) {
+        if(pNode && pNode->GetType() == SmNodeType::Text)
+            return SmCaretPos(pNode, static_cast<SmTextNode*>(pNode)->GetText().getLength());
+        return SmCaretPos(pNode, 1);
+    }
+};
+
+/** A line that represents a caret */
+class SmCaretLine{
+public:
+    SmCaretLine(long left = 0, long top = 0, long height = 0) {
+        _top = top;
+        _left = left;
+        _height = height;
+    }
+    long GetTop() const {return _top;}
+    long GetLeft() const {return _left;}
+    long GetHeight() const {return _height;}
+    long SquaredDistanceX(const SmCaretLine& line) const{
+        return (GetLeft() - line.GetLeft()) * (GetLeft() - line.GetLeft());
+    }
+    long SquaredDistanceX(const Point &pos) const{
+        return (GetLeft() - pos.X()) * (GetLeft() - pos.X());
+    }
+    long SquaredDistanceY(const SmCaretLine& line) const{
+        long d = GetTop() - line.GetTop();
+        if(d < 0)
+            d = (d * -1) - GetHeight();
+        else
+            d = d - line.GetHeight();
+        if(d < 0)
+            return 0;
+        return d * d;
+    }
+    long SquaredDistanceY(const Point &pos) const{
+        long d = GetTop() - pos.Y();
+        if(d < 0)
+            d = (d * -1) - GetHeight();
+        if(d < 0)
+            return 0;
+        return d * d;
+    }
+private:
+    long _top;
+    long _left;
+    long _height;
+};
+
+// SmCaretPosGraph
+
+/** An entry in SmCaretPosGraph */
+struct SmCaretPosGraphEntry{
+    SmCaretPosGraphEntry(SmCaretPos pos,
+                         SmCaretPosGraphEntry* left,
+                         SmCaretPosGraphEntry* right) {
+        CaretPos = pos;
+        Left = left;
+        Right = right;
+    }
+    /** Caret position */
+    SmCaretPos CaretPos;
+    /** Entry to the left visually */
+    SmCaretPosGraphEntry* Left;
+    /** Entry to the right visually */
+    SmCaretPosGraphEntry* Right;
+    void SetRight(SmCaretPosGraphEntry* right){
+        Right = right;
+    }
+    void SetLeft(SmCaretPosGraphEntry* left){
+        Left = left;
+    }
+};
+
+/** A graph over all caret positions
+ * @remarks Graphs can only grow, entries cannot be removed!
+ */
+class SmCaretPosGraph{
+public:
+    SmCaretPosGraph();
+
+    ~SmCaretPosGraph();
+
+    /** Add a caret position
+     *  @remarks If left is NULL, they will point back to the entry.
+     */
+    SmCaretPosGraphEntry* Add(SmCaretPos pos,
+                            SmCaretPosGraphEntry* left = nullptr);
+
+    std::vector<std::unique_ptr<SmCaretPosGraphEntry>>::iterator begin()
+    {
+        return mvEntries.begin();
+    }
+
+    std::vector<std::unique_ptr<SmCaretPosGraphEntry>>::iterator end()
+    {
+        return mvEntries.end();
+    }
+
+private:
+    std::vector<std::unique_ptr<SmCaretPosGraphEntry>> mvEntries;
+};
+
+/** \page visual_formula_editing Visual Formula Editing
+ * A visual formula editor allows users to easily edit formulas without having to learn and
+ * use complicated commands. A visual formula editor is a WYSIWYG editor. For OpenOffice Math
+ * this essentially means that you can click on the formula image, to get a caret, which you
+ * can move with arrow keys, and use to modify the formula by entering text, clicking buttons
+ * or using shortcuts.
+ *
+ * \subsection formula_trees Formula Trees
+ * A formula in OpenOffice Math is a tree of nodes, take for instance the formula
+ * "A + {B cdot C} over D", it looks like this
+ * \f$ \mbox{A} + \frac{\mbox{B} \cdot \mbox{C}}{\mbox{D}} \f$. The tree for this formula
+ * looks like this:
+ *
+ * \dot
+ * digraph {
+ * labelloc = "t";
+ * label= "Equation: \"A  + {B  cdot C} over D\"";
+ * size = "9,9";
+ * n0 [label="SmTableNode (1)"];
+ * n0 -> n1 [label="0"];
+ * n1 [label="SmLineNode (2)"];
+ * n1 -> n2 [label="0"];
+ * n2 [label="SmExpressionNode (3)"];
+ * n2 -> n3 [label="0"];
+ * n3 [label="SmBinHorNode (4)"];
+ * n3 -> n4 [label="0"];
+ * n4 [label="SmTextNode: A (5)"];
+ * n3 -> n5 [label="1"];
+ * n5 [label="SmMathSymbolNode: + (6)"];
+ * n3 -> n6 [label="2"];
+ * n6 [label="SmBinVerNode (7)"];
+ * n6 -> n7 [label="0"];
+ * n7 [label="SmExpressionNode (8)"];
+ * n7 -> n8 [label="0"];
+ * n8 [label="SmBinHorNode (9)"];
+ * n8 -> n9 [label="0"];
+ * n9 [label="SmTextNode: B (10)"];
+ * n8 -> n10 [label="1"];
+ * n10 [label="SmMathSymbolNode: &#183; (11)"];
+ * n8 -> n11 [label="2"];
+ * n11 [label="SmTextNode: C (12)"];
+ * n6 -> n12 [label="1"];
+ * n12 [label="SmRectangleNode (13)"];
+ * n6 -> n13 [label="2"];
+ * n13 [label="SmTextNode: D (14)"];
+ * }
+ * \enddot
+ *
+ * The vertices are nodes, their label says what kind of node and the number in parentheses is
+ *  the identifier of the node (In practices a pointer is used instead of the id). The direction
+ *  of the edges tells which node is parent and which is child. The label of the edges are the
+ *  child node index number, given to SmNode::GetSubNode() of the parent to get the child node.
+ *
+ *
+ * \subsection visual_lines Visual Lines
+ *
+ * Inorder to do caret movement in visual lines, we need a definition of caret position and
+ * visual line. In a tree such as the above there are three visual lines. There's the outer most
+ * line, with entries such as
+ * \f$\mbox{A}\f$, \f$ + \f$ and \f$ \frac{\mbox{B} \cdot \mbox{C}}{\mbox{D}} \f$. Then there's
+ *  the numerator line of the fraction it has entries \f$ \mbox{B} \f$, \f$ \cdot \f$ and \f$ \mbox{C} \f$.
+ *  And last by not least there's the denominator line of the fraction it's only entry is \f$ \mbox{D} \f$.
+ *
+ * For visual editing it should be possible to place a caret on both sides of any line entry,
+ * consider a line entry a character or construction that in a line is treated as a character.
+ *  Imagine the caret is placed to the right of the plus sign (id: 6), now if user presses
+ * backspace this should delete the plus sign (id: 6), and if the user presses delete this
+ * should delete the entire fraction (id: 7). This is because the caret is in the outer most
+ * line where the fraction is considered a line entry.
+ *
+ * However, inorder to prevent users from accidentally deleting large subtrees, just because
+ * they logically placed there caret a in the wrong line, require that complex constructions
+ * such as a fraction is selected before it is deleted. Thus in this case it wouldn't be
+ * deleted, but only selected and then deleted if the user hit delete again. Anyway, this is
+ * slightly off topic for now.
+ *
+ * Important about visual lines is that they don't always have an SmExpressionNode as root
+ * and the entries in a visual line is all the nodes of a subtree ordered left to right that
+ *  isn't either an SmExpressionNode, SmBinHorNode or SmUnHorNode.
+ *
+ *
+ * \subsection caret_positions Caret Positions
+ *
+ * A caret position in OpenOffice Math is represented by an instance of SmCaretPos.
+ * That is a caret position is a node and an index related to this node. For most nodes the
+ * index 0, means caret is in front of this node, the index 1 means caret is after this node.
+ * For SmTextNode the index is the caret position after the specified number of characters,
+ * imagine an SmTextNode with the number 1337. The index 3 in such SmTextNode would mean a
+ * caret placed right before 7, e.g. "133|7".
+ *
+ * For SmExpressionNode, SmBinHorNode and SmUnHorNode the only legal index is 0, which means
+ * in front of the node. Actually the index 0 may only because for the first caret position
+ * in a visual line. From the example above, consider the following subtree that constitutes
+ * a visual line:
+ *
+ * \dot
+ * digraph {
+ * labelloc = "t";
+ * label= "Subtree that constitutes a visual line";
+ * size = "7,5";
+ * n7 [label="SmExpressionNode (8)"];
+ * n7 -> n8 [label="0"];
+ * n8 [label="SmBinHorNode (9)"];
+ * n8 -> n9 [label="0"];
+ * n9 [label="SmTextNode: B (10)"];
+ * n8 -> n10 [label="1"];
+ * n10 [label="SmMathSymbolNode: &#183; (11)"];
+ * n8 -> n11 [label="2"];
+ * n11 [label="SmTextNode: C (12)"];
+ * }
+ * \enddot
+ * Here the caret positions are:
+ *
+ * <TABLE>
+ * <TR><TD><B>Caret position:</B></TD><TD><B>Example:</B></TD>
+ * </TR><TR>
+ *     <TD>{id: 8, index: 0}</TD>
+ *     <TD>\f$ \mid \mbox{C} \cdot \mbox{C} \f$</TD>
+ * </TR><TR>
+ *     <TD>{id: 10, index: 1}</TD>
+ *     <TD>\f$ \mbox{C} \mid \cdot \mbox{C} \f$</TD>
+ * </TR><TR>
+ *     <TD>{id: 11, index: 1}</TD>
+ *     <TD>\f$ \mbox{C} \cdot \mid \mbox{C} \f$</TD>
+ * </TR><TR>
+ *     <TD>{id: 12, index: 1}</TD>
+ *     <TD>\f$ \mbox{C} \cdot \mbox{C} \mid \f$</TD>
+ * </TR><TR>
+ * </TABLE>
+ *
+ * Where \f$ \mid \f$ is used to denote caret position.
+ *
+ * With these exceptions included in the definition the id and index: {id: 11, index: 0} does
+ * \b not constitute a caret position in the given context. Note the method
+ * SmCaretPos::IsValid() does not check if this invariant holds true, but code in SmCaret,
+ * SmSetSelectionVisitor and other places depends on this invariant to hold.
+ *
+ *
+ * \subsection caret_movement Caret Movement
+ *
+ * As the placement of caret positions depends very much on the context within which a node
+ * appears it is not trivial to find all caret positions and determine which follows which.
+ * In OpenOffice Math this is done by the SmCaretPosGraphBuildingVisitor. This visitor builds
+ * graph (an instance of SmCaretPosGraph) over the caret positions. For details on how this
+ * graph is build, and how new methods should be implemented see SmCaretPosGraphBuildingVisitor.
+ *
+ * The result of the SmCaretPosGraphBuildingVisitor is a graph over the caret positions in a
+ * formula, represented by an instance of SmCaretPosGraph. Each entry (instances of SmCaretPosGraphEntry)
+ * has a pointer to the entry to the left and right of itself. This way we can easily find
+ * the caret position to a right or left of a given caret position. Note each caret position
+ * only appears once in this graph.
+ *
+ * When searching for a caret position after a left click on the formula this map is also used.
+ * We simply iterate over all entries, uses the SmCaretPos2LineVisitor to find a line for each
+ * caret position. Then the distance from the click to the line is computed and we choose the
+ * caret position closest to the click.
+ *
+ * For up and down movement, we also iterator over all caret positions and use SmCaretPos2LineVisitor
+ * to find a line for each caret position. Then we compute the distance from the current
+ * caret position to every other caret position and chooses the one closest that is either
+ * above or below the current caret position, depending on whether we're doing up or down movement.
+ *
+ * This result of this approach to caret movement is that we have logically predictable
+ * movement for left and right, whilst leftclick, up and down movement depends on the sizes
+ * and placement of all node and may be less logically predictable. This solution also means
+ * that we only have one complex visitor generating the graph, imagine the nightmare if we
+ * had a visitor for movement in each direction.
+ *
+ * Making up and down movement independent of node sizes and placement wouldn't necessarily
+ * be a good thing either. Consider the formula \f$ \frac{1+2+3+4+5}{6} \f$, if the caret is
+ * placed as displayed here: \f$ \frac{1+2+3+4+5}{6 \mid} \f$, up movement should move to right
+ * after "3": \f$ \frac{1+2+3|+4+5}{6} \f$. However, such a move depends on the sizes and placement
+ * of all nodes in the fraction.
+ *
+ *
+ * \subsubsection caretpos_graph_example Example of Caret Position Graph
+ *
+ * If we consider the formula
+ * \f$ \mbox{A} + \frac{\mbox{B} \cdot \mbox{C}}{\mbox{D}} \f$ from \ref formula_trees.
+ * It has the following caret positions:
+ *
+ * <TABLE>
+ * <TR>
+ *     <TD><B>Caret position:</B></TD>
+ *     <TD><B>Example:</B></TD>
+ * </TR><TR>
+ *     <TD>{id: 3, index: 0}</TD>
+ *     <TD>\f$ \mid\mbox{A} + \frac{\mbox{B} \cdot \mbox{C}}{\mbox{D}} \f$</TD>
+ * </TR><TR>
+ *     <TD>{id: 5, index: 1}</TD>
+ *     <TD>\f$ \mbox{A}\mid + \frac{\mbox{B} \cdot \mbox{C}}{\mbox{D}} \f$</TD>
+ * </TR><TR>
+ *     <TD>{id: 6, index: 1}</TD>
+ *     <TD>\f$ \mbox{A} + \mid \frac{\mbox{B} \cdot \mbox{C}}{\mbox{D}} \f$</TD>
+ * </TR><TR>
+ *     <TD>{id: 8, index: 0}</TD>
+ *     <TD>\f$ \mbox{A} + \frac{ \mid \mbox{B} \cdot \mbox{C}}{\mbox{D}} \f$</TD>
+ * </TR><TR>
+ *     <TD>{id: 10, index: 1}</TD>
+ *     <TD>\f$ \mbox{A} + \frac{\mbox{B} \mid \cdot \mbox{C}}{\mbox{D}} \f$</TD>
+ * </TR><TR>
+ *     <TD>{id: 11, index: 1}</TD>
+ *     <TD>\f$ \mbox{A} + \frac{\mbox{B} \cdot \mid \mbox{C}}{\mbox{D}} \f$</TD>
+ * </TR><TR>
+ *     <TD>{id: 12, index: 1}</TD>
+ *     <TD>\f$ \mbox{A} + \frac{\mbox{B} \cdot \mbox{C} \mid}{\mbox{D}} \f$</TD>
+ * </TR><TR>
+ *     <TD>{id: 14, index: 0}</TD>
+ *     <TD>\f$ \mbox{A} + \frac{\mbox{B} \cdot \mbox{C}}{\mid \mbox{D}} \f$</TD>
+ * </TR><TR>
+ *     <TD>{id: 14, index: 1}</TD>
+ *     <TD>\f$ \mbox{A} + \frac{\mbox{B} \cdot \mbox{C}}{\mbox{D} \mid} \f$</TD>
+ * </TR><TR>
+ *     <TD>{id: 7, index: 1}</TD>
+ *     <TD>\f$ \mbox{A} + \frac{\mbox{B} \cdot \mbox{C}}{\mbox{D}} \mid \f$</TD>
+ * </TR>
+ * </TABLE>
+ *
+ * Below is a directed graph over the caret positions and how you can move between them.
+ * \dot
+ * digraph {
+ *     labelloc = "t";
+ *     label= "Caret Position Graph";
+ *     size = "4,6";
+ *     p0 [label = "{id: 3, index: 0}"];
+ *     p0 -> p1 [fontsize = 10.0, label = "right"];
+ *     p1 [label = "{id: 5, index: 1}"];
+ *     p1 -> p0 [fontsize = 10.0, label = "left"];
+ *     p1 -> p2 [fontsize = 10.0, label = "right"];
+ *     p2 [label = "{id: 6, index: 1}"];
+ *     p2 -> p1 [fontsize = 10.0, label = "left"];
+ *     p2 -> p3 [fontsize = 10.0, label = "right"];
+ *     p3 [label = "{id: 8, index: 0}"];
+ *     p3 -> p2 [fontsize = 10.0, label = "left"];
+ *     p3 -> p4 [fontsize = 10.0, label = "right"];
+ *     p4 [label = "{id: 10, index: 1}"];
+ *     p4 -> p3 [fontsize = 10.0, label = "left"];
+ *     p4 -> p5 [fontsize = 10.0, label = "right"];
+ *     p5 [label = "{id: 11, index: 1}"];
+ *     p5 -> p4 [fontsize = 10.0, label = "left"];
+ *     p5 -> p6 [fontsize = 10.0, label = "right"];
+ *     p6 [label = "{id: 12, index: 1}"];
+ *     p6 -> p5 [fontsize = 10.0, label = "left"];
+ *     p6 -> p9 [fontsize = 10.0, label = "right"];
+ *     p7 [label = "{id: 14, index: 0}"];
+ *     p7 -> p2 [fontsize = 10.0, label = "left"];
+ *     p7 -> p8 [fontsize = 10.0, label = "right"];
+ *     p8 [label = "{id: 14, index: 1}"];
+ *     p8 -> p7 [fontsize = 10.0, label = "left"];
+ *     p8 -> p9 [fontsize = 10.0, label = "right"];
+ *     p9 [label = "{id: 7, index: 1}"];
+ *     p9 -> p6 [fontsize = 10.0, label = "left"];
+ * }
+ * \enddot
+ */
+
+/* TODO: Write documentation about the following keywords:
+ *
+ * Visual Selections:
+ *  - Show images
+ *  - Talk about how the visitor does this
+ *
+ * Modifying a Visual Line:
+ *  - Find top most non-compo of the line (e.g. The subtree that constitutes a line)
+ *  - Make the line into a list
+ *  - Edit the list, add/remove/modify nodes
+ *  - Parse the list back into a subtree
+ *  - Insert the new subtree where the old was taken
+ */
+
+#endif // INCLUDED_STARMATH_INC_CARET_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/starmath/inc/cursor.hxx b/starmath/inc/cursor.hxx
new file mode 100644
index 000000000..236485d5e
--- /dev/null
+++ b/starmath/inc/cursor.hxx
@@ -0,0 +1,427 @@
+/* -*- 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/.
+ */
+#ifndef INCLUDED_STARMATH_INC_CURSOR_HXX
+#define INCLUDED_STARMATH_INC_CURSOR_HXX
+
+#include "node.hxx"
+#include "caret.hxx"
+
+#include <cassert>
+#include <list>
+#include <memory>
+
+/** Factor to multiple the squared horizontal distance with
+ * Used for Up and Down movement.
+ */
+#define HORIZONTICAL_DISTANCE_FACTOR        10
+
+/** Enum of direction for movement */
+enum SmMovementDirection{
+    MoveUp,
+    MoveDown,
+    MoveLeft,
+    MoveRight
+};
+
+/** Enum of elements that can inserted into a formula */
+enum SmFormulaElement{
+    BlankElement,
+    FactorialElement,
+    PlusElement,
+    MinusElement,
+    CDotElement,
+    EqualElement,
+    LessThanElement,
+    GreaterThanElement,
+    PercentElement
+};
+
+/** Bracket types that can be inserted */
+enum class SmBracketType {
+    /** Round brackets, left command "(" */
+    Round,
+    /**Square brackets, left command "[" */
+    Square,
+    /** Curly brackets, left command "lbrace" */
+    Curly,
+};
+
+/** A list of nodes */
+typedef std::list<SmNode*> SmNodeList;
+
+typedef std::list<std::unique_ptr<SmNode>> SmClipboard;
+
+class SmDocShell;
+
+/** Formula cursor
+ *
+ * This class is used to represent a cursor in a formula, which can be used to manipulate
+ * a formula programmatically.
+ * @remarks This class is a very intimate friend of SmDocShell.
+ */
+class SmCursor{
+public:
+    SmCursor(SmNode* tree, SmDocShell* pShell)
+        : mpAnchor(nullptr)
+        , mpPosition(nullptr)
+        , mpTree(tree)
+        , mpDocShell(pShell)
+        , mnEditSections(0)
+        , mbIsEnabledSetModifiedSmDocShell(false)
+    {
+        //Build graph
+        BuildGraph();
+    }
+
+    /** Get position */
+    const SmCaretPos& GetPosition() const { return mpPosition->CaretPos; }
+
+    /** True, if the cursor has a selection */
+    bool HasSelection() const { return mpAnchor != mpPosition; }
+
+    /** Move the position of this cursor */
+    void Move(OutputDevice* pDev, SmMovementDirection direction, bool bMoveAnchor = true);
+
+    /** Move to the caret position closest to a given point */
+    void MoveTo(OutputDevice* pDev, const Point& pos, bool bMoveAnchor);
+
+    /** Delete the current selection or do nothing */
+    void Delete();
+
+    /** Delete selection, previous element or merge lines
+     *
+     * This method implements the behaviour of backspace.
+     */
+    void DeletePrev(OutputDevice* pDev);
+
+    /** Insert text at the current position */
+    void InsertText(const OUString& aString);
+
+    /** Insert an element into the formula */
+    void InsertElement(SmFormulaElement element);
+
+    /** Insert command text translated into line entries at position
+     *
+     * Note: This method uses the parser to translate a command text into a
+     * tree, then it copies line entries from this tree into the current tree.
+     * Will not work for commands such as newline or ##, if position is in a matrix.
+     * This will work for stuff like "A intersection B". But stuff spanning multiple lines
+     * or dependent on the context which position is placed in will not work!
+     */
+    void InsertCommandText(const OUString& aCommandText);
+
+    /** Insert a special node created from aString
+     *
+     * Used for handling insert request from the "catalog" dialog.
+     * The provided string should be formatted as the desired command: %phi
+     * Note: this method ONLY supports commands defined in Math.xcu
+     *
+     * For more complex expressions use InsertCommandText, this method doesn't
+     * use SmParser, this means that it's faster, but not as strong.
+     */
+    void InsertSpecial(const OUString& aString);
+
+    /** Create sub-/super script
+     *
+     * If there's a selection, it will be move into the appropriate sub-/super scription
+     * of the node in front of it. If there's no node in front of position (or the selection),
+     * a sub-/super scription of a new SmPlaceNode will be made.
+     *
+     * If there's is an existing subscription of the node, the caret will be moved into it,
+     * and any selection will replace it.
+     */
+    void InsertSubSup(SmSubSup eSubSup);
+
+    /** Insert a new row or newline
+     *
+     * Inserts a new row if position is in a matrix or stack command.
+     * Otherwise a newline is inserted if we're in a toplevel line.
+     *
+     * @returns True, if a new row/line could be inserted.
+     *
+     * @remarks If the caret is placed in a subline of a command that doesn't support
+     *          this operator the method returns FALSE, and doesn't do anything.
+     */
+    bool InsertRow();
+
+    /** Insert a fraction, use selection as numerator */
+    void InsertFraction();
+
+    /** Create brackets around current selection, or new SmPlaceNode */
+    void InsertBrackets(SmBracketType eBracketType);
+
+    /** Copy the current selection */
+    void Copy();
+    /** Cut the current selection */
+    void Cut(){
+        Copy();
+        Delete();
+    }
+    /** Paste the clipboard */
+    void Paste();
+
+    /** Returns true if more than one node is selected
+     *
+     * This method is used for implementing backspace and delete.
+     * If one of these causes a complex selection, e.g. a node with
+     * subnodes or similar, this should not be deleted immediately.
+     */
+    bool HasComplexSelection();
+
+    /** Finds the topmost node in a visual line
+     *
+     * If MoveUpIfSelected is true, this will move up to the parent line
+     * if the parent of the current line is selected.
+     */
+    static SmNode* FindTopMostNodeInLine(SmNode* pSNode, bool MoveUpIfSelected = false);
+
+    /** Draw the caret */
+    void Draw(OutputDevice& pDev, Point Offset, bool isCaretVisible);
+
+    bool IsAtTailOfBracket(SmBracketType eBracketType, SmBraceNode** ppBraceNode) const;
+    void MoveAfterBracket(SmBraceNode* pBraceNode);
+
+private:
+    friend class SmDocShell;
+
+    SmCaretPosGraphEntry    *mpAnchor,
+                            *mpPosition;
+    /** Formula tree */
+    SmNode* mpTree;
+    /** Owner of the formula tree */
+    SmDocShell* mpDocShell;
+    /** Graph over caret position in the current tree */
+    std::unique_ptr<SmCaretPosGraph> mpGraph;
+    /** Clipboard holder */
+    SmClipboard maClipboard;
+
+    /** Returns a node that is selected, if any could be found */
+    SmNode* FindSelectedNode(SmNode* pNode);
+
+    /** Is this one of the nodes used to compose a line
+     *
+     * These are SmExpression, SmBinHorNode, SmUnHorNode etc.
+     */
+    static bool IsLineCompositionNode(SmNode const * pNode);
+
+    /** Count number of selected nodes, excluding line composition nodes
+     *
+     * Note this function doesn't count line composition nodes and it
+     * does count all subnodes as well as the owner nodes.
+     *
+     * Used by SmCursor::HasComplexSelection()
+     */
+    int CountSelectedNodes(SmNode* pNode);
+
+    /** Convert a visual line to a list
+     *
+     * Note this method will delete all the nodes that will no longer be needed.
+     * that includes pLine!
+     * This method also deletes SmErrorNode's as they're just meta info in the line.
+     */
+    static void LineToList(SmStructureNode* pLine, SmNodeList& rList);
+
+    /** Auxiliary function for calling LineToList on a node
+     *
+     * This method sets pNode = NULL and remove it from its parent.
+     * (Assuming it has a parent, and is a child of it).
+     */
+    static void NodeToList(SmNode*& rpNode, SmNodeList& rList){
+        //Remove from parent and NULL rpNode
+        SmNode* pNode = rpNode;
+        if(rpNode && rpNode->GetParent()){    //Don't remove this, correctness relies on it
+            int index = rpNode->GetParent()->IndexOfSubNode(rpNode);
+            assert(index >= 0);
+            rpNode->GetParent()->SetSubNode(index, nullptr);
+        }
+        rpNode = nullptr;
+        //Create line from node
+        if(pNode && IsLineCompositionNode(pNode)){
+            LineToList(static_cast<SmStructureNode*>(pNode), rList);
+            return;
+        }
+        if(pNode)
+            rList.push_front(pNode);
+    }
+
+    /** Clone a visual line to a clipboard
+     *
+     * ... but the selected part only.
+     * Doesn't clone SmErrorNodes, which are ignored as they are context dependent metadata.
+     */
+    static void CloneLineToClipboard(SmStructureNode* pLine, SmClipboard* pClipboard);
+
+    /** Build pGraph over caret positions */
+    void BuildGraph();
+
+    /** Insert new nodes in the tree after position */
+    void InsertNodes(std::unique_ptr<SmNodeList> pNewNodes);
+
+    /** tries to set position to a specific SmCaretPos
+     *
+     * @returns false on failure to find the position in pGraph.
+     */
+    bool SetCaretPosition(SmCaretPos pos);
+
+    /** Set selected on nodes of the tree */
+    void AnnotateSelection();
+
+    /** Clone list of nodes in a clipboard (creates a deep clone) */
+    static std::unique_ptr<SmNodeList> CloneList(SmClipboard &rClipboard);
+
+    /** Find an iterator pointing to the node in pLineList following rCaretPos
+     *
+     * If rCaretPos.pSelectedNode cannot be found it is assumed that it's in front of pLineList,
+     * thus not an element in pLineList. In this case this method returns an iterator to the
+     * first element in pLineList.
+     *
+     * If the current position is inside an SmTextNode, this node will be split in two, for this
+     * reason you should beaware that iterators to elements in pLineList may be invalidated, and
+     * that you should call PatchLineList() with this iterator if no action is taken.
+     */
+    static SmNodeList::iterator FindPositionInLineList(SmNodeList* pLineList,
+                                                       const SmCaretPos& rCaretPos);
+
+    /** Patch a line list after modification, merge SmTextNode, remove SmPlaceNode etc.
+     *
+     * @param pLineList The line list to patch
+     * @param aIter     Iterator pointing to the element that needs to be patched with its previous.
+     *
+     * When the list is patched text nodes before and after aIter will be merged.
+     * If there's an, in the context, inappropriate SmPlaceNode before or after aIter it will also be
+     * removed.
+     *
+     * @returns A caret position equivalent to one selecting the node before aIter, the method returns
+     *          an invalid SmCaretPos to indicate placement in front of the line.
+     */
+     static SmCaretPos PatchLineList(SmNodeList* pLineList, SmNodeList::iterator aIter);
+
+    /** Take selected nodes from a list
+     *
+     * Puts the selected nodes into pSelectedNodes, or if pSelectedNodes is NULL deletes
+     * the selected nodes.
+     * Note: If there's a selection inside an SmTextNode this node will be split, and it
+     * will not be merged when the selection have been taken. Use PatchLineList on the
+     * iterator returns to fix this.
+     *
+     * @returns An iterator pointing to the element following the selection taken.
+     */
+    static SmNodeList::iterator TakeSelectedNodesFromList(SmNodeList *pLineList,
+                                                         SmNodeList *pSelectedNodes = nullptr);
+
+    /** Create an instance of SmMathSymbolNode usable for brackets */
+    static SmNode *CreateBracket(SmBracketType eBracketType, bool bIsLeft);
+
+    /** The number of times BeginEdit have been called
+     * Used to allow nesting of BeginEdit() and EndEdit() sections
+     */
+    int mnEditSections;
+    /** Holds data for BeginEdit() and EndEdit() */
+    bool mbIsEnabledSetModifiedSmDocShell;
+    /** Begin edit section where the tree will be modified */
+    void BeginEdit();
+    /** End edit section where the tree will be modified */
+    void EndEdit();
+    /** Finish editing
+     *
+     * Finishes editing by parsing pLineList and inserting back into pParent at nParentIndex.
+     * This method also rebuilds the graph, annotates the selection, sets caret position and
+     * Calls EndEdit.
+     *
+     * @remarks Please note that this method will delete pLineList, as the elements are taken.
+     *
+     * @param pLineList     List the constitutes the edited line.
+     * @param pParent       Parent to which the line should be inserted.
+     * @param nParentIndex  Index in parent where the line should be inserted.
+     * @param PosAfterEdit  Caret position to look for after rebuilding graph.
+     * @param pStartLine    Line to take first position in, if PosAfterEdit cannot be found,
+     *                      leave it NULL for pLineList.
+     */
+    void FinishEdit(std::unique_ptr<SmNodeList> pLineList,
+                    SmStructureNode* pParent,
+                    int nParentIndex,
+                    SmCaretPos PosAfterEdit,
+                    SmNode* pStartLine = nullptr);
+    /** Request the formula is repainted */
+    void RequestRepaint();
+};
+
+/** Minimalistic recursive decent SmNodeList parser
+ *
+ * This parser is used to take a list of nodes that constitutes a line
+ * and parse them to a tree of SmBinHorNode, SmUnHorNode and SmExpression.
+ *
+ * Please note, this will not handle all kinds of nodes, only nodes that
+ * constitutes and entry in a line.
+ *
+ * Below is an EBNF representation of the grammar used for this parser:
+ * \code
+ * Expression   -> Relation*
+ * Relation     -> Sum [(=|<|>|...) Sum]*
+ * Sum          -> Product [(+|-) Product]*
+ * Product      -> Factor [(*|/) Factor]*
+ * Factor       -> [+|-|-+|...]* Factor | Postfix
+ * Postfix      -> node [!]*
+ * \endcode
+ */
+class SmNodeListParser{
+public:
+    /** Create an instance of SmNodeListParser */
+    SmNodeListParser(){
+        pList = nullptr;
+    }
+    /** Parse a list of nodes to an expression.
+     *
+     * Old error nodes will be deleted.
+     */
+    SmNode* Parse(SmNodeList* list);
+    /** True, if the token is an operator */
+    static bool IsOperator(const SmToken &token);
+    /** True, if the token is a relation operator */
+    static bool IsRelationOperator(const SmToken &token);
+    /** True, if the token is a sum operator */
+    static bool IsSumOperator(const SmToken &token);
+    /** True, if the token is a product operator */
+    static bool IsProductOperator(const SmToken &token);
+    /** True, if the token is a unary operator */
+    static bool IsUnaryOperator(const SmToken &token);
+    /** True, if the token is a postfix operator */
+    static bool IsPostfixOperator(const SmToken &token);
+private:
+    SmNodeList* pList;
+    /** Get the current terminal */
+    SmNode* Terminal(){
+        if (!pList->empty())
+            return pList->front();
+        return nullptr;
+    }
+    /** Move to next terminal */
+    SmNode* Next(){
+        pList->pop_front();
+        return Terminal();
+    }
+    /** Take the current terminal */
+    SmNode* Take(){
+        SmNode* pRetVal = Terminal();
+        Next();
+        return pRetVal;
+    }
+    SmNode* Expression();
+    SmNode* Relation();
+    SmNode* Sum();
+    SmNode* Product();
+    SmNode* Factor();
+    SmNode* Postfix();
+    static SmNode* Error();
+};
+
+
+#endif // INCLUDED_STARMATH_INC_CURSOR_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/starmath/inc/dialog.hxx b/starmath/inc/dialog.hxx
new file mode 100644
index 000000000..48910cafe
--- /dev/null
+++ b/starmath/inc/dialog.hxx
@@ -0,0 +1,486 @@
+/* -*- 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 .
+ */
+#ifndef INCLUDED_STARMATH_INC_DIALOG_HXX
+#define INCLUDED_STARMATH_INC_DIALOG_HXX
+
+#include <sfx2/tabdlg.hxx>
+#include <vcl/outdev.hxx>
+#include <vcl/customweld.hxx>
+#include "symbol.hxx"
+#include <memory>
+
+class SubsetMap;
+class SmFormat;
+class FontList;
+class SvxShowCharSet;
+
+#define CATEGORY_NONE   0xFFFF
+
+/**************************************************************************/
+
+void SetFontStyle(const OUString &rStyleName, vcl::Font &rFont);
+
+/**************************************************************************/
+
+class SmPrintOptionsTabPage final : public SfxTabPage
+{
+    std::unique_ptr<weld::CheckButton>      m_xTitle;
+    std::unique_ptr<weld::CheckButton>      m_xText;
+    std::unique_ptr<weld::CheckButton>      m_xFrame;
+    std::unique_ptr<weld::RadioButton>      m_xSizeNormal;
+    std::unique_ptr<weld::RadioButton>      m_xSizeScaled;
+    std::unique_ptr<weld::RadioButton>      m_xSizeZoomed;
+    std::unique_ptr<weld::MetricSpinButton> m_xZoom;
+    std::unique_ptr<weld::CheckButton>      m_xNoRightSpaces;
+    std::unique_ptr<weld::CheckButton>      m_xSaveOnlyUsedSymbols;
+    std::unique_ptr<weld::CheckButton>      m_xAutoCloseBrackets;
+
+    DECL_LINK(SizeButtonClickHdl, weld::ToggleButton&, void);
+
+    virtual bool    FillItemSet(SfxItemSet* rSet) override;
+    virtual void    Reset(const SfxItemSet* rSet) override;
+
+public:
+    static std::unique_ptr<SfxTabPage> Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet &rSet);
+
+    SmPrintOptionsTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet &rOptions);
+    virtual ~SmPrintOptionsTabPage() override;
+};
+
+/**************************************************************************/
+
+class SmShowFont final : public weld::CustomWidgetController
+{
+    virtual void Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle&) override;
+
+    vcl::Font maFont;
+
+public:
+    SmShowFont()
+    {
+    }
+    virtual void SetDrawingArea(weld::DrawingArea* pDrawingArea) override;
+    void SetFont(const vcl::Font& rFont);
+};
+
+class SmFontDialog : public weld::GenericDialogController
+{
+    vcl::Font maFont;
+    SmShowFont m_aShowFont;
+    std::unique_ptr<weld::EntryTreeView> m_xFontBox;
+    std::unique_ptr<weld::Widget> m_xAttrFrame;
+    std::unique_ptr<weld::CheckButton> m_xBoldCheckBox;
+    std::unique_ptr<weld::CheckButton> m_xItalicCheckBox;
+    std::unique_ptr<weld::CustomWeld> m_xShowFont;
+
+    DECL_LINK(FontSelectHdl, weld::ComboBox&, void);
+    DECL_LINK(AttrChangeHdl, weld::ToggleButton&, void);
+
+public:
+    SmFontDialog(weld::Window* pParent, OutputDevice *pFntListDevice, bool bHideCheckboxes);
+    virtual ~SmFontDialog() override;
+
+    const vcl::Font& GetFont() const
+    {
+        return maFont;
+    }
+    void SetFont(const vcl::Font &rFont);
+};
+
+/**************************************************************************/
+
+class SmFontSizeDialog final : public weld::GenericDialogController
+{
+    std::unique_ptr<weld::MetricSpinButton> m_xBaseSize;
+    std::unique_ptr<weld::MetricSpinButton> m_xTextSize;
+    std::unique_ptr<weld::MetricSpinButton> m_xIndexSize;
+    std::unique_ptr<weld::MetricSpinButton> m_xFunctionSize;
+    std::unique_ptr<weld::MetricSpinButton> m_xOperatorSize;
+    std::unique_ptr<weld::MetricSpinButton> m_xBorderSize;
+    std::unique_ptr<weld::Button> m_xDefaultButton;
+
+    DECL_LINK(DefaultButtonClickHdl, weld::Button&, void);
+
+public:
+    SmFontSizeDialog(weld::Window *pParent);
+    virtual ~SmFontSizeDialog() override;
+
+    void ReadFrom(const SmFormat &rFormat);
+    void WriteTo (SmFormat &rFormat) const;
+};
+
+/**************************************************************************/
+
+class SmFontTypeDialog final : public weld::GenericDialogController
+{
+    VclPtr<OutputDevice> pFontListDev;
+
+    std::unique_ptr<SmFontPickListBox> m_xVariableFont;
+    std::unique_ptr<SmFontPickListBox> m_xFunctionFont;
+    std::unique_ptr<SmFontPickListBox> m_xNumberFont;
+    std::unique_ptr<SmFontPickListBox> m_xTextFont;
+    std::unique_ptr<SmFontPickListBox> m_xSerifFont;
+    std::unique_ptr<SmFontPickListBox> m_xSansFont;
+    std::unique_ptr<SmFontPickListBox> m_xFixedFont;
+    std::unique_ptr<weld::MenuButton> m_xMenuButton;
+    std::unique_ptr<weld::Button> m_xDefaultButton;
+
+    DECL_LINK(MenuSelectHdl, const OString&, void);
+    DECL_LINK(DefaultButtonClickHdl, weld::Button&, void);
+
+public:
+    SmFontTypeDialog(weld::Window* pParent, OutputDevice *pFntListDevice);
+    virtual ~SmFontTypeDialog() override;
+
+    void ReadFrom(const SmFormat &rFormat);
+    void WriteTo (SmFormat &rFormat) const;
+};
+
+/**************************************************************************/
+
+#define NOCATEGORIES    10
+
+class SmCategoryDesc
+{
+    OUString Name;
+    OUString Strings[4];
+    std::unique_ptr<weld::Widget> Graphics[4];    /* regular bitmaps */
+    sal_uInt16 Minimum[4];
+    sal_uInt16 Maximum[4];
+    sal_uInt16 Value[4];
+
+public:
+    SmCategoryDesc(weld::Builder& rBuilder, sal_uInt16 nCategoryIdx);
+    ~SmCategoryDesc();
+
+    const OUString& GetName() const                 { return Name; }
+    const OUString& GetString(sal_uInt16 Index) const   { return Strings[Index];  }
+    sal_uInt16          GetMinimum(sal_uInt16 Index)        { return Minimum[Index]; }
+    sal_uInt16          GetMaximum(sal_uInt16 Index)        { return Maximum[Index]; }
+    sal_uInt16          GetValue(sal_uInt16 Index) const    { return Value[Index]; }
+    void            SetValue(sal_uInt16 Index, sal_uInt16 nVal) { Value[Index] = nVal;}
+
+    weld::Widget* GetGraphic(sal_uInt16 Index) const
+    {
+        return Graphics[Index].get();
+    }
+};
+
+class SmDistanceDialog final : public weld::GenericDialogController
+{
+    std::unique_ptr<weld::Frame> m_xFrame;
+    std::unique_ptr<weld::Label> m_xFixedText1;
+    std::unique_ptr<weld::MetricSpinButton>    m_xMetricField1;
+    std::unique_ptr<weld::Label> m_xFixedText2;
+    std::unique_ptr<weld::MetricSpinButton>    m_xMetricField2;
+    std::unique_ptr<weld::Label> m_xFixedText3;
+    std::unique_ptr<weld::MetricSpinButton>    m_xMetricField3;
+    std::unique_ptr<weld::CheckButton> m_xCheckBox1;
+    std::unique_ptr<weld::Label> m_xFixedText4;
+    std::unique_ptr<weld::MetricSpinButton> m_xMetricField4;
+    std::unique_ptr<weld::MenuButton> m_xMenuButton;
+    std::unique_ptr<weld::Button> m_xDefaultButton;
+    std::unique_ptr<weld::Widget> m_xBitmap;
+
+    weld::Widget* m_pCurrentImage;
+
+    std::unique_ptr<SmCategoryDesc> m_xCategories[NOCATEGORIES];
+    sal_uInt16          nActiveCategory;
+    bool            bScaleAllBrackets;
+
+    DECL_LINK(GetFocusHdl, weld::Widget&, void);
+    DECL_LINK(MenuSelectHdl, const OString&, void);
+    DECL_LINK(DefaultButtonClickHdl, weld::Button&, void);
+    DECL_LINK(CheckBoxClickHdl, weld::ToggleButton&, void);
+
+    void    SetCategory(sal_uInt16 Category);
+
+public:
+    SmDistanceDialog(weld::Window *pParent);
+    virtual ~SmDistanceDialog() override;
+
+    void ReadFrom(const SmFormat &rFormat);
+    void WriteTo (SmFormat &rFormat);
+};
+
+/**************************************************************************/
+
+
+class SmAlignDialog final : public weld::GenericDialogController
+{
+    std::unique_ptr<weld::RadioButton> m_xLeft;
+    std::unique_ptr<weld::RadioButton> m_xCenter;
+    std::unique_ptr<weld::RadioButton> m_xRight;
+    std::unique_ptr<weld::Button> m_xDefaultButton;
+
+    DECL_LINK(DefaultButtonClickHdl, weld::Button&, void);
+
+public:
+    SmAlignDialog(weld::Window *pParent);
+    virtual ~SmAlignDialog() override;
+
+    void ReadFrom(const SmFormat &rFormat);
+    void WriteTo (SmFormat &rFormat) const;
+};
+
+/**************************************************************************/
+
+class SmShowSymbolSet final : public weld::CustomWidgetController
+{
+    Size m_aOldSize;
+    SymbolPtrVec_t aSymbolSet;
+    Link<SmShowSymbolSet&,void> aSelectHdlLink;
+    Link<SmShowSymbolSet&,void> aDblClickHdlLink;
+    long        nLen;
+    long        nRows, nColumns;
+    long        nXOffset, nYOffset;
+    sal_uInt16  nSelectSymbol;
+    std::unique_ptr<weld::ScrolledWindow> m_xScrolledWindow;
+
+    void SetScrollBarRange();
+    Point OffsetPoint(const Point &rPoint) const;
+
+    virtual void Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect) override;
+    virtual bool MouseButtonDown(const MouseEvent& rMEvt) override;
+    virtual bool KeyInput(const KeyEvent& rKEvt) override;
+    virtual void Resize() override;
+
+    DECL_LINK(ScrollHdl, weld::ScrolledWindow&, void);
+
+public:
+    SmShowSymbolSet(std::unique_ptr<weld::ScrolledWindow> pScrolledWindow);
+
+    virtual void SetDrawingArea(weld::DrawingArea* pDrawingArea) override
+    {
+        CustomWidgetController::SetDrawingArea(pDrawingArea);
+        m_aOldSize = Size(pDrawingArea->get_approximate_digit_width() * 27,
+                          pDrawingArea->get_text_height() * 9);
+        pDrawingArea->set_size_request(m_aOldSize.Width(), m_aOldSize.Height());
+        SetOutputSizePixel(m_aOldSize);
+        calccols(pDrawingArea->get_ref_device());
+    }
+
+    void calccols(const vcl::RenderContext& rRenderContext);
+    void    SelectSymbol(sal_uInt16 nSymbol);
+    sal_uInt16  GetSelectSymbol() const { return nSelectSymbol; }
+    void SetSymbolSet(const SymbolPtrVec_t& rSymbolSet);
+    void SetSelectHdl(const Link<SmShowSymbolSet&,void>& rLink) { aSelectHdlLink = rLink; }
+    void SetDblClickHdl(const Link<SmShowSymbolSet&,void>& rLink) { aDblClickHdlLink = rLink; }
+};
+
+class SmShowSymbol final : public weld::CustomWidgetController
+{
+private:
+    vcl::Font m_aFont;
+    OUString m_aText;
+
+    Link<SmShowSymbol&,void> aDblClickHdlLink;
+
+    virtual void Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle&) override;
+    virtual bool MouseButtonDown(const MouseEvent& rMEvt) override;
+
+    void setFontSize(vcl::Font &rFont) const;
+
+public:
+    SmShowSymbol();
+
+    virtual void SetDrawingArea(weld::DrawingArea* pDrawingArea) override
+    {
+        CustomWidgetController::SetDrawingArea(pDrawingArea);
+        pDrawingArea->set_size_request(pDrawingArea->get_approximate_digit_width() * 27,
+                                       pDrawingArea->get_text_height() * 9);
+    }
+
+    void SetText(const OUString& rText) { m_aText = rText; }
+    const OUString& GetText() const { return m_aText; }
+
+    void SetFont(const vcl::Font& rFont) { m_aFont = rFont; }
+    const vcl::Font& GetFont() const { return m_aFont; }
+
+    void    SetSymbol(const SmSym *pSymbol);
+    void    SetDblClickHdl(const Link<SmShowSymbol&,void> &rLink) { aDblClickHdlLink = rLink; }
+};
+
+class SmSymbolDialog final : public weld::GenericDialogController
+{
+    SmViewShell        &rViewSh;
+    SmSymbolManager    &rSymbolMgr;
+
+    OUString       aSymbolSetName;
+    SymbolPtrVec_t      aSymbolSet;
+
+    VclPtr<OutputDevice> pFontListDev;
+
+    SmShowSymbol m_aSymbolDisplay;
+
+    std::unique_ptr<weld::ComboBox> m_xSymbolSets;
+    std::unique_ptr<SmShowSymbolSet> m_xSymbolSetDisplay;
+    std::unique_ptr<weld::CustomWeld> m_xSymbolSetDisplayArea;
+    std::unique_ptr<weld::Label> m_xSymbolName;
+    std::unique_ptr<weld::CustomWeld> m_xSymbolDisplay;
+    std::unique_ptr<weld::Button> m_xGetBtn;
+    std::unique_ptr<weld::Button> m_xEditBtn;
+
+    DECL_LINK(SymbolSetChangeHdl, weld::ComboBox&, void);
+    DECL_LINK(SymbolChangeHdl, SmShowSymbolSet&, void);
+    DECL_LINK(SymbolDblClickHdl, SmShowSymbol&, void);
+    DECL_LINK(SymbolDblClickHdl2, SmShowSymbolSet&, void);
+    DECL_LINK(EditClickHdl, weld::Button&, void);
+    DECL_LINK(GetClickHdl, weld::Button&, void);
+    void SymbolDblClickHdl();
+
+    void            FillSymbolSets();
+    const SmSym    *GetSymbol() const;
+
+public:
+    SmSymbolDialog(weld::Window* pParent, OutputDevice *pFntListDevice,
+            SmSymbolManager &rSymbolMgr, SmViewShell &rViewShell);
+    virtual ~SmSymbolDialog() override;
+
+    bool    SelectSymbolSet(const OUString &rSymbolSetName);
+    void    SelectSymbol(sal_uInt16 nSymbolPos);
+};
+
+class SmShowChar final : public weld::CustomWidgetController
+{
+private:
+    OUString m_aText;
+    vcl::Font m_aFont;
+
+    virtual void Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle&) override;
+    virtual void Resize() override;
+
+public:
+    SmShowChar()
+    {
+    }
+
+    virtual void SetDrawingArea(weld::DrawingArea* pDrawingArea) override
+    {
+        CustomWidgetController::SetDrawingArea(pDrawingArea);
+        pDrawingArea->set_size_request(pDrawingArea->get_approximate_digit_width() * 7,
+                                       pDrawingArea->get_text_height() * 3);
+    }
+
+    void SetSymbol(const SmSym *pSym);
+    void SetSymbol(sal_UCS4 cChar, const vcl::Font &rFont);
+    void SetText(const OUString& rText) { m_aText = rText; }
+    const OUString& GetText() const { return m_aText; }
+    void SetFont(const vcl::Font& rFont) { m_aFont = rFont; }
+    const vcl::Font& GetFont() const { return m_aFont; }
+};
+
+class SmSymDefineDialog final : public weld::GenericDialogController
+{
+    VclPtr<VirtualDevice> m_xVirDev;
+    SmSymbolManager m_aSymbolMgrCopy;
+    SmSymbolManager& m_rSymbolMgr;
+    SmShowChar m_aOldSymbolDisplay;
+    SmShowChar m_aSymbolDisplay;
+    std::unique_ptr<SmSym> m_xOrigSymbol;
+    std::unique_ptr<SubsetMap> m_xSubsetMap;
+    std::unique_ptr<FontList> m_xFontList;
+    std::unique_ptr<weld::ComboBox> m_xOldSymbols;
+    std::unique_ptr<weld::ComboBox> m_xOldSymbolSets;
+    std::unique_ptr<weld::ComboBox> m_xSymbols;
+    std::unique_ptr<weld::ComboBox> m_xSymbolSets;
+    std::unique_ptr<weld::ComboBox> m_xFonts;
+    std::unique_ptr<weld::ComboBox> m_xFontsSubsetLB;
+    std::unique_ptr<weld::ComboBox> m_xStyles;
+    std::unique_ptr<weld::Label> m_xOldSymbolName;
+    std::unique_ptr<weld::Label> m_xOldSymbolSetName;
+    std::unique_ptr<weld::Label> m_xSymbolName;
+    std::unique_ptr<weld::Label> m_xSymbolSetName;
+    std::unique_ptr<weld::Button> m_xAddBtn;
+    std::unique_ptr<weld::Button> m_xChangeBtn;
+    std::unique_ptr<weld::Button> m_xDeleteBtn;
+    std::unique_ptr<weld::CustomWeld> m_xOldSymbolDisplay;
+    std::unique_ptr<weld::CustomWeld> m_xSymbolDisplay;
+    std::unique_ptr<SvxShowCharSet>  m_xCharsetDisplay;
+    std::unique_ptr<weld::CustomWeld>  m_xCharsetDisplayArea;
+
+    DECL_LINK(OldSymbolChangeHdl, weld::ComboBox&, void);
+    DECL_LINK(OldSymbolSetChangeHdl, weld::ComboBox&, void);
+    DECL_LINK(ModifyHdl, weld::ComboBox&, void);
+    DECL_LINK(FontChangeHdl, weld::ComboBox&, void);
+    DECL_LINK(SubsetChangeHdl, weld::ComboBox&, void);
+    DECL_LINK(StyleChangeHdl, weld::ComboBox&, void);
+    DECL_LINK(CharHighlightHdl, SvxShowCharSet*, void);
+    DECL_LINK(AddClickHdl, weld::Button&, void);
+    DECL_LINK(ChangeClickHdl, weld::Button&, void);
+    DECL_LINK(DeleteClickHdl, weld::Button&, void);
+
+    void    FillSymbols(weld::ComboBox& rComboBox, bool bDeleteText = true);
+    void    FillSymbolSets(weld::ComboBox& rComboBox, bool bDeleteText = true);
+    void    FillFonts();
+    void    FillStyles();
+
+    void    SetSymbolSetManager(const SmSymbolManager &rMgr);
+    void    SetFont(const OUString &rFontName, const OUString &rStyleName);
+    void    SetOrigSymbol(const SmSym *pSymbol, const OUString &rSymbolSetName);
+    void    UpdateButtons();
+
+    bool    SelectSymbolSet(weld::ComboBox &rComboBox, const OUString &rSymbolSetName,
+                            bool bDeleteText);
+    bool    SelectSymbol(weld::ComboBox& rComboBox, const OUString &rSymbolName,
+                            bool bDeleteText);
+    bool    SelectFont(const OUString &rFontName, bool bApplyFont);
+    bool    SelectStyle(const OUString &rStyleName, bool bApplyFont);
+
+    SmSym* GetSymbol(const weld::ComboBox& rComboBox);
+    const SmSym* GetSymbol(const weld::ComboBox& rComboBox) const
+    {
+        return const_cast<SmSymDefineDialog *>(this)->GetSymbol(rComboBox);
+    }
+
+public:
+    SmSymDefineDialog(weld::Window *pParent, OutputDevice *pFntListDevice, SmSymbolManager &rMgr);
+    virtual ~SmSymDefineDialog() override;
+
+    virtual short run() override;
+
+    void SelectOldSymbolSet(const OUString &rSymbolSetName)
+    {
+        SelectSymbolSet(*m_xOldSymbolSets, rSymbolSetName, false);
+    }
+
+    void SelectOldSymbol(const OUString &rSymbolName)
+    {
+        SelectSymbol(*m_xOldSymbols, rSymbolName, false);
+    }
+
+    bool SelectSymbolSet(const OUString &rSymbolSetName)
+    {
+        return SelectSymbolSet(*m_xSymbolSets, rSymbolSetName, false);
+    }
+
+    bool SelectSymbol(const OUString &rSymbolName)
+    {
+        return SelectSymbol(*m_xSymbols, rSymbolName, false);
+    }
+
+    bool        SelectFont(const OUString &rFontName)   { return SelectFont(rFontName, true); }
+    bool        SelectStyle(const OUString &rStyleName) { return SelectStyle(rStyleName, true); };
+    void        SelectChar(sal_Unicode cChar);
+};
+
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/starmath/inc/document.hxx b/starmath/inc/document.hxx
new file mode 100644
index 000000000..1b425c91e
--- /dev/null
+++ b/starmath/inc/document.hxx
@@ -0,0 +1,220 @@
+/* -*- 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 .
+ */
+
+#ifndef INCLUDED_STARMATH_INC_DOCUMENT_HXX
+#define INCLUDED_STARMATH_INC_DOCUMENT_HXX
+
+#include <rtl/ustring.hxx>
+#include <rtl/strbuf.hxx>
+#include <sfx2/docfac.hxx>
+#include <sfx2/objsh.hxx>
+#include <svl/lstner.hxx>
+#include <sax/fshelper.hxx>
+#include <unotools/lingucfg.hxx>
+#include <oox/core/filterbase.hxx>
+#include <oox/export/utils.hxx>
+
+#include <memory>
+#include <set>
+
+#include "format.hxx"
+#include "node.hxx"
+#include "parse.hxx"
+#include "smdllapi.hxx"
+
+class SfxPrinter;
+class Printer;
+class SmCursor;
+
+namespace oox::formulaimport { class XmlStream; }
+
+#define STAROFFICE_XML  "StarOffice XML (Math)"
+#define MATHML_XML      "MathML XML (Math)"
+
+/* Access to printer should happen through this class only
+ * ==========================================================================
+ *
+ * The printer can belong to the document or the OLE-Container. If the document
+ * is an OLE-Document the printer generally belongs to the container too.
+ * But the container maybe works with a different MapUnit than the server.
+ * Referring to the MapMode the printer will be accordingly adjusted in the
+ * constructor and restored in the destructor. This brings that this class
+ * is always allowed to exists only a short time (e.g. while painting).
+ * The control whether the printer is self-generated, gotten from the server
+ * or is NULL then, is taken by the DocShell in the method GetPrt(), for
+ * which the access is friend of the DocShell too.
+ */
+
+class SmDocShell;
+class EditEngine;
+
+class SmPrinterAccess
+{
+    VclPtr<Printer> pPrinter;
+    VclPtr<OutputDevice> pRefDev;
+public:
+    explicit SmPrinterAccess( SmDocShell &rDocShell );
+    ~SmPrinterAccess();
+    Printer* GetPrinter()  { return pPrinter.get(); }
+    OutputDevice* GetRefDev()  { return pRefDev.get(); }
+};
+
+
+class SM_DLLPUBLIC SmDocShell : public SfxObjectShell, public SfxListener
+{
+    friend class SmPrinterAccess;
+    friend class SmCursor;
+
+    OUString            maText;
+    SmFormat            maFormat;
+    SmParser            maParser;
+    OUString            maAccText;
+    SvtLinguOptions     maLinguOptions;
+    std::unique_ptr<SmTableNode> mpTree;
+    SfxItemPool        *mpEditEngineItemPool;
+    std::unique_ptr<EditEngine> mpEditEngine;
+    VclPtr<SfxPrinter>  mpPrinter;       //q.v. comment to SmPrinter Access!
+    VclPtr<Printer>     mpTmpPrinter;    //ditto
+    sal_uInt16          mnModifyCount;
+    bool                mbFormulaArranged;
+    std::unique_ptr<SmCursor> mpCursor;
+    std::set< OUString >    maUsedSymbols;   // to export used symbols only when saving
+
+
+    virtual void Notify(SfxBroadcaster& rBC, const SfxHint& rHint) override;
+
+    bool        WriteAsMathType3( SfxMedium& );
+
+    virtual void        Draw(OutputDevice *pDevice,
+                             const JobSetup & rSetup,
+                             sal_uInt16 nAspect) override;
+
+    virtual void        FillClass(SvGlobalName* pClassName,
+                                  SotClipboardFormatId*  pFormat,
+                                  OUString* pFullTypeName,
+                                  sal_Int32 nFileFormat,
+                                  bool bTemplate = false ) const override;
+
+    virtual void        OnDocumentPrinterChanged( Printer * ) override;
+    virtual bool        InitNew( const css::uno::Reference< css::embed::XStorage >& xStorage ) override;
+    virtual bool        Load( SfxMedium& rMedium ) override;
+    virtual bool        Save() override;
+    virtual bool        SaveAs( SfxMedium& rMedium ) override;
+
+    Printer             *GetPrt();
+    OutputDevice*       GetRefDev();
+
+    void                SetFormulaArranged(bool bVal) { mbFormulaArranged = bVal; }
+
+    virtual bool        ConvertFrom(SfxMedium &rMedium) override;
+
+    /** Called whenever the formula is changed
+     * Deletes the current cursor
+     */
+    void                InvalidateCursor();
+
+public:
+    SFX_DECL_INTERFACE(SFX_INTERFACE_SMA_START+SfxInterfaceId(1))
+
+    SFX_DECL_OBJECTFACTORY();
+
+private:
+    /// SfxInterface initializer.
+    static void InitInterface_Impl();
+
+public:
+    explicit SmDocShell( SfxModelFlags i_nSfxCreationFlags );
+    virtual     ~SmDocShell() override;
+
+    virtual bool        ConvertTo( SfxMedium &rMedium ) override;
+
+    // For unit tests, not intended to use in other context
+    void SetGreekCharStyle(sal_Int16 nVal) { maFormat.SetGreekCharStyle(nVal); }
+
+    static void LoadSymbols();
+    static void SaveSymbols();
+
+    void        ArrangeFormula();
+
+    //Access for the View. This access is not for the OLE-case!
+    //and for the communication with the SFX!
+    //All internal printer uses should work with the SmPrinterAccess only
+    bool        HasPrinter() const { return mpPrinter != nullptr; }
+    SfxPrinter *GetPrinter()    { GetPrt(); return mpPrinter; }
+    void        SetPrinter( SfxPrinter * );
+
+    OUString GetComment() const;
+
+    // to replace chars that can not be saved with the document...
+    void        ReplaceBadChars();
+
+    void        UpdateText();
+    void        SetText(const OUString& rBuffer);
+    const OUString&  GetText() const { return maText; }
+    void        SetFormat(SmFormat const & rFormat);
+    const SmFormat&  GetFormat() const { return maFormat; }
+
+    void            Parse();
+    SmParser &      GetParser() { return maParser; }
+    const SmTableNode *GetFormulaTree() const  { return mpTree.get(); }
+    void            SetFormulaTree(SmTableNode *pTree) { mpTree.reset(pTree); }
+
+    const std::set< OUString > &    GetUsedSymbols() const  { return maUsedSymbols; }
+
+    OUString const & GetAccessibleText();
+
+    EditEngine &    GetEditEngine();
+
+    void        DrawFormula(OutputDevice &rDev, Point &rPosition, bool bDrawSelection = false);
+    Size        GetSize();
+
+    void        Repaint();
+
+    virtual SfxUndoManager *GetUndoManager () override;
+
+    static SfxItemPool& GetPool();
+
+    void        Execute( SfxRequest& rReq );
+    void        GetState(SfxItemSet &);
+
+    virtual void SetVisArea (const tools::Rectangle & rVisArea) override;
+    virtual void SetModified(bool bModified = true) override;
+
+    /** Get a cursor for modifying this document
+     * @remarks Don't store this reference, a new cursor may be made...
+     */
+    SmCursor&   GetCursor();
+    /** True, if cursor have previously been requested and thus
+     * has some sort of position.
+     */
+    bool        HasCursor() const;
+
+    void writeFormulaOoxml(const ::sax_fastparser::FSHelperPtr& pSerializer,
+            oox::core::OoxmlVersion version,
+            oox::drawingml::DocumentType documentType,
+            const sal_Int8 nAlign);
+    void writeFormulaRtf(OStringBuffer& rBuffer, rtl_TextEncoding nEncoding);
+    void readFormulaOoxml( oox::formulaimport::XmlStream& stream );
+
+    void UpdateEditEngineDefaultFonts(const Color& aTextColor);
+};
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/starmath/inc/edit.hxx b/starmath/inc/edit.hxx
new file mode 100644
index 000000000..c1ce769ab
--- /dev/null
+++ b/starmath/inc/edit.hxx
@@ -0,0 +1,134 @@
+/* -*- 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 .
+ */
+#ifndef INCLUDED_STARMATH_INC_EDIT_HXX
+#define INCLUDED_STARMATH_INC_EDIT_HXX
+
+#include <vcl/window.hxx>
+#include <vcl/idle.hxx>
+#include <vcl/transfer.hxx>
+#include <editeng/editdata.hxx>
+#include <memory>
+
+class SmDocShell;
+class SmViewShell;
+class EditView;
+class EditEngine;
+class EditStatus;
+class ScrollBar;
+class ScrollBarBox;
+class DataChangedEvent;
+class SmCmdBoxWindow;
+class SmEditAccessible;
+class CommandEvent;
+class Timer;
+
+namespace svtools { class ColorConfig; }
+
+void SmGetLeftSelectionPart(const ESelection &rSelection, sal_Int32 &nPara, sal_uInt16 &nPos);
+
+class SmEditWindow final : public vcl::Window, public DropTargetHelper
+{
+    rtl::Reference<SmEditAccessible> mxAccessible;
+
+    SmCmdBoxWindow& rCmdBox;
+    std::unique_ptr<EditView> pEditView;
+    VclPtr<ScrollBar> pHScrollBar;
+    VclPtr<ScrollBar> pVScrollBar;
+    VclPtr<ScrollBarBox> pScrollBox;
+    Idle aModifyIdle;
+    Idle aCursorMoveIdle;
+    ESelection aOldSelection;
+
+    virtual void KeyInput(const KeyEvent& rKEvt) override;
+    virtual void Command(const CommandEvent& rCEvt) override;
+
+    DECL_LINK(ModifyTimerHdl, Timer *, void);
+    DECL_LINK(CursorMoveTimerHdl, Timer *, void);
+
+    virtual void ApplySettings(vcl::RenderContext&) override;
+    virtual void DataChanged( const DataChangedEvent& ) override;
+    virtual void Resize() override;
+    virtual void MouseMove(const MouseEvent &rEvt) override;
+    virtual void MouseButtonUp(const MouseEvent &rEvt) override;
+    virtual void MouseButtonDown(const MouseEvent &rEvt) override;
+
+    virtual sal_Int8 AcceptDrop( const AcceptDropEvent& rEvt ) override;
+    virtual sal_Int8 ExecuteDrop( const ExecuteDropEvent& rEvt ) override;
+    virtual void Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect) override;
+
+    DECL_LINK(EditStatusHdl, EditStatus&, void);
+    DECL_LINK(ScrollHdl, ScrollBar*, void);
+
+    void CreateEditView();
+    tools::Rectangle AdjustScrollBars();
+    void SetScrollBarRanges();
+    void InitScrollBars();
+    void InvalidateSlots();
+    void UpdateStatus(bool bSetDocModified);
+
+public:
+    explicit SmEditWindow(SmCmdBoxWindow& rMyCmdBoxWin);
+    virtual ~SmEditWindow() override;
+    virtual void dispose() override;
+
+    SmDocShell* GetDoc();
+    SmViewShell* GetView();
+    EditView* GetEditView();
+    EditEngine* GetEditEngine();
+
+    // Window
+    virtual void SetText(const OUString& rText) override;
+    virtual OUString GetText() const override;
+    virtual void GetFocus() override;
+    virtual void LoseFocus() override;
+
+    ESelection GetSelection() const;
+    void SetSelection(const ESelection& rSel);
+
+    bool IsEmpty() const;
+    bool IsSelected() const;
+    bool IsAllSelected() const;
+    void Cut();
+    void Copy();
+    void Paste();
+    void Delete();
+    void SelectAll();
+    void InsertText(const OUString& rText);
+    void MarkError(const Point &rPos);
+    void SelNextMark();
+    void SelPrevMark();
+    static bool HasMark(const OUString &rText);
+
+    void Flush() override;
+    void DeleteEditView();
+
+    bool HandleWheelCommands(const CommandEvent& rCEvt);
+    bool IsInlineEditEnabled();
+    void StartCursorMove();
+
+    // for Accessibility
+    virtual css::uno::Reference<css::accessibility::XAccessible> CreateAccessible() override;
+
+    using Window::GetAccessible;
+};
+
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/starmath/inc/error.hxx b/starmath/inc/error.hxx
new file mode 100644
index 000000000..a05123d6e
--- /dev/null
+++ b/starmath/inc/error.hxx
@@ -0,0 +1,55 @@
+/* -*- 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 .
+ */
+#ifndef INCLUDED_STARMATH_INC_ERROR_HXX
+#define INCLUDED_STARMATH_INC_ERROR_HXX
+
+#include <rtl/ustring.hxx>
+
+class SmNode;
+
+enum class SmParseError
+{
+    None,
+    UnexpectedChar,
+    UnexpectedToken,
+    PoundExpected,
+    ColorExpected,
+    LgroupExpected,
+    RgroupExpected,
+    LbraceExpected,
+    RbraceExpected,
+    ParentMismatch,
+    RightExpected,
+    FontExpected,
+    SizeExpected,
+    DoubleAlign,
+    DoubleSubsupscript
+};
+
+
+struct SmErrorDesc
+{
+    SmParseError m_eType;
+    SmNode      *m_pNode;
+    OUString     m_aText;
+};
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/starmath/inc/format.hxx b/starmath/inc/format.hxx
new file mode 100644
index 000000000..14fbfc2a6
--- /dev/null
+++ b/starmath/inc/format.hxx
@@ -0,0 +1,154 @@
+/* -*- 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 .
+ */
+#ifndef INCLUDED_STARMATH_INC_FORMAT_HXX
+#define INCLUDED_STARMATH_INC_FORMAT_HXX
+
+
+#include <svl/hint.hxx>
+#include <svl/SfxBroadcaster.hxx>
+#include "utility.hxx"
+#include "types.hxx"
+
+
+#define FNTNAME_TIMES   "Times New Roman"
+#define FNTNAME_HELV    "Helvetica"
+#define FNTNAME_COUR    "Courier"
+#define FNTNAME_MATH    FONTNAME_MATH
+
+
+// symbolic names used as array indices
+#define SIZ_BEGIN       0
+#define SIZ_TEXT        0
+#define SIZ_INDEX       1
+#define SIZ_FUNCTION    2
+#define SIZ_OPERATOR    3
+#define SIZ_LIMITS      4
+#define SIZ_END         4
+
+// symbolic names used as array indices
+#define FNT_BEGIN       0
+#define FNT_VARIABLE    0
+#define FNT_FUNCTION    1
+#define FNT_NUMBER      2
+#define FNT_TEXT        3
+#define FNT_SERIF       4
+#define FNT_SANS        5
+#define FNT_FIXED       6
+#define FNT_MATH        7
+#define FNT_END         7
+
+// symbolic names used as array indices
+#define DIS_BEGIN                0
+#define DIS_HORIZONTAL           0
+#define DIS_VERTICAL             1
+#define DIS_ROOT                 2
+#define DIS_SUPERSCRIPT          3
+#define DIS_SUBSCRIPT            4
+#define DIS_NUMERATOR            5
+#define DIS_DENOMINATOR          6
+#define DIS_FRACTION             7
+#define DIS_STROKEWIDTH          8
+#define DIS_UPPERLIMIT           9
+#define DIS_LOWERLIMIT          10
+#define DIS_BRACKETSIZE         11
+#define DIS_BRACKETSPACE        12
+#define DIS_MATRIXROW           13
+#define DIS_MATRIXCOL           14
+#define DIS_ORNAMENTSIZE        15
+#define DIS_ORNAMENTSPACE       16
+#define DIS_OPERATORSIZE        17
+#define DIS_OPERATORSPACE       18
+#define DIS_LEFTSPACE           19
+#define DIS_RIGHTSPACE          20
+#define DIS_TOPSPACE            21
+#define DIS_BOTTOMSPACE         22
+#define DIS_NORMALBRACKETSIZE   23
+#define DIS_END                 23
+
+
+enum class SmHorAlign {
+    Left,
+    Center,
+    Right
+};
+
+class SmFormat final : public SfxBroadcaster
+{
+    SmFace      vFont[FNT_END + 1];
+    bool        bDefaultFont[FNT_END + 1];
+    Size        aBaseSize;
+    sal_uInt16      vSize[SIZ_END + 1];
+    sal_uInt16      vDist[DIS_END + 1];
+    SmHorAlign  eHorAlign;
+    sal_Int16       nGreekCharStyle;
+    bool        bIsTextmode,
+                bScaleNormalBrackets;
+
+public:
+    SmFormat();
+    SmFormat(const SmFormat &rFormat) : SfxBroadcaster() { *this = rFormat; }
+
+    const Size &    GetBaseSize() const             { return aBaseSize; }
+    void            SetBaseSize(const Size &rSize)  { aBaseSize = rSize; }
+
+    const SmFace &  GetFont(sal_uInt16 nIdent) const { return vFont[nIdent]; }
+    void            SetFont(sal_uInt16 nIdent, const SmFace &rFont, bool bDefault = false);
+    void            SetFontSize(sal_uInt16 nIdent, const Size &rSize)   { vFont[nIdent].SetSize( rSize ); }
+
+    void            SetDefaultFont(sal_uInt16 nIdent, bool bVal)    { bDefaultFont[nIdent] = bVal; }
+    bool            IsDefaultFont(sal_uInt16 nIdent) const   { return bDefaultFont[nIdent]; }
+
+    sal_uInt16      GetRelSize(sal_uInt16 nIdent) const         { return vSize[nIdent]; }
+    void            SetRelSize(sal_uInt16 nIdent, sal_uInt16 nVal)  { vSize[nIdent] = nVal;}
+
+    sal_uInt16      GetDistance(sal_uInt16 nIdent) const            { return vDist[nIdent]; }
+    void            SetDistance(sal_uInt16 nIdent, sal_uInt16 nVal) { vDist[nIdent] = nVal; }
+
+    SmHorAlign      GetHorAlign() const             { return eHorAlign; }
+    void            SetHorAlign(SmHorAlign eAlign)  { eHorAlign = eAlign; }
+
+    bool            IsTextmode() const     { return bIsTextmode; }
+    void            SetTextmode(bool bVal) { bIsTextmode = bVal; }
+
+    sal_Int16       GetGreekCharStyle() const     { return nGreekCharStyle; }
+    void            SetGreekCharStyle(sal_Int16 nVal) { nGreekCharStyle = nVal; }
+
+    bool            IsScaleNormalBrackets() const     { return bScaleNormalBrackets; }
+    void            SetScaleNormalBrackets(bool bVal) { bScaleNormalBrackets = bVal; }
+
+    SmFormat &      operator = (const SmFormat &rFormat);
+
+    bool            operator == (const SmFormat &rFormat) const;
+    inline bool     operator != (const SmFormat &rFormat) const;
+
+    void RequestApplyChanges()
+    {
+        Broadcast(SfxHint(SfxHintId::MathFormatChanged));
+    }
+
+};
+
+inline bool    SmFormat::operator != (const SmFormat &rFormat) const
+{
+    return !(*this == rFormat);
+}
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/starmath/inc/helpids.h b/starmath/inc/helpids.h
new file mode 100644
index 000000000..7e13c3ac8
--- /dev/null
+++ b/starmath/inc/helpids.h
@@ -0,0 +1,54 @@
+/* -*- 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 .
+ */
+#ifndef INCLUDED_STARMATH_INC_HELPIDS_H
+#define INCLUDED_STARMATH_INC_HELPIDS_H
+
+#define HID_SMA_WIN_DOCUMENT                              "STARMATH_HID_SMA_WIN_DOCUMENT"
+#define HID_SMA_COMMAND_WIN_EDIT                          "STARMATH_HID_SMA_COMMAND_WIN_EDIT"
+
+#define HID_SMA_COMMAND_WIN                               "STARMATH_HID_SMA_COMMAND_WIN"
+
+#define HID_SMA_DEFAULT_DIST                              "STARMATH_HID_SMA_DEFAULT_DIST"
+#define HID_SMA_LINE_DIST                                 "STARMATH_HID_SMA_LINE_DIST"
+#define HID_SMA_ROOT_DIST                                 "STARMATH_HID_SMA_ROOT_DIST"
+#define HID_SMA_SUP_DIST                                  "STARMATH_HID_SMA_SUP_DIST"
+#define HID_SMA_SUB_DIST                                  "STARMATH_HID_SMA_SUB_DIST"
+#define HID_SMA_NUMERATOR_DIST                            "STARMATH_HID_SMA_NUMERATOR_DIST"
+#define HID_SMA_DENOMINATOR_DIST                          "STARMATH_HID_SMA_DENOMINATOR_DIST"
+#define HID_SMA_FRACLINE_EXCWIDTH                         "STARMATH_HID_SMA_FRACLINE_EXCWIDTH"
+#define HID_SMA_FRACLINE_LINEWIDTH                        "STARMATH_HID_SMA_FRACLINE_LINEWIDTH"
+#define HID_SMA_UPPERLIMIT_DIST                           "STARMATH_HID_SMA_UPPERLIMIT_DIST"
+#define HID_SMA_LOWERLIMIT_DIST                           "STARMATH_HID_SMA_LOWERLIMIT_DIST"
+#define HID_SMA_BRACKET_EXCHEIGHT                         "STARMATH_HID_SMA_BRACKET_EXCHEIGHT"
+#define HID_SMA_BRACKET_DIST                              "STARMATH_HID_SMA_BRACKET_DIST"
+#define HID_SMA_MATRIXROW_DIST                            "STARMATH_HID_SMA_MATRIXROW_DIST"
+#define HID_SMA_MATRIXCOL_DIST                            "STARMATH_HID_SMA_MATRIXCOL_DIST"
+#define HID_SMA_ATTRIBUT_DIST                             "STARMATH_HID_SMA_ATTRIBUT_DIST"
+#define HID_SMA_INTERATTRIBUT_DIST                        "STARMATH_HID_SMA_INTERATTRIBUT_DIST"
+#define HID_SMA_OPERATOR_EXCHEIGHT                        "STARMATH_HID_SMA_OPERATOR_EXCHEIGHT"
+#define HID_SMA_OPERATOR_DIST                             "STARMATH_HID_SMA_OPERATOR_DIST"
+#define HID_SMA_LEFTBORDER_DIST                           "STARMATH_HID_SMA_LEFTBORDER_DIST"
+#define HID_SMA_RIGHTBORDER_DIST                          "STARMATH_HID_SMA_RIGHTBORDER_DIST"
+#define HID_SMA_UPPERBORDER_DIST                          "STARMATH_HID_SMA_UPPERBORDER_DIST"
+#define HID_SMA_LOWERBORDER_DIST                          "STARMATH_HID_SMA_LOWERBORDER_DIST"
+#define HID_SMA_BRACKET_EXCHEIGHT2                        "STARMATH_HID_SMA_BRACKET_EXCHEIGHT2"
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/starmath/inc/node.hxx b/starmath/inc/node.hxx
new file mode 100644
index 000000000..1e301369c
--- /dev/null
+++ b/starmath/inc/node.hxx
@@ -0,0 +1,1272 @@
+/* -*- 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 .
+ */
+
+#ifndef INCLUDED_STARMATH_INC_NODE_HXX
+#define INCLUDED_STARMATH_INC_NODE_HXX
+
+#include "types.hxx"
+#include "token.hxx"
+#include "rect.hxx"
+#include "format.hxx"
+
+#include <o3tl/typed_flags_set.hxx>
+#include <rtl/ustrbuf.hxx>
+
+#include <cassert>
+#include <vector>
+
+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
+};
+
+enum class SmNodeType
+{
+/* 0*/ Table,       Brace,         Bracebody,     Oper,        Align,
+/* 5*/ Attribut,    Font,          UnHor,         BinHor,      BinVer,
+/*10*/ BinDiagonal, SubSup,        Matrix,        Place,       Text,
+/*15*/ Special,     GlyphSpecial,  Math,          Blank,       Error,
+/*20*/ Line,        Expression,    PolyLine,      Root,        RootSymbol,
+/*25*/ Rectangle,   VerticalBrace, MathIdent
+};
+
+
+class SmNode : public SmRect
+{
+    SmFace      maFace;
+
+    SmToken     maNodeToken;
+    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();
+
+    /**
+     * Returns true if this is an instance of SmVisibleNode's subclass, false otherwise.
+     */
+    virtual bool        IsVisible() const = 0;
+
+    virtual size_t      GetNumSubNodes() const = 0;
+    virtual SmNode *    GetSubNode(size_t nIndex) = 0;
+            const SmNode * GetSubNode(size_t nIndex) const
+            {
+                return const_cast<SmNode *>(this)->GetSubNode(nIndex);
+            }
+
+    virtual const SmNode * GetLeftMost() const;
+
+            FontChangeMask &Flags() { return mnFlags; }
+            FontAttribute  &Attributes() { return mnAttributes; }
+
+            bool IsPhantom() const { return mbIsPhantom; }
+            void SetPhantom(bool bIsPhantom);
+            void SetColor(const Color &rColor);
+
+            void SetAttribut(FontAttribute nAttrib);
+            void ClearAttribut(FontAttribute nAttrib);
+
+            const SmFace & GetFont() const { return maFace; };
+                  SmFace & GetFont()       { return maFace; };
+
+            void SetFont(const SmFace &rFace);
+            void SetFontSize(const Fraction &rRelSize, FontSizeType nType);
+            void SetSize(const Fraction &rScale);
+
+    /** Prepare preliminary settings about font and text
+     *  (e.g. maFace, meRectHorAlign, mnFlags, mnAttributes, etc.)
+     */
+    virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell, int nDepth);
+    void PrepareAttributes();
+
+    void         SetRectHorAlign(RectHorAlign eHorAlign, bool bApplyToSubTree = true );
+    RectHorAlign GetRectHorAlign() const { return meRectHorAlign; }
+
+    const SmRect & GetRect() const { return *this; }
+
+    void Move(const Point &rPosition);
+    void MoveTo(const Point &rPosition) { Move(rPosition - GetTopLeft()); }
+    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;
+
+    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); }
+
+    SmScaleMode     GetScaleMode() const { return meScaleMode; }
+    void            SetScaleMode(SmScaleMode eMode) { meScaleMode = eMode; }
+
+    virtual void AdaptToX(OutputDevice &rDev, sal_uLong nWidth);
+    virtual void AdaptToY(OutputDevice &rDev, sal_uLong nHeight);
+
+    SmNodeType      GetType() const  { return meType; }
+    const SmToken & GetToken() const { return maNodeToken; }
+
+    const SmNode *  FindTokenAt(sal_uInt16 nRow, sal_uInt16 nCol) const;
+    const SmNode *  FindRectClosestTo(const Point &rPoint) const;
+
+    /** Accept a visitor
+     * Calls the method for this class on the visitor
+     */
+    virtual void Accept(SmVisitor* pVisitor) = 0;
+
+    /** True if this node is selected */
+    bool IsSelected() const {return mbIsSelected;}
+    void SetSelected(bool Selected) {mbIsSelected = Selected;}
+
+    /** Get the parent node of this node */
+    SmStructureNode* GetParent(){ return mpParentNode; }
+    const SmStructureNode* GetParent() const { return mpParentNode; }
+    /** Set the parent node */
+    void SetParent(SmStructureNode* parent){
+        mpParentNode = parent;
+    }
+
+    /** Set the token for this node */
+    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;
+
+    virtual bool        IsVisible() const override;
+
+    virtual size_t      GetNumSubNodes() const override;
+
+    using   SmNode::GetSubNode;
+    virtual SmNode *    GetSubNode(size_t nIndex) override;
+    void ClearSubNodes();
+            void SetSubNodes(std::unique_ptr<SmNode> pFirst, std::unique_ptr<SmNode> pSecond, std::unique_ptr<SmNode> pThird = nullptr);
+            void SetSubNodes(SmNodeArray&& rNodeArray);
+
+    virtual void  GetAccessibleText( OUStringBuffer &rText ) const override;
+
+    SmNodeArray::iterator begin() {return maSubNodes.begin();}
+    SmNodeArray::iterator end() {return maSubNodes.end();}
+    SmNodeArray::reverse_iterator rbegin() {return maSubNodes.rbegin();}
+    SmNodeArray::reverse_iterator rend() {return maSubNodes.rend();}
+
+    /** Get the index of a child node
+     *
+     * Returns -1, if pSubNode isn't a subnode of this.
+     */
+    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;
+    }
+
+    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);
+    }
+
+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:
+
+    virtual bool        IsVisible() const override;
+    virtual size_t      GetNumSubNodes() const override;
+    using   SmNode::GetSubNode;
+    virtual SmNode *    GetSubNode(size_t nIndex) override;
+};
+
+
+class SmGraphicNode : public SmVisibleNode
+{
+protected:
+    SmGraphicNode(SmNodeType eNodeType, const SmToken &rNodeToken)
+    :   SmVisibleNode(eNodeType, rNodeToken)
+    {}
+
+public:
+
+    virtual void  GetAccessibleText( OUStringBuffer &rText ) const override;
+};
+
+
+/** 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)
+    {}
+
+    virtual void AdaptToX(OutputDevice &rDev, sal_uLong nWidth) override;
+    virtual void AdaptToY(OutputDevice &rDev, sal_uLong nHeight) override;
+
+    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
+
+    void CreateTextFromNode(OUStringBuffer &rText) override;
+    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;
+    long mnWidth;
+
+public:
+    explicit SmPolyLineNode(const SmToken &rNodeToken);
+
+    long         GetWidth() const { return mnWidth; }
+    tools::Polygon &GetPolygon() { return maPoly; }
+
+    virtual void AdaptToX(OutputDevice &rDev, sal_uLong nWidth) override;
+    virtual void AdaptToY(OutputDevice &rDev, sal_uLong nHeight) override;
+
+    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
+
+    void Accept(SmVisitor* pVisitor) override;
+};
+
+
+/** Text node
+ *
+ * @remarks This class also serves as baseclass for all nodes that contains text.
+ */
+class SmTextNode : public SmVisibleNode
+{
+    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 );
+
+    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;
+    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
+    virtual void CreateTextFromNode(OUStringBuffer &rText) override;
+
+    virtual void  GetAccessibleText( OUStringBuffer &rText ) const override;
+    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.
+    */
+    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);
+
+    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;
+};
+
+
+/** 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)
+    {}
+
+    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
+    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)
+    {
+        sal_Unicode cChar = GetToken().cMathChar;
+        if (u'\0' != cChar)
+            SetText(OUString(cChar));
+    }
+
+public:
+    explicit SmMathSymbolNode(const SmToken &rNodeToken);
+
+    virtual void AdaptToX(OutputDevice &rDev, sal_uLong nWidth) override;
+    virtual void AdaptToY(OutputDevice &rDev, sal_uLong nHeight) override;
+
+    virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell, int nDepth) override;
+    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
+    void CreateTextFromNode(OUStringBuffer &rText) override;
+    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)
+    {
+    }
+
+    sal_uLong GetBodyWidth() const {return mnBodyWidth;};
+    virtual void AdaptToX(OutputDevice &rDev, sal_uLong nHeight) override;
+    virtual void AdaptToY(OutputDevice &rDev, sal_uLong nHeight) override;
+
+    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, "<?>")) {};
+
+    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;
+};
+
+
+/** 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));
+    }
+
+    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;
+};
+
+
+/** 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
+{
+    long mnFormulaBaseline;
+public:
+    explicit SmTableNode(const SmToken &rNodeToken)
+        : SmStructureNode(SmNodeType::Table, rNodeToken)
+        , mnFormulaBaseline(0)
+    {
+    }
+
+    virtual const SmNode * GetLeftMost() const override;
+
+    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
+    long GetFormulaBaseline() const;
+
+    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)
+    {
+    }
+
+    void  SetUseExtraSpaces(bool bVal) { mbUseExtraSpaces = bVal; }
+    bool  IsUseExtraSpaces() const { return mbUseExtraSpaces; };
+
+    virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell, int nDepth) override;
+    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
+    void Accept(SmVisitor* pVisitor) override;
+};
+
+
+/** 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)
+    {}
+
+    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
+    void CreateTextFromNode(OUStringBuffer &rText) override;
+    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)
+    {
+    }
+
+    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
+    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)
+    {
+    }
+
+    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
+    void CreateTextFromNode(OUStringBuffer &rText) override;
+    void Accept(SmVisitor* pVisitor) override;
+
+    SmNode* Argument();
+    const SmNode* Argument() const;
+    SmRootSymbolNode* Symbol();
+    const SmRootSymbolNode* Symbol() const;
+    SmNode* Body();
+    const SmNode* Body() const;
+};
+
+
+/** 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)
+    {
+    }
+
+    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
+    void Accept(SmVisitor* pVisitor) override;
+
+    SmNode* Symbol();
+    const SmNode* Symbol() const;
+    SmNode* LeftOperand();
+    const SmNode* LeftOperand() const;
+    SmNode* RightOperand();
+    const SmNode* RightOperand() const;
+};
+
+
+/** 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;
+
+    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
+    void CreateTextFromNode(OUStringBuffer &rText) override;
+    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;
+
+    void    GetOperPosSize(Point &rPos, Size &rSize,
+                           const Point &rDiagPoint, double fAngleDeg) const;
+
+public:
+    explicit SmBinDiagonalNode(const SmToken &rNodeToken)
+        : SmStructureNode(SmNodeType::BinDiagonal, rNodeToken, 3)
+        , mbAscending(false)
+    {
+    }
+
+    bool    IsAscending() const { return mbAscending; }
+    void    SetAscending(bool bVal)  { mbAscending = bVal; }
+
+    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
+    void Accept(SmVisitor* pVisitor) override;
+};
+
+
+/** Enum 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)
+    {
+    }
+
+    /** Get body (Not NULL) */
+    SmNode *       GetBody()    { return GetSubNode(0); }
+    /** Get body (Not NULL) */
+    const SmNode * GetBody() const
+    {
+        return const_cast<SmSubSupNode *>(this)->GetBody();
+    }
+
+    void  SetUseLimits(bool bVal) { mbUseLimits = bVal; }
+    bool  IsUseLimits() const { return mbUseLimits; };
+
+    /** Get super- or subscript
+     * @remarks this method may return NULL.
+     */
+    SmNode * GetSubSup(SmSubSup eSubSup) { return GetSubNode(1 + eSubSup); };
+    const SmNode * GetSubSup(SmSubSup eSubSup) const { return const_cast< SmSubSupNode* >( this )->GetSubSup( eSubSup ); }
+
+    /** Set the body */
+    void SetBody(SmNode* pBody) { SetSubNode(0, pBody); }
+    void SetSubSup(SmSubSup eSubSup, SmNode* pScript) { SetSubNode( 1 + eSubSup, pScript); }
+
+    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
+    void CreateTextFromNode(OUStringBuffer &rText) override;
+    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)
+    {
+    }
+
+    SmMathSymbolNode* OpeningBrace();
+    const SmMathSymbolNode* OpeningBrace() const;
+    SmNode* Body();
+    const SmNode* Body() const;
+    SmMathSymbolNode* ClosingBrace();
+    const SmMathSymbolNode* ClosingBrace() const;
+
+    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
+    void CreateTextFromNode(OUStringBuffer &rText) override;
+    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
+{
+    long mnBodyHeight;
+
+public:
+    explicit SmBracebodyNode(const SmToken &rNodeToken)
+        : SmStructureNode(SmNodeType::Bracebody, rNodeToken)
+        , mnBodyHeight(0)
+    {
+    }
+
+    virtual void    Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
+    long GetBodyHeight() const { return mnBodyHeight; }
+    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 inline SmVerticalBraceNode(const SmToken &rNodeToken);
+
+    SmNode* Body();
+    const SmNode* Body() const;
+    SmMathSymbolNode* Brace();
+    const SmMathSymbolNode* Brace() const;
+    SmNode* Script();
+    const SmNode* Script() const;
+
+    virtual void    Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
+    void Accept(SmVisitor* pVisitor) override;
+};
+
+
+inline SmVerticalBraceNode::SmVerticalBraceNode(const SmToken &rNodeToken)
+    : SmStructureNode(SmNodeType::VerticalBrace, rNodeToken, 3)
+{
+}
+
+
+/** 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)
+    {
+    }
+
+    SmNode *       GetSymbol();
+    const SmNode * GetSymbol() const
+    {
+        return const_cast<SmOperNode *>(this)->GetSymbol();
+    }
+
+    long CalcSymbolHeight(const SmNode &rSymbol, const SmFormat &rFormat) const;
+
+    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
+    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)
+    {}
+
+    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
+    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 SmAttributNode final : public SmStructureNode
+{
+public:
+    explicit SmAttributNode(const SmToken &rNodeToken)
+        : SmStructureNode(SmNodeType::Attribut, rNodeToken, 2)
+    {}
+
+    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
+    void CreateTextFromNode(OUStringBuffer &rText) override;
+    void Accept(SmVisitor* pVisitor) override;
+
+    SmNode* Attribute();
+    const SmNode* Attribute() const;
+    SmNode* Body();
+    const SmNode* Body() const;
+};
+
+
+/** 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)
+    {
+    }
+
+    void SetSizeParameter(const Fraction &rValue, FontSizeType nType);
+    const Fraction & GetSizeParameter() const {return maFontSize;}
+    FontSizeType GetSizeType() const {return meSizeType;}
+
+    virtual void Prepare(const SmFormat &rFormat, const SmDocShell &rDocShell, int nDepth) override;
+    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
+    void CreateTextFromNode(OUStringBuffer &rText) override;
+    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)
+    {
+    }
+
+    sal_uInt16 GetNumRows() const {return mnNumRows;}
+    sal_uInt16 GetNumCols() const {return mnNumCols;}
+    void SetRowCol(sal_uInt16 nMatrixRows, sal_uInt16 nMatrixCols);
+
+    virtual const SmNode * GetLeftMost() const override;
+
+    virtual void Arrange(OutputDevice &rDev, const SmFormat &rFormat) override;
+    void CreateTextFromNode(OUStringBuffer &rText) override;
+    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; }
+
+    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();
+}
+
+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();
+}
+
+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();
+}
+
+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
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/starmath/inc/parse.hxx b/starmath/inc/parse.hxx
new file mode 100644
index 000000000..519a90041
--- /dev/null
+++ b/starmath/inc/parse.hxx
@@ -0,0 +1,156 @@
+/* -*- 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 .
+ */
+#ifndef INCLUDED_STARMATH_INC_PARSE_HXX
+#define INCLUDED_STARMATH_INC_PARSE_HXX
+
+#include <unotools/charclass.hxx>
+#include <memory>
+#include <set>
+#include <vector>
+
+#include "token.hxx"
+#include "error.hxx"
+
+class SmBlankNode;
+class SmBracebodyNode;
+class SmExpressionNode;
+class SmGlyphSpecialNode;
+class SmNode;
+class SmOperNode;
+class SmSpecialNode;
+class SmStructureNode;
+class SmTableNode;
+class SmTextNode;
+
+#define DEPTH_LIMIT 1024
+
+class SmParser
+{
+    OUString        m_aBufferString;
+    SmToken         m_aCurToken;
+    std::vector<std::unique_ptr<SmErrorDesc>> m_aErrDescList;
+    int             m_nCurError;
+    sal_Int32       m_nBufferIndex,
+                    m_nTokenIndex;
+    sal_Int32       m_nRow,    // 1-based
+                    m_nColOff; // 0-based
+    bool            m_bImportSymNames,
+                    m_bExportSymNames;
+    sal_Int32       m_nParseDepth;
+
+    class DepthProtect
+    {
+    private:
+        sal_Int32& m_rParseDepth;
+    public:
+        DepthProtect(sal_Int32& rParseDepth)
+            : m_rParseDepth(rParseDepth)
+        {
+            ++m_rParseDepth;
+        }
+        bool TooDeep() const { return m_rParseDepth > DEPTH_LIMIT; }
+        ~DepthProtect()
+        {
+            --m_rParseDepth;
+        }
+    };
+
+    // map of used symbols (used to reduce file size by exporting only actually used symbols)
+    std::set< OUString >   m_aUsedSymbols;
+
+    // CharClass representing a locale for parsing numbers
+    CharClass m_aNumCC;
+    // pointer to System locale's CharClass, which is alive inside SM_MOD()
+    const CharClass* m_pSysCC;
+
+    SmParser(const SmParser&) = delete;
+    SmParser& operator=(const SmParser&) = delete;
+
+    void            NextToken();
+    sal_Int32       GetTokenIndex() const   { return m_nTokenIndex; }
+    void            Replace( sal_Int32 nPos, sal_Int32 nLen, const OUString &rText );
+
+    inline bool     TokenInGroup( TG nGroup );
+
+    // grammar
+    std::unique_ptr<SmTableNode> DoTable();
+    std::unique_ptr<SmNode> DoLine();
+    std::unique_ptr<SmNode> DoExpression(bool bUseExtraSpaces = true);
+    std::unique_ptr<SmNode> DoRelation();
+    std::unique_ptr<SmNode> DoSum();
+    std::unique_ptr<SmNode> DoProduct();
+    std::unique_ptr<SmNode> DoSubSup(TG nActiveGroup, SmNode *pGivenNode);
+    std::unique_ptr<SmNode> DoOpSubSup();
+    std::unique_ptr<SmNode> DoPower();
+    std::unique_ptr<SmBlankNode> DoBlank();
+    std::unique_ptr<SmNode> DoTerm(bool bGroupNumberIdent);
+    std::unique_ptr<SmNode> DoEscape();
+    std::unique_ptr<SmOperNode> DoOperator();
+    std::unique_ptr<SmNode> DoOper();
+    std::unique_ptr<SmStructureNode> DoUnOper();
+    std::unique_ptr<SmNode> DoAlign(bool bUseExtraSpaces = true);
+    std::unique_ptr<SmStructureNode> DoFontAttribut();
+    std::unique_ptr<SmStructureNode> DoAttribut();
+    std::unique_ptr<SmStructureNode> DoFont();
+    std::unique_ptr<SmStructureNode> DoFontSize();
+    std::unique_ptr<SmStructureNode> DoColor();
+    std::unique_ptr<SmStructureNode> DoBrace();
+    std::unique_ptr<SmBracebodyNode> DoBracebody(bool bIsLeftRight);
+    std::unique_ptr<SmTextNode> DoFunction();
+    std::unique_ptr<SmTableNode> DoBinom();
+    std::unique_ptr<SmStructureNode> DoStack();
+    std::unique_ptr<SmStructureNode> DoMatrix();
+    std::unique_ptr<SmSpecialNode> DoSpecial();
+    std::unique_ptr<SmGlyphSpecialNode> DoGlyphSpecial();
+    std::unique_ptr<SmExpressionNode> DoError(SmParseError Error);
+    // end of grammar
+
+public:
+                 SmParser();
+
+    /** Parse rBuffer to formula tree */
+    std::unique_ptr<SmTableNode> Parse(const OUString &rBuffer);
+    /** Parse rBuffer to formula subtree that constitutes an expression */
+    std::unique_ptr<SmNode> ParseExpression(const OUString &rBuffer);
+
+    const OUString & GetText() const { return m_aBufferString; };
+
+    bool        IsImportSymbolNames() const        { return m_bImportSymNames; }
+    void        SetImportSymbolNames(bool bVal)    { m_bImportSymNames = bVal; }
+    bool        IsExportSymbolNames() const        { return m_bExportSymNames; }
+    void        SetExportSymbolNames(bool bVal)    { m_bExportSymNames = bVal; }
+
+    void        AddError(SmParseError Type, SmNode *pNode);
+    const SmErrorDesc*  NextError();
+    const SmErrorDesc*  PrevError();
+    const SmErrorDesc*  GetError();
+    static const SmTokenTableEntry* GetTokenTableEntry( const OUString &rName );
+    const std::set< OUString >&   GetUsedSymbols() const      { return m_aUsedSymbols; }
+};
+
+
+inline bool SmParser::TokenInGroup( TG nGroup)
+{
+    return bool(m_aCurToken.nGroup & nGroup);
+}
+
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/starmath/inc/pch/precompiled_sm.cxx b/starmath/inc/pch/precompiled_sm.cxx
new file mode 100644
index 000000000..f5d78e96f
--- /dev/null
+++ b/starmath/inc/pch/precompiled_sm.cxx
@@ -0,0 +1,12 @@
+/* -*- 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/.
+ */
+
+#include "precompiled_sm.hxx"
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/starmath/inc/pch/precompiled_sm.hxx b/starmath/inc/pch/precompiled_sm.hxx
new file mode 100644
index 000000000..f1239ec47
--- /dev/null
+++ b/starmath/inc/pch/precompiled_sm.hxx
@@ -0,0 +1,157 @@
+/* -*- 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 has been autogenerated by update_pch.sh. It is possible to edit it
+ manually (such as when an include file has been moved/renamed/removed). All such
+ manual changes will be rewritten by the next run of update_pch.sh (which presumably
+ also fixes all possible problems, so it's usually better to use it).
+
+ Generated on 2020-04-25 20:55:30 using:
+ ./bin/update_pch starmath sm --cutoff=5 --exclude:system --exclude:module --include:local
+
+ If after updating build fails, use the following command to locate conflicting headers:
+ ./bin/update_pch_bisect ./starmath/inc/pch/precompiled_sm.hxx "make starmath.build" --find-conflicts
+*/
+
+#if PCH_LEVEL >= 1
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <cstring>
+#include <functional>
+#include <limits.h>
+#include <limits>
+#include <list>
+#include <map>
+#include <memory>
+#include <new>
+#include <optional>
+#include <ostream>
+#include <string_view>
+#include <type_traits>
+#include <utility>
+#include <vector>
+#include <boost/property_tree/ptree_fwd.hpp>
+#endif // PCH_LEVEL >= 1
+#if PCH_LEVEL >= 2
+#include <osl/diagnose.h>
+#include <osl/endian.h>
+#include <osl/mutex.hxx>
+#include <rtl/alloc.h>
+#include <rtl/character.hxx>
+#include <rtl/instance.hxx>
+#include <rtl/locale.h>
+#include <rtl/math.hxx>
+#include <rtl/ref.hxx>
+#include <rtl/string.hxx>
+#include <rtl/stringconcat.hxx>
+#include <rtl/stringutils.hxx>
+#include <rtl/textenc.h>
+#include <rtl/ustrbuf.h>
+#include <rtl/ustrbuf.hxx>
+#include <rtl/ustring.h>
+#include <rtl/ustring.hxx>
+#include <rtl/uuid.h>
+#include <sal/config.h>
+#include <sal/log.hxx>
+#include <sal/types.h>
+#include <vcl/IDialogRenderable.hxx>
+#include <vcl/bitmap.hxx>
+#include <vcl/cairo.hxx>
+#include <vcl/devicecoordinate.hxx>
+#include <vcl/dllapi.h>
+#include <vcl/errcode.hxx>
+#include <vcl/font.hxx>
+#include <vcl/keycod.hxx>
+#include <vcl/keycodes.hxx>
+#include <vcl/mapmod.hxx>
+#include <vcl/metaactiontypes.hxx>
+#include <vcl/outdev.hxx>
+#include <vcl/outdevmap.hxx>
+#include <vcl/outdevstate.hxx>
+#include <vcl/region.hxx>
+#include <vcl/salnativewidgets.hxx>
+#include <vcl/settings.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/uitest/factory.hxx>
+#include <vcl/vclenum.hxx>
+#include <vcl/vclevent.hxx>
+#include <vcl/vclptr.hxx>
+#include <vcl/vclreferencebase.hxx>
+#include <vcl/virdev.hxx>
+#include <vcl/wall.hxx>
+#endif // PCH_LEVEL >= 2
+#if PCH_LEVEL >= 3
+#include <basegfx/color/bcolor.hxx>
+#include <basegfx/numeric/ftools.hxx>
+#include <basegfx/polygon/b2dpolypolygon.hxx>
+#include <basegfx/vector/b2enums.hxx>
+#include <com/sun/star/drawing/LineCap.hpp>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <com/sun/star/lang/XUnoTunnel.hpp>
+#include <com/sun/star/uno/Any.hxx>
+#include <com/sun/star/uno/Reference.h>
+#include <com/sun/star/uno/Reference.hxx>
+#include <com/sun/star/uno/Sequence.hxx>
+#include <comphelper/comphelperdllapi.h>
+#include <cppuhelper/implbase.hxx>
+#include <cppuhelper/supportsservice.hxx>
+#include <editeng/editdata.hxx>
+#include <editeng/editengdllapi.h>
+#include <editeng/editstat.hxx>
+#include <i18nlangtag/lang.h>
+#include <o3tl/cow_wrapper.hxx>
+#include <o3tl/strong_int.hxx>
+#include <o3tl/typed_flags_set.hxx>
+#include <salhelper/simplereferenceobject.hxx>
+#include <sfx2/dllapi.h>
+#include <sfx2/docfile.hxx>
+#include <sfx2/shell.hxx>
+#include <sot/formats.hxx>
+#include <sot/storage.hxx>
+#include <svl/SfxBroadcaster.hxx>
+#include <svl/hint.hxx>
+#include <svl/itemset.hxx>
+#include <svl/languageoptions.hxx>
+#include <svl/poolitem.hxx>
+#include <svl/stritem.hxx>
+#include <svl/svldllapi.h>
+#include <svl/typedwhich.hxx>
+#include <svtools/colorcfg.hxx>
+#include <svx/svxdllapi.h>
+#include <tools/color.hxx>
+#include <tools/gen.hxx>
+#include <tools/lineend.hxx>
+#include <tools/link.hxx>
+#include <tools/mapunit.hxx>
+#include <tools/poly.hxx>
+#include <tools/ref.hxx>
+#include <tools/solar.h>
+#include <tools/toolsdllapi.h>
+#include <unotools/configitem.hxx>
+#include <unotools/fontdefs.hxx>
+#include <unotools/options.hxx>
+#include <unotools/unotoolsdllapi.h>
+#include <xmloff/dllapi.h>
+#endif // PCH_LEVEL >= 3
+#if PCH_LEVEL >= 4
+#include <ElementsDockingWindow.hxx>
+#include <dialog.hxx>
+#include <document.hxx>
+#include <node.hxx>
+#include <smmod.hxx>
+#include <symbol.hxx>
+#include <unomodel.hxx>
+#include <utility.hxx>
+#include <view.hxx>
+#include <visitors.hxx>
+#endif // PCH_LEVEL >= 4
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/starmath/inc/rect.hxx b/starmath/inc/rect.hxx
new file mode 100644
index 000000000..ce390b197
--- /dev/null
+++ b/starmath/inc/rect.hxx
@@ -0,0 +1,219 @@
+/* -*- 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 .
+ */
+
+#ifndef INCLUDED_STARMATH_INC_RECT_HXX
+#define INCLUDED_STARMATH_INC_RECT_HXX
+
+#include <rtl/ustring.hxx>
+#include <sal/log.hxx>
+#include <tools/gen.hxx>
+#include <vcl/outdev.hxx>
+
+class SmFormat;
+
+
+inline long SmFromTo(long nFrom, long nTo, double fRelDist)
+{
+    return nFrom + static_cast<long>(fRelDist * (nTo - nFrom));
+}
+
+
+// SmRect
+// ... (to be done)
+// This Implementation assumes that the x-axis points to the right and the
+// y-axis to the bottom.
+// Note: however, italic spaces can be negative!
+
+
+// possible positions and alignments for the 'AlignTo' function
+enum class RectPos
+{
+    Left, // align the current object to the left of the argument
+    Right,
+    Top,
+    Bottom,
+    Attribute
+};
+
+enum class RectHorAlign
+{
+    Left,
+    Center,
+    Right
+};
+
+enum class RectVerAlign
+{
+    Top,
+    Mid,
+    Bottom,
+    Baseline,
+    CenterY,
+    AttributeHi,
+    AttributeMid,
+    AttributeLo
+};
+
+// different methods of copying baselines and mid's in 'ExtendBy' function
+enum class RectCopyMBL
+{
+    This,   // keep baseline of current object even if it has none
+    Arg,    // as above but for the argument
+    None,   // result will have no baseline
+    Xor     // if current object has a baseline keep it else copy
+            //   the arguments baseline (even if it has none)
+};
+
+
+class SmRect
+{
+    Point   aTopLeft;
+    Size    aSize;
+    long    nBaseline,
+            nAlignT,
+            nAlignM,
+            nAlignB,
+            nGlyphTop,
+            nGlyphBottom,
+            nItalicLeftSpace,
+            nItalicRightSpace,
+            nLoAttrFence,
+            nHiAttrFence;
+    sal_uInt16  nBorderWidth;
+    bool    bHasBaseline,
+            bHasAlignInfo;
+
+    inline  void CopyMBL(const SmRect& rRect);
+            void CopyAlignInfo(const SmRect& rRect);
+
+            void Union(const SmRect &rRect);
+
+public:
+            SmRect();
+            SmRect(const OutputDevice &rDev, const SmFormat *pFormat,
+                   const OUString &rText, sal_uInt16 nBorderWidth);
+            SmRect(long nWidth, long nHeight);
+
+
+            sal_uInt16  GetBorderWidth() const  { return nBorderWidth; }
+
+            void SetItalicSpaces(long nLeftSpace, long nRightSpace);
+
+            void SetWidth(sal_uLong nWidth)     { aSize.setWidth(nWidth); }
+
+            void SetLeft(long nLeft);
+            void SetRight(long nRight);
+            void SetBottom(long nBottom);
+            void SetTop(long nTop);
+
+            const Point & GetTopLeft() const { return aTopLeft; }
+
+            long GetTop()     const { return GetTopLeft().Y(); }
+            long GetLeft()    const { return GetTopLeft().X(); }
+            long GetBottom()  const { return GetTop() + GetHeight() - 1; }
+            long GetRight()   const { return GetLeft() + GetWidth() - 1; }
+            long GetCenterY() const { return (GetTop() + GetBottom()) / 2; }
+            long GetWidth()   const { return GetSize().Width(); }
+            long GetHeight()  const { return GetSize().Height(); }
+
+            long GetItalicLeftSpace()  const { return nItalicLeftSpace; }
+            long GetItalicRightSpace() const { return nItalicRightSpace; }
+
+            long GetHiAttrFence() const     { return nHiAttrFence; }
+            long GetLoAttrFence() const     { return nLoAttrFence; }
+
+            long GetItalicLeft() const      { return GetLeft() - GetItalicLeftSpace(); }
+            long GetItalicCenterX() const   { return (GetItalicLeft() + GetItalicRight()) / 2; }
+            long GetItalicRight() const     { return GetRight() + GetItalicRightSpace(); }
+            long GetItalicWidth() const     { return GetWidth() + GetItalicLeftSpace() + GetItalicRightSpace(); }
+
+            bool HasBaseline() const        { return bHasBaseline; }
+    inline  long GetBaseline() const;
+            long GetBaselineOffset() const  { return GetBaseline() - GetTop(); }
+
+            long GetAlignT() const  { return nAlignT; }
+            long GetAlignM() const  { return nAlignM; }
+            long GetAlignB() const  { return nAlignB; }
+
+            const Size & GetSize() const    { return aSize; }
+
+            Size  GetItalicSize() const
+            {   return Size(GetItalicWidth(), GetHeight()); }
+
+            void Move  (const Point &rPosition);
+            void MoveTo(const Point &rPosition) { Move(rPosition - GetTopLeft()); }
+
+            bool IsEmpty() const
+            {
+                return GetWidth() == 0  ||  GetHeight() == 0;
+            }
+
+            bool HasAlignInfo() const { return bHasAlignInfo; }
+
+            Point AlignTo(const SmRect &rRect, RectPos ePos,
+                                RectHorAlign eHor, RectVerAlign eVer) const;
+
+            SmRect & ExtendBy(const SmRect &rRect, RectCopyMBL eCopyMode);
+            void     ExtendBy(const SmRect &rRect, RectCopyMBL eCopyMode,
+                              long nNewAlignM);
+            SmRect & ExtendBy(const SmRect &rRect, RectCopyMBL eCopyMode,
+                      bool bKeepVerAlignParams);
+
+            long    OrientedDist(const Point &rPoint) const;
+            bool    IsInsideRect(const Point &rPoint) const;
+            bool    IsInsideItalicRect(const Point &rPoint) const;
+
+    inline  tools::Rectangle   AsRectangle() const;
+            SmRect      AsGlyphRect() const;
+};
+
+
+inline void SmRect::SetItalicSpaces(long nLeftSpace, long nRightSpace)
+    // set extra spacing to the left and right for (italic)
+    // letters/text
+{
+    nItalicLeftSpace  = nLeftSpace;
+    nItalicRightSpace = nRightSpace;
+}
+
+
+inline void SmRect::CopyMBL(const SmRect &rRect)
+    // copy AlignM baseline and value of 'rRect'
+{
+    nBaseline    = rRect.nBaseline;
+    bHasBaseline = rRect.bHasBaseline;
+    nAlignM      = rRect.nAlignM;
+}
+
+
+inline long SmRect::GetBaseline() const
+{
+    SAL_WARN_IF( !HasBaseline(), "starmath", "Baseline does not exist" );
+    return nBaseline;
+}
+
+
+inline tools::Rectangle SmRect::AsRectangle() const
+{
+    return tools::Rectangle(Point(GetItalicLeft(), GetTop()), GetItalicSize());
+}
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/starmath/inc/smdll.hxx b/starmath/inc/smdll.hxx
new file mode 100644
index 000000000..3408f2fd4
--- /dev/null
+++ b/starmath/inc/smdll.hxx
@@ -0,0 +1,31 @@
+/* -*- 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 .
+ */
+#ifndef INCLUDED_STARMATH_INC_SMDLL_HXX
+#define INCLUDED_STARMATH_INC_SMDLL_HXX
+
+#include "smdllapi.hxx"
+
+namespace SmGlobals
+{
+    SM_DLLPUBLIC void ensure();
+}
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/starmath/inc/smdllapi.hxx b/starmath/inc/smdllapi.hxx
new file mode 100644
index 000000000..ad183991f
--- /dev/null
+++ b/starmath/inc/smdllapi.hxx
@@ -0,0 +1,23 @@
+/* -*- 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/.
+ */
+
+#ifndef INCLUDED_STARMATH_INC_SMDLLAPI_HXX
+#define INCLUDED_STARMATH_INC_SMDLLAPI_HXX
+
+#include <sal/types.h>
+
+#if defined(SM_DLLIMPLEMENTATION)
+#define SM_DLLPUBLIC SAL_DLLPUBLIC_EXPORT
+#else
+#define SM_DLLPUBLIC SAL_DLLPUBLIC_IMPORT
+#endif
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/starmath/inc/smmod.hrc b/starmath/inc/smmod.hrc
new file mode 100644
index 000000000..59a4a7cd8
--- /dev/null
+++ b/starmath/inc/smmod.hrc
@@ -0,0 +1,92 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
+/*
+ * 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/.
+ */
+#ifndef INCLUDED_VCL_INC_STRINGS_HRC
+#define INCLUDED_VCL_INC_STRINGS_HRC
+
+#define NC_(Context, String) reinterpret_cast<char const *>(Context "\004" u8##String)
+
+const char* RID_UI_SYMBOLSET_NAMES[] =
+{
+    NC_("RID_UI_SYMBOLSET_NAMES", "Greek"),
+    NC_("RID_UI_SYMBOLSET_NAMES", "Special")
+};
+
+const char* RID_UI_SYMBOL_NAMES[] =
+{
+    NC_("RID_UI_SYMBOL_NAMES", "alpha"),
+    NC_("RID_UI_SYMBOL_NAMES", "ALPHA"),
+    NC_("RID_UI_SYMBOL_NAMES", "beta"),
+    NC_("RID_UI_SYMBOL_NAMES", "BETA"),
+    NC_("RID_UI_SYMBOL_NAMES", "gamma"),
+    NC_("RID_UI_SYMBOL_NAMES", "GAMMA"),
+    NC_("RID_UI_SYMBOL_NAMES", "delta"),
+    NC_("RID_UI_SYMBOL_NAMES", "DELTA"),
+    NC_("RID_UI_SYMBOL_NAMES", "epsilon"),
+    NC_("RID_UI_SYMBOL_NAMES", "EPSILON"),
+    NC_("RID_UI_SYMBOL_NAMES", "zeta"),
+    NC_("RID_UI_SYMBOL_NAMES", "ZETA"),
+    NC_("RID_UI_SYMBOL_NAMES", "eta"),
+    NC_("RID_UI_SYMBOL_NAMES", "ETA"),
+    NC_("RID_UI_SYMBOL_NAMES", "theta"),
+    NC_("RID_UI_SYMBOL_NAMES", "THETA"),
+    NC_("RID_UI_SYMBOL_NAMES", "iota"),
+    NC_("RID_UI_SYMBOL_NAMES", "IOTA"),
+    NC_("RID_UI_SYMBOL_NAMES", "kappa"),
+    NC_("RID_UI_SYMBOL_NAMES", "KAPPA"),
+    NC_("RID_UI_SYMBOL_NAMES", "lambda"),
+    NC_("RID_UI_SYMBOL_NAMES", "LAMBDA"),
+    NC_("RID_UI_SYMBOL_NAMES", "mu"),
+    NC_("RID_UI_SYMBOL_NAMES", "MU"),
+    NC_("RID_UI_SYMBOL_NAMES", "nu"),
+    NC_("RID_UI_SYMBOL_NAMES", "NU"),
+    NC_("RID_UI_SYMBOL_NAMES", "xi"),
+    NC_("RID_UI_SYMBOL_NAMES", "XI"),
+    NC_("RID_UI_SYMBOL_NAMES", "omicron"),
+    NC_("RID_UI_SYMBOL_NAMES", "OMICRON"),
+    NC_("RID_UI_SYMBOL_NAMES", "pi"),
+    NC_("RID_UI_SYMBOL_NAMES", "PI"),
+    NC_("RID_UI_SYMBOL_NAMES", "rho"),
+    NC_("RID_UI_SYMBOL_NAMES", "RHO"),
+    NC_("RID_UI_SYMBOL_NAMES", "sigma"),
+    NC_("RID_UI_SYMBOL_NAMES", "SIGMA"),
+    NC_("RID_UI_SYMBOL_NAMES", "tau"),
+    NC_("RID_UI_SYMBOL_NAMES", "TAU"),
+    NC_("RID_UI_SYMBOL_NAMES", "upsilon"),
+    NC_("RID_UI_SYMBOL_NAMES", "UPSILON"),
+    NC_("RID_UI_SYMBOL_NAMES", "phi"),
+    NC_("RID_UI_SYMBOL_NAMES", "PHI"),
+    NC_("RID_UI_SYMBOL_NAMES", "chi"),
+    NC_("RID_UI_SYMBOL_NAMES", "CHI"),
+    NC_("RID_UI_SYMBOL_NAMES", "psi"),
+    NC_("RID_UI_SYMBOL_NAMES", "PSI"),
+    NC_("RID_UI_SYMBOL_NAMES", "omega"),
+    NC_("RID_UI_SYMBOL_NAMES", "OMEGA"),
+    NC_("RID_UI_SYMBOL_NAMES", "varepsilon"),
+    NC_("RID_UI_SYMBOL_NAMES", "vartheta"),
+    NC_("RID_UI_SYMBOL_NAMES", "varpi"),
+    NC_("RID_UI_SYMBOL_NAMES", "varrho"),
+    NC_("RID_UI_SYMBOL_NAMES", "varsigma"),
+    NC_("RID_UI_SYMBOL_NAMES", "varphi"),
+    NC_("RID_UI_SYMBOL_NAMES", "element"),
+    NC_("RID_UI_SYMBOL_NAMES", "noelement"),
+    NC_("RID_UI_SYMBOL_NAMES", "strictlylessthan"),
+    NC_("RID_UI_SYMBOL_NAMES", "strictlygreaterthan"),
+    NC_("RID_UI_SYMBOL_NAMES", "notequal"),
+    NC_("RID_UI_SYMBOL_NAMES", "identical"),
+    NC_("RID_UI_SYMBOL_NAMES", "tendto"),
+    NC_("RID_UI_SYMBOL_NAMES", "infinite"),
+    NC_("RID_UI_SYMBOL_NAMES", "angle"),
+    NC_("RID_UI_SYMBOL_NAMES", "perthousand"),
+    NC_("RID_UI_SYMBOL_NAMES", "and"),
+    NC_("RID_UI_SYMBOL_NAMES", "or")
+};
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */
diff --git a/starmath/inc/smmod.hxx b/starmath/inc/smmod.hxx
new file mode 100644
index 000000000..a8f1ac17c
--- /dev/null
+++ b/starmath/inc/smmod.hxx
@@ -0,0 +1,108 @@
+/* -*- 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 .
+ */
+
+#ifndef INCLUDED_STARMATH_INC_SMMOD_HXX
+#define INCLUDED_STARMATH_INC_SMMOD_HXX
+
+#include <sfx2/module.hxx>
+#include <sfx2/app.hxx>
+#include <vcl/vclptr.hxx>
+
+#include <unotools/options.hxx>
+#include <memory>
+
+namespace svtools { class ColorConfig; }
+
+class SfxObjectFactory;
+class SmSymbolManager;
+class SmMathConfig;
+
+/*************************************************************************
+|*
+|* This subclass of <SfxModule> (which is a subclass of <SfxShell>) is
+|* linked to the DLL. One instance of this class exists while the DLL is
+|* loaded.
+|*
+|* SdModule is like to be compared with the <SfxApplication>-subclass.
+|*
+|* Remember: Don`t export this class! It uses DLL-internal symbols.
+|*
+\************************************************************************/
+
+class SvtSysLocale;
+class VirtualDevice;
+
+
+OUString SmResId(const char* pId);
+
+class SmLocalizedSymbolData
+{
+public:
+    SmLocalizedSymbolData() = delete;
+
+    static OUString GetUiSymbolName( const OUString &rExportName );
+    static OUString GetExportSymbolName( const OUString &rUiName );
+
+    static OUString GetUiSymbolSetName( const OUString &rExportName );
+    static OUString GetExportSymbolSetName( const OUString &rUiName );
+};
+
+class SmModule final : public SfxModule, public utl::ConfigurationListener
+{
+    std::unique_ptr<svtools::ColorConfig> mpColorConfig;
+    std::unique_ptr<SmMathConfig> mpConfig;
+    std::unique_ptr<SmLocalizedSymbolData> mpLocSymbolData;
+    std::unique_ptr<SvtSysLocale> mpSysLocale;
+    VclPtr<VirtualDevice>    mpVirtualDev;
+
+public:
+    SFX_DECL_INTERFACE(SFX_INTERFACE_SMA_START + SfxInterfaceId(0))
+
+private:
+    /// SfxInterface initializer.
+    static void InitInterface_Impl();
+
+public:
+    explicit SmModule(SfxObjectFactory* pObjFact);
+    virtual ~SmModule() override;
+
+    virtual void ConfigurationChanged( utl::ConfigurationBroadcaster*, ConfigurationHints ) override;
+
+    svtools::ColorConfig &  GetColorConfig();
+
+    SmMathConfig *          GetConfig();
+    SmSymbolManager &       GetSymbolManager();
+
+    static void GetState(SfxItemSet&);
+
+    const SvtSysLocale& GetSysLocale();
+
+    VirtualDevice &     GetDefaultVirtualDev();
+
+    //virtual methods for options dialog
+    virtual std::unique_ptr<SfxItemSet> CreateItemSet( sal_uInt16 nId ) override;
+    virtual void         ApplyItemSet( sal_uInt16 nId, const SfxItemSet& rSet ) override;
+    virtual std::unique_ptr<SfxTabPage> CreateTabPage( sal_uInt16 nId, weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rSet ) override;
+};
+
+#define SM_MOD() ( static_cast<SmModule*>(SfxApplication::GetModule(SfxToolsModule::Math)) )
+
+#endif // INCLUDED_STARMATH_INC_SMMOD_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/starmath/inc/starmath.hrc b/starmath/inc/starmath.hrc
new file mode 100644
index 000000000..60fd52e7c
--- /dev/null
+++ b/starmath/inc/starmath.hrc
@@ -0,0 +1,74 @@
+/* -*- 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 .
+ */
+
+#ifndef INCLUDED_STARMATH_INC_STARMATH_HRC
+#define INCLUDED_STARMATH_INC_STARMATH_HRC
+
+#include <svl/solar.hrc>
+
+#define SID_NEXTERR                 (SID_SMA_START + 1)
+#define SID_PREVERR                 (SID_SMA_START + 2)
+#define SID_NEXTMARK                (SID_SMA_START + 3)
+#define SID_PREVMARK                (SID_SMA_START + 4)
+#define SID_SYMBOLS_CATALOGUE       (SID_SMA_START + 5)
+#define SID_ZOOMIN                  (SID_SMA_START + 10)
+#define SID_ZOOMOUT                 (SID_SMA_START + 11)
+#define SID_DRAW                    (SID_SMA_START + 12)
+#define SID_FORMULACURSOR           (SID_SMA_START + 15)
+#define SID_FONT                    (SID_SMA_START + 50)
+#define SID_FONTSIZE                (SID_SMA_START + 51)
+#define SID_DISTANCE                (SID_SMA_START + 52)
+#define SID_ALIGN                   (SID_SMA_START + 53)
+
+#define SID_AUTO_REDRAW             (SID_SMA_START + 55)
+#define SID_TEXTMODE                (SID_SMA_START + 57)
+#define SID_IMPORT_FORMULA          (SID_SMA_START + 58)
+#define SID_IMPORT_MATHML_CLIPBOARD (SID_SMA_START + 59)
+#define SID_TEXT                    (SID_SMA_START + 100)
+#define SID_GAPHIC_SM               (SID_SMA_START + 101)
+/** Command for inserting a symbol specified by a string (Inserts an SmSpecialNode) */
+#define SID_INSERTSPECIAL           (SID_SMA_START + 104)
+/** Command for inserting a math construction */
+#define SID_INSERTCOMMANDTEXT       (SID_SMA_START + 106)
+
+#define SID_LOADSYMBOLS             (SID_SMA_START + 107)
+#define SID_SAVESYMBOLS             (SID_SMA_START + 108)
+#define SID_MODIFYSTATUS            (SID_SMA_START + 110)
+#define SID_TEXTSTATUS              (SID_SMA_START + 111)
+
+#define SID_PRINTTITLE              (SID_SMA_START + 112)
+#define SID_PRINTTEXT               (SID_SMA_START + 113)
+#define SID_PRINTFRAME              (SID_SMA_START + 114)
+#define SID_PRINTSIZE               (SID_SMA_START + 115)
+#define SID_PRINTZOOM               (SID_SMA_START + 116)
+
+#define SID_COPYOBJECT              (SID_SMA_START + 117)
+#define SID_PASTEOBJECT             (SID_SMA_START + 118)
+#define SID_AUTOREDRAW              (SID_SMA_START + 119)
+
+#define SID_GETEDITTEXT             (SID_SMA_START + 121)
+#define SID_CMDBOXWINDOW            (SID_SMA_START + 122)
+#define SID_NO_RIGHT_SPACES         (SID_SMA_START + 124)
+#define SID_SAVE_ONLY_USED_SYMBOLS  (SID_SMA_START + 125)
+#define SID_ELEMENTSDOCKINGWINDOW   (SID_SMA_START + 126)
+#define SID_AUTO_CLOSE_BRACKETS     (SID_SMA_START + 127)
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/starmath/inc/strings.hrc b/starmath/inc/strings.hrc
new file mode 100644
index 000000000..b4a22c58e
--- /dev/null
+++ b/starmath/inc/strings.hrc
@@ -0,0 +1,351 @@
+/* -*- 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 .
+ */
+
+#ifndef INCLUDED_SM_INC_STRINGS_HRC
+#define INCLUDED_SM_INC_STRINGS_HRC
+
+#define NC_(Context, String) reinterpret_cast<char const *>(Context "\004" u8##String)
+
+#define RID_PLUSX_HELP                      NC_("RID_PLUSX_HELP", "+ Sign" )
+#define RID_MINUSX_HELP                     NC_("RID_MINUSX_HELP", "- Sign" )
+#define RID_PLUSMINUSX_HELP                 NC_("RID_PLUSMINUSX_HELP", "+- Sign" )
+#define RID_MINUSPLUSX_HELP                 NC_("RID_MINUSPLUSX_HELP", "-+ Sign" )
+#define RID_NEGX_HELP                       NC_("RID_NEGX_HELP", "Boolean NOT" )
+#define RID_XPLUSY_HELP                     NC_("RID_XPLUSY_HELP", "Addition +" )
+#define RID_XMINUSY_HELP                    NC_("RID_XMINUSY_HELP", "Subtraction -" )
+#define RID_XCDOTY_HELP                     NC_("RID_XCDOTY_HELP", "Multiplication (Dot)" )
+#define RID_XTIMESY_HELP                    NC_("RID_XTIMESY_HELP", "Multiplication (x)" )
+#define RID_XSYMTIMESY_HELP                 NC_("RID_XSYMTIMESY_HELP", "Multiplication (*)" )
+#define RID_XSYMDIVIDEY_HELP                NC_("RID_XSYMDIVIDEY_HELP", "Division (Slash)" )
+#define RID_XDIVY_HELP                      NC_("RID_XDIVY_HELP", "Division (÷)" )
+#define RID_XOVERY_HELP                     NC_("RID_XOVERY_HELP", "Division (Fraction)" )
+#define RID_XODIVIDEY_HELP                  NC_("RID_XODIVIDEY_HELP", "Circled Slash" )
+#define RID_XODOTY_HELP                     NC_("RID_XODOTY_HELP", "Circled Dot" )
+#define RID_XOMINUSY_HELP                   NC_("RID_XOMINUSY_HELP", "Circled Minus" )
+#define RID_XOPLUSY_HELP                    NC_("RID_XOPLUSY_HELP", "Circled Plus" )
+#define RID_XOTIMESY_HELP                   NC_("RID_XOTIMESY_HELP", "Tensor Product" )
+#define RID_XANDY_HELP                      NC_("RID_XANDY_HELP", "Boolean AND" )
+#define RID_XORY_HELP                       NC_("RID_XORY_HELP", "Boolean OR" )
+#define RID_XEQY_HELP                       NC_("RID_XEQY_HELP", "Is Equal" )
+#define RID_XNEQY_HELP                      NC_("RID_XNEQY_HELP", "Is Not Equal" )
+#define RID_XLTY_HELP                       NC_("RID_XLTY_HELP", "Is Less Than" )
+#define RID_XGTY_HELP                       NC_("RID_XGTY_HELP", "Is Greater Than" )
+#define RID_XLEY_HELP                       NC_("RID_XLEY_HELP", "Is Less Than Or Equal To" )
+#define RID_XGEY_HELP                       NC_("RID_XGEY_HELP", "Is Greater Than Or Equal To" )
+#define RID_XLESLANTY_HELP                  NC_("RID_XLESLANTY_HELP", "Is Less Than Or Equal To" )
+#define RID_XGESLANTY_HELP                  NC_("RID_XGESLANTY_HELP", "Is Greater Than Or Equal To" )
+#define RID_XLLY_HELP                       NC_("RID_XLLY_HELP", "Is Much Less Than" )
+#define RID_XGGY_HELP                       NC_("RID_XGGY_HELP", "Is Much Greater Than" )
+#define RID_XDEFY_HELP                      NC_("RID_XDEFY_HELP", "Is Defined As" )
+#define RID_XEQUIVY_HELP                    NC_("RID_XEQUIVY_HELP", "Is Congruent To" )
+#define RID_XAPPROXY_HELP                   NC_("RID_XAPPROXY_HELP", "Is Approximately Equal" )
+#define RID_XSIMY_HELP                      NC_("RID_XSIMY_HELP", "Is Similar To" )
+#define RID_XSIMEQY_HELP                    NC_("RID_XSIMEQY_HELP", "Is Similar Or Equal" )
+#define RID_XPROPY_HELP                     NC_("RID_XPROPY_HELP", "Is Proportional To" )
+#define RID_XORTHOY_HELP                    NC_("RID_XORTHOY_HELP", "Is Orthogonal To" )
+#define RID_XPARALLELY_HELP                 NC_("RID_XPARALLELY_HELP", "Is Parallel To" )
+#define RID_XTOWARDY_HELP                   NC_("RID_XTOWARDY_HELP", "Toward" )
+#define RID_XTRANSLY_HELP                   NC_("RID_XTRANSLY_HELP", "Corresponds To (Left)" )
+#define RID_XTRANSRY_HELP                   NC_("RID_XTRANSRY_HELP", "Corresponds To (Right)" )
+#define RID_XINY_HELP                       NC_("RID_XINY_HELP", "Is In" )
+#define RID_XNOTINY_HELP                    NC_("RID_XNOTINY_HELP", "Is Not In" )
+#define RID_XOWNSY_HELP                     NC_("RID_XOWNSY_HELP", "Owns" )
+#define RID_XUNIONY_HELP                    NC_("RID_XUNIONY_HELP", "Union" )
+#define RID_XINTERSECTIONY_HELP             NC_("RID_XINTERSECTIONY_HELP", "Intersection" )
+#define RID_XSETMINUSY_HELP                 NC_("RID_XSETMINUSY_HELP", "Difference" )
+#define RID_XSLASHY_HELP                    NC_("RID_XSLASHY_HELP", "Quotient Set" )
+#define RID_XSUBSETY_HELP                   NC_("RID_XSUBSETY_HELP", "Subset" )
+#define RID_XSUBSETEQY_HELP                 NC_("RID_XSUBSETEQY_HELP", "Subset Or Equal To" )
+#define RID_XSUPSETY_HELP                   NC_("RID_XSUPSETY_HELP", "Superset" )
+#define RID_XSUPSETEQY_HELP                 NC_("RID_XSUPSETEQY_HELP", "Superset Or Equal To" )
+#define RID_XNSUBSETY_HELP                  NC_("RID_XNSUBSETY_HELP", "Not Subset" )
+#define RID_XNSUBSETEQY_HELP                NC_("RID_XNSUBSETEQY_HELP", "Not Subset Or Equal" )
+#define RID_XNSUPSETY_HELP                  NC_("RID_XNSUPSETY_HELP", "Not Superset" )
+#define RID_XNSUPSETEQY_HELP                NC_("RID_XNSUPSETEQY_HELP", "Not Superset Or Equal" )
+#define RID_ABSX_HELP                       NC_("RID_ABSX_HELP", "Absolute Value" )
+#define RID_FACTX_HELP                      NC_("RID_FACTX_HELP", "Factorial" )
+#define RID_SQRTX_HELP                      NC_("RID_SQRTX_HELP", "Square Root" )
+#define RID_NROOTXY_HELP                    NC_("RID_NROOTXY_HELP", "N-th Root" )
+#define RID_EX_HELP                         NC_("RID_EX_HELP", "Exponential Function" )
+#define RID_EXPX_HELP                       NC_("RID_EXPX_HELP", "Exponential Function" )
+#define RID_LNX_HELP                        NC_("RID_LNX_HELP", "Natural Logarithm" )
+#define RID_LOGX_HELP                       NC_("RID_LOGX_HELP", "Logarithm" )
+#define RID_SINX_HELP                       NC_("RID_SINX_HELP", "Sine" )
+#define RID_COSX_HELP                       NC_("RID_COSX_HELP", "Cosine" )
+#define RID_TANX_HELP                       NC_("RID_TANX_HELP", "Tangent" )
+#define RID_COTX_HELP                       NC_("RID_COTX_HELP", "Cotangent" )
+#define RID_ARCSINX_HELP                    NC_("RID_ARCSINX_HELP", "Arcsine" )
+#define RID_ARCCOSX_HELP                    NC_("RID_ARCCOSX_HELP", "Arccosine" )
+#define RID_ARCTANX_HELP                    NC_("RID_ARCTANX_HELP", "Arctangent" )
+#define RID_ARCCOTX_HELP                    NC_("RID_ARCCOTX_HELP", "Arccotangent" )
+#define RID_SINHX_HELP                      NC_("RID_SINHX_HELP", "Hyperbolic Sine" )
+#define RID_COSHX_HELP                      NC_("RID_COSHX_HELP", "Hyperbolic Cosine" )
+#define RID_TANHX_HELP                      NC_("RID_TANHX_HELP", "Hyperbolic Tangent" )
+#define RID_COTHX_HELP                      NC_("RID_COTHX_HELP", "Hyperbolic Cotangent" )
+#define RID_ARSINHX_HELP                    NC_("RID_ARSINHX_HELP", "Area Hyperbolic Sine" )
+#define RID_ARCOSHX_HELP                    NC_("RID_ARCOSHX_HELP", "Area Hyperbolic Cosine" )
+#define RID_ARTANHX_HELP                    NC_("RID_ARTANHX_HELP", "Area Hyperbolic Tangent" )
+#define RID_ARCOTHX_HELP                    NC_("RID_ARCOTHX_HELP", "Area Hyperbolic Cotangent" )
+#define RID_SUMX_HELP                       NC_("RID_SUMX_HELP", "Sum" )
+#define RID_SUM_FROMX_HELP                  NC_("RID_SUM_FROMX_HELP", "Sum Subscript Bottom" )
+#define RID_SUM_TOX_HELP                    NC_("RID_SUM_TOX_HELP", "Sum Superscript Top" )
+#define RID_SUM_FROMTOX_HELP                NC_("RID_SUM_FROMTOX_HELP", "Sum Sup/Sub script" )
+#define RID_PRODX_HELP                      NC_("RID_PRODX_HELP", "Product" )
+#define RID_PROD_FROMX_HELP                 NC_("RID_PROD_FROMX_HELP", "Product Subscript Bottom" )
+#define RID_PROD_TOX_HELP                   NC_("RID_PROD_TOX_HELP", "Product Superscript Top" )
+#define RID_PROD_FROMTOX_HELP               NC_("RID_PROD_FROMTOX_HELP", "Product Sup/Sub script" )
+#define RID_COPRODX_HELP                    NC_("RID_COPRODX_HELP", "Coproduct" )
+#define RID_COPROD_FROMX_HELP               NC_("RID_COPROD_FROMX_HELP", "Coproduct Subscript Bottom" )
+#define RID_COPROD_TOX_HELP                 NC_("RID_COPROD_TOX_HELP", "Coproduct Superscript Top" )
+#define RID_COPROD_FROMTOX_HELP             NC_("RID_COPROD_FROMTOX_HELP", "Coproduct Sup/Sub script" )
+#define RID_LIMX_HELP                       NC_("RID_LIMX_HELP", "Limes" )
+#define RID_LIM_FROMX_HELP                  NC_("RID_LIM_FROMX_HELP", "Limes Subscript Bottom" )
+#define RID_LIM_TOX_HELP                    NC_("RID_LIM_TOX_HELP", "Limes Superscript Top" )
+#define RID_LIM_FROMTOX_HELP                NC_("RID_LIM_FROMTOX_HELP", "Limes Sup/Sub script" )
+#define RID_LIMINFX_HELP                    NC_("RID_LIMINFX_HELP", "Limit Inferior" )
+#define RID_LIMINF_FROMX_HELP               NC_("RID_LIMINF_FROMX_HELP", "Limit Inferior Subscript Bottom" )
+#define RID_LIMINF_TOX_HELP                 NC_("RID_LIMINF_TOX_HELP", "Limit Inferior Superscript Top" )
+#define RID_LIMINF_FROMTOX_HELP             NC_("RID_LIMINF_FROMTOX_HELP", "Limit Inferior Sup/Sub script" )
+#define RID_LIMSUPX_HELP                    NC_("RID_LIMSUPX_HELP", "Limit Superior" )
+#define RID_LIMSUP_FROMX_HELP               NC_("RID_LIMSUP_FROMX_HELP", "Limit Superior Subscript Bottom" )
+#define RID_LIMSUP_TOX_HELP                 NC_("RID_LIMSUP_TOX_HELP", "Limit Superior Superscript Top" )
+#define RID_LIMSUP_FROMTOX_HELP             NC_("RID_LIMSUP_FROMTOX_HELP", "Limit Superior Sup/Sub script" )
+#define RID_EXISTS_HELP                     NC_("RID_EXISTS_HELP", "There Exists" )
+#define RID_NOTEXISTS_HELP                  NC_("RID_NOTEXISTS_HELP", "There Not Exists" )
+#define RID_FORALL_HELP                     NC_("RID_FORALL_HELP", "For all" )
+#define RID_INTX_HELP                       NC_("RID_INTX_HELP", "Integral" )
+#define RID_INT_FROMX_HELP                  NC_("RID_INT_FROMX_HELP", "Integral Subscript Bottom" )
+#define RID_INT_TOX_HELP                    NC_("RID_INT_TOX_HELP", "Integral Superscript Top" )
+#define RID_INT_FROMTOX_HELP                NC_("RID_INT_FROMTOX_HELP", "Integral Sup/Sub script" )
+#define RID_IINTX_HELP                      NC_("RID_IINTX_HELP", "Double Integral" )
+#define RID_IINT_FROMX_HELP                 NC_("RID_IINT_FROMX_HELP", "Double Integral Subscript Bottom" )
+#define RID_IINT_TOX_HELP                   NC_("RID_IINT_TOX_HELP", "Double Integral Superscript Top" )
+#define RID_IINT_FROMTOX_HELP               NC_("RID_IINT_FROMTOX_HELP", "Double Integral Sup/Sub script" )
+#define RID_IIINTX_HELP                     NC_("RID_IIINTX_HELP", "Triple Integral" )
+#define RID_IIINT_FROMX_HELP                NC_("RID_IIINT_FROMX_HELP", "Triple Integral Subscript Bottom" )
+#define RID_IIINT_TOX_HELP                  NC_("RID_IIINT_TOX_HELP", "Triple Integral Superscript Top" )
+#define RID_IIINT_FROMTOX_HELP              NC_("RID_IIINT_FROMTOX_HELP", "Triple Integral Sup/Sub script" )
+#define RID_LINTX_HELP                      NC_("RID_LINTX_HELP", "Curve Integral" )
+#define RID_LINT_FROMX_HELP                 NC_("RID_LINT_FROMX_HELP", "Curve Integral Subscript Bottom" )
+#define RID_LINT_TOX_HELP                   NC_("RID_LINT_TOX_HELP", "Curve Integral Superscript Top" )
+#define RID_LINT_FROMTOX_HELP               NC_("RID_LINT_FROMTOX_HELP", "Curve Integral Sup/Sub script" )
+#define RID_LLINTX_HELP                     NC_("RID_LLINTX_HELP", "Double Curve Integral" )
+#define RID_LLINT_FROMX_HELP                NC_("RID_LLINT_FROMX_HELP", "Double Curve Integral Subscript Bottom" )
+#define RID_LLINT_TOX_HELP                  NC_("RID_LLINT_TOX_HELP", "Double Curve Integral Superscript Top" )
+#define RID_LLINT_FROMTOX_HELP              NC_("RID_LLINT_FROMTOX_HELP", "Double Curve Integral Sup/Sub script" )
+#define RID_LLLINTX_HELP                    NC_("RID_LLLINTX_HELP", "Triple Curve Integral" )
+#define RID_LLLINT_FROMX_HELP               NC_("RID_LLLINT_FROMX_HELP", "Triple Curve Integral Subscript Bottom" )
+#define RID_LLLINT_TOX_HELP                 NC_("RID_LLLINT_TOX_HELP", "Triple Curve Integral Superscript Top" )
+#define RID_LLLINT_FROMTOX_HELP             NC_("RID_LLLINT_FROMTOX_HELP", "Triple Curve Integral Sup/Sub script" )
+#define RID_ACUTEX_HELP                     NC_("RID_ACUTEX_HELP", "Acute Accent" )
+#define RID_BARX_HELP                       NC_("RID_BARX_HELP", "Line Above" )
+#define RID_BREVEX_HELP                     NC_("RID_BREVEX_HELP", "Breve" )
+#define RID_CHECKX_HELP                     NC_("RID_CHECKX_HELP", "Reverse Circumflex" )
+#define RID_CIRCLEX_HELP                    NC_("RID_CIRCLEX_HELP", "Circle" )
+#define RID_DOTX_HELP                       NC_("RID_DOTX_HELP", "Dot" )
+#define RID_DDOTX_HELP                      NC_("RID_DDOTX_HELP", "Double Dot" )
+#define RID_DDDOTX_HELP                     NC_("RID_DDDOTX_HELP", "Triple Dot" )
+#define RID_GRAVEX_HELP                     NC_("RID_GRAVEX_HELP", "Grave Accent" )
+#define RID_HATX_HELP                       NC_("RID_HATX_HELP", "Circumflex" )
+#define RID_TILDEX_HELP                     NC_("RID_TILDEX_HELP", "Tilde" )
+#define RID_VECX_HELP                       NC_("RID_VECX_HELP", "Vector Arrow" )
+#define RID_HARPOONX_HELP                   NC_("RID_HARPOONX_HELP", "Harpoon" )
+#define RID_UNDERLINEX_HELP                 NC_("RID_UNDERLINEX_HELP", "Line Below" )
+#define RID_OVERLINEX_HELP                  NC_("RID_OVERLINEX_HELP", "Line Over" )
+#define RID_OVERSTRIKEX_HELP                NC_("RID_OVERSTRIKEX_HELP", "Line Through" )
+#define RID_PHANTOMX_HELP                   NC_("RID_PHANTOMX_HELP", "Transparent" )
+#define RID_BOLDX_HELP                      NC_("RID_BOLDX_HELP", "Bold Font" )
+#define RID_ITALX_HELP                      NC_("RID_ITALX_HELP", "Italic Font" )
+#define RID_SIZEXY_HELP                     NC_("RID_SIZEXY_HELP", "Resize" )
+#define RID_FONTXY_HELP                     NC_("RID_FONTXY_HELP", "Change Font" )
+#define RID_COLORX_BLACK_HELP               NC_("RID_COLORX_BLACK_HELP", "Color Black" )
+#define RID_COLORX_BLUE_HELP                NC_("RID_COLORX_BLUE_HELP", "Color Blue" )
+#define RID_COLORX_GREEN_HELP               NC_("RID_COLORX_GREEN_HELP", "Color Green" )
+#define RID_COLORX_RED_HELP                 NC_("RID_COLORX_RED_HELP", "Color Red" )
+#define RID_COLORX_CYAN_HELP                NC_("RID_COLORX_CYAN_HELP", "Color Cyan" )
+#define RID_COLORX_MAGENTA_HELP             NC_("RID_COLORX_MAGENTA_HELP", "Color Magenta" )
+#define RID_COLORX_GRAY_HELP                NC_("RID_COLORX_GRAY_HELP", "Color Gray" )
+#define RID_COLORX_LIME_HELP                NC_("RID_COLORX_LIME_HELP", "Color Lime" )
+#define RID_COLORX_MAROON_HELP              NC_("RID_COLORX_MAROON_HELP", "Color Maroon" )
+#define RID_COLORX_NAVY_HELP                NC_("RID_COLORX_NAVY_HELP", "Color Navy" )
+#define RID_COLORX_OLIVE_HELP               NC_("RID_COLORX_OLIVE_HELP", "Color Olive" )
+#define RID_COLORX_PURPLE_HELP              NC_("RID_COLORX_PURPLE_HELP", "Color Purple" )
+#define RID_COLORX_SILVER_HELP              NC_("RID_COLORX_SILVER_HELP", "Color Silver" )
+#define RID_COLORX_TEAL_HELP                NC_("RID_COLORX_TEAL_HELP", "Color Teal" )
+#define RID_COLORX_YELLOW_HELP              NC_("RID_COLORX_YELLOW_HELP", "Color Yellow" )
+#define RID_COLORX_RGB_HELP                 NC_("RID_COLORX_RGB_HELP", "Color RGB" )
+#define RID_LRGROUPX_HELP                   NC_("RID_LRGROUPX_HELP", "Group Brackets" )
+#define RID_LRPARENTX_HELP                  NC_("RID_LRPARENTX_HELP", "Round Brackets" )
+#define RID_LRBRACKETX_HELP                 NC_("RID_LRBRACKETX_HELP", "Square Brackets" )
+#define RID_LRDBRACKETX_HELP                NC_("RID_LRDBRACKETX_HELP", "Double Square Brackets" )
+#define RID_LRBRACEX_HELP                   NC_("RID_LRBRACEX_HELP", "Braces" )
+#define RID_LRANGLEX_HELP                   NC_("RID_LRANGLEX_HELP", "Angle Brackets" )
+#define RID_LRCEILX_HELP                    NC_("RID_LRCEILX_HELP", "Upper Ceil" )
+#define RID_LRFLOORX_HELP                   NC_("RID_LRFLOORX_HELP", "Floor" )
+#define RID_LRLINEX_HELP                    NC_("RID_LRLINEX_HELP", "Single Lines" )
+#define RID_LRDLINEX_HELP                   NC_("RID_LRDLINEX_HELP", "Double Lines" )
+#define RID_LMRANGLEXY_HELP                 NC_("RID_LMRANGLEXY_HELP", "Operator Brackets" )
+#define RID_SLRPARENTX_HELP                 NC_("RID_SLRPARENTX_HELP", "Round Brackets (Scalable)" )
+#define RID_SLRBRACKETX_HELP                NC_("RID_SLRBRACKETX_HELP", "Square Brackets (Scalable)" )
+#define RID_SLRDBRACKETX_HELP               NC_("RID_SLRDBRACKETX_HELP", "Double Square Brackets (Scalable)" )
+#define RID_SLRBRACEX_HELP                  NC_("RID_SLRBRACEX_HELP", "Braces (Scalable)" )
+#define RID_SLRANGLEX_HELP                  NC_("RID_SLRANGLEX_HELP", "Angle Brackets (Scalable)" )
+#define RID_SLRCEILX_HELP                   NC_("RID_SLRCEILX_HELP", "Ceiling (Scalable)" )
+#define RID_SLRFLOORX_HELP                  NC_("RID_SLRFLOORX_HELP", "Floor (Scalable)" )
+#define RID_SLRLINEX_HELP                   NC_("RID_SLRLINEX_HELP", "Single Lines (Scalable)" )
+#define RID_SLRDLINEX_HELP                  NC_("RID_SLRDLINEX_HELP", "Double Lines (Scalable)" )
+#define RID_SLMRANGLEXY_HELP                NC_("RID_SLMRANGLEXY_HELP", "Operator Brackets (Scalable)" )
+#define RID_XEVALUATEDATY_HELP              NC_("RID_XEVALUATEDATY_HELP", "Evaluated At" )
+#define RID_XOVERBRACEY_HELP                NC_("RID_XOVERBRACEY_HELP", "Braces Top (Scalable)" )
+#define RID_XUNDERBRACEY_HELP               NC_("RID_XUNDERBRACEY_HELP", "Braces Bottom (Scalable)" )
+#define RID_RSUBX_HELP                      NC_("RID_RSUBX_HELP", "Subscript Right" )
+#define RID_RSUPX_HELP                      NC_("RID_RSUPX_HELP", "Power" )
+#define RID_LSUBX_HELP                      NC_("RID_LSUBX_HELP", "Subscript Left" )
+#define RID_LSUPX_HELP                      NC_("RID_LSUPX_HELP", "Superscript Left" )
+#define RID_CSUBX_HELP                      NC_("RID_CSUBX_HELP", "Subscript Bottom" )
+#define RID_CSUPX_HELP                      NC_("RID_CSUPX_HELP", "Superscript Top" )
+#define RID_SBLANK_HELP                     NC_("RID_SBLANK_HELP", "Small Gap" )
+#define RID_BLANK_HELP                      NC_("RID_BLANK_HELP", "Blank" )
+#define RID_NEWLINE_HELP                    NC_("RID_NEWLINE_HELP", "New Line" )
+#define RID_BINOMXY_HELP                    NC_("RID_BINOMXY_HELP", "Vertical Stack (2 Elements)")
+#define RID_STACK_HELP                      NC_("RID_STACK_HELP", "Vertical Stack" )
+#define RID_MATRIX_HELP                     NC_("RID_MATRIX_HELP", "Matrix Stack" )
+#define RID_ALIGNLX_HELP                    NC_("RID_ALIGNLX_HELP", "Align Left" )
+#define RID_ALIGNCX_HELP                    NC_("RID_ALIGNCX_HELP", "Align Center" )
+#define RID_ALIGNRX_HELP                    NC_("RID_ALIGNRX_HELP", "Align Right" )
+#define RID_ALEPH_HELP                      NC_("RID_ALEPH_HELP", "Aleph" )
+#define RID_EMPTYSET_HELP                   NC_("RID_EMPTYSET_HELP", "Empty Set" )
+#define RID_RE_HELP                         NC_("RID_RE_HELP", "Real Part" )
+#define RID_IM_HELP                         NC_("RID_IM_HELP", "Imaginary Part" )
+#define RID_INFINITY_HELP                   NC_("RID_INFINITY_HELP", "Infinity" )
+#define RID_PARTIAL_HELP                    NC_("RID_PARTIAL_HELP", "Partial" )
+#define RID_NABLA_HELP                      NC_("RID_NABLA_HELP", "Nabla" )
+#define RID_LAPLACE_HELP                    NC_("RID_LAPLACE_HELP", "Laplace" )
+#define RID_WP_HELP                         NC_("RID_WP_HELP", "Weierstrass p" )
+#define RID_DOTSAXIS_HELP                   NC_("RID_DOTSAXIS_HELP", "Dots In Middle" )
+#define RID_DOTSUP_HELP                     NC_("RID_DOTSUP_HELP", "Dots To Top" )
+#define RID_DOTSDOWN_HELP                   NC_("RID_DOTSDOWN_HELP", "Dots To Bottom" )
+#define RID_DOTSLOW_HELP                    NC_("RID_DOTSLOW_HELP", "Dots At Bottom" )
+#define RID_DOTSVERT_HELP                   NC_("RID_DOTSVERT_HELP", "Dots Vertically" )
+#define RID_XCIRCY_HELP                     NC_("RID_XCIRCY_HELP", "Concatenate" )
+#define RID_XWIDESLASHY_HELP                NC_("RID_XWIDESLASHY_HELP", "Division (wideslash)" )
+#define RID_XWIDEBSLASHY_HELP               NC_("RID_XWIDEBSLASHY_HELP", "Division (counter wideslash)" )
+#define RID_XDIVIDESY_HELP                  NC_("RID_XDIVIDESY_HELP", "Divides" )
+#define RID_XNDIVIDESY_HELP                 NC_("RID_XNDIVIDESY_HELP", "Does Not Divide" )
+#define RID_DLARROW_HELP                    NC_("RID_DLARROW_HELP", "Double Arrow Left" )
+#define RID_DLRARROW_HELP                   NC_("RID_DLRARROW_HELP", "Double Arrow Left And Right" )
+#define RID_DRARROW_HELP                    NC_("RID_DRARROW_HELP", "Double Arrow Right" )
+#define RID_SETN_HELP                       NC_("RID_SETN_HELP", "Natural Numbers Set" )
+#define RID_SETZ_HELP                       NC_("RID_SETZ_HELP", "Integers Set" )
+#define RID_SETQ_HELP                       NC_("RID_SETQ_HELP", "Set of Rational Numbers" )
+#define RID_SETR_HELP                       NC_("RID_SETR_HELP", "Real Numbers Set" )
+#define RID_SETC_HELP                       NC_("RID_SETC_HELP", "Complex Numbers Set" )
+#define RID_WIDEHATX_HELP                   NC_("RID_WIDEHATX_HELP", "Large Circumflex" )
+#define RID_WIDETILDEX_HELP                 NC_("RID_WIDETILDEX_HELP", "Large Tilde" )
+#define RID_WIDEVECX_HELP                   NC_("RID_WIDEVECX_HELP", "Large Vector Arrow" )
+#define RID_WIDEHARPOONX_HELP               NC_("RID_WIDEHARPOONX_HELP", "Large Harpoon" )
+#define RID_HBAR_HELP                       NC_("RID_HBAR_HELP", "h Bar" )
+#define RID_LAMBDABAR_HELP                  NC_("RID_LAMBDABAR_HELP", "Lambda Bar" )
+#define RID_LEFTARROW_HELP                  NC_("RID_LEFTARROW_HELP", "Left Arrow" )
+#define RID_RIGHTARROW_HELP                 NC_("RID_RIGHTARROW_HELP", "Right Arrow" )
+#define RID_UPARROW_HELP                    NC_("RID_UPARROW_HELP", "Up Arrow" )
+#define RID_DOWNARROW_HELP                  NC_("RID_DOWNARROW_HELP", "Down Arrow" )
+#define RID_NOSPACE_HELP                    NC_("RID_NOSPACE_HELP", "No space" )
+#define RID_XPRECEDESY_HELP                 NC_("RID_XPRECEDESY_HELP", "Precedes" )
+#define RID_XPRECEDESEQUALY_HELP            NC_("RID_XPRECEDESEQUALY_HELP", "Precedes or equal to" )
+#define RID_XPRECEDESEQUIVY_HELP            NC_("RID_XPRECEDESEQUIVY_HELP", "Precedes or equivalent to" )
+#define RID_XSUCCEEDSY_HELP                 NC_("RID_XSUCCEEDSY_HELP", "Succeeds" )
+#define RID_XSUCCEEDSEQUALY_HELP            NC_("RID_XSUCCEEDSEQUALY_HELP", "Succeeds or equal to" )
+#define RID_XSUCCEEDSEQUIVY_HELP            NC_("RID_XSUCCEEDSEQUIVY_HELP", "Succeeds or equivalent to" )
+#define RID_XNOTPRECEDESY_HELP              NC_("RID_XNOTPRECEDESY_HELP", "Not precedes" )
+#define RID_XNOTSUCCEEDSY_HELP              NC_("RID_XNOTSUCCEEDSY_HELP", "Not succeeds" )
+#define RID_CATEGORY_UNARY_BINARY_OPERATORS NC_("RID_CATEGORY_UNARY_BINARY_OPERATORS", "Unary/Binary Operators" )
+#define RID_CATEGORY_RELATIONS              NC_("RID_CATEGORY_RELATIONS", "Relations" )
+#define RID_CATEGORY_SET_OPERATIONS         NC_("RID_CATEGORY_SET_OPERATIONS", "Set Operations" )
+#define RID_CATEGORY_FUNCTIONS              NC_("RID_CATEGORY_FUNCTIONS", "Functions" )
+#define RID_CATEGORY_OPERATORS              NC_("RID_CATEGORY_OPERATORS", "Operators" )
+#define RID_CATEGORY_ATTRIBUTES             NC_("RID_CATEGORY_ATTRIBUTES", "Attributes" )
+#define RID_CATEGORY_BRACKETS               NC_("RID_CATEGORY_BRACKETS", "Brackets" )
+#define RID_CATEGORY_FORMATS                NC_("RID_CATEGORY_FORMATS", "Formats" )
+#define RID_CATEGORY_OTHERS                 NC_("RID_CATEGORY_OTHERS", "Others" )
+#define RID_CATEGORY_EXAMPLES               NC_("RID_CATEGORY_EXAMPLES", "Examples" )
+
+#define RID_EXAMPLE_CIRCUMFERENCE_HELP      NC_("RID_EXAMPLE_CIRCUMFERENCE_HELP", "Circumference" )
+#define RID_EXAMPLE_MASS_ENERGY_EQUIV_HELP  NC_("RID_EXAMPLE_MASS_ENERGY_EQUIV_HELP", "Mass–energy equivalence" )
+#define RID_EXAMPLE_PYTHAGOREAN_THEO_HELP   NC_("RID_EXAMPLE_PYTHAGOREAN_THEO_HELP", "Pythagorean theorem" )
+#define RID_EXAMPLE_A_SIMPLE_SERIES_HELP    NC_("RID_EXAMPLE_A_SIMPLE_SERIES_HELP", "A simple series" )
+#define RID_EXAMPLE_GAUSS_DISTRIBUTION_HELP NC_("RID_EXAMPLE_GAUSS_DISTRIBUTION_HELP", "Gauss distribution" )
+
+#define RID_FONTREGULAR                     NC_("RID_FONTREGULAR", "Standard" )
+#define RID_FONTITALIC                      NC_("RID_FONTITALIC", "Italic" )
+#define RID_FONTBOLD                        NC_("RID_FONTBOLD", "Bold" )
+#define STR_BLACK                           NC_("STR_BLACK", "black" )
+#define STR_BLUE                            NC_("STR_BLUE", "blue" )
+#define STR_GREEN                           NC_("STR_GREEN", "green" )
+#define STR_RED                             NC_("STR_RED", "red" )
+#define STR_CYAN                            NC_("STR_CYAN", "cyan" )
+#define STR_MAGENTA                         NC_("STR_MAGENTA", "magenta" )
+#define STR_GRAY                            NC_("STR_GRAY", "gray" )
+#define STR_LIME                            NC_("STR_LIME", "lime" )
+#define STR_MAROON                          NC_("STR_MAROON", "maroon" )
+#define STR_NAVY                            NC_("STR_NAVY", "navy" )
+#define STR_OLIVE                           NC_("STR_OLIVE", "olive" )
+#define STR_PURPLE                          NC_("STR_PURPLE", "purple" )
+#define STR_SILVER                          NC_("STR_SILVER", "silver" )
+#define STR_TEAL                            NC_("STR_TEAL", "teal" )
+#define STR_YELLOW                          NC_("STR_YELLOW", "yellow" )
+#define STR_RGB                             NC_("STR_RGB", "rgb" )
+#define STR_HIDE                            NC_("STR_HIDE", "hide" )
+#define STR_SIZE                            NC_("STR_SIZE", "size" )
+#define STR_FONT                            NC_("STR_FONT", "font" )
+#define STR_ALIGN_LEFT                      NC_("STR_ALIGN_LEFT", "left" )
+#define STR_ALIGN_CENTER                    NC_("STR_ALIGN_CENTER", "center" )
+#define STR_ALIGN_RIGHT                     NC_("STR_ALIGN_RIGHT", "right" )
+#define STR_CMDBOXWINDOW                    NC_("STR_CMDBOXWINDOW", "Commands" )
+#define RID_DOCUMENTSTR                     NC_("RID_DOCUMENTSTR", "Formula" )
+#define STR_STATSTR_WRITING                 NC_("STR_STATSTR_WRITING", "Saving document..." )
+#define STR_MATH_DOCUMENT_FULLTYPE_CURRENT  NC_("STR_MATH_DOCUMENT_FULLTYPE_CURRENT", "%PRODUCTNAME %PRODUCTVERSION Formula")
+#define RID_ERR_IDENT                       NC_("RID_ERR_IDENT", "ERROR : " )
+#define RID_ERR_UNEXPECTEDCHARACTER         NC_("RID_ERR_UNEXPECTEDCHARACTER", "Unexpected character" )
+#define RID_ERR_UNEXPECTEDTOKEN             NC_("RID_ERR_UNEXPECTEDTOKEN", "Unexpected token" )
+#define RID_ERR_LGROUPEXPECTED              NC_("RID_ERR_LGROUPEXPECTED", "'{' expected" )
+#define RID_ERR_RGROUPEXPECTED              NC_("RID_ERR_RGROUPEXPECTED", "'}' expected" )
+#define RID_ERR_LBRACEEXPECTED              NC_("RID_ERR_LBRACEEXPECTED", "'(' expected" )
+#define RID_ERR_RBRACEEXPECTED              NC_("RID_ERR_RBRACEEXPECTED", "')' expected" )
+#define RID_ERR_PARENTMISMATCH              NC_("RID_ERR_PARENTMISMATCH", "Left and right symbols mismatched" )
+#define RID_ERR_FONTEXPECTED                NC_("RID_ERR_FONTEXPECTED", "'fixed', 'sans', or 'serif' expected" )
+#define RID_ERR_SIZEEXPECTED                NC_("RID_ERR_SIZEEXPECTED", "'size' followed by an unexpected token" )
+#define RID_ERR_DOUBLEALIGN                 NC_("RID_ERR_DOUBLEALIGN", "Double aligning is not allowed" )
+#define RID_ERR_DOUBLESUBSUPSCRIPT          NC_("RID_ERR_DOUBLESUBSUPSCRIPT", "Double sub/superscripts is not allowed" )
+#define RID_ERR_POUNDEXPECTED               NC_("RID_ERR_POUNDEXPECTED", "'#' expected" )
+#define RID_ERR_COLOREXPECTED               NC_("RID_ERR_COLOREXPECTED", "Color required" )
+#define RID_ERR_RIGHTEXPECTED               NC_("RID_ERR_RIGHTEXPECTED", "'RIGHT' expected" )
+#define RID_PRINTUIOPT_PRODNAME             NC_("RID_PRINTUIOPT_PRODNAME", "%PRODUCTNAME %s" )
+#define RID_PRINTUIOPT_CONTENTS             NC_("RID_PRINTUIOPT_CONTENTS", "Contents" )
+#define RID_PRINTUIOPT_TITLE                NC_("RID_PRINTUIOPT_TITLE", "~Title" )
+#define RID_PRINTUIOPT_FRMLTXT              NC_("RID_PRINTUIOPT_FRMLTXT", "~Formula text" )
+#define RID_PRINTUIOPT_BORDERS              NC_("RID_PRINTUIOPT_BORDERS", "B~orders" )
+#define RID_PRINTUIOPT_SIZE                 NC_("RID_PRINTUIOPT_SIZE", "Size" )
+#define RID_PRINTUIOPT_ORIGSIZE             NC_("RID_PRINTUIOPT_ORIGSIZE", "O~riginal size" )
+#define RID_PRINTUIOPT_FITTOPAGE            NC_("RID_PRINTUIOPT_FITTOPAGE", "Fit to ~page" )
+#define RID_PRINTUIOPT_SCALING              NC_("RID_PRINTUIOPT_SCALING", "~Scaling" )
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/starmath/inc/strings.hxx b/starmath/inc/strings.hxx
new file mode 100644
index 000000000..bedd95347
--- /dev/null
+++ b/starmath/inc/strings.hxx
@@ -0,0 +1,274 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
+/*
+ * 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/.
+ */
+
+#ifndef INCLUDED_STARMATH_INC_STRINGS_HXX
+#define INCLUDED_STARMATH_INC_STRINGS_HXX
+
+#define RID_UNDOFORMATNAME  "Format"
+
+#define RID_PLUSX           "+<?> "
+#define RID_MINUSX          "-<?> "
+#define RID_PLUSMINUSX      "+-<?> "
+#define RID_MINUSPLUSX      "-+<?> "
+#define RID_NEGX            "neg <?> "
+#define RID_XPLUSY          "<?> + <?> "
+#define RID_XMINUSY         "<?> - <?> "
+#define RID_XCDOTY          "<?> cdot <?> "
+#define RID_XTIMESY         "<?> times <?> "
+#define RID_XSYMTIMESY      "<?> * <?> "
+#define RID_XSYMDIVIDEY     "<?> / <?> "
+#define RID_XDIVY           "<?> div <?> "
+#define RID_XOVERY          "{<?>} over {<?>} "
+#define RID_XODIVIDEY       "<?> odivide <?> "
+#define RID_XODOTY          "<?> odot <?> "
+#define RID_XOMINUSY        "<?> ominus <?> "
+#define RID_XOPLUSY         "<?> oplus <?> "
+#define RID_XOTIMESY        "<?> otimes <?> "
+#define RID_XANDY           "<?> and <?> "
+#define RID_XORY            "<?> or <?> "
+#define RID_XEQY            "<?> = <?> "
+#define RID_XNEQY           "<?> <> <?> "
+#define RID_XLTY            "<?> < <?> "
+#define RID_XGTY            "<?> > <?> "
+#define RID_XLEY            "<?> <= <?> "
+#define RID_XGEY            "<?> >= <?> "
+#define RID_XLESLANTY       "<?> leslant <?> "
+#define RID_XGESLANTY       "<?> geslant <?> "
+#define RID_XLLY            "<?> << <?> "
+#define RID_XGGY            "<?> >> <?> "
+#define RID_XDEFY           "<?> def <?> "
+#define RID_XEQUIVY         "<?> equiv <?> "
+#define RID_XAPPROXY        "<?> approx <?> "
+#define RID_XSIMY           "<?> sim <?> "
+#define RID_XSIMEQY         "<?> simeq <?> "
+#define RID_XPROPY          "<?> prop <?> "
+#define RID_XORTHOY         "<?> ortho <?> "
+#define RID_XPARALLELY      "<?> parallel <?> "
+#define RID_XTOWARDY        "<?> toward <?> "
+#define RID_XTRANSLY        "<?> transl <?> "
+#define RID_XTRANSRY        "<?> transr <?> "
+#define RID_XINY            "<?> in <?> "
+#define RID_XNOTINY         "<?> notin <?> "
+#define RID_XOWNSY          "<?> owns <?> "
+#define RID_XUNIONY         "<?> union <?> "
+#define RID_XINTERSECTIONY  "<?> intersection <?> "
+#define RID_XSETMINUSY      "<?> setminus <?> "
+#define RID_XSLASHY         "<?> slash <?> "
+#define RID_XSUBSETY        "<?> subset <?> "
+#define RID_XSUBSETEQY      "<?> subseteq <?> "
+#define RID_XSUPSETY        "<?> supset <?> "
+#define RID_XSUPSETEQY      "<?> supseteq <?> "
+#define RID_XNSUBSETY       "<?> nsubset <?> "
+#define RID_XNSUBSETEQY     "<?> nsubseteq <?> "
+#define RID_XNSUPSETY       "<?> nsupset <?> "
+#define RID_XNSUPSETEQY     "<?> nsupseteq <?> "
+#define RID_ABSX            "abs{<?>} "
+#define RID_FACTX           "fact{<?>} "
+#define RID_SQRTX           "sqrt{<?>} "
+#define RID_NROOTXY         "nroot{<?>}{<?>} "
+#define RID_EX              "func e^{<?>} "
+#define RID_EXPX            "exp(<?>) "
+#define RID_LNX             "ln(<?>) "
+#define RID_LOGX            "log(<?>) "
+#define RID_SINX            "sin(<?>) "
+#define RID_COSX            "cos(<?>) "
+#define RID_TANX            "tan(<?>) "
+#define RID_COTX            "cot(<?>) "
+#define RID_ARCSINX         "arcsin(<?>) "
+#define RID_ARCCOSX         "arccos(<?>) "
+#define RID_ARCTANX         "arctan(<?>) "
+#define RID_ARCCOTX         "arccot(<?>) "
+#define RID_SINHX           "sinh(<?>) "
+#define RID_COSHX           "cosh(<?>) "
+#define RID_TANHX           "tanh(<?>) "
+#define RID_COTHX           "coth(<?>) "
+#define RID_ARSINHX         "arsinh(<?>) "
+#define RID_ARCOSHX         "arcosh(<?>) "
+#define RID_ARTANHX         "artanh(<?>) "
+#define RID_ARCOTHX         "arcoth(<?>) "
+#define RID_SUMX            "sum <?> "
+#define RID_SUM_FROMX       "sum from{<?>} <?> "
+#define RID_SUM_TOX         "sum to{<?>} <?> "
+#define RID_SUM_FROMTOX     "sum from{<?>} to{<?>} <?> "
+#define RID_PRODX           "prod <?> "
+#define RID_PROD_FROMX      "prod from{<?>} <?> "
+#define RID_PROD_TOX        "prod to{<?>} <?> "
+#define RID_PROD_FROMTOX    "prod from{<?>} to{<?>} <?> "
+#define RID_COPRODX         "coprod <?> "
+#define RID_COPROD_FROMX    "coprod from{<?>} <?> "
+#define RID_COPROD_TOX      "coprod to{<?>} <?> "
+#define RID_COPROD_FROMTOX  "coprod from{<?>} to{<?>} <?> "
+#define RID_LIMX            "lim <?> "
+#define RID_LIM_FROMX       "lim from{<?>} <?> "
+#define RID_LIM_TOX         "lim to{<?>} <?> "
+#define RID_LIM_FROMTOX     "lim from{<?>} to{<?>} <?> "
+#define RID_LIMINFX         "liminf <?> "
+#define RID_LIMINF_FROMX    "liminf from{<?>} <?> "
+#define RID_LIMINF_TOX      "liminf to{<?>} <?> "
+#define RID_LIMINF_FROMTOX  "liminf from{<?>} to{<?>} <?> "
+#define RID_LIMSUPX         "limsup <?> "
+#define RID_LIMSUP_FROMX    "limsup from{<?>} <?> "
+#define RID_LIMSUP_TOX      "limsup to{<?>} <?> "
+#define RID_LIMSUP_FROMTOX  "limsup from{<?>} to{<?>} <?> "
+#define RID_EXISTS          "exists "
+#define RID_NOTEXISTS       "notexists "
+#define RID_FORALL          "forall "
+#define RID_INTX            "int <?> "
+#define RID_INT_FROMX       "int from{<?>} <?> "
+#define RID_INT_TOX         "int to{<?>} <?> "
+#define RID_INT_FROMTOX     "int from{<?>} to{<?>} <?> "
+#define RID_IINTX           "iint <?> "
+#define RID_IINT_FROMX      "iint from{<?>} <?> "
+#define RID_IINT_TOX        "iint to{<?>} <?> "
+#define RID_IINT_FROMTOX    "iint from{<?>} to{<?>} <?> "
+#define RID_IIINTX          "iiint <?> "
+#define RID_IIINT_FROMX     "iiint from{<?>} <?> "
+#define RID_IIINT_TOX       "iiint to{<?>} <?> "
+#define RID_IIINT_FROMTOX   "iiint from{<?>} to{<?>} <?> "
+#define RID_LINTX           "lint <?> "
+#define RID_LINT_FROMX      "lint from{<?>} <?> "
+#define RID_LINT_TOX        "lint to{<?>} <?> "
+#define RID_LINT_FROMTOX    "lint from{<?>} to{<?>} <?> "
+#define RID_LLINTX          "llint <?> "
+#define RID_LLINT_FROMX     "llint from{<?>} <?> "
+#define RID_LLINT_TOX       "llint to{<?>} <?> "
+#define RID_LLINT_FROMTOX   "llint from{<?>} to{<?>} <?> "
+#define RID_LLLINTX         "lllint <?> "
+#define RID_LLLINT_FROMX    "lllint from{<?>} <?> "
+#define RID_LLLINT_TOX      "lllint to{<?>} <?> "
+#define RID_LLLINT_FROMTOX  "lllint from{<?>} to{<?>} <?> "
+#define RID_FROMX           "from{<?>} <?> "
+#define RID_TOX             "to{<?>} <?> "
+#define RID_FROMXTOY        "from{<?>} to{<?>} <?> "
+#define RID_ACUTEX          "acute <?> "
+#define RID_BARX            "bar <?> "
+#define RID_BREVEX          "breve <?> "
+#define RID_CHECKX          "check <?> "
+#define RID_CIRCLEX         "circle <?> "
+#define RID_DOTX            "dot <?> "
+#define RID_DDOTX           "ddot <?> "
+#define RID_DDDOTX          "dddot <?> "
+#define RID_GRAVEX          "grave <?> "
+#define RID_HATX            "hat <?> "
+#define RID_TILDEX          "tilde <?> "
+#define RID_VECX            "vec <?> "
+#define RID_HARPOONX        "harpoon <?> "
+#define RID_UNDERLINEX      "underline {<?>} "
+#define RID_OVERLINEX       "overline {<?>} "
+#define RID_OVERSTRIKEX     "overstrike {<?>} "
+#define RID_PHANTOMX        "phantom {<?>} "
+#define RID_BOLDX           "bold <?> "
+#define RID_ITALX           "ital <?> "
+#define RID_SIZEXY          "size <?> {<?>} "
+#define RID_FONTXY          "font <?> {<?>} "
+#define RID_COLORX_BLACK    "color black {<?>} "
+#define RID_COLORX_BLUE     "color blue {<?>} "
+#define RID_COLORX_GREEN    "color green {<?>} "
+#define RID_COLORX_RED      "color red {<?>} "
+#define RID_COLORX_CYAN     "color cyan {<?>} "
+#define RID_COLORX_MAGENTA  "color magenta {<?>} "
+#define RID_COLORX_GRAY     "color gray {<?>} "
+#define RID_COLORX_LIME     "color lime {<?>} "
+#define RID_COLORX_MAROON   "color maroon {<?>} "
+#define RID_COLORX_NAVY     "color navy {<?>} "
+#define RID_COLORX_OLIVE    "color olive {<?>} "
+#define RID_COLORX_PURPLE   "color purple {<?>} "
+#define RID_COLORX_SILVER   "color silver {<?>} "
+#define RID_COLORX_TEAL     "color teal {<?>} "
+#define RID_COLORX_YELLOW   "color yellow {<?>} "
+#define RID_COLORX_RGB      "color rgb 0 0 0 {<?>} "
+#define RID_LRGROUPX        "{<?>} "
+#define RID_LRPARENTX       "(<?>) "
+#define RID_LRBRACKETX      "[<?>] "
+#define RID_LRDBRACKETX     "ldbracket <?> rdbracket "
+#define RID_LRBRACEX        "lbrace <?> rbrace "
+#define RID_LRANGLEX        "langle <?> rangle "
+#define RID_LRCEILX         "lceil <?> rceil "
+#define RID_LRFLOORX        "lfloor <?> rfloor "
+#define RID_LRLINEX         "lline <?> rline "
+#define RID_LRDLINEX        "ldline <?> rdline "
+#define RID_LMRANGLEXY      "langle <?> mline <?> rangle "
+#define RID_SLRPARENTX      "left ( <?> right ) "
+#define RID_SLRBRACKETX     "left [ <?> right ] "
+#define RID_SLRDBRACKETX    "left ldbracket <?> right rdbracket "
+#define RID_SLRBRACEX       "left lbrace <?> right rbrace "
+#define RID_SLRANGLEX       "left langle <?> right rangle "
+#define RID_SLRCEILX        "left lceil <?> right rceil "
+#define RID_SLRFLOORX       "left lfloor <?> right rfloor "
+#define RID_SLRLINEX        "left lline <?> right rline "
+#define RID_SLRDLINEX       "left ldline <?> right rdline "
+#define RID_SLMRANGLEXY     "left langle <?> mline <?> right rangle "
+#define RID_XEVALUATEDATY   "left none {<?>} right rline_{<?>} "
+#define RID_XOVERBRACEY     "{<?>} overbrace {<?>} "
+#define RID_XUNDERBRACEY    "{<?>} underbrace {<?>} "
+#define RID_RSUBX           "<?>_{<?>}"
+#define RID_RSUPX           "<?>^{<?>}"
+#define RID_LSUBX           "<?> lsub{<?>} "
+#define RID_LSUPX           "<?> lsup{<?>} "
+#define RID_CSUBX           "<?> csub{<?>} "
+#define RID_CSUPX           "<?> csup{<?>} "
+#define RID_SBLANK          "`"
+#define RID_BLANK           "~"
+#define RID_NEWLINE         "newline "
+#define RID_BINOMXY         "binom{<?>}{<?>} "
+#define RID_STACK           "stack{<?> # <?> # <?>} "
+#define RID_MATRIX          "matrix{<?> # <?> ## <?> # <?>} "
+#define RID_ALIGNLX         "alignl <?> "
+#define RID_ALIGNCX         "alignc <?> "
+#define RID_ALIGNRX         "alignr <?> "
+#define RID_ALEPH           "aleph "
+#define RID_EMPTYSET        "emptyset "
+#define RID_RE              "Re "
+#define RID_IM              "Im "
+#define RID_INFINITY        "infinity "
+#define RID_PARTIAL         "partial "
+#define RID_NABLA           "nabla "
+#define RID_WP              "wp "
+#define RID_LAPLACE         "laplace "
+#define RID_DOTSAXIS        "dotsaxis "
+#define RID_DOTSUP          "dotsup "
+#define RID_DOTSDOWN        "dotsdown "
+#define RID_DOTSLOW         "dotslow "
+#define RID_DOTSVERT        "dotsvert "
+#define RID_XCIRCY          "<?> circ <?> "
+#define RID_XWIDESLASHY     "{<?>} wideslash {<?>} "
+#define RID_XWIDEBSLASHY    "{<?>} widebslash {<?>} "
+#define RID_XDIVIDESY       "<?> divides <?> "
+#define RID_XNDIVIDESY      "<?> ndivides <?> "
+#define RID_DLARROW         "<?> dlarrow <?> "
+#define RID_DLRARROW        "<?> dlrarrow <?> "
+#define RID_DRARROW         "<?> drarrow <?> "
+#define RID_SETN            "setN "
+#define RID_SETZ            "setZ "
+#define RID_SETQ            "setQ "
+#define RID_SETR            "setR "
+#define RID_SETC            "setC "
+#define RID_WIDEHATX        "widehat {<?>} "
+#define RID_WIDETILDEX      "widetilde {<?>} "
+#define RID_WIDEVECX        "widevec {<?>} "
+#define RID_WIDEHARPOONX    "wideharpoon {<?>} "
+#define RID_HBAR            "hbar "
+#define RID_LAMBDABAR       "lambdabar "
+#define RID_LEFTARROW       "leftarrow "
+#define RID_RIGHTARROW      "rightarrow "
+#define RID_UPARROW         "uparrow "
+#define RID_DOWNARROW       "downarrow "
+#define RID_NOSPACE         "nospace {<?>} "
+#define RID_XPRECEDESY      "<?> prec <?> "
+#define RID_XPRECEDESEQUALY "<?> preccurlyeq <?> "
+#define RID_XPRECEDESEQUIVY "<?> precsim <?> "
+#define RID_XSUCCEEDSY      "<?> succ <?> "
+#define RID_XSUCCEEDSEQUALY "<?> succcurlyeq <?> "
+#define RID_XSUCCEEDSEQUIVY "<?> succsim <?> "
+#define RID_XNOTPRECEDESY   "<?> nprec <?> "
+#define RID_XNOTSUCCEEDSY   "<?> nsucc <?> "
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */
diff --git a/starmath/inc/symbol.hxx b/starmath/inc/symbol.hxx
new file mode 100644
index 000000000..9a9a595ed
--- /dev/null
+++ b/starmath/inc/symbol.hxx
@@ -0,0 +1,106 @@
+/* -*- 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 .
+ */
+
+#ifndef INCLUDED_STARMATH_INC_SYMBOL_HXX
+#define INCLUDED_STARMATH_INC_SYMBOL_HXX
+
+#include <map>
+#include <vector>
+#include <set>
+
+#include "utility.hxx"
+
+
+#define SYMBOL_NONE     0xFFFF
+
+class SmSym
+{
+private:
+    SmFace              m_aFace;
+    OUString            m_aName;
+    OUString            m_aExportName;
+    OUString            m_aSetName;
+    sal_UCS4            m_cChar;
+    bool                m_bPredefined;
+
+public:
+    SmSym();
+    SmSym(const OUString& rName, const vcl::Font& rFont, sal_UCS4 cChar,
+          const OUString& rSet, bool bIsPredefined = false);
+    SmSym(const SmSym& rSymbol);
+
+    SmSym&      operator = (const SmSym& rSymbol);
+
+    const vcl::Font&  GetFace() const { return m_aFace; }
+    sal_UCS4        GetCharacter() const { return m_cChar; }
+    const OUString&   GetName() const { return m_aName; }
+
+    bool            IsPredefined() const        { return m_bPredefined; }
+    const OUString& GetSymbolSetName() const    { return m_aSetName; }
+    const OUString& GetExportName() const       { return m_aExportName; }
+    void            SetExportName( const OUString &rName )        { m_aExportName = rName; }
+
+    // true if rSymbol has the same name, font and character
+    bool            IsEqualInUI( const SmSym& rSymbol ) const;
+};
+
+// type of the actual container to hold the symbols
+typedef std::map< OUString, SmSym >    SymbolMap_t;
+
+// vector of pointers to the actual symbols in the above container
+typedef std::vector< const SmSym * >            SymbolPtrVec_t;
+
+
+class SmSymbolManager
+{
+private:
+    SymbolMap_t         m_aSymbols;
+    bool                m_bModified;
+
+public:
+    SmSymbolManager();
+    SmSymbolManager(const SmSymbolManager& rSymbolSetManager);
+    ~SmSymbolManager();
+
+    SmSymbolManager &   operator = (const SmSymbolManager& rSymbolSetManager);
+
+    // symbol sets are for UI purpose only, thus we assemble them here
+    std::set< OUString >      GetSymbolSetNames() const;
+    SymbolPtrVec_t          GetSymbolSet(  const OUString& rSymbolSetName );
+
+    SymbolPtrVec_t          GetSymbols() const;
+    bool                    AddOrReplaceSymbol( const SmSym & rSymbol, bool bForceChange = false );
+    void                    RemoveSymbol( const OUString & rSymbolName );
+
+    SmSym       *   GetSymbolByName(const OUString& rSymbolName);
+    const SmSym *   GetSymbolByName(const OUString& rSymbolName) const
+    {
+        return const_cast<SmSymbolManager *>(this)->GetSymbolByName(rSymbolName);
+    }
+
+    bool        IsModified() const          { return m_bModified; }
+    void        SetModified(bool bModify)   { m_bModified = bModify; }
+
+    void        Load();
+    void        Save();
+};
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/starmath/inc/token.hxx b/starmath/inc/token.hxx
new file mode 100644
index 000000000..cdc91ddf4
--- /dev/null
+++ b/starmath/inc/token.hxx
@@ -0,0 +1,142 @@
+/* -*- 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 .
+ */
+#ifndef INCLUDED_STARMATH_INC_TOKEN_HXX
+#define INCLUDED_STARMATH_INC_TOKEN_HXX
+
+#include <sal/types.h>
+#include <rtl/ustring.hxx>
+#include <o3tl/typed_flags_set.hxx>
+
+// TokenGroups
+enum class TG {
+    NONE          = 0x000000,
+    Oper          = 0x000001,
+    Relation      = 0x000002,
+    Sum           = 0x000004,
+    Product       = 0x000008,
+    UnOper        = 0x000010,
+    Power         = 0x000020,
+    Attribute     = 0x000040,
+    Align         = 0x000080,
+    Function      = 0x000100,
+    Blank         = 0x000200,
+    LBrace        = 0x000400,
+    RBrace        = 0x000800,
+    Color         = 0x001000,
+    Font          = 0x002000,
+    Standalone    = 0x004000,
+    Limit         = 0x010000,
+    FontAttr      = 0x020000
+};
+
+namespace o3tl {
+    template<> struct typed_flags<TG> : is_typed_flags<TG, 0x037fff> {};
+}
+
+enum SmTokenType
+{
+    TEND,           TLGROUP,        TRGROUP,        TLPARENT,       TRPARENT,
+    TLBRACKET,      TRBRACKET,      TPLUS,          TMINUS,         TMULTIPLY,
+    TDIVIDEBY,      TASSIGN,        TPOUND,         TSPECIAL,       TSLASH,
+    TBACKSLASH,     TBLANK,         TSBLANK,        TRSUB,          TRSUP,
+    TCSUB,          TCSUP,          TLSUB,          TLSUP,          TGT,
+    TLT,            TAND,           TOR,            TINTERSECT,     TUNION,
+    TNEWLINE,       TBINOM,         TFROM,          TTO,            TINT,
+    TSUM,           TOPER,          TABS,           TSQRT,          TFACT,
+    TNROOT,         TOVER,          TTIMES,         TGE,            TLE,
+    TGG,            TLL,            TDOTSAXIS,      TDOTSLOW,       TDOTSVERT,
+    TDOTSDIAG,      TDOTSUP,        TDOTSDOWN,      TACUTE,         TBAR,
+    TBREVE,         TCHECK,         TCIRCLE,        TDOT,           TDDOT,
+    TDDDOT,         TGRAVE,         THAT,           TTILDE,         TVEC,
+    THARPOON,
+    TUNDERLINE,     TOVERLINE,      TOVERSTRIKE,    TITALIC,        TNITALIC,
+    TBOLD,          TNBOLD,         TPHANTOM,       TFONT,          TSIZE,
+    TCOLOR,         TALIGNL,        TALIGNC,        TALIGNR,        TLEFT,
+    TRIGHT,         TLANGLE,        TLBRACE,        TLLINE,         TLDLINE,
+    TLCEIL,         TLFLOOR,        TNONE,          TMLINE,         TRANGLE,
+    TRBRACE,        TRLINE,         TRDLINE,        TRCEIL,         TRFLOOR,
+    TSIN,           TCOS,           TTAN,           TCOT,           TFUNC,
+    TSTACK,         TMATRIX,        TDPOUND,        TPLACE,
+    TTEXT,          TNUMBER,        TCHARACTER,     TIDENT,         TNEQ,
+    TEQUIV,         TDEF,           TPROP,          TSIM,           TSIMEQ,
+    TAPPROX,        TPARALLEL,      TORTHO,         TIN,            TNOTIN,
+    TSUBSET,        TSUBSETEQ,      TSUPSET,        TSUPSETEQ,      TPLUSMINUS,
+    TMINUSPLUS,     TOPLUS,         TOMINUS,        TDIV,           TOTIMES,
+    TODIVIDE,       TTRANSL,        TTRANSR,        TIINT,          TIIINT,
+    TLINT,          TLLINT,         TLLLINT,        TPROD,          TCOPROD,
+    TFORALL,        TEXISTS,        TNOTEXISTS,     TLIM,           TNABLA,
+    TTOWARD,        TSINH,          TCOSH,          TTANH,          TCOTH,
+    TASIN,          TACOS,          TATAN,          TLN,            TLOG,
+    TUOPER,         TBOPER,         TBLACK,         TWHITE,         TRED,
+    TGREEN,         TBLUE,          TCYAN,          TMAGENTA,       TYELLOW,
+    TFIXED,         TSANS,          TSERIF,         TASINH,
+    TACOSH,         TATANH,         TACOTH,         TACOT,          TEXP,
+    TCDOT,          TODOT,          TLESLANT,       TGESLANT,       TNSUBSET,
+    TNSUPSET,       TNSUBSETEQ,     TNSUPSETEQ,     TPARTIAL,       TNEG,
+    TNI,            TBACKEPSILON,   TALEPH,         TIM,            TRE,
+    TWP,            TEMPTYSET,      TINFINITY,      TESCAPE,        TLIMSUP,
+    TLIMINF,        TNDIVIDES,      TDRARROW,       TDLARROW,       TDLRARROW,
+    TUNDERBRACE,    TOVERBRACE,     TCIRC,          THBAR,
+    TLAMBDABAR,     TLEFTARROW,     TRIGHTARROW,    TUPARROW,       TDOWNARROW,
+    TDIVIDES,       TSETN,          TSETZ,          TSETQ,
+    TSETR,          TSETC,          TWIDEVEC,       TWIDEHARPOON,   TWIDETILDE,
+    TWIDEHAT,
+    TWIDESLASH,     TWIDEBACKSLASH, TLDBRACKET,     TRDBRACKET,     TNOSPACE,
+    TUNKNOWN,       TPRECEDES,      TSUCCEEDS,      TPRECEDESEQUAL, TSUCCEEDSEQUAL,
+    TPRECEDESEQUIV, TSUCCEEDSEQUIV, TNOTPRECEDES,   TNOTSUCCEEDS,   TSILVER,
+    TGRAY,          TMAROON,        TPURPLE,        TLIME,          TOLIVE,
+    TNAVY,          TTEAL,          TAQUA,          TFUCHSIA,       TINTD,
+    TRGB,           TLAPLACE
+};
+
+struct SmToken
+{
+
+    OUString        aText;      // token text
+    SmTokenType     eType;      // token info
+    sal_Unicode cMathChar;
+
+    // parse-help info
+    TG              nGroup;
+    sal_uInt16      nLevel;
+
+    // token position
+    sal_Int32      nRow; // 1-based
+    sal_Int32      nCol; // 1-based
+
+    SmToken();
+    SmToken(SmTokenType eTokenType,
+            sal_Unicode cMath,
+            const char* pText,
+            TG nTokenGroup = TG::NONE,
+            sal_uInt16 nTokenLevel = 0);
+};
+
+struct SmTokenTableEntry
+{
+    const char* pIdent;
+    SmTokenType      eType;
+    sal_Unicode      cMathChar;
+    TG               nGroup;
+    sal_uInt16       nLevel;
+};
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/starmath/inc/types.hxx b/starmath/inc/types.hxx
new file mode 100644
index 000000000..044b2fab0
--- /dev/null
+++ b/starmath/inc/types.hxx
@@ -0,0 +1,203 @@
+/* -*- 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 .
+ */
+
+#ifndef INCLUDED_STARMATH_INC_TYPES_HXX
+#define INCLUDED_STARMATH_INC_TYPES_HXX
+
+#include <sal/types.h>
+#define FONTNAME_MATH   "OpenSymbol"
+
+
+enum SmPrintSize { PRINT_SIZE_NORMAL, PRINT_SIZE_SCALED, PRINT_SIZE_ZOOMED };
+
+
+// definitions for characters from the 'StarSymbol' font
+// (some chars have more than one alias!)
+//! Note: not listed here does not(!) mean "not used"
+//!     (see %alpha ... %gamma for example)
+
+sal_Unicode const MS_FACT = 0x0021;
+sal_Unicode const MS_INFINITY = 0x221E;
+sal_Unicode const MS_SLASH = 0x002F;
+
+sal_Unicode const MS_NDIVIDES = 0x2224;
+sal_Unicode const MS_DRARROW = 0x21D2;
+sal_Unicode const MS_DLARROW = 0x21D0;
+sal_Unicode const MS_DLRARROW = 0x21D4;
+sal_Unicode const MS_OVERBRACE = 0x23DE;
+sal_Unicode const MS_UNDERBRACE = 0x23DF;
+sal_Unicode const MS_CIRC = 0x2218;
+sal_Unicode const MS_ASSIGN = 0x003D;
+sal_Unicode const MS_ERROR = 0x00BF;
+
+sal_Unicode const MS_NEQ = 0x2260;
+sal_Unicode const MS_PLUS = 0x002B;
+sal_Unicode const MS_MINUS = 0x2212;
+sal_Unicode const MS_MULTIPLY = 0x2217;
+sal_Unicode const MS_TIMES = 0x00D7;
+sal_Unicode const MS_CDOT = 0x22C5;
+sal_Unicode const MS_DIV = 0x00F7;
+sal_Unicode const MS_PLUSMINUS = 0x00B1;
+sal_Unicode const MS_MINUSPLUS = 0x2213;
+sal_Unicode const MS_OPLUS = 0x2295;
+sal_Unicode const MS_OMINUS = 0x2296;
+sal_Unicode const MS_OTIMES = 0x2297;
+sal_Unicode const MS_ODIVIDE = 0x2298;
+sal_Unicode const MS_ODOT = 0x2299;
+sal_Unicode const MS_UNION = 0x222A;
+sal_Unicode const MS_INTERSECT = 0x2229;
+
+sal_Unicode const MS_LT = 0x003C;
+sal_Unicode const MS_GT = 0x003E;
+sal_Unicode const MS_LE = 0x2264;
+sal_Unicode const MS_GE = 0x2265;
+sal_Unicode const MS_LESLANT = 0x2A7D;
+sal_Unicode const MS_GESLANT = 0x2A7E;
+sal_Unicode const MS_LL = 0x226A;
+sal_Unicode const MS_GG = 0x226B;
+sal_Unicode const MS_SIM = 0x223C;
+sal_Unicode const MS_SIMEQ = 0x2243;
+sal_Unicode const MS_APPROX = 0x2248;
+sal_Unicode const MS_DEF = 0x225D;
+sal_Unicode const MS_EQUIV = 0x2261;
+sal_Unicode const MS_PROP = 0x221D;
+sal_Unicode const MS_PARTIAL = 0x2202;
+sal_Unicode const MS_LAPLACE = 0x2112;
+
+sal_Unicode const MS_SUBSET = 0x2282;
+sal_Unicode const MS_SUPSET = 0x2283;
+sal_Unicode const MS_SUBSETEQ = 0x2286;
+sal_Unicode const MS_SUPSETEQ = 0x2287;
+sal_Unicode const MS_NSUBSET = 0x2284;
+sal_Unicode const MS_NSUPSET = 0x2285;
+sal_Unicode const MS_NSUBSETEQ = 0x2288;
+sal_Unicode const MS_NSUPSETEQ = 0x2289;
+sal_Unicode const MS_IN = 0x2208;
+sal_Unicode const MS_NOTIN = 0x2209;
+sal_Unicode const MS_EXISTS = 0x2203;
+sal_Unicode const MS_NOTEXISTS = 0x2204;
+sal_Unicode const MS_BACKEPSILON = 0x220D;
+sal_Unicode const MS_ALEPH = 0x2135;
+sal_Unicode const MS_IM = 0x2111;
+sal_Unicode const MS_RE = 0x211C;
+sal_Unicode const MS_WP = 0x2118;
+
+sal_Unicode const MS_LINE = 0x2223;
+sal_Unicode const MS_VERTLINE = 0x007C;
+sal_Unicode const MS_DLINE = 0x2225;
+sal_Unicode const MS_DVERTLINE = 0x2016;
+sal_Unicode const MS_ORTHO = 0x22A5;
+sal_Unicode const MS_DOTSLOW = 0x2026;
+sal_Unicode const MS_DOTSAXIS = 0x22EF;
+sal_Unicode const MS_DOTSVERT = 0x22EE;
+sal_Unicode const MS_DOTSUP = 0x22F0;
+sal_Unicode const MS_DOTSDOWN = 0x22F1;
+sal_Unicode const MS_TRANSR = 0x22B6;
+sal_Unicode const MS_TRANSL = 0x22B7;
+sal_Unicode const MS_BACKSLASH = 0x2216;
+sal_Unicode const MS_NEG = 0x00AC;
+
+sal_Unicode const MS_FORALL = 0x2200;
+sal_Unicode const MS_NABLA = 0x2207;
+sal_Unicode const MS_PROD = 0x220F;
+sal_Unicode const MS_COPROD = 0x2210;
+sal_Unicode const MS_SUM = 0x2211;
+sal_Unicode const MS_SQRT = 0x221A;
+sal_Unicode const MS_INT = 0x222B;
+sal_Unicode const MS_IINT = 0x222C;
+sal_Unicode const MS_IIINT = 0x222D;
+sal_Unicode const MS_LINT = 0x222E;
+sal_Unicode const MS_LLINT = 0x222F;
+sal_Unicode const MS_LLLINT = 0x2230;
+
+sal_Unicode const MS_GRAVE = 0x0060;
+sal_Unicode const MS_COMBGRAVE = 0x0300;
+sal_Unicode const MS_ACUTE = 0x00B4;
+sal_Unicode const MS_COMBACUTE = 0x0301;
+sal_Unicode const MS_HAT = 0x005E;
+sal_Unicode const MS_COMBHAT = 0x0302;
+sal_Unicode const MS_TILDE = 0x007E;
+sal_Unicode const MS_COMBTILDE = 0x0303;
+sal_Unicode const MS_BAR = 0x00AF;
+sal_Unicode const MS_COMBBAR = 0x0304;
+sal_Unicode const MS_COMBOVERLINE = 0x0305;
+sal_Unicode const MS_BREVE = 0x02D8;
+sal_Unicode const MS_COMBBREVE = 0x0306;
+sal_Unicode const MS_CIRCLE = 0x02DA;
+sal_Unicode const MS_COMBCIRCLE = 0x030A;
+sal_Unicode const MS_CHECK = 0x02C7;
+sal_Unicode const MS_COMBCHECK = 0x030C;
+sal_Unicode const MS_HARPOON = 0x20D1;
+sal_Unicode const MS_VEC = 0x20D7;
+sal_Unicode const MS_DOT = 0x02D9;
+sal_Unicode const MS_DDOT = 0x00A8;
+sal_Unicode const MS_COMBDOT = 0x0307;
+sal_Unicode const MS_COMBDDOT = 0x0308;
+sal_Unicode const MS_DDDOT = 0x20DB;
+sal_Unicode const MS_AND = 0x2227;
+sal_Unicode const MS_OR = 0x2228;
+sal_Unicode const MS_NI = 0x220B;
+sal_Unicode const MS_EMPTYSET = 0x2205;
+
+sal_Unicode const MS_LPARENT = 0x0028;
+sal_Unicode const MS_RPARENT = 0x0029;
+sal_Unicode const MS_LBRACKET = 0x005B;
+sal_Unicode const MS_RBRACKET = 0x005D;
+sal_Unicode const MS_LBRACE = 0x007B;
+sal_Unicode const MS_RBRACE = 0x007D;
+sal_Unicode const MS_LCEIL = 0x2308;
+sal_Unicode const MS_RCEIL = 0x2309;
+sal_Unicode const MS_LFLOOR = 0x230A;
+sal_Unicode const MS_RFLOOR = 0x230B;
+sal_Unicode const MS_LANGLE = 0x2329;
+sal_Unicode const MS_RANGLE = 0x232A;
+sal_Unicode const MS_LDBRACKET = 0x27E6;
+sal_Unicode const MS_RDBRACKET = 0x27E7;
+sal_Unicode const MS_LMATHANGLE = 0x27E8;
+sal_Unicode const MS_RMATHANGLE = 0x27E9;
+
+sal_Unicode const MS_PLACE = 0x2751;
+
+sal_Unicode const MS_LAMBDABAR = 0x019B;
+sal_Unicode const MS_HBAR = 0x210F;
+sal_Unicode const MS_LEFTARROW = 0x2190;
+sal_Unicode const MS_UPARROW = 0x2191;
+sal_Unicode const MS_RIGHTARROW = 0x2192;
+sal_Unicode const MS_DOWNARROW = 0x2193;
+
+sal_Unicode const MS_SETN = 0x2115;
+sal_Unicode const MS_SETZ = 0x2124;
+sal_Unicode const MS_SETQ = 0x211A;
+sal_Unicode const MS_SETR = 0x211D;
+sal_Unicode const MS_SETC = 0x2102;
+
+sal_Unicode const MS_PERCENT = 0x0025;
+
+sal_Unicode const MS_PRECEDES = 0x227A;
+sal_Unicode const MS_PRECEDESEQUAL = 0x227C;
+sal_Unicode const MS_PRECEDESEQUIV = 0x227E;
+sal_Unicode const MS_SUCCEEDS = 0x227B;
+sal_Unicode const MS_SUCCEEDSEQUAL = 0x227D;
+sal_Unicode const MS_SUCCEEDSEQUIV = 0x227F;
+sal_Unicode const MS_NOTPRECEDES = 0x2280;
+sal_Unicode const MS_NOTSUCCEEDS = 0x2281;
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/starmath/inc/unomodel.hxx b/starmath/inc/unomodel.hxx
new file mode 100644
index 000000000..f18b09381
--- /dev/null
+++ b/starmath/inc/unomodel.hxx
@@ -0,0 +1,99 @@
+/* -*- 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 .
+ */
+#ifndef INCLUDED_STARMATH_INC_UNOMODEL_HXX
+#define INCLUDED_STARMATH_INC_UNOMODEL_HXX
+
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <com/sun/star/view/XRenderable.hpp>
+
+#include <sfx2/sfxbasemodel.hxx>
+#include <comphelper/propertysethelper.hxx>
+#include <vcl/print.hxx>
+#include <oox/mathml/export.hxx>
+#include <oox/mathml/import.hxx>
+#include <memory>
+
+
+#define PRTUIOPT_TITLE_ROW          "TitleRow"
+#define PRTUIOPT_FORMULA_TEXT       "FormulaText"
+#define PRTUIOPT_BORDER             "Border"
+#define PRTUIOPT_PRINT_FORMAT       "PrintFormat"
+#define PRTUIOPT_PRINT_SCALE        "PrintScale"
+
+class SmPrintUIOptions : public vcl::PrinterOptionsHelper
+{
+public:
+    SmPrintUIOptions();
+};
+
+
+class SmModel final : public SfxBaseModel,
+                public comphelper::PropertySetHelper,
+                public css::lang::XServiceInfo,
+                public css::view::XRenderable,
+                public oox::FormulaExportBase,
+                public oox::FormulaImportBase
+{
+    std::unique_ptr<SmPrintUIOptions> m_pPrintUIOptions;
+
+    virtual void _setPropertyValues( const comphelper::PropertyMapEntry** ppEntries, const css::uno::Any* pValues ) override;
+    virtual void _getPropertyValues( const comphelper::PropertyMapEntry** ppEntries, css::uno::Any* pValue ) override;
+public:
+    explicit SmModel( SfxObjectShell *pObjSh );
+    virtual ~SmModel() throw () override;
+
+    //XInterface
+    virtual     css::uno::Any SAL_CALL queryInterface( const css::uno::Type& aType ) override;
+    virtual void SAL_CALL acquire(  ) throw() override;
+    virtual void SAL_CALL release(  ) throw() override;
+
+    //XTypeProvider
+    virtual css::uno::Sequence< css::uno::Type > SAL_CALL getTypes(  ) override;
+
+    static const css::uno::Sequence< sal_Int8 > & getUnoTunnelId();
+
+    //XUnoTunnel
+    virtual sal_Int64 SAL_CALL getSomething( const css::uno::Sequence< sal_Int8 >& aIdentifier ) override;
+
+    //XRenderable
+    virtual sal_Int32 SAL_CALL getRendererCount( const css::uno::Any& rSelection, const css::uno::Sequence< css::beans::PropertyValue >& rxOptions ) override;
+    virtual css::uno::Sequence< css::beans::PropertyValue > SAL_CALL getRenderer( sal_Int32 nRenderer, const css::uno::Any& rSelection, const css::uno::Sequence< css::beans::PropertyValue >& rxOptions ) override;
+    virtual void SAL_CALL render( sal_Int32 nRenderer, const css::uno::Any& rSelection, const css::uno::Sequence< css::beans::PropertyValue >& rxOptions ) override;
+
+    //XServiceInfo
+    virtual OUString SAL_CALL getImplementationName() override;
+    virtual sal_Bool SAL_CALL supportsService(const OUString& ServiceName) override;
+    virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
+
+    virtual void SAL_CALL setParent( const css::uno::Reference< css::uno::XInterface >& xParent ) override;
+
+    // oox::FormulaExportBase
+    virtual void writeFormulaOoxml(::sax_fastparser::FSHelperPtr pSerializer,
+            oox::core::OoxmlVersion version,
+            oox::drawingml::DocumentType documentType, sal_Int8 nAlign) override;
+    virtual void writeFormulaRtf(OStringBuffer& rBuffer, rtl_TextEncoding nEncoding) override;
+    // oox::FormulaImportBase
+    virtual void readFormulaOoxml( oox::formulaimport::XmlStream& stream ) override;
+    virtual Size getFormulaSize() const override;
+};
+
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/starmath/inc/utility.hxx b/starmath/inc/utility.hxx
new file mode 100644
index 000000000..2a462b98d
--- /dev/null
+++ b/starmath/inc/utility.hxx
@@ -0,0 +1,147 @@
+/* -*- 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 .
+ */
+#ifndef INCLUDED_STARMATH_INC_UTILITY_HXX
+#define INCLUDED_STARMATH_INC_UTILITY_HXX
+
+#include <sal/config.h>
+
+#include <sal/log.hxx>
+#include <vcl/font.hxx>
+#include <vcl/weld.hxx>
+#include <tools/fract.hxx>
+#include <deque>
+
+inline long SmPtsTo100th_mm(long nNumPts)
+    // returns the length (in 100th of mm) that corresponds to the length
+    // 'nNumPts' (in units points).
+    // 72.27 [pt] = 1 [inch] = 2,54 [cm] = 2540 [100th of mm].
+    // result is being rounded to the nearest integer.
+{
+    SAL_WARN_IF( nNumPts < 0, "starmath", "Ooops..." );
+    // broken into multiple and fraction of 'nNumPts' to reduce chance
+    // of overflow
+    // (7227 / 2) is added in order to round to the nearest integer
+    return 35 * nNumPts + (nNumPts * 1055L + (7227 / 2)) / 7227L;
+}
+
+
+inline Fraction Sm100th_mmToPts(long nNum100th_mm)
+    // returns the length (in points) that corresponds to the length
+    // 'nNum100th_mm' (in 100th of mm).
+{
+    SAL_WARN_IF( nNum100th_mm < 0, "starmath", "Ooops..." );
+    return Fraction(7227L, 254000L) * Fraction(nNum100th_mm);
+}
+
+
+inline long SmRoundFraction(const Fraction &rFrac)
+{
+    SAL_WARN_IF( rFrac <= Fraction(), "starmath", "Ooops..." );
+    return (rFrac.GetNumerator() + rFrac.GetDenominator() / 2) / rFrac.GetDenominator();
+}
+
+
+class SmViewShell;
+SmViewShell * SmGetActiveView();
+
+
+// SmFace
+
+
+bool    IsItalic( const vcl::Font &rFont );
+bool    IsBold( const vcl::Font &rFont );
+
+class SmFace final : public vcl::Font
+{
+    long    nBorderWidth;
+
+    void    Impl_Init();
+
+public:
+    SmFace() :
+        Font(), nBorderWidth(-1) { Impl_Init(); }
+    SmFace(const Font& rFont) :
+        Font(rFont), nBorderWidth(-1) { Impl_Init(); }
+    SmFace(const OUString& rName, const Size& rSize) :
+        Font(rName, rSize), nBorderWidth(-1) { Impl_Init(); }
+
+    SmFace(const SmFace &rFace) :
+        Font(rFace), nBorderWidth(-1) { Impl_Init(); }
+
+    // overloaded version in order to supply a min value
+    // for font size (height). (Also used in ctor's to do so.)
+    void    SetSize(const Size& rSize);
+
+    void    SetBorderWidth(long nWidth)     { nBorderWidth = nWidth; }
+    long    GetBorderWidth() const;
+    long    GetDefaultBorderWidth() const   { return GetFontSize().Height() / 20 ; }
+    void    FreezeBorderWidth()     { nBorderWidth = GetDefaultBorderWidth(); }
+
+    SmFace & operator = (const SmFace &rFace);
+};
+
+SmFace & operator *= (SmFace &rFace, const Fraction &rFrac);
+
+
+// SmFontPickList
+
+
+class SmFontDialog;
+
+class SmFontPickList
+{
+protected:
+    sal_uInt16 nMaxItems;
+    std::deque<vcl::Font> aFontVec;
+
+public:
+    explicit SmFontPickList(sal_uInt16 nMax = 5) : nMaxItems(nMax) {}
+    virtual ~SmFontPickList() { Clear(); }
+
+    virtual void    Insert(const vcl::Font &rFont);
+
+    void            Clear();
+    vcl::Font       Get(sal_uInt16 nPos = 0) const;
+
+    SmFontPickList& operator = (const SmFontPickList& rList);
+
+    void            ReadFrom(const SmFontDialog& rDialog);
+    void            WriteTo(SmFontDialog& rDialog) const;
+};
+
+
+//  SmFontPickListBox
+
+
+class SmFontPickListBox final : public SmFontPickList
+{
+private:
+    std::unique_ptr<weld::ComboBox> m_xWidget;
+
+    DECL_LINK(SelectHdl, weld::ComboBox&, void);
+
+public:
+    SmFontPickListBox(std::unique_ptr<weld::ComboBox> pWidget);
+    SmFontPickListBox& operator = (const SmFontPickList& rList);
+    virtual void    Insert(const vcl::Font &rFont) override;
+};
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/starmath/inc/view.hxx b/starmath/inc/view.hxx
new file mode 100644
index 000000000..b3625b7dc
--- /dev/null
+++ b/starmath/inc/view.hxx
@@ -0,0 +1,319 @@
+/* -*- 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 .
+ */
+#ifndef INCLUDED_STARMATH_INC_VIEW_HXX
+#define INCLUDED_STARMATH_INC_VIEW_HXX
+
+#include <sal/config.h>
+
+#include <memory>
+
+#include <rtl/ref.hxx>
+#include <sfx2/dockwin.hxx>
+#include <sfx2/viewsh.hxx>
+#include <svtools/scrwin.hxx>
+#include <sfx2/ctrlitem.hxx>
+#include <sfx2/shell.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <vcl/timer.hxx>
+#include "document.hxx"
+#include "edit.hxx"
+
+class SmViewShell;
+class SmPrintUIOptions;
+class SmGraphicAccessible;
+class SmNode;
+
+namespace svtools { class ColorConfig; }
+
+class SmGraphicWindow final : public ScrollableWindow
+{
+public:
+    bool IsCursorVisible() const
+    {
+        return bIsCursorVisible;
+    }
+    void ShowCursor(bool bShow);
+    bool IsLineVisible() const
+    {
+        return bIsLineVisible;
+    }
+    void ShowLine(bool bShow);
+    const SmNode * SetCursorPos(sal_uInt16 nRow, sal_uInt16 nCol);
+
+    explicit SmGraphicWindow(SmViewShell* pShell);
+    virtual ~SmGraphicWindow() override;
+    virtual void dispose() override;
+
+    // Window
+    virtual void ApplySettings(vcl::RenderContext&) override;
+    virtual void MouseButtonDown(const MouseEvent &rMEvt) override;
+    virtual void MouseMove(const MouseEvent &rMEvt) override;
+    virtual void GetFocus() override;
+    virtual void LoseFocus() override;
+
+    SmViewShell* GetView()
+    {
+        return pViewShell;
+    }
+
+    using Window::SetZoom;
+    void SetZoom(sal_uInt16 Factor);
+    using Window::GetZoom;
+    sal_uInt16 GetZoom() const
+    {
+        return nZoom;
+    }
+
+    const Point& GetFormulaDrawPos() const
+    {
+        return aFormulaDrawPos;
+    }
+
+    void ZoomToFitInWindow();
+    using ScrollableWindow::SetTotalSize;
+    void SetTotalSize();
+
+    // for Accessibility
+    virtual css::uno::Reference<css::accessibility::XAccessible> CreateAccessible() override;
+
+    using Window::GetAccessible;
+    SmGraphicAccessible* GetAccessible_Impl()
+    {
+        return mxAccessible.get();
+    }
+
+private:
+    void SetIsCursorVisible(bool bVis)
+    {
+        bIsCursorVisible = bVis;
+    }
+    using Window::SetCursor;
+    void SetCursor(const SmNode *pNode);
+    void SetCursor(const tools::Rectangle &rRect);
+    bool IsInlineEditEnabled() const;
+
+    virtual void Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle&) override;
+    virtual void KeyInput(const KeyEvent& rKEvt) override;
+    virtual void Command(const CommandEvent& rCEvt) override;
+    virtual void StateChanged( StateChangedType eChanged ) override;
+
+    void RepaintViewShellDoc();
+    DECL_LINK(CaretBlinkTimerHdl, Timer *, void);
+    void CaretBlinkInit();
+    void CaretBlinkStart();
+    void CaretBlinkStop();
+
+    Point aFormulaDrawPos;
+    // old style editing pieces
+    tools::Rectangle aCursorRect;
+    bool bIsCursorVisible;
+    bool bIsLineVisible;
+    AutoTimer aCaretBlinkTimer;
+    rtl::Reference<SmGraphicAccessible> mxAccessible;
+    SmViewShell* pViewShell;
+    sal_uInt16 nZoom;
+};
+
+class SmGraphicController final : public SfxControllerItem
+{
+    SmGraphicWindow &rGraphic;
+public:
+    SmGraphicController(SmGraphicWindow &, sal_uInt16, SfxBindings & );
+    virtual void StateChanged(sal_uInt16             nSID,
+                              SfxItemState       eState,
+                              const SfxPoolItem* pState) override;
+};
+
+class SmEditController final : public SfxControllerItem
+{
+    SmEditWindow &rEdit;
+
+public:
+    SmEditController(SmEditWindow &, sal_uInt16, SfxBindings  & );
+
+    virtual void StateChanged(sal_uInt16 nSID, SfxItemState eState, const SfxPoolItem* pState) override;
+};
+
+class SmCmdBoxWindow : public SfxDockingWindow
+{
+    VclPtr<SmEditWindow>        aEdit;
+    SmEditController    aController;
+    bool                bExiting;
+
+    Timer               aInitialFocusTimer;
+
+    DECL_LINK(InitialFocusTimerHdl, Timer *, void);
+
+protected:
+
+    // Window
+    virtual void    GetFocus() override;
+    virtual void Resize() override;
+    virtual void Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect) override;
+    virtual void StateChanged( StateChangedType nStateChange ) override;
+
+    virtual Size CalcDockingSize(SfxChildAlignment eAlign) override;
+    virtual SfxChildAlignment CheckAlignment(SfxChildAlignment eActual,
+                                             SfxChildAlignment eWish) override;
+
+    virtual void    ToggleFloatingMode() override;
+
+public:
+    SmCmdBoxWindow(SfxBindings    *pBindings,
+                   SfxChildWindow *pChildWindow,
+                   Window         *pParent);
+
+    virtual ~SmCmdBoxWindow () override;
+    virtual void dispose() override;
+
+    void AdjustPosition();
+
+    SmEditWindow& GetEditWindow()
+    {
+        return *aEdit;
+    }
+    SmViewShell* GetView();
+};
+
+class SmCmdBoxWrapper final : public SfxChildWindow
+{
+    SFX_DECL_CHILDWINDOW_WITHID(SmCmdBoxWrapper);
+
+    SmCmdBoxWrapper(vcl::Window* pParentWindow, sal_uInt16 nId, SfxBindings* pBindings, SfxChildWinInfo* pInfo);
+
+public:
+
+    SmEditWindow& GetEditWindow()
+    {
+        return static_cast<SmCmdBoxWindow *>(GetWindow())->GetEditWindow();
+    }
+};
+
+namespace sfx2 { class FileDialogHelper; }
+struct SmViewShell_Impl;
+
+class SmViewShell: public SfxViewShell
+{
+    std::unique_ptr<SmViewShell_Impl> mpImpl;
+
+    VclPtr<SmGraphicWindow> mpGraphic;
+    SmGraphicController maGraphicController;
+    OUString maStatusText;
+
+    bool mbPasteState;
+
+    DECL_LINK( DialogClosedHdl, sfx2::FileDialogHelper*, void );
+    virtual void            Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) override;
+
+    /** Used to determine whether insertions using SID_INSERTSPECIAL and SID_INSERTCOMMANDTEXT
+     * should be inserted into SmEditWindow or directly into the SmDocShell as done if the
+     * visual editor was last to have focus.
+     */
+    bool mbInsertIntoEditWindow;
+protected:
+
+    static Size GetTextLineSize(OutputDevice const & rDevice,
+                         const OUString& rLine);
+    static Size GetTextSize(OutputDevice const & rDevice,
+                     const OUString& rText,
+                     long          MaxWidth);
+    static void DrawTextLine(OutputDevice& rDevice,
+                      const Point&  rPosition,
+                      const OUString& rLine);
+    static void DrawText(OutputDevice& rDevice,
+                  const Point&  rPosition,
+                  const OUString& rText,
+                  sal_uInt16        MaxWidth);
+
+    virtual SfxPrinter *GetPrinter(bool bCreate = false) override;
+    virtual sal_uInt16 SetPrinter(SfxPrinter *pNewPrinter,
+                              SfxPrinterChangeFlags nDiffFlags = SFX_PRINTER_ALL) override;
+
+    void Insert( SfxMedium& rMedium );
+    void InsertFrom(SfxMedium &rMedium);
+
+    virtual bool HasPrintOptionsPage() const override;
+    virtual std::unique_ptr<SfxTabPage> CreatePrintOptionsPage(weld::Container* pPage, weld::DialogController* pController,
+                                                               const SfxItemSet &rOptions) override;
+    virtual void Deactivate(bool IsMDIActivate) override;
+    virtual void Activate(bool IsMDIActivate) override;
+    virtual void InnerResizePixel(const Point &rOfs, const Size  &rSize, bool inplaceEditModeChange) override;
+    virtual void OuterResizePixel(const Point &rOfs, const Size  &rSize) override;
+    virtual void QueryObjAreaPixel( tools::Rectangle& rRect ) const override;
+    virtual void SetZoomFactor( const Fraction &rX, const Fraction &rY ) override;
+
+public:
+
+    SmViewShell(SfxViewFrame *pFrame, SfxViewShell *pOldSh);
+    virtual ~SmViewShell() override;
+
+    SmDocShell * GetDoc()
+    {
+        return static_cast<SmDocShell *>( GetViewFrame()->GetObjectShell() );
+    }
+
+    SmEditWindow * GetEditWindow();
+
+    SmGraphicWindow& GetGraphicWindow()
+    {
+        return *mpGraphic;
+    }
+    const SmGraphicWindow& GetGraphicWindow() const
+    {
+        return *mpGraphic;
+    }
+
+    void        SetStatusText(const OUString& rText);
+
+    void        ShowError( const SmErrorDesc *pErrorDesc );
+    void        NextError();
+    void        PrevError();
+
+    SFX_DECL_INTERFACE(SFX_INTERFACE_SMA_START+SfxInterfaceId(2))
+    SFX_DECL_VIEWFACTORY(SmViewShell);
+
+private:
+    /// SfxInterface initializer.
+    static void InitInterface_Impl();
+
+public:
+    void Execute( SfxRequest& rReq );
+    void GetState(SfxItemSet &);
+
+    void Impl_Print( OutputDevice &rOutDev, const SmPrintUIOptions &rPrintUIOptions,
+            tools::Rectangle aOutRect );
+
+    /** Set bInsertIntoEditWindow so we know where to insert
+     *
+     * This method is called whenever SmGraphicWindow or SmEditWindow gets focus,
+     * so that when text is inserted from catalog or elsewhere we know whether to
+     * insert for the visual editor, or the text editor.
+     */
+    void SetInsertIntoEditWindow(bool bEditWindowHadFocusLast){
+        mbInsertIntoEditWindow = bEditWindowHadFocusLast;
+    }
+    bool IsInlineEditEnabled() const;
+
+private:
+    void ZoomByItemSet(const SfxItemSet *pSet);
+};
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/starmath/inc/visitors.hxx b/starmath/inc/visitors.hxx
new file mode 100644
index 000000000..3f903aba8
--- /dev/null
+++ b/starmath/inc/visitors.hxx
@@ -0,0 +1,462 @@
+/* -*- 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/.
+ */
+#ifndef INCLUDED_STARMATH_INC_VISITORS_HXX
+#define INCLUDED_STARMATH_INC_VISITORS_HXX
+
+#include <sal/config.h>
+
+#include <sal/log.hxx>
+
+#include "node.hxx"
+#include "caret.hxx"
+#include <memory>
+
+/** Base class for visitors that visits a tree of SmNodes
+ * @remarks all methods have been left abstract to ensure that implementers
+ * don't forget to implement one.
+ */
+class SmVisitor
+{
+public:
+    virtual void Visit( SmTableNode* pNode ) = 0;
+    virtual void Visit( SmBraceNode* pNode ) = 0;
+    virtual void Visit( SmBracebodyNode* pNode ) = 0;
+    virtual void Visit( SmOperNode* pNode ) = 0;
+    virtual void Visit( SmAlignNode* pNode ) = 0;
+    virtual void Visit( SmAttributNode* pNode ) = 0;
+    virtual void Visit( SmFontNode* pNode ) = 0;
+    virtual void Visit( SmUnHorNode* pNode ) = 0;
+    virtual void Visit( SmBinHorNode* pNode ) = 0;
+    virtual void Visit( SmBinVerNode* pNode ) = 0;
+    virtual void Visit( SmBinDiagonalNode* pNode ) = 0;
+    virtual void Visit( SmSubSupNode* pNode ) = 0;
+    virtual void Visit( SmMatrixNode* pNode ) = 0;
+    virtual void Visit( SmPlaceNode* pNode ) = 0;
+    virtual void Visit( SmTextNode* pNode ) = 0;
+    virtual void Visit( SmSpecialNode* pNode ) = 0;
+    virtual void Visit( SmGlyphSpecialNode* pNode ) = 0;
+    virtual void Visit( SmMathSymbolNode* pNode ) = 0;
+    virtual void Visit( SmBlankNode* pNode ) = 0;
+    virtual void Visit( SmErrorNode* pNode ) = 0;
+    virtual void Visit( SmLineNode* pNode ) = 0;
+    virtual void Visit( SmExpressionNode* pNode ) = 0;
+    virtual void Visit( SmPolyLineNode* pNode ) = 0;
+    virtual void Visit( SmRootNode* pNode ) = 0;
+    virtual void Visit( SmRootSymbolNode* pNode ) = 0;
+    virtual void Visit( SmRectangleNode* pNode ) = 0;
+    virtual void Visit( SmVerticalBraceNode* pNode ) = 0;
+
+protected:
+    ~SmVisitor() {}
+};
+
+// SmDefaultingVisitor
+
+
+/** Visitor that uses DefaultVisit for handling visits by default
+ *
+ * This abstract baseclass is useful for visitors where many methods share the same
+ * implementation.
+ */
+class SmDefaultingVisitor : public SmVisitor
+{
+public:
+    void Visit( SmTableNode* pNode ) override;
+    void Visit( SmBraceNode* pNode ) override;
+    void Visit( SmBracebodyNode* pNode ) override;
+    void Visit( SmOperNode* pNode ) override;
+    void Visit( SmAlignNode* pNode ) override;
+    void Visit( SmAttributNode* pNode ) override;
+    void Visit( SmFontNode* pNode ) override;
+    void Visit( SmUnHorNode* pNode ) override;
+    void Visit( SmBinHorNode* pNode ) override;
+    void Visit( SmBinVerNode* pNode ) override;
+    void Visit( SmBinDiagonalNode* pNode ) override;
+    void Visit( SmSubSupNode* pNode ) override;
+    void Visit( SmMatrixNode* pNode ) override;
+    void Visit( SmPlaceNode* pNode ) override;
+    void Visit( SmTextNode* pNode ) override;
+    void Visit( SmSpecialNode* pNode ) override;
+    void Visit( SmGlyphSpecialNode* pNode ) override;
+    void Visit( SmMathSymbolNode* pNode ) override;
+    void Visit( SmBlankNode* pNode ) override;
+    void Visit( SmErrorNode* pNode ) override;
+    void Visit( SmLineNode* pNode ) override;
+    void Visit( SmExpressionNode* pNode ) override;
+    void Visit( SmPolyLineNode* pNode ) override;
+    void Visit( SmRootNode* pNode ) override;
+    void Visit( SmRootSymbolNode* pNode ) override;
+    void Visit( SmRectangleNode* pNode ) override;
+    void Visit( SmVerticalBraceNode* pNode ) override;
+protected:
+    ~SmDefaultingVisitor() {}
+
+    /** Method invoked by Visit methods by default */
+    virtual void DefaultVisit( SmNode* pNode ) = 0;
+};
+
+// SmCaretDrawingVisitor
+
+/** Visitor for drawing a caret position */
+class SmCaretDrawingVisitor final : public SmDefaultingVisitor
+{
+public:
+    /** Given position and device this constructor will draw the caret */
+    SmCaretDrawingVisitor( OutputDevice& rDevice, SmCaretPos position, Point offset, bool caretVisible );
+    virtual ~SmCaretDrawingVisitor() {}
+    void Visit( SmTextNode* pNode ) override;
+    using SmDefaultingVisitor::Visit;
+private:
+    OutputDevice &mrDev;
+    SmCaretPos maPos;
+    /** Offset to draw from */
+    Point  maOffset;
+    bool  mbCaretVisible;
+
+    /** Default method for drawing pNodes */
+    void DefaultVisit( SmNode* pNode ) override;
+};
+
+// SmCaretPos2LineVisitor
+
+/** Visitor getting a line from a caret position */
+class SmCaretPos2LineVisitor final : public SmDefaultingVisitor
+{
+public:
+    /** Given position and device this constructor will compute a line for the caret */
+    SmCaretPos2LineVisitor( OutputDevice *pDevice, SmCaretPos position )
+        : mpDev( pDevice )
+        , maPos( position )
+    {
+        SAL_WARN_IF( !position.IsValid(), "starmath", "Cannot draw invalid position!" );
+
+        maPos.pSelectedNode->Accept( this );
+    }
+    virtual ~SmCaretPos2LineVisitor() {}
+    void Visit( SmTextNode* pNode ) override;
+    using SmDefaultingVisitor::Visit;
+    const SmCaretLine& GetResult( ) const {
+        return maLine;
+    }
+private:
+    SmCaretLine maLine;
+    VclPtr<OutputDevice> mpDev;
+    SmCaretPos maPos;
+
+    /** Default method for computing lines for pNodes */
+    void DefaultVisit( SmNode* pNode ) override;
+};
+
+// SmDrawingVisitor
+
+/** Visitor for drawing SmNodes to OutputDevice */
+class SmDrawingVisitor final : public SmVisitor
+{
+public:
+    /** Create an instance of SmDrawingVisitor, and use it to draw a formula
+     * @param rDevice   Device to draw on
+     * @param position  Offset on device to draw the formula
+     * @param pTree     Formula tree to draw
+     * @remarks This constructor will do the drawing, no need to anything more.
+     */
+    SmDrawingVisitor( OutputDevice &rDevice, Point position, SmNode* pTree )
+        : mrDev( rDevice )
+        , maPosition( position )
+    {
+        pTree->Accept( this );
+    }
+    virtual ~SmDrawingVisitor() {}
+    void Visit( SmTableNode* pNode ) override;
+    void Visit( SmBraceNode* pNode ) override;
+    void Visit( SmBracebodyNode* pNode ) override;
+    void Visit( SmOperNode* pNode ) override;
+    void Visit( SmAlignNode* pNode ) override;
+    void Visit( SmAttributNode* pNode ) override;
+    void Visit( SmFontNode* pNode ) override;
+    void Visit( SmUnHorNode* pNode ) override;
+    void Visit( SmBinHorNode* pNode ) override;
+    void Visit( SmBinVerNode* pNode ) override;
+    void Visit( SmBinDiagonalNode* pNode ) override;
+    void Visit( SmSubSupNode* pNode ) override;
+    void Visit( SmMatrixNode* pNode ) override;
+    void Visit( SmPlaceNode* pNode ) override;
+    void Visit( SmTextNode* pNode ) override;
+    void Visit( SmSpecialNode* pNode ) override;
+    void Visit( SmGlyphSpecialNode* pNode ) override;
+    void Visit( SmMathSymbolNode* pNode ) override;
+    void Visit( SmBlankNode* pNode ) override;
+    void Visit( SmErrorNode* pNode ) override;
+    void Visit( SmLineNode* pNode ) override;
+    void Visit( SmExpressionNode* pNode ) override;
+    void Visit( SmPolyLineNode* pNode ) override;
+    void Visit( SmRootNode* pNode ) override;
+    void Visit( SmRootSymbolNode* pNode ) override;
+    void Visit( SmRectangleNode* pNode ) override;
+    void Visit( SmVerticalBraceNode* pNode ) override;
+private:
+    /** Draw the children of a pNode
+     * This the default method, use by most pNodes
+     */
+    void DrawChildren( SmStructureNode* pNode );
+
+    /** Draw an SmTextNode or a subclass of this */
+    void DrawTextNode( SmTextNode* pNode );
+    /** Draw an SmSpecialNode or a subclass of this  */
+    void DrawSpecialNode( SmSpecialNode* pNode );
+    /** OutputDevice to draw on */
+    OutputDevice& mrDev;
+    /** Position to draw on the mrDev
+     * @remarks This variable is used to pass parameters in DrawChildren( ), this means
+                that after a call to DrawChildren( ) the contents of this method is undefined
+                so if needed cache it locally on the stack.
+     */
+    Point maPosition;
+};
+
+// SmSetSelectionVisitor
+
+/** Set Selection Visitor
+ * Sets the IsSelected( ) property on all SmNodes of the tree
+ */
+class SmSetSelectionVisitor final : public SmDefaultingVisitor
+{
+public:
+    SmSetSelectionVisitor( SmCaretPos startPos, SmCaretPos endPos, SmNode* pNode);
+    virtual ~SmSetSelectionVisitor() {}
+    void Visit( SmBinHorNode* pNode ) override;
+    void Visit( SmUnHorNode* pNode ) override;
+    void Visit( SmFontNode* pNode ) override;
+    void Visit( SmTextNode* pNode ) override;
+    void Visit( SmExpressionNode* pNode ) override;
+    void Visit( SmLineNode* pNode ) override;
+    void Visit( SmAlignNode* pNode ) override;
+    using SmDefaultingVisitor::Visit;
+    /** Set IsSelected on all pNodes of pSubTree */
+    static void SetSelectedOnAll( SmNode* pSubTree, bool IsSelected = true );
+private:
+    /** Visit a selectable pNode
+     * Can be used to handle pNodes that can be selected, that doesn't have more SmCaretPos'
+     * than 0 and 1 inside them. SmTextNode should be handle separately!
+     * Also note that pNodes such as SmBinVerNode cannot be selected, don't this method for
+     * it.
+     */
+    void DefaultVisit( SmNode* pNode ) override;
+    void VisitCompositionNode( SmStructureNode* pNode );
+    /** Caret position where the selection starts */
+    SmCaretPos maStartPos;
+    /** Caret position where the selection ends */
+    SmCaretPos maEndPos;
+    /** The current state of this visitor
+     * This property changes when the visitor meets either maStartPos
+     * or maEndPos. This means that anything visited in between will be
+     * selected.
+     */
+    bool mbSelecting;
+};
+
+
+// SmCaretPosGraphBuildingVisitor
+
+
+/** A visitor for building a SmCaretPosGraph
+ *
+ * Visit invariant:
+ * Each pNode, except SmExpressionNode, SmBinHorNode and a few others, constitutes an entry
+ * in a line. Consider the line entry "H", this entry creates one carat position, here
+ * denoted by | in "H|".
+ *
+ * Parameter variables:
+ *  The following variables are used to transfer parameters into calls and results out
+ *  of calls.
+ *      pRightMost : SmCaretPosGraphEntry*
+ *
+ * Prior to a Visit call:
+ *  pRightMost: A pointer to right most position in front of the current line entry.
+ *
+ * After a Visit call:
+ *  pRightMost: A pointer to the right most position in the called line entry, if no there's
+ *              no caret positions in called line entry don't change this variable.
+ */
+class SmCaretPosGraphBuildingVisitor final : public SmVisitor
+{
+public:
+    /** Builds a caret position graph for pRootNode */
+    explicit SmCaretPosGraphBuildingVisitor( SmNode* pRootNode );
+    virtual ~SmCaretPosGraphBuildingVisitor();
+    void Visit( SmTableNode* pNode ) override;
+    void Visit( SmBraceNode* pNode ) override;
+    void Visit( SmBracebodyNode* pNode ) override;
+    void Visit( SmOperNode* pNode ) override;
+    void Visit( SmAlignNode* pNode ) override;
+    void Visit( SmAttributNode* pNode ) override;
+    void Visit( SmFontNode* pNode ) override;
+    void Visit( SmUnHorNode* pNode ) override;
+    void Visit( SmBinHorNode* pNode ) override;
+    void Visit( SmBinVerNode* pNode ) override;
+    void Visit( SmBinDiagonalNode* pNode ) override;
+    void Visit( SmSubSupNode* pNode ) override;
+    void Visit( SmMatrixNode* pNode ) override;
+    void Visit( SmPlaceNode* pNode ) override;
+    void Visit( SmTextNode* pNode ) override;
+    void Visit( SmSpecialNode* pNode ) override;
+    void Visit( SmGlyphSpecialNode* pNode ) override;
+    void Visit( SmMathSymbolNode* pNode ) override;
+    void Visit( SmBlankNode* pNode ) override;
+    void Visit( SmErrorNode* pNode ) override;
+    void Visit( SmLineNode* pNode ) override;
+    void Visit( SmExpressionNode* pNode ) override;
+    void Visit( SmPolyLineNode* pNode ) override;
+    void Visit( SmRootNode* pNode ) override;
+    void Visit( SmRootSymbolNode* pNode ) override;
+    void Visit( SmRectangleNode* pNode ) override;
+    void Visit( SmVerticalBraceNode* pNode ) override;
+    SmCaretPosGraph* takeGraph()
+    {
+        return mpGraph.release();
+    }
+private:
+    SmCaretPosGraphEntry* mpRightMost;
+    std::unique_ptr<SmCaretPosGraph> mpGraph;
+};
+
+// SmCloningVisitor
+
+/** Visitor for cloning a pNode
+ *
+ * This visitor creates deep clones.
+ */
+class SmCloningVisitor final : public SmVisitor
+{
+public:
+    SmCloningVisitor()
+        : mpResult(nullptr)
+    {}
+    virtual ~SmCloningVisitor() {}
+    void Visit( SmTableNode* pNode ) override;
+    void Visit( SmBraceNode* pNode ) override;
+    void Visit( SmBracebodyNode* pNode ) override;
+    void Visit( SmOperNode* pNode ) override;
+    void Visit( SmAlignNode* pNode ) override;
+    void Visit( SmAttributNode* pNode ) override;
+    void Visit( SmFontNode* pNode ) override;
+    void Visit( SmUnHorNode* pNode ) override;
+    void Visit( SmBinHorNode* pNode ) override;
+    void Visit( SmBinVerNode* pNode ) override;
+    void Visit( SmBinDiagonalNode* pNode ) override;
+    void Visit( SmSubSupNode* pNode ) override;
+    void Visit( SmMatrixNode* pNode ) override;
+    void Visit( SmPlaceNode* pNode ) override;
+    void Visit( SmTextNode* pNode ) override;
+    void Visit( SmSpecialNode* pNode ) override;
+    void Visit( SmGlyphSpecialNode* pNode ) override;
+    void Visit( SmMathSymbolNode* pNode ) override;
+    void Visit( SmBlankNode* pNode ) override;
+    void Visit( SmErrorNode* pNode ) override;
+    void Visit( SmLineNode* pNode ) override;
+    void Visit( SmExpressionNode* pNode ) override;
+    void Visit( SmPolyLineNode* pNode ) override;
+    void Visit( SmRootNode* pNode ) override;
+    void Visit( SmRootSymbolNode* pNode ) override;
+    void Visit( SmRectangleNode* pNode ) override;
+    void Visit( SmVerticalBraceNode* pNode ) override;
+    /** Clone a pNode */
+    SmNode* Clone( SmNode* pNode );
+private:
+    SmNode* mpResult;
+    /** Clone children of pSource and give them to pTarget */
+    void CloneKids( SmStructureNode* pSource, SmStructureNode* pTarget );
+    /** Clone attributes on a pNode */
+    static void CloneNodeAttr( SmNode const * pSource, SmNode* pTarget );
+};
+
+
+// SmSelectionDrawingVisitor
+
+class SmSelectionDrawingVisitor final : public SmDefaultingVisitor
+{
+public:
+    /** Draws a selection on rDevice for the selection on pTree */
+    SmSelectionDrawingVisitor( OutputDevice& rDevice, SmNode* pTree, const Point& rOffset );
+    virtual ~SmSelectionDrawingVisitor() {}
+    void Visit( SmTextNode* pNode ) override;
+    using SmDefaultingVisitor::Visit;
+private:
+    /** Reference to drawing device */
+    OutputDevice& mrDev;
+    /** True if  aSelectionArea have been initialized */
+    bool mbHasSelectionArea;
+    /** The current area that is selected */
+    tools::Rectangle maSelectionArea;
+    /** Extend the area that must be selected  */
+    void ExtendSelectionArea(const tools::Rectangle& rArea);
+    /** Default visiting method */
+    void DefaultVisit( SmNode* pNode ) override;
+    /** Visit the children of a given pNode */
+    void VisitChildren( SmNode* pNode );
+};
+
+// SmNodeToTextVisitor
+
+/** Extract command text from pNodes */
+class SmNodeToTextVisitor final : public SmVisitor
+{
+public:
+    SmNodeToTextVisitor( SmNode* pNode, OUString &rText );
+    virtual ~SmNodeToTextVisitor() {}
+
+    void Visit( SmTableNode* pNode ) override;
+    void Visit( SmBraceNode* pNode ) override;
+    void Visit( SmBracebodyNode* pNode ) override;
+    void Visit( SmOperNode* pNode ) override;
+    void Visit( SmAlignNode* pNode ) override;
+    void Visit( SmAttributNode* pNode ) override;
+    void Visit( SmFontNode* pNode ) override;
+    void Visit( SmUnHorNode* pNode ) override;
+    void Visit( SmBinHorNode* pNode ) override;
+    void Visit( SmBinVerNode* pNode ) override;
+    void Visit( SmBinDiagonalNode* pNode ) override;
+    void Visit( SmSubSupNode* pNode ) override;
+    void Visit( SmMatrixNode* pNode ) override;
+    void Visit( SmPlaceNode* pNode ) override;
+    void Visit( SmTextNode* pNode ) override;
+    void Visit( SmSpecialNode* pNode ) override;
+    void Visit( SmGlyphSpecialNode* pNode ) override;
+    void Visit( SmMathSymbolNode* pNode ) override;
+    void Visit( SmBlankNode* pNode ) override;
+    void Visit( SmErrorNode* pNode ) override;
+    void Visit( SmLineNode* pNode ) override;
+    void Visit( SmExpressionNode* pNode ) override;
+    void Visit( SmPolyLineNode* pNode ) override;
+    void Visit( SmRootNode* pNode ) override;
+    void Visit( SmRootSymbolNode* pNode ) override;
+    void Visit( SmRectangleNode* pNode ) override;
+    void Visit( SmVerticalBraceNode* pNode ) override;
+private:
+    /** Extract text from a pNode that constitutes a line */
+    void LineToText( SmNode* pNode ) {
+        Separate( );
+        if( pNode )
+            pNode->Accept( this );
+        Separate( );
+    }
+    void Append( const OUString &rText ) {
+        maCmdText.append( rText );
+    }
+    /** Append a blank for separation, if needed */
+    void Separate( ){
+        if( maCmdText.isEmpty() || maCmdText[ maCmdText.getLength() - 1 ] != ' ' )
+            maCmdText.append(' ');
+    }
+    /** Output text generated from the pNodes */
+    OUStringBuffer maCmdText;
+};
+
+#endif // INCLUDED_STARMATH_INC_VISITORS_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */