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

**

** Copyright (C) 2010 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 <QtCore/qhash.h>

#include <QtGui/qpushbutton.h>

#include <QtGui/qstyle.h>

#include <QtGui/qlayout.h>

#include <QtGui/qdialog.h>

#include <QtGui/qapplication.h>

#include <QtGui/private/qwidget_p.h>

#include <QtGui/qaction.h>

#include "qdialogbuttonbox.h"

#ifdef QT_SOFTKEYS_ENABLED

#include <QtGui/qaction.h>

#endif

QT_BEGIN_NAMESPACE

/*!

    \class QDialogButtonBox

    \since 4.2

    \brief The QDialogButtonBox class is a widget that presents buttons in a

    layout that is appropriate to the current widget style.

    \ingroup dialog-classes

    Dialogs and message boxes typically present buttons in a layout that

    conforms to the interface guidelines for that platform. Invariably,

    different platforms have different layouts for their dialogs.

    QDialogButtonBox allows a developer to add buttons to it and will

    automatically use the appropriate layout for the user's desktop

    environment.

    Most buttons for a dialog follow certain roles. Such roles include:

    \list

    \o Accepting or rejecting the dialog.

    \o Asking for help.

    \o Performing actions on the dialog itself (such as resetting fields or

       applying changes).

    \endlist

    There can also be alternate ways of dismissing the dialog which may cause

    destructive results.

    Most dialogs have buttons that can almost be considered standard (e.g.

    \gui OK and \gui Cancel buttons). It is sometimes convenient to create these

    buttons in a standard way.

    There are a couple ways of using QDialogButtonBox. One ways is to create

    the buttons (or button texts) yourself and add them to the button box,

    specifying their role.

    \snippet examples/dialogs/extension/finddialog.cpp 1

    Alternatively, QDialogButtonBox provides several standard buttons (e.g. OK, Cancel, Save)

    that you can use. They exist as flags so you can OR them together in the constructor.

    \snippet examples/dialogs/tabdialog/tabdialog.cpp 2

    You can mix and match normal buttons and standard buttons.

    Currently the buttons are laid out in the following way if the button box is horizontal:

    \table

    \row \o \inlineimage buttonbox-gnomelayout-horizontal.png GnomeLayout Horizontal

         \o Button box laid out in horizontal GnomeLayout

    \row \o \inlineimage buttonbox-kdelayout-horizontal.png KdeLayout Horizontal

         \o Button box laid out in horizontal KdeLayout

    \row \o \inlineimage buttonbox-maclayout-horizontal.png MacLayout Horizontal

         \o Button box laid out in horizontal MacLayout

    \row \o \inlineimage buttonbox-winlayout-horizontal.png  WinLayout Horizontal

         \o Button box laid out in horizontal WinLayout

    \endtable

    The buttons are laid out the following way if the button box is vertical:

    \table

    \row \o GnomeLayout

         \o KdeLayout

         \o MacLayout

         \o WinLayout

    \row \o \inlineimage buttonbox-gnomelayout-vertical.png GnomeLayout Vertical

         \o \inlineimage buttonbox-kdelayout-vertical.png KdeLayout Vertical

         \o \inlineimage buttonbox-maclayout-vertical.png MacLayout Vertical

         \o \inlineimage buttonbox-winlayout-vertical.png WinLayout Vertical

    \endtable

    Additionally, button boxes that contain only buttons with ActionRole or

    HelpRole can be considered modeless and have an alternate look on Mac OS X:

    \table

    \row \o modeless horizontal MacLayout

         \o \inlineimage buttonbox-mac-modeless-horizontal.png Screenshot of modeless horizontal MacLayout

    \endtable

    When a button is clicked in the button box, the clicked() signal is emitted

    for the actual button is that is pressed. For convenience, if the button

    has an AcceptRole, RejectRole, or HelpRole, the accepted(), rejected(), or

    helpRequested() signals are emitted respectively.

    If you want a specific button to be default you need to call

    QPushButton::setDefault() on it yourself. However, if there is no default

    button set and to preserve which button is the default button across

    platforms when using the QPushButton::autoDefault property, the first push

    button with the accept role is made the default button when the

    QDialogButtonBox is shown,

    \sa QMessageBox, QPushButton, QDialog

*/

enum {

    AcceptRole      = QDialogButtonBox::AcceptRole,

    RejectRole      = QDialogButtonBox::RejectRole,

    DestructiveRole = QDialogButtonBox::DestructiveRole,

    ActionRole      = QDialogButtonBox::ActionRole,

    HelpRole        = QDialogButtonBox::HelpRole,

    YesRole         = QDialogButtonBox::YesRole,

    NoRole          = QDialogButtonBox::NoRole,

    ApplyRole       = QDialogButtonBox::ApplyRole,

    ResetRole       = QDialogButtonBox::ResetRole,

    AlternateRole   = 0x10000000,

    Stretch         = 0x20000000,

    EOL             = 0x40000000,

    Reverse         = 0x80000000

};

static QDialogButtonBox::ButtonRole roleFor(QDialogButtonBox::StandardButton button)

{

    switch (button) {

    case QDialogButtonBox::Ok:

    case QDialogButtonBox::Save:

    case QDialogButtonBox::Open:

    case QDialogButtonBox::SaveAll:

    case QDialogButtonBox::Retry:

    case QDialogButtonBox::Ignore:

        return QDialogButtonBox::AcceptRole;

    case QDialogButtonBox::Cancel:

    case QDialogButtonBox::Close:

    case QDialogButtonBox::Abort:

        return QDialogButtonBox::RejectRole;

    case QDialogButtonBox::Discard:

        return QDialogButtonBox::DestructiveRole;

    case QDialogButtonBox::Help:

        return QDialogButtonBox::HelpRole;

    case QDialogButtonBox::Apply:

        return QDialogButtonBox::ApplyRole;

    case QDialogButtonBox::Yes:

    case QDialogButtonBox::YesToAll:

        return QDialogButtonBox::YesRole;

    case QDialogButtonBox::No:

    case QDialogButtonBox::NoToAll:

        return QDialogButtonBox::NoRole;

    case QDialogButtonBox::RestoreDefaults:

    case QDialogButtonBox::Reset:

        return QDialogButtonBox::ResetRole;

    case QDialogButtonBox::NoButton:    // NoButton means zero buttons, not "No" button

        ;

    }

    return QDialogButtonBox::InvalidRole;

}

static const int layouts[2][5][14] =

{

    // Qt::Horizontal

    {

        // WinLayout

        { ResetRole, Stretch, YesRole, AcceptRole, AlternateRole, DestructiveRole, NoRole, ActionRole, RejectRole, ApplyRole,

           HelpRole, EOL, EOL, EOL },

        // MacLayout

        { HelpRole, ResetRole, ApplyRole, ActionRole, Stretch, DestructiveRole | Reverse,

          AlternateRole | Reverse, RejectRole | Reverse, AcceptRole | Reverse, NoRole | Reverse, YesRole | Reverse, EOL, EOL },

        // KdeLayout

        { HelpRole, ResetRole, Stretch, YesRole, NoRole, ActionRole, AcceptRole, AlternateRole,

          ApplyRole, DestructiveRole, RejectRole, EOL },

        // GnomeLayout

        { HelpRole, ResetRole, Stretch, ActionRole, ApplyRole | Reverse, DestructiveRole | Reverse,

          AlternateRole | Reverse, RejectRole | Reverse, AcceptRole | Reverse, NoRole | Reverse, YesRole | Reverse, EOL },

        // Mac modeless

        { ResetRole, ApplyRole, ActionRole, Stretch, HelpRole, EOL, EOL, EOL, EOL, EOL, EOL, EOL, EOL, EOL }

    },

    // Qt::Vertical

    {

        // WinLayout

        { ActionRole, YesRole, AcceptRole, AlternateRole, DestructiveRole, NoRole, RejectRole, ApplyRole, ResetRole,

          HelpRole, Stretch, EOL, EOL, EOL },

        // MacLayout

        { YesRole, NoRole, AcceptRole, RejectRole, AlternateRole, DestructiveRole, Stretch, ActionRole, ApplyRole,

          ResetRole, HelpRole, EOL, EOL },

        // KdeLayout

        { AcceptRole, AlternateRole, ApplyRole, ActionRole, YesRole, NoRole, Stretch, ResetRole,

          DestructiveRole, RejectRole, HelpRole, EOL },

        // GnomeLayout

        { YesRole, NoRole, AcceptRole, RejectRole, AlternateRole, DestructiveRole, ApplyRole, ActionRole, Stretch,

          ResetRole, HelpRole, EOL, EOL, EOL },

        // Mac modeless

        { ActionRole, ApplyRole, ResetRole, Stretch, HelpRole, EOL, EOL, EOL, EOL, EOL, EOL, EOL, EOL, EOL }

    }

};

#if defined(QT_SOFTKEYS_ENABLED) && !defined(QT_NO_ACTION)

