\r
/* -- PRIVATE FUNCTIONS --------------------------------------------------- */\r
\r
-extern void fghSetCursor ( SFG_Window *window, int cursorID );\r
-extern void fghWarpPointer ( int x, int y );\r
+extern void fgPlatformSetCursor ( SFG_Window *window, int cursorID );\r
+extern void fgPlatformWarpPointer ( int x, int y );\r
\r
#if TARGET_HOST_POSIX_X11 || TARGET_HOST_MAC_OSX || TARGET_HOST_SOLARIS\r
#include <X11/cursorfont.h>\r
{ XC_bottom_left_corner, None } /* GLUT_CURSOR_BOTTOM_LEFT_CORNER */\r
};\r
\r
-static void fghSetCursor ( SFG_Window *window, int cursorID )\r
+static void fgPlatformSetCursor ( SFG_Window *window, int cursorID )\r
{\r
Cursor cursor;\r
/*\r
}\r
\r
\r
-static void fghWarpPointer ( int x, int y )\r
+static void fgPlatformWarpPointer ( int x, int y )\r
{\r
XWarpPointer(\r
fgDisplay.Display,\r
/* -- INTERNAL FUNCTIONS ---------------------------------------------------- */\r
void fgSetCursor ( SFG_Window *window, int cursorID )\r
{\r
- fghSetCursor ( window, cursorID );\r
+ fgPlatformSetCursor ( window, cursorID );\r
}\r
\r
\r
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSetCursor" );\r
FREEGLUT_EXIT_IF_NO_WINDOW ( "glutSetCursor" );\r
\r
- fghSetCursor ( fgStructure.CurrentWindow, cursorID );\r
+ fgPlatformSetCursor ( fgStructure.CurrentWindow, cursorID );\r
fgStructure.CurrentWindow->State.Cursor = cursorID;\r
}\r
\r
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWarpPointer" );\r
FREEGLUT_EXIT_IF_NO_WINDOW ( "glutWarpPointer" );\r
\r
- fghWarpPointer ( x, y );\r
+ fgPlatformWarpPointer ( x, y );\r
}\r
\r
/*** END OF FILE ***/\r
#include "freeglut_internal.h"\r
\r
extern SFG_Proc fghGetProcAddress( const char *procName );\r
-extern GLUTproc fghGetPlatformSpecificGLUTProcAddress( const char *procName );\r
+extern GLUTproc fgPlatformGlutGetProcAddress( const char *procName );\r
\r
static GLUTproc fghGetGLUTProcAddress( const char* procName )\r
{\r
}\r
\r
\r
+static GLUTproc fgPlatformGlutGetProcAddress( const char* procName )\r
+{\r
+ return NULL;\r
+}\r
+\r
+\r
SFG_Proc fghGetProcAddress( const char *procName )\r
{\r
#if defined( GLX_ARB_get_proc_address )\r
\r
/* Some GLUT functions are platform-specific: */\r
if ( !p )\r
- p = fghGetPlatformSpecificGLUTProcAddress( procName );\r
+ p = fgPlatformGlutGetProcAddress( procName );\r
\r
return ( p != NULL ) ? p : fghGetProcAddress( procName );\r
}\r
\r
\r
/* -- PRIVATE FUNCTIONS ---------------------------------------------------- */\r
-extern void fghRememberState( void );\r
-extern void fghRestoreState( void );\r
-extern GLboolean fghChangeDisplayMode( GLboolean haveToTest );\r
+extern void fgPlatformRememberState( void );\r
+extern void fgPlatformRestoreState( void );\r
+extern GLboolean fgPlatformChangeDisplayMode( GLboolean haveToTest );\r
\r
\r
#if TARGET_HOST_POSIX_X11\r
* Remembers the current visual settings, so that\r
* we can change them and restore later...\r
*/\r
-static void fghRememberState( void )\r
+static void fgPlatformRememberState( void )\r
{\r
int event_base, error_base;\r
\r
/*\r
* Restores the previously remembered visual settings\r
*/\r
-static void fghRestoreState( void )\r
+static void fgPlatformRestoreState( void )\r
{\r
/* Restore the remembered pointer position: */\r
XWarpPointer(\r
/*\r
* Changes the current display mode to match user's settings\r
*/\r
-static GLboolean fghChangeDisplayMode( GLboolean haveToTest )\r
+static GLboolean fgPlatformChangeDisplayMode( GLboolean haveToTest )\r
{\r
GLboolean success = GL_FALSE;\r
/* first try to use XRandR, then fallback to XF86VidMode */\r
\r
/* All values not specified are now set to -1, which means those\r
* aspects of the current display mode are not changed in\r
- * fghChangeDisplayMode() above.\r
+ * fgPlatformChangeDisplayMode() above.\r
*/\r
fgState.GameModeSize.X = width;\r
fgState.GameModeSize.Y = height;\r
if( fgStructure.GameModeWindow )\r
fgAddToWindowDestroyList( fgStructure.GameModeWindow );\r
else\r
- fghRememberState( );\r
+ fgPlatformRememberState( );\r
\r
- if( ! fghChangeDisplayMode( GL_FALSE ) )\r
+ if( ! fgPlatformChangeDisplayMode( GL_FALSE ) )\r
{\r
fgWarning( "failed to change screen settings" );\r
return 0;\r
\r
#endif\r
\r
- fghRestoreState();\r
+ fgPlatformRestoreState();\r
}\r
\r
/*\r
return !!fgStructure.GameModeWindow;\r
\r
case GLUT_GAME_MODE_POSSIBLE:\r
- return fghChangeDisplayMode( GL_TRUE );\r
+ return fgPlatformChangeDisplayMode( GL_TRUE );\r
\r
case GLUT_GAME_MODE_WIDTH:\r
return fgState.GameModeSize.X;\r
\r
/* -- PRIVATE FUNCTIONS ---------------------------------------------------- */\r
\r
-extern void fghInitialize( const char* displayName );\r
-extern void fghDeinitialiseInputDevices ( void );\r
-extern void fghCloseDisplay ( void );\r
+extern void fgPlatformInitialize( const char* displayName );\r
+extern void fgPlatformDeinitialiseInputDevices ( void );\r
+extern void fgPlatformCloseDisplay ( void );\r
\r
#if TARGET_HOST_POSIX_X11\r
\r
/*\r
* A call to this function should initialize all the display stuff...\r
*/\r
-static void fghInitialize( const char* displayName )\r
+static void fgPlatformInitialize( const char* displayName )\r
{\r
fgDisplay.Display = XOpenDisplay( displayName );\r
\r
\r
\r
#if TARGET_HOST_POSIX_X11\r
-static void fghDeinitialiseInputDevices ( void )\r
+static void fgPlatformDeinitialiseInputDevices ( void )\r
{\r
fghCloseInputDevices ();\r
\r
}\r
\r
\r
-static void fghCloseDisplay ( void )\r
+static void fgPlatformCloseDisplay ( void )\r
{\r
/*\r
* Make sure all X-client data we have created will be destroyed on\r
free( timer );\r
}\r
\r
- fghDeinitialiseInputDevices ();\r
+ fgPlatformDeinitialiseInputDevices ();\r
\r
fgState.MouseWheelTicks = 0;\r
\r
fgState.ProgramName = NULL;\r
}\r
\r
- fghCloseDisplay ();\r
+ fgPlatformCloseDisplay ();\r
\r
fgState.Initialised = GL_FALSE;\r
}\r
* in the program arguments, we will use the DISPLAY environment\r
* variable for opening the X display (see code above):\r
*/\r
- fghInitialize( displayName );\r
+ fgPlatformInitialize( displayName );\r
\r
/*\r
* Geometry parsing deffered until here because we may need the screen\r
extern int serial_putchar ( SERIALPORT *port, unsigned char ch );\r
extern void serial_flush ( SERIALPORT *port );\r
\r
-extern void fghRegisterDialDevice ( const char *dial_device );\r
+extern void fgPlatformRegisterDialDevice ( const char *dial_device );\r
static void send_dial_event(int dial, int value);\r
static void poll_dials(int id);\r
\r
* Try initializing the input device(s)\r
*/\r
#if TARGET_HOST_POSIX_X11\r
-static void fghRegisterDialDevice ( const char *dial_device )\r
+static void fgPlatformRegisterDialDevice ( const char *dial_device )\r
{\r
}\r
#endif\r
{\r
const char *dial_device=NULL;\r
dial_device = getenv ( "GLUT_DIALS_SERIAL" );\r
- fghRegisterDialDevice ( dial_device );\r
+ fgPlatformRegisterDialDevice ( dial_device );\r
\r
if ( !dial_device ) return;\r
if ( !( dialbox_port = serial_open ( dial_device ) ) ) return;\r
\r
/* The window procedure for Win32 events handling */\r
#if TARGET_HOST_MS_WINDOWS\r
-LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg,\r
+LRESULT CALLBACK fgPlatformWindowProc( HWND hWnd, UINT uMsg,\r
WPARAM wParam, LPARAM lParam );\r
void fgNewWGLCreateContext( SFG_Window* window );\r
GLboolean fgSetupPixelFormat( SFG_Window* window, GLboolean checkOnly,\r
static pCloseTouchInputHandle fghCloseTouchInputHandle = (pCloseTouchInputHandle)0xDEADBEEF;\r
#endif\r
\r
-extern void fghPlatformReshapeWindow ( SFG_Window *window, int width, int height );\r
-extern void fghcbPlatformDisplayWindow ( SFG_Window *window );\r
-extern void fghPlatformSleepForEvents( long msec );\r
-extern void fghProcessSingleEvent ( void );\r
-extern void fghMainLoopPreliminaryWork ( void );\r
+extern void fgPlatformReshapeWindow ( SFG_Window *window, int width, int height );\r
+extern void fgPlatformDisplayWindow ( SFG_Window *window );\r
+extern void fgPlatformSleepForEvents( long msec );\r
+extern void fgPlatformProcessSingleEvent ( void );\r
+extern void fgPlatformMainLoopPreliminaryWork ( void );\r
\r
\r
/*\r
* match the new window size.\r
*/\r
#if TARGET_HOST_POSIX_X11\r
-static void fghPlatformReshapeWindow ( SFG_Window *window, int width, int height )\r
+static void fgPlatformReshapeWindow ( SFG_Window *window, int width, int height )\r
{\r
XResizeWindow( fgDisplay.Display, window->Window.Handle,\r
width, height );\r
\r
freeglut_return_if_fail( window != NULL );\r
\r
- fghPlatformReshapeWindow ( window, width, height );\r
+ fgPlatformReshapeWindow ( window, width, height );\r
\r
if( FETCH_WCB( *window, Reshape ) )\r
INVOKE_WCB( *window, Reshape, ( width, height ) );\r
* A static helper function to execute display callback for a window\r
*/\r
#if TARGET_HOST_POSIX_X11\r
-static void fghcbPlatformDisplayWindow ( SFG_Window *window )\r
+static void fgPlatformDisplayWindow ( SFG_Window *window )\r
{\r
fghRedrawWindow ( window ) ;\r
}\r
window->State.Visible )\r
{\r
window->State.Redisplay = GL_FALSE;\r
- fghcbPlatformDisplayWindow ( window );\r
+ fgPlatformDisplayWindow ( window );\r
}\r
\r
fgEnumSubWindows( window, fghcbDisplayWindow, enumerator );\r
*/\r
\r
#if TARGET_HOST_POSIX_X11\r
-static void fghPlatformSleepForEvents( long msec )\r
+static void fgPlatformSleepForEvents( long msec )\r
{\r
/*\r
* Possibly due to aggressive use of XFlush() and friends,\r
if( fghHaveJoystick( ) && ( msec > 10 ) ) \r
msec = 10;\r
\r
- fghPlatformSleepForEvents ( msec );\r
+ fgPlatformSleepForEvents ( msec );\r
}\r
\r
#if TARGET_HOST_POSIX_X11\r
/*\r
* Returns GLUT modifier mask for the state field of an X11 event.\r
*/\r
-int fghGetModifiers( int state )\r
+int fgPlatformGetModifiers( int state )\r
{\r
int ret = 0;\r
\r
}\r
\r
\r
-void fghProcessSingleEvent ( void )\r
+void fgPlatformProcessSingleEvent ( void )\r
{\r
SFG_Window* window;\r
XEvent event;\r
* XXX track ButtonPress/ButtonRelease events in our own\r
* XXX bit-mask?\r
*/\r
- fgState.Modifiers = fghGetModifiers( event.xmotion.state );\r
+ fgState.Modifiers = fgPlatformGetModifiers( event.xmotion.state );\r
if ( event.xmotion.state & ( Button1Mask | Button2Mask | Button3Mask | Button4Mask | Button5Mask ) ) {\r
INVOKE_WCB( *window, Motion, ( event.xmotion.x,\r
event.xmotion.y ) );\r
! FETCH_WCB( *window, MouseWheel ) )\r
break;\r
\r
- fgState.Modifiers = fghGetModifiers( event.xbutton.state );\r
+ fgState.Modifiers = fgPlatformGetModifiers( event.xbutton.state );\r
\r
/* Finally execute the mouse or mouse wheel callback */\r
if( ( button < glutDeviceGet ( GLUT_NUM_MOUSE_BUTTONS ) ) || ( ! FETCH_WCB( *window, MouseWheel ) ) )\r
if( keyboard_cb )\r
{\r
fgSetWindow( window );\r
- fgState.Modifiers = fghGetModifiers( event.xkey.state );\r
+ fgState.Modifiers = fgPlatformGetModifiers( event.xkey.state );\r
keyboard_cb( asciiCode[ 0 ],\r
event.xkey.x, event.xkey.y\r
);\r
if( special_cb && (special != -1) )\r
{\r
fgSetWindow( window );\r
- fgState.Modifiers = fghGetModifiers( event.xkey.state );\r
+ fgState.Modifiers = fgPlatformGetModifiers( event.xkey.state );\r
special_cb( special, event.xkey.x, event.xkey.y );\r
fgState.Modifiers = INVALID_MODIFIERS;\r
}\r
}\r
\r
\r
-static void fghMainLoopPreliminaryWork ( void )\r
+static void fgPlatformMainLoopPreliminaryWork ( void )\r
{\r
}\r
#endif\r
*/\r
void FGAPIENTRY glutMainLoopEvent( void )\r
{\r
- fghProcessSingleEvent ();\r
+ fgPlatformProcessSingleEvent ();\r
\r
if( fgState.Timers.First )\r
fghCheckTimers( );\r
\r
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutMainLoop" );\r
\r
- fghMainLoopPreliminaryWork ();\r
+ fgPlatformMainLoopPreliminaryWork ();\r
\r
fgState.ExecState = GLUT_EXEC_STATE_RUNNING ;\r
while( fgState.ExecState == GLUT_EXEC_STATE_RUNNING )\r
#endif\r
\r
\r
-extern GLvoid fghGetGameModeVMaxExtent( SFG_Window* window, int* x, int* y );\r
+extern GLvoid fgPlatformGetGameModeVMaxExtent( SFG_Window* window, int* x, int* y );\r
\r
/* -- PRIVATE FUNCTIONS ---------------------------------------------------- */\r
\r
* Private function to get the virtual maximum screen extent\r
*/\r
#if TARGET_HOST_POSIX_X11\r
-static GLvoid fghGetGameModeVMaxExtent( SFG_Window* window, int* x, int* y )\r
+static GLvoid fgPlatformGetGameModeVMaxExtent( SFG_Window* window, int* x, int* y )\r
{\r
int wx, wy;\r
Window w;\r
static GLvoid fghGetVMaxExtent( SFG_Window* window, int* x, int* y )\r
{\r
if( fgStructure.GameModeWindow )\r
- fghGetGameModeVMaxExtent ( window, x, y );\r
+ fgPlatformGetGameModeVMaxExtent ( window, x, y );\r
else\r
{\r
*x = fgDisplay.ScreenWidth;\r
#include <X11/extensions/XInput2.h>
/* import function from freeglut_main.c */
-int fghGetModifiers( int state );
+extern int fgPlatformGetModifiers( int state );
/* extension opcode for XInput */
int xi_opcode = -1;
case XI_Enter:
case XI_Leave:
- fgState.Modifiers = fghGetModifiers( ((XIEnterEvent*)event)->mods.base );
+ fgState.Modifiers = fgPlatformGetModifiers( ((XIEnterEvent*)event)->mods.base );
INVOKE_WCB( *window, MultiEntry, (
event->deviceid,
(event->evtype == XI_Enter ? GLUT_ENTERED : GLUT_LEFT)
case XI_ButtonPress:
case XI_ButtonRelease:
- fgState.Modifiers = fghGetModifiers( event->mods.base );
+ fgState.Modifiers = fgPlatformGetModifiers( event->mods.base );
INVOKE_WCB( *window, MultiButton, (
event->deviceid,
event->event_x,
break;
case XI_Motion:
- fgState.Modifiers = fghGetModifiers( event->mods.base );
+ fgState.Modifiers = fgPlatformGetModifiers( event->mods.base );
for (i = 0; i < event->buttons.mask_len; i++) if (event->buttons.mask[i]) button = 1;
if (button) {
INVOKE_WCB( *window, MultiMotion, ( event->deviceid, event->event_x, event->event_y ) );
\r
\r
\r
-void fghSetCursor ( SFG_Window *window, int cursorID )\r
+void fgPlatformSetCursor ( SFG_Window *window, int cursorID )\r
{\r
/*\r
* Joe Krahn is re-writing the following code.\r
}\r
\r
\r
-void fghWarpPointer ( int x, int y )\r
+void fgPlatformWarpPointer ( int x, int y )\r
{\r
POINT coords;\r
coords.x = x;\r
#include <GL/freeglut.h>\r
#include "freeglut_internal_mswin.h"\r
\r
-GLUTproc fghGetPlatformSpecificGLUTProcAddress( const char* procName )\r
+GLUTproc fgPlatformGlutGetProcAddress( const char* procName )\r
{\r
#if !defined(_WIN32_WCE)\r
/* optimization: quick initial check */\r
* Remembers the current visual settings, so that\r
* we can change them and restore later...\r
*/\r
-void fghRememberState( void )\r
+void fgPlatformRememberState( void )\r
{\r
/* DEVMODE devMode; */\r
\r
/*\r
* Restores the previously remembered visual settings\r
*/\r
-void fghRestoreState( void )\r
+void fgPlatformRestoreState( void )\r
{\r
/* Restore the previously remembered desktop display settings */\r
ChangeDisplaySettingsEx( fgDisplay.DisplayName,&fgDisplay.DisplayMode, 0,0,0 );\r
/*\r
* Changes the current display mode to match user's settings\r
*/\r
-GLboolean fghChangeDisplayMode( GLboolean haveToTest )\r
+GLboolean fgPlatformChangeDisplayMode( GLboolean haveToTest )\r
{\r
GLboolean success = GL_FALSE;\r
DEVMODE devMode;\r
/*\r
* A call to this function should initialize all the display stuff...\r
*/\r
-void fghInitialize( const char* displayName )\r
+void fgPlatformInitialize( const char* displayName )\r
{\r
WNDCLASS wc;\r
ATOM atom;\r
* XXX Old code had "| CS_DBCLCKS" commented out. Plans for the\r
* XXX future? Dead-end idea?\r
*/\r
- wc.lpfnWndProc = fgWindowProc;\r
+ wc.lpfnWndProc = fgPlatformWindowProc;\r
wc.cbClsExtra = 0;\r
wc.cbWndExtra = 0;\r
wc.hInstance = fgDisplay.Instance;\r
\r
/* Register the window class */\r
atom = RegisterClass( &wc );\r
- FREEGLUT_INTERNAL_ERROR_EXIT ( atom, "Window Class Not Registered", "fghInitialize" );\r
+ FREEGLUT_INTERNAL_ERROR_EXIT ( atom, "Window Class Not Registered", "fgPlatformInitialize" );\r
}\r
\r
/* The screen dimensions can be obtained via GetSystemMetrics() calls */\r
DeleteDC(context);\r
}\r
else\r
- fgWarning("fghInitialize: "\r
+ fgWarning("fgPlatformInitialize: "\r
"CreateDC failed, Screen size info may be incorrect\n"\r
"This is quite likely caused by a bad '-display' parameter");\r
\r
/* Platform-Specific Deinitialization Functions: */\r
extern void fghCloseInputDevices ( void );\r
\r
-void fghDeinitialiseInputDevices ( void )\r
+void fgPlatformDeinitialiseInputDevices ( void )\r
{\r
#if !defined(_WIN32_WCE)\r
fghCloseInputDevices ();\r
fgState.InputDevsInitialised = GL_FALSE;\r
}\r
\r
-void fghCloseDisplay ( void )\r
+void fgPlatformCloseDisplay ( void )\r
{\r
if( fgDisplay.DisplayName )\r
{\r
void serial_flush ( SERIALPORT *port );\r
\r
\r
-void fghRegisterDialDevice ( const char *dial_device )\r
+void fgPlatformRegisterDialDevice ( const char *dial_device )\r
{\r
if (!dial_device){\r
static char devname[256];\r
extern void fghRedrawWindow ( SFG_Window *window );\r
\r
\r
-void fghPlatformReshapeWindow ( SFG_Window *window, int width, int height )\r
+void fgPlatformReshapeWindow ( SFG_Window *window, int width, int height )\r
{\r
RECT windowRect;\r
\r
}\r
\r
\r
-void fghcbPlatformDisplayWindow ( SFG_Window *window )\r
+void fgPlatformDisplayWindow ( SFG_Window *window )\r
{\r
RedrawWindow(\r
window->Window.Handle, NULL, NULL,\r
}\r
\r
\r
-void fghPlatformSleepForEvents( long msec )\r
+void fgPlatformSleepForEvents( long msec )\r
{\r
MsgWaitForMultipleObjects( 0, NULL, FALSE, msec, QS_ALLINPUT );\r
}\r
\r
\r
-void fghProcessSingleEvent ( void )\r
+void fgPlatformProcessSingleEvent ( void )\r
{\r
MSG stMsg;\r
\r
\r
\r
\r
-void fghMainLoopPreliminaryWork ( void )\r
+void fgPlatformMainLoopPreliminaryWork ( void )\r
{\r
SFG_Window *window = (SFG_Window *)fgStructure.Windows.First ;\r
\r
/*\r
* Determine a GLUT modifer mask based on MS-WINDOWS system info.\r
*/\r
-static int fghGetModifiers (void)\r
+static int fgPlatformGetModifiers (void)\r
{\r
return\r
( ( ( GetKeyState( VK_LSHIFT ) < 0 ) ||\r
/*\r
* The window procedure for handling Win32 events\r
*/\r
-LRESULT CALLBACK fgWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam,\r
- LPARAM lParam )\r
+LRESULT CALLBACK fgPlatformWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam,\r
+ LPARAM lParam )\r
{\r
static unsigned char lControl = 0, rControl = 0, lShift = 0,\r
rShift = 0, lAlt = 0, rAlt = 0;\r
/* The window structure is passed as the creation structure parameter... */\r
window = (SFG_Window *) (((LPCREATESTRUCT) lParam)->lpCreateParams);\r
FREEGLUT_INTERNAL_ERROR_EXIT ( ( window != NULL ), "Cannot create window",\r
- "fgWindowProc" );\r
+ "fgPlatformWindowProc" );\r
\r
window->Window.Handle = hWnd;\r
window->Window.Device = GetDC( hWnd );\r
}\r
SetFocus(window->Window.Handle);\r
\r
- fgState.Modifiers = fghGetModifiers( );\r
+ fgState.Modifiers = fgPlatformGetModifiers( );\r
\r
if( ( wParam & MK_LBUTTON ) ||\r
( wParam & MK_MBUTTON ) ||\r
break;\r
\r
fgSetWindow( window );\r
- fgState.Modifiers = fghGetModifiers( );\r
+ fgState.Modifiers = fgPlatformGetModifiers( );\r
\r
INVOKE_WCB(\r
*window, Mouse,\r
break;\r
\r
fgSetWindow( window );\r
- fgState.Modifiers = fghGetModifiers( );\r
+ fgState.Modifiers = fgPlatformGetModifiers( );\r
\r
/*\r
* XXX Should use WHEEL_DELTA instead of 120\r
* Remember the current modifiers state. This is done here in order\r
* to make sure the VK_DELETE keyboard callback is executed properly.\r
*/\r
- fgState.Modifiers = fghGetModifiers( );\r
+ fgState.Modifiers = fgPlatformGetModifiers( );\r
\r
GetCursorPos( &mouse_pos );\r
ScreenToClient( window->Window.Handle, &mouse_pos );\r
* Remember the current modifiers state. This is done here in order\r
* to make sure the VK_DELETE keyboard callback is executed properly.\r
*/\r
- fgState.Modifiers = fghGetModifiers( );\r
+ fgState.Modifiers = fgPlatformGetModifiers( );\r
\r
GetCursorPos( &mouse_pos );\r
ScreenToClient( window->Window.Handle, &mouse_pos );\r
if( (fgState.KeyRepeat==GLUT_KEY_REPEAT_OFF || window->State.IgnoreKeyRepeat==GL_TRUE) && (HIWORD(lParam) & KF_REPEAT) )\r
break;\r
\r
- fgState.Modifiers = fghGetModifiers( );\r
+ fgState.Modifiers = fgPlatformGetModifiers( );\r
INVOKE_WCB( *window, Keyboard,\r
( (char)wParam,\r
window->State.MouseX, window->State.MouseY )\r
#include "freeglut_internal_mswin.h"\r
\r
\r
-GLvoid fghGetGameModeVMaxExtent( SFG_Window* window, int* x, int* y )\r
+GLvoid fgPlatformGetGameModeVMaxExtent( SFG_Window* window, int* x, int* y )\r
{\r
*x = glutGet ( GLUT_SCREEN_WIDTH );\r
*y = glutGet ( GLUT_SCREEN_HEIGHT );\r