xmloff/source/style/prstylei.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 <sal/config.h>
  21
  22 #include <o3tl/any.hxx>
  23 #include <osl/diagnose.h>
  24 #include <sal/log.hxx>
  25 #include <set>
  26 #include <xmloff/xmlnamespace.hxx>
  27 #include <xmloff/xmltoken.hxx>
  28 #include <xmloff/xmlprcon.hxx>
  29 #include <com/sun/star/frame/XModel.hpp>
  30 #include <com/sun/star/style/XStyle.hpp>
  31 #include <com/sun/star/style/XAutoStyleFamily.hpp>
  32 #include <com/sun/star/container/XNameContainer.hpp>
  33 #include <com/sun/star/beans/XPropertySet.hpp>
  34 #include <com/sun/star/beans/XPropertyState.hpp>
  35 #include <com/sun/star/beans/XMultiPropertyStates.hpp>
  36 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  37 #include <xmloff/xmlimp.hxx>
  38 #include <xmloff/prstylei.hxx>
  39 #include <xmloff/xmlerror.hxx>
  40 #include <xmloff/xmltypes.hxx>
  41 #include <xmloff/maptype.hxx>
  42 #include <xmloff/xmlimppr.hxx>
  43 #include <xmloff/xmlprmap.hxx>
  44 #include <comphelper/sequence.hxx>
  45 #include <com/sun/star/drawing/FillStyle.hpp>
  46 #include "StylePropertiesContext.hxx"
  47
  48 using namespace ::com::sun::star;
  49 using namespace ::com::sun::star::uno;
  50 using namespace ::com::sun::star::xml::sax;
  51 using namespace ::com::sun::star::style;
  52 using namespace ::com::sun::star::container;
  53 using namespace ::com::sun::star::beans;
  54 using namespace ::com::sun::star::lang;
  55 using namespace ::xmloff::token;
  56 using namespace com::sun::star::drawing;
  57
  58 void XMLPropStyleContext::SetAttribute( sal_Int32 nElement,
  59                                         const OUString& rValue )
  60 {
  61     if( nElement == XML_ELEMENT(STYLE, XML_FAMILY) )
  62     {
  63         SAL_WARN_IF( GetFamily() != SvXMLStylesContext::GetFamily( rValue ), "xmloff", "unexpected style family" );
  64     }
  65     else
  66     {
  67         SvXMLStyleContext::SetAttribute( nElement, rValue );
  68     }
  69 }
  70
  71
  72 namespace
  73 {
  74     const OldFillStyleDefinitionSet & theStandardSet()
  75     {
  76         static const OldFillStyleDefinitionSet theSet = []()
  77             {
  78                 OldFillStyleDefinitionSet aSet;
  79                 aSet.insert("BackColorRGB");
  80                 aSet.insert("BackTransparent");
  81                 aSet.insert("BackColorTransparency");
  82                 aSet.insert("BackGraphic");
  83                 aSet.insert("BackGraphicFilter");
  84                 aSet.insert("BackGraphicLocation");
  85                 aSet.insert("BackGraphicTransparency");
  86                 return aSet;
  87             }();
  88         return theSet;
  89     };
  90     const OldFillStyleDefinitionSet & theHeaderSet()
  91     {
  92         static const OldFillStyleDefinitionSet theSet = []()
  93             {
  94                 OldFillStyleDefinitionSet aSet;
  95                 aSet.insert("HeaderBackColorRGB");
  96                 aSet.insert("HeaderBackTransparent");
  97                 aSet.insert("HeaderBackColorTransparency");
  98                 aSet.insert("HeaderBackGraphic");
  99                 aSet.insert("HeaderBackGraphicFilter");
 100                 aSet.insert("HeaderBackGraphicLocation");
 101                 aSet.insert("HeaderBackGraphicTransparency");
 102                 return aSet;
 103             }();
 104         return theSet;
 105     };
 106     const OldFillStyleDefinitionSet & theFooterSet()
 107     {
 108         static const OldFillStyleDefinitionSet theSet = []()
 109             {
 110                 OldFillStyleDefinitionSet aSet;
 111                 aSet.insert("FooterBackColorRGB");
 112                 aSet.insert("FooterBackTransparent");
 113                 aSet.insert("FooterBackColorTransparency");
 114                 aSet.insert("FooterBackGraphic");
 115                 aSet.insert("FooterBackGraphicFilter");
 116                 aSet.insert("FooterBackGraphicLocation");
 117                 aSet.insert("FooterBackGraphicTransparency");
 118                 return aSet;
 119             }();
 120         return theSet;
 121     };
 122     const OldFillStyleDefinitionSet & theParaSet()
 123     {
 124         static const OldFillStyleDefinitionSet theSet = []()
 125             {
 126                 OldFillStyleDefinitionSet aSet;
 127                 // Caution: here it is *not* 'ParaBackColorRGB' as it should be, but indeed
 128                 // 'ParaBackColor' is used, see aXMLParaPropMap definition (line 313)
 129                 aSet.insert("ParaBackColor");
 130                 aSet.insert("ParaBackTransparent");
 131                 aSet.insert("ParaBackGraphicLocation");
 132                 aSet.insert("ParaBackGraphicFilter");
 133                 aSet.insert("ParaBackGraphic");
 134
 135                 // These are not used in aXMLParaPropMap definition, thus not needed here
 136                 // aSet.insert("ParaBackColorTransparency");
 137                 // aSet.insert("ParaBackGraphicTransparency");
 138                 return aSet;
 139             }();
 140         return theSet;
 141     };
 142 }
 143
 144
 145
 146 constexpr OUStringLiteral gsIsPhysical(  u"IsPhysical"  );
 147 constexpr OUStringLiteral gsFollowStyle(  u"FollowStyle"  );
 148
 149 XMLPropStyleContext::XMLPropStyleContext( SvXMLImport& rImport,
 150         SvXMLStylesContext& rStyles, XmlStyleFamily nFamily,
 151         bool bDefault )
 152 :   SvXMLStyleContext( rImport, nFamily, bDefault )
 153 ,   mxStyles( &rStyles )
 154 {
 155 }
 156
 157 XMLPropStyleContext::~XMLPropStyleContext()
 158 {
 159 }
 160
 161 const OldFillStyleDefinitionSet& XMLPropStyleContext::getStandardSet()
 162 {
 163     return theStandardSet();
 164 }
 165
 166 const OldFillStyleDefinitionSet& XMLPropStyleContext::getHeaderSet()
 167 {
 168     return theHeaderSet();
 169 }
 170
 171 const OldFillStyleDefinitionSet& XMLPropStyleContext::getFooterSet()
 172 {
 173     return theFooterSet();
 174 }
 175
 176 css::uno::Reference< css::xml::sax::XFastContextHandler > XMLPropStyleContext::createFastChildContext(
 177     sal_Int32 nElement,
 178     const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
 179 {
 180     sal_uInt32 nFamily = 0;
 181     if( IsTokenInNamespace(nElement, XML_NAMESPACE_STYLE) ||
 182         IsTokenInNamespace(nElement, XML_NAMESPACE_LO_EXT) )
 183     {
 184         sal_Int32 nLocalName = nElement & TOKEN_MASK;
 185         if( nLocalName == XML_GRAPHIC_PROPERTIES )
 186             nFamily = XML_TYPE_PROP_GRAPHIC;
 187         else if( nLocalName == XML_DRAWING_PAGE_PROPERTIES )
 188             nFamily = XML_TYPE_PROP_DRAWING_PAGE;
 189         else if( nLocalName == XML_TEXT_PROPERTIES )
 190             nFamily = XML_TYPE_PROP_TEXT;
 191         else if( nLocalName == XML_PARAGRAPH_PROPERTIES )
 192             nFamily = XML_TYPE_PROP_PARAGRAPH;
 193         else if( nLocalName == XML_RUBY_PROPERTIES )
 194             nFamily = XML_TYPE_PROP_RUBY;
 195         else if( nLocalName == XML_SECTION_PROPERTIES )
 196             nFamily = XML_TYPE_PROP_SECTION;
 197         else if( nLocalName == XML_TABLE_PROPERTIES )
 198             nFamily = XML_TYPE_PROP_TABLE;
 199         else if( nLocalName == XML_TABLE_COLUMN_PROPERTIES  )
 200             nFamily = XML_TYPE_PROP_TABLE_COLUMN;
 201         else if( nLocalName ==XML_TABLE_ROW_PROPERTIES  )
 202             nFamily = XML_TYPE_PROP_TABLE_ROW;
 203         else if( nLocalName == XML_TABLE_CELL_PROPERTIES  )
 204             nFamily = XML_TYPE_PROP_TABLE_CELL;
 205         else if( nLocalName == XML_CHART_PROPERTIES )
 206             nFamily = XML_TYPE_PROP_CHART;
 207     }
 208     if( nFamily )
 209     {
 210         rtl::Reference < SvXMLImportPropertyMapper > xImpPrMap =
 211             mxStyles->GetImportPropertyMapper( GetFamily() );
 212         if (xImpPrMap.is())
 213         {
 214             return new StylePropertiesContext(GetImport(), nElement, xAttrList, nFamily, maProperties, xImpPrMap);
 215         }
 216     }
 217     XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
 218     return nullptr;
 219 }
 220
 221 void XMLPropStyleContext::FillPropertySet(
 222             const Reference< XPropertySet > & rPropSet )
 223 {
 224     rtl::Reference < SvXMLImportPropertyMapper > xImpPrMap =
 225         mxStyles->GetImportPropertyMapper( GetFamily() );
 226     SAL_WARN_IF( !xImpPrMap.is(), "xmloff", "There is the import prop mapper" );
 227     if( xImpPrMap.is() )
 228         xImpPrMap->FillPropertySet( maProperties, rPropSet );
 229 }
 230
 231 void XMLPropStyleContext::SetDefaults()
 232 {
 233 }
 234
 235 Reference < XStyle > XMLPropStyleContext::Create()
 236 {
 237     Reference < XStyle > xNewStyle;
 238
 239     OUString sServiceName = mxStyles->GetServiceName( GetFamily() );
 240     if( !sServiceName.isEmpty() )
 241     {
 242         Reference< XMultiServiceFactory > xFactory( GetImport().GetModel(),
 243                                                     UNO_QUERY );
 244         if( xFactory.is() )
 245         {
 246             Reference < XInterface > xIfc =
 247                 xFactory->createInstance( sServiceName );
 248             if( xIfc.is() )
 249                 xNewStyle.set( xIfc, UNO_QUERY );
 250         }
 251     }
 252
 253     return xNewStyle;
 254 }
 255
 256 void XMLPropStyleContext::CreateAndInsert( bool bOverwrite )
 257 {
 258     SvXMLStylesContext* pSvXMLStylesContext = mxStyles.get();
 259     rtl::Reference < SvXMLImportPropertyMapper > xImpPrMap = pSvXMLStylesContext->GetImportPropertyMapper(GetFamily());
 260     OSL_ENSURE(xImpPrMap.is(), "There is no import prop mapper");
 261
 262     // need to filter out old fill definitions when the new ones are used. The new
 263     // ones are used when a FillStyle is defined
 264     const bool bTakeCareOfDrawingLayerFillStyle(xImpPrMap.is() && GetFamily() == XmlStyleFamily::TEXT_PARAGRAPH);
 265     bool bDrawingLayerFillStylesUsed(false);
 266
 267     if(bTakeCareOfDrawingLayerFillStyle)
 268     {
 269         // check if new FillStyles are used and if so mark old ones with -1
 270         static OUString s_FillStyle("FillStyle");
 271
 272         if(doNewDrawingLayerFillStyleDefinitionsExist(s_FillStyle))
 273         {
 274             deactivateOldFillStyleDefinitions(theParaSet());
 275             bDrawingLayerFillStylesUsed = true;
 276         }
 277     }
 278
 279     if( pSvXMLStylesContext->IsAutomaticStyle()
 280         && ( GetFamily() == XmlStyleFamily::TEXT_TEXT || GetFamily() == XmlStyleFamily::TEXT_PARAGRAPH ) )
 281     {
 282         // Need to translate StyleName from temp MapNames to names
 283         // used in already imported items (already exist in the pool). This
 284         // is required for AutomaticStyles since these do *not* use FillPropertySet
 285         // and thus just trigger CheckSpecialContext in XMLTextStyleContext::FillPropertySet
 286         // (which may be double action anyways). The mechanism there to use _ContextID_Index_Pair
 287         // is not working for AutomaticStyles and is already too late, too (this
 288         // method is already called before XMLTextStyleContext::FillPropertySet gets called)
 289         if(bDrawingLayerFillStylesUsed)
 290         {
 291             translateNameBasedDrawingLayerFillStyleDefinitionsToStyleDisplayNames();
 292         }
 293
 294         Reference < XAutoStyleFamily > xAutoFamily = pSvXMLStylesContext->GetAutoStyles( GetFamily() );
 295         if( !xAutoFamily.is() )
 296             return;
 297         if( xImpPrMap.is() )
 298         {
 299             Sequence< PropertyValue > aValues;
 300             xImpPrMap->FillPropertySequence( maProperties, aValues );
 301
 302             sal_Int32 nLen = aValues.getLength();
 303             if( nLen )
 304             {
 305                 if( GetFamily() == XmlStyleFamily::TEXT_PARAGRAPH )
 306                 {
 307                     aValues.realloc( nLen + 2 );
 308                     PropertyValue *pProps = aValues.getArray() + nLen;
 309                     pProps->Name = "ParaStyleName";
 310                     OUString sParent( GetParentName() );
 311                     if( !sParent.isEmpty() )
 312                     {
 313                         sParent = GetImport().GetStyleDisplayName( GetFamily(), sParent );
 314                         Reference < XNameContainer > xFamilies = pSvXMLStylesContext->GetStylesContainer( GetFamily() );
 315                         if(xFamilies.is() && xFamilies->hasByName( sParent ) )
 316                         {
 317                             css::uno::Reference< css::style::XStyle > xStyle;
 318                             Any aAny = xFamilies->getByName( sParent );
 319                             aAny >>= xStyle;
 320                             sParent = xStyle->getName() ;
 321                         }
 322                     }
 323                     else
 324                         sParent = "Standard";
 325                     pProps->Value <<= sParent;
 326                     ++pProps;
 327                     pProps->Name = "ParaConditionalStyleName";
 328                     pProps->Value <<= sParent;
 329                 }
 330
 331                 Reference < XAutoStyle > xAutoStyle = xAutoFamily->insertStyle( aValues );
 332                 if( xAutoStyle.is() )
 333                 {
 334                     Sequence< OUString > aPropNames
 335                     {
 336                         (GetFamily() == XmlStyleFamily::TEXT_PARAGRAPH)?
 337                         OUString("ParaAutoStyleName"):
 338                         OUString("CharAutoStyleName")
 339                     };
 340                     Sequence< Any > aAny = xAutoStyle->getPropertyValues( aPropNames );
 341                     if( aAny.hasElements() )
 342                     {
 343                         SetAutoName(aAny[0]);
 344                     }
 345                 }
 346             }
 347         }
 348     }
 349     else
 350     {
 351         const OUString& rName = GetDisplayName();
 352         if( rName.isEmpty() || IsDefaultStyle() )
 353             return;
 354
 355         Reference < XNameContainer > xFamilies = pSvXMLStylesContext->GetStylesContainer( GetFamily() );
 356         if( !xFamilies.is() )
 357         {
 358             SAL_WARN("xmloff", "no styles container for family " << static_cast<int>(GetFamily()));
 359             return;
 360         }
 361
 362         bool bNew = false;
 363         if( xFamilies->hasByName( rName ) )
 364         {
 365             Any aAny = xFamilies->getByName( rName );
 366             aAny >>= mxStyle;
 367         }
 368         else
 369         {
 370             mxStyle = Create();
 371             if( !mxStyle.is() )
 372                 return;
 373
 374             xFamilies->insertByName( rName, Any(mxStyle) );
 375             bNew = true;
 376         }
 377
 378         Reference < XPropertySet > xPropSet( mxStyle, UNO_QUERY );
 379         Reference< XPropertySetInfo > xPropSetInfo =
 380                     xPropSet->getPropertySetInfo();
 381         if( !bNew && xPropSetInfo->hasPropertyByName( gsIsPhysical ) )
 382         {
 383             Any aAny = xPropSet->getPropertyValue( gsIsPhysical );
 384             bNew = !*o3tl::doAccess<bool>(aAny);
 385         }
 386         SetNew( bNew );
 387         if( rName != GetName() )
 388             GetImport().AddStyleDisplayName( GetFamily(), GetName(), rName );
 389
 390
 391         if( bOverwrite || bNew )
 392         {
 393             rtl::Reference < XMLPropertySetMapper > xPrMap;
 394             if( xImpPrMap.is() )
 395                 xPrMap = xImpPrMap->getPropertySetMapper();
 396             if( xPrMap.is() )
 397             {
 398                 Reference < XMultiPropertyStates > xMultiStates( xPropSet,
 399                                                                  UNO_QUERY );
 400                 if( xMultiStates.is() )
 401                 {
 402                     xMultiStates->setAllPropertiesToDefault();
 403                 }
 404                 else
 405                 {
 406                     std::set < OUString > aNameSet;
 407                     sal_Int32 nCount = xPrMap->GetEntryCount();
 408                     sal_Int32 i;
 409                     for( i = 0; i < nCount; i++ )
 410                     {
 411                         const OUString& rPrName = xPrMap->GetEntryAPIName( i );
 412                         if( xPropSetInfo->hasPropertyByName( rPrName ) )
 413                             aNameSet.insert( rPrName );
 414                     }
 415                     Reference< XPropertyState > xPropState( xPropSet, uno::UNO_QUERY );
 416                     if (xPropState.is())
 417                     {
 418                         nCount = aNameSet.size();
 419                         Sequence<OUString> aNames( comphelper::containerToSequence(aNameSet) );
 420                         Sequence < PropertyState > aStates( xPropState->getPropertyStates(aNames) );
 421                         const PropertyState *pStates = aStates.getConstArray();
 422                         OUString* pNames = aNames.getArray();
 423
 424                         for( i = 0; i < nCount; i++ )
 425                         {
 426                             if( PropertyState_DIRECT_VALUE == *pStates++ )
 427                                 xPropState->setPropertyToDefault( pNames[i] );
 428                         }
 429                     }
 430                 }
 431             }
 432
 433             if (mxStyle.is())
 434                 mxStyle->setParentStyle(OUString());
 435
 436             FillPropertySet( xPropSet );
 437         }
 438         else
 439         {
 440             SetValid( false );
 441         }
 442     }
 443 }
 444
 445 void XMLPropStyleContext::Finish( bool bOverwrite )
 446 {
 447     if( !mxStyle.is() || !(IsNew() || bOverwrite) )
 448         return;
 449
 450     // The families container must exist
 451     Reference < XNameContainer > xFamilies = mxStyles->GetStylesContainer( GetFamily() );
 452     SAL_WARN_IF( !xFamilies.is(), "xmloff", "Families lost" );
 453     if( !xFamilies.is() )
 454         return;
 455
 456     // connect parent
 457     OUString sParent( GetParentName() );
 458     if( !sParent.isEmpty() )
 459         sParent = GetImport().GetStyleDisplayName( GetFamily(), sParent );
 460     if( !sParent.isEmpty() && !xFamilies->hasByName( sParent ) )
 461         sParent.clear();
 462
 463     if( sParent != mxStyle->getParentStyle() )
 464     {
 465         // this may except if setting the parent style forms a
 466         // circle in the style dependencies; especially if the parent
 467         // style is the same as the current style
 468         try
 469         {
 470             mxStyle->setParentStyle( sParent );
 471         }
 472         catch(const uno::Exception& e)
 473         {
 474             // according to the API definition, I would expect a
 475             // container::NoSuchElementException. But it throws an
 476             // uno::RuntimeException instead. I catch
 477             // uno::Exception in order to process both of them.
 478
 479             // We can't set the parent style. For a proper
 480             // Error-Message, we should pass in the name of the
 481             // style, as well as the desired parent style.
 482
 483             // getName() throws no non-Runtime exception:
 484             GetImport().SetError(
 485                 XMLERROR_FLAG_ERROR | XMLERROR_PARENT_STYLE_NOT_ALLOWED,
 486                 { mxStyle->getName(), sParent }, e.Message, nullptr );
 487         }
 488     }
 489
 490     // connect follow
 491     OUString sFollow( GetFollow() );
 492     if( !sFollow.isEmpty() )
 493         sFollow = GetImport().GetStyleDisplayName( GetFamily(), sFollow );
 494     if( sFollow.isEmpty() || !xFamilies->hasByName( sFollow ) )
 495         sFollow = mxStyle->getName();
 496
 497     Reference < XPropertySet > xPropSet( mxStyle, UNO_QUERY );
 498     Reference< XPropertySetInfo > xPropSetInfo =
 499         xPropSet->getPropertySetInfo();
 500     if( xPropSetInfo->hasPropertyByName( gsFollowStyle ) )
 501     {
 502         Any aAny = xPropSet->getPropertyValue( gsFollowStyle );
 503         OUString sCurrFollow;
 504         aAny >>= sCurrFollow;
 505         if( sCurrFollow != sFollow )
 506         {
 507             xPropSet->setPropertyValue( gsFollowStyle, Any(sFollow) );
 508         }
 509     }
 510
 511     // Connect linked style.
 512     OUString aLinked(GetLinked());
 513     if (!aLinked.isEmpty())
 514     {
 515         if (GetFamily() == XmlStyleFamily::TEXT_PARAGRAPH)
 516         {
 517             aLinked = GetImport().GetStyleDisplayName(XmlStyleFamily::TEXT_TEXT, aLinked);
 518         }
 519         else if (GetFamily() == XmlStyleFamily::TEXT_TEXT)
 520         {
 521             aLinked = GetImport().GetStyleDisplayName(XmlStyleFamily::TEXT_PARAGRAPH, aLinked);
 522         }
 523     }
 524     if (!aLinked.isEmpty() && xPropSetInfo->hasPropertyByName("LinkStyle"))
 525     {
 526         uno::Any aAny = xPropSet->getPropertyValue("LinkStyle");
 527         OUString aCurrentLinked;
 528         aAny >>= aCurrentLinked;
 529         if (aCurrentLinked != aLinked)
 530         {
 531             xPropSet->setPropertyValue("LinkStyle", uno::Any(aLinked));
 532         }
 533     }
 534
 535     if ( xPropSetInfo->hasPropertyByName( "Hidden" ) )
 536     {
 537         xPropSet->setPropertyValue( "Hidden", uno::Any( IsHidden( ) ) );
 538     }
 539
 540 }
 541
 542 bool XMLPropStyleContext::doNewDrawingLayerFillStyleDefinitionsExist(
 543     std::u16string_view rFillStyleTag) const
 544 {
 545     if(!maProperties.empty() && !rFillStyleTag.empty())
 546     {
 547         // no & to avoid non-obvious UAF due to the 2nd temp Reference
 548         const rtl::Reference<XMLPropertySetMapper> rMapper = GetStyles()->GetImportPropertyMapper(GetFamily())->getPropertySetMapper();
 549
 550         if(rMapper.is())
 551         {
 552             for(const auto& a : maProperties)
 553             {
 554                 if(a.mnIndex != -1)
 555                 {
 556                     const OUString& rPropName = rMapper->GetEntryAPIName(a.mnIndex);
 557
 558                     if(rPropName == rFillStyleTag)
 559                     {
 560                         FillStyle eFillStyle(FillStyle_NONE);
 561
 562                         if(a.maValue >>= eFillStyle)
 563                         {
 564                             // okay, type was good, FillStyle is set
 565                         }
 566                         else
 567                         {
 568                             // also try an int (see XFillStyleItem::PutValue)
 569                             sal_Int32 nFillStyle(0);
 570
 571                             if(a.maValue >>= nFillStyle)
 572                             {
 573                                 eFillStyle = static_cast< FillStyle >(nFillStyle);
 574                             }
 575                         }
 576
 577                         // we found the entry, check it
 578                         return FillStyle_NONE != eFillStyle;
 579                     }
 580                 }
 581             }
 582         }
 583     }
 584
 585     return false;
 586 }
 587
 588 void XMLPropStyleContext::deactivateOldFillStyleDefinitions(
 589     const OldFillStyleDefinitionSet& rHashSetOfTags)
 590 {
 591     if(rHashSetOfTags.empty() || maProperties.empty())
 592         return;
 593
 594     const rtl::Reference< XMLPropertySetMapper >& rMapper = GetStyles()->GetImportPropertyMapper(GetFamily())->getPropertySetMapper();
 595
 596     if(!rMapper.is())
 597         return;
 598
 599     for(auto& a : maProperties)
 600     {
 601         if(a.mnIndex != -1)
 602         {
 603             const OUString& rPropName = rMapper->GetEntryAPIName(a.mnIndex);
 604
 605             if(rHashSetOfTags.find(rPropName) != rHashSetOfTags.end())
 606             {
 607                 // mark entry as inactive
 608                 a.mnIndex = -1;
 609             }
 610         }
 611     }
 612 }
 613
 614 void XMLPropStyleContext::translateNameBasedDrawingLayerFillStyleDefinitionsToStyleDisplayNames()
 615 {
 616     if(maProperties.empty())
 617         return;
 618
 619     const rtl::Reference< XMLPropertySetMapper >& rMapper = GetStyles()->GetImportPropertyMapper(GetFamily())->getPropertySetMapper();
 620
 621     if(!rMapper.is())
 622         return;
 623
 624     static constexpr OUStringLiteral s_FillGradientName(u"FillGradientName");
 625     static constexpr OUStringLiteral s_FillHatchName(u"FillHatchName");
 626     static constexpr OUStringLiteral s_FillBitmapName(u"FillBitmapName");
 627     static constexpr OUStringLiteral s_FillTransparenceGradientName(u"FillTransparenceGradientName");
 628
 629     for(auto& a : maProperties)
 630     {
 631         if(a.mnIndex != -1)
 632         {
 633             const OUString& rPropName = rMapper->GetEntryAPIName(a.mnIndex);
 634             XmlStyleFamily aStyleFamily(XmlStyleFamily::DATA_STYLE);
 635
 636             if(rPropName == s_FillGradientName || rPropName == s_FillTransparenceGradientName)
 637             {
 638                 aStyleFamily = XmlStyleFamily::SD_GRADIENT_ID;
 639             }
 640             else if(rPropName == s_FillHatchName)
 641             {
 642                 aStyleFamily = XmlStyleFamily::SD_HATCH_ID;
 643             }
 644             else if(rPropName == s_FillBitmapName)
 645             {
 646                 aStyleFamily = XmlStyleFamily::SD_FILL_IMAGE_ID;
 647             }
 648
 649             if(aStyleFamily != XmlStyleFamily::DATA_STYLE)
 650             {
 651                 OUString sStyleName;
 652
 653                 a.maValue >>= sStyleName;
 654                 sStyleName = GetImport().GetStyleDisplayName( aStyleFamily, sStyleName );
 655                 a.maValue <<= sStyleName;
 656             }
 657         }
 658     }
 659 }
 660
 661 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */