// Copyright (c) 1998-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\inc\gui.h

// 

//

#ifndef __EX_GUI_H__

#define __EX_GUI_H__

#define _CRTIMP			// we want to use the win32 static runtime library

#include "platform.h"

#include <kernel/win32/property.h>

#include "nk_priv.h"

#include "vwins.h"

#include <e32keys.h>

#include <stdlib.h>

#include <videodriver.h>

#include <dispchannel.h>

GLREF_C const char* skipws(const char* aPtr);

GLREF_C const char* skiptok(const char* aPtr);

// keyboard mapping

const TUint KKeyExtendedBit=0x100;

const TUint KKeyNormalBits=0xFF;

const TInt KMaxExtendedKey=0x5d;

const TInt KExtendedKeyBase=0x1c;

const TInt KStandardKeyMapSize = 89;

const TInt KExtendedKeyMapSize = KMaxExtendedKey + 1 - KExtendedKeyBase;

const TUint KMaxHotKeyCombinationLength=10;

const TInt KDatFileVersion= 1000;

enum TEmulCommand

	{

	ENoCommand,

	EKey,

	ENextConfig,

	ESelectConfig,

	};

class VirtualKey

	{

public:

	VirtualKey(const TInt aCommandData, TEmulCommand aCommand);

	virtual TBool Contains(TInt aX, TInt aY) const = 0;

	virtual void Draw(HDC aHdc,COLORREF aColor) const =0;

	inline TInt Value() const {return iData;};

	inline TEmulCommand Command() const {return iCommand;};

private:

	TEmulCommand iCommand;

	TInt iData;

	};

typedef TStdScanCode KeyArray[KMaxHotKeyCombinationLength];

class KeyCombination

	{

public:

	KeyCombination(const TInt aCommandData, TEmulCommand aCommand);

	TBool AddKey(TStdScanCode);

	TBool CheckCombinationPressed();

	TEmulCommand iCommand;

	TInt iData;

private:

	KeyArray iCombination;

	};

class VKRect : public VirtualKey

	{

public:

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

	// From VirtualKey

	TBool Contains(TInt aX, TInt aY) const;

	virtual void Draw(HDC aHdc,COLORREF aColor) const;

private:

	TInt iLeft,iTop,iRight,iBottom;

	VKRect();

	};

class Alias

	{

public:

	Alias();

//

	TInt Add(const TDesC8& aAlias, const TDesC8& aName);

	const TDesC8* operator[](const TDesC8& aAlias);

private:

	struct SEntry

		{

		TDesC8* iAlias;

		TDesC8* iName;

		};

	static TBool Compare(const SEntry& aLhs, const SEntry& aRhs);

private:

	RArray<SEntry> iMap;

	};

// GUI settings

const TInt KPowerTimerId=1;

const TInt KRomMajorVersionNumber=1;

const TInt KRomMinorVersionNumber=0;

const TInt KRomBuildVersionNumber=1;

//

const TInt KScreenOffsetX=90;

const TInt KScreenOffsetY=51;

const TInt KScreenWidth=640;

const TInt KScreenHeight=240;

const TInt KWinPosX=10;

const TInt KWinPosY=10;

const TInt KCompositionBuffers=2;	// Default to double-buffering

const TInt KRefreshRateHz=30;	// Default to 30fps

const TInt KMaxNameSize=80;	//size of window title string

//

// window style

const DWORD KInvisibleControlWinStyle=WS_CAPTION|WS_CLIPCHILDREN|WS_MINIMIZEBOX|WS_OVERLAPPED|WS_SYSMENU;

const DWORD KControlWinStyle=KInvisibleControlWinStyle|WS_VISIBLE;

const DWORD KInvisibleWinStyle=WS_CAPTION|WS_CLIPCHILDREN|WS_OVERLAPPED|WS_HSCROLL|WS_VSCROLL|WS_SIZEBOX|

	WS_MAXIMIZEBOX|WS_MINIMIZEBOX|WS_SYSMENU;

const DWORD KWinStyle=KInvisibleWinStyle|WS_VISIBLE;

//

// Scaling factors to use if PhysicalScreenWidth or Height are not specified

const TReal KDefaultPixelsToTwipsX=11.90625;

const TReal KDefaultPixelsToTwipsY=11.9083333334;

//

const TInt KHeapSize=0x2000;

const TInt KWindowServerHeapSize=0x40000;

const TInt KKeyDown=0x80;

//

const TInt KLedTop=45;

const TInt KLedLeft=36;

const TInt KLedSize=14;

const TInt KLedGap=5;

const TBool KLedVertical=ETrue;

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

const TInt KSecureLedColor = 0xFFFF;

