/****************************************************************************

**

** 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