sd/source/ui/toolpanel/controls/MasterPageContainerQueue.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: MasterPageContainerQueue.cxx,v $
  10  * $Revision: 1.6 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sd.hxx"
  33
  34 #include "MasterPageContainerQueue.hxx"
  35
  36 #include "tools/IdleDetection.hxx"
  37
  38 #include <set>
  39
  40 namespace sd { namespace toolpanel { namespace controls {
  41
  42 const sal_Int32 MasterPageContainerQueue::snDelayedCreationTimeout (15);
  43 const sal_Int32 MasterPageContainerQueue::snDelayedCreationTimeoutWhenNotIdle (100);
  44 const sal_Int32 MasterPageContainerQueue::snMasterPagePriorityBoost (5);
  45 const sal_Int32 MasterPageContainerQueue::snWaitForMoreRequestsPriorityThreshold (-10);
  46 sal_uInt32 MasterPageContainerQueue::snWaitForMoreRequestsCount(15);
  47
  48 //===== MasterPageContainerQueue::PreviewCreationRequest ======================
  49
  50 class MasterPageContainerQueue::PreviewCreationRequest
  51 {
  52 public:
  53     PreviewCreationRequest (const SharedMasterPageDescriptor& rpDescriptor, int nPriority)
  54         : mpDescriptor(rpDescriptor),
  55           mnPriority(nPriority)
  56     {}
  57     SharedMasterPageDescriptor mpDescriptor;
  58     int mnPriority;
  59     class Compare {public:
  60         bool operator() (const PreviewCreationRequest& r1,const PreviewCreationRequest& r2)
  61         {
  62             if (r1.mnPriority != r2.mnPriority)
  63             {
  64                 // Prefer requests with higher priority.
  65                 return r1.mnPriority > r2.mnPriority;
  66             }
  67             else
  68             {
  69                 // Prefer tokens that have been earlier created (those with lower
  70                 // value).
  71                 return r1.mpDescriptor->maToken < r2.mpDescriptor->maToken;
  72             }
  73         }
  74     };
  75     class CompareToken {public:
  76         MasterPageContainer::Token maToken;
  77         CompareToken(MasterPageContainer::Token aToken) : maToken(aToken) {}
  78         bool operator() (const PreviewCreationRequest& rRequest)
  79         {     return maToken==rRequest.mpDescriptor->maToken; }
  80     };
  81 };
  82
  83
  84
  85
  86 //===== MasterPageContainerQueue::RequestQueue ================================
  87
  88 class MasterPageContainerQueue::RequestQueue
  89     : public ::std::set<PreviewCreationRequest,PreviewCreationRequest::Compare>
  90 {
  91 public:
  92     RequestQueue (void) {}
  93 };
  94
  95
  96
  97
  98 //===== MasterPageContainerQueue ==============================================
  99
 100 MasterPageContainerQueue* MasterPageContainerQueue::Create (
 101     const ::boost::weak_ptr<ContainerAdapter>& rpContainer)
 102 {
 103     MasterPageContainerQueue* pQueue = new MasterPageContainerQueue(rpContainer);
 104     pQueue->LateInit();
 105     return pQueue;
 106 }
 107
 108
 109
 110
 111 MasterPageContainerQueue::MasterPageContainerQueue (
 112     const ::boost::weak_ptr<ContainerAdapter>& rpContainer)
 113     : mpWeakContainer(rpContainer),
 114       mpRequestQueue(new RequestQueue()),
 115       maDelayedPreviewCreationTimer(),
 116       mnRequestsServedCount(0)
 117 {
 118 }
 119
 120
 121
 122
 123 MasterPageContainerQueue::~MasterPageContainerQueue (void)
 124 {
 125     maDelayedPreviewCreationTimer.Stop();
 126     while ( ! mpRequestQueue->empty())
 127         mpRequestQueue->erase(mpRequestQueue->begin());
 128 }
 129
 130
 131
 132
 133 void MasterPageContainerQueue::LateInit (void)
 134 {
 135     // Set up the timer for the delayed creation of preview bitmaps.
 136     maDelayedPreviewCreationTimer.SetTimeout (snDelayedCreationTimeout);
 137     Link aLink (LINK(this,MasterPageContainerQueue,DelayedPreviewCreation));
 138     maDelayedPreviewCreationTimer.SetTimeoutHdl(aLink);
 139 }
 140
 141
 142
 143
 144 bool MasterPageContainerQueue::RequestPreview (const SharedMasterPageDescriptor& rpDescriptor)
 145 {
 146     bool bSuccess (false);
 147     if (rpDescriptor.get() != NULL
 148         && rpDescriptor->maLargePreview.GetSizePixel().Width() == 0)
 149     {
 150         sal_Int32 nPriority (CalculatePriority(rpDescriptor));
 151
 152         // Add a new or replace an existing request.
 153         RequestQueue::iterator iRequest (::std::find_if(
 154             mpRequestQueue->begin(),
 155             mpRequestQueue->end(),
 156             PreviewCreationRequest::CompareToken(rpDescriptor->maToken)));
 157         // When a request for the same token exists then the lowest of the
 158         // two priorities is used.
 159         if (HasRequest(rpDescriptor->maToken))
 160             if (iRequest->mnPriority < nPriority)
 161             {
 162                 mpRequestQueue->erase(iRequest);
 163                 iRequest = mpRequestQueue->end();
 164             }
 165
 166         // Add a new request when none exists (or has just been erased).
 167         if (iRequest == mpRequestQueue->end())
 168         {
 169             mpRequestQueue->insert(PreviewCreationRequest(rpDescriptor,nPriority));
 170             maDelayedPreviewCreationTimer.Start();
 171             bSuccess = true;
 172         }
 173     }
 174     return bSuccess;
 175 }
 176
 177
 178
 179
 180 sal_Int32 MasterPageContainerQueue::CalculatePriority (
 181     const SharedMasterPageDescriptor& rpDescriptor) const
 182 {
 183     sal_Int32 nPriority;
 184
 185     // The cost is used as a starting value.
 186     int nCost (0);
 187     if (rpDescriptor->mpPreviewProvider.get() != NULL)
 188     {
 189         nCost = rpDescriptor->mpPreviewProvider->GetCostIndex();
 190         if (rpDescriptor->mpPreviewProvider->NeedsPageObject())
 191             if (rpDescriptor->mpPageObjectProvider.get() != NULL)
 192                 nCost += rpDescriptor->mpPageObjectProvider->GetCostIndex();
 193     }
 194
 195     // Its negative value is used so that requests with a low cost are
 196     // preferred over those with high costs.
 197     nPriority = -nCost;
 198
 199     // Add a term that introduces an order based on the appearance in the
 200     // AllMasterPagesSelector.
 201     nPriority -= rpDescriptor->maToken / 3;
 202
 203     // Process requests for the CurrentMasterPagesSelector first.
 204     if (rpDescriptor->meOrigin == MasterPageContainer::MASTERPAGE)
 205         nPriority += snMasterPagePriorityBoost;
 206
 207     return nPriority;
 208 }
 209
 210
 211
 212
 213 IMPL_LINK(MasterPageContainerQueue, DelayedPreviewCreation, Timer*, pTimer)
 214 {
 215     bool bIsShowingFullScreenShow (false);
 216     bool bWaitForMoreRequests (false);
 217
 218     do
 219     {
 220         if (mpRequestQueue->size() == 0)
 221             break;
 222
 223         // First check whether the system is idle.
 224         sal_Int32 nIdleState (tools::IdleDetection::GetIdleState());
 225         if (nIdleState != tools::IdleDetection::IDET_IDLE)
 226         {
 227             if ((nIdleState&tools::IdleDetection::IDET_FULL_SCREEN_SHOW_ACTIVE) != 0)
 228                 bIsShowingFullScreenShow = true;
 229             break;
 230         }
 231
 232         PreviewCreationRequest aRequest (*mpRequestQueue->begin());
 233
 234         // Check if the request should really be processed right now.
 235         // Reasons to not do it are when its cost is high and not many other
 236         // requests have been inserted into the queue that would otherwise
 237         // be processed first.
 238         if (aRequest.mnPriority < snWaitForMoreRequestsPriorityThreshold
 239             && (mnRequestsServedCount+mpRequestQueue->size() < snWaitForMoreRequestsCount))
 240         {
 241             // Wait for more requests before this one is processed.  Note
 242             // that the queue processing is not started anew when this
 243             // method is left.  That is done when the next request is
 244             // inserted.
 245             bWaitForMoreRequests = true;
 246             break;
 247         }
 248
 249         mpRequestQueue->erase(mpRequestQueue->begin());
 250
 251         if (aRequest.mpDescriptor.get() != NULL)
 252         {
 253             mnRequestsServedCount += 1;
 254             if ( ! mpWeakContainer.expired())
 255             {
 256                 ::boost::shared_ptr<ContainerAdapter> pContainer (mpWeakContainer);
 257                 if (pContainer.get() != NULL)
 258                     pContainer->UpdateDescriptor(aRequest.mpDescriptor,false,true,true);
 259             }
 260         }
 261     }
 262     while (false);
 263
 264     if (mpRequestQueue->size() > 0 && ! bWaitForMoreRequests)
 265     {
 266         int nTimeout (snDelayedCreationTimeout);
 267         if (bIsShowingFullScreenShow)
 268             nTimeout = snDelayedCreationTimeoutWhenNotIdle;
 269         maDelayedPreviewCreationTimer.SetTimeout(nTimeout);
 270         pTimer->Start();
 271     }
 272
 273     return 0;
 274 }
 275
 276
 277
 278
 279 bool MasterPageContainerQueue::HasRequest (MasterPageContainer::Token aToken) const
 280 {
 281     RequestQueue::iterator iRequest (::std::find_if(
 282         mpRequestQueue->begin(),
 283         mpRequestQueue->end(),
 284         PreviewCreationRequest::CompareToken(aToken)));
 285     return (iRequest != mpRequestQueue->end());
 286 }
 287
 288
 289
 290
 291 bool MasterPageContainerQueue::IsEmpty (void) const
 292 {
 293     return mpRequestQueue->empty();
 294 }
 295
 296
 297
 298
 299 void MasterPageContainerQueue::ProcessAllRequests (void)
 300 {
 301     snWaitForMoreRequestsCount = 0;
 302     if (mpRequestQueue->size() > 0)
 303         maDelayedPreviewCreationTimer.Start();
 304 }
 305
 306
 307 } } } // end of namespace ::sd::toolpanel::controls