xmloff/source/style/PageMasterExportPropMapper.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "PageMasterExportPropMapper.hxx"
  21 #include <xmloff/xmlprmap.hxx>
  22 #include <xmloff/xmlexp.hxx>
  23 #include <comphelper/types.hxx>
  24 #include <com/sun/star/beans/XPropertySet.hpp>
  25 #include <com/sun/star/table/BorderLine2.hpp>
  26 #include <PageMasterStyleMap.hxx>
  27 #include <rtl/ref.hxx>
  28 #include <comphelper/extract.hxx>
  29
  30 using namespace ::com::sun::star;
  31 using namespace ::com::sun::star::uno;
  32 using namespace ::com::sun::star::beans;
  33 using namespace ::comphelper;
  34
  35 static bool lcl_HasSameLineWidth( const table::BorderLine2& rLine1, const table::BorderLine2& rLine2 )
  36 {
  37     return  (rLine1.InnerLineWidth == rLine2.InnerLineWidth) &&
  38             (rLine1.OuterLineWidth == rLine2.OuterLineWidth) &&
  39             (rLine1.LineDistance == rLine2.LineDistance) &&
  40             (rLine1.LineWidth == rLine2.LineWidth);
  41 }
  42
  43 static void lcl_RemoveState( XMLPropertyState* pState )
  44 {
  45     pState->mnIndex = -1;
  46     pState->maValue.clear();
  47 }
  48
  49 static void lcl_RemoveStateIfZero16( XMLPropertyState* pState )
  50 {
  51     sal_Int16   nValue = sal_Int16();
  52     if( (pState->maValue >>= nValue) && !nValue )
  53         lcl_RemoveState( pState );
  54 }
  55
  56 static void lcl_AddState(::std::vector< XMLPropertyState >& rPropState, sal_Int32 nIndex, const OUString& rProperty, const uno::Reference< beans::XPropertySet >& xProps)
  57 {
  58     if(::cppu::any2bool(xProps->getPropertyValue(rProperty)))
  59         rPropState.emplace_back(nIndex, css::uno::Any(true));
  60 }
  61
  62 // helper struct to handle equal XMLPropertyState's for page, header and footer
  63
  64 namespace {
  65
  66 struct XMLPropertyStateBuffer
  67 {
  68     XMLPropertyState*       pPMMarginAll;
  69
  70     XMLPropertyState*       pPMBorderAll;
  71     XMLPropertyState*       pPMBorderTop;
  72     XMLPropertyState*       pPMBorderBottom;
  73     XMLPropertyState*       pPMBorderLeft;
  74     XMLPropertyState*       pPMBorderRight;
  75
  76     XMLPropertyState*       pPMBorderWidthAll;
  77     XMLPropertyState*       pPMBorderWidthTop;
  78     XMLPropertyState*       pPMBorderWidthBottom;
  79     XMLPropertyState*       pPMBorderWidthLeft;
  80     XMLPropertyState*       pPMBorderWidthRight;
  81
  82     XMLPropertyState*       pPMPaddingAll;
  83     XMLPropertyState*       pPMPaddingTop;
  84     XMLPropertyState*       pPMPaddingBottom;
  85     XMLPropertyState*       pPMPaddingLeft;
  86     XMLPropertyState*       pPMPaddingRight;
  87
  88     XMLPropertyState*       pPMMarginGutter;
  89     XMLPropertyState*       pPMMarginLeft;
  90     XMLPropertyState*       pPMRtlGutter;
  91     XMLPropertyState*       pPMMarginRight;
  92     bool                    m_bGutterAtTop;
  93     XMLPropertyState*       pPMMarginTop;
  94
  95                             XMLPropertyStateBuffer();
  96     void                    ContextFilter( ::std::vector< XMLPropertyState >& rPropState );
  97 };
  98
  99 }
 100
 101 XMLPropertyStateBuffer::XMLPropertyStateBuffer()
 102     :   pPMMarginAll( nullptr )
 103     ,
 104         pPMBorderAll( nullptr ),
 105         pPMBorderTop( nullptr ),
 106         pPMBorderBottom( nullptr ),
 107         pPMBorderLeft( nullptr ),
 108         pPMBorderRight( nullptr ),
 109
 110         pPMBorderWidthAll( nullptr ),
 111         pPMBorderWidthTop( nullptr ),
 112         pPMBorderWidthBottom( nullptr ),
 113         pPMBorderWidthLeft( nullptr ),
 114         pPMBorderWidthRight( nullptr ),
 115
 116         pPMPaddingAll( nullptr ),
 117         pPMPaddingTop( nullptr ),
 118         pPMPaddingBottom( nullptr ),
 119         pPMPaddingLeft( nullptr ),
 120         pPMPaddingRight( nullptr ),
 121
 122         pPMMarginGutter( nullptr ),
 123         pPMMarginLeft( nullptr ),
 124         pPMRtlGutter( nullptr ),
 125         pPMMarginRight( nullptr ),
 126         m_bGutterAtTop( false ),
 127         pPMMarginTop( nullptr )
 128 {
 129 }
 130
 131 void XMLPropertyStateBuffer::ContextFilter( ::std::vector< XMLPropertyState >& )
 132 {
 133     if (pPMMarginGutter)
 134     {
 135         sal_Int32 nGutterMargin{};
 136         pPMMarginGutter->maValue >>= nGutterMargin;
 137         if (m_bGutterAtTop)
 138         {
 139             if (nGutterMargin && pPMMarginTop)
 140             {
 141                 // Increase top margin to include gutter.
 142                 sal_Int32 nTopMargin{};
 143                 pPMMarginTop->maValue >>= nTopMargin;
 144                 nTopMargin += nGutterMargin;
 145                 pPMMarginTop->maValue <<= nTopMargin;
 146             }
 147         }
 148         else
 149         {
 150             bool bRtlGutter{};
 151             if (nGutterMargin && pPMRtlGutter)
 152             {
 153                 pPMRtlGutter->maValue >>= bRtlGutter;
 154             }
 155             if (bRtlGutter)
 156             {
 157                 if (nGutterMargin && pPMMarginRight)
 158                 {
 159                     // Increase right margin to include gutter.
 160                     sal_Int32 nRightMargin{};
 161                     pPMMarginRight->maValue >>= nRightMargin;
 162                     nRightMargin += nGutterMargin;
 163                     pPMMarginRight->maValue <<= nRightMargin;
 164                 }
 165             }
 166             else
 167             {
 168                 if (nGutterMargin && pPMMarginLeft)
 169                 {
 170                     // Increase left margin to include gutter.
 171                     sal_Int32 nLeftMargin{};
 172                     pPMMarginLeft->maValue >>= nLeftMargin;
 173                     nLeftMargin += nGutterMargin;
 174                     pPMMarginLeft->maValue <<= nLeftMargin;
 175                 }
 176             }
 177         }
 178     }
 179
 180     if (pPMMarginAll)
 181     {
 182         lcl_RemoveState(pPMMarginAll); // #i117696# do not write fo:margin
 183     }
 184
 185     if( pPMBorderAll )
 186     {
 187         if( pPMBorderTop && pPMBorderBottom && pPMBorderLeft && pPMBorderRight )
 188         {
 189             table::BorderLine2 aLineTop, aLineBottom, aLineLeft, aLineRight;
 190
 191             pPMBorderTop->maValue >>= aLineTop;
 192             pPMBorderBottom->maValue >>= aLineBottom;
 193             pPMBorderLeft->maValue >>= aLineLeft;
 194             pPMBorderRight->maValue >>= aLineRight;
 195
 196             if( (aLineTop == aLineBottom) && (aLineBottom == aLineLeft) && (aLineLeft == aLineRight) )
 197             {
 198                 lcl_RemoveState( pPMBorderTop );
 199                 lcl_RemoveState( pPMBorderBottom );
 200                 lcl_RemoveState( pPMBorderLeft );
 201                 lcl_RemoveState( pPMBorderRight );
 202             }
 203             else
 204                 lcl_RemoveState( pPMBorderAll );
 205         }
 206         else
 207             lcl_RemoveState( pPMBorderAll );
 208     }
 209
 210     if( pPMBorderWidthAll )
 211     {
 212         if( pPMBorderWidthTop && pPMBorderWidthBottom && pPMBorderWidthLeft && pPMBorderWidthRight )
 213         {
 214             table::BorderLine2 aLineTop, aLineBottom, aLineLeft, aLineRight;
 215
 216             pPMBorderWidthTop->maValue >>= aLineTop;
 217             pPMBorderWidthBottom->maValue >>= aLineBottom;
 218             pPMBorderWidthLeft->maValue >>= aLineLeft;
 219             pPMBorderWidthRight->maValue >>= aLineRight;
 220
 221             if( lcl_HasSameLineWidth( aLineTop, aLineBottom ) &&
 222                 lcl_HasSameLineWidth( aLineBottom, aLineLeft ) &&
 223                 lcl_HasSameLineWidth( aLineLeft, aLineRight ) )
 224             {
 225                 lcl_RemoveState( pPMBorderWidthTop );
 226                 lcl_RemoveState( pPMBorderWidthBottom );
 227                 lcl_RemoveState( pPMBorderWidthLeft );
 228                 lcl_RemoveState( pPMBorderWidthRight );
 229             }
 230             else
 231                 lcl_RemoveState( pPMBorderWidthAll );
 232         }
 233         else
 234             lcl_RemoveState( pPMBorderWidthAll );
 235     }
 236
 237     if( !pPMPaddingAll )
 238         return;
 239
 240     if( pPMPaddingTop && pPMPaddingBottom && pPMPaddingLeft && pPMPaddingRight )
 241     {
 242         sal_Int32 nTop = 0, nBottom = 0, nLeft = 0, nRight = 0;
 243
 244         pPMPaddingTop->maValue >>= nTop;
 245         pPMPaddingBottom->maValue >>= nBottom;
 246         pPMPaddingLeft->maValue >>= nLeft;
 247         pPMPaddingRight->maValue >>= nRight;
 248
 249         if( (nTop == nBottom) && (nBottom == nLeft) && (nLeft == nRight) )
 250         {
 251             lcl_RemoveState( pPMPaddingTop );
 252             lcl_RemoveState( pPMPaddingBottom );
 253             lcl_RemoveState( pPMPaddingLeft );
 254             lcl_RemoveState( pPMPaddingRight );
 255         }
 256         else
 257             lcl_RemoveState( pPMPaddingAll );
 258     }
 259     else
 260         lcl_RemoveState( pPMPaddingAll );
 261 }
 262
 263 XMLPageMasterExportPropMapper::XMLPageMasterExportPropMapper(
 264         const rtl::Reference< XMLPropertySetMapper >& rMapper,
 265         SvXMLExport& rExport ) :
 266     SvXMLExportPropertyMapper( rMapper ),
 267     aBackgroundImageExport( rExport ),
 268     aTextColumnsExport( rExport ),
 269     aFootnoteSeparatorExport( rExport )
 270 {
 271 }
 272
 273 XMLPageMasterExportPropMapper::~XMLPageMasterExportPropMapper()
 274 {
 275 }
 276
 277 void XMLPageMasterExportPropMapper::handleElementItem(
 278         SvXMLExport&,
 279         const XMLPropertyState& rProperty,
 280         SvXmlExportFlags /*nFlags*/,
 281         const ::std::vector< XMLPropertyState >* pProperties,
 282         sal_uInt32 nIdx ) const
 283 {
 284     XMLPageMasterExportPropMapper* pThis = const_cast<XMLPageMasterExportPropMapper*>(this);
 285
 286     sal_uInt32 nContextId = getPropertySetMapper()->GetEntryContextId( rProperty.mnIndex );
 287     switch( nContextId )
 288     {
 289         case CTF_PM_GRAPHICURL:
 290         case CTF_PM_HEADERGRAPHICURL:
 291         case CTF_PM_FOOTERGRAPHICURL:
 292             {
 293                 assert(pProperties);
 294                 assert(nIdx >= 2 && "horrible array ordering borked again");
 295                 sal_Int32 nPos(-1);
 296                 sal_Int32 nFilter(-1);
 297                 switch( nContextId  )
 298                 {
 299                 case CTF_PM_GRAPHICURL:
 300                     nPos = CTF_PM_GRAPHICPOSITION;
 301                     nFilter = CTF_PM_GRAPHICFILTER;
 302                     break;
 303                 case CTF_PM_HEADERGRAPHICURL:
 304                     nPos = CTF_PM_HEADERGRAPHICPOSITION;
 305                     nFilter = CTF_PM_HEADERGRAPHICFILTER;
 306                     break;
 307                 case CTF_PM_FOOTERGRAPHICURL:
 308                     nPos = CTF_PM_FOOTERGRAPHICPOSITION;
 309                     nFilter = CTF_PM_FOOTERGRAPHICFILTER;
 310                     break;
 311                 default:
 312                     assert(false);
 313                 }
 314                 const Any*  pPos    = nullptr;
 315                 const Any*  pFilter = nullptr;
 316                 sal_uInt32 nIndex(nIdx - 1);
 317                 const XMLPropertyState& rFilter = (*pProperties)[nIndex];
 318                 if (getPropertySetMapper()->GetEntryContextId(rFilter.mnIndex) == nFilter)
 319                 {
 320                     pFilter = &rFilter.maValue;
 321                     --nIndex;
 322                 }
 323                 const XMLPropertyState& rPos = (*pProperties)[nIndex];
 324                 if (getPropertySetMapper()->GetEntryContextId(rPos.mnIndex) == nPos)
 325                 {
 326                     pPos = &rPos.maValue;
 327                     --nIndex;
 328                 }
 329                 sal_uInt32 nPropIndex = rProperty.mnIndex;
 330                 pThis->aBackgroundImageExport.exportXML( rProperty.maValue, pPos, pFilter, nullptr,
 331                     getPropertySetMapper()->GetEntryNameSpace( nPropIndex ),
 332                     getPropertySetMapper()->GetEntryXMLName( nPropIndex ) );
 333             }
 334             break;
 335         case CTF_PM_TEXTCOLUMNS:
 336             pThis->aTextColumnsExport.exportXML( rProperty.maValue );
 337             break;
 338         case CTF_PM_FTN_LINE_WEIGHT:
 339             pThis->aFootnoteSeparatorExport.exportXML( pProperties, nIdx,
 340                                                        getPropertySetMapper());
 341             break;
 342     }
 343 }
 344
 345 void XMLPageMasterExportPropMapper::handleSpecialItem(
 346         comphelper::AttributeList&,
 347         const XMLPropertyState&,
 348         const SvXMLUnitConverter&,
 349         const SvXMLNamespaceMap&,
 350         const ::std::vector< XMLPropertyState >*,
 351         sal_uInt32 /*nIdx*/) const
 352 {
 353 }
 354
 355 void XMLPageMasterExportPropMapper::ContextFilter(
 356         bool bEnableFoFontFamily,
 357         ::std::vector< XMLPropertyState >& rPropState,
 358         const Reference< XPropertySet >& rPropSet ) const
 359 {
 360     XMLPropertyStateBuffer  aPageBuffer;
 361     if (m_bGutterAtTop)
 362     {
 363         aPageBuffer.m_bGutterAtTop = true;
 364     }
 365
 366     XMLPropertyStateBuffer  aHeaderBuffer;
 367     XMLPropertyStateBuffer  aFooterBuffer;
 368
 369     XMLPropertyState*       pPMHeaderHeight     = nullptr;
 370     XMLPropertyState*       pPMHeaderMinHeight  = nullptr;
 371     XMLPropertyState*       pPMHeaderDynamic    = nullptr;
 372
 373     XMLPropertyState*       pPMFooterHeight     = nullptr;
 374     XMLPropertyState*       pPMFooterMinHeight  = nullptr;
 375     XMLPropertyState*       pPMFooterDynamic    = nullptr;
 376
 377     XMLPropertyState*       pPMScaleTo          = nullptr;
 378     XMLPropertyState*       pPMScaleToPages     = nullptr;
 379     XMLPropertyState*       pPMScaleToX         = nullptr;
 380     XMLPropertyState*       pPMScaleToY         = nullptr;
 381     XMLPropertyState*       pPMStandardMode     = nullptr;
 382     XMLPropertyState*       pPMGridBaseWidth    = nullptr;
 383     // same as pPMGridSnapTo but for backward compatibility only
 384     XMLPropertyState*       pPMGridSnapToChars  = nullptr;
 385     XMLPropertyState*       pPMGridSnapTo       = nullptr;
 386
 387     XMLPropertyState*       pPrint              = nullptr;
 388
 389     XMLPropertyState* pRepeatOffsetX = nullptr;
 390     XMLPropertyState* pRepeatOffsetY = nullptr;
 391     XMLPropertyState* pHeaderRepeatOffsetX = nullptr;
 392     XMLPropertyState* pHeaderRepeatOffsetY = nullptr;
 393     XMLPropertyState* pFooterRepeatOffsetX = nullptr;
 394     XMLPropertyState* pFooterRepeatOffsetY = nullptr;
 395
 396     rtl::Reference < XMLPropertySetMapper > aPropMapper(getPropertySetMapper());
 397
 398     // distinguish 2 cases: drawing-page export has CTF_PM_FILL, page-layout-properties export does not
 399     bool const isDrawingPageExport(aPropMapper->FindEntryIndex(CTF_PM_FILL) != -1);
 400
 401     for( auto& rProp : rPropState )
 402     {
 403         XMLPropertyState *pProp = &rProp;
 404         sal_Int16 nContextId    = aPropMapper->GetEntryContextId( pProp->mnIndex );
 405         sal_Int16 nFlag         = nContextId & CTF_PM_FLAGMASK;
 406         sal_Int16 nSimpleId     = nContextId & (~CTF_PM_FLAGMASK | XML_PM_CTF_START);
 407         sal_Int16 nPrintId      = nContextId & CTF_PM_PRINTMASK;
 408
 409
 410         // tdf#103602 don't export draw:fill attributes on page-layout-properties in strict ODF
 411         if (!isDrawingPageExport
 412             && [](OUString const& rName) -> bool {
 413                 return rName.startsWith("Fill")
 414                     || rName.startsWith("HeaderFill")
 415                     || rName.startsWith("FooterFill");
 416                 } (aPropMapper->GetEntryAPIName(rProp.mnIndex))
 417             && ((aBackgroundImageExport.GetExport().getSaneDefaultVersion()
 418                 & SvtSaveOptions::ODFSVER_EXTENDED) == 0))
 419         {
 420             lcl_RemoveState(&rProp);
 421             continue;
 422         }
 423
 424         XMLPropertyStateBuffer* pBuffer;
 425         switch( nFlag )
 426         {
 427             case CTF_PM_HEADERFLAG:         pBuffer = &aHeaderBuffer;   break;
 428             case CTF_PM_FOOTERFLAG:         pBuffer = &aFooterBuffer;   break;
 429             default:                        pBuffer = &aPageBuffer;     break;
 430         }
 431
 432         switch( nSimpleId )
 433         {
 434             case CTF_PM_MARGINALL:          pBuffer->pPMMarginAll           = pProp;    break;
 435             case CTF_PM_BORDERALL:          pBuffer->pPMBorderAll           = pProp;    break;
 436             case CTF_PM_BORDERTOP:          pBuffer->pPMBorderTop           = pProp;    break;
 437             case CTF_PM_BORDERBOTTOM:       pBuffer->pPMBorderBottom        = pProp;    break;
 438             case CTF_PM_BORDERLEFT:         pBuffer->pPMBorderLeft          = pProp;    break;
 439             case CTF_PM_BORDERRIGHT:        pBuffer->pPMBorderRight         = pProp;    break;
 440             case CTF_PM_BORDERWIDTHALL:     pBuffer->pPMBorderWidthAll      = pProp;    break;
 441             case CTF_PM_BORDERWIDTHTOP:     pBuffer->pPMBorderWidthTop      = pProp;    break;
 442             case CTF_PM_BORDERWIDTHBOTTOM:  pBuffer->pPMBorderWidthBottom   = pProp;    break;
 443             case CTF_PM_BORDERWIDTHLEFT:    pBuffer->pPMBorderWidthLeft     = pProp;    break;
 444             case CTF_PM_BORDERWIDTHRIGHT:   pBuffer->pPMBorderWidthRight    = pProp;    break;
 445             case CTF_PM_PADDINGALL:         pBuffer->pPMPaddingAll          = pProp;    break;
 446             case CTF_PM_PADDINGTOP:         pBuffer->pPMPaddingTop          = pProp;    break;
 447             case CTF_PM_PADDINGBOTTOM:      pBuffer->pPMPaddingBottom       = pProp;    break;
 448             case CTF_PM_PADDINGLEFT:        pBuffer->pPMPaddingLeft         = pProp;    break;
 449             case CTF_PM_PADDINGRIGHT:       pBuffer->pPMPaddingRight        = pProp;    break;
 450             case CTF_PM_MARGINGUTTER:
 451                 pBuffer->pPMMarginGutter = pProp;
 452                 break;
 453             case CTF_PM_MARGINLEFT:
 454                 pBuffer->pPMMarginLeft = pProp;
 455                 break;
 456             case CTF_PM_RTLGUTTER:
 457                 pBuffer->pPMRtlGutter = pProp;
 458                 break;
 459             case CTF_PM_MARGINRIGHT:
 460                 pBuffer->pPMMarginRight = pProp;
 461                 break;
 462             case CTF_PM_MARGINTOP:
 463                 pBuffer->pPMMarginTop = pProp;
 464                 break;
 465         }
 466
 467         switch( nContextId )
 468         {
 469             case CTF_PM_HEADERHEIGHT:       pPMHeaderHeight     = pProp;    break;
 470             case CTF_PM_HEADERMINHEIGHT:    pPMHeaderMinHeight  = pProp;    break;
 471             case CTF_PM_HEADERDYNAMIC:      pPMHeaderDynamic    = pProp;    break;
 472             case CTF_PM_FOOTERHEIGHT:       pPMFooterHeight     = pProp;    break;
 473             case CTF_PM_FOOTERMINHEIGHT:    pPMFooterMinHeight  = pProp;    break;
 474             case CTF_PM_FOOTERDYNAMIC:      pPMFooterDynamic    = pProp;    break;
 475             case CTF_PM_SCALETO:            pPMScaleTo          = pProp;    break;
 476             case CTF_PM_SCALETOPAGES:       pPMScaleToPages     = pProp;    break;
 477             case CTF_PM_SCALETOX:           pPMScaleToX         = pProp;    break;
 478             case CTF_PM_SCALETOY:           pPMScaleToY         = pProp;    break;
 479             case CTF_PM_STANDARD_MODE:      pPMStandardMode     = pProp;    break;
 480             case CTP_PM_GRID_BASE_WIDTH:        pPMGridBaseWidth    = pProp;    break;
 481             case CTP_PM_GRID_SNAP_TO_CHARS:     pPMGridSnapToChars  = pProp;    break;
 482             case CTP_PM_GRID_SNAP_TO:       pPMGridSnapTo = pProp;    break;
 483
 484             case CTF_PM_REPEAT_OFFSET_X:
 485                 pRepeatOffsetX = pProp;
 486                 break;
 487
 488             case CTF_PM_REPEAT_OFFSET_Y:
 489                 pRepeatOffsetY = pProp;
 490                 break;
 491
 492             case CTF_PM_HEADERREPEAT_OFFSET_X:
 493                 pHeaderRepeatOffsetX = pProp;
 494                 break;
 495
 496             case CTF_PM_HEADERREPEAT_OFFSET_Y:
 497                 pHeaderRepeatOffsetY = pProp;
 498                 break;
 499
 500             case CTF_PM_FOOTERREPEAT_OFFSET_X:
 501                 pFooterRepeatOffsetX = pProp;
 502                 break;
 503
 504             case CTF_PM_FOOTERREPEAT_OFFSET_Y:
 505                 pFooterRepeatOffsetY = pProp;
 506                 break;
 507
 508             // Sort out empty entries
 509             case CTF_PM_FILLGRADIENTNAME:
 510             case CTF_PM_FILLHATCHNAME:
 511             case CTF_PM_FILLBITMAPNAME:
 512             case CTF_PM_FILLTRANSNAME:
 513
 514             case CTF_PM_HEADERFILLGRADIENTNAME:
 515             case CTF_PM_HEADERFILLHATCHNAME:
 516             case CTF_PM_HEADERFILLBITMAPNAME:
 517             case CTF_PM_HEADERFILLTRANSNAME:
 518
 519             case CTF_PM_FOOTERFILLGRADIENTNAME:
 520             case CTF_PM_FOOTERFILLHATCHNAME:
 521             case CTF_PM_FOOTERFILLBITMAPNAME:
 522             case CTF_PM_FOOTERFILLTRANSNAME:
 523             {
 524                 OUString aStr;
 525
 526                 if( (pProp->maValue >>= aStr) && 0 == aStr.getLength() )
 527                 {
 528                     pProp->mnIndex = -1;
 529                 }
 530
 531                 break;
 532             }
 533         }
 534
 535         if (nPrintId == CTF_PM_PRINTMASK)
 536         {
 537             pPrint = pProp;
 538             lcl_RemoveState(pPrint);
 539         }
 540     }
 541
 542     // These entries need to be reduced to a single one for XML export.
 543     // Both would be exported as 'draw:tile-repeat-offset' following a percent
 544     // value and a 'vertical' or 'horizontal' tag as mark. If both would be active
 545     // and both would be exported this would create an XML error (same property twice)
 546     if(pRepeatOffsetX && pRepeatOffsetY)
 547     {
 548         sal_Int32 nOffset(0);
 549
 550         if((pRepeatOffsetX->maValue >>= nOffset) && (!nOffset))
 551         {
 552             pRepeatOffsetX->mnIndex = -1;
 553         }
 554         else
 555         {
 556             pRepeatOffsetY->mnIndex = -1;
 557         }
 558     }
 559
 560     // Same as above for Header
 561     if(pHeaderRepeatOffsetX && pHeaderRepeatOffsetY)
 562     {
 563         sal_Int32 nOffset(0);
 564
 565         if((pHeaderRepeatOffsetX->maValue >>= nOffset) && (!nOffset))
 566         {
 567             pHeaderRepeatOffsetX->mnIndex = -1;
 568         }
 569         else
 570         {
 571             pHeaderRepeatOffsetY->mnIndex = -1;
 572         }
 573     }
 574
 575     // Same as above for Footer
 576     if(pFooterRepeatOffsetX && pFooterRepeatOffsetY)
 577     {
 578         sal_Int32 nOffset(0);
 579
 580         if((pFooterRepeatOffsetX->maValue >>= nOffset) && (!nOffset))
 581         {
 582             pFooterRepeatOffsetX->mnIndex = -1;
 583         }
 584         else
 585         {
 586             pFooterRepeatOffsetY->mnIndex = -1;
 587         }
 588     }
 589
 590     if( pPMStandardMode && !getBOOL(pPMStandardMode->maValue) )
 591     {
 592         lcl_RemoveState(pPMStandardMode);
 593         if( pPMGridBaseWidth )
 594             lcl_RemoveState(pPMGridBaseWidth);
 595         if( pPMGridSnapToChars )
 596             lcl_RemoveState(pPMGridSnapToChars);
 597         if (pPMGridSnapTo)
 598         {
 599             lcl_RemoveState(pPMGridSnapTo);
 600         }
 601     }
 602
 603     if( pPMGridBaseWidth && pPMStandardMode )
 604         lcl_RemoveState(pPMStandardMode);
 605
 606     aPageBuffer.ContextFilter( rPropState );
 607     aHeaderBuffer.ContextFilter( rPropState );
 608     aFooterBuffer.ContextFilter( rPropState );
 609
 610     if( pPMHeaderHeight && (!pPMHeaderDynamic || getBOOL( pPMHeaderDynamic->maValue )) )
 611         lcl_RemoveState( pPMHeaderHeight );
 612     if( pPMHeaderMinHeight && pPMHeaderDynamic && !getBOOL( pPMHeaderDynamic->maValue ) )
 613         lcl_RemoveState( pPMHeaderMinHeight );
 614     if( pPMHeaderDynamic )
 615         lcl_RemoveState( pPMHeaderDynamic );
 616
 617     if( pPMFooterHeight && (!pPMFooterDynamic || getBOOL( pPMFooterDynamic->maValue )) )
 618         lcl_RemoveState( pPMFooterHeight );
 619     if( pPMFooterMinHeight && pPMFooterDynamic && !getBOOL( pPMFooterDynamic->maValue ) )
 620         lcl_RemoveState( pPMFooterMinHeight );
 621     if( pPMFooterDynamic )
 622         lcl_RemoveState( pPMFooterDynamic );
 623
 624     if( pPMScaleTo )
 625         lcl_RemoveStateIfZero16( pPMScaleTo );
 626     if( pPMScaleToPages )
 627         lcl_RemoveStateIfZero16( pPMScaleToPages );
 628     if( pPMScaleToX )
 629         lcl_RemoveStateIfZero16( pPMScaleToX );
 630     if( pPMScaleToY )
 631         lcl_RemoveStateIfZero16( pPMScaleToY );
 632
 633     if (pPrint)
 634     {
 635         lcl_AddState(rPropState, aPropMapper->FindEntryIndex(CTF_PM_PRINT_ANNOTATIONS), u"PrintAnnotations"_ustr, rPropSet);
 636         lcl_AddState(rPropState, aPropMapper->FindEntryIndex(CTF_PM_PRINT_CHARTS), u"PrintCharts"_ustr, rPropSet);
 637         lcl_AddState(rPropState, aPropMapper->FindEntryIndex(CTF_PM_PRINT_DRAWING), u"PrintDrawing"_ustr, rPropSet);
 638         lcl_AddState(rPropState, aPropMapper->FindEntryIndex(CTF_PM_PRINT_FORMULAS), u"PrintFormulas"_ustr, rPropSet);
 639         lcl_AddState(rPropState, aPropMapper->FindEntryIndex(CTF_PM_PRINT_GRID), u"PrintGrid"_ustr, rPropSet);
 640         lcl_AddState(rPropState, aPropMapper->FindEntryIndex(CTF_PM_PRINT_HEADERS), u"PrintHeaders"_ustr, rPropSet);
 641         lcl_AddState(rPropState, aPropMapper->FindEntryIndex(CTF_PM_PRINT_OBJECTS), u"PrintObjects"_ustr, rPropSet);
 642         lcl_AddState(rPropState, aPropMapper->FindEntryIndex(CTF_PM_PRINT_ZEROVALUES), u"PrintZeroValues"_ustr, rPropSet);
 643     }
 644
 645     SvXMLExportPropertyMapper::ContextFilter(bEnableFoFontFamily, rPropState, rPropSet);
 646 }
 647
 648 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */