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

**

** Copyright (C) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (developer.feedback@nokia.com)

**

** This file is part of the HbWidgets module of the UI Extensions for Mobile.

**

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

**

** If you have questions regarding the use of this file, please contact

** Nokia at developer.feedback@nokia.com.

**

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

#include <hbdevicedialog.h>

#include <hbdevicedialogtrace_p.h>

#include "hbdevicemessagebox.h"

#include "hbdevicemessagebox_p.h"

#include <QTimer>

#include <QTimerEvent>

#include <QAction>

#include <QPointer>

HbDeviceMessageBoxPrivate::HbDeviceMessageBoxPrivate() : QObject(),

    mDeviceDialog(0),

    mVisible(false),

    mUpdateTimerId(0)

{

    TRACE_ENTRY

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

        mDefaultActions[i] = 0;

        mActions[i].mAction = 0;

    }

    TRACE_EXIT

}

HbDeviceMessageBoxPrivate::~HbDeviceMessageBoxPrivate()

{

    TRACE_ENTRY

    // information/warning dialogs may be left at server when client is deleted. If there are no connected

    // signals, device dialog widget is not deleted but runs at server and is closed by a timeout.

    if (mProperties[Type].mValue.toInt() != HbMessageBox::MessageTypeQuestion &&

        q_ptr->receivers(SIGNAL(aboutToClose())) <= 0) {

        mDeviceDialog->disconnect(q_ptr, SLOT(aboutToClose()));

        mDeviceDialog->disconnect(this, SLOT(triggerAction(QVariantMap)));

        if (mUpdateTimerId != 0) {

            // There's a pending update

            sendToServer(false); // this also kills the timer

        }

    }

    delete mDeviceDialog;

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

        delete mDefaultActions[i];

    }

    TRACE_EXIT

}

void HbDeviceMessageBoxPrivate::init()

{

    TRACE_ENTRY

    initProperties();

    mDeviceDialog = new HbDeviceDialog;

    connect(mDeviceDialog, SIGNAL(deviceDialogClosed()), q_ptr, SIGNAL(aboutToClose()));

    connect(mDeviceDialog, SIGNAL(dataReceived(QVariantMap)), this, SLOT(triggerAction(QVariantMap)));

    TRACE_EXIT

}

void HbDeviceMessageBoxPrivate::initAction(int index)

{

    if (!mActions[index].mAction) {

        if (!mDefaultActions[index]) {

            mDefaultActions[index] = new QAction(0);

        }

        mActions[index].mAction = mDefaultActions[index];

        connect(mActions[index].mAction, SIGNAL(changed()), SLOT(actionChanged()));

    }

}

void HbDeviceMessageBoxPrivate::initProperties()

{

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

        mProperties[i].mFlags = NoFlags;

    }

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

        clearAction(mActions[i]);

    }

    QString text;

    q_ptr->setText(text);

    q_ptr->setIconName(text);

    q_ptr->setIconVisible(true);

    q_ptr->setAnimationDefinition(text);

    bool useActions[NumActions];

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

        useActions[i] = false;

    }

    switch(mProperties[Type].mValue.toInt()) {

    case HbMessageBox::MessageTypeNone:

        q_ptr->setIconVisible(false);

        // Fall trough

    case HbMessageBox::MessageTypeInformation:

    case HbMessageBox::MessageTypeWarning:

        q_ptr->setDismissPolicy(HbPopup::TapAnywhere);

        q_ptr->setTimeout(timeoutValue(HbPopup::StandardTimeout));

        // HbMessageBox sets by default accept button to "Ok", reject button is empty

        mProperties[StandardButtons].mValue.setValue(static_cast<int>(HbMessageBox::Ok));

        useActions[AcceptButton] = true;

        break;

    case HbMessageBox::MessageTypeQuestion:

        q_ptr->setTimeout(HbPopup::NoTimeout);

        q_ptr->setDismissPolicy(HbPopup::NoDismiss);

        // HbMessageBox sets by default accept button to "Ok", reject button is empty.

        // Set default buttons to yes/no

        setProperty(StandardButtons, HbMessageBox::Yes|HbMessageBox::No);

        useActions[AcceptButton] = true;

        useActions[RejectButton] = true;

        break;

    default:

        Q_ASSERT(false);

    }

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

        if (useActions[i]) {

            initAction(i);

        }

    }

}

