A KisActionManager class keeps track of KisActions. These actions are always associated with the GUI. That means each MainWindow will create its own duplicate of these actions. More...

#include <kis_action_manager.h>

Inheritance diagram for KisActionManager:

Public Member Functions
KisAction *	actionByName (const QString &name) const

void	addAction (const QString &name, KisAction *action)

KisAction *	createAction (const QString &name)

KisAction *	createStandardAction (KStandardAction::StandardAction, const QObject receiver, const char member)

	KisActionManager (KisViewManager viewManager, KisKActionCollection actionCollection)

	Private ()

void	registerOperation (KisOperation *operation)

void	registerOperationUIFactory (KisOperationUIFactory *factory)

void	runOperation (const QString &id)

void	runOperationFromConfiguration (KisOperationConfigurationSP config)

void	setView (QPointer< KisView > imageView)

void	takeAction (KisAction *action)

void	updateGUI ()

	~KisActionManager () override

	~Private ()

Static Public Member Functions
static void	safePopulateMenu (QMenu menu, const QString &actionId, KisActionManager actionManager)

Public Attributes
KisKActionCollection *	actionCollection {nullptr}

QList< QPointer< KisAction > >	actions

KisOperationRegistry	operationRegistry

KoGenericRegistry< KisOperationUIFactory * >	uiRegistry

KisViewManager *	viewManager {nullptr}

Private Slots
void	slotActionAddedToCollection (QAction *action)

Private Member Functions
void	dumpActionFlags ()

Private Member Functions inherited from Private
	Private (KisCanvas2 *c)

Private Attributes
Private *const	d

Private Attributes inherited from Private
KisCanvas2 *	canvas

int	displayedFrame

int	intendedFrame

Detailed Description

A KisActionManager class keeps track of KisActions. These actions are always associated with the GUI. That means each MainWindow will create its own duplicate of these actions.

KisActionManager enables and disables actions, to grey out buttons according to the state of the application.

Some of the primitive actions (load/save and so on) are not defined as KisActions, but instead KActions, automatically registered through KisKXMLGUI. It tracks these actions through the KisKActionCollection owned by the window. Ultimately it would be nice to unify these things more fully.

Definition at line 32 of file kis_action_manager.cpp.

Constructor & Destructor Documentation

◆ ~Private()

KisActionManager::~Private ( )

inline

Definition at line 37 of file kis_action_manager.cpp.

    {
        qDeleteAll(uiRegistry.values());
    }

◆ KisActionManager()

KisActionManager::KisActionManager	(	KisViewManager *	viewManager,
		KisKActionCollection *	actionCollection )

Definition at line 51 of file kis_action_manager.cpp.

    : d(new Private)
{
    d->viewManager = viewManager;
    d->actionCollection = actionCollection;
 
    connect(d->actionCollection,
            SIGNAL(inserted(QAction*)), SLOT(slotActionAddedToCollection(QAction*)));
}

References actionCollection, connect(), d, slotActionAddedToCollection(), and viewManager.

◆ ~KisActionManager()

KisActionManager::~KisActionManager ( )

override

Definition at line 61 of file kis_action_manager.cpp.

{
 
#if 0
  if ((d->actions.size() > 0)) {
 
       QDomDocument doc;
       QDomElement e = doc.createElement("Actions");
       e.setAttribute("version", "2");
       doc.appendChild(e);
 
       Q_FOREACH (KisAction *action, d->actions) {
           QDomElement a = doc.createElement("Action");
           a.setAttribute("name", action->objectName());
 
           // But seriously, XML is the worst format ever designed
           auto addElement = [&](QString title, QString content) {
               QDomElement newNode = doc.createElement(title);
               QDomText    newText = doc.createTextNode(content);
               newNode.appendChild(newText);
               a.appendChild(newNode);
           };
 
           addElement("icon", action->icon().name());
           addElement("text", action->text());
           addElement("whatsThis" , action->whatsThis());
           addElement("toolTip" , action->toolTip());
           addElement("iconText" , action->iconText());
           addElement("shortcut" , action->shortcut().toString());
           addElement("activationFlags" , QString::number(action->activationFlags(),2));
           addElement("activationConditions" , QString::number(action->activationConditions(),2));
           addElement("defaultShortcut" , action->defaultShortcut().toString());
           addElement("isCheckable" , QString((action->isChecked() ? "true" : "false")));
           addElement("statusTip", action->statusTip());
           e.appendChild(a);
       }
       QFile f("ActionManager.action");
       f.open(QFile::WriteOnly);
       f.write(doc.toString().toUtf8());
       f.close();
 
   }
#endif
    delete d;
}

