mirror/glfw
1
0
Fork 0
mirror of https://github.com/glfw/glfw.git synced 2024-11-22 13:04:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

Shallow formatting pass (no code changes).

Browse Source
This commit is contained in:
Camilla Berglund 2010-09-08 04:15:49 +02:00
parent c5af4c4324
commit a0351391d1
6 changed files with 22 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
lib/x11/x11_fullscreen.c
View File

@ -53,14 +53,11 @@ static void BPP2RGB( int bpp, int *r, int *g, int *b )
*r = *g = *b = bpp / 3; *r = *g = *b = bpp / 3;
delta = bpp - (*r * 3); delta = bpp - (*r * 3);
if( delta >= 1 ) if( delta >= 1 )
{
*g = *g + 1; *g = *g + 1;
}
if( delta == 2 ) if( delta == 2 )
{
*r = *r + 1; *r = *r + 1;
} }
}
//======================================================================== //========================================================================
@ -123,20 +120,16 @@ int _glfwGetClosestVideoMode( int screen, int *width, int *height, int *rate )
} }
if( bestrate != -1 ) if( bestrate != -1 )
{
*rate = bestrate; *rate = bestrate;
} }
} }
}
// Free modelist // Free modelist
XRRFreeScreenConfigInfo( sc ); XRRFreeScreenConfigInfo( sc );
if( bestsize != -1 ) if( bestsize != -1 )
{
return bestsize; return bestsize;
} }
}
#elif defined( _GLFW_HAS_XF86VIDMODE ) #elif defined( _GLFW_HAS_XF86VIDMODE )
XF86VidModeModeInfo **modelist; XF86VidModeModeInfo **modelist;
int modecount, i, bestmode, bestmatch, match; int modecount, i, bestmode, bestmatch, match;
@ -175,10 +168,8 @@ int _glfwGetClosestVideoMode( int screen, int *width, int *height, int *rate )
XFree( modelist ); XFree( modelist );
if( bestmode != -1 ) if( bestmode != -1 )
{
return bestmode; return bestmode;
} }
}
#endif #endif
// Default: Simply use the screen resolution // Default: Simply use the screen resolution
@ -251,9 +242,7 @@ void _glfwSetVideoModeMODE( int screen, int mode, int rate )
// Unlock mode switch if necessary // Unlock mode switch if necessary
if( _glfwWin.FS.modeChanged ) if( _glfwWin.FS.modeChanged )
{
XF86VidModeLockModeSwitch( _glfwLibrary.display, screen, 0 ); XF86VidModeLockModeSwitch( _glfwLibrary.display, screen, 0 );
}
// Change the video mode to the desired mode // Change the video mode to the desired mode
XF86VidModeSwitchToMode( _glfwLibrary.display, screen, XF86VidModeSwitchToMode( _glfwLibrary.display, screen,
@ -379,9 +368,7 @@ int _glfwPlatformGetVideoModes( GLFWvidmode *list, int maxcount )
// Get list of visuals // Get list of visuals
vislist = XGetVisualInfo( dpy, 0, &dummy, &viscount ); vislist = XGetVisualInfo( dpy, 0, &dummy, &viscount );
if( vislist == NULL ) if( vislist == NULL )
{
return 0; return 0;
}
rgbarray = (int*) malloc( sizeof(int) * viscount ); rgbarray = (int*) malloc( sizeof(int) * viscount );
rgbcount = 0; rgbcount = 0;
@ -405,10 +392,9 @@ int _glfwPlatformGetVideoModes( GLFWvidmode *list, int maxcount )
for( l = 0; l < rgbcount; l++ ) for( l = 0; l < rgbcount; l++ )
{ {
if( depth == rgbarray[ l ] ) if( depth == rgbarray[ l ] )
{
break; break;
} }
}
if( l >= rgbcount ) if( l >= rgbcount )
{ {
rgbarray[ rgbcount ] = depth; rgbarray[ rgbcount ] = depth;
@ -454,10 +440,8 @@ int _glfwPlatformGetVideoModes( GLFWvidmode *list, int maxcount )
for( l = 0; l < rescount; l++ ) for( l = 0; l < rescount; l++ )
{ {
if( width == resarray[ l ].width && height == resarray[ l ].height ) if( width == resarray[ l ].width && height == resarray[ l ].height )
{
break; break;
} }
}
if( l >= rescount ) if( l >= rescount )
{ {

2
lib/x11/x11_glext.c
View File

@ -70,10 +70,8 @@ int _glfwPlatformExtensionSupported( const char *extension )
if( extensions != NULL ) if( extensions != NULL )
{ {
if( _glfwStringInExtensionString( extension, extensions ) ) if( _glfwStringInExtensionString( extension, extensions ) )
{
return GL_TRUE; return GL_TRUE;
} }
}
return GL_FALSE; return GL_FALSE;
} }

4
lib/x11/x11_init.c
View File

@ -31,7 +31,6 @@
#include "internal.h" #include "internal.h"
//************************************************************************ //************************************************************************
//**** GLFW internal functions **** //**** GLFW internal functions ****
//************************************************************************ //************************************************************************
@ -155,11 +154,8 @@ static void terminateDisplay( void )
int _glfwPlatformInit( void ) int _glfwPlatformInit( void )
{ {
// Initialize display
if( !initDisplay() ) if( !initDisplay() )
{
return GL_FALSE; return GL_FALSE;
}
// Try to load libGL.so if necessary // Try to load libGL.so if necessary
initLibraries(); initLibraries();

34
lib/x11/x11_joystick.c
View File

@ -74,7 +74,7 @@ struct js_event {
//======================================================================== //========================================================================
// _glfwInitJoysticks() - Initialize joystick interface // Initialize joystick interface
//======================================================================== //========================================================================
void _glfwInitJoysticks( void ) void _glfwInitJoysticks( void )
@ -89,9 +89,7 @@ void _glfwInitJoysticks( void )
// Start by saying that there are no sticks // Start by saying that there are no sticks
for( i = 0; i <= GLFW_JOYSTICK_LAST; ++ i ) for( i = 0; i <= GLFW_JOYSTICK_LAST; ++ i )
{
_glfwJoy[ i ].Present = GL_FALSE; _glfwJoy[ i ].Present = GL_FALSE;
}
#ifdef _GLFW_USE_LINUX_JOYSTICKS #ifdef _GLFW_USE_LINUX_JOYSTICKS
@ -160,13 +158,10 @@ void _glfwInitJoysticks( void )
// Clear joystick state // Clear joystick state
for( n = 0; n < _glfwJoy[ joy_count ].NumAxes; ++ n ) for( n = 0; n < _glfwJoy[ joy_count ].NumAxes; ++ n )
{
_glfwJoy[ joy_count ].Axis[ n ] = 0.0f; _glfwJoy[ joy_count ].Axis[ n ] = 0.0f;
}
for( n = 0; n < _glfwJoy[ joy_count ].NumButtons; ++ n ) for( n = 0; n < _glfwJoy[ joy_count ].NumButtons; ++ n )
{
_glfwJoy[ joy_count ].Button[ n ] = GLFW_RELEASE; _glfwJoy[ joy_count ].Button[ n ] = GLFW_RELEASE;
}
// The joystick is supported and connected // The joystick is supported and connected
_glfwJoy[ joy_count ].Present = GL_TRUE; _glfwJoy[ joy_count ].Present = GL_TRUE;
@ -181,7 +176,7 @@ void _glfwInitJoysticks( void )
//======================================================================== //========================================================================
// _glfwTerminateJoysticks() - Close all opened joystick handles // Close all opened joystick handles
//======================================================================== //========================================================================
void _glfwTerminateJoysticks( void ) void _glfwTerminateJoysticks( void )
@ -269,16 +264,13 @@ static void pollJoystickEvents( void )
//************************************************************************ //************************************************************************
//======================================================================== //========================================================================
// _glfwPlatformGetJoystickParam() - Determine joystick capabilities // Determine joystick capabilities
//======================================================================== //========================================================================
int _glfwPlatformGetJoystickParam( int joy, int param ) int _glfwPlatformGetJoystickParam( int joy, int param )
{ {
// Is joystick present?
if( !_glfwJoy[ joy ].Present ) if( !_glfwJoy[ joy ].Present )
{
return 0; return 0;
}
switch( param ) switch( param )
{ {
@ -300,40 +292,33 @@ int _glfwPlatformGetJoystickParam( int joy, int param )
//======================================================================== //========================================================================
// _glfwPlatformGetJoystickPos() - Get joystick axis positions // Get joystick axis positions
//======================================================================== //========================================================================
int _glfwPlatformGetJoystickPos( int joy, float *pos, int numaxes ) int _glfwPlatformGetJoystickPos( int joy, float *pos, int numaxes )
{ {
int i; int i;
// Is joystick present?
if( !_glfwJoy[ joy ].Present ) if( !_glfwJoy[ joy ].Present )
{
return 0; return 0;
}
// Update joystick state // Update joystick state
pollJoystickEvents(); pollJoystickEvents();
// Does the joystick support less axes than requested? // Does the joystick support less axes than requested?
if( _glfwJoy[ joy ].NumAxes < numaxes ) if( _glfwJoy[ joy ].NumAxes < numaxes )
{
numaxes = _glfwJoy[ joy ].NumAxes; numaxes = _glfwJoy[ joy ].NumAxes;
}
// Copy axis positions from internal state // Copy axis positions from internal state
for( i = 0; i < numaxes; ++ i ) for( i = 0; i < numaxes; ++ i )
{
pos[ i ] = _glfwJoy[ joy ].Axis[ i ]; pos[ i ] = _glfwJoy[ joy ].Axis[ i ];
}
return numaxes; return numaxes;
} }
//======================================================================== //========================================================================
// _glfwPlatformGetJoystickButtons() - Get joystick button states // Get joystick button states
//======================================================================== //========================================================================
int _glfwPlatformGetJoystickButtons( int joy, unsigned char *buttons, int _glfwPlatformGetJoystickButtons( int joy, unsigned char *buttons,
@ -341,26 +326,19 @@ int _glfwPlatformGetJoystickButtons( int joy, unsigned char *buttons,
{ {
int i; int i;
// Is joystick present?
if( !_glfwJoy[ joy ].Present ) if( !_glfwJoy[ joy ].Present )
{
return 0; return 0;
}
// Update joystick state // Update joystick state
pollJoystickEvents(); pollJoystickEvents();
// Does the joystick support less buttons than requested? // Does the joystick support less buttons than requested?
if( _glfwJoy[ joy ].NumButtons < numbuttons ) if( _glfwJoy[ joy ].NumButtons < numbuttons )
{
numbuttons = _glfwJoy[ joy ].NumButtons; numbuttons = _glfwJoy[ joy ].NumButtons;
}
// Copy button states from internal state // Copy button states from internal state
for( i = 0; i < numbuttons; ++ i ) for( i = 0; i < numbuttons; ++ i )
{
buttons[ i ] = _glfwJoy[ joy ].Button[ i ]; buttons[ i ] = _glfwJoy[ joy ].Button[ i ];
}
return numbuttons; return numbuttons;
} }

6
lib/x11/x11_keysym2unicode.c
View File

@ -873,22 +873,16 @@ long _glfwKeySym2Unicode( KeySym keysym )
/* Also check for directly encoded 24-bit UCS characters */ /* Also check for directly encoded 24-bit UCS characters */
if( (keysym & 0xff000000) == 0x01000000 ) if( (keysym & 0xff000000) == 0x01000000 )
{
return keysym & 0x00ffffff; return keysym & 0x00ffffff;
}
/* Binary search in table */ /* Binary search in table */
while( max >= min ) while( max >= min )
{ {
mid = (min + max) / 2; mid = (min + max) / 2;
if( keysymtab[mid].keysym < keysym ) if( keysymtab[mid].keysym < keysym )
{
min = mid + 1; min = mid + 1;
}
else if( keysymtab[mid].keysym > keysym ) else if( keysymtab[mid].keysym > keysym )
{
max = mid - 1; max = mid - 1;
}
else else
{ {
/* Found it! */ /* Found it! */

76
lib/x11/x11_window.c
View File

@ -89,9 +89,7 @@ static unsigned long getWindowProperty( Window window,
value ); value );
if( actualType != type ) if( actualType != type )
{
return 0; return 0;
}
return itemCount; return itemCount;
} }
@ -113,11 +111,9 @@ static Atom getSupportedAtom( Atom* supportedAtoms,
for( i = 0; i < atomCount; i++ ) for( i = 0; i < atomCount; i++ )
{ {
if( supportedAtoms[i] == atom ) if( supportedAtoms[i] == atom )
{
return atom; return atom;
} }
} }
}
return None; return None;
} }
@ -142,9 +138,7 @@ static GLboolean checkForEWMH( void )
"_NET_SUPPORTED", "_NET_SUPPORTED",
True ); True );
if( supportingWmCheck == None || wmSupported == None ) if( supportingWmCheck == None || wmSupported == None )
{
return GL_FALSE; return GL_FALSE;
}
// Then we look for the _NET_SUPPORTING_WM_CHECK property of the root window // Then we look for the _NET_SUPPORTING_WM_CHECK property of the root window
if( getWindowProperty( _glfwWin.root, if( getWindowProperty( _glfwWin.root,
@ -332,11 +326,9 @@ static int translateKey( int keycode )
key = key_uc; key = key_uc;
// Valid ISO 8859-1 character? // Valid ISO 8859-1 character?
if( (key >= 32 && key <= 126) || if( (key >= 32 && key <= 126) || (key >= 160 && key <= 255) )
(key >= 160 && key <= 255) )
{
return (int) key; return (int) key;
}
return GLFW_KEY_UNKNOWN; return GLFW_KEY_UNKNOWN;
} }
} }
@ -397,12 +389,11 @@ static int getFBConfigAttrib( GLXFBConfig fbconfig, int attrib )
if( _glfwWin.has_GLX_SGIX_fbconfig ) if( _glfwWin.has_GLX_SGIX_fbconfig )
{ {
_glfwWin.GetFBConfigAttribSGIX( _glfwLibrary.display, fbconfig, attrib, &value ); _glfwWin.GetFBConfigAttribSGIX( _glfwLibrary.display,
fbconfig, attrib, &value );
} }
else else
{
glXGetFBConfigAttrib( _glfwLibrary.display, fbconfig, attrib, &value ); glXGetFBConfigAttrib( _glfwLibrary.display, fbconfig, attrib, &value );
}
return value; return value;
} }
@ -496,13 +487,9 @@ static _GLFWfbconfig *getFBConfigs( unsigned int *found )
result[*found].stereo = getFBConfigAttrib( fbconfigs[i], GLX_STEREO ); result[*found].stereo = getFBConfigAttrib( fbconfigs[i], GLX_STEREO );
if( _glfwWin.has_GLX_ARB_multisample ) if( _glfwWin.has_GLX_ARB_multisample )
{
result[*found].samples = getFBConfigAttrib( fbconfigs[i], GLX_SAMPLES ); result[*found].samples = getFBConfigAttrib( fbconfigs[i], GLX_SAMPLES );
}
else else
{
result[*found].samples = 0; result[*found].samples = 0;
}
result[*found].platformID = (GLFWintptr) getFBConfigAttrib( fbconfigs[i], GLX_FBCONFIG_ID ); result[*found].platformID = (GLFWintptr) getFBConfigAttrib( fbconfigs[i], GLX_FBCONFIG_ID );
@ -566,7 +553,8 @@ static int createContext( const _GLFWwndconfig *wndconfig, GLXFBConfigID fbconfi
} }
else else
{ {
_glfwWin.visual = glXGetVisualFromFBConfig( _glfwLibrary.display, *fbconfig ); _glfwWin.visual = glXGetVisualFromFBConfig( _glfwLibrary.display,
*fbconfig );
} }
if( _glfwWin.visual == NULL ) if( _glfwWin.visual == NULL )
@ -594,14 +582,10 @@ static int createContext( const _GLFWwndconfig *wndconfig, GLXFBConfigID fbconfi
flags = 0; flags = 0;
if( wndconfig->glForward ) if( wndconfig->glForward )
{
flags |= GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB; flags |= GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB;
}
if( wndconfig->glDebug ) if( wndconfig->glDebug )
{
flags |= GLX_CONTEXT_DEBUG_BIT_ARB; flags |= GLX_CONTEXT_DEBUG_BIT_ARB;
}
setGLXattrib( attribs, index, GLX_CONTEXT_FLAGS_ARB, flags ); setGLXattrib( attribs, index, GLX_CONTEXT_FLAGS_ARB, flags );
} }
@ -616,13 +600,9 @@ static int createContext( const _GLFWwndconfig *wndconfig, GLXFBConfigID fbconfi
} }
if( wndconfig->glProfile == GLFW_OPENGL_CORE_PROFILE ) if( wndconfig->glProfile == GLFW_OPENGL_CORE_PROFILE )
{
flags = GLX_CONTEXT_CORE_PROFILE_BIT_ARB; flags = GLX_CONTEXT_CORE_PROFILE_BIT_ARB;
}
else else
{
flags = GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB; flags = GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB;
}
setGLXattrib( attribs, index, GLX_CONTEXT_PROFILE_MASK_ARB, flags ); setGLXattrib( attribs, index, GLX_CONTEXT_PROFILE_MASK_ARB, flags );
} }
@ -796,6 +776,7 @@ static GLboolean createWindow( int width, int height,
wamask, wamask,
&wa &wa
); );
if( !_glfwWin.window ) if( !_glfwWin.window )
{ {
_glfwPlatformCloseWindow(); _glfwPlatformCloseWindow();
@ -847,9 +828,7 @@ static GLboolean createWindow( int width, int height,
// Tells the WM to ping our window and flag us as unresponsive if we // Tells the WM to ping our window and flag us as unresponsive if we
// don't reply within a few seconds // don't reply within a few seconds
if( _glfwWin.wmPing != None ) if( _glfwWin.wmPing != None )
{
protocols[count++] = _glfwWin.wmPing; protocols[count++] = _glfwWin.wmPing;
}
if( count > 0 ) if( count > 0 )
{ {
@ -994,9 +973,7 @@ static void enterFullscreenMode( void )
} }
if( _glfwWin.mouseLock ) if( _glfwWin.mouseLock )
{
_glfwPlatformHideMouseCursor(); _glfwPlatformHideMouseCursor();
}
// HACK: Try to get window inside viewport (for virtual displays) by moving // HACK: Try to get window inside viewport (for virtual displays) by moving
// the mouse cursor to the upper left corner (and then to the center) // the mouse cursor to the upper left corner (and then to the center)
@ -1054,10 +1031,8 @@ static void leaveFullscreenMode( void )
} }
if( _glfwWin.mouseLock ) if( _glfwWin.mouseLock )
{
_glfwPlatformShowMouseCursor(); _glfwPlatformShowMouseCursor();
} }
}
//======================================================================== //========================================================================
// Get and process next X event (called by _glfwPlatformPollEvents) // Get and process next X event (called by _glfwPlatformPollEvents)
@ -1121,9 +1096,8 @@ static GLboolean processSingleEvent( void )
// Translate and report character input // Translate and report character input
if( _glfwWin.charCallback ) if( _glfwWin.charCallback )
{
_glfwInputChar( translateChar( &event.xkey ), GLFW_RELEASE ); _glfwInputChar( translateChar( &event.xkey ), GLFW_RELEASE );
}
break; break;
} }
@ -1132,17 +1106,11 @@ static GLboolean processSingleEvent( void )
// A mouse button was pressed or a scrolling event occurred // A mouse button was pressed or a scrolling event occurred
if( event.xbutton.button == Button1 ) if( event.xbutton.button == Button1 )
{
_glfwInputMouseClick( GLFW_MOUSE_BUTTON_LEFT, GLFW_PRESS ); _glfwInputMouseClick( GLFW_MOUSE_BUTTON_LEFT, GLFW_PRESS );
}
else if( event.xbutton.button == Button2 ) else if( event.xbutton.button == Button2 )
{
_glfwInputMouseClick( GLFW_MOUSE_BUTTON_MIDDLE, GLFW_PRESS ); _glfwInputMouseClick( GLFW_MOUSE_BUTTON_MIDDLE, GLFW_PRESS );
}
else if( event.xbutton.button == Button3 ) else if( event.xbutton.button == Button3 )
{
_glfwInputMouseClick( GLFW_MOUSE_BUTTON_RIGHT, GLFW_PRESS ); _glfwInputMouseClick( GLFW_MOUSE_BUTTON_RIGHT, GLFW_PRESS );
}
// XFree86 3.3.2 and later translates mouse wheel up/down into // XFree86 3.3.2 and later translates mouse wheel up/down into
// mouse button 4 & 5 presses // mouse button 4 & 5 presses
@ -1150,18 +1118,14 @@ static GLboolean processSingleEvent( void )
{ {
_glfwInput.WheelPos++; // To verify: is this up or down? _glfwInput.WheelPos++; // To verify: is this up or down?
if( _glfwWin.mouseWheelCallback ) if( _glfwWin.mouseWheelCallback )
{
_glfwWin.mouseWheelCallback( _glfwInput.WheelPos ); _glfwWin.mouseWheelCallback( _glfwInput.WheelPos );
} }
}
else if( event.xbutton.button == Button5 ) else if( event.xbutton.button == Button5 )
{ {
_glfwInput.WheelPos--; _glfwInput.WheelPos--;
if( _glfwWin.mouseWheelCallback ) if( _glfwWin.mouseWheelCallback )
{
_glfwWin.mouseWheelCallback( _glfwInput.WheelPos ); _glfwWin.mouseWheelCallback( _glfwInput.WheelPos );
} }
}
break; break;
} }
@ -1292,9 +1256,7 @@ static GLboolean processSingleEvent( void )
_glfwWin.active = GL_TRUE; _glfwWin.active = GL_TRUE;
if( _glfwWin.mouseLock ) if( _glfwWin.mouseLock )
{
_glfwPlatformHideMouseCursor(); _glfwPlatformHideMouseCursor();
}
break; break;
} }
@ -1307,9 +1269,7 @@ static GLboolean processSingleEvent( void )
_glfwInputDeactivation(); _glfwInputDeactivation();
if( _glfwWin.mouseLock ) if( _glfwWin.mouseLock )
{
_glfwPlatformShowMouseCursor(); _glfwPlatformShowMouseCursor();
}
break; break;
} }
@ -1319,9 +1279,8 @@ static GLboolean processSingleEvent( void )
// The window's contents was damaged // The window's contents was damaged
if( _glfwWin.windowRefreshCallback ) if( _glfwWin.windowRefreshCallback )
{
_glfwWin.windowRefreshCallback(); _glfwWin.windowRefreshCallback();
}
break; break;
} }
@ -1485,9 +1444,7 @@ int _glfwPlatformOpenWindow( int width, int height,
void _glfwPlatformCloseWindow( void ) void _glfwPlatformCloseWindow( void )
{ {
if( _glfwWin.fullscreen ) if( _glfwWin.fullscreen )
{
leaveFullscreenMode(); leaveFullscreenMode();
}
if( _glfwWin.context ) if( _glfwWin.context )
{ {
@ -1582,10 +1539,8 @@ void _glfwPlatformSetWindowSize( int width, int height )
// Set window size (if not already changed) // Set window size (if not already changed)
if( !sizeChanged ) if( !sizeChanged )
{
XResizeWindow( _glfwLibrary.display, _glfwWin.window, width, height ); XResizeWindow( _glfwLibrary.display, _glfwWin.window, width, height );
} }
}
//======================================================================== //========================================================================
@ -1650,10 +1605,8 @@ void _glfwPlatformSwapBuffers( void )
void _glfwPlatformSwapInterval( int interval ) void _glfwPlatformSwapInterval( int interval )
{ {
if( _glfwWin.has_GLX_SGI_swap_control ) if( _glfwWin.has_GLX_SGI_swap_control )
{
_glfwWin.SwapIntervalSGI( interval ); _glfwWin.SwapIntervalSGI( interval );
} }
}
//======================================================================== //========================================================================
@ -1719,13 +1672,9 @@ void _glfwPlatformRefreshWindowParams( void )
// Get FSAA buffer sample count // Get FSAA buffer sample count
if( _glfwWin.has_GLX_ARB_multisample ) if( _glfwWin.has_GLX_ARB_multisample )
{
_glfwWin.samples = getFBConfigAttrib( *fbconfig, GLX_SAMPLES ); _glfwWin.samples = getFBConfigAttrib( *fbconfig, GLX_SAMPLES );
}
else else
{
_glfwWin.samples = 0; _glfwWin.samples = 0;
}
// Default to refresh rate unknown (=0 according to GLFW spec) // Default to refresh rate unknown (=0 according to GLFW spec)
_glfwWin.refreshRate = 0; _glfwWin.refreshRate = 0;
@ -1769,10 +1718,8 @@ void _glfwPlatformPollEvents( void )
while( XPending( _glfwLibrary.display ) ) while( XPending( _glfwLibrary.display ) )
{ {
if( processSingleEvent() ) if( processSingleEvent() )
{
closeRequested = GL_TRUE; closeRequested = GL_TRUE;
} }
}
// Did we get mouse movement in fully enabled hidden cursor mode? // Did we get mouse movement in fully enabled hidden cursor mode?
if( _glfwInput.MouseMoved && _glfwWin.pointerHidden ) if( _glfwInput.MouseMoved && _glfwWin.pointerHidden )
@ -1782,14 +1729,11 @@ void _glfwPlatformPollEvents( void )
} }
if( closeRequested && _glfwWin.windowCloseCallback ) if( closeRequested && _glfwWin.windowCloseCallback )
{
closeRequested = _glfwWin.windowCloseCallback(); closeRequested = _glfwWin.windowCloseCallback();
}
if( closeRequested ) if( closeRequested )
{
glfwCloseWindow(); glfwCloseWindow();
} }
}
//======================================================================== //========================================================================