void HbDeviceMessageBoxPrivate::setAction(ActionSelector select, QAction *action)

{

    TRACE_ENTRY

    Action &dialogAction = mActions[select];

    bool saveTriggered = dialogAction.mTriggered;

    clearAction(dialogAction);

    dialogAction.mTriggered = saveTriggered;

    dialogAction.mFlags = Modified;

    dialogAction.mAction = action;

    if (dialogAction.mAction) {

        connect(dialogAction.mAction, SIGNAL(changed()), SLOT(actionChanged()));

    }

    TRACE_EXIT

}

void HbDeviceMessageBoxPrivate::setStandardButtons(HbMessageBox::StandardButtons buttons)

{

    // Create actions for buttons. These will be signaled on button press.

    int buttonCount = qMin(static_cast<int>(NumActions), countBits(buttons));

    int i = 0;

    for(; i < buttonCount; i++) {

        initAction(i);

    }

    // Clear extra actions

    for(; i < NumActions; i++) {

      clearAction(mActions[i]);

    }

    setProperty(StandardButtons, buttons);

}

// Send properties to server

void HbDeviceMessageBoxPrivate::sendToServer(bool show)

{

    killTimer(mUpdateTimerId);

    mUpdateTimerId = 0;

    // If this is update but show has not been called, return.

    if (!show && !mVisible) {

      return;

    }

    // If this is update but no properties have been mofified, return

    if (!show && !propertiesModified()) {

        return;

    }

    // If this is a show, send type property

    if (show) {

        mProperties[Type].mFlags = Modified;

    }

    static const char * const propertyNames[] = {

        "type",

        "standardButtons",

        "text",

        "iconName",

        "iconVisible",

        "timeout",

        "dismissPolicy",

        "animationDefinition"

    };

    QVariantMap parameters;

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

        if (mProperties[i].mFlags & Modified) {

            if (show || !(mProperties[i].mFlags & SentToServer)) {

                parameters.insert(propertyNames[i], mProperties[i].mValue);

                mProperties[i].mFlags |= SentToServer;

            }

        }

    }

    static const char * const actionNames[] = {

        "acceptAction",

        "rejectAction"

    };

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

        if (mActions[i].mFlags & Modified) {

            if (show || !(mActions[i].mFlags & SentToServer)) {

                QString actionData; // empty removes action at the plugin

                if (mActions[i].mAction) {

                    actionData.append("t:").append(mActions[i].mAction->text());

                }

                parameters.insert(actionNames[i], actionData);

                mActions[i].mFlags |= SentToServer;

            }

        }

    }

    if (show) {

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

            mActions[i].mTriggered = false;

        }

        if (mDeviceDialog->show("com.nokia.hb.devicemessagebox/1.0", parameters)) {

            mVisible = true;

        } else { // failed to show device dialog. Start a one shot to emit aboutToClose() signal.

            QTimer::singleShot(0, q_ptr, SIGNAL(aboutToClose()));

        }

    } else {

        mDeviceDialog->update(parameters);

    }

}

// Check if any properties have been modified

bool HbDeviceMessageBoxPrivate::propertiesModified() const

{

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

        if ((mProperties[i].mFlags & Modified) && !(mProperties[i].mFlags & SentToServer)) {

            return true;

        }

    }

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

        if ((mActions[i].mFlags & Modified) && !(mActions[i].mFlags & SentToServer)) {

            return true;

        }

    }

    return false;

}

// Clear action

void HbDeviceMessageBoxPrivate::clearAction(Action &action)

