visitors.cxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
 
#include <rtl/math.hxx>
#include <sal/log.hxx>
#include <tools/gen.hxx>
#include <vcl/lineinfo.hxx>
#include <visitors.hxx>
#include "tmpdevice.hxx"
#include <cursor.hxx>
 
#include <starmathdatabase.hxx>
 
// SmDefaultingVisitor
 
void SmDefaultingVisitor::Visit( SmTableNode* pNode )
{
    DefaultVisit( pNode );
}
 
void SmDefaultingVisitor::Visit( SmBraceNode* pNode )
{
    DefaultVisit( pNode );
}
 
void SmDefaultingVisitor::Visit( SmBracebodyNode* pNode )
{
    DefaultVisit( pNode );
}
 
void SmDefaultingVisitor::Visit( SmOperNode* pNode )
{
    DefaultVisit( pNode );
}
 
void SmDefaultingVisitor::Visit( SmAlignNode* pNode )
{
    DefaultVisit( pNode );
}
 
void SmDefaultingVisitor::Visit( SmAttributeNode* pNode )
{
    DefaultVisit( pNode );
}
 
void SmDefaultingVisitor::Visit( SmFontNode* pNode )
{
    DefaultVisit( pNode );
}
 
void SmDefaultingVisitor::Visit( SmUnHorNode* pNode )
{
    DefaultVisit( pNode );
}
 
void SmDefaultingVisitor::Visit( SmBinHorNode* pNode )
{
    DefaultVisit( pNode );
}
 
void SmDefaultingVisitor::Visit( SmBinVerNode* pNode )
{
    DefaultVisit( pNode );
}
 
void SmDefaultingVisitor::Visit( SmBinDiagonalNode* pNode )
{
    DefaultVisit( pNode );
}
 
void SmDefaultingVisitor::Visit( SmSubSupNode* pNode )
{
    DefaultVisit( pNode );
}
 
void SmDefaultingVisitor::Visit( SmMatrixNode* pNode )
{
    DefaultVisit( pNode );
}
 
void SmDefaultingVisitor::Visit( SmPlaceNode* pNode )
{
    DefaultVisit( pNode );
}
 
void SmDefaultingVisitor::Visit( SmTextNode* pNode )
{
    DefaultVisit( pNode );
}
 
void SmDefaultingVisitor::Visit( SmSpecialNode* pNode )
{
    DefaultVisit( pNode );
}
 
void SmDefaultingVisitor::Visit( SmGlyphSpecialNode* pNode )
{
    DefaultVisit( pNode );
}
 
void SmDefaultingVisitor::Visit( SmMathSymbolNode* pNode )
{
    DefaultVisit( pNode );
}
 
void SmDefaultingVisitor::Visit( SmBlankNode* pNode )
{
    DefaultVisit( pNode );
}
 
void SmDefaultingVisitor::Visit( SmErrorNode* pNode )
{
    DefaultVisit( pNode );
}
 
void SmDefaultingVisitor::Visit( SmLineNode* pNode )
{
    DefaultVisit( pNode );
}
 
void SmDefaultingVisitor::Visit( SmExpressionNode* pNode )
{
    DefaultVisit( pNode );
}
 
void SmDefaultingVisitor::Visit( SmPolyLineNode* pNode )
{
    DefaultVisit( pNode );
}
 
void SmDefaultingVisitor::Visit( SmRootNode* pNode )
{
    DefaultVisit( pNode );
}
 
void SmDefaultingVisitor::Visit( SmRootSymbolNode* pNode )
{
    DefaultVisit( pNode );
}
 
void SmDefaultingVisitor::Visit( SmRectangleNode* pNode )
{
    DefaultVisit( pNode );
}
 
void SmDefaultingVisitor::Visit( SmVerticalBraceNode* pNode )
{
    DefaultVisit( pNode );
}
 
// SmCaretLinesVisitor
 
SmCaretLinesVisitor::SmCaretLinesVisitor(OutputDevice& rDevice, SmCaretPos position, Point offset)
    : mrDev(rDevice)
    , maPos(position)
    , maOffset(offset)
{
}
 
void SmCaretLinesVisitor::DoIt()
{
    SAL_WARN_IF(!maPos.IsValid(), "starmath", "Cannot draw invalid position!");
    if (!maPos.IsValid())
        return;
 
    //Save device state
    mrDev.Push( vcl::PushFlags::FONT | vcl::PushFlags::MAPMODE | vcl::PushFlags::LINECOLOR | vcl::PushFlags::FILLCOLOR | vcl::PushFlags::TEXTCOLOR );
 
    maPos.pSelectedNode->Accept( this );
    //Restore device state
    mrDev.Pop( );
}
 
void SmCaretLinesVisitor::Visit( SmTextNode* pNode )
{
    tools::Long i = maPos.nIndex;
 
    mrDev.SetFont( pNode->GetFont( ) );
 
    //Find the line
    SmNode* pLine = SmCursor::FindTopMostNodeInLine( pNode );
 
    //Find coordinates
    tools::Long left = pNode->GetLeft( ) + mrDev.GetTextWidth( pNode->GetText( ), 0, i ) + maOffset.X( );
    tools::Long top = pLine->GetTop( ) + maOffset.Y( );
    tools::Long height = pLine->GetHeight( );
    tools::Long left_line = pLine->GetLeft( ) + maOffset.X( );
    tools::Long right_line = pLine->GetRight( ) + maOffset.X( );
 
    // Vertical line
    ProcessCaretLine({ left, top }, { left, top + height });
 
    // Underline
    ProcessUnderline({ left_line, top + height }, { right_line, top + height });
}
 
void SmCaretLinesVisitor::DefaultVisit( SmNode* pNode )
{
    //Find the line
    SmNode* pLine = SmCursor::FindTopMostNodeInLine( pNode );
 
    //Find coordinates
    tools::Long left = pNode->GetLeft( ) + maOffset.X( ) + ( maPos.nIndex == 1 ? pNode->GetWidth( ) : 0 );
    tools::Long top = pLine->GetTop( ) + maOffset.Y( );
    tools::Long height = pLine->GetHeight( );
    tools::Long left_line = pLine->GetLeft( ) + maOffset.X( );
    tools::Long right_line = pLine->GetRight( ) + maOffset.X( );
 
    // Vertical line
    ProcessCaretLine({ left, top }, { left, top + height });
 
    // Underline
    ProcessUnderline({ left_line, top + height }, { right_line, top + height });
}
 
// SmCaretRectanglesVisitor
 
SmCaretRectanglesVisitor::SmCaretRectanglesVisitor(OutputDevice& rDevice, SmCaretPos position)
    : SmCaretLinesVisitor(rDevice, position, {})
{
    DoIt();
}
 
void SmCaretRectanglesVisitor::ProcessCaretLine(Point from, Point to) { maCaret = { from, to }; }
void SmCaretRectanglesVisitor::ProcessUnderline(Point /*from*/, Point /*to*/) {} // No underline
 
// SmCaretDrawingVisitor
 
SmCaretDrawingVisitor::SmCaretDrawingVisitor( OutputDevice& rDevice,
                                             SmCaretPos position,
                                             Point offset,
                                             bool caretVisible )
    : SmCaretLinesVisitor(rDevice, position, offset)
    , mbCaretVisible( caretVisible )
{
    DoIt();
}
 
void SmCaretDrawingVisitor::ProcessCaretLine(Point from, Point to)
{
    if ( mbCaretVisible ) {
        //Set color
        getDev().SetLineColor(COL_BLACK);
        //Draw vertical line
        getDev().DrawLine(from, to);
    }
}
 
void SmCaretDrawingVisitor::ProcessUnderline(Point from, Point to)
{
    //Set color
    getDev().SetLineColor(COL_BLACK);
    //Underline the line
    getDev().DrawLine(from, to);
}
 
// SmCaretPos2LineVisitor
 
void SmCaretPos2LineVisitor::Visit( SmTextNode* pNode )
{
    //Save device state
    mpDev->Push( vcl::PushFlags::FONT | vcl::PushFlags::TEXTCOLOR );
 
    tools::Long i = maPos.nIndex;
 
    mpDev->SetFont( pNode->GetFont( ) );
 
    //Find coordinates
    tools::Long left = pNode->GetLeft( ) + mpDev->GetTextWidth( pNode->GetText( ), 0, i );
    tools::Long top = pNode->GetTop( );
    tools::Long height = pNode->GetHeight( );
 
    maLine = SmCaretLine( left, top, height );
 
    //Restore device state
    mpDev->Pop( );
}
 
void SmCaretPos2LineVisitor::DefaultVisit( SmNode* pNode )
{
    //Vertical line ( code from SmCaretDrawingVisitor )
    Point p1 = pNode->GetTopLeft( );
    if( maPos.nIndex == 1 )
        p1.Move( pNode->GetWidth( ), 0 );
 
    maLine = SmCaretLine( p1.X( ), p1.Y( ), pNode->GetHeight( ) );
}
 
 
// SmDrawingVisitor
 
void SmDrawingVisitor::Visit( SmTableNode* pNode )
{
    DrawChildren( pNode );
}
 
void SmDrawingVisitor::Visit( SmBraceNode* pNode )
{
    DrawChildren( pNode );
}
 
void SmDrawingVisitor::Visit( SmBracebodyNode* pNode )
{
    DrawChildren( pNode );
}
 
void SmDrawingVisitor::Visit( SmOperNode* pNode )
{
    DrawChildren( pNode );
}
 
void SmDrawingVisitor::Visit( SmAlignNode* pNode )
{
    DrawChildren( pNode );
}
 
void SmDrawingVisitor::Visit( SmAttributeNode* pNode )
{
    DrawChildren( pNode );
}
 
void SmDrawingVisitor::Visit( SmFontNode* pNode )
{
    DrawChildren( pNode );
}
 
void SmDrawingVisitor::Visit( SmUnHorNode* pNode )
{
    DrawChildren( pNode );
}
 
void SmDrawingVisitor::Visit( SmBinHorNode* pNode )
{
    DrawChildren( pNode );
}
 
void SmDrawingVisitor::Visit( SmBinVerNode* pNode )
{
    DrawChildren( pNode );
}
 
void SmDrawingVisitor::Visit( SmBinDiagonalNode* pNode )
{
    DrawChildren( pNode );
}
 
void SmDrawingVisitor::Visit( SmSubSupNode* pNode )
{
    DrawChildren( pNode );
}
 
void SmDrawingVisitor::Visit( SmMatrixNode* pNode )
{
    DrawChildren( pNode );
}
 
void SmDrawingVisitor::Visit( SmPlaceNode* pNode )
{
    DrawSpecialNode( pNode );
}
 
void SmDrawingVisitor::Visit( SmTextNode* pNode )
{
    DrawTextNode( pNode );
}
 
void SmDrawingVisitor::Visit( SmSpecialNode* pNode )
{
    DrawSpecialNode( pNode );
}
 
void SmDrawingVisitor::Visit( SmGlyphSpecialNode* pNode )
{
    DrawSpecialNode( pNode );
}
 
void SmDrawingVisitor::Visit( SmMathSymbolNode* pNode )
{
    DrawSpecialNode( pNode );
}
 
void SmDrawingVisitor::Visit( SmBlankNode* )
{
}
 
void SmDrawingVisitor::Visit( SmErrorNode* pNode )
{
    DrawSpecialNode( pNode );
}
 
void SmDrawingVisitor::Visit( SmLineNode* pNode )
{
    DrawChildren( pNode );
}
 
void SmDrawingVisitor::Visit( SmExpressionNode* pNode )
{
    DrawChildren( pNode );
}
 
void SmDrawingVisitor::Visit( SmRootNode* pNode )
{
    DrawChildren( pNode );
}
 
void SmDrawingVisitor::Visit( SmVerticalBraceNode* pNode )
{
    DrawChildren( pNode );
}
 
void SmDrawingVisitor::Visit( SmRootSymbolNode* pNode )
{
    if ( pNode->IsPhantom( ) )
        return;
 
    // draw root-sign itself
    DrawSpecialNode( pNode );
 
    SmTmpDevice aTmpDev( mrDev, true );
    aTmpDev.SetFillColor( pNode->GetFont( ).GetColor( ) );
    mrDev.SetLineColor( );
    aTmpDev.SetFont( pNode->GetFont( ) );
 
    // since the width is always unscaled it corresponds to the _original_
    // _unscaled_ font height to be used, we use that to calculate the
    // bar height. Thus it is independent of the arguments height.
    // ( see display of sqrt QQQ versus sqrt stack{Q#Q#Q#Q} )
    tools::Long nBarHeight = pNode->GetWidth( ) * 7 / 100;
    tools::Long nBarWidth = pNode->GetBodyWidth( ) + pNode->GetBorderWidth( );
    Point aBarOffset( pNode->GetWidth( ), +pNode->GetBorderWidth( ) );
    Point aBarPos( maPosition + aBarOffset );
 
    tools::Rectangle  aBar( aBarPos, Size( nBarWidth, nBarHeight ) );
    //  This is done by shifting its output-position to a point that
    //  corresponds exactly to a pixel on the output device.
    Point  aDrawPos( mrDev.PixelToLogic( mrDev.LogicToPixel( aBar.TopLeft( ) ) ) );
    aBar.SetPos( aDrawPos );
 
    mrDev.DrawRect( aBar );
}
 
void SmDrawingVisitor::Visit( SmPolyLineNode* pNode )
{
    if ( pNode->IsPhantom( ) )
        return;
 
    tools::Long nBorderwidth = pNode->GetFont( ).GetBorderWidth( );
 
    LineInfo  aInfo;
    aInfo.SetWidth( pNode->GetWidth( ) - 2 * nBorderwidth );
 
    Point aOffset ( Point( ) - pNode->GetPolygon( ).GetBoundRect( ).TopLeft( )
                   + Point( nBorderwidth, nBorderwidth ) ),
          aPos ( maPosition + aOffset );
    pNode->GetPolygon( ).Move( aPos.X( ), aPos.Y( ) );    //Works because Polygon wraps a pointer
 
    SmTmpDevice aTmpDev ( mrDev, false );
    aTmpDev.SetLineColor( pNode->GetFont( ).GetColor( ) );
 
    mrDev.DrawPolyLine( pNode->GetPolygon( ), aInfo );
}
 
void SmDrawingVisitor::Visit( SmRectangleNode* pNode )
{
    if ( pNode->IsPhantom( ) )
        return;
 
    SmTmpDevice aTmpDev ( mrDev, false );
    aTmpDev.SetFillColor( pNode->GetFont( ).GetColor( ) );
    mrDev.SetLineColor( );
    aTmpDev.SetFont( pNode->GetFont( ) );
 
    sal_uLong  nTmpBorderWidth = pNode->GetFont( ).GetBorderWidth( );
 
    // get rectangle and remove borderspace
    tools::Rectangle  aTmp ( pNode->AsRectangle( ) + maPosition - pNode->GetTopLeft( ) );
    aTmp.AdjustLeft(nTmpBorderWidth );
    aTmp.AdjustRight( -sal_Int32(nTmpBorderWidth) );
    aTmp.AdjustTop(nTmpBorderWidth );
    aTmp.AdjustBottom( -sal_Int32(nTmpBorderWidth) );
 
    SAL_WARN_IF( aTmp.IsEmpty(), "starmath", "Empty rectangle" );
 
    //  This is done by shifting its output-position to a point that
    //  corresponds exactly to a pixel on the output device.
    Point  aPos ( mrDev.PixelToLogic( mrDev.LogicToPixel( aTmp.TopLeft( ) ) ) );
    aTmp.SetPos( aPos );
 
    mrDev.DrawRect( aTmp );
}
 
void SmDrawingVisitor::DrawTextNode( SmTextNode* pNode )
{
    if ( pNode->IsPhantom() || pNode->GetText().isEmpty() || pNode->GetText()[0] == '\0' )
        return;
 
    SmTmpDevice aTmpDev ( mrDev, false );
    aTmpDev.SetFont( pNode->GetFont( ) );
 
    Point  aPos ( maPosition );
    aPos.AdjustY(pNode->GetBaselineOffset( ) );
    // round to pixel coordinate
    aPos = mrDev.PixelToLogic( mrDev.LogicToPixel( aPos ) );
 
    mrDev.DrawStretchText( aPos, pNode->GetWidth( ), pNode->GetText( ) );
}
 
void SmDrawingVisitor::DrawSpecialNode( SmSpecialNode* pNode )
{
    pNode->GetFont( ).SetAlignment( ALIGN_BASELINE );
 
    DrawTextNode( pNode );
}
 
void SmDrawingVisitor::DrawChildren( SmStructureNode* pNode )
{
    if ( pNode->IsPhantom( ) )
        return;
 
    Point rPosition = maPosition;
 
    for( auto pChild : *pNode )
    {
        if(!pChild)
            continue;
        Point  aOffset ( pChild->GetTopLeft( ) - pNode->GetTopLeft( ) );
        maPosition = rPosition + aOffset;
        pChild->Accept( this );
    }
}
 
// SmSetSelectionVisitor
 
SmSetSelectionVisitor::SmSetSelectionVisitor( SmCaretPos startPos, SmCaretPos endPos, SmNode* pTree)
    : maStartPos(startPos)
    , maEndPos(endPos)
    , mbSelecting(false)
{
    //Assume that pTree is a SmTableNode
    SAL_WARN_IF(pTree->GetType() != SmNodeType::Table, "starmath", "pTree should be a SmTableNode!");
    //Visit root node, this is special as this node cannot be selected, but its children can!
    if(pTree->GetType() == SmNodeType::Table){
        //Change state if maStartPos is in front of this node
        if( maStartPos.pSelectedNode == pTree && maStartPos.nIndex == 0 )
            mbSelecting = !mbSelecting;
        //Change state if maEndPos is in front of this node
        if( maEndPos.pSelectedNode == pTree && maEndPos.nIndex == 0 )
            mbSelecting = !mbSelecting;
        SAL_WARN_IF(mbSelecting, "starmath", "Caret positions needed to set mbSelecting about, shouldn't be possible!");
 
        //Visit lines
        for( auto pChild : *static_cast<SmStructureNode*>(pTree) )
        {
            if(!pChild)
                continue;
            pChild->Accept( this );
            //If we started a selection in this line and it haven't ended, we do that now!
            if(mbSelecting) {
                mbSelecting = false;
                SetSelectedOnAll(pChild);
                //Set maStartPos and maEndPos to invalid positions, this ensures that an unused
                //start or end (because we forced end above), doesn't start a new selection.
                maStartPos = maEndPos = SmCaretPos();
            }
        }
        //Check if pTree isn't selected
        SAL_WARN_IF(pTree->IsSelected(), "starmath", "pTree should never be selected!");
        //Discard the selection if there's a bug (it's better than crashing)
        if(pTree->IsSelected())
            SetSelectedOnAll(pTree, false);
    }else //This shouldn't happen, but I don't see any reason to die if it does
        pTree->Accept(this);
}
 