References KisAction::activationConditions(), KisAction::activationFlags(), d, and KisAction::defaultShortcut().

Member Function Documentation

◆ actionByName()

KisAction * KisActionManager::actionByName ( const QString & name ) const

Look up an action by name.

Definition at line 147 of file kis_action_manager.cpp.

{
    Q_FOREACH (KisAction *action, d->actions) {
        if (action->objectName() == name) {
            return action;
        }
    }
    return 0;
}

References d.

◆ addAction()

void KisActionManager::addAction	(	const QString &	name,
		KisAction *	action )

Add an existing action to the action manager.

Definition at line 123 of file kis_action_manager.cpp.

{
    Q_ASSERT(!name.isEmpty());
    Q_ASSERT(action);
    Q_ASSERT(d->viewManager);
    Q_ASSERT(d->actionCollection);
 
    d->actionCollection->addAction(name, action);
    action->setParent(d->actionCollection);
 
    d->actions.append(action);
    action->setActionManager(this);
}

References d, and KisAction::setActionManager().

◆ createAction()

KisAction * KisActionManager::createAction ( const QString & name )

Create a new KisAction. Looks up data from the .action data files.

Definition at line 158 of file kis_action_manager.cpp.

{
    KisAction *a = actionByName(name); // Check if the action already exists
 
    if (a) {
        dbgAction << name << "already exists";
        return a;
    }
 
    // There is some tension here. KisActionManager is supposed to be in control
    // of global actions, but these actions are supposed to be duplicated. We
    // will add them to the KisActionRegistry for the time being so we can get
    // properly categorized shortcuts.
    a = new KisAction();
 
    KisActionRegistry *actionRegistry = KisActionRegistry::instance();
 
    // Add extra properties
    actionRegistry->propertizeAction(name, a);
    bool ok; // We will skip this check
    int activationFlags = actionRegistry->getActionProperty(name, "activationFlags").toInt(&ok, 2);
    int activationConditions = actionRegistry->getActionProperty(name, "activationConditions").toInt(&ok, 2);
    a->setActivationFlags((KisAction::ActivationFlags) activationFlags);
    a->setActivationConditions((KisAction::ActivationConditions) activationConditions);
 
    addAction(name, a);
    return a;
}

References actionByName(), addAction(), dbgAction, KisActionRegistry::getActionProperty(), KisActionRegistry::instance(), KisActionRegistry::propertizeAction(), KisAction::setActivationConditions(), and KisAction::setActivationFlags().

◆ createStandardAction()

KisAction * KisActionManager::createStandardAction	(	KStandardAction::StandardAction	actionType,
		const QObject *	receiver,
		const char *	member )

Create a KisAction based on a KStandardAction. The KStandardAction is deleted.

Definition at line 339 of file kis_action_manager.cpp.

