home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / X / mit / lib / Xaw / SimpleMenu.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-07-21  |  34.4 KB  |  1,268 lines
  1. /* $XConsortium: SimpleMenu.c,v 1.41 92/09/10 16:25:07 converse Exp $ */
  2.  
  3. /*
  4.  * Copyright 1989 Massachusetts Institute of Technology
  5.  *
  6.  * Permission to use, copy, modify, distribute, and sell this software and its
  7.  * documentation for any purpose is hereby granted without fee, provided that
  8.  * the above copyright notice appear in all copies and that both that
  9.  * copyright notice and this permission notice appear in supporting
  10.  * documentation, and that the name of M.I.T. not be used in advertising or
  11.  * publicity pertaining to distribution of the software without specific,
  12.  * written prior permission.  M.I.T. makes no representations about the
  13.  * suitability of this software for any purpose.  It is provided "as is"
  14.  * without express or implied warranty.
  15.  *
  16.  * M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
  17.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL M.I.T.
  18.  * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  19.  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  20.  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN 
  21.  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22.  */
  23.  
  24. /*
  25.  * SimpleMenu.c - Source code file for SimpleMenu widget.
  26.  *
  27.  * Date:    April 3, 1989
  28.  *
  29.  * By:      Chris D. Peterson
  30.  *          MIT X Consortium 
  31.  *          kit@expo.lcs.mit.edu
  32.  */
  33.  
  34. #include <stdio.h>
  35. #include <X11/IntrinsicP.h>
  36. #include <X11/StringDefs.h>
  37.  
  38. #include <X11/Xaw/XawInit.h>
  39. #include <X11/Xaw/SimpleMenP.h>
  40. #include <X11/Xaw/SmeBSB.h>
  41. #include <X11/Xaw/Cardinals.h>
  42.  
  43. #include <X11/Xmu/Initer.h>
  44. #include <X11/Xmu/CharSet.h>
  45.  
  46. #define streq(a, b)        ( strcmp((a), (b)) == 0 )
  47.  
  48. #define offset(field) XtOffsetOf(SimpleMenuRec, simple_menu.field)
  49.  
  50. static XtResource resources[] = { 
  51.  
  52. /*
  53.  * Label Resources.
  54.  */
  55.  
  56.   {XtNlabel,  XtCLabel, XtRString, sizeof(String),
  57.      offset(label_string), XtRString, NULL},
  58.   {XtNlabelClass,  XtCLabelClass, XtRPointer, sizeof(WidgetClass),
  59.      offset(label_class), XtRImmediate, (XtPointer) NULL},
  60.  
  61. /*
  62.  * Layout Resources.
  63.  */
  64.  
  65.   {XtNrowHeight,  XtCRowHeight, XtRDimension, sizeof(Dimension),
  66.      offset(row_height), XtRImmediate, (XtPointer) 0},
  67.   {XtNtopMargin,  XtCVerticalMargins, XtRDimension, sizeof(Dimension),
  68.      offset(top_margin), XtRImmediate, (XtPointer) 0},
  69.   {XtNbottomMargin,  XtCVerticalMargins, XtRDimension, sizeof(Dimension),
  70.      offset(bottom_margin), XtRImmediate, (XtPointer) 0},
  71.  
  72. /*
  73.  * Misc. Resources
  74.  */
  75.  
  76.   { XtNallowShellResize, XtCAllowShellResize, XtRBoolean, sizeof(Boolean),
  77.       XtOffsetOf(SimpleMenuRec, shell.allow_shell_resize),
  78.       XtRImmediate, (XtPointer) TRUE },
  79.   {XtNcursor, XtCCursor, XtRCursor, sizeof(Cursor),
  80.       offset(cursor), XtRImmediate, (XtPointer) None},
  81.   {XtNmenuOnScreen,  XtCMenuOnScreen, XtRBoolean, sizeof(Boolean),
  82.       offset(menu_on_screen), XtRImmediate, (XtPointer) TRUE},
  83.   {XtNpopupOnEntry,  XtCPopupOnEntry, XtRWidget, sizeof(Widget),
  84.       offset(popup_entry), XtRWidget, NULL},
  85.   {XtNbackingStore, XtCBackingStore, XtRBackingStore, sizeof (int),
  86.       offset(backing_store), 
  87.       XtRImmediate, (XtPointer) (Always + WhenMapped + NotUseful)},
  88. };  
  89. #undef offset
  90.  
  91. static char defaultTranslations[] =
  92.     "<EnterWindow>:     highlight()             \n\
  93.      <LeaveWindow>:     unhighlight()           \n\
  94.      <BtnMotion>:       highlight()             \n\
  95.      <BtnUp>:           MenuPopdown() notify() unhighlight()"; 
  96.  
  97. /*
  98.  * Semi Public function definitions. 
  99.  */
  100.  
  101. static void Redisplay(), Realize(), Resize(), ChangeManaged();
  102. static void Initialize(), ClassInitialize(), ClassPartInitialize();
  103. static Boolean SetValues(), SetValuesHook();
  104. static XtGeometryResult GeometryManager();
  105.  
  106. /*
  107.  * Action Routine Definitions
  108.  */
  109.  
  110. static void Highlight(), Unhighlight(), Notify(), PositionMenuAction();
  111.  
  112. /* 
  113.  * Private Function Definitions.
  114.  */
  115.  
  116. static void MakeSetValuesRequest(), CreateLabel(), Layout();
  117. static void AddPositionAction(), PositionMenu(), ChangeCursorOnGrab();
  118. static Dimension GetMenuWidth(), GetMenuHeight();
  119. static Widget FindMenu();
  120. static SmeObject GetEventEntry();
  121. static void MoveMenu();
  122.  
  123. static XtActionsRec actionsList[] =
  124. {
  125.   {"notify",            Notify},
  126.   {"highlight",         Highlight},
  127.   {"unhighlight",       Unhighlight},
  128. };
  129.  
  130. static CompositeClassExtensionRec extension_rec = {
  131.     /* next_extension */  NULL,
  132.     /* record_type */     NULLQUARK,
  133.     /* version */         XtCompositeExtensionVersion,
  134.     /* record_size */     sizeof(CompositeClassExtensionRec),
  135.     /* accepts_objects */ TRUE,
  136. };
  137.  
  138. #define superclass (&overrideShellClassRec)
  139.     
  140. SimpleMenuClassRec simpleMenuClassRec = {
  141.   {
  142.     /* superclass         */    (WidgetClass) superclass,
  143.     /* class_name         */    "SimpleMenu",
  144.     /* size               */    sizeof(SimpleMenuRec),
  145.     /* class_initialize   */    ClassInitialize,
  146.     /* class_part_initialize*/    ClassPartInitialize,
  147.     /* Class init'ed      */    FALSE,
  148.     /* initialize         */    Initialize,
  149.     /* initialize_hook    */    NULL,
  150.     /* realize            */    Realize,
  151.     /* actions            */    actionsList,
  152.     /* num_actions        */    XtNumber(actionsList),
  153.     /* resources          */    resources,
  154.     /* resource_count     */    XtNumber(resources),
  155.     /* xrm_class          */    NULLQUARK,
  156.     /* compress_motion    */    TRUE, 
  157.     /* compress_exposure  */    TRUE,
  158.     /* compress_enterleave*/     TRUE,
  159.     /* visible_interest   */    FALSE,
  160.     /* destroy            */    NULL,
  161.     /* resize             */    Resize,
  162.     /* expose             */    Redisplay,
  163.     /* set_values         */    SetValues,
  164.     /* set_values_hook    */    SetValuesHook,
  165.     /* set_values_almost  */    XtInheritSetValuesAlmost,  
  166.     /* get_values_hook    */    NULL,            
  167.     /* accept_focus       */    NULL,
  168.     /* intrinsics version */    XtVersion,
  169.     /* callback offsets   */    NULL,
  170.     /* tm_table          */    defaultTranslations,
  171.     /* query_geometry      */    NULL,
  172.     /* display_accelerator*/    NULL,
  173.     /* extension      */    NULL
  174.   },{
  175.     /* geometry_manager   */    GeometryManager,
  176.     /* change_managed     */    ChangeManaged,
  177.     /* insert_child      */    XtInheritInsertChild,
  178.     /* delete_child      */    XtInheritDeleteChild,
  179.     /* extension      */    NULL
  180.   },{
  181.     /* Shell extension      */    NULL
  182.   },{
  183.     /* Override extension */    NULL
  184.   },{
  185.     /* Simple Menu extension*/  NULL
  186.   }
  187. };
  188.  
  189. WidgetClass simpleMenuWidgetClass = (WidgetClass)&simpleMenuClassRec;
  190.  
  191. /************************************************************
  192.  *
  193.  * Semi-Public Functions.
  194.  *
  195.  ************************************************************/
  196.  
  197. /*      Function Name: ClassInitialize
  198.  *      Description: Class Initialize routine, called only once.
  199.  *      Arguments: none.
  200.  *      Returns: none.
  201.  */
  202.  
  203. static void
  204. ClassInitialize()
  205. {
  206.   XawInitializeWidgetSet();
  207.   XtAddConverter( XtRString, XtRBackingStore, XmuCvtStringToBackingStore,
  208.          NULL, 0 );
  209.   XmuAddInitializer( AddPositionAction, NULL);
  210. }
  211.  
  212. /*      Function Name: ClassInitialize
  213.  *      Description: Class Part Initialize routine, called for every
  214.  *                   subclass.  Makes sure that the subclasses pick up 
  215.  *                   the extension record.
  216.  *      Arguments: wc - the widget class of the subclass.
  217.  *      Returns: none.
  218.  */
  219.  
  220. static void
  221. ClassPartInitialize(wc)
  222. WidgetClass wc;
  223. {
  224.     SimpleMenuWidgetClass smwc = (SimpleMenuWidgetClass) wc;
  225.  
  226. /*
  227.  * Make sure that our subclass gets the extension rec too.
  228.  */
  229.  
  230.     extension_rec.next_extension = smwc->composite_class.extension;
  231.     smwc->composite_class.extension = (XtPointer) &extension_rec;
  232. }
  233.  
  234. /*      Function Name: Initialize
  235.  *      Description: Initializes the simple menu widget
  236.  *      Arguments: request - the widget requested by the argument list.
  237.  *                 new     - the new widget with both resource and non
  238.  *                           resource values.
  239.  *      Returns: none.
  240.  */
  241.  
  242. /* ARGSUSED */
  243. static void
  244. Initialize(request, new, args, num_args)
  245. Widget request, new;
  246. ArgList args;
  247. Cardinal *num_args;
  248. {
  249.   SimpleMenuWidget smw = (SimpleMenuWidget) new;
  250.  
  251.   XmuCallInitializers(XtWidgetToApplicationContext(new));
  252.  
  253.   if (smw->simple_menu.label_class == NULL) 
  254.       smw->simple_menu.label_class = smeBSBObjectClass;
  255.  
  256.   smw->simple_menu.label = NULL;
  257.   smw->simple_menu.entry_set = NULL;
  258.   smw->simple_menu.recursive_set_values = FALSE;
  259.  
  260.   if (smw->simple_menu.label_string != NULL)
  261.       CreateLabel(new);
  262.  
  263.   smw->simple_menu.menu_width = TRUE;
  264.  
  265.   if (smw->core.width == 0) {
  266.       smw->simple_menu.menu_width = FALSE;
  267.       smw->core.width = GetMenuWidth(new, NULL);
  268.   }
  269.  
  270.   smw->simple_menu.menu_height = TRUE;
  271.  
  272.   if (smw->core.height == 0) {
  273.       smw->simple_menu.menu_height = FALSE;
  274.       smw->core.height = GetMenuHeight(new);
  275.   }
  276.  
  277. /*
  278.  * Add a popup_callback routine for changing the cursor.
  279.  */
  280.   
  281.   XtAddCallback(new, XtNpopupCallback, ChangeCursorOnGrab, NULL);
  282. }
  283.  
  284. /*      Function Name: Redisplay
  285.  *      Description: Redisplays the contents of the widget.
  286.  *      Arguments: w - the simple menu widget.
  287.  *                 event - the X event that caused this redisplay.
  288.  *                 region - the region the needs to be repainted. 
  289.  *      Returns: none.
  290.  */
  291.  
  292. /* ARGSUSED */
  293. static void
  294. Redisplay(w, event, region)
  295. Widget w;
  296. XEvent * event;
  297. Region region;
  298. {
  299.     SimpleMenuWidget smw = (SimpleMenuWidget) w;
  300.     SmeObject * entry;
  301.     SmeObjectClass class;
  302.  
  303.     if (region == NULL)
  304.     XClearWindow(XtDisplay(w), XtWindow(w));
  305.  
  306.     /*
  307.      * Check and Paint each of the entries - including the label.
  308.      */
  309.  
  310.     ForAllChildren(smw, entry) {
  311.     if (!XtIsManaged ( (Widget) *entry)) continue;
  312.  
  313.     if (region != NULL) 
  314.         switch(XRectInRegion(region, (int) (*entry)->rectangle.x,
  315.                  (int) (*entry)->rectangle.y,
  316.                  (unsigned int) (*entry)->rectangle.width,
  317.                  (unsigned int) (*entry)->rectangle.height)) {
  318.         case RectangleIn:
  319.         case RectanglePart:
  320.         break;
  321.         default:
  322.         continue;
  323.         }
  324.     class = (SmeObjectClass) (*entry)->object.widget_class;
  325.  
  326.     if (class->rect_class.expose != NULL)
  327.         (class->rect_class.expose)( (Widget) *entry, NULL, NULL);
  328.     }
  329. }
  330.  
  331. /*      Function Name: Realize
  332.  *      Description: Realizes the widget.
  333.  *      Arguments: w - the simple menu widget.
  334.  *                 mask - value mask for the window to create.
  335.  *                 attrs - attributes for the window to create.
  336.  *      Returns: none
  337.  */
  338.  
  339. static void
  340. Realize(w, mask, attrs)
  341. Widget w;
  342. XtValueMask * mask;
  343. XSetWindowAttributes * attrs;
  344. {
  345.     SimpleMenuWidget smw = (SimpleMenuWidget) w;
  346.  
  347.     attrs->cursor = smw->simple_menu.cursor;
  348.     *mask |= CWCursor;
  349.     if ((smw->simple_menu.backing_store == Always) ||
  350.     (smw->simple_menu.backing_store == NotUseful) ||
  351.     (smw->simple_menu.backing_store == WhenMapped) ) {
  352.     *mask |= CWBackingStore;
  353.     attrs->backing_store = smw->simple_menu.backing_store;
  354.     }
  355.     else
  356.     *mask &= ~CWBackingStore;
  357.  
  358.     (*superclass->core_class.realize) (w, mask, attrs);
  359. }
  360.  
  361. /*      Function Name: Resize
  362.  *      Description: Handle the menu being resized bigger.
  363.  *      Arguments: w - the simple menu widget.
  364.  *      Returns: none.
  365.  */
  366.  
  367. static void
  368. Resize(w)
  369. Widget w;
  370. {
  371.     SimpleMenuWidget smw = (SimpleMenuWidget) w;
  372.     SmeObject * entry;
  373.  
  374.     if ( !XtIsRealized(w) ) return;
  375.  
  376.     ForAllChildren(smw, entry)     /* reset width of all entries. */
  377.     if (XtIsManaged( (Widget) *entry))
  378.         (*entry)->rectangle.width = smw->core.width;
  379.     
  380.     Redisplay(w, (XEvent *) NULL, (Region) NULL);
  381. }
  382.  
  383. /*      Function Name: SetValues
  384.  *      Description: Relayout the menu when one of the resources is changed.
  385.  *      Arguments: current - current state of the widget.
  386.  *                 request - what was requested.
  387.  *                 new - what the widget will become.
  388.  *      Returns: none
  389.  */
  390.  
  391. /* ARGSUSED */
  392. static Boolean
  393. SetValues(current, request, new, args, num_args)
  394. Widget current, request, new;
  395. ArgList args;
  396. Cardinal *num_args;
  397. {
  398.     SimpleMenuWidget smw_old = (SimpleMenuWidget) current;
  399.     SimpleMenuWidget smw_new = (SimpleMenuWidget) new;
  400.     Boolean ret_val = FALSE, layout = FALSE;
  401.     
  402.     if (!XtIsRealized(current)) return(FALSE);
  403.     
  404.     if (!smw_new->simple_menu.recursive_set_values) {
  405.     if (smw_new->core.width != smw_old->core.width) {
  406.         smw_new->simple_menu.menu_width = (smw_new->core.width != 0);
  407.         layout = TRUE;
  408.     }
  409.     if (smw_new->core.height != smw_old->core.height) {
  410.         smw_new->simple_menu.menu_height = (smw_new->core.height != 0);
  411.         layout = TRUE;
  412.     }
  413.     }
  414.  
  415.     if (smw_old->simple_menu.cursor != smw_new->simple_menu.cursor)
  416.     XDefineCursor(XtDisplay(new),
  417.               XtWindow(new), smw_new->simple_menu.cursor);
  418.     
  419.     if (smw_old->simple_menu.label_string !=smw_new->simple_menu.label_string) 
  420.     if (smw_new->simple_menu.label_string == NULL)         /* Destroy. */
  421.         XtDestroyWidget((Widget) smw_old->simple_menu.label);
  422.     else if (smw_old->simple_menu.label_string == NULL)    /* Create. */
  423.         CreateLabel(new);
  424.     else {                                                 /* Change. */
  425.         Arg arglist[1];
  426.         
  427.         XtSetArg(arglist[0], XtNlabel, smw_new->simple_menu.label_string);
  428.         XtSetValues((Widget) smw_new->simple_menu.label, arglist, ONE);
  429.     }
  430.     
  431.     if (smw_old->simple_menu.label_class != smw_new->simple_menu.label_class)
  432.     XtAppWarning(XtWidgetToApplicationContext(new),
  433.              "No Dynamic class change of the SimpleMenu Label.");
  434.     
  435.     if ((smw_old->simple_menu.top_margin != smw_new->simple_menu.top_margin) ||
  436.     (smw_old->simple_menu.bottom_margin != 
  437.      smw_new->simple_menu.bottom_margin) /* filler.................  */ ) {
  438.     layout = TRUE;
  439.     ret_val = TRUE;
  440.     }
  441.  
  442.     if (layout)
  443.     Layout(new, NULL, NULL);
  444.  
  445.     return(ret_val);
  446. }
  447.  
  448. /*      Function Name: SetValuesHook
  449.  *      Description: To handle a special case, this is passed the
  450.  *                   actual arguments.
  451.  *      Arguments: w - the menu widget.
  452.  *                 arglist - the argument list passed to XtSetValues.
  453.  *                 num_args - the number of args.
  454.  *      Returns: none
  455.  */
  456.  
  457. /* 
  458.  * If the user actually passed a width and height to the widget
  459.  * then this MUST be used, rather than our newly calculated width and
  460.  * height.
  461.  */
  462.  
  463. static Boolean
  464. SetValuesHook(w, arglist, num_args)
  465. Widget w;
  466. ArgList arglist;
  467. Cardinal *num_args;
  468. {
  469.     register Cardinal i;
  470.     Dimension width, height;
  471.     
  472.     width = w->core.width;
  473.     height = w->core.height;
  474.     
  475.     for ( i = 0 ; i < *num_args ; i++) {
  476.     if ( streq(arglist[i].name, XtNwidth) )
  477.         width = (Dimension) arglist[i].value;
  478.     if ( streq(arglist[i].name, XtNheight) )
  479.         height = (Dimension) arglist[i].value;
  480.     }
  481.  
  482.     if ((width != w->core.width) || (height != w->core.height))
  483.     MakeSetValuesRequest(w, width, height);
  484.     return(FALSE);
  485. }
  486.  
  487. /************************************************************
  488.  *
  489.  * Geometry Management routines.
  490.  *
  491.  ************************************************************/
  492.  
  493. /*    Function Name: GeometryManager
  494.  *    Description: This is the SimpleMenu Widget's Geometry Manager.
  495.  *    Arguments: w - the Menu Entry making the request.
  496.  *                 request - requested new geometry.
  497.  *                 reply - the allowed geometry.
  498.  *    Returns: XtGeometry{Yes, No, Almost}.
  499.  */
  500.  
  501. static XtGeometryResult
  502. GeometryManager(w, request, reply)
  503. Widget w;
  504. XtWidgetGeometry * request, * reply;
  505. {
  506.     SimpleMenuWidget smw = (SimpleMenuWidget) XtParent(w);
  507.     SmeObject entry = (SmeObject) w;
  508.     XtGeometryMask mode = request->request_mode;
  509.     XtGeometryResult answer;
  510.     Dimension old_height, old_width;
  511.  
  512.     if ( !(mode & CWWidth) && !(mode & CWHeight) )
  513.     return(XtGeometryNo);
  514.  
  515.     reply->width = request->width;
  516.     reply->height = request->height;
  517.  
  518.     old_width = entry->rectangle.width;
  519.     old_height = entry->rectangle.height;
  520.  
  521.     Layout(w, &(reply->width), &(reply->height) );
  522.  
  523. /*
  524.  * Since we are an override shell and have no parent there is no one to
  525.  * ask to see if this geom change is okay, so I am just going to assume
  526.  * we can do whatever we want.  If you subclass be very careful with this
  527.  * assumption, it could bite you.
  528.  *
  529.  * Chris D. Peterson - Sept. 1989.
  530.  */
  531.  
  532.     if ( (reply->width == request->width) &&
  533.      (reply->height == request->height) ) {
  534.  
  535.     if ( mode & XtCWQueryOnly ) { /* Actually perform the layout. */
  536.         entry->rectangle.width = old_width;
  537.         entry->rectangle.height = old_height;    
  538.     }
  539.     else {
  540.         Layout(( Widget) smw, NULL, NULL);
  541.     }
  542.     answer = XtGeometryDone;
  543.     }
  544.     else {
  545.     entry->rectangle.width = old_width;
  546.     entry->rectangle.height = old_height;    
  547.  
  548.     if ( ((reply->width == request->width) && !(mode & CWHeight)) ||
  549.           ((reply->height == request->height) && !(mode & CWWidth)) ||
  550.           ((reply->width == request->width) && 
  551.            (reply->height == request->height)) )
  552.         answer = XtGeometryNo;
  553.     else {
  554.         answer = XtGeometryAlmost;
  555.         reply->request_mode = 0;
  556.         if (reply->width != request->width)
  557.         reply->request_mode |= CWWidth;
  558.         if (reply->height != request->height)
  559.         reply->request_mode |= CWHeight;
  560.     }
  561.     }
  562.     return(answer);
  563. }
  564.  
  565. /*    Function Name: ChangeManaged
  566.  *    Description: called whenever a new child is managed.
  567.  *    Arguments: w - the simple menu widget.
  568.  *    Returns: none.
  569.  */
  570.  
  571. static void
  572. ChangeManaged(w)
  573. Widget w;
  574. {
  575.     Layout(w, NULL, NULL);
  576. }
  577.  
  578. /************************************************************
  579.  *
  580.  * Global Action Routines.
  581.  * 
  582.  * These actions routines will be added to the application's
  583.  * global action list. 
  584.  * 
  585.  ************************************************************/
  586.  
  587. /*      Function Name: PositionMenuAction
  588.  *      Description: Positions the simple menu widget.
  589.  *      Arguments: w - a widget (no the simple menu widget.)
  590.  *                 event - the event that caused this action.
  591.  *                 params, num_params - parameters passed to the routine.
  592.  *                                      we expect the name of the menu here.
  593.  *      Returns: none
  594.  */
  595.  
  596. /* ARGSUSED */
  597. static void
  598. PositionMenuAction(w, event, params, num_params)
  599. Widget w;
  600. XEvent * event;
  601. String * params;
  602. Cardinal * num_params;
  603. { 
  604.   Widget menu;
  605.   XPoint loc;
  606.  
  607.   if (*num_params != 1) {
  608.     char error_buf[BUFSIZ];
  609.     sprintf(error_buf, "%s %s",
  610.         "Xaw - SimpleMenuWidget: position menu action expects only one",
  611.         "parameter which is the name of the menu.");
  612.     XtAppWarning(XtWidgetToApplicationContext(w), error_buf);
  613.     return;
  614.   }
  615.  
  616.   if ( (menu = FindMenu(w, params[0])) == NULL) {
  617.     char error_buf[BUFSIZ];
  618.     sprintf(error_buf, "%s '%s'",
  619.         "Xaw - SimpleMenuWidget: could not find menu named: ", params[0]);
  620.     XtAppWarning(XtWidgetToApplicationContext(w), error_buf);
  621.     return;
  622.   }
  623.   
  624.   switch (event->type) {
  625.   case ButtonPress:
  626.   case ButtonRelease:
  627.     loc.x = event->xbutton.x_root;
  628.     loc.y = event->xbutton.y_root;
  629.     PositionMenu(menu, &loc);
  630.     break;
  631.   case EnterNotify:
  632.   case LeaveNotify:
  633.     loc.x = event->xcrossing.x_root;
  634.     loc.y = event->xcrossing.y_root;
  635.     PositionMenu(menu, &loc);
  636.     break;
  637.   case MotionNotify:
  638.     loc.x = event->xmotion.x_root;
  639.     loc.y = event->xmotion.y_root;
  640.     PositionMenu(menu, &loc);
  641.     break;
  642.   default:
  643.     PositionMenu(menu, NULL);
  644.     break;
  645.   }
  646. }  
  647.  
  648. /************************************************************
  649.  *
  650.  * Widget Action Routines.
  651.  * 
  652.  ************************************************************/
  653.  
  654. /*      Function Name: Unhighlight
  655.  *      Description: Unhighlights current entry.
  656.  *      Arguments: w - the simple menu widget.
  657.  *                 event - the event that caused this action.
  658.  *                 params, num_params - ** NOT USED **
  659.  *      Returns: none
  660.  */
  661.  
  662. /* ARGSUSED */
  663. static void
  664. Unhighlight(w, event, params, num_params)
  665. Widget w;
  666. XEvent * event;
  667. String * params;
  668. Cardinal * num_params;
  669. { 
  670.     SimpleMenuWidget smw = (SimpleMenuWidget) w;
  671.     SmeObject entry = smw->simple_menu.entry_set;
  672.     SmeObjectClass class;
  673.  
  674.     if ( entry == NULL) return;
  675.  
  676.     smw->simple_menu.entry_set = NULL;
  677.     class = (SmeObjectClass) entry->object.widget_class;
  678.     (class->sme_class.unhighlight) ( (Widget) entry);
  679. }
  680.  
  681. /*      Function Name: Highlight
  682.  *      Description: Highlights current entry.
  683.  *      Arguments: w - the simple menu widget.
  684.  *                 event - the event that caused this action.
  685.  *                 params, num_params - ** NOT USED **
  686.  *      Returns: none
  687.  */
  688.  
  689. /* ARGSUSED */
  690. static void
  691. Highlight(w, event, params, num_params)
  692. Widget w;
  693. XEvent * event;
  694. String * params;
  695. Cardinal * num_params;
  696. {
  697.     SimpleMenuWidget smw = (SimpleMenuWidget) w;
  698.     SmeObject entry;
  699.     SmeObjectClass class;
  700.     
  701.     if ( !XtIsSensitive(w) ) return;
  702.     
  703.     entry = GetEventEntry(w, event);
  704.  
  705.     if (entry == smw->simple_menu.entry_set) return;
  706.  
  707.     Unhighlight(w, event, params, num_params);  
  708.  
  709.     if (entry == NULL) return;
  710.  
  711.     if ( !XtIsSensitive( (Widget) entry)) {
  712.     smw->simple_menu.entry_set = NULL;
  713.     return;
  714.     }
  715.  
  716.     smw->simple_menu.entry_set = entry;
  717.     class = (SmeObjectClass) entry->object.widget_class;
  718.  
  719.     (class->sme_class.highlight) ( (Widget) entry);
  720. }
  721.  
  722. /*      Function Name: Notify
  723.  *      Description: Notify user of current entry.
  724.  *      Arguments: w - the simple menu widget.
  725.  *                 event - the event that caused this action.
  726.  *                 params, num_params - ** NOT USED **
  727.  *      Returns: none
  728.  */
  729.  
  730. /* ARGSUSED */
  731. static void
  732. Notify(w, event, params, num_params)
  733. Widget w;
  734. XEvent * event;
  735. String * params;
  736. Cardinal * num_params;
  737. {
  738.     SimpleMenuWidget smw = (SimpleMenuWidget) w;
  739.     SmeObject entry = smw->simple_menu.entry_set;
  740.     SmeObjectClass class;
  741.     
  742.     if ( (entry == NULL) || !XtIsSensitive((Widget) entry) ) return;
  743.  
  744.     class = (SmeObjectClass) entry->object.widget_class;
  745.     (class->sme_class.notify)( (Widget) entry );
  746. }
  747.  
  748. /************************************************************
  749.  *
  750.  * Public Functions.
  751.  *
  752.  ************************************************************/
  753.  
  754. /*    Function Name: XawSimpleMenuAddGlobalActions
  755.  *    Description: adds the global actions to the simple menu widget.
  756.  *    Arguments: app_con - the appcontext.
  757.  *    Returns: none.
  758.  */
  759.  
  760. void
  761. #if NeedFunctionPrototypes
  762. XawSimpleMenuAddGlobalActions(XtAppContext app_con)
  763. #else
  764. XawSimpleMenuAddGlobalActions(app_con)
  765. XtAppContext app_con;
  766. #endif
  767. {
  768.     XtInitializeWidgetClass(simpleMenuWidgetClass);
  769.     XmuCallInitializers( app_con );
  770. } 
  771.  
  772.  
  773. /*    Function Name: XawSimpleMenuGetActiveEntry
  774.  *    Description: Gets the currently active (set) entry.
  775.  *    Arguments: w - the smw widget.
  776.  *    Returns: the currently set entry or NULL if none is set.
  777.  */
  778.  
  779. Widget
  780. #if NeedFunctionPrototypes
  781. XawSimpleMenuGetActiveEntry(Widget w)
  782. #else
  783. XawSimpleMenuGetActiveEntry(w)
  784. Widget w;
  785. #endif
  786. {
  787.     SimpleMenuWidget smw = (SimpleMenuWidget) w;
  788.  
  789.     return( (Widget) smw->simple_menu.entry_set);
  790. } 
  791.  
  792. /*    Function Name: XawSimpleMenuClearActiveEntry
  793.  *    Description: Unsets the currently active (set) entry.
  794.  *    Arguments: w - the smw widget.
  795.  *    Returns: none.
  796.  */
  797.  
  798. void
  799. #if NeedFunctionPrototypes
  800. XawSimpleMenuClearActiveEntry(Widget w)
  801. #else
  802. XawSimpleMenuClearActiveEntry(w)
  803. Widget w;
  804. #endif
  805. {
  806.     SimpleMenuWidget smw = (SimpleMenuWidget) w;
  807.  
  808.     smw->simple_menu.entry_set = NULL;
  809. } 
  810.  
  811. /************************************************************
  812.  *
  813.  * Private Functions.
  814.  *
  815.  ************************************************************/
  816.  
  817. /*    Function Name: CreateLabel
  818.  *    Description: Creates a the menu label.
  819.  *    Arguments: w - the smw widget.
  820.  *    Returns: none.
  821.  * 
  822.  * Creates the label object and makes sure it is the first child in
  823.  * in the list.
  824.  */
  825.  
  826. static void
  827. CreateLabel(w)
  828. Widget w;
  829. {
  830.     SimpleMenuWidget smw = (SimpleMenuWidget) w;
  831.     register Widget * child, * next_child;
  832.     register int i;
  833.     Arg args[2];
  834.  
  835.     if ( (smw->simple_menu.label_string == NULL) ||
  836.      (smw->simple_menu.label != NULL) ) {
  837.     char error_buf[BUFSIZ];
  838.  
  839.     sprintf(error_buf, "Xaw Simple Menu Widget: %s or %s, %s",
  840.         "label string is NULL", "label already exists", 
  841.         "no label is being created.");
  842.     XtAppWarning(XtWidgetToApplicationContext(w), error_buf);
  843.     return;
  844.     }
  845.  
  846.     XtSetArg(args[0], XtNlabel, smw->simple_menu.label_string);
  847.     XtSetArg(args[1], XtNjustify, XtJustifyCenter);
  848.     smw->simple_menu.label = (SmeObject) 
  849.                           XtCreateManagedWidget("menuLabel", 
  850.                         smw->simple_menu.label_class, w,
  851.                         args, TWO);
  852.  
  853.     next_child = NULL;
  854.     for (child = smw->composite.children + smw->composite.num_children,
  855.      i = smw->composite.num_children ; i > 0 ; i--, child--) {
  856.     if (next_child != NULL)
  857.         *next_child = *child;
  858.     next_child = child;
  859.     }
  860.     *child = (Widget) smw->simple_menu.label;
  861. }
  862.  
  863. /*    Function Name: Layout
  864.  *    Description: lays the menu entries out all nice and neat.
  865.  *    Arguments: w - See below (+++)
  866.  *                 width_ret, height_ret - The returned width and 
  867.  *                                         height values.
  868.  *    Returns: none.
  869.  *
  870.  * if width == NULL || height == NULL then it assumes the you do not care
  871.  * about the return values, and just want a relayout.
  872.  *
  873.  * if this is not the case then it will set width_ret and height_ret
  874.  * to be width and height that the child would get if it were layed out
  875.  * at this time.
  876.  *
  877.  * +++ "w" can be the simple menu widget or any of its object children.
  878.  */
  879.  
  880. static void
  881. Layout(w, width_ret, height_ret)
  882. Widget w;
  883. Dimension *width_ret, *height_ret;
  884. {
  885.     SmeObject current_entry, *entry;
  886.     SimpleMenuWidget smw;
  887.     Dimension width, height;
  888.     Boolean do_layout = ((height_ret == NULL) || (width_ret == NULL));
  889.     Boolean allow_change_size;
  890.     height = 0;
  891.  
  892.     if ( XtIsSubclass(w, simpleMenuWidgetClass) ) {
  893.     smw = (SimpleMenuWidget) w;
  894.     current_entry = NULL;
  895.     }
  896.     else {
  897.     smw = (SimpleMenuWidget) XtParent(w);
  898.     current_entry = (SmeObject) w;
  899.     }
  900.  
  901.     allow_change_size = (!XtIsRealized((Widget)smw) ||
  902.              (smw->shell.allow_shell_resize));
  903.  
  904.     if ( smw->simple_menu.menu_height )
  905.     height = smw->core.height;
  906.     else
  907.     if (do_layout) {
  908.         height = smw->simple_menu.top_margin;
  909.         ForAllChildren(smw, entry) {
  910.         if (!XtIsManaged( (Widget) *entry)) continue;
  911.  
  912.         if ( (smw->simple_menu.row_height != 0) && 
  913.             (*entry != smw->simple_menu.label) ) 
  914.             (*entry)->rectangle.height = smw->simple_menu.row_height;
  915.         
  916.         (*entry)->rectangle.y = height;
  917.         (*entry)->rectangle.x = 0;
  918.         height += (*entry)->rectangle.height;
  919.         }
  920.         height += smw->simple_menu.bottom_margin;
  921.     }
  922.     else {
  923.         if ((smw->simple_menu.row_height != 0) && 
  924.         (current_entry != smw->simple_menu.label) )
  925.         height = smw->simple_menu.row_height;
  926.     }
  927.     
  928.     if (smw->simple_menu.menu_width)
  929.     width = smw->core.width;
  930.     else if ( allow_change_size )
  931.     width = GetMenuWidth((Widget) smw, (Widget) current_entry);
  932.     else
  933.     width = smw->core.width;
  934.  
  935.     if (do_layout) {
  936.     ForAllChildren(smw, entry)
  937.         if (XtIsManaged( (Widget) *entry)) 
  938.         (*entry)->rectangle.width = width;
  939.  
  940.     if (allow_change_size)
  941.         MakeSetValuesRequest((Widget) smw, width, height);
  942.     }
  943.     else {
  944.     *width_ret = width;
  945.     if (height != 0)
  946.         *height_ret = height;
  947.     }
  948. }
  949.     
  950. /*    Function Name: AddPositionAction
  951.  *    Description: Adds the XawPositionSimpleMenu action to the global
  952.  *                   action list for this appcon.
  953.  *    Arguments: app_con - the application context for this app.
  954.  *                 data - NOT USED.
  955.  *    Returns: none.
  956.  */
  957.  
  958. /* ARGSUSED */
  959. static void
  960. AddPositionAction(app_con, data)
  961. XtAppContext app_con;
  962. caddr_t data;
  963. {
  964.     static XtActionsRec pos_action[] = {
  965.         { "XawPositionSimpleMenu", PositionMenuAction },
  966.     };
  967.  
  968.     XtAppAddActions(app_con, pos_action, XtNumber(pos_action));
  969. }
  970.  
  971. /*    Function Name: FindMenu
  972.  *    Description: Find the menu give a name and reference widget.
  973.  *    Arguments: widget - reference widget.
  974.  *                 name   - the menu widget's name.
  975.  *    Returns: the menu widget or NULL.
  976.  */
  977.  
  978. static Widget 
  979. FindMenu(widget, name)
  980. Widget widget;
  981. String name;
  982. {
  983.     register Widget w, menu;
  984.     
  985.     for ( w = widget ; w != NULL ; w = XtParent(w) )
  986.     if ( (menu = XtNameToWidget(w, name)) != NULL )
  987.         return(menu);
  988.     return(NULL);
  989. }
  990.  
  991. /*    Function Name: PositionMenu
  992.  *    Description: Places the menu
  993.  *    Arguments: w - the simple menu widget.
  994.  *                 location - a pointer the the position or NULL.
  995.  *    Returns: none.
  996.  */
  997.  
  998. static void
  999. PositionMenu(w, location)
  1000. Widget w;
  1001. XPoint * location;
  1002. {
  1003.     SimpleMenuWidget smw = (SimpleMenuWidget) w;
  1004.     SmeObject entry;
  1005.     XPoint t_point;
  1006.     
  1007.     if (location == NULL) {
  1008.     Window junk1, junk2;
  1009.     int root_x, root_y, junkX, junkY;
  1010.     unsigned int junkM;
  1011.     
  1012.     location = &t_point;
  1013.     if (XQueryPointer(XtDisplay(w), XtWindow(w), &junk1, &junk2, 
  1014.               &root_x, &root_y, &junkX, &junkY, &junkM) == FALSE) {
  1015.         char error_buf[BUFSIZ];
  1016.         sprintf(error_buf, "%s %s", "Xaw - SimpleMenuWidget:",
  1017.             "Could not find location of mouse pointer");
  1018.         XtAppWarning(XtWidgetToApplicationContext(w), error_buf);
  1019.         return;
  1020.     }
  1021.     location->x = (short) root_x;
  1022.     location->y = (short) root_y;
  1023.     }
  1024.     
  1025.     /*
  1026.      * The width will not be correct unless it is realized.
  1027.      */
  1028.     
  1029.     XtRealizeWidget(w);
  1030.     
  1031.     location->x -= (Position) w->core.width/2;
  1032.     
  1033.     if (smw->simple_menu.popup_entry == NULL)
  1034.     entry = smw->simple_menu.label;
  1035.     else
  1036.     entry = smw->simple_menu.popup_entry;
  1037.  
  1038.     if (entry != NULL)
  1039.     location->y -= entry->rectangle.y + entry->rectangle.height/2;
  1040.  
  1041.     MoveMenu(w, (Position) location->x, (Position) location->y);
  1042. }
  1043.  
  1044. /*    Function Name: MoveMenu
  1045.  *    Description: Actually moves the menu, may force it to
  1046.  *                   to be fully visable if menu_on_screen is TRUE.
  1047.  *    Arguments: w - the simple menu widget.
  1048.  *                 x, y - the current location of the widget.
  1049.  *    Returns: none 
  1050.  */
  1051.  
  1052. static void
  1053. MoveMenu(w, x, y)
  1054. Widget w;
  1055. Position x, y;
  1056. {
  1057.     Arg arglist[2];
  1058.     Cardinal num_args = 0;
  1059.     SimpleMenuWidget smw = (SimpleMenuWidget) w;
  1060.     
  1061.     if (smw->simple_menu.menu_on_screen) {
  1062.     int width = w->core.width + 2 * w->core.border_width;
  1063.     int height = w->core.height + 2 * w->core.border_width;
  1064.     
  1065.     if (x >= 0) {
  1066.         int scr_width = WidthOfScreen(XtScreen(w));
  1067.         if (x + width > scr_width)
  1068.         x = scr_width - width;
  1069.     }
  1070.     if (x < 0) 
  1071.         x = 0;
  1072.     
  1073.     if (y >= 0) {
  1074.         int scr_height = HeightOfScreen(XtScreen(w));
  1075.         if (y + height > scr_height)
  1076.         y = scr_height - height;
  1077.     }
  1078.     if (y < 0)
  1079.         y = 0;
  1080.     }
  1081.     
  1082.     XtSetArg(arglist[num_args], XtNx, x); num_args++;
  1083.     XtSetArg(arglist[num_args], XtNy, y); num_args++;
  1084.     XtSetValues(w, arglist, num_args);
  1085. }
  1086.  
  1087. /*    Function Name: ChangeCursorOnGrab
  1088.  *    Description: Changes the cursor on the active grab to the one
  1089.  *                   specified in out resource list.
  1090.  *    Arguments: w - the widget.
  1091.  *                 junk, garbage - ** NOT USED **.
  1092.  *    Returns: None.
  1093.  */
  1094.  
  1095. /* ARGSUSED */
  1096. static void
  1097. ChangeCursorOnGrab(w, junk, garbage)
  1098. Widget w;
  1099. XtPointer junk, garbage;
  1100. {
  1101.     SimpleMenuWidget smw = (SimpleMenuWidget) w;
  1102.     
  1103.     /*
  1104.      * The event mask here is what is currently in the MIT implementation.
  1105.      * There really needs to be a way to get the value of the mask out
  1106.      * of the toolkit (CDP 5/26/89).
  1107.      */
  1108.     
  1109.     XChangeActivePointerGrab(XtDisplay(w), ButtonPressMask|ButtonReleaseMask,
  1110.                  smw->simple_menu.cursor, 
  1111.                  XtLastTimestampProcessed(XtDisplay(w)));
  1112. }
  1113.  
  1114. /*      Function Name: MakeSetValuesRequest
  1115.  *      Description: Makes a (possibly recursive) call to SetValues,
  1116.  *                   I take great pains to not go into an infinite loop.
  1117.  *      Arguments: w - the simple menu widget.
  1118.  *                 width, height - the size of the ask for.
  1119.  *      Returns: none
  1120.  */
  1121.  
  1122. static void
  1123. MakeSetValuesRequest(w, width, height)
  1124. Widget w;
  1125. Dimension width, height;
  1126. {
  1127.     SimpleMenuWidget smw = (SimpleMenuWidget) w;
  1128.     Arg arglist[2];
  1129.     Cardinal num_args = (Cardinal) 0;
  1130.     
  1131.     if ( !smw->simple_menu.recursive_set_values ) {
  1132.     if ( (smw->core.width != width) || (smw->core.height != height) ) {
  1133.         smw->simple_menu.recursive_set_values = TRUE;
  1134.         XtSetArg(arglist[num_args], XtNwidth, width);   num_args++;
  1135.         XtSetArg(arglist[num_args], XtNheight, height); num_args++;
  1136.         XtSetValues(w, arglist, num_args);
  1137.     }
  1138.     else if (XtIsRealized( (Widget) smw))
  1139.         Redisplay((Widget) smw, (XEvent *) NULL, (Region) NULL);
  1140.     }
  1141.     smw->simple_menu.recursive_set_values = FALSE;
  1142. }
  1143.  
  1144. /*      Function Name: GetMenuWidth
  1145.  *      Description: Sets the length of the widest entry in pixels.
  1146.  *      Arguments: w - the simple menu widget.
  1147.  *      Returns: width of menu.
  1148.  */
  1149.  
  1150. static Dimension
  1151. GetMenuWidth(w, w_ent)
  1152. Widget w, w_ent;
  1153. {
  1154.     SmeObject cur_entry = (SmeObject) w_ent;
  1155.     SimpleMenuWidget smw = (SimpleMenuWidget) w;
  1156.     Dimension width, widest = (Dimension) 0;
  1157.     SmeObject * entry;
  1158.     
  1159.     if ( smw->simple_menu.menu_width ) 
  1160.     return(smw->core.width);
  1161.  
  1162.     ForAllChildren(smw, entry) {
  1163.     XtWidgetGeometry preferred;
  1164.  
  1165.     if (!XtIsManaged( (Widget) *entry)) continue;
  1166.     
  1167.     if (*entry != cur_entry) {
  1168.         XtQueryGeometry((Widget) *entry, NULL, &preferred);
  1169.         
  1170.         if (preferred.request_mode & CWWidth)
  1171.         width = preferred.width;
  1172.         else
  1173.         width = (*entry)->rectangle.width;
  1174.     }
  1175.     else
  1176.         width = (*entry)->rectangle.width;
  1177.     
  1178.     if ( width > widest )
  1179.         widest = width;
  1180.     }
  1181.     
  1182.     return(widest);
  1183. }
  1184.  
  1185. /*      Function Name: GetMenuHeight
  1186.  *      Description: Sets the length of the widest entry in pixels.
  1187.  *      Arguments: w - the simple menu widget.
  1188.  *      Returns: width of menu.
  1189.  */
  1190.  
  1191. static Dimension
  1192. GetMenuHeight(w)
  1193. Widget w;
  1194. {
  1195.     SimpleMenuWidget smw = (SimpleMenuWidget) w;
  1196.     SmeObject * entry;
  1197.     Dimension height;
  1198.     
  1199.     if (smw->simple_menu.menu_height)
  1200.     return(smw->core.height);
  1201.  
  1202.     height = smw->simple_menu.top_margin + smw->simple_menu.bottom_margin;
  1203.     
  1204.     if (smw->simple_menu.row_height == 0) {
  1205.     ForAllChildren(smw, entry) 
  1206.         if (XtIsManaged ((Widget) *entry)) 
  1207.         height += (*entry)->rectangle.height;
  1208.     } else 
  1209.     height += smw->simple_menu.row_height * smw->composite.num_children;
  1210.     
  1211.     return(height);
  1212. }
  1213.  
  1214. /*      Function Name: GetEventEntry
  1215.  *      Description: Gets an entry given an event that has X and Y coords.
  1216.  *      Arguments: w - the simple menu widget.
  1217.  *                 event - the event.
  1218.  *      Returns: the entry that this point is in.
  1219.  */
  1220.  
  1221. static SmeObject
  1222. GetEventEntry(w, event)
  1223. Widget w;
  1224. XEvent * event;
  1225. {
  1226.     Position x_loc, y_loc;
  1227.     SimpleMenuWidget smw = (SimpleMenuWidget) w;
  1228.     SmeObject * entry;
  1229.     
  1230.     switch (event->type) {
  1231.     case MotionNotify:
  1232.     x_loc = event->xmotion.x;
  1233.     y_loc = event->xmotion.y;
  1234.     break;
  1235.     case EnterNotify:
  1236.     case LeaveNotify:
  1237.     x_loc = event->xcrossing.x;
  1238.     y_loc = event->xcrossing.y;
  1239.     break;
  1240.     case ButtonPress:
  1241.     case ButtonRelease:
  1242.     x_loc = event->xbutton.x;
  1243.     y_loc = event->xbutton.y;
  1244.     break;
  1245.     default:
  1246.     XtAppError(XtWidgetToApplicationContext(w),
  1247.            "Unknown event type in GetEventEntry().");
  1248.     break;
  1249.     }
  1250.     
  1251.     if ( (x_loc < 0) || (x_loc >= (int)smw->core.width) || (y_loc < 0) ||
  1252.     (y_loc >= (int)smw->core.height) )
  1253.     return(NULL);
  1254.     
  1255.     ForAllChildren(smw, entry) {
  1256.     if (!XtIsManaged ((Widget) *entry)) continue;
  1257.  
  1258.     if ( ((*entry)->rectangle.y < y_loc) &&
  1259.         ((*entry)->rectangle.y + (int) (*entry)->rectangle.height > y_loc) )
  1260.         if ( *entry == smw->simple_menu.label )
  1261.         return(NULL);    /* cannot select the label. */
  1262.         else
  1263.         return(*entry);
  1264.     }
  1265.     
  1266.     return(NULL);
  1267. }
  1268.