### Context Menu Services Availability LightWave® 7.0 Component Layout, Modeler Header lwpanel.h Context menu services are a set of functions for creating and displaying context menus over your panels. A context menu is a modal popup window containing a list of options. You typically display one of these when the user right-clicks or shift-clicks an item in your panel. Global Call
       ContextMenuFuncs *cmenuf;
       cmenuf = global( LWCONTEXTMENU_GLOBAL, GFUSE_TRANSIENT );
The global function returns a pointer to a ContextMenuFuncs.
       typedef struct st_ContextMenuFuncs {
          LWContextMenuID (*cmenuCreate) (LWPanPopupDesc, void *userdata);
          int             (*cmenuDeploy) (LWContextMenuID, LWPanelID,
                                            int item);
          void            (*cmenuDestroy)(LWContextMenuID);
       } ContextMenuFuncs;
`menu = cmenuCreate( popdesc, userdata )` Create a context menu. The `popdesc` structure, described below, contains your menu parameters and callbacks. The `userdata` is a pointer that you want your callbacks to receive. `selection = cmenuDeploy( menu, panel, item )` Display the context menu, typically in response to some user action. A context menu is always displayed in association with a particular `panel`. The `item` is the 0-based index of the menu item that should be selected when the menu is first displayed, and the return value is the index of the item selected by the user. Either of these can be -1 to indicate no selection. `cmenuDestroy( menu )` Free the menu and related resources allocated by `cmenuCreate`. Popup Descriptor The `cmenuCreate` function uses an LWPanPopupDesc structure to define the menu. This is the same structure used by Panels custom popup controls, but for that purpose, its details are conveniently hidden from you by the `CUSTPOPUP_CTL` macro.
       typedef struct st_LWPanPopupDesc {
          LWType  type;
          int     width;
          int    (*countFn)(void *userdata);
          char * (*nameFn) (void *userdata, int item);
       } LWPanPopupDesc;
`type` Set this to `LWT_POPUP`. `width` The width of the menu in pixels. `nitems = countFn( userdata )` Your count callback, which returns the number of items in the menu. The `userdata` is whatever you passed as the second argument to `cmenuCreate`. `itemstring = nameFn( userdata, item )` Your item name callback, which returns the string that should be displayed for the item. Example The following code fragments create and display a simple context menu. First, we'll create a data structure for our menu and define the callbacks.
       typedef struct st_MyMenuData {
          int    count;
          char **name;
       } MyMenuData;

       static char *itemname[] = {
          "New", "Load", "Save", "Copy", "Paste", NULL };

       MyMenuData menudata = { 5, itemname };

       int menuCount( MyMenuData *data )
       {
          return data->count;
       }

       int menuName( MyMenuData *data, int index )
       {
          if ( index >= 0 && index < data->count )
             return data->name[ index ];
          return NULL;
       }
Don't forget to initialize the global.
       #include <lwpanel.h>

       ContextMenuFuncs *cmenuf;

       cmenuf = global( LWCONTEXTMENU_GLOBAL, GFUSE_TRANSIENT );
       if ( !cmenuf ) return AFUNC_BADGLOBAL;
Create the menu. Typically you'll do this when you're creating the associated panel and its controls.
       LWContextMenuID menu;
       LWPanPopupDesc desc;

       desc.type    = LWT_POPUP;
       desc.width   = 200;
       desc.countFn = menuCount;
       desc.nameFn  = menuName;

       menu = cmenuf->cmenuCreate( &desc, menudata );
       if ( !menu ) goto MenuFail;
Display the context menu in response to some user action.
       int select, current;

       select = cmenuf->cmenuDeploy( menu, panel, current );
       if ( select != -1 ) {
          current = select;
          ...
When you're done with it, free the menu.
       cmenuf->cmenuDestroy( menu );