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