{
    QAction *standardAction = KStandardAction::create(actionType, receiver, member, 0);
    KisAction *action = new KisAction(standardAction->icon(), standardAction->text());
 
    const QList<QKeySequence> defaultShortcuts = standardAction->property("defaultShortcuts").value<QList<QKeySequence> >();
    const QKeySequence defaultShortcut = defaultShortcuts.isEmpty() ? QKeySequence() : defaultShortcuts.at(0);
    action->setDefaultShortcut(standardAction->shortcut());
#ifdef Q_OS_WIN
    if (actionType == KStandardAction::SaveAs && defaultShortcuts.isEmpty()) {
        action->setShortcut(QKeySequence("CTRL+SHIFT+S"));
    }
#endif
    action->setCheckable(standardAction->isCheckable());
    if (action->isCheckable()) {
        action->setChecked(standardAction->isChecked());
    }
    action->setMenuRole(standardAction->menuRole());
    action->setText(standardAction->text());
    action->setToolTip(standardAction->toolTip());
 
    if (receiver && member) {
        if (actionType == KStandardAction::OpenRecent) {
            QObject::connect(action, SIGNAL(urlSelected(QUrl)), receiver, member);
        }
        else if (actionType == KStandardAction::ConfigureToolbars) {
            QObject::connect(action, SIGNAL(triggered(bool)), receiver, member, Qt::QueuedConnection);
        }
        else {
            QObject::connect(action, SIGNAL(triggered(bool)), receiver, member);
        }
    }
 
    KisActionRegistry *actionRegistry = KisActionRegistry::instance();
    actionRegistry->propertizeAction(standardAction->objectName(), action);
 
    addAction(standardAction->objectName(), action);
    delete standardAction;
    return action;
}

References addAction(), KStandardAction::ConfigureToolbars, KStandardAction::create(), KisActionRegistry::instance(), KStandardAction::OpenRecent, KisActionRegistry::propertizeAction(), KStandardAction::SaveAs, and KisAction::setDefaultShortcut().

◆ dumpActionFlags()

void KisActionManager::dumpActionFlags ( )

private

Definition at line 422 of file kis_action_manager.cpp.

{
    QFile data("actions.txt");
    if (data.open(QFile::WriteOnly | QFile::Truncate)) {
        QTextStream out(&data);
        KisPortingUtils::setUtf8OnStream(out);
 
        Q_FOREACH (KisAction* action, d->actions) {
            KisAction::ActivationFlags flags = action->activationFlags();
            out << "-------- " << action->text() << " --------\n";
            out << "Action will activate on: \n";
 
            if (flags & KisAction::ACTIVE_IMAGE) {
                out << "    Active image\n";
            }
            if (flags & KisAction::MULTIPLE_IMAGES) {
                out << "    More than one image open\n";
            }
            if (flags & KisAction::CURRENT_IMAGE_MODIFIED) {
                out << "    Active image modified\n";
            }
            if (flags & KisAction::ACTIVE_DEVICE) {
                out << "    Active device\n";
            }
            if (flags & KisAction::ACTIVE_LAYER) {
                out << "    Active layer\n";
            }
            if (flags & KisAction::ACTIVE_TRANSPARENCY_MASK) {
                out << "    Active transparency mask\n";
            }
            if (flags & KisAction::ACTIVE_NODE) {
                out << "    Active node\n";
            }
            if (flags & KisAction::ACTIVE_SHAPE_LAYER) {
                out << "    Active shape layer\n";
            }
            if (flags & KisAction::PIXELS_SELECTED) {
                out << "    Pixels selected\n";
            }
            if (flags & KisAction::SHAPES_SELECTED) {
                out << "    Shapes selected\n";
            }
            if (flags & KisAction::ANY_SELECTION_WITH_PIXELS) {
                out << "    Any selection with pixels\n";
            }
            if (flags & KisAction::PIXELS_IN_CLIPBOARD) {
                out << "    Pixels in clipboard\n";
            }
            if (flags & KisAction::SHAPES_IN_CLIPBOARD) {
                out << "    Shape in clipboard\n";
            }
            if (flags & KisAction::IMAGE_HAS_ANIMATION) {
                out << "    Image has animation\n";
            }
 
            out << "\n\n";
            out << "Action will only activate if the following conditions are met: \n";
            KisAction::ActivationConditions conditions = action->activationConditions();
            if ((int)conditions == 0) {
                out << "    -\n";
            }
            if (conditions & KisAction::ACTIVE_NODE_EDITABLE) {
                out << "    Active Node editable\n";
            }
            if (conditions & KisAction::ACTIVE_NODE_EDITABLE_PAINT_DEVICE) {
                out << "    Active Node has editable paint device\n";
            }
            if (conditions & KisAction::SELECTION_EDITABLE) {
                out << "    Selection is editable\n";
            }
            if (conditions & KisAction::OPENGL_ENABLED) {
                out << "    OpenGL is enabled\n";
            }
            out << "\n\n";
        }
    }
}