class QDialogButtonEnabledProxy : public QObject

{

public:

    QDialogButtonEnabledProxy(QObject *parent, QWidget *src, QAction *trg) : QObject(parent), source(src), target(trg)

    {

        source->installEventFilter(this);

        target->setEnabled(source->isEnabled());

    }

    ~QDialogButtonEnabledProxy()

    {

        source->removeEventFilter(this);

    }

    bool eventFilter(QObject *object, QEvent *event)

    {

        if (object == source && event->type() == QEvent::EnabledChange) {

            target->setEnabled(source->isEnabled());

        }

        return false;

    };

private:

    QWidget *source;

    QAction *target;

};

#endif

class QDialogButtonBoxPrivate : public QWidgetPrivate

{

    Q_DECLARE_PUBLIC(QDialogButtonBox)

public:

    QDialogButtonBoxPrivate(Qt::Orientation orient);

    QList<QAbstractButton *> buttonLists[QDialogButtonBox::NRoles];

    QHash<QPushButton *, QDialogButtonBox::StandardButton> standardButtonHash;

#ifdef QT_SOFTKEYS_ENABLED

    QHash<QAbstractButton *, QAction *> softKeyActions;

#endif

    Qt::Orientation orientation;

    QDialogButtonBox::ButtonLayout layoutPolicy;

    QBoxLayout *buttonLayout;

    bool internalRemove;

    bool center;

    void createStandardButtons(QDialogButtonBox::StandardButtons buttons);

    void layoutButtons();

    void initLayout();

    void resetLayout();

    QPushButton *createButton(QDialogButtonBox::StandardButton button, bool doLayout = true);

    void addButton(QAbstractButton *button, QDialogButtonBox::ButtonRole role, bool doLayout = true);

    void _q_handleButtonDestroyed();

    void _q_handleButtonClicked();

    void addButtonsToLayout(const QList<QAbstractButton *> &buttonList, bool reverse);

    void retranslateStrings();

    const char *standardButtonText(QDialogButtonBox::StandardButton sbutton) const;

#if defined(QT_SOFTKEYS_ENABLED) && !defined(QT_NO_ACTION)

    QAction *createSoftKey(QAbstractButton *button, QDialogButtonBox::ButtonRole role);

#endif

};

QDialogButtonBoxPrivate::QDialogButtonBoxPrivate(Qt::Orientation orient)

    : orientation(orient), buttonLayout(0), internalRemove(false), center(false)

{

}

void QDialogButtonBoxPrivate::initLayout()

{

    Q_Q(QDialogButtonBox);

    layoutPolicy = QDialogButtonBox::ButtonLayout(q->style()->styleHint(QStyle::SH_DialogButtonLayout, 0, q));

    bool createNewLayout = buttonLayout == 0

        || (orientation == Qt::Horizontal && qobject_cast<QVBoxLayout *>(buttonLayout) != 0)

        || (orientation == Qt::Vertical && qobject_cast<QHBoxLayout *>(buttonLayout) != 0);

    if (createNewLayout) {

        delete buttonLayout;

        if (orientation == Qt::Horizontal)

            buttonLayout = new QHBoxLayout(q);

        else

            buttonLayout = new QVBoxLayout(q);

    }

    int left, top, right, bottom;

    setLayoutItemMargins(QStyle::SE_PushButtonLayoutItem);

    getLayoutItemMargins(&left, &top, &right, &bottom);

    buttonLayout->setContentsMargins(-left, -top, -right, -bottom);

    if (!q->testAttribute(Qt::WA_WState_OwnSizePolicy)) {

        QSizePolicy sp(QSizePolicy::Expanding, QSizePolicy::Fixed, QSizePolicy::ButtonBox);

        if (orientation == Qt::Vertical)

            sp.transpose();

        q->setSizePolicy(sp);

        q->setAttribute(Qt::WA_WState_OwnSizePolicy, false);

    }

    // ### move to a real init() function

    q->setFocusPolicy(Qt::TabFocus);

}

void QDialogButtonBoxPrivate::resetLayout()

{

    //delete buttonLayout;

    initLayout();

    layoutButtons();

}

void QDialogButtonBoxPrivate::addButtonsToLayout(const QList<QAbstractButton *> &buttonList,

                                                 bool reverse)

{

    int start = reverse ? buttonList.count() - 1 : 0;

    int end = reverse ? -1 : buttonList.count();

    int step = reverse ? -1 : 1;

    for (int i = start; i != end; i += step) {

        QAbstractButton *button = buttonList.at(i);

        buttonLayout->addWidget(button);

        button->show();

    }

}

