/*

* Copyright (c) 2006-2007 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:  Wrapper for converter used for drawing to Canvas or Image.

*

*/

//  INCLUDE FILES

#include "CMIDNativeConverter.h"

#include "CMIDConvertFactory.h"

const TInt KAlphaShift = 8;

CMIDNativeConverter::CMIDNativeConverter()

{

    iDefaultConverter = TMID8888Format();

    iAlphaMode = ENone;

}

CMIDNativeConverter::~CMIDNativeConverter()

{

    delete iNativeFormat;

}

CMIDNativeConverter* CMIDNativeConverter::NewL(const TMIDBitmapParameters& aParameters)

{

    CMIDNativeConverter* self = new(ELeave)CMIDNativeConverter;

    CleanupStack::PushL(self);

    self->ConstructL(aParameters);

    CleanupStack::Pop(self);

    return self;

}

void CMIDNativeConverter::ConstructL(const TMIDBitmapParameters& aParameters)

{

    iAlphaBitmap = aParameters.iAlpha;

    iAlphaMode = aParameters.iAlphaMode;

    iScanlength = aParameters.iScanLength;

    iNativeFormat = CMIDConvertFactory::NewConverterL(aParameters.iFormat);

    iNativeFormat->InitializeL(aParameters);

}

void CMIDNativeConverter::Convert(TMIDInternalARGB& aResult, TUint32 aColor) const

{

    iDefaultConverter.Convert(aResult, aColor);

}

void CMIDNativeConverter::GetPixel(TMIDInternalARGB& aResult) const

{

    if (iNativeFormat->IsAlpha())

    {

        iNativeFormat->GetPixelWithAlpha(aResult);

    }

    iNativeFormat->GetPixel(aResult);

}

void CMIDNativeConverter::PlotPixel(const TMIDInternalARGB& aInternal)

{

    iNativeFormat->PlotPixel(aInternal);

}

void CMIDNativeConverter::PlotPixelWithAlpha(const TMIDInternalARGB& aInternal)

{

    if (aInternal.iA == KAlphaFullTransparent)

    {

        // totally transparent, no need to do anything

        return;

    }

    if (aInternal.iA == KAlphaFullOpaque)

    {

        iNativeFormat->PlotPixel(aInternal);

    }

    else

    {

        // calculating partial transparency

        TMIDInternalARGB alphaPixel = aInternal;

        TMIDInternalARGB belowPixel;

        iNativeFormat->GetPixel(belowPixel);

        CalculateAlpha(alphaPixel, belowPixel);

        iNativeFormat->PlotPixel(alphaPixel);

    }

}

void CMIDNativeConverter::PlotPixelWithAlphaBitmap(const TMIDInternalARGB& aInternal)

{

    if (aInternal.iA == KAlphaFullTransparent)

    {

        // totally transparent, no need to do anything

        return;

    }

    if (aInternal.iA == KAlphaFullOpaque)

    {

        iNativeFormat->PlotPixelWithAlpha(aInternal);

    }

    else

    {

        // calculating partial transparency

        TMIDInternalARGB alphaPixel = aInternal;

        TMIDInternalARGB belowPixel;

        iNativeFormat->GetPixel(belowPixel);

        CalculateAlpha(alphaPixel, belowPixel);

        iNativeFormat->PlotPixelWithAlpha(alphaPixel);

    }

}

void CMIDNativeConverter::SetBitmaps(TUint32* aBitmap)

{

    iNativeFormat->SetBitmap(aBitmap);

}

void CMIDNativeConverter::SetDrawRect(TRect aDrawRect)

{

    iDrawRect = aDrawRect;

    iPosition = aDrawRect.iTl;

    iNativeFormat->iOffset = iDrawRect.iTl.iX + iDrawRect.iTl.iY * iScanlength;

}

void CMIDNativeConverter::PlotPixel(const TPoint& aPos,

                                    const TMIDInternalARGB& aInternal, const TRect& aClip)

{

    // is in clip rect

    if (aClip.Contains(aPos))

    {

        iNativeFormat->iOffset = aPos.iX + aPos.iY * iScanlength;

        PlotPixelWithAlphaBitmap(aInternal);

    }

}

void CMIDNativeConverter::DrawScanLine(TPoint aPos, TInt aLength,

                                       const TMIDInternalARGB& aInternal, const TRect& aClip)

{

    if ((aPos.iY < aClip.iTl.iY) ||

            (aPos.iY >= aClip.iBr.iY)||

            (aPos.iX > aClip.iBr.iX))

    {

        return;

    }

    if (aPos.iX > aClip.iBr.iX)

    {

        return;

    }

    if (aPos.iX < aClip.iTl.iX)

    {

        aLength -= aClip.iTl.iX - aPos.iX;

        aPos.iX = aClip.iTl.iX;

    }

    if (aPos.iX + aLength > aClip.iBr.iX)

    {

        aLength = aClip.iBr.iX - aPos.iX;

    }

    iNativeFormat->iOffset = aPos.iX + aPos.iY * iScanlength;

    for (TInt i = 0; i < aLength; i++)

    {

        PlotPixelWithAlphaBitmap(aInternal);

        ++(iNativeFormat->iOffset);

    }

}

void CMIDNativeConverter::CalculateAlpha(TMIDInternalARGB& aTargetColor,

        const TMIDInternalARGB& aBelowColor)

{

    TInt alphaBelow(KAlphaFullOpaque - aTargetColor.iA + 1);

    TInt alpha(aTargetColor.iA);

    if (aBelowColor.iA + aTargetColor.iA > KAlphaFullOpaque)

    {

        aTargetColor.iA = KAlphaFullOpaque;

    }

    else

    {

        aTargetColor.iA = (TUint8)(aBelowColor.iA + aTargetColor.iA);

    }

    aTargetColor.iR = (TUint8)((aBelowColor.iR * alphaBelow +

                                aTargetColor.iR * alpha) >> KAlphaShift);

    aTargetColor.iG = (TUint8)((aBelowColor.iG * alphaBelow +

                                aTargetColor.iG * alpha) >> KAlphaShift);

    aTargetColor.iB = (TUint8)((aBelowColor.iB * alphaBelow +

                                aTargetColor.iB * alpha) >> KAlphaShift);

}

TBool CMIDNativeConverter::HasAlphaBitmap()

{

    return iNativeFormat->IsAlpha();

}