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

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

1 files changed, 1149 insertions, 0 deletions

diff --git a/xmloff/source/style/xmlexppr.cxx b/xmloff/source/style/xmlexppr.cxx
new file mode 100644
index 000000000..7601bf1f1
--- /dev/null
+++ b/xmloff/source/style/xmlexppr.cxx
@@ -0,0 +1,1149 @@
+/* -*- 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 .
+ */
+
+#include <memory>
+#include <string_view>
+#include <com/sun/star/container/XNameContainer.hpp>
+#include <com/sun/star/xml/AttributeData.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/beans/XPropertyState.hpp>
+#include <com/sun/star/beans/XMultiPropertySet.hpp>
+#include <com/sun/star/beans/XTolerantMultiPropertySet.hpp>
+#include <com/sun/star/beans/TolerantPropertySetResultType.hpp>
+#include <rtl/ustrbuf.hxx>
+#include <comphelper/anycompare.hxx>
+#include <cppuhelper/weakref.hxx>
+#include <osl/diagnose.h>
+#include <list>
+#include <map>
+
+#include <xmloff/xmlexppr.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/attrlist.hxx>
+#include <xmloff/nmspmap.hxx>
+#include <xmloff/xmlnmspe.hxx>
+#include <xmloff/xmlexp.hxx>
+#include <xmloff/xmlprmap.hxx>
+#include <xmloff/maptype.hxx>
+#include <xmloff/xmltypes.hxx>
+#include <xmloff/xmlprhdl.hxx>
+
+using namespace ::std;
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::lang;
+using namespace ::xmloff::token;
+
+#define GET_PROP_TYPE( f ) static_cast<sal_uInt16>((f & XML_TYPE_PROP_MASK) >> XML_TYPE_PROP_SHIFT)
+#define ENTRY(t) { GET_PROP_TYPE(XML_TYPE_PROP_##t), XML_##t##_PROPERTIES }
+
+namespace {
+
+struct XMLPropTokens_Impl
+{
+    sal_uInt16 nType;
+    XMLTokenEnum eToken;
+};
+
+const sal_uInt16 MAX_PROP_TYPES =
+    (XML_TYPE_PROP_END >> XML_TYPE_PROP_SHIFT) -
+    (XML_TYPE_PROP_START >> XML_TYPE_PROP_SHIFT);
+
+XMLPropTokens_Impl const aPropTokens[MAX_PROP_TYPES] =
+{
+    ENTRY(CHART),
+    ENTRY(GRAPHIC),
+    ENTRY(TABLE),
+    ENTRY(TABLE_COLUMN),
+    ENTRY(TABLE_ROW),
+    ENTRY(TABLE_CELL),
+    ENTRY(LIST_LEVEL),
+    ENTRY(PARAGRAPH),
+    ENTRY(TEXT),
+    ENTRY(DRAWING_PAGE),
+    ENTRY(PAGE_LAYOUT),
+    ENTRY(HEADER_FOOTER),
+    ENTRY(RUBY),
+    ENTRY(SECTION)
+};
+
+// public methods
+
+// Take all properties of the XPropertySet which are also found in the
+// XMLPropertyMapEntry-array and which are not set to their default-value,
+// if a state is available.
+// After that I call the method 'ContextFilter'.
+
+typedef std::list<XMLPropertyState> XMLPropertyStateList_Impl;
+
+class XMLPropertyStates_Impl
+{
+    XMLPropertyStateList_Impl           aPropStates;
+    XMLPropertyStateList_Impl::iterator aLastItr;
+    sal_uInt32                          nCount;
+public:
+    XMLPropertyStates_Impl();
+    void AddPropertyState(const XMLPropertyState& rPropState);
+    void FillPropertyStateVector(std::vector<XMLPropertyState>& rVector);
+};
+
+XMLPropertyStates_Impl::XMLPropertyStates_Impl() :
+    aPropStates(),
+    nCount(0)
+{
+    aLastItr = aPropStates.begin();
+}
+
+void XMLPropertyStates_Impl::AddPropertyState(
+        const XMLPropertyState& rPropState)
+{
+    XMLPropertyStateList_Impl::iterator aItr = aPropStates.begin();
+    bool bInserted(false);
+    if (nCount)
+    {
+        if (aLastItr->mnIndex < rPropState.mnIndex)
+            aItr = ++aLastItr;
+    }
+    do
+    {
+        // TODO: one path required only
+        if (aItr == aPropStates.end())
+        {
+            aLastItr = aPropStates.insert(aPropStates.end(), rPropState);
+            bInserted = true;
+            nCount++;
+        }
+        else if (aItr->mnIndex > rPropState.mnIndex)
+        {
+            aLastItr = aPropStates.insert(aItr, rPropState);
+            bInserted = true;
+            nCount++;
+        }
+    }
+    while(!bInserted && (aItr++ != aPropStates.end()));
+}
+
+void XMLPropertyStates_Impl::FillPropertyStateVector(
+        std::vector<XMLPropertyState>& rVector)
+{
+    if (nCount)
+    {
+        rVector.resize(nCount, XMLPropertyState(-1));
+        ::std::copy( aPropStates.begin(), aPropStates.end(), rVector.begin() );
+    }
+}
+
+class FilterPropertyInfo_Impl
+{
+    const OUString     sApiName;
+    std::list<sal_uInt32>   aIndexes;
+
+public:
+
+    FilterPropertyInfo_Impl( const OUString& rApiName,
+                             const sal_uInt32 nIndex);
+
+    const OUString& GetApiName() const { return sApiName; }
+    std::list<sal_uInt32>& GetIndexes() { return aIndexes; }
+
+    // for sort
+    bool operator< ( const FilterPropertyInfo_Impl& rArg ) const
+    {
+        return (GetApiName() < rArg.GetApiName());
+    }
+};
+
+FilterPropertyInfo_Impl::FilterPropertyInfo_Impl(
+        const OUString& rApiName,
+        const sal_uInt32 nIndex ) :
+    sApiName( rApiName )
+{
+    aIndexes.push_back(nIndex);
+}
+
+typedef std::list<FilterPropertyInfo_Impl> FilterPropertyInfoList_Impl;
+
+class FilterPropertiesInfo_Impl
+{
+    sal_uInt32                              nCount;
+    FilterPropertyInfoList_Impl             aPropInfos;
+
+    std::unique_ptr<Sequence<OUString>>     pApiNames;
+
+public:
+    FilterPropertiesInfo_Impl();
+
+    void AddProperty(const OUString& rApiName, const sal_uInt32 nIndex);
+    const uno::Sequence<OUString>& GetApiNames();
+    void FillPropertyStateArray(
+            vector< XMLPropertyState >& rPropStates,
+            const Reference< XPropertySet >& xPropSet,
+            const rtl::Reference< XMLPropertySetMapper >& maPropMapper,
+            const bool bDefault);
+    sal_uInt32 GetPropertyCount() const { return nCount; }
+};
+
+FilterPropertiesInfo_Impl::FilterPropertiesInfo_Impl() :
+    nCount(0),
+    aPropInfos()
+{
+}
+
+void FilterPropertiesInfo_Impl::AddProperty(
+        const OUString& rApiName, const sal_uInt32 nIndex)
+{
+    aPropInfos.emplace_back(rApiName, nIndex);
+    nCount++;
+
+    OSL_ENSURE( !pApiNames, "performance warning: API names already retrieved" );
+    pApiNames.reset();
+}
+
+const uno::Sequence<OUString>& FilterPropertiesInfo_Impl::GetApiNames()
+{
+    OSL_ENSURE(nCount == aPropInfos.size(), "wrong property count");
+    if( !pApiNames )
+    {
+        // we have to do three things:
+        // 1) sort API names,
+        // 2) merge duplicates,
+        // 3) construct sequence
+
+        // sort names
+        aPropInfos.sort();
+
+        // merge duplicates
+        if ( nCount > 1 )
+        {
+            FilterPropertyInfoList_Impl::iterator aOld = aPropInfos.begin();
+            FilterPropertyInfoList_Impl::iterator aEnd = aPropInfos.end();
+            FilterPropertyInfoList_Impl::iterator aCurrent = aOld;
+            ++aCurrent;
+
+            while ( aCurrent != aEnd )
+            {
+                // equal to next element?
+                if ( aOld->GetApiName() == aCurrent->GetApiName() )
+                {
+                    // if equal: merge index lists
+                    aOld->GetIndexes().merge( aCurrent->GetIndexes() );
+                    // erase element, and continue with next
+                    aCurrent = aPropInfos.erase( aCurrent );
+                    nCount--;
+                }
+                else
+                {
+                    // remember old element and continue with next
+                    aOld = aCurrent;
+                    ++aCurrent;
+                }
+            }
+        }
+
+        // construct sequence
+        pApiNames.reset( new Sequence < OUString >( nCount ) );
+        OUString *pNames = pApiNames->getArray();
+
+        for (auto const& propInfo : aPropInfos)
+        {
+            *pNames = propInfo.GetApiName();
+            ++pNames;
+        }
+    }
+
+    return *pApiNames;
+}
+
+void FilterPropertiesInfo_Impl::FillPropertyStateArray(
+        vector< XMLPropertyState >& rPropStates,
+        const Reference< XPropertySet >& rPropSet,
+        const rtl::Reference< XMLPropertySetMapper >& rPropMapper,
+        const bool bDefault )
+{
+    XMLPropertyStates_Impl aPropStates;
+
+    const uno::Sequence<OUString>& rApiNames = GetApiNames();
+
+    Reference < XTolerantMultiPropertySet > xTolPropSet( rPropSet, UNO_QUERY );
+    if (xTolPropSet.is())
+    {
+        if (!bDefault)
+        {
+            Sequence < beans::GetDirectPropertyTolerantResult > aResults(xTolPropSet->getDirectPropertyValuesTolerant(rApiNames));
+            sal_Int32 nResultCount(aResults.getLength());
+            if (nResultCount > 0)
+            {
+                const beans::GetDirectPropertyTolerantResult *pResults = aResults.getConstArray();
+                FilterPropertyInfoList_Impl::iterator aPropIter(aPropInfos.begin());
+                XMLPropertyState aNewProperty( -1 );
+                sal_uInt32 i = 0;
+                while (nResultCount > 0 && i < nCount)
+                {
+                    if (pResults->Name == aPropIter->GetApiName())
+                    {
+                        aNewProperty.mnIndex = -1;
+                        aNewProperty.maValue = pResults->Value;
+
+                        for (auto const& index : aPropIter->GetIndexes())
+                        {
+                            aNewProperty.mnIndex = index;
+                            aPropStates.AddPropertyState( aNewProperty );
+                        }
+                        ++pResults;
+                        --nResultCount;
+                    }
+                    ++aPropIter;
+                    ++i;
+                }
+            }
+        }
+        else
+        {
+            const Sequence < beans::GetPropertyTolerantResult > aResults(xTolPropSet->getPropertyValuesTolerant(rApiNames));
+            OSL_ENSURE( rApiNames.getLength() == aResults.getLength(), "wrong implemented XTolerantMultiPropertySet" );
+            FilterPropertyInfoList_Impl::iterator aPropIter(aPropInfos.begin());
+            XMLPropertyState aNewProperty( -1 );
+            OSL_ENSURE( nCount == static_cast<sal_uInt32>(aResults.getLength()), "wrong implemented XTolerantMultiPropertySet??" );
+            for( const auto& rResult : aResults )
+            {
+                if ((rResult.Result == beans::TolerantPropertySetResultType::SUCCESS) &&
+                    ((rResult.State == PropertyState_DIRECT_VALUE) || (rResult.State == PropertyState_DEFAULT_VALUE)))
+                {
+                    aNewProperty.mnIndex = -1;
+                    aNewProperty.maValue = rResult.Value;
+
+                    for (auto const& index : aPropIter->GetIndexes())
+                    {
+                        aNewProperty.mnIndex = index;
+                        aPropStates.AddPropertyState( aNewProperty );
+                    }
+                }
+                ++aPropIter;
+            }
+        }
+    }
+    else
+    {
+        Sequence < PropertyState > aStates;
+        const PropertyState *pStates = nullptr;
+        Reference< XPropertyState > xPropState( rPropSet, UNO_QUERY );
+        if( xPropState.is() )
+        {
+            aStates = xPropState->getPropertyStates( rApiNames );
+            pStates = aStates.getConstArray();
+        }
+
+        Reference < XMultiPropertySet > xMultiPropSet( rPropSet, UNO_QUERY );
+        if( xMultiPropSet.is() && !bDefault )
+        {
+            Sequence < Any > aValues;
+            if( pStates )
+            {
+                // step 1: get value count
+                sal_uInt32 nValueCount = 0;
+                sal_uInt32 i;
+
+                for( i = 0; i < nCount; ++i, ++pStates )
+                {
+                    if( *pStates == PropertyState_DIRECT_VALUE )
+                        nValueCount++;
+                }
+
+                if( nValueCount )
+                {
+                    // step 2: collect property names
+                    Sequence < OUString > aAPINames( nValueCount );
+                    OUString *pAPINames = aAPINames.getArray();
+
+                    ::std::vector< FilterPropertyInfoList_Impl::iterator > aPropIters;
+                    aPropIters.reserve( nValueCount );
+
+                    FilterPropertyInfoList_Impl::iterator aItr = aPropInfos.begin();
+                    OSL_ENSURE(aItr != aPropInfos.end(),"Invalid iterator!");
+
+                    pStates = aStates.getConstArray();
+                    i = 0;
+                    while( i < nValueCount )
+                    {
+                        if( *pStates == PropertyState_DIRECT_VALUE )
+                        {
+                            *pAPINames++ = aItr->GetApiName();
+                            aPropIters.push_back( aItr );
+                            ++i;
+                        }
+                        ++aItr;
+                        ++pStates;
+                    }
+
+                    aValues = xMultiPropSet->getPropertyValues( aAPINames );
+                    const Any *pValues = aValues.getConstArray();
+
+                    ::std::vector< FilterPropertyInfoList_Impl::iterator >::const_iterator
+                        pPropIter = aPropIters.begin();
+
+                    XMLPropertyState aNewProperty( -1 );
+                    for( i = 0; i < nValueCount; ++i )
+                    {
+                        aNewProperty.mnIndex = -1;
+                        aNewProperty.maValue = *pValues;
+
+                        for (auto const& index : (*pPropIter)->GetIndexes())
+                        {
+                            aNewProperty.mnIndex = index;
+                            aPropStates.AddPropertyState( aNewProperty );
+                        }
+
+                        ++pPropIter;
+                        ++pValues;
+                    }
+                }
+            }
+            else
+            {
+                aValues = xMultiPropSet->getPropertyValues( rApiNames );
+                const Any *pValues = aValues.getConstArray();
+
+                FilterPropertyInfoList_Impl::iterator aItr = aPropInfos.begin();
+                for(sal_uInt32 i = 0; i < nCount; ++i)
+                {
+                    // The value is stored in the PropertySet itself, add to list.
+                    XMLPropertyState aNewProperty( -1 );
+                    aNewProperty.maValue = *pValues;
+                    ++pValues;
+                    for (auto const& index : aItr->GetIndexes())
+                    {
+                        aNewProperty.mnIndex = index;
+                        aPropStates.AddPropertyState( aNewProperty );
+                    }
+                    ++aItr;
+                }
+            }
+        }
+        else
+        {
+            FilterPropertyInfoList_Impl::iterator aItr = aPropInfos.begin();
+            for(sal_uInt32 i = 0; i < nCount; ++i)
+            {
+                bool bDirectValue =
+                    !pStates || *pStates == PropertyState_DIRECT_VALUE;
+                if( bDirectValue || bDefault )
+                {
+                    // The value is stored in the PropertySet itself, add to list.
+                    bool bGotValue = false;
+                    XMLPropertyState aNewProperty( -1 );
+                    for (auto const& index : aItr->GetIndexes())
+                    {
+                        if( bDirectValue ||
+                            (rPropMapper->GetEntryFlags(index) &
+                                            MID_FLAG_DEFAULT_ITEM_EXPORT) != 0 )
+                        {
+                            try
+                            {
+                                if( !bGotValue )
+                                {
+                                    aNewProperty.maValue =
+                                        rPropSet->getPropertyValue( aItr->GetApiName() );
+                                    bGotValue = true;
+                                }
+                                aNewProperty.mnIndex = index;
+                                aPropStates.AddPropertyState( aNewProperty );
+                            }
+                            catch( UnknownPropertyException& )
+                            {
+                                // might be a problem of getImplemenetationId
+                                OSL_ENSURE( false, "unknown property in getPropertyValue" );
+                            }
+
+                        }
+                    }
+                }
+
+                ++aItr;
+                if( pStates )
+                    ++pStates;
+            }
+        }
+    }
+    aPropStates.FillPropertyStateVector(rPropStates);
+}
+
+}
+
+struct SvXMLExportPropertyMapper::Impl
+{
+    typedef std::map<css::uno::Reference<css::beans::XPropertySetInfo>, std::unique_ptr<FilterPropertiesInfo_Impl>> CacheType;
+    CacheType maCache;
+
+    rtl::Reference<SvXMLExportPropertyMapper> mxNextMapper;
+    rtl::Reference<XMLPropertySetMapper> mxPropMapper;
+
+    OUString maStyleName;
+};
+
+// ctor/dtor , class SvXMLExportPropertyMapper
+
+SvXMLExportPropertyMapper::SvXMLExportPropertyMapper(
+        const rtl::Reference< XMLPropertySetMapper >& rMapper ) :
+    mpImpl(new Impl)
+{
+    mpImpl->mxPropMapper = rMapper;
+}
+
+SvXMLExportPropertyMapper::~SvXMLExportPropertyMapper()
+{
+}
+
+void SvXMLExportPropertyMapper::ChainExportMapper(
+        const rtl::Reference< SvXMLExportPropertyMapper>& rMapper )
+{
+    // add map entries from rMapper to current map
+    mpImpl->mxPropMapper->AddMapperEntry( rMapper->getPropertySetMapper() );
+    // rMapper uses the same map as 'this'
+    rMapper->mpImpl->mxPropMapper = mpImpl->mxPropMapper;
+
+    // set rMapper as last mapper in current chain
+    rtl::Reference< SvXMLExportPropertyMapper > xNext = mpImpl->mxNextMapper;
+    if( xNext.is())
+    {
+        while (xNext->mpImpl->mxNextMapper.is())
+            xNext = xNext->mpImpl->mxNextMapper;
+        xNext->mpImpl->mxNextMapper = rMapper;
+    }
+    else
+        mpImpl->mxNextMapper = rMapper;
+
+    // if rMapper was already chained, correct
+    // map pointer of successors
+    xNext = rMapper;
+
+    while (xNext->mpImpl->mxNextMapper.is())
+    {
+        xNext = xNext->mpImpl->mxNextMapper;
+        xNext->mpImpl->mxPropMapper = mpImpl->mxPropMapper;
+    }
+}
+
+std::vector<XMLPropertyState> SvXMLExportPropertyMapper::Filter(
+    const uno::Reference<beans::XPropertySet>& rPropSet, bool bEnableFoFontFamily ) const
+{
+    return Filter_(rPropSet, false, bEnableFoFontFamily);
+}
+
+std::vector<XMLPropertyState> SvXMLExportPropertyMapper::FilterDefaults(
+    const uno::Reference<beans::XPropertySet>& rPropSet ) const
+{
+    return Filter_(rPropSet, true, false/*bEnableFoFontFamily*/);
+}
+
+vector<XMLPropertyState> SvXMLExportPropertyMapper::Filter_(
+    const Reference<XPropertySet>& xPropSet, bool bDefault, bool bEnableFoFontFamily ) const
+{
+    vector< XMLPropertyState > aPropStateArray;
+
+    // Retrieve XPropertySetInfo and XPropertyState
+    Reference< XPropertySetInfo > xInfo( xPropSet->getPropertySetInfo() );
+    if( !xInfo.is() )
+        return aPropStateArray;
+
+    sal_Int32 nProps = mpImpl->mxPropMapper->GetEntryCount();
+
+    FilterPropertiesInfo_Impl *pFilterInfo = nullptr;
+
+    Impl::CacheType::iterator aIter = mpImpl->maCache.find(xInfo);
+    if (aIter != mpImpl->maCache.end())
+        pFilterInfo = (*aIter).second.get();
+
+    bool bDelInfo = false;
+    if( !pFilterInfo )
+    {
+        assert(SvtSaveOptions().GetODFDefaultVersion() != SvtSaveOptions::ODFVER_UNKNOWN);
+        const SvtSaveOptions::ODFSaneDefaultVersion nCurrentVersion(SvtSaveOptions().GetODFSaneDefaultVersion());
+        pFilterInfo = new FilterPropertiesInfo_Impl;
+        for( sal_Int32 i=0; i < nProps; i++ )
+        {
+            // Are we allowed to ask for the property? (MID_FLAG_NO_PROP..)
+            // Does the PropertySet contain name of mpEntries-array ?
+            const OUString& rAPIName = mpImpl->mxPropMapper->GetEntryAPIName( i );
+            const sal_Int32 nFlags = mpImpl->mxPropMapper->GetEntryFlags( i );
+            if( (0 == (nFlags & MID_FLAG_NO_PROPERTY_EXPORT)) &&
+                ( (0 != (nFlags & MID_FLAG_MUST_EXIST)) ||
+                  xInfo->hasPropertyByName( rAPIName ) ) )
+            {
+                const SvtSaveOptions::ODFSaneDefaultVersion nEarliestODFVersionForExport(
+                        mpImpl->mxPropMapper->GetEarliestODFVersionForExport(i));
+                // note: only standard ODF versions are allowed here,
+                // only exception is the unknown future
+                assert((nEarliestODFVersionForExport & SvtSaveOptions::ODFSVER_EXTENDED) == 0
+                    || nEarliestODFVersionForExport == SvtSaveOptions::ODFSVER_FUTURE_EXTENDED);
+                static_assert(SvtSaveOptions::ODFSVER_LATEST_EXTENDED < SvtSaveOptions::ODFSVER_FUTURE_EXTENDED);
+                /// standard ODF namespaces for elements and attributes
+                static sal_uInt16 s_OdfNs[] = {
+                    XML_NAMESPACE_OFFICE,
+                    XML_NAMESPACE_STYLE,
+                    XML_NAMESPACE_TEXT,
+                    XML_NAMESPACE_TABLE,
+                    XML_NAMESPACE_DRAW,
+                    XML_NAMESPACE_FO,
+                    XML_NAMESPACE_XLINK,
+                    XML_NAMESPACE_DC,
+                    XML_NAMESPACE_META,
+                    XML_NAMESPACE_NUMBER,
+                    XML_NAMESPACE_PRESENTATION,
+                    XML_NAMESPACE_SVG,
+                    XML_NAMESPACE_CHART,
+                    XML_NAMESPACE_DR3D,
+                    XML_NAMESPACE_MATH,
+                    XML_NAMESPACE_FORM,
+                    XML_NAMESPACE_SCRIPT,
+                    XML_NAMESPACE_CONFIG,
+                    XML_NAMESPACE_DB,
+                    XML_NAMESPACE_XFORMS,
+                    XML_NAMESPACE_SMIL,
+                    XML_NAMESPACE_ANIMATION,
+                    XML_NAMESPACE_XML,
+                    XML_NAMESPACE_XHTML,
+                    XML_NAMESPACE_GRDDL,
+                };
+                static bool s_Assert(false);
+                if (!s_Assert)
+                {
+                    assert(std::is_sorted(std::begin(s_OdfNs), std::end(s_OdfNs)));
+                    s_Assert = true;
+                }
+                //static_assert(std::is_sorted(std::begin(s_OdfNs), std::end(s_OdfNs)));
+                auto const ns(mpImpl->mxPropMapper->GetEntryNameSpace(i));
+                auto const iter(std::lower_bound(std::begin(s_OdfNs), std::end(s_OdfNs),
+                            ns));
+                bool const isExtension(iter == std::end(s_OdfNs) || *iter != ns
+                        // FIXME: very special hack to suppress style:hyperlink
+                        || (ns == XML_NAMESPACE_STYLE
+                            && mpImpl->mxPropMapper->GetEntryXMLName(i) == GetXMLToken(XML_HYPERLINK)));
+                if (isExtension
+                    ? ((nCurrentVersion & SvtSaveOptions::ODFSVER_EXTENDED)
+                        // if it's in standard ODF, don't export extension
+                        && (nCurrentVersion < nEarliestODFVersionForExport))
+                    : (nEarliestODFVersionForExport <= nCurrentVersion))
+                {
+                    pFilterInfo->AddProperty(rAPIName, i);
+                }
+            }
+        }
+
+        // Check whether the property set info is destroyed if it is assigned to
+        // a weak reference only; If it is destroyed, then every instance of
+        // getPropertySetInfo returns a new object; such property set infos must
+        // not be cached:
+        WeakReference < XPropertySetInfo > xWeakInfo( xInfo );
+        xInfo.clear();
+        xInfo = xWeakInfo;
+        if( xInfo.is() )
+        {
+            mpImpl->maCache.emplace(xInfo, std::unique_ptr<FilterPropertiesInfo_Impl>(pFilterInfo));
+        }
+        else
+            bDelInfo = true;
+    }
+
+    if( pFilterInfo->GetPropertyCount() )
+    {
+        try
+        {
+            pFilterInfo->FillPropertyStateArray(
+                aPropStateArray, xPropSet, mpImpl->mxPropMapper, bDefault);
+        }
+        catch( UnknownPropertyException& )
+        {
+            // might be a problem of getImplemenetationId
+            OSL_ENSURE( false, "unknown property in getPropertyStates" );
+        }
+    }
+
+    // Call context-filter
+    if( !aPropStateArray.empty() )
+        ContextFilter(bEnableFoFontFamily, aPropStateArray, xPropSet);
+
+    // Have to do if we change from a vector to a list or something like that
+
+    if( bDelInfo )
+        delete pFilterInfo;
+
+    return aPropStateArray;
+}
+
+void SvXMLExportPropertyMapper::ContextFilter(
+        bool bEnableFoFontFamily,
+        vector< XMLPropertyState >& rProperties,
+        const Reference< XPropertySet >& rPropSet ) const
+{
+    // Derived class could implement this.
+    if (mpImpl->mxNextMapper.is())
+        mpImpl->mxNextMapper->ContextFilter(bEnableFoFontFamily, rProperties, rPropSet);
+}
+
+// Compares two Sequences of XMLPropertyState:
+//  1.Number of elements equal ?
+//  2.Index of each element equal ? (So I know whether the propertynames are the same)
+//  3.Value of each element equal ?
+bool SvXMLExportPropertyMapper::Equals(
+        const vector< XMLPropertyState >& aProperties1,
+        const vector< XMLPropertyState >& aProperties2 ) const
+{
+    if (aProperties1.size() < aProperties2.size())
+        return true;
+    if (aProperties1.size() > aProperties2.size())
+        return false;
+
+    sal_uInt32 nCount = aProperties1.size();
+
+    for (sal_uInt32 nIndex = 0; nIndex < nCount; ++nIndex)
+    {
+        const XMLPropertyState& rProp1 = aProperties1[ nIndex ];
+        const XMLPropertyState& rProp2 = aProperties2[ nIndex ];
+
+        // Compare index. If equal, compare value
+        if( rProp1.mnIndex < rProp2.mnIndex )
+            return true;
+        if( rProp1.mnIndex > rProp2.mnIndex )
+            return false;
+
+        if( rProp1.mnIndex != -1 )
+        {
+            // Now compare values
+            if ( (mpImpl->mxPropMapper->GetEntryType( rProp1.mnIndex ) &
+                  XML_TYPE_BUILDIN_CMP ) != 0 )
+            {
+                // simple type ( binary compare )
+                if ( rProp1.maValue != rProp2.maValue)
+                    return false;
+            }
+            else
+            {
+                // complex type ( ask for compare-function )
+                if (!mpImpl->mxPropMapper->GetPropertyHandler(
+                            rProp1.mnIndex )->equals( rProp1.maValue,
+                                                      rProp2.maValue ))
+                    return false;
+            }
+        }
+    }
+
+    return true;
+}
+
+// Compares two Sequences of XMLPropertyState:
+//  1.Number of elements equal ?
+//  2.Index of each element equal ? (So I know whether the propertynames are the same)
+//  3.Value of each element equal ?
+bool SvXMLExportPropertyMapper::LessPartial(
+        const vector< XMLPropertyState >& aProperties1,
+        const vector< XMLPropertyState >& aProperties2 ) const
+{
+    if (aProperties1.size() < aProperties2.size())
+        return true;
+    if (aProperties1.size() > aProperties2.size())
+        return false;
+
+    sal_uInt32 nCount = aProperties1.size();
+
+    for (sal_uInt32 nIndex = 0; nIndex < nCount; ++nIndex)
+    {
+        const XMLPropertyState& rProp1 = aProperties1[ nIndex ];
+        const XMLPropertyState& rProp2 = aProperties2[ nIndex ];
+
+        // Compare index. If equal, compare value
+        if( rProp1.mnIndex < rProp2.mnIndex )
+            return true;
+        if( rProp1.mnIndex > rProp2.mnIndex )
+            return false;
+
+        if( rProp1.mnIndex != -1 )
+        {
+            // Now compare values
+            if ( (mpImpl->mxPropMapper->GetEntryType( rProp1.mnIndex ) &
+                  XML_TYPE_BUILDIN_CMP ) != 0 )
+            {
+                // simple type ( binary compare )
+                if ( comphelper::anyLess(rProp1.maValue, rProp2.maValue) )
+                    return true;
+                if ( comphelper::anyLess(rProp2.maValue, rProp1.maValue ) )
+                    return false;
+            }
+        }
+    }
+
+    return false;
+}
+
+/** fills the given attribute list with the items in the given set
+void SvXMLExportPropertyMapper::exportXML( SvXMLAttributeList& rAttrList,
+        const ::std::vector< XMLPropertyState >& rProperties,
+        const SvXMLUnitConverter& rUnitConverter,
+        const SvXMLNamespaceMap& rNamespaceMap,
+        sal_uInt16 nFlags ) const
+{
+    _exportXML( rAttrList, rProperties, rUnitConverter, rNamespaceMap,
+                nFlags, 0, -1, -1 );
+}
+
+void SvXMLExportPropertyMapper::exportXML( SvXMLAttributeList& rAttrList,
+        const ::std::vector< XMLPropertyState >& rProperties,
+        const SvXMLUnitConverter& rUnitConverter,
+        const SvXMLNamespaceMap& rNamespaceMap,
+        sal_Int32 nPropMapStartIdx, sal_Int32 nPropMapEndIdx,
+        sal_uInt16 nFlags ) const
+{
+    _exportXML( rAttrList, rProperties, rUnitConverter, rNamespaceMap,
+                nFlags, 0, nPropMapStartIdx, nPropMapEndIdx );
+}
+*/
+
+void SvXMLExportPropertyMapper::exportXML(
+        SvXMLExport& rExport,
+        const ::std::vector< XMLPropertyState >& rProperties,
+        SvXmlExportFlags nFlags,
+        bool bUseExtensionNamespaceForGraphicProperties) const
+{
+    exportXML(rExport, rProperties, -1, -1,  nFlags, bUseExtensionNamespaceForGraphicProperties);
+}
+
+
+void SvXMLExportPropertyMapper::exportXML(
+        SvXMLExport& rExport,
+        const ::std::vector< XMLPropertyState >& rProperties,
+        sal_Int32 nPropMapStartIdx, sal_Int32 nPropMapEndIdx,
+        SvXmlExportFlags nFlags, bool bUseExtensionNamespaceForGraphicProperties) const
+{
+    sal_uInt16 nPropTypeFlags = 0;
+    for( sal_uInt16 i=0; i<MAX_PROP_TYPES; ++i )
+    {
+        sal_uInt16 nPropType = aPropTokens[i].nType;
+        if( 0==i || (nPropTypeFlags & (1 << nPropType)) != 0 )
+        {
+            sal_uInt16 nNamespace = XML_NAMESPACE_STYLE;
+            if (bUseExtensionNamespaceForGraphicProperties &&
+                aPropTokens[i].eToken == xmloff::token::XML_GRAPHIC_PROPERTIES)
+            {
+                nNamespace = XML_NAMESPACE_LO_EXT;
+                if ((rExport.getSaneDefaultVersion() & SvtSaveOptions::ODFSVER_EXTENDED) == 0)
+                {
+                    continue; // don't write for ODF <= 1.2
+                }
+            }
+
+            std::vector<sal_uInt16> aIndexArray;
+
+            _exportXML( nPropType, nPropTypeFlags,
+                        rExport.GetAttrList(), rProperties,
+                        rExport.GetMM100UnitConverter(),
+                        rExport.GetNamespaceMap(),
+                        &aIndexArray,
+                        nPropMapStartIdx, nPropMapEndIdx );
+
+            if( rExport.GetAttrList().getLength() > 0 ||
+                !aIndexArray.empty() )
+            {
+                SvXMLElementExport aElem( rExport, nNamespace,
+                                  aPropTokens[i].eToken,
+                                  bool(nFlags & SvXmlExportFlags::IGN_WS),
+                                  false );
+
+                exportElementItems( rExport, rProperties, nFlags, aIndexArray );
+            }
+        }
+    }
+}
+
+/** this method is called for every item that has the
+    MID_FLAG_SPECIAL_ITEM_EXPORT flag set */
+void SvXMLExportPropertyMapper::handleSpecialItem(
+        SvXMLAttributeList& rAttrList,
+        const XMLPropertyState& rProperty,
+        const SvXMLUnitConverter& rUnitConverter,
+        const SvXMLNamespaceMap& rNamespaceMap,
+        const ::std::vector< XMLPropertyState > *pProperties,
+        sal_uInt32 nIdx ) const
+{
+    OSL_ENSURE(mpImpl->mxNextMapper.is(), "special item not handled in xml export");
+    if (mpImpl->mxNextMapper.is())
+        mpImpl->mxNextMapper->handleSpecialItem(
+            rAttrList, rProperty, rUnitConverter, rNamespaceMap, pProperties, nIdx);
+}
+
+/** this method is called for every item that has the
+    MID_FLAG_ELEMENT_EXPORT flag set */
+void SvXMLExportPropertyMapper::handleElementItem(
+        SvXMLExport& rExport,
+        const XMLPropertyState& rProperty,
+        SvXmlExportFlags nFlags,
+        const ::std::vector< XMLPropertyState > *pProperties,
+        sal_uInt32 nIdx ) const
+{
+    OSL_ENSURE(mpImpl->mxNextMapper.is(), "element item not handled in xml export");
+    if (mpImpl->mxNextMapper.is())
+        mpImpl->mxNextMapper->handleElementItem(rExport, rProperty, nFlags, pProperties, nIdx);
+}
+
+// protected methods
+
+/** fills the given attribute list with the items in the given set */
+void SvXMLExportPropertyMapper::_exportXML(
+        sal_uInt16 nPropType, sal_uInt16& rPropTypeFlags,
+        SvXMLAttributeList& rAttrList,
+        const ::std::vector< XMLPropertyState >& rProperties,
+        const SvXMLUnitConverter& rUnitConverter,
+        const SvXMLNamespaceMap& rNamespaceMap,
+        std::vector<sal_uInt16>* pIndexArray,
+        sal_Int32 nPropMapStartIdx, sal_Int32 nPropMapEndIdx ) const
+{
+    const sal_uInt32 nCount = rProperties.size();
+    sal_uInt32 nIndex = 0;
+
+    if( -1 == nPropMapStartIdx )
+        nPropMapStartIdx = 0;
+    if( -1 == nPropMapEndIdx )
+        nPropMapEndIdx = mpImpl->mxPropMapper->GetEntryCount();
+
+    while( nIndex < nCount )
+    {
+        sal_Int32 nPropMapIdx = rProperties[nIndex].mnIndex;
+        if( nPropMapIdx >= nPropMapStartIdx &&
+            nPropMapIdx < nPropMapEndIdx  )// valid entry?
+        {
+            sal_uInt32 nEFlags = mpImpl->mxPropMapper->GetEntryFlags(nPropMapIdx);
+            sal_uInt16 nEPType = GET_PROP_TYPE(nEFlags);
+            OSL_ENSURE(nEPType >= (XML_TYPE_PROP_START >> XML_TYPE_PROP_SHIFT),
+                       "no prop type specified");
+            rPropTypeFlags |= (1 << nEPType);
+            if( nEPType == nPropType )
+            {
+                // we have a valid map entry here, so lets use it...
+                if( ( nEFlags & MID_FLAG_ELEMENT_ITEM_EXPORT ) != 0 )
+                {
+                    // element items do not add any properties,
+                    // we export it later
+                    if( pIndexArray )
+                    {
+                        pIndexArray->push_back( static_cast<sal_uInt16>(nIndex) );
+                    }
+                }
+                else
+                {
+                    _exportXML( rAttrList, rProperties[nIndex], rUnitConverter,
+                                rNamespaceMap, &rProperties, nIndex );
+                }
+            }
+        }
+
+        nIndex++;
+    }
+}
+
+void SvXMLExportPropertyMapper::_exportXML(
+        SvXMLAttributeList& rAttrList,
+        const XMLPropertyState& rProperty,
+        const SvXMLUnitConverter& rUnitConverter,
+        const SvXMLNamespaceMap& rNamespaceMap,
+        const ::std::vector< XMLPropertyState > *pProperties,
+        sal_uInt32 nIdx ) const
+{
+    if ((mpImpl->mxPropMapper->GetEntryFlags(rProperty.mnIndex) & MID_FLAG_SPECIAL_ITEM_EXPORT) != 0)
+    {
+        uno::Reference< container::XNameContainer > xAttrContainer;
+        if( (rProperty.maValue >>= xAttrContainer) && xAttrContainer.is() )
+        {
+            std::unique_ptr<SvXMLNamespaceMap> pNewNamespaceMap;
+            const SvXMLNamespaceMap *pNamespaceMap = &rNamespaceMap;
+
+            const uno::Sequence< OUString > aAttribNames( xAttrContainer->getElementNames() );
+
+            OUStringBuffer sNameBuffer;
+            xml::AttributeData aData;
+            for( const auto& rAttribName : aAttribNames )
+            {
+                xAttrContainer->getByName( rAttribName ) >>= aData;
+                OUString sAttribName( rAttribName );
+
+                // extract namespace prefix from attribute name if it exists
+                OUString sPrefix;
+                const sal_Int32 nColonPos =
+                    rAttribName.indexOf( ':' );
+                if( nColonPos != -1 )
+                    sPrefix = rAttribName.copy( 0, nColonPos );
+
+                if( !sPrefix.isEmpty() )
+                {
+                    OUString sNamespace( aData.Namespace );
+
+                    // if the prefix isn't defined yet or has another meaning,
+                    // we have to redefine it now.
+                    sal_uInt16 nKey = pNamespaceMap->GetKeyByPrefix( sPrefix );
+                    if( USHRT_MAX == nKey || pNamespaceMap->GetNameByKey( nKey ) != sNamespace )
+                    {
+                        bool bAddNamespace = false;
+                        if( USHRT_MAX == nKey )
+                        {
+                            // The prefix is unused, so it is sufficient
+                            // to add it to the namespace map.
+                            bAddNamespace = true;
+                        }
+                        else
+                        {
+                            // check if there is a prefix registered for the
+                            // namespace URI
+                            nKey = pNamespaceMap->GetKeyByName( sNamespace );
+                            if( XML_NAMESPACE_UNKNOWN == nKey )
+                            {
+                                // There is no prefix for the namespace, so
+                                // we have to generate one and have to add it.
+                                sal_Int32 n=0;
+                                OUString sOrigPrefix( sPrefix );
+                                do
+                                {
+                                    sNameBuffer.append( sOrigPrefix );
+                                    sNameBuffer.append( ++n );
+                                    sPrefix = sNameBuffer.makeStringAndClear();
+                                    nKey = pNamespaceMap->GetKeyByPrefix( sPrefix );
+                                }
+                                while( nKey != USHRT_MAX );
+
+                                bAddNamespace = true;
+                            }
+                            else
+                            {
+                                // If there is a prefix for the namespace,
+                                // we reuse that.
+                                sPrefix = pNamespaceMap->GetPrefixByKey( nKey );
+                            }
+                            // In any case, the attribute name has to be adapted.
+                            sNameBuffer.append(sPrefix).append(":").append(std::u16string_view(rAttribName).substr(nColonPos+1) );
+                            sAttribName = sNameBuffer.makeStringAndClear();
+                        }
+
+                        if( bAddNamespace )
+                        {
+                            if( !pNewNamespaceMap )
+                            {
+                                pNewNamespaceMap.reset(new SvXMLNamespaceMap( rNamespaceMap ));
+                                pNamespaceMap = pNewNamespaceMap.get();
+                            }
+                            pNewNamespaceMap->Add( sPrefix, sNamespace );
+                            sNameBuffer.append( GetXMLToken(XML_XMLNS) ).append( ":" ).append( sPrefix );
+                            rAttrList.AddAttribute( sNameBuffer.makeStringAndClear(),
+                                                    sNamespace );
+                        }
+                    }
+                }
+                OUString sOldValue( rAttrList.getValueByName( sAttribName ) );
+                OSL_ENSURE( sOldValue.isEmpty(), "alien attribute exists already" );
+                OSL_ENSURE(aData.Type == GetXMLToken(XML_CDATA), "different type to our default type which should be written out");
+                if( sOldValue.isEmpty() )
+                    rAttrList.AddAttribute( sAttribName, aData.Value );
+            }
+        }
+        else
+        {
+            handleSpecialItem( rAttrList, rProperty, rUnitConverter,
+                               rNamespaceMap, pProperties, nIdx );
+        }
+    }
+    else if ((mpImpl->mxPropMapper->GetEntryFlags(rProperty.mnIndex) & MID_FLAG_ELEMENT_ITEM_EXPORT ) == 0)
+    {
+        OUString aValue;
+        OUString sName = rNamespaceMap.GetQNameByKey(
+            mpImpl->mxPropMapper->GetEntryNameSpace(rProperty.mnIndex),
+            mpImpl->mxPropMapper->GetEntryXMLName(rProperty.mnIndex));
+
+        bool bRemove = false;
+        if ((mpImpl->mxPropMapper->GetEntryFlags( rProperty.mnIndex ) & MID_FLAG_MERGE_ATTRIBUTE) != 0)
+        {
+            aValue = rAttrList.getValueByName( sName );
+            bRemove = true;
+        }
+
+        if (mpImpl->mxPropMapper->exportXML(aValue, rProperty, rUnitConverter))
+        {
+            if( bRemove )
+                rAttrList.RemoveAttribute( sName );
+
+            // We don't seem to have a generic mechanism to write an attribute in the extension
+            // namespace in case of certain attribute values only, so do this manually.
+            if (IsXMLToken(mpImpl->mxPropMapper->GetEntryXMLName(rProperty.mnIndex), XML_WRITING_MODE))
+            {
+                if (IsXMLToken(aValue, XML_BT_LR))
+                {
+                    sName = rNamespaceMap.GetQNameByKey(
+                            XML_NAMESPACE_LO_EXT,
+                            mpImpl->mxPropMapper->GetEntryXMLName(rProperty.mnIndex));
+                }
+            }
+            else if (IsXMLToken(mpImpl->mxPropMapper->GetEntryXMLName(rProperty.mnIndex), XML_VERTICAL_REL))
+            {
+                if (IsXMLToken(aValue, XML_PAGE_CONTENT_BOTTOM))
+                {
+                    sName = rNamespaceMap.GetQNameByKey(
+                            XML_NAMESPACE_LO_EXT,
+                            mpImpl->mxPropMapper->GetEntryXMLName(rProperty.mnIndex));
+                }
+            }
+
+            rAttrList.AddAttribute( sName, aValue );
+        }
+    }
+}
+
+void SvXMLExportPropertyMapper::exportElementItems(
+        SvXMLExport& rExport,
+        const ::std::vector< XMLPropertyState >& rProperties,
+        SvXmlExportFlags nFlags,
+        const std::vector<sal_uInt16>& rIndexArray ) const
+{
+    bool bItemsExported = false;
+    for (const sal_uInt16 nElement : rIndexArray)
+    {
+        OSL_ENSURE( 0 != (mpImpl->mxPropMapper->GetEntryFlags(
+                rProperties[nElement].mnIndex ) & MID_FLAG_ELEMENT_ITEM_EXPORT),
+                "wrong mid flag!" );
+
+        rExport.IgnorableWhitespace();
+        handleElementItem( rExport, rProperties[nElement],
+                           nFlags, &rProperties, nElement );
+        bItemsExported = true;
+    }
+
+    if( bItemsExported )
+        rExport.IgnorableWhitespace();
+}
+
+const rtl::Reference<XMLPropertySetMapper>& SvXMLExportPropertyMapper::getPropertySetMapper() const
+{
+    return mpImpl->mxPropMapper;
+}
+
+void SvXMLExportPropertyMapper::SetStyleName( const OUString& rStyleName )
+{
+    mpImpl->maStyleName = rStyleName;
+}
+
+const OUString& SvXMLExportPropertyMapper::GetStyleName() const
+{
+    return mpImpl->maStyleName;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */