/* -*- 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 <sal/config.h>

#include <string_view>

#include "ooxmlimport.hxx"

#include <types.hxx>

#include <oox/mathml/importutils.hxx>

#include <oox/token/namespaces.hxx>

#include <rtl/ustring.hxx>

#include <rtl/ustrbuf.hxx>

#include <sal/log.hxx>

#include <o3tl/string_view.hxx>

#include <parse5.hxx>

#include <unordered_set>

using namespace oox::formulaimport;

/*

The primary internal data structure for the formula is the text representation

(the SmNode tree is built from it), so read data must be converted into this format.

*/

#define OPENING( token ) XML_STREAM_OPENING( token )

#define CLOSING( token ) XML_STREAM_CLOSING( token )

// TODO create IS_OPENING(), IS_CLOSING() instead of doing 'next == OPENING( next )' ?

SmOoxmlImport::SmOoxmlImport( oox::formulaimport::XmlStream& s )

    : m_rStream( s )

{

}

OUString SmOoxmlImport::ConvertToStarMath()

{

    return handleStream();

}

// "toplevel" of reading, there will be oMath (if there was oMathPara, that was

// up to the parent component to handle)

// NOT complete

OUString SmOoxmlImport::handleStream()

{

    m_rStream.ensureOpeningTag( M_TOKEN( oMath ));

    OUStringBuffer ret;

    while( !m_rStream.atEnd() && m_rStream.currentToken() != CLOSING( M_TOKEN( oMath )))

    {

        // strictly speaking, it is not OMathArg here, but currently supported

        // functionality is the same like OMathArg, in the future this may need improving

        OUString item = readOMathArg( M_TOKEN( oMath ));

        if( item.isEmpty())

            continue;

        if( !ret.isEmpty())

            ret.append(" ");

        ret.append(item);

    }

    m_rStream.ensureClosingTag( M_TOKEN( oMath ));

    // Placeholders are written out as nothing (i.e. nothing inside e.g. the <e> element),

    // which will result in "{}" in the formula text. Fix this up.

    OUString ret2 = ret.makeStringAndClear().replaceAll( "{}", "<?>" );

    // And as a result, empty parts of the formula that are not placeholders are written out

    // as a single space, so fix that up too.

    ret2 = ret2.replaceAll( "{ }", "{}" );

    SAL_INFO( "starmath.ooxml", "Formula: " << ret2 );

    return ret2;

}

OUString SmOoxmlImport::readOMathArg( int stoptoken )

{

    OUStringBuffer ret;

    while( !m_rStream.atEnd() && m_rStream.currentToken() != CLOSING( stoptoken ))

    {

        if( !ret.isEmpty())

            ret.append(" ");

        switch( m_rStream.currentToken())

        {

            case OPENING( M_TOKEN( acc )):

                ret.append(handleAcc());

                break;

            case OPENING( M_TOKEN( bar )):

                ret.append(handleBar());

                break;

            case OPENING( M_TOKEN( box )):

                ret.append(handleBox());

                break;

            case OPENING( M_TOKEN( borderBox )):

                ret.append(handleBorderBox());

                break;

            case OPENING( M_TOKEN( d )):

                ret.append(handleD());

                break;

            case OPENING( M_TOKEN( eqArr )):

                ret.append(handleEqArr());

                break;

            case OPENING( M_TOKEN( f )):

                ret.append(handleF());

                break;

            case OPENING( M_TOKEN( func )):

                ret.append(handleFunc());

                break;

            case OPENING( M_TOKEN( limLow )):

                ret.append(handleLimLowUpp( LimLow ));

                break;

            case OPENING( M_TOKEN( limUpp )):

                ret.append(handleLimLowUpp( LimUpp ));

                break;

            case OPENING( M_TOKEN( groupChr )):

                ret.append(handleGroupChr());

                break;

            case OPENING( M_TOKEN( m )):

                ret.append(handleM());

                break;

            case OPENING( M_TOKEN( nary )):

                ret.append(handleNary());

                break;

            case OPENING( M_TOKEN( r )):

                ret.append(handleR());

                break;

            case OPENING( M_TOKEN( rad )):

                ret.append(handleRad());

                break;

            case OPENING( M_TOKEN( sPre )):

                ret.append(handleSpre());

                break;

            case OPENING( M_TOKEN( sSub )):

                ret.append(handleSsub());

                break;

            case OPENING( M_TOKEN( sSubSup )):

                ret.append(handleSsubsup());

                break;

            case OPENING( M_TOKEN( sSup )):

                ret.append(handleSsup());

                break;

            default:

                m_rStream.handleUnexpectedTag();

                break;

        }

    }

    return ret.makeStringAndClear();

}

OUString SmOoxmlImport::readOMathArgInElement( int token )

{

    m_rStream.ensureOpeningTag( token );

    OUString ret = readOMathArg( token );

    m_rStream.ensureClosingTag( token );

    return ret;

}

OUString SmOoxmlImport::handleAcc()

{

    m_rStream.ensureOpeningTag( M_TOKEN( acc ));

    sal_Unicode accChr = 0x302;

    if( XmlStream::Tag accPr = m_rStream.checkOpeningTag( M_TOKEN( accPr )))

    {

        if( XmlStream::Tag chr = m_rStream.checkOpeningTag( M_TOKEN( chr )))

        {

            accChr = chr.attribute( M_TOKEN( val ), accChr );

            m_rStream.ensureClosingTag( M_TOKEN( chr ));

        }

        m_rStream.ensureClosingTag( M_TOKEN( accPr ));

    }

    // see aTokenTable in parse.cxx

    OUString acc;

    switch( accChr )

    {

        case MS_BAR:

        case MS_COMBBAR:

            acc = "bar";

            break;

        case MS_CHECK:

        case MS_COMBCHECK:

            acc = "check";

            break;

        case MS_ACUTE:

        case MS_COMBACUTE:

            acc = "acute";

            break;

        case MS_COMBOVERLINE:

            acc = "overline";

            break;

        case MS_GRAVE:

        case MS_COMBGRAVE:

            acc = "grave";

            break;

        case MS_BREVE:

        case MS_COMBBREVE:

            acc = "breve";

            break;

        case MS_CIRCLE:

        case MS_COMBCIRCLE:

            acc = "circle";

            break;

        case MS_RIGHTARROW:

        case MS_VEC:

            // prefer wide variants for these 3, .docx can't seem to differentiate

            // between e.g. 'vec' and 'widevec', if whatever the accent is above is short, this

            // shouldn't matter, but short above a longer expression doesn't look right

            acc = "widevec";

            break;

        case MS_LVEC:

            acc = "wideleftvec";

            break;

        case MS_HARPOON:

            acc = "wideharpoon";

            break;

        case MS_LHARPOON:

            acc = "wideleftharpoon";

            break;

        case MS_TILDE:

        case MS_COMBTILDE:

            acc = "widetilde";

            break;

        case MS_HAT:

        case MS_COMBHAT:

            acc = "widehat";

            break;

        case MS_DOT:

        case MS_COMBDOT:

            acc = "dot";

            break;

        case MS_DDOT:

        case MS_COMBDDOT:

            acc = "ddot";

            break;

        case MS_DDDOT:

            acc = "dddot";

            break;

        default:

            acc = "acute";

            SAL_WARN( "starmath.ooxml", "Unknown m:chr in m:acc \'" << OUString(accChr) << "\'" );

            break;

    }

    OUString e = readOMathArgInElement( M_TOKEN( e ));

    m_rStream.ensureClosingTag( M_TOKEN( acc ));

    return acc + " {" + e + "}";

}

OUString SmOoxmlImport::handleBar()

{

    m_rStream.ensureOpeningTag( M_TOKEN( bar ));

    enum pos_t { top, bot } topbot = bot;

    if( m_rStream.checkOpeningTag( M_TOKEN( barPr )))

    {

        if( XmlStream::Tag pos = m_rStream.checkOpeningTag( M_TOKEN( pos )))

        {

            if( pos.attribute( M_TOKEN( val )) == "top" )

                topbot = top;

            else if( pos.attribute( M_TOKEN( val )) == "bot" )

                topbot = bot;

            m_rStream.ensureClosingTag( M_TOKEN( pos ));

        }

        m_rStream.ensureClosingTag( M_TOKEN( barPr ));

    }

    OUString e = readOMathArgInElement( M_TOKEN( e ));

    m_rStream.ensureClosingTag( M_TOKEN( bar ));

    if( topbot == top )

        return "overline {" + e + "}";

    else

        return "underline {" + e + "}";

}

OUString SmOoxmlImport::handleBox()

{

    // there does not seem to be functionality in LO to actually implement this

    // (or is there), but at least read in the contents instead of ignoring them

    m_rStream.ensureOpeningTag( M_TOKEN( box ));

    OUString e = readOMathArgInElement( M_TOKEN( e ));

    m_rStream.ensureClosingTag( M_TOKEN( box ));

    return e;

}

OUString SmOoxmlImport::handleBorderBox()

{

    m_rStream.ensureOpeningTag( M_TOKEN( borderBox ));

    bool isStrikeH = false;

    if( m_rStream.checkOpeningTag( M_TOKEN( borderBoxPr )))

    {

        if( XmlStream::Tag strikeH = m_rStream.checkOpeningTag( M_TOKEN( strikeH )))

        {

            if( strikeH.attribute( M_TOKEN( val ), false ))

                isStrikeH = true;

            m_rStream.ensureClosingTag( M_TOKEN( strikeH ));

        }

        m_rStream.ensureClosingTag( M_TOKEN( borderBoxPr ));

    }

    OUString e = readOMathArgInElement( M_TOKEN( e ));

    m_rStream.ensureClosingTag( M_TOKEN( borderBox ));

    if( isStrikeH )

        return "overstrike {" + e + "}";

    // LO does not seem to implement anything for handling the other cases

    return e;

}

OUString SmOoxmlImport::handleD()

{

    m_rStream.ensureOpeningTag( M_TOKEN( d ));

    OUString opening = u"("_ustr;

    OUString closing = u")"_ustr;

    OUString separator = u"|"_ustr;

    if( XmlStream::Tag dPr = m_rStream.checkOpeningTag( M_TOKEN( dPr )))

    {

        if( XmlStream::Tag begChr = m_rStream.checkOpeningTag( M_TOKEN( begChr )))

        {

            opening = begChr.attribute( M_TOKEN( val ), opening );

            m_rStream.ensureClosingTag( M_TOKEN( begChr ));

        }

        if( XmlStream::Tag sepChr = m_rStream.checkOpeningTag( M_TOKEN( sepChr )))

        {

            separator = sepChr.attribute( M_TOKEN( val ), separator );

            m_rStream.ensureClosingTag( M_TOKEN( sepChr ));

        }

        if( XmlStream::Tag endChr = m_rStream.checkOpeningTag( M_TOKEN( endChr )))

        {

            closing = endChr.attribute( M_TOKEN( val ), closing );

            m_rStream.ensureClosingTag( M_TOKEN( endChr ));

        }

        m_rStream.ensureClosingTag( M_TOKEN( dPr ));

    }

    if( opening == "{" )

        opening = "left lbrace ";

    if( closing == "}" )

        closing = " right rbrace";

    if( opening == u"\u27e6" )

        opening = "left ldbracket ";

    if( closing == u"\u27e7" )

        closing = " right rdbracket";

    if( opening == "|" )

        opening = "left lline ";

    if( closing == "|" )

        closing = " right rline";

    if (opening == OUStringChar(MS_DLINE)

        || opening == OUStringChar(MS_DVERTLINE))

        opening = "left ldline ";

    if (closing == OUStringChar(MS_DLINE)

        || closing == OUStringChar(MS_DVERTLINE))

        closing = " right rdline";

    if (opening == OUStringChar(MS_LANGLE)

        || opening == OUStringChar(MS_LMATHANGLE))

        opening = "left langle ";

    if (closing == OUStringChar(MS_RANGLE)

        || closing == OUStringChar(MS_RMATHANGLE))

        closing = " right rangle";

    // use scalable brackets (the explicit "left" or "right")

    if( opening == "(" || opening == "[" || opening == ")" || opening == "]" )

        opening = "left " + opening;

    if( closing == ")" || closing == "]" || closing == "(" || closing == "[")

        closing = " right " + closing;

    if( separator == "|" ) // plain "|" would be actually "V" (logical or)

        separator = " mline ";

    if( opening.isEmpty())

        opening = "left none ";

    if( closing.isEmpty())

        closing = " right none";

    OUStringBuffer ret( opening );

    bool first = true;

    while( m_rStream.findTag( OPENING( M_TOKEN( e ))))

    {

        if( !first )

            ret.append( separator );

        first = false;

        ret.append( readOMathArgInElement( M_TOKEN( e )));

    }

    ret.append( closing );

    m_rStream.ensureClosingTag( M_TOKEN( d ));

    return ret.makeStringAndClear();

}

OUString SmOoxmlImport::handleEqArr()

{

    m_rStream.ensureOpeningTag( M_TOKEN( eqArr ));

    OUStringBuffer ret;

    do

    { // there must be at least one m:e

        if( !ret.isEmpty())

            ret.append("#");

        ret.append(" "

            + readOMathArgInElement( M_TOKEN( e ))

            + " ");

    } while( !m_rStream.atEnd() && m_rStream.findTag( OPENING( M_TOKEN( e ))));

    m_rStream.ensureClosingTag( M_TOKEN( eqArr ));

    return "stack {" + ret + "}";

}

OUString SmOoxmlImport::handleF()

{

    m_rStream.ensureOpeningTag( M_TOKEN( f ));

    enum operation_t { bar, lin, noBar } operation = bar;

    if( m_rStream.checkOpeningTag( M_TOKEN( fPr )))

    {

        if( XmlStream::Tag type = m_rStream.checkOpeningTag( M_TOKEN( type )))

        {

            if( type.attribute( M_TOKEN( val )) == "bar" )

                operation = bar;

            else if( type.attribute( M_TOKEN( val )) == "lin" )

                operation = lin;

            else if( type.attribute( M_TOKEN( val )) == "noBar" )

                operation = noBar;

            m_rStream.ensureClosingTag( M_TOKEN( type ));

        }

        m_rStream.ensureClosingTag( M_TOKEN( fPr ));

    }

    OUString num = readOMathArgInElement( M_TOKEN( num ));

    OUString den = readOMathArgInElement( M_TOKEN( den ));

    m_rStream.ensureClosingTag( M_TOKEN( f ));

    if( operation == bar )

        return "{" + num + "} over {" + den + "}";

    else if( operation == lin )

        return "{" + num + "} / {" + den + "}";

    else // noBar

    {

        return "binom {" + num + "} {" + den + "}";

    }

}

OUString SmOoxmlImport::handleFunc()

{

//lim from{x rightarrow 1} x

    m_rStream.ensureOpeningTag( M_TOKEN( func ));

    OUString fname = readOMathArgInElement( M_TOKEN( fName ));

    // fix the various functions

    if( fname.startsWith( "lim csub {" ))

        fname = OUString::Concat("lim from {") + fname.subView( 10 );

    OUString ret = fname + " {" + readOMathArgInElement( M_TOKEN( e )) + "}";

    m_rStream.ensureClosingTag( M_TOKEN( func ));

    return ret;

}

OUString SmOoxmlImport::handleLimLowUpp( LimLowUpp_t limlowupp )

{

    int token = limlowupp == LimLow ? M_TOKEN( limLow ) : M_TOKEN( limUpp );

    m_rStream.ensureOpeningTag( token );

    OUString e = readOMathArgInElement( M_TOKEN( e ));

    OUString lim = readOMathArgInElement( M_TOKEN( lim ));

    m_rStream.ensureClosingTag( token );

    // fix up overbrace/underbrace  (use { }, as {} will be converted to a placeholder)

    if( limlowupp == LimUpp && e.endsWith( " overbrace { }" ))

        return e.subView( 0, e.getLength() - 2 ) + lim + "}";

    if( limlowupp == LimLow && e.endsWith( " underbrace { }" ))

        return e.subView( 0, e.getLength() - 2 ) + lim + "}";

    return e

        + ( limlowupp == LimLow

            ? std::u16string_view( u" csub {" ) : std::u16string_view( u" csup {" ))

        + lim + "}";

}

OUString SmOoxmlImport::handleGroupChr()

{

    m_rStream.ensureOpeningTag( M_TOKEN( groupChr ));

    sal_Unicode chr = 0x23df;

    enum pos_t { top, bot } pos = bot;

    if( m_rStream.checkOpeningTag( M_TOKEN( groupChrPr )))

    {

        if( XmlStream::Tag chrTag = m_rStream.checkOpeningTag( M_TOKEN( chr )))

        {

            chr = chrTag.attribute( M_TOKEN( val ), chr );

            m_rStream.ensureClosingTag( M_TOKEN( chr ));

        }

        if( XmlStream::Tag posTag = m_rStream.checkOpeningTag( M_TOKEN( pos )))

        {

            if( posTag.attribute( M_TOKEN( val ), u"bot"_ustr) == "top" )

                pos = top;

            m_rStream.ensureClosingTag( M_TOKEN( pos ));

        }

        m_rStream.ensureClosingTag( M_TOKEN( groupChrPr ));

    }

    OUString e = readOMathArgInElement( M_TOKEN( e ));

    m_rStream.ensureClosingTag( M_TOKEN( groupChr ));

    if( pos == top && chr == u'\x23de')

        return "{" + e + "} overbrace { }";

    if( pos == bot && chr == u'\x23df')

        return "{" + e + "} underbrace { }";

    if( pos == top )

        return "{" + e + "} csup {" + OUStringChar( chr ) + "}";

    else

        return "{" + e + "} csub {" + OUStringChar( chr ) + "}";

}

OUString SmOoxmlImport::handleM()

{

    m_rStream.ensureOpeningTag( M_TOKEN( m ));

    OUStringBuffer allrows;

    do // there must be at least one m:mr

    {

        m_rStream.ensureOpeningTag( M_TOKEN( mr ));

        OUStringBuffer row;

        do // there must be at least one m:e

        {

            if( !row.isEmpty())

                row.append(" # ");

            row.append(readOMathArgInElement( M_TOKEN( e )));

        } while( !m_rStream.atEnd() && m_rStream.findTag( OPENING( M_TOKEN( e ))));

        if( !allrows.isEmpty())

            allrows.append(" ## ");

        allrows.append(row);

        m_rStream.ensureClosingTag( M_TOKEN( mr ));

    } while( !m_rStream.atEnd() && m_rStream.findTag( OPENING( M_TOKEN( mr ))));

    m_rStream.ensureClosingTag( M_TOKEN( m ));

    return "matrix {" + allrows + "}";

}

OUString SmOoxmlImport::handleNary()

{

    m_rStream.ensureOpeningTag( M_TOKEN( nary ));

    sal_Unicode chr = 0x222b;

    bool subHide = false;

    bool supHide = false;

    if( m_rStream.checkOpeningTag( M_TOKEN( naryPr )))

    {

        if( XmlStream::Tag chrTag = m_rStream.checkOpeningTag( M_TOKEN( chr )))

        {

            chr = chrTag.attribute( M_TOKEN( val ), chr );

            m_rStream.ensureClosingTag( M_TOKEN( chr ));

        }

        if( XmlStream::Tag subHideTag = m_rStream.checkOpeningTag( M_TOKEN( subHide )))

        {

            subHide = subHideTag.attribute( M_TOKEN( val ), subHide );

            m_rStream.ensureClosingTag( M_TOKEN( subHide ));

        }

        if( XmlStream::Tag supHideTag = m_rStream.checkOpeningTag( M_TOKEN( supHide )))

        {

            supHide = supHideTag.attribute( M_TOKEN( val ), supHide );

            m_rStream.ensureClosingTag( M_TOKEN( supHide ));

        }

        m_rStream.ensureClosingTag( M_TOKEN( naryPr ));

    }

    OUString sub = readOMathArgInElement( M_TOKEN( sub ));

    OUString sup = readOMathArgInElement( M_TOKEN( sup ));

    OUString e = readOMathArgInElement( M_TOKEN( e ));

    OUString ret;

    switch( chr )

    {

        case MS_INT:

            ret = "int";

            break;

        case MS_IINT:

            ret = "iint";

            break;

        case MS_IIINT:

            ret = "iiint";

            break;

        case MS_LINT:

            ret = "lint";

            break;

        case MS_LLINT:

            ret = "llint";

            break;

        case MS_LLLINT:

            ret = "lllint";

            break;

        case MS_PROD:

            ret = "prod";

            break;

        case MS_COPROD:

            ret = "coprod";

            break;

        case MS_SUM:

            ret = "sum";

            break;

        default:

            SAL_WARN( "starmath.ooxml", "Unknown m:nary chr \'" << OUString(chr) << "\'" );

            break;

    }

    if( !subHide )

        ret += " from {" + sub + "}";

    if( !supHide )

        ret += " to {" + sup + "}";

    ret += " {" + e + "}";

    m_rStream.ensureClosingTag( M_TOKEN( nary ));

    return ret;

}

// NOT complete

OUString SmOoxmlImport::handleR()

{

    m_rStream.ensureOpeningTag( M_TOKEN( r ));

    bool normal = false;

    bool literal = false;

    OUString scrString;

    if( XmlStream::Tag rPr = m_rStream.checkOpeningTag( M_TOKEN( rPr )))

    {

        if( XmlStream::Tag litTag = m_rStream.checkOpeningTag( M_TOKEN( lit )))

        {

            literal = litTag.attribute( M_TOKEN( val ), true );

            m_rStream.ensureClosingTag( M_TOKEN( lit ));

        }

        if( XmlStream::Tag norTag = m_rStream.checkOpeningTag( M_TOKEN( nor )))

        {

            normal = norTag.attribute( M_TOKEN( val ), true );

            m_rStream.ensureClosingTag( M_TOKEN( nor ));

        }

        if (XmlStream::Tag srcTag = m_rStream.checkOpeningTag( M_TOKEN( scr )))

        {

            scrString = srcTag.attribute( M_TOKEN( val ), scrString );

            m_rStream.ensureClosingTag( M_TOKEN( scr ));

        }

        m_rStream.ensureClosingTag( M_TOKEN( rPr ));

    }

    OUStringBuffer text;

    bool isTagT = false;

    while( !m_rStream.atEnd() && m_rStream.currentToken() != CLOSING( m_rStream.currentToken()))

    {

        switch( m_rStream.currentToken())

        {

            case OPENING( M_TOKEN( t )):

            {

                isTagT = true;

                XmlStream::Tag rtag = m_rStream.ensureOpeningTag( M_TOKEN( t ));

                OUString sTagText = rtag.text;

                if (scrString == "double-struck")

                {

                    sTagText = SmOoxmlImport::handleSetString(sTagText);

                }

                if( rtag.attribute( OOX_TOKEN( xml, space )) != "preserve" )

                    sTagText = o3tl::trim(sTagText);

                text.append(sTagText);

                m_rStream.ensureClosingTag( M_TOKEN( t ));

                break;

            }

            default:

                m_rStream.handleUnexpectedTag();

                break;

        }

    }

    m_rStream.ensureClosingTag( M_TOKEN( r ));

    if (scrString.isEmpty() && (normal || literal || isTagT))

    {

        return encloseOrEscapeLiteral(text.makeStringAndClear(), normal || literal);

    }

    return text.makeStringAndClear();

}

