--- a/include/SDL_video.h	Sat Jul 08 20:55:39 2006 +0000
+++ b/include/SDL_video.h	Sun Jul 09 09:02:26 2006 +0000
@@ -98,6 +98,7 @@
  * \sa SDL_RaiseWindow()
  * \sa SDL_RestoreWindow()
  * \sa SDL_SetWindowData()
+ * \sa SDL_SetWindowFullscreen()
  * \sa SDL_SetWindowGrab()
  * \sa SDL_SetWindowIcon()
  * \sa SDL_SetWindowPosition()
@@ -474,15 +475,28 @@
                                                                    * closest);
 
 /**
- * \fn int SDL_SetDisplayMode(const SDL_DisplayMode *mode)
+ * \fn int SDL_SetFullscreenDisplayMode(const SDL_DisplayMode *mode)
  *
- * \brief Set up the closest available mode on the current display.
+ * \brief Set the display mode used when a fullscreen window is visible
+ *        on the currently selected display.
  *
- * \param mode The desired display mode, or NULL to set the desktop mode.
+ * \param mode The mode to use, or NULL for the desktop mode.
  *
  * \return 0 on success, or -1 if setting the display mode failed.
+ *
+ * \sa SDL_SetWindowFullscreen()
  */
-extern DECLSPEC int SDLCALL SDL_SetDisplayMode(const SDL_DisplayMode * mode);
+extern DECLSPEC int SDLCALL SDL_SetFullscreenDisplayMode(const SDL_DisplayMode
+                                                         * mode);
+
+/**
+ * \fn const SDL_DisplayMode *SDL_GetFullscreenDisplayMode(void)
+ *
+ * \brief Query the display mode used when a fullscreen window is visible
+ *        on the currently selected display.
+ */
+extern DECLSPEC const SDL_DisplayMode *SDLCALL
+SDL_GetFullscreenDisplayMode(void);
 
 /**
  * \fn int SDL_SetDisplayPalette(const SDL_Color *colors, int firstcolor, int ncolors)
@@ -507,6 +521,57 @@
                                                   int ncolors);
 
 /**
+ * \fn int SDL_SetGamma(float red, float green, float blue)
+ *
+ * \brief Set the gamma correction for each of the color channels on the currently selected display.
+ *
+ * \return 0 on success, or -1 if setting the gamma isn't supported.
+ *
+ * \sa SDL_SetGammaRamp()
+ */
+extern DECLSPEC int SDLCALL SDL_SetGamma(float red, float green, float blue);
+
+/**
+ * \fn int SDL_SetGammaRamp(const Uint16 * red, const Uint16 * green, const Uint16 * blue)
+ *
+ * \brief Set the gamma ramp for the currently selected display.
+ *
+ * \param red The translation table for the red channel, or NULL
+ * \param green The translation table for the green channel, or NULL
+ * \param blue The translation table for the blue channel, or NULL
+ *
+ * \return 0 on success, or -1 if gamma ramps are unsupported.
+ *
+ * Set the gamma translation table for the red, green, and blue channels
+ * of the video hardware.  Each table is an array of 256 16-bit quantities,
+ * representing a mapping between the input and output for that channel.
+ * The input is the index into the array, and the output is the 16-bit
+ * gamma value at that index, scaled to the output color precision.
+ * 
+ * \sa SDL_GetGammaRamp()
+ */
+extern DECLSPEC int SDLCALL SDL_SetGammaRamp(const Uint16 * red,
+                                             const Uint16 * green,
+                                             const Uint16 * blue);
+
+/**
+ * \fn int SDL_GetGammaRamp(Uint16 * red, Uint16 * green, Uint16 * blue)
+ *
+ * \brief Get the gamma ramp for the currently selected display.
+ *
+ * \param red A pointer to a 256 element array of 16-bit quantities to hold the translation table for the red channel, or NULL.
+ * \param green A pointer to a 256 element array of 16-bit quantities to hold the translation table for the green channel, or NULL.
+ * \param blue A pointer to a 256 element array of 16-bit quantities to hold the translation table for the blue channel, or NULL.
+ * 
+ * \return 0 on success, or -1 if gamma ramps are unsupported.
+ *
+ * \sa SDL_SetGammaRamp()
+ */
+extern DECLSPEC int SDLCALL SDL_GetGammaRamp(Uint16 * red, Uint16 * green,
+                                             Uint16 * blue);
+
+
+/**
  * \fn SDL_WindowID SDL_CreateWindow(const char *title, int x, int y, int w, int h, Uint32 flags)
  *
  * \brief Create a window with the specified position, dimensions, and flags.
@@ -516,7 +581,7 @@
  * \param y The y position of the window
  * \param w The width of the window
  * \param h The height of the window
- * \param flags The flags for the window
+ * \param flags The flags for the window, a mask of any of the following: SDL_WINDOW_FULLSCREEN, SDL_WINDOW_OPENGL, SDL_WINDOW_SHOWN, SDL_WINDOW_BORDERLESS, SDL_WINDOW_RESIZABLE, SDL_WINDOW_MAXIMIZED, SDL_WINDOW_MINIMIZED, SDL_WINDOW_INPUT_GRABBED
  *
  * \return The id of the window created, or zero if window creation failed.
  *
@@ -702,13 +767,24 @@
 extern DECLSPEC void SDLCALL SDL_RestoreWindow(SDL_WindowID windowID);
 
 /**
+ * \fn int SDL_SetWindowFullscreen(SDL_WindowID windowID, int fullscreen)
+ *
+ * \brief Set the window's fullscreen state.
+ *
+ * \return 0 on success, or -1 if setting the display mode failed.
+ *
+ * \sa SDL_SetFullscreenDisplayMode()
+ */
+extern DECLSPEC int SDLCALL SDL_SetWindowFullscreen(SDL_WindowID windowID,
+                                                    int fullscreen);
+
+/**
  * \fn void SDL_SetWindowGrab(SDL_WindowID windowID, int mode)
  *
  * \brief Set the window's input grab mode.
  *
  * \param mode This is 1 to grab input, and 0 to release input.
  *
- * \sa SDL_GrabMode
  * \sa SDL_GetWindowGrab()
  */
 extern DECLSPEC void SDLCALL SDL_SetWindowGrab(SDL_WindowID windowID,
@@ -721,7 +797,6 @@
  *
  * \return This returns 1 if input is grabbed, and 0 otherwise.
  *
- * \sa SDL_GrabMode
  * \sa SDL_SetWindowGrab()
  */
 extern DECLSPEC int SDLCALL SDL_GetWindowGrab(SDL_WindowID windowID);
@@ -1070,44 +1145,6 @@
 extern DECLSPEC void SDLCALL SDL_DestroyRenderer(SDL_WindowID windowID);
 
 /*
- * Set the gamma correction for each of the color channels.
- * The gamma values range (approximately) between 0.1 and 10.0
- * 
- * If this function isn't supported directly by the hardware, it will
- * be emulated using gamma ramps, if available.  If successful, this
- * function returns 0, otherwise it returns -1.
- */
-extern DECLSPEC int SDLCALL SDL_SetGamma(float red, float green, float blue);
-
-/*
- * Set the gamma translation table for the red, green, and blue channels
- * of the video hardware.  Each table is an array of 256 16-bit quantities,
- * representing a mapping between the input and output for that channel.
- * The input is the index into the array, and the output is the 16-bit
- * gamma value at that index, scaled to the output color precision.
- * 
- * You may pass NULL for any of the channels to leave it unchanged.
- * If the call succeeds, it will return 0.  If the display driver or
- * hardware does not support gamma translation, or otherwise fails,
- * this function will return -1.
- */
-extern DECLSPEC int SDLCALL SDL_SetGammaRamp(const Uint16 * red,
-                                             const Uint16 * green,
-                                             const Uint16 * blue);
-
-/*
- * Retrieve the current values of the gamma translation tables.
- * 
- * You must pass in valid pointers to arrays of 256 16-bit quantities.
- * Any of the pointers may be NULL to ignore that channel.
- * If the call succeeds, it will return 0.  If the display driver or
- * hardware does not support gamma translation, or otherwise fails,
- * this function will return -1.
- */
-extern DECLSPEC int SDLCALL SDL_GetGammaRamp(Uint16 * red, Uint16 * green,
-                                             Uint16 * blue);
-
-/*
  * Maps an RGB triple to an opaque pixel value for a given pixel format
  */
 extern DECLSPEC Uint32 SDLCALL SDL_MapRGB

--- a/src/SDL_compat.c	Sat Jul 08 20:55:39 2006 +0000
+++ b/src/SDL_compat.c	Sun Jul 09 09:02:26 2006 +0000
@@ -360,9 +360,8 @@
     if (flags & SDL_NOFRAME) {
         window_flags |= SDL_WINDOW_BORDERLESS;
     }
-    if (SDL_getenv("SDL_WINDOW_POS")) {
-    }
     GetEnvironmentWindowPosition(width, height, &window_x, &window_y);
+    SDL_SetFullscreenDisplayMode(NULL);
     SDL_VideoWindow =
         SDL_CreateWindow(wm_title, window_x, window_y, width, height,
                          window_flags);
@@ -427,21 +426,9 @@
 
     /* Set the desired display mode */
     if (flags & SDL_FULLSCREEN) {
-        if (!SDL_GetClosestDisplayMode(&mode, &mode)) {
+        if (SDL_SetFullscreenDisplayMode(&mode) < 0) {
             return NULL;
         }
-    } else {
-        if (desktop_format) {
-            mode.format = desktop_format;
-        }
-        if (desktop_mode->w && desktop_mode->h) {
-            mode.w = desktop_mode->w;
-            mode.h = desktop_mode->h;
-        }
-        mode.refresh_rate = desktop_mode->refresh_rate;
-    }
-    if (SDL_SetDisplayMode(&mode) < 0) {
-        return NULL;
     }
 
     /* If we're in OpenGL mode, just create a stub surface and we're done! */

--- a/src/events/SDL_windowevents.c	Sat Jul 08 20:55:39 2006 +0000
+++ b/src/events/SDL_windowevents.c	Sun Jul 09 09:02:26 2006 +0000
@@ -44,19 +44,27 @@
             return 0;
         }
         window->flags |= SDL_WINDOW_SHOWN;
+        SDL_OnWindowShown(window);
         break;
     case SDL_WINDOWEVENT_HIDDEN:
         if (!(window->flags & SDL_WINDOW_SHOWN)) {
             return 0;
         }
         window->flags &= ~SDL_WINDOW_SHOWN;
+        SDL_OnWindowHidden(window);
         break;
     case SDL_WINDOWEVENT_MOVED:
+        if (window->flags & SDL_WINDOW_FULLSCREEN) {
+            return 0;
+        }
         if (data1 == window->x && data2 == window->y) {
             return 0;
         }
         break;
     case SDL_WINDOWEVENT_RESIZED:
+        if (window->flags & SDL_WINDOW_FULLSCREEN) {
+            return 0;
+        }
         if (data1 == window->w && data2 == window->h) {
             return 0;
         }
@@ -96,12 +104,14 @@
             return 0;
         }
         window->flags |= SDL_WINDOW_KEYBOARD_FOCUS;
+        SDL_OnWindowFocusGained(window);
         break;
     case SDL_WINDOWEVENT_FOCUS_LOST:
         if (!(window->flags & SDL_WINDOW_KEYBOARD_FOCUS)) {
             return 0;
         }
         window->flags &= ~SDL_WINDOW_KEYBOARD_FOCUS;
+        SDL_OnWindowFocusLost(window);
         break;
     }
 

--- a/src/video/SDL_gamma.c	Sat Jul 08 20:55:39 2006 +0000
+++ b/src/video/SDL_gamma.c	Sun Jul 09 09:02:26 2006 +0000
@@ -96,24 +96,13 @@
 int
 SDL_SetGamma(float red, float green, float blue)
 {
-    SDL_VideoDevice *_this = SDL_GetVideoDevice();
-    int succeeded;
-
-    succeeded = -1;
-    /* Prefer using SetGammaRamp(), as it's more flexible */
-    {
-        Uint16 ramp[3][256];
+    Uint16 ramp[3][256];
 
-        CalculateGammaRamp(red, ramp[0]);
-        CalculateGammaRamp(green, ramp[1]);
-        CalculateGammaRamp(blue, ramp[2]);
-        succeeded = SDL_SetGammaRamp(ramp[0], ramp[1], ramp[2]);
-    }
-    if ((succeeded < 0) && _this && _this->SetGamma) {
-        SDL_ClearError();
-        succeeded = _this->SetGamma(_this, red, green, blue);
-    }
-    return succeeded;
+    CalculateGammaRamp(red, ramp[0]);
+    CalculateGammaRamp(green, ramp[1]);
+    CalculateGammaRamp(blue, ramp[2]);
+
+    return SDL_SetGammaRamp(ramp[0], ramp[1], ramp[2]);
 }
 
 /* Calculating the gamma by integrating the gamma ramps isn't exact,
@@ -122,24 +111,14 @@
 int
 SDL_GetGamma(float *red, float *green, float *blue)
 {
-    SDL_VideoDevice *_this = SDL_GetVideoDevice();
     int succeeded;
-
-    succeeded = -1;
-    /* Prefer using GetGammaRamp(), as it's more flexible */
-    {
-        Uint16 ramp[3][256];
+    Uint16 ramp[3][256];
 
-        succeeded = SDL_GetGammaRamp(ramp[0], ramp[1], ramp[2]);
-        if (succeeded >= 0) {
-            CalculateGammaFromRamp(red, ramp[0]);
-            CalculateGammaFromRamp(green, ramp[1]);
-            CalculateGammaFromRamp(blue, ramp[2]);
-        }
-    }
-    if ((succeeded < 0) && _this && _this->GetGamma) {
-        SDL_ClearError();
-        succeeded = _this->GetGamma(_this, red, green, blue);
+    succeeded = SDL_GetGammaRamp(ramp[0], ramp[1], ramp[2]);
+    if (succeeded >= 0) {
+        CalculateGammaFromRamp(red, ramp[0]);
+        CalculateGammaFromRamp(green, ramp[1]);
+        CalculateGammaFromRamp(blue, ramp[2]);
     }
     return succeeded;
 }
@@ -152,28 +131,29 @@
     int succeeded;
 
     /* Lazily allocate the gamma tables */
-    if (!SDL_CurrentWindow.gamma) {
-        SDL_GetGammaRamp(0, 0, 0);
+    if (!SDL_CurrentDisplay.gamma) {
+        SDL_GetGammaRamp(NULL, NULL, NULL);
     }
 
     /* Fill the gamma table with the new values */
     if (red) {
-        SDL_memcpy(&SDL_CurrentWindow.gamma[0 * 256], red,
-                   256 * sizeof(*SDL_CurrentWindow.gamma));
+        SDL_memcpy(&SDL_CurrentDisplay.gamma[0 * 256], red,
+                   256 * sizeof(*SDL_CurrentDisplay.gamma));
     }
     if (green) {
-        SDL_memcpy(&SDL_CurrentWindow.gamma[1 * 256], green,
-                   256 * sizeof(*SDL_CurrentWindow.gamma));
+        SDL_memcpy(&SDL_CurrentDisplay.gamma[1 * 256], green,
+                   256 * sizeof(*SDL_CurrentDisplay.gamma));
     }
     if (blue) {
-        SDL_memcpy(&SDL_CurrentWindow.gamma[2 * 256], blue,
-                   256 * sizeof(*SDL_CurrentWindow.gamma));
+        SDL_memcpy(&SDL_CurrentDisplay.gamma[2 * 256], blue,
+                   256 * sizeof(*SDL_CurrentDisplay.gamma));
     }
 
     /* Try to set the gamma ramp in the driver */
     succeeded = -1;
-    if (_this && _this->SetGammaRamp) {
-        succeeded = _this->SetGammaRamp(_this, SDL_CurrentWindow.gamma);
+    if (_this && _this->SetDisplayGammaRamp) {
+        succeeded =
+            _this->SetDisplayGammaRamp(_this, SDL_CurrentDisplay.gamma);
     } else {
         SDL_SetError("Gamma ramp manipulation not supported");
     }
@@ -186,38 +166,42 @@
     SDL_VideoDevice *_this = SDL_GetVideoDevice();
 
     /* Lazily allocate the gamma table */
-    if (!SDL_CurrentWindow.gamma) {
-        SDL_CurrentWindow.gamma =
-            SDL_malloc(3 * 256 * sizeof(*SDL_CurrentWindow.gamma));
-        if (!SDL_CurrentWindow.gamma) {
+    if (!SDL_CurrentDisplay.gamma) {
+        size_t rampsize = (3 * 256 * sizeof(*SDL_CurrentDisplay.gamma));
+
+        SDL_CurrentDisplay.gamma = SDL_malloc(rampsize * 2);
+        if (!SDL_CurrentDisplay.gamma) {
             SDL_OutOfMemory();
             return -1;
         }
-        if (_this && _this->GetGammaRamp) {
+        if (_this && _this->GetDisplayGammaRamp) {
             /* Get the real hardware gamma */
-            _this->GetGammaRamp(_this, SDL_CurrentWindow.gamma);
+            _this->GetDisplayGammaRamp(_this, SDL_CurrentDisplay.gamma);
         } else {
             /* Assume an identity gamma */
             int i;
             for (i = 0; i < 256; ++i) {
-                SDL_CurrentWindow.gamma[0 * 256 + i] = (i << 8) | i;
-                SDL_CurrentWindow.gamma[1 * 256 + i] = (i << 8) | i;
-                SDL_CurrentWindow.gamma[2 * 256 + i] = (i << 8) | i;
+                SDL_CurrentDisplay.gamma[0 * 256 + i] = (i << 8) | i;
+                SDL_CurrentDisplay.gamma[1 * 256 + i] = (i << 8) | i;
+                SDL_CurrentDisplay.gamma[2 * 256 + i] = (i << 8) | i;
             }
         }
+        SDL_CurrentDisplay.saved_gamma = SDL_CurrentDisplay.gamma + (3 * 256);
+        SDL_memcpy(SDL_CurrentDisplay.saved_gamma, SDL_CurrentDisplay.gamma,
+                   rampsize);
     }
 
     /* Just copy from our internal table */
     if (red) {
-        SDL_memcpy(red, &SDL_CurrentWindow.gamma[0 * 256],
+        SDL_memcpy(red, &SDL_CurrentDisplay.gamma[0 * 256],
                    256 * sizeof(*red));
     }
     if (green) {
-        SDL_memcpy(green, &SDL_CurrentWindow.gamma[1 * 256],
+        SDL_memcpy(green, &SDL_CurrentDisplay.gamma[1 * 256],
                    256 * sizeof(*green));
     }
     if (blue) {
-        SDL_memcpy(blue, &SDL_CurrentWindow.gamma[2 * 256],
+        SDL_memcpy(blue, &SDL_CurrentDisplay.gamma[2 * 256],
                    256 * sizeof(*blue));
     }
     return 0;

--- a/src/video/SDL_sysvideo.h	Sat Jul 08 20:55:39 2006 +0000
+++ b/src/video/SDL_sysvideo.h	Sun Jul 09 09:02:26 2006 +0000
@@ -117,14 +117,16 @@
     int w, h;
     Uint32 flags;
 
-    Uint16 *gamma;
-
     int display;
     SDL_Renderer *renderer;
 
     void *userdata;
     void *driverdata;
 };
+#define FULLSCREEN_VISIBLE(W) \
+    ((W->flags & SDL_WINDOW_FULLSCREEN) && \
+     (W->flags & SDL_WINDOW_SHOWN) && \
+     !(W->flags & SDL_WINDOW_MINIMIZED))
 
 /* Define the SDL display structure
    This corresponds to physical monitors attached to the system.
@@ -136,8 +138,13 @@
     SDL_DisplayMode *display_modes;
     SDL_DisplayMode desktop_mode;
     SDL_DisplayMode current_mode;
+    SDL_DisplayMode desired_mode;
+    SDL_DisplayMode *fullscreen_mode;
     SDL_Palette *palette;
 
+    Uint16 *gamma;
+    Uint16 *saved_gamma;        /* (just offset into gamma) */
+
     int num_render_drivers;
     SDL_RenderDriver *render_drivers;
 
@@ -174,6 +181,12 @@
     /* * * */
     /* Display functions
      */
+
+    /* Get a list of the available display modes.
+     * e.g.  SDL_AddDisplayMode(_this->current_display, mode)
+     */
+    void (*GetDisplayModes) (_THIS);
+
     /* Setting the display mode is independent of creating windows,
      * so when the display mode is changed, all existing windows
      * should have their data updated accordingly, including the
@@ -181,12 +194,18 @@
      */
     int (*SetDisplayMode) (_THIS, SDL_DisplayMode * mode);
 
-    /* Sets the color entries of the display palette to those in 'colors'.
-       The return value is 0 if all entries could be set properly or -1
-       otherwise.
-     */
+    /* Set the color entries of the display palette */
     int (*SetDisplayPalette) (_THIS, SDL_Palette * palette);
 
+    /* Get the color entries of the display palette */
+    int (*GetDisplayPalette) (_THIS, SDL_Palette * palette);
+
+    /* Set the gamma ramp */
+    int (*SetDisplayGammaRamp) (_THIS, Uint16 * ramp);
+
+    /* Get the gamma ramp */
+    int (*GetDisplayGammaRamp) (_THIS, Uint16 * ramp);
+
     /* * * */
     /* Window functions
      */
@@ -214,21 +233,6 @@
     void (*VideoQuit) (_THIS);
 
     /* * * */
-    /* Gamma support */
-
-    /* Set the gamma correction directly (emulated with gamma ramps) */
-    int (*SetGamma) (_THIS, float red, float green, float blue);
-
-    /* Get the gamma correction directly (emulated with gamma ramps) */
-    int (*GetGamma) (_THIS, float *red, float *green, float *blue);
-
-    /* Set the gamma ramp */
-    int (*SetGammaRamp) (_THIS, Uint16 * ramp);
-
-    /* Get the gamma ramp */
-    int (*GetGammaRamp) (_THIS, Uint16 * ramp);
-
-    /* * * */
     /* OpenGL support */
 
     /* Sets the dll to use for OpenGL and loads it */
@@ -405,7 +409,6 @@
 #endif
 
 #define SDL_CurrentDisplay	(_this->displays[_this->current_display])
-#define SDL_CurrentWindow	(SDL_CurrentDisplay.windows[0])
 
 extern SDL_VideoDevice *SDL_GetVideoDevice();
 extern int SDL_AddBasicVideoDisplay(const SDL_DisplayMode * desktop_mode);
@@ -418,6 +421,11 @@
 extern SDL_Window *SDL_GetWindowFromID(SDL_WindowID windowID);
 extern SDL_VideoDisplay *SDL_GetDisplayFromWindow(SDL_Window * window);
 
+extern void SDL_OnWindowShown(SDL_Window * window);
+extern void SDL_OnWindowHidden(SDL_Window * window);
+extern void SDL_OnWindowFocusGained(SDL_Window * window);
+extern void SDL_OnWindowFocusLost(SDL_Window * window);
+
 #endif /* _SDL_sysvideo_h */
 
 /* vi: set ts=4 sw=4 expandtab: */

--- a/src/video/SDL_video.c	Sat Jul 08 20:55:39 2006 +0000
+++ b/src/video/SDL_video.c	Sun Jul 09 09:02:26 2006 +0000
@@ -267,13 +267,6 @@
         return (-1);
     }
 
-    /* Sort the video modes */
-    for (i = 0; i < _this->num_displays; ++i) {
-        SDL_qsort(_this->displays[i].display_modes,
-                  _this->displays[i].num_display_modes,
-                  sizeof(SDL_DisplayMode), cmpmodes);
-    }
-
     /* The software renderer is always available */
     for (i = 0; i < _this->num_displays; ++i) {
         if (_this->displays[i].num_render_drivers > 0) {
@@ -398,7 +391,13 @@
 SDL_GetNumDisplayModes()
 {
     if (_this) {
-        return SDL_CurrentDisplay.num_display_modes;
+        SDL_VideoDisplay *display = &SDL_CurrentDisplay;
+        if (!display->num_display_modes && _this->GetDisplayModes) {
+            _this->GetDisplayModes(_this);
+            SDL_qsort(display->display_modes, display->num_display_modes,
+                      sizeof(SDL_DisplayMode), cmpmodes);
+        }
+        return display->num_display_modes;
     }
     return 0;
 }
@@ -460,7 +459,7 @@
     }
 
     match = NULL;
-    for (i = 0; i < SDL_CurrentDisplay.num_display_modes; ++i) {
+    for (i = 0; i < SDL_GetNumDisplayModes(); ++i) {
         current = &SDL_CurrentDisplay.display_modes[i];
 
         if ((current->w && current->h) &&
@@ -602,7 +601,7 @@
     /* Move any fullscreen windows into position */
     for (i = 0; i < display->num_windows; ++i) {
         SDL_Window *window = &display->windows[i];
-        if (window->flags & SDL_WINDOW_FULLSCREEN) {
+        if (FULLSCREEN_VISIBLE(window)) {
             SDL_SetWindowPosition(window->id,
                                   ((display_mode.w - window->w) / 2),
                                   ((display_mode.h - window->h) / 2));
@@ -613,6 +612,44 @@
 }
 
 int
+SDL_SetFullscreenDisplayMode(const SDL_DisplayMode * mode)
+{
+    SDL_VideoDisplay *display;
+    int i;
+
+    if (!_this) {
+        SDL_SetError("Video subsystem has not been initialized");
+        return -1;
+    }
+
+    display = &SDL_CurrentDisplay;
+    if (mode) {
+        SDL_GetClosestDisplayMode(mode, &display->desired_mode);
+        display->fullscreen_mode = &display->desired_mode;
+    } else {
+        display->fullscreen_mode = NULL;
+    }
+
+    /* Actually set the mode if we have a fullscreen window visible */
+    for (i = 0; i < display->num_windows; ++i) {
+        SDL_Window *window = &display->windows[i];
+        if (FULLSCREEN_VISIBLE(window)) {
+            return SDL_SetDisplayMode(display->fullscreen_mode);
+        }
+    }
+    return 0;
+}
+
+const SDL_DisplayMode *
+SDL_GetFullscreenDisplayMode(void)
+{
+    if (_this) {
+        return SDL_CurrentDisplay.fullscreen_mode;
+    }
+    return NULL;
+}
+
+int
 SDL_SetDisplayPalette(const SDL_Color * colors, int firstcolor, int ncolors)
 {
     SDL_Palette *palette;
@@ -939,7 +976,7 @@
         return;
     }
 
-    window->flags |= SDL_WINDOW_SHOWN;
+    SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_SHOWN, 0, 0);
 
     if (_this->ShowWindow) {
         _this->ShowWindow(_this, window);
@@ -955,7 +992,7 @@
         return;
     }
 
-    window->flags &= ~SDL_WINDOW_SHOWN;
+    SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_HIDDEN, 0, 0);
 
     if (_this->HideWindow) {
         _this->HideWindow(_this, window);
@@ -985,7 +1022,7 @@
         return;
     }
 
-    window->flags |= SDL_WINDOW_MAXIMIZED;
+    SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_MAXIMIZED, 0, 0);
 
     if (_this->MaximizeWindow) {
         _this->MaximizeWindow(_this, window);
@@ -1001,7 +1038,7 @@
         return;
     }
 
-    window->flags |= SDL_WINDOW_MINIMIZED;
+    SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_MINIMIZED, 0, 0);
 
     if (_this->MinimizeWindow) {
         _this->MinimizeWindow(_this, window);
@@ -1018,7 +1055,7 @@
         return;
     }
 
-    window->flags &= ~(SDL_WINDOW_MAXIMIZED | SDL_WINDOW_MINIMIZED);
+    SDL_SendWindowEvent(window->id, SDL_WINDOWEVENT_RESTORED, 0, 0);
 
     if (_this->RestoreWindow) {
         _this->RestoreWindow(_this, window);
@@ -1058,6 +1095,43 @@
 }
 
 void
+SDL_OnWindowShown(SDL_Window * window)
+{
+}
+
+void
+SDL_OnWindowHidden(SDL_Window * window)
+{
+}
+
+void
+SDL_OnWindowFocusGained(SDL_Window * window)
+{
+    SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
+
+    if (window->flags & SDL_WINDOW_FULLSCREEN) {
+        SDL_SetDisplayMode(display->fullscreen_mode);
+    }
+    if (display->gamma && _this->SetDisplayGammaRamp) {
+        _this->SetDisplayGammaRamp(_this, display->gamma);
+    }
+}
+
+void
+SDL_OnWindowFocusLost(SDL_Window * window)
+{
+    SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
+
+    if (window->flags & SDL_WINDOW_FULLSCREEN) {
+        SDL_SetDisplayMode(NULL);
+        SDL_MinimizeWindow(window->id);
+    }
+    if (display->gamma && _this->SetDisplayGammaRamp) {
+        _this->SetDisplayGammaRamp(_this, display->saved_gamma);
+    }
+}
+
+void
 SDL_DestroyWindow(SDL_WindowID windowID)
 {
     int i, j;
@@ -1073,6 +1147,12 @@
             if (window->id != windowID) {
                 continue;
             }
+            if (window->flags & SDL_WINDOW_FULLSCREEN) {
+                SDL_SetDisplayMode(NULL);
+            }
+            if (display->gamma && _this->SetDisplayGammaRamp) {
+                _this->SetDisplayGammaRamp(_this, display->saved_gamma);
+            }
             if (window->flags & SDL_WINDOW_INPUT_GRABBED) {
                 window->flags &= ~SDL_WINDOW_INPUT_GRABBED;
                 _this->SetWindowGrab(_this, window);
@@ -1086,9 +1166,6 @@
             if (window->title) {
                 SDL_free(window->title);
             }
-            if (window->gamma) {
-                SDL_free(window->gamma);
-            }
             if (j != display->num_windows - 1) {
                 SDL_memcpy(&display->windows[i],
                            &display->windows[i + 1],
@@ -1868,6 +1945,12 @@
             SDL_FreePalette(display->palette);
             display->palette = NULL;
         }
+        if (display->gamma) {
+            SDL_free(display->gamma);
+        }
+        if (display->driverdata) {
+            SDL_free(display->driverdata);
+        }
     }
     if (_this->displays) {
         SDL_free(_this->displays);

--- a/src/video/win32/SDL_win32events.c	Sat Jul 08 20:55:39 2006 +0000
+++ b/src/video/win32/SDL_win32events.c	Sun Jul 09 09:02:26 2006 +0000
@@ -421,6 +421,18 @@
 
     switch (msg) {
 
+    case WM_SHOWWINDOW:
+        {
+            if (wParam) {
+                SDL_SendWindowEvent(data->windowID, SDL_WINDOWEVENT_SHOWN, 0,
+                                    0);
+            } else {
+                SDL_SendWindowEvent(data->windowID, SDL_WINDOWEVENT_HIDDEN, 0,
+                                    0);
+            }
+        }
+        break;
+
     case WM_ACTIVATE:
         {
             int index;
@@ -452,7 +464,6 @@
                         ClipCursor(&rect);
                     }
                 }
-                /* FIXME: Restore mode state (mode, gamma) */
                 /* FIXME: Update keyboard state */
             } else {
                 if (keyboard && keyboard->focus == data->windowID) {
@@ -467,7 +478,6 @@
                     SDL_SendWindowEvent(data->windowID,
                                         SDL_WINDOWEVENT_MINIMIZED, 0, 0);
                 }
-                /* FIXME: Restore desktop state (mode, gamma) */
             }
             return (0);
         }

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/win32/SDL_win32gamma.c	Sun Jul 09 09:02:26 2006 +0000
@@ -0,0 +1,63 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    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"
+
+#include "SDL_win32video.h"
+
+
+int
+WIN_SetDisplayGammaRamp(_THIS, Uint16 * ramp)
+{
+    SDL_DisplayData *data = (SDL_DisplayData *) SDL_CurrentDisplay.driverdata;
+    HDC hdc;
+    BOOL succeeded = FALSE;
+
+    hdc = CreateDC(data->DeviceName, NULL, NULL, NULL);
+    if (hdc) {
+        succeeded = SetDeviceGammaRamp(hdc, ramp);
+        if (!succeeded) {
+            WIN_SetError("SetDeviceGammaRamp()");
+        }
+        DeleteDC(hdc);
+    }
+    return succeeded ? 0 : -1;
+}
+
+int
+WIN_GetDisplayGammaRamp(_THIS, Uint16 * ramp)
+{
+    SDL_DisplayData *data = (SDL_DisplayData *) SDL_CurrentDisplay.driverdata;
+    HDC hdc;
+    BOOL succeeded = FALSE;
+
+    hdc = CreateDC(data->DeviceName, NULL, NULL, NULL);
+    if (hdc) {
+        succeeded = GetDeviceGammaRamp(hdc, ramp);
+        if (!succeeded) {
+            WIN_SetError("GetDeviceGammaRamp()");
+        }
+        DeleteDC(hdc);
+    }
+    return succeeded ? 0 : -1;
+}
+
+/* vi: set ts=4 sw=4 expandtab: */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/win32/SDL_win32gamma.h	Sun Jul 09 09:02:26 2006 +0000
@@ -0,0 +1,32 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    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_win32gamma_h
+#define _SDL_win32gamma_h
+
+extern int WIN_SetDisplayGammaRamp(_THIS, Uint16 * ramp);
+extern int WIN_GetDisplayGammaRamp(_THIS, Uint16 * ramp);
+
+#endif /* _SDL_win32gamma_h */
+
+/* vi: set ts=4 sw=4 expandtab: */

--- a/src/video/win32/SDL_win32modes.c	Sat Jul 08 20:55:39 2006 +0000
+++ b/src/video/win32/SDL_win32modes.c	Sun Jul 09 09:02:26 2006 +0000
@@ -24,12 +24,6 @@
 #include "SDL_win32video.h"
 
 
-typedef struct
-{
-    TCHAR DeviceName[32];
-    DEVMODE DeviceMode;
-} SDL_DisplayModeData;
-
 /* FIXME: Each call to EnumDisplaySettings() takes about 6 ms on my laptop.
           With 500 or so modes, this takes almost 3 seconds to run!
 */
@@ -123,7 +117,7 @@
 WIN_InitModes(_THIS)
 {
     SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
-    DWORD i, j, k;
+    DWORD i, j;
     DISPLAY_DEVICE device;
 
     device.cb = sizeof(device);
@@ -143,6 +137,7 @@
         for (j = 0;; ++j) {
             int index;
             SDL_VideoDisplay display;
+            SDL_DisplayData *displaydata;
             SDL_DisplayMode mode;
 
             if (!EnumDisplayDevices(DeviceName, j, &device, 0)) {
@@ -157,19 +152,37 @@
             if (!WIN_GetDisplayMode(DeviceName, ENUM_CURRENT_SETTINGS, &mode)) {
                 break;
             }
+
+            displaydata =
+                (SDL_DisplayData *) SDL_malloc(sizeof(*displaydata));
+            if (!displaydata) {
+                continue;
+            }
+            SDL_memcpy(displaydata->DeviceName, DeviceName,
+                       sizeof(DeviceName));
+
             SDL_zero(display);
             display.desktop_mode = mode;
             display.current_mode = mode;
-            index = SDL_AddVideoDisplay(&display);
+            display.driverdata = displaydata;
+            SDL_AddVideoDisplay(&display);
+        }
+    }
+}
 
-            for (k = 0;; ++k) {
-                if (!WIN_GetDisplayMode(DeviceName, k, &mode)) {
-                    break;
-                }
-                if (!SDL_AddDisplayMode(index, &mode)) {
-                    SDL_free(mode.driverdata);
-                }
-            }
+void
+WIN_GetDisplayModes(_THIS)
+{
+    SDL_DisplayData *data = (SDL_DisplayData *) SDL_CurrentDisplay.driverdata;
+    DWORD i;
+    SDL_DisplayMode mode;
+
+    for (i = 0;; ++i) {
+        if (!WIN_GetDisplayMode(data->DeviceName, i, &mode)) {
+            break;
+        }
+        if (!SDL_AddDisplayMode(_this->current_display, &mode)) {
+            SDL_free(mode.driverdata);
         }
     }
 }

--- a/src/video/win32/SDL_win32modes.h	Sat Jul 08 20:55:39 2006 +0000
+++ b/src/video/win32/SDL_win32modes.h	Sun Jul 09 09:02:26 2006 +0000
@@ -24,7 +24,19 @@
 #ifndef _SDL_win32modes_h
 #define _SDL_win32modes_h
 
+typedef struct
+{
+    TCHAR DeviceName[32];
+} SDL_DisplayData;
+
+typedef struct
+{
+    TCHAR DeviceName[32];
+    DEVMODE DeviceMode;
+} SDL_DisplayModeData;
+
 extern void WIN_InitModes(_THIS);
+extern void WIN_GetDisplayModes(_THIS);
 extern int WIN_SetDisplayMode(_THIS, SDL_DisplayMode * mode);
 extern void WIN_QuitModes(_THIS);
 

--- a/src/video/win32/SDL_win32video.c	Sat Jul 08 20:55:39 2006 +0000
+++ b/src/video/win32/SDL_win32video.c	Sun Jul 09 09:02:26 2006 +0000
@@ -84,11 +84,11 @@
 #if SDL_VIDEO_RENDER_D3D
     data->d3dDLL = LoadLibrary(TEXT("D3D9.DLL"));
     if (data->d3dDLL) {
-        IDirect3D9 *WINAPI(*D3DCreate) (UINT SDKVersion);
+        IDirect3D9 *(WINAPI * D3DCreate) (UINT SDKVersion);
 
         D3DCreate =
-            (IDirect3D9 * WINAPI(*)(UINT)) GetProcAddress(data->d3dDLL,
-                                                          "Direct3DCreate9");
+            (IDirect3D9 * (WINAPI *) (UINT)) GetProcAddress(data->d3dDLL,
+                                                            "Direct3DCreate9");
         if (D3DCreate) {
             data->d3d = D3DCreate(D3D_SDK_VERSION);
         }
@@ -101,7 +101,10 @@
 
     /* Set the function pointers */
     device->VideoInit = WIN_VideoInit;
+    device->GetDisplayModes = WIN_GetDisplayModes;
     device->SetDisplayMode = WIN_SetDisplayMode;
+    device->SetDisplayGammaRamp = WIN_SetDisplayGammaRamp;
+    device->GetDisplayGammaRamp = WIN_GetDisplayGammaRamp;
     device->VideoQuit = WIN_VideoQuit;
     device->PumpEvents = WIN_PumpEvents;
 

--- a/src/video/win32/SDL_win32video.h	Sat Jul 08 20:55:39 2006 +0000
+++ b/src/video/win32/SDL_win32video.h	Sun Jul 09 09:02:26 2006 +0000
@@ -36,6 +36,7 @@
 #endif
 
 #include "SDL_win32events.h"
+#include "SDL_win32gamma.h"
 #include "SDL_win32keyboard.h"
 #include "SDL_win32modes.h"
 #include "SDL_win32mouse.h"

--- a/src/video/win32/SDL_win32window.c	Sat Jul 08 20:55:39 2006 +0000
+++ b/src/video/win32/SDL_win32window.c	Sun Jul 09 09:02:26 2006 +0000
@@ -22,6 +22,7 @@
 #include "SDL_config.h"
 
 #include "../SDL_sysvideo.h"
+#include "../../events/SDL_keyboard_c.h"
 
 #include "SDL_win32video.h"
 
@@ -110,6 +111,14 @@
         int index = data->videodata->keyboard;
         window->flags |= SDL_WINDOW_KEYBOARD_FOCUS;
         SDL_SetKeyboardFocus(index, data->windowID);
+
+        if (window->flags & SDL_WINDOW_INPUT_GRABBED) {
+            RECT rect;
+            GetClientRect(hwnd, &rect);
+            ClientToScreen(hwnd, (LPPOINT) & rect);
+            ClientToScreen(hwnd, (LPPOINT) & rect + 1);
+            ClipCursor(&rect);
+        }
     }
 
     /* All done! */

--- a/test/testsprite2.c	Sat Jul 08 20:55:39 2006 +0000
+++ b/test/testsprite2.c	Sun Jul 09 09:02:26 2006 +0000
@@ -162,14 +162,7 @@
         SDL_zero(fullscreen_mode);
         fullscreen_mode.w = window_w;
         fullscreen_mode.h = window_h;
-        mode = &fullscreen_mode;
-    } else {
-        /* Set the desktop mode, we don't care what it is */
-        mode = NULL;
-    }
-    if (SDL_SetDisplayMode(mode) < 0) {
-        fprintf(stderr, "Couldn't set display mode: %s\n", SDL_GetError());
-        quit(2);
+        SDL_SetFullscreenDisplayMode(&fullscreen_mode);
     }
 
     /* Create the windows, initialize the renderers, and load the textures */

--- a/test/testwm2.c	Sat Jul 08 20:55:39 2006 +0000
+++ b/test/testwm2.c	Sun Jul 09 09:02:26 2006 +0000
@@ -49,12 +49,6 @@
         }
     }
 
-    /* Set the desktop mode, we don't care what it is */
-    if (SDL_SetDisplayMode(NULL) < 0) {
-        fprintf(stderr, "Couldn't set display mode: %s\n", SDL_GetError());
-        quit(2);
-    }
-
     /* Create the windows */
     windows = (SDL_WindowID *) SDL_malloc(num_windows * sizeof(*windows));
     if (!windows) {