sd/source/core/stlsheet.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 <com/sun/star/beans/PropertyAttribute.hpp>
  21 #include <com/sun/star/lang/DisposedException.hpp>
  22 #include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
  23 #include <com/sun/star/style/XStyle.hpp>
  24 #include <com/sun/star/table/BorderLine.hpp>
  25
  26 #include <osl/mutex.hxx>
  27 #include <vcl/svapp.hxx>
  28 #include <cppuhelper/exc_hlp.hxx>
  29 #include <cppuhelper/supportsservice.hxx>
  30
  31 #include <editeng/eeitem.hxx>
  32 #include <editeng/fhgtitem.hxx>
  33 #include <editeng/ulspitem.hxx>
  34 #include <svl/hint.hxx>
  35 #include <svl/itemset.hxx>
  36
  37 #include <svx/xflbmtit.hxx>
  38 #include <svx/xflbstit.hxx>
  39 #include <editeng/bulletitem.hxx>
  40 #include <editeng/lrspitem.hxx>
  41 #include <svx/unoshprp.hxx>
  42 #include <svx/unoshape.hxx>
  43 #include <svx/svdpool.hxx>
  44 #include <svx/sdtaaitm.hxx>
  45 #include <svx/sdtacitm.hxx>
  46 #include <svx/sdtayitm.hxx>
  47 #include <svx/sdtaiitm.hxx>
  48 #include <svx/xit.hxx>
  49 #include <tools/diagnose_ex.h>
  50 #include <stlsheet.hxx>
  51 #include <sdresid.hxx>
  52 #include <sdpage.hxx>
  53 #include <drawdoc.hxx>
  54 #include <stlpool.hxx>
  55 #include <strings.hrc>
  56 #include <app.hrc>
  57 #include <strings.hxx>
  58 #include <glob.hxx>
  59 #include <DrawViewShell.hxx>
  60 #include <ViewShellBase.hxx>
  61
  62 #include <cstddef>
  63 #include <memory>
  64 #include <string_view>
  65
  66 using ::osl::MutexGuard;
  67 using ::osl::ClearableMutexGuard;
  68 using ::com::sun::star::table::BorderLine;
  69 using namespace ::com::sun::star::uno;
  70 using namespace ::com::sun::star::util;
  71 using namespace ::com::sun::star::lang;
  72 using namespace ::com::sun::star::style;
  73 using namespace ::com::sun::star::beans;
  74 using namespace ::com::sun::star::container;
  75 using namespace ::com::sun::star::drawing;
  76
  77 #define WID_STYLE_HIDDEN    7997
  78 #define WID_STYLE_DISPNAME  7998
  79 #define WID_STYLE_FAMILY    7999
  80
  81 static SvxItemPropertySet& GetStylePropertySet()
  82 {
  83     static const SfxItemPropertyMapEntry aFullPropertyMap_Impl[] =
  84     {
  85         { u"Family",                 WID_STYLE_FAMILY,       ::cppu::UnoType<OUString>::get(), PropertyAttribute::READONLY,    0},
  86         { u"UserDefinedAttributes",  SDRATTR_XMLATTRIBUTES,  cppu::UnoType<XNameContainer>::get(), 0,     0},
  87         { u"DisplayName",            WID_STYLE_DISPNAME,     ::cppu::UnoType<OUString>::get(), PropertyAttribute::READONLY,    0},
  88         { u"Hidden",                 WID_STYLE_HIDDEN,       cppu::UnoType<bool>::get(),       0,     0},
  89
  90         SVX_UNOEDIT_NUMBERING_PROPERTIE,
  91         SHADOW_PROPERTIES
  92         LINE_PROPERTIES
  93         LINE_PROPERTIES_START_END
  94         FILL_PROPERTIES
  95         EDGERADIUS_PROPERTIES
  96         TEXT_PROPERTIES_DEFAULTS
  97         CONNECTOR_PROPERTIES
  98         SPECIAL_DIMENSIONING_PROPERTIES_DEFAULTS
  99         { u"TopBorder",                    SDRATTR_TABLE_BORDER,           ::cppu::UnoType<BorderLine>::get(), 0, TOP_BORDER },
 100         { u"BottomBorder",                 SDRATTR_TABLE_BORDER,           ::cppu::UnoType<BorderLine>::get(), 0, BOTTOM_BORDER },
 101         { u"LeftBorder",                   SDRATTR_TABLE_BORDER,           ::cppu::UnoType<BorderLine>::get(), 0, LEFT_BORDER },
 102         { u"RightBorder",                  SDRATTR_TABLE_BORDER,           ::cppu::UnoType<BorderLine>::get(), 0, RIGHT_BORDER },
 103         { u"", 0, css::uno::Type(), 0, 0 }
 104     };
 105
 106     static SvxItemPropertySet aPropSet( aFullPropertyMap_Impl, SdrObject::GetGlobalDrawObjectItemPool() );
 107     return aPropSet;
 108 }
 109
 110 class ModifyListenerForwarder : public SfxListener
 111 {
 112 public:
 113     explicit ModifyListenerForwarder( SdStyleSheet* pStyleSheet );
 114
 115     virtual void Notify(SfxBroadcaster& rBC, const SfxHint& rHint) override;
 116
 117 private:
 118     SdStyleSheet* mpStyleSheet;
 119 };
 120
 121 ModifyListenerForwarder::ModifyListenerForwarder( SdStyleSheet* pStyleSheet )
 122 : mpStyleSheet( pStyleSheet )
 123 {
 124     if( pStyleSheet )
 125     {
 126         SfxBroadcaster& rBC = static_cast< SfxBroadcaster& >( *pStyleSheet );
 127         StartListening( rBC );
 128     }
 129 }
 130
 131 void ModifyListenerForwarder::Notify(SfxBroadcaster& /*rBC*/, const SfxHint& /*rHint*/)
 132 {
 133     if( mpStyleSheet )
 134         mpStyleSheet->notifyModifyListener();
 135 }
 136
 137 SdStyleSheet::SdStyleSheet(const OUString& rDisplayName, SfxStyleSheetBasePool& _rPool, SfxStyleFamily eFamily, SfxStyleSearchBits _nMask)
 138 : SdStyleSheetBase( rDisplayName, _rPool, eFamily, _nMask)
 139 , ::cppu::BaseMutex()
 140 , msApiName( rDisplayName )
 141 , mxPool( &_rPool )
 142 , mrBHelper( m_aMutex )
 143 {
 144 }
 145
 146 SdStyleSheet::~SdStyleSheet()
 147 {
 148     delete pSet;
 149     pSet = nullptr;    // that following destructors also get a change
 150 }
 151
 152 void SdStyleSheet::SetApiName( const OUString& rApiName )
 153 {
 154     msApiName = rApiName;
 155 }
 156
 157 OUString const & SdStyleSheet::GetApiName() const
 158 {
 159     if( !msApiName.isEmpty() )
 160         return msApiName;
 161     else
 162         return GetName();
 163 }
 164
 165 bool SdStyleSheet::SetParent(const OUString& rParentName)
 166 {
 167     bool bResult = false;
 168
 169     if (SfxStyleSheet::SetParent(rParentName))
 170     {
 171         // PseudoStyleSheets do not have their own ItemSets
 172         if (nFamily != SfxStyleFamily::Pseudo)
 173         {
 174             if( !rParentName.isEmpty() )
 175             {
 176                 SfxStyleSheetBase* pStyle = m_pPool->Find(rParentName, nFamily);
 177                 if (pStyle)
 178                 {
 179                     bResult = true;
 180                     SfxItemSet& rParentSet = pStyle->GetItemSet();
 181                     GetItemSet().SetParent(&rParentSet);
 182                     Broadcast( SfxHint( SfxHintId::DataChanged ) );
 183                 }
 184             }
 185             else
 186             {
 187                 bResult = true;
 188                 GetItemSet().SetParent(nullptr);
 189                 Broadcast( SfxHint( SfxHintId::DataChanged ) );
 190             }
 191         }
 192         else
 193         {
 194             bResult = true;
 195         }
 196     }
 197     return bResult;
 198 }
 199
 200 /**
 201  * create if necessary and return ItemSets
 202  */
 203 SfxItemSet& SdStyleSheet::GetItemSet()
 204 {
 205     if (nFamily == SfxStyleFamily::Para || nFamily == SfxStyleFamily::Page)
 206     {
 207         // we create the ItemSet 'on demand' if necessary
 208         if (!pSet)
 209         {
 210             pSet = new SfxItemSet(
 211                 GetPool()->GetPool(),
 212                 svl::Items<
 213                     XATTR_LINE_FIRST, XATTR_LINE_LAST,
 214                     XATTR_FILL_FIRST, XATTR_FILL_LAST,
 215                     SDRATTR_SHADOW_FIRST, SDRATTR_SHADOW_LAST,
 216                     SDRATTR_TEXT_MINFRAMEHEIGHT, SDRATTR_TEXT_WORDWRAP,
 217                     SDRATTR_EDGE_FIRST, SDRATTR_MEASURE_LAST,
 218                     SDRATTR_3D_FIRST, SDRATTR_3D_LAST,
 219                     EE_PARA_START, EE_CHAR_END>{});
 220             bMySet = true;
 221         }
 222
 223         return *pSet;
 224     }
 225
 226     else if( nFamily == SfxStyleFamily::Frame )
 227     {
 228         if (!pSet)
 229         {
 230             pSet = new SfxItemSet(
 231                 GetPool()->GetPool(),
 232                 svl::Items<
 233                     XATTR_LINE_FIRST, XATTR_LINE_LAST,
 234                     XATTR_FILL_FIRST, XATTR_FILL_LAST,
 235                     SDRATTR_SHADOW_FIRST, SDRATTR_SHADOW_LAST,
 236                     SDRATTR_TEXT_MINFRAMEHEIGHT, SDRATTR_XMLATTRIBUTES,
 237                     SDRATTR_TEXT_WORDWRAP, SDRATTR_TEXT_WORDWRAP,
 238                     SDRATTR_TABLE_FIRST, SDRATTR_TABLE_LAST,
 239                     EE_PARA_START, EE_CHAR_END>{});
 240             bMySet = true;
 241         }
 242
 243         return *pSet;
 244     }
 245
 246     // this is a dummy template for the internal template of the
 247     // current presentation layout; return the ItemSet of that template
 248     else
 249     {
 250
 251         SdStyleSheet* pSdSheet = GetRealStyleSheet();
 252
 253         if (pSdSheet)
 254         {
 255             return pSdSheet->GetItemSet();
 256         }
 257         else
 258         {
 259             if (!pSet)
 260             {
 261                 pSet = new SfxItemSet(
 262                     GetPool()->GetPool(),
 263                     svl::Items<
 264                         XATTR_LINE_FIRST, XATTR_LINE_LAST,
 265                         XATTR_FILL_FIRST, XATTR_FILL_LAST,
 266                         SDRATTR_SHADOW_FIRST, SDRATTR_SHADOW_LAST,
 267                         SDRATTR_TEXT_MINFRAMEHEIGHT, SDRATTR_TEXT_WORDWRAP,
 268                         SDRATTR_EDGE_FIRST, SDRATTR_MEASURE_LAST,
 269                         SDRATTR_3D_FIRST, SDRATTR_3D_LAST,
 270                         EE_PARA_START, EE_CHAR_END>{});
 271                 bMySet = true;
 272             }
 273
 274             return(*pSet);
 275         }
 276     }
 277 }
 278
 279 /**
 280  * A template is used when it is referenced by inserted object or by a used
 281  * template.
 282  */
 283 bool SdStyleSheet::IsUsed() const
 284 {
 285     bool bResult = false;
 286
 287     const size_t nListenerCount = GetSizeOfVector();
 288     for (size_t n = 0; n < nListenerCount; ++n)
 289     {
 290         SfxListener* pListener = GetListener(n);
 291         if( pListener == this )
 292             continue;
 293
 294         const svl::StyleSheetUser* const pUser(dynamic_cast<svl::StyleSheetUser*>(pListener));
 295         if (pUser)
 296             bResult = pUser->isUsedByModel();
 297         if (bResult)
 298             break;
 299     }
 300
 301     if( !bResult )
 302     {
 303         MutexGuard aGuard( mrBHelper.rMutex );
 304
 305         cppu::OInterfaceContainerHelper * pContainer = mrBHelper.getContainer( cppu::UnoType<XModifyListener>::get() );
 306         if( pContainer )
 307         {
 308             Sequence< Reference< XInterface > > aModifyListeners( pContainer->getElements() );
 309             bResult = std::any_of(aModifyListeners.begin(), aModifyListeners.end(),
 310                 [](const Reference<XInterface>& rListener) {
 311                     Reference< XStyle > xStyle( rListener, UNO_QUERY );
 312                     return xStyle.is() && xStyle->isInUse();
 313                 });
 314         }
 315     }
 316     return bResult;
 317 }
 318
 319 /**
 320  * Determine the style sheet for which this dummy is for.
 321  */
 322 SdStyleSheet* SdStyleSheet::GetRealStyleSheet() const
 323 {
 324     OUString aRealStyle;
 325     OUString aSep( SD_LT_SEPARATOR );
 326     SdStyleSheet* pRealStyle = nullptr;
 327     SdDrawDocument* pDoc = static_cast<SdStyleSheetPool*>(m_pPool)->GetDoc();
 328
 329     ::sd::DrawViewShell* pDrawViewShell = nullptr;
 330
 331     ::sd::ViewShellBase* pBase = dynamic_cast< ::sd::ViewShellBase* >( SfxViewShell::Current() );
 332     if( pBase )
 333         pDrawViewShell = dynamic_cast< ::sd::DrawViewShell* >( pBase->GetMainViewShell().get() );
 334
 335     if (pDrawViewShell && pDrawViewShell->GetDoc() == pDoc)
 336     {
 337         SdPage* pPage = pDrawViewShell->getCurrentPage();
 338         if( pPage )
 339         {
 340             aRealStyle = pPage->GetLayoutName();
 341             // cut after separator string
 342
 343             if( aRealStyle.indexOf(aSep) >= 0)
 344             {
 345                 aRealStyle = aRealStyle.copy(0,(aRealStyle.indexOf(aSep) + aSep.getLength()));
 346             }
 347         }
 348     }
 349     if (aRealStyle.isEmpty())
 350     {
 351         SdPage* pPage = pDoc->GetSdPage(0, PageKind::Standard);
 352
 353         if (pPage)
 354         {
 355             aRealStyle = pDoc->GetSdPage(0, PageKind::Standard)->GetLayoutName();
 356         }
 357         else
 358         {
 359             /* no page available yet. This can happen when actualizing the
 360                document templates.  */
 361             SfxStyleSheetIterator aIter(m_pPool, SfxStyleFamily::Page);
 362             SfxStyleSheetBase* pSheet = aIter.First();
 363             if( pSheet )
 364                 aRealStyle = pSheet->GetName();
 365         }
 366
 367         if( aRealStyle.indexOf(aSep) >= 0)
 368         {
 369             aRealStyle = aRealStyle.copy(0,(aRealStyle.indexOf(aSep) + aSep.getLength()));
 370         }
 371     }
 372
 373     /* now map from the name (specified for country language) to the internal
 374        name (independent of the country language)  */
 375     OUString aInternalName;
 376     OUString aStyleName(aName);
 377
 378     if (aStyleName == SdResId(STR_PSEUDOSHEET_TITLE))
 379     {
 380         aInternalName = STR_LAYOUT_TITLE;
 381     }
 382     else if (aStyleName == SdResId(STR_PSEUDOSHEET_SUBTITLE))
 383     {
 384         aInternalName = STR_LAYOUT_SUBTITLE;
 385     }
 386     else if (aStyleName == SdResId(STR_PSEUDOSHEET_BACKGROUND))
 387     {
 388         aInternalName = STR_LAYOUT_BACKGROUND;
 389     }
 390     else if (aStyleName == SdResId(STR_PSEUDOSHEET_BACKGROUNDOBJECTS))
 391     {
 392         aInternalName = STR_LAYOUT_BACKGROUNDOBJECTS;
 393     }
 394     else if (aStyleName == SdResId(STR_PSEUDOSHEET_NOTES))
 395     {
 396         aInternalName = STR_LAYOUT_NOTES;
 397     }
 398     else
 399     {
 400         OUString aOutlineStr(SdResId(STR_PSEUDOSHEET_OUTLINE));
 401         sal_Int32 nPos = aStyleName.indexOf(aOutlineStr);
 402         if (nPos >= 0)
 403         {
 404             OUString aNumStr(aStyleName.copy(aOutlineStr.getLength()));
 405             aInternalName = STR_LAYOUT_OUTLINE + aNumStr;
 406         }
 407     }
 408
 409     aRealStyle += aInternalName;
 410     pRealStyle = static_cast< SdStyleSheet* >( m_pPool->Find(aRealStyle, SfxStyleFamily::Page) );
 411
 412 #ifdef DBG_UTIL
 413     if( !pRealStyle )
 414     {
 415         SfxStyleSheetIterator aIter(m_pPool, SfxStyleFamily::Page);
 416         if( aIter.Count() > 0 )
 417             // StyleSheet not found, but pool already loaded
 418             DBG_ASSERT(pRealStyle, "Internal StyleSheet not found");
 419     }
 420 #endif
 421
 422     return pRealStyle;
 423 }
 424
 425 /**
 426  * Determine pseudo style sheet which stands for this style sheet.
 427  */
 428 SdStyleSheet* SdStyleSheet::GetPseudoStyleSheet() const
 429 {
 430     SdStyleSheet* pPseudoStyle = nullptr;
 431     OUString aSep( SD_LT_SEPARATOR );
 432     OUString aStyleName(aName);
 433         // without layout name and separator
 434
 435     if( aStyleName.indexOf(aSep) >=0 )
 436     {
 437         aStyleName = aStyleName.copy (aStyleName.indexOf(aSep) + aSep.getLength());
 438     }
 439
 440     if (aStyleName == STR_LAYOUT_TITLE)
 441     {
 442         aStyleName = SdResId(STR_PSEUDOSHEET_TITLE);
 443     }
 444     else if (aStyleName == STR_LAYOUT_SUBTITLE)
 445     {
 446         aStyleName = SdResId(STR_PSEUDOSHEET_SUBTITLE);
 447     }
 448     else if (aStyleName == STR_LAYOUT_BACKGROUND)
 449     {
 450         aStyleName = SdResId(STR_PSEUDOSHEET_BACKGROUND);
 451     }
 452     else if (aStyleName == STR_LAYOUT_BACKGROUNDOBJECTS)
 453     {
 454         aStyleName = SdResId(STR_PSEUDOSHEET_BACKGROUNDOBJECTS);
 455     }
 456     else if (aStyleName == STR_LAYOUT_NOTES)
 457     {
 458         aStyleName = SdResId(STR_PSEUDOSHEET_NOTES);
 459     }
 460     else
 461     {
 462         OUString aOutlineStr(STR_LAYOUT_OUTLINE);
 463         sal_Int32 nPos = aStyleName.indexOf(aOutlineStr);
 464         if (nPos != -1)
 465         {
 466             OUString aNumStr(aStyleName.copy(aOutlineStr.getLength()));
 467             aStyleName = SdResId(STR_PSEUDOSHEET_OUTLINE) + aNumStr;
 468         }
 469     }
 470
 471     pPseudoStyle = static_cast<SdStyleSheet*>(m_pPool->Find(aStyleName, SfxStyleFamily::Pseudo));
 472     DBG_ASSERT(pPseudoStyle, "PseudoStyleSheet missing");
 473
 474     return pPseudoStyle;
 475 }
 476
 477 void SdStyleSheet::Notify(SfxBroadcaster& rBC, const SfxHint& rHint)
 478 {
 479     // first, base class functionality
 480     SfxStyleSheet::Notify(rBC, rHint);
 481
 482     if (nFamily != SfxStyleFamily::Pseudo)
 483         return;
 484
 485     /* if the dummy gets a notify about a changed attribute, he takes care that
 486        the actual meant style sheet sends broadcasts. */
 487     if (rHint.GetId() == SfxHintId::DataChanged)
 488     {
 489         SdStyleSheet* pRealStyle = GetRealStyleSheet();
 490         if (pRealStyle)
 491             pRealStyle->Broadcast(rHint);
 492     }
 493 }
 494
 495 /**
 496  * Adjust the bullet width and the left text indent of the provided ItemSets to
 497  * their font height. The new values are calculated that the ratio to the font
 498  * height is as in the style sheet.
 499  *
 500  * @param bOnlyMissingItems If sal_True, only not set items are completed. With
 501  * sal_False, are items are overwritten.
 502  */
 503 void SdStyleSheet::AdjustToFontHeight(SfxItemSet& rSet, bool bOnlyMissingItems)
 504 {
 505     /* If not explicit set, adjust bullet width and text indent to new font
 506        height. */
 507     SfxStyleFamily eFamily = nFamily;
 508     OUString aStyleName(aName);
 509     if (eFamily == SfxStyleFamily::Pseudo)
 510     {
 511         SfxStyleSheet* pRealStyle = GetRealStyleSheet();
 512         eFamily = pRealStyle->GetFamily();
 513         aStyleName = pRealStyle->GetName();
 514     }
 515
 516     if (!(eFamily == SfxStyleFamily::Page &&
 517           aStyleName.indexOf(STR_LAYOUT_OUTLINE) != -1 &&
 518           rSet.GetItemState(EE_CHAR_FONTHEIGHT) == SfxItemState::SET))
 519         return;
 520
 521     const SfxItemSet* pCurSet = &GetItemSet();
 522     sal_uInt32 nNewHeight = rSet.Get(EE_CHAR_FONTHEIGHT).GetHeight();
 523     sal_uInt32 nOldHeight = pCurSet->Get(EE_CHAR_FONTHEIGHT).GetHeight();
 524
 525     if (rSet.GetItemState(EE_PARA_BULLET) != SfxItemState::SET || !bOnlyMissingItems)
 526     {
 527         const SvxBulletItem& rBItem = pCurSet->Get(EE_PARA_BULLET);
 528         double fBulletFraction = double(rBItem.GetWidth()) / nOldHeight;
 529         SvxBulletItem aNewBItem(rBItem);
 530         aNewBItem.SetWidth(static_cast<sal_uInt32>(fBulletFraction * nNewHeight));
 531         rSet.Put(aNewBItem);
 532     }
 533
 534     if (rSet.GetItemState(EE_PARA_LRSPACE) != SfxItemState::SET || !bOnlyMissingItems)
 535     {
 536         const SvxLRSpaceItem& rLRItem = pCurSet->Get(EE_PARA_LRSPACE);
 537         double fIndentFraction = double(rLRItem.GetTextLeft()) / nOldHeight;
 538         SvxLRSpaceItem aNewLRItem(rLRItem);
 539         aNewLRItem.SetTextLeft(fIndentFraction * nNewHeight);
 540         double fFirstIndentFraction = double(rLRItem.GetTextFirstLineOffset()) / nOldHeight;
 541         aNewLRItem.SetTextFirstLineOffset(static_cast<short>(fFirstIndentFraction * nNewHeight));
 542         rSet.Put(aNewLRItem);
 543     }
 544
 545     if (rSet.GetItemState(EE_PARA_ULSPACE) != SfxItemState::SET || !bOnlyMissingItems)
 546     {
 547         const SvxULSpaceItem& rULItem = pCurSet->Get(EE_PARA_ULSPACE);
 548         SvxULSpaceItem aNewULItem(rULItem);
 549         double fLowerFraction = double(rULItem.GetLower()) / nOldHeight;
 550         aNewULItem.SetLower(static_cast<sal_uInt16>(fLowerFraction * nNewHeight));
 551         double fUpperFraction = double(rULItem.GetUpper()) / nOldHeight;
 552         aNewULItem.SetUpper(static_cast<sal_uInt16>(fUpperFraction * nNewHeight));
 553         rSet.Put(aNewULItem);
 554     }
 555 }
 556
 557 bool SdStyleSheet::HasFollowSupport() const
 558 {
 559     return false;
 560 }
 561
 562 bool SdStyleSheet::HasParentSupport() const
 563 {
 564     return true;
 565 }
 566
 567 bool SdStyleSheet::HasClearParentSupport() const
 568 {
 569     return true;
 570 }
 571
 572 namespace
 573 {
 574 struct ApiNameMap
 575 {
 576     std::u16string_view mpApiName;
 577     sal_uInt32 mnHelpId;
 578 } const pApiNameMap[]
 579     = { { std::u16string_view(u"title"), HID_PSEUDOSHEET_TITLE },
 580         { std::u16string_view(u"subtitle"), HID_PSEUDOSHEET_SUBTITLE },
 581         { std::u16string_view(u"background"), HID_PSEUDOSHEET_BACKGROUND },
 582         { std::u16string_view(u"backgroundobjects"), HID_PSEUDOSHEET_BACKGROUNDOBJECTS },
 583         { std::u16string_view(u"notes"), HID_PSEUDOSHEET_NOTES },
 584         { std::u16string_view(u"standard"), HID_STANDARD_STYLESHEET_NAME },
 585         { std::u16string_view(u"objectwithoutfill"), HID_POOLSHEET_OBJWITHOUTFILL },
 586
 587         { std::u16string_view(u"Text"), HID_POOLSHEET_TEXT },
 588         { std::u16string_view(u"A4"), HID_POOLSHEET_A4 },
 589         { std::u16string_view(u"Title A4"), HID_POOLSHEET_A4_TITLE },
 590         { std::u16string_view(u"Heading A4"), HID_POOLSHEET_A4_HEADLINE },
 591         { std::u16string_view(u"Text A4"), HID_POOLSHEET_A4_TEXT },
 592         { std::u16string_view(u"A4"), HID_POOLSHEET_A0 },
 593         { std::u16string_view(u"Title A0"), HID_POOLSHEET_A0_TITLE },
 594         { std::u16string_view(u"Heading A0"), HID_POOLSHEET_A0_HEADLINE },
 595         { std::u16string_view(u"Text A0"), HID_POOLSHEET_A0_TEXT },
 596
 597         { std::u16string_view(u"Graphic"), HID_POOLSHEET_GRAPHIC },
 598         { std::u16string_view(u"Shapes"), HID_POOLSHEET_SHAPES },
 599         { std::u16string_view(u"Filled"), HID_POOLSHEET_FILLED },
 600         { std::u16string_view(u"Filled Blue"), HID_POOLSHEET_FILLED_BLUE },
 601         { std::u16string_view(u"Filled Green"), HID_POOLSHEET_FILLED_GREEN },
 602         { std::u16string_view(u"Filled Red"), HID_POOLSHEET_FILLED_RED },
 603         { std::u16string_view(u"Filled Yellow"), HID_POOLSHEET_FILLED_YELLOW },
 604         { std::u16string_view(u"Outlined"), HID_POOLSHEET_OUTLINE },
 605         { std::u16string_view(u"Outlined Blue"), HID_POOLSHEET_OUTLINE_BLUE },
 606         { std::u16string_view(u"Outlined Green"), HID_POOLSHEET_OUTLINE_GREEN },
 607         { std::u16string_view(u"Outlined Red"), HID_POOLSHEET_OUTLINE_RED },
 608         { std::u16string_view(u"Outlined Yellow"), HID_POOLSHEET_OUTLINE_YELLOW },
 609         { std::u16string_view(u"Lines"), HID_POOLSHEET_LINES },
 610         { std::u16string_view(u"Arrow Line"), HID_POOLSHEET_MEASURE },
 611         { std::u16string_view(u"Arrow Dashed"), HID_POOLSHEET_LINES_DASHED }
 612       };
 613
 614 OUString GetApiNameForHelpId(sal_uLong nId)
 615 {
 616     if ((nId >= HID_PSEUDOSHEET_OUTLINE1) && (nId <= HID_PSEUDOSHEET_OUTLINE9))
 617         return "outline" + OUStringChar(sal_Unicode('1' + (nId - HID_PSEUDOSHEET_OUTLINE1)));
 618
 619     for (const auto& i : pApiNameMap)
 620         if (nId == i.mnHelpId)
 621             return i.mpApiName;
 622
 623     return OUString();
 624 }
 625
 626 sal_uInt32 GetHelpIdForApiName(const OUString& sName)
 627 {
 628     OUString sRest;
 629     if (sName.startsWith("outline", &sRest))
 630     {
 631         if (sRest.getLength() == 1)
 632         {
 633             sal_Unicode ch = sRest.toChar();
 634             if ('1' <= ch && ch <= '9')
 635                 return HID_PSEUDOSHEET_OUTLINE1 + ch - '1';
 636         }
 637         // No other pre-defined names start with "outline"
 638         return 0;
 639     }
 640
 641     for (const auto& i : pApiNameMap)
 642         if (sName == i.mpApiName)
 643             return i.mnHelpId;
 644
 645     return 0;
 646 }
 647 }
 648
 649 void SdStyleSheet::SetHelpId( const OUString& r, sal_uLong nId )
 650 {
 651     SfxStyleSheet::SetHelpId( r, nId );
 652
 653     const OUString sNewApiName = GetApiNameForHelpId(nId);
 654     if (!sNewApiName.isEmpty())
 655         msApiName = sNewApiName;
 656 }
 657
 658 OUString SdStyleSheet::GetFamilyString( SfxStyleFamily eFamily )
 659 {
 660     switch( eFamily )
 661     {
 662     case SfxStyleFamily::Frame:
 663         return "cell";
 664     default:
 665         OSL_FAIL( "SdStyleSheet::GetFamilyString(), illegal family!" );
 666         [[fallthrough]];
 667     case SfxStyleFamily::Para:
 668         return "graphics";
 669     }
 670 }
 671
 672 void SdStyleSheet::throwIfDisposed()
 673 {
 674     if( !mxPool.is() )
 675         throw DisposedException();
 676 }
 677
 678 SdStyleSheet* SdStyleSheet::CreateEmptyUserStyle( SfxStyleSheetBasePool& rPool, SfxStyleFamily eFamily )
 679 {
 680     OUString aName;
 681     sal_Int32 nIndex = 1;
 682     do
 683     {
 684         aName = "user" + OUString::number( nIndex++ );
 685     }
 686     while( rPool.Find( aName, eFamily ) != nullptr );
 687
 688     return new SdStyleSheet(aName, rPool, eFamily, SfxStyleSearchBits::UserDefined);
 689 }
 690
 691 // XInterface
 692
 693 void SAL_CALL SdStyleSheet::release(  ) throw ()
 694 {
 695     if (osl_atomic_decrement( &m_refCount ) != 0)
 696         return;
 697
 698     // restore reference count:
 699     osl_atomic_increment( &m_refCount );
 700     if (! mrBHelper.bDisposed) try
 701     {
 702         dispose();
 703     }
 704     catch (RuntimeException const&)
 705     {
 706         // don't break throw ()
 707         TOOLS_WARN_EXCEPTION( "sd", "" );
 708     }
 709     OSL_ASSERT( mrBHelper.bDisposed );
 710     SdStyleSheetBase::release();
 711 }
 712
 713 // XComponent
 714
 715 void SAL_CALL SdStyleSheet::dispose(  )
 716 {
 717     {
 718         MutexGuard aGuard(mrBHelper.rMutex);
 719         if (mrBHelper.bDisposed || mrBHelper.bInDispose)
 720             return;
 721
 722         mrBHelper.bInDispose = true;
 723     }
 724     try
 725     {
 726         // side effect: keeping a reference to this
 727         EventObject aEvt( static_cast< OWeakObject * >( this ) );
 728         try
 729         {
 730             mrBHelper.aLC.disposeAndClear( aEvt );
 731             disposing();
 732         }
 733         catch (...)
 734         {
 735             MutexGuard aGuard2( mrBHelper.rMutex );
 736             // bDisposed and bInDispose must be set in this order:
 737             mrBHelper.bDisposed = true;
 738             mrBHelper.bInDispose = false;
 739             throw;
 740         }
 741         MutexGuard aGuard2( mrBHelper.rMutex );
 742         // bDisposed and bInDispose must be set in this order:
 743         mrBHelper.bDisposed = true;
 744         mrBHelper.bInDispose = false;
 745     }
 746     catch (RuntimeException &)
 747     {
 748         throw;
 749     }
 750     catch (const Exception & exc)
 751     {
 752         css::uno::Any anyEx = cppu::getCaughtException();
 753         throw css::lang::WrappedTargetRuntimeException(
 754             "unexpected UNO exception caught: " + exc.Message ,
 755             nullptr, anyEx );
 756     }
 757 }
 758
 759 void SdStyleSheet::disposing()
 760 {
 761     SolarMutexGuard aGuard;
 762     if (bMySet)
 763     {
 764         delete pSet;
 765     }
 766     pSet = nullptr;
 767     m_pPool = nullptr;
 768     mxPool.clear();
 769 }
 770
 771 void SAL_CALL SdStyleSheet::addEventListener( const Reference< XEventListener >& xListener )
 772 {
 773     ClearableMutexGuard aGuard( mrBHelper.rMutex );
 774     if (mrBHelper.bDisposed || mrBHelper.bInDispose)
 775     {
 776         aGuard.clear();
 777         EventObject aEvt( static_cast< OWeakObject * >( this ) );
 778         xListener->disposing( aEvt );
 779     }
 780     else
 781     {
 782         mrBHelper.addListener( cppu::UnoType<decltype(xListener)>::get(), xListener );
 783     }
 784 }
 785
 786 void SAL_CALL SdStyleSheet::removeEventListener( const Reference< XEventListener >& xListener  )
 787 {
 788     mrBHelper.removeListener( cppu::UnoType<decltype(xListener)>::get(), xListener );
 789 }
 790
 791 // XModifyBroadcaster
 792
 793 void SAL_CALL SdStyleSheet::addModifyListener( const Reference< XModifyListener >& xListener )
 794 {
 795     ClearableMutexGuard aGuard( mrBHelper.rMutex );
 796     if (mrBHelper.bDisposed || mrBHelper.bInDispose)
 797     {
 798         aGuard.clear();
 799         EventObject aEvt( static_cast< OWeakObject * >( this ) );
 800         xListener->disposing( aEvt );
 801     }
 802     else
 803     {
 804         if (!mpModifyListenerForwarder)
 805             mpModifyListenerForwarder.reset( new ModifyListenerForwarder( this ) );
 806         mrBHelper.addListener( cppu::UnoType<XModifyListener>::get(), xListener );
 807     }
 808 }
 809
 810 void SAL_CALL SdStyleSheet::removeModifyListener( const Reference< XModifyListener >& xListener )
 811 {
 812     mrBHelper.removeListener( cppu::UnoType<XModifyListener>::get(), xListener );
 813 }
 814
 815 void SdStyleSheet::notifyModifyListener()
 816 {
 817     MutexGuard aGuard( mrBHelper.rMutex );
 818
 819     cppu::OInterfaceContainerHelper * pContainer = mrBHelper.getContainer( cppu::UnoType<XModifyListener>::get() );
 820     if( pContainer )
 821     {
 822         EventObject aEvt( static_cast< OWeakObject * >( this ) );
 823         pContainer->forEach<XModifyListener>(
 824             [&] (Reference<XModifyListener> const& xListener) {
 825                 return xListener->modified(aEvt);
 826             } );
 827     }
 828 }
 829
 830 // XServiceInfo
 831 OUString SAL_CALL SdStyleSheet::getImplementationName()
 832 {
 833     return "SdStyleSheet";
 834 }
 835
 836 sal_Bool SAL_CALL SdStyleSheet::supportsService( const OUString& ServiceName )
 837 {
 838     return cppu::supportsService( this, ServiceName );
 839 }
 840
 841 Sequence< OUString > SAL_CALL SdStyleSheet::getSupportedServiceNames()
 842 {
 843     return { "com.sun.star.style.Style",
 844              "com.sun.star.drawing.FillProperties",
 845              "com.sun.star.drawing.LineProperties",
 846              "com.sun.star.drawing.ShadowProperties",
 847              "com.sun.star.drawing.ConnectorProperties",
 848              "com.sun.star.drawing.MeasureProperties",
 849              "com.sun.star.style.ParagraphProperties",
 850              "com.sun.star.style.CharacterProperties",
 851              "com.sun.star.drawing.TextProperties",
 852              "com.sun.star.drawing.Text" };
 853 }
 854
 855 bool SdStyleSheet::SetName(const OUString& rNewName, bool bReindexNow)
 856 {
 857     const bool bResult = SfxUnoStyleSheet::SetName(rNewName, bReindexNow);
 858     // Don't overwrite predefined API names
 859     if (bResult && GetHelpIdForApiName(msApiName) == 0)
 860     {
 861         msApiName = rNewName;
 862         Broadcast(SfxHint(SfxHintId::DataChanged));
 863     }
 864     return bResult;
 865 }
 866
 867 // XNamed
 868 OUString SAL_CALL SdStyleSheet::getName()
 869 {
 870     SolarMutexGuard aGuard;
 871     throwIfDisposed();
 872     return GetApiName();
 873 }
 874
 875 void SAL_CALL SdStyleSheet::setName( const OUString& rName  )
 876 {
 877     SolarMutexGuard aGuard;
 878     throwIfDisposed();
 879     SetName(rName);
 880 }
 881
 882 // XStyle
 883
 884 sal_Bool SAL_CALL SdStyleSheet::isUserDefined()
 885 {
 886     SolarMutexGuard aGuard;
 887     throwIfDisposed();
 888     return IsUserDefined();
 889 }
 890
 891 sal_Bool SAL_CALL SdStyleSheet::isInUse()
 892 {
 893     SolarMutexGuard aGuard;
 894     throwIfDisposed();
 895     return IsUsed();
 896 }
 897
 898 OUString SAL_CALL SdStyleSheet::getParentStyle()
 899 {
 900     SolarMutexGuard aGuard;
 901     throwIfDisposed();
 902
 903     if( !GetParent().isEmpty() )
 904     {
 905         SdStyleSheet* pParentStyle = static_cast< SdStyleSheet* >( mxPool->Find( GetParent(), nFamily ) );
 906         if( pParentStyle )
 907             return pParentStyle->GetApiName();
 908     }
 909     return OUString();
 910 }
 911
 912 void SAL_CALL SdStyleSheet::setParentStyle( const OUString& rParentName  )
 913 {
 914     SolarMutexGuard aGuard;
 915     throwIfDisposed();
 916
 917     if( !rParentName.isEmpty() )
 918     {
 919         OUString const name(GetName());
 920         sal_Int32 const sep(name.indexOf(SD_LT_SEPARATOR));
 921         OUString const master((sep == -1) ? OUString() : name.copy(0, sep));
 922         std::shared_ptr<SfxStyleSheetIterator> aSSSI = std::make_shared<SfxStyleSheetIterator>(mxPool.get(), nFamily);
 923         for (SfxStyleSheetBase *pStyle = aSSSI->First(); pStyle; pStyle = aSSSI->Next())
 924         {
 925             // we hope that we have only sd style sheets
 926             SdStyleSheet* pSdStyleSheet = static_cast<SdStyleSheet*>(pStyle);
 927             OUString const curName(pStyle->GetName());
 928             sal_Int32 const curSep(curName.indexOf(SD_LT_SEPARATOR));
 929             OUString const curMaster((curSep == -1)
 930                     ? OUString() : curName.copy(0, curSep));
 931             // check that the master matches, as msApiName exists once per
 932             // master page
 933             if (pSdStyleSheet->msApiName == rParentName && master == curMaster)
 934             {
 935                 if( pStyle != this )
 936                 {
 937                     SetParent(curName);
 938                 }
 939                 return;
 940             }
 941         }
 942         throw NoSuchElementException();
 943     }
 944     else
 945     {
 946         SetParent( rParentName );
 947     }
 948 }
 949
 950 // XPropertySet
 951
 952 Reference< XPropertySetInfo > SdStyleSheet::getPropertySetInfo()
 953 {
 954     throwIfDisposed();
 955     static Reference< XPropertySetInfo > xInfo = GetStylePropertySet().getPropertySetInfo();
 956     return xInfo;
 957 }
 958
 959 void SAL_CALL SdStyleSheet::setPropertyValue( const OUString& aPropertyName, const Any& aValue )
 960 {
 961     SolarMutexGuard aGuard;
 962     throwIfDisposed();
 963
 964     const SfxItemPropertySimpleEntry* pEntry = getPropertyMapEntry( aPropertyName );
 965     if( pEntry == nullptr )
 966     {
 967         throw UnknownPropertyException( aPropertyName, static_cast<cppu::OWeakObject*>(this));
 968     }
 969
 970     if( pEntry->nWID == WID_STYLE_HIDDEN )
 971     {
 972         bool bValue = false;
 973         if ( aValue >>= bValue )
 974             SetHidden( bValue );
 975         return;
 976     }
 977     if( pEntry->nWID == SDRATTR_TEXTDIRECTION )
 978         return; // not yet implemented for styles
 979
 980     if( pEntry->nWID == WID_STYLE_FAMILY )
 981         throw PropertyVetoException();
 982
 983     if( (pEntry->nWID == EE_PARA_NUMBULLET) && (GetFamily() == SfxStyleFamily::Page) )
 984     {
 985         OUString aStr;
 986         const sal_uInt32 nTempHelpId = GetHelpId( aStr );
 987
 988         if( (nTempHelpId >= HID_PSEUDOSHEET_OUTLINE2) && (nTempHelpId <= HID_PSEUDOSHEET_OUTLINE9) )
 989             return;
 990     }
 991
 992     SfxItemSet &rStyleSet = GetItemSet();
 993
 994     if( pEntry->nWID == OWN_ATTR_FILLBMP_MODE )
 995     {
 996         BitmapMode eMode;
 997         if( aValue >>= eMode )
 998         {
 999             rStyleSet.Put( XFillBmpStretchItem( eMode == BitmapMode_STRETCH ) );
1000             rStyleSet.Put( XFillBmpTileItem( eMode == BitmapMode_REPEAT ) );
1001             return;
1002         }
1003         throw IllegalArgumentException();
1004     }
1005
1006     SfxItemSet aSet( GetPool()->GetPool(),   {{pEntry->nWID, pEntry->nWID}});
1007     aSet.Put( rStyleSet );
1008
1009     if( !aSet.Count() )
1010     {
1011         if( EE_PARA_NUMBULLET == pEntry->nWID )
1012         {
1013             vcl::Font aBulletFont;
1014             SdStyleSheetPool::PutNumBulletItem( this, aBulletFont );
1015             aSet.Put( rStyleSet );
1016         }
1017         else
1018         {
1019             aSet.Put( GetPool()->GetPool().GetDefaultItem( pEntry->nWID ) );
1020         }
1021     }
1022
1023     if( pEntry->nMemberId == MID_NAME &&
1024         ( pEntry->nWID == XATTR_FILLBITMAP || pEntry->nWID == XATTR_FILLGRADIENT ||
1025           pEntry->nWID == XATTR_FILLHATCH || pEntry->nWID == XATTR_FILLFLOATTRANSPARENCE ||
1026           pEntry->nWID == XATTR_LINESTART || pEntry->nWID == XATTR_LINEEND || pEntry->nWID == XATTR_LINEDASH) )
1027     {
1028         OUString aTempName;
1029         if(!(aValue >>= aTempName ))
1030             throw IllegalArgumentException();
1031
1032         SvxShape::SetFillAttribute( pEntry->nWID, aTempName, aSet );
1033     }
1034     else if(!SvxUnoTextRangeBase::SetPropertyValueHelper( pEntry, aValue, aSet ))
1035     {
1036         SvxItemPropertySet_setPropertyValue( pEntry, aValue, aSet );
1037     }
1038
1039     rStyleSet.Put( aSet );
1040     Broadcast(SfxHint(SfxHintId::DataChanged));
1041
1042 }
1043
1044 Any SAL_CALL SdStyleSheet::getPropertyValue( const OUString& PropertyName )
1045 {
1046     SolarMutexGuard aGuard;
1047
1048     throwIfDisposed();
1049
1050     const SfxItemPropertySimpleEntry* pEntry = getPropertyMapEntry( PropertyName );
1051     if( pEntry == nullptr )
1052     {
1053         throw UnknownPropertyException( PropertyName, static_cast<cppu::OWeakObject*>(this));
1054     }
1055
1056     Any aAny;
1057
1058     if( pEntry->nWID == WID_STYLE_FAMILY )
1059     {
1060         if( nFamily == SfxStyleFamily::Page )
1061         {
1062             const OUString aLayoutName( GetName() );
1063             aAny <<= aLayoutName.copy( 0, aLayoutName.indexOf( SD_LT_SEPARATOR) );
1064         }
1065         else
1066         {
1067             aAny <<= GetFamilyString(nFamily);
1068         }
1069     }
1070     else if( pEntry->nWID == WID_STYLE_DISPNAME )
1071     {
1072         OUString aDisplayName;
1073         if ( nFamily == SfxStyleFamily::Page )
1074         {
1075             const SdStyleSheet* pStyleSheet = GetPseudoStyleSheet();
1076             if (pStyleSheet != nullptr)
1077                 aDisplayName = pStyleSheet->GetName();
1078         }
1079
1080         if (aDisplayName.isEmpty())
1081             aDisplayName = GetName();
1082
1083         aAny <<= aDisplayName;
1084     }
1085     else if( pEntry->nWID == SDRATTR_TEXTDIRECTION )
1086     {
1087         aAny <<= false;
1088     }
1089     else if( pEntry->nWID == OWN_ATTR_FILLBMP_MODE )
1090     {
1091         SfxItemSet &rStyleSet = GetItemSet();
1092
1093         const XFillBmpStretchItem* pStretchItem = rStyleSet.GetItem<XFillBmpStretchItem>(XATTR_FILLBMP_STRETCH);
1094         const XFillBmpTileItem* pTileItem = rStyleSet.GetItem<XFillBmpTileItem>(XATTR_FILLBMP_TILE);
1095
1096         if( pStretchItem && pTileItem )
1097         {
1098             if( pTileItem->GetValue() )
1099                 aAny <<= BitmapMode_REPEAT;
1100             else if( pStretchItem->GetValue() )
1101                 aAny <<= BitmapMode_STRETCH;
1102             else
1103                 aAny <<= BitmapMode_NO_REPEAT;
1104         }
1105     }
1106     else if( pEntry->nWID == WID_STYLE_HIDDEN )
1107     {
1108         aAny <<= IsHidden( );
1109     }
1110     else
1111     {
1112         SfxItemSet aSet( GetPool()->GetPool(),   {{pEntry->nWID, pEntry->nWID}});
1113
1114         const SfxPoolItem* pItem;
1115         SfxItemSet& rStyleSet = GetItemSet();
1116
1117         if( rStyleSet.GetItemState( pEntry->nWID, true, &pItem ) == SfxItemState::SET )
1118             aSet.Put(  *pItem );
1119
1120         if( !aSet.Count() )
1121             aSet.Put( GetPool()->GetPool().GetDefaultItem( pEntry->nWID ) );
1122
1123         if(SvxUnoTextRangeBase::GetPropertyValueHelper( aSet, pEntry, aAny ))
1124             return aAny;
1125
1126         // Get value of ItemSet
1127         aAny = SvxItemPropertySet_getPropertyValue( pEntry, aSet );
1128     }
1129
1130     if( pEntry->aType != aAny.getValueType() )
1131     {
1132         // since the sfx uint16 item now exports a sal_Int32, we may have to fix this here
1133         if( ( pEntry->aType == ::cppu::UnoType<sal_Int16>::get()) && aAny.getValueType() == ::cppu::UnoType<sal_Int32>::get() )
1134         {
1135             sal_Int32 nValue = 0;
1136             aAny >>= nValue;
1137             aAny <<= static_cast<sal_Int16>(nValue);
1138         }
1139         else
1140         {
1141             OSL_FAIL("SvxShape::GetAnyForItem() Returnvalue has wrong Type!" );
1142         }
1143     }
1144
1145     return aAny;
1146
1147 }
1148
1149 void SAL_CALL SdStyleSheet::addPropertyChangeListener( const OUString& , const Reference< XPropertyChangeListener >&  ) {}
1150 void SAL_CALL SdStyleSheet::removePropertyChangeListener( const OUString& , const Reference< XPropertyChangeListener >&  ) {}
1151 void SAL_CALL SdStyleSheet::addVetoableChangeListener( const OUString& , const Reference< XVetoableChangeListener >&  ) {}
1152 void SAL_CALL SdStyleSheet::removeVetoableChangeListener( const OUString& , const Reference< XVetoableChangeListener >&  ) {}
1153
1154 // XPropertyState
1155
1156 PropertyState SAL_CALL SdStyleSheet::getPropertyState( const OUString& PropertyName )
1157 {
1158     SolarMutexGuard aGuard;
1159
1160     throwIfDisposed();
1161
1162     const SfxItemPropertySimpleEntry* pEntry = getPropertyMapEntry( PropertyName );
1163
1164     if( pEntry == nullptr )
1165         throw UnknownPropertyException( PropertyName, static_cast<cppu::OWeakObject*>(this));
1166
1167     if( pEntry->nWID == WID_STYLE_FAMILY )
1168     {
1169         return PropertyState_DIRECT_VALUE;
1170     }
1171     else if( pEntry->nWID == SDRATTR_TEXTDIRECTION )
1172     {
1173         return PropertyState_DEFAULT_VALUE;
1174     }
1175     else if( pEntry->nWID == OWN_ATTR_FILLBMP_MODE )
1176     {
1177         const SfxItemSet& rSet = GetItemSet();
1178
1179         if( rSet.GetItemState( XATTR_FILLBMP_STRETCH, false ) == SfxItemState::SET ||
1180             rSet.GetItemState( XATTR_FILLBMP_TILE, false ) == SfxItemState::SET )
1181         {
1182             return PropertyState_DIRECT_VALUE;
1183         }
1184         else
1185         {
1186             return PropertyState_AMBIGUOUS_VALUE;
1187         }
1188     }
1189     else
1190     {
1191         SfxItemSet &rStyleSet = GetItemSet();
1192
1193         PropertyState eState;
1194
1195         switch( rStyleSet.GetItemState( pEntry->nWID, false ) )
1196         {
1197         case SfxItemState::READONLY:
1198         case SfxItemState::SET:
1199             eState = PropertyState_DIRECT_VALUE;
1200             break;
1201         case SfxItemState::DEFAULT:
1202             eState = PropertyState_DEFAULT_VALUE;
1203             break;
1204         default:
1205             eState = PropertyState_AMBIGUOUS_VALUE;
1206             break;
1207         }
1208
1209         // if an item is set, this doesn't mean we want it :)
1210         if( PropertyState_DIRECT_VALUE == eState )
1211         {
1212             switch( pEntry->nWID )
1213             {
1214             case XATTR_FILLBITMAP:
1215             case XATTR_FILLGRADIENT:
1216             case XATTR_FILLHATCH:
1217             case XATTR_FILLFLOATTRANSPARENCE:
1218             case XATTR_LINEEND:
1219             case XATTR_LINESTART:
1220             case XATTR_LINEDASH:
1221                 {
1222                     const NameOrIndex* pItem = rStyleSet.GetItem<NameOrIndex>(pEntry->nWID);
1223                     if( ( pItem == nullptr ) || pItem->GetName().isEmpty() )
1224                         eState = PropertyState_DEFAULT_VALUE;
1225                 }
1226             }
1227         }
1228
1229         return eState;
1230     }
1231 }
1232
1233 Sequence< PropertyState > SAL_CALL SdStyleSheet::getPropertyStates( const Sequence< OUString >& aPropertyName )
1234 {
1235     SolarMutexGuard aGuard;
1236
1237     throwIfDisposed();
1238
1239     sal_Int32 nCount = aPropertyName.getLength();
1240
1241     Sequence< PropertyState > aPropertyStateSequence( nCount );
1242
1243     std::transform(aPropertyName.begin(), aPropertyName.end(), aPropertyStateSequence.begin(),
1244         [this](const OUString& rName) -> PropertyState { return getPropertyState(rName); });
1245
1246     return aPropertyStateSequence;
1247 }
1248
1249 void SAL_CALL SdStyleSheet::setPropertyToDefault( const OUString& PropertyName )
1250 {
1251     SolarMutexGuard aGuard;
1252
1253     throwIfDisposed();
1254
1255     const SfxItemPropertySimpleEntry* pEntry = getPropertyMapEntry( PropertyName );
1256     if( pEntry == nullptr )
1257         throw UnknownPropertyException( PropertyName, static_cast<cppu::OWeakObject*>(this));
1258
1259     SfxItemSet &rStyleSet = GetItemSet();
1260
1261     if( pEntry->nWID == OWN_ATTR_FILLBMP_MODE )
1262     {
1263         rStyleSet.ClearItem( XATTR_FILLBMP_STRETCH );
1264         rStyleSet.ClearItem( XATTR_FILLBMP_TILE );
1265     }
1266     else
1267     {
1268         rStyleSet.ClearItem( pEntry->nWID );
1269     }
1270     Broadcast(SfxHint(SfxHintId::DataChanged));
1271 }
1272
1273 Any SAL_CALL SdStyleSheet::getPropertyDefault( const OUString& aPropertyName )
1274 {
1275     SolarMutexGuard aGuard;
1276
1277     throwIfDisposed();
1278
1279     const SfxItemPropertySimpleEntry* pEntry = getPropertyMapEntry( aPropertyName );
1280     if( pEntry == nullptr )
1281         throw UnknownPropertyException( aPropertyName, static_cast<cppu::OWeakObject*>(this));
1282     Any aRet;
1283     if( pEntry->nWID == WID_STYLE_FAMILY )
1284     {
1285         aRet <<= GetFamilyString(nFamily);
1286     }
1287     else if( pEntry->nWID == SDRATTR_TEXTDIRECTION )
1288     {
1289         aRet <<= false;
1290     }
1291     else if( pEntry->nWID == OWN_ATTR_FILLBMP_MODE )
1292     {
1293         aRet <<= BitmapMode_REPEAT;
1294     }
1295     else
1296     {
1297         SfxItemPool& rMyPool = GetPool()->GetPool();
1298         SfxItemSet aSet( rMyPool,   {{pEntry->nWID, pEntry->nWID}});
1299         aSet.Put( rMyPool.GetDefaultItem( pEntry->nWID ) );
1300         aRet = SvxItemPropertySet_getPropertyValue( pEntry, aSet );
1301     }
1302     return aRet;
1303 }
1304
1305 /** this is used because our property map is not sorted yet */
1306 const SfxItemPropertySimpleEntry* SdStyleSheet::getPropertyMapEntry( const OUString& rPropertyName )
1307 {
1308     return GetStylePropertySet().getPropertyMapEntry(rPropertyName);
1309 }
1310
1311 //Broadcast that a SdStyleSheet has changed, taking into account outline sublevels
1312 //which need to be explicitly broadcast as changing if their parent style was
1313 //the one that changed
1314 void SdStyleSheet::BroadcastSdStyleSheetChange(SfxStyleSheetBase const * pStyleSheet,
1315     PresentationObjects ePO, SfxStyleSheetBasePool* pSSPool)
1316 {
1317     SdStyleSheet* pRealSheet = static_cast<SdStyleSheet const *>(pStyleSheet)->GetRealStyleSheet();
1318     pRealSheet->Broadcast(SfxHint(SfxHintId::DataChanged));
1319
1320     if( (ePO < PresentationObjects::Outline_1) || (ePO > PresentationObjects::Outline_8) )
1321         return;
1322
1323     OUString sStyleName(SdResId(STR_PSEUDOSHEET_OUTLINE) + " ");
1324
1325     for( sal_uInt16 n = static_cast<sal_uInt16>(ePO) - static_cast<sal_uInt16>(PresentationObjects::Outline_1) + 2; n < 10; n++ )
1326     {
1327         OUString aName( sStyleName + OUString::number(n) );
1328
1329         SfxStyleSheetBase* pSheet = pSSPool->Find( aName, SfxStyleFamily::Pseudo);
1330
1331         if(pSheet)
1332         {
1333             SdStyleSheet* pRealStyleSheet = static_cast<SdStyleSheet*>(pSheet)->GetRealStyleSheet();
1334             pRealStyleSheet->Broadcast(SfxHint(SfxHintId::DataChanged));
1335         }
1336     }
1337 }
1338
1339 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */