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

[patch] The patch file

SDLFS.patch (text/plain), 13.66 KB, created by Karl F. Glatzer on 2010-06-21 09:51:43 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Karl F. Glatzer

Created: 2010-06-21 09:51:43 UTC

Size: 13.66 KB

patch

obsolete

>diff -ru a/src/video/SDL_video.c b/src/video/SDL_video.c
>--- a/src/video/SDL_video.c	2010-05-21 14:03:39.577939562 +0200
>+++ b/src/video/SDL_video.c	2010-06-21 18:35:02.775081892 +0200
>@@ -1417,12 +1417,12 @@
> SDL_OnWindowFocusLost(SDL_Window * window)
> {
>     SDL_VideoDisplay *display = window->display;
>-
>-    /* If we're fullscreen on a single-head system and lose focus, minimize */
>+    //TODO: I think this can be removed.
>+    /* If we're fullscreen on a single-head system and lose focus, minimize 
>     if ((window->flags & SDL_WINDOW_FULLSCREEN) &&
>         _this->num_displays == 1) {
>         SDL_MinimizeWindow(window);
>-    }
>+    }*/
> 
>     if (display->gamma && _this->SetDisplayGammaRamp) {
>         _this->SetDisplayGammaRamp(_this, display, display->saved_gamma);
>@@ -3280,8 +3280,9 @@
>     if (!_this || !context) {
>         return;
>     }
>+    //FIXME: Something is broken here 
>    _this->GL_MakeCurrent(_this, NULL, NULL); 
>    _this->GL_DeleteContext(_this, context);
> }
> 
> #if 0                           // FIXME
>diff -ru a/src/video/x11/SDL_x11events.c b/src/video/x11/SDL_x11events.c
>--- a/src/video/x11/SDL_x11events.c	2010-05-21 14:03:39.677938954 +0200
>+++ b/src/video/x11/SDL_x11events.c	2010-06-21 18:06:56.876333009 +0200
>@@ -33,6 +33,8 @@
> #include "SDL_timer.h"
> #include "SDL_syswm.h"
> 
>+int lasttime = 0;
>+
> static void
> X11_DispatchEvent(_THIS)
> {
>@@ -286,6 +288,22 @@
>         }
>         break;
> 
>+    case PropertyNotify:{
>+            Atom _NET_WM_STATE = XInternAtom(videodata->display, "_NET_WM_STATE", False);
>+            if( xevent.xproperty.atom == _NET_WM_STATE )
>+            {
>+                if( X11_CheckWindowFullscreen(data->window) )
>+                {
>+                    data->window->flags |= SDL_WINDOW_FULLSCREEN;
>+                }
>+                else
>+                {
>+                    data->window->flags &= ~SDL_WINDOW_FULLSCREEN;
>+                }
>+            }
>+        }
>+        break;
>+
>     default:{
> #ifdef DEBUG_XEVENTS
>             printf("Unhandled event %d\n", xevent.type);
>@@ -323,6 +341,48 @@
>     return (0);
> }
> 
>+//////////////////////////////////////////////////////////////////////////////////////////////
>+///////////////TODO:There probably is a better place to put this to///////////////////////////
>+//////////////////////////////////////////////////////////////////////////////////////////////
>+static void CheckWindowLoop(_THIS)
>+{
>+    SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata;
>+    SDL_WindowData *data;
>+    XEvent xevent;
>+    int i;
>+    SDL_zero(xevent);           /* valgrind fix. --ryan. */
>+
>+    data = NULL;
>+    if (videodata && videodata->windowlist) {
>+        for (i = 0; i < videodata->numwindows; ++i) {
>+            if ( videodata->windowlist[i] != NULL ) {
>+                data = videodata->windowlist[i];
>+                break;
>+            }
>+        }
>+    }
>+    if (!data){
>+        return;
>+        }
>+        if( SDL_GetTicks() >= lasttime+300 )
>+        {
>+    	//printf("TICKED\n");
>+        if ( data->window->flags & SDL_WINDOW_FULLSCREEN)
>+        {
>+            X11_SetWindowFullscreen( data->window, 1 );
>+        }
>+        else
>+        {
>+            X11_SetWindowFullscreen( data->window, 0 );
>+        }
>+        lasttime = SDL_GetTicks();
>+        }
>+
>+}
>+///////////////////////////////////////////////////////////////////////////////////////////////
>+///////////////////////////////////////////////////////////////////////////////////////////////
>+///////////////////////////////////////////////////////////////////////////////////////////////
>+
> void
> X11_PumpEvents(_THIS)
> {
>@@ -342,6 +402,7 @@
>     while (X11_Pending(data->display)) {
>         X11_DispatchEvent(_this);
>     }
>+    CheckWindowLoop(_this);
> }
> 
> /* This is so wrong it hurts */
>diff -ru a/src/video/x11/SDL_x11window.c b/src/video/x11/SDL_x11window.c
>--- a/src/video/x11/SDL_x11window.c	2010-05-21 14:03:39.687939355 +0200
>+++ b/src/video/x11/SDL_x11window.c	2010-06-21 18:19:20.885083809 +0200
>@@ -136,6 +136,9 @@
>         Atom _NET_WM_STATE_MAXIMIZED_HORZ =
>             XInternAtom(data->videodata->display,
>                         "_NET_WM_STATE_MAXIMIZED_HORZ", False);
>+        Atom _NET_WM_STATE_FULLSCREEN =
>+            XInternAtom(data->videodata->display,
>+                        "_NET_WM_STATE_FULLSCREEN", False);
>         Atom actualType;
>         int actualFormat;
>         unsigned long i, numItems, bytesAfter;
>@@ -148,12 +151,15 @@
>                                &propertyValue) == Success) {
>             Atom *atoms = (Atom *) propertyValue;
>             int maximized = 0;
>+            int fullscreen = 0;
> 
>             for (i = 0; i < numItems; ++i) {
>                 if (atoms[i] == _NET_WM_STATE_MAXIMIZED_VERT) {
>                     maximized |= 1;
>                 } else if (atoms[i] == _NET_WM_STATE_MAXIMIZED_HORZ) {
>                     maximized |= 2;
>+                } else if ( atoms[i] == _NET_WM_STATE_FULLSCREEN) {
>+                    fullscreen = 1;
>                 }
>                 /* Might also want to check the following properties:
>                    _NET_WM_STATE_ABOVE, _NET_WM_STATE_FULLSCREEN
>@@ -161,6 +167,8 @@
>             }
>             if (maximized == 3) {
>                 window->flags |= SDL_WINDOW_MAXIMIZED;
>+            }  else if (fullscreen == 1) {
>+                window->flags |= SDL_WINDOW_FULLSCREEN;
>             }
>             XFree(propertyValue);
>         }
>@@ -222,7 +230,6 @@
>     XSetWindowAttributes xattr;
>     int x, y;
>     Window w;
>-    XSizeHints *sizehints;
>     XWMHints *wmhints;
>     XClassHint *classhints;
> 
>@@ -265,11 +272,7 @@
>         depth = displaydata->depth;
>     }
> 
>-    if (window->flags & SDL_WINDOW_FULLSCREEN) {
>-        xattr.override_redirect = True;
>-    } else {
>-        xattr.override_redirect = False;
>-    }
>+    xattr.override_redirect = False;
>     xattr.background_pixel = 0;
>     xattr.border_pixel = 0;
> 
>@@ -516,8 +519,7 @@
>     w = XCreateWindow(data->display,
>                       RootWindow(data->display, displaydata->screen), x, y,
>                       window->w, window->h, 0, depth, InputOutput, visual,
>-                      (CWOverrideRedirect | CWBackPixel | CWBorderPixel |
>-                       CWColormap), &xattr);
>+                      (CWBackPixel | CWBorderPixel | CWColormap), &xattr);
>     if (!w) {
>         SDL_SetError("Couldn't create window");
>         return -1;
>@@ -535,27 +537,8 @@
>         return -1;
>     }
> #endif
>-
>-    sizehints = XAllocSizeHints();
>-    if (sizehints) {
>-        if (!(window->flags & SDL_WINDOW_RESIZABLE)
>-            || (window->flags & SDL_WINDOW_FULLSCREEN)) {
>-            sizehints->min_width = sizehints->max_width = window->w;
>-            sizehints->min_height = sizehints->max_height = window->h;
>-            sizehints->flags = PMaxSize | PMinSize;
>-        }
>-        if (!(window->flags & SDL_WINDOW_FULLSCREEN)
>-            && window->x != SDL_WINDOWPOS_UNDEFINED
>-            && window->y != SDL_WINDOWPOS_UNDEFINED) {
>-            sizehints->x = x;
>-            sizehints->y = y;
>-            sizehints->flags |= USPosition;
>-        }
>-        XSetWMNormalHints(data->display, w, sizehints);
>-        XFree(sizehints);
>-    }
>-
>-    if (window->flags & (SDL_WINDOW_BORDERLESS | SDL_WINDOW_FULLSCREEN)) {
>+    //FIXME: I'm not sure if this is needed.
>+    if (window->flags & ( SDL_WINDOW_BORDERLESS | SDL_WINDOW_FULLSCREEN ) ) {
>         SDL_bool set;
>         Atom WM_HINTS;
> 
>@@ -643,23 +626,6 @@
>         }
>     }
> 
>-    /* Tell KDE to keep fullscreen windows on top */
>-    if (window->flags & SDL_WINDOW_FULLSCREEN) {
>-        XEvent ev;
>-
>-        SDL_zero(ev);
>-        ev.xclient.type = ClientMessage;
>-        ev.xclient.window = RootWindow(data->display, displaydata->screen);
>-        ev.xclient.message_type =
>-            XInternAtom(data->display, "KWM_KEEP_ON_TOP", False);
>-        ev.xclient.format = 32;
>-        ev.xclient.data.l[0] = w;
>-        ev.xclient.data.l[1] = CurrentTime;
>-        XSendEvent(data->display,
>-                   RootWindow(data->display, displaydata->screen), False,
>-                   SubstructureRedirectMask, &ev);
>-    }
>-
>     /* Set the input hints so we get keyboard input */
>     wmhints = XAllocWMHints();
>     if (wmhints) {
>@@ -870,6 +836,92 @@
>     XResizeWindow(display, data->xwindow, window->w, window->h);
> }
> 
>+int
>+X11_CheckWindowFullscreen(SDL_Window * window )
>+{
>+    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
>+    Display *display = data->videodata->display;
>+
>+	int isfullscreen = 0;
>+	unsigned char *atomdata;
>+	Atom *atoms;
>+	int status, real_format;
>+	Atom real_type;
>+	unsigned long items_read, items_left, i;
>+	int result = 1;
>+	Atom _NET_WM_STATE;
>+	Atom _NET_WM_STATE_FULLSCREEN;
>+
>+	_NET_WM_STATE = XInternAtom( display, "_NET_WM_STATE", 0 );
>+	_NET_WM_STATE_FULLSCREEN = XInternAtom( display, "_NET_WM_STATE_FULLSCREEN", 0 );
>+
>+	status = XGetWindowProperty( display, data->xwindow, _NET_WM_STATE,
>+		0L, 8192L, False, XA_ATOM, &real_type, &real_format,
>+		&items_read, &items_left, &atomdata );
>+
>+	if( status != Success )
>+	{
>+		return -1;
>+	}
>+
>+	atoms = (Atom *)atomdata;
>+	for( i = 0; result && i < items_read; i++ )
>+	{
>+		if( atoms[i] == _NET_WM_STATE_FULLSCREEN )
>+		{
>+			isfullscreen = 1;
>+			break;
>+		}
>+	}
>+
>+	if( isfullscreen == 1 )
>+	{
>+
>+		return 1;
>+	}
>+	else
>+	{
>+		return 0;
>+	}
>+
>+	XFree( atomdata );
>+}
>+
>+int
>+X11_SetWindowFullscreen(SDL_Window * window, SDL_bool setFullscreen )
>+{
>+    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
>+    SDL_DisplayData *displaydata =
>+        (SDL_DisplayData *) window->display->driverdata;
>+    Display *display = data->videodata->display;
>+
>+	int result, status = 0;
>+	Atom _NET_WM_STATE;
>+	Atom _NET_WM_STATE_FULLSCREEN;
>+
>+	_NET_WM_STATE = XInternAtom( display, "_NET_WM_STATE", 0 );
>+	_NET_WM_STATE_FULLSCREEN = XInternAtom( display, "_NET_WM_STATE_FULLSCREEN", 0 );
>+
>+    XEvent e;
>+
>+    e.xany.type = ClientMessage;
>+    e.xany.window = data->xwindow;
>+    e.xclient.message_type = _NET_WM_STATE;
>+    e.xclient.format = 32;
>+    e.xclient.data.l[0] =
>+        setFullscreen ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE;
>+    e.xclient.data.l[1] = _NET_WM_STATE_FULLSCREEN;
>+    e.xclient.data.l[2] = 0;
>+
>+	status =  XSendEvent(display, RootWindow(display, displaydata->screen), 0,
>+               SubstructureNotifyMask | SubstructureRedirectMask, &e);
>+
>+    if( status != Success )
>+	{
>+		return -1;
>+	}
>+}
>+
> void
> X11_ShowWindow(_THIS, SDL_Window * window)
> {
>@@ -935,9 +987,32 @@
> void
> X11_MinimizeWindow(_THIS, SDL_Window * window)
> {
>-    X11_HideWindow(_this, window);
>+    SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
>+    SDL_DisplayData *displaydata =
>+        (SDL_DisplayData *) window->display->driverdata;
>+    Display *display = data->videodata->display;
>+    Atom _NET_WM_STATE = XInternAtom( display, "_NET_WM_STATE", False );
>+    Atom _NET_WM_STATE_HIDDEN = XInternAtom( display, "_NET_WM_STATE_HIDDEN", False );
>+    XEvent e;
>+
>+    e.xclient.type = ClientMessage;
>+    e.xclient.window = data->xwindow;
>+    e.xclient.format = 32;
>+
>+    XIconifyWindow( display, data->xwindow, displaydata->screen );
>+
>+    e.xclient.message_type = _NET_WM_STATE;
>+    e.xclient.data.l[0] = _NET_WM_STATE_ADD;
>+    e.xclient.data.l[1] = _NET_WM_STATE_HIDDEN;
>+    e.xclient.data.l[2] = 0;
>+
>+    XSendEvent(display, RootWindow(display, displaydata->screen), 0,
>+               SubstructureNotifyMask, &e);
>+
> }
> 
>+//TODO: Proper X11_HideWindow for not showing the Window without minimizing.
>+
> void
> X11_RestoreWindow(_THIS, SDL_Window * window)
> {
>@@ -950,26 +1025,26 @@
> {
>     SDL_WindowData *data = (SDL_WindowData *) window->driverdata;
>     Display *display = data->videodata->display;
>+    int i;
> 
>-    if ((window->flags & (SDL_WINDOW_INPUT_GRABBED | SDL_WINDOW_FULLSCREEN))
>+    if ((window->flags & (SDL_WINDOW_INPUT_GRABBED))
>         && (window->flags & SDL_WINDOW_INPUT_FOCUS)) {
>+        //TODO: Implement a more "consistent" way to grab the mouse, without taking it forever
>         /* Try to grab the mouse */
>-        for (;;) {
>+        for(i = 0; i < 3 ; i++)
>+        {
>             int result =
>-                XGrabPointer(display, data->xwindow, True, 0, GrabModeAsync,
>-                             GrabModeAsync, data->xwindow, None, CurrentTime);
>+            XGrabPointer(display, data->xwindow, True, 0, GrabModeAsync,
>+                        GrabModeAsync, data->xwindow, None, CurrentTime);
>             if (result == GrabSuccess) {
>-                break;
>-            }
>-            SDL_Delay(100);
>+        	break;
>+        	}
>+        SDL_Delay(100);
>         }
> 
>-        /* Raise the window if we grab the mouse */
>-        XRaiseWindow(display, data->xwindow);
>-
>-        /* Now grab the keyboard */
>+        /* FIXME: We shouldn't grab the Keyboard. Remove?
>         XGrabKeyboard(display, data->xwindow, True, GrabModeAsync,
>-                      GrabModeAsync, CurrentTime);
>+                      GrabModeAsync, CurrentTime); */
>     } else {
>         XUngrabPointer(display, CurrentTime);
>         XUngrabKeyboard(display, CurrentTime);
>diff -ru a/src/video/x11/SDL_x11window.h b/src/video/x11/SDL_x11window.h
>--- a/src/video/x11/SDL_x11window.h	2010-05-21 14:03:39.687939355 +0200
>+++ b/src/video/x11/SDL_x11window.h	2010-06-20 10:44:09.286327371 +0200
>@@ -39,6 +39,8 @@
> extern void X11_SetWindowIcon(_THIS, SDL_Window * window, SDL_Surface * icon);
> extern void X11_SetWindowPosition(_THIS, SDL_Window * window);
> extern void X11_SetWindowSize(_THIS, SDL_Window * window);
>+extern int X11_CheckWindowFullscreen(SDL_Window * window );
>+extern int X11_SetWindowFullscreen(SDL_Window * window, SDL_bool setFullscreen );
> extern void X11_ShowWindow(_THIS, SDL_Window * window);
> extern void X11_HideWindow(_THIS, SDL_Window * window);
> extern void X11_RaiseWindow(_THIS, SDL_Window * window);

Actions: View | Diff

Attachments on bug 1008: 510

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

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