aff9ea4c77
in
commit 01a3cc1e55
Author: Noel Grandin <noel.grandin@collabora.co.uk>
Date: Tue Nov 29 16:09:10 2022 +0200
tdf#133343 collect autostyle prop names
before scanning for autostyles. That way we can collect only the
property state we are interested in, instead of all properties.
where I apparently wrote the code at the beginning of the call-chain
to collect autostyle prop names, and I wrote the code at the end of the
call-chain to filter on those names, but I never hooked it up in
the middle.
(which just means that the initial commit had no effect at all)
Unfortunately, fixing the middle part results in
unit test failures, so for now, just revert it.
Change-Id: Ia1d655f70d2f5a1656e910d45817c3c4627b85fb
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/150531
Tested-by: Jenkins
Reviewed-by: Noel Grandin <noel.grandin@collabora.co.uk>
383 lines
13 KiB
C++
383 lines
13 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 <com/sun/star/container/XIndexReplace.hpp>
|
|
#include "impastpl.hxx"
|
|
#include <xmloff/xmlaustp.hxx>
|
|
#include <xmloff/families.hxx>
|
|
#include <xmloff/xmlnamespace.hxx>
|
|
#include <xmloff/xmltoken.hxx>
|
|
#include <xmloff/xmlexp.hxx>
|
|
#include <xmloff/xmlprhdl.hxx>
|
|
#include <xmloff/xmlprmap.hxx>
|
|
#include <xmloff/XMLTextListAutoStylePool.hxx>
|
|
|
|
#include <PageMasterStyleMap.hxx>
|
|
#include <osl/diagnose.h>
|
|
|
|
|
|
using namespace ::com::sun::star;
|
|
using namespace ::xmloff::token;
|
|
|
|
|
|
namespace
|
|
{
|
|
void lcl_exportDataStyle( SvXMLExport& _rExport, const rtl::Reference< XMLPropertySetMapper >& _rxMapper,
|
|
const XMLPropertyState& _rProperty )
|
|
{
|
|
assert(_rxMapper.is());
|
|
// obtain the data style name
|
|
OUString sDataStyleName;
|
|
_rProperty.maValue >>= sDataStyleName;
|
|
assert(!sDataStyleName.isEmpty() && "xmloff::lcl_exportDataStyle: invalid property value for the data style name!");
|
|
|
|
// add the attribute
|
|
_rExport.AddAttribute(
|
|
_rxMapper->GetEntryNameSpace( _rProperty.mnIndex ),
|
|
_rxMapper->GetEntryXMLName( _rProperty.mnIndex ),
|
|
sDataStyleName );
|
|
}
|
|
}
|
|
|
|
void SvXMLAutoStylePoolP::exportStyleAttributes(
|
|
comphelper::AttributeList&,
|
|
XmlStyleFamily nFamily,
|
|
const std::vector< XMLPropertyState >& rProperties,
|
|
const SvXMLExportPropertyMapper& rPropExp,
|
|
const SvXMLUnitConverter&,
|
|
const SvXMLNamespaceMap&
|
|
) const
|
|
{
|
|
if ( XmlStyleFamily::CONTROL_ID == nFamily )
|
|
{ // it's a control-related style
|
|
const rtl::Reference< XMLPropertySetMapper >& aPropertyMapper = rPropExp.getPropertySetMapper();
|
|
|
|
for (const auto& rProp : rProperties)
|
|
{
|
|
if ( ( rProp.mnIndex > -1 )
|
|
&& ( CTF_FORMS_DATA_STYLE == aPropertyMapper->GetEntryContextId( rProp.mnIndex ) )
|
|
)
|
|
{ // it's the data-style for a grid column
|
|
lcl_exportDataStyle( GetExport(), aPropertyMapper, rProp );
|
|
}
|
|
}
|
|
}
|
|
|
|
if( (XmlStyleFamily::SD_GRAPHICS_ID == nFamily) || (XmlStyleFamily::SD_PRESENTATION_ID == nFamily) )
|
|
{ // it's a graphics style
|
|
const rtl::Reference< XMLPropertySetMapper >& aPropertyMapper = rPropExp.getPropertySetMapper();
|
|
assert(aPropertyMapper.is());
|
|
|
|
bool bFoundControlShapeDataStyle = false;
|
|
bool bFoundNumberingRulesName = false;
|
|
|
|
for (const auto& rProp : rProperties)
|
|
{
|
|
if (rProp.mnIndex > -1)
|
|
{ // it's a valid property
|
|
switch( aPropertyMapper->GetEntryContextId(rProp.mnIndex) )
|
|
{
|
|
case CTF_SD_CONTROL_SHAPE_DATA_STYLE:
|
|
{ // it's the control shape data style property
|
|
|
|
if (bFoundControlShapeDataStyle)
|
|
{
|
|
OSL_FAIL("SvXMLAutoStylePoolP::exportStyleAttributes: found two properties with the ControlShapeDataStyle context id!");
|
|
// already added the attribute for the first occurrence
|
|
break;
|
|
}
|
|
|
|
lcl_exportDataStyle( GetExport(), aPropertyMapper, rProp );
|
|
|
|
// check if there is another property with the special context id we're handling here
|
|
bFoundControlShapeDataStyle = true;
|
|
break;
|
|
}
|
|
case CTF_SD_NUMBERINGRULES_NAME:
|
|
{
|
|
if (bFoundNumberingRulesName)
|
|
{
|
|
OSL_FAIL("SvXMLAutoStylePoolP::exportStyleAttributes: found two properties with the numbering rules name context id!");
|
|
// already added the attribute for the first occurrence
|
|
break;
|
|
}
|
|
|
|
uno::Reference< container::XIndexReplace > xNumRule;
|
|
rProp.maValue >>= xNumRule;
|
|
if( xNumRule.is() && (xNumRule->getCount() > 0 ) )
|
|
{
|
|
const OUString sName(const_cast<XMLTextListAutoStylePool*>(&GetExport().GetTextParagraphExport()->GetListAutoStylePool())->Add( xNumRule ));
|
|
|
|
GetExport().AddAttribute( XML_NAMESPACE_STYLE, XML_LIST_STYLE_NAME, GetExport().EncodeStyleName( sName ) );
|
|
}
|
|
|
|
bFoundNumberingRulesName = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if( nFamily != XmlStyleFamily::PAGE_MASTER )
|
|
return;
|
|
|
|
for( const auto& rProp : rProperties )
|
|
{
|
|
if (rProp.mnIndex > -1)
|
|
{
|
|
const rtl::Reference< XMLPropertySetMapper >& aPropMapper = rPropExp.getPropertySetMapper();
|
|
sal_Int32 nIndex = rProp.mnIndex;
|
|
sal_Int16 nContextID = aPropMapper->GetEntryContextId( nIndex );
|
|
switch( nContextID )
|
|
{
|
|
case CTF_PM_PAGEUSAGE:
|
|
{
|
|
OUString sValue;
|
|
const XMLPropertyHandler* pPropHdl = aPropMapper->GetPropertyHandler( nIndex );
|
|
if( pPropHdl &&
|
|
pPropHdl->exportXML( sValue, rProp.maValue,
|
|
GetExport().GetMM100UnitConverter() ) &&
|
|
( ! IsXMLToken( sValue, XML_ALL ) ) )
|
|
{
|
|
GetExport().AddAttribute( aPropMapper->GetEntryNameSpace( nIndex ), aPropMapper->GetEntryXMLName( nIndex ), sValue );
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void SvXMLAutoStylePoolP::exportStyleContent(
|
|
const css::uno::Reference< css::xml::sax::XDocumentHandler > &,
|
|
XmlStyleFamily nFamily,
|
|
const std::vector< XMLPropertyState >& rProperties,
|
|
const SvXMLExportPropertyMapper& rPropExp,
|
|
const SvXMLUnitConverter&,
|
|
const SvXMLNamespaceMap&
|
|
) const
|
|
{
|
|
if( nFamily != XmlStyleFamily::PAGE_MASTER )
|
|
return;
|
|
|
|
sal_Int32 nHeaderStartIndex(-1);
|
|
sal_Int32 nHeaderEndIndex(-1);
|
|
sal_Int32 nFooterStartIndex(-1);
|
|
sal_Int32 nFooterEndIndex(-1);
|
|
bool bHeaderStartIndex(false);
|
|
bool bHeaderEndIndex(false);
|
|
bool bFooterStartIndex(false);
|
|
bool bFooterEndIndex(false);
|
|
|
|
const rtl::Reference< XMLPropertySetMapper >& aPropMapper = rPropExp.getPropertySetMapper();
|
|
|
|
sal_Int32 nIndex(0);
|
|
while(nIndex < aPropMapper->GetEntryCount())
|
|
{
|
|
switch( aPropMapper->GetEntryContextId( nIndex ) & CTF_PM_FLAGMASK )
|
|
{
|
|
case CTF_PM_HEADERFLAG:
|
|
{
|
|
if (!bHeaderStartIndex)
|
|
{
|
|
nHeaderStartIndex = nIndex;
|
|
bHeaderStartIndex = true;
|
|
}
|
|
if (bFooterStartIndex && !bFooterEndIndex)
|
|
{
|
|
nFooterEndIndex = nIndex;
|
|
bFooterEndIndex = true;
|
|
}
|
|
}
|
|
break;
|
|
case CTF_PM_FOOTERFLAG:
|
|
{
|
|
if (!bFooterStartIndex)
|
|
{
|
|
nFooterStartIndex = nIndex;
|
|
bFooterStartIndex = true;
|
|
}
|
|
if (bHeaderStartIndex && !bHeaderEndIndex)
|
|
{
|
|
nHeaderEndIndex = nIndex;
|
|
bHeaderEndIndex = true;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
nIndex++;
|
|
}
|
|
if (!bHeaderEndIndex)
|
|
nHeaderEndIndex = nIndex;
|
|
if (!bFooterEndIndex)
|
|
nFooterEndIndex = nIndex;
|
|
|
|
// export header style element
|
|
{
|
|
SvXMLElementExport aElem(
|
|
GetExport(), XML_NAMESPACE_STYLE, XML_HEADER_STYLE,
|
|
true, true );
|
|
|
|
rPropExp.exportXML(
|
|
GetExport(), rProperties,
|
|
nHeaderStartIndex, nHeaderEndIndex, SvXmlExportFlags::IGN_WS);
|
|
}
|
|
|
|
// export footer style
|
|
{
|
|
SvXMLElementExport aElem(
|
|
GetExport(), XML_NAMESPACE_STYLE, XML_FOOTER_STYLE,
|
|
true, true );
|
|
|
|
rPropExp.exportXML(
|
|
GetExport(), rProperties,
|
|
nFooterStartIndex, nFooterEndIndex, SvXmlExportFlags::IGN_WS);
|
|
}
|
|
|
|
}
|
|
|
|
SvXMLAutoStylePoolP::SvXMLAutoStylePoolP( SvXMLExport& rExport )
|
|
: m_pImpl( new SvXMLAutoStylePoolP_Impl( rExport ) )
|
|
{
|
|
}
|
|
|
|
SvXMLAutoStylePoolP::~SvXMLAutoStylePoolP()
|
|
{
|
|
}
|
|
|
|
SvXMLExport& SvXMLAutoStylePoolP::GetExport() const
|
|
{
|
|
return m_pImpl->GetExport();
|
|
}
|
|
|
|
// TODO: remove this
|
|
void SvXMLAutoStylePoolP::AddFamily(
|
|
XmlStyleFamily nFamily,
|
|
const OUString& rStrName,
|
|
SvXMLExportPropertyMapper* pMapper,
|
|
const OUString& aStrPrefix )
|
|
{
|
|
rtl::Reference <SvXMLExportPropertyMapper> xTmp = pMapper;
|
|
AddFamily( nFamily, rStrName, xTmp, aStrPrefix );
|
|
}
|
|
|
|
void SvXMLAutoStylePoolP::AddFamily(
|
|
XmlStyleFamily nFamily,
|
|
const OUString& rStrName,
|
|
const rtl::Reference < SvXMLExportPropertyMapper > & rMapper,
|
|
const OUString& rStrPrefix,
|
|
bool bAsFamily )
|
|
{
|
|
m_pImpl->AddFamily( nFamily, rStrName, rMapper, rStrPrefix, bAsFamily );
|
|
}
|
|
|
|
void SvXMLAutoStylePoolP::SetFamilyPropSetMapper(
|
|
XmlStyleFamily nFamily,
|
|
const rtl::Reference < SvXMLExportPropertyMapper > & rMapper )
|
|
{
|
|
m_pImpl->SetFamilyPropSetMapper( nFamily, rMapper );
|
|
}
|
|
|
|
void SvXMLAutoStylePoolP::RegisterName( XmlStyleFamily nFamily,
|
|
const OUString& rName )
|
|
{
|
|
m_pImpl->RegisterName( nFamily, rName );
|
|
}
|
|
|
|
void SvXMLAutoStylePoolP::RegisterDefinedName( XmlStyleFamily nFamily,
|
|
const OUString& rName )
|
|
{
|
|
m_pImpl->RegisterDefinedName( nFamily, rName );
|
|
}
|
|
|
|
void SvXMLAutoStylePoolP::GetRegisteredNames(
|
|
uno::Sequence<sal_Int32>& rFamilies,
|
|
uno::Sequence<OUString>& rNames )
|
|
{
|
|
m_pImpl->GetRegisteredNames( rFamilies, rNames );
|
|
}
|
|
|
|
void SvXMLAutoStylePoolP::RegisterNames(
|
|
uno::Sequence<sal_Int32> const & aFamilies,
|
|
uno::Sequence<OUString> const & aNames )
|
|
{
|
|
assert(aFamilies.getLength() == aNames.getLength());
|
|
|
|
// iterate over sequence(s) and call RegisterName(..) for each pair
|
|
const sal_Int32* pFamilies = aFamilies.getConstArray();
|
|
const OUString* pNames = aNames.getConstArray();
|
|
sal_Int32 nCount = std::min( aFamilies.getLength(), aNames.getLength() );
|
|
for( sal_Int32 n = 0; n < nCount; n++ )
|
|
RegisterName( static_cast<XmlStyleFamily>(pFamilies[n]), pNames[n] );
|
|
}
|
|
|
|
OUString SvXMLAutoStylePoolP::Add( XmlStyleFamily nFamily,
|
|
std::vector< XMLPropertyState >&& rProperties )
|
|
{
|
|
OUString sName;
|
|
m_pImpl->Add(sName, nFamily, "", std::move(rProperties) );
|
|
return sName;
|
|
}
|
|
|
|
OUString SvXMLAutoStylePoolP::Add( XmlStyleFamily nFamily,
|
|
const OUString& rParent,
|
|
std::vector< XMLPropertyState >&& rProperties, bool bDontSeek )
|
|
{
|
|
OUString sName;
|
|
m_pImpl->Add(sName, nFamily, rParent, std::move(rProperties), bDontSeek);
|
|
return sName;
|
|
}
|
|
|
|
bool SvXMLAutoStylePoolP::Add(OUString& rName, XmlStyleFamily nFamily, const OUString& rParent, ::std::vector< XMLPropertyState >&& rProperties )
|
|
{
|
|
return m_pImpl->Add(rName, nFamily, rParent, std::move(rProperties));
|
|
}
|
|
|
|
bool SvXMLAutoStylePoolP::AddNamed( const OUString& rName, XmlStyleFamily nFamily, const OUString& rParent,
|
|
std::vector< XMLPropertyState > rProperties )
|
|
|
|
{
|
|
return m_pImpl->AddNamed(rName, nFamily, rParent, std::move(rProperties));
|
|
}
|
|
|
|
OUString SvXMLAutoStylePoolP::Find( XmlStyleFamily nFamily,
|
|
const OUString& rParent,
|
|
const std::vector< XMLPropertyState >& rProperties ) const
|
|
{
|
|
return m_pImpl->Find( nFamily, rParent, rProperties );
|
|
}
|
|
|
|
void SvXMLAutoStylePoolP::exportXML( XmlStyleFamily nFamily ) const
|
|
{
|
|
m_pImpl->exportXML( nFamily, this );
|
|
}
|
|
|
|
void SvXMLAutoStylePoolP::ClearEntries()
|
|
{
|
|
m_pImpl->ClearEntries();
|
|
}
|
|
|
|
std::vector<xmloff::AutoStyleEntry> SvXMLAutoStylePoolP::GetAutoStyleEntries() const
|
|
{
|
|
return m_pImpl->GetAutoStyleEntries();
|
|
}
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|