void SmSetSelectionVisitor::SetSelectedOnAll( SmNode* pSubTree, bool IsSelected ) {
    pSubTree->SetSelected( IsSelected );
 
    if(pSubTree->GetNumSubNodes() == 0)
        return;
    //Quick BFS to set all selections
    for( auto pChild : *static_cast<SmStructureNode*>(pSubTree) )
    {
        if(!pChild)
            continue;
        SetSelectedOnAll( pChild, IsSelected );
    }
}
 
void SmSetSelectionVisitor::DefaultVisit( SmNode* pNode ) {
    //Change state if maStartPos is in front of this node
    if( maStartPos.pSelectedNode == pNode && maStartPos.nIndex == 0 )
        mbSelecting = !mbSelecting;
    //Change state if maEndPos is in front of this node
    if( maEndPos.pSelectedNode == pNode && maEndPos.nIndex == 0 )
        mbSelecting = !mbSelecting;
 
    //Cache current state
    bool WasSelecting = mbSelecting;
    bool ChangedState = false;
 
    //Set selected
    pNode->SetSelected( mbSelecting );
 
    //Visit children
    if(pNode->GetNumSubNodes() > 0)
    {
        for( auto pChild : *static_cast<SmStructureNode*>(pNode) )
        {
            if(!pChild)
                continue;
            pChild->Accept( this );
            ChangedState = ( WasSelecting != mbSelecting ) || ChangedState;
        }
    }
 
    //If state changed
    if( ChangedState )
    {
        //Select this node and all of its children
        //(Make exception for SmBracebodyNode)
        if( pNode->GetType() != SmNodeType::Bracebody ||
            !pNode->GetParent() ||
            pNode->GetParent()->GetType() != SmNodeType::Brace )
            SetSelectedOnAll( pNode );
        else
            SetSelectedOnAll( pNode->GetParent() );
        /* If the equation is:      sqrt{2 + 4} + 5
         * And the selection is:    sqrt{2 + [4} +] 5
         *      Where [ denotes maStartPos and ] denotes maEndPos
         * Then the sqrt node should be selected, so that the
         * effective selection is:  [sqrt{2 + 4} +] 5
         * The same is the case if we swap maStartPos and maEndPos.
         */
    }
 
    //Change state if maStartPos is after this node
    if( maStartPos.pSelectedNode == pNode && maStartPos.nIndex == 1 )
    {
        mbSelecting = !mbSelecting;
    }
    //Change state if maEndPos is after of this node
    if( maEndPos.pSelectedNode == pNode && maEndPos.nIndex == 1 )
    {
        mbSelecting = !mbSelecting;
    }
}
 
void SmSetSelectionVisitor::VisitCompositionNode( SmStructureNode* pNode )
{
    //Change state if maStartPos is in front of this node
    if( maStartPos.pSelectedNode == pNode && maStartPos.nIndex == 0 )
        mbSelecting = !mbSelecting;
    //Change state if maEndPos is in front of this node
    if( maEndPos.pSelectedNode == pNode && maEndPos.nIndex == 0 )
        mbSelecting = !mbSelecting;
 
    //Cache current state
    bool WasSelecting = mbSelecting;
 
    //Visit children
    for( auto pChild : *pNode )
    {
        if(!pChild)
            continue;
        pChild->Accept( this );
    }
 
    //Set selected, if everything was selected
    pNode->SetSelected( WasSelecting && mbSelecting );
 
    //Change state if maStartPos is after this node
    if( maStartPos.pSelectedNode == pNode && maStartPos.nIndex == 1 )
        mbSelecting = !mbSelecting;
    //Change state if maEndPos is after of this node
    if( maEndPos.pSelectedNode == pNode && maEndPos.nIndex == 1 )
        mbSelecting = !mbSelecting;
}
 
void SmSetSelectionVisitor::Visit( SmTextNode* pNode ) {
    tools::Long    i1 = -1,
            i2 = -1;
    if( maStartPos.pSelectedNode == pNode )
        i1 = maStartPos.nIndex;
    if( maEndPos.pSelectedNode == pNode )
        i2 = maEndPos.nIndex;
 
    tools::Long start, end;
    pNode->SetSelected(true);
    if( i1 != -1 && i2 != -1 ) {
        start = std::min(i1, i2);
        end   = std::max(i1, i2);
    } else if( mbSelecting && i1 != -1 ) {
        start = 0;
        end = i1;
        mbSelecting = false;
    } else if( mbSelecting && i2 != -1 ) {
        start = 0;
        end = i2;
        mbSelecting = false;
    } else if( !mbSelecting && i1 != -1 ) {
        start = i1;
        end = pNode->GetText().getLength();
        mbSelecting = true;
    } else if( !mbSelecting && i2 != -1 ) {
        start = i2;
        end = pNode->GetText().getLength();
        mbSelecting = true;
    } else if( mbSelecting ) {
        start = 0;
        end = pNode->GetText().getLength();
    } else {
        pNode->SetSelected( false );
        start = 0;
        end = 0;
    }
    pNode->SetSelected( start != end );
    pNode->SetSelectionStart( start );
    pNode->SetSelectionEnd( end );
}
 
void SmSetSelectionVisitor::Visit( SmExpressionNode* pNode ) {
    VisitCompositionNode( pNode );
}
 
void SmSetSelectionVisitor::Visit( SmLineNode* pNode ) {
    VisitCompositionNode( pNode );
}
 
void SmSetSelectionVisitor::Visit( SmAlignNode* pNode ) {
    VisitCompositionNode( pNode );
}
 
void SmSetSelectionVisitor::Visit( SmBinHorNode* pNode ) {
    VisitCompositionNode( pNode );
}
 
void SmSetSelectionVisitor::Visit( SmUnHorNode* pNode ) {
    VisitCompositionNode( pNode );
}
 
void SmSetSelectionVisitor::Visit( SmFontNode* pNode ) {
    VisitCompositionNode( pNode );
}
 
// SmCaretPosGraphBuildingVisitor
 
SmCaretPosGraphBuildingVisitor::SmCaretPosGraphBuildingVisitor( SmNode* pRootNode )
    : mpRightMost(nullptr)
    , mpGraph(new SmCaretPosGraph)
{
    //pRootNode should always be a table
    SAL_WARN_IF( pRootNode->GetType( ) != SmNodeType::Table, "starmath", "pRootNode must be a table node");
    //Handle the special case where SmNodeType::Table is used a rootnode
    if( pRootNode->GetType( ) == SmNodeType::Table ){
        //Children are SmLineNodes
        //Or so I thought... Apparently, the children can be instances of SmExpression
        //especially if there's an error in the formula... So here we go, a simple work around.
        for( auto pChild : *static_cast<SmStructureNode*>(pRootNode) )
        {
            if(!pChild)
                continue;
            mpRightMost = mpGraph->Add( SmCaretPos( pChild, 0 ) );
            pChild->Accept( this );
        }
    }else
        pRootNode->Accept(this);
}
 
SmCaretPosGraphBuildingVisitor::~SmCaretPosGraphBuildingVisitor()
{
}
 
void SmCaretPosGraphBuildingVisitor::Visit( SmLineNode* pNode ){
    for( auto pChild : *pNode )
    {
        if(!pChild)
            continue;
        pChild->Accept( this );
    }
}
 
void SmCaretPosGraphBuildingVisitor::Visit( SmTableNode* pNode ){
    SmCaretPosGraphEntry *left  = mpRightMost,
                         *right = mpGraph->Add( SmCaretPos( pNode, 1) );
    bool bIsFirst = true;
    for( auto pChild : *pNode )
    {
        if(!pChild)
            continue;
        mpRightMost = mpGraph->Add( SmCaretPos( pChild, 0 ), left);
        if(bIsFirst)
            left->SetRight(mpRightMost);
        pChild->Accept( this );
        mpRightMost->SetRight(right);
        if(bIsFirst)
            right->SetLeft(mpRightMost);
        bIsFirst = false;
    }
    mpRightMost = right;
}
 
void SmCaretPosGraphBuildingVisitor::Visit( SmSubSupNode* pNode )
{
    SmCaretPosGraphEntry *left,
                         *right,
                         *bodyLeft,
                         *bodyRight;
 
    assert(mpRightMost);
    left = mpRightMost;
 
    //Create bodyLeft
    SAL_WARN_IF( !pNode->GetBody(), "starmath", "SmSubSupNode Doesn't have a body!" );
    bodyLeft = mpGraph->Add( SmCaretPos( pNode->GetBody( ), 0 ), left );
    left->SetRight( bodyLeft ); //TODO: Don't make this if LSUP or LSUB are NULL ( not sure??? )
 
    //Create right
    right = mpGraph->Add( SmCaretPos( pNode, 1 ) );
 
    //Visit the body, to get bodyRight
    mpRightMost = bodyLeft;
    pNode->GetBody( )->Accept( this );
    bodyRight = mpRightMost;
    bodyRight->SetRight( right );
    right->SetLeft( bodyRight );
 
    SmNode* pChild;
    for (SmSubSup const nodeType : { LSUP, LSUB, CSUP, CSUB, RSUP, RSUB })
    {
        pChild = pNode->GetSubSup(nodeType);
        if( pChild )
        {
            SmCaretPosGraphEntry *cLeft; //Child left
            cLeft = mpGraph->Add( SmCaretPos( pChild, 0 ), ((nodeType == RSUP) || (nodeType == RSUB))?bodyRight:left );
 
            mpRightMost = cLeft;
            pChild->Accept( this );
 
            mpRightMost->SetRight( ((nodeType == LSUP) || (nodeType == LSUB))?bodyLeft:right );
        }
    }
 
    //Set return parameters
    mpRightMost = right;
}
 
