( HWND handle, int width, int height )
#endif
{
+ SFG_Window *current_window = fgStructure.Window ;
+
/*
* Find the window that received the reshape event
*/
* we resize the window.
*/
window->State.Redisplay = TRUE ;
+
+ /*
+ * If this is a menu, restore the active window
+ */
+ if ( window->IsMenu )
+ fgSetWindow ( current_window ) ;
}
/*
(window->State.Redisplay == TRUE) &&
(window->State.Visible == TRUE) )
{
+ SFG_Window *current_window = fgStructure.Window ;
+
/*
* OKi, this is the case: have the window set as the current one
*/
* And execute the display callback immediately after
*/
window->Callbacks.Display();
+
+ fgSetWindow ( current_window ) ;
}
#elif TARGET_HOST_WIN32
*/
if( window->State.NeedToResize )
{
+ SFG_Window *current_window = fgStructure.Window ;
+
fgSetWindow( window );
fghReshapeWindowByHandle(
* Never ever do that again:
*/
window->State.NeedToResize = FALSE;
+
+ fgSetWindow ( current_window ) ;
}
/*
/*
* For every timer that is waiting for triggering
*/
- for( timer = fgState.Timers.First; timer; timer = next )
+ for( timer = (SFG_Timer *)fgState.Timers.First; timer; timer = (SFG_Timer *)next )
{
- next = timer->Node.Next;
+ next = (SFG_Timer *)timer->Node.Next;
/*
* Check for the timeout:
/*
* Add the timer to the timed out timers list
*/
- fgListRemove( &fgState.Timers, &timer->Node );
+ fgListRemove( &fgState.Timers, &timer->Node );
fgListAppend( &timedOut, &timer->Node );
}
}
* Now feel free to execute all the hooked and timed out timer callbacks
* And delete the timed out timers...
*/
- while ( (timer = timedOut.First) )
+ while ( (timer = (SFG_Timer *)timedOut.First) )
{
if( timer->Callback != NULL )
timer->Callback( timer->ID );
va_end( ap );
}
-/*
- * Clean up on exit
- */
-static void fgCleanUpGlutsMess( void )
-{
- int i;
-
- i = 0;
-
- if ( fgStructure.Windows.First != NULL )
- {
- SFG_Window *win = fgStructure.Windows.First ;
- glEnd();
- glFinish();
- glFlush();
- while ( win != NULL )
- {
- SFG_Window *temp_win = win->Node.Next ;
- fgDestroyWindow ( win, FALSE ) ;
- win = temp_win ;
- }
- }
-
-#if 0
- /* these are pointers to external handles */
-
- __glutWindowListSize = 0;
- __glutStaleWindowList = NULL;
- __glutWindowList = NULL;
- __glutCurrentWindow = NULL;
-
- /* make sure we no longer have a GL context */
-
- if ( wglGetCurrentContext() != NULL )
- {
- wglDeleteContext( wglGetCurrentContext() );
- }
-
- hInstance = GetModuleHandle(NULL);
- UnregisterClass( classname, hInstance );
-
- /* clean up allocated timer memory */
-
- tList = __glutTimerList;
- i = 0;
-
- while ( __glutTimerList )
- {
- i++;
- tList = __glutTimerList;
-
- if ( __glutTimerList )
- __glutTimerList = __glutTimerList->next;
-
- if ( tList )
- free( tList );
- }
-#endif
-}
-
-
/* -- INTERFACE FUNCTIONS -------------------------------------------------- */
/*
* Grab the next event to be processed...
*/
XNextEvent( fgDisplay.Display, &event );
- window = fgWindowByHandle ( event.xany.window ) ;
/*
* Check the event's type
/*
* Call the window closure callback, remove from the structure, etc.
*/
- fgStructure.Window = window ;
/* fgAddToWindowDestroyList ( window, FALSE ); */
break;
*/
if( (Atom) event.xclient.data.l[ 0 ] == fgDisplay.DeleteWindow )
{
- fgStructure.Window = window ;
+ GETWINDOW( xclient );
/*
* Call the XWindows functions to close the window
* We are too dumb to process partial exposes...
*/
if( event.xexpose.count == 0 )
- fghRedrawWindowByHandle( window->Window.Handle );
+ fghRedrawWindowByHandle( event.xexpose.window );
break;
case ConfigureNotify:
/*
* The window's visiblity might have changed
*/
+ GETWINDOW( xvisibility );
+
/*
* Break now if no window status callback has been hooked to that window
*/
/*
* Mouse is over one of our windows
*/
- GETMOUSE( xcrossing );
+ GETWINDOW( xcrossing ); GETMOUSE( xcrossing );
/*
* Is there an entry callback hooked to the window?
if( window->Callbacks.Entry != NULL )
{
/*
+ * Set the current window
+ */
+ fgSetWindow ( window ) ;
+
+ /*
* Yeah. Notify the window about having the mouse cursor over
*/
window->Callbacks.Entry( GLUT_ENTERED );
/*
* Mouse is no longer over one of our windows
*/
- GETMOUSE( xcrossing );
+ GETWINDOW( xcrossing ); GETMOUSE( xcrossing );
/*
* Is there an entry callback hooked to the window?
if( window->Callbacks.Entry != NULL )
{
/*
+ * Set the current window
+ */
+ fgSetWindow ( window ) ;
+
+ /*
* Yeah. Notify the window about having the mouse cursor over
*/
window->Callbacks.Entry( GLUT_LEFT );
/*
* The mouse cursor was moved...
*/
- GETMOUSE( xmotion );
+ GETWINDOW( xmotion ); GETMOUSE( xmotion );
/*
- * Set the current window
+ * Fallback if there's an active menu hooked to this window
*/
- fgStructure.Window = window ;
+ if( window->ActiveMenu != NULL )
+ {
+ /*
+ * Let's make the window redraw as a result of the mouse motion.
+ */
+ window->State.Redisplay = TRUE ;
+
+ /*
+ * Since the window is a menu, make the parent window current
+ */
+ fgSetWindow ( window->ActiveMenu->ParentWindow ) ;
+
+ break;
+ }
/*
* What kind of a movement was it?
if( window->Callbacks.Motion != NULL )
{
/*
+ * Set the current window
+ */
+ fgSetWindow ( window ) ;
+
+ /*
* Yup. Have it executed immediately
*/
window->Callbacks.Motion( event.xmotion.x, event.xmotion.y );
if( window->Callbacks.Passive != NULL )
{
/*
+ * Set the current window
+ */
+ fgSetWindow ( window ) ;
+
+ /*
* That's right, and there is a passive callback, too.
*/
window->Callbacks.Passive( event.xmotion.x, event.xmotion.y );
* A mouse button has been pressed or released. Traditionally,
* break if the window was found within the freeglut structures.
*/
- GETMOUSE( xbutton );
+ GETWINDOW( xbutton ); GETMOUSE( xbutton );
/*
* GLUT API assumes that you can't have more than three mouse buttons, so:
/* Save the current window and menu and set the current window to the window whose menu this is */
SFG_Window *save_window = fgStructure.Window ;
SFG_Menu *save_menu = fgStructure.Menu ;
+ SFG_Window *parent_window = window->ActiveMenu->ParentWindow ;
fgSetWindow ( window ) ;
fgStructure.Menu = window->ActiveMenu ;
/* Execute the menu callback */
fgExecuteMenuCallback ( window->ActiveMenu ) ;
- fgDeactivateMenu ( window ) ;
+ fgDeactivateMenu ( parent_window ) ;
/* Restore the current window and menu */
fgSetWindow ( save_window ) ;
}
else /* Outside the menu, deactivate the menu if it's a downclick */
{
- if ( pressed == TRUE ) fgDeactivateMenu ( window ) ;
+ if ( pressed == TRUE ) fgDeactivateMenu ( window->ActiveMenu->ParentWindow ) ;
}
/*
window->State.Redisplay = TRUE ;
/*
+ * Set the current window
+ */
+ fgSetWindow( window );
+
+ /*
* Activate the appropriate menu structure...
*/
fgActivateMenu( window, button );
/*
* Set the current window
*/
- fgSetWindow( window );
+ fgSetWindow ( window );
/*
* Remember the current modifiers state
modifiers |= GLUT_ACTIVE_CTRL;
if (event.xbutton.state & Mod1Mask)
modifiers |= GLUT_ACTIVE_ALT;
- window->State.Modifiers = modifiers;
+ fgStructure.Window->State.Modifiers = modifiers;
/*
* Finally execute the mouse callback
*/
- window->Callbacks.Mouse(
+ fgStructure.Window->Callbacks.Mouse(
button,
event.type == ButtonPress ? GLUT_DOWN : GLUT_UP,
event.xbutton.x,
/*
* Trash the modifiers state
*/
- window->State.Modifiers = 0xffffffff;
+ fgStructure.Window->State.Modifiers = 0xffffffff;
}
break;
/*
* A key has been pressed, find the window that had the focus:
*/
- GETMOUSE( xkey );
+ GETWINDOW( xkey ); GETMOUSE( xkey );
if( event.type == KeyPress )
{
len = XLookupString( &event.xkey, asciiCode, sizeof(asciiCode), &keySym, &composeStatus );
/*
- * Get ready to calling the keyboard/special callbacks
- */
- fgSetWindow( window );
-
- /*
* GLUT API tells us to have two separate callbacks...
*/
if( len > 0 )
if( keyboard_cb != NULL )
{
/*
+ * Set the current window
+ */
+ fgSetWindow( window );
+
+ /*
* Remember the current modifiers state
*/
modifiers = 0;
if( (special_cb != NULL) && (special != -1) )
{
/*
+ * Set the current window
+ */
+ fgSetWindow( window );
+
+ /*
* Remember the current modifiers state
*/
modifiers = 0;
fghDisplayAll();
}
#endif
+
+ /*
+ * If an event caused a window to be closed, do the actual closing here
+ */
+ fgCloseWindows () ;
}
/*
void FGAPIENTRY glutMainLoop( void )
{
#if TARGET_HOST_WIN32
- SFG_Window *window = fgStructure.Windows.First ;
+ SFG_Window *window = (SFG_Window *)fgStructure.Windows.First ;
#endif
/*
while ( window != NULL )
{
if ( window->Callbacks.Visibility != NULL )
+ {
+ SFG_Window *current_window = fgStructure.Window ;
+
+ /*
+ * Set the current window
+ */
+ fgSetWindow( window );
+
window->Callbacks.Visibility ( window->State.Visible ) ;
- window = window->Node.Next ;
+ /*
+ * Restore the current window
+ */
+ fgSetWindow( current_window );
+ }
+
+ window = (SFG_Window *)window->Node.Next ;
}
#endif
glutMainLoopEvent () ;
/*
- * If an event caused a window to be closed, do the actual closing here
- */
- fgCloseWindows () ;
-
- /*
* If there are no more windows open, stop execution
*/
if ( fgStructure.Windows.First == NULL )
fgState.ExecState = GLUT_EXEC_STATE_STOP ;
}
+ {
+ fgExecutionState execState = fgState.ActionOnWindowClose;
- /*
- * If we got here by the user closing a window or by the application closing down, there may still be windows open.
- */
- fgCleanUpGlutsMess () ;
-
- /*
- * Check whether we return to the calling program or simply exit
- */
- if ( fgState.ActionOnWindowClose == GLUT_ACTION_EXIT )
- exit ( 0 ) ;
+ /*
+ * When this loop terminates, destroy the display, state and structure
+ * of a freeglut session, so that another glutInit() call can happen
+ */
+ fgDeinitialize();
- /*
- * When this loop terminates, destroy the display, state and structure
- * of a freeglut session, so that another glutInit() call can happen
- */
- fgDeinitialize();
+ /*
+ * Check whether we return to the calling program or simply exit
+ */
+ if ( execState == GLUT_ACTION_EXIT )
+ exit ( 0 ) ;
+ }
}
/*
window->Window.Device = GetDC( hWnd );
/*
- * Setup the pixel format of our window
- */
- fgSetupPixelFormat( window, FALSE, PFD_MAIN_PLANE );
-
- /*
* Create or get the OpenGL rendering context now
*/
- if ( fgState.UseCurrentContext == TRUE )
- window->Window.Context = wglGetCurrentContext();
- else
+ if ( fgState.BuildingAMenu )
+ {
+ /*
+ * Setup the pixel format of our window
+ */
+ unsigned int current_DisplayMode = fgState.DisplayMode ;
+ fgState.DisplayMode = GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH ;
+ fgSetupPixelFormat( window, FALSE, PFD_MAIN_PLANE );
+ fgState.DisplayMode = current_DisplayMode ;
+
+ /*
+ * If there isn't already an OpenGL rendering context for menu windows, make one
+ */
+ if ( !fgStructure.MenuContext )
+ {
+ fgStructure.MenuContext = (SFG_MenuContext *)malloc ( sizeof(SFG_MenuContext) ) ;
+ fgStructure.MenuContext->Context = wglCreateContext( window->Window.Device );
+ }
+ else
+ wglMakeCurrent ( window->Window.Device, fgStructure.MenuContext->Context ) ;
+
+/* window->Window.Context = wglGetCurrentContext () ; */
window->Window.Context = wglCreateContext( window->Window.Device );
+ }
+ else
+ {
+ /*
+ * Setup the pixel format of our window
+ */
+ fgSetupPixelFormat( window, FALSE, PFD_MAIN_PLANE );
+
+ if ( fgState.UseCurrentContext == TRUE )
+ {
+ window->Window.Context = wglGetCurrentContext();
+ if ( ! window->Window.Context )
+ window->Window.Context = wglCreateContext( window->Window.Device );
+ }
+ else
+ window->Window.Context = wglCreateContext( window->Window.Device );
+ }
/*
* Still, we'll be needing to explicitly resize the window
/* Step through the list of windows. If the rendering context is notbeing used
* by another window, then we delete it.
*/
- for ( iter = fgStructure.Windows.First; iter; iter = iter->Node.Next )
+ for ( iter = (SFG_Window *)fgStructure.Windows.First; iter; iter = (SFG_Window *)iter->Node.Next )
{
if ( ( iter->Window.Context == window->Window.Context ) && ( iter != window ) )
used = TRUE ;
/*
* Fallback if there's an active menu hooked to this window
*/
- if( window->ActiveMenu != NULL )
+ if ( window->ActiveMenu != NULL )
{
/*
* Let's make the window redraw as a result of the mouse motion.
*/
window->State.Redisplay = TRUE ;
+ /*
+ * Since the window is a menu, make the parent window current
+ */
+ fgSetWindow ( window->ActiveMenu->ParentWindow ) ;
+
break;
}
/* Save the current window and menu and set the current window to the window whose menu this is */
SFG_Window *save_window = fgStructure.Window ;
SFG_Menu *save_menu = fgStructure.Menu ;
+ SFG_Window *parent_window = window->ActiveMenu->ParentWindow ;
fgSetWindow ( window ) ;
fgStructure.Menu = window->ActiveMenu ;
/* Execute the menu callback */
fgExecuteMenuCallback ( window->ActiveMenu ) ;
- fgDeactivateMenu ( window ) ;
+ fgDeactivateMenu ( parent_window ) ;
/* Restore the current window and menu */
fgSetWindow ( save_window ) ;
}
else /* Outside the menu, deactivate the menu if it's a downclick */
{
- if ( pressed == TRUE ) fgDeactivateMenu ( window ) ;
+ if ( pressed == TRUE ) fgDeactivateMenu ( window->ActiveMenu->ParentWindow ) ;
}
/*
* Let's make the window redraw as a result of the mouse click and menu activity.
*/
- window->State.Redisplay = TRUE ;
+ if ( ! window->IsMenu ) window->State.Redisplay = TRUE ;
break ;
}
window->State.Redisplay = TRUE ;
/*
+ * Set the current window
+ */
+ fgSetWindow( window );
+
+ /*
* Activate the appropriate menu structure...
*/
fgActivateMenu( window, button );
/*
* Set the current window
*/
- fgSetWindow( window );
+ fgSetWindow ( window );
/*
* Remember the current modifiers state.
*/
- window->State.Modifiers =
+ fgStructure.Window->State.Modifiers =
( ( (GetKeyState( VK_LSHIFT ) < 0 ) || ( GetKeyState( VK_RSHIFT ) < 0 )) ? GLUT_ACTIVE_SHIFT : 0 ) |
( ( (GetKeyState( VK_LCONTROL ) < 0 ) || ( GetKeyState( VK_RCONTROL ) < 0 )) ? GLUT_ACTIVE_CTRL : 0 ) |
( ( (GetKeyState( VK_LMENU ) < 0 ) || ( GetKeyState( VK_RMENU ) < 0 )) ? GLUT_ACTIVE_ALT : 0 );
/*
* Trash the modifiers state
*/
- window->State.Modifiers = 0xffffffff;
+ fgStructure.Window->State.Modifiers = 0xffffffff;
}
break;
break;
/*
- * Set the current window
- */
- fgSetWindow( window );
-
- /*
* Remember the current modifiers state. This is done here in order
* to make sure the VK_DELETE keyboard callback is executed properly.
*/
* The delete key should be treated as an ASCII keypress:
*/
if( window->Callbacks.Keyboard != NULL )
+ {
+ fgSetWindow( window );
window->Callbacks.Keyboard( 127, window->State.MouseX, window->State.MouseY );
+ }
}
/*
if( (keypress != -1) && (window->Callbacks.Special != NULL) )
{
/*
+ * Set the current window
+ */
+ fgSetWindow( window );
+
+ /*
* Have the special callback executed:
*/
window->Callbacks.Special( keypress, window->State.MouseX, window->State.MouseY );
POINT mouse_pos ;
/*
- * Set the current window
- */
- fgSetWindow( window );
-
- /*
* Remember the current modifiers state. This is done here in order
* to make sure the VK_DELETE keyboard callback is executed properly.
*/
* The delete key should be treated as an ASCII keypress:
*/
if( window->Callbacks.KeyboardUp != NULL )
+ {
+ fgSetWindow ( window ) ;
window->Callbacks.KeyboardUp( 127, window->State.MouseX, window->State.MouseY );
+ }
break ;
default:
wParam=code[ 0 ];
if( window->Callbacks.KeyboardUp != NULL )
+ {
+ /*
+ * Set the current window
+ */
+ fgSetWindow( window );
+
window->Callbacks.KeyboardUp( (char)wParam, window->State.MouseX, window->State.MouseY );
+ }
}
}
if( (keypress != -1) && (window->Callbacks.SpecialUp != NULL) )
{
/*
+ * Set the current window
+ */
+ fgSetWindow( window );
+
+ /*
* Have the special callback executed:
*/
window->Callbacks.SpecialUp( keypress, window->State.MouseX, window->State.MouseY );
if( window->Callbacks.Keyboard != NULL )
{
/*
+ * Set the current window
+ */
+ fgSetWindow( window );
+
+ /*
* Remember the current modifiers state
*/
window->State.Modifiers =
case WM_CAPTURECHANGED : /* User has finished resizing the window, force a redraw */
if ( window->Callbacks.Display )
+ {
+ /*
+ * Set the current window
+ */
+ fgSetWindow( window );
+
window->Callbacks.Display () ;
+ }
/* lRet = DefWindowProc( hWnd, uMsg, wParam, lParam ) ; */
break ;
projects / freeglut / blobdiff