/*

* Copyright (c) 2002-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: 

*

*/

#include <barsread.h>

#include <AknUtils.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <centralrepository.h>

#include <AvkonInternalCRKeys.h>

#include <AknBidiTextUtils.h>

#include <AknPanic.h>

#include <smiley.rsg>

#include <smiley.mbg>

#include "AknSmileyModel.h"

#include "AknSmileyImage.h"

#include "akntrace.h"

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

// TSmileyIconInfo

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

TSmileyIconInfo::TSmileyIconInfo()

    {

    Reset();

    }

TSmileyIconInfo::TSmileyIconInfo(const TSmileyIconInfo& aInfo) : 

iSkinItemID(aInfo.iSkinItemID), 

iDefaultStillImageID(aInfo.iDefaultStillImageID), 

iDefaultAnimationImageID(aInfo.iDefaultAnimationImageID)

    {

    }

void TSmileyIconInfo::Reset()

    {

    iSkinItemID.Set(0, 0);

    iDefaultStillImageID = 0;

    iDefaultAnimationImageID = 0;

    }

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

// CSmileyIcon

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

CSmileyIcon* CSmileyIcon::NewL(const TSmileyIconInfo& aInfo, MAknSmileyObserver* aObserver)

    {

    CSmileyIcon* self = new (ELeave) CSmileyIcon(aObserver);

    CleanupStack::PushL(self);

    self->ConstructL(aInfo);

    CleanupStack::Pop(); // self;

    return self;

    }

void CSmileyIcon::ConstructL(const TSmileyIconInfo& aInfo)

    {

    iIndex = aInfo.iIndex;

    iStillImage = CSmileyImage::NewL(aInfo.iSkinItemID, aInfo.iDefaultStillImageID, EFalse, this);

    if(aInfo.iSkinItemID.iMinor==0 && aInfo.iDefaultAnimationImageID>0)

        {

        TAknsItemID nullID;

        nullID.Set(0, 0);

        iAnimationImage = CSmileyImage::NewL(nullID, aInfo.iDefaultAnimationImageID, ETrue, this);

        }

    }

CSmileyIcon::CSmileyIcon(MAknSmileyObserver* aObserver) : iSmileyIconObserver(aObserver)

    {

    }

CSmileyIcon::~CSmileyIcon()

    {

    delete iStillImage;

    delete iAnimationImage;

    iTextArray.Close();

    iCodeArray.Close();

    }

const CFbsBitmap* CSmileyIcon::Image() const

    {

    if(AnimationImageIsReadyToDraw())

        {

        return iAnimationImage->Image();

        }

    else

        {

        return iStillImage->Image();

        }

    }

const CFbsBitmap* CSmileyIcon::Mask() const

    {

    if(AnimationImageIsReadyToDraw())

        {

        return iAnimationImage->Mask();

        }

    else

        {

        return iStillImage->Mask();

        }

    }

TBool CSmileyIcon::ReadyToDraw() const

    {

    return StillImageIsReadyToDraw() || AnimationImageIsReadyToDraw();

    }

void CSmileyIcon::SetSize(const TSize& aSize)

    {

    iStillImage->SetSize(aSize);

    if(iAnimationImage)

        {

        iAnimationImage->SetSize(aSize);

        }

    }

const TSize& CSmileyIcon::Size() const

    {

    return iStillImage->Size();

    }

void CSmileyIcon::PlayAnimationL(TInt aRepeat, TInt aDelay)

    {

    if(iAnimationImage)

        {

        iAnimationImage->LoadL(aRepeat, aDelay);

        }

    }

void CSmileyIcon::StopAnimation()

    {

    if(iAnimationImage)

        {

        iAnimationImage->Release();

        }

    }

void CSmileyIcon::BitmapChanged(CSmileyImage* aSmileyImage, CFbsBitmap* /*aBitmap*/)

    {

    if(aSmileyImage == iStillImage)

        {

        if(iSmileyIconObserver) iSmileyIconObserver->SmileyStillImageLoaded(this);

        }

    else

        {

        if(iSmileyIconObserver) iSmileyIconObserver->SmileyAnimationChanged(this);

        }

    }

TInt CSmileyIcon::Index() const

    {

    return iIndex;

    }

void CSmileyIcon::LoadStillImageL(TInt aDelay)

    {

    iStillImage->LoadL(0, aDelay);

    }

TBool CSmileyIcon::StillImageIsReadyToDraw() const

    {

    return iStillImage->ReadyToDraw();

    }

TBool CSmileyIcon::AnimationImageIsReadyToDraw() const

    {

    return (iAnimationImage && iAnimationImage->ReadyToDraw());

    }

void CSmileyIcon::AddVariant(const TDesC& aText, TChar aBaseCode)

    {

    TPtrC ptr(aText);

    TUint16 baseCode = aBaseCode;

    while(ptr.Length())

        {

        TInt left = ptr.Find(_L(" "));

        TInt right = ptr.Length() - left - 1;

        if(left == KErrNotFound)

            {

            left = ptr.Length();

            right = 0;

            }

        iTextArray.Append(ptr.Left(left));

        ptr.Set(ptr.Right(right));

        iCodeArray.Append(baseCode++);

        }

    }

TInt CSmileyIcon::VariantCount() const

    {

    return iTextArray.Count();

    }

const TDesC& CSmileyIcon::Text(TInt aVariant) const

    {

    if(aVariant>=0 && aVariant<VariantCount())

        {

        return iTextArray[aVariant];

        }

    else

        {

        return KNullDesC;

        }

    }

TChar CSmileyIcon::Code(TInt aVariant) const

    {

    if(aVariant>=0 && aVariant<VariantCount())

        {

        return iCodeArray[aVariant];

    }

    else

        {

        return 0;

        }

    }

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

// CSmileyTnumbnailAsynLoader

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

CSmileyTnumbnailAsynLoader::CSmileyTnumbnailAsynLoader()

    {

    }

CSmileyTnumbnailAsynLoader::~CSmileyTnumbnailAsynLoader()

    {

    iLoadingTaskArray.Close();

    }

void CSmileyTnumbnailAsynLoader::AddTaskL(CSmileyIcon* aSmileyIcon)

    {

    if(aSmileyIcon)

        {

        TBool isIdel = (TaskCount() == 0);

        iLoadingTaskArray.Append(aSmileyIcon);

        if(isIdel)

            {

            DoNextTaskL();

            }

        }

    }

void CSmileyTnumbnailAsynLoader::DiscardAll()

    {

    iLoadingTaskArray.Reset();

    }

TInt CSmileyTnumbnailAsynLoader::TaskCount() const

    {

    return iLoadingTaskArray.Count();

    }

void CSmileyTnumbnailAsynLoader::DoNextTaskL()

    {

    if(TaskCount() > 0)

        {

        CSmileyIcon* icon = iLoadingTaskArray[0];

        iLoadingTaskArray.Remove(0);

        if(icon->StillImageIsReadyToDraw())

            {

            DoNextTaskL();

            }

        else

            {

            }

        }

    }

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

// CSmileyTextTreeNode

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

NONSHARABLE_CLASS(CSmileyTextTreeNode) : public CBase

    {

public:

    CSmileyTextTreeNode(TChar aChar);

    ~CSmileyTextTreeNode();

    TChar Char() const;

    CSmileyTextTreeNode* AddTreeL(const TDesC& aText, TChar aCode);

    TInt ChildCount() const;

    CSmileyTextTreeNode* Child(TInt aIndex) const;

    CSmileyTextTreeNode* Child(TChar aChar) const;

private:

    CSmileyTextTreeNode* AddChildAscendingL(TChar aChar);

private:

    TChar   iChar;

    typedef CArrayPtrFlat<CSmileyTextTreeNode> CSmileyTextTreeNodeArrayPtrFlat;

    CSmileyTextTreeNodeArrayPtrFlat* iChildArray;

    };

CSmileyTextTreeNode::CSmileyTextTreeNode(TChar aChar) : iChar(aChar)

    {

    }

CSmileyTextTreeNode::~CSmileyTextTreeNode()

    {

    if(iChildArray)

        {

        iChildArray->ResetAndDestroy();

        delete iChildArray;

        }

    }

TChar CSmileyTextTreeNode::Char() const

    {

    return iChar;

    }

CSmileyTextTreeNode* CSmileyTextTreeNode::AddTreeL(const TDesC& aText, TChar aCode)

    {

    TInt length = aText.Length();

    if(length > 0)

        {

        CSmileyTextTreeNode* node = AddChildAscendingL(aText[0]);

        return node->AddTreeL(aText.Right(length-1), aCode);

        }

    else

        {

        return AddChildAscendingL(aCode);

        }

    }

TInt CSmileyTextTreeNode::ChildCount() const

    {

    if(iChildArray)

        {

        return iChildArray->Count();

        }

    else

        {

        return 0;

        }

    }

CSmileyTextTreeNode* CSmileyTextTreeNode::Child(TInt aIndex) const

    {

    if(aIndex>=0 && aIndex<ChildCount())

        {

        return iChildArray->At(aIndex);

        }

    else

        {

        return NULL;

        }

    }

CSmileyTextTreeNode* CSmileyTextTreeNode::Child(TChar aChar) const

    {

    if(iChildArray)

        {

        const TInt KFirstPos = 0;

        const TInt KEndPos = iChildArray->Count() - 1;

        if(aChar<iChildArray->At(KFirstPos)->Char() || aChar>iChildArray->At(KEndPos)->Char())

            {

            return NULL;

            }

        for(TInt i=KEndPos; i>=KFirstPos; i--)

            {

            CSmileyTextTreeNode* node = iChildArray->At(i);

            if(node->Char() == aChar)

                {

                return node;

                }

            }

        }

    return NULL;

    }

CSmileyTextTreeNode* CSmileyTextTreeNode::AddChildAscendingL(TChar aChar)

    {

    // new

    if(!iChildArray)

        {

        iChildArray = new (ELeave) CSmileyTextTreeNodeArrayPtrFlat(1);

        }

    // sequential search

    TInt pos = 0;

    for(; pos<iChildArray->Count(); pos++)

        {

        CSmileyTextTreeNode* node = iChildArray->At(pos);

        TChar character = node->Char();

        if(aChar == character)

            {

            return node;

            }

        else if(aChar < character)

            {

            break;

            }

        }

    CSmileyTextTreeNode* node = new (ELeave) CSmileyTextTreeNode(aChar);

    iChildArray->InsertL(pos, node);

    return node;

    }

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

// CSmileyModel

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

const TUint16 KBaseCode = 0xf880;

//const TUint16 KBaseCodeOff = 0x7FFF;

_LIT(KPlaceHolder, "\xf880i");

CSmileyModel::CSmileyModel(MAknSmileyObserver* aObserver) : iSmileyIconObserver(aObserver)

    {

    }

CSmileyModel::~CSmileyModel()

    {

    ReleaseResource();

    iSmileyIconArray.Close();

    iSmileyCodeIndexArray.Close();

    }

void CSmileyModel::LoadResourceL()

    {

    if(Count() > 0) return;

    // append image resourece

    TResourceReader reader;

    TFileName smileyRscName;

    SmileyUtils::GetCustomizableResPath(smileyRscName, KSmileyRsc);

    TInt offset = CCoeEnv::Static()->AddResourceFileL(smileyRscName);

    CCoeEnv::Static()->CreateResourceReaderLC(reader, R_SMILEY_ICONS_INFO);

    TUint16 codeRef = KBaseCode;

    TInt index = 0;

    iTextSearchTree = new (ELeave) CSmileyTextTreeNode(0);

    TInt count(reader.ReadInt16());

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

        {

        TSmileyIconInfo info;

        TBool isAnimation = (reader.ReadInt16() == 1);

        TInt16 code = reader.ReadInt16();

        TInt bmpId1 = reader.ReadInt32();

        TInt maskId1 = reader.ReadInt32();

        TInt bmpId2 = reader.ReadInt32();

        TInt maskId2 = reader.ReadInt32();

        info.iIndex = index++;

        if(bmpId2 > 0)

            {

            info.iDefaultStillImageID = bmpId2;

            info.iDefaultAnimationImageID = bmpId1;

            }

        else

            {

            info.iDefaultStillImageID = bmpId1;

            info.iDefaultAnimationImageID = 0;

            }