/*

* 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 <w32std.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)

{

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

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

    iContentRect = aRect;

    TInt error = StaticRedrawVideo(*this);

    if (KErrNone != error)

    {

    }

}

void CMMASurfaceWindow::SetRWindowRect(const TRect& aRect,

                                       MMMADisplay::TThreadType aThreadType)

{

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

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

    if (iRWindowRect == aRect)

    {

        return;

    }

    iRWindowRect = aRect;

    if (MMMADisplay::EMmaThread == aThreadType)

    {

        if (iDisplay)

        {

            //iDisplay->UIGetCallback(*this,

//                                    CMMASurfaceWindow::ESetClipRect);

            // MMAPI UI 3.x req.

            TBool iseSWT = iDisplay->iseSWT();

            if (iseSWT)

            {

                UICallback((TInt)CMMASurfaceWindow::ESetClipRect);

            }

            else

            {

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

            }

        }

    }

    else if (MMMADisplay::EUiThread == aThreadType)

    {

        TInt error = SetClipRect();

        if (KErrNone != error)

        {

        }

    }

}

TInt CMMASurfaceWindow::SetClipRect()

{

    // CMediaClientVideoDisplay expects client to RemoveDisplayWindow

    // and AddDisplayWindow again everytime when RWindow rect changes

    if (iMediaClientVideoDisplay && iWindow)

    {

        iMediaClientVideoDisplay->RemoveDisplayWindow(*iWindow);

        TRect contentRect;

        if (iVisible)

        {

            contentRect = iContentRect;

        }

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

        LOG2(EJavaMMAPI, EInfo, "CMMASurfaceWindow::SetClipRect(): iRWindowRect size = %d x %d", iRWindowRect.Width(), iRWindowRect.Height());

        TRect clipRect(0,0,iRWindowRect.Width(),iRWindowRect.Height());

        TRAPD(error, iMediaClientVideoDisplay->AddDisplayWindowL(iWindow,

                clipRect, // new clip rect

                iVideoCropRegion,

                drawRect,  // video extent

                0.0f, // ignore

                0.0f, // ignore

                EVideoRotationNone,

                EAutoScaleBestFit,

                EHorizontalAlignCenter,

                EVerticalAlignCenter,

                (RWindow*)iWindow));

        return error;

    }

    return KErrNone;

}

void CMMASurfaceWindow::SetDrawRect(const TRect& aRect)

{

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

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

    iContentRect = aRect;

    if (iDisplay)

    {

        // iDisplay->UIGetCallback( *this,

        //                         CMMASurfaceWindow::ESetDrawRect );

        // MMAPI UI 3.x req.

        TBool iseSWT = iDisplay->iseSWT();

        if (iseSWT)

        {

            UICallback((TInt)CMMASurfaceWindow::ESetDrawRect);

        }

        else

        {

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

        }

    }

}

TInt CMMASurfaceWindow::StaticRedrawVideo(CMMASurfaceWindow& aSurfaceWindow)

{

    TRAPD(error, aSurfaceWindow.RedrawVideoL());

    LOG1(EJavaMMAPI,EInfo,"CMMASurfaceWindow::RedrawVideoL - error = %d",error);

    return error;

}

void CMMASurfaceWindow::RedrawVideoL()

{

    LOG(EJavaMMAPI, EInfo,  "CMMASurfaceWindow::RedrawVideoL +");

    if (!iMediaClientVideoDisplay)

    {

        return;

    }

    //iVisible = true;

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

        /*TRect temp1(TPoint(127,8),TPoint(255,104));

        TRect temp2(TPoint(0,0),TPoint(128,96));

        iMediaClientVideoDisplay->SetVideoExtentL(*iWindow,

                  temp1,

                  temp2);*/

        iMediaClientVideoDisplay->SetVideoExtentL(*iWindow,

                drawRect,

                iVideoCropRegion);

        LOG(EJavaMMAPI, EInfo,  "CMMASurfaceWindow::RedrawvideoL() - after setVideoExtentL");

        iMediaClientVideoDisplay->RedrawWindows(iVideoCropRegion);

        LOG(EJavaMMAPI, EInfo,  "CMMASurfaceWindow::RedrawvideoL() - after redrawWindows");

        //iMediaClientVideoDisplay->RedrawWindows(temp2);

        ((RWindow*)iWindow)->Invalidate();

        LOG(EJavaMMAPI, EInfo,  "CMMASurfaceWindow::RedrawvideoL() -");

    }

}

const TRect& CMMASurfaceWindow::DrawRect()

{

    return iContentRect;

}

TSize CMMASurfaceWindow::WindowSize()

{

    return iParentRect.Size();

}

void CMMASurfaceWindow::SetPosition(const TPoint& aPosition)

{

    LOG(EJavaMMAPI, EInfo,  "+ CMMASurfaceWindow::SetPosition");

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

    TInt error = StaticRedrawVideo(*this);

    if (KErrNone != error)

    {

    }

}

TBool CMMASurfaceWindow::IsVisible() const

{

    return iVisible;

}

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

{

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

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

    {

        if (aVisible != iVisible)

        {

            iVisible = aVisible;

            if (aUseEventServer)

            {

                if (KErrNone != error)

                {

                }

            }

            else

            {

                if (iDisplay)

                {

                }

            }

        }

    }

}

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

{

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

         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)

{

    if (iDisplay != aDisplay)

    {

        if (iDisplay)

        {

            // Clear the resources created within the old Display

            TBool iseSWT = iDisplay->iseSWT();

            if (iseSWT)

            {

                UICallback((TInt)CMMASurfaceWindow::ECleanVideoDisplay);

            }

            else

            {

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

            }

            */

    }

}

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

{