Quelle  xmlstyle.cxx   Sprache: C

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

#include <sal/config.h>

#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/frame/XModel.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 <com/sun/star/drawing/XDrawPageSupplier.hpp>
#include <PageMasterPropMapper.hxx>

#include <comphelper/diagnose_ex.hxx>
#include <sal/log.hxx>
#include <svl/style.hxx>
#include <utility>
#include <xmloff/xmlnamespace.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 <XMLThemeContext.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 <string_view>
#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;

constexpr OUStringLiteral gsParaStyleServiceName( u"com.sun.star.style.ParagraphStyle" );
constexpr OUStringLiteral gsTextStyleServiceName( u"com.sun.star.style.CharacterStyle" );
constexpr OUString gsParagraphStyles(u"ParagraphStyles"_ustr);
constexpr OUString gsCharacterStyles(u"CharacterStyles"_ustr);

void SvXMLStyleContext::SetAttribute( sal_Int32 nElement,
                                      const OUString& rValue )
{
    switch (nElement)
    {
        case XML_ELEMENT(STYLE, XML_FAMILY):
        {
            if( IsXMLToken( rValue, XML_PARAGRAPH ) )
                mnFamily = XmlStyleFamily(SfxStyleFamily::Para);
            else if( IsXMLToken( rValue, XML_TEXT ) )
                mnFamily = XmlStyleFamily(SfxStyleFamily::Char);
            break;
        }
        case XML_ELEMENT(STYLE, XML_NAME):
            maName = rValue;
            break;
        case XML_ELEMENT(STYLE, XML_DISPLAY_NAME):
            maDisplayName = rValue;
            break;
        case XML_ELEMENT(STYLE, XML_PARENT_STYLE_NAME):
            maParentName = rValue;
            break;
        case XML_ELEMENT(STYLE, XML_NEXT_STYLE_NAME):
            maFollow = rValue;
            break;
        case XML_ELEMENT(LO_EXT, XML_LINKED_STYLE_NAME):
            maLinked = rValue;
            break;
        case XML_ELEMENT(STYLE, XML_HIDDEN):
        case XML_ELEMENT(LO_EXT, XML_HIDDEN):
            mbHidden = rValue.toBoolean();
            break;
    }
}


SvXMLStyleContext::SvXMLStyleContext(
        SvXMLImport& rImp,
        XmlStyleFamily nFam, bool bDefault ) :
    SvXMLImportContext( rImp ),
    mbHidden( false ),
    mnFamily( nFam ),
    mbValid( true ),
    mbNew( true ),
    mbDefaultStyle( bDefault )
{
}

SvXMLStyleContext::~SvXMLStyleContext()
{
}

void SvXMLStyleContext::startFastElement(
    sal_Int32 /*nElement*/,
    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
{
    for( auto &it : sax_fastparser::castToFastAttributeList( xAttrList ) )
        SetAttribute( it.getToken(), it.toString() );
}

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 {
struct StyleIndexCompareByName
{
    bool operator()(const SvXMLStyleContext* r1, const SvXMLStyleContext* r2) const
    {
        if( r1->GetFamily() < r2->GetFamily() )
            return true;
        if( r1->GetFamily() > r2->GetFamily() )
            return false;
        return r1->GetName() < r2->GetName();
    }
};
struct StyleIndexCompareByDisplayName
{
    bool operator()(const SvXMLStyleContext* r1, const SvXMLStyleContext* r2) const
    {
        if( r1->GetFamily() < r2->GetFamily() )
            return true;
        if( r1->GetFamily() > r2->GetFamily() )
            return false;
        return r1->GetDisplayName() < r2->GetDisplayName();
    }
};
}

class SvXMLStylesContext_Impl
{
    std::vector<rtl::Reference<SvXMLStyleContext>> aStyles;
    // it would be better if we could share one vector for the styles and the index, but some code in calc
    // is sensitive to having styles re-ordered
    mutable SvXMLStylesContext::StyleIndex maStylesIndexByName;
    mutable SvXMLStylesContext::StyleIndex maStylesIndexByDisplayName;
    bool bAutomaticStyle;

#if OSL_DEBUG_LEVEL > 0
    mutable sal_uInt32 m_nIndexCreated;
#endif

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 dispose();

    const SvXMLStyleContext *FindStyleChildContext( XmlStyleFamily nFamily,
                                                    const OUString& rName,
                                                    bool bCreateIndex ) const;

    std::pair<SvXMLStylesContext::StyleIndex::const_iterator, SvXMLStylesContext::StyleIndex::const_iterator>
    FindStyleChildContextByDisplayNamePrefix( XmlStyleFamily nFamily,
                                    const OUString& rPrefix ) const;

    bool IsAutomaticStyle() const { return bAutomaticStyle; }

private:
    void BuildNameIndex() const;
    void BuildDisplayNameIndex() const;
};

SvXMLStylesContext_Impl::SvXMLStylesContext_Impl( bool bAuto ) :
    bAutomaticStyle( bAuto )
#if OSL_DEBUG_LEVEL > 0
    , m_nIndexCreated( 0 )
#endif
{}

inline void SvXMLStylesContext_Impl::AddStyle( SvXMLStyleContext *pStyle )
{
#if OSL_DEBUG_LEVEL > 0
//    for (auto const & xStyle : aStyles)
//        if (xStyle->GetFamily() == pStyle->GetFamily() && xStyle->GetName() == pStyle->GetName())
//            assert(false && "duplicate style");
#endif
    aStyles.emplace_back(pStyle );

    maStylesIndexByName.clear();
    maStylesIndexByDisplayName.clear();
}

void SvXMLStylesContext_Impl::dispose()
{
    aStyles.clear();
}

const SvXMLStyleContext *SvXMLStylesContext_Impl::FindStyleChildContext( XmlStyleFamily nFamily,
                                                                         const OUString& rName,
                                                                         bool bCreateIndex ) const
{
    const SvXMLStyleContext *pStyle = nullptr;

    if( maStylesIndexByName.empty() && bCreateIndex && !aStyles.empty() )
        BuildNameIndex();

    if( !maStylesIndexByName.empty() )
    {
        auto it = std::lower_bound(maStylesIndexByName.begin(), maStylesIndexByName.end(), true,
            [&nFamily, &rName](const SvXMLStyleContext* lhs, bool /*rhs*/)
            {
                if (lhs->GetFamily() < nFamily)
                    return true;
                if (lhs->GetFamily() > nFamily)
                    return false;
                return lhs->GetName() < rName;
            });
        if (it != maStylesIndexByName.end() && (*it)->GetFamily() == nFamily && (*it)->GetName() == rName)
            pStyle = *it;
    }
    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;
}

namespace
{
struct PrefixProbeLowerBound
{
    XmlStyleFamily nFamily;
    const OUString& rPrefix;

    bool operator()(const SvXMLStyleContext* lhs, bool /*rhs*/)
    {
        if (lhs->GetFamily() < nFamily)
            return true;
        if (lhs->GetFamily() > nFamily)
            return false;
        return lhs->GetDisplayName() < rPrefix;
    }
};
struct PrefixProbeUpperBound
{
    XmlStyleFamily nFamily;
    const OUString& rPrefix;

    bool operator()(bool /*lhs*/, const SvXMLStyleContext* rhs)
    {
        if (nFamily < rhs->GetFamily())
            return true;
        if (nFamily > rhs->GetFamily())
            return false;
        std::u16string_view rhsName = rhs->GetDisplayName();
        // For the upper bound we want to view the vector's data as if
        // every element was truncated to the size of the prefix.
        // Then perform a normal match.
        rhsName = rhsName.substr(0, rPrefix.getLength());
        // compare UP TO the length of the prefix and no farther
        if (int cmp = rPrefix.compareTo(rhsName))
            return cmp < 0;
        // The strings are equal to the length of the prefix so
        // behave as if they are equal. That means s1 < s2 == false
        return false;
    }
};
}

std::pair<SvXMLStylesContext::StyleIndex::const_iterator, SvXMLStylesContext::StyleIndex::const_iterator>
SvXMLStylesContext_Impl::FindStyleChildContextByDisplayNamePrefix( XmlStyleFamily nFamily,
                                                        const OUString& rPrefix ) const
{
    if( maStylesIndexByDisplayName.empty() )
        BuildDisplayNameIndex();
    auto itStart = std::lower_bound(maStylesIndexByDisplayName.begin(), maStylesIndexByDisplayName.end(), true, PrefixProbeLowerBound{nFamily,rPrefix});
    auto itEnd = std::upper_bound(itStart, maStylesIndexByDisplayName.end(), true, PrefixProbeUpperBound{nFamily,rPrefix});
    return {itStart, itEnd};
}

void SvXMLStylesContext_Impl::BuildNameIndex() const
{
    maStylesIndexByName.reserve(aStyles.size());

    for (const auto & i : aStyles)
        maStylesIndexByName.push_back(i.get());
    std::sort(maStylesIndexByName.begin(), maStylesIndexByName.end(), StyleIndexCompareByName());

#if OSL_DEBUG_LEVEL > 0
    SAL_WARN_IF(0 != m_nIndexCreated, "xmloff.style",
                "Performance warning: sdbcx::Index created multiple times");
    ++m_nIndexCreated;
#endif
}

void SvXMLStylesContext_Impl::BuildDisplayNameIndex() const
{
    maStylesIndexByDisplayName.reserve(aStyles.size());
    for (const auto & i : aStyles)
        maStylesIndexByDisplayName.push_back(i.get());
    std::sort(maStylesIndexByDisplayName.begin(), maStylesIndexByDisplayName.end(), StyleIndexCompareByDisplayName());
}

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_Int32 nElement,
        const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList)
{
    SvXMLStyleContext *pStyle = nullptr;

    if(GetImport().GetDataStylesImport())
    {
        pStyle = GetImport().GetDataStylesImport()->CreateChildContext(GetImport(), nElement,
                                               xAttrList, *this);
        if (pStyle)
            return pStyle;
    }

    switch (nElement)
    {
        case XML_ELEMENT(STYLE, XML_STYLE):
        case XML_ELEMENT(STYLE, XML_DEFAULT_STYLE):
        {
            XmlStyleFamily nFamily = XmlStyleFamily::DATA_STYLE;
            for( auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ) )
            {
                if( aIter.getToken() == XML_ELEMENT(STYLE, XML_FAMILY) )
                {
                    nFamily = GetFamily( aIter.toString() );
                    break;
                }
            }
            pStyle = XML_ELEMENT(STYLE, XML_STYLE)==nElement
                ? CreateStyleStyleChildContext( nFamily, nElement, xAttrList )
                : CreateDefaultStyleStyleChildContext( nFamily, nElement, xAttrList );
            break;
        }
        case XML_ELEMENT(TEXT, XML_BIBLIOGRAPHY_CONFIGURATION):
            pStyle = new XMLIndexBibliographyConfigurationContext(GetImport());
            break;
        case XML_ELEMENT(TEXT, XML_NOTES_CONFIGURATION):
            pStyle = new XMLFootnoteConfigurationImportContext(
                GetImport(), nElement, xAttrList);
            break;
        case XML_ELEMENT(TEXT, XML_LINENUMBERING_CONFIGURATION):
            pStyle = new XMLLineNumberingImportContext(GetImport());
            break;
        case XML_ELEMENT(STYLE, XML_PAGE_LAYOUT):
        case XML_ELEMENT(STYLE, XML_DEFAULT_PAGE_LAYOUT):
        {
            //there is not page family in ODF now, so I specify one for it
            bool bDefaultStyle  = XML_ELEMENT(STYLE, XML_DEFAULT_PAGE_LAYOUT) == nElement;
            pStyle = new PageStyleContext( GetImport(), *this, bDefaultStyle );
        }
        break;
        case XML_ELEMENT(TEXT, XML_LIST_STYLE):
            pStyle = new SvxXMLListStyleContext( GetImport() );
            break;
        case XML_ELEMENT(TEXT, XML_OUTLINE_STYLE):
            pStyle = new SvxXMLListStyleContext( GetImport(), true );
            break;

        // FillStyles

        case XML_ELEMENT(DRAW, XML_GRADIENT):
        {
            pStyle = new XMLGradientStyleContext( GetImport(), nElement, xAttrList );
            break;
        }
        case XML_ELEMENT(DRAW, XML_HATCH):
        {
            pStyle = new XMLHatchStyleContext( GetImport(), nElement, xAttrList );
            break;
        }
        case XML_ELEMENT(DRAW, XML_FILL_IMAGE):
        {
            pStyle = new XMLBitmapStyleContext( GetImport(), nElement, xAttrList );
            break;
        }
        case XML_ELEMENT(DRAW, XML_OPACITY):
        {
            pStyle = new XMLTransGradientStyleContext( GetImport(), nElement, xAttrList );
            break;
        }
        case XML_ELEMENT(DRAW, XML_MARKER):
        {
            pStyle = new XMLMarkerStyleContext( GetImport(), nElement, xAttrList );
            break;
        }
        case XML_ELEMENT(DRAW, XML_STROKE_DASH):
        {
            pStyle = new XMLDashStyleContext( GetImport(), nElement, xAttrList );
            break;
        }
    }

    if (!pStyle)
        SAL_WARN("xmloff", "Unknown element " << SvXMLImport::getPrefixAndNameFromToken(nElement));

    return pStyle;
}

