/*

* Copyright (c) 2007-2008 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Utility class for data model

*

*/

//Includes

#include "mul/mulmodelutility.h"

#include <e32cmn.h>

#include <mul/mulvisualitem.h>

#include <mul/imulvarianttype.h>

#include <mul/mulvarianttype.h>

#include <stdexcept> // for standard exceptions

#include <osn/ustring.h>

#include <utf.h>

//#include "mulactionitem.h"

namespace Alf

    {

// ---------------------------------------------------------------------------

// CreateVariantType

// ---------------------------------------------------------------------------

//

OSN_EXPORT IAlfVariantType* MulModelUtility::CreateVariantType( IAlfVariantType& aValue )

	{

/*	IAlfVariantType* data = new (EMM) AlfVariantType();

	data->set(aValue);

	return data;*/

	switch( aValue.type() )

		{

		case IAlfVariantType::EBool:

			{

			return new AlfVariantType( aValue.boolean() );

			}

		case IAlfVariantType::EInt:

			{

			return new AlfVariantType( aValue.integer() );

			}

		case IAlfVariantType::EUint:

			{

			return new AlfVariantType( aValue.uinteger() );

			}

		case IAlfVariantType::EReal:

			{

			return new AlfVariantType( aValue.real() );

			}

		case IAlfVariantType::EString:

			{

			return new AlfVariantType( aValue.string() );

			}

		case IAlfVariantType::EContainer:

			{

			return new AlfVariantType( aValue.container() );

			}

		case IAlfVariantType::EMap:

			{

			return new AlfVariantType( aValue.map() );

			}

		case IAlfVariantType::EBranch:

			{

			return new AlfVariantType( aValue.branch() );

			}

		case IAlfVariantType::ECustomData:

		default :

			{

			return NULL;

			}

		}

	}

// ---------------------------------------------------------------------------

// ConvertVisualItemToMap

// ---------------------------------------------------------------------------

//

OSN_EXPORT std::auto_ptr<IAlfMap> MulModelUtility::ConvertVisualItemToMap( MulVisualItem& /*aVisualItem*/ )

	{

	auto_ptr<IAlfMap> map( new ( EMM ) AlfMap());	

	return map;

	}

// ---------------------------------------------------------------------------

// ConvertMapToVisualItem

// ---------------------------------------------------------------------------

//

OSN_EXPORT std::auto_ptr<MulVisualItem> MulModelUtility::ConvertMapToVisualItem( IAlfMap& /*aMap*/ )

	{

	auto_ptr<MulVisualItem> visualItem( new ( EMM ) MulVisualItem());	

//	for( int i = 0 ; i < aMap.count() ; ++i )

//		{

//		const UString& attributeName = aMap.name(i);	

//		IAlfVariantType* origValue = aMap.item( attributeName );

//		std::auto_ptr< IMulVariantType> value ( new (EMM) MulVariantType() );

//		value->set(*origValue);

//		visualItem->SetAttribute( attributeName , value.get() );

//		value.release();

//		}

	return visualItem;

	}

// ---------------------------------------------------------------------------

// CheckNamePrefix

// ---------------------------------------------------------------------------

//

bool MulModelUtility::CheckNamePrefix( UString aName ) 

	{

	_LIT8(KMulPrefix,"mul_");

	TPtrC8 debugString1 = ((TUint8*)aName.getUtf8());

	int index = debugString1.Find(KMulPrefix);

	if( index == KErrNotFound )

		{

		return false;

		}

	else 

	    {

	    return true;

	    }

	}

// ---------------------------------------------------------------------------

// UStringToAlfString

// ---------------------------------------------------------------------------

//

OSN_EXPORT UString MulModelUtility::UStringToAlfString( const UString& aUString )

	{

	if(aUString.isEmpty())

		{

		return UString("");

		}

	else

		{

		return UString( aUString.getUtf8() );

		}

	}

// ---------------------------------------------------------------------------

// AlfStringToUString

// ---------------------------------------------------------------------------

//

OSN_EXPORT UString MulModelUtility::AlfStringToUString( const UString& aAlfString )

	{

	return UString( aAlfString.getUtf8() );

	}

// ---------------------------------------------------------------------------

// IntToAlfString

// ---------------------------------------------------------------------------

//

OSN_EXPORT UString MulModelUtility::IntToUString( int aNumber )

	{

	TBuf8<20> buf;

	buf.AppendNum(aNumber);

	return UString( (char*)buf.PtrZ());

	}

// ---------------------------------------------------------------------------

// ConvertTDesToUString

// ---------------------------------------------------------------------------

//

OSN_EXPORT void MulModelUtility::ConvertTDesToUString (const TDesC& aDes, UString& aString)

	{

	HBufC8* utf8Buffer( NULL );

    TRAPD( error, utf8Buffer = CnvUtfConverter::ConvertFromUnicodeToUtf8L( aDes ) );

    if ( !utf8Buffer || error != KErrNone )

        {

        delete utf8Buffer;

        throw std::exception();

        }

    TPtrC8 ptr = utf8Buffer->Des();

    std::auto_ptr<osncore::UString> ret;

    try

        {

        if ( ptr.Length() )

            {

            ret.reset( new osncore::UString( ( osncore::Utf8* ) &ptr[0], ptr.Length() ));

            }

        else

            {

            ret.reset( new osncore::UString( "" ) );

            }

        }

    catch ( std::exception e )

        {

        delete utf8Buffer;

        throw e;        

        }

    delete utf8Buffer;

    utf8Buffer = NULL;

    aString = UString(*ret);       

	}

// ---------------------------------------------------------------------------

// ConvertTDes8ToUString

// ---------------------------------------------------------------------------

//

OSN_EXPORT void MulModelUtility::ConvertTDes8ToUString (const TDesC8& aDes, UString& aString)

	{

    TPtrC8 ptr = aDes;

    std::auto_ptr<osncore::UString> ret;

    try

        {

        if ( ptr.Length() )

            {

            ret.reset( new osncore::UString( ( osncore::Utf8* ) &ptr[0], ptr.Length() ));

            }

        else

            {

            ret.reset( new osncore::UString( "" ) );

            }

        }

    catch ( std::exception e )

        {

        throw e;        

        }

    aString = UString(*ret);       

	}

// ---------------------------------------------------------------------------

// ConvertUStringToTDes

// ---------------------------------------------------------------------------

//

OSN_EXPORT void MulModelUtility::ConvertUStringToTDes (const UString& aString, TDes& aDes)

    {

    HBufC* unicodeBuffer = NULL;

    if ( !aString.isEmpty() )

        {

        TRAPD( error, unicodeBuffer = CnvUtfConverter::ConvertToUnicodeFromUtf8L(TPtrC8((TUint8*)aString.getUtf8())) );

        if ( !unicodeBuffer || error != KErrNone )

            {

            delete unicodeBuffer;

            throw std::exception();

            }

        aDes.Copy(*unicodeBuffer);

        delete unicodeBuffer;

        unicodeBuffer = NULL;

        }

    else

    	{

    	aDes.Zero(); 

    	}

    }

// ---------------------------------------------------------------------------

// ConvertUStringToTDes8

// ---------------------------------------------------------------------------

//

OSN_EXPORT void MulModelUtility::ConvertUStringToTDes8(const UString& aString, TDes8& aDes)

    {

    /// @see comments in MulModelUtility::ConvertUStringToTDes

    HBufC* unicodeBuffer = NULL;

    if ( !aString.isEmpty() )

        {

        TRAPD( error, unicodeBuffer = CnvUtfConverter::ConvertToUnicodeFromUtf8L(TPtrC8((TUint8*)aString.getUtf8())) );

        if ( !unicodeBuffer || error != KErrNone )

            {

            delete unicodeBuffer;

            throw std::exception();

            }

        aDes.Copy(*unicodeBuffer);

        delete unicodeBuffer;

        unicodeBuffer = NULL;

        }

    else

    	{

    	aDes.Zero(); 

    	}

    }

// ---------------------------------------------------------------------------

// CreateVisualItem

// ---------------------------------------------------------------------------

//    

OSN_EXPORT std::auto_ptr<MulVisualItem> MulModelUtility::CreateVisualItem( mulwidget::TLogicalTemplate aDefaultTemplate )

	{

	std::auto_ptr<MulVisualItem> visualItem( new (EMM) MulVisualItem() );

	visualItem->SetAttribute( mulvisualitem::KAttributeTemplate , aDefaultTemplate);

	return visualItem;

	}

} // namespace Alf

//End of file