{

    if (action.mAction) {

        disconnect(action.mAction, SIGNAL(changed()), this, SLOT(actionChanged()));

    }

    action.mAction = 0;

    action.mFlags = NoFlags;

    action.mTriggered = false;

}

void HbDeviceMessageBoxPrivate::close()

{

    TRACE_ENTRY

    mDeviceDialog->cancel();

    mVisible = false;

    TRACE_EXIT

    return;

}

void HbDeviceMessageBoxPrivate::exec()

{

    TRACE_ENTRY

    sendToServer(true);

    mDeviceDialog->waitForClosed();

    TRACE_EXIT

}

void HbDeviceMessageBoxPrivate::triggerAction(QVariantMap data)

{

    TRACE_ENTRY

    const char *key = "act";

    QVariantMap::const_iterator i = data.find(key);

    if (i != data.constEnd()) {

        QAction *action;

        if (i.value().toString() == "p") {

            mActions[AcceptButton].mTriggered = true;

            action = mActions[AcceptButton].mAction;

        } else {

            mActions[RejectButton].mTriggered = true;

            action = mActions[RejectButton].mAction;

        }

        if (action) {

            action->trigger();

        }

    }

    TRACE_EXIT

}

void HbDeviceMessageBoxPrivate::actionChanged()

{

    QObject *action = sender();

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

        if (mActions[i].mAction == action) {

            mActions[i].mFlags = Modified;

            scheduleUpdateEvent();

            break;

        }

    }

}

void HbDeviceMessageBoxPrivate::setProperty(PropertySelector propertySelector, int value)

{

    Property &property = mProperties[propertySelector];

    property.mValue.setValue(value);

    property.mFlags = Modified;

    scheduleUpdateEvent();

}

void HbDeviceMessageBoxPrivate::setProperty(PropertySelector propertySelector,

    const QString &value)

{

    Property &property = mProperties[propertySelector];

    property.mValue.setValue(value);

    property.mFlags = Modified;

    scheduleUpdateEvent();

}

// Schedule event to update changed properties to device dialog server. update() is not

// called after each time a property is set. Instead an event is scheduled in order to

// update all changed properties in one shot.

void HbDeviceMessageBoxPrivate::scheduleUpdateEvent()

{

    if (mVisible && mUpdateTimerId == 0) {

        mUpdateTimerId = startTimer(0);

    }

}

void HbDeviceMessageBoxPrivate::timerEvent(QTimerEvent *event)

{

    if (event->timerId() == mUpdateTimerId) {

        sendToServer(false);

    }

}

int HbDeviceMessageBoxPrivate::timeoutValue(HbPopup::DefaultTimeout timeout)

{

    TRACE_STATIC_ENTRY

    static const struct { HbPopup::DefaultTimeout timeout; int value; } timeoutValues[] = {

        {HbPopup::NoTimeout,0},

        {HbPopup::ConfirmationNoteTimeout,1500},

        {HbPopup::StandardTimeout,3000},

        {HbPopup::ContextMenuTimeout,6000}

    };

    int count = sizeof(timeoutValues) / sizeof(timeoutValues[0]);

    if (timeout < 0 || timeout >= count) {

        TRACE_EXIT

        return timeoutValues[HbPopup::NoTimeout].value;

    }

    TRACE_EXIT

    return timeoutValues[timeout].value;

}

int HbDeviceMessageBoxPrivate::countBits(unsigned int value)

{

    int count = 0;

    while(value) {

        count += value & 1;

        value >>= 1;

    }

    return count;

}

HbDeviceMessageBoxPrivate::ActionSelector HbDeviceMessageBoxPrivate::actionSelector(

    HbDeviceMessageBox::ActionRole role)

{

    static const ActionSelector selectors[] = {

        AcceptButton, RejectButton

    };

    const unsigned numSelectors = sizeof(selectors) / sizeof(selectors[0]);

    unsigned index = role;

    if (index >= numSelectors) {

        Q_ASSERT(false);

        return InvalidSelector;

    }

    else {

        return selectors[index];

    }

}

/*!

    @stable

    @hbwidgets

    \class HbDeviceMessageBox

    A device message box is lauched by a show(). A new message box is lauched every time show()

    is called. aboutToClose() signal is emitted when the box has closed. There is also syncronous

    exec() function which launches a message box and waits for it close. exec() is not compatible

    with gestures and cannot be used from applications that have an user interface.

    After message box has been launched, updating it's properties causes interprocess

    communication. Therefore it's best to construct the message box fully before

    calling show(). Changing a property while a message box is displayed, causes the property

    to be updated to the displayed widget automatically next time event loop is entered

    or updated values can be sent immediately by calling update().

    Message box buttons are represented by two actions. Left button corrensponds to accept

    action and the right one to reject action. triggered() signal of action is emitted when

    corresponding button is pressed. Changing action text changes corresponding button text.

    Icons on buttons are not suppported.

    Device message box is closed when user dismisses it, when HbDeviceMessageBox::close() is

    called, timeout expires and message box closes itself or system closes the message box for

    some reason. aboutToClose() signal is always emitted after the box has closed.

    Static convenience functions are provided for launching message boxes. They launch message boxes

    containing default properties appropriate for the message box type and their contents cannot

    be updated. Information and warning convenience methods return immediately. Question waits for

    a message box to close and is not compatible with gestures.

    Four types of message boxes are predefined. The type determines a set of default properties that

    are set on construction. Below is a table listing types and their default properties.

    <table border="1">

        <caption><b>HbDeviceMessageBox types and default properties</b></caption>

        <tr><th>Type</th><th>Icon</th><th>Buttons</th><th>Timeout</th><th>Dismiss policy</th><th>Sound</th></tr>

        <tr><td>None</td><td>No icon</td><td>"Ok" button</td><td>Standard timeout</td><td>Tap anywhere</td><td>No sound</td></tr>

        <tr><td>Information</td><td>Info icon</td><td>"Ok" button</td><td>Standard timeout</td><td>Tap anywhere</td><td>Info sound</td></tr>

        <tr><td>Warning</td><td>Warning icon</td><td>"Ok" button</td><td>Standard timeout</td><td>Tap anywhere</td><td>Warn sound</td></tr>

        <tr><td>Question</td><td>Question icon</td><td>"Yes" and "No" buttons</td><td>No timeout</td><td>Button press</td><td>Question sound</td></tr>

    </table>

    - GIF (.gif)

    - MNG (.mng)

    - Frame animations (.axml)

    \code

    // Ask from user whether to continue operation or not.

    // Uses default accept/reject buttons (yes/no).

    bool value = HbDeviceMessageBox::question("Continue operation ?");

    if (value) {

        continueOperation();

    }

    \endcode

    Modify appearance of a message box with the methods provided by the class.

    \code

    // Code below modifies the default properties of the message box.

    HbDeviceMessageBox messageBox(HbMessageBox::MessageTypeQuestion);

    messageBox.setText("End game?");

    QString fileName("note_warning");

    messageBox.setIconName(fileName);

    // Change button text

    messageBox.action(HbDeviceMessageBox::AcceptButtonRole)->setText("Ok");

    messageBox.action(HbDeviceMessageBox::RejectButtonRole)->setText("Cancel");

    // Set new actions (buttons)

    QAction acceptAction("Ok", 0);

    messageBox.setAction(&acceptAction, HbDeviceMessageBox::AcceptButtonRole);

    QAction rejectAction("Cancel", 0);

    messageBox.setAction(&rejectAction, HbDeviceMessageBox::RejectButtonRole);

    // Set standard buttons

    messageBox.setStandardButtons(HbMessageBox::Ok|HbMessageBox::Cancel);

    // Beware, application may exit during exec().

    // Beware, exec() is not compatible with gestures.

    QAction *result = messageBox.exec();

    bool quit = messageBox.isAcceptAction(result);

    if (quit) {

        quit();

    }

    \endcode