svx/source/sdr/properties/attributeproperties.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: attributeproperties.cxx,v $
  10  * $Revision: 1.13 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_svx.hxx"
  33 #include <svx/sdr/properties/attributeproperties.hxx>
  34 #include <svx/sdr/properties/itemsettools.hxx>
  35 #include <tools/debug.hxx>
  36 #include <svtools/itemset.hxx>
  37 #include <svtools/style.hxx>
  38 #include <svtools/whiter.hxx>
  39 #include <svtools/poolitem.hxx>
  40 #include <svx/svdobj.hxx>
  41 #include <svx/svddef.hxx>
  42 #include <svx/xit.hxx>
  43 #include <svx/xbtmpit.hxx>
  44 #include <svx/xlndsit.hxx>
  45 #include <svx/xlnstit.hxx>
  46 #include <svx/xlnedit.hxx>
  47 #include <svx/xflgrit.hxx>
  48 #include <svx/xflftrit.hxx>
  49 #include <svx/xflhtit.hxx>
  50 #include <svx/xlnasit.hxx>
  51 #include <svx/xflasit.hxx>
  52 #include <svx/svdmodel.hxx>
  53 #include <svx/svdtrans.hxx>
  54 #include <svx/svdpage.hxx>
  55
  56 // #114265#
  57 #include <svtools/smplhint.hxx>
  58
  59 //////////////////////////////////////////////////////////////////////////////
  60
  61 namespace sdr
  62 {
  63     namespace properties
  64     {
  65         void AttributeProperties::ImpAddStyleSheet(SfxStyleSheet* pNewStyleSheet, sal_Bool bDontRemoveHardAttr)
  66         {
  67             // test if old StyleSheet is cleared, else it would be lost
  68             // after this method -> memory leak (!)
  69             DBG_ASSERT(!mpStyleSheet, "Old style sheet not deleted before setting new one (!)");
  70
  71             if(pNewStyleSheet)
  72             {
  73                 mpStyleSheet = pNewStyleSheet;
  74
  75                 // local ItemSet is needed here, force it
  76                 GetObjectItemSet();
  77
  78                 // register as listener
  79                 StartListening(pNewStyleSheet->GetPool());
  80                 StartListening(*pNewStyleSheet);
  81
  82                 // Delete hard attributes where items are set in the style sheet
  83                 if(!bDontRemoveHardAttr)
  84                 {
  85                     const SfxItemSet& rStyle = pNewStyleSheet->GetItemSet();
  86                     SfxWhichIter aIter(rStyle);
  87                     sal_uInt16 nWhich = aIter.FirstWhich();
  88
  89                     while(nWhich)
  90                     {
  91                         if(SFX_ITEM_SET == rStyle.GetItemState(nWhich))
  92                         {
  93                             mpItemSet->ClearItem(nWhich);
  94                         }
  95
  96                         nWhich = aIter.NextWhich();
  97                     }
  98                 }
  99
 100                 // set new stylesheet as parent
 101                 mpItemSet->SetParent(&pNewStyleSheet->GetItemSet());
 102             }
 103         }
 104
 105         void AttributeProperties::ImpRemoveStyleSheet()
 106         {
 107             // Check type since it is destroyed when the type is deleted
 108             if(GetStyleSheet() && HAS_BASE(SfxStyleSheet, mpStyleSheet))
 109             {
 110                 EndListening(*mpStyleSheet);
 111                 EndListening(mpStyleSheet->GetPool());
 112
 113                 // reset parent of ItemSet
 114                 if(mpItemSet)
 115                 {
 116                     mpItemSet->SetParent(0L);
 117                 }
 118
 119                 SdrObject& rObj = GetSdrObject();
 120                 rObj.SetBoundRectDirty();
 121                 rObj.SetRectsDirty(sal_True);
 122             }
 123
 124             mpStyleSheet = 0L;
 125         }
 126
 127         // create a new itemset
 128         SfxItemSet& AttributeProperties::CreateObjectSpecificItemSet(SfxItemPool& rPool)
 129         {
 130             return *(new SfxItemSet(rPool,
 131
 132                 // ranges from SdrAttrObj
 133                 SDRATTR_START, SDRATTR_SHADOW_LAST,
 134                 SDRATTR_MISC_FIRST, SDRATTR_MISC_LAST,
 135                 SDRATTR_TEXTDIRECTION, SDRATTR_TEXTDIRECTION,
 136
 137                 // end
 138                 0, 0));
 139         }
 140
 141         AttributeProperties::AttributeProperties(SdrObject& rObj)
 142         :       DefaultProperties(rObj),
 143             mpStyleSheet(0L)
 144         {
 145         }
 146
 147         AttributeProperties::AttributeProperties(const AttributeProperties& rProps, SdrObject& rObj)
 148         :       DefaultProperties(rProps, rObj),
 149             mpStyleSheet(0L)
 150         {
 151             if(rProps.GetStyleSheet())
 152             {
 153                 ImpAddStyleSheet(rProps.GetStyleSheet(), sal_True);
 154             }
 155         }
 156
 157         AttributeProperties::~AttributeProperties()
 158         {
 159             ImpRemoveStyleSheet();
 160         }
 161
 162         BaseProperties& AttributeProperties::Clone(SdrObject& rObj) const
 163         {
 164             return *(new AttributeProperties(*this, rObj));
 165         }
 166
 167         void AttributeProperties::ItemSetChanged(const SfxItemSet& /*rSet*/)
 168         {
 169             // own modifications
 170             SdrObject& rObj = GetSdrObject();
 171
 172             rObj.SetBoundRectDirty();
 173             rObj.SetRectsDirty(sal_True);
 174             rObj.SetChanged();
 175         }
 176
 177         void AttributeProperties::ItemChange(const sal_uInt16 nWhich, const SfxPoolItem* pNewItem)
 178         {
 179             if(pNewItem)
 180             {
 181                 const SfxPoolItem* pItem = pNewItem;
 182                 SdrModel* pModel = GetSdrObject().GetModel();
 183
 184                 switch( nWhich )
 185                 {
 186                     case XATTR_FILLBITMAP:
 187                     {
 188                         pItem = ((XFillBitmapItem*)pItem)->checkForUniqueItem( pModel );
 189                         break;
 190                     }
 191                     case XATTR_LINEDASH:
 192                     {
 193                         pItem = ((XLineDashItem*)pItem)->checkForUniqueItem( pModel );
 194                         break;
 195                     }
 196                     case XATTR_LINESTART:
 197                     {
 198                         pItem = ((XLineStartItem*)pItem)->checkForUniqueItem( pModel );
 199                         break;
 200                     }
 201                     case XATTR_LINEEND:
 202                     {
 203                         pItem = ((XLineEndItem*)pItem)->checkForUniqueItem( pModel );
 204                         break;
 205                     }
 206                     case XATTR_FILLGRADIENT:
 207                     {
 208                         pItem = ((XFillGradientItem*)pItem)->checkForUniqueItem( pModel );
 209                         break;
 210                     }
 211                     case XATTR_FILLFLOATTRANSPARENCE:
 212                     {
 213                         // #85953# allow all kinds of XFillFloatTransparenceItem to be set
 214                         pItem = ((XFillFloatTransparenceItem*)pItem)->checkForUniqueItem( pModel );
 215                         break;
 216                     }
 217                     case XATTR_FILLHATCH:
 218                     {
 219                         pItem = ((XFillHatchItem*)pItem)->checkForUniqueItem( pModel );
 220                         break;
 221                     }
 222                 }
 223
 224                 // set item
 225                 if(pItem)
 226                 {
 227                     // force ItemSet
 228                     GetObjectItemSet();
 229                     mpItemSet->Put(*pItem);
 230
 231                     // delete item if it was a generated one
 232                     if(pItem != pNewItem)
 233                     {
 234                         delete (SfxPoolItem*)pItem;
 235                     }
 236                 }
 237             }
 238             else
 239             {
 240                 // clear item if ItemSet exists
 241                 if(mpItemSet)
 242                 {
 243                     mpItemSet->ClearItem(nWhich);
 244                 }
 245             }
 246         }
 247
 248         void AttributeProperties::SetStyleSheet(SfxStyleSheet* pNewStyleSheet, sal_Bool bDontRemoveHardAttr)
 249         {
 250             ImpRemoveStyleSheet();
 251             ImpAddStyleSheet(pNewStyleSheet, bDontRemoveHardAttr);
 252
 253             SdrObject& rObj = GetSdrObject();
 254             rObj.SetBoundRectDirty();
 255             rObj.SetRectsDirty(sal_True);
 256         }
 257
 258         SfxStyleSheet* AttributeProperties::GetStyleSheet() const
 259         {
 260             return mpStyleSheet;
 261         }
 262
 263         void AttributeProperties::MoveToItemPool(SfxItemPool* pSrcPool, SfxItemPool* pDestPool, SdrModel* pNewModel)
 264         {
 265             if(pSrcPool && pDestPool && (pSrcPool != pDestPool))
 266             {
 267                 if(mpItemSet)
 268                 {
 269                     // migrate ItemSet to new pool. Scaling is NOT necessary
 270                     // because this functionality is used by UNDO only. Thus
 271                     // objects and ItemSets would be moved back to their original
 272                     // pool before usage.
 273                     SfxItemSet* pOldSet = mpItemSet;
 274                     SfxStyleSheet* pStySheet = GetStyleSheet();
 275
 276                     if(pStySheet)
 277                     {
 278                         ImpRemoveStyleSheet();
 279                     }
 280
 281                     mpItemSet = mpItemSet->Clone(FALSE, pDestPool);
 282                     GetSdrObject().GetModel()->MigrateItemSet(pOldSet, mpItemSet, pNewModel);
 283
 284                     // set stylesheet (if used)
 285                     if(pStySheet)
 286                     {
 287                         ImpAddStyleSheet(pStySheet, sal_True);
 288                     }
 289
 290                     delete pOldSet;
 291                 }
 292             }
 293         }
 294
 295         void AttributeProperties::SetModel(SdrModel* pOldModel, SdrModel* pNewModel)
 296         {
 297             if(pOldModel != pNewModel && pNewModel && !pNewModel->IsLoading())
 298             {
 299                 // For a living model move the items from one pool to the other
 300                 if(pOldModel)
 301                 {
 302                     // If metric has changed, scale items.
 303                     MapUnit aOldUnit(pOldModel->GetScaleUnit());
 304                     MapUnit aNewUnit(pNewModel->GetScaleUnit());
 305                     sal_Bool bScaleUnitChanged(aNewUnit != aOldUnit);
 306                     Fraction aMetricFactor;
 307
 308                     if(bScaleUnitChanged)
 309                     {
 310                         aMetricFactor = GetMapFactor(aOldUnit, aNewUnit).X();
 311                         Scale(aMetricFactor);
 312                     }
 313
 314                     // Move all styles which are used by the object to the new
 315                     // StyleSheet pool
 316                     SfxStyleSheet* pOldStyleSheet = GetStyleSheet();
 317
 318                     if(pOldStyleSheet)
 319                     {
 320                         SfxStyleSheetBase* pSheet = pOldStyleSheet;
 321                         SfxStyleSheetBasePool* pOldPool = pOldModel->GetStyleSheetPool();
 322                         SfxStyleSheetBasePool* pNewPool = pNewModel->GetStyleSheetPool();
 323                         DBG_ASSERT(pOldPool, "Properties::SetModel(): Object has StyleSheet but no StyleSheetPool (!)");
 324
 325                         if(pOldPool && pNewPool)
 326                         {
 327                             // build a list of to-be-copied Styles
 328                             List aList;
 329                             SfxStyleSheetBase* pAnchor = 0L;
 330
 331                             while(pSheet)
 332                             {
 333                                 pAnchor = pNewPool->Find(pSheet->GetName(), pSheet->GetFamily());
 334
 335                                 if(!pAnchor)
 336                                 {
 337                                     aList.Insert(pSheet, LIST_APPEND);
 338                                     pSheet = pOldPool->Find(pSheet->GetParent(), pSheet->GetFamily());
 339                                 }
 340                                 else
 341                                 {
 342                                     // the style does exist
 343                                     pSheet = 0L;
 344                                 }
 345                             }
 346
 347                             // copy and set the parents
 348                             pSheet = (SfxStyleSheetBase*)aList.First();
 349                             SfxStyleSheetBase* pNewSheet = 0L;
 350                             SfxStyleSheetBase* pLastSheet = 0L;
 351                             SfxStyleSheetBase* pForThisObject = 0L;
 352
 353                             while(pSheet)
 354                             {
 355                                 pNewSheet = &pNewPool->Make(pSheet->GetName(), pSheet->GetFamily(), pSheet->GetMask());
 356                                 pNewSheet->GetItemSet().Put(pSheet->GetItemSet(), FALSE);
 357
 358                                 if(bScaleUnitChanged)
 359                                 {
 360                                     sdr::properties::ScaleItemSet(pNewSheet->GetItemSet(), aMetricFactor);
 361                                 }
 362
 363                                 if(pLastSheet)
 364                                 {
 365                                     pLastSheet->SetParent(pNewSheet->GetName());
 366                                 }
 367
 368                                 if(!pForThisObject)
 369                                 {
 370                                     pForThisObject = pNewSheet;
 371                                 }
 372
 373                                 pLastSheet = pNewSheet;
 374                                 pSheet = (SfxStyleSheetBase*)aList.Next();
 375                             }
 376
 377                             // Set link to the Style found in the Pool
 378                             if(pAnchor && pLastSheet)
 379                             {
 380                                 pLastSheet->SetParent(pAnchor->GetName());
 381                             }
 382
 383                             // if list was empty (all Styles exist in destination pool)
 384                             // pForThisObject is not yet set
 385                             if(!pForThisObject && pAnchor)
 386                             {
 387                                 pForThisObject = pAnchor;
 388                             }
 389
 390                             // De-register at old and register at new Style
 391                             if(GetStyleSheet() != pForThisObject)
 392                             {
 393                                 ImpRemoveStyleSheet();
 394                                 ImpAddStyleSheet((SfxStyleSheet*)pForThisObject, sal_True);
 395                             }
 396                         }
 397                         else
 398                         {
 399                             // there is no StyleSheetPool in the new model, thus set
 400                             // all items as hard items in the object
 401                             List aList;
 402                             const SfxItemSet* pItemSet = &pOldStyleSheet->GetItemSet();
 403
 404                             while(pItemSet)
 405                             {
 406                                 aList.Insert((void*)pItemSet, CONTAINER_APPEND);
 407                                 pItemSet = pItemSet->GetParent();
 408                             }
 409
 410                             SfxItemSet* pNewSet = &CreateObjectSpecificItemSet(pNewModel->GetItemPool());
 411                             pItemSet = (SfxItemSet*)aList.Last();
 412
 413                             while(pItemSet)
 414                             {
 415                                 pNewSet->Put(*pItemSet);
 416                                 pItemSet = (SfxItemSet*)aList.Prev();
 417                             }
 418
 419                             // Items which were hard attributes before need to stay
 420                             if(mpItemSet)
 421                             {
 422                                 SfxWhichIter aIter(*mpItemSet);
 423                                 sal_uInt16 nWhich = aIter.FirstWhich();
 424
 425                                 while(nWhich)
 426                                 {
 427                                     if(mpItemSet->GetItemState(nWhich, FALSE) == SFX_ITEM_SET)
 428                                     {
 429                                         pNewSet->Put(mpItemSet->Get(nWhich));
 430                                     }
 431
 432                                     nWhich = aIter.NextWhich();
 433                                 }
 434                             }
 435
 436                             if(bScaleUnitChanged)
 437                             {
 438                                 ScaleItemSet(*pNewSet, aMetricFactor);
 439                             }
 440
 441                             if(mpItemSet)
 442                             {
 443                                 if(GetStyleSheet())
 444                                 {
 445                                     ImpRemoveStyleSheet();
 446                                 }
 447
 448                                 delete mpItemSet;
 449                                 mpItemSet = 0L;
 450                             }
 451
 452                             mpItemSet = pNewSet;
 453                         }
 454                     }
 455                 }
 456
 457                 // each object gets the default Style if there is none set yet.
 458                 if(mpItemSet && !GetStyleSheet() && pNewModel && !pNewModel->IsLoading())
 459                 {
 460                     SetStyleSheet(pNewModel->GetDefaultStyleSheet(), sal_True);
 461                 }
 462             }
 463         }
 464
 465         void AttributeProperties::ForceStyleToHardAttributes()
 466         {
 467             if(GetStyleSheet() && HAS_BASE(SfxStyleSheet, mpStyleSheet))
 468             {
 469                 // prepare copied, new itemset, but WITHOUT parent
 470                 GetObjectItemSet();
 471                 SfxItemSet* pDestItemSet = new SfxItemSet(*mpItemSet);
 472                 pDestItemSet->SetParent(0L);
 473
 474                 // pepare forgetting the current stylesheet like in RemoveStyleSheet()
 475                 EndListening(*mpStyleSheet);
 476                 EndListening(mpStyleSheet->GetPool());
 477
 478                 // prepare the iter; use the mpObjectItemSet which may have less
 479                 // WhichIDs than the style.
 480                 SfxWhichIter aIter(*pDestItemSet);
 481                 sal_uInt16 nWhich(aIter.FirstWhich());
 482                 const SfxPoolItem *pItem = NULL;
 483
 484                 // now set all hard attributes of the current at the new itemset
 485                 while(nWhich)
 486                 {
 487                     // #i61284# use mpItemSet with parents, makes things easier and reduces to
 488                     // one loop
 489                     if(SFX_ITEM_SET == mpItemSet->GetItemState(nWhich, true, &pItem))
 490                     {
 491                         pDestItemSet->Put(*pItem);
 492                     }
 493
 494                     nWhich = aIter.NextWhich();
 495                 }
 496
 497                 // replace itemsets
 498                 delete mpItemSet;
 499                 mpItemSet = pDestItemSet;
 500
 501                 // set necessary changes like in RemoveStyleSheet()
 502                 GetSdrObject().SetBoundRectDirty();
 503                 GetSdrObject().SetRectsDirty(sal_True);
 504
 505                 mpStyleSheet = NULL;
 506             }
 507         }
 508
 509         void AttributeProperties::Notify(SfxBroadcaster& rBC, const SfxHint& rHint)
 510         {
 511             sal_Bool bHintUsed(sal_False);
 512
 513             SfxStyleSheetHint *pStyleHint = PTR_CAST(SfxStyleSheetHint, &rHint);
 514
 515             if(pStyleHint && pStyleHint->GetStyleSheet() == GetStyleSheet())
 516             {
 517                 SdrObject& rObj = GetSdrObject();
 518                 //SdrPage* pPage = rObj.GetPage();
 519
 520                 switch(pStyleHint->GetHint())
 521                 {
 522                     case SFX_STYLESHEET_CREATED                 :
 523                     {
 524                         // cannot happen, nothing to do
 525                         break;
 526                     }
 527                     case SFX_STYLESHEET_MODIFIED                :
 528                     case SFX_STYLESHEET_CHANGED                 :
 529                     {
 530                         // notify change
 531                         break;
 532                     }
 533                     case SFX_STYLESHEET_ERASED                  :
 534                     case SFX_STYLESHEET_INDESTRUCTION   :
 535                     {
 536                         // Style needs to be exchanged
 537                         SfxStyleSheet* pNewStSh = 0L;
 538                         SdrModel* pModel = rObj.GetModel();
 539
 540                         // #111111#
 541                         // Do nothing if object is in destruction, else a StyleSheet may be found from
 542                         // a StyleSheetPool which is just being deleted itself. and thus it would be fatal
 543                         // to register as listener to that new StyleSheet.
 544                         if(pModel && !rObj.IsInDestruction())
 545                         {
 546                             if(HAS_BASE(SfxStyleSheet, GetStyleSheet()))
 547                             {
 548                                 pNewStSh = (SfxStyleSheet*)pModel->GetStyleSheetPool()->Find(
 549                                     GetStyleSheet()->GetParent(), GetStyleSheet()->GetFamily());
 550                             }
 551
 552                             if(!pNewStSh)
 553                             {
 554                                 pNewStSh = pModel->GetDefaultStyleSheet();
 555                             }
 556                         }
 557
 558                         // remove used style, it's erased or in destruction
 559                         ImpRemoveStyleSheet();
 560
 561                         if(pNewStSh)
 562                         {
 563                             ImpAddStyleSheet(pNewStSh, sal_True);
 564                         }
 565
 566                         break;
 567                     }
 568                 }
 569
 570                 // Get old BoundRect. Do this after the style change is handled
 571                 // in the ItemSet parts because GetBoundRect() may calculate a new
 572                 Rectangle aBoundRect = rObj.GetLastBoundRect();
 573
 574                 rObj.SetRectsDirty(sal_True);
 575
 576                 // tell the object about the change
 577                 rObj.SetChanged();
 578                 rObj.BroadcastObjectChange();
 579
 580                 //if(pPage && pPage->IsInserted())
 581                 //{
 582                 //      rObj.BroadcastObjectChange();
 583                 //}
 584
 585                 rObj.SendUserCall(SDRUSERCALL_CHGATTR, aBoundRect);
 586
 587                 bHintUsed = sal_True;
 588             }
 589
 590             // #111111#
 591             // When it's the BackgroundObject, set the MasterPage to changed to
 592             // get a refresh for the evtl. changed BackgroundStyle
 593
 594             // #114265#
 595             // To only invalidate the page when the StyleSheet change happens,
 596             // some more rigid testing is necessary.
 597             const SfxSimpleHint *pSimpleHint = PTR_CAST(SfxSimpleHint, &rHint);
 598
 599             if(pSimpleHint
 600                 && pSimpleHint->GetId() == SFX_HINT_DATACHANGED
 601                 && GetSdrObject().IsMasterPageBackgroundObject())
 602             {
 603                 GetSdrObject().GetPage()->ActionChanged();
 604             }
 605
 606             if(!bHintUsed)
 607             {
 608                 // forward to SdrObject ATM. Not sure if this will be necessary
 609                 // in the future.
 610                 GetSdrObject().Notify(rBC, rHint);
 611             }
 612         }
 613     } // end of namespace properties
 614 } // end of namespace sdr
 615
 616 //////////////////////////////////////////////////////////////////////////////
 617 // eof