/*

* 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:   Implementation of CHuiCanvasVisual.

*

*/

#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/HuiLayout.h"

#include "uiacceltk/HuiTextMesh.h"

#include "uiacceltk/HuiCanvasCmdBufferReader.h"

#include "uiacceltk/HuiTransformation.h"

#include "huicanvasgc.h"

#include "HuiRenderSurface.h"

#include "huicanvastexturecache.h"

#include "huicanvasbackground.h"

#include <graphics/wsgraphicscontext.h>

#include <e32cmn.h>

#include <AknLayoutFont.h>

#include "huicanvasalfpainter.h"

#include "huicanvaswspainter.h"

#include "HuiRosterImpl.h"

#include "huilayoutdata.h"

#include "Matrix.h"

#include "HuiFxEffect.h"

#include "HuiCmdBufferBrush.h"

#include "huiextension.h"

#include "huiwscanvascommands.h"

/** Flag to convienintly disable/enable canvas render buffer usage if needed */

/* Turned to EFalse as DFS77 was having booting problems in wk26 */

/* Now checked dynamically from CHuiRenderer to allow different behaviour in DFS77 and DFS79 */

//const TBool KHuiCanvasVisualUseRenderBuffer = EFalse; 

NONSHARABLE_STRUCT( CHuiCanvasVisual::THuiCanvasVisualData )

    {

    THuiCanvasVisualData(){};

    TInt iCommandSetType;

    TInt iCanvasFlags;

    // Canvas background

    CHuiCanvasBackground* iBackground;    

    CHuiCanvasPainter* iCanvasPainter;

	// External draw content. Can be layout visual that have child visuals.

    CHuiVisual* iExternalContentVisual; // Not owned

    CHuiCanvasVisual* iParentCanvas; // Not owned

    RPointerArray<CHuiCanvasVisual> iChildCanvasList; // Does not own contained visuals 

    RRegionBuf<5> iClipRegion;

    RRegionBuf<20> iPaintedRegion;

    CHuiCanvasRenderBuffer* iStoredRenderBuffer;

    // For handling possible background surface that window may have

    TBool iLayerUsesAlphaFlag;

    TRect iLayerExtent;

    RRegionBuf<5> iShapeRegion;

    TPoint iShapeOrigin;

    // Flag to indicate if this has received commands while inactive

    TBool iCommandsReceivedWhileNoCache;

    };

EXPORT_C CHuiCanvasVisual* CHuiCanvasVisual::AddNewL(CHuiControl& aOwnerControl,

                                                 CHuiLayout* aParentLayout)

    {

    CHuiCanvasVisual* canvas = STATIC_CAST(CHuiCanvasVisual*,

        aOwnerControl.AppendVisualL(EHuiVisualTypeCanvas, aParentLayout));

    return canvas;

    }

CHuiCanvasVisual::CHuiCanvasVisual(MHuiVisualOwner& aOwner)

        : CHuiLayout(aOwner)

    {

    }

void CHuiCanvasVisual::ConstructL()

    {

    CHuiLayout::ConstructL();

    SetFlags(EHuiVisualFlagWserv);

    iCanvasVisualData = new (ELeave) THuiCanvasVisualData;

    iCanvasVisualData->iCommandSetType = ECommandBufferWs;

    iCanvasVisualData->iCanvasFlags = 0;   

    iCanvasVisualData->iExternalContentVisual = NULL;    

    iCanvasVisualData->iParentCanvas = NULL;

    iCanvasVisualData->iBackground = NULL;

    iCanvasVisualData->iCanvasPainter = NULL;

    iCanvasVisualData->iStoredRenderBuffer = 0;

    iCanvasVisualData->iBackground = CHuiCanvasBackground::NewL();

    iCanvasVisualData->iBackground->SetVisual(this);

    iCanvasVisualData->iCanvasPainter = CHuiCanvasWsPainter::NewL();

    iCanvasVisualData->iCanvasPainter->SetVisual(this);

    TBool useCanvasRenderBuffer = CHuiStatic::Renderer().Allows(EHuiRenderPluginAllowVisualPBufferSurfaces);    

    iCanvasVisualData->iCanvasPainter->EnableRenderBuffer(useCanvasRenderBuffer); 

    iCanvasVisualData->iLayerUsesAlphaFlag = EFalse;

    iCanvasVisualData->iLayerExtent = TRect();

    iCanvasVisualData->iShapeOrigin = TPoint();

    iCanvasVisualData->iCommandsReceivedWhileNoCache = EFalse;

    // subwindow effects

    //EnableBrushesL(ETrue);

    }

CHuiCanvasVisual::~CHuiCanvasVisual()

    {

    FreeRenderBuffer();	

    if (iCanvasVisualData)

        {

        if(iCanvasVisualData->iExternalContentVisual)

            {

            // Allow the external content visual to be drawn normally

            iCanvasVisualData->iExternalContentVisual->ClearFlag(EHuiVisualFlagDrawOnlyAsExternalContent);

            }

        ClearCommandSet();

        if ( iCanvasVisualData->iBackground )

            {

            delete iCanvasVisualData->iBackground;

            iCanvasVisualData->iBackground = NULL;

            }

        if ( iCanvasVisualData->iCanvasPainter )

            {

            delete iCanvasVisualData->iCanvasPainter;

            iCanvasVisualData->iCanvasPainter = NULL;

            }

    	iCanvasVisualData->iExternalContentVisual = NULL;

    	// Tell parent that we are destructed

    	if (iCanvasVisualData->iParentCanvas)

    	    {

    	    iCanvasVisualData->iParentCanvas->RemoveChildCanvas(this);

    	    }

    	// Tell children

        for (TInt i=0; i<iCanvasVisualData->iChildCanvasList.Count(); i++)

            {

            iCanvasVisualData->iChildCanvasList[i]->SetParentCanvas(NULL);

            }

        iCanvasVisualData->iPaintedRegion.Close();

        iCanvasVisualData->iClipRegion.Close();

        iCanvasVisualData->iChildCanvasList.Close();

        iCanvasVisualData->iShapeRegion.Close();

        }

    delete iCanvasVisualData;

    iCanvasVisualData = NULL;

    }

CHuiCanvasGc& CHuiCanvasVisual::CanvasGc() const

    {

    return iCanvasVisualData->iCanvasPainter->CanvasGc();

    }

EXPORT_C void CHuiCanvasVisual::SetClearBackground(CHuiDisplay::TClearMode aClearBackground)

    {

    if (iCanvasVisualData->iBackground->ClearBackground() != aClearBackground)

        {

        iCanvasVisualData->iBackground->SetClearBackground(aClearBackground);    

        SetChanged();

        }

    }

EXPORT_C void CHuiCanvasVisual::SetBackgroundColor(const TRgb& aBackgroundColor)

    {

    if (iCanvasVisualData->iBackground->BackgroundColor() != aBackgroundColor)

        {

        iCanvasVisualData->iBackground->SetBackgroundColor(aBackgroundColor);    

        SetChanged();

        }

    }

EXPORT_C void CHuiCanvasVisual::SetBackgroundItems(const RArray<THuiDisplayBackgroundItem>& aItems)

    {

    iCanvasVisualData->iBackground->SetBackgroundItems(aItems);    

    }

EXPORT_C void CHuiCanvasVisual::SetExternalContentL(CHuiVisual* aVisual)

	{

	if (aVisual)

		{

		// Clip external content to canvas visual rect

		SetClipping(ETrue);

		}

	else

		{

		SetClipping(EFalse);

		}

	iCanvasVisualData->iExternalContentVisual = aVisual;

	}

EXPORT_C CHuiVisual* CHuiCanvasVisual::ExternalContent()

	{

	return iCanvasVisualData->iExternalContentVisual;

	}

