// Copyright (c) 2007-2009 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:

//

#include "displayrenderstage.h"

#include <graphics/wselement.h>

#include <hal.h>

#include "openwfcwrapper.h"

#include "panic.h"

#include "utils.h"

#include "rsdisplaychangeao.h"

#include <graphics/wsdisplaycontrol.h>

#include <graphics/wsdisplaymapping.h>

#include <graphics/wsdisplaypolicy.h>

#include "screencaptureutil.h"

#include "elementwrapper.h"

#include "alfdecoderserverclient.h"

#include "huiwscanvascommands.h"

#include "alflogger.h"

CDisplayRenderStage* CDisplayRenderStage::NewL(MWsGraphicDrawerEnvironment* aEnv,MWsScreen* aScreen, TInt aScreenNumber)

    {

    CDisplayRenderStage* stage = new(ELeave) CDisplayRenderStage(aScreenNumber);

    CleanupStack::PushL(stage);

    stage->ConstructL(aEnv, aScreen, aScreenNumber);

    CleanupStack::Pop(stage);

    return stage;

    }

CDisplayRenderStage::CDisplayRenderStage(TInt aScreenNumber)

    : iScreenNumber(aScreenNumber)

    {

    }

CDisplayRenderStage::~CDisplayRenderStage()

    {

    iSurfaceUpdateSession.Close();

    iUpdateRegion = NULL;

    delete iDispNotifier;

    delete iConfigNotifier;

    delete iDisplayPolicy;

    delete iOpenWfcWrapper;

    delete iScreenCaptureUtil;

    }

void CDisplayRenderStage::ConstructL(MWsGraphicDrawerEnvironment* aEnv, MWsScreen* aScreen, TInt aScreenNumber)

    {

    BaseConstructL();

    MWsIniFile* iniFile = aEnv->ObjectInterface<MWsIniFile>();

    STD_ASSERT_ALWAYS(iniFile, EPluginPanicIniFileMissing);

    //Initialise display policy and strategy segments

    iDisplayPolicy = CDisplayPolicy::NewL(aEnv,aScreen, aScreenNumber);

    iDisplayPolicyEnabled = iDisplayPolicy->PolicyEnabled();

    // initialize compositor

    iOpenWfcWrapper = COpenWfcWrapper::NewL(aScreenNumber, iDisplayPolicy);

    iOpenWfcWrapperDisplayControl = iOpenWfcWrapper->GetInterface<MWsDisplayControl>();

    if(iOpenWfcWrapperDisplayControl)

        {

        iDispNotifier = CRsDisplayChangeNotifier::NewL(iOpenWfcWrapperDisplayControl, iDisplayPolicy);  

        iDispNotifier->IssueNotificationRequest();

        iConfigNotifier = CRsConfigChangeNotifier::NewL(iOpenWfcWrapperDisplayControl);

        iConfigNotifier->IssueNotificationRequest();

        //calculate min UI buffer size depending on physical resolutions

        TInt ret = iOpenWfcWrapperDisplayControl->NumberOfResolutions();

        RArray<MDisplayControlBase::TResolution> resolutions;

        CleanupClosePushL(resolutions);

        if(ret > 0)

            {

            User::LeaveIfError(resolutions.Reserve(ret));

            User::LeaveIfError(iOpenWfcWrapperDisplayControl->GetResolutions(resolutions));

            }

        iDisplayPolicy->CalculateMinBufferSize(resolutions, ret);               

        CleanupStack::PopAndDestroy(&resolutions);

        }

    TSize screenSize = iOpenWfcWrapper->ScreenSize();

    iDisplayPolicy->AdjustStageBufferSize(TSize(0,0), screenSize);

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

    TDisplayConfiguration displayConfig;

    if(iOpenWfcWrapperDisplayControl)

        {

        iOpenWfcWrapper->GetConfiguration(displayConfig);

        }

    else

        {

        displayConfig.SetResolution(SizeInPixels());    // Both getters eventually reach RDisplayChannel

        displayConfig.SetResolutionTwips(SizeInTwips());// as iOpenWfcWrapper->GetConfiguration does

        const MWsScene::TSceneRotation rotation = iOpenWfcWrapper->ScreenRotation();

        displayConfig.SetRotation(static_cast<TDisplayConfiguration::TRotation>(rotation));

        }

    iDisplayPolicy->SetCompositionInfo(displayConfig,displayConfig);    //1 to 1 mapping

    }

