RGuiAction.h

Go to the documentation of this file.

 
#ifndef RGUIACTION_H
#define RGUIACTION_H
 
#include "core_global.h"
 
#include <QMetaType>
#include <QString>
#include <QStringList>
#include <QList>
#include <QAction>
 
#include "RTransactionListener.h"
#include "RFocusListener.h"
#include "RSelectionListener.h"
 
class QToolBar;
 
class RDocument;
class RDocumentInterface;
 
class QCADCORE_EXPORT RGuiAction:
    public QAction,
    public RFocusListener,
    public RTransactionListener,
    public RSelectionListener {
 
Q_OBJECT
 
public:
    typedef void (*FactoryFunction)(RGuiAction*);
 
public:
    RGuiAction(const QString& oriText, QObject* parent = 0);
    virtual ~RGuiAction();
    
    void setText(const QString& oriText);
 
    virtual void initTexts();
 
    virtual void init();
 
    static QString formatToolTip(const QString& oriText, const QString& shortcut);
    QString getToolTip(const QString& oriText, const QString& shortcut);
 
    //void setDocumentInterface(RDocumentInterface* di);
    //RDocumentInterface* getDocumentInterface() const;
 
    void addShortcut(const QKeySequence& shortcut);
    void removeShortcuts();
    void setShortcut(const QKeySequence& shortcut);
    void setDefaultShortcut(const QKeySequence& shortcut);
    void setShortcuts(const QList<QKeySequence>& shortcuts);
    void setShortcutsFromStrings(const QStringList& shortcuts);
    QList<QKeySequence> getShortcuts() const;
    void setDefaultShortcuts(const QList<QKeySequence>& shortcuts);
    QList<QKeySequence> getDefaultShortcuts();
    void setShortcutText(const QString& oriText);
    QString getShortcutText() const;
    QString getShortcutsString(const QString& separator = ",", QKeySequence::SequenceFormat format = QKeySequence::PortableText) const;
 
    static void setGroupSortOrderStatic(QAction* a, int sortOrder);
    static void setGroupSortOrderOverrideStatic(QAction* a, const QString& widgetName, int sortOrder);
    static int getGroupSortOrderStatic(const QAction* a, const QWidget* w = NULL);
 
    static void setSortOrderStatic(QAction* a, int sortOrder);
    static void setSortOrderOverrideStatic(QAction* a, const QString& widgetName, int sortOrder);
    static int getSortOrderStatic(const QAction* a, const QWidget* w = NULL);
 
    void setGroupSortOrder(int sortOrder);
    void setGroupSortOrderOverride(const QString& widgetName, int sortOrder);
    int getGroupSortOrder(const QWidget* w = NULL) const;
 
    void setSortOrder(int sortOrder);
    void setSortOrderOverride(const QString& widgetName, int sortOrder);
    int getSortOrder(const QWidget* w = NULL) const;
 
    void addToMenu(QMenu* menu);
    void addToToolBar(QToolBar* tb);
 
    static void fixSeparators(const QWidget* w);
    static void addSeparatorToWidget(QAction* a, QWidget* w);
    static void addToWidget(QAction* a, QWidget* w);
    static void removeFromWidget(QAction* a, QWidget* w);
 
    static void updateIcons();
    void updateIcon();
 
    static void updateToolTips();
 
    virtual void setIcon(const QString& iconFile);
 
    void disableIcon();
    bool isIconDisabled() const;
 
    virtual void setToolTip(const QString& tip);
 
    virtual void setStatusTip(const QString& tip);
 
    virtual void setEnabled(bool on);
    
    virtual void setEnabledOverride(bool on, int override);
    
    virtual void setChecked(bool on);
 
    static void triggerGroupDefault(const QString& group);
    static void triggerGroupDefaults();
 
    virtual bool isChecked() const;
    
    void setForceGlobal(bool on) {
        forceGlobal = on;
    }
 
    bool getForceGlobal() const {
        return forceGlobal;
    }
 
    void setRequiresDocument(bool on) {
        requiresDocument = on;
    }
 
    bool getRequiresDocument() const {
        return requiresDocument;
    }
 
    void setRequiresSelection(bool on);
 
    bool getRequiresSelection() const {
        return requiresSelection;
    }
 
    void setRequiresUndoableTransaction(bool on) {
        requiresUndoableTransaction = on;
    }
 
    bool getRequiresUndoableTransaction() const {
        return requiresUndoableTransaction;
    }
 
    void setRequiresRedoableTransaction(bool on) {
        requiresRedoableTransaction = on;
    }
 
    bool getRequiresRedoableTransaction() const {
        return requiresRedoableTransaction;
    }
 
    void setOverride() {
        override = true;
    }
 
    bool isOverride() const {
        return override;
    }
 
    void setAllowInterrupt() {
        allowInterrupt = true;
    }
 
    bool getAllowInterrupt() const {
        return allowInterrupt;
    }
 
    void setNoState(bool checkable = false) {
        noState = true;
        setCheckable(checkable);
    }
 
    bool hasNoState() const {
        return noState;
    }
 
    void setToggleable(bool on = true) {
        toggleable = on;
    }
 
    bool isToggleable() const {
        return toggleable;
    }
 
    void setUniqueGroup(const QString& ug) {
        uniqueGroup = ug;
    }
 
    QString getUniqueGroup() const {
        return uniqueGroup;
    }
 
    QString getMainCommand() const {
        return mainCommand;
    }
 
    QStringList getCommands() const {
        return commandList;
    }
 
    QStringList getDefaultCommands() {
        return defaultCommandList;
    }
    
    void setDefaultCommands(const QStringList& cmds);
    void setCommands(const QStringList& cmds);
    
    void setFactory(FactoryFunction f);
    
    void setScriptFile(const QString& sf, bool isSecondary = false);
 
    QString getScriptFile() const {
        return scriptFile;
    }
 
    QString getScriptClass() const;
 
    virtual void setGroup(const QString& title);
    QString getGroup();
 
    void setGroupDefault(bool on);
    bool isGroupDefault();
 
//    void setSeparatorGroup(const QString& title);
//    QString getSeparatorGroup();
 
    static QList<RGuiAction*> getActions() {
        return actions;
    }
 
    static bool triggerByCommand(const QString& cmd);
    static bool triggerByShortcut(const QString& sc);
    static RGuiAction* getByScriptFile(const QString& scriptFile);
    static RGuiAction* getByClassName(const QString& className);
    static RGuiAction* getByCommand(const QString& command);
    static bool triggerByScriptFile(const QString& scriptFile);
    
    static QStringList getAvailableCommands(bool primaryOnly=false);
    static QStringList getAvailableCommands(const QString& start, bool primaryOnly=false);
 
    static void clear();
 
    virtual void updateTransactionListener(RDocument* document, RTransaction* transaction = NULL);
    virtual void setCurrentBlock(RDocument* document) {
        Q_UNUSED(document);
    }
    virtual void updateSelectionListener(RDocumentInterface* documentInterface);
    virtual void updateFocus(RDocumentInterface* documentInterface);
 
    void addArgument(const QString& arg);
    QStringList getArguments();
    void clearArguments();
 
    static void setWidgetNamesStatic(QAction* a, const QStringList& widgetNames);
    static QStringList getWidgetNamesStatic(const QAction *a);
 
    void setWidgetNames(const QStringList& widgetNames);
    QStringList getWidgetNames() const;
 
public slots:
    bool slotTrigger(const QString& command = QString());
 
signals:
    void postTriggered();
 
protected:
    static QMap<QString, RGuiAction*> actionsByCommand;
    static QMap<QString, RGuiAction*> actionsByShortcut;
    static QMap<QString, RGuiAction*> actionsByPrimaryCommand;
    static QMap<QString, RGuiAction*> actionsByScriptFile;
    static QMultiMap<QString, RGuiAction*> actionsByGroup;
    static QList<RGuiAction*> actions;
 
    FactoryFunction factory;
    QString oriText;
    QString scriptFile;
    QString iconFile;
    QString mainCommand;
    QStringList commandList;
    QStringList defaultCommandList;
    QString group;
    bool groupDefault;
    
    // TODO: refactor to use flags:
    bool forceGlobal;
    bool requiresDocument;
    bool requiresSelection;
    bool requiresUndoableTransaction;
    bool requiresRedoableTransaction;
    bool override;
    bool allowInterrupt;
    bool noState;
    bool toggleable;
    QString uniqueGroup;
    QStringList arguments;
 
    QList<QKeySequence> defaultShortcuts;
    QList<QKeySequence> multiKeyShortcuts;
    QString shortcutText;
    QString oriToolTip;
    bool iconDisabled;
    int enabledOverride;
    //RDocumentInterface* documentInterface;
};
 
Q_DECLARE_METATYPE(RGuiAction*)
Q_DECLARE_METATYPE(QList<RGuiAction*>)
 
#endif