/* * Deactivates a menu pointed by the function argument. */ void fgDeactivateSubMenu( SFG_MenuEntry *menuEntry ) { SFG_Window *current_window = fgStructure.Window; SFG_MenuEntry *subMenuIter; /* * Hide the present menu's window */ fgSetWindow( menuEntry->SubMenu->Window ); glutHideWindow( ); /* * Forget about having that menu active anymore, now: */ menuEntry->SubMenu->Window->ActiveMenu = NULL; menuEntry->SubMenu->IsActive = GL_FALSE; /* * Hide all submenu windows, and the root menu's window. */ for ( subMenuIter = (SFG_MenuEntry *)menuEntry->SubMenu->Entries.First; subMenuIter; subMenuIter = (SFG_MenuEntry *)subMenuIter->Node.Next ) { /* * Is that an active submenu by any case? */ if( subMenuIter->SubMenu ) fgDeactivateSubMenu( subMenuIter ); } fgSetWindow( current_window ); }
void fgFinishMenu(SFG_Window *win, int x, int y) { unmapMenu(fgMappedMenu); if(fgState.MenuStatusCallback) { fgSetWindow(fgMenuWindow); fgSetMenu(fgMappedMenu); /* Setting fgMappedMenu to NULL permits operations that change menus or destroy the menu window again. */ fgMappedMenu = NULL; fgState.MenuStatusCallback(GLUT_MENU_NOT_IN_USE, x, y); } /* Setting fgMappedMenu to NULL permits operations that change menus or destroy the menu window again. */ fgMappedMenu = NULL; /* If an item is selected and it is not a submenu trigger, generate menu callback. */ if(fgItemSelected && !fgItemSelected->IsTrigger) { fgSetWindow(fgMenuWindow); /* When menu callback is triggered, current menu should be set to the callback menu. */ fgSetMenu(fgItemSelected->Menu); fgItemSelected->Menu->Select(fgItemSelected->Value); } fgMenuWindow = NULL; }
/* * Calls a window's redraw method. This is used when * a redraw is forced by the incoming window messages, * or if a redisplay is otherwise pending. * this is lean and mean without checks as it is * currently only called from fghcbDisplayWindow which * only calls this if the window is visible and needs * a redisplay. * Note that the fgSetWindow call on Windows makes the * right device context current on windows, allowing * direct drawing without BeginPaint/EndPaint in the * WM_PAINT handler. */ void fghRedrawWindow ( SFG_Window *window ) { SFG_Window *current_window = fgStructure.CurrentWindow; fgSetWindow( window ); INVOKE_WCB( *window, Display, ( ) ); fgSetWindow( current_window ); }
/* * Displays the currently active menu for the current window */ void fgDisplayMenu( void ) { SFG_Window* window = fgStructure.Window; SFG_Menu* menu = NULL; freeglut_assert_window; /* * Check if there is an active menu attached to this window... */ menu = window->ActiveMenu; freeglut_return_if_fail( menu ); fgSetWindow( menu->Window ); glPushAttrib( GL_DEPTH_BUFFER_BIT | GL_TEXTURE_BIT | GL_LIGHTING_BIT | GL_POLYGON_BIT ); glDisable( GL_DEPTH_TEST ); glDisable( GL_TEXTURE_2D ); glDisable( GL_LIGHTING ); glDisable( GL_CULL_FACE ); glMatrixMode( GL_PROJECTION ); glPushMatrix( ); glLoadIdentity( ); glOrtho( 0, glutGet( GLUT_WINDOW_WIDTH ), glutGet( GLUT_WINDOW_HEIGHT ), 0, -1, 1 ); glMatrixMode( GL_MODELVIEW ); glPushMatrix( ); glLoadIdentity( ); fghCheckMenuStatus( window, menu ); fghDisplayMenuBox( menu ); glPopAttrib( ); glMatrixMode( GL_PROJECTION ); glPopMatrix( ); glMatrixMode( GL_MODELVIEW ); glPopMatrix( ); glutSwapBuffers( ); fgSetWindow ( window ); }
/* * Displays the currently active menu for the current window */ void fgDisplayMenu( void ) { SFG_Window* window = fgStructure.CurrentWindow; SFG_Menu* menu = NULL; FREEGLUT_INTERNAL_ERROR_EXIT ( fgStructure.CurrentWindow, "Displaying menu in nonexistent window", "fgDisplayMenu" ); if (!window) return; /* Check if there is an active menu attached to this window... */ menu = window->ActiveMenu; freeglut_return_if_fail( menu ); fgSetWindow( menu->Window ); glPushAttrib( GL_DEPTH_BUFFER_BIT | GL_TEXTURE_BIT | GL_LIGHTING_BIT | GL_POLYGON_BIT ); glDisable( GL_DEPTH_TEST ); glDisable( GL_TEXTURE_2D ); glDisable( GL_LIGHTING ); glDisable( GL_CULL_FACE ); glMatrixMode( GL_PROJECTION ); glPushMatrix( ); glLoadIdentity( ); glOrtho( 0, glutGet( GLUT_WINDOW_WIDTH ), glutGet( GLUT_WINDOW_HEIGHT ), 0, -1, 1 ); glMatrixMode( GL_MODELVIEW ); glPushMatrix( ); glLoadIdentity( ); fghDisplayMenuBox( menu ); glPopAttrib( ); glMatrixMode( GL_PROJECTION ); glPopMatrix( ); glMatrixMode( GL_MODELVIEW ); glPopMatrix( ); glutSwapBuffers( ); fgSetWindow ( window ); }
/* * Activates a menu pointed by the function argument */ static void fghActivateMenu( SFG_Window* window, int button ) { int max_x, max_y; /* We'll be referencing this menu a lot, so remember its address: */ SFG_Menu* menu = window->Menu[ button ]; SFG_Window* current_window = fgStructure.CurrentWindow; /* If the menu is already active in another window, deactivate it there */ if ( menu->ParentWindow ) menu->ParentWindow->ActiveMenu = NULL ; /* Mark the menu as active, so that it gets displayed: */ window->ActiveMenu = menu; menu->IsActive = GL_TRUE; fghSetMenuParentWindow ( window, menu ); fgState.ActiveMenus++; /* Set up the initial menu position now: */ fghGetVMaxExtent(menu->ParentWindow, &max_x, &max_y); fgSetWindow( window ); menu->X = window->State.MouseX + glutGet( GLUT_WINDOW_X ); menu->Y = window->State.MouseY + glutGet( GLUT_WINDOW_Y ); if( menu->X + menu->Width > max_x ) menu->X -=menu->Width; if( menu->Y + menu->Height > max_y ) { menu->Y -=menu->Height; if( menu->Y < 0 ) menu->Y = 0; } menu->Window->State.MouseX = window->State.MouseX + glutGet( GLUT_WINDOW_X ) - menu->X; menu->Window->State.MouseY = window->State.MouseY + glutGet( GLUT_WINDOW_Y ) - menu->Y; fgSetWindow( menu->Window ); glutPositionWindow( menu->X, menu->Y ); glutReshapeWindow( menu->Width, menu->Height ); glutPopWindow( ); glutShowWindow( ); menu->Window->ActiveMenu = menu; fghCheckMenuStatus( menu ); fgSetWindow( current_window ); }
void fgStartMenu(SFG_WinMenu * menu, SFG_Window * window, int x, int y, int x_win, int y_win) { assert(fgMappedMenu == NULL); fgMappedMenu = menu; fgMenuWindow = window; fgItemSelected = NULL; if(fgState.MenuStatusCallback) { fgSetMenu(menu); fgSetWindow(window); fgState.MenuStatusCallback(GLUT_MENU_IN_USE, x_win, y_win); } eglSwapBuffers(fgDisplay.eglDisplay, window->Window.Surface); RedrawWindow(window->Window.Handle, NULL, NULL, RDW_INTERNALPAINT); #ifndef _WIN32_WCE TrackPopupMenu(menu->Handle, TPM_LEFTALIGN | (fgMenuButton == TPM_RIGHTBUTTON) ? TPM_RIGHTBUTTON : TPM_LEFTBUTTON, x, y, 0, fgStructure.Window->Window.Handle, NULL); #else TrackPopupMenu(menu->Handle, TPM_LEFTALIGN, x, y, 0, fgStructure.Window->Window.Handle, NULL); #endif }
void fgPlatformMainLoopPreliminaryWork ( void ) { SFG_Window *window = (SFG_Window *)fgStructure.Windows.First ; /* * Processing before the main loop: If there is a window which is open and * which has a visibility callback, call it. I know this is an ugly hack, * but I'm not sure what else to do about it. Ideally we should leave * something uninitialized in the create window code and initialize it in * the main loop, and have that initialization create a "WM_ACTIVATE" * message. Then we would put the visibility callback code in the * "case WM_ACTIVATE" block below. - John Fay -- 10/24/02 */ while( window ) { if ( FETCH_WCB( *window, Visibility ) ) { SFG_Window *current_window = fgStructure.CurrentWindow ; INVOKE_WCB( *window, Visibility, ( window->State.Visible ) ); fgSetWindow( current_window ); } window = (SFG_Window *)window->Node.Next ; } }
void fghOnReshapeNotify(SFG_Window *window, int width, int height, GLboolean forceNotify) { GLboolean notify = GL_FALSE; if( width != window->State.Width || height != window->State.Height ) { window->State.Width = width; window->State.Height = height; notify = GL_TRUE; } if (notify || forceNotify) { SFG_Window *saved_window = fgStructure.CurrentWindow; INVOKE_WCB( *window, Reshape, ( width, height ) ); /* * Force a window redraw. In Windows at least this is only a partial * solution: if the window is increasing in size in either dimension, * the already-drawn part does not get drawn again and things look funny. * But without this we get this bad behaviour whenever we resize the * window. * DN: Hmm.. the above sounds like a concern only in single buffered mode... */ window->State.WorkMask |= GLUT_DISPLAY_WORK; if( window->IsMenu ) fgSetWindow( saved_window ); } }
/* * This private function creates a menu and adds it to the menus list */ SFG_Menu* fgCreateMenu( FGCBMenu menuCallback ) { int x = 100, y = 100, w = 1, h = 1; SFG_Window *current_window = fgStructure.CurrentWindow; /* Have the menu object created */ SFG_Menu* menu = (SFG_Menu *)calloc( sizeof(SFG_Menu), 1 ); menu->ParentWindow = NULL; /* Create a window for the menu to reside in. */ fgCreateWindow( NULL, "freeglut menu", GL_TRUE, x, y, GL_TRUE, w, h, GL_FALSE, GL_TRUE ); menu->Window = fgStructure.CurrentWindow; glutDisplayFunc( fgDisplayMenu ); glutHideWindow( ); /* Hide the window for now */ fgSetWindow( current_window ); /* Initialize the object properties: */ menu->ID = ++fgStructure.MenuID; menu->Callback = menuCallback; menu->ActiveEntry = NULL; fgListInit( &menu->Entries ); fgListAppend( &fgStructure.Menus, &menu->Node ); /* Newly created menus implicitly become current ones */ fgStructure.CurrentMenu = menu; return menu; }
/* * Opens a window. Requires a SFG_Window object created and attached * to the freeglut structure. OpenGL context is created here. */ void fgOpenWindow( SFG_Window* window, const char* title, GLboolean positionUse, int x, int y, GLboolean sizeUse, int w, int h, GLboolean gameMode, GLboolean isSubWindow ) { fgPlatformOpenWindow( window, title, positionUse, x, y, sizeUse, w, h, gameMode, isSubWindow ); fgSetWindow( window ); window->Window.DoubleBuffered = ( fgState.DisplayMode & GLUT_DOUBLE ) ? 1 : 0; #ifndef EGL_VERSION_1_0 /* No glDrawBuffer/glReadBuffer in GLES */ if ( ! window->Window.DoubleBuffered ) { glDrawBuffer ( GL_FRONT ); glReadBuffer ( GL_FRONT ); } #endif window->Window.attribute_v_coord = -1; window->Window.attribute_v_normal = -1; fgInitGL2(); window->State.NeedToInitContext = GL_TRUE; }
/* * This function destroys a window and all of its subwindows. Actually, * another function, defined in freeglut_window.c is called, but this is * a whole different story... */ void fgDestroyWindow( SFG_Window* window ) { FREEGLUT_INTERNAL_ERROR_EXIT ( window, "Window destroy function called with null window", "fgDestroyWindow" ); while( window->Children.First ) fgDestroyWindow( ( SFG_Window * )window->Children.First ); { SFG_Window *activeWindow = fgStructure.CurrentWindow; INVOKE_WCB( *window, Destroy, ( ) ); fgSetWindow( activeWindow ); } if( window->Parent ) fgListRemove( &window->Parent->Children, &window->Node ); else fgListRemove( &fgStructure.Windows, &window->Node ); if( window->ActiveMenu ) fgDeactivateMenu( window ); fghClearCallBacks( window ); fgCloseWindow( window ); free( window ); if( fgStructure.CurrentWindow == window ) fgStructure.CurrentWindow = NULL; }
/* * Activates a menu pointed by the function argument */ void fgActivateMenu( SFG_Window* window, int button ) { /* * We'll be referencing this menu a lot, so remember its address: */ SFG_Menu* menu = window->Menu[ button ]; /* * Mark the menu as active, so that it gets displayed: */ window->ActiveMenu = menu; menu->IsActive = GL_TRUE; fgState.ActiveMenus++; /* * Set up the initial menu position now: */ menu->X = window->State.MouseX + glutGet( GLUT_WINDOW_X ); menu->Y = window->State.MouseY + glutGet( GLUT_WINDOW_Y ); if( menu->X + menu->Width > glutGet ( GLUT_SCREEN_WIDTH ) ) menu->X -=menu->Width; if( menu->Y + menu->Height > glutGet ( GLUT_SCREEN_HEIGHT ) ) menu->Y -=menu->Height; fgSetWindow( menu->Window ); glutPositionWindow( menu->X, menu->Y ); glutReshapeWindow( menu->Width, menu->Height ); glutPopWindow( ); glutShowWindow( ); menu->Window->ActiveMenu = menu; }
/* * Deactivates a menu pointed by the function argument. */ void fgDeactivateMenu( SFG_Window *window ) { SFG_Window *current_window = fgStructure.Window; /* * Check if there is an active menu attached to this window... */ SFG_Menu* menu = window->ActiveMenu; SFG_MenuEntry *menuEntry; /* * Did we find an active window? */ freeglut_return_if_fail( menu ); /* * Hide the present menu's window */ fgSetWindow( menu->Window ); glutHideWindow( ); /* * Forget about having that menu active anymore, now: */ menu->Window->ActiveMenu = NULL; menu->ParentWindow->ActiveMenu = NULL; menu->IsActive = GL_FALSE; fgState.ActiveMenus--; /* * Hide all submenu windows, and the root menu's window. */ for ( menuEntry = ( SFG_MenuEntry * )menu->Entries.First; menuEntry; menuEntry = ( SFG_MenuEntry * )menuEntry->Node.Next ) { /* * Is that an active submenu by any case? */ if( menuEntry->SubMenu ) fgDeactivateSubMenu( menuEntry ); } fgSetWindow( current_window ); }
/* * This function destroys a menu specified by the parameter. All menus * and windows are updated to make sure no ill pointers hang around. */ void fgDestroyMenu( SFG_Menu* menu ) { SFG_Window *window; SFG_Menu *from; FREEGLUT_INTERNAL_ERROR_EXIT ( menu, "Menu destroy function called with null menu", "fgDestroyMenu" ); /* First of all, have all references to this menu removed from all windows: */ for( window = (SFG_Window *)fgStructure.Windows.First; window; window = (SFG_Window *)window->Node.Next ) fghRemoveMenuFromWindow( window, menu ); /* Now proceed with removing menu entries that lead to this menu */ for( from = ( SFG_Menu * )fgStructure.Menus.First; from; from = ( SFG_Menu * )from->Node.Next ) fghRemoveMenuFromMenu( from, menu ); /* * If the programmer defined a destroy callback, call it * A. Donev: But first make this the active menu */ if( menu->Destroy ) { SFG_Menu *activeMenu=fgStructure.CurrentMenu; fgStructure.CurrentMenu = menu; menu->Destroy( ); fgStructure.CurrentMenu = activeMenu; } /* * Now we are pretty sure the menu is not used anywhere * and that we can remove all of its entries */ while( menu->Entries.First ) { SFG_MenuEntry *entry = ( SFG_MenuEntry * ) menu->Entries.First; fgListRemove( &menu->Entries, &entry->Node ); if( entry->Text ) free( entry->Text ); entry->Text = NULL; free( entry ); } if( fgStructure.CurrentWindow == menu->Window ) fgSetWindow( NULL ); fgDestroyWindow( menu->Window ); fgListRemove( &fgStructure.Menus, &menu->Node ); if( fgStructure.CurrentMenu == menu ) fgStructure.CurrentMenu = NULL; free( menu ); }
/* * This function selects the current window */ void FGAPIENTRY glutSetWindow( int ID ) { SFG_Window* window = NULL; freeglut_assert_ready; if( fgStructure.Window != NULL ) if( fgStructure.Window->ID == ID ) return; window = fgWindowByID( ID ); if( window == NULL ) { fgWarning( "glutSetWindow(): window ID %i not found!", ID ); return; } fgSetWindow( window ); }
/* * This function selects the current window */ void FGAPIENTRY glutSetWindow( int ID ) { SFG_Window* window = NULL; FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSetWindow" ); if( fgStructure.CurrentWindow != NULL ) if( fgStructure.CurrentWindow->ID == ID ) return; window = fgWindowByID( ID ); if( window == NULL ) { fgWarning( "glutSetWindow(): window ID %d not found!", ID ); return; } fgSetWindow( window ); }
void fghOnPositionNotify(SFG_Window *window, int x, int y, GLboolean forceNotify) { GLboolean notify = GL_FALSE; if( x != window->State.Xpos || y != window->State.Ypos ) { window->State.Xpos = x; window->State.Ypos = y; notify = GL_TRUE; } if (notify || forceNotify) { SFG_Window *saved_window = fgStructure.CurrentWindow; INVOKE_WCB( *window, Position, ( x, y ) ); fgSetWindow( saved_window ); } }
static void fghReshapeWindow ( SFG_Window *window, int width, int height ) { SFG_Window *current_window = fgStructure.CurrentWindow; freeglut_return_if_fail( window != NULL ); fgPlatformReshapeWindow ( window, width, height ); /* * Force a window redraw. In Windows at least this is only a partial * solution: if the window is increasing in size in either dimension, * the already-drawn part does not get drawn again and things look funny. * But without this we get this bad behaviour whenever we resize the * window. * DN: Hmm.. the above sounds like a concern only in single buffered mode... */ window->State.Redisplay = GL_TRUE; if( window->IsMenu ) fgSetWindow( current_window ); }
/* * Private function to check for the current menu/sub menu activity state */ static GLboolean fghCheckMenuStatus( SFG_Menu* menu ) { SFG_MenuEntry* menuEntry; int x, y; /* First of all check any of the active sub menus... */ for( menuEntry = (SFG_MenuEntry *)menu->Entries.First; menuEntry; menuEntry = (SFG_MenuEntry *)menuEntry->Node.Next ) { if( menuEntry->SubMenu && menuEntry->IsActive ) { /* * OK, have the sub-menu checked, too. If it returns GL_TRUE, it * will mean that it caught the mouse cursor and we do not need * to regenerate the activity list, and so our parents do... */ GLboolean return_status; menuEntry->SubMenu->Window->State.MouseX = menu->Window->State.MouseX + menu->X - menuEntry->SubMenu->X; menuEntry->SubMenu->Window->State.MouseY = menu->Window->State.MouseY + menu->Y - menuEntry->SubMenu->Y; return_status = fghCheckMenuStatus( menuEntry->SubMenu ); if ( return_status ) return GL_TRUE; } } /* That much about our sub menus, let's get to checking the current menu: */ x = menu->Window->State.MouseX; y = menu->Window->State.MouseY; /* Check if the mouse cursor is contained within the current menu box */ if( ( x >= FREEGLUT_MENU_BORDER ) && ( x < menu->Width - FREEGLUT_MENU_BORDER ) && ( y >= FREEGLUT_MENU_BORDER ) && ( y < menu->Height - FREEGLUT_MENU_BORDER ) ) { int menuID = ( y - FREEGLUT_MENU_BORDER ) / FREEGLUT_MENU_HEIGHT; /* The mouse cursor is somewhere over our box, check it out. */ menuEntry = fghFindMenuEntry( menu, menuID + 1 ); FREEGLUT_INTERNAL_ERROR_EXIT( menuEntry, "Cannot find menu entry", "fghCheckMenuStatus" ); menuEntry->IsActive = GL_TRUE; menuEntry->Ordinal = menuID; /* * If this is not the same as the last active menu entry, deactivate * the previous entry. Specifically, if the previous active entry * was a submenu then deactivate it. */ if( menu->ActiveEntry && ( menuEntry != menu->ActiveEntry ) ) if( menu->ActiveEntry->SubMenu ) fghDeactivateSubMenu( menu->ActiveEntry ); if( menuEntry != menu->ActiveEntry ) { menu->Window->State.Redisplay = GL_TRUE; if( menu->ActiveEntry ) menu->ActiveEntry->IsActive = GL_FALSE; } menu->ActiveEntry = menuEntry; menu->IsActive = GL_TRUE; /* XXX Do we need this? */ /* * OKi, we have marked that entry as active, but it would be also * nice to have its contents updated, in case it's a sub menu. * Also, ignore the return value of the check function: */ if( menuEntry->SubMenu ) { if ( ! menuEntry->SubMenu->IsActive ) { int max_x, max_y; SFG_Window *current_window = fgStructure.CurrentWindow; /* Set up the initial menu position now... */ menuEntry->SubMenu->IsActive = GL_TRUE; /* Set up the initial submenu position now: */ fghGetVMaxExtent(menu->ParentWindow, &max_x, &max_y); menuEntry->SubMenu->X = menu->X + menu->Width; menuEntry->SubMenu->Y = menu->Y + menuEntry->Ordinal * FREEGLUT_MENU_HEIGHT; if( menuEntry->SubMenu->X + menuEntry->SubMenu->Width > max_x ) menuEntry->SubMenu->X = menu->X - menuEntry->SubMenu->Width; if( menuEntry->SubMenu->Y + menuEntry->SubMenu->Height > max_y ) { menuEntry->SubMenu->Y -= ( menuEntry->SubMenu->Height - FREEGLUT_MENU_HEIGHT - 2 * FREEGLUT_MENU_BORDER ); if( menuEntry->SubMenu->Y < 0 ) menuEntry->SubMenu->Y = 0; } fgSetWindow( menuEntry->SubMenu->Window ); glutPositionWindow( menuEntry->SubMenu->X, menuEntry->SubMenu->Y ); glutReshapeWindow( menuEntry->SubMenu->Width, menuEntry->SubMenu->Height ); glutPopWindow( ); glutShowWindow( ); menuEntry->SubMenu->Window->ActiveMenu = menuEntry->SubMenu; fgSetWindow( current_window ); menuEntry->SubMenu->Window->State.MouseX = x + menu->X - menuEntry->SubMenu->X; menuEntry->SubMenu->Window->State.MouseY = y + menu->Y - menuEntry->SubMenu->Y; fghCheckMenuStatus( menuEntry->SubMenu ); } /* Activate it because its parent entry is active */ menuEntry->SubMenu->IsActive = GL_TRUE; /* XXX Do we need this? */ } /* Report back that we have caught the menu cursor */ return GL_TRUE; } /* Looks like the menu cursor is somewhere else... */ if( menu->ActiveEntry && menu->ActiveEntry->IsActive && ( !menu->ActiveEntry->SubMenu || !menu->ActiveEntry->SubMenu->IsActive ) ) { menu->Window->State.Redisplay = GL_TRUE; menu->ActiveEntry->IsActive = GL_FALSE; menu->ActiveEntry = NULL; } return GL_FALSE; }
void fgPlatformProcessSingleEvent ( void ) { SFG_Window* window; XEvent event; /* This code was repeated constantly, so here it goes into a definition: */ #define GETWINDOW(a) \ window = fgWindowByHandle( event.a.window ); \ if( window == NULL ) \ break; #define GETMOUSE(a) \ window->State.MouseX = event.a.x; \ window->State.MouseY = event.a.y; FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutMainLoopEvent" ); while( XPending( fgDisplay.pDisplay.Display ) ) { XNextEvent( fgDisplay.pDisplay.Display, &event ); #if _DEBUG fghPrintEvent( &event ); #endif switch( event.type ) { case ClientMessage: if (fgStructure.CurrentWindow) if(fgIsSpaceballXEvent(&event)) { fgSpaceballHandleXEvent(&event); break; } /* Destroy the window when the WM_DELETE_WINDOW message arrives */ if( (Atom) event.xclient.data.l[ 0 ] == fgDisplay.pDisplay.DeleteWindow ) { GETWINDOW( xclient ); fgDestroyWindow ( window ); if( fgState.ActionOnWindowClose == GLUT_ACTION_EXIT ) { fgDeinitialize( ); exit( 0 ); } else if( fgState.ActionOnWindowClose == GLUT_ACTION_GLUTMAINLOOP_RETURNS ) fgState.ExecState = GLUT_EXEC_STATE_STOP; return; } break; /* * CreateNotify causes a configure-event so that sub-windows are * handled compatibly with GLUT. Otherwise, your sub-windows * (in freeglut only) will not get an initial reshape event, * which can break things. * * GLUT presumably does this because it generally tries to treat * sub-windows the same as windows. */ case CreateNotify: case ConfigureNotify: { int width, height, x, y; if( event.type == CreateNotify ) { GETWINDOW( xcreatewindow ); width = event.xcreatewindow.width; height = event.xcreatewindow.height; x = event.xcreatewindow.x; y = event.xcreatewindow.y; } else { GETWINDOW( xconfigure ); width = event.xconfigure.width; height = event.xconfigure.height; x = event.xconfigure.x; y = event.xconfigure.y; } /* Update state and call callback, if there was a change */ fghOnPositionNotify(window, x, y, GL_FALSE); /* Update state and call callback, if there was a change */ fghOnReshapeNotify(window, width, height, GL_FALSE); } break; case DestroyNotify: /* * This is sent to confirm the XDestroyWindow call. * * XXX WHY is this commented out? Should we re-enable it? */ /* fgAddToWindowDestroyList ( window ); */ break; case Expose: /* * We are too dumb to process partial exposes... * * XXX Well, we could do it. However, it seems to only * XXX be potentially useful for single-buffered (since * XXX double-buffered does not respect viewport when we * XXX do a buffer-swap). * */ if( event.xexpose.count == 0 ) { GETWINDOW( xexpose ); window->State.WorkMask |= GLUT_DISPLAY_WORK; } break; case MapNotify: break; case UnmapNotify: /* We get this when iconifying a window. */ GETWINDOW( xunmap ); INVOKE_WCB( *window, WindowStatus, ( GLUT_HIDDEN ) ); window->State.Visible = GL_FALSE; break; case MappingNotify: /* * Have the client's keyboard knowledge updated (xlib.ps, * page 206, says that's a good thing to do) */ XRefreshKeyboardMapping( (XMappingEvent *) &event ); break; case VisibilityNotify: { /* * Sending this event, the X server can notify us that the window * has just acquired one of the three possible visibility states: * VisibilityUnobscured, VisibilityPartiallyObscured or * VisibilityFullyObscured. Note that we DO NOT receive a * VisibilityNotify event when iconifying a window, we only get an * UnmapNotify then. */ GETWINDOW( xvisibility ); switch( event.xvisibility.state ) { case VisibilityUnobscured: INVOKE_WCB( *window, WindowStatus, ( GLUT_FULLY_RETAINED ) ); window->State.Visible = GL_TRUE; break; case VisibilityPartiallyObscured: INVOKE_WCB( *window, WindowStatus, ( GLUT_PARTIALLY_RETAINED ) ); window->State.Visible = GL_TRUE; break; case VisibilityFullyObscured: INVOKE_WCB( *window, WindowStatus, ( GLUT_FULLY_COVERED ) ); window->State.Visible = GL_FALSE; break; default: fgWarning( "Unknown X visibility state: %d", event.xvisibility.state ); break; } } break; case EnterNotify: case LeaveNotify: GETWINDOW( xcrossing ); GETMOUSE( xcrossing ); if( ( event.type == LeaveNotify ) && window->IsMenu && window->ActiveMenu && window->ActiveMenu->IsActive ) fgUpdateMenuHighlight( window->ActiveMenu ); INVOKE_WCB( *window, Entry, ( ( EnterNotify == event.type ) ? GLUT_ENTERED : GLUT_LEFT ) ); break; case MotionNotify: { /* if GLUT_SKIP_STALE_MOTION_EVENTS is true, then discard all but * the last motion event from the queue */ if(fgState.SkipStaleMotion) { while(XCheckIfEvent(fgDisplay.pDisplay.Display, &event, match_motion, 0)); } GETWINDOW( xmotion ); GETMOUSE( xmotion ); if( window->ActiveMenu ) { if( window == window->ActiveMenu->ParentWindow ) { window->ActiveMenu->Window->State.MouseX = event.xmotion.x_root - window->ActiveMenu->X; window->ActiveMenu->Window->State.MouseY = event.xmotion.y_root - window->ActiveMenu->Y; } fgUpdateMenuHighlight( window->ActiveMenu ); break; } /* * XXX For more than 5 buttons, just check {event.xmotion.state}, * XXX rather than a host of bit-masks? Or maybe we need to * XXX track ButtonPress/ButtonRelease events in our own * XXX bit-mask? */ fgState.Modifiers = fgPlatformGetModifiers( event.xmotion.state ); if ( event.xmotion.state & ( Button1Mask | Button2Mask | Button3Mask | Button4Mask | Button5Mask ) ) { INVOKE_WCB( *window, Motion, ( event.xmotion.x, event.xmotion.y ) ); } else { INVOKE_WCB( *window, Passive, ( event.xmotion.x, event.xmotion.y ) ); } fgState.Modifiers = INVALID_MODIFIERS; } break; case ButtonRelease: case ButtonPress: { GLboolean pressed = GL_TRUE; int button; if( event.type == ButtonRelease ) pressed = GL_FALSE ; /* * A mouse button has been pressed or released. Traditionally, * break if the window was found within the freeglut structures. */ GETWINDOW( xbutton ); GETMOUSE( xbutton ); /* * An X button (at least in XFree86) is numbered from 1. * A GLUT button is numbered from 0. * Old GLUT passed through buttons other than just the first * three, though it only gave symbolic names and official * support to the first three. */ button = event.xbutton.button - 1; /* * Do not execute the application's mouse callback if a menu * is hooked to this button. In that case an appropriate * private call should be generated. */ if( fgCheckActiveMenu( window, button, pressed, event.xbutton.x, event.xbutton.y ) ) break; /* * Check if there is a mouse or mouse wheel callback hooked to the * window */ if( ! FETCH_WCB( *window, Mouse ) && ! FETCH_WCB( *window, MouseWheel ) ) break; fgState.Modifiers = fgPlatformGetModifiers( event.xbutton.state ); /* Finally execute the mouse or mouse wheel callback */ if( ( button < glutDeviceGet ( GLUT_NUM_MOUSE_BUTTONS ) ) || ( ! FETCH_WCB( *window, MouseWheel ) ) ) INVOKE_WCB( *window, Mouse, ( button, pressed ? GLUT_DOWN : GLUT_UP, event.xbutton.x, event.xbutton.y ) ); else { /* * Map 4 and 5 to wheel zero; EVEN to +1, ODD to -1 * " 6 and 7 " " one; ... * * XXX This *should* be behind some variables/macros, * XXX since the order and numbering isn't certain * XXX See XFree86 configuration docs (even back in the * XXX 3.x days, and especially with 4.x). * * XXX Note that {button} has already been decremented * XXX in mapping from X button numbering to GLUT. * * XXX Should add support for partial wheel turns as Windows does -- 5/27/11 */ int wheel_number = (button - glutDeviceGet ( GLUT_NUM_MOUSE_BUTTONS )) / 2; int direction = -1; if( button % 2 ) direction = 1; if( pressed ) INVOKE_WCB( *window, MouseWheel, ( wheel_number, direction, event.xbutton.x, event.xbutton.y ) ); } fgState.Modifiers = INVALID_MODIFIERS; } break; case KeyRelease: case KeyPress: { FGCBKeyboard keyboard_cb; FGCBSpecial special_cb; GETWINDOW( xkey ); GETMOUSE( xkey ); /* Detect auto repeated keys, if configured globally or per-window */ if ( fgState.KeyRepeat==GLUT_KEY_REPEAT_OFF || window->State.IgnoreKeyRepeat==GL_TRUE ) { if (event.type==KeyRelease) { /* * Look at X11 keystate to detect repeat mode. * While X11 says the key is actually held down, we'll ignore KeyRelease/KeyPress pairs. */ char keys[32]; 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 ( keys[event.xkey.keycode>>3] & (1<<(event.xkey.keycode%8)) ) window->State.pWState.KeyRepeating = GL_TRUE; else window->State.pWState.KeyRepeating = GL_FALSE; } } } else window->State.pWState.KeyRepeating = GL_FALSE; /* Cease processing this event if it is auto repeated */ if (window->State.pWState.KeyRepeating) { if (event.type == KeyPress) window->State.pWState.KeyRepeating = GL_FALSE; break; } if( event.type == KeyPress ) { keyboard_cb = (FGCBKeyboard)( FETCH_WCB( *window, Keyboard )); special_cb = (FGCBSpecial) ( FETCH_WCB( *window, Special )); } else { keyboard_cb = (FGCBKeyboard)( FETCH_WCB( *window, KeyboardUp )); special_cb = (FGCBSpecial) ( FETCH_WCB( *window, SpecialUp )); } /* Is there a keyboard/special callback hooked for this window? */ if( keyboard_cb || special_cb ) { XComposeStatus composeStatus; char asciiCode[ 32 ]; KeySym keySym; int len; /* Check for the ASCII/KeySym codes associated with the event: */ len = XLookupString( &event.xkey, asciiCode, sizeof(asciiCode), &keySym, &composeStatus ); /* GLUT API tells us to have two separate callbacks... */ if( len > 0 ) { /* ...one for the ASCII translateable keypresses... */ if( keyboard_cb ) { fgSetWindow( window ); fgState.Modifiers = fgPlatformGetModifiers( event.xkey.state ); keyboard_cb( asciiCode[ 0 ], event.xkey.x, event.xkey.y ); fgState.Modifiers = INVALID_MODIFIERS; } } else { int special = -1; /* * ...and one for all the others, which need to be * translated to GLUT_KEY_Xs... */ switch( keySym ) { case XK_F1: special = GLUT_KEY_F1; break; case XK_F2: special = GLUT_KEY_F2; break; case XK_F3: special = GLUT_KEY_F3; break; case XK_F4: special = GLUT_KEY_F4; break; case XK_F5: special = GLUT_KEY_F5; break; case XK_F6: special = GLUT_KEY_F6; break; case XK_F7: special = GLUT_KEY_F7; break; case XK_F8: special = GLUT_KEY_F8; break; case XK_F9: special = GLUT_KEY_F9; break; case XK_F10: special = GLUT_KEY_F10; break; case XK_F11: special = GLUT_KEY_F11; break; case XK_F12: special = GLUT_KEY_F12; break; case XK_KP_Left: case XK_Left: special = GLUT_KEY_LEFT; break; case XK_KP_Right: case XK_Right: special = GLUT_KEY_RIGHT; break; case XK_KP_Up: case XK_Up: special = GLUT_KEY_UP; break; case XK_KP_Down: case XK_Down: special = GLUT_KEY_DOWN; break; case XK_KP_Prior: case XK_Prior: special = GLUT_KEY_PAGE_UP; break; case XK_KP_Next: case XK_Next: special = GLUT_KEY_PAGE_DOWN; break; case XK_KP_Home: case XK_Home: special = GLUT_KEY_HOME; break; case XK_KP_End: case XK_End: special = GLUT_KEY_END; break; case XK_KP_Insert: case XK_Insert: special = GLUT_KEY_INSERT; break; case XK_Num_Lock : special = GLUT_KEY_NUM_LOCK; break; case XK_KP_Begin : special = GLUT_KEY_BEGIN; break; case XK_KP_Delete: special = GLUT_KEY_DELETE; break; case XK_Shift_L: special = GLUT_KEY_SHIFT_L; break; case XK_Shift_R: special = GLUT_KEY_SHIFT_R; break; case XK_Control_L: special = GLUT_KEY_CTRL_L; break; case XK_Control_R: special = GLUT_KEY_CTRL_R; break; case XK_Alt_L: special = GLUT_KEY_ALT_L; break; case XK_Alt_R: special = GLUT_KEY_ALT_R; break; } /* * Execute the callback (if one has been specified), * given that the special code seems to be valid... */ if( special_cb && (special != -1) ) { fgSetWindow( window ); fgState.Modifiers = fgPlatformGetModifiers( event.xkey.state ); special_cb( special, event.xkey.x, event.xkey.y ); fgState.Modifiers = INVALID_MODIFIERS; } } } }
/* * Activates a menu pointed by the function argument */ static void fghActivateMenu( SFG_Window* window, int button ) { int max_x, max_y; SFG_XYUse mouse_pos; /* We'll be referencing this menu a lot, so remember its address: */ SFG_Menu* menu = window->Menu[ button ]; SFG_Window* current_window = fgStructure.CurrentWindow; /* If the menu is already active in another window, deactivate it (and any submenus) there */ if ( menu->ParentWindow ) fgDeactivateMenu(menu->ParentWindow); /* Mark the menu as active, so that it gets displayed: */ window->ActiveMenu = menu; menu->IsActive = GL_TRUE; fghSetMenuParentWindow ( window, menu ); fgState.ActiveMenus++; /* Set up the initial menu position now: */ fghGetVMaxExtent(menu->ParentWindow, &max_x, &max_y); fgSetWindow( window ); /* get mouse position on screen (window->State.MouseX and window->State.MouseY * are relative to client area origin), and not easy to correct given that * glutGet( GLUT_WINDOW_X ) and glutGet( GLUT_WINDOW_Y ) return relative to parent * origin when looking at a child window * for parent windows: window->State.MouseX + glutGet( GLUT_WINDOW_X ) == mouse_pos.X */ fghGetCursorPos(&mouse_pos); menu->X = mouse_pos.X; menu->Y = mouse_pos.Y; /* Make sure the whole menu is on the screen */ if( menu->X + menu->Width > max_x ) menu->X -=menu->Width; if( menu->Y + menu->Height > max_y ) { menu->Y -=menu->Height; if( menu->Y < 0 ) menu->Y = 0; } /* Set position of mouse relative to top-left menu in menu's window state (could as well set 0 at creation time...) */ menu->Window->State.MouseX = mouse_pos.X - menu->X; menu->Window->State.MouseY = mouse_pos.Y - menu->Y; /* Menu status callback */ if (fgState.MenuStateCallback || fgState.MenuStatusCallback) { fgStructure.CurrentMenu = menu; fgStructure.CurrentWindow = window; if (fgState.MenuStateCallback) fgState.MenuStateCallback(GLUT_MENU_IN_USE); if (fgState.MenuStatusCallback) /* window->State.MouseX and window->State.MouseY are relative to client area origin, as needed */ fgState.MenuStatusCallback(GLUT_MENU_IN_USE, window->State.MouseX, window->State.MouseY); } fgSetWindow( menu->Window ); glutPositionWindow( menu->X, menu->Y ); glutReshapeWindow( menu->Width, menu->Height ); glutPopWindow( ); glutShowWindow( ); menu->Window->ActiveMenu = menu; fghCheckMenuStatus( menu ); fgSetWindow( current_window ); }
/* * Check whether an active menu absorbs a mouse click */ GLboolean fgCheckActiveMenu ( SFG_Window *window, int button, GLboolean pressed, int mouse_x, int mouse_y ) { /* * Near as I can tell, this is the menu behaviour: * - Down-click the menu button, menu not active: activate * the menu with its upper left-hand corner at the mouse * location. * - Down-click any button outside the menu, menu active: * deactivate the menu * - Down-click any button inside the menu, menu active: * select the menu entry and deactivate the menu * - Up-click the menu button, menu not active: nothing happens * - Up-click the menu button outside the menu, menu active: * nothing happens * - Up-click the menu button inside the menu, menu active: * select the menu entry and deactivate the menu * Since menus can have submenus, we need to check this recursively. */ if( window->ActiveMenu ) { if( window == window->ActiveMenu->ParentWindow ) { window->ActiveMenu->Window->State.MouseX = mouse_x - window->ActiveMenu->X; window->ActiveMenu->Window->State.MouseY = mouse_y - window->ActiveMenu->Y; } /* In the menu, invoke the callback and deactivate the menu */ if( fghCheckMenuStatus( window->ActiveMenu ) ) { /* * Save the current window and menu and set the current * window to the window whose menu this is */ SFG_Window *save_window = fgStructure.CurrentWindow; SFG_Menu *save_menu = fgStructure.CurrentMenu; SFG_Window *parent_window = window->ActiveMenu->ParentWindow; fgSetWindow( parent_window ); fgStructure.CurrentMenu = window->ActiveMenu; /* Execute the menu callback */ fghExecuteMenuCallback( window->ActiveMenu ); fgDeactivateMenu( parent_window ); /* Restore the current window and menu */ fgSetWindow( save_window ); fgStructure.CurrentMenu = save_menu; } else if( pressed ) /* * Outside the menu, deactivate if it's a downclick * * A downclick outside of the interior of our freeglut windows * is dealt with in the WM_KILLFOCUS handler of fgPlatformWindowProc */ fgDeactivateMenu( window->ActiveMenu->ParentWindow ); /* * XXX Why does an active menu require a redisplay at * XXX this point? If this can come out cleanly, then * XXX it probably should do so; if not, a comment should * XXX explain it. */ if( ! window->IsMenu ) window->State.Redisplay = GL_TRUE; return GL_TRUE; } /* No active menu, let's check whether we need to activate one. */ if( ( 0 <= button ) && ( FREEGLUT_MAX_MENUS > button ) && ( window->Menu[ button ] ) && pressed ) { /* XXX Posting a requisite Redisplay seems bogus. */ window->State.Redisplay = GL_TRUE; fghActivateMenu( window, button ); return GL_TRUE; } return GL_FALSE; }
/* * The window procedure for handling Win32 events */ LRESULT CALLBACK fgPlatformWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam ) { SFG_Window *window; LRESULT lRet = 1; static int setCaptureActive = 0; FREEGLUT_INTERNAL_ERROR_EXIT_IF_NOT_INITIALISED ( "Event Handler" ) ; window = fgWindowByHandle( hWnd ); if ( ( window == NULL ) && ( uMsg != WM_CREATE ) ) return DefWindowProc( hWnd, uMsg, wParam, lParam ); /* printf ( "Window %3d message <%04x> %12d %12d\n", window?window->ID:0, uMsg, wParam, lParam ); */ switch( uMsg ) { case WM_CREATE: /* The window structure is passed as the creation structure parameter... */ window = (SFG_Window *) (((LPCREATESTRUCT) lParam)->lpCreateParams); FREEGLUT_INTERNAL_ERROR_EXIT ( ( window != NULL ), "Cannot create window", "fgPlatformWindowProc" ); window->Window.Handle = hWnd; window->Window.pContext.Device = GetDC( hWnd ); if( window->IsMenu ) { unsigned int current_DisplayMode = fgState.DisplayMode; fgState.DisplayMode = GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH; #if !defined(_WIN32_WCE) fgSetupPixelFormat( window, GL_FALSE, PFD_MAIN_PLANE ); #endif fgState.DisplayMode = current_DisplayMode; if( fgStructure.MenuContext ) wglMakeCurrent( window->Window.pContext.Device, fgStructure.MenuContext->MContext ); else { fgStructure.MenuContext = (SFG_MenuContext *)malloc( sizeof(SFG_MenuContext) ); fgStructure.MenuContext->MContext = wglCreateContext( window->Window.pContext.Device ); } /* window->Window.Context = wglGetCurrentContext (); */ window->Window.Context = wglCreateContext( window->Window.pContext.Device ); } else { #if !defined(_WIN32_WCE) fgSetupPixelFormat( window, GL_FALSE, PFD_MAIN_PLANE ); #endif if( ! fgState.UseCurrentContext ) window->Window.Context = wglCreateContext( window->Window.pContext.Device ); else { window->Window.Context = wglGetCurrentContext( ); if( ! window->Window.Context ) window->Window.Context = wglCreateContext( window->Window.pContext.Device ); } #if !defined(_WIN32_WCE) fgNewWGLCreateContext( window ); #endif } window->State.NeedToResize = GL_TRUE; /* if we used CW_USEDEFAULT (thats a negative value) for the size * of the window, query the window now for the size at which it * was created. */ if( ( window->State.Width < 0 ) || ( window->State.Height < 0 ) ) { SFG_Window *current_window = fgStructure.CurrentWindow; fgSetWindow( window ); window->State.Width = glutGet( GLUT_WINDOW_WIDTH ); window->State.Height = glutGet( GLUT_WINDOW_HEIGHT ); fgSetWindow( current_window ); } ReleaseDC( window->Window.Handle, window->Window.pContext.Device ); #if defined(_WIN32_WCE) /* Take over button handling */ { HINSTANCE dxDllLib=LoadLibrary(_T("gx.dll")); if (dxDllLib) { GXGetDefaultKeys_=(GXGETDEFAULTKEYS)GetProcAddress(dxDllLib, _T("?GXGetDefaultKeys@@YA?AUGXKeyList@@H@Z")); GXOpenInput_=(GXOPENINPUT)GetProcAddress(dxDllLib, _T("?GXOpenInput@@YAHXZ")); } if(GXOpenInput_) (*GXOpenInput_)(); if(GXGetDefaultKeys_) gxKeyList = (*GXGetDefaultKeys_)(GX_LANDSCAPEKEYS); } #endif /* defined(_WIN32_WCE) */ break; case WM_SIZE: /* printf("WM_SIZE (ID: %i): wParam: %i, new size: %ix%i \n",window->ID,wParam,LOWORD(lParam),HIWORD(lParam)); */ /* Update visibility state of the window */ if (wParam==SIZE_MINIMIZED) fghUpdateWindowStatus(window,GL_FALSE); else if (wParam==SIZE_RESTORED && !window->State.Visible) fghUpdateWindowStatus(window,GL_TRUE); /* Check window visible, we don't want to resize when the user or glutIconifyWindow minimized the window */ if( window->State.Visible ) { /* get old values first to compare to below */ int width = window->State.Width, height=window->State.Height; #if defined(_WIN32_WCE) window->State.Width = HIWORD(lParam); window->State.Height = LOWORD(lParam); #else window->State.Width = LOWORD(lParam); window->State.Height = HIWORD(lParam); #endif /* defined(_WIN32_WCE) */ if (width!=window->State.Width || height!=window->State.Height) { SFG_Window* saved_window = fgStructure.CurrentWindow; /* size changed, call reshape callback */ INVOKE_WCB( *window, Reshape, ( width, height ) ); glutPostRedisplay( ); if( window->IsMenu ) fgSetWindow( saved_window ); } } /* according to docs, should return 0 */ lRet = 0; break; case WM_MOVE: { SFG_Window* saved_window = fgStructure.CurrentWindow; RECT windowRect; /* Check window is minimized, we don't want to call the position callback when the user or glutIconifyWindow minimized the window */ if (!IsIconic(window->Window.Handle)) { /* Get top-left of non-client area of window, matching coordinates of * glutInitPosition and glutPositionWindow, but not those of * glutGet(GLUT_WINDOW_X) and glutGet(GLUT_WINDOW_Y), which return * top-left of client area. */ GetWindowRect( window->Window.Handle, &windowRect ); if (window->Parent) { /* For child window, we should return relative to upper-left * of parent's client area. */ POINT topleft = {windowRect.left,windowRect.top}; ScreenToClient(window->Parent->Window.Handle,&topleft); windowRect.left = topleft.x; windowRect.top = topleft.y; } INVOKE_WCB( *window, Position, ( windowRect.left, windowRect.top ) ); fgSetWindow(saved_window); } } /* according to docs, should return 0 */ lRet = 0; break; case WM_SETFOCUS: /*printf("WM_SETFOCUS: %p\n", window );*/ lRet = DefWindowProc( hWnd, uMsg, wParam, lParam ); SetActiveWindow( window->Window.Handle ); UpdateWindow ( hWnd ); break; case WM_KILLFOCUS: /*printf("WM_KILLFOCUS: %p\n", window ); */ lRet = DefWindowProc( hWnd, uMsg, wParam, lParam ); /* Check if there are any open menus that need to be closed */ fgPlatformCheckMenuDeactivate(); break; #if 0 case WM_ACTIVATE: //printf("WM_ACTIVATE: %x (ID: %i) %d %d\n",lParam, window->ID, HIWORD(wParam), LOWORD(wParam)); if (LOWORD(wParam) != WA_INACTIVE) { /* printf("WM_ACTIVATE: fgSetCursor( %p, %d)\n", window, window->State.Cursor ); */ fgSetCursor( window, window->State.Cursor ); } lRet = DefWindowProc( hWnd, uMsg, wParam, lParam ); break; #endif case WM_SETCURSOR: /* printf ( "Cursor event %x %x %x %x\n", window, window->State.Cursor, lParam, wParam ) ; */ if( LOWORD( lParam ) == HTCLIENT ) { if (!window->State.pWState.MouseTracking) { TRACKMOUSEEVENT tme; /* Cursor just entered window, set cursor look */ fgSetCursor ( window, window->State.Cursor ) ; /* If an EntryFunc callback is specified by the user, also * invoke that callback and start mouse tracking so that * we get a WM_MOUSELEAVE message */ if (FETCH_WCB( *window, Entry )) { SFG_Window* saved_window = fgStructure.CurrentWindow; INVOKE_WCB( *window, Entry, ( GLUT_ENTERED ) ); fgSetWindow(saved_window); tme.cbSize = sizeof(TRACKMOUSEEVENT); tme.dwFlags = TME_LEAVE; tme.hwndTrack = window->Window.Handle; TrackMouseEvent(&tme); window->State.pWState.MouseTracking = GL_TRUE; } } } else /* Only pass non-client WM_SETCURSOR to DefWindowProc, or we get WM_SETCURSOR on parents of children as well */ lRet = DefWindowProc( hWnd, uMsg, wParam, lParam ); break; case WM_MOUSELEAVE: { /* NB: This message is only received when a EntryFunc callback * is specified by the user, as that is the only condition under * which mouse tracking is setup in WM_SETCURSOR handler above */ SFG_Window* saved_window = fgStructure.CurrentWindow; INVOKE_WCB( *window, Entry, ( GLUT_LEFT ) ); fgSetWindow(saved_window); window->State.pWState.MouseTracking = GL_FALSE; lRet = 0; /* As per docs, must return zero */ } break; case WM_SHOWWINDOW: /* printf("WM_SHOWWINDOW, shown? %i, source: %i\n",wParam,lParam); */ if (wParam) { fghUpdateWindowStatus(window, GL_TRUE); window->State.Redisplay = GL_TRUE; } else { fghUpdateWindowStatus(window, GL_FALSE); window->State.Redisplay = GL_FALSE; } break; case WM_PAINT: { RECT rect; if (GetUpdateRect(hWnd,&rect,FALSE)) { /* As per docs, upon receiving WM_PAINT, first check if the update region is not empty before you call BeginPaint */ PAINTSTRUCT ps; /* Turn on the visibility in case it was turned off somehow */ window->State.Visible = GL_TRUE; InvalidateRect( hWnd, NULL, GL_FALSE ); BeginPaint( hWnd, &ps ); fghRedrawWindow( window ); EndPaint( hWnd, &ps ); } lRet = 0; /* As per docs, should return 0 */ } break; case WM_CLOSE: fgDestroyWindow ( window ); if ( fgState.ActionOnWindowClose != GLUT_ACTION_CONTINUE_EXECUTION ) PostQuitMessage(0); break; case WM_DESTROY: /* * The window already got destroyed, so don't bother with it. */ return 0; case WM_MOUSEMOVE: { /* Per docs, use LOWORD/HIWORD for WinCE and GET_X_LPARAM/GET_Y_LPARAM for desktop windows */ #if defined(_WIN32_WCE) window->State.MouseX = 320-HIWORD( lParam ); /* XXX: Docs say x should be loword and y hiword? */ window->State.MouseY = LOWORD( lParam ); #else window->State.MouseX = GET_X_LPARAM( lParam ); window->State.MouseY = GET_Y_LPARAM( lParam ); #endif /* defined(_WIN32_WCE) */ /* Restrict to [-32768, 32767] to match X11 behaviour */ /* See comment in "freeglut_developer" mailing list 10/4/04 */ if ( window->State.MouseX > 32767 ) window->State.MouseX -= 65536; if ( window->State.MouseY > 32767 ) window->State.MouseY -= 65536; if ( window->ActiveMenu ) { fgUpdateMenuHighlight( window->ActiveMenu ); break; } fgState.Modifiers = fgPlatformGetModifiers( ); if( ( wParam & MK_LBUTTON ) || ( wParam & MK_MBUTTON ) || ( wParam & MK_RBUTTON ) ) INVOKE_WCB( *window, Motion, ( window->State.MouseX, window->State.MouseY ) ); else INVOKE_WCB( *window, Passive, ( window->State.MouseX, window->State.MouseY ) ); fgState.Modifiers = INVALID_MODIFIERS; } break; case WM_LBUTTONDOWN: case WM_MBUTTONDOWN: case WM_RBUTTONDOWN: case WM_LBUTTONUP: case WM_MBUTTONUP: case WM_RBUTTONUP: { GLboolean pressed = GL_TRUE; int button; /* Per docs, use LOWORD/HIWORD for WinCE and GET_X_LPARAM/GET_Y_LPARAM for desktop windows */ #if defined(_WIN32_WCE) window->State.MouseX = 320-HIWORD( lParam ); /* XXX: Docs say x should be loword and y hiword? */ window->State.MouseY = LOWORD( lParam ); #else window->State.MouseX = GET_X_LPARAM( lParam ); window->State.MouseY = GET_Y_LPARAM( lParam ); #endif /* defined(_WIN32_WCE) */ /* Restrict to [-32768, 32767] to match X11 behaviour */ /* See comment in "freeglut_developer" mailing list 10/4/04 */ if ( window->State.MouseX > 32767 ) window->State.MouseX -= 65536; if ( window->State.MouseY > 32767 ) window->State.MouseY -= 65536; switch( uMsg ) { case WM_LBUTTONDOWN: pressed = GL_TRUE; button = GLUT_LEFT_BUTTON; break; case WM_MBUTTONDOWN: pressed = GL_TRUE; button = GLUT_MIDDLE_BUTTON; break; case WM_RBUTTONDOWN: pressed = GL_TRUE; button = GLUT_RIGHT_BUTTON; break; case WM_LBUTTONUP: pressed = GL_FALSE; button = GLUT_LEFT_BUTTON; break; case WM_MBUTTONUP: pressed = GL_FALSE; button = GLUT_MIDDLE_BUTTON; break; case WM_RBUTTONUP: pressed = GL_FALSE; button = GLUT_RIGHT_BUTTON; break; default: pressed = GL_FALSE; button = -1; break; } #if !defined(_WIN32_WCE) if( GetSystemMetrics( SM_SWAPBUTTON ) ) { if( button == GLUT_LEFT_BUTTON ) button = GLUT_RIGHT_BUTTON; else if( button == GLUT_RIGHT_BUTTON ) button = GLUT_LEFT_BUTTON; } #endif /* !defined(_WIN32_WCE) */ if( button == -1 ) return DefWindowProc( hWnd, uMsg, lParam, wParam ); /* * Do not execute the application's mouse callback if a menu * is hooked to this button. In that case an appropriate * private call should be generated. */ if( fgCheckActiveMenu( window, button, pressed, window->State.MouseX, window->State.MouseY ) ) break; /* Set capture so that the window captures all the mouse messages * * The mouse is not released from the window until all buttons have * been released, even if the user presses a button in another window. * This is consistent with the behavior on X11. */ if ( pressed == GL_TRUE ) { if (!setCaptureActive) SetCapture ( window->Window.Handle ) ; setCaptureActive = 1; /* Set to false in WM_CAPTURECHANGED handler */ } else if (!GetAsyncKeyState(VK_LBUTTON) && !GetAsyncKeyState(VK_MBUTTON) && !GetAsyncKeyState(VK_RBUTTON)) /* Make sure all mouse buttons are released before releasing capture */ ReleaseCapture () ; if( ! FETCH_WCB( *window, Mouse ) ) break; fgSetWindow( window ); fgState.Modifiers = fgPlatformGetModifiers( ); INVOKE_WCB( *window, Mouse, ( button, pressed ? GLUT_DOWN : GLUT_UP, window->State.MouseX, window->State.MouseY ) ); fgState.Modifiers = INVALID_MODIFIERS; /* As per docs, should return zero */ lRet = 0; } break; case WM_MOUSEWHEEL: { int wheel_number = 0; /* Only one scroll wheel on windows */ #if defined(_WIN32_WCE) int modkeys = LOWORD(wParam); short ticks = (short)HIWORD(wParam); /* commented out as should not be needed here, mouse motion is processed in WM_MOUSEMOVE first: xPos = LOWORD(lParam); -- straight from docs, not consistent with mouse nutton and mouse motion above (which i think is wrong) yPos = HIWORD(lParam); */ #else /* int modkeys = GET_KEYSTATE_WPARAM( wParam ); */ short ticks = GET_WHEEL_DELTA_WPARAM( wParam ); /* commented out as should not be needed here, mouse motion is processed in WM_MOUSEMOVE first: window->State.MouseX = GET_X_LPARAM( lParam ); window->State.MouseY = GET_Y_LPARAM( lParam ); */ #endif /* defined(_WIN32_WCE) */ window = fghWindowUnderCursor(window); fgState.MouseWheelTicks += ticks; if ( abs ( fgState.MouseWheelTicks ) >= WHEEL_DELTA ) { int direction = ( fgState.MouseWheelTicks > 0 ) ? 1 : -1; if( ! FETCH_WCB( *window, MouseWheel ) && ! FETCH_WCB( *window, Mouse ) ) break; fgSetWindow( window ); fgState.Modifiers = fgPlatformGetModifiers( ); while( abs ( fgState.MouseWheelTicks ) >= WHEEL_DELTA ) { if( FETCH_WCB( *window, MouseWheel ) ) INVOKE_WCB( *window, MouseWheel, ( wheel_number, direction, window->State.MouseX, window->State.MouseY ) ); else /* No mouse wheel, call the mouse button callback twice */ { /* * Map wheel zero to button 3 and 4; +1 to 3, -1 to 4 * " " one +1 to 5, -1 to 6, ... * * XXX The below assumes that you have no more than 3 mouse * XXX buttons. Sorry. */ int button = wheel_number * 2 + 3; if( direction < 0 ) ++button; INVOKE_WCB( *window, Mouse, ( button, GLUT_DOWN, window->State.MouseX, window->State.MouseY ) ); INVOKE_WCB( *window, Mouse, ( button, GLUT_UP, window->State.MouseX, window->State.MouseY ) ); } fgState.MouseWheelTicks -= WHEEL_DELTA * direction; } fgState.Modifiers = INVALID_MODIFIERS; } /* Per docs, should return zero */ lRet = 0; } break ; case WM_SYSKEYDOWN: case WM_KEYDOWN: { window = fghWindowUnderCursor(window); lRet = fghWindowProcKeyPress(window,uMsg,GL_TRUE,wParam,lParam); } break; case WM_SYSKEYUP: case WM_KEYUP: { window = fghWindowUnderCursor(window); lRet = fghWindowProcKeyPress(window,uMsg,GL_FALSE,wParam,lParam); } break; case WM_SYSCHAR: case WM_CHAR: { window = fghWindowUnderCursor(window); if( (fgState.KeyRepeat==GLUT_KEY_REPEAT_OFF || window->State.IgnoreKeyRepeat==GL_TRUE) && (HIWORD(lParam) & KF_REPEAT) ) break; fgState.Modifiers = fgPlatformGetModifiers( ); INVOKE_WCB( *window, Keyboard, ( (char)wParam, window->State.MouseX, window->State.MouseY ) ); fgState.Modifiers = INVALID_MODIFIERS; } break; case WM_CAPTURECHANGED: if (!lParam || !fgWindowByHandle((HWND)lParam)) /* Capture released or capture taken by non-FreeGLUT window */ setCaptureActive = 0; /* Docs advise a redraw */ InvalidateRect( hWnd, NULL, GL_FALSE ); UpdateWindow(hWnd); lRet = 0; /* Per docs, should return zero */ break; #if !defined(_WIN32_WCE) case WM_SYNCPAINT: /* 0x0088 */ /* Another window has moved, need to update this one */ window->State.Redisplay = GL_TRUE; lRet = DefWindowProc( hWnd, uMsg, wParam, lParam ); /* Help screen says this message must be passed to "DefWindowProc" */ break; case WM_SYSCOMMAND : /* 0x0112 */ { /* * We have received a system command message. Try to act on it. * The commands are passed in through the "wParam" parameter: * The least significant digit seems to be which edge of the window * is being used for a resize event: * 4 3 5 * 1 2 * 7 6 8 * Congratulations and thanks to Richard Rauch for figuring this out.. */ switch ( wParam & 0xfff0 ) { case SC_SIZE : break ; case SC_MOVE : break ; case SC_MINIMIZE : /* User has clicked on the "-" to minimize the window */ /* Turning off the visibility is handled in WM_SIZE handler */ break ; case SC_MAXIMIZE : break ; case SC_NEXTWINDOW : break ; case SC_PREVWINDOW : break ; case SC_CLOSE : /* Followed very closely by a WM_CLOSE message */ break ; case SC_VSCROLL : break ; case SC_HSCROLL : break ; case SC_MOUSEMENU : break ; case SC_KEYMENU : break ; case SC_ARRANGE : break ; case SC_RESTORE : break ; case SC_TASKLIST : break ; case SC_SCREENSAVE : break ; case SC_HOTKEY : break ; #if(WINVER >= 0x0400) case SC_DEFAULT : break ; case SC_MONITORPOWER : break ; case SC_CONTEXTHELP : break ; #endif /* WINVER >= 0x0400 */ default: #if _DEBUG fgWarning( "Unknown wParam type 0x%x", wParam ); #endif break; } } #endif /* !defined(_WIN32_WCE) */ /* We need to pass the message on to the operating system as well */ lRet = DefWindowProc( hWnd, uMsg, wParam, lParam ); break; #ifdef WM_TOUCH /* handle multi-touch messages */ case WM_TOUCH: { unsigned int numInputs = (unsigned int)wParam; unsigned int i = 0; TOUCHINPUT* ti = (TOUCHINPUT*)malloc( sizeof(TOUCHINPUT)*numInputs); if (fghGetTouchInputInfo == (pGetTouchInputInfo)0xDEADBEEF) { fghGetTouchInputInfo = (pGetTouchInputInfo)GetProcAddress(GetModuleHandle("user32"),"GetTouchInputInfo"); fghCloseTouchInputHandle = (pCloseTouchInputHandle)GetProcAddress(GetModuleHandle("user32"),"CloseTouchInputHandle"); } if (!fghGetTouchInputInfo) { free( (void*)ti ); break; } if (fghGetTouchInputInfo( (HTOUCHINPUT)lParam, numInputs, ti, sizeof(TOUCHINPUT) )) { /* Handle each contact point */ for (i = 0; i < numInputs; ++i ) { POINT tp; tp.x = TOUCH_COORD_TO_PIXEL(ti[i].x); tp.y = TOUCH_COORD_TO_PIXEL(ti[i].y); ScreenToClient( hWnd, &tp ); ti[i].dwID = ti[i].dwID * 2; if (ti[i].dwFlags & TOUCHEVENTF_DOWN) { INVOKE_WCB( *window, MultiEntry, ( ti[i].dwID, GLUT_ENTERED ) ); INVOKE_WCB( *window, MultiButton, ( ti[i].dwID, tp.x, tp.y, 0, GLUT_DOWN ) ); } else if (ti[i].dwFlags & TOUCHEVENTF_MOVE) { INVOKE_WCB( *window, MultiMotion, ( ti[i].dwID, tp.x, tp.y ) ); } else if (ti[i].dwFlags & TOUCHEVENTF_UP) { INVOKE_WCB( *window, MultiButton, ( ti[i].dwID, tp.x, tp.y, 0, GLUT_UP ) ); INVOKE_WCB( *window, MultiEntry, ( ti[i].dwID, GLUT_LEFT ) ); } } } fghCloseTouchInputHandle((HTOUCHINPUT)lParam); free( (void*)ti ); lRet = 0; /*DefWindowProc( hWnd, uMsg, wParam, lParam );*/ break; } #endif default: /* Handle unhandled messages */ lRet = DefWindowProc( hWnd, uMsg, wParam, lParam ); break; } return lRet; }
/* * Opens a window. Requires a SFG_Window object created and attached * to the freeglut structure. OpenGL context is created here. */ void fgOpenWindow( SFG_Window* window, const char* title, int x, int y, int w, int h, GLboolean gameMode, GLboolean isSubWindow ) { #if TARGET_HOST_UNIX_X11 XSetWindowAttributes winAttr; XTextProperty textProperty; XSizeHints sizeHints; XWMHints wmHints; unsigned long mask; unsigned int current_DisplayMode = fgState.DisplayMode ; /* Save the display mode if we are creating a menu window */ if( window->IsMenu && ( ! fgStructure.MenuContext ) ) fgState.DisplayMode = GLUT_DOUBLE | GLUT_RGB ; window->Window.VisualInfo = fgChooseVisual( ); if( window->IsMenu && ( ! fgStructure.MenuContext ) ) fgState.DisplayMode = current_DisplayMode ; if( ! window->Window.VisualInfo ) { /* * The "fgChooseVisual" returned a null meaning that the visual * context is not available. * Try a couple of variations to see if they will work. */ if( !( fgState.DisplayMode & GLUT_DOUBLE ) ) { fgState.DisplayMode |= GLUT_DOUBLE ; window->Window.VisualInfo = fgChooseVisual( ); fgState.DisplayMode &= ~GLUT_DOUBLE; } /* * GLUT also checks for multi-sampling, but I don't see that * anywhere else in FREEGLUT so I won't bother with it for the moment. */ } FREEGLUT_INTERNAL_ERROR_EXIT( window->Window.VisualInfo != NULL, "Visual with necessary capabilities not found", "fgOpenWindow" ); /* * XXX HINT: the masks should be updated when adding/removing callbacks. * XXX This might speed up message processing. Is that true? * XXX * XXX A: Not appreciably, but it WILL make it easier to debug. * XXX Try tracing old GLUT and try tracing freeglut. Old GLUT * XXX turns off events that it doesn't need and is a whole lot * XXX more pleasant to trace. (Think mouse-motion! Tons of * XXX ``bonus'' GUI events stream in.) */ winAttr.event_mask = StructureNotifyMask | SubstructureNotifyMask | ExposureMask | ButtonPressMask | ButtonReleaseMask | KeyPressMask | KeyReleaseMask | VisibilityChangeMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask | ButtonMotionMask; winAttr.background_pixmap = None; winAttr.background_pixel = 0; winAttr.border_pixel = 0; winAttr.colormap = XCreateColormap( fgDisplay.Display, fgDisplay.RootWindow, window->Window.VisualInfo->visual, AllocNone ); mask = CWBackPixmap | CWBorderPixel | CWColormap | CWEventMask; if( window->IsMenu || ( gameMode == GL_TRUE ) ) { winAttr.override_redirect = True; mask |= CWOverrideRedirect; } window->Window.Handle = XCreateWindow( fgDisplay.Display, window->Parent == NULL ? fgDisplay.RootWindow : window->Parent->Window.Handle, x, y, w, h, 0, window->Window.VisualInfo->depth, InputOutput, window->Window.VisualInfo->visual, mask, &winAttr ); /* * The GLX context creation, possibly trying the direct context rendering * or else use the current context if the user has so specified */ if( window->IsMenu ) { /* * 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->VisualInfo = window->Window.VisualInfo; fgStructure.MenuContext->Context = glXCreateContext( fgDisplay.Display, fgStructure.MenuContext->VisualInfo, NULL, ( fgState.DirectContext != GLUT_FORCE_INDIRECT_CONTEXT ) ); } /* window->Window.Context = fgStructure.MenuContext->Context; */ window->Window.Context = glXCreateContext( fgDisplay.Display, window->Window.VisualInfo, NULL, ( fgState.DirectContext != GLUT_FORCE_INDIRECT_CONTEXT ) ); } else if( fgState.UseCurrentContext ) { window->Window.Context = glXGetCurrentContext( ); if( ! window->Window.Context ) window->Window.Context = glXCreateContext( fgDisplay.Display, window->Window.VisualInfo, NULL, ( fgState.DirectContext != GLUT_FORCE_INDIRECT_CONTEXT ) ); } else window->Window.Context = glXCreateContext( fgDisplay.Display, window->Window.VisualInfo, NULL, ( fgState.DirectContext != GLUT_FORCE_INDIRECT_CONTEXT ) ); #if !defined( __FreeBSD__ ) && !defined( __NetBSD__ ) if( !glXIsDirect( fgDisplay.Display, window->Window.Context ) ) { if( fgState.DirectContext == GLUT_FORCE_DIRECT_CONTEXT ) fgError( "Unable to force direct context rendering for window '%s'", title ); else if( fgState.DirectContext == GLUT_TRY_DIRECT_CONTEXT ) fgWarning( "Unable to create direct context rendering for window '%s'\nThis may hurt performance.", title ); } #endif /* * XXX Assume the new window is visible by default * XXX Is this a safe assumption? */ window->State.Visible = GL_TRUE; sizeHints.flags = 0; if ( fgState.Position.Use ) sizeHints.flags |= USPosition; if ( fgState.Size.Use ) sizeHints.flags |= USSize; /* * Fill in the size hints values now (the x, y, width and height * settings are obsolete, are there any more WMs that support them?) * Unless the X servers actually stop supporting these, we should * continue to fill them in. It is *not* our place to tell the user * that they should replace a window manager that they like, and which * works, just because *we* think that it's not "modern" enough. */ sizeHints.x = x; sizeHints.y = y; sizeHints.width = w; sizeHints.height = h; wmHints.flags = StateHint; wmHints.initial_state = fgState.ForceIconic ? IconicState : NormalState; /* Prepare the window and iconified window names... */ XStringListToTextProperty( (char **) &title, 1, &textProperty ); XSetWMProperties( fgDisplay.Display, window->Window.Handle, &textProperty, &textProperty, 0, 0, &sizeHints, &wmHints, NULL ); XFree( textProperty.value ); XSetWMProtocols( fgDisplay.Display, window->Window.Handle, &fgDisplay.DeleteWindow, 1 ); glXMakeCurrent( fgDisplay.Display, window->Window.Handle, window->Window.Context ); XMapWindow( fgDisplay.Display, window->Window.Handle ); #elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE WNDCLASS wc; DWORD flags; DWORD exFlags = 0; ATOM atom; /* Grab the window class we have registered on glutInit(): */ atom = GetClassInfo( fgDisplay.Instance, _T("FREEGLUT"), &wc ); FREEGLUT_INTERNAL_ERROR_EXIT ( atom, "Window Class Info Not Found", "fgOpenWindow" ); if( gameMode ) { FREEGLUT_INTERNAL_ERROR_EXIT ( window->Parent == NULL, "Game mode being invoked on a subwindow", "fgOpenWindow" ); /* * Set the window creation flags appropriately to make the window * entirely visible: */ flags = WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_VISIBLE; } else { #if !TARGET_HOST_WINCE if ( ( ! isSubWindow ) && ( ! window->IsMenu ) ) { /* * Update the window dimensions, taking account of window * decorations. "freeglut" is to create the window with the * outside of its border at (x,y) and with dimensions (w,h). */ w += (GetSystemMetrics( SM_CXSIZEFRAME ) )*2; h += (GetSystemMetrics( SM_CYSIZEFRAME ) )*2 + GetSystemMetrics( SM_CYCAPTION ); } #endif /* TARGET_HOST_WINCE */ if( ! fgState.Position.Use ) { x = CW_USEDEFAULT; y = CW_USEDEFAULT; } if( ! fgState.Size.Use ) { w = CW_USEDEFAULT; h = CW_USEDEFAULT; } /* * There's a small difference between creating the top, child and * game mode windows */ flags = WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_VISIBLE; if ( window->IsMenu ) { flags |= WS_POPUP; exFlags |= WS_EX_TOOLWINDOW; } #if !TARGET_HOST_WINCE else if( window->Parent == NULL ) flags |= WS_OVERLAPPEDWINDOW; #endif else flags |= WS_CHILD; } #if TARGET_HOST_WINCE { wchar_t* wstr = fghWstrFromStr(title); window->Window.Handle = CreateWindow( _T("FREEGLUT"), wstr, WS_VISIBLE | WS_POPUP, 0,0, 240,320, NULL, NULL, fgDisplay.Instance, (LPVOID) window ); free(wstr); SHFullScreen(window->Window.Handle, SHFS_HIDESTARTICON); SHFullScreen(window->Window.Handle, SHFS_HIDESIPBUTTON); SHFullScreen(window->Window.Handle, SHFS_HIDETASKBAR); MoveWindow(window->Window.Handle, 0, 0, 240, 320, TRUE); ShowWindow(window->Window.Handle, SW_SHOW); UpdateWindow(window->Window.Handle); } #else window->Window.Handle = CreateWindowExA( exFlags, "FREEGLUT", title, flags, x, y, w, h, (HWND) window->Parent == NULL ? NULL : window->Parent->Window.Handle, (HMENU) NULL, fgDisplay.Instance, (LPVOID) window ); #endif /* TARGET_HOST_WINCE */ if( !( window->Window.Handle ) ) fgError( "Failed to create a window (%s)!", title ); #if TARGET_HOST_WINCE ShowWindow( window->Window.Handle, SW_SHOW ); #else ShowWindow( window->Window.Handle, fgState.ForceIconic ? SW_SHOWMINIMIZED : SW_SHOW ); #endif /* TARGET_HOST_WINCE */ UpdateWindow( window->Window.Handle ); ShowCursor( TRUE ); /* XXX Old comments say "hide cursor"! */ #endif fgSetWindow( window ); window->Window.DoubleBuffered = ( fgState.DisplayMode & GLUT_DOUBLE ) ? 1 : 0; if ( ! window->Window.DoubleBuffered ) { glDrawBuffer ( GL_FRONT ); glReadBuffer ( GL_FRONT ); } }
/* * The window procedure for handling Win32 events */ LRESULT CALLBACK fgPlatformWindowProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam ) { static unsigned char lControl = 0, rControl = 0, lShift = 0, rShift = 0, lAlt = 0, rAlt = 0; SFG_Window* window; PAINTSTRUCT ps; LRESULT lRet = 1; FREEGLUT_INTERNAL_ERROR_EXIT_IF_NOT_INITIALISED ( "Event Handler" ) ; window = fgWindowByHandle( hWnd ); if ( ( window == NULL ) && ( uMsg != WM_CREATE ) ) return DefWindowProc( hWnd, uMsg, wParam, lParam ); /* printf ( "Window %3d message <%04x> %12d %12d\n", window?window->ID:0, uMsg, wParam, lParam ); */ if ( window ) { /* Checking for CTRL, ALT, and SHIFT key positions: Key Down! */ if ( !lControl && GetAsyncKeyState ( VK_LCONTROL ) ) { INVOKE_WCB ( *window, Special, ( GLUT_KEY_CTRL_L, window->State.MouseX, window->State.MouseY ) ); lControl = 1; } if ( !rControl && GetAsyncKeyState ( VK_RCONTROL ) ) { INVOKE_WCB ( *window, Special, ( GLUT_KEY_CTRL_R, window->State.MouseX, window->State.MouseY ) ); rControl = 1; } if ( !lShift && GetAsyncKeyState ( VK_LSHIFT ) ) { INVOKE_WCB ( *window, Special, ( GLUT_KEY_SHIFT_L, window->State.MouseX, window->State.MouseY ) ); lShift = 1; } if ( !rShift && GetAsyncKeyState ( VK_RSHIFT ) ) { INVOKE_WCB ( *window, Special, ( GLUT_KEY_SHIFT_R, window->State.MouseX, window->State.MouseY ) ); rShift = 1; } if ( !lAlt && GetAsyncKeyState ( VK_LMENU ) ) { INVOKE_WCB ( *window, Special, ( GLUT_KEY_ALT_L, window->State.MouseX, window->State.MouseY ) ); lAlt = 1; } if ( !rAlt && GetAsyncKeyState ( VK_RMENU ) ) { INVOKE_WCB ( *window, Special, ( GLUT_KEY_ALT_R, window->State.MouseX, window->State.MouseY ) ); rAlt = 1; } /* Checking for CTRL, ALT, and SHIFT key positions: Key Up! */ if ( lControl && !GetAsyncKeyState ( VK_LCONTROL ) ) { INVOKE_WCB ( *window, SpecialUp, ( GLUT_KEY_CTRL_L, window->State.MouseX, window->State.MouseY ) ); lControl = 0; } if ( rControl && !GetAsyncKeyState ( VK_RCONTROL ) ) { INVOKE_WCB ( *window, SpecialUp, ( GLUT_KEY_CTRL_R, window->State.MouseX, window->State.MouseY ) ); rControl = 0; } if ( lShift && !GetAsyncKeyState ( VK_LSHIFT ) ) { INVOKE_WCB ( *window, SpecialUp, ( GLUT_KEY_SHIFT_L, window->State.MouseX, window->State.MouseY ) ); lShift = 0; } if ( rShift && !GetAsyncKeyState ( VK_RSHIFT ) ) { INVOKE_WCB ( *window, SpecialUp, ( GLUT_KEY_SHIFT_R, window->State.MouseX, window->State.MouseY ) ); rShift = 0; } if ( lAlt && !GetAsyncKeyState ( VK_LMENU ) ) { INVOKE_WCB ( *window, SpecialUp, ( GLUT_KEY_ALT_L, window->State.MouseX, window->State.MouseY ) ); lAlt = 0; } if ( rAlt && !GetAsyncKeyState ( VK_RMENU ) ) { INVOKE_WCB ( *window, SpecialUp, ( GLUT_KEY_ALT_R, window->State.MouseX, window->State.MouseY ) ); rAlt = 0; } } switch( uMsg ) { case WM_CREATE: /* The window structure is passed as the creation structure parameter... */ window = (SFG_Window *) (((LPCREATESTRUCT) lParam)->lpCreateParams); FREEGLUT_INTERNAL_ERROR_EXIT ( ( window != NULL ), "Cannot create window", "fgPlatformWindowProc" ); window->Window.Handle = hWnd; window->Window.pContext.Device = GetDC( hWnd ); if( window->IsMenu ) { unsigned int current_DisplayMode = fgState.DisplayMode; fgState.DisplayMode = GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH; #if !defined(_WIN32_WCE) fgSetupPixelFormat( window, GL_FALSE, PFD_MAIN_PLANE ); #endif fgState.DisplayMode = current_DisplayMode; if( fgStructure.MenuContext ) wglMakeCurrent( window->Window.pContext.Device, fgStructure.MenuContext->MContext ); else { fgStructure.MenuContext = (SFG_MenuContext *)malloc( sizeof(SFG_MenuContext) ); fgStructure.MenuContext->MContext = wglCreateContext( window->Window.pContext.Device ); } /* window->Window.Context = wglGetCurrentContext (); */ window->Window.Context = wglCreateContext( window->Window.pContext.Device ); } else { #if !defined(_WIN32_WCE) fgSetupPixelFormat( window, GL_FALSE, PFD_MAIN_PLANE ); #endif if( ! fgState.UseCurrentContext ) window->Window.Context = wglCreateContext( window->Window.pContext.Device ); else { window->Window.Context = wglGetCurrentContext( ); if( ! window->Window.Context ) window->Window.Context = wglCreateContext( window->Window.pContext.Device ); } #if !defined(_WIN32_WCE) fgNewWGLCreateContext( window ); #endif } window->State.NeedToResize = GL_TRUE; /* if we used CW_USEDEFAULT (thats a negative value) for the size * of the window, query the window now for the size at which it * was created. */ if( ( window->State.Width < 0 ) || ( window->State.Height < 0 ) ) { SFG_Window *current_window = fgStructure.CurrentWindow; fgSetWindow( window ); window->State.Width = glutGet( GLUT_WINDOW_WIDTH ); window->State.Height = glutGet( GLUT_WINDOW_HEIGHT ); fgSetWindow( current_window ); } ReleaseDC( window->Window.Handle, window->Window.pContext.Device ); #if defined(_WIN32_WCE) /* Take over button handling */ { HINSTANCE dxDllLib=LoadLibrary(_T("gx.dll")); if (dxDllLib) { GXGetDefaultKeys_=(GXGETDEFAULTKEYS)GetProcAddress(dxDllLib, _T("?GXGetDefaultKeys@@YA?AUGXKeyList@@H@Z")); GXOpenInput_=(GXOPENINPUT)GetProcAddress(dxDllLib, _T("?GXOpenInput@@YAHXZ")); } if(GXOpenInput_) (*GXOpenInput_)(); if(GXGetDefaultKeys_) gxKeyList = (*GXGetDefaultKeys_)(GX_LANDSCAPEKEYS); } #endif /* defined(_WIN32_WCE) */ break; case WM_SIZE: /* * If the window is visible, then it is the user manually resizing it. * If it is not, then it is the system sending us a dummy resize with * zero dimensions on a "glutIconifyWindow" call. */ if( window->State.Visible ) { window->State.NeedToResize = GL_TRUE; #if defined(_WIN32_WCE) window->State.Width = HIWORD(lParam); window->State.Height = LOWORD(lParam); #else window->State.Width = LOWORD(lParam); window->State.Height = HIWORD(lParam); #endif /* defined(_WIN32_WCE) */ } break; case WM_SETFOCUS: /* printf("WM_SETFOCUS: %p\n", window ); */ lRet = DefWindowProc( hWnd, uMsg, wParam, lParam ); INVOKE_WCB( *window, Entry, ( GLUT_ENTERED ) ); UpdateWindow ( hWnd ); break; case WM_KILLFOCUS: /* printf("WM_KILLFOCUS: %p\n", window ); */ lRet = DefWindowProc( hWnd, uMsg, wParam, lParam ); INVOKE_WCB( *window, Entry, ( GLUT_LEFT ) ); if( window->IsMenu && window->ActiveMenu && window->ActiveMenu->IsActive ) fgUpdateMenuHighlight( window->ActiveMenu ); break; #if 0 case WM_ACTIVATE: if (LOWORD(wParam) != WA_INACTIVE) { /* printf("WM_ACTIVATE: fgSetCursor( %p, %d)\n", window, window->State.Cursor ); */ fgSetCursor( window, window->State.Cursor ); } lRet = DefWindowProc( hWnd, uMsg, wParam, lParam ); break; #endif case WM_SETCURSOR: /* printf ( "Cursor event %x %x %x %x\n", window, window->State.Cursor, lParam, wParam ) ; */ if( LOWORD( lParam ) == HTCLIENT ) fgSetCursor ( window, window->State.Cursor ) ; else lRet = DefWindowProc( hWnd, uMsg, wParam, lParam ); break; case WM_SHOWWINDOW: window->State.Visible = GL_TRUE; window->State.Redisplay = GL_TRUE; break; case WM_PAINT: /* Turn on the visibility in case it was turned off somehow */ window->State.Visible = GL_TRUE; BeginPaint( hWnd, &ps ); fghRedrawWindow( window ); EndPaint( hWnd, &ps ); break; case WM_CLOSE: fgDestroyWindow ( window ); if ( fgState.ActionOnWindowClose != GLUT_ACTION_CONTINUE_EXECUTION ) PostQuitMessage(0); break; case WM_DESTROY: /* * The window already got destroyed, so don't bother with it. */ return 0; case WM_MOUSEMOVE: { #if defined(_WIN32_WCE) window->State.MouseX = 320-HIWORD( lParam ); window->State.MouseY = LOWORD( lParam ); #else window->State.MouseX = LOWORD( lParam ); window->State.MouseY = HIWORD( lParam ); #endif /* defined(_WIN32_WCE) */ /* Restrict to [-32768, 32767] to match X11 behaviour */ /* See comment in "freeglut_developer" mailing list 10/4/04 */ if ( window->State.MouseX > 32767 ) window->State.MouseX -= 65536; if ( window->State.MouseY > 32767 ) window->State.MouseY -= 65536; if ( window->ActiveMenu ) { fgUpdateMenuHighlight( window->ActiveMenu ); break; } SetFocus(window->Window.Handle); fgState.Modifiers = fgPlatformGetModifiers( ); if( ( wParam & MK_LBUTTON ) || ( wParam & MK_MBUTTON ) || ( wParam & MK_RBUTTON ) ) INVOKE_WCB( *window, Motion, ( window->State.MouseX, window->State.MouseY ) ); else INVOKE_WCB( *window, Passive, ( window->State.MouseX, window->State.MouseY ) ); fgState.Modifiers = INVALID_MODIFIERS; } break; case WM_LBUTTONDOWN: case WM_MBUTTONDOWN: case WM_RBUTTONDOWN: case WM_LBUTTONUP: case WM_MBUTTONUP: case WM_RBUTTONUP: { GLboolean pressed = GL_TRUE; int button; #if defined(_WIN32_WCE) window->State.MouseX = 320-HIWORD( lParam ); window->State.MouseY = LOWORD( lParam ); #else window->State.MouseX = LOWORD( lParam ); window->State.MouseY = HIWORD( lParam ); #endif /* defined(_WIN32_WCE) */ /* Restrict to [-32768, 32767] to match X11 behaviour */ /* See comment in "freeglut_developer" mailing list 10/4/04 */ if ( window->State.MouseX > 32767 ) window->State.MouseX -= 65536; if ( window->State.MouseY > 32767 ) window->State.MouseY -= 65536; switch( uMsg ) { case WM_LBUTTONDOWN: pressed = GL_TRUE; button = GLUT_LEFT_BUTTON; break; case WM_MBUTTONDOWN: pressed = GL_TRUE; button = GLUT_MIDDLE_BUTTON; break; case WM_RBUTTONDOWN: pressed = GL_TRUE; button = GLUT_RIGHT_BUTTON; break; case WM_LBUTTONUP: pressed = GL_FALSE; button = GLUT_LEFT_BUTTON; break; case WM_MBUTTONUP: pressed = GL_FALSE; button = GLUT_MIDDLE_BUTTON; break; case WM_RBUTTONUP: pressed = GL_FALSE; button = GLUT_RIGHT_BUTTON; break; default: pressed = GL_FALSE; button = -1; break; } #if !defined(_WIN32_WCE) if( GetSystemMetrics( SM_SWAPBUTTON ) ) { if( button == GLUT_LEFT_BUTTON ) button = GLUT_RIGHT_BUTTON; else if( button == GLUT_RIGHT_BUTTON ) button = GLUT_LEFT_BUTTON; } #endif /* !defined(_WIN32_WCE) */ if( button == -1 ) return DefWindowProc( hWnd, uMsg, lParam, wParam ); /* * Do not execute the application's mouse callback if a menu * is hooked to this button. In that case an appropriate * private call should be generated. */ if( fgCheckActiveMenu( window, button, pressed, window->State.MouseX, window->State.MouseY ) ) break; /* Set capture so that the window captures all the mouse messages */ /* * XXX - Multiple button support: Under X11, the mouse is not released * XXX - from the window until all buttons have been released, even if the * XXX - user presses a button in another window. This will take more * XXX - code changes than I am up to at the moment (10/5/04). The present * XXX - is a 90 percent solution. */ if ( pressed == GL_TRUE ) SetCapture ( window->Window.Handle ) ; else ReleaseCapture () ; if( ! FETCH_WCB( *window, Mouse ) ) break; fgSetWindow( window ); fgState.Modifiers = fgPlatformGetModifiers( ); INVOKE_WCB( *window, Mouse, ( button, pressed ? GLUT_DOWN : GLUT_UP, window->State.MouseX, window->State.MouseY ) ); fgState.Modifiers = INVALID_MODIFIERS; } break; case 0x020a: /* Should be WM_MOUSEWHEEL but my compiler doesn't recognize it */ { int wheel_number = LOWORD( wParam ); short ticks = ( short )HIWORD( wParam ); fgState.MouseWheelTicks += ticks; /* * XXX Should use WHEEL_DELTA instead of 120 */ if ( abs ( fgState.MouseWheelTicks ) > 120 ) { int direction = ( fgState.MouseWheelTicks > 0 ) ? 1 : -1; if( ! FETCH_WCB( *window, MouseWheel ) && ! FETCH_WCB( *window, Mouse ) ) break; fgSetWindow( window ); fgState.Modifiers = fgPlatformGetModifiers( ); /* * XXX Should use WHEEL_DELTA instead of 120 */ while( abs ( fgState.MouseWheelTicks ) > 120 ) { if( FETCH_WCB( *window, MouseWheel ) ) INVOKE_WCB( *window, MouseWheel, ( wheel_number, direction, window->State.MouseX, window->State.MouseY ) ); else /* No mouse wheel, call the mouse button callback twice */ { /* * Map wheel zero to button 3 and 4; +1 to 3, -1 to 4 * " " one +1 to 5, -1 to 6, ... * * XXX The below assumes that you have no more than 3 mouse * XXX buttons. Sorry. */ int button = wheel_number * 2 + 3; if( direction < 0 ) ++button; INVOKE_WCB( *window, Mouse, ( button, GLUT_DOWN, window->State.MouseX, window->State.MouseY ) ); INVOKE_WCB( *window, Mouse, ( button, GLUT_UP, window->State.MouseX, window->State.MouseY ) ); } /* * XXX Should use WHEEL_DELTA instead of 120 */ fgState.MouseWheelTicks -= 120 * direction; } fgState.Modifiers = INVALID_MODIFIERS; } } break ; case WM_SYSKEYDOWN: case WM_KEYDOWN: { int keypress = -1; POINT mouse_pos ; if( ( fgState.KeyRepeat==GLUT_KEY_REPEAT_OFF || window->State.IgnoreKeyRepeat==GL_TRUE ) && (HIWORD(lParam) & KF_REPEAT) ) break; /* * Remember the current modifiers state. This is done here in order * to make sure the VK_DELETE keyboard callback is executed properly. */ fgState.Modifiers = fgPlatformGetModifiers( ); GetCursorPos( &mouse_pos ); ScreenToClient( window->Window.Handle, &mouse_pos ); window->State.MouseX = mouse_pos.x; window->State.MouseY = mouse_pos.y; /* Convert the Win32 keystroke codes to GLUTtish way */ # define KEY(a,b) case a: keypress = b; break; switch( wParam ) { KEY( VK_F1, GLUT_KEY_F1 ); KEY( VK_F2, GLUT_KEY_F2 ); KEY( VK_F3, GLUT_KEY_F3 ); KEY( VK_F4, GLUT_KEY_F4 ); KEY( VK_F5, GLUT_KEY_F5 ); KEY( VK_F6, GLUT_KEY_F6 ); KEY( VK_F7, GLUT_KEY_F7 ); KEY( VK_F8, GLUT_KEY_F8 ); KEY( VK_F9, GLUT_KEY_F9 ); KEY( VK_F10, GLUT_KEY_F10 ); KEY( VK_F11, GLUT_KEY_F11 ); KEY( VK_F12, GLUT_KEY_F12 ); KEY( VK_PRIOR, GLUT_KEY_PAGE_UP ); KEY( VK_NEXT, GLUT_KEY_PAGE_DOWN ); KEY( VK_HOME, GLUT_KEY_HOME ); KEY( VK_END, GLUT_KEY_END ); KEY( VK_LEFT, GLUT_KEY_LEFT ); KEY( VK_UP, GLUT_KEY_UP ); KEY( VK_RIGHT, GLUT_KEY_RIGHT ); KEY( VK_DOWN, GLUT_KEY_DOWN ); KEY( VK_INSERT, GLUT_KEY_INSERT ); KEY( VK_LCONTROL, GLUT_KEY_CTRL_L ); KEY( VK_RCONTROL, GLUT_KEY_CTRL_R ); KEY( VK_LSHIFT, GLUT_KEY_SHIFT_L ); KEY( VK_RSHIFT, GLUT_KEY_SHIFT_R ); KEY( VK_LMENU, GLUT_KEY_ALT_L ); KEY( VK_RMENU, GLUT_KEY_ALT_R ); case VK_DELETE: /* The delete key should be treated as an ASCII keypress: */ INVOKE_WCB( *window, Keyboard, ( 127, window->State.MouseX, window->State.MouseY ) ); } #if defined(_WIN32_WCE) if(!(lParam & 0x40000000)) /* Prevent auto-repeat */ { if(wParam==(unsigned)gxKeyList.vkRight) keypress = GLUT_KEY_RIGHT; else if(wParam==(unsigned)gxKeyList.vkLeft) keypress = GLUT_KEY_LEFT; else if(wParam==(unsigned)gxKeyList.vkUp) keypress = GLUT_KEY_UP; else if(wParam==(unsigned)gxKeyList.vkDown) keypress = GLUT_KEY_DOWN; else if(wParam==(unsigned)gxKeyList.vkA) keypress = GLUT_KEY_F1; else if(wParam==(unsigned)gxKeyList.vkB) keypress = GLUT_KEY_F2; else if(wParam==(unsigned)gxKeyList.vkC) keypress = GLUT_KEY_F3; else if(wParam==(unsigned)gxKeyList.vkStart) keypress = GLUT_KEY_F4; } #endif if( keypress != -1 ) INVOKE_WCB( *window, Special, ( keypress, window->State.MouseX, window->State.MouseY ) ); fgState.Modifiers = INVALID_MODIFIERS; } break; case WM_SYSKEYUP: case WM_KEYUP: { int keypress = -1; POINT mouse_pos; /* * Remember the current modifiers state. This is done here in order * to make sure the VK_DELETE keyboard callback is executed properly. */ fgState.Modifiers = fgPlatformGetModifiers( ); GetCursorPos( &mouse_pos ); ScreenToClient( window->Window.Handle, &mouse_pos ); window->State.MouseX = mouse_pos.x; window->State.MouseY = mouse_pos.y; /* * Convert the Win32 keystroke codes to GLUTtish way. * "KEY(a,b)" was defined under "WM_KEYDOWN" */ switch( wParam ) { KEY( VK_F1, GLUT_KEY_F1 ); KEY( VK_F2, GLUT_KEY_F2 ); KEY( VK_F3, GLUT_KEY_F3 ); KEY( VK_F4, GLUT_KEY_F4 ); KEY( VK_F5, GLUT_KEY_F5 ); KEY( VK_F6, GLUT_KEY_F6 ); KEY( VK_F7, GLUT_KEY_F7 ); KEY( VK_F8, GLUT_KEY_F8 ); KEY( VK_F9, GLUT_KEY_F9 ); KEY( VK_F10, GLUT_KEY_F10 ); KEY( VK_F11, GLUT_KEY_F11 ); KEY( VK_F12, GLUT_KEY_F12 ); KEY( VK_PRIOR, GLUT_KEY_PAGE_UP ); KEY( VK_NEXT, GLUT_KEY_PAGE_DOWN ); KEY( VK_HOME, GLUT_KEY_HOME ); KEY( VK_END, GLUT_KEY_END ); KEY( VK_LEFT, GLUT_KEY_LEFT ); KEY( VK_UP, GLUT_KEY_UP ); KEY( VK_RIGHT, GLUT_KEY_RIGHT ); KEY( VK_DOWN, GLUT_KEY_DOWN ); KEY( VK_INSERT, GLUT_KEY_INSERT ); KEY( VK_LCONTROL, GLUT_KEY_CTRL_L ); KEY( VK_RCONTROL, GLUT_KEY_CTRL_R ); KEY( VK_LSHIFT, GLUT_KEY_SHIFT_L ); KEY( VK_RSHIFT, GLUT_KEY_SHIFT_R ); KEY( VK_LMENU, GLUT_KEY_ALT_L ); KEY( VK_RMENU, GLUT_KEY_ALT_R ); case VK_DELETE: /* The delete key should be treated as an ASCII keypress: */ INVOKE_WCB( *window, KeyboardUp, ( 127, window->State.MouseX, window->State.MouseY ) ); break; default: { #if !defined(_WIN32_WCE) BYTE state[ 256 ]; WORD code[ 2 ]; GetKeyboardState( state ); if( ToAscii( (UINT)wParam, 0, state, code, 0 ) == 1 ) wParam=code[ 0 ]; INVOKE_WCB( *window, KeyboardUp, ( (char)wParam, window->State.MouseX, window->State.MouseY ) ); #endif /* !defined(_WIN32_WCE) */ } } if( keypress != -1 ) INVOKE_WCB( *window, SpecialUp, ( keypress, window->State.MouseX, window->State.MouseY ) ); fgState.Modifiers = INVALID_MODIFIERS; } break; case WM_SYSCHAR: case WM_CHAR: { if( (fgState.KeyRepeat==GLUT_KEY_REPEAT_OFF || window->State.IgnoreKeyRepeat==GL_TRUE) && (HIWORD(lParam) & KF_REPEAT) ) break; fgState.Modifiers = fgPlatformGetModifiers( ); INVOKE_WCB( *window, Keyboard, ( (char)wParam, window->State.MouseX, window->State.MouseY ) ); fgState.Modifiers = INVALID_MODIFIERS; } break; case WM_CAPTURECHANGED: /* User has finished resizing the window, force a redraw */ INVOKE_WCB( *window, Display, ( ) ); /*lRet = DefWindowProc( hWnd, uMsg, wParam, lParam ); */ break; /* Other messages that I have seen and which are not handled already */ case WM_SETTEXT: /* 0x000c */ lRet = DefWindowProc( hWnd, uMsg, wParam, lParam ); /* Pass it on to "DefWindowProc" to set the window text */ break; case WM_GETTEXT: /* 0x000d */ /* Ideally we would copy the title of the window into "lParam" */ /* strncpy ( (char *)lParam, "Window Title", wParam ); lRet = ( wParam > 12 ) ? 12 : wParam; */ /* the number of characters copied */ lRet = DefWindowProc( hWnd, uMsg, wParam, lParam ); break; case WM_GETTEXTLENGTH: /* 0x000e */ /* Ideally we would get the length of the title of the window */ lRet = 12; /* the number of characters in "Window Title\0" (see above) */ break; case WM_ERASEBKGND: /* 0x0014 */ lRet = DefWindowProc( hWnd, uMsg, wParam, lParam ); break; #if !defined(_WIN32_WCE) case WM_SYNCPAINT: /* 0x0088 */ /* Another window has moved, need to update this one */ window->State.Redisplay = GL_TRUE; lRet = DefWindowProc( hWnd, uMsg, wParam, lParam ); /* Help screen says this message must be passed to "DefWindowProc" */ break; case WM_NCPAINT: /* 0x0085 */ /* Need to update the border of this window */ lRet = DefWindowProc( hWnd, uMsg, wParam, lParam ); /* Pass it on to "DefWindowProc" to repaint a standard border */ break; case WM_SYSCOMMAND : /* 0x0112 */ { /* * We have received a system command message. Try to act on it. * The commands are passed in through the "wParam" parameter: * The least significant digit seems to be which edge of the window * is being used for a resize event: * 4 3 5 * 1 2 * 7 6 8 * Congratulations and thanks to Richard Rauch for figuring this out.. */ switch ( wParam & 0xfff0 ) { case SC_SIZE : break ; case SC_MOVE : break ; case SC_MINIMIZE : /* User has clicked on the "-" to minimize the window */ /* Turn off the visibility */ window->State.Visible = GL_FALSE ; break ; case SC_MAXIMIZE : break ; case SC_NEXTWINDOW : break ; case SC_PREVWINDOW : break ; case SC_CLOSE : /* Followed very closely by a WM_CLOSE message */ break ; case SC_VSCROLL : break ; case SC_HSCROLL : break ; case SC_MOUSEMENU : break ; case SC_KEYMENU : break ; case SC_ARRANGE : break ; case SC_RESTORE : break ; case SC_TASKLIST : break ; case SC_SCREENSAVE : break ; case SC_HOTKEY : break ; #if(WINVER >= 0x0400) case SC_DEFAULT : break ; case SC_MONITORPOWER : break ; case SC_CONTEXTHELP : break ; #endif /* WINVER >= 0x0400 */ default: #if _DEBUG fgWarning( "Unknown wParam type 0x%x", wParam ); #endif break; } } #endif /* !defined(_WIN32_WCE) */ /* We need to pass the message on to the operating system as well */ lRet = DefWindowProc( hWnd, uMsg, wParam, lParam ); break; #ifdef WM_TOUCH /* handle multi-touch messages */ case WM_TOUCH: { unsigned int numInputs = (unsigned int)wParam; unsigned int i = 0; TOUCHINPUT* ti = (TOUCHINPUT*)malloc( sizeof(TOUCHINPUT)*numInputs); if (fghGetTouchInputInfo == (pGetTouchInputInfo)0xDEADBEEF) { fghGetTouchInputInfo = (pGetTouchInputInfo)GetProcAddress(GetModuleHandle("user32"),"GetTouchInputInfo"); fghCloseTouchInputHandle = (pCloseTouchInputHandle)GetProcAddress(GetModuleHandle("user32"),"CloseTouchInputHandle"); } if (!fghGetTouchInputInfo) { free( (void*)ti ); break; } if (fghGetTouchInputInfo( (HTOUCHINPUT)lParam, numInputs, ti, sizeof(TOUCHINPUT) )) { /* Handle each contact point */ for (i = 0; i < numInputs; ++i ) { POINT tp; tp.x = TOUCH_COORD_TO_PIXEL(ti[i].x); tp.y = TOUCH_COORD_TO_PIXEL(ti[i].y); ScreenToClient( hWnd, &tp ); ti[i].dwID = ti[i].dwID * 2; if (ti[i].dwFlags & TOUCHEVENTF_DOWN) { INVOKE_WCB( *window, MultiEntry, ( ti[i].dwID, GLUT_ENTERED ) ); INVOKE_WCB( *window, MultiButton, ( ti[i].dwID, tp.x, tp.y, 0, GLUT_DOWN ) ); } else if (ti[i].dwFlags & TOUCHEVENTF_MOVE) { INVOKE_WCB( *window, MultiMotion, ( ti[i].dwID, tp.x, tp.y ) ); } else if (ti[i].dwFlags & TOUCHEVENTF_UP) { INVOKE_WCB( *window, MultiButton, ( ti[i].dwID, tp.x, tp.y, 0, GLUT_UP ) ); INVOKE_WCB( *window, MultiEntry, ( ti[i].dwID, GLUT_LEFT ) ); } } } fghCloseTouchInputHandle((HTOUCHINPUT)lParam); free( (void*)ti ); lRet = 0; /*DefWindowProc( hWnd, uMsg, wParam, lParam );*/ break; } #endif default: /* Handle unhandled messages */ lRet = DefWindowProc( hWnd, uMsg, wParam, lParam ); break; } return lRet; }
/* * Deactivates a menu pointed by the function argument. */ void fgDeactivateMenu( SFG_Window *window ) { SFG_Window *parent_window = NULL; SFG_Menu* menu; SFG_MenuEntry *menuEntry; /* Did we find an active window? */ freeglut_return_if_fail( window ); /* Check if there is an active menu attached to this window... */ menu = window->ActiveMenu; freeglut_return_if_fail( menu ); parent_window = menu->ParentWindow; /* Hide the present menu's window */ fgSetWindow( menu->Window ); glutHideWindow( ); /* Forget about having that menu active anymore, now: */ menu->Window->ActiveMenu = NULL; menu->ParentWindow->ActiveMenu = NULL; fghSetMenuParentWindow ( NULL, menu ); menu->IsActive = GL_FALSE; menu->ActiveEntry = NULL; fgState.ActiveMenus--; /* Hide all submenu windows, and the root menu's window. */ for ( menuEntry = ( SFG_MenuEntry * )menu->Entries.First; menuEntry; menuEntry = ( SFG_MenuEntry * )menuEntry->Node.Next ) { menuEntry->IsActive = GL_FALSE; /* Is that an active submenu by any chance? */ if( menuEntry->SubMenu ) fghDeactivateSubMenu( menuEntry ); } fgSetWindow ( parent_window ) ; /* Menu status callback */ if (fgState.MenuStateCallback || fgState.MenuStatusCallback) { fgStructure.CurrentMenu = menu; fgStructure.CurrentWindow = parent_window; if (fgState.MenuStateCallback) fgState.MenuStateCallback(GLUT_MENU_NOT_IN_USE); if (fgState.MenuStatusCallback) { /* Get cursor position on screen and convert to relative to parent_window's client area */ SFG_XYUse mouse_pos; fghGetCursorPos(&mouse_pos); mouse_pos.X -= glutGet( GLUT_WINDOW_X ); mouse_pos.Y -= glutGet( GLUT_WINDOW_Y ); fgState.MenuStatusCallback(GLUT_MENU_NOT_IN_USE, mouse_pos.X, mouse_pos.Y); } } }
/* * Enters the freeglut processing loop. * Stays until the "ExecState" changes to "GLUT_EXEC_STATE_STOP". */ void FGAPIENTRY glutMainLoopMT( void ) { //int action; //MT #if TARGET_HOST_WIN32 || TARGET_HOST_WINCE SFG_Window *window = (SFG_Window *)fgStructure.Windows.First ; #endif FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutMainLoop" ); #if TARGET_HOST_WIN32 || TARGET_HOST_WINCE /* * Processing before the main loop: If there is a window which is open and * which has a visibility callback, call it. I know this is an ugly hack, * but I'm not sure what else to do about it. Ideally we should leave * something uninitialized in the create window code and initialize it in * the main loop, and have that initialization create a "WM_ACTIVATE" * message. Then we would put the visibility callback code in the * "case WM_ACTIVATE" block below. - John Fay -- 10/24/02 */ while( window ) { if ( FETCH_WCB( *window, Visibility ) ) { SFG_Window *current_window = fgStructure.CurrentWindow ; INVOKE_WCB( *window, Visibility, ( window->State.Visible ) ); fgSetWindow( current_window ); } window = (SFG_Window *)window->Node.Next ; } #endif fgState.ExecState = GLUT_EXEC_STATE_RUNNING ; while( fgState.ExecState == GLUT_EXEC_STATE_RUNNING ) { SFG_Window *window; glutMainLoopEvent( ); /* * Step through the list of windows, seeing if there are any * that are not menus */ for( window = ( SFG_Window * )fgStructure.Windows.First; window; window = ( SFG_Window * )window->Node.Next ) if ( ! ( window->IsMenu ) ) break; if( ! window ) fgState.ExecState = GLUT_EXEC_STATE_STOP; else { if( fgState.IdleCallback ) { if( fgStructure.CurrentWindow && fgStructure.CurrentWindow->IsMenu ) /* fail safe */ fgSetWindow( window ); fgState.IdleCallback( ); } fghSleepForEvents( ); } } #if 0 //Marc Toussaint /* * When this loop terminates, destroy the display, state and structure * of a freeglut session, so that another glutInit() call can happen * * Save the "ActionOnWindowClose" because "fgDeinitialize" resets it. */ action = fgState.ActionOnWindowClose; fgDeinitialize( ); if( action == GLUT_ACTION_EXIT ) exit( 0 ); #endif }
/* * Private function to check for the current menu/sub menu activity state */ static GLboolean fghCheckMenuStatus( SFG_Window* window, SFG_Menu* menu ) { SFG_MenuEntry* menuEntry; int x, y; /* * First of all check any of the active sub menus... */ for( menuEntry = (SFG_MenuEntry *)menu->Entries.First; menuEntry; menuEntry = (SFG_MenuEntry *)menuEntry->Node.Next ) { if( menuEntry->SubMenu && menuEntry->IsActive ) { /* * OK, have the sub-menu checked, too. If it returns GL_TRUE, it * will mean that it caught the mouse cursor and we do not need * to regenerate the activity list, and so our parents do... */ GLboolean return_status = fghCheckMenuStatus( window, menuEntry->SubMenu ); /* * Reactivate the submenu as the checkMenuStatus may have turned * it off if the mouse is in its parent menu entry. */ menuEntry->SubMenu->IsActive = GL_TRUE; if ( return_status ) return GL_TRUE; } } /* * That much about our sub menus, let's get to checking the current menu: */ x = window->State.MouseX; y = window->State.MouseY; for( menuEntry = (SFG_MenuEntry *)menu->Entries.First; menuEntry; menuEntry = (SFG_MenuEntry *)menuEntry->Node.Next ) menuEntry->IsActive = GL_FALSE; menu->IsActive = GL_FALSE; /* * Check if the mouse cursor is contained within the current menu box */ if( ( x >= FREEGLUT_MENU_BORDER ) && ( x < menu->Width - FREEGLUT_MENU_BORDER ) && ( y >= FREEGLUT_MENU_BORDER ) && ( y < menu->Height - FREEGLUT_MENU_BORDER ) && ( window == menu->Window ) ) { int menuID = ( y - FREEGLUT_MENU_BORDER ) / FREEGLUT_MENU_HEIGHT; /* * The mouse cursor is somewhere over our box, check it out. */ menuEntry = fghFindMenuEntry( menu, menuID + 1 ); assert( menuEntry ); menuEntry->IsActive = GL_TRUE; menuEntry->Ordinal = menuID; /* * If this is not the same as the last active menu entry, deactivate * the previous entry. Specifically, if the previous active entry * was a submenu then deactivate it. */ if( menu->ActiveEntry && ( menuEntry != menu->ActiveEntry ) ) if( menu->ActiveEntry->SubMenu ) fgDeactivateSubMenu( menu->ActiveEntry ); menu->ActiveEntry = menuEntry; menu->IsActive = GL_TRUE; /* * OKi, we have marked that entry as active, but it would be also * nice to have its contents updated, in case it's a sub menu. * Also, ignore the return value of the check function: */ if( menuEntry->SubMenu ) { if ( ! menuEntry->SubMenu->IsActive ) { SFG_Window *current_window = fgStructure.Window; /* * Set up the initial menu position now... */ menuEntry->SubMenu->IsActive = GL_TRUE; /* * Set up the initial submenu position now: */ menuEntry->SubMenu->X = menu->X + menu->Width; menuEntry->SubMenu->Y = menu->Y + menuEntry->Ordinal * FREEGLUT_MENU_HEIGHT; if( menuEntry->SubMenu->X + menuEntry->SubMenu->Width > glutGet( GLUT_SCREEN_WIDTH ) ) menuEntry->SubMenu->X = menu->X - menuEntry->SubMenu->Width; if( menuEntry->SubMenu->Y + menuEntry->SubMenu->Height > glutGet( GLUT_SCREEN_HEIGHT ) ) menuEntry->SubMenu->Y -= ( menuEntry->SubMenu->Height - FREEGLUT_MENU_HEIGHT - 2 * FREEGLUT_MENU_BORDER ); fgSetWindow( menuEntry->SubMenu->Window ); glutPositionWindow( menuEntry->SubMenu->X, menuEntry->SubMenu->Y ); glutReshapeWindow( menuEntry->SubMenu->Width, menuEntry->SubMenu->Height ); glutPopWindow( ); glutShowWindow( ); menuEntry->SubMenu->Window->ActiveMenu = menuEntry->SubMenu; fgSetWindow( current_window ); } fghCheckMenuStatus( window, menuEntry->SubMenu ); /* * Activate it because its parent entry is active */ menuEntry->SubMenu->IsActive = GL_TRUE; } /* * Report back that we have caught the menu cursor */ return GL_TRUE; } /* * Looks like the menu cursor is somewhere else... */ return GL_FALSE; }
/* * Displays a menu box and all of its submenus (if they are active) */ static void fghDisplayMenuBox( SFG_Menu* menu ) { SFG_MenuEntry *menuEntry; int i; int border = FREEGLUT_MENU_BORDER; /* * Have the menu box drawn first. The +- values are * here just to make it more nice-looking... */ /* a non-black dark version of the below. */ glColor4f( 1.0f, 1.0f, 1.0f, 1.0f ); glBegin( GL_QUAD_STRIP ); glVertex2i( menu->Width , 0 ); glVertex2i( menu->Width - border, border); glVertex2i( 0 , 0 ); glVertex2i( border, border); glVertex2i( 0 , menu->Height ); glVertex2i( border, menu->Height - border); glEnd( ); /* a non-black dark version of the below. */ glColor4f( 0.5f, 0.5f, 0.5f, 1.0f ); glBegin( GL_QUAD_STRIP ); glVertex2i( 0 , menu->Height ); glVertex2i( border, menu->Height - border); glVertex2i( menu->Width , menu->Height ); glVertex2i( menu->Width - border, menu->Height - border); glVertex2i( menu->Width , 0 ); glVertex2i( menu->Width - border, border); glEnd( ); glColor4fv( menu_pen_back ); glBegin( GL_QUADS ); glVertex2i( border, border); glVertex2i( menu->Width - border, border); glVertex2i( menu->Width - border, menu->Height - border); glVertex2i( border, menu->Height - border); glEnd( ); /* * Check if any of the submenus is currently active... */ for( menuEntry = (SFG_MenuEntry *)menu->Entries.First; menuEntry; menuEntry = (SFG_MenuEntry *)menuEntry->Node.Next ) { /* * Has the menu been marked as active, maybe? */ if( menuEntry->IsActive ) { /* * That's truly right, and we need to have it highlighted. * There is an assumption that mouse cursor didn't move * since the last check of menu activity state: */ int menuID = menuEntry->Ordinal; /* * So have the highlight drawn... */ glColor4fv( menu_pen_hback ); glBegin( GL_QUADS ); glVertex2i( border, (menuID + 0)*FREEGLUT_MENU_HEIGHT + border ); glVertex2i( menu->Width - border, (menuID + 0)*FREEGLUT_MENU_HEIGHT + border ); glVertex2i( menu->Width - border, (menuID + 1)*FREEGLUT_MENU_HEIGHT + border ); glVertex2i( border, (menuID + 1)*FREEGLUT_MENU_HEIGHT + border ); glEnd( ); } } /* * Print the menu entries now... */ glColor4fv( menu_pen_fore ); for( menuEntry = (SFG_MenuEntry *)menu->Entries.First, i = 0; menuEntry; menuEntry = (SFG_MenuEntry *)menuEntry->Node.Next, ++i ) { /* * If the menu entry is active, set the color to white */ if( menuEntry->IsActive ) glColor4fv( menu_pen_hfore ); /* * Move the raster into position... */ /* Try to center the text - JCJ 31 July 2003*/ glRasterPos2i( 2 * border, ( i + 1 )*FREEGLUT_MENU_HEIGHT - ( int )( FREEGLUT_MENU_HEIGHT*0.3 - border ) ); /* * Have the label drawn, character after character: */ glutBitmapString( FREEGLUT_MENU_FONT, (unsigned char *)menuEntry->Text); /* * If it's a submenu, draw a right arrow */ if( menuEntry->SubMenu ) { int width = glutBitmapWidth( FREEGLUT_MENU_FONT, '_' ); int x_base = menu->Width - 2 - width; int y_base = i*FREEGLUT_MENU_HEIGHT + border; glBegin( GL_TRIANGLES ); glVertex2i( x_base, y_base + 2*border); glVertex2i( menu->Width - 2, y_base + ( FREEGLUT_MENU_HEIGHT + border) / 2 ); glVertex2i( x_base, y_base + FREEGLUT_MENU_HEIGHT - border ); glEnd( ); } /* * If the menu entry is active, reset the color */ if( menuEntry->IsActive ) glColor4fv( menu_pen_fore ); } /* * Now we are ready to check if any of our children needs to be redrawn: */ for( menuEntry = ( SFG_MenuEntry * )menu->Entries.First; menuEntry; menuEntry = ( SFG_MenuEntry * )menuEntry->Node.Next ) { /* * Is that an active sub menu by any case? */ if( menuEntry->SubMenu && menuEntry->IsActive ) { /* * Yeah, indeed. Have it redrawn now: */ fgSetWindow( menuEntry->SubMenu->Window ); fghDisplayMenuBox( menuEntry->SubMenu ); fgSetWindow( menu->Window ); } } }