/*
* 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 "LcdImage.h"
#include <lcdgdrv.h>
#include "fbslcdgraphics.h"
#include "LcdFbsImage.h"

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

CLcdImage::CLcdImage(CLcdGraphicsDriver& aDriver, TBool aMutable)
        : iDriver(aDriver)
        , iFbsImage(NULL)
        , iMutable(aMutable)
{
}

CLcdImage::~CLcdImage()
{
    if (iFbsImage)
    {
        iFbsImage->RemoveRef();
    }
}

void CLcdImage::ConstructL(const TSize& aSize, const TImageType& aImageType)
{
    ASSERT(NULL == iFbsImage);
    ASSERT(aSize.iWidth  > 0);
    ASSERT(aSize.iHeight > 0);

    iFbsImage = CLcdFbsImage::NewL(aSize, aImageType.iColorMode, aImageType.iAlphaMode);
    iFbsImage->AddRef();
    iTransparency = aImageType.iTransparency;
}

/**
 * 2nd phase constructor from bitmap(s)
 *
 * Where possible, make a shallow copy (Duplicate) of aColorBitmap and optional aAlphaBitmap,
 * if that is not possible because the bitmaps do not match the desired image type, make a
 * deep copy.
 */
void CLcdImage::ConstructL(CFbsBitmap* aColorBitmap, CFbsBitmap* aAlphaBitmap, const TImageType& aImageType)
{
    ASSERT(NULL == iFbsImage);

    TDisplayMode colorMode = aColorBitmap->DisplayMode();
    TDisplayMode alphaMode = aAlphaBitmap ? aAlphaBitmap->DisplayMode() : ENone;

    if ((colorMode == aImageType.iColorMode) && (alphaMode == aImageType.iAlphaMode))
    {
        // modes match - just duplicate.
        iFbsImage = CLcdFbsImage::NewL(aColorBitmap, aAlphaBitmap);
        iFbsImage->AddRef();
    }
    else
    {
        iFbsImage = CLcdFbsImage::NewL(aColorBitmap->SizeInPixels(), aImageType.iColorMode, aImageType.iAlphaMode);
        iFbsImage->AddRef();
        CopyBitmapsL(iDriver, *iFbsImage, aColorBitmap, aAlphaBitmap, EFalse);
    }

    iTransparency = aImageType.iTransparency;
}

TTransparency CLcdImage::Transparency() const
{
    return iTransparency;
}

TSize CLcdImage::Size() const
{
    return iFbsImage->Size();
}

void CLcdImage::CopyRegion(CLcdImage& aSource, const TDrawRegion& aRegion, const TRect& aClipRect)
{
    TTransparency dstTransparency = Transparency();
    TTransparency srcTransparency = aSource.Transparency();

    TInt error = TFbsLcdGraphics::CopyRegion
                 (
                     iDriver,
                     iFbsImage->ColorBitmap(),
                     iFbsImage->AlphaBitmap(),
                     dstTransparency,
                     aSource.iFbsImage->ColorBitmap(),
                     aSource.iFbsImage->AlphaBitmap(),
                     srcTransparency,
                     aRegion,
                     aClipRect
                 );

    ASSERT(error==KErrNone);
}

void CLcdImage::SetPixels
(
    const TRect&    aRect,
    const TUint32*  aPixels,
    TInt            aLength,
    TInt            aOffset,
    TInt            aScanLength,
    const TSize&    aSize,
    TBool           aProcessAlpha
)
{
    TInt error = TFbsLcdGraphics::SetPixels
                 (
                     iDriver,
                     iFbsImage->ColorBitmap(),
                     iFbsImage->AlphaBitmap(),
                     iTransparency,
                     aRect,
                     aPixels,
                     aLength,
                     aOffset,
                     aScanLength,
                     aSize,
                     aProcessAlpha
                 );

    ASSERT(error == KErrNone);
}

void CLcdImage::GetPixels
(
    const TRect&    aRect,
    TUint32*        aPixels,
    TInt            aLength,
    TInt            aOffset,
    TInt            aScanLength,
    const TSize&    aSize
)
{
    TInt error = TFbsLcdGraphics::GetPixels
                 (
                     iDriver,
                     iFbsImage->ColorBitmap(),
                     iFbsImage->AlphaBitmap(),
                     iTransparency,
                     aRect,
                     aPixels,
                     aLength,
                     aOffset,
                     aScanLength,
                     aSize
                 );

    ASSERT(error == KErrNone);
}

