b954a2409b
This may make short lived progress bars somewhat more 'blocky' and less smooth - but inevitably make loading faster, particularly for loaded machines with ultra-beautiful, slow to render themed progress-bars. Change-Id: I5a7e43690f5e7eff35c980cae4991376204eb5fb Reviewed-on: https://gerrit.libreoffice.org/c/core/+/171503 Tested-by: Jenkins Reviewed-by: Noel Grandin <noel.grandin@collabora.co.uk>
174 lines
4.7 KiB
C++
174 lines
4.7 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 <sal/config.h>
|
|
|
|
#include <com/sun/star/uno/Reference.hxx>
|
|
#include <com/sun/star/util/XUpdatable.hpp>
|
|
#include <rtl/ref.hxx>
|
|
#include <osl/thread.hxx>
|
|
#include <salhelper/thread.hxx>
|
|
#include <condition_variable>
|
|
#include <chrono>
|
|
#include <vector>
|
|
#include <mutex>
|
|
|
|
#include <helper/wakeupthread.hxx>
|
|
|
|
using namespace std::chrono_literals;
|
|
|
|
/// We only need one thread to wake everyone up.
|
|
|
|
namespace
|
|
{
|
|
class SharedWakeUpThread final : public salhelper::Thread
|
|
{
|
|
static std::vector<css::uno::WeakReference<css::util::XUpdatable>> updatables;
|
|
std::condition_variable condition;
|
|
bool terminate;
|
|
|
|
public:
|
|
static rtl::Reference<SharedWakeUpThread> wakeupThread;
|
|
|
|
static std::mutex& getMutex()
|
|
{
|
|
static std::mutex mutex;
|
|
return mutex;
|
|
}
|
|
|
|
SharedWakeUpThread()
|
|
: Thread("WakeUpThread")
|
|
, terminate(false)
|
|
{
|
|
assert(!wakeupThread);
|
|
launch();
|
|
}
|
|
|
|
void execute() override
|
|
{
|
|
while (true)
|
|
{
|
|
std::unique_lock g(getMutex());
|
|
condition.wait_for(g, 200ms, [this] { return terminate; });
|
|
if (terminate || updatables.empty())
|
|
break;
|
|
|
|
auto copyOfUpdatables = updatables;
|
|
g.unlock();
|
|
|
|
for (auto& it : copyOfUpdatables)
|
|
{
|
|
css::uno::Reference<css::util::XUpdatable> up(it);
|
|
if (up.is()) // check weak
|
|
up->update();
|
|
}
|
|
}
|
|
|
|
std::unique_lock g(getMutex());
|
|
if (updatables.empty())
|
|
{
|
|
terminate = false;
|
|
wakeupThread.clear();
|
|
}
|
|
}
|
|
|
|
static void startThread()
|
|
{
|
|
std::unique_lock g(getMutex());
|
|
if (!updatables.empty() && !wakeupThread)
|
|
wakeupThread = new SharedWakeUpThread();
|
|
}
|
|
|
|
void stopWithLock(std::unique_lock<std::mutex>& g)
|
|
{
|
|
terminate = true;
|
|
condition.notify_one();
|
|
g.unlock();
|
|
|
|
join();
|
|
}
|
|
|
|
static void disposeThreadWithLock(std::unique_lock<std::mutex>& g)
|
|
{
|
|
if (wakeupThread)
|
|
{
|
|
auto holdRef = wakeupThread;
|
|
wakeupThread.clear();
|
|
holdRef->stopWithLock(g);
|
|
}
|
|
assert(!wakeupThread);
|
|
}
|
|
|
|
static void add(css::uno::WeakReference<css::util::XUpdatable> up)
|
|
{
|
|
std::unique_lock g(getMutex());
|
|
updatables.push_back(up);
|
|
if (!wakeupThread)
|
|
wakeupThread = new SharedWakeUpThread();
|
|
}
|
|
|
|
static void remove(css::uno::WeakReference<css::util::XUpdatable> up)
|
|
{
|
|
std::unique_lock g(getMutex());
|
|
auto it = updatables.begin();
|
|
bool found = false;
|
|
for (; it != updatables.end(); ++it)
|
|
{
|
|
css::uno::Reference<css::util::XUpdatable> itValid(*it);
|
|
if (!itValid || *it == up)
|
|
{
|
|
it = updatables.erase(it);
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
(void)found; assert(found);
|
|
if (updatables.empty())
|
|
disposeThreadWithLock(g);
|
|
}
|
|
|
|
static void joinThread()
|
|
{
|
|
std::unique_lock g(getMutex());
|
|
disposeThreadWithLock(g);
|
|
}
|
|
};
|
|
|
|
rtl::Reference<SharedWakeUpThread> SharedWakeUpThread::wakeupThread;
|
|
std::vector<css::uno::WeakReference<css::util::XUpdatable>> SharedWakeUpThread::updatables;
|
|
}
|
|
|
|
namespace framework
|
|
{
|
|
/* static */ void WakeUpThread::startThread() { SharedWakeUpThread::startThread(); }
|
|
|
|
WakeUpThread::WakeUpThread(css::uno::Reference<css::util::XUpdatable> const& up)
|
|
: _updatable(up)
|
|
{
|
|
assert(_updatable);
|
|
SharedWakeUpThread::add(_updatable);
|
|
}
|
|
|
|
void WakeUpThread::stop() { SharedWakeUpThread::remove(_updatable); }
|
|
|
|
/* static */ void WakeUpThread::joinThread() { SharedWakeUpThread::joinThread(); }
|
|
|
|
} // namespace framework
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|