c01cac0654
V1037 Two or more case-branches perform the same actions. Check lines: 103, 106 Change-Id: I761622d8c980c7f53ae4d9c77a83c918a2efb22c Reviewed-on: https://gerrit.libreoffice.org/c/core/+/175429 Tested-by: Jenkins Reviewed-by: David Gilbert <freedesktop@treblig.org>
840 lines
27 KiB
C++
840 lines
27 KiB
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 StyleVectorCompare
|
|
{
|
|
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();
|
|
}
|
|
};
|
|
}
|
|
|
|
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 maStylesIndex;
|
|
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>
|
|
FindStyleChildContextByPrefix( XmlStyleFamily nFamily,
|
|
const OUString& rPrefix ) const;
|
|
|
|
bool IsAutomaticStyle() const { return bAutomaticStyle; }
|
|
|
|
private:
|
|
void BuildIndex() 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 );
|
|
|
|
maStylesIndex.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( maStylesIndex.empty() && bCreateIndex && !aStyles.empty() )
|
|
BuildIndex();
|
|
|
|
if( !maStylesIndex.empty() )
|
|
{
|
|
auto it = std::lower_bound(maStylesIndex.begin(), maStylesIndex.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 != maStylesIndex.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 PrefixProbe
|
|
{
|
|
XmlStyleFamily nFamily;
|
|
const OUString& rPrefix;
|
|
|
|
bool operator()(const SvXMLStyleContext* lhs, bool /*rhs*/)
|
|
{
|
|
if (lhs->GetFamily() < nFamily)
|
|
return true;
|
|
if (lhs->GetFamily() > nFamily)
|
|
return false;
|
|
const OUString& lhsName = lhs->GetName();
|
|
return lhsName.subView(0, std::min(lhsName.getLength(), rPrefix.getLength())) < rPrefix;
|
|
}
|
|
bool operator()(bool /*lhs*/, const SvXMLStyleContext* rhs)
|
|
{
|
|
if (nFamily < rhs->GetFamily())
|
|
return true;
|
|
if (nFamily > rhs->GetFamily())
|
|
return false;
|
|
const OUString& rhsName = rhs->GetName();
|
|
return rPrefix < rhsName.subView(0, std::min(rhsName.getLength(), rPrefix.getLength()));
|
|
}
|
|
};
|
|
}
|
|
|
|
std::pair<SvXMLStylesContext::StyleIndex::const_iterator, SvXMLStylesContext::StyleIndex::const_iterator>
|
|
SvXMLStylesContext_Impl::FindStyleChildContextByPrefix( XmlStyleFamily nFamily,
|
|
const OUString& rPrefix ) const
|
|
{
|
|
if( maStylesIndex.empty() )
|
|
BuildIndex();
|
|
return std::equal_range(maStylesIndex.begin(), maStylesIndex.end(), true, PrefixProbe{nFamily,rPrefix});
|
|
}
|
|
|
|
void SvXMLStylesContext_Impl::BuildIndex() const
|
|
{
|
|
maStylesIndex.reserve(aStyles.size());
|
|
for (const auto & i : aStyles)
|
|
maStylesIndex.push_back(i.get());
|
|
std::sort(maStylesIndex.begin(), maStylesIndex.end(), StyleVectorCompare());
|
|
#if OSL_DEBUG_LEVEL > 0
|
|
SAL_WARN_IF(0 != m_nIndexCreated, "xmloff.style",
|
|
"Performance warning: sdbcx::Index created multiple times");
|
|
++m_nIndexCreated;
|
|
#endif
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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;
|
|
#if !ENABLE_WASM_STRIP_CHART
|
|
// WASM_CHART change
|
|
case XmlStyleFamily::SCH_CHART_ID:
|
|
if( ! mxChartImpPropMapper.is() )
|
|
{
|
|
XMLPropertySetMapper *const pPropMapper = new XMLChartPropertySetMapper(nullptr);
|
|
mxChartImpPropMapper = new XMLChartImportPropertyMapper( pPropMapper, GetImport() );
|
|
}
|
|
xMapper = mxChartImpPropMapper;
|
|
break;
|
|
#endif
|
|
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;
|
|
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::FindStyleChildContextByPrefix(
|
|
XmlStyleFamily nFamily,
|
|
const OUString& rNamePrefix ) const
|
|
{
|
|
return mpImpl->FindStyleChildContextByPrefix( nFamily, rNamePrefix );
|
|
}
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|