home *** CD-ROM | disk | FTP | other *** search
/ IRIX 6.3 Development Libraries / SGI IRIX 6.3 Development Libraries.iso / dist6.3 / ViewKit_dev.idb / usr / include / Vk / VkMenuItem.h.z / VkMenuItem.h
Encoding:
C/C++ Source or Header  |  1996-09-20  |  8.9 KB  |  384 lines
  1. ////////////////////////////////////////////////////////////////////////////////
  2. ///////   Copyright 1992, Silicon Graphics, Inc.  All Rights Reserved.   ///////
  3. //                                                                            //
  4. // This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;     //
  5. // the contents of this file may not be disclosed to third parties, copied    //
  6. // or duplicated in any form, in whole or in part, without the prior written  //
  7. // permission of Silicon Graphics, Inc.                                       //
  8. //                                                                            //
  9. // RESTRICTED RIGHTS LEGEND:                                                  //
  10. // Use,duplication or disclosure by the Government is subject to restrictions //
  11. // as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data     //
  12. // and Computer Software clause at DFARS 252.227-7013, and/or in similar or   //
  13. // successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -    //
  14. // rights reserved under the Copyright Laws of the United States.             //
  15. //                                                                            //
  16. ////////////////////////////////////////////////////////////////////////////////
  17.  
  18.  
  19. // Classes for menu items in a VkMenu object.
  20.     
  21. #ifndef VKMENUITEM_H
  22. #define VKMENUITEM_H
  23.     
  24. #include <Vk/VkComponent.h>
  25.  
  26. class VkComponentList;
  27.  
  28. #define MAXWIDGETS 25
  29.  
  30.  
  31. enum  VkMenuItemType {
  32.     END,                     // Used to mark the end of a static menu structure definition
  33.     ACTION,              // A "normal" menu item - uses a pushbutton gadget
  34.     ACTIONWIDGET,        // Same as an action, but forces a widget to be used
  35.     SUBMENU,             // A cascading submenu
  36.     RADIOSUBMENU,        // Same as above, but forced to act as a radio-style pane
  37.     SEPARATOR,           // A separator gadget
  38.     LABEL,               // A label gadget
  39.     TOGGLE,              // A two-state toggle button gadget
  40.     OPTION,              // An XmOption Menu
  41.     POPUP,               // a popup pane
  42.     BAR,                 // a menu bar
  43.         CONFIRMFIRSTACTION,  // An action that will not be executed unless user confirms first
  44.     OBJECT,              // A user-defined subclass of VkMenuActionObject
  45.     STUB                 // Used internally to support undo of arbirtrary callbacks
  46.     };
  47.  
  48.  
  49. class VkMenuItem : public VkComponent {
  50.     
  51.     friend  class VkMenu;
  52.     friend  class VkMenuBar;
  53.     friend  class VkPopupMenu;
  54.     friend  class VkOptionMenu;
  55.     friend  class VkSubMenu;
  56.  
  57.  public:
  58.  
  59.     ~VkMenuItem();
  60.     
  61.     virtual void setLabel(const char *);
  62.     char *getLabel();
  63.     
  64.     void setPosition(int );
  65.  
  66.     void activate();
  67.     void deactivate();
  68.     int remove();
  69.     void show();
  70.     void show(Widget);
  71.     void hide();
  72.  
  73.     virtual const char* className();
  74.     virtual Boolean isContainer();
  75.     virtual  VkMenuItemType menuType () = 0;
  76.     Widget baseWidget() const;
  77.  
  78.  
  79.  protected:
  80.  
  81.     int                _position;
  82.     Boolean            _isBuilt;
  83.     int                _sensitive;
  84.     class VkMenu      *_parentMenu;
  85.     char              *_label;
  86.  
  87.     Boolean         _isHidden;
  88.  
  89.     VkMenuItem();
  90.     VkMenuItem(const char * );
  91.  
  92.     static  Widget  _unmanagedWidgets[MAXWIDGETS];
  93.     static  int     _numUnmanagedWidgets;
  94.     static  void    manageAll();
  95.  
  96.     static VkComponentList *_workProcList;
  97.  
  98.     virtual void build(Widget);
  99. };
  100.  
  101.  
  102. class VkMenuAction : public VkMenuItem {
  103.  
  104.     friend  class VkMenu;
  105.     friend  class VkMenuBar;
  106.     friend  class VkPopupMenu;
  107.     friend  class VkOptionMenu;
  108.     friend  class VkSubMenu;
  109.  
  110.   public:
  111.     
  112.     VkMenuAction(const char *name, XtCallbackProc func = NULL, XtPointer clientData = NULL);
  113.     VkMenuAction(const char *, XtCallbackProc, XtCallbackProc, XtPointer clientData = NULL);
  114.     ~VkMenuAction();
  115.  
  116.     virtual void undo();
  117.  
  118.     Boolean hasUndo() { return (_undoCallback != NULL); }
  119.     virtual VkMenuItemType menuType ();
  120.     virtual const char* className();
  121.  
  122.   protected:
  123.  
  124.     XtCallbackProc  _undoCallback;
  125.     XtCallbackProc  _func;       
  126.     void           *_data;           
  127.  
  128.     virtual void build(Widget);
  129. };
  130.  
  131. class VkMenuConfirmFirstAction : public VkMenuAction {
  132.  
  133.     friend  class VkMenu;
  134.     friend  class VkMenuBar;
  135.     friend  class VkPopupMenu;
  136.     friend  class VkOptionMenu;
  137.     friend  class VkSubMenu;
  138.  
  139.   public:
  140.     
  141.     VkMenuConfirmFirstAction(const char *name, XtCallbackProc func = NULL, XtPointer clientData = NULL);
  142.     ~VkMenuConfirmFirstAction();
  143.     virtual VkMenuItemType menuType ();
  144.     virtual const char* className();
  145.  
  146.   protected:
  147.  
  148.     virtual void build(Widget);
  149.  
  150.  
  151.   private:
  152.  
  153.      static void actionCallback(Widget, XtPointer, XtPointer);
  154.     
  155. };
  156.  
  157.  
  158. class VkMenuActionObject : public VkMenuAction {
  159.  
  160.     friend  class VkMenu;
  161.     friend  class VkMenuBar;
  162.     friend  class VkPopupMenu;
  163.     friend  class VkOptionMenu;
  164.     friend  class VkSubMenu;
  165.  
  166.  
  167.   public:
  168.     
  169.     VkMenuActionObject(const char *, void *clientData = NULL);
  170.     ~VkMenuActionObject();
  171.  
  172.     virtual VkMenuItemType menuType ();
  173.     virtual const char* className();
  174.  
  175.   protected:
  176.  
  177.     virtual void undoit(void *) = 0;
  178.     virtual void doit(void *) = 0;
  179.     void *_clientData;
  180.  
  181.   private:
  182.  
  183.     static void undoCallback(Widget, XtPointer, XtPointer);
  184.     static void doitCallback(Widget, XtPointer, XtPointer);
  185.     
  186. };
  187.  
  188.  
  189. class VkMenuActionStub : public VkMenuAction {
  190.  
  191.     friend  class VkMenu;
  192.     friend  class VkMenuBar;
  193.     friend  class VkPopupMenu;
  194.     friend  class VkOptionMenu;
  195.     friend  class VkSubMenu;
  196.  
  197.  
  198.   public:
  199.     
  200.     VkMenuActionStub(const char *name, XtCallbackProc func = NULL, XtPointer clientData = NULL);
  201.     ~VkMenuActionStub();
  202.  
  203.     virtual VkMenuItemType menuType ();
  204.     virtual const char* className();
  205.  
  206.   protected:
  207.  
  208.      virtual void build(Widget);
  209. };
  210.  
  211.  
  212.  
  213. class VkMenuActionWidget : public VkMenuAction {
  214.  
  215.     friend  class VkMenu;
  216.     friend  class VkMenuBar;
  217.     friend  class VkPopupMenu;
  218.     friend  class VkOptionMenu;
  219.     friend  class VkSubMenu;
  220.  
  221.   public:
  222.     
  223.     VkMenuActionWidget(const char *name, 
  224.                XtCallbackProc func = NULL, 
  225.                XtPointer clientData = NULL);
  226.  
  227.     VkMenuActionWidget(const char *, 
  228.                XtCallbackProc, 
  229.                XtCallbackProc func, 
  230.                XtPointer clientData = NULL);
  231.  
  232.     ~VkMenuActionWidget();
  233.     virtual  VkMenuItemType menuType ();
  234.     virtual const char* className();
  235.  
  236.   private:
  237.  
  238.     virtual void build(Widget);
  239. };
  240.  
  241.  
  242.  
  243.  
  244. class VkMenuLabel : public VkMenuItem {
  245.  
  246.     friend  class VkMenu;
  247.     friend  class VkMenuBar;
  248.     friend  class VkPopupMenu;
  249.     friend  class VkOptionMenu;
  250.     friend  class VkSubMenu;
  251.  
  252.   public:
  253.     
  254.     VkMenuLabel(const char *);
  255.     ~VkMenuLabel();
  256.     virtual  VkMenuItemType menuType ();
  257.     virtual const char* className();
  258.  
  259.   protected:
  260.  
  261.     virtual void build(Widget);
  262. };
  263.  
  264.  
  265. class VkMenuSeparator : public VkMenuLabel {
  266.  
  267.     friend  class VkMenu;
  268.     friend  class VkMenuBar;
  269.     friend  class VkPopupMenu;
  270.     friend  class VkOptionMenu;
  271.     friend  class VkSubMenu;
  272.  
  273.   public:
  274.     
  275.     VkMenuSeparator();
  276.     VkMenuSeparator(const char *name);    
  277.     ~VkMenuSeparator();
  278.     virtual VkMenuItemType menuType ();
  279.     virtual const char* className();
  280.  
  281.   protected:
  282.  
  283.     virtual void build(Widget);
  284.     
  285. };
  286.  
  287.  
  288. class VkMenuToggle : public VkMenuAction {
  289.  
  290.     friend  class VkMenu;
  291.     friend  class VkMenuBar;
  292.     friend  class VkPopupMenu;
  293.     friend  class VkOptionMenu;
  294.     friend  class VkSubMenu;
  295.  
  296.   public:
  297.  
  298.     VkMenuToggle(const char *, 
  299.          XtCallbackProc func = NULL, 
  300.          XtPointer clientData = NULL);
  301.  
  302.     VkMenuToggle(const char *, 
  303.          XtCallbackProc, XtCallbackProc, 
  304.          XtPointer clientData = NULL);
  305.  
  306.     ~VkMenuToggle();
  307.  
  308.     virtual  VkMenuItemType menuType ();
  309.     virtual const char* className();
  310.     void setVisualState(Boolean state);
  311.     void setStateAndNotify(Boolean);
  312.     Boolean getState();
  313.  
  314.   protected:
  315.  
  316.     int             _state;
  317.     virtual void build(Widget);
  318. };
  319.  
  320. ///////////////////////////////////////////////////////////////////
  321. // Undo support
  322. //
  323. ///////////////////////////////////////////////////////////////////
  324.  
  325. class VkComponentList;
  326. class VkAction;
  327.  
  328. class VkMenuUndoManager : public VkMenuAction {
  329.  
  330.     friend  class VkMenu;
  331.     friend  class VkMenuBar;
  332.     friend  class VkPopupMenu;
  333.     friend  class VkOptionMenu;
  334.     friend  class VkSubMenu;
  335.  
  336.   public:
  337.  
  338.     VkMenuUndoManager(const char *);
  339.     ~VkMenuUndoManager();
  340.  
  341.      void  reset();
  342.      void  add(VkMenuAction *);    
  343.      void  add(const char *name, XtCallbackProc undoCallback, XtPointer clientData);
  344.      void  multiLevel (Boolean flag) { _multiLevel = flag; }
  345.      VkComponentList *historyList() { return _commands; }
  346.      virtual const char* className();
  347.  
  348.   protected:
  349.  
  350.      VkComponentList *_commands;
  351.      virtual void undo();
  352.      void setUndoLabel();
  353.      virtual void build(Widget);
  354.  
  355.  
  356.   private:
  357.     
  358.     static void undoCallback(Widget, XtPointer, XtPointer);
  359.     XmString _labelString;
  360.     Boolean  _multiLevel;
  361.     Boolean  _undoMode;
  362.  
  363.     
  364. };
  365.  
  366. extern VkMenuUndoManager *getTheUndoManager();
  367.     
  368. #define theUndoManager getTheUndoManager()
  369.  
  370.  
  371. #endif
  372.  
  373.  
  374.  
  375.  
  376.  
  377.  
  378.  
  379.  
  380.  
  381.  
  382.  
  383.  
  384.