/*

* Copyright (c) 2007-2008 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:   Definition of CHuiCanvasWsPainter.

*

*/

#include "huicanvaswspainter.h"

#include "uiacceltk/HuiCanvasVisual.h"

#include "HuiRenderPlugin.h"

#include "uiacceltk/HuiGc.h"

#include "uiacceltk/HuiPanic.h"

#include "uiacceltk/HuiUtil.h"

#include "uiacceltk/HuiStatic.h"

#include "uiacceltk/HuiEnv.h"

#include "uiacceltk/HuiControl.h"

#include "uiacceltk/HuiVisual.h"

#include "uiacceltk/HuiTextMesh.h"

#include "uiacceltk/HuiCanvasCmdBufferReader.h"

#include "huicanvasgc.h"

#include "huicanvaswsgc.h"

#include "HuiRenderSurface.h"

#include "huicanvastexturecache.h"

#include "huicanvasbackground.h"

#include "huicanvaswsswgc.h"

#include "huicanvasdebugwsgc.h"

#include "huicanvaswsbitgc.h"

#include "../../CommonInc/huiwscanvascommands.h"

#include <graphics/wsgraphicscontext.h>

#ifdef HUI_DEBUG_TRACK_DRAWING

#include "alfloggingconfiguration.h"

#include "alfcommanddebug.h"

#endif

#include <e32cmn.h>

#include <AknLayoutFont.h>

#include <graphics/lookuptable.h>

#include "HuiCmdBufferBrush.h"

/** 

 * Constants to define enabling/disabling render buffer automatically 

 *  incase there are frequently new buffers posted. 

 * 

 *  This may improve performance in some HW platforms.

 * 

 */

const TBool KHuiCanvasAutomaticRenderBufferUsage = EFalse; // Disbaled until all UI isses has been solved  

const TInt KHuiCanvasDisableRenderBufferHandleInterval = 100; // Milliseconds 

const TInt KHuiCanvasEnableRenderBufferHandleInterval = 500;  // Milliseconds

/** Internal constant to identify complex command buffers */

const TInt KPossiblePerformanceProblemInWindow = 64;

/** ETrue - use SelectGcL to select gc implementation, 

    EFalse - use KHuiDefaultCanvasWsGc. */

const TBool KHuiUseSelectGc = ETrue;

/** Change this to select default rendering ws gc implementation.

    Only used when KHuiUseSelectGc does not hold. */

const THuiCanvasWsGcType KHuiDefaultCanvasWsGc = EHuiCanvasWsHw;

//#define HUI_DEBUG_PRINT_PERFORMANCE_INTERVAL

CHuiCanvasWsPainter* CHuiCanvasWsPainter::NewL()

	{

	CHuiCanvasWsPainter* self    = new ( ELeave ) CHuiCanvasWsPainter;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

	return self;

    }

CHuiCanvasWsPainter::CHuiCanvasWsPainter()

    {

    }

void CHuiCanvasWsPainter::ConstructL()

    {

    CHuiStatic::Env().AddMemoryLevelObserver(this);

    iWsCommandBufferReader = NULL;

    iPartialCommandBuffer = NULL;

    iCacheCleared = EFalse;

    if ( KHuiUseSelectGc )

        {

        SelectGcL();

        }

    else if (KHuiDefaultCanvasWsGc == EHuiCanvasWsHw)

        {

        iCanvasWsHwGc = CHuiCanvasWsHwGc::NewL();

        iCanvasWsGc = iCanvasWsHwGc;        

        }

    else if (KHuiDefaultCanvasWsGc == EHuiCanvasWsSw)

        {

        iCanvasWsSwGc = CHuiCanvasWsSwGc::NewL();

        iCanvasWsGc = iCanvasWsSwGc;            

        }    

    else if (KHuiDefaultCanvasWsGc == EHuiCanvasWsBit)

        {

        iCanvasWsBitGc = CHuiCanvasWsBitGc::NewL();

        iCanvasWsGc = iCanvasWsBitGc;            

        }    

    else

        {

        // Never happens, right.

        }

    iWsCommandBufferReader = new (ELeave) CHuiCanvasCmdBufferReader();    

#ifdef HUI_DEBUG_TRACK_DRAWING

    iCommandDebugger = CAlfCommandDebug::NewL();

    CHuiCanvasWsGc* realGc = iCanvasWsGc;

    iCanvasWsGc = CHuiCanvasDebugWsGc::NewL( realGc, *iCommandDebugger );

#endif

    }

