// 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)

		{