goodies/source/graphic/grfcache.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: grfcache.cxx,v $
  10  * $Revision: 1.23.38.1 $
  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_goodies.hxx"
  33
  34 #include <vos/timer.hxx>
  35 #include <tools/debug.hxx>
  36 #include <vcl/outdev.hxx>
  37 #include <tools/poly.hxx>
  38 #include "grfcache.hxx"
  39
  40 // -----------
  41 // - Defines -
  42 // -----------
  43
  44 #define RELEASE_TIMEOUT 10000
  45 #define MAX_BMP_EXTENT  4096
  46
  47 // -----------
  48 // - statics -
  49 // -----------
  50
  51 static const char aHexData[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
  52
  53 // -------------
  54 // - GraphicID -
  55 // -------------
  56
  57 class GraphicID
  58 {
  59 private:
  60
  61     sal_uInt32  mnID1;
  62     sal_uInt32  mnID2;
  63     sal_uInt32  mnID3;
  64     sal_uInt32  mnID4;
  65
  66                 GraphicID();
  67
  68 public:
  69
  70
  71                 GraphicID( const GraphicObject& rObj );
  72                 ~GraphicID() {}
  73
  74     BOOL                operator==( const GraphicID& rID ) const
  75                 {
  76                     return( rID.mnID1 == mnID1 && rID.mnID2 == mnID2 &&
  77                             rID.mnID3 == mnID3 && rID.mnID4 == mnID4 );
  78                 }
  79
  80     ByteString  GetIDString() const;
  81     BOOL        IsEmpty() const { return( 0 == mnID4 ); }
  82 };
  83
  84 // -----------------------------------------------------------------------------
  85
  86 GraphicID::GraphicID( const GraphicObject& rObj )
  87 {
  88     const Graphic& rGraphic = rObj.GetGraphic();
  89
  90     mnID1 = ( (ULONG) rGraphic.GetType() ) << 28;
  91
  92     switch( rGraphic.GetType() )
  93     {
  94         case( GRAPHIC_BITMAP ):
  95         {
  96             if( rGraphic.IsAnimated() )
  97             {
  98                 const Animation aAnimation( rGraphic.GetAnimation() );
  99
 100                 mnID1 |= ( aAnimation.Count() & 0x0fffffff );
 101                 mnID2 = aAnimation.GetDisplaySizePixel().Width();
 102                 mnID3 = aAnimation.GetDisplaySizePixel().Height();
 103                 mnID4 = rGraphic.GetChecksum();
 104             }
 105             else
 106             {
 107                 const BitmapEx aBmpEx( rGraphic.GetBitmapEx() );
 108
 109                 mnID1 |= ( ( ( (ULONG) aBmpEx.GetTransparentType() << 8 ) | ( aBmpEx.IsAlpha() ? 1 : 0 ) ) & 0x0fffffff );
 110                 mnID2 = aBmpEx.GetSizePixel().Width();
 111                 mnID3 = aBmpEx.GetSizePixel().Height();
 112                 mnID4 = rGraphic.GetChecksum();
 113             }
 114         }
 115         break;
 116
 117         case( GRAPHIC_GDIMETAFILE ):
 118         {
 119             const GDIMetaFile aMtf( rGraphic.GetGDIMetaFile() );
 120
 121             mnID1 |= ( aMtf.GetActionCount() & 0x0fffffff );
 122             mnID2 = aMtf.GetPrefSize().Width();
 123             mnID3 = aMtf.GetPrefSize().Height();
 124             mnID4 = rGraphic.GetChecksum();
 125         }
 126         break;
 127
 128         default:
 129             mnID2 = mnID3 = mnID4 = 0;
 130         break;
 131     }
 132 }
 133
 134 // -----------------------------------------------------------------------------
 135
 136 ByteString GraphicID::GetIDString() const
 137 {
 138     ByteString  aHexStr;
 139     sal_Char*   pStr = aHexStr.AllocBuffer( 32 );
 140     sal_Int32   nShift;
 141
 142     for( nShift = 28; nShift >= 0; nShift -= 4 )
 143         *pStr++ = aHexData[ ( mnID1 >> (sal_uInt32) nShift ) & 0xf ];
 144
 145     for( nShift = 28; nShift >= 0; nShift -= 4 )
 146         *pStr++ = aHexData[ ( mnID2 >> (sal_uInt32) nShift ) & 0xf ];
 147
 148     for( nShift = 28; nShift >= 0; nShift -= 4 )
 149         *pStr++ = aHexData[ ( mnID3 >> (sal_uInt32) nShift ) & 0xf ];
 150
 151     for( nShift = 28; nShift >= 0; nShift -= 4 )
 152         *pStr++ = aHexData[ ( mnID4 >> (sal_uInt32) nShift ) & 0xf ];
 153
 154     return aHexStr;
 155 }
 156
 157 // ---------------------
 158 // - GraphicCacheEntry -
 159 // ---------------------
 160
 161 class GraphicCacheEntry
 162 {
 163 private:
 164
 165     List                                maGraphicObjectList;
 166     GraphicID                   maID;
 167     GfxLink                             maGfxLink;
 168     BitmapEx*                   mpBmpEx;
 169     GDIMetaFile*                mpMtf;
 170     Animation*                  mpAnimation;
 171     BOOL                                mbSwappedAll;
 172
 173     BOOL                                ImplInit( const GraphicObject& rObj );
 174     BOOL                                ImplMatches( const GraphicObject& rObj ) const { return( GraphicID( rObj ) == maID ); }
 175     void                                ImplFillSubstitute( Graphic& rSubstitute );
 176
 177 public:
 178
 179                         GraphicCacheEntry( const GraphicObject& rObj );
 180                         ~GraphicCacheEntry();
 181
 182     const GraphicID&    GetID() const { return maID; }
 183
 184     void                                AddGraphicObjectReference( const GraphicObject& rObj, Graphic& rSubstitute );
 185     BOOL                                ReleaseGraphicObjectReference( const GraphicObject& rObj );
 186     ULONG                               GetGraphicObjectReferenceCount() { return maGraphicObjectList.Count(); }
 187     BOOL                                HasGraphicObjectReference( const GraphicObject& rObj );
 188
 189     void                                TryToSwapIn();
 190     void                                GraphicObjectWasSwappedOut( const GraphicObject& rObj );
 191     BOOL                                FillSwappedGraphicObject( const GraphicObject& rObj, Graphic& rSubstitute );
 192     void                                GraphicObjectWasSwappedIn( const GraphicObject& rObj );
 193 };
 194
 195 // -----------------------------------------------------------------------------
 196
 197 GraphicCacheEntry::GraphicCacheEntry( const GraphicObject& rObj ) :
 198     maID                        ( rObj ),
 199     mpBmpEx                     ( NULL ),
 200     mpMtf                       ( NULL ),
 201     mpAnimation         ( NULL ),
 202     mbSwappedAll    ( !ImplInit( rObj ) )
 203 {
 204     maGraphicObjectList.Insert( (void*) &rObj, LIST_APPEND );
 205 }
 206
 207 // -----------------------------------------------------------------------------
 208
 209 GraphicCacheEntry::~GraphicCacheEntry()
 210 {
 211     DBG_ASSERT( !maGraphicObjectList.Count(), "GraphicCacheEntry::~GraphicCacheEntry(): Not all GraphicObjects are removed from this entry" );
 212
 213     delete mpBmpEx;
 214     delete mpMtf;
 215     delete mpAnimation;
 216 }
 217
 218 // -----------------------------------------------------------------------------
 219
 220 BOOL GraphicCacheEntry::ImplInit( const GraphicObject& rObj )
 221 {
 222     BOOL bRet;
 223
 224     if( !rObj.IsSwappedOut() )
 225     {
 226         const Graphic& rGraphic = rObj.GetGraphic();
 227
 228         if( mpBmpEx )
 229             delete mpBmpEx, mpBmpEx = NULL;
 230
 231         if( mpMtf )
 232             delete mpMtf, mpMtf = NULL;
 233
 234         if( mpAnimation )
 235             delete mpAnimation, mpAnimation = NULL;
 236
 237         switch( rGraphic.GetType() )
 238         {
 239             case( GRAPHIC_BITMAP ):
 240             {
 241                 if( rGraphic.IsAnimated() )
 242                     mpAnimation = new Animation( rGraphic.GetAnimation() );
 243                 else
 244                     mpBmpEx = new BitmapEx( rGraphic.GetBitmapEx() );
 245             }
 246             break;
 247
 248             case( GRAPHIC_GDIMETAFILE ):
 249             {
 250                 mpMtf = new GDIMetaFile( rGraphic.GetGDIMetaFile() );
 251             }
 252             break;
 253
 254             default:
 255                 DBG_ASSERT( GetID().IsEmpty(), "GraphicCacheEntry::ImplInit: Could not initialize graphic! (=>KA)" );
 256             break;
 257         }
 258
 259         if( rGraphic.IsLink() )
 260             maGfxLink = ( (Graphic&) rGraphic ).GetLink();
 261         else
 262             maGfxLink = GfxLink();
 263
 264         bRet = TRUE;
 265     }
 266     else
 267         bRet = FALSE;
 268
 269     return bRet;
 270 }
 271
 272 // -----------------------------------------------------------------------------
 273
 274 void GraphicCacheEntry::ImplFillSubstitute( Graphic& rSubstitute )
 275 {
 276     // create substitute for graphic;
 277     const Size                  aPrefSize( rSubstitute.GetPrefSize() );
 278     const MapMode               aPrefMapMode( rSubstitute.GetPrefMapMode() );
 279     const Link                  aAnimationNotifyHdl( rSubstitute.GetAnimationNotifyHdl() );
 280     const String                aDocFileName( rSubstitute.GetDocFileName() );
 281     const ULONG                 nDocFilePos = rSubstitute.GetDocFilePos();
 282     const GraphicType   eOldType = rSubstitute.GetType();
 283     const BOOL                  bDefaultType = ( rSubstitute.GetType() == GRAPHIC_DEFAULT );
 284
 285     if( rSubstitute.IsLink() && ( GFX_LINK_TYPE_NONE == maGfxLink.GetType() ) )
 286         maGfxLink = rSubstitute.GetLink();
 287
 288     if( mpBmpEx )
 289         rSubstitute = *mpBmpEx;
 290     else if( mpAnimation )
 291         rSubstitute = *mpAnimation;
 292     else if( mpMtf )
 293         rSubstitute = *mpMtf;
 294     else
 295         rSubstitute.Clear();
 296
 297     if( eOldType != GRAPHIC_NONE )
 298     {
 299         rSubstitute.SetPrefSize( aPrefSize );
 300         rSubstitute.SetPrefMapMode( aPrefMapMode );
 301         rSubstitute.SetAnimationNotifyHdl( aAnimationNotifyHdl );
 302         rSubstitute.SetDocFileName( aDocFileName, nDocFilePos );
 303     }
 304
 305     if( GFX_LINK_TYPE_NONE != maGfxLink.GetType() )
 306         rSubstitute.SetLink( maGfxLink );
 307
 308     if( bDefaultType )
 309         rSubstitute.SetDefaultType();
 310 }
 311
 312 // -----------------------------------------------------------------------------
 313
 314 void GraphicCacheEntry::AddGraphicObjectReference( const GraphicObject& rObj, Graphic& rSubstitute )
 315 {
 316     if( mbSwappedAll )
 317         mbSwappedAll = !ImplInit( rObj );
 318
 319     ImplFillSubstitute( rSubstitute );
 320     maGraphicObjectList.Insert( (void*) &rObj, LIST_APPEND );
 321 }
 322
 323 // -----------------------------------------------------------------------------
 324
 325 BOOL GraphicCacheEntry::ReleaseGraphicObjectReference( const GraphicObject& rObj )
 326 {
 327     BOOL bRet = FALSE;
 328
 329     for( void* pObj = maGraphicObjectList.First(); !bRet && pObj; pObj = maGraphicObjectList.Next() )
 330     {
 331         if( &rObj == (GraphicObject*) pObj )
 332         {
 333             maGraphicObjectList.Remove( pObj );
 334             bRet = TRUE;
 335         }
 336     }
 337
 338     return bRet;
 339 }
 340
 341 // -----------------------------------------------------------------------------
 342
 343 BOOL GraphicCacheEntry::HasGraphicObjectReference( const GraphicObject& rObj )
 344 {
 345     BOOL bRet = FALSE;
 346
 347     for( void* pObj = maGraphicObjectList.First(); !bRet && pObj; pObj = maGraphicObjectList.Next() )
 348         if( &rObj == (GraphicObject*) pObj )
 349             bRet = TRUE;
 350
 351     return bRet;
 352 }
 353
 354 // -----------------------------------------------------------------------------
 355
 356 void GraphicCacheEntry::TryToSwapIn()
 357 {
 358     if( mbSwappedAll && maGraphicObjectList.Count() )
 359         ( (GraphicObject*) maGraphicObjectList.First() )->FireSwapInRequest();
 360 }
 361
 362 // -----------------------------------------------------------------------------
 363
 364 void GraphicCacheEntry::GraphicObjectWasSwappedOut( const GraphicObject& /*rObj*/ )
 365 {
 366     mbSwappedAll = TRUE;
 367
 368     for( void* pObj = maGraphicObjectList.First(); mbSwappedAll && pObj; pObj = maGraphicObjectList.Next() )
 369         if( !( (GraphicObject*) pObj )->IsSwappedOut() )
 370             mbSwappedAll = FALSE;
 371
 372     if( mbSwappedAll )
 373     {
 374         delete mpBmpEx, mpBmpEx = NULL;
 375         delete mpMtf, mpMtf = NULL;
 376         delete mpAnimation, mpAnimation = NULL;
 377     }
 378 }
 379
 380 // -----------------------------------------------------------------------------
 381
 382 BOOL GraphicCacheEntry::FillSwappedGraphicObject( const GraphicObject& rObj, Graphic& rSubstitute )
 383 {
 384     BOOL bRet;
 385
 386     if( !mbSwappedAll && rObj.IsSwappedOut() )
 387     {
 388         ImplFillSubstitute( rSubstitute );
 389         bRet = TRUE;
 390     }
 391     else
 392         bRet = FALSE;
 393
 394     return bRet;
 395 }
 396
 397 // -----------------------------------------------------------------------------
 398
 399 void GraphicCacheEntry::GraphicObjectWasSwappedIn( const GraphicObject& rObj )
 400 {
 401     if( mbSwappedAll )
 402         mbSwappedAll = !ImplInit( rObj );
 403 }
 404
 405 // ----------------------------
 406 // - GraphicDisplayCacheEntry -
 407 // ----------------------------
 408
 409 class GraphicDisplayCacheEntry
 410 {
 411 private:
 412
 413     ::vos::TTimeValue           maReleaseTime;
 414     const GraphicCacheEntry*    mpRefCacheEntry;
 415     GDIMetaFile*                                mpMtf;
 416     BitmapEx*                                   mpBmpEx;
 417     GraphicAttr                                 maAttr;
 418     Size                                                maOutSizePix;
 419     ULONG                                               mnCacheSize;
 420     ULONG                                               mnOutDevDrawMode;
 421     USHORT                                              mnOutDevBitCount;
 422
 423 public:
 424
 425     static ULONG                                GetNeededSize( OutputDevice* pOut, const Point& rPt, const Size& rSz,
 426                                                const GraphicObject& rObj, const GraphicAttr& rAttr );
 427
 428 public:
 429
 430                                 GraphicDisplayCacheEntry( const GraphicCacheEntry* pRefCacheEntry,
 431                                                           OutputDevice* pOut, const Point& rPt, const Size& rSz,
 432                                                           const GraphicObject& rObj, const GraphicAttr& rAttr,
 433                                                           const BitmapEx& rBmpEx ) :
 434                                     mpRefCacheEntry( pRefCacheEntry ),
 435                                     mpMtf( NULL ), mpBmpEx( new BitmapEx( rBmpEx ) ),
 436                                     maAttr( rAttr ), maOutSizePix( pOut->LogicToPixel( rSz ) ),
 437                                     mnCacheSize( GetNeededSize( pOut, rPt, rSz, rObj, rAttr ) ),
 438                                     mnOutDevDrawMode( pOut->GetDrawMode() ),
 439                                     mnOutDevBitCount( pOut->GetBitCount() )
 440                                     {
 441                                     }
 442
 443                                 GraphicDisplayCacheEntry( const GraphicCacheEntry* pRefCacheEntry,
 444                                                           OutputDevice* pOut, const Point& rPt, const Size& rSz,
 445                                                           const GraphicObject& rObj, const GraphicAttr& rAttr,
 446                                                           const GDIMetaFile& rMtf ) :
 447                                     mpRefCacheEntry( pRefCacheEntry ),
 448                                     mpMtf( new GDIMetaFile( rMtf ) ), mpBmpEx( NULL ),
 449                                     maAttr( rAttr ), maOutSizePix( pOut->LogicToPixel( rSz ) ),
 450                                     mnCacheSize( GetNeededSize( pOut, rPt, rSz, rObj, rAttr ) ),
 451                                     mnOutDevDrawMode( pOut->GetDrawMode() ),
 452                                     mnOutDevBitCount( pOut->GetBitCount() )
 453                                     {
 454                                     }
 455
 456
 457                                 ~GraphicDisplayCacheEntry();
 458
 459     const GraphicAttr&                  GetAttr() const { return maAttr; }
 460     const Size&                                 GetOutputSizePixel() const { return maOutSizePix; }
 461     ULONG                                       GetCacheSize() const { return mnCacheSize; }
 462     const GraphicCacheEntry*    GetReferencedCacheEntry() const { return mpRefCacheEntry; }
 463     ULONG                                       GetOutDevDrawMode() const { return mnOutDevDrawMode; }
 464     USHORT                              GetOutDevBitCount()     const { return mnOutDevBitCount; }
 465
 466     void                        SetReleaseTime( const ::vos::TTimeValue& rReleaseTime ) { maReleaseTime = rReleaseTime; }
 467     const ::vos::TTimeValue&    GetReleaseTime() const { return maReleaseTime; }
 468
 469     BOOL                                                Matches( OutputDevice* pOut, const Point& /*rPtPixel*/, const Size& rSzPixel,
 470                                          const GraphicCacheEntry* pCacheEntry, const GraphicAttr& rAttr ) const
 471                                 {
 472                                     // #i46805# Additional match
 473                                     // criteria: outdev draw mode and
 474                                     // bit count. One cannot reuse
 475                                     // this cache object, if it's
 476                                     // e.g. generated for
 477                                     // DRAWMODE_GRAYBITMAP.
 478                                     return( ( pCacheEntry == mpRefCacheEntry ) &&
 479                                             ( maAttr == rAttr ) &&
 480                                             ( ( maOutSizePix == rSzPixel ) || ( !maOutSizePix.Width() && !maOutSizePix.Height() ) ) &&
 481                                             ( pOut->GetBitCount() == mnOutDevBitCount ) &&
 482                                             ( pOut->GetDrawMode() == mnOutDevDrawMode ) );
 483                                 }
 484
 485     void                                                Draw( OutputDevice* pOut, const Point& rPt, const Size& rSz ) const;
 486 };
 487
 488 // -----------------------------------------------------------------------------
 489
 490 ULONG GraphicDisplayCacheEntry::GetNeededSize( OutputDevice* pOut, const Point& /*rPt*/, const Size& rSz,
 491                                                const GraphicObject& rObj, const GraphicAttr& rAttr )
 492 {
 493     const Graphic&      rGraphic = rObj.GetGraphic();
 494     const GraphicType   eType = rGraphic.GetType();
 495     ULONG                               nNeededSize;
 496
 497     if( GRAPHIC_BITMAP == eType )
 498     {
 499         const Size aOutSizePix( pOut->LogicToPixel( rSz ) );
 500         const long nBitCount = pOut->GetBitCount();
 501
 502         if( ( aOutSizePix.Width() > MAX_BMP_EXTENT ) ||
 503             ( aOutSizePix.Height() > MAX_BMP_EXTENT ) )
 504         {
 505             nNeededSize = ULONG_MAX;
 506         }
 507         else if( nBitCount )
 508         {
 509             nNeededSize = aOutSizePix.Width() * aOutSizePix.Height() * nBitCount / 8;
 510
 511             if( rObj.IsTransparent() || ( rAttr.GetRotation() % 3600 ) )
 512                 nNeededSize += nNeededSize / nBitCount;
 513         }
 514         else
 515         {
 516              DBG_ERROR( "GraphicDisplayCacheEntry::GetNeededSize(): pOut->GetBitCount() == 0" );
 517             nNeededSize = 256000;
 518         }
 519     }
 520     else if( GRAPHIC_GDIMETAFILE == eType )
 521         nNeededSize = rGraphic.GetSizeBytes();
 522     else
 523         nNeededSize = 0;
 524
 525     return nNeededSize;
 526 }
 527
 528 // -----------------------------------------------------------------------------
 529
 530 GraphicDisplayCacheEntry::~GraphicDisplayCacheEntry()
 531 {
 532     if( mpMtf )
 533         delete mpMtf;
 534
 535     if( mpBmpEx )
 536         delete mpBmpEx;
 537 }
 538
 539 // -----------------------------------------------------------------------------
 540
 541 void GraphicDisplayCacheEntry::Draw( OutputDevice* pOut, const Point& rPt, const Size& rSz ) const
 542 {
 543     if( mpMtf )
 544         GraphicManager::ImplDraw( pOut, rPt, rSz, *mpMtf, maAttr );
 545     else if( mpBmpEx )
 546     {
 547         if( maAttr.IsRotated() )
 548         {
 549             Polygon aPoly( Rectangle( rPt, rSz ) );
 550
 551             aPoly.Rotate( rPt, maAttr.GetRotation() % 3600 );
 552             const Rectangle aRotBoundRect( aPoly.GetBoundRect() );
 553             pOut->DrawBitmapEx( aRotBoundRect.TopLeft(), aRotBoundRect.GetSize(), *mpBmpEx );
 554         }
 555         else
 556             pOut->DrawBitmapEx( rPt, rSz, *mpBmpEx );
 557     }
 558 }
 559
 560 // -----------------------
 561 // - GraphicCache -
 562 // -----------------------
 563
 564 GraphicCache::GraphicCache( GraphicManager& rMgr, ULONG nDisplayCacheSize, ULONG nMaxObjDisplayCacheSize ) :
 565     mrMgr                                   ( rMgr ),
 566     mnReleaseTimeoutSeconds ( 0UL ),
 567     mnMaxDisplaySize        ( nDisplayCacheSize ),
 568     mnMaxObjDisplaySize     ( nMaxObjDisplayCacheSize ),
 569     mnUsedDisplaySize       ( 0UL )
 570 {
 571     maReleaseTimer.SetTimeoutHdl( LINK( this, GraphicCache, ReleaseTimeoutHdl ) );
 572     maReleaseTimer.SetTimeout( RELEASE_TIMEOUT );
 573     maReleaseTimer.Start();
 574 }
 575
 576 // -----------------------------------------------------------------------------
 577
 578 GraphicCache::~GraphicCache()
 579 {
 580     DBG_ASSERT( !maGraphicCache.Count(), "GraphicCache::~GraphicCache(): there are some GraphicObjects in cache" );
 581     DBG_ASSERT( !maDisplayCache.Count(), "GraphicCache::~GraphicCache(): there are some GraphicObjects in display cache" );
 582 }
 583
 584 // -----------------------------------------------------------------------------
 585
 586 void GraphicCache::AddGraphicObject( const GraphicObject& rObj, Graphic& rSubstitute,
 587                                      const ByteString* pID, const GraphicObject* pCopyObj )
 588 {
 589     BOOL bInserted = FALSE;
 590
 591     if( !rObj.IsSwappedOut() &&
 592         ( pID || ( pCopyObj && ( pCopyObj->GetType() != GRAPHIC_NONE ) ) || ( rObj.GetType() != GRAPHIC_NONE ) ) )
 593     {
 594         if( pCopyObj )
 595         {
 596             GraphicCacheEntry* pEntry = static_cast< GraphicCacheEntry* >( maGraphicCache.First() );
 597
 598             while( !bInserted && pEntry )
 599             {
 600                 if( pEntry->HasGraphicObjectReference( *pCopyObj ) )
 601                 {
 602                     pEntry->AddGraphicObjectReference( rObj, rSubstitute );
 603                     bInserted = TRUE;
 604                 }
 605                 else
 606                 {
 607                     pEntry = static_cast< GraphicCacheEntry* >( maGraphicCache.Next() );
 608                 }
 609             }
 610         }
 611
 612         if( !bInserted )
 613         {
 614             GraphicCacheEntry* pEntry = static_cast< GraphicCacheEntry* >( maGraphicCache.First() );
 615             const GraphicID     aID( rObj );
 616
 617             while( !bInserted && pEntry )
 618             {
 619                 const GraphicID& rEntryID = pEntry->GetID();
 620
 621                 if( pID )
 622                 {
 623                     if( rEntryID.GetIDString() == *pID )
 624                     {
 625                         pEntry->TryToSwapIn();
 626
 627                         // since pEntry->TryToSwapIn can modify our current list, we have to
 628                         // iterate from beginning to add a reference to the appropriate
 629                         // CacheEntry object; after this, quickly jump out of the outer iteration
 630                         for( pEntry = static_cast< GraphicCacheEntry* >( maGraphicCache.First() );
 631                              !bInserted && pEntry;
 632                              pEntry = static_cast< GraphicCacheEntry* >( maGraphicCache.Next() ) )
 633                         {
 634                             const GraphicID& rID = pEntry->GetID();
 635
 636                             if( rID.GetIDString() == *pID )
 637                             {
 638                                 pEntry->AddGraphicObjectReference( rObj, rSubstitute );
 639                                 bInserted = TRUE;
 640                             }
 641                         }
 642
 643                         if( !bInserted )
 644                         {
 645                             maGraphicCache.Insert( new GraphicCacheEntry( rObj ), LIST_APPEND );
 646                             bInserted = TRUE;
 647                         }
 648                     }
 649                 }
 650                 else if( rEntryID == aID )
 651                 {
 652                     pEntry->AddGraphicObjectReference( rObj, rSubstitute );
 653                     bInserted = TRUE;
 654                 }
 655
 656                 if( !bInserted )
 657                     pEntry = static_cast< GraphicCacheEntry* >( maGraphicCache.Next() );
 658             }
 659         }
 660     }
 661
 662     if( !bInserted )
 663         maGraphicCache.Insert( new GraphicCacheEntry( rObj ), LIST_APPEND );
 664 }
 665
 666 // -----------------------------------------------------------------------------
 667
 668 void GraphicCache::ReleaseGraphicObject( const GraphicObject& rObj )
 669 {
 670     // Release cached object
 671     GraphicCacheEntry*  pEntry = (GraphicCacheEntry*) maGraphicCache.First();
 672     BOOL                                bRemoved = FALSE;
 673
 674     while( !bRemoved && pEntry )
 675     {
 676         bRemoved = pEntry->ReleaseGraphicObjectReference( rObj );
 677
 678         if( bRemoved )
 679         {
 680             if( 0 == pEntry->GetGraphicObjectReferenceCount() )
 681             {
 682                 // if graphic cache entry has no more references,
 683                 // the corresponding display cache object can be removed
 684                 GraphicDisplayCacheEntry* pDisplayEntry = (GraphicDisplayCacheEntry*) maDisplayCache.First();
 685
 686                 while( pDisplayEntry )
 687                 {
 688                     if( pDisplayEntry->GetReferencedCacheEntry() == pEntry )
 689                     {
 690                         mnUsedDisplaySize -= pDisplayEntry->GetCacheSize();
 691                         maDisplayCache.Remove( pDisplayEntry );
 692                         delete pDisplayEntry;
 693                         pDisplayEntry = (GraphicDisplayCacheEntry*) maDisplayCache.GetCurObject();
 694                     }
 695                     else
 696                         pDisplayEntry = (GraphicDisplayCacheEntry*) maDisplayCache.Next();
 697                 }
 698
 699                 // delete graphic cache entry
 700                 maGraphicCache.Remove( (void*) pEntry );
 701                 delete pEntry;
 702             }
 703         }
 704         else
 705             pEntry = (GraphicCacheEntry*) maGraphicCache.Next();
 706     }
 707
 708     DBG_ASSERT( bRemoved, "GraphicCache::ReleaseGraphicObject(...): GraphicObject not found in cache" );
 709 }
 710
 711 // -----------------------------------------------------------------------------
 712
 713 void GraphicCache::GraphicObjectWasSwappedOut( const GraphicObject& rObj )
 714 {
 715     // notify cache that rObj is swapped out (and can thus be pruned
 716     // from the cache)
 717     GraphicCacheEntry* pEntry = ImplGetCacheEntry( rObj );
 718
 719     if( pEntry )
 720         pEntry->GraphicObjectWasSwappedOut( rObj );
 721 }
 722
 723 // -----------------------------------------------------------------------------
 724
 725 BOOL GraphicCache::FillSwappedGraphicObject( const GraphicObject& rObj, Graphic& rSubstitute )
 726 {
 727     GraphicCacheEntry* pEntry = ImplGetCacheEntry( rObj );
 728
 729     if( !pEntry )
 730         return FALSE;
 731
 732     return pEntry->FillSwappedGraphicObject( rObj, rSubstitute );
 733 }
 734
 735 // -----------------------------------------------------------------------------
 736
 737 void GraphicCache::GraphicObjectWasSwappedIn( const GraphicObject& rObj )
 738 {
 739     GraphicCacheEntry* pEntry = ImplGetCacheEntry( rObj );
 740
 741     if( pEntry )
 742     {
 743         if( pEntry->GetID().IsEmpty() )
 744         {
 745             ReleaseGraphicObject( rObj );
 746             AddGraphicObject( rObj, (Graphic&) rObj.GetGraphic(), NULL, NULL );
 747         }
 748         else
 749             pEntry->GraphicObjectWasSwappedIn( rObj );
 750     }
 751 }
 752
 753 // -----------------------------------------------------------------------------
 754
 755 void GraphicCache::SetMaxDisplayCacheSize( ULONG nNewCacheSize )
 756 {
 757     mnMaxDisplaySize = nNewCacheSize;
 758
 759     if( GetMaxDisplayCacheSize() < GetUsedDisplayCacheSize() )
 760         ImplFreeDisplayCacheSpace( GetUsedDisplayCacheSize() - GetMaxDisplayCacheSize() );
 761 }
 762
 763 // -----------------------------------------------------------------------------
 764
 765 void GraphicCache::SetMaxObjDisplayCacheSize( ULONG nNewMaxObjSize, BOOL bDestroyGreaterCached )
 766 {
 767     const BOOL bDestroy = ( bDestroyGreaterCached && ( nNewMaxObjSize < mnMaxObjDisplaySize ) );
 768
 769     mnMaxObjDisplaySize = Min( nNewMaxObjSize, mnMaxDisplaySize );
 770
 771     if( bDestroy )
 772     {
 773         GraphicDisplayCacheEntry* pCacheObj = (GraphicDisplayCacheEntry*) maDisplayCache.First();
 774
 775         while( pCacheObj )
 776         {
 777             if( pCacheObj->GetCacheSize() > mnMaxObjDisplaySize )
 778             {
 779                 mnUsedDisplaySize -= pCacheObj->GetCacheSize();
 780                 maDisplayCache.Remove( pCacheObj );
 781                 delete pCacheObj;
 782                 pCacheObj = (GraphicDisplayCacheEntry*) maDisplayCache.GetCurObject();
 783             }
 784             else
 785                 pCacheObj = (GraphicDisplayCacheEntry*) maDisplayCache.Next();
 786         }
 787     }
 788 }
 789
 790 // -----------------------------------------------------------------------------
 791
 792 void GraphicCache::SetCacheTimeout( ULONG nTimeoutSeconds )
 793 {
 794     if( mnReleaseTimeoutSeconds != nTimeoutSeconds )
 795     {
 796         GraphicDisplayCacheEntry*   pDisplayEntry = (GraphicDisplayCacheEntry*) maDisplayCache.First();
 797         ::vos::TTimeValue           aReleaseTime;
 798
 799         if( ( mnReleaseTimeoutSeconds = nTimeoutSeconds ) != 0 )
 800         {
 801             osl_getSystemTime( &aReleaseTime );
 802             aReleaseTime.addTime( ::vos::TTimeValue( nTimeoutSeconds, 0 ) );
 803         }
 804
 805         while( pDisplayEntry )
 806         {
 807             pDisplayEntry->SetReleaseTime( aReleaseTime );
 808             pDisplayEntry = (GraphicDisplayCacheEntry*) maDisplayCache.Next();
 809         }
 810     }
 811 }
 812
 813 // -----------------------------------------------------------------------------
 814
 815 void GraphicCache::ClearDisplayCache()
 816 {
 817     for( void* pObj = maDisplayCache.First(); pObj; pObj = maDisplayCache.Next() )
 818         delete (GraphicDisplayCacheEntry*) pObj;
 819
 820     maDisplayCache.Clear();
 821     mnUsedDisplaySize = 0UL;
 822 }
 823
 824 // -----------------------------------------------------------------------------
 825
 826 BOOL GraphicCache::IsDisplayCacheable( OutputDevice* pOut, const Point& rPt, const Size& rSz,
 827                                        const GraphicObject& rObj, const GraphicAttr& rAttr ) const
 828 {
 829     return( GraphicDisplayCacheEntry::GetNeededSize( pOut, rPt, rSz, rObj, rAttr ) <=
 830             GetMaxObjDisplayCacheSize() );
 831 }
 832
 833 // -----------------------------------------------------------------------------
 834
 835 BOOL GraphicCache::IsInDisplayCache( OutputDevice* pOut, const Point& rPt, const Size& rSz,
 836                                      const GraphicObject& rObj, const GraphicAttr& rAttr ) const
 837 {
 838     const Point                                 aPtPixel( pOut->LogicToPixel( rPt ) );
 839     const Size                                  aSzPixel( pOut->LogicToPixel( rSz ) );
 840     const GraphicCacheEntry*    pCacheEntry = ( (GraphicCache*) this )->ImplGetCacheEntry( rObj );
 841     //GraphicDisplayCacheEntry* pDisplayEntry = (GraphicDisplayCacheEntry*) ( (GraphicCache*) this )->maDisplayCache.First(); // -Wall removed ....
 842     BOOL                                                bFound = FALSE;
 843
 844     if( pCacheEntry )
 845     {
 846         for( long i = 0, nCount = maDisplayCache.Count(); !bFound && ( i < nCount ); i++ )
 847             if( ( (GraphicDisplayCacheEntry*) maDisplayCache.GetObject( i ) )->Matches( pOut, aPtPixel, aSzPixel, pCacheEntry, rAttr ) )
 848                 bFound = TRUE;
 849     }
 850
 851     return bFound;
 852 }
 853
 854 // -----------------------------------------------------------------------------
 855
 856 ByteString GraphicCache::GetUniqueID( const GraphicObject& rObj ) const
 857 {
 858     ByteString                  aRet;
 859     GraphicCacheEntry*  pEntry = ( (GraphicCache*) this )->ImplGetCacheEntry( rObj );
 860
 861     // ensure that the entry is correctly initialized (it has to be read at least once)
 862     if( pEntry && pEntry->GetID().IsEmpty() )
 863         pEntry->TryToSwapIn();
 864
 865     // do another call to ImplGetCacheEntry in case of modified entry list
 866     pEntry = ( (GraphicCache*) this )->ImplGetCacheEntry( rObj );
 867
 868     if( pEntry )
 869         aRet = pEntry->GetID().GetIDString();
 870
 871     return aRet;
 872 }
 873
 874 // -----------------------------------------------------------------------------
 875
 876 BOOL GraphicCache::CreateDisplayCacheObj( OutputDevice* pOut, const Point& rPt, const Size& rSz,
 877                                           const GraphicObject& rObj, const GraphicAttr& rAttr,
 878                                           const BitmapEx& rBmpEx )
 879 {
 880     const ULONG nNeededSize = GraphicDisplayCacheEntry::GetNeededSize( pOut, rPt, rSz, rObj, rAttr );
 881     BOOL                bRet = FALSE;
 882
 883     if( nNeededSize <= GetMaxObjDisplayCacheSize() )
 884     {
 885         if( nNeededSize > GetFreeDisplayCacheSize() )
 886             ImplFreeDisplayCacheSpace( nNeededSize - GetFreeDisplayCacheSize() );
 887
 888         GraphicDisplayCacheEntry* pNewEntry = new GraphicDisplayCacheEntry( ImplGetCacheEntry( rObj ),
 889                                                                             pOut, rPt, rSz, rObj, rAttr, rBmpEx );
 890
 891         if( GetCacheTimeout() )
 892         {
 893             ::vos::TTimeValue aReleaseTime;
 894
 895             osl_getSystemTime( &aReleaseTime );
 896             aReleaseTime.addTime( ::vos::TTimeValue( GetCacheTimeout(), 0 ) );
 897             pNewEntry->SetReleaseTime( aReleaseTime );
 898         }
 899
 900         maDisplayCache.Insert( pNewEntry, LIST_APPEND );
 901         mnUsedDisplaySize += pNewEntry->GetCacheSize();
 902         bRet = TRUE;
 903     }
 904
 905     return bRet;
 906 }
 907
 908 // -----------------------------------------------------------------------------
 909
 910 BOOL GraphicCache::CreateDisplayCacheObj( OutputDevice* pOut, const Point& rPt, const Size& rSz,
 911                                           const GraphicObject& rObj, const GraphicAttr& rAttr,
 912                                           const GDIMetaFile& rMtf )
 913 {
 914     const ULONG nNeededSize = GraphicDisplayCacheEntry::GetNeededSize( pOut, rPt, rSz, rObj, rAttr );
 915     BOOL                bRet = FALSE;
 916
 917     if( nNeededSize <= GetMaxObjDisplayCacheSize() )
 918     {
 919         if( nNeededSize > GetFreeDisplayCacheSize() )
 920             ImplFreeDisplayCacheSpace( nNeededSize - GetFreeDisplayCacheSize() );
 921
 922         GraphicDisplayCacheEntry* pNewEntry = new GraphicDisplayCacheEntry( ImplGetCacheEntry( rObj ),
 923                                                                             pOut, rPt, rSz, rObj, rAttr, rMtf );
 924
 925         if( GetCacheTimeout() )
 926         {
 927             ::vos::TTimeValue aReleaseTime;
 928
 929             osl_getSystemTime( &aReleaseTime );
 930             aReleaseTime.addTime( ::vos::TTimeValue( GetCacheTimeout(), 0 ) );
 931             pNewEntry->SetReleaseTime( aReleaseTime );
 932         }
 933
 934         maDisplayCache.Insert( pNewEntry, LIST_APPEND );
 935         mnUsedDisplaySize += pNewEntry->GetCacheSize();
 936         bRet = TRUE;
 937     }
 938
 939     return bRet;
 940 }
 941
 942 // -----------------------------------------------------------------------------
 943
 944 BOOL GraphicCache::DrawDisplayCacheObj( OutputDevice* pOut, const Point& rPt, const Size& rSz,
 945                                         const GraphicObject& rObj, const GraphicAttr& rAttr )
 946 {
 947     const Point                                 aPtPixel( pOut->LogicToPixel( rPt ) );
 948     const Size                                  aSzPixel( pOut->LogicToPixel( rSz ) );
 949     const GraphicCacheEntry*    pCacheEntry = ImplGetCacheEntry( rObj );
 950     GraphicDisplayCacheEntry*   pDisplayCacheEntry = (GraphicDisplayCacheEntry*) maDisplayCache.First();
 951     BOOL                                                bRet = FALSE;
 952
 953     while( !bRet && pDisplayCacheEntry )
 954     {
 955         if( pDisplayCacheEntry->Matches( pOut, aPtPixel, aSzPixel, pCacheEntry, rAttr ) )
 956         {
 957             ::vos::TTimeValue aReleaseTime;
 958
 959             // put found object at last used position
 960             maDisplayCache.Insert( maDisplayCache.Remove( pDisplayCacheEntry ), LIST_APPEND );
 961
 962             if( GetCacheTimeout() )
 963             {
 964                 osl_getSystemTime( &aReleaseTime );
 965                 aReleaseTime.addTime( ::vos::TTimeValue( GetCacheTimeout(), 0 ) );
 966             }
 967
 968             pDisplayCacheEntry->SetReleaseTime( aReleaseTime );
 969             bRet = TRUE;
 970         }
 971         else
 972             pDisplayCacheEntry = (GraphicDisplayCacheEntry*) maDisplayCache.Next();
 973     }
 974
 975     if( bRet )
 976         pDisplayCacheEntry->Draw( pOut, rPt, rSz );
 977
 978     return bRet;
 979 }
 980
 981 // -----------------------------------------------------------------------------
 982
 983 BOOL GraphicCache::ImplFreeDisplayCacheSpace( ULONG nSizeToFree )
 984 {
 985     ULONG nFreedSize = 0UL;
 986
 987     if( nSizeToFree )
 988     {
 989         void* pObj = maDisplayCache.First();
 990
 991         if( nSizeToFree > mnUsedDisplaySize )
 992             nSizeToFree = mnUsedDisplaySize;
 993
 994         while( pObj )
 995         {
 996             GraphicDisplayCacheEntry* pCacheObj = (GraphicDisplayCacheEntry*) pObj;
 997
 998             nFreedSize += pCacheObj->GetCacheSize();
 999             mnUsedDisplaySize -= pCacheObj->GetCacheSize();
1000             maDisplayCache.Remove( pObj );
1001             delete pCacheObj;
1002
1003             if( nFreedSize >= nSizeToFree )
1004                 break;
1005             else
1006                 pObj = maDisplayCache.GetCurObject();
1007         }
1008     }
1009
1010     return( nFreedSize >= nSizeToFree );
1011 }
1012
1013 // -----------------------------------------------------------------------------
1014
1015 GraphicCacheEntry* GraphicCache::ImplGetCacheEntry( const GraphicObject& rObj )
1016 {
1017     GraphicCacheEntry* pRet = NULL;
1018
1019     for( void* pObj = maGraphicCache.First(); !pRet && pObj; pObj = maGraphicCache.Next() )
1020         if( ( (GraphicCacheEntry*) pObj )->HasGraphicObjectReference( rObj ) )
1021             pRet = (GraphicCacheEntry*) pObj;
1022
1023     return pRet;
1024 }
1025
1026 // -----------------------------------------------------------------------------
1027
1028 IMPL_LINK( GraphicCache, ReleaseTimeoutHdl, Timer*, pTimer )
1029 {
1030     pTimer->Stop();
1031
1032     ::vos::TTimeValue           aCurTime;
1033     GraphicDisplayCacheEntry*   pDisplayEntry = (GraphicDisplayCacheEntry*) maDisplayCache.First();
1034
1035     osl_getSystemTime( &aCurTime );
1036
1037     while( pDisplayEntry )
1038     {
1039         const ::vos::TTimeValue& rReleaseTime = pDisplayEntry->GetReleaseTime();
1040
1041         if( !rReleaseTime.isEmpty() && ( rReleaseTime < aCurTime ) )
1042         {
1043             mnUsedDisplaySize -= pDisplayEntry->GetCacheSize();
1044             maDisplayCache.Remove( pDisplayEntry );
1045             delete pDisplayEntry;
1046             pDisplayEntry = (GraphicDisplayCacheEntry*) maDisplayCache.GetCurObject();
1047         }
1048         else
1049             pDisplayEntry = (GraphicDisplayCacheEntry*) maDisplayCache.Next();
1050     }
1051
1052     pTimer->Start();
1053
1054     return 0;
1055 }