FMudanyali/FreeGLUT-Vita
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Moving platform-specific fields in "SFG_Display" into a substructure

Browse Source 
git-svn-id: https://svn.code.sf.net/p/freeglut/code/trunk@1011 7f0cb862-5218-0410-a997-914c9d46530a
This commit is contained in:
fayjf 2012-01-29 02:45:04 +00:00
parent 488cd6ed75
commit ab2e6057aa
11 changed files with 191 additions and 186 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
freeglut/freeglut/src/Common/freeglut_cursor.c
View File

@ -57,14 +57,14 @@ static Cursor getEmptyCursor( void )
Pixmap cursorNonePixmap; Pixmap cursorNonePixmap;
memset( cursorNoneBits, 0, sizeof( cursorNoneBits ) ); memset( cursorNoneBits, 0, sizeof( cursorNoneBits ) );
memset( &dontCare, 0, sizeof( dontCare ) ); memset( &dontCare, 0, sizeof( dontCare ) );
cursorNonePixmap = XCreateBitmapFromData ( fgDisplay.Display, cursorNonePixmap = XCreateBitmapFromData ( fgDisplay.pDisplay.Display,
fgDisplay.RootWindow, fgDisplay.pDisplay.RootWindow,
cursorNoneBits, 16, 16 ); cursorNoneBits, 16, 16 );
if( cursorNonePixmap != None ) { if( cursorNonePixmap != None ) {
cursorNone = XCreatePixmapCursor( fgDisplay.Display, cursorNone = XCreatePixmapCursor( fgDisplay.pDisplay.Display,
cursorNonePixmap, cursorNonePixmap, cursorNonePixmap, cursorNonePixmap,
&dontCare, &dontCare, 0, 0 ); &dontCare, &dontCare, 0, 0 );
XFreePixmap( fgDisplay.Display, cursorNonePixmap ); XFreePixmap( fgDisplay.pDisplay.Display, cursorNonePixmap );
} }
} }
return cursorNone; return cursorNone;
@ -120,7 +120,7 @@ void fgPlatformSetCursor ( SFG_Window *window, int cursorID )
cursorCacheEntry *entry = &cursorCache[ cursorIDToUse ]; cursorCacheEntry *entry = &cursorCache[ cursorIDToUse ];
if( entry->cachedCursor == None ) { if( entry->cachedCursor == None ) {
entry->cachedCursor = entry->cachedCursor =
XCreateFontCursor( fgDisplay.Display, entry->cursorShape ); XCreateFontCursor( fgDisplay.pDisplay.Display, entry->cursorShape );
} }
cursor = entry->cachedCursor; cursor = entry->cachedCursor;
} else { } else {
@ -141,9 +141,9 @@ void fgPlatformSetCursor ( SFG_Window *window, int cursorID )
} }
if ( cursorIDToUse == GLUT_CURSOR_INHERIT ) { if ( cursorIDToUse == GLUT_CURSOR_INHERIT ) {
XUndefineCursor( fgDisplay.Display, window->Window.Handle ); XUndefineCursor( fgDisplay.pDisplay.Display, window->Window.Handle );
} else if ( cursor != None ) { } else if ( cursor != None ) {
XDefineCursor( fgDisplay.Display, window->Window.Handle, cursor ); XDefineCursor( fgDisplay.pDisplay.Display, window->Window.Handle, cursor );
} else if ( cursorIDToUse != GLUT_CURSOR_NONE ) { } else if ( cursorIDToUse != GLUT_CURSOR_NONE ) {
fgError( "Failed to create cursor" ); fgError( "Failed to create cursor" );
} }
@ -153,14 +153,14 @@ void fgPlatformSetCursor ( SFG_Window *window, int cursorID )
void fgPlatformWarpPointer ( int x, int y ) void fgPlatformWarpPointer ( int x, int y )
{ {
XWarpPointer( XWarpPointer(
fgDisplay.Display, fgDisplay.pDisplay.Display,
None, None,
fgStructure.CurrentWindow->Window.Handle, fgStructure.CurrentWindow->Window.Handle,
0, 0, 0, 0, 0, 0, 0, 0,
x, y x, y
); );
/* Make the warp visible immediately. */ /* Make the warp visible immediately. */
XFlush( fgDisplay.Display ); XFlush( fgDisplay.pDisplay.Display );
} }
#endif #endif

2
freeglut/freeglut/src/Common/freeglut_display.c
View File

@ -62,7 +62,7 @@ void FGAPIENTRY glutSwapBuffers( void )
return; return;
#if TARGET_HOST_POSIX_X11 #if TARGET_HOST_POSIX_X11
glXSwapBuffers( fgDisplay.Display, fgStructure.CurrentWindow->Window.Handle ); glXSwapBuffers( fgDisplay.pDisplay.Display, fgStructure.CurrentWindow->Window.Handle );
#elif TARGET_HOST_MS_WINDOWS #elif TARGET_HOST_MS_WINDOWS
SwapBuffers( fgStructure.CurrentWindow->Window.Device ); SwapBuffers( fgStructure.CurrentWindow->Window.Device );
#endif #endif

148
freeglut/freeglut/src/Common/freeglut_gamemode.c
View File