SvXMLStyleContext *SvXMLStylesContext::CreateStyleStyleChildContext(
        XmlStyleFamily nFamily, sal_Int32 /*nElement*/,
        const uno::Reference< xml::sax::XFastAttributeList > & /*xAttrList*/ )
{
    SvXMLStyleContext *pStyle = nullptr;

    switch( nFamily )
    {
        case XmlStyleFamily::TEXT_PARAGRAPH:
        case XmlStyleFamily::TEXT_TEXT:
        case XmlStyleFamily::TEXT_SECTION:
            pStyle = new XMLTextStyleContext( GetImport(), *this, nFamily );
            break;

        case XmlStyleFamily::TEXT_RUBY:
            pStyle = new XMLPropStyleContext( GetImport(), *this, nFamily );
            break;
#if !ENABLE_WASM_STRIP_CHART
        // WASM_CHART change
        case XmlStyleFamily::SCH_CHART_ID:
            pStyle = new XMLChartStyleContext( GetImport(), *this, nFamily );
            break;
#endif
        case XmlStyleFamily::SD_GRAPHICS_ID:
        case XmlStyleFamily::SD_PRESENTATION_ID:
        case XmlStyleFamily::SD_POOL_ID:
            pStyle = new XMLShapeStyleContext( GetImport(), *this, nFamily );
            break;
        default: break;
    }

    return pStyle;
}

SvXMLStyleContext *SvXMLStylesContext::CreateDefaultStyleStyleChildContext(
        XmlStyleFamily /*nFamily*/, sal_Int32 /*nElement*/,
        const uno::Reference< xml::sax::XFastAttributeList > & )
{
    return nullptr;
}

bool SvXMLStylesContext::InsertStyleFamily( XmlStyleFamily ) const
{
    return true;
}

XmlStyleFamily SvXMLStylesContext::GetFamily( std::u16string_view 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;
}

SvXMLImportPropertyMapper* SvXMLStylesContext::GetImportPropertyMapper(
                        XmlStyleFamily nFamily ) const
{
    SvXMLImportPropertyMapper* pMapper = nullptr;

    SvXMLStylesContext * pThis = const_cast<SvXMLStylesContext *>(this);
    switch( nFamily )
    {
    case XmlStyleFamily::TEXT_PARAGRAPH:
        pMapper =
            pThis->GetImport().GetTextImport()
                 ->GetParaImportPropertySetMapper();
        break;
    case XmlStyleFamily::TEXT_TEXT:
        pMapper =
            pThis->GetImport().GetTextImport()
                 ->GetTextImportPropertySetMapper();
        break;

    case XmlStyleFamily::TEXT_SECTION:
        // *sigh*, cast to non-const, because this is a const method,
        // but SvXMLImport::GetTextImport() isn't.
        pMapper = pThis->GetImport().GetTextImport()->
                GetSectionImportPropertySetMapper();
        break;

    case XmlStyleFamily::TEXT_RUBY:
        // *sigh*, cast to non-const, because this is a const method,
        // but SvXMLImport::GetTextImport() isn't.
        pMapper = pThis->GetImport().GetTextImport()->
            GetRubyImportPropertySetMapper();
        break;

    case XmlStyleFamily::SD_GRAPHICS_ID:
    case XmlStyleFamily::SD_PRESENTATION_ID:
    case XmlStyleFamily::SD_POOL_ID:
        pMapper = const_cast<SvXMLImport&>(GetImport()).GetShapeImport()->GetPropertySetMapper();
        break;
#if !ENABLE_WASM_STRIP_CHART
    // WASM_CHART change
    case XmlStyleFamily::SCH_CHART_ID:
        if( ! mxChartImpPropMapper )
        {
            XMLPropertySetMapper *const pPropMapper = new XMLChartPropertySetMapper(nullptr);
            mxChartImpPropMapper = std::make_unique<XMLChartImportPropertyMapper>( pPropMapper, GetImport() );
        }
        pMapper = mxChartImpPropMapper.get();
        break;
#endif
    case XmlStyleFamily::PAGE_MASTER:
        if( ! mxPageImpPropMapper )
        {
            XMLPropertySetMapper *pPropMapper =
                new XMLPageMasterPropSetMapper();
            mxPageImpPropMapper =
                std::make_unique<PageMasterImportPropertyMapper>( pPropMapper,
                                    const_cast<SvXMLStylesContext*>(this)->GetImport() );
        }
        pMapper = mxPageImpPropMapper.get();
        break;
    default: break;
    }

    return pMapper;
}

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;
        const Reference<XAutoStyleFamily>& rxAutoStyles = bPara ? mxParaAutoStyles : mxTextAutoStyles;
        if (!rxAutoStyles)
        {
            OUString sName(bPara ? gsParagraphStyles : gsCharacterStyles);
            Reference< XAutoStylesSupplier > xAutoStylesSupp(   GetImport().GetModel(), UNO_QUERY );
            Reference< XAutoStyles > xAutoStyleFamilies = xAutoStylesSupp->getAutoStyles();
            if (xAutoStyleFamilies->hasByName(sName))
            {
                Any aAny = xAutoStyleFamilies->getByName( sName );
                aAny >>= const_cast<Reference<XAutoStyleFamily>&>(rxAutoStyles);
            }
        }
        xAutoStyles = rxAutoStyles;
    }
    return xAutoStyles;
}

Reference < XNameContainer > SvXMLStylesContext::GetStylesContainer(
                                                XmlStyleFamily nFamily ) const
{
    Reference < XNameContainer > xStyles;
    if (XmlStyleFamily::TEXT_TEXT == nFamily || XmlStyleFamily::TEXT_PARAGRAPH == nFamily)
    {
        bool bPara = XmlStyleFamily::TEXT_PARAGRAPH == nFamily;
        const Reference<XNameContainer>& rxStyles = bPara ? mxParaStyles : mxTextStyles;
        if (!rxStyles)
        {
            OUString sName(bPara ? gsParagraphStyles : gsCharacterStyles);
            Reference<XStyleFamiliesSupplier> xFamiliesSupp(GetImport().GetModel(), UNO_QUERY);
            if (xFamiliesSupp.is())
            {
                Reference<XNameAccess> xFamilies = xFamiliesSupp->getStyleFamilies();
                if (xFamilies->hasByName(sName))
                {
                    Any aAny = xFamilies->getByName(sName);
                    aAny >>= const_cast<Reference<XNameContainer>&>(rxStyles);
                }
            }
        }
        xStyles = rxStyles;
    }

    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 )
{
    if (nElement ==  XML_ELEMENT(LO_EXT, XML_THEME))
    {
        if (auto xImportInfo = GetImport().getImportInfo())
        {
            try
            {
                if (auto xPropertySetInfo = xImportInfo->getPropertySetInfo())
                {
                    if (xPropertySetInfo->hasPropertyByName(u"IsInPaste"_ustr))
                    {
                        css::uno::Any value = xImportInfo->getPropertyValue(u"IsInPaste"_ustr);
                        if (bool b; (value >>= b) && b)
                            return nullptr; // do not import themes in paste mode
                    }
                }
            }
            catch (const css::uno::Exception&)
            {
                DBG_UNHANDLED_EXCEPTION("xmloff");
            }
        }

        uno::Reference<uno::XInterface> xObject(GetImport().GetModel(), uno::UNO_QUERY);
        uno::Reference<drawing::XDrawPageSupplier> const xDrawPageSupplier(GetImport().GetModel(), uno::UNO_QUERY);
        if (xDrawPageSupplier.is())
        {
            uno::Reference<drawing::XDrawPage> xPage = xDrawPageSupplier->getDrawPage();
            if (xPage.is())
                xObject = xPage;
        }

        return new XMLThemeContext(GetImport(), xAttrList, xObject);
    }

    SvXMLStyleContext* pStyle = CreateStyleChildContext( nElement, xAttrList );
    if (pStyle)
    {
        if (!pStyle->IsTransient())
            mpImpl->AddStyle(pStyle);
        return pStyle;
    }

    return nullptr;
}

void SvXMLStylesContext::AddStyle(SvXMLStyleContext& rNew)
{
    mpImpl->AddStyle( &rNew );
}

void SvXMLStylesContext::dispose()
{
    mpImpl->dispose();
}

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 );
}

std::pair<SvXMLStylesContext::StyleIndex::const_iterator, SvXMLStylesContext::StyleIndex::const_iterator>
SvXMLStylesContext::FindStyleChildContextByDisplayNamePrefix(
                                  XmlStyleFamily nFamily,
                                  const OUString& rNamePrefix ) const
{
    return mpImpl->FindStyleChildContextByDisplayNamePrefix( nFamily, rNamePrefix );
}

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