/*
* Copyright (c) 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:  smiely engine class
*
*/

#include <fbs.h>
#include <bitdev.h>
#include <bitstd.h>
#include <AknIconUtils.h>
#include <coeutils.h>
#include <AknIconObserver.h>

#include "smileymodel.h"
#include "smileybmpobserver.h"
#include "smileyiconrecord.h"
#include "smileyimagedata.h"

// ======== MEMBER FUNCTIONS ========
// ---------------------------------------------------------------------------
// CSmileyImageData::CSmileyImageData
// ---------------------------------------------------------------------------
//
CSmileyImageData::CSmileyImageData( CSmileyBmpObserver* aObserver ) : 
    iObserver( aObserver )
    { 
    if ( iObserver )
        {
        iObserver->SetImageData( this );
        }
    }

// ---------------------------------------------------------------------------
// CSmileyImageData::~CSmileyImageData
// ---------------------------------------------------------------------------
//
CSmileyImageData::~CSmileyImageData()
    {    
    AknIconUtils::SetObserver( iBmp, NULL );    
    delete iBmp;
    delete iMask;
    delete iStaticBmp;
    delete iStaticMask;
    for ( TInt i( 0 ); i < iRefArray.Count(); i++ )
        {
        iRefArray[i]->SetImageData( NULL );
        }
    iRefArray.Reset();
    iRefArray.Close();
    delete iObserver;
    }

// ---------------------------------------------------------------------------
// CSmileyImageData::Bitmap
// ---------------------------------------------------------------------------
//
CFbsBitmap* CSmileyImageData::Bitmap()
    {
    return iBmp;
    }

// ---------------------------------------------------------------------------
// CSmileyImageData::Mask
// ---------------------------------------------------------------------------
//
CFbsBitmap* CSmileyImageData::Mask()
    {
    return iMask;
    }

// ---------------------------------------------------------------------------
// CSmileyImageData::CreateImageL
// ---------------------------------------------------------------------------
//
void CSmileyImageData::CreateImageL( const TDesC& aIconFileName, TImageInfo& aInfo )
    {
    DeleteImage();
    CreateBmpAndMaskL( aIconFileName, aInfo );
    if ( !iStaticBmp )
        {
        CreateStaticBmpAndMaskForAnimationL( aIconFileName, aInfo );
        }
    SetBitmapSize( iBmpSize, ETrue );        
    }

// ---------------------------------------------------------------------------
// CSmileyImageData::DeleteImage
// ---------------------------------------------------------------------------
//
void CSmileyImageData::DeleteImage()
    {
    AknIconUtils::SetObserver( iBmp, NULL );
    delete iBmp;
    iBmp = NULL;
    delete iMask;
    iMask = NULL;
    }

// ---------------------------------------------------------------------------
// CSmileyImageData::RefArrayCount
// ---------------------------------------------------------------------------
//
TInt CSmileyImageData::RefArrayCount()
    {
    return iRefArray.Count();
    }

// ---------------------------------------------------------------------------
// CSmileyImageData::AddToRefArray
// ---------------------------------------------------------------------------
//
void CSmileyImageData::AddToRefArray( CSmileyIcon* aNode )
    {
    for ( TInt i( 0 ); i < iRefArray.Count(); i++ )
        {
        if ( iRefArray[i] == aNode )
            {
            return;
            }
        }
    iRefArray.Append( aNode );
    }

// ---------------------------------------------------------------------------
// CSmileyImageData::RemoveFromaRefArray
// ---------------------------------------------------------------------------
//
void CSmileyImageData::RemoveFromRefArray( CSmileyIcon* aNode )
    {
    for ( TInt i( 0 ); i < iRefArray.Count(); i++ )
        {
        if ( iRefArray[i] == aNode )
            {
            iRefArray.Remove( i );
            break;
            }
        }
    }

// ---------------------------------------------------------------------------
// CSmileyImageData::RefIcon
// ---------------------------------------------------------------------------
//
CSmileyIcon* CSmileyImageData::RefIcon( TInt aIndex )
    {
    CSmileyIcon* icon( NULL );
    if ( aIndex >= 0 && aIndex < iRefArray.Count() )
        {
        icon = iRefArray[aIndex];
        }
    return icon;
    }

