PMenu.h

//==============================================================================
// File:        PMenu.h
//
// Copyright (c) 2017, Phil Harvey, Queen's University
//==============================================================================
#ifndef __PMenu_h__
#define __PMenu_h__

#include <Xm/Xm.h>
#include <X11/keysym.h>

// menu item flags
#define MENU_TOGGLE     0x0100      // the item is a toggle button
#define MENU_RADIO      0x0200      // the item is a radio button
#define MENU_TOGGLE_ON  0x0400      // the toggle or radio button is turned on
#define MENU_DISABLED   0x0800      // the item is disabled
#define MENU_PROTECTED  0x1000      // the item is protected (permanently disabled)

class PMenuHandler {
public:
    virtual ~PMenuHandler() { }
    // execute a menu command
    virtual void    DoMenuCommand(int anID)                 { }
    // check/change the state of a menu item before the menu is selected
    virtual int     CheckMenuCommand(int anID, int flags)   { return flags; }
};

// menu item structure -- used to define menu items when creating new menus
struct MenuStruct {
    char          * name;           // menu item label (NULL for separator item)
    char            accelerator;    // accelerator character
    KeySym          mnemonic;       // mnemonic keysym
    int             id;             // menu command ID number (0 for no command)
    MenuStruct    * sub_menu;       // pointer to first sub-menu item (NULL for no sub-menu)
    int             n_sub_items;    // number of items in sub-menu (0 for no sub-menu)
    int             flags;          // menu item flag bits
};

class PMenu;

// menu list element -- used to store data for active menu items
struct MenuList {
    MenuList(PMenu *anOwner, MenuStruct *ms, PMenuHandler *aHandler);
    ~MenuList();
    
    PMenu         * owner;          // pointer to PMenu object that created this item
    int             id;             // menu command ID number (0 for no command)
    KeySym          accelerator;    // menu accelerator
    PMenuHandler  * menu_handler;   // pointer to object that handles menu commands
    int             flags;          // menu item flag bits
    Widget          button;         // button widget (never NULL, even for separator items)
    MenuList      * sub_menu;       // first item in sub-menu (NULL if no sub-menu)
    MenuList      * next;           // pointer to next item in menu (NULL if last item)
};


// class definition
class PMenu {
public:
    PMenu(Widget menu, MenuStruct *menuDef, int nitems, PMenuHandler *handler);
    ~PMenu();
    
    Widget              GetWidget()         { return mWidget;       }
    
    MenuList          * FindMenuItem(int id);
    
    void                AddMenu(MenuStruct *menuDef, int nitems, PMenuHandler *handler);
    void                AddMenuItem(MenuStruct *newItem, MenuList *subMenu=NULL,
                                    PMenuHandler *handler=NULL, int index=XmLAST_POSITION);
    void                RemoveMenuItem(MenuList *subMenu=NULL, int index=XmLAST_POSITION);
    
    int                 SelectItem(int id);
    void                SetToggle(int id, int on=TRUE);
    void                EnableItem(int id, int on=TRUE);
    void                ProtectItem(int id, int on=TRUE);
    void                SetLabel(int id, char *str);
    char *              GetLabel(int id);
    int                 DoAccelerator(KeySym ks);
    
    MenuList          * GetMenuList()       { return mMenuList; }
    
    static void         SelectItem(MenuList *ms);
    static int          GetToggle(MenuList *ms);
    static void         SetToggle(MenuList *ms, int on=TRUE);
    static void         EnableItem(MenuList *ms, int on=TRUE);
    static void         ProtectItem(MenuList *ms, int on=TRUE);
    static void         SetLabel(MenuList *ms, char *str);
    static char       * GetLabel(MenuList *ms);
    static void         SetEnabled(int *flagPt, int on=TRUE);
    static int          UpdateTogglePair(int *valpt);
    static int          IsSensitive(MenuList *ms);
    static MenuList   * GetCurMenuItem()    { return sCurMenuItem;      }
    static int          WasAccelerator()    { return sWasAccelerator;   }

private:
    MenuList          * CreateMenu(char *title,Widget menu,MenuStruct *menuDef,int nitems,
                                   PMenuHandler *handler, int index=XmLAST_POSITION);
    MenuList          * AddMenuItem(Widget menu, MenuList *ms, MenuStruct *newItem,
                                    PMenuHandler *handler, int index=XmLAST_POSITION);
    
    static MenuList   * FindMenuItem(int id, MenuList *menu);
    static int          DoAccelerator(KeySym ks, MenuList *menu);
    static void         DestroyMenu(MenuList *menu, int destroy_widgets);
    static void         VerifyAccelerators(MenuStruct *menuDef, int nitems);

    static void         MenuProc(Widget w, MenuList *ms, caddr_t call_data);
    static void         CascadeProc(Widget w, MenuList *ms, caddr_t call_data);
    
    Widget              mWidget;
    PMenuHandler      * mHandler;
    MenuList          * mMenuList;
    
    static MenuList   * sCurMenuItem;   // current menu item (only valid in menu handler)
    static int          sWasAccelerator;
};

#endif // __PMenu_h__