KisIdleTasksManager Class Reference

#include <KisIdleTasksManager.h>

Inheritance diagram for KisIdleTasksManager:

Classes
struct	Private
struct	TaskGuard

Public Member Functions
TaskGuard	addIdleTaskWithGuard (KisIdleTaskStrokeStrategyFactory factory)
	Registers the factory for the idle task.
	KisIdleTasksManager ()
void	setImage (KisImageSP image)
	~KisIdleTasksManager ()

Private Slots
void	slotImageIsIdle ()
void	slotImageIsModified ()
void	slotTaskIsCompleted ()

Private Member Functions
int	addIdleTask (KisIdleTaskStrokeStrategyFactory factory)
void	removeIdleTask (int id)
void	triggerIdleTask (int id)

Private Attributes
QScopedPointer< Private >	m_d

Detailed Description

A special per-main-window manager that handles jobs that should be run in the background while the user is idle. The manager automatically restarts all the jobs when the image is modified. E.g. updates the overview image or histogram.

The manager is owned by KisViewManager, which automatically connects it to the currently active image. When the image becomes idle, the manager starts its tasks one-by-one.

If you want to add a new task to the manager, just provide a factory to addIdleTaskWithGuard() method. This factory should create and return a stroke strategy for the idle task to be run.

The factory will be called by the task manager every time when it thinks that the idle task should be started.

addIdleTaskWithGuard() returns a TaskGuard handle, which represents the registered task. It is a movable object that will automatically de-register the idle task on destruction.

If your idle-task-factory is a lambda object, make sure that the lifetime of the objects you capture into the lambda's closure is longer than the lifetime of the corresponding TaskGuard handle. In other words, if you capture this into your lambda, make sure that the corresponding TaskGuard also belongs to this or destroyed manually in the destructor.

Definition at line 46 of file KisIdleTasksManager.h.

Constructor & Destructor Documentation

KisIdleTasksManager()

KisIdleTasksManager::KisIdleTasksManager

(

)

Definition at line 36 of file KisIdleTasksManager.cpp.

    : m_d(new Private())
{
    connect(&m_d->idleWatcher, SIGNAL(startedIdleMode()), SLOT(slotImageIsIdle()));
    connect(&m_d->idleWatcher, SIGNAL(imageModified()), SLOT(slotImageIsModified()));
}

References connect(), m_d, slotImageIsIdle(), and slotImageIsModified().

~KisIdleTasksManager()

KisIdleTasksManager::~KisIdleTasksManager ( )

default

Member Function Documentation

addIdleTask()

int KisIdleTasksManager::addIdleTask ( KisIdleTaskStrokeStrategyFactory factory )

private

TODO: don't restart the whole queue on the the task change, just restart the currently added task

Definition at line 57 of file KisIdleTasksManager.cpp.

{
    const int newId =
        !m_d->tasks.isEmpty() ?
        m_d->tasks.last().id + 1 : 0;
 
    m_d->tasks.append({newId, factory});
    triggerIdleTask(newId);
 
    return newId;
}

References m_d, and triggerIdleTask().

addIdleTaskWithGuard()

KisIdleTasksManager::TaskGuard KisIdleTasksManager::addIdleTaskWithGuard

(

KisIdleTaskStrokeStrategyFactory

factory

)

Registers the factory for the idle task.

The manager will use this factory to start the task after every image modification.

Parameters

factory

is a functor creating a KisIdleTaskStrokeStrategy that will actually execute the task

Returns

a TaskGuard object that can be used for task manipulations

Definition at line 107 of file KisIdleTasksManager.cpp.

{
    return {addIdleTask(factory), this};
}

References addIdleTask().

removeIdleTask()

void KisIdleTasksManager::removeIdleTask ( int id )

private

Definition at line 74 of file KisIdleTasksManager.cpp.

{
    {
        auto it = std::remove_if(m_d->tasks.begin(), m_d->tasks.end(),
                                 kismpl::mem_equal_to(&TaskStruct::id, id));
        KIS_SAFE_ASSERT_RECOVER_NOOP(it != m_d->tasks.end());
        m_d->tasks.erase(it, m_d->tasks.end());
    }
 
    {
        auto it = std::remove(m_d->queue.begin(), m_d->queue.end(), id);
        m_d->queue.erase(it, m_d->queue.end());
    }
}

References KIS_SAFE_ASSERT_RECOVER_NOOP, m_d, and kismpl::mem_equal_to().

setImage()

void KisIdleTasksManager::setImage

(

KisImageSP

image

)

Definition at line 45 of file KisIdleTasksManager.cpp.

{
    m_d->idleWatcher.setTrackedImage(image);
    m_d->image = image;
    m_d->queue.clear();
 
    if (image) {
        slotImageIsModified();
        m_d->idleWatcher.triggerCountdownNoDelay();
    }
}

References m_d, and slotImageIsModified().

slotImageIsIdle

void KisIdleTasksManager::slotImageIsIdle ( )

privateslot

Definition at line 121 of file KisIdleTasksManager.cpp.

{
    KisImageSP image = m_d->image;
    if (!image) return;
 
    if (m_d->currentTaskCookie) {
        m_d->idleWatcher.restartCountdown();
        return;
    }
 
    if (m_d->queue.isEmpty()) return;
 
    const int newTaskId = m_d->queue.dequeue();
 
    auto it = std::find_if(m_d->tasks.begin(), m_d->tasks.end(),
                           kismpl::mem_equal_to(&TaskStruct::id, newTaskId));
    KIS_SAFE_ASSERT_RECOVER_NOOP(it != m_d->tasks.end());
 
    KisIdleTaskStrokeStrategy *strategy = it->factory(image);
 
    connect(strategy, SIGNAL(sigIdleTaskFinished()), SLOT(slotTaskIsCompleted()));
    m_d->currentTaskCookie = strategy->idleTaskCookie();
 
    KisStrokeId strokeId = image->startStroke(strategy);
    image->endStroke(strokeId);
}

References connect(), KisImage::endStroke(), KisIdleTaskStrokeStrategy::idleTaskCookie(), KIS_SAFE_ASSERT_RECOVER_NOOP, m_d, kismpl::mem_equal_to(), slotTaskIsCompleted(), and KisImage::startStroke().

slotImageIsModified

void KisIdleTasksManager::slotImageIsModified ( )

privateslot

Definition at line 112 of file KisIdleTasksManager.cpp.

{
    m_d->queue.clear();
    m_d->queue.reserve(m_d->tasks.size());
    std::transform(m_d->tasks.begin(), m_d->tasks.end(),
                   std::back_inserter(m_d->queue),
                   std::mem_fn(&TaskStruct::id));
}

References m_d.

slotTaskIsCompleted

void KisIdleTasksManager::slotTaskIsCompleted ( )

privateslot

Definition at line 148 of file KisIdleTasksManager.cpp.

{
    if (m_d->queue.isEmpty()) {
        // all tasks are completed!
    } else {
        if (m_d->idleWatcher.isIdle()) {
            slotImageIsIdle();
        } else if (!m_d->idleWatcher.isCounting()) {
            m_d->idleWatcher.restartCountdown();
        }
    }
}

References m_d, and slotImageIsIdle().

triggerIdleTask()

void KisIdleTasksManager::triggerIdleTask ( int id )

private

Definition at line 89 of file KisIdleTasksManager.cpp.

{
    {
        // just verify that this tasks actually exists
        auto it = std::find_if(m_d->tasks.begin(), m_d->tasks.end(),
                               kismpl::mem_equal_to(&TaskStruct::id, id));
        KIS_SAFE_ASSERT_RECOVER_NOOP(it != m_d->tasks.end());
    }
 
    auto it = std::find(m_d->queue.begin(), m_d->queue.end(), id);
    if (it == m_d->queue.end()) {
        m_d->queue.enqueue(id);
    }
 
    m_d->idleWatcher.triggerCountdownNoDelay();
}

References KIS_SAFE_ASSERT_RECOVER_NOOP, m_d, and kismpl::mem_equal_to().

Member Data Documentation

m_d

QScopedPointer<Private> KisIdleTasksManager::m_d

private

Definition at line 138 of file KisIdleTasksManager.h.

---

The documentation for this class was generated from the following files:

• libs/ui/KisIdleTasksManager.h
• libs/ui/KisIdleTasksManager.cpp