// Copyright (c) 1995-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:

 // wins\specific\gui.cpp

 // 

 //

 #define WINVER 0x0500

 #include "gui.h"

 #include <emulator.h>

 #include <assp.h>

 #include <kernel/kern_priv.h>

 #include <kernel/kpower.h>

 #include "variant.h"

 #include "resource.h"

 #include "winsgui.h"

 #include "display_chan.h"

 #include "pixelformats.h"

 #include "multitouch.h"

 #include "monitors.h"

 //Define these so that emulator generates varying values for gce stride and offset.

 //By default in emulator, stride is exactly right for display resolution and offset is zero

 //Setting these will identify code which incorrectly calculates these factors instead of requesting them

 //Note that multiples of 4 bytes are preferred for various reasons.

 //[3/5/07 The Secure presentation burffer ignores stride extra because it uses a windows bitmap header to render.]

 // #define TEST_GCE_VARIABLE_STRIDE_EXTRA	16		 	//This constant is added to each mode's scanline length in bytes. It may cause a break if enabled because the iDisplayBufferOffset is not being set

 // #define TEST_GCE_VARIABLE_START_EXTRA	16			//A multiple of this is added to each mode's start address in bytes

 // #define ASSYMETRIC_SQUARE_STRIDE						//If this is defined and the width==height the the stride will not be the same!

 enum  

 	{

 		KMaskModeNum=0x0FFFFFFF,

 		KMaskModeFlag8=0x80000000,

 		KMaskModeFlag4=0x40000000,

 		KMaskModeFlag2=0x20000000,

 		KMaskModeFlag1=0x10000000,

 		KModeFlagFlipped=KMaskModeFlag8,

 	};

 enum  

 	{

 		KMaskScreenNum=0x0FFF,

 		KMaskScreenFlag8=0x8000,

 		KMaskScreenFlag4=0x4000,

 		KMaskScreenFlag2=0x2000,

 		KMaskScreenFlag1=0x1000,

 		KScreenFlagSecure=KMaskScreenFlag8,

 	};

 const TInt KMaxDisplayColors=16777216;

 const TInt KMaxDisplayContrast=1;

 static TEmulatorFlip* CurrentFlipState=NULL;

 static TInt CurrentConfiguration = 0;

 static TInt SavedFlipMessage = 0;

 DWinsUi *systemIni=NULL;

 DMasterIni* masterIni;

 DMultiTouch* TheMultiTouch;

 static HWND TheControlWin;

 static HWND* TheChildWin=NULL;

 static HWND* TheWin=NULL;

 static HWND hwndStatus; // To display the X,Y,Z information of each mouse

 static TInt VirtualKeyPressed = EStdKeyNull;

 static HBITMAP* TheScreenBitmap=NULL;

 static TUint LedMask;

 static TBool WsSwitchOnScreen;

 const char * DefaultWindowTitle = "Symbian OS Emulator";

 #ifdef __VC32__

 #ifdef _DEBUG

 const char * VersionText = " - wins udeb";

 #else

 const char * VersionText = " - wins urel";

 #endif

 #else

 #ifdef __CW32__

 #ifdef _DEBUG

 const char * VersionText = " - winscw udeb";

 #else

 const char * VersionText = " - winscw urel";

 #endif

 #else

 //not winscw or wins!

 #ifdef _DEBUG

 const char * VersionText = " - unknown udeb";

 #else

 const char * VersionText = " - unknown urel");

 #endif

 #endif

 #endif

 void Inactive();

 void Active();

 void DrawLeds();

 void UpdateModifiers(); 

 TInt DisplayHalFunction(TAny*, TInt aFunction, TAny* a1, TAny* a2);

 LOCAL_C TBool PaintWindowFromBuffer(HWND hWnd);

 GLDEF_C const char* skipws(const char* aPtr)

 	{

 	while (isspace(*aPtr))

 		++aPtr;

 	return aPtr;

 	}

 GLDEF_C const char* skiptok(const char* aPtr)

 	{

 	while (isalnum(*aPtr))

 		++aPtr;

 	return aPtr;

 	}

 GLDEF_C TInt CompareI(const TDesC8& aLhs, const TDesC8& aRhs)

 //

 // Case insensitive comparison of descriptors

 // (TDesC::CompareF not available to kernel side code)

 //

 	{

 	TInt ll = aLhs.Length();

 	TInt rl = aRhs.Length();

 	TInt len = Min(ll, rl);

 	TInt k = _strnicmp((const char*)aLhs.Ptr(), (const char*)aRhs.Ptr(), len);

 	return k != 0 ? k : ll - rl;

 	}

 GLDEF_C TInt MultiProperty(TInt (*aHandler)(TAny* aObj, const char*), TAny* aPtr, const char* aProperty)

 	{

 	const char* value = Property::GetString(aProperty);

 	if (!value)

 		return KErrNone;

 	for (;;)

 		{

 		TInt r = aHandler(aPtr, value);

 		if (r != KErrNone)

 			return r;

 		const char* ev = strchr(value, ';');

 		if (!ev)

 			break;

 		value = ev + 1;

 		}

 	return KErrNone;

 	}

 class DWinsGuiPowerHandler : public DPowerHandler

 	{

 public: // from DPowerHandler

 	void PowerDown(TPowerState);

 	void PowerUp();

 public:

 	static DWinsGuiPowerHandler* New();

 	void ScreenOn();

 	void ScreenOff();

 	void ScreenOn(TInt aScreen);

 	void ScreenOff(TInt aScreen);

 public:

 	DWinsGuiPowerHandler();

 	TBool ProcessEvent(const TRawEvent* aEvent);

 	TBool ProcessEventDfc(const TRawEvent* aEvent);

 	TBool	iStandby;

 	};

 static DWinsGuiPowerHandler* WinsGuiPowerHandler;

 _LIT(KWinsGuiName, "WinsGui");

 DWinsGuiPowerHandler* DWinsGuiPowerHandler::New()

 	{

 	DWinsGuiPowerHandler* self = new DWinsGuiPowerHandler();

 	if (!self)

 		return NULL;

 	self->Add();

 	return self;

 	}

 DWinsGuiPowerHandler::DWinsGuiPowerHandler() : DPowerHandler(KWinsGuiName)

 	{

 	}

 void DWinsGuiPowerHandler::ScreenOff()

 	{

 	for(TInt ix=0;ix<systemIni->iScreens.Count();ix++)

 		ScreenOff(ix);

 	}

 void DWinsGuiPowerHandler::ScreenOn()

 	{

 	for(TInt ix=0;ix<systemIni->iScreens.Count();ix++)

 		ScreenOn(ix);

 	}

 void DWinsGuiPowerHandler::ScreenOff(TInt aScreen)

 	{

 	PostMessageA(TheWin[aScreen], WM_EMUL_POWER_ON, FALSE, NULL);

 	systemIni->iScreens[aScreen]->iScreenOff = ETrue;

 	}

 void DWinsGuiPowerHandler::ScreenOn(TInt aScreen)

 	{

 	PostMessageA(TheWin[aScreen], WM_EMUL_POWER_ON, TRUE, NULL);

 	systemIni->iScreens[aScreen]->iScreenOff = EFalse;

 	}

 void DWinsGuiPowerHandler::PowerDown(TPowerState aState)

 	{

 	if (aState == EPwStandby)

 		iStandby = ETrue;

 	ScreenOff();

 	PowerDownDone();

 	}

 void DWinsGuiPowerHandler::PowerUp()

 	{

 	iStandby = EFalse;

 	ScreenOn();

 	PowerUpDone();

 	}

 // called in the interrupt context

 TBool DWinsGuiPowerHandler::ProcessEvent(const TRawEvent* aEvent)

 	{

 	if (!iStandby)

 		// Pass through 

 		return EFalse;

 	if ((aEvent->Type() == TRawEvent::EKeyDown))

 			{

 			Wins::Self() -> AssertWakeupSignal();

 			}

 	// Ignore

 	return ETrue;

 	}

 // called in DFC

 TBool DWinsGuiPowerHandler::ProcessEventDfc(const TRawEvent* aEvent)

 	{

 	if (aEvent->Type() == TRawEvent::EKeyDown)

 		{

 		Wins::Self() -> WakeupEvent();

 		if (aEvent->ScanCode() == EStdKeyF5)

 			{

 			// Simulate a media change interrupt (media removed)

 			Wins::MediaChangeCallBack();

 			*Wins::MediaDoorOpenPtr()=ETrue;

 			// Ignore

 			return ETrue;

 			}

 		if (aEvent->ScanCode() == EStdKeyF8)

 			{

 			TRawEvent v;

 			v.Set(TRawEvent::ECaseClose);

 			Kern::AddEvent(v);

 			// Ignore

 			return ETrue;

 			}

 		if (aEvent->ScanCode() == EStdKeyF8)

 			{

 			TRawEvent v;

 			v.Set(TRawEvent::ECaseClose);

 			Kern::AddEvent(v);

 			// Ignore

 			return ETrue;

 			}

 		if (aEvent->ScanCode() == EStdKeyOff)

 			{

 			// Pass through

 			return EFalse;

 			}

 		if (aEvent->ScanCode() == EStdKeyF10)

 			{

 			TRawEvent v;

 			v.Set(TRawEvent::ESwitchOff);

 			Kern::AddEvent(v);

 			// Ignore

 			return ETrue;

 			}

 		if (aEvent->ScanCode() == EStdKeyF11)

 			{

 			TRawEvent v;

 			v.Set(TRawEvent::ECaseOpen);

 			Kern::AddEvent(v);

 			// Ignore

 			return ETrue;

 			}

 		}

 	else if (aEvent->Type() == TRawEvent::EKeyUp)

 		{

 		if (aEvent->ScanCode() == EStdKeyF10)

 			// Ignore

 			return ETrue;

 		if (aEvent->ScanCode() == EStdKeyF5)

 			{

 			// Simulate a media change interrupt (media Present)

 			*Wins::MediaDoorOpenPtr()=EFalse;

 			return ETrue;

 			}

 		}

 	// Path through

 	return EFalse;

 	}

 class EventQ

 	{

 	enum {ESize = 16};

 public:

 	EventQ();

 	void Add(const TRawEvent& aEvent);

 private:

 	static void Dfc(TAny* aPtr);

 	void Empty();

 private:

 	TDfc iDfc;

 	TRawEvent* iTail;

 	TRawEvent iQ[ESize];

 	};

 EventQ::EventQ()

 	:iDfc(&EventQ::Dfc, this, Kern::DfcQue0(), 6), iTail(iQ)

 	{}

 void EventQ::Add(const TRawEvent& aEvent)

 	{

 	StartOfInterrupt();	

 	if (WinsGuiPowerHandler->ProcessEvent(&aEvent)) 

 		{

 		EndOfInterrupt();

 		return;

 		}

 	TRawEvent* pE = iTail;

 	if (pE != &iQ[ESize])

 		{

 		*pE = aEvent;

 		iTail = pE + 1;

 		if (pE == iQ)

 			iDfc.Add();

 		}

 	EndOfInterrupt();

 	}

 void EventQ::Dfc(TAny* aPtr)

 	{

 	static_cast<EventQ*>(aPtr)->Empty();

 	}

 void EventQ::Empty()

 //

 // Called in the DFC

 //

 	{

 	TInt irq;

 	TRawEvent* pE = iQ;

 	for (;;)

 		{

 		if (!WinsGuiPowerHandler->ProcessEventDfc(pE)) 

 			Kern::AddEvent(*pE);

 		++pE;

 		irq = NKern::DisableAllInterrupts();

 		if (pE == iTail)

 			break;

 		NKern::RestoreInterrupts(irq);

 		}

 	iTail = iQ;

 	NKern::RestoreInterrupts(irq);

 	}

 LOCAL_D EventQ TheEventQ;

 // Virtual keys

 VirtualKey::VirtualKey(const TInt aCommandData, const TEmulCommand aCommand) : iCommand(aCommand), iData(aCommandData)

 	{

 	}

 TBool VKRect::Contains(TInt aX, TInt aY) const

 	{

 	return (aX >= iLeft && aX < iRight && aY >= iTop && aY < iBottom);

 	}

 VKRect::VKRect(const TInt aCommandData, const TEmulCommand aCommand, TInt aX, TInt aY, TInt aWidth, TInt aHeight) :

 	VirtualKey(aCommandData, aCommand)

 	{

 	iLeft = aX;

 	iTop = aY;

 	iRight = aX + aWidth;

 	iBottom = aY + aHeight;

 	}

 void VKRect::Draw(HDC aHdc,COLORREF aColor) const

 	{

 	HPEN pen;

 	pen=CreatePen(PS_SOLID, 2, aColor);

 	SelectObject(aHdc, pen);

 	POINT point;

 	MoveToEx(aHdc, (int)iLeft, (int)iTop, &point);

 	LineTo(aHdc, (int)iLeft, (int)iBottom);

 	LineTo(aHdc, (int)iRight, (int)iBottom);

 	LineTo(aHdc, (int)iRight, (int)iTop);

 	LineTo(aHdc, (int)iLeft, (int)iTop);

 	}

 KeyCombination::KeyCombination(const TInt aCommandData, TEmulCommand aCommand):

 	iData(aCommandData),

 	iCommand(aCommand)

 {

 	for (TInt i=0;i<KMaxHotKeyCombinationLength;i++) 

 		{

 		iCombination[i]=EStdKeyNull;

 		}

 }

 TBool KeyCombination::CheckCombinationPressed()

 {

 	for (TInt j=0;(j<KMaxHotKeyCombinationLength && iCombination[j]!=0);j++)

 		{

 		if (GetAsyncKeyState(MapVirtualKey(iCombination[j],1))>=0)//if at least one key is not pressed, we return false

 			return EFalse;				

 		}

 	return ETrue;	

 }

 TBool KeyCombination::AddKey(TStdScanCode aKey)

 {

 	TInt i;

 	for (i=0;i<KMaxHotKeyCombinationLength;i++) 

 		{

 		if (iCombination[i]==EStdKeyNull) 

 			break;

 		}

 	if (KMaxHotKeyCombinationLength==i)

 		return EFalse;

 	else		

 		iCombination[i]=aKey;	

 	return ETrue;

 }

 DScreenProperties::DScreenProperties()

 	{

 	memset(this,0,sizeof(DScreenProperties));

 	iColorDepth=KDefaultColorDepth;

 	iViewport = TViewport(this);

 	}

 LOCAL_C TInt MaskGceOnly(TInt aModeBits)

 	{	   //All HAL modes are now reported. The GCE may refuse to register the surfaces.

 	return aModeBits&KEmulModes;	//previous useful settings: //(KEmulPixPerLong2|KEmulPixPerLong1);	//|KEmulPixPerLong4;

 	}

 LOCAL_C TInt BitsForSingleMode(TInt aModeColor)

 	{	//only 1 bit should be set in aModeColor

 	switch (aModeColor)

 		{

 		case KEmulGray2:	return 1;	

 		case KEmulGray4:	return 2;	

 		case KEmulGray16:	return 4;

 		case KEmulGray256:	return 8;

 		case KEmulColor16:	return 4;

 		case KEmulColor256:	return 8;

 		case KEmulColor4K:	return 12;

 		case KEmulColor64K:	return 16;

 		case KEmulColor16M:	return 24;

 		default:	return 32;

 		}

 	}

 DScreenProperties::~DScreenProperties() 

 	{

 	}

 TWindowState DScreenProperties::GetWindowState()

 	{

 	TWindowState state;

 	state.iWinPlace = iWinPlace;

 	state.iFlipstate = iScreenRotation;

 	state.iXoffset = iViewport.GetViewportOffsetX();

 	state.iYoffset = iViewport.GetViewportOffsetY();

 	return state;

 	}

 TInt DScreenProperties::SetupProperties(TInt aConf, TInt aScreen)

 	{

 	char property[50];

 	// Calculate maximum dimensions

 	TInt configurations = Property::GetInt("ConfigCount", 0);

 	if (configurations == 0)

 		return KErrGeneral;

 	TInt count, screenWidth, screenHeight, physicalScreenWidth, physicalScreenHeight;

 	for (count = 0; count < configurations; ++count)

 		{

 		wsprintfA(property, "Configuration[%d][%d]ScreenWidth", count, aScreen);

 		screenWidth = Property::GetInt(property, KScreenWidth);

 		screenWidth = (screenWidth + 3) & ~3;

 		if (screenWidth > iMaxScreenWidth)

 			iMaxScreenWidth = screenWidth;

 		wsprintfA(property, "Configuration[%d][%d]ScreenHeight", count, aScreen);

 		screenHeight = Property::GetInt(property, KScreenHeight);

 		screenHeight = (screenHeight + 3) & ~3;

 		if (screenHeight > iMaxScreenHeight)

 			iMaxScreenHeight = screenHeight;

 //

 		wsprintfA(property, "Configuration[%d][%d]PhysicalScreenWidth", count, aScreen);

 		physicalScreenWidth = Property::GetInt(property);

 		if (physicalScreenWidth > iMaxPhysicalScreenWidth)

 			iMaxPhysicalScreenWidth = physicalScreenWidth;

 		wsprintfA(property, "Configuration[%d][%d]PhysicalScreenHeight", count, aScreen);

 		physicalScreenHeight = Property::GetInt(property);

 		if (physicalScreenHeight > iMaxPhysicalScreenHeight)

 			iMaxPhysicalScreenHeight = physicalScreenHeight;

 		}

 	// Read figures for current configuration

 	TInt givenWidth, givenHeight;

 	wsprintfA(property, "Configuration[%d][%d]ScreenWidth",aConf,aScreen);

 	givenWidth = Property::GetInt(property, KScreenWidth);

 	iScreenWidth = (givenWidth + 3) & ~3;

 	wsprintfA(property, "Configuration[%d][%d]ScreenHeight",aConf,aScreen);

 	givenHeight = Property::GetInt(property, KScreenHeight);

 	iScreenHeight = (givenHeight + 3) & ~3;

 	// Width of screen should be multiple number of 4 pixels.

 	if (givenWidth & 3 || givenHeight & 3)

 		{

 		Kern::Printf("Width and Height of Screen should be multiple number of 4 pixels.\n"

 				"\tWidth of screen[%d] set to: %d\n\tHeight of screen[%d] set to: %d", 

 				aScreen, iScreenWidth, aScreen, iScreenHeight);

 		}

 //

 	wsprintfA(property, "Configuration[%d][%d]PhysicalScreenWidth",aConf,aScreen);

 	iPhysicalScreenWidth = Property::GetInt(property);

 	wsprintfA(property, "Configuration[%d][%d]PhysicalScreenHeight",aConf,aScreen);

 	iPhysicalScreenHeight = Property::GetInt(property);

 //

 	wsprintfA(property, "Configuration[%d][%d]ScreenOffsetX",aConf,aScreen);

 	iScreenOffsetX = Property::GetInt(property, KScreenOffsetX);

 	wsprintfA(property, "Configuration[%d][%d]ScreenOffsetY",aConf,aScreen);

 	iScreenOffsetY = Property::GetInt(property, KScreenOffsetY);

 	wsprintfA(property, "Configuration[%d][%d]CompositionBuffers",aConf,aScreen);

 	iCompositionBuffers = Property::GetInt(property, KCompositionBuffers);

 	wsprintfA(property, "Configuration[%d][%d]RefreshRateHz",aConf,aScreen);

 	iRefreshRateHz = Property::GetInt(property, KRefreshRateHz);

 	wsprintfA(property, "Configuration[%d][%d]ColorDepth",aConf,aScreen);

 	const char* colors = Property::GetString(property);

 	if (colors)

 		{

 		TUint colorDepth=0;

 		const char* end = colors;

 		for (;;)

 			{

 			const char* beg = skipws(end);

 			if(*beg==';')

 				break;

 			if (!*beg)

 				break;

 			end	= skiptok(beg);

 			if (_strnicmp("Gray2",beg,end-beg) == 0)

 				{

 				colorDepth|=KEmulGray2|KEmulIsBitMask;

 				}

 			else if (_strnicmp("Gray4",beg,end-beg) == 0)

 				{

 				colorDepth|=KEmulGray4|KEmulIsBitMask;

 				}

 			else if (_strnicmp("Gray16",beg,end-beg) == 0)

 				{

 				colorDepth|=KEmulGray16|KEmulIsBitMask;

 				}

 			else if (_strnicmp("Gray256",beg,end-beg) == 0)

 				{

 				colorDepth|=KEmulGray256|KEmulIsBitMask;

 				}

 			else if (_strnicmp("Color16",beg,end-beg) == 0)

 				{

 				colorDepth|=KEmulColor16|KEmulIsBitMask;

 				}

 			else if (_strnicmp("Color256",beg,end-beg) == 0)

 				{

 				colorDepth|=KEmulColor256|KEmulIsBitMask;

 				}

 			else if (_strnicmp("Color4K",beg,end-beg) == 0)

 				{

 				colorDepth|=KEmulColor4K|KEmulIsBitMask;

 				}

 			else if (_strnicmp("Color64K",beg,end-beg) == 0)

 				{

 				colorDepth|=KEmulColor64K|KEmulIsBitMask;

 				}

 			else if (_strnicmp("Color16M",beg,end-beg) == 0)

 				{

 				colorDepth|=KEmulColor16M|KEmulIsBitMask;

 				}

 			else

 				return KErrArgument;

 			}

 		iColorDepth = colorDepth;

 		}

 	//multiple mode support is currently only for GCE. 

 	//I fill this array in before knowing if GCE will be instanced.

 	if (iColorDepth&KEmulIsBitMask)

 		{

 		//iModeDepths is only used by GCE

 		TInt colorDepth=MaskGceOnly(iColorDepth);

 		TInt setMode=0;

 		for (TInt i=1;i!=KEmulIsBitMask;i+=i)

 			if (colorDepth&i)

 				iModeDepths[setMode++]=BitsForSingleMode(i);

 		iMaxModes= setMode;	

 		iModeDepths[setMode++]=0;	//a bit width of 0 is illegal	

 		}

 	else

 		{

 		iModeDepths[0]=iColorDepth;

 		iMaxModes=1;

 		iModeDepths[1]=0;	//a bit width of 0 is illegal

 		}

 	wsprintfA(property, "Configuration[%d][%d]FasciaBitmap",aConf,aScreen);

 	const char* fascia = Property::GetString(property);

 	if (fascia)

 		{

 		TInt len = strlen(fascia);

 		//the path may have quotes at the start and end

 		//need to work out if this is an absolute or relative path

 		if (fascia[0] == '\"')

 			{

 			++fascia;

 			--len;

 			if (--len > 0 && fascia[len-1] == '\"')

 				--len;

 			}

 		char* p = iFasciaFileName;

 		if (fascia[0] != '\\' && (len < 3 || fascia[1] != ':'))

 			{

 			//relative path

 			strcpy(p, Property::GetString("EmulatorDataPath"));

 			p += strlen(p);

 			}

 		memcpy(p, fascia, len);

 		p[len] = '\0';

 		}

 	else

 		{

 		// default to machine name

 		strcpy(iFasciaFileName, Property::GetString("EmulatorDataPath"));

 		strcat(iFasciaFileName, Property::GetString("MachineName"));

 		strcat(iFasciaFileName, ".bmp");

 		}

 	return KErrNone;

 	}

 TViewport::TViewport() 

 	:iScreenProps(NULL),iViewportWidth(0), iViewportHeight(0), iViewportOffsetX(0), iViewportOffsetY(0)

 	{

 	}

 TViewport::TViewport(DScreenProperties* aScreenProps)

 	:iScreenProps(aScreenProps),iViewportWidth(0), iViewportHeight(0), iViewportOffsetX(0), iViewportOffsetY(0)

 	{	

 	}	

 TViewport::~TViewport()

 	{

 	}

 /**

 Changes the logical position of the viewport within the input area

 of the emulator screen. The method may adjust the position so that

 the viewport stays within the input area.

 @param aPosition The new Y position of the top left hand corner of the viewport.

 @param aHwnd The window associated with the viewport

 */

 void TViewport::ScrollToY(TInt aPosition, HWND aHwnd)

 	{

 	SCROLLINFO scrollinfo;

 	scrollinfo.cbSize=sizeof(scrollinfo);

 	//save for later

 	scrollinfo.fMask=SIF_POS;

 	GetScrollInfo(aHwnd, SB_VERT, &scrollinfo);

 	TInt oldY=scrollinfo.nPos;

 	if(aPosition<0)

 	{

 		scrollinfo.nPos = 0;

 	}

 	else if( (aPosition+GetViewportHeight())>GetMaxHeight())

 	{

 		scrollinfo.nPos = max(0,GetMaxHeight() - GetViewportHeight() );

 	}

 	else

 	{

 		scrollinfo.nPos=aPosition;

 	}

 	SetViewportOffsetY(scrollinfo.nPos);

 	scrollinfo.fMask=SIF_POS;

 	SetScrollInfo(aHwnd,SB_VERT, &scrollinfo, TRUE );

 	ScrollWindowEx(aHwnd, 0, oldY-scrollinfo.nPos, 0, 0, NULL, NULL, SW_INVALIDATE);

 	UpdateChildPos(aHwnd);

 	}

 /**

 As for ScrollToY but for the X direction

 */

 void TViewport::ScrollToX(TInt aPosition, HWND aHwnd)

 	{

 	SCROLLINFO scrollinfo;

 	scrollinfo.cbSize=sizeof(scrollinfo);

 	//save for later

 	scrollinfo.fMask=SIF_POS;

 	GetScrollInfo(aHwnd, SB_HORZ, &scrollinfo);

 	TInt oldX=scrollinfo.nPos;

 	if(aPosition<0)

 	{

 		scrollinfo.nPos = 0;

 	}

 	else if( (aPosition+GetViewportWidth())>GetMaxWidth())

 	{

 		scrollinfo.nPos = max(0,GetMaxWidth() - GetViewportWidth() );

 	}

 	else

 	{

 		scrollinfo.nPos=aPosition;

 	}

 	SetViewportOffsetX(scrollinfo.nPos);

 	scrollinfo.fMask=SIF_POS;

 	SetScrollInfo(aHwnd,SB_HORZ, &scrollinfo, TRUE );

 	ScrollWindowEx(aHwnd, oldX-scrollinfo.nPos, 0, 0, 0, NULL, NULL, SW_INVALIDATE);

 	UpdateChildPos(aHwnd);

 	}

 //Forward declaration

 LOCAL_C TInt ScreenFromHWND(HWND aHwnd,HWND* pWin);

 /**

 Move the child window to it's correct position.

 @param aHwnd The HWND of the parent window

 */

 void TViewport::UpdateChildPos(HWND aHwnd)

 	{

 	TInt screenNumber = ::ScreenFromHWND(aHwnd,TheWin);

 	HWND childWin = TheChildWin[screenNumber];

 	switch (iScreenProps->iScreenRotation)

 		{

 		case EEmulatorFlipRestore:

 			MoveWindow(

 				childWin,

 				iScreenProps->iScreenOffsetX - GetViewportOffsetX(),

 				iScreenProps->iScreenOffsetY - GetViewportOffsetY(),

 				iScreenProps->iScreenWidth,

 				iScreenProps->iScreenHeight,

 				TRUE

 				);

 			break;

 		case EEmulatorFlipInvert:

 			MoveWindow(

 				childWin,

 				iScreenProps->iXYInputWidth-(iScreenProps->iScreenOffsetX+iScreenProps->iScreenWidth) - GetViewportOffsetX(),

 				iScreenProps->iXYInputHeight-(iScreenProps->iScreenOffsetY+iScreenProps->iScreenHeight) - GetViewportOffsetY(),

 				iScreenProps->iScreenWidth,

 				iScreenProps->iScreenHeight,

 				TRUE

 				);

 			break;

 		case EEmulatorFlipLeft:

 			MoveWindow(

 				childWin,

 				iScreenProps->iScreenOffsetY - GetViewportOffsetX(),

 				iScreenProps->iXYInputWidth-(iScreenProps->iScreenOffsetX+iScreenProps->iScreenWidth)- GetViewportOffsetY(),

 				iScreenProps->iScreenHeight,

 				iScreenProps->iScreenWidth,

 				TRUE

 				);

 			break;

 		case EEmulatorFlipRight:

 			MoveWindow(

 				childWin,

 				iScreenProps->iXYInputHeight-(iScreenProps->iScreenOffsetY+iScreenProps->iScreenHeight) - GetViewportOffsetX(),

 				iScreenProps->iScreenOffsetX - GetViewportOffsetY(),

 				iScreenProps->iScreenHeight,

 				iScreenProps->iScreenWidth,

 				TRUE

 				);

 			break;

 		}

 	}

 /**

 Update the range of the horizontal scrollbar,

 to take account of the current viewport width.

 @param aHwnd The window to be updated

 */

 void TViewport::UpdateScrollBarH(HWND aHwnd)

 	{

 	SCROLLINFO scrollinfoHor;

 	scrollinfoHor.cbSize=sizeof(scrollinfoHor);

 	scrollinfoHor.fMask=SIF_RANGE|SIF_PAGE;

 	scrollinfoHor.nMin=0;

 	scrollinfoHor.nMax= GetMaxWidth()-1;

 	TInt newPage = GetViewportWidth() ;

 	TBool redraw=EFalse; //redraw window if a resize has caused a scrollbar to disappear and reveal image.

 	if ( newPage>= scrollinfoHor.nMax -GetSystemMetrics(SM_CXVSCROLL)

 		&& newPage < scrollinfoHor.nMax+1)

 		{

 		redraw=ETrue;

 		newPage=GetMaxWidth();

 		}

 	scrollinfoHor.nPage= newPage;

 	SetScrollInfo(aHwnd,SB_HORZ, &scrollinfoHor, TRUE );

 	if(redraw)

 		{

 		ScrollToX(0, aHwnd); //in case egde of fascia was against edge of vertical scrollbar

 		InvalidateRect(aHwnd, NULL, TRUE);

 		}

 	}

 /**

 Update the range of the vertical scrollbar,

 to take account of the current viewport width.

 @param aHwnd The window to be updated

 */	

 void TViewport::UpdateScrollBarV(HWND aHwnd)

 	{

 	SCROLLINFO scrollinfoVer;

 	scrollinfoVer.cbSize=sizeof(scrollinfoVer);

 	scrollinfoVer.fMask=SIF_RANGE|SIF_PAGE;

 	scrollinfoVer.nMin=0;

 	scrollinfoVer.nMax= GetMaxHeight()-1;

 	TInt newPage = GetViewportHeight() ;

 	TBool redraw=EFalse; //redraw window if a resize has caused a scrollbar to disappear and reveal image.

 	if ( newPage>= scrollinfoVer.nMax -GetSystemMetrics(SM_CYHSCROLL)

 		&& newPage < scrollinfoVer.nMax+1)

 		{

 		redraw=ETrue;

 		newPage=GetMaxHeight();

 		}

 	scrollinfoVer.nPage= newPage;

 	SetScrollInfo(aHwnd,SB_VERT, &scrollinfoVer, TRUE );

 	if(redraw)

 		{

 		ScrollToY(0, aHwnd); //in case egde of fascia was against edge of vertical scrollbar

 		InvalidateRect(aHwnd, NULL, TRUE);

 		}

 	}

 /**

 Returns the max width for the viewport window (non-client area) so that it

 may be bounded. Takes account of scrollbar.

 @return Max width

 */	

 TInt TViewport::GetMaxWindowWidth() const

 	{

 	RECT rect = {0,0,0,0};

 	switch(iScreenProps->iScreenRotation)

 		{

 		case EEmulatorFlipRestore:

 		case EEmulatorFlipInvert:

 			{

 			rect.right=iScreenProps->iXYInputWidth;

 			rect.bottom=iScreenProps->iXYInputHeight;

 			break;

 			}

 		case EEmulatorFlipLeft:

 		case EEmulatorFlipRight:

 			{

 			rect.right=iScreenProps->iXYInputHeight;

 			rect.bottom=iScreenProps->iXYInputWidth;

 			break;

 			}

 		}

 	AdjustWindowRect(//take account of window decorations

 		&rect,

 		KWinStyle,

 		FALSE

 		);

 	return (rect.right-rect.left);

 	}

 /**

 Returns the max height for the viewport window (non-client area) so that it

 may be bounded. Takes account of scrollbar.

 @return Max height

 */

 TInt TViewport::GetMaxWindowHeight() const

 	{

 	RECT rect ={0,0,0,0};

 	switch(iScreenProps->iScreenRotation)

 		{

 		case EEmulatorFlipRestore:

 		case EEmulatorFlipInvert:

 			{

 			rect.right=iScreenProps->iXYInputWidth;

 			rect.bottom=iScreenProps->iXYInputHeight;

 			break;

 			}

 		case EEmulatorFlipLeft:

 		case EEmulatorFlipRight:

 			{

 			rect.right=iScreenProps->iXYInputHeight;

 			rect.bottom=iScreenProps->iXYInputWidth;

 			break;

 			}

 		}

 	AdjustWindowRect(//take account of window decorations

 		&rect,

 		KWinStyle,

 		FALSE

 		);

 	return (rect.bottom-rect.top);

 	}

 /**

 Returns the maximum width for the viewport (client area only).

 Allowing for the orientation of the emulator.

 @return Max width

 */

 TInt TViewport::GetMaxWidth() const

 	{

 	TInt width=0;

 	switch(iScreenProps->iScreenRotation)

 		{

 		case EEmulatorFlipRestore:

 		case EEmulatorFlipInvert:

 			{

 			width = iScreenProps->iXYInputWidth;

 			break;

 			}

 		case EEmulatorFlipLeft:

 		case EEmulatorFlipRight:

 			{

 			width = iScreenProps->iXYInputHeight;

 			break;

 			}

 		}

 	return width;

 	}

 /**

 Returns the maximum height for the viewport (client area only).

 Allowing for the orientation of the emulator.

 @return Max height

 */

 TInt TViewport::GetMaxHeight() const

 	{

 	TInt height=0;

 	switch(iScreenProps->iScreenRotation)

 		{

 		case EEmulatorFlipRestore:

 		case EEmulatorFlipInvert:

 			{

 			height = iScreenProps->iXYInputHeight;

 			break;

 			}

 		case EEmulatorFlipLeft:

 		case EEmulatorFlipRight:

 			{

 			height =  iScreenProps->iXYInputWidth;

 			break;

 			}

 		}

 	return height;

 	}

 /**

 Sets the X offset of the viewport from the edge of the input area

 @param aOffset The X offset

 */

 void TViewport::SetViewportOffsetX(TInt aOffset)

 	{

 	iViewportOffsetX = aOffset;

 	}

 /**

 Sets the Y offset of the viewport from the edge of the input area

 @param aOffset The Y offset

 */

 void TViewport::SetViewportOffsetY(TInt aOffset)

 	{

 	iViewportOffsetY = aOffset;

 	}

 TInt TViewport::GetViewportOffsetX() const

 	{

 	return iViewportOffsetX;	

 	}

 TInt TViewport::GetViewportOffsetY() const

 	{

 	return iViewportOffsetY;

 	}

 /**

 Sets the viewport width, this is equal to the width

 of the window's client area

 @param aWidth The width

 */

 void TViewport::SetViewportWidth(TInt aWidth)

 	{

 	iViewportWidth=aWidth;

 	}

 /**

 Sets the viewport height, this is equal to the height

 of the window's client area

 @param aHeight The height

 */

 void TViewport::SetViewportHeight(TInt aHeight)

 	{

 	iViewportHeight=aHeight;

 	}

 TInt TViewport::GetViewportWidth() const

 	{

 	return iViewportWidth;

 	}

 TInt TViewport::GetViewportHeight() const

 	{

 	return iViewportHeight;

 	}

 // the UI class

 DWinsUi::DWinsUi()

 	:iVirtualKeys(10),

 	iControlHotKeys(10)

 	{}

 /// Returns the current mode's depth. Remember current mode is never set!

 TUint DWinsUi::ColorDepth(TInt aScreenNumber)

 	{

 	TVideoInfoV01 info;

 	VideoInfo(aScreenNumber, info);

 	return info.iBitsPerPixel;

 	}

 TInt DWinsUi::SetFlip(TEmulatorFlip aFlip, TInt aScreenNumber)

 	{

 	if(TUint(aScreenNumber)>=TUint(systemIni->iScreens.Count()))

 		return KErrArgument;

 	int r1 = PostMessageA(TheChildWin[aScreenNumber],WM_FLIP_MESSAGE,(TUint)aFlip,NULL);

 	return r1 ? KErrNone : KErrGeneral;

 	}

 void DWinsUi::Info(TVariantInfoV01& aInfo)

 	{

 	aInfo.iLedCapabilities=0x3;

 	}

 HWND DWinsUi::HWnd()

 	{

 	return TheControlWin;

 	}

 TInt DWinsUi::SetupProperties(TInt aId)

 //

 // load UI settings from the emulator properties

 //

 	{

 	//setup the screens

 	TInt screens = Property::GetInt("[screens]", 1);

  	for (TInt x = 0; x < screens; ++x)

  		{

  		DScreenProperties * pScr = new DScreenProperties();

  		if (!pScr)

  			return KErrNoMemory;

  		TInt ret = pScr->SetupProperties(aId,x);

  		if (KErrNone == ret)

  			ret = iScreens.Append(pScr);

  		if (KErrNone != ret)

  			{

  			delete pScr;

  			return ret;

  			}

  		}

 //

 	char property[50];

 	wsprintfA(property, "Configuration[%d]LedSize",aId);

 	iLedSize = Property::GetInt(property, KLedSize);

 	wsprintfA(property, "Configuration[%d]LedArrangeVertically",aId);

 	iLedVertical = Property::GetBool(property, KLedVertical);

 	wsprintfA(property, "Configuration[%d]LedArrangeHorizontally",aId);

 	if (Property::GetBool(property))

 		iLedVertical = EFalse;

 	wsprintfA(property, "Configuration[%d]LedOffsetX",aId);

 	iLedOffsetX = Property::GetInt(property, KLedLeft);

 	wsprintfA(property, "Configuration[%d]LedOffsetY",aId);

 	iLedOffsetY = Property::GetInt(property, KLedTop);

 	wsprintfA(property, "Configuration[%d]LedGap",aId);

 	iLedGap = Property::GetInt(property, KLedGap);

 //

 	wsprintfA(property, "Configuration[%d]PointerType",aId);

 	const char* pointer = Property::GetString(property, "Pen");

 	if (_stricmp(pointer, "None") == 0)

 		{

 		iPointerType=_S8("NONE");

 		iXYInputType=EXYInputNone;

 		}

 	else if (_stricmp(pointer,"Pen") == 0)

 		{

 		iPointerType=_S8("PEN");

 		iXYInputType=EXYInputPointer;

 		}

 	else if (_stricmp(pointer,"Mouse") == 0)

 		{

 		iPointerType=_S8("MOUSE");

 		iXYInputType=EXYInputMouse;

 		}

 	else if (_stricmp(pointer,"Delta-Mouse") == 0)

 		{

 		iPointerType=_S8("MOUSE");

 		iXYInputType=EXYInputDeltaMouse;

 		}

 	else

 		return KErrArgument;

 //

 	wsprintfA(property, "Configuration[%d]DigitizerOffsetX",aId);

 	iDigitizerOffsetX = Property::GetInt(property, -iScreens[0]->iScreenOffsetX);

 	wsprintfA(property, "Configuration[%d]DigitizerOffsetY",aId);

 	iDigitizerOffsetY = Property::GetInt(property, -iScreens[0]->iScreenOffsetY);

 	wsprintfA(property, "Configuration[%d]DigitizerWidth",aId);

 	iDigitizerWidth = Property::GetInt(property,-1);

 	wsprintfA(property, "Configuration[%d]DigitizerHeight",aId);

 	iDigitizerHeight = Property::GetInt(property,-1);

 	wsprintfA(property, "Configuration[%d]DisableDigitizer",aId);

 	iDigitizerEnabled = !Property::GetBool(property);

 //	To enable the multitouch 

 	wsprintfA(property, "EnableMultiTouch");

 	iMultiTouchEnabled = Property::GetBool(property,EFalse);

 	wsprintfA(property, "SYMBIAN_BASE_USE_GCE");

 	iGCEEnabled = Property::GetBool(property,EFalse);

 	wsprintfA(property, "MultiTouchProximityStep");

 	iMultiTouchProximityStep = Property::GetInt(property,-1);

 	wsprintfA(property, "MultiTouchPressureStep");

 	iMultiTouchPressureStep = Property::GetInt(property,-1);

 //

 	strcpy(iSysIniFileName, Property::GetString("EmulatorDataPath"));

 	strcat(iSysIniFileName, "emulator\\");

 	if (!Emulator::CreateAllDirectories(iSysIniFileName))

 		return Emulator::LastError();

 	strcat(iSysIniFileName, Property::GetString("MachineName"));

 	strcat(iSysIniFileName, ".sys.ini");

 //

 	TInt r = iKeyboard.Init(aId);

 	if (r != KErrNone)

 		return r;

 	wsprintfA(property, "Configuration[%d]VirtualKey",aId);

 	r = MultiProperty(&DWinsUi::DoDefineVirtualKey, this, property);

 	if (r != KErrNone)

 		return r;

 //

 	wsprintfA(property, "Configuration[%d]NoVersionInfo",aId);

 	iDisplayVersionInfo = !Property::GetBool(property);

 	wsprintfA(property, "Configuration[%d]WindowTitle",aId);

 	const char * p = Property::GetString(property);

 	if (p && (strlen(p) <= KMaxNameSize))

 		strcpy(iWindowTitle, p);

 	else

 		strcpy(iWindowTitle, DefaultWindowTitle);

 	if (iDisplayVersionInfo)

 		{

 		TInt wtLen = strlen(iWindowTitle);

 		TInt vtLen = strlen(VersionText);

 		if ((wtLen + vtLen) > KMaxNameSize)

 			iWindowTitle[KMaxNameSize-vtLen] = '\0';

 		strcat(iWindowTitle, VersionText);

 		}

 	wsprintfA(property, "Configuration[%d]OnActivation",aId);

 	pointer = Property::GetString(property);	

 	//example	OnActivation 270 EKeyScreenDimension1

 	//params are rotation(int) and key(string)

 	if (pointer)

 		{

 		char * next;

 		//skip any white space

 		const char* beg = skipws(pointer);

 		//get the number

 		long rotation = strtol(beg, &next, 0);

 		if (next == beg)

 			return KErrArgument;

 		switch (rotation)

 			{

 			case 0:

 				iScreens[0]->iScreenRotation = EEmulatorFlipRestore;

 				break;

 			case 90:

 				iScreens[0]->iScreenRotation = EEmulatorFlipRight;

 				break;

 			case 180:

 				iScreens[0]->iScreenRotation = EEmulatorFlipInvert;

 				break;

 			case 270:

 				iScreens[0]->iScreenRotation = EEmulatorFlipLeft;

 				break;

 			default:

 				r = KErrArgument;

 			}

 		if (r != KErrNone)

 			return r;

 		beg = skipws(next);

 		//beg should now point to the keycode

 		TInt key = iKeyboard.GetEPOCKeyCode(TPtrC8((const TUint8*)beg, strlen(beg)));

 		if (key == KErrNotFound)

 			return key;

 		iInitialFlipMsg = key;

 		}

 	//EmulatorControl messages are a bit like virtual keys

 	wsprintfA(property, "Configuration[%d]EmulatorControl",aId);

 	r = MultiProperty(&DWinsUi::DoDefineEmulatorControl, this, property);

 	if (r != KErrNone)

 		return r;

 	wsprintfA(property, "Configuration[%d]EmulatorControlHotKey",aId);

 	r = MultiProperty(&DWinsUi::DoDefineEmulatorControlHotKey, this, property);

 	if (r != KErrNone)

 		return r;

 	return KErrNone;

 	}

 TInt DWinsUi::NumberOfScreens()

 	{

 	return iScreens.Count();

 	}

 /**

 Return the highest bit depth from an emulator mode mask.

 @param aModeMask	A bitwise combination of KEmul... display mode mask values.

 @return A color depth in bits per pixel.

 */

 LOCAL_C TInt MaximumBitDepthFromMask(TInt aModeMask)

 	{

 	// Choose the highest bits per pixel based on the display mode mask.

 	if (aModeMask & KEmulColor16M)

 		{

 		return 24;

 		}

 	if (aModeMask & KEmulColor64K)

 		{

 		return 16;

 		}

 	if (aModeMask & KEmulColor4K)

 		{

 		return 12;

 		}

 	// Lower bit depths are not supported, so use the default

 	return 24;

 	}

 /**

 Return the TDisplayRotation corresponding to the given TEmulatorFlip.

 @param aFlip	A screen rotation as a TEmulatorFlip.

 @return The screen rotation as a TDisplayRotation.

 */

 LOCAL_C RDisplayChannel::TDisplayRotation FlipToDisplayRotation(TEmulatorFlip aFlip)

 	{

 	switch (aFlip)

 		{

 		case EEmulatorFlipLeft:

 			return RDisplayChannel::ERotation90CW;

 		case EEmulatorFlipInvert:

 			return RDisplayChannel::ERotation180;

 		case EEmulatorFlipRight:

 			return RDisplayChannel::ERotation270CW;

 		}

 	return RDisplayChannel::ERotationNormal;

 	}

 TInt DWinsUi::SetDisplayChannel(TInt aScreenNumber, DDisplayChannel* aDisplay)

 	{

 	return systemIni->SetDisplayChannelImpl(aScreenNumber,aDisplay);

 	}

 TInt DWinsUi::SetDisplayChannelImpl(TInt aScreenNumber, DDisplayChannel* aDisplay)

 	{

 	if (TUint(aScreenNumber) >= TUint(NumberOfScreens()))

 		{

 		// Screen number is either negative or too big.

 		return KErrArgument;

 		}

 	TInt r = KErrNone;

 	HWND hWnd = TheChildWin[aScreenNumber];

 	TBufferSet& buffer = masterIni->iBufferSet[aScreenNumber];

 	if (aDisplay)

 		{

 		// Display driver connecting

 		DScreenProperties* screen = iScreens[aScreenNumber];

 		RDisplayChannel::TDisplayInfo info;

 		TInt pixelBytes = 2;

 		info.iBitsPerPixel = MaximumBitDepthFromMask(screen->iColorDepth);

 		switch (info.iBitsPerPixel)

 			{

 			case 12:	// XRGB4444

 				info.iPixelFormat = EUidPixelFormatXRGB_4444;

 				break;

 			case 16:	// RGB565

 				info.iPixelFormat = EUidPixelFormatRGB_565;

 				break;

 			default:

 				// Force anything else to packed RGB888

 				pixelBytes = 4;

 				info.iBitsPerPixel = 24;

 				info.iPixelFormat = EUidPixelFormatXRGB_8888;

 				break;

 			}

 		TInt width = screen->iMaxScreenWidth;

 		TInt height = screen->iMaxScreenHeight;

 		info.iRefreshRateHz = screen->iRefreshRateHz;

 		info.iAvailableRotations = RDisplayChannel::ERotationNormal | RDisplayChannel::ERotation90CW |

 									RDisplayChannel::ERotation180 | RDisplayChannel::ERotation270CW;

 		info.iNormal.iWidth = width;

 		info.iNormal.iHeight = height;

 		// Windows requires rounding up to 4-bytes words

 		info.iNormal.iOffsetBetweenLines = _ALIGN_UP(width * pixelBytes, 4);

 		info.iFlipped.iWidth = height;

 		info.iFlipped.iHeight = width;

 		// Windows requires rounding up to 4-bytes words

 		info.iFlipped.iOffsetBetweenLines = _ALIGN_UP(height * pixelBytes, 4);

 		TInt maxSize=0;	 

 		//ensure legacy buffer is large enough for all supported modes.

 		//It would be a very strange setup for the max size to not be the max bpp,

 		//but we don't know which mode is max bpp anyway!

 		TVideoInfoV01 videoInfo;

 		for (TInt mode=0,maxMode=screen->iMaxModes;mode<maxMode;mode++)

 			{

 			if (systemIni->VideoInfoForDisplayDriver(aScreenNumber,mode, videoInfo))	//can't actually fail currently

 				{

 				TInt dwSize=videoInfo.iOffsetToFirstPixel+videoInfo.iOffsetBetweenLines*videoInfo.iSizeInPixels.iHeight;

 				if (dwSize>maxSize)

 					maxSize=dwSize;

 				}

 			else

 				{

 				Fault(EGuiVideoInfoUnavailable);

 				}

 			//rotated mode may use more RAM?? Height may be >Width or may not be a multiple of stride quantum

 			if (systemIni->VideoInfoForDisplayDriver(aScreenNumber,mode|KModeFlagFlipped, videoInfo))	//can't actually fail currently

 				{

 				TInt dwSize=videoInfo.iOffsetToFirstPixel+videoInfo.iOffsetBetweenLines*videoInfo.iSizeInPixels.iWidth;

 				if (dwSize>maxSize)

 					{

 					maxSize=dwSize;

 					}

 				}

 			else

 				{

 				Fault(EGuiVideoInfoUnavailable);

 				}

 			}

 		masterIni->iMaxSizeInBytes = maxSize;

 		if (__e32_atomic_add_ord32(&buffer.iDisplayDriverCount, 1) == 0)

 			{

 			// First driver to connect, allocate frame buffers.

 			// +1 frame buffer is ui legacy buffer at [0], so does need to take account of stride and offset

 			r = masterIni->AllocateFrameBuffers(aScreenNumber, screen->iCompositionBuffers + 1, maxSize);

 			}

 		if (r == KErrNone)

 			{

 			buffer.iScreenBuffer.iDisplayBufferOffset = 0;

 			masterIni->iBufferSet[aScreenNumber].iDisplayChannel = aDisplay;

 			masterIni->InitBitmapHeader(*screen, &buffer.iInfo);

 			masterIni->InitBufferFormat(*screen, buffer.iBufferFormat);

 			if(systemIni->VideoInfoForDisplayDriver(aScreenNumber,screen->iCurrentMode, videoInfo, ETrue))

 				{

 					r = aDisplay->Initialize(info,

 											 FlipToDisplayRotation(screen->iScreenRotation),

 											 hWnd, buffer.iScreenBuffer.iFrameBuffers,

 											 buffer.iScreenBuffer.iMemChunks,

 											 buffer.iDsaBuffer,

 						                     videoInfo.iSizeInPixels,videoInfo.iSizeInTwips,

 						                     masterIni->iSupportedPixelFormatTable,

 						                     masterIni->iSupportedPixelFormatTableSize,

 						                     buffer.iBufferFormat);

 				}

 			else

 				{

 				Fault(EGuiVideoInfoUnavailable);

 				}

 			}

 		if (r != KErrNone && __e32_atomic_tas_ord32(&buffer.iDisplayDriverCount, 1, -1, 0) == 1)

 			{

 			// Release any that were allocated

 			masterIni->ReleaseFrameBuffers(aScreenNumber);

 			}

 		}

 	else

 		{

 		// Display driver disconnected

 		if (__e32_atomic_tas_ord32(&buffer.iDisplayDriverCount, 1, -1, 0) == 1)

 			{

 			// All drivers disconnected, deallocate memory.

 			masterIni->ReleaseFrameBuffers(aScreenNumber);

 			}

 		}

 	return r;

 	}

 void DWinsUi::SetVirtualKey(const TBool aProcessing, const TInt aCommandData, const TEmulCommand aCommand)

 	{

 	iProcessingVirtualKey = aProcessing;

 	iFakedVirtualKey = aCommandData;

 	iVirtualKeyCommand = aCommand;

 	}

 TBool DWinsUi::WasVirtualKey(TInt& aCommandData, TEmulCommand& aCommand)

 	{

 	if (iProcessingVirtualKey)

 		{

 		aCommandData = iFakedVirtualKey;

 		aCommand = iVirtualKeyCommand;

 		}

 	return iProcessingVirtualKey;

 	}

 TInt DWinsUi::DoDefineEmulatorControl(TAny* aPtr, const char* aValue)

 	{

 	return static_cast<DWinsUi*>(aPtr)->DefineEmulatorControl(aValue);

 	}

 TInt DWinsUi::DefineEmulatorControl(const char* aValue)

 	{

 	//example EmulatorControl SelectConfig 2 rect 223,640 29,22

 	//example EmulatorControl NextConfig rect 223,640 29,22

 	const char* beg = skipws(aValue);

 	const char* end = skiptok(beg);

 	TInt err = KErrNone;

 	TEmulCommand command = ENoCommand;

 	TInt data = 0;

 	if (_strnicmp(beg, "SelectConfig", end-beg) == 0)

 		{

 		//get the int param which is the config to switch to

 		beg = end;

 		char * e;

 		data = strtol(beg, &e,0);

 		if (beg == e)

 			err = KErrArgument;

 		end = e;

 		command = ESelectConfig;

 		}

 	else if(_strnicmp(beg, "NextConfig", end-beg) == 0)

 		{

 		command = ENextConfig;

 		}

 	else

 		err = KErrArgument;

 	if (err != KErrNone)

 		return err;

 	//get the shape

 	beg = skipws(end);

 	end = skiptok(beg);

 	if (end - beg != 4 || _strnicmp(beg, "rect", 4) != 0)

 		return KErrArgument;

 	// get the parameters

 	beg = skipws(end);

 	char* end2;

 	TInt x = strtol(beg, &end2, 10);

 	if (beg == end2 || *end2++ != ',')

 		return KErrArgument;

 	beg = end2;

 	TInt y = strtol(beg, &end2, 10);

 	if (beg == end2)

 		return KErrArgument;

 	beg = skipws(end2);

 	TInt w = strtol(beg, &end2, 10);

 	if (beg == end2 || *end2++ != ',')

 		return KErrArgument;

 	beg = end2;

 	TInt h = strtol(beg, &end2, 10);

 	if (beg == end2)

 		return KErrArgument;

 	VKRect* pRect = new VKRect(data, command, x, y, w, h);

 	if (!pRect)

 		return KErrNoMemory;

 	return iVirtualKeys.Append(pRect);

 	}

 TInt DWinsUi::DoDefineVirtualKey(TAny* aPtr, const char* aValue)

 	{

 	return static_cast<DWinsUi*>(aPtr)->DefineVirtualKey(aValue);

 	}

 TInt DWinsUi::DefineVirtualKey(const char* aValue)

 	{

 	// Get the key to map

 	const char* beg = skipws(aValue);

 	const char* end = skiptok(beg);

 	TInt key = iKeyboard.GetEPOCKeyCode(TPtrC8((const TUint8*)beg, end-beg));

 	if (key == KErrNotFound)

 		return key;

 	//get the shape

 	beg = skipws(end);

 	end = skiptok(beg);

 	if (end - beg != 4 || _strnicmp(beg, "rect", 4) != 0)

 		return KErrArgument;

 	// get the parameters

 	beg = skipws(end);

 	char* end2;

 	TInt x = strtol(beg, &end2, 10);

 	if (beg == end2 || *end2++ != ',')

 		return KErrArgument;

 	beg = end2;

 	TInt y = strtol(beg, &end2, 10);

 	if (beg == end2)

 		return KErrArgument;

 	beg = skipws(end2);

 	TInt w = strtol(beg, &end2, 10);

 	if (beg == end2 || *end2++ != ',')

 		return KErrArgument;

 	beg = end2;

 	TInt h = strtol(beg, &end2, 10);

 	if (beg == end2)

 		return KErrArgument;

 	VKRect* pRect = new VKRect(key, EKey, x, y, w, h);

 	if (!pRect)

 		return KErrNoMemory;

 	return iVirtualKeys.Append(pRect);

 	}

 LOCAL_C TInt readBitmapInfo(PBITMAPINFOHEADER aHeader, const char* aFileName)

 	{

 	PBITMAPFILEHEADER pbmfh=NULL;

 	PBITMAPINFOHEADER pbmih=NULL;

 	TInt bfOffBits;

 	HANDLE fh=CreateFileA(aFileName,GENERIC_READ,NULL,NULL,OPEN_EXISTING,NULL,NULL);

 	if (!fh || fh==INVALID_HANDLE_VALUE)

 		return KErrNotFound;

 	TInt r=KErrNone;

 	// read in the bitmap file header.  save the offset to bits.

 	pbmfh = (PBITMAPFILEHEADER)LocalAlloc(LPTR, sizeof(BITMAPFILEHEADER));

 	if (pbmfh==NULL)

 		{

 		r=KErrNotFound;

         goto exit;

 		}

 	DWORD bytesRead;

 	ReadFile(fh, (LPVOID)pbmfh, sizeof(BITMAPFILEHEADER), &bytesRead, NULL);

 	bfOffBits=pbmfh->bfOffBits;

 	// read in the bitmap info header and the color table right after it.

 	pbmih = (PBITMAPINFOHEADER)LocalAlloc(LPTR, bfOffBits- sizeof(BITMAPFILEHEADER));

 	if (pbmih==NULL)

 		{

 		r=KErrNotFound;

         goto exit;

 		}

 	ReadFile(fh, (LPVOID)pbmih, bfOffBits-sizeof(BITMAPFILEHEADER),&bytesRead,NULL);

 	*aHeader=*pbmih;

 exit:

 	LocalFree(LocalHandle ((LPSTR)pbmih));

 	LocalFree(LocalHandle ((LPSTR)pbmfh));

 	CloseHandle(fh);

 	return r;

 	}

 HBITMAP readBitmap(HDC aHdc, const char* aFileName)

 //

 // reads a BMP file from disk and returns a HBITMAP

 //

 	{

 	HBITMAP hbm=NULL;

 	PBITMAPFILEHEADER pbmfh=NULL;

 	PBITMAPINFOHEADER pbmih=NULL;

 	TUint8 *pBits=NULL;

 	TInt bfOffBits;

 	TInt nbytes;

 	HANDLE fh=CreateFileA(aFileName, GENERIC_READ, NULL, NULL, OPEN_EXISTING, NULL, NULL);

 	if (!fh || fh==INVALID_HANDLE_VALUE)

 		return NULL;

 	nbytes=GetFileSize((HANDLE)fh, NULL);

 	// read in the bitmap file header.  save the offset to bits.

 	pbmfh = (PBITMAPFILEHEADER)LocalAlloc(LPTR, sizeof(BITMAPFILEHEADER));

 	if (pbmfh==NULL)

         goto exit;

 	DWORD bytesRead;

 	ReadFile(fh, (LPVOID)pbmfh, sizeof(BITMAPFILEHEADER),&bytesRead,NULL);

 	bfOffBits=pbmfh->bfOffBits;

 	// read in the bitmap info header and the color table right after it.

 	pbmih = (PBITMAPINFOHEADER)LocalAlloc(LPTR, bfOffBits- sizeof(BITMAPFILEHEADER));

 	if (pbmih==NULL)

         goto exit;

 	ReadFile(fh, (LPVOID)pbmih, bfOffBits-sizeof(BITMAPFILEHEADER),&bytesRead,NULL);

 	// finally read in the bit data.

 	pBits = (PBYTE)LocalAlloc (LPTR, (nbytes - bfOffBits));

 	if (pBits==NULL)

         goto exit;

 	ReadFile(fh, (LPVOID)pBits, nbytes-bfOffBits,&bytesRead,NULL);

 	hbm=CreateDIBitmap(aHdc, pbmih, CBM_INIT, pBits,(PBITMAPINFO) pbmih, DIB_RGB_COLORS);

 exit:

 	LocalFree(LocalHandle ((LPSTR)pBits));

 	LocalFree(LocalHandle ((LPSTR)pbmih));

 	LocalFree(LocalHandle ((LPSTR)pbmfh));

 	CloseHandle(fh);

 	return hbm;

 	}

 void LoadFasciaBitmap(TInt aScreen)

 	{

 	HDC hdc=GetDC(TheWin[aScreen]);

 	RECT windowRect = {0};

 	windowRect.right=systemIni->iScreens[aScreen]->iXYInputWidth;

 	windowRect.bottom=systemIni->iScreens[aScreen]->iXYInputHeight;

 	HBITMAP screenBitmap=readBitmap(hdc, systemIni->iScreens[aScreen]->iFasciaFileName);

 	if (screenBitmap==NULL)

 		{

 		screenBitmap=CreateCompatibleBitmap(hdc, windowRect.right-windowRect.left, windowRect.bottom-windowRect.top);

 		HDC hdcMem=CreateCompatibleDC(hdc);

 		SelectObject(hdcMem, screenBitmap);

 		PatBlt(hdcMem, 0, 0, windowRect.right-windowRect.left, windowRect.bottom-windowRect.top, BLACKNESS);

 		DeleteDC(hdcMem);

 		}

 	__ASSERT_ALWAYS(screenBitmap!=NULL,Fault(EGuiCreateBitmap));

 	TheScreenBitmap[aScreen]=screenBitmap;

 	DrawLeds();

 	ReleaseDC(TheWin[aScreen], hdc);

 	}

 TBool DWinsUi::MultiTouchEnabled() const

 	{

 	return iMultiTouchEnabled;

 	}

 TBool DWinsUi::GCEEnabled() const

 	{

 	return iGCEEnabled;

 	}

 TInt DWinsUi::MultiTouchProximityStep() const

 	{

 	return iMultiTouchProximityStep;

 	}

 TInt DWinsUi::MultiTouchPressureStep() const

 	{

 	return iMultiTouchPressureStep;

 	}

 TBool DWinsUi::OnDigitizer(TInt aX, TInt aY) const

 	{

 	if (!iDigitizerEnabled)

 		return EFalse;

 	switch(CurrentFlipState[0])

 		{

 		case EEmulatorFlipRestore:

 			{

 			aX -= iDigitizerOffsetX;

 			aY -= iDigitizerOffsetY;

 			break;

 			}

 		case EEmulatorFlipInvert:

 			{

 			aX -= systemIni->iScreens[0]->iScreenWidth - iDigitizerOffsetX - iDigitizerWidth;

 			aY -= systemIni->iScreens[0]->iScreenHeight - iDigitizerOffsetY - iDigitizerHeight;

 			break;

 			}

 		case EEmulatorFlipRight:

 			{

 			TInt oldY = aY;

 			aY = aX - (systemIni->iScreens[0]->iScreenHeight - iDigitizerOffsetY - iDigitizerHeight);

 			aX = oldY - iDigitizerOffsetX;

 			break;

 			}

 		case EEmulatorFlipLeft:

 			{

 			TInt oldY = aY;

 			aY = aX - iDigitizerOffsetY;

 			aX = oldY - (systemIni->iScreens[0]->iScreenWidth - iDigitizerOffsetX - iDigitizerWidth);

 			break;

 			}

 		}

 	return (TUint(aX) < TUint(iDigitizerWidth) && TUint(aY) < TUint(iDigitizerHeight));

 	}

 LOCAL_C void addMouseEvent(TRawEvent::TType aType,TInt aXpos,TInt aYpos)

 //

 // Add a mouse event.

 //

 	{

 	if (systemIni->OnDigitizer(aXpos, aYpos))

 		{

 		TRawEvent v;

 		v.Set(aType,aXpos,aYpos);

 		TheEventQ.Add(v);

 		}

 	}

 LOCAL_C void addMouseEvent(TRawEvent::TType aType,TInt aXpos,TInt aYpos,TInt aZpos, TInt aPointerId=0)

 //

 // Add a multitouch mouse event.

 //

 	{

 	if (systemIni->OnDigitizer(aXpos, aYpos))

 		{

 		TRawEvent v;

 		v.Set(aType,aXpos,aYpos, aZpos);

 		v.SetPointerNumber(static_cast<const TUint8>(aPointerId));

 		TheEventQ.Add(v);

 		}

 	}

 LOCAL_C void addKeyEvent(TRawEvent::TType aType,TInt aKey)

 	{

 	TRawEvent v;

 	v.Set(aType, aKey);

 	TheEventQ.Add(v);

 	}

 LOCAL_C void SwitchConfiguration(TInt aData, TBool aSendFlipKey = ETrue)

 	{

 	if (aData < 0 || aData >= masterIni->iSystemInis.Count())

 		return;

 	CurrentConfiguration = aData;

 	systemIni = masterIni->iSystemInis[aData];

 	//get the correct fascia bitmaps

 	TInt screens=systemIni->iScreens.Count();

 	TInt i;

 	TUint disabledWinType=ENormalResolution;

 	for(i=0;i<screens;i++)

 		{

 		DeleteObject(TheScreenBitmap[i]);

 		LoadFasciaBitmap(i);

 		if (masterIni->iBufferSet[i].iDisplayState!=ENormalResolution)

 			{

 			disabledWinType=masterIni->iBufferSet[i].iDisplayState;

 			}

 		}

 	//update the window title

 	if (disabledWinType!=ENormalResolution && disabledWinType < 4)	//hardwired 4 because the code below is hardwired

 		{	//string may be multi-part indexed by disable type, or it may not

 		CHAR* firstsemi=strchr(systemIni->iWindowTitle,';');

 		CHAR* secondsemi=NULL;

 		if (firstsemi)

 			{

 			secondsemi=strchr(firstsemi+1,';');

 			}

 		if (firstsemi&&secondsemi)

 			{

 			*firstsemi='\0';

 			*secondsemi='\0';

 			char* ptr[4]={0,systemIni->iWindowTitle,firstsemi+1,secondsemi+1};

 			SetWindowTextA(TheControlWin, ptr[disabledWinType]);

 			*firstsemi=';';

 			*secondsemi=';';

 			}

 		else

 			{

 			SetWindowTextA(TheControlWin, systemIni->iWindowTitle);

 			}

 		}

 	else

 		{

 		SetWindowTextA(TheControlWin, systemIni->iWindowTitle);

 		}

 	//resize and repaint the current window anyway.

 	//the text window server doesn't respond to orientation messages

 	for(i=0;i<screens;i++)

 		{

 		InvalidateRect(TheWin[i], NULL, false);

 		SendMessage(TheWin[i], WM_FLIP_MESSAGE, systemIni->iScreens[i]->iScreenRotation,0);

 		}

 	//pass on the orientation key to the windows server

 	if (aSendFlipKey)

 		{

 		if (!WinsGuiPowerHandler->iStandby)

 			{

 			addKeyEvent(TRawEvent::EKeyDown, systemIni->iInitialFlipMsg);

 			addKeyEvent(TRawEvent::EKeyUp, systemIni->iInitialFlipMsg);

 			}

 		else

 			{

 			//remember the flip message so we can send it to the window server when we come out of standby

 			SavedFlipMessage = systemIni->iInitialFlipMsg;

 			}

 		}

 	}

 /**

 Sets the specified screen to the given width and height, if available.

 The configurations are searched to find a match, taking the display state into

 account. If no configuration is available, the request is ignored.

 @param aScreenNumber	the screen index

 @param aWidth 			the desired width

 @param aHeight			the desired height

 **/

 void DMasterIni::SetDisplaySize(TInt aDisplayNumber, TInt aWidth, TInt aHeight)

 	{

 	TInt displayCount = iBufferSet.Count();

 	if (aDisplayNumber < 0 || aDisplayNumber >= displayCount)

 		{

 		// Invalid screen number, discard.

 		return;

 		}

 	if (iBufferSet[aDisplayNumber].iDisplayState != ENormalResolution)

 		{

 		// No (non-zero) resolutions available, discard.

 		return;

 		}

 	TInt count = iSystemInis.Count();

 	TInt index;

 	for (index = 0; index < count; index++)

 		{

 		DWinsUi* newIni = masterIni->iSystemInis[index];

 		DScreenProperties* newProps = newIni->iScreens[aDisplayNumber];

 		if (newProps->iScreenWidth == aWidth && newProps->iScreenHeight == aHeight)

 			{

 			// Found a potential match. Check other screens match their current size.

 			if (newIni == systemIni)

 				{

 				// Current configuration, already in use. Nothing to do.

 				break;

 				}

 			TInt display;

 			for (display = 0; display < displayCount; display++)

 				{

 				if (display == aDisplayNumber)

 					{

 					// No need to check the display we are changing

 					continue;

 					}

 				DScreenProperties* currentPropsN = systemIni->iScreens[display];

 				DScreenProperties* newPropsN = newIni->iScreens[display];

 				if (newPropsN->iScreenWidth != currentPropsN->iScreenWidth ||

 						newPropsN->iScreenHeight != currentPropsN->iScreenHeight)

 					{

 					// Resolution mismatch, try next configuration.

 					break;

 					}

 				}

 			if (display == displayCount)

 				{

 				// Match found, switch to this configuration and stop. Force

 				// rotation to the same as the current rotation.

 				newProps->iScreenRotation = systemIni->iScreens[aDisplayNumber]->iScreenRotation;

 				SwitchConfiguration(index);

 				break;

 				}

 			}

 		}

 	}

 void DMasterIni::SetBufferFormat(TInt aDisplayNumber, TUint aAggregateSize, RDisplayChannel::TPixelFormat aPixelFormat)

 	{

 	TInt displayCount = iBufferSet.Count();

 	if (aDisplayNumber < 0 || aDisplayNumber >= displayCount)

 		{

 		// Invalid screen number, discard.

 		return;

 		}

 	LPBITMAPV4HEADER info = &iBufferSet[aDisplayNumber].iInfo;

 	// update the bitmap header taking in consideration the new pixel format

 	switch (aPixelFormat)

 		{

 		case EUidPixelFormatXRGB_4444:

 		case EUidPixelFormatARGB_4444:

 			info->bV4BitCount=16;

 			info->bV4V4Compression = BI_BITFIELDS;

 			info->bV4RedMask   = 0x0F00;

 			info->bV4GreenMask = 0x00F0;

 			info->bV4BlueMask  = 0x000F;

 			break;

 		case EUidPixelFormatRGB_565:

 			info->bV4BitCount=16;

 			info->bV4V4Compression = BI_BITFIELDS;

 			info->bV4RedMask   = 0xF800;

 			info->bV4GreenMask = 0x07E0;

 			info->bV4BlueMask  = 0x001F;

 			break;

 		case EUidPixelFormatXRGB_8888:	// Really 32bpp, but top 8 unused

 		case EUidPixelFormatARGB_8888:

 		case EUidPixelFormatARGB_8888_PRE:

 			info->bV4BitCount=32;

 			info->bV4V4Compression = BI_RGB;

 			// Mask is implicit for BI_RGB compression

 			break;

 		default:

 			// We got an error, it seems. Let's ignore the message

 			return;

 		}

 	iBufferSet[aDisplayNumber].iBufferFormat.iPixelFormat = aPixelFormat;

 	// taking advantage of limiting the width and size to KMaxTInt16

 	TInt width = aAggregateSize & 0x0000ffff;

 	TInt height = (aAggregateSize >> 16) & 0x0000ffff;

 	// let's deal with the new size just received

 	iBufferSet[aDisplayNumber].iBufferFormat.iSize.iWidth = width;

 	iBufferSet[aDisplayNumber].iBufferFormat.iSize.iHeight = height;

 	// update the bitmap header, taking in consideration the rotation

 	switch (CurrentFlipState[aDisplayNumber])

 		{

 		case EEmulatorFlipRestore:

 		case EEmulatorFlipInvert:

 			info->bV4Width = width;

 			info->bV4Height = -height;

 			break;

 		case EEmulatorFlipLeft:

 		case EEmulatorFlipRight:

 			info->bV4Width = height;

 			info->bV4Height = -width;

 			break;

 		}

 	// finally, update the image size

 	SetImageSize(aDisplayNumber);

 	}

 void DMasterIni::SetImageSize(TInt aScreenNumber)

 	{

 	TInt displayCount = iBufferSet.Count();

 	if (aScreenNumber >= 0 && aScreenNumber < displayCount)

 		{

 		LPBITMAPV4HEADER info = &iBufferSet[aScreenNumber].iInfo;

 		TInt bpp = _ALIGN_UP(info->bV4BitCount, 16); //12 & 16 --> 16 ; 24 & 32 --> 32

 		TInt widthInBpp = info->bV4Width * bpp;

 		//rounding to 32 bits (4 octets) and converting, then, bits to octets;

 		TInt scanLineInBytes = _ALIGN_UP(widthInBpp, 32) >> 3;

 		// info->bV4Height is negative or zero

 		info->bV4SizeImage = -info->bV4Height * scanLineInBytes;

 		}

 	}

 LOCAL_C void NextConfiguration()

 	{

 	TInt config = CurrentConfiguration;

 	if (++config == masterIni->iSystemInis.Count())

 		config = 0;

 	SwitchConfiguration(config);

 	}

 LOCAL_C TBool ProcessedByEmulatorKey(TInt aScanCode, HWND hWnd,TUint message,TUint wParam,TUint lParam)

 	{

 	TBool rVal = EFalse;

 	rVal = ETrue;

 	for (TInt i=0;i<systemIni->iControlHotKeys.Count();i++)//check key combinations

 		{

 		if (systemIni->iControlHotKeys[i]->CheckCombinationPressed()) 

 			{				

 			switch (systemIni->iControlHotKeys[i]->iCommand)

 				{

 				case ENextConfig:

 					NextConfiguration();

 					break;

 				case ESelectConfig:

 					SwitchConfiguration(systemIni->iControlHotKeys[i]->iData);

 					break;

 				}

 			return ETrue;

 			}

 		}

 	switch (aScanCode)

 	{

 	case EStdKeyF4:

 		{

 		// Simulate a change of media card

 		TInt irq = NKern::DisableAllInterrupts();

 		if (*Wins::MediaDoorOpenPtr())

 			{

 			*Wins::CurrentPBusDevicePtr() += 1;

 			if (*Wins::CurrentPBusDevicePtr() == 2)

 				{

 				*Wins::CurrentPBusDevicePtr() = -1;

 				}

 			}

 		NKern::RestoreInterrupts(irq);

 		// pass on to the windows system so that if

 		// Alt-F4 is pressed the window will close

 		if (hWnd)

 			DefWindowProcA(hWnd,message,wParam,lParam);

 		break;

 		}

 	default:

 		rVal = EFalse;

 		break;

 	}

 	return rVal;

 	}

 LOCAL_C void MultiChildWndPointer(TUint aMessage,TInt aXpos,TInt aYpos, TInt aZ, TInt aPointerId)

 //

 // Handle a multi-touch pointer event in the Symbian OS screen window 

 //

 	{

 	TRawEvent::TType eventType=TRawEvent::ENone;

 	CHAR buf[50];

 	if (aZ <= TheMultiTouch->iZMaxRange) //negative

 		{

 		eventType = TRawEvent::EPointer3DOutOfRange;

 		wsprintf((LPTSTR)buf, (LPCTSTR)TEXT("Out Of Range"));

 		SendMessage(hwndStatus, SB_SETTEXT, aPointerId , (LPARAM)(buf));					

 		}

 	else 

 		{

 		wsprintf((LPTSTR)buf, (LPCTSTR)TEXT("%d: %d,%d,%d"), aPointerId, aXpos,aYpos,aZ);

 		SendMessage(hwndStatus, SB_SETTEXT, aPointerId , (LPARAM)(buf));					

 		switch (aMessage)

 	    	{

 			case WM_MOUSEMOVE:

 				{

 				eventType=TRawEvent::EPointerMove;

 				break;

 				}

 			case WM_LBUTTONDOWN:

 				{

 				SetCapture(TheChildWin[0]);

 				eventType = TRawEvent::EButton1Down;

 				}

 				break;

 			case WM_LBUTTONUP:

 				{

 				ReleaseCapture();

 				eventType = TRawEvent::EButton1Up;

 				break;

 				}

 			case WM_RBUTTONDOWN:

 				{

 				eventType = TRawEvent::EButton3Down;

 				break;

 				}

 			case WM_RBUTTONUP:

 				{

 				eventType = TRawEvent::EButton3Up;

 				break;

 				}

 			case WM_MOUSEWHEEL:

 				{

 				eventType = TRawEvent::EPointerMove;

 				break;

 				}

 			default:

 				return;

 			}

 		}

 	if (!WinsGuiPowerHandler->iStandby)

 		{

 		addMouseEvent(eventType, aXpos, aYpos, aZ, aPointerId);

 		}

 	}

 LOCAL_C void ChildWndPointer(TUint message,TInt aXpos,TInt aYpos)

 //

 // Handle a pointer event in the Symbian OS screen window

 //

 	{

 	// Enable the multitouch if the cursor is inside the main client window

 	if (DMultiTouch::iMultiTouchCreated)

 		{

 		RECT client;

 		WINDOWINFO info;

 		GetWindowInfo(TheChildWin[0], &info);

 		POINT pt = {aXpos+(TInt)info.rcClient.left, aYpos+(TInt)info.rcClient.top};

 		if (GetWindowRect(TheChildWin[0], &client) &&

 				(PtInRect(&client,pt)!=NULL) && !DMultiTouch::iMultiTouchTempEnabled)	// within the window

 			{

 			if (systemIni->MultiTouchEnabled() && systemIni->GCEEnabled())

 				{

 				if(TheMultiTouch->Register())	// Register successfully

 					{

 					DMultiTouch::iMultiTouchTempEnabled = TRUE;

 					//Show the status bars at the bottom of the emulator

 					SetWindowPos(hwndStatus,0,0,0,0,0,SWP_SHOWWINDOW);

 					SetFocus(TheWin[0]);

 					SetCursor(LoadCursorA(NULL,MAKEINTRESOURCEA(32512)));

 					}

 				}

 			}

 		}

 	TRawEvent::TType eventType=TRawEvent::ENone;

 	switch (message)

     	{

 	case WM_MOUSEMOVE:

 		eventType=TRawEvent::EPointerMove;

 		break;

 	case WM_LBUTTONDOWN:

 		{

 		SetCapture(TheChildWin[0]);

 		eventType=TRawEvent::EButton1Down;

 		}

 		break;

 	case WM_LBUTTONUP:

 		ReleaseCapture();

 		eventType=TRawEvent::EButton1Up;

 		break;

 	case WM_RBUTTONDOWN:

 		eventType=TRawEvent::EButton3Down;

 		break;

 	case WM_RBUTTONUP:

 		eventType=TRawEvent::EButton3Up;

 		break;

 	case WM_MBUTTONDOWN:

 		eventType=TRawEvent::EButton2Down;

 		break;

 	case WM_MBUTTONUP:

 		eventType=TRawEvent::EButton2Up;

 		break;

 		}

 	if (!WinsGuiPowerHandler->iStandby)

 		{

 		addMouseEvent(eventType, aXpos, aYpos);

 		}

 	}

 LOCAL_C void FrameWndPointer(TUint message,TInt aXpos,TInt aYpos, TInt aScreenNumber, TInt aPointerId = 0)

 //

 // Handle a frame wnd pointer event.

 //

 	{

 	static bool	processingScreenOn=FALSE;

 	TEmulCommand command = ENoCommand;

 	TInt commandData = 0;

 	TBool mouseEvent = ETrue;

 	TRawEvent::TType eventType=TRawEvent::ENone;

 	TViewport& viewport = systemIni->iScreens[aScreenNumber]->iViewport;

 	aXpos += viewport.GetViewportOffsetX(); // make mouse-coords relative to fascia edge even if window is scrolled

 	aYpos += viewport.GetViewportOffsetY();

 	switch (message)

     	{

 	case WM_MOUSEMOVE:

 		{

 		TInt newX, newY;

 		systemIni->TranslateMouseCoords(CurrentFlipState[0], aXpos, aYpos, systemIni->iScreens[0]->iXYInputWidth, systemIni->iScreens[0]->iXYInputHeight, newX, newY);

 		if (aPointerId == 0)

 			{ // only system pointer changes shape

 		if (systemIni->GetVirtualKey(command, newX, newY) >= 0)

 			{

 			HMODULE hmodule = GetModuleHandleA("winsgui.dll");

 			SetCursor(LoadCursorA((HINSTANCE)hmodule,MAKEINTRESOURCEA(OVERKEY)));		//hand cursor

 			}

 		else

 			SetCursor(LoadCursorA(NULL,MAKEINTRESOURCEA(32512))); //ICD_ARROW

 				}

 		eventType=TRawEvent::EPointerMove;

 		}

 		break;

 	case WM_LBUTTONDOWN:

 		{

 		SetCapture(TheWin[0]);

 		//check the configuration

 		TInt newX, newY;

 		//if the emulator screen is rotated, rotate/flip the current mouse cursor position

 		//so it can be checked to see if it is in a key region.

 		systemIni->TranslateMouseCoords(CurrentFlipState[0], aXpos, aYpos, systemIni->iScreens[0]->iXYInputWidth, systemIni->iScreens[0]->iXYInputHeight, newX, newY);

 		commandData = systemIni->GetVirtualKey(command, newX, newY);

 		if (commandData >= 0)

 			{

 			eventType=TRawEvent::EKeyDown;

 			mouseEvent = EFalse;

 			systemIni->SetVirtualKey(ETrue, commandData, command);

 			}

 		else

 			eventType=TRawEvent::EButton1Down;

 		}

 		break;

 	case WM_LBUTTONUP:

 		ReleaseCapture();

 		if (processingScreenOn)

 			{

 			// ignore button up - button down was switching things on

 			processingScreenOn=FALSE;

 			return;

 			}

 		if (systemIni->WasVirtualKey(commandData, command))

 			{

 			eventType=TRawEvent::EKeyUp;

 			mouseEvent = EFalse;

 			systemIni->SetVirtualKey(EFalse, EStdKeyNull, ENoCommand);

 			}

 		else

 			eventType=TRawEvent::EButton1Up;

 		break;

 	case WM_RBUTTONDOWN:

 		eventType=TRawEvent::EButton3Down;

 		break;

 	case WM_RBUTTONUP:

 		eventType=TRawEvent::EButton3Up;

 		break;

 	case WM_MBUTTONDOWN:

 		eventType=TRawEvent::EButton2Down;

 		break;

 	case WM_MBUTTONUP:

 		eventType=TRawEvent::EButton2Up;

 		break;

 		}

 	if (mouseEvent)

 		{

 		if (!WinsGuiPowerHandler->iStandby)

 			{

 			/*

 			mouse events are relative to the child window position

 			and are clipped to the digitzer region in addMouseEvent

 			so all the mouse clicks are passed on here after being translated 

 			to the child window coordinate system (under the current rotation)

 			*/

 			TInt newX, newY;

 			switch (CurrentFlipState[0])

 				{

 				case EEmulatorFlipRestore:

 				default:

 					newX = aXpos - systemIni->iScreens[0]->iScreenOffsetX;

 					newY = aYpos - systemIni->iScreens[0]->iScreenOffsetY;

 					break;

 				case EEmulatorFlipInvert:

 					newX = aXpos - (systemIni->iScreens[0]->iXYInputWidth - systemIni->iScreens[0]->iScreenWidth - systemIni->iScreens[0]->iScreenOffsetX);

 					newY = aYpos - (systemIni->iScreens[0]->iXYInputHeight - systemIni->iScreens[0]->iScreenHeight - systemIni->iScreens[0]->iScreenOffsetY);

 					break;

 				case EEmulatorFlipLeft:

 					newX = aXpos - systemIni->iScreens[0]->iScreenOffsetY;

 					newY = aYpos - (systemIni->iScreens[0]->iXYInputWidth - systemIni->iScreens[0]->iScreenWidth - systemIni->iScreens[0]->iScreenOffsetX);

 					break;	

 				case EEmulatorFlipRight:

 					newX = aXpos - (systemIni->iScreens[0]->iXYInputHeight - systemIni->iScreens[0]->iScreenHeight - systemIni->iScreens[0]->iScreenOffsetY);

 					newY = aYpos - systemIni->iScreens[0]->iScreenOffsetX;

 					break;

 				}

 			addMouseEvent(eventType, newX, newY);

 			}

 		}

 	else if ((((message == WM_LBUTTONDOWN && command == EKey) && !ProcessedByEmulatorKey((TUint8)commandData,0,0,0,0)))

 			|| (message == WM_LBUTTONUP))

 		{

 			switch (command)

 			{

 			case EKey:

 				if (!WinsGuiPowerHandler->iStandby)

 					addKeyEvent(eventType, (TUint8)commandData);

 				break;

 			case ENextConfig:

 				NextConfiguration();

 				break;

 			case ESelectConfig:

 				SwitchConfiguration(commandData);

 				break;

 			}

 		}

 	}

 LOCAL_C TInt ScreenFromHWND(HWND aHwnd,HWND* pWin)

 	{

 	TInt screens=systemIni->iScreens.Count();

 	TInt r=-1;

 	for(TInt i=0;i<screens;i++)

 		{

 		if(pWin[i]==aHwnd)

 			{

 			r=i;

 			break;

 			}

 		}

 	return r;

 	}

 void MultiTouchWndPointer(TUint message,TInt aXpos,TInt aYpos, TInt aZ, TInt aPointerId)

 	{

 	WINDOWINFO info;

 	info.cbSize = sizeof(WINDOWINFO);

 	if (GetWindowInfo(TheWin[0], &info))

 		{

 		POINT pt = {aXpos,aYpos};

 		if (PtInRect(&info.rcWindow,pt))

 			{

 			RECT client;

 			if (GetWindowRect(TheChildWin[0], &client) && PtInRect(&client,pt))	// within the window

 				{

 				MultiChildWndPointer(message, aXpos-client.left, aYpos-client.top, aZ, aPointerId);

 				}

 			else  

 				{		

 				//	Disable the multitouch if the cursor is outside the application window

 				if (DMultiTouch::iMultiTouchTempEnabled)	// within the window

 					{

 					DMultiTouch::iMultiTouchTempEnabled = FALSE;

 					if(TheMultiTouch->UnRegister())

 						{

 						SetWindowPos(hwndStatus,0,0,0,0,0,SWP_HIDEWINDOW);

 						}

 					}

 				FrameWndPointer(message, aXpos-info.rcClient.left, aYpos-info.rcClient.top, 0, aPointerId);	

 				}

 			}

 		}

 	}

 LOCAL_C DScreenProperties* ScreenPropsFromHWND(HWND aHwnd, HWND* pWin)

 	{

 	TInt screenNumber =  ScreenFromHWND(aHwnd, pWin);

 	if(screenNumber >=0)

 		{

 		return systemIni->iScreens[screenNumber];

 		}

 	return NULL;

 	}

 TInt APIENTRY childWinProc(HWND hWnd,TUint message,TUint wParam,TUint lParam)

 //

 // The child window function.

 //

 	{

 	TInt screenNumber = 0;

 	TRawEvent v;

     switch (message)

     	{

 	case WM_FLIP_MESSAGE: // pass the flip message onto the parent window

 		{

 		screenNumber =ScreenFromHWND(hWnd,TheChildWin);

 		if(TUint(screenNumber) < TUint(systemIni->iScreens.Count()))

 			PostMessageA(TheWin[screenNumber],WM_FLIP_MESSAGE,wParam,NULL);

 		break;

 		}

 	case WM_LBUTTONDOWN:

 	case WM_LBUTTONUP:

 	case WM_MOUSEMOVE:

 	case WM_RBUTTONDOWN:

 	case WM_RBUTTONUP:

 	case WM_MBUTTONDOWN:

 	case WM_MBUTTONUP:

 		{

 		if (DMultiTouch::iMultiTouchTempEnabled)

 			{

 			DMultiTouch::iMultiTouchTempEnabled = FALSE;

 			}

 		screenNumber=ScreenFromHWND(hWnd,TheChildWin);

 		if(screenNumber==0)

 			{

 			ChildWndPointer(message,(TInt16)(lParam&0xFFFF),(TInt16)((lParam>>16)&0xFFFF));

 			}

 		break;

 		}

     case WM_PAINT:

 		if (!PaintWindowFromBuffer(hWnd))

 			{

 			// Original behaviour

 			ValidateRect(hWnd,NULL);

 			v.Set(TRawEvent::ERedraw);

 			TheEventQ.Add(v);

 			}

         break;

     case WM_ACTIVATE:

 	case WM_SYSKEYDOWN:

 	case WM_KEYDOWN:

 	case WM_SYSKEYUP:

 	case WM_KEYUP:

 		Fault(EGuiChildWinProc);

 		break;

     case WM_DESTROY:

 		break;

 	case WM_CHAR:

 	case WM_SYSCHAR:

 	case WM_DEADCHAR:

 	case WM_SYSDEADCHAR:

         break;

 	case WMU_SET_DISPLAY_BUFFER:

 		screenNumber = ScreenFromHWND(hWnd, TheChildWin);

 		if (TUint(screenNumber) < TUint(systemIni->iScreens.Count()))

 			{

 			masterIni->iBufferSet[screenNumber].iDisplayBuffer = (LPVOID)lParam;

 			}

 		break;

 	case WMU_SET_DISPLAY_SIZE:

 		screenNumber = ScreenFromHWND(hWnd, TheChildWin);

 		masterIni->SetDisplaySize(screenNumber, wParam, lParam);

 		break;

 	case WMU_SET_BUFFER_FORMAT:

 		screenNumber = ScreenFromHWND(hWnd, TheChildWin);

 		masterIni->SetBufferFormat(screenNumber, wParam, (RDisplayChannel::TPixelFormat) lParam);

 		break;

  	default:

         return(DefWindowProcA(hWnd,message,wParam,lParam));

 	    }

     return(FALSE);

 	}

 LOCAL_C TBool PaintWindowFromBuffer(HWND hWnd)

 	{

 	TInt screenNumber = ScreenFromHWND(hWnd,TheChildWin);

 	if (TUint(screenNumber) >= TUint(masterIni->iBufferSet.Count()))

 		{

 		return EFalse;

 		}

 	LPVOID displayBuffer = masterIni->iBufferSet[screenNumber].iDisplayBuffer;

 	if (!displayBuffer)

 		{

 		return EFalse;

 		}

 	TInt   frameOffset = masterIni->iBufferSet[screenNumber].iScreenBuffer.iDisplayBufferOffset;

 	displayBuffer=LPVOID(frameOffset+(char*)displayBuffer);

 	PAINTSTRUCT ps;

 	BeginPaint(hWnd, &ps);

 	// Paint directly from the buffer to the window

 	LPBITMAPINFO info = (LPBITMAPINFO)&masterIni->iBufferSet[screenNumber].iInfo;

 	WORD width = (WORD)info->bmiHeader.biWidth;

 	WORD height = (WORD)-info->bmiHeader.biHeight;	// stored -ve in info

 	SetDIBitsToDevice(ps.hdc,

 						0, 0, 	// Dst X, Y

 						width, height,	// Src W, H

 						0, 0,	// Src X, Y

 						0,		// Src offset to first line

 						height,	// Src lines available

 						displayBuffer,	// Src pointer to pixels

 						info,			// Src info

 						DIB_RGB_COLORS);

 	EndPaint(hWnd, &ps);

 	return TRUE;

 	}

 LOCAL_C void CalcTextPos(TInt aScreen, TInt& aX, TInt& aY)

 	{

 	switch (CurrentFlipState[aScreen])

 		{

 	case EEmulatorFlipInvert:

 		aX = systemIni->iScreens[aScreen]->iXYInputWidth-(systemIni->iScreens[aScreen]->iScreenOffsetX+systemIni->iScreens[aScreen]->iScreenWidth);

 		aY = systemIni->iScreens[aScreen]->iXYInputHeight-(systemIni->iScreens[aScreen]->iScreenOffsetY+systemIni->iScreens[aScreen]->iScreenHeight);

 		break;

 	case EEmulatorFlipLeft:

 		aX = systemIni->iScreens[aScreen]->iScreenOffsetY;

 		aY = systemIni->iScreens[aScreen]->iXYInputWidth-(systemIni->iScreens[aScreen]->iScreenOffsetX+systemIni->iScreens[aScreen]->iScreenWidth);

 		break;

 	case EEmulatorFlipRight:

 		aX = systemIni->iScreens[aScreen]->iXYInputHeight-(systemIni->iScreens[aScreen]->iScreenOffsetY+systemIni->iScreens[aScreen]->iScreenHeight);

 		aY = systemIni->iScreens[aScreen]->iScreenOffsetX;

 		break;

 	case EEmulatorFlipRestore:

 	default:

 		aX = systemIni->iScreens[aScreen]->iScreenOffsetX;

 		aY = systemIni->iScreens[aScreen]->iScreenOffsetY;

 	break;

 		}

 	//subtract viewport offset here

 	aX -= systemIni->iScreens[aScreen]->iViewport.GetViewportOffsetX();

 	aY -= systemIni->iScreens[aScreen]->iViewport.GetViewportOffsetY();

 	}

 TInt APIENTRY ctrlwinProc(HWND hWnd,TUint message,TUint wParam,TUint lParam)

 //

 // The control window function

 //

 	{

 	switch(message)

 	{

 		case WM_SYSCOMMAND:

 			{

 				switch(wParam)

 				{

 					case 1:

 						{

 						NextConfiguration();

 						return 0;

 						}

 					case SC_MINIMIZE:

 					case SC_RESTORE:

 						{

 						if (wParam == SC_RESTORE) 

 							Active();

 						for(TInt ix=0;ix<systemIni->iScreens.Count();ix++)

 							{

 							SendMessage(TheWin[ix],message,wParam,lParam);

 							}

 						if (wParam == SC_MINIMIZE) 

 							Inactive();

 						}			

 				}

 				return(DefWindowProcA(hWnd,message,wParam,lParam));

 			}

 		case WM_CLOSE: // tell all emulator screen windows to close

 			{

 			for(TInt i=0;i<systemIni->iScreens.Count();i++)

 				{

 				DestroyWindow(TheWin[i]);

 				}

 			DestroyWindow(hWnd);

 			break;

 			}

 		case WM_DESTROY: