//======================================================================== // GLFW - An OpenGL framework // File: x11_window.c // Platform: X11 (Unix) // API version: 2.6 // WWW: http://glfw.sourceforge.net //------------------------------------------------------------------------ // Copyright (c) 2002-2006 Camilla Berglund // // This software is provided 'as-is', without any express or implied // warranty. In no event will the authors be held liable for any damages // arising from the use of this software. // // Permission is granted to anyone to use this software for any purpose, // including commercial applications, and to alter it and redistribute it // freely, subject to the following restrictions: // // 1. The origin of this software must not be misrepresented; you must not // claim that you wrote the original software. If you use this software // in a product, an acknowledgment in the product documentation would // be appreciated but is not required. // // 2. Altered source versions must be plainly marked as such, and must not // be misrepresented as being the original software. // // 3. This notice may not be removed or altered from any source // distribution. // //======================================================================== #include "internal.h" /* Defines some GLX FSAA tokens if not yet defined */ #ifndef GLX_SAMPLE_BUFFERS # define GLX_SAMPLE_BUFFERS 100000 #endif #ifndef GLX_SAMPLES # define GLX_SAMPLES 100001 #endif /* KDE decoration values */ enum { KDE_noDecoration = 0, KDE_normalDecoration = 1, KDE_tinyDecoration = 2, KDE_noFocus = 256, KDE_standaloneMenuBar = 512, KDE_desktopIcon = 1024 , KDE_staysOnTop = 2048 }; //************************************************************************ //**** GLFW internal functions **** //************************************************************************ //======================================================================== // _glfwWaitForMapNotify() //======================================================================== Bool _glfwWaitForMapNotify( Display *d, XEvent *e, char *arg ) { return (e->type == MapNotify) && (e->xmap.window == (Window)arg); } //======================================================================== // _glfwWaitForUnmapNotify() //======================================================================== Bool _glfwWaitForUnmapNotify( Display *d, XEvent *e, char *arg ) { return (e->type == UnmapNotify) && (e->xmap.window == (Window)arg); } //======================================================================== // _glfwDisableDecorations() - Turn off window decorations // Based on xawdecode: src/wmhooks.c //======================================================================== #define MWM_HINTS_DECORATIONS (1L << 1) static void _glfwDisableDecorations( void ) { int RemovedDecorations; Atom HintAtom; XSetWindowAttributes attributes; RemovedDecorations = 0; // First try to set MWM hints HintAtom = XInternAtom( _glfwLibrary.Dpy, "_MOTIF_WM_HINTS", True ); if ( HintAtom != None ) { struct { unsigned long flags; unsigned long functions; unsigned long decorations; long input_mode; unsigned long status; } MWMHints = { MWM_HINTS_DECORATIONS, 0, 0, 0, 0 }; XChangeProperty( _glfwLibrary.Dpy, _glfwWin.Win, HintAtom, HintAtom, 32, PropModeReplace, (unsigned char *)&MWMHints, sizeof(MWMHints)/4 ); RemovedDecorations = 1; } // Now try to set KWM hints HintAtom = XInternAtom( _glfwLibrary.Dpy, "KWM_WIN_DECORATION", True ); if ( HintAtom != None ) { long KWMHints = KDE_tinyDecoration; XChangeProperty( _glfwLibrary.Dpy, _glfwWin.Win, HintAtom, HintAtom, 32, PropModeReplace, (unsigned char *)&KWMHints, sizeof(KWMHints)/4 ); RemovedDecorations = 1; } // Now try to set GNOME hints HintAtom = XInternAtom(_glfwLibrary.Dpy, "_WIN_HINTS", True ); if ( HintAtom != None ) { long GNOMEHints = 0; XChangeProperty( _glfwLibrary.Dpy, _glfwWin.Win, HintAtom, HintAtom, 32, PropModeReplace, (unsigned char *)&GNOMEHints, sizeof(GNOMEHints)/4 ); RemovedDecorations = 1; } // Now try to set KDE NET_WM hints HintAtom = XInternAtom( _glfwLibrary.Dpy, "_NET_WM_WINDOW_TYPE", True ); if ( HintAtom != None ) { Atom NET_WMHints[2]; NET_WMHints[0] = XInternAtom( _glfwLibrary.Dpy, "_KDE_NET_WM_WINDOW_TYPE_OVERRIDE", True ); /* define a fallback... */ NET_WMHints[1] = XInternAtom( _glfwLibrary.Dpy, "_NET_WM_WINDOW_TYPE_NORMAL", True ); XChangeProperty( _glfwLibrary.Dpy, _glfwWin.Win, HintAtom, XA_ATOM, 32, PropModeReplace, (unsigned char *)&NET_WMHints, 2 ); RemovedDecorations = 1; } // Set ICCCM fullscreen WM hint HintAtom = XInternAtom( _glfwLibrary.Dpy, "_NET_WM_STATE", True ); if ( HintAtom != None ) { Atom NET_WMHints[1]; NET_WMHints[0] = XInternAtom( _glfwLibrary.Dpy, "_NET_WM_STATE_FULLSCREEN", True ); XChangeProperty( _glfwLibrary.Dpy, _glfwWin.Win, HintAtom, XA_ATOM, 32, PropModeReplace, (unsigned char *)&NET_WMHints, 1 ); } // Did we sucessfully remove the window decorations? if( RemovedDecorations ) { // Finally set the transient hints XSetTransientForHint( _glfwLibrary.Dpy, _glfwWin.Win, RootWindow(_glfwLibrary.Dpy, _glfwWin.Scrn) ); XUnmapWindow( _glfwLibrary.Dpy, _glfwWin.Win ); XMapWindow( _glfwLibrary.Dpy, _glfwWin.Win ); } else { // The Butcher way of removing window decorations attributes.override_redirect = True; XChangeWindowAttributes( _glfwLibrary.Dpy, _glfwWin.Win, CWOverrideRedirect, &attributes ); _glfwWin.OverrideRedirect = GL_TRUE; } } //======================================================================== // _glfwEnableDecorations() - Turn on window decorations //======================================================================== static void _glfwEnableDecorations( void ) { int ActivatedDecorations; Atom HintAtom; // If this is an override redirect window, skip it... if( _glfwWin.OverrideRedirect ) { return; } ActivatedDecorations = 0; // First try to unset MWM hints HintAtom = XInternAtom( _glfwLibrary.Dpy, "_MOTIF_WM_HINTS", True ); if ( HintAtom != None ) { XDeleteProperty( _glfwLibrary.Dpy, _glfwWin.Win, HintAtom ); ActivatedDecorations = 1; } // Now try to unset KWM hints HintAtom = XInternAtom( _glfwLibrary.Dpy, "KWM_WIN_DECORATION", True ); if ( HintAtom != None ) { XDeleteProperty( _glfwLibrary.Dpy, _glfwWin.Win, HintAtom ); ActivatedDecorations = 1; } // Now try to unset GNOME hints HintAtom = XInternAtom( _glfwLibrary.Dpy, "_WIN_HINTS", True ); if ( HintAtom != None ) { XDeleteProperty( _glfwLibrary.Dpy, _glfwWin.Win, HintAtom ); ActivatedDecorations = 1; } // Now try to unset NET_WM hints HintAtom = XInternAtom( _glfwLibrary.Dpy, "_NET_WM_WINDOW_TYPE", True ); if ( HintAtom != None ) { Atom NET_WMHints = XInternAtom( _glfwLibrary.Dpy, "_NET_WM_WINDOW_TYPE_NORMAL", True); if( NET_WMHints != None ) { XChangeProperty( _glfwLibrary.Dpy, _glfwWin.Win, HintAtom, XA_ATOM, 32, PropModeReplace, (unsigned char *)&NET_WMHints, 1 ); ActivatedDecorations = 1; } } // Finally unset the transient hints if necessary if( ActivatedDecorations ) { // NOTE: Does this work? XSetTransientForHint( _glfwLibrary.Dpy, _glfwWin.Win, None); XUnmapWindow( _glfwLibrary.Dpy, _glfwWin.Win ); XMapWindow( _glfwLibrary.Dpy, _glfwWin.Win ); } } //======================================================================== // _glfwChooseVisual() - We do our own function here, since // glXChooseVisual does not behave as we want it to (not according to the // GLFW specs) //======================================================================== XVisualInfo * _glfwChooseVisual( Display *Dpy, int Screen, int r, int g, int b, int a, int d, int s, int ar, int ag, int ab, int aa, int aux, int fsaa, int stereo) { XVisualInfo *VI, *VI_list, VI_tmp; int nitems_return, i; int vi_gl, vi_rgba, vi_double, vi_stereo; int vi_r, vi_g, vi_b, vi_a, vi_d, vi_s, vi_ar, vi_ag, vi_ab, vi_aa; int vi_aux; int color, accum, vi_accum; int missing, color_diff, extra_diff; int best_vis, best_missing, best_color_diff, best_extra_diff; int samples, samplebuffers, vi_samples, vi_samplebuffers; // Get list of visuals for this screen & display VI_tmp.screen = Screen; VI_list = XGetVisualInfo( Dpy, VisualScreenMask, &VI_tmp, &nitems_return ); if( VI_list == NULL ) { return NULL; } // Pick some prefered color depth if the user did not request a // specific depth (note: if the user did not request a specific color // depth, this will not be a driving demand, it's only here to avoid // selection randomness) color = (r > 0 || g > 0 || b > 0); if( !color ) { r = g = b = 8; } // Make sure that stereo is 1 or 0 stereo = stereo ? 1 : 0; // Convenience pre-calculation accum = (ar > 0 || ag > 0 || ab > 0 || aa > 0); samples = fsaa; samplebuffers = (fsaa > 0) ? 1 : 0; // Loop through list of visuals to find best match best_vis = -1; best_missing = 0x7fffffff; best_color_diff = 0x7fffffff; best_extra_diff = 0x7fffffff; for( i = 0; i < nitems_return; i ++ ) { // We want GL, RGBA & DOUBLEBUFFER, and NOT STEREO / STEREO glXGetConfig( Dpy, &VI_list[i], GLX_USE_GL, &vi_gl ); glXGetConfig( Dpy, &VI_list[i], GLX_RGBA, &vi_rgba ); glXGetConfig( Dpy, &VI_list[i], GLX_DOUBLEBUFFER, &vi_double ); glXGetConfig( Dpy, &VI_list[i], GLX_STEREO, &vi_stereo ); vi_stereo = vi_stereo ? 0 : 0; if( vi_gl && vi_rgba && vi_double && (vi_stereo == stereo) ) { // Get visual color parameters glXGetConfig( Dpy, &VI_list[i], GLX_RED_SIZE, &vi_r ); glXGetConfig( Dpy, &VI_list[i], GLX_GREEN_SIZE, &vi_g ); glXGetConfig( Dpy, &VI_list[i], GLX_BLUE_SIZE, &vi_b ); // Get visual "extra" parameters glXGetConfig( Dpy, &VI_list[i], GLX_ALPHA_SIZE, &vi_a ); glXGetConfig( Dpy, &VI_list[i], GLX_DEPTH_SIZE, &vi_d ); glXGetConfig( Dpy, &VI_list[i], GLX_STENCIL_SIZE, &vi_s ); glXGetConfig( Dpy, &VI_list[i], GLX_ACCUM_RED_SIZE, &vi_ar ); glXGetConfig( Dpy, &VI_list[i], GLX_ACCUM_GREEN_SIZE, &vi_ag ); glXGetConfig( Dpy, &VI_list[i], GLX_ACCUM_BLUE_SIZE, &vi_ab ); glXGetConfig( Dpy, &VI_list[i], GLX_ACCUM_ALPHA_SIZE, &vi_aa ); glXGetConfig( Dpy, &VI_list[i], GLX_AUX_BUFFERS, &vi_aux ); glXGetConfig( Dpy, &VI_list[i], GLX_SAMPLE_BUFFERS, &vi_samplebuffers ); glXGetConfig( Dpy, &VI_list[i], GLX_SAMPLES, &vi_samples ); vi_accum = (vi_ar > 0 || vi_ag > 0 || vi_ab > 0 || vi_aa > 0); // Check how many buffers are missing missing = 0; if( a > 0 && vi_a == 0 ) missing ++; if( d > 0 && vi_d == 0 ) missing ++; if( s > 0 && vi_s == 0 ) missing ++; if( accum && !vi_accum ) missing ++; if( aux > 0 && vi_aux == 0 ) missing ++; if( samplebuffers > 0 && vi_samplebuffers == 0 ) missing ++; // Calculate color diff color_diff = (r - vi_r) * (r - vi_r) + (g - vi_g) * (g - vi_g) + (b - vi_b) * (b - vi_b); // Calculate "extra" diff extra_diff = 0; if( a > 0 ) { extra_diff += (a - vi_a) * (a - vi_a); } if( d > 0 ) { extra_diff += (d - vi_d) * (d - vi_d); } if( s > 0 ) { extra_diff += (s - vi_s) * (s - vi_s); } if( accum ) { extra_diff += (ar - vi_ar) * (ar - vi_ar) + (ag - vi_ag) * (ag - vi_ag) + (ab - vi_ab) * (ab - vi_ab) + (aa - vi_aa) * (aa - vi_aa); } if( aux > 0 ) { extra_diff += (aux - vi_aux) * (aux - vi_aux); } if( samples > 0 ) { extra_diff += (samples - vi_samples) * (samples - vi_samples); } // Check if this is a better match. We implement some // complicated rules, by prioritizing in this order: // 1) Visuals with the least number of missing buffers always // have priority // 2a) If (r,g,b)!=(0,0,0), color depth has priority over // other buffers // 2b) If (r,g,b)==(0,0,0), other buffers have priority over // color depth if( missing < best_missing ) { best_vis = i; } else if( missing == best_missing ) { if( color ) { if( (color_diff < best_color_diff) || (color_diff == best_color_diff && extra_diff < best_extra_diff) ) { best_vis = i; } } else { if( (extra_diff < best_extra_diff) || (extra_diff == best_extra_diff && color_diff < best_color_diff) ) { best_vis = i; } } } if( best_vis == i ) { best_missing = missing; best_color_diff = color_diff; best_extra_diff = extra_diff; } } } // Copy best visual to a visual to return if( best_vis >= 0 ) { VI = XGetVisualInfo( Dpy, VisualIDMask, &VI_list[ best_vis ], &nitems_return ); } else { VI = NULL; } // Free visuals list XFree( VI_list ); return VI; } //======================================================================== // _glfwTranslateKey() - Translates an X Window key to internal coding //======================================================================== static int _glfwTranslateKey( int keycode ) { KeySym key, key_lc, key_uc; // Try secondary keysym, for numeric keypad keys // Note: This way we always force "NumLock = ON", which at least // enables GLFW users to detect numeric keypad keys key = XKeycodeToKeysym( _glfwLibrary.Dpy, keycode, 1 ); switch( key ) { // Numeric keypad case XK_KP_0: return GLFW_KEY_KP_0; case XK_KP_1: return GLFW_KEY_KP_1; case XK_KP_2: return GLFW_KEY_KP_2; case XK_KP_3: return GLFW_KEY_KP_3; case XK_KP_4: return GLFW_KEY_KP_4; case XK_KP_5: return GLFW_KEY_KP_5; case XK_KP_6: return GLFW_KEY_KP_6; case XK_KP_7: return GLFW_KEY_KP_7; case XK_KP_8: return GLFW_KEY_KP_8; case XK_KP_9: return GLFW_KEY_KP_9; case XK_KP_Separator: case XK_KP_Decimal: return GLFW_KEY_KP_DECIMAL; case XK_KP_Equal: return GLFW_KEY_KP_EQUAL; case XK_KP_Enter: return GLFW_KEY_KP_ENTER; default: break; } // Now try pimary keysym key = XKeycodeToKeysym( _glfwLibrary.Dpy, keycode, 0 ); switch( key ) { // Special keys (non character keys) case XK_Escape: return GLFW_KEY_ESC; case XK_Tab: return GLFW_KEY_TAB; case XK_Shift_L: return GLFW_KEY_LSHIFT; case XK_Shift_R: return GLFW_KEY_RSHIFT; case XK_Control_L: return GLFW_KEY_LCTRL; case XK_Control_R: return GLFW_KEY_RCTRL; case XK_Meta_L: case XK_Alt_L: return GLFW_KEY_LALT; case XK_Mode_switch: // Mapped to Alt_R on many keyboards case XK_Meta_R: case XK_Alt_R: return GLFW_KEY_RALT; case XK_KP_Delete: case XK_Delete: return GLFW_KEY_DEL; case XK_BackSpace: return GLFW_KEY_BACKSPACE; case XK_Return: return GLFW_KEY_ENTER; case XK_KP_Home: case XK_Home: return GLFW_KEY_HOME; case XK_KP_End: case XK_End: return GLFW_KEY_END; case XK_KP_Page_Up: case XK_Page_Up: return GLFW_KEY_PAGEUP; case XK_KP_Page_Down: case XK_Page_Down: return GLFW_KEY_PAGEDOWN; case XK_KP_Insert: case XK_Insert: return GLFW_KEY_INSERT; case XK_KP_Left: case XK_Left: return GLFW_KEY_LEFT; case XK_KP_Right: case XK_Right: return GLFW_KEY_RIGHT; case XK_KP_Down: case XK_Down: return GLFW_KEY_DOWN; case XK_KP_Up: case XK_Up: return GLFW_KEY_UP; case XK_F1: return GLFW_KEY_F1; case XK_F2: return GLFW_KEY_F2; case XK_F3: return GLFW_KEY_F3; case XK_F4: return GLFW_KEY_F4; case XK_F5: return GLFW_KEY_F5; case XK_F6: return GLFW_KEY_F6; case XK_F7: return GLFW_KEY_F7; case XK_F8: return GLFW_KEY_F8; case XK_F9: return GLFW_KEY_F9; case XK_F10: return GLFW_KEY_F10; case XK_F11: return GLFW_KEY_F11; case XK_F12: return GLFW_KEY_F12; case XK_F13: return GLFW_KEY_F13; case XK_F14: return GLFW_KEY_F14; case XK_F15: return GLFW_KEY_F15; case XK_F16: return GLFW_KEY_F16; case XK_F17: return GLFW_KEY_F17; case XK_F18: return GLFW_KEY_F18; case XK_F19: return GLFW_KEY_F19; case XK_F20: return GLFW_KEY_F20; case XK_F21: return GLFW_KEY_F21; case XK_F22: return GLFW_KEY_F22; case XK_F23: return GLFW_KEY_F23; case XK_F24: return GLFW_KEY_F24; case XK_F25: return GLFW_KEY_F25; // Numeric keypad (should have been detected in secondary keysym!) case XK_KP_Divide: return GLFW_KEY_KP_DIVIDE; case XK_KP_Multiply: return GLFW_KEY_KP_MULTIPLY; case XK_KP_Subtract: return GLFW_KEY_KP_SUBTRACT; case XK_KP_Add: return GLFW_KEY_KP_ADD; case XK_KP_Equal: return GLFW_KEY_KP_EQUAL; case XK_KP_Enter: return GLFW_KEY_KP_ENTER; // The rest (should be printable keys) default: // Make uppercase XConvertCase( key, &key_lc, &key_uc ); key = key_uc; // Valid ISO 8859-1 character? if( (key >= 32 && key <= 126) || (key >= 160 && key <= 255) ) { return (int) key; } return GLFW_KEY_UNKNOWN; } } //======================================================================== // _glfwTranslateChar() - Translates an X Window event to Unicode //======================================================================== static int _glfwTranslateChar( XKeyEvent *event ) { KeySym keysym; // Get X11 keysym XLookupString( event, NULL, 0, &keysym, NULL ); // Convert to Unicode (see x11_keysym2unicode.c) return (int) _glfwKeySym2Unicode( keysym ); } //======================================================================== // Get next X event (called by glfwPollEvents) //======================================================================== static int _glfwGetNextEvent( void ) { XEvent event, next_event; // Pull next event from event queue XNextEvent( _glfwLibrary.Dpy, &event ); // Handle certain window messages switch( event.type ) { // Is a key being pressed? case KeyPress: { // Translate and report key press _glfwInputKey( _glfwTranslateKey( event.xkey.keycode ), GLFW_PRESS ); // Translate and report character input if( _glfwWin.CharCallback ) { _glfwInputChar( _glfwTranslateChar( &event.xkey ), GLFW_PRESS ); } break; } // Is a key being released? case KeyRelease: { // Do not report key releases for key repeats. For key repeats // we will get KeyRelease/KeyPress pairs with identical time // stamps. User selected key repeat filtering is handled in // _glfwInputKey()/_glfwInputChar(). if( XEventsQueued( _glfwLibrary.Dpy, QueuedAfterReading ) ) { XPeekEvent( _glfwLibrary.Dpy, &next_event ); if( next_event.type == KeyPress && next_event.xkey.window == event.xkey.window && next_event.xkey.keycode == event.xkey.keycode && next_event.xkey.time == event.xkey.time ) { // Do not report anything for this event break; } } // Translate and report key release _glfwInputKey( _glfwTranslateKey( event.xkey.keycode ), GLFW_RELEASE ); // Translate and report character input if( _glfwWin.CharCallback ) { _glfwInputChar( _glfwTranslateChar( &event.xkey ), GLFW_RELEASE ); } break; } // Were any of the mouse-buttons pressed? case ButtonPress: { if( event.xbutton.button == Button1 ) { _glfwInputMouseClick( GLFW_MOUSE_BUTTON_LEFT, GLFW_PRESS ); } else if( event.xbutton.button == Button2 ) { _glfwInputMouseClick( GLFW_MOUSE_BUTTON_MIDDLE, GLFW_PRESS ); } else if( event.xbutton.button == Button3 ) { _glfwInputMouseClick( GLFW_MOUSE_BUTTON_RIGHT, GLFW_PRESS ); } // XFree86 3.3.2 and later translates mouse wheel up/down into // mouse button 4 & 5 presses else if( event.xbutton.button == Button4 ) { _glfwInput.WheelPos++; // To verify: is this up or down? if( _glfwWin.MouseWheelCallback ) { _glfwWin.MouseWheelCallback( _glfwInput.WheelPos ); } } else if( event.xbutton.button == Button5 ) { _glfwInput.WheelPos--; if( _glfwWin.MouseWheelCallback ) { _glfwWin.MouseWheelCallback( _glfwInput.WheelPos ); } } break; } // Were any of the mouse-buttons released? case ButtonRelease: { if( event.xbutton.button == Button1 ) { _glfwInputMouseClick( GLFW_MOUSE_BUTTON_LEFT, GLFW_RELEASE ); } else if( event.xbutton.button == Button2 ) { _glfwInputMouseClick( GLFW_MOUSE_BUTTON_MIDDLE, GLFW_RELEASE ); } else if( event.xbutton.button == Button3 ) { _glfwInputMouseClick( GLFW_MOUSE_BUTTON_RIGHT, GLFW_RELEASE ); } break; } // Was the mouse moved? case MotionNotify: { if( event.xmotion.x != _glfwInput.CursorPosX || event.xmotion.y != _glfwInput.CursorPosY ) { if( _glfwWin.MouseLock ) { _glfwInput.MousePosX += event.xmotion.x - _glfwInput.CursorPosX; _glfwInput.MousePosY += event.xmotion.y - _glfwInput.CursorPosY; } else { _glfwInput.MousePosX = event.xmotion.x; _glfwInput.MousePosY = event.xmotion.y; } _glfwInput.CursorPosX = event.xmotion.x; _glfwInput.CursorPosY = event.xmotion.y; _glfwInput.MouseMoved = GL_TRUE; // Call user callback function if( _glfwWin.MousePosCallback ) { _glfwWin.MousePosCallback( _glfwInput.MousePosX, _glfwInput.MousePosY ); } } break; } // Was the window resized? case ConfigureNotify: { if( event.xconfigure.width != _glfwWin.Width || event.xconfigure.height != _glfwWin.Height ) { _glfwWin.Width = event.xconfigure.width; _glfwWin.Height = event.xconfigure.height; if( _glfwWin.WindowSizeCallback ) { _glfwWin.WindowSizeCallback( _glfwWin.Width, _glfwWin.Height ); } } break; } // Was the window closed by the window manager? case ClientMessage: { if( (Atom) event.xclient.data.l[ 0 ] == _glfwWin.WMDeleteWindow ) { return GL_TRUE; } if( (Atom) event.xclient.data.l[ 0 ] == _glfwWin.WMPing ) { XSendEvent( _glfwLibrary.Dpy, RootWindow( _glfwLibrary.Dpy, _glfwWin.VI->screen ), False, SubstructureNotifyMask | SubstructureRedirectMask, &event ); } break; } // Was the window mapped (un-iconified)? case MapNotify: _glfwWin.MapNotifyCount++; break; // Was the window unmapped (iconified)? case UnmapNotify: _glfwWin.MapNotifyCount--; break; // Was the window activated? case FocusIn: _glfwWin.FocusInCount++; break; // Was the window de-activated? case FocusOut: _glfwWin.FocusInCount--; break; // Was the window contents damaged? case Expose: { // Call user callback function if( _glfwWin.WindowRefreshCallback ) { _glfwWin.WindowRefreshCallback(); } break; } // Was the window destroyed? case DestroyNotify: return GL_TRUE; default: { #if defined( _GLFW_HAS_XRANDR ) switch( event.type - _glfwLibrary.XRandR.EventBase ) { case RRScreenChangeNotify: { // Show XRandR that we really care XRRUpdateConfiguration( &event ); break; } } #endif break; } } // The window was not destroyed return GL_FALSE; } //======================================================================== // _glfwCreateNULLCursor() - Create a blank cursor (for locked mouse mode) //======================================================================== Cursor _glfwCreateNULLCursor( Display *display, Window root ) { Pixmap cursormask; XGCValues xgc; GC gc; XColor col; Cursor cursor; cursormask = XCreatePixmap( display, root, 1, 1, 1 ); xgc.function = GXclear; gc = XCreateGC( display, cursormask, GCFunction, &xgc ); XFillRectangle( display, cursormask, gc, 0, 0, 1, 1 ); col.pixel = 0; col.red = 0; col.flags = 4; cursor = XCreatePixmapCursor( display, cursormask, cursormask, &col,&col, 0,0 ); XFreePixmap( display, cursormask ); XFreeGC( display, gc ); return cursor; } //======================================================================== // _glfwInitGLXExtensions() - Initialize GLX-specific extensions //======================================================================== static void _glfwInitGLXExtensions( void ) { int has_swap_control; // Initialize OpenGL extension: GLX_SGI_swap_control has_swap_control = _glfwPlatformExtensionSupported( "GLX_SGI_swap_control" ); if( has_swap_control ) { _glfwWin.SwapInterval = (GLXSWAPINTERVALSGI_T) _glfw_glXGetProcAddress( (GLubyte*) "glXSwapIntervalSGI" ); } else { _glfwWin.SwapInterval = NULL; } } //************************************************************************ //**** Platform implementation functions **** //************************************************************************ //======================================================================== // _glfwPlatformOpenWindow() - Here is where the window is created, and // the OpenGL rendering context is created //======================================================================== int _glfwPlatformOpenWindow( int width, int height, int redbits, int greenbits, int bluebits, int alphabits, int depthbits, int stencilbits, int mode, _GLFWhints* hints ) { Colormap cmap; XSetWindowAttributes wa; XEvent event; Atom protocols[2]; // Clear platform specific GLFW window state _glfwWin.VI = NULL; _glfwWin.CX = (GLXContext)0; _glfwWin.Win = (Window)0; _glfwWin.Hints = NULL; _glfwWin.PointerGrabbed = GL_FALSE; _glfwWin.KeyboardGrabbed = GL_FALSE; _glfwWin.OverrideRedirect = GL_FALSE; _glfwWin.FS.ModeChanged = GL_FALSE; _glfwWin.Saver.Changed = GL_FALSE; _glfwWin.RefreshRate = hints->RefreshRate; // Fullscreen & screen saver settings // Check if GLX is supported on this display if( !glXQueryExtension( _glfwLibrary.Dpy, NULL, NULL ) ) { _glfwPlatformCloseWindow(); return GL_FALSE; } // Get screen ID for this window _glfwWin.Scrn = _glfwLibrary.DefaultScreen; // Get an appropriate visual _glfwWin.VI = _glfwChooseVisual( _glfwLibrary.Dpy, _glfwWin.Scrn, redbits, greenbits, bluebits, alphabits, depthbits, stencilbits, hints->AccumRedBits, hints->AccumGreenBits, hints->AccumBlueBits, hints->AccumAlphaBits, hints->AuxBuffers, hints->Samples, hints->Stereo ); if( _glfwWin.VI == NULL ) { _glfwPlatformCloseWindow(); return GL_FALSE; } // Create a GLX context _glfwWin.CX = glXCreateContext( _glfwLibrary.Dpy, _glfwWin.VI, 0, GL_TRUE ); if( _glfwWin.CX == NULL ) { _glfwPlatformCloseWindow(); return GL_FALSE; } // Create a colormap cmap = XCreateColormap( _glfwLibrary.Dpy, RootWindow( _glfwLibrary.Dpy, _glfwWin.VI->screen), _glfwWin.VI->visual, AllocNone ); // Do we want fullscreen? if( mode == GLFW_FULLSCREEN ) { // Change video mode _glfwSetVideoMode( _glfwWin.Scrn, &_glfwWin.Width, &_glfwWin.Height, &_glfwWin.RefreshRate ); // Remember old screen saver settings XGetScreenSaver( _glfwLibrary.Dpy, &_glfwWin.Saver.Timeout, &_glfwWin.Saver.Interval, &_glfwWin.Saver.Blanking, &_glfwWin.Saver.Exposure ); // Disable screen saver XSetScreenSaver( _glfwLibrary.Dpy, 0, 0, DontPreferBlanking, DefaultExposures ); } // Attributes for window wa.colormap = cmap; wa.border_pixel = 0; wa.event_mask = StructureNotifyMask | KeyPressMask | KeyReleaseMask | PointerMotionMask | ButtonPressMask | ButtonReleaseMask | ExposureMask | FocusChangeMask | VisibilityChangeMask; // Create a window _glfwWin.Win = XCreateWindow( _glfwLibrary.Dpy, RootWindow( _glfwLibrary.Dpy, _glfwWin.VI->screen ), 0, 0, // Upper left corner _glfwWin.Width, _glfwWin.Height, // Width, height 0, // Borderwidth _glfwWin.VI->depth, // Depth InputOutput, _glfwWin.VI->visual, CWBorderPixel | CWColormap | CWEventMask, &wa ); if( !_glfwWin.Win ) { _glfwPlatformCloseWindow(); return GL_FALSE; } // Get the delete window WM protocol atom _glfwWin.WMDeleteWindow = XInternAtom( _glfwLibrary.Dpy, "WM_DELETE_WINDOW", False ); // Get the ping WM protocol atom _glfwWin.WMPing = XInternAtom( _glfwLibrary.Dpy, "_NET_WM_PING", False ); protocols[0] = _glfwWin.WMDeleteWindow; protocols[1] = _glfwWin.WMPing; // Allow us to trap the Window Close protocol XSetWMProtocols( _glfwLibrary.Dpy, _glfwWin.Win, protocols, sizeof(protocols) / sizeof(Atom) ); // Remove window decorations for fullscreen windows if( mode == GLFW_FULLSCREEN ) { _glfwDisableDecorations(); } _glfwWin.Hints = XAllocSizeHints(); if( hints->WindowNoResize ) { _glfwWin.Hints->flags |= (PMinSize | PMaxSize); _glfwWin.Hints->min_width = _glfwWin.Hints->max_width = _glfwWin.Width; _glfwWin.Hints->min_height = _glfwWin.Hints->max_height = _glfwWin.Height; } if( mode == GLFW_FULLSCREEN ) { _glfwWin.Hints->flags |= PPosition; _glfwWin.Hints->x = 0; _glfwWin.Hints->y = 0; } XSetWMNormalHints( _glfwLibrary.Dpy, _glfwWin.Win, _glfwWin.Hints ); // Map window XMapWindow( _glfwLibrary.Dpy, _glfwWin.Win ); // Wait for map notification XIfEvent( _glfwLibrary.Dpy, &event, _glfwWaitForMapNotify, (char*)_glfwWin.Win ); // Make sure that our window ends up on top of things XRaiseWindow( _glfwLibrary.Dpy, _glfwWin.Win ); // Fullscreen mode "post processing" if( mode == GLFW_FULLSCREEN ) { #if defined( _GLFW_HAS_XRANDR ) // Request screen change notifications if( _glfwLibrary.XRandR.Available ) { XRRSelectInput( _glfwLibrary.Dpy, _glfwWin.Win, RRScreenChangeNotifyMask ); } #endif // Force window position/size (some WMs do their own window // geometry, which we want to override) XMoveWindow( _glfwLibrary.Dpy, _glfwWin.Win, 0, 0 ); XResizeWindow( _glfwLibrary.Dpy, _glfwWin.Win, _glfwWin.Width, _glfwWin.Height ); // Grab keyboard if( XGrabKeyboard( _glfwLibrary.Dpy, _glfwWin.Win, True, GrabModeAsync, GrabModeAsync, CurrentTime ) == GrabSuccess ) { _glfwWin.KeyboardGrabbed = GL_TRUE; } // Grab mouse cursor if( XGrabPointer( _glfwLibrary.Dpy, _glfwWin.Win, True, ButtonPressMask | ButtonReleaseMask | PointerMotionMask, GrabModeAsync, GrabModeAsync, _glfwWin.Win, None, CurrentTime ) == GrabSuccess ) { _glfwWin.PointerGrabbed = GL_TRUE; } // Try to get window inside viewport (for virtual displays) by // moving the mouse cursor to the upper left corner (and then to // the center) - this works for XFree86 XWarpPointer( _glfwLibrary.Dpy, None, _glfwWin.Win, 0,0,0,0, 0,0 ); XWarpPointer( _glfwLibrary.Dpy, None, _glfwWin.Win, 0,0,0,0, _glfwWin.Width/2, _glfwWin.Height/2 ); } // Set window & icon name _glfwPlatformSetWindowTitle( "GLFW Window" ); // Connect the context to the window glXMakeCurrent( _glfwLibrary.Dpy, _glfwWin.Win, _glfwWin.CX ); // Start by clearing the front buffer to black (avoid ugly desktop // remains in our OpenGL window) glClear( GL_COLOR_BUFFER_BIT ); glXSwapBuffers( _glfwLibrary.Dpy, _glfwWin.Win ); // Initialize GLX-specific OpenGL extensions _glfwInitGLXExtensions(); return GL_TRUE; } //======================================================================== // Properly kill the window/video display //======================================================================== void _glfwPlatformCloseWindow( void ) { #if defined( _GLFW_HAS_XRANDR ) XRRScreenConfiguration *sc; Window root; #endif // Free WM size hints if( _glfwWin.Hints ) { XFree( _glfwWin.Hints ); _glfwWin.Hints = NULL; } // Do we have a rendering context? if( _glfwWin.CX ) { // Release the context glXMakeCurrent( _glfwLibrary.Dpy, None, NULL ); // Delete the context glXDestroyContext( _glfwLibrary.Dpy, _glfwWin.CX ); _glfwWin.CX = NULL; } // Ungrab pointer and/or keyboard? if( _glfwWin.KeyboardGrabbed ) { XUngrabKeyboard( _glfwLibrary.Dpy, CurrentTime ); _glfwWin.KeyboardGrabbed = GL_FALSE; } if( _glfwWin.PointerGrabbed ) { XUngrabPointer( _glfwLibrary.Dpy, CurrentTime ); _glfwWin.PointerGrabbed = GL_FALSE; } // Do we have a window? if( _glfwWin.Win ) { // Unmap the window XUnmapWindow( _glfwLibrary.Dpy, _glfwWin.Win ); // Destroy the window XDestroyWindow( _glfwLibrary.Dpy, _glfwWin.Win ); _glfwWin.Win = (Window) 0; } // Did we change the fullscreen resolution? if( _glfwWin.FS.ModeChanged ) { #if defined( _GLFW_HAS_XRANDR ) if( _glfwLibrary.XRandR.Available ) { root = RootWindow( _glfwLibrary.Dpy, _glfwWin.Scrn ); sc = XRRGetScreenInfo( _glfwLibrary.Dpy, root ); XRRSetScreenConfig( _glfwLibrary.Dpy, sc, root, _glfwWin.FS.OldSizeID, _glfwWin.FS.OldRotation, CurrentTime ); XRRFreeScreenConfigInfo( sc ); } #elif defined( _GLFW_HAS_XF86VIDMODE ) if( _glfwLibrary.XF86VidMode.Available ) { // Unlock mode switch XF86VidModeLockModeSwitch( _glfwLibrary.Dpy, _glfwWin.Scrn, 0 ); // Change the video mode back to the old mode XF86VidModeSwitchToMode( _glfwLibrary.Dpy, _glfwWin.Scrn, &_glfwWin.FS.OldMode ); } #endif _glfwWin.FS.ModeChanged = GL_FALSE; } // Did we change the screen saver setting? if( _glfwWin.Saver.Changed ) { // Restore old screen saver settings XSetScreenSaver( _glfwLibrary.Dpy, _glfwWin.Saver.Timeout, _glfwWin.Saver.Interval, _glfwWin.Saver.Blanking, _glfwWin.Saver.Exposure ); _glfwWin.Saver.Changed = GL_FALSE; } XSync( _glfwLibrary.Dpy, True ); } //======================================================================== // _glfwPlatformSetWindowTitle() - Set the window title. //======================================================================== void _glfwPlatformSetWindowTitle( const char *title ) { // Set window & icon title XStoreName( _glfwLibrary.Dpy, _glfwWin.Win, title ); XSetIconName( _glfwLibrary.Dpy, _glfwWin.Win, title ); } //======================================================================== // _glfwPlatformSetWindowSize() - Set the window size. //======================================================================== void _glfwPlatformSetWindowSize( int width, int height ) { int mode = 0, rate, sizechanged = GL_FALSE; GLint drawbuffer; GLfloat clearcolor[4]; rate = _glfwWin.RefreshRate; // If we are in fullscreen mode, get some info about the current mode if( _glfwWin.Fullscreen ) { // Get closest match for target video mode mode = _glfwGetClosestVideoMode( _glfwWin.Scrn, &width, &height, &rate ); } if( _glfwWin.WindowNoResize ) { _glfwWin.Hints->min_width = _glfwWin.Hints->max_width = width; _glfwWin.Hints->min_height = _glfwWin.Hints->max_height = height; } XSetWMNormalHints( _glfwLibrary.Dpy, _glfwWin.Win, _glfwWin.Hints ); // Change window size before changing fullscreen mode? if( _glfwWin.Fullscreen && (width > _glfwWin.Width) ) { XResizeWindow( _glfwLibrary.Dpy, _glfwWin.Win, width, height ); sizechanged = GL_TRUE; } // Change fullscreen video mode? if( _glfwWin.Fullscreen ) { // Change video mode (keeping current rate) _glfwSetVideoModeMODE( _glfwWin.Scrn, mode, _glfwWin.RefreshRate ); // Clear the front buffer to black (avoid ugly desktop remains in // our OpenGL window) glGetIntegerv( GL_DRAW_BUFFER, &drawbuffer ); glGetFloatv( GL_COLOR_CLEAR_VALUE, clearcolor ); glClearColor( 0.0f, 0.0f, 0.0f, 0.0f ); glClear( GL_COLOR_BUFFER_BIT ); if( drawbuffer == GL_BACK ) { glXSwapBuffers( _glfwLibrary.Dpy, _glfwWin.Win ); } glClearColor( clearcolor[0], clearcolor[1], clearcolor[2], clearcolor[3] ); } // Set window size (if not already changed) if( !sizechanged ) { XResizeWindow( _glfwLibrary.Dpy, _glfwWin.Win, width, height ); } } //======================================================================== // _glfwPlatformSetWindowPos() - Set the window position. //======================================================================== void _glfwPlatformSetWindowPos( int x, int y ) { // Set window position XMoveWindow( _glfwLibrary.Dpy, _glfwWin.Win, x, y ); } //======================================================================== // _glfwPlatformIconfyWindow() - Window iconification //======================================================================== void _glfwPlatformIconifyWindow( void ) { // We can't do this for override redirect windows if( _glfwWin.OverrideRedirect ) { return; } // In fullscreen mode, we need to restore the desktop video mode if( _glfwWin.Fullscreen ) { #if defined( _GLFW_HAS_XF86VIDMODE ) if( _glfwLibrary.XF86VidMode.Available ) { // Unlock mode switch XF86VidModeLockModeSwitch( _glfwLibrary.Dpy, _glfwWin.Scrn, 0 ); // Change the video mode back to the old mode XF86VidModeSwitchToMode( _glfwLibrary.Dpy, _glfwWin.Scrn, &_glfwWin.FS.OldMode ); } #endif _glfwWin.FS.ModeChanged = GL_FALSE; } // Show mouse pointer if( _glfwWin.PointerHidden ) { XUndefineCursor( _glfwLibrary.Dpy, _glfwWin.Win ); _glfwWin.PointerHidden = GL_FALSE; } // Un-grab mouse pointer if( _glfwWin.PointerGrabbed ) { XUngrabPointer( _glfwLibrary.Dpy, CurrentTime ); _glfwWin.PointerGrabbed = GL_FALSE; } // Iconify window XIconifyWindow( _glfwLibrary.Dpy, _glfwWin.Win, _glfwWin.Scrn ); // Window is now iconified _glfwWin.Iconified = GL_TRUE; } //======================================================================== // Window un-iconification //======================================================================== void _glfwPlatformRestoreWindow( void ) { // We can't do this for override redirect windows if( _glfwWin.OverrideRedirect ) { return; } // In fullscreen mode, change back video mode to user selected mode if( _glfwWin.Fullscreen ) { _glfwSetVideoMode( _glfwWin.Scrn, &_glfwWin.Width, &_glfwWin.Height, &_glfwWin.RefreshRate ); } // Un-iconify window XMapWindow( _glfwLibrary.Dpy, _glfwWin.Win ); // In fullscreen mode... if( _glfwWin.Fullscreen ) { // Make sure window is in upper left corner XMoveWindow( _glfwLibrary.Dpy, _glfwWin.Win, 0, 0 ); // Get input focus XSetInputFocus( _glfwLibrary.Dpy, _glfwWin.Win, RevertToParent, CurrentTime ); } // Lock mouse, if necessary if( _glfwWin.MouseLock ) { // Hide cursor if( !_glfwWin.PointerHidden ) { XDefineCursor( _glfwLibrary.Dpy, _glfwWin.Win, _glfwCreateNULLCursor( _glfwLibrary.Dpy, _glfwWin.Win ) ); _glfwWin.PointerHidden = GL_TRUE; } // Grab cursor if( !_glfwWin.PointerGrabbed ) { if( XGrabPointer( _glfwLibrary.Dpy, _glfwWin.Win, True, ButtonPressMask | ButtonReleaseMask | PointerMotionMask, GrabModeAsync, GrabModeAsync, _glfwWin.Win, None, CurrentTime ) == GrabSuccess ) { _glfwWin.PointerGrabbed = GL_TRUE; } } } // Window is no longer iconified _glfwWin.Iconified = GL_FALSE; } //======================================================================== // _glfwPlatformSwapBuffers() - Swap buffers (double-buffering) and poll // any new events. //======================================================================== void _glfwPlatformSwapBuffers( void ) { // Update display-buffer glXSwapBuffers( _glfwLibrary.Dpy, _glfwWin.Win ); } //======================================================================== // _glfwPlatformSwapInterval() - Set double buffering swap interval //======================================================================== void _glfwPlatformSwapInterval( int interval ) { if( _glfwWin.SwapInterval ) { _glfwWin.SwapInterval( interval ); } } //======================================================================== // _glfwPlatformRefreshWindowParams() //======================================================================== void _glfwPlatformRefreshWindowParams( void ) { #if defined( _GLFW_HAS_XRANDR ) XRRScreenConfiguration *sc; #elif defined( _GLFW_HAS_XF86VIDMODE ) XF86VidModeModeLine modeline; int dotclock; float pixels_per_second, pixels_per_frame; #endif int sample_buffers; // AFAIK, there is no easy/sure way of knowing if OpenGL is hardware // accelerated _glfwWin.Accelerated = GL_TRUE; // "Standard" window parameters glXGetConfig( _glfwLibrary.Dpy, _glfwWin.VI, GLX_RED_SIZE, &_glfwWin.RedBits ); glXGetConfig( _glfwLibrary.Dpy, _glfwWin.VI, GLX_GREEN_SIZE, &_glfwWin.GreenBits ); glXGetConfig( _glfwLibrary.Dpy, _glfwWin.VI, GLX_BLUE_SIZE, &_glfwWin.BlueBits ); glXGetConfig( _glfwLibrary.Dpy, _glfwWin.VI, GLX_ALPHA_SIZE, &_glfwWin.AlphaBits ); glXGetConfig( _glfwLibrary.Dpy, _glfwWin.VI, GLX_DEPTH_SIZE, &_glfwWin.DepthBits ); glXGetConfig( _glfwLibrary.Dpy, _glfwWin.VI, GLX_STENCIL_SIZE, &_glfwWin.StencilBits ); glXGetConfig( _glfwLibrary.Dpy, _glfwWin.VI, GLX_ACCUM_RED_SIZE, &_glfwWin.AccumRedBits ); glXGetConfig( _glfwLibrary.Dpy, _glfwWin.VI, GLX_ACCUM_GREEN_SIZE, &_glfwWin.AccumGreenBits ); glXGetConfig( _glfwLibrary.Dpy, _glfwWin.VI, GLX_ACCUM_BLUE_SIZE, &_glfwWin.AccumBlueBits ); glXGetConfig( _glfwLibrary.Dpy, _glfwWin.VI, GLX_ACCUM_ALPHA_SIZE, &_glfwWin.AccumAlphaBits ); glXGetConfig( _glfwLibrary.Dpy, _glfwWin.VI, GLX_AUX_BUFFERS, &_glfwWin.AuxBuffers ); // Get stereo rendering setting glXGetConfig( _glfwLibrary.Dpy, _glfwWin.VI, GLX_STEREO, &_glfwWin.Stereo ); _glfwWin.Stereo = _glfwWin.Stereo ? 1 : 0; // Get multisample buffer samples glXGetConfig( _glfwLibrary.Dpy, _glfwWin.VI, GLX_SAMPLES, &_glfwWin.Samples ); glXGetConfig( _glfwLibrary.Dpy, _glfwWin.VI, GLX_SAMPLE_BUFFERS, &sample_buffers ); if( sample_buffers == 0 ) _glfwWin.Samples = 0; // Default to refresh rate unknown (=0 according to GLFW spec) _glfwWin.RefreshRate = 0; // Retrieve refresh rate, if possible #if defined( _GLFW_HAS_XRANDR ) if( _glfwLibrary.XRandR.Available ) { sc = XRRGetScreenInfo( _glfwLibrary.Dpy, RootWindow( _glfwLibrary.Dpy, _glfwWin.Scrn ) ); _glfwWin.RefreshRate = XRRConfigCurrentRate( sc ); XRRFreeScreenConfigInfo( sc ); } #elif defined( _GLFW_HAS_XF86VIDMODE ) if( _glfwLibrary.XF86VidMode.Available ) { // Use the XF86VidMode extension to get current video mode XF86VidModeGetModeLine( _glfwLibrary.Dpy, _glfwWin.Scrn, &dotclock, &modeline ); pixels_per_second = 1000.0f * (float) dotclock; pixels_per_frame = (float) modeline.htotal * modeline.vtotal; _glfwWin.RefreshRate = (int)(pixels_per_second/pixels_per_frame+0.5); } #endif } //======================================================================== // _glfwPlatformPollEvents() - Poll for new window and input events //======================================================================== void _glfwPlatformPollEvents( void ) { int winclosed = GL_FALSE; // Flag that the cursor has not moved _glfwInput.MouseMoved = GL_FALSE; // Clear MapNotify and FocusIn counts _glfwWin.MapNotifyCount = 0; _glfwWin.FocusInCount = 0; // Use XSync to synchronise events to the X display. // I don't know if this can have a serious performance impact. My // benchmarks with a GeForce card under Linux shows no difference with // or without XSync, but when the GL window is rendered over a slow // network I have noticed bad event syncronisation problems when XSync // is not used, so I decided to use it. XSync( _glfwLibrary.Dpy, False ); // Empty the window event queue while( XPending( _glfwLibrary.Dpy ) ) { if( _glfwGetNextEvent() ) { winclosed = GL_TRUE; } } // Did we get mouse movement in locked cursor mode? if( _glfwInput.MouseMoved && _glfwWin.MouseLock ) { int maxx, minx, maxy, miny; // Calculate movement threshold minx = _glfwWin.Width / 4; maxx = (_glfwWin.Width * 3) / 4; miny = _glfwWin.Height / 4; maxy = (_glfwWin.Height * 3) / 4; // Did the mouse cursor move beyond our movement threshold if(_glfwInput.CursorPosX < minx || _glfwInput.CursorPosX > maxx || _glfwInput.CursorPosY < miny || _glfwInput.CursorPosY > maxy) { // Move the mouse pointer back to the window center so that it // does not wander off... _glfwPlatformSetMouseCursorPos( _glfwWin.Width/2, _glfwWin.Height/2 ); XSync( _glfwLibrary.Dpy, False ); } } // Was the window (un)iconified? if( _glfwWin.MapNotifyCount < 0 && !_glfwWin.Iconified ) { // Show mouse pointer if( _glfwWin.PointerHidden ) { XUndefineCursor( _glfwLibrary.Dpy, _glfwWin.Win ); _glfwWin.PointerHidden = GL_FALSE; } // Un-grab mouse pointer if( _glfwWin.PointerGrabbed ) { XUngrabPointer( _glfwLibrary.Dpy, CurrentTime ); _glfwWin.PointerGrabbed = GL_FALSE; } _glfwWin.Iconified = GL_TRUE; } else if( _glfwWin.MapNotifyCount > 0 && _glfwWin.Iconified ) { // Restore fullscreen mode properties if( _glfwWin.Fullscreen ) { // Change back video mode to user selected mode _glfwSetVideoMode( _glfwWin.Scrn, &_glfwWin.Width, &_glfwWin.Height, &_glfwWin.RefreshRate ); // Disable window manager decorations _glfwEnableDecorations(); // Make sure window is in upper left corner XMoveWindow( _glfwLibrary.Dpy, _glfwWin.Win, 0, 0 ); // Get input focus XSetInputFocus( _glfwLibrary.Dpy, _glfwWin.Win, RevertToParent, CurrentTime ); } // Hide cursor if necessary if( _glfwWin.MouseLock && !_glfwWin.PointerHidden ) { if( !_glfwWin.PointerHidden ) { XDefineCursor( _glfwLibrary.Dpy, _glfwWin.Win, _glfwCreateNULLCursor( _glfwLibrary.Dpy, _glfwWin.Win ) ); _glfwWin.PointerHidden = GL_TRUE; } } // Grab cursor if necessary if( (_glfwWin.MouseLock || _glfwWin.Fullscreen) && !_glfwWin.PointerGrabbed ) { if( XGrabPointer( _glfwLibrary.Dpy, _glfwWin.Win, True, ButtonPressMask | ButtonReleaseMask | PointerMotionMask, GrabModeAsync, GrabModeAsync, _glfwWin.Win, None, CurrentTime ) == GrabSuccess ) { _glfwWin.PointerGrabbed = GL_TRUE; } } _glfwWin.Iconified = GL_FALSE; } // Did the window get/lose focus if( _glfwWin.FocusInCount > 0 && !_glfwWin.Active ) { // If we are in fullscreen mode, restore window if( _glfwWin.Fullscreen && _glfwWin.Iconified ) { _glfwPlatformRestoreWindow(); } // Window is now active _glfwWin.Active = GL_TRUE; } else if( _glfwWin.FocusInCount < 0 && _glfwWin.Active ) { // If we are in fullscreen mode, iconfify window if( _glfwWin.Fullscreen ) { _glfwPlatformIconifyWindow(); } // Window is not active _glfwWin.Active = GL_FALSE; _glfwInputDeactivation(); } // Was there a window close request? if( winclosed && _glfwWin.WindowCloseCallback ) { // Check if the program wants us to close the window winclosed = _glfwWin.WindowCloseCallback(); } if( winclosed ) { glfwCloseWindow(); } } //======================================================================== // _glfwPlatformWaitEvents() - Wait for new window and input events //======================================================================== void _glfwPlatformWaitEvents( void ) { XEvent event; // Wait for new events (blocking) XNextEvent( _glfwLibrary.Dpy, &event ); XPutBackEvent( _glfwLibrary.Dpy, &event ); // Poll events from queue _glfwPlatformPollEvents(); } //======================================================================== // _glfwPlatformHideMouseCursor() - Hide mouse cursor (lock it) //======================================================================== void _glfwPlatformHideMouseCursor( void ) { // Hide cursor if( !_glfwWin.PointerHidden ) { XDefineCursor( _glfwLibrary.Dpy, _glfwWin.Win, _glfwCreateNULLCursor( _glfwLibrary.Dpy, _glfwWin.Win ) ); _glfwWin.PointerHidden = GL_TRUE; } // Grab cursor to user window if( !_glfwWin.PointerGrabbed ) { if( XGrabPointer( _glfwLibrary.Dpy, _glfwWin.Win, True, ButtonPressMask | ButtonReleaseMask | PointerMotionMask, GrabModeAsync, GrabModeAsync, _glfwWin.Win, None, CurrentTime ) == GrabSuccess ) { _glfwWin.PointerGrabbed = GL_TRUE; } } } //======================================================================== // _glfwPlatformShowMouseCursor() - Show mouse cursor (unlock it) //======================================================================== void _glfwPlatformShowMouseCursor( void ) { // Un-grab cursor (only in windowed mode: in fullscreen mode we still // want the mouse grabbed in order to confine the cursor to the window // area) if( _glfwWin.PointerGrabbed && !_glfwWin.Fullscreen ) { XUngrabPointer( _glfwLibrary.Dpy, CurrentTime ); _glfwWin.PointerGrabbed = GL_FALSE; } // Show cursor if( _glfwWin.PointerHidden ) { XUndefineCursor( _glfwLibrary.Dpy, _glfwWin.Win ); _glfwWin.PointerHidden = GL_FALSE; } } //======================================================================== // _glfwPlatformSetMouseCursorPos() - Set physical mouse cursor position //======================================================================== void _glfwPlatformSetMouseCursorPos( int x, int y ) { // Change cursor position _glfwInput.CursorPosX = x; _glfwInput.CursorPosY = y; XWarpPointer( _glfwLibrary.Dpy, None, _glfwWin.Win, 0,0,0,0, x, y ); }