KisFilterManager Class Reference

#include <kis_filter_manager.h>

Inheritance diagram for KisFilterManager:

Classes
struct	Private

Public Member Functions
void	apply (KisFilterConfigurationSP filterConfig)
void	cancelDialog ()
	Call cancelRunningStroke() and then delete dialog d
void	cancelRunningStroke ()
	Cancel current running stroke.
bool	filterAllSelectedFrames ()
void	finish ()
bool	isIdle () const
bool	isStrokeRunning () const
	KisFilterManager (KisViewManager *parent)
void	setFilterAllSelectedFrames (bool filterAllSelectedFrames)
void	setup (KisKActionCollection *ac, KisActionManager *actionManager)
void	setView (QPointer< KisView >imageView)
void	updateGUI ()
	~KisFilterManager () override

Private Slots
void	filterDialogHasFinished (int)
	Clean up after filter dialog has been accepted / rejected / closed.
void	insertFilter (const QString &name)
void	reapplyLastFilter ()
void	reapplyLastFilterReprompt ()
void	showFilterDialog (const QString &filterId, KisFilterConfigurationSP overrideDefaultConfig=nullptr)
void	slotStrokeCancelRequested ()
void	slotStrokeEndRequested ()

Private Attributes
QScopedPointer< Private >	d

Detailed Description

Create all the filter actions for the specified view and implement re-apply filter

Definition at line 23 of file kis_filter_manager.h.

Constructor & Destructor Documentation

KisFilterManager()

KisFilterManager::KisFilterManager

(

KisViewManager *

parent

)

Definition at line 74 of file kis_filter_manager.cc.

    : d(new Private)
{
    d->view = view;
}

References d.

~KisFilterManager()

KisFilterManager::~KisFilterManager ( )

override

Definition at line 80 of file kis_filter_manager.cc.

{
}

Member Function Documentation

apply()

void KisFilterManager::apply

(

KisFilterConfigurationSP

filterConfig

)

Definition at line 269 of file kis_filter_manager.cc.

{
    KisFilterConfigurationSP filterConfig = _filterConfig->cloneWithResourcesSnapshot();
 
    KisFilterSP filter = KisFilterRegistry::instance()->value(filterConfig->name());
    KisImageWSP image = d->view->image();
 
    if (d->currentStrokeId) {
        image->cancelStroke(d->currentStrokeId);
 
        d->currentStrokeId.clear();
        d->idleBarrierCookie.clear();
    } else {
        image->waitForDone();
    }
 
    if (!d->externalCancelUpdatesStorage) {
        // Lazily initialize the cancel updates storage, just in case
        // if the stroke has been cancelled in the meantime.
 
        d->externalCancelUpdatesStorage.reset(new KisFilterStrokeStrategy::ExternalCancelUpdatesStorage());
    }
 
    KoCanvasResourceProvider *resourceManager =
        d->view->canvasResourceProvider()->resourceManager();
 
    KisResourcesSnapshotSP resources =
        new KisResourcesSnapshot(image,
                                 d->view->activeNode(),
                                 resourceManager);
 
    KisFilterStrokeStrategy *strategy = new KisFilterStrokeStrategy(filter,
                                                                    KisFilterConfigurationSP(filterConfig),
                                                                    resources,
                                                                    d->externalCancelUpdatesStorage.toWeakRef());
    {
        KConfigGroup group( KSharedConfig::openConfig(), "filterdialog");
        strategy->setForceLodModeIfPossible(group.readEntry("forceLodMode", true));
    }
 
    d->currentStrokeId =
        image->startStroke(strategy);
 
    // Apply filter preview to active, visible frame only.
    KisImageConfig imgConf(true);
    image->addJob(d->currentStrokeId, new KisFilterStrokeStrategy::FilterJobData());
 
    {
        KisFilterStrokeStrategy::IdleBarrierData *data =
            new KisFilterStrokeStrategy::IdleBarrierData();
        d->idleBarrierCookie = data->idleBarrierCookie();
        image->addJob(d->currentStrokeId, data);
    }
 
    d->currentlyAppliedConfiguration = filterConfig;
}

References KisImage::addJob(), KisImage::cancelStroke(), d, KisFilterStrokeStrategy::IdleBarrierData::idleBarrierCookie(), KisFilterRegistry::instance(), KisStrokeStrategy::setForceLodModeIfPossible(), KisImage::startStroke(), KoGenericRegistry< T >::value(), and KisImage::waitForDone().

cancelDialog()

void KisFilterManager::cancelDialog

(

)

Call cancelRunningStroke() and then delete dialog d

Definition at line 375 of file kis_filter_manager.cc.

{
    cancelRunningStroke();
 
    d->filterDialog->reject();
}

References cancelRunningStroke(), and d.

cancelRunningStroke()

void KisFilterManager::cancelRunningStroke

(

)

Cancel current running stroke.

Definition at line 361 of file kis_filter_manager.cc.

{
    Q_ASSERT(d->currentStrokeId);
 
    // we should to notify the stroke that it should do the updates itself.
    d->externalCancelUpdatesStorage->shouldIssueCancellationUpdates.ref();
    d->view->image()->cancelStroke(d->currentStrokeId);
 
    d->currentStrokeId.clear();
    d->idleBarrierCookie.clear();
    d->currentlyAppliedConfiguration.clear();
    d->externalCancelUpdatesStorage.clear();
}

References d.

filterAllSelectedFrames()

bool KisFilterManager::filterAllSelectedFrames

(

)

Definition at line 397 of file kis_filter_manager.cc.

{
    return d->filterAllSelectedFrames;
}

References d.

filterDialogHasFinished

void KisFilterManager::filterDialogHasFinished ( int )

privateslot

Clean up after filter dialog has been accepted / rejected / closed.

Definition at line 415 of file kis_filter_manager.cc.

{
    // as far as we are concerned, filterDialog has been deleted
    d->filterDialog = nullptr;
}

References d.

finish()

void KisFilterManager::finish

(

)

Definition at line 326 of file kis_filter_manager.cc.

{
    Q_ASSERT(d->currentStrokeId);
 
    if (d->filterAllSelectedFrames) {   // Apply filter to the other selected frames...
        KisImageSP image = d->view->image();
        KisPaintDeviceSP paintDevice = d->view->activeNode()->paintDevice();
        KisNodeSP node = d->view->activeNode();
 
        // Filter selected times to only those with keyframes...
        QSet<int> selectedTimes = image->animationInterface()->activeLayerSelectedTimes();
        selectedTimes = KisLayerUtils::filterTimesForOnlyRasterKeyedTimes(node, selectedTimes);
        QSet<int> uniqueFrames = KisLayerUtils::fetchUniqueFrameTimes(node, selectedTimes, true);
 
        Q_FOREACH(const int& frameTime, uniqueFrames) {
            image->addJob(d->currentStrokeId, new KisFilterStrokeStrategy::FilterJobData(frameTime));
        }
    }
 
    d->view->image()->endStroke(d->currentStrokeId);
 
    KisFilterSP filter = KisFilterRegistry::instance()->value(d->currentlyAppliedConfiguration->name());
    if (filter->bookmarkManager()) {
        filter->bookmarkManager()->save(KisBookmarkedConfigurationManager::ConfigLastUsed,
                                       d->currentlyAppliedConfiguration.data());
    }
 
    d->lastConfiguration = d->currentlyAppliedConfiguration;
    d->reapplyAction->setEnabled(true);
    d->reapplyAction->setText(i18n("Apply Filter Again: %1", filter->name()));
 
    d->idleBarrierCookie.clear();
    d->currentlyAppliedConfiguration.clear();
}

References KisImageAnimationInterface::activeLayerSelectedTimes(), KisImage::addJob(), KisImage::animationInterface(), KisBaseProcessor::bookmarkManager, KisBookmarkedConfigurationManager::ConfigLastUsed, d, KisLayerUtils::fetchUniqueFrameTimes(), KisLayerUtils::filterTimesForOnlyRasterKeyedTimes(), KisFilterRegistry::instance(), KisBaseProcessor::name(), KisBookmarkedConfigurationManager::save(), and KoGenericRegistry< T >::value().

insertFilter

void KisFilterManager::insertFilter ( const QString & name )

privateslot

Definition at line 119 of file kis_filter_manager.cc.

{
    Q_ASSERT(d->actionCollection);
 
    KisFilterSP filter = KisFilterRegistry::instance()->value(filterName);
    Q_ASSERT(filter);
 
    if (d->filters2Action.contains(filter.data())) {
        warnKrita << "Filter" << filterName << " has already been inserted";
        return;
    }
 
    KoID category = filter->menuCategory();
    KActionMenu* actionMenu = d->filterActionMenus[ category.id()];
    if (!actionMenu) {
        actionMenu = new KActionMenu(category.name(), this);
        d->actionCollection->addAction(category.id(), actionMenu);
        d->filterActionMenus[category.id()] = actionMenu;
    }
 
    KisAction *action = new KisAction(filter->menuEntry(), this);
    action->setDefaultShortcut(filter->shortcut());
    action->setActivationFlags(KisAction::ACTIVE_DEVICE);
 
    d->actionManager->addAction(QString("krita_filter_%1").arg(filterName), action);
    d->filters2Action[filter.data()] = action;
 
    actionMenu->addAction(action);
 
    d->actionsMapper.setMapping(action, filterName);
    connect(action, SIGNAL(triggered()), &d->actionsMapper, SLOT(map()));
}

References KisAction::ACTIVE_DEVICE, connect(), d, KisSharedPtr< T >::data(), KoID::id(), KisFilterRegistry::instance(), KisBaseProcessor::menuCategory(), KisBaseProcessor::menuEntry(), KoID::name(), KisAction::setActivationFlags(), KisAction::setDefaultShortcut(), KisBaseProcessor::shortcut, KoGenericRegistry< T >::value(), and warnKrita.

isIdle()

bool KisFilterManager::isIdle

(

)

const

Definition at line 387 of file kis_filter_manager.cc.

{
    return !d->idleBarrierCookie;
}

References d.

isStrokeRunning()

bool KisFilterManager::isStrokeRunning

(

)

const

Definition at line 382 of file kis_filter_manager.cc.

{
    return bool(d->currentStrokeId);
}

References d.

reapplyLastFilter

void KisFilterManager::reapplyLastFilter ( )

privateslot

Definition at line 172 of file kis_filter_manager.cc.

{
    if (!d->lastConfiguration) return;
 
    apply(d->lastConfiguration);
    finish();
}

References apply(), d, and finish().

reapplyLastFilterReprompt

void KisFilterManager::reapplyLastFilterReprompt ( )

privateslot

Definition at line 180 of file kis_filter_manager.cc.

{
    if (!d->lastConfiguration) return;
 
    showFilterDialog(d->lastConfiguration->name(), d->lastConfiguration);
}

References d, and showFilterDialog().

setFilterAllSelectedFrames()

void KisFilterManager::setFilterAllSelectedFrames

(

bool

filterAllSelectedFrames

)

Definition at line 392 of file kis_filter_manager.cc.

{
    d->filterAllSelectedFrames = filterAllSelectedFrames;
}

References d, and filterAllSelectedFrames().

setup()

void KisFilterManager::setup	(	KisKActionCollection *	ac,
		KisActionManager *	actionManager )

Definition at line 90 of file kis_filter_manager.cc.

{
    d->actionCollection = ac;
    d->actionManager = actionManager;
 
    // Setup reapply action
    d->reapplyAction = d->actionManager->createAction("filter_apply_again");
    d->reapplyAction->setActivationFlags(KisAction::ACTIVE_DEVICE);
    d->reapplyAction->setEnabled(false);
 
    d->reapplyActionReprompt = d->actionManager->createAction("filter_apply_reprompt");
    d->reapplyActionReprompt->setActivationFlags(KisAction::ACTIVE_DEVICE);
    d->reapplyActionReprompt->setEnabled(false);
 
    connect(d->reapplyAction, SIGNAL(triggered()), SLOT(reapplyLastFilter()));
    connect(d->reapplyActionReprompt, SIGNAL(triggered()), SLOT(reapplyLastFilterReprompt()));
 
    connect(&d->actionsMapper, SIGNAL(mapped(QString)), SLOT(showFilterDialog(QString)));
 
    // Setup list of filters
    QStringList keys = KisFilterRegistry::instance()->keys();
    keys.sort();
    Q_FOREACH (const QString &filterName, keys) {
        insertFilter(filterName);
    }
 
    connect(KisFilterRegistry::instance(), SIGNAL(filterAdded(QString)), SLOT(insertFilter(QString)));
}

References KisAction::ACTIVE_DEVICE, connect(), KisActionManager::createAction(), d, insertFilter(), KisFilterRegistry::instance(), KoGenericRegistry< T >::keys(), reapplyLastFilter(), reapplyLastFilterReprompt(), KisAction::setActivationFlags(), and showFilterDialog().

setView()

void KisFilterManager::setView

(

QPointer< KisView >

imageView

)

Definition at line 84 of file kis_filter_manager.cc.

{
    Q_UNUSED(imageView);
}

showFilterDialog

void KisFilterManager::showFilterDialog ( const QString & filterId, KisFilterConfigurationSP overrideDefaultConfig = nullptr )

privateslot

The UI should show only after every running stroke is finished, so a virtual barrier is added here.

Definition at line 187 of file kis_filter_manager.cc.

{
    if (!d->view->activeNode()->isEditable()) {
        d->view->showFloatingMessage(i18n("Cannot apply filter to locked layer."),
                                      KisIconUtils::loadIcon("object-locked"));
        return;
    }
 
    if (d->filterDialog && d->filterDialog->isVisible()) {
        KisFilterSP filter = KisFilterRegistry::instance()->value(filterId);
        d->filterDialog->setFilter(filter, overrideDefaultConfig);
        return;
    }
 
    connect(d->view->image(),
            SIGNAL(sigStrokeCancellationRequested()),
            SLOT(slotStrokeCancelRequested()),
            Qt::UniqueConnection);
 
    connect(d->view->image(),
            SIGNAL(sigStrokeEndRequested()),
            SLOT(slotStrokeEndRequested()),
            Qt::UniqueConnection);
 
    if (!d->view->blockUntilOperationsFinished(d->view->image())) {
        return;
    }
 
    Q_ASSERT(d->view);
    Q_ASSERT(d->view->activeNode());
 
    KisPaintDeviceSP dev = d->view->activeNode()->paintDevice();
    if (!dev) {
        warnKrita << "KisFilterManager::showFilterDialog(): Filtering was requested for illegal active layer!" << d->view->activeNode();
        return;
    }
 
    KisFilterSP filter = KisFilterRegistry::instance()->value(filterId);
 
    if (dev->colorSpace()->willDegrade(filter->colorSpaceIndependence())) {
        // Warning bells!
        if (filter->colorSpaceIndependence() == TO_LAB16) {
            if (QMessageBox::warning(d->view->mainWindow(),
                                     i18nc("@title:window", "Krita"),
                                     i18n("The %1 filter will convert your %2 data to 16-bit L*a*b* and vice versa. ",
                                          filter->name(),
                                          dev->colorSpace()->name()),
                                     QMessageBox::Ok | QMessageBox::Cancel, QMessageBox::Ok)
                    != QMessageBox::Ok) return;
 
        } else if (filter->colorSpaceIndependence() == TO_RGBA16) {
            if (QMessageBox::warning(d->view->mainWindow(),
                                     i18nc("@title:window", "Krita"),
                                     i18n("The %1 filter will convert your %2 data to 16-bit RGBA and vice versa. ",
                                          filter->name() , dev->colorSpace()->name()),
                                     QMessageBox::Ok | QMessageBox::Cancel, QMessageBox::Ok)
                    != QMessageBox::Ok) return;
        }
    }
 
    if (filter->showConfigurationWidget()) {
        if (!d->filterDialog) {
            d->filterDialog = new KisDlgFilter(d->view , d->view->activeNode(), this, d->view->mainWindow());
            d->filterDialog->setAttribute(Qt::WA_DeleteOnClose); // make sure that the dialog is deleted when calling `done()`
            connect(d->filterDialog, SIGNAL(finished(int)),
                    this, SLOT(filterDialogHasFinished(int)));
        }
 
        d->filterDialog->setFilter(filter, overrideDefaultConfig);
        d->filterDialog->setVisible(true);
    } else {
        KisFilterConfigurationSP defaultConfiguration =
            overrideDefaultConfig ? overrideDefaultConfig : filter->defaultConfiguration(KisGlobalResourcesInterface::instance());
        apply(defaultConfiguration);
        finish();
    }
}

References apply(), KisPaintDevice::colorSpace(), KisBaseProcessor::colorSpaceIndependence, connect(), d, KisBaseProcessor::defaultConfiguration(), filterDialogHasFinished(), finish(), KisFilterRegistry::instance(), KisGlobalResourcesInterface::instance(), KisIconUtils::loadIcon(), KisBaseProcessor::name(), KoColorSpace::name, KisBaseProcessor::showConfigurationWidget, slotStrokeCancelRequested(), slotStrokeEndRequested(), TO_LAB16, TO_RGBA16, KoGenericRegistry< T >::value(), warnKrita, and KoColorSpace::willDegrade().

slotStrokeCancelRequested

void KisFilterManager::slotStrokeCancelRequested ( )

privateslot

Definition at line 409 of file kis_filter_manager.cc.

{
    if (d->currentStrokeId && d->filterDialog) {
        d->filterDialog->reject();
    }
}

References d.

slotStrokeEndRequested

void KisFilterManager::slotStrokeEndRequested ( )

privateslot

Definition at line 402 of file kis_filter_manager.cc.

{
    if (d->currentStrokeId && d->filterDialog) {
        d->filterDialog->accept();
    }
}

References d.

updateGUI()

void KisFilterManager::updateGUI

(

)

Definition at line 152 of file kis_filter_manager.cc.

{
    if (!d->view) return;
 
    bool enable = false;
 
    KisNodeSP activeNode = d->view->activeNode();
    enable = activeNode && activeNode->hasEditablePaintDevice();
 
    d->reapplyAction->setEnabled(enable);
 
    for (QHash<KisFilter*, QAction *>::iterator it = d->filters2Action.begin();
            it != d->filters2Action.end(); ++it) {
 
        bool localEnable = enable;
 
        it.value()->setEnabled(localEnable);
    }
}

References d, and KisBaseNode::hasEditablePaintDevice().

Member Data Documentation

d

QScopedPointer<Private> KisFilterManager::d

private

Definition at line 65 of file kis_filter_manager.h.

---

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

• libs/ui/kis_filter_manager.h
• libs/ui/kis_filter_manager.cc