svx/source/svdraw/svdlayer.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * Copyright 2000, 2010 Oracle and/or its affiliates.
   7  *
   8  * OpenOffice.org - a multi-platform office productivity suite
   9  *
  10  * This file is part of OpenOffice.org.
  11  *
  12  * OpenOffice.org is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU Lesser General Public License version 3
  14  * only, as published by the Free Software Foundation.
  15  *
  16  * OpenOffice.org is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU Lesser General Public License version 3 for more details
  20  * (a copy is included in the LICENSE file that accompanied this code).
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * version 3 along with OpenOffice.org.  If not, see
  24  * <http://www.openoffice.org/license.html>
  25  * for a copy of the LGPLv3 License.
  26  *
  27  ************************************************************************/
  28
  29 #include <com/sun/star/uno/Sequence.hxx>
  30
  31 #include <svx/svdlayer.hxx>
  32 #include <svx/svdmodel.hxx> // for Broadcasting
  33 #include "svx/svdglob.hxx"  // StringCache
  34 #include "svx/svdstr.hrc"   // names taken from the resource
  35
  36 ////////////////////////////////////////////////////////////////////////////////////////////////////
  37 // SetOfByte
  38 ////////////////////////////////////////////////////////////////////////////////////////////////////
  39
  40 sal_Bool SetOfByte::IsEmpty() const
  41 {
  42     for(sal_uInt16 i(0); i < 32; i++)
  43     {
  44         if(aData[i] != 0)
  45             return sal_False;
  46     }
  47
  48     return sal_True;
  49 }
  50
  51 void SetOfByte::operator&=(const SetOfByte& r2ndSet)
  52 {
  53     for(sal_uInt16 i(0); i < 32; i++)
  54     {
  55         aData[i] &= r2ndSet.aData[i];
  56     }
  57 }
  58
  59 void SetOfByte::operator|=(const SetOfByte& r2ndSet)
  60 {
  61     for(sal_uInt16 i(0); i < 32; i++)
  62     {
  63         aData[i] |= r2ndSet.aData[i];
  64     }
  65 }
  66
  67 /** initialize this set with a uno sequence of sal_Int8
  68 */
  69 void SetOfByte::PutValue( const com::sun::star::uno::Any & rAny )
  70 {
  71     com::sun::star::uno::Sequence< sal_Int8 > aSeq;
  72     if( rAny >>= aSeq )
  73     {
  74         sal_Int16 nCount = (sal_Int16)aSeq.getLength();
  75         if( nCount > 32 )
  76             nCount = 32;
  77
  78         sal_Int16 nIndex;
  79         for( nIndex = 0; nIndex < nCount; nIndex++ )
  80         {
  81             aData[nIndex] = static_cast<sal_uInt8>(aSeq[nIndex]);
  82         }
  83
  84         for( ; nIndex < 32; nIndex++ )
  85         {
  86             aData[nIndex] = 0;
  87         }
  88     }
  89 }
  90
  91 /** returns a uno sequence of sal_Int8
  92 */
  93 void SetOfByte::QueryValue( com::sun::star::uno::Any & rAny ) const
  94 {
  95     sal_Int16 nNumBytesSet = 0;
  96     sal_Int16 nIndex;
  97     for( nIndex = 31; nIndex >= 00; nIndex-- )
  98     {
  99         if( 0 != aData[nIndex] )
 100         {
 101             nNumBytesSet = nIndex + 1;
 102             break;
 103         }
 104     }
 105
 106     com::sun::star::uno::Sequence< sal_Int8 > aSeq( nNumBytesSet );
 107
 108     for( nIndex = 0; nIndex < nNumBytesSet; nIndex++ )
 109     {
 110         aSeq[nIndex] = static_cast<sal_Int8>(aData[nIndex]);
 111     }
 112
 113     rAny <<= aSeq;
 114 }
 115
 116 ////////////////////////////////////////////////////////////////////////////////////////////////////
 117 // SdrLayer
 118 ////////////////////////////////////////////////////////////////////////////////////////////////////
 119
 120 void SdrLayer::SetStandardLayer(bool bStd)
 121 {
 122     nType=(sal_uInt16)bStd;
 123     if (bStd) {
 124         aName=ImpGetResStr(STR_StandardLayerName);
 125     }
 126     if (pModel!=NULL) {
 127         SdrHint aHint(HINT_LAYERCHG);
 128         pModel->Broadcast(aHint);
 129         pModel->SetChanged();
 130     }
 131 }
 132
 133 void SdrLayer::SetName(const XubString& rNewName)
 134 {
 135     if(!rNewName.Equals(aName))
 136     {
 137         aName = rNewName;
 138         nType = 0; // user defined
 139
 140         if(pModel)
 141         {
 142             SdrHint aHint(HINT_LAYERCHG);
 143
 144             pModel->Broadcast(aHint);
 145             pModel->SetChanged();
 146         }
 147     }
 148 }
 149
 150 bool SdrLayer::operator==(const SdrLayer& rCmpLayer) const
 151 {
 152     return (nID == rCmpLayer.nID
 153         && nType == rCmpLayer.nType
 154         && aName.Equals(rCmpLayer.aName));
 155 }
 156
 157 ////////////////////////////////////////////////////////////////////////////////////////////////////
 158 // SdrLayerAdmin
 159 ////////////////////////////////////////////////////////////////////////////////////////////////////
 160
 161 SdrLayerAdmin::SdrLayerAdmin(SdrLayerAdmin* pNewParent):
 162     aLayer(1024,16,16),
 163     aLSets(1024,16,16),
 164     pModel(NULL)
 165 {
 166     aControlLayerName = String(RTL_CONSTASCII_USTRINGPARAM("Controls"));
 167     pParent=pNewParent;
 168 }
 169
 170 SdrLayerAdmin::SdrLayerAdmin(const SdrLayerAdmin& rSrcLayerAdmin):
 171     aLayer(1024,16,16),
 172     aLSets(1024,16,16),
 173     pParent(NULL),
 174     pModel(NULL)
 175 {
 176     aControlLayerName = String(RTL_CONSTASCII_USTRINGPARAM("Controls"));
 177     *this = rSrcLayerAdmin;
 178 }
 179
 180 SdrLayerAdmin::~SdrLayerAdmin()
 181 {
 182     ClearLayer();
 183 }
 184
 185 void SdrLayerAdmin::ClearLayer()
 186 {
 187     SdrLayer* pL;
 188     pL=(SdrLayer*)aLayer.First();
 189     while (pL!=NULL) {
 190         delete pL;
 191         pL=(SdrLayer*)aLayer.Next();
 192     }
 193     aLayer.Clear();
 194 }
 195
 196 const SdrLayerAdmin& SdrLayerAdmin::operator=(const SdrLayerAdmin& rSrcLayerAdmin)
 197 {
 198     ClearLayer();
 199     pParent=rSrcLayerAdmin.pParent;
 200     sal_uInt16 i;
 201     sal_uInt16 nAnz=rSrcLayerAdmin.GetLayerCount();
 202     for (i=0; i<nAnz; i++) {
 203         aLayer.Insert(new SdrLayer(*rSrcLayerAdmin.GetLayer(i)),CONTAINER_APPEND);
 204     }
 205     return *this;
 206 }
 207
 208 bool SdrLayerAdmin::operator==(const SdrLayerAdmin& rCmpLayerAdmin) const
 209 {
 210     if (pParent!=rCmpLayerAdmin.pParent ||
 211         aLayer.Count()!=rCmpLayerAdmin.aLayer.Count() ||
 212         aLSets.Count()!=rCmpLayerAdmin.aLSets.Count()) return sal_False;
 213     bool bOk = true;
 214     sal_uInt16 nAnz=GetLayerCount();
 215     sal_uInt16 i=0;
 216     while (bOk && i<nAnz) {
 217         bOk=*GetLayer(i)==*rCmpLayerAdmin.GetLayer(i);
 218         i++;
 219     }
 220     return bOk;
 221 }
 222
 223 void SdrLayerAdmin::SetModel(SdrModel* pNewModel)
 224 {
 225     if (pNewModel!=pModel) {
 226         pModel=pNewModel;
 227         sal_uInt16 nAnz=GetLayerCount();
 228         sal_uInt16 i;
 229         for (i=0; i<nAnz; i++) {
 230             GetLayer(i)->SetModel(pNewModel);
 231         }
 232     }
 233 }
 234
 235 void SdrLayerAdmin::Broadcast() const
 236 {
 237     if (pModel!=NULL) {
 238         SdrHint aHint(HINT_LAYERORDERCHG);
 239         pModel->Broadcast(aHint);
 240         pModel->SetChanged();
 241     }
 242 }
 243
 244 SdrLayer* SdrLayerAdmin::RemoveLayer(sal_uInt16 nPos)
 245 {
 246     SdrLayer* pRetLayer=(SdrLayer*)(aLayer.Remove(nPos));
 247     Broadcast();
 248     return pRetLayer;
 249 }
 250
 251 SdrLayer* SdrLayerAdmin::NewLayer(const XubString& rName, sal_uInt16 nPos)
 252 {
 253     SdrLayerID nID=GetUniqueLayerID();
 254     SdrLayer* pLay=new SdrLayer(nID,rName);
 255     pLay->SetModel(pModel);
 256     aLayer.Insert(pLay,nPos);
 257     Broadcast();
 258     return pLay;
 259 }
 260
 261 SdrLayer* SdrLayerAdmin::NewStandardLayer(sal_uInt16 nPos)
 262 {
 263     SdrLayerID nID=GetUniqueLayerID();
 264     SdrLayer* pLay=new SdrLayer(nID,String());
 265     pLay->SetStandardLayer();
 266     pLay->SetModel(pModel);
 267     aLayer.Insert(pLay,nPos);
 268     Broadcast();
 269     return pLay;
 270 }
 271
 272 sal_uInt16 SdrLayerAdmin::GetLayerPos(SdrLayer* pLayer) const
 273 {
 274     sal_uIntPtr nRet=SDRLAYER_NOTFOUND;
 275     if (pLayer!=NULL) {
 276         nRet=aLayer.GetPos(pLayer);
 277         if (nRet==CONTAINER_ENTRY_NOTFOUND) {
 278             nRet=SDRLAYER_NOTFOUND;
 279         }
 280     }
 281     return sal_uInt16(nRet);
 282 }
 283
 284 const SdrLayer* SdrLayerAdmin::GetLayer(const XubString& rName, bool /*bInherited*/) const
 285 {
 286     sal_uInt16 i(0);
 287     const SdrLayer* pLay = NULL;
 288
 289     while(i < GetLayerCount() && !pLay)
 290     {
 291         if(rName.Equals(GetLayer(i)->GetName()))
 292             pLay = GetLayer(i);
 293         else
 294             i++;
 295     }
 296
 297     if(!pLay && pParent)
 298     {
 299         pLay = pParent->GetLayer(rName, sal_True);
 300     }
 301
 302     return pLay;
 303 }
 304
 305 SdrLayerID SdrLayerAdmin::GetLayerID(const XubString& rName, bool bInherited) const
 306 {
 307     SdrLayerID nRet=SDRLAYER_NOTFOUND;
 308     const SdrLayer* pLay=GetLayer(rName,bInherited);
 309     if (pLay!=NULL) nRet=pLay->GetID();
 310     return nRet;
 311 }
 312
 313 const SdrLayer* SdrLayerAdmin::GetLayerPerID(sal_uInt16 nID) const
 314 {
 315     sal_uInt16 i=0;
 316     const SdrLayer* pLay=NULL;
 317     while (i<GetLayerCount() && pLay==NULL) {
 318         if (nID==GetLayer(i)->GetID()) pLay=GetLayer(i);
 319         else i++;
 320     }
 321     return pLay;
 322 }
 323
 324 // Global LayerIDs begin at 0 and increase,
 325 // local LayerIDs begin at 254 and decrease;
 326 // 255 is reserved for SDRLAYER_NOTFOUND.
 327
 328 SdrLayerID SdrLayerAdmin::GetUniqueLayerID() const
 329 {
 330     SetOfByte aSet;
 331     sal_Bool bDown = (pParent == NULL);
 332     sal_uInt16 j;
 333     for (j=0; j<GetLayerCount(); j++)
 334     {
 335         aSet.Set(GetLayer((sal_uInt16)j)->GetID());
 336     }
 337     SdrLayerID i;
 338     if (!bDown)
 339     {
 340         i=254;
 341         while (i && aSet.IsSet(sal_uInt8(i)))
 342             --i;
 343         if (i == 0)
 344             i=254;
 345     }
 346     else
 347     {
 348         i=0;
 349         while (i<=254 && aSet.IsSet(sal_uInt8(i)))
 350             i++;
 351         if (i>254)
 352             i=0;
 353     }
 354     return i;
 355 }
 356
 357 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */