sd/source/ui/slidesorter/cache/SlsQueueProcessor.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: SlsQueueProcessor.cxx,v $
  10  * $Revision: 1.10 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include "precompiled_sd.hxx"
  32
  33 #include "SlsQueueProcessor.hxx"
  34 #include "SlsCacheConfiguration.hxx"
  35 #include "SlsRequestQueue.hxx"
  36 #include "SlsIdleDetector.hxx"
  37
  38 namespace sd { namespace slidesorter { namespace cache {
  39
  40
  41 //=====  QueueProcessor  ======================================================
  42
  43 QueueProcessor::QueueProcessor (
  44     RequestQueue& rQueue,
  45     const ::boost::shared_ptr<BitmapCache>& rpCache,
  46     const Size& rPreviewSize,
  47     const SharedCacheContext& rpCacheContext)
  48     : maMutex(),
  49       maTimer(),
  50       mnTimeBetweenHighPriorityRequests (10/*ms*/),
  51       mnTimeBetweenLowPriorityRequests (100/*ms*/),
  52       mnTimeBetweenRequestsWhenNotIdle (1000/*ms*/),
  53       maPreviewSize(rPreviewSize),
  54       mpCacheContext(rpCacheContext),
  55       mrQueue(rQueue),
  56       mpCache(rpCache),
  57       maBitmapFactory(),
  58       mbIsPaused(false)
  59 {
  60     // Look into the configuration if there for overriding values.
  61     ::com::sun::star::uno::Any aTimeBetweenReqeusts;
  62     aTimeBetweenReqeusts = CacheConfiguration::Instance()->GetValue(
  63         ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("TimeBetweenHighPriorityRequests")));
  64     if (aTimeBetweenReqeusts.has<sal_Int32>())
  65         aTimeBetweenReqeusts >>= mnTimeBetweenHighPriorityRequests;
  66
  67     aTimeBetweenReqeusts = CacheConfiguration::Instance()->GetValue(
  68         ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("TimeBetweenLowPriorityRequests")));
  69     if (aTimeBetweenReqeusts.has<sal_Int32>())
  70         aTimeBetweenReqeusts >>= mnTimeBetweenLowPriorityRequests;
  71
  72     aTimeBetweenReqeusts = CacheConfiguration::Instance()->GetValue(
  73         ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("TimeBetweenRequestsDuringShow")));
  74     if (aTimeBetweenReqeusts.has<sal_Int32>())
  75         aTimeBetweenReqeusts >>= mnTimeBetweenRequestsWhenNotIdle;
  76
  77     maTimer.SetTimeoutHdl (LINK(this,QueueProcessor,ProcessRequestHdl));
  78     maTimer.SetTimeout (mnTimeBetweenHighPriorityRequests);
  79 }
  80
  81
  82
  83
  84
  85 QueueProcessor::~QueueProcessor (void)
  86 {
  87 }
  88
  89
  90
  91
  92 void QueueProcessor::Start (int nPriorityClass)
  93 {
  94     if (mbIsPaused)
  95         return;
  96     if ( ! maTimer.IsActive())
  97     {
  98         if (nPriorityClass == 0)
  99             maTimer.SetTimeout (mnTimeBetweenHighPriorityRequests);
 100         else
 101             maTimer.SetTimeout (mnTimeBetweenLowPriorityRequests);
 102         maTimer.Start();
 103     }
 104 }
 105
 106
 107
 108
 109 void QueueProcessor::Stop (void)
 110 {
 111     if (maTimer.IsActive())
 112         maTimer.Stop();
 113 }
 114
 115
 116
 117
 118 void QueueProcessor::Pause (void)
 119 {
 120     mbIsPaused = true;
 121 }
 122
 123
 124
 125
 126 void QueueProcessor::Resume (void)
 127 {
 128     mbIsPaused = false;
 129     if ( ! mrQueue.IsEmpty())
 130         Start(mrQueue.GetFrontPriorityClass());
 131 }
 132
 133
 134
 135
 136 void QueueProcessor::Terminate (void)
 137 {
 138 }
 139
 140
 141
 142
 143 void QueueProcessor::SetPreviewSize (const Size& rPreviewSize)
 144 {
 145     maPreviewSize = rPreviewSize;
 146 }
 147
 148
 149
 150
 151 IMPL_LINK(QueueProcessor, ProcessRequestHdl, Timer*, EMPTYARG)
 152 {
 153     ProcessRequests();
 154     return 1;
 155 }
 156
 157
 158
 159
 160 void QueueProcessor::ProcessRequests (void)
 161 {
 162     OSL_ASSERT(mpCacheContext.get()!=NULL);
 163
 164     while ( ! mrQueue.IsEmpty() && ! mbIsPaused)
 165     {
 166         if ( ! mpCacheContext->IsIdle())
 167             break;
 168
 169         CacheKey aKey = NULL;
 170         RequestPriorityClass ePriorityClass (NOT_VISIBLE);
 171         {
 172             ::osl::MutexGuard aGuard (mrQueue.GetMutex());
 173
 174             if ( ! mrQueue.IsEmpty())
 175             {
 176                 // Get the request with the highest priority from the queue.
 177                 ePriorityClass = mrQueue.GetFrontPriorityClass();
 178                 aKey = mrQueue.GetFront();
 179                 mrQueue.PopFront();
 180             }
 181         }
 182
 183         if (aKey != NULL)
 184             ProcessOneRequest(aKey, ePriorityClass);
 185
 186         // Requests of lower priority are processed one at a time.
 187         {
 188             ::osl::MutexGuard aGuard (mrQueue.GetMutex());
 189             if ( ! mrQueue.IsEmpty())
 190                 if (mrQueue.GetFrontPriorityClass() > 0)
 191                     break;
 192         }
 193     }
 194
 195     // Schedule the processing of the next element(s).
 196     {
 197         ::osl::MutexGuard aGuard (mrQueue.GetMutex());
 198         if ( ! mrQueue.IsEmpty())
 199             /*
 200             if (bIsShowingFullScreenShow)
 201                 Start(mnTimeBetweenRequestsWhenNotIdle);
 202             else
 203             */
 204             Start(mrQueue.GetFrontPriorityClass());
 205     }
 206 }
 207
 208
 209
 210
 211 void QueueProcessor::ProcessOneRequest (
 212     CacheKey aKey,
 213     const RequestPriorityClass ePriorityClass)
 214 {
 215     try
 216     {
 217         ::osl::MutexGuard aGuard (maMutex);
 218
 219         // Create a new preview bitmap and store it in the cache.
 220         if (mpCache.get() != NULL
 221             && mpCacheContext.get() != NULL)
 222         {
 223             const SdPage* pSdPage = dynamic_cast<const SdPage*>(mpCacheContext->GetPage(aKey));
 224             if (pSdPage != NULL)
 225             {
 226                 const ::boost::shared_ptr<BitmapEx> pPreview (
 227                     maBitmapFactory.CreateBitmap(*pSdPage, maPreviewSize));
 228                 mpCache->SetBitmap (
 229                     pSdPage,
 230                     pPreview,
 231                     ePriorityClass!=NOT_VISIBLE);
 232
 233                 // Initiate a repaint of the new preview.
 234                 mpCacheContext->NotifyPreviewCreation(aKey, pPreview);
 235             }
 236         }
 237     }
 238     catch (::com::sun::star::uno::RuntimeException aException)
 239     {
 240         (void) aException;
 241         OSL_ASSERT("RuntimeException caught in QueueProcessor");
 242     }
 243     catch (::com::sun::star::uno::Exception aException)
 244     {
 245         (void) aException;
 246         OSL_ASSERT("Exception caught in QueueProcessor");
 247     }
 248 }
 249
 250
 251
 252
 253 void QueueProcessor::RemoveRequest (CacheKey aKey)
 254 {
 255     (void)aKey;
 256     // See the method declaration above for an explanation why this makes sense.
 257     ::osl::MutexGuard aGuard (maMutex);
 258 }
 259
 260
 261
 262
 263 void QueueProcessor::SetBitmapCache (
 264     const ::boost::shared_ptr<BitmapCache>& rpCache)
 265 {
 266     mpCache = rpCache;
 267 }
 268
 269
 270 } } } // end of namespace ::sd::slidesorter::cache