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

**

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

#include <hbsymbianvariant.h>

#include <hbdevicedialogsymbian.h>

#include <hbdeleteguardsymbian_p.h>

#define ARG_UNUSED(x) (void)x;

enum TMessageBoxPanic {

    ETypePanic,

    EPropertyPanic,

    EButtonIdPanic

};

NONSHARABLE_CLASS(TMessageBoxProperty)

{

public:

    enum TType {

        EIntProperty,

        EStringProperty

    };

    TMessageBoxProperty(){mValue.mString = 0;}

    void Init(TType aId);

    ~TMessageBoxProperty();

    const TPtrC StringValue() const;

    TInt IntValue() const;

    void SetL(const TDesC &aValue);

    void Set(TInt aValue);

    bool Modified() const{return mFlags.mModified;}

    void SetModified(bool aModified){mFlags.mModified = aModified;}

    bool Valid() const{return mFlags.mValid;}

    void SetValid(bool aValid){mFlags.mValid = aValid;}

    bool IsNullAction() const{return mFlags.mNullAction;}

    void SetNullAction(bool aNull){mFlags.mNullAction = aNull;}

    TType Type() const{return mType;}

    void SetType(TType aType){mType = aType;}

private:

    TType mType;

    union {

        TInt mInt;

        HBufC *mString;

    } mValue;

    struct {

        bool mNullAction:1; // marks action (button) null

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

        bool mModified:1; // property has been modified

    } mFlags;

};

NONSHARABLE_CLASS(CHbDeviceMessageBoxPrivate)  : public CBase, public MHbDeviceDialogObserver

{

public:

    enum TPropertyId {

        EFirstIntProperty,

        EType = EFirstIntProperty,

        EIconVisible,

        ETimeout,

        EStandardButtons,

        EShowLevel,

        EDismissPolicy,

        ELastIntProperty = EDismissPolicy,

        EFirstStringProperty,

        EText = EFirstStringProperty,

        EIconName,

        EAcceptText,

        ERejectText,

        EAnimationDefinition,

        ELastStringProperty = EAnimationDefinition,

        ENumProperties

    };

    void ConstructL(CHbDeviceMessageBoxSymbian::TType aType,

        MHbDeviceMessageBoxObserver *aObserver);

    ~CHbDeviceMessageBoxPrivate();

    void InitProperties(CHbDeviceMessageBoxSymbian::TType aType);

    bool PropertiesModified(TInt aIgnoreMask) const;

    void SetPropertyValueL(TPropertyId aId, const TDesC &aValue);

    void SetPropertyValue(TPropertyId aId, TInt aValue);

    void SetButtonNull(CHbDeviceMessageBoxSymbian::TButtonId aButtonId, bool aValue);

    void SetButtonTextL(CHbDeviceMessageBoxSymbian::TButtonId aButtonId, const TDesC &aValue);

    void SetStandardButtons(TUint aButtons);

    void SendToServerL(bool aShow = false);

    void Close();

    bool WaitForClosed();

    static const TPtrC PropertyName(TPropertyId aId);

    static TPropertyId ButtonPropertyId(TPropertyId aId, CHbDeviceMessageBoxSymbian::TButtonId aButtonId);

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

    static TInt CountBits(TUint aValue);

public: // MHbDeviceDialogObserver

    void DataReceived(CHbSymbianVariantMap& aData);

    void DeviceDialogClosed(TInt aCompletionCode);

public: // data

    CHbDeviceMessageBoxSymbian *q;

    TMessageBoxProperty mProperties[ENumProperties];

    CHbDeviceDialogSymbian *mDeviceDialog;

    bool mShowCalled;

    CHbDeviceMessageBoxSymbian::TButtonId mReceivedButton;

    MHbDeviceMessageBoxObserver *mObserver;

    bool *mDeleted;

    CActiveSchedulerWait mActiveSchedulerWait;

};

// Panic application

static void Panic(TInt aCode)

{

    _LIT(KCategory, "CHbDeviceMessageBoxSymbian");

    User::Panic(KCategory, aCode);

}

// Initialize property

void TMessageBoxProperty::Init(TType aType)

{

    if (mType == EStringProperty) {

        delete mValue.mString;

        // NULL string property denotes an empty string

        mValue.mString = 0;

    } else {

        mValue.mInt = 0;

    }

    mType = aType;

    mFlags.mNullAction = false;

    mFlags.mValid = false;

    mFlags.mModified = false;

}

// Destructor

TMessageBoxProperty::~TMessageBoxProperty()

{

    if (mType == EStringProperty) {

        delete mValue.mString;

    }

}

// Get string value

const TPtrC TMessageBoxProperty::StringValue() const

{

    __ASSERT_DEBUG(mType == EStringProperty, Panic(EPropertyPanic));

    if (mValue.mString) {

        return TPtrC(*mValue.mString);

    } else {

        return TPtrC(KNullDesC);

    }

}

// Get integer value

TInt TMessageBoxProperty::IntValue() const

{

    __ASSERT_DEBUG(mType == EIntProperty, Panic(EPropertyPanic));

    return mValue.mInt;

}

// Set string value

void TMessageBoxProperty::SetL(const TDesC &aValue)

{

    __ASSERT_DEBUG(mType == EStringProperty, Panic(EPropertyPanic));

    // Check that value changes

    if (mValue.mString && *mValue.mString == aValue) {

        return;

    }

    HBufC *newValue = HBufC::NewL(aValue.Length());

    *newValue = aValue;

    delete mValue.mString;

    mValue.mString = newValue;

    mFlags.mValid = true;

    mFlags.mModified = true;

}

// Set integer value

void TMessageBoxProperty::Set(TInt aValue)

{

    __ASSERT_DEBUG(mType == EIntProperty, Panic(EPropertyPanic));

    mFlags.mValid = true;

    if (mValue.mInt == aValue) {

        return;

    }

    mValue.mInt = aValue;

    mFlags.mModified = true;

}

// Construct private

void CHbDeviceMessageBoxPrivate::ConstructL(CHbDeviceMessageBoxSymbian::TType aType,

    MHbDeviceMessageBoxObserver *aObserver)

{

    mDeviceDialog = CHbDeviceDialogSymbian::NewL();

    mReceivedButton = CHbDeviceMessageBoxSymbian::EInvalidButton;

    mObserver = aObserver;

    InitProperties(aType);

}

// Destructor

CHbDeviceMessageBoxPrivate::~CHbDeviceMessageBoxPrivate()

{

    // If no observer, remove observer from device dialog. This leaves the

    // dialog widget executing at server when client closes connection.

    if (!mObserver) {

        mDeviceDialog->SetObserver(0);

    }

    delete mDeviceDialog;

    // Set object deleted flag

    if (mDeleted) {

        // Mark the object as deleted.

        *mDeleted = true;

        mDeleted = 0;

    }

}

// Initialize properties

void CHbDeviceMessageBoxPrivate::InitProperties(CHbDeviceMessageBoxSymbian::TType aType)

{

    // Initialize all properties to default values

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

        TMessageBoxProperty &property = mProperties[i];

        property.Init(i >= EFirstStringProperty ?

            TMessageBoxProperty::EStringProperty : TMessageBoxProperty::EIntProperty);

    }

    // Set properties to default values

    mProperties[EType].Set(aType);

    mProperties[EIconVisible].Set(ETrue);

    switch(aType) {

    case CHbDeviceMessageBoxSymbian::ENone:

        mProperties[EIconVisible].Set(EFalse);

        // Fall through

    case CHbDeviceMessageBoxSymbian::EInformation:

    case CHbDeviceMessageBoxSymbian::EWarning: {

        const TInt KStandardTimeout = 3000; // 3s

        mProperties[ETimeout].Set(KStandardTimeout);

        const TInt KTapAnywhere = 0x03; // HbPopup::TapAnywhere

        mProperties[EDismissPolicy].Set(KTapAnywhere);

        // Initialize standard buttons but do not send to server as

        // HbMessageBox sets standard buttons by default

        const TInt KStandardButtons = 0x00000400; // Ok

        mProperties[EStandardButtons].Set(KStandardButtons);

        mProperties[EStandardButtons].SetModified(false);

        mProperties[EStandardButtons].SetValid(false);

        // Plugin has accept button by default

        mProperties[ERejectText].SetNullAction(true);

        break;

    }

    case CHbDeviceMessageBoxSymbian::EQuestion: {

        const TInt KNoTimeout = 0;

        mProperties[ETimeout].Set(KNoTimeout);

        const TInt KNoDismiss = 0; // HbPopup::NoDismiss

        mProperties[EDismissPolicy].Set(KNoDismiss);

        // Initialize standard buttons and send to server as

        // HbMessageBox currently sets standard buttons to "Ok" by default

        const TInt KStandardButtons = 0x00002000|0x00010000; // Yes|No

        mProperties[EStandardButtons].Set(KStandardButtons);

        break;

    }

    default:

        Panic(ETypePanic);

    }

}

bool CHbDeviceMessageBoxPrivate::PropertiesModified(TInt aIgnoreMask) const

{

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

        if (mProperties[i].Modified() && (aIgnoreMask & 1) == 0) {

            return true;

        }

        aIgnoreMask >>= 1;

    }

    return false;

}

// Set string property value

void CHbDeviceMessageBoxPrivate::SetPropertyValueL(TPropertyId aId, const TDesC &aValue)

{

    mProperties[aId].SetL(aValue);

}

// Set int property value

void CHbDeviceMessageBoxPrivate::SetPropertyValue(TPropertyId aId, TInt aValue)

{

    mProperties[aId].Set(aValue);

}

// Set button null property value

void CHbDeviceMessageBoxPrivate::SetButtonNull(CHbDeviceMessageBoxSymbian::TButtonId aButtonId,

    bool aValue)

{

    TPropertyId id = ButtonPropertyId(EAcceptText, aButtonId);

    mProperties[id].SetNullAction(aValue);

    mProperties[id].SetValid(true);

    mProperties[id].SetModified(true);

}

// Set button text property

void CHbDeviceMessageBoxPrivate::SetButtonTextL(

    CHbDeviceMessageBoxSymbian::TButtonId aButtonId, const TDesC &aValue)

{

    TPropertyId id = ButtonPropertyId(EAcceptText, aButtonId);

    mProperties[id].SetL(aValue);

}

// Set standard buttons property

void CHbDeviceMessageBoxPrivate::SetStandardButtons(TUint aButtons)

{

    static const CHbDeviceMessageBoxSymbian::TButtonId buttonIds[] = {

        CHbDeviceMessageBoxSymbian::EAcceptButton, CHbDeviceMessageBoxSymbian::ERejectButton

    };

    const TInt KNumButtonIds = sizeof(buttonIds) / sizeof(buttonIds[0]);

    TInt buttonCount = Min(KNumButtonIds, CountBits(aButtons));

    // Mark buttons present

    TInt i = 0;

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

        TPropertyId id = ButtonPropertyId(EAcceptText, buttonIds[i]);

        // Set property value but don't send to server

        mProperties[id].SetNullAction(false);

        mProperties[id].SetValid(false);

        mProperties[id].SetModified(false);

    }

    // Mark extra buttons not present

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

        TPropertyId id = ButtonPropertyId(EAcceptText, buttonIds[i]);

        // Set property value but don't send to server

        mProperties[id].SetNullAction(true);

        mProperties[id].SetValid(false);

        mProperties[id].SetModified(false);

    }

    SetPropertyValue(EStandardButtons, aButtons);

}

// Send properties to server. Show or update.

void CHbDeviceMessageBoxPrivate::SendToServerL(bool aShow)