◆ Private()

KisActionManager::Private ( )

inline

Definition at line 35 of file kis_action_manager.cpp.

35{}

◆ registerOperation()

void KisActionManager::registerOperation ( KisOperation * operation )

Definition at line 395 of file kis_action_manager.cpp.

{
    d->operationRegistry.add(operation);
}

References d.

◆ registerOperationUIFactory()

void KisActionManager::registerOperationUIFactory ( KisOperationUIFactory * factory )

Definition at line 390 of file kis_action_manager.cpp.

{
    d->uiRegistry.add(factory);
}

References d.

◆ runOperation()

void KisActionManager::runOperation ( const QString & id )

Definition at line 400 of file kis_action_manager.cpp.

{
    KisOperationConfigurationSP config = new KisOperationConfiguration(id);
 
    KisOperationUIFactory* uiFactory = d->uiRegistry.get(id);
    if (uiFactory) {
        bool gotConfig = uiFactory->fetchConfiguration(d->viewManager, config);
        if (!gotConfig) {
            return;
        }
    }
 
    runOperationFromConfiguration(config);
}

References d, KisOperationUIFactory::fetchConfiguration(), and runOperationFromConfiguration().

◆ runOperationFromConfiguration()

void KisActionManager::runOperationFromConfiguration ( KisOperationConfigurationSP config )

Definition at line 415 of file kis_action_manager.cpp.

{
    KisOperation* operation = d->operationRegistry.get(config->id());
    Q_ASSERT(operation);
    operation->runFromXML(d->viewManager, *config);
}

References d, and KisOperation::runFromXML().

◆ safePopulateMenu()

void KisActionManager::safePopulateMenu	(	QMenu *	menu,
		const QString &	actionId,
		KisActionManager *	actionManager )

static

Definition at line 380 of file kis_action_manager.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(actionManager);
 
    KisAction *action = actionManager->actionByName(actionId);
    KIS_SAFE_ASSERT_RECOVER_RETURN(action);
 
    menu->addAction(action);
}

References actionByName(), and KIS_SAFE_ASSERT_RECOVER_RETURN.

◆ setView()

void KisActionManager::setView ( QPointer< KisView > imageView )

Definition at line 107 of file kis_action_manager.cpp.

{
    Q_UNUSED(imageView);
}

◆ slotActionAddedToCollection

void KisActionManager::slotActionAddedToCollection ( QAction * action )

privateslot

Small hack alert: not all the actions are still created by the manager and immediately added to the action collection. Some plugins add actions directly to the action collection when a document is created. Here we catch these cases

Definition at line 112 of file kis_action_manager.cpp.

{
    KisActionRegistry::instance()->updateShortcut(action->objectName(), action);
}

References KisActionRegistry::instance(), and KisActionRegistry::updateShortcut().

◆ takeAction()

void KisActionManager::takeAction ( KisAction * action )

Stop managing an action.

Definition at line 137 of file kis_action_manager.cpp.

{
    d->actions.removeOne(action);
 
    if (!action->objectName().isEmpty()) {
        KIS_ASSERT_RECOVER_RETURN(d->actionCollection);
        d->actionCollection->takeAction(action);
    }
}

References d, and KIS_ASSERT_RECOVER_RETURN.

◆ updateGUI()

void KisActionManager::updateGUI ( )

Update actions handled by kis_action_manager to set enabled. This is used to grey out buttons that can't be pressed.

Definition at line 187 of file kis_action_manager.cpp.

{
    //TODO other flags
    KisAction::ActivationFlags flags;
 
    KisImageWSP image;
    KisNodeSP node;
    KisLayerSP layer;
    KisSelectionManager *selectionManager = 0;
 
    KisAction::ActivationConditions conditions = KisAction::NO_CONDITION;
 
    if (d->viewManager) {
        node = d->viewManager->activeNode();
        selectionManager = d->viewManager->selectionManager();
 
        // if there are no views, that means no document is open.
        // we cannot have nodes (selections), devices, or documents without a view
        if ( d->viewManager->viewCount() > 0 )
        {
            image = d->viewManager->image();
            flags |= KisAction::ACTIVE_IMAGE;
 
            if (image && image->animationInterface()->hasAnimation()) {
                flags |= KisAction::IMAGE_HAS_ANIMATION;
            }
 
            KisDocument *document = d->viewManager->document();
            if (document && document->isReadWrite()) {
                flags |= KisAction::IMAGE_IS_WRITABLE;
            }
 
            if (d->viewManager->viewCount() > 1) {
                flags |= KisAction::MULTIPLE_IMAGES;
            }
 
            if (d->viewManager->document() && d->viewManager->document()->isModified()) {
                flags |= KisAction::CURRENT_IMAGE_MODIFIED;
            }
 
            if (d->viewManager->activeDevice()) {
                flags |= KisAction::ACTIVE_DEVICE;
            }
        }
 
        if (d->viewManager->selectionEditable()) {
            conditions |= KisAction::SELECTION_EDITABLE;
        }
 
    }
 
    // is there a selection/mask?
    // you have to have at least one view (document) open for this to be true
    if (node) {
 
        // if a node exists, we know there is an active layer as well
        flags |= KisAction::ACTIVE_NODE;
 
        layer = qobject_cast<KisLayer*>(node.data());
        if (layer) {
            flags |= KisAction::ACTIVE_LAYER;
        }
 
        if (node->inherits("KisTransparencyMask")) {
            flags |= KisAction::ACTIVE_TRANSPARENCY_MASK;
        }
 
 
        if (layer && layer->inherits("KisShapeLayer")) {
            flags |= KisAction::ACTIVE_SHAPE_LAYER;
        }
 
        if (KisClipboard::instance()->hasLayers()) {
            flags |= KisAction::LAYERS_IN_CLIPBOARD;
        }
 
        if (selectionManager) {
 
            if (selectionManager->canReselectDeactivatedSelection()) {
                flags |= KisAction::IMAGE_CAN_RESELECT;
            }
 
            if (selectionManager->havePixelsSelected()) {
                flags |= KisAction::PIXELS_SELECTED;
            }
 
            if (selectionManager->haveShapesSelected()) {
                flags |= KisAction::SHAPES_SELECTED;
            }
 
            if (selectionManager->haveAnySelectionWithPixels()) {
                flags |= KisAction::ANY_SELECTION_WITH_PIXELS;
            }
 
            if (selectionManager->haveShapeSelectionWithShapes()) {
                flags |= KisAction::SHAPE_SELECTION_WITH_SHAPES;
            }
 
            if (selectionManager->haveRasterSelectionWithPixels()) {
                flags |= KisAction::PIXEL_SELECTION_WITH_PIXELS;
            }
 
            if (selectionManager->havePixelsInClipboard()) {
                flags |= KisAction::PIXELS_IN_CLIPBOARD;
            }
 
            if (selectionManager->haveShapesInClipboard()) {
                flags |= KisAction::SHAPES_IN_CLIPBOARD;
            }
        }
 
        if (node->isEditable(false)) {
            conditions |= KisAction::ACTIVE_NODE_EDITABLE;
        }
 
        if (node->hasEditablePaintDevice()) {
            conditions |= KisAction::ACTIVE_NODE_EDITABLE_PAINT_DEVICE;
        }
    }
 
    KisConfig cfg(true);
    if (cfg.useOpenGL()) {
        conditions |= KisAction::OPENGL_ENABLED;
    }
 
    // loop through all actions in action manager and determine what should be enabled
    Q_FOREACH (QPointer<KisAction> action, d->actions) {
        bool enable;
        if (action) {
            if (action->activationFlags() == KisAction::NONE) {
                enable = true;
            }
            else {
                enable = action->activationFlags() & flags; // combine action flags with updateGUI flags
            }
 
            enable = enable && (int)(action->activationConditions() & conditions) == (int)action->activationConditions();
 
            if (node && enable) {
                Q_FOREACH (const QString &type, action->excludedNodeTypes()) {
                    if (node->inherits(type.toLatin1())) {
                        enable = false;
                        break;
                    }
                }
            }
 
            action->setActionEnabled(enable);
        }
    }
}

References KisAction::ACTIVE_DEVICE, KisAction::ACTIVE_IMAGE, KisAction::ACTIVE_LAYER, KisAction::ACTIVE_NODE, KisAction::ACTIVE_NODE_EDITABLE, KisAction::ACTIVE_NODE_EDITABLE_PAINT_DEVICE, KisAction::ACTIVE_SHAPE_LAYER, KisAction::ACTIVE_TRANSPARENCY_MASK, KisImage::animationInterface(), KisAction::ANY_SELECTION_WITH_PIXELS, KisSelectionManager::canReselectDeactivatedSelection(), KisAction::CURRENT_IMAGE_MODIFIED, d, KisSharedPtr< T >::data(), KisImageAnimationInterface::hasAnimation(), KisBaseNode::hasEditablePaintDevice(), KisSelectionManager::haveAnySelectionWithPixels(), KisSelectionManager::havePixelsInClipboard(), KisSelectionManager::havePixelsSelected, KisSelectionManager::haveRasterSelectionWithPixels(), KisSelectionManager::haveShapeSelectionWithShapes(), KisSelectionManager::haveShapesInClipboard(), KisSelectionManager::haveShapesSelected(), KisAction::IMAGE_CAN_RESELECT, KisAction::IMAGE_HAS_ANIMATION, KisAction::IMAGE_IS_WRITABLE, KisClipboard::instance(), KisBaseNode::isEditable(), KisAction::LAYERS_IN_CLIPBOARD, KisAction::MULTIPLE_IMAGES, KisAction::NO_CONDITION, KisAction::NONE, KisAction::OPENGL_ENABLED, KisAction::PIXEL_SELECTION_WITH_PIXELS, KisAction::PIXELS_IN_CLIPBOARD, KisAction::PIXELS_SELECTED, KisAction::SELECTION_EDITABLE, KisAction::SHAPE_SELECTION_WITH_SHAPES, KisAction::SHAPES_IN_CLIPBOARD, KisAction::SHAPES_SELECTED, and KisConfig::useOpenGL().

Member Data Documentation

◆ actionCollection

KisKActionCollection* KisActionManager::actionCollection {nullptr}

Definition at line 43 of file kis_action_manager.cpp.

43{nullptr};

◆ actions

QList<QPointer<KisAction> > KisActionManager::actions

Definition at line 45 of file kis_action_manager.cpp.

◆ d

Private* const KisActionManager::d

private

Definition at line 95 of file kis_action_manager.h.

◆ operationRegistry

KisOperationRegistry KisActionManager::operationRegistry

Definition at line 47 of file kis_action_manager.cpp.

◆ uiRegistry

KoGenericRegistry<KisOperationUIFactory*> KisActionManager::uiRegistry

Definition at line 46 of file kis_action_manager.cpp.

◆ viewManager

KisViewManager* KisActionManager::viewManager {nullptr}

Definition at line 42 of file kis_action_manager.cpp.

42{nullptr};

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

libs/ui/kis_action_manager.cpp
libs/ui/kis_action_manager.h

Public Member Functions

Static Public Member Functions

Public Attributes

Private Slots

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ~Private()

◆ KisActionManager()

◆ ~KisActionManager()

Member Function Documentation

◆ actionByName()

◆ addAction()

◆ createAction()

◆ createStandardAction()

◆ dumpActionFlags()

◆ Private()

◆ registerOperation()

◆ registerOperationUIFactory()

◆ runOperation()

◆ runOperationFromConfiguration()

◆ safePopulateMenu()

◆ setView()

◆ slotActionAddedToCollection

◆ takeAction()

◆ updateGUI()

Member Data Documentation

◆ actionCollection

◆ actions

◆ d

◆ operationRegistry

◆ uiRegistry

◆ viewManager