void SmCaretPosGraphBuildingVisitor::Visit( SmOperNode* pNode )
{
    SmNode *pOper = pNode->GetSubNode( 0 ),
           *pBody = pNode->GetSubNode( 1 );
 
    SmCaretPosGraphEntry *left = mpRightMost,
                         *bodyLeft,
                         *bodyRight,
                         *right;
    //Create body left
    bodyLeft = mpGraph->Add( SmCaretPos( pBody, 0 ), left );
    left->SetRight( bodyLeft );
 
    //Visit body, get bodyRight
    mpRightMost = bodyLeft;
    pBody->Accept( this );
    bodyRight = mpRightMost;
 
    //Create right
    right = mpGraph->Add( SmCaretPos( pNode, 1 ), bodyRight );
    bodyRight->SetRight( right );
 
    //Get subsup pNode if any
    SmSubSupNode* pSubSup = pOper->GetType( ) == SmNodeType::SubSup ? static_cast<SmSubSupNode*>(pOper) : nullptr;
 
    if( pSubSup ) {
        SmNode* pChild;
        for (SmSubSup const nodeType : { LSUP, LSUB, CSUP, CSUB, RSUP, RSUB })
        {
            pChild = pSubSup->GetSubSup(nodeType);
            if( pChild )
            {
            //Create position in front of pChild
                SmCaretPosGraphEntry *childLeft = mpGraph->Add( SmCaretPos( pChild, 0 ), left );
                //Visit pChild
                mpRightMost = childLeft;
                pChild->Accept( this );
                //Set right on mpRightMost from pChild
                mpRightMost->SetRight( bodyLeft );
            }
        }
    }
 
    //Return right
    mpRightMost = right;
}
 
void SmCaretPosGraphBuildingVisitor::Visit( SmMatrixNode* pNode )
{
    SmCaretPosGraphEntry *left  = mpRightMost,
                         *right = mpGraph->Add( SmCaretPos( pNode, 1 ) );
 
    for (size_t i = 0;  i < pNode->GetNumRows(); ++i)
    {
        SmCaretPosGraphEntry* r = left;
        for (size_t j = 0;  j < pNode->GetNumCols(); ++j)
        {
            SmNode* pSubNode = pNode->GetSubNode( i * pNode->GetNumCols( ) + j );
 
            mpRightMost = mpGraph->Add( SmCaretPos( pSubNode, 0 ), r );
            if( j != 0 || ( pNode->GetNumRows() - 1U ) / 2 == i )
                r->SetRight( mpRightMost );
 
            pSubNode->Accept( this );
 
            r = mpRightMost;
        }
        mpRightMost->SetRight( right );
        if( ( pNode->GetNumRows() - 1U ) / 2 == i )
            right->SetLeft( mpRightMost );
    }
 
    mpRightMost = right;
}
 
void SmCaretPosGraphBuildingVisitor::Visit( SmTextNode* pNode )
{
    SAL_WARN_IF( pNode->GetText().isEmpty(), "starmath", "Empty SmTextNode is bad" );
 
    int size = pNode->GetText().getLength();
    for( int i = 1; i <= size; i++ ){
        SmCaretPosGraphEntry* pRight = mpRightMost;
        mpRightMost = mpGraph->Add( SmCaretPos( pNode, i ), pRight );
        pRight->SetRight( mpRightMost );
    }
}
 
void SmCaretPosGraphBuildingVisitor::Visit( SmBinVerNode* pNode )
{
    //None if these children can be NULL, see SmBinVerNode::Arrange
    SmNode  *pNum   = pNode->GetSubNode( 0 ),
            *pDenom = pNode->GetSubNode( 2 );
 
    SmCaretPosGraphEntry *left,
                         *right,
                         *numLeft,
                         *denomLeft;
 
    assert(mpRightMost);
    //Set left
    left = mpRightMost;
 
    //Create right
    right = mpGraph->Add( SmCaretPos( pNode, 1 ) );
 
    //Create numLeft
    numLeft = mpGraph->Add( SmCaretPos( pNum, 0 ), left );
    left->SetRight( numLeft );
 
    //Visit pNum
    mpRightMost = numLeft;
    pNum->Accept( this );
    mpRightMost->SetRight( right );
    right->SetLeft( mpRightMost );
 
    //Create denomLeft
    denomLeft = mpGraph->Add( SmCaretPos( pDenom, 0 ), left );
 
    //Visit pDenom
    mpRightMost = denomLeft;
    pDenom->Accept( this );
    mpRightMost->SetRight( right );
 
    //Set return parameter
    mpRightMost = right;
}
 
void SmCaretPosGraphBuildingVisitor::Visit( SmVerticalBraceNode* pNode )
{
    SmNode  *pBody   = pNode->Body(),
            *pScript = pNode->Script();
    //None of these children can be NULL
 
    SmCaretPosGraphEntry  *left,
                        *bodyLeft,
                        *scriptLeft,
                        *right;
 
    left = mpRightMost;
 
    //Create right
    right = mpGraph->Add( SmCaretPos( pNode, 1 ) );
 
    //Create bodyLeft
    bodyLeft = mpGraph->Add( SmCaretPos( pBody, 0 ), left );
    left->SetRight( bodyLeft );
    mpRightMost = bodyLeft;
    pBody->Accept( this );
    mpRightMost->SetRight( right );
    right->SetLeft( mpRightMost );
 
    //Create script
    scriptLeft = mpGraph->Add( SmCaretPos( pScript, 0 ), left );
    mpRightMost = scriptLeft;
    pScript->Accept( this );
    mpRightMost->SetRight( right );
 
    //Set return value
    mpRightMost = right;
}
 
void SmCaretPosGraphBuildingVisitor::Visit( SmBinDiagonalNode* pNode )
{
    SmNode  *A = pNode->GetSubNode( 0 ),
            *B = pNode->GetSubNode( 1 );
 
    SmCaretPosGraphEntry  *left,
                        *leftA,
                        *rightA,
                        *leftB,
                        *right;
    left = mpRightMost;
 
    //Create right
    right = mpGraph->Add( SmCaretPos( pNode, 1 ) );
 
    //Create left A
    leftA = mpGraph->Add( SmCaretPos( A, 0 ), left );
    left->SetRight( leftA );
 
    //Visit A
    mpRightMost = leftA;
    A->Accept( this );
    rightA = mpRightMost;
 
    //Create left B
    leftB = mpGraph->Add( SmCaretPos( B, 0 ), rightA );
    rightA->SetRight( leftB );
 
    //Visit B
    mpRightMost = leftB;
    B->Accept( this );
    mpRightMost->SetRight( right );
    right->SetLeft( mpRightMost );
 
    //Set return value
    mpRightMost = right;
}
 
//Straight forward ( I think )
void SmCaretPosGraphBuildingVisitor::Visit( SmBinHorNode* pNode )
{
    for( auto pChild : *pNode )
    {
        if(!pChild)
            continue;
        pChild->Accept( this );
    }
}
void SmCaretPosGraphBuildingVisitor::Visit( SmUnHorNode* pNode )
{
    // Unary operator node
    for( auto pChild : *pNode )
    {
        if(!pChild)
            continue;
        pChild->Accept( this );
    }
}
 
void SmCaretPosGraphBuildingVisitor::Visit( SmExpressionNode* pNode )
{
    for( auto pChild : *pNode )
    {
        if(!pChild)
            continue;
        pChild->Accept( this );
    }
}
 
void SmCaretPosGraphBuildingVisitor::Visit( SmFontNode* pNode )
{
    //Has only got one child, should act as an expression if possible
    for( auto pChild : *pNode )
    {
        if(!pChild)
            continue;
        pChild->Accept( this );
    }
}
 
void SmCaretPosGraphBuildingVisitor::Visit( SmBracebodyNode* pNode )
{
    for( auto pChild : *pNode )
    {
        if(!pChild)
            continue;
        SmCaretPosGraphEntry* pStart = mpGraph->Add( SmCaretPos( pChild, 0), mpRightMost );
        mpRightMost->SetRight( pStart );
        mpRightMost = pStart;
        pChild->Accept( this );
    }
}
 
void SmCaretPosGraphBuildingVisitor::Visit( SmAlignNode* pNode )
{
    for( auto pChild : *pNode )
    {
        if(!pChild)
            continue;
        pChild->Accept( this );
    }
}
 
void SmCaretPosGraphBuildingVisitor::Visit( SmRootNode* pNode )
{
    SmNode  *pExtra = pNode->GetSubNode( 0 ), //Argument, NULL for sqrt, and SmTextNode if cubicroot
            *pBody  = pNode->GetSubNode( 2 ); //Body of the root
    assert(pBody);
 
    SmCaretPosGraphEntry  *left,
                        *right,
                        *bodyLeft,
                        *bodyRight;
 
    //Get left and save it
    assert(mpRightMost);
    left = mpRightMost;
 
    //Create body left
    bodyLeft = mpGraph->Add( SmCaretPos( pBody, 0 ), left );
    left->SetRight( bodyLeft );
 
    //Create right
    right = mpGraph->Add( SmCaretPos( pNode, 1 ) );
 
    //Visit body
    mpRightMost = bodyLeft;
    pBody->Accept( this );
    bodyRight = mpRightMost;
    bodyRight->SetRight( right );
    right->SetLeft( bodyRight );
 
    //Visit pExtra
    if( pExtra ){
        mpRightMost = mpGraph->Add( SmCaretPos( pExtra, 0 ), left );
        pExtra->Accept( this );
        mpRightMost->SetRight( bodyLeft );
    }
 
    mpRightMost = right;
}
 
 
void SmCaretPosGraphBuildingVisitor::Visit( SmPlaceNode* pNode )
{
    SmCaretPosGraphEntry* right = mpGraph->Add( SmCaretPos( pNode, 1 ), mpRightMost );
    mpRightMost->SetRight( right );
    mpRightMost = right;
}
 
