--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/emulator/emulatorbsp/inc/gui.h Tue Feb 02 01:39:10 2010 +0200
@@ -0,0 +1,523 @@
+// 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