TAny* CDisplayRenderStage::ResolveObjectInterface(TUint aTypeId)

    {

    switch(aTypeId)

        {

    case MWsScreenDevice::EWsObjectInterfaceId:

        return static_cast<MWsScreenDevice*>(this);

    case MWsScene::EWsObjectInterfaceId:

        return static_cast<MWsScene*>(this);

    case MWsDisplayControl::EWsObjectInterfaceId:

//#ifndef FAKE_DISPLAY_CONFIGURATION_FOR_SINGLE_DISPLAY

//      if (iOpenWfcWrapperDisplayControl)

//#endif

//          {   //only support the interface if the compositor does

                //otherwise we need to fake single-element support.

            return static_cast<MWsDisplayControl*>(this);

//          }

//      break;

    case MWsDisplayMapping::EWsObjectInterfaceId:

        return static_cast<MWsDisplayMapping*>(this);

    case MWsWindowTreeObserver::EWsObjectInterfaceId:

        return static_cast<MWsWindowTreeObserver*>(this);

    case KAlfCompositionControllerIfUid:

        return static_cast<MAlfCompositionController*>(this);    

    case MWsDisplayPolicy::EWsObjectInterfaceId:

            {

            if (iDisplayPolicyEnabled)

                {

                return static_cast<MWsDisplayPolicy*>(this);

                }

            else

                {

                return NULL;

                }

            }   

        }

    return CWsRenderStage::ResolveObjectInterface(aTypeId);

    }

void CDisplayRenderStage::Begin(const TRegion* aRegion)

    {

    STD_ASSERT_DEBUG(!aRegion || !aRegion->CheckError(), EPluginPanicRegionError);

    iUpdateRegion = aRegion;

    iOpenWfcWrapper->Begin(aRegion);

    }

void CDisplayRenderStage::End(TRequestStatus* aFinished)

    {

  if (!iOpenWfcWrapper->CompositionDue() && aFinished) 

      {

        // No re-composition required and the update region is empty.

      // Signal that we are ready for more updates.

        *aFinished = KRequestPending;

        User::RequestComplete(aFinished, KErrNone);

        }

   else

      {

      iOpenWfcWrapper->Compose(aFinished);

      }

    iOpenWfcWrapper->End();

    iUpdateRegion = NULL;

    }

TInt CDisplayRenderStage::ScreenNumber() const

    {

    return iScreenNumber;

    }

TDisplayMode CDisplayRenderStage::DisplayMode() const

    {

    return EColor16MAP;//iRenderTarget->DisplayMode();

    }

TSize CDisplayRenderStage::SizeInPixels() const

    {

    TSize size(0, 0);

    if (iOpenWfcWrapperDisplayControl)

        {

        size=iDisplayPolicy->GetUiResolution();

        }

    return size;

    }

TSize CDisplayRenderStage::SizeInTwips() const

    {  

    if (iOpenWfcWrapperDisplayControl)

        {

        TSize size(0, 0);

        size = iDisplayPolicy->GetUiResolutionAsTwips();

        if (size.iWidth)

            {

            return size;

            }     

        }

    const TSize size = SizeInPixels();

    const MWsScene::TSceneRotation screenRotation = iOpenWfcWrapper->ScreenRotation();

    const TBool rotated = (screenRotation == ESceneAntiClockwise90 || screenRotation == ESceneAntiClockwise270);

    TInt twips = 0;

    TInt res = HAL::Get(iScreenNumber, rotated ? HALData::EDisplayYTwips : HALData::EDisplayXTwips,twips);

    __ASSERT_DEBUG(res==KErrNone && twips!=0, Panic(EPluginPanicSizeInTwipsFailed));

    const TInt horzTwipsPerThousandPixels = twips * 1000 / size.iWidth; 

    const TInt horzSizeInTwips = (horzTwipsPerThousandPixels * size.iWidth + 500) / 1000;

    twips = 0;

    res = HAL::Get(iScreenNumber, rotated ? HALData::EDisplayXTwips : HALData::EDisplayYTwips,twips);

    __ASSERT_DEBUG(res==KErrNone && twips!=0, Panic(EPluginPanicSizeInTwipsFailed));

    const TInt vertTwipsPerThousandPixels = twips * 1000 / size.iHeight; 

    const TInt vertSizeInTwips = (vertTwipsPerThousandPixels * size.iHeight + 500) / 1000;

    return TSize (horzSizeInTwips, vertSizeInTwips);

    }

TRect CDisplayRenderStage::PointerRect() const

    {

    if (iScreenNumber != 0)

        {

        return TRect();  // Only screen 0 supports a digitizer

        }

    TMachineInfoV1Buf macInfo;

    UserHal::MachineInfo(macInfo);

    return TRect(-macInfo().iOffsetToDisplayInPixels, macInfo().iXYInputSizeInPixels);    

    }

void CDisplayRenderStage::GetPixel(TRgb& /*aColor*/, const TPoint& /*aPixel*/) const

    {

    //iRenderTarget->GetPixel(aColor, aPixel);

    }

void CDisplayRenderStage::GetScanLine(TDes8& /*aScanLine*/, const TPoint& /*aStartPixel*/, TInt /*aPixelLength*/, TDisplayMode /*aDispMode*/) const

    {

    //iRenderTarget->GetScanLine(aScanLine, aStartPixel, aPixelLength, aDispMode);

    }

TBool CDisplayRenderStage::RectCompare(const TRect& /*aRect1*/, const TRect& /*aRect2*/) const

    {

    return EFalse;//iRenderTarget->RectCompare(aRect1, aRect2);

    }

void doDynamicCaptureL(CDisplayRenderStage* aThis, CFbsBitmap* aBitmap)

    {

    if (!aThis->iScreenCaptureUtil)

        {

        aThis->iScreenCaptureUtil = CScreenCaptureUtil::NewL(aThis);

        }   

    aThis->iScreenCaptureUtil->ComposeScreenL(aBitmap->Handle());

    }

void CDisplayRenderStage::CopyScreenToBitmapL(CFbsBitmap* aBitmap, const TRect& /*aRect*/) const

    {

  if (iRunningOnLowMem)

        {

    User::Leave(KErrNoMemory);

    }

  if ( aBitmap->ExtendedBitmapType() != KNullUid )

    {

    User::Leave(KErrArgument);

    }            

    doDynamicCaptureL((CDisplayRenderStage*)this, aBitmap);

    }

MWsElement* CDisplayRenderStage::CreateSceneElementL()

    {

    return iOpenWfcWrapper->CreateElementL();

    }

void CDisplayRenderStage::DestroySceneElement(MWsElement* aElement)

    { 

    iOpenWfcWrapper->DestroyElement(aElement);

    }

TInt CDisplayRenderStage::InsertSceneElement(MWsElement* aInsertElement, MWsElement* aSubordinateElement)

    {

	if (aInsertElement)

	    {

#ifdef USE_UI_SURFACE_FOR_ALF

        TUint32 flags(0);

        aInsertElement->GetRenderStageFlags(flags);

        if ( flags & MWsElement::EElementIsIndirectlyRenderedUserInterface)

            {

            iUiElement = aInsertElement;

	        if (!iAlfElement)

	            {

	            __ALFLOGSTRING("CDisplayRenderStage: Skipping UI element for now"); 

	            return KErrNone;

	            }

            }

         }

#endif        

    return iOpenWfcWrapper->AddElement(aInsertElement, aSubordinateElement);

    }

TInt CDisplayRenderStage::RemoveSceneElement(MWsElement* aRemoveElement)

    {

    iOpenWfcWrapper->RemoveElement(aRemoveElement);

    return KErrNone;

    }

void CDisplayRenderStage::ComposePendingScene(TSurfaceId& aOffScreenTarget, TRequestStatus* aCompleted)

    {

    /*

     * If the supplied off-screen target is NULL and If the optionally provided TRequestStatus

     * is present, signal immediately and return.

     */

    if (aOffScreenTarget.IsNull())

        {

        if (aCompleted)

            {           

            User::RequestComplete(aCompleted, KErrArgument);

            return;

            }

        }

    iOpenWfcWrapper->RegisterSurface(aOffScreenTarget);

    iOpenWfcWrapper->Compose(aOffScreenTarget, aCompleted);

    iOpenWfcWrapper->UnregisterSurface(aOffScreenTarget);

    }

TInt CDisplayRenderStage::SetSceneRotation(const MWsScene::TSceneRotation aSceneRotation)

    {

    const TSceneRotation oldRotation = iOpenWfcWrapper->ScreenRotation();

    //rotate in compositor 

    iOpenWfcWrapper->SetScreenRotation(aSceneRotation);

/*  switch (aSceneRotation)

        {

        case ESceneAntiClockwise0:

        case ESceneAntiClockwise180:

            iRenderTarget->SetAspectRatio(CRenderTarget::ENormalAspectRatio);

            break;

        default:

            iRenderTarget->SetAspectRatio(CRenderTarget::EInvertedAspectRatio);

        }

*/      

    TDisplayConfiguration rotate;

    rotate.SetRotation((TDisplayConfiguration::TRotation)aSceneRotation);

    iDisplayPolicy->SetCompositionInfo(rotate,rotate);

    //update ui element

    //const TSurfaceId& uiSurface = iRenderTarget->SurfaceId();

    //return iOpenWfcWrapper->SetUiSurface(uiSurface);

    return KErrNone;

    }

MWsScene::TSceneRotation CDisplayRenderStage::SceneRotation() const

    {

    return iOpenWfcWrapper->ScreenRotation();

    }

void CDisplayRenderStage::ClearDisplay(TRgb /*aBackColor*/)

    {

    }

//

//

// Implementation of MWsDisplayConfiguration/MDisplayConfiguration interface

//

//

void CDisplayRenderStage::NotifyOnDisplayChange(TRequestStatus& aStatus)

    {

    aStatus = KRequestPending;

    if(iDispNotifier)

        {

        iDispNotifier->RegisterActiveStatus(aStatus);

        }

    else

        {

        TRequestStatus* reqPtr=&aStatus;    //indirection is required

        User::RequestComplete(reqPtr, KErrNotSupported);

        }

    }

void CDisplayRenderStage::NotifyOnDisplayChangeCancel()

    {

    if(iDispNotifier)

        {

        iDispNotifier->CancelNotificationRequest();

        }

    }

void CDisplayRenderStage::NotifyOnConfigChange(TRequestStatus& aStatus)

    {

    aStatus = KRequestPending;

    if(iConfigNotifier)

        {

        iConfigNotifier->RegisterActiveStatus(aStatus);

        }

    else

        {

        TRequestStatus* reqPtr=&aStatus;    //indirection is required

        User::RequestComplete(reqPtr, KErrNotSupported);

        }

    }

void CDisplayRenderStage::NotifyOnConfigChangeCancel()

    {

    if(iConfigNotifier)

        {

        iConfigNotifier->CancelNotificationRequest();

        }

    }

/** Determine the display configuration and application rendering

    offset to use for a given screen size mode.

    The Window Server uses this function when a request to change to a

    new screen size mode or new display configuration is made by a

    client. The display configuration passed in may be partially filled,

    and the combination of the defined entries in it and the requested

    screen size mode values shall be used to define the rest of the

    configuration and new application offset to be used.

    Only undefined entries in the configuration may be set by this

    function. Entries already defined must retain the same values. If

    the combination of defined entries and size mode values is not

    acceptable to the implementer, the function shall return EFalse.

    If the function returns ETrue, the Window Server shall set the

    returned display configuration, notify render stages of the new

    application offset and change to use the screen size mode. If

    either this function returns EFalse or the call to set the display

    configuration fails for any reason (such as KErrNoMemory, for

    example), then no further changes are made.

    @see MWsScreenConfigList

    @param aScreenSizeMode    The requested screen size mode. If static,

    the size in pixels, size in twips, and the rotation must be

    respected. If dynamic, only the rotation must be respected.

    @param aConfig    The requested display configuration on input, the

    required configuration on return. Only undefined entries may be set.

    @param aSizeModePosition    The screen size mode offset and size to be filled in

    @return KErrNone if no error, otherwise a system wide error code

*/

TInt CDisplayRenderStage::GetSizeModeConfiguration(TInt aScreenSizeMode, TDisplayConfiguration& aConfig, TRect& aSizeModePosition) const

    {

    TInt reply;

    RArray<TResolution> resolutions;

    reply = iOpenWfcWrapperDisplayControl->GetResolutions(resolutions);

    if (reply < KErrNone &&

            reply != KErrDisconnected)

        {

        resolutions.Close();

        return reply;

        }

    TBool isDisconnected=EFalse;

    if (reply == KErrDisconnected || resolutions.Count() == 0)

        {

        isDisconnected=ETrue;

        }

    else if (resolutions.Count() == 1 && resolutions[0].iPixelSize==TSize(0,0))

        {

        isDisconnected=ETrue;

        }

    if (isDisconnected)

        {//in this case aScreenSizeMode should be the smallest app mode

        reply = iDisplayPolicy->GetSizeModeConfiguration(aScreenSizeMode, aConfig, aSizeModePosition);

        }

    else

        {

        reply = iDisplayPolicy->GetSizeModeConfiguration(resolutions,aScreenSizeMode,aConfig,aSizeModePosition);

        }

    resolutions.Close();

    return reply;

    }

void CDisplayRenderStage::SetSizeModeExtent(TRect& aExtent, TBitFlags32 aContext)

    {

    if (aContext.iFlags&KOffMap)

        {

        iDisplayPolicy->SetSizeModeExtent(aExtent,aContext);

        aContext.iFlags&=~KOffMap;

        }

/*  if (aContext.iFlags&KOffGc)

        {

        iRenderTarget->SetDrawDeviceOffset(aExtent.iTl);

        aContext.iFlags&=~KOffGc;

        }*/

    //Could chain through again if required?

    }

TInt CDisplayRenderStage::NumberOfResolutions() const

    {

    if(iOpenWfcWrapperDisplayControl)

        {

        TInt returnValue = iOpenWfcWrapperDisplayControl->NumberOfResolutions();

        iDisplayPolicy->AddVirtualResolutionCount(returnValue);

        return returnValue;

        }

#ifdef FAKE_DISPLAY_CONFIGURATION_FOR_SINGLE_DISPLAY    

    return 1;

#else

    return KErrNotSupported;

#endif

    }

TInt CDisplayRenderStage::GetResolutions(RArray<TResolution>& aResolutions) const   

    {

    if(iOpenWfcWrapperDisplayControl)

        {

        TInt returnValue = iOpenWfcWrapperDisplayControl->GetResolutions(aResolutions);

        if (returnValue >= KErrNone)

            {

            //add virtual resolutions

            returnValue = iDisplayPolicy->AddVirtualResolutions(aResolutions);

            }

        return returnValue;

        }

    return KErrNotSupported;

    }