diff -r 000000000000 -r 1918ee327afb src/gui/kernel/qaction.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/gui/kernel/qaction.cpp	Mon Jan 11 14:00:40 2010 +0000
@@ -0,0 +1,1508 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, 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.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $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),
+                                   menuRole(QAction::TextHeuristicRole), softKeyRole(QAction::NoSoftKey),
+                                   priority(QAction::NormalPriority), iconVisibleInMenu(-1)
+{
+#ifdef QT3_SUPPORT
+    static int qt_static_action_id = -1;
+    param = id = --qt_static_action_id;
+    act_signal = 0;
+#endif
+#ifndef QT_NO_SHORTCUT
+    shortcutId = 0;
+    shortcutContext = Qt::WindowShortcut;
+    autorepeat = true;
+#endif
+}
+
+QActionPrivate::~QActionPrivate()
+{
+}
+
+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);
+    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));
+        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
+
+
+    \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 heirarchy 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;
+}
+
+#ifdef QT3_SUPPORT
+/*!
+    Use one of the QAction constructors that doesn't take a \a name
+    argument and call setObjectName() instead.
+*/
+QAction::QAction(QObject* parent, const char* name)
+ : QObject(*(new QActionPrivate), parent)
+{
+    Q_D(QAction);
+    setObjectName(QString::fromAscii(name));
+    d->group = qobject_cast<QActionGroup *>(parent);
+    if (d->group)
+        d->group->addAction(this);
+}
+
+
+/*!
+    Use one of the QAction constructors that doesn't take a \a name
+    argument and call setObjectName() instead.
+*/
+QAction::QAction(const QString &text, const QKeySequence &shortcut, QObject* parent, const char* name)
+ : QObject(*(new QActionPrivate), parent)
+{
+    Q_D(QAction);
+    setObjectName(QString::fromAscii(name));
+    d->text = text;
+    setShortcut(shortcut);
+    d->group = qobject_cast<QActionGroup *>(parent);
+    if (d->group)
+        d->group->addAction(this);
+}
+
+/*!
+    Use one of the QAction constructors that doesn't take a \a name
+    argument and call setObjectName() instead.
+*/
+QAction::QAction(const QIcon &icon, const QString &text, const QKeySequence &shortcut,
+                 QObject* parent, const char* name)
+    : QObject(*(new QActionPrivate), parent)
+{
+    Q_D(QAction);
+    setObjectName(QString::fromAscii(name));
+    d->text = text;
+    setShortcut(shortcut);
+    d->icon = icon;
+    d->group = qobject_cast<QActionGroup *>(parent);
+    if (d->group)
+        d->group->addAction(this);
+}
+#endif
+
+/*!
+    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", QString(se->key()).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)
+{
+#ifdef QT_NO_STATUSTIP
+    Q_UNUSED(widget);
+#else
+    if(QObject *object = widget ? widget : parent()) {
+        QStatusTipEvent tip(statusTip());
+        QApplication::sendEvent(object, &tip);
+        return true;
+    }
+#endif
+    return false;
+}
+
+/*!
+  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) {
+        QObject *guard = this;
+        QMetaObject::addGuard(&guard);
+        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)
+                    emit triggered(true);
+                QMetaObject::removeGuard(&guard);
+                return;
+            }
+            setChecked(!d->checked);
+        }
+        if (guard)
+            emit triggered(d->checked);
+#ifdef QT3_SUPPORT
+        if (guard)
+            emit activated(d->param);
+#endif
+        QMetaObject::removeGuard(&guard);
+    } 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.
+*/
+
+/*!
+    \fn void QAction::setMenuText(const QString &text)
+
+    Use setText() instead.
+*/
+
+/*!
+    \fn QString QAction::menuText() const
+
+    Use text() instead.
+*/
+
+/*!
+    \fn bool QAction::isOn() const
+
+    Use isChecked() instead.
+*/
+
+/*!
+    \fn void QAction::setOn(bool b)
+
+    Use setChecked() instead.
+*/
+
+/*!
+    \fn bool QAction::isToggleAction() const
+
+    Use isCheckable() instead.
+*/
+
+/*!
+    \fn void QAction::setToggleAction(bool b)
+
+    Use setCheckable() instead.
+*/
+
+/*!
+    \fn void QAction::setIconSet(const QIcon &i)
+
+    Use setIcon() instead.
+*/
+
+/*!
+    \fn bool QAction::addTo(QWidget *w)
+
+    Use QWidget::addAction() instead.
+
+    \oldcode
+    action->addTo(widget);
+    \newcode
+    widget->addAction(action);
+    \endcode
+*/
+
+/*!
+    \fn bool QAction::removeFrom(QWidget *w)
+
+    Use QWidget::removeAction() instead.
+
+    \oldcode
+    action->removeFrom(widget);
+    \newcode
+    widget->removeAction(action);
+    \endcode
+*/
+
+/*!
+    \fn void QAction::setAccel(const QKeySequence &shortcut)
+
+    Use setShortcut() instead.
+*/
+
+/*!
+    \fn QIcon QAction::iconSet() const
+
+    Use icon() instead.
+*/
+
+/*!
+    \fn QKeySequence QAction::accel() const
+
+    Use shortcut() instead.
+*/
+
+/*!
+    \fn void QAction::activated(int i);
+
+    Use triggered() instead.
+*/
+
+
+/*!
+    \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