@ -53,11 +53,11 @@ static int xrandr_resize(int xsz, int ysz, int rate, int just_checking)
Status result = -1; Status result = -1;
/* must check at runtime for the availability of the extension */ /* must check at runtime for the availability of the extension */
if(!XRRQueryExtension(fgDisplay.Display, &event_base, &error_base)) { if(!XRRQueryExtension(fgDisplay.pDisplay.Display, &event_base, &error_base)) {
return -1; return -1;
} }
XRRQueryVersion(fgDisplay.Display, &ver_major, &ver_minor); XRRQueryVersion(fgDisplay.pDisplay.Display, &ver_major, &ver_minor);
/* we only heed the rate if we CAN actually use it (Xrandr >= 1.1) and /* we only heed the rate if we CAN actually use it (Xrandr >= 1.1) and
* the user actually cares about it (rate > 0) * the user actually cares about it (rate > 0)
@ -80,7 +80,7 @@ static int xrandr_resize(int xsz, int ysz, int rate, int just_checking)
XRRFreeScreenConfigInfo(xrr_config); XRRFreeScreenConfigInfo(xrr_config);
} }
if(!(xrr_config = XRRGetScreenInfo(fgDisplay.Display, fgDisplay.RootWindow))) { if(!(xrr_config = XRRGetScreenInfo(fgDisplay.pDisplay.Display, fgDisplay.RootWindow))) {
fgWarning("XRRGetScreenInfo failed"); fgWarning("XRRGetScreenInfo failed");
break; break;
} }
@ -136,12 +136,12 @@ static int xrandr_resize(int xsz, int ysz, int rate, int just_checking)
#if ( RANDR_MAJOR >= 1 ) || ( ( RANDR_MAJOR == 1 ) && ( RANDR_MINOR >= 1 ) ) #if ( RANDR_MAJOR >= 1 ) || ( ( RANDR_MAJOR == 1 ) && ( RANDR_MINOR >= 1 ) )
if(use_rate) if(use_rate)
result = XRRSetScreenConfigAndRate(fgDisplay.Display, xrr_config, result = XRRSetScreenConfigAndRate(fgDisplay.pDisplay.Display, xrr_config,
fgDisplay.RootWindow, res_idx, rot, rate, timestamp); fgDisplay.pDisplay.RootWindow, res_idx, rot, rate, timestamp);
else else
#endif #endif
result = XRRSetScreenConfig(fgDisplay.Display, xrr_config, result = XRRSetScreenConfig(fgDisplay.pDisplay.Display, xrr_config,
fgDisplay.RootWindow, res_idx, rot, timestamp); fgDisplay.pDisplay.RootWindow, res_idx, rot, timestamp);
} while(result == RRSetConfigInvalidTime); } while(result == RRSetConfigInvalidTime);
@ -174,33 +174,33 @@ void fgPlatformRememberState( void )
Window junk_window; Window junk_window;
unsigned int junk_mask; unsigned int junk_mask;
XQueryPointer(fgDisplay.Display, fgDisplay.RootWindow, XQueryPointer(fgDisplay.pDisplay.Display, fgDisplay.pDisplay.RootWindow,
&junk_window, &junk_window, &junk_window, &junk_window,
&fgDisplay.DisplayPointerX, &fgDisplay.DisplayPointerY, &fgDisplay.pDisplay.DisplayPointerX, &fgDisplay.pDisplay.DisplayPointerY,
&fgDisplay.DisplayPointerX, &fgDisplay.DisplayPointerY, &junk_mask); &fgDisplay.pDisplay.DisplayPointerX, &fgDisplay.pDisplay.DisplayPointerY, &junk_mask);
# ifdef HAVE_X11_EXTENSIONS_XRANDR_H # ifdef HAVE_X11_EXTENSIONS_XRANDR_H
if(XRRQueryExtension(fgDisplay.Display, &event_base, &error_base)) { if(XRRQueryExtension(fgDisplay.pDisplay.Display, &event_base, &error_base)) {
XRRScreenConfiguration *xrr_config; XRRScreenConfiguration *xrr_config;
XRRScreenSize *ssizes; XRRScreenSize *ssizes;
Rotation rot; Rotation rot;
int ssize_count, curr; int ssize_count, curr;
if((xrr_config = XRRGetScreenInfo(fgDisplay.Display, fgDisplay.RootWindow))) { if((xrr_config = XRRGetScreenInfo(fgDisplay.pDisplay.Display, fgDisplay.pDisplay.RootWindow))) {
ssizes = XRRConfigSizes(xrr_config, &ssize_count); ssizes = XRRConfigSizes(xrr_config, &ssize_count);
curr = XRRConfigCurrentConfiguration(xrr_config, &rot); curr = XRRConfigCurrentConfiguration(xrr_config, &rot);
fgDisplay.prev_xsz = ssizes[curr].width; fgDisplay.pDisplay.prev_xsz = ssizes[curr].width;
fgDisplay.prev_ysz = ssizes[curr].height; fgDisplay.pDisplay.prev_ysz = ssizes[curr].height;
fgDisplay.prev_refresh = -1; fgDisplay.pDisplay.prev_refresh = -1;
# if ( RANDR_MAJOR >= 1 ) || ( ( RANDR_MAJOR == 1 ) && ( RANDR_MINOR >= 1 ) ) # if ( RANDR_MAJOR >= 1 ) || ( ( RANDR_MAJOR == 1 ) && ( RANDR_MINOR >= 1 ) )
if(fgState.GameModeRefresh != -1) { if(fgState.GameModeRefresh != -1) {
fgDisplay.prev_refresh = XRRConfigCurrentRate(xrr_config); fgDisplay.pDisplay.prev_refresh = XRRConfigCurrentRate(xrr_config);
} }
# endif # endif
fgDisplay.prev_size_valid = 1; fgDisplay.pDisplay.prev_size_valid = 1;
XRRFreeScreenConfigInfo(xrr_config); XRRFreeScreenConfigInfo(xrr_config);
} }
@ -212,7 +212,7 @@ void fgPlatformRememberState( void )
* not approved as X Consortium standards * not approved as X Consortium standards
*/ */
# ifdef HAVE_X11_EXTENSIONS_XF86VMODE_H # ifdef HAVE_X11_EXTENSIONS_XF86VMODE_H
if(!XF86VidModeQueryExtension(fgDisplay.Display, &event_base, &error_base)) { if(!XF86VidModeQueryExtension(fgDisplay.pDisplay.Display, &event_base, &error_base)) {
return; return;
} }
@ -221,23 +221,23 @@ void fgPlatformRememberState( void )
* restore the ViewPort on LeaveGameMode(): * restore the ViewPort on LeaveGameMode():
*/ */
if( !XF86VidModeGetViewPort( if( !XF86VidModeGetViewPort(
fgDisplay.Display, fgDisplay.pDisplay.Display,
fgDisplay.Screen, fgDisplay.pDisplay.Screen,
&fgDisplay.DisplayViewPortX, &fgDisplay.pDisplay.DisplayViewPortX,
&fgDisplay.DisplayViewPortY ) ) &fgDisplay.pDisplay.DisplayViewPortY ) )
fgWarning( "XF86VidModeGetViewPort failed" ); fgWarning( "XF86VidModeGetViewPort failed" );
/* Query the current display settings: */ /* Query the current display settings: */
fgDisplay.DisplayModeValid = fgDisplay.pDisplay.DisplayModeValid =
XF86VidModeGetModeLine( XF86VidModeGetModeLine(
fgDisplay.Display, fgDisplay.pDisplay.Display,
fgDisplay.Screen, fgDisplay.pDisplay.Screen,
&fgDisplay.DisplayModeClock, &fgDisplay.pDisplay.DisplayModeClock,
&fgDisplay.DisplayMode &fgDisplay.pDisplay.DisplayMode
); );
if( !fgDisplay.DisplayModeValid ) if( !fgDisplay.pDisplay.DisplayModeValid )
fgWarning( "XF86VidModeGetModeLine failed" ); fgWarning( "XF86VidModeGetModeLine failed" );
# endif # endif
@ -252,17 +252,17 @@ void fgPlatformRestoreState( void )
{ {
/* Restore the remembered pointer position: */ /* Restore the remembered pointer position: */
XWarpPointer( XWarpPointer(
fgDisplay.Display, None, fgDisplay.RootWindow, 0, 0, 0, 0, fgDisplay.pDisplay.Display, None, fgDisplay.pDisplay.RootWindow, 0, 0, 0, 0,
fgDisplay.DisplayPointerX, fgDisplay.DisplayPointerY fgDisplay.pDisplay.DisplayPointerX, fgDisplay.pDisplay.DisplayPointerY
); );
# ifdef HAVE_X11_EXTENSIONS_XRANDR_H # ifdef HAVE_X11_EXTENSIONS_XRANDR_H
if(fgDisplay.prev_size_valid) { if(fgDisplay.pDisplay.prev_size_valid) {
if(xrandr_resize(fgDisplay.prev_xsz, fgDisplay.prev_ysz, fgDisplay.prev_refresh, 0) != -1) { if(xrandr_resize(fgDisplay.pDisplay.prev_xsz, fgDisplay.pDisplay.prev_ysz, fgDisplay.pDisplay.prev_refresh, 0) != -1) {
fgDisplay.prev_size_valid = 0; fgDisplay.pDisplay.prev_size_valid = 0;
# ifdef HAVE_X11_EXTENSIONS_XF86VMODE_H # ifdef HAVE_X11_EXTENSIONS_XF86VMODE_H
fgDisplay.DisplayModeValid = 0; fgDisplay.pDisplay.DisplayModeValid = 0;
# endif # endif
return; return;
} }
@ -277,14 +277,14 @@ void fgPlatformRestoreState( void )
* not approved as X Consortium standards * not approved as X Consortium standards
*/ */
if( fgDisplay.DisplayModeValid ) if( fgDisplay.pDisplay.DisplayModeValid )
{ {
XF86VidModeModeInfo** displayModes; XF86VidModeModeInfo** displayModes;
int i, displayModesCount; int i, displayModesCount;
if( !XF86VidModeGetAllModeLines( if( !XF86VidModeGetAllModeLines(
fgDisplay.Display, fgDisplay.pDisplay.Display,
fgDisplay.Screen, fgDisplay.pDisplay.Screen,
&displayModesCount, &displayModesCount,
&displayModes ) ) &displayModes ) )
{ {
@ -299,13 +299,13 @@ void fgPlatformRestoreState( void )
*/ */
for( i = 0; i < displayModesCount; i++ ) for( i = 0; i < displayModesCount; i++ )
{ {
if(displayModes[ i ]->hdisplay == fgDisplay.DisplayMode.hdisplay && if(displayModes[ i ]->hdisplay == fgDisplay.pDisplay.DisplayMode.hdisplay &&
displayModes[ i ]->vdisplay == fgDisplay.DisplayMode.vdisplay && displayModes[ i ]->vdisplay == fgDisplay.pDisplay.DisplayMode.vdisplay &&
displayModes[ i ]->dotclock == fgDisplay.DisplayModeClock ) displayModes[ i ]->dotclock == fgDisplay.pDisplay.DisplayModeClock )
{ {
if( !XF86VidModeSwitchToMode( if( !XF86VidModeSwitchToMode(
fgDisplay.Display, fgDisplay.pDisplay.Display,
fgDisplay.Screen, fgDisplay.pDisplay.Screen,
displayModes[ i ] ) ) displayModes[ i ] ) )
{ {
fgWarning( "XF86VidModeSwitchToMode failed" ); fgWarning( "XF86VidModeSwitchToMode failed" );
@ -313,10 +313,10 @@ void fgPlatformRestoreState( void )
} }
if( !XF86VidModeSetViewPort( if( !XF86VidModeSetViewPort(
fgDisplay.Display, fgDisplay.pDisplay.Display,
fgDisplay.Screen, fgDisplay.pDisplay.Screen,
fgDisplay.DisplayViewPortX, fgDisplay.pDisplay.DisplayViewPortX,
fgDisplay.DisplayViewPortY ) ) fgDisplay.pDisplay.DisplayViewPortY ) )
fgWarning( "XF86VidModeSetViewPort failed" ); fgWarning( "XF86VidModeSetViewPort failed" );
@ -325,11 +325,11 @@ void fgPlatformRestoreState( void )
* calls exit() we've to flush the X11 output queue to have the * calls exit() we've to flush the X11 output queue to have the
* commands sent to the X server before the application exits. * commands sent to the X server before the application exits.
*/ */
XFlush( fgDisplay.Display ); XFlush( fgDisplay.pDisplay.Display );
fgDisplay.DisplayModeValid = 0; fgDisplay.pDisplay.DisplayModeValid = 0;
# ifdef HAVE_X11_EXTENSIONS_XRANDR_H # ifdef HAVE_X11_EXTENSIONS_XRANDR_H
fgDisplay.prev_size_valid = 0; fgDisplay.pDisplay.prev_size_valid = 0;
# endif # endif
break; break;
@ -420,7 +420,7 @@ GLboolean fgPlatformChangeDisplayMode( GLboolean haveToTest )
* This is also used by applications which check modes by calling * This is also used by applications which check modes by calling
* glutGameModeGet(GLUT_GAME_MODE_POSSIBLE), so allow the check: * glutGameModeGet(GLUT_GAME_MODE_POSSIBLE), so allow the check:
*/ */
if( haveToTest || fgDisplay.DisplayModeValid ) if( haveToTest || fgDisplay.pDisplay.DisplayModeValid )
{ {
XF86VidModeModeInfo** displayModes; XF86VidModeModeInfo** displayModes;
int i, displayModesCount; int i, displayModesCount;
@ -430,20 +430,20 @@ GLboolean fgPlatformChangeDisplayMode( GLboolean haveToTest )
* glutEnterGameMode, then we need to query the current mode, to make * glutEnterGameMode, then we need to query the current mode, to make
* unspecified settings to default to their current values. * unspecified settings to default to their current values.
*/ */
if(!fgDisplay.DisplayModeValid) { if(!fgDisplay.pDisplay.DisplayModeValid) {
if(!XF86VidModeGetModeLine(fgDisplay.Display, fgDisplay.Screen, if(!XF86VidModeGetModeLine(fgDisplay.pDisplay.Display, fgDisplay.pDisplay.Screen,
&fgDisplay.DisplayModeClock, &fgDisplay.DisplayMode)) { &fgDisplay.pDisplay.DisplayModeClock, &fgDisplay.pDisplay.DisplayMode)) {
return success; return success;
} }
} }
if (fgState.GameModeSize.X == -1) if (fgState.GameModeSize.X == -1)
{ {
fgState.GameModeSize.X = fgDisplay.DisplayMode.hdisplay; fgState.GameModeSize.X = fgDisplay.pDisplay.DisplayMode.hdisplay;
} }
if (fgState.GameModeSize.Y == -1) if (fgState.GameModeSize.Y == -1)
{ {
fgState.GameModeSize.Y = fgDisplay.DisplayMode.vdisplay; fgState.GameModeSize.Y = fgDisplay.pDisplay.DisplayMode.vdisplay;
} }
if (fgState.GameModeDepth == -1) if (fgState.GameModeDepth == -1)
{ {
@ -454,16 +454,16 @@ GLboolean fgPlatformChangeDisplayMode( GLboolean haveToTest )
if (fgState.GameModeRefresh == -1) if (fgState.GameModeRefresh == -1)
{ {
/* Compute the displays refresh rate, dotclock comes in kHz. */ /* Compute the displays refresh rate, dotclock comes in kHz. */
int refresh = ( fgDisplay.DisplayModeClock * 1000 ) / int refresh = ( fgDisplay.pDisplay.DisplayModeClock * 1000 ) /
( fgDisplay.DisplayMode.htotal * fgDisplay.DisplayMode.vtotal ); ( fgDisplay.pDisplay.DisplayMode.htotal * fgDisplay.pDisplay.DisplayMode.vtotal );
fgState.GameModeRefresh = refresh; fgState.GameModeRefresh = refresh;
} }
/* query all possible display modes */ /* query all possible display modes */
if( !XF86VidModeGetAllModeLines( if( !XF86VidModeGetAllModeLines(
fgDisplay.Display, fgDisplay.pDisplay.Display,
fgDisplay.Screen, fgDisplay.pDisplay.Screen,
&displayModesCount, &displayModesCount,
&displayModes ) ) &displayModes ) )
{ {
@ -484,8 +484,8 @@ GLboolean fgPlatformChangeDisplayMode( GLboolean haveToTest )
if( !haveToTest && success ) { if( !haveToTest && success ) {
if( !XF86VidModeSwitchToMode( if( !XF86VidModeSwitchToMode(
fgDisplay.Display, fgDisplay.pDisplay.Display,
fgDisplay.Screen, fgDisplay.pDisplay.Screen,
displayModes[ i ] ) ) displayModes[ i ] ) )
fgWarning( "XF86VidModeSwitchToMode failed" ); fgWarning( "XF86VidModeSwitchToMode failed" );
} }
@ -576,7 +576,7 @@ int FGAPIENTRY glutEnterGameMode( void )
* Sync needed to avoid a real race, the Xserver must have really created * Sync needed to avoid a real race, the Xserver must have really created
* the window before we can grab the pointer into it: * the window before we can grab the pointer into it:
*/ */
XSync( fgDisplay.Display, False ); XSync( fgDisplay.pDisplay.Display, False );
/* /*
* Grab the pointer to confine it into the window after the calls to * Grab the pointer to confine it into the window after the calls to
* XWrapPointer() which ensure that the pointer really enters the window. * XWrapPointer() which ensure that the pointer really enters the window.
@ -587,7 +587,7 @@ int FGAPIENTRY glutEnterGameMode( void )
* the application which we have to aviod, so wait until it's viewable: * the application which we have to aviod, so wait until it's viewable:
*/ */
while( GrabSuccess != XGrabPointer( while( GrabSuccess != XGrabPointer(
fgDisplay.Display, fgStructure.GameModeWindow->Window.Handle, fgDisplay.pDisplay.Display, fgStructure.GameModeWindow->Window.Handle,
TRUE, TRUE,
ButtonPressMask | ButtonReleaseMask | ButtonMotionMask ButtonPressMask | ButtonReleaseMask | ButtonMotionMask
| PointerMotionMask, | PointerMotionMask,
@ -599,7 +599,7 @@ int FGAPIENTRY glutEnterGameMode( void )
* if the new window is not viewable yet, see the XGrabPointer loop above. * if the new window is not viewable yet, see the XGrabPointer loop above.
*/ */
XSetInputFocus( XSetInputFocus(
fgDisplay.Display, fgDisplay.pDisplay.Display,
fgStructure.GameModeWindow->Window.Handle, fgStructure.GameModeWindow->Window.Handle,
RevertToNone, RevertToNone,
CurrentTime CurrentTime
@ -607,22 +607,22 @@ int FGAPIENTRY glutEnterGameMode( void )
/* Move the Pointer to the middle of the fullscreen window */ /* Move the Pointer to the middle of the fullscreen window */
XWarpPointer( XWarpPointer(
fgDisplay.Display, fgDisplay.pDisplay.Display,
None, None,
fgDisplay.RootWindow, fgDisplay.pDisplay.RootWindow,
0, 0, 0, 0, 0, 0, 0, 0,
fgState.GameModeSize.X/2, fgState.GameModeSize.Y/2 fgState.GameModeSize.X/2, fgState.GameModeSize.Y/2
); );
# ifdef HAVE_X11_EXTENSIONS_XF86VMODE_H # ifdef HAVE_X11_EXTENSIONS_XF86VMODE_H
if( fgDisplay.DisplayModeValid ) if( fgDisplay.pDisplay.DisplayModeValid )
{ {
int x, y; int x, y;
Window child; Window child;
/* Change to viewport to the window topleft edge: */ /* Change to viewport to the window topleft edge: */
if( !XF86VidModeSetViewPort( fgDisplay.Display, fgDisplay.Screen, 0, 0 ) ) if( !XF86VidModeSetViewPort( fgDisplay.pDisplay.Display, fgDisplay.Screen, 0, 0 ) )
fgWarning( "XF86VidModeSetViewPort failed" ); fgWarning( "XF86VidModeSetViewPort failed" );
/* /*
@ -633,15 +633,15 @@ int FGAPIENTRY glutEnterGameMode( void )
/* Get the current postion of the drawable area on screen */ /* Get the current postion of the drawable area on screen */
XTranslateCoordinates( XTranslateCoordinates(
fgDisplay.Display, fgDisplay.pDisplay.Display,
fgStructure.CurrentWindow->Window.Handle, fgStructure.CurrentWindow->Window.Handle,
fgDisplay.RootWindow, fgDisplay.pDisplay.RootWindow,
0, 0, &x, &y, 0, 0, &x, &y,
&child &child
); );
/* Move the decorataions out of the topleft corner of the display */ /* Move the decorataions out of the topleft corner of the display */
XMoveWindow( fgDisplay.Display, fgStructure.CurrentWindow->Window.Handle, XMoveWindow( fgDisplay.pDisplay.Display, fgStructure.CurrentWindow->Window.Handle,
-x, -y); -x, -y);
} }
@ -649,7 +649,7 @@ int FGAPIENTRY glutEnterGameMode( void )
/* Grab the keyboard, too */ /* Grab the keyboard, too */
XGrabKeyboard( XGrabKeyboard(
fgDisplay.Display, fgDisplay.pDisplay.Display,
fgStructure.GameModeWindow->Window.Handle, fgStructure.GameModeWindow->Window.Handle,
FALSE, FALSE,
GrabModeAsync, GrabModeAsync, GrabModeAsync, GrabModeAsync,
@ -675,8 +675,8 @@ void FGAPIENTRY glutLeaveGameMode( void )
#if TARGET_HOST_POSIX_X11 #if TARGET_HOST_POSIX_X11
XUngrabPointer( fgDisplay.Display, CurrentTime ); XUngrabPointer( fgDisplay.pDisplay.Display, CurrentTime );
XUngrabKeyboard( fgDisplay.Display, CurrentTime ); XUngrabKeyboard( fgDisplay.pDisplay.Display, CurrentTime );
#endif #endif

58
freeglut/freeglut/src/Common/freeglut_init.c
View File

@ -109,7 +109,7 @@ extern void fgPlatformCloseDisplay ( void );
/* Return the atom associated with "name". */ /* Return the atom associated with "name". */
static Atom fghGetAtom(const char * name) static Atom fghGetAtom(const char * name)
{ {
return XInternAtom(fgDisplay.Display, name, False); return XInternAtom(fgDisplay.pDisplay.Display, name, False);
} }
/* /*
@ -137,7 +137,7 @@ static int fghGetWindowProperty(Window window,
unsigned long temp_bytes_after; /* Not used. */ unsigned long temp_bytes_after; /* Not used. */
status = XGetWindowProperty(fgDisplay.Display, status = XGetWindowProperty(fgDisplay.pDisplay.Display,
window, window,
property, property,
0, 0,
@ -181,7 +181,7 @@ static int fghNetWMSupported(void)
* Check that the window manager has set this property on the root window. * Check that the window manager has set this property on the root window.
* The property must be the ID of a child window. * The property must be the ID of a child window.
*/ */
number_of_windows = fghGetWindowProperty(fgDisplay.RootWindow, number_of_windows = fghGetWindowProperty(fgDisplay.pDisplay.RootWindow,
wm_check, wm_check,
XA_WINDOW, XA_WINDOW,
(unsigned char **) window_ptr_1); (unsigned char **) window_ptr_1);
@ -248,47 +248,47 @@ int fgHintPresent(Window window, Atom property, Atom hint)
*/ */
void fgPlatformInitialize( const char* displayName ) void fgPlatformInitialize( const char* displayName )
{ {
fgDisplay.Display = XOpenDisplay( displayName ); fgDisplay.pDisplay.Display = XOpenDisplay( displayName );
if( fgDisplay.Display == NULL ) if( fgDisplay.pDisplay.Display == NULL )
fgError( "failed to open display '%s'", XDisplayName( displayName ) ); fgError( "failed to open display '%s'", XDisplayName( displayName ) );
if( !glXQueryExtension( fgDisplay.Display, NULL, NULL ) ) if( !glXQueryExtension( fgDisplay.pDisplay.Display, NULL, NULL ) )
fgError( "OpenGL GLX extension not supported by display '%s'", fgError( "OpenGL GLX extension not supported by display '%s'",
XDisplayName( displayName ) ); XDisplayName( displayName ) );
fgDisplay.Screen = DefaultScreen( fgDisplay.Display ); fgDisplay.pDisplay.Screen = DefaultScreen( fgDisplay.pDisplay.Display );
fgDisplay.RootWindow = RootWindow( fgDisplay.pDisplay.RootWindow = RootWindow(
fgDisplay.Display, fgDisplay.pDisplay.Display,
fgDisplay.Screen fgDisplay.pDisplay.Screen
); );
fgDisplay.ScreenWidth = DisplayWidth( fgDisplay.ScreenWidth = DisplayWidth(
fgDisplay.Display, fgDisplay.pDisplay.Display,
fgDisplay.Screen fgDisplay.pDisplay.Screen
); );
fgDisplay.ScreenHeight = DisplayHeight( fgDisplay.ScreenHeight = DisplayHeight(
fgDisplay.Display, fgDisplay.pDisplay.Display,
fgDisplay.Screen fgDisplay.pDisplay.Screen
); );
fgDisplay.ScreenWidthMM = DisplayWidthMM( fgDisplay.ScreenWidthMM = DisplayWidthMM(
fgDisplay.Display, fgDisplay.pDisplay.Display,
fgDisplay.Screen fgDisplay.pDisplay.Screen
); );
fgDisplay.ScreenHeightMM = DisplayHeightMM( fgDisplay.ScreenHeightMM = DisplayHeightMM(
fgDisplay.Display, fgDisplay.pDisplay.Display,
fgDisplay.Screen fgDisplay.pDisplay.Screen
); );
fgDisplay.Connection = ConnectionNumber( fgDisplay.Display ); fgDisplay.pDisplay.Connection = ConnectionNumber( fgDisplay.pDisplay.Display );
/* Create the window deletion atom */ /* Create the window deletion atom */
fgDisplay.DeleteWindow = fghGetAtom("WM_DELETE_WINDOW"); fgDisplay.pDisplay.DeleteWindow = fghGetAtom("WM_DELETE_WINDOW");
/* Create the state and full screen atoms */ /* Create the state and full screen atoms */
fgDisplay.State = None; fgDisplay.pDisplay.State = None;
fgDisplay.StateFullScreen = None; fgDisplay.pDisplay.StateFullScreen = None;
if (fghNetWMSupported()) if (fghNetWMSupported())
{ {
@ -296,17 +296,17 @@ void fgPlatformInitialize( const char* displayName )
const Atom state = fghGetAtom("_NET_WM_STATE"); const Atom state = fghGetAtom("_NET_WM_STATE");
/* Check if the state hint is supported. */ /* Check if the state hint is supported. */
if (fgHintPresent(fgDisplay.RootWindow, supported, state)) if (fgHintPresent(fgDisplay.pDisplay.RootWindow, supported, state))
{ {
const Atom full_screen = fghGetAtom("_NET_WM_STATE_FULLSCREEN"); const Atom full_screen = fghGetAtom("_NET_WM_STATE_FULLSCREEN");
fgDisplay.State = state; fgDisplay.pDisplay.State = state;
/* Check if the window manager supports full screen. */ /* Check if the window manager supports full screen. */
/** Check "_NET_WM_ALLOWED_ACTIONS" on our window instead? **/ /** Check "_NET_WM_ALLOWED_ACTIONS" on our window instead? **/
if (fgHintPresent(fgDisplay.RootWindow, supported, full_screen)) if (fgHintPresent(fgDisplay.pDisplay.RootWindow, supported, full_screen))
{ {
fgDisplay.StateFullScreen = full_screen; fgDisplay.pDisplay.StateFullScreen = full_screen;
} }
} }
} }
@ -452,13 +452,13 @@ void fgPlatformCloseDisplay ( void )
* Make sure all X-client data we have created will be destroyed on * Make sure all X-client data we have created will be destroyed on
* display closing * display closing
*/ */
XSetCloseDownMode( fgDisplay.Display, DestroyAll ); XSetCloseDownMode( fgDisplay.pDisplay.Display, DestroyAll );
/* /*
* Close the display connection, destroying all windows we have * Close the display connection, destroying all windows we have
* created so far * created so far
*/ */
XCloseDisplay( fgDisplay.Display ); XCloseDisplay( fgDisplay.pDisplay.Display );
} }
#endif #endif
@ -486,7 +486,7 @@ void fgDeinitialize( void )
{ {
#if TARGET_HOST_POSIX_X11 #if TARGET_HOST_POSIX_X11
/* Note that the MVisualInfo is not owned by the MenuContext! */ /* Note that the MVisualInfo is not owned by the MenuContext! */
glXDestroyContext( fgDisplay.Display, fgStructure.MenuContext->MContext ); glXDestroyContext( fgDisplay.pDisplay.Display, fgStructure.MenuContext->MContext );
#endif #endif
free( fgStructure.MenuContext ); free( fgStructure.MenuContext );
fgStructure.MenuContext = NULL; fgStructure.MenuContext = NULL;

70
freeglut/freeglut/src/Common/freeglut_internal.h
View File

@ -214,6 +214,39 @@ LONG WINAPI ChangeDisplaySettingsExW(LPCWSTR,LPDEVMODEW,HWND,DWORD,LPVOID);
/* Platform-specific includes */ /* Platform-specific includes */
#if TARGET_HOST_POSIX_X11 #if TARGET_HOST_POSIX_X11
typedef struct tagSFG_PlatformDisplay SFG_PlatformDisplay;
struct tagSFG_PlatformDisplay
{
Display* Display; /* The display we are being run in. */
int Screen; /* The screen we are about to use. */
Window RootWindow; /* The screen's root window. */
int Connection; /* The display's connection number */
Atom DeleteWindow; /* The window deletion atom */
Atom State; /* The state atom */
Atom StateFullScreen; /* The full screen atom */
#ifdef HAVE_X11_EXTENSIONS_XRANDR_H
int prev_xsz, prev_ysz;
int prev_refresh;
int prev_size_valid;
#endif /* HAVE_X11_EXTENSIONS_XRANDR_H */
#ifdef HAVE_X11_EXTENSIONS_XF86VMODE_H
/*
* XF86VidMode may be compilable even if it fails at runtime. Therefore,
* the validity of the VidMode has to be tracked
*/
int DisplayModeValid; /* Flag that indicates runtime status*/
XF86VidModeModeLine DisplayMode; /* Current screen's display settings */
int DisplayModeClock; /* The display mode's refresh rate */
int DisplayViewPortX; /* saved X location of the viewport */
int DisplayViewPortY; /* saved Y location of the viewport */
#endif /* HAVE_X11_EXTENSIONS_XF86VMODE_H */
int DisplayPointerX; /* saved X location of the pointer */
int DisplayPointerY; /* saved Y location of the pointer */
};
#endif #endif
#if TARGET_HOST_MS_WINDOWS #if TARGET_HOST_MS_WINDOWS
#include "../mswin/freeglut_internal_mswin.h" #include "../mswin/freeglut_internal_mswin.h"
@ -366,42 +399,7 @@ struct tagSFG_State
typedef struct tagSFG_Display SFG_Display; typedef struct tagSFG_Display SFG_Display;
struct tagSFG_Display struct tagSFG_Display
{ {
#if TARGET_HOST_POSIX_X11 SFG_PlatformDisplay pDisplay;
Display* Display; /* The display we are being run in. */
int Screen; /* The screen we are about to use. */
Window RootWindow; /* The screen's root window. */
int Connection; /* The display's connection number */
Atom DeleteWindow; /* The window deletion atom */
Atom State; /* The state atom */
Atom StateFullScreen; /* The full screen atom */
#ifdef HAVE_X11_EXTENSIONS_XRANDR_H
int prev_xsz, prev_ysz;
int prev_refresh;
int prev_size_valid;
#endif /* HAVE_X11_EXTENSIONS_XRANDR_H */
#ifdef HAVE_X11_EXTENSIONS_XF86VMODE_H
/*
* XF86VidMode may be compilable even if it fails at runtime. Therefore,
* the validity of the VidMode has to be tracked
*/
int DisplayModeValid; /* Flag that indicates runtime status*/
XF86VidModeModeLine DisplayMode; /* Current screen's display settings */
int DisplayModeClock; /* The display mode's refresh rate */
int DisplayViewPortX; /* saved X location of the viewport */
int DisplayViewPortY; /* saved Y location of the viewport */
#endif /* HAVE_X11_EXTENSIONS_XF86VMODE_H */
int DisplayPointerX; /* saved X location of the pointer */
int DisplayPointerY; /* saved Y location of the pointer */
#elif TARGET_HOST_MS_WINDOWS
HINSTANCE Instance; /* The application's instance */
DEVMODE DisplayMode; /* Desktop's display settings */
char *DisplayName; /* Display name for multi display support*/
#endif
int ScreenWidth; /* The screen's width in pixels */ int ScreenWidth; /* The screen's width in pixels */
int ScreenHeight; /* The screen's height in pixels */ int ScreenHeight; /* The screen's height in pixels */

16
freeglut/freeglut/src/Common/freeglut_main.c
View File

@ -98,9 +98,9 @@ extern void fgPlatformMainLoopPreliminaryWork ( void );
#if TARGET_HOST_POSIX_X11 #if TARGET_HOST_POSIX_X11
void fgPlatformReshapeWindow ( SFG_Window *window, int width, int height ) void fgPlatformReshapeWindow ( SFG_Window *window, int width, int height )
{ {
XResizeWindow( fgDisplay.Display, window->Window.Handle, XResizeWindow( fgDisplay.pDisplay.Display, window->Window.Handle,
width, height ); width, height );
XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */ XFlush( fgDisplay.pDisplay.Display ); /* XXX Shouldn't need this */
} }
#endif #endif
@ -427,14 +427,14 @@ void fgPlatformSleepForEvents( long msec )
* need to allow that we may have an empty socket but non- * need to allow that we may have an empty socket but non-
* empty event queue. * empty event queue.
*/ */
if( ! XPending( fgDisplay.Display ) ) if( ! XPending( fgDisplay.pDisplay.Display ) )
{ {
fd_set fdset; fd_set fdset;
int err; int err;
int socket; int socket;
struct timeval wait; struct timeval wait;
socket = ConnectionNumber( fgDisplay.Display ); socket = ConnectionNumber( fgDisplay.pDisplay.Display );
FD_ZERO( &fdset ); FD_ZERO( &fdset );
FD_SET( socket, &fdset ); FD_SET( socket, &fdset );
wait.tv_sec = msec / 1000; wait.tv_sec = msec / 1000;
@ -943,9 +943,9 @@ void fgPlatformProcessSingleEvent ( void )
FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutMainLoopEvent" ); FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutMainLoopEvent" );
while( XPending( fgDisplay.Display ) ) while( XPending( fgDisplay.pDisplay.Display ) )
{ {
XNextEvent( fgDisplay.Display, &event ); XNextEvent( fgDisplay.pDisplay.Display, &event );
#if _DEBUG #if _DEBUG
fghPrintEvent( &event ); fghPrintEvent( &event );
#endif #endif
@ -958,7 +958,7 @@ void fgPlatformProcessSingleEvent ( void )
break; break;
} }
/* Destroy the window when the WM_DELETE_WINDOW message arrives */ /* Destroy the window when the WM_DELETE_WINDOW message arrives */
if( (Atom) event.xclient.data.l[ 0 ] == fgDisplay.DeleteWindow ) if( (Atom) event.xclient.data.l[ 0 ] == fgDisplay.pDisplay.DeleteWindow )
{ {
GETWINDOW( xclient ); GETWINDOW( xclient );
@ -1256,7 +1256,7 @@ void fgPlatformProcessSingleEvent ( void )
*/ */
char keys[32]; char keys[32];
XQueryKeymap( fgDisplay.Display, keys ); /* Look at X11 keystate to detect repeat mode */ XQueryKeymap( fgDisplay.pDisplay.Display, keys ); /* Look at X11 keystate to detect repeat mode */
if ( event.xkey.keycode<256 ) /* XQueryKeymap is limited to 256 keycodes */ if ( event.xkey.keycode<256 ) /* XQueryKeymap is limited to 256 keycodes */
{ {

4
freeglut/freeglut/src/Common/freeglut_menu.c
View File

@ -149,9 +149,9 @@ GLvoid fgPlatformGetGameModeVMaxExtent( SFG_Window* window, int* x, int* y )
Window w; Window w;
XTranslateCoordinates( XTranslateCoordinates(
fgDisplay.Display, fgDisplay.pDisplay.Display,
window->Window.Handle, window->Window.Handle,
fgDisplay.RootWindow, fgDisplay.pDisplay.RootWindow,
0, 0, &wx, &wy, &w); 0, 0, &wx, &wy, &w);
*x = fgState.GameModeSize.X + wx; *x = fgState.GameModeSize.X + wx;

14
freeglut/freeglut/src/mswin/freeglut_gamemode_mswin.c
View File

@ -41,11 +41,11 @@ void fgPlatformRememberState( void )
/* hack to get around my stupid cross-gcc headers */ /* hack to get around my stupid cross-gcc headers */
#define FREEGLUT_ENUM_CURRENT_SETTINGS -1 #define FREEGLUT_ENUM_CURRENT_SETTINGS -1
EnumDisplaySettings( fgDisplay.DisplayName, FREEGLUT_ENUM_CURRENT_SETTINGS, EnumDisplaySettings( fgDisplay.pDisplay.DisplayName, FREEGLUT_ENUM_CURRENT_SETTINGS,
&fgDisplay.DisplayMode ); &fgDisplay.pDisplay.DisplayMode );
/* Make sure we will be restoring all settings needed */ /* Make sure we will be restoring all settings needed */
fgDisplay.DisplayMode.dmFields |= fgDisplay.pDisplay.DisplayMode.dmFields |=
DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL | DM_DISPLAYFREQUENCY; DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL | DM_DISPLAYFREQUENCY;
} }
@ -56,7 +56,7 @@ void fgPlatformRememberState( void )
void fgPlatformRestoreState( void ) void fgPlatformRestoreState( void )
{ {
/* Restore the previously remembered desktop display settings */ /* Restore the previously remembered desktop display settings */
ChangeDisplaySettingsEx( fgDisplay.DisplayName,&fgDisplay.DisplayMode, 0,0,0 ); ChangeDisplaySettingsEx( fgDisplay.pDisplay.DisplayName,&fgDisplay.pDisplay.DisplayMode, 0,0,0 );
} }
@ -75,7 +75,7 @@ GLboolean fgPlatformChangeDisplayMode( GLboolean haveToTest )
success = GL_FALSE; success = GL_FALSE;
EnumDisplaySettings( fgDisplay.DisplayName, -1, &devMode ); EnumDisplaySettings( fgDisplay.pDisplay.DisplayName, -1, &devMode );
devMode.dmFields = 0; devMode.dmFields = 0;
if (fgState.GameModeSize.X!=-1) if (fgState.GameModeSize.X!=-1)
@ -99,7 +99,7 @@ GLboolean fgPlatformChangeDisplayMode( GLboolean haveToTest )
devMode.dmFields |= DM_DISPLAYFREQUENCY; devMode.dmFields |= DM_DISPLAYFREQUENCY;
} }
switch ( ChangeDisplaySettingsEx(fgDisplay.DisplayName, &devMode, NULL, haveToTest ? CDS_TEST : CDS_FULLSCREEN , NULL) ) switch ( ChangeDisplaySettingsEx(fgDisplay.pDisplay.DisplayName, &devMode, NULL, haveToTest ? CDS_TEST : CDS_FULLSCREEN , NULL) )
{ {
case DISP_CHANGE_SUCCESSFUL: case DISP_CHANGE_SUCCESSFUL:
success = GL_TRUE; success = GL_TRUE;
@ -107,7 +107,7 @@ GLboolean fgPlatformChangeDisplayMode( GLboolean haveToTest )
if (!haveToTest) if (!haveToTest)
{ {
/* update vars in case if windows switched to proper mode */ /* update vars in case if windows switched to proper mode */
EnumDisplaySettings( fgDisplay.DisplayName, FREEGLUT_ENUM_CURRENT_SETTINGS, &devMode ); EnumDisplaySettings( fgDisplay.pDisplay.DisplayName, FREEGLUT_ENUM_CURRENT_SETTINGS, &devMode );
fgState.GameModeSize.X = devMode.dmPelsWidth; fgState.GameModeSize.X = devMode.dmPelsWidth;
fgState.GameModeSize.Y = devMode.dmPelsHeight; fgState.GameModeSize.Y = devMode.dmPelsHeight;
fgState.GameModeDepth = devMode.dmBitsPerPel; fgState.GameModeDepth = devMode.dmBitsPerPel;

20
freeglut/freeglut/src/mswin/freeglut_init_mswin.c
View File

@ -43,9 +43,9 @@ void fgPlatformInitialize( const char* displayName )
ATOM atom; ATOM atom;
/* What we need to do is to initialize the fgDisplay global structure here. */ /* What we need to do is to initialize the fgDisplay global structure here. */
fgDisplay.Instance = GetModuleHandle( NULL ); fgDisplay.pDisplay.Instance = GetModuleHandle( NULL );
fgDisplay.DisplayName= displayName ? strdup(displayName) : 0 ; fgDisplay.pDisplay.DisplayName= displayName ? strdup(displayName) : 0 ;
atom = GetClassInfo( fgDisplay.Instance, _T("FREEGLUT"), &wc ); atom = GetClassInfo( fgDisplay.pDisplay.Instance, _T("FREEGLUT"), &wc );
if( atom == 0 ) if( atom == 0 )
{ {
@ -62,8 +62,8 @@ void fgPlatformInitialize( const char* displayName )
wc.lpfnWndProc = fgPlatformWindowProc; wc.lpfnWndProc = fgPlatformWindowProc;
wc.cbClsExtra = 0; wc.cbClsExtra = 0;
wc.cbWndExtra = 0; wc.cbWndExtra = 0;
wc.hInstance = fgDisplay.Instance; wc.hInstance = fgDisplay.pDisplay.Instance;
wc.hIcon = LoadIcon( fgDisplay.Instance, _T("GLUT_ICON") ); wc.hIcon = LoadIcon( fgDisplay.pDisplay.Instance, _T("GLUT_ICON") );
#if defined(_WIN32_WCE) #if defined(_WIN32_WCE)
wc.style = CS_HREDRAW | CS_VREDRAW; wc.style = CS_HREDRAW | CS_VREDRAW;
@ -97,9 +97,9 @@ void fgPlatformInitialize( const char* displayName )
ReleaseDC( desktop, context ); ReleaseDC( desktop, context );
} }
/* If we have a DisplayName try to use it for metrics */ /* If we have a DisplayName try to use it for metrics */
if( fgDisplay.DisplayName ) if( fgDisplay.pDisplay.DisplayName )
{ {
HDC context = CreateDC(fgDisplay.DisplayName,0,0,0); HDC context = CreateDC(fgDisplay.pDisplay.DisplayName,0,0,0);
if( context ) if( context )
{ {
fgDisplay.ScreenWidth = GetDeviceCaps( context, HORZRES ); fgDisplay.ScreenWidth = GetDeviceCaps( context, HORZRES );
@ -147,10 +147,10 @@ void fgPlatformDeinitialiseInputDevices ( void )
void fgPlatformCloseDisplay ( void ) void fgPlatformCloseDisplay ( void )
{ {
if( fgDisplay.DisplayName ) if( fgDisplay.pDisplay.DisplayName )
{ {
free( fgDisplay.DisplayName ); free( fgDisplay.pDisplay.DisplayName );
fgDisplay.DisplayName = NULL; fgDisplay.pDisplay.DisplayName = NULL;
} }
/* Reset the timer granularity */ /* Reset the timer granularity */

7
freeglut/freeglut/src/mswin/freeglut_internal_mswin.h
View File

@ -28,6 +28,13 @@
#ifndef FREEGLUT_INTERNAL_MSWIN_H #ifndef FREEGLUT_INTERNAL_MSWIN_H
#define FREEGLUT_INTERNAL_MSWIN_H #define FREEGLUT_INTERNAL_MSWIN_H
typedef struct tagSFG_PlatformDisplay SFG_PlatformDisplay;
struct tagSFG_PlatformDisplay
{
HINSTANCE Instance; /* The application's instance */
DEVMODE DisplayMode; /* Desktop's display settings */
char *DisplayName; /* Display name for multi display support*/
};

20
freeglut/freeglut/src/mswin/freeglut_window_mswin.c
View File

@ -313,12 +313,12 @@ GLboolean fgSetupPixelFormat( SFG_Window* window, GLboolean checkOnly,
/* create a dummy window */ /* create a dummy window */
ZeroMemory(&wndCls, sizeof(wndCls)); ZeroMemory(&wndCls, sizeof(wndCls));
wndCls.lpfnWndProc = DefWindowProc; wndCls.lpfnWndProc = DefWindowProc;
wndCls.hInstance = fgDisplay.Instance; wndCls.hInstance = fgDisplay.pDisplay.Instance;
wndCls.style = CS_OWNDC | CS_HREDRAW | CS_VREDRAW; wndCls.style = CS_OWNDC | CS_HREDRAW | CS_VREDRAW;
wndCls.lpszClassName = _T("FREEGLUT_dummy"); wndCls.lpszClassName = _T("FREEGLUT_dummy");
RegisterClass( &wndCls ); RegisterClass( &wndCls );
hWnd=CreateWindow(_T("FREEGLUT_dummy"), _T(""), WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_OVERLAPPEDWINDOW , 0,0,0,0, 0, 0, fgDisplay.Instance, 0 ); hWnd=CreateWindow(_T("FREEGLUT_dummy"), _T(""), WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_OVERLAPPEDWINDOW , 0,0,0,0, 0, 0, fgDisplay.pDisplay.Instance, 0 );
hDC=GetDC(hWnd); hDC=GetDC(hWnd);
SetPixelFormat( hDC, pixelformat, ppfd ); SetPixelFormat( hDC, pixelformat, ppfd );
@ -350,7 +350,7 @@ GLboolean fgSetupPixelFormat( SFG_Window* window, GLboolean checkOnly,
wglDeleteContext(rc); wglDeleteContext(rc);
ReleaseDC(hWnd, hDC); ReleaseDC(hWnd, hDC);
DestroyWindow(hWnd); DestroyWindow(hWnd);
UnregisterClass(_T("FREEGLUT_dummy"), fgDisplay.Instance); UnregisterClass(_T("FREEGLUT_dummy"), fgDisplay.pDisplay.Instance);
} }
success = ( pixelformat != 0 ) && ( checkOnly || SetPixelFormat( current_hDC, pixelformat, ppfd ) ); success = ( pixelformat != 0 ) && ( checkOnly || SetPixelFormat( current_hDC, pixelformat, ppfd ) );
@ -571,7 +571,7 @@ static BOOL CALLBACK m_proc(HMONITOR mon,
/* /*
* this function returns the origin of the screen identified by * this function returns the origin of the screen identified by
* fgDisplay.DisplayName, and 0 otherwise. * fgDisplay.pDisplay.DisplayName, and 0 otherwise.
* This is used in fgOpenWindow to open the gamemode window on the screen * This is used in fgOpenWindow to open the gamemode window on the screen
* identified by the -display command line argument. The function should * identified by the -display command line argument. The function should
* not be called otherwise. * not be called otherwise.
@ -582,12 +582,12 @@ static void get_display_origin(int *xp,int *yp)
*xp = 0; *xp = 0;
*yp = 0; *yp = 0;
if( fgDisplay.DisplayName ) if( fgDisplay.pDisplay.DisplayName )
{ {
m_proc_t st; m_proc_t st;
st.x=xp; st.x=xp;
st.y=yp; st.y=yp;
st.name=fgDisplay.DisplayName; st.name=fgDisplay.pDisplay.DisplayName;
EnumDisplayMonitors(0,0,m_proc,(LPARAM)&st); EnumDisplayMonitors(0,0,m_proc,(LPARAM)&st);
} }
} }
@ -599,7 +599,7 @@ static void get_display_origin(int *xp,int *yp)
*xp = 0; *xp = 0;
*yp = 0; *yp = 0;
if( fgDisplay.DisplayName ) if( fgDisplay.pDisplay.DisplayName )
{ {
fgWarning( "for working -display support FreeGLUT must be compiled with WINVER >= 0x0500"); fgWarning( "for working -display support FreeGLUT must be compiled with WINVER >= 0x0500");
} }
@ -624,7 +624,7 @@ void fgPlatformOpenWindow( SFG_Window* window, const char* title,
ATOM atom; ATOM atom;
/* Grab the window class we have registered on glutInit(): */ /* Grab the window class we have registered on glutInit(): */
atom = GetClassInfo( fgDisplay.Instance, _T("FREEGLUT"), &wc ); atom = GetClassInfo( fgDisplay.pDisplay.Instance, _T("FREEGLUT"), &wc );
FREEGLUT_INTERNAL_ERROR_EXIT ( atom, "Window Class Info Not Found", FREEGLUT_INTERNAL_ERROR_EXIT ( atom, "Window Class Info Not Found",
"fgOpenWindow" ); "fgOpenWindow" );
@ -748,7 +748,7 @@ void fgPlatformOpenWindow( SFG_Window* window, const char* title,
0,0, 240,320, 0,0, 240,320,
NULL, NULL,
NULL, NULL,
fgDisplay.Instance, fgDisplay.pDisplay.Instance,
(LPVOID) window (LPVOID) window
); );
@ -770,7 +770,7 @@ void fgPlatformOpenWindow( SFG_Window* window, const char* title,
x, y, w, h, x, y, w, h,
(HWND) window->Parent == NULL ? NULL : window->Parent->Window.Handle, (HWND) window->Parent == NULL ? NULL : window->Parent->Window.Handle,
(HMENU) NULL, (HMENU) NULL,
fgDisplay.Instance, fgDisplay.pDisplay.Instance,
(LPVOID) window (LPVOID) window
); );
#endif /* defined(_WIN32_WCE) */ #endif /* defined(_WIN32_WCE) */