// ---------------------------------------------------------------------------
// CSmileyImageData::Code
// ---------------------------------------------------------------------------
//
TText CSmileyImageData::Code()
    {
    return iCode;
    }

// ---------------------------------------------------------------------------
// CSmileyImageData::SetCode
// ---------------------------------------------------------------------------
//
void CSmileyImageData::SetCode( TText aCode )
    {
    iCode = aCode;
    }

// ---------------------------------------------------------------------------
// CSmileyImageData::BitmapSize
// ---------------------------------------------------------------------------
//
TSize CSmileyImageData::BitmapSize()
    {
    return iBmpSize;
    }

// ---------------------------------------------------------------------------
// CSmileyImageData::BitmapSize
// ---------------------------------------------------------------------------
//
void CSmileyImageData::SetBitmapSize( TSize aBmpSize, TBool aForceSet )
    {
    TBool sizeChanged = ( iBmpSize != aBmpSize );
    iBmpSize = aBmpSize;
    if ( sizeChanged || aForceSet )
        {
        if ( iBmp )
            {
            AknIconUtils::SetSize( iBmp, iBmpSize );        
            }
        if ( iStaticBmp )
            {
            AknIconUtils::SetSize( iStaticBmp, iBmpSize );
            }        
        }
    }

// ---------------------------------------------------------------------------
// CSmileyImageData::IsAnimationFinished
// ---------------------------------------------------------------------------
//
TBool CSmileyImageData::IsAnimationFinished()
    {
    return ( iIsAnimation && iBmp == NULL );
    }

// ---------------------------------------------------------------------------
// CSmileyImageData::IsAnimation
// ---------------------------------------------------------------------------
//
TBool CSmileyImageData::IsAnimation()
    {
    return iIsAnimation;
    }

// ---------------------------------------------------------------------------
// CSmileyImageData::StoredBmp
// ---------------------------------------------------------------------------
//
CFbsBitmap* CSmileyImageData::StaticBmp()
    {
    return iStaticBmp;
    }

// ---------------------------------------------------------------------------
// CSmileyImageData::StoredMask
// ---------------------------------------------------------------------------
//
CFbsBitmap* CSmileyImageData::StaticMask()
    {
    return iStaticMask;
    }

// ---------------------------------------------------------------------------
// CSmileyImageData::CreateBmpAndMaskL
// ---------------------------------------------------------------------------
//
void CSmileyImageData::CreateBmpAndMaskL( const TDesC& aIconFileName, 
    TImageInfo& aInfo )
    {
    iIsAnimation = aInfo.iIsAnimation;
    if ( aInfo.iMaskId != 0 )
        {
        AknIconUtils::CreateIconL( iBmp, iMask, aIconFileName, aInfo.iBmpId, 
            aInfo.iMaskId );        
        }
    else
        {
        AknIconUtils::CreateIconL( iBmp, iMask, aIconFileName, aInfo.iBmpId, 
            aInfo.iBmpId );       
        }
    if ( iIsAnimation )
        {
        AknIconUtils::SetObserver( iBmp, iObserver );
        }
    }

// ---------------------------------------------------------------------------
// CSmileyImageData::CreateStaticBmpAndMaskForAnimationL
// ---------------------------------------------------------------------------
//
void CSmileyImageData::CreateStaticBmpAndMaskForAnimationL( 
    const TDesC& aIconFileName, TImageInfo& aInfo )
    {
    if ( aInfo.iIsAnimation )
        {
        if ( aInfo.iStaticMaskId != 0 )
            {
            AknIconUtils::CreateIconL( iStaticBmp, iStaticMask, aIconFileName, 
                aInfo.iStaticBmpId, aInfo.iStaticMaskId );        
            }
        else
            {
            AknIconUtils::CreateIconL( iStaticBmp, iStaticMask, aIconFileName, 
                aInfo.iStaticBmpId, aInfo.iStaticBmpId );       
            }
        }
    }