diff -r 6c158198356e -r ae942d28ec0e javauis/mmapi_qt/baseline/src/cmmadisplay.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/javauis/mmapi_qt/baseline/src/cmmadisplay.cpp	Tue Aug 31 15:09:22 2010 +0300
@@ -0,0 +1,798 @@
+/*
+* 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:  This class implements MMMADisplay
+*
+*/
+
+
+//  Include Files
+#include "logger.h"
+
+#include "cmmadisplay.h"
+#include "mmmadisplaywindow.h"
+
+// temporary
+#include <w32std.h>
+
+// Destructor (virtual by CBase)
+CMMADisplay::~CMMADisplay()
+{
+    /*
+        if (iDirectContainer)
+        {
+            // Remove clip rect if set
+            if (!iClipRect.IsEmpty())
+            {
+                LOG(EJavaMMAPI,EInfo,"CMMADisplay::~CMMADisplay(): Removing clip rect");
+                iDirectContainer->MdcRemoveContentBounds(iClipRect);
+            }
+
+            // Remove this object from MDirectContainer
+            iDirectContainer->MdcRemoveContent(this);
+        }
+        */
+}
+
+
+CMMADisplay::CMMADisplay():
+        iVisible(ETrue),
+        iFullScreen(EFalse),
+        iContainerVisible(ETrue),
+        iIsForeground(ETrue),
+        iResetDrawRect(EFalse),
+        iIseSWT(EFalse)
+{
+}
+
+void CMMADisplay::Construct(MMAFunctionServer* eventSource ,JNIEnv* aJni, jobject javadisplayref)
+{
+    iEventSource = eventSource;
+    iJavadisplayref = javadisplayref;
+    LOG1(EJavaMMAPI,EInfo,"CMMADisplay::Construct=%d",iIseSWT);
+    if (iIseSWT)
+    {
+        iJni = aJni;
+    }
+    else
+    {
+        iJni = iEventSource->getValidJniEnv();
+    }
+    iJavaDisplayObject = iJni->NewGlobalRef(javadisplayref);
+    iJavaDisplayClass = iJni->GetObjectClass(iJavaDisplayObject);
+
+    setRectID = iJni->GetMethodID(iJavaDisplayClass,
+                                  "setRect",
+                                  "()V");
+    iRectDimensionField = iJni->GetFieldID(iJavaDisplayClass, "rectDimension", "[I");
+
+    redrawControlID = iJni->GetMethodID(
+                          iJavaDisplayClass,
+                          "redrawControl",
+                          "()V");
+
+    removeContentBoundID = iJni->GetMethodID(
+                               iJavaDisplayClass,
+                               "removeContentBound",
+                               "()V");
+
+    setContentBoundID = iJni->GetMethodID(
+                            iJavaDisplayClass,
+                            "setContentBound",
+                            "()V");
+
+    getCallBackMethodID = iJni->GetMethodID(
+                              iJavaDisplayClass,
+                              "GetCallbackInUiThread",
+                              "(I)V");
+
+    getBoundRectID = iJni->GetMethodID(
+                         iJavaDisplayClass,
+                         "getBoundRect",
+                         "()V");
+
+    iDisplayboundarrField = iJni->GetFieldID(iJavaDisplayClass, "displayboundarr", "[I");
+
+    // Components must have direct content.
+    /* __ASSERT_LOG(EJavaMMAPI,EInfo,"aDirectContainer, User::Invariant());
+
+     // Not owned
+     iDirectContainer = aDirectContainer;
+
+     // Get component visibility. Later visibility changes will
+     // be informed through MDirectContent observer.
+     iContainerVisible = iDirectContainer->MdcContainerVisibility();
+     LOG1(EJavaMMAPI,EInfo,"CMMADisplay::Construct iContainerVisible = %d", iContainerVisible);
+     LOG1(EJavaMMAPI,EInfo,"CMMADisplay::Construct iVisible = %d", iVisible);
+
+     // Add this MDirectContent to the MDirectContainer. Cannot fail.
+     iDirectContainer->MdcAddContent(this);
+     */
+}
+
+TRect CMMADisplay::ScaleToFullScreen(const TSize& aFullScreenSize,
+                                     const TSize& aSourceSize)
+{
+    LOG(EJavaMMAPI,EInfo,"CMMADisplay::ScaleToFullScreen() +");
+    if ((aSourceSize.iWidth == 0) &&
+            (aSourceSize.iHeight == 0))
+    {
+        // Avoid divide by zero.
+        return TRect();
+    }
+
+    // Width or height will be full size.
+    TRect drawRect(TPoint(0, 0),
+                   aFullScreenSize);
+
+    // Smaller dimension scale ratio will be scaled.
+    // Changed to area calculation to avoid reals and dimension
+    // with smaller area will be scaled.
+    TInt vDif((aFullScreenSize.iWidth - aSourceSize.iWidth)
+              * aFullScreenSize.iHeight);
+    TInt hDif((aFullScreenSize.iHeight - aSourceSize.iHeight)
+              * aFullScreenSize.iWidth);
+
+    TPoint position(0, 0);
+
+    // Check which side to scale to fullscreen size.
+    if (hDif > vDif)
+    {
+        // Width is full screen width.
+        // Scale height with aspect ratio.
+        drawRect.iBr.iY = aFullScreenSize.iWidth * aSourceSize.iHeight
+                          / aSourceSize.iWidth;
+        // move rect middle of the screen
+        position.iY = (aFullScreenSize.iHeight - drawRect.iBr.iY) / 2;
+    }
+    else
+    {
+        // Height is full screen height.
+        // Scale width with aspect ratio.
+        drawRect.iBr.iX = aFullScreenSize.iHeight * aSourceSize.iWidth
+                          / aSourceSize.iHeight;
+        // move rect middle of the screen
+        position.iX = (aFullScreenSize.iWidth - drawRect.iBr.iX) / 2;
+    }
+
+    drawRect.Move(position);
+    LOG2(EJavaMMAPI, EInfo, "CMMADisplay::ScaleToFullScreen::drawRect.Width=%d, drawRect.Height=%d",drawRect.Width(), drawRect.Height());
+    LOG(EJavaMMAPI,EInfo,"CMMADisplay::ScaleToFullScreen() -");
+    return drawRect;
+}
+
+// from MMMADisplay
+void CMMADisplay::DrawFrameL(const CFbsBitmap* aBitmap)
+{
+    // This method is called only if bitmap is used.
+    // Runs in mmapi thread
+    if (iVisible && iWindow /*&& iDirectContainer*/)
+    {
+        iWindow->DrawFrameL(aBitmap);
+        //iDirectContainer->MdcFlushContainer(iWindow->WindowRect());
+    }
+}
+
+void CMMADisplay::SetClippingRegion()
+{
+    LOG(EJavaMMAPI,EInfo,"CMMADisplay::SetClippingRegion");
+
+    if (!iWindow ||
+            (iWindow->GetDisplayWindowType() == MMMADisplayWindow::EDisplayWindowTypeIsBitmap) ||
+            iClipRect == iWindow->DrawRect() && iContainerVisible && iVisible)
+    {
+        LOG(EJavaMMAPI,EInfo,"CMMADisplay::SetClippingRegion before return");
+        return;
+    }
+
+    TBool refreshScreen(EFalse);
+    // Remove first the current clip rect if set
+    LOG2(EJavaMMAPI,EInfo,"CMMADisplay::SetClippingRegion: iClipRect = %d X %d",iClipRect.Width(),iClipRect.Height());
+    if (!iClipRect.IsEmpty())
+    {
+        LOG(EJavaMMAPI,EInfo,"CMMADisplay::SetClippingRegion: Removing old rect");
+        //iDirectContainer->MdcRemoveContentBounds(iClipRect);
+        RemoveContentBoundFromJavaControl(iClipRect);
+        iClipRect.SetRect(0, 0, 0, 0);
+        refreshScreen = ETrue;
+    }
+    // If visible then set a new clip rect
+    if (iVisible && iContainerVisible)
+    {
+        LOG(EJavaMMAPI,EInfo,"CMMADisplay::SetClippingRegion: inside if (iVisible && iContainerVisible)");
+        iClipRect = iWindow->DrawRect();
+        LOG2(EJavaMMAPI,EInfo,"CMMADisplay::SetClippingRegion: inside if (iVisible && iContainerVisible)iClipRect = %d X %d",iClipRect.Width(),iClipRect.Height());
+        if (!iClipRect.IsEmpty())
+        {
+            LOG(EJavaMMAPI,EInfo,"CMMADisplay::SetClippingRegion: Adding new rect");
+            // Add new clipping rect
+            //   iDirectContainer->MdcAddContentBounds(iClipRect);
+            SetContentBoundToJavaControl(iClipRect);
+            refreshScreen = ETrue;
+        }
+    }
+    if (refreshScreen)
+    {
+        LOG(EJavaMMAPI,EInfo,"CMMADisplay::SetClippingRegion: inside if(refreshScreen)");
+        // refresh screen
+        // iDirectContainer->MdcFlushContainer(iWindow->WindowRect());
+        RefreshJavaControl();
+    }
+    LOG(EJavaMMAPI,EInfo,"CMMADisplay::SetClippingRegion -");
+}
+
+void CMMADisplay::RemoveClippingRegion()
+{
+    // Called in mmapi thread
+    LOG(EJavaMMAPI,EInfo,"CMMADisplay::RemoveClippingRegion");
+
+    if (!iWindow ||
+            (iWindow->GetDisplayWindowType() == MMMADisplayWindow::EDisplayWindowTypeIsBitmap))
+    {
+        return;
+    }
+    // Remove first the current clip rect if set
+    if (!iClipRect.IsEmpty())
+    {
+        LOG(EJavaMMAPI,EInfo,"CMMADisplay::RemoveClippingRegion: Removing old rect");
+        //iDirectContainer->MdcRemoveContentBounds(iClipRect);
+        RemoveContentBoundFromJavaControl(iClipRect);
+        iClipRect.SetRect(0, 0, 0, 0);
+        // refresh screen
+        //iDirectContainer->MdcFlushContainer(iWindow->WindowRect());
+        RefreshJavaControl();
+    }
+}
+
+void CMMADisplay::AddClippingRegion()
+{
+    // Called in mmapi thread
+    LOG(EJavaMMAPI,EInfo,"CMMADisplay::AddClippingRegion");
+    LOG2(EJavaMMAPI,EInfo,"CMMADisplay::AddClippingRegion iClipRect width = %d height = %d", iClipRect.Width() , iClipRect.Height());
+
+    if (!iWindow ||
+            (iWindow->GetDisplayWindowType() ==
+             MMMADisplayWindow::EDisplayWindowTypeIsBitmap) ||
+            iClipRect == iWindow->DrawRect())
+    {
+        return;
+    }
+    // If visible then set a new clip rect
+    if (iVisible)
+    {
+        iClipRect = iWindow->DrawRect();
+        if (!iClipRect.IsEmpty())
+        {
+            LOG(EJavaMMAPI,EInfo,"CMMADisplay::AddClippingRegion: Adding new rect");
+            // Add new clipping rect
+            // iDirectContainer->MdcAddContentBounds(iClipRect);
+            SetContentBoundToJavaControl(iClipRect);
+            // refresh screen
+            // iDirectContainer->MdcFlushContainer(
+            //     iWindow->WindowRect());
+            RefreshJavaControl();
+        }
+    }
+}
+
+// from MMMADisplay
+TSize CMMADisplay::DisplaySize()
+{
+    LOG(EJavaMMAPI,EInfo,"CMMADisplay::DisplaySize +");
+    if (iWindow && iFullScreen)
+    {
+        LOG(EJavaMMAPI,EInfo,"CMMADisplay::DisplaySize if loop ");
+        return iWindow->DrawRect().Size();
+    }
+    else
+    {
+        LOG1(EJavaMMAPI,EInfo,"CMMADisplay::DisplaySize else loop %d",iUserRect.Size().iHeight);
+        return iUserRect.Size();
+    }
+}
+
+// from MMMADisplay
+void CMMADisplay::SetDisplaySizeL(const TSize& aSize)
+{
+    // user rect contains size set from java.
+    iUserRect.SetSize(aSize);
+    LOG2(EJavaMMAPI,EInfo,"CMMADisplay::SetDisplaySizeL iUserRect = %d X %d", iUserRect.Width() ,iUserRect.Height());
+    // Size change has no effect if fullscreen mode is on.
+    // New size could be used when fullscreen is turned off.
+    if (iContainerVisible && !iFullScreen && iWindow)
+    {
+        LOG1(EJavaMMAPI,EInfo,"CMMADisplay::SetVisible + iContainerVisible = %d", iContainerVisible);
+        RemoveClippingRegion();
+        LOG2(EJavaMMAPI,EInfo,"CMMADisplay::SetDisplaySizeL iUserRect after removingClipRegion = %d X %d", iUserRect.Width() ,iUserRect.Height());
+        iWindow->SetDrawRect(iUserRect);
+        AddClippingRegion();
+        LOG2(EJavaMMAPI,EInfo,"CMMADisplay::SetDisplaySizeL iUserRect after AddingClipRegion = %d X %d", iUserRect.Width() ,iUserRect.Height());
+    }
+    else
+    {
+        LOG1(EJavaMMAPI,EInfo,"CMMADisplay::SetVisible + iContainerVisible = %d", iContainerVisible);
+        iResetDrawRect = ETrue;
+    }
+}
+
+// from MMMADisplay
+void CMMADisplay::SetVisible(TBool aValue)
+{
+    iVisible = aValue;
+    // Window may be set visible only if container is on screen,
+
+    LOG1(EJavaMMAPI,EInfo,"CMMADisplay::SetVisible + iContainerVisible = %d", iContainerVisible);
+    LOG1(EJavaMMAPI,EInfo,"CMMADisplay::SetVisible iVisible = %d", iVisible);
+    if (!iIsForeground)
+    {
+        LOG(EJavaMMAPI,EInfo,"CMMADisplay::SetVisible - iIsForeground = 0");
+        return;
+    }
+    // if not it can not be set visible.
+    if (iWindow && iContainerVisible)
+    {
+        // iWindow->SetVisible(aValue, EFalse);
+        //MMAPI UI 3.x req. (had to comment above line and add below line which excutes in FS thread)
+        if (iIseSWT == true)
+        {
+            iWindow->SetVisible(aValue, ETrue);
+        }
+        else
+        {
+            iWindow->SetVisible(aValue, EFalse);
+        }
+        LOG(EJavaMMAPI,EInfo,"CMMADisplay::SetVisible after iWindow->SetVisible()");
+        SetClippingRegion();
+        LOG(EJavaMMAPI,EInfo,"CMMADisplay::SetVisible -");
+    }
+}
+
+
+void CMMADisplay::SetContainerVisibility(TBool aValue)
+{
+    iContainerVisible = aValue;
+    // TODO : delete the below check once implementation is done as it is used only for testing purpose
+    if (iContainerVisible)
+        LOG(EJavaMMAPI,EInfo,"CMMADisplay:SetContainerVisibility(): Container is visible ");
+    else
+        LOG(EJavaMMAPI,EInfo,"CMMADisplay:SetContainerVisibility(): Container is not visible ");
+
+    HandleContainerVisibilityChanged(aValue);
+}
+// from MMMADisplay
+void CMMADisplay::SetWindowL(MMMADisplayWindow* aWindow)
+{
+    // Sets new window. Ownership is not transferred.
+    iWindow = aWindow;
+}
+
+// from MMMADisplay
+MMMADisplayWindow* CMMADisplay::Window()
+{
+    return iWindow;
+}
+
+TBool CMMADisplay::IsVisible()
+{
+    LOG1(EJavaMMAPI,EInfo,"CMMADisplay::IsVisible iContainerVisible = %d", iContainerVisible);
+    LOG1(EJavaMMAPI,EInfo,"CMMADisplay::IsVisible iVisible = %d", iVisible);
+    // display is visible if container is on screen and
+    // java side has set it visible
+    return iVisible && iContainerVisible;
+}
+
+TBool CMMADisplay::IsFullScreen()
+{
+    return iFullScreen;
+}
+
+TBool CMMADisplay::HasContainer()
+{
+    // return iDirectContainer != NULL;
+    return EFalse;   // temporary
+}
+
+
+void CMMADisplay::HandleContainerVisibilityChanged(TBool aVisible)
+{
+    LOG1(EJavaMMAPI,EInfo, "CMMADisplay::HandleContainerVisibilityChanged aVisible = %d",
+         aVisible);
+    if (!iIsForeground && aVisible)
+    {
+        LOG(EJavaMMAPI,EInfo," CMMADisplay::HandleContainerVisibilityChanged Condition 1 ");
+        return;
+    }
+
+    LOG(EJavaMMAPI,EInfo," CMMADisplay::HandleContainerVisibilityChanged After condition1");
+
+    if (iWindow)
+    {
+        // midlet comes to foreground (0 to 1 transition),
+        // Allow turn on or turn off based on aVisible
+        if (aVisible != iWindow->IsVisible())
+        {
+            // Allow
+            LOG(EJavaMMAPI,EInfo,"CMMADisplay::MdcContainerVisibilityChanged Allow ");
+        }
+        else if (iContainerVisible == aVisible)
+        {
+            LOG(EJavaMMAPI,EInfo,"CMMADisplay::MdcContainerVisibilityChanged iContainerVisible == aVisible ");
+            // if state is not changed, we do not need to do it again
+            return;
+        }
+    }
+
+    LOG(EJavaMMAPI,EInfo,"CMMADisplay::MdcContainerVisibilityChanged After condition2");
+
+    if (iWindow)
+    {
+        LOG(EJavaMMAPI,EInfo,"CMMADisplay::MdcContainerVisibilityChanged iWindow is valid ");
+        // change is only needed if java side has set display visible or
+        // if container loses focus
+        if (!iContainerVisible || iVisible)
+        {
+            LOG(EJavaMMAPI,EInfo,"CMMADisplay::MdcContainerVisibilityChanged container is invisible and window is visible");
+            if (iResetDrawRect && aVisible && !iFullScreen)
+            {
+                LOG(EJavaMMAPI,EInfo,"CMMADisplay::MdcContainerVisibilityChanged resetdrawrect is true");
+                iWindow->SetDrawRectThread(iUserRect);
+                iResetDrawRect = EFalse;
+            }
+            if (iIsForeground)
+            {
+                LOG(EJavaMMAPI,EInfo,"CMMADisplay::MdcContainerVisibilityChanged container foreground is true");
+                iWindow->SetVisible(aVisible,false);
+            }
+            SetClippingRegion();
+        }
+    }
+}
+
+/*
+
+void CMMADisplay::MdcItemContentRectChanged(const TRect& aContentRect,
+        const TRect& aScreenRect)
+{
+    // To be overwritten if used
+    __ASSERT_LOG(EJavaMMAPI,EInfo,"EFalse, User::Invariant());
+}
+
+void CMMADisplay::MdcContainerWindowRectChanged(const TRect&
+                                                  #ifdef RD_JAVA_NGA_ENABLED
+                                                   aRect
+                                                  #endif
+                                                  )
+    {
+    LOG(EJavaMMAPI,EInfo,"CMMADisplay::MdcContainerWindowRectChanged +");
+
+    #ifdef RD_JAVA_NGA_ENABLED
+    if( iWindow )
+        {
+        LOG(EJavaMMAPI,EInfo,"CMMADisplay::MdcContainerWindowRectChanged, SetRWindowRect");
+        iWindow->SetRWindowRect(aRect, MMMADisplay::EUiThread);
+        }
+    #endif
+    }
+void CMMADisplay::MdcContainerDestroyed()
+{
+    LOG(EJavaMMAPI,EInfo,"MMA::CMMADisplay::MdcContainerDestroyed");
+
+    if (iWindow)
+    {
+        iWindow->ContainerDestroyed();
+    }
+
+    iDirectContainer = NULL;
+}
+
+
+void CMMADisplay::MdcAbortDSA()
+{
+    if (iWindow)
+    {
+        iWindow->AbortDSA();
+    }
+}
+
+
+void CMMADisplay::MdcResumeDSA()
+{
+    if (iWindow)
+    {
+        iWindow->ResumeDSA();
+    }
+}
+
+void CMMADisplay::UIGetCallback(
+    MUiEventConsumer& aConsumer,
+    TInt aCallbackId)
+{
+    if (iDirectContainer)
+    {
+        iDirectContainer->MdcGetUICallback(aConsumer, aCallbackId);
+    }
+}
+*/
+
+
+void CMMADisplay::GetCallbackInUiThread(TInt placeholder)
+{
+    JNIEnv* validJni = iEventSource->getValidJniEnv();
+    jobject javaDisplayObject;
+    jclass javaDisplayClass;
+    LOG(EJavaMMAPI,EInfo,"CMMADisplay::GetCallbackInUiThread +");
+    /**
+     * In case of eSWT iJavaDisplayClass and iJavaDisplayObject were initialized with JNI
+     * in UI Thread. Since this function is called from FunctionServer Thread so we need to get
+     * valid JNI for FunctionServer Thread and need to initialize iJavaDisplayClass and iJavaDisplayObject
+     * again for FunctionServer Thread rather than using the one that was created in Constructor(UI Thread).
+     */
+    if (iIseSWT)
+    {
+        javaDisplayObject = validJni->NewGlobalRef(iJavadisplayref);
+        javaDisplayClass =  validJni->GetObjectClass(iJavaDisplayObject);
+    }
+    else
+    {
+        javaDisplayObject = iJavaDisplayObject;
+        javaDisplayClass = iJavaDisplayClass;
+    }
+    getCallBackMethodID = validJni->GetMethodID(javaDisplayClass,
+                          "GetCallbackInUiThread",
+                          "(I)V");
+    LOG1(EJavaMMAPI,EInfo,"CMMADisplay::GetCallbackInUiThread getCallBackMethodID = %d",getCallBackMethodID);
+    validJni->CallVoidMethod(javaDisplayObject,getCallBackMethodID,placeholder);
+    LOG(EJavaMMAPI,EInfo,"CMMADisplay::GetCallbackInUiThread -");
+}
+
+void CMMADisplay::CalledBackInUiThread(TInt placeholder)
+{
+    LOG(EJavaMMAPI,EInfo,"CMMADisplay::CalledBackInUiThread +");
+    iWindow->UICallback(placeholder);
+    LOG(EJavaMMAPI,EInfo,"CMMADisplay::CalledBackInUiThread -");
+
+}
+
+
+
+void CMMADisplay::SetWindowResources(QWidget* qtWidget)
+{
+    LOG(EJavaMMAPI,EInfo,"CMMADisplay::SetWindowResources +");
+    CCoeControl* control = 0;
+    if (qtWidget && qtWidget ->winId())
+    {
+        control = reinterpret_cast<CCoeControl*>(qtWidget->winId());
+    }
+
+    CCoeEnv *coeEnv = control->ControlEnv();
+    RWsSession * iWs = &(coeEnv->WsSession());
+    CWsScreenDevice* iScreenDevice = coeEnv->ScreenDevice();
+    RWindowBase* window = static_cast<RWindowBase*>(control->DrawableWindow());
+    if (!iWindow)
+    {
+        return;
+    }
+    iWindow->ProcureWindowResourcesFromQWidget(iWs,iScreenDevice,window);
+    iWindow->SetVisible(ETrue,ETrue);
+    LOG(EJavaMMAPI,EInfo,"CMMADisplay::SetWindowResources -");
+}
+
+
+void CMMADisplay::SetForeground(TBool aForeground, TBool aUseEventServer)
+{
+    LOG1(EJavaMMAPI,EInfo,"MMA::CMMADisplay::SetForeground %d", aForeground);
+    iIsForeground = aForeground;
+
+    if (aForeground)
+    {
+        if (iContainerVisible && !iWindow->IsVisible())
+        {
+            iWindow->SetVisible(ETrue, aUseEventServer);
+        }
+    }
+    else
+    {
+        if (iWindow->IsVisible())
+        {
+            iWindow->SetVisible(EFalse, aUseEventServer);
+        }
+    }
+}
+
+TSize CMMADisplay::SourceSize()
+{
+    LOG(EJavaMMAPI,EInfo,"CMMADisplay::SetSourceSizeToDisplay ");
+    return iUiPlayer->SourceSize();
+}
+
+void CMMADisplay::SetUIPlayer(MMMAGuiPlayer* player)
+{
+    iUiPlayer = player;
+}
+
+
+void CMMADisplay::SourceSizeChanged(const TSize& aSourceSize)
+{
+    LOG(EJavaMMAPI,EInfo,"CMMADisplay::SourceSizeChanged");
+
+#ifdef RD_JAVA_NGA_ENABLED
+    if (iWindow)
+    {
+        iWindow->SetVideoCropRegion(TRect(iUserRect.iTl, aSourceSize));
+    }
+#endif
+
+    iSourceSize = aSourceSize;
+    LOG1(EJavaMMAPI,EInfo,"MMA::CMMADisplay::SourceSizeChanged %d",
+         aSourceSize.iWidth);
+    LOG1(EJavaMMAPI,EInfo,"MMA::CMMADisplay::SourceSizeChanged %d",
+         aSourceSize.iHeight);
+    jmethodID getDisplayWidthID = iJni->GetMethodID(
+                                      iJavaDisplayClass,
+                                      "getDisplayWidth",
+                                      "()I");
+
+    jmethodID getDisplayHeightID = iJni->GetMethodID(
+                                       iJavaDisplayClass,
+                                       "getDisplayHeight",
+                                       "()I");
+
+
+    TInt x =  iJni->CallIntMethod(iJavaDisplayObject,getDisplayWidthID);
+    TInt y = iJni->CallIntMethod(iJavaDisplayObject,getDisplayHeightID);
+    LOG2(EJavaMMAPI,EInfo,"CMMADisplay.cpp : SourceSizeChanged () iFullScreenSize is x = %d ,y = %d ",x,y);
+    // get the ScreenSize from canvas in java
+    TSize canvasSize(x, y);
+    iFullScreenSize = canvasSize;
+    TBool sourceIsBigger = (aSourceSize.iWidth > iFullScreenSize.iWidth ||
+                            aSourceSize.iHeight > iFullScreenSize.iHeight);
+
+    if (sourceIsBigger)
+    {
+        // Source is larger than display area.
+        // Shrink draw are to fit in display.
+        iWindow->SetDrawRect(ScaleToFullScreen(iFullScreenSize, iSourceSize));
+    }
+    else
+    {
+        // source is smaller than display area
+        iWindow->SetDrawRect(TRect(iUserRect.iTl, iSourceSize));
+    }
+
+    SetClippingRegion();
+
+    if (iUserRect.IsEmpty())
+    {
+        // Java side hasn't set size.
+        iUserRect = iWindow->DrawRect();
+
+        if (!sourceIsBigger)
+        {
+            // Addjusting rect to top left corner.
+            iUserRect = TRect(iUserRect.Size());
+        }
+    }
+}
+
+
+
+void CMMADisplay::SetDisplayPosition(TInt /*uiControlLocationX*/,TInt /*uiControlLocationY*/,TInt   videoControlLocationX,TInt videoControlLocationY)
+{
+    LOG(EJavaMMAPI,EInfo,"CMMADisplay::SourceSizeChanged + ");
+    TPoint point(videoControlLocationX ,videoControlLocationY);
+    //calling derived class fuction
+    TRAP_IGNORE(SetDisplayLocationL(point));
+    LOG(EJavaMMAPI,EInfo,"CMMADisplay::SourceSizeChanged - ");
+}
+
+
+void CMMADisplay::ResetJavaRectObject(const TRect& aRect)
+{
+    LOG(EJavaMMAPI,EInfo,"MMA::CMMACanvasDisplay::ResetJavaRectObject +");
+    //TRect rect = aRect;
+    JNIEnv* validJni = iJni;//iEventSource->getValidJniEnv();//iJni;
+    /*jmethodID setRectID = validJni->GetMethodID(
+                                                 iJavaDisplayClass,
+                                                 "setRect",
+                                             "()V");
+    */
+    LOG(EJavaMMAPI,EInfo,"MMA::CMMACanvasDisplay::ResetJavaRectObject --1");
+    // set the value to java,so that we can access those from array
+
+    //jfieldID iRectDimensionField = validJni->GetFieldID(iJavaDisplayClass, "rectDimension", "[I");
+    if (iRectDimensionField == NULL)
+    {
+        // handle error
+    }
+    /* Write to the instance fields */
+    jintArray javaDimensionarr = (jintArray)validJni->GetObjectField(iJavaDisplayObject, iRectDimensionField);
+    LOG(EJavaMMAPI,EInfo,"MMA::CMMACanvasDisplay::ResetJavaRectObject --2");
+    jint* nativeRectDimensionArr = validJni->GetIntArrayElements(javaDimensionarr, NULL);
+    LOG(EJavaMMAPI,EInfo,"MMA::CMMACanvasDisplay::ResetJavaRectObject --3");
+    if (!nativeRectDimensionArr)
+    {    // inputBuffer was already allocated
+        validJni->ReleaseIntArrayElements(javaDimensionarr, nativeRectDimensionArr, JNI_ABORT);
+        LOG(EJavaMMAPI,EInfo,"MMA::CMMACanvasDisplay::ResetJavaRectObject Error in resetting rect dimension to java");
+        return;
+    }
+    nativeRectDimensionArr[0] = aRect.iTl.iX;
+    nativeRectDimensionArr[1] = aRect.iTl.iY;;
+    nativeRectDimensionArr[2] = aRect.Width();
+    nativeRectDimensionArr[3] = aRect.Height();
+    // Now the dimension array in java is updated hence reset the java rect
+
+    validJni->ReleaseIntArrayElements(javaDimensionarr, nativeRectDimensionArr, 0);
+    validJni->CallVoidMethod(iJavaDisplayObject,setRectID);
+
+    LOG(EJavaMMAPI,EInfo,"MMA::CMMACanvasDisplay::ResetJavaRectObject -");
+}
+
+
+void CMMADisplay::SetContentBoundToJavaControl(const TRect& aRect)
+{
+    LOG(EJavaMMAPI,EInfo,"MMA::CMMACanvasDisplay::SetContentBoundToJavaControl +");
+    JNIEnv* validJni = iJni;//iEventSource->getValidJniEnv();//iJni;
+    // Reset the java rect
+    ResetJavaRectObject(aRect);
+    /*jmethodID setContentBoundID = validJni->GetMethodID(
+                                         iJavaDisplayClass,
+                                         "setContentBound",
+                                     "()V");
+    */
+    // call java function
+    validJni->CallVoidMethod(iJavaDisplayObject,setContentBoundID);
+    LOG(EJavaMMAPI,EInfo,"MMA::CMMACanvasDisplay::SetContentBoundToJavaControl -");
+}
+
+void CMMADisplay::RemoveContentBoundFromJavaControl(const TRect& aRect)
+{
+    LOG(EJavaMMAPI,EInfo,"MMA::CMMACanvasDisplay::RemoveContentBoundFromJavaControl +");
+    JNIEnv* validJni = iJni;//iEventSource->getValidJniEnv();
+    // Reset the java rect
+    ResetJavaRectObject(aRect);
+    /*jmethodID removeContentBoundID = validJni->GetMethodID(
+                                         iJavaDisplayClass,
+                                         "removeContentBound",
+                                     "()V");
+    */
+    // call java function
+    validJni->CallVoidMethod(iJavaDisplayObject,removeContentBoundID);
+    LOG(EJavaMMAPI,EInfo,"MMA::CMMACanvasDisplay::RemoveContentBoundFromJavaControl -");
+}
+
+void CMMADisplay::RefreshJavaControl()
+{
+    LOG(EJavaMMAPI,EInfo,"MMA::CMMACanvasDisplay::RefreshJavaControl +");
+    JNIEnv* validJni = iJni;//iEventSource->getValidJniEnv();//iJni;
+    // Reset the java rect
+    //ResetJavaRectObject(aRect);
+    /*jmethodID redrawControlID = validJni->GetMethodID(
+                                         iJavaDisplayClass,
+                                         "redrawControl",
+                                     "()V");
+    */
+    // call java function
+    validJni->CallVoidMethod(iJavaDisplayObject,redrawControlID);
+    LOG(EJavaMMAPI,EInfo,"MMA::CMMACanvasDisplay::RefreshJavaControl -");
+}
+
+TBool CMMADisplay::iseSWT()
+{
+    return iIseSWT;
+}
+
+void CMMADisplay::SetFullscreenSize(TSize &aFullscreenSize)
+{
+    iFullScreenSize = aFullscreenSize;
+}
+//  END OF FILE