| /************************************************************** |
| * |
| * 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 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_xmloff.hxx" |
| |
| #include "PageMasterImportPropMapper.hxx" |
| #include "PageMasterPropMapper.hxx" |
| #include <xmloff/PageMasterStyleMap.hxx> |
| #include <xmloff/maptype.hxx> |
| #include <com/sun/star/table/BorderLine.hpp> |
| #include <com/sun/star/container/XNameContainer.hpp> |
| #include <xmloff/xmlimp.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 UniReference< XMLPropertySetMapper >& rMapper, |
| SvXMLImport& rImp ) : |
| SvXMLImportPropertyMapper( rMapper, rImp ), |
| rImport( rImp ) |
| { |
| } |
| |
| PageMasterImportPropertyMapper::~PageMasterImportPropertyMapper() |
| { |
| } |
| |
| sal_Bool PageMasterImportPropertyMapper::handleSpecialItem( |
| XMLPropertyState& rProperty, |
| ::std::vector< XMLPropertyState >& rProperties, |
| const ::rtl::OUString& rValue, |
| const SvXMLUnitConverter& rUnitConverter, |
| const SvXMLNamespaceMap& rNamespaceMap ) const |
| { |
| sal_Bool bRet = sal_False; |
| sal_Int16 nContextID = |
| getPropertySetMapper()->GetEntryContextId(rProperty.mnIndex); |
| |
| if( CTF_PM_REGISTER_STYLE==nContextID ) |
| { |
| ::rtl::OUString sDisplayName( rImport.GetStyleDisplayName( |
| XML_STYLE_FAMILY_TEXT_PARAGRAPH, rValue ) ); |
| Reference < XNameContainer > xParaStyles = |
| rImport.GetTextImport()->GetParaStyles(); |
| if( xParaStyles.is() && xParaStyles->hasByName( sDisplayName ) ) |
| { |
| rProperty.maValue <<= sDisplayName; |
| bRet = sal_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 = NULL; |
| XMLPropertyState* pPadding[4] = { NULL, NULL, NULL, NULL }; |
| XMLPropertyState* pNewPadding[4] = { NULL, NULL, NULL, NULL }; |
| XMLPropertyState* pAllBorderProperty = NULL; |
| XMLPropertyState* pBorders[4] = { NULL, NULL, NULL, NULL }; |
| XMLPropertyState* pNewBorders[4] = { NULL, NULL, NULL, NULL }; |
| XMLPropertyState* pAllBorderWidthProperty = NULL; |
| XMLPropertyState* pBorderWidths[4] = { NULL, NULL, NULL, NULL }; |
| XMLPropertyState* pAllHeaderPaddingProperty = NULL; |
| XMLPropertyState* pHeaderPadding[4] = { NULL, NULL, NULL, NULL }; |
| XMLPropertyState* pHeaderNewPadding[4] = { NULL, NULL, NULL, NULL }; |
| XMLPropertyState* pAllHeaderBorderProperty = NULL; |
| XMLPropertyState* pHeaderBorders[4] = { NULL, NULL, NULL, NULL }; |
| XMLPropertyState* pHeaderNewBorders[4] = { NULL, NULL, NULL, NULL }; |
| XMLPropertyState* pAllHeaderBorderWidthProperty = NULL; |
| XMLPropertyState* pHeaderBorderWidths[4] = { NULL, NULL, NULL, NULL }; |
| XMLPropertyState* pAllFooterPaddingProperty = NULL; |
| XMLPropertyState* pFooterPadding[4] = { NULL, NULL, NULL, NULL }; |
| XMLPropertyState* pFooterNewPadding[4] = { NULL, NULL, NULL, NULL }; |
| XMLPropertyState* pAllFooterBorderProperty = NULL; |
| XMLPropertyState* pFooterBorders[4] = { NULL, NULL, NULL, NULL }; |
| XMLPropertyState* pFooterNewBorders[4] = { NULL, NULL, NULL, NULL }; |
| XMLPropertyState* pAllFooterBorderWidthProperty = NULL; |
| XMLPropertyState* pFooterBorderWidths[4] = { NULL, NULL, NULL, NULL }; |
| XMLPropertyState* pHeaderHeight = NULL; |
| XMLPropertyState* pHeaderMinHeight = NULL; |
| XMLPropertyState* pHeaderDynamic = NULL; |
| XMLPropertyState* pFooterHeight = NULL; |
| XMLPropertyState* pFooterMinHeight = NULL; |
| XMLPropertyState* pFooterDynamic = NULL; |
| XMLPropertyState* pAllMarginProperty = NULL; |
| XMLPropertyState* pMargins[4] = { NULL, NULL, NULL, NULL }; |
| ::std::auto_ptr<XMLPropertyState> pNewMargins[4]; |
| XMLPropertyState* pAllHeaderMarginProperty = NULL; |
| XMLPropertyState* pHeaderMargins[4] = { NULL, NULL, NULL, NULL }; |
| ::std::auto_ptr<XMLPropertyState> pNewHeaderMargins[4]; |
| XMLPropertyState* pAllFooterMarginProperty = NULL; |
| XMLPropertyState* pFooterMargins[4] = { NULL, NULL, NULL, NULL }; |
| ::std::auto_ptr<XMLPropertyState> pNewFooterMargins[4]; |
| |
| ::std::vector< XMLPropertyState >::iterator aEnd = rProperties.end(); |
| for (::std::vector< XMLPropertyState >::iterator aIter = rProperties.begin(); aIter != aEnd; ++aIter) |
| { |
| XMLPropertyState *property = &(*aIter); |
| 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_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].reset(new XMLPropertyState( |
| pAllMarginProperty->mnIndex + 1 + i, |
| pAllMarginProperty->maValue)); |
| } |
| if (pAllHeaderMarginProperty && !pHeaderMargins[i]) |
| { |
| pNewHeaderMargins[i].reset(new XMLPropertyState( |
| pAllHeaderMarginProperty->mnIndex + 1 + i, |
| pAllHeaderMarginProperty->maValue)); |
| } |
| if (pAllFooterMarginProperty && !pFooterMargins[i]) |
| { |
| pNewFooterMargins[i].reset(new XMLPropertyState( |
| 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::BorderLine aBorderLine; |
| pBorders[i]->maValue >>= aBorderLine; |
| if( pBorderWidths[i] ) |
| { |
| table::BorderLine aBorderLineWidth; |
| pBorderWidths[i]->maValue >>= aBorderLineWidth; |
| aBorderLine.OuterLineWidth = aBorderLineWidth.OuterLineWidth; |
| aBorderLine.InnerLineWidth = aBorderLineWidth.InnerLineWidth; |
| aBorderLine.LineDistance = aBorderLineWidth.LineDistance; |
| 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::BorderLine aBorderLine; |
| pHeaderBorders[i]->maValue >>= aBorderLine; |
| if( pHeaderBorderWidths[i] ) |
| { |
| table::BorderLine aBorderLineWidth; |
| pHeaderBorderWidths[i]->maValue >>= aBorderLineWidth; |
| aBorderLine.OuterLineWidth = aBorderLineWidth.OuterLineWidth; |
| aBorderLine.InnerLineWidth = aBorderLineWidth.InnerLineWidth; |
| aBorderLine.LineDistance = aBorderLineWidth.LineDistance; |
| 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::BorderLine aBorderLine; |
| pFooterBorders[i]->maValue >>= aBorderLine; |
| if( pFooterBorderWidths[i] ) |
| { |
| table::BorderLine aBorderLineWidth; |
| pFooterBorderWidths[i]->maValue >>= aBorderLineWidth; |
| aBorderLine.OuterLineWidth = aBorderLineWidth.OuterLineWidth; |
| aBorderLine.InnerLineWidth = aBorderLineWidth.InnerLineWidth; |
| aBorderLine.LineDistance = aBorderLineWidth.LineDistance; |
| pFooterBorders[i]->maValue <<= aBorderLine; |
| } |
| } |
| } |
| |
| if (pHeaderHeight) |
| { |
| sal_Bool bValue(sal_False); |
| uno::Any aAny; |
| aAny.setValue( &bValue, ::getBooleanCppuType() ); |
| pHeaderDynamic = new XMLPropertyState(pHeaderHeight->mnIndex + 2, aAny); |
| } |
| if (pHeaderMinHeight) |
| { |
| sal_Bool bValue(sal_True); |
| uno::Any aAny; |
| aAny.setValue( &bValue, ::getBooleanCppuType() ); |
| pHeaderDynamic = new XMLPropertyState(pHeaderMinHeight->mnIndex + 1, aAny); |
| } |
| if (pFooterHeight) |
| { |
| sal_Bool bValue(sal_False); |
| uno::Any aAny; |
| aAny.setValue( &bValue, ::getBooleanCppuType() ); |
| pFooterDynamic = new XMLPropertyState(pFooterHeight->mnIndex + 2, aAny); |
| } |
| if (pFooterMinHeight) |
| { |
| sal_Bool bValue(sal_True); |
| uno::Any aAny; |
| aAny.setValue( &bValue, ::getBooleanCppuType() ); |
| pFooterDynamic = new XMLPropertyState(pFooterMinHeight->mnIndex + 1, aAny); |
| } |
| for (sal_uInt16 i = 0; i < 4; i++) |
| { |
| if (pNewMargins[i].get()) |
| { |
| rProperties.push_back(*pNewMargins[i]); |
| } |
| if (pNewHeaderMargins[i].get()) |
| { |
| rProperties.push_back(*pNewHeaderMargins[i]); |
| } |
| if (pNewFooterMargins[i].get()) |
| { |
| 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]; |
| } |
| } |
| if(pHeaderDynamic) |
| { |
| rProperties.push_back(*pHeaderDynamic); |
| delete pHeaderDynamic; |
| } |
| if(pFooterDynamic) |
| { |
| rProperties.push_back(*pFooterDynamic); |
| delete pFooterDynamic; |
| } |
| } |
| |
