-/*\r
- * freeglut_init_x11.c\r
- *\r
- * Various freeglut initialization functions.\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 <limits.h> /* LONG_MAX */\r
-#include <GL/freeglut.h>\r
-#include "../Common/freeglut_internal.h"\r
-\r
-/* Return the atom associated with "name". */\r
-static Atom fghGetAtom(const char * name)\r
-{\r
- return XInternAtom(fgDisplay.pDisplay.Display, name, False);\r
-}\r
-\r
-/*\r
- * Check if "property" is set on "window". The property's values are returned\r
- * through "data". If the property is set and is of type "type", return the\r
- * number of elements in "data". Return zero otherwise. In both cases, use\r
- * "Xfree()" to free "data".\r
- */\r
-static int fghGetWindowProperty(Window window,\r
- Atom property,\r
- Atom type,\r
- unsigned char ** data)\r
-{\r
- /*\r
- * Caller always has to use "Xfree()" to free "data", since\r
- * "XGetWindowProperty() always allocates one extra byte in prop_return\r
- * [i.e. "data"] (even if the property is zero length) [..]".\r
- */\r
-\r
- int status; /* Returned by "XGetWindowProperty". */\r
-\r
- Atom type_returned;\r
- int temp_format; /* Not used. */\r
- unsigned long number_of_elements;\r
- unsigned long temp_bytes_after; /* Not used. */\r
-\r
-\r
- status = XGetWindowProperty(fgDisplay.pDisplay.Display,\r
- window,\r
- property,\r
- 0,\r
- LONG_MAX,\r
- False,\r
- type,\r
- &type_returned,\r
- &temp_format,\r
- &number_of_elements,\r
- &temp_bytes_after,\r
- data);\r
-\r
- FREEGLUT_INTERNAL_ERROR_EXIT(status == Success,\r
- "XGetWindowProperty failled",\r
- "fghGetWindowProperty");\r
-\r
- if (type_returned != type)\r
- {\r
- number_of_elements = 0;\r
- }\r
-\r
- return number_of_elements;\r
-}\r
-\r
-/* Check if the window manager is NET WM compliant. */\r
-static int fghNetWMSupported(void)\r
-{\r
- Atom wm_check;\r
- Window ** window_ptr_1;\r
-\r
- int number_of_windows;\r
- int net_wm_supported;\r
-\r
-\r
- net_wm_supported = 0;\r
-\r
- wm_check = fghGetAtom("_NET_SUPPORTING_WM_CHECK");\r
- window_ptr_1 = malloc(sizeof(Window *));\r
-\r
- /*\r
- * Check that the window manager has set this property on the root window.\r
- * The property must be the ID of a child window.\r
- */\r
- number_of_windows = fghGetWindowProperty(fgDisplay.pDisplay.RootWindow,\r
- wm_check,\r
- XA_WINDOW,\r
- (unsigned char **) window_ptr_1);\r
- if (number_of_windows == 1)\r
- {\r
- Window ** window_ptr_2;\r
-\r
- window_ptr_2 = malloc(sizeof(Window *));\r
-\r
- /* Check that the window has the same property set to the same value. */\r
- number_of_windows = fghGetWindowProperty(**window_ptr_1,\r
- wm_check,\r
- XA_WINDOW,\r
- (unsigned char **) window_ptr_2);\r
- if ((number_of_windows == 1) && (**window_ptr_1 == **window_ptr_2))\r
- {\r
- /* NET WM compliant */\r
- net_wm_supported = 1;\r
- }\r
-\r
- XFree(*window_ptr_2);\r
- free(window_ptr_2);\r
- }\r
-\r
- XFree(*window_ptr_1);\r
- free(window_ptr_1);\r
-\r
- return net_wm_supported;\r
-}\r
-\r
-/* Check if "hint" is present in "property" for "window". */\r
-int fgHintPresent(Window window, Atom property, Atom hint)\r
-{\r
- Atom *atoms;\r
- int number_of_atoms;\r
- int supported;\r
- int i;\r
-\r
- supported = 0;\r
-\r
- number_of_atoms = fghGetWindowProperty(window,\r
- property,\r
- XA_ATOM,\r
- (unsigned char **) &atoms);\r
- for (i = 0; i < number_of_atoms; i++)\r
- {\r
- if (atoms[i] == hint)\r
- {\r
- supported = 1;\r
- break;\r
- }\r
- }\r
-\r
- XFree(atoms);\r
- return supported;\r
-}\r
-\r
-/*\r
- * A call to this function should initialize all the display stuff...\r
- */\r
-void fgPlatformInitialize( const char* displayName )\r
-{\r
- fgDisplay.pDisplay.Display = XOpenDisplay( displayName );\r
-\r
- if( fgDisplay.pDisplay.Display == NULL )\r
- fgError( "failed to open display '%s'", XDisplayName( displayName ) );\r
-\r
- if( !glXQueryExtension( fgDisplay.pDisplay.Display, NULL, NULL ) )\r
- fgError( "OpenGL GLX extension not supported by display '%s'",\r
- XDisplayName( displayName ) );\r
-\r
- fgDisplay.pDisplay.Screen = DefaultScreen( fgDisplay.pDisplay.Display );\r
- fgDisplay.pDisplay.RootWindow = RootWindow(\r
- fgDisplay.pDisplay.Display,\r
- fgDisplay.pDisplay.Screen\r
- );\r
-\r
- fgDisplay.ScreenWidth = DisplayWidth(\r
- fgDisplay.pDisplay.Display,\r
- fgDisplay.pDisplay.Screen\r
- );\r
- fgDisplay.ScreenHeight = DisplayHeight(\r
- fgDisplay.pDisplay.Display,\r
- fgDisplay.pDisplay.Screen\r
- );\r
-\r
- fgDisplay.ScreenWidthMM = DisplayWidthMM(\r
- fgDisplay.pDisplay.Display,\r
- fgDisplay.pDisplay.Screen\r
- );\r
- fgDisplay.ScreenHeightMM = DisplayHeightMM(\r
- fgDisplay.pDisplay.Display,\r
- fgDisplay.pDisplay.Screen\r
- );\r
-\r
- fgDisplay.pDisplay.Connection = ConnectionNumber( fgDisplay.pDisplay.Display );\r
-\r
- /* Create the window deletion atom */\r
- fgDisplay.pDisplay.DeleteWindow = fghGetAtom("WM_DELETE_WINDOW");\r
-\r
- /* Create the state and full screen atoms */\r
- fgDisplay.pDisplay.State = None;\r
- fgDisplay.pDisplay.StateFullScreen = None;\r
-\r
- if (fghNetWMSupported())\r
- {\r
- const Atom supported = fghGetAtom("_NET_SUPPORTED");\r
- const Atom state = fghGetAtom("_NET_WM_STATE");\r
- \r
- /* Check if the state hint is supported. */\r
- if (fgHintPresent(fgDisplay.pDisplay.RootWindow, supported, state))\r
- {\r
- const Atom full_screen = fghGetAtom("_NET_WM_STATE_FULLSCREEN");\r
- \r
- fgDisplay.pDisplay.State = state;\r
- \r
- /* Check if the window manager supports full screen. */\r
- /** Check "_NET_WM_ALLOWED_ACTIONS" on our window instead? **/\r
- if (fgHintPresent(fgDisplay.pDisplay.RootWindow, supported, full_screen))\r
- {\r
- fgDisplay.pDisplay.StateFullScreen = full_screen;\r
- }\r
- }\r
- }\r
-\r
-\r
- fgState.Initialised = GL_TRUE;\r
-\r
- atexit(fgDeinitialize);\r
-\r
- /* InputDevice uses GlutTimerFunc(), so fgState.Initialised must be TRUE */\r
- fgInitialiseInputDevices();\r
-}\r
-\r
-void fgPlatformDeinitialiseInputDevices ( void )\r
-{\r
- fghCloseInputDevices ();\r
-\r
- fgState.JoysticksInitialised = GL_FALSE;\r
- fgState.InputDevsInitialised = GL_FALSE;\r
-}\r
-\r
-\r
-void fgPlatformCloseDisplay ( void )\r
-{\r
- /*\r
- * Make sure all X-client data we have created will be destroyed on\r
- * display closing\r
- */\r
- XSetCloseDownMode( fgDisplay.pDisplay.Display, DestroyAll );\r
-\r
- /*\r
- * Close the display connection, destroying all windows we have\r
- * created so far\r
- */\r
- XCloseDisplay( fgDisplay.pDisplay.Display );\r
-}\r
-\r
-\r
-void fgPlatformDestroyContext ( SFG_PlatformDisplay pDisplay, SFG_WindowContextType MContext )\r
-{\r
- /* Note that the MVisualInfo is not owned by the MenuContext! */\r
- glXDestroyContext( pDisplay.Display, MContext );\r
+/*
+ * freeglut_init_x11.c
+ *
+ * Various freeglut initialization functions.
+ *
+ * Copyright (c) 1999-2000 Pawel W. Olszta. All Rights Reserved.
+ * Written by Pawel W. Olszta, <olszta@sourceforge.net>
+ * Copied for Platform code by Evan Felix <karcaw at gmail.com>
+ * Creation date: Thur Feb 2 2012
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * PAWEL W. OLSZTA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#define FREEGLUT_BUILDING_LIB
+#include <limits.h> /* LONG_MAX */
+#include <GL/freeglut.h>
+#include "../Common/freeglut_internal.h"
+
+/* Return the atom associated with "name". */
+static Atom fghGetAtom(const char * name)
+{
+ return XInternAtom(fgDisplay.pDisplay.Display, name, False);
+}
+
+/*
+ * Check if "property" is set on "window". The property's values are returned
+ * through "data". If the property is set and is of type "type", return the
+ * number of elements in "data". Return zero otherwise. In both cases, use
+ * "Xfree()" to free "data".
+ */
+static int fghGetWindowProperty(Window window,
+ Atom property,
+ Atom type,
+ unsigned char ** data)
+{
+ /*
+ * Caller always has to use "Xfree()" to free "data", since
+ * "XGetWindowProperty() always allocates one extra byte in prop_return
+ * [i.e. "data"] (even if the property is zero length) [..]".
+ */
+
+ int status; /* Returned by "XGetWindowProperty". */
+
+ Atom type_returned;
+ int temp_format; /* Not used. */
+ unsigned long number_of_elements;
+ unsigned long temp_bytes_after; /* Not used. */
+
+
+ status = XGetWindowProperty(fgDisplay.pDisplay.Display,
+ window,
+ property,
+ 0,
+ LONG_MAX,
+ False,
+ type,
+ &type_returned,
+ &temp_format,
+ &number_of_elements,
+ &temp_bytes_after,
+ data);
+
+ FREEGLUT_INTERNAL_ERROR_EXIT(status == Success,
+ "XGetWindowProperty failled",
+ "fghGetWindowProperty");
+
+ if (type_returned != type)
+ {
+ number_of_elements = 0;
+ }
+
+ return number_of_elements;
+}
+
+/* Check if the window manager is NET WM compliant. */
+static int fghNetWMSupported(void)
+{
+ Atom wm_check;
+ Window ** window_ptr_1;
+
+ int number_of_windows;
+ int net_wm_supported;
+
+
+ net_wm_supported = 0;
+
+ wm_check = fghGetAtom("_NET_SUPPORTING_WM_CHECK");
+ window_ptr_1 = malloc(sizeof(Window *));
+
+ /*
+ * Check that the window manager has set this property on the root window.
+ * The property must be the ID of a child window.
+ */
+ number_of_windows = fghGetWindowProperty(fgDisplay.pDisplay.RootWindow,
+ wm_check,
+ XA_WINDOW,
+ (unsigned char **) window_ptr_1);
+ if (number_of_windows == 1)
+ {
+ Window ** window_ptr_2;
+
+ window_ptr_2 = malloc(sizeof(Window *));
+
+ /* Check that the window has the same property set to the same value. */
+ number_of_windows = fghGetWindowProperty(**window_ptr_1,
+ wm_check,
+ XA_WINDOW,
+ (unsigned char **) window_ptr_2);
+ if ((number_of_windows == 1) && (**window_ptr_1 == **window_ptr_2))
+ {
+ /* NET WM compliant */
+ net_wm_supported = 1;
+ }
+
+ XFree(*window_ptr_2);
+ free(window_ptr_2);
+ }
+
+ XFree(*window_ptr_1);
+ free(window_ptr_1);
+
+ return net_wm_supported;
+}
+
+/* Check if "hint" is present in "property" for "window". */
+int fgHintPresent(Window window, Atom property, Atom hint)
+{
+ Atom *atoms;
+ int number_of_atoms;
+ int supported;
+ int i;
+
+ supported = 0;
+
+ number_of_atoms = fghGetWindowProperty(window,
+ property,
+ XA_ATOM,
+ (unsigned char **) &atoms);
+ for (i = 0; i < number_of_atoms; i++)
+ {
+ if (atoms[i] == hint)
+ {
+ supported = 1;
+ break;
+ }
+ }
+
+ XFree(atoms);
+ return supported;
+}
+
+/*
+ * A call to this function should initialize all the display stuff...
+ */
+void fgPlatformInitialize( const char* displayName )
+{
+ fgDisplay.pDisplay.Display = XOpenDisplay( displayName );
+
+ if( fgDisplay.pDisplay.Display == NULL )
+ fgError( "failed to open display '%s'", XDisplayName( displayName ) );
+
+ if( !glXQueryExtension( fgDisplay.pDisplay.Display, NULL, NULL ) )
+ fgError( "OpenGL GLX extension not supported by display '%s'",
+ XDisplayName( displayName ) );
+
+ fgDisplay.pDisplay.Screen = DefaultScreen( fgDisplay.pDisplay.Display );
+ fgDisplay.pDisplay.RootWindow = RootWindow(
+ fgDisplay.pDisplay.Display,
+ fgDisplay.pDisplay.Screen
+ );
+
+ fgDisplay.ScreenWidth = DisplayWidth(
+ fgDisplay.pDisplay.Display,
+ fgDisplay.pDisplay.Screen
+ );
+ fgDisplay.ScreenHeight = DisplayHeight(
+ fgDisplay.pDisplay.Display,
+ fgDisplay.pDisplay.Screen
+ );
+
+ fgDisplay.ScreenWidthMM = DisplayWidthMM(
+ fgDisplay.pDisplay.Display,
+ fgDisplay.pDisplay.Screen
+ );
+ fgDisplay.ScreenHeightMM = DisplayHeightMM(
+ fgDisplay.pDisplay.Display,
+ fgDisplay.pDisplay.Screen
+ );
+
+ fgDisplay.pDisplay.Connection = ConnectionNumber( fgDisplay.pDisplay.Display );
+
+ /* Create the window deletion atom */
+ fgDisplay.pDisplay.DeleteWindow = fghGetAtom("WM_DELETE_WINDOW");
+
+ /* Create the state and full screen atoms */
+ fgDisplay.pDisplay.State = None;
+ fgDisplay.pDisplay.StateFullScreen = None;
+
+ if (fghNetWMSupported())
+ {
+ const Atom supported = fghGetAtom("_NET_SUPPORTED");
+ const Atom state = fghGetAtom("_NET_WM_STATE");
+
+ /* Check if the state hint is supported. */
+ if (fgHintPresent(fgDisplay.pDisplay.RootWindow, supported, state))
+ {
+ const Atom full_screen = fghGetAtom("_NET_WM_STATE_FULLSCREEN");
+
+ fgDisplay.pDisplay.State = state;
+
+ /* Check if the window manager supports full screen. */
+ /** Check "_NET_WM_ALLOWED_ACTIONS" on our window instead? **/
+ if (fgHintPresent(fgDisplay.pDisplay.RootWindow, supported, full_screen))
+ {
+ fgDisplay.pDisplay.StateFullScreen = full_screen;
+ }
+ }
+ }
+
+
+ fgState.Initialised = GL_TRUE;
+
+ atexit(fgDeinitialize);
+
+ /* InputDevice uses GlutTimerFunc(), so fgState.Initialised must be TRUE */
+ fgInitialiseInputDevices();
+}
+
+void fgPlatformDeinitialiseInputDevices ( void )
+{
+ fghCloseInputDevices ();
+
+ fgState.JoysticksInitialised = GL_FALSE;
+ fgState.InputDevsInitialised = GL_FALSE;
+}
+
+
+void fgPlatformCloseDisplay ( void )
+{
+ /*
+ * Make sure all X-client data we have created will be destroyed on
+ * display closing
+ */
+ XSetCloseDownMode( fgDisplay.pDisplay.Display, DestroyAll );
+
+ /*
+ * Close the display connection, destroying all windows we have
+ * created so far
+ */
+ XCloseDisplay( fgDisplay.pDisplay.Display );
+}
+
+
+void fgPlatformDestroyContext ( SFG_PlatformDisplay pDisplay, SFG_WindowContextType MContext )
+{
+ /* Note that the MVisualInfo is not owned by the MenuContext! */
+ glXDestroyContext( pDisplay.Display, MContext );