--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uiacceltk/hitchcock/Client/src/alfdisplay.cpp Tue Feb 02 07:56:43 2010 +0200
@@ -0,0 +1,840 @@
+/*
+* Copyright (c) 2006 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: Display
+*
+*/
+
+
+
+#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
+#include <uikon/eikdefmacros.h>
+#endif
+#include <aknappui.h>
+#include <coecntrl.h>
+#include <coecobs.h>
+#include <gdi.h>
+#include <AknUtils.h>
+#include <babitflags.h>
+
+#include "alf/alfdisplay.h"
+#include "alfdisplaysubsession.h"
+#include "alf/alfroster.h"
+#include "alf/alfenv.h"
+#include "alfclient.h"
+#include "alf/alfevent.h"
+#include "alf/alfinputcapabilitiessupplier.h"
+#include "alflogger.h"
+#include "alf/alfevent.h"
+#include <alf/alfscreenbuffer.h>
+#include <alf/alfsymbiansbdrawer.h>
+
+#include "uiacceltk/HuiUtil.h"
+
+// Flags
+enum TAlfDisplayFlags
+ {
+ EAlfDisplayActive = 0x01,
+ EAlfDisplayUpdateRenderState = 0x02,
+ EAlfDisplayOwnRoster = 0x04
+ };
+
+// Default flags.
+const TUint KAlfDisplayDefaultFlags = 0x00;
+
+enum
+ {
+ EAlfDisplayRectCustom,
+ EAlfDisplayRectMainPane,
+ EAlfDisplayRectWholeSceen
+ };
+
+
+// Private data.
+struct CAlfDisplay::TPrivateData
+ {
+ TPrivateData():iEnv(0),iNativeControl(0),iRoster(0){}
+ RAlfDisplaySubSession iDisplaySubSession; // Owned
+ TUint iFlags; // Owned.
+ CAlfEnv* iEnv; // Not owned.
+ CAlfDisplayCoeControl* iNativeControl; // Owned.
+ CAlfRoster* iRoster; // Owned/not owned - see EAlfDisplayOwnRoster
+ TInt iDisplayRectType; // To allow automatic screensize change in layout switch
+ };
+
+// ======== LOCAL FUNCTIONS ========
+
+NONSHARABLE_CLASS( CAlfDisplayCoeControl ):
+ public CCoeControl
+ {
+public: // Enumerations
+ enum
+ {
+ EManipulatingInputFocusIndex,
+ EIsActiveIndex
+ };
+
+public:
+
+ CAlfDisplayCoeControl(){}
+ CAlfDisplayCoeControl( CAlfDisplay& aDisplay ) : iDisplay(&aDisplay){}
+ void SetFocusedEditor( MAlfInputCapabilitiesSupplier* aFocusedEditor );
+
+ /**
+ * This returns whether the CCoeControl is focused in general. However, during an operation where
+ * focus is temporarily withdrawn from the CCoeControl, this state will continue to return ETrue.
+ * This method cannot be called IsFocused since that would access the instantaneous
+ * CONE focus, which is not what is required here.
+ */
+ TBool IsActive() const;
+
+ /**
+ * Sets the active state according to the current focus state from CONE
+ */
+ void SetActiveState();
+
+ virtual void InitL();
+
+ virtual TBool DrawsIntoLocalWindow() const;
+
+protected:
+ TKeyResponse OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType);
+ void HandlePointerEventL(const TPointerEvent& aPointerEvent);
+ void HandleResourceChange(TInt aType);
+ /**
+ * From CCoeControl
+ */
+protected:
+ virtual TCoeInputCapabilities InputCapabilities() const;
+ virtual void FocusChanged(TDrawNow aDrawNow);
+
+protected:
+ CAlfDisplay* iDisplay;
+ MAlfInputCapabilitiesSupplier* iFocusedEditor;
+ TBitFlags iFlags; // Cleared at construction
+ };
+
+void CAlfDisplayCoeControl::InitL()
+ {
+ // Window is needed for HandleResourceChange to get events
+ CreateWindowL();
+ Window().EnableOSB(EFalse);
+ }
+
+
+TKeyResponse CAlfDisplayCoeControl::OfferKeyEventL(
+ const TKeyEvent& aKeyEvent,
+ TEventCode aType)
+ {
+ TAlfEvent event(*iDisplay, aKeyEvent, aType);
+ if(iDisplay->Roster().HandleEventL(event))
+ {
+ return EKeyWasConsumed;
+ }
+ return EKeyWasNotConsumed;
+ }
+
+
+void CAlfDisplayCoeControl::HandlePointerEventL(
+ const TPointerEvent& aPointerEvent)
+ {
+ CCoeControl::HandlePointerEventL( aPointerEvent );
+ }
+
+void CAlfDisplayCoeControl::HandleResourceChange(TInt aType)
+ {
+ CCoeControl::HandleResourceChange( aType );
+ if (aType == KEikDynamicLayoutVariantSwitch)
+ {
+ iDisplay->Env().ReportWsEventAsActionCommand(KAlfActionIdDeviceLayoutChanged);
+ }
+ }
+
+TCoeInputCapabilities CAlfDisplayCoeControl::InputCapabilities() const
+ {
+ if ( iFocusedEditor )
+ {
+ return iFocusedEditor->InputCapabilities();
+ }
+ else
+ {
+ TCoeInputCapabilities nullCapabilities(TCoeInputCapabilities::ENavigation);
+ return nullCapabilities;
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// Sets the pointer to the object supplying input capabilities.
+// This method needs to ensure that the FEP registers the change in focus of the AlfControl
+// - some sort of editor in this case.
+// ---------------------------------------------------------------------------
+//
+void CAlfDisplayCoeControl::SetFocusedEditor( MAlfInputCapabilitiesSupplier* aFocusedEditor )
+ {
+ // A flag is set to register the fact that we are currently manipulating focus of the CCoeControl, albeit temporarily.
+ // The flag is used by call-backs to suppress Alf reacting too deeply to the focus changes.
+ iFlags.Set( EManipulatingInputFocusIndex );
+ if ( !aFocusedEditor )
+ {
+ // The focus state of this CCoeControl must be preserved through this "kicking" of the FEP
+ // Use a local variable to highlight that the "IsActive" flag may change temporarily during this sequence
+ // (depending on implementation)
+ TBool focusStateToKeep = iFlags.IsSet( EIsActiveIndex );
+ if ( focusStateToKeep ) // No need to even remove focus if off already
+ {
+ SetFocus(EFalse, ENoDrawNow); // Forces focus off this
+ // Force removal of focus to be synchronous
+ ControlEnv()->SyncNotifyFocusObserversOfChangeInFocus();
+ }
+ iFocusedEditor = aFocusedEditor; // Removed only after FEP has taken focus off
+
+ if ( !IsFocused() && focusStateToKeep ) // Ensure focus gets put back on
+ {
+ SetFocus(ETrue, ENoDrawNow); // Forces focus on again but now there is no AlfControl
+ }
+ }
+ else
+ {
+ iFocusedEditor = aFocusedEditor; // Put in place before focus is forced on
+ SetFocus(ETrue, ENoDrawNow); // Forces focus onto this control
+ }
+ iFlags.Clear( EManipulatingInputFocusIndex );
+ }
+
+// ---------------------------------------------------------------------------
+// This is a call-back from CONE when the focus is changed on a this CCoeControl.
+// The roster must be kept "in step" with the focus change, and is called strictly
+// only when the focus state changes.
+// However Alf should not track focus changes when SetFocusedEditor is being processed
+// This interlock is effected by the ManipulatingInputFocus flag
+// ---------------------------------------------------------------------------
+void CAlfDisplayCoeControl::FocusChanged( TDrawNow aDrawNow )
+ {
+ if ( iFlags.IsClear( EManipulatingInputFocusIndex ) )
+ {
+ TBool coneFocus = IsFocused();
+ if ( !COMPARE_BOOLS(iFlags.IsSet( EIsActiveIndex ), coneFocus ) )
+ {
+ iFlags.Assign( EIsActiveIndex, coneFocus );
+ iDisplay->Roster().DisplayFocusChanged( *iDisplay, coneFocus );
+ }
+ }
+ CCoeControl::FocusChanged( aDrawNow );
+ }
+
+
+// ---------------------------------------------------------------------------
+// Implemenation of CCoeControl virtual.
+// Used here to set up the focus state at the construction point of the control.
+// ---------------------------------------------------------------------------
+void CAlfDisplayCoeControl::SetActiveState()
+ {
+ iFlags.Assign( EIsActiveIndex, IsFocused() );
+ iDisplay->Roster().DisplayFocusChanged( *iDisplay, iFlags.IsSet( EIsActiveIndex ) );
+ }
+
+TBool CAlfDisplayCoeControl::IsActive() const
+ {
+ return iFlags.IsSet( EIsActiveIndex );
+ }
+
+TBool CAlfDisplayCoeControl::DrawsIntoLocalWindow() const
+ {
+ return EFalse;
+ }
+
+//
+//
+//
+//
+NONSHARABLE_CLASS( CAlfDisplayOffScreenBufferCoeControl ):
+ public CAlfDisplayCoeControl, public MAlfScreenBufferObserver
+ {
+public:
+ CAlfDisplayOffScreenBufferCoeControl( CAlfDisplay& aDisplay );
+
+ ~CAlfDisplayOffScreenBufferCoeControl();
+
+ void InitL(TUid aBufferUid);
+
+ void Draw( const TRect& aRect ) const;
+
+ void SizeChanged();
+
+ TBool DrawsIntoLocalWindow() const;
+
+protected:
+ void HandlePointerEventL(const TPointerEvent& aPointerEvent);
+
+private: // From MAlfScreenBufferObserver
+
+ TBool BufferComplete(TUid aId, TRect& aDisplayRect, TRect& aDirtyRect);
+ void HandleScreenBufferEvent(TUid aId, TInt aEvent);
+
+private:
+ CAlfScreenBuffer* iAlfScreenBuffer;
+ TRect iDisplayRect;
+ CAlfSymbianBufferDrawer* iBufferDrawer;
+ TUid iBufferUid;
+ };
+
+CAlfDisplayOffScreenBufferCoeControl::CAlfDisplayOffScreenBufferCoeControl(CAlfDisplay& aDisplay)
+ {
+ iDisplay = &aDisplay;
+ }
+
+CAlfDisplayOffScreenBufferCoeControl::~CAlfDisplayOffScreenBufferCoeControl()
+ {
+ if(iBufferDrawer)
+ iBufferDrawer->ReleaseDrawer();
+ delete iAlfScreenBuffer;
+ }
+
+void CAlfDisplayOffScreenBufferCoeControl::InitL(TUid aBufferUid)
+ {
+ CAlfDisplayCoeControl::InitL();
+
+ // Set the windows size
+ SetRect( iDisplay->VisibleArea() );
+
+ // Activate the window, which makes it ready to be drawn
+ ActivateL();
+
+ iAlfScreenBuffer = CAlfScreenBuffer::NewL(iDisplay->Env());
+ iAlfScreenBuffer->AddObserverL(aBufferUid, this);
+ iBufferUid = aBufferUid;
+
+ EnableDragEvents();
+ }
+
+
+void CAlfDisplayOffScreenBufferCoeControl::Draw( const TRect& /*aRect*/ ) const
+ {
+ // Get the standard graphics context
+ CWindowGc& gc = SystemGc();
+
+ if (iBufferDrawer)
+ {
+ iBufferDrawer->DrawBuffer(gc, TPoint(), iDisplayRect);
+ }
+
+ }
+
+void CAlfDisplayOffScreenBufferCoeControl::SizeChanged()
+ {
+ DrawDeferred();
+ }
+
+TBool CAlfDisplayOffScreenBufferCoeControl::BufferComplete(TUid aId, TRect& aDisplayRect, TRect& /*aDirtyRect*/)
+ {
+ if (aId == iBufferUid)
+ {
+ if (!iBufferDrawer)
+ {
+ iBufferDrawer = (CAlfSymbianBufferDrawer*)iAlfScreenBuffer->GetDrawingInterface(KAlfSymbianBufferDrawerUid, iBufferUid);
+ }
+ iDisplayRect = aDisplayRect;
+ DrawNow();
+ }
+
+ return ETrue;
+ }
+
+
+void CAlfDisplayOffScreenBufferCoeControl::HandleScreenBufferEvent(TUid aId, TInt aEvent)
+ {
+ if (aId == iBufferUid)
+ {
+ if (aEvent == MAlfScreenBufferObserver::ECreated)
+ {
+ }
+ else if (aEvent == MAlfScreenBufferObserver::EDeleted)
+ {
+ // delete bitmap drawer etc.
+ if(iBufferDrawer)
+ iBufferDrawer->ReleaseDrawer();
+ iBufferDrawer = NULL;
+ // Draw
+ DrawNow();
+ }
+ }
+ }
+
+void CAlfDisplayOffScreenBufferCoeControl::HandlePointerEventL(
+ const TPointerEvent& aPointerEvent)
+ {
+ CCoeControl::HandlePointerEventL( aPointerEvent );
+ iDisplay->HandlePointerEventL( aPointerEvent );
+ }
+
+TBool CAlfDisplayOffScreenBufferCoeControl::DrawsIntoLocalWindow() const
+ {
+ return ETrue;
+ }
+
+
+// ======== MEMBER FUNCTIONS ========
+
+// ---------------------------------------------------------------------------
+// Constructor
+// ---------------------------------------------------------------------------
+//
+CAlfDisplay::CAlfDisplay()
+ {
+ }
+
+
+// ---------------------------------------------------------------------------
+// ConstructL
+// ---------------------------------------------------------------------------
+//
+void CAlfDisplay::ConstructL(
+ CAlfEnv& aEnv,
+ TBool aAsCoeControl,
+ const TRect& aRect,
+ CAlfRoster* aSharedRoster,
+ TInt aDisplayType,
+ TUid aBufferUid)
+ {
+ iData = new (ELeave) TPrivateData;
+
+ User::LeaveIfError( iData->iDisplaySubSession.Open(aEnv.Client(), aRect, aDisplayType, aBufferUid) );
+
+
+ iData->iFlags = KAlfDisplayDefaultFlags;
+
+ iData->iEnv = &aEnv;
+ iData->iNativeControl = NULL;
+ iData->iFlags |= EAlfDisplayActive;
+ iData->iFlags |= EAlfDisplayUpdateRenderState;
+
+
+ // Create a control roster.
+ if(aSharedRoster)
+ {
+ iData->iRoster = aSharedRoster;
+ iData->iFlags &= ~EAlfDisplayOwnRoster;
+ }
+ else
+ {
+ // Construct a private roster.
+ CAlfRoster* roster = new (ELeave) CAlfRoster;
+ CleanupStack::PushL(roster);
+ roster->ConstructL(this);
+ CleanupStack::Pop(roster);
+ iData->iRoster= roster;
+ iData->iFlags |= EAlfDisplayOwnRoster;
+ }
+
+ if ( aAsCoeControl )
+ {
+ if (aDisplayType == EDisplayOffScreenBuffer && aBufferUid.iUid != 0)
+ {
+ CAlfDisplayOffScreenBufferCoeControl* osbf = new (ELeave) CAlfDisplayOffScreenBufferCoeControl(*this);
+ iData->iNativeControl = osbf;
+ iData->iNativeControl->SetMopParent( iAvkonAppUi );
+ CCoeEnv::Static()->AppUi()->AddToStackL(iData->iNativeControl);
+ iData->iNativeControl->SetActiveState();
+ osbf->InitL(aBufferUid);
+ }
+ else
+ {
+ iData->iNativeControl = new (ELeave) CAlfDisplayCoeControl(*this);
+ iData->iNativeControl->SetMopParent( iAvkonAppUi );
+ CCoeEnv::Static()->AppUi()->AddToStackL(iData->iNativeControl);
+ iData->iNativeControl->SetActiveState();
+ iData->iNativeControl->InitL();
+ }
+ }
+
+ iData->iDisplayRectType = EAlfDisplayRectCustom;
+ if ( CCoeEnv::Static() ) // check that we are running this from Symbian application
+ {
+ CheckScreenRect(aRect);
+
+ // In case of display is created after application has already received foregound
+ // we notify just to make sure we really have foreground
+ aEnv.Client().ApplicationIsForeground(iAvkonAppUi->IsForeground() ||
+ iAvkonAppUi->IsPartialForeground());
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// Destructor
+// ---------------------------------------------------------------------------
+//
+CAlfDisplay::~CAlfDisplay()
+ {
+ if ( iData )
+ {
+ if ( (iData->iFlags&EAlfDisplayOwnRoster) && iData->iRoster )
+ {
+ delete iData->iRoster;
+ }
+ iData->iFlags &= ~EAlfDisplayOwnRoster;
+ iData->iRoster = NULL;
+
+ if ( iData->iNativeControl )
+ {
+ CCoeEnv::Static()->AppUi()->RemoveFromStack(iData->iNativeControl);
+ delete iData->iNativeControl;
+ iData->iNativeControl = NULL;
+ }
+
+ if ( iData->iEnv )
+ {
+ iData->iEnv->RemoveDisplay(*this);
+ }
+
+ iData->iDisplaySubSession.Close();
+ }
+
+ delete iData;
+ iData = NULL;
+ }
+
+// ---------------------------------------------------------------------------
+// Sets clear background method
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CAlfDisplay::SetClearBackgroundL(TInt aClearBackground)
+ {
+ TInt err =
+ iData->iDisplaySubSession.SetClearBackground(
+ aClearBackground );
+
+ if ( err != KErrNone )
+ {
+ __ALFLOGSTRING1( "CAlfDisplay::SetClearBackgroundL leave error %d", err )
+ User::Leave( err );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// Returns roster
+// ---------------------------------------------------------------------------
+//
+EXPORT_C CAlfRoster& CAlfDisplay::Roster()
+ {
+ __ASSERT_ALWAYS( iData, USER_INVARIANT() );
+ __ASSERT_ALWAYS( iData->iRoster, USER_INVARIANT() );
+ return *iData->iRoster;
+ }
+
+// ---------------------------------------------------------------------------
+// Returns roster
+// ---------------------------------------------------------------------------
+//
+EXPORT_C const CAlfRoster& CAlfDisplay::Roster() const
+ {
+ __ASSERT_ALWAYS( iData, USER_INVARIANT() );
+ __ASSERT_ALWAYS( iData->iRoster, USER_INVARIANT() );
+ return *iData->iRoster;
+ }
+
+// ---------------------------------------------------------------------------
+// Sets visible area.
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CAlfDisplay::SetVisibleArea(const TRect& aArea)
+ {
+ TInt err = iData->iDisplaySubSession.SetVisibleArea( aArea );
+
+ if ( err != KErrNone )
+ {
+ // panic?
+ __ALFLOGSTRING1( "CAlfDisplay::SetVisibleArea ignore error %d", err )
+ }
+
+ if ( CCoeEnv::Static() ) // check that we are running this from Symbian application
+ {
+ CheckScreenRect(aArea);
+
+ // If offscreenbuffer is drawn, then set its rect too.
+ if (iData->iNativeControl && iData->iNativeControl->DrawsIntoLocalWindow())
+ {
+ iData->iNativeControl->SetRect(aArea);
+ }
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// Sets visible area.
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CAlfDisplay::ForceSetVisibleArea(const TRect& aArea)
+ {
+ // forces to set visible area
+ TInt err = iData->iDisplaySubSession.SetVisibleArea( aArea, ETrue );
+
+ if ( err != KErrNone )
+ {
+ // panic?
+ __ALFLOGSTRING1( "CAlfDisplay::ForceSetVisibleArea ignore error %d", err )
+ }
+
+ if ( CCoeEnv::Static() ) // check that we are running this from Symbian application
+ {
+ CheckScreenRect(aArea);
+
+ // If offscreenbuffer is drawn, then set its rect too.
+ if (iData->iNativeControl && iData->iNativeControl->DrawsIntoLocalWindow())
+ {
+ iData->iNativeControl->SetRect(aArea);
+ }
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// Returns visible area
+// ---------------------------------------------------------------------------
+//
+EXPORT_C TRect CAlfDisplay::VisibleArea() const
+ {
+ TRect area(0,0,0,0);
+
+ TInt err = iData->iDisplaySubSession.VisibleArea( area );
+
+ if ( err != KErrNone )
+ {
+ // panic?
+ __ALFLOGSTRING1( "CAlfDisplay::VisibleArea ignore error %d", err )
+ }
+
+ return area;
+ }
+
+// ---------------------------------------------------------------------------
+// Returns env.
+// ---------------------------------------------------------------------------
+//
+EXPORT_C CAlfEnv& CAlfDisplay::Env()
+ {
+ return *iData->iEnv;
+ }
+
+
+// ---------------------------------------------------------------------------
+// Returns server handle
+// ---------------------------------------------------------------------------
+//
+TInt CAlfDisplay::ServerHandle() const
+ {
+ return iData->iDisplaySubSession.SubSessionHandle();
+ }
+// ---------------------------------------------------------------------------
+// Set the current focused editor.
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CAlfDisplay::SetFocusedEditor( MAlfInputCapabilitiesSupplier* aCurrentEditor )
+ {
+ __ASSERT_ALWAYS(iData->iNativeControl, USER_INVARIANT() );
+ iData->iNativeControl->SetFocusedEditor(aCurrentEditor);
+ }
+
+// ---------------------------------------------------------------------------
+// Set display dirty.
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CAlfDisplay::SetDirty()
+ {
+ iData->iDisplaySubSession.SetDirty();
+ }
+
+// ---------------------------------------------------------------------------
+// Set display rendering quality.
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CAlfDisplay::SetQuality(TAlfQuality aRenderingQuality)
+ {
+ TInt err = iData->iDisplaySubSession.SetQuality(aRenderingQuality);
+ if ( err != KErrNone )
+ {
+ // panic?
+ __ALFLOGSTRING1( "CAlfDisplay::SetQuality ignore error %d", err )
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// Get display rendering quality.
+// ---------------------------------------------------------------------------
+//
+EXPORT_C TAlfQuality CAlfDisplay::Quality() const
+ {
+ TAlfQuality renderingQuality;
+ TInt err = iData->iDisplaySubSession.Quality(renderingQuality);
+ if ( err != KErrNone )
+ {
+ // panic?
+ __ALFLOGSTRING1( "CAlfDisplay::Quality ignore error %d", err )
+ }
+ return renderingQuality;
+ }
+
+// ---------------------------------------------------------------------------
+// Set display depth test use
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CAlfDisplay::SetUseDepth(TBool aUseDepth)
+ {
+ TInt err = iData->iDisplaySubSession.SetUseDepth(aUseDepth);
+ if ( err != KErrNone )
+ {
+ // panic?
+ __ALFLOGSTRING1( "CAlfDisplay::SetUseDepth ignore error %d", err )
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// Handles layout switch
+// ---------------------------------------------------------------------------
+//
+void CAlfDisplay::NotifyLayoutChangedL()
+ {
+ // If screen size had been set to main pane or whole screen,
+ // set it automatically here to new value.
+ // Otherwise let application handle it.
+ if (iData->iDisplayRectType == EAlfDisplayRectMainPane)
+ {
+ TRect metricsRect = TRect(0,0,0,0);
+ AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EMainPane, metricsRect);
+ ForceSetVisibleArea(metricsRect);
+ }
+ else if (iData->iDisplayRectType == EAlfDisplayRectWholeSceen)
+ {
+ TRect metricsRect = TRect(0,0,0,0);
+ AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EScreen, metricsRect);
+ ForceSetVisibleArea(metricsRect);
+ }
+ else
+ {
+ // for PC lint
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CAlfDisplay::CheckScreenRect(TRect aRect)
+ {
+ TRect mainpaneRect = TRect(0,0,0,0);
+ AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EMainPane, mainpaneRect);
+
+ TRect screenRect = TRect(0,0,0,0);
+ AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EScreen, screenRect);
+
+ if (aRect == mainpaneRect)
+ {
+ iData->iDisplayRectType = EAlfDisplayRectMainPane;
+ }
+ else if (aRect == screenRect)
+ {
+ iData->iDisplayRectType = EAlfDisplayRectWholeSceen;
+ }
+ else
+ {
+ iData->iDisplayRectType = EAlfDisplayRectCustom;
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// Access the object provider for the display.
+// ---------------------------------------------------------------------------
+//
+EXPORT_C MObjectProvider* CAlfDisplay::ObjectProvider() const
+ {
+ return iData->iNativeControl;
+ }
+
+TBool CAlfDisplay::IsFocused() const
+ {
+ return iData->iNativeControl ? iData->iNativeControl->IsActive() : ETrue;
+ }
+
+
+// ---------------------------------------------------------------------------
+// Sets usage hint
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CAlfDisplay::SetUsageL(TUint aUsageHint)
+ {
+ TInt err = iData->iDisplaySubSession.SetUsage(aUsageHint);
+ if ( err != KErrNone )
+ {
+ __ALFLOGSTRING1( "CAlfDisplay::SetUsageL leave error %d", err )
+ User::Leave( err );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// Suppresses automatic fading
+// ---------------------------------------------------------------------------
+//
+EXPORT_C TInt CAlfDisplay::SuppressAutomaticFading( TBool aSuppress )
+ {
+ TInt err = iData->iDisplaySubSession.SuppressAutomaticFading( aSuppress );
+ if ( err != KErrNone )
+ {
+ __ALFLOGSTRING1( "CAlfDisplay::SuppressAutomaticFading return error %d", err )
+ }
+ return err;
+ }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CAlfDisplay::SetBackgroundItemsL(const RArray<TAlfDisplayBackgroundItem>& aItems)
+ {
+ TInt err = iData->iDisplaySubSession.SetBackgroundItemsL(aItems);
+ if ( err != KErrNone )
+ {
+ __ALFLOGSTRING1( "CAlfDisplay::SetBackgroundItemsL ignore error %d", err )
+ }
+ }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CAlfDisplay::HandlePointerEventL(const TPointerEvent& aPointerEvent)
+ {
+ TInt err = iData->iDisplaySubSession.HandlePointerEventL(aPointerEvent);
+ if ( err != KErrNone )
+ {
+ __ALFLOGSTRING1( "CAlfDisplay::HandlePointerEventL ignore error %d", err )
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+
+EXPORT_C void CAlfDisplay::SetClientWindowForDrawingL(RWindow* aWindow, CAlfVisual* aVisual)
+ {
+ TInt windowGroupId = 0;
+ TInt clientWindowHandle = 0;
+ TInt visualHandle = NULL;
+ windowGroupId = aWindow->WindowGroupId();
+ clientWindowHandle = aWindow->ClientHandle();
+ if (aVisual)
+ {
+ visualHandle = aVisual->Identifier();
+ }
+ iData->iDisplaySubSession.SetClientWindowForDrawingL(windowGroupId, clientWindowHandle, visualHandle);
+ }