kcommandmanager.h

Go to the documentation of this file.

/****************************************************************************
**
** This file is part of KDWinutils, KDAB's MFC to Qt migration tool.
**
** Copyright (C) 2023 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
** All rights reserved.
**
** This file is intended solely for use by the migration tools and services
** provided by Klarälvdalens Datakonsult AB.
**
**  Any other use or distribution of this software that is not otherwise agreed
**  upon in writing and signed by an authorized representative of Klarälvdalens
**  Datakonsult AB, KDAB (USA) LLC, KDAB (Deutschland) GmbH & Co. K.G.,
**  KDAB (France) SAS, KDAB (UK), Ltd., or any future subsidiary of Klarälvdalens
**  Datakonsult AB is hereby prohibited.
**
**  Contact info@kdab.com if any conditions stated above are unclear to you.
**
****************************************************************************/
 
#pragma once
 
#include "../kdwinutils_global.h"
 
#include <QHash>
#include <QMenu>
#include <QObject>
#include <QVector>
 
#include <functional>
 
class QAction;
class QWidget;
class QSignalMapper;
class QToolBar;
class QWidgetAction;
class QTimer;
 
KDWINUTILS_BEGIN_NAMESPACE
 
class KDWINUTILS_EXPORT KCommandManager : public QObject
{
    Q_OBJECT
 
public:
    explicit KCommandManager(QObject *parent = nullptr);
    ~KCommandManager();
 
    // Command handling
    QAction *createCommand(int id, const QString &title = QString(), QWidget *context = nullptr);
    QAction *findOrCreateCommand(int id, const QString &title = QString(), QWidget *context = nullptr);
    QWidgetAction *createWidgetCommand(int id, QWidget *defaultWidget, QWidget *context = nullptr);
    QAction *command(int id);
    void removeCommand(int id);
    void clearAllCommands();
    bool hasCommand(int id) const;
 
    void setCommandEnabled(int id, bool enabled);
    void setCommandChecked(int id, bool checked);
 
    void triggerCommandAsync(int id) const;
    void triggerCommand(int id) const;
 
    template <typename T>
    void connectCommand(int id, T method);
    template <typename T>
    void connectCommand(int id, T *object, void (T::*method)());
    template <typename T>
    void connectCommand(int id, T *object, void (T::*method)(unsigned int));
    template <typename T>
    void connectCommandRange(int first, int last, T *object, void (T::*method)(unsigned int));
 
    template <typename T>
    void connectCommandUpdater(int id, T method);
    template <typename T>
    void connectCommandUpdater(int id, T *object, void (T::*method)(QAction *));
    template <typename T>
    void connectCommandRangeUpdater(int first, int last, T *object, void (T::*method)(QAction *));
 
    template <typename Func>
    void visitCommands(Func fn);
 
    // Menu handling
    QMenu *createMenu(const QString &title, QWidget *parent = nullptr);
    QMenu *createMenu(QWidget *parent = nullptr);
    void addMenu(QMenu *menu);
 
    // Toolbar handling
    QToolBar *createToolBar(int id, const QString &title, QWidget *context = nullptr);
    void addToolBar(int id, QToolBar *toolBar, QWidget *context = nullptr);
    QToolBar *toolBar(int id) const;
    void updateAllToolBars();
 
    // Timer handling
    void startUpdateTimer();
    void stopUpdateTimer();
 
signals:
    void commandUpdated();
 
private:
    void updateAllMenus();
    void triggerUpdate(QAction *action) const;
 
    QTimer *m_updateTimer;
    QHash<int, QAction *> m_actions;
    QHash<int, QToolBar *> m_toolbars;
    QSignalMapper *m_actionMapper;
    QHash<int, std::function<void()>> m_actionSlots;
    QHash<int, QVector<std::function<void()>>> m_actionUpdates;
};
 
template <typename T>
void KCommandManager::connectCommand(int id, T method)
{
    m_actionSlots[id] = method;
}
template <typename T>
void KCommandManager::connectCommand(int id, T *object, void (T::*method)())
{
    connectCommand(id, [object, method]() {
        (object->*method)();
    });
}
template <typename T>
void KCommandManager::connectCommand(int id, T *object, void (T::*method)(unsigned int))
{
    connectCommand(id, [id, object, method]() {
        (object->*method)(id);
    });
}
template <typename T>
void KCommandManager::connectCommandRange(int first, int last, T *object, void (T::*method)(unsigned int))
{
    for (int id = first; id <= last; ++id)
        connectCommand(id, object, method);
}
 
template <typename T>
void KCommandManager::connectCommandUpdater(int id, T method)
{
    m_actionUpdates[id].append([this, id, method] {
        method(m_actions.value(id));
    });
}
 
template <typename T>
void KCommandManager::connectCommandUpdater(int id, T *object, void (T::*method)(QAction *))
{
    connectCommandUpdater(id, [this, id, object, method](QAction *action) {
        (object->*method)(action);
    });
}
 
template <typename T>
void KCommandManager::connectCommandRangeUpdater(int first, int last, T *object, void (T::*method)(QAction *))
{
    for (int id = first; id <= last; ++id)
        connectCommandUpdater(id, object, method);
}
 
template <typename Func>
void KCommandManager::visitCommands(Func fn)
{
    for (const auto action : m_actions)
        fn(action);
}
 
KDWINUTILS_END_NAMESPACE