Older Version
Newer Version
swetterlin
Jan 25, 2010
[[code format="vb"]] 'Demo for Hiding/Showing Submenus and Command Items 'This example illustrates how to hide submenus and reshow them when desired. The menus are created in the normal way, 'and we keep track of handles, IDs and positions to refer to later. 'Terminology: Menus are basically lists of menu items. The menu bar at the top of the window is the top-level menu. 'Its menu items are normally themselves menus and are called submenus. The menu items listed in a submenu, such as 'the File menu, normally trigger some action, such as Save File, and are called command items. However, the File 'menu could contain a submenu that opens another list. Everything is a menu item. Each menu item is either itself a menu, 'or it is a command item. Every menu except the menu bar is also a submenu. We don't deal here with hiding 'the menu bar, so everything we hide/show will either be a submenu or a command item. The distinction is important 'mainly because submenus are referred to by their handles (and normally have IDs of -1) and command items are 'referred to by their IDs (and have NULL handles). ' 'We create a File and Options menu, and two additional menus to trigger the hiding/showing of the entire Options 'menu, or the Save menu item in the File menu. Hiding/showing the Options menu illustrates how to deal with submenus. 'Hiding/showing the Save menu item illustrates how to deal with command items. 'declare major variables global hWindow 'Windows handle to the window global hMenuBar 'Windows handle to menu bar in window global hFileMenu, hOptionsMenu 'Windows handles to menus we want to mess with global menuSaveID 'ID of Save menu item global menuFilePosition, menuSavePosition, menuOptionsPosition 'Positions of these menu items in their menus, with first menu=0 global showOptions, showSave 'Flags to indicate whether Options menu and Save menu item should be made visible global optionsIsShowing, saveIsShowing 'Keeps track of what is actually showing now nomainwin [CreateWindow] WindowWidth = 300 WindowHeight = 300 UpperLeftX = 200 UpperLeftY = 200 'Create File, Save and Options menus menu #handle, "File", "Open", [Open], "Save", [Save] menu #handle, "Options", "Calibrate", [Calibrate], "Reset", [Reset] 'Create menu to hide/show entire Options menu with its command items menu #handle, "Options_Mode", "With Options",[WithOptions], "Without Options", [WithoutOptions] 'Create menu to hide/show just the Save command item in the File menu menu #handle, "File_Mode", "With Save", [WithSave], "Without Save", [WithoutSave] open "Test Window" for window as #handle 'Open the actual window with all menus showing 'Keep track of the position of the things that need to be modified. Note that if we were possibly 'hiding more than one menu in the menu bar, the position of our target menu might change based on 'what else we had hidden, so we would have to keep track of that. menuOptionsPosition=1 'Options menu is second in menu bar, which is position 1 when indexed from zero menuFilePosition=0 'File menu is first in menu bar, which is position 1 when indexed from zero menuSavePosition=1 'Save menu item is second in File menu, which is position 1 when indexed from zero hWindow=hwnd(#handle) 'get window handle 'Get handle to the menu bar. We could put this in a subroutine, but it will only be used once. calldll #user32, "GetMenu",_ hWindow as ulong,_ 'window handle hMenuBar as ulong 'returns handle of menubar 'Save handle to Options menu for later reference. Because it is a submenu (i.e. it opens another 'menu of choices) it is referred to by its handle) hOptionsMenu=uSubMenuHandle(hMenuBar, menuOptionsPosition) hFileMenu=uSubMenuHandle(hMenuBar, menuFilePosition) 'Save ID of Save menu item. Because it is a command item (i.e. it triggers a command, rather than 'opening another menu), it is referred to by an ID number) menuSaveID=uMenuItemID(hFileMenu, menuSavePosition) optionsIsShowing=1 : saveIsShowing=1 'Everything is showing at the moment showSave=1 : showOptions=0 'Tells ConformMenusToMode to show Save and hide Options call ConformMenusToMode 'Hide/show whatever is indicated by showSave and showOptions print #handle, "trapclose [quit]" 'goto [quit] if window is closed wait 'Wait for user action [quit] close #handle end 'These are the actions for the File and Options menus. Here we just wait. [Open] wait [Save] wait [Calibrate] wait [Reset] wait 'The following respond to clicks in the Options Mode and Save Mode menus. [WithOptions] showOptions=1 : call ConformMenusToMode wait [WithoutOptions] showOptions=0 : call ConformMenusToMode wait [WithSave] showSave=1 : call ConformMenusToMode wait [WithoutSave] showSave=0 : call ConformMenusToMode wait 'ConformMenusToMode shows/hides whatever is indicated by showOptions and showSave 'showOptions and showSave could be made arguments here instead of global variables. sub ConformMenusToMode 'Here we hide everything that might ever need to be hidden, and then show what we want. In this 'simple example, we could first check to see that what is now shown is supposed to be shown, but 'for a more involved case it is better to first hide everything that might need to be hidden. 'We created two different subroutines for hiding. One is for command items like Save, which 'actually trigger action and are referred to by an ID. One is for submenus like Options, which simply 'open another list of choices. if saveIsShowing then menuOK=uHideCommandItem(hFileMenu,menuSaveID) 'Hide Save menu item, identified by the handle of 'the menu it is in and its own ID 'Hide Options menu item, identified by the handle of menu it is in and its relative postion. 'This hides the word "Options" in the menu bar and also the Calibrate and Reset command items 'that are listed ini the Options menu. Because uHideSubMenu uses the DLL RemoveMenu, rather than DeleteMenu, 'the full Options menu structure will continue to exist in memory so we can show it later. if optionsIsShowing then menuOK=uHideSubMenu(hMenuBar, menuOptionsPosition) 'Now both Options and Save are hidden. If we want to show one, we do it here. 'For variety, we take a different approach here. For hiding, we created separate subroutines 'for command items and menus. Here, we use a single subroutine, with two different arguments, one for 'the ID and one for the handle. When showing a command item, we use the ID and dummy handle. When showing 'a submenu, we use the handle and a dummy ID. if showSave then menuOK=uShowMenuItem(hFileMenu, _ 'Handle to the menu that contains the Save menu item menuSaveID, _ 'ID of the Save menu item. We use this because Save is a command item NULL, _ 'Dummy handle for Save menu item. We use this because command items don't have handles. "Save", _ 'Caption to use for inserted menu item. We aren't changing the caption. menuSavePosition) 'Position in File menu to insert Save menu item. saveIsShowing=1 else saveIsShowing=0 end if if showOptions then menuOK=uShowMenuItem(hMenuBar, _ 'Handle to the menu that contains the Save menu item -1, _ 'Dummy ID of Options menu. IDs are for command items, which this is not. hOptionsMenu, _ 'handle to Options menu, which still exists in memory "Options", _ 'Caption to use for inserted menu. We aren't changing the caption. menuOptionsPosition) 'Position in menu bar to insert Options menu optionsIsShowing=1 else optionsIsShowing=0 end if 'The above only affected memory structures. We need to actually draw the new menu. 'This has to be done even if the window is not currently visible. 'We specify the handle of the window whose menu bar is to be redrawn. call uDrawMenu hWindow end sub '------------------------------------------------------------------------------------------- '-----The remaining subroutines are wrappers for calling Windows API functions.------------- '------------------------------------------------------------------------------------------- function uHideCommandItem(hParent, itemID) 'Delete the specified command item. It can later be re-inserted 'hParent is the submenu containing the item. "Parent" may not be Windows terminology. 'itemID is the ID of the item to hide by removing it calldll #user32, "RemoveMenu",_ hParent as ulong,_ 'handle of submenu itemID as ulong,_ 'menu item ID _MF_BYCOMMAND as long,_ 'says we are specifying the target item by its ID, not its position result as boolean 'nonzero=success We return this, but it probably won't be used. uHideCommandItem=result end function function uHideSubMenu(hParent, position) 'Delete the specified submenu. It can later be re-inserted 'hParent is the submenu containing the item. "Parent" may not be Windows terminology. 'postion is the position of the item to hide by removing it calldll #user32, "RemoveMenu",_ hParent as ulong,_ 'handle of menu listing the one we want to hide position as ulong,_ 'position of menu we want to hide _MF_BYPOSITION as long,_ 'Says we are specifying the target menu by its position result as boolean 'nonzero=success We return this, but it probably won't be used. uHideSubMenu=result end function function uShowMenuItem(hParent, itemID, hMenu, caption$, precedeNum) 'Insert a menu item that was previously deleted 'hParent is the submenu in which it will be inserted 'itemID is the item ID of the item to insert, if it is a command item; otherwise -1 'hMenu is the handle of the submenu to insert, if the item is a submenu; otherwise NULL 'caption$ is the name of the item being inserted; 'The item will be inserted prior to the item in position precedeNum (0...)--That is, 'once it is inserted it will occupy position precedeNum. 'the number of existing items. 'An alternative subroutine could be written to locate the insertion 'point by the ID of the item to be preceded, rather than by position. 'The DLL uses the following structure to contain info about the item to be shown struct MENUITEMINFO,cbSize as ulong,fMask as ulong, _ fType as ulong,fState as ulong,wID as ulong, _ hSubMenu as ulong,hbmpChecked as ulong,hbmpUnchecked as ulong, _ dwItemData as ulong,dwTypeData$ as ptr,cch as ulong 'Note dwTypeData$ is ptr because we have text caption MENUITEMINFO.cbSize.struct = len(MENUITEMINFO.struct) 'length of this structure MENUITEMINFO.fMask.struct = _MIIM_ID or _MIIM_SUBMENU or _MIIM_TYPE 'Says to process ID, submenu handle and type MENUITEMINFO.wID.struct = itemID 'ID of command item, or any value for submenu MENUITEMINFO.fType.struct = _MFT_STRING 'type of caption is text MENUITEMINFO.hSubMenu.struct =hMenu 'handle to submenu being inserted, or NULL if not a submenu MENUITEMINFO.dwTypeData$.struct = caption$ 'caption for menu. This is represented in the struct as a pointer to the text MENUITEMINFO.cch.struct = len(caption$) 'length of new caption 'we don't mess here with the struct members fState, hbmChecked, hbmpUnchecked or dwItemData. 'Actual DLL call calldll #user32, "InsertMenuItemA",_ hParent as ulong,_ 'handle of menu into which we are inserting. "Parent" may not be Windows terminology. precedeNum as ulong,_ 'pos of item that new item is to precede _MF_BYPOSITION as long,_ 'Says to find locate the insertion point by position MENUITEMINFO as struct,_ 'struct with item info result as boolean 'nonzero=success We return this, but it probably won't be used. uShowMenuItem=result end function sub uDrawMenu hWind 'Redraw menu after making modifications calldll #user32, "DrawMenuBar",_ hWind as ulong,_ 'window handle result as boolean 'nonzero=success We don't bother to return this end sub function uSubMenuHandle(hParent, subPosition) 'Return handle of submenu in specified position 'hParent is handle of the menu bar, or whatever menu contains the submenu 'subPosition is position (0...) of the desired submenu calldll #user32, "GetSubMenu",_ hParent as ulong,_ 'menu handle subPosition as long,_ '0-indexed pos of submenu whose handle is sought hSub as ulong 'returns submenu handle uSubMenuHandle=hSub end function function uMenuItemID(hSub, itemPosition) 'Return ID of item in submenu in menubar 'This returns -1 if the specified menu item is not a command item, so 'it is pointless to use it for submenus. calldll #user32, "GetMenuItemID", _ hSub as ulong, _ 'handle of the submenu itemPosition as long, _ 'position of the menu item menuID as ulong 'the handle (or ID) of the menu item uMenuItemID=menuID end function [[code]]