/*
* 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 "CMIDImage.h"
#include "CMIDBitmapImage.h"
#include "LcdImage.h"
#include "LcdFbsImage.h"
#include "LcdFbsImageCache.h"

#ifdef _DEBUG
static const TUint KTransparancyMapCount = 6;
#endif

const MMIDImage::TTransparencyType TransparencyMap[] =
{
    MMIDImage::ENone,       /* ETransparencyNone        */
    MMIDImage::EMask,       /* ETransparencyMaskBitmap  */
    MMIDImage::EAlpha,      /* ETransparencyAlphaBitmap */
    MMIDImage::EAlpha,      /* ETransparencyAlphaChannel*/
    MMIDImage::EMask,       /* ETransparencyMaskChannel */
    MMIDImage::ENone        /* ETransparencyIgnoreChannel */
};


CMIDImage::CMIDImage(CLcdFbsImageCache& aCache, MImageTypeMap& aTypeMap, CLcdImage* aImage)
        : iCache(aCache)
        , iTypeMap(aTypeMap)
        , iImage(aImage)
{
}

void CMIDImage::ConstructL()
{
    RegisterL();
}

void CMIDImage::RegisterL()
{
    CMIDBitmapImage* bitmapImage = new(ELeave) CMIDBitmapImage(*iImage->FbsImage());
    CleanupStack::PushL(bitmapImage);
    iCache.RegisterL(this, EFalse, bitmapImage);
    CleanupStack::Pop(bitmapImage);
}

CMIDImage::~CMIDImage()
{
    iCache.Purge(this);
    delete iImage;
}

MMIDImage::TTransparencyType
CMIDImage::TransparencyType() const
{
    TTransparency transparency = iImage->Transparency();

    ASSERT(0 <= transparency && transparency < KTransparancyMapCount);

    return TransparencyMap[transparency];
}

TInt CMIDImage::SetTransparencyType(TTransparencyType aType)
{
    if (TransparencyType() == aType)
    {
        return KErrNone;
    }

    if (aType != MMIDImage::EAlpha)
    {
        //
        // Only support switch to alpha for transparent mutable images.
        // Fail all other cases.
        //
        return KErrNotSupported;
    }

    //
    // Set new image type and fixup cache entries. Iff any of these steps
    // fail the image may be left in an inconsistent state. It is anticipated
    // that SetTransparencyType will be called once only during transparent
    // mutable image construction (the only supported use case). Hence
    // transactional error handling not required as failure will result in
    // immediate destruction of the image.
    //
    TInt err = iImage->SetImageType(iTypeMap.GetImageType(aType));
    if (0 == err)
    {
        iCache.Purge(this);
        TRAP(err, RegisterL());
    }

    return err;
}

TInt CMIDImage::CopyRegion
(
    MMIDImage*          aSource,
    const TRect&        aRect,
    TInt                aTransform
)
{
    CMIDImage& proxy = *static_cast<CMIDImage*>(aSource);
    CLcdImage& source = proxy.Image();
    CLcdImage& target = Image();

    TDrawRegion region;
    TRect       clipRect(target.Size());    // clip to target, not source.

    region.iAnchor    = EAnchorTop|EAnchorLeft;
    region.iDstPoint  = TPoint();
    region.iSrcRect   = aRect;
    region.iTransform = aTransform;

    target.CopyRegion(source, region, clipRect);

    return KErrNone;
}

TInt CMIDImage::SetPixels
(
    const TUint32*  aPixelBuffer,
    TInt            aLength,
    TInt            aOffset,
    TInt            aScanLength,
    const TRect&    aRect,
    TBool           aProcessAlpha
)
{
    iImage->SetPixels(aRect, aPixelBuffer, aLength, aOffset, aScanLength, aRect.Size(), aProcessAlpha);
    return KErrNone;
}

TInt CMIDImage::GetPixels
(
    TUint32*        aPixelBuffer,
    TInt            aLength,
    TInt            aOffset,        // in words
    TInt            aScanLength,
    const TRect&    aRect
)
{
    iImage->GetPixels(aRect, aPixelBuffer, aLength, aOffset, aScanLength, aRect.Size());
    return KErrNone;
}

void CMIDImage::Dispose()
{
    delete this;
}

MMIDComponent::TType CMIDImage::Type() const
{
    return EImage;
}

TSize CMIDImage::Size() const
{
    return iImage->Size();
}

CLcdImage& CMIDImage::Image() const
{
    return *iImage;
}

TBool CMIDImage::DetectCollision
(
    const TRect& aRect1, TInt aTransform1, const TPoint& aPoint1,
    MMIDImage* aImage2,
    const TRect& aRect2, TInt aTransform2, const TPoint& aPoint2
)
{
    CMIDImage& proxy = *static_cast<CMIDImage*>(aImage2);
    CLcdImage& image2 = proxy.Image();

    return iImage->DetectCollision
           (
               aRect1,
               aTransform1,
               aPoint1,
               image2,
               aRect2,
               aTransform2,
               aPoint2
           );
}

/**
 *@return the primary mode bitmap representation of this image - i.e. the representation
 * that Graphics would render from or to, as opposed to the representation used by
 * high level components such as Form Items.
 *
 * IMPROVEMENT: consider keeping pointer to the CMIDBitmapImage instance constructed in
 * RegisterL() and return that here since it will always be the primary representation.
 */
MMIDBitmapImage* CMIDImage::BitmapImage()
{
    return (MMIDBitmapImage*)iCache.GetBitmapImage(this);
}

MMIDBitmapImage* CMIDImage::BitmapImage(TInt aColorMode, TInt aAlphaMode, TBool aInvert)
{
    return (MMIDBitmapImage*)iCache.GetBitmapImage(this, aColorMode, aAlphaMode, aInvert);
}

MMIDBitmapImage* CMIDImage::BitmapImageL(TInt aColorMode, TInt aAlphaMode, TBool aInvert)
{
    return (MMIDBitmapImage*)iCache.GetBitmapImageL(this, aColorMode, aAlphaMode, aInvert);
}