/*

* Copyright (c) 2005-2006 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:  Render context implementation

*

*/

// INCLUDE FILES

#include <eikenv.h> // CCoeEnv

#include "CMIDGraphics.h"

#include "CM2GRenderContext.h"

#include "MM2GSVGProxy.h"

M2G_NS_START

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

/* static */ const TReal32       MM2GRenderContext::KFullOpaque             = 1.0;

/* static */

const TReal32       MM2GRenderContext::KFullTransparency       = 0.0;

/* static */

const TUint8        MM2GRenderContext::KMaxAlphaValue          = 255;

/* static */

const TDisplayMode  MM2GRenderContext::KDefaultDisplayMode     = EColor16MA;

/* static */

const TDisplayMode  MM2GRenderContext::KMaskDisplayMode        = EGray256;

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// -----------------------------------------------------------------------------

// CM2GRenderContext::CM2GRenderContext

// -----------------------------------------------------------------------------

CM2GRenderContext::CM2GRenderContext()

        : CBase(),

        iProxy(NULL),

        iEngineHandle(M2G_INVALID_HANDLE),

        iAlpha(MM2GRenderContext::KFullOpaque),

        iScaledAlpha(MM2GRenderContext::KMaxAlphaValue),

        iMaskBmp(NULL),

        iTargetBmp(NULL),

        iImgBmp(NULL)

{

    M2G_DEBUG_0("M2G_DEBUG: CM2GRenderContext::CM2GRenderContext");

}

// -----------------------------------------------------------------------------

// CM2GRenderContext::NewL

// -----------------------------------------------------------------------------

CM2GRenderContext* CM2GRenderContext::NewL(MM2GSVGProxy* aProxy)

{

    M2G_DEBUG_0("M2G_DEBUG: CM2GRenderContext::NewL()");

    CM2GRenderContext* self = new(ELeave) CM2GRenderContext;

    CleanupStack::PushL(self);

    self->ConstructL(aProxy);

    CleanupStack::Pop();

    return self;

}

// -----------------------------------------------------------------------------

// CM2GRenderContext::~CM2GRenderContext

// -----------------------------------------------------------------------------

CM2GRenderContext::~CM2GRenderContext()

{

    M2G_DEBUG_2("M2G_DEBUG: CM2GRenderContext::~CM2GRenderContext() - proxy=%d, engine=%d", iProxy, iEngineHandle);

    if ((iEngineHandle != M2G_INVALID_HANDLE) && (iProxy != NULL))

    {

        TRAP_IGNORE(iProxy->DeleteSvgEngineL(iEngineHandle));

    }

    delete iImgBmp;

    delete iMaskBmp;

    iFbsSession.Disconnect();

}

// -----------------------------------------------------------------------------

// CM2GRenderContext::BindL

// -----------------------------------------------------------------------------

void CM2GRenderContext::BindL(TInt& aTargetHandle, TBool aUiToolKit)

{

    M2G_DEBUG_0("M2G_DEBUG: CM2GRenderContext::BindL()");

    if (!aUiToolKit)

    {

        // Current Ui Toolkit is LCDUI

        // Set target graphics bitmap

        CMIDGraphics* graphics = MIDUnhand<CMIDGraphics>(aTargetHandle);

        iTargetBmp = graphics->Bitmap();

        User::LeaveIfNull(iTargetBmp);

#ifdef RD_JAVA_NGA_ENABLED

        iTargetCanvas = graphics->GetTargetCanvas();        

#endif // RD_JAVA_NGA_ENABLED

    }

    // initialize the svg image bitmap (on which we will render later during RenderL())

    InitImageBitmapL();

}

// -----------------------------------------------------------------------------

// CM2GRenderContext::GetImgHandleL

// -----------------------------------------------------------------------------

TM2GBitmapHandle CM2GRenderContext::GetImgHandleL() const

{

    User::LeaveIfNull(iImgBmp);

    return REINTERPRET_CAST(TM2GBitmapHandle, iImgBmp);

}

// -----------------------------------------------------------------------------

// CM2GRenderContext::InitImageBitmapL

// -----------------------------------------------------------------------------

void CM2GRenderContext::InitImageBitmapL()

