/*

* 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"

/** 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;

    };

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();

    iCanvasVisualData = new (ELeave) THuiCanvasVisualData;

    iCanvasVisualData->iCommandSetType = ECommandBufferWs;

    iCanvasVisualData->iCanvasFlags = 0;   

    iCanvasVisualData->iExternalContentVisual = NULL;    

    iCanvasVisualData->iParentCanvas = NULL;

    iCanvasVisualData->iBackground = NULL;

    iCanvasVisualData->iCanvasPainter = NULL;

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

    iCanvasVisualData->iBackground->SetVisual(this);

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

    iCanvasVisualData->iCanvasPainter->SetVisual(this);

    iCanvasVisualData->iStoredRenderBuffer = 0;

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

    iCanvasVisualData->iCanvasPainter->EnableRenderBuffer(useCanvasRenderBuffer); 

    iCanvasVisualData->iLayerUsesAlphaFlag = EFalse;

    iCanvasVisualData->iLayerExtent = TRect();

    // subwindow effects

    EnableBrushesL(ETrue);

    }

CHuiCanvasVisual::~CHuiCanvasVisual()

    {

    FreeRenderBuffer();

    if(iCanvasVisualData->iExternalContentVisual)

    	{

    	// Allow the external content visual to be drawn normally

    	iCanvasVisualData->iExternalContentVisual->ClearFlag(EHuiVisualFlagDrawOnlyAsExternalContent);

    	}

    if (iCanvasVisualData)

        {

        ClearCommandSet();

        delete iCanvasVisualData->iBackground;

        iCanvasVisualData->iBackground = NULL;

        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();

        }

    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())

        {        

        // 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 (IsBackgroundDrawingEnabled() || 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

    {

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

        {

        TRAPD(err, iCanvasVisualData->iCanvasPainter->HandleBufferL(aDisplayRect, aAction, *this, aGc, DisplayRect().iTl.Round()));  

        if (err)

        	{

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

        	}

        }

    else

        {

        // do nothing    

        }                

    }

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;	

    }

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;

    		}

    	}

    TBool semiTranparentEffectActive = (Effect() && Effect()->IsSemitransparent());

    TBool childWindowEffectActive = (Effect() && EffectIsAppliedToChildren());

    TBool invisible = (iOpacity.Now() <= EPSILON && !semiTranparentEffectActive);

    if( invisible || 

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

         !childWindowEffectActive &&

         !IsBackgroundDrawingEnabled() && 

         !IsExternalContentDrawingEnabled()&&

         !IsExternalContentDrawingEnabled(ETrue /*include children*/)

        ))

        {

        // This will not be visible due to being completely transparent, or the visual does not actually draw anything

        // However, the draw should continue, if the effect is possibly manipulating the opacity of the visual. See CHuiFxVisualLayer::Draw.

        return;

        }

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

        {

        if (StoredRenderBuffer())

            {

            DrawStoredFullScreenRenderBuffer(aGc);

            return;

            }

        else if (iCanvasVisualData->iStoredRenderBuffer)

            {

            DrawStoredVisualRenderBuffer();

            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())

        {

        // Note that EHuiVisualFlagOpaqueHint improves performance a lot in cached effect drawing 

        TBool transparent = EFalse; 

        transparent |= (!(Flags() & EHuiVisualFlagOpaqueHint)); // Does not have opaque hint -> always transparent

        transparent |= iOpacity.Now() < 1.0f; // Opacity less than 1.0f -> always transparent

        TBool refreshCache = EFalse;        

        if (EffectIsAppliedToChildren())

            {

            refreshCache |= ChildTreeChanged(EHuiCanvasFlagExcludeFromParentEffect);

            }

        else

            {

            refreshCache |= Changed();

            }

        // TODO: We could update this somewhere else, not here everytime

        iCanvasVisualData->iPaintedRegion.Clear();

        TInt paintedAreaCount = PaintedAreaCount();  

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

            {

            iCanvasVisualData->iPaintedRegion.AddRect( CanvasPaintedArea(i).iPaintedRect.Round() );

            }

        didDrawEffect = Effect()->CachedDraw(aGc, area, refreshCache, !transparent, iCanvasVisualData->iPaintedRegion);

        }

    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);

        }

    else if (didDrawEffect && !EffectIsAppliedToChildren())

        {

        // Draw all children

        DrawCanvasChildren(aGc, 0, 0);    

        }

    else if (didDrawEffect && EffectIsAppliedToChildren())

        {

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

        DrawCanvasChildren(aGc, EHuiCanvasFlagExcludeFromParentEffect, 0);        

        }

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

    	{

    	if (Display())

    		{

    		// Enable drawing external visual tree

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

    		// The possible effect has been attached to the layout of the visual itself

    		// If the external content needs an effect, too, it should probably be defined

    		// separately, or alternatively the drawing of an effect should be able to 

    		// handle the external content, too.

	   		iCanvasVisualData->iExternalContentVisual->Draw(aGc);

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

    		}

    	}

    if(Clipping())

        {

        // Restore original clipping rectangle.

        aGc.PopClip();

        }

    if (drawVisualContent)

        {

        DrawBrushes(aGc, EHuiBrushLayerForeground);

        }

    // Restore original transformation.

    Transform(aGc, EFalse);

    EnterLocalProjection(aGc, EFalse);

    }

void CHuiCanvasVisual::DrawSelf(CHuiGc& aGc, const TRect& aDisplayRect) const

    {

#ifdef HUI_DEBUG_TRACK_DRAWING	

    if ( Tracking() )

        {

        RDebug::Print(_L("CHuiCanvasVisual::DrawSelf - tracked visual"));

        }

#endif		

    TReal32 effectiveOpacity = EffectiveOpacity();

    if (effectiveOpacity <= 0 || !HasCommandBuffers(ETrue))

        {

        // In case background drawing is enabled, and even if we don't have command buffers we still

        // want to issue clear. If the background drawing is enabled here, it means that the

        // window bound to this visual has a background surface. If we dont do the clear, the

        // surface will be covered by the Alf surface, ie. the underlying surface is not visible

        // It's quite common for applications using Khronos APIs not to issue any drawing commands, 

        // as the drawing goes directly via Khronos APIs.

        // In that case, the background clearing should only be skipped if the window is not 

        // visible (ie. the visual is inactive), and that should already be handled elsewhere.

        if (!IsBackgroundDrawingEnabled())

            {

            return;

            }

        }

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

        {

        if (StoredRenderBuffer())

            {

            DrawStoredFullScreenRenderBuffer(aGc);

			return;

            }

        else if (iCanvasVisualData->iStoredRenderBuffer)

            {

            DrawStoredVisualRenderBuffer();

            return;

            }

        }    

    // Use 'under opaque' hint to optimize drawing.

    // See comment from CHuiCanvasVisual::Draw for further details. 

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

    // Canvas clipping is done in DrawSelf instead of Draw so that canvas clipping does not clip effects 

    if (IsCanvasClippingEnabled())

        {

        aGc.Enable(CHuiGc::EFeatureClipping);

        aGc.PushClip();

        aGc.Clip(ClipRegion());        

        }

    // Draws background if it has been defined

    if (drawVisualContent && IsBackgroundDrawingEnabled())

        { 

        iCanvasVisualData->iBackground->DrawSelf(aGc, aDisplayRect); 

        }

    aGc.Push(EHuiGcMatrixModel);	

    TRect displayRect = aDisplayRect;