{

    // If this is update but ShowL() has not been called, return.

    if (!aShow && !mShowCalled) {

      return;

    }

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

    const TInt ignoreMask = 0;

    if (!aShow && !PropertiesModified(ignoreMask)) {

        return;

    }

    CHbSymbianVariantMap *parameters = CHbSymbianVariantMap::NewL();

    CleanupStack::PushL(parameters);

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

        TMessageBoxProperty &property = mProperties[i];

        // ShowL() send all valid properties. Update only sends modified properties.

        bool sendProperty = aShow ? property.Valid() : property.Modified();

        if (sendProperty) {

            CHbSymbianVariant* parameter;

            if (i == EAcceptText || i == ERejectText) {

                HBufC *actionData = CreateActionDataLC(property.IsNullAction(), property.StringValue());

                parameter = CHbSymbianVariant::NewL(actionData, CHbSymbianVariant::EDes);

                CleanupStack::PopAndDestroy(); // actionData

            } else if (property.Type() == TMessageBoxProperty::EIntProperty) {

                TInt value = property.IntValue();

                parameter = CHbSymbianVariant::NewL(&value, CHbSymbianVariant::EInt);

            } else {

                TPtrC value = property.StringValue();

                parameter = CHbSymbianVariant::NewL(&value, CHbSymbianVariant::EDes);

            }

            CleanupStack::PushL(parameter);

            User::LeaveIfError(parameters->Add(

                PropertyName(static_cast<TPropertyId>(i)), parameter));

            CleanupStack::Pop(); // parameter

            property.SetModified(false);

        }

    }

    _LIT(KDeviceDialogType, "com.nokia.hb.devicemessagebox/1.0");

    TInt error;

    if (aShow) {

        mReceivedButton = CHbDeviceMessageBoxSymbian::EInvalidButton;

        error = mDeviceDialog->Show(KDeviceDialogType, *parameters, this);

        if (error != KErrNone) {

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

        }

        mShowCalled = true;

    } else {

        error = mDeviceDialog->Update(*parameters);

        if (error != KErrNone) {

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

        }

    }

    CleanupStack::PopAndDestroy(); // parameters

}

// Close message box

void CHbDeviceMessageBoxPrivate::Close()

{

    mDeviceDialog->Cancel();

}

// Wait for message box to close

bool CHbDeviceMessageBoxPrivate::WaitForClosed()

{

    // Returns true if object was not deleted during wait

    if (!mShowCalled) {

        return true;

    }

    RHbDeleteGuardSymbian guard;

    guard.OpenAndPushL(&mDeleted);

    mActiveSchedulerWait.Start();

    return !guard.PopAndClose();

}

// Get property name

const TPtrC CHbDeviceMessageBoxPrivate::PropertyName(TPropertyId aId)

{

    static const wchar_t * const names[] = {

        L"type",

        L"iconVisible",

        L"timeout",

        L"standardButtons",

        L"showLevel",

        L"dismissPolicy",

        L"text",

        L"iconName",

        L"acceptAction",

        L"rejectAction",

        L"animationDefinition"

    };

    __ASSERT_DEBUG(aId >= 0 && aId < sizeof(names)/sizeof(names[0]), Panic(EPropertyPanic));

    return TPtrC((const TUint16 *)names[aId]);

}

// Modify property id according to button

CHbDeviceMessageBoxPrivate::TPropertyId CHbDeviceMessageBoxPrivate::ButtonPropertyId(

    TPropertyId aId, CHbDeviceMessageBoxSymbian::TButtonId aButtonId)

{

    __ASSERT_DEBUG(aButtonId == CHbDeviceMessageBoxSymbian::EAcceptButton ||

        aButtonId == CHbDeviceMessageBoxSymbian::ERejectButton, Panic(EButtonIdPanic));

    switch(aId) {

    case EAcceptText:

        return aButtonId == CHbDeviceMessageBoxSymbian::EAcceptButton ? EAcceptText : ERejectText;

    default:

        Panic(EPropertyPanic);

        return aId; // suppress warning

    }

}

// Pack into a string a data for a button

HBufC *CHbDeviceMessageBoxPrivate::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;

}

// Count number of bits on

TInt CHbDeviceMessageBoxPrivate::CountBits(TUint aValue)

{

    TInt count = 0;

    while(aValue) {

        count += aValue & 1;

        aValue >>= 1;

    }

    return count;

}

// Observer, data received from device message box

void CHbDeviceMessageBoxPrivate::DataReceived(CHbSymbianVariantMap& aData)

{

    _LIT(KKey, "act");

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

    if (variant) {

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

        if (value) {

            _LIT(KPrimary, "p");

            if (*value == KPrimary) {

                mReceivedButton = CHbDeviceMessageBoxSymbian::EAcceptButton;

            } else {

                mReceivedButton = CHbDeviceMessageBoxSymbian::ERejectButton;