svx/source/sdr/properties/textproperties.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <sal/config.h>
  21
  22 #include <sdr/properties/textproperties.hxx>
  23 #include <svl/itemset.hxx>
  24 #include <svl/style.hxx>
  25 #include <svl/itemiter.hxx>
  26 #include <svl/hint.hxx>
  27 #include <svx/svddef.hxx>
  28 #include <svx/svdotext.hxx>
  29 #include <svx/svdoutl.hxx>
  30 #include <svx/sdmetitm.hxx>
  31 #include <svx/sdtditm.hxx>
  32 #include <editeng/writingmodeitem.hxx>
  33 #include <svx/svdmodel.hxx>
  34 #include <editeng/eeitem.hxx>
  35 #include <editeng/outlobj.hxx>
  36 #include <svx/xfillit0.hxx>
  37 #include <svx/xflclit.hxx>
  38 #include <editeng/adjustitem.hxx>
  39 #include <svx/svdetc.hxx>
  40 #include <editeng/editeng.hxx>
  41 #include <editeng/flditem.hxx>
  42 #include <svx/xlineit0.hxx>
  43 #include <svx/xlnwtit.hxx>
  44
  45 using namespace com::sun::star;
  46
  47 namespace sdr::properties
  48 {
  49         SfxItemSet TextProperties::CreateObjectSpecificItemSet(SfxItemPool& rPool)
  50         {
  51             return SfxItemSet(rPool,
  52
  53                 // range from SdrAttrObj
  54                 svl::Items<SDRATTR_START, SDRATTR_SHADOW_LAST,
  55                 SDRATTR_MISC_FIRST, SDRATTR_MISC_LAST,
  56                 SDRATTR_TEXTDIRECTION, SDRATTR_TEXTDIRECTION,
  57                 SDRATTR_TEXTCOLUMNS_FIRST, SDRATTR_TEXTCOLUMNS_LAST,
  58
  59                 // range from SdrTextObj
  60                 EE_ITEMS_START, EE_ITEMS_END>);
  61         }
  62
  63         TextProperties::TextProperties(SdrObject& rObj)
  64         :   AttributeProperties(rObj),
  65             maVersion(0)
  66         {
  67         }
  68
  69         TextProperties::TextProperties(const TextProperties& rProps, SdrObject& rObj)
  70         :   AttributeProperties(rProps, rObj),
  71             maVersion(rProps.getVersion())
  72         {
  73         }
  74
  75         TextProperties::~TextProperties()
  76         {
  77         }
  78
  79         std::unique_ptr<BaseProperties> TextProperties::Clone(SdrObject& rObj) const
  80         {
  81             return std::unique_ptr<BaseProperties>(new TextProperties(*this, rObj));
  82         }
  83
  84         void TextProperties::ItemSetChanged(std::span< const SfxPoolItem* const > aChangedItems, sal_uInt16 nDeletedWhich)
  85         {
  86             SdrTextObj& rObj = static_cast<SdrTextObj&>(GetSdrObject());
  87
  88             // #i101556# ItemSet has changed -> new version
  89             maVersion++;
  90
  91             if (auto pOutliner = rObj.GetTextEditOutliner())
  92             {
  93                 pOutliner->SetTextColumns(rObj.GetTextColumnsNumber(),
  94                                           rObj.GetTextColumnsSpacing());
  95             }
  96
  97             const svx::ITextProvider& rTextProvider(getTextProvider());
  98             sal_Int32 nText = rTextProvider.getTextCount();
  99             while (nText--)
 100             {
 101                 SdrText* pText = rTextProvider.getText( nText );
 102
 103                 OutlinerParaObject* pParaObj = pText ? pText->GetOutlinerParaObject() : nullptr;
 104
 105                 if(pParaObj)
 106                 {
 107                     const bool bTextEdit = rObj.IsTextEditActive() && (rObj.getActiveText() == pText);
 108
 109                     // handle outliner attributes
 110                     GetObjectItemSet();
 111                     Outliner* pOutliner = rObj.GetTextEditOutliner();
 112
 113                     if(!bTextEdit)
 114                     {
 115                         pOutliner = &rObj.ImpGetDrawOutliner();
 116                         pOutliner->SetText(*pParaObj);
 117                     }
 118
 119                     sal_Int32 nParaCount(pOutliner->GetParagraphCount());
 120
 121                     for(sal_Int32 nPara = 0; nPara < nParaCount; nPara++)
 122                     {
 123                         SfxItemSet aSet(pOutliner->GetParaAttribs(nPara));
 124                         for (const SfxPoolItem* pItem : aChangedItems)
 125                             aSet.Put(*pItem);
 126                         if (nDeletedWhich)
 127                             aSet.ClearItem(nDeletedWhich);
 128                         pOutliner->SetParaAttribs(nPara, aSet);
 129                     }
 130
 131                     if(!bTextEdit)
 132                     {
 133                         if(nParaCount)
 134                         {
 135                             // force ItemSet
 136                             GetObjectItemSet();
 137
 138                             moItemSet->Put(pOutliner->GetParaAttribs(0));
 139                         }
 140
 141                         std::optional<OutlinerParaObject> pTemp = pOutliner->CreateParaObject(0, nParaCount);
 142                         pOutliner->Clear();
 143
 144                         rObj.NbcSetOutlinerParaObjectForText(std::move(pTemp),pText);
 145                     }
 146                 }
 147             }
 148
 149             // Extra-Repaint for radical layout changes (#43139#)
 150             for (const SfxPoolItem* pItem : aChangedItems)
 151                 if (pItem->Which() == SDRATTR_TEXT_CONTOURFRAME)
 152                 {
 153                     // Here only repaint wanted
 154                     rObj.ActionChanged();
 155                     //rObj.BroadcastObjectChange();
 156                     break;
 157                 }
 158
 159             // call parent
 160             AttributeProperties::ItemSetChanged(aChangedItems, nDeletedWhich);
 161         }
 162
 163         void TextProperties::ItemChange(const sal_uInt16 nWhich, const SfxPoolItem* pNewItem)
 164         {
 165             SdrTextObj& rObj = static_cast<SdrTextObj&>(GetSdrObject());
 166
 167             // #i25616#
 168             sal_Int32 nOldLineWidth(0);
 169
 170             if(XATTR_LINEWIDTH == nWhich && rObj.DoesSupportTextIndentingOnLineWidthChange())
 171             {
 172                 nOldLineWidth = GetItem(XATTR_LINEWIDTH).GetValue();
 173             }
 174
 175             if(pNewItem && (SDRATTR_TEXTDIRECTION == nWhich))
 176             {
 177                 bool bVertical(css::text::WritingMode_TB_RL == static_cast<const SvxWritingModeItem*>(pNewItem)->GetValue());
 178                 rObj.SetVerticalWriting(bVertical);
 179             }
 180
 181             // #95501# reset to default
 182             if(!pNewItem && !nWhich && rObj.HasText() )
 183             {
 184                 SdrOutliner& rOutliner = rObj.ImpGetDrawOutliner();
 185
 186                 const svx::ITextProvider& rTextProvider(getTextProvider());
 187                 sal_Int32 nCount = rTextProvider.getTextCount();
 188                 while (nCount--)
 189                 {
 190                     SdrText* pText = rTextProvider.getText( nCount );
 191                     OutlinerParaObject* pParaObj = pText->GetOutlinerParaObject();
 192                     if( pParaObj )
 193                     {
 194                         rOutliner.SetText(*pParaObj);
 195                         sal_Int32 nParaCount(rOutliner.GetParagraphCount());
 196
 197                         if(nParaCount)
 198                         {
 199                             ESelection aSelection( 0, 0, EE_PARA_ALL, EE_TEXTPOS_ALL);
 200                             rOutliner.RemoveAttribs(aSelection, true, 0);
 201
 202                             std::optional<OutlinerParaObject> pTemp = rOutliner.CreateParaObject(0, nParaCount);
 203                             rOutliner.Clear();
 204
 205                             rObj.NbcSetOutlinerParaObjectForText( std::move(pTemp), pText );
 206                         }
 207                     }
 208                 }
 209             }
 210
 211             // call parent
 212             AttributeProperties::ItemChange( nWhich, pNewItem );
 213
 214             // #i25616#
 215             if(!(XATTR_LINEWIDTH == nWhich && rObj.DoesSupportTextIndentingOnLineWidthChange()))
 216                 return;
 217
 218             const sal_Int32 nNewLineWidth(GetItem(XATTR_LINEWIDTH).GetValue());
 219             const sal_Int32 nDifference((nNewLineWidth - nOldLineWidth) / 2);
 220
 221             if(!nDifference)
 222                 return;
 223
 224             const bool bLineVisible(drawing::LineStyle_NONE != GetItem(XATTR_LINESTYLE).GetValue());
 225
 226             if(bLineVisible)
 227             {
 228                 const sal_Int32 nLeftDist(GetItem(SDRATTR_TEXT_LEFTDIST).GetValue());
 229                 const sal_Int32 nRightDist(GetItem(SDRATTR_TEXT_RIGHTDIST).GetValue());
 230                 const sal_Int32 nUpperDist(GetItem(SDRATTR_TEXT_UPPERDIST).GetValue());
 231                 const sal_Int32 nLowerDist(GetItem(SDRATTR_TEXT_LOWERDIST).GetValue());
 232
 233                 SetObjectItemDirect(makeSdrTextLeftDistItem(nLeftDist + nDifference));
 234                 SetObjectItemDirect(makeSdrTextRightDistItem(nRightDist + nDifference));
 235                 SetObjectItemDirect(makeSdrTextUpperDistItem(nUpperDist + nDifference));
 236                 SetObjectItemDirect(makeSdrTextLowerDistItem(nLowerDist + nDifference));
 237             }
 238         }
 239
 240         const svx::ITextProvider& TextProperties::getTextProvider() const
 241         {
 242             return static_cast<const SdrTextObj&>(GetSdrObject());
 243         }
 244
 245         void TextProperties::SetStyleSheet(SfxStyleSheet* pNewStyleSheet, bool bDontRemoveHardAttr,
 246                 bool bBroadcast)
 247         {
 248             // call parent (always first thing to do, may create the SfxItemSet)
 249             AttributeProperties::SetStyleSheet(pNewStyleSheet, bDontRemoveHardAttr, bBroadcast);
 250
 251             // #i101556# StyleSheet has changed -> new version
 252             SdrTextObj& rObj = static_cast<SdrTextObj&>(GetSdrObject());
 253             maVersion++;
 254
 255             if(!rObj.IsLinkedText() )
 256             {
 257                 SdrOutliner& rOutliner = rObj.ImpGetDrawOutliner();
 258
 259                 const svx::ITextProvider& rTextProvider(getTextProvider());
 260                 sal_Int32 nText = rTextProvider.getTextCount();
 261                 while (nText--)
 262                 {
 263                     SdrText* pText = rTextProvider.getText( nText );
 264
 265                     OutlinerParaObject* pParaObj = pText ? pText->GetOutlinerParaObject() : nullptr;
 266                     if( !pParaObj )
 267                         continue;
 268
 269                     // apply StyleSheet to all paragraphs
 270                     rOutliner.SetText(*pParaObj);
 271                     sal_Int32 nParaCount(rOutliner.GetParagraphCount());
 272
 273                     if(nParaCount)
 274                     {
 275                         for(sal_Int32 nPara = 0; nPara < nParaCount; nPara++)
 276                         {
 277                             std::optional<SfxItemSet> pTempSet;
 278
 279                             // since setting the stylesheet removes all para attributes
 280                             if(bDontRemoveHardAttr)
 281                             {
 282                                 // we need to remember them if we want to keep them
 283                                 pTempSet.emplace(rOutliner.GetParaAttribs(nPara));
 284                             }
 285
 286                             if(GetStyleSheet())
 287                             {
 288                                 if((SdrObjKind::OutlineText == rObj.GetTextKind()) && (SdrInventor::Default == rObj.GetObjInventor()))
 289                                 {
 290                                     OUString aNewStyleSheetName(GetStyleSheet()->GetName());
 291                                     aNewStyleSheetName = aNewStyleSheetName.copy(0, aNewStyleSheetName.getLength() - 1);
 292                                     sal_Int16 nDepth = rOutliner.GetDepth(nPara);
 293                                     aNewStyleSheetName += OUString::number( nDepth <= 0 ? 1 : nDepth + 1);
 294                                     SfxStyleSheetBasePool* pStylePool(rObj.getSdrModelFromSdrObject().GetStyleSheetPool());
 295                                     SfxStyleSheet* pNewStyle = nullptr;
 296                                     if(pStylePool)
 297                                         pNewStyle = static_cast<SfxStyleSheet*>(pStylePool->Find(aNewStyleSheetName, GetStyleSheet()->GetFamily()));
 298                                     DBG_ASSERT( pNewStyle, "AutoStyleSheetName - Style not found!" );
 299
 300                                     if(pNewStyle)
 301                                     {
 302                                         rOutliner.SetStyleSheet(nPara, pNewStyle);
 303                                     }
 304                                 }
 305                                 else
 306                                 {
 307                                     rOutliner.SetStyleSheet(nPara, GetStyleSheet());
 308                                 }
 309                             }
 310                             else
 311                             {
 312                                 // remove StyleSheet
 313                                 rOutliner.SetStyleSheet(nPara, nullptr);
 314                             }
 315
 316                             if(bDontRemoveHardAttr)
 317                             {
 318                                 if(pTempSet)
 319                                 {
 320                                     // restore para attributes
 321                                     rOutliner.SetParaAttribs(nPara, *pTempSet);
 322                                 }
 323                             }
 324                             else
 325                             {
 326                                 if(pNewStyleSheet)
 327                                 {
 328                                     // remove all hard paragraph attributes
 329                                     // which occur in StyleSheet, take care of
 330                                     // parents (!)
 331                                     SfxItemIter aIter(pNewStyleSheet->GetItemSet());
 332
 333                                     for (const SfxPoolItem* pItem = aIter.GetCurItem(); pItem;
 334                                          pItem = aIter.NextItem())
 335                                     {
 336                                         if(!IsInvalidItem(pItem))
 337                                         {
 338                                             sal_uInt16 nW(pItem->Which());
 339
 340                                             if(nW >= EE_ITEMS_START && nW <= EE_ITEMS_END)
 341                                             {
 342                                                 rOutliner.RemoveCharAttribs(nPara, nW);
 343                                             }
 344                                         }
 345                                     }
 346                                 }
 347                             }
 348                         }
 349
 350                         std::optional<OutlinerParaObject> pTemp = rOutliner.CreateParaObject(0, nParaCount);
 351                         rOutliner.Clear();
 352                         rObj.NbcSetOutlinerParaObjectForText(std::move(pTemp), pText);
 353                     }
 354                 }
 355             }
 356
 357             if(rObj.IsTextFrame())
 358             {
 359                 rObj.NbcAdjustTextFrameWidthAndHeight();
 360             }
 361         }
 362
 363         void TextProperties::ForceDefaultAttributes()
 364         {
 365             SdrTextObj& rObj = static_cast<SdrTextObj&>(GetSdrObject());
 366
 367             if( rObj.GetObjInventor() == SdrInventor::Default )
 368             {
 369                 const SdrObjKind nSdrObjKind = rObj.GetObjIdentifier();
 370
 371                 if( nSdrObjKind == SdrObjKind::TitleText || nSdrObjKind == SdrObjKind::OutlineText )
 372                     return; // no defaults for presentation objects
 373             }
 374
 375             bool bTextFrame(rObj.IsTextFrame());
 376
 377             if(bTextFrame)
 378             {
 379                 moItemSet->Put(XLineStyleItem(drawing::LineStyle_NONE));
 380                 moItemSet->Put(XFillColorItem(OUString(), COL_WHITE));
 381                 moItemSet->Put(XFillStyleItem(drawing::FillStyle_NONE));
 382             }
 383             else
 384             {
 385                 moItemSet->Put(SvxAdjustItem(SvxAdjust::Center, EE_PARA_JUST));
 386                 moItemSet->Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_CENTER));
 387                 moItemSet->Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_CENTER));
 388             }
 389         }
 390
 391         void TextProperties::ForceStyleToHardAttributes()
 392         {
 393             // #i61284# call parent first to get the hard ObjectItemSet
 394             AttributeProperties::ForceStyleToHardAttributes();
 395
 396             // #i61284# push hard ObjectItemSet to OutlinerParaObject attributes
 397             // using existing functionality
 398             GetObjectItemSet(); // force ItemSet
 399             std::vector<const SfxPoolItem*> aChangedItems;
 400             SfxItemIter aIter(*moItemSet);
 401             for (const SfxPoolItem* pItem = aIter.GetCurItem(); pItem; pItem = aIter.NextItem())
 402             {
 403                 if(!IsInvalidItem(pItem))
 404                     aChangedItems.push_back(pItem);
 405             }
 406             ItemSetChanged(aChangedItems, 0);
 407
 408             // now the standard TextProperties stuff
 409             SdrTextObj& rObj = static_cast<SdrTextObj&>(GetSdrObject());
 410
 411             if(rObj.IsTextEditActive() || rObj.IsLinkedText())
 412                 return;
 413
 414             std::unique_ptr<Outliner> pOutliner = SdrMakeOutliner(OutlinerMode::OutlineObject, rObj.getSdrModelFromSdrObject());
 415             const svx::ITextProvider& rTextProvider(getTextProvider());
 416             sal_Int32 nText = rTextProvider.getTextCount();
 417             while (nText--)
 418             {
 419                 SdrText* pText = rTextProvider.getText( nText );
 420
 421                 OutlinerParaObject* pParaObj = pText ? pText->GetOutlinerParaObject() : nullptr;
 422                 if( !pParaObj )
 423                     continue;
 424
 425                 pOutliner->SetText(*pParaObj);
 426
 427                 sal_Int32 nParaCount(pOutliner->GetParagraphCount());
 428
 429                 if(nParaCount)
 430                 {
 431                     bool bBurnIn(false);
 432
 433                     for(sal_Int32 nPara = 0; nPara < nParaCount; nPara++)
 434                     {
 435                         SfxStyleSheet* pSheet = pOutliner->GetStyleSheet(nPara);
 436
 437                         if(pSheet)
 438                         {
 439                             SfxItemSet aParaSet(pOutliner->GetParaAttribs(nPara));
 440                             SfxItemSet aSet(*aParaSet.GetPool());
 441                             aSet.Put(pSheet->GetItemSet());
 442
 443                             /** the next code handles a special case for paragraphs that contain a
 444                                 url field. The color for URL fields is either the system color for
 445                                 urls or the char color attribute that formats the portion in which the
 446                                 url field is contained.
 447                                 When we set a char color attribute to the paragraphs item set from the
 448                                 styles item set, we would have this char color attribute as an attribute
 449                                 that is spanned over the complete paragraph after xml import due to some
 450                                 problems in the xml import (using a XCursor on import so it does not know
 451                                 the paragraphs and can't set char attributes to paragraphs ).
 452
 453                                 To avoid this, as soon as we try to set a char color attribute from the style
 454                                 we
 455                                 1. check if we have at least one url field in this paragraph
 456                                 2. if we found at least one url field, we span the char color attribute over
 457                                 all portions that are not url fields and remove the char color attribute
 458                                 from the paragraphs item set
 459                             */
 460
 461                             bool bHasURL(false);
 462
 463                             if(aSet.GetItemState(EE_CHAR_COLOR) == SfxItemState::SET)
 464                             {
 465                                 EditEngine* pEditEngine = const_cast<EditEngine*>(&(pOutliner->GetEditEngine()));
 466                                 std::vector<EECharAttrib> aAttribs;
 467                                 pEditEngine->GetCharAttribs(nPara, aAttribs);
 468
 469                                 for(const auto& rAttrib : aAttribs)
 470                                 {
 471                                     if(rAttrib.pAttr && EE_FEATURE_FIELD == rAttrib.pAttr->Which())
 472                                     {
 473                                         const SvxFieldItem* pFieldItem = static_cast<const SvxFieldItem*>(rAttrib.pAttr);
 474
 475                                         if(pFieldItem)
 476                                         {
 477                                             const SvxFieldData* pData = pFieldItem->GetField();
 478
 479                                             if(dynamic_cast<const SvxURLField*>( pData))
 480                                             {
 481                                                 bHasURL = true;
 482                                                 break;
 483                                             }
 484                                         }
 485                                     }
 486                                 }
 487
 488                                 if(bHasURL)
 489                                 {
 490                                     SfxItemSetFixed<EE_CHAR_COLOR, EE_CHAR_COLOR> aColorSet(*aSet.GetPool());
 491                                     aColorSet.Put(aSet, false);
 492
 493                                     ESelection aSel(nPara, 0);
 494
 495                                     for(const auto& rAttrib : aAttribs)
 496                                     {
 497                                         if(EE_FEATURE_FIELD == rAttrib.pAttr->Which())
 498                                         {
 499                                             aSel.nEndPos = rAttrib.nStart;
 500
 501                                             if(aSel.nStartPos != aSel.nEndPos)
 502                                                 pEditEngine->QuickSetAttribs(aColorSet, aSel);
 503
 504                                             aSel.nStartPos = rAttrib.nEnd;
 505                                         }
 506                                     }
 507
 508                                     aSel.nEndPos = pEditEngine->GetTextLen(nPara);
 509
 510                                     if(aSel.nStartPos != aSel.nEndPos)
 511                                     {
 512                                         pEditEngine->QuickSetAttribs( aColorSet, aSel );
 513                                     }
 514                                 }
 515
 516                             }
 517
 518                             aSet.Put(aParaSet, false);
 519
 520                             if(bHasURL)
 521                             {
 522                                 aSet.ClearItem(EE_CHAR_COLOR);
 523                             }
 524
 525                             pOutliner->SetParaAttribs(nPara, aSet);
 526                             bBurnIn = true; // #i51163# Flag was set wrong
 527                         }
 528                     }
 529
 530                     if(bBurnIn)
 531                     {
 532                         std::optional<OutlinerParaObject> pTemp = pOutliner->CreateParaObject(0, nParaCount);
 533                         rObj.NbcSetOutlinerParaObjectForText(std::move(pTemp),pText);
 534                     }
 535                 }
 536
 537                 pOutliner->Clear();
 538             }
 539         }
 540
 541         void TextProperties::SetObjectItemNoBroadcast(const SfxPoolItem& rItem)
 542         {
 543             GetObjectItemSet();
 544             moItemSet->Put(rItem);
 545         }
 546
 547
 548         void TextProperties::Notify(SfxBroadcaster& rBC, const SfxHint& rHint)
 549         {
 550             // call parent
 551             AttributeProperties::Notify(rBC, rHint);
 552
 553             SdrTextObj& rObj = static_cast<SdrTextObj&>(GetSdrObject());
 554             if(!rObj.HasText())
 555                 return;
 556
 557             SfxHintId nId(rHint.GetId());
 558             const svx::ITextProvider& rTextProvider(getTextProvider());
 559
 560             if(SfxHintId::DataChanged == nId && dynamic_cast<const SfxStyleSheet *>(&rBC) != nullptr)
 561             {
 562                 sal_Int32 nText = rTextProvider.getTextCount();
 563                 while (nText--)
 564                 {
 565                     OutlinerParaObject* pParaObj = rTextProvider.getText( nText )->GetOutlinerParaObject();
 566                     if( pParaObj )
 567                         pParaObj->ClearPortionInfo();
 568                 }
 569                 rObj.SetTextSizeDirty();
 570
 571                 if(rObj.IsTextFrame() && rObj.NbcAdjustTextFrameWidthAndHeight())
 572                 {
 573                     // here only repaint wanted
 574                     rObj.ActionChanged();
 575                     //rObj.BroadcastObjectChange();
 576                 }
 577
 578                 // #i101556# content of StyleSheet has changed -> new version
 579                 maVersion++;
 580             }
 581             else if(SfxHintId::Dying == nId && dynamic_cast<const SfxStyleSheet *>(&rBC) != nullptr)
 582             {
 583                 sal_Int32 nText = rTextProvider.getTextCount();
 584                 while (nText--)
 585                 {
 586                     OutlinerParaObject* pParaObj = rTextProvider.getText( nText )->GetOutlinerParaObject();
 587                     if( pParaObj )
 588                         pParaObj->ClearPortionInfo();
 589                 }
 590             }
 591             else if (nId == SfxHintId::StyleSheetModified && dynamic_cast<const SfxStyleSheetBasePool *>(&rBC) != nullptr)
 592             {
 593                 const SfxStyleSheetModifiedHint* pExtendedHint = dynamic_cast<const SfxStyleSheetModifiedHint*>(&rHint);
 594                 if (pExtendedHint)
 595                 {
 596                     const OUString& aOldName(pExtendedHint->GetOldName());
 597                     OUString aNewName(pExtendedHint->GetStyleSheet()->GetName());
 598                     SfxStyleFamily eFamily = pExtendedHint->GetStyleSheet()->GetFamily();
 599
 600                     if(aOldName != aNewName)
 601                     {
 602                         sal_Int32 nText = rTextProvider.getTextCount();
 603                         while (nText--)
 604                         {
 605                             OutlinerParaObject* pParaObj = rTextProvider.getText( nText )->GetOutlinerParaObject();
 606                             if( pParaObj )
 607                                 pParaObj->ChangeStyleSheetName(eFamily, aOldName, aNewName);
 608                         }
 609                     }
 610                 }
 611             }
 612         }
 613
 614         // #i101556# Handout version information
 615         sal_uInt32 TextProperties::getVersion() const
 616         {
 617             return maVersion;
 618         }
 619 } // end of namespace
 620
 621 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */