/*

 * Copyright (c) 2009 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: implementation smiley classes 

 *

 */

#include <AknIconUtils.h> 

#include <barsread.h>

#include <coemain.h>

#include <smiley.mbg>

#include <smiley.rsg>

#include "peninputlayoutsmiley.h"

//resource file

_LIT( KSmileyMifFile, "z:\\resource\\apps\\smiley.mif" );

_LIT( KSmileyResFile, "z:\\resource\\smiley.rsc" );

//string to calculate smiley width

_LIT( KSmileySizeTemplate, "\xf8e4" );

//invisible place holder for smiley character

const TUint16 KSmileyPlaceHolder = 0x3000;

const TInt KDefaultSmileySize = 24;

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

// Symbian Constructor

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

//

CPeninputSmileyImage* CPeninputSmileyImage::NewL( TInt aSmileyId, TInt aBitmapId, 

                                                  TInt aMaskId, const TSize& aImageSize )

    {

    CPeninputSmileyImage* self = CPeninputSmileyImage::NewLC( aSmileyId, aBitmapId, 

                                                              aMaskId, aImageSize );

    CleanupStack::Pop( self );

    return self;

    }

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

// Symbian Constructor

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

//

CPeninputSmileyImage* CPeninputSmileyImage::NewLC( TInt aSmileyId, TInt aBitmapId, 

                                                   TInt aMaskId, const TSize& aImageSize )

    {

    CPeninputSmileyImage* self = new ( ELeave ) CPeninputSmileyImage( aSmileyId, 

                                                   aBitmapId, aMaskId,aImageSize );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// c++ destructor

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

//

CPeninputSmileyImage::~CPeninputSmileyImage()

    {

    delete iImageBitmap;

    delete iMaskBitmap;

    }

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

// Create smiley image

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

//

void CPeninputSmileyImage::CreateImageL()

    {

    DestroyImage();

    TInt maskid = iMaskBitmapId != 0 ? iMaskBitmapId : iImageBitmapId;

    AknIconUtils::CreateIconL( iImageBitmap, iMaskBitmap, 

                               KSmileyMifFile, iImageBitmapId, maskid );

    AknIconUtils::SetSize( iImageBitmap, iImageSize );

    }

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

// Destroy smiley image

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

//

void CPeninputSmileyImage::DestroyImage()

    {

    if ( iImageBitmap )

        {

        delete iImageBitmap;

        iImageBitmap = NULL;

        }

    if ( iMaskBitmap )

        {

        delete iMaskBitmap;

        iMaskBitmap = NULL;

        }    

    }

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

// Get image bitmap of smiley

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

//

CFbsBitmap* CPeninputSmileyImage::ImageBitmap()

    {

    return iImageBitmap;

    }

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

// Get mask bitmap of smiley

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

//

CFbsBitmap* CPeninputSmileyImage::MaskBitmap()

    {

    return iMaskBitmap;

    }

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

// Get smiley id

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

//

TInt CPeninputSmileyImage::SmileyId()

    {

    return iSmileyId;

    }

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

// Get smiley size

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

//

TSize CPeninputSmileyImage::SmileyImageSize()

    {

    return iImageSize;

    }

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

// Set smiley size

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

//

void CPeninputSmileyImage::SetImageSize( const TSize& aSize )

    {

    if ( aSize != iImageSize )

        {

        iImageSize = aSize;

        if ( iImageBitmap )

            {

            AknIconUtils::SetSize( iImageBitmap, aSize );

            }     

        }

    }

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

// c++ constructor

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

//

CPeninputSmileyImage::CPeninputSmileyImage( TInt aSmileyId, TInt aBitmapId, 

                                            TInt aMaskId, const TSize& aImageSize ) 

    : iSmileyId( aSmileyId ) 

    , iImageBitmapId( aBitmapId ) 

    , iMaskBitmapId( aMaskId )

    , iImageSize( aImageSize )

    {

    }

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

// Symbian second-phase constructor

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

//

void CPeninputSmileyImage::ConstructL()

    {

    }

//////////////////////////////////////////////////////////////////////////////

//CPeninputSmileyManager

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

// Symbian Constructor

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

//

CPeninputSmileyManager* CPeninputSmileyManager::NewL()

    {

    CPeninputSmileyManager* self = CPeninputSmileyManager::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// Symbian Constructor

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

//

CPeninputSmileyManager* CPeninputSmileyManager::NewLC()

    {

    CPeninputSmileyManager* self = new ( ELeave ) CPeninputSmileyManager;

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// C++ destructor

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

//

CPeninputSmileyManager::~CPeninputSmileyManager()

    {

    iSmileyArray.ResetAndDestroy();

    iSmileyArray.Close();

    iSmileyHash.Close();

    }

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

// Get smiley object by id

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

//

CPeninputSmileyImage* CPeninputSmileyManager::SmileyImage( TInt aSmileyId )

    {

    TInt key = aSmileyId;

    CPeninputSmileyImage** ptr = iSmileyHash.Find( key );

    if ( ptr )

        {

        return *ptr;

        }

    return NULL;

    }

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

// Detech if Specified character is smiley

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

//

TBool CPeninputSmileyManager::IsSmileyCode( TUint16 aCharCode )

    {

    return ( aCharCode >= 0xf880 && aCharCode <= 0xf8e4 );

    }

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

// Get smiley template

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

//

const TDesC& CPeninputSmileyManager::SmileySizeTemplate()

    {

    return KSmileySizeTemplate;

    }

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

// Get invisible character as place holder

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

//

TUint16 CPeninputSmileyManager::SmileyPlaceHolderCharacter()

    {

    return KSmileyPlaceHolder;

    }

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

// C++ constructor

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

//

CPeninputSmileyManager::CPeninputSmileyManager()

    {

    }

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

// Symbian second-phase constructor

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

//

void CPeninputSmileyManager::ConstructL()

    {

    TInt id = CCoeEnv::Static()->AddResourceFileL( KSmileyResFile );

    ReadSmileyInfoL( R_SMILEY_ICONS_INFO );

    CCoeEnv::Static()->DeleteResourceFile( id );

    PreLoadSmileyImageL();

    }

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

// Read smiley info from resource

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

//

void CPeninputSmileyManager::ReadSmileyInfoL( TInt aResourceId )

    {

    TResourceReader reader;

    CCoeEnv::Static()->CreateResourceReaderLC( reader, aResourceId );//resId

    TInt count = reader.ReadInt16();

    CPeninputSmileyImage* smiley = NULL;

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

        {

        TUint16 animation = reader.ReadUint16(); // read animation

        TUint16 smileyId = reader.ReadUint16();

        TInt32 bitmapId = reader.ReadInt32();

        TInt32 maskId = reader.ReadInt32();

        TInt32 staticBitmapId = reader.ReadInt32();

        TInt32 staticMaskId = reader.ReadInt32();

        TPtrC smileycode = reader.ReadTPtrC(); // read string

        TSize size( KDefaultSmileySize, KDefaultSmileySize );

        if ( animation )

            {

            smiley = CPeninputSmileyImage::NewL( smileyId, staticBitmapId, 

                                                 staticMaskId, size );

            }

        else

            {

            smiley = CPeninputSmileyImage::NewL( smileyId, bitmapId, maskId,

                                                 size );            

            }

        iSmileyArray.Append( smiley );

        iSmileyHash.Insert( smileyId, smiley );

        }

    CleanupStack::PopAndDestroy(); // reader

    }

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

// Initalize all smily images

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

//

void CPeninputSmileyManager::PreLoadSmileyImageL()

    {

    for ( TInt i = 0; i < iSmileyArray.Count(); i++ )

        {

        iSmileyArray[i]->CreateImageL();

        }

    }