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

**

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

    }

    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::initProperties()

{

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

        mProperties[i].mFlags = NoFlags;

    }

    clearActions();

    QString text;

    q_ptr->setText(text);

    q_ptr->setIconName(text);

    q_ptr->setIconAlignment(Qt::AlignCenter);

    q_ptr->setIconVisible(true);

    q_ptr->setAnimationDefinition(text);

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

    case HbMessageBox::MessageTypeInformation:

    case HbMessageBox::MessageTypeWarning:

        q_ptr->setDismissPolicy(HbPopup::TapAnywhere);

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

        // Use default primary button, secondary button is empty

        if (!mDefaultActions[AcceptButton]) {

            mDefaultActions[AcceptButton] = new HbAction(0);

        }

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

        break;

    case HbMessageBox::MessageTypeQuestion:

        q_ptr->setTimeout(HbPopup::NoTimeout);

        q_ptr->setDismissPolicy(HbPopup::NoDismiss);

        // Use default primary and secondary buttons

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

            if (!mDefaultActions[i]) {

                mDefaultActions[i] = new HbAction(0);

            }

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

        }

        break;

    default:

        Q_ASSERT(false);

    }

}

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

{

    TRACE_ENTRY

    Action &dialogAction = mActions[select];

    dialogAction.mFlags = Modified;

    dialogAction.mAction = action;

    TRACE_EXIT

}

// 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",

        "text",

        "iconName",

        "iconAlignment",

        "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[] = {

        "primaryActionText",

        "secondaryActionText"

    };

    static const char * const nullActionNames[] = {

        "primaryActionNull",

        "secondaryActionNull"

    };

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

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

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

                if (mActions[i].mAction) {

                    parameters.insert(actionNames[i], mActions[i].mAction->text());

                } else {

                    parameters.insert(nullActionNames[i], true);

                }

                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 actions

void HbDeviceMessageBoxPrivate::clearActions()

{

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

        mActions[i].mAction = 0;

        mActions[i].mFlags = NoFlags;

        mActions[i].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::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;

}

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];

    }

}

// Temporary until HbAction is deprecated out from device message box API

// Tbd. remove when deprecation period ends

HbAction *HbDeviceMessageBoxPrivate::toHbAction(QAction *action)

{

    // Upcast to HbAction

    HbAction *hbAction = qobject_cast<HbAction*>(action);

    // Warn if user has mixed HbAction and QAction APis

    if (action != hbAction) {

        //qWarning("HbDeviceMessageBox: HbAction API:s deprecated! Returning QAction instead of HbAction");

        // Best option is to return QAction and hope caller doesn't use HbAction parts

        hbAction = reinterpret_cast<HbAction*>(action);

    }

    return hbAction;

}

/*!

    \class HbDeviceMessageBox

    \brief HbDeviceMessageBox is a device dialog version of HbMessageBox.

    It displays a message box with text, icon or animation and optional reply button(s).

    Device dialogs are shown on top of any running applications and are always modal by nature.

    HbDeviceMessageBox provides a similar kind of interface as HbMessageBox,

    excluding functions which handle concrete UI-component related information.

    A device message box is launched when exec() for synchronous dialog or show() for asynchronous

    dialog is called. Launched dialog can be updated by setters. Because updating a dialog

    requires interprocess communication, it's advisable to fully construct the device message box before

    calling show(). Device message box is closed when user dismisses it with pressing a button, when

    client calls close() or the dialog reaches timeout. If the system must close the device message

    box while it is executing, it will have the same effect than having message box's secondary action

    activated.

    Static convenience functions are provided for launching message boxes.

    Dialogs created by them contain a default property values 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.

    Supported icon animation formats are following:

    - GIF (.gif)

    - MNG (.mng)

        - Frame animations

    Sample code:

    \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

    Alter the appearance of the 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);

    Qt::Alignment align(Qt::AlignLeft|Qt::AlignTop);

    messageBox.setIconAlignment(align);

    QAction acceptAction("Ok", 0);

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

    QAction rejectAction("Cancel", 0);

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

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

    Creating a frame animation.

    Create an animation definition file:

    \code

    <animations>

        <icon name="frame_anim_looping" playmode="loop">

            <frame duration="100">c:\icon1.svg</frame>

            <frame duration="200">c:\icon2.svg</frame>

            <frame duration="300">c:\icon3.svg</frame>

            </icon>

    </animations>

    \endcode

    Create HbDeviceMessageBox in a way described before and

    set definition file and animation's logical name.

    \code

    QString animationDefinitionXML("c:\animation.axml");

    QString logicalIconName("frame_anim_looping");

    msg->setAnimationDefinition(animationDefinitionXML);

    msg->setIconName(logicalIconName);

    msg->show();

    \endcode

    \sa HbMessageBox, HbDialog, HbDeviceDialog

    @proto

    @hbwidgets

*/

/*!

    \fn void HbDeviceMessageBox::aboutToClose();

    This signal is emitted when the device message box is about to be closed i.e.

    when the question type of message is replied to by the user.

 */

/*!

    \enum HbDeviceMessageBox::ActionRole

    Defines roles for actions set into a message box.

*/

/*!

    \var HbDeviceMessageBox::ActionRole HbDeviceMessageBox::InvalidRole

    No action.

*/

/*!

    \var HbDeviceMessageBox::ActionRole HbDeviceMessageBox::AcceptButtonRole

    Accept button action.

*/

/*!

    \var HbDeviceMessageBox::ActionRole HbDeviceMessageBox::RejectButtonRole

    Reject button action.

*/

/*!

    Constructor.

    \param type Type of the message box.

    \param parent An optional parameter.

*/

HbDeviceMessageBox::HbDeviceMessageBox(HbMessageBox::MessageBoxType type, QObject *parent) :

    QObject(parent), d_ptr(new HbDeviceMessageBoxPrivate)

{

    TRACE_ENTRY

    d_ptr->q_ptr = this;

    d_ptr->mProperties[HbDeviceMessageBoxPrivate::Type].mValue.setValue(static_cast<int>(type));

    d_ptr->init();

    TRACE_EXIT

}

/*!

    Constructor.

    \param text Text can be set in the constructor.

    \param type Type of the message box.

    \param parent An optional parameter.

*/

HbDeviceMessageBox::HbDeviceMessageBox(const QString &text, HbMessageBox::MessageBoxType type,

    QObject *parent) : QObject(parent), d_ptr(new HbDeviceMessageBoxPrivate)

{

    TRACE_ENTRY

    d_ptr->q_ptr = this;

    d_ptr->mProperties[HbDeviceMessageBoxPrivate::Type].mValue.setValue(static_cast<int>(type));

    d_ptr->init();

    setText(text);

    TRACE_EXIT

}

/*!

    Destructs the class.

*/

HbDeviceMessageBox::~HbDeviceMessageBox()

{

    TRACE_ENTRY

    delete d_ptr;

    TRACE_EXIT

}

/*!

    Executes the dialog asynchronously.

*/

void HbDeviceMessageBox::show()