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

**

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

_LIT(KPanicSymbianVariantNotSupportedType, "CHbSymbianVariant: Not supported type");

NONSHARABLE_CLASS(CHbSymbianVariantPrivate) : public CBase

{

public:

    CHbSymbianVariantPrivate();

    ~CHbSymbianVariantPrivate();

    void InitializeDataL(const TAny* aData, CHbSymbianVariant::TType aDataType);

    void ResetData();

    void* Data();

public:

    struct Data {

        union BasicData {

        TInt i;

        TUint u;

        TReal r;

        TAny* ptr;

        } iBasicData;

    } iData;

    CHbSymbianVariant::TType iType;

    TBool iNull;

};

CHbSymbianVariantPrivate::CHbSymbianVariantPrivate() : iType(CHbSymbianVariant::EInt), iNull(ETrue)

{

    iData.iBasicData.i = 0;

}

CHbSymbianVariantPrivate::~CHbSymbianVariantPrivate()

{

    ResetData();

};

void CHbSymbianVariantPrivate::InitializeDataL(const TAny* aData, CHbSymbianVariant::TType aDataType)

{

    switch(aDataType) {

        case CHbSymbianVariant::EInt: {

            iData.iBasicData.i = *reinterpret_cast<const TInt*>(aData);

            break;

        }

        case CHbSymbianVariant::EBool: {

            iData.iBasicData.i = *reinterpret_cast<const TBool*>(aData);

            break;

        }

        case CHbSymbianVariant::EUint: {

            iData.iBasicData.u = *reinterpret_cast<const TUint*>(aData);

            break;

        }

        case CHbSymbianVariant::EReal: {

            iData.iBasicData.r = *reinterpret_cast<const TReal*>(aData);

            break;

        }

        case CHbSymbianVariant::EChar: {

            const TChar* chPtr = reinterpret_cast<const TChar*>(aData);

            TChar* ch = new TChar(*chPtr);

            iData.iBasicData.ptr = ch;

            break;

        }

        case CHbSymbianVariant::ERect: {

            const TRect* rectPtr = reinterpret_cast<const TRect*>(aData);

            TRect* rect = new TRect(rectPtr->iTl, rectPtr->iBr);

            iData.iBasicData.ptr = rect;

            break;

        }

        case CHbSymbianVariant::EDes: {

            const TDesC* desPtr = reinterpret_cast<const TDesC*>(aData);

            HBufC* buf = desPtr->Alloc();

            iData.iBasicData.ptr = buf;

            break;

        }

        case CHbSymbianVariant::EPoint: {

            const TPoint* pointPtr = reinterpret_cast<const TPoint*>(aData);

            TPoint* point = new TPoint(pointPtr->iX, pointPtr->iY);

            iData.iBasicData.ptr = point;

            break;

        }

        case CHbSymbianVariant::ESize: {

            const TSize* sizePtr = reinterpret_cast<const TSize*>(aData);

            TSize* size = new TSize(sizePtr->iWidth, sizePtr->iHeight);

            iData.iBasicData.ptr = size;

            break;

        }

        case CHbSymbianVariant::EBinary: {

            const TDesC8* binPtr = reinterpret_cast<const TDesC8*>(aData);

            HBufC8* binBuf = binPtr->Alloc();

            iData.iBasicData.ptr = binBuf;

            break;

        }

        case CHbSymbianVariant::EDesArray: {

            const MDesCArray* arrayPtr = reinterpret_cast<const MDesCArray*>(aData);

            TInt count = arrayPtr->MdcaCount();

            CDesC16ArrayFlat* array = new (ELeave) CDesC16ArrayFlat(16);

            CleanupStack::PushL(array);

            for(TInt i = 0; i < count; ++i) {

                array->AppendL(arrayPtr->MdcaPoint(i));

            }

            CleanupStack::Pop(array);

            iData.iBasicData.ptr = array;

            break;

        }

        case CHbSymbianVariant::EVariantMap: {

            const CHbSymbianVariantMap* mapPtr = 

                reinterpret_cast<const CHbSymbianVariantMap*>(aData);

            CHbSymbianVariantMap* copy = CHbSymbianVariantMap::NewL();

            CleanupStack::PushL(copy);

            MDesCArray& keys = mapPtr->Keys();

            TInt count = keys.MdcaCount();

            for(TInt i = 0; i < count ; ++i) {

                TPtrC ptr = keys.MdcaPoint(i);

                const CHbSymbianVariant* var = mapPtr->Get(ptr);

                copy->Add(ptr, CHbSymbianVariant::NewL(var->Data(), var->Type()));

            }

            iData.iBasicData.ptr = copy;

            CleanupStack::Pop(copy);

            break;

        }

        default: {

            User::Panic(KPanicSymbianVariantNotSupportedType, aDataType);

            break;

        }

    }

    iType = aDataType;

    iNull = EFalse;

}

