/*

* Copyright (c) 2002-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 Files

#include <e32def.h>

#include <fbs.h>

#include <logger.h>

#include "cmmaplayerevent.h"

#include "mmmaguiplayer.h"

#include "mmmadisplaywindow.h"

#include "cmmadcdisplay.h"

#include "mmmacontainer.h"

#include "mmafunctionserver.h"

#include "cmmadcrepaintevent.h"

#include "cmmadcfullscreenevent.h"

#include "cmmadcinvalidateevent.h"

// CONSTRUCTION

// Static constructor, leaves pointer to cleanup-stack

CMMADCDisplay* CMMADCDisplay::NewLC(MMMAGuiPlayer* aPlayer,

                                    MMAFunctionServer* aEventSource,

                                    JNIEnv* aJni,

                                    jobject aGUIObject)

{

    CMMADCDisplay* self =

        new(ELeave) CMMADCDisplay(aPlayer, aEventSource, aGUIObject);

    CleanupStack::PushL(self);

    self->iRepaint = new(ELeave) CMMADCRepaintEvent(aGUIObject);

    self->iIseSWT = ETrue;

    self->Construct(aEventSource, aJni, aGUIObject);

    return self;

}

// Destructor (virtual by CBase)

CMMADCDisplay::~CMMADCDisplay()

{

    if (iContainer)

    {

        iContainer->MdcRemoveContent();

    }

    delete iBitmap;

    delete iRepaint;

}

// interface MMMADisplay

void CMMADCDisplay::DrawFrameL(const CFbsBitmap* aBitmap)

{

    // This method is called only if bitmap is used.

    TInt err = InitBitmapMode();

    if (iVisible && iWindow &&

            iContainer && iContainer->MdcContainerVisibility() &&

            err == KErrNone)

    {

        iWindow->DrawFrameL(aBitmap);

        // container will draw bitmap obtained with MdcFrameBuffer method

        if (!iRepaint->IsActive())

        {

            iRepaint->SetActive();

            iEventSource->PostEvent(iRepaint, CMMAEvent::EEventPriority);

        }

    }

}

/*

// interface MMMADisplay

void CMMADCDisplay::SetDisplaySizeL(const TSize& aSize)

{

    LOG2(EJavaMMAPI, EInfo, "CMMADCDisplay::SetDisplaySizeL w %d h %d",

         aSize.iWidth, aSize.iHeight);

    // user rect contains size set from java.

    iUserRect.SetSize(aSize);

    if (iContainer)

    {

        CMMADCInvalidateEvent* event =

            new(ELeave)CMMADCInvalidateEvent(iGUIObject, aSize);

        iEventSource->PostEvent(event, CMMAEvent::EEventPriority);

    }

}

*/

// interface MMMADisplay

void CMMADCDisplay::SetDisplayLocationL(const TPoint& /*aPosition*/)

{

    LOG(EJavaMMAPI, EInfo, "CMMADCDisplay::SetDisplayLocationL");

    // This method only works when the USE_DIRECT_VIDEO mode is set.

    // In USE_GUI_PRIMITIVE mode, this call will be ignored.

}

// interface MMMADisplay

TPoint CMMADCDisplay::DisplayLocation()

{

    LOG(EJavaMMAPI, EInfo, "CMMADCDisplay::DisplayLocation");

    // This method returns always (0,0),

    // because SetDisplayLocationL call is ignored.

    return TPoint(0, 0);

}

// interface MMMADisplay

void CMMADCDisplay::SetFullScreenL(TBool aFullScreen)

{

    LOG1(EJavaMMAPI, EInfo, "CMMADCDisplay::SetFullScreenL %d", aFullScreen);

    // This method tries to set eSWT Widget size to its parent size.

    // If real full screen mode is needed parent Composite must be in

    // fullscreen mode (for example with MobileShell's setFullScreenMode method).

    //if (iContainer)

    //{

    //    CMMADCFullScreenEvent* event =

    //        new(ELeave)CMMADCFullScreenEvent(iGUIObject, aFullScreen);

    //    iEventSource->PostEvent(event, CMMAEvent::EEventPriority);

    //}

    iFullScreen = aFullScreen;

    if (iContainerVisible)

    {

        RemoveClippingRegion();

        if (aFullScreen)

        {

            // use new scaled rect

            // iWindow->SetDrawRect(ScaleToFullScreen(fullScreenSize, iSourceSize));

            LOG2(EJavaMMAPI, EInfo, "CMMADCDisplay::SetFullscreen iFullScreenSize.Width = %d iFullscreenSize.Height = %d",

                 iFullScreenSize.iWidth, iFullScreenSize.iHeight);

            iWindow->SetWindowRect(ScaleToFullScreen(iFullScreenSize, iSourceSize), MMMADisplay::EUiThread);

            iWindow->SetRWindowRect(ScaleToFullScreen(iFullScreenSize, iSourceSize), MMMADisplay::EUiThread);

            iWindow->SetDrawRectThread(ScaleToFullScreen(iFullScreenSize, iSourceSize));

            //iWindow->SetDrawRect(ScaleToFullScreen(iFullScreenSize, iSourceSize));

        }

        else

        {

            // use size set from java

            //iWindow->SetDrawRect(iUserRect);

            iWindow->SetDrawRectThread(iUserRect);

        }

        AddClippingRegion();

    }

}

/*

void CMMADCDisplay::SetFullScreenL(TBool aFullScreen)

{

    LOG(EJavaMMAPI, EInfo, "CMMADCDisplay::SetFullscreenL() +");

       //  TSize canvasSize(aJavaControlWidth, aJavaControlHeight);

       iSourceSize = SourceSize();

       //iSourceSize=canvasSize;

          LOG1(EJavaMMAPI, EInfo, "CMMADCDisplay::SetFullscreenL() asourcesize %d",iSourceSize );

        #ifdef RD_JAVA_NGA_Enabled

        if(iWindow)

        {

            iWindow->SetVideoCropRegion( TRect(iUserRect.iTl, iSourceSize));

        }

        #endif

       //  TSize canvasSize(aJavaControlWidth, aJavaControlHeight);

       //chnaged

       //TSize canvasSize(iFullScreenSize.iWidth, iFullScreenSize.iHeight);

       //TSize iUser(iUserRect.Width(),iUserRect.Height());

        //iFullScreenSize = canvasSize;

      // iFullScreenSize=iUser;

      // if(aFullScreen)

       //   {

       //        iFullScreenSize = canvasSize;

       //   }

        TBool sourceIsBigger = (iSourceSize.iWidth > iFullScreenSize.iWidth ||

                                iSourceSize.iHeight > iFullScreenSize.iHeight);

        if(sourceIsBigger)

        {

              iWindow->SetWindowRect(iFullScreenSize,MMMADisplay::EMmaThread);

            iWindow->SetRWindowRect(iFullScreenSize,MMMADisplay::EMmaThread);

            iWindow->SetDrawRect(ScaleToFullScreen(iFullScreenSize, iSourceSize));

        }

        else

        {

             iWindow->SetWindowRect(iFullScreenSize,MMMADisplay::EMmaThread);

            iWindow->SetRWindowRect(iFullScreenSize,MMMADisplay::EMmaThread);

            //iWindow->SetVideoCropRegion( TRect(iUserRect.iTl,iFullScreenSize));

            //;iWindow->SetDrawRect( TRect(iUserRect.iTl, iSourceSize));

            iWindow->SetDrawRect( TRect(iUserRect.iTl,iFullScreenSize));

        }

       LOG1(EJavaMMAPI, EInfo, "CMMADCDisplay::SourceSizeChanged()1 - %d",iUserRect.Size());

        SetClippingRegion();

        LOG1(EJavaMMAPI, EInfo, "CMMADCDisplay::SourceSizeChanged()2 -%d",iUserRect.Size());

        if(iUserRect.IsEmpty())

        {

            iUserRect = iWindow->DrawRect();

            if(!sourceIsBigger)

            {

                iUserRect = TRect(iUserRect.Size());

            }

        }

        LOG(EJavaMMAPI, EInfo, "CMMADCDisplay::SourceSizeChanged() -");

        LOG1(EJavaMMAPI, EInfo, "CMMADCDisplay::SourceSizeChanged()3 -%d",iUserRect.Size());

}*/

// interface MMMADisplay

void CMMADCDisplay::SourceSizeChanged(const TSize& aSourceSize)

{

    LOG2(EJavaMMAPI, EInfo, "CMMADCDisplay::SourceSizeChanged %d %d",

         aSourceSize.iWidth,

         aSourceSize.iHeight);

#ifdef RD_JAVA_NGA_ENABLED

    if (iWindow)

    {

        iWindow->SetVideoCropRegion(TRect(iUserRect.iTl, aSourceSize));

    }

#endif

    if (iWindow)

    {

        TRect tmp(TPoint(0, 0), aSourceSize);

        iWindow->SetDrawRect(tmp);

        iWindow->SetWindowRect(tmp,MMMADisplay::EMmaThread);

        // set visibility without using event server because this is called

        // from MMA thread

        if (iContainer)

        {

            if (iContainer->MdcContainerVisibility())

            {

                iWindow->SetVisible(ETrue, EFalse);

            }

        }

    }

}

void CMMADCDisplay::SourceSizeChanged(TInt aJavaControlWidth, TInt aJavaControlHeight,TInt /*x*/, TInt /*y*/, TRect /*aBoundsRect*/)

{

    LOG(EJavaMMAPI, EInfo, "CMMADCDisplay::SourceSizeChanged() +");

    LOG2(EJavaMMAPI, EInfo, "CMMADCDisplay::SourceSizeChanged() aJavaControlWidth=%d aJavaControlHeight=%d", aJavaControlWidth, aJavaControlHeight);

    //  TSize canvasSize(aJavaControlWidth, aJavaControlHeight);

    iSourceSize = SourceSize();

    //iSourceSize=canvasSize;

    LOG2(EJavaMMAPI, EInfo, "CMMADCDisplay::SourceSizeChanged() asourcesize (%d,%d)",iSourceSize.iHeight,iSourceSize.iWidth);

#ifdef RD_JAVA_NGA_Enabled

    if (iWindow)

    {

        iWindow->SetVideoCropRegion(TRect(iUserRect.iTl, iSourceSize));

    }

#endif

    //  TSize canvasSize(aJavaControlWidth, aJavaControlHeight);

    //chnaged

    TSize canvasSize(aJavaControlWidth, aJavaControlHeight);

    iFullScreenSize = canvasSize;

    TBool sourceIsBigger = (iSourceSize.iWidth > iFullScreenSize.iWidth ||

                            iSourceSize.iHeight > iFullScreenSize.iHeight);

    if (sourceIsBigger)

    {

        iWindow->SetWindowRect(iFullScreenSize,MMMADisplay::EMmaThread);

        iWindow->SetRWindowRect(iFullScreenSize,MMMADisplay::EMmaThread);

        iWindow->SetDrawRect(ScaleToFullScreen(iFullScreenSize, iSourceSize));

    }

    else

    {

        iWindow->SetWindowRect(iFullScreenSize,MMMADisplay::EMmaThread);

        iWindow->SetRWindowRect(iFullScreenSize,MMMADisplay::EMmaThread);

        //;iWindow->SetDrawRect( TRect(iUserRect.iTl, iSourceSize));

        iWindow->SetDrawRect(TRect(iUserRect.iTl,iFullScreenSize));

    }

    LOG2(EJavaMMAPI, EInfo, "CMMADCDisplay::SourceSizeChanged()1 - %d , %d",iUserRect.Height(),iUserRect.Width());

    SetClippingRegion();

    LOG2(EJavaMMAPI, EInfo, "CMMADCDisplay::SourceSizeChanged()2 -%d , %d ",iUserRect.Height(),iUserRect.Width());

    if (iUserRect.IsEmpty())

    {

        iUserRect = iWindow->DrawRect();

        if (!sourceIsBigger)

        {

            iUserRect = TRect(iUserRect.Size());

        }

    }

    LOG(EJavaMMAPI, EInfo, "CMMADCDisplay::SourceSizeChanged() -");

    LOG2(EJavaMMAPI, EInfo, "CMMADCDisplay::SourceSizeChanged()3 -%d , %d",iUserRect.Height(),iUserRect.Width());

}

// interface MMMADisplay

TBool CMMADCDisplay::IsVisible()

{

    TBool visible = EFalse;

    if (iContainer)

    {

        visible = iContainer->MdcContainerVisibility();

    }

    // else invisible

    // return true if both are visible

    return iVisible && visible;

}

// interface MMMADisplay

TBool CMMADCDisplay::HasContainer()

{

    return iContainer != NULL;

}

// interface MMMADirectContent

void CMMADCDisplay::MdcContainerVisibilityChanged(TBool aVisible)

{

    LOG1(EJavaMMAPI, EInfo, "CMMADCDisplay::MdcContainerVisibilityChanged aVisible %d",

         aVisible);

    if (iWindow)

    {

        iWindow->SetVisible(aVisible && iVisible);

    }

    LOG(EJavaMMAPI, EInfo, "CMMADCDisplay::MdcContainerVisibilityChanged OK");

}

// interface MMMADirectContent

void CMMADCDisplay::MdcContentRectChanged(const TRect& aContentRect,

        const TRect& aParentRect)

{

    LOG(EJavaMMAPI, EInfo, "MMA::CMMADCDisplay::MdcContentRectChanged");

    if (iWindow)

    {

        TSize size = aContentRect.Size();

        iWindow->SetDrawRectThread(TRect(size));

        TInt err = iEventSource->ExecuteTrap(CMMADCDisplay::SetDrawRectL,

                                             this,

                                             &size);

        if (err == KErrNone)

        {

            // bitmap window ignores window rect and position

            iWindow->SetWindowRect(aParentRect,MMMADisplay::EUiThread);

            iWindow->SetPosition(aContentRect.iTl - aParentRect.iTl);

        }

    }

}

void CMMADCDisplay::MdcContainerWindowRectChanged(const TRect&

#ifdef RD_JAVA_NGA_ENABLED

        aRect

#endif

                                                 )

{

    LOG(EJavaMMAPI, EInfo, "CMMADCDisplay::MdcContainerWindowRectChanged");

#ifdef RD_JAVA_NGA_ENABLED

    if (iWindow)

    {

        iWindow->SetRWindowRect(aRect, MMMADisplay::EUiThread);

    }

#endif

}

// interface MMMADirectContent

void CMMADCDisplay::MdcContainerDestroyed()

{

    LOG(EJavaMMAPI, EInfo, "MMA::CMMADCDisplay::MdcContainerDestroyed");

    if (iContainer)

    {

        iContainer->MdcRemoveContent();

    }

    iContainer = NULL;

    if (iWindow)

    {

        iWindow->SetVisible(EFalse);

        iWindow->ContainerDestroyed();

    }

}

// interface MMMADirectContent

void CMMADCDisplay::MdcSetContainer(MMMAContainer* aContainer)

{

    iContainer = aContainer;

    TSize sourceSize = iPlayer->SourceSize();

    LOG2(EJavaMMAPI, EInfo, "CMMADCDisplay::MdcSetContainer source size %d %d",

         sourceSize.iWidth, sourceSize.iHeight);

    aContainer->MdcInvalidate(sourceSize);

    if (iWindow)

    {

        // Notify window that container has been set

        iWindow->ContainerSet();

        TRect controlRect;

        TRect parentRect;

        iContainer->MdcGetContentRect(controlRect, parentRect);

        // bitmap window ignores window rect and position

        iWindow->SetWindowRect(parentRect,MMMADisplay::EUiThread);

        iWindow->SetPosition(controlRect.iTl - parentRect.iTl);

        LOG1(EJavaMMAPI, EInfo, "CMMADCDisplay::MdcSetContainer container visible %d",

             aContainer->MdcContainerVisibility());

        LOG1(EJavaMMAPI, EInfo, "CMMADCDisplay::MdcSetContainer content visible %d",

             iVisible);

        iWindow->SetVisible(aContainer->MdcContainerVisibility() &&

                            iVisible);

    }

}

// interface MMMADirectContent

CFbsBitmap* CMMADCDisplay::MdcFrameBuffer() const

{

    return iBitmap;

}

// interface MMMADirectContent

TSize CMMADCDisplay::MdcSourceSize()

{

    return iPlayer->SourceSize();

}

void CMMADCDisplay::MdcContentBoundsChanged(const TRect& /*aRect*/)

{

}

void CMMADCDisplay::UIGetDSAResources(

    MUiEventConsumer& aConsumer,

    MMMADisplay::TThreadType aThreadType)

{

    if (iContainer)

    {

        iContainer->MdcGetDSAResources(aConsumer, aThreadType);

    }

}

void CMMADCDisplay::UIGetCallback(

    MUiEventConsumer& aConsumer,

    TInt aCallbackId)

{

    if (iContainer)

    {

        iContainer->MdcGetUICallback(aConsumer, aCallbackId);

    }

}

TInt CMMADCDisplay::InitBitmapMode()

{

    TInt errCode = KErrNone;

    // If there is no bitmap, create one and set it to window

    if (!iBitmap && iWindow)

    {

        iBitmap = new CFbsBitmap;

        if (iBitmap)

        {

            errCode = iBitmap->Create(iPlayer->SourceSize(),

                                      EColor16MA);

        }

        else

        {

            errCode = KErrNoMemory;

        }

        if (errCode == KErrNone)

        {

            TRAP(errCode,

                 iWindow->SetDestinationBitmapL(iBitmap));

        }

    }

    return errCode;

}

void CMMADCDisplay::SetDrawRectL(CMMADCDisplay* aDisplay, TSize* aSize)

{

    if (aDisplay->iBitmap)

    {

        User::LeaveIfError(aDisplay->iBitmap->Resize(*aSize));

        aDisplay->iWindow->SetDestinationBitmapL(aDisplay->iBitmap);

    }

}

CMMADCDisplay::CMMADCDisplay(MMMAGuiPlayer* aPlayer,

                             MMAFunctionServer* aEventSource,

                             jobject aGUIObject)

{

    iPlayer = aPlayer;

    iEventSource = aEventSource;

    iGUIObject = aGUIObject;

    // GUI_PRIMITIVE is visible by default.

    iVisible = ETrue;

}

// END OF FILE