/*
- * freeglut_window_x11.c
+ * fg_window_x11.c
*
* Window management methods for X11
*
#define FREEGLUT_BUILDING_LIB
#include <GL/freeglut.h>
-#include <limits.h> /* LONG_MAX */
-#include <unistd.h> /* usleep */
+#include <limits.h> /* LONG_MAX */
+#include <unistd.h> /* usleep, gethostname, getpid */
+#include <sys/types.h> /* pid_t */
#include "../fg_internal.h"
-/* pushing attribute/value pairs into an array */
-#define ATTRIB(a) attributes[where++]=(a)
-#define ATTRIB_VAL(a,v) {ATTRIB(a); ATTRIB(v);}
-
-
-#ifndef GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB
-#define GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB 0x20B2
-#endif
-
-#ifndef GLX_CONTEXT_MAJOR_VERSION_ARB
-#define GLX_CONTEXT_MAJOR_VERSION_ARB 0x2091
-#endif
-
-#ifndef GLX_CONTEXT_MINOR_VERSION_ARB
-#define GLX_CONTEXT_MINOR_VERSION_ARB 0x2092
-#endif
-
-#ifndef GLX_CONTEXT_FLAGS_ARB
-#define GLX_CONTEXT_FLAGS_ARB 0x2094
-#endif
-
-#ifndef GLX_CONTEXT_PROFILE_MASK_ARB
-#define GLX_CONTEXT_PROFILE_MASK_ARB 0x9126
-#endif
-
-#ifndef GLX_CONTEXT_DEBUG_BIT_ARB
-#define GLX_CONTEXT_DEBUG_BIT_ARB 0x0001
-#endif
-
-#ifndef GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB
-#define GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x0002
-#endif
-
-#ifndef GLX_CONTEXT_CORE_PROFILE_BIT_ARB
-#define GLX_CONTEXT_CORE_PROFILE_BIT_ARB 0x00000001
-#endif
-
-#ifndef GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB
-#define GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002
-#endif
-
-#ifndef GLX_RGBA_FLOAT_TYPE
-#define GLX_RGBA_FLOAT_TYPE 0x20B9
+#ifdef EGL_VERSION_1_0
+#include "egl/fg_window_egl.h"
+#define fghCreateNewContext fghCreateNewContextEGL
+#else
+#include "x11/fg_window_x11_glx.h"
#endif
-#ifndef GLX_RGBA_FLOAT_BIT
-#define GLX_RGBA_FLOAT_BIT 0x00000004
+#ifndef HOST_NAME_MAX
+#define HOST_NAME_MAX 255
#endif
-
-/*
- * Chooses a visual basing on the current display mode settings
- */
-
-GLXFBConfig* fgPlatformChooseFBConfig( int *numcfgs )
+/* Motif window hints, only define needed ones */
+typedef struct
{
- GLboolean wantIndexedMode = GL_FALSE;
- int attributes[ 100 ];
- int where = 0, numAuxBuffers;
-
- /* First we have to process the display mode settings... */
- if( fgState.DisplayMode & GLUT_INDEX ) {
- ATTRIB_VAL( GLX_BUFFER_SIZE, 8 );
- /* Buffer size is selected later. */
-
- ATTRIB_VAL( GLX_RENDER_TYPE, GLX_COLOR_INDEX_BIT );
- wantIndexedMode = GL_TRUE;
- } else {
- ATTRIB_VAL( GLX_RED_SIZE, 1 );
- ATTRIB_VAL( GLX_GREEN_SIZE, 1 );
- ATTRIB_VAL( GLX_BLUE_SIZE, 1 );
- if( fgState.DisplayMode & GLUT_ALPHA ) {
- ATTRIB_VAL( GLX_ALPHA_SIZE, 1 );
- }
- }
-
- if( fgState.DisplayMode & GLUT_DOUBLE ) {
- ATTRIB_VAL( GLX_DOUBLEBUFFER, True );
- }
-
- if( fgState.DisplayMode & GLUT_STEREO ) {
- ATTRIB_VAL( GLX_STEREO, True );
- }
-
- if( fgState.DisplayMode & GLUT_DEPTH ) {
- ATTRIB_VAL( GLX_DEPTH_SIZE, 1 );
- }
-
- if( fgState.DisplayMode & GLUT_STENCIL ) {
- ATTRIB_VAL( GLX_STENCIL_SIZE, 1 );
- }
-
- if( fgState.DisplayMode & GLUT_ACCUM ) {
- ATTRIB_VAL( GLX_ACCUM_RED_SIZE, 1 );
- ATTRIB_VAL( GLX_ACCUM_GREEN_SIZE, 1 );
- ATTRIB_VAL( GLX_ACCUM_BLUE_SIZE, 1 );
- if( fgState.DisplayMode & GLUT_ALPHA ) {
- ATTRIB_VAL( GLX_ACCUM_ALPHA_SIZE, 1 );
- }
- }
-
- numAuxBuffers = fghNumberOfAuxBuffersRequested();
- if ( numAuxBuffers > 0 ) {
- ATTRIB_VAL( GLX_AUX_BUFFERS, numAuxBuffers );
- }
-
- if( fgState.DisplayMode & GLUT_SRGB ) {
- ATTRIB_VAL( GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB, True );
- }
-
- if (fgState.DisplayMode & GLUT_MULTISAMPLE) {
- ATTRIB_VAL(GLX_SAMPLE_BUFFERS, 1);
- ATTRIB_VAL(GLX_SAMPLES, fgState.SampleNumber);
- }
-
- /* Push a terminator at the end of the list */
- ATTRIB( None );
-
- {
- GLXFBConfig * fbconfigArray; /* Array of FBConfigs */
- GLXFBConfig * fbconfig; /* The FBConfig we want */
- int fbconfigArraySize; /* Number of FBConfigs in the array */
-
-
- /* Get all FBConfigs that match "attributes". */
- fbconfigArray = glXChooseFBConfig( fgDisplay.pDisplay.Display,
- fgDisplay.pDisplay.Screen,
- attributes,
- &fbconfigArraySize );
+ unsigned long flags;
+ unsigned long functions;
+ unsigned long decorations;
+ long input_mode;
+ unsigned long status;
+} MotifWmHints;
+#define MWM_HINTS_DECORATIONS (1L << 1)
+#define MWM_DECOR_BORDER (1L << 1)
- if (fbconfigArray != NULL)
- {
- int result; /* Returned by glXGetFBConfigAttrib, not checked. */
-
-
- if( wantIndexedMode )
- {
- /*
- * In index mode, we want the largest buffer size, i.e. visual
- * depth. Here, FBConfigs are sorted by increasing buffer size
- * first, so FBConfigs with the largest size come last.
- */
-
- int bufferSizeMin, bufferSizeMax;
-
- /* Get bufferSizeMin. */
- result =
- glXGetFBConfigAttrib( fgDisplay.pDisplay.Display,
- fbconfigArray[0],
- GLX_BUFFER_SIZE,
- &bufferSizeMin );
- /* Get bufferSizeMax. */
- result =
- glXGetFBConfigAttrib( fgDisplay.pDisplay.Display,
- fbconfigArray[fbconfigArraySize - 1],
- GLX_BUFFER_SIZE,
- &bufferSizeMax );
-
- if (bufferSizeMax > bufferSizeMin)
- {
- /*
- * Free and reallocate fbconfigArray, keeping only FBConfigs
- * with the largest buffer size.
- */
- XFree(fbconfigArray);
-
- /* Add buffer size token at the end of the list. */
- where--;
- ATTRIB_VAL( GLX_BUFFER_SIZE, bufferSizeMax );
- ATTRIB( None );
-
- fbconfigArray = glXChooseFBConfig( fgDisplay.pDisplay.Display,
- fgDisplay.pDisplay.Screen,
- attributes,
- &fbconfigArraySize );
- }
- }
-
- /*
- * We now have an array of FBConfigs, the first one being the "best"
- * one. So we should return only this FBConfig:
- *
- * int fbconfigXID;
- *
- * - pick the XID of the FBConfig we want
- * result = glXGetFBConfigAttrib( fgDisplay.pDisplay.Display,
- * fbconfigArray[0],
- * GLX_FBCONFIG_ID,
- * &fbconfigXID );
- *
- * - free the array
- * XFree(fbconfigArray);
- *
- * - reset "attributes" with the XID
- * where = 0;
- * ATTRIB_VAL( GLX_FBCONFIG_ID, fbconfigXID );
- * ATTRIB( None );
- *
- * - get our FBConfig only
- * fbconfig = glXChooseFBConfig( fgDisplay.pDisplay.Display,
- * fgDisplay.pDisplay.Screen,
- * attributes,
- * &fbconfigArraySize );
- *
- * However, for some configurations (for instance multisampling with
- * Mesa 6.5.2 and ATI drivers), this does not work:
- * glXChooseFBConfig returns NULL, whereas fbconfigXID is a valid
- * XID. Further investigation is needed.
- *
- * So, for now, we return the whole array of FBConfigs. This should
- * not produce any side effects elsewhere.
- */
- fbconfig = fbconfigArray;
- }
- else
- {
- fbconfig = NULL;
- }
-
- if (numcfgs)
- *numcfgs = fbconfigArraySize;
-
- return fbconfig;
- }
-}
-
-
-static void fghFillContextAttributes( int *attributes ) {
- int where = 0, contextFlags, contextProfile;
-
- if ( !fghIsLegacyContextVersionRequested() ) {
- ATTRIB_VAL( GLX_CONTEXT_MAJOR_VERSION_ARB, fgState.MajorVersion );
- ATTRIB_VAL( GLX_CONTEXT_MINOR_VERSION_ARB, fgState.MinorVersion );
- }
-
- contextFlags =
- fghMapBit( fgState.ContextFlags, GLUT_DEBUG, GLX_CONTEXT_DEBUG_BIT_ARB ) |
- fghMapBit( fgState.ContextFlags, GLUT_FORWARD_COMPATIBLE, GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB );
- if ( contextFlags != 0 ) {
- ATTRIB_VAL( GLX_CONTEXT_FLAGS_ARB, contextFlags );
- }
-
- contextProfile =
- fghMapBit( fgState.ContextProfile, GLUT_CORE_PROFILE, GLX_CONTEXT_CORE_PROFILE_BIT_ARB ) |
- fghMapBit( fgState.ContextProfile, GLUT_COMPATIBILITY_PROFILE, GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB );
- if ( contextProfile != 0 ) {
- ATTRIB_VAL( GLX_CONTEXT_PROFILE_MASK_ARB, contextProfile );
- }
-
- ATTRIB( 0 );
-}
-
-typedef GLXContext (*CreateContextAttribsProc)(Display *dpy, GLXFBConfig config,
- GLXContext share_list, Bool direct,
- const int *attrib_list);
-
-static GLXContext fghCreateNewContext( SFG_Window* window )
-{
- /* for color model calculation */
- int menu = ( window->IsMenu && !fgStructure.MenuContext );
- int index_mode = ( fgState.DisplayMode & GLUT_INDEX );
-
- /* "classic" context creation */
- Display *dpy = fgDisplay.pDisplay.Display;
- GLXFBConfig config = *(window->Window.pContext.FBConfig);
- int render_type = ( !menu && index_mode ) ? GLX_COLOR_INDEX_TYPE : GLX_RGBA_TYPE;
- GLXContext share_list = NULL;
- Bool direct = ( fgState.DirectContext != GLUT_FORCE_INDIRECT_CONTEXT );
- GLXContext context;
-
- /* new context creation */
- int attributes[9];
- CreateContextAttribsProc createContextAttribs = (CreateContextAttribsProc) fgPlatformGetProcAddress( "glXCreateContextAttribsARB" );
-
- /* glXCreateContextAttribsARB not found, yet the user has requested the new context creation */
- if ( !createContextAttribs && !fghIsLegacyContextRequested() ) {
- fgWarning( "OpenGL >2.1 context requested but glXCreateContextAttribsARB is not available! Falling back to legacy context creation" );
- fgState.MajorVersion = 2;
- fgState.MinorVersion = 1;
- }
-
- /* If nothing fancy has been required, simply use the old context creation GLX API entry */
- if ( fghIsLegacyContextRequested() || !createContextAttribs )
- {
- context = glXCreateNewContext( dpy, config, render_type, share_list, direct );
- if ( context == NULL ) {
- fghContextCreationError();
- }
- return context;
- }
-
- /* color index mode is not available anymore with OpenGL 3.0 */
- if ( render_type == GLX_COLOR_INDEX_TYPE ) {
- fgWarning( "color index mode is deprecated, using RGBA mode" );
- }
-
- fghFillContextAttributes( attributes );
-
- context = createContextAttribs( dpy, config, share_list, direct, attributes );
- if ( context == NULL ) {
- fghContextCreationError();
- }
- return context;
-}
-
-
-#define _NET_WM_STATE_TOGGLE 2
static int fghResizeFullscrToggle(void)
{
XWindowAttributes attributes;
+ SFG_Window *win = fgStructure.CurrentWindow;
if(glutGet(GLUT_FULL_SCREEN)) {
/* restore original window size */
- SFG_Window *win = fgStructure.CurrentWindow;
- fgStructure.CurrentWindow->State.NeedToResize = GL_TRUE;
- fgStructure.CurrentWindow->State.Width = win->State.pWState.OldWidth;
- fgStructure.CurrentWindow->State.Height = win->State.pWState.OldHeight;
+ fgStructure.CurrentWindow->State.WorkMask = GLUT_SIZE_WORK;
+ fgStructure.CurrentWindow->State.DesiredWidth = win->State.pWState.OldWidth;
+ fgStructure.CurrentWindow->State.DesiredHeight = win->State.pWState.OldHeight;
} else {
+ fgStructure.CurrentWindow->State.pWState.OldWidth = win->State.Width;
+ fgStructure.CurrentWindow->State.pWState.OldHeight = win->State.Height;
+
/* resize the window to cover the entire screen */
XGetWindowAttributes(fgDisplay.pDisplay.Display,
fgStructure.CurrentWindow->Window.Handle,
return 0;
}
+#define _NET_WM_STATE_TOGGLE 2
static int fghEwmhFullscrToggle(void)
{
XEvent xev;
return -1;
}
-void fgPlatformSetWindow ( SFG_Window *window )
-{
- if ( window )
- {
- glXMakeContextCurrent(
- fgDisplay.pDisplay.Display,
- window->Window.Handle,
- window->Window.Handle,
- window->Window.Context
- );
- }
-}
-
static Bool fghWindowIsVisible( Display *display, XEvent *event, XPointer arg)
{
Window window = (Window)arg;
XWMHints wmHints;
XEvent eventReturnBuffer; /* return buffer required for a call */
unsigned long mask;
- int num_FBConfigs, i;
unsigned int current_DisplayMode = fgState.DisplayMode ;
+ XEvent fakeEvent = {0};
/* Save the display mode if we are creating a menu window */
if( window->IsMenu && ( ! fgStructure.MenuContext ) )
fgState.DisplayMode = GLUT_DOUBLE | GLUT_RGB ;
- window->Window.pContext.FBConfig = fgPlatformChooseFBConfig( &num_FBConfigs );
+#ifdef EGL_VERSION_1_0
+#define WINDOW_CONFIG window->Window.pContext.egl.Config
+#else
+#define WINDOW_CONFIG window->Window.pContext.FBConfig
+#endif
+ fghChooseConfig(&WINDOW_CONFIG);
if( window->IsMenu && ( ! fgStructure.MenuContext ) )
fgState.DisplayMode = current_DisplayMode ;
- if( ! window->Window.pContext.FBConfig )
+ if( ! WINDOW_CONFIG )
{
/*
- * The "fgPlatformChooseFBConfig" returned a null meaning that the visual
+ * The "fghChooseConfig" returned a null meaning that the visual
* context is not available.
* Try a couple of variations to see if they will work.
*/
+#ifndef EGL_VERSION_1_0
if( !( fgState.DisplayMode & GLUT_DOUBLE ) )
{
fgState.DisplayMode |= GLUT_DOUBLE ;
- window->Window.pContext.FBConfig = fgPlatformChooseFBConfig( &num_FBConfigs );
+ fghChooseConfig(&WINDOW_CONFIG);
fgState.DisplayMode &= ~GLUT_DOUBLE;
+
+ if( WINDOW_CONFIG ) goto done_retry;
}
+#endif
if( fgState.DisplayMode & GLUT_MULTISAMPLE )
{
fgState.DisplayMode &= ~GLUT_MULTISAMPLE ;
- window->Window.pContext.FBConfig = fgPlatformChooseFBConfig( &num_FBConfigs );
+ fghChooseConfig(&WINDOW_CONFIG);
fgState.DisplayMode |= GLUT_MULTISAMPLE;
+
+ if( WINDOW_CONFIG ) goto done_retry;
+ }
+
+ if( fgState.DisplayMode & GLUT_SRGB )
+ {
+ fgState.DisplayMode &= ~GLUT_SRGB ;
+ fghChooseConfig(&WINDOW_CONFIG);
+ fgState.DisplayMode |= GLUT_SRGB;
+
+ if( WINDOW_CONFIG ) goto done_retry;
}
}
+done_retry:
- FREEGLUT_INTERNAL_ERROR_EXIT( window->Window.pContext.FBConfig != NULL,
+ FREEGLUT_INTERNAL_ERROR_EXIT( WINDOW_CONFIG != NULL,
"FBConfig with necessary capabilities not found", "fgOpenWindow" );
/* Get the X visual. */
- for (i = 0; i < num_FBConfigs; i++) {
- visualInfo = glXGetVisualFromFBConfig( fgDisplay.pDisplay.Display,
- window->Window.pContext.FBConfig[i] );
- if (visualInfo)
- break;
- }
+#ifdef EGL_VERSION_1_0
+ EGLint vid = 0;
+ XVisualInfo visualTemplate;
+ int num_visuals;
+ if (!eglGetConfigAttrib(fgDisplay.pDisplay.egl.Display, window->Window.pContext.egl.Config, EGL_NATIVE_VISUAL_ID, &vid))
+ fgError("eglGetConfigAttrib(EGL_NATIVE_VISUAL_ID) failed");
+ visualTemplate.visualid = vid;
+ visualInfo = XGetVisualInfo(fgDisplay.pDisplay.Display, VisualIDMask, &visualTemplate, &num_visuals);
+#else
+ visualInfo = glXGetVisualFromFBConfig( fgDisplay.pDisplay.Display,
+ window->Window.pContext.FBConfig );
+#endif
FREEGLUT_INTERNAL_ERROR_EXIT( visualInfo != NULL,
"visualInfo could not be retrieved from FBConfig", "fgOpenWindow" );
&winAttr
);
+ /* Fake configure event to force viewport setup
+ * even with no window manager.
+ */
+ fakeEvent.xconfigure.type = ConfigureNotify;
+ fakeEvent.xconfigure.display = fgDisplay.pDisplay.Display;
+ fakeEvent.xconfigure.window = window->Window.Handle;
+ fakeEvent.xconfigure.x = x;
+ fakeEvent.xconfigure.y = y;
+ fakeEvent.xconfigure.width = w;
+ fakeEvent.xconfigure.height = h;
+ XPutBackEvent(fgDisplay.pDisplay.Display, &fakeEvent);
+
/*
* The GLX context creation, possibly trying the direct context rendering
* or else use the current context if the user has so specified
}
else if( fgState.UseCurrentContext )
{
+
+#ifdef EGL_VERSION_1_0
+ window->Window.Context = eglGetCurrentContext( );
+#else
window->Window.Context = glXGetCurrentContext( );
+#endif
if( ! window->Window.Context )
window->Window.Context = fghCreateNewContext( window );
else
window->Window.Context = fghCreateNewContext( window );
-#if !defined( __FreeBSD__ ) && !defined( __NetBSD__ )
+#if !defined( __FreeBSD__ ) && !defined( __NetBSD__ ) && !defined(EGL_VERSION_1_0)
if( !glXIsDirect( fgDisplay.pDisplay.Display, window->Window.Context ) )
{
if( fgState.DirectContext == GLUT_FORCE_DIRECT_CONTEXT )
}
#endif
- /*
- * XXX Assume the new window is visible by default
- * XXX Is this a safe assumption?
- */
- window->State.Visible = GL_TRUE;
-
sizeHints.flags = 0;
if ( positionUse )
sizeHints.flags |= USPosition;
XSetWMProtocols( fgDisplay.pDisplay.Display, window->Window.Handle,
&fgDisplay.pDisplay.DeleteWindow, 1 );
+ if (!isSubWindow && !window->IsMenu &&
+ ((fgState.DisplayMode & GLUT_BORDERLESS) || (fgState.DisplayMode & GLUT_CAPTIONLESS)))
+ {
+ /* _MOTIF_WM_HINTS is replaced by _NET_WM_WINDOW_TYPE, but that property does not allow precise
+ * control over the visual style of the window, which is what we are trying to achieve here.
+ * Stick with Motif and hope for the best... */
+ MotifWmHints hints = {0};
+ hints.flags = MWM_HINTS_DECORATIONS;
+ hints.decorations = (fgState.DisplayMode & GLUT_CAPTIONLESS) ? MWM_DECOR_BORDER:0;
+
+ XChangeProperty(fgDisplay.pDisplay.Display, window->Window.Handle,
+ XInternAtom( fgDisplay.pDisplay.Display, "_MOTIF_WM_HINTS", False ),
+ XInternAtom( fgDisplay.pDisplay.Display, "_MOTIF_WM_HINTS", False ), 32,
+ PropModeReplace,
+ (unsigned char*) &hints,
+ sizeof(MotifWmHints) / sizeof(long));
+ }
+
+
+ if (fgDisplay.pDisplay.NetWMSupported
+ && fgDisplay.pDisplay.NetWMPid != None
+ && fgDisplay.pDisplay.ClientMachine != None)
+ {
+ char hostname[HOST_NAME_MAX];
+ pid_t pid = getpid();
+
+ if (pid > 0 && gethostname(hostname, sizeof(hostname)) > -1)
+ {
+ hostname[sizeof(hostname) - 1] = '\0';
+
+ XChangeProperty(
+ fgDisplay.pDisplay.Display,
+ window->Window.Handle,
+ fgDisplay.pDisplay.NetWMPid,
+ XA_CARDINAL,
+ 32,
+ PropModeReplace,
+ (unsigned char *) &pid,
+ 1
+ );
+
+ XChangeProperty(
+ fgDisplay.pDisplay.Display,
+ window->Window.Handle,
+ fgDisplay.pDisplay.ClientMachine,
+ XA_STRING,
+ 8,
+ PropModeReplace,
+ (unsigned char *) hostname,
+ strlen(hostname)
+ );
+ }
+ }
+
+#ifdef EGL_VERSION_1_0
+ fghPlatformOpenWindowEGL(window);
+#else
glXMakeContextCurrent(
fgDisplay.pDisplay.Display,
window->Window.Handle,
window->Window.Handle,
window->Window.Context
);
+#endif
/* register extension events _before_ window is mapped */
#ifdef HAVE_X11_EXTENSIONS_XINPUT2_H
fgRegisterDevices( fgDisplay.pDisplay.Display, &(window->Window.Handle) );
#endif
- XMapWindow( fgDisplay.pDisplay.Display, window->Window.Handle );
+ if (!window->IsMenu) /* Don't show window after creation if its a menu */
+ {
+ XMapWindow( fgDisplay.pDisplay.Display, window->Window.Handle );
+ window->State.Visible = GL_TRUE;
+ }
XFree(visualInfo);
- if( !isSubWindow)
+ /* wait till window visible */
+ if( !isSubWindow && !window->IsMenu)
XPeekIfEvent( fgDisplay.pDisplay.Display, &eventReturnBuffer, &fghWindowIsVisible, (XPointer)(window->Window.Handle) );
+#undef WINDOW_CONFIG
+}
+
+
+/*
+ * Request a window resize
+ */
+void fgPlatformReshapeWindow ( SFG_Window *window, int width, int height )
+{
+ XResizeWindow( fgDisplay.pDisplay.Display, window->Window.Handle,
+ width, height );
+ XFlush( fgDisplay.pDisplay.Display ); /* XXX Shouldn't need this */
}
*/
void fgPlatformCloseWindow( SFG_Window* window )
{
+#ifdef EGL_VERSION_1_0
+ fghPlatformCloseWindowEGL(window);
+#else
if( window->Window.Context )
glXDestroyContext( fgDisplay.pDisplay.Display, window->Window.Context );
- XFree( window->Window.pContext.FBConfig );
+ window->Window.pContext.FBConfig = NULL;
+#endif
if( window->Window.Handle ) {
XDestroyWindow( fgDisplay.pDisplay.Display, window->Window.Handle );
/*
- * This function makes the current window visible
+ * This function makes the specified window visible
*/
-void fgPlatformGlutShowWindow( void )
+void fgPlatformShowWindow( SFG_Window *window )
{
- XMapWindow( fgDisplay.pDisplay.Display, fgStructure.CurrentWindow->Window.Handle );
+ XMapWindow( fgDisplay.pDisplay.Display, window->Window.Handle );
XFlush( fgDisplay.pDisplay.Display ); /* XXX Shouldn't need this */
}
/*
- * This function hides the current window
+ * This function hides the specified window
*/
-void fgPlatformGlutHideWindow( void )
+void fgPlatformHideWindow( SFG_Window *window )
{
- if( fgStructure.CurrentWindow->Parent == NULL )
+ if( window->Parent == NULL )
XWithdrawWindow( fgDisplay.pDisplay.Display,
- fgStructure.CurrentWindow->Window.Handle,
+ window->Window.Handle,
fgDisplay.pDisplay.Screen );
else
XUnmapWindow( fgDisplay.pDisplay.Display,
- fgStructure.CurrentWindow->Window.Handle );
+ window->Window.Handle );
XFlush( fgDisplay.pDisplay.Display ); /* XXX Shouldn't need this */
}
/*
- * Iconify the current window (top-level windows only)
+ * Iconify the specified window (top-level windows only)
*/
-void fgPlatformGlutIconifyWindow( void )
+void fgPlatformIconifyWindow( SFG_Window *window )
{
- XIconifyWindow( fgDisplay.pDisplay.Display, fgStructure.CurrentWindow->Window.Handle,
+ XIconifyWindow( fgDisplay.pDisplay.Display, window->Window.Handle,
fgDisplay.pDisplay.Screen );
XFlush( fgDisplay.pDisplay.Display ); /* XXX Shouldn't need this */
+
+ fgStructure.CurrentWindow->State.Visible = GL_FALSE;
}
/*
}
/*
- * Change the current window's position
+ * Change the specified window's position
*/
-void fgPlatformGlutPositionWindow( int x, int y )
+void fgPlatformPositionWindow( SFG_Window *window, int x, int y )
{
- XMoveWindow( fgDisplay.pDisplay.Display, fgStructure.CurrentWindow->Window.Handle,
+ XMoveWindow( fgDisplay.pDisplay.Display, window->Window.Handle,
x, y );
XFlush( fgDisplay.pDisplay.Display ); /* XXX Shouldn't need this */
}
/*
- * Lowers the current window (by Z order change)
- */
-void fgPlatformGlutPushWindow( void )
-{
- XLowerWindow( fgDisplay.pDisplay.Display, fgStructure.CurrentWindow->Window.Handle );
-}
-
-/*
- * Raises the current window (by Z order change)
- */
-void fgPlatformGlutPopWindow( void )
-{
- XRaiseWindow( fgDisplay.pDisplay.Display, fgStructure.CurrentWindow->Window.Handle );
-}
-
-/*
- * Resize the current window so that it fits the whole screen
+ * Lowers the specified window (by Z order change)
*/
-void fgPlatformGlutFullScreen( SFG_Window *win )
+void fgPlatformPushWindow( SFG_Window *window )
{
- if(!glutGet(GLUT_FULL_SCREEN)) {
- if(fghToggleFullscreen() != -1) {
- win->State.IsFullscreen = GL_TRUE;
- }
- }
+ XLowerWindow( fgDisplay.pDisplay.Display, window->Window.Handle );
}
/*
- * If we are fullscreen, resize the current window back to its original size
+ * Raises the specified window (by Z order change)
*/
-void fgPlatformGlutLeaveFullScreen( SFG_Window *win )
+void fgPlatformPopWindow( SFG_Window *window )
{
- if(glutGet(GLUT_FULL_SCREEN)) {
- if(fghToggleFullscreen() != -1) {
- win->State.IsFullscreen = GL_FALSE;
- }
- }
+ XRaiseWindow( fgDisplay.pDisplay.Display, window->Window.Handle );
}
/*
* Toggle the window's full screen state.
*/
-void fgPlatformGlutFullScreenToggle( SFG_Window *win )
+void fgPlatformFullScreenToggle( SFG_Window *win )
{
if(fghToggleFullscreen() != -1) {
win->State.IsFullscreen = !win->State.IsFullscreen;
projects / freeglut / blobdiff