xref: /aoo41x/main/svx/source/xoutdev/xtable.cxx (revision f6e50924) 
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_svx.hxx"
26 
27 #include <svx/xtable.hxx>
28 #include <svx/xpool.hxx>
29 
30 #define GLOBALOVERFLOW
31 
32 // Vergleichsstrings
33 sal_Unicode __FAR_DATA pszStandard[] = { 's', 't', 'a', 'n', 'd', 'a', 'r', 'd', 0 };
34 
35 // Konvertiert in echte RGB-Farben, damit in den Listboxen
36 // endlich mal richtig selektiert werden kann.
37 Color RGB_Color( ColorData nColorName )
38 {
39 	Color aColor( nColorName );
40 	Color aRGBColor( aColor.GetRed(), aColor.GetGreen(), aColor.GetBlue() );
41 	return aRGBColor;
42 }
43 
44 // ---------------------
45 // class XPropertyTable
46 // ---------------------
47 
48 /*************************************************************************
49 |*
50 |* XPropertyTable::XPropertyTable()
51 |*
52 *************************************************************************/
53 
54 XPropertyTable::XPropertyTable( const String& rPath,
55 								XOutdevItemPool* pInPool,
56 								sal_uInt16 nInitSize, sal_uInt16 nReSize ) :
57 			aName			( pszStandard, 8 ),
58 			aPath			( rPath ),
59 			pXPool			( pInPool ),
60 			aTable			( nInitSize, nReSize ),
61 			pBmpTable		( NULL ),
62 			bTableDirty		( sal_True ),
63 			bBitmapsDirty	( sal_True ),
64 			bOwnPool		( sal_False )
65 {
66 	if( !pXPool )
67 	{
68 		bOwnPool = sal_True;
69 		pXPool = new XOutdevItemPool;
70 		DBG_ASSERT( pXPool, "XOutPool konnte nicht erzeugt werden!" );
71 	}
72 }
73 
74 /*************************************************************************
75 |*
76 |* XPropertyTable::XPropertyTable( SvStraem& )
77 |*
78 *************************************************************************/
79 
80 XPropertyTable::XPropertyTable( SvStream& /*rIn*/) :
81 			pBmpTable	( NULL )
82 {
83 }
84 
85 /*************************************************************************
86 |*
87 |* XPropertyTable::~XPropertyTable()
88 |*
89 *************************************************************************/
90 
91 XPropertyTable::~XPropertyTable()
92 {
93 	XPropertyEntry* pEntry = (XPropertyEntry*)aTable.First();
94 	Bitmap* pBitmap = NULL;
95 	for (sal_uIntPtr nIndex = 0; nIndex < aTable.Count(); nIndex++)
96 	{
97 		delete pEntry;
98 		pEntry = (XPropertyEntry*)aTable.Next();
99 	}
100 	// Hier wird die Bitmaptabelle geloescht
101 	if( pBmpTable )
102 	{
103 		pBitmap = (Bitmap*) pBmpTable->First();
104 
105 		for( sal_uIntPtr nIndex = 0; nIndex < pBmpTable->Count(); nIndex++ )
106 		{
107 			delete pBitmap;
108 			pBitmap = (Bitmap*) pBmpTable->Next();
109 		}
110 		delete pBmpTable;
111 		pBmpTable = NULL;
112 	}
113 	// Eigener Pool wird geloescht
114 	if( bOwnPool && pXPool )
115 	{
116         SfxItemPool::Free(pXPool);
117 	}
118 }
119 
120 /*************************************************************************
121 |*
122 |* XPropertyTable::Clear()
123 |*
124 *************************************************************************/
125 
126 void XPropertyTable::Clear()
127 {
128 	aTable.Clear();
129 	if( pBmpTable )
130 		pBmpTable->Clear();
131 }
132 
133 /************************************************************************/
134 
135 long XPropertyTable::Count() const
136 {
137 	if( bTableDirty )
138 	{
139 		// ( (XPropertyTable*) this )->bTableDirty = sal_False; <- im Load()
140 		if( !( (XPropertyTable*) this )->Load() )
141 			( (XPropertyTable*) this )->Create();
142 	}
143 	return( aTable.Count() );
144 }
145 
146 /*************************************************************************
147 |*
148 |* XPropertyEntry* XPropertyTable::Get()
149 |*
150 *************************************************************************/
151 
152 XPropertyEntry* XPropertyTable::Get( long nIndex, sal_uInt16 /*nDummy*/) const
153 {
154 	if( bTableDirty )
155 	{
156 		// ( (XPropertyTable*) this )->bTableDirty = sal_False; <- im Load()
157 		if( !( (XPropertyTable*) this )->Load() )
158 			( (XPropertyTable*) this )->Create();
159 	}
160 	return (XPropertyEntry*) aTable.GetObject( (sal_uIntPtr) nIndex );
161 }
162 
163 /*************************************************************************
164 |*
165 |* long XPropertyTable::Get(const String& rName)
166 |*
167 *************************************************************************/
168 
169 long XPropertyTable::Get(const XubString& rName)
170 {
171 	if( bTableDirty )
172 	{
173 		// bTableDirty = sal_False;
174 		if( !Load() )
175 			Create();
176 	}
177 	long nPos = 0;
178 	XPropertyEntry* pEntry = (XPropertyEntry*)aTable.First();
179 	while (pEntry && pEntry->GetName() != rName)
180 	{
181 		nPos++;
182 		pEntry = (XPropertyEntry*)aTable.Next();
183 	}
184 	if (!pEntry) nPos = -1;
185 	return nPos;
186 }
187 
188 /*************************************************************************
189 |*
190 |* Bitmap* XPropertyTable::GetBitmap()
191 |*
192 *************************************************************************/
193 
194 Bitmap* XPropertyTable::GetBitmap( long nIndex ) const
195 {
196 	if( pBmpTable )
197 	{
198 		if( bBitmapsDirty )
199 		{
200 			( (XPropertyTable*) this )->bBitmapsDirty = sal_False;
201 			( (XPropertyTable*) this )->CreateBitmapsForUI();
202 		}
203 
204 		if( pBmpTable->Count() >= (sal_uIntPtr) nIndex )
205 			return (Bitmap*) pBmpTable->GetObject( (sal_uIntPtr) nIndex );
206 	}
207 	return( NULL );
208 }
209 
210 /*************************************************************************
211 |*
212 |* void XPropertyTable::Insert()
213 |*
214 *************************************************************************/
215 
216 sal_Bool XPropertyTable::Insert( long nIndex, XPropertyEntry* pEntry )
217 {
218 	sal_Bool bReturn = aTable.Insert( (sal_uIntPtr) nIndex, pEntry );
219 
220 	if( pBmpTable && !bBitmapsDirty )
221 	{
222 		Bitmap* pBmp = CreateBitmapForUI( (sal_uIntPtr) nIndex );
223 		pBmpTable->Insert( (sal_uIntPtr) nIndex, pBmp );
224 	}
225 	return bReturn;
226 }
227 
228 /*************************************************************************
229 |*
230 |* void XPropertyTable::Replace()
231 |*
232 *************************************************************************/
233 
234 XPropertyEntry* XPropertyTable::Replace( long nIndex, XPropertyEntry* pEntry )
235 {
236 	XPropertyEntry* pOldEntry = (XPropertyEntry*) aTable.Replace( (sal_uIntPtr) nIndex, pEntry );
237 
238 	if( pBmpTable && !bBitmapsDirty )
239 	{
240 		Bitmap* pBmp = CreateBitmapForUI( (sal_uIntPtr) nIndex );
241 		Bitmap* pOldBmp = (Bitmap*) pBmpTable->Replace( (sal_uIntPtr) nIndex, pBmp );
242 		if( pOldBmp )
243 			delete pOldBmp;
244 	}
245 	return pOldEntry;
246 }
247 
248 /*************************************************************************
249 |*
250 |* void XPropertyTable::Remove()
251 |*
252 *************************************************************************/
253 
254 XPropertyEntry* XPropertyTable::Remove( long nIndex, sal_uInt16 /*nDummy*/)
255 {
256 	if( pBmpTable && !bBitmapsDirty )
257 	{
258 		Bitmap* pOldBmp = (Bitmap*) pBmpTable->Remove( (sal_uIntPtr) nIndex );
259 		if( pOldBmp )
260 			delete pOldBmp;
261 	}
262 	return (XPropertyEntry*) aTable.Remove((sal_uIntPtr)nIndex);
263 }
264 
265 /************************************************************************/
266 
267 void XPropertyTable::SetName( const String& rString )
268 {
269 	if(rString.Len())
270 	{
271 		aName = rString;
272 	}
273 }
274 
275 // --------------------
276 // class XPropertyList
277 // --------------------
278 
279 
280 /*************************************************************************
281 |*
282 |* XPropertyList::XPropertyList()
283 |*
284 *************************************************************************/
285 
286 XPropertyList::XPropertyList( const String& rPath,
287 								XOutdevItemPool* pInPool,
288 								sal_uInt16 nInitSize, sal_uInt16 nReSize ) :
289 			aName			( pszStandard, 8 ),
290 			aPath			( rPath ),
291 			pXPool			( pInPool ),
292 			aList			( nInitSize, nReSize ),
293 			pBmpList		( NULL ),
294 			bListDirty		( sal_True ),
295 			bBitmapsDirty	( sal_True ),
296 			bOwnPool		( sal_False )
297 {
298 	if( !pXPool )
299 	{
300 		bOwnPool = sal_True;
301 		pXPool = new XOutdevItemPool;
302 		DBG_ASSERT( pXPool, "XOutPool konnte nicht erzeugt werden!" );
303 	}
304 }
305 
306 /*************************************************************************
307 |*
308 |* XPropertyList::XPropertyList( SvStraem& )
309 |*
310 *************************************************************************/
311 
312 XPropertyList::XPropertyList( SvStream& /*rIn*/) :
313 			pBmpList	( NULL )
314 {
315 }
316 
317 /*************************************************************************
318 |*
319 |* XPropertyList::~XPropertyList()
320 |*
321 *************************************************************************/
322 
323 XPropertyList::~XPropertyList()
324 {
325 	XPropertyEntry* pEntry = (XPropertyEntry*)aList.First();
326 	Bitmap* pBitmap = NULL;
327 	for( sal_uIntPtr nIndex = 0; nIndex < aList.Count(); nIndex++ )
328 	{
329 		delete pEntry;
330 		pEntry = (XPropertyEntry*)aList.Next();
331 	}
332 
333 	if( pBmpList )
334 	{
335 		pBitmap = (Bitmap*) pBmpList->First();
336 
337 		for( sal_uIntPtr nIndex = 0; nIndex < pBmpList->Count(); nIndex++ )
338 		{
339 			delete pBitmap;
340 			pBitmap = (Bitmap*) pBmpList->Next();
341 		}
342 		delete pBmpList;
343 		pBmpList = NULL;
344 	}
345 
346 	if( bOwnPool && pXPool )
347 	{
348         SfxItemPool::Free(pXPool);
349 	}
350 }
351 
352 /*************************************************************************
353 |*
354 |* XPropertyList::Clear()
355 |*
356 *************************************************************************/
357 
358 void XPropertyList::Clear()
359 {
360 	aList.Clear();
361 	if( pBmpList )
362 		pBmpList->Clear();
363 }
364 
365 /************************************************************************/
366 
367 long XPropertyList::Count() const
368 {
369 	if( bListDirty )
370 	{
371 		// ( (XPropertyList*) this )->bListDirty = sal_False; <- im Load()
372 		if( !( (XPropertyList*) this )->Load() )
373 			( (XPropertyList*) this )->Create();
374 	}
375 	return( aList.Count() );
376 }
377 
378 /*************************************************************************
379 |*
380 |* XPropertyEntry* XPropertyList::Get()
381 |*
382 *************************************************************************/
383 
384 XPropertyEntry* XPropertyList::Get( long nIndex, sal_uInt16 /*nDummy*/) const
385 {
386 	if( bListDirty )
387 	{
388 		// ( (XPropertyList*) this )->bListDirty = sal_False; <- im Load()
389 		if( !( (XPropertyList*) this )->Load() )
390 			( (XPropertyList*) this )->Create();
391 	}
392 	return (XPropertyEntry*) aList.GetObject( (sal_uIntPtr) nIndex );
393 }
394 
395 /*************************************************************************
396 |*
397 |* XPropertyList::Get()
398 |*
399 *************************************************************************/
400 
401 long XPropertyList::Get(const XubString& rName)
402 {
403 	if( bListDirty )
404 	{
405 		//bListDirty = sal_False;
406 		if( !Load() )
407 			Create();
408 	}
409 	long nPos = 0;
410 	XPropertyEntry* pEntry = (XPropertyEntry*)aList.First();
411 	while (pEntry && pEntry->GetName() != rName)
412 	{
413 		nPos++;
414 		pEntry = (XPropertyEntry*)aList.Next();
415 	}
416 	if (!pEntry) nPos = -1;
417 	return nPos;
418 }
419 
420 /*************************************************************************
421 |*
422 |* Bitmap* XPropertyList::GetBitmap()
423 |*
424 *************************************************************************/
425 
426 Bitmap* XPropertyList::GetBitmap( long nIndex ) const
427 {
428 	if( pBmpList )
429 	{
430 		if( bBitmapsDirty )
431 		{
432 			( (XPropertyList*) this )->bBitmapsDirty = sal_False;
433 			( (XPropertyList*) this )->CreateBitmapsForUI();
434 		}
435 		if( pBmpList->Count() >= (sal_uIntPtr) nIndex )
436 			return (Bitmap*) pBmpList->GetObject( (sal_uIntPtr) nIndex );
437 	}
438 	return( NULL );
439 }
440 
441 /*************************************************************************
442 |*
443 |* void XPropertyList::Insert()
444 |*
445 *************************************************************************/
446 
447 void XPropertyList::Insert( XPropertyEntry* pEntry, long nIndex )
448 {
449 	aList.Insert( pEntry, (sal_uIntPtr) nIndex );
450 
451 	if( pBmpList && !bBitmapsDirty )
452 	{
453 		Bitmap* pBmp = CreateBitmapForUI(
454 				(sal_uIntPtr) nIndex < aList.Count() ? nIndex : aList.Count() - 1 );
455 		pBmpList->Insert( pBmp, (sal_uIntPtr) nIndex );
456 	}
457 }
458 
459 /*************************************************************************
460 |*
461 |* void XPropertyList::Replace()
462 |*
463 *************************************************************************/
464 
465 XPropertyEntry* XPropertyList::Replace( XPropertyEntry* pEntry, long nIndex )
466 {
467 	XPropertyEntry* pOldEntry = (XPropertyEntry*) aList.Replace( pEntry, (sal_uIntPtr) nIndex );
468 
469 	if( pBmpList && !bBitmapsDirty )
470 	{
471 		Bitmap* pBmp = CreateBitmapForUI( (sal_uIntPtr) nIndex );
472 		Bitmap* pOldBmp = (Bitmap*) pBmpList->Replace( pBmp, (sal_uIntPtr) nIndex );
473 		if( pOldBmp )
474 			delete pOldBmp;
475 	}
476 	return pOldEntry;
477 }
478 
479 /*************************************************************************
480 |*
481 |* void XPropertyList::Remove()
482 |*
483 *************************************************************************/
484 
485 XPropertyEntry* XPropertyList::Remove( long nIndex, sal_uInt16 /*nDummy*/)
486 {
487 	if( pBmpList && !bBitmapsDirty )
488 	{
489 		Bitmap* pOldBmp = (Bitmap*) pBmpList->Remove( (sal_uIntPtr) nIndex );
490 		if( pOldBmp )
491 			delete pOldBmp;
492 	}
493 	return (XPropertyEntry*) aList.Remove( (sal_uIntPtr) nIndex );
494 }
495 
496 /************************************************************************/
497 
498 void XPropertyList::SetName( const String& rString )
499 {
500 	if(rString.Len())
501 	{
502 		aName = rString;
503 	}
504 }
505 
506 
507 
508