#include <GL/freeglut.h>\r
#include "freeglut_internal.h"\r
\r
-#if TARGET_HOST_POSIX_X11\r
-#include <limits.h> /* LONG_MAX */\r
-#include <unistd.h> /* usleep */\r
-#endif\r
-\r
#if defined(_WIN32_WCE)\r
# include <Aygshell.h>\r
# ifdef FREEGLUT_LIB_PRAGMAS\r
#endif /* defined(_WIN32_WCE) */\r
\r
\r
-#if TARGET_HOST_POSIX_X11\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
-#endif /* TARGET_HOST_POSIX_X11 */\r
-\r
-\r
-#ifdef WM_TOUCH\r
- typedef BOOL (WINAPI *pRegisterTouchWindow)(HWND,ULONG);\r
- static pRegisterTouchWindow fghRegisterTouchWindow = (pRegisterTouchWindow)0xDEADBEEF;\r
-#endif\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
* TODO BEFORE THE STABLE RELEASE:\r
*\r
- * fgChooseFBConfig() -- OK, but what about glutInitDisplayString()?\r
* fgSetupPixelFormat -- ignores the display mode settings\r
* fgOpenWindow() -- check the Win32 version, -iconic handling!\r
* fgCloseWindow() -- check the Win32 version\r
GLboolean sizeUse, int w, int h,\r
GLboolean gameMode, GLboolean isSubWindow );\r
extern void fgPlatformCloseWindow( SFG_Window* window );\r
+extern void fgPlatformGlutShowWindow( void );\r
+extern void fgPlatformGlutHideWindow( void );\r
+extern void fgPlatformGlutIconifyWindow( void );\r
+extern void fgPlatformGlutSetWindowTitle( const char* title );\r
+extern void fgPlatformGlutSetIconTitle( const char* title );\r
+extern void fgPlatformGlutPositionWindow( int x, int y );\r
+extern void fgPlatformGlutPushWindow( void );\r
+extern void fgPlatformGlutPopWindow( void );\r
+extern void fgPlatformGlutFullScreen( SFG_Window *win );\r
+extern void fgPlatformGlutLeaveFullScreen( SFG_Window *win );\r
+extern void fgPlatformGlutFullScreenToggle( SFG_Window *win );\r
+\r
\r
/* -- PRIVATE FUNCTIONS ---------------------------------------------------- */\r
\r
\r
/* -- SYSTEM-DEPENDENT PRIVATE FUNCTIONS ------------------------------------ */\r
\r
-#if TARGET_HOST_POSIX_X11\r
-/*\r
- * Chooses a visual basing on the current display mode settings\r
- */\r
-\r
-GLXFBConfig* fgChooseFBConfig( 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.Display,\r
- fgDisplay.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.Display,\r
- fbconfigArray[0],\r
- GLX_BUFFER_SIZE,\r
- &bufferSizeMin );\r
- /* Get bufferSizeMax. */\r
- result =\r
- glXGetFBConfigAttrib( fgDisplay.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.Display,\r
- fgDisplay.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.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.Display,\r
- * fgDisplay.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.Display;\r
- GLXFBConfig config = *(window->Window.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.OldWidth;\r
- fgStructure.CurrentWindow->State.Height = win->State.OldHeight;\r
-\r
- } else {\r
- /* resize the window to cover the entire screen */\r
- XGetWindowAttributes(fgDisplay.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.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.State || !fgDisplay.StateFullScreen) {\r
- return -1;\r
- }\r
-\r
- xev.type = ClientMessage;\r
- xev.xclient.window = fgStructure.CurrentWindow->Window.Handle;\r
- xev.xclient.message_type = fgDisplay.State;\r
- xev.xclient.format = 32;\r
- xev.xclient.data.l[0] = _NET_WM_STATE_TOGGLE;\r
- xev.xclient.data.l[1] = fgDisplay.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.Display, fgDisplay.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.Display,\r
- window->Window.Handle,\r
- window->Window.Handle,\r
- window->Window.Context\r
- );\r
- }\r
-}\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.FBConfig = fgChooseFBConfig( &num_FBConfigs );\r
-\r
- if( window->IsMenu && ( ! fgStructure.MenuContext ) )\r
- fgState.DisplayMode = current_DisplayMode ;\r
-\r
- if( ! window->Window.FBConfig )\r
- {\r
- /*\r
- * The "fgChooseFBConfig" 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.FBConfig = fgChooseFBConfig( &num_FBConfigs );\r
- fgState.DisplayMode &= ~GLUT_DOUBLE;\r
- }\r
-\r
- if( fgState.DisplayMode & GLUT_MULTISAMPLE )\r
- {\r
- fgState.DisplayMode &= ~GLUT_MULTISAMPLE ;\r
- window->Window.FBConfig = fgChooseFBConfig( &num_FBConfigs );\r
- fgState.DisplayMode |= GLUT_MULTISAMPLE;\r
- }\r
- }\r
-\r
- FREEGLUT_INTERNAL_ERROR_EXIT( window->Window.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.Display,\r
- window->Window.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.Display, fgDisplay.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.Display,\r
- window->Parent == NULL ? fgDisplay.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.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.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.Display, window->Window.Handle,\r
- &fgDisplay.DeleteWindow, 1 );\r
-\r
- glXMakeContextCurrent(\r
- fgDisplay.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.Display, &(window->Window.Handle) );\r
- #endif\r
-\r
- XMapWindow( fgDisplay.Display, window->Window.Handle );\r
-\r
- XFree(visualInfo);\r
-\r
- if( !isSubWindow)\r
- XPeekIfEvent( fgDisplay.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.Display, window->Window.Context );\r
- XFree( window->Window.FBConfig );\r
-\r
- if( window->Window.Handle ) {\r
- XDestroyWindow( fgDisplay.Display, window->Window.Handle );\r
- }\r
- /* XFlush( fgDisplay.Display ); */ /* XXX Shouldn't need this */\r
-}\r
-\r
-#endif /* TARGET_HOST_POSIX_X11 */\r
-\r
-\r
/*\r
* Sets the OpenGL context and the fgStructure "Current Window" pointer to\r
* the window structure passed in.\r
fgStructure.CurrentWindow = window;\r
}\r
\r
-\r
-#if TARGET_HOST_POSIX_X11\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
-#endif\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
GL_FALSE, GL_FALSE )->ID;\r
}\r
\r
-#if TARGET_HOST_MS_WINDOWS\r
-int FGAPIENTRY __glutCreateWindowWithExit( const char *title, void (__cdecl *exit_function)(int) )\r
-{\r
- __glutExitFunc = exit_function;\r
- return glutCreateWindow( title );\r
-}\r
-#endif\r
-\r
/*\r
* This function creates a sub window.\r
*/\r
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutShowWindow" );\r
FREEGLUT_EXIT_IF_NO_WINDOW ( "glutShowWindow" );\r
\r
-#if TARGET_HOST_POSIX_X11\r
-\r
- XMapWindow( fgDisplay.Display, fgStructure.CurrentWindow->Window.Handle );\r
- XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */\r
-\r
-#elif TARGET_HOST_MS_WINDOWS\r
-\r
- ShowWindow( fgStructure.CurrentWindow->Window.Handle, SW_SHOW );\r
-\r
-#endif\r
+ fgPlatformGlutShowWindow ();\r
\r
fgStructure.CurrentWindow->State.Redisplay = GL_TRUE;\r
}\r
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutHideWindow" );\r
FREEGLUT_EXIT_IF_NO_WINDOW ( "glutHideWindow" );\r
\r
-#if TARGET_HOST_POSIX_X11\r
-\r
- if( fgStructure.CurrentWindow->Parent == NULL )\r
- XWithdrawWindow( fgDisplay.Display,\r
- fgStructure.CurrentWindow->Window.Handle,\r
- fgDisplay.Screen );\r
- else\r
- XUnmapWindow( fgDisplay.Display,\r
- fgStructure.CurrentWindow->Window.Handle );\r
- XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */\r
-\r
-#elif TARGET_HOST_MS_WINDOWS\r
-\r
- ShowWindow( fgStructure.CurrentWindow->Window.Handle, SW_HIDE );\r
-\r
-#endif\r
+ fgPlatformGlutHideWindow ();\r
\r
fgStructure.CurrentWindow->State.Redisplay = GL_FALSE;\r
}\r
FREEGLUT_EXIT_IF_NO_WINDOW ( "glutIconifyWindow" );\r
\r
fgStructure.CurrentWindow->State.Visible = GL_FALSE;\r
-#if TARGET_HOST_POSIX_X11\r
-\r
- XIconifyWindow( fgDisplay.Display, fgStructure.CurrentWindow->Window.Handle,\r
- fgDisplay.Screen );\r
- XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */\r
\r
-#elif TARGET_HOST_MS_WINDOWS\r
-\r
- ShowWindow( fgStructure.CurrentWindow->Window.Handle, SW_MINIMIZE );\r
-\r
-#endif\r
+ fgPlatformGlutIconifyWindow ();\r
\r
fgStructure.CurrentWindow->State.Redisplay = GL_FALSE;\r
}\r
FREEGLUT_EXIT_IF_NO_WINDOW ( "glutSetWindowTitle" );\r
if( ! fgStructure.CurrentWindow->Parent )\r
{\r
-#if TARGET_HOST_POSIX_X11\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.Display,\r
- fgStructure.CurrentWindow->Window.Handle,\r
- &text\r
- );\r
-\r
- XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */\r
-\r
-#elif TARGET_HOST_MS_WINDOWS\r
-# ifdef _WIN32_WCE\r
- {\r
- wchar_t* wstr = fghWstrFromStr(title);\r
- SetWindowText( fgStructure.CurrentWindow->Window.Handle, wstr );\r
- free(wstr);\r
- }\r
-# else\r
- SetWindowText( fgStructure.CurrentWindow->Window.Handle, title );\r
-# endif\r
-\r
-#endif\r
+ fgPlatformGlutSetWindowTitle ( title );\r
}\r
}\r
\r
\r
if( ! fgStructure.CurrentWindow->Parent )\r
{\r
-#if TARGET_HOST_POSIX_X11\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.Display,\r
- fgStructure.CurrentWindow->Window.Handle,\r
- &text\r
- );\r
-\r
- XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */\r
-\r
-#elif TARGET_HOST_MS_WINDOWS\r
-# ifdef _WIN32_WCE\r
- {\r
- wchar_t* wstr = fghWstrFromStr(title);\r
- SetWindowText( fgStructure.CurrentWindow->Window.Handle, wstr );\r
- free(wstr);\r
- }\r
-# else\r
- SetWindowText( fgStructure.CurrentWindow->Window.Handle, title );\r
-# endif\r
-\r
-#endif\r
+ fgPlatformGlutSetIconTitle ( title );\r
}\r
}\r
\r
glutLeaveFullScreen();\r
}\r
\r
-#if TARGET_HOST_POSIX_X11\r
-\r
- XMoveWindow( fgDisplay.Display, fgStructure.CurrentWindow->Window.Handle,\r
- x, y );\r
- XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */\r
-\r
-#elif TARGET_HOST_MS_WINDOWS\r
-\r
- {\r
- RECT winRect;\r
-\r
- /* "GetWindowRect" returns the pixel coordinates of the outside of the window */\r
- GetWindowRect( fgStructure.CurrentWindow->Window.Handle, &winRect );\r
- MoveWindow(\r
- fgStructure.CurrentWindow->Window.Handle,\r
- x,\r
- y,\r
- winRect.right - winRect.left,\r
- winRect.bottom - winRect.top,\r
- TRUE\r
- );\r
- }\r
-\r
-#endif\r
+ fgPlatformGlutPositionWindow ( x, y );\r
}\r
\r
/*\r
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutPushWindow" );\r
FREEGLUT_EXIT_IF_NO_WINDOW ( "glutPushWindow" );\r
\r
-#if TARGET_HOST_POSIX_X11\r
-\r
- XLowerWindow( fgDisplay.Display, fgStructure.CurrentWindow->Window.Handle );\r
-\r
-#elif TARGET_HOST_MS_WINDOWS\r
-\r
- SetWindowPos(\r
- fgStructure.CurrentWindow->Window.Handle,\r
- HWND_BOTTOM,\r
- 0, 0, 0, 0,\r
- SWP_NOSIZE | SWP_NOMOVE\r
- );\r
-\r
-#endif\r
+ fgPlatformGlutPushWindow ();\r
}\r
\r
/*\r
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutPopWindow" );\r
FREEGLUT_EXIT_IF_NO_WINDOW ( "glutPopWindow" );\r
\r
-#if TARGET_HOST_POSIX_X11\r
-\r
- XRaiseWindow( fgDisplay.Display, fgStructure.CurrentWindow->Window.Handle );\r
-\r
-#elif TARGET_HOST_MS_WINDOWS\r
-\r
- SetWindowPos(\r
- fgStructure.CurrentWindow->Window.Handle,\r
- HWND_TOP,\r
- 0, 0, 0, 0,\r
- SWP_NOSIZE | SWP_NOMOVE\r
- );\r
-\r
-#endif\r
+ fgPlatformGlutPopWindow ();\r
}\r
\r
/*\r
return;\r
}\r
\r
-#if TARGET_HOST_POSIX_X11\r
- if(!glutGet(GLUT_FULL_SCREEN)) {\r
- if(fghToggleFullscreen() != -1) {\r
- win->State.IsFullscreen = GL_TRUE;\r
- }\r
- }\r
-\r
-#elif TARGET_HOST_MS_WINDOWS && !defined(_WIN32_WCE) /* FIXME: what about WinCE */\r
-\r
- if (glutGet(GLUT_FULL_SCREEN))\r
- {\r
- /* Leave full screen state before entering fullscreen again (resizing?) */\r
- glutLeaveFullScreen();\r
- }\r
-\r
- {\r
-#if(WINVER >= 0x0500) /* Windows 2000 or later */\r
- DWORD s;\r
- RECT rect;\r
- HMONITOR hMonitor;\r
- MONITORINFO mi;\r
-\r
- /* For fullscreen mode, first remove all window decoration\r
- * and set style to popup so it will overlap the taskbar\r
- * then force to maximize on the screen on which it has the most\r
- * overlap.\r
- */\r
-\r
- \r
- /* store current window rect */\r
- GetWindowRect( win->Window.Handle, &win->State.OldRect );\r
-\r
- /* store current window style */\r
- win->State.OldStyle = s = GetWindowLong(win->Window.Handle, GWL_STYLE);\r
-\r
- /* remove decorations from style and add popup style*/\r
- s &= ~WS_OVERLAPPEDWINDOW;\r
- s |= WS_POPUP;\r
- SetWindowLong(win->Window.Handle, GWL_STYLE, s);\r
- SetWindowPos(win->Window.Handle, HWND_TOP, 0,0,0,0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);\r
-\r
- /* For fullscreen mode, find the monitor that is covered the most\r
- * by the window and get its rect as the resize target.\r
- */\r
- hMonitor= MonitorFromRect(&win->State.OldRect, MONITOR_DEFAULTTONEAREST);\r
- mi.cbSize = sizeof(mi);\r
- GetMonitorInfo(hMonitor, &mi);\r
- rect = mi.rcMonitor;\r
-#else /* if (WINVER >= 0x0500) */\r
- RECT rect;\r
-\r
- /* For fullscreen mode, force the top-left corner to 0,0\r
- * and adjust the window rectangle so that the client area\r
- * covers the whole screen.\r
- */\r
-\r
- rect.left = 0;\r
- rect.top = 0;\r
- rect.right = fgDisplay.ScreenWidth;\r
- rect.bottom = fgDisplay.ScreenHeight;\r
-\r
- AdjustWindowRect ( &rect, WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS |\r
- WS_CLIPCHILDREN, FALSE );\r
-#endif /* (WINVER >= 0x0500) */\r
-\r
- /*\r
- * then resize window\r
- * SWP_NOACTIVATE Do not activate the window\r
- * SWP_NOOWNERZORDER Do not change position in z-order\r
- * SWP_NOSENDCHANGING Suppress WM_WINDOWPOSCHANGING message\r
- * SWP_NOZORDER Retains the current Z order (ignore 2nd param)\r
- */\r
- SetWindowPos( fgStructure.CurrentWindow->Window.Handle,\r
- HWND_TOP,\r
- rect.left,\r
- rect.top,\r
- rect.right - rect.left,\r
- rect.bottom - rect.top,\r
- SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOSENDCHANGING |\r
- SWP_NOZORDER\r
- );\r
-\r
- win->State.IsFullscreen = GL_TRUE;\r
- }\r
-#endif\r
+ fgPlatformGlutFullScreen ( win );\r
}\r
\r
/*\r
\r
win = fgStructure.CurrentWindow;\r
\r
-#if TARGET_HOST_POSIX_X11\r
- if(glutGet(GLUT_FULL_SCREEN)) {\r
- if(fghToggleFullscreen() != -1) {\r
- win->State.IsFullscreen = GL_FALSE;\r
- }\r
- }\r
-\r
-#elif TARGET_HOST_MS_WINDOWS && !defined(_WIN32_WCE) /* FIXME: what about WinCE */\r
- if (!glutGet(GLUT_FULL_SCREEN))\r
- {\r
- /* nothing to do */\r
- return;\r
- }\r
-\r
- /* restore style of window before making it fullscreen */\r
- SetWindowLong(win->Window.Handle, GWL_STYLE, win->State.OldStyle);\r
- SetWindowPos(win->Window.Handle, HWND_TOP, 0,0,0,0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);\r
-\r
- /* Then resize */\r
- SetWindowPos(win->Window.Handle,\r
- HWND_TOP,\r
- win->State.OldRect.left,\r
- win->State.OldRect.top,\r
- win->State.OldRect.right - win->State.OldRect.left,\r
- win->State.OldRect.bottom - win->State.OldRect.top,\r
- SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOSENDCHANGING |\r
- SWP_NOZORDER\r
- );\r
-\r
- win->State.IsFullscreen = GL_FALSE;\r
-#endif\r
+ fgPlatformGlutLeaveFullScreen ( win );\r
}\r
\r
/*\r
\r
win = fgStructure.CurrentWindow;\r
\r
-#if TARGET_HOST_POSIX_X11\r
- if(fghToggleFullscreen() != -1) {\r
- win->State.IsFullscreen = !win->State.IsFullscreen;\r
- }\r
-#elif TARGET_HOST_MS_WINDOWS\r
- if (!win->State.IsFullscreen)\r
- glutFullScreen();\r
- else\r
- glutLeaveFullScreen();\r
-#endif\r
+ fgPlatformGlutFullScreenToggle ( win );\r
}\r
\r
/*\r
projects / freeglut / blobdiff