X-Git-Url: http://git.mutantstargoat.com/user/nuclear/?a=blobdiff_plain;f=src%2Ffreeglut_state.c;h=0ddceaf706ee97071c6943bd2bab037bc16d4497;hb=d0632564dbd8662418d6820dc17f5f6b237d788b;hp=3dbc4bbc82cebdb049f25b74039bce8250074e09;hpb=fe89df7de1aa6a732a441e983cce03e1fd6fd81a;p=freeglut diff --git a/src/freeglut_state.c b/src/freeglut_state.c index 3dbc4bb..0ddceaf 100644 --- a/src/freeglut_state.c +++ b/src/freeglut_state.c @@ -29,16 +29,16 @@ #include "config.h" #endif -#define G_LOG_DOMAIN "freeglut-state" - #include "../include/GL/freeglut.h" #include "freeglut_internal.h" /* * TODO BEFORE THE STABLE RELEASE: * - * glutGet() -- X11 tests passed, but check if all enums handled (what about Win32?) - * glutDeviceGet() -- X11 tests passed, but check if all enums handled (what about Win32?) + * glutGet() -- X11 tests passed, but check if all enums + * handled (what about Win32?) + * glutDeviceGet() -- X11 tests passed, but check if all enums + * handled (what about Win32?) * glutGetModifiers() -- OK, but could also remove the limitation * glutLayerGet() -- what about GLUT_NORMAL_DAMAGED? * @@ -55,24 +55,13 @@ */ static int fghGetConfig( int attribute ) { - int returnValue ; + int returnValue = 0; - /* - * Return nothing if there is no current window set - */ - if( fgStructure.Window == NULL ) - return( 0 ); + if( fgStructure.Window ) + glXGetConfig( fgDisplay.Display, fgStructure.Window->Window.VisualInfo, + attribute, &returnValue ); - /* - * glXGetConfig should work fine - */ - glXGetConfig( fgDisplay.Display, fgStructure.Window->Window.VisualInfo, attribute, &returnValue ); - - - /* - * Have the query results returned - */ - return ( returnValue ) ; + return returnValue; } #endif @@ -86,35 +75,45 @@ void FGAPIENTRY glutSetOption( GLenum eWhat, int value ) freeglut_assert_ready; /* - * Check what is the caller querying for. In chronological code add order. + * XXX In chronological code add order. (WHY in that order?) */ switch( eWhat ) { - case GLUT_INIT_WINDOW_X: fgState.Position.X = (GLint)value ; - break ; - case GLUT_INIT_WINDOW_Y: fgState.Position.Y = (GLint)value ; - break ; - case GLUT_INIT_WINDOW_WIDTH: fgState.Size.X = (GLint)value ; - break ; - case GLUT_INIT_WINDOW_HEIGHT: fgState.Size.Y = (GLint)value ; - break ; - case GLUT_INIT_DISPLAY_MODE: fgState.DisplayMode = (unsigned int)value ; - break ; - - case GLUT_ACTION_ON_WINDOW_CLOSE: fgState.ActionOnWindowClose = value ; - break ; - - case GLUT_RENDERING_CONTEXT: fgState.UseCurrentContext = ( value == GLUT_USE_CURRENT_CONTEXT ) ? TRUE : FALSE ; - break ; + case GLUT_INIT_WINDOW_X: + fgState.Position.X = (GLint)value; + break; + + case GLUT_INIT_WINDOW_Y: + fgState.Position.Y = (GLint)value; + break; + + case GLUT_INIT_WINDOW_WIDTH: + fgState.Size.X = (GLint)value; + break; + + case GLUT_INIT_WINDOW_HEIGHT: + fgState.Size.Y = (GLint)value; + break; + + case GLUT_INIT_DISPLAY_MODE: + fgState.DisplayMode = (unsigned int)value; + break; + + case GLUT_ACTION_ON_WINDOW_CLOSE: + fgState.ActionOnWindowClose = value; + break; + + case GLUT_RENDERING_CONTEXT: + fgState.UseCurrentContext = + ( value == GLUT_USE_CURRENT_CONTEXT ) ? TRUE : FALSE; + break; case GLUT_WINDOW_CURSOR: - if( fgStructure.Window != NULL ) fgStructure.Window->State.Cursor = value ; - break ; + if( fgStructure.Window != NULL ) + fgStructure.Window->State.Cursor = value; + break; default: - /* - * Just have it reported, so that we can see what needs to be implemented - */ fgWarning( "glutSetOption(): missing enum handle %i\n", eWhat ); break; } @@ -125,25 +124,25 @@ void FGAPIENTRY glutSetOption( GLenum eWhat, int value ) */ int FGAPIENTRY glutGet( GLenum eWhat ) { - int returnValue ; - GLboolean boolValue ; + int returnValue ; + GLboolean boolValue ; - if ( eWhat == GLUT_INIT_STATE ) - return ( fgState.Time.Set ) ; + switch (eWhat) + { + case GLUT_INIT_STATE: + return ( fgState.Initalized ) ; + + case GLUT_ELAPSED_TIME: + return( fgElapsedTime() ); + } freeglut_assert_ready; /* - * Check what is the caller querying for. In chronological code add order. + * XXX In chronological code add order. (WHY in that order?) */ switch( eWhat ) { - case GLUT_ELAPSED_TIME: - /* - * This is easy and nicely portable, as we are using GLib... - */ - return( fgElapsedTime() ); - /* * Following values are stored in fgState and fgDisplay global structures */ @@ -158,17 +157,19 @@ int FGAPIENTRY glutGet( GLenum eWhat ) case GLUT_INIT_DISPLAY_MODE: return( fgState.DisplayMode ); /* - * The window/context specific queries are handled mostly by fghGetConfig(). + * The window/context specific queries are handled mostly by + * fghGetConfig(). */ case GLUT_WINDOW_NUM_SAMPLES: /* - * Multisampling. Return what I know about multisampling. + * XXX Multisampling. Return what I know about multisampling. */ return( 0 ); #if TARGET_HOST_UNIX_X11 /* - * The rest of GLX queries under X are general enough to use a macro to check them + * The rest of GLX queries under X are general enough to use a macro to + * check them */ # define GLX_QUERY(a,b) case a: return( fghGetConfig( b ) ); @@ -193,9 +194,6 @@ int FGAPIENTRY glutGet( GLenum eWhat ) * Colormap size is handled in a bit different way than all the rest */ case GLUT_WINDOW_COLORMAP_SIZE: - /* - * Check for the visual type - */ if( (fghGetConfig( GLX_RGBA )) || (fgStructure.Window == NULL) ) { /* @@ -204,50 +202,65 @@ int FGAPIENTRY glutGet( GLenum eWhat ) */ return( 0 ); } - - /* - * Otherwise return the number of entries in the colormap - */ return( fgStructure.Window->Window.VisualInfo->visual->map_entries ); /* - * Those calls are somewhat similiar, as they use XGetWindowAttributes() function + * Those calls are somewhat similiar, as they use XGetWindowAttributes() + * function */ case GLUT_WINDOW_X: case GLUT_WINDOW_Y: + case GLUT_WINDOW_BORDER_WIDTH: + case GLUT_WINDOW_HEADER_HEIGHT: + { + int x, y; + Window w; + + if( fgStructure.Window == NULL ) + return( 0 ); + + XTranslateCoordinates( + fgDisplay.Display, + fgStructure.Window->Window.Handle, + fgDisplay.RootWindow, + 0, 0, &x, &y, &w); + + switch ( eWhat ) + { + case GLUT_WINDOW_X: return x; + case GLUT_WINDOW_Y: return y; + } + + if ( w == 0 ) + return( 0 ); + XTranslateCoordinates( + fgDisplay.Display, + fgStructure.Window->Window.Handle, + w, 0, 0, &x, &y, &w); + + switch ( eWhat ) + { + case GLUT_WINDOW_BORDER_WIDTH: return x; + case GLUT_WINDOW_HEADER_HEIGHT: return y; + } + } + case GLUT_WINDOW_WIDTH: case GLUT_WINDOW_HEIGHT: - case GLUT_WINDOW_BORDER_WIDTH : - case GLUT_WINDOW_HEADER_HEIGHT : { XWindowAttributes winAttributes; - /* - * Return zero if there is no current window set - */ if( fgStructure.Window == NULL ) return( 0 ); - - /* - * Grab the current window's attributes now - */ XGetWindowAttributes( fgDisplay.Display, fgStructure.Window->Window.Handle, &winAttributes ); - - /* - * See which window attribute to return - */ switch ( eWhat ) { - case GLUT_WINDOW_X: return winAttributes.x ; - case GLUT_WINDOW_Y: return winAttributes.y ; case GLUT_WINDOW_WIDTH: return winAttributes.width ; case GLUT_WINDOW_HEIGHT: return winAttributes.height ; - case GLUT_WINDOW_BORDER_WIDTH : return winAttributes.border_width ; - case GLUT_WINDOW_HEADER_HEIGHT : return winAttributes.border_width * 3 ; /* a kludge for now */ } } @@ -255,18 +268,12 @@ int FGAPIENTRY glutGet( GLenum eWhat ) * I do not know yet if there will be a fgChooseVisual() function for Win32 */ case GLUT_DISPLAY_MODE_POSSIBLE: - /* - * Check if the current display mode is possible - */ return( fgChooseVisual() == NULL ? 0 : 1 ); /* * This is system-dependant */ case GLUT_WINDOW_FORMAT_ID: - /* - * Return the visual ID, if there is a current window naturally: - */ if( fgStructure.Window == NULL ) return( 0 ); @@ -278,44 +285,44 @@ int FGAPIENTRY glutGet( GLenum eWhat ) * Handle the OpenGL inquiries */ case GLUT_WINDOW_RGBA: - glGetBooleanv ( GL_RGBA_MODE, &boolValue ) ; /* True if color buffers store RGBA */ + glGetBooleanv ( GL_RGBA_MODE, &boolValue ) ; returnValue = boolValue ? 1 : 0 ; return ( returnValue ) ; case GLUT_WINDOW_DOUBLEBUFFER: - glGetBooleanv ( GL_DOUBLEBUFFER, &boolValue ) ; /* True if front and back buffers exist */ + glGetBooleanv ( GL_DOUBLEBUFFER, &boolValue ) ; returnValue = boolValue ? 1 : 0 ; return ( returnValue ) ; case GLUT_WINDOW_STEREO: - glGetBooleanv ( GL_STEREO, &boolValue ) ; /* True if left and right buffers exist */ + glGetBooleanv ( GL_STEREO, &boolValue ) ; returnValue = boolValue ? 1 : 0 ; return ( returnValue ) ; case GLUT_WINDOW_RED_SIZE: - glGetIntegerv ( GL_RED_BITS, &returnValue ) ; /* Number of bits per red component in color buffers */ + glGetIntegerv ( GL_RED_BITS, &returnValue ) ; return ( returnValue ) ; case GLUT_WINDOW_GREEN_SIZE: - glGetIntegerv ( GL_GREEN_BITS, &returnValue ) ; /* Number of bits per green component in color buffers */ + glGetIntegerv ( GL_GREEN_BITS, &returnValue ) ; return ( returnValue ) ; case GLUT_WINDOW_BLUE_SIZE: - glGetIntegerv ( GL_BLUE_BITS, &returnValue ) ; /* Number of bits per blue component in color buffers */ + glGetIntegerv ( GL_BLUE_BITS, &returnValue ) ; return ( returnValue ) ; case GLUT_WINDOW_ALPHA_SIZE: - glGetIntegerv ( GL_ALPHA_BITS, &returnValue ) ; /* Number of bits per alpha component in color buffers */ + glGetIntegerv ( GL_ALPHA_BITS, &returnValue ) ; return ( returnValue ) ; case GLUT_WINDOW_ACCUM_RED_SIZE: - glGetIntegerv ( GL_ACCUM_RED_BITS, &returnValue ) ; /* Number of bits per red component in the accumulation buffer */ + glGetIntegerv ( GL_ACCUM_RED_BITS, &returnValue ) ; return ( returnValue ) ; case GLUT_WINDOW_ACCUM_GREEN_SIZE: - glGetIntegerv ( GL_ACCUM_GREEN_BITS, &returnValue ) ; /* Number of bits per green component in the accumulation buffer */ + glGetIntegerv ( GL_ACCUM_GREEN_BITS, &returnValue ) ; return ( returnValue ) ; case GLUT_WINDOW_ACCUM_BLUE_SIZE: - glGetIntegerv ( GL_ACCUM_BLUE_BITS, &returnValue ) ; /* Number of bits per blue component in the accumulation buffer */ + glGetIntegerv ( GL_ACCUM_BLUE_BITS, &returnValue ) ; return ( returnValue ) ; case GLUT_WINDOW_ACCUM_ALPHA_SIZE: - glGetIntegerv ( GL_ACCUM_ALPHA_BITS, &returnValue ) ; /* Number of bits per alpha component in the accumulation buffer */ + glGetIntegerv ( GL_ACCUM_ALPHA_BITS, &returnValue ) ; return ( returnValue ) ; case GLUT_WINDOW_DEPTH_SIZE: - glGetIntegerv ( GL_DEPTH_BITS, &returnValue ) ; /* Number of depth-buffer bitplanes */ + glGetIntegerv ( GL_DEPTH_BITS, &returnValue ) ; return ( returnValue ) ; case GLUT_WINDOW_BUFFER_SIZE: @@ -325,37 +332,37 @@ int FGAPIENTRY glutGet( GLenum eWhat ) returnValue = 0 ; /* ????? */ return ( returnValue ) ; - /* - * Window position and size - */ case GLUT_WINDOW_X: case GLUT_WINDOW_Y: case GLUT_WINDOW_WIDTH: case GLUT_WINDOW_HEIGHT: { /* - * There is considerable confusion about the "right thing to do" concerning window - * size and position. GLUT itself is not consistent between Windows and Linux; since - * platform independence is a virtue for "freeglut", we decided to break with GLUT's - * behaviour. - * Under Linux, it is apparently not possible to get the window border sizes in order - * to subtract them off the window's initial position until some time after the window - * has been created. Therefore we decided on the following behaviour, both under - * Windows and under Linux: - * - When you create a window with position (x,y) and size (w,h), the upper left hand - * corner of the outside of the window is at (x,y) and the size of the drawable area - * is (w,h). - * - When you query the size and position of the window--as is happening here for - * Windows--"freeglut" will return the size of the drawable area--the (w,h) that you - * specified when you created the window--and the coordinates of the upper left hand - * corner of the drawable area--which is NOT the (x,y) you specified. + * There is considerable confusion about the "right thing to + * do" concerning window size and position. GLUT itself is + * not consistent between Windows and UNIX/X11; since + * platform independence is a virtue for "freeglut", we + * decided to break with GLUT's behaviour. + * + * Under UNIX/X11, it is apparently not possible to get the + * window border sizes in order to subtract them off the + * window's initial position until some time after the window + * has been created. Therefore we decided on the following + * behaviour, both under Windows and under UNIX/X11: + * - When you create a window with position (x,y) and size + * (w,h), the upper left hand corner of the outside of the + * window is at (x,y) and the size of the drawable area is + * (w,h). + * - When you query the size and position of the window--as + * is happening here for Windows--"freeglut" will return + * the size of the drawable area--the (w,h) that you + * specified when you created the window--and the coordinates + * of the upper left hand corner of the drawable + * area--which is NOT the (x,y) you specified. */ RECT winRect; - /* - * Check if there is a window to be queried for dimensions: - */ freeglut_return_val_if_fail( fgStructure.Window != NULL, 0 ); /* @@ -376,9 +383,6 @@ int FGAPIENTRY glutGet( GLenum eWhat ) winRect.bottom -= GetSystemMetrics( SM_CYSIZEFRAME ); } - /* - * ...and finally return the caller the desired value: - */ switch( eWhat ) { case GLUT_WINDOW_X: return( winRect.left ); @@ -396,21 +400,11 @@ int FGAPIENTRY glutGet( GLenum eWhat ) return ( GetSystemMetrics( SM_CYCAPTION ) ) ; case GLUT_DISPLAY_MODE_POSSIBLE: - /* - * Check if the current display mode is possible - */ return( fgSetupPixelFormat( fgStructure.Window, TRUE, PFD_MAIN_PLANE ) ); case GLUT_WINDOW_FORMAT_ID: - /* - * Return the pixel format of the current window - */ if( fgStructure.Window != NULL ) return( GetPixelFormat( fgStructure.Window->Window.Device ) ); - - /* - * If the current window does not exist, fail: - */ return( 0 ); #endif @@ -419,39 +413,23 @@ int FGAPIENTRY glutGet( GLenum eWhat ) * The window structure queries */ case GLUT_WINDOW_PARENT: - /* - * Return the ID number of current window's parent, if any - */ if( fgStructure.Window == NULL ) return( 0 ); if( fgStructure.Window->Parent == NULL ) return( 0 ); - return( fgStructure.Window->Parent->ID ); case GLUT_WINDOW_NUM_CHILDREN: - /* - * Return the number of children attached to the current window - */ if( fgStructure.Window == NULL ) return( 0 ); - return( fgListLength( &fgStructure.Window->Children ) ); case GLUT_WINDOW_CURSOR: - /* - * Return the currently selected window cursor - */ if( fgStructure.Window == NULL ) return( 0 ); - return( fgStructure.Window->State.Cursor ); case GLUT_MENU_NUM_ITEMS: - /* - * Return the number of menu entries in the current menu - */ if( fgStructure.Menu == NULL ) return( 0 ); - return( fgListLength( &fgStructure.Menu->Entries ) ); case GLUT_ACTION_ON_WINDOW_CLOSE: @@ -464,16 +442,9 @@ int FGAPIENTRY glutGet( GLenum eWhat ) return ( fgState.UseCurrentContext ? GLUT_USE_CURRENT_CONTEXT : GLUT_CREATE_NEW_CONTEXT ) ; default: - /* - * Just have it reported, so that we can see what needs to be implemented - */ fgWarning( "glutGet(): missing enum handle %i\n", eWhat ); break; } - - /* - * If nothing happens, then we are in deep trouble... - */ return( -1 ); } @@ -485,29 +456,46 @@ int FGAPIENTRY glutDeviceGet( GLenum eWhat ) freeglut_assert_ready; /* - * See why are we bothered... - * - * WARNING: we are mostly lying in this function. + * XXX WARNING: we are mostly lying in this function. */ switch( eWhat ) { case GLUT_HAS_KEYBOARD: /* * We always have a keyboard present on PC machines... + * + * XXX I think that some of my PCs will boot without a keyboard. + * XXX Also, who says that we are running on a PC? UNIX/X11 + * XXX is much more generic, and X11 can go over a network. + * XXX Though in actuality, we can probably assume BOTH a + * XXX mouse and keyboard for most/all of our users. */ return( TRUE ); #if TARGET_HOST_UNIX_X11 case GLUT_HAS_MOUSE: - /* - * Hey, my Atari 65XE hasn't had a mouse! - */ return( TRUE ); case GLUT_NUM_MOUSE_BUTTONS: /* * Return the number of mouse buttons available. This is a big guess. + * + * XXX We can probe /var/run/dmesg.boot which is world-readable. + * XXX This would be somewhat system-dependant, but is doable. + * XXX E.g., on NetBSD, my USB mouse registers: + * XXX ums0 at uhidev0: 3 buttons and Z dir. + * XXX We can also probe /var/log/XFree86\..*\.log to get + * XXX lines such as: + * XXX (**) Option "Buttons" "5" + * XXX (**) Option "ZAxisMapping" "4 5" + * XXX (**) Mouse0: ZAxisMapping: buttons 4 and 5 + * XXX (**) Mouse0: Buttons: 5 + * XXX ...which tells us even more, and is a bit less + * XXX system-dependant. (Other than MS-WINDOWS, all + * XXX target hosts with actual users are probably running + * XXX XFree86...) It is at least worth taking a look at + * XXX this file. */ return( 3 ); @@ -533,43 +521,31 @@ int FGAPIENTRY glutDeviceGet( GLenum eWhat ) case GLUT_JOYSTICK_BUTTONS: case GLUT_JOYSTICK_AXES: /* - * WARNING: THIS IS A BIG LIE! + * XXX WARNING: THIS IS A BIG LIE! */ return( 0 ); case GLUT_HAS_SPACEBALL: case GLUT_HAS_DIAL_AND_BUTTON_BOX: case GLUT_HAS_TABLET: - /* - * Sounds cool. And unuseful. - */ return( FALSE ); case GLUT_NUM_SPACEBALL_BUTTONS: case GLUT_NUM_BUTTON_BOX_BUTTONS: case GLUT_NUM_DIALS: case GLUT_NUM_TABLET_BUTTONS: - /* - * Zero is not the answer. Zero is the question. Continuum is the answer. - */ return( 0 ); case GLUT_DEVICE_IGNORE_KEY_REPEAT: - /* - * Return what we think about the key auto repeat settings - */ return( fgState.IgnoreKeyRepeat ); case GLUT_DEVICE_KEY_REPEAT: /* - * WARNING: THIS IS A BIG LIE! + * XXX WARNING: THIS IS A BIG LIE! */ return( GLUT_KEY_REPEAT_DEFAULT ); default: - /* - * Complain. - */ fgWarning( "glutDeviceGet(): missing enum handle %i\n", eWhat ); break; } @@ -585,9 +561,6 @@ int FGAPIENTRY glutDeviceGet( GLenum eWhat ) */ int FGAPIENTRY glutGetModifiers( void ) { - /* - * Fail if there is no current window or called outside an input callback - */ if( fgStructure.Window == NULL ) return( 0 ); @@ -597,9 +570,6 @@ int FGAPIENTRY glutGetModifiers( void ) return( 0 ); } - /* - * Return the current modifiers state otherwise - */ return( fgStructure.Window->State.Modifiers ); } @@ -612,6 +582,9 @@ int FGAPIENTRY glutLayerGet( GLenum eWhat ) /* * This is easy as layers are not implemented ;-) + * + * XXX Can we merge the UNIX/X11 and WIN32 sections? Or + * XXX is overlay support planned? */ switch( eWhat ) { @@ -619,85 +592,62 @@ int FGAPIENTRY glutLayerGet( GLenum eWhat ) #if TARGET_HOST_UNIX_X11 case GLUT_OVERLAY_POSSIBLE: - /* - * Nope, overlays are not possible. - */ return( FALSE ); case GLUT_LAYER_IN_USE: - /* - * The normal plane is always in use - */ return( GLUT_NORMAL ); case GLUT_HAS_OVERLAY: - /* - * No window is allowed to have an overlay - */ return( FALSE ); case GLUT_TRANSPARENT_INDEX: /* * Return just anything, which is always defined as zero + * + * XXX HUH? */ return( 0 ); case GLUT_NORMAL_DAMAGED: /* - * Actually I do not know. Maybe. + * XXX Actually I do not know. Maybe. */ return( FALSE ); case GLUT_OVERLAY_DAMAGED: - /* - * Return minus one to mark that no layer is in use - */ return( -1 ); #elif TARGET_HOST_WIN32 case GLUT_OVERLAY_POSSIBLE: - /* - * Check if an overlay display mode is possible - */ /* return( fgSetupPixelFormat( fgStructure.Window, TRUE, PFD_OVERLAY_PLANE ) ); */ return FALSE ; case GLUT_LAYER_IN_USE: - /* - * The normal plane is always in use - */ return( GLUT_NORMAL ); case GLUT_HAS_OVERLAY: - /* - * No window is allowed to have an overlay - */ return( FALSE ); case GLUT_TRANSPARENT_INDEX: /* * Return just anything, which is always defined as zero + * + * XXX HUH? */ return( 0 ); case GLUT_NORMAL_DAMAGED: /* - * Actually I do not know. Maybe. + * XXX Actually I do not know. Maybe. */ return( FALSE ); case GLUT_OVERLAY_DAMAGED: - /* - * Return minus one to mark that no layer is in use - */ return( -1 ); #endif default: - /* - * Complain to the user about the obvious bug - */ fgWarning( "glutLayerGet(): missing enum handle %i\n", eWhat ); break; }