/*

* Copyright (c) 2006-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:   Implementation of CHuiDisplay, a drawing buffer into which a 

*                the toolkit contents (visuals) are drawn.

*

*/

#include "uiacceltk/HuiDisplay.h"  // Class definition

#include "uiacceltk/HuiStatic.h"

#include "HuiRenderPlugin.h"

#include "HuiRenderSurface.h"

#include "uiacceltk/HuiEnv.h"

#include "HuiRosterImpl.h"

#include "uiacceltk/HuiSkin.h"

#include "uiacceltk/HuiTransformation.h"

#include "uiacceltk/HuiUtil.h"

#include "uiacceltk/HuiTexture.h"

#include "uiacceltk/HuiProbe.h"

#include "uiacceltk/HuiS60Skin.h"

#include "uiacceltk/HuiGc.h"

#ifndef __SERIES60_30__ 

#include "HuiTargetBitmap.h"

#endif

#include "uiacceltk/HuiControlGroup.h"

#include "alf/alfconstants.h" 

#ifdef RD_ALF_IN_PLATFORM            

#include <displaylayoutmetrics.cdl.h>

#endif // RD_ALF_IN_PLATFORM            

#include <AknsRendererWrapper.h>

#include <AknsDrawUtils.h>

#include <coecntrl.h>

#include <uiacceltk/huidisplaybackgrounditem.h>

#include "huiskinbackroundlayout.h"

#include "HuiFxEngine.h"

#include "huiextension.h"

const TUid KHuiInternalFbsBitmapBufferGcUid = {0x2000e5a3}; 

//#define HUI_DEBUG_PRINT_PERFORMANCE_INTERVAL

// *** Class CHuiFbsBitmapBufferGc

class CHuiFbsBitmapBufferGc: public CBase, public MHuiFbsBitmapBufferGc

    {

    public:

    	CHuiFbsBitmapBufferGc(CFbsBitmap* aBitmap) :iBitmap(aBitmap) {};

    private: // From MHuiFbsBitmapBufferGc

    	void ReleaseGc(); 

    	CFbsBitmap* Bitmap(); 

    private:

    	CFbsBitmap* iBitmap; // not owned  

    };

void CHuiFbsBitmapBufferGc::ReleaseGc()

	{

	// Line "delete(this)" should always be the last line in this method.

	// If you change this method behaviour make sure you know what caveats "delete(this)" has.

	delete(this); 

	}

CFbsBitmap* CHuiFbsBitmapBufferGc::Bitmap()

	{

	return iBitmap; 

	}

// *** Class CHuiDisplay

CHuiDisplay::CHuiDisplay(CHuiEnv& aEnv, RWindow* aNativeWindow, TInt aDisplayType, TUid aBackBufferUid )

          : iEnv(aEnv),

          iDisplayType(aDisplayType),

          iActive(ETrue),

          iBackgroundColor(KRgbBlack),

          iUpdateRenderState(ETrue),

          iUsageHint(EHuiDisplayUsageGeneric),

          iOnForeground(ETrue),

          iScreenBufferUid(aBackBufferUid),

          iUseTransformedDirtyRegions(EFalse),

          iDrawVisualOutline( EDrawVisualOutlineNone ),

          iNativeWindow(aNativeWindow)

    {

    }

CHuiDisplay::CHuiDisplay(CHuiEnv& aEnv, CCoeControl* aNativeControl, TInt aDisplayType, TUid aBackBufferUid )

        : iEnv(aEnv),

          iDisplayType(aDisplayType),

          iNativeControl(aNativeControl),

          iSize(0, 0),

          iActive(ETrue),

          iBackgroundColor(KRgbBlack),

          iUpdateRenderState(ETrue),

          iUsageHint(EHuiDisplayUsageGeneric),

          iOnForeground(ETrue),

          iScreenBufferUid(aBackBufferUid),

          iUseTransformedDirtyRegions(EFalse),

          iDrawDirtyRegions( EFalse ),

          iDrawVisualOutline( EDrawVisualOutlineNone )

    {

    }

void CHuiDisplay::ConstructL(const TRect& aRect, CHuiRoster* aSharedRoster)

    {

    HUI_DEBUG1(_L("CHuiDisplay::ConstructL - Free memory in beginning: %i"), HuiUtil::FreeMemory());

    // Register this display to receive foreground lost / gained events.

/*    CCoeEnv* coeEnv = CCoeEnv::Static();

    if(coeEnv && NativeWindow())

        {

        coeEnv->AddMessageMonitorObserverL(*this);

        NativeWindow()->EnableVisibilityChangeEvents();

        }

*/    

    iSize = aRect.Size();

    // Create a rendering surface.

    iRenderSurface = CHuiStatic::Renderer().CreateRenderSurfaceL(*this);

    iCurrentDirtyRegions = &iDirtyRegions;

    // Preserve previous dirty rect info only if the surface uses both dirty rects and double 

    // buffering

    TUint flags = MHuiRenderSurface::EFlagUseDirtyRects | MHuiRenderSurface::EFlagUseDoubleBuffering;

    TBool preservePreviousDirtyRectInfo = ((iRenderSurface->Flags() & flags) == flags);

    if (preservePreviousDirtyRectInfo)

   		{

    	iPreviousDirtyRegions = &iDirtyRegions2;

   		}

    // Create a control roster.

    if(aSharedRoster)

        {

        iRoster.Set(aSharedRoster, EHuiDoesNotHaveOwnership);

        }

    else

        {

        // Construct a private roster.

        CHuiRosterImpl* roster = new (ELeave) CHuiRosterImpl(this);

        iRoster.Set(roster, EHuiHasOwnership);

        }

    // Transformation for the entire display.

    iTransform = CHuiTransformation::NewL();

    // Window transformation for the entire display.

    iWindowTransform = CHuiTransformation::NewL();

	SetScreenBufferLock(EFalse);

    // Create a graphics context.

    iGc = CHuiStatic::Renderer().CreateGcL();

    HUI_DEBUG1(_L("CHuiDisplay::ConstructL - Free memory after GC created: %i"), HuiUtil::FreeMemory());

    SetVisibleArea(TRect(TPoint(0, 0), iSize));

    HUI_DEBUG1(_L("CHuiDisplay::ConstructL - Free memory after surface created: %i"), HuiUtil::FreeMemory());

    if ( !CHuiStatic::Renderer().Allows( EHuiRenderPluginAllowPBufferSurfaces ) )

    // There is no default render surface, so make this one current 

    // immediately to enable texture loading.

        {

        iRenderSurface->MakeCurrent();

        }

    // When dirty regions are transformed it is possible to avoid

    // full display refresh in many cases -> better performance.

    iGc->EnableTransformedClippingRects(iUseTransformedDirtyRegions);

    HUI_DEBUG1(_L("CHuiDisplay::ConstructL - Free memory when exiting ConstructL: %i"), HuiUtil::FreeMemory());

    }

