home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / yacl-012.zip / ui / menu.h < prev    next >
C/C++ Source or Header  |  1995-04-08  |  10KB  |  331 lines
  1.  
  2.  
  3. #ifndef _menu_h_ /* Mon Sep 20 21:20:32 1993 */
  4. #define _menu_h_
  5.  
  6.  
  7.  
  8.  
  9.  
  10. /*
  11.  *
  12.  *          Copyright (C) 1994, M. A. Sridhar
  13.  *  
  14.  *
  15.  *     This software is Copyright M. A. Sridhar, 1994. You are free
  16.  *     to copy, modify or distribute this software  as you see fit,
  17.  *     and to use  it  for  any  purpose, provided   this copyright
  18.  *     notice and the following   disclaimer are included  with all
  19.  *     copies.
  20.  *
  21.  *                        DISCLAIMER
  22.  *
  23.  *     The author makes no warranties, either expressed or implied,
  24.  *     with respect  to  this  software, its  quality, performance,
  25.  *     merchantability, or fitness for any particular purpose. This
  26.  *     software is distributed  AS IS.  The  user of this  software
  27.  *     assumes all risks  as to its quality  and performance. In no
  28.  *     event shall the author be liable for any direct, indirect or
  29.  *     consequential damages, even if the  author has been  advised
  30.  *     as to the possibility of such damages.
  31.  *
  32.  */
  33.  
  34.  
  35.  
  36.  
  37.  
  38. // A Menu  is thought of  as  a labeled tree,   each of whose  nodes is a
  39. // MenuItem object, and the label  of a given node  is the handle of  the
  40. // corresponding MenuItem object. Thus we require that  the labels of the
  41. // MenuItem objects are  all distinct. The  root of the  tree is  a dummy
  42. // node.  (This formulation allows direct use  of CL_Tree.) Each MenuItem
  43. // object is (derived  from) a  VisualObject,  and therefore supports  an
  44. // event-handling protocol. In particular, it  displays a picture in  its
  45. // view area, which most often is a simple text string, and it provides a
  46. // "highlighting" capability for what it displays.
  47. //
  48. // The    MenuItem responds to     the  GetFocus,  Select and   LoseFocus
  49. // events.  Its response to the GetFocus  event  (the WM_INITMENU message
  50. // under Windows)  is to  highlight  its view, and notifying  any clients
  51. // that might be interested in that event. Similarly, its response to the
  52. // LoseFocus event is to notify any clients interested in the event.  Its
  53. // response to  the Select event  depends on whether it is  a leaf in the
  54. // tree or not.  If it is not a leaf in the tree, it displays the submenu
  55. // associated with it.  If  it is a leaf,  it simply notifies any clients
  56. // interested in that event.
  57. //
  58. // Since every simple visual object must contain  a model, we use a string as
  59. // model for the  MenuItem. This model is the  value displayed by default
  60. // in  the MenuItem's  view. (Custom  MenuItem   objects that draw  fancy
  61. // graphics  in  their  view might   or might not   use  this string.) An
  62. // assignment to this model changes the picture drawn in the view.
  63. //
  64. // The  Menu class simply functions as  a container for MenuItem objects,
  65. // and provides convenience functions  for accessing MenuItems.
  66. //
  67. // The MenuBar and PopupMenu classes are derived from the Menu class, and
  68. // are simply  two different ways  of representing the "main" menu, i.e.,
  69. // the children of the root of the menu tree.
  70. //
  71. // The abstraction of the menu represented by the UI_Menu class is the
  72. // following. The Menu is thought of as a container for MenuItem
  73. // objects. Thus all the contained MenuItems must have
  74. // distinct Id's. Note that this view "linearizes" the traditional
  75. // tree-structured view of a menu in which the children of the root are the
  76. // main menu items, and their children are submenu items.
  77. //
  78. // The root uses an id of 0, so all menu items must have distinct id's that
  79. // are greater than 0.
  80.  
  81.  
  82. #if defined(__GNUC__)
  83. #pragma interface
  84. #endif
  85.  
  86. #include "base/tree.h"
  87. #include "base/clntset.h"
  88.  
  89. #include "ui/simple.h"
  90.  
  91.  
  92.  
  93.  
  94. class CL_EXPORT UI_MenuItem;
  95. class CL_EXPORT UI_PopupMenu;
  96. struct UI_MenuItemDescriptor;
  97. class CL_EXPORT UI_CompositeVObject;
  98.  
  99. class CL_EXPORT UI_Menu: public UI_VisualObject {
  100.  
  101. public:
  102.  
  103.     UI_MenuItem* operator[] (UI_ViewID id);
  104.     // Return a pointer to the menu item with the given id. The returned
  105.     // object remains owned by the Menu, and may not be destroyed by the
  106.     // caller. This method returns NULL if no such id exists in the menu.
  107.  
  108.  
  109.     bool Add (UI_ViewID id, const char* label,
  110.               UI_ViewID parent_id = 0, short rank = 32000);
  111.     // Add a new menu item, with view id {\tt id} and label {\tt label}, as
  112.     // a child of the item with id {\tt parent_id}. The new item is added
  113.     // immediately to the right of the child at position {\tt rank}.
  114.     // Specifying a rank that is too large causes the item to be added as
  115.     // the rightmost child; specifying -1 causes it to become the leftmost
  116.     // child.
  117.     //
  118.     // The method returns TRUE if the addition was successful, FALSE
  119.     // otherwise (e.g., a duplicate view id or an invalid parent id was
  120.     // specified).
  121.     
  122.     bool AddSeparator (UI_ViewID parent_id, short rank);
  123.     // Add a separator as a part of the sub-menu whose root is {\tt
  124.     // parent_id}. The value of {\tt rank} is as in the {\tt Add} method.
  125.  
  126.     bool Remove (UI_ViewID id);
  127.     // Remove the menu item with view id {\tt id}, along with all its
  128.     // descendants in the menu tree. Return TRUE if successful, FALSE if an
  129.     // invalid item was specified.
  130.  
  131.     UI_ViewID RootID () const;
  132.     // Return the view id of the dummy MenuItem at the root of the menu
  133.     // tree. This method is only needed for menu tree traversal.
  134.     
  135.     short ChildCount (UI_ViewID id) const;
  136.     // Return the number of children of the item with the given id. This
  137.     // method returns -1 if there is no MenuItem with the given id in the
  138.     // menu.
  139.  
  140.     UI_MenuItem* Child (UI_ViewID id, short i) const;
  141.     // Return a pointer to the child $i$ of the menu item with view id {\tt
  142.     // id}. The value $i$ must be between 0 and $n-1$, where $n$ is the
  143.     // number of children of
  144.     // the specified menu item. If this is not the case, or if there is no
  145.     // menu item with the given id, this method returns NULL.
  146.  
  147.     short Index (UI_ViewID id) const;
  148.     // Return the rank of the menu item with the given id among its
  149.     // siblings; for example, if it is the first child, this method returns
  150.     // 0. This method returns -1 if there is no menu item with the given id.
  151.     
  152.  
  153.     UI_WindowClass WindowClass () const;
  154.     
  155.     bool IsTabStop () const {return FALSE;};
  156.     // Return FALSE unconditionally, since menus cannot be tab stops.
  157.  
  158.     const char* ClassName     () const { return "UI_Menu";};
  159.  
  160. protected:
  161.  
  162.     UI_Menu  (UI_CompositeVObject* parent, UI_MenuItemDescriptor* item);
  163.  
  164.     ~UI_Menu ();
  165.  
  166.  
  167.     short _BuildMenuSubtree (UI_MenuItemDescriptor* items, UI_ViewID id);
  168.  
  169.     bool  _CreateMenuItemVisual (CL_IntegerTreeNode&);
  170.  
  171.     bool  MakeVisualElement () = 0;
  172.     
  173.     bool  HandleEvent (UI_Event* e);
  174.  
  175.     bool  DestroyVisualElement ();
  176.  
  177.     // Instance data:
  178.     
  179.     CL_IntegerTree _menuTree;
  180.     UI_MenuItem*   _focusItem;
  181.  
  182. #if defined(__MS_WINDOWS__) || defined(__OS2__)
  183. public:
  184.     void MoveFocusTo (UI_MenuItem* item);
  185.     // [Specific to MS-Windows and OS/2. Internal use only.]
  186.  
  187.     UI_MenuItem* Focus () const {return _focusItem;};
  188.     // [Specific to MS-Windows and OS/2. Internal use only.]
  189.  
  190.     
  191. #endif
  192.     
  193. };
  194.  
  195.  
  196. class CL_EXPORT UI_MenuItem: public UI_SimpleVObject {
  197.  
  198. public:
  199.     // Overridden inherited methods:
  200.  
  201.     bool Enable ();
  202.  
  203.     bool Disable ();
  204.     
  205.     bool IsTabStop () const {return FALSE;};
  206.     // Return FALSE unconditionally, since menus cannot be tab stops.
  207.  
  208.         
  209.     CL_Object& Model() {return _title;};
  210.     // Return reference to the string label.
  211.  
  212.     UI_Menu& Container () {return _container;};
  213.     // Return a reference to the menu that contains us.
  214.  
  215.     UI_ViewHandle ViewHandle () const;
  216.  
  217.     UI_WindowClass WindowClass () const;
  218.  
  219.     const char* ClassName() const { return "UI_MenuItem";}; 
  220.  
  221. protected:
  222.  
  223.     friend UI_Menu;
  224.     friend class UI_MenuBar;
  225.     friend class UI_PopupMenu;
  226.     UI_MenuItem (UI_Menu* container, const char* label, UI_ViewID id);
  227.  
  228.     ~UI_MenuItem();
  229.  
  230.     bool MakeVisualElement ();
  231.  
  232.     void _PrivateInitialize ();
  233.  
  234.     bool _TitleChanged (CL_Object&, long);
  235.     
  236.     bool DestroyVisualElement ();
  237.     
  238. #if defined(__X_MOTIF__)
  239.     void SetLabel ();
  240.  
  241. #endif
  242.     // 
  243.     // Instance variables
  244.     // 
  245.  
  246.  
  247.     UI_Menu&         _container;   // The menu object of which we are a
  248.                                    // part
  249.     
  250. private:
  251. #if defined(__MS_WINDOWS__)
  252.     void _SetState ();
  253.     
  254.     UI_ViewHandle    _parentHandle;
  255.  
  256. #elif defined(__OS2__)
  257.     UI_ViewHandle    _parentHandle;
  258.  
  259. #elif defined (__X_MOTIF__)
  260.  
  261.     struct _WidgetRec* _xitemw;
  262.     static void GetFocusCallback  (struct _WidgetRec*, void *, void *);
  263.  
  264.     static void LoseFocusCallback (struct _WidgetRec*, void *, void *);
  265.     
  266.     static void SelectionCallback (struct _WidgetRec*, void *, void *);
  267.     
  268. #endif
  269.  
  270. };
  271.  
  272.  
  273.  
  274.  
  275. #define UIMenu_Separator  "---"
  276.  
  277. struct UI_MenuItemDescriptor {
  278.     char*                  label;     // Set this field to UIMenu_Separator
  279.                                       // for a separator; the remaining fields
  280.                                       // are ignored for separators
  281.     UI_ViewID              id;
  282.     UI_MenuItemDescriptor* submenu;
  283. };
  284.  
  285.  
  286.  
  287.  
  288. class CL_EXPORT UI_MenuBar: public UI_Menu {
  289.  
  290. public:
  291.  
  292.     UI_MenuBar (UI_CompositeVObject* parent, UI_MenuItemDescriptor* item );
  293.     // The descriptor array {\tt item} must contain at least one
  294.     // item. Otherwise the results can be unpredictable.
  295.     
  296.     const char* ClassName() const { return "UI_MenuBar";};
  297.  
  298. protected:
  299.     bool MakeVisualElement ();
  300.  
  301. };
  302.  
  303.  
  304. class CL_EXPORT UI_PopupMenu: public UI_Menu {
  305.  
  306. public:
  307.  
  308.     UI_PopupMenu (UI_CompositeVObject* parent, UI_MenuItemDescriptor* item);
  309.     // The descriptor array {\tt item} must contain at least one
  310.     // item. Otherwise the results can be unpredictable.
  311.     
  312.  
  313.     ~UI_PopupMenu ();
  314.  
  315.     bool ShowAt (const UI_Point& p);
  316.     // Show the popup menu at the given point
  317.     
  318.     const char* ClassName () const { return "UI_PopupMenu";};
  319.  
  320.  
  321. protected:
  322.     bool MakeVisualElement ();
  323.  
  324. };
  325.  
  326.  
  327. #endif
  328.  
  329.  
  330.  
  331.