class DWinsKeyboard : public DBase

	{

public:

	DWinsKeyboard();

	TInt Init(TInt aId);

//

	TInt ScanCodeToRemappedKey(TInt aScanCode);

	static TInt ScanCodeToStandardKey(TInt aScanCode);

//

	TInt GetEPOCKeyCode(const TDesC8& aStr);

	TInt GetScanCode(const TDesC8& aStr);

private:

	static TInt ScanCodeToKey(TInt aScanCode, const TUint8* aStandardMap, const TUint8* aExtendedMap);

	TInt DefineAlias(const char* aValue);

	static TInt DoDefineAlias(TAny* aObj, const char* aValue);

	TInt MapKey(const char* aValue);

	static TInt DoMapKey(TAny* aObj, const char* aValue);

private:

	TUint8 iStandardKeyMap[KStandardKeyMapSize];

	TUint8 iExtendedKeyMap[KExtendedKeyMapSize];

	TUint8 iAltStandardKeyMap[KStandardKeyMapSize];

	TUint8 iAltExtendedKeyMap[KExtendedKeyMapSize];

	TUint8 iCtrlStandardKeyMap[KStandardKeyMapSize];

	TUint8 iCtrlExtendedKeyMap[KExtendedKeyMapSize];

	Alias iAliasedKeys;

	};

struct TWindowState

	{

public:

	WINDOWPLACEMENT iWinPlace;

	TInt iXoffset;

	TInt iYoffset;

	TEmulatorFlip iFlipstate;

	};

class DScreenProperties;

class TViewport 

	{

public:

	TViewport();

	TViewport(DScreenProperties* aScreenProps);

	~TViewport();

	void UpdateScrollBarH(HWND aHwnd);

	void UpdateScrollBarV(HWND aHwnd);

	TInt GetMaxWindowWidth() const;

	TInt GetMaxWindowHeight() const;

	TInt GetMaxWidth() const;

	TInt GetMaxHeight() const;

	TInt GetViewportOffsetX() const;

	TInt GetViewportOffsetY() const;

	void SetViewportWidth(TInt aWidth);

	void SetViewportHeight(TInt aHeight);

	TInt GetViewportWidth() const;

	TInt GetViewportHeight() const;

	void ScrollToY(TInt aPosition,HWND aHwnd);

	void ScrollToX(TInt aPosition, HWND aHwnd);

	void UpdateChildPos(HWND aHwnd);

private:

	void SetViewportOffsetX(TInt aOffset);

	void SetViewportOffsetY(TInt aOffset);

	/**

	The DScreenProperties object which owns this viewport

	*/

	DScreenProperties* iScreenProps;

	/**

	Width in pixels of the client area of the window through which the emulator is being viewed

	*/

	TInt iViewportWidth;

	/**

	Height in pixels of the client area of the window through which the emulator is being viewed

	*/

	TInt iViewportHeight;

	/**

	X Offset of viewport edge from emulator image ie. How far viewport is translated

	*/

	TInt iViewportOffsetX;

	/**

	Y Offset of viewport edge from emulator image ie. How far viewport is translated

	*/

	TInt iViewportOffsetY;

	};

class DScreenProperties

	{

friend class TViewport;

public:

	DScreenProperties();

	~DScreenProperties();

	TInt SetupProperties(TInt aConf, TInt aScreen);

	TWindowState GetWindowState();

public:

	TInt iScreenWidth;

	TInt iScreenHeight;

	TInt iMaxScreenWidth;

	TInt iMaxScreenHeight;

    TInt iXYInputWidth;

    TInt iXYInputHeight;

	TInt iPhysicalScreenWidth;

	TInt iPhysicalScreenHeight;

	TInt iMaxPhysicalScreenWidth;

	TInt iMaxPhysicalScreenHeight;

	TInt iScreenOffsetX; 

	TInt iScreenOffsetY;

	TUint iColorDepth; 			///<In emulator this is a bitfield of the available modes. All other aspects of each mode are identical.

	TInt iDisplayContrast;

	TEmulatorFlip iScreenRotation;

	CHAR iFasciaFileName[MAX_PATH];

	HWND iWindowHandle;

	WINDOWPLACEMENT iWinPlace; ///<Used to store the window's WINDOWPLACEMENT struct.

	RECT iWinRect;

	TBool iScreenOff;

	TInt  iCurrentMode;		   ///<Indicates the current mode when multiple modes are supported

	TInt  iMaxModes;

	TInt  iModeDepths[KEmulMaxNumModes];

	TInt iCompositionBuffers;

	TInt iRefreshRateHz;

	/**

	The viewport owned by the screen

	*/

	TViewport iViewport;

	};

class DDisplayChannel;

