Allow the render context to do necessary work when the video mode changes.

--HG--
extra : convert_revision : svn%3Ac70aab31-4412-0410-b14c-859654838e24/trunk%402017

src/events/SDL_windowevents.c

@@ -72,6 +72,7 @@ SDL_SendWindowEvent(SDL_WindowID windowID, Uint8 windowevent, int data1,
         }
         window->w = data1;
         window->h = data2;
+        SDL_OnWindowResized(window);
         break;
     case SDL_WINDOWEVENT_MINIMIZED:
         if (window->flags & SDL_WINDOW_MINIMIZED) {

src/video/SDL_renderer_gl.c

@@ -34,6 +34,7 @@
 
 static SDL_Renderer *GL_CreateRenderer(SDL_Window * window, Uint32 flags);
 static int GL_ActivateRenderer(SDL_Renderer * renderer);
+static int GL_DisplayModeChanged(SDL_Renderer * renderer);
 static int GL_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture);
 static int GL_SetTexturePalette(SDL_Renderer * renderer,
                                 SDL_Texture * texture,
@@ -97,6 +98,7 @@ SDL_RenderDriver GL_RenderDriver = {
 typedef struct
 {
     SDL_GLContext context;
+    SDL_bool updateSize;
     SDL_bool GL_ARB_texture_rectangle_supported;
     int blendMode;
     int scaleMode;
@@ -219,6 +221,7 @@ GL_CreateRenderer(SDL_Window * window, Uint32 flags)
     }
 
     renderer->ActivateRenderer = GL_ActivateRenderer;
+    renderer->DisplayModeChanged = GL_DisplayModeChanged;
     renderer->CreateTexture = GL_CreateTexture;
     renderer->SetTexturePalette = GL_SetTexturePalette;
     renderer->GetTexturePalette = GL_GetTexturePalette;
@@ -282,13 +285,7 @@ GL_CreateRenderer(SDL_Window * window, Uint32 flags)
     } else {
         data->glEnable(GL_TEXTURE_2D);
     }
-    data->glMatrixMode(GL_PROJECTION);
-    data->glLoadIdentity();
-    data->glMatrixMode(GL_MODELVIEW);
-    data->glLoadIdentity();
-    data->glViewport(0, 0, window->w, window->h);
-    data->glOrtho(0.0, (GLdouble) window->w, (GLdouble) window->h, 0.0, 0.0,
-                  1.0);
+    data->updateSize = SDL_TRUE;
 
     return renderer;
 }
@@ -299,7 +296,29 @@ GL_ActivateRenderer(SDL_Renderer * renderer)
     GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
     SDL_Window *window = SDL_GetWindowFromID(renderer->window);
 
-    return SDL_GL_MakeCurrent(window->id, data->context);
+    if (SDL_GL_MakeCurrent(window->id, data->context) < 0) {
+        return -1;
+    }
+    if (data->updateSize) {
+        data->glMatrixMode(GL_PROJECTION);
+        data->glLoadIdentity();
+        data->glMatrixMode(GL_MODELVIEW);
+        data->glLoadIdentity();
+        data->glViewport(0, 0, window->w, window->h);
+        data->glOrtho(0.0, (GLdouble) window->w, (GLdouble) window->h, 0.0,
+                      0.0, 1.0);
+        data->updateSize = SDL_FALSE;
+    }
+    return 0;
+}
+
+static int
+GL_DisplayModeChanged(SDL_Renderer * renderer)
+{
+    GL_RenderData *data = (GL_RenderData *) renderer->driverdata;
+
+    data->updateSize = SDL_TRUE;
+    return 0;
 }
 
 static __inline__ int

src/video/SDL_renderer_sw.c

@@ -31,6 +31,8 @@
 /* SDL surface based renderer implementation */
 
 static SDL_Renderer *SW_CreateRenderer(SDL_Window * window, Uint32 flags);
+static int SW_ActivateRenderer(SDL_Renderer * renderer);
+static int SW_DisplayModeChanged(SDL_Renderer * renderer);
 static int SW_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture);
 static int SW_QueryTexturePixels(SDL_Renderer * renderer,
                                  SDL_Texture * texture, void **pixels,
@@ -179,7 +181,8 @@ SW_CreateRenderer(SDL_Window * window, Uint32 flags)
         SDL_OutOfMemory();
         return NULL;
     }
-
+    renderer->ActivateRenderer = SW_ActivateRenderer;
+    renderer->DisplayModeChanged = SW_DisplayModeChanged;
     renderer->CreateTexture = SW_CreateTexture;
     renderer->QueryTexturePixels = SW_QueryTexturePixels;
     renderer->SetTexturePalette = SW_SetTexturePalette;
@@ -269,6 +272,32 @@ SW_CreateRenderer(SDL_Window * window, Uint32 flags)
     return renderer;
 }
 
+static int
+SW_ActivateRenderer(SDL_Renderer * renderer)
+{
+    SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
+
+    if (data->renderer && data->renderer->ActivateRenderer) {
+        if (data->renderer->ActivateRenderer(data->renderer) < 0) {
+            return -1;
+        }
+    }
+    return 0;
+}
+
+static int
+SW_DisplayModeChanged(SDL_Renderer * renderer)
+{
+    SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
+
+    if (data->renderer && data->renderer->DisplayModeChanged) {
+        if (data->renderer->DisplayModeChanged(data->renderer) < 0) {
+            return -1;
+        }
+    }
+    return 0;
+}
+
 static int
 SW_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
 {

src/video/SDL_sysvideo.h

@@ -56,6 +56,7 @@ struct SDL_Texture
 struct SDL_Renderer
 {
     int (*ActivateRenderer) (SDL_Renderer * renderer);
+    int (*DisplayModeChanged) (SDL_Renderer * renderer);
     int (*CreateTexture) (SDL_Renderer * renderer, SDL_Texture * texture);
     int (*QueryTexturePixels) (SDL_Renderer * renderer, SDL_Texture * texture,
                                void **pixels, int *pitch);
@@ -133,8 +134,7 @@ struct SDL_VideoDisplay
     SDL_DisplayMode *display_modes;
     SDL_DisplayMode desktop_mode;
     SDL_DisplayMode current_mode;
-    SDL_DisplayMode desired_mode;
-    SDL_DisplayMode *fullscreen_mode;
+    SDL_DisplayMode fullscreen_mode;
     SDL_Palette *palette;
 
     Uint16 *gamma;
@@ -389,6 +389,7 @@ 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_OnWindowResized(SDL_Window * window);
 extern void SDL_OnWindowFocusGained(SDL_Window * window);
 extern void SDL_OnWindowFocusLost(SDL_Window * window);
 extern SDL_WindowID SDL_GetFocusWindow(void);

src/video/SDL_video.c

@@ -645,6 +645,7 @@ int
 SDL_SetFullscreenDisplayMode(const SDL_DisplayMode * mode)
 {
     SDL_VideoDisplay *display;
+    SDL_DisplayMode fullscreen_mode;
     int i;
 
     if (!_this) {
@@ -653,18 +654,29 @@ SDL_SetFullscreenDisplayMode(const SDL_DisplayMode * mode)
     }
 
     display = &SDL_CurrentDisplay;
-    if (mode) {
-        SDL_GetClosestDisplayMode(mode, &display->desired_mode);
-        display->fullscreen_mode = &display->desired_mode;
-    } else {
-        display->fullscreen_mode = NULL;
+    if (!mode) {
+        mode = &display->desktop_mode;
     }
 
+    SDL_GetClosestDisplayMode(mode, &fullscreen_mode);
+    if (SDL_memcmp
+        (&fullscreen_mode, &display->fullscreen_mode,
+         sizeof(fullscreen_mode)) == 0) {
+        /* Nothing to do... */
+        return 0;
+    }
+    display->fullscreen_mode = fullscreen_mode;
+
     /* 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);
+            if (SDL_SetDisplayMode(&display->fullscreen_mode) < 0) {
+                return -1;
+            }
+        }
+        if (window->flags & SDL_WINDOW_FULLSCREEN) {
+            SDL_OnWindowResized(window);
         }
     }
     return 0;
@@ -678,7 +690,7 @@ SDL_GetFullscreenDisplayMode(SDL_DisplayMode * mode)
         return -1;
     }
     if (mode) {
-        *mode = *SDL_CurrentDisplay.fullscreen_mode;
+        *mode = SDL_CurrentDisplay.fullscreen_mode;
     }
     return 0;
 }
@@ -1197,7 +1209,7 @@ SDL_SetWindowFullscreen(SDL_WindowID windowID, int fullscreen)
                 }
             }
 
-            SDL_SetDisplayMode(display->fullscreen_mode);
+            SDL_SetDisplayMode(&display->fullscreen_mode);
         }
     } else {
         window->flags &= ~SDL_WINDOW_FULLSCREEN;
@@ -1251,13 +1263,23 @@ SDL_OnWindowHidden(SDL_Window * window)
 {
 }
 
+void
+SDL_OnWindowResized(SDL_Window * window)
+{
+    SDL_Renderer *renderer = window->renderer;
+
+    if (renderer && renderer->DisplayModeChanged) {
+        renderer->DisplayModeChanged(renderer);
+    }
+}
+
 void
 SDL_OnWindowFocusGained(SDL_Window * window)
 {
     SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
 
     if (window->flags & SDL_WINDOW_FULLSCREEN) {
-        SDL_SetDisplayMode(display->fullscreen_mode);
+        SDL_SetDisplayMode(&display->fullscreen_mode);
     }
     if (display->gamma && _this->SetDisplayGammaRamp) {
         _this->SetDisplayGammaRamp(_this, display->gamma);

src/video/cocoa/SDL_cocoaopengl.m

@@ -268,6 +268,7 @@ Cocoa_GL_MakeCurrent(_THIS, SDL_Window * window, SDL_GLContext context)
         NSOpenGLContext *nscontext = (NSOpenGLContext *)context;
 
         [nscontext setView:[windowdata->window contentView]];
+        [nscontext update];
         [nscontext makeCurrentContext];
     } else {
         [NSOpenGLContext clearCurrentContext];

test/common.c

@@ -749,15 +749,15 @@ PrintEvent(SDL_Event * event)
             fprintf(stderr, "Window %d hidden", event->window.windowID);
             break;
         case SDL_WINDOWEVENT_EXPOSED:
-            fprintf(stderr, "Window %d exposed: %d", event->window.windowID);
+            fprintf(stderr, "Window %d exposed", event->window.windowID);
             break;
         case SDL_WINDOWEVENT_MOVED:
-            fprintf(stderr, "Window %d moved to %d,%d: %d",
+            fprintf(stderr, "Window %d moved to %d,%d",
                     event->window.windowID, event->window.data1,
                     event->window.data2);
             break;
         case SDL_WINDOWEVENT_RESIZED:
-            fprintf(stderr, "Window %d resized to %dx%d: %d",
+            fprintf(stderr, "Window %d resized to %dx%d",
                     event->window.windowID, event->window.data1,
                     event->window.data2);
             break;