void SmCaretPosGraphBuildingVisitor::Visit( SmErrorNode* )
{
}
 
void SmCaretPosGraphBuildingVisitor::Visit( SmBlankNode* pNode )
{
    SmCaretPosGraphEntry* right = mpGraph->Add( SmCaretPos( pNode, 1 ), mpRightMost );
    mpRightMost->SetRight( right );
    mpRightMost = right;
}
 
void SmCaretPosGraphBuildingVisitor::Visit( SmBraceNode* pNode )
{
    SmNode* pBody = pNode->Body();
 
    SmCaretPosGraphEntry  *left = mpRightMost,
                        *right = mpGraph->Add( SmCaretPos( pNode, 1 ) );
 
    if( pBody->GetType() != SmNodeType::Bracebody ) {
        mpRightMost = mpGraph->Add( SmCaretPos( pBody, 0 ), left );
        left->SetRight( mpRightMost );
    }else
        mpRightMost = left;
 
    pBody->Accept( this );
    mpRightMost->SetRight( right );
    right->SetLeft( mpRightMost );
 
    mpRightMost = right;
}
 
void SmCaretPosGraphBuildingVisitor::Visit( SmAttributeNode* pNode )
{
    SmNode  *pAttr = pNode->Attribute(),
            *pBody = pNode->Body();
    assert(pAttr);
    assert(pBody);
 
    SmCaretPosGraphEntry  *left = mpRightMost,
                        *attrLeft,
                        *bodyLeft,
                        *bodyRight,
                        *right;
 
    //Creating bodyleft
    bodyLeft = mpGraph->Add( SmCaretPos( pBody, 0 ), left );
    left->SetRight( bodyLeft );
 
    //Creating right
    right = mpGraph->Add( SmCaretPos( pNode, 1 ) );
 
    //Visit the body
    mpRightMost = bodyLeft;
    pBody->Accept( this );
    bodyRight = mpRightMost;
    bodyRight->SetRight( right );
    right->SetLeft( bodyRight );
 
    //Create attrLeft
    attrLeft = mpGraph->Add( SmCaretPos( pAttr, 0 ), left );
 
    //Visit attribute
    mpRightMost = attrLeft;
    pAttr->Accept( this );
    mpRightMost->SetRight( right );
 
    //Set return value
    mpRightMost = right;
}
 
//Consider these single symbols
void SmCaretPosGraphBuildingVisitor::Visit( SmSpecialNode* pNode )
{
    SmCaretPosGraphEntry* right = mpGraph->Add( SmCaretPos( pNode, 1 ), mpRightMost );
    mpRightMost->SetRight( right );
    mpRightMost = right;
}
void SmCaretPosGraphBuildingVisitor::Visit( SmGlyphSpecialNode* pNode )
{
    SmCaretPosGraphEntry* right = mpGraph->Add( SmCaretPos( pNode, 1 ), mpRightMost );
    mpRightMost->SetRight( right );
    mpRightMost = right;
}
void SmCaretPosGraphBuildingVisitor::Visit( SmMathSymbolNode* pNode )
{
    SmCaretPosGraphEntry* right = mpGraph->Add( SmCaretPos( pNode, 1 ), mpRightMost );
    mpRightMost->SetRight( right );
    mpRightMost = right;
}
 
void SmCaretPosGraphBuildingVisitor::Visit( SmRootSymbolNode* )
{
    //Do nothing
}
 
void SmCaretPosGraphBuildingVisitor::Visit( SmRectangleNode* )
{
    //Do nothing
}
void SmCaretPosGraphBuildingVisitor::Visit( SmPolyLineNode* )
{
    //Do nothing
}
 
// SmCloningVisitor
 
SmNode* SmCloningVisitor::Clone( SmNode* pNode )
{
    SmNode* pCurrResult = mpResult;
    pNode->Accept( this );
    SmNode* pClone = mpResult;
    mpResult = pCurrResult;
    return pClone;
}
 
void SmCloningVisitor::CloneNodeAttr( SmNode const * pSource, SmNode* pTarget )
{
    pTarget->SetScaleMode( pSource->GetScaleMode( ) );
    //Other attributes are set when prepare or arrange is executed
    //and may depend on stuff not being cloned here.
}
 
void SmCloningVisitor::CloneKids( SmStructureNode* pSource, SmStructureNode* pTarget )
{
    //Cache current result
    SmNode* pCurrResult = mpResult;
 
    //Create array for holding clones
    size_t nSize = pSource->GetNumSubNodes( );
    SmNodeArray aNodes( nSize );
 
    //Clone children
    for (size_t i = 0; i < nSize; ++i)
    {
        SmNode* pKid;
        if( nullptr != ( pKid = pSource->GetSubNode( i ) ) )
            pKid->Accept( this );
        else
            mpResult = nullptr;
        aNodes[i] = mpResult;
    }
 
    //Set subnodes of pTarget
    pTarget->SetSubNodes( std::move(aNodes) );
 
    //Restore result as where prior to call
    mpResult = pCurrResult;
}
 
void SmCloningVisitor::Visit( SmTableNode* pNode )
{
    SmTableNode* pClone = new SmTableNode( pNode->GetToken( ) );
    pClone->SetSelection( pNode->GetSelection() );
    CloneNodeAttr( pNode, pClone );
    CloneKids( pNode, pClone );
    mpResult = pClone;
}
 
void SmCloningVisitor::Visit( SmBraceNode* pNode )
{
    SmBraceNode* pClone = new SmBraceNode( pNode->GetToken( ) );
    pClone->SetSelection( pNode->GetSelection() );
    CloneNodeAttr( pNode, pClone );
    CloneKids( pNode, pClone );
    mpResult = pClone;
}
 
void SmCloningVisitor::Visit( SmBracebodyNode* pNode )
{
    SmBracebodyNode* pClone = new SmBracebodyNode( pNode->GetToken( ) );
    pClone->SetSelection( pNode->GetSelection() );
    CloneNodeAttr( pNode, pClone );
    CloneKids( pNode, pClone );
    mpResult = pClone;
}
 
void SmCloningVisitor::Visit( SmOperNode* pNode )
{
    SmOperNode* pClone = new SmOperNode( pNode->GetToken( ) );
    pClone->SetSelection( pNode->GetSelection() );
    CloneNodeAttr( pNode, pClone );
    CloneKids( pNode, pClone );
    mpResult = pClone;
}
 
void SmCloningVisitor::Visit( SmAlignNode* pNode )
{
    SmAlignNode* pClone = new SmAlignNode( pNode->GetToken( ) );
    pClone->SetSelection( pNode->GetSelection() );
    CloneNodeAttr( pNode, pClone );
    CloneKids( pNode, pClone );
    mpResult = pClone;
}
 
void SmCloningVisitor::Visit( SmAttributeNode* pNode )
{
    SmAttributeNode* pClone = new SmAttributeNode( pNode->GetToken( ) );
    pClone->SetSelection( pNode->GetSelection() );
    CloneNodeAttr( pNode, pClone );
    CloneKids( pNode, pClone );
    mpResult = pClone;
}
 
void SmCloningVisitor::Visit( SmFontNode* pNode )
{
    SmFontNode* pClone = new SmFontNode( pNode->GetToken( ) );
    pClone->SetSelection( pNode->GetSelection() );
    pClone->SetSizeParameter( pNode->GetSizeParameter( ), pNode->GetSizeType( ) );
    CloneNodeAttr( pNode, pClone );
    CloneKids( pNode, pClone );
    mpResult = pClone;
}
 
void SmCloningVisitor::Visit( SmUnHorNode* pNode )
{
    SmUnHorNode* pClone = new SmUnHorNode( pNode->GetToken( ) );
    pClone->SetSelection( pNode->GetSelection() );
    CloneNodeAttr( pNode, pClone );
    CloneKids( pNode, pClone );
    mpResult = pClone;
}
 
void SmCloningVisitor::Visit( SmBinHorNode* pNode )
{
    SmBinHorNode* pClone = new SmBinHorNode( pNode->GetToken( ) );
    pClone->SetSelection( pNode->GetSelection() );
    CloneNodeAttr( pNode, pClone );
    CloneKids( pNode, pClone );
    mpResult = pClone;
}
 
void SmCloningVisitor::Visit( SmBinVerNode* pNode )
{
    SmBinVerNode* pClone = new SmBinVerNode( pNode->GetToken( ) );
    pClone->SetSelection( pNode->GetSelection() );
    CloneNodeAttr( pNode, pClone );
    CloneKids( pNode, pClone );
    mpResult = pClone;
}
 
void SmCloningVisitor::Visit( SmBinDiagonalNode* pNode )
{
    SmBinDiagonalNode *pClone = new SmBinDiagonalNode( pNode->GetToken( ) );
    pClone->SetSelection( pNode->GetSelection() );
    pClone->SetAscending( pNode->IsAscending( ) );
    CloneNodeAttr( pNode, pClone );
    CloneKids( pNode, pClone );
    mpResult = pClone;
}
 
void SmCloningVisitor::Visit( SmSubSupNode* pNode )
{
    SmSubSupNode *pClone = new SmSubSupNode( pNode->GetToken( ) );
    pClone->SetSelection( pNode->GetSelection() );
    pClone->SetUseLimits( pNode->IsUseLimits( ) );
    CloneNodeAttr( pNode, pClone );
    CloneKids( pNode, pClone );
    mpResult = pClone;
}
 
void SmCloningVisitor::Visit( SmMatrixNode* pNode )
{
    SmMatrixNode *pClone = new SmMatrixNode( pNode->GetToken( ) );
    pClone->SetSelection( pNode->GetSelection() );
    pClone->SetRowCol( pNode->GetNumRows( ), pNode->GetNumCols( ) );
    CloneNodeAttr( pNode, pClone );
    CloneKids( pNode, pClone );
    mpResult = pClone;
}
 