void CHbSymbianVariantPrivate::ResetData()

{

    switch(iType) {

        case CHbSymbianVariant::EInt:

        case CHbSymbianVariant::EBool:

        case CHbSymbianVariant::EUint:

        case CHbSymbianVariant::EReal:

            // no need to destroy anything

            break;

        case CHbSymbianVariant::EChar: {

            TChar* del_ptr = static_cast<TChar*>(iData.iBasicData.ptr);

            delete del_ptr;

            iData.iBasicData.ptr = NULL;

            break;

            }

        case CHbSymbianVariant::EDes: {

            TDesC* del_ptr = static_cast<TDesC*>(iData.iBasicData.ptr);

            delete del_ptr;

            iData.iBasicData.ptr = NULL;

            break;

            }

        case CHbSymbianVariant::ERect: {

            TRect* del_ptr = static_cast<TRect*>(iData.iBasicData.ptr);

            delete del_ptr;

            iData.iBasicData.ptr = NULL;

            break;

            }

        case CHbSymbianVariant::EPoint: {

            TPoint* del_ptr = static_cast<TPoint*>(iData.iBasicData.ptr);

            delete del_ptr;

            iData.iBasicData.ptr = NULL;

            break;

            }

        case CHbSymbianVariant::ESize: {

            TSize* del_ptr = static_cast<TSize*>(iData.iBasicData.ptr);

            delete del_ptr;

            iData.iBasicData.ptr = NULL;

            break;

            }

        case CHbSymbianVariant::EBinary: {

            TDesC8* del_ptr = static_cast<TDesC8*>(iData.iBasicData.ptr);

            delete del_ptr;

            iData.iBasicData.ptr = NULL;

            break;

            }

        case CHbSymbianVariant::EDesArray: {

            CDesC16ArrayFlat* del_ptr = static_cast<CDesC16ArrayFlat*>(iData.iBasicData.ptr);

            delete del_ptr;

            iData.iBasicData.ptr = NULL;

            break; // dynamic data

            }

        default:

            break;

    };

}

void* CHbSymbianVariantPrivate::Data() {

    void* return_value;

    switch(iType) {

    case CHbSymbianVariant::EInt:

        return_value = &iData.iBasicData.i;

        break;

    case CHbSymbianVariant::EBool:

        return_value = &iData.iBasicData.i;

        break;

    case CHbSymbianVariant::EUint:

        return_value = &iData.iBasicData.u;

        break;

    case CHbSymbianVariant::EReal:

        return_value = &iData.iBasicData.r;

        break;

    case CHbSymbianVariant::EChar:

    case CHbSymbianVariant::EDes:

    case CHbSymbianVariant::ERect:

    case CHbSymbianVariant::EPoint:

    case CHbSymbianVariant::ESize:

    case CHbSymbianVariant::EBinary:

    case CHbSymbianVariant::EDesArray:

    case CHbSymbianVariant::EVariantMap:

        return_value = iData.iBasicData.ptr;

        break; // dynamic data

    default:

        return_value = NULL;

        break;

    }

    return return_value;

};

