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