void SmCloningVisitor::Visit( SmPlaceNode* pNode )
{
    mpResult = new SmPlaceNode( pNode->GetToken( ) );
    mpResult->SetSelection( pNode->GetSelection() );
    CloneNodeAttr( pNode, mpResult );
}
 
void SmCloningVisitor::Visit( SmTextNode* pNode )
{
    SmTextNode* pClone = new SmTextNode( pNode->GetToken( ), pNode->GetFontDesc( ) );
    pClone->SetSelection( pNode->GetSelection() );
    pClone->ChangeText( pNode->GetText( ) );
    CloneNodeAttr( pNode, pClone );
    mpResult = pClone;
}
 
void SmCloningVisitor::Visit( SmSpecialNode* pNode )
{
    mpResult = new SmSpecialNode( pNode->GetToken( ) );
    mpResult->SetSelection( pNode->GetSelection() );
    CloneNodeAttr( pNode, mpResult );
}
 
void SmCloningVisitor::Visit( SmGlyphSpecialNode* pNode )
{
    mpResult = new SmGlyphSpecialNode( pNode->GetToken( ) );
    mpResult->SetSelection( pNode->GetSelection() );
    CloneNodeAttr( pNode, mpResult );
}
 
void SmCloningVisitor::Visit( SmMathSymbolNode* pNode )
{
    mpResult = new SmMathSymbolNode( pNode->GetToken( ) );
    mpResult->SetSelection( pNode->GetSelection() );
    CloneNodeAttr( pNode, mpResult );
}
 
void SmCloningVisitor::Visit( SmBlankNode* pNode )
{
    SmBlankNode* pClone = new SmBlankNode( pNode->GetToken( ) );
    pClone->SetSelection( pNode->GetSelection() );
    pClone->SetBlankNum( pNode->GetBlankNum( ) );
    mpResult = pClone;
    CloneNodeAttr( pNode, mpResult );
}
 
void SmCloningVisitor::Visit( SmErrorNode* pNode )
{
    mpResult = new SmErrorNode( pNode->GetToken( ) );
    mpResult->SetSelection( pNode->GetSelection() );
    CloneNodeAttr( pNode, mpResult );
}
 
void SmCloningVisitor::Visit( SmLineNode* pNode )
{
    SmLineNode* pClone = new SmLineNode( pNode->GetToken( ) );
    pClone->SetSelection( pNode->GetSelection() );
    CloneNodeAttr( pNode, pClone );
    CloneKids( pNode, pClone );
    mpResult = pClone;
}
 
void SmCloningVisitor::Visit( SmExpressionNode* pNode )
{
    SmExpressionNode* pClone = new SmExpressionNode( pNode->GetToken( ) );
    pClone->SetSelection( pNode->GetSelection() );
    CloneNodeAttr( pNode, pClone );
    CloneKids( pNode, pClone );
    mpResult = pClone;
}
 
void SmCloningVisitor::Visit( SmPolyLineNode* pNode )
{
    mpResult = new SmPolyLineNode( pNode->GetToken( ) );
    mpResult->SetSelection( pNode->GetSelection() );
    CloneNodeAttr( pNode, mpResult );
}
 
void SmCloningVisitor::Visit( SmRootNode* pNode )
{
    SmRootNode* pClone = new SmRootNode( pNode->GetToken( ) );
    pClone->SetSelection( pNode->GetSelection() );
    CloneNodeAttr( pNode, pClone );
    CloneKids( pNode, pClone );
    mpResult = pClone;
}
 
void SmCloningVisitor::Visit( SmRootSymbolNode* pNode )
{
    mpResult = new SmRootSymbolNode( pNode->GetToken( ) );
    mpResult->SetSelection( pNode->GetSelection() );
    CloneNodeAttr( pNode, mpResult );
}
 
void SmCloningVisitor::Visit( SmRectangleNode* pNode )
{
    mpResult = new SmRectangleNode( pNode->GetToken( ) );
    mpResult->SetSelection( pNode->GetSelection() );
    CloneNodeAttr( pNode, mpResult );
}
 
void SmCloningVisitor::Visit( SmVerticalBraceNode* pNode )
{
    SmVerticalBraceNode* pClone = new SmVerticalBraceNode( pNode->GetToken( ) );
    pClone->SetSelection( pNode->GetSelection() );
    CloneNodeAttr( pNode, pClone );
    CloneKids( pNode, pClone );
    mpResult = pClone;
}
 
// SmSelectionDrawingVisitor
 
SmSelectionDrawingVisitor::SmSelectionDrawingVisitor( OutputDevice& rDevice, SmNode* pTree, const Point& rOffset )
    : SmSelectionRectanglesVisitor( rDevice, pTree )
{
    //Draw selection if there's any
    if(GetSelection().IsEmpty())        return;
 
    tools::Rectangle aSelectionArea = GetSelection() + rOffset;
 
    //Save device state
    rDevice.Push( vcl::PushFlags::LINECOLOR | vcl::PushFlags::FILLCOLOR );
    //Change colors
    rDevice.SetLineColor( );
    rDevice.SetFillColor( COL_LIGHTGRAY );
 
    //Draw rectangle
    rDevice.DrawRect( aSelectionArea );
 
    //Restore device state
    rDevice.Pop( );
}
 
// SmSelectionRectanglesVisitor
 
SmSelectionRectanglesVisitor::SmSelectionRectanglesVisitor(OutputDevice& rDevice, SmNode* pTree)
    : mrDev(rDevice)
{
    // Visit everything
    SAL_WARN_IF(!pTree, "starmath", "pTree can't be null!");
    if (pTree)
        pTree->Accept(this);
}
 
void SmSelectionRectanglesVisitor::DefaultVisit( SmNode* pNode )
{
    if( pNode->IsSelected( ) )
        ExtendSelectionArea( pNode->AsRectangle( ) );
    VisitChildren( pNode );
}
 
void SmSelectionRectanglesVisitor::VisitChildren( SmNode* pNode )
{
    if(pNode->GetNumSubNodes() == 0)
        return;
    for( auto pChild : *static_cast<SmStructureNode*>(pNode) )
    {
        if(!pChild)
            continue;
        pChild->Accept( this );
    }
}
 
void SmSelectionRectanglesVisitor::Visit( SmTextNode* pNode )
{
    if( !pNode->IsSelected())
        return;
 
    mrDev.Push( vcl::PushFlags::TEXTCOLOR | vcl::PushFlags::FONT );
 
    mrDev.SetFont( pNode->GetFont( ) );
    Point Position = pNode->GetTopLeft( );
    tools::Long left   = Position.getX( ) + mrDev.GetTextWidth( pNode->GetText( ), 0, pNode->GetSelectionStart( ) );
    tools::Long right  = Position.getX( ) + mrDev.GetTextWidth( pNode->GetText( ), 0, pNode->GetSelectionEnd( ) );
    tools::Long top    = Position.getY( );
    tools::Long bottom = top + pNode->GetHeight( );
    tools::Rectangle rect( left, top, right, bottom );
 
    ExtendSelectionArea( rect );
 
    mrDev.Pop( );
}
 
// SmNodeToTextVisitor
 
SmNodeToTextVisitor::SmNodeToTextVisitor( SmNode* pNode, OUString &rText )
{
    pNode->Accept( this );
    maCmdText.stripEnd(' ');
    rText = maCmdText.makeStringAndClear();
}
 
void SmNodeToTextVisitor::Visit( SmTableNode* pNode )
{
    if( pNode->GetToken( ).eType == TBINOM ) {
        Append(u"{ binom");
        LineToText( pNode->GetSubNode( 0 ) );
        LineToText( pNode->GetSubNode( 1 ) );
        Append(u"} ");
    } else if( pNode->GetToken( ).eType == TSTACK ) {
        Append(u"stack{ ");
        bool bFirst = true;
        for( auto pChild : *pNode )
        {
            if(!pChild)
                continue;
            if(bFirst)
                bFirst = false;
            else
            {
                Separate( );
                Append(u"# ");
            }
            LineToText( pChild );
        }
        Separate( );
        Append(u"}");
    } else { //Assume it's a toplevel table, containing lines
        bool bFirst = true;
        for( auto pChild : *pNode )
        {
            if(!pChild)
                continue;
            if(bFirst)
                bFirst = false;
            else
            {
                Separate( );
                Append(u"newline");
            }
            Separate( );
            pChild->Accept( this );
        }
    }
}
 
void SmNodeToTextVisitor::Visit( SmBraceNode* pNode )
{
    if ( pNode->GetToken().eType == TEVALUATE )
    {
        SmNode *pBody = pNode->Body();
        Append(u"evaluate { ");
        pBody->Accept( this );
        Append(u"} ");
    }
    else{
        SmNode *pLeftBrace  = pNode->OpeningBrace(),
               *pBody       = pNode->Body(),
               *pRightBrace = pNode->ClosingBrace();
        //Handle special case where it's absolute function
        if( pNode->GetToken( ).eType == TABS ) {
            Append(u"abs");
            LineToText( pBody );
        } else {
            if( pNode->GetScaleMode( ) == SmScaleMode::Height )
                Append(u"left ");
            pLeftBrace->Accept( this );
            Separate( );
            pBody->Accept( this );
            Separate( );
            if( pNode->GetScaleMode( ) == SmScaleMode::Height )
                Append(u"right ");
            pRightBrace->Accept( this );
        }
    }
}
 
void SmNodeToTextVisitor::Visit( SmBracebodyNode* pNode )
{
    for( auto pChild : *pNode )
    {
        if(!pChild)
            continue;
        Separate( );
        pChild->Accept( this );
    }
}
 