CHuiCanvasWsPainter::~CHuiCanvasWsPainter()

    {

    if (iCanvasVisual)

        {

        iCanvasVisual->Env().CanvasTextureCache().ReleaseAllCachedEntries(*iCanvasVisual);

        iCanvasVisual->Env().RemoveMemoryLevelObserver(this);

        }

    else

        {

        CHuiStatic::Env().RemoveMemoryLevelObserver(this);

        }

    ClearCommandSet();	

    delete iWsCommandBufferReader;	

    delete iCanvasWsHwGc;

    delete iCanvasWsSwGc;

    delete iCanvasWsBitGc;

    iTempRegion.Close();

    iTempCurrentSubRegion.Close();

    iTempIntersectingRegion.Close();

#ifdef HUI_DEBUG_TRACK_DRAWING

    delete iCommandDebugger;

#endif

    iFullUpdateRegion.Close();

    iShapeRegion.Close();

    }

CHuiGc::TOrientation CHuiCanvasWsPainter::CalculateRelativeOrientation()

    {

    // Calculate drawing command rotation as relative to the current display rotation.

    // It may be that drawing commands has been sent when display was in different rotation.

    TInt last = iCommandBuffers.Count() - 1;

    CHuiGc::TOrientation relativeOrientation = CHuiGc::EOrientationNormal;    

    CHuiGc::TOrientation displayOrientation = CHuiStatic::Env().PrimaryDisplay().Orientation(); 

    CHuiGc::TOrientation drawingCommandOrientation = iCommandBuffers[last]->iOrientation; 

    TInt rotationAngle[] =

        {

        0, 

        270, 

        90, 

        180

        };

    TInt displayOrientationAngle = rotationAngle[displayOrientation];

    TInt drawingCommandOrientationAngle = rotationAngle[drawingCommandOrientation];    

    TInt relativeOrientationAngle = drawingCommandOrientationAngle - displayOrientationAngle;

    // Check over/underflow

    if (relativeOrientationAngle > 360)

        {

        relativeOrientationAngle -= 360;

        }

    else if (relativeOrientationAngle < 0)

        {

        relativeOrientationAngle += 360;

        }

    switch (relativeOrientationAngle)

        {

        case 0:

            {

            relativeOrientation = CHuiGc::EOrientationNormal;

            break;

            }

        case 90:

            {

            relativeOrientation = CHuiGc::EOrientationCW90;            

            break;

            }

        case 270:

            {

            relativeOrientation = CHuiGc::EOrientationCCW90;            

            break;

            }

        case 180:

            {

            relativeOrientation = CHuiGc::EOrientation180;            

            break;

            }

        default:

            {

            // As usual, this should not happen...but just in case it does use normal rotation

            relativeOrientation = CHuiGc::EOrientationNormal;

            break;

            }        

        }

    return relativeOrientation;

    }