void QDialogButtonBoxPrivate::layoutButtons()

{

    Q_Q(QDialogButtonBox);

    const int MacGap = 36 - 8;    // 8 is the default gap between a widget and a spacer item

    for (int i = buttonLayout->count() - 1; i >= 0; --i) {

        QLayoutItem *item = buttonLayout->takeAt(i);

        if (QWidget *widget = item->widget())

            widget->hide();

        delete item;

    }

    int tmpPolicy = layoutPolicy;

    static const int M = 5;

    static const int ModalRoles[M] = { AcceptRole, RejectRole, DestructiveRole, YesRole, NoRole };

    if (tmpPolicy == QDialogButtonBox::MacLayout) {

        bool hasModalButton = false;

        for (int i = 0; i < M; ++i) {

            if (!buttonLists[ModalRoles[i]].isEmpty()) {

                hasModalButton = true;

                break;

            }

        }

        if (!hasModalButton)

            tmpPolicy = 4;  // Mac modeless

    }

    const int *currentLayout = layouts[orientation == Qt::Vertical][tmpPolicy];

    if (center)

        buttonLayout->addStretch();

    QList<QAbstractButton *> acceptRoleList = buttonLists[AcceptRole];

    while (*currentLayout != EOL) {

        int role = (*currentLayout & ~Reverse);

        bool reverse = (*currentLayout & Reverse);

        switch (role) {

        case Stretch:

            if (!center)

                buttonLayout->addStretch();

            break;

        case AcceptRole: {

            if (acceptRoleList.isEmpty())

                break;

            // Only the first one

            QAbstractButton *button = acceptRoleList.first();

            buttonLayout->addWidget(button);

            button->show();

        }

            break;

        case AlternateRole:

            {

                if (acceptRoleList.size() < 2)

                    break;

                QList<QAbstractButton *> list = acceptRoleList;

                list.removeFirst();

                addButtonsToLayout(list, reverse);

            }

            break;

        case DestructiveRole:

            {

                const QList<QAbstractButton *> &list = buttonLists[role];

                /*

                    Mac: Insert a gap on the left of the destructive

                    buttons to ensure that they don't get too close to

                    the help and action buttons (but only if there are

                    some buttons to the left of the destructive buttons

                    (and the stretch, whence buttonLayout->count() > 1

                    and not 0)).

                */

                if (tmpPolicy == QDialogButtonBox::MacLayout

                        && !list.isEmpty() && buttonLayout->count() > 1)

                    buttonLayout->addSpacing(MacGap);

                addButtonsToLayout(list, reverse);

                /*

                    Insert a gap between the destructive buttons and the

                    accept and reject buttons.

                */

                if (tmpPolicy == QDialogButtonBox::MacLayout && !list.isEmpty())

                    buttonLayout->addSpacing(MacGap);

            }

            break;

        case RejectRole:

        case ActionRole:

        case HelpRole:

        case YesRole:

        case NoRole:

        case ApplyRole:

        case ResetRole:

            addButtonsToLayout(buttonLists[role], reverse);

        }

        ++currentLayout;

    }

    QWidget *lastWidget = 0;

    q->setFocusProxy(0);

    for (int i = 0; i < buttonLayout->count(); ++i) {

        QLayoutItem *item = buttonLayout->itemAt(i);

        if (QWidget *widget = item->widget()) {

            if (lastWidget)

                QWidget::setTabOrder(lastWidget, widget);

            else

                q->setFocusProxy(widget);

            lastWidget = widget;

        }

    }

    if (center)

        buttonLayout->addStretch();

}

QPushButton *QDialogButtonBoxPrivate::createButton(QDialogButtonBox::StandardButton sbutton,

                                                   bool doLayout)

{

    Q_Q(QDialogButtonBox);

    const char *buttonText = 0;

    int icon = 0;

    switch (sbutton) {

    case QDialogButtonBox::Ok:

        icon = QStyle::SP_DialogOkButton;

        break;

    case QDialogButtonBox::Save:

        icon = QStyle::SP_DialogSaveButton;

        break;

    case QDialogButtonBox::Open:

        icon = QStyle::SP_DialogOpenButton;

        break;

    case QDialogButtonBox::Cancel:

        icon = QStyle::SP_DialogCancelButton;

        break;

    case QDialogButtonBox::Close:

        icon = QStyle::SP_DialogCloseButton;

        break;

    case QDialogButtonBox::Apply:

        icon = QStyle::SP_DialogApplyButton;

        break;

    case QDialogButtonBox::Reset: