#include <AknBidiTextUtils.h>

#include <AknPanic.h>

iDefaultStillImageID(aInfo.iDefaultStillImageID), 

iDefaultAnimationImageID(aInfo.iDefaultAnimationImageID)

    iDefaultStillImageID = 0;

    iDefaultAnimationImageID = 0;

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

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

    self->ConstructL(aInfo);

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)

    delete iStillImage;

    iTextArray.Close();

    if(AnimationImageIsReadyToDraw())

        return iStillImage->Image();

    if(AnimationImageIsReadyToDraw())

        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::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::AddText(const TDesC& aText) // for spliting strings = ":P :p :-P :-p";

    TPtrC ptr(aText);

    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));

        }

    }

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

    {

    if(aVariate>=0 && aVariate<TextVariate())

        {

        return iTextArray[aVariate];

        return KNullDesC;

TInt CSmileyIcon::TextVariate() const

    return iTextArray.Count();

    iLoadingTaskArray.Close();

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

        iLoadingTaskArray.Append(aSmileyIcon);

        if(isIdel)

    iLoadingTaskArray.Reset();

    return iLoadingTaskArray.Count();

    if(TaskCount() > 0)

        CSmileyIcon* icon = iLoadingTaskArray[0];

        iLoadingTaskArray.Remove(0);

        if(icon->StillImageIsReadyToDraw())

            icon->LoadStillImageL(1); // 1 is for asynchronous

    }

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

// CSmileyTextTreeNode

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

NONSHARABLE_CLASS(CSmileyTextTreeNode) : public CBase

    {

public:

    CSmileyTextTreeNode(TChar aChar);

    ~CSmileyTextTreeNode();

    TChar Char() const;

    TChar LastChildChar() const;

    TChar FirstChildChar() const;

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

    TInt ChildCount() const;

    CSmileyTextTreeNode* Child(TInt aIndex) const;

    CSmileyTextTreeNode* Child(TChar aChar) const;

private:

    CSmileyTextTreeNode* AddChildL(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;

    }

TChar CSmileyTextTreeNode::LastChildChar() const

    {

    if(iChildArray)

        {

        TInt index = iChildArray->Count() - 1;

        return iChildArray->At(index)->Char();

        }

    else

        {

        return 0;

        }

    }

TChar CSmileyTextTreeNode::FirstChildChar() const

    {

    if(iChildArray)

        {

        return iChildArray->At(0)->Char();

        }

        return 0;

        }

    }

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

    {

    TInt length = aText.Length();

    if(length > 0)

        {

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

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

        }

    else

        {

        return AddChildL(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)

        {

        for(TInt i=iChildArray->Count()-1; i>=0; i--)

            {

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

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

                {

                return node;

                }

            }

        }

    return NULL;

    }

CSmileyTextTreeNode* CSmileyTextTreeNode::AddChildL(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;

    }

const TUint16 KBaseCodeOn = 0xf880;

const TUint16 KBaseCodeOff = 0x7FFF;

_LIT(KPlaceHolder, "\xf880i");

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

    iBaseCode = KBaseCodeOn;

    TInt index = 0;

    iTextSearchTree = new (ELeave) CSmileyTextTreeNode(0);

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

        TInt code = reader.ReadInt16();

        if(iBaseCode > code) iBaseCode = code;

        info.iIndex = index++;

            info.iDefaultStillImageID = bmpId2;

            info.iDefaultAnimationImageID = bmpId1;