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