/*
* Copyright (c) 2005 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 "LcdFbsImageCache.h"
#include "CMIDImage.h"
#include "CMIDBitmapImage.h"
#include "LcdImage.h"

/**
 * Copy bitmap data from (aColorBitmap,aAlphaBitmap) to aFbsImage.
 */
extern void CopyBitmapsL
(
    CLcdGraphicsDriver& aDriver,
    CLcdFbsImage&       aFbsImage,
    CFbsBitmap*         aColorBitmap,
    CFbsBitmap*         aAlphaBitmap,
    TBool               aInvertMask
);

TInt CompareImageAddress(const TLcdFbsImageEntry& aLhs, const TLcdFbsImageEntry& aRhs)
{
    return (aLhs.iImage - aRhs.iImage);
}

TBool MatchEntry(const TLcdFbsImageEntry& aLhs, const TLcdFbsImageEntry& aRhs)
{
    return aLhs.iImage       == aRhs.iImage     &&
           aLhs.iColorMode  == aRhs.iColorMode &&
           aLhs.iAlphaMode  == aRhs.iAlphaMode &&
           aLhs.iInvertMask == aRhs.iInvertMask;
}

CLcdFbsImageCache* CLcdFbsImageCache::NewL(CLcdGraphicsDriver& aDriver, TDisplayMode aDefaultColorMode, TDisplayMode aDefaultAlphaMode, TBool aDefaultInverted)
{
    CLcdFbsImageCache* cache = new(ELeave) CLcdFbsImageCache(aDriver);
    cache->iDefaultColorMode = aDefaultColorMode;
    cache->iDefaultAlphaMode = aDefaultAlphaMode;
    cache->iDefaultInverted = aDefaultInverted;
    return cache;
}

CLcdFbsImageCache::CLcdFbsImageCache(CLcdGraphicsDriver& aDriver)
        : iDriver(aDriver)
        , iEntries(8, _FOFF(TLcdFbsImageEntry, iImage))
        , iOrder(CompareImageAddress)
{
}

CLcdFbsImageCache::~CLcdFbsImageCache()
{
    for (TInt i = iEntries.Count(); --i>=0;)
    {
        RemoveEntry(i);
    }
    iEntries.Reset();
    iEntries.Close();
}

TDisplayMode ValidateMode(TInt aMode, TDisplayMode aDefault)
{
    if (aMode == MMIDBitmapImage::EDefaultDisplayMode)
    {
        return aDefault;
    }
    return (TDisplayMode)aMode;
}


/**
 * Gets the primary bitmap representation of this image.
 */
MMIDBitmapImage* CLcdFbsImageCache::GetBitmapImage(MMIDImage* aImage)
{
    TLcdFbsImageEntry example;
    example.iImage      = aImage;
    example.iPrimary    = ETrue;    // not used in Find.
    example.iColorMode  = ENone;
    example.iAlphaMode  = ENone;
    example.iInvertMask = EFalse;
    example.iBitmapRep  = NULL;

    //
    // Get a start point for the search. Assuming that FindInOrder
    // does a binary search of some sort, then it will probably
    // end up in the middle of the range of entries corresponding
    // to aImage. Note that iEntries is sorted by aImage address.
    //
    TInt start = iEntries.FindInOrder(example, iOrder);
    TInt count = iEntries.Count();
    TInt index;

    ASSERT(start >= 0);

    //
    // Search backwards from start point
    //
    for (index=start; index>=0; --index)
    {
        TLcdFbsImageEntry& entry = iEntries[index];
        if (entry.iImage != aImage)
        {
            break;
        }
        if (entry.iPrimary)
        {
            entry.iBitmapRep->AddRef();
            return entry.iBitmapRep;
        }
    }

    //
    // We didn't find it searching backwards - try forwards
    //
    for (index=start+1; index<count; index++)
    {
        TLcdFbsImageEntry& entry = iEntries[index];
        if (entry.iImage != aImage)
        {
            break;
        }
        if (entry.iPrimary)
        {
            entry.iBitmapRep->AddRef();
            return entry.iBitmapRep;
        }
    }

    return NULL;
}

/**
 * Find A bitmap image representation of aImage with color bitmap in displaymode aColorMode, and alpha
 * bitmap (if present) in displaymode aAlphaMode. If aColorMode or aAlphaMode are EDefaultDisplayMode,
 * then this method will select a mode based on the default image pixel format.
 *
 *@return a bitmap image or NULL if no appropriate bitmap representation of aImage exists.
 */
MMIDBitmapImage* CLcdFbsImageCache::GetBitmapImage(MMIDImage* aImage, TInt aColorMode, TInt aAlphaMode, TBool aInvertMask)
{
    TDisplayMode defaultAlphaMode = (aImage->TransparencyType() == MMIDImage::ENone ? ENone : iDefaultAlphaMode);

    TIdentityRelation<TLcdFbsImageEntry> relation(MatchEntry);
    TLcdFbsImageEntry entry;

    entry.iImage      = aImage;
    entry.iColorMode  = ValidateMode(aColorMode, iDefaultColorMode);;
    entry.iAlphaMode  = ValidateMode(aAlphaMode, defaultAlphaMode);
    entry.iInvertMask = aInvertMask;
    entry.iPrimary    = EFalse;
    entry.iBitmapRep  = NULL;

    // linear search starting at
    TInt index = iEntries.Find(entry, relation);
    if (index >= 0)
    {
        MMIDBitmapImage* bitmapRep = iEntries[index].iBitmapRep;
        bitmapRep->AddRef();
        return bitmapRep;
    }

    return NULL;
}


/**
 * Find or create a bitmap image representation of aImage with a color bitmap in displaymode aColorMode and
 * alpha bitmap (if present) in displaymode  aAlphaMode.
 *
 *@return a bitmap image representation.
 *
 * Will leave with one of the system error codes if a bitmap representation does not exist and one cannot
 * be created.
 */
MMIDBitmapImage* CLcdFbsImageCache::GetBitmapImageL(MMIDImage* aImage, TInt aColorMode, TInt aAlphaMode, TBool aInvertMask)
{
    TDisplayMode colorMode = ValidateMode(aColorMode, iDefaultColorMode);

    TDisplayMode defaultAlphaMode = (aImage->TransparencyType() == MMIDImage::ENone ? ENone : iDefaultAlphaMode);

    TDisplayMode alphaMode = ValidateMode(aAlphaMode, defaultAlphaMode);

    MMIDBitmapImage* image = GetBitmapImage(aImage, colorMode, alphaMode, aInvertMask);
    if (NULL == image)
    {
        image = CreateBitmapImageRepLC(*aImage, colorMode, alphaMode, aInvertMask);
        TLcdFbsImageEntry entry;
        entry.iImage      = aImage;
        entry.iPrimary    = EFalse;
        entry.iColorMode  = colorMode;
        entry.iAlphaMode  = alphaMode;
        entry.iInvertMask = aInvertMask;
        entry.iBitmapRep  = image;
        iEntries.InsertInOrderAllowRepeatsL(entry, iOrder);
        image->AddRef();        // 1 for the cache
        CleanupStack::Pop();    // image
        image->AddRef();        // 1 for the caller
    }

    ASSERT(image);
    return image;
}

TDisplayMode BitmapMode(CFbsBitmap* aBitmapOrNull)
{
    TDisplayMode mode = ENone;
    if (aBitmapOrNull)
    {
        mode = aBitmapOrNull->DisplayMode();
    }
    return mode;
}

void CLcdFbsImageCache::RegisterL(MMIDImage* aImage, TBool aInverted, MMIDBitmapImage* aBitmapImageRep)
{
    TLcdFbsImageEntry entry;
    entry.iImage      = aImage;
    entry.iPrimary    = ETrue;
    entry.iColorMode  = BitmapMode(aBitmapImageRep->ColorBitmap());
    entry.iAlphaMode  = BitmapMode(aBitmapImageRep->AlphaBitmap());
    entry.iInvertMask = aInverted;
    entry.iBitmapRep  = aBitmapImageRep;
    iEntries.InsertInOrderAllowRepeatsL(entry, iOrder);
    aBitmapImageRep->AddRef();
}

//
// purge all entries corresponding to aImage.
//
void CLcdFbsImageCache::Purge(MMIDImage* aImage)
{
    TLcdFbsImageEntry entry;
    entry.iImage = aImage;
    TInt index;
    while ((index = iEntries.FindInOrder(entry, iOrder)) >= 0)
    {
        RemoveEntry(index);
    }
}

void CLcdFbsImageCache::RemoveEntry(TInt aIndex)
{
    iEntries[aIndex].iBitmapRep->RemoveRef();
    iEntries.Remove(aIndex);
}

MMIDBitmapImage* CLcdFbsImageCache::CreateBitmapImageRepLC(MMIDImage& aImage, TDisplayMode aColorMode, TDisplayMode aAlphaMode, TBool aInvertMask)
{
    MMIDBitmapImage* bitmapImage = aImage.BitmapImage();
    if (!bitmapImage)
    {
        User::Leave(KErrGeneral);
    }

    CMIDImage& proxy = static_cast<CMIDImage&>(aImage);
    CLcdImage& image = proxy.Image();
    const TSize size = proxy.Size();
    ASSERT(aColorMode != ENone);

    CMIDBitmapImage* bitmapRep = NULL;

    CLcdFbsImage* fbsImage = CLcdFbsImage::NewL(size, aColorMode, aAlphaMode);
    CleanupStack::PushL(fbsImage);
    CopyBitmapsL(iDriver, *fbsImage, bitmapImage->ColorBitmap(), bitmapImage->AlphaBitmap(), aInvertMask);
    bitmapRep = new(ELeave) CMIDBitmapImage(*fbsImage);
    CleanupStack::Pop(fbsImage);
    CleanupStack::PushL(bitmapRep);

    return bitmapRep;
}