--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/hbwidgets/devicedialogs/hbdeviceprogressdialogsymbian.cpp	Mon Apr 19 14:02:13 2010 +0300
@@ -0,0 +1,897 @@
+/****************************************************************************
+**
+** 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(KDialogTextAlign, "textAlignment");
+_LIT(KDialogIconAlign, "iconAlignment");
+_LIT(KPrimaryActionText, "primaryActionText");
+_LIT(KPrimaryActionNull, "primaryActionNull");
+_LIT(KPluginIdentifier, "com.nokia.hb.deviceprogressdialog/1.0");
+_LIT(KAnimationDefinition, "animationDefinition");
+
+const TInt KAlignCenterLeft = 0x0080 | 0x0001;  //Qt::AlignVCenter | Qt::AlignLeft
+const TInt KAlignCenter = 0x0080 | 0x0004;      //Qt::AlignCenter
+
+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;
+
+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;
+    TInt iTextAlign;
+    TInt iIconAlign;
+    TBool iWrap;
+    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);
+    AddVariantL(KDialogTextAlign, &iTextAlign, CHbSymbianVariant::EInt, iVariantMap);
+    AddVariantL(KDialogIconAlign, &iIconAlign, 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;
+        TBool isNull = iButton.iFlags.iIsNull;
+        if (isNull)
+            {
+            AddVariantL(KPrimaryActionNull, &isNull, CHbSymbianVariant::EBool, iVariantMap);
+            }
+        else
+            {
+            AddVariantL(KPrimaryActionText, &iButton.iText, CHbSymbianVariant::EDes, iVariantMap);
+            }
+        }
+    iButton.iFlags.iPressed = false;
+    User::LeaveIfError(iDeviceDialog->Show(KPluginIdentifier, *iVariantMap, this));
+
+    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(KDialogTextAlign);
+    if (variant && *variant->Value<TInt>() != iTextAlign)
+        {
+        AddVariantL(KDialogTextAlign, &iTextAlign, CHbSymbianVariant::EInt, iVariantMap);
+        AddVariantL(KDialogTextAlign, &iTextAlign, CHbSymbianVariant::EInt, map);
+        }
+
+    variant = Variant(KDialogIconAlign);
+    if (variant && *variant->Value<TInt>() != iIconAlign)
+        {
+        AddVariantL(KDialogIconAlign, &iIconAlign, CHbSymbianVariant::EInt, iVariantMap);
+        AddVariantL(KDialogIconAlign, &iIconAlign, 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;
+        TBool isNull = iButton.iFlags.iIsNull;
+        if (isNull)
+            {
+            AddVariantL(KPrimaryActionNull, &isNull, CHbSymbianVariant::EBool, iVariantMap);
+            }
+        else
+            {
+            AddVariantL(KPrimaryActionText, &iButton.iText, CHbSymbianVariant::EDes, iVariantMap);
+            }
+        }
+
+    User::LeaveIfError(iDeviceDialog->Update(*map));
+    delete map;
+    map = 0;
+    }
+
+void CHbDeviceProgressDialogSymbianPrivate::DataReceived(CHbSymbianVariantMap& aData)
+    {
+    _LIT(KKey, "act");
+    const CHbSymbianVariant* variant = aData.Get(KKey);
+    if (variant)
+        {
+        const TDesC *value = variant->Value<const TDesC>();
+        _LIT(KPrimary, "p");
+        if (value && *value == KPrimary)
+            {
+            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);
+    }
+
+/*!
+    \class MHbDeviceProgressDialogObserver
+    \brief MHbDeviceProgressDialogObserver is an observer interface for observing CHbDeviceProgressDialogSymbian.
+*/
+
+/*!
+    \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.
+
+    \a aDialog - Pointer to dialog that was cancelled.
+*/
+
+/*!
+   \fn void MHbDeviceProgressDialogObserver::ProgressDialogClosed(const CHbDeviceProgressDialogSymbian* aDialog) = 0
+
+    This callback is called when a device progress dialog is 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 called if Close() is
+    called before ShowL().
+
+    \a aDialog - Pointer to dialog instance that has closed.
+*/
+
+/*!
+    \class CHbDeviceProgressDialogSymbian
+    \brief CHbDeviceProgressDialogSymbian is a Symbian implementation of HbDeviceProgressDialog.
+
+    It is a client interface for s60 native application to notify user with a text message, icon
+    and progress bar, when HbDeviceProgressDialog can not be used.
+
+    CHbDeviceProgressDialogSymbian provides similar interface and functionality as HbDeviceProgressDialog.
+    Main difference is that signals are replaced by observer interface. Also the parameters of methods using Qt enumerations are changed to TInt.
+
+    Two progress dialog types are supported: wait and progress dialog.
+
+    Wait dialog can be used when the progress of operation cannot be determined.
+    As the delay is unknown, the waiting progress bar will be shown until either a user
+    cancels the dialog by pressing the "cancel" button or the application showing the device
+    wait dialog closes the dialog after the operation has finished or in case of timeout.
+
+    Progress dialog can be used when the progress of operation is known. For example
+    when deleting a number of files, the progress of the operation could be shown as a
+    percentage of the files deleted. Application sets the progress value during the
+    operation and the dialog will be shown until either a user cancels the dialog by pressing
+    the "cancel" button or the application showing the device progress dialog closes the
+    dialog after the operation is finished or in case of error.
+
+    Progress dialogs are always asynchronous by nature as the client is responsible of updating the dialog
+    according to current progress status.
+
+    The device dialog is only shown when ShowL() is called. Because each dialog update requires
+    IPC calls to be made, it's advisable to fully construct the device dialog before calling
+    ShowL() or UpdateL().
+
+    Here is an example of using the infinite wait note:
+
+    \code
+    _LIT(KConnectText, "Connecting...");
+    CHbDeviceProgressDialogSymbian *iDialog = CHbDeviceProgressDialogSymbian::NewL(CHbDeviceProgressDialogSymbian::EWaitDialog);
+    iDialog->SetTextL(KConnectText);
+    iDialog->ShowL();
+    \endcode
+
+    Below is an example of using the device progress dialog:
+
+    \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
+
+    CHbDeviceProgressDialogSymbian supports animations.
+    Supported formats are the following:
+
+    - GIF (.gif)
+    - MNG (.mng)
+	- Frame animations
+
+	There is a built-in support for GIF and MNG animations.
+
+	Frame animations can be created by following way:
+
+	\code
+	Create an animation definition file.
+
+	<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>
+
+	Create CHbDeviceProgressDialogSymbian in a way described before and
+	set definition file and animation's logical name.
+
+	_LIT(KAnimationDefinitionXML, "C:\animation.axml");
+	_LITK(KLogicalIconName, "frame_anim_looping");
+
+	iDialog->SetAnimationDefinitionL(KAnimationDefinitionXML);
+	iDialog->SetIconNameL(KIconName);
+	iDialog->ShowL();
+	\endcode
+	\sa HbIconAnimationManager::addDefinitionFile
+	\note Animation definition files must be stored to a place where they
+	can be accessed.
+
+    \sa HbDeviceProgressDialog, HbDeviceDialog
+    \proto
+    \hbwidgets
+*/
+/*!
+    \enum CHbDeviceProgressDialogSymbian::TType
+    Progress dialog types.
+*/
+/*!
+    \var CHbDeviceProgressDialogSymbian::TType CHbDeviceProgressDialogSymbian::EProgressDialog
+    Progress dialog.
+*/
+/*!
+    \var CHbDeviceProgressDialogSymbian::TType CHbDeviceProgressDialogSymbian::EWaitDialog
+    Wait dialog.
+*/
+
+/*!
+    Symbian two phase constructor. Returns a pointer to CHbDeviceNotificationDialogSymbian instance.
+    \param aType Must be one of the defined CHbDeviceProgressDialogSymbian::TType enumerations.
+    \param aObserver Pointer to observer.
+
+    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;
+    }
+
+/*!
+    Destructs the class.
+*/
+EXPORT_C CHbDeviceProgressDialogSymbian::~CHbDeviceProgressDialogSymbian()
+    {
+    delete d;
+    }
+
+/*!
+    Executes the dialog asynchronously.
+*/
+EXPORT_C void CHbDeviceProgressDialogSymbian::ShowL()
+    {
+    d->ShowL();
+    }
+
+/*!
+    Updates the dialog asynchronously.
+*/
+EXPORT_C void CHbDeviceProgressDialogSymbian::UpdateL()
+    {
+    d->UpdateL();
+    }
+
+/*!
+    Cancels and closes the dialog.
+
+    \deprecated CHbDeviceProgressDialogSymbian::Cancel()
+    is deprecated. Replaced by CHbDeviceProgressDialogSymbian::Close().
+
+*/
+EXPORT_C void CHbDeviceProgressDialogSymbian::Cancel()
+    {
+    d->Close();
+    }
+
+/*!
+    Closes the dialog.
+*/
+EXPORT_C void CHbDeviceProgressDialogSymbian::Close()
+    {
+    d->Close();
+    }
+
+/*!
+    Sets the minimum and maximum value of the progress bar within the dialog.
+    \param aMin minimum value of the progress bar.
+    \param aMax maximum value of the progress bar.
+
+    \sa Minimum(), Maximum()
+*/
+EXPORT_C void CHbDeviceProgressDialogSymbian::SetRange(TInt aMin, TInt aMax)
+    {
+    SetMinimum(aMin);
+    SetMaximum(aMax);
+    }
+
+/*!
+    Sets the maximum value of the progress bar within the dialog.
+    \param aMax maximum value of the progress bar.
+    \sa Maximum()
+*/
+EXPORT_C void CHbDeviceProgressDialogSymbian::SetMaximum(TInt aMax)
+    {
+    // Don't allow wait dialog to set max/min other than zero as wait
+    // animation bar doesn't work in that case.
+    d->iMaximum = d->iType == EWaitDialog ? 0 : aMax;
+    }
+
+/*!
+    Returns the maximum value of the progress bar within the dialog.
+
+    The default value is 100.
+    \sa SetMaximum()
+*/
+EXPORT_C TInt CHbDeviceProgressDialogSymbian::Maximum() const
+    {
+    return d->iMaximum;
+    }
+
+/*!
+    Sets the minimum value of the progress bar within the dialog.
+    \param aMin minimum value of the progress bar.
+    \sa Minimum()
+*/
+EXPORT_C void CHbDeviceProgressDialogSymbian::SetMinimum(TInt aMin)
+    {
+    // Don't allow wait dialog to set max/min other than zero as wait
+    // animation bar doesn't work in that case.
+    d->iMinimum = d->iType == EWaitDialog ? 0 : aMin;
+    }
+
+/*!
+    Returns the minimum value of the progress bar within the dialog.
+
+    The default value is 0.
+    \sa SetMinimumL()
+*/
+EXPORT_C TInt CHbDeviceProgressDialogSymbian::Minimum() const
+    {
+    return d->iMinimum;
+    }
+
+/*!
+    Sets the autoClose property value of the dialog.
+    \param aAutoClose When set, the dialog is closed when value of the progress bar reaches
+    the maximum value of the progress bar.
+    \sa AutoClose()
+*/
+EXPORT_C void CHbDeviceProgressDialogSymbian::SetAutoClose(TBool aAutoClose)
+    {
+    d->iAutoClose = aAutoClose;
+    }
+
+/*!
+    Returns the value of the autoClose property of the dialog.
+
+    The default value is true for CHbDeviceProgressDialogSymbian::ProgressDialod and false
+    for CHbDeviceProgressDialogSymbian::WaitDialog.
+    \sa SetAutoCloseL()
+*/
+EXPORT_C TBool CHbDeviceProgressDialogSymbian::AutoClose() const
+    {
+    return d->iAutoClose;
+    }
+
+/*!
+    Sets dialog type.
+    \param aType defines the type of the dialog.
+    \sa ProgressType()
+*/
+EXPORT_C void CHbDeviceProgressDialogSymbian::SetProgressType(
+    CHbDeviceProgressDialogSymbian::TType aType)
+    {
+    d->iType = aType;
+
+    if (aType == EWaitDialog)
+        {
+        SetRange(0,0);
+        SetAutoClose(false);
+        }
+    else
+        {
+        SetRange(0,100);
+        SetAutoClose(true);
+        }
+    }
+
+/*!
+    Returns dialog's type.
+    \sa SetProgressType()
+*/
+EXPORT_C CHbDeviceProgressDialogSymbian::TType CHbDeviceProgressDialogSymbian::ProgressType() const
+    {
+    return static_cast<TType>(d->iType);
+    }
+
+/*!
+    Sets the value of the progress bar within the dialog.
+    \param aProgressValue value of the progress bar.
+    \sa ProgressValue()
+*/
+EXPORT_C void CHbDeviceProgressDialogSymbian::SetProgressValue(TInt aProgressValue)
+    {
+    d->iProgressValue = aProgressValue;
+    }
+
+/*!
+    Returns the value of the progress bar within the dialog.
+    \sa SetProgressValue()
+*/
+EXPORT_C TInt CHbDeviceProgressDialogSymbian::ProgressValue() const
+    {
+    return d->iProgressValue;
+    }
+
+/*!
+    Sets text of the dialog.
+    \param aText dialog text.
+    \sa Text()
+*/
+EXPORT_C void CHbDeviceProgressDialogSymbian::SetTextL(const TDesC& aText)
+    {
+    TInt length = aText.Length();
+    if (length > d->iText.MaxLength())
+        {
+        d->iText.ReAllocL(length);
+        }
+    d->iText.Copy(aText);
+    }
+
+/*!
+    Returns text of the note.
+    \sa SetTextL()
+*/
+EXPORT_C const TPtrC CHbDeviceProgressDialogSymbian::Text() const
+    {
+    return d->iText;
+    }
+
+/*!
+    Sets message box icon name or animation logical name. The message box gets updated next time ShowL() or UpdateL()
+    is called.
+
+    \param aIconName Icon name. Icon can be from Hb resources or themes. Or it can be a file in
+    a file system.
+
+    \sa IconName()
+*/
+EXPORT_C void CHbDeviceProgressDialogSymbian::SetIconNameL(const TDesC& aIconName)
+    {
+    TInt length = aIconName.Length();
+    if (length > d->iIconName.MaxLength())
+        {
+        d->iIconName.ReAllocL(length);
+        }
+    d->iIconName.Copy(aIconName);
+    }
+
+/*!
+    Returns name and path of the icon shown on dialog or animation's logical name.
+
+    \sa SetIconNameL()
+*/
+EXPORT_C const TPtrC CHbDeviceProgressDialogSymbian::IconName() const
+    {
+    return d->iIconName;
+    }
+
+/*!
+    Sets notification dialog's animation definition name.  The dialogs get updated next when time ShowL() or UpdateL()
+    is called.
+
+    \param aAnimationDefinition Animation definition file name. Definition can be from Hb resources or themes.
+    Or can be a file in a file system.
+
+    \sa AnimationDefinition()
+*/
+EXPORT_C void CHbDeviceProgressDialogSymbian::SetAnimationDefinitionL(const TDesC& aAnimationDefinition)
+    {
+    TInt length = aAnimationDefinition.Length();
+    if (length > d->iAnimationDefinition.MaxLength())
+        {
+        d->iAnimationDefinition.ReAllocL(length);
+        }
+    d->iAnimationDefinition.Copy(aAnimationDefinition);
+    }
+
+/*!
+    Returns an animation definition set for a dialog. If not set, return string.
+
+    \sa SetAnimationDefinitionL()
+*/
+EXPORT_C TPtrC CHbDeviceProgressDialogSymbian::AnimationDefinition() const
+	{
+	return d->iAnimationDefinition;
+	}
+
+/*!
+    Sets the text alignment.
+    \param aAlign Qt defined alignment options can used.
+    \sa TextAlignment()
+*/
+EXPORT_C void CHbDeviceProgressDialogSymbian::SetTextAlignment(TInt aAlign)
+    {
+    d->iTextAlign = aAlign;
+    }
+
+/*!
+    Returns the text alignment.
+
+    The default value is Qt::AlignLeft|Qt::AlignVCenter.
+    \sa SetTextAlignment()
+*/
+EXPORT_C TInt CHbDeviceProgressDialogSymbian::TextAlignment() const
+    {
+    return d->iTextAlign;
+    }
+
+/*!
+    Sets the icon alignment.
+    \param aAlign Qt defined alignment options can used.
+    \sa IconAlignment()
+*/
+EXPORT_C void CHbDeviceProgressDialogSymbian::SetIconAlignment(TInt aAlign)
+    {
+    d->iIconAlign = aAlign;
+    }
+
+/*!
+    Returns the icon alignment.
+
+    The default value is Qt::AlignCenter.
+    \sa SetIconAlignment()
+*/
+EXPORT_C TInt CHbDeviceProgressDialogSymbian::IconAlignment() const
+    {
+    return d->iIconAlign;
+    }
+
+/*!
+    Sets the text wrapping.
+    \param aWrap When set, the text is drawn with Qt::TextWordWrap enabled meaning that
+    lines breaks are at appropriate point, e.g. at word boundaries.
+    \sa TextWrapping()
+
+    \deprecated CHbDeviceProgressDialogSymbian::SetTextWrapping()
+    is deprecated. Will be removed.
+
+*/
+EXPORT_C void CHbDeviceProgressDialogSymbian::SetTextWrapping(TBool aWrap)
+    {
+    d->iWrap = aWrap;
+    }
+
+/*!
+    Returns the text wrapping setting.
+
+    The default value is true.
+    \sa SetTextWrapping()
+
+    \deprecated CHbDeviceProgressDialogSymbian::TextWrapping()
+    is deprecated. Will be removed.
+*/
+EXPORT_C TBool CHbDeviceProgressDialogSymbian::TextWrapping() const
+    {
+    return d->iWrap;
+    }
+
+/*!
+    Sets progress dialog box button text. The dialog gets updated next time ShowL() or UpdateL()
+    is called.
+
+    \param aText Button text.
+
+    \sa ButtonText()
+*/
+EXPORT_C void CHbDeviceProgressDialogSymbian::SetButtonTextL(const TDesC& aText)
+{
+    TInt length = aText.Length();
+    if (length > d->iButton.iText.MaxLength()) {
+        d->iButton.iText.ReAllocL(length);
+    }
+    d->iButton.iText.Copy(aText);
+    d->iButton.iFlags.iTextValid = true;
+    d->iButton.iFlags.iTextModified = true;
+}
+
+/*!
+    Returns progress dialog button text.
+
+    \sa SetButtonTextL()
+*/
+EXPORT_C const TPtrC CHbDeviceProgressDialogSymbian::ButtonText() const
+{
+    return d->iButton.iText;
+}
+
+/*!
+    Sets progress dialog button presence. The dialog updated next time ShowL() or UpdateL()
+    is called.
+
+    \param aEnable True enables (makes visible) the dialog button.
+
+    \sa HasButton()
+*/
+EXPORT_C void CHbDeviceProgressDialogSymbian::SetButton(TBool aEnable)
+{
+    d->iButton.iFlags.iIsNull = !aEnable;
+    d->iButton.iFlags.iIsNullValid = true;
+    d->iButton.iFlags.iIsNullModified = true;
+}
+
+/*!
+    Returns progress dialog button presence.
+
+    \param aButton Selects the button.
+
+    \sa SetButton()
+*/
+EXPORT_C TBool CHbDeviceProgressDialogSymbian::HasButton() const
+{
+    return !d->iButton.iFlags.iIsNull;
+}
+
+/*!
+    Sets progress dialog observer. The observer is called when progress dialog is closed.
+    \param aObserver Pointer to observer.
+
+    \sa MHbDeviceProgressDialogObserver
+*/
+EXPORT_C void CHbDeviceProgressDialogSymbian::SetObserver(MHbDeviceProgressDialogObserver* aObserver)
+    {
+    d->iObserver = aObserver;
+    }
+
+/*
+    Constructor.
+*/
+CHbDeviceProgressDialogSymbian::CHbDeviceProgressDialogSymbian()
+    {
+    }
+
+/*
+    2nd Constructor.
+*/
+void CHbDeviceProgressDialogSymbian::ConstructL(TType aType)
+    {
+    d = new (ELeave) CHbDeviceProgressDialogSymbianPrivate;
+    d->ConstructL(this);
+    SetProgressType(aType);
+    SetProgressValue(0);
+    SetTextAlignment(KAlignCenterLeft);
+    SetIconAlignment(KAlignCenter);
+    SetTextWrapping(ETrue);
+    }