{

    M2G_DEBUG_0("M2G_DEBUG: CM2GRenderContext::InitImageBitmapL() - begin");

    // get the screen size

    TSize screenSize = CEikonEnv::Static()->ScreenDevice()->SizeInPixels();

    if (iImgBmp == NULL || (iImgBmp && iImgBmp->SizeInPixels() != screenSize))

    {

        M2G_DEBUG_2("M2G_DEBUG: CM2GRenderContext::InitImageBitmapL() - new bitmap: w=%d, h=%d", screenSize.iWidth, screenSize.iHeight);

        // Create a new svg surface if first time

        // or the size of the screen is different than the actual buffer size

        delete iImgBmp;

        iImgBmp = NULL;

        iImgBmp = new(ELeave) CFbsBitmap();

        User::LeaveIfError(

            iImgBmp->Create(screenSize, KDefaultDisplayMode));

    }

    M2G_DEBUG_0("M2G_DEBUG: CM2GRenderContext::InitImageBitmapL() - end");

}

// -----------------------------------------------------------------------------

// CM2GRenderContext::InitMaskL

// -----------------------------------------------------------------------------

void CM2GRenderContext::InitMaskL(TSize aSize)

{

    M2G_DEBUG_2("M2G_DEBUG: CM2GRenderContext::InitMaskL( w=%d, h=%d ) - begin", aSize.iWidth, aSize.iHeight);

    if (iMaskBmp == NULL || (iMaskBmp && iMaskBmp->SizeInPixels() != aSize))

    {

        // Create a new mask but first delete the previous one if allocated

        delete iMaskBmp;

        iMaskBmp = NULL;

        M2G_DEBUG_0(" M2G_DEBUG: >CM2GRenderContext::InitMaskL() creates new mask ");

        iMaskBmp = new(ELeave) CFbsBitmap();

        User::LeaveIfError(

            iMaskBmp->Create(aSize, KMaskDisplayMode));

    }

    User::LeaveIfNull(iMaskBmp);

    // Mask is filled with the current alpha factor

    FillBitmapL(iMaskBmp, iScaledAlpha);

    M2G_DEBUG_0("M2G_DEBUG: CM2GRenderContext::InitMaskL() - end");

}

// -----------------------------------------------------------------------------

// CM2GRenderContext::ReleaseL

// -----------------------------------------------------------------------------

void CM2GRenderContext::ReleaseL()

{

    M2G_DEBUG_0("M2G_DEBUG: CM2GRenderContext::ReleaseL() - begin");

    iTargetBmp = NULL;

#ifdef RD_JAVA_NGA_ENABLED

    iTargetCanvas = NULL;        

#endif // RD_JAVA_NGA_ENABLED

    M2G_DEBUG_0("M2G_DEBUG: CM2GRenderContext::ReleaseL() - end");

}

// -----------------------------------------------------------------------------

// CM2GRenderContext::RenderL

// -----------------------------------------------------------------------------

void CM2GRenderContext::RenderLCDUIL(

    TM2GSvgDocumentHandle& aSvgDocHandle,

    const TReal32 aCurrentTime,

    TInt aSvgW, TInt aSvgH,

    TM2GRenderRect& aRect

)

{

    // prepare viewbox

    TRect viewbox;

    TPoint anchor;

    PrepareViewbox(aRect, aSvgW, aSvgH, viewbox, anchor);

    RenderLCDUIL(aSvgDocHandle, aCurrentTime, viewbox, anchor);

#ifdef RD_JAVA_NGA_ENABLED

    if (iTargetCanvas && iTargetCanvas->IsEglAvailable())

    {

        iTargetCanvas->UpdateRect(TRect(anchor, viewbox.Size()));

    }

#endif // RD_JAVA_NGA_ENABLED

}

// -----------------------------------------------------------------------------

void CM2GRenderContext::RenderESWTL(

    TM2GSvgDocumentHandle& aSvgDocHandle,

    const TReal32 aCurrentTime,

    TInt aSvgW, TInt aSvgH,

    TM2GRenderRect& aRect,

    MSwtClient* aClientHandle,

    TBool aUseNativeClear,

    TInt* aReturnData)

