diff options
Diffstat (limited to 'xmloff/source/style/PageMasterImportPropMapper.cxx')
| -rw-r--r-- | xmloff/source/style/PageMasterImportPropMapper.cxx | 521 |
1 files changed, 521 insertions, 0 deletions
diff --git a/xmloff/source/style/PageMasterImportPropMapper.cxx b/xmloff/source/style/PageMasterImportPropMapper.cxx new file mode 100644 index 000000000..d4eba7601 --- /dev/null +++ b/xmloff/source/style/PageMasterImportPropMapper.cxx @@ -0,0 +1,521 @@ +/* -*- 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 "PageMasterImportPropMapper.hxx" +#include <PageMasterStyleMap.hxx> +#include <xmloff/maptype.hxx> +#include <com/sun/star/table/BorderLine2.hpp> +#include <com/sun/star/container/XNameContainer.hpp> +#include <com/sun/star/lang/XServiceInfo.hpp> +#include <com/sun/star/lang/XMultiServiceFactory.hpp> +#include <com/sun/star/frame/XModel.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <xmloff/xmlimp.hxx> +#include <xmloff/xmlprmap.hxx> +#include <memory> + +#define XML_LINE_LEFT 0 +#define XML_LINE_RIGHT 1 +#define XML_LINE_TOP 2 +#define XML_LINE_BOTTOM 3 + +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::container; + +PageMasterImportPropertyMapper::PageMasterImportPropertyMapper( + const rtl::Reference< XMLPropertySetMapper >& rMapper, + SvXMLImport& rImp ) : + SvXMLImportPropertyMapper( rMapper, rImp ), + rImport( rImp ) +{ +} + +PageMasterImportPropertyMapper::~PageMasterImportPropertyMapper() +{ +} + +bool PageMasterImportPropertyMapper::handleSpecialItem( + XMLPropertyState& rProperty, + std::vector< XMLPropertyState >& rProperties, + const OUString& rValue, + const SvXMLUnitConverter& rUnitConverter, + const SvXMLNamespaceMap& rNamespaceMap ) const +{ + bool bRet = false; + sal_Int16 nContextID = + getPropertySetMapper()->GetEntryContextId(rProperty.mnIndex); + + if( CTF_PM_REGISTER_STYLE==nContextID ) + { + OUString sDisplayName( rImport.GetStyleDisplayName( + XmlStyleFamily::TEXT_PARAGRAPH, rValue ) ); + Reference < XNameContainer > xParaStyles = + rImport.GetTextImport()->GetParaStyles(); + if( xParaStyles.is() && xParaStyles->hasByName( sDisplayName ) ) + { + rProperty.maValue <<= sDisplayName; + bRet = true; + } + } + else + { + bRet = SvXMLImportPropertyMapper::handleSpecialItem( + rProperty, rProperties, rValue, + rUnitConverter, rNamespaceMap ); + } + + return bRet; +} + + +void PageMasterImportPropertyMapper::finished(std::vector< XMLPropertyState >& rProperties, sal_Int32 nStartIndex, sal_Int32 nEndIndex ) const +{ + SvXMLImportPropertyMapper::finished(rProperties, nStartIndex, nEndIndex); + XMLPropertyState* pAllPaddingProperty = nullptr; + XMLPropertyState* pPadding[4] = { nullptr, nullptr, nullptr, nullptr }; + XMLPropertyState* pNewPadding[4] = { nullptr, nullptr, nullptr, nullptr }; + XMLPropertyState* pAllBorderProperty = nullptr; + XMLPropertyState* pBorders[4] = { nullptr, nullptr, nullptr, nullptr }; + XMLPropertyState* pNewBorders[4] = { nullptr, nullptr, nullptr, nullptr }; + XMLPropertyState* pAllBorderWidthProperty = nullptr; + XMLPropertyState* pBorderWidths[4] = { nullptr, nullptr, nullptr, nullptr }; + XMLPropertyState* pAllHeaderPaddingProperty = nullptr; + XMLPropertyState* pHeaderPadding[4] = { nullptr, nullptr, nullptr, nullptr }; + XMLPropertyState* pHeaderNewPadding[4] = { nullptr, nullptr, nullptr, nullptr }; + XMLPropertyState* pAllHeaderBorderProperty = nullptr; + XMLPropertyState* pHeaderBorders[4] = { nullptr, nullptr, nullptr, nullptr }; + XMLPropertyState* pHeaderNewBorders[4] = { nullptr, nullptr, nullptr, nullptr }; + XMLPropertyState* pAllHeaderBorderWidthProperty = nullptr; + XMLPropertyState* pHeaderBorderWidths[4] = { nullptr, nullptr, nullptr, nullptr }; + XMLPropertyState* pAllFooterPaddingProperty = nullptr; + XMLPropertyState* pFooterPadding[4] = { nullptr, nullptr, nullptr, nullptr }; + XMLPropertyState* pFooterNewPadding[4] = { nullptr, nullptr, nullptr, nullptr }; + XMLPropertyState* pAllFooterBorderProperty = nullptr; + XMLPropertyState* pFooterBorders[4] = { nullptr, nullptr, nullptr, nullptr }; + XMLPropertyState* pFooterNewBorders[4] = { nullptr, nullptr, nullptr, nullptr }; + XMLPropertyState* pAllFooterBorderWidthProperty = nullptr; + XMLPropertyState* pFooterBorderWidths[4] = { nullptr, nullptr, nullptr, nullptr }; + XMLPropertyState* pHeaderHeight = nullptr; + XMLPropertyState* pHeaderMinHeight = nullptr; + std::optional<XMLPropertyState> xHeaderDynamic; + XMLPropertyState* pFooterHeight = nullptr; + XMLPropertyState* pFooterMinHeight = nullptr; + std::optional<XMLPropertyState> xFooterDynamic; + XMLPropertyState* pAllMarginProperty = nullptr; + XMLPropertyState* pMargins[4] = { nullptr, nullptr, nullptr, nullptr }; + std::optional<XMLPropertyState> pNewMargins[4]; + XMLPropertyState* pAllHeaderMarginProperty = nullptr; + XMLPropertyState* pHeaderMargins[4] = { nullptr, nullptr, nullptr, nullptr }; + std::optional<XMLPropertyState> pNewHeaderMargins[4]; + XMLPropertyState* pAllFooterMarginProperty = nullptr; + XMLPropertyState* pFooterMargins[4] = { nullptr, nullptr, nullptr, nullptr }; + std::optional<XMLPropertyState> pNewFooterMargins[4]; + XMLPropertyState* pMarginGutter = nullptr; + XMLPropertyState* pRtlGutter = nullptr; + + for (auto& rProp : rProperties) + { + XMLPropertyState *property = &rProp; + sal_Int16 nContextID = getPropertySetMapper()->GetEntryContextId(property->mnIndex); + if (property->mnIndex >= nStartIndex && property->mnIndex < nEndIndex) + { + switch (nContextID) + { + case CTF_PM_PADDINGALL : pAllPaddingProperty = property; break; + case CTF_PM_PADDINGLEFT : pPadding[XML_LINE_LEFT] = property; break; + case CTF_PM_PADDINGRIGHT : pPadding[XML_LINE_RIGHT] = property; break; + case CTF_PM_PADDINGTOP : pPadding[XML_LINE_TOP] = property; break; + case CTF_PM_PADDINGBOTTOM : pPadding[XML_LINE_BOTTOM] = property; break; + case CTF_PM_BORDERALL : pAllBorderProperty = property; break; + case CTF_PM_BORDERLEFT : pBorders[XML_LINE_LEFT] = property; break; + case CTF_PM_BORDERRIGHT : pBorders[XML_LINE_RIGHT] = property; break; + case CTF_PM_BORDERTOP : pBorders[XML_LINE_TOP] = property; break; + case CTF_PM_BORDERBOTTOM : pBorders[XML_LINE_BOTTOM] = property; break; + case CTF_PM_BORDERWIDTHALL : pAllBorderWidthProperty = property; break; + case CTF_PM_BORDERWIDTHLEFT : pBorderWidths[XML_LINE_LEFT] = property; break; + case CTF_PM_BORDERWIDTHRIGHT : pBorderWidths[XML_LINE_RIGHT] = property; break; + case CTF_PM_BORDERWIDTHTOP : pBorderWidths[XML_LINE_TOP] = property; break; + case CTF_PM_BORDERWIDTHBOTTOM : pBorderWidths[XML_LINE_BOTTOM] = property; break; + case CTF_PM_HEADERPADDINGALL : pAllHeaderPaddingProperty = property; break; + case CTF_PM_HEADERPADDINGLEFT : pHeaderPadding[XML_LINE_LEFT] = property; break; + case CTF_PM_HEADERPADDINGRIGHT : pHeaderPadding[XML_LINE_RIGHT] = property; break; + case CTF_PM_HEADERPADDINGTOP : pHeaderPadding[XML_LINE_TOP] = property; break; + case CTF_PM_HEADERPADDINGBOTTOM : pHeaderPadding[XML_LINE_BOTTOM] = property; break; + case CTF_PM_HEADERBORDERALL : pAllHeaderBorderProperty = property; break; + case CTF_PM_HEADERBORDERLEFT : pHeaderBorders[XML_LINE_LEFT] = property; break; + case CTF_PM_HEADERBORDERRIGHT : pHeaderBorders[XML_LINE_RIGHT] = property; break; + case CTF_PM_HEADERBORDERTOP : pHeaderBorders[XML_LINE_TOP] = property; break; + case CTF_PM_HEADERBORDERBOTTOM : pHeaderBorders[XML_LINE_BOTTOM] = property; break; + case CTF_PM_HEADERBORDERWIDTHALL : pAllHeaderBorderWidthProperty = property; break; + case CTF_PM_HEADERBORDERWIDTHLEFT : pHeaderBorderWidths[XML_LINE_LEFT] = property; break; + case CTF_PM_HEADERBORDERWIDTHRIGHT : pHeaderBorderWidths[XML_LINE_RIGHT] = property; break; + case CTF_PM_HEADERBORDERWIDTHTOP : pHeaderBorderWidths[XML_LINE_TOP] = property; break; + case CTF_PM_HEADERBORDERWIDTHBOTTOM : pHeaderBorderWidths[XML_LINE_BOTTOM] = property; break; + case CTF_PM_FOOTERPADDINGALL : pAllFooterPaddingProperty = property; break; + case CTF_PM_FOOTERPADDINGLEFT : pFooterPadding[XML_LINE_LEFT] = property; break; + case CTF_PM_FOOTERPADDINGRIGHT : pFooterPadding[XML_LINE_RIGHT] = property; break; + case CTF_PM_FOOTERPADDINGTOP : pFooterPadding[XML_LINE_TOP] = property; break; + case CTF_PM_FOOTERPADDINGBOTTOM : pFooterPadding[XML_LINE_BOTTOM] = property; break; + case CTF_PM_FOOTERBORDERALL : pAllFooterBorderProperty = property; break; + case CTF_PM_FOOTERBORDERLEFT : pFooterBorders[XML_LINE_LEFT] = property; break; + case CTF_PM_FOOTERBORDERRIGHT : pFooterBorders[XML_LINE_RIGHT] = property; break; + case CTF_PM_FOOTERBORDERTOP : pFooterBorders[XML_LINE_TOP] = property; break; + case CTF_PM_FOOTERBORDERBOTTOM : pFooterBorders[XML_LINE_BOTTOM] = property; break; + case CTF_PM_FOOTERBORDERWIDTHALL : pAllFooterBorderWidthProperty = property; break; + case CTF_PM_FOOTERBORDERWIDTHLEFT : pFooterBorderWidths[XML_LINE_LEFT] = property; break; + case CTF_PM_FOOTERBORDERWIDTHRIGHT : pFooterBorderWidths[XML_LINE_RIGHT] = property; break; + case CTF_PM_FOOTERBORDERWIDTHTOP : pFooterBorderWidths[XML_LINE_TOP] = property; break; + case CTF_PM_FOOTERBORDERWIDTHBOTTOM : pFooterBorderWidths[XML_LINE_BOTTOM] = property; break; + case CTF_PM_HEADERHEIGHT : pHeaderHeight = property; break; + case CTF_PM_HEADERMINHEIGHT : pHeaderMinHeight = property; break; + case CTF_PM_FOOTERHEIGHT : pFooterHeight = property; break; + case CTF_PM_FOOTERMINHEIGHT : pFooterMinHeight = property; break; + case CTF_PM_MARGINALL : + pAllMarginProperty = property; break; + case CTF_PM_MARGINTOP : + pMargins[XML_LINE_TOP] = property; break; + case CTF_PM_MARGINBOTTOM: + pMargins[XML_LINE_BOTTOM] = property; break; + case CTF_PM_MARGINLEFT : + pMargins[XML_LINE_LEFT] = property; break; + case CTF_PM_MARGINRIGHT : + pMargins[XML_LINE_RIGHT] = property; break; + case CTF_PM_MARGINGUTTER: + pMarginGutter = property; + break; + case CTF_PM_RTLGUTTER: + pRtlGutter = property; + break; + case CTF_PM_HEADERMARGINALL : + pAllHeaderMarginProperty = property; break; + case CTF_PM_HEADERMARGINTOP : + pHeaderMargins[XML_LINE_TOP] = property; break; + case CTF_PM_HEADERMARGINBOTTOM: + pHeaderMargins[XML_LINE_BOTTOM] = property; break; + case CTF_PM_HEADERMARGINLEFT : + pHeaderMargins[XML_LINE_LEFT] = property; break; + case CTF_PM_HEADERMARGINRIGHT : + pHeaderMargins[XML_LINE_RIGHT] = property; break; + case CTF_PM_FOOTERMARGINALL : + pAllFooterMarginProperty = property; break; + case CTF_PM_FOOTERMARGINTOP : + pFooterMargins[XML_LINE_TOP] = property; break; + case CTF_PM_FOOTERMARGINBOTTOM: + pFooterMargins[XML_LINE_BOTTOM] = property; break; + case CTF_PM_FOOTERMARGINLEFT : + pFooterMargins[XML_LINE_LEFT] = property; break; + case CTF_PM_FOOTERMARGINRIGHT : + pFooterMargins[XML_LINE_RIGHT] = property; break; + } + } + } + + for (sal_uInt16 i = 0; i < 4; i++) + { + if (pAllMarginProperty && !pMargins[i]) + { + pNewMargins[i].emplace( + pAllMarginProperty->mnIndex + 1 + i, + pAllMarginProperty->maValue); + } + if (pAllHeaderMarginProperty && !pHeaderMargins[i]) + { + pNewHeaderMargins[i].emplace( + pAllHeaderMarginProperty->mnIndex + 1 + i, + pAllHeaderMarginProperty->maValue); + } + if (pAllFooterMarginProperty && !pFooterMargins[i]) + { + pNewFooterMargins[i].emplace( + pAllFooterMarginProperty->mnIndex + 1 + i, + pAllFooterMarginProperty->maValue); + } + if (pAllPaddingProperty && !pPadding[i]) + pNewPadding[i] = new XMLPropertyState(pAllPaddingProperty->mnIndex + 1 + i, pAllPaddingProperty->maValue); + if (pAllBorderProperty && !pBorders[i]) + { + pNewBorders[i] = new XMLPropertyState(pAllBorderProperty->mnIndex + 1 + i, pAllBorderProperty->maValue); + pBorders[i] = pNewBorders[i]; + } + if( !pBorderWidths[i] ) + pBorderWidths[i] = pAllBorderWidthProperty; + else + pBorderWidths[i]->mnIndex = -1; + if( pBorders[i] ) + { + table::BorderLine2 aBorderLine; + pBorders[i]->maValue >>= aBorderLine; + if( pBorderWidths[i] ) + { + table::BorderLine2 aBorderLineWidth; + pBorderWidths[i]->maValue >>= aBorderLineWidth; + aBorderLine.OuterLineWidth = aBorderLineWidth.OuterLineWidth; + aBorderLine.InnerLineWidth = aBorderLineWidth.InnerLineWidth; + aBorderLine.LineDistance = aBorderLineWidth.LineDistance; + aBorderLine.LineWidth = aBorderLineWidth.LineWidth; + pBorders[i]->maValue <<= aBorderLine; + } + } + if (pAllHeaderPaddingProperty && !pHeaderPadding[i]) + pHeaderNewPadding[i] = new XMLPropertyState(pAllHeaderPaddingProperty->mnIndex + 1 + i, pAllHeaderPaddingProperty->maValue); + if (pAllHeaderBorderProperty && !pHeaderBorders[i]) + pHeaderNewBorders[i] = new XMLPropertyState(pAllHeaderBorderProperty->mnIndex + 1 + i, pAllHeaderBorderProperty->maValue); + if( !pHeaderBorderWidths[i] ) + pHeaderBorderWidths[i] = pAllHeaderBorderWidthProperty; + else + pHeaderBorderWidths[i]->mnIndex = -1; + if( pHeaderBorders[i] ) + { + table::BorderLine2 aBorderLine; + pHeaderBorders[i]->maValue >>= aBorderLine; + if( pHeaderBorderWidths[i] ) + { + table::BorderLine2 aBorderLineWidth; + pHeaderBorderWidths[i]->maValue >>= aBorderLineWidth; + aBorderLine.OuterLineWidth = aBorderLineWidth.OuterLineWidth; + aBorderLine.InnerLineWidth = aBorderLineWidth.InnerLineWidth; + aBorderLine.LineDistance = aBorderLineWidth.LineDistance; + aBorderLine.LineWidth = aBorderLineWidth.LineWidth; + pHeaderBorders[i]->maValue <<= aBorderLine; + } + } + if (pAllFooterPaddingProperty && !pFooterPadding[i]) + pFooterNewPadding[i] = new XMLPropertyState(pAllFooterPaddingProperty->mnIndex + 1 + i, pAllFooterPaddingProperty->maValue); + if (pAllFooterBorderProperty && !pFooterBorders[i]) + pFooterNewBorders[i] = new XMLPropertyState(pAllFooterBorderProperty->mnIndex + 1 + i, pAllFooterBorderProperty->maValue); + if( !pFooterBorderWidths[i] ) + pFooterBorderWidths[i] = pAllFooterBorderWidthProperty; + else + pFooterBorderWidths[i]->mnIndex = -1; + if( pFooterBorders[i] ) + { + table::BorderLine2 aBorderLine; + pFooterBorders[i]->maValue >>= aBorderLine; + if( pFooterBorderWidths[i] ) + { + table::BorderLine2 aBorderLineWidth; + pFooterBorderWidths[i]->maValue >>= aBorderLineWidth; + aBorderLine.OuterLineWidth = aBorderLineWidth.OuterLineWidth; + aBorderLine.InnerLineWidth = aBorderLineWidth.InnerLineWidth; + aBorderLine.LineDistance = aBorderLineWidth.LineDistance; + aBorderLine.LineWidth = aBorderLineWidth.LineWidth; + pFooterBorders[i]->maValue <<= aBorderLine; + } + } + } + + if (pHeaderHeight) + { + xHeaderDynamic.emplace(pHeaderHeight->mnIndex + 2, Any(false)); + } + if (pHeaderMinHeight) + { + xHeaderDynamic.emplace(pHeaderMinHeight->mnIndex + 1, Any(true)); + } + if (pFooterHeight) + { + xFooterDynamic.emplace(pFooterHeight->mnIndex + 2, Any(false)); + } + if (pFooterMinHeight) + { + xFooterDynamic.emplace(pFooterMinHeight->mnIndex + 1, Any(true)); + } + + // fdo#38056: nerf the various AllFoo properties so they do not override + // the individual Foo properties later on + if (pAllPaddingProperty) + { + pAllPaddingProperty->mnIndex = -1; + } + if (pAllBorderProperty) + { + pAllBorderProperty->mnIndex = -1; + } + if (pAllBorderWidthProperty) + { + pAllBorderWidthProperty->mnIndex = -1; + } + if (pAllHeaderPaddingProperty) + { + pAllHeaderPaddingProperty->mnIndex = -1; + } + if (pAllHeaderBorderProperty) + { + pAllHeaderBorderProperty->mnIndex = -1; + } + if (pAllHeaderBorderWidthProperty) + { + pAllHeaderBorderWidthProperty->mnIndex = -1; + } + if (pAllFooterPaddingProperty) + { + pAllFooterPaddingProperty->mnIndex = -1; + } + if (pAllFooterBorderProperty) + { + pAllFooterBorderProperty->mnIndex = -1; + } + if (pAllFooterBorderWidthProperty) + { + pAllFooterBorderWidthProperty->mnIndex = -1; + } + if (pAllMarginProperty) + { + pAllMarginProperty->mnIndex = -1; + } + if (pAllHeaderMarginProperty) + { + pAllHeaderMarginProperty->mnIndex = -1; + } + if (pAllFooterMarginProperty) + { + pAllFooterMarginProperty->mnIndex = -1; + } + + if (pMarginGutter) + { + sal_Int32 nGutterMargin{}; + pMarginGutter->maValue >>= nGutterMargin; + + bool bGutterAtTop{}; + uno::Reference<lang::XServiceInfo> xSI(GetImport().GetModel(), uno::UNO_QUERY); + if (xSI.is() && xSI->supportsService("com.sun.star.text.TextDocument")) + { + uno::Reference<lang::XMultiServiceFactory> xFac(GetImport().GetModel(), uno::UNO_QUERY); + if (xFac.is()) + { + uno::Reference<beans::XPropertySet> xProps( + xFac->createInstance("com.sun.star.document.Settings"), uno::UNO_QUERY); + if (xProps.is()) + { + xProps->getPropertyValue("GutterAtTop") >>= bGutterAtTop; + } + } + } + if (bGutterAtTop) + { + if (nGutterMargin && pMargins[XML_LINE_TOP]) + { + // Decrease top margin to not include gutter. + sal_Int32 nTopMargin{}; + pMargins[XML_LINE_TOP]->maValue >>= nTopMargin; + nTopMargin -= nGutterMargin; + pMargins[XML_LINE_TOP]->maValue <<= nTopMargin; + } + } + else + { + bool bRtlGutter{}; + if (nGutterMargin && pRtlGutter) + { + pRtlGutter->maValue >>= bRtlGutter; + } + if (bRtlGutter) + { + if (nGutterMargin && pMargins[XML_LINE_RIGHT]) + { + // Decrease right margin to not include gutter. + sal_Int32 nRightMargin{}; + pMargins[XML_LINE_RIGHT]->maValue >>= nRightMargin; + nRightMargin -= nGutterMargin; + pMargins[XML_LINE_RIGHT]->maValue <<= nRightMargin; + } + } + else + { + if (nGutterMargin && pMargins[XML_LINE_LEFT]) + { + // Decrease left margin to not include gutter. + sal_Int32 nLeftMargin{}; + pMargins[XML_LINE_LEFT]->maValue >>= nLeftMargin; + nLeftMargin -= nGutterMargin; + pMargins[XML_LINE_LEFT]->maValue <<= nLeftMargin; + } + } + } + } + + // CAUTION! + // The following code adds into the rProperties vector, so all the + // XMLPropertyState* pointers that are pointing to the rProperties + // elements could potentially be deallocated, so don't use them after + // this! + for (sal_uInt16 i = 0; i < 4; i++) + { + if (pNewMargins[i]) + { + rProperties.push_back(*pNewMargins[i]); + } + if (pNewHeaderMargins[i]) + { + rProperties.push_back(*pNewHeaderMargins[i]); + } + if (pNewFooterMargins[i]) + { + rProperties.push_back(*pNewFooterMargins[i]); + } + if (pNewPadding[i]) + { + rProperties.push_back(*pNewPadding[i]); + delete pNewPadding[i]; + } + if (pNewBorders[i]) + { + rProperties.push_back(*pNewBorders[i]); + delete pNewBorders[i]; + } + if (pHeaderNewPadding[i]) + { + rProperties.push_back(*pHeaderNewPadding[i]); + delete pHeaderNewPadding[i]; + } + if (pHeaderNewBorders[i]) + { + rProperties.push_back(*pHeaderNewBorders[i]); + delete pHeaderNewBorders[i]; + } + if (pFooterNewPadding[i]) + { + rProperties.push_back(*pFooterNewPadding[i]); + delete pFooterNewPadding[i]; + } + if (pFooterNewBorders[i]) + { + rProperties.push_back(*pFooterNewBorders[i]); + delete pFooterNewBorders[i]; + } + } + // CAUTION - do not use XMLPropertyState* pointers (like pMargins, + // pMarginGutter) after this. + + if(xHeaderDynamic) + { + rProperties.push_back(*xHeaderDynamic); + xHeaderDynamic.reset(); + } + if(xFooterDynamic) + { + rProperties.push_back(*xFooterDynamic); + xFooterDynamic.reset(); + } + +} +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |