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