svx/source/svdraw/svdlayer.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: svdlayer.cxx,v $
  10  * $Revision: 1.16 $
  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 <com/sun/star/uno/Sequence.hxx>
  34
  35 #include <svx/svdlayer.hxx>
  36 #include <svx/svdmodel.hxx> // fuer Broadcasting
  37 #include "svdglob.hxx"  // StringCache
  38 #include "svdstr.hrc"   // Namen aus der Resource
  39
  40 ////////////////////////////////////////////////////////////////////////////////////////////////////
  41 // SetOfByte
  42 ////////////////////////////////////////////////////////////////////////////////////////////////////
  43
  44 sal_Bool SetOfByte::IsEmpty() const
  45 {
  46     for(sal_uInt16 i(0); i < 32; i++)
  47     {
  48         if(aData[i] != 0)
  49             return sal_False;
  50     }
  51
  52     return sal_True;
  53 }
  54
  55 sal_Bool SetOfByte::IsFull() const
  56 {
  57     for(sal_uInt16 i(0); i < 32; i++)
  58     {
  59         if(aData[i] != 0xFF)
  60             return sal_False;
  61     }
  62
  63     return sal_True;
  64 }
  65
  66 sal_uInt16 SetOfByte::GetSetCount() const
  67 {
  68     sal_uInt16 nRet(0);
  69
  70     for(sal_uInt16 i(0); i < 32; i++)
  71     {
  72         sal_uInt8 a(aData[i]);
  73
  74         if(a != 0)
  75         {
  76             if(a & 0x80) nRet++;
  77             if(a & 0x40) nRet++;
  78             if(a & 0x20) nRet++;
  79             if(a & 0x10) nRet++;
  80             if(a & 0x08) nRet++;
  81             if(a & 0x04) nRet++;
  82             if(a & 0x02) nRet++;
  83             if(a & 0x01) nRet++;
  84         }
  85     }
  86
  87     return nRet;
  88 }
  89
  90 sal_uInt8 SetOfByte::GetSetBit(sal_uInt16 nNum) const
  91 {
  92     nNum++;
  93     sal_uInt16 i(0), j(0);
  94     sal_uInt16 nRet(0);
  95
  96     while(j < nNum && i < 256)
  97     {
  98         if(IsSet(sal_uInt8(i)))
  99             j++;
 100         i++;
 101     }
 102
 103     if(j == nNum)
 104         nRet = i - 1;
 105
 106     return sal_uInt8(nRet);
 107 }
 108
 109 sal_uInt16 SetOfByte::GetClearCount() const
 110 {
 111     return sal_uInt16(256 - GetSetCount());
 112 }
 113
 114 sal_uInt8 SetOfByte::GetClearBit(sal_uInt16 nNum) const
 115 {
 116     nNum++;
 117     sal_uInt16 i(0), j(0);
 118     sal_uInt16 nRet(0);
 119
 120     while(j < nNum && i < 256)
 121     {
 122         if(!IsSet(sal_uInt8(i)))
 123             j++;
 124         i++;
 125     }
 126
 127     if(j == nNum)
 128         nRet = i - 1;
 129
 130     return sal_uInt8(nRet);
 131 }
 132
 133 void SetOfByte::operator&=(const SetOfByte& r2ndSet)
 134 {
 135     for(sal_uInt16 i(0); i < 32; i++)
 136     {
 137         aData[i] &= r2ndSet.aData[i];
 138     }
 139 }
 140
 141 void SetOfByte::operator|=(const SetOfByte& r2ndSet)
 142 {
 143     for(sal_uInt16 i(0); i < 32; i++)
 144     {
 145         aData[i] |= r2ndSet.aData[i];
 146     }
 147 }
 148
 149 /** initialize this set with a uno sequence of sal_Int8
 150 */
 151 void SetOfByte::PutValue( const com::sun::star::uno::Any & rAny )
 152 {
 153     com::sun::star::uno::Sequence< sal_Int8 > aSeq;
 154     if( rAny >>= aSeq )
 155     {
 156         sal_Int16 nCount = (sal_Int16)aSeq.getLength();
 157         if( nCount > 32 )
 158             nCount = 32;
 159
 160         sal_Int16 nIndex;
 161         for( nIndex = 0; nIndex < nCount; nIndex++ )
 162         {
 163             aData[nIndex] = static_cast<BYTE>(aSeq[nIndex]);
 164         }
 165
 166         for( ; nIndex < 32; nIndex++ )
 167         {
 168             aData[nIndex] = 0;
 169         }
 170     }
 171 }
 172
 173 /** returns a uno sequence of sal_Int8
 174 */
 175 void SetOfByte::QueryValue( com::sun::star::uno::Any & rAny ) const
 176 {
 177     sal_Int16 nNumBytesSet = 0;
 178     sal_Int16 nIndex;
 179     for( nIndex = 31; nIndex >= 00; nIndex-- )
 180     {
 181         if( 0 != aData[nIndex] )
 182         {
 183             nNumBytesSet = nIndex + 1;
 184             break;
 185         }
 186     }
 187
 188     com::sun::star::uno::Sequence< sal_Int8 > aSeq( nNumBytesSet );
 189
 190     for( nIndex = 0; nIndex < nNumBytesSet; nIndex++ )
 191     {
 192         aSeq[nIndex] = static_cast<sal_Int8>(aData[nIndex]);
 193     }
 194
 195     rAny <<= aSeq;
 196 }
 197
 198 ////////////////////////////////////////////////////////////////////////////////////////////////////
 199 // SdrLayer
 200 ////////////////////////////////////////////////////////////////////////////////////////////////////
 201
 202 void SdrLayer::SetStandardLayer(FASTBOOL bStd)
 203 {
 204     nType=(UINT16)bStd;
 205     if (bStd) {
 206         aName=ImpGetResStr(STR_StandardLayerName);
 207     }
 208     if (pModel!=NULL) {
 209         SdrHint aHint(HINT_LAYERCHG);
 210         pModel->Broadcast(aHint);
 211         pModel->SetChanged();
 212     }
 213 }
 214
 215 void SdrLayer::SetName(const XubString& rNewName)
 216 {
 217     if(!rNewName.Equals(aName))
 218     {
 219         aName = rNewName;
 220         nType = 0; // Userdefined
 221
 222         if(pModel)
 223         {
 224             SdrHint aHint(HINT_LAYERCHG);
 225
 226             pModel->Broadcast(aHint);
 227             pModel->SetChanged();
 228         }
 229     }
 230 }
 231
 232 bool SdrLayer::operator==(const SdrLayer& rCmpLayer) const
 233 {
 234     return (nID == rCmpLayer.nID
 235         && nType == rCmpLayer.nType
 236         && aName.Equals(rCmpLayer.aName));
 237 }
 238
 239 ////////////////////////////////////////////////////////////////////////////////////////////////////
 240 // SdrLayerAdmin
 241 ////////////////////////////////////////////////////////////////////////////////////////////////////
 242
 243 SdrLayerAdmin::SdrLayerAdmin(SdrLayerAdmin* pNewParent):
 244     aLayer(1024,16,16),
 245     aLSets(1024,16,16),
 246     pModel(NULL)
 247 {
 248     sal_Char aTextControls[] = "Controls";
 249     aControlLayerName = String(aTextControls, sizeof(aTextControls-1));
 250     pParent=pNewParent;
 251 }
 252
 253 SdrLayerAdmin::SdrLayerAdmin(const SdrLayerAdmin& rSrcLayerAdmin):
 254     aLayer(1024,16,16),
 255     aLSets(1024,16,16),
 256     pParent(NULL),
 257     pModel(NULL)
 258 {
 259     sal_Char aTextControls[] = "Controls";
 260     aControlLayerName = String(aTextControls, sizeof(aTextControls-1));
 261     *this = rSrcLayerAdmin;
 262 }
 263
 264 SdrLayerAdmin::~SdrLayerAdmin()
 265 {
 266     ClearLayer();
 267 }
 268
 269 void SdrLayerAdmin::ClearLayer()
 270 {
 271     SdrLayer* pL;
 272     pL=(SdrLayer*)aLayer.First();
 273     while (pL!=NULL) {
 274         delete pL;
 275         pL=(SdrLayer*)aLayer.Next();
 276     }
 277     aLayer.Clear();
 278 }
 279
 280 const SdrLayerAdmin& SdrLayerAdmin::operator=(const SdrLayerAdmin& rSrcLayerAdmin)
 281 {
 282     ClearLayer();
 283     pParent=rSrcLayerAdmin.pParent;
 284     USHORT i;
 285     USHORT nAnz=rSrcLayerAdmin.GetLayerCount();
 286     for (i=0; i<nAnz; i++) {
 287         aLayer.Insert(new SdrLayer(*rSrcLayerAdmin.GetLayer(i)),CONTAINER_APPEND);
 288     }
 289     return *this;
 290 }
 291
 292 bool SdrLayerAdmin::operator==(const SdrLayerAdmin& rCmpLayerAdmin) const
 293 {
 294     if (pParent!=rCmpLayerAdmin.pParent ||
 295         aLayer.Count()!=rCmpLayerAdmin.aLayer.Count() ||
 296         aLSets.Count()!=rCmpLayerAdmin.aLSets.Count()) return FALSE;
 297     FASTBOOL bOk=TRUE;
 298     USHORT nAnz=GetLayerCount();
 299     USHORT i=0;
 300     while (bOk && i<nAnz) {
 301         bOk=*GetLayer(i)==*rCmpLayerAdmin.GetLayer(i);
 302         i++;
 303     }
 304     return bOk;
 305 }
 306
 307 void SdrLayerAdmin::SetModel(SdrModel* pNewModel)
 308 {
 309     if (pNewModel!=pModel) {
 310         pModel=pNewModel;
 311         USHORT nAnz=GetLayerCount();
 312         USHORT i;
 313         for (i=0; i<nAnz; i++) {
 314             GetLayer(i)->SetModel(pNewModel);
 315         }
 316     }
 317 }
 318
 319 void SdrLayerAdmin::Broadcast() const
 320 {
 321     if (pModel!=NULL) {
 322         SdrHint aHint(HINT_LAYERORDERCHG);
 323         pModel->Broadcast(aHint);
 324         pModel->SetChanged();
 325     }
 326 }
 327
 328 SdrLayer* SdrLayerAdmin::RemoveLayer(USHORT nPos)
 329 {
 330     SdrLayer* pRetLayer=(SdrLayer*)(aLayer.Remove(nPos));
 331     Broadcast();
 332     return pRetLayer;
 333 }
 334
 335 SdrLayer* SdrLayerAdmin::NewLayer(const XubString& rName, USHORT nPos)
 336 {
 337     SdrLayerID nID=GetUniqueLayerID();
 338     SdrLayer* pLay=new SdrLayer(nID,rName);
 339     pLay->SetModel(pModel);
 340     aLayer.Insert(pLay,nPos);
 341     Broadcast();
 342     return pLay;
 343 }
 344
 345 SdrLayer* SdrLayerAdmin::NewStandardLayer(USHORT nPos)
 346 {
 347     SdrLayerID nID=GetUniqueLayerID();
 348     SdrLayer* pLay=new SdrLayer(nID,String());
 349     pLay->SetStandardLayer();
 350     pLay->SetModel(pModel);
 351     aLayer.Insert(pLay,nPos);
 352     Broadcast();
 353     return pLay;
 354 }
 355
 356 SdrLayer* SdrLayerAdmin::MoveLayer(USHORT nPos, USHORT nNewPos)
 357 {
 358     SdrLayer* pLayer=(SdrLayer*)(aLayer.Remove(nPos));
 359     if (pLayer!=NULL) {
 360         aLayer.Insert(pLayer,nNewPos);
 361     }
 362
 363     Broadcast();
 364     return pLayer;
 365 }
 366
 367 void SdrLayerAdmin::MoveLayer(SdrLayer* pLayer, USHORT nNewPos)
 368 {
 369     ULONG nPos=aLayer.GetPos(pLayer);
 370     if (nPos!=CONTAINER_ENTRY_NOTFOUND) {
 371         aLayer.Remove(nPos);
 372         aLayer.Insert(pLayer,nNewPos);
 373         Broadcast();
 374     }
 375 }
 376
 377 USHORT SdrLayerAdmin::GetLayerPos(SdrLayer* pLayer) const
 378 {
 379     ULONG nRet=SDRLAYER_NOTFOUND;
 380     if (pLayer!=NULL) {
 381         nRet=aLayer.GetPos(pLayer);
 382         if (nRet==CONTAINER_ENTRY_NOTFOUND) {
 383             nRet=SDRLAYER_NOTFOUND;
 384         }
 385     }
 386     return USHORT(nRet);
 387 }
 388
 389 const SdrLayer* SdrLayerAdmin::GetLayer(const XubString& rName, FASTBOOL /*bInherited*/) const
 390 {
 391     UINT16 i(0);
 392     const SdrLayer* pLay = NULL;
 393
 394     while(i < GetLayerCount() && !pLay)
 395     {
 396         if(rName.Equals(GetLayer(i)->GetName()))
 397             pLay = GetLayer(i);
 398         else
 399             i++;
 400     }
 401
 402     if(!pLay && pParent)
 403     {
 404         pLay = pParent->GetLayer(rName, TRUE);
 405     }
 406
 407     return pLay;
 408 }
 409
 410 SdrLayerID SdrLayerAdmin::GetLayerID(const XubString& rName, FASTBOOL bInherited) const
 411 {
 412     SdrLayerID nRet=SDRLAYER_NOTFOUND;
 413     const SdrLayer* pLay=GetLayer(rName,bInherited);
 414     if (pLay!=NULL) nRet=pLay->GetID();
 415     return nRet;
 416 }
 417
 418 const SdrLayer* SdrLayerAdmin::GetLayerPerID(USHORT nID) const
 419 {
 420     USHORT i=0;
 421     const SdrLayer* pLay=NULL;
 422     while (i<GetLayerCount() && pLay==NULL) {
 423         if (nID==GetLayer(i)->GetID()) pLay=GetLayer(i);
 424         else i++;
 425     }
 426     return pLay;
 427 }
 428
 429 // Globale LayerID's beginnen mit 0 aufsteigend.
 430 // Lokale LayerID's beginnen mit 254 absteigend.
 431 // 255 ist reserviert fuer SDRLAYER_NOTFOUND
 432
 433 SdrLayerID SdrLayerAdmin::GetUniqueLayerID() const
 434 {
 435     SetOfByte aSet;
 436     sal_Bool bDown = (pParent == NULL);
 437     USHORT j;
 438     for (j=0; j<GetLayerCount(); j++)
 439     {
 440         aSet.Set(GetLayer((sal_uInt16)j)->GetID());
 441     }
 442     SdrLayerID i;
 443     if (!bDown)
 444     {
 445         i=254;
 446         while (i && aSet.IsSet(BYTE(i)))
 447             --i;
 448         if (i == 0)
 449             i=254;
 450     }
 451     else
 452     {
 453         i=0;
 454         while (i<=254 && aSet.IsSet(BYTE(i)))
 455             i++;
 456         if (i>254)
 457             i=0;
 458     }
 459     return i;
 460 }
 461