class DWinsUi : public DWinsUiBase

	{

public:

	DWinsUi();

	TInt Create(TInt aId);

//

	TInt GetVirtualKey(TEmulCommand& aCommand, TInt aX, TInt aY);

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

	TBool WasVirtualKey(TInt& aCommandData, TEmulCommand& aCommand);

	void TranslateMouseCoords(const TEmulatorFlip aFlipState, const TInt aX, const TInt aY, const TInt aRegionWidth, const TInt aRegionHeight, TInt& aNewX, TInt& aNewY);

	//

	TBool OnScreen(TInt aScreen, TInt aX, TInt aY) const;

	TBool OnDigitizer(TInt aX, TInt aY) const;

	TBool MultiTouchEnabled() const;

	TBool GCEEnabled() const;

	TInt MultiTouchPressureStep() const;

	TInt MultiTouchProximityStep() const;

//private:

	void ScreenInfo(TScreenInfoV01& aInfo);

	TBool VideoInfo(TInt aDeviceNumber, TVideoInfoV01& aInfo);

	TBool VideoInfo(TInt aDeviceNumber,TInt aModeNumber, TVideoInfoV01& aInfo);

	TBool VideoInfoForDisplayDriver(TInt aDeviceNumber,TInt aModeNumber, TVideoInfoV01& aInfo, TBool aRealWidthAndHeight = EFalse);

//

	TInt SetupProperties(TInt aId);

	TInt DefineVirtualKey(const char* aValue);

	static TInt DoDefineVirtualKey(TAny* aObj, const char* aValue);

	TInt DefineEmulatorControl(const char* aValue);

	static TInt DoDefineEmulatorControl(TAny* aObj, const char* aValue);

	static TInt DoDefineEmulatorControlHotKey(TAny* aPtr, const char* aValue);

	TInt DefineEmulatorControlHotKey(const char* aValue);

//	implementing DWinsUiBase

	TUint ColorDepth(TInt aScreenNumber);

	TInt SetFlip(TEmulatorFlip aFlip, TInt aScreenNumber);

	void Info(TVariantInfoV01& aInfo);

	HWND HWnd();

	void SwitchDisplay(TBool aSecure);

	TInt NumberOfScreens();

	virtual TInt SetDisplayChannel(TInt aScreenNumber, DDisplayChannel* aDisplay);

	TInt SetDisplayChannelImpl(TInt aScreenNumber, DDisplayChannel* aDisplay);

public:

	DWinsKeyboard iKeyboard;

//

	TInt iLedSize;

	TInt iLedGap;

	TInt iLedOffsetX;

	TInt iLedOffsetY;

	TBool iLedVertical;

	TBuf8<0x10> iPointerType;

	TXYInputType iXYInputType;

	CHAR iSysIniFileName[MAX_PATH];

	WINDOWPLACEMENT iWinPlace;

    RPointerArray<VirtualKey> iVirtualKeys;

	RPointerArray<KeyCombination> iControlHotKeys;

	TInt iDigitizerWidth;

	TInt iDigitizerHeight;

	TInt iDigitizerOffsetX;	//offset from the epoc screen 0!

	TInt iDigitizerOffsetY;//offset from the epoc screen 0!

	TBool iDigitizerEnabled;

	CHAR iWindowTitle[KMaxNameSize+1];

	TBool iDisplayVersionInfo;

	TInt aId;			//configuration number;

	TInt iInitialFlipMsg;

	TBool iProcessingVirtualKey;

	TUint iFakedVirtualKey;

	TEmulCommand iVirtualKeyCommand;

	RPointerArray<DScreenProperties> iScreens;

private:

	TBool iMultiTouchEnabled;

	TBool iGCEEnabled;

	TInt iMultiTouchProximityStep;

	TInt iMultiTouchPressureStep;

	};

struct TBufferAddressA

	{

	DChunk* iChunk;

	TAny* iAddress;

	};

class TScreenBuffer

	{

public:	

	RPointerArray<TAny> iFrameBuffers;

	RPointerArray<TBufferAddressA> iMemChunks;

	TInt 	iDisplayBufferOffset;    //offset to pixel data in current mode for display buffer. Mode of display buffer doesn't change we presume!

	};

// Chunk cleanup object - used to clean up the process/addr table when the process goes away.

class TChunkCleanup : public TDfc

    {

public:

    TChunkCleanup(DProcess* aProcess, TInt aScreenNumber);

    void Cancel();

    inline void SetIndex(TUint aIndex) { iIndex = aIndex; }

private:

    static void ChunkDestroyed(TChunkCleanup* aSelf);

private:

    DProcess* iProcess;

    TInt      iScreenNumber;

    TInt	  iIndex;

    };

// Entry to hold the process/disp.memory address, as we need to find the address of the display

// memory when requested. A new entry would be added when a process first requests the address of display

// memory. When the process dies, we remove the process entry (by way of a DFC for a chunk that is 

// created on behalf of that process).

class TProcessAddrEntry 

    {

public:

	TProcessAddrEntry(DProcess *aProcess, TUint8* aAddress);

public:

	DProcess* iProcess;

	TUint8* iAddress;

	};

class TBufferSet

	{

public:

	TAny* iDisplayBuffer;		//current display buffer

	BITMAPV4HEADER iInfo;		// This can be cast to a BITMAPINFOHEADER

	TInt           iDisplayDriverCount;

	TScreenBuffer  iScreenBuffer;

	TScreenBuffer  iDsaBuffer;

	RArray<TProcessAddrEntry> iProcAddrTable;

	TInt iDisplayState;

	TInt iStateChangeCount;

	RDisplayChannel::TBufferFormat iBufferFormat;

	DDisplayChannel* iDisplayChannel;

	};

class DMasterIni : public DBase

	{

public:

	TInt SetupProperties();

	TInt Create();

	static TInt DoHalFunction(TAny* aPtr, TInt aFunction, TAny* a1, TAny* a2);

	TInt HalFunction(TInt aDeviceNumber, TInt aFunction, TAny* a1, TAny* a2);

	static TInt DoXYHalFunction(TAny* aThis, TInt aFunction, TAny* a1, TAny* a2);

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

	static TInt DoMouseHalFunction(TAny* aThis, TInt aFunction, TAny* a1, TAny* a2);

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

	static TInt DoKbdHalFunction(TAny* aThis, TInt aFunction, TAny* a1, TAny* a2);

	void InitBitmapHeader(DScreenProperties& aScreenProperties, LPBITMAPV4HEADER aInfo);

	void InitBufferFormat(DScreenProperties& aScreenProperties, RDisplayChannel::TBufferFormat& aBufferFormat);

	TInt AllocateFrameBuffers(TInt aScreenNumber, TInt aCount, TInt aSize);

	void ReleaseFrameBuffers(TInt aScreenNumber);

	TInt DisplayMemoryAddress(TInt aScreenNumber, TInt& aAddress);

	TInt DisplayMemoryHandle(TInt aScreenNumber, TInt& aHandle);

	void ProcessDeletedDFC();

	void SetDisplaySize(TInt aDisplayNumber, TInt aWidth, TInt aHeight);

	void SetBufferFormat(TInt aDisplayNumber, TUint aAgregatSize, RDisplayChannel::TPixelFormat aPixelFormat);

	void SetImageSize(TInt aScreenNumber);

public:

	//not set or used: TInt iConfigurationCount;

	RPointerArray<DWinsUi> iSystemInis;	//Indexed by config

	RArray<TBufferSet>     iBufferSet;

	// Fast mutex used to control access to the process/address table in the 

	// TBufferSet. 

	NFastMutex iLock;

	TUint iMaxSizeInBytes;

	static const RDisplayChannel::TPixelFormat iSupportedPixelFormatTable[];

	static const TInt iSupportedPixelFormatTableSize;

private:

	TInt NumberOfResolutions(TInt aDeviceNumber, TAny* a1, TAny* a2);

	TInt SpecificScreenInfo(TInt aDeviceNumber, TAny* a1, TAny* a2);

	TInt CurrentScreenInfo(TInt aDeviceNumber, TAny* a1, TAny* a2);

};

GLREF_C TInt CompareI(const TDesC8& aLhs, const TDesC8& aRhs);

// user-defined messages ...

// flip the emulator window

#define WM_FLIP_MESSAGE 0x7FFF

// emulator window power state

#define WM_EMUL_POWER_ON 0x7FFE

//redraw client window from the internal buffer

#define WM_REDRAW_WINDOW 	(WM_USER + 1)

// Set the display frame buffer for this window to lParam

#define WMU_SET_DISPLAY_BUFFER	(WM_USER + 2)

// Set the display size for this window to (wParam,lParam)

// Rotation (flip) is ignored. Current display state is used.

// Configurations are searched to find a match, message is ignored if none found.

#define WMU_SET_DISPLAY_SIZE	(WM_USER + 3)

//modifies the header of the bitmap that is getting painted, updating the size

#define WMU_SET_BUFFER_FORMAT	(WM_USER + 4)

enum TGuiPanic

	{

	EGuiGetModuleHandle=21,

	EGuiRegisterWindow=22,

	EGuiKernelWindowCreate=23,

	EGuiRegisterChildWindow=24,

	EGuiKernelChildWindowCreate=25,

	EGuiCreateBitmap=26,

	EGuiChildWinProc=27,

	EGuiEnterCS=28,

	EGuiLeaveCS=29,

	EGuiStandbyWhilstOff=30,

	EGuiResetPowerEvent=31,

	EGuiSetPowerEvent=32,

	EGuiWaitPowerOnFailed=33,

	EGuiNoDisplayChannel=34,

	EGuiVideoInfoUnavailable=35,

	EGuiInvalidMultiTouch=36

	};

GLREF_C void Fault(TGuiPanic aPanic);

#endif