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

**

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

#include <hbsymbianvariant.h>

#include <hbdeleteguardsymbian_p.h>

#include "hbdeviceprogressdialogsymbian.h"

_LIT(KDialogType, "progressDialogType");

_LIT(KDialogMaximum, "maximum");

_LIT(KDialogMinimum, "minimum");

_LIT(KDialogValue, "value");

_LIT(KDialogAutoClose, "autoClose");

_LIT(KDialogText, "text");

_LIT(KDialogIconName, "iconName");

_LIT(KCancelAction, "cancelAction");

_LIT(KPluginIdentifier, "com.nokia.hb.deviceprogressdialog/1.0");

_LIT(KAnimationDefinition, "animationDefinition");

NONSHARABLE_CLASS(CHbDeviceProgressDialogSymbianPrivate) : public CBase,

                                                           public MHbDeviceDialogObserver

{

public:

    CHbDeviceProgressDialogSymbianPrivate();

    virtual ~CHbDeviceProgressDialogSymbianPrivate();

    void ShowL();

    void UpdateL();

    void Close();

    bool Visible() const;

    void AddVariantL(const TDesC& aKey, const TAny* aData,

            CHbSymbianVariant::TType aDataType, CHbSymbianVariantMap* map);

    const CHbSymbianVariant* Variant(const TDesC& aKey) const;

    static HBufC *CreateActionDataLC(TBool aNull, const TDesC &text);

public: // MHbDeviceDialogObserver

    void DataReceived(CHbSymbianVariantMap& aData);

    void DeviceDialogClosed(TInt aCompletionCode);

public: // data

    void ConstructL(CHbDeviceProgressDialogSymbian* aDialog);

    MHbDeviceProgressDialogObserver* iObserver;

    CHbDeviceDialogSymbian *iDeviceDialog;

    CHbSymbianVariantMap* iVariantMap;

    CHbDeviceProgressDialogSymbian* q;

    TBool iVisible;

    TInt iMinimum;

    TInt iMaximum;

    TBool iAutoClose;

    TInt iType;

    TInt iProgressValue;

    RBuf iText;

    RBuf iIconName;

    RBuf iAnimationDefinition;

    struct {

        RBuf iText;

        struct {

            bool iTextValid:1; // property value has has been set

            bool iTextModified:1; // property has been modified

            bool iIsNull:1; // button is null

            bool iIsNullValid:1;

            bool iIsNullModified:1;

            bool iPressed:1; // true is button was pressed

        } iFlags;

    } iButton;

    bool *iDeleted;

};

CHbDeviceProgressDialogSymbianPrivate::CHbDeviceProgressDialogSymbianPrivate()

    {

    }

CHbDeviceProgressDialogSymbianPrivate::~CHbDeviceProgressDialogSymbianPrivate()

    {

    iText.Close();

    iIconName.Close();

    iAnimationDefinition.Close();

    iButton.iText.Close();

    delete iDeviceDialog;

    delete iVariantMap;

    // Set object deleted flag

    if (iDeleted)

        {

        // Mark the object as deleted.

        *iDeleted = true;

        iDeleted = 0;

        }

    }

void CHbDeviceProgressDialogSymbianPrivate::ConstructL(

    CHbDeviceProgressDialogSymbian* aDialog)

    {

    q = aDialog;

    iDeviceDialog = CHbDeviceDialogSymbian::NewL();

    iVariantMap = CHbSymbianVariantMap::NewL();

    iText.Create(KNullDesC);

    iIconName.Create(KNullDesC);

    iAnimationDefinition.Create(KNullDesC);

    iButton.iText.Create(KNullDesC);

    }

void CHbDeviceProgressDialogSymbianPrivate::ShowL()

    {

    AddVariantL(KDialogType, &iType, CHbSymbianVariant::EInt, iVariantMap);

    AddVariantL(KDialogMaximum, &iMaximum, CHbSymbianVariant::EInt, iVariantMap);

    AddVariantL(KDialogMinimum, &iMinimum, CHbSymbianVariant::EInt, iVariantMap);

    AddVariantL(KDialogAutoClose, &iAutoClose, CHbSymbianVariant::EBool, iVariantMap);

    AddVariantL(KDialogValue, &iProgressValue, CHbSymbianVariant::EInt, iVariantMap);

    if (iText.Length() > 0)

        {

        AddVariantL(KDialogText, &iText, CHbSymbianVariant::EDes, iVariantMap);

        }

    if (iIconName.Length() > 0)

        {

        AddVariantL(KDialogIconName, &iIconName, CHbSymbianVariant::EDes, iVariantMap);

        }

    if (iAnimationDefinition.Length() > 0)

        {

        AddVariantL(KAnimationDefinition, &iAnimationDefinition, CHbSymbianVariant::EDes, iVariantMap);

        }

    if (iButton.iFlags.iTextValid || iButton.iFlags.iIsNullValid)

        {

        iButton.iFlags.iTextModified = false;

        iButton.iFlags.iIsNullModified = false;

        HBufC *actionData = CreateActionDataLC(iButton.iFlags.iIsNull, iButton.iText);

        AddVariantL(KCancelAction, actionData, CHbSymbianVariant::EDes, iVariantMap);

        CleanupStack::PopAndDestroy(); // actionData

        }

    iButton.iFlags.iPressed = false;

    TInt error = iDeviceDialog->Show(KPluginIdentifier, *iVariantMap, this);

    if (error != KErrNone) {

        User::Leave(error); // error can be positive or negative

    }

    iVisible = ETrue;

    }

void CHbDeviceProgressDialogSymbianPrivate::Close()

    {

    iDeviceDialog->Cancel();

    }

void CHbDeviceProgressDialogSymbianPrivate::UpdateL()

    {

    CHbSymbianVariantMap* map = CHbSymbianVariantMap::NewL();

    const CHbSymbianVariant* variant = Variant(KDialogMaximum);

    if (variant && *variant->Value<TInt>() != iMaximum)

        {

        AddVariantL(KDialogMaximum, &iMaximum, CHbSymbianVariant::EInt, iVariantMap);

        AddVariantL(KDialogMaximum, &iMaximum, CHbSymbianVariant::EInt, map);

        }

    variant = Variant(KDialogMinimum);

    if (variant && *variant->Value<TInt>() != iMinimum)

        {

        AddVariantL(KDialogMinimum, &iMinimum, CHbSymbianVariant::EInt, iVariantMap);

        AddVariantL(KDialogMinimum, &iMinimum, CHbSymbianVariant::EInt, map);

        }

    variant = Variant(KDialogAutoClose);

    if (variant && *variant->Value<TBool>() != iAutoClose)

        {

        AddVariantL(KDialogAutoClose, &iAutoClose, CHbSymbianVariant::EInt, iVariantMap);

        AddVariantL(KDialogAutoClose, &iAutoClose, CHbSymbianVariant::EInt, map);

        }

    variant = Variant(KDialogType);

    if (variant && *variant->Value<TInt>() != iType)

        {

        AddVariantL(KDialogType, &iType, CHbSymbianVariant::EInt, iVariantMap);

        AddVariantL(KDialogType, &iType, CHbSymbianVariant::EInt, map);

        }

    variant = Variant(KDialogValue);

    if (variant && *variant->Value<TInt>() != iProgressValue)

        {

        AddVariantL(KDialogValue, &iProgressValue, CHbSymbianVariant::EInt, iVariantMap);

        AddVariantL(KDialogValue, &iProgressValue, CHbSymbianVariant::EInt, map);

        }

    variant = Variant(KDialogText);

    if (variant && iText == *variant->Value<TDesC>())

        {

        AddVariantL(KDialogText, &iText, CHbSymbianVariant::EDes, iVariantMap);

        AddVariantL(KDialogText, &iText, CHbSymbianVariant::EDes, map);

        }

    variant = Variant(KDialogIconName);

    if (variant && iIconName == *variant->Value<TDesC>())

        {

        AddVariantL(KDialogIconName, &iIconName, CHbSymbianVariant::EDes, iVariantMap);

        AddVariantL(KDialogIconName, &iIconName, CHbSymbianVariant::EDes, map);

        }

    variant = Variant(KAnimationDefinition);

    if (variant && iAnimationDefinition == *variant->Value<TDesC>())

        {

        AddVariantL(KAnimationDefinition, &iAnimationDefinition, CHbSymbianVariant::EDes, iVariantMap);

        AddVariantL(KAnimationDefinition, &iAnimationDefinition, CHbSymbianVariant::EDes, map);

        }

    if (iButton.iFlags.iTextModified || iButton.iFlags.iIsNullModified)

        {

        iButton.iFlags.iTextModified = false;

        iButton.iFlags.iIsNullModified = false;

        HBufC *actionData = CreateActionDataLC(iButton.iFlags.iIsNull, iButton.iText);

        AddVariantL(KCancelAction, actionData, CHbSymbianVariant::EDes, iVariantMap);

        CleanupStack::PopAndDestroy(); // actionData

        }

    TInt error = iDeviceDialog->Update(*map);

    if (error != KErrNone) {

        User::Leave(error); // error can be positive or negative

    }

    }

void CHbDeviceProgressDialogSymbianPrivate::DataReceived(CHbSymbianVariantMap& aData)

    {

    _LIT(KKey, "act");

    const CHbSymbianVariant* variant = aData.Get(KKey);

    if (variant)

        {

        const TDesC *value = variant->Value<const TDesC>();

        _LIT(KCancel, "c");

        if (value && *value == KCancel)

            {

            iButton.iFlags.iPressed = true;

            if (iObserver)

                {

                iObserver->ProgressDialogCancelled(q);

                // Don't touch this object anymore, observer callback may have deleted it.

                }

            }

        }

    }

void CHbDeviceProgressDialogSymbianPrivate::DeviceDialogClosed(TInt /*aCompletionCode*/)

    {

    // Send closed signal if the device dialog has been actually shown, as it is possible

    // to create and cancel a device dialog without showing it at all.

    if (iVisible)

        {

        iVisible = EFalse;

        if (iObserver)

            {

            iObserver->ProgressDialogClosed(q);

            // Don't touch this object anymore, observer callback may have deleted it.

            }

        }

    }

void CHbDeviceProgressDialogSymbianPrivate::AddVariantL(

    const TDesC& aKey,

    const TAny* aData,

    CHbSymbianVariant::TType aDataType,

    CHbSymbianVariantMap* map

    )

    {

    CHbSymbianVariant *variant = CHbSymbianVariant::NewL(aData, aDataType);

    CleanupStack::PushL(variant);

    User::LeaveIfError(map->Add(aKey, variant));

    CleanupStack::Pop(variant);

    }

const CHbSymbianVariant* CHbDeviceProgressDialogSymbianPrivate::Variant(const TDesC& aKey) const

    {

    return iVariantMap->Get(aKey);

    }

// Pack into a string a data for cancel button

HBufC *CHbDeviceProgressDialogSymbianPrivate::CreateActionDataLC(TBool aNull, const TDesC &text)

{

    HBufC *actionData;

    if (aNull)

        {

        actionData = HBufC::NewL(0);

        }

    else

        {

        _LIT(KtextTag, "t:");

        actionData = HBufC::NewL(text.Length() + KtextTag().Length());

        TPtr ptr = actionData->Des();

        ptr.Append(KtextTag);

        ptr.Append(text);

        }

    CleanupStack::PushL(actionData);

    return actionData;

}

/*!

    \class MHbDeviceProgressDialogObserver

*/

/*!

    \fn void MHbDeviceProgressDialogObserver::ProgressDialogCancelled(const CHbDeviceProgressDialogSymbian* aDialog) = 0

    This callback is called when the device progress dialog is closed by user pressing the "cancel" button.

*/

/*!

   \fn void MHbDeviceProgressDialogObserver::ProgressDialogClosed(const CHbDeviceProgressDialogSymbian* aDialog) = 0

    This callback is called when a device progress dialog is has closed. The closing may

    its maximum value or user pressing cancel button. It is not called if Close() is

    called before ShowL().

*/

/*!

    \class CHbDeviceProgressDialogSymbian

    \brief CHbDeviceProgressDialogSymbian is a Symbian implementation of HbDeviceProgressDialog.

    \code

    _LIT(KConnectText, "Connecting...");

    CHbDeviceProgressDialogSymbian *iDialog = CHbDeviceProgressDialogSymbian::NewL(CHbDeviceProgressDialogSymbian::EWaitDialog);

    iDialog->SetTextL(KConnectText);

    iDialog->ShowL();

    \endcode

    \code

    CHbDeviceProgressDialogSymbian* iDialog = CHbDeviceProgressDialogSymbian::NewL();

    _LIT(KUpdatingText, "Updating...");

    iDialog->SetTextL(KUpdatingText);

    iDialog->ShowL();

    iDialog->SetMinimum(1);

    iDialog->SetMaximum(76);

    iDialog->SetProgressValue(25);

    iDialog->UpdateL();

    \endcode

*/

/*!

    \enum CHbDeviceProgressDialogSymbian::TType

    Progress dialog types.

*/

/*!

    \var CHbDeviceProgressDialogSymbian::TType CHbDeviceProgressDialogSymbian::EProgressDialog

    Progress dialog.

*/

/*!

    \var CHbDeviceProgressDialogSymbian::TType CHbDeviceProgressDialogSymbian::EWaitDialog

    Wait dialog.

*/

/*!

    \param aType Must be one of the defined CHbDeviceProgressDialogSymbian::TType enumerations.

    Default value is CHbDeviceProgressDialogSymbian::EProgressDialog.

*/

EXPORT_C CHbDeviceProgressDialogSymbian* CHbDeviceProgressDialogSymbian::NewL(

    TType aType,

    MHbDeviceProgressDialogObserver* aObserver)

    {

    CHbDeviceProgressDialogSymbian* self = new (ELeave) CHbDeviceProgressDialogSymbian();

    CleanupStack::PushL(self);

    self->ConstructL(aType);

    self->SetObserver(aObserver);

    CleanupStack::Pop(self);

    return self;

    }

/*!

*/

EXPORT_C CHbDeviceProgressDialogSymbian::~CHbDeviceProgressDialogSymbian()

    {

    delete d;

    }

/*!

*/

EXPORT_C void CHbDeviceProgressDialogSymbian::ShowL()

    {

    d->ShowL();

    }

/*!

*/

EXPORT_C void CHbDeviceProgressDialogSymbian::UpdateL()

    {

    d->UpdateL();

    }

/*!

*/

EXPORT_C void CHbDeviceProgressDialogSymbian::Close()

    {

    d->Close();

    }