/*
* 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 <jdebug.h>
#include "cmmadisplay.h"
#include "mmmadisplaywindow.h"
// Destructor (virtual by CBase)
CMMADisplay::~CMMADisplay()
{
if (iDirectContainer)
{
// Remove clip rect if set
if (!iClipRect.IsEmpty())
{
DEBUG("CMMADisplay::~CMMADisplay(): Removing clip rect");
iDirectContainer->MdcRemoveContentBounds(iClipRect);
}
// Remove this object from MDirectContainer
iDirectContainer->MdcRemoveContent(this);
}
}
CMMADisplay::CMMADisplay():
iVisible(EFalse),
iFullScreen(EFalse),
iContainerVisible(EFalse),
iIsForeground(ETrue),
iResetDrawRect(EFalse)
{
}
void CMMADisplay::Construct(MDirectContainer* aDirectContainer)
{
// Components must have direct content.
__ASSERT_DEBUG(aDirectContainer, User::Invariant());
// Not owned
iDirectContainer = aDirectContainer;
// Get component visibility. Later visibility changes will
// be informed through MDirectContent observer.
iContainerVisible = iDirectContainer->MdcContainerVisibility();
DEBUG_INT("MID::CMMADisplay::Construct iContainerVisible = %d", iContainerVisible);
DEBUG_INT("MID::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)
{
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);
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()
{
DEBUG("CMMADisplay::SetClippingRegion");
if (!iWindow ||
(iWindow->GetDisplayWindowType() == MMMADisplayWindow::EDisplayWindowTypeIsBitmap) ||
iClipRect == iWindow->DrawRect() && iContainerVisible && iVisible)
{
return;
}
TBool refreshScreen(EFalse);
// Remove first the current clip rect if set
if (!iClipRect.IsEmpty())
{
DEBUG("CMMADisplay::SetClippingRegion: Removing old rect");
iDirectContainer->MdcRemoveContentBounds(iClipRect);
iClipRect.SetRect(0, 0, 0, 0);
refreshScreen = ETrue;
}
// If visible then set a new clip rect
if (iVisible && iContainerVisible)
{
iClipRect = iWindow->DrawRect();
if (!iClipRect.IsEmpty())
{
DEBUG("CMMADisplay::SetClippingRegion: Adding new rect");
// Add new clipping rect
iDirectContainer->MdcAddContentBounds(iClipRect);
refreshScreen = ETrue;
}
}
if (refreshScreen)
{
// refresh screen
iDirectContainer->MdcFlushContainer(iWindow->WindowRect());
}
DEBUG("CMMADisplay::SetClippingRegion -");
}
void CMMADisplay::RemoveClippingRegion()
{
// Called in mmapi thread
DEBUG("CMMADisplay::RemoveClippingRegion");
if (!iWindow ||
(iWindow->GetDisplayWindowType() == MMMADisplayWindow::EDisplayWindowTypeIsBitmap))
{
return;
}
// Remove first the current clip rect if set
if (!iClipRect.IsEmpty())
{
DEBUG("CMMADisplay::RemoveClippingRegion: Removing old rect");
iDirectContainer->MdcRemoveContentBounds(iClipRect);
iClipRect.SetRect(0, 0, 0, 0);
// refresh screen
iDirectContainer->MdcFlushContainer(iWindow->WindowRect());
}
}
void CMMADisplay::AddClippingRegion()
{
// Called in mmapi thread
DEBUG("CMMADisplay::AddClippingRegion");
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())
{
DEBUG("CMMADisplay::AddClippingRegion: Adding new rect");
// Add new clipping rect
iDirectContainer->MdcAddContentBounds(iClipRect);
// refresh screen
iDirectContainer->MdcFlushContainer(
iWindow->WindowRect());
}
}
}
// from MMMADisplay
TSize CMMADisplay::DisplaySize()
{
if (iWindow && iFullScreen)
{
return iWindow->DrawRect().Size();
}
else
{
return iUserRect.Size();
}
}
// from MMMADisplay
void CMMADisplay::SetDisplaySizeL(const TSize& aSize)
{
// user rect contains size set from java.
iUserRect.SetSize(aSize);
// Size change has no effect if fullscreen mode is on.
// New size could be used when fullscreen is turned off.
if (iContainerVisible && !iFullScreen && iWindow)
{
RemoveClippingRegion();
iWindow->SetDrawRect(iUserRect);
AddClippingRegion();
}
else
{
iResetDrawRect = ETrue;
}
}
// from MMMADisplay
void CMMADisplay::SetVisible(TBool aValue)
{
iVisible = aValue;
// Window may be set visible only if container is on screen,
DEBUG_INT("MID::CMMADisplay::SetVisible + iContainerVisible = %d", iContainerVisible);
DEBUG_INT("MID::CMMADisplay::SetVisible iVisible = %d", iVisible);
if (!iIsForeground)
{
DEBUG("MID::CMMADisplay::SetVisible - iIsForeground = 0");
return;
}
// if not it can not be set visible.
if (iWindow && iContainerVisible)
{
iWindow->SetVisible(aValue, EFalse);
SetClippingRegion();
}
}
// 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()
{
DEBUG_INT("MID::CMMADisplay::IsVisible iContainerVisible = %d", iContainerVisible);
DEBUG_INT("MID::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;
}
void CMMADisplay::MdcContainerVisibilityChanged(TBool aVisible)
{
DEBUG_INT("MID::CMMADisplay::MdcContainerVisibilityChanged aVisible = %d",
aVisible);
if (!iIsForeground && aVisible)
{
DEBUG("MID::CMMADisplay::MdcContainerVisibilityChanged Condition 1 ");
return;
}
DEBUG("MID::CMMADisplay::MdcContainerVisibilityChanged After condition1");
iContainerVisible = aVisible;
if (iWindow)
{
// midlet comes to foreground (0 to 1 transition),
// Allow turn on or turn off based on aVisible
if (aVisible != iWindow->IsVisible())
{
// Allow
DEBUG("MID::CMMADisplay::MdcContainerVisibilityChanged Allow ");
}
else //if( iContainerVisible == aVisible )
{
DEBUG("MID::CMMADisplay::MdcContainerVisibilityChanged iContainerVisible == aVisible ");
// if state is not changed, we do not need to do it again
return;
}
}
DEBUG("MID::CMMADisplay::MdcContainerVisibilityChanged After condition2");
if (iWindow)
{
DEBUG("MID::CMMADisplay::MdcContainerVisibilityChanged iWindow is valid ");
// change is only needed if java side has set display visible or
// if container loses focus
if (!iContainerVisible || iVisible)
{
if (iResetDrawRect && aVisible && !iFullScreen)
{
iWindow->SetDrawRectThread(iUserRect);
iResetDrawRect = EFalse;
}
if (iIsForeground)
{
iWindow->SetVisible(aVisible);
}
SetClippingRegion();
}
}
}
void CMMADisplay::MdcItemContentRectChanged(const TRect& /*aContentRect*/,
const TRect& /*aScreenRect*/)
{
// To be overwritten if used
__ASSERT_DEBUG(EFalse, User::Invariant());
}
void CMMADisplay::MdcContainerWindowRectChanged(const TRect&
#ifdef RD_JAVA_NGA_ENABLED
aRect
#endif
)
{
DEBUG("CMMADisplay::MdcContainerWindowRectChanged +");
#ifdef RD_JAVA_NGA_ENABLED
if (iWindow)
{
DEBUG("CMMADisplay::MdcContainerWindowRectChanged, SetRWindowRect");
iWindow->SetRWindowRect(aRect, MMMADisplay::EUiThread);
}
#endif
}
void CMMADisplay::MdcContainerDestroyed()
{
DEBUG("MMA::CMMADisplay::MdcContainerDestroyed");
if (iWindow)
{
iWindow->ContainerDestroyed();
}
iDirectContainer = NULL;
}
void CMMADisplay::SetForeground(TBool aForeground, TBool aUseEventServer)
{
DEBUG_INT("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);
}
}
}
void CMMADisplay::MdcAbortDSA()
{
if (iWindow)
{
iWindow->AbortDSA();
}
}
void CMMADisplay::MdcResumeDSA()
{
if (iWindow)
{
iWindow->ResumeDSA();
}
}
void CMMADisplay::UIGetDSAResources(
MUiEventConsumer& aConsumer,
MMMADisplay::TThreadType /* aThreadType */)
{
if (iDirectContainer)
{
iDirectContainer->MdcGetDSAResources(aConsumer);
}
}
void CMMADisplay::UIGetCallback(
MUiEventConsumer& aConsumer,
TInt aCallbackId)
{
if (iDirectContainer)
{
iDirectContainer->MdcGetUICallback(aConsumer, aCallbackId);
}
}
void CMMADisplay::FixUIOrientation(TBool aFix)
{
if (iDirectContainer)
{
iDirectContainer->MdcFixUIOrientation(aFix);
}
}
// END OF FILE