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