TBool CLcdImage::DetectCollision
(
    const TRect&        aRect1,
    TInt                aTransform1,
    const TPoint&       aPoint1,
    const CLcdImage&    aImage2,
    const TRect&        aRect2,
    TInt                aTransform2,
    const TPoint&       aPoint2
)
{
    TTransparency transparency1 = iTransparency;
    CFbsBitmap* alphaBitmap1 = iFbsImage->AlphaBitmap();
    if (transparency1 == ETransparencyAlphaChannel || transparency1 == ETransparencyMaskChannel)
    {
        alphaBitmap1 = iFbsImage->ColorBitmap();
    }

    TTransparency transparency2 = aImage2.iTransparency;
    CFbsBitmap* alphaBitmap2 = aImage2.iFbsImage->AlphaBitmap();
    if (transparency2 == ETransparencyAlphaChannel || transparency2 == ETransparencyMaskChannel)
    {
        alphaBitmap2 = aImage2.iFbsImage->ColorBitmap();
    }

    return TFbsLcdGraphics::DetectCollision
           (
               iDriver,
               alphaBitmap1,
               iTransparency,
               Size(),
               aRect1,
               aTransform1,
               aPoint1,
               alphaBitmap2,
               aImage2.Transparency(),
               aImage2.Size(),
               aRect2,
               aTransform2,
               aPoint2
           );
}


void CLcdImage::Lock(TBitmapLockCount& aCount, TAcceleratedBitmapInfo& aColorBitmap, TAcceleratedBitmapInfo& aAlphaBitmap) const
{
    CFbsBitmap* colorBitmap = iFbsImage->ColorBitmap();
    CFbsBitmap* alphaBitmap = iFbsImage->AlphaBitmap();

    TAcceleratedBitmapSpec color(colorBitmap);
    TAcceleratedBitmapSpec alpha;
    if (alphaBitmap)
    {
        alpha = TAcceleratedBitmapSpec(alphaBitmap);
    }

    color.Lock(aCount);
    color.GetInfo(aColorBitmap);
    if (alphaBitmap)
    {
        alpha.Lock(aCount);
        alpha.GetInfo(aAlphaBitmap);
    }
    else
    {
        Mem::FillZ(&aAlphaBitmap, sizeof(TAcceleratedBitmapInfo));
    }
}

void CLcdImage::Unlock(TBitmapLockCount& aCount) const
{
    CFbsBitmap* colorBitmap = iFbsImage->ColorBitmap();
    CFbsBitmap* alphaBitmap = iFbsImage->AlphaBitmap();

    if (alphaBitmap)
    {
        TAcceleratedBitmapSpec alpha(alphaBitmap);
        alpha.Unlock(aCount);
    }

    TAcceleratedBitmapSpec color(colorBitmap);
    color.Unlock(aCount);
}

TBool CLcdImage::Mutable()
{
    return iMutable;
}

/**
 * Temporary
 */
CLcdFbsImage* CLcdImage::FbsImage()
{
    return iFbsImage;
}

TInt CLcdImage::SetImageType(const TImageType& aType)
{
    //
    // We only support changing from no-transparency images.
    //
    if (iTransparency != ETransparencyNone)
    {
        return KErrNotSupported;
    }

    ASSERT(NULL == iFbsImage->AlphaBitmap());

    CFbsBitmap* colorBitmap = iFbsImage->ColorBitmap();
    TDisplayMode colorMode  = colorBitmap->DisplayMode();

    TInt err = KErrNotSupported;
    if ((colorMode == aType.iColorMode) && (aType.iTransparency == ETransparencyAlphaBitmap))
    {
        //
        // We are just adding an alpha bitmap.
        //
        TRAP(err, iFbsImage->CreateAlphaBitmapL());
    }
    else if ((colorMode == EColor16MU) && (aType.iColorMode == EColor16MA) && (aType.iTransparency == ETransparencyAlphaChannel))
    {
        //
        // Switch from EColor16MU to EColor16MA mode.
        //
        err = colorBitmap->SetDisplayMode(EColor16MA);
    }

    if (0 == err)
    {
        iTransparency = aType.iTransparency;
    }

    return err;
}