void CHuiCanvasVisual::ExpandRectWithContent(TRect& aRect) const

    {

    TRect scannedRect(0,0,0,0);

    // HandleBuffer tries to return area where the drawing actually happens, area

    // may be smaller than the visuals displayarea. In that case we dont expand

    // rect but make it smaller.

    HandleBuffer(scannedRect, EScanBuffer, NULL); 

    // Note: this could be improved to take care of dirty rects 

    if (Effect() && Display() && CHuiEnv::Static()->MemoryLevel() != EHuiMemoryLevelLowest )

        {        

        // If there is effect enabled, we cannot say anything about dirty area so

        // we set whole screen dirty.

        scannedRect = TRect(TPoint(0,0), Display()->VisibleArea().Size());

        }

    else if (IsExternalContentDrawingEnabled())

        {

        // If the visual has external content or draws background, 

        // set always the whole window area as a content.

        scannedRect = aRect; 

        }

    if (scannedRect != TRect(0,0,0,0))

        {        

        if (!Brushes())

            {

            aRect = scannedRect;                

            }

        else

            {

            // However if there are brushes they need to know the visual displayrect

            // so incase scanned rect is smaller we use bounding rect as the expanded rect

            if (!Clipping())

                {

                aRect.BoundingRect(scannedRect);                        

                }            

            }    

        }

    CHuiLayout::ExpandRectWithContent(aRect);

    }

void CHuiCanvasVisual::HandleBuffer(TRect& aDisplayRect, TInt aAction, CHuiGc* aGc) const

    {

    TBool touchCountWasEnabled = EFalse;

    if (iCanvasVisualData->iCommandsReceivedWhileNoCache)

        {

        // Commands were received while this visual didn't keep cache. 

        // So it's possible that some images are still in texture cache but haven't been updated.

        touchCountWasEnabled = Env().CanvasTextureCache().IsTouchCountCheckEnabled();

        Env().CanvasTextureCache().EnableTouchCountCheck();

        }

    if (iCanvasVisualData->iCommandSetType == ECommandBufferWs || iCanvasVisualData->iCommandSetType == ECommandBufferAlf)

        {

        if (err)

        	{

        	HUI_DEBUG2(_L("CHuiCanvasVisual::HandleBufferL returned:%d command type was: %d"), err,iCanvasVisualData->iCommandSetType);

        	}

        }

    else

        {

        // do nothing    

        }                

    if (iCanvasVisualData->iCommandsReceivedWhileNoCache)

        {

        Env().CanvasTextureCache().EnableTouchCountCheck( touchCountWasEnabled );

        if ( !KeepNoCache() && aAction == EDrawBuffer )

            {

            iCanvasVisualData->iCommandsReceivedWhileNoCache = EFalse;

            }   

        }

    }

TBool CHuiCanvasVisual::PrepareDrawL() 

    {

	if (Flags() & EHuiVisualFlagDrawOnlyAsExternalContent)

	   	{

	    // This is used only as external content visual. Return now if we are not currently drawing

	    // external content.

	   	if (!Display() || !Display()->RosterImpl().IsDrawingExternalContent())

	   		{

			return ETrue;

	   		}

	   	}

    TBool ret = CHuiLayout::PrepareDrawL();

    if (ret && IsExternalContentDrawingEnabled())

    	{

    	if (Display())

    		{

    		// Enable drawing external visual tree

	    	Display()->RosterImpl().SetDrawingExternalContent(ETrue);

    		ret =  iCanvasVisualData->iExternalContentVisual->PrepareDrawL();

	    	Display()->RosterImpl().SetDrawingExternalContent(EFalse);

    		}

    	}

    return ret;	

    }

TBool CHuiCanvasVisual::CanSkipDrawing() const

    {

    if(Display()->RosterImpl().AlfEventWindow() == this)

         {

         return EFalse;

         }

    if (Effect())

        {

        TBool hasStoredContent = (IsDelayedEffectSource() || Freezed()) && (StoredRenderBuffer() ||  iCanvasVisualData->iStoredRenderBuffer);

        if ((iOpacity.Now() <= EPSILON && !semiTranparentEffectActive))

            {

            return ETrue;

            }

        TBool childWindowEffectActive = EffectIsAppliedToChildren();

        TBool effectAppliedToSurfacePixels = (Effect()->EffectFlags() & KHuiFxEnableBackgroundInAllLayers);

        if( !childWindowEffectActive &&

            !effectAppliedToSurfacePixels &&

            !HasCommandBuffers(ETrue /*include children*/) && 

            !IsBackgroundDrawingEnabled() &&

            !IsExternalContentDrawingEnabled()&&

            !IsExternalContentDrawingEnabled(ETrue /*include children*/) &&

            !hasStoredContent )

            {

            return ETrue;

            }

        }

    else

        {

        if (iOpacity.Now() <= EPSILON ||

            (!HasCommandBuffers(ETrue /*include children*/) && 

            !IsBackgroundDrawingEnabled() &&

            !IsExternalContentDrawingEnabled() &&

            !IsExternalContentDrawingEnabled(ETrue /*include children*/)) )

            {

            return ETrue;

            }

        }

    return EFalse;

    }

void CHuiCanvasVisual::Draw(CHuiGc& aGc) const

    {

    if (Flags() & EHuiVisualFlagDrawOnlyAsExternalContent)

    	{

   	    // This is used only as external content visual. Return now if we are not currently drawing

   	    // external content.

    	if (!Display() || !Display()->RosterImpl().IsDrawingExternalContent())

    		{

			return;

    		}

    	}

    // Optimization

        {

        return;

        }

    if ((IsDelayedEffectSource() || Freezed()))

        {

        // Select right draw mode

        THuiCanvasDrawMode drawMode = (Flags() & EHuiVisualFlagOpaqueHint) ? EHuiCanvasDrawModeNormal : EHuiCanvasDrawModeBlend;

        if (StoredRenderBuffer())

            {

            DrawStoredFullScreenRenderBuffer(drawMode, aGc);

            return;

            }

        else if (iCanvasVisualData->iStoredRenderBuffer)

            {

            DrawStoredVisualRenderBuffer(drawMode);

            return;

			}

        }  

    // If this visual is completely under another visual, then this visual 

    // shouldn't draw anything, but of course there might still be children 

    // that should be drawn.

    // For example, consider the case where you have two visuals:

    // - visual B is child of window A.

    // - visual A and B have exactly same position and size.

    // - both are opaque.

    // Thus, window A can have 'under opaque' hint, but not window B.

    const TBool drawVisualContent = !( Flags() & EHuiVisualFlagUnderOpaqueHint );

    THuiRealRect area = DisplayRect();

    // Apply local transformation.

    EnterLocalProjection(aGc, ETrue, 0.f, &area);

    Transform(aGc, ETrue, &area);

    if (drawVisualContent)

        {

        DrawBrushes(aGc, EHuiBrushLayerBackground);

        }

    if(Clipping())

        {

        // @todo  Clipping not going to work if there is a transformation?

        // Layout clipping is not affected by transformation.

        aGc.Enable(CHuiGc::EFeatureClipping);

        aGc.PushClip();

        aGc.Clip(area);

        }

    // Flag to know what we did

    TBool didDrawEffect = EFalse;

    if (EffectActive())

        {

        TBool refreshCache = EFalse;        

        TBool layer =  EFalse;

        if (EffectIsAppliedToChildren())

            {

            refreshCache |= ChildTreeChanged(EHuiCanvasFlagExcludeFromParentEffect);

            iCanvasVisualData->iPaintedRegion.Clear();

            layer = CollectRecursivePaintedRegion(iCanvasVisualData->iPaintedRegion, EHuiCanvasFlagExcludeFromParentEffect);

            }

        else

            {

            refreshCache |= Changed();            

            iCanvasVisualData->iPaintedRegion.Clear();

            layer = CollectPaintedRegion(iCanvasVisualData->iPaintedRegion, 0);

            }

        if(Display()->RosterImpl().AlfEventWindow() == this)

            {

            refreshCache |= Display()->RosterImpl().NativeAppsContentChanged();

            }

        }

    if ( !didDrawEffect )

        {

        DrawSelf(aGc, area);

        }

    else

        {

        // Effect was drawn, OpenGLES/OpenVG may be in different state than what Gc thinks so we restore it.

        aGc.RestoreState();        

        }

    if (!didDrawEffect)

        {

        // Draw all children

        DrawCanvasChildren(aGc, 0, 0);

        }

        {

        // Draw all children

        DrawCanvasChildren(aGc, 0, 0);    

        }

        {

        // Draw only children which do not want to have parent effect applied to them

        DrawCanvasChildren(aGc, EHuiCanvasFlagExcludeFromParentEffect, 0);        

        }

    if (drawVisualContent && IsContentDrawingEnabled() && IsExternalContentDrawingEnabled())

    	{

    	if (Display())