svx/source/svdraw/svdlayer.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 <com/sun/star/uno/Sequence.hxx>
  21
  22 #include <svx/svdlayer.hxx>
  23 #include <svx/svdmodel.hxx>
  24 #include "svdglob.hxx"
  25 #include "svx/svdstr.hrc"
  26
  27 bool SetOfByte::IsEmpty() const
  28 {
  29     for(sal_uInt16 i(0); i < 32; i++)
  30     {
  31         if(aData[i] != 0)
  32             return false;
  33     }
  34
  35     return true;
  36 }
  37
  38 void SetOfByte::operator&=(const SetOfByte& r2ndSet)
  39 {
  40     for(sal_uInt16 i(0); i < 32; i++)
  41     {
  42         aData[i] &= r2ndSet.aData[i];
  43     }
  44 }
  45
  46 void SetOfByte::operator|=(const SetOfByte& r2ndSet)
  47 {
  48     for(sal_uInt16 i(0); i < 32; i++)
  49     {
  50         aData[i] |= r2ndSet.aData[i];
  51     }
  52 }
  53
  54 /** initialize this set with a uno sequence of sal_Int8
  55 */
  56 void SetOfByte::PutValue( const com::sun::star::uno::Any & rAny )
  57 {
  58     com::sun::star::uno::Sequence< sal_Int8 > aSeq;
  59     if( rAny >>= aSeq )
  60     {
  61         sal_Int16 nCount = (sal_Int16)aSeq.getLength();
  62         if( nCount > 32 )
  63             nCount = 32;
  64
  65         sal_Int16 nIndex;
  66         for( nIndex = 0; nIndex < nCount; nIndex++ )
  67         {
  68             aData[nIndex] = static_cast<sal_uInt8>(aSeq[nIndex]);
  69         }
  70
  71         for( ; nIndex < 32; nIndex++ )
  72         {
  73             aData[nIndex] = 0;
  74         }
  75     }
  76 }
  77
  78 /** returns a uno sequence of sal_Int8
  79 */
  80 void SetOfByte::QueryValue( com::sun::star::uno::Any & rAny ) const
  81 {
  82     sal_Int16 nNumBytesSet = 0;
  83     sal_Int16 nIndex;
  84     for( nIndex = 31; nIndex >= 00; nIndex-- )
  85     {
  86         if( 0 != aData[nIndex] )
  87         {
  88             nNumBytesSet = nIndex + 1;
  89             break;
  90         }
  91     }
  92
  93     com::sun::star::uno::Sequence< sal_Int8 > aSeq( nNumBytesSet );
  94
  95     for( nIndex = 0; nIndex < nNumBytesSet; nIndex++ )
  96     {
  97         aSeq[nIndex] = static_cast<sal_Int8>(aData[nIndex]);
  98     }
  99
 100     rAny <<= aSeq;
 101 }
 102
 103 SdrLayer::SdrLayer(SdrLayerID nNewID, const OUString& rNewName) :
 104     maName(rNewName), pModel(NULL), nType(0), nID(nNewID)
 105 {
 106 }
 107
 108 void SdrLayer::SetStandardLayer(bool bStd)
 109 {
 110     nType=(sal_uInt16)bStd;
 111     if (bStd) {
 112         maName = ImpGetResStr(STR_StandardLayerName);
 113     }
 114     if (pModel!=NULL) {
 115         SdrHint aHint(HINT_LAYERCHG);
 116         pModel->Broadcast(aHint);
 117         pModel->SetChanged();
 118     }
 119 }
 120
 121 void SdrLayer::SetName(const OUString& rNewName)
 122 {
 123     if (rNewName == maName)
 124         return;
 125
 126     maName = rNewName;
 127     nType = 0; // user defined
 128
 129     if (pModel)
 130     {
 131         SdrHint aHint(HINT_LAYERCHG);
 132         pModel->Broadcast(aHint);
 133         pModel->SetChanged();
 134     }
 135 }
 136
 137 bool SdrLayer::operator==(const SdrLayer& rCmpLayer) const
 138 {
 139     return (nID == rCmpLayer.nID
 140         && nType == rCmpLayer.nType
 141         && maName == rCmpLayer.maName);
 142 }
 143
 144 SdrLayerAdmin::SdrLayerAdmin(SdrLayerAdmin* pNewParent):
 145     aLayer(),
 146     pParent(pNewParent),
 147     pModel(NULL),
 148     maControlLayerName("Controls")
 149 {
 150 }
 151
 152 SdrLayerAdmin::SdrLayerAdmin(const SdrLayerAdmin& rSrcLayerAdmin):
 153     aLayer(),
 154     pParent(NULL),
 155     pModel(NULL),
 156     maControlLayerName("Controls")
 157 {
 158     *this = rSrcLayerAdmin;
 159 }
 160
 161 SdrLayerAdmin::~SdrLayerAdmin()
 162 {
 163     ClearLayer();
 164 }
 165
 166 void SdrLayerAdmin::ClearLayer()
 167 {
 168     for( std::vector<SdrLayer*>::const_iterator it = aLayer.begin(); it != aLayer.end(); ++it )
 169         delete *it;
 170     aLayer.clear();
 171 }
 172
 173 const SdrLayerAdmin& SdrLayerAdmin::operator=(const SdrLayerAdmin& rSrcLayerAdmin)
 174 {
 175     ClearLayer();
 176     pParent=rSrcLayerAdmin.pParent;
 177     sal_uInt16 i;
 178     sal_uInt16 nCount=rSrcLayerAdmin.GetLayerCount();
 179     for (i=0; i<nCount; i++) {
 180         aLayer.push_back(new SdrLayer(*rSrcLayerAdmin.GetLayer(i)));
 181     }
 182     return *this;
 183 }
 184
 185 bool SdrLayerAdmin::operator==(const SdrLayerAdmin& rCmpLayerAdmin) const
 186 {
 187     if (pParent!=rCmpLayerAdmin.pParent ||
 188         aLayer.size()!=rCmpLayerAdmin.aLayer.size())
 189         return false;
 190     bool bOk = true;
 191     sal_uInt16 nCount=GetLayerCount();
 192     sal_uInt16 i=0;
 193     while (bOk && i<nCount) {
 194         bOk=*GetLayer(i)==*rCmpLayerAdmin.GetLayer(i);
 195         i++;
 196     }
 197     return bOk;
 198 }
 199
 200 void SdrLayerAdmin::SetModel(SdrModel* pNewModel)
 201 {
 202     if (pNewModel!=pModel) {
 203         pModel=pNewModel;
 204         sal_uInt16 nCount=GetLayerCount();
 205         sal_uInt16 i;
 206         for (i=0; i<nCount; i++) {
 207             GetLayer(i)->SetModel(pNewModel);
 208         }
 209     }
 210 }
 211
 212 void SdrLayerAdmin::Broadcast() const
 213 {
 214     if (pModel!=NULL) {
 215         SdrHint aHint(HINT_LAYERORDERCHG);
 216         pModel->Broadcast(aHint);
 217         pModel->SetChanged();
 218     }
 219 }
 220
 221 SdrLayer* SdrLayerAdmin::RemoveLayer(sal_uInt16 nPos)
 222 {
 223     SdrLayer* pRetLayer=aLayer[nPos];
 224     aLayer.erase(aLayer.begin()+nPos);
 225     Broadcast();
 226     return pRetLayer;
 227 }
 228
 229 SdrLayer* SdrLayerAdmin::NewLayer(const OUString& rName, sal_uInt16 nPos)
 230 {
 231     SdrLayerID nID=GetUniqueLayerID();
 232     SdrLayer* pLay=new SdrLayer(nID,rName);
 233     pLay->SetModel(pModel);
 234     if(nPos==0xFFFF)
 235         aLayer.push_back(pLay);
 236     else
 237         aLayer.insert(aLayer.begin() + nPos, pLay);
 238     Broadcast();
 239     return pLay;
 240 }
 241
 242 SdrLayer* SdrLayerAdmin::NewStandardLayer(sal_uInt16 nPos)
 243 {
 244     SdrLayerID nID=GetUniqueLayerID();
 245     SdrLayer* pLay=new SdrLayer(nID,OUString());
 246     pLay->SetStandardLayer();
 247     pLay->SetModel(pModel);
 248     if(nPos==0xFFFF)
 249         aLayer.push_back(pLay);
 250     else
 251         aLayer.insert(aLayer.begin() + nPos, pLay);
 252     Broadcast();
 253     return pLay;
 254 }
 255
 256 sal_uInt16 SdrLayerAdmin::GetLayerPos(SdrLayer* pLayer) const
 257 {
 258     sal_uIntPtr nRet=SDRLAYER_NOTFOUND;
 259     if (pLayer!=NULL) {
 260         std::vector<SdrLayer*>::const_iterator it = std::find(aLayer.begin(), aLayer.end(), pLayer);
 261         if (it==aLayer.end()) {
 262             nRet=SDRLAYER_NOTFOUND;
 263         } else {
 264             nRet=it - aLayer.begin();
 265         }
 266     }
 267     return sal_uInt16(nRet);
 268 }
 269
 270 SdrLayer* SdrLayerAdmin::GetLayer(const OUString& rName, bool bInherited)
 271 {
 272     return const_cast<SdrLayer*>(((const SdrLayerAdmin*)this)->GetLayer(rName, bInherited));
 273 }
 274
 275 const SdrLayer* SdrLayerAdmin::GetLayer(const OUString& rName, bool /*bInherited*/) const
 276 {
 277     sal_uInt16 i(0);
 278     const SdrLayer* pLay = NULL;
 279
 280     while(i < GetLayerCount() && !pLay)
 281     {
 282         if (rName == GetLayer(i)->GetName())
 283             pLay = GetLayer(i);
 284         else
 285             i++;
 286     }
 287
 288     if(!pLay && pParent)
 289     {
 290         pLay = pParent->GetLayer(rName, true);
 291     }
 292
 293     return pLay;
 294 }
 295
 296 SdrLayerID SdrLayerAdmin::GetLayerID(const OUString& rName, bool bInherited) const
 297 {
 298     SdrLayerID nRet=SDRLAYER_NOTFOUND;
 299     const SdrLayer* pLay=GetLayer(rName,bInherited);
 300     if (pLay!=NULL) nRet=pLay->GetID();
 301     return nRet;
 302 }
 303
 304 const SdrLayer* SdrLayerAdmin::GetLayerPerID(sal_uInt16 nID) const
 305 {
 306     sal_uInt16 i=0;
 307     const SdrLayer* pLay=NULL;
 308     while (i<GetLayerCount() && pLay==NULL) {
 309         if (nID==GetLayer(i)->GetID()) pLay=GetLayer(i);
 310         else i++;
 311     }
 312     return pLay;
 313 }
 314
 315 // Global LayerIDs begin at 0 and increase,
 316 // local LayerIDs begin at 254 and decrease;
 317 // 255 is reserved for SDRLAYER_NOTFOUND.
 318
 319 SdrLayerID SdrLayerAdmin::GetUniqueLayerID() const
 320 {
 321     SetOfByte aSet;
 322     bool bDown = (pParent == NULL);
 323     sal_uInt16 j;
 324     for (j=0; j<GetLayerCount(); j++)
 325     {
 326         aSet.Set(GetLayer((sal_uInt16)j)->GetID());
 327     }
 328     SdrLayerID i;
 329     if (!bDown)
 330     {
 331         i=254;
 332         while (i && aSet.IsSet(sal_uInt8(i)))
 333             --i;
 334         if (i == 0)
 335             i=254;
 336     }
 337     else
 338     {
 339         i=0;
 340         while (i<=254 && aSet.IsSet(sal_uInt8(i)))
 341             i++;
 342         if (i>254)
 343             i=0;
 344     }
 345     return i;
 346 }
 347
 348 void SdrLayerAdmin::SetControlLayerName(const OUString& rNewName)
 349 {
 350     maControlLayerName = rNewName;
 351 }
 352
 353 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */