d2bbe9a98afbce4cac569568cf3f0e2caf1508c9
[freeglut] / src / Common / freeglut_gamemode.c
1 /*\r
2  * freeglut_gamemode.c\r
3  *\r
4  * The game mode handling code.\r
5  *\r
6  * Copyright (c) 1999-2000 Pawel W. Olszta. All Rights Reserved.\r
7  * Written by Pawel W. Olszta, <olszta@sourceforge.net>\r
8  * Creation date: Thu Dec 16 1999\r
9  *\r
10  * Permission is hereby granted, free of charge, to any person obtaining a\r
11  * copy of this software and associated documentation files (the "Software"),\r
12  * to deal in the Software without restriction, including without limitation\r
13  * the rights to use, copy, modify, merge, publish, distribute, sublicense,\r
14  * and/or sell copies of the Software, and to permit persons to whom the\r
15  * Software is furnished to do so, subject to the following conditions:\r
16  *\r
17  * The above copyright notice and this permission notice shall be included\r
18  * in all copies or substantial portions of the Software.\r
19  *\r
20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS\r
21  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r
22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL\r
23  * PAWEL W. OLSZTA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\r
24  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
25  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
26  */\r
27 \r
28 #include <GL/freeglut.h>\r
29 #include "freeglut_internal.h"\r
30 \r
31 /*\r
32  * TODO BEFORE THE STABLE RELEASE:\r
33  *\r
34  *  glutGameModeString()    -- missing\r
35  *  glutEnterGameMode()     -- X11 version\r
36  *  glutLeaveGameMode()     -- is that correct?\r
37  *  glutGameModeGet()       -- is that correct?\r
38  */\r
39 \r
40 \r
41 /* -- PRIVATE FUNCTIONS ---------------------------------------------------- */\r
42 extern void fgPlatformRememberState( void );\r
43 extern void fgPlatformRestoreState( void );\r
44 extern GLboolean fgPlatformChangeDisplayMode( GLboolean haveToTest );\r
45 \r
46 \r
47 #if TARGET_HOST_POSIX_X11\r
48 static int xrandr_resize(int xsz, int ysz, int rate, int just_checking)\r
49 {\r
50 #ifdef HAVE_X11_EXTENSIONS_XRANDR_H\r
51     int event_base, error_base, ver_major, ver_minor, use_rate;\r
52     XRRScreenConfiguration *xrr_config = 0;\r
53     Status result = -1;\r
54 \r
55     /* must check at runtime for the availability of the extension */\r
56     if(!XRRQueryExtension(fgDisplay.Display, &event_base, &error_base)) {\r
57         return -1;\r
58     }\r
59 \r
60     XRRQueryVersion(fgDisplay.Display, &ver_major, &ver_minor);\r
61 \r
62     /* we only heed the rate if we CAN actually use it (Xrandr >= 1.1) and\r
63      * the user actually cares about it (rate > 0)\r
64      */\r
65     use_rate = ( rate > 0 ) && ( ( ver_major >= 1 ) ||\r
66                                          ( ( ver_major == 1 ) && ( ver_minor >= 1 ) ) );\r
67 \r
68     /* this loop is only so that the whole thing will be repeated if someone\r
69      * else changes video mode between our query of the current information and\r
70      * the attempt to change it.\r
71      */\r
72     do {\r
73         XRRScreenSize *ssizes;\r
74         short *rates;\r
75         Rotation rot;\r
76         int i, ssizes_count, rates_count, curr, res_idx = -1;\r
77         Time timestamp, cfg_timestamp;\r
78 \r
79         if(xrr_config) {\r
80             XRRFreeScreenConfigInfo(xrr_config);\r
81         }\r
82 \r
83         if(!(xrr_config = XRRGetScreenInfo(fgDisplay.Display, fgDisplay.RootWindow))) {\r
84             fgWarning("XRRGetScreenInfo failed");\r
85             break;\r
86         }\r
87         ssizes = XRRConfigSizes(xrr_config, &ssizes_count);\r
88         curr = XRRConfigCurrentConfiguration(xrr_config, &rot);\r
89         timestamp = XRRConfigTimes(xrr_config, &cfg_timestamp);\r
90 \r
91         /* if either of xsz or ysz are unspecified, use the current values */\r
92         if(xsz <= 0)\r
93             xsz = fgState.GameModeSize.X = ssizes[curr].width;\r
94         if(ysz <= 0)\r
95             ysz = fgState.GameModeSize.Y = ssizes[curr].height;\r
96 \r
97 \r
98         if(xsz == ssizes[curr].width && ysz == ssizes[curr].height) {\r
99             /* no need to switch, we're already in the requested resolution */\r
100             res_idx = curr;\r
101         } else {\r
102             for(i=0; i<ssizes_count; i++) {\r
103                 if(ssizes[i].width == xsz && ssizes[i].height == ysz) {\r
104                     res_idx = i;\r
105                     break;  /* found it */\r
106                 }\r
107             }\r
108         }\r
109         if(res_idx == -1)\r
110             break;  /* no matching resolution */\r
111 \r
112 #if ( RANDR_MAJOR >= 1 ) || ( ( RANDR_MAJOR == 1 ) && ( RANDR_MINOR >= 1 ) )\r
113         if(use_rate) {\r
114             rate = fgState.GameModeRefresh;\r
115 \r
116             /* for the selected resolution, let's find out if there is\r
117              * a matching refresh rate available.\r
118              */\r
119             rates = XRRConfigRates(xrr_config, res_idx, &rates_count);\r
120 \r
121             for(i=0; i<rates_count; i++) {\r
122                 if(rates[i] == rate) {\r
123                     break;\r
124                 }\r
125             }\r
126             if(i == rates_count) {\r
127                 break; /* no matching rate */\r
128             }\r
129         }\r
130 #endif\r
131 \r
132         if(just_checking) {\r
133             result = 0;\r
134             break;\r
135         }\r
136 \r
137 #if ( RANDR_MAJOR >= 1 ) || ( ( RANDR_MAJOR == 1 ) && ( RANDR_MINOR >= 1 ) )\r
138         if(use_rate)\r
139             result = XRRSetScreenConfigAndRate(fgDisplay.Display, xrr_config,\r
140                     fgDisplay.RootWindow, res_idx, rot, rate, timestamp);\r
141         else\r
142 #endif\r
143             result = XRRSetScreenConfig(fgDisplay.Display, xrr_config,\r
144                     fgDisplay.RootWindow, res_idx, rot, timestamp);\r
145 \r
146     } while(result == RRSetConfigInvalidTime);\r
147 \r
148     if(xrr_config) {\r
149         XRRFreeScreenConfigInfo(xrr_config);\r
150     }\r
151 \r
152     if(result == 0) {\r
153         return 0;\r
154     }\r
155 \r
156 #endif  /* HAVE_X11_EXTENSIONS_XRANDR_H */\r
157     return -1;\r
158 }\r
159 #endif  /* TARGET_HOST_POSIX_X11 */\r
160 \r
161 #if TARGET_HOST_POSIX_X11\r
162 /*\r
163  * Remembers the current visual settings, so that\r
164  * we can change them and restore later...\r
165  */\r
166 static void fgPlatformRememberState( void )\r
167 {\r
168     int event_base, error_base;\r
169 \r
170     /*\r
171      * Remember the current pointer location before going fullscreen\r
172      * for restoring it later:\r
173      */\r
174     Window junk_window;\r
175     unsigned int junk_mask;\r
176 \r
177     XQueryPointer(fgDisplay.Display, fgDisplay.RootWindow,\r
178             &junk_window, &junk_window,\r
179             &fgDisplay.DisplayPointerX, &fgDisplay.DisplayPointerY,\r
180             &fgDisplay.DisplayPointerX, &fgDisplay.DisplayPointerY, &junk_mask);\r
181 \r
182 #   ifdef HAVE_X11_EXTENSIONS_XRANDR_H\r
183     if(XRRQueryExtension(fgDisplay.Display, &event_base, &error_base)) {\r
184         XRRScreenConfiguration *xrr_config;\r
185         XRRScreenSize *ssizes;\r
186         Rotation rot;\r
187         int ssize_count, curr;\r
188 \r
189         if((xrr_config = XRRGetScreenInfo(fgDisplay.Display, fgDisplay.RootWindow))) {\r
190             ssizes = XRRConfigSizes(xrr_config, &ssize_count);\r
191             curr = XRRConfigCurrentConfiguration(xrr_config, &rot);\r
192 \r
193             fgDisplay.prev_xsz = ssizes[curr].width;\r
194             fgDisplay.prev_ysz = ssizes[curr].height;\r
195             fgDisplay.prev_refresh = -1;\r
196 \r
197 #       if ( RANDR_MAJOR >= 1 ) || ( ( RANDR_MAJOR == 1 ) && ( RANDR_MINOR >= 1 ) )\r
198             if(fgState.GameModeRefresh != -1) {\r
199                 fgDisplay.prev_refresh = XRRConfigCurrentRate(xrr_config);\r
200             }\r
201 #       endif\r
202 \r
203             fgDisplay.prev_size_valid = 1;\r
204 \r
205             XRRFreeScreenConfigInfo(xrr_config);\r
206         }\r
207     }\r
208 #   endif\r
209 \r
210     /*\r
211      * This highly depends on the XFree86 extensions,\r
212      * not approved as X Consortium standards\r
213      */\r
214 #   ifdef HAVE_X11_EXTENSIONS_XF86VMODE_H\r
215     if(!XF86VidModeQueryExtension(fgDisplay.Display, &event_base, &error_base)) {\r
216         return;\r
217     }\r
218 \r
219     /*\r
220      * Remember the current ViewPort location of the screen to be able to\r
221      * restore the ViewPort on LeaveGameMode():\r
222      */\r
223     if( !XF86VidModeGetViewPort(\r
224              fgDisplay.Display,\r
225              fgDisplay.Screen,\r
226              &fgDisplay.DisplayViewPortX,\r
227              &fgDisplay.DisplayViewPortY ) )\r
228         fgWarning( "XF86VidModeGetViewPort failed" );\r
229 \r
230 \r
231     /* Query the current display settings: */\r
232     fgDisplay.DisplayModeValid =\r
233       XF86VidModeGetModeLine(\r
234         fgDisplay.Display,\r
235         fgDisplay.Screen,\r
236         &fgDisplay.DisplayModeClock,\r
237         &fgDisplay.DisplayMode\r
238     );\r
239 \r
240     if( !fgDisplay.DisplayModeValid )\r
241         fgWarning( "XF86VidModeGetModeLine failed" );\r
242 #   endif\r
243 \r
244 }\r
245 #endif\r
246 \r
247 #if TARGET_HOST_POSIX_X11\r
248 /*\r
249  * Restores the previously remembered visual settings\r
250  */\r
251 static void fgPlatformRestoreState( void )\r
252 {\r
253     /* Restore the remembered pointer position: */\r
254     XWarpPointer(\r
255         fgDisplay.Display, None, fgDisplay.RootWindow, 0, 0, 0, 0,\r
256         fgDisplay.DisplayPointerX, fgDisplay.DisplayPointerY\r
257     );\r
258 \r
259 \r
260 #   ifdef HAVE_X11_EXTENSIONS_XRANDR_H\r
261     if(fgDisplay.prev_size_valid) {\r
262         if(xrandr_resize(fgDisplay.prev_xsz, fgDisplay.prev_ysz, fgDisplay.prev_refresh, 0) != -1) {\r
263             fgDisplay.prev_size_valid = 0;\r
264 #       ifdef HAVE_X11_EXTENSIONS_XF86VMODE_H\r
265             fgDisplay.DisplayModeValid = 0;\r
266 #       endif\r
267             return;\r
268         }\r
269     }\r
270 #   endif\r
271 \r
272 \r
273 \r
274 #   ifdef HAVE_X11_EXTENSIONS_XF86VMODE_H\r
275     /*\r
276      * This highly depends on the XFree86 extensions,\r
277      * not approved as X Consortium standards\r
278      */\r
279 \r
280     if( fgDisplay.DisplayModeValid )\r
281     {\r
282         XF86VidModeModeInfo** displayModes;\r
283         int i, displayModesCount;\r
284 \r
285         if( !XF86VidModeGetAllModeLines(\r
286                  fgDisplay.Display,\r
287                  fgDisplay.Screen,\r
288                  &displayModesCount,\r
289                  &displayModes ) )\r
290         {\r
291             fgWarning( "XF86VidModeGetAllModeLines failed" );\r
292             return;\r
293         }\r
294 \r
295 \r
296         /*\r
297          * Check every of the modes looking for one that matches our demands.\r
298          * If we find one, switch to it and restore the remembered viewport.\r
299          */\r
300         for( i = 0; i < displayModesCount; i++ )\r
301         {\r
302             if(displayModes[ i ]->hdisplay == fgDisplay.DisplayMode.hdisplay &&\r
303                displayModes[ i ]->vdisplay == fgDisplay.DisplayMode.vdisplay &&\r
304                displayModes[ i ]->dotclock == fgDisplay.DisplayModeClock )\r
305             {\r
306                 if( !XF86VidModeSwitchToMode(\r
307                          fgDisplay.Display,\r
308                          fgDisplay.Screen,\r
309                          displayModes[ i ] ) )\r
310                 {\r
311                     fgWarning( "XF86VidModeSwitchToMode failed" );\r
312                     break;\r
313                 }\r
314 \r
315                 if( !XF86VidModeSetViewPort(\r
316                          fgDisplay.Display,\r
317                          fgDisplay.Screen,\r
318                          fgDisplay.DisplayViewPortX,\r
319                          fgDisplay.DisplayViewPortY ) )\r
320                     fgWarning( "XF86VidModeSetViewPort failed" );\r
321 \r
322 \r
323                 /*\r
324                  * For the case this would be the last X11 call the application\r
325                  * calls exit() we've to flush the X11 output queue to have the\r
326                  * commands sent to the X server before the application exits.\r
327                  */\r
328                 XFlush( fgDisplay.Display );\r
329 \r
330                 fgDisplay.DisplayModeValid = 0;\r
331 #       ifdef HAVE_X11_EXTENSIONS_XRANDR_H\r
332                 fgDisplay.prev_size_valid = 0;\r
333 #       endif\r
334 \r
335                 break;\r
336             }\r
337         }\r
338         XFree( displayModes );\r
339     }\r
340 \r
341 #   endif\r
342 \r
343 }\r
344 #endif\r
345 \r
346 #if TARGET_HOST_POSIX_X11\r
347 #ifdef HAVE_X11_EXTENSIONS_XF86VMODE_H\r
348 \r
349 /*\r
350  * Checks a single display mode settings against user's preferences.\r
351  */\r
352 static GLboolean fghCheckDisplayMode( int width, int height, int depth, int refresh )\r
353 {\r
354     /* The desired values should be stored in fgState structure... */\r
355     return ( width == fgState.GameModeSize.X ) &&\r
356            ( height == fgState.GameModeSize.Y ) &&\r
357            ( depth == fgState.GameModeDepth ) &&\r
358            ( refresh == fgState.GameModeRefresh );\r
359 }\r
360 \r
361 /*\r
362  * Checks all display modes settings against user's preferences.\r
363  * Returns the mode number found or -1 if none could be found.\r
364  */\r
365 static int fghCheckDisplayModes( GLboolean exactMatch, int displayModesCount, XF86VidModeModeInfo** displayModes )\r
366 {\r
367     int i;\r
368     for( i = 0; i < displayModesCount; i++ )\r
369     {\r
370         /* Compute the displays refresh rate, dotclock comes in kHz. */\r
371         int refresh = ( displayModes[ i ]->dotclock * 1000 ) /\r
372                       ( displayModes[ i ]->htotal * displayModes[ i ]->vtotal );\r
373 \r
374         if( fghCheckDisplayMode( displayModes[ i ]->hdisplay,\r
375                                  displayModes[ i ]->vdisplay,\r
376                                  fgState.GameModeDepth,\r
377                                  ( exactMatch ? refresh : fgState.GameModeRefresh ) ) ) {\r
378             if (!exactMatch)\r
379             {\r
380                 /* Update the chosen refresh rate, otherwise a\r
381                  * glutGameModeGet(GLUT_GAME_MODE_REFRESH_RATE) would not\r
382                  * return the right values\r
383                  */\r
384                 fgState.GameModeRefresh = refresh;\r
385             }\r
386 \r
387             return i;\r
388         }\r
389     }\r
390     return -1;\r
391 }\r
392 \r
393 #endif\r
394 #endif\r
395 \r
396 #if TARGET_HOST_POSIX_X11\r
397 \r
398 /*\r
399  * Changes the current display mode to match user's settings\r
400  */\r
401 static GLboolean fgPlatformChangeDisplayMode( GLboolean haveToTest )\r
402 {\r
403     GLboolean success = GL_FALSE;\r
404     /* first try to use XRandR, then fallback to XF86VidMode */\r
405 #   ifdef HAVE_X11_EXTENSIONS_XRANDR_H\r
406     if(xrandr_resize(fgState.GameModeSize.X, fgState.GameModeSize.Y,\r
407                 fgState.GameModeRefresh, haveToTest) != -1) {\r
408         return GL_TRUE;\r
409     }\r
410 #   endif\r
411 \r
412 \r
413     /*\r
414      * This highly depends on the XFree86 extensions,\r
415      * not approved as X Consortium standards\r
416      */\r
417 #   ifdef HAVE_X11_EXTENSIONS_XF86VMODE_H\r
418 \r
419     /*\r
420      * This is also used by applications which check modes by calling\r
421      * glutGameModeGet(GLUT_GAME_MODE_POSSIBLE), so allow the check:\r
422      */\r
423     if( haveToTest || fgDisplay.DisplayModeValid )\r
424     {\r
425         XF86VidModeModeInfo** displayModes;\r
426         int i, displayModesCount;\r
427 \r
428         /* If we don't have a valid modeline in the display structure, which\r
429          * can happen if this is called from glutGameModeGet instead of\r
430          * glutEnterGameMode, then we need to query the current mode, to make\r
431          * unspecified settings to default to their current values.\r
432          */\r
433         if(!fgDisplay.DisplayModeValid) {\r
434             if(!XF86VidModeGetModeLine(fgDisplay.Display, fgDisplay.Screen,\r
435                     &fgDisplay.DisplayModeClock, &fgDisplay.DisplayMode)) {\r
436                 return success;\r
437             }\r
438         }\r
439 \r
440         if (fgState.GameModeSize.X == -1)\r
441         {\r
442             fgState.GameModeSize.X = fgDisplay.DisplayMode.hdisplay;\r
443         }\r
444         if (fgState.GameModeSize.Y == -1)\r
445         {\r
446             fgState.GameModeSize.Y = fgDisplay.DisplayMode.vdisplay;\r
447         }\r
448         if (fgState.GameModeDepth == -1)\r
449         {\r
450             /* can't get color depth from this, nor can we change it, do nothing\r
451              * TODO: get with XGetVisualInfo()? but then how to set?\r
452              */\r
453         }\r
454         if (fgState.GameModeRefresh == -1)\r
455         {\r
456             /* Compute the displays refresh rate, dotclock comes in kHz. */\r
457             int refresh = ( fgDisplay.DisplayModeClock * 1000 ) /\r
458                 ( fgDisplay.DisplayMode.htotal * fgDisplay.DisplayMode.vtotal );\r
459 \r
460             fgState.GameModeRefresh = refresh;\r
461         }\r
462 \r
463         /* query all possible display modes */\r
464         if( !XF86VidModeGetAllModeLines(\r
465                  fgDisplay.Display,\r
466                  fgDisplay.Screen,\r
467                  &displayModesCount,\r
468                  &displayModes ) )\r
469         {\r
470             fgWarning( "XF86VidModeGetAllModeLines failed" );\r
471             return success;\r
472         }\r
473 \r
474 \r
475         /*\r
476          * Check every of the modes looking for one that matches our demands,\r
477          * ignoring the refresh rate if no exact match could be found.\r
478          */\r
479         i = fghCheckDisplayModes( GL_TRUE, displayModesCount, displayModes );\r
480         if( i < 0 ) {\r
481             i = fghCheckDisplayModes( GL_FALSE, displayModesCount, displayModes );\r
482         }\r
483         success = ( i < 0 ) ? GL_FALSE : GL_TRUE;\r
484 \r
485         if( !haveToTest && success ) {\r
486             if( !XF86VidModeSwitchToMode(\r
487                      fgDisplay.Display,\r
488                      fgDisplay.Screen,\r
489                      displayModes[ i ] ) )\r
490                 fgWarning( "XF86VidModeSwitchToMode failed" );\r
491         }\r
492 \r
493         XFree( displayModes );\r
494     }\r
495 \r
496 #   endif\r
497 \r
498     return success;\r
499 }\r
500 \r
501 #endif\r
502 \r
503 /* -- INTERFACE FUNCTIONS -------------------------------------------------- */\r
504 \r
505 /*\r
506  * Sets the game mode display string\r
507  */\r
508 void FGAPIENTRY glutGameModeString( const char* string )\r
509 {\r
510     int width = -1, height = -1, depth = -1, refresh = -1;\r
511 \r
512     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutGameModeString" );\r
513 \r
514     /*\r
515      * This one seems a bit easier than glutInitDisplayString. The bad thing\r
516      * about it that I was unable to find the game mode string definition, so\r
517      * that I assumed it is: "[width]x[height]:[depth]@[refresh rate]", which\r
518      * appears in all GLUT game mode programs I have seen to date.\r
519      */\r
520     if( sscanf( string, "%ix%i:%i@%i", &width, &height, &depth, &refresh ) !=\r
521         4 )\r
522         if( sscanf( string, "%ix%i:%i", &width, &height, &depth ) != 3 )\r
523             if( sscanf( string, "%ix%i@%i", &width, &height, &refresh ) != 3 )\r
524                 if( sscanf( string, "%ix%i", &width, &height ) != 2 )\r
525                     if( sscanf( string, ":%i@%i", &depth, &refresh ) != 2 )\r
526                         if( sscanf( string, ":%i", &depth ) != 1 )\r
527                             if( sscanf( string, "@%i", &refresh ) != 1 )\r
528                                 fgWarning(\r
529                                     "unable to parse game mode string `%s'",\r
530                                     string\r
531                                 );\r
532 \r
533     /* All values not specified are now set to -1, which means those\r
534      * aspects of the current display mode are not changed in\r
535      * fgPlatformChangeDisplayMode() above.\r
536      */\r
537     fgState.GameModeSize.X  = width;\r
538     fgState.GameModeSize.Y  = height;\r
539     fgState.GameModeDepth   = depth;\r
540     fgState.GameModeRefresh = refresh;\r
541 }\r
542 \r
543 \r
544 \r
545 /*\r
546  * Enters the game mode\r
547  */\r
548 int FGAPIENTRY glutEnterGameMode( void )\r
549 {\r
550     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutEnterGameMode" );\r
551 \r
552     if( fgStructure.GameModeWindow )\r
553         fgAddToWindowDestroyList( fgStructure.GameModeWindow );\r
554     else\r
555         fgPlatformRememberState( );\r
556 \r
557     if( ! fgPlatformChangeDisplayMode( GL_FALSE ) )\r
558     {\r
559         fgWarning( "failed to change screen settings" );\r
560         return 0;\r
561     }\r
562 \r
563     fgStructure.GameModeWindow = fgCreateWindow(\r
564         NULL, "FREEGLUT", GL_TRUE, 0, 0,\r
565         GL_TRUE, fgState.GameModeSize.X, fgState.GameModeSize.Y,\r
566         GL_TRUE, GL_FALSE\r
567     );\r
568 \r
569     fgStructure.GameModeWindow->State.Width  = fgState.GameModeSize.X;\r
570     fgStructure.GameModeWindow->State.Height = fgState.GameModeSize.Y;\r
571     fgStructure.GameModeWindow->State.NeedToResize = GL_TRUE;\r
572 \r
573 #if TARGET_HOST_POSIX_X11\r
574 \r
575     /*\r
576      * Sync needed to avoid a real race, the Xserver must have really created\r
577      * the window before we can grab the pointer into it:\r
578      */\r
579     XSync( fgDisplay.Display, False );\r
580     /*\r
581      * Grab the pointer to confine it into the window after the calls to\r
582      * XWrapPointer() which ensure that the pointer really enters the window.\r
583      *\r
584      * We also need to wait here until XGrabPointer() returns GrabSuccess,\r
585      * otherwise the new window is not viewable yet and if the next function\r
586      * (XSetInputFocus) is called with a not yet viewable window, it will exit\r
587      * the application which we have to aviod, so wait until it's viewable:\r
588      */\r
589     while( GrabSuccess != XGrabPointer(\r
590                fgDisplay.Display, fgStructure.GameModeWindow->Window.Handle,\r
591                TRUE,\r
592                ButtonPressMask | ButtonReleaseMask | ButtonMotionMask\r
593                | PointerMotionMask,\r
594                GrabModeAsync, GrabModeAsync,\r
595                fgStructure.GameModeWindow->Window.Handle, None, CurrentTime) )\r
596         usleep( 100 );\r
597     /*\r
598      * Change input focus to the new window. This will exit the application\r
599      * if the new window is not viewable yet, see the XGrabPointer loop above.\r
600      */\r
601     XSetInputFocus(\r
602         fgDisplay.Display,\r
603         fgStructure.GameModeWindow->Window.Handle,\r
604         RevertToNone,\r
605         CurrentTime\r
606     );\r
607 \r
608     /* Move the Pointer to the middle of the fullscreen window */\r
609     XWarpPointer(\r
610         fgDisplay.Display,\r
611         None,\r
612         fgDisplay.RootWindow,\r
613         0, 0, 0, 0,\r
614         fgState.GameModeSize.X/2, fgState.GameModeSize.Y/2\r
615     );\r
616 \r
617 #   ifdef HAVE_X11_EXTENSIONS_XF86VMODE_H\r
618 \r
619     if( fgDisplay.DisplayModeValid )\r
620     {\r
621         int x, y;\r
622         Window child;\r
623 \r
624         /* Change to viewport to the window topleft edge: */\r
625         if( !XF86VidModeSetViewPort( fgDisplay.Display, fgDisplay.Screen, 0, 0 ) )\r
626             fgWarning( "XF86VidModeSetViewPort failed" );\r
627 \r
628         /*\r
629          * Final window repositioning: It could be avoided using an undecorated\r
630          * window using override_redirect, but this * would possily require\r
631          * more changes and investigation.\r
632          */\r
633 \r
634         /* Get the current postion of the drawable area on screen */\r
635         XTranslateCoordinates(\r
636             fgDisplay.Display,\r
637             fgStructure.CurrentWindow->Window.Handle,\r
638             fgDisplay.RootWindow,\r
639             0, 0, &x, &y,\r
640             &child\r
641         );\r
642 \r
643         /* Move the decorataions out of the topleft corner of the display */\r
644         XMoveWindow( fgDisplay.Display, fgStructure.CurrentWindow->Window.Handle,\r
645                      -x, -y);\r
646     }\r
647 \r
648 #endif\r
649 \r
650     /* Grab the keyboard, too */\r
651     XGrabKeyboard(\r
652         fgDisplay.Display,\r
653         fgStructure.GameModeWindow->Window.Handle,\r
654         FALSE,\r
655         GrabModeAsync, GrabModeAsync,\r
656         CurrentTime\r
657     );\r
658 \r
659 #endif\r
660 \r
661     return fgStructure.GameModeWindow->ID;\r
662 }\r
663 \r
664 /*\r
665  * Leaves the game mode\r
666  */\r
667 void FGAPIENTRY glutLeaveGameMode( void )\r
668 {\r
669     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutLeaveGameMode" );\r
670 \r
671     freeglut_return_if_fail( fgStructure.GameModeWindow );\r
672 \r
673     fgAddToWindowDestroyList( fgStructure.GameModeWindow );\r
674     fgStructure.GameModeWindow = NULL;\r
675 \r
676 #if TARGET_HOST_POSIX_X11\r
677 \r
678     XUngrabPointer( fgDisplay.Display, CurrentTime );\r
679     XUngrabKeyboard( fgDisplay.Display, CurrentTime );\r
680 \r
681 #endif\r
682 \r
683     fgPlatformRestoreState();\r
684 }\r
685 \r
686 /*\r
687  * Returns information concerning the freeglut game mode\r
688  */\r
689 int FGAPIENTRY glutGameModeGet( GLenum eWhat )\r
690 {\r
691     FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutGameModeGet" );\r
692 \r
693     switch( eWhat )\r
694     {\r
695     case GLUT_GAME_MODE_ACTIVE:\r
696         return !!fgStructure.GameModeWindow;\r
697 \r
698     case GLUT_GAME_MODE_POSSIBLE:\r
699         return fgPlatformChangeDisplayMode( GL_TRUE );\r
700 \r
701     case GLUT_GAME_MODE_WIDTH:\r
702         return fgState.GameModeSize.X;\r
703 \r
704     case GLUT_GAME_MODE_HEIGHT:\r
705         return fgState.GameModeSize.Y;\r
706 \r
707     case GLUT_GAME_MODE_PIXEL_DEPTH:\r
708         return fgState.GameModeDepth;\r
709 \r
710     case GLUT_GAME_MODE_REFRESH_RATE:\r
711         return fgState.GameModeRefresh;\r
712 \r
713     case GLUT_GAME_MODE_DISPLAY_CHANGED:\r
714         /*\r
715          * This is true if the game mode has been activated successfully..\r
716          */\r
717         return !!fgStructure.GameModeWindow;\r
718     }\r
719 \r
720     fgWarning( "Unknown gamemode get: %d", eWhat );\r
721     return -1;\r
722 }\r
723 \r
724 /*** END OF FILE ***/\r