void SmNodeToTextVisitor::Visit( SmOperNode* pNode )
{
    Append( pNode->GetToken( ).aText );
    Separate( );
    if( pNode->GetToken( ).eType == TOPER ){
        //There's an SmGlyphSpecialNode if eType == TOPER
        if( pNode->GetSubNode( 0 )->GetType( ) == SmNodeType::SubSup )
            Append( pNode->GetSubNode( 0 )->GetSubNode( 0 )->GetToken( ).aText );
        else
            Append( pNode->GetSubNode( 0 )->GetToken( ).aText );
    }
    if( pNode->GetSubNode( 0 )->GetType( ) == SmNodeType::SubSup ) {
        SmSubSupNode *pSubSup = static_cast<SmSubSupNode*>( pNode->GetSubNode( 0 ) );
        SmNode* pChild = pSubSup->GetSubSup( LSUP );
        if( pChild ) {
            Separate( );
            Append(u"lsup { ");
            LineToText( pChild );
            Append(u"} ");
        }
        pChild = pSubSup->GetSubSup( LSUB );
        if( pChild ) {
            Separate( );
            Append(u"lsub { ");
            LineToText( pChild );
            Append(u"} ");
        }
        pChild = pSubSup->GetSubSup( RSUP );
        if( pChild ) {
            Separate( );
            Append(u"^ { ");
            LineToText( pChild );
            Append(u"} ");
        }
        pChild = pSubSup->GetSubSup( RSUB );
        if( pChild ) {
            Separate( );
            Append(u"_ { ");
            LineToText( pChild );
            Append(u"} ");
        }
        pChild = pSubSup->GetSubSup( CSUP );
        if( pChild ) {
            Separate( );
            if (pSubSup->IsUseLimits())
                Append(u"to { ");
            else
                Append(u"csup { ");
            LineToText( pChild );
            Append(u"} ");
        }
        pChild = pSubSup->GetSubSup( CSUB );
        if( pChild ) {
            Separate( );
            if (pSubSup->IsUseLimits())
                Append(u"from { ");
            else
                Append(u"csub { ");
            LineToText( pChild );
            Append(u"} ");
        }
    }
    LineToText( pNode->GetSubNode( 1 ) );
}
 
void SmNodeToTextVisitor::Visit( SmAlignNode* pNode )
{
    Append( pNode->GetToken( ).aText );
    LineToText( pNode->GetSubNode( 0 ) );
}
 
void SmNodeToTextVisitor::Visit( SmAttributeNode* pNode )
{
    Append( pNode->GetToken( ).aText );
    LineToText( pNode->Body() );
}
 
void SmNodeToTextVisitor::Visit( SmFontNode* pNode )
{
    sal_uInt32 nc;
    sal_uInt8  nr, ng, nb;
    switch ( pNode->GetToken( ).eType )
    {
        case TBOLD:
            Append(u"bold ");
            break;
        case TNBOLD:
            Append(u"nbold ");
            break;
        case TITALIC:
            Append(u"italic ");
            break;
        case TNITALIC:
            Append(u"nitalic ");
            break;
        case TPHANTOM:
            Append(u"phantom ");
            break;
        case TSIZE:
            {
                Append(u"size ");
                switch ( pNode->GetSizeType( ) )
                {
                    case FontSizeType::PLUS:
                        Append(u"+");
                        break;
                    case FontSizeType::MINUS:
                        Append(u"-");
                        break;
                    case FontSizeType::MULTIPLY:
                        Append(u"*");
                        break;
                    case FontSizeType::DIVIDE:
                        Append(u"/");
                        break;
                    case FontSizeType::ABSOLUT:
                    default:
                        break;
                }
                Append( ::rtl::math::doubleToUString(
                            static_cast<double>( pNode->GetSizeParameter( ) ),
                            rtl_math_StringFormat_Automatic,
                            rtl_math_DecimalPlaces_Max, '.', true ) );
                Separate( );
            }
            break;
 
        case TDVIPSNAMESCOL:
            Append(u"color dvip ");
            nc = pNode->GetToken().cMathChar.toUInt32(16);
            Append( starmathdatabase::Identify_Color_Parser( nc ).aIdent );
            break;
        case THTMLCOL:
        case TMATHMLCOL:
        case TICONICCOL:
            Append(u"color ");
            nc = pNode->GetToken().cMathChar.toUInt32(16);
            Append( starmathdatabase::Identify_Color_Parser( nc ).aIdent );
            break;
        case TRGB:
            nc = pNode->GetToken().cMathChar.toUInt32(16);
            Append(u"color rgb ");
            nb = nc % 256;
            nc /= 256;
            ng = nc % 256;
            nc /= 256;
            nr = nc % 256;
            Append(OUString::number(nr));
            Separate();
            Append(OUString::number(ng));
            Separate();
            Append(OUString::number(nb));
            Separate();
            break;
        case TRGBA:
            Append(u"color rgba ");
            nc = pNode->GetToken().cMathChar.toUInt32(16);
            nb = nc % 256;
            nc /= 256;
            ng = nc % 256;
            nc /= 256;
            nr = nc % 256;
            nc /= 256;
            Append(OUString::number(nr));
            Separate();
            Append(OUString::number(ng));
            Separate();
            Append(OUString::number(nb));
            Separate();
            Append(OUString::number(nc));
            Separate();
            break;
        case THEX:
            Append(u"color hex ");
            nc = pNode->GetToken().cMathChar.toUInt32(16);
            Append(OUString::number(nc,16));
            Separate();
            break;
        case TSANS:
            Append(u"font sans ");
            break;
        case TSERIF:
            Append(u"font serif ");
            break;
        case TFIXED:
            Append(u"font fixed ");
            break;
        default:
            break;
    }
    LineToText( pNode->GetSubNode( 1 ) );
}
 
void SmNodeToTextVisitor::Visit( SmUnHorNode* pNode )
{
    if(pNode->GetSubNode( 1 )->GetToken( ).eType == TFACT)
    {
        // visit children in the reverse order
        for( auto it = pNode->rbegin(); it != pNode->rend(); ++it )
        {
            auto pChild = *it;
            if(!pChild)
                continue;
            Separate( );
            pChild->Accept( this );
        }
    }
    else
    {
        for( auto pChild : *pNode )
        {
            if(!pChild)
                continue;
            Separate( );
            pChild->Accept( this );
        }
    }
}
 
void SmNodeToTextVisitor::Visit( SmBinHorNode* pNode )
{
    const SmNode *pParent = pNode->GetParent();
    bool bBraceNeeded = pParent && pParent->GetType() == SmNodeType::Font;
    SmNode *pLeft  = pNode->LeftOperand(),
           *pOper  = pNode->Symbol(),
           *pRight = pNode->RightOperand();
    Separate( );
    if (bBraceNeeded)
        Append(u"{ ");
    pLeft->Accept( this );
    Separate( );
    pOper->Accept( this );
    Separate( );
    pRight->Accept( this );
    Separate( );
    if (bBraceNeeded)
        Append(u"} ");
}
 
void SmNodeToTextVisitor::Visit( SmBinVerNode* pNode )
{
    if( pNode->GetToken().eType == TOVER ){
        SmNode *pNum    = pNode->GetSubNode( 0 ),
               *pDenom  = pNode->GetSubNode( 2 );
        Append(u"{ ");
        LineToText( pNum );
        Append(u"over");
        LineToText( pDenom );
        Append(u"} ");
    } else{
        SmNode *pNum    = pNode->GetSubNode( 0 ),
               *pDenom  = pNode->GetSubNode( 2 );
        Append(u"{ frac {");
        LineToText( pNum );
        Append(u"} {");
        LineToText( pDenom );
        Append(u"} }");
    }
}
 
void SmNodeToTextVisitor::Visit( SmBinDiagonalNode* pNode )
{
    SmNode *pLeftOperand  = pNode->GetSubNode( 0 ),
           *pRightOperand = pNode->GetSubNode( 1 );
    Append(u"{ ");
    LineToText( pLeftOperand );
    Separate( );
    Append(u"wideslash ");
    LineToText( pRightOperand );
    Append(u"} ");
}
 
void SmNodeToTextVisitor::Visit( SmSubSupNode* pNode )
{
    if( pNode->GetToken().eType == TEVALUATE )
    {
        Append(u"evaluate { ");
        pNode->GetSubNode( 0 )->GetSubNode( 1 )->Accept(this);
        Append(u"} ");
        SmNode* pChild = pNode->GetSubSup( RSUP );
        if( pChild ) {
            Separate( );
            Append(u"to { ");
            LineToText( pChild );
            Append(u"} ");
        }
        pChild = pNode->GetSubSup( RSUB );
        if( pChild ) {
            Separate( );
            Append(u"from { ");
            LineToText( pChild );
            Append(u"} ");
        }
    }
    else
    {
        LineToText( pNode->GetBody( ) );
        SmNode *pChild = pNode->GetSubSup( LSUP );
        if( pChild ) {
            Separate( );
            Append(u"lsup ");
            LineToText( pChild );
        }
        pChild = pNode->GetSubSup( LSUB );
        if( pChild ) {
            Separate( );
            Append(u"lsub ");
            LineToText( pChild );
        }
        pChild = pNode->GetSubSup( RSUP );
        if( pChild ) {
            Separate( );
            Append(u"^ ");
            LineToText( pChild );
        }
        pChild = pNode->GetSubSup( RSUB );
        if( pChild ) {
            Separate( );
            Append(u"_ ");
            LineToText( pChild );
        }
        pChild = pNode->GetSubSup( CSUP );
        if( pChild ) {
            Separate( );
            if (pNode->IsUseLimits())
                Append(u"to ");
            else
                Append(u"csup ");
            LineToText( pChild );
        }
        pChild = pNode->GetSubSup( CSUB );
        if( pChild ) {
            Separate( );
            if (pNode->IsUseLimits())
                Append(u"from ");
            else
                Append(u"csub ");
            LineToText( pChild );
        }
    }
}
 
