+/*\r
+ * freeglut_window_x11.c\r
+ *\r
+ * Window management methods for X11\r
+ *\r
+ * Copyright (c) 1999-2000 Pawel W. Olszta. All Rights Reserved.\r
+ * Written by Pawel W. Olszta, <olszta@sourceforge.net>\r
+ * Copied for Platform code by Evan Felix <karcaw at gmail.com>\r
+ * Creation date: Thur Feb 2 2012\r
+ *\r
+ * Permission is hereby granted, free of charge, to any person obtaining a\r
+ * copy of this software and associated documentation files (the "Software"),\r
+ * to deal in the Software without restriction, including without limitation\r
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,\r
+ * and/or sell copies of the Software, and to permit persons to whom the\r
+ * Software is furnished to do so, subject to the following conditions:\r
+ *\r
+ * The above copyright notice and this permission notice shall be included\r
+ * in all copies or substantial portions of the Software.\r
+ *\r
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS\r
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL\r
+ * PAWEL W. OLSZTA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\r
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
+ */\r
+\r
+#define FREEGLUT_BUILDING_LIB\r
+#include <GL/freeglut.h>\r
+#include <limits.h> /* LONG_MAX */\r
+#include <unistd.h> /* usleep */\r
+#include "freeglut_internal.h"\r
+\r
+/* pushing attribute/value pairs into an array */\r
+#define ATTRIB(a) attributes[where++]=(a)\r
+#define ATTRIB_VAL(a,v) {ATTRIB(a); ATTRIB(v);}\r
+\r
+\r
+#ifndef GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB\r
+#define GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB 0x20B2\r
+#endif\r
+\r
+#ifndef GLX_CONTEXT_MAJOR_VERSION_ARB\r
+#define GLX_CONTEXT_MAJOR_VERSION_ARB 0x2091\r
+#endif\r
+\r
+#ifndef GLX_CONTEXT_MINOR_VERSION_ARB\r
+#define GLX_CONTEXT_MINOR_VERSION_ARB 0x2092\r
+#endif\r
+\r
+#ifndef GLX_CONTEXT_FLAGS_ARB\r
+#define GLX_CONTEXT_FLAGS_ARB 0x2094\r
+#endif\r
+\r
+#ifndef GLX_CONTEXT_PROFILE_MASK_ARB\r
+#define GLX_CONTEXT_PROFILE_MASK_ARB 0x9126\r
+#endif\r
+\r
+#ifndef GLX_CONTEXT_DEBUG_BIT_ARB\r
+#define GLX_CONTEXT_DEBUG_BIT_ARB 0x0001\r
+#endif\r
+\r
+#ifndef GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB\r
+#define GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x0002\r
+#endif\r
+\r
+#ifndef GLX_CONTEXT_CORE_PROFILE_BIT_ARB\r
+#define GLX_CONTEXT_CORE_PROFILE_BIT_ARB 0x00000001\r
+#endif\r
+\r
+#ifndef GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB\r
+#define GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002\r
+#endif\r
+\r
+#ifndef GLX_RGBA_FLOAT_TYPE\r
+#define GLX_RGBA_FLOAT_TYPE 0x20B9\r
+#endif\r
+\r
+#ifndef GLX_RGBA_FLOAT_BIT\r
+#define GLX_RGBA_FLOAT_BIT 0x00000004\r
+#endif\r
+\r
+\r
+/*\r
+ * Chooses a visual basing on the current display mode settings\r
+ */\r
+\r
+GLXFBConfig* fgPlatformChooseFBConfig( int *numcfgs )\r
+{\r
+ GLboolean wantIndexedMode = GL_FALSE;\r
+ int attributes[ 100 ];\r
+ int where = 0, numAuxBuffers;\r
+\r
+ /* First we have to process the display mode settings... */\r
+ if( fgState.DisplayMode & GLUT_INDEX ) {\r
+ ATTRIB_VAL( GLX_BUFFER_SIZE, 8 );\r
+ /* Buffer size is selected later. */\r
+\r
+ ATTRIB_VAL( GLX_RENDER_TYPE, GLX_COLOR_INDEX_BIT );\r
+ wantIndexedMode = GL_TRUE;\r
+ } else {\r
+ ATTRIB_VAL( GLX_RED_SIZE, 1 );\r
+ ATTRIB_VAL( GLX_GREEN_SIZE, 1 );\r
+ ATTRIB_VAL( GLX_BLUE_SIZE, 1 );\r
+ if( fgState.DisplayMode & GLUT_ALPHA ) {\r
+ ATTRIB_VAL( GLX_ALPHA_SIZE, 1 );\r
+ }\r
+ }\r
+\r
+ if( fgState.DisplayMode & GLUT_DOUBLE ) {\r
+ ATTRIB_VAL( GLX_DOUBLEBUFFER, True );\r
+ }\r
+\r
+ if( fgState.DisplayMode & GLUT_STEREO ) {\r
+ ATTRIB_VAL( GLX_STEREO, True );\r
+ }\r
+\r
+ if( fgState.DisplayMode & GLUT_DEPTH ) {\r
+ ATTRIB_VAL( GLX_DEPTH_SIZE, 1 );\r
+ }\r
+\r
+ if( fgState.DisplayMode & GLUT_STENCIL ) {\r
+ ATTRIB_VAL( GLX_STENCIL_SIZE, 1 );\r
+ }\r
+\r
+ if( fgState.DisplayMode & GLUT_ACCUM ) {\r
+ ATTRIB_VAL( GLX_ACCUM_RED_SIZE, 1 );\r
+ ATTRIB_VAL( GLX_ACCUM_GREEN_SIZE, 1 );\r
+ ATTRIB_VAL( GLX_ACCUM_BLUE_SIZE, 1 );\r
+ if( fgState.DisplayMode & GLUT_ALPHA ) {\r
+ ATTRIB_VAL( GLX_ACCUM_ALPHA_SIZE, 1 );\r
+ }\r
+ }\r
+\r
+ numAuxBuffers = fghNumberOfAuxBuffersRequested();\r
+ if ( numAuxBuffers > 0 ) {\r
+ ATTRIB_VAL( GLX_AUX_BUFFERS, numAuxBuffers );\r
+ }\r
+\r
+ if( fgState.DisplayMode & GLUT_SRGB ) {\r
+ ATTRIB_VAL( GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB, True );\r
+ }\r
+\r
+ if (fgState.DisplayMode & GLUT_MULTISAMPLE) {\r
+ ATTRIB_VAL(GLX_SAMPLE_BUFFERS, 1);\r
+ ATTRIB_VAL(GLX_SAMPLES, fgState.SampleNumber);\r
+ }\r
+\r
+ /* Push a terminator at the end of the list */\r
+ ATTRIB( None );\r
+\r
+ {\r
+ GLXFBConfig * fbconfigArray; /* Array of FBConfigs */\r
+ GLXFBConfig * fbconfig; /* The FBConfig we want */\r
+ int fbconfigArraySize; /* Number of FBConfigs in the array */\r
+\r
+\r
+ /* Get all FBConfigs that match "attributes". */\r
+ fbconfigArray = glXChooseFBConfig( fgDisplay.pDisplay.Display,\r
+ fgDisplay.pDisplay.Screen,\r
+ attributes,\r
+ &fbconfigArraySize );\r
+\r
+ if (fbconfigArray != NULL)\r
+ {\r
+ int result; /* Returned by glXGetFBConfigAttrib, not checked. */\r
+\r
+\r
+ if( wantIndexedMode )\r
+ {\r
+ /*\r
+ * In index mode, we want the largest buffer size, i.e. visual\r
+ * depth. Here, FBConfigs are sorted by increasing buffer size\r
+ * first, so FBConfigs with the largest size come last.\r
+ */\r
+\r
+ int bufferSizeMin, bufferSizeMax;\r
+\r
+ /* Get bufferSizeMin. */\r
+ result =\r
+ glXGetFBConfigAttrib( fgDisplay.pDisplay.Display,\r
+ fbconfigArray[0],\r
+ GLX_BUFFER_SIZE,\r
+ &bufferSizeMin );\r
+ /* Get bufferSizeMax. */\r
+ result =\r
+ glXGetFBConfigAttrib( fgDisplay.pDisplay.Display,\r
+ fbconfigArray[fbconfigArraySize - 1],\r
+ GLX_BUFFER_SIZE,\r
+ &bufferSizeMax );\r
+\r
+ if (bufferSizeMax > bufferSizeMin)\r
+ {\r
+ /* \r
+ * Free and reallocate fbconfigArray, keeping only FBConfigs\r
+ * with the largest buffer size.\r
+ */\r
+ XFree(fbconfigArray);\r
+\r
+ /* Add buffer size token at the end of the list. */\r
+ where--;\r
+ ATTRIB_VAL( GLX_BUFFER_SIZE, bufferSizeMax );\r
+ ATTRIB( None );\r
+\r
+ fbconfigArray = glXChooseFBConfig( fgDisplay.pDisplay.Display,\r
+ fgDisplay.pDisplay.Screen,\r
+ attributes,\r
+ &fbconfigArraySize );\r
+ }\r
+ }\r
+\r
+ /*\r
+ * We now have an array of FBConfigs, the first one being the "best"\r
+ * one. So we should return only this FBConfig:\r
+ *\r
+ * int fbconfigXID;\r
+ *\r
+ * - pick the XID of the FBConfig we want\r
+ * result = glXGetFBConfigAttrib( fgDisplay.pDisplay.Display,\r
+ * fbconfigArray[0],\r
+ * GLX_FBCONFIG_ID,\r
+ * &fbconfigXID );\r
+ *\r
+ * - free the array\r
+ * XFree(fbconfigArray);\r
+ *\r
+ * - reset "attributes" with the XID\r
+ * where = 0;\r
+ * ATTRIB_VAL( GLX_FBCONFIG_ID, fbconfigXID );\r
+ * ATTRIB( None );\r
+ *\r
+ * - get our FBConfig only\r
+ * fbconfig = glXChooseFBConfig( fgDisplay.pDisplay.Display,\r
+ * fgDisplay.pDisplay.Screen,\r
+ * attributes,\r
+ * &fbconfigArraySize );\r
+ *\r
+ * However, for some configurations (for instance multisampling with\r
+ * Mesa 6.5.2 and ATI drivers), this does not work:\r
+ * glXChooseFBConfig returns NULL, whereas fbconfigXID is a valid\r
+ * XID. Further investigation is needed.\r
+ *\r
+ * So, for now, we return the whole array of FBConfigs. This should\r
+ * not produce any side effects elsewhere.\r
+ */\r
+ fbconfig = fbconfigArray;\r
+ }\r
+ else\r
+ {\r
+ fbconfig = NULL;\r
+ }\r
+\r
+ if (numcfgs)\r
+ *numcfgs = fbconfigArraySize;\r
+\r
+ return fbconfig;\r
+ }\r
+}\r
+\r
+\r
+static void fghFillContextAttributes( int *attributes ) {\r
+ int where = 0, contextFlags, contextProfile;\r
+\r
+ if ( !fghIsLegacyContextVersionRequested() ) {\r
+ ATTRIB_VAL( GLX_CONTEXT_MAJOR_VERSION_ARB, fgState.MajorVersion );\r
+ ATTRIB_VAL( GLX_CONTEXT_MINOR_VERSION_ARB, fgState.MinorVersion );\r
+ }\r
+\r
+ contextFlags =\r
+ fghMapBit( fgState.ContextFlags, GLUT_DEBUG, GLX_CONTEXT_DEBUG_BIT_ARB ) |\r
+ fghMapBit( fgState.ContextFlags, GLUT_FORWARD_COMPATIBLE, GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB );\r
+ if ( contextFlags != 0 ) {\r
+ ATTRIB_VAL( GLX_CONTEXT_FLAGS_ARB, contextFlags );\r
+ }\r
+\r
+ contextProfile =\r
+ fghMapBit( fgState.ContextProfile, GLUT_CORE_PROFILE, GLX_CONTEXT_CORE_PROFILE_BIT_ARB ) |\r
+ fghMapBit( fgState.ContextProfile, GLUT_COMPATIBILITY_PROFILE, GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB );\r
+ if ( contextProfile != 0 ) {\r
+ ATTRIB_VAL( GLX_CONTEXT_PROFILE_MASK_ARB, contextProfile );\r
+ }\r
+\r
+ ATTRIB( 0 );\r
+}\r
+\r
+typedef GLXContext (*CreateContextAttribsProc)(Display *dpy, GLXFBConfig config,\r
+ GLXContext share_list, Bool direct,\r
+ const int *attrib_list);\r
+\r
+static GLXContext fghCreateNewContext( SFG_Window* window )\r
+{\r
+ /* for color model calculation */\r
+ int menu = ( window->IsMenu && !fgStructure.MenuContext );\r
+ int index_mode = ( fgState.DisplayMode & GLUT_INDEX );\r
+\r
+ /* "classic" context creation */\r
+ Display *dpy = fgDisplay.pDisplay.Display;\r
+ GLXFBConfig config = *(window->Window.pContext.FBConfig);\r
+ int render_type = ( !menu && index_mode ) ? GLX_COLOR_INDEX_TYPE : GLX_RGBA_TYPE;\r
+ GLXContext share_list = NULL;\r
+ Bool direct = ( fgState.DirectContext != GLUT_FORCE_INDIRECT_CONTEXT );\r
+ GLXContext context;\r
+\r
+ /* new context creation */\r
+ int attributes[9];\r
+ CreateContextAttribsProc createContextAttribs = (CreateContextAttribsProc) fghGetProcAddress( "glXCreateContextAttribsARB" );\r
+ \r
+ /* glXCreateContextAttribsARB not found, yet the user has requested the new context creation */\r
+ if ( !createContextAttribs && !fghIsLegacyContextRequested() ) {\r
+ fgWarning( "OpenGL >2.1 context requested but glXCreateContextAttribsARB is not available! Falling back to legacy context creation" );\r
+ fgState.MajorVersion = 2;\r
+ fgState.MinorVersion = 1;\r
+ }\r
+\r
+ /* If nothing fancy has been required, simply use the old context creation GLX API entry */\r
+ if ( fghIsLegacyContextRequested() || !createContextAttribs )\r
+ {\r
+ context = glXCreateNewContext( dpy, config, render_type, share_list, direct );\r
+ if ( context == NULL ) {\r
+ fghContextCreationError();\r
+ }\r
+ return context;\r
+ }\r
+\r
+ /* color index mode is not available anymore with OpenGL 3.0 */\r
+ if ( render_type == GLX_COLOR_INDEX_TYPE ) {\r
+ fgWarning( "color index mode is deprecated, using RGBA mode" );\r
+ }\r
+\r
+ fghFillContextAttributes( attributes );\r
+\r
+ context = createContextAttribs( dpy, config, share_list, direct, attributes );\r
+ if ( context == NULL ) {\r
+ fghContextCreationError();\r
+ }\r
+ return context;\r
+}\r
+\r
+\r
+#define _NET_WM_STATE_TOGGLE 2\r
+static int fghResizeFullscrToggle(void)\r
+{\r
+ XWindowAttributes attributes;\r
+\r
+ if(glutGet(GLUT_FULL_SCREEN)) {\r
+ /* restore original window size */\r
+ SFG_Window *win = fgStructure.CurrentWindow;\r
+ fgStructure.CurrentWindow->State.NeedToResize = GL_TRUE;\r
+ fgStructure.CurrentWindow->State.Width = win->State.pWState.OldWidth;\r
+ fgStructure.CurrentWindow->State.Height = win->State.pWState.OldHeight;\r
+\r
+ } else {\r
+ /* resize the window to cover the entire screen */\r
+ XGetWindowAttributes(fgDisplay.pDisplay.Display,\r
+ fgStructure.CurrentWindow->Window.Handle,\r
+ &attributes);\r
+ \r
+ /*\r
+ * The "x" and "y" members of "attributes" are the window's coordinates\r
+ * relative to its parent, i.e. to the decoration window.\r
+ */\r
+ XMoveResizeWindow(fgDisplay.pDisplay.Display,\r
+ fgStructure.CurrentWindow->Window.Handle,\r
+ -attributes.x,\r
+ -attributes.y,\r
+ fgDisplay.ScreenWidth,\r
+ fgDisplay.ScreenHeight);\r
+ }\r
+ return 0;\r
+}\r
+\r
+static int fghEwmhFullscrToggle(void)\r
+{\r
+ XEvent xev;\r
+ long evmask = SubstructureRedirectMask | SubstructureNotifyMask;\r
+\r
+ if(!fgDisplay.pDisplay.State || !fgDisplay.pDisplay.StateFullScreen) {\r
+ return -1;\r
+ }\r
+\r
+ xev.type = ClientMessage;\r
+ xev.xclient.window = fgStructure.CurrentWindow->Window.Handle;\r
+ xev.xclient.message_type = fgDisplay.pDisplay.State;\r
+ xev.xclient.format = 32;\r
+ xev.xclient.data.l[0] = _NET_WM_STATE_TOGGLE;\r
+ xev.xclient.data.l[1] = fgDisplay.pDisplay.StateFullScreen;\r
+ xev.xclient.data.l[2] = 0; /* no second property to toggle */\r
+ xev.xclient.data.l[3] = 1; /* source indication: application */\r
+ xev.xclient.data.l[4] = 0; /* unused */\r
+\r
+ if(!XSendEvent(fgDisplay.pDisplay.Display, fgDisplay.pDisplay.RootWindow, 0, evmask, &xev)) {\r
+ return -1;\r
+ }\r
+ return 0;\r
+}\r
+\r
+static int fghToggleFullscreen(void)\r
+{\r
+ /* first try the EWMH (_NET_WM_STATE) method ... */\r
+ if(fghEwmhFullscrToggle() != -1) {\r
+ return 0;\r
+ }\r
+\r
+ /* fall back to resizing the window */\r
+ if(fghResizeFullscrToggle() != -1) {\r
+ return 0;\r
+ }\r
+ return -1;\r
+}\r
+\r
+void fgPlatformSetWindow ( SFG_Window *window )\r
+{\r
+ if ( window )\r
+ {\r
+ glXMakeContextCurrent(\r
+ fgDisplay.pDisplay.Display,\r
+ window->Window.Handle,\r
+ window->Window.Handle,\r
+ window->Window.Context\r
+ );\r
+ }\r
+}\r
+\r
+static Bool fghWindowIsVisible( Display *display, XEvent *event, XPointer arg)\r
+{\r
+ Window window = (Window)arg;\r
+ return (event->type == MapNotify) && (event->xmap.window == window);\r
+}\r
+\r
+/*\r
+ * Opens a window. Requires a SFG_Window object created and attached\r
+ * to the freeglut structure. OpenGL context is created here.\r
+ */\r
+void fgPlatformOpenWindow( SFG_Window* window, const char* title,\r
+ GLboolean positionUse, int x, int y,\r
+ GLboolean sizeUse, int w, int h,\r
+ GLboolean gameMode, GLboolean isSubWindow )\r
+{\r
+ XVisualInfo * visualInfo = NULL;\r
+ XSetWindowAttributes winAttr;\r
+ XTextProperty textProperty;\r
+ XSizeHints sizeHints;\r
+ XWMHints wmHints;\r
+ XEvent eventReturnBuffer; /* return buffer required for a call */\r
+ unsigned long mask;\r
+ int num_FBConfigs, i;\r
+ unsigned int current_DisplayMode = fgState.DisplayMode ;\r
+\r
+ /* Save the display mode if we are creating a menu window */\r
+ if( window->IsMenu && ( ! fgStructure.MenuContext ) )\r
+ fgState.DisplayMode = GLUT_DOUBLE | GLUT_RGB ;\r
+\r
+ window->Window.pContext.FBConfig = fgPlatformChooseFBConfig( &num_FBConfigs );\r
+\r
+ if( window->IsMenu && ( ! fgStructure.MenuContext ) )\r
+ fgState.DisplayMode = current_DisplayMode ;\r
+\r
+ if( ! window->Window.pContext.FBConfig )\r
+ {\r
+ /*\r
+ * The "fgPlatformChooseFBConfig" returned a null meaning that the visual\r
+ * context is not available.\r
+ * Try a couple of variations to see if they will work.\r
+ */\r
+ if( !( fgState.DisplayMode & GLUT_DOUBLE ) )\r
+ {\r
+ fgState.DisplayMode |= GLUT_DOUBLE ;\r
+ window->Window.pContext.FBConfig = fgPlatformChooseFBConfig( &num_FBConfigs );\r
+ fgState.DisplayMode &= ~GLUT_DOUBLE;\r
+ }\r
+\r
+ if( fgState.DisplayMode & GLUT_MULTISAMPLE )\r
+ {\r
+ fgState.DisplayMode &= ~GLUT_MULTISAMPLE ;\r
+ window->Window.pContext.FBConfig = fgPlatformChooseFBConfig( &num_FBConfigs );\r
+ fgState.DisplayMode |= GLUT_MULTISAMPLE;\r
+ }\r
+ }\r
+\r
+ FREEGLUT_INTERNAL_ERROR_EXIT( window->Window.pContext.FBConfig != NULL,\r
+ "FBConfig with necessary capabilities not found", "fgOpenWindow" );\r
+\r
+ /* Get the X visual. */\r
+ for (i = 0; i < num_FBConfigs; i++) {\r
+ visualInfo = glXGetVisualFromFBConfig( fgDisplay.pDisplay.Display,\r
+ window->Window.pContext.FBConfig[i] );\r
+ if (visualInfo)\r
+ break;\r
+ }\r
+\r
+ FREEGLUT_INTERNAL_ERROR_EXIT( visualInfo != NULL,\r
+ "visualInfo could not be retrieved from FBConfig", "fgOpenWindow" );\r
+\r
+ /*\r
+ * XXX HINT: the masks should be updated when adding/removing callbacks.\r
+ * XXX This might speed up message processing. Is that true?\r
+ * XXX\r
+ * XXX A: Not appreciably, but it WILL make it easier to debug.\r
+ * XXX Try tracing old GLUT and try tracing freeglut. Old GLUT\r
+ * XXX turns off events that it doesn't need and is a whole lot\r
+ * XXX more pleasant to trace. (Think mouse-motion! Tons of\r
+ * XXX ``bonus'' GUI events stream in.)\r
+ */\r
+ winAttr.event_mask =\r
+ StructureNotifyMask | SubstructureNotifyMask | ExposureMask |\r
+ ButtonPressMask | ButtonReleaseMask | KeyPressMask | KeyReleaseMask |\r
+ VisibilityChangeMask | EnterWindowMask | LeaveWindowMask |\r
+ PointerMotionMask | ButtonMotionMask;\r
+ winAttr.background_pixmap = None;\r
+ winAttr.background_pixel = 0;\r
+ winAttr.border_pixel = 0;\r
+\r
+ winAttr.colormap = XCreateColormap(\r
+ fgDisplay.pDisplay.Display, fgDisplay.pDisplay.RootWindow,\r
+ visualInfo->visual, AllocNone\r
+ );\r
+\r
+ mask = CWBackPixmap | CWBorderPixel | CWColormap | CWEventMask;\r
+\r
+ if( window->IsMenu || ( gameMode == GL_TRUE ) )\r
+ {\r
+ winAttr.override_redirect = True;\r
+ mask |= CWOverrideRedirect;\r
+ }\r
+\r
+ if( ! positionUse )\r
+ x = y = -1; /* default window position */\r
+ if( ! sizeUse )\r
+ w = h = 300; /* default window size */\r
+\r
+ window->Window.Handle = XCreateWindow(\r
+ fgDisplay.pDisplay.Display,\r
+ window->Parent == NULL ? fgDisplay.pDisplay.RootWindow :\r
+ window->Parent->Window.Handle,\r
+ x, y, w, h, 0,\r
+ visualInfo->depth, InputOutput,\r
+ visualInfo->visual, mask,\r
+ &winAttr\r
+ );\r
+\r
+ /*\r
+ * The GLX context creation, possibly trying the direct context rendering\r
+ * or else use the current context if the user has so specified\r
+ */\r
+\r
+ if( window->IsMenu )\r
+ {\r
+ /*\r
+ * If there isn't already an OpenGL rendering context for menu\r
+ * windows, make one\r
+ */\r
+ if( !fgStructure.MenuContext )\r
+ {\r
+ fgStructure.MenuContext =\r
+ (SFG_MenuContext *)malloc( sizeof(SFG_MenuContext) );\r
+ fgStructure.MenuContext->MContext = fghCreateNewContext( window );\r
+ }\r
+\r
+ /* window->Window.Context = fgStructure.MenuContext->MContext; */\r
+ window->Window.Context = fghCreateNewContext( window );\r
+ }\r
+ else if( fgState.UseCurrentContext )\r
+ {\r
+ window->Window.Context = glXGetCurrentContext( );\r
+\r
+ if( ! window->Window.Context )\r
+ window->Window.Context = fghCreateNewContext( window );\r
+ }\r
+ else\r
+ window->Window.Context = fghCreateNewContext( window );\r
+\r
+#if !defined( __FreeBSD__ ) && !defined( __NetBSD__ )\r
+ if( !glXIsDirect( fgDisplay.pDisplay.Display, window->Window.Context ) )\r
+ {\r
+ if( fgState.DirectContext == GLUT_FORCE_DIRECT_CONTEXT )\r
+ fgError( "Unable to force direct context rendering for window '%s'",\r
+ title );\r
+ }\r
+#endif\r
+\r
+ /*\r
+ * XXX Assume the new window is visible by default\r
+ * XXX Is this a safe assumption?\r
+ */\r
+ window->State.Visible = GL_TRUE;\r
+\r
+ sizeHints.flags = 0;\r
+ if ( positionUse )\r
+ sizeHints.flags |= USPosition;\r
+ if ( sizeUse )\r
+ sizeHints.flags |= USSize;\r
+\r
+ /*\r
+ * Fill in the size hints values now (the x, y, width and height\r
+ * settings are obsolete, are there any more WMs that support them?)\r
+ * Unless the X servers actually stop supporting these, we should\r
+ * continue to fill them in. It is *not* our place to tell the user\r
+ * that they should replace a window manager that they like, and which\r
+ * works, just because *we* think that it's not "modern" enough.\r
+ */\r
+ sizeHints.x = x;\r
+ sizeHints.y = y;\r
+ sizeHints.width = w;\r
+ sizeHints.height = h;\r
+\r
+ wmHints.flags = StateHint;\r
+ wmHints.initial_state = fgState.ForceIconic ? IconicState : NormalState;\r
+ /* Prepare the window and iconified window names... */\r
+ XStringListToTextProperty( (char **) &title, 1, &textProperty );\r
+\r
+ XSetWMProperties(\r
+ fgDisplay.pDisplay.Display,\r
+ window->Window.Handle,\r
+ &textProperty,\r
+ &textProperty,\r
+ 0,\r
+ 0,\r
+ &sizeHints,\r
+ &wmHints,\r
+ NULL\r
+ );\r
+ XFree( textProperty.value );\r
+\r
+ XSetWMProtocols( fgDisplay.pDisplay.Display, window->Window.Handle,\r
+ &fgDisplay.pDisplay.DeleteWindow, 1 );\r
+\r
+ glXMakeContextCurrent(\r
+ fgDisplay.pDisplay.Display,\r
+ window->Window.Handle,\r
+ window->Window.Handle,\r
+ window->Window.Context\r
+ );\r
+\r
+ /* register extension events _before_ window is mapped */\r
+ #ifdef HAVE_X11_EXTENSIONS_XINPUT2_H\r
+ fgRegisterDevices( fgDisplay.pDisplay.Display, &(window->Window.Handle) );\r
+ #endif\r
+\r
+ XMapWindow( fgDisplay.pDisplay.Display, window->Window.Handle );\r
+\r
+ XFree(visualInfo);\r
+\r
+ if( !isSubWindow)\r
+ XPeekIfEvent( fgDisplay.pDisplay.Display, &eventReturnBuffer, &fghWindowIsVisible, (XPointer)(window->Window.Handle) );\r
+}\r
+\r
+\r
+/*\r
+ * Closes a window, destroying the frame and OpenGL context\r
+ */\r
+void fgPlatformCloseWindow( SFG_Window* window )\r
+{\r
+ if( window->Window.Context )\r
+ glXDestroyContext( fgDisplay.pDisplay.Display, window->Window.Context );\r
+ XFree( window->Window.pContext.FBConfig );\r
+\r
+ if( window->Window.Handle ) {\r
+ XDestroyWindow( fgDisplay.pDisplay.Display, window->Window.Handle );\r
+ }\r
+ /* XFlush( fgDisplay.pDisplay.Display ); */ /* XXX Shouldn't need this */\r
+}\r
+\r
+\r
+/*\r
+ * This function makes the current window visible\r
+ */\r
+void fgPlatformGlutShowWindow( void )\r
+{\r
+ XMapWindow( fgDisplay.pDisplay.Display, fgStructure.CurrentWindow->Window.Handle );\r
+ XFlush( fgDisplay.pDisplay.Display ); /* XXX Shouldn't need this */\r
+}\r
+\r
+/*\r
+ * This function hides the current window\r
+ */\r
+void fgPlatformGlutHideWindow( void )\r
+{\r
+ if( fgStructure.CurrentWindow->Parent == NULL )\r
+ XWithdrawWindow( fgDisplay.pDisplay.Display,\r
+ fgStructure.CurrentWindow->Window.Handle,\r
+ fgDisplay.pDisplay.Screen );\r
+ else\r
+ XUnmapWindow( fgDisplay.pDisplay.Display,\r
+ fgStructure.CurrentWindow->Window.Handle );\r
+ XFlush( fgDisplay.pDisplay.Display ); /* XXX Shouldn't need this */\r
+}\r
+\r
+/*\r
+ * Iconify the current window (top-level windows only)\r
+ */\r
+void fgPlatformGlutIconifyWindow( void )\r
+{\r
+ XIconifyWindow( fgDisplay.pDisplay.Display, fgStructure.CurrentWindow->Window.Handle,\r
+ fgDisplay.pDisplay.Screen );\r
+ XFlush( fgDisplay.pDisplay.Display ); /* XXX Shouldn't need this */\r
+}\r
+\r
+/*\r
+ * Set the current window's title\r
+ */\r
+void fgPlatformGlutSetWindowTitle( const char* title )\r
+{\r
+ XTextProperty text;\r
+\r
+ text.value = (unsigned char *) title;\r
+ text.encoding = XA_STRING;\r
+ text.format = 8;\r
+ text.nitems = strlen( title );\r
+\r
+ XSetWMName(\r
+ fgDisplay.pDisplay.Display,\r
+ fgStructure.CurrentWindow->Window.Handle,\r
+ &text\r
+ );\r
+\r
+ XFlush( fgDisplay.pDisplay.Display ); /* XXX Shouldn't need this */\r
+}\r
+\r
+/*\r
+ * Set the current window's iconified title\r
+ */\r
+void fgPlatformGlutSetIconTitle( const char* title )\r
+{\r
+ XTextProperty text;\r
+\r
+ text.value = (unsigned char *) title;\r
+ text.encoding = XA_STRING;\r
+ text.format = 8;\r
+ text.nitems = strlen( title );\r
+\r
+ XSetWMIconName(\r
+ fgDisplay.pDisplay.Display,\r
+ fgStructure.CurrentWindow->Window.Handle,\r
+ &text\r
+ );\r
+\r
+ XFlush( fgDisplay.pDisplay.Display ); /* XXX Shouldn't need this */\r
+}\r
+\r
+/*\r
+ * Change the current window's position\r
+ */\r
+void fgPlatformGlutPositionWindow( int x, int y )\r
+{\r
+ XMoveWindow( fgDisplay.pDisplay.Display, fgStructure.CurrentWindow->Window.Handle,\r
+ x, y );\r
+ XFlush( fgDisplay.pDisplay.Display ); /* XXX Shouldn't need this */\r
+}\r
+\r
+/*\r
+ * Lowers the current window (by Z order change)\r
+ */\r
+void fgPlatformGlutPushWindow( void )\r
+{\r
+ XLowerWindow( fgDisplay.pDisplay.Display, fgStructure.CurrentWindow->Window.Handle );\r
+}\r
+\r
+/*\r
+ * Raises the current window (by Z order change)\r
+ */\r
+void fgPlatformGlutPopWindow( void )\r
+{\r
+ XRaiseWindow( fgDisplay.pDisplay.Display, fgStructure.CurrentWindow->Window.Handle );\r
+}\r
+\r
+/*\r
+ * Resize the current window so that it fits the whole screen\r
+ */\r
+void fgPlatformGlutFullScreen( SFG_Window *win )\r
+{\r
+ if(!glutGet(GLUT_FULL_SCREEN)) {\r
+ if(fghToggleFullscreen() != -1) {\r
+ win->State.IsFullscreen = GL_TRUE;\r
+ }\r
+ }\r
+}\r
+\r
+/*\r
+ * If we are fullscreen, resize the current window back to its original size\r
+ */\r
+void fgPlatformGlutLeaveFullScreen( SFG_Window *win )\r
+{\r
+ if(glutGet(GLUT_FULL_SCREEN)) {\r
+ if(fghToggleFullscreen() != -1) {\r
+ win->State.IsFullscreen = GL_FALSE;\r
+ }\r
+ }\r
+}\r
+\r
+/*\r
+ * Toggle the window's full screen state.\r
+ */\r
+void fgPlatformGlutFullScreenToggle( SFG_Window *win )\r
+{\r
+ if(fghToggleFullscreen() != -1) {\r
+ win->State.IsFullscreen = !win->State.IsFullscreen;\r
+ }\r
+}\r
+\r
projects / freeglut / blobdiff