Keep fg_geometry in normal builds\!
[freeglut] / src / x11 / fg_window_x11.c
1 /*
2  * freeglut_window_x11.c
3  *
4  * Window management methods for X11
5  *
6  * Copyright (c) 1999-2000 Pawel W. Olszta. All Rights Reserved.
7  * Written by Pawel W. Olszta, <olszta@sourceforge.net>
8  * Copied for Platform code by Evan Felix <karcaw at gmail.com>
9  * Creation date: Thur Feb 2 2012
10  *
11  * Permission is hereby granted, free of charge, to any person obtaining a
12  * copy of this software and associated documentation files (the "Software"),
13  * to deal in the Software without restriction, including without limitation
14  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
15  * and/or sell copies of the Software, and to permit persons to whom the
16  * Software is furnished to do so, subject to the following conditions:
17  *
18  * The above copyright notice and this permission notice shall be included
19  * in all copies or substantial portions of the Software.
20  *
21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
22  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
23  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
24  * PAWEL W. OLSZTA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
25  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
26  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27  */
28
29 #define FREEGLUT_BUILDING_LIB
30 #include <GL/freeglut.h>
31 #include <limits.h>  /* LONG_MAX */
32 #include <unistd.h>  /* usleep */
33 #include "../fg_internal.h"
34
35 #ifdef EGL_VERSION_1_0
36 #include "egl/fg_window_egl.h"
37 #define fghCreateNewContext fghCreateNewContextEGL
38 #else
39 #include "x11/fg_window_x11_glx.h"
40 #endif
41
42 static int fghResizeFullscrToggle(void)
43 {
44     XWindowAttributes attributes;
45
46     if(glutGet(GLUT_FULL_SCREEN)) {
47         /* restore original window size */
48         SFG_Window *win = fgStructure.CurrentWindow;
49         fgStructure.CurrentWindow->State.NeedToResize = GL_TRUE;
50         fgStructure.CurrentWindow->State.Width  = win->State.pWState.OldWidth;
51         fgStructure.CurrentWindow->State.Height = win->State.pWState.OldHeight;
52
53     } else {
54         /* resize the window to cover the entire screen */
55         XGetWindowAttributes(fgDisplay.pDisplay.Display,
56                 fgStructure.CurrentWindow->Window.Handle,
57                 &attributes);
58         
59         /*
60          * The "x" and "y" members of "attributes" are the window's coordinates
61          * relative to its parent, i.e. to the decoration window.
62          */
63         XMoveResizeWindow(fgDisplay.pDisplay.Display,
64                 fgStructure.CurrentWindow->Window.Handle,
65                 -attributes.x,
66                 -attributes.y,
67                 fgDisplay.ScreenWidth,
68                 fgDisplay.ScreenHeight);
69     }
70     return 0;
71 }
72
73 #define _NET_WM_STATE_TOGGLE    2
74 static int fghEwmhFullscrToggle(void)
75 {
76     XEvent xev;
77     long evmask = SubstructureRedirectMask | SubstructureNotifyMask;
78
79     if(!fgDisplay.pDisplay.State || !fgDisplay.pDisplay.StateFullScreen) {
80         return -1;
81     }
82
83     xev.type = ClientMessage;
84     xev.xclient.window = fgStructure.CurrentWindow->Window.Handle;
85     xev.xclient.message_type = fgDisplay.pDisplay.State;
86     xev.xclient.format = 32;
87     xev.xclient.data.l[0] = _NET_WM_STATE_TOGGLE;
88     xev.xclient.data.l[1] = fgDisplay.pDisplay.StateFullScreen;
89     xev.xclient.data.l[2] = 0;  /* no second property to toggle */
90     xev.xclient.data.l[3] = 1;  /* source indication: application */
91     xev.xclient.data.l[4] = 0;  /* unused */
92
93     if(!XSendEvent(fgDisplay.pDisplay.Display, fgDisplay.pDisplay.RootWindow, 0, evmask, &xev)) {
94         return -1;
95     }
96     return 0;
97 }
98
99 static int fghToggleFullscreen(void)
100 {
101     /* first try the EWMH (_NET_WM_STATE) method ... */
102     if(fghEwmhFullscrToggle() != -1) {
103         return 0;
104     }
105
106     /* fall back to resizing the window */
107     if(fghResizeFullscrToggle() != -1) {
108         return 0;
109     }
110     return -1;
111 }
112
113 static Bool fghWindowIsVisible( Display *display, XEvent *event, XPointer arg)
114 {
115     Window window = (Window)arg;
116     return (event->type == MapNotify) && (event->xmap.window == window);
117 }
118
119 /*
120  * Opens a window. Requires a SFG_Window object created and attached
121  * to the freeglut structure. OpenGL context is created here.
122  */
123 void fgPlatformOpenWindow( SFG_Window* window, const char* title,
124                            GLboolean positionUse, int x, int y,
125                            GLboolean sizeUse, int w, int h,
126                            GLboolean gameMode, GLboolean isSubWindow )
127 {
128     XVisualInfo * visualInfo = NULL;
129     XSetWindowAttributes winAttr;
130     XTextProperty textProperty;
131     XSizeHints sizeHints;
132     XWMHints wmHints;
133     XEvent eventReturnBuffer; /* return buffer required for a call */
134     unsigned long mask;
135     int num_FBConfigs, i;
136     unsigned int current_DisplayMode = fgState.DisplayMode ;
137
138     /* Save the display mode if we are creating a menu window */
139     if( window->IsMenu && ( ! fgStructure.MenuContext ) )
140         fgState.DisplayMode = GLUT_DOUBLE | GLUT_RGB ;
141
142 #ifdef EGL_VERSION_1_0
143 #define WINDOW_CONFIG window->Window.pContext.egl.Config
144 #else
145 #define WINDOW_CONFIG window->Window.pContext.FBConfig
146 #endif
147     fghChooseConfig(&WINDOW_CONFIG);
148
149     if( window->IsMenu && ( ! fgStructure.MenuContext ) )
150         fgState.DisplayMode = current_DisplayMode ;
151
152     if( ! WINDOW_CONFIG )
153     {
154         /*
155          * The "fghChooseConfig" returned a null meaning that the visual
156          * context is not available.
157          * Try a couple of variations to see if they will work.
158          */
159 #ifndef EGL_VERSION_1_0
160         if( !( fgState.DisplayMode & GLUT_DOUBLE ) )
161         {
162             fgState.DisplayMode |= GLUT_DOUBLE ;
163             fghChooseConfig(&WINDOW_CONFIG);
164             fgState.DisplayMode &= ~GLUT_DOUBLE;
165         }
166 #endif
167
168         if( fgState.DisplayMode & GLUT_MULTISAMPLE )
169         {
170             fgState.DisplayMode &= ~GLUT_MULTISAMPLE ;
171             fghChooseConfig(&WINDOW_CONFIG);
172             fgState.DisplayMode |= GLUT_MULTISAMPLE;
173         }
174     }
175
176     FREEGLUT_INTERNAL_ERROR_EXIT( WINDOW_CONFIG != NULL,
177                                   "FBConfig with necessary capabilities not found", "fgOpenWindow" );
178
179     /*  Get the X visual.  */
180 #ifdef EGL_VERSION_1_0
181     EGLint vid = 0;
182     XVisualInfo visualTemplate;
183     int num_visuals;
184     if (!eglGetConfigAttrib(fgDisplay.pDisplay.egl.Display, window->Window.pContext.egl.Config, EGL_NATIVE_VISUAL_ID, &vid))
185       fgError("eglGetConfigAttrib(EGL_NATIVE_VISUAL_ID) failed");
186     visualTemplate.visualid = vid;
187     visualInfo = XGetVisualInfo(fgDisplay.pDisplay.Display, VisualIDMask, &visualTemplate, &num_visuals);
188 #else
189     visualInfo = glXGetVisualFromFBConfig( fgDisplay.pDisplay.Display,
190                                            window->Window.pContext.FBConfig );
191 #endif
192
193     FREEGLUT_INTERNAL_ERROR_EXIT( visualInfo != NULL,
194                                   "visualInfo could not be retrieved from FBConfig", "fgOpenWindow" );
195
196     /*
197      * XXX HINT: the masks should be updated when adding/removing callbacks.
198      * XXX       This might speed up message processing. Is that true?
199      * XXX
200      * XXX A: Not appreciably, but it WILL make it easier to debug.
201      * XXX    Try tracing old GLUT and try tracing freeglut.  Old GLUT
202      * XXX    turns off events that it doesn't need and is a whole lot
203      * XXX    more pleasant to trace.  (Think mouse-motion!  Tons of
204      * XXX    ``bonus'' GUI events stream in.)
205      */
206     winAttr.event_mask        =
207         StructureNotifyMask | SubstructureNotifyMask | ExposureMask |
208         ButtonPressMask | ButtonReleaseMask | KeyPressMask | KeyReleaseMask |
209         VisibilityChangeMask | EnterWindowMask | LeaveWindowMask |
210         PointerMotionMask | ButtonMotionMask;
211     winAttr.background_pixmap = None;
212     winAttr.background_pixel  = 0;
213     winAttr.border_pixel      = 0;
214
215     winAttr.colormap = XCreateColormap(
216         fgDisplay.pDisplay.Display, fgDisplay.pDisplay.RootWindow,
217         visualInfo->visual, AllocNone
218     );
219
220     mask = CWBackPixmap | CWBorderPixel | CWColormap | CWEventMask;
221
222     if( window->IsMenu || ( gameMode == GL_TRUE ) )
223     {
224         winAttr.override_redirect = True;
225         mask |= CWOverrideRedirect;
226     }
227
228     if( ! positionUse )
229         x = y = -1; /* default window position */
230     if( ! sizeUse )
231         w = h = 300; /* default window size */
232
233     window->Window.Handle = XCreateWindow(
234         fgDisplay.pDisplay.Display,
235         window->Parent == NULL ? fgDisplay.pDisplay.RootWindow :
236         window->Parent->Window.Handle,
237         x, y, w, h, 0,
238         visualInfo->depth, InputOutput,
239         visualInfo->visual, mask,
240         &winAttr
241     );
242
243     /*
244      * The GLX context creation, possibly trying the direct context rendering
245      *  or else use the current context if the user has so specified
246      */
247
248     if( window->IsMenu )
249     {
250         /*
251          * If there isn't already an OpenGL rendering context for menu
252          * windows, make one
253          */
254         if( !fgStructure.MenuContext )
255         {
256             fgStructure.MenuContext =
257                 (SFG_MenuContext *)malloc( sizeof(SFG_MenuContext) );
258             fgStructure.MenuContext->MContext = fghCreateNewContext( window );
259         }
260
261         /* window->Window.Context = fgStructure.MenuContext->MContext; */
262         window->Window.Context = fghCreateNewContext( window );
263     }
264     else if( fgState.UseCurrentContext )
265     {
266
267 #ifdef EGL_VERSION_1_0
268         window->Window.Context = eglGetCurrentContext( );
269 #else
270         window->Window.Context = glXGetCurrentContext( );
271 #endif
272
273         if( ! window->Window.Context )
274             window->Window.Context = fghCreateNewContext( window );
275     }
276     else
277         window->Window.Context = fghCreateNewContext( window );
278
279 #if !defined( __FreeBSD__ ) && !defined( __NetBSD__ ) && !defined(EGL_VERSION_1_0)
280     if(  !glXIsDirect( fgDisplay.pDisplay.Display, window->Window.Context ) )
281     {
282       if( fgState.DirectContext == GLUT_FORCE_DIRECT_CONTEXT )
283         fgError( "Unable to force direct context rendering for window '%s'",
284                  title );
285     }
286 #endif
287
288     /*
289      * XXX Assume the new window is visible by default
290      * XXX Is this a  safe assumption?
291      */
292     window->State.Visible = GL_TRUE;
293
294     sizeHints.flags = 0;
295     if ( positionUse )
296         sizeHints.flags |= USPosition;
297     if ( sizeUse )
298         sizeHints.flags |= USSize;
299
300     /*
301      * Fill in the size hints values now (the x, y, width and height
302      * settings are obsolete, are there any more WMs that support them?)
303      * Unless the X servers actually stop supporting these, we should
304      * continue to fill them in.  It is *not* our place to tell the user
305      * that they should replace a window manager that they like, and which
306      * works, just because *we* think that it's not "modern" enough.
307      */
308     sizeHints.x      = x;
309     sizeHints.y      = y;
310     sizeHints.width  = w;
311     sizeHints.height = h;
312
313     wmHints.flags = StateHint;
314     wmHints.initial_state = fgState.ForceIconic ? IconicState : NormalState;
315     /* Prepare the window and iconified window names... */
316     XStringListToTextProperty( (char **) &title, 1, &textProperty );
317
318     XSetWMProperties(
319         fgDisplay.pDisplay.Display,
320         window->Window.Handle,
321         &textProperty,
322         &textProperty,
323         0,
324         0,
325         &sizeHints,
326         &wmHints,
327         NULL
328     );
329     XFree( textProperty.value );
330
331     XSetWMProtocols( fgDisplay.pDisplay.Display, window->Window.Handle,
332                      &fgDisplay.pDisplay.DeleteWindow, 1 );
333
334 #ifdef EGL_VERSION_1_0
335     fghPlatformOpenWindowEGL(window);
336 #else
337     glXMakeContextCurrent(
338         fgDisplay.pDisplay.Display,
339         window->Window.Handle,
340         window->Window.Handle,
341         window->Window.Context
342     );
343 #endif
344
345     /* register extension events _before_ window is mapped */
346     #ifdef HAVE_X11_EXTENSIONS_XINPUT2_H
347        fgRegisterDevices( fgDisplay.pDisplay.Display, &(window->Window.Handle) );
348     #endif
349
350     XMapWindow( fgDisplay.pDisplay.Display, window->Window.Handle );
351
352     XFree(visualInfo);
353
354     if( !isSubWindow)
355         XPeekIfEvent( fgDisplay.pDisplay.Display, &eventReturnBuffer, &fghWindowIsVisible, (XPointer)(window->Window.Handle) );
356 #undef WINDOW_CONFIG
357 }
358
359
360 /*
361  * Closes a window, destroying the frame and OpenGL context
362  */
363 void fgPlatformCloseWindow( SFG_Window* window )
364 {
365 #ifdef EGL_VERSION_1_0
366     fghPlatformCloseWindowEGL(window);
367 #else
368     if( window->Window.Context )
369         glXDestroyContext( fgDisplay.pDisplay.Display, window->Window.Context );
370     window->Window.pContext.FBConfig = NULL;
371 #endif
372
373     if( window->Window.Handle ) {
374         XDestroyWindow( fgDisplay.pDisplay.Display, window->Window.Handle );
375     }
376     /* XFlush( fgDisplay.pDisplay.Display ); */ /* XXX Shouldn't need this */
377 }
378
379
380 /*
381  * This function makes the current window visible
382  */
383 void fgPlatformGlutShowWindow( void )
384 {
385     XMapWindow( fgDisplay.pDisplay.Display, fgStructure.CurrentWindow->Window.Handle );
386     XFlush( fgDisplay.pDisplay.Display ); /* XXX Shouldn't need this */
387 }
388
389 /*
390  * This function hides the current window
391  */
392 void fgPlatformGlutHideWindow( void )
393 {
394     if( fgStructure.CurrentWindow->Parent == NULL )
395         XWithdrawWindow( fgDisplay.pDisplay.Display,
396                          fgStructure.CurrentWindow->Window.Handle,
397                          fgDisplay.pDisplay.Screen );
398     else
399         XUnmapWindow( fgDisplay.pDisplay.Display,
400                       fgStructure.CurrentWindow->Window.Handle );
401     XFlush( fgDisplay.pDisplay.Display ); /* XXX Shouldn't need this */
402 }
403
404 /*
405  * Iconify the current window (top-level windows only)
406  */
407 void fgPlatformGlutIconifyWindow( void )
408 {
409     XIconifyWindow( fgDisplay.pDisplay.Display, fgStructure.CurrentWindow->Window.Handle,
410                     fgDisplay.pDisplay.Screen );
411     XFlush( fgDisplay.pDisplay.Display ); /* XXX Shouldn't need this */
412 }
413
414 /*
415  * Set the current window's title
416  */
417 void fgPlatformGlutSetWindowTitle( const char* title )
418 {
419     XTextProperty text;
420
421     text.value = (unsigned char *) title;
422     text.encoding = XA_STRING;
423     text.format = 8;
424     text.nitems = strlen( title );
425
426     XSetWMName(
427         fgDisplay.pDisplay.Display,
428         fgStructure.CurrentWindow->Window.Handle,
429         &text
430     );
431
432     XFlush( fgDisplay.pDisplay.Display ); /* XXX Shouldn't need this */
433 }
434
435 /*
436  * Set the current window's iconified title
437  */
438 void fgPlatformGlutSetIconTitle( const char* title )
439 {
440     XTextProperty text;
441
442     text.value = (unsigned char *) title;
443     text.encoding = XA_STRING;
444     text.format = 8;
445     text.nitems = strlen( title );
446
447     XSetWMIconName(
448         fgDisplay.pDisplay.Display,
449         fgStructure.CurrentWindow->Window.Handle,
450         &text
451     );
452
453     XFlush( fgDisplay.pDisplay.Display ); /* XXX Shouldn't need this */
454 }
455
456 /*
457  * Change the current window's position
458  */
459 void fgPlatformGlutPositionWindow( int x, int y )
460 {
461     XMoveWindow( fgDisplay.pDisplay.Display, fgStructure.CurrentWindow->Window.Handle,
462                  x, y );
463     XFlush( fgDisplay.pDisplay.Display ); /* XXX Shouldn't need this */
464 }
465
466 /*
467  * Lowers the current window (by Z order change)
468  */
469 void fgPlatformGlutPushWindow( void )
470 {
471     XLowerWindow( fgDisplay.pDisplay.Display, fgStructure.CurrentWindow->Window.Handle );
472 }
473
474 /*
475  * Raises the current window (by Z order change)
476  */
477 void fgPlatformGlutPopWindow( void )
478 {
479     XRaiseWindow( fgDisplay.pDisplay.Display, fgStructure.CurrentWindow->Window.Handle );
480 }
481
482 /*
483  * Resize the current window so that it fits the whole screen
484  */
485 void fgPlatformGlutFullScreen( SFG_Window *win )
486 {
487     if(!glutGet(GLUT_FULL_SCREEN)) {
488         if(fghToggleFullscreen() != -1) {
489             win->State.IsFullscreen = GL_TRUE;
490         }
491     }
492 }
493
494 /*
495  * If we are fullscreen, resize the current window back to its original size
496  */
497 void fgPlatformGlutLeaveFullScreen( SFG_Window *win )
498 {
499     if(glutGet(GLUT_FULL_SCREEN)) {
500         if(fghToggleFullscreen() != -1) {
501             win->State.IsFullscreen = GL_FALSE;
502         }
503     }
504 }
505
506 /*
507  * Toggle the window's full screen state.
508  */
509 void fgPlatformGlutFullScreenToggle( SFG_Window *win )
510 {
511     if(fghToggleFullscreen() != -1) {
512         win->State.IsFullscreen = !win->State.IsFullscreen;
513     }
514 }
515