We are currently migrating Bugzilla to GitHub issues.
Any changes made to the bug tracker now will be lost, so please do not post new bugs or make changes to them.
When we're done, all bug URLs will redirect to their equivalent location on the new bug tracker.

[patch] Patch for Windows CE

libsdl-1.2.svn-wince_video.diff (text/plain), 105.84 KB, created by Sam Lantinga on 2011-02-28 15:16:42 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Sam Lantinga

Created: 2011-02-28 15:16:42 UTC

Size: 105.84 KB

patch

obsolete

>Index: src/file/SDL_rwops.c
>===================================================================
>Index: src/stdlib/SDL_malloc.c
>===================================================================
>Index: src/main/win32/SDL_win32_main.c
>===================================================================
>Index: src/events/SDL_keyboard.c
>===================================================================
>Index: src/video/gapi/SDL_gapivideo.h
>===================================================================
>--- src/video/gapi/SDL_gapivideo.h	(revision 29)
>+++ src/video/gapi/SDL_gapivideo.h	(revision 41)
>@@ -1,160 +1,88 @@
>-/*
>-    SDL - Simple DirectMedia Layer
>-    Copyright (C) 1997-2009 Sam Lantinga
>+/***************************************************************************
>+ *   Copyright (C) 2010 by Andrey Afletdinov <afletdinov@gmail.com>        *
>+ *                                                                         *
>+ *   WinCE RAW/GAPI video driver                                           *
>+ *                                                                         *
>+ *   Part of the SDL - (Simple DirectMedia Layer)                          *
>+ *   http://www.libsdl.org                                                 *
>+ *                                                                         *
>+ *   This program is free software; you can redistribute it and/or modify  *
>+ *   it under the terms of the GNU General Public License as published by  *
>+ *   the Free Software Foundation; either version 2 of the License, or     *
>+ *   (at your option) any later version.                                   *
>+ *                                                                         *
>+ *   This program is distributed in the hope that it will be useful,       *
>+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
>+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
>+ *   GNU General Public License for more details.                          *
>+ *                                                                         *
>+ *   You should have received a copy of the GNU General Public License     *
>+ *   along with this program; if not, write to the                         *
>+ *   Free Software Foundation, Inc.,                                       *
>+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
>+ ***************************************************************************/
> 
>-    This library is free software; you can redistribute it and/or
>-    modify it under the terms of the GNU Lesser General Public
>-    License as published by the Free Software Foundation; either
>-    version 2.1 of the License, or (at your option) any later version.
>-
>-    This library is distributed in the hope that it will be useful,
>-    but WITHOUT ANY WARRANTY; without even the implied warranty of
>-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
>-    Lesser General Public License for more details.
>-
>-    You should have received a copy of the GNU Lesser General Public
>-    License along with this library; if not, write to the Free Software
>-    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
>-
>-    Sam Lantinga
>-    slouken@libsdl.org
>-*/
> #include "SDL_config.h"
> 
> #ifndef _SDL_gapivideo_h
> #define _SDL_gapivideo_h
> 
>-#include "SDL_mouse.h"
>-#include "SDL_mutex.h"
> #include "../SDL_sysvideo.h"
>-#include "../windib/SDL_gapidibvideo.h"
> 
>-/* From gx.h, since it's not really C compliant */
>+#define WIN32_LEAN_AND_MEAN
>+#include <windows.h>
> 
>-struct GXDisplayProperties {
>-    DWORD cxWidth;
>-    DWORD cyHeight;         // notice lack of 'th' in the word height.
>-    long cbxPitch;          // number of bytes to move right one x pixel - can be negative.
>-    long cbyPitch;          // number of bytes to move down one y pixel - can be negative.
>-    long cBPP;              // # of bits in each pixel
>-    DWORD ffFormat;         // format flags.
>-};
>+// private framebuffer info
>+typedef struct
>+{
>+    int width;
>+    int height;
>+    int xpitch;
>+    int ypitch;
>+    int offset;
>+    int bpp;
>+    int flags;
>+    int format;
>+} FrameBufferInfo;
> 
>-struct GXKeyList {
>-    short vkUp;             // key for up
>-    POINT ptUp;             // x,y position of key/button.  Not on screen but in screen coordinates.
>-    short vkDown;
>-    POINT ptDown;
>-    short vkLeft;
>-    POINT ptLeft;
>-    short vkRight;
>-    POINT ptRight;
>-    short vkA;
>-    POINT ptA;
>-    short vkB;
>-    POINT ptB;
>-    short vkC;
>-    POINT ptC;
>-    short vkStart;
>-    POINT ptStart;
>-};
>+// SDL_gapivideo.c
>+typedef struct _GapiInfo GapiInfo;
>+typedef BOOL  (*PFNSHFullScreen)(HWND, DWORD);
> 
>-typedef int   (*PFNGXOpenDisplay)(HWND hWnd, DWORD dwFlags);
>-typedef int   (*PFNGXCloseDisplay)();
>-typedef void* (*PFNGXBeginDraw)();
>-typedef int   (*PFNGXEndDraw)();
>-typedef int   (*PFNGXOpenInput)();
>-typedef int   (*PFNGXCloseInput)();
>-typedef struct GXDisplayProperties (*PFNGXGetDisplayProperties)();
>-typedef struct GXKeyList (*PFNGXGetDefaultKeys)(int iOptions);
>-typedef int   (*PFNGXSuspend)();
>-typedef int   (*PFNGXResume)();
>-typedef int   (*PFNGXSetViewport)( DWORD dwTop, DWORD dwHeight, DWORD dwReserved1, DWORD dwReserved2 );
>-typedef BOOL  (*PFNGXIsDisplayDRAMBuffer)();
>-
>-struct GapiFunc
>+// private display data
>+struct SDL_PrivateVideoData
> {
>-    PFNGXOpenDisplay          GXOpenDisplay;
>-    PFNGXCloseDisplay         GXCloseDisplay;
>-    PFNGXBeginDraw            GXBeginDraw;
>-    PFNGXEndDraw              GXEndDraw;
>-    PFNGXOpenInput            GXOpenInput;
>-    PFNGXCloseInput           GXCloseInput;
>-    PFNGXGetDisplayProperties GXGetDisplayProperties;
>-    PFNGXGetDefaultKeys       GXGetDefaultKeys;
>-    PFNGXSuspend              GXSuspend;
>-    PFNGXResume               GXResume;
>-    PFNGXSetViewport          GXSetViewport;
>-    PFNGXIsDisplayDRAMBuffer  GXIsDisplayDRAMBuffer;
>-};
>+    // system params
>+    int w, h;
>+    void* buffer;
> 
>-#define kfLandscape	0x8			// Screen is rotated 270 degrees
>-#define kfPalette	0x10		// Pixel values are indexes into a palette
>-#define kfDirect	0x20		// Pixel values contain actual level information
>-#define kfDirect555	0x40		// 5 bits each for red, green and blue values in a pixel.
>-#define kfDirect565	0x80		// 5 red bits, 6 green bits and 5 blue bits per pixel
>-#define kfDirect888	0x100		// 8 bits each for red, green and blue values in a pixel.
>-#define kfDirect444	0x200		// 4 red, 4 green, 4 blue
>-#define kfDirectInverted 0x400
>+    // video memory
>+    unsigned char* videoMem;
> 
>-#define GX_FULLSCREEN	0x01		// for OpenDisplay() 
>-#define GX_NORMALKEYS   0x02
>-#define GX_LANDSCAPEKEYS        0x03
>+    // framebuffer
>+    FrameBufferInfo fb;
> 
>+    // GAPI module
>+    GapiInfo* gapi;
> 
>-/* GAPI video mode */
>-typedef enum {
>-	GAPI_NONE = 0,
>-	GAPI_DIRECT_565,
>-	GAPI_DIRECT_555,
>-	GAPI_MONO,
>-	GAPI_PALETTE
>-} GAPIVideoMode; 
>+    // modelist
>+    // (gapi and raw only two mode (portrait and landscape)
>+    SDL_Rect  modeP;
>+    SDL_Rect  modeL;
>+    SDL_Rect* modes[3];
> 
>-typedef unsigned short PIXEL;
>+    // specific info
>+    WCHAR oemInfo[48];
>+    int userOrientation, systemOrientation, hardwareGeometry;
> 
>-/* Private display data 
>-   begin with DIB private structure to allow DIB events code sharing
>-*/
>-struct GapiInfo {
>-	/* Rotation which has to be applied to the key (arrow keys) and mouse events measured in quarters of a circle
>-	 * counter clockwise */
>-	int coordinateTransform; 
>-	char hiresFix; /* using hires mode without defining hires resource */
>-	int invert; //TODO this is only written but never read, so it should be removed
>+    // scale pointer position
>+    float scale;
> 
>-#define NUM_MODELISTS	4		/* 8, 16, 24, and 32 bits-per-pixel */
>-	int SDL_nummodes[NUM_MODELISTS];
>-	SDL_Rect **SDL_modelist[NUM_MODELISTS];
>-	
>+    // aygshell.dll
>+    HMODULE         hAygShell;
>+    PFNSHFullScreen SHFullScreen;
> 
>-	// The orientation of the video mode user wants to get
>-	// Probably restricted to UP and RIGHT
>-	SDL_ScreenOrientation userOrientation;
>-	SDL_ScreenOrientation systemOrientation;
>-// --------------
>-	int useGXOpenDisplay; /* use GXOpenDispplay */
>-	int alreadyGXOpened;
>-	int w, h;
>-	// The orientation of GAPI framebuffer.
>-	// Never changes on the same device.
>-	SDL_ScreenOrientation gapiOrientation;
>-
>-	void *buffer; // may be 8, 16, 24, 32 bpp
>-	PIXEL *videoMem;
>-	BOOL needUpdate;
>-	struct GXKeyList keyList;
>-	struct GapiFunc gxFunc;
>-	struct GXDisplayProperties gxProperties;
>-	GAPIVideoMode videoMode;
>-	int colorscale;
>-	int dstLineStep;  // in bytes
>-	int dstPixelStep; // in bytes
>-	int startOffset; // in bytes
>-	int useVga;
>-	int suspended; // do not pu anything into video memory
>+    int debug;
> };
> 
>-
>-
>-#endif /* _SDL_gapivideo_h */
>+#endif
>Index: src/video/gapi/SDL_gapivideo.c
>===================================================================
>--- src/video/gapi/SDL_gapivideo.c	(revision 29)
>+++ src/video/gapi/SDL_gapivideo.c	(revision 41)
>@@ -1,499 +1,772 @@
>-/*
>-    SDL - Simple DirectMedia Layer
>-    Copyright (C) 1997-2009 Sam Lantinga
>+/***************************************************************************
>+ *   Copyright (C) 2010 by Andrey Afletdinov <afletdinov@gmail.com>        *
>+ *                                                                         *
>+ *   WinCE RAW/GAPI video driver                                           *
>+ *                                                                         *
>+ *   Part of the SDL - (Simple DirectMedia Layer)                          *
>+ *   http://www.libsdl.org                                                 *
>+ *                                                                         *
>+ *   This program is free software; you can redistribute it and/or modify  *
>+ *   it under the terms of the GNU General Public License as published by  *
>+ *   the Free Software Foundation; either version 2 of the License, or     *
>+ *   (at your option) any later version.                                   *
>+ *                                                                         *
>+ *   This program is distributed in the hope that it will be useful,       *
>+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
>+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
>+ *   GNU General Public License for more details.                          *
>+ *                                                                         *
>+ *   You should have received a copy of the GNU General Public License     *
>+ *   along with this program; if not, write to the                         *
>+ *   Free Software Foundation, Inc.,                                       *
>+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
>+ ***************************************************************************/
> 
>-    This library is free software; you can redistribute it and/or
>-    modify it under the terms of the GNU Lesser General Public
>-    License as published by the Free Software Foundation; either
>-    version 2.1 of the License, or (at your option) any later version.
>+#include "SDL_config.h"
> 
>-    This library is distributed in the hope that it will be useful,
>-    but WITHOUT ANY WARRANTY; without even the implied warranty of
>-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
>-    Lesser General Public License for more details.
>+#include "SDL.h"
>+#include "SDL_error.h"
>+#include "SDL_video.h"
> 
>-    You should have received a copy of the GNU Lesser General Public
>-    License along with this library; if not, write to the Free Software
>-    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
>+// for define few types
>+#include "../wincommon/SDL_syswm_c.h"
> 
>-    Sam Lantinga
>-    slouken@libsdl.org
>-*/
>-#include "SDL_config.h"
>+#include "SDL_gapivideo.h"
> 
>-/* Pocket PC GAPI SDL video driver implementation;
>-Implemented by Dmitry Yakimov - support@activekitten.com
>-Inspired by http://arisme.free.fr/ports/SDL.php
>-*/
>+// RawFrameBufferInfo
>+typedef struct
>+{
>+   WORD wFormat;
>+   WORD wBPP;
>+   VOID *pFramePointer;
>+   int  cxStride;
>+   int  cyStride;
>+   int  cxPixels;
>+   int  cyPixels;
>+} RawFrameBufferInfo;
> 
>-// TODO: copy surface on window when lost focus
>-// TODO: test buttons rotation
>-// TODO: test on be300 and HPC ( check WinDib fullscreen keys catching )
>-// TODO: test on smartphones
>-// TODO: windib on SH3 PPC2000 landscape test
>-// TODO: optimize 8bpp landscape mode
>+// GXDeviceInfo
>+typedef struct
>+{
>+    long Version;
>+    void* pvFrameBuffer;
>+    unsigned long cbStride;
>+    unsigned long cxWidth;
>+    unsigned long cyHeight;
>+    unsigned long cBPP;
>+    unsigned long ffFormat;
>+    char unknown[0x84 - 7 * 4];
>+} GXDeviceInfo;
> 
>-// there is some problems in runnings apps from a device landscape mode
>-// due to WinCE bugs. Some works and some - does not.
>-// TODO: finish Axim Dell X30 and user landscape mode, device landscape mode
>-// TODO: finish Axim Dell X30 user portrait, device landscape stylus conversion
>-// TODO: fix running GAPI apps from landscape mode - 
>-//       wince goes to portrait mode, but does not update video memory
>+// GXDisplayProperties
>+struct GXDisplayProperties
>+{
>+    DWORD cxWidth;
>+    DWORD cyHeight;
>+    long cbxPitch;
>+    long cbyPitch;
>+    long cBPP;
>+    DWORD ffFormat;
>+};
> 
>+// define GapiInfo
>+typedef int   (*PFNGXOpenDisplay)(HWND hWnd, DWORD dwFlags);
>+typedef int   (*PFNGXCloseDisplay)();
>+typedef void* (*PFNGXBeginDraw)();
>+typedef int   (*PFNGXEndDraw)();
>+typedef int   (*PFNGXOpenInput)();
>+typedef int   (*PFNGXCloseInput)();
>+typedef struct GXDisplayProperties (*PFNGXGetDisplayProperties)();
>+typedef struct GXKeyList (*PFNGXGetDefaultKeys)(int iOptions);
>+typedef int   (*PFNGXSuspend)();
>+typedef int   (*PFNGXResume)();
>+typedef int   (*PFNGXSetViewport)( DWORD dwTop, DWORD dwHeight, DWORD dwReserved1, DWORD dwReserved2 );
>+typedef BOOL  (*PFNGXIsDisplayDRAMBuffer)();
> 
>-#include "SDL.h"
>-#include "SDL_error.h"
>-#include "SDL_video.h"
>-#include "SDL_mouse.h"
>-#include "../SDL_sysvideo.h"
>-#include "../SDL_pixels_c.h"
>-#include "../../events/SDL_events_c.h"
>-#include "../wincommon/SDL_syswm_c.h"
>-#include "../wincommon/SDL_sysmouse_c.h"
>-#include "../windib/SDL_dibevents_c.h" 
>+struct _GapiInfo
>+{
>+    // gx.dll
>+    HMODULE                   hGapiLib;
>+    PFNGXOpenDisplay          GXOpenDisplay;
>+    PFNGXCloseDisplay         GXCloseDisplay;
>+    PFNGXBeginDraw            GXBeginDraw;
>+    PFNGXEndDraw              GXEndDraw;
>+    PFNGXOpenInput            GXOpenInput;
>+    PFNGXCloseInput           GXCloseInput;
>+    PFNGXGetDisplayProperties GXGetDisplayProperties;
>+    PFNGXGetDefaultKeys       GXGetDefaultKeys;
>+    PFNGXSuspend              GXSuspend;
>+    PFNGXResume               GXResume;
>+    PFNGXSetViewport          GXSetViewport;
>+    PFNGXIsDisplayDRAMBuffer  GXIsDisplayDRAMBuffer;
>+};
> 
>-#include "../windib/SDL_gapidibvideo.h"
>-#include "SDL_gapivideo.h"
>+enum ScreenOrientation { ORIENTATION_UNKNOWN, ORIENTATION_UP, ORIENTATION_DOWN, ORIENTATION_LEFT, ORIENTATION_RIGHT };
>+enum ScreenGeometry { GEOMETRY_UNKNOWN, GEOMETRY_PORTRAIT, GEOMETRY_LANDSCAPE, GEOMETRY_SQUARE };
>+enum FrameBufferFlags { FB_SKIP_OFFSET = 0x0001, FB_RAW_MODE = 0x0002, FB_SUSPENDED = 0x0004 };
> 
>-#define gapi this->hidden->gapiInfo
>-
> #define GAPIVID_DRIVER_NAME "gapi"
> 
>-#if defined(DEBUG) || defined (_DEBUG) || defined(NDEBUG)
>-#define REPORT_VIDEO_INFO 1
>-#else
>-#define REPORT_VIDEO_INFO 0
>-#endif
>+int			WINCE_Available(void);
>+SDL_VideoDevice*	WINCE_CreateDevice(int devindex);
>+void			WINCE_DeleteDevice(SDL_VideoDevice *device);
> 
>-// for testing with GapiEmu
>-#define USE_GAPI_EMU 0
>-#define EMULATE_AXIM_X30 0
>-#define WITHOUT_GAPI 0
>+// GAPI driver bootstrap functions
>+VideoBootStrap GAPI_bootstrap = { GAPIVID_DRIVER_NAME, "WinCE GAPI video driver", WINCE_Available, WINCE_CreateDevice };
> 
>-#if USE_GAPI_EMU && !REPORT_VIDEO_INFO
>-#pragma message("Warning: Using GapiEmu in release build. I assume you'd like to set USE_GAPI_EMU to zero.")
>-#endif
>+#define FORMAT_565		1
>+#define FORMAT_555		2
>+#define FORMAT_OTHER		3
> 
>+#define GETRAWFRAMEBUFFER	0x00020001
>+#define GETGXINFO		0x00020000
>+
>+#define SHFS_SHOWTASKBAR	0x0001
>+#define SHFS_HIDETASKBAR	0x0002
>+#define SHFS_SHOWSIPBUTTON	0x0004
>+#define SHFS_HIDESIPBUTTON	0x0008
>+#define SHFS_SHOWSTARTICON	0x0010
>+#define SHFS_HIDESTARTICON	0x0020
>+
>+#define kfPalette		0x10
>+#define kfDirect		0x20
>+#define kfDirect555		0x40
>+#define kfDirect565		0x80
>+
>+#define GX_FULLSCREEN		0x01
>+
> #ifndef _T
>-#define _T(x) L##x
>+#define _T(x)			L##x
> #endif
> 
>-#ifndef ASSERT
>-#define ASSERT(x)
>-#endif
> 
>-// defined and used in SDL_sysevents.c
>-extern HINSTANCE aygshell;
>-extern void SDL_UnregisterApp();
>-extern int DIB_AddMode(_THIS, int bpp, int w, int h);
> 
>-/* Initialization/Query functions */
>-static int GAPI_VideoInit(_THIS, SDL_PixelFormat *vformat);
>-static SDL_Rect **GAPI_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags);
>-static SDL_Surface *GAPI_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags);
>-static int GAPI_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors);
>-static void GAPI_VideoQuit(_THIS);
>+// short defines
>+#define _THIS		SDL_VideoDevice *this
>+#define g_Private	this->hidden
>+#define g_GapiInfo	this->hidden->gapi
> 
>-/* Hardware surface functions */
>-static int GAPI_AllocHWSurface(_THIS, SDL_Surface *surface);
>-static int GAPI_LockHWSurface(_THIS, SDL_Surface *surface);
>-static void GAPI_UnlockHWSurface(_THIS, SDL_Surface *surface);
>-static void GAPI_FreeHWSurface(_THIS, SDL_Surface *surface);
>+// windib/SDL_dibevents.c
>+extern LONG	DIB_HandleMessage(_THIS, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
>+extern void	DIB_InitOSKeymap(_THIS);
> 
>-/* Windows message handling functions, will not be processed */
>-static void GAPI_Activate(_THIS, BOOL active, BOOL minimized);
>-static void GAPI_RealizePalette(_THIS);
>-static void GAPI_PaletteChanged(_THIS, HWND window);
>-static void GAPI_WinPAINT(_THIS, HDC hdc); 
>+// system func
>+int		WINCE_VideoInit(_THIS, SDL_PixelFormat *vformat);
>+void		WINCE_VideoQuit(_THIS);
>+SDL_Surface*	WINCE_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags);
>+SDL_Rect**	WINCE_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags);
>+void		WINCE_UpdateRects(_THIS, int numrects, SDL_Rect *rects);
>+void		WINCE_PumpEvents(_THIS);
>+void		WINCE_WinPAINT(_THIS, HDC hdc);
>+int		WINCE_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors);
>+void		WINCE_Activate(_THIS, BOOL active, BOOL minimized);
>+void		WINCE_GenerateMouseMotionEvent(_THIS);
> 
>-/* etc. */
>-static void GAPI_UpdateRects(_THIS, int numrects, SDL_Rect *rects);
>+void		WINCE_UpdateMouse(_THIS);
> 
>-static HMODULE g_hGapiLib = 0;
>-#define LINK(type,name,import) \
>-	if( g_hGapiLib ) \
>-		name = (PFN##type)GetProcAddress( g_hGapiLib, _T(import) ); 
>+void		WINCE_ShowWindow(_THIS, int visible);
>+void		WINCE_PointerCoordinateTransform(_THIS, POINT* pt);
>+int		WinCE_GetLastStylusPos(POINT* pt);
>+void		WINCE_DumpVideoInfo(_THIS);
>+void		WINCE_PortraitTransform(_THIS, int width, int height);
>+void		WINCE_LandscapeTransform(_THIS, int width, int height);
>+void		WINCE_SquareTransform(_THIS, int width, int height);
>+int		WINCE_FixedGeometry(_THIS);
> 
>-static char g_bRawBufferAvailable = 0;
>+// unused
>+int		WINCE_AllocHWSurface(_THIS, SDL_Surface *surface);
>+int		WINCE_LockHWSurface(_THIS, SDL_Surface *surface);
>+void		WINCE_UnlockHWSurface(_THIS, SDL_Surface *surface);
>+void		WINCE_FreeHWSurface(_THIS, SDL_Surface *surface);
> 
>-/* GAPI driver bootstrap functions */
>+// gapi engine specific
>+int		GAPI_Init(_THIS);
>+void		GAPI_Quit(_THIS);
>+int		GAPI_PreferableDriver(void);
> 
>-/* hi res definitions */
>-typedef struct _RawFrameBufferInfo
>-{
>-   WORD wFormat;
>-   WORD wBPP;
>-   VOID *pFramePointer;
>-   int  cxStride;
>-   int  cyStride;
>-   int  cxPixels;
>-   int  cyPixels;
>-} RawFrameBufferInfo; 
>+// raw engine specific
>+int		RAW_Init(_THIS);
>+void		RAW_Quit(_THIS);
> 
>-static struct _RawFrameBufferInfo g_RawFrameBufferInfo = {0};
>+// tools
>+void		SetRGBMask(int bpp, Uint32 *r, Uint32 *g, Uint32 *b);
>+void		FrameBufferRotate(FrameBufferInfo* src, int orientation);
>+int		GetFrameBufferOrientation(const FrameBufferInfo* src);
>+void		PointerRotate(POINT* pt, const FrameBufferInfo* fb, int orientation);
>+void		FrameBufferInitialize(FrameBufferInfo* fb);
>+void		FrameBufferDumpInfo(const FrameBufferInfo* fb, const char*);
>+const		char* GetOrientationName(int orientation);
>+int		GetSystemOrientation(void);
>+int		UpdateLine8to8(const FrameBufferInfo* fb, const unsigned char* src, unsigned char* dst, int width, int height);
>+int		UpdateLine16to16(const FrameBufferInfo* fb, const Uint16* src, Uint16* dst, Uint16 width, Uint16 height);
> 
>-#define GETRAWFRAMEBUFFER   0x00020001
>+// stdlib
>+inline int	__abs(int x){ return x < 0 ? -x : x; };
>+inline void	__swap(int* a, int* b){ int t = *a; *a = *b; *b = t; };
> 
>-#define FORMAT_565 1
>-#define FORMAT_555 2
>-#define FORMAT_OTHER 3
>+int WINCE_Available(void)
>+{
>+    // raw check
>+    RawFrameBufferInfo rfbi = { 0 };
>+    HDC hdc = GetDC(NULL);
>+    int result = ExtEscape(hdc, GETRAWFRAMEBUFFER, 0, NULL, sizeof(RawFrameBufferInfo), (char *) &rfbi);
>+    ReleaseDC(NULL, hdc);
> 
>-/* Dell Axim x30 hangs when we use GAPI from landscape,
>-   so lets avoid using GxOpenDisplay there via GETGXINFO trick 
>-   It seems that GAPI subsystem use the same ExtEscape code.
>-*/
>-#define GETGXINFO 0x00020000
>+    if(result != 0 && !GAPI_PreferableDriver() &&
>+	rfbi.cxPixels != 0 && rfbi.cyPixels != 0 &&
>+	rfbi.pFramePointer != 0 && rfbi.cxStride != 0 && rfbi.cyStride != 0) return 1;
> 
>-typedef struct GXDeviceInfo
>-{
>-long Version; //00 (should filled with 100 before calling ExtEscape)
>-void * pvFrameBuffer; //04
>-unsigned long cbStride; //08
>-unsigned long cxWidth; //0c
>-unsigned long cyHeight; //10
>-unsigned long cBPP; //14
>-unsigned long ffFormat; //18
>-char Unused[0x84-7*4];
>-} GXDeviceInfo; 
>+    // gapi check
>+    HMODULE hgx = LoadLibrary(_T("\\Windows\\gx.dll"));
>+    if(0 == hgx)
>+    {
>+	hgx = LoadLibrary(_T("gx.dll"));
>+	if(0 == hgx) return 0;
>+    }
>+    FreeLibrary(hgx);
> 
>-static int GAPI_Available(void)
>+    return 1;
>+}
>+
>+SDL_VideoDevice *WINCE_CreateDevice(int devindex)
> {
>-	// try to use VGA display, even on emulator
>-	HDC hdc = GetDC(NULL); 
>-	int result = ExtEscape(hdc, GETRAWFRAMEBUFFER, 0, NULL, sizeof(RawFrameBufferInfo), (char *)&g_RawFrameBufferInfo);
>-	ReleaseDC(NULL, hdc);
>-	g_bRawBufferAvailable = result > 0;
>+    SDL_VideoDevice *device = (SDL_VideoDevice *) SDL_malloc(sizeof(SDL_VideoDevice));
> 
>-	//My Asus MyPAL 696 reports the RAWFRAMEBUFFER as available, but with a size of 0 x 0
>-	if(g_RawFrameBufferInfo.cxPixels <= 0 || g_RawFrameBufferInfo.cyPixels <= 0){
>-		g_bRawBufferAvailable = 0;
>-	}
>+    if(device == NULL)
>+    {
>+	SDL_OutOfMemory();
>+	return NULL;
>+    }
> 
>-#if WITHOUT_GAPI
>-	return g_bRawBufferAvailable;
>+    SDL_memset(device, 0, sizeof(SDL_VideoDevice));
>+    device->hidden = (struct SDL_PrivateVideoData *) SDL_malloc(sizeof(struct SDL_PrivateVideoData));
>+
>+    if(device->hidden == NULL)
>+    {
>+	SDL_OutOfMemory();
>+	WINCE_DeleteDevice(device);
>+        return NULL;
>+    }
>+
>+    SDL_memset(device->hidden, 0, sizeof(struct SDL_PrivateVideoData));
>+
>+    // set debug
>+    device->hidden->debug	= SDL_getenv("DEBUG_VIDEO") ? 1 : 0;
>+#if defined(DEBUG_VIDEO) || defined(DEBUG_VIDEO_GAPI)
>+    device->hidden->debug	= 1;
> #endif
> 
>-#if USE_GAPI_EMU
>-	g_hGapiLib = LoadLibrary(_T("GAPI_Emu.dll"));
>-	if( !g_hGapiLib )
>+    // Set the function pointers
>+    device->VideoInit		= WINCE_VideoInit;
>+    device->VideoQuit		= WINCE_VideoQuit;
>+    device->SetVideoMode	= WINCE_SetVideoMode;
>+    device->ListModes		= WINCE_ListModes;
>+    device->UpdateRects		= WINCE_UpdateRects;
>+    device->PumpEvents		= WINCE_PumpEvents;
>+    device->SetColors		= WINCE_SetColors;
>+
>+    device->CreateYUVOverlay	= NULL;
>+    device->FlipHWSurface	= NULL;
>+    device->CheckHWBlit		= NULL;
>+    device->FillHWRect		= NULL;
>+    device->SetHWColorKey	= NULL;
>+    device->SetHWAlpha		= NULL;
>+
>+    device->AllocHWSurface	= WINCE_AllocHWSurface;
>+    device->LockHWSurface	= WINCE_LockHWSurface;
>+    device->UnlockHWSurface	= WINCE_UnlockHWSurface;
>+    device->FreeHWSurface	= WINCE_FreeHWSurface;
>+
>+    device->UpdateMouse		= WINCE_UpdateMouse;
>+    // wincommon/SDL_syswm.c
>+    device->IconifyWindow	= WIN_IconifyWindow;
>+    device->GrabInput		= WIN_GrabInput;
>+    device->GetWMInfo		= WIN_GetWMInfo;
>+    device->InitOSKeymap	= DIB_InitOSKeymap;
>+    device->CheckMouseMode	= NULL;
>+    device->SetIcon		= NULL;
>+    device->FreeWMCursor	= NULL;
>+    device->CreateWMCursor	= NULL;
>+    device->ShowWMCursor	= NULL;
>+    device->WarpWMCursor	= NULL;
>+
>+    // Set up the windows message handling functions
>+    WIN_Activate		= WINCE_Activate;
>+    WIN_WinPAINT		= WINCE_WinPAINT;
>+    WIN_RealizePalette		= NULL;
>+    WIN_PaletteChanged		= NULL;
>+    HandleMessage		= DIB_HandleMessage; 
>+
>+    device->free		= WINCE_DeleteDevice;
>+
>+    // aygshell.dll
>+    device->hidden->hAygShell = LoadLibrary(_T("\\windows\\aygshell.dll"));
>+
>+    if(0 == device->hidden->hAygShell)
>+	device->hidden->hAygShell = LoadLibrary(_T("aygshell.dll"));
>+
>+    device->hidden->SHFullScreen = (0 != device->hidden->hAygShell ?
>+		(PFNSHFullScreen) GetProcAddress(device->hidden->hAygShell, _T("SHFullScreen")) : 0);
>+
>+    // initialize internal engine
>+    if((GAPI_PreferableDriver() && !GAPI_Init(device)) ||
>+       (!RAW_Init(device) && !GAPI_Init(device)))
>+    {
>+	SDL_SetError("WINCE_CreateDevice: raw framebuffer is not available or GAPI dll is not found");
>+	WINCE_DeleteDevice(device);
>+	return NULL;
>+    }
>+
>+    return device;
>+}
>+
>+void WINCE_DeleteDevice(_THIS)
>+{
>+    if(this)
>+    {
>+	if(g_Private)
> 	{
>-		SDL_SetError("Gapi Emu not found!");
>-	}
>-	return g_hGapiLib != 0;
>-#endif
>+	    GAPI_Quit(this);
>+	    RAW_Quit(this);
> 
>-	// try to find gx.dll
>-	g_hGapiLib = LoadLibrary(_T("\\Windows\\gx.dll"));
>-	if( !g_hGapiLib )
>-	{
>-		g_hGapiLib = LoadLibrary(_T("gx.dll"));
>-		if( !g_hGapiLib ) return g_bRawBufferAvailable;
>+	    if(g_Private->hAygShell) FreeLibrary(g_Private->hAygShell);
>+	    SDL_free(g_Private);
> 	}
>-
>-	return(1);
>+	SDL_free(g_Private);
>+    }
> }
> 
>-static int cmpmodes(const void *va, const void *vb)
>+int WINCE_VideoInit(_THIS, SDL_PixelFormat *vformat)
> {
>-    SDL_Rect *a = *(SDL_Rect **)va;
>-    SDL_Rect *b = *(SDL_Rect **)vb;
>-    if ( a->w == b->w )
>-        return b->h - a->h;
>+    // Create the window
>+    SDL_RegisterApp(NULL, 0, 0);
>+
>+    SDL_Window = CreateWindow(SDL_Appname, SDL_Appname, WS_VISIBLE,
>+			0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN), NULL, NULL, SDL_Instance, NULL);
>+
>+    if(SDL_Window == NULL)
>+    {
>+	SDL_SetError("WINCE_VideoInit: Couldn't create window");
>+	WINCE_VideoQuit(this);
>+
>+        return -1;
>+    }
>+
>+    if(NULL == g_Private->videoMem)
>+    {
>+	SDL_SetError("WINCE_VideoInit: videoMem is NULL");
>+	WINCE_VideoQuit(this);
>+
>+	return -1;
>+    }
>+
>+    // defaults
>+    g_Private->w = 0;
>+    g_Private->h = 0;
>+    g_Private->buffer = NULL;
>+
>+    g_Private->scale = 1;
>+
>+    g_Private->modes[0] = NULL;
>+    g_Private->modes[1] = NULL;
>+    g_Private->modes[2] = NULL;
>+
>+    // added modes
>+    g_Private->modeP.x = 0;
>+    g_Private->modeP.y = 0;
>+    g_Private->modeP.w = g_Private->fb.width;
>+    g_Private->modeP.h = g_Private->fb.height;
>+
>+    g_Private->modeL.x = 0;
>+    g_Private->modeL.y = 0;
>+    g_Private->modeL.w = g_Private->modeP.h;
>+    g_Private->modeL.h = g_Private->modeP.w;
>+
>+    g_Private->modes[0] = &g_Private->modeP;
>+    g_Private->modes[1] = &g_Private->modeL;
>+
>+    // determine the current screen size
>+    this->info.current_w = GetSystemMetrics(SM_CXSCREEN);
>+    this->info.current_h = GetSystemMetrics(SM_CYSCREEN);
>+
>+    // get oem info
>+    SDL_memset(g_Private->oemInfo, 0, sizeof(g_Private->oemInfo));
>+    SystemParametersInfo(SPI_GETOEMINFO, sizeof(g_Private->oemInfo) - sizeof(WCHAR), g_Private->oemInfo, 0);
>+
>+    // scale define
>+    {
>+	float maxW1 = GetSystemMetrics(SM_CXSCREEN) > GetSystemMetrics(SM_CYSCREEN) ? GetSystemMetrics(SM_CXSCREEN) : GetSystemMetrics(SM_CYSCREEN);
>+	float maxW2 = g_Private->fb.width > g_Private->fb.height ? g_Private->fb.width : g_Private->fb.height;
>+
>+	g_Private->scale = maxW2 / maxW1;
>+    }
>+
>+    // init fb values
>+    FrameBufferInitialize(&g_Private->fb);
>+
>+    // orientation values
>+    g_Private->userOrientation = ORIENTATION_UP;
>+    g_Private->systemOrientation = GetSystemOrientation();
>+    g_Private->hardwareGeometry = g_Private->fb.width == g_Private->fb.height ? GEOMETRY_SQUARE :
>+				(g_Private->fb.width < g_Private->fb.height ? GEOMETRY_PORTRAIT : GEOMETRY_LANDSCAPE);
>+
>+    // set color mask
>+    if(g_Private->fb.format & kfDirect565)
>+    {
>+	vformat->BitsPerPixel = 16;
>+	SetRGBMask(16, &vformat->Rmask, &vformat->Gmask, &vformat->Bmask);
>+    }
>     else
>-        return b->w - a->w;
>+    if(g_Private->fb.format & kfDirect555)
>+    {
>+	vformat->BitsPerPixel = 16;
>+	SetRGBMask(15, &vformat->Rmask, &vformat->Gmask, &vformat->Bmask);
>+    }
>+    else
>+    if(g_Private->fb.format & kfPalette)
>+    {
>+	vformat->BitsPerPixel = g_Private->fb.bpp;
>+    }
>+    else
>+    {
>+        SDL_SetError("WINCE_VideoInit: unknown format: 0x%x\n", g_Private->fb.format);
>+	WINCE_DumpVideoInfo(this);
>+	WINCE_VideoQuit(this);
>+
>+        return -1;
>+    }
>+
>+    if(g_Private->debug)
>+    {
>+	WINCE_DumpVideoInfo(this);
>+	printf("system orientation:      %d, %s\n", g_Private->systemOrientation, GetOrientationName(g_Private->systemOrientation));
>+	printf("hardware geometry:       %d\n", g_Private->hardwareGeometry);
>+    }
>+
>+    return 0;
> }
> 
>-static int GAPI_AddMode(_THIS, int bpp, int w, int h)
>+void WINCE_VideoQuit(_THIS)
> {
>-	SDL_Rect *mode;
>-	int i, index;
>-	int next_mode;
>+    if(SDL_Window)
>+    {
>+	WINCE_ShowWindow(this, 0);
>+	DestroyWindow(SDL_Window);
>+	SDL_UnregisterApp();
>+	SDL_Window = NULL;
>+    }
> 
>-	/* Check to see if we already have this mode */
>-	if ( bpp < 8 ) {  /* Not supported */
>-		return(0);
>-	}
>-	index = ((bpp+7)/8)-1;
>-	for ( i=0; i<gapi->SDL_nummodes[index]; ++i ) {
>-		mode = gapi->SDL_modelist[index][i];
>-		if ( (mode->w == w) && (mode->h == h) ) {
>-			return(0);
>-		}
>-	}
>+    if(g_Private->buffer != NULL)
>+    {
>+	if(g_Private->buffer == this->screen->pixels)
>+	    this->screen->pixels = NULL;
> 
>-	/* Set up the new video mode rectangle */
>-	mode = (SDL_Rect *)SDL_malloc(sizeof *mode);
>-	if ( mode == NULL ) {
>-		SDL_OutOfMemory();
>-		return(-1);
>-	}
>-	mode->x = 0;
>-	mode->y = 0;
>-	mode->w = w;
>-	mode->h = h;
>+	SDL_free(g_Private->buffer);
>+	g_Private->buffer = NULL;
>+    }
> 
>-	/* Allocate the new list of modes, and fill in the new mode */
>-	next_mode = gapi->SDL_nummodes[index];
>-	gapi->SDL_modelist[index] = (SDL_Rect **)
>-	       SDL_realloc(gapi->SDL_modelist[index], (1+next_mode+1)*sizeof(SDL_Rect *));
>-	if ( gapi->SDL_modelist[index] == NULL ) {
>-		SDL_OutOfMemory();
>-		gapi->SDL_nummodes[index] = 0;
>-		SDL_free(mode);
>-		return(-1);
>-	}
>-	gapi->SDL_modelist[index][next_mode] = mode;
>-	gapi->SDL_modelist[index][next_mode+1] = NULL;
>-	gapi->SDL_nummodes[index]++;
>+    if(g_GapiInfo)
>+	g_GapiInfo->GXCloseDisplay(); 
> 
>-	return(0);
>+    g_Private->videoMem = 0;
> }
> 
>-static void GAPI_DeleteDevice(SDL_VideoDevice *device)
>+void WINCE_DumpVideoInfo(_THIS)
> {
>-	if( g_hGapiLib )
>-	{
>-		FreeLibrary(g_hGapiLib);
>-		g_hGapiLib = 0;
>-	}
>-	SDL_free(device->hidden->gapiInfo);
>-	SDL_free(device->hidden);
>-	SDL_free(device);
>+    printf("hardware oem: ");
>+    wprintf(g_Private->oemInfo);
>+    printf("\n");
>+    printf("video driver mode:             %s\n", (g_Private->fb.flags & FB_RAW_MODE ? "raw" : "gapi"));
>+    printf("GetSystemMetrics(SM_CXSCREEN): %d\n", GetSystemMetrics(SM_CXSCREEN));
>+    printf("GetSystemMetrics(SM_CYSCREEN): %d\n", GetSystemMetrics(SM_CYSCREEN));
>+    printf("scale coord:                   %f\n", g_Private->scale);
>+
>+    FrameBufferDumpInfo(&g_Private->fb, "hardware");
>+
>+    printf("framebuffer memory:            %p\n", g_Private->videoMem);
>+    //POINT mouse;
>+    //printf("GetCursorPos:                  %s\n", (GetCursorPos(&mouse) ? "enable" : "disable"));
> }
> 
>-static SDL_VideoDevice *GAPI_CreateDevice(int devindex)
>+SDL_Rect **WINCE_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags)
> {
>-	SDL_VideoDevice *device;
>+    return format && format->BitsPerPixel == g_Private->fb.bpp ? g_Private->modes : (SDL_Rect **) 0;
>+}
> 
>-	if( !g_hGapiLib && !g_bRawBufferAvailable)
>-	{
>-		if( !GAPI_Available() )
>-		{
>-			SDL_SetError("GAPI dll is not found and VGA mode is not available!");
>-			return 0;
>-		}
>-	}
>+int WINCE_AllocHWSurface(_THIS, SDL_Surface *surface)
>+{
>+    return -1;
>+}
> 
>-	/* Initialize all variables that we clean on shutdown */
>-	device = (SDL_VideoDevice *)SDL_malloc(sizeof(SDL_VideoDevice));
>-	if ( device ) {
>-		SDL_memset(device, 0, (sizeof *device));
>-		device->hidden = (struct SDL_PrivateVideoData *)
>-				SDL_malloc((sizeof *device->hidden));
>-		if(device->hidden){
>-			SDL_memset(device->hidden, 0, (sizeof *device->hidden));
>-			device->hidden->gapiInfo = (GapiInfo *)SDL_malloc((sizeof(GapiInfo)));
>-			if(device->hidden->gapiInfo == NULL)
>-			{
>-				SDL_free(device->hidden);
>-				device->hidden = NULL;
>-			}
>-		}
>-	}
>-	if ( (device == NULL) || (device->hidden == NULL) ) {
>-		SDL_OutOfMemory();
>-		if ( device ) {
>-			SDL_free(device);
>-		}
>-		return(0);
>-	}
>-	SDL_memset(device->hidden->gapiInfo, 0, (sizeof *device->hidden->gapiInfo));
>+void WINCE_FreeHWSurface(_THIS, SDL_Surface *surface)
>+{
>+}
> 
>-	/* Set the function pointers */
>-	device->VideoInit = GAPI_VideoInit;
>-	device->ListModes = GAPI_ListModes;
>-	device->SetVideoMode = GAPI_SetVideoMode;
>-	device->UpdateMouse = WIN_UpdateMouse; 
>-	device->CreateYUVOverlay = NULL;
>-	device->SetColors = GAPI_SetColors;
>-	device->UpdateRects = GAPI_UpdateRects;
>-	device->VideoQuit = GAPI_VideoQuit;
>-	device->AllocHWSurface = GAPI_AllocHWSurface;
>-	device->CheckHWBlit = NULL;
>-	device->FillHWRect = NULL;
>-	device->SetHWColorKey = NULL;
>-	device->SetHWAlpha = NULL;
>-	device->LockHWSurface = GAPI_LockHWSurface;
>-	device->UnlockHWSurface = GAPI_UnlockHWSurface;
>-	device->FlipHWSurface = NULL;
>-	device->FreeHWSurface = GAPI_FreeHWSurface;
>-	device->SetCaption = WIN_SetWMCaption;
>-	device->SetIcon = WIN_SetWMIcon;
>-	device->IconifyWindow = WIN_IconifyWindow;
>-	device->GrabInput = WIN_GrabInput;
>-	device->GetWMInfo = WIN_GetWMInfo;
>-	device->FreeWMCursor = WIN_FreeWMCursor;
>-	device->CreateWMCursor = WIN_CreateWMCursor; 
>-	device->ShowWMCursor = WIN_ShowWMCursor;	
>-	device->WarpWMCursor = WIN_WarpWMCursor; 
>-    device->CheckMouseMode = WIN_CheckMouseMode;
>-	device->InitOSKeymap = DIB_InitOSKeymap;
>-	device->PumpEvents = DIB_PumpEvents;
>+int WINCE_LockHWSurface(_THIS, SDL_Surface *surface)
>+{
>+    return 0;
>+}
> 
>-	/* Set up the windows message handling functions */
>-	WIN_Activate = GAPI_Activate;
>-	WIN_RealizePalette = GAPI_RealizePalette;
>-	WIN_PaletteChanged = GAPI_PaletteChanged;
>-	WIN_WinPAINT = GAPI_WinPAINT;
>-	HandleMessage = DIB_HandleMessage; 
>+void WINCE_UnlockHWSurface(_THIS, SDL_Surface *surface)
>+{
>+}
> 
>-	device->free = GAPI_DeleteDevice;
>+void WINCE_WinPAINT(_THIS, HDC hdc)
>+{
>+    SDL_Rect allScreen = {0, 0, g_Private->w - 1, g_Private->h - 1};
>+    WINCE_UpdateRects(this, 1, &allScreen);
>+}
> 
>-	/* Load gapi library */
>-#define gx device->hidden->gapiInfo->gxFunc
>+void WINCE_PumpEvents(_THIS)
>+{
>+    MSG msg;
> 
>-    LINK( GXOpenDisplay, gx.GXOpenDisplay,         "?GXOpenDisplay@@YAHPAUHWND__@@K@Z" )
>-    LINK( GXCloseDisplay, gx.GXCloseDisplay,        "?GXCloseDisplay@@YAHXZ" )
>-    LINK( GXBeginDraw, gx.GXBeginDraw,           "?GXBeginDraw@@YAPAXXZ" )
>-    LINK( GXEndDraw, gx.GXEndDraw,             "?GXEndDraw@@YAHXZ" )
>-    LINK( GXOpenInput, gx.GXOpenInput,           "?GXOpenInput@@YAHXZ" )
>-    LINK( GXCloseInput, gx.GXCloseInput,          "?GXCloseInput@@YAHXZ" )
>-    LINK( GXGetDisplayProperties, gx.GXGetDisplayProperties,"?GXGetDisplayProperties@@YA?AUGXDisplayProperties@@XZ" )
>-    LINK( GXGetDefaultKeys, gx.GXGetDefaultKeys,      "?GXGetDefaultKeys@@YA?AUGXKeyList@@H@Z" )
>-    LINK( GXSuspend, gx.GXSuspend,             "?GXSuspend@@YAHXZ" )
>-    LINK( GXResume, gx.GXResume,              "?GXResume@@YAHXZ" )
>-    LINK( GXSetViewport, gx.GXSetViewport,         "?GXSetViewport@@YAHKKKK@Z" )
>-    LINK( GXIsDisplayDRAMBuffer, gx.GXIsDisplayDRAMBuffer, "?GXIsDisplayDRAMBuffer@@YAHXZ" )
>+    while(PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE))
>+    {
>+	if(GetMessage(&msg, NULL, 0, 0) > 0)
>+            DispatchMessage(&msg);
>+    }
> 
>-	/* wrong gapi.dll */
>-	if( !gx.GXOpenDisplay )
>+    if(SDL_GetAppState() & SDL_APPMOUSEFOCUS)
>+	WINCE_GenerateMouseMotionEvent(this);
>+}
>+
>+SDL_Surface *WINCE_SetVideoMode(_THIS, SDL_Surface *current,
>+				int width, int height, int bpp, Uint32 flags)
>+{
>+    SDL_Surface *video; 
>+
>+    // Recalculate bitmasks if necessary
>+    if(bpp == current->format->BitsPerPixel)
>+    {
>+	video = current;
>+    }
>+    else
>+    {
>+	Uint32 Rmask, Gmask, Bmask; 
>+
>+	switch(bpp)
> 	{
>-		if( g_hGapiLib ) 
>-		{
>-			FreeLibrary(g_hGapiLib);
>-			g_hGapiLib = 0;
>-		}
>+	    case 8:
>+		SetRGBMask(bpp, &Rmask, &Gmask, &Bmask);
>+		break;
>+
>+	    case 24:
>+	    case 32:
>+		SetRGBMask(32, &Rmask, &Gmask, &Bmask);
>+		break;
>+
>+	    case 15:				
>+	    case 16:
>+		// Default is 565 unless the display is specifically 555
>+		SetRGBMask((g_Private->fb.format & kfDirect555 ? 15 : 16), &Rmask, &Gmask, &Bmask);
>+		break;
>+
>+	    default:
>+		SDL_SetError("WINCE_SetVideoMode: unsupported BitsPerPixel format requested");
>+		return NULL;
> 	}
>-	
>-	if( !gx.GXOpenDisplay && !g_bRawBufferAvailable)
>+
>+	video = SDL_CreateRGBSurface(SDL_SWSURFACE, 0, 0, bpp, Rmask, Gmask, Bmask, 0);
>+
>+	if(video == NULL)
> 	{
>-		SDL_SetError("Error: damaged or unknown gapi.dll!\n");
>-		GAPI_DeleteDevice(device);
>-		return 0;
>+	    SDL_OutOfMemory();
>+	    return NULL;
> 	}
>+    }
> 
>-	return device;
>+    g_Private->userOrientation = ORIENTATION_UP;
>+
>+    switch(g_Private->hardwareGeometry)
>+    {
>+	case GEOMETRY_PORTRAIT:  WINCE_PortraitTransform(this, width, height); break;
>+	case GEOMETRY_LANDSCAPE: WINCE_LandscapeTransform(this, width, height); break;
>+	case GEOMETRY_SQUARE:    WINCE_SquareTransform(this, width, height); break;
>+	default: break;
>+    }
>+
>+    video->w = g_Private->w = width;
>+    video->h = g_Private->h = height;
>+    video->pitch = SDL_CalculatePitch(video);
>+    video->flags = SDL_FULLSCREEN;
>+
>+    // allocate bitmap buffer
>+    if(g_Private->buffer)
>+    {
>+	SDL_free(g_Private->buffer);
>+	g_Private->buffer = NULL;
>+    }
>+
>+    g_Private->buffer = SDL_malloc(video->h * video->pitch);
>+    video->pixels = g_Private->buffer;
>+
>+    if(NULL == g_Private->buffer)
>+    {
>+	SDL_OutOfMemory();
>+	return NULL;
>+    }
>+
>+    SDL_memset(g_Private->buffer, 255, video->h * video->pitch);
>+
>+    if(g_Private->debug)
>+    {
>+	printf("\n");
>+	printf("user video width:          %d\n", width);
>+	printf("user video height:         %d\n", height);
>+	FrameBufferDumpInfo(&g_Private->fb, "user");
>+    }
>+
>+    WINCE_ShowWindow(this, 1);
>+
>+    return video;
> }
> 
>-VideoBootStrap GAPI_bootstrap = {
>-	GAPIVID_DRIVER_NAME, "WinCE GAPI video driver",
>-	GAPI_Available, GAPI_CreateDevice
>-};
>+/* reality, this function is not necessary. WINCE does not use mouse.
>+   but if it is disabled, you will receive crash, inside SDL_GetMapRGB(format->palette is undefined) */
>+void WINCE_UpdateMouse(_THIS)
>+{
>+    // return;
> 
>-static void FillStructs(_THIS, BOOL useVga)
>+    POINT pt;
>+
>+    /* Always unset SDL_APPMOUSEFOCUS to give the WM_MOUSEMOVE event
>+     * handler a chance to install a TRACKMOUSEEVENT */
>+    SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS);
>+
>+    GetCursorPos(&pt);
>+    ScreenToClient(SDL_Window, &pt);
>+    SDL_PrivateMouseMotion(0, 1, (Sint16)pt.x, (Sint16)pt.y);
>+}
>+
>+void WINCE_Activate(_THIS, BOOL active, BOOL minimized)
> {
>-#ifdef _ARM_
>-	WCHAR oemstr[100];
>-#endif
>-	/* fill a device properties */
>+    if(minimized || !active)
>+	WINCE_ShowWindow(this, 0);
>+    else
>+	WINCE_ShowWindow(this, 1);
>+}
> 
>-	if( !useVga )
>-	{
>-		gapi->gxProperties = gapi->gxFunc.GXGetDisplayProperties();
>-		gapi->needUpdate = 1;
>-		gapi->hiresFix = 0;
>-		gapi->useVga = 0;
>-		gapi->useGXOpenDisplay = 1;
>+void WINCE_ShowWindow(_THIS, int visible)
>+{
>+    if(visible)
>+    {
>+	ShowWindow(FindWindow(TEXT("HHTaskBar"), NULL), SW_HIDE);
> 
>-#ifdef _ARM_
>-		/* check some devices and extract addition info */
>-		SystemParametersInfo( SPI_GETOEMINFO, sizeof( oemstr ), oemstr, 0 );
>+	if(g_Private->SHFullScreen)
>+	    g_Private->SHFullScreen(SDL_Window, SHFS_HIDETASKBAR | SHFS_HIDESTARTICON | SHFS_HIDESIPBUTTON);
> 
>-		// buggy iPaq38xx
>-		if ((oemstr[12] == 'H') && (oemstr[13] == '3') && (oemstr[14] == '8') && (gapi->gxProperties.cbxPitch > 0)) 
>-		{
>-			gapi->videoMem = (PIXEL*)0xac0755a0;
>-			gapi->gxProperties.cbxPitch = -640;
>-			gapi->gxProperties.cbyPitch = 2;
>-			gapi->needUpdate = 0;
>-		}
>-#if (EMULATE_AXIM_X30 == 0)
>-		// buggy Dell Axim X30
>-		if( _tcsncmp(oemstr, L"Dell Axim X30", 13) == 0 )
>-#endif
>-		{
>-			GXDeviceInfo gxInfo = {0};
>-			HDC hdc = GetDC(NULL);
>-			int result;
>+	g_Private->fb.flags &= ~FB_SUSPENDED;
> 
>-			gxInfo.Version = 100;
>-			result = ExtEscape(hdc, GETGXINFO, 0, NULL, sizeof(gxInfo), (char *)&gxInfo);
>-			if( result > 0 )
>-			{
>-				gapi->useGXOpenDisplay = 0;
>-				gapi->videoMem = gxInfo.pvFrameBuffer;
>-				gapi->needUpdate = 0;
>-				gapi->gxProperties.cbxPitch = 2;
>-				gapi->gxProperties.cbyPitch = 480;
>-				gapi->gxProperties.cxWidth = gxInfo.cxWidth;
>-				gapi->gxProperties.cyHeight = gxInfo.cyHeight;
>-				gapi->gxProperties.ffFormat = gxInfo.ffFormat;
>-			}
>-		}
>-#endif
>-	} else
>+	if(g_GapiInfo)
>+	    g_GapiInfo->GXResume();
>+
>+	ShowWindow(SDL_Window, SW_SHOW);
>+    }
>+    else
>+    {
>+	ShowWindow(SDL_Window, SW_HIDE);
>+
>+	if(g_GapiInfo)
>+	    g_GapiInfo->GXSuspend();
>+
>+	g_Private->fb.flags |= FB_SUSPENDED;
>+
>+	if(g_Private->SHFullScreen)
>+	    g_Private->SHFullScreen(SDL_Window, SHFS_SHOWTASKBAR | SHFS_SHOWSTARTICON | SHFS_SHOWSIPBUTTON);
>+
>+	ShowWindow(FindWindow(TEXT("HHTaskBar"), NULL), SW_SHOW);
>+    }
>+}
>+
>+int WinCE_GetLastStylusPos(POINT* pt)
>+{
>+    UINT ret;
>+    GetMouseMovePoints(pt, 1, &ret);
>+
>+    if(ret == 1)
>+    {
>+	pt->x /= 4;
>+	pt->y /= 4;
>+	return 1;
>+    }
>+    return 0;
>+}
>+
>+void WINCE_GenerateMouseMotionEvent(_THIS)
>+{
>+    extern int posted;
>+    POINT pt;
>+
>+    if(GetCursorPos(&pt) || WinCE_GetLastStylusPos(&pt))
>+    {
>+	WINCE_PointerCoordinateTransform(this, &pt);
>+        posted = SDL_PrivateMouseMotion(0, 0, pt.x, pt.y);
>+    }
>+}
>+
>+void WINCE_UpdateRects(_THIS, int numrects, SDL_Rect *rects)
>+{
>+    // skip
>+    if(g_Private->fb.flags & FB_SUSPENDED) return;
>+
>+    // lock gapi
>+    if(g_GapiInfo) g_GapiInfo->GXBeginDraw(); 
>+
>+    int ii, height, lines;
>+
>+    for (ii = 0; ii < numrects; ii++)
>+    {
>+	if(! rects[ii].w || ! rects[ii].h) continue;
>+
>+        unsigned char *dst = g_Private->videoMem + (g_Private->fb.flags & FB_SKIP_OFFSET ? 0 : g_Private->fb.offset) +
>+					rects[ii].y * g_Private->fb.ypitch +
>+					rects[ii].x * g_Private->fb.xpitch;
>+
>+	const unsigned char *src = ((const unsigned char*) SDL_VideoSurface->pixels) +
>+					rects[ii].y * SDL_VideoSurface->pitch +
>+					rects[ii].x * (g_Private->fb.bpp >> 3);
>+
>+	height = rects[ii].h;
>+
>+	while(height)
> 	{
>-		gapi->needUpdate = 0;		
>-		gapi->hiresFix = 0;
>-		gapi->gxProperties.cBPP = g_RawFrameBufferInfo.wBPP;
>-		gapi->gxProperties.cbxPitch = g_RawFrameBufferInfo.cxStride;
>-		gapi->gxProperties.cbyPitch = g_RawFrameBufferInfo.cyStride;
>-		gapi->gxProperties.cxWidth = g_RawFrameBufferInfo.cxPixels;
>-		gapi->gxProperties.cyHeight = g_RawFrameBufferInfo.cyPixels;
>-		gapi->videoMem = g_RawFrameBufferInfo.pFramePointer;
>-		gapi->useVga = 1;
>+	    switch(g_Private->fb.bpp)
>+	    {
>+		case 8:
>+		    lines = UpdateLine8to8(&g_Private->fb, src, dst, rects[ii].w, height);
>+		    break;
> 
>-		switch( g_RawFrameBufferInfo.wFormat )
>-		{
>-		case FORMAT_565:
>-			gapi->gxProperties.ffFormat = kfDirect565;
>-			break;
>-		case FORMAT_555:
>-			gapi->gxProperties.ffFormat = kfDirect555;
>-			break;
>+		case 16:
>+		    lines = UpdateLine16to16(&g_Private->fb, (Uint16*) src, (Uint16*) dst, rects[ii].w, height);
>+		    break;
>+
>+
> 		default:
>-			/* unknown pixel format, try define by BPP! */
>-			switch( g_RawFrameBufferInfo.wBPP )
>-			{
>-			case 4:
>-			case 8:
>-				gapi->gxProperties.ffFormat = kfDirect;
>-			case 16:
>-				gapi->gxProperties.ffFormat = kfDirect565;
>-			default:
>-				gapi->gxProperties.ffFormat = kfDirect;
>-				break;
>-			}
>-		}
>+		    // unsupported colors
>+		    break;
>+	    }
>+
>+	    height -= lines;
>+	    dst += g_Private->fb.ypitch * lines;
>+	    src += SDL_VideoSurface->pitch * lines;
> 	}
>+    }
> 
>-	if( gapi->gxProperties.cBPP != 16 )
>-	{
>-		gapi->gapiOrientation = SDL_ORIENTATION_UP;
>-	} else
>-	if( (gapi->gxProperties.cbxPitch > 0) && (gapi->gxProperties.cbyPitch > 0 ))
>-	{
>-		gapi->gapiOrientation = SDL_ORIENTATION_UP;
>-	} else
>-	if( (gapi->gxProperties.cbxPitch > 0) && (gapi->gxProperties.cbyPitch < 0 ))
>-	{
>-		gapi->gapiOrientation = SDL_ORIENTATION_RIGHT; // ipaq 3660
>-	} else
>-	if( (gapi->gxProperties.cbxPitch < 0) && (gapi->gxProperties.cbyPitch > 0 ))
>-	{
>-		gapi->gapiOrientation = SDL_ORIENTATION_LEFT; // ipaq 3800
>-	}
>+    // unlock gapi
>+    if(g_GapiInfo) g_GapiInfo->GXEndDraw();
> }
> 
>-static void GAPI_CreatePalette(int ncolors, SDL_Color *colors)
>+/* original variant.
>+   for devices with 16bit is not used.
>+   as other modes are not realised. probably, it also is not necessary ;) */
>+int WINCE_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
> {
>   // Setup a custom color palette
>-   BYTE buffer[ sizeof(LOGPALETTE) + 255 * sizeof(PALETTEENTRY) ];
>+   BYTE buffer[sizeof(LOGPALETTE) + 255 * sizeof(PALETTEENTRY)];
>    int i;
>    LOGPALETTE*   pLogical = (LOGPALETTE*)buffer;
>    PALETTEENTRY* entries  = pLogical->palPalEntry;
>-   HPALETTE hPalette;
>-   HDC hdc;
> 
>    for (i = 0; i < ncolors; ++i)
>    {
>@@ -508,780 +781,584 @@
>    pLogical->palVersion    = 0x0300;
>    pLogical->palNumEntries = ncolors;
> 
>-   hPalette = CreatePalette( pLogical );
>-   ASSERT(hPalette);
>-	
>+   HPALETTE hPalette = CreatePalette(pLogical);
>+   
>+   if(!hPalette) return 0;
> 
>    // Realize the palette
>-   hdc = GetDC(0);
>+   HDC hdc = GetDC(0);
> 
>-   SelectPalette( hdc, hPalette, FALSE );
>-   RealizePalette( hdc );
>+   SelectPalette(hdc, hPalette, FALSE);
>+   RealizePalette(hdc);
> 
>-   ReleaseDC( 0, hdc );
>-   DeleteObject( hPalette );
>+   ReleaseDC(0, hdc);
>+   DeleteObject(hPalette);
>+
>+   return 1;
> }
> 
>-int GAPI_VideoInit(_THIS, SDL_PixelFormat *vformat)
>+void WINCE_PointerCoordinateTransform(_THIS, POINT* pt)
> {
>-	int i,bpp;
>+    pt->x *= g_Private->scale;
>+    pt->y *= g_Private->scale;
> 
>-	/* Create the window */
>-	if ( DIB_CreateWindow(this) < 0 ) {
>-		return(-1);
>-	}
>+    PointerRotate(pt, &g_Private->fb, g_Private->userOrientation);
>+}
> 
>-	if( g_hGapiLib )
>-	{
>-		FillStructs(this, 0);
>+void WINCE_PortraitTransform(_THIS, int width, int height)
>+{
>+    if(g_Private->systemOrientation != ORIENTATION_UP)
>+	FrameBufferRotate(&g_Private->fb, g_Private->systemOrientation);
> 
>-		// SDL does not supports 2/4bpp mode, so use 16 bpp
>-		bpp = gapi->gxProperties.cBPP < 8 ? 16 : gapi->gxProperties.cBPP;
>-		
>-		/* set up normal and landscape mode */
>-		GAPI_AddMode(this, bpp, gapi->gxProperties.cyHeight, gapi->gxProperties.cxWidth);	
>-		GAPI_AddMode(this, bpp, gapi->gxProperties.cxWidth, gapi->gxProperties.cyHeight);	
>-	}
>+    if(g_Private->fb.width != width || g_Private->fb.height != height)
>+    switch(g_Private->systemOrientation)
>+    {
>+	case ORIENTATION_UP:
>+	case ORIENTATION_LEFT: g_Private->userOrientation = ORIENTATION_RIGHT; break;
>+	case ORIENTATION_RIGHT:
>+	case ORIENTATION_DOWN: g_Private->userOrientation = ORIENTATION_LEFT; break;
>+	default: break;
>+    }
> 
>-	/* add hi-res mode */
>-	if( g_bRawBufferAvailable && 
>-		!((gapi->gxProperties.cxWidth == (unsigned)g_RawFrameBufferInfo.cxPixels) && (gapi->gxProperties.cyHeight == (unsigned)g_RawFrameBufferInfo.cyPixels)))
>-	{
>-		FillStructs(this, 1);
>+    if(g_Private->userOrientation != ORIENTATION_UP)
>+	FrameBufferRotate(&g_Private->fb, g_Private->userOrientation);
>+}
> 
>-		// SDL does not supports 2/4bpp mode, so use 16 bpp
>-		bpp = gapi->gxProperties.cBPP < 8 ? 16 : gapi->gxProperties.cBPP;
>+void WINCE_LandscapeTransform(_THIS, int width, int height)
>+{
>+    switch(g_Private->systemOrientation)
>+    {
>+	case ORIENTATION_UP:  FrameBufferRotate(&g_Private->fb, ORIENTATION_LEFT); break;
>+	case ORIENTATION_LEFT:FrameBufferRotate(&g_Private->fb, ORIENTATION_DOWN); break;
>+	case ORIENTATION_DOWN:FrameBufferRotate(&g_Private->fb, ORIENTATION_RIGHT); break;
>+	default: break;
>+    }
> 
>-		/* set up normal and landscape mode */
>-		GAPI_AddMode(this, bpp, gapi->gxProperties.cyHeight, gapi->gxProperties.cxWidth);	
>-		GAPI_AddMode(this, bpp, gapi->gxProperties.cxWidth, gapi->gxProperties.cyHeight);	
>-	}
>+    if(g_Private->fb.width != width || g_Private->fb.height != height)
>+    switch(g_Private->systemOrientation)
>+    {
>+	case ORIENTATION_UP:
>+	case ORIENTATION_LEFT: g_Private->userOrientation = ORIENTATION_RIGHT; break;
>+	case ORIENTATION_RIGHT:
>+	case ORIENTATION_DOWN: g_Private->userOrientation = ORIENTATION_LEFT; break;
>+	default: break;
>+    }
> 
>-	/* Determine the current screen size.
>-	 * This is NOT necessarily the size of the Framebuffer or GAPI, as they return
>-	 * the displaysize in ORIENTATION_UP */
>-	this->info.current_w = GetSystemMetrics(SM_CXSCREEN);
>-	this->info.current_h = GetSystemMetrics(SM_CYSCREEN);
>+    if(g_Private->userOrientation != ORIENTATION_UP)
>+	FrameBufferRotate(&g_Private->fb, g_Private->userOrientation);
>+}
> 
>-	/* Sort the mode lists */
>-	for ( i=0; i<NUM_MODELISTS; ++i ) {
>-		if ( gapi->SDL_nummodes[i] > 0 ) {
>-			SDL_qsort(gapi->SDL_modelist[i], gapi->SDL_nummodes[i], sizeof *gapi->SDL_modelist[i], cmpmodes);
>-		}
>-	}
>+void WINCE_SquareTransform(_THIS, int width, int height)
>+{
>+    WINCE_PortraitTransform(this, width, height);
>+}
> 
>-	vformat->BitsPerPixel = gapi->gxProperties.cBPP < 8 ? 16 : (unsigned char)gapi->gxProperties.cBPP;
>+int WINCE_FixedGeometry(_THIS)
>+{
>+    // byte per pixel
>+    int bpp = g_Private->fb.bpp / 8;
> 
>-	// Get color mask
>-	if (gapi->gxProperties.ffFormat & kfDirect565) {
>-		vformat->BitsPerPixel = 16;
>-		vformat->Rmask = 0x0000f800;
>-		vformat->Gmask = 0x000007e0;
>-		vformat->Bmask = 0x0000001f;
>-		gapi->videoMode = GAPI_DIRECT_565;
>-	}
>+    // check square
>+    if(GetSystemMetrics(SM_CXSCREEN) == GetSystemMetrics(SM_CYSCREEN) &&
>+	g_Private->fb.width != g_Private->fb.height)
>+    {
>+	if(g_Private->fb.width < g_Private->fb.height)
>+	    g_Private->fb.height = g_Private->fb.width;
> 	else
>-	if (gapi->gxProperties.ffFormat & kfDirect555) {
>-		vformat->BitsPerPixel = 16;
>-		vformat->Rmask = 0x00007c00;
>-		vformat->Gmask = 0x000003e0;
>-		vformat->Bmask = 0x0000001f;
>-		gapi->videoMode = GAPI_DIRECT_555;
>+	if(g_Private->fb.height < g_Private->fb.width)
>+	    g_Private->fb.width = g_Private->fb.height;
>+    }
>+
>+    // check width
>+    if(__abs(g_Private->fb.xpitch) == bpp &&
>+	g_Private->fb.width  != __abs(g_Private->fb.ypitch) / bpp)
>+    {
>+	if(g_Private->fb.height == __abs(g_Private->fb.ypitch) / bpp)
>+    	{
>+	    __swap(&g_Private->fb.width, &g_Private->fb.height);
>+
>+	    if(g_Private->debug)
>+		printf("WINCE_FixedGeometry: width: %d, height: %d\n", g_Private->fb.width, g_Private->fb.height);
> 	}
> 	else
>-	if ((gapi->gxProperties.ffFormat & kfDirect) && (gapi->gxProperties.cBPP < 8)) {
>-		// We'll perform the conversion
>-		vformat->BitsPerPixel = 16;
>-		vformat->Rmask = 0x0000f800; // 16 bit 565
>-		vformat->Gmask = 0x000007e0;
>-		vformat->Bmask = 0x0000001f;
>-		if (gapi->gxProperties.ffFormat & kfDirectInverted)
>-			gapi->invert = (1 << gapi->gxProperties.cBPP) - 1;
>-		gapi->colorscale = gapi->gxProperties.cBPP < 8 ? 8 - gapi->gxProperties.cBPP : 0;
>-		gapi->videoMode = GAPI_MONO;
>+	    return -1;
>+    }
>+    else
>+    // check height
>+    if(__abs(g_Private->fb.ypitch) == bpp &&
>+	g_Private->fb.height != __abs(g_Private->fb.xpitch) / bpp)
>+    {
>+	if(g_Private->fb.width  == __abs(g_Private->fb.xpitch) / bpp)
>+    	{
>+	    __swap(&g_Private->fb.width, &g_Private->fb.height);
>+
>+	    if(g_Private->debug)
>+		printf("WINCE_FixedGeometry: width: %d, height: %d\n", g_Private->fb.width, g_Private->fb.height);
> 	}
> 	else
>-	if (gapi->gxProperties.ffFormat & kfPalette) {
>-		gapi->videoMode = GAPI_PALETTE;
>-	} 
>+	    return -1;
>+    }
> 
>-	/* We're done! */
>-	return(0);
>+    return 0;
> }
> 
>-SDL_Rect **GAPI_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags)
>-{
>-	return(gapi->SDL_modelist[((format->BitsPerPixel+7)/8)-1]);
>-//  	 return (SDL_Rect **) -1;
>-}
> 
>-SDL_Surface *GAPI_SetVideoMode(_THIS, SDL_Surface *current,
>-				int width, int height, int bpp, Uint32 flags)
>+int GAPI_Init(_THIS)
> {
>-	SDL_Surface *video; 
>-	Uint32 Rmask, Gmask, Bmask; 
>-	DWORD style; 
>-	SDL_Rect allScreen;
>+    if(NULL == g_GapiInfo)
>+    {
>+        g_GapiInfo = (GapiInfo *) SDL_malloc(sizeof(GapiInfo));
> 
>-	if( bpp < 4 )
>-	{
>-		SDL_SetError("1 bpp and 2 bpp modes is not implemented yet!");
>-		return 0;
>-	}
>+        if(NULL == g_GapiInfo)
>+        {
>+            SDL_OutOfMemory();
>+            return 0;
>+        }
> 
>-	/* Recalculate bitmasks if necessary */
>-	if (bpp == current->format->BitsPerPixel) {
>-		video = current;
>-	}
>-	else {
>-		switch(bpp) {
>-			case 8:
>-				Rmask = 0;
>-				Gmask = 0;
>-				Bmask = 0;
>-				break;
>-			case 15:				
>-			case 16:
>-				/* Default is 565 unless the display is specifically 555 */
>-				if (gapi->gxProperties.ffFormat & kfDirect555) {
>-					Rmask = 0x00007c00;
>-					Gmask = 0x000003e0;
>-					Bmask = 0x0000001f;
>-				}
>-				else {
>-					Rmask = 0x0000f800;
>-					Gmask = 0x000007e0;
>-					Bmask = 0x0000001f;
>-				}
>-				break;
>-			case 24:
>-			case 32:
>-				Rmask = 0x00ff0000;
>-				Gmask = 0x0000ff00;
>-				Bmask = 0x000000ff;
>-				break;
>-			default:
>-				SDL_SetError("Unsupported Bits Per Pixel format requested");
>-				return NULL;
>-		}
>-		video = SDL_CreateRGBSurface(SDL_SWSURFACE,
>-					0, 0, bpp, Rmask, Gmask, Bmask, 0);
>-		if ( video == NULL ) {
>-			SDL_OutOfMemory();
>-			return(NULL);
>-		}
>-	}
>+        SDL_memset(g_Private->gapi, 0, sizeof(GapiInfo));
> 
>-	gapi->userOrientation = SDL_ORIENTATION_UP;
>-	gapi->systemOrientation = SDL_ORIENTATION_UP;
>-	video->flags = SDL_FULLSCREEN;	/* Clear flags, GAPI supports fullscreen only */
>-
>-	/* GAPI or VGA? */
>-	if( g_hGapiLib )
>+	g_GapiInfo->hGapiLib = LoadLibrary(_T("\\Windows\\gx.dll"));
>+	if(0 == g_GapiInfo->hGapiLib)
> 	{
>-		FillStructs(this, 0);
>-		if( (((unsigned)width != gapi->gxProperties.cxWidth) || ((unsigned)height != gapi->gxProperties.cyHeight))
>-			&& (((unsigned)width != gapi->gxProperties.cyHeight) || ((unsigned)height != gapi->gxProperties.cxWidth)))
>-			FillStructs(this, 1); // gapi is found but we use VGA resolution			
>-	} else
>-		FillStructs(this, 1);
>-
>-	if ( !gapi->needUpdate && !gapi->videoMem) {
>-		SDL_SetError("Couldn't get address of video memory, may be unsupported device or bug");
>-		return(NULL);
>+	    g_GapiInfo->hGapiLib = LoadLibrary(_T("gx.dll"));
>+	    if(0 == g_GapiInfo->hGapiLib) return 0;
> 	}
> 
>-	/* detect user landscape mode */
>-       if( (width > height) && (gapi->gxProperties.cxWidth < gapi->gxProperties.cyHeight))
>-		gapi->userOrientation = SDL_ORIENTATION_RIGHT;
>+	// load gapi library
>+#define LINK(type,name,import) name=(PFN##type)GetProcAddress(g_GapiInfo->hGapiLib,_T(import))
> 
>-       if(GetSystemMetrics(SM_CYSCREEN) < GetSystemMetrics(SM_CXSCREEN))
>-		gapi->systemOrientation = SDL_ORIENTATION_RIGHT;
>+	LINK(GXOpenDisplay,         g_GapiInfo->GXOpenDisplay,         "?GXOpenDisplay@@YAHPAUHWND__@@K@Z");
>+	LINK(GXCloseDisplay,        g_GapiInfo->GXCloseDisplay,        "?GXCloseDisplay@@YAHXZ");
>+	LINK(GXBeginDraw,           g_GapiInfo->GXBeginDraw,           "?GXBeginDraw@@YAPAXXZ");
>+	LINK(GXEndDraw,             g_GapiInfo->GXEndDraw,             "?GXEndDraw@@YAHXZ");
>+	LINK(GXOpenInput,           g_GapiInfo->GXOpenInput,           "?GXOpenInput@@YAHXZ");
>+	LINK(GXCloseInput,          g_GapiInfo->GXCloseInput,          "?GXCloseInput@@YAHXZ");
>+	LINK(GXGetDisplayProperties,g_GapiInfo->GXGetDisplayProperties,"?GXGetDisplayProperties@@YA?AUGXDisplayProperties@@XZ");
>+	LINK(GXGetDefaultKeys,      g_GapiInfo->GXGetDefaultKeys,      "?GXGetDefaultKeys@@YA?AUGXKeyList@@H@Z");
>+	LINK(GXSuspend,             g_GapiInfo->GXSuspend,             "?GXSuspend@@YAHXZ");
>+	LINK(GXResume,              g_GapiInfo->GXResume,              "?GXResume@@YAHXZ");
>+	LINK(GXSetViewport,         g_GapiInfo->GXSetViewport,         "?GXSetViewport@@YAHKKKK@Z");
>+	LINK(GXIsDisplayDRAMBuffer, g_GapiInfo->GXIsDisplayDRAMBuffer, "?GXIsDisplayDRAMBuffer@@YAHXZ");
> 
>-	gapi->hiresFix = 0;
>+	int enable = g_GapiInfo->GXGetDisplayProperties && g_GapiInfo->GXCloseDisplay && g_GapiInfo->GXOpenDisplay &&
>+	    g_GapiInfo->GXOpenInput && g_GapiInfo->GXCloseInput && g_GapiInfo->GXGetDefaultKeys && g_GapiInfo->GXSetViewport &&
>+	    g_GapiInfo->GXIsDisplayDRAMBuffer && g_GapiInfo->GXBeginDraw && g_GapiInfo->GXEndDraw && g_GapiInfo->GXSuspend && g_GapiInfo->GXResume;
> 
>-	/* check hires */
>-	if(GetSystemMetrics(SM_CXSCREEN) < width && GetSystemMetrics(SM_CYSCREEN) < height)
>+	if(!enable)
> 	{
>-	    gapi->hiresFix = 1;
>+	    SDL_SetError("GAPI_Init: error gx.dll: internal error");
>+	    GAPI_Quit(this);
>+
>+	    return 0;
> 	}
> 
>-	switch( gapi->userOrientation )
>+	if(0 == g_GapiInfo->GXOpenDisplay(SDL_Window, GX_FULLSCREEN))
> 	{
>-	case SDL_ORIENTATION_UP:
>-		gapi->startOffset = 0;
>-		gapi->dstLineStep = gapi->gxProperties.cbyPitch;
>-		gapi->dstPixelStep = gapi->gxProperties.cbxPitch;
>-		break;
>-	case SDL_ORIENTATION_RIGHT:
>-		switch( gapi->gapiOrientation )
>-		{
>-		case SDL_ORIENTATION_UP:
>-		case SDL_ORIENTATION_RIGHT:
>-		case SDL_ORIENTATION_LEFT:
>-			if( (gapi->videoMode == GAPI_MONO) )
>-				gapi->startOffset = -gapi->gxProperties.cbxPitch + 1; // monochrome mode
>-			else
>-				gapi->startOffset = gapi->gxProperties.cbyPitch * (gapi->gxProperties.cyHeight - 1);
>-				
>-			gapi->dstLineStep = gapi->gxProperties.cbxPitch;
>-			gapi->dstPixelStep = -gapi->gxProperties.cbyPitch;
>-			break;
>-		}
>+	    SDL_SetError("GAPI_VideoInit: couldn't initialize GAPI");
>+	    GAPI_Quit(this);
>+
>+	    return 0;
> 	}
> 
>-	video->w = gapi->w = width;
>-	video->h = gapi->h = height;
>-	video->pitch = SDL_CalculatePitch(video); 
>+	struct GXDisplayProperties gxProperties = g_GapiInfo->GXGetDisplayProperties();
> 
>-	/* Small fix for WinCE/Win32 - when activating window
>-	   SDL_VideoSurface is equal to zero, so activating code
>-	   is not called properly for fullscreen windows because
>-	   macros WINDIB_FULLSCREEN uses SDL_VideoSurface
>-	*/
>-	SDL_VideoSurface = video;
>+	// fill FrameBufferInfo
>+	SDL_memset(&g_Private->fb, 0, sizeof(FrameBufferInfo));
> 
>-	/* GAPI is always fullscreen, title bar is useless */
>-	style = 0;
>+	g_Private->fb.xpitch = gxProperties.cbxPitch;
>+	g_Private->fb.ypitch = gxProperties.cbyPitch;
>+	g_Private->fb.width  =  gxProperties.cxWidth;
>+	g_Private->fb.height = gxProperties.cyHeight;
>+	g_Private->fb.offset = 0;
>+	g_Private->fb.bpp    = gxProperties.cBPP;
>+	g_Private->fb.flags  = 0;
>+	g_Private->fb.format = gxProperties.ffFormat;
> 
>-	if (!SDL_windowid)
>-		SetWindowLong(SDL_Window, GWL_STYLE, style);
>+	// get videoMem
>+	GXDeviceInfo gxInfo = { 0 };
>+	HDC hdc = GetDC(NULL);
> 
>-	/* Allocate bitmap */
>-	if( gapi->buffer ) 
>+	gxInfo.Version = 100;
>+	int result = ExtEscape(hdc, GETGXINFO, 0, NULL, sizeof(gxInfo), (char *) &gxInfo);
>+	ReleaseDC(NULL, hdc);
>+
>+	if(result > 0)
> 	{
>-		SDL_free( gapi->buffer );
>-		gapi->buffer = NULL;
>-	}
>-	gapi->buffer = SDL_malloc(video->h * video->pitch);
>-	video->pixels = gapi->buffer; 
>+#ifdef DEBUG_VIDEO_GAPI
>+	    // more debug
>+	    if(g_Private->debug)
>+	    {
>+		printf("GXDeviceInfo.pvFrameBuffer:    %p\n", gxInfo.pvFrameBuffer);
>+    		printf("GXDeviceInfo.cxWidth:          %d\n", gxInfo.cxWidth);
>+    		printf("GXDeviceInfo.cyHeight:         %d\n", gxInfo.cyHeight);
>+    		printf("GXDeviceInfo.cbStride:         %d\n", gxInfo.cbStride);
>+    		printf("GXDeviceInfo.cBPP:             %d\n", gxInfo.cBPP);
>+    		printf("GXDeviceInfo.ffFormat:        0x%x\n", gxInfo.ffFormat);
> 
>-	if ( ! gapi->buffer ) {
>-		SDL_SetError("Couldn't allocate buffer for requested mode");
>-		return(NULL);
>-	}
>-
>-	SDL_memset(gapi->buffer, 255, video->h * video->pitch);
>-	MoveWindow(SDL_Window, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN), FALSE);
>-	ShowWindow(SDL_Window, SW_SHOW);
>-	SetForegroundWindow(SDL_Window);
>-
>-	/* JC 14 Mar 2006
>-		Flush the message loop or this can cause big problems later
>-		Especially if the user decides to use dialog boxes or assert()!
>-	*/
>-	WIN_FlushMessageQueue();
>-
>-       /* Open GAPI display */
>-       if( !gapi->useVga && gapi->useGXOpenDisplay && !gapi->alreadyGXOpened )
>-       {
>-#if REPORT_VIDEO_INFO
>-               printf("system display width  (orig): %d\n", GetSystemMetrics(SM_CXSCREEN));
>-               printf("system display height (orig): %d\n", GetSystemMetrics(SM_CYSCREEN));
>+    		printf("GXDeviceInfo.unk:\n");
>+		int ii; for(ii = 0; ii <  sizeof(gxInfo.unknown); ++ii)
>+		printf("0x%02hhX,", gxInfo.unknown[ii]);
>+		printf("\n");
>+	    }
> #endif
>-               gapi->alreadyGXOpened = 1;
>-		if( !gapi->gxFunc.GXOpenDisplay(SDL_Window, GX_FULLSCREEN) )
>-		{
>-			SDL_SetError("Couldn't initialize GAPI");
>-			return(NULL);
>-		}
>-       }
> 
>-	if(gapi->useVga)
>-		gapi->coordinateTransform = (4 - gapi->systemOrientation + gapi->userOrientation) % 4;
>+    	    g_Private->fb.bpp = gxInfo.cBPP;
>+    	    g_Private->videoMem = gxInfo.pvFrameBuffer;
>+        }
> 	else
>-		gapi->coordinateTransform = gapi->userOrientation;
>+	{
>+	    g_Private->fb.flags |= FB_SKIP_OFFSET;
>+	    g_Private->videoMem = g_GapiInfo->GXBeginDraw();
>+	    g_GapiInfo->GXEndDraw();
> 
>-#if REPORT_VIDEO_INFO
>-	printf("Video properties:\n");
>-	printf("display bpp: %d\n", gapi->gxProperties.cBPP);
>-	printf("display width: %d\n", gapi->gxProperties.cxWidth);
>-	printf("display height: %d\n", gapi->gxProperties.cyHeight);
>-       printf("system display width: %d\n", GetSystemMetrics(SM_CXSCREEN));
>-       printf("system display height: %d\n", GetSystemMetrics(SM_CYSCREEN));
>-	printf("x pitch: %d\n", gapi->gxProperties.cbxPitch);
>-	printf("y pitch: %d\n", gapi->gxProperties.cbyPitch);
>-	printf("gapi flags: 0x%x\n", gapi->gxProperties.ffFormat);
>-       printf("user orientation: %d\n", gapi->userOrientation);
>-	printf("system orientation: %d\n", gapi->systemOrientation);
>-       printf("gapi orientation: %d\n", gapi->gapiOrientation);
>+	    if(g_Private->debug)
>+	    {
>+		printf("GAPI_VideoInit\n");
>+		printf("use GXBeginDraw:               %p\n", g_Private->videoMem);
>+		printf("use skip offset\n");
>+	    }
>+	}
> 
>+	if(g_Private->fb.bpp == 15) g_Private->fb.bpp = 16;
> 
>-	if( !gapi->useVga && gapi->useGXOpenDisplay && gapi->needUpdate)
>+	if(0 > WINCE_FixedGeometry(this))
> 	{
>-		gapi->videoMem = gapi->gxFunc.GXBeginDraw(); 
>-		gapi->gxFunc.GXEndDraw();
>+	    SDL_SetError("GAPI_VideoInit: unknown hardware");
>+	    if(g_Private->debug) FrameBufferDumpInfo(&g_Private->fb, "incorrect geometry");
>+	    GAPI_Quit(this);
>+	    return 0;
> 	}
>+    }
> 
>-	printf("video memory: 0x%x\n", gapi->videoMem);
>-	printf("need update: %d\n", gapi->needUpdate);
>-	printf("hi-res fix: %d\n", gapi->hiresFix);
>-	printf("VGA is available on the device: %d\n", g_bRawBufferAvailable);
>-	printf("use raw framebuffer: %d\n", gapi->useVga);
>-	printf("video surface bpp: %d\n", video->format->BitsPerPixel);
>-	printf("video surface width: %d\n", video->w);
>-	printf("video surface height: %d\n", video->h);
>-	printf("mouse/arrows transformation angle: %d\n", gapi->coordinateTransform);
>-#endif
>-
>-
>-	/* Blank screen */
>-	allScreen.x = allScreen.y = 0;
>-	allScreen.w = video->w - 1;
>-	allScreen.h = video->h - 1;
>-	GAPI_UpdateRects(this, 1, &allScreen);
>-
>-	/* We're done */
>-	return(video);
>+    return g_GapiInfo ? 1 : 0;
> }
> 
>-/* We don't actually allow hardware surfaces other than the main one */
>-static int GAPI_AllocHWSurface(_THIS, SDL_Surface *surface)
>+void GAPI_Quit(_THIS)
> {
>-	return(-1);
>-}
>-static void GAPI_FreeHWSurface(_THIS, SDL_Surface *surface)
>-{
>-	return;
>-}
>+    if(g_GapiInfo)
>+    {
>+	if(g_GapiInfo->hGapiLib)  FreeLibrary(g_GapiInfo->hGapiLib);
> 
>-/* We need to wait for vertical retrace on page flipped displays */
>-static int GAPI_LockHWSurface(_THIS, SDL_Surface *surface)
>-{
>-	return(0);
>+	SDL_free(g_GapiInfo);
>+        g_GapiInfo = NULL;
>+    }
> }
> 
>-static void GAPI_UnlockHWSurface(_THIS, SDL_Surface *surface)
>+int GAPI_PreferableDriver(void)
> {
>-	return;
>+    return (SDL_getenv("SDL_VIDEODRIVER") &&
>+	0 == SDL_strcmp(GAPIVID_DRIVER_NAME, SDL_getenv("SDL_VIDEODRIVER")));
> }
> 
>-static int updateLine8to8(_THIS, unsigned char *srcPointer, unsigned char *destPointer, int width, int height, int lines)
>+int RAW_Init(_THIS)
> {
>-	if( gapi->dstPixelStep == 1) /* optimized blitting on most devices */
>-	{
>-		SDL_memcpy(destPointer, srcPointer, width);
>-		return 1;
>-	} else
>-	{
>-		// TODO: read 4 pixels, write DWORD
>-		int step = gapi->dstPixelStep;
>-		while(width--)
>-		{
>-			*destPointer = *srcPointer++;
>-			destPointer += step;
>-		}
>-	}
>-	return 1;
>-}
>+    RawFrameBufferInfo rfbi = { 0 };
>+    HDC hdc = GetDC(NULL);
>+    int result = ExtEscape(hdc, GETRAWFRAMEBUFFER, 0, NULL, sizeof(RawFrameBufferInfo), (char *) &rfbi);
>+    ReleaseDC(NULL, hdc);
> 
>-/* Video memory is very slow so lets optimize as much as possible */
>-static int updateLine16to16(_THIS, PIXEL *srcPointer, PIXEL *destPointer, int width, int height, int lines)
>-{
>-	PIXEL *line1, *line2;
>-	int step = gapi->dstPixelStep / 2;
>+    //disable
>+    if(result == 0 || rfbi.pFramePointer == 0 ||
>+    	rfbi.cxPixels == 0 || rfbi.cyPixels == 0 ||
>+	rfbi.cxStride == 0 || rfbi.cyStride == 0) return 0;
> 
>-	if( step == 1 ) /* optimized blitting on most devices */
>-	{
>-		SDL_memcpy(destPointer, srcPointer, width * sizeof(PIXEL));
>-		return 1;
>-	}
>-	else
>-	{
>-		if( (gapi->gapiOrientation != SDL_ORIENTATION_UP) &&
>-			(gapi->userOrientation == SDL_ORIENTATION_UP )) // iPaq 3660/3800 and user orientation up
>-		{	
>-			// to prevent data misalignment copy only one line
>-			if( ((((unsigned)destPointer & 3) != 0) && (gapi->gapiOrientation == SDL_ORIENTATION_LEFT)) 
>-				|| ((((unsigned)destPointer & 3) == 0) && (gapi->gapiOrientation != SDL_ORIENTATION_LEFT))
>-				|| (lines == 1) ) 
>-			{
>-				while(width--)
>-				{
>-					*destPointer = *srcPointer++;
>-					destPointer += step;
>-				}
>-				return 1;
>-			}
>+    // fill FrameBufferInfo
>+    SDL_memset(&g_Private->fb, 0, sizeof(FrameBufferInfo));
> 
>-			/* read two lines at the same time, write DWORD */
>-			line1 = srcPointer;
>-			line2 = srcPointer + SDL_VideoSurface->pitch / 2;
>+    g_Private->fb.xpitch = rfbi.cxStride;
>+    g_Private->fb.ypitch = rfbi.cyStride;
>+    g_Private->fb.width  = rfbi.cxPixels;
>+    g_Private->fb.height = rfbi.cyPixels;
>+    g_Private->fb.offset = 0;
>+    g_Private->fb.bpp    = rfbi.wBPP;
>+    g_Private->fb.flags  = FB_RAW_MODE;
>+    g_Private->fb.format = 0;
> 
>-			if( gapi->gapiOrientation == SDL_ORIENTATION_LEFT )
>-				while(width--) // iPaq 3800
>-				{
>-					*(DWORD*)destPointer =(*line2++ << 16) | *line1++;
>-					destPointer += step;
>-				}
>-			else
>-			{
>-				destPointer += gapi->gxProperties.cbyPitch / 2;
>+    if(0 > WINCE_FixedGeometry(this))
>+    {
>+	SDL_SetError("GAPI_VideoInit: unknown hardware");
>+	if(g_Private->debug) FrameBufferDumpInfo(&g_Private->fb, "incorrect geometry");
>+	RAW_Quit(this);
>+	return 0;
>+    }
> 
>-				while(width--) // iPaq 3660
>-				{
>-					*(DWORD*)destPointer =(*line1++ << 16) | *line2++;
>-					destPointer += step;
>-				}
>-			}
>-			return 2;
>-		} else
>-		{
>-			// iPaq 3800 and user orientation landscape
>-			if( gapi->gapiOrientation == SDL_ORIENTATION_LEFT )
>-			{
>-				int w1;
>+    switch(rfbi.wFormat)
>+    {
>+	case FORMAT_565:
>+	    g_Private->fb.format = kfDirect565;
>+	    break;
> 
>-				// to prevent data misalignment copy only one pixel
>-				if( (((unsigned)destPointer & 3) == 0) && (width > 0)) 
>-				{
>-					*destPointer-- = *srcPointer++;
>-					width--;
>-				}
>+	case FORMAT_555:
>+	    g_Private->fb.format = kfDirect555;
>+	    break;
> 
>-				destPointer--;
>+	default:
>+	    // unknown pixel format
>+	    switch(rfbi.wBPP)
>+	    {
>+		case 16: g_Private->fb.format = kfDirect565; break;
>+		case 15: g_Private->fb.format = kfDirect555; break;
>+		default: g_Private->fb.format = kfDirect; break;
>+	    }
>+    }
> 
>-				w1 = width / 2;
>+    g_Private->videoMem = rfbi.pFramePointer;
> 
>-				while(w1--)
>-				{
>-					DWORD p = *(DWORD*)srcPointer;
>-					*((DWORD*)destPointer) = (p << 16) | (p >> 16);
>-					destPointer -= 2;
>-					srcPointer += 2;
>-				}
>+    return 1;
>+}
> 
>-				if( width & 1 ) // copy the last pixel
>-				{
>-					destPointer++;
>-					*destPointer = *srcPointer;
>-				}
>+void RAW_Quit(_THIS)
>+{
>+}
> 
>-				return 1;
>-			}
>+void FrameBufferInitialize(FrameBufferInfo* fb)
>+{
>+    int orientation = GetFrameBufferOrientation(fb);
> 
>-			// modern iPaqs and user orientation landscape
>-			// read two pixels, write DWORD
>+    // set correct start offset
>+    switch(orientation)
>+    {
>+	case ORIENTATION_UP:
>+	    fb->offset = 0;
>+	    break;
> 
>-			line1 = srcPointer;
>-			line2 = srcPointer + SDL_VideoSurface->pitch / 2;
>+	case ORIENTATION_LEFT:
>+	    fb->offset = __abs(fb->ypitch * (fb->height - 1));
>+	    break;
> 
>-			if( (((unsigned)destPointer & 3) != 0) || (lines == 1) ) 
>-			{
>-				while(width--)
>-				{
>-					*destPointer = *srcPointer++;
>-					destPointer += step;
>-				}
>-				return 1;
>-			}
>-			
>-			while(width--)
>-			{
>-				*(DWORD*)destPointer =(*line2++ << 16) | *line1++;
>-				destPointer -= gapi->gxProperties.cbyPitch / 2;
>-			}
>-			return 2;
>-		}
>-	}
>-}
>+	case ORIENTATION_RIGHT:
>+	    fb->offset = __abs(fb->xpitch * (fb->width - 1));
>+	    break;
> 
>-// Color component masks for 565
>-#define REDMASK (31<<11)
>-#define GREENMASK (63<<5)
>-#define BLUEMASK (31)
>+	case ORIENTATION_DOWN:
>+	    fb->offset = __abs(fb->xpitch * (fb->width - 1) +
>+				fb->ypitch * (fb->height - 1));
>+	    break;
> 
>+	default: break;
>+    }
> 
>-static int updateLine16to4(_THIS, PIXEL *srcPointer, unsigned char *destPointer, int width, int height, int lines, int yNibble, int xNibble)
>-{
>-	PIXEL *line1, *line2;
>-	int step = gapi->dstPixelStep;
>+    //if(orientation != ORIENTATION_UP)
>+    switch(orientation)
>+    {
>+	case ORIENTATION_LEFT: FrameBufferRotate(fb, ORIENTATION_RIGHT); break;
>+	case ORIENTATION_RIGHT:FrameBufferRotate(fb, ORIENTATION_LEFT); break;
>+	case ORIENTATION_DOWN: FrameBufferRotate(fb, ORIENTATION_DOWN); break;
> 
>-	if( gapi->userOrientation == SDL_ORIENTATION_UP )
>-	{
>-		if( yNibble ) // copy bottom half of a line
>-		{
>-			while(width--)
>-			{
>-				PIXEL c1 = *srcPointer++;
>-				c1 = ((c1 & REDMASK) >> 11) + ((c1 & GREENMASK) >> 5) + (c1 & BLUEMASK);			
>-				*destPointer = (*destPointer & 0x0F) | ((~(c1 >> 3) << 4));
>-				destPointer += step;
>-			}
>-			return 1;
>-		}
>+	default: break;
>+    }
>+}
> 
>-		// either 1 pixel picture or tail, anyway this is the last line
>-		if( lines == 1 )
>-		{
>-			while(width--)
>-			{
>-				PIXEL c1 = *srcPointer++;
>-				c1 = ((c1 & REDMASK) >> 11) + ((c1 & GREENMASK) >> 5) + (c1 & BLUEMASK);			
>-				*destPointer = (*destPointer & 0xF0) | ((~(c1 >> 3) & 0xF));
>-				destPointer += step;
>-			}
>-			return 1;
>-		}
>+int GetFrameBufferOrientation(const FrameBufferInfo* src)
>+{
>+    if(src->xpitch > 0 && src->ypitch > 0)
>+	return ORIENTATION_UP;
>+    else
>+    if(src->xpitch > 0 && src->ypitch < 0)
>+	return ORIENTATION_LEFT;
>+    else
>+    if(src->xpitch < 0 && src->ypitch > 0)
>+	return ORIENTATION_RIGHT;
>+    else
>+    if(src->xpitch < 0 && src->ypitch < 0)
>+	return ORIENTATION_DOWN;
> 
>-		line1 = srcPointer;
>-		line2 = srcPointer + SDL_VideoSurface->pitch / 2;
>+    return ORIENTATION_UNKNOWN;
>+}
> 
>-		while(width--)
>-		{
>-			PIXEL c1 = *line1++;
>-			PIXEL c2 = *line2++;
>-			c1 = ((c1 & REDMASK) >> 11) + ((c1 & GREENMASK) >> 5) + (c1 & BLUEMASK);
>-			c2 = ((c2 & REDMASK) >> 11) + ((c2 & GREENMASK) >> 5) + (c2 & BLUEMASK);
>-			*destPointer = ~((c1 >> 3) + ((c2 >> 3) << 4));
>-			destPointer += step;
>-		}
>-		return 2;
>-	} else
>-	{
>-		int w1;
>-		w1 = width / 2;
>+void FrameBufferRotate(FrameBufferInfo* dst, int orientation)
>+{
>+    FrameBufferInfo src;
>+    // copy dst -> src
>+    SDL_memcpy(&src, dst, sizeof(FrameBufferInfo));
> 
>-		if( xNibble )
>-		{
>-			// copy one pixel
>-			PIXEL c1 = *srcPointer++;
>-			c1 = ((c1 & REDMASK) >> 11) + ((c1 & GREENMASK) >> 5) + (c1 & BLUEMASK);			
>-			*destPointer = (*destPointer & 0xF0) | ((~(c1 >> 3) & 0xF));
>-			destPointer++;
>-		}
>+    switch(orientation)
>+    {
>+        case ORIENTATION_LEFT:
>+	    dst->width  = src.height;
>+	    dst->height = src.width;
>+	    dst->xpitch = src.ypitch;
>+	    dst->ypitch = -src.xpitch;
>+	    dst->offset = src.offset + src.xpitch * (src.width - 1);
>+	    break;
> 
>-		while(w1--)
>-		{
>-			PIXEL c1 = *srcPointer;
>-			PIXEL c2 = *(srcPointer + 1);
>-			c1 = ((c1 & REDMASK) >> 11) + ((c1 & GREENMASK) >> 5) + (c1 & BLUEMASK);
>-			c2 = ((c2 & REDMASK) >> 11) + ((c2 & GREENMASK) >> 5) + (c2 & BLUEMASK);
>-			*destPointer++ = ~((c2 >> 3) + ((c1 >> 3) << 4));
>-			srcPointer += 2;
>-		}
>+        case ORIENTATION_RIGHT:
>+	    dst->width  = src.height;
>+	    dst->height = src.width;
>+	    dst->xpitch = -src.ypitch;
>+	    dst->ypitch = src.xpitch;
>+	    dst->offset = src.offset + src.ypitch * (src.height - 1);
>+	    break;
> 
>-		// copy tail
>-		if( (width & 1) && !xNibble )
>-		{
>-			PIXEL c1 = *srcPointer;
>-			c1 = ((c1 & REDMASK) >> 11) + ((c1 & GREENMASK) >> 5) + (c1 & BLUEMASK);			
>-			*destPointer = (*destPointer & 0x0F) | ((~(c1 >> 3) << 4));
>-		}
>+        case ORIENTATION_DOWN:
>+	    FrameBufferRotate(dst, ORIENTATION_LEFT);
>+	    FrameBufferRotate(dst, ORIENTATION_LEFT);
>+	    break;
> 
>-		return 1;
>-	}
>+        default:
>+	    break;
>+    }
> }
> 
>-static void GAPI_UpdateRectsMono(_THIS, int numrects, SDL_Rect *rects)
>+void PointerRotate(POINT* pt, const FrameBufferInfo* fb, int orientation)
> {
>-	int i, height;
>-	int linesProcessed;
>-	int xNibble, yNibble;
>+    switch(orientation)
>+    {
>+	case ORIENTATION_UP:
>+	    break;
> 
>-	for (i=0; i<numrects; i++)
>+	case ORIENTATION_LEFT:
> 	{
>-		unsigned char *destPointer;
>-		unsigned char *srcPointer;
>+	    int temp = pt->y;
>+	    pt->y = fb->height - pt->x;
>+	    pt->x = temp;
>+	}
>+	    break;
> 
>-		if( gapi->userOrientation == SDL_ORIENTATION_UP )
>-			destPointer = (unsigned char*) gapi->videoMem + gapi->startOffset - rects[i].y * gapi->gxProperties.cBPP / 8 + rects[i].x * gapi->dstPixelStep;
>-		else
>-			destPointer = (unsigned char*) gapi->videoMem + gapi->startOffset + rects[i].x * gapi->gxProperties.cBPP / 8 + rects[i].y * gapi->dstLineStep;
>-
>-		srcPointer = ((unsigned char*) SDL_VideoSurface->pixels) + rects[i].y * SDL_VideoSurface->pitch + rects[i].x * 2;
>-		yNibble = rects[i].y & 1; // TODO: only for 4 bpp
>-		xNibble = rects[i].x & 1;
>-		height = rects[i].h;
>-		while (height > 0)
>-		{
>-			switch(gapi->gxProperties.cBPP)
>-			{
>-			case 2: // TODO
>-			case 4:
>-					linesProcessed = updateLine16to4(this, (PIXEL*) srcPointer, destPointer, rects[i].w, rects[i].h, height, yNibble, xNibble);
>-					yNibble = 0;
>-			}
>-			height -= linesProcessed;
>-			if( gapi->userOrientation == SDL_ORIENTATION_UP )
>-				destPointer--; // always fill 1 byte
>-			else destPointer += gapi->dstLineStep;
>-			srcPointer += SDL_VideoSurface->pitch * linesProcessed; // pitch in bytes
>-		}
>+	case ORIENTATION_RIGHT:
>+	{
>+	    int temp = pt->x;
>+	    pt->x = fb->width - pt->y;
>+	    pt->y = temp;
> 	}
>-}
>+	    break;
> 
>-static void GAPI_UpdateRectsColor(_THIS, int numrects, SDL_Rect *rects)
>-{
>-	int i, height;
>-	int bytesPerPixel = (gapi->gxProperties.cBPP + 1) / 8;
>-	int linesProcessed;
>-	for (i=0; i<numrects; i++) {
>-		unsigned char *destPointer = (unsigned char*) gapi->videoMem + gapi->startOffset + rects[i].y * gapi->dstLineStep + rects[i].x * gapi->dstPixelStep;
>-		unsigned char *srcPointer = ((unsigned char*) SDL_VideoSurface->pixels) + rects[i].y * SDL_VideoSurface->pitch + rects[i].x * bytesPerPixel;
>-		height = rects[i].h;
>+	case ORIENTATION_DOWN:
>+	    pt->x = fb->width  - pt->x;
>+	    pt->y = fb->height - pt->y;
>+	    break;
> 
>-//		fprintf(stderr, "Starting rect %dx%d, dst=0x%x, w = %d, h = %d\n", rects[i].w, rects[i].h,destPointer,rects[i].w,rects[i].h);
>-//		fflush(stderr);
>-		linesProcessed = height;
>-
>-		while (height > 0) {
>-			switch(bytesPerPixel)
>-			{
>-			case 1:
>-				linesProcessed = updateLine8to8(this, srcPointer, (unsigned char *) destPointer, rects[i].w, rects[i].h, height);
>-				break;
>-			case 2:
>-#pragma warning(disable: 4133)
>-				linesProcessed = updateLine16to16(this, (PIXEL*) srcPointer, destPointer, rects[i].w, rects[i].h, height);
>-				break;
>-			}
>-			height -= linesProcessed;
>-			destPointer += gapi->dstLineStep * linesProcessed;
>-			srcPointer += SDL_VideoSurface->pitch * linesProcessed; // pitch in bytes
>-		}
>-//		fprintf(stderr, "End of rect\n");
>-//		fflush(stderr);
>-	}
>+	default: break;
>+    }
> }
> 
>-
>-static void GAPI_UpdateRects(_THIS, int numrects, SDL_Rect *rects)
>+void SetRGBMask(int bpp, Uint32 *r, Uint32 *g, Uint32 *b)
> {
>-	// we do not want to corrupt video memory
>-	if( gapi->suspended ) return;
>+    switch(bpp)
>+    {
>+	case 15:				
>+	    *r = 0x00007c00;
>+	    *g = 0x000003e0;
>+	    *b = 0x0000001f;
>+	    break;
> 
>-	if( gapi->needUpdate )
>-		gapi->videoMem = gapi->gxFunc.GXBeginDraw(); 
>+	case 16:
>+	    *r = 0x0000f800;
>+	    *g = 0x000007e0;
>+	    *b = 0x0000001f;
>+	    break;
> 
>-	if( gapi->gxProperties.cBPP < 8 )
>-		GAPI_UpdateRectsMono(this, numrects, rects);
>-	else
>-		GAPI_UpdateRectsColor(this, numrects, rects);
>+	case 24:
>+	case 32:
>+	    *r = 0x00ff0000;
>+	    *g = 0x0000ff00;
>+	    *b = 0x000000ff;
>+	    break;
> 
>-	if( gapi->needUpdate )
>-		gapi->gxFunc.GXEndDraw();
>+	default:
>+	    *r = 0;
>+	    *g = 0;
>+	    *b = 0;
>+	    break;
>+    }
> }
> 
>-/* Note:  If we are terminated, this could be called in the middle of
>-   another SDL video routine -- notably UpdateRects.
>-*/
>-void GAPI_VideoQuit(_THIS)
>+const char* GetOrientationName(int orientation)
> {
>-	int i, j;
>-	/* Destroy the window and everything associated with it */
>-	if ( SDL_Window ) 
>-	{
>-	    if ((g_hGapiLib != 0) && this && gapi && gapi->gxFunc.GXCloseDisplay && !gapi->useVga)
>-			gapi->gxFunc.GXCloseDisplay(); 
>+    switch(orientation)
>+    {
>+        case ORIENTATION_UP:        return "UP";
>+        case ORIENTATION_DOWN:      return "DOWN";
>+        case ORIENTATION_LEFT:      return "LEFT";
>+        case ORIENTATION_RIGHT:     return "RIGHT";
>+        default: break;
>+    }
> 
>-		if (this->screen->pixels != NULL)
>-		{
>-			SDL_free(this->screen->pixels);
>-			this->screen->pixels = NULL;
>-		}
>-		if ( screen_icn ) {
>-			DestroyIcon(screen_icn);
>-			screen_icn = NULL;
>-		}
>+    return "UNKNOWN";
>+}
> 
>-		DIB_DestroyWindow(this);
>-		SDL_UnregisterApp();
>+int GetSystemOrientation(void)
>+{
>+    DEVMODE sDevMode = {0};
>+    sDevMode.dmSize = sizeof(DEVMODE);
>+    sDevMode.dmFields = DM_DISPLAYORIENTATION;
> 
>-		SDL_Window = NULL;
>-#if defined(_WIN32_WCE)
>-
>-// Unload wince aygshell library to prevent leak
>-		if( aygshell ) 
>-		{
>-			FreeLibrary(aygshell);
>-			aygshell = NULL;
>-		}
>-#endif
>-
>-	/* Free video mode lists */
>-	for ( i=0; i<NUM_MODELISTS; ++i ) {
>-		if ( gapi->SDL_modelist[i] != NULL ) {
>-			for ( j=0; gapi->SDL_modelist[i][j]; ++j )
>-				SDL_free(gapi->SDL_modelist[i][j]);
>-			SDL_free(gapi->SDL_modelist[i]);
>-			gapi->SDL_modelist[i] = NULL;
>-		}
>+    // DMDO_0, DMDO_90, DMDO_180, DMDO_270
>+    if(DISP_CHANGE_BADMODE != ChangeDisplaySettingsEx(NULL, &sDevMode, NULL, CDS_TEST, NULL))
>+	switch(sDevMode.dmDisplayOrientation)
>+	{
>+	    case DMDO_0:	return ORIENTATION_UP;
>+	    case DMDO_90:	return ORIENTATION_RIGHT;
>+	    case DMDO_180:	return ORIENTATION_DOWN;
>+	    case DMDO_270:	return ORIENTATION_LEFT;
>+	    default: break;
> 	}
> 
>-	}
>-
>+    return ORIENTATION_UNKNOWN;
> }
> 
>-static void GAPI_Activate(_THIS, BOOL active, BOOL minimized)
>+void FrameBufferDumpInfo(const FrameBufferInfo* fb, const char* name)
> {
>-	//Nothing to do here (as far as I know)
>-}
>+    printf("%s fb.width:       %d\n", name, fb->width);
>+    printf("%s fb.height:      %d\n", name, fb->height);
>+    printf("%s fb.xpitch:      %d\n", name, fb->xpitch);
>+    printf("%s fb.ypitch:      %d\n", name, fb->ypitch);
>+    printf("%s fb.offset:      %d\n", name, fb->offset);
>+    printf("%s fb.bpp:         %d\n", name, fb->bpp);
>+    printf("%s fb.format:      0x%x\n", name, fb->format);
>+    printf("%s fb.flags:       0x%x\n", name, fb->flags);
> 
>-static void GAPI_RealizePalette(_THIS)
>-{
>-	OutputDebugString(TEXT("GAPI_RealizePalette NOT IMPLEMENTED !\r\n"));
>+    int orientation = GetFrameBufferOrientation(fb);
>+    printf("%s fb.orientation: %d, %s\n", name, orientation, GetOrientationName(orientation));
> }
> 
>-static void GAPI_PaletteChanged(_THIS, HWND window)
>+int UpdateLine8to8(const FrameBufferInfo* fb, const unsigned char* src, unsigned char* dst, int width, int height)
> {
>-	OutputDebugString(TEXT("GAPI_PaletteChanged NOT IMPLEMENTED !\r\n"));
>+    if(fb->xpitch == 1)
>+	SDL_memcpy(dst, src, width);
>+    else
>+    {
>+	while(width--)
>+	{
>+	    *dst = *src++;
>+	    dst += fb->xpitch;
>+	}
>+    }
>+    return 1;
> }
> 
>-static void GAPI_WinPAINT(_THIS, HDC hdc)
>+int UpdateLine16to16(const FrameBufferInfo* fb, const Uint16* src, Uint16* dst, Uint16 width, Uint16 height)
> {
>-	// draw current offscreen buffer on hdc
>+    if(2 == fb->xpitch)
>+    {
>+	switch(width)
>+	{
>+	    case 1:
>+		*dst = *src;
>+		break;
> 
>-	int bpp = 16; // we always use either 8 or 16 bpp internally
>-	HGDIOBJ prevObject;
>-	unsigned short *bitmapData;
>-	HBITMAP hb;
>-	HDC srcDC;
>+	    case 2:
>+		*((Uint32*) dst) = *((Uint32*) src);
>+		break;
> 
>-    // Create a DIB
>-    BYTE buffer[sizeof(BITMAPINFOHEADER) + 3 * sizeof(RGBQUAD)] = {0};
>-    BITMAPINFO*       pBMI    = (BITMAPINFO*)buffer;
>-    BITMAPINFOHEADER* pHeader = &pBMI->bmiHeader;
>-    DWORD*            pColors = (DWORD*)&pBMI->bmiColors;   
>-
>-	// CreateDIBSection does not support 332 pixel format on wce
>-	if( gapi->gxProperties.cBPP == 8 ) return;
>-
>-    // DIB Header
>-    pHeader->biSize            = sizeof(BITMAPINFOHEADER);
>-    pHeader->biWidth           = gapi->w;
>-    pHeader->biHeight          = -gapi->h;
>-    pHeader->biPlanes          = 1;
>-    pHeader->biBitCount        = bpp;
>-    pHeader->biCompression     = BI_RGB;
>-    pHeader->biSizeImage       = (gapi->w * gapi->h * bpp) / 8;
>-	
>-    // Color masks
>-	if( bpp == 16 )
>+	    default:
>+		SDL_memcpy(dst, src, width * 2);
>+		break;
>+	}
>+    }
>+    else
>+    if(-2 == fb->xpitch)
>+    {
>+	while(width--)
>+	    *dst-- = *src++;
>+    }
>+    else
>+    {
>+	while(width--)
> 	{
>-		pColors[0] = REDMASK;
>-		pColors[1] = GREENMASK;
>-		pColors[2] = BLUEMASK;
>-		pHeader->biCompression = BI_BITFIELDS;
>+	    *dst = *src++;
>+	    dst += fb->xpitch / 2;
> 	}
>-    // Create the DIB
>-    hb =  CreateDIBSection( 0, pBMI, DIB_RGB_COLORS, (void**)&bitmapData, 0, 0 );
>-
>-	// copy data
>-	// FIXME: prevent misalignment, but I've never seen non aligned width of screen
>-	memcpy(bitmapData, gapi->buffer, pHeader->biSizeImage);
>-	srcDC = CreateCompatibleDC(hdc);
>-	prevObject = SelectObject(srcDC, hb);
>-
>-	BitBlt(hdc, 0, 0, gapi->w, gapi->h, srcDC, 0, 0, SRCCOPY);
>-
>-	SelectObject(srcDC, prevObject);
>-	DeleteObject(hb);
>-	DeleteDC(srcDC);
>+    }
>+    return 1;
> }
>-
>-int GAPI_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors) 
>-{
>-	GAPI_CreatePalette(ncolors, colors);
>-	return 1;
>-}
>Index: src/video/wincommon/SDL_sysevents.c
>===================================================================
>--- src/video/wincommon/SDL_sysevents.c	(revision 29)
>+++ src/video/wincommon/SDL_sysevents.c	(revision 41)
>@@ -50,12 +50,6 @@
> #include "wmmsg.h"
> #endif
> 
>-#include "../windib/SDL_gapidibvideo.h"
>-
>-#ifdef SDL_VIDEO_DRIVER_GAPI
>-#include "../gapi/SDL_gapivideo.h"
>-#endif
>-
> #ifdef _WIN32_WCE
> #define IsZoomed(HWND) 1
> #define NO_GETKEYBOARDSTATE
>@@ -88,10 +82,10 @@
> 
> /* Functions called by the message processing function */
> LONG (*HandleMessage)(_THIS, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)=NULL;
>-void (*WIN_Activate)(_THIS, BOOL active, BOOL iconic);
>-void (*WIN_RealizePalette)(_THIS);
>-void (*WIN_PaletteChanged)(_THIS, HWND window);
>-void (*WIN_WinPAINT)(_THIS, HDC hdc);
>+void (*WIN_Activate)(_THIS, BOOL active, BOOL iconic) = NULL;
>+void (*WIN_RealizePalette)(_THIS) = NULL;
>+void (*WIN_PaletteChanged)(_THIS, HWND window) = NULL;
>+void (*WIN_WinPAINT)(_THIS, HDC hdc) = NULL;
> extern void DIB_SwapGamma(_THIS);
> 
> #ifndef NO_GETKEYBOARDSTATE
>@@ -104,35 +98,6 @@
> ToUnicodeFN SDL_ToUnicode = ToUnicode9xME;
> #endif /* !NO_GETKEYBOARDSTATE */
> 
>-
>-#if defined(_WIN32_WCE)
>-
>-//AdjustWindowRect is not available under WinCE 2003
>-#define AdjustWindowRect(a,b,c) (AdjustWindowRectEx((a),(b),(c),0))
>-
>-// dynamically load aygshell dll because we want SDL to work on HPC and be300
>-HINSTANCE aygshell = NULL;
>-BOOL (WINAPI *SHFullScreen)(HWND hwndRequester, DWORD dwState) = 0;
>-
>-#define SHFS_SHOWTASKBAR            0x0001
>-#define SHFS_HIDETASKBAR            0x0002
>-#define SHFS_SHOWSIPBUTTON          0x0004
>-#define SHFS_HIDESIPBUTTON          0x0008
>-#define SHFS_SHOWSTARTICON          0x0010
>-#define SHFS_HIDESTARTICON          0x0020
>-
>-static void LoadAygshell(void)
>-{
>-	if( !aygshell )
>-		 aygshell = SDL_LoadObject("aygshell.dll");
>-	if( (aygshell != 0) && (SHFullScreen == 0) )
>-	{
>-		SHFullScreen = (int (WINAPI *)(struct HWND__ *,unsigned long)) SDL_LoadFunction(aygshell, "SHFullScreen");
>-	}
>-}
>-
>-#endif
>-
> /* JC 14 Mar 2006
>    This is used all over the place, in the windib driver and in the dx5 driver
>    So we may as well stick it here instead of having multiple copies scattered
>@@ -150,20 +115,8 @@
> 
> static void SDL_RestoreGameMode(void)
> {
>-#ifdef _WIN32_WCE //Under ce we don't minimize, therefore no restore
>-	
>-#ifdef SDL_VIDEO_DRIVER_GAPI
>-	SDL_VideoDevice *this = current_video;
>-	if(SDL_strcmp(this->name, "gapi") == 0)
>-	{
>-		if( this->hidden->gapiInfo->suspended )
>-		{
>-			this->hidden->gapiInfo->suspended = 0;
>-		}
>-	}
>-#endif
>-	
>-#else
>+#ifndef _WIN32_WCE
>+	//Under ce we don't minimize, therefore no restore
> 	ShowWindow(SDL_Window, SW_RESTORE);
> #endif
> 
>@@ -176,20 +129,7 @@
> static void SDL_RestoreDesktopMode(void)
> {
> 
>-#ifdef _WIN32_WCE
>-	
>-#ifdef SDL_VIDEO_DRIVER_GAPI
>-	SDL_VideoDevice *this = current_video;
>-	if(SDL_strcmp(this->name, "gapi") == 0)
>-	{
>-		if( !this->hidden->gapiInfo->suspended )
>-		{
>-			this->hidden->gapiInfo->suspended = 1;
>-		}
>-	}
>-#endif
>-	
>-#else
>+#ifndef _WIN32_WCE
> 	/* WinCE does not have a taskbar, so minimizing is not convenient */
> 	ShowWindow(SDL_Window, SW_MINIMIZE);
> #endif
>@@ -327,15 +267,6 @@
> 						SDL_RestoreGameMode();
> 					}
> 				}
>-#if defined(_WIN32_WCE)
>-				if ( WINDIB_FULLSCREEN() ) {
>-					LoadAygshell();
>-					if( SHFullScreen )
>-						SHFullScreen(SDL_Window, SHFS_HIDESTARTICON|SHFS_HIDETASKBAR|SHFS_HIDESIPBUTTON);
>-					else
>-						ShowWindow(FindWindow(TEXT("HHTaskBar"),NULL),SW_HIDE);
>-				}
>-#endif
> 				posted = SDL_PrivateAppActive(1, appstate);
> 				WIN_GetKeyboardState();
> 			} else {
>@@ -355,18 +286,11 @@
> 					if ( WINDIB_FULLSCREEN() ) {
> 						appstate |= SDL_APPMOUSEFOCUS;
> 						SDL_RestoreDesktopMode();
>-#if defined(_WIN32_WCE)
>-						LoadAygshell();
>-						if( SHFullScreen ) 
>-							SHFullScreen(SDL_Window, SHFS_SHOWSTARTICON|SHFS_SHOWTASKBAR|SHFS_SHOWSIPBUTTON);
>-						else
>-							ShowWindow(FindWindow(TEXT("HHTaskBar"),NULL),SW_SHOW);
>-#endif
> 					}
> 				}
> 				posted = SDL_PrivateAppActive(0, appstate);
> 			}
>-			WIN_Activate(this, active, minimized);
>+			if(WIN_Activate) WIN_Activate(this, active, minimized);
> 			return(0);
> 		}
> 		break;
>@@ -374,7 +298,12 @@
> 		case WM_MOUSEMOVE: {
> 
> #ifdef WM_MOUSELEAVE
>+#if defined(_WIN32_WCE)
>+			/* No need to handle SDL_APPMOUSEFOCUS when fullscreen */
>+			if ( SDL_VideoSurface && !FULLSCREEN() ) {
>+#else
> 			if ( SDL_VideoSurface ) {
>+#endif
> 				/* mouse has entered the window */
> 
> 				if ( !(SDL_GetAppState() & SDL_APPMOUSEFOCUS) ) {
>@@ -399,7 +328,12 @@
> #ifdef WM_MOUSELEAVE
> 		case WM_MOUSELEAVE: {
> 
>+#if defined(_WIN32_WCE)
>+			/* No need to handle SDL_APPMOUSEFOCUS when fullscreen */
>+			if ( SDL_VideoSurface && !FULLSCREEN() ) {
>+#else
> 			if ( SDL_VideoSurface ) {
>+#endif
> 				/* mouse has left the window */
> 				posted = SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS);
> 			}
>@@ -641,19 +575,20 @@
> 
> 		/* We are about to get palette focus! */
> 		case WM_QUERYNEWPALETTE: {
>-			WIN_RealizePalette(current_video);
>+			if(WIN_RealizePalette) WIN_RealizePalette(current_video);
> 			return(TRUE);
> 		}
> 		break;
> 
> 		/* Another application changed the palette */
> 		case WM_PALETTECHANGED: {
>-			WIN_PaletteChanged(current_video, (HWND)wParam);
>+			if(WIN_PaletteChanged) WIN_PaletteChanged(current_video, (HWND)wParam);
> 		}
> 		break;
> 
> 		/* We were occluded, refresh our display */
> 		case WM_PAINT: {
>+		    if(WIN_WinPAINT) {
> 			HDC hdc;
> 			PAINTSTRUCT ps;
> 
>@@ -663,6 +598,7 @@
> 				WIN_WinPAINT(current_video, hdc);
> 			}
> 			EndPaint(SDL_Window, &ps);
>+		    }
> 		}
> 		return(0);
> 
>Index: src/video/windib/SDL_dibevents.c
>===================================================================
>--- src/video/windib/SDL_dibevents.c	(revision 29)
>+++ src/video/windib/SDL_dibevents.c	(revision 41)
>@@ -30,13 +30,8 @@
> #include "../../events/SDL_sysevents.h"
> #include "../../events/SDL_events_c.h"
> #include "../wincommon/SDL_lowvideo.h"
>-#include "SDL_gapidibvideo.h"
> #include "SDL_vkeys.h"
> 
>-#ifdef SDL_VIDEO_DRIVER_GAPI
>-#include "../gapi/SDL_gapivideo.h"
>-#endif
>-
> #ifdef SDL_VIDEO_DRIVER_WINDIB
> #include "SDL_dibvideo.h"
> #endif
>@@ -47,12 +42,12 @@
> 
> #ifdef _WIN32_WCE
> #define NO_GETKEYBOARDSTATE
>+extern int  WinCE_GetLastStylusPos(POINT* ptLast);
> #endif
> 
> /* The translation table from a Microsoft VK keysym to a SDL keysym */
> static SDLKey VK_keymap[SDLK_LAST];
> static SDL_keysym *TranslateKey(WPARAM vkey, UINT scancode, SDL_keysym *keysym, int pressed);
>-static SDLKey Arrows_keymap[4];
> 
> /* Masks for processing the windows KEYDOWN and KEYUP messages */
> #define REPEATED_KEYMASK	(1<<30)
>@@ -61,73 +56,14 @@
> /* DJM: If the user setup the window for us, we want to save his window proc,
>    and give him a chance to handle some messages. */
> #ifdef STRICT
>-#define WNDPROCTYPE	WNDPROC
>+#define WNDPROCTYPE     WNDPROC
> #else
>-#define WNDPROCTYPE	FARPROC
>+#define WNDPROCTYPE     FARPROC
> #endif
> static WNDPROCTYPE userWindowProc = NULL;
> 
>+static HKL hLayoutUS = NULL;
> 
>-#ifdef SDL_VIDEO_DRIVER_GAPI
>-
>-WPARAM rotateKey(WPARAM key,int direction) 
>-{
>-	if(direction ==0 ) return key;
>-	
>-	switch (key) {
>-		case 0x26: /* up */
>-			return Arrows_keymap[(2 + direction) % 4];
>-		case 0x27: /* right */
>-			return Arrows_keymap[(1 + direction) % 4];
>-		case 0x28: /* down */
>-			return Arrows_keymap[direction % 4];
>-		case 0x25: /* left */
>-			return Arrows_keymap[(3 + direction) % 4];
>-	}
>-
>-	return key;
>-}
>-
>-static void GapiTransform(GapiInfo *gapiInfo, LONG *x, LONG *y)
>-{
>-    if(gapiInfo->hiresFix)
>-    {
>-	*x *= 2;
>-	*y *= 2;
>-    }
>-
>-    // 0 3 0
>-    if((!gapiInfo->userOrientation && gapiInfo->systemOrientation && !gapiInfo->gapiOrientation) ||
>-    // 3 0 3
>-       (gapiInfo->userOrientation && !gapiInfo->systemOrientation && gapiInfo->gapiOrientation) ||
>-    // 3 0 0
>-       (gapiInfo->userOrientation && !gapiInfo->systemOrientation && !gapiInfo->gapiOrientation))
>-    {
>-	Sint16 temp = *x;
>-        *x = SDL_VideoSurface->w - *y;
>-        *y = temp;
>-    }
>-    else
>-    // 0 0 0
>-    if((!gapiInfo->userOrientation && !gapiInfo->systemOrientation && !gapiInfo->gapiOrientation) ||
>-    // 0 0 3
>-      (!gapiInfo->userOrientation && !gapiInfo->systemOrientation && gapiInfo->gapiOrientation))
>-    {
>-	// without changes
>-	// *x = *x;
>-	// *y = *y;
>-    }
>-    // default
>-    else
>-    {
>-	// without changes
>-	// *x = *x;
>-	// *y = *y;
>-    }
>-}
>-#endif 
>-
>-
> /* The main Win32 event handler */
> LRESULT DIB_HandleMessage(_THIS, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
> {
>@@ -138,16 +74,6 @@
> 		case WM_KEYDOWN: {
> 			SDL_keysym keysym;
> 
>-#ifdef SDL_VIDEO_DRIVER_GAPI
>-			if(this->hidden->gapiInfo)
>-			{
>-				// Drop GAPI artefacts
>-				if (wParam == 0x84 || wParam == 0x5B)
>-					return 0;
>-
>-				wParam = rotateKey(wParam, this->hidden->gapiInfo->coordinateTransform);
>-			}
>-#endif 
> 			/* Ignore repeated keys */
> 			if ( lParam&REPEATED_KEYMASK ) {
> 				return(0);
>@@ -204,6 +130,7 @@
> 				}
> 			}
> #endif /* NO_GETKEYBOARDSTATE */
>+
> 			posted = SDL_PrivateKeyboard(SDL_PRESSED,
> 				TranslateKey(wParam,HIWORD(lParam),&keysym,1));
> 		}
>@@ -213,17 +140,6 @@
> 		case WM_KEYUP: {
> 			SDL_keysym keysym;
> 
>-#ifdef SDL_VIDEO_DRIVER_GAPI
>-			if(this->hidden->gapiInfo)
>-			{
>-				// Drop GAPI artifacts
>-				if (wParam == 0x84 || wParam == 0x5B)
>-					return 0;
>-	
>-				wParam = rotateKey(wParam, this->hidden->gapiInfo->coordinateTransform);
>-			}
>-#endif
>-
> 			switch (wParam) {
> 				case VK_CONTROL:
> 					if ( lParam&EXTENDED_KEYMASK )
>@@ -233,7 +149,7 @@
> 					break;
> 				case VK_SHIFT:
> 					/* EXTENDED trick doesn't work here */
>-					{
>+				{
> 					Uint8 *state = SDL_GetKeyState(NULL);
> 					if (state[SDLK_LSHIFT] == SDL_PRESSED && !(GetKeyState(VK_LSHIFT) & 0x8000)) {
> 						wParam = VK_LSHIFT;
>@@ -251,8 +167,8 @@
> 						else
> 							wParam = VK_LSHIFT;
> 					}
>-					}
> 					break;
>+				}
> 				case VK_MENU:
> 					if ( lParam&EXTENDED_KEYMASK )
> 						wParam = VK_RMENU;
>@@ -273,7 +189,7 @@
> 		case WM_SYSCOMMAND: {
> 			const DWORD val = (DWORD) (wParam & 0xFFF0);
> 			if ((val == SC_SCREENSAVE) || (val == SC_MONITORPOWER)) {
>-				if (this->hidden->dibInfo && !allow_screensaver) {
>+				if (this->hidden && !allow_screensaver) {
> 					/* Note that this doesn't stop anything on Vista
> 					   if the screensaver has a password. */
> 					return(0);
>@@ -308,29 +224,14 @@
> 	return(DefWindowProc(hwnd, msg, wParam, lParam));
> }
> 
>-#ifdef _WIN32_WCE
>-static BOOL GetLastStylusPos(POINT* ptLast)
>+void DIB_GenerateMouseMotionEvent(_THIS)
> {
>-    BOOL bResult = FALSE;
>-    UINT nRet;
>-    GetMouseMovePoints(ptLast, 1, &nRet);
>-    if ( nRet == 1 ) {
>-        ptLast->x /= 4;
>-        ptLast->y /= 4;
>-        bResult = TRUE;
>-    }
>-    return bResult;
>-}
>-#endif
>-
>-static void DIB_GenerateMouseMotionEvent(_THIS)
>-{
> 	extern int mouse_relative;
> 	extern int posted;
> 
> 	POINT mouse;
> #ifdef _WIN32_WCE
>-	if ( !GetCursorPos(&mouse) && !GetLastStylusPos(&mouse) ) return;
>+	if ( !GetCursorPos(&mouse) && !WinCE_GetLastStylusPos(&mouse) ) return;
> #else
> 	if ( !GetCursorPos(&mouse) ) return;
> #endif
>@@ -349,10 +250,6 @@
> 		}
> 	} else {
> 		ScreenToClient(SDL_Window, &mouse);
>-#ifdef SDL_VIDEO_DRIVER_GAPI
>-       if (SDL_VideoSurface && this->hidden->gapiInfo)
>-			GapiTransform(this->hidden->gapiInfo, &mouse.x, &mouse.y);
>-#endif
> 		posted = SDL_PrivateMouseMotion(0, 0, (Sint16)mouse.x, (Sint16)mouse.y);
> 	}
> }
>@@ -372,11 +269,8 @@
> 	}
> }
> 
>-static HKL hLayoutUS = NULL;
>-
> void DIB_InitOSKeymap(_THIS)
> {
>-	int	i;
> #ifndef _WIN32_WCE
> 	char	current_layout[KL_NAMELENGTH];
> 
>@@ -404,11 +298,12 @@
> 		hLayoutUS = GetKeyboardLayout(0);
> 	}
> 	LoadKeyboardLayout(current_layout, 0);
>+
>+	int i = 0;
>+	for(; i < SDLK_LAST; ++i) VK_keymap[i] = i;
> #endif // _WIN32_WCE >=420
> #endif
> 	/* Map the VK keysyms */
>-	for ( i=0; i<SDL_arraysize(VK_keymap); ++i )
>-		VK_keymap[i] = SDLK_UNKNOWN;
> 
> 	VK_keymap[VK_BACK] = SDLK_BACKSPACE;
> 	VK_keymap[VK_TAB] = SDLK_TAB;
>@@ -488,6 +383,7 @@
> 	VK_keymap[VK_DOWN] = SDLK_DOWN;
> 	VK_keymap[VK_RIGHT] = SDLK_RIGHT;
> 	VK_keymap[VK_LEFT] = SDLK_LEFT;
>+
> 	VK_keymap[VK_INSERT] = SDLK_INSERT;
> 	VK_keymap[VK_HOME] = SDLK_HOME;
> 	VK_keymap[VK_END] = SDLK_END;
>@@ -529,24 +425,18 @@
> 	VK_keymap[VK_SNAPSHOT] = SDLK_PRINT;
> 	VK_keymap[VK_CANCEL] = SDLK_BREAK;
> 	VK_keymap[VK_APPS] = SDLK_MENU;
>-
>-	Arrows_keymap[3] = 0x25;
>-	Arrows_keymap[2] = 0x26;
>-	Arrows_keymap[1] = 0x27;
>-	Arrows_keymap[0] = 0x28;
> }
> 
>-#define EXTKEYPAD(keypad) ((scancode & 0x100)?(mvke):(keypad))
>+#define EXTKEYPAD(scancode, keypad) ((scancode & 0x100)?(mvke):(keypad))
> 
>-static int SDL_MapVirtualKey(int scancode, int vkey)
>+UINT SDL_MapVirtualKey(UINT scancode, WPARAM vkey)
> {
>-#ifndef _WIN32_WCE
>-	int	mvke  = MapVirtualKeyEx(scancode & 0xFF, 1, hLayoutUS);
>-#else
>-	int	mvke  = MapVirtualKey(scancode & 0xFF, 1);
>-#endif
>+	switch(vkey)
>+	{
>+        	/* No VK_ code for the keypad enter key */
>+		case VK_RETURN:
>+		    return scancode & 0x100 ? SDLK_KP_ENTER : VK_RETURN;
> 
>-	switch(vkey) {
> 		/* These are always correct */
> 		case VK_DIVIDE:
> 		case VK_MULTIPLY:
>@@ -565,44 +455,48 @@
> 		case VK_SNAPSHOT:
> 		case VK_PAUSE:
> 			return vkey;
>-	}	
>-	switch(mvke) {
>+	}
>+
>+#ifdef _WIN32_WCE
>+	//const UINT mvke  = MapVirtualKey(scancode & 0xFF, 1);
>+	return vkey;
>+#else
>+	// get virtual key from scancode
>+	const UINT mvke  = MapVirtualKeyEx(scancode & 0xFF, 1, hLayoutUS);
>+
>+	switch(mvke)
>+	{
> 		/* Distinguish between keypad and extended keys */
>-		case VK_INSERT: return EXTKEYPAD(VK_NUMPAD0);
>-		case VK_DELETE: return EXTKEYPAD(VK_DECIMAL);
>-		case VK_END:    return EXTKEYPAD(VK_NUMPAD1);
>-		case VK_DOWN:   return EXTKEYPAD(VK_NUMPAD2);
>-		case VK_NEXT:   return EXTKEYPAD(VK_NUMPAD3);
>-		case VK_LEFT:   return EXTKEYPAD(VK_NUMPAD4);
>-		case VK_CLEAR:  return EXTKEYPAD(VK_NUMPAD5);
>-		case VK_RIGHT:  return EXTKEYPAD(VK_NUMPAD6);
>-		case VK_HOME:   return EXTKEYPAD(VK_NUMPAD7);
>-		case VK_UP:     return EXTKEYPAD(VK_NUMPAD8);
>-		case VK_PRIOR:  return EXTKEYPAD(VK_NUMPAD9);
>+		case VK_INSERT: return EXTKEYPAD(scancode, VK_NUMPAD0);
>+		case VK_DELETE: return EXTKEYPAD(scancode, VK_DECIMAL);
>+		case VK_END:    return EXTKEYPAD(scancode, VK_NUMPAD1);
>+		case VK_DOWN:   return EXTKEYPAD(scancode, VK_NUMPAD2);
>+		case VK_NEXT:   return EXTKEYPAD(scancode, VK_NUMPAD3);
>+		case VK_LEFT:   return EXTKEYPAD(scancode, VK_NUMPAD4);
>+		case VK_CLEAR:  return EXTKEYPAD(scancode, VK_NUMPAD5);
>+		case VK_RIGHT:  return EXTKEYPAD(scancode, VK_NUMPAD6);
>+		case VK_HOME:   return EXTKEYPAD(scancode, VK_NUMPAD7);
>+		case VK_UP:     return EXTKEYPAD(scancode, VK_NUMPAD8);
>+		case VK_PRIOR:  return EXTKEYPAD(scancode, VK_NUMPAD9);
> 	}
>-	return mvke?mvke:vkey;
>+
>+	return 0 < mvke && mvke < SDLK_LAST ? mvke : vkey;
>+#endif
> }
> 
>-static SDL_keysym *TranslateKey(WPARAM vkey, UINT scancode, SDL_keysym *keysym, int pressed)
>+SDL_keysym *TranslateKey(WPARAM vkey, UINT scancode, SDL_keysym *keysym, int pressed)
> {
> 	/* Set the keysym information */
>-	keysym->scancode = (unsigned char) scancode;
>+	keysym->scancode = scancode;
> 	keysym->mod = KMOD_NONE;
> 	keysym->unicode = 0;
>-	
>-	if ((vkey == VK_RETURN) && (scancode & 0x100)) {
>-		/* No VK_ code for the keypad enter key */
>-		keysym->sym = SDLK_KP_ENTER;
>-	}
>-	else {
>-		keysym->sym = VK_keymap[SDL_MapVirtualKey(scancode, vkey)];
>-	}
>+	keysym->sym = VK_keymap[scancode ? SDL_MapVirtualKey(scancode, vkey) : vkey];
> 
>-	if ( pressed && SDL_TranslateUNICODE ) {
>+	if(pressed && SDL_TranslateUNICODE)
>+	{
> #ifdef NO_GETKEYBOARDSTATE
> 		/* Uh oh, better hope the vkey is close enough.. */
>-		if((keysym->sym == vkey) || (vkey > 0x7f))
>-		keysym->unicode = vkey;
>+		if((keysym->sym == vkey) || (vkey > 0x7f)) keysym->unicode = vkey;
> #else
> 		BYTE	keystate[256];
> 		Uint16	wchars[2];
>@@ -610,13 +504,14 @@
> 		GetKeyboardState(keystate);
> 		/* Numlock isn't taken into account in ToUnicode,
> 		 * so we handle it as a special case here */
>-		if ((keystate[VK_NUMLOCK] & 1) && vkey >= VK_NUMPAD0 && vkey <= VK_NUMPAD9)
>+		if((keystate[VK_NUMLOCK] & 1) && vkey >= VK_NUMPAD0 && vkey <= VK_NUMPAD9)
> 		{
>-			keysym->unicode = vkey - VK_NUMPAD0 + '0';
>+		    keysym->unicode = vkey - VK_NUMPAD0 + '0';
> 		}
>-		else if (SDL_ToUnicode((UINT)vkey, scancode, keystate, wchars, sizeof(wchars)/sizeof(wchars[0]), 0) > 0)
>+		else
>+		if(SDL_ToUnicode((UINT)vkey, scancode, keystate, wchars, sizeof(wchars)/sizeof(wchars[0]), 0) > 0)
> 		{
>-			keysym->unicode = wchars[0];
>+		    keysym->unicode = wchars[0];
> 		}
> #endif /* NO_GETKEYBOARDSTATE */
> 	}
>@@ -636,6 +531,7 @@
> 		);
> 	}
> #endif
>+
> 	return(keysym);
> }
> 
>Index: src/video/windib/SDL_dibvideo.c
>===================================================================
>--- src/video/windib/SDL_dibvideo.c	(revision 29)
>+++ src/video/windib/SDL_dibvideo.c	(revision 41)
>@@ -34,7 +34,6 @@
> #include "../SDL_pixels_c.h"
> #include "../../events/SDL_sysevents.h"
> #include "../../events/SDL_events_c.h"
>-#include "SDL_gapidibvideo.h"
> #include "SDL_dibvideo.h"
> #include "../wincommon/SDL_syswm_c.h"
> #include "../wincommon/SDL_sysmouse_c.h"
>@@ -42,6 +41,12 @@
> #include "../wincommon/SDL_wingl_c.h"
> 
> #ifdef _WIN32_WCE
>+#define SHFS_SHOWTASKBAR        0x0001
>+#define SHFS_HIDETASKBAR        0x0002
>+#define SHFS_SHOWSIPBUTTON      0x0004
>+#define SHFS_HIDESIPBUTTON      0x0008
>+#define SHFS_SHOWSTARTICON      0x0010
>+#define SHFS_HIDESTARTICON      0x0020
> 
> #ifndef DM_DISPLAYORIENTATION
> #define DM_DISPLAYORIENTATION 0x00800000L
>@@ -83,9 +88,8 @@
> #define PC_NOCOLLAPSE	0
> #endif
> 
>-#ifdef _WIN32_WCE
>-// defined and used in SDL_sysevents.c
>-extern HINSTANCE aygshell;
>+#ifndef _T
>+#define _T(x)           L##x
> #endif
> 
> /* Initialization/Query functions */
>@@ -129,9 +133,6 @@
> {
> 	if ( device ) {
> 		if ( device->hidden ) {
>-			if ( device->hidden->dibInfo ) {
>-				SDL_free( device->hidden->dibInfo );
>-			}
> 			SDL_free(device->hidden);
> 		}
> 		if ( device->gl_data ) {
>@@ -153,12 +154,6 @@
> 				SDL_malloc((sizeof *device->hidden));
> 		if(device->hidden){
> 			SDL_memset(device->hidden, 0, (sizeof *device->hidden));
>-			device->hidden->dibInfo = (DibInfo *)SDL_malloc((sizeof(DibInfo)));
>-			if(device->hidden->dibInfo == NULL)
>-			{
>-				SDL_free(device->hidden);
>-				device->hidden = NULL;
>-			}
> 		}
> 		
> 		device->gl_data = (struct SDL_PrivateGLData *)
>@@ -170,7 +165,6 @@
> 		DIB_DeleteDevice(device);
> 		return(NULL);
> 	}
>-	SDL_memset(device->hidden->dibInfo, 0, (sizeof *device->hidden->dibInfo));
> 	SDL_memset(device->gl_data, 0, (sizeof *device->gl_data));
> 
> 	/* Set the function pointers */
>@@ -359,6 +353,15 @@
> #ifdef _WIN32_WCE
> 	settings.dmFields = DM_DISPLAYQUERYORIENTATION;
> 	this->hidden->supportRotation = ChangeDisplaySettingsEx(NULL, &settings, NULL, CDS_TEST, NULL) == DISP_CHANGE_SUCCESSFUL;
>+
>+	// aygshell.dll
>+	this->hidden->hAygShell = LoadLibrary(_T("\\windows\\aygshell.dll"));
>+
>+	if(0 == this->hidden->hAygShell)
>+    	    this->hidden->hAygShell = LoadLibrary(_T("aygshell.dll"));
>+
>+	this->hidden->SHFullScreen = (0 != this->hidden->hAygShell ?
>+            (PFNSHFullScreen) GetProcAddress(this->hidden->hAygShell, _T("SHFullScreen")) : 0);
> #endif
> 	/* Query for the desktop resolution */
> 	SDL_desktop_mode.dmSize = sizeof(SDL_desktop_mode);
>@@ -684,6 +687,10 @@
> #if defined(_WIN32_WCE)
> 	if ( flags & SDL_FULLSCREEN )
> 		video->flags |= SDL_FULLSCREEN;
>+
>+        ShowWindow(FindWindow(TEXT("HHTaskBar"), NULL), SW_HIDE);
>+        if(this->hidden->SHFullScreen)
>+    	    this->hidden->SHFullScreen(SDL_Window, SHFS_HIDETASKBAR | SHFS_HIDESTARTICON | SHFS_HIDESIPBUTTON);
> #endif
> 
> #ifndef NO_CHANGEDISPLAYSETTINGS
>@@ -1177,6 +1184,10 @@
> 
> 	/* Destroy the window and everything associated with it */
> 	if ( SDL_Window ) {
>+#ifdef _WIN32_WCE
>+	    if(this->hidden->SHFullScreen)
>+		this->hidden->SHFullScreen(SDL_Window, SHFS_SHOWTASKBAR | SHFS_SHOWSTARTICON | SHFS_SHOWSIPBUTTON);
>+#endif
> 		/* Delete the screen bitmap (also frees screen->pixels) */
> 		if ( this->screen ) {
> 			if ( grab_palette ) {
>@@ -1213,16 +1224,6 @@
> 		DIB_DestroyWindow(this);
> 
> 		SDL_Window = NULL;
>-
>-#if defined(_WIN32_WCE)
>-
>-// Unload wince aygshell library to prevent leak
>-		if( aygshell ) 
>-		{
>-			FreeLibrary(aygshell);
>-			aygshell = NULL;
>-		}
>-#endif
> 	}
> 
> 	for ( i=0; i < SDL_arraysize(SDL_modelist); ++i ) {
>@@ -1236,6 +1237,13 @@
> 		SDL_modelist[i] = NULL;
> 		SDL_nummodes[i] = 0;
> 	}
>+
>+#ifdef _WIN32_WCE
>+    ShowWindow(FindWindow(TEXT("HHTaskBar"), NULL), SW_SHOW);
>+
>+    if(this->hidden->hAygShell) FreeLibrary(this->hidden->hAygShell);
>+    this->hidden->hAygShell = 0;
>+#endif
> }
> 
> /* Exported for the windows message loop only */
>@@ -1273,6 +1281,20 @@
> 			DIB_RealizePalette(this);
> 		}
> 	}
>+#ifndef _WIN32_WCE
>+    if(minimized || !active)
>+    {
>+        if(this->hidden->SHFullScreen)
>+            this->hidden->SHFullScreen(SDL_Window, SHFS_SHOWTASKBAR | SHFS_SHOWSTARTICON | SHFS_SHOWSIPBUTTON);
>+        ShowWindow(FindWindow(TEXT("HHTaskBar"), NULL), SW_SHOW);
>+    }
>+    else
>+    {
>+        ShowWindow(FindWindow(TEXT("HHTaskBar"), NULL), SW_HIDE);
>+        if(this->hidden->SHFullScreen)
>+    	    this->hidden->SHFullScreen(SDL_Window, SHFS_HIDETASKBAR | SHFS_HIDESTARTICON | SHFS_HIDESIPBUTTON);
>+    }
>+#endif
> }
> static void DIB_RealizePalette(_THIS)
> {
>Index: src/video/windib/SDL_dibvideo.h
>===================================================================
>--- src/video/windib/SDL_dibvideo.h	(revision 29)
>+++ src/video/windib/SDL_dibvideo.h	(revision 41)
>@@ -27,9 +27,11 @@
> #define WIN32_LEAN_AND_MEAN
> #include <windows.h>
> 
>+typedef BOOL  (*PFNSHFullScreen)(HWND, DWORD);
> 
>+
> /* Private display data */
>-struct DibInfo {
>+struct  SDL_PrivateVideoData {
> 	HBITMAP screen_bmp;
>     HPALETTE screen_pal;
>     LOGPALETTE *screen_logpal;
>@@ -40,20 +42,24 @@
>     SDL_Rect **SDL_modelist[NUM_MODELISTS];
>         
> #ifdef _WIN32_WCE
>-	int supportRotation; /* for Pocket PC devices */
>-	DWORD origRotation; /* for Pocket PC devices */
>+    int supportRotation; /* for Pocket PC devices */
>+    DWORD origRotation; /* for Pocket PC devices */
>+
>+    // aygshell.dll
>+    HMODULE         hAygShell;
>+    PFNSHFullScreen SHFullScreen;
> #endif
> 
>     /* Screensaver settings */
>     int allow_screensaver;
> };
> /* Old variable names */
>-#define screen_bmp		(this->hidden->dibInfo->screen_bmp)
>-#define screen_pal		(this->hidden->dibInfo->screen_pal)
>-#define screen_logpal		(this->hidden->dibInfo->screen_logpal)
>-#define grab_palette		(this->hidden->dibInfo->grab_palette)
>-#define SDL_nummodes		(this->hidden->dibInfo->SDL_nummodes)
>-#define SDL_modelist		(this->hidden->dibInfo->SDL_modelist)
>-#define allow_screensaver	(this->hidden->dibInfo->allow_screensaver)
>+#define screen_bmp		(this->hidden->screen_bmp)
>+#define screen_pal		(this->hidden->screen_pal)
>+#define screen_logpal		(this->hidden->screen_logpal)
>+#define grab_palette		(this->hidden->grab_palette)
>+#define SDL_nummodes		(this->hidden->SDL_nummodes)
>+#define SDL_modelist		(this->hidden->SDL_modelist)
>+#define allow_screensaver	(this->hidden->allow_screensaver)
> 
> #endif /* _SDL_dibvideo_h */
>Index: src/video/windib/SDL_gapidibvideo.h
>===================================================================
>--- src/video/windib/SDL_gapidibvideo.h	(revision 29)
>+++ src/video/windib/SDL_gapidibvideo.h	(revision 41)
>@@ -24,33 +24,6 @@
> #ifndef _SDL_gapidibvideo_h
> #define _SDL_gapidibvideo_h
> 
>-#define WIN32_LEAN_AND_MEAN
>-#include <windows.h>
>+// separate GAPI and DIB
> 
>-/* Hidden "this" pointer for the video functions */
>-#define _THIS	SDL_VideoDevice *this
>-
>-/* typedef these to be able to define pointers, but still force everybody who
>- * wants to access them to include the corresponding header */
>-typedef struct GapiInfo GapiInfo;
>-typedef struct DibInfo DibInfo;
>-
>-/* for PDA */
>-typedef enum
>-{
>-	SDL_ORIENTATION_UP,
>-	SDL_ORIENTATION_DOWN,
>-	SDL_ORIENTATION_LEFT,
>-	SDL_ORIENTATION_RIGHT
>-} SDL_ScreenOrientation;
>-
>-/* Private display data shared by gapi and windib*/
>-struct SDL_PrivateVideoData {
>-	int supportRotation; /* for Pocket PC devices */
>-	DWORD origRotation; /* for Pocket PC devices */
>-	
>-	GapiInfo* gapiInfo;
>-	DibInfo* dibInfo;
>-};
>-
> #endif
>Index: include/SDL_endian.h
>===================================================================
>Index: configure.in
>===================================================================

Actions: View | Diff

Attachments on bug 1154: 590

We are currently migrating Bugzilla to GitHub issues.Any changes made to the bug tracker now will be lost, so please do not post new bugs or make changes to them.When we're done, all bug URLs will redirect to their equivalent location on the new bug tracker.

We are currently migrating Bugzilla to GitHub issues.
Any changes made to the bug tracker now will be lost, so please do not post new bugs or make changes to them.
When we're done, all bug URLs will redirect to their equivalent location on the new bug tracker.