EXPORT_C CHuiDisplay::~CHuiDisplay()

    {

    HUI_DEBUG1(_L("CHuiDisplay %x destructor"), this);

    // Unregister this display from foreground gained / lost events.

//    CCoeEnv* coeEnv = CCoeEnv::Static();

//    if(coeEnv && NativeWindow())

//        {

//        coeEnv->RemoveMessageMonitorObserver(*this);

//        }

    // Notify observers of deletion.

   	if(iScreenBufferObserver)

		{

		iScreenBufferObserver->HandleScreenBufferEvent(iScreenBufferUid, MHuiScreenBufferObserver::EDeleted);

		}

    for(TInt i = 0; i < iDeletionObservers.Count(); ++i)

        {

        iDeletionObservers[i].NotifyDisplayDeletion(*this);

        }

    iDeletionObservers.Reset();

    iRefreshObservers.Reset();

    iVisibleAreaObservers.Reset();

    iRosterObservers.Reset();

    iTempDirtyRegions.Close();

    iDirtyRegions.Close();

    iDirtyRegions2.Close();

    if ( iCurrentDirtyRegions )

        {

        iCurrentDirtyRegions->Close();

        }

    iCurrentDirtyRegions = NULL;

    if ( iPreviousDirtyRegions )

        {

        iPreviousDirtyRegions->Close();

        }

    iPreviousDirtyRegions = NULL;

    delete iRenderSurface;

    iRenderSurface = NULL;

    delete iGc;

    iGc = NULL;

    delete iTransform; 

    iTransform = NULL;

    delete iWindowTransform;

    iWindowTransform = NULL;

    iEnv.RemoveDisplay(*this);

    iNativeControl = NULL;

    iBackgroundItems.Close();

    delete iForegroundTexture;

    delete iForegroundBitmapGc;

    delete iForegroundBitmapDevice;

    iForegroundBitmap = NULL;

    }

TReal32 CHuiDisplay::UnitValue() const

    {

#ifdef RD_ALF_IN_PLATFORM            

    // this will be correct according to the currently loaded layout pack for the current display

    if (CCoeEnv::Static())

        {

        return Display_Layout_Metrics::UnitValue();

        }

    else

        {

        return 1.0f;

        }

#else // RD_ALF_IN_PLATFORM            

    // not supported

    return 1.0f;

#endif // RD_ALF_IN_PLATFORM            

    }

void CHuiDisplay::MonitorWsMessage(const TWsEvent& aEvent)

    {

	switch(aEvent.Type())

	    {

        case EEventWindowVisibilityChanged:

            {

            const TBool wasOnForeground = iOnForeground;

//            iOnForeground = !(aEvent.VisibilityChanged()->iFlags&TWsVisibilityChangedEvent::ENotVisible);

            if ( !wasOnForeground && iOnForeground )

                {

                // Becomes visible, force refresh. 

                // This is needed for example in case of resolution changes.

                SetDirty();

                }

            break;

            }

      	default:

        	break;              

	    }

    }

CHuiGc* CHuiDisplay::Gc()

    {

    ASSERT(iGc != NULL);

    return iGc;

    }

EXPORT_C CCoeControl* CHuiDisplay::NativeControl()

    {

    return iNativeControl;

    }

EXPORT_C RDrawableWindow* CHuiDisplay::NativeWindow()

    {

    if (iNativeWindow)

        {

        return iNativeWindow;

        }

    else if(iNativeControl)

        {

        return iNativeControl->DrawableWindow();

        }

    return 0;

    }

EXPORT_C CHuiEnv& CHuiDisplay::Env()

    {

    return iEnv;

    }

EXPORT_C MHuiRenderSurface& CHuiDisplay::RenderSurface() const

    {

    return *iRenderSurface;

    }

EXPORT_C CHuiRoster& CHuiDisplay::Roster()

    {

    return iRoster.Ref();

    }

EXPORT_C const CHuiRoster& CHuiDisplay::Roster() const

    {

    return iRoster.Ref();

    }

EXPORT_C void CHuiDisplay::Show(TBool aShow)

    {

    iRenderSurface->HandleVisibilityEvent(aShow);

    // Update projection and GC state on the next refresh.

    iUpdateRenderState = ETrue;

    }

CHuiRosterImpl& CHuiDisplay::RosterImpl() const

    {

    return STATIC_CAST(CHuiRosterImpl&, iRoster.NonConstRef());

    }

EXPORT_C void CHuiDisplay::SetSizeL(const TSize& aSize)

    {

    iSize = aSize;

    // Update projection and GC state on the next refresh.

    iUpdateRenderState = ETrue;

    if(iRenderSurface)

        {

        iRenderSurface->SetSizeL(iSize);

        }

    }

EXPORT_C TSize CHuiDisplay::Size() const

    {

    return iSize;

    }

EXPORT_C TRect CHuiDisplay::VisibleArea() const

    {

    return iGc->DisplayArea();

    }

EXPORT_C void CHuiDisplay::SetVisibleArea(const TRect& aArea)

    {

    if(iGc)

        {

        // If clipping has been defined for visible are, it is now invalid so disable.

        SetVisibleAreaClippingRect(TRect(0,0,0,0));

        iGc->SetDisplayArea(aArea);

        // Make sure everything gets redrawn.

        SetDirty();

  		// Can change the roster rect only if the roster is own

   		// \todo This should be prevented also for other shared roster types.

       	RosterImpl().SetRect(aArea);

        // Update projection and GC state on the next refresh.

        iUpdateRenderState = ETrue;

        // Inform observers.

        for(TInt i = 0; i < iVisibleAreaObservers.Count(); ++i)

            {

            iVisibleAreaObservers[i].NotifyDisplayVisibleAreaChanged(*this);

            }

        }

    }

EXPORT_C void CHuiDisplay::Activate(TBool aActivate)

    {

    iActive = aActivate;

    if(iActive)

        {

        // This is the display now using the roster. Only meaningful when the

        // roster is shared between many displays.

        RosterImpl().SetDisplay(this);

        }

    }

EXPORT_C TBool CHuiDisplay::Active() const

    {

    return iActive;

    }

EXPORT_C void CHuiDisplay::SetOrientation(CHuiGc::TOrientation aOrientation)

    {

    if (iGc->Orientation() == aOrientation)

        {

        return;

        }

    iGc->SetOrientation(aOrientation);

    // The effective visible area, as seen by the UI, changes.

    RosterImpl().SetRect(VisibleArea());

    for(TInt i = 0; i < iVisibleAreaObservers.Count(); ++i)

        {

        iVisibleAreaObservers[i].NotifyDisplayVisibleAreaChanged(*this);

        }

    SetDirty();

    // Update projection and GC state on the next refresh.

    iUpdateRenderState = ETrue;

    // Clear effect engine cache as it most likely now contains buffers which 

    // sizes are not very well reusable. It would be better to have "fifo" or

    // something in the cache implementation but until that just release everything here

    // when display layout changes.

    CHuiFxEngine* fxEngine = Env().EffectsEngine();  

    if (fxEngine)

        {

        fxEngine->ClearCache();

        }

    } 

EXPORT_C CHuiGc::TOrientation CHuiDisplay::Orientation() const

    {

    return iGc->Orientation();

    }

EXPORT_C void CHuiDisplay::SetDirty()

    {

    // Mark the entire display dirty.

    HUI_DEBUG(_L("CHuiDisplay::SetDirty() - called."));

    if ( iWholeDisplayAreaIsDirty )

        {

        return;

        }

    TRect displayArea = iGc->DisplayArea();

    AddDirtyRegion(displayArea, *iCurrentDirtyRegions);

    if (iPreviousDirtyRegions)

    	{

		AddDirtyRegion(displayArea, *iPreviousDirtyRegions);

    	}

    iEnv.ContinueRefresh();

    iWholeDisplayAreaIsDirty = ETrue;

    }

TBool CHuiDisplay::IsDirty() const

    {

    //iRoster->ScanDirty();

    //return iDirtyRegions.Count() > 0;

    /** @todo  Determine this better. There should be a way to quickly

               determine if the display needs to be updated; although

               a visual change scan is also a possiblity if it is done

               once per frame. */

    return iActive;

    }

void CHuiDisplay::AddDirtyRegion(const TRect& aDirtyRegion)

    {        

    // Whole screen has been set dirty, no need to add new areas.

    if (iWholeDisplayAreaIsDirty && iGotDirtyReports)

        {

        return;    

        }

    TRect clippedDirtyRect = aDirtyRegion;