svx/source/sdr/properties/groupproperties.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: groupproperties.cxx,v $
  10  * $Revision: 1.12 $
  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/groupproperties.hxx>
  34 #include <svtools/itemset.hxx>
  35 #include <svtools/whiter.hxx>
  36 #include <svx/svddef.hxx>
  37 #include <svx/eeitem.hxx>
  38 #include <svx/svdogrp.hxx>
  39 #include <svx/svdpool.hxx>
  40 #include <svx/svdpage.hxx>
  41
  42 //////////////////////////////////////////////////////////////////////////////
  43
  44 namespace sdr
  45 {
  46     namespace properties
  47     {
  48         // create a new itemset
  49         SfxItemSet& GroupProperties::CreateObjectSpecificItemSet(SfxItemPool& rPool)
  50         {
  51             // Groups have in principle no ItemSet. To support methods like
  52             // GetMergedItemSet() the local one is used. Thus, all items in the pool
  53             // may be used and a pool itemset is created.
  54             return *(new SfxItemSet(rPool));
  55         }
  56
  57         GroupProperties::GroupProperties(SdrObject& rObj)
  58         :       DefaultProperties(rObj)
  59         {
  60         }
  61
  62         GroupProperties::GroupProperties(const GroupProperties& rProps, SdrObject& rObj)
  63         :       DefaultProperties(rProps, rObj)
  64         {
  65         }
  66
  67         GroupProperties::~GroupProperties()
  68         {
  69         }
  70
  71         BaseProperties& GroupProperties::Clone(SdrObject& rObj) const
  72         {
  73             return *(new GroupProperties(*this, rObj));
  74         }
  75
  76         const SfxItemSet& GroupProperties::GetObjectItemSet() const
  77         {
  78             DBG_ASSERT(sal_False, "GroupProperties::GetObjectItemSet() should never be called (!)");
  79             return DefaultProperties::GetObjectItemSet();
  80         }
  81
  82         const SfxItemSet& GroupProperties::GetMergedItemSet() const
  83         {
  84             // prepare ItemSet
  85             if(mpItemSet)
  86             {
  87                 // clear local itemset for merge
  88                 mpItemSet->ClearItem();
  89             }
  90             else
  91             {
  92                 // force local itemset
  93                 DefaultProperties::GetObjectItemSet();
  94             }
  95
  96             // collect all ItemSets in mpItemSet
  97             const SdrObjList* pSub = ((const SdrObjGroup&)GetSdrObject()).GetSubList();
  98             const sal_uInt32 nCount(pSub->GetObjCount());
  99
 100             for(sal_uInt32 a(0L); a < nCount; a++)
 101             {
 102                 const SfxItemSet& rSet = pSub->GetObj(a)->GetMergedItemSet();
 103                 SfxWhichIter aIter(rSet);
 104                 sal_uInt16 nWhich(aIter.FirstWhich());
 105
 106                 while(nWhich)
 107                 {
 108                     if(SFX_ITEM_DONTCARE == rSet.GetItemState(nWhich, FALSE))
 109                     {
 110                         mpItemSet->InvalidateItem(nWhich);
 111                     }
 112                     else
 113                     {
 114                         mpItemSet->MergeValue(rSet.Get(nWhich), TRUE);
 115                     }
 116
 117                     nWhich = aIter.NextWhich();
 118                 }
 119             }
 120
 121             // For group proerties, do not call parent since groups do
 122             // not have local ItemSets.
 123             return *mpItemSet;
 124         }
 125
 126         void GroupProperties::SetMergedItemSet(const SfxItemSet& rSet, sal_Bool bClearAllItems)
 127         {
 128             // iterate over contained SdrObjects
 129             const SdrObjList* pSub = ((const SdrObjGroup&)GetSdrObject()).GetSubList();
 130             const sal_uInt32 nCount(pSub->GetObjCount());
 131
 132             for(sal_uInt32 a(0L); a < nCount; a++)
 133             {
 134                 SdrObject* pObj = pSub->GetObj(a);
 135
 136                 if(pObj)
 137                 {
 138                     // Set merged ItemSet at contained object
 139                     pObj->SetMergedItemSet(rSet, bClearAllItems);
 140                 }
 141             }
 142
 143             // Do not call parent here. Group objects do not have local ItemSets
 144             // where items need to be set.
 145             // DefaultProperties::SetMergedItemSet(rSet, bClearAllItems);
 146         }
 147
 148         void GroupProperties::SetObjectItem(const SfxPoolItem& /*rItem*/)
 149         {
 150             DBG_ASSERT(sal_False, "GroupProperties::SetObjectItem() should never be called (!)");
 151         }
 152
 153         void GroupProperties::SetObjectItemDirect(const SfxPoolItem& /*rItem*/)
 154         {
 155             DBG_ASSERT(sal_False, "GroupProperties::SetObjectItemDirect() should never be called (!)");
 156         }
 157
 158         void GroupProperties::ClearObjectItem(const sal_uInt16 /*nWhich*/)
 159         {
 160             DBG_ASSERT(sal_False, "GroupProperties::ClearObjectItem() should never be called (!)");
 161         }
 162
 163         void GroupProperties::ClearObjectItemDirect(const sal_uInt16 /*nWhich*/)
 164         {
 165             DBG_ASSERT(sal_False, "GroupProperties::ClearObjectItemDirect() should never be called (!)");
 166         }
 167
 168         void GroupProperties::SetMergedItem(const SfxPoolItem& rItem)
 169         {
 170             const SdrObjList* pSub = ((const SdrObjGroup&)GetSdrObject()).GetSubList();
 171             const sal_uInt32 nCount(pSub->GetObjCount());
 172
 173             for(sal_uInt32 a(0L); a < nCount; a++)
 174             {
 175                 pSub->GetObj(a)->GetProperties().SetMergedItem(rItem);
 176             }
 177         }
 178
 179         void GroupProperties::ClearMergedItem(const sal_uInt16 nWhich)
 180         {
 181             const SdrObjList* pSub = ((const SdrObjGroup&)GetSdrObject()).GetSubList();
 182             const sal_uInt32 nCount(pSub->GetObjCount());
 183
 184             for(sal_uInt32 a(0L); a < nCount; a++)
 185             {
 186                 pSub->GetObj(a)->GetProperties().ClearMergedItem(nWhich);
 187             }
 188         }
 189
 190         void GroupProperties::SetObjectItemSet(const SfxItemSet& /*rSet*/)
 191         {
 192             DBG_ASSERT(sal_False, "GroupProperties::SetObjectItemSet() should never be called (!)");
 193         }
 194
 195         void GroupProperties::ItemSetChanged(const SfxItemSet& /*rSet*/)
 196         {
 197             DBG_ASSERT(sal_False, "GroupProperties::ItemSetChanged() should never be called (!)");
 198         }
 199
 200         sal_Bool GroupProperties::AllowItemChange(const sal_uInt16 /*nWhich*/, const SfxPoolItem* /*pNewItem*/) const
 201         {
 202             DBG_ASSERT(sal_False, "GroupProperties::AllowItemChange() should never be called (!)");
 203             return sal_False;
 204         }
 205
 206         void GroupProperties::ItemChange(const sal_uInt16 /*nWhich*/, const SfxPoolItem* /*pNewItem*/)
 207         {
 208             DBG_ASSERT(sal_False, "GroupProperties::ItemChange() should never be called (!)");
 209         }
 210
 211         void GroupProperties::PostItemChange(const sal_uInt16 /*nWhich*/)
 212         {
 213             DBG_ASSERT(sal_False, "GroupProperties::PostItemChange() should never be called (!)");
 214         }
 215
 216         SfxStyleSheet* GroupProperties::GetStyleSheet() const
 217         {
 218             SfxStyleSheet* pRetval = 0L;
 219
 220             const SdrObjList* pSub = ((const SdrObjGroup&)GetSdrObject()).GetSubList();
 221             const sal_uInt32 nCount(pSub->GetObjCount());
 222
 223             for(sal_uInt32 a(0L); a < nCount; a++)
 224             {
 225                 SfxStyleSheet* pCandidate = pSub->GetObj(a)->GetStyleSheet();
 226
 227                 if(pRetval)
 228                 {
 229                     if(pCandidate != pRetval)
 230                     {
 231                         // different StyleSheelts, return none
 232                         return 0L;
 233                     }
 234                 }
 235                 else
 236                 {
 237                     pRetval = pCandidate;
 238                 }
 239             }
 240
 241             return pRetval;
 242         }
 243
 244         void GroupProperties::SetStyleSheet(SfxStyleSheet* pNewStyleSheet, sal_Bool bDontRemoveHardAttr)
 245         {
 246             const SdrObjList* pSub = ((const SdrObjGroup&)GetSdrObject()).GetSubList();
 247             const sal_uInt32 nCount(pSub->GetObjCount());
 248
 249             for(sal_uInt32 a(0L); a < nCount; a++)
 250             {
 251                 pSub->GetObj(a)->SetStyleSheet(pNewStyleSheet, bDontRemoveHardAttr);
 252             }
 253         }
 254
 255         void GroupProperties::ForceDefaultAttributes()
 256         {
 257             // nothing to do here, groups have no items and thus no default items, too.
 258         }
 259
 260         void GroupProperties::MoveToItemPool(SfxItemPool* pSrcPool, SfxItemPool* pDestPool, SdrModel* pNewModel)
 261         {
 262             if(pSrcPool && pDestPool && (pSrcPool != pDestPool))
 263             {
 264                 const SdrObjList* pSub = ((const SdrObjGroup&)GetSdrObject()).GetSubList();
 265                 const sal_uInt32 nCount(pSub->GetObjCount());
 266
 267                 for(sal_uInt32 a(0L); a < nCount; a++)
 268                 {
 269                     pSub->GetObj(a)->GetProperties().MoveToItemPool(pSrcPool, pDestPool, pNewModel);
 270                 }
 271
 272                 // also clear local ItemSet, it's only temporary for group objects anyways.
 273                 if(mpItemSet)
 274                 {
 275                     // #121905#
 276                     // copy/paste is still using clone operators and MoveToItemPool functionality.
 277                     // Since SfxItemSet contains a pool pointer, ClearItem is not enough here.
 278                     // The ItemSet for merge is constructed on demand, so it's enough here to
 279                     // just delete it and set to 0L.
 280                     // mpItemSet->ClearItem();
 281                     delete mpItemSet;
 282                     mpItemSet = 0L;
 283                 }
 284             }
 285         }
 286
 287         void GroupProperties::ForceStyleToHardAttributes()
 288         {
 289             const SdrObjList* pSub = ((const SdrObjGroup&)GetSdrObject()).GetSubList();
 290             const sal_uInt32 nCount(pSub->GetObjCount());
 291
 292             for(sal_uInt32 a(0L); a < nCount; a++)
 293             {
 294                 pSub->GetObj(a)->GetProperties().ForceStyleToHardAttributes();
 295             }
 296         }
 297     } // end of namespace properties
 298 } // end of namespace sdr
 299
 300 //////////////////////////////////////////////////////////////////////////////
 301 // eof