From 2b4b30d15cd602ecc6e380d99771149bd289c1bb Mon Sep 17 00:00:00 2001
From: Sam Lantinga <slouken@lokigames.com>
Date: Fri, 11 May 2001 01:13:35 +0000
Subject: [PATCH] Added initial support for Nano-X (thanks Hsieh-Fu!)

---
 README.NanoX                     |  81 +++++
 configure.in                     |  45 +++
 docs.html                        |   1 +
 include/SDL_syswm.h              |  17 +-
 src/video/Makefile.am            |   2 +-
 src/video/SDL_sysvideo.h         |   3 +
 src/video/SDL_video.c            |   3 +
 src/video/nanox/Makefile.am      |  20 ++
 src/video/nanox/SDL_nxevents.c   | 364 ++++++++++++++++++++
 src/video/nanox/SDL_nxevents_c.h |  31 ++
 src/video/nanox/SDL_nximage.c    | 166 +++++++++
 src/video/nanox/SDL_nximage_c.h  |  34 ++
 src/video/nanox/SDL_nxmodes.c    |  84 +++++
 src/video/nanox/SDL_nxmodes_c.h  |  33 ++
 src/video/nanox/SDL_nxmouse.c    |  81 +++++
 src/video/nanox/SDL_nxmouse_c.h  |   6 +
 src/video/nanox/SDL_nxvideo.c    | 557 +++++++++++++++++++++++++++++++
 src/video/nanox/SDL_nxvideo.h    |  89 +++++
 src/video/nanox/SDL_nxwm.c       |  63 ++++
 src/video/nanox/SDL_nxwm_c.h     |  31 ++
 20 files changed, 1709 insertions(+), 2 deletions(-)
 create mode 100644 README.NanoX
 create mode 100644 src/video/nanox/Makefile.am
 create mode 100644 src/video/nanox/SDL_nxevents.c
 create mode 100644 src/video/nanox/SDL_nxevents_c.h
 create mode 100644 src/video/nanox/SDL_nximage.c
 create mode 100644 src/video/nanox/SDL_nximage_c.h
 create mode 100644 src/video/nanox/SDL_nxmodes.c
 create mode 100644 src/video/nanox/SDL_nxmodes_c.h
 create mode 100644 src/video/nanox/SDL_nxmouse.c
 create mode 100644 src/video/nanox/SDL_nxmouse_c.h
 create mode 100644 src/video/nanox/SDL_nxvideo.c
 create mode 100644 src/video/nanox/SDL_nxvideo.h
 create mode 100644 src/video/nanox/SDL_nxwm.c
 create mode 100644 src/video/nanox/SDL_nxwm_c.h

diff --git a/README.NanoX b/README.NanoX
new file mode 100644
index 000000000..a9570a970
--- /dev/null
+++ b/README.NanoX
@@ -0,0 +1,81 @@
+  =================================================================
+  Patch version 0.8 of SDL(Simple DirectMedia Layer) for Nano-X API
+  =================================================================
+  
+  Author: Hsieh-Fu Tsai, clare@setabox.com
+
+  There are two patch files in this package. 
+
+  1. The first patch file, nanox.patch, is to fix a bug in Nano-X. 
+     This patch is proposed by Gary James (gjames@twcny.rr.com).
+
+  It fixes the client side GrClose(). In the original version, 
+  GrOpen() can only be called once. When the GrOpen() is called at 
+  the second time, the program will terminate. In order to prevent
+  this situation, we need to insert "nxSocket = -1" after 
+  "close(nxSocket)" in GrClose(). If you do not have this problem,
+  you may skip this step. 
+
+  =============
+  Quick Install 
+  =============
+
+  1. ./configure --disable-video-x11 --disable-video-fbcon \ 
+       --enable-video-nanox \ 
+       --with-nanox-pixel-type=[rgb/0888/888/565/555/332/pal] 
+  2. make clean 
+  3. make 
+  4. make install (as root) 
+
+  ============
+  Nitty-gritty 
+  ============
+
+  --with-nanox-pixel-type=[rgb/0888/888/565/555/332/pal] 
+
+  If the wrong pixel type is used, the program will crash when the 
+  sub-routine updates the screen. This option depends on SCREEN_PIXTYPE 
+  which is defined in Microwin0.89pre7/src/config. SCREEN_PIXTYPE 
+  is used to define the pixel type in Microwindows/Nano-X. 
+  I only test the program when the pixel type is in "rgb" 
+  (Microwin under X11) or "888" (framebuffer in 24-bit).
+
+  --enable-nanox-debug           Show debug messages 
+  --enable-nanox-share-memory    Use shared-memory to speed up 
+
+  =============================================
+  Some programs can be used to test this patch. 
+  =============================================
+
+  1. http://www.cs.berkeley.edu/~weimer/atris (a tetris-like game) 
+  2. http://www.libsdl.org/projects/newvox/
+  3. http://www.libsdl.org/projects/xflame/
+  4. http://www.libsdl.org/projects/optimum/ 
+  5. http://www.gnugeneration.com/software/loop/ 
+    
+  =========
+  Todo List 
+  =========
+
+  1. Create hardware surface
+  2. Create YUVOverlay on hardware
+  3. Use OpenGL
+  4. Gamma correction
+  5. Hide/Change mouse pointer
+
+  =====================
+  Supporting Institutes
+  =====================
+  
+  Many thanks to go to Setabox Co., Ltd. and CML (Communication and
+  Multimedia Laboratory, http://www.cmlab.csie.ntu.edu.tw/) in the 
+  Department of Computer Science and Information Engineering of 
+  National Taiwan University for supporting this porting project.
+  
+  ===================
+  Contact Information
+  ===================
+
+  Welcome to give me any suggestion and to report bugs.
+  My e-mail address : clare@setabox.com or niky@cmlab.csie.ntu.edu.tw
+  
diff --git a/configure.in b/configure.in
index e37ca55cc..81bc8f95b 100644
--- a/configure.in
+++ b/configure.in
@@ -403,6 +403,49 @@ CheckNASM()
     fi
 }
 
+dnl Find the nanox include and library directories
+CheckNANOX()
+{
+	AC_ARG_ENABLE(video-nanox,
+		[  --enable-video-nanox use nanox video driver [default=no]],
+	        , enable_video_nanox=no)
+	AC_ARG_ENABLE(nanox-debug,  
+		[  --enable-nanox-debug print debug messages [default=no]],
+		, enable_nanox_debug=no)
+	AC_ARG_ENABLE(nanox-share-memory,  
+		[  --enable-nanox-share-memory use share memory [default=no]],
+		, enable_nanox_share_memory=no)
+
+	AC_ARG_WITH(nanox_pixel_type, 
+		[  --with-nanox-pixel-type=[rgb/0888/888/565/555/332/pal]])
+
+	if test x$enable_video = xyes -a x$enable_video_nanox = xyes; then
+		if test x$enable_nanox_debug = xyes; then
+			CFLAGS="$CFLAGS -DENABLE_NANOX_DEBUG"
+		fi
+
+		if test x$enable_nanox_share_memory = xyes; then
+			CFLAGS="$CFLAGS -DNANOX_SHARE_MEMORY"
+		fi
+
+		case "$with_nanox_pixel_type" in
+			 rgb) CFLAGS="$CFLAGS -DNANOX_PIXEL_RGB" ;;
+			0888) CFLAGS="$CFLAGS -DNANOX_PIXEL_0888" ;;
+			 888) CFLAGS="$CFLAGS -DNANOX_PIXEL_888"  ;;
+			 565) CFLAGS="$CFLAGS -DNANOX_PIXEL_565"  ;;
+			 555) CFLAGS="$CFLAGS -DNANOX_PIXEL_555"  ;;
+			 332) CFLAGS="$CFLAGS -DNANOX_PIXEL_332"  ;;
+			 pal) CFLAGS="$CFLAGS -DNANOX_PIXEL_PAL"  ;;
+			   *) AC_MSG_ERROR([Invalid nanox_pixel_type]);;
+		esac
+
+		CFLAGS="$CFLAGS $X_CFLAGS -DENABLE_NANOX"
+		SYSTEM_LIBS="$SYSTEM_LIBS -lnano-X"
+		VIDEO_SUBDIRS="$VIDEO_SUBDIRS nanox"
+		VIDEO_DRIVERS="$VIDEO_DRIVERS nanox/libvideo_nanox.la"
+	fi
+}
+
 dnl Find the X11 include and library directories
 CheckX11()
 {
@@ -1042,6 +1085,7 @@ case "$target" in
         CheckESD
         CheckNAS
         CheckX11
+        CheckNANOX
         CheckDGA
         CheckFBCON
         CheckGGI
@@ -1921,6 +1965,7 @@ src/video/Makefile
 src/video/cybergfx/Makefile
 src/video/x11/Makefile
 src/video/dga/Makefile
+src/video/nanox/Makefile
 src/video/fbcon/Makefile
 src/video/ggi/Makefile
 src/video/maccommon/Makefile
diff --git a/docs.html b/docs.html
index 9d3d14bac..c51be1903 100644
--- a/docs.html
+++ b/docs.html
@@ -16,6 +16,7 @@ <H2>
 Major changes since SDL 1.0.0:
 </H2>
 <UL>
+	<LI> 1.2.1: Added initial support for Nano-X (thanks Hsieh-Fu!)
 	<LI> 1.2.1: Fixed endian detection on IA64 architectures (thanks Bill!)
 	<LI> 1.2.1: Added --disable-dga configure option to disable DGA
 	<LI> 1.2.1: Fixed stuck keys when changing the video mode
diff --git a/include/SDL_syswm.h b/include/SDL_syswm.h
index a7c1c527e..2df9b8044 100644
--- a/include/SDL_syswm.h
+++ b/include/SDL_syswm.h
@@ -50,7 +50,7 @@ typedef struct SDL_SysWMinfo SDL_SysWMinfo;
 
 /* This is the structure for custom window manager events */
 #if (defined(unix) || defined(__unix__) || defined(_AIX)) && \
-    (!defined(DISABLE_X11) && !defined(__CYGWIN32__))
+    (defined(ENABLE_X11) && !defined(__CYGWIN32__))
  /* AIX is unix, of course, but the native compiler CSet doesn't define unix */
 #include <X11/Xlib.h>
 #include <X11/Xatom.h>
@@ -95,6 +95,21 @@ typedef struct {
 	} info;
 } SDL_SysWMinfo;
 
