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

**

** 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 "hbdeviceprogressdialog.h"

#include "hbdeviceprogressdialog_p.h"

#include <QTimer>

#include <QAction>

HbDeviceProgressDialogPrivate::HbDeviceProgressDialogPrivate() : QObject(),

    mVisible(false),

    mUpdateTimerId(0)

{

    TRACE_ENTRY

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

        mDefaultActions[i] = 0;

    }

    TRACE_EXIT

}

HbDeviceProgressDialogPrivate::~HbDeviceProgressDialogPrivate()

{

    TRACE_ENTRY

    cancel();

    killTimer(mUpdateTimerId);

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

        delete mDefaultActions[i];

    }

    TRACE_EXIT

}

void HbDeviceProgressDialogPrivate::initProperties(HbProgressDialog::ProgressDialogType type)

{

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

        mProperties[i].mFlags = NoFlags;

    }

    clearActions();

    if (!mDefaultActions[CancelButton]) {

        mDefaultActions[CancelButton] = new QAction(0);

    }

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

    QString text;

    mProperties[ProgressType].mValue.setValue(static_cast<int>(type));

    mProperties[ProgressType].mFlags = Modified;

    if (type == HbProgressDialog::WaitDialog){

        q->setRange(0,0);

        q->setAutoClose(false);

    } else {

        q->setRange(0,100);

        q->setAutoClose(true);

    }

    q->setProgressValue(0);

    q->setText(text);

    q->setIconName(text);

    q->setAnimationDefinition(text);

}

// Send properties to server

void HbDeviceProgressDialogPrivate::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;

    }

    static const char * const propertyNames[] = {

        "progressDialogType",

        "maximum",

        "minimum",

        "value",

        "autoClose",

        "text",

        "iconName",

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

        "cancelAction"

    };

    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.deviceprogressdialog/1.0", parameters)) {

            mVisible = true;

        } else {

            // Failed to show the device dialog. Start a one shot to emit aboutToClose() signal.

            QTimer::singleShot(0, this, SLOT(aboutToClose()));

        }

    } else {

        mDeviceDialog.update(parameters);

    }

}

// Check if any properties have been modified

bool HbDeviceProgressDialogPrivate::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 HbDeviceProgressDialogPrivate::clearActions()

{

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

        mActions[i].mAction = 0;

        mActions[i].mFlags = NoFlags;

        mActions[i].mTriggered = false;

    }

}

// Set int property

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

{

    Property &property = mProperties[propertySelector];

    property.mValue.setValue(value);

    property.mFlags = Modified;

    scheduleUpdateEvent();

}

// Set string property

void HbDeviceProgressDialogPrivate::setProperty(PropertySelector propertySelector,

    const QString &value)

{

    Property &property = mProperties[propertySelector];

    property.mValue.setValue(value);

    property.mFlags = Modified;

    scheduleUpdateEvent();

}

void HbDeviceProgressDialogPrivate::init(HbProgressDialog::ProgressDialogType type)

{

    TRACE_ENTRY

    initProperties(type);

    connect(&mDeviceDialog, SIGNAL(deviceDialogClosed()), this, SLOT(aboutToClose()));

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

    TRACE_EXIT

}

void HbDeviceProgressDialogPrivate::cancel()

{

    TRACE_ENTRY

    mDeviceDialog.cancel();

    TRACE_EXIT

    return;

}

// 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 HbDeviceProgressDialogPrivate::scheduleUpdateEvent()

{

    if (mVisible && mUpdateTimerId == 0) {

        mUpdateTimerId = startTimer(0);

    }

}

void HbDeviceProgressDialogPrivate::timerEvent(QTimerEvent *event)

{

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

        sendToServer(false);

    }

}

HbDeviceProgressDialogPrivate::ActionSelector HbDeviceProgressDialogPrivate::actionSelector(

    HbDeviceProgressDialog::ActionRole role)

{

    static const ActionSelector selectors[] = {

        CancelButton

    };

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

    unsigned index = role;

    if (index >= numSelectors) {

        Q_ASSERT(false);

        return InvalidSelector;

    }

    else {

        return selectors[index];

    }

}

void HbDeviceProgressDialogPrivate::aboutToClose()

{

    TRACE_ENTRY

    mVisible = false;

    emit q->aboutToClose();

    TRACE_EXIT

    return;

}

void HbDeviceProgressDialogPrivate::dataReceived(QVariantMap data)

{

    const char *key = "act";

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

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

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

            // Client has pressed button. Signal action if one is set. Otherwise emit

            // cancelled() signal.

            mActions[CancelButton].mTriggered = true;

            QAction *action = mActions[CancelButton].mAction;

            if (action) {

                action->trigger();

                emit q->cancelled();

            }

        }

    }

}

/*!

    \stable

    \hbwidgets

    \class HbDeviceProgressDialog

    \brief HbDeviceProgressDialog displays a progress dialog on top all applications.

    HbDeviceProgressDialog is a device-dialog version of HbProgressDialog. It is a modal

    dialog and displayed on top all applications by a device-dialog service.

    HbDeviceProgressDialog is a client of the service.

    HbDeviceProgressDialog provides a similar kind of interface as HbProgressDialog.

    Progress dialogs are always shown asynchronously as application needs to perform an operation

    and update the dialog while the dialog is showing.

    For content it provides wait animation or progress bar, text, icon or icon-animation and a

    cancel button.

    Two different dialogs are supported: wait and progress. Progress dialog displays a progress

    bar indicating progress of the operation. Wait dialog displays a wait animation in place of

    the progress bar.

    Wait dialog is used when length of an operation cannot be determined beforehand.

    The dialog is closed by user pressing dialog cancel button or by an application closing

    the dialog after the operation has finished by HbDeviceProgressDialog::close().

    Progress dialog is used when the length of operation can be determined. beforehand.

    For example when deleting a number of files, the progress could be shown as a

    percentage of the files deleted. Application updates the progress bar during the

    operation. The dialog closes by user pressing the cancel button, the application closing the

    dialog after the operation is finished or automatically when progress value reaches a

    maximum, HbDeviceProgressDialog::autoClose().

    Device progress dialog is launched when show() is called. Launched dialog can be updated by

    setters. Changed properties are updated to the displayed dialog automatically next time event

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

    Because updating a dialog requires interprocess communication, it's advisable to fully construct the

    progress dialog before calling show().

    An animation can replace an icon on device progress dialog. Supported icon animation formats are

    following:

    - GIF (.gif)

    - MNG (.mng)

        - Frame animations

    \section _platform_spec Platform-specific implementation notes for HbDeviceProgressDialog

    \subsection _nonsymbian Non-Symbian

    Device dialog service is implemented only for the Symbian platform. On other platforms device 

    progress dialogs are displayed on client's main window.

    \section _code_samples Sample code

    An example showing a wait dialog:

    \code

    mDialog = new HbDeviceProgressDialog(HbProgressDialog::WaitDialog);

    mDialog->setText("Connecting...");

    mDialog->show();

    \endcode

    An example showing a progress dialog:

    \include tsrc/fute/ultimatecodesnippet/deviceprogressdialog.cpp

    Showing an icon 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

*/

/*!

    \fn void HbDeviceProgressDialog::aboutToClose();

    This signal is emitted when a device progress dialog has closed. The closing may

    be a result of close() being called, a dialog with autoClose property has reached

    its maximum value or user pressing cancel button. It is not emitted if close() is

    called before show().

 */

/*!

    \fn void HbDeviceProgressDialog::cancelled();

    This signal is emitted when the device progress dialog is closed by user pressing the

    "cancel" button. It is not emitted if dialog is closed for any other reason.

 */

/*!

    \enum HbDeviceProgressDialog::ActionRole

    Defines roles for actions set into a progress dialog.

*/

/*!

    \var HbDeviceProgressDialog::ActionRole HbDeviceProgressDialog::InvalidRole

    No action.

*/

/*!

    \var HbDeviceProgressDialog::ActionRole HbDeviceProgressDialog::CancelButtonRole

    Cancel button action.

*/

/*!

    \param type Must be one of the defined HbProgressDialog::ProgressDialogType enumerations.

*/

HbDeviceProgressDialog::HbDeviceProgressDialog(HbProgressDialog::ProgressDialogType type, QObject *parent) :

    QObject(parent), d(new HbDeviceProgressDialogPrivate)

{

    TRACE_ENTRY

    d->q = this;

    d->init(type);

    TRACE_EXIT

}

/*!

*/

HbDeviceProgressDialog::HbDeviceProgressDialog(QObject *parent) :

    QObject(parent), d(new HbDeviceProgressDialogPrivate)

{

    TRACE_ENTRY

    d->q = this;

    d->init(HbProgressDialog::ProgressDialog);

    TRACE_EXIT

}

/*!

*/

HbDeviceProgressDialog::~HbDeviceProgressDialog()

{

    TRACE_ENTRY

    delete d;

    TRACE_EXIT

}

/*!

    Shows a dialog and returns immediately without waiting for it to close. Closing

    is indicated by aboutToClose() signal. User cancellation is indicated by cancelled()

    signal. Button press is also indicated by QAction::triggered() signal.

    The dialog can be updated while showing by property setters. A new dialog is launched

    each time show() is called.

    \sa update(), aboutToClose(), cancelled()

*/

void HbDeviceProgressDialog::show()

{

    TRACE_ENTRY

    d->sendToServer(true);

    TRACE_EXIT

 }

/*!

    Updates changed properties of a launched progress dialog to device dialog service using

    interprocess communication. Has no effect if show() has not been called or dialog has

    closed already. Calling update() is optional as updating any property schedules an event

    and the dialog is updated next time Qt event loop executes.

    \sa show()

*/

void HbDeviceProgressDialog::update()

{

    TRACE_ENTRY

    d->sendToServer(false);

    TRACE_EXIT

}

/*!

    Closes the dialog.

*/

void HbDeviceProgressDialog::close()

{

    TRACE_ENTRY

    return d->cancel();

    TRACE_EXIT

}

/*!

    Returns an action user triggered causing the dialog to close. Returns 0 if none of the actions were

    triggered and dialog was closed for other reason.

    \sa show(), action()

*/

const QAction *HbDeviceProgressDialog::triggeredAction() const

{

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

        if (d->mActions[i].mTriggered) {

            return d->mActions[i].mAction;

        }

    }

    return 0;

}

/*!

    Sets progress bar maximum value.

    \sa maximum()

*/

void HbDeviceProgressDialog::setMaximum(int max)

{

    TRACE_ENTRY

    // Don't allow wait dialog to set max/min other than zero as wait

    // animation bar doesn't work in that case.

    if (progressType() == HbProgressDialog::WaitDialog) {

        max = 0;

    }

    d->setProperty(HbDeviceProgressDialogPrivate::Maximum, max);

    TRACE_EXIT

}

/*!

    Returns progress bar maximum value. Default value is 100.

    \sa setMaximum()

*/

int HbDeviceProgressDialog::maximum() const

{

    return d->mProperties[HbDeviceProgressDialogPrivate::Maximum].mValue.toInt();

}