/*!

    \class CHbSymbianVariant

    \brief CHbSymbianVariant is a QVariant like union for Symbian data types.

    <b>This class is Symbian only. Not available on other platforms.</b>

    CHbSymbianVariant holds a single value of a single type at a time. CHbSymbianVariant::TType

    specifies supported data types.

    The class is used to pass parameters to device dialog and indicator plugins. Device dialog

    and indicator frameworks perform conversion between Qt and Symbian data types. Below list

    contains a partial list of Symbian data types and corresponding Qt types supported by

    the class.

     <table>

         <caption> Symbian/Qt data type analogy</caption>

         <tr><th>Symbian type</th><th>Qt type</th></tr>

         <tr><td>TDesC</td><td>QString</td></tr>

         <tr><td>TChar</td><td>QChar</td></tr>

         <tr><td>TPoint</td><td>QPoint</td></tr>

         <tr><td>TRect</td><td>QRect</td></tr>

         <tr><td>TSize</td><td>QSize</td></tr>

         <tr><td>TDesC8</td><td>QByteArray</td></tr>

         <tr><td>MDesCArray</td><td>QStringList</td></tr>

         <tr><td>CHbSymbianVariantMap</td><td>QVariantMap</td></tr>

     </table>

    \sa CHbSymbianVariantMap, CHbDeviceDialogSymbian, CHbIndicatorSymbian

    \stable

    \hbcore

 */

/*!

   \enum CHbSymbianVariant::TType

   Data types CHbSymbianVariant supports.

*/

/*!

   \var CHbSymbianVariant::TType CHbSymbianVariant::EInt

   Data type TInt.

*/

/*!

    \var CHbSymbianVariant::TType CHbSymbianVariant::EBool

    Data type TBool.

*/

/*!

    \var CHbSymbianVariant::TType CHbSymbianVariant::EUint

    Data type TUint.

*/

/*!

    \var CHbSymbianVariant::TType CHbSymbianVariant::EReal

    Data type TReal.

*/

/*!

    \var CHbSymbianVariant::TType CHbSymbianVariant::ERect

    Data type TRect.

*/

/*!

    \var CHbSymbianVariant::TType CHbSymbianVariant::EPoint

    Data type TPoint.

*/

/*!

    \var CHbSymbianVariant::TType CHbSymbianVariant::ESize

    Data type TSize.

*/

/*!

    \var CHbSymbianVariant::TType CHbSymbianVariant::EChar

    Data type TChar.

*/

/*!

    \var CHbSymbianVariant::TType CHbSymbianVariant::EDes

    Data type TDesC.

*/

/*!

    \var CHbSymbianVariant::TType CHbSymbianVariant::EBinary

    Data type TDesC8.

*/

/*!

    \var CHbSymbianVariant::TType CHbSymbianVariant::EDesArray

    Data type MDesCArray.

*/

/*!

    \var CHbSymbianVariant::TType CHbSymbianVariant::EVariantMap

    Data type CHbSymbianVariantMap.

*/

 /*!

    \fn T* CHbSymbianVariant::Value() const

    Template fuction to get variant's value casted to a correct pointer type. See

    TType for the supported types.

    \sa TType

*/

/*!

    \param aData Data to copy into the variant. Note: If EDesArray is used, data pointer must be casted to MDesCArray.

    \param aDataType Type of data. 

*/

EXPORT_C CHbSymbianVariant* CHbSymbianVariant::NewL(const TAny* aData, TType aDataType)

{

    CHbSymbianVariant* variant = new (ELeave) CHbSymbianVariant(aData, aDataType);

    CleanupStack::PushL(variant);

    variant->ConstructL(aData, aDataType);

    CleanupStack::Pop(variant); //variant

    return variant;

}

/*!

    Returns type of data stored in CHbSymbianVariant.

    \sa TType

*/

EXPORT_C CHbSymbianVariant::TType CHbSymbianVariant::Type() const

{

    return d->iType;

}

/*!

    Returns pointer to data stored by CHbSymbianVariant. Ownership does not changed.

    Value() should be used instead of this method.

*/

EXPORT_C TAny* CHbSymbianVariant::Data() const

{

    return d->Data();

}

/*!

    Copies new data to CHbSymbianVariant. Old data is deleted.

    Ownership does not changed.

    \param aData Data to copy into the variant. Note: If EDesArray is used, data pointer must be casted to MDesCArray.

    \param aDataType Type of data. 

*/

EXPORT_C void CHbSymbianVariant::SetData(TAny* aData, TType aDataType)

{

    if(d) {

        d->ResetData();

        d->InitializeDataL(aData, aDataType);

    }

}

/*!

    Returns true if CHbSymbianVariant holds valid data.

*/

EXPORT_C TBool CHbSymbianVariant::IsValid() const

{

    if(d && !(d->iNull))

        return ETrue;

    else

        return EFalse;

}

EXPORT_C CHbSymbianVariant::~CHbSymbianVariant()

{

    delete d;

    d = 0;

}

CHbSymbianVariant::CHbSymbianVariant(const TAny* /* aData */, TType /* aDataType */) : d(0)

{

}

void CHbSymbianVariant::ConstructL(const TAny* aData, TType aDataType)

{

    d = new (ELeave) CHbSymbianVariantPrivate;

    d->InitializeDataL(aData, aDataType);

}

NONSHARABLE_CLASS(CHbSymbianVariantMapPrivate) : public CBase

{

public:

    CHbSymbianVariantMapPrivate():iKeyArray(NULL),iVariantArray() {

        iKeyArray = new CDesC16ArrayFlat(16);

    };

    ~CHbSymbianVariantMapPrivate(){

        delete iKeyArray;

        iKeyArray = NULL;

        iVariantArray.ResetAndDestroy();

        iVariantArray.Close();

    };

public:

    CDesC16Array* iKeyArray;

    RPointerArray<CHbSymbianVariant> iVariantArray;

};

/*!

    \class CHbSymbianVariantMap

    \brief CHbSymbianVariantMap is QVariantMap style container for CHbSymbianVariant objects.

    <b>This class is Symbian only. Not available on other platforms.</b>

    This class is used to pass parameters to/from device dialogs.

    \sa CHbSymbianVariant, CHbDeviceDialogSymbian

    \stable

*/

/*!

 */

EXPORT_C CHbSymbianVariantMap* CHbSymbianVariantMap::NewL()

{

    CHbSymbianVariantMap* map = new (ELeave) CHbSymbianVariantMap();

    CleanupStack::PushL(map);

    map->ConstructL();

    CleanupStack::Pop(map); // map

    return map;

}

EXPORT_C CHbSymbianVariantMap::~CHbSymbianVariantMap()

{

    delete d;

    d = 0;

}

/*!

    Adds a key-value pair into the container. Takes ownership of the variant,

    key is copied. If key is already in the map, the value connected to the key

    is replaced with the new value and the old value is deleted.

    \param aKey Key for the value.

    \param aVariant Value to add. 

    \return Returns Symbian error code. On error ownership of \p aKey is returned to caller. 

 */

EXPORT_C TInt CHbSymbianVariantMap::Add(const TDesC& aKey, CHbSymbianVariant* aVariant)

{

    TInt pos = KErrNotFound;

    TInt result = d->iKeyArray->Find(aKey, pos, ECmpNormal);

    // There is already a key-value pairing in the map

    if ((result == KErrNone) && (pos >= 0)) {

        // for some reason directly deleting the pointer and

        // assigning a new one to position does not work

        CHbSymbianVariant* remove = d->iVariantArray[pos];

        d->iVariantArray.Remove(pos);

        d->iVariantArray.Insert(aVariant, pos);

        delete remove;

        remove = 0;

    }

    // new key-value pair

    else {

        result = KErrNone;

        TRAP(result, d->iKeyArray->AppendL(aKey));

        if (result == KErrNone){

            result = d->iVariantArray.Append(aVariant);

            if (result) {

                d->iKeyArray->Delete(d->iKeyArray->MdcaCount()-1);

            }

        }

    }

    return result;

}