--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/nanox/SDL_nxvideo.c	Fri May 11 01:13:35 2001 +0000
@@ -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 ;
+}