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