{

    // prepare viewbox

    TRect viewbox;

    TPoint anchor;

    PrepareViewbox(aRect, aSvgW, aSvgH, viewbox, anchor);

    aReturnData[0] = 0;

    aReturnData[1] = 0;

    aReturnData[2] = 0;

    aReturnData[3] = 0;

    aReturnData[4] = anchor.iX;

    aReturnData[5] = anchor.iY;

    aReturnData[6] = viewbox.iTl.iX;

    aReturnData[7] = viewbox.iTl.iY;

    aReturnData[8] = viewbox.Width();

    aReturnData[9] = viewbox.Height();

    RenderESWTL(aSvgDocHandle, aCurrentTime, viewbox, anchor, aClientHandle, aUseNativeClear, aReturnData);

    return;

}

// CM2GRenderContext::SetRenderingQualityL

// -----------------------------------------------------------------------------

void CM2GRenderContext::SetRenderingQualityL(TInt aMode)

{

    M2G_DEBUG_0("M2G_DEBUG: CM2GRenderContext::SetRenderingQualityL()");

    User::LeaveIfNull(iProxy);

    iProxy->RenderQualityL(iEngineHandle, aMode);

}

// -----------------------------------------------------------------------------

// CM2GRenderContext::SetTransparencyL

// -----------------------------------------------------------------------------

void CM2GRenderContext::SetTransparency(TReal32 aAlpha)

{

    iAlpha = aAlpha;

    iScaledAlpha = STATIC_CAST(TUint8, (aAlpha * MM2GRenderContext::KMaxAlphaValue));

}

// -----------------------------------------------------------------------------

// CM2GRenderContext::ConstructL

// -----------------------------------------------------------------------------

void CM2GRenderContext::ConstructL(MM2GSVGProxy* aProxy)

{

    // Init member variables

    SetTransparency(MM2GRenderContext::KFullOpaque);

    M2G_DEBUG_0("M2G_DEBUG: CM2GRenderContext::ConstructL() - begin");

    if (aProxy)

    {

        iProxy = aProxy;

        iProxy->CreateSvgEngineL(iEngineHandle);

        M2G_DEBUG_2("M2G_DEBUG: CM2GRenderContext::ConstructL() - proxy: %d, new engine: %d", iProxy, iEngineHandle);

    }

    else

    {

        M2G_DEBUG_0("M2G_DEBUG: CM2GRenderContext::ConstructL() - proxy is invalid");

        M2G_THROW(KM2GArgNotOk);

    }

    User::LeaveIfError(iFbsSession.Connect());

    M2G_DEBUG_0("M2G_DEBUG: CM2GRenderContext::ConstructL() - end");

}

// -----------------------------------------------------------------------------

// CM2GRenderContext::PrepareViewbox

// -----------------------------------------------------------------------------

void CM2GRenderContext::PrepareViewbox(

    TM2GRenderRect& aRr,

    TInt aSvgW, TInt aSvgH,

    TRect& aViewbox, TPoint& aAnchor)

{

    M2G_DEBUG_6("M2G_DEBUG: CM2GRenderContext::PrepareViewbox() cX=%d, cY=%d, cW=%d, cH=%d, anchorX=%d, anchorY=%d - begin", aRr.GetClipX(), aRr.GetClipY(), aRr.GetClipW(), aRr.GetClipH(), aRr.GetAnchorX(), aRr.GetAnchorY());

    // Create an anchor point and an svg render area rect

    aAnchor.SetXY(aRr.GetAnchorX(), aRr.GetAnchorY());

    aViewbox.SetRect(aAnchor, TSize(aSvgW, aSvgH));

    // NOTE: It's already verified in Java side that the SVG render area and

    // the clip area intersects each other

    aViewbox.Intersection(aRr);

    // Check if the clip rect has changes the svg rect

    if (aViewbox.iTl != aAnchor)

    {

        // Update anchor position

        TPoint oldAnchor(aAnchor);

        aAnchor = aViewbox.iTl;

        // Update svg rect

        aViewbox.Move((-oldAnchor.iX), (-oldAnchor.iY));

    }

    else

    {

        // The clip rect has not changed the svg rect. Only the

        // anchor position need to be updated

        aViewbox.Move(-aAnchor.iX, -aAnchor.iY);

    }

    M2G_DEBUG_0("M2G_DEBUG: CM2GRenderContext::PrepareViewbox() - end");

}

// -----------------------------------------------------------------------------

// CM2GRenderContext::RenderL

// -----------------------------------------------------------------------------

/**

 * @see CBitmapContext::BitBltMasked()

 * @note CBitmapContext::BitBltMasked() does alpha blending if the provided mask is 256 and not null,

 * and simply blits otherwise

 */

void CM2GRenderContext::RenderLCDUIL(

    TM2GSvgDocumentHandle& aSvgDocHandle,

    TReal32 aCurrentTime,

    const TRect& aViewbox,

    const TPoint& aAnchor

)

{

    M2G_DEBUG_4("M2G_DEBUG: CM2GRenderContext::RenderL() viewbox: x=%d, y=%d, w=%d, h=%d begin", aViewbox.iTl.iX, aViewbox.iTl.iY, aViewbox.Size().iWidth, aViewbox.Size().iHeight);

    // No need to render if content is fully transparency (i.e. alpha=0)

    if (iScaledAlpha == 0)

    {

        return;

    }

    // 0: clear the previous rendered image

    ClearBitmapL(iImgBmp);

    // 1: render the svg document on the iImgBmp

    iProxy->RenderDocumentL(

        iEngineHandle,

        aSvgDocHandle,

        GetImgHandleL(), NULL, aCurrentTime);

    CFbsBitmap* mask = NULL;

    // 2: calculate mask if alpha-blending is used

    if (iScaledAlpha < MM2GRenderContext::KMaxAlphaValue)

    {

        // mask is always the same size as the viewbox

        CreateAlphaBlendMaskL(aViewbox.Size());

        mask = iMaskBmp; // use this mask for alpha blending

    }

    // 3: blit the rendered image on the target bitmap

    // it will do alpha blending when mask is not null

    M2GBitmapUtils::BitBlt(*iTargetBmp,

                           *iImgBmp,

                           aAnchor,

                           &aViewbox,

                           mask);

    M2G_DEBUG_0("M2G_DEBUG: CM2GRenderContext::RenderL() end");

}

// -----------------------------------------------------------------------------

void CM2GRenderContext::RenderESWTL(

    TM2GSvgDocumentHandle& aSvgDocHandle,

    TReal32 aCurrentTime,

    const TRect& aViewbox,

    const TPoint& aAnchor,

    MSwtClient* /*aClientHandle*/,

    TBool /*aUseNativeClear*/,

    TInt* aReturnData)

{

    M2G_DEBUG_4("M2G_DEBUG: CM2GRenderContext::RenderL() viewbox: x=%d, y=%d, w=%d, h=%d begin", aViewbox.iTl.iX, aViewbox.iTl.iY, aViewbox.Size().iWidth, aViewbox.Size().iHeight);

    // No need to render if content is fully transparency (i.e. alpha=0)

    if (iScaledAlpha == 0)

    {

        return;

    }

    // 0: clear the previous rendered image

    ClearBitmapL(iImgBmp);

    // 1: render the svg document on the iImgBmp

    iProxy->RenderDocumentL(

        iEngineHandle,

        aSvgDocHandle,

        GetImgHandleL(), NULL, aCurrentTime);

    CFbsBitmapHack* tempImgBmp = new(ELeave) CFbsBitmapHack();

    tempImgBmp->Create(aViewbox.Size(), iImgBmp->DisplayMode());

    ClearBitmapL(tempImgBmp);

    M2GBitmapUtils::BitBlt(*tempImgBmp,

                           *iImgBmp,

                           aAnchor,

                           &aViewbox,

                           NULL);

    aReturnData[0] = tempImgBmp->Handle();

    aReturnData[1] = tempImgBmp->GetMyHandle();

    tempImgBmp = NULL;

    // 2: calculate mask if alpha-blending is used

    if (iScaledAlpha < MM2GRenderContext::KMaxAlphaValue)

    {

        // mask is always the same size as the viewbox

        CreateAlphaBlendMaskL(aViewbox.Size());

        if (iMaskBmp)

        {

            CFbsBitmapHack* tempMaskBmp = new(ELeave) CFbsBitmapHack();

            tempMaskBmp->Create(aViewbox.Size(), iMaskBmp->DisplayMode());

            ClearBitmapL(tempMaskBmp);

            M2GBitmapUtils::BitBlt(*tempMaskBmp,

                                   *iMaskBmp,

                                   aAnchor,

                                   &aViewbox,

                                   NULL);

            aReturnData[2] = tempMaskBmp->Handle();

            aReturnData[3] = tempMaskBmp->GetMyHandle();

            tempMaskBmp = NULL;

        }

    }

    // Is this needed ??

    //iImgBmp = NULL;

    //iMaskBmp = NULL;

    M2G_DEBUG_0("M2G_DEBUG: CM2GRenderContext::RenderL() end");

}

