264 lines
8.9 KiB
C++
264 lines
8.9 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/*
|
|
* This file is part of the LibreOffice project.
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
*
|
|
* This file incorporates work covered by the following license notice:
|
|
*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed
|
|
* with this work for additional information regarding copyright
|
|
* ownership. The ASF licenses this file to you under the Apache
|
|
* License, Version 2.0 (the "License"); you may not use this file
|
|
* except in compliance with the License. You may obtain a copy of
|
|
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
|
|
*/
|
|
|
|
#include "MasterPageContainerQueue.hxx"
|
|
#include "MasterPageContainerProviders.hxx"
|
|
|
|
#include <tools/IdleDetection.hxx>
|
|
|
|
#include <set>
|
|
#include <utility>
|
|
|
|
namespace sd::sidebar {
|
|
|
|
const sal_Int32 MasterPageContainerQueue::snDelayedCreationTimeout (15);
|
|
const sal_Int32 MasterPageContainerQueue::snDelayedCreationTimeoutWhenNotIdle (100);
|
|
const sal_Int32 MasterPageContainerQueue::snMasterPagePriorityBoost (5);
|
|
const sal_Int32 MasterPageContainerQueue::snWaitForMoreRequestsPriorityThreshold (-10);
|
|
sal_uInt32 MasterPageContainerQueue::snWaitForMoreRequestsCount(15);
|
|
|
|
//===== MasterPageContainerQueue::PreviewCreationRequest ======================
|
|
|
|
class MasterPageContainerQueue::PreviewCreationRequest
|
|
{
|
|
public:
|
|
PreviewCreationRequest (SharedMasterPageDescriptor pDescriptor, int nPriority)
|
|
: mpDescriptor(std::move(pDescriptor)),
|
|
mnPriority(nPriority)
|
|
{}
|
|
SharedMasterPageDescriptor mpDescriptor;
|
|
int mnPriority;
|
|
class Compare
|
|
{
|
|
public:
|
|
bool operator() (const PreviewCreationRequest& r1,const PreviewCreationRequest& r2) const
|
|
{
|
|
if (r1.mnPriority != r2.mnPriority)
|
|
{
|
|
// Prefer requests with higher priority.
|
|
return r1.mnPriority > r2.mnPriority;
|
|
}
|
|
else
|
|
{
|
|
// Prefer tokens that have been earlier created (those with lower
|
|
// value).
|
|
return r1.mpDescriptor->maToken < r2.mpDescriptor->maToken;
|
|
}
|
|
}
|
|
};
|
|
class CompareToken
|
|
{
|
|
public:
|
|
MasterPageContainer::Token maToken;
|
|
explicit CompareToken(MasterPageContainer::Token aToken) : maToken(aToken) {}
|
|
bool operator() (const PreviewCreationRequest& rRequest) const
|
|
{ return maToken==rRequest.mpDescriptor->maToken; }
|
|
};
|
|
};
|
|
|
|
//===== MasterPageContainerQueue::RequestQueue ================================
|
|
|
|
class MasterPageContainerQueue::RequestQueue
|
|
: public ::std::set<PreviewCreationRequest,PreviewCreationRequest::Compare>
|
|
{
|
|
public:
|
|
RequestQueue() {}
|
|
};
|
|
|
|
//===== MasterPageContainerQueue ==============================================
|
|
|
|
MasterPageContainerQueue* MasterPageContainerQueue::Create (
|
|
const std::weak_ptr<ContainerAdapter>& rpContainer)
|
|
{
|
|
MasterPageContainerQueue* pQueue = new MasterPageContainerQueue(rpContainer);
|
|
pQueue->LateInit();
|
|
return pQueue;
|
|
}
|
|
|
|
MasterPageContainerQueue::MasterPageContainerQueue (
|
|
std::weak_ptr<ContainerAdapter> pContainer)
|
|
: mpWeakContainer(std::move(pContainer)),
|
|
mpRequestQueue(new RequestQueue()),
|
|
maDelayedPreviewCreationTimer("sd MasterPageContainerQueue maDelayedPreviewCreationTimer"),
|
|
mnRequestsServedCount(0)
|
|
{
|
|
}
|
|
|
|
MasterPageContainerQueue::~MasterPageContainerQueue()
|
|
{
|
|
maDelayedPreviewCreationTimer.Stop();
|
|
while ( ! mpRequestQueue->empty())
|
|
mpRequestQueue->erase(mpRequestQueue->begin());
|
|
}
|
|
|
|
void MasterPageContainerQueue::LateInit()
|
|
{
|
|
// Set up the timer for the delayed creation of preview bitmaps.
|
|
maDelayedPreviewCreationTimer.SetTimeout (snDelayedCreationTimeout);
|
|
maDelayedPreviewCreationTimer.SetInvokeHandler(
|
|
LINK(this,MasterPageContainerQueue,DelayedPreviewCreation) );
|
|
}
|
|
|
|
bool MasterPageContainerQueue::RequestPreview (const SharedMasterPageDescriptor& rpDescriptor)
|
|
{
|
|
bool bSuccess (false);
|
|
if (rpDescriptor
|
|
&& rpDescriptor->maLargePreview.GetSizePixel().Width() == 0)
|
|
{
|
|
sal_Int32 nPriority (CalculatePriority(rpDescriptor));
|
|
|
|
// Add a new or replace an existing request.
|
|
RequestQueue::iterator iRequest (::std::find_if(
|
|
mpRequestQueue->begin(),
|
|
mpRequestQueue->end(),
|
|
PreviewCreationRequest::CompareToken(rpDescriptor->maToken)));
|
|
// When a request for the same token exists then the lowest of the
|
|
// two priorities is used.
|
|
if (iRequest != mpRequestQueue->end())
|
|
if (iRequest->mnPriority < nPriority)
|
|
{
|
|
mpRequestQueue->erase(iRequest);
|
|
iRequest = mpRequestQueue->end();
|
|
}
|
|
|
|
// Add a new request when none exists (or has just been erased).
|
|
if (iRequest == mpRequestQueue->end())
|
|
{
|
|
mpRequestQueue->insert(PreviewCreationRequest(rpDescriptor,nPriority));
|
|
maDelayedPreviewCreationTimer.Start();
|
|
bSuccess = true;
|
|
}
|
|
}
|
|
return bSuccess;
|
|
}
|
|
|
|
sal_Int32 MasterPageContainerQueue::CalculatePriority (
|
|
const SharedMasterPageDescriptor& rpDescriptor)
|
|
{
|
|
sal_Int32 nPriority;
|
|
|
|
// The cost is used as a starting value.
|
|
int nCost (0);
|
|
if (rpDescriptor->mpPreviewProvider != nullptr)
|
|
{
|
|
nCost = rpDescriptor->mpPreviewProvider->GetCostIndex();
|
|
if (rpDescriptor->mpPreviewProvider->NeedsPageObject())
|
|
if (rpDescriptor->mpPageObjectProvider != nullptr)
|
|
nCost += rpDescriptor->mpPageObjectProvider->GetCostIndex();
|
|
}
|
|
|
|
// Its negative value is used so that requests with a low cost are
|
|
// preferred over those with high costs.
|
|
nPriority = -nCost;
|
|
|
|
// Add a term that introduces an order based on the appearance in the
|
|
// AllMasterPagesSelector.
|
|
nPriority -= rpDescriptor->maToken / 3;
|
|
|
|
// Process requests for the CurrentMasterPagesSelector first.
|
|
if (rpDescriptor->meOrigin == MasterPageContainer::MASTERPAGE)
|
|
nPriority += snMasterPagePriorityBoost;
|
|
|
|
return nPriority;
|
|
}
|
|
|
|
IMPL_LINK(MasterPageContainerQueue, DelayedPreviewCreation, Timer*, pTimer, void)
|
|
{
|
|
bool bIsShowingFullScreenShow (false);
|
|
bool bWaitForMoreRequests (false);
|
|
|
|
do
|
|
{
|
|
if (mpRequestQueue->empty())
|
|
break;
|
|
|
|
// First check whether the system is idle.
|
|
tools::IdleState nIdleState (tools::IdleDetection::GetIdleState(nullptr));
|
|
if (nIdleState != tools::IdleState::Idle)
|
|
{
|
|
if (nIdleState & tools::IdleState::FullScreenShowActive)
|
|
bIsShowingFullScreenShow = true;
|
|
break;
|
|
}
|
|
|
|
PreviewCreationRequest aRequest (*mpRequestQueue->begin());
|
|
|
|
// Check if the request should really be processed right now.
|
|
// Reasons to not do it are when its cost is high and not many other
|
|
// requests have been inserted into the queue that would otherwise
|
|
// be processed first.
|
|
if (aRequest.mnPriority < snWaitForMoreRequestsPriorityThreshold
|
|
&& (mnRequestsServedCount+mpRequestQueue->size() < snWaitForMoreRequestsCount))
|
|
{
|
|
// Wait for more requests before this one is processed. Note
|
|
// that the queue processing is not started anew when this
|
|
// method is left. That is done when the next request is
|
|
// inserted.
|
|
bWaitForMoreRequests = true;
|
|
break;
|
|
}
|
|
|
|
mpRequestQueue->erase(mpRequestQueue->begin());
|
|
|
|
if (aRequest.mpDescriptor)
|
|
{
|
|
mnRequestsServedCount += 1;
|
|
if ( ! mpWeakContainer.expired())
|
|
{
|
|
std::shared_ptr<ContainerAdapter> pContainer (mpWeakContainer);
|
|
if (pContainer != nullptr)
|
|
pContainer->UpdateDescriptor(aRequest.mpDescriptor,false,true,true);
|
|
}
|
|
}
|
|
}
|
|
while (false);
|
|
|
|
if (!mpRequestQueue->empty() && ! bWaitForMoreRequests)
|
|
{
|
|
int nTimeout (snDelayedCreationTimeout);
|
|
if (bIsShowingFullScreenShow)
|
|
nTimeout = snDelayedCreationTimeoutWhenNotIdle;
|
|
maDelayedPreviewCreationTimer.SetTimeout(nTimeout);
|
|
pTimer->Start();
|
|
}
|
|
}
|
|
|
|
bool MasterPageContainerQueue::HasRequest (MasterPageContainer::Token aToken) const
|
|
{
|
|
return std::any_of(
|
|
mpRequestQueue->begin(),
|
|
mpRequestQueue->end(),
|
|
PreviewCreationRequest::CompareToken(aToken));
|
|
}
|
|
|
|
bool MasterPageContainerQueue::IsEmpty() const
|
|
{
|
|
return mpRequestQueue->empty();
|
|
}
|
|
|
|
void MasterPageContainerQueue::ProcessAllRequests()
|
|
{
|
|
snWaitForMoreRequestsCount = 0;
|
|
if (!mpRequestQueue->empty())
|
|
maDelayedPreviewCreationTimer.Start();
|
|
}
|
|
|
|
} // end of namespace sd::sidebar
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|