home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / X / mit / lib / Xaw / SimpleMenu.c.orig < prev    next >
Encoding:
Text File  |  1991-06-22  |  34.3 KB  |  1,264 lines
  1. /* $XConsortium: SimpleMenu.c,v 1.39 91/06/22 18:03:29 rws 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)
  245. Widget request, new;
  246. {
  247.   SimpleMenuWidget smw = (SimpleMenuWidget) new;
  248.  
  249.   XmuCallInitializers(XtWidgetToApplicationContext(new));
  250.  
  251.   if (smw->simple_menu.label_class == NULL) 
  252.       smw->simple_menu.label_class = smeBSBObjectClass;
  253.  
  254.   smw->simple_menu.label = NULL;
  255.   smw->simple_menu.entry_set = NULL;
  256.   smw->simple_menu.recursive_set_values = FALSE;
  257.  
  258.   if (smw->simple_menu.label_string != NULL)
  259.       CreateLabel(new);
  260.  
  261.   smw->simple_menu.menu_width = TRUE;
  262.  
  263.   if (smw->core.width == 0) {
  264.       smw->simple_menu.menu_width = FALSE;
  265.       smw->core.width = GetMenuWidth(new, NULL);
  266.   }
  267.  
  268.   smw->simple_menu.menu_height = TRUE;
  269.  
  270.   if (smw->core.height == 0) {
  271.       smw->simple_menu.menu_height = FALSE;
  272.       smw->core.height = GetMenuHeight(new);
  273.   }
  274.  
  275. /*
  276.  * Add a popup_callback routine for changing the cursor.
  277.  */
  278.   
  279.   XtAddCallback(new, XtNpopupCallback, ChangeCursorOnGrab, NULL);
  280. }
  281.  
  282. /*      Function Name: Redisplay
  283.  *      Description: Redisplays the contents of the widget.
  284.  *      Arguments: w - the simple menu widget.
  285.  *                 event - the X event that caused this redisplay.
  286.  *                 region - the region the needs to be repainted. 
  287.  *      Returns: none.
  288.  */
  289.  
  290. /* ARGSUSED */
  291. static void
  292. Redisplay(w, event, region)
  293. Widget w;
  294. XEvent * event;
  295. Region region;
  296. {
  297.     SimpleMenuWidget smw = (SimpleMenuWidget) w;
  298.     SmeObject * entry;
  299.     SmeObjectClass class;
  300.  
  301.     if (region == NULL)
  302.     XClearWindow(XtDisplay(w), XtWindow(w));
  303.  
  304.     /*
  305.      * Check and Paint each of the entries - including the label.
  306.      */
  307.  
  308.     ForAllChildren(smw, entry) {
  309.     if (!XtIsManaged ( (Widget) *entry)) continue;
  310.  
  311.     if (region != NULL) 
  312.         switch(XRectInRegion(region, (int) (*entry)->rectangle.x,
  313.                  (int) (*entry)->rectangle.y,
  314.                  (unsigned int) (*entry)->rectangle.width,
  315.                  (unsigned int) (*entry)->rectangle.height)) {
  316.         case RectangleIn:
  317.         case RectanglePart:
  318.         break;
  319.         default:
  320.         continue;
  321.         }
  322.     class = (SmeObjectClass) (*entry)->object.widget_class;
  323.  
  324.     if (class->rect_class.expose != NULL)
  325.         (class->rect_class.expose)( (Widget) *entry, NULL, NULL);
  326.     }
  327. }
  328.  
  329. /*      Function Name: Realize
  330.  *      Description: Realizes the widget.
  331.  *      Arguments: w - the simple menu widget.
  332.  *                 mask - value mask for the window to create.
  333.  *                 attrs - attributes for the window to create.
  334.  *      Returns: none
  335.  */
  336.  
  337. static void
  338. Realize(w, mask, attrs)
  339. Widget w;
  340. XtValueMask * mask;
  341. XSetWindowAttributes * attrs;
  342. {
  343.     SimpleMenuWidget smw = (SimpleMenuWidget) w;
  344.  
  345.     attrs->cursor = smw->simple_menu.cursor;
  346.     *mask |= CWCursor;
  347.     if ((smw->simple_menu.backing_store == Always) ||
  348.     (smw->simple_menu.backing_store == NotUseful) ||
  349.     (smw->simple_menu.backing_store == WhenMapped) ) {
  350.     *mask |= CWBackingStore;
  351.     attrs->backing_store = smw->simple_menu.backing_store;
  352.     }
  353.     else
  354.     *mask &= ~CWBackingStore;
  355.  
  356.     (*superclass->core_class.realize) (w, mask, attrs);
  357. }
  358.  
  359. /*      Function Name: Resize
  360.  *      Description: Handle the menu being resized bigger.
  361.  *      Arguments: w - the simple menu widget.
  362.  *      Returns: none.
  363.  */
  364.  
  365. static void
  366. Resize(w)
  367. Widget w;
  368. {
  369.     SimpleMenuWidget smw = (SimpleMenuWidget) w;
  370.     SmeObject * entry;
  371.  
  372.     if ( !XtIsRealized(w) ) return;
  373.  
  374.     ForAllChildren(smw, entry)     /* reset width of all entries. */
  375.     if (XtIsManaged( (Widget) *entry))
  376.         (*entry)->rectangle.width = smw->core.width;
  377.     
  378.     Redisplay(w, (XEvent *) NULL, (Region) NULL);
  379. }
  380.  
  381. /*      Function Name: SetValues
  382.  *      Description: Relayout the menu when one of the resources is changed.
  383.  *      Arguments: current - current state of the widget.
  384.  *                 request - what was requested.
  385.  *                 new - what the widget will become.
  386.  *      Returns: none
  387.  */
  388.  
  389. /* ARGSUSED */
  390. static Boolean
  391. SetValues(current, request, new)
  392. Widget current, request, new;
  393. {
  394.     SimpleMenuWidget smw_old = (SimpleMenuWidget) current;
  395.     SimpleMenuWidget smw_new = (SimpleMenuWidget) new;
  396.     Boolean ret_val = FALSE, layout = FALSE;
  397.     
  398.     if (!XtIsRealized(current)) return(FALSE);
  399.     
  400.     if (!smw_new->simple_menu.recursive_set_values) {
  401.     if (smw_new->core.width != smw_old->core.width) {
  402.         smw_new->simple_menu.menu_width = (smw_new->core.width != 0);
  403.         layout = TRUE;
  404.     }
  405.     if (smw_new->core.height != smw_old->core.height) {
  406.         smw_new->simple_menu.menu_height = (smw_new->core.height != 0);
  407.         layout = TRUE;
  408.     }
  409.     }
  410.  
  411.     if (smw_old->simple_menu.cursor != smw_new->simple_menu.cursor)
  412.     XDefineCursor(XtDisplay(new),
  413.               XtWindow(new), smw_new->simple_menu.cursor);
  414.     
  415.     if (smw_old->simple_menu.label_string !=smw_new->simple_menu.label_string) 
  416.     if (smw_new->simple_menu.label_string == NULL)         /* Destroy. */
  417.         XtDestroyWidget((Widget) smw_old->simple_menu.label);
  418.     else if (smw_old->simple_menu.label_string == NULL)    /* Create. */
  419.         CreateLabel(new);
  420.     else {                                                 /* Change. */
  421.         Arg args[1];
  422.         
  423.         XtSetArg(args[0], XtNlabel, smw_new->simple_menu.label_string);
  424.         XtSetValues((Widget) smw_new->simple_menu.label, args, ONE);
  425.     }
  426.     
  427.     if (smw_old->simple_menu.label_class != smw_new->simple_menu.label_class)
  428.     XtAppWarning(XtWidgetToApplicationContext(new),
  429.              "No Dynamic class change of the SimpleMenu Label.");
  430.     
  431.     if ((smw_old->simple_menu.top_margin != smw_new->simple_menu.top_margin) ||
  432.     (smw_old->simple_menu.bottom_margin != 
  433.      smw_new->simple_menu.bottom_margin) /* filler.................  */ ) {
  434.     layout = TRUE;
  435.     ret_val = TRUE;
  436.     }
  437.  
  438.     if (layout)
  439.     Layout(new, NULL, NULL);
  440.  
  441.     return(ret_val);
  442. }
  443.  
  444. /*      Function Name: SetValuesHook
  445.  *      Description: To handle a special case, this is passed the
  446.  *                   actual arguments.
  447.  *      Arguments: w - the menu widget.
  448.  *                 arglist - the argument list passed to XtSetValues.
  449.  *                 num_args - the number of args.
  450.  *      Returns: none
  451.  */
  452.  
  453. /* 
  454.  * If the user actually passed a width and height to the widget
  455.  * then this MUST be used, rather than our newly calculated width and
  456.  * height.
  457.  */
  458.  
  459. static Boolean
  460. SetValuesHook(w, arglist, num_args)
  461. Widget w;
  462. ArgList arglist;
  463. Cardinal *num_args;
  464. {
  465.     register Cardinal i;
  466.     Dimension width, height;
  467.     
  468.     width = w->core.width;
  469.     height = w->core.height;
  470.     
  471.     for ( i = 0 ; i < *num_args ; i++) {
  472.     if ( streq(arglist[i].name, XtNwidth) )
  473.         width = (Dimension) arglist[i].value;
  474.     if ( streq(arglist[i].name, XtNheight) )
  475.         height = (Dimension) arglist[i].value;
  476.     }
  477.  
  478.     if ((width != w->core.width) || (height != w->core.height))
  479.     MakeSetValuesRequest(w, width, height);
  480.     return(FALSE);
  481. }
  482.  
  483. /************************************************************
  484.  *
  485.  * Geometry Management routines.
  486.  *
  487.  ************************************************************/
  488.  
  489. /*    Function Name: GeometryManager
  490.  *    Description: This is the SimpleMenu Widget's Geometry Manager.
  491.  *    Arguments: w - the Menu Entry making the request.
  492.  *                 request - requested new geometry.
  493.  *                 reply - the allowed geometry.
  494.  *    Returns: XtGeometry{Yes, No, Almost}.
  495.  */
  496.  
  497. static XtGeometryResult
  498. GeometryManager(w, request, reply)
  499. Widget w;
  500. XtWidgetGeometry * request, * reply;
  501. {
  502.     SimpleMenuWidget smw = (SimpleMenuWidget) XtParent(w);
  503.     SmeObject entry = (SmeObject) w;
  504.     XtGeometryMask mode = request->request_mode;
  505.     XtGeometryResult answer;
  506.     Dimension old_height, old_width;
  507.  
  508.     if ( !(mode & CWWidth) && !(mode & CWHeight) )
  509.     return(XtGeometryNo);
  510.  
  511.     reply->width = request->width;
  512.     reply->height = request->height;
  513.  
  514.     old_width = entry->rectangle.width;
  515.     old_height = entry->rectangle.height;
  516.  
  517.     Layout(w, &(reply->width), &(reply->height) );
  518.  
  519. /*
  520.  * Since we are an override shell and have no parent there is no one to
  521.  * ask to see if this geom change is okay, so I am just going to assume
  522.  * we can do whatever we want.  If you subclass be very careful with this
  523.  * assumption, it could bite you.
  524.  *
  525.  * Chris D. Peterson - Sept. 1989.
  526.  */
  527.  
  528.     if ( (reply->width == request->width) &&
  529.      (reply->height == request->height) ) {
  530.  
  531.     if ( mode & XtCWQueryOnly ) { /* Actually perform the layout. */
  532.         entry->rectangle.width = old_width;
  533.         entry->rectangle.height = old_height;    
  534.     }
  535.     else {
  536.         Layout(( Widget) smw, NULL, NULL);
  537.     }
  538.     answer = XtGeometryDone;
  539.     }
  540.     else {
  541.     entry->rectangle.width = old_width;
  542.     entry->rectangle.height = old_height;    
  543.  
  544.     if ( ((reply->width == request->width) && !(mode & CWHeight)) ||
  545.           ((reply->height == request->height) && !(mode & CWWidth)) ||
  546.           ((reply->width == request->width) && 
  547.            (reply->height == request->height)) )
  548.         answer = XtGeometryNo;
  549.     else {
  550.         answer = XtGeometryAlmost;
  551.         reply->request_mode = 0;
  552.         if (reply->width != request->width)
  553.         reply->request_mode |= CWWidth;
  554.         if (reply->height != request->height)
  555.         reply->request_mode |= CWHeight;
  556.     }
  557.     }
  558.     return(answer);
  559. }
  560.  
  561. /*    Function Name: ChangeManaged
  562.  *    Description: called whenever a new child is managed.
  563.  *    Arguments: w - the simple menu widget.
  564.  *    Returns: none.
  565.  */
  566.  
  567. static void
  568. ChangeManaged(w)
  569. Widget w;
  570. {
  571.     Layout(w, NULL, NULL);
  572. }
  573.  
  574. /************************************************************
  575.  *
  576.  * Global Action Routines.
  577.  * 
  578.  * These actions routines will be added to the application's
  579.  * global action list. 
  580.  * 
  581.  ************************************************************/
  582.  
  583. /*      Function Name: PositionMenuAction
  584.  *      Description: Positions the simple menu widget.
  585.  *      Arguments: w - a widget (no the simple menu widget.)
  586.  *                 event - the event that caused this action.
  587.  *                 params, num_params - parameters passed to the routine.
  588.  *                                      we expect the name of the menu here.
  589.  *      Returns: none
  590.  */
  591.  
  592. /* ARGSUSED */
  593. static void
  594. PositionMenuAction(w, event, params, num_params)
  595. Widget w;
  596. XEvent * event;
  597. String * params;
  598. Cardinal * num_params;
  599. { 
  600.   Widget menu;
  601.   XPoint loc;
  602.  
  603.   if (*num_params != 1) {
  604.     char error_buf[BUFSIZ];
  605.     sprintf(error_buf, "%s %s",
  606.         "Xaw - SimpleMenuWidget: position menu action expects only one",
  607.         "parameter which is the name of the menu.");
  608.     XtAppWarning(XtWidgetToApplicationContext(w), error_buf);
  609.     return;
  610.   }
  611.  
  612.   if ( (menu = FindMenu(w, params[0])) == NULL) {
  613.     char error_buf[BUFSIZ];
  614.     sprintf(error_buf, "%s '%s'",
  615.         "Xaw - SimpleMenuWidget: could not find menu named: ", params[0]);
  616.     XtAppWarning(XtWidgetToApplicationContext(w), error_buf);
  617.     return;
  618.   }
  619.   
  620.   switch (event->type) {
  621.   case ButtonPress:
  622.   case ButtonRelease:
  623.     loc.x = event->xbutton.x_root;
  624.     loc.y = event->xbutton.y_root;
  625.     PositionMenu(menu, &loc);
  626.     break;
  627.   case EnterNotify:
  628.   case LeaveNotify:
  629.     loc.x = event->xcrossing.x_root;
  630.     loc.y = event->xcrossing.y_root;
  631.     PositionMenu(menu, &loc);
  632.     break;
  633.   case MotionNotify:
  634.     loc.x = event->xmotion.x_root;
  635.     loc.y = event->xmotion.y_root;
  636.     PositionMenu(menu, &loc);
  637.     break;
  638.   default:
  639.     PositionMenu(menu, NULL);
  640.     break;
  641.   }
  642. }  
  643.  
  644. /************************************************************
  645.  *
  646.  * Widget Action Routines.
  647.  * 
  648.  ************************************************************/
  649.  
  650. /*      Function Name: Unhighlight
  651.  *      Description: Unhighlights current entry.
  652.  *      Arguments: w - the simple menu widget.
  653.  *                 event - the event that caused this action.
  654.  *                 params, num_params - ** NOT USED **
  655.  *      Returns: none
  656.  */
  657.  
  658. /* ARGSUSED */
  659. static void
  660. Unhighlight(w, event, params, num_params)
  661. Widget w;
  662. XEvent * event;
  663. String * params;
  664. Cardinal * num_params;
  665. { 
  666.     SimpleMenuWidget smw = (SimpleMenuWidget) w;
  667.     SmeObject entry = smw->simple_menu.entry_set;
  668.     SmeObjectClass class;
  669.  
  670.     if ( entry == NULL) return;
  671.  
  672.     smw->simple_menu.entry_set = NULL;
  673.     class = (SmeObjectClass) entry->object.widget_class;
  674.     (class->sme_class.unhighlight) ( (Widget) entry);
  675. }
  676.  
  677. /*      Function Name: Highlight
  678.  *      Description: Highlights current entry.
  679.  *      Arguments: w - the simple menu widget.
  680.  *                 event - the event that caused this action.
  681.  *                 params, num_params - ** NOT USED **
  682.  *      Returns: none
  683.  */
  684.  
  685. /* ARGSUSED */
  686. static void
  687. Highlight(w, event, params, num_params)
  688. Widget w;
  689. XEvent * event;
  690. String * params;
  691. Cardinal * num_params;
  692. {
  693.     SimpleMenuWidget smw = (SimpleMenuWidget) w;
  694.     SmeObject entry;
  695.     SmeObjectClass class;
  696.     
  697.     if ( !XtIsSensitive(w) ) return;
  698.     
  699.     entry = GetEventEntry(w, event);
  700.  
  701.     if (entry == smw->simple_menu.entry_set) return;
  702.  
  703.     Unhighlight(w, event, params, num_params);  
  704.  
  705.     if (entry == NULL) return;
  706.  
  707.     if ( !XtIsSensitive( (Widget) entry)) {
  708.     smw->simple_menu.entry_set = NULL;
  709.     return;
  710.     }
  711.  
  712.     smw->simple_menu.entry_set = entry;
  713.     class = (SmeObjectClass) entry->object.widget_class;
  714.  
  715.     (class->sme_class.highlight) ( (Widget) entry);
  716. }
  717.  
  718. /*      Function Name: Notify
  719.  *      Description: Notify user of current entry.
  720.  *      Arguments: w - the simple menu widget.
  721.  *                 event - the event that caused this action.
  722.  *                 params, num_params - ** NOT USED **
  723.  *      Returns: none
  724.  */
  725.  
  726. /* ARGSUSED */
  727. static void
  728. Notify(w, event, params, num_params)
  729. Widget w;
  730. XEvent * event;
  731. String * params;
  732. Cardinal * num_params;
  733. {
  734.     SimpleMenuWidget smw = (SimpleMenuWidget) w;
  735.     SmeObject entry = smw->simple_menu.entry_set;
  736.     SmeObjectClass class;
  737.     
  738.     if ( (entry == NULL) || !XtIsSensitive((Widget) entry) ) return;
  739.  
  740.     class = (SmeObjectClass) entry->object.widget_class;
  741.     (class->sme_class.notify)( (Widget) entry );
  742. }
  743.  
  744. /************************************************************
  745.  *
  746.  * Public Functions.
  747.  *
  748.  ************************************************************/
  749.  
  750. /*    Function Name: XawSimpleMenuAddGlobalActions
  751.  *    Description: adds the global actions to the simple menu widget.
  752.  *    Arguments: app_con - the appcontext.
  753.  *    Returns: none.
  754.  */
  755.  
  756. void
  757. #if NeedFunctionPrototypes
  758. XawSimpleMenuAddGlobalActions(XtAppContext app_con)
  759. #else
  760. XawSimpleMenuAddGlobalActions(app_con)
  761. XtAppContext app_con;
  762. #endif
  763. {
  764.     XtInitializeWidgetClass(simpleMenuWidgetClass);
  765.     XmuCallInitializers( app_con );
  766. } 
  767.  
  768.  
  769. /*    Function Name: XawSimpleMenuGetActiveEntry
  770.  *    Description: Gets the currently active (set) entry.
  771.  *    Arguments: w - the smw widget.
  772.  *    Returns: the currently set entry or NULL if none is set.
  773.  */
  774.  
  775. Widget
  776. #if NeedFunctionPrototypes
  777. XawSimpleMenuGetActiveEntry(Widget w)
  778. #else
  779. XawSimpleMenuGetActiveEntry(w)
  780. Widget w;
  781. #endif
  782. {
  783.     SimpleMenuWidget smw = (SimpleMenuWidget) w;
  784.  
  785.     return( (Widget) smw->simple_menu.entry_set);
  786. } 
  787.  
  788. /*    Function Name: XawSimpleMenuClearActiveEntry
  789.  *    Description: Unsets the currently active (set) entry.
  790.  *    Arguments: w - the smw widget.
  791.  *    Returns: none.
  792.  */
  793.  
  794. void
  795. #if NeedFunctionPrototypes
  796. XawSimpleMenuClearActiveEntry(Widget w)
  797. #else
  798. XawSimpleMenuClearActiveEntry(w)
  799. Widget w;
  800. #endif
  801. {
  802.     SimpleMenuWidget smw = (SimpleMenuWidget) w;
  803.  
  804.     smw->simple_menu.entry_set = NULL;
  805. } 
  806.  
  807. /************************************************************
  808.  *
  809.  * Private Functions.
  810.  *
  811.  ************************************************************/
  812.  
  813. /*    Function Name: CreateLabel
  814.  *    Description: Creates a the menu label.
  815.  *    Arguments: w - the smw widget.
  816.  *    Returns: none.
  817.  * 
  818.  * Creates the label object and makes sure it is the first child in
  819.  * in the list.
  820.  */
  821.  
  822. static void
  823. CreateLabel(w)
  824. Widget w;
  825. {
  826.     SimpleMenuWidget smw = (SimpleMenuWidget) w;
  827.     register Widget * child, * next_child;
  828.     register int i;
  829.     Arg args[2];
  830.  
  831.     if ( (smw->simple_menu.label_string == NULL) ||
  832.      (smw->simple_menu.label != NULL) ) {
  833.     char error_buf[BUFSIZ];
  834.  
  835.     sprintf(error_buf, "Xaw Simple Menu Widget: %s or %s, %s",
  836.         "label string is NULL", "label already exists", 
  837.         "no label is being created.");
  838.     XtAppWarning(XtWidgetToApplicationContext(w), error_buf);
  839.     return;
  840.     }
  841.  
  842.     XtSetArg(args[0], XtNlabel, smw->simple_menu.label_string);
  843.     XtSetArg(args[1], XtNjustify, XtJustifyCenter);
  844.     smw->simple_menu.label = (SmeObject) 
  845.                           XtCreateManagedWidget("menuLabel", 
  846.                         smw->simple_menu.label_class, w,
  847.                         args, TWO);
  848.  
  849.     next_child = NULL;
  850.     for (child = smw->composite.children + smw->composite.num_children,
  851.      i = smw->composite.num_children ; i > 0 ; i--, child--) {
  852.     if (next_child != NULL)
  853.         *next_child = *child;
  854.     next_child = child;
  855.     }
  856.     *child = (Widget) smw->simple_menu.label;
  857. }
  858.  
  859. /*    Function Name: Layout
  860.  *    Description: lays the menu entries out all nice and neat.
  861.  *    Arguments: w - See below (+++)
  862.  *                 width_ret, height_ret - The returned width and 
  863.  *                                         height values.
  864.  *    Returns: none.
  865.  *
  866.  * if width == NULL || height == NULL then it assumes the you do not care
  867.  * about the return values, and just want a relayout.
  868.  *
  869.  * if this is not the case then it will set width_ret and height_ret
  870.  * to be width and height that the child would get if it were layed out
  871.  * at this time.
  872.  *
  873.  * +++ "w" can be the simple menu widget or any of its object children.
  874.  */
  875.  
  876. static void
  877. Layout(w, width_ret, height_ret)
  878. Widget w;
  879. Dimension *width_ret, *height_ret;
  880. {
  881.     SmeObject current_entry, *entry;
  882.     SimpleMenuWidget smw;
  883.     Dimension width, height;
  884.     Boolean do_layout = ((height_ret == NULL) || (width_ret == NULL));
  885.     Boolean allow_change_size;
  886.     height = 0;
  887.  
  888.     if ( XtIsSubclass(w, simpleMenuWidgetClass) ) {
  889.     smw = (SimpleMenuWidget) w;
  890.     current_entry = NULL;
  891.     }
  892.     else {
  893.     smw = (SimpleMenuWidget) XtParent(w);
  894.     current_entry = (SmeObject) w;
  895.     }
  896.  
  897.     allow_change_size = (!XtIsRealized((Widget)smw) ||
  898.              (smw->shell.allow_shell_resize));
  899.  
  900.     if ( smw->simple_menu.menu_height )
  901.     height = smw->core.height;
  902.     else
  903.     if (do_layout) {
  904.         height = smw->simple_menu.top_margin;
  905.         ForAllChildren(smw, entry) {
  906.         if (!XtIsManaged( (Widget) *entry)) continue;
  907.  
  908.         if ( (smw->simple_menu.row_height != 0) && 
  909.             (*entry != smw->simple_menu.label) ) 
  910.             (*entry)->rectangle.height = smw->simple_menu.row_height;
  911.         
  912.         (*entry)->rectangle.y = height;
  913.         (*entry)->rectangle.x = 0;
  914.         height += (*entry)->rectangle.height;
  915.         }
  916.         height += smw->simple_menu.bottom_margin;
  917.     }
  918.     else {
  919.         if ((smw->simple_menu.row_height != 0) && 
  920.         (current_entry != smw->simple_menu.label) )
  921.         height = smw->simple_menu.row_height;
  922.     }
  923.     
  924.     if (smw->simple_menu.menu_width)
  925.     width = smw->core.width;
  926.     else if ( allow_change_size )
  927.     width = GetMenuWidth((Widget) smw, (Widget) current_entry);
  928.     else
  929.     width = smw->core.width;
  930.  
  931.     if (do_layout) {
  932.     ForAllChildren(smw, entry)
  933.         if (XtIsManaged( (Widget) *entry)) 
  934.         (*entry)->rectangle.width = width;
  935.  
  936.     if (allow_change_size)
  937.         MakeSetValuesRequest((Widget) smw, width, height);
  938.     }
  939.     else {
  940.     *width_ret = width;
  941.     if (height != 0)
  942.         *height_ret = height;
  943.     }
  944. }
  945.     
  946. /*    Function Name: AddPositionAction
  947.  *    Description: Adds the XawPositionSimpleMenu action to the global
  948.  *                   action list for this appcon.
  949.  *    Arguments: app_con - the application context for this app.
  950.  *                 data - NOT USED.
  951.  *    Returns: none.
  952.  */
  953.  
  954. /* ARGSUSED */
  955. static void
  956. AddPositionAction(app_con, data)
  957. XtAppContext app_con;
  958. caddr_t data;
  959. {
  960.     static XtActionsRec pos_action[] = {
  961.         { "XawPositionSimpleMenu", PositionMenuAction },
  962.     };
  963.  
  964.     XtAppAddActions(app_con, pos_action, XtNumber(pos_action));
  965. }
  966.  
  967. /*    Function Name: FindMenu
  968.  *    Description: Find the menu give a name and reference widget.
  969.  *    Arguments: widget - reference widget.
  970.  *                 name   - the menu widget's name.
  971.  *    Returns: the menu widget or NULL.
  972.  */
  973.  
  974. static Widget 
  975. FindMenu(widget, name)
  976. Widget widget;
  977. String name;
  978. {
  979.     register Widget w, menu;
  980.     
  981.     for ( w = widget ; w != NULL ; w = XtParent(w) )
  982.     if ( (menu = XtNameToWidget(w, name)) != NULL )
  983.         return(menu);
  984.     return(NULL);
  985. }
  986.  
  987. /*    Function Name: PositionMenu
  988.  *    Description: Places the menu
  989.  *    Arguments: w - the simple menu widget.
  990.  *                 location - a pointer the the position or NULL.
  991.  *    Returns: none.
  992.  */
  993.  
  994. static void
  995. PositionMenu(w, location)
  996. Widget w;
  997. XPoint * location;
  998. {
  999.     SimpleMenuWidget smw = (SimpleMenuWidget) w;
  1000.     SmeObject entry;
  1001.     XPoint t_point;
  1002.     
  1003.     if (location == NULL) {
  1004.     Window junk1, junk2;
  1005.     int root_x, root_y, junkX, junkY;
  1006.     unsigned int junkM;
  1007.     
  1008.     location = &t_point;
  1009.     if (XQueryPointer(XtDisplay(w), XtWindow(w), &junk1, &junk2, 
  1010.               &root_x, &root_y, &junkX, &junkY, &junkM) == FALSE) {
  1011.         char error_buf[BUFSIZ];
  1012.         sprintf(error_buf, "%s %s", "Xaw - SimpleMenuWidget:",
  1013.             "Could not find location of mouse pointer");
  1014.         XtAppWarning(XtWidgetToApplicationContext(w), error_buf);
  1015.         return;
  1016.     }
  1017.     location->x = (short) root_x;
  1018.     location->y = (short) root_y;
  1019.     }
  1020.     
  1021.     /*
  1022.      * The width will not be correct unless it is realized.
  1023.      */
  1024.     
  1025.     XtRealizeWidget(w);
  1026.     
  1027.     location->x -= (Position) w->core.width/2;
  1028.     
  1029.     if (smw->simple_menu.popup_entry == NULL)
  1030.     entry = smw->simple_menu.label;
  1031.     else
  1032.     entry = smw->simple_menu.popup_entry;
  1033.  
  1034.     if (entry != NULL)
  1035.     location->y -= entry->rectangle.y + entry->rectangle.height/2;
  1036.  
  1037.     MoveMenu(w, (Position) location->x, (Position) location->y);
  1038. }
  1039.  
  1040. /*    Function Name: MoveMenu
  1041.  *    Description: Actually moves the menu, may force it to
  1042.  *                   to be fully visable if menu_on_screen is TRUE.
  1043.  *    Arguments: w - the simple menu widget.
  1044.  *                 x, y - the current location of the widget.
  1045.  *    Returns: none 
  1046.  */
  1047.  
  1048. static void
  1049. MoveMenu(w, x, y)
  1050. Widget w;
  1051. Position x, y;
  1052. {
  1053.     Arg arglist[2];
  1054.     Cardinal num_args = 0;
  1055.     SimpleMenuWidget smw = (SimpleMenuWidget) w;
  1056.     
  1057.     if (smw->simple_menu.menu_on_screen) {
  1058.     int width = w->core.width + 2 * w->core.border_width;
  1059.     int height = w->core.height + 2 * w->core.border_width;
  1060.     
  1061.     if (x >= 0) {
  1062.         int scr_width = WidthOfScreen(XtScreen(w));
  1063.         if (x + width > scr_width)
  1064.         x = scr_width - width;
  1065.     }
  1066.     if (x < 0) 
  1067.         x = 0;
  1068.     
  1069.     if (y >= 0) {
  1070.         int scr_height = HeightOfScreen(XtScreen(w));
  1071.         if (y + height > scr_height)
  1072.         y = scr_height - height;
  1073.     }
  1074.     if (y < 0)
  1075.         y = 0;
  1076.     }
  1077.     
  1078.     XtSetArg(arglist[num_args], XtNx, x); num_args++;
  1079.     XtSetArg(arglist[num_args], XtNy, y); num_args++;
  1080.     XtSetValues(w, arglist, num_args);
  1081. }
  1082.  
  1083. /*    Function Name: ChangeCursorOnGrab
  1084.  *    Description: Changes the cursor on the active grab to the one
  1085.  *                   specified in out resource list.
  1086.  *    Arguments: w - the widget.
  1087.  *                 junk, garbage - ** NOT USED **.
  1088.  *    Returns: None.
  1089.  */
  1090.  
  1091. /* ARGSUSED */
  1092. static void
  1093. ChangeCursorOnGrab(w, junk, garbage)
  1094. Widget w;
  1095. XtPointer junk, garbage;
  1096. {
  1097.     SimpleMenuWidget smw = (SimpleMenuWidget) w;
  1098.     
  1099.     /*
  1100.      * The event mask here is what is currently in the MIT implementation.
  1101.      * There really needs to be a way to get the value of the mask out
  1102.      * of the toolkit (CDP 5/26/89).
  1103.      */
  1104.     
  1105.     XChangeActivePointerGrab(XtDisplay(w), ButtonPressMask|ButtonReleaseMask,
  1106.                  smw->simple_menu.cursor, 
  1107.                  XtLastTimestampProcessed(XtDisplay(w)));
  1108. }
  1109.  
  1110. /*      Function Name: MakeSetValuesRequest
  1111.  *      Description: Makes a (possibly recursive) call to SetValues,
  1112.  *                   I take great pains to not go into an infinite loop.
  1113.  *      Arguments: w - the simple menu widget.
  1114.  *                 width, height - the size of the ask for.
  1115.  *      Returns: none
  1116.  */
  1117.  
  1118. static void
  1119. MakeSetValuesRequest(w, width, height)
  1120. Widget w;
  1121. Dimension width, height;
  1122. {
  1123.     SimpleMenuWidget smw = (SimpleMenuWidget) w;
  1124.     Arg arglist[2];
  1125.     Cardinal num_args = (Cardinal) 0;
  1126.     
  1127.     if ( !smw->simple_menu.recursive_set_values ) {
  1128.     if ( (smw->core.width != width) || (smw->core.height != height) ) {
  1129.         smw->simple_menu.recursive_set_values = TRUE;
  1130.         XtSetArg(arglist[num_args], XtNwidth, width);   num_args++;
  1131.         XtSetArg(arglist[num_args], XtNheight, height); num_args++;
  1132.         XtSetValues(w, arglist, num_args);
  1133.     }
  1134.     else if (XtIsRealized( (Widget) smw))
  1135.         Redisplay((Widget) smw, (XEvent *) NULL, (Region) NULL);
  1136.     }
  1137.     smw->simple_menu.recursive_set_values = FALSE;
  1138. }
  1139.  
  1140. /*      Function Name: GetMenuWidth
  1141.  *      Description: Sets the length of the widest entry in pixels.
  1142.  *      Arguments: w - the simple menu widget.
  1143.  *      Returns: width of menu.
  1144.  */
  1145.  
  1146. static Dimension
  1147. GetMenuWidth(w, w_ent)
  1148. Widget w, w_ent;
  1149. {
  1150.     SmeObject cur_entry = (SmeObject) w_ent;
  1151.     SimpleMenuWidget smw = (SimpleMenuWidget) w;
  1152.     Dimension width, widest = (Dimension) 0;
  1153.     SmeObject * entry;
  1154.     
  1155.     if ( smw->simple_menu.menu_width ) 
  1156.     return(smw->core.width);
  1157.  
  1158.     ForAllChildren(smw, entry) {
  1159.     XtWidgetGeometry preferred;
  1160.  
  1161.     if (!XtIsManaged( (Widget) *entry)) continue;
  1162.     
  1163.     if (*entry != cur_entry) {
  1164.         XtQueryGeometry((Widget) *entry, NULL, &preferred);
  1165.         
  1166.         if (preferred.request_mode & CWWidth)
  1167.         width = preferred.width;
  1168.         else
  1169.         width = (*entry)->rectangle.width;
  1170.     }
  1171.     else
  1172.         width = (*entry)->rectangle.width;
  1173.     
  1174.     if ( width > widest )
  1175.         widest = width;
  1176.     }
  1177.     
  1178.     return(widest);
  1179. }
  1180.  
  1181. /*      Function Name: GetMenuHeight
  1182.  *      Description: Sets the length of the widest entry in pixels.
  1183.  *      Arguments: w - the simple menu widget.
  1184.  *      Returns: width of menu.
  1185.  */
  1186.  
  1187. static Dimension
  1188. GetMenuHeight(w)
  1189. Widget w;
  1190. {
  1191.     SimpleMenuWidget smw = (SimpleMenuWidget) w;
  1192.     SmeObject * entry;
  1193.     Dimension height;
  1194.     
  1195.     if (smw->simple_menu.menu_height)
  1196.     return(smw->core.height);
  1197.  
  1198.     height = smw->simple_menu.top_margin + smw->simple_menu.bottom_margin;
  1199.     
  1200.     if (smw->simple_menu.row_height == 0) 
  1201.     ForAllChildren(smw, entry) 
  1202.         if (XtIsManaged ((Widget) *entry)) 
  1203.         height += (*entry)->rectangle.height;
  1204.     else 
  1205.     height += smw->simple_menu.row_height * smw->composite.num_children;
  1206.     
  1207.     return(height);
  1208. }
  1209.  
  1210. /*      Function Name: GetEventEntry
  1211.  *      Description: Gets an entry given an event that has X and Y coords.
  1212.  *      Arguments: w - the simple menu widget.
  1213.  *                 event - the event.
  1214.  *      Returns: the entry that this point is in.
  1215.  */
  1216.  
  1217. static SmeObject
  1218. GetEventEntry(w, event)
  1219. Widget w;
  1220. XEvent * event;
  1221. {
  1222.     Position x_loc, y_loc;
  1223.     SimpleMenuWidget smw = (SimpleMenuWidget) w;
  1224.     SmeObject * entry;
  1225.     
  1226.     switch (event->type) {
  1227.     case MotionNotify:
  1228.     x_loc = event->xmotion.x;
  1229.     y_loc = event->xmotion.y;
  1230.     break;
  1231.     case EnterNotify:
  1232.     case LeaveNotify:
  1233.     x_loc = event->xcrossing.x;
  1234.     y_loc = event->xcrossing.y;
  1235.     break;
  1236.     case ButtonPress:
  1237.     case ButtonRelease:
  1238.     x_loc = event->xbutton.x;
  1239.     y_loc = event->xbutton.y;
  1240.     break;
  1241.     default:
  1242.     XtAppError(XtWidgetToApplicationContext(w),
  1243.            "Unknown event type in GetEventEntry().");
  1244.     break;
  1245.     }
  1246.     
  1247.     if ( (x_loc < 0) || (x_loc >= (int)smw->core.width) || (y_loc < 0) ||
  1248.     (y_loc >= (int)smw->core.height) )
  1249.     return(NULL);
  1250.     
  1251.     ForAllChildren(smw, entry) {
  1252.     if (!XtIsManaged ((Widget) *entry)) continue;
  1253.  
  1254.     if ( ((*entry)->rectangle.y < y_loc) &&
  1255.         ((*entry)->rectangle.y + (int) (*entry)->rectangle.height > y_loc) )
  1256.         if ( *entry == smw->simple_menu.label )
  1257.         return(NULL);    /* cannot select the label. */
  1258.         else
  1259.         return(*entry);
  1260.     }
  1261.     
  1262.     return(NULL);
  1263. }
  1264.