diff -r 000000000000 -r 2f259fa3e83a uifw/AvKon/src/aknsgcc.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/uifw/AvKon/src/aknsgcc.cpp	Tue Feb 02 01:00:49 2010 +0200
@@ -0,0 +1,767 @@
+/*
+* Copyright (c) 2002 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: 
+*
+*/
+
+#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
+#include <uikon/eikenvinterface.h>
+#include <uikon/eikdefmacros.h>
+#endif
+#include "AknSgcc.h"
+#include <eikspane.h>
+#include <eikappui.h>
+#include <eikenv.h>
+#include <barsread.h>
+#include <AknPriv.hrh>
+#include <aknenv.h>
+#include <aknconsts.h>
+#include "AknDef.h"
+#include <aknappui.h>
+#include "AknSettingCache.h"
+#include "AknLayoutConfig.h"
+#include "UikonInternalPSKeys.h"
+#include "AknPanic.h"
+
+#define KLegacyScreenSize TSize(176, 208)
+
+const TUid KAknSgcClientStaticId = { 0x101f7674 };
+const TUint32 KPeninputServerUid = 0x10281855;
+
+const TInt KStartupUnblankPriority = 10000;
+
+enum TSgcClientFlags
+	{
+	EHandlingChange,
+	EInAknSrv,
+	ESystemFaded,
+	ENeverRelinquish
+	};
+
+
+NONSHARABLE_CLASS(CAknSgcClientImpl) : public CAknSgcImpl
+	{
+public:
+	CAknSgcClientImpl(RAknUiServer& aAknSrv);
+    void MoveApp(TInt aAppWindowGroupId, TSgcMoveAppToWhere aWhere);
+
+private:
+	RAknUiServer& iAknSrv;
+	};
+
+
+NONSHARABLE_CLASS(CAknSgcClientServerInst) : public CAknSgcClient
+	{
+public:
+	CAknSgcClientServerInst();
+	~CAknSgcClientServerInst();
+private: // from CAknSgcClient
+    const TDesC8& DoLayoutConfigBuf();
+	void ConstructL();
+private:
+	HBufC8* iPackedLayoutConfigBuf;
+	};
+
+
+EXPORT_C void MAknSgcStatusPaneRedrawCoordinator::MAknSgcStatusPaneRedrawCoordinator_Reserved_1() {}
+EXPORT_C void MAknSgcStatusPaneRedrawCoordinator::MAknSgcStatusPaneRedrawCoordinator_Reserved_2() {}
+
+
+inline CAknSgcClient* CAknSgcClient::Static()
+	{ return static_cast<CAknSgcClient*>(CCoeEnv::Static(KAknSgcClientStaticId)); }
+
+
+
+NONSHARABLE_CLASS(TSgcClientStatusPaneRedrawCoordinator) : public MAknSgcStatusPaneRedrawCoordinator
+	{
+public:
+	TSgcClientStatusPaneRedrawCoordinator(RAknUiServer& aAknSrv);
+	void BlockServerStatusPaneRedrawsL();
+	void RedrawServerStatusPane();
+	
+private:
+	RAknUiServer& iAknSrv;
+	};
+
+TSgcClientStatusPaneRedrawCoordinator::TSgcClientStatusPaneRedrawCoordinator(RAknUiServer& aAknSrv)
+: iAknSrv(aAknSrv)
+	{
+	}
+
+void TSgcClientStatusPaneRedrawCoordinator::BlockServerStatusPaneRedrawsL()
+	{
+	}
+
+void TSgcClientStatusPaneRedrawCoordinator::RedrawServerStatusPane()
+	{
+	iAknSrv.RedrawServerStatusPane();
+	}
+
+
+
+EXPORT_C void CAknSgcClient::CreateL()
+	{
+	CAknSgcClient* self=CAknSgcClient::Static();
+	if (!self)
+		{
+		RThread thread;
+		if (thread.Name() == _L("akncapserver"))
+			self = new(ELeave) CAknSgcClientServerInst();  // CCoeEnv takes ownership immediately
+		else
+			self = new(ELeave) CAknSgcClient(); // CCoeEnv takes ownership immediately
+		self->ConstructL();
+		}
+	}
+
+CAknSgcClient::~CAknSgcClient()
+	{
+	delete iImpl;
+	delete iLayoutConfig;
+	if (!iFlags[EInAknSrv])
+		{
+    	DoStartupUnblank();
+		// iSpRedrawCoord and iAknSrv are only owned/opened if this object
+		// is not running in the AknSrv process (see ConstructL()).
+		delete static_cast<TSgcClientStatusPaneRedrawCoordinator*>(iSpRedrawCoord);
+		iAknSrv.Close();
+		}
+	delete iDrawSync;
+	}
+
+void CAknSgcClient::ClearHandlingChangeFlag(TAny* aThis)
+	{
+	static_cast<CAknSgcClient*>(aThis)->iFlags.Clear(EHandlingChange);
+	}
+
+EXPORT_C void CAknSgcClient::HandleChangeL()
+	{
+	CAknSgcClient* self = Static();
+	if (self)
+		self->DoHandleChangeL();
+	}
+
+void CAknSgcClient::DoHandleChangeL()
+	{
+	if (iFlags[EInAknSrv])
+		return;
+
+	CAknAppUi* topAppUi = iAvkonAppUi;
+
+	if (!topAppUi)
+		return;
+
+	if (iFlags[EHandlingChange])
+		return;
+	iFlags.Set(EHandlingChange);
+	CleanupStack::PushL(TCleanupItem(ClearHandlingChangeFlag, this));
+
+	TInt spLayout = 0;
+	TInt spFlags = 0;
+	TBitFlags appFlags;
+	TInt screenMode = KAknScreenModeUnset;
+	SetLegacyOrientationAndScreenModeAppUiFlags(appFlags, screenMode, topAppUi);
+	appFlags.Assign(EFullScreen, topAppUi->IsFullScreenApp());
+	TBool partialFg = topAppUi->IsPartialForeground();
+	TBool foreground = topAppUi->IsForeground();
+
+	// loop over app UIs from most embedded to base app
+	for (CAknAppUiBase* appUi = static_cast<CAknAppUiBase*>(topAppUi); appUi; appUi = static_cast<CAknAppUiBase*>(appUi->ContainerAppUi()))
+		{
+		CEikStatusPane* sp = StatusPane(appUi);
+		if (sp && !spLayout)
+			{
+			spLayout = sp->CurrentLayoutResId();
+			spFlags = sp->Flags();
+			}
+
+		if (appUi != topAppUi)
+			{
+			SetLegacyOrientationAndScreenModeAppUiFlags(appFlags, screenMode, appUi);
+
+			partialFg = (foreground || partialFg) && !appFlags[EFullScreen];
+			foreground = EFalse;
+			appFlags.Assign(EFullScreen, appFlags[EFullScreen] || appUi->IsFullScreenApp());
+
+			SetAppUiForegroundL(appUi, foreground);
+			SetAppUiPartialFgL(appUi, partialFg);
+			}
+		}
+
+	if (spLayout != iSpLayout || 
+	    !(appFlags == iAppFlags) || 
+	    spFlags != iSpFlags ||
+	    screenMode != iAppScreenMode)
+		{
+		iSpLayout = spLayout;
+		iSpFlags = spFlags;
+		iAppFlags = appFlags;
+		iAppScreenMode = screenMode;
+		User::LeaveIfError(iAknSrv.SetSgcParams(iEikonEnv->RootWin().Identifier(), appFlags, spLayout, spFlags, screenMode));
+		}
+
+	CleanupStack::PopAndDestroy();
+	}
+
+CAknSgcClient::CAknSgcClient()
+: CCoeStatic(KAknSgcClientStaticId), iCoeEnv(CCoeEnv::Static())
+	{
+	}
+
+void CAknSgcClient::BaseConstructL()
+	{
+	RProcess process;
+	if( process.SecureId() == KPeninputServerUid )
+	    {
+	    iFlags.Set(ENeverRelinquish);
+	    }
+	
+	iDrawSync = CAknDrawSynchronizer::NewL();
+	iLayoutConfig = new(ELeave) CAknLayoutConfig;
+	}
+	
+void CAknSgcClient::ConstructL()
+	{
+	BaseConstructL();
+	
+	User::LeaveIfError(iAknSrv.Connect());
+	iSpRedrawCoord = new(ELeave) TSgcClientStatusPaneRedrawCoordinator(iAknSrv);
+	SetImpl(new(ELeave) CAknSgcClientImpl(iAknSrv));
+
+    if(iAvkonEnv->HasBlank())
+        StartupBlankL();
+
+	HBufC8* packedBuf;
+	if (iAknSrv.Handle())
+		{
+		packedBuf = iAknSrv.GetPackedConfigL();
+		}
+	else
+		{	// eiksrv will end up here
+		packedBuf = iLayoutConfig->CreatePackedBufL();
+		}
+	iLayoutConfig->ConstructL(packedBuf);
+	}
+
+CEikStatusPane* CAknSgcClient::StatusPane(CEikAppUi* aAppUi)
+	{
+	MEikAppUiFactory* factory = iEikonEnv->AppUiFactory(*aAppUi);
+	if (factory)
+		return factory->StatusPane();
+	else
+		return NULL;
+	}
+
+void CAknSgcClient::SetAppUiForegroundL(CAknAppUiBase* aAppUi, TBool aForeground)
+	{
+	if (!COMPARE_BOOLS(aAppUi->IsForeground(), aForeground))
+		SimulateWsEventL(aAppUi, aForeground ? EEventFocusGained : EEventFocusLost);
+	}
+
+void CAknSgcClient::SetAppUiPartialFgL(CAknAppUiBase* aAppUi, TBool aPartialFg)
+	{
+	if (!COMPARE_BOOLS(aAppUi->IsPartialForeground(), aPartialFg))
+		SimulateWsEventL(aAppUi, aPartialFg ? KEikPartialForeground : KEikClearPartialForegroundState);
+	}
+
+void CAknSgcClient::SimulateWsEventL(CEikAppUi* aAppUi, TInt aEventId)
+	{
+	TWsEvent event;
+	event.SetType(aEventId);
+	event.SetHandle(0);
+#if (defined(SYMBIAN_SUPPORT_UI_FRAMEWORKS_V1) || defined(__SERIES60_27__) || defined(__SERIES60_28__)) 
+	static_cast<CCoeAppUiBase*>(aAppUi)->HandleWsEventL(event, NULL);	
+#else 
+	static_cast<CCoeAppUi*>(aAppUi)->HandleWsEventL(event, NULL);
+#endif 
+	}
+
+EXPORT_C RAknUiServer* CAknSgcClient::AknSrv()
+	{
+	CAknSgcClient* self = Static();
+	if (self)
+		return &self->iAknSrv;
+	else
+		return NULL;
+	}
+
+EXPORT_C void CAknSgcClient::SetStatusPaneRedrawCoordinator(MAknSgcStatusPaneRedrawCoordinator* aSpRedrawCoord)
+	{
+	CAknSgcClient* self = Static();
+	if (self)
+		{
+		ASSERT(!self->iSpRedrawCoord || !aSpRedrawCoord);
+		self->iSpRedrawCoord = aSpRedrawCoord;
+		}
+	}
+
+EXPORT_C void CAknSgcClient::BlockServerStatusPaneRedrawsL()
+	{
+	}
+
+EXPORT_C void CAknSgcClient::RedrawServerStatusPane()
+	{
+	CAknSgcClient* self = Static();
+	if (self && self->iSpRedrawCoord)
+		self->iSpRedrawCoord->RedrawServerStatusPane();
+	}
+
+EXPORT_C CAknDrawSynchronizer* CAknSgcClient::DrawSynchronizer()
+	{
+	CAknSgcClient* self = Static();
+	if (self)
+		return self->iDrawSync;
+	else
+		return NULL;
+	}
+
+EXPORT_C void CAknSgcClient::PrepareForAppExit()
+	{
+	CAknSgcClient* self = Static();
+	if (self)
+		self->DoPrepareForAppExit();
+	}
+
+void CAknSgcClient::DoPrepareForAppExit()
+	{
+	if (!iFlags[EInAknSrv])
+		{
+		iAknSrv.PrepareForAppExit(iEikonEnv->RootWin().Identifier());
+		}
+	}
+
+EXPORT_C void CAknSgcClient::SetSystemFaded(TBool aFade)
+	{
+	CAknSgcClient* self = Static();
+	if (self)
+		self->DoSetSystemFaded(aFade);
+	}
+
+EXPORT_C TBool CAknSgcClient::IsSystemFaded()
+	{
+	CAknSgcClient* self = Static();
+	if (self)
+		return self->DoIsSystemFaded();
+	else
+		return EFalse;
+	}
+
+void CAknSgcClient::DoSetSystemFaded(TBool aFade)
+	{
+	if (iFlags[EInAknSrv])
+		{
+		if (!COMPARE_BOOLS(iFlags[ESystemFaded], aFade))
+			{
+			if (aFade)
+				{
+				RedrawServerStatusPane();
+				}
+			}
+		iEikonEnv->WsSession().SetSystemFaded(aFade);
+		iFlags.Assign(ESystemFaded, aFade);	
+		}
+	else
+		{
+		iAknSrv.SetSystemFaded(aFade);
+		}
+	}
+
+TBool CAknSgcClient::DoIsSystemFaded() const
+	{
+	if (iFlags[EInAknSrv])
+		{
+		return iFlags[ESystemFaded];
+		}
+	else
+		{
+		TBool fade;
+		iAknSrv.IsSystemFaded(fade);
+		return fade;
+		}
+	}
+
+void CAknSgcClient::SetLegacyOrientationAndScreenModeAppUiFlags(TBitFlags& aAppFlags, TInt& aScreenMode, CAknAppUiBase* aAppUi)
+	{
+	if (!aAppFlags[EFullScreen] && aAppUi->IsFullScreenApp())
+		{
+	//	aAppFlags.Assign(ELegacyLayout, !aAppUi->IsLayoutAwareApp()); // Fix Me !!
+		CAknAppUiBase::TAppUiOrientation r = aAppUi->Orientation();
+		aAppFlags.Assign(EOrientationSpecified, r != CAknAppUiBase::EAppUiOrientationUnspecified);
+		aAppFlags.Assign(EOrientationLandscape, r == CAknAppUiBase::EAppUiOrientationLandscape);
+		aScreenMode = aAppUi->ScreenMode();
+		}
+	}
+
+EXPORT_C TPixelsTwipsAndRotation CAknSgcClient::PixelsAndRotation()
+	{
+	CAknSgcClient* self = Static();
+	if (self)
+		{
+		TBitFlags& flags = self->iAppFlags;
+    	TInt mode = self->iAppScreenMode;
+		return self->DoCalculatePixelsAndRotation(flags[EFullScreen], flags[ELegacyLayout], flags[EOrientationSpecified], flags[EOrientationLandscape], mode);
+		}
+	else
+		{
+		TPixelsTwipsAndRotation r;
+		CEikonEnv::Static()->ScreenDevice()->GetDefaultScreenSizeAndRotation(r);
+		return r;
+		}
+	}
+
+inline TBool AspectIsLandscape(const TPixelsTwipsAndRotation& aR)
+	{
+	return aR.iPixelSize.iWidth > aR.iPixelSize.iHeight;
+	}
+
+EXPORT_C TPixelsTwipsAndRotation CAknSgcClient::CalculatePixelsAndRotation(TBool aFullScreen, TBool aLegacyApp, TBool aAppOrientationSpecified, TBool aAppOrientationLandscape)
+	{
+	CAknSgcClient* self = Static();
+	if (self)
+		{
+		return self->DoCalculatePixelsAndRotation(aFullScreen, aLegacyApp, aAppOrientationSpecified, aAppOrientationLandscape, KAknScreenModeUnset);
+		}
+	else
+		{
+		TPixelsTwipsAndRotation r;
+		CEikonEnv::Static()->ScreenDevice()->GetDefaultScreenSizeAndRotation(r);
+		return r;
+		}
+	}
+
+TPixelsTwipsAndRotation CAknSgcClient::DoCalculatePixelsAndRotation(TBool aFullScreen, TBool aLegacyApp, TBool aAppOrientationSpecified, TBool aAppOrientationLandscape, TInt aAppScreenMode)
+	{
+	CAknLayoutConfig::TScreenMode screenMode = DoCalculateScreenMode(aFullScreen, aAppOrientationSpecified, aAppOrientationLandscape, aAppScreenMode);
+	TPixelsTwipsAndRotation r = screenMode.PixelsTwipsAndRotation();
+
+	// legacy mode
+	if (aLegacyApp && aFullScreen)
+		r.iPixelSize = KLegacyScreenSize;
+
+	return r;
+	}
+	
+EXPORT_C CAknLayoutConfig::TScreenMode CAknSgcClient::ScreenMode()
+	{
+	CAknSgcClient* self = Static();
+	__ASSERT_ALWAYS(self, Panic(EAknPanicSgccNull));
+	TBitFlags& flags = self->iAppFlags;
+	TInt mode = self->iAppScreenMode;
+	return self->DoCalculateScreenMode(flags[EFullScreen], flags[EOrientationSpecified], flags[EOrientationLandscape], mode);
+	}
+
+EXPORT_C CAknLayoutConfig::TScreenMode CAknSgcClient::CalculateScreenMode(TBool aFullScreen, TBool aAppOrientationSpecified, TBool aAppOrientationLandscape)
+	{
+	return CalculateScreenMode(aFullScreen, aAppOrientationSpecified, aAppOrientationLandscape, KAknScreenModeUnset);
+	}
+
+EXPORT_C CAknLayoutConfig::TScreenMode CAknSgcClient::CalculateScreenMode(TBool aFullScreen, TBool aAppOrientationSpecified, TBool aAppOrientationLandscape, TInt aAppScreenMode)
+	{
+	CAknSgcClient* self = Static();
+	__ASSERT_ALWAYS(self, Panic(EAknPanicSgccNull));
+	return self->DoCalculateScreenMode(aFullScreen, aAppOrientationSpecified, aAppOrientationLandscape, aAppScreenMode);
+	}
+
+CAknLayoutConfig::TScreenMode CAknSgcClient::DoCalculateScreenMode(TBool aFullScreen, TBool aAppOrientationSpecified, TBool aAppOrientationLandscape, TInt aAppScreenMode)
+	{
+	if (!aFullScreen)
+		{
+		// return current screen mode for partial screen apps
+		return iLayoutConfig->ScreenModes().Find(iEikonEnv->ScreenDevice()->CurrentScreenMode());
+		}
+
+    if (aAppScreenMode != KAknScreenModeUnset)
+		{
+		// return current screen mode set by the app
+		return iLayoutConfig->ScreenModes().Find(aAppScreenMode);
+		}
+
+	TInt hwStateNum = iAvkonEnv->SettingCache().HardwareLayoutState();
+	CAknLayoutConfig::THardwareState hwScreen = iLayoutConfig->HardwareStates().Find(hwStateNum);
+
+    TInt mode;
+    TInt orientation = iAvkonEnv->SettingCache().PreferredOrientation();
+    if ( orientation == EPreferredOrientationNormal )
+        {
+        mode = hwScreen.ScreenMode();
+        }
+    else
+        {
+        mode = hwScreen.AlternateScreenMode();
+        }
+
+	CAknLayoutConfig::TScreenMode screenMode = iLayoutConfig->ScreenModes().Find(mode);
+	
+	if (aAppOrientationSpecified &&
+		!COMPARE_BOOLS(aAppOrientationLandscape, AspectIsLandscape(screenMode.PixelsTwipsAndRotation())))
+		{
+        if ( orientation == EPreferredOrientationNormal )
+            {
+    		// App rotation specificied but orientation is different to hw state
+	    	// so use alternate mode
+            mode = hwScreen.AlternateScreenMode();
+            }
+        else 
+            {
+            mode = hwScreen.ScreenMode();
+            }
+		return iLayoutConfig->ScreenModes().Find(mode);
+		}
+		
+	return screenMode;
+	}
+
+EXPORT_C void CAknSgcClient::SetKeyBlockMode(TAknKeySoundOpcode aMode)
+    {
+	CAknSgcClient* self = Static();
+	if (self)
+        {
+        self->DoSetKeyBlockMode(aMode);
+        }
+    }
+
+EXPORT_C void CAknSgcClient::SetKeyboardRepeatRate(TAknDefaultKeyboardRepeatRate aRate)
+    {
+	CAknSgcClient* self = Static();
+	if (self)
+        {
+        self->DoSetKeyboardRepeatRate(aRate);
+        }
+    }
+
+EXPORT_C TInt CAknSgcClient::CurrentStatuspaneResource()
+    {
+	CAknSgcClient* self = Static();
+	if (self)
+        {
+        return self->DoAskCurrentStatuspaneResource();
+        }
+        
+    return 0; // not able to resolve
+    }
+    
+
+TInt CAknSgcClient::DoAskCurrentStatuspaneResource()
+    {
+    if (CEikStatusPaneBase::Current())
+        {
+        return CEikStatusPaneBase::Current()->CurrentLayoutResId();
+        }
+    else 
+        return iAknSrv.StatusPaneResourceId();   
+    }
+
+void CAknSgcClient::DoSetKeyBlockMode(TAknKeySoundOpcode aMode)
+    {
+	if (iFlags[EInAknSrv])
+		{
+        TRawEvent event;
+        TAknKeySoundOpcode opcode = EEnableKeyBlock; // default
+	    if (aMode == ENoKeyBlock)
+		    {
+		    opcode = EDisableKeyBlock;
+		    }
+	    event.Set((TRawEvent::TType)opcode);
+        iEikonEnv->WsSession().SimulateRawEvent(event);		
+		}
+	else
+		{
+		iAknSrv.SetKeyblockMode(aMode);
+		}
+    }
+
+void CAknSgcClient::DoSetKeyboardRepeatRate(TAknDefaultKeyboardRepeatRate aRate)
+    {
+	if (iFlags[EInAknSrv])
+		{
+        TInt repeatRate = KAknStandardKeyboardRepeatRate; // default 
+        if (aRate == EAknEditorDefaulRepeatRate)
+            {
+            repeatRate = KAknEditorKeyboardRepeatRate;
+            }
+        iEikonEnv->WsSession().SetKeyboardRepeatRate(KAknKeyboardRepeatInitialDelay,repeatRate);
+        }
+	else
+		{
+		iAknSrv.SetKeyboardRepeatRate(aRate);
+		}
+    }
+
+void CAknSgcClient::RelinquishPriorityToForegroundAppLC(TBool aIsForeground)
+	{
+	CAknSgcClient* self = Static();
+	if (self)
+		self->DoRelinquishPriorityToForegroundAppLC(aIsForeground);
+	}
+
+void RestorePriority(TAny* aPriority)
+    {
+    if (!aPriority)
+        return;
+	RThread myThread;
+	TProcessPriority priority = *(TProcessPriority*)&aPriority;
+	myThread.SetProcessPriority(priority);
+    }
+
+void CAknSgcClient::DoRelinquishPriorityToForegroundAppLC(TBool aIsForeground)
+	{
+	RThread myThread;
+	TProcessPriority priority = myThread.ProcessPriority();
+
+	if( IsSystemFaded() )
+		{
+		// Solution for EKKG-7RQ9U8:
+		// If the system is faded we have a popup on screen.
+		// Get the process behind the foreground process. 
+		TApaTask task = TApaTaskList(iEikonEnv->WsSession()).FindByPos(1);
+
+		// Check if this application is next behind the foreground app.
+		if( task.Exists() && myThread.Id() == task.ThreadId())
+			{
+			// Act as if we were foreground because some portion of the app might be visible.
+			// The actual foreground application might only be displaying the popup and therefore
+			// would not update the entire screen. 	
+			aIsForeground = ETrue;
+			}
+		}
+
+	if (!aIsForeground && priority > EPriorityBackground && !iFlags[ENeverRelinquish] )
+	    {
+	    // App is not visible, but has priority higher than background
+	    // Temporarily move it to background priority
+        CleanupStack::PushL(TCleanupItem(RestorePriority, (TAny*)priority));
+        iAknSrv.RelinquishPriorityToForegroundApp();
+	    }
+	else if (aIsForeground && priority < EPriorityForeground)
+	    {
+	    // App is visible, but has priority lower than foreground
+	    // Temporarily move it to foreground priority
+        CleanupStack::PushL(TCleanupItem(RestorePriority, (TAny*)priority));
+        myThread.SetProcessPriority(EPriorityForeground);
+	    }
+	else
+	    {
+	    // App has correct priority
+	    // push a dummy cleanup item onto the cleanup stack
+        CleanupStack::PushL(TCleanupItem(RestorePriority, NULL));
+	    }
+	}
+
+EXPORT_C CAknLayoutConfig& CAknSgcClient::LayoutConfig()
+	{
+	CAknSgcClient* self = Static();
+	__ASSERT_ALWAYS(self && self->iLayoutConfig, Panic(EAknPanicSgccLayoutConfigNull));
+	return *self->iLayoutConfig;
+	}
+
+EXPORT_C const TDesC8& CAknSgcClient::LayoutConfigBuf()
+	{
+	CAknSgcClient* self = Static();
+	if (!self)
+		return KNullDesC8;
+	else
+		return self->DoLayoutConfigBuf();
+	}
+
+const TDesC8& CAknSgcClient::DoLayoutConfigBuf()
+	{
+	return KNullDesC8;
+	}
+
+void CAknSgcClient::StartupBlankL()
+	{
+	// Only use blanker when this app is focused, ie foreground
+	if (iEikonEnv->WsSession().GetFocusWindowGroup() == iEikonEnv->RootWin().Identifier())
+		{
+	    iStartupBlank = CIdle::New(KStartupUnblankPriority);
+	    iStartupBlank->Start(TCallBack(StartupUnblank, this));
+		User::LeaveIfError(iAknSrv.BlankScreen());
+		}
+	}
+
+TInt CAknSgcClient::StartupUnblank(TAny* aThis)
+	{
+	((CAknSgcClient*)aThis)->DoStartupUnblank();
+	return 0;
+	}
+
+void CAknSgcClient::DoStartupUnblank()
+	{
+    if (iStartupBlank)
+    	{
+		iAknSrv.UnblankScreen();
+		delete iStartupBlank;
+		iStartupBlank = NULL;
+    	}
+	}
+
+EXPORT_C void CAknSgcClient::MoveApp(TInt aAppWindowGroupId, TSgcMoveAppToWhere aWhere)
+	{
+	CAknSgcClient* self = Static();
+	if (self && self->iImpl)
+		self->iImpl->MoveApp(aAppWindowGroupId, aWhere);
+	}
+
+EXPORT_C void CAknSgcClient::SetImpl(CAknSgcImpl* aImpl)
+	{
+	CAknSgcClient* self = Static();
+	if (self)
+		{
+		delete self->iImpl;
+		self->iImpl = aImpl;
+		}
+	}
+
+//
+// CAknSgcClientServerInst
+//
+CAknSgcClientServerInst::CAknSgcClientServerInst()
+	{
+	iFlags.Set(EInAknSrv);
+	iFlags.Set(ENeverRelinquish);
+	}
+
+CAknSgcClientServerInst::~CAknSgcClientServerInst()
+	{
+	delete iPackedLayoutConfigBuf;
+	}
+
+const TDesC8& CAknSgcClientServerInst::DoLayoutConfigBuf()
+	{
+	return *iPackedLayoutConfigBuf;
+	}
+
+void CAknSgcClientServerInst::ConstructL()
+	{
+	BaseConstructL();
+	
+	iPackedLayoutConfigBuf = iLayoutConfig->CreatePackedBufL();
+	iLayoutConfig->ConstructL(iPackedLayoutConfigBuf->AllocL());
+	}
+
+
+//
+// CAknSgcClientImpl
+//
+CAknSgcClientImpl::CAknSgcClientImpl(RAknUiServer& aAknSrv)
+: iAknSrv(aAknSrv)
+	{
+	}
+	
+void CAknSgcClientImpl::MoveApp(TInt aAppWindowGroupId, TSgcMoveAppToWhere aWhere)
+	{
+	iAknSrv.MoveAppInZOrder(aAppWindowGroupId, aWhere);
+	}
+
+
+// End of File