LCOV - code coverage report
Current view: top level - sd/source/ui/slidesorter/cache - SlsBitmapCache.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 261 0.0 %
Date: 2014-04-14 Functions: 0 47 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : 
      21             : #include "SlsBitmapCache.hxx"
      22             : #include "SlsCacheCompactor.hxx"
      23             : #include "SlsBitmapCompressor.hxx"
      24             : #include "SlsCacheConfiguration.hxx"
      25             : 
      26             : #include "sdpage.hxx"
      27             : #include "drawdoc.hxx"
      28             : 
      29             : // Define the default value for the maximal cache size that is used for
      30             : // previews that are currently not visible.  The visible previews are all
      31             : // held in memory at all times.  This default is used only when the
      32             : // configuration does not have a value.
      33             : static const sal_Int32 MAXIMAL_CACHE_SIZE = 4L*1024L*1024L;
      34             : 
      35             : using namespace ::com::sun::star::uno;
      36             : 
      37             : namespace sd { namespace slidesorter { namespace cache {
      38             : 
      39           0 : class BitmapCache::CacheEntry
      40             : {
      41             : public:
      42             :     CacheEntry(const Bitmap& rBitmap, sal_Int32 nLastAccessTime, bool bIsPrecious);
      43             :     CacheEntry(sal_Int32 nLastAccessTime, bool bIsPrecious);
      44           0 :     ~CacheEntry (void) {};
      45             :     inline void Recycle (const CacheEntry& rEntry);
      46             :     inline sal_Int32 GetMemorySize (void) const;
      47             :     void Compress (const ::boost::shared_ptr<BitmapCompressor>& rpCompressor);
      48             :     inline void Decompress (void);
      49             : 
      50           0 :     bool IsUpToDate (void) const { return mbIsUpToDate; }
      51           0 :     void SetUpToDate (bool bIsUpToDate) { mbIsUpToDate = bIsUpToDate; }
      52           0 :     sal_Int32 GetAccessTime (void) const { return mnLastAccessTime; }
      53           0 :     void SetAccessTime (sal_Int32 nAccessTime) { mnLastAccessTime = nAccessTime; }
      54             : 
      55           0 :     Bitmap GetPreview (void) const { return maPreview; }
      56             :     inline void SetPreview (const Bitmap& rPreview);
      57             :     bool HasPreview (void) const;
      58             : 
      59           0 :     Bitmap GetMarkedPreview (void) const { return maMarkedPreview; }
      60             :     inline void SetMarkedPreview (const Bitmap& rMarkePreview);
      61             : 
      62           0 :     bool HasReplacement (void) const { return (mpReplacement.get() != NULL); }
      63             :     inline bool HasLosslessReplacement (void) const;
      64             :     void Clear (void) { maPreview.SetEmpty(); maMarkedPreview.SetEmpty();
      65             :         mpReplacement.reset(); mpCompressor.reset(); }
      66           0 :     void Invalidate (void) { mpReplacement.reset(); mpCompressor.reset(); mbIsUpToDate = false; }
      67           0 :     bool IsPrecious (void) const { return mbIsPrecious; }
      68           0 :     void SetPrecious (bool bIsPrecious) { mbIsPrecious = bIsPrecious; }
      69             : 
      70             : private:
      71             :     Bitmap maPreview;
      72             :     Bitmap maMarkedPreview;
      73             :     ::boost::shared_ptr<BitmapReplacement> mpReplacement;
      74             :     ::boost::shared_ptr<BitmapCompressor> mpCompressor;
      75             :     Size maBitmapSize;
      76             :     bool mbIsUpToDate;
      77             :     sal_Int32 mnLastAccessTime;
      78             :     // When this flag is set then the bitmap is not modified by a cache
      79             :     // compactor.
      80             :     bool mbIsPrecious;
      81             : };
      82             : class CacheEntry;
      83             : 
      84             : class CacheHash {
      85             : public:
      86           0 :     size_t operator()(const BitmapCache::CacheKey& p) const
      87           0 :     { return (size_t)p; }
      88             : };
      89             : 
      90           0 : class BitmapCache::CacheBitmapContainer
      91             :     : public ::boost::unordered_map<CacheKey, CacheEntry, CacheHash>
      92             : {
      93             : public:
      94           0 :     CacheBitmapContainer (void) {}
      95             : };
      96             : 
      97             : namespace {
      98             : 
      99             : typedef ::std::vector<
     100             :     ::std::pair< ::sd::slidesorter::cache::BitmapCache::CacheKey,
     101             :       ::sd::slidesorter::cache::BitmapCache::CacheEntry>
     102             :     > SortableBitmapContainer;
     103             : 
     104             :     /** Compare elements of the bitmap cache according to their last access
     105             :         time.
     106             :     */
     107             :     class AccessTimeComparator
     108             :     {
     109             :     public:
     110           0 :         bool operator () (
     111             :             const SortableBitmapContainer::value_type& e1,
     112             :             const SortableBitmapContainer::value_type& e2)
     113             :         {
     114           0 :             return e1.second.GetAccessTime() < e2.second.GetAccessTime();
     115             :         }
     116             :     };
     117             : 
     118             : 
     119             : } // end of anonymous namespace
     120             : 
     121             : 
     122             : //=====  BitmapCache  =========================================================
     123             : 
     124           0 : BitmapCache::BitmapCache (const sal_Int32 nMaximalNormalCacheSize)
     125             :     : maMutex(),
     126           0 :       mpBitmapContainer(new CacheBitmapContainer()),
     127             :       mnNormalCacheSize(0),
     128             :       mnPreciousCacheSize(0),
     129             :       mnCurrentAccessTime(0),
     130             :       mnMaximalNormalCacheSize(MAXIMAL_CACHE_SIZE),
     131             :       mpCacheCompactor(),
     132           0 :       mbIsFull(false)
     133             : {
     134           0 :     if (nMaximalNormalCacheSize > 0)
     135           0 :         mnMaximalNormalCacheSize = nMaximalNormalCacheSize;
     136             :     else
     137             :     {
     138           0 :         Any aCacheSize (CacheConfiguration::Instance()->GetValue("CacheSize"));
     139           0 :         if (aCacheSize.has<sal_Int32>())
     140           0 :             aCacheSize >>= mnMaximalNormalCacheSize;
     141             :     }
     142             : 
     143           0 :     mpCacheCompactor = CacheCompactor::Create(*this,mnMaximalNormalCacheSize);
     144           0 : }
     145             : 
     146             : 
     147             : 
     148             : 
     149           0 : BitmapCache::~BitmapCache (void)
     150             : {
     151           0 :     Clear();
     152           0 : }
     153             : 
     154             : 
     155             : 
     156             : 
     157           0 : void BitmapCache::Clear (void)
     158             : {
     159           0 :     ::osl::MutexGuard aGuard (maMutex);
     160             : 
     161           0 :     mpBitmapContainer->clear();
     162           0 :     mnNormalCacheSize = 0;
     163           0 :     mnPreciousCacheSize = 0;
     164           0 :     mnCurrentAccessTime = 0;
     165           0 : }
     166             : 
     167             : 
     168             : 
     169             : 
     170           0 : bool BitmapCache::IsFull (void) const
     171             : {
     172           0 :     return mbIsFull;
     173             : }
     174             : 
     175             : 
     176             : 
     177             : 
     178           0 : sal_Int32 BitmapCache::GetSize (void)
     179             : {
     180           0 :     return mnNormalCacheSize;
     181             : }
     182             : 
     183             : 
     184             : 
     185             : 
     186           0 : bool BitmapCache::HasBitmap (const CacheKey& rKey)
     187             : {
     188           0 :     ::osl::MutexGuard aGuard (maMutex);
     189             : 
     190           0 :     CacheBitmapContainer::iterator iEntry (mpBitmapContainer->find(rKey));
     191           0 :     return (iEntry != mpBitmapContainer->end()
     192           0 :         && (iEntry->second.HasPreview() || iEntry->second.HasReplacement()));
     193             : }
     194             : 
     195             : 
     196             : 
     197             : 
     198           0 : bool BitmapCache::BitmapIsUpToDate (const CacheKey& rKey)
     199             : {
     200           0 :     ::osl::MutexGuard aGuard (maMutex);
     201             : 
     202           0 :     bool bIsUpToDate = false;
     203           0 :     CacheBitmapContainer::iterator aIterator (mpBitmapContainer->find(rKey));
     204           0 :     if (aIterator != mpBitmapContainer->end())
     205           0 :         bIsUpToDate = aIterator->second.IsUpToDate();
     206             : 
     207           0 :     return bIsUpToDate;
     208             : }
     209             : 
     210             : 
     211             : 
     212             : 
     213           0 : Bitmap BitmapCache::GetBitmap (const CacheKey& rKey)
     214             : {
     215           0 :     ::osl::MutexGuard aGuard (maMutex);
     216             : 
     217           0 :     CacheBitmapContainer::iterator iEntry (mpBitmapContainer->find(rKey));
     218           0 :     if (iEntry == mpBitmapContainer->end())
     219             :     {
     220             :         // Create an empty bitmap for the given key that acts as placeholder
     221             :         // until we are given the real one.  Mark it as not being up to date.
     222           0 :         SetBitmap(rKey, Bitmap(), false);
     223           0 :         iEntry = mpBitmapContainer->find(rKey);
     224           0 :         iEntry->second.SetUpToDate(false);
     225             :     }
     226             :     else
     227             :     {
     228           0 :         iEntry->second.SetAccessTime(mnCurrentAccessTime++);
     229             : 
     230             :         // Maybe we have to decompress the preview.
     231           0 :         if ( ! iEntry->second.HasPreview() && iEntry->second.HasReplacement())
     232             :         {
     233           0 :             UpdateCacheSize(iEntry->second, REMOVE);
     234           0 :             iEntry->second.Decompress();
     235           0 :             UpdateCacheSize(iEntry->second, ADD);
     236             :         }
     237             :     }
     238           0 :     return iEntry->second.GetPreview();
     239             : }
     240             : 
     241             : 
     242             : 
     243             : 
     244           0 : Bitmap BitmapCache::GetMarkedBitmap (const CacheKey& rKey)
     245             : {
     246           0 :     ::osl::MutexGuard aGuard (maMutex);
     247             : 
     248           0 :     CacheBitmapContainer::iterator iEntry (mpBitmapContainer->find(rKey));
     249           0 :     if (iEntry != mpBitmapContainer->end())
     250             :     {
     251           0 :         iEntry->second.SetAccessTime(mnCurrentAccessTime++);
     252           0 :         return iEntry->second.GetMarkedPreview();
     253             :     }
     254             :     else
     255           0 :         return Bitmap();
     256             : }
     257             : 
     258             : 
     259             : 
     260             : 
     261           0 : void BitmapCache::ReleaseBitmap (const CacheKey& rKey)
     262             : {
     263           0 :     ::osl::MutexGuard aGuard (maMutex);
     264             : 
     265           0 :     CacheBitmapContainer::iterator aIterator (mpBitmapContainer->find(rKey));
     266           0 :     if (aIterator != mpBitmapContainer->end())
     267             :     {
     268           0 :         UpdateCacheSize(aIterator->second, REMOVE);
     269           0 :         mpBitmapContainer->erase(aIterator);
     270           0 :     }
     271           0 : }
     272             : 
     273             : 
     274             : 
     275             : 
     276           0 : bool BitmapCache::InvalidateBitmap (const CacheKey& rKey)
     277             : {
     278           0 :     ::osl::MutexGuard aGuard (maMutex);
     279             : 
     280           0 :     CacheBitmapContainer::iterator iEntry (mpBitmapContainer->find(rKey));
     281           0 :     if (iEntry != mpBitmapContainer->end())
     282             :     {
     283           0 :         iEntry->second.SetUpToDate(false);
     284             : 
     285             :         // When there is a preview then we release the replacement.  The
     286             :         // preview itself is kept until a new one is created.
     287           0 :         if (iEntry->second.HasPreview())
     288             :         {
     289           0 :             UpdateCacheSize(iEntry->second, REMOVE);
     290           0 :             iEntry->second.Invalidate();
     291           0 :             UpdateCacheSize(iEntry->second, ADD);
     292             :         }
     293           0 :         return true;
     294             :     }
     295             :     else
     296           0 :         return false;
     297             : }
     298             : 
     299             : 
     300             : 
     301             : 
     302           0 : void BitmapCache::InvalidateCache (void)
     303             : {
     304           0 :     ::osl::MutexGuard aGuard (maMutex);
     305             : 
     306           0 :     CacheBitmapContainer::iterator iEntry;
     307           0 :     for (iEntry=mpBitmapContainer->begin(); iEntry!=mpBitmapContainer->end(); ++iEntry)
     308             :     {
     309           0 :         iEntry->second.Invalidate();
     310             :     }
     311           0 :     ReCalculateTotalCacheSize();
     312           0 : }
     313             : 
     314             : 
     315             : 
     316             : 
     317           0 : void BitmapCache::SetBitmap (
     318             :     const CacheKey& rKey,
     319             :     const Bitmap& rPreview,
     320             :     bool bIsPrecious)
     321             : {
     322           0 :     ::osl::MutexGuard aGuard (maMutex);
     323             : 
     324           0 :     CacheBitmapContainer::iterator iEntry (mpBitmapContainer->find(rKey));
     325           0 :     if (iEntry != mpBitmapContainer->end())
     326             :     {
     327           0 :         UpdateCacheSize(iEntry->second, REMOVE);
     328           0 :         iEntry->second.SetPreview(rPreview);
     329           0 :         iEntry->second.SetUpToDate(true);
     330           0 :         iEntry->second.SetAccessTime(mnCurrentAccessTime++);
     331             :     }
     332             :     else
     333             :     {
     334           0 :         iEntry = mpBitmapContainer->insert(CacheBitmapContainer::value_type (
     335             :             rKey,
     336             :             CacheEntry(rPreview, mnCurrentAccessTime++, bIsPrecious))
     337           0 :             ).first;
     338             :     }
     339             : 
     340           0 :     if (iEntry != mpBitmapContainer->end())
     341           0 :         UpdateCacheSize(iEntry->second, ADD);
     342           0 : }
     343             : 
     344             : 
     345             : 
     346             : 
     347           0 : void BitmapCache::SetMarkedBitmap (
     348             :     const CacheKey& rKey,
     349             :     const Bitmap& rPreview)
     350             : {
     351           0 :     ::osl::MutexGuard aGuard (maMutex);
     352             : 
     353           0 :     CacheBitmapContainer::iterator iEntry (mpBitmapContainer->find(rKey));
     354           0 :     if (iEntry != mpBitmapContainer->end())
     355             :     {
     356           0 :         UpdateCacheSize(iEntry->second, REMOVE);
     357           0 :         iEntry->second.SetMarkedPreview(rPreview);
     358           0 :         iEntry->second.SetAccessTime(mnCurrentAccessTime++);
     359           0 :         UpdateCacheSize(iEntry->second, ADD);
     360           0 :     }
     361           0 : }
     362             : 
     363             : 
     364             : 
     365             : 
     366           0 : void BitmapCache::SetPrecious (const CacheKey& rKey, bool bIsPrecious)
     367             : {
     368           0 :     ::osl::MutexGuard aGuard (maMutex);
     369             : 
     370           0 :     CacheBitmapContainer::iterator iEntry (mpBitmapContainer->find(rKey));
     371           0 :     if (iEntry != mpBitmapContainer->end())
     372             :     {
     373           0 :         if (iEntry->second.IsPrecious() != bIsPrecious)
     374             :         {
     375           0 :             UpdateCacheSize(iEntry->second, REMOVE);
     376           0 :             iEntry->second.SetPrecious(bIsPrecious);
     377           0 :             UpdateCacheSize(iEntry->second, ADD);
     378             :         }
     379             :     }
     380           0 :     else if (bIsPrecious)
     381             :     {
     382           0 :         iEntry = mpBitmapContainer->insert(CacheBitmapContainer::value_type (
     383             :             rKey,
     384             :             CacheEntry(Bitmap(), mnCurrentAccessTime++, bIsPrecious))
     385           0 :             ).first;
     386           0 :         UpdateCacheSize(iEntry->second, ADD);
     387           0 :     }
     388           0 : }
     389             : 
     390             : 
     391             : 
     392             : 
     393           0 : void BitmapCache::ReCalculateTotalCacheSize (void)
     394             : {
     395           0 :     ::osl::MutexGuard aGuard (maMutex);
     396             : 
     397           0 :     mnNormalCacheSize = 0;
     398           0 :     mnPreciousCacheSize = 0;
     399           0 :     CacheBitmapContainer::iterator iEntry;
     400           0 :     for (iEntry=mpBitmapContainer->begin(); iEntry!=mpBitmapContainer->end();  ++iEntry)
     401             :     {
     402           0 :         if (iEntry->second.IsPrecious())
     403           0 :             mnPreciousCacheSize += iEntry->second.GetMemorySize();
     404             :         else
     405           0 :             mnNormalCacheSize += iEntry->second.GetMemorySize();
     406             :     }
     407           0 :     mbIsFull = (mnNormalCacheSize  >= mnMaximalNormalCacheSize);
     408             : 
     409           0 :     SAL_INFO("sd.sls", OSL_THIS_FUNC << ": cache size is " << mnNormalCacheSize << "/" << mnPreciousCacheSize);
     410           0 : }
     411             : 
     412             : 
     413             : 
     414             : 
     415           0 : void BitmapCache::Recycle (const BitmapCache& rCache)
     416             : {
     417           0 :     ::osl::MutexGuard aGuard (maMutex);
     418             : 
     419           0 :     CacheBitmapContainer::const_iterator iOtherEntry;
     420           0 :     for (iOtherEntry=rCache.mpBitmapContainer->begin();
     421           0 :          iOtherEntry!=rCache.mpBitmapContainer->end();
     422             :          ++iOtherEntry)
     423             :     {
     424           0 :         CacheBitmapContainer::iterator iEntry (mpBitmapContainer->find(iOtherEntry->first));
     425           0 :         if (iEntry == mpBitmapContainer->end())
     426             :         {
     427           0 :             iEntry = mpBitmapContainer->insert(CacheBitmapContainer::value_type (
     428           0 :                 iOtherEntry->first,
     429             :                 CacheEntry(mnCurrentAccessTime++, true))
     430           0 :                 ).first;
     431           0 :             UpdateCacheSize(iEntry->second, ADD);
     432             :         }
     433           0 :         if (iEntry != mpBitmapContainer->end())
     434             :         {
     435           0 :             UpdateCacheSize(iEntry->second, REMOVE);
     436           0 :             iEntry->second.Recycle(iOtherEntry->second);
     437           0 :             UpdateCacheSize(iEntry->second, ADD);
     438             :         }
     439           0 :     }
     440           0 : }
     441             : 
     442             : 
     443             : 
     444             : SAL_WNODEPRECATED_DECLARATIONS_PUSH
     445           0 : ::std::auto_ptr<BitmapCache::CacheIndex> BitmapCache::GetCacheIndex (
     446             :     bool bIncludePrecious,
     447             :     bool bIncludeNoPreview) const
     448             : {
     449           0 :     ::osl::MutexGuard aGuard (maMutex);
     450             : 
     451             :     // Create a copy of the bitmap container.
     452           0 :     SortableBitmapContainer aSortedContainer;
     453           0 :     aSortedContainer.reserve(mpBitmapContainer->size());
     454             : 
     455             :     // Copy the relevant entries.
     456           0 :     CacheBitmapContainer::iterator iEntry;
     457           0 :     for (iEntry=mpBitmapContainer->begin(); iEntry!=mpBitmapContainer->end(); ++iEntry)
     458             :     {
     459           0 :         if ( ! bIncludePrecious && iEntry->second.IsPrecious())
     460           0 :             continue;
     461             : 
     462           0 :         if ( ! bIncludeNoPreview && ! iEntry->second.HasPreview())
     463           0 :             continue;
     464             : 
     465             :         aSortedContainer.push_back(SortableBitmapContainer::value_type(
     466           0 :             iEntry->first,iEntry->second));
     467             :     }
     468             : 
     469             :     // Sort the remaining entries.
     470           0 :     ::std::sort(aSortedContainer.begin(), aSortedContainer.end(), AccessTimeComparator());
     471             : 
     472             :     // Return a list with the keys of the sorted entries.
     473           0 :     ::std::auto_ptr<CacheIndex> pIndex(new CacheIndex());
     474           0 :     SortableBitmapContainer::iterator iIndexEntry;
     475           0 :     pIndex->reserve(aSortedContainer.size());
     476           0 :     for (iIndexEntry=aSortedContainer.begin(); iIndexEntry!=aSortedContainer.end(); ++iIndexEntry)
     477           0 :         pIndex->push_back(iIndexEntry->first);
     478           0 :     return pIndex;
     479             : }
     480             : SAL_WNODEPRECATED_DECLARATIONS_POP
     481             : 
     482             : 
     483             : 
     484           0 : void BitmapCache::Compress (
     485             :     const CacheKey& rKey,
     486             :     const ::boost::shared_ptr<BitmapCompressor>& rpCompressor)
     487             : {
     488           0 :     ::osl::MutexGuard aGuard (maMutex);
     489             : 
     490           0 :     CacheBitmapContainer::iterator iEntry (mpBitmapContainer->find(rKey));
     491           0 :     if (iEntry != mpBitmapContainer->end() && iEntry->second.HasPreview())
     492             :     {
     493           0 :         UpdateCacheSize(iEntry->second, REMOVE);
     494           0 :         iEntry->second.Compress(rpCompressor);
     495           0 :         UpdateCacheSize(iEntry->second, ADD);
     496           0 :     }
     497           0 : }
     498             : 
     499             : 
     500             : 
     501             : 
     502           0 : void BitmapCache::UpdateCacheSize (const CacheEntry& rEntry, CacheOperation eOperation)
     503             : {
     504           0 :     sal_Int32 nEntrySize (rEntry.GetMemorySize());
     505           0 :     sal_Int32& rCacheSize (rEntry.IsPrecious() ? mnPreciousCacheSize : mnNormalCacheSize);
     506           0 :     switch (eOperation)
     507             :     {
     508             :         case ADD:
     509           0 :             rCacheSize += nEntrySize;
     510           0 :             if ( ! rEntry.IsPrecious() && mnNormalCacheSize>mnMaximalNormalCacheSize)
     511             :             {
     512           0 :                 mbIsFull = true;
     513             :                 SAL_INFO("sd.sls", OSL_THIS_FUNC << ": cache size is " << mnNormalCacheSize << " > " << mnMaximalNormalCacheSize);
     514           0 :                 mpCacheCompactor->RequestCompaction();
     515             :             }
     516           0 :             break;
     517             : 
     518             :         case REMOVE:
     519           0 :             rCacheSize -= nEntrySize;
     520           0 :             if (mnNormalCacheSize < mnMaximalNormalCacheSize)
     521           0 :                 mbIsFull = false;
     522           0 :             break;
     523             : 
     524             :         default:
     525             :             OSL_ASSERT(false);
     526           0 :             break;
     527             :     }
     528           0 : }
     529             : 
     530             : 
     531             : 
     532             : 
     533             : //===== CacheEntry ============================================================
     534             : 
     535           0 : BitmapCache::CacheEntry::CacheEntry(
     536             :     sal_Int32 nLastAccessTime,
     537             :     bool bIsPrecious)
     538             :     : maPreview(),
     539             :       maMarkedPreview(),
     540             :       mbIsUpToDate(true),
     541             :       mnLastAccessTime(nLastAccessTime),
     542           0 :       mbIsPrecious(bIsPrecious)
     543             : {
     544           0 : }
     545             : 
     546             : 
     547             : 
     548             : 
     549           0 : BitmapCache::CacheEntry::CacheEntry(
     550             :     const Bitmap& rPreview,
     551             :     sal_Int32 nLastAccessTime,
     552             :     bool bIsPrecious)
     553             :     : maPreview(rPreview),
     554             :       maMarkedPreview(),
     555             :       mbIsUpToDate(true),
     556             :       mnLastAccessTime(nLastAccessTime),
     557           0 :       mbIsPrecious(bIsPrecious)
     558             : {
     559           0 : }
     560             : 
     561             : 
     562             : 
     563             : 
     564           0 : inline void BitmapCache::CacheEntry::Recycle (const CacheEntry& rEntry)
     565             : {
     566           0 :     if ((rEntry.HasPreview() || rEntry.HasLosslessReplacement())
     567           0 :         && ! (HasPreview() || HasLosslessReplacement()))
     568             :     {
     569           0 :         maPreview = rEntry.maPreview;
     570           0 :         maMarkedPreview = rEntry.maMarkedPreview;
     571           0 :         mpReplacement = rEntry.mpReplacement;
     572           0 :         mpCompressor = rEntry.mpCompressor;
     573           0 :         mnLastAccessTime = rEntry.mnLastAccessTime;
     574           0 :         mbIsUpToDate = rEntry.mbIsUpToDate;
     575             :     }
     576           0 : }
     577             : 
     578             : 
     579             : 
     580             : 
     581           0 : inline sal_Int32 BitmapCache::CacheEntry::GetMemorySize (void) const
     582             : {
     583           0 :     sal_Int32 nSize (0);
     584           0 :     nSize += maPreview.GetSizeBytes();
     585           0 :     nSize += maMarkedPreview.GetSizeBytes();
     586           0 :     if (mpReplacement.get() != NULL)
     587           0 :         nSize += mpReplacement->GetMemorySize();
     588           0 :     return nSize;
     589             : }
     590             : 
     591             : 
     592             : 
     593             : 
     594           0 : void BitmapCache::CacheEntry::Compress (const ::boost::shared_ptr<BitmapCompressor>& rpCompressor)
     595             : {
     596           0 :     if ( ! maPreview.IsEmpty())
     597             :     {
     598           0 :         if (mpReplacement.get() == NULL)
     599             :         {
     600           0 :             mpReplacement = rpCompressor->Compress(maPreview);
     601             : 
     602             : #if OSL_DEBUG_LEVEL > 2
     603             :             sal_uInt32 nOldSize (maPreview.GetSizeBytes());
     604             :             sal_uInt32 nNewSize (mpReplacement.get()!=NULL ? mpReplacement->GetMemorySize() : 0);
     605             :             if (nOldSize == 0)
     606             :                 nOldSize = 1;
     607             :             sal_Int32 nRatio (100L * nNewSize / nOldSize);
     608             :             SAL_INFO("sd.sls", OSL_THIS_FUNC << ": compressing bitmap for " << %x << " from " << nOldSize << " to " << nNewSize << " bytes (" << nRatio << "%)");
     609             : #endif
     610             : 
     611           0 :             mpCompressor = rpCompressor;
     612             :         }
     613             : 
     614           0 :         maPreview.SetEmpty();
     615           0 :         maMarkedPreview.SetEmpty();
     616             :     }
     617           0 : }
     618             : 
     619             : 
     620             : 
     621             : 
     622           0 : inline void BitmapCache::CacheEntry::Decompress (void)
     623             : {
     624           0 :     if (mpReplacement.get()!=NULL && mpCompressor.get()!=NULL && maPreview.IsEmpty())
     625             :     {
     626           0 :         maPreview = mpCompressor->Decompress(*mpReplacement);
     627           0 :         maMarkedPreview.SetEmpty();
     628           0 :         if ( ! mpCompressor->IsLossless())
     629           0 :             mbIsUpToDate = false;
     630             :     }
     631           0 : }
     632             : 
     633             : 
     634             : 
     635           0 : inline void BitmapCache::CacheEntry::SetPreview (const Bitmap& rPreview)
     636             : {
     637           0 :     maPreview = rPreview;
     638           0 :     maMarkedPreview.SetEmpty();
     639           0 :     mpReplacement.reset();
     640           0 :     mpCompressor.reset();
     641           0 : }
     642             : 
     643             : 
     644             : 
     645             : 
     646           0 : bool BitmapCache::CacheEntry::HasPreview (void) const
     647             : {
     648           0 :     return ! maPreview.IsEmpty();
     649             : }
     650             : 
     651             : 
     652             : 
     653             : 
     654           0 : inline void BitmapCache::CacheEntry::SetMarkedPreview (const Bitmap& rMarkedPreview)
     655             : {
     656           0 :     maMarkedPreview = rMarkedPreview;
     657           0 : }
     658             : 
     659             : 
     660             : 
     661             : 
     662           0 : inline bool BitmapCache::CacheEntry::HasLosslessReplacement (void) const
     663             : {
     664           0 :     return mpReplacement.get()!=NULL
     665           0 :         && mpCompressor.get()!=NULL
     666           0 :         && mpCompressor->IsLossless();
     667             : }
     668             : 
     669             : 
     670             : } } } // end of namespace ::sd::slidesorter::cache
     671             : 
     672             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10