+#elif defined(ENABLE_NANOX)
+#include <microwin/nano-X.h>
+
+/* The generic custom event structure */
+struct SDL_SysWMmsg {
+	SDL_version version;
+	int data;
+};
+
+/* The windows custom window manager information structure */
+typedef struct {
+	SDL_version version ;
+	GR_WINDOW_ID window ;	/* The display window */
+} SDL_SysWMinfo;
+
 #elif defined(WIN32)
 #include <windows.h>
 
diff --git a/src/video/Makefile.am b/src/video/Makefile.am
index 0197c3d88..36eedbfee 100644
--- a/src/video/Makefile.am
+++ b/src/video/Makefile.am
@@ -5,7 +5,7 @@ noinst_LTLIBRARIES = libvideo.la
 
 # Define which subdirectories need to be built
 SUBDIRS = @VIDEO_SUBDIRS@
-DIST_SUBDIRS = dummy x11 dga fbcon svga ggi aalib \
+DIST_SUBDIRS = dummy x11 dga nanox fbcon svga ggi aalib \
                wincommon windib windx5 \
                maccommon macdsp macrom bwindow photon cybergfx
 
diff --git a/src/video/SDL_sysvideo.h b/src/video/SDL_sysvideo.h
index 7306207df..ae079c396 100644
--- a/src/video/SDL_sysvideo.h
+++ b/src/video/SDL_sysvideo.h
@@ -331,6 +331,9 @@ extern VideoBootStrap X11_bootstrap;
 #ifdef ENABLE_DGA
 extern VideoBootStrap DGA_bootstrap;
 #endif
+#ifdef ENABLE_NANOX
+extern VideoBootStrap NX_bootstrap;
+#endif
 #ifdef ENABLE_FBCON
 extern VideoBootStrap FBCON_bootstrap;
 #endif
diff --git a/src/video/SDL_video.c b/src/video/SDL_video.c
index 7765ef51e..6c95b1fdc 100644
--- a/src/video/SDL_video.c
+++ b/src/video/SDL_video.c
@@ -51,6 +51,9 @@ static VideoBootStrap *bootstrap[] = {
 #ifdef ENABLE_DGA
 	&DGA_bootstrap,
 #endif
+#ifdef ENABLE_NANOX
+	&NX_bootstrap,
+#endif
 #ifdef ENABLE_FBCON
 	&FBCON_bootstrap,
 #endif
diff --git a/src/video/nanox/Makefile.am b/src/video/nanox/Makefile.am
new file mode 100644
index 000000000..70c41e36e
--- /dev/null
+++ b/src/video/nanox/Makefile.am
@@ -0,0 +1,20 @@
+
+## Makefile.am for SDL using the nanox video driver
+
+noinst_LTLIBRARIES = libvideo_nanox.la
+libvideo_nanox_la_SOURCES = $(NANOX_SRCS)
+
+# The SDL nanox video driver sources
+NANOX_SRCS =         \
+    SDL_nxmodes.c    \
+    SDL_nxmodes_c.h  \
+    SDL_nxmouse.c    \
+    SDL_nxmouse_c.h  \
+    SDL_nxvideo.c    \
+    SDL_nxvideo.h    \
+    SDL_nxwm.c       \
+    SDL_nxwm_c.h     \
+    SDL_nxevents.c   \
+    SDL_nxevents_c.h \
+    SDL_nximage.c    \
+    SDL_nximage_c.h
diff --git a/src/video/nanox/SDL_nxevents.c b/src/video/nanox/SDL_nxevents.c
new file mode 100644
index 000000000..6acd4b4f3
--- /dev/null
+++ b/src/video/nanox/SDL_nxevents.c
@@ -0,0 +1,364 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga
+    Copyright (C) 2001  Hsieh-Fu Tsai
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@devolution.com
+    
+    Hsieh-Fu Tsai
+    clare@setabox.com
+*/
+
+#include "SDL_keysym.h"
+#include "SDL_events_c.h"
+
+#include "SDL_nxevents_c.h"
+#include "SDL_nximage_c.h"
+
+// The translation tables from a nanox keysym to a SDL keysym
+static SDLKey NX_NONASCII_keymap [MWKEY_LAST + 1] ;
+
+void NX_InitOSKeymap (_THIS)
+{
+    int i ;
+
+    Dprintf ("enter NX_InitOSKeymap\n") ;
+
+    // Map the nanox scancodes to SDL keysyms
+    for (i = 0; i < SDL_TABLESIZE (NX_NONASCII_keymap); ++ i)
+        NX_NONASCII_keymap [i] = SDLK_UNKNOWN ;
+
+    NX_NONASCII_keymap [MWKEY_LEFT        & 0xFF] = SDLK_LEFT ;
+    NX_NONASCII_keymap [MWKEY_RIGHT       & 0xFF] = SDLK_RIGHT ;
+    NX_NONASCII_keymap [MWKEY_UP          & 0xFF] = SDLK_UP ;
+    NX_NONASCII_keymap [MWKEY_DOWN        & 0xFF] = SDLK_DOWN ;
+    NX_NONASCII_keymap [MWKEY_INSERT      & 0xFF] = SDLK_INSERT ;
+    NX_NONASCII_keymap [MWKEY_DELETE      & 0xFF] = SDLK_DELETE ;
+    NX_NONASCII_keymap [MWKEY_HOME        & 0xFF] = SDLK_HOME ;
+    NX_NONASCII_keymap [MWKEY_END         & 0xFF] = SDLK_END ;
+    NX_NONASCII_keymap [MWKEY_PAGEUP      & 0xFF] = SDLK_PAGEUP ;
+    NX_NONASCII_keymap [MWKEY_PAGEDOWN    & 0xFF] = SDLK_PAGEDOWN ;
+
+    NX_NONASCII_keymap [MWKEY_KP0         & 0xFF] = SDLK_KP0 ;
+    NX_NONASCII_keymap [MWKEY_KP1         & 0xFF] = SDLK_KP1 ;
+    NX_NONASCII_keymap [MWKEY_KP2         & 0xFF] = SDLK_KP2 ;
+    NX_NONASCII_keymap [MWKEY_KP3         & 0xFF] = SDLK_KP3 ;
+    NX_NONASCII_keymap [MWKEY_KP4         & 0xFF] = SDLK_KP4 ;
+    NX_NONASCII_keymap [MWKEY_KP5         & 0xFF] = SDLK_KP5 ;
+    NX_NONASCII_keymap [MWKEY_KP6         & 0xFF] = SDLK_KP6 ;
+    NX_NONASCII_keymap [MWKEY_KP7         & 0xFF] = SDLK_KP7 ;
+    NX_NONASCII_keymap [MWKEY_KP8         & 0xFF] = SDLK_KP8 ;
+    NX_NONASCII_keymap [MWKEY_KP9         & 0xFF] = SDLK_KP9 ;
+    NX_NONASCII_keymap [MWKEY_KP_PERIOD   & 0xFF] = SDLK_KP_PERIOD ;
+    NX_NONASCII_keymap [MWKEY_KP_DIVIDE   & 0xFF] = SDLK_KP_DIVIDE ;
+    NX_NONASCII_keymap [MWKEY_KP_MULTIPLY & 0xFF] = SDLK_KP_MULTIPLY ;
+    NX_NONASCII_keymap [MWKEY_KP_MINUS    & 0xFF] = SDLK_KP_MINUS ;
+    NX_NONASCII_keymap [MWKEY_KP_PLUS     & 0xFF] = SDLK_KP_PLUS ;
+    NX_NONASCII_keymap [MWKEY_KP_ENTER    & 0xFF] = SDLK_KP_ENTER ;
+    NX_NONASCII_keymap [MWKEY_KP_EQUALS   & 0xFF] = SDLK_KP_EQUALS ;
+
+    NX_NONASCII_keymap [MWKEY_F1          & 0xFF] = SDLK_F1 ;
+    NX_NONASCII_keymap [MWKEY_F2          & 0xFF] = SDLK_F2 ;
+    NX_NONASCII_keymap [MWKEY_F3          & 0xFF] = SDLK_F3 ;
+    NX_NONASCII_keymap [MWKEY_F4          & 0xFF] = SDLK_F4 ;
+    NX_NONASCII_keymap [MWKEY_F5          & 0xFF] = SDLK_F5 ;
+    NX_NONASCII_keymap [MWKEY_F6          & 0xFF] = SDLK_F6 ;
+    NX_NONASCII_keymap [MWKEY_F7          & 0xFF] = SDLK_F7 ;
+    NX_NONASCII_keymap [MWKEY_F8          & 0xFF] = SDLK_F8 ;
+    NX_NONASCII_keymap [MWKEY_F9          & 0xFF] = SDLK_F9 ;
+    NX_NONASCII_keymap [MWKEY_F10         & 0xFF] = SDLK_F10 ;
+    NX_NONASCII_keymap [MWKEY_F11         & 0xFF] = SDLK_F11 ;
+    NX_NONASCII_keymap [MWKEY_F12         & 0xFF] = SDLK_F12 ;
+
+    NX_NONASCII_keymap [MWKEY_NUMLOCK     & 0xFF] = SDLK_NUMLOCK ;
+    NX_NONASCII_keymap [MWKEY_CAPSLOCK    & 0xFF] = SDLK_CAPSLOCK ;
+    NX_NONASCII_keymap [MWKEY_SCROLLOCK   & 0xFF] = SDLK_SCROLLOCK ;
+    NX_NONASCII_keymap [MWKEY_LSHIFT      & 0xFF] = SDLK_LSHIFT ;
+    NX_NONASCII_keymap [MWKEY_RSHIFT      & 0xFF] = SDLK_RSHIFT ;
+    NX_NONASCII_keymap [MWKEY_LCTRL       & 0xFF] = SDLK_LCTRL ;
+    NX_NONASCII_keymap [MWKEY_RCTRL       & 0xFF] = SDLK_RCTRL ;
+    NX_NONASCII_keymap [MWKEY_LALT        & 0xFF] = SDLK_LALT ;
+    NX_NONASCII_keymap [MWKEY_RALT        & 0xFF] = SDLK_RALT ;
+    NX_NONASCII_keymap [MWKEY_LMETA       & 0xFF] = SDLK_LMETA ;
+    NX_NONASCII_keymap [MWKEY_RMETA       & 0xFF] = SDLK_RMETA ;
+    NX_NONASCII_keymap [MWKEY_ALTGR       & 0xFF] = SDLK_MODE ;
+
+    NX_NONASCII_keymap [MWKEY_PRINT       & 0xFF] = SDLK_PRINT ;
+    NX_NONASCII_keymap [MWKEY_SYSREQ      & 0xFF] = SDLK_SYSREQ ;
+    NX_NONASCII_keymap [MWKEY_PAUSE       & 0xFF] = SDLK_PAUSE ;
+    NX_NONASCII_keymap [MWKEY_BREAK       & 0xFF] = SDLK_BREAK ;
+    NX_NONASCII_keymap [MWKEY_MENU        & 0xFF] = SDLK_MENU ;
+
+    Dprintf ("leave NX_InitOSKeymap\n") ;
+}
+
+SDL_keysym * NX_TranslateKey (GR_EVENT_KEYSTROKE * keystroke, SDL_keysym * keysym)
+{
+    GR_KEY ch = keystroke -> ch ;
+
+    Dprintf ("enter NX_TranslateKey\n") ;
+
+    keysym -> scancode = keystroke -> scancode ;
+    keysym -> sym = SDLK_UNKNOWN ;
+
+    if (ch & MWKEY_NONASCII_MASK) {
+        keysym -> sym = NX_NONASCII_keymap [ch & 0xFF] ;
+    } else {
+        keysym -> sym = ch & 0x7F ;
+    }
+
+    keysym -> mod = KMOD_NONE ;
+    
+#if 1   //   Retrieve more mode information
+    {
+        GR_KEYMOD   mod = keystroke -> modifiers ;
+
+        if (mod & MWKMOD_LSHIFT)
+            keysym -> mod |= KMOD_LSHIFT ;
+        if (mod & MWKMOD_RSHIFT)
+            keysym -> mod |= KMOD_RSHIFT ;
+        if (mod & MWKMOD_LCTRL)
+            keysym -> mod |= KMOD_LCTRL ;
+        if (mod & MWKMOD_RCTRL)
+            keysym -> mod |= KMOD_RCTRL ;
+        if (mod & MWKMOD_LALT)
+            keysym -> mod |= KMOD_LALT ;
+        if (mod & MWKMOD_RALT)
+            keysym -> mod |= KMOD_RALT ;
+        if (mod & MWKMOD_LMETA)
+            keysym -> mod |= KMOD_LMETA ;
+        if (mod & MWKMOD_RMETA)
+            keysym -> mod |= KMOD_RMETA ;
+        if (mod & MWKMOD_NUM)
+            keysym -> mod |= KMOD_NUM ;
+        if (mod & MWKMOD_CAPS)
+            keysym -> mod |= KMOD_CAPS ;
+        if (mod & MWKMOD_ALTGR)
+            keysym -> mod |= KMOD_MODE ;
+    }
+#endif
+
+    keysym -> unicode = ch ;
+
+    Dprintf ("leave NX_TranslateKey\n") ;
+    return keysym ;
+}
+
+static int check_boundary (_THIS, int x, int y)
+{
+    if (x < OffsetX || y < OffsetY || x > OffsetX + this -> screen -> w ||
+        y > OffsetY + this -> screen -> h)
+        return 0 ;
+            
+    return 1 ;
+}
+
+void NX_PumpEvents (_THIS)
+{
+    GR_EVENT         event ;
+    static GR_BUTTON last_button_down = 0 ;
+
+    GrCheckNextEvent (& event) ;
+    while (event.type != GR_EVENT_TYPE_NONE) {
+
+        // dispatch event
+        switch (event.type) {
+            case GR_EVENT_TYPE_MOUSE_ENTER :
+            {
+                Dprintf ("mouse enter\n") ;
+                SDL_PrivateAppActive (1, SDL_APPMOUSEFOCUS) ;
+                break ;
+            }
+
+            case GR_EVENT_TYPE_MOUSE_EXIT :
+            {
+                Dprintf ("mouse exit\n") ;
+                SDL_PrivateAppActive (0, SDL_APPMOUSEFOCUS) ;
+                break ;
+            }
+
+            case GR_EVENT_TYPE_FOCUS_IN :
+            {
+                Dprintf ("focus in\n") ;
+                SDL_PrivateAppActive (1, SDL_APPINPUTFOCUS) ;
+                break ;
+            }
+
+            case GR_EVENT_TYPE_FOCUS_OUT :
+            {
+                Dprintf ("focus out\n") ;
+                SDL_PrivateAppActive (0, SDL_APPINPUTFOCUS) ;
+                break ;
+            }
+
+            case GR_EVENT_TYPE_MOUSE_MOTION :
+            {               
+                Dprintf ("mouse motion\n") ;
+
+                if (SDL_VideoSurface) {
+                    if (currently_fullscreen) {
+                        if (check_boundary (this, event.button.x, event.button.y)) {
+                            SDL_PrivateMouseMotion (0, 0, event.button.x - OffsetX, 
+                                event.button.y - OffsetY) ;
+                        }
+                    } else {
+                        SDL_PrivateMouseMotion (0, 0, event.button.x, event.button.y) ;
+                    }
+                }
+                break ;
+            }
+
+            case GR_EVENT_TYPE_BUTTON_DOWN :
+            {
+                int button = event.button.buttons ;
+                
+                Dprintf ("button down\n") ;
+
+                switch (button) {
+                    case MWBUTTON_L :
+                        button = 1 ;
+                        break ;
+                    case MWBUTTON_M :
+                        button = 2 ;
+                        break ;
+                    case MWBUTTON_R :
+                        button = 3 ;
+                        break ;
+                    default :
+                        button = 0 ;
+                }
+                last_button_down = button ;
+                
+                if (currently_fullscreen) {
+                    if (check_boundary (this, event.button.x, event.button.y)) {
+                        SDL_PrivateMouseButton (SDL_PRESSED, button, 
+                            event.button.x - OffsetX, event.button.y - OffsetY) ;
+                    }
+                } else {
+                    SDL_PrivateMouseButton (SDL_PRESSED, button, 
+                        event.button.x, event.button.y) ;
+                }
+                break ;
+            }
+
+            // do not konw which button is released
+            case GR_EVENT_TYPE_BUTTON_UP :
+            {   
+                Dprintf ("button up\n") ;
+
+                if (currently_fullscreen) {
+                    if (check_boundary (this, event.button.x, event.button.y)) {
+                        SDL_PrivateMouseButton (SDL_RELEASED, last_button_down, 
+                            event.button.x - OffsetX, event.button.y - OffsetY) ;
+                    }
+                } else {
+                    SDL_PrivateMouseButton (SDL_RELEASED, last_button_down, 
+                        event.button.x, event.button.y) ;
+                }
+                last_button_down = 0 ;
+                break ;
+            }
+
+            case GR_EVENT_TYPE_KEY_DOWN :
+            {
+                SDL_keysym keysym ;
+
+                Dprintf ("key down\n") ;
+                SDL_PrivateKeyboard (SDL_PRESSED,
+                    NX_TranslateKey (& event.keystroke, & keysym)) ;
+                break ;
+            }
+
+            case GR_EVENT_TYPE_KEY_UP :
+            {
+                SDL_keysym keysym ;
+
+                Dprintf ("key up\n") ;
+                SDL_PrivateKeyboard (SDL_RELEASED,
+                    NX_TranslateKey (& event.keystroke, & keysym)) ;
+                break ;
+            }
+
+            case GR_EVENT_TYPE_CLOSE_REQ :
+            {
+                Dprintf ("close require\n") ;
+                SDL_PrivateQuit () ;
+                break ;
+            }
+
+            case GR_EVENT_TYPE_EXPOSURE :
+            {
+                Dprintf ("event_type_exposure\n") ;
+                if (SDL_VideoSurface) {
+                    NX_RefreshDisplay (this) ;//, & event.exposure) ;
+                }
+                break ;
+            }
+
+            case GR_EVENT_TYPE_UPDATE :
+            {
+                switch (event.update.utype) {
+                    case GR_UPDATE_MAP :
+                    {
+                        Dprintf ("GR_UPDATE_MAP\n") ;
+                        // If we're not active, make ourselves active
+                        if (!(SDL_GetAppState () & SDL_APPACTIVE)) {
+                            // Send an internal activate event
+                            SDL_PrivateAppActive (1, SDL_APPACTIVE) ;
+                        }
+                        if (SDL_VideoSurface) {
+                            NX_RefreshDisplay (this) ;
+                        }
+                        break ;
+                    }
+                    
+                    case GR_UPDATE_UNMAP :
+                    case GR_UPDATE_UNMAPTEMP :
+                    {
+                        Dprintf ("GR_UPDATE_UNMAP or GR_UPDATE_UNMAPTEMP\n") ;
+                        // If we're active, make ourselves inactive
+                        if (SDL_GetAppState () & SDL_APPACTIVE) {
+                            // Send an internal deactivate event
+                            SDL_PrivateAppActive (0, SDL_APPACTIVE | SDL_APPINPUTFOCUS) ;
+                        }
+                        break ; 
+                    }
+                    
+                    case GR_UPDATE_SIZE :
+                    {
+                        Dprintf ("GR_UPDATE_SIZE\n") ;
+                        SDL_PrivateResize (event.update.width, event.update.height) ;
+                        break ; 
+                    }
+                    
+                    default :
+                        Dprintf ("unknown GR_EVENT_TYPE_UPDATE\n") ;
+                        break ; 
+                }
+                break ; 
+            }
+                
+            default :
+            {
+                Dprintf ("pump event default\n") ;
+            }
+        }
+
+        GrCheckNextEvent (& event) ;
+    }
+}
diff --git a/src/video/nanox/SDL_nxevents_c.h b/src/video/nanox/SDL_nxevents_c.h
new file mode 100644
index 000000000..5a5bb46e7
--- /dev/null
+++ b/src/video/nanox/SDL_nxevents_c.h
@@ -0,0 +1,31 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga
+    Copyright (C) 2001  Hsieh-Fu Tsai
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@devolution.com
+    
+    Hsieh-Fu Tsai
+    clare@setabox.com
+*/
+
+#include "SDL_nxvideo.h"
+
+// Functions to be exported
+extern void NX_InitOSKeymap (_THIS) ;
+extern void NX_PumpEvents (_THIS) ;
diff --git a/src/video/nanox/SDL_nximage.c b/src/video/nanox/SDL_nximage.c
new file mode 100644
index 000000000..3c11d4ed1
--- /dev/null
+++ b/src/video/nanox/SDL_nximage.c
@@ -0,0 +1,166 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga
+    Copyright (C) 2001  Hsieh-Fu Tsai
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@devolution.com
+    
+    Hsieh-Fu Tsai
+    clare@setabox.com
+*/
+
+#include <stdlib.h>
+
+#include "SDL_error.h"
+
+#include "SDL_nximage_c.h"
+
+void NX_NormalUpdate (_THIS, int numrects, SDL_Rect * rects)
+{
+    int           i, j, xinc, yinc, destinc ;
+    int           x, y, w, h ;
+    unsigned char * src = NULL, * dest = NULL ;
+            
+    Dprintf ("enter NX_NormalUpdate\n") ;
+
+    xinc = this -> screen -> format -> BytesPerPixel ;
+    yinc = this -> screen -> pitch ;
+        
+    for (i = 0; i < numrects; ++ i) {
+        x = rects [i].x, y = rects [i].y ;
+        w = rects [i].w, h = rects [i].h ;
+        src = SDL_Image + y * yinc + x * xinc ;
+        dest = Image_buff ;
+        destinc = w * xinc ;
+
+        // apply GammaRamp table
+#if (defined (NANOX_PIXEL_RGB) || defined (NANOX_PIXEL_0888) || \
+     defined (NANOX_PIXEL_888))
+        if (GammaRamp_R && GammaRamp_G && GammaRamp_B) {
+            Uint8 * ptr ;
+            int   k ;
+
+            for (j = h; j > 0; -- j, src += yinc) {
+                ptr = src - 1 ;
+                for (k = w; k > 0; -- k) {
+#ifdef NANOX_PIXEL_RGB
+                    ptr += 2 ;
+#endif
+#ifdef NANOX_PIXEL_0888
+                    ptr += 2 ;
+#endif
+#ifdef NANOX_PIXEL_888
+                    ++ ptr ;
+#endif
+                    (* ptr) = GammaRamp_B [(* ptr)] ;
+                    ++ ptr ;
+                    (* ptr) = GammaRamp_G [(* ptr)] ;
+                    ++ ptr ;
+                    (* ptr) = GammaRamp_R [(* ptr)] ;
+                }
+            }
+            src = SDL_Image + y * yinc + x * xinc ;
+        }
+#endif // apply Gamma table
+
+        for (j = h; j > 0; -- j, src += yinc, dest += destinc) {
+            memcpy (dest, src, destinc) ;
+        }
+
+        if (currently_fullscreen) {
+            GrArea (FSwindow, SDL_GC, x + OffsetX, y + OffsetY, w, h, Image_buff, 
+                pixel_type) ;
+        } else {
+            GrArea (SDL_Window, SDL_GC, x, y, w, h, Image_buff, pixel_type) ;
+        }
+    }
+
+    Dprintf ("leave NX_NormalUpdate\n") ;
+}
+
+int NX_SetupImage (_THIS, SDL_Surface * screen)
+{
+    int size = screen -> h * screen -> pitch ;
+    
+    Dprintf ("enter NX_SetupImage\n") ;
+
+    screen -> pixels = (void *) malloc (size) ;
+    Image_buff = (unsigned char *) malloc (size) ;
+    if (screen -> pixels == NULL || Image_buff == NULL) {
+        free (screen -> pixels) ;
+        free (Image_buff) ;
+        SDL_OutOfMemory () ;
+        return -1 ;
+    }
+
+    SDL_Image = (unsigned char *) screen -> pixels ;
+
+    this -> UpdateRects = NX_NormalUpdate ;
+
+    Dprintf ("leave NX_SetupImage\n") ;
+    return 0 ;
+}
+
+void NX_DestroyImage (_THIS, SDL_Surface * screen)
+{
+    Dprintf ("enter NX_DestroyImage\n") ;
+    
+    if (SDL_Image) free (SDL_Image) ;
+    if (Image_buff) free (Image_buff) ;
+    if (screen) screen -> pixels = NULL ;
+    
+    Dprintf ("leave NX_DestroyImage\n") ;
+}
+
+int NX_ResizeImage (_THIS, SDL_Surface * screen, Uint32 flags)
+{
+    int            retval ;
+    GR_SCREEN_INFO si ;
+
+    Dprintf ("enter NX_ResizeImage\n") ;
+
+    NX_DestroyImage (this, screen) ;
+    retval = NX_SetupImage (this, screen) ;
+
+    GrGetScreenInfo (& si) ;
+    OffsetX = (si.cols - screen -> w) / 2 ;
+    OffsetY = (si.rows - screen -> h) / 2 ;
+    
+    Dprintf ("leave NX_ResizeImage\n") ;
+    return retval ;
+}
+
+void NX_RefreshDisplay (_THIS)
+{
+    Dprintf ("enter NX_RefreshDisplay\n") ;
+
+    // Don't refresh a display that doesn't have an image (like GL)
+    if (! SDL_Image) {
+        return;
+    }
+
+    if (currently_fullscreen) {
+        GrArea (FSwindow, SDL_GC, OffsetX, OffsetY, this -> screen -> w, 
+            this -> screen -> h, SDL_Image, pixel_type) ;
+    } else {
+        GrArea (SDL_Window, SDL_GC, 0, 0, this -> screen -> w, 
+            this -> screen -> h, SDL_Image, pixel_type) ;
+    }
+
+    Dprintf ("leave NX_RefreshDisplay\n") ;
+}
diff --git a/src/video/nanox/SDL_nximage_c.h b/src/video/nanox/SDL_nximage_c.h
new file mode 100644
index 000000000..361c03f48
--- /dev/null
+++ b/src/video/nanox/SDL_nximage_c.h
@@ -0,0 +1,34 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga
+    Copyright (C) 2001  Hsieh-Fu Tsai
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@devolution.com
+    
+    Hsieh-Fu Tsai
+    clare@setabox.com
+*/
+
+#include "SDL_nxvideo.h"
+
+extern int NX_SetupImage (_THIS, SDL_Surface * screen) ;
+extern void NX_DestroyImage (_THIS, SDL_Surface * screen) ;
+extern int NX_ResizeImage (_THIS, SDL_Surface * screen, Uint32 flags) ;
+
+extern void NX_NormalUpdate (_THIS, int numrects, SDL_Rect * rects) ;
+extern void NX_RefreshDisplay (_THIS) ;
diff --git a/src/video/nanox/SDL_nxmodes.c b/src/video/nanox/SDL_nxmodes.c
new file mode 100644
index 000000000..974005eae
--- /dev/null
+++ b/src/video/nanox/SDL_nxmodes.c
@@ -0,0 +1,84 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga
+    Copyright (C) 2001  Hsieh-Fu Tsai
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@devolution.com
+    
+    Hsieh-Fu Tsai
+    clare@setabox.com
+*/
+
+#include <stdlib.h>
+
+#include "SDL_nxmodes_c.h"
+
+SDL_Rect ** NX_ListModes (_THIS, SDL_PixelFormat * format, Uint32 flags)
+{
+    if (flags & SDL_FULLSCREEN)
+        return SDL_modelist ;
+
+    if (SDL_Visual.bpp == format -> BitsPerPixel) {
+        return ((SDL_Rect **) -1) ;
+    } else {
+        return ((SDL_Rect **) 0) ;
+    }
+}
+
+void NX_FreeVideoModes (_THIS)
+{
+    int i ;
+
+    if (SDL_modelist) {
+        for (i = 0; SDL_modelist [i]; ++ i) {
+            free (SDL_modelist [i]) ;
+        }
+        free (SDL_modelist) ;
+        SDL_modelist = NULL;
+    }
+}
+
+int NX_EnterFullScreen (_THIS)
+{
+    if (! currently_fullscreen) {
+        GR_SCREEN_INFO si ;
+
+        GrGetScreenInfo (& si) ;
+        GrResizeWindow (FSwindow, si.cols, si.rows) ;
+        GrUnmapWindow (SDL_Window) ;
+        GrMapWindow (FSwindow) ;
+        GrRaiseWindow (FSwindow) ;
+        GrSetFocus (FSwindow) ;
+        currently_fullscreen = 1 ;      
+    }
+
+    return 1 ;
+}
+
+int NX_LeaveFullScreen (_THIS)
+{
+    if (currently_fullscreen) {
+        GrUnmapWindow (FSwindow) ;
+        GrMapWindow (SDL_Window) ;
+        GrRaiseWindow (SDL_Window) ;
+        GrSetFocus (SDL_Window) ;
+        currently_fullscreen = 0 ;
+    }
+
+    return 0 ;
+}
diff --git a/src/video/nanox/SDL_nxmodes_c.h b/src/video/nanox/SDL_nxmodes_c.h
new file mode 100644
index 000000000..29883330e
--- /dev/null
+++ b/src/video/nanox/SDL_nxmodes_c.h
@@ -0,0 +1,33 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga
+    Copyright (C) 2001  Hsieh-Fu Tsai
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@devolution.com
+    
+    Hsieh-Fu Tsai
+    clare@setabox.com
+*/
+
+#include "SDL_nxvideo.h"
+#include <SDL/SDL.h>
+
+extern SDL_Rect ** NX_ListModes (_THIS, SDL_PixelFormat * format, Uint32 flags) ;
+extern void NX_FreeVideoModes (_THIS) ;
+extern int NX_EnterFullScreen (_THIS) ;
+extern int NX_LeaveFullScreen (_THIS) ;
diff --git a/src/video/nanox/SDL_nxmouse.c b/src/video/nanox/SDL_nxmouse.c
new file mode 100644
index 000000000..34f88e34b
--- /dev/null
+++ b/src/video/nanox/SDL_nxmouse.c
@@ -0,0 +1,81 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga
+    Copyright (C) 2001  Hsieh-Fu Tsai
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@devolution.com
+    
+    Hsieh-Fu Tsai
+    clare@setabox.com
+*/
+
+#include <stdlib.h>
+
+#include "SDL_error.h"
+#include "SDL_events_c.h"
+
+#include "SDL_nxmouse_c.h"
+
+// The implementation dependent data for the window manager cursor
+struct WMcursor {
+    int unused ;
+} ;
+
+WMcursor * NX_CreateWMCursor (_THIS,
+        Uint8 * data, Uint8 * mask, int w, int h, int hot_x, int hot_y)
+{
+    WMcursor * cursor ;
+
+    Dprintf ("enter NX_CreateWMCursor\n") ;
+
+    cursor = (WMcursor *) malloc (sizeof (WMcursor)) ;
+    if (cursor == NULL) {
+        SDL_OutOfMemory () ;
+        return NULL ;
+    }
+
+    Dprintf ("leave NX_CreateWMCursor\n") ;
+    return cursor ;
+}
+
+void NX_FreeWMCursor (_THIS, WMcursor * cursor)
+{
+    Dprintf ("NX_FreeWMCursor\n") ;
+    free (cursor) ;
+    return ;
+}
+
+void NX_WarpWMCursor(_THIS, Uint16 x, Uint16 y)
+{
+    GR_WINDOW_INFO info ;
+
+    Dprintf ("enter NX_WarpWMCursor\n") ;
+    SDL_Lock_EventThread () ;
+    
+    GrGetWindowInfo (SDL_Window, & info) ;
+    GrMoveCursor (info.x + x, info.y + y) ;
+
+    SDL_Unlock_EventThread () ;
+    Dprintf ("leave NX_WarpWMCursor\n") ;
+}
+
+int NX_ShowWMCursor (_THIS, WMcursor * cursor)
+{
+    Dprintf ("NX_ShowWMCursor\n") ;
+    return 1 ;
+}
diff --git a/src/video/nanox/SDL_nxmouse_c.h b/src/video/nanox/SDL_nxmouse_c.h
new file mode 100644
index 000000000..4af86b0bd
--- /dev/null
+++ b/src/video/nanox/SDL_nxmouse_c.h
@@ -0,0 +1,6 @@
+#include "SDL_nxvideo.h"
+
+extern WMcursor * NX_CreateWMCursor (_THIS, Uint8 * data, Uint8 * mask, int w, int h, int hot_x, int hot_y) ;
+void NX_FreeWMCursor (_THIS, WMcursor * cursor) ;
+extern void NX_WarpWMCursor (_THIS, Uint16 x, Uint16 y) ;
+extern int NX_ShowWMCursor (_THIS, WMcursor * cursor) ;
diff --git a/src/video/nanox/SDL_nxvideo.c b/src/video/nanox/SDL_nxvideo.c
new file mode 100644
index 000000000..cb122e166
--- /dev/null
+++ b/src/video/nanox/SDL_nxvideo.c
@@ -0,0 +1,557 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga
+    Copyright (C) 2001  Hsieh-Fu Tsai
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@devolution.com
+    
+    Hsieh-Fu Tsai
+    clare@setabox.com
+*/
+
+#include <stdlib.h>
+
+#include "SDL_video.h"
+#include "SDL_pixels_c.h"
+#include "SDL_events_c.h"
+#include "SDL_thread.h"
+
+#define MWINCLUDECOLORS
+#include "SDL_nxvideo.h"
+#include "SDL_nxmodes_c.h"
+#include "SDL_nxwm_c.h"
+#include "SDL_nxmouse_c.h"
+#include "SDL_nximage_c.h"
+#include "SDL_nxevents_c.h"
+
+// Initialization/Query functions
+static int NX_VideoInit (_THIS, SDL_PixelFormat * vformat) ;
+static SDL_Surface * NX_SetVideoMode (_THIS, SDL_Surface * current, int width, int height, int bpp, Uint32 flags) ;
+static int NX_SetColors (_THIS, int firstcolor, int ncolors, SDL_Color * colors) ;
+static void NX_VideoQuit (_THIS) ;
+static void NX_DestroyWindow (_THIS, SDL_Surface * screen) ;
+static int NX_ToggleFullScreen (_THIS, int on) ;
+static void NX_UpdateMouse (_THIS) ;
+static int NX_SetGammaRamp (_THIS, Uint16 * ramp) ;
+static int NX_GetGammaRamp (_THIS, Uint16 * ramp) ;
+
+// Microwin driver bootstrap functions
+static int NX_Available ()
+{
+    Dprintf ("enter NX_Available\n") ;
+
+    if (GrOpen () < 0) return 0 ;
+        GrClose () ;
+    
+    Dprintf ("leave NX_Available\n") ;
+    return 1 ;
+}
+
+static void NX_DeleteDevice (SDL_VideoDevice * device)
+{
+    Dprintf ("enter NX_DeleteDevice\n") ;
+
+    if (device) {
+        if (device -> hidden) free (device -> hidden) ;
+        if (device -> gl_data) free (device -> gl_data) ;
+            free (device) ;
+    }
+
+    Dprintf ("leave NX_DeleteDevice\n") ;
+}
+    
+static SDL_VideoDevice * NX_CreateDevice (int devindex)
+{
+    SDL_VideoDevice * device ;
+
+    Dprintf ("enter NX_CreateDevice\n") ;
+
+    // Initialize all variables that we clean on shutdown
+    device = (SDL_VideoDevice *) malloc (sizeof (SDL_VideoDevice)) ;
+    if (device) {
+        memset (device, 0, (sizeof * device)) ;
+        device -> hidden = (struct SDL_PrivateVideoData *)
+                malloc ((sizeof * device -> hidden)) ;
+        device -> gl_data = NULL ;
+    }
+    if ((device == NULL) || (device -> hidden == NULL)) {
+        SDL_OutOfMemory () ;
+        NX_DeleteDevice (device) ;
+        return 0 ;
+    }
+    memset (device -> hidden, 0, (sizeof * device -> hidden)) ;
+
+    // Set the function pointers
+    device -> VideoInit = NX_VideoInit ;
+    device -> ListModes = NX_ListModes ;
+    device -> SetVideoMode = NX_SetVideoMode ;
+    device -> ToggleFullScreen = NX_ToggleFullScreen ;
+    device -> UpdateMouse = NX_UpdateMouse ;
+    device -> CreateYUVOverlay = NULL ;
+    device -> SetColors = NX_SetColors ;
+    device -> UpdateRects = NULL ;
+    device -> VideoQuit = NX_VideoQuit;
+    device -> AllocHWSurface = NULL ;
+    device -> CheckHWBlit = NULL ;
+    device -> FillHWRect = NULL ;
+    device -> SetHWColorKey = NULL ;
+    device -> SetHWAlpha = NULL ;
+    device -> LockHWSurface = NULL ;
+    device -> UnlockHWSurface = NULL ;
+    device -> FlipHWSurface = NULL ;
+    device -> FreeHWSurface = NULL ;
+    device -> SetGamma = NULL ;
+    device -> GetGamma = NULL ;
+    device -> SetGammaRamp = NX_SetGammaRamp ;
+    device -> GetGammaRamp = NX_GetGammaRamp ;
+
+#ifdef HAVE_OPENGL
+    device -> GL_LoadLibrary = NULL ;
+    device -> GL_GetProcAddress = NULL ;
+    device -> GL_GetAttribute = NULL ;
+    device -> GL_MakeCurrent = NULL ;
+    device -> GL_SwapBuffers = NULL ;
+#endif
+
+    device -> SetIcon = NULL ;
+    device -> SetCaption = NX_SetCaption;
+    device -> IconifyWindow = NULL ;
+    device -> GrabInput = NULL ;
+    device -> GetWMInfo = NX_GetWMInfo ;
+    device -> FreeWMCursor =  NX_FreeWMCursor ;
+    device -> CreateWMCursor = NX_CreateWMCursor ;
+    device -> ShowWMCursor = NX_ShowWMCursor ;
+    device -> WarpWMCursor = NX_WarpWMCursor ;
+    device -> CheckMouseMode = NULL ;
+    device -> InitOSKeymap = NX_InitOSKeymap ;
+    device -> PumpEvents = NX_PumpEvents ;
+
+    device -> free = NX_DeleteDevice ;
+
+    Dprintf ("leave NX_CreateDevice\n") ;
+    return device ;
+}
+
+VideoBootStrap NX_bootstrap = {
+    "nanox", "nanox", NX_Available, NX_CreateDevice
+} ;
+
+static void create_aux_windows (_THIS)
+{
+    GR_WM_PROPERTIES props ;
+
+    Dprintf ("enter create_aux_windows\n") ;
+
+    // Don't create any extra windows if we are being managed
+    if (SDL_windowid) {
+        FSwindow = 0 ;
+        return ;
+    }
+    
+    if (FSwindow && FSwindow != GR_ROOT_WINDOW_ID) {
+        GrDestroyWindow (FSwindow) ;
+    }
+    
+    FSwindow = GrNewWindow (GR_ROOT_WINDOW_ID, 0, 0, 1, 1, 0, BLACK, BLACK) ;
+    props.flags = GR_WM_FLAGS_PROPS ;
+    props.props = GR_WM_PROPS_NODECORATE ;
+    GrSetWMProperties (FSwindow, & props) ;
+
+    GrSelectEvents (FSwindow, (GR_EVENT_MASK_EXPOSURE         |
+        GR_EVENT_MASK_BUTTON_DOWN  | GR_EVENT_MASK_BUTTON_UP  |
+        GR_EVENT_MASK_FOCUS_IN     | GR_EVENT_MASK_FOCUS_OUT  |
+        GR_EVENT_MASK_KEY_DOWN     | GR_EVENT_MASK_KEY_UP     |
+        GR_EVENT_MASK_MOUSE_ENTER  | GR_EVENT_MASK_MOUSE_EXIT |
+        GR_EVENT_MASK_MOUSE_MOTION | GR_EVENT_MASK_UPDATE     |
+        GR_EVENT_MASK_CLOSE_REQ)) ;
+
+    Dprintf ("leave create_aux_windows\n") ;
+}
+
+int NX_VideoInit (_THIS, SDL_PixelFormat * vformat)
+{
+    GR_SCREEN_INFO si ;
+
+    Dprintf ("enter NX_VideoInit\n") ;
+    
+    if (GrOpen () < 0) {
+        SDL_SetError ("GrOpen() fail") ;
+        return -1 ;
+    }
+
+    // use share memory to speed up
+#ifdef NANOX_SHARE_MEMORY
+    GrReqShmCmds (0xFFFF);
+#endif
+
+    SDL_Window = 0 ;
+    FSwindow = 0 ;
+
+    GammaRamp_R = NULL ;
+    GammaRamp_G = NULL ;
+    GammaRamp_B = NULL ;    
+
+    GrGetScreenInfo (& si) ;
+    SDL_Visual.bpp = si.bpp ;
+
+    // GetVideoMode
+    SDL_modelist = (SDL_Rect **) malloc (sizeof (SDL_Rect *) * 2) ;
+    if (SDL_modelist) {
+        SDL_modelist [0] = (SDL_Rect *) malloc (sizeof(SDL_Rect)) ;
+        if (SDL_modelist [0]) {
+            SDL_modelist [0] -> x = 0 ;
+            SDL_modelist [0] -> y = 0 ;
+            SDL_modelist [0] -> w = si.cols ;
+            SDL_modelist [0] -> h = si.rows ;
+        }
+        SDL_modelist [1] = NULL ;
+    }
+
+#ifdef NANOX_PIXEL_RGB
+    pixel_type = MWPF_RGB ;
+    SDL_Visual.red_mask   = 0x000000FF ;
+    SDL_Visual.green_mask = 0x0000FF00 ;
+    SDL_Visual.blue_mask  = 0x00FF0000 ;
+#endif
+#ifdef NANOX_PIXEL_0888
+    pixel_type = MWPF_TRUECOLOR0888 ;
+    SDL_Visual.red_mask   = 0x00FF0000 ;
+    SDL_Visual.green_mask = 0x0000FF00 ;
+    SDL_Visual.blue_mask  = 0x000000FF ;
+#endif
+#ifdef NANOX_PIXEL_888
+    pixel_type = MWPF_TRUECOLOR888 ;
+    SDL_Visual.red_mask   = 0xFF0000 ;
+    SDL_Visual.green_mask = 0x00FF00 ;
+    SDL_Visual.blue_mask  = 0x0000FF ;
+#endif
+#ifdef NANOX_PIXEL_565
+    pixel_type = MWPF_TRUECOLOR565 ;
+    SDL_Visual.red_mask   = 0xF800 ;
+    SDL_Visual.green_mask = 0x07E0 ;
+    SDL_Visual.blue_mask  = 0x001F ;
+#endif
+#ifdef NANOX_PIXEL_555
+    pixel_type = MWPF_TRUECOLOR555 ;
+    SDL_Visual.red_mask   = 0x7C00 ;
+    SDL_Visual.green_mask = 0x03E0 ;
+    SDL_Visual.blue_mask  = 0x001F ;
+#endif
+#ifdef NANOX_PIXEL_332
+    pixel_type = MWPF_TRUECOLOR332 ;
+#endif
+#ifdef NANOX_PIXEL_PAL
+    pixel_type = MWPF_PALETTE ;
+#endif
+
+    vformat -> BitsPerPixel = SDL_Visual.bpp ;
+    if (vformat -> BitsPerPixel > 8) {
+        vformat -> Rmask = SDL_Visual.red_mask ;
+        vformat -> Gmask = SDL_Visual.green_mask ;
+        vformat -> Bmask = SDL_Visual.blue_mask ;
+    }
+
+    // See if we have been passed a window to use
+    SDL_windowid = getenv ("SDL_WINDOWID") ;
+    
+    // Create the fullscreen (and managed windows : no implement)
+    create_aux_windows (this) ;
+
+    Dprintf ("leave NX_VideoInit\n") ;
+    return 0 ;
+}
+
+void NX_VideoQuit (_THIS)
+{
+    Dprintf ("enter NX_VideoQuit\n") ;
+
+    // Start shutting down the windows
+    NX_DestroyImage (this, this -> screen) ;
+    NX_DestroyWindow (this, this -> screen) ;
+    if (FSwindow && FSwindow != GR_ROOT_WINDOW_ID) {
+        GrDestroyWindow (FSwindow) ;
+    }
+    NX_FreeVideoModes (this) ;
+    free (GammaRamp_R) ;
+    free (GammaRamp_G) ;
+    free (GammaRamp_B) ;
+    GrClose () ;
+
+    Dprintf ("leave NX_VideoQuit\n") ;
+}
+
+static void NX_DestroyWindow (_THIS, SDL_Surface * screen)
+{
+    Dprintf ("enter NX_DestroyWindow\n") ;
+
+    if (! SDL_windowid) {
+        if (screen && (screen -> flags & SDL_FULLSCREEN)) {
+            screen -> flags &= ~ SDL_FULLSCREEN ;
+            NX_LeaveFullScreen (this) ;
+        }
+
+        // Destroy the output window
+        if (SDL_Window && SDL_Window != GR_ROOT_WINDOW_ID) {
+            GrDestroyWindow (SDL_Window) ;
+        }
+    }
+    
+    // Free the graphics context
+    if (! SDL_GC) {
+        GrDestroyGC (SDL_GC) ;
+        SDL_GC = 0;
+    }
+
+    Dprintf ("leave NX_DestroyWindow\n") ;
+}
+
+static int NX_CreateWindow (_THIS, SDL_Surface * screen,
+                int w, int h, int bpp, Uint32 flags)
+{
+    Dprintf ("enter NX_CreateWindow\n") ;
+
+    // If a window is already present, destroy it and start fresh
+    if (SDL_Window && SDL_Window != GR_ROOT_WINDOW_ID) {
+        NX_DestroyWindow (this, screen) ;
+    }
+
+    // See if we have been given a window id
+    if (SDL_windowid) {
+        SDL_Window = strtol (SDL_windowid, NULL, 0) ;
+    } else {
+        SDL_Window = 0 ;
+    }
+    
+    if ( ! SDL_ReallocFormat (screen, bpp, SDL_Visual.red_mask, 
+        SDL_Visual.green_mask, SDL_Visual.blue_mask, 0))
+        return -1;
+
+    // Create (or use) the nanox display window
+    if (! SDL_windowid) {
+
+        SDL_Window = GrNewWindow (GR_ROOT_WINDOW_ID, 0, 0, w, h, 0, BLACK, WHITE) ;
+
+        GrSelectEvents (SDL_Window, (GR_EVENT_MASK_EXPOSURE       |
+            GR_EVENT_MASK_BUTTON_DOWN  | GR_EVENT_MASK_BUTTON_UP  |
+            GR_EVENT_MASK_FOCUS_IN     | GR_EVENT_MASK_FOCUS_OUT  |
+            GR_EVENT_MASK_KEY_DOWN     | GR_EVENT_MASK_KEY_UP     |
+            GR_EVENT_MASK_MOUSE_ENTER  | GR_EVENT_MASK_MOUSE_EXIT |
+            GR_EVENT_MASK_MOUSE_MOTION | GR_EVENT_MASK_UPDATE     |
+            GR_EVENT_MASK_CLOSE_REQ)) ;
+    }
+    
+    /* Create the graphics context here, once we have a window */
+    SDL_GC = GrNewGC () ;
+    if (SDL_GC == 0) {
+        SDL_SetError("Couldn't create graphics context");
+        return(-1);
+    }
+
+    // Map them both and go fullscreen, if requested
+    if (! SDL_windowid) {
+        GrMapWindow (SDL_Window) ;
+        if (flags & SDL_FULLSCREEN) {
+            screen -> flags |= SDL_FULLSCREEN ;
+            NX_EnterFullScreen (this) ;
+        } else {
+            screen -> flags &= ~ SDL_FULLSCREEN ;
+        }
+    }
+
+    Dprintf ("leave NX_CreateWindow\n") ;
+    return 0 ;
+}
+
+SDL_Surface * NX_SetVideoMode (_THIS, SDL_Surface * current,
+                int width, int height, int bpp, Uint32 flags)
+{
+    Dprintf ("enter NX_SetVideoMode\n") ;
+
+    // Lock the event thread, in multi-threading environments
+    SDL_Lock_EventThread () ;
+
+    bpp = SDL_Visual.bpp ;
+    if (NX_CreateWindow (this, current, width, height, bpp, flags) < 0) {
+        current = NULL;
+        goto done;
+    }
+
+    if (current -> w != width || current -> h != height) {
+        current -> w = width ;
+        current -> h = height ;
+        current -> pitch = SDL_CalculatePitch (current) ;
+        NX_ResizeImage (this, current, flags) ;
+    }
+    current -> flags |= (flags & (SDL_RESIZABLE | SDL_NOFRAME)) ;
+
+  done:
+    SDL_Unlock_EventThread () ;
+
+    Dprintf ("leave NX_SetVideoMode\n") ;
+
+    // We're done!
+    return current ;
+}
+
+// ncolors <= 256
+int NX_SetColors (_THIS, int firstcolor, int ncolors, SDL_Color * colors)
+{
+    int        i ;
+    GR_PALETTE pal ;
+
+    Dprintf ("enter NX_SetColors\n") ;
+
+    if (ncolors > 256) return 0 ;
+    
+    pal.count = ncolors ;
+    for (i = 0; i < ncolors; ++ i) {
+        pal.palette [i].r = colors [i].r ;
+        pal.palette [i].g = colors [i].g ;
+        pal.palette [i].b = colors [i].b ;
+    }
+    GrSetSystemPalette (firstcolor, & pal) ;
+
+    Dprintf ("leave NX_SetColors\n") ;
+    return 1 ;
+}
+
+static int NX_ToggleFullScreen (_THIS, int on)
+{
+    SDL_Rect rect ;
+    Uint32   event_thread ;
+    
+    Dprintf ("enter NX_ToggleFullScreen\n") ;
+
+    // Don't switch if we don't own the window
+    if (SDL_windowid) return 0 ;
+    
+    // Don't lock if we are the event thread
+    event_thread = SDL_EventThreadID () ;
+    if (event_thread && (SDL_ThreadID () == event_thread)) {
+        event_thread = 0 ;
+    }
+    if (event_thread) {
+        SDL_Lock_EventThread() ;
+    }
+    
+    if (on) {
+        NX_EnterFullScreen (this) ;
+    } else {
+        this -> screen -> flags &= ~ SDL_FULLSCREEN ;
+        NX_LeaveFullScreen (this) ;
+    }
+
+    rect.x = rect.y = 0 ;
+    rect.w = this -> screen -> w, rect.h = this -> screen -> h ;
+    NX_NormalUpdate (this, 1, & rect) ;
+
+    if (event_thread) {
+        SDL_Unlock_EventThread () ;
+    }
+    
+    Dprintf ("leave NX_ToggleFullScreen\n") ;
+    return 1 ;
+}
+
+// Update the current mouse state and position
+static void NX_UpdateMouse (_THIS)
+{
+    int            x, y ;
+    GR_WINDOW_INFO info ;
+    GR_SCREEN_INFO si ;
+
+
+    Dprintf ("enter NX_UpdateMouse\n") ;
+
+    // Lock the event thread, in multi-threading environments
+    SDL_Lock_EventThread () ;
+    
+    GrGetScreenInfo (& si) ;
+    GrGetWindowInfo (SDL_Window, & info) ;
+    x = si.xpos - info.x ;
+    y = si.ypos - info.y ;
+    if (x >= 0 && x <= info.width && y >= 0 && y <= info.height) {
+        SDL_PrivateAppActive (1, SDL_APPMOUSEFOCUS) ;
+        SDL_PrivateMouseMotion (0, 0, x, y);
+    } else {
+        SDL_PrivateAppActive (0, SDL_APPMOUSEFOCUS) ;
+    }
+
+    SDL_Unlock_EventThread () ;
+    Dprintf ("leave NX_UpdateMouse\n") ;
+}
+
+static int NX_SetGammaRamp (_THIS, Uint16 * ramp)
+{
+    int i ;
+    Uint16 * red, * green, * blue ;
+    
+    Dprintf ("enter NX_SetGammaRamp\n") ;
+    
+    if (SDL_Visual.bpp != 32 && SDL_Visual.bpp != 24) return -1 ;
+
+    if (! GammaRamp_R) GammaRamp_R = (Uint16 *) malloc (sizeof (Uint16) * CI_SIZE) ;
+    if (! GammaRamp_G) GammaRamp_G = (Uint16 *) malloc (sizeof (Uint16) * CI_SIZE) ;
+    if (! GammaRamp_B) GammaRamp_B = (Uint16 *) malloc (sizeof (Uint16) * CI_SIZE) ;
+    if ((! GammaRamp_R) || (! GammaRamp_G) || (! GammaRamp_B)) {
+        SDL_OutOfMemory () ;
+        return -1 ;
+    }
+
+    for (i = 0; i < CI_SIZE; ++ i)
+        GammaRamp_R [i] = GammaRamp_G [i] = GammaRamp_B [i] = i ;
+
+    red   = ramp ;
+    green = ramp + CI_SIZE ;
+    blue  = green + CI_SIZE ;
+        
+    for (i = 0; i < CI_SIZE; ++ i) {
+        GammaRamp_R [i] = red   [i] ;
+        GammaRamp_G [i] = green [i] ;
+        GammaRamp_B [i] = blue  [i] ;
+    }
+
+    Dprintf ("leave NX_SetGammaRamp\n") ;   
+    return 0 ;
+}
+
+static int NX_GetGammaRamp (_THIS, Uint16 * ramp)
+{
+    int i ;
+    Uint16 * red, * green, * blue ;
+
+    Dprintf ("enter NX_GetGammaRamp\n") ;   
+
+    if (SDL_Visual.bpp != 32 && SDL_Visual.bpp != 24) return -1 ;
+    red   = ramp ;
+    green = ramp  + CI_SIZE ;
+    blue  = green + CI_SIZE ;
+    if (GammaRamp_R && GammaRamp_G && GammaRamp_B) {
+        for (i = 0; i < CI_SIZE; ++ i) {
+            red   [i] = GammaRamp_R [i] ;
+            green [i] = GammaRamp_G [i] ;
+            blue  [i] = GammaRamp_B [i] ;
+        }
+    } else {
+        for (i = 0; i < CI_SIZE; ++ i)
+            red [i] = green [i] = blue [i] = i ;
+    }
+
+    Dprintf ("leave NX_GetGammaRamp\n") ;
+    return 0 ;
+}
diff --git a/src/video/nanox/SDL_nxvideo.h b/src/video/nanox/SDL_nxvideo.h
new file mode 100644
index 000000000..aa2dcebf5
--- /dev/null
+++ b/src/video/nanox/SDL_nxvideo.h
@@ -0,0 +1,89 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga
+    Copyright (C) 2001  Hsieh-Fu Tsai
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@devolution.com
+    
+    Hsieh-Fu Tsai
+    clare@setabox.com
+*/
+
+#ifndef _SDL_nxvideo_h
+#define _SDL_nxvideo_h
+
+#include <microwin/nano-X.h>
+
+#include "SDL_sysvideo.h"
+
+#ifdef ENABLE_NANOX_DEBUG
+#define Dprintf printf
+#else
+#define Dprintf(ignore...)
+#endif
+
+// Hidden "this" pointer for the video functions
+#define _THIS   SDL_VideoDevice * this
+
+// Private display data
+typedef struct NX_SDL_VISUAL {
+    int    bpp ;
+    Uint32 red_mask ;
+    Uint32 green_mask ;
+    Uint32 blue_mask ;
+} nx_sdl_visual_t ;
+
+struct SDL_PrivateVideoData {
+    GR_WINDOW_ID    SDL_Window ;
+    GR_WINDOW_ID    FSwindow ;
+    // Flag: true if we have been passed a window
+    char            * SDL_windowid ;
+    GR_GC_ID        GC ;
+    unsigned char   * Image ;
+    unsigned char   * Image_buff ;
+    nx_sdl_visual_t SDL_Visual ;
+    // The current list of available video modes
+    SDL_Rect        ** modelist ;
+    int             currently_fullscreen ;
+    // for fullscreen
+    int             OffsetX, OffsetY ;
+    // for GammaRamp
+    Uint16          * GammaRamp_R, * GammaRamp_G, * GammaRamp_B ;
+    // for GrArea, r_mask, g_mask, b_mask
+    int             pixel_type ;
+} ;
+
+#define SDL_Window           (this -> hidden -> SDL_Window)
+#define FSwindow             (this -> hidden -> FSwindow)
+#define SDL_windowid         (this -> hidden -> SDL_windowid)
+#define SDL_GC               (this -> hidden -> GC)
+#define SDL_Image            (this -> hidden -> Image)
+#define Image_buff           (this -> hidden -> Image_buff)
+#define SDL_Visual           (this -> hidden -> SDL_Visual)
+#define SDL_modelist         (this -> hidden -> modelist)
+#define currently_fullscreen (this -> hidden -> currently_fullscreen)
+#define OffsetX              (this -> hidden -> OffsetX)
+#define OffsetY              (this -> hidden -> OffsetY)
+#define GammaRamp_R          (this -> hidden -> GammaRamp_R)
+#define GammaRamp_G          (this -> hidden -> GammaRamp_G)
+#define GammaRamp_B          (this -> hidden -> GammaRamp_B)
+#define pixel_type           (this -> hidden -> pixel_type)
+
+#define CI_SIZE 256   // color index size
+
+#endif  // _SDL_nxvideo_h
diff --git a/src/video/nanox/SDL_nxwm.c b/src/video/nanox/SDL_nxwm.c
new file mode 100644
index 000000000..3fa94faa9
--- /dev/null
+++ b/src/video/nanox/SDL_nxwm.c
@@ -0,0 +1,63 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga
+    Copyright (C) 2001  Hsieh-Fu Tsai
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@devolution.com
+    
+    Hsieh-Fu Tsai
+    clare@setabox.com
+*/
+
+#include <stdlib.h>
+
+#include "SDL_syswm.h"
+#include "SDL_error.h"
+#include "SDL_events_c.h"
+
+#include "SDL_nxwm_c.h"
+
+void NX_SetCaption (_THIS, const char * title, const char * icon)
+{
+    Dprintf ("enter NX_SetCaption\n") ;
+
+    // Lock the event thread, in multi-threading environments
+    SDL_Lock_EventThread () ;
+    
+    if (SDL_Window) 
+        GrSetWindowTitle (SDL_Window, title) ;
+    
+    SDL_Unlock_EventThread () ;
+    Dprintf ("leave NX_SetCaption\n") ;
+}
+
+int NX_GetWMInfo (_THIS, SDL_SysWMinfo * info)
+{
+    Dprintf ("enter NX_GetWMInfo\n") ;
+
+    if (info -> version.major <= SDL_MAJOR_VERSION) {
+        info -> window = SDL_Window ;
+        return 1 ;
+    } else {
+        SDL_SetError("Application not compiled with SDL %d.%d\n",
+            SDL_MAJOR_VERSION, SDL_MINOR_VERSION) ;
+        return -1 ;
+    }
+
+    Dprintf ("leave NX_GetWMInfo\n") ;
+}
diff --git a/src/video/nanox/SDL_nxwm_c.h b/src/video/nanox/SDL_nxwm_c.h
new file mode 100644
index 000000000..d9d5b9895
--- /dev/null
+++ b/src/video/nanox/SDL_nxwm_c.h
@@ -0,0 +1,31 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga
+    Copyright (C) 2001  Hsieh-Fu Tsai
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@devolution.com
+    
+    Hsieh-Fu Tsai
+    clare@setabox.com
+*/
+
+#include "SDL_nxvideo.h"
+
+// Functions to be exported
+extern void NX_SetCaption (_THIS, const char * title, const char * icon) ;
+extern int NX_GetWMInfo (_THIS, SDL_SysWMinfo * info) ;