gridcontrol_03: merge with DEV300_m75

1 files changed, 1062 insertions, 0 deletions

diff --git a/svtools/source/graphic/grfcache.cxx b/svtools/source/graphic/grfcache.cxx
new file mode 100644
index 000000000000..41240c95d113
--- /dev/null
+++ b/svtools/source/graphic/grfcache.cxx
@@ -0,0 +1,1062 @@
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2000, 2010 Oracle and/or its affiliates.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org.  If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+
+// MARKER(update_precomp.py): autogen include statement, do not remove
+#include "precompiled_svtools.hxx"
+
+#include <vos/timer.hxx>
+#include <tools/debug.hxx>
+#include <vcl/outdev.hxx>
+#include <tools/poly.hxx>
+#include "grfcache.hxx"
+
+#include <memory>
+
+// -----------
+// - Defines -
+// -----------
+
+#define RELEASE_TIMEOUT 10000
+#define MAX_BMP_EXTENT  4096
+
+// -----------
+// - statics -
+// -----------
+
+static const char aHexData[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
+
+// -------------
+// - GraphicID -
+// -------------
+
+class GraphicID
+{
+private:
+
+    sal_uInt32  mnID1;
+    sal_uInt32  mnID2;
+    sal_uInt32  mnID3;
+    sal_uInt32  mnID4;
+
+                GraphicID();
+
+public:
+
+
+                GraphicID( const GraphicObject& rObj );
+                ~GraphicID() {}
+
+    BOOL        operator==( const GraphicID& rID ) const
+                {
+                    return( rID.mnID1 == mnID1 && rID.mnID2 == mnID2 &&
+                            rID.mnID3 == mnID3 && rID.mnID4 == mnID4 );
+                }
+
+    ByteString  GetIDString() const;
+    BOOL        IsEmpty() const { return( 0 == mnID4 ); }
+};
+
+// -----------------------------------------------------------------------------
+
+GraphicID::GraphicID( const GraphicObject& rObj )
+{
+    const Graphic& rGraphic = rObj.GetGraphic();
+
+    mnID1 = ( (ULONG) rGraphic.GetType() ) << 28;
+
+    switch( rGraphic.GetType() )
+    {
+        case( GRAPHIC_BITMAP ):
+        {
+            if( rGraphic.IsAnimated() )
+            {
+                const Animation aAnimation( rGraphic.GetAnimation() );
+
+                mnID1 |= ( aAnimation.Count() & 0x0fffffff );
+                mnID2 = aAnimation.GetDisplaySizePixel().Width();
+                mnID3 = aAnimation.GetDisplaySizePixel().Height();
+                mnID4 = rGraphic.GetChecksum();
+            }
+            else
+            {
+                const BitmapEx aBmpEx( rGraphic.GetBitmapEx() );
+
+                mnID1 |= ( ( ( (ULONG) aBmpEx.GetTransparentType() << 8 ) | ( aBmpEx.IsAlpha() ? 1 : 0 ) ) & 0x0fffffff );
+                mnID2 = aBmpEx.GetSizePixel().Width();
+                mnID3 = aBmpEx.GetSizePixel().Height();
+                mnID4 = rGraphic.GetChecksum();
+            }
+        }
+        break;
+
+        case( GRAPHIC_GDIMETAFILE ):
+        {
+            const GDIMetaFile aMtf( rGraphic.GetGDIMetaFile() );
+
+            mnID1 |= ( aMtf.GetActionCount() & 0x0fffffff );
+            mnID2 = aMtf.GetPrefSize().Width();
+            mnID3 = aMtf.GetPrefSize().Height();
+            mnID4 = rGraphic.GetChecksum();
+        }
+        break;
+
+        default:
+            mnID2 = mnID3 = mnID4 = 0;
+        break;
+    }
+}
+
+// -----------------------------------------------------------------------------
+
+ByteString GraphicID::GetIDString() const
+{
+    ByteString  aHexStr;
+    sal_Char*   pStr = aHexStr.AllocBuffer( 32 );
+    sal_Int32   nShift;
+
+    for( nShift = 28; nShift >= 0; nShift -= 4 )
+        *pStr++ = aHexData[ ( mnID1 >> (sal_uInt32) nShift ) & 0xf ];
+
+    for( nShift = 28; nShift >= 0; nShift -= 4 )
+        *pStr++ = aHexData[ ( mnID2 >> (sal_uInt32) nShift ) & 0xf ];
+
+    for( nShift = 28; nShift >= 0; nShift -= 4 )
+        *pStr++ = aHexData[ ( mnID3 >> (sal_uInt32) nShift ) & 0xf ];
+
+    for( nShift = 28; nShift >= 0; nShift -= 4 )
+        *pStr++ = aHexData[ ( mnID4 >> (sal_uInt32) nShift ) & 0xf ];
+
+    return aHexStr;
+}
+
+// ---------------------
+// - GraphicCacheEntry -
+// ---------------------
+
+class GraphicCacheEntry
+{
+private:
+
+    List                maGraphicObjectList;
+    GraphicID           maID;
+    GfxLink             maGfxLink;
+    BitmapEx*           mpBmpEx;
+    GDIMetaFile*        mpMtf;
+    Animation*          mpAnimation;
+    BOOL                mbSwappedAll;
+
+    BOOL                ImplInit( const GraphicObject& rObj );
+    BOOL                ImplMatches( const GraphicObject& rObj ) const { return( GraphicID( rObj ) == maID ); }
+    void                ImplFillSubstitute( Graphic& rSubstitute );
+
+public:
+
+                        GraphicCacheEntry( const GraphicObject& rObj );
+                        ~GraphicCacheEntry();
+
+    const GraphicID&    GetID() const { return maID; }
+
+    void                AddGraphicObjectReference( const GraphicObject& rObj, Graphic& rSubstitute );
+    BOOL                ReleaseGraphicObjectReference( const GraphicObject& rObj );
+    ULONG               GetGraphicObjectReferenceCount() { return maGraphicObjectList.Count(); }
+    BOOL                HasGraphicObjectReference( const GraphicObject& rObj );
+
+    void                TryToSwapIn();
+    void                GraphicObjectWasSwappedOut( const GraphicObject& rObj );
+    BOOL                FillSwappedGraphicObject( const GraphicObject& rObj, Graphic& rSubstitute );
+    void                GraphicObjectWasSwappedIn( const GraphicObject& rObj );
+};
+
+// -----------------------------------------------------------------------------
+
+GraphicCacheEntry::GraphicCacheEntry( const GraphicObject& rObj ) :
+    maID            ( rObj ),
+    mpBmpEx         ( NULL ),
+    mpMtf           ( NULL ),
+    mpAnimation     ( NULL ),
+    mbSwappedAll    ( !ImplInit( rObj ) )
+{
+    maGraphicObjectList.Insert( (void*) &rObj, LIST_APPEND );
+}
+
+// -----------------------------------------------------------------------------
+
+GraphicCacheEntry::~GraphicCacheEntry()
+{
+    DBG_ASSERT( !maGraphicObjectList.Count(), "GraphicCacheEntry::~GraphicCacheEntry(): Not all GraphicObjects are removed from this entry" );
+
+    delete mpBmpEx;
+    delete mpMtf;
+    delete mpAnimation;
+}
+
+// -----------------------------------------------------------------------------
+
+BOOL GraphicCacheEntry::ImplInit( const GraphicObject& rObj )
+{
+    BOOL bRet;
+
+    if( !rObj.IsSwappedOut() )
+    {
+        const Graphic& rGraphic = rObj.GetGraphic();
+
+        if( mpBmpEx )
+            delete mpBmpEx, mpBmpEx = NULL;
+
+        if( mpMtf )
+            delete mpMtf, mpMtf = NULL;
+
+        if( mpAnimation )
+            delete mpAnimation, mpAnimation = NULL;
+
+        switch( rGraphic.GetType() )
+        {
+            case( GRAPHIC_BITMAP ):
+            {
+                if( rGraphic.IsAnimated() )
+                    mpAnimation = new Animation( rGraphic.GetAnimation() );
+                else
+                    mpBmpEx = new BitmapEx( rGraphic.GetBitmapEx() );
+            }
+            break;
+
+            case( GRAPHIC_GDIMETAFILE ):
+            {
+                mpMtf = new GDIMetaFile( rGraphic.GetGDIMetaFile() );
+            }
+            break;
+
+            default:
+                DBG_ASSERT( GetID().IsEmpty(), "GraphicCacheEntry::ImplInit: Could not initialize graphic! (=>KA)" );
+            break;
+        }
+
+        if( rGraphic.IsLink() )
+            maGfxLink = ( (Graphic&) rGraphic ).GetLink();
+        else
+            maGfxLink = GfxLink();
+
+        bRet = TRUE;
+    }
+    else
+        bRet = FALSE;
+
+    return bRet;
+}
+
+// -----------------------------------------------------------------------------
+
+void GraphicCacheEntry::ImplFillSubstitute( Graphic& rSubstitute )
+{
+    // create substitute for graphic;
+    const Size          aPrefSize( rSubstitute.GetPrefSize() );
+    const MapMode       aPrefMapMode( rSubstitute.GetPrefMapMode() );
+    const Link          aAnimationNotifyHdl( rSubstitute.GetAnimationNotifyHdl() );
+    const String        aDocFileName( rSubstitute.GetDocFileName() );
+    const ULONG         nDocFilePos = rSubstitute.GetDocFilePos();
+    const GraphicType   eOldType = rSubstitute.GetType();
+    const BOOL          bDefaultType = ( rSubstitute.GetType() == GRAPHIC_DEFAULT );
+
+    if( rSubstitute.IsLink() && ( GFX_LINK_TYPE_NONE == maGfxLink.GetType() ) )
+        maGfxLink = rSubstitute.GetLink();
+
+    if( mpBmpEx )
+        rSubstitute = *mpBmpEx;
+    else if( mpAnimation )
+        rSubstitute = *mpAnimation;
+    else if( mpMtf )
+        rSubstitute = *mpMtf;
+    else
+        rSubstitute.Clear();
+
+    if( eOldType != GRAPHIC_NONE )
+    {
+        rSubstitute.SetPrefSize( aPrefSize );
+        rSubstitute.SetPrefMapMode( aPrefMapMode );
+        rSubstitute.SetAnimationNotifyHdl( aAnimationNotifyHdl );
+        rSubstitute.SetDocFileName( aDocFileName, nDocFilePos );
+    }
+
+    if( GFX_LINK_TYPE_NONE != maGfxLink.GetType() )
+        rSubstitute.SetLink( maGfxLink );
+
+    if( bDefaultType )
+        rSubstitute.SetDefaultType();
+}
+
+// -----------------------------------------------------------------------------
+
+void GraphicCacheEntry::AddGraphicObjectReference( const GraphicObject& rObj, Graphic& rSubstitute )
+{
+    if( mbSwappedAll )
+        mbSwappedAll = !ImplInit( rObj );
+
+    ImplFillSubstitute( rSubstitute );
+    maGraphicObjectList.Insert( (void*) &rObj, LIST_APPEND );
+}
+
+// -----------------------------------------------------------------------------
+
+BOOL GraphicCacheEntry::ReleaseGraphicObjectReference( const GraphicObject& rObj )
+{
+    BOOL bRet = FALSE;
+
+    for( void* pObj = maGraphicObjectList.First(); !bRet && pObj; pObj = maGraphicObjectList.Next() )
+    {
+        if( &rObj == (GraphicObject*) pObj )
+        {
+            maGraphicObjectList.Remove( pObj );
+            bRet = TRUE;
+        }
+    }
+
+    return bRet;
+}
+
+// -----------------------------------------------------------------------------
+
+BOOL GraphicCacheEntry::HasGraphicObjectReference( const GraphicObject& rObj )
+{
+    BOOL bRet = FALSE;
+
+    for( void* pObj = maGraphicObjectList.First(); !bRet && pObj; pObj = maGraphicObjectList.Next() )
+        if( &rObj == (GraphicObject*) pObj )
+            bRet = TRUE;
+
+    return bRet;
+}
+
+// -----------------------------------------------------------------------------
+
+void GraphicCacheEntry::TryToSwapIn()
+{
+    if( mbSwappedAll && maGraphicObjectList.Count() )
+        ( (GraphicObject*) maGraphicObjectList.First() )->FireSwapInRequest();
+}
+
+// -----------------------------------------------------------------------------
+
+void GraphicCacheEntry::GraphicObjectWasSwappedOut( const GraphicObject& /*rObj*/ )
+{
+    mbSwappedAll = TRUE;
+
+    for( void* pObj = maGraphicObjectList.First(); mbSwappedAll && pObj; pObj = maGraphicObjectList.Next() )
+        if( !( (GraphicObject*) pObj )->IsSwappedOut() )
+            mbSwappedAll = FALSE;
+
+    if( mbSwappedAll )
+    {
+        delete mpBmpEx, mpBmpEx = NULL;
+        delete mpMtf, mpMtf = NULL;
+        delete mpAnimation, mpAnimation = NULL;
+    }
+}
+
+// -----------------------------------------------------------------------------
+
+BOOL GraphicCacheEntry::FillSwappedGraphicObject( const GraphicObject& rObj, Graphic& rSubstitute )
+{
+    BOOL bRet;
+
+    if( !mbSwappedAll && rObj.IsSwappedOut() )
+    {
+        ImplFillSubstitute( rSubstitute );
+        bRet = TRUE;
+    }
+    else
+        bRet = FALSE;
+
+    return bRet;
+}
+
+// -----------------------------------------------------------------------------
+
+void GraphicCacheEntry::GraphicObjectWasSwappedIn( const GraphicObject& rObj )
+{
+    if( mbSwappedAll )
+        mbSwappedAll = !ImplInit( rObj );
+}
+
+// ----------------------------
+// - GraphicDisplayCacheEntry -
+// ----------------------------
+
+class GraphicDisplayCacheEntry
+{
+private:
+
+    ::vos::TTimeValue           maReleaseTime;
+    const GraphicCacheEntry*    mpRefCacheEntry;
+    GDIMetaFile*                mpMtf;
+    BitmapEx*                   mpBmpEx;
+    GraphicAttr                 maAttr;
+    Size                        maOutSizePix;
+    ULONG                       mnCacheSize;
+    ULONG                       mnOutDevDrawMode;
+    USHORT                      mnOutDevBitCount;
+
+public:
+
+    static ULONG                GetNeededSize( OutputDevice* pOut, const Point& rPt, const Size& rSz,
+                                               const GraphicObject& rObj, const GraphicAttr& rAttr );
+
+public:
+
+                                GraphicDisplayCacheEntry( const GraphicCacheEntry* pRefCacheEntry,
+                                                          OutputDevice* pOut, const Point& rPt, const Size& rSz,
+                                                          const GraphicObject& rObj, const GraphicAttr& rAttr,
+                                                          const BitmapEx& rBmpEx ) :
+                                    mpRefCacheEntry( pRefCacheEntry ),
+                                    mpMtf( NULL ), mpBmpEx( new BitmapEx( rBmpEx ) ),
+                                    maAttr( rAttr ), maOutSizePix( pOut->LogicToPixel( rSz ) ),
+                                    mnCacheSize( GetNeededSize( pOut, rPt, rSz, rObj, rAttr ) ),
+                                    mnOutDevDrawMode( pOut->GetDrawMode() ),
+                                    mnOutDevBitCount( pOut->GetBitCount() )
+                                    {
+                                    }
+
+                                GraphicDisplayCacheEntry( const GraphicCacheEntry* pRefCacheEntry,
+                                                          OutputDevice* pOut, const Point& rPt, const Size& rSz,
+                                                          const GraphicObject& rObj, const GraphicAttr& rAttr,
+                                                          const GDIMetaFile& rMtf ) :
+                                    mpRefCacheEntry( pRefCacheEntry ),
+                                    mpMtf( new GDIMetaFile( rMtf ) ), mpBmpEx( NULL ),
+                                    maAttr( rAttr ), maOutSizePix( pOut->LogicToPixel( rSz ) ),
+                                    mnCacheSize( GetNeededSize( pOut, rPt, rSz, rObj, rAttr ) ),
+                                    mnOutDevDrawMode( pOut->GetDrawMode() ),
+                                    mnOutDevBitCount( pOut->GetBitCount() )
+                                    {
+                                    }
+
+
+                                ~GraphicDisplayCacheEntry();
+
+    const GraphicAttr&          GetAttr() const { return maAttr; }
+    const Size&                 GetOutputSizePixel() const { return maOutSizePix; }
+    ULONG                   GetCacheSize() const { return mnCacheSize; }
+    const GraphicCacheEntry*    GetReferencedCacheEntry() const { return mpRefCacheEntry; }
+    ULONG                   GetOutDevDrawMode() const { return mnOutDevDrawMode; }
+    USHORT              GetOutDevBitCount() const { return mnOutDevBitCount; }
+
+    void                        SetReleaseTime( const ::vos::TTimeValue& rReleaseTime ) { maReleaseTime = rReleaseTime; }
+    const ::vos::TTimeValue&    GetReleaseTime() const { return maReleaseTime; }
+
+    BOOL                        Matches( OutputDevice* pOut, const Point& /*rPtPixel*/, const Size& rSzPixel,
+                                         const GraphicCacheEntry* pCacheEntry, const GraphicAttr& rAttr ) const
+                                {
+                                    // #i46805# Additional match
+                                    // criteria: outdev draw mode and
+                                    // bit count. One cannot reuse
+                                    // this cache object, if it's
+                                    // e.g. generated for
+                                    // DRAWMODE_GRAYBITMAP.
+                                    return( ( pCacheEntry == mpRefCacheEntry ) &&
+                                            ( maAttr == rAttr ) &&
+                                            ( ( maOutSizePix == rSzPixel ) || ( !maOutSizePix.Width() && !maOutSizePix.Height() ) ) &&
+                                            ( pOut->GetBitCount() == mnOutDevBitCount ) &&
+                                            ( pOut->GetDrawMode() == mnOutDevDrawMode ) );
+                                }
+
+    void                        Draw( OutputDevice* pOut, const Point& rPt, const Size& rSz ) const;
+};
+
+// -----------------------------------------------------------------------------
+
+ULONG GraphicDisplayCacheEntry::GetNeededSize( OutputDevice* pOut, const Point& /*rPt*/, const Size& rSz,
+                                               const GraphicObject& rObj, const GraphicAttr& rAttr )
+{
+    const Graphic&      rGraphic = rObj.GetGraphic();
+    const GraphicType   eType = rGraphic.GetType();
+    ULONG               nNeededSize;
+
+    if( GRAPHIC_BITMAP == eType )
+    {
+        const Size aOutSizePix( pOut->LogicToPixel( rSz ) );
+        const long nBitCount = pOut->GetBitCount();
+
+        if( ( aOutSizePix.Width() > MAX_BMP_EXTENT ) ||
+            ( aOutSizePix.Height() > MAX_BMP_EXTENT ) )
+        {
+            nNeededSize = ULONG_MAX;
+        }
+        else if( nBitCount )
+        {
+            nNeededSize = aOutSizePix.Width() * aOutSizePix.Height() * nBitCount / 8;
+
+            if( rObj.IsTransparent() || ( rAttr.GetRotation() % 3600 ) )
+                nNeededSize += nNeededSize / nBitCount;
+        }
+        else
+        {
+             DBG_ERROR( "GraphicDisplayCacheEntry::GetNeededSize(): pOut->GetBitCount() == 0" );
+            nNeededSize = 256000;
+        }
+    }
+    else if( GRAPHIC_GDIMETAFILE == eType )
+        nNeededSize = rGraphic.GetSizeBytes();
+    else
+        nNeededSize = 0;
+
+    return nNeededSize;
+}
+
+// -----------------------------------------------------------------------------
+
+GraphicDisplayCacheEntry::~GraphicDisplayCacheEntry()
+{
+    if( mpMtf )
+        delete mpMtf;
+
+    if( mpBmpEx )
+        delete mpBmpEx;
+}
+
+// -----------------------------------------------------------------------------
+
+void GraphicDisplayCacheEntry::Draw( OutputDevice* pOut, const Point& rPt, const Size& rSz ) const
+{
+    if( mpMtf )
+        GraphicManager::ImplDraw( pOut, rPt, rSz, *mpMtf, maAttr );
+    else if( mpBmpEx )
+    {
+        if( maAttr.IsRotated() )
+        {
+            Polygon aPoly( Rectangle( rPt, rSz ) );
+
+            aPoly.Rotate( rPt, maAttr.GetRotation() % 3600 );
+            const Rectangle aRotBoundRect( aPoly.GetBoundRect() );
+            pOut->DrawBitmapEx( aRotBoundRect.TopLeft(), aRotBoundRect.GetSize(), *mpBmpEx );
+        }
+        else
+            pOut->DrawBitmapEx( rPt, rSz, *mpBmpEx );
+    }
+}
+
+// -----------------------
+// - GraphicCache -
+// -----------------------
+
+GraphicCache::GraphicCache( GraphicManager& rMgr, ULONG nDisplayCacheSize, ULONG nMaxObjDisplayCacheSize ) :
+    mrMgr                   ( rMgr ),
+    mnReleaseTimeoutSeconds ( 0UL ),
+    mnMaxDisplaySize        ( nDisplayCacheSize ),
+    mnMaxObjDisplaySize     ( nMaxObjDisplayCacheSize ),
+    mnUsedDisplaySize       ( 0UL )
+{
+    maReleaseTimer.SetTimeoutHdl( LINK( this, GraphicCache, ReleaseTimeoutHdl ) );
+    maReleaseTimer.SetTimeout( RELEASE_TIMEOUT );
+    maReleaseTimer.Start();
+}
+
+// -----------------------------------------------------------------------------
+
+GraphicCache::~GraphicCache()
+{
+    DBG_ASSERT( !maGraphicCache.Count(), "GraphicCache::~GraphicCache(): there are some GraphicObjects in cache" );
+    DBG_ASSERT( !maDisplayCache.Count(), "GraphicCache::~GraphicCache(): there are some GraphicObjects in display cache" );
+}
+
+// -----------------------------------------------------------------------------
+
+void GraphicCache::AddGraphicObject( const GraphicObject& rObj, Graphic& rSubstitute,
+                                     const ByteString* pID, const GraphicObject* pCopyObj )
+{
+    BOOL bInserted = FALSE;
+
+    if( !rObj.IsSwappedOut() &&
+        ( pID || ( pCopyObj && ( pCopyObj->GetType() != GRAPHIC_NONE ) ) || ( rObj.GetType() != GRAPHIC_NONE ) ) )
+    {
+        if( pCopyObj )
+        {
+            GraphicCacheEntry* pEntry = static_cast< GraphicCacheEntry* >( maGraphicCache.First() );
+
+            while( !bInserted && pEntry )
+            {
+                if( pEntry->HasGraphicObjectReference( *pCopyObj ) )
+                {
+                    pEntry->AddGraphicObjectReference( rObj, rSubstitute );
+                    bInserted = TRUE;
+                }
+                else
+                {
+                    pEntry = static_cast< GraphicCacheEntry* >( maGraphicCache.Next() );
+                }
+            }
+        }
+
+        if( !bInserted )
+        {
+            GraphicCacheEntry* pEntry = static_cast< GraphicCacheEntry* >( maGraphicCache.First() );
+            ::std::auto_ptr< GraphicID > apID;
+
+            if( !pID )
+            {
+                apID.reset( new GraphicID( rObj ) );
+            }
+
+            while( !bInserted && pEntry )
+            {
+                const GraphicID& rEntryID = pEntry->GetID();
+
+                if( pID )
+                {
+                    if( rEntryID.GetIDString() == *pID )
+                    {
+                        pEntry->TryToSwapIn();
+
+                        // since pEntry->TryToSwapIn can modify our current list, we have to
+                        // iterate from beginning to add a reference to the appropriate
+                        // CacheEntry object; after this, quickly jump out of the outer iteration
+                        for( pEntry = static_cast< GraphicCacheEntry* >( maGraphicCache.First() );
+                             !bInserted && pEntry;
+                             pEntry = static_cast< GraphicCacheEntry* >( maGraphicCache.Next() ) )
+                        {
+                            const GraphicID& rID = pEntry->GetID();
+
+                            if( rID.GetIDString() == *pID )
+                            {
+                                pEntry->AddGraphicObjectReference( rObj, rSubstitute );
+                                bInserted = TRUE;
+                            }
+                        }
+
+                        if( !bInserted )
+                        {
+                            maGraphicCache.Insert( new GraphicCacheEntry( rObj ), LIST_APPEND );
+                            bInserted = TRUE;
+                        }
+                    }
+                }
+                else
+                {
+                    if( rEntryID == *apID )
+                    {
+                        pEntry->AddGraphicObjectReference( rObj, rSubstitute );
+                        bInserted = TRUE;
+                    }
+                }
+
+                if( !bInserted )
+                    pEntry = static_cast< GraphicCacheEntry* >( maGraphicCache.Next() );
+            }
+        }
+    }
+
+    if( !bInserted )
+        maGraphicCache.Insert( new GraphicCacheEntry( rObj ), LIST_APPEND );
+}
+
+// -----------------------------------------------------------------------------
+
+void GraphicCache::ReleaseGraphicObject( const GraphicObject& rObj )
+{
+    // Release cached object
+    GraphicCacheEntry*  pEntry = (GraphicCacheEntry*) maGraphicCache.First();
+    BOOL                bRemoved = FALSE;
+
+    while( !bRemoved && pEntry )
+    {
+        bRemoved = pEntry->ReleaseGraphicObjectReference( rObj );
+
+        if( bRemoved )
+        {
+            if( 0 == pEntry->GetGraphicObjectReferenceCount() )
+            {
+                // if graphic cache entry has no more references,
+                // the corresponding display cache object can be removed
+                GraphicDisplayCacheEntry* pDisplayEntry = (GraphicDisplayCacheEntry*) maDisplayCache.First();
+
+                while( pDisplayEntry )
+                {
+                    if( pDisplayEntry->GetReferencedCacheEntry() == pEntry )
+                    {
+                        mnUsedDisplaySize -= pDisplayEntry->GetCacheSize();
+                        maDisplayCache.Remove( pDisplayEntry );
+                        delete pDisplayEntry;
+                        pDisplayEntry = (GraphicDisplayCacheEntry*) maDisplayCache.GetCurObject();
+                    }
+                    else
+                        pDisplayEntry = (GraphicDisplayCacheEntry*) maDisplayCache.Next();
+                }
+
+                // delete graphic cache entry
+                maGraphicCache.Remove( (void*) pEntry );
+                delete pEntry;
+            }
+        }
+        else
+            pEntry = (GraphicCacheEntry*) maGraphicCache.Next();
+    }
+
+    DBG_ASSERT( bRemoved, "GraphicCache::ReleaseGraphicObject(...): GraphicObject not found in cache" );
+}
+
+// -----------------------------------------------------------------------------
+
+void GraphicCache::GraphicObjectWasSwappedOut( const GraphicObject& rObj )
+{
+    // notify cache that rObj is swapped out (and can thus be pruned
+    // from the cache)
+    GraphicCacheEntry* pEntry = ImplGetCacheEntry( rObj );
+
+    if( pEntry )
+        pEntry->GraphicObjectWasSwappedOut( rObj );
+}
+
+// -----------------------------------------------------------------------------
+
+BOOL GraphicCache::FillSwappedGraphicObject( const GraphicObject& rObj, Graphic& rSubstitute )
+{
+    GraphicCacheEntry* pEntry = ImplGetCacheEntry( rObj );
+
+    if( !pEntry )
+        return FALSE;
+
+    return pEntry->FillSwappedGraphicObject( rObj, rSubstitute );
+}
+
+// -----------------------------------------------------------------------------
+
+void GraphicCache::GraphicObjectWasSwappedIn( const GraphicObject& rObj )
+{
+    GraphicCacheEntry* pEntry = ImplGetCacheEntry( rObj );
+
+    if( pEntry )
+    {
+        if( pEntry->GetID().IsEmpty() )
+        {
+            ReleaseGraphicObject( rObj );
+            AddGraphicObject( rObj, (Graphic&) rObj.GetGraphic(), NULL, NULL );
+        }
+        else
+            pEntry->GraphicObjectWasSwappedIn( rObj );
+    }
+}
+
+// -----------------------------------------------------------------------------
+
+void GraphicCache::SetMaxDisplayCacheSize( ULONG nNewCacheSize )
+{
+    mnMaxDisplaySize = nNewCacheSize;
+
+    if( GetMaxDisplayCacheSize() < GetUsedDisplayCacheSize() )
+        ImplFreeDisplayCacheSpace( GetUsedDisplayCacheSize() - GetMaxDisplayCacheSize() );
+}
+
+// -----------------------------------------------------------------------------
+
+void GraphicCache::SetMaxObjDisplayCacheSize( ULONG nNewMaxObjSize, BOOL bDestroyGreaterCached )
+{
+    const BOOL bDestroy = ( bDestroyGreaterCached && ( nNewMaxObjSize < mnMaxObjDisplaySize ) );
+
+    mnMaxObjDisplaySize = Min( nNewMaxObjSize, mnMaxDisplaySize );
+
+    if( bDestroy )
+    {
+        GraphicDisplayCacheEntry* pCacheObj = (GraphicDisplayCacheEntry*) maDisplayCache.First();
+
+        while( pCacheObj )
+        {
+            if( pCacheObj->GetCacheSize() > mnMaxObjDisplaySize )
+            {
+                mnUsedDisplaySize -= pCacheObj->GetCacheSize();
+                maDisplayCache.Remove( pCacheObj );
+                delete pCacheObj;
+                pCacheObj = (GraphicDisplayCacheEntry*) maDisplayCache.GetCurObject();
+            }
+            else
+                pCacheObj = (GraphicDisplayCacheEntry*) maDisplayCache.Next();
+        }
+    }
+}
+
+// -----------------------------------------------------------------------------
+
+void GraphicCache::SetCacheTimeout( ULONG nTimeoutSeconds )
+{
+    if( mnReleaseTimeoutSeconds != nTimeoutSeconds )
+    {
+        GraphicDisplayCacheEntry*   pDisplayEntry = (GraphicDisplayCacheEntry*) maDisplayCache.First();
+        ::vos::TTimeValue           aReleaseTime;
+
+        if( ( mnReleaseTimeoutSeconds = nTimeoutSeconds ) != 0 )
+        {
+            osl_getSystemTime( &aReleaseTime );
+            aReleaseTime.addTime( ::vos::TTimeValue( nTimeoutSeconds, 0 ) );
+        }
+
+        while( pDisplayEntry )
+        {
+            pDisplayEntry->SetReleaseTime( aReleaseTime );
+            pDisplayEntry = (GraphicDisplayCacheEntry*) maDisplayCache.Next();
+        }
+    }
+}
+
+// -----------------------------------------------------------------------------
+
+void GraphicCache::ClearDisplayCache()
+{
+    for( void* pObj = maDisplayCache.First(); pObj; pObj = maDisplayCache.Next() )
+        delete (GraphicDisplayCacheEntry*) pObj;
+
+    maDisplayCache.Clear();
+    mnUsedDisplaySize = 0UL;
+}
+
+// -----------------------------------------------------------------------------
+
+BOOL GraphicCache::IsDisplayCacheable( OutputDevice* pOut, const Point& rPt, const Size& rSz,
+                                       const GraphicObject& rObj, const GraphicAttr& rAttr ) const
+{
+    return( GraphicDisplayCacheEntry::GetNeededSize( pOut, rPt, rSz, rObj, rAttr ) <=
+            GetMaxObjDisplayCacheSize() );
+}
+
+// -----------------------------------------------------------------------------
+
+BOOL GraphicCache::IsInDisplayCache( OutputDevice* pOut, const Point& rPt, const Size& rSz,
+                                     const GraphicObject& rObj, const GraphicAttr& rAttr ) const
+{
+    const Point                 aPtPixel( pOut->LogicToPixel( rPt ) );
+    const Size                  aSzPixel( pOut->LogicToPixel( rSz ) );
+    const GraphicCacheEntry*    pCacheEntry = ( (GraphicCache*) this )->ImplGetCacheEntry( rObj );
+    //GraphicDisplayCacheEntry* pDisplayEntry = (GraphicDisplayCacheEntry*) ( (GraphicCache*) this )->maDisplayCache.First(); // -Wall removed ....
+    BOOL                        bFound = FALSE;
+
+    if( pCacheEntry )
+    {
+        for( long i = 0, nCount = maDisplayCache.Count(); !bFound && ( i < nCount ); i++ )
+            if( ( (GraphicDisplayCacheEntry*) maDisplayCache.GetObject( i ) )->Matches( pOut, aPtPixel, aSzPixel, pCacheEntry, rAttr ) )
+                bFound = TRUE;
+    }
+
+    return bFound;
+}
+
+// -----------------------------------------------------------------------------
+
+ByteString GraphicCache::GetUniqueID( const GraphicObject& rObj ) const
+{
+    ByteString          aRet;
+    GraphicCacheEntry*  pEntry = ( (GraphicCache*) this )->ImplGetCacheEntry( rObj );
+
+    // ensure that the entry is correctly initialized (it has to be read at least once)
+    if( pEntry && pEntry->GetID().IsEmpty() )
+        pEntry->TryToSwapIn();
+
+    // do another call to ImplGetCacheEntry in case of modified entry list
+    pEntry = ( (GraphicCache*) this )->ImplGetCacheEntry( rObj );
+
+    if( pEntry )
+        aRet = pEntry->GetID().GetIDString();
+
+    return aRet;
+}
+
+// -----------------------------------------------------------------------------
+
+BOOL GraphicCache::CreateDisplayCacheObj( OutputDevice* pOut, const Point& rPt, const Size& rSz,
+                                          const GraphicObject& rObj, const GraphicAttr& rAttr,
+                                          const BitmapEx& rBmpEx )
+{
+    const ULONG nNeededSize = GraphicDisplayCacheEntry::GetNeededSize( pOut, rPt, rSz, rObj, rAttr );
+    BOOL        bRet = FALSE;
+
+    if( nNeededSize <= GetMaxObjDisplayCacheSize() )
+    {
+        if( nNeededSize > GetFreeDisplayCacheSize() )
+            ImplFreeDisplayCacheSpace( nNeededSize - GetFreeDisplayCacheSize() );
+
+        GraphicDisplayCacheEntry* pNewEntry = new GraphicDisplayCacheEntry( ImplGetCacheEntry( rObj ),
+                                                                            pOut, rPt, rSz, rObj, rAttr, rBmpEx );
+
+        if( GetCacheTimeout() )
+        {
+            ::vos::TTimeValue aReleaseTime;
+
+            osl_getSystemTime( &aReleaseTime );
+            aReleaseTime.addTime( ::vos::TTimeValue( GetCacheTimeout(), 0 ) );
+            pNewEntry->SetReleaseTime( aReleaseTime );
+        }
+
+        maDisplayCache.Insert( pNewEntry, LIST_APPEND );
+        mnUsedDisplaySize += pNewEntry->GetCacheSize();
+        bRet = TRUE;
+    }
+
+    return bRet;
+}
+
+// -----------------------------------------------------------------------------
+
+BOOL GraphicCache::CreateDisplayCacheObj( OutputDevice* pOut, const Point& rPt, const Size& rSz,
+                                          const GraphicObject& rObj, const GraphicAttr& rAttr,
+                                          const GDIMetaFile& rMtf )
+{
+    const ULONG nNeededSize = GraphicDisplayCacheEntry::GetNeededSize( pOut, rPt, rSz, rObj, rAttr );
+    BOOL        bRet = FALSE;
+
+    if( nNeededSize <= GetMaxObjDisplayCacheSize() )
+    {
+        if( nNeededSize > GetFreeDisplayCacheSize() )
+            ImplFreeDisplayCacheSpace( nNeededSize - GetFreeDisplayCacheSize() );
+
+        GraphicDisplayCacheEntry* pNewEntry = new GraphicDisplayCacheEntry( ImplGetCacheEntry( rObj ),
+                                                                            pOut, rPt, rSz, rObj, rAttr, rMtf );
+
+        if( GetCacheTimeout() )
+        {
+            ::vos::TTimeValue aReleaseTime;
+
+            osl_getSystemTime( &aReleaseTime );
+            aReleaseTime.addTime( ::vos::TTimeValue( GetCacheTimeout(), 0 ) );
+            pNewEntry->SetReleaseTime( aReleaseTime );
+        }
+
+        maDisplayCache.Insert( pNewEntry, LIST_APPEND );
+        mnUsedDisplaySize += pNewEntry->GetCacheSize();
+        bRet = TRUE;
+    }
+
+    return bRet;
+}
+
+// -----------------------------------------------------------------------------
+
+BOOL GraphicCache::DrawDisplayCacheObj( OutputDevice* pOut, const Point& rPt, const Size& rSz,
+                                        const GraphicObject& rObj, const GraphicAttr& rAttr )
+{
+    const Point                 aPtPixel( pOut->LogicToPixel( rPt ) );
+    const Size                  aSzPixel( pOut->LogicToPixel( rSz ) );
+    const GraphicCacheEntry*    pCacheEntry = ImplGetCacheEntry( rObj );
+    GraphicDisplayCacheEntry*   pDisplayCacheEntry = (GraphicDisplayCacheEntry*) maDisplayCache.First();
+    BOOL                        bRet = FALSE;
+
+    while( !bRet && pDisplayCacheEntry )
+    {
+        if( pDisplayCacheEntry->Matches( pOut, aPtPixel, aSzPixel, pCacheEntry, rAttr ) )
+        {
+            ::vos::TTimeValue aReleaseTime;
+
+            // put found object at last used position
+            maDisplayCache.Insert( maDisplayCache.Remove( pDisplayCacheEntry ), LIST_APPEND );
+
+            if( GetCacheTimeout() )
+            {
+                osl_getSystemTime( &aReleaseTime );
+                aReleaseTime.addTime( ::vos::TTimeValue( GetCacheTimeout(), 0 ) );
+            }
+
+            pDisplayCacheEntry->SetReleaseTime( aReleaseTime );
+            bRet = TRUE;
+        }
+        else
+            pDisplayCacheEntry = (GraphicDisplayCacheEntry*) maDisplayCache.Next();
+    }
+
+    if( bRet )
+        pDisplayCacheEntry->Draw( pOut, rPt, rSz );
+
+    return bRet;
+}
+
+// -----------------------------------------------------------------------------
+
+BOOL GraphicCache::ImplFreeDisplayCacheSpace( ULONG nSizeToFree )
+{
+    ULONG nFreedSize = 0UL;
+
+    if( nSizeToFree )
+    {
+        void* pObj = maDisplayCache.First();
+
+        if( nSizeToFree > mnUsedDisplaySize )
+            nSizeToFree = mnUsedDisplaySize;
+
+        while( pObj )
+        {
+            GraphicDisplayCacheEntry* pCacheObj = (GraphicDisplayCacheEntry*) pObj;
+
+            nFreedSize += pCacheObj->GetCacheSize();
+            mnUsedDisplaySize -= pCacheObj->GetCacheSize();
+            maDisplayCache.Remove( pObj );
+            delete pCacheObj;
+
+            if( nFreedSize >= nSizeToFree )
+                break;
+            else
+                pObj = maDisplayCache.GetCurObject();
+        }
+    }
+
+    return( nFreedSize >= nSizeToFree );
+}
+
+// -----------------------------------------------------------------------------
+
+GraphicCacheEntry* GraphicCache::ImplGetCacheEntry( const GraphicObject& rObj )
+{
+    GraphicCacheEntry* pRet = NULL;
+
+    for( void* pObj = maGraphicCache.First(); !pRet && pObj; pObj = maGraphicCache.Next() )
+        if( ( (GraphicCacheEntry*) pObj )->HasGraphicObjectReference( rObj ) )
+            pRet = (GraphicCacheEntry*) pObj;
+
+    return pRet;
+}
+
+// -----------------------------------------------------------------------------
+
+IMPL_LINK( GraphicCache, ReleaseTimeoutHdl, Timer*, pTimer )
+{
+    pTimer->Stop();
+
+    ::vos::TTimeValue           aCurTime;
+    GraphicDisplayCacheEntry*   pDisplayEntry = (GraphicDisplayCacheEntry*) maDisplayCache.First();
+
+    osl_getSystemTime( &aCurTime );
+
+    while( pDisplayEntry )
+    {
+        const ::vos::TTimeValue& rReleaseTime = pDisplayEntry->GetReleaseTime();
+
+        if( !rReleaseTime.isEmpty() && ( rReleaseTime < aCurTime ) )
+        {
+            mnUsedDisplaySize -= pDisplayEntry->GetCacheSize();
+            maDisplayCache.Remove( pDisplayEntry );
+            delete pDisplayEntry;
+            pDisplayEntry = (GraphicDisplayCacheEntry*) maDisplayCache.GetCurObject();
+        }
+        else
+            pDisplayEntry = (GraphicDisplayCacheEntry*) maDisplayCache.Next();
+    }
+
+    pTimer->Start();
+
+    return 0;
+}