/* -*- 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 .

 */

/*todo: Change characters and tcharacters to accumulate the characters together

into one string, xml parser hands them to us line by line rather than all in

one go*/

#include <com/sun/star/xml/sax/InputSource.hpp>

#include <com/sun/star/xml/sax/FastParser.hpp>

#include <com/sun/star/xml/sax/Parser.hpp>

#include <com/sun/star/xml/sax/SAXParseException.hpp>

#include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>

#include <com/sun/star/packages/WrongPasswordException.hpp>

#include <com/sun/star/packages/zip/ZipIOException.hpp>

#include <com/sun/star/beans/PropertyAttribute.hpp>

#include <com/sun/star/embed/ElementModes.hpp>

#include <com/sun/star/uno/Any.h>

#include <com/sun/star/task/XStatusIndicator.hpp>

#include <comphelper/fileformat.h>

#include <comphelper/genericpropertyset.hxx>

#include <comphelper/processfactory.hxx>

#include <comphelper/servicehelper.hxx>

#include <comphelper/propertysetinfo.hxx>

#include <rtl/character.hxx>

#include <sal/log.hxx>

#include <sfx2/frame.hxx>

#include <sfx2/docfile.hxx>

#include <sfx2/sfxsids.hrc>

#include <sfx2/sfxmodelfactory.hxx>

#include <osl/diagnose.h>

#include <sot/storage.hxx>

#include <svtools/sfxecode.hxx>

#include <svl/itemset.hxx>

#include <svl/stritem.hxx>

#include <unotools/streamwrap.hxx>

#include <sax/tools/converter.hxx>

#include <xmloff/DocumentSettingsContext.hxx>

#include <xmloff/xmlnamespace.hxx>

#include <xmloff/xmltoken.hxx>

#include <xmloff/xmluconv.hxx>

#include <xmloff/xmlmetai.hxx>

#include <svx/dialmgr.hxx>

#include <svx/strings.hrc>

#include <comphelper/diagnose_ex.hxx>

#include <o3tl/string_view.hxx>

#include <mathmlattr.hxx>

#include <xparsmlbase.hxx>

#include <mathmlimport.hxx>

#include <document.hxx>

#include <smdll.hxx>

#include <unomodel.hxx>

#include <utility.hxx>

#include <visitors.hxx>

#include <starmathdatabase.hxx>

#include <smmod.hxx>

#include <cfgitem.hxx>

using namespace ::com::sun::star::beans;

using namespace ::com::sun::star::document;

using namespace ::com::sun::star::lang;

using namespace ::com::sun::star::uno;

using namespace ::com::sun::star;

using namespace ::xmloff::token;

namespace

{

std::unique_ptr<SmNode> popOrZero(SmNodeStack& rStack)

{

    if (rStack.empty())

        return nullptr;

    auto pTmp = std::move(rStack.front());

    rStack.pop_front();

    return pTmp;

}

}

ErrCode SmXMLImportWrapper::Import(SfxMedium& rMedium)

{

    ErrCode nError = ERRCODE_SFX_DOLOADFAILED;

    const uno::Reference<uno::XComponentContext>& xContext(

        comphelper::getProcessComponentContext());

    OSL_ENSURE(m_xModel.is(), "XMLReader::Read: got no model");

    // try to get an XStatusIndicator from the Medium

    uno::Reference<task::XStatusIndicator> xStatusIndicator;

    bool bEmbedded = false;

    SmModel* pModel = m_xModel.get();

    SmDocShell* pDocShell = pModel ? static_cast<SmDocShell*>(pModel->GetObjectShell()) : nullptr;

    if (pDocShell)

    {

        OSL_ENSURE(pDocShell->GetMedium() == &rMedium, "different SfxMedium found");

        const SfxUnoAnyItem* pItem = rMedium.GetItemSet().GetItem(SID_PROGRESS_STATUSBAR_CONTROL);

        if (pItem)

            pItem->GetValue() >>= xStatusIndicator;

        if (SfxObjectCreateMode::EMBEDDED == pDocShell->GetCreateMode())

            bEmbedded = true;

    }

    static const comphelper::PropertyMapEntry aInfoMap[]

        = { { u"PrivateData"_ustr, 0, cppu::UnoType<XInterface>::get(),

              beans::PropertyAttribute::MAYBEVOID, 0 },

            { u"BaseURI"_ustr, 0, ::cppu::UnoType<OUString>::get(),

              beans::PropertyAttribute::MAYBEVOID, 0 },

            { u"StreamRelPath"_ustr, 0, ::cppu::UnoType<OUString>::get(),

              beans::PropertyAttribute::MAYBEVOID, 0 },

            { u"StreamName"_ustr, 0, ::cppu::UnoType<OUString>::get(),

              beans::PropertyAttribute::MAYBEVOID, 0 } };

    uno::Reference<beans::XPropertySet> xInfoSet(

        comphelper::GenericPropertySet_CreateInstance(new comphelper::PropertySetInfo(aInfoMap)));

    // Set base URI

    OUString const baseURI(rMedium.GetBaseURL());

    // needed for relative URLs; but it's OK to import e.g. MathML from the

    // clipboard without one

    SAL_INFO_IF(baseURI.isEmpty(), "starmath", "SmXMLImportWrapper: no base URL");

    xInfoSet->setPropertyValue(u"BaseURI"_ustr, Any(baseURI));

    sal_Int32 nSteps = 3;

    if (!(rMedium.IsStorage()))

        nSteps = 1;

    sal_Int32 nProgressRange(nSteps);

    if (xStatusIndicator.is())

    {

        xStatusIndicator->start(SvxResId(RID_SVXSTR_DOC_LOAD), nProgressRange);

    }

    nSteps = 0;

    if (xStatusIndicator.is())

        xStatusIndicator->setValue(nSteps++);

    if (rMedium.IsStorage())

    {

        // TODO/LATER: handle the case of embedded links gracefully

        if (bEmbedded) // && !rMedium.GetStorage()->IsRoot() )

        {

            OUString aName(u"dummyObjName"_ustr);

            const SfxStringItem* pDocHierarchItem

                = rMedium.GetItemSet().GetItem(SID_DOC_HIERARCHICALNAME);

            if (pDocHierarchItem)

                aName = pDocHierarchItem->GetValue();

            if (!aName.isEmpty())

            {

                xInfoSet->setPropertyValue(u"StreamRelPath"_ustr, Any(aName));

            }

        }

        bool bOASIS = (SotStorage::GetVersion(rMedium.GetStorage()) > SOFFICE_FILEFORMAT_60);

        if (xStatusIndicator.is())

            xStatusIndicator->setValue(nSteps++);

        auto nWarn

            = ReadThroughComponent(rMedium.GetStorage(), m_xModel, "meta.xml", xContext, xInfoSet,

                                   (bOASIS ? "com.sun.star.comp.Math.XMLOasisMetaImporter"

                                           : "com.sun.star.comp.Math.XMLMetaImporter"),

                                   m_bUseHTMLMLEntities);

        if (nWarn != ERRCODE_IO_BROKENPACKAGE)

        {

            if (xStatusIndicator.is())

                xStatusIndicator->setValue(nSteps++);

            nWarn = ReadThroughComponent(rMedium.GetStorage(), m_xModel, "settings.xml", xContext,

                                         xInfoSet,

                                         (bOASIS ? "com.sun.star.comp.Math.XMLOasisSettingsImporter"

                                                 : "com.sun.star.comp.Math.XMLSettingsImporter"),

                                         m_bUseHTMLMLEntities);

            if (nWarn != ERRCODE_IO_BROKENPACKAGE)

            {

                if (xStatusIndicator.is())

                    xStatusIndicator->setValue(nSteps++);

                nError = ReadThroughComponent(

                    rMedium.GetStorage(), m_xModel, "content.xml", xContext, xInfoSet,

                    "com.sun.star.comp.Math.XMLImporter", m_bUseHTMLMLEntities);

            }

            else

                nError = ERRCODE_IO_BROKENPACKAGE;

        }

        else

            nError = ERRCODE_IO_BROKENPACKAGE;

    }

    else

    {

        Reference<io::XInputStream> xInputStream

            = new utl::OInputStreamWrapper(rMedium.GetInStream());

        if (xStatusIndicator.is())

            xStatusIndicator->setValue(nSteps++);

        nError = ReadThroughComponent(xInputStream, m_xModel, xContext, xInfoSet,

                                      "com.sun.star.comp.Math.XMLImporter", false,

                                      m_bUseHTMLMLEntities);

    }

    if (xStatusIndicator.is())

        xStatusIndicator->end();

    return nError;

}

/// read a component (file + filter version)

ErrCode SmXMLImportWrapper::ReadThroughComponent(const Reference<io::XInputStream>& xInputStream,

                                                 const Reference<XComponent>& xModelComponent,

                                                 Reference<uno::XComponentContext> const& rxContext,

                                                 Reference<beans::XPropertySet> const& rPropSet,

                                                 const char* pFilterName, bool bEncrypted,

                                                 bool bUseHTMLMLEntities)

{

    ErrCode nError = ERRCODE_SFX_DOLOADFAILED;

    OSL_ENSURE(xInputStream.is(), "input stream missing");

    OSL_ENSURE(xModelComponent.is(), "document missing");

    OSL_ENSURE(rxContext.is(), "factory missing");

    OSL_ENSURE(nullptr != pFilterName, "I need a service name for the component!");

    // prepare ParserInputSource

    xml::sax::InputSource aParserInput;

    aParserInput.aInputStream = xInputStream;

    Sequence<Any> aArgs{ Any(rPropSet) };

    // get filter

    Reference<XInterface> xFilter

        = rxContext->getServiceManager()->createInstanceWithArgumentsAndContext(

            OUString::createFromAscii(pFilterName), aArgs, rxContext);

    SAL_WARN_IF(!xFilter, "starmath", "Can't instantiate filter component " << pFilterName);

    if (!xFilter.is())

        return nError;

    // connect model and filter

    Reference<XImporter> xImporter(xFilter, UNO_QUERY);

    xImporter->setTargetDocument(xModelComponent);

    // finally, parser the stream

    try

    {

        Reference<css::xml::sax::XFastParser> xFastParser(xFilter, UNO_QUERY);

        Reference<css::xml::sax::XFastDocumentHandler> xFastDocHandler(xFilter, UNO_QUERY);

        if (xFastParser)

        {

            if (bUseHTMLMLEntities)

                xFastParser->setCustomEntityNames(starmathdatabase::icustomMathmlHtmlEntities);

            xFastParser->parseStream(aParserInput);

        }

        else if (xFastDocHandler)

        {

            Reference<css::xml::sax::XFastParser> xParser

                = css::xml::sax::FastParser::create(rxContext);

            if (bUseHTMLMLEntities)

                xParser->setCustomEntityNames(starmathdatabase::icustomMathmlHtmlEntities);

            xParser->setFastDocumentHandler(xFastDocHandler);

            xParser->parseStream(aParserInput);

        }

        else

        {

            Reference<css::xml::sax::XDocumentHandler> xDocHandler(xFilter, UNO_QUERY);

            assert(xDocHandler);

            Reference<css::xml::sax::XParser> xParser = css::xml::sax::Parser::create(rxContext);

            xParser->setDocumentHandler(xDocHandler);

            xParser->parseStream(aParserInput);

        }

        auto pFilter = dynamic_cast<SmXMLImport*>(xFilter.get());

        if (pFilter && pFilter->GetSuccess())

            nError = ERRCODE_NONE;

    }

    catch (const xml::sax::SAXParseException& r)

    {

        // sax parser sends wrapped exceptions,

        // try to find the original one

        xml::sax::SAXException aSaxEx = *static_cast<const xml::sax::SAXException*>(&r);

        bool bTryChild = true;

        while (bTryChild)

        {

            xml::sax::SAXException aTmp;

            if (aSaxEx.WrappedException >>= aTmp)

                aSaxEx = std::move(aTmp);

            else

                bTryChild = false;

        }

        packages::zip::ZipIOException aBrokenPackage;

        if (aSaxEx.WrappedException >>= aBrokenPackage)

            return ERRCODE_IO_BROKENPACKAGE;

        if (bEncrypted)

            nError = ERRCODE_SFX_WRONGPASSWORD;

    }

    catch (const xml::sax::SAXException& r)

    {

        packages::zip::ZipIOException aBrokenPackage;

        if (r.WrappedException >>= aBrokenPackage)

            return ERRCODE_IO_BROKENPACKAGE;

        if (bEncrypted)

            nError = ERRCODE_SFX_WRONGPASSWORD;

    }

    catch (const packages::zip::ZipIOException&)

    {

        nError = ERRCODE_IO_BROKENPACKAGE;

    }

    catch (const io::IOException&)

    {

    }

    catch (const std::range_error&)

    {

    }

    return nError;

}

ErrCode SmXMLImportWrapper::ReadThroughComponent(const uno::Reference<embed::XStorage>& xStorage,

                                                 const Reference<XComponent>& xModelComponent,

                                                 const char* pStreamName,

                                                 Reference<uno::XComponentContext> const& rxContext,

                                                 Reference<beans::XPropertySet> const& rPropSet,

                                                 const char* pFilterName, bool bUseHTMLMLEntities)

{

    OSL_ENSURE(xStorage.is(), "Need storage!");

    OSL_ENSURE(nullptr != pStreamName, "Please, please, give me a name!");

    // open stream (and set parser input)

    OUString sStreamName = OUString::createFromAscii(pStreamName);

    // get input stream

    try

    {

        uno::Reference<io::XStream> xEventsStream

            = xStorage->openStreamElement(sStreamName, embed::ElementModes::READ);

        // determine if stream is encrypted or not

        uno::Reference<beans::XPropertySet> xProps(xEventsStream, uno::UNO_QUERY);

        Any aAny = xProps->getPropertyValue(u"Encrypted"_ustr);

        bool bEncrypted = false;

        if (aAny.getValueType() == cppu::UnoType<bool>::get())

            aAny >>= bEncrypted;

        // set Base URL

        if (rPropSet.is())

        {

            rPropSet->setPropertyValue(u"StreamName"_ustr, Any(sStreamName));

        }

        Reference<io::XInputStream> xStream = xEventsStream->getInputStream();

        return ReadThroughComponent(xStream, xModelComponent, rxContext, rPropSet, pFilterName,

                                    bEncrypted, bUseHTMLMLEntities);

    }

    catch (packages::WrongPasswordException&)

    {

        return ERRCODE_SFX_WRONGPASSWORD;

    }

    catch (packages::zip::ZipIOException&)

    {

        return ERRCODE_IO_BROKENPACKAGE;

    }

    catch (uno::Exception&)

    {

    }

    return ERRCODE_SFX_DOLOADFAILED;

}

SmXMLImport::SmXMLImport(const css::uno::Reference<css::uno::XComponentContext>& rContext,

                         OUString const& implementationName, SvXMLImportFlags nImportFlags)

    : SvXMLImport(rContext, implementationName, nImportFlags)

    , bSuccess(false)

    , nParseDepth(0)

    , mnSmSyntaxVersion(SmModule::get()->GetConfig()->GetDefaultSmSyntaxVersion())

{

}

extern "C" SAL_DLLPUBLIC_EXPORT uno::XInterface*

Math_XMLImporter_get_implementation(uno::XComponentContext* pCtx,

                                    uno::Sequence<uno::Any> const& /*rSeq*/)

{

    return cppu::acquire(

        new SmXMLImport(pCtx, u"com.sun.star.comp.Math.XMLImporter"_ustr, SvXMLImportFlags::ALL));

}

extern "C" SAL_DLLPUBLIC_EXPORT uno::XInterface*

Math_XMLOasisMetaImporter_get_implementation(uno::XComponentContext* pCtx,

                                             uno::Sequence<uno::Any> const& /*rSeq*/)

{

    return cppu::acquire(new SmXMLImport(pCtx, u"com.sun.star.comp.Math.XMLOasisMetaImporter"_ustr,

                                         SvXMLImportFlags::META));

}

extern "C" SAL_DLLPUBLIC_EXPORT uno::XInterface*

Math_XMLOasisSettingsImporter_get_implementation(uno::XComponentContext* pCtx,

                                                 uno::Sequence<uno::Any> const& /*rSeq*/)

{

    return cppu::acquire(new SmXMLImport(

        pCtx, u"com.sun.star.comp.Math.XMLOasisSettingsImporter"_ustr, SvXMLImportFlags::SETTINGS));

}

void SmXMLImport::endDocument()

{

    //Set the resulted tree into the SmDocShell where it belongs

    std::unique_ptr<SmNode> pTree = popOrZero(aNodeStack);

    if (pTree && pTree->GetType() == SmNodeType::Table)

    {

        uno::Reference<frame::XModel> xModel = GetModel();

        SmModel* pModel = dynamic_cast<SmModel*>(xModel.get());

        if (pModel)

        {

            SmDocShell* pDocShell = static_cast<SmDocShell*>(pModel->GetObjectShell());

            auto pTreeTmp = pTree.get();

            pDocShell->SetFormulaTree(static_cast<SmTableNode*>(pTree.release()));

            if (aText.isEmpty()) //If we picked up no annotation text

            {

                // Get text from imported formula

                SmNodeToTextVisitor tmpvisitor(pTreeTmp, aText);

            }

            // Convert symbol names

            AbstractSmParser* rParser = pDocShell->GetParser();

            bool bVal = rParser->IsImportSymbolNames();

            rParser->SetImportSymbolNames(true);

            auto pTmpTree = rParser->Parse(aText);

            aText = rParser->GetText();

            pTmpTree.reset();

            rParser->SetImportSymbolNames(bVal);

            pDocShell->SetText(aText);

            pDocShell->SetSmSyntaxVersion(mnSmSyntaxVersion);

        }

        OSL_ENSURE(pModel, "So there *was* a UNO problem after all");

        bSuccess = true;

    }

    SvXMLImport::endDocument();

}

namespace

{

class SmXMLImportContext : public SvXMLImportContext

{

public:

    SmXMLImportContext(SmXMLImport& rImport)

        : SvXMLImportContext(rImport)

    {

        GetSmImport().IncParseDepth();

    }

    virtual ~SmXMLImportContext() override { GetSmImport().DecParseDepth(); }

    SmXMLImport& GetSmImport() { return static_cast<SmXMLImport&>(GetImport()); }

    virtual void TCharacters(const OUString& /*rChars*/);

    virtual void SAL_CALL characters(const OUString& rChars) override;

    virtual void SAL_CALL startFastElement(

        sal_Int32 /*nElement*/,

        const css::uno::Reference<css::xml::sax::XFastAttributeList>& /*rAttrList*/) override

    {

        if (GetSmImport().TooDeep())

            throw std::range_error("too deep");

    }

};

}

void SmXMLImportContext::TCharacters(const OUString& /*rChars*/) {}

void SmXMLImportContext::characters(const OUString& rChars)

{

    /*

    Whitespace occurring within the content of token elements is "trimmed"

    from the ends (i.e. all whitespace at the beginning and end of the

    content is removed), and "collapsed" internally (i.e. each sequence of

    1 or more whitespace characters is replaced with one blank character).

    */

    //collapsing not done yet!

    const OUString aChars2 = rChars.trim();

    if (!aChars2.isEmpty())

        TCharacters(aChars2 /*.collapse()*/);

}

namespace

{

struct SmXMLContext_Helper

{

    sal_Int8 nIsBold;

    sal_Int8 nIsItalic;

    double nFontSize;

    OUString sFontFamily;

    OUString sColor;

    SmXMLImportContext& rContext;

    explicit SmXMLContext_Helper(SmXMLImportContext& rImport)

        : nIsBold(-1)

        , nIsItalic(-1)

        , nFontSize(0.0)

        , rContext(rImport)

    {

    }

    bool IsFontNodeNeeded() const;

    void RetrieveAttrs(const uno::Reference<xml::sax::XFastAttributeList>& xAttrList);

    void ApplyAttrs();

};

}

bool SmXMLContext_Helper::IsFontNodeNeeded() const

{

    return nIsBold != -1 || nIsItalic != -1 || nFontSize != 0.0 || !sFontFamily.isEmpty()

           || !sColor.isEmpty();

}

void SmXMLContext_Helper::RetrieveAttrs(

    const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)

{

    bool bMvFound = false;

    for (auto& aIter : sax_fastparser::castToFastAttributeList(xAttrList))

    {

        // sometimes they have namespace, sometimes not?

        switch (aIter.getToken() & TOKEN_MASK)

        {

            case XML_FONTWEIGHT:

                nIsBold = sal_Int8(IsXMLToken(aIter, XML_BOLD));

                break;

            case XML_FONTSTYLE:

                nIsItalic = sal_Int8(IsXMLToken(aIter, XML_ITALIC));

                break;

            case XML_FONTSIZE:

            case XML_MATHSIZE:

            {

                OUString sValue = aIter.toString();

                ::sax::Converter::convertDouble(nFontSize, sValue);

                rContext.GetSmImport().GetMM100UnitConverter().SetXMLMeasureUnit(

                    util::MeasureUnit::POINT);

                if (-1 == sValue.indexOf(GetXMLToken(XML_UNIT_PT)))

                {

                    if (-1 == sValue.indexOf('%'))

                        nFontSize = 0.0;

                    else

                    {

                        rContext.GetSmImport().GetMM100UnitConverter().SetXMLMeasureUnit(

                            util::MeasureUnit::PERCENT);

                    }

                }

                break;

            }

            case XML_FONTFAMILY:

                sFontFamily = aIter.toString();

                break;

            case XML_COLOR:

            case XML_MATHCOLOR:

                sColor = aIter.toString();

                break;

            case XML_MATHVARIANT:

                bMvFound = true;

                break;

            default:

                XMLOFF_WARN_UNKNOWN("starmath", aIter);

                break;

        }

    }

    if (bMvFound)

    {

        // Ignore deprecated attributes fontfamily, fontweight, and fontstyle

        // in favor of mathvariant, as specified in

        // <https://www.w3.org/TR/MathML3/chapter3.html#presm.deprecatt>.

        sFontFamily.clear();

        nIsBold = -1;

        nIsItalic = -1;

    }

}

void SmXMLContext_Helper::ApplyAttrs()

{

    SmNodeStack& rNodeStack = rContext.GetSmImport().GetNodeStack();

    if (!IsFontNodeNeeded())

        return;

    SmToken aToken;

    aToken.cMathChar = u""_ustr;

    aToken.nLevel = 5;

    if (nIsBold != -1)

    {

        if (nIsBold)

            aToken.eType = TBOLD;

        else

            aToken.eType = TNBOLD;

        std::unique_ptr<SmFontNode> pFontNode(new SmFontNode(aToken));

        pFontNode->SetSubNodes(nullptr, popOrZero(rNodeStack));

        rNodeStack.push_front(std::move(pFontNode));

    }

    if (nIsItalic != -1)

    {

        if (nIsItalic)

            aToken.eType = TITALIC;

        else

            aToken.eType = TNITALIC;

        std::unique_ptr<SmFontNode> pFontNode(new SmFontNode(aToken));

        pFontNode->SetSubNodes(nullptr, popOrZero(rNodeStack));

        rNodeStack.push_front(std::move(pFontNode));

    }

    if (nFontSize != 0.0)

    {

        aToken.eType = TSIZE;

        std::unique_ptr<SmFontNode> pFontNode(new SmFontNode(aToken));

        if (util::MeasureUnit::PERCENT

            == rContext.GetSmImport().GetMM100UnitConverter().GetXMLMeasureUnit())

        {

            if (nFontSize < 100.00)

                pFontNode->SetSizeParameter(100.00 / nFontSize, FontSizeType::DIVIDE);

            else

                pFontNode->SetSizeParameter(nFontSize / 100.00, FontSizeType::MULTIPLY);

        }

        else

            pFontNode->SetSizeParameter(nFontSize, FontSizeType::ABSOLUT);

        pFontNode->SetSubNodes(nullptr, popOrZero(rNodeStack));

        rNodeStack.push_front(std::move(pFontNode));

    }

    if (!sColor.isEmpty())

    {

        SmColorTokenTableEntry aSmColorTokenTableEntry;

        aSmColorTokenTableEntry = starmathdatabase::Identify_ColorName_HTML(sColor);

        if (aSmColorTokenTableEntry.eType == TRGB)

            aSmColorTokenTableEntry = starmathdatabase::Identify_Color_Parser(

                sal_uInt32(aSmColorTokenTableEntry.cColor));

        if (aSmColorTokenTableEntry.eType != TERROR)

        {

            aToken = aSmColorTokenTableEntry;

            std::unique_ptr<SmFontNode> pFontNode(new SmFontNode(aToken));

            pFontNode->SetSubNodes(nullptr, popOrZero(rNodeStack));

            rNodeStack.push_front(std::move(pFontNode));

        }

        // If not known, not implemented yet. Giving up.

    }

    if (sFontFamily.isEmpty())

        return;

    if (sFontFamily.equalsIgnoreAsciiCase(GetXMLToken(XML_FIXED)))

        aToken.eType = TFIXED;

    else if (sFontFamily.equalsIgnoreAsciiCase("sans"))

        aToken.eType = TSANS;

    else if (sFontFamily.equalsIgnoreAsciiCase("serif"))

        aToken.eType = TSERIF;

    else //Just give up, we need to extend our font mechanism to be

        //more general

        return;

    aToken.aText = sFontFamily;

    std::unique_ptr<SmFontNode> pFontNode(new SmFontNode(aToken));

    pFontNode->SetSubNodes(nullptr, popOrZero(rNodeStack));

    rNodeStack.push_front(std::move(pFontNode));

}

namespace

{

class SmXMLTokenAttrHelper

{

    SmXMLImportContext& mrContext;

    MathMLMathvariantValue meMv;

    bool mbMvFound;

public:

    SmXMLTokenAttrHelper(SmXMLImportContext& rContext)

        : mrContext(rContext)

        , meMv(MathMLMathvariantValue::Normal)

        , mbMvFound(false)

    {

    }

    void RetrieveAttrs(const uno::Reference<xml::sax::XFastAttributeList>& xAttrList);

    void ApplyAttrs(MathMLMathvariantValue eDefaultMv);

};

}

void SmXMLTokenAttrHelper::RetrieveAttrs(

    const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)

{

    for (auto& aIter : sax_fastparser::castToFastAttributeList(xAttrList))

    {

        OUString sValue = aIter.toString();

        switch (aIter.getToken())

        {

            case XML_MATHVARIANT:

                if (!GetMathMLMathvariantValue(sValue, meMv))

                    SAL_WARN("starmath", "failed to recognize mathvariant: " << sValue);

                mbMvFound = true;

                break;

            default:

                XMLOFF_WARN_UNKNOWN("starmath", aIter);

                break;

        }

    }

}

void SmXMLTokenAttrHelper::ApplyAttrs(MathMLMathvariantValue eDefaultMv)

{

    assert(eDefaultMv == MathMLMathvariantValue::Normal

           || eDefaultMv == MathMLMathvariantValue::Italic);

    std::vector<SmTokenType> vVariant;

    MathMLMathvariantValue eMv = mbMvFound ? meMv : eDefaultMv;

    switch (eMv)

    {

        case MathMLMathvariantValue::Normal:

            vVariant.push_back(TNITALIC);

            break;

        case MathMLMathvariantValue::Bold:

        case MathMLMathvariantValue::BoldFraktur:

            // TODO: Fraktur

        case MathMLMathvariantValue::BoldScript:

            // TODO: Script

            vVariant.push_back(TBOLD);

            break;

        case MathMLMathvariantValue::Italic:

            // nothing to do

            break;

        case MathMLMathvariantValue::BoldItalic:

            vVariant.push_back(TITALIC);

            vVariant.push_back(TBOLD);

            break;

        case MathMLMathvariantValue::DoubleStruck:

            // TODO

            break;

        case MathMLMathvariantValue::Script:

            // TODO

            break;

        case MathMLMathvariantValue::Fraktur:

            // TODO

            break;

        case MathMLMathvariantValue::SansSerif:

            vVariant.push_back(TSANS);

            break;

        case MathMLMathvariantValue::BoldSansSerif:

            vVariant.push_back(TSANS);

            vVariant.push_back(TBOLD);

            break;

        case MathMLMathvariantValue::SansSerifItalic:

            vVariant.push_back(TITALIC);

            vVariant.push_back(TSANS);

            break;

        case MathMLMathvariantValue::SansSerifBoldItalic:

            vVariant.push_back(TITALIC);

            vVariant.push_back(TBOLD);

            vVariant.push_back(TSANS);

            break;

        case MathMLMathvariantValue::Monospace:

            vVariant.push_back(TFIXED);

            break;

        case MathMLMathvariantValue::Initial:

        case MathMLMathvariantValue::Tailed:

        case MathMLMathvariantValue::Looped:

        case MathMLMathvariantValue::Stretched:

            // TODO

            break;

    }

    if (vVariant.empty())

        return;

    SmNodeStack& rNodeStack = mrContext.GetSmImport().GetNodeStack();

    for (auto eType : vVariant)

    {

        SmToken aToken;

        aToken.eType = eType;

        aToken.cMathChar = u""_ustr;

        aToken.nLevel = 5;

        std::unique_ptr<SmFontNode> pFontNode(new SmFontNode(aToken));

        pFontNode->SetSubNodes(nullptr, popOrZero(rNodeStack));

        rNodeStack.push_front(std::move(pFontNode));

    }

}

namespace

{

class SmXMLDocContext_Impl : public SmXMLImportContext

{

public:

    SmXMLDocContext_Impl(SmXMLImport& rImport)

        : SmXMLImportContext(rImport)

    {

    }

    virtual uno::Reference<xml::sax::XFastContextHandler> SAL_CALL createFastChildContext(

        sal_Int32 nElement, const uno::Reference<xml::sax::XFastAttributeList>& xAttrList) override;

    void SAL_CALL endFastElement(sal_Int32 nElement) override;

};

/*avert the gaze from the originator*/

class SmXMLRowContext_Impl : public SmXMLDocContext_Impl

{

protected:

    size_t nElementCount;

public:

    SmXMLRowContext_Impl(SmXMLImport& rImport)

        : SmXMLDocContext_Impl(rImport)

        , nElementCount(GetSmImport().GetNodeStack().size())

    {

    }

    virtual uno::Reference<xml::sax::XFastContextHandler> SAL_CALL createFastChildContext(

        sal_Int32 nElement, const uno::Reference<xml::sax::XFastAttributeList>& xAttrList) override;

    uno::Reference<xml::sax::XFastContextHandler> StrictCreateChildContext(sal_Int32 nElement);

    virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;

};

class SmXMLEncloseContext_Impl : public SmXMLRowContext_Impl

{

public:

    // TODO/LATER: convert <menclose notation="horizontalstrike"> into

    // "overstrike{}" and extend the Math syntax to support more notations

    SmXMLEncloseContext_Impl(SmXMLImport& rImport)

        : SmXMLRowContext_Impl(rImport)

    {

    }

    void SAL_CALL endFastElement(sal_Int32 nElement) override;

};

}

void SmXMLEncloseContext_Impl::endFastElement(sal_Int32 nElement)

{

    /*

    <menclose> accepts any number of arguments; if this number is not 1, its

    contents are treated as a single "inferred <mrow>" containing its

    arguments

    */

    if (GetSmImport().GetNodeStack().size() - nElementCount != 1)

        SmXMLRowContext_Impl::endFastElement(nElement);

}

namespace

{

class SmXMLFracContext_Impl : public SmXMLRowContext_Impl

{

public:

    // TODO/LATER: convert <mfrac bevelled="true"> into "wideslash{}{}"

    SmXMLFracContext_Impl(SmXMLImport& rImport)

        : SmXMLRowContext_Impl(rImport)

    {

    }

    void SAL_CALL endFastElement(sal_Int32 nElement) override;

};

class SmXMLSqrtContext_Impl : public SmXMLRowContext_Impl

{

public:

    SmXMLSqrtContext_Impl(SmXMLImport& rImport)

        : SmXMLRowContext_Impl(rImport)

    {

    }

    void SAL_CALL endFastElement(sal_Int32 nElement) override;

};

class SmXMLRootContext_Impl : public SmXMLRowContext_Impl

{

public:

    SmXMLRootContext_Impl(SmXMLImport& rImport)

        : SmXMLRowContext_Impl(rImport)

    {

    }

    void SAL_CALL endFastElement(sal_Int32 nElement) override;

};

class SmXMLStyleContext_Impl : public SmXMLRowContext_Impl

{

protected:

    SmXMLContext_Helper aStyleHelper;

public:

    /*Right now the style tag is completely ignored*/

    SmXMLStyleContext_Impl(SmXMLImport& rImport)

        : SmXMLRowContext_Impl(rImport)

        , aStyleHelper(*this)

    {

    }

    void SAL_CALL endFastElement(sal_Int32 nElement) override;

    void SAL_CALL startFastElement(

        sal_Int32 nElement, const uno::Reference<xml::sax::XFastAttributeList>& xAttrList) override;

};

}

void SmXMLStyleContext_Impl::startFastElement(

    sal_Int32 /*nElement*/, const uno::Reference<xml::sax::XFastAttributeList>& xAttrList)

{