/* -*- 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 . */ /* Warning: The SvXMLElementExport helper class creates the beginning and closing tags of xml elements in its constructor and destructor, so there's hidden stuff going on, on occasion the ordering of these classes declarations may be significant */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "mathmlexport.hxx" #include #include #include #include #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 { inline bool IsInPrivateUseArea( sal_Unicode cChar ) { return 0xE000 <= cChar && cChar <= 0xF8FF; } sal_Unicode ConvertMathToMathML( sal_Unicode cChar ) { sal_Unicode cRes = cChar; if (IsInPrivateUseArea( cChar )) { SAL_WARN("starmath", "Error: private use area characters should no longer be in use!" ); cRes = u'@'; // just some character that should easily be notice as odd in the context } return cRes; } } bool SmXMLExportWrapper::Export(SfxMedium &rMedium) { bool bRet=true; uno::Reference xContext(comphelper::getProcessComponentContext()); //Get model uno::Reference< lang::XComponent > xModelComp(xModel, uno::UNO_QUERY ); bool bEmbedded = false; uno::Reference xTunnel(xModel,uno::UNO_QUERY); SmModel *pModel = reinterpret_cast (xTunnel->getSomething(SmModel::getUnoTunnelId())); SmDocShell *pDocShell = pModel ? static_cast(pModel->GetObjectShell()) : nullptr; if ( pDocShell && SfxObjectCreateMode::EMBEDDED == pDocShell->GetCreateMode() ) bEmbedded = true; uno::Reference xStatusIndicator; if (!bEmbedded) { if (pDocShell /*&& pDocShell->GetMedium()*/) { OSL_ENSURE( pDocShell->GetMedium() == &rMedium, "different SfxMedium found" ); SfxItemSet* pSet = rMedium.GetItemSet(); if (pSet) { const SfxUnoAnyItem* pItem = static_cast( pSet->GetItem(SID_PROGRESS_STATUSBAR_CONTROL) ); if (pItem) pItem->GetValue() >>= xStatusIndicator; } } // set progress range and start status indicator if (xStatusIndicator.is()) { sal_Int32 nProgressRange = bFlat ? 1 : 3; xStatusIndicator->start(SmResId(STR_STATSTR_WRITING), nProgressRange); } } // create XPropertySet with three properties for status indicator comphelper::PropertyMapEntry aInfoMap[] = { { OUString("UsePrettyPrinting"), 0, cppu::UnoType::get(), beans::PropertyAttribute::MAYBEVOID, 0}, { OUString("BaseURI"), 0, ::cppu::UnoType::get(), beans::PropertyAttribute::MAYBEVOID, 0 }, { OUString("StreamRelPath"), 0, ::cppu::UnoType::get(), beans::PropertyAttribute::MAYBEVOID, 0 }, { OUString("StreamName"), 0, ::cppu::UnoType::get(), beans::PropertyAttribute::MAYBEVOID, 0 }, { OUString(), 0, css::uno::Type(), 0, 0 } }; uno::Reference< beans::XPropertySet > xInfoSet( comphelper::GenericPropertySet_CreateInstance( new comphelper::PropertySetInfo( aInfoMap ) ) ); SvtSaveOptions aSaveOpt; bool bUsePrettyPrinting( bFlat || aSaveOpt.IsPrettyPrinting() ); xInfoSet->setPropertyValue( "UsePrettyPrinting", Any(bUsePrettyPrinting) ); // Set base URI OUString sPropName( "BaseURI" ); xInfoSet->setPropertyValue( sPropName, makeAny( rMedium.GetBaseURL( true ) ) ); sal_Int32 nSteps=0; if (xStatusIndicator.is()) xStatusIndicator->setValue(nSteps++); if (!bFlat) //Storage (Package) of Stream { uno::Reference < embed::XStorage > xStg = rMedium.GetOutputStorage(); bool bOASIS = ( SotStorage::GetVersion( xStg ) > SOFFICE_FILEFORMAT_60 ); // TODO/LATER: handle the case of embedded links gracefully if ( bEmbedded ) //&& !pStg->IsRoot() ) { OUString aName; if ( rMedium.GetItemSet() ) { const SfxStringItem* pDocHierarchItem = static_cast( rMedium.GetItemSet()->GetItem(SID_DOC_HIERARCHICALNAME) ); if ( pDocHierarchItem ) aName = pDocHierarchItem->GetValue(); } if ( !aName.isEmpty() ) { sPropName = "StreamRelPath"; xInfoSet->setPropertyValue( sPropName, makeAny( aName ) ); } } if ( !bEmbedded ) { if (xStatusIndicator.is()) xStatusIndicator->setValue(nSteps++); bRet = WriteThroughComponent( xStg, xModelComp, "meta.xml", xContext, xInfoSet, (bOASIS ? "com.sun.star.comp.Math.XMLOasisMetaExporter" : "com.sun.star.comp.Math.XMLMetaExporter")); } if ( bRet ) { if (xStatusIndicator.is()) xStatusIndicator->setValue(nSteps++); bRet = WriteThroughComponent( xStg, xModelComp, "content.xml", xContext, xInfoSet, "com.sun.star.comp.Math.XMLContentExporter"); } if ( bRet ) { if (xStatusIndicator.is()) xStatusIndicator->setValue(nSteps++); bRet = WriteThroughComponent( xStg, xModelComp, "settings.xml", xContext, xInfoSet, (bOASIS ? "com.sun.star.comp.Math.XMLOasisSettingsExporter" : "com.sun.star.comp.Math.XMLSettingsExporter") ); } } else { SvStream *pStream = rMedium.GetOutStream(); uno::Reference xOut( new utl::OOutputStreamWrapper(*pStream) ); if (xStatusIndicator.is()) xStatusIndicator->setValue(nSteps++); bRet = WriteThroughComponent( xOut, xModelComp, xContext, xInfoSet, "com.sun.star.comp.Math.XMLContentExporter"); } if (xStatusIndicator.is()) xStatusIndicator->end(); return bRet; } /// export through an XML exporter component (output stream version) bool SmXMLExportWrapper::WriteThroughComponent( const Reference& xOutputStream, const Reference& xComponent, Reference const & rxContext, Reference const & rPropSet, const sal_Char* pComponentName ) { OSL_ENSURE(xOutputStream.is(), "I really need an output stream!"); OSL_ENSURE(xComponent.is(), "Need component!"); OSL_ENSURE(nullptr != pComponentName, "Need component name!"); // get component Reference< xml::sax::XWriter > xSaxWriter = xml::sax::Writer::create(rxContext ); // connect XML writer to output stream xSaxWriter->setOutputStream( xOutputStream ); // prepare arguments (prepend doc handler to given arguments) Reference xDocHandler( xSaxWriter,UNO_QUERY); Sequence aArgs( 2 ); aArgs[0] <<= xDocHandler; aArgs[1] <<= rPropSet; // get filter component Reference< document::XExporter > xExporter( rxContext->getServiceManager()->createInstanceWithArgumentsAndContext(OUString::createFromAscii(pComponentName), aArgs, rxContext), UNO_QUERY); OSL_ENSURE( xExporter.is(), "can't instantiate export filter component" ); if ( !xExporter.is() ) return false; // connect model and filter xExporter->setSourceDocument( xComponent ); // filter! Reference < XFilter > xFilter( xExporter, UNO_QUERY ); uno::Sequence< PropertyValue > aProps(0); xFilter->filter( aProps ); uno::Reference xFilterTunnel( xFilter, uno::UNO_QUERY ); SmXMLExport *pFilter = reinterpret_cast< SmXMLExport * >( sal::static_int_cast< sal_uIntPtr >( xFilterTunnel->getSomething( SmXMLExport::getUnoTunnelId() ))); return pFilter == nullptr || pFilter->GetSuccess(); } /// export through an XML exporter component (storage version) bool SmXMLExportWrapper::WriteThroughComponent( const Reference < embed::XStorage >& xStorage, const Reference& xComponent, const sal_Char* pStreamName, Reference const & rxContext, Reference const & rPropSet, const sal_Char* pComponentName ) { OSL_ENSURE(xStorage.is(), "Need storage!"); OSL_ENSURE(nullptr != pStreamName, "Need stream name!"); // open stream Reference < io::XStream > xStream; OUString sStreamName = OUString::createFromAscii(pStreamName); try { xStream = xStorage->openStreamElement( sStreamName, embed::ElementModes::READWRITE | embed::ElementModes::TRUNCATE ); } catch ( const uno::Exception& rEx ) { SAL_WARN("starmath", "Can't create output stream in package: " << rEx ); return false; } uno::Reference < beans::XPropertySet > xSet( xStream, uno::UNO_QUERY ); xSet->setPropertyValue( "MediaType", Any(OUString( "text/xml" )) ); // all streams must be encrypted in encrypted document xSet->setPropertyValue( "UseCommonStoragePasswordEncryption", Any(true) ); // set Base URL if ( rPropSet.is() ) { rPropSet->setPropertyValue( "StreamName", makeAny( sStreamName ) ); } // write the stuff bool bRet = WriteThroughComponent( xStream->getOutputStream(), xComponent, rxContext, rPropSet, pComponentName ); return bRet; } SmXMLExport::SmXMLExport( const css::uno::Reference< css::uno::XComponentContext >& rContext, OUString const & implementationName, SvXMLExportFlags nExportFlags) : SvXMLExport(util::MeasureUnit::INCH, rContext, implementationName, XML_MATH, nExportFlags) , pTree(nullptr) , bSuccess(false) { } sal_Int64 SAL_CALL SmXMLExport::getSomething( const uno::Sequence< sal_Int8 >& rId ) { if ( rId.getLength() == 16 && 0 == memcmp( getUnoTunnelId().getConstArray(), rId.getConstArray(), 16 ) ) return sal::static_int_cast< sal_Int64 >(reinterpret_cast< sal_uIntPtr >(this)); return SvXMLExport::getSomething( rId ); } namespace { class theSmXMLExportUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theSmXMLExportUnoTunnelId> {}; } const uno::Sequence< sal_Int8 > & SmXMLExport::getUnoTunnelId() throw() { return theSmXMLExportUnoTunnelId::get().getSeq(); } extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface* Math_XMLExporter_get_implementation(css::uno::XComponentContext* context, css::uno::Sequence const &) { return cppu::acquire(new SmXMLExport(context, "com.sun.star.comp.Math.XMLExporter", SvXMLExportFlags::OASIS|SvXMLExportFlags::ALL)); } extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface* Math_XMLMetaExporter_get_implementation(css::uno::XComponentContext* context, css::uno::Sequence const &) { return cppu::acquire(new SmXMLExport(context, "com.sun.star.comp.Math.XMLMetaExporter", SvXMLExportFlags::META)); } extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface* Math_XMLOasisMetaExporter_get_implementation(css::uno::XComponentContext* context, css::uno::Sequence const &) { return cppu::acquire(new SmXMLExport(context, "com.sun.star.comp.Math.XMLOasisMetaExporter", SvXMLExportFlags::OASIS|SvXMLExportFlags::META)); } extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface* Math_XMLSettingsExporter_get_implementation(css::uno::XComponentContext* context, css::uno::Sequence const &) { return cppu::acquire(new SmXMLExport(context, "com.sun.star.comp.Math.XMLSettingsExporter", SvXMLExportFlags::SETTINGS)); } extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface* Math_XMLOasisSettingsExporter_get_implementation(css::uno::XComponentContext* context, css::uno::Sequence const &) { return cppu::acquire(new SmXMLExport(context, "com.sun.star.comp.Math.XMLOasisSettingsExporter", SvXMLExportFlags::OASIS|SvXMLExportFlags::SETTINGS)); } extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface* Math_XMLContentExporter_get_implementation(css::uno::XComponentContext* context, css::uno::Sequence const &) { return cppu::acquire(new SmXMLExport(context, "com.sun.star.comp.Math.XMLContentExporter", SvXMLExportFlags::OASIS|SvXMLExportFlags::CONTENT)); } ErrCode SmXMLExport::exportDoc(enum XMLTokenEnum eClass) { if ( !(getExportFlags() & SvXMLExportFlags::CONTENT) ) { SvXMLExport::exportDoc( eClass ); } else { uno::Reference xModel = GetModel(); uno::Reference xTunnel(xModel,uno::UNO_QUERY); SmModel *pModel = reinterpret_cast (xTunnel->getSomething(SmModel::getUnoTunnelId())); if (pModel) { SmDocShell *pDocShell = static_cast(pModel->GetObjectShell()); pTree = pDocShell->GetFormulaTree(); aText = pDocShell->GetText(); } GetDocHandler()->startDocument(); addChaffWhenEncryptedStorage(); /*Add xmlns line*/ SvXMLAttributeList &rList = GetAttrList(); // make use of a default namespace ResetNamespaceMap(); // Math doesn't need namespaces from xmloff, since it now uses default namespaces (because that is common with current MathML usage in the web) GetNamespaceMap_().Add( OUString(), GetXMLToken(XML_N_MATH), XML_NAMESPACE_MATH ); rList.AddAttribute(GetNamespaceMap().GetAttrNameByKey(XML_NAMESPACE_MATH), GetNamespaceMap().GetNameByKey( XML_NAMESPACE_MATH)); //I think we need something like ImplExportEntities(); ExportContent_(); GetDocHandler()->endDocument(); } bSuccess=true; return ERRCODE_NONE; } void SmXMLExport::ExportContent_() { uno::Reference xModel = GetModel(); uno::Reference xTunnel(xModel,uno::UNO_QUERY); SmModel *pModel = reinterpret_cast (xTunnel->getSomething(SmModel::getUnoTunnelId())); SmDocShell *pDocShell = pModel ? static_cast(pModel->GetObjectShell()) : nullptr; OSL_ENSURE( pDocShell, "doc shell missing" ); if (pDocShell && !pDocShell->GetFormat().IsTextmode()) { // If the Math equation is not in text mode, we attach a display="block" // attribute on the

root. We don't do anything if it is in
        // text mode, the default display="inline" value will be used.
        AddAttribute(XML_NAMESPACE_MATH, XML_DISPLAY, XML_BLOCK);
    }
    SvXMLElementExport aEquation(*this, XML_NAMESPACE_MATH, XML_MATH, true, true);
    SvXMLElementExport *pSemantics=nullptr;

    if (!aText.isEmpty())
    {
        pSemantics = new SvXMLElementExport(*this, XML_NAMESPACE_MATH,
            XML_SEMANTICS, true, true);
    }

    ExportNodes(pTree, 0);

    if (!aText.isEmpty())
    {
        // Convert symbol names
        if (pDocShell)
        {
            SmParser &rParser = pDocShell->GetParser();
            bool bVal = rParser.IsExportSymbolNames();
            rParser.SetExportSymbolNames( true );
            auto pTmpTree = rParser.Parse( aText );
            aText = rParser.GetText();
            pTmpTree.reset();
            rParser.SetExportSymbolNames( bVal );
        }

        AddAttribute(XML_NAMESPACE_MATH, XML_ENCODING,
            OUString("StarMath 5.0"));
        SvXMLElementExport aAnnotation(*this, XML_NAMESPACE_MATH,
            XML_ANNOTATION, true, false);
        GetDocHandler()->characters( aText );
    }
    delete pSemantics;
}

void SmXMLExport::GetViewSettings( Sequence < PropertyValue >& aProps)
{
    uno::Reference xModel = GetModel();
    if ( !xModel.is() )
        return;

    uno::Reference xTunnel(xModel,uno::UNO_QUERY);
    SmModel *pModel = reinterpret_cast (xTunnel->getSomething(SmModel::getUnoTunnelId()));

    if ( !pModel )
        return;

    SmDocShell *pDocShell =
        static_cast (pModel->GetObjectShell());
    if ( !pDocShell )
        return;

    aProps.realloc( 4 );
    PropertyValue *pValue = aProps.getArray();
    sal_Int32 nIndex = 0;

    tools::Rectangle aRect( pDocShell->GetVisArea() );

    pValue[nIndex].Name = "ViewAreaTop";
    pValue[nIndex++].Value <<= aRect.Top();

    pValue[nIndex].Name = "ViewAreaLeft";
    pValue[nIndex++].Value <<= aRect.Left();

    pValue[nIndex].Name = "ViewAreaWidth";
    pValue[nIndex++].Value <<= aRect.GetWidth();

    pValue[nIndex].Name = "ViewAreaHeight";
    pValue[nIndex++].Value <<= aRect.GetHeight();
}

void SmXMLExport::GetConfigurationSettings( Sequence < PropertyValue > & rProps)
{
    Reference < XPropertySet > xProps ( GetModel(), UNO_QUERY );
    if ( xProps.is() )
    {
        Reference< XPropertySetInfo > xPropertySetInfo = xProps->getPropertySetInfo();
        if (xPropertySetInfo.is())
        {
            Sequence< Property > aProps = xPropertySetInfo->getProperties();
            sal_Int32 nCount(aProps.getLength());
            if (nCount > 0)
            {
                rProps.realloc(nCount);
                PropertyValue* pProps = rProps.getArray();
                if (pProps)
                {
                    SmMathConfig *pConfig = SM_MOD()->GetConfig();
                    const bool bUsedSymbolsOnly = pConfig && pConfig->IsSaveOnlyUsedSymbols();

                    const OUString sFormula ( "Formula" );
                    const OUString sBasicLibraries ( "BasicLibraries" );
                    const OUString sDialogLibraries ( "DialogLibraries" );
                    const OUString sRuntimeUID ( "RuntimeUID" );
                    for (sal_Int32 i = 0; i < nCount; i++, pProps++)
                    {
                        const OUString &rPropName = aProps[i].Name;
                        if (rPropName != sFormula &&
                            rPropName != sBasicLibraries &&
                            rPropName != sDialogLibraries &&
                            rPropName != sRuntimeUID)
                        {
                            pProps->Name = rPropName;

                            OUString aActualName( rPropName );

                            // handle 'save used symbols only'
                            if (bUsedSymbolsOnly && rPropName == "Symbols" )
                                aActualName = "UserDefinedSymbolsInUse";

                            pProps->Value = xProps->getPropertyValue( aActualName );
                        }
                    }
                }
            }
        }
    }
}

void SmXMLExport::ExportLine(const SmNode *pNode, int nLevel)
{
    ExportExpression(pNode, nLevel);
}

void SmXMLExport::ExportBinaryHorizontal(const SmNode *pNode, int nLevel)
{
    TG nGroup = pNode->GetToken().nGroup;

    std::unique_ptr pRow( new SvXMLElementExport(*this,
        XML_NAMESPACE_MATH, XML_MROW, true, true) );

    // Unfold the binary tree structure as long as the nodes are SmBinHorNode
    // with the same nGroup. This will reduce the number of nested // elements e.g. we only need three levels to export

    // "a*b*c*d+e*f*g*h+i*j*k*l = a*b*c*d+e*f*g*h+i*j*k*l =
    //  a*b*c*d+e*f*g*h+i*j*k*l = a*b*c*d+e*f*g*h+i*j*k*l"

    // See https://www.libreoffice.org/bugzilla/show_bug.cgi?id=66081
    ::std::stack< const SmNode* > s;
    s.push(pNode);
    while (!s.empty())
    {
        const SmNode *node = s.top();
        s.pop();
        if (node->GetType() != SmNodeType::BinHor || node->GetToken().nGroup != nGroup)
        {
            ExportNodes(node, nLevel+1);
            continue;
        }
        const SmBinHorNode* binNode = static_cast (node);
        s.push(binNode->RightOperand());
        s.push(binNode->Symbol());
        s.push(binNode->LeftOperand());
    }
}

void SmXMLExport::ExportUnaryHorizontal(const SmNode *pNode, int nLevel)
{
    ExportExpression(pNode, nLevel);
}

void SmXMLExport::ExportExpression(const SmNode *pNode, int nLevel,
                                   bool bNoMrowContainer /*=false*/)
{
    SvXMLElementExport *pRow=nullptr;
    size_t nSize = pNode->GetNumSubNodes();

    // #i115443: nodes of type expression always need to be grouped with mrow statement
    if (!bNoMrowContainer &&
        (nSize > 1 || pNode->GetType() == SmNodeType::Expression))
        pRow = new SvXMLElementExport(*this, XML_NAMESPACE_MATH, XML_MROW, true, true);

    for (size_t i = 0; i < nSize; ++i)
    {
        if (const SmNode *pTemp = pNode->GetSubNode(i))
            ExportNodes(pTemp, nLevel+1);
    }

    delete pRow;
}

void SmXMLExport::ExportBinaryVertical(const SmNode *pNode, int nLevel)
{
    assert(pNode->GetNumSubNodes() == 3);
    const SmNode *pNum = pNode->GetSubNode(0);
    const SmNode *pDenom = pNode->GetSubNode(2);
    if (pNum->GetType() == SmNodeType::Align && pNum->GetToken().eType != TALIGNC)
    {
        // A left or right alignment is specified on the numerator:
        // attach the corresponding numalign attribute.
        AddAttribute(XML_NAMESPACE_MATH, XML_NUMALIGN,
            pNum->GetToken().eType == TALIGNL ? XML_LEFT : XML_RIGHT);
    }
    if (pDenom->GetType() == SmNodeType::Align && pDenom->GetToken().eType != TALIGNC)
    {
        // A left or right alignment is specified on the denominator:
        // attach the corresponding denomalign attribute.
        AddAttribute(XML_NAMESPACE_MATH, XML_DENOMALIGN,
            pDenom->GetToken().eType == TALIGNL ? XML_LEFT : XML_RIGHT);
    }
    SvXMLElementExport aFraction(*this, XML_NAMESPACE_MATH, XML_MFRAC, true, true);
    ExportNodes(pNum, nLevel);
    ExportNodes(pDenom, nLevel);
}

void SmXMLExport::ExportBinaryDiagonal(const SmNode *pNode, int nLevel)
{
    assert(pNode->GetNumSubNodes() == 3);

    if (pNode->GetToken().eType == TWIDESLASH)
    {
        // wideslash
        // export the node as \frac{AddAttribute(XML_NAMESPACE_MATH, XML_BEVELLED, XML_TRUE);
        SvXMLElementExport aFraction(*this, XML_NAMESPACE_MATH, XML_MFRAC,
            true, true);
        ExportNodes(pNode->GetSubNode(0), nLevel);
        ExportNodes(pNode->GetSubNode(1), nLevel);
    }
    else
    {
        // widebslash
        // We can not use}{\frac{to a backslash, so just use}{\}}