#define G_LOG_DOMAIN "freeglut-state"
#include "../include/GL/freeglut.h"
-#include "../include/GL/freeglut_internal.h"
+#include "freeglut_internal.h"
/*
* TODO BEFORE THE STABLE RELEASE:
*/
int FGAPIENTRY glutGet( GLenum eWhat )
{
- int returnValue ;
- GLboolean boolValue ;
+ int returnValue ;
+ GLboolean boolValue ;
+
+ if ( eWhat == GLUT_INIT_STATE )
+ return ( fgState.Time.Set ) ;
+
freeglut_assert_ready;
/*
*/
case GLUT_WINDOW_X:
case GLUT_WINDOW_Y:
- {
- XWindowAttributes winAttributes;
- Window another, window;
- int x, y;
-
- /*
- * Return zero if there is no current window set
- */
- if( fgStructure.Window == NULL )
- return( 0 );
-
- /*
- * So, grab the current window's position
- */
- window = fgStructure.Window->Window.Handle;
-
- /*
- * Grab the current window's attributes now
- */
- XGetWindowAttributes(
- fgDisplay.Display,
- window,
- &winAttributes
- );
-
- /*
- * Correct the results for the parental relation and border size
- */
- XTranslateCoordinates(
- fgDisplay.Display,
- window,
- winAttributes.root,
- -winAttributes.border_width,
- -winAttributes.border_width,
- &x, &y,
- &another
- );
-
- /*
- * See if we have to return the X or Y coordinate
- */
- return( eWhat == GLUT_WINDOW_X ? x : y );
- }
-
case GLUT_WINDOW_WIDTH:
case GLUT_WINDOW_HEIGHT:
+ case GLUT_WINDOW_BORDER_WIDTH :
+ case GLUT_WINDOW_HEADER_HEIGHT :
{
XWindowAttributes winAttributes;
return( 0 );
/*
- * Checking for window's size is much easier:
+ * Grab the current window's attributes now
*/
XGetWindowAttributes(
fgDisplay.Display,
);
/*
- * See if to return the window's width or height
+ * See which window attribute to return
*/
- return( eWhat == GLUT_WINDOW_WIDTH ? winAttributes.width : winAttributes.height );
+ 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 */
+ }
}
/*
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.
+ */
+
RECT winRect;
/*
/*
* We need to call GetWindowRect() first...
+ * (this returns the pixel coordinates of the outside of the window)
*/
GetWindowRect( fgStructure.Window->Window.Handle, &winRect );
/*
* ...then we've got to correct the results we've just received...
*/
- winRect.left += GetSystemMetrics( SM_CXSIZEFRAME ) - 1;
- winRect.right -= GetSystemMetrics( SM_CXSIZEFRAME ) - 1;
- winRect.top += GetSystemMetrics( SM_CYSIZEFRAME ) - 1 + GetSystemMetrics( SM_CYCAPTION );
- winRect.bottom -= GetSystemMetrics( SM_CYSIZEFRAME ) + 1;
+ if ( fgStructure.Window->Parent == NULL )
+ {
+ winRect.left += GetSystemMetrics( SM_CXSIZEFRAME );
+ winRect.right -= GetSystemMetrics( SM_CXSIZEFRAME );
+ winRect.top += GetSystemMetrics( SM_CYSIZEFRAME ) + GetSystemMetrics( SM_CYCAPTION );
+ winRect.bottom -= GetSystemMetrics( SM_CYSIZEFRAME );
+ }
/*
* ...and finally return the caller the desired value:
}
break;
+ case GLUT_WINDOW_BORDER_WIDTH :
+ return ( GetSystemMetrics( SM_CXSIZEFRAME ) ) ;
+
+ case GLUT_WINDOW_HEADER_HEIGHT :
+ return ( GetSystemMetrics( SM_CYCAPTION ) ) ;
+
case GLUT_DISPLAY_MODE_POSSIBLE:
/*
* Check if the current display mode is possible
*/
- return( fgSetupPixelFormat( fgStructure.Window, TRUE ) );
+ return( fgSetupPixelFormat( fgStructure.Window, TRUE, PFD_MAIN_PLANE ) );
case GLUT_WINDOW_FORMAT_ID:
/*
return( fgListLength( &fgStructure.Menu->Entries ) );
- case GLUT_ACTION_ON_WINDOW_CLOSE: return ( fgState.ActionOnWindowClose ) ;
+ case GLUT_ACTION_ON_WINDOW_CLOSE:
+ return fgState.ActionOnWindowClose;
+
+ case GLUT_VERSION:
+ return VERSION_MAJOR * 10000 + VERSION_MINOR * 100 + VERSION_PATCH;
default:
/*
*/
switch( eWhat )
{
+
+#if TARGET_HOST_UNIX_X11
+
case GLUT_OVERLAY_POSSIBLE:
/*
* Nope, overlays are not possible.
*/
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 ) );
+
+ 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
+ */
+ return( 0 );
+
+ case GLUT_NORMAL_DAMAGED:
+ /*
+ * 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
projects / freeglut / blobdiff