// CM2GRenderContext::CreateAlphaBlendMask

// -----------------------------------------------------------------------------

/**

 * <li> mask is initialized with iScaledAlpha for all pixels.

 * <li> reset the mask for those pixels that are not rendered (a = 0).

 * <li> due to anti-aliasing (a != 1),

 * recompute the mask by combining the pixel's alpha with the whole image alpha

 *

 * @note The svg backbuffer area is larger than the viewbox

 * @note The size of the mask is the same as for SVG backbuffer

 */

void CM2GRenderContext::CreateAlphaBlendMaskL(const TSize& aViewBox)

{

    M2G_DEBUG_0("M2G_DEBUG: CM2GRenderContext::CreateAlphaBlendMaskL() - begin");

    // the mask will have the same size as the svg image bitmap

    // allocate memory for mask according to the size

    // and initializes it with iScaledAlpha for each pixel ( i.e. Mem::Fill() = fast operation )

    InitMaskL(iImgBmp->SizeInPixels());

    // lock svg buffer and mask bitmaps

    TM2GBitmapLock maskLock(iMaskBmp);

    TM2GBitmapLock imgLock(iImgBmp);

    TUint8*            maskDataPtr    = REINTERPRET_CAST(TUint8*, iMaskBmp->DataAddress());

    const TUint32*     imgDataPtr     = iImgBmp->DataAddress();

    // Each row of CFbsBitmap is aligned to a 4 bytes boundary

    // if the mask width in pixels is not a multiple of 4, then we must align the pointer

    // to the correct address corresponding to the first pixel on the line below

    TInt maskMaxWidthBytes  = iMaskBmp->ScanLineLength(

                                  iMaskBmp->SizeInPixels().iWidth, KMaskDisplayMode);

    const TInt maskDeltaIndex = maskMaxWidthBytes - aViewBox.iWidth;

    // the svg backbuffer width could be larger than the viewbox width

    const TInt imgDeltaIndex = iImgBmp->SizeInPixels().iWidth - aViewBox.iWidth;

    // how many pixels from the viewbox will be rechecked for alpha value

    const TUint32 countViewBoxPixels = aViewBox.iHeight * aViewBox.iWidth;

    TUint32 imgAlphaMSB;

    TUint32 imgAlpha32;

    TUint32 index = 0;

    while (index < countViewBoxPixels)

    {

        // get the alpha channel in the most left octet (MSB) within a 4 octet

        imgAlphaMSB = *imgDataPtr & 0xFF000000;

        if (imgAlphaMSB == 0x0)

        {

            // pixel is not rendered so we mask it out

            *maskDataPtr = 0x0;

        }

        else if (imgAlphaMSB != 0xFF000000)

        {

            // combine the pixel's alpha with the whole image's alpha (iScaledAlpha)

            // we are not sure if shifting to right pads it with 0 to the left

            imgAlpha32 = (imgAlphaMSB >> 24) & 0xFF;

            // compute the combined alpha on 32b because of possible overflow,

            // and then downcast to TUint8

            // iScaledAlpha = 8b, KMaxAlphaValue = 8b

            *maskDataPtr = TUint8(

                               (imgAlpha32 * iScaledAlpha) / MM2GRenderContext::KMaxAlphaValue);