void CHuiCanvasWsPainter::HandleBufferL(TRect& aDisplayRect, TInt aAction, const CHuiCanvasVisual& aUser, CHuiGc* aGc, TPoint aPos ) 

    {   

	#ifdef __ALF_SYMBIAN_RWINDOW_CLEARING_BUG_WORKAROUND__

    iTestFullDisplayRect = aDisplayRect;

	#endif

    // Store user so that we can clear cache later

    iCanvasVisual = (CHuiCanvasVisual*)&aUser;

    // Let canvas know about user and gc

    CHuiCanvasGc& canvasGc = iCanvasWsGc->CanvasGc();

    canvasGc.SetVisual(aUser);

    if (aGc)

        {

        canvasGc.SetGc(*aGc);

        }

    if (iCommandBuffers.Count() != 0)

        {

#ifdef HUI_DEBUG_PRINT_PERFORMANCE_INTERVAL

        RDebug::Print(_L(">> CHuiCanvasWsPainter::HandleBufferL this = %i, Action = %i"), this, aAction );

        TTime startTime;

        startTime.UniversalTime();

#endif

        // Initialize canvas

        canvasGc.SetDefaults();   

        // Make sure we got up to date update reagion

        iFullUpdateRegion.Clear();                

        TInt bufferCount = iCommandBuffers.Count();

        for (TInt cb = 0; cb < bufferCount; cb++)

            {        

            iFullUpdateRegion.Union(iCommandBuffers[cb]->iUpdateRegion);

            }

        iFullUpdateRegion.Tidy();

#ifdef HUI_DEBUG_PRINT_PERFORMANCE_INTERVAL

        const TRect updateRegionBoundingRect = iFullUpdateRegion.BoundingRect();        

        RDebug::Print(_L(">> CHuiCanvasWsPainter::HandleBufferL iFullUpdateRegion.BoundingRect() = (%i,%i) (%i,%i)"), 

                updateRegionBoundingRect.iTl.iX,

                updateRegionBoundingRect.iTl.iY,

                updateRegionBoundingRect.iBr.iX,

                updateRegionBoundingRect.iBr.iY

                );

        if (iCanvasWsGc->Type() == EHuiCanvasWsSw)

            {

            RDebug::Print(_L(">> CHuiCanvasWsPainter::HandleBufferL - SW mode is used."));

            }

        else if (iCanvasWsGc->Type() == EHuiCanvasWsBit)

            {

            RDebug::Print(_L(">> CHuiCanvasWsPainter::HandleBufferL - BITGC mode is used."));

            }

        if (aUser.Effect())

            {

            RDebug::Print(_L(">> CHuiCanvasWsPainter::HandleBufferL - visual has EFFECT"));

            }

#endif

        if (aAction == EDrawBuffer)

            {

            /* Check and enable render buffer if needed */

            EnableRenderBufferIfNeeded(ETrue);

            // Compenstate possible orientation mismatch between drawing commands and display orientation

            // by letting iCanvasWsGc know about it. Mismatch usually happens when screen is rotated and

            // it may cause visually unpleasent things at the screen.

            CHuiGc::TOrientation relativeOrientation = CalculateRelativeOrientation();

            iCanvasWsGc->SetRelativeOrientation(relativeOrientation);

            #ifdef HUI_DEBUG_PRINT_PERFORMANCE_INTERVAL

            RDebug::Print(_L(">> CHuiCanvasWsPainter::HandleBufferL - relativeOrientation = %i "), relativeOrientation);    

            #endif

            /* If window shape region has been changed, we should clear the window to get rid of old content. 

             * We also set all command buffers to "not drawn" state so that everything will be redrawn.

             */

            TBool isFullUpdateRegionCleared = EFalse;

            if(iShapeRegionClearingPending)

                {

                #ifdef HUI_DEBUG_PRINT_PERFORMANCE_INTERVAL

                RDebug::Print(_L(">> CHuiCanvasWsPainter::HandleBufferL - Clearing fullupdateregion"));    

                #endif

                // Clear the window update region area

                TBool doClear = ETrue;

                iCanvasWsGc->EnableUpdateRegion(iFullUpdateRegion, doClear);

                iCanvasWsGc->DisableUpdateRegion(); 

                isFullUpdateRegionCleared = ETrue;

                // Cause a full redraw for the canvas visual

                SetAllBuffersChanged(ETrue);    

                ClearAllBufferStatusFlags(EHuiCanvasBufferStatusDrawn);

                iShapeRegionClearingPending = EFalse;

                }

            /* Check if we have buffers that are not yet been drawn (or we render buffer is disabled) */

            TBool cachePrepared = !HasCommandBuffersWithoutFlags(EHuiCanvasBufferStatusDrawn) || !iCanvasWsGc->IsRenderBufferEnabled();

            /* Begin draw. If render buffer is used this sets up the render buffer if needed */

            iCanvasWsGc->BeginActionL(aAction,aDisplayRect,aUser,cachePrepared,iFullUpdateRegion);                   

            #ifdef HUI_DEBUG_PRINT_PERFORMANCE_INTERVAL

            if (iCanvasWsGc->IsRenderBufferEnabled())

                {

                RDebug::Print(_L(">> CHuiCanvasWsPainter::HandleBufferL renderbuffer is ENABLED"));

                }

            else

                {

                RDebug::Print(_L(">> CHuiCanvasWsPainter::HandleBufferL renderbuffer is DISABLED"));

                }

            #endif

            /* We do not ignore unchanged buffers currently */

            TBool ignoreUnChangedBuffers = EFalse; 

            /* We can ignore buffers that only update areas which get clipped */

            TBool ignoreClippedBuffers = ETrue;            

            if (relativeOrientation != CHuiGc::EOrientationNormal)

                {

                ignoreClippedBuffers = EFalse;

                }

            /* We can ignore buffers that has previously already been drawn into render buffer */

            TBool ignoreHandledBuffers = iCanvasWsGc->IsRenderBufferEnabled() && iCanvasWsGc->IsRenderBufferInitialized();                    

            /* 

             * We need to clear area if render buffer is used because otherwise it will cause dimming for semitransparent areas.

             * 

             * NOTE1: We do not clear if the window is opaque. This is a bit questionable, but Avkon seems to rely

             * quite much on luck with its drawing and there are areas in the windows which are not always covered

             * by drawing commands, thus random garabage from previous frames would be visible if such window

             * update area would always be cleared.

             * 

             * NOTE2: We handle window that has background clearing enabled similarly as transparent window

             *        because their wanted behaviour is similar to transparent window (user wants to see the stuff

             *        behind window drawing commands and may want to draw commands translucently). 

             *        

             * -> So always clear if drawing vie render buffer and window is transparent or has backround.       

             *        

             */            

            TBool clearBeforeHandlingBuffer = iCanvasWsGc->IsRenderBufferEnabled() 

                && (!(aUser.Flags() & EHuiVisualFlagOpaqueHint) || aUser.IsBackgroundDrawingEnabled())

                && !isFullUpdateRegionCleared;

            // TODO: Should avoid trap, but EndActionL must always be called

            TRAPD(err, DoHandleAllBuffersL( aDisplayRect, aAction, aUser, aGc, aPos, 

                    ignoreUnChangedBuffers, 

                    ignoreClippedBuffers,

                    ignoreHandledBuffers,

                    clearBeforeHandlingBuffer));

            if (err != KErrNone)

                {

                RDebug::Print(_L("CHuiCanvasWsPainter::HandleBufferL(): draw error = %i "), err);

                RenewAllBuffers();

                }

            // Workaround for fact that WSERV sends command buffers that do not contain real drawing commands.

            // If there are no real drawing commnads, just avoid display update at the EndAction so that

            // we don't write empty pixels to screen and cause flicker. 

            TBool updateDisplay = HasCommandBuffers(EHuiCanvasBufferContainsDrawing);

            /* End draw. If render buffer is in use, this will update the screen */

            iCanvasWsGc->EndActionL(iFullUpdateRegion, updateDisplay);                 

            /* Mark that cache is not more clear */

            iCacheCleared = EFalse;

            }

        else if (aAction == EScanBuffer)

            {

            /* Check and enable render buffer if needed */

            EnableRenderBufferIfNeeded(ETrue);

            /* Check if we have buffers that are not yet prepared (or we render buffer is disabled) */

            TBool cachePrepared = !HasCommandBuffersWithoutFlags(EHuiCanvasBufferStatusScanned) || !iCanvasWsGc->IsRenderBufferEnabled();

            /* Begin scan. If render buffer is used this sets up the render buffer if needed */

            iCanvasWsGc->BeginActionL(aAction,aDisplayRect,aUser,cachePrepared,iFullUpdateRegion);    

            #ifdef HUI_DEBUG_PRINT_PERFORMANCE_INTERVAL

            if (iCanvasWsGc->IsRenderBufferEnabled())

                {

                RDebug::Print(_L(">> CHuiCanvasWsPainter::HandleBufferL renderbuffer is ENABLED"));

                }

            else

                {

                RDebug::Print(_L(">> CHuiCanvasWsPainter::HandleBufferL renderbuffer is DISABLED"));

                }

            #endif

            /* We do not ignore unchanged buffers currently */

            TBool ignoreUnChangedBuffers = EFalse;

            /* We do not ignore clipped buffers as they possibly contain items that may soon appear on the screen */

            TBool ignoreClippedBuffers = EFalse;                    

            /* We can ignore buffers that has previously already been scanned */

            TBool ignoreHandledBuffers = ETrue;     

            /* No need to clear area if scanning */

            TBool clearBeforeHandlingBuffer = EFalse;

            // TODO: Should avoid trap, but EndActionL must always be called

            TRAPD(err, DoHandleAllBuffersL( aDisplayRect, aAction, aUser, aGc, aPos, 

                    ignoreUnChangedBuffers, 

                    ignoreClippedBuffers,

                    ignoreHandledBuffers,

                    clearBeforeHandlingBuffer));    

            if (err != KErrNone)

                {

                RDebug::Print(_L("CHuiCanvasWsPainter::HandleBufferL(): scan error = %i "), err);

                RenewAllBuffers();

                }

            /* End draw. If render buffer is in use, this will update the screen */

            iCanvasWsGc->EndActionL(iFullUpdateRegion, EFalse);

            /* Mark that cache is not more clear */

            iCacheCleared = EFalse;

            /* Update dirty area to aDisplayRect in case this action is originated from dirty area scan */

            aDisplayRect = DirtyRect();

            }

#ifdef HUI_DEBUG_PRINT_PERFORMANCE_INTERVAL

        TTime endTime;

        endTime.UniversalTime();

        TInt timeInMs =  endTime.MicroSecondsFrom( startTime ).Int64()/1000;           

        RDebug::Print(_L(">> CHuiCanvasWsPainter::HandleBufferL took %i ms"), timeInMs);

#endif

        }

    }

void CHuiCanvasWsPainter::DoHandleAllBuffersL( TRect& aDisplayRect, 

                                               TInt aAction, 

                                               const CHuiCanvasVisual& aUser, 

                                               CHuiGc* aGc, 

                                               TPoint& aPos, 

                                               TBool aIgnoreUnChangedBuffers, 

                                               TBool aIgnoreClippedBuffers, 

                                               TBool aIgnoreHandledBuffers,

                                               TBool aClearBeforeHandlingBuffers) 

    {   

    UpdateBufferUpdateRegions(aPos);

    TInt bufferCount = iCommandBuffers.Count();

    for (TInt cb = 0; cb < bufferCount; cb++)

        {

        CHuiCanvasCommandBuffer* cmdbuffer = iCommandBuffers[cb];

        #ifdef HUI_DEBUG_PRINT_PERFORMANCE_INTERVAL

        RDebug::Print(_L(">> CHuiCanvasWsPainter::DoHandleAllBuffersL Buffer size: %i "), iCommandBuffers[cb]->iCommands->Size());                

        for (TInt k=0; k < cmdbuffer->iUpdateRegion.Count();k++)

            {

            RDebug::Print(_L(">> CHuiCanvasWsPainter::DoHandleAllBuffersL Buffer region rect: %i,%i, %i,%i "), 

                cmdbuffer->iUpdateRegion[k].iTl.iX,

                cmdbuffer->iUpdateRegion[k].iTl.iY,

                cmdbuffer->iUpdateRegion[k].iBr.iX,

                cmdbuffer->iUpdateRegion[k].iBr.iY);                

            }

        #endif

        if (aIgnoreUnChangedBuffers && !cmdbuffer->iChanged)

            {

            #ifdef HUI_DEBUG_PRINT_PERFORMANCE_INTERVAL

            RDebug::Print(_L(">> CHuiCanvasWsPainter::DoHandleAllBuffersL Skipping buffer, it has not changed"));                

            #endif            

            continue;            

            }

        if (aIgnoreHandledBuffers)

            {

            if (aAction == EDrawBuffer && (cmdbuffer->iStatusFlags & EHuiCanvasBufferStatusDrawn))

                {

                #ifdef HUI_DEBUG_PRINT_PERFORMANCE_INTERVAL

                RDebug::Print(_L(">> CHuiCanvasWsPainter::DoHandleAllBuffersL Skipping buffer, it has already been drawn."));                

                #endif                            

                continue;

                }

            else if (aAction == EScanBuffer && (cmdbuffer->iStatusFlags & EHuiCanvasBufferStatusScanned))

                {

                #ifdef HUI_DEBUG_PRINT_PERFORMANCE_INTERVAL

                RDebug::Print(_L(">> CHuiCanvasWsPainter::DoHandleAllBuffersL Skipping buffer, it has already been scanned."));                

                #endif            

                continue;            

                }

            else

                {

                // No, we dont ignore.                                

                }

            }

        if (aIgnoreClippedBuffers && IsBufferCompletelyOutisideClippingRegion(*cmdbuffer))

            {

            #ifdef HUI_DEBUG_PRINT_PERFORMANCE_INTERVAL