#ifndef FREEGLUT_INTERNAL_H
#define FREEGLUT_INTERNAL_H
+#if HAVE_CONFIG_H
+# include "config.h"
+#endif
+
/* XXX Update these for each release! */
#define VERSION_MAJOR 2
#define VERSION_MINOR 2
#include <string.h>
#include <math.h>
#include <stdlib.h>
-#include <assert.h>
-#include <stdarg.h>
-#if TARGET_HOST_UNIX_X11
-#include <unistd.h>
-#include <sys/time.h>
+#if HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+#if HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+#if TIME_WITH_SYS_TIME
+# include <sys/time.h>
+# include <time.h>
+#else
+# if HAVE_SYS_TIME_H
+# include <sys/time.h>
+# else
+# include <time.h>
+# endif
#endif
/* The system-dependant include files should go here: */
typedef struct tagSFG_Time SFG_Time;
struct tagSFG_Time
{
-#ifdef WIN32
+#if TARGET_HOST_WIN32 || TARGET_HOST_WINCE
DWORD Value;
#else
struct timeval Value;
fgExecutionState ExecState; /* Used for GLUT termination */
char *ProgramName; /* Name of the invoking program */
+ GLboolean JoysticksInitialised; /* Only initialize if application calls for them */
};
/* The structure used by display initialization in freeglut_init.c */
/*
+ * A generic function pointer. We should really use the GLUTproc type
+ * defined in freeglut_ext.h, but if we include that header in this file
+ * a bunch of other stuff (font-related) blows up!
+ */
+typedef void (*SFG_Proc)();
+
+
+/*
* SET_WCB() is used as:
*
- * SET_WCB( window, Visibility, func );
+ * SET_WCB( window, cbname, func );
*
* ...where {window} is the freeglut window to set the callback,
- * {Visibility} is the window-specific callback to set,
+ * {cbname} is the window-specific callback to set,
* {func} is a function-pointer.
*
* Originally, {FETCH_WCB( ... ) = func} was rather sloppily used,
do \
{ \
if( FETCH_WCB( window, cbname ) != func ) \
- (((window).CallBacks[CB_ ## cbname]) = (void *) func); \
-} while( 0 ) \
+ (((window).CallBacks[CB_ ## cbname]) = (SFG_Proc) func); \
+} while( 0 )
/*
* FETCH_WCB() is used as:
*
- * FETCH_WCB( window, Visibility );
+ * FETCH_WCB( window, cbname );
*
* ...where {window} is the freeglut window to fetch the callback from,
- * {Visibility} is the window-specific callback to fetch.
+ * {cbname} is the window-specific callback to fetch.
*
* The result is correctly type-cast to the callback function pointer
* type.
*/
#define FETCH_WCB(window,cbname) \
- ((FGCB ## cbname)((window).CallBacks[CB_ ## cbname]))
+ ((window).CallBacks[CB_ ## cbname])
/*
* INVOKE_WCB() is used as:
*
- * INVOKE_WCB( window, Visibility, ( status ) );
+ * INVOKE_WCB( window, cbname, ( arg_list ) );
*
* ...where {window} is the freeglut window,
- * {Visibility} is the window-specific callback,
- * {(status)} is the parameter list.
+ * {cbname} is the window-specific callback to be invoked,
+ * {(arg_list)} is the parameter list.
*
* The callback is invoked as:
*
- * callback( status );
+ * callback( arg_list );
*
* ...so the parentheses are REQUIRED in the {arg_list}.
*
* current window.
*
*/
+#if TARGET_HOST_WIN32
+#define INVOKE_WCB(window,cbname,arg_list) \
+do \
+{ \
+ if( FETCH_WCB( window, cbname ) ) \
+ { \
+ FGCB ## cbname func = (FGCB ## cbname)(FETCH_WCB( window, cbname )); \
+ fgSetWindow( &window ); \
+ func arg_list; \
+ } \
+} while( 0 )
+#else
#define INVOKE_WCB(window,cbname,arg_list) \
do \
{ \
if( FETCH_WCB( window, cbname ) ) \
{ \
fgSetWindow( &window ); \
- FETCH_WCB( window, cbname ) arg_list; \
+ ((FGCB ## cbname)FETCH_WCB( window, cbname )) arg_list; \
} \
} while( 0 )
+#endif
/*
* The window callbacks the user can supply us with. Should be kept portable.
SFG_MenuEntry *ActiveEntry; /* Currently active entry in the menu */
SFG_Window *Window; /* Window for menu */
- SFG_Window *ParentWindow; /* Window in which the menu is defined */
+ SFG_Window *ParentWindow; /* Window in which the menu is invoked */
};
/* This is a menu entry */
SFG_Context Window; /* Window and OpenGL context */
SFG_WindowState State; /* The window state */
- void *CallBacks[ TOTAL_CALLBACKS ]; /* Array of window callbacks */
+ SFG_Proc CallBacks[ TOTAL_CALLBACKS ]; /* Array of window callbacks */
void *UserData ; /* For use by user */
SFG_Menu* Menu[ FREEGLUT_MAX_MENUS ]; /* Menus appended to window */
SFG_List Menus; /* The global menus list */
SFG_List WindowsToDestroy;
- SFG_Window* Window; /* The currently active win. */
- SFG_Menu* Menu; /* Same, but menu... */
+ SFG_Window* CurrentWindow; /* The currently set window */
+ SFG_Menu* CurrentMenu; /* Same, but menu... */
SFG_MenuContext* MenuContext; /* OpenGL rendering context for menus */
* A call to this function makes us sure that the Display and Structure
* subsystems have been properly initialized and are ready to be used
*/
-#define freeglut_assert_ready assert( fgState.Initialised );
+#define FREEGLUT_EXIT_IF_NOT_INITIALISED( string ) \
+ if ( ! fgState.Initialised ) \
+ { \
+ fgError ( " ERROR: Function <%s> called" \
+ " without first calling 'glutInit'.", (string) ) ; \
+ }
+
+#define FREEGLUT_INTERNAL_ERROR_EXIT_IF_NOT_INITIALISED( string ) \
+ if ( ! fgState.Initialised ) \
+ { \
+ fgError ( " ERROR: Internal <%s> function called" \
+ " without first calling 'glutInit'.", (string) ) ; \
+ }
+
+#define FREEGLUT_INTERNAL_ERROR_EXIT( cond, string, function ) \
+ if ( ! ( cond ) ) \
+ { \
+ fgError ( " ERROR: Internal error <%s> in function %s", \
+ (string), (function) ) ; \
+ }
/*
* Following definitions are somewhat similiar to GLib's,
/*
* A call to those macros assures us that there is a current
- * window and menu set, respectively:
+ * window set, respectively:
*/
-#define freeglut_assert_window assert( fgStructure.Window != NULL );
-#define freeglut_assert_menu assert( fgStructure.Menu != NULL );
+#define FREEGLUT_EXIT_IF_NO_WINDOW( string ) \
+ if ( ! fgStructure.CurrentWindow ) \
+ { \
+ fgError ( " ERROR: Function <%s> called" \
+ " with no current window defined.", (string) ) ; \
+ }
/*
- * The initialize and deinitialize functions get called on glutInit()
- * and glutMainLoop() end respectively. They should create/clean up
+ * The deinitialize function gets called on glutMainLoop() end. It should clean up
* everything inside of the freeglut
*/
-void fgInitialize( const char* displayName );
void fgDeinitialize( void );
/*
void fgAddToWindowDestroyList ( SFG_Window* window );
void fgCloseWindows ();
void fgDestroyWindow( SFG_Window* window );
-void fgClearCallBacks( SFG_Window *window );
/* Menu creation and destruction. Defined in freeglut_structure.c */
SFG_Menu* fgCreateMenu( FGCBMenu menuCallback );
void fgDestroyMenu( SFG_Menu* menu );
/* Joystick device management functions, defined in freeglut_joystick.c */
-void fgJoystickInit( int ident );
+int fgJoystickDetect( void );
+void fgInitialiseJoysticks( void );
void fgJoystickClose( void );
void fgJoystickPollWindow( SFG_Window* window );
+/* More joystick functions. Should these go into the API? */
+int glutJoystickGetNumAxes( int ident );
+int glutJoystickGetNumButtons( int ident );
+int glutJoystickNotWorking( int ident );
+
+/* Setting the cursor for a given window */
+void fgSetCursor ( SFG_Window *window, int cursorID );
+
/*
* Helper function to enumerate through all registered windows
* and one to enumerate all of a window's subwindows...
* The menu activation and deactivation the code. This is the meat
* of the menu user interface handling code...
*/
-void fgActivateMenu( SFG_Window* window, int button );
-void fgExecuteMenuCallback( SFG_Menu* menu );
-GLboolean fgCheckActiveMenu ( SFG_Window *window, SFG_Menu *menu );
+GLboolean fgCheckActiveMenu ( SFG_Window *window, int button, GLboolean pressed,
+ int mouse_x, int mouse_y );
void fgDeactivateMenu( SFG_Window *window );
-void fgDeactivateSubMenu( SFG_MenuEntry *menuEntry );
/*
* This function gets called just before the buffers swap, so that
*/
void fgDisplayMenu( void );
-/*
- * Display the mouse cursor using OpenGL calls. The function
- * is defined in freeglut_cursor.c file.
- */
-void fgDisplayCursor( void );
-
/* Elapsed time as per glutGet(GLUT_ELAPSED_TIME). */
long fgElapsedTime( void );
projects / freeglut / blobdiff