void SmNodeToTextVisitor::Visit( SmMatrixNode* pNode )
{
    Append(u"matrix{");
    for (size_t i = 0; i < pNode->GetNumRows(); ++i)
    {
        for (size_t j = 0; j < pNode->GetNumCols( ); ++j)
        {
            SmNode* pSubNode = pNode->GetSubNode( i * pNode->GetNumCols( ) + j );
            Separate( );
            if (pSubNode)
                pSubNode->Accept( this );
            Separate( );
            if (j != pNode->GetNumCols() - 1U)
                Append(u"#");
        }
        Separate( );
        if (i != pNode->GetNumRows() - 1U)
            Append(u"##");
    }
    Append(u"} ");
}
 
void SmNodeToTextVisitor::Visit( SmPlaceNode* )
{
    Append(u"<?>");
}
 
void SmNodeToTextVisitor::Visit( SmTextNode* pNode )
{
    SmTokenType type = pNode->GetToken( ).eType;
    switch(type){
        case TTEXT:
            Append(u"\"");
            Append( pNode->GetToken().aText );
            Append(u"\"");
            break;
        case TNUMBER:
            Append( pNode->GetToken().aText );
            break;
        case TIDENT:
            Append( pNode->GetToken().aText );
            break;
        case TFUNC:
            Append(u"func ");
            Append( pNode->GetToken().aText );
            break;
        case THEX:
            Append(u"hex ");
            Append( pNode->GetToken().aText );
            break;
        default:
            Append( pNode->GetToken().aText );
    }
    Separate( );
}
 
void SmNodeToTextVisitor::Visit( SmSpecialNode* pNode )
{
    SmTokenType type = pNode->GetToken().eType;
    switch(type){
        case TLIMSUP:
            Append(u"lim sup ");
            break;
        case TLIMINF:
            Append(u"lim inf ");
            break;
        default:
            Append( pNode->GetToken().aText );
            break;
    }
}
 
void SmNodeToTextVisitor::Visit( SmGlyphSpecialNode* pNode )
{
    if( pNode->GetToken( ).eType == TBOPER )
        Append(u"boper ");
    else
        Append(u"uoper ");
    Append( pNode->GetToken( ).aText );
}
 
//TODO to improve this it is required to improve mathmlimport.
void SmNodeToTextVisitor::Visit( SmMathSymbolNode* pNode )
{
    if (    ( pNode->GetToken().nGroup & TG::LBrace )
         || ( pNode->GetToken().nGroup & TG::RBrace )
         || ( pNode->GetToken().nGroup & TG::Sum )
         || ( pNode->GetToken().nGroup & TG::Product )
         || ( pNode->GetToken().nGroup & TG::Relation )
         || ( pNode->GetToken().nGroup & TG::UnOper )
         || ( pNode->GetToken().nGroup & TG::Oper )
    ) {
        Append( pNode->GetToken().aText );
        return;
    }
    sal_Unicode cChar = pNode->GetToken().cMathChar[0];
    Separate( );
    switch(cChar){
        case MS_NONE:
            Append(u"none");
            break;
        case '{':
            Append(u"{");
            break;
        case '}':
            Append(u"}");
            break;
        case MS_VERTLINE:
            Append(u"mline");
            break;
        case MS_TILDE:
            Append(u"\"~\"");
            break;
        case MS_RIGHTARROW:
            if( pNode->GetToken().eType == TTOWARD ) Append(u"toward");
            else Append(u"rightarrow");
            break;
        case MS_LEFTARROW:
            Append(u"leftarrow");
            break;
        case MS_UPARROW:
            Append(u"uparrow");
            break;
        case MS_DOWNARROW:
            Append(u"downarrow");
            break;
        case MS_LAMBDABAR:
            Append(u"lambdabar");
            break;
        case MS_DOTSLOW:
            Append(u"dotslow");
            break;
        case MS_SETC:
            Append(u"setC");
            break;
        case MS_HBAR:
            Append(u"hbar");
            break;
        case MS_IM:
            Append(u"Im");
            break;
        case MS_SETN:
            Append(u"setN");
            break;
        case MS_WP:
            Append(u"wp");
            break;
        case MS_LAPLACE:
            Append(u"laplace");
            break;
        case MS_SETQ:
            Append(u"setQ");
            break;
        case MS_RE:
            Append(u"Re");
            break;
        case MS_SETR:
            Append(u"setR");
            break;
        case MS_SETZ:
            Append(u"setZ");
            break;
        case MS_ALEPH:
            Append(u"aleph");
            break;
        case 0x0362:
            Append(u"widevec");
            break;
        case MS_DLARROW:
            Append(u"dlarrow");
            break;
        case MS_DRARROW:
            Append(u"drarrow");
            break;
        case MS_DLRARROW:
            Append(u"dlrarrow");
            break;
        case MS_FORALL:
            Append(u"forall");
            break;
        case MS_PARTIAL:
            Append(u"partial");
            break;
        case MS_EXISTS:
            Append(u"exists");
            break;
        case MS_NOTEXISTS:
            Append(u"notexists");
            break;
        case MS_EMPTYSET:
            Append(u"emptyset");
            break;
        case MS_NABLA:
            Append(u"nabla");
            break;
        case MS_BACKEPSILON:
            Append(u"backepsilon");
            break;
        case MS_CIRC:
            Append(u"circ");
            break;
        case MS_INFINITY:
            Append(u"infinity");
            break;
        case 0x22b2: // NORMAL SUBGROUP OF
            Append(OUStringChar(cChar));
            break;
        case 0x22b3: // CONTAINS AS NORMAL SUBGROUP
            Append(OUStringChar(cChar));
            break;
        case MS_ORTHO:
            Append(u"ortho");
            break;
        case MS_DOTSVERT:
            Append(u"dotsvert");
            break;
        case MS_DOTSAXIS:
            Append(u"dotsaxis");
            break;
        case MS_DOTSUP:
            Append(u"dotsup");
            break;
        case MS_DOTSDOWN:
            Append(u"dotsdown");
            break;
        case '^':
            Append(u"^");
            break;
        case 0xe091:
            Append(u"widehat");
            break;
        case 0xe096:
            Append(u"widetilde");
            break;
        case 0xe098:
            Append(u"widevec");
            break;
        case 0xeb01:    //no space
        case 0xeb08:    //normal space
            break;
        case 0xef04:    //tiny space
        case 0xef05:    //tiny space
        case 0xeb02:    //small space
        case 0xeb04:    //medium space
            Append(u"`");
            break;
        case 0xeb05:    //large space
            Append(u"~");
            break;
        case 0x3a9:
            Append(u"%OMEGA");
            break;
        default:
            Append(OUStringChar(cChar));
            break;
    }
}
 
void SmNodeToTextVisitor::Visit( SmBlankNode* pNode )
{
    sal_uInt16 nNum = pNode->GetBlankNum();
    if (nNum <= 0)
        return;
    sal_uInt16 nWide = nNum / 4;
    sal_uInt16 nNarrow = nNum % 4;
    for (sal_uInt16 i = 0; i < nWide; i++)
        Append(u"~");
    for (sal_uInt16 i = 0; i < nNarrow; i++)
        Append(u"`");
    Append(u" ");
}
 
void SmNodeToTextVisitor::Visit( SmErrorNode* )
{
}
 
void SmNodeToTextVisitor::Visit( SmLineNode* pNode )
{
    for( auto pChild : *pNode )
    {
        if(!pChild)
            continue;
        Separate( );
        pChild->Accept( this );
    }
}
 
void SmNodeToTextVisitor::Visit( SmExpressionNode* pNode )
{
    bool bracketsNeeded = pNode->GetNumSubNodes() != 1 || pNode->GetSubNode(0)->GetType() == SmNodeType::BinHor;
    if (!bracketsNeeded)
    {
        const SmNode *pParent = pNode->GetParent();
        // nested subsups
        bracketsNeeded =
            pParent && pParent->GetType() == SmNodeType::SubSup &&
            pNode->GetNumSubNodes() == 1 &&
            pNode->GetSubNode(0)->GetType() == SmNodeType::SubSup;
    }
 
    if (bracketsNeeded) {
        Append(u"{ ");
    }
    for( auto pChild : *pNode )
    {
        if(!pChild)
            continue;
        pChild->Accept( this );
        Separate( );
    }
    if (bracketsNeeded) {
        Append(u"} ");
    }
}
 
void SmNodeToTextVisitor::Visit( SmPolyLineNode* )
{
}
 
void SmNodeToTextVisitor::Visit( SmRootNode* pNode )
{
    SmNode *pExtra   = pNode->GetSubNode( 0 ),
           *pBody    = pNode->GetSubNode( 2 );
    if( pExtra ) {
        Append(u"nroot");
        LineToText( pExtra );
    } else
        Append(u"sqrt");
    LineToText( pBody );
}
 
void SmNodeToTextVisitor::Visit( SmRootSymbolNode* )
{
}
 
void SmNodeToTextVisitor::Visit( SmRectangleNode* )
{
}
 
void SmNodeToTextVisitor::Visit( SmVerticalBraceNode* pNode )
{
    SmNode *pBody   = pNode->Body(),
           *pScript = pNode->Script();
    LineToText( pBody );
    Append( pNode->GetToken( ).aText );
    LineToText( pScript );
}
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */