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, 887 insertions, 0 deletions

diff --git a/xmloff/source/style/xmlstyle.cxx b/xmloff/source/style/xmlstyle.cxx
new file mode 100644
index 000000000..f6eeb70de
--- /dev/null
+++ b/xmloff/source/style/xmlstyle.cxx
@@ -0,0 +1,887 @@
+/* -*- 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 <sal/config.h>
+
+#include <com/sun/star/frame/XModel.hpp>
+#include <com/sun/star/xml/sax/XAttributeList.hpp>
+#include <com/sun/star/container/XNameContainer.hpp>
+#include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
+#include <com/sun/star/style/XAutoStylesSupplier.hpp>
+#include <com/sun/star/style/XAutoStyleFamily.hpp>
+#include <PageMasterPropMapper.hxx>
+#include <sal/log.hxx>
+#include <svl/style.hxx>
+#include <xmloff/nmspmap.hxx>
+#include <xmloff/xmlnmspe.hxx>
+#include <xmloff/xmltoken.hxx>
+
+#include <xmloff/families.hxx>
+#include <xmloff/xmlimp.hxx>
+#include <xmloff/xmlnumi.hxx>
+#include <xmloff/xmlimppr.hxx>
+#include <xmloff/xmlstyle.hxx>
+#include <xmloff/txtstyli.hxx>
+#include <xmloff/xmlnumfi.hxx>
+#include <XMLChartStyleContext.hxx>
+#include <XMLChartPropertySetMapper.hxx>
+#include <xmloff/XMLShapeStyleContext.hxx>
+#include "FillStyleContext.hxx"
+#include <XMLFootnoteConfigurationImportContext.hxx>
+#include <XMLIndexBibliographyConfigurationContext.hxx>
+#include <XMLLineNumberingImportContext.hxx>
+#include <PageMasterImportContext.hxx>
+#include "PageMasterImportPropMapper.hxx"
+
+#include <memory>
+#include <set>
+#include <vector>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::style;
+using namespace ::xmloff::token;
+
+static const SvXMLTokenMapEntry aStyleStylesElemTokenMap[] =
+{
+    { XML_NAMESPACE_STYLE,  XML_STYLE,          XML_TOK_STYLE_STYLE                },
+    { XML_NAMESPACE_STYLE,  XML_PAGE_LAYOUT,    XML_TOK_STYLE_PAGE_MASTER          },
+    { XML_NAMESPACE_TEXT,   XML_LIST_STYLE,     XML_TOK_TEXT_LIST_STYLE            },
+    { XML_NAMESPACE_TEXT,   XML_OUTLINE_STYLE,  XML_TOK_TEXT_OUTLINE               },
+    { XML_NAMESPACE_STYLE,  XML_DEFAULT_STYLE,  XML_TOK_STYLE_DEFAULT_STYLE        },
+    { XML_NAMESPACE_DRAW,   XML_GRADIENT,       XML_TOK_STYLES_GRADIENTSTYLES      },
+    { XML_NAMESPACE_DRAW,   XML_HATCH,          XML_TOK_STYLES_HATCHSTYLES         },
+    { XML_NAMESPACE_DRAW,   XML_FILL_IMAGE,     XML_TOK_STYLES_BITMAPSTYLES        },
+    { XML_NAMESPACE_DRAW,   XML_OPACITY,        XML_TOK_STYLES_TRANSGRADIENTSTYLES },
+    { XML_NAMESPACE_DRAW,   XML_MARKER,         XML_TOK_STYLES_MARKERSTYLES        },
+    { XML_NAMESPACE_DRAW,   XML_STROKE_DASH,    XML_TOK_STYLES_DASHSTYLES        },
+    { XML_NAMESPACE_TEXT,   XML_NOTES_CONFIGURATION,    XML_TOK_TEXT_NOTE_CONFIG },
+    { XML_NAMESPACE_TEXT,   XML_BIBLIOGRAPHY_CONFIGURATION, XML_TOK_TEXT_BIBLIOGRAPHY_CONFIG },
+    { XML_NAMESPACE_TEXT,   XML_LINENUMBERING_CONFIGURATION,XML_TOK_TEXT_LINENUMBERING_CONFIG },
+    { XML_NAMESPACE_STYLE,  XML_DEFAULT_PAGE_LAYOUT,    XML_TOK_STYLE_DEFAULT_PAGE_LAYOUT        },
+    XML_TOKEN_MAP_END
+};
+
+static const OUStringLiteral gsParaStyleServiceName( "com.sun.star.style.ParagraphStyle" );
+static const OUStringLiteral gsTextStyleServiceName( "com.sun.star.style.CharacterStyle" );
+
+const SvXMLTokenMap& SvXMLStylesContext::GetStyleStylesElemTokenMap()
+{
+    if( !mpStyleStylesElemTokenMap )
+        mpStyleStylesElemTokenMap.reset(
+            new SvXMLTokenMap( aStyleStylesElemTokenMap ) );
+
+    return *mpStyleStylesElemTokenMap;
+}
+
+void SvXMLStyleContext::SetAttribute( sal_uInt16 nPrefixKey,
+                                      const OUString& rLocalName,
+                                      const OUString& rValue )
+{
+    // TODO: use a map here
+    if( XML_NAMESPACE_STYLE == nPrefixKey )
+    {
+        if( IsXMLToken( rLocalName, XML_FAMILY ) )
+        {
+            if( IsXMLToken( rValue, XML_PARAGRAPH ) )
+                mnFamily = XmlStyleFamily(SfxStyleFamily::Para);
+            else if( IsXMLToken( rValue, XML_TEXT ) )
+                mnFamily = XmlStyleFamily(SfxStyleFamily::Char);
+        }
+        else if( IsXMLToken( rLocalName, XML_NAME ) )
+        {
+            maName = rValue;
+        }
+        else if( IsXMLToken( rLocalName, XML_DISPLAY_NAME ) )
+        {
+            maDisplayName = rValue;
+        }
+        else if( IsXMLToken( rLocalName, XML_PARENT_STYLE_NAME ) )
+        {
+            maParentName = rValue;
+        }
+        else if( IsXMLToken( rLocalName, XML_NEXT_STYLE_NAME ) )
+        {
+            maFollow = rValue;
+        }
+        else if( IsXMLToken( rLocalName, XML_HIDDEN ) )
+        {
+            mbHidden = rValue.toBoolean();
+        }
+    }
+    else if (XML_NAMESPACE_LO_EXT == nPrefixKey)
+    {
+        if (IsXMLToken(rLocalName, XML_HIDDEN))
+        {
+            mbHidden = rValue.toBoolean();
+        }
+    }
+}
+
+
+SvXMLStyleContext::SvXMLStyleContext(
+        SvXMLImport& rImp, sal_uInt16 nPrfx,
+        const OUString& rLName,
+        const uno::Reference< xml::sax::XAttributeList >&,
+        XmlStyleFamily nFam, bool bDefault ) :
+    SvXMLImportContext( rImp, nPrfx, rLName ),
+    mbHidden( false ),
+    mnFamily( nFam ),
+    mbValid( true ),
+    mbNew( true ),
+    mbDefaultStyle( bDefault )
+{
+}
+
+SvXMLStyleContext::SvXMLStyleContext(
+        SvXMLImport& rImp,
+        sal_Int32 /*nElement*/,
+        const css::uno::Reference< css::xml::sax::XFastAttributeList > &,
+        XmlStyleFamily nFam, bool bDefault ) :
+    SvXMLImportContext( rImp ),
+    mbHidden( false ),
+    mnFamily( nFam ),
+    mbValid( true ),
+    mbNew( true ),
+    mbDefaultStyle( bDefault )
+{
+}
+
+SvXMLStyleContext::~SvXMLStyleContext()
+{
+}
+
+void SvXMLStyleContext::StartElement( const uno::Reference< xml::sax::XAttributeList > & xAttrList )
+{
+    sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
+    for( sal_Int16 i=0; i < nAttrCount; i++ )
+    {
+        const OUString& rAttrName = xAttrList->getNameByIndex( i );
+        OUString aLocalName;
+        sal_uInt16 nPrefix = GetImport().GetNamespaceMap().GetKeyByAttrName( rAttrName, &aLocalName );
+        const OUString& rValue = xAttrList->getValueByIndex( i );
+
+        SetAttribute( nPrefix, aLocalName, rValue );
+    }
+}
+
+void SvXMLStyleContext::SetDefaults()
+{
+}
+
+void SvXMLStyleContext::CreateAndInsert( bool /*bOverwrite*/ )
+{
+}
+
+void SvXMLStyleContext::CreateAndInsertLate( bool /*bOverwrite*/ )
+{
+}
+
+void SvXMLStyleContext::Finish( bool /*bOverwrite*/ )
+{
+}
+
+bool SvXMLStyleContext::IsTransient() const
+{
+    return false;
+}
+
+namespace {
+
+class SvXMLStyleIndex_Impl
+{
+    OUString               sName;
+    XmlStyleFamily         nFamily;
+    const rtl::Reference<SvXMLStyleContext> mxStyle;
+
+public:
+
+    SvXMLStyleIndex_Impl( XmlStyleFamily nFam, const OUString& rName ) :
+        sName( rName ),
+        nFamily( nFam )
+    {
+    }
+
+    SvXMLStyleIndex_Impl( const rtl::Reference<SvXMLStyleContext> &rStl ) :
+        sName( rStl->GetName() ),
+        nFamily( rStl->GetFamily() ),
+        mxStyle ( rStl )
+    {
+    }
+
+    const OUString& GetName() const { return sName; }
+    XmlStyleFamily GetFamily() const { return nFamily; }
+    const SvXMLStyleContext *GetStyle() const { return mxStyle.get(); }
+};
+
+struct SvXMLStyleIndexCmp_Impl
+{
+    bool operator()(const SvXMLStyleIndex_Impl& r1, const SvXMLStyleIndex_Impl& r2) const
+    {
+        sal_Int32 nRet;
+
+        if( r1.GetFamily() < r2.GetFamily() )
+            nRet = -1;
+        else if( r1.GetFamily() > r2.GetFamily() )
+            nRet = 1;
+        else
+            nRet = r1.GetName().compareTo( r2.GetName() );
+
+        return nRet < 0;
+    }
+};
+
+}
+
+class SvXMLStylesContext_Impl
+{
+    typedef std::set<SvXMLStyleIndex_Impl, SvXMLStyleIndexCmp_Impl> IndicesType;
+
+    std::vector<rtl::Reference<SvXMLStyleContext>> aStyles;
+    mutable std::unique_ptr<IndicesType> pIndices;
+    bool bAutomaticStyle;
+
+#if OSL_DEBUG_LEVEL > 0
+    mutable sal_uInt32 m_nIndexCreated;
+#endif
+
+    void FlushIndex() { pIndices.reset(); }
+
+public:
+    explicit SvXMLStylesContext_Impl( bool bAuto );
+
+    size_t GetStyleCount() const { return aStyles.size(); }
+
+    SvXMLStyleContext *GetStyle( size_t i )
+    {
+        return i < aStyles.size() ? aStyles[ i ].get() : nullptr;
+    }
+
+    inline void AddStyle( SvXMLStyleContext *pStyle );
+    void Clear();
+
+    const SvXMLStyleContext *FindStyleChildContext( XmlStyleFamily nFamily,
+                                                    const OUString& rName,
+                                                    bool bCreateIndex ) const;
+    bool IsAutomaticStyle() const { return bAutomaticStyle; }
+};
+
+SvXMLStylesContext_Impl::SvXMLStylesContext_Impl( bool bAuto ) :
+    bAutomaticStyle( bAuto )
+#if OSL_DEBUG_LEVEL > 0
+    , m_nIndexCreated( 0 )
+#endif
+{}
+
+inline void SvXMLStylesContext_Impl::AddStyle( SvXMLStyleContext *pStyle )
+{
+    aStyles.emplace_back(pStyle );
+
+    FlushIndex();
+}
+
+void SvXMLStylesContext_Impl::Clear()
+{
+    FlushIndex();
+    aStyles.clear();
+}
+
+const SvXMLStyleContext *SvXMLStylesContext_Impl::FindStyleChildContext( XmlStyleFamily nFamily,
+                                                                         const OUString& rName,
+                                                                         bool bCreateIndex ) const
+{
+    const SvXMLStyleContext *pStyle = nullptr;
+
+    if( !pIndices && bCreateIndex && !aStyles.empty() )
+    {
+        pIndices = std::make_unique<IndicesType>(aStyles.begin(), aStyles.end());
+        SAL_WARN_IF(pIndices->size() != aStyles.size(), "xmloff.style", "Here is a duplicate Style");
+#if OSL_DEBUG_LEVEL > 0
+        SAL_WARN_IF(0 != m_nIndexCreated, "xmloff.style",
+                    "Performance warning: sdbcx::Index created multiple times");
+        ++m_nIndexCreated;
+#endif
+    }
+
+    if( pIndices )
+    {
+        SvXMLStyleIndex_Impl aIndex( nFamily, rName );
+        IndicesType::iterator aFind = pIndices->find(aIndex);
+        if( aFind != pIndices->end() )
+            pStyle = aFind->GetStyle();
+   }
+    else
+    {
+        for( size_t i = 0; !pStyle && i < aStyles.size(); i++ )
+        {
+            const SvXMLStyleContext *pS = aStyles[ i ].get();
+            if( pS->GetFamily() == nFamily &&
+                pS->GetName() == rName )
+                pStyle = pS;
+        }
+    }
+    return pStyle;
+}
+
+
+sal_uInt32 SvXMLStylesContext::GetStyleCount() const
+{
+    return mpImpl->GetStyleCount();
+}
+
+SvXMLStyleContext *SvXMLStylesContext::GetStyle( sal_uInt32 i )
+{
+    return mpImpl->GetStyle( i );
+}
+
+const SvXMLStyleContext *SvXMLStylesContext::GetStyle( sal_uInt32 i ) const
+{
+    return mpImpl->GetStyle( i );
+}
+
+bool SvXMLStylesContext::IsAutomaticStyle() const
+{
+    return mpImpl->IsAutomaticStyle();
+}
+
+SvXMLStyleContext *SvXMLStylesContext::CreateStyleChildContext( sal_uInt16 p_nPrefix,
+                                                                const OUString& rLocalName,
+                                                                const uno::Reference< xml::sax::XAttributeList > & xAttrList )
+{
+    SvXMLStyleContext *pStyle = nullptr;
+
+    if(GetImport().GetDataStylesImport())
+    {
+        pStyle = GetImport().GetDataStylesImport()->CreateChildContext(GetImport(), p_nPrefix,
+                                               rLocalName, xAttrList, *this);
+    }
+
+    if (!pStyle)
+    {
+        const SvXMLTokenMap& rTokenMap = GetStyleStylesElemTokenMap();
+        sal_uInt16 nToken = rTokenMap.Get( p_nPrefix, rLocalName );
+        switch( nToken )
+        {
+            case XML_TOK_STYLE_STYLE:
+            case XML_TOK_STYLE_DEFAULT_STYLE:
+            {
+                XmlStyleFamily nFamily = XmlStyleFamily::DATA_STYLE;
+                sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
+                for( sal_Int16 i=0; i < nAttrCount; i++ )
+                {
+                    const OUString& rAttrName = xAttrList->getNameByIndex( i );
+                    OUString aLocalName;
+                    sal_uInt16 nPrefix =
+                        GetImport().GetNamespaceMap().GetKeyByAttrName( rAttrName,
+                                                                    &aLocalName );
+                    if( XML_NAMESPACE_STYLE == nPrefix &&
+                        IsXMLToken( aLocalName, XML_FAMILY ) )
+                    {
+                        const OUString& rValue = xAttrList->getValueByIndex( i );
+                        nFamily = GetFamily( rValue );
+                        break;
+                    }
+                }
+                pStyle = XML_TOK_STYLE_STYLE==nToken
+                    ? CreateStyleStyleChildContext( nFamily, p_nPrefix,
+                                                    rLocalName, xAttrList )
+                    : CreateDefaultStyleStyleChildContext( nFamily, p_nPrefix,
+                                                    rLocalName, xAttrList );
+            }
+            break;
+            case XML_TOK_STYLE_PAGE_MASTER:
+            case XML_TOK_STYLE_DEFAULT_PAGE_LAYOUT:
+            {
+                //there is not page family in ODF now, so I specify one for it
+                bool bDefaultStyle  = XML_TOK_STYLE_DEFAULT_PAGE_LAYOUT == nToken;
+                pStyle = new PageStyleContext( GetImport(), p_nPrefix,
+                                                    rLocalName, xAttrList, *this, bDefaultStyle );
+            }
+            break;
+            case XML_TOK_TEXT_LIST_STYLE:
+                pStyle = new SvxXMLListStyleContext( GetImport(), p_nPrefix,
+                                                    rLocalName, xAttrList );
+                break;
+            case XML_TOK_TEXT_OUTLINE:
+                pStyle = new SvxXMLListStyleContext( GetImport(), p_nPrefix,
+                                                    rLocalName, xAttrList, true );
+                break;
+            case XML_TOK_TEXT_NOTE_CONFIG:
+                pStyle = new XMLFootnoteConfigurationImportContext(GetImport(),
+                                                                   p_nPrefix,
+                                                                   rLocalName,
+                                                                   xAttrList);
+                break;
+
+            case XML_TOK_TEXT_BIBLIOGRAPHY_CONFIG:
+                pStyle = new XMLIndexBibliographyConfigurationContext(
+                    GetImport(), p_nPrefix, rLocalName, xAttrList);
+                break;
+
+            case XML_TOK_TEXT_LINENUMBERING_CONFIG:
+                pStyle = new XMLLineNumberingImportContext(
+                    GetImport(), p_nPrefix, rLocalName, xAttrList);
+                break;
+
+
+            // FillStyles
+
+            case XML_TOK_STYLES_GRADIENTSTYLES:
+            {
+                pStyle = new XMLGradientStyleContext( GetImport(), p_nPrefix, rLocalName, xAttrList );
+                break;
+            }
+            case XML_TOK_STYLES_HATCHSTYLES:
+            {
+                pStyle = new XMLHatchStyleContext( GetImport(), p_nPrefix, rLocalName, xAttrList );
+                break;
+            }
+            case XML_TOK_STYLES_BITMAPSTYLES:
+            {
+                pStyle = new XMLBitmapStyleContext( GetImport(), p_nPrefix, rLocalName, xAttrList );
+                break;
+            }
+            case XML_TOK_STYLES_TRANSGRADIENTSTYLES:
+            {
+                pStyle = new XMLTransGradientStyleContext( GetImport(), p_nPrefix, rLocalName, xAttrList );
+                break;
+            }
+            case XML_TOK_STYLES_MARKERSTYLES:
+            {
+                pStyle = new XMLMarkerStyleContext( GetImport(), p_nPrefix, rLocalName, xAttrList );
+                break;
+            }
+            case XML_TOK_STYLES_DASHSTYLES:
+            {
+                pStyle = new XMLDashStyleContext( GetImport(), p_nPrefix, rLocalName, xAttrList );
+                break;
+            }
+        }
+    }
+
+    return pStyle;
+}
+
+SvXMLStyleContext *SvXMLStylesContext::CreateStyleStyleChildContext(
+        XmlStyleFamily nFamily, sal_uInt16 nPrefix, const OUString& rLocalName,
+        const uno::Reference< xml::sax::XAttributeList > & xAttrList )
+{
+    SvXMLStyleContext *pStyle = nullptr;
+
+    switch( nFamily )
+    {
+        case XmlStyleFamily::TEXT_PARAGRAPH:
+        case XmlStyleFamily::TEXT_TEXT:
+        case XmlStyleFamily::TEXT_SECTION:
+            pStyle = new XMLTextStyleContext( GetImport(), nPrefix, rLocalName,
+                                              xAttrList, *this, nFamily );
+            break;
+
+        case XmlStyleFamily::TEXT_RUBY:
+            pStyle = new XMLPropStyleContext( GetImport(), nPrefix, rLocalName,
+                                              xAttrList, *this, nFamily );
+            break;
+        case XmlStyleFamily::SCH_CHART_ID:
+            pStyle = new XMLChartStyleContext( GetImport(), nPrefix, rLocalName,
+                                               xAttrList, *this, nFamily );
+            break;
+
+        case XmlStyleFamily::SD_GRAPHICS_ID:
+        case XmlStyleFamily::SD_PRESENTATION_ID:
+        case XmlStyleFamily::SD_POOL_ID:
+            pStyle = new XMLShapeStyleContext( GetImport(), nPrefix, rLocalName,
+                                               xAttrList, *this, nFamily );
+            break;
+        default: break;
+    }
+
+    return pStyle;
+}
+
+SvXMLStyleContext *SvXMLStylesContext::CreateDefaultStyleStyleChildContext(
+        XmlStyleFamily /*nFamily*/, sal_uInt16 /*nPrefix*/, const OUString& /*rLocalName*/,
+        const uno::Reference< xml::sax::XAttributeList > & )
+{
+    return nullptr;
+}
+
+bool SvXMLStylesContext::InsertStyleFamily( XmlStyleFamily ) const
+{
+    return true;
+}
+
+XmlStyleFamily SvXMLStylesContext::GetFamily( const OUString& rValue )
+{
+    XmlStyleFamily nFamily = XmlStyleFamily::DATA_STYLE;
+    if( IsXMLToken( rValue, XML_PARAGRAPH ) )
+    {
+        nFamily = XmlStyleFamily::TEXT_PARAGRAPH;
+    }
+    else if( IsXMLToken( rValue, XML_TEXT ) )
+    {
+        nFamily = XmlStyleFamily::TEXT_TEXT;
+    }
+    else if( IsXMLToken( rValue, XML_DATA_STYLE ) )
+    {
+        nFamily = XmlStyleFamily::DATA_STYLE;
+    }
+    else if ( IsXMLToken( rValue, XML_SECTION ) )
+    {
+        nFamily = XmlStyleFamily::TEXT_SECTION;
+    }
+    else if( IsXMLToken( rValue, XML_TABLE ) )
+    {
+        nFamily = XmlStyleFamily::TABLE_TABLE;
+    }
+    else if( IsXMLToken( rValue, XML_TABLE_COLUMN ) )
+        nFamily = XmlStyleFamily::TABLE_COLUMN;
+    else if( IsXMLToken( rValue, XML_TABLE_ROW ) )
+        nFamily = XmlStyleFamily::TABLE_ROW;
+    else if( IsXMLToken( rValue, XML_TABLE_CELL ) )
+        nFamily = XmlStyleFamily::TABLE_CELL;
+    else if ( rValue == XML_STYLE_FAMILY_SD_GRAPHICS_NAME )
+    {
+        nFamily = XmlStyleFamily::SD_GRAPHICS_ID;
+    }
+    else if ( rValue == XML_STYLE_FAMILY_SD_PRESENTATION_NAME )
+    {
+        nFamily = XmlStyleFamily::SD_PRESENTATION_ID;
+    }
+    else if ( rValue == XML_STYLE_FAMILY_SD_POOL_NAME )
+    {
+        nFamily = XmlStyleFamily::SD_POOL_ID;
+    }
+    else if ( rValue == XML_STYLE_FAMILY_SD_DRAWINGPAGE_NAME )
+    {
+        nFamily = XmlStyleFamily::SD_DRAWINGPAGE_ID;
+    }
+    else if ( rValue == XML_STYLE_FAMILY_SCH_CHART_NAME )
+    {
+        nFamily = XmlStyleFamily::SCH_CHART_ID;
+    }
+    else if ( IsXMLToken( rValue, XML_RUBY ) )
+    {
+        nFamily = XmlStyleFamily::TEXT_RUBY;
+    }
+
+    return nFamily;
+}
+
+rtl::Reference < SvXMLImportPropertyMapper > SvXMLStylesContext::GetImportPropertyMapper(
+                        XmlStyleFamily nFamily ) const
+{
+    rtl::Reference < SvXMLImportPropertyMapper > xMapper;
+
+    switch( nFamily )
+    {
+    case XmlStyleFamily::TEXT_PARAGRAPH:
+        if( !mxParaImpPropMapper.is() )
+        {
+            SvXMLStylesContext * pThis = const_cast<SvXMLStylesContext *>(this);
+            pThis->mxParaImpPropMapper =
+                pThis->GetImport().GetTextImport()
+                     ->GetParaImportPropertySetMapper();
+        }
+        xMapper = mxParaImpPropMapper;
+        break;
+    case XmlStyleFamily::TEXT_TEXT:
+        if( !mxTextImpPropMapper.is() )
+        {
+            SvXMLStylesContext * pThis = const_cast<SvXMLStylesContext *>(this);
+            pThis->mxTextImpPropMapper =
+                pThis->GetImport().GetTextImport()
+                     ->GetTextImportPropertySetMapper();
+        }
+        xMapper = mxTextImpPropMapper;
+        break;
+
+    case XmlStyleFamily::TEXT_SECTION:
+        // don't cache section mapper, as it's rarely used
+        // *sigh*, cast to non-const, because this is a const method,
+        // but SvXMLImport::GetTextImport() isn't.
+        xMapper = const_cast<SvXMLStylesContext*>(this)->GetImport().GetTextImport()->
+            GetSectionImportPropertySetMapper();
+        break;
+
+    case XmlStyleFamily::TEXT_RUBY:
+        // don't cache section mapper, as it's rarely used
+        // *sigh*, cast to non-const, because this is a const method,
+        // but SvXMLImport::GetTextImport() isn't.
+        xMapper = const_cast<SvXMLStylesContext*>(this)->GetImport().GetTextImport()->
+            GetRubyImportPropertySetMapper();
+        break;
+
+    case XmlStyleFamily::SD_GRAPHICS_ID:
+    case XmlStyleFamily::SD_PRESENTATION_ID:
+    case XmlStyleFamily::SD_POOL_ID:
+        if(!mxShapeImpPropMapper.is())
+        {
+            rtl::Reference< XMLShapeImportHelper > aImpHelper = const_cast<SvXMLImport&>(GetImport()).GetShapeImport();
+            const_cast<SvXMLStylesContext*>(this)->mxShapeImpPropMapper =
+                aImpHelper->GetPropertySetMapper();
+        }
+        xMapper = mxShapeImpPropMapper;
+        break;
+    case XmlStyleFamily::SCH_CHART_ID:
+        if( ! mxChartImpPropMapper.is() )
+        {
+            XMLPropertySetMapper *const pPropMapper = new XMLChartPropertySetMapper(nullptr);
+            mxChartImpPropMapper = new XMLChartImportPropertyMapper( pPropMapper, GetImport() );
+        }
+        xMapper = mxChartImpPropMapper;
+        break;
+    case XmlStyleFamily::PAGE_MASTER:
+        if( ! mxPageImpPropMapper.is() )
+        {
+            XMLPropertySetMapper *pPropMapper =
+                new XMLPageMasterPropSetMapper();
+            mxPageImpPropMapper =
+                new PageMasterImportPropertyMapper( pPropMapper,
+                                    const_cast<SvXMLStylesContext*>(this)->GetImport() );
+        }
+        xMapper = mxPageImpPropMapper;
+        break;
+    default: break;
+    }
+
+    return xMapper;
+}
+
+Reference < XAutoStyleFamily > SvXMLStylesContext::GetAutoStyles( XmlStyleFamily nFamily ) const
+{
+    Reference < XAutoStyleFamily > xAutoStyles;
+    if( XmlStyleFamily::TEXT_TEXT == nFamily || XmlStyleFamily::TEXT_PARAGRAPH == nFamily)
+    {
+        bool bPara = XmlStyleFamily::TEXT_PARAGRAPH == nFamily;
+        OUString sName;
+        if( !bPara && mxTextAutoStyles.is() )
+            xAutoStyles = mxTextAutoStyles;
+        else if( bPara && mxParaAutoStyles.is() )
+            xAutoStyles = mxParaAutoStyles;
+        else
+        {
+            sName = bPara ? OUStringLiteral( "ParagraphStyles" ): OUStringLiteral( "CharacterStyles" );
+            Reference< XAutoStylesSupplier > xAutoStylesSupp(   GetImport().GetModel(), UNO_QUERY );
+            Reference< XAutoStyles > xAutoStyleFamilies = xAutoStylesSupp->getAutoStyles();
+            if (xAutoStyleFamilies->hasByName(sName))
+            {
+                Any aAny = xAutoStyleFamilies->getByName( sName );
+                aAny >>= xAutoStyles;
+                if( bPara )
+                    const_cast<SvXMLStylesContext *>(this)->mxParaAutoStyles = xAutoStyles;
+                else
+                    const_cast<SvXMLStylesContext *>(this)->mxTextAutoStyles = xAutoStyles;
+            }
+        }
+    }
+    return xAutoStyles;
+}
+
+Reference < XNameContainer > SvXMLStylesContext::GetStylesContainer(
+                                                XmlStyleFamily nFamily ) const
+{
+    Reference < XNameContainer > xStyles;
+    OUString sName;
+    switch( nFamily )
+    {
+    case XmlStyleFamily::TEXT_PARAGRAPH:
+        if( mxParaStyles.is() )
+            xStyles = mxParaStyles;
+        else
+            sName = "ParagraphStyles";
+        break;
+
+    case XmlStyleFamily::TEXT_TEXT:
+        if( mxTextStyles.is() )
+            xStyles = mxTextStyles;
+        else
+            sName = "CharacterStyles";
+        break;
+    default: break;
+    }
+    if( !xStyles.is() && !sName.isEmpty() )
+    {
+        Reference< XStyleFamiliesSupplier > xFamiliesSupp(
+                                        GetImport().GetModel(), UNO_QUERY );
+        if ( xFamiliesSupp.is() )
+        {
+            Reference< XNameAccess > xFamilies = xFamiliesSupp->getStyleFamilies();
+            if (xFamilies->hasByName(sName))
+            {
+                xStyles.set(xFamilies->getByName( sName ),uno::UNO_QUERY);
+
+                switch( nFamily )
+                {
+                case XmlStyleFamily::TEXT_PARAGRAPH:
+                    const_cast<SvXMLStylesContext *>(this)->mxParaStyles = xStyles;
+                    break;
+
+                case XmlStyleFamily::TEXT_TEXT:
+                    const_cast<SvXMLStylesContext *>(this)->mxTextStyles = xStyles;
+                    break;
+                default: break;
+                }
+            }
+        }
+    }
+
+    return xStyles;
+}
+
+OUString SvXMLStylesContext::GetServiceName( XmlStyleFamily nFamily ) const
+{
+    OUString sServiceName;
+    switch( nFamily )
+    {
+    case XmlStyleFamily::TEXT_PARAGRAPH:
+        sServiceName = gsParaStyleServiceName;
+        break;
+    case XmlStyleFamily::TEXT_TEXT:
+        sServiceName = gsTextStyleServiceName;
+        break;
+    default: break;
+    }
+
+    return sServiceName;
+}
+
+SvXMLStylesContext::SvXMLStylesContext( SvXMLImport& rImport, bool bAuto ) :
+    SvXMLImportContext( rImport ),
+    mpImpl( new SvXMLStylesContext_Impl( bAuto ) )
+{
+}
+
+SvXMLStylesContext::~SvXMLStylesContext()
+{
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > SvXMLStylesContext::createFastChildContext(
+        sal_Int32 /*nElement*/, const css::uno::Reference< css::xml::sax::XFastAttributeList >& /*xAttrList*/ )
+{
+    return nullptr;
+}
+
+SvXMLImportContextRef SvXMLStylesContext::CreateChildContext( sal_uInt16 nPrefix,
+                                                            const OUString& rLocalName,
+                                                            const uno::Reference< xml::sax::XAttributeList > & xAttrList )
+{
+    SvXMLImportContext *pContext = nullptr;
+
+    SvXMLStyleContext *pStyle =
+        CreateStyleChildContext( nPrefix, rLocalName, xAttrList );
+    if( pStyle )
+    {
+        if( !pStyle->IsTransient() )
+            mpImpl->AddStyle( pStyle );
+        pContext = pStyle;
+    }
+
+    return pContext;
+}
+
+void SvXMLStylesContext::EndElement()
+{
+}
+
+void SvXMLStylesContext::AddStyle(SvXMLStyleContext& rNew)
+{
+    mpImpl->AddStyle( &rNew );
+}
+
+void SvXMLStylesContext::Clear()
+{
+    mpImpl->Clear();
+}
+
+void SvXMLStylesContext::CopyAutoStylesToDoc()
+{
+    sal_uInt32 nCount = GetStyleCount();
+    sal_uInt32 i;
+    for( i = 0; i < nCount; i++ )
+    {
+        SvXMLStyleContext *pStyle = GetStyle( i );
+        if( !pStyle || ( pStyle->GetFamily() != XmlStyleFamily::TEXT_TEXT &&
+            pStyle->GetFamily() != XmlStyleFamily::TEXT_PARAGRAPH  &&
+            pStyle->GetFamily() != XmlStyleFamily::TABLE_CELL ) )
+            continue;
+        pStyle->CreateAndInsert( false );
+    }
+}
+
+void SvXMLStylesContext::CopyStylesToDoc( bool bOverwrite,
+                                          bool bFinish )
+{
+    // pass 1: create text, paragraph and frame styles
+    sal_uInt32 nCount = GetStyleCount();
+    sal_uInt32 i;
+
+    for( i = 0; i < nCount; i++ )
+    {
+        SvXMLStyleContext *pStyle = GetStyle( i );
+        if( !pStyle )
+            continue;
+
+        if (pStyle->IsDefaultStyle())
+        {
+            if (bOverwrite) pStyle->SetDefaults();
+        }
+        else if( InsertStyleFamily( pStyle->GetFamily() ) )
+            pStyle->CreateAndInsert( bOverwrite );
+    }
+
+    // pass 2: create list styles (they require char styles)
+    for( i=0; i<nCount; i++ )
+    {
+        SvXMLStyleContext *pStyle = GetStyle( i );
+        if( !pStyle || pStyle->IsDefaultStyle())
+            continue;
+
+        if( InsertStyleFamily( pStyle->GetFamily() ) )
+            pStyle->CreateAndInsertLate( bOverwrite );
+    }
+
+    // pass3: finish creation of styles
+    if( bFinish )
+        FinishStyles( bOverwrite );
+}
+
+void SvXMLStylesContext::FinishStyles( bool bOverwrite )
+{
+    sal_uInt32 nCount = GetStyleCount();
+    for( sal_uInt32 i=0; i<nCount; i++ )
+    {
+        SvXMLStyleContext *pStyle = GetStyle( i );
+        if( !pStyle || !pStyle->IsValid() || pStyle->IsDefaultStyle() )
+            continue;
+
+        if( InsertStyleFamily( pStyle->GetFamily() ) )
+            pStyle->Finish( bOverwrite );
+    }
+}
+
+const SvXMLStyleContext *SvXMLStylesContext::FindStyleChildContext(
+                                  XmlStyleFamily nFamily,
+                                  const OUString& rName,
+                                  bool bCreateIndex ) const
+{
+    return mpImpl->FindStyleChildContext( nFamily, rName, bCreateIndex );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */