/*

* Copyright (c) 2002-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:  This class implements MMMADisplayWindow functionality

*               in graphics surface based displays for Helix engine.

*

*/

//  Include Files

#include <logger.h>

#include "cmmasurfacewindow.h"

#include "cmmaplayer.h"

// Used for iDisplay member

#include "mmmadisplay.h"

CMMASurfaceWindow* CMMASurfaceWindow::NewL(

    MMAFunctionServer* aEventSource,

    CMMAPlayer* aPlayer)

{

    CMMASurfaceWindow* self =

        new(ELeave) CMMASurfaceWindow(aEventSource,

                                      aPlayer);

    return self;

}

// Destructor (virtual by CBase)

CMMASurfaceWindow::~CMMASurfaceWindow()

{

    // It's not allowed to delete any nonsharable object here.

    // This must be done in Destroy().

    // If the iDisplay is set,

    // instance should be deleted by sending

    // event from UI to be received by MUiEventConsumer.

}

CMMASurfaceWindow::CMMASurfaceWindow(

    MMAFunctionServer* aEventSource,

    CMMAPlayer* aPlayer):

        iEventSource(aEventSource),

        iPlayer(aPlayer),

        iVideoDisplayInitState(EUIResourcesAndSurfaceParametersNotSet)

{

    // Empty rect until video size is known

    iContentRect.SetRect(0, 0, 0, 0);

    iParentRect.SetRect(0, 0, 0, 0);

    iRWindowRect.SetRect(0, 0, 0, 0);

}

void CMMASurfaceWindow::SetDestinationBitmapL(CFbsBitmap* /*aBitmap*/)

{

    // Ignored, this window will not be used for actual drawing

}

void CMMASurfaceWindow::DrawFrameL(const CFbsBitmap* /*aBitmap*/)

{

    // Ignored, this window will not be used for actual drawing

}

void CMMASurfaceWindow::SetDrawRectThread( const TRect& aRect )

    {

    LOG2( EJavaMMAPI, EInfo,  "MID::CMMASurfaceWindow::SetDrawRectThread TL %d %d",

    	aRect.iTl.iX, aRect.iTl.iY );

    LOG2( EJavaMMAPI, EInfo,  "MID::CMMASurfaceWindow::SetDrawRectThread BR %d %d",

    	aRect.iBr.iX, aRect.iBr.iY );

    iContentRect = aRect;

    TInt error = StaticRedrawVideo(*this);

    if ( KErrNone != error  )

		 {

     ELOG1( EJavaMMAPI, "MID::CMMASurfaceWindow::SetDrawRectThread, StaticRedrawVideo error = %d", error);

     }

    }

void CMMASurfaceWindow::SetRWindowRect(const TRect& aRect,

                                       MMMADisplay::TThreadType aThreadType)

{

		LOG2( EJavaMMAPI, EInfo,  "MID::CMMASurfaceWindow::SetRWindowRect TL %d %d",

               aRect.iTl.iX, aRect.iTl.iY);

    LOG2( EJavaMMAPI, EInfo,  "MID::CMMASurfaceWindow::SetRWindowRect BR %d %d",

               aRect.iBr.iX, aRect.iBr.iY);

    iRWindowRect = aRect;

    if (MMMADisplay::EMmaThread == aThreadType)

    {

        if (iDisplay)

        {

				/*		    iDisplay->UIGetCallback( *this,

                                    CMMASurfaceWindow::ESetDrawRect);

        */                            

	     // MMAPI UI 3.x req.

	     iDisplay->GetCallbackInUiThread( (TInt)CMMASurfaceWindow::ESetDrawRect );

       LOG(EJavaMMAPI,EInfo,"MID::CMMASurfaceWindow::SetRWindowRect after GetCallbackInUiThread " );

        }

    }

    else if (MMMADisplay::EUiThread == aThreadType)

    {

        /*TInt error = StaticRedrawVideo(*this);

        if (KErrNone != error)

        {

		   LOG1(EJavaMMAPI,EInfo,"MID::CMMASurfaceWindow::SetRWindowRect, StaticRedrawVideo error = %d", error);

        }

				*/

		   LOG(EJavaMMAPI,EInfo,"MID::CMMASurfaceWindow::SetRWindowRect else GetCallbackInUiThread + " );

		   iDisplay->GetCallbackInUiThread( (TInt)CMMASurfaceWindow::ESetDrawRect );

       LOG(EJavaMMAPI,EInfo,"MID::CMMASurfaceWindow::SetRWindowRect else GetCallbackInUiThread -" );

    }

}

void CMMASurfaceWindow::SetDrawRect( const TRect& aRect )

		{

		LOG2( EJavaMMAPI, EInfo,  "MID::CMMASurfaceWindow::SetDrawRect TL %d %d",

    	aRect.iTl.iX, aRect.iTl.iY );

    LOG2( EJavaMMAPI, EInfo,  "MID::CMMASurfaceWindow::SetDrawRect BR %d %d",

    	aRect.iBr.iX, aRect.iBr.iY );

		iContentRect = aRect;

		if ( iDisplay )

		  {

		 // iDisplay->UIGetCallback( *this,

		  //                         CMMASurfaceWindow::ESetDrawRect );

		   // MMAPI UI 3.x req.

		   iDisplay->GetCallbackInUiThread((TInt)CMMASurfaceWindow::ESetDrawRect);

       LOG(EJavaMMAPI,EInfo,"MID::CMMASurfaceWindow::SetDrawRect, after GetCallbackInUiThread");

		  }

		}

TInt CMMASurfaceWindow::StaticRedrawVideo(CMMASurfaceWindow& aSurfaceWindow)

{

    TRAPD(error, aSurfaceWindow.RedrawVideoL());

    return error;

}

void CMMASurfaceWindow::RedrawVideoL()

{

    if (!iMediaClientVideoDisplay)

    {

      LOG( EJavaMMAPI, EInfo,  "MID::CMMASurfaceWindow::RedrawVideoL: no MediaClientVideoDisplay set, aborting -" );

        return;

    }

    if (iWindow)

    {

        TRect contentRect;

        if (iVisible)

        {

            contentRect = iContentRect;

            ScaleVideoL(contentRect);

        }

        else

        {

            TRect emptyRect(0,0,0,0);

            contentRect = emptyRect;

        }

        // align parent rect with respect to RWindow

        TRect relativeParentRect;

        relativeParentRect = iParentRect;

        relativeParentRect.Move(-iRWindowRect.iTl);

        // setting video draw rect and adjusting it to window

        TRect drawRect = contentRect;

        drawRect.Move(relativeParentRect.iTl);

        // Area where should be drawn is the intersection of drawRect and relativeParentRect.

        TRect areaRect = relativeParentRect;

        areaRect.Intersection(drawRect);

        iMediaClientVideoDisplay->SetWindowClipRectL(*iWindow,

                areaRect,

                iVideoCropRegion);

        iMediaClientVideoDisplay->SetVideoExtentL(*iWindow,

                areaRect,

                iVideoCropRegion);

			LOG2( EJavaMMAPI, EInfo,  "MID::CMMASurfaceWindow::RedrawVideoL: RedrawWindows() areaRect is %d X %d",areaRect.Width(),areaRect.Height() );

        iMediaClientVideoDisplay->RedrawWindows(iVideoCropRegion);

    }

}

void CMMASurfaceWindow::ScaleVideoL(const TRect& aRect)

{

    // return without scaling incase cropregion dimensions are zero

    if (!(iVideoCropRegion.Width() && iVideoCropRegion.Height()))

    {

        return;

    }

    TReal32 numerator = 1.0f * (aRect.Width() - iVideoCropRegion.Width());

    TReal32 denominator = 1.0f * iVideoCropRegion.Width();

    // new video width percent(relative to the original width) to

    // which video has to be scaled.

    TReal32 scaleWidthPercent = 100.0f + (100.0f * (numerator/denominator));

    numerator = 1.0f * (aRect.Height() - iVideoCropRegion.Height());

    denominator = 1.0f * iVideoCropRegion.Height();

    // new video height percent(relative to the original height) to

    // which video has to be scaled.

    TReal32 scaleHeightPercent = 100.0f + (100.0f * (numerator/denominator));

	LOG2( EJavaMMAPI, EInfo,  "MID::CMMASurfaceWindow:: scaleWidthPercent, scaleHeightPercent %d %d",

	scaleWidthPercent, scaleHeightPercent );

    iMediaClientVideoDisplay->SetScaleFactorL(scaleWidthPercent,

            scaleHeightPercent,

            iVideoCropRegion);

}

const TRect& CMMASurfaceWindow::DrawRect()

{

    return iContentRect;

}

TSize CMMASurfaceWindow::WindowSize()

{

    return iParentRect.Size();

}

void CMMASurfaceWindow::SetPosition(const TPoint& aPosition)

{

    iContentRect = TRect(aPosition, iContentRect.Size());

    TInt error = StaticRedrawVideo(*this);

    if (KErrNone != error)

    {

   ELOG1( EJavaMMAPI, "MID::CMMASurfaceWindow::SetPosition, StaticRedrawVideo error = %d", error);

    }

}

TBool CMMASurfaceWindow::IsVisible() const

  {

  LOG1( EJavaMMAPI, EInfo,  "MID::CMMASurfaceWindow::IsVisible %d ", iVisible );

  return iVisible;

  }

void CMMASurfaceWindow::SetVisible(TBool aVisible, TBool aUseEventServer)

{

  LOG1( EJavaMMAPI, EInfo,  "MID::CMMASurfaceWindow::SetVisible aVisible %d", aVisible );

    RPointerArray< CMMAPlayer > players = iEventSource->Players();

    if (players.Find(iPlayer) != KErrNotFound)

    {

    LOG( EJavaMMAPI, EInfo,  "MID::CMMASurfaceWindow::SetVisible : Player found");

        if (aVisible != iVisible)

        {

    	LOG( EJavaMMAPI, EInfo,  "MID::CMMASurfaceWindow::SetVisible: Changed visibility" );

            iVisible = aVisible;

            if (iDisplay)

            {

      			 //MMAPI UI 3.x req.

     					iDisplay->GetCallbackInUiThread((TInt)CMMASurfaceWindow::ESetDrawRect);

     					LOG(EJavaMMAPI,EInfo,"MID::CMMASurfaceWindow::SetVisible,GetCallbackInUiThread");

            }

											          /*  if (aUseEventServer)

											            {

											                TInt error = StaticRedrawVideo(*this);

											                if (KErrNone != error)

											                {

											         ELOG1( EJavaMMAPI, "MID::CMMASurfaceWindow::SetVisible, StaticRedrawVideo error = %d", error);

											                }

											            }

											            else // in MMA thread, so switch to UI thread

											            {

											                if (iDisplay)

											                {

													      				//iDisplay->UIGetCallback(*this,

													     				  //                     CMMASurfaceWindow::ESetDrawRect );

													    				  //MMAPI UI 3.x req.

													     					iDisplay->GetCallbackInUiThread((TInt)CMMASurfaceWindow::ESetDrawRect);

											         					LOG(EJavaMMAPI,EInfo,"MID::CMMASurfaceWindow::SetVisible,GetCallbackInUiThread");

											                }

											            }

											            */

        }

    }

}

void CMMASurfaceWindow::SetWindowRect(const TRect& aRect,MMMADisplay::TThreadType /*aThreadType*/)

{

    LOG2( EJavaMMAPI, EInfo,  "MID::CMMASurfaceWindow::SetWindowRect aRect TL %d %d",

               aRect.iTl.iX, aRect.iTl.iY);

    LOG2( EJavaMMAPI, EInfo,  "MID::CMMASurfaceWindow::SetWindowRect aRect BR %d %d",

               aRect.iBr.iX, aRect.iBr.iY);

    iParentRect = aRect;

}

void CMMASurfaceWindow::SetVideoCropRegion(const TRect& aRect)

{

    // video size

    iVideoCropRegion = aRect;

}

const TRect& CMMASurfaceWindow::WindowRect()

{

    return iParentRect;

}

void CMMASurfaceWindow::ContainerDestroyed()

{

    // We are in UI thread context now.

    CleanVideoDisplay();

}

void CMMASurfaceWindow::SetDisplay(MMMADisplay *aDisplay)

{

    LOG( EJavaMMAPI, EInfo,  "MID::CMMASurfaceWindow::SetDisplay +" );

    if (iDisplay != aDisplay)

    {

        if (iDisplay)

        {

            // Clear the resources created within the old Display

         	 iDisplay->GetCallbackInUiThread((TInt)CMMASurfaceWindow::ECleanVideoDisplay );

        }

        // Set the new Display

        iDisplay = aDisplay;

        /*if ( iDisplay )

            {

            // Get a DSA resources for the new Display

            //iDisplay->UIGetDSAResources( *this, MMMADisplay::EMmaThread );

            CMMACanvasDisplay* display =  static_cast< CMMACanvasDisplay* >( iDisplay );

            display->GetWindowResources( this, MMMADisplay::EMmaThread );

            }

            */

        }

    LOG( EJavaMMAPI, EInfo,  "MID::CMMASurfaceWindow::SetDisplay -" );

    }

void CMMASurfaceWindow::ContainerSet()

    {

    	LOG(EJavaMMAPI,EInfo, "MID::CMMASurfaceWindow::ContainerSet" );

    // We are in UI thread now

    // Container was probably not set when

    // iDisplay was set,

    // we can now try get the DSA stuff again

    if (iDisplay)

    {

        // Get a DSA stuff for the new Display

//        iDisplay->UIGetDSAResources( *this, MMMADisplay::EUiThread );

        }

    }

void CMMASurfaceWindow::Destroy()

    {

    LOG( EJavaMMAPI, EInfo,  "MID::CMMASurfaceWindow::Destroy" );

    // Delete itself

    delete this;

    }

void CMMASurfaceWindow::ProcureWindowResourcesFromQWidget(RWsSession * aWs,

    CWsScreenDevice* aScreenDevice,

    RWindowBase* aWindow)

	{

		iWs = aWs;

    iScreenDevice = aScreenDevice;

    iWindow = aWindow;

		LOG(EJavaMMAPI,EInfo, "MID::CMMASurfaceWindow::ProcureWindowResourcesFromQWidget" );

		switch ( iVideoDisplayInitState )

		  {

		  	LOG(EJavaMMAPI,EInfo, "MID::CMMASurfaceWindow::ProcureWindowResourcesFromQWidget  -7" );

			case EUIResourcesAndSurfaceParametersNotSet:

			     {

			     LOG(EJavaMMAPI,EInfo, "MID::CMMASurfaceWindow::ProcureWindowResourcesFromQWidget  -8" );

			     iVideoDisplayInitState =

			     EUIResourcesSetAndSurfaceParametersNotSet;

			     }

			     break;

			case ESurfaceParametersSetAndUIResourcesNotSet:

			     {

			     	LOG(EJavaMMAPI,EInfo, "MID::CMMASurfaceWindow::ProcureWindowResourcesFromQWidget  -9" );

			     iVideoDisplayInitState =

			     EUIResourcesAndSurfaceParametersSet;

			     }

			     break;

			 // can not occur

			case EUIResourcesSetAndSurfaceParametersNotSet:

		  case EUIResourcesAndSurfaceParametersSet:

			default:

           {LOG(EJavaMMAPI,EInfo, "MID::CMMASurfaceWindow::ProcureWindowResourcesFromQWidget  -10" );

      		 __ASSERT_DEBUG( EFalse, User::Invariant() );

           }

			     break;

		  }

		if( iVideoDisplayInitState == EUIResourcesAndSurfaceParametersSet )

			{

				LOG(EJavaMMAPI,EInfo, "MID::CMMASurfaceWindow::ProcureWindowResourcesFromQWidget  -11" );

			TRAPD(error, InitVideoDisplayL());

			LOG(EJavaMMAPI,EInfo, "MID::CMMASurfaceWindow::ProcureWindowResourcesFromQWidget  -12" );

			if ( KErrNone != error )

				{

				ELOG1( EJavaMMAPI, "MID::CMMASurfaceWindow::MdcDSAResourcesCallback, error = %d", error);

				}

			}

	}

/*

void CMMASurfaceWindow::MdcDSAResourcesCallback(

    RWsSession &aWs,

    CWsScreenDevice &aScreenDevice,

    RWindowBase &aWindow )

    {

    LOG(EJavaMMAPI,EInfo, "MID::CMMASurfaceWindow::MdcDSAResourcesCallback" );

    // We are in UI thread context now.

    iWs = &aWs;

    iScreenDevice = &aScreenDevice;

    iWindow = &aWindow;

		switch ( iVideoDisplayInitState )

		  {

			case EUIResourcesAndSurfaceParametersNotSet:

			     {

			     iVideoDisplayInitState =

			     EUIResourcesSetAndSurfaceParametersNotSet;

			     }

			     break;

			case ESurfaceParametersSetAndUIResourcesNotSet:

			     {

			     iVideoDisplayInitState =

			     EUIResourcesAndSurfaceParametersSet;

			     }

			     break;

			 // can not occur

			case EUIResourcesSetAndSurfaceParametersNotSet:

		  case EUIResourcesAndSurfaceParametersSet:

			default:

           {

      		 __ASSERT_DEBUG( EFalse, User::Invariant() );

           }

			     break;

		  }

		if( iVideoDisplayInitState == EUIResourcesAndSurfaceParametersSet )

			{

			TRAPD(error, InitVideoDisplayL());

			if ( KErrNone != error )

				{

				LOG1(EJavaMMAPI,EInfo,"MID::CMMASurfaceWindow::MdcDSAResourcesCallback, error = %d", error);

				}

			}

    }

*/

void CMMASurfaceWindow::UICallback( TInt aCallbackId )

    {

    // We are in UI thread context now.

    LOG1( EJavaMMAPI, EInfo,  "MID::CMMASurfaceWindow::MdcUICallback CallbackId = %d", aCallbackId );

    TInt error = KErrNone;

    switch (aCallbackId)

    {

    case ERemoveSurface:

    {

        DoRemoveSurface();

    }

    break;

    case ESetDrawRect:

    {

        error = StaticRedrawVideo(*this);

           ELOG1( EJavaMMAPI, "MID::CMMASurfaceWindow::MdcUICallback,StaticRedrawVideo error = %d", error);

    }

    break;

    case EInitVideoDisplay:

    {

        TRAP(error, InitVideoDisplayL());

			     ELOG1( EJavaMMAPI, "MID::CMMASurfaceWindow::MdcUICallback,InitVideoDisplayL error = %d", error);

    }

    break;

    case ESetChangedSurfaceParameters:

    {

        DoSetChangedSurfaceParameters();

    }

    break;

    case EResetSurfaceParameters:

    {

        DoResetSurfaceParameters();

    }

    break;

    case ECleanVideoDisplay:

    {

        CleanVideoDisplay();

    }

    break;

    case EDestroyWindow:

    {

        Destroy();

    }

    break;

    default:

    {

        __ASSERT_DEBUG(EFalse, User::Invariant());

    }

    break;

    }

}

void CMMASurfaceWindow::SetSurfaceParameters(const TSurfaceId& aSurfaceId,

        const TRect& aCropRect,

        const TVideoAspectRatio& aPixelAspectRatio)

{

    iSurfaceId = aSurfaceId;

    iCropRect = aCropRect;

    iPixelAspectRatio = aPixelAspectRatio;

    switch ( iVideoDisplayInitState )