/* -*- 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>

#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(u"com.sun.star.text.TextDocument"_ustr))

        {

            uno::Reference<lang::XMultiServiceFactory> xFac(GetImport().GetModel(), uno::UNO_QUERY);

            if (xFac.is())

            {

                uno::Reference<beans::XPropertySet> xProps(

                    xFac->createInstance(u"com.sun.star.document.Settings"_ustr), uno::UNO_QUERY);

                if (xProps.is())

                {

                    xProps->getPropertyValue(u"GutterAtTop"_ustr) >>= 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: */