Added QAction

Change-Id: I0342d7432413086438bae925d0cad215d757e12b
Reviewed-by: Anselmo L. S. Melo <anselmo.melo@openbossa.org>

7 files changed, 2265 insertions, 1 deletions

diff --git a/src/action/action.pri b/src/action/action.pri
new file mode 100644
index 0000000..178be6c
--- /dev/null
+++ b/src/action/action.pri
@@ -0,0 +1,11 @@
+INCLUDEPATH += $$PWD
+
+HEADERS += \
+    $$PWD/qaction.h
+
+HEADERS += \
+    $$PWD/qaction_p.h
+
+SOURCES += \
+    $$PWD/qaction.cpp
+
diff --git a/src/action/qaction.cpp b/src/action/qaction.cpp
new file mode 100644
index 0000000..6bc0c9b
--- /dev/null
+++ b/src/action/qaction.cpp
@@ -0,0 +1,1363 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** This file may be used under the terms of the GNU Lesser General Public
+** License version 2.1 as published by the Free Software Foundation and
+** appearing in the file LICENSE.LGPL included in the packaging of this
+** file. Please review the following information to ensure the GNU Lesser
+** General Public License version 2.1 requirements will be met:
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qaction.h"
+#include "qactiongroup.h"
+
+#ifndef QT_NO_ACTION
+#include "qaction_p.h"
+#include "qapplication.h"
+#include "qevent.h"
+#include "qlist.h"
+#include "qdebug.h"
+#include <private/qshortcutmap_p.h>
+#include <private/qapplication_p.h>
+#include <private/qmenu_p.h>
+
+#define QAPP_CHECK(functionName) \
+    if (!qApp) { \
+        qWarning("QAction: Initialize QApplication before calling '" functionName "'."); \
+        return; \
+    }
+
+QT_BEGIN_NAMESPACE
+
+/*
+  internal: guesses a descriptive text from a text suited for a menu entry
+ */
+static QString qt_strippedText(QString s)
+{
+    s.remove( QString::fromLatin1("...") );
+    int i = 0;
+    while (i < s.size()) {
+        ++i;
+        if (s.at(i-1) != QLatin1Char('&'))
+            continue;
+        if (i < s.size() && s.at(i) == QLatin1Char('&'))
+            ++i;
+        s.remove(i-1,1);
+    }
+    return s.trimmed();
+}
+
+
+QActionPrivate::QActionPrivate() : group(0), enabled(1), forceDisabled(0),
+                                   visible(1), forceInvisible(0), checkable(0), checked(0), separator(0), fontSet(false),
+                                   forceEnabledInSoftkeys(false), menuActionSoftkeys(false),
+                                   iconVisibleInMenu(-1),
+                                   menuRole(QAction::TextHeuristicRole), softKeyRole(QAction::NoSoftKey),
+                                   priority(QAction::NormalPriority)
+{
+#ifndef QT_NO_SHORTCUT
+    shortcutId = 0;
+    shortcutContext = Qt::WindowShortcut;
+    autorepeat = true;
+#endif
+}
+
+QActionPrivate::~QActionPrivate()
+{
+}
+
+bool QActionPrivate::showStatusText(QWidget *widget, const QString &str)
+{
+#ifdef QT_NO_STATUSTIP
+    Q_UNUSED(widget);
+    Q_UNUSED(str);
+#else
+    if (QObject *object = widget ? widget : parent) {
+        QStatusTipEvent tip(str);
+        QApplication::sendEvent(object, &tip);
+        return true;
+    }
+#endif
+    return false;
+}
+
+void QActionPrivate::sendDataChanged()
+{
+    Q_Q(QAction);
+    QActionEvent e(QEvent::ActionChanged, q);
+    for (int i = 0; i < widgets.size(); ++i) {
+        QWidget *w = widgets.at(i);
+        QApplication::sendEvent(w, &e);
+    }
+#ifndef QT_NO_GRAPHICSVIEW
+    for (int i = 0; i < graphicsWidgets.size(); ++i) {
+        QGraphicsWidget *w = graphicsWidgets.at(i);
+        QApplication::sendEvent(w, &e);
+    }
+#endif
+    QApplication::sendEvent(q, &e);
+
+    emit q->changed();
+}
+
+#ifndef QT_NO_SHORTCUT
+void QActionPrivate::redoGrab(QShortcutMap &map)
+{
+    Q_Q(QAction);
+    if (shortcutId)
+        map.removeShortcut(shortcutId, q);
+    if (shortcut.isEmpty())
+        return;
+    shortcutId = map.addShortcut(q, shortcut, shortcutContext, qWidgetShortcutContextMatcher);
+    if (!enabled)
+        map.setShortcutEnabled(false, shortcutId, q);
+    if (!autorepeat)
+        map.setShortcutAutoRepeat(false, shortcutId, q);
+}
+
+void QActionPrivate::redoGrabAlternate(QShortcutMap &map)
+{
+    Q_Q(QAction);
+    for (int i = 0; i < alternateShortcutIds.count(); ++i) {
+        if (const int id = alternateShortcutIds.at(i))
+            map.removeShortcut(id, q);
+    }
+    alternateShortcutIds.clear();
+    if (alternateShortcuts.isEmpty())
+        return;
+    for (int i = 0; i < alternateShortcuts.count(); ++i) {
+        const QKeySequence& alternate = alternateShortcuts.at(i);
+        if (!alternate.isEmpty())
+            alternateShortcutIds.append(map.addShortcut(q, alternate, shortcutContext, qWidgetShortcutContextMatcher));
+        else
+            alternateShortcutIds.append(0);
+    }
+    if (!enabled) {
+        for (int i = 0; i < alternateShortcutIds.count(); ++i) {
+            const int id = alternateShortcutIds.at(i);
+            map.setShortcutEnabled(false, id, q);
+        }
+    }
+    if (!autorepeat) {
+        for (int i = 0; i < alternateShortcutIds.count(); ++i) {
+            const int id = alternateShortcutIds.at(i);
+            map.setShortcutAutoRepeat(false, id, q);
+        }
+    }
+}
+
+void QActionPrivate::setShortcutEnabled(bool enable, QShortcutMap &map)
+{
+    Q_Q(QAction);
+    if (shortcutId)
+        map.setShortcutEnabled(enable, shortcutId, q);
+    for (int i = 0; i < alternateShortcutIds.count(); ++i) {
+        if (const int id = alternateShortcutIds.at(i))
+            map.setShortcutEnabled(enable, id, q);
+    }
+}
+#endif // QT_NO_SHORTCUT
+
+
+/*!
+    \class QAction
+    \brief The QAction class provides an abstract user interface
+    action that can be inserted into widgets.
+
+    \ingroup mainwindow-classes
+    \inmodule QtWidgets
+
+    \omit
+        * parent and widget are different
+        * parent does not define context
+    \endomit
+
+    In applications many common commands can be invoked via menus,
+    toolbar buttons, and keyboard shortcuts. Since the user expects
+    each command to be performed in the same way, regardless of the
+    user interface used, it is useful to represent each command as
+    an \e action.
+
+    Actions can be added to menus and toolbars, and will
+    automatically keep them in sync. For example, in a word processor,
+    if the user presses a Bold toolbar button, the Bold menu item
+    will automatically be checked.
+
+    Actions can be created as independent objects, but they may
+    also be created during the construction of menus; the QMenu class
+    contains convenience functions for creating actions suitable for
+    use as menu items.
+
+    A QAction may contain an icon, menu text, a shortcut, status text,
+    "What's This?" text, and a tooltip. Most of these can be set in
+    the constructor. They can also be set independently with
+    setIcon(), setText(), setIconText(), setShortcut(),
+    setStatusTip(), setWhatsThis(), and setToolTip(). For menu items,
+    it is possible to set an individual font with setFont().
+
+    Actions are added to widgets using QWidget::addAction() or
+    QGraphicsWidget::addAction(). Note that an action must be added to a
+    widget before it can be used; this is also true when the shortcut should
+    be global (i.e., Qt::ApplicationShortcut as Qt::ShortcutContext).
+
+    Once a QAction has been created it should be added to the relevant
+    menu and toolbar, then connected to the slot which will perform
+    the action. For example:
+
+    \snippet examples/mainwindows/application/mainwindow.cpp 19
+    \codeline
+    \snippet examples/mainwindows/application/mainwindow.cpp 28
+    \snippet examples/mainwindows/application/mainwindow.cpp 31
+
+    We recommend that actions are created as children of the window
+    they are used in. In most cases actions will be children of
+    the application's main window.
+
+    \sa QMenu, QToolBar, {Application Example}
+*/
+
+/*!
+    \fn void QAction::trigger()
+
+    This is a convenience slot that calls activate(Trigger).
+*/
+
+/*!
+    \fn void QAction::hover()
+
+    This is a convenience slot that calls activate(Hover).
+*/
+
+/*!
+    \enum QAction::MenuRole
+
+    This enum describes how an action should be moved into the application menu on Mac OS X.
+
+    \value NoRole This action should not be put into the application menu
+    \value TextHeuristicRole This action should be put in the application menu based on the action's text
+           as described in the QMenuBar documentation.
+    \value ApplicationSpecificRole This action should be put in the application menu with an application specific role
+    \value AboutQtRole This action matches handles the "About Qt" menu item.
+    \value AboutRole This action should be placed where the "About" menu item is in the application menu. The text of
+           the menu item will be set to "About <application name>". The application name is fetched from the
+           \c{Info.plist} file in the application's bundle (See \l{Deploying an Application on Mac OS X}).
+    \value PreferencesRole This action should be placed where the  "Preferences..." menu item is in the application menu.
+    \value QuitRole This action should be placed where the Quit menu item is in the application menu.
+
+    Setting this value only has effect on items that are in the immediate menus
+    of the menubar, not the submenus of those menus. For example, if you have
+    File menu in your menubar and the File menu has a submenu, setting the
+    MenuRole for the actions in that submenu have no effect. They will never be moved.
+*/
+
+/*! \since 4.6
+
+    \enum QAction::SoftKeyRole
+
+    This enum describes how an action should be placed in the softkey bar. Currently this enum only
+    has an effect on the Symbian platform.
+
+    \value NoSoftKey This action should not be used as a softkey
+    \value PositiveSoftKey This action is used to describe a softkey with a positive or non-destructive
+           role such as Ok, Select, or Options.
+    \value NegativeSoftKey This action is used to describe a soft ey with a negative or destructive role
+           role such as Cancel, Discard, or Close.
+    \value SelectSoftKey This action is used to describe a role that selects a particular item or widget
+           in the application.
+
+    Actions with a softkey role defined are only visible in the softkey bar when the widget containing
+    the action has focus. If no widget currently has focus, the softkey framework will traverse up the
+    widget parent hierarchy looking for a widget containing softkey actions.
+ */
+
+/*!
+    Constructs an action with \a parent. If \a parent is an action
+    group the action will be automatically inserted into the group.
+*/
+QAction::QAction(QObject* parent)
+    : QObject(*(new QActionPrivate), parent)
+{
+    Q_D(QAction);
+    d->group = qobject_cast<QActionGroup *>(parent);
+    if (d->group)
+        d->group->addAction(this);
+}
+
+
+/*!
+    Constructs an action with some \a text and \a parent. If \a
+    parent is an action group the action will be automatically
+    inserted into the group.
+
+    The action uses a stripped version of \a text (e.g. "\&Menu
+    Option..." becomes "Menu Option") as descriptive text for
+    tool buttons. You can override this by setting a specific
+    description with setText(). The same text will be used for
+    tooltips unless you specify a different text using
+    setToolTip().
+
+*/
+QAction::QAction(const QString &text, QObject* parent)
+    : QObject(*(new QActionPrivate), parent)
+{
+    Q_D(QAction);
+    d->text = text;
+    d->group = qobject_cast<QActionGroup *>(parent);
+    if (d->group)
+        d->group->addAction(this);
+}
+
+/*!
+    Constructs an action with an \a icon and some \a text and \a
+    parent. If \a parent is an action group the action will be
+    automatically inserted into the group.
+
+    The action uses a stripped version of \a text (e.g. "\&Menu
+    Option..." becomes "Menu Option") as descriptive text for
+    tool buttons. You can override this by setting a specific
+    description with setText(). The same text will be used for
+    tooltips unless you specify a different text using
+    setToolTip().
+*/
+QAction::QAction(const QIcon &icon, const QString &text, QObject* parent)
+    : QObject(*(new QActionPrivate), parent)
+{
+    Q_D(QAction);
+    d->icon = icon;
+    d->text = text;
+    d->group = qobject_cast<QActionGroup *>(parent);
+    if (d->group)
+        d->group->addAction(this);
+}
+
+/*!
+    \internal
+*/
+QAction::QAction(QActionPrivate &dd, QObject *parent)
+    : QObject(dd, parent)
+{
+    Q_D(QAction);
+    d->group = qobject_cast<QActionGroup *>(parent);
+    if (d->group)
+        d->group->addAction(this);
+}
+
+/*!
+    Returns the parent widget.
+*/
+QWidget *QAction::parentWidget() const
+{
+    QObject *ret = parent();
+    while (ret && !ret->isWidgetType())
+        ret = ret->parent();
+    return (QWidget*)ret;
+}
+
+/*!
+  \since 4.2
+  Returns a list of widgets this action has been added to.
+
+  \sa QWidget::addAction(), associatedGraphicsWidgets()
+*/
+QList<QWidget *> QAction::associatedWidgets() const
+{
+    Q_D(const QAction);
+    return d->widgets;
+}
+
+#ifndef QT_NO_GRAPHICSVIEW
+/*!
+  \since 4.5
+  Returns a list of widgets this action has been added to.
+
+  \sa QWidget::addAction(), associatedWidgets()
+*/
+QList<QGraphicsWidget *> QAction::associatedGraphicsWidgets() const
+{
+    Q_D(const QAction);
+    return d->graphicsWidgets;
+}
+#endif
+
+#ifndef QT_NO_SHORTCUT
+/*!
+    \property QAction::shortcut
+    \brief the action's primary shortcut key
+
+    Valid keycodes for this property can be found in \l Qt::Key and
+    \l Qt::Modifier. There is no default shortcut key.
+*/
+void QAction::setShortcut(const QKeySequence &shortcut)
+{
+    QAPP_CHECK("setShortcut");
+
+    Q_D(QAction);
+    if (d->shortcut == shortcut)
+        return;
+
+    d->shortcut = shortcut;
+    d->redoGrab(qApp->d_func()->shortcutMap);
+    d->sendDataChanged();
+}
+
+/*!
+    \since 4.2
+
+    Sets \a shortcuts as the list of shortcuts that trigger the
+    action. The first element of the list is the primary shortcut.
+
+    \sa shortcut
+*/
+void QAction::setShortcuts(const QList<QKeySequence> &shortcuts)
+{
+    Q_D(QAction);
+
+    QList <QKeySequence> listCopy = shortcuts;
+
+    QKeySequence primary;
+    if (!listCopy.isEmpty())
+        primary = listCopy.takeFirst();
+
+    if (d->shortcut == primary && d->alternateShortcuts == listCopy)
+        return;
+
+    QAPP_CHECK("setShortcuts");
+
+    d->shortcut = primary;
+    d->alternateShortcuts = listCopy;
+    d->redoGrab(qApp->d_func()->shortcutMap);
+    d->redoGrabAlternate(qApp->d_func()->shortcutMap);
+    d->sendDataChanged();
+}
+
+/*!
+    \since 4.2
+
+    Sets a platform dependent list of shortcuts based on the \a key.
+    The result of calling this function will depend on the currently running platform.
+    Note that more than one shortcut can assigned by this action.
+    If only the primary shortcut is required, use setShortcut instead.
+
+    \sa QKeySequence::keyBindings()
+*/
+void QAction::setShortcuts(QKeySequence::StandardKey key)
+{
+    QList <QKeySequence> list = QKeySequence::keyBindings(key);
+    setShortcuts(list);
+}
+
+/*!
+    Returns the primary shortcut.
+
+    \sa setShortcuts()
+*/
+QKeySequence QAction::shortcut() const
+{
+    Q_D(const QAction);
+    return d->shortcut;
+}
+
+/*!
+    \since 4.2
+
+    Returns the list of shortcuts, with the primary shortcut as
+    the first element of the list.
+
+    \sa setShortcuts()
+*/
+QList<QKeySequence> QAction::shortcuts() const
+{
+    Q_D(const QAction);
+    QList <QKeySequence> shortcuts;
+    if (!d->shortcut.isEmpty())
+        shortcuts << d->shortcut;
+    if (!d->alternateShortcuts.isEmpty())
+        shortcuts << d->alternateShortcuts;
+    return shortcuts;
+}
+
+/*!
+    \property QAction::shortcutContext
+    \brief the context for the action's shortcut
+
+    Valid values for this property can be found in \l Qt::ShortcutContext.
+    The default value is Qt::WindowShortcut.
+*/
+void QAction::setShortcutContext(Qt::ShortcutContext context)
+{
+    Q_D(QAction);
+    if (d->shortcutContext == context)
+        return;
+    QAPP_CHECK("setShortcutContext");
+    d->shortcutContext = context;
+    d->redoGrab(qApp->d_func()->shortcutMap);
+    d->redoGrabAlternate(qApp->d_func()->shortcutMap);
+    d->sendDataChanged();
+}
+
+Qt::ShortcutContext QAction::shortcutContext() const
+{
+    Q_D(const QAction);
+    return d->shortcutContext;
+}
+
+/*!
+    \property QAction::autoRepeat
+    \brief whether the action can auto repeat
+    \since 4.2
+
+    If true, the action will auto repeat when the keyboard shortcut
+    combination is held down, provided that keyboard auto repeat is
+    enabled on the system.
+    The default value is true.
+*/
+void QAction::setAutoRepeat(bool on)
+{
+    Q_D(QAction);
+    if (d->autorepeat == on)
+        return;
+    QAPP_CHECK("setAutoRepeat");
+    d->autorepeat = on;
+    d->redoGrab(qApp->d_func()->shortcutMap);
+    d->redoGrabAlternate(qApp->d_func()->shortcutMap);
+    d->sendDataChanged();
+}
+
+bool QAction::autoRepeat() const
+{
+    Q_D(const QAction);
+    return d->autorepeat;
+}
+#endif // QT_NO_SHORTCUT
+
+/*!
+    \property QAction::font
+    \brief the action's font
+
+    The font property is used to render the text set on the
+    QAction. The font will can be considered a hint as it will not be
+    consulted in all cases based upon application and style.
+
+    By default, this property contains the application's default font.
+
+    \sa QAction::setText() QStyle
+*/
+void QAction::setFont(const QFont &font)
+{
+    Q_D(QAction);
+    if (d->font == font)
+        return;
+
+    d->fontSet = true;
+    d->font = font;
+    d->sendDataChanged();
+}
+
+QFont QAction::font() const
+{
+    Q_D(const QAction);
+    return d->font;
+}
+
+
+/*!
+    Destroys the object and frees allocated resources.
+*/
+QAction::~QAction()
+{
+    Q_D(QAction);
+    for (int i = d->widgets.size()-1; i >= 0; --i) {
+        QWidget *w = d->widgets.at(i);
+        w->removeAction(this);
+    }
+#ifndef QT_NO_GRAPHICSVIEW
+    for (int i = d->graphicsWidgets.size()-1; i >= 0; --i) {
+        QGraphicsWidget *w = d->graphicsWidgets.at(i);
+        w->removeAction(this);
+    }
+#endif
+    if (d->group)
+        d->group->removeAction(this);
+#ifndef QT_NO_SHORTCUT
+    if (d->shortcutId && qApp) {
+        qApp->d_func()->shortcutMap.removeShortcut(d->shortcutId, this);
+        for (int i = 0; i < d->alternateShortcutIds.count(); ++i) {
+            const int id = d->alternateShortcutIds.at(i);
+            qApp->d_func()->shortcutMap.removeShortcut(id, this);
+        }
+    }
+#endif
+}
+
+/*!
+  Sets this action group to \a group. The action will be automatically
+  added to the group's list of actions.
+
+  Actions within the group will be mutually exclusive.
+
+  \sa QActionGroup, QAction::actionGroup()
+*/
+void QAction::setActionGroup(QActionGroup *group)
+{
+    Q_D(QAction);
+    if (group == d->group)
+        return;
+
+    if (d->group)
+        d->group->removeAction(this);
+    d->group = group;
+    if (group)
+        group->addAction(this);
+}
+
+/*!
+  Returns the action group for this action. If no action group manages
+  this action then 0 will be returned.
+
+  \sa QActionGroup, QAction::setActionGroup()
+*/
+QActionGroup *QAction::actionGroup() const
+{
+    Q_D(const QAction);
+    return d->group;
+}
+
+
+/*!
+    \property QAction::icon
+    \brief the action's icon
+
+    In toolbars, the icon is used as the tool button icon; in menus,
+    it is displayed to the left of the menu text. There is no default
+    icon.
+
+    If a null icon (QIcon::isNull() is passed into this function,
+    the icon of the action is cleared.
+*/
+void QAction::setIcon(const QIcon &icon)
+{
+    Q_D(QAction);
+    d->icon = icon;
+    d->sendDataChanged();
+}
+
+QIcon QAction::icon() const
+{
+    Q_D(const QAction);
+    return d->icon;
+}
+
+#ifndef QT_NO_MENU
+/*!
+  Returns the menu contained by this action. Actions that contain
+  menus can be used to create menu items with submenus, or inserted
+  into toolbars to create buttons with popup menus.
+
+  \sa QMenu::addAction()
+*/
+QMenu *QAction::menu() const
+{
+    Q_D(const QAction);
+    return d->menu;
+}
+
+/*!
+    Sets the menu contained by this action to the specified \a menu.
+*/
+void QAction::setMenu(QMenu *menu)
+{
+    Q_D(QAction);
+    if (d->menu)
+        d->menu->d_func()->setOverrideMenuAction(0); //we reset the default action of any previous menu
+    d->menu = menu;
+    if (menu)
+        menu->d_func()->setOverrideMenuAction(this);
+    d->sendDataChanged();
+}
+#endif // QT_NO_MENU
+
+/*!
+  If \a b is true then this action will be considered a separator.
+
+  How a separator is represented depends on the widget it is inserted
+  into. Under most circumstances the text, submenu, and icon will be
+  ignored for separator actions.
+
+  \sa QAction::isSeparator()
+*/
+void QAction::setSeparator(bool b)
+{
+    Q_D(QAction);
+    if (d->separator == b)
+        return;
+
+    d->separator = b;
+    d->sendDataChanged();
+}
+
+/*!
+  Returns true if this action is a separator action; otherwise it
+  returns false.
+
+  \sa QAction::setSeparator()
+*/
+bool QAction::isSeparator() const
+{
+    Q_D(const QAction);
+    return d->separator;
+}
+
+/*!
+    \property QAction::text
+    \brief the action's descriptive text
+
+    If the action is added to a menu, the menu option will consist of
+    the icon (if there is one), the text, and the shortcut (if there
+    is one). If the text is not explicitly set in the constructor, or
+    by using setText(), the action's description icon text will be
+    used as text. There is no default text.
+
+    \sa iconText
+*/
+void QAction::setText(const QString &text)
+{
+    Q_D(QAction);
+    if (d->text == text)
+        return;
+
+    d->text = text;
+    d->sendDataChanged();
+}
+
+QString QAction::text() const
+{
+    Q_D(const QAction);
+    QString s = d->text;
+    if (s.isEmpty()) {
+        s = d->iconText;
+        s.replace(QLatin1Char('&'), QLatin1String("&&"));
+    }
+    return s;
+}
+
+
+
+
+
+/*!
+    \property QAction::iconText
+    \brief the action's descriptive icon text
+
+    If QToolBar::toolButtonStyle is set to a value that permits text to
+    be displayed, the text defined held in this property appears as a
+    label in the relevant tool button.
+
+    It also serves as the default text in menus and tooltips if the action
+    has not been defined with setText() or setToolTip(), and will
+    also be used in toolbar buttons if no icon has been defined using setIcon().
+
+    If the icon text is not explicitly set, the action's normal text will be
+    used for the icon text.
+
+    By default, this property contains an empty string.
+
+    \sa setToolTip(), setStatusTip()
+*/
+void QAction::setIconText(const QString &text)
+{
+    Q_D(QAction);
+    if (d->iconText == text)
+        return;
+
+    d->iconText = text;
+    d->sendDataChanged();
+}
+
+QString QAction::iconText() const
+{
+    Q_D(const QAction);
+    if (d->iconText.isEmpty())
+        return qt_strippedText(d->text);
+    return d->iconText;
+}
+
+/*!
+    \property QAction::toolTip
+    \brief the action's tooltip
+
+    This text is used for the tooltip. If no tooltip is specified,
+    the action's text is used.
+
+    By default, this property contains the action's text.
+
+    \sa setStatusTip() setShortcut()
+*/
+void QAction::setToolTip(const QString &tooltip)
+{
+    Q_D(QAction);
+    if (d->tooltip == tooltip)
+        return;
+
+    d->tooltip = tooltip;
+    d->sendDataChanged();
+}
+
+QString QAction::toolTip() const
+{
+    Q_D(const QAction);
+    if (d->tooltip.isEmpty()) {
+        if (!d->text.isEmpty())
+            return qt_strippedText(d->text);
+        return qt_strippedText(d->iconText);
+    }
+    return d->tooltip;
+}
+
+/*!
+    \property QAction::statusTip
+    \brief the action's status tip
+
+    The status tip is displayed on all status bars provided by the
+    action's top-level parent widget.
+
+    By default, this property contains an empty string.
+
+    \sa setToolTip() showStatusText()
+*/
+void QAction::setStatusTip(const QString &statustip)
+{
+    Q_D(QAction);
+    if (d->statustip == statustip)
+        return;
+
+    d->statustip = statustip;
+    d->sendDataChanged();
+}
+
+QString QAction::statusTip() const
+{
+    Q_D(const QAction);
+    return d->statustip;
+}
+
+/*!
+    \property QAction::whatsThis
+    \brief the action's "What's This?" help text
+
+    The "What's This?" text is used to provide a brief description of
+    the action. The text may contain rich text. There is no default
+    "What's This?" text.
+
+    \sa QWhatsThis Q3StyleSheet
+*/
+void QAction::setWhatsThis(const QString &whatsthis)
+{
+    Q_D(QAction);
+    if (d->whatsthis == whatsthis)
+        return;
+
+    d->whatsthis = whatsthis;
+    d->sendDataChanged();
+}
+
+QString QAction::whatsThis() const
+{
+    Q_D(const QAction);
+    return d->whatsthis;
+}
+
+/*!
+    \enum QAction::Priority
+    \since 4.6
+
+    This enum defines priorities for actions in user interface.
+
+    \value LowPriority The action should not be prioritized in
+    the user interface.
+
+    \value NormalPriority
+
+    \value HighPriority The action should be prioritized in
+    the user interface.
+
+    \sa priority
+*/
+
+
+/*!
+    \property QAction::priority
+    \since 4.6
+
+    \brief the actions's priority in the user interface.
+
+    This property can be set to indicate how the action should be prioritized
+    in the user interface.
+
+    For instance, when toolbars have the Qt::ToolButtonTextBesideIcon
+    mode set, then actions with LowPriority will not show the text
+    labels.
+*/
+void QAction::setPriority(Priority priority)
+{
+    Q_D(QAction);
+    if (d->priority == priority)
+        return;
+
+    d->priority = priority;
+    d->sendDataChanged();
+}
+
+QAction::Priority QAction::priority() const
+{
+    Q_D(const QAction);
+    return d->priority;
+}
+
+/*!
+    \property QAction::checkable
+    \brief whether the action is a checkable action
+
+    A checkable action is one which has an on/off state. For example,
+    in a word processor, a Bold toolbar button may be either on or
+    off. An action which is not a toggle action is a command action;
+    a command action is simply executed, e.g. file save.
+    By default, this property is false.
+
+    In some situations, the state of one toggle action should depend
+    on the state of others. For example, "Left Align", "Center" and
+    "Right Align" toggle actions are mutually exclusive. To achieve
+    exclusive toggling, add the relevant toggle actions to a
+    QActionGroup with the QActionGroup::exclusive property set to
+    true.
+
+    \sa QAction::setChecked()
+*/
+void QAction::setCheckable(bool b)
+{
+    Q_D(QAction);
+    if (d->checkable == b)
+        return;
+
+    d->checkable = b;
+    d->checked = false;
+    d->sendDataChanged();
+}
+
+bool QAction::isCheckable() const
+{
+    Q_D(const QAction);
+    return d->checkable;
+}
+
+/*!
+    \fn void QAction::toggle()
+
+    This is a convenience function for the \l checked property.
+    Connect to it to change the checked state to its opposite state.
+*/
+void QAction::toggle()
+{
+    Q_D(QAction);
+    setChecked(!d->checked);
+}
+
+/*!
+    \property QAction::checked
+    \brief whether the action is checked.
+
+    Only checkable actions can be checked.  By default, this is false
+    (the action is unchecked).
+
+    \sa checkable
+*/
+void QAction::setChecked(bool b)
+{
+    Q_D(QAction);
+    if (!d->checkable || d->checked == b)
+        return;
+
+    QPointer<QAction> guard(this);
+    d->checked = b;
+    d->sendDataChanged();
+    if (guard)
+        emit toggled(b);
+}
+
+bool QAction::isChecked() const
+{
+    Q_D(const QAction);
+    return d->checked;
+}
+
+/*!
+    \fn void QAction::setDisabled(bool b)
+
+    This is a convenience function for the \l enabled property, that
+    is useful for signals--slots connections. If \a b is true the
+    action is disabled; otherwise it is enabled.
+*/
+
+/*!
+    \property QAction::enabled
+    \brief whether the action is enabled
+
+    Disabled actions cannot be chosen by the user. They do not
+    disappear from menus or toolbars, but they are displayed in a way
+    which indicates that they are unavailable. For example, they might
+    be displayed using only shades of gray.
+
+    \gui{What's This?} help on disabled actions is still available, provided
+    that the QAction::whatsThis property is set.
+
+    An action will be disabled when all widgets to which it is added
+    (with QWidget::addAction()) are disabled or not visible. When an
+    action is disabled, it is not possible to trigger it through its
+    shortcut.
+
+    By default, this property is true (actions are enabled).
+
+    \sa text
+*/
+void QAction::setEnabled(bool b)
+{
+    Q_D(QAction);
+    if (b == d->enabled && b != d->forceDisabled)
+        return;
+    d->forceDisabled = !b;
+    if (b && (!d->visible || (d->group && !d->group->isEnabled())))
+        return;
+    QAPP_CHECK("setEnabled");
+    d->enabled = b;
+#ifndef QT_NO_SHORTCUT
+    d->setShortcutEnabled(b, qApp->d_func()->shortcutMap);
+#endif
+    d->sendDataChanged();
+}
+
+bool QAction::isEnabled() const
+{
+    Q_D(const QAction);
+    return d->enabled;
+}
+
+/*!
+    \property QAction::visible
+    \brief whether the action can be seen (e.g. in menus and toolbars)
+
+    If \e visible is true the action can be seen (e.g. in menus and
+    toolbars) and chosen by the user; if \e visible is false the
+    action cannot be seen or chosen by the user.
+
+    Actions which are not visible are \e not grayed out; they do not
+    appear at all.
+
+    By default, this property is true (actions are visible).
+*/
+void QAction::setVisible(bool b)
+{
+    Q_D(QAction);
+    if (b == d->visible && b != d->forceInvisible)
+        return;
+    QAPP_CHECK("setVisible");
+    d->forceInvisible = !b;
+    d->visible = b;
+    d->enabled = b && !d->forceDisabled && (!d->group || d->group->isEnabled()) ;
+#ifndef QT_NO_SHORTCUT
+    d->setShortcutEnabled(d->enabled, qApp->d_func()->shortcutMap);
+#endif
+    d->sendDataChanged();
+}
+
+
+bool QAction::isVisible() const
+{
+    Q_D(const QAction);
+    return d->visible;
+}
+
+/*!
+  \reimp
+*/
+bool
+QAction::event(QEvent *e)
+{
+#ifndef QT_NO_SHORTCUT
+    if (e->type() == QEvent::Shortcut) {
+        QShortcutEvent *se = static_cast<QShortcutEvent *>(e);
+        Q_ASSERT_X(se->key() == d_func()->shortcut || d_func()->alternateShortcuts.contains(se->key()),
+                   "QAction::event",
+                   "Received shortcut event from incorrect shortcut");
+        if (se->isAmbiguous())
+            qWarning("QAction::eventFilter: Ambiguous shortcut overload: %s", se->key().toString(QKeySequence::NativeText).toLatin1().constData());
+        else
+            activate(Trigger);
+        return true;
+    }
+#endif
+    return QObject::event(e);
+}
+
+/*!
+  Returns the user data as set in QAction::setData.
+
+  \sa setData()
+*/
+QVariant
+QAction::data() const
+{
+    Q_D(const QAction);
+    return d->userData;
+}
+
+/*!
+  \fn void QAction::setData(const QVariant &userData)
+
+  Sets the action's internal data to the given \a userData.
+
+  \sa data()
+*/
+void
+QAction::setData(const QVariant &data)
+{
+    Q_D(QAction);
+    d->userData = data;
+    d->sendDataChanged();
+}
+
+
+/*!
+  Updates the relevant status bar for the \a widget specified by sending a
+  QStatusTipEvent to its parent widget. Returns true if an event was sent;
+  otherwise returns false.
+
+  If a null widget is specified, the event is sent to the action's parent.
+
+  \sa statusTip
+*/
+bool
+QAction::showStatusText(QWidget *widget)
+{
+    return d_func()->showStatusText(widget, statusTip());
+}
+
+/*!
+  Sends the relevant signals for ActionEvent \a event.
+
+  Action based widgets use this API to cause the QAction
+  to emit signals as well as emitting their own.
+*/
+void QAction::activate(ActionEvent event)
+{
+    Q_D(QAction);
+    if (event == Trigger) {
+        QWeakPointer<QObject> guard = this;
+        if (d->checkable) {
+            // the checked action of an exclusive group cannot be  unchecked
+            if (d->checked && (d->group && d->group->isExclusive()
+                               && d->group->checkedAction() == this)) {
+                if (!guard.isNull())
+                    emit triggered(true);
+                return;
+            }
+            setChecked(!d->checked);
+        }
+        if (!guard.isNull())
+            emit triggered(d->checked);
+    } else if (event == Hover) {
+        emit hovered();
+    }
+}
+
+/*!
+    \fn void QAction::triggered(bool checked)
+
+    This signal is emitted when an action is activated by the user;
+    for example, when the user clicks a menu option, toolbar button,
+    or presses an action's shortcut key combination, or when trigger()
+    was called. Notably, it is \e not emitted when setChecked() or
+    toggle() is called.
+
+    If the action is checkable, \a checked is true if the action is
+    checked, or false if the action is unchecked.
+
+    \sa QAction::activate(), QAction::toggled(), checked
+*/
+
+/*!
+    \fn void QAction::toggled(bool checked)
+
+    This signal is emitted whenever a checkable action changes its
+    isChecked() status. This can be the result of a user interaction,
+    or because setChecked() was called.
+
+    \a checked is true if the action is checked, or false if the
+    action is unchecked.
+
+    \sa QAction::activate(), QAction::triggered(), checked
+*/
+
+/*!
+    \fn void QAction::hovered()
+
+    This signal is emitted when an action is highlighted by the user;
+    for example, when the user pauses with the cursor over a menu option,
+    toolbar button, or presses an action's shortcut key combination.
+
+    \sa QAction::activate()
+*/
+
+/*!
+    \fn void QAction::changed()
+
+    This signal is emitted when an action has changed. If you
+    are only interested in actions in a given widget, you can
+    watch for QWidget::actionEvent() sent with an
+    QEvent::ActionChanged.
+
+    \sa QWidget::actionEvent()
+*/
+
+/*!
+    \enum QAction::ActionEvent
+
+    This enum type is used when calling QAction::activate()
+
+    \value Trigger this will cause the QAction::triggered() signal to be emitted.
+
+    \value Hover this will cause the QAction::hovered() signal to be emitted.
+*/
+
+/*!
+    \property QAction::menuRole
+    \brief the action's menu role
+    \since 4.2
+
+    This indicates what role the action serves in the application menu on Mac
+    OS X. By default all action have the TextHeuristicRole, which means that
+    the action is added based on its text (see QMenuBar for more information).
+
+    The menu role can only be changed before the actions are put into the menu
+    bar in Mac OS X (usually just before the first application window is
+    shown).
+*/
+void QAction::setMenuRole(MenuRole menuRole)
+{
+    Q_D(QAction);
+    if (d->menuRole == menuRole)
+        return;
+
+    d->menuRole = menuRole;
+    d->sendDataChanged();
+}
+
+QAction::MenuRole QAction::menuRole() const
+{
+    Q_D(const QAction);
+    return d->menuRole;
+}
+
+/*!
+    \property QAction::softKeyRole
+    \brief the action's softkey role
+    \since 4.6
+
+    This indicates what type of role this action describes in the softkey framework
+    on platforms where such a framework is supported. Currently this is only
+    supported on the Symbian platform.
+
+    The softkey role can be changed any time.
+*/
+void QAction::setSoftKeyRole(SoftKeyRole softKeyRole)
+{
+    Q_D(QAction);
+    if (d->softKeyRole == softKeyRole)
+        return;
+
+    d->softKeyRole = softKeyRole;
+    d->sendDataChanged();
+}
+
+QAction::SoftKeyRole QAction::softKeyRole() const
+{
+    Q_D(const QAction);
+    return d->softKeyRole;
+}
+
+/*!
+    \property QAction::iconVisibleInMenu
+    \brief Whether or not an action should show an icon in a menu
+    \since 4.4
+
+    In some applications, it may make sense to have actions with icons in the
+    toolbar, but not in menus. If true, the icon (if valid) is shown in the menu, when it
+    is false, it is not shown.
+
+    The default is to follow whether the Qt::AA_DontShowIconsInMenus attribute
+    is set for the application. Explicitly settings this property overrides
+    the presence (or abscence) of the attribute.
+
+    For example:
+    \snippet doc/src/snippets/code/src_gui_kernel_qaction.cpp 0
+
+    \sa QAction::icon QApplication::setAttribute()
+*/
+void QAction::setIconVisibleInMenu(bool visible)
+{
+    Q_D(QAction);
+    if (d->iconVisibleInMenu == -1 || visible != bool(d->iconVisibleInMenu)) {
+        int oldValue = d->iconVisibleInMenu;
+        d->iconVisibleInMenu = visible;
+        // Only send data changed if we really need to.
+        if (oldValue != -1
+            || (oldValue == -1
+                && visible == !QApplication::instance()->testAttribute(Qt::AA_DontShowIconsInMenus))) {
+            d->sendDataChanged();
+        }
+    }
+}
+
+bool QAction::isIconVisibleInMenu() const
+{
+    Q_D(const QAction);
+    if (d->iconVisibleInMenu == -1) {
+        return !QApplication::instance()->testAttribute(Qt::AA_DontShowIconsInMenus);
+    }
+    return d->iconVisibleInMenu;
+}
+
+QT_END_NAMESPACE
+
+#include "moc_qaction.cpp"
+
+#endif // QT_NO_ACTION
diff --git a/src/action/qaction.h b/src/action/qaction.h
new file mode 100644
index 0000000..485b592
--- /dev/null
+++ b/src/action/qaction.h
@@ -0,0 +1,232 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** This file may be used under the terms of the GNU Lesser General Public
+** License version 2.1 as published by the Free Software Foundation and
+** appearing in the file LICENSE.LGPL included in the packaging of this
+** file. Please review the following information to ensure the GNU Lesser
+** General Public License version 2.1 requirements will be met:
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QACTION_H
+#define QACTION_H
+
+#include <QtGui/qkeysequence.h>
+#include <QtCore/qstring.h>
+#include <QtWidgets/qwidget.h>
+#include <QtCore/qvariant.h>
+#include <QtWidgets/qicon.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+
+#ifndef QT_NO_ACTION
+
+class QMenu;
+class QActionGroup;
+class QActionPrivate;
+class QGraphicsWidget;
+
+class Q_WIDGETS_EXPORT QAction : public QObject
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QAction)
+
+    Q_ENUMS(MenuRole)
+    Q_ENUMS(SoftKeyRole)
+    Q_ENUMS(Priority)
+    Q_PROPERTY(bool checkable READ isCheckable WRITE setCheckable NOTIFY changed)
+    Q_PROPERTY(bool checked READ isChecked WRITE setChecked DESIGNABLE isCheckable NOTIFY toggled)
+    Q_PROPERTY(bool enabled READ isEnabled WRITE setEnabled NOTIFY changed)
+    Q_PROPERTY(QIcon icon READ icon WRITE setIcon NOTIFY changed)
+    Q_PROPERTY(QString text READ text WRITE setText NOTIFY changed)
+    Q_PROPERTY(QString iconText READ iconText WRITE setIconText NOTIFY changed)
+    Q_PROPERTY(QString toolTip READ toolTip WRITE setToolTip NOTIFY changed)
+    Q_PROPERTY(QString statusTip READ statusTip WRITE setStatusTip NOTIFY changed)
+    Q_PROPERTY(QString whatsThis READ whatsThis WRITE setWhatsThis NOTIFY changed)
+    Q_PROPERTY(QFont font READ font WRITE setFont NOTIFY changed)
+#ifndef QT_NO_SHORTCUT
+    Q_PROPERTY(QKeySequence shortcut READ shortcut WRITE setShortcut NOTIFY changed)
+    Q_PROPERTY(Qt::ShortcutContext shortcutContext READ shortcutContext WRITE setShortcutContext NOTIFY changed)
+    Q_PROPERTY(bool autoRepeat READ autoRepeat WRITE setAutoRepeat NOTIFY changed)
+#endif
+    Q_PROPERTY(bool visible READ isVisible WRITE setVisible NOTIFY changed)
+    Q_PROPERTY(MenuRole menuRole READ menuRole WRITE setMenuRole NOTIFY changed)
+    Q_PROPERTY(SoftKeyRole softKeyRole READ softKeyRole WRITE setSoftKeyRole NOTIFY changed)
+    Q_PROPERTY(bool iconVisibleInMenu READ isIconVisibleInMenu WRITE setIconVisibleInMenu NOTIFY changed)
+    Q_PROPERTY(Priority priority READ priority WRITE setPriority)
+
+public:
+    enum MenuRole { NoRole, TextHeuristicRole, ApplicationSpecificRole, AboutQtRole,
+                    AboutRole, PreferencesRole, QuitRole };
+    enum SoftKeyRole {
+                    NoSoftKey, PositiveSoftKey, NegativeSoftKey, SelectSoftKey };
+    enum Priority { LowPriority = 0,
+                    NormalPriority = 128,
+                    HighPriority = 256};
+    explicit QAction(QObject* parent);
+    QAction(const QString &text, QObject* parent);
+    QAction(const QIcon &icon, const QString &text, QObject* parent);
+
+    ~QAction();
+
+    void setActionGroup(QActionGroup *group);
+    QActionGroup *actionGroup() const;
+    void setIcon(const QIcon &icon);
+    QIcon icon() const;
+
+    void setText(const QString &text);
+    QString text() const;
+
+    void setIconText(const QString &text);
+    QString iconText() const;
+
+    void setToolTip(const QString &tip);
+    QString toolTip() const;
+
+    void setStatusTip(const QString &statusTip);
+    QString statusTip() const;
+
+    void setWhatsThis(const QString &what);
+    QString whatsThis() const;
+
+    void setPriority(Priority priority);
+    Priority priority() const;
+
+#ifndef QT_NO_MENU
+    QMenu *menu() const;
+    void setMenu(QMenu *menu);
+#endif
+
+    void setSeparator(bool b);
+    bool isSeparator() const;
+
+#ifndef QT_NO_SHORTCUT
+    void setShortcut(const QKeySequence &shortcut);
+    QKeySequence shortcut() const;
+
+    void setShortcuts(const QList<QKeySequence> &shortcuts);
+    void setShortcuts(QKeySequence::StandardKey);
+    QList<QKeySequence> shortcuts() const;
+
+    void setShortcutContext(Qt::ShortcutContext context);
+    Qt::ShortcutContext shortcutContext() const;
+
+    void setAutoRepeat(bool);
+    bool autoRepeat() const;
+#endif
+
+    void setFont(const QFont &font);
+    QFont font() const;
+
+    void setCheckable(bool);
+    bool isCheckable() const;
+
+    QVariant data() const;
+    void setData(const QVariant &var);
+
+    bool isChecked() const;
+
+    bool isEnabled() const;
+
+    bool isVisible() const;
+
+    enum ActionEvent { Trigger, Hover };
+    void activate(ActionEvent event);
+    bool showStatusText(QWidget *widget=0);
+
+    void setMenuRole(MenuRole menuRole);
+    MenuRole menuRole() const;
+
+    void setSoftKeyRole(SoftKeyRole softKeyRole);
+    SoftKeyRole softKeyRole() const;
+
+    void setIconVisibleInMenu(bool visible);
+    bool isIconVisibleInMenu() const;
+
+
+    QWidget *parentWidget() const;
+
+    QList<QWidget *> associatedWidgets() const;
+#ifndef QT_NO_GRAPHICSVIEW
+    QList<QGraphicsWidget *> associatedGraphicsWidgets() const; // ### suboptimal
+#endif
+
+protected:
+    bool event(QEvent *);
+    QAction(QActionPrivate &dd, QObject *parent);
+
+public Q_SLOTS:
+    void trigger() { activate(Trigger); }
+    void hover() { activate(Hover); }
+    void setChecked(bool);
+    void toggle();
+    void setEnabled(bool);
+    inline void setDisabled(bool b) { setEnabled(!b); }
+    void setVisible(bool);
+
+Q_SIGNALS:
+    void changed();
+    void triggered(bool checked = false);
+    void hovered();
+    void toggled(bool);
+
+private:
+    Q_DISABLE_COPY(QAction)
+
+    friend class QGraphicsWidget;
+    friend class QWidget;
+    friend class QActionGroup;
+    friend class QMenu;
+    friend class QMenuPrivate;
+    friend class QMenuBar;
+    friend class QToolButton;
+#ifdef Q_OS_MAC
+    friend void qt_mac_clear_status_text(QAction *action);
+#endif
+};
+
+QT_BEGIN_INCLUDE_NAMESPACE
+#include <QtWidgets/qactiongroup.h>
+QT_END_INCLUDE_NAMESPACE
+
+#endif // QT_NO_ACTION
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QACTION_H
diff --git a/src/action/qaction_p.h b/src/action/qaction_p.h
new file mode 100644
index 0000000..7a8cd5e
--- /dev/null
+++ b/src/action/qaction_p.h
@@ -0,0 +1,137 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** This file may be used under the terms of the GNU Lesser General Public
+** License version 2.1 as published by the Free Software Foundation and
+** appearing in the file LICENSE.LGPL included in the packaging of this
+** file. Please review the following information to ensure the GNU Lesser
+** General Public License version 2.1 requirements will be met:
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QACTION_P_H
+#define QACTION_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "QtWidgets/qaction.h"
+#include "QtWidgets/qmenu.h"
+#include "private/qgraphicswidget_p.h"
+#include "private/qobject_p.h"
+
+QT_BEGIN_NAMESPACE
+
+#ifndef QT_NO_ACTION
+
+
+class QShortcutMap;
+
+class Q_WIDGETS_EXPORT QActionPrivate : public QObjectPrivate
+{
+    Q_DECLARE_PUBLIC(QAction)
+public:
+    QActionPrivate();
+    ~QActionPrivate();
+
+    static QActionPrivate *get(QAction *q)
+    {
+        return q->d_func();
+    }
+
+    bool showStatusText(QWidget *w, const QString &str);
+
+    QPointer<QActionGroup> group;
+    QString text;
+    QString iconText;
+    QIcon icon;
+    QString tooltip;
+    QString statustip;
+    QString whatsthis;
+#ifndef QT_NO_SHORTCUT
+    QKeySequence shortcut;
+    QList<QKeySequence> alternateShortcuts;
+#endif
+    QVariant userData;
+#ifndef QT_NO_SHORTCUT
+    int shortcutId;
+    QList<int> alternateShortcutIds;
+    Qt::ShortcutContext shortcutContext;
+    uint autorepeat : 1;
+#endif
+    QFont font;
+    QPointer<QMenu> menu;
+    uint enabled : 1, forceDisabled : 1;
+    uint visible : 1, forceInvisible : 1;
+    uint checkable : 1;
+    uint checked : 1;
+    uint separator : 1;
+    uint fontSet : 1;
+
+    //for soft keys management
+    uint forceEnabledInSoftkeys : 1;
+    uint menuActionSoftkeys : 1;
+    int iconVisibleInMenu : 3;  // Only has values -1, 0, and 1
+
+    QAction::MenuRole menuRole;
+    QAction::SoftKeyRole softKeyRole;
+    QAction::Priority priority;
+
+    QList<QWidget *> widgets;
+#ifndef QT_NO_GRAPHICSVIEW
+    QList<QGraphicsWidget *> graphicsWidgets;
+#endif
+#ifndef QT_NO_SHORTCUT
+    void redoGrab(QShortcutMap &map);
+    void redoGrabAlternate(QShortcutMap &map);
+    void setShortcutEnabled(bool enable, QShortcutMap &map);
+
+    static QShortcutMap *globalMap;
+#endif // QT_NO_SHORTCUT
+
+    void sendDataChanged();
+};
+
+#endif // QT_NO_ACTION
+
+QT_END_NAMESPACE
+
+#endif // QACTION_P_H
diff --git a/src/action/qactiongroup.cpp b/src/action/qactiongroup.cpp
new file mode 100644
index 0000000..70bef43
--- /dev/null
+++ b/src/action/qactiongroup.cpp
@@ -0,0 +1,416 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** This file may be used under the terms of the GNU Lesser General Public
+** License version 2.1 as published by the Free Software Foundation and
+** appearing in the file LICENSE.LGPL included in the packaging of this
+** file. Please review the following information to ensure the GNU Lesser
+** General Public License version 2.1 requirements will be met:
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qactiongroup.h"
+
+#ifndef QT_NO_ACTION
+
+#include "qaction_p.h"
+#include "qapplication.h"
+#include "qevent.h"
+#include "qlist.h"
+
+QT_BEGIN_NAMESPACE
+
+class QActionGroupPrivate : public QObjectPrivate
+{
+    Q_DECLARE_PUBLIC(QActionGroup)
+public:
+    QActionGroupPrivate() : exclusive(1), enabled(1), visible(1)  { }
+    QList<QAction *> actions;
+    QPointer<QAction> current;
+    uint exclusive : 1;
+    uint enabled : 1;
+    uint visible : 1;
+
+private:
+    void _q_actionTriggered();  //private slot
+    void _q_actionChanged();    //private slot
+    void _q_actionHovered();    //private slot
+};
+
+void QActionGroupPrivate::_q_actionChanged()
+{
+    Q_Q(QActionGroup);
+    QAction *action = qobject_cast<QAction*>(q->sender());
+    Q_ASSERT_X(action != 0, "QWidgetGroup::_q_actionChanged", "internal error");
+    if (exclusive) {
+        if (action->isChecked()) {
+            if (action != current) {
+                if (current)
+                    current->setChecked(false);
+                current = action;
+            }
+        } else if (action == current) {
+            current = 0;
+        }
+    }
+}
+
+void QActionGroupPrivate::_q_actionTriggered()
+{
+    Q_Q(QActionGroup);
+    QAction *action = qobject_cast<QAction*>(q->sender());
+    Q_ASSERT_X(action != 0, "QWidgetGroup::_q_actionTriggered", "internal error");
+    emit q->triggered(action);
+}
+
+void QActionGroupPrivate::_q_actionHovered()
+{
+    Q_Q(QActionGroup);
+    QAction *action = qobject_cast<QAction*>(q->sender());
+    Q_ASSERT_X(action != 0, "QWidgetGroup::_q_actionHovered", "internal error");
+    emit q->hovered(action);
+}
+
+/*!
+    \class QActionGroup
+    \brief The QActionGroup class groups actions together.
+
+    \ingroup mainwindow-classes
+    \inmodule QtWidgets
+
+    In some situations it is useful to group QAction objects together.
+    For example, if you have a \gui{Left Align} action, a \gui{Right
+    Align} action, a \gui{Justify} action, and a \gui{Center} action,
+    only one of these actions should be active at any one time. One
+    simple way of achieving this is to group the actions together in
+    an action group.
+
+    Here's a example (from the \l{mainwindows/menus}{Menus} example):
+
+    \snippet examples/mainwindows/menus/mainwindow.cpp 6
+
+    Here we create a new action group. Since the action group is
+    exclusive by default, only one of the actions in the group is
+    checked at any one time.
+
+    \img qactiongroup-align.png Alignment options in a QMenu
+
+    A QActionGroup emits an triggered() signal when one of its
+    actions is chosen. Each action in an action group emits its
+    triggered() signal as usual.
+
+    As stated above, an action group is \l exclusive by default; it
+    ensures that only one checkable action is active at any one time.
+    If you want to group checkable actions without making them
+    exclusive, you can turn of exclusiveness by calling
+    setExclusive(false).
+
+    Actions can be added to an action group using addAction(), but it
+    is usually more convenient to specify a group when creating
+    actions; this ensures that actions are automatically created with
+    a parent. Actions can be visually separated from each other by
+    adding a separator action to the group; create an action and use
+    QAction's \l {QAction::}{setSeparator()} function to make it
+    considered a separator. Action groups are added to widgets with
+    the QWidget::addActions() function.
+
+    \sa QAction
+*/
+
+/*!
+    Constructs an action group for the \a parent object.
+
+    The action group is exclusive by default. Call setExclusive(false)
+    to make the action group non-exclusive.
+*/
+QActionGroup::QActionGroup(QObject* parent) : QObject(*new QActionGroupPrivate, parent)
+{
+}
+
+/*!
+    Destroys the action group.
+*/
+QActionGroup::~QActionGroup()
+{
+}
+
+/*!
+    \fn QAction *QActionGroup::addAction(QAction *action)
+
+    Adds the \a action to this group, and returns it.
+
+    Normally an action is added to a group by creating it with the
+    group as its parent, so this function is not usually used.
+
+    \sa QAction::setActionGroup()
+*/
+QAction *QActionGroup::addAction(QAction* a)
+{
+    Q_D(QActionGroup);
+    if (!d->actions.contains(a)) {
+        d->actions.append(a);
+        QObject::connect(a, SIGNAL(triggered()), this, SLOT(_q_actionTriggered()));
+        QObject::connect(a, SIGNAL(changed()), this, SLOT(_q_actionChanged()));
+        QObject::connect(a, SIGNAL(hovered()), this, SLOT(_q_actionHovered()));
+    }
+    if (!a->d_func()->forceDisabled) {
+        a->setEnabled(d->enabled);
+        a->d_func()->forceDisabled = false;
+    }
+    if (!a->d_func()->forceInvisible) {
+        a->setVisible(d->visible);
+        a->d_func()->forceInvisible = false;
+    }
+    if (a->isChecked())
+        d->current = a;
+    QActionGroup *oldGroup = a->d_func()->group;
+    if (oldGroup != this) {
+        if (oldGroup)
+            oldGroup->removeAction(a);
+        a->d_func()->group = this;
+    }
+    return a;
+}
+
+/*!
+    Creates and returns an action with \a text.  The newly created
+    action is a child of this action group.
+
+    Normally an action is added to a group by creating it with the
+    group as parent, so this function is not usually used.
+
+    \sa QAction::setActionGroup()
+*/
+QAction *QActionGroup::addAction(const QString &text)
+{
+    return new QAction(text, this);
+}
+
+/*!
+    Creates and returns an action with \a text and an \a icon. The
+    newly created action is a child of this action group.
+
+    Normally an action is added to a group by creating it with the
+    group as its parent, so this function is not usually used.
+
+    \sa QAction::setActionGroup()
+*/
+QAction *QActionGroup::addAction(const QIcon &icon, const QString &text)
+{
+    return new QAction(icon, text, this);
+}
+
+/*!
+  Removes the \a action from this group. The action will have no
+  parent as a result.
+
+  \sa QAction::setActionGroup()
+*/
+void QActionGroup::removeAction(QAction *action)
+{
+    Q_D(QActionGroup);
+    if (d->actions.removeAll(action)) {
+        if (action == d->current)
+            d->current = 0;
+        QObject::disconnect(action, SIGNAL(triggered()), this, SLOT(_q_actionTriggered()));
+        QObject::disconnect(action, SIGNAL(changed()), this, SLOT(_q_actionChanged()));
+        QObject::disconnect(action, SIGNAL(hovered()), this, SLOT(_q_actionHovered()));
+        action->d_func()->group = 0;
+    }
+}
+
+/*!
+    Returns the list of this groups's actions. This may be empty.
+*/
+QList<QAction*> QActionGroup::actions() const
+{
+    Q_D(const QActionGroup);
+    return d->actions;
+}
+
+/*!
+    \property QActionGroup::exclusive
+    \brief whether the action group does exclusive checking
+
+    If exclusive is true, only one checkable action in the action group
+    can ever be active at any time. If the user chooses another
+    checkable action in the group, the one they chose becomes active and
+    the one that was active becomes inactive.
+
+    \sa QAction::checkable
+*/
+void QActionGroup::setExclusive(bool b)
+{
+    Q_D(QActionGroup);
+    d->exclusive = b;
+}
+
+bool QActionGroup::isExclusive() const
+{
+    Q_D(const QActionGroup);
+    return d->exclusive;
+}
+
+/*!
+    \fn void QActionGroup::setDisabled(bool b)
+
+    This is a convenience function for the \l enabled property, that
+    is useful for signals--slots connections. If \a b is true the
+    action group is disabled; otherwise it is enabled.
+*/
+
+/*!
+    \property QActionGroup::enabled
+    \brief whether the action group is enabled
+
+    Each action in the group will be enabled or disabled unless it
+    has been explicitly disabled.
+
+    \sa QAction::setEnabled()
+*/
+void QActionGroup::setEnabled(bool b)
+{
+    Q_D(QActionGroup);
+    d->enabled = b;
+    for (QList<QAction*>::const_iterator it = d->actions.constBegin(); it != d->actions.constEnd(); ++it) {
+        if (!(*it)->d_func()->forceDisabled) {
+            (*it)->setEnabled(b);
+            (*it)->d_func()->forceDisabled = false;
+        }
+    }
+}
+
+bool QActionGroup::isEnabled() const
+{
+    Q_D(const QActionGroup);
+    return d->enabled;
+}
+
+/*!
+  Returns the currently checked action in the group, or 0 if none
+  are checked.
+*/
+QAction *QActionGroup::checkedAction() const
+{
+    Q_D(const QActionGroup);
+    return d->current;
+}
+
+/*!
+    \property QActionGroup::visible
+    \brief whether the action group is visible
+
+    Each action in the action group will match the visible state of
+    this group unless it has been explicitly hidden.
+
+    \sa QAction::setEnabled()
+*/
+void QActionGroup::setVisible(bool b)
+{
+    Q_D(QActionGroup);
+    d->visible = b;
+    for (QList<QAction*>::Iterator it = d->actions.begin(); it != d->actions.end(); ++it) {
+        if (!(*it)->d_func()->forceInvisible) {
+            (*it)->setVisible(b);
+            (*it)->d_func()->forceInvisible = false;
+        }
+    }
+}
+
+bool QActionGroup::isVisible() const
+{
+    Q_D(const QActionGroup);
+    return d->visible;
+}
+
+/*!
+    \fn void QActionGroup::triggered(QAction *action)
+
+    This signal is emitted when the given \a action in the action
+    group is activated by the user; for example, when the user clicks
+    a menu option, toolbar button, or presses an action's shortcut key
+    combination.
+
+    Connect to this signal for command actions.
+
+    \sa QAction::activate()
+*/
+
+/*!
+    \fn void QActionGroup::hovered(QAction *action)
+
+    This signal is emitted when the given \a action in the action
+    group is highlighted by the user; for example, when the user
+    pauses with the cursor over a menu option, toolbar button, or
+    presses an action's shortcut key combination.
+
+    \sa QAction::activate()
+*/
+
+/*!
+    \fn void QActionGroup::add(QAction* a)
+
+    Use addAction() instead.
+*/
+
+/*!
+    \fn void QActionGroup::addSeparator()
+
+    Normally you add a separator to the menus or widgets to which
+    actions are added, so this function is very rarely needed.
+
+    \oldcode
+    actionGroup->addSeparator();
+    \newcode
+    QAction *separator = new QAction(this);
+    separator->setSeparator(true);
+    actionGroup->addAction(separator);
+    \endcode
+*/
+
+/*!
+    \fn bool QActionGroup::addTo(QWidget *widget)
+
+    \oldcode
+    actionGroup->addTo(widget);
+    \newcode
+    widget->addActions(actionGroup->actions());
+    \endcode
+*/
+
+
+QT_END_NAMESPACE
+
+#include "moc_qactiongroup.cpp"
+
+#endif // QT_NO_ACTION
diff --git a/src/action/qactiongroup.h b/src/action/qactiongroup.h
new file mode 100644
index 0000000..3cff248
--- /dev/null
+++ b/src/action/qactiongroup.h
@@ -0,0 +1,104 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** This file may be used under the terms of the GNU Lesser General Public
+** License version 2.1 as published by the Free Software Foundation and
+** appearing in the file LICENSE.LGPL included in the packaging of this
+** file. Please review the following information to ensure the GNU Lesser
+** General Public License version 2.1 requirements will be met:
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QACTIONGROUP_H
+#define QACTIONGROUP_H
+
+#include <QtWidgets/qaction.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+
+#ifndef QT_NO_ACTION
+
+class QActionGroupPrivate;
+
+class Q_WIDGETS_EXPORT QActionGroup : public QObject
+{
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QActionGroup)
+
+    Q_PROPERTY(bool exclusive READ isExclusive WRITE setExclusive)
+    Q_PROPERTY(bool enabled READ isEnabled WRITE setEnabled)
+    Q_PROPERTY(bool visible READ isVisible WRITE setVisible)
+
+public:
+    explicit QActionGroup(QObject* parent);
+    ~QActionGroup();
+
+    QAction *addAction(QAction* a);
+    QAction *addAction(const QString &text);
+    QAction *addAction(const QIcon &icon, const QString &text);
+    void removeAction(QAction *a);
+    QList<QAction*> actions() const;
+
+    QAction *checkedAction() const;
+    bool isExclusive() const;
+    bool isEnabled() const;
+    bool isVisible() const;
+
+
+public Q_SLOTS:
+    void setEnabled(bool);
+    inline void setDisabled(bool b) { setEnabled(!b); }
+    void setVisible(bool);
+    void setExclusive(bool);
+
+Q_SIGNALS:
+    void triggered(QAction *);
+    void hovered(QAction *);
+
+private:
+    Q_DISABLE_COPY(QActionGroup)
+    Q_PRIVATE_SLOT(d_func(), void _q_actionTriggered())
+    Q_PRIVATE_SLOT(d_func(), void _q_actionChanged())
+    Q_PRIVATE_SLOT(d_func(), void _q_actionHovered())
+};
+
+#endif // QT_NO_ACTION
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QACTIONGROUP_H
diff --git a/src/src.pro b/src/src.pro
index 8dd146c..8897458 100644
--- a/src/src.pro
+++ b/src/src.pro
@@ -2,7 +2,7 @@ load(qt_module)
 
 TARGET = UiHelpers
 QPRO_PWD   = $$PWD
-QT = core core-private gui
+QT = core core-private gui gui-private
 CONFIG += module
 MODULE_PRI = ../modules/qt_uihelpers.pri
 
@@ -20,3 +20,4 @@ HEADERS += \
 
 include(utils/utils.pri)
 include(models/models.pri)
+include(action/action.pri)