OUString SmOoxmlImport::handleSetString(const OUString& setOUstring)

{

    std::unordered_set<sal_Unicode> setList= {'C', 'N', 'Q', 'R', 'Z', 'c', 'n', 'q', 'r', 'z'};

    OUString result;

    for (sal_Int32 i = 0; i < setOUstring.getLength(); i++)

    {

        if (setList.contains(setOUstring[i]))

        {

            result += OUString::Concat(" set" ) + OUStringChar(setOUstring[i]) + OUString::Concat(" ");

        }

        else

            result += encloseOrEscapeLiteral(setOUstring.copy(i, 1), /*bForce=*/false);

    }

    return result;

}

OUString SmOoxmlImport::handleRad()

{

    m_rStream.ensureOpeningTag( M_TOKEN( rad ));

    bool degHide = false;

    if( m_rStream.checkOpeningTag( M_TOKEN( radPr )))

    {

        if( XmlStream::Tag degHideTag = m_rStream.checkOpeningTag( M_TOKEN( degHide )))

        {

            degHide = degHideTag.attribute( M_TOKEN( val ), degHide );

            m_rStream.ensureClosingTag( M_TOKEN( degHide ));

        }

        m_rStream.ensureClosingTag( M_TOKEN( radPr ));

    }

    OUString deg = readOMathArgInElement( M_TOKEN( deg ));

    OUString e = readOMathArgInElement( M_TOKEN( e ));

    m_rStream.ensureClosingTag( M_TOKEN( rad ));

    if( degHide )

        return "sqrt {" + e + "}";

    else

        return "nroot {" + deg + "} {" + e + "}";

}

OUString SmOoxmlImport::handleSpre()

{

    m_rStream.ensureOpeningTag( M_TOKEN( sPre ));

    OUString sub = readOMathArgInElement( M_TOKEN( sub ));

    OUString sup = readOMathArgInElement( M_TOKEN( sup ));

    OUString e = readOMathArgInElement( M_TOKEN( e ));

    m_rStream.ensureClosingTag( M_TOKEN( sPre ));

    return "{" + e + "} lsub {" + sub + "} lsup {" + sup + "}";

}

OUString SmOoxmlImport::handleSsub()

{

    m_rStream.ensureOpeningTag( M_TOKEN( sSub ));

    OUString e = readOMathArgInElement( M_TOKEN( e ));

    OUString sub = readOMathArgInElement( M_TOKEN( sub ));

    m_rStream.ensureClosingTag( M_TOKEN( sSub ));

    return "{" + e + "} rsub {" + sub + "}";

}

OUString SmOoxmlImport::handleSsubsup()

{

    m_rStream.ensureOpeningTag( M_TOKEN( sSubSup ));

    OUString e = readOMathArgInElement( M_TOKEN( e ));

    OUString sub = readOMathArgInElement( M_TOKEN( sub ));

    OUString sup = readOMathArgInElement( M_TOKEN( sup ));

    m_rStream.ensureClosingTag( M_TOKEN( sSubSup ));

    return "{" + e + "} rsub {" + sub + "} rsup {" + sup + "}";

}

OUString SmOoxmlImport::handleSsup()

{

    m_rStream.ensureOpeningTag( M_TOKEN( sSup ));

    OUString e = readOMathArgInElement( M_TOKEN( e ));

    OUString sup = readOMathArgInElement( M_TOKEN( sup ));

    m_rStream.ensureClosingTag( M_TOKEN( sSup ));

    if (sup == "'")

        return "{" + e + "} {" + sup + "}";

    return "{" + e + "} ^ {" + sup + "}";

}

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */