home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 2: Applications / Linux Cubed Series 2 - Applications.iso / editors / emacs / xemacs / xemacs-1.004 / xemacs-1 / xemacs-19.13 / lwlib / xlwmenu.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-07-28  |  83.2 KB  |  3,172 lines
  1. /* Implements a lightweight menubar widget.  
  2.    Copyright (C) 1992, 1993, 1994 Lucid, Inc.
  3.    Copyright (C) 1995 Tinker Systems and INS Engineering Corp.
  4.  
  5. This file is part of the Lucid Widget Library.
  6.  
  7. The Lucid Widget Library is free software; you can redistribute it and/or 
  8. modify it under the terms of the GNU General Public License as published by
  9. the Free Software Foundation; either version 2, or (at your option)
  10. any later version.
  11.  
  12. The Lucid Widget Library is distributed in the hope that it will be useful,
  13. but WITHOUT ANY WARRANTY; without even the implied warranty of 
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. GNU General Public License for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with GNU Emacs; see the file COPYING.  If not, write to
  19. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20.  
  21. /* Created by devin@lucid.com */
  22.  
  23. #include <stdlib.h>
  24. #include <unistd.h>
  25. #include <string.h>
  26. #include <ctype.h>
  27. #include <stdio.h>
  28.  
  29. #include <sys/types.h>
  30. #include <X11/Xos.h>
  31. #include <X11/IntrinsicP.h>
  32. #include <X11/StringDefs.h>
  33. #include <X11/cursorfont.h>
  34. #include <X11/bitmaps/gray>
  35.  
  36. #ifdef NEED_MOTIF
  37. #include <Xm/Xm.h>
  38. #endif
  39. #include "xlwmenuP.h"
  40.  
  41. static char 
  42. xlwMenuTranslations [] = 
  43. "<BtnDown>:    start()\n\
  44. <BtnMotion>:    drag()\n\
  45. <BtnUp>:    select()\n\
  46. ";
  47.  
  48. #define offset(field) XtOffset(XlwMenuWidget, field)
  49. static XtResource 
  50. xlwMenuResources[] =
  51. { 
  52. #ifdef NEED_MOTIF
  53.   /* There are three font list resources, so that we can accept either of
  54.      the resources *fontList: or *font:, and so that we can tell the
  55.      difference between them being specified, and being defaulted to a
  56.      font from the XtRString specified here.
  57.    */
  58.   {XmNfontList,  XmCFontList, XmRFontList, sizeof(XmFontList),
  59.      offset(menu.font_list),  XtRImmediate, (XtPointer)0},
  60.   {XtNfont,      XtCFont,     XmRFontList, sizeof(XmFontList),
  61.      offset(menu.font_list_2),XtRImmediate, (XtPointer)0},
  62.   {XmNfontList,  XmCFontList, XmRFontList, sizeof(XmFontList),
  63.      offset(menu.fallback_font_list),
  64.      /* We must use an iso8859-1 font here, or people without $LANG set lose.
  65.     It's fair to assume that those who do have $LANG set also have the
  66.     *fontList resource set, or at least know how to deal with this.
  67.       */
  68.      XtRString, "-*-helvetica-bold-r-*-*-*-120-*-*-*-*-iso8859-1"},
  69. #else
  70.   {XtNfont,  XtCFont, XtRFontStruct, sizeof(XFontStruct *),
  71.      offset(menu.font),XtRString, "XtDefaultFont"},
  72. #endif
  73.   {XtNforeground, XtCForeground, XtRPixel, sizeof(Pixel),
  74.      offset(menu.foreground), XtRString, "XtDefaultForeground"},
  75.   {XtNbuttonForeground, XtCButtonForeground, XtRPixel, sizeof(Pixel),
  76.      offset(menu.button_foreground), XtRString, "XtDefaultForeground"},
  77.   {XtNmargin, XtCMargin, XtRDimension,  sizeof(Dimension),
  78.      offset(menu.margin), XtRImmediate, (XtPointer)2},
  79.   {XmNmarginWidth, XmCMarginWidth, XmRHorizontalDimension, sizeof(Dimension),
  80.      offset(menu.horizontal_margin), XtRImmediate, (XtPointer)2},
  81.   {XmNmarginHeight, XmCMarginHeight, XmRVerticalDimension, sizeof(Dimension),
  82.      offset(menu.vertical_margin), XtRImmediate, (XtPointer)1},
  83.   {XmNspacing, XmCSpacing, XmRHorizontalDimension,  sizeof(Dimension),
  84.      offset(menu.column_spacing), XtRImmediate, (XtPointer)4},
  85.   {XmNindicatorSize, XmCIndicatorSize, XtRDimension,  sizeof(Dimension),
  86.      offset(menu.indicator_size), XtRImmediate, (XtPointer)0},
  87.   {XmNshadowThickness, XmCShadowThickness, XmRHorizontalDimension,
  88.      sizeof (Dimension), offset (menu.shadow_thickness),
  89.      XtRImmediate, (XtPointer) 2},
  90.   {XmNselectColor, XmCSelectColor, XtRPixel, sizeof (Pixel),
  91.      offset (menu.select_color), XtRImmediate, (XtPointer)-1},
  92.   {XmNtopShadowColor, XmCTopShadowColor, XtRPixel, sizeof (Pixel),
  93.      offset (menu.top_shadow_color), XtRImmediate, (XtPointer)-1},
  94.   {XmNbottomShadowColor, XmCBottomShadowColor, XtRPixel, sizeof (Pixel),
  95.      offset (menu.bottom_shadow_color), XtRImmediate, (XtPointer)-1},
  96.   {XmNtopShadowPixmap, XmCTopShadowPixmap, XtRPixmap, sizeof (Pixmap),
  97.      offset (menu.top_shadow_pixmap), XtRImmediate, (XtPointer)None},
  98.   {XmNbottomShadowPixmap, XmCBottomShadowPixmap, XtRPixmap, sizeof (Pixmap),
  99.      offset (menu.bottom_shadow_pixmap), XtRImmediate, (XtPointer)None},
  100.  
  101.   {XtNopen, XtCCallback, XtRCallback, sizeof(XtPointer), 
  102.      offset(menu.open), XtRCallback, (XtPointer)NULL},
  103.   {XtNselect, XtCCallback, XtRCallback, sizeof(XtPointer), 
  104.      offset(menu.select), XtRCallback, (XtPointer)NULL},
  105.   {XtNmenu, XtCMenu, XtRPointer, sizeof(XtPointer),
  106.      offset(menu.contents), XtRImmediate, (XtPointer)NULL},
  107.   {XtNcursor, XtCCursor, XtRCursor, sizeof(Cursor),
  108.      offset(menu.cursor_shape), XtRString, (XtPointer)"right_ptr"},
  109.   {XtNhorizontal, XtCHorizontal, XtRInt, sizeof(int),
  110.      offset(menu.horizontal), XtRImmediate, (XtPointer)True},
  111.   {XtNuseBackingStore, XtCUseBackingStore, XtRBoolean, sizeof (Boolean),
  112.      offset (menu.use_backing_store), XtRImmediate, (XtPointer)False},
  113.   {XtNbounceDown, XtCBounceDown, XtRBoolean, sizeof (Boolean),
  114.      offset (menu.bounce_down), XtRImmediate, (XtPointer)True},
  115.   {XtNresourceLabels, XtCResourceLabels, XtRBoolean, sizeof (Boolean),
  116.      offset (menu.lookup_labels), XtRImmediate, (XtPointer)False},
  117. };
  118. #undef offset
  119.  
  120. static Boolean XlwMenuSetValues (Widget current, Widget request, Widget new,
  121.                  ArgList args, Cardinal *num_args);
  122. static void XlwMenuRealize (Widget w, Mask *valueMask,
  123.                 XSetWindowAttributes *attributes);
  124. static void XlwMenuRedisplay (Widget w, XEvent *ev, Region region);
  125. static void XlwMenuResize (Widget w);
  126. static void XlwMenuInitialize (Widget request, Widget new, ArgList args,
  127.                    Cardinal *num_args);
  128. static void XlwMenuDestroy (Widget w);
  129. static void XlwMenuClassInitialize (void);
  130. static void Start (Widget w, XEvent *ev, String *params, Cardinal *num_params);
  131. static void Drag (Widget w, XEvent *ev, String *params, Cardinal *num_params);
  132. static void Select (Widget w, XEvent *ev, String *params,
  133.  Cardinal *num_params);
  134.  
  135. #ifdef NEED_MOTIF
  136. static XFontStruct *default_font_of_font_list (XmFontList);
  137. #endif
  138.  
  139. static XtActionsRec 
  140. xlwMenuActionsList [] =
  141. {
  142.   {"start",        Start},
  143.   {"drag",        Drag},
  144.   {"select",        Select},
  145. };
  146.  
  147. #define SuperClass ((CoreWidgetClass)&coreClassRec)
  148.  
  149. XlwMenuClassRec xlwMenuClassRec =
  150. {
  151.   {  /* CoreClass fields initialization */
  152.     (WidgetClass) SuperClass,        /* superclass          */    
  153.     "XlwMenu",                /* class_name          */
  154.     sizeof(XlwMenuRec),            /* size              */
  155.     XlwMenuClassInitialize,        /* class_initialize      */
  156.     NULL,                /* class_part_initialize  */
  157.     FALSE,                /* class_inited          */
  158.     XlwMenuInitialize,            /* initialize          */
  159.     NULL,                /* initialize_hook      */
  160.     XlwMenuRealize,            /* realize          */
  161.     xlwMenuActionsList,            /* actions          */
  162.     XtNumber(xlwMenuActionsList),    /* num_actions          */
  163.     xlwMenuResources,            /* resources          */
  164.     XtNumber(xlwMenuResources),        /* resource_count      */
  165.     NULLQUARK,                /* xrm_class          */
  166.     TRUE,                /* compress_motion      */
  167.     TRUE,                /* compress_exposure      */
  168.     TRUE,                /* compress_enterleave    */
  169.     FALSE,                /* visible_interest      */
  170.     XlwMenuDestroy,            /* destroy          */
  171.     XlwMenuResize,            /* resize          */
  172.     XlwMenuRedisplay,            /* expose          */
  173.     XlwMenuSetValues,            /* set_values          */
  174.     NULL,                /* set_values_hook      */
  175.     XtInheritSetValuesAlmost,        /* set_values_almost      */
  176.     NULL,                /* get_values_hook      */
  177.     NULL,            /* #### - should this be set for grabs? accept_focus          */
  178.     XtVersion,                /* version          */
  179.     NULL,                /* callback_private      */
  180.     xlwMenuTranslations,        /* tm_table          */
  181.     XtInheritQueryGeometry,        /* query_geometry      */
  182.     XtInheritDisplayAccelerator,    /* display_accelerator      */
  183.     NULL                /* extension          */
  184.   },  /* XlwMenuClass fields initialization */
  185.   {
  186.     0                    /* dummy */
  187.   },
  188. };
  189.  
  190. WidgetClass xlwMenuWidgetClass = (WidgetClass) &xlwMenuClassRec;
  191.  
  192. /* Utilities */
  193. #if 0 /* Apparently not used anywhere */
  194.  
  195. static char *
  196. safe_strdup (char *s)
  197. {
  198.   char *result;
  199.   if (! s) return 0;
  200.   result = (char *) malloc (strlen (s) + 1);
  201.   if (! result)
  202.     return 0;
  203.   strcpy (result, s);
  204.   return result;
  205. }
  206.  
  207. #endif /* 0 */
  208.  
  209. static void
  210. push_new_stack (XlwMenuWidget mw, widget_value *val)
  211. {
  212.   if (!mw->menu.new_stack)
  213.     {
  214.       mw->menu.new_stack_length = 10;
  215.       mw->menu.new_stack =
  216.     (widget_value**)XtCalloc (mw->menu.new_stack_length,
  217.                   sizeof (widget_value*));
  218.     }
  219.   else if (mw->menu.new_depth == mw->menu.new_stack_length)
  220.     {
  221.       mw->menu.new_stack_length *= 2;
  222.       mw->menu.new_stack =
  223.     (widget_value**)XtRealloc ((char*)mw->menu.new_stack,
  224.                    mw->menu.new_stack_length *
  225.                    sizeof (widget_value*));
  226.     }
  227.   mw->menu.new_stack [mw->menu.new_depth++] = val;
  228. }
  229.  
  230. static void
  231. pop_new_stack_if_no_contents (XlwMenuWidget mw)
  232. {
  233.   if (mw->menu.new_depth)
  234.     {
  235.       if (!mw->menu.new_stack [mw->menu.new_depth - 1]->contents)
  236.     {
  237.       mw->menu.new_depth -= 1;
  238.     }
  239.     }
  240. }
  241.  
  242. static void
  243. make_old_stack_space (XlwMenuWidget mw, int n)
  244. {
  245.   if (!mw->menu.old_stack)
  246.     {
  247.       mw->menu.old_stack_length = 10;
  248.       mw->menu.old_stack =
  249.     (widget_value**)XtCalloc (mw->menu.old_stack_length,
  250.                   sizeof (widget_value*));
  251.     }
  252.   else if (mw->menu.old_stack_length < n)
  253.     {
  254.       mw->menu.old_stack_length *= 2;
  255.       mw->menu.old_stack =
  256.     (widget_value**)XtRealloc ((char*)mw->menu.old_stack,
  257.                    mw->menu.old_stack_length *
  258.                    sizeof (widget_value*));
  259.     }
  260. }
  261.  
  262. static Boolean
  263. close_to_reference_time(Widget w, Time reference_time, XEvent *ev)
  264. {
  265.   return (reference_time &&
  266.       (ev->xbutton.time - reference_time
  267.           < XtGetMultiClickTime (XtDisplay (w))));
  268. }
  269.  
  270. /* Size code */
  271. static int
  272. string_width (XlwMenuWidget mw,
  273. #ifdef NEED_MOTIF
  274.           XmString s
  275. #else
  276.           char *s
  277. #endif
  278.           )
  279. {
  280. #ifdef NEED_MOTIF
  281.   Dimension width, height;
  282.   XmStringExtent (mw->menu.font_list, s, &width, &height);
  283.   return width;
  284. #else
  285.   XCharStruct xcs;
  286.   int drop;
  287.   XTextExtents (mw->menu.font, s, strlen (s), &drop, &drop, &drop, &xcs);
  288.   return xcs.width;
  289. #endif
  290. }
  291.  
  292. static void
  293. massage_resource_name (CONST char *in, char *out)
  294. {
  295.   /* Turn a random string into something suitable for using as a resource.
  296.      For example:
  297.  
  298.      "Kill Buffer"        ->    "killBuffer"
  299.      "Find File..."        ->    "findFile"
  300.      "Search and Replace..."    ->    "searchAndReplace"
  301.    */
  302.  
  303. # define GOOD_CHAR(c) (((c) >= 'a' && (c) <= 'z') || \
  304.                ((c) >= 'A' && (c) <= 'Z') || \
  305.                ((c) >= '0' && (c) <= '9') || \
  306.                ((c) == '_') || \
  307.                ((c) > 0240))
  308.   int firstp = 1;
  309.   while (*in)
  310.     {
  311.       if (GOOD_CHAR ((unsigned char) *in))
  312.     {
  313.       if (firstp)
  314.         *out = tolower (*in);
  315.       else
  316.         *out = toupper (*in);
  317.       firstp = 0;
  318.       in++;
  319.       out++;
  320.       while (GOOD_CHAR ((unsigned char) *in))
  321.         {
  322.           *out = *in;
  323.           in++;
  324.           out++;
  325.         }
  326.     }
  327.       else
  328.     {
  329.       /* A bogus char between words; skip it. */
  330.       in++;
  331.     }
  332.     }
  333.   *out = 0;
  334. #undef GOOD_CHAR
  335. }
  336.  
  337. static XtResource
  338. nameResource[] =
  339. { 
  340.   { "labelString",  "LabelString", XtRString, sizeof(String),
  341.     0, XtRImmediate, 0 }
  342. };
  343.  
  344. /*
  345.  *    This function looks through string searching for parameter
  346.  *    inserts of the form:
  347.  *    %[padding]1
  348.  *    padding is space (' ') or dash ('-') characters meaning
  349.  *    padding to the left or right of the inserted parameter.
  350.  *    In essence all %1 strings are replaced by value in the return
  351.  *    value (which the caller is expected to free).
  352.  *    %% means insert one % (like printf).
  353.  *    %1 means insert value.
  354.  *    %-1 means insert value followed by one space. The latter is
  355.  *    not inserted if value is a zero length string.
  356.  */
  357. static char*
  358. parameterize_string (char *string, char *value)
  359. {
  360.   char *percent;
  361.   char *result;
  362.   unsigned done = 0;
  363.   unsigned ntimes;
  364.  
  365.   if (!string)
  366.     string = "";
  367.  
  368.   if (!value)
  369.     value = "";
  370.  
  371.   for (ntimes = 1, result = string; (percent = strchr(result, '%')); ntimes++)
  372.     result = &percent[1];
  373.   
  374.   result = XtMalloc((ntimes * strlen(value)) + strlen(string) + 4);
  375.   result[0] = '\0';
  376.  
  377.   while ((percent = strchr(string, '%')))
  378.     {
  379.       unsigned left_pad;
  380.       unsigned right_pad;
  381.       char *p;
  382.       
  383.       if (percent[1] == '%')
  384.     {    /* it's a real % */
  385.       strncat(result, string, 1 + percent - string); /* incl % */
  386.       string = &percent[2];    /* after the second '%' */
  387.       continue;        /* with the while() loop */
  388.     }
  389.       
  390.       left_pad = 0;
  391.       right_pad = 0;
  392.  
  393.       for (p = &percent[1]; /* test *p inside the loop */ ; p++)
  394.     {
  395.       if (*p == ' ')
  396.         {            /* left pad */
  397.           left_pad++;
  398.         }
  399.       else if (*p == '-')
  400.         {            /* right pad */
  401.           right_pad++;
  402.         }
  403.       else if (*p == '1')
  404.         {            /* param and terminator */
  405.           strncat(result, string, percent - string);
  406.           if (value[0] != '\0')
  407.         {
  408.           unsigned i;
  409.           for (i = 0; i < left_pad; i++)
  410.             strcat(result, " ");
  411.           strcat(result, value);
  412.           for (i = 0; i < right_pad; i++)
  413.             strcat(result, " ");
  414.         }
  415.           string = &p[1];    /* after the '1' */
  416.           done++;        /* no need to do old way */
  417.           break;        /* out of for() loop */
  418.         }
  419.       else
  420.         {            /* bogus, copy the format as is */
  421.                 /* out of for() loop */
  422.           strncat(result, string, 1 + p - string);
  423.           string= (*p ? &p[1] : p);
  424.           break;        
  425.         }
  426.     }
  427.     }
  428.  
  429.   /*
  430.    *    Copy the tail of the string
  431.    */
  432.   strcat(result, string);
  433.  
  434.   /*
  435.    *    If we have not processed a % string, and we have a value, tail it.
  436.    */
  437.   if (!done && value[0] != '\0')
  438.     {
  439.       strcat(result, " ");
  440.       strcat(result, value);
  441.     }
  442.  
  443.   return result;
  444. }
  445.  
  446. #ifdef NEED_MOTIF
  447.  
  448. static XmString
  449. resource_widget_value (XlwMenuWidget mw, widget_value *val)
  450. {
  451.   if (!val->toolkit_data)
  452.     {
  453.       char *resourced_name = NULL;
  454.       char *converted_name, *str;
  455.       XmString complete_name;
  456.       char massaged_name [1024];
  457.  
  458.       if (mw->menu.lookup_labels)
  459.     {
  460.       /* Convert value style name into resource style name.
  461.          eg: "Free Willy" becomes "freeWilly" */
  462.       massage_resource_name (val->name, massaged_name);
  463.       
  464.       /* If we have a value (parameter) see if we can find a "Named"
  465.          resource. */
  466.       if (val->value)
  467.         {
  468.           char named_name[1024];
  469.           sprintf(named_name, "%sNamed", massaged_name);
  470.           XtGetSubresources ((Widget) mw,
  471.                  (XtPointer) &resourced_name,
  472.                  named_name, named_name,
  473.                  nameResource, 1, NULL, 0);
  474.         }
  475.  
  476.       /* If nothing yet, try to load from the massaged name. */
  477.       if (!resourced_name)
  478.         {
  479.           XtGetSubresources ((Widget) mw,
  480.                  (XtPointer) &resourced_name,
  481.                  massaged_name, massaged_name,
  482.                  nameResource, 1, NULL, 0);
  483.         }
  484.     } /* if (mw->menu.lookup_labels) */
  485.  
  486.       /* Still nothing yet, use the name as the value. */
  487.       if (!resourced_name)
  488.     resourced_name = val->name;
  489.  
  490.       /* Parameterize the string. */
  491.       converted_name = parameterize_string(resourced_name, val->value);
  492.  
  493.       /* nuke newline characters to prevent menubar screwups */
  494.       for ( str = converted_name ; *str ; str++ )
  495.     {
  496.       if (str[0] == '\n') str[0] = ' ';
  497.     }
  498.  
  499.       /* Improve OSF's bottom line. */
  500.       complete_name = XmStringCreateLtoR (converted_name,
  501.                       XmSTRING_DEFAULT_CHARSET);
  502.       XtFree (converted_name);
  503.  
  504.       val->toolkit_data = complete_name;
  505.       val->free_toolkit_data = True;
  506.     }
  507.   return ((XmString) val->toolkit_data);
  508. }
  509.  
  510. /* Unused */
  511. #if 0
  512. /*
  513.  *    These two routines should be a seperate file..djw
  514.  */
  515. static char *
  516. xlw_create_localized_string (Widget w,
  517.                  char *name,
  518.                  char **args,
  519.                  unsigned nargs)
  520. {
  521.   char *string = NULL;
  522.   char *arg = NULL;
  523.  
  524.   if (nargs > 0)
  525.     arg = args[0];
  526.  
  527.   XtGetSubresources (w,
  528.              (XtPointer)&string,
  529.              name,
  530.              name,
  531.              nameResource, 1,
  532.              NULL, 0
  533.              );
  534.  
  535.   if (!string)
  536.     string = name;
  537.  
  538.   return parameterize_string (string, arg);
  539. }
  540.  
  541. static XmString
  542. xlw_create_localized_xmstring (Widget w,
  543.                    char *name,
  544.                    char **args,
  545.                    unsigned nargs)
  546. {
  547.   char *   string = xlw_create_localized_string (w, name, args, nargs);
  548.   XmString xm_string = XmStringCreateLtoR (string, XmSTRING_DEFAULT_CHARSET);
  549.   XtFree(string);
  550.   return xm_string;
  551. }
  552. #endif /* 0 */
  553.  
  554. #else /* !Motif */
  555.  
  556. static char*
  557. resource_widget_value (XlwMenuWidget mw, widget_value *val)
  558. {
  559.   if (!val->toolkit_data)
  560.     {
  561.       char *resourced_name = NULL;
  562.       char *complete_name;
  563.       char massaged_name [1024];
  564.  
  565.       if (mw->menu.lookup_labels)
  566.     {
  567.       massage_resource_name (val->name, massaged_name);
  568.       
  569.       XtGetSubresources ((Widget) mw,
  570.                  (XtPointer) &resourced_name,
  571.                  massaged_name, massaged_name,
  572.                  nameResource, 1, NULL, 0);
  573.     }
  574.       if (!resourced_name)
  575.     resourced_name = val->name;
  576.  
  577.       complete_name = parameterize_string(resourced_name, val->value);
  578.  
  579.       val->toolkit_data = complete_name;
  580.       /* nuke newline characters to prevent menubar screwups */
  581.       for ( ; *complete_name ; complete_name++ )
  582.     {
  583.       if (complete_name[0] == '\n')
  584.         complete_name[0] = ' ';
  585.     }
  586.       val->free_toolkit_data = True;
  587.     }
  588.   return (char*)val->toolkit_data;
  589. }
  590.  
  591. #endif /* !Motif */
  592.  
  593. /*
  594.  *    Code for drawing strings.
  595.  */
  596. static void
  597. string_draw(
  598.         XlwMenuWidget mw,
  599.         Window window,
  600.         int x, int y,
  601.         GC gc,
  602. #ifdef NEED_MOTIF
  603.         XmString string
  604. #else
  605.         char *string
  606. #endif
  607. ) {
  608. #ifdef NEED_MOTIF
  609.   XmStringDraw (XtDisplay (mw), window,
  610.         mw->menu.font_list,
  611.         string, gc,
  612.         x, y,
  613.         1000,    /* ???? width */
  614.         XmALIGNMENT_BEGINNING,
  615.         0, /* ???? layout_direction */
  616.         0);
  617. #else
  618.   XDrawString (XtDisplay (mw), window, gc,
  619.            x, y + mw->menu.font_ascent, string, strlen (string));
  620.  
  621. #endif
  622. }
  623.  
  624. static void 
  625. binding_draw (XlwMenuWidget mw, Window w, int x, int y, GC gc, char *value)
  626. {
  627. #ifdef NEED_MOTIF
  628.   XmString xm_value = XmStringCreateLtoR(value, XmSTRING_DEFAULT_CHARSET);
  629.   string_draw (mw, w, x, y, gc, xm_value);
  630.   XmStringFree (xm_value);
  631. #else
  632.   string_draw (mw, w, x, y, gc, value);
  633. #endif
  634. }
  635.  
  636. /*
  637.  *    Low level code for drawing 3-D edges.
  638.  */
  639. static void
  640. shadow_rectangle_draw (
  641.                Display *dpy,
  642.                Window window,
  643.                GC top_gc,
  644.                GC bottom_gc,
  645.                int x, int y, unsigned width, unsigned height,
  646.                unsigned thickness
  647.                )
  648. {
  649.   XPoint points [4];
  650.  
  651.   if (!thickness)
  652.     return;
  653.  
  654.   points [0].x = x;
  655.   points [0].y = y;
  656.   points [1].x = x + width;
  657.   points [1].y = y;
  658.   points [2].x = x + width - thickness;
  659.   points [2].y = y + thickness;
  660.   points [3].x = x;
  661.   points [3].y = y + thickness;
  662.   XFillPolygon (dpy, window, top_gc, points, 4, Convex, CoordModeOrigin);
  663.   points [0].x = x;
  664.   points [0].y = y + thickness;
  665.   points [1].x = x;
  666.   points [1].y = y + height;
  667.   points [2].x = x + thickness;
  668.   points [2].y = y + height - thickness;
  669.   points [3].x = x + thickness;
  670.   points [3].y = y + thickness;
  671.   XFillPolygon (dpy, window, top_gc, points, 4, Convex, CoordModeOrigin);
  672.   points [0].x = x + width;
  673.   points [0].y = y;
  674.   points [1].x = x + width - thickness;
  675.   points [1].y = y + thickness;
  676.   points [2].x = x + width - thickness;
  677.   points [2].y = y + height - thickness;
  678.   points [3].x = x + width;
  679.   points [3].y = y + height - thickness;
  680.   XFillPolygon (dpy, window, bottom_gc, points, 4, Convex, CoordModeOrigin);
  681.   points [0].x = x;
  682.   points [0].y = y + height;
  683.   points [1].x = x + width;
  684.   points [1].y = y + height;
  685.   points [2].x = x + width;
  686.   points [2].y = y + height - thickness;
  687.   points [3].x = x + thickness;
  688.   points [3].y = y + height - thickness;
  689.   XFillPolygon (dpy, window, bottom_gc, points, 4, Convex, CoordModeOrigin);
  690. }
  691.  
  692. typedef enum e_shadow_type
  693. {
  694.   /* these are Motif compliant */
  695.   SHADOW_BACKGROUND,
  696.   SHADOW_OUT,
  697.   SHADOW_IN,
  698.   SHADOW_ETCHED_OUT,
  699.   SHADOW_ETCHED_IN,
  700.   SHADOW_ETCHED_OUT_DASH,
  701.   SHADOW_ETCHED_IN_DASH,
  702.   SHADOW_SINGLE_LINE,
  703.   SHADOW_DOUBLE_LINE,
  704.   SHADOW_SINGLE_DASHED_LINE,
  705.   SHADOW_DOUBLE_DASHED_LINE,
  706.   SHADOW_NO_LINE,
  707.   /* these are all non-Motif */
  708.   SHADOW_DOUBLE_ETCHED_OUT,
  709.   SHADOW_DOUBLE_ETCHED_IN,
  710.   SHADOW_DOUBLE_ETCHED_OUT_DASH,
  711.   SHADOW_DOUBLE_ETCHED_IN_DASH
  712. } shadow_type;
  713.  
  714. static void
  715. shadow_draw (XlwMenuWidget mw,
  716.          Window window,
  717.          int x, int y, unsigned width, unsigned height,
  718.          shadow_type type
  719.          )
  720. {
  721.   Display *dpy = XtDisplay (mw);
  722.   GC top_gc;
  723.   GC bottom_gc;
  724.   int thickness = mw->menu.shadow_thickness;
  725. #if 0
  726.   XPoint points [4];
  727. #endif /* 0 */
  728.   Boolean etched = False;
  729.  
  730.   switch (type)
  731.     {
  732.     case SHADOW_BACKGROUND:
  733.       top_gc = bottom_gc = mw->menu.background_gc;
  734.       break;
  735.     case SHADOW_ETCHED_IN:
  736.       top_gc = mw->menu.shadow_bottom_gc;
  737.       bottom_gc = mw->menu.shadow_top_gc;
  738.       etched = True;
  739.       break;
  740.     case SHADOW_ETCHED_OUT:
  741.       top_gc = mw->menu.shadow_top_gc;
  742.       bottom_gc = mw->menu.shadow_bottom_gc;
  743.       etched = True;
  744.       break;
  745.     case SHADOW_IN:
  746.       top_gc = mw->menu.shadow_bottom_gc;
  747.       bottom_gc = mw->menu.shadow_top_gc;
  748.       break;
  749.     case SHADOW_OUT:
  750.     default:
  751.       top_gc = mw->menu.shadow_top_gc;
  752.       bottom_gc = mw->menu.shadow_bottom_gc;
  753.       break;
  754.     }
  755.  
  756.   if (etched)
  757.     {
  758.       unsigned half = thickness/2;
  759.       shadow_rectangle_draw (
  760.                  dpy,
  761.                  window,
  762.                  top_gc,
  763.                  top_gc,
  764.                  x, y,
  765.                  width - half, height - half,
  766.                  thickness - half
  767.                  );
  768.       shadow_rectangle_draw (
  769.                  dpy,
  770.                  window,
  771.                  bottom_gc,
  772.                  bottom_gc,
  773.                  x + half, y + half,
  774.                  width - half , height - half,
  775.                  half
  776.                  );
  777.     }
  778.   else
  779.     {
  780.       shadow_rectangle_draw (
  781.                  dpy,
  782.                  window,
  783.                  top_gc,
  784.                  bottom_gc,
  785.                  x, y,
  786.                  width, height,
  787.                  thickness
  788.                  );
  789.     }
  790. }
  791.  
  792. static void 
  793. arrow_decoration_draw (
  794.                XlwMenuWidget mw,
  795.                Window window,
  796.                int x, int y,
  797.                unsigned width,
  798.                Boolean raised
  799.                )
  800. {
  801.   Display *dpy = XtDisplay (mw);
  802.   GC top_gc;
  803.   GC bottom_gc;
  804.   GC select_gc;
  805.   int thickness = mw->menu.shadow_thickness;
  806.   XPoint points [4];
  807.   int half_width;
  808.   int length = (int)((double)width * 0.87);
  809.   int thick_med = (int)((double)thickness * 1.73);
  810.  
  811.   if (width & 0x1)
  812.     half_width = width/2 + 1;
  813.   else
  814.     half_width = width/2;
  815.   
  816.   select_gc = mw->menu.background_gc;
  817.   
  818.   if (raised)
  819.     {
  820.       top_gc = mw->menu.shadow_bottom_gc;
  821.       bottom_gc = mw->menu.shadow_top_gc;
  822.     }
  823.   else
  824.     {
  825.       top_gc = mw->menu.shadow_top_gc;
  826.       bottom_gc = mw->menu.shadow_bottom_gc;
  827.     }
  828.  
  829.   /*
  830.    *    Fill internal area, we do this first so that the borders
  831.    *    have a nice sharp edge.
  832.    */
  833.   points [0].x = x + thickness;
  834.   points [0].y = y + thickness;
  835.   points [1].x = x + length - thickness;
  836.   points [1].y = y + half_width;
  837.   points [2].x = x + length - thickness;
  838.   points [2].y = y + half_width + thickness;
  839.   points [3].x = x + thickness;
  840.   points [3].y = y + width - thickness;
  841.     
  842.   XFillPolygon (
  843.         dpy,
  844.         window,
  845.         select_gc,
  846.         points,
  847.         4, 
  848.         Convex,
  849.         CoordModeOrigin
  850.         );
  851.  
  852.   /* left border */
  853.   points [0].x = x;
  854.   points [0].y = y;
  855.   points [1].x = x + thickness;
  856.   points [1].y = y + thick_med;
  857.   points [2].x = x + thickness;
  858.   points [2].y = y + width - thick_med;
  859.   points [3].x = x;
  860.   points [3].y = y + width;
  861.   
  862.   XFillPolygon (dpy, window, top_gc, points, 4, Convex, CoordModeOrigin);
  863.  
  864.   /* top border */
  865.   points [0].x = x;
  866.   points [0].y = y + width;
  867.   points [1].x = x + length;
  868.   points [1].y = y + half_width;
  869.   points [2].x = x + length - (thickness + thickness);
  870.   points [2].y = y + half_width;
  871.   points [3].x = x + thickness;
  872.   points [3].y = y + width - thick_med;
  873.   
  874.   XFillPolygon (dpy, window, bottom_gc, points, 4, Convex, CoordModeOrigin);
  875.  
  876.   /* bottom shadow */
  877.   points [0].x = x;
  878.   points [0].y = y;
  879.   points [1].x = x + length;
  880.   points [1].y = y + half_width;
  881.   points [2].x = x + length - (thickness + thickness);
  882.   points [2].y = y + half_width;
  883.   points [3].x = x + thickness;
  884.   points [3].y = y + thick_med;
  885.   
  886.   XFillPolygon (dpy, window, top_gc, points, 4, Convex, CoordModeOrigin);
  887. }
  888.  
  889. static void
  890. toggle_decoration_draw (
  891.             XlwMenuWidget mw,
  892.             Window window,
  893.             int x, int y,
  894.             unsigned width,
  895.             Boolean set
  896.             )
  897. {
  898.   Display *dpy = XtDisplay (mw);
  899.   int thickness = mw->menu.shadow_thickness;
  900.   shadow_type type;
  901.   GC select_gc = mw->menu.select_gc;
  902.  
  903.   if (set)
  904.     type = SHADOW_IN;
  905.   else
  906.     type = SHADOW_OUT;
  907.  
  908.   /*
  909.    *    Fill internal area.
  910.    */
  911.   if (set) 
  912.     XFillRectangle (
  913.             dpy,
  914.             window,
  915.             select_gc,
  916.             x + thickness,
  917.             y + thickness,
  918.             width - (2*thickness),
  919.             width - (2*thickness)
  920.             );
  921.   
  922.   shadow_draw(mw, window, x, y, width, width, type);
  923. }
  924.  
  925. static void
  926. radio_decoration_draw (
  927.                XlwMenuWidget mw,
  928.                Window window,
  929.                int x, int y,
  930.                unsigned width,
  931.                Boolean enabled
  932.                )
  933. {
  934.   Display *dpy = XtDisplay (mw);
  935.   GC top_gc;
  936.   GC bottom_gc;
  937.   GC select_gc = mw->menu.select_gc;
  938.   int thickness = mw->menu.shadow_thickness;
  939.   XPoint points[6];
  940.   int half_width;
  941. #if 0
  942.   int npoints;
  943. #endif /* 0 */
  944.  
  945.   if (width & 0x1)
  946.     width++;
  947.  
  948.   half_width = width/2;
  949.  
  950.   if (enabled)
  951.     {
  952.       top_gc = mw->menu.shadow_bottom_gc;
  953.       bottom_gc = mw->menu.shadow_top_gc;
  954.     }
  955.   else
  956.     {
  957.       top_gc = mw->menu.shadow_top_gc;
  958.       bottom_gc = mw->menu.shadow_bottom_gc;
  959.     }
  960.  
  961. #if 1
  962.   /*
  963.    *    Draw the bottom first, just incase the regions overlap.
  964.    *    The top should cast the longer shadow.
  965.    */
  966.   points [0].x = x; /* left corner */
  967.   points [0].y = y + half_width;
  968.   points [1].x = x + half_width; /* bottom corner */
  969.   points [1].y = y + width;
  970.   points [2].x = x + half_width; /* bottom inside corner */
  971.   points [2].y = y + width - thickness;
  972.   points [3].x = x + thickness; /* left inside corner */
  973.   points [3].y = y + half_width;
  974.  
  975.   XFillPolygon (dpy, window, bottom_gc, points, 4, Convex, CoordModeOrigin);
  976.  
  977.   points [0].x = x + half_width; /* bottom corner */
  978.   points [0].y = y + width;
  979.   points [1].x = x + width; /* right corner */
  980.   points [1].y = y + half_width;
  981.   points [2].x = x + width - thickness; /* right inside corner */
  982.   points [2].y = y + half_width;
  983.   points [3].x = x + half_width; /* bottom inside corner */
  984.   points [3].y = y + width - thickness;
  985.  
  986.   XFillPolygon (dpy, window, bottom_gc, points, 4, Convex, CoordModeOrigin);
  987.  
  988.   points [0].x = x; /* left corner */
  989.   points [0].y = y + half_width;
  990.   points [1].x = x + half_width; /* top corner */
  991.   points [1].y = y;
  992.   points [2].x = x + half_width; /* top inside corner */
  993.   points [2].y = y + thickness;
  994.   points [3].x = x + thickness; /* left inside corner */
  995.   points [3].y = y + half_width;
  996.  
  997.   XFillPolygon (dpy, window, top_gc, points, 4, Convex, CoordModeOrigin);
  998.  
  999.   points [0].x = x + half_width; /* top corner */
  1000.   points [0].y = y;
  1001.   points [1].x = x + width; /* right corner */
  1002.   points [1].y = y + half_width;
  1003.   points [2].x = x + width - thickness; /* right inside corner */
  1004.   points [2].y = y + half_width;
  1005.   points [3].x = x + half_width; /* top inside corner */
  1006.   points [3].y = y + thickness;
  1007.  
  1008.   XFillPolygon (dpy, window, top_gc, points, 4, Convex, CoordModeOrigin);
  1009. #else
  1010.   /*
  1011.    *    Draw the bottom first, just incase the regions overlap.
  1012.    *    The top should cast the longer shadow.
  1013.    */
  1014.   npoints = 0;
  1015.   points [npoints].x = x; /* left corner */
  1016.   points [npoints++].y = y + half_width;
  1017.   points [npoints].x = x + half_width; /* bottom corner */
  1018.   points [npoints++].y = y + width;
  1019.   points [npoints].x = x + width; /* right corner */
  1020.   points [npoints++].y = y + half_width;
  1021.   points [npoints].x = x + width - thickness; /* right inside corner */
  1022.   points [npoints++].y = y + half_width;
  1023.   points [npoints].x = x + half_width; /* bottom inside corner */
  1024.   points [npoints++].y = y + width - thickness;
  1025.   points [npoints].x = x + thickness; /* left inside corner */
  1026.   points [npoints++].y = y + half_width;
  1027.  
  1028.   XFillPolygon (dpy, window, bottom_gc, 
  1029.         points, npoints, Nonconvex, CoordModeOrigin);
  1030.  
  1031.   npoints = 0;
  1032.  
  1033.   points [npoints].x = x; /* left corner */
  1034.   points [npoints++].y = y + half_width;
  1035.   points [npoints].x = x + half_width; /* top corner */
  1036.   points [npoints++].y = y;
  1037.   points [npoints].x = x + width; /* right corner */
  1038.   points [npoints++].y = y + half_width;
  1039.   points [npoints].x = x + width - thickness; /* right inside corner */
  1040.   points [npoints++].y = y + half_width;
  1041.   points [npoints].x = x + half_width; /* top inside corner */
  1042.   points [npoints++].y = y + thickness;
  1043.   points [npoints].x = x + thickness; /* left inside corner */
  1044.   points [npoints++].y = y + half_width;
  1045.  
  1046.   XFillPolygon (dpy, window, top_gc, points, npoints, Nonconvex,
  1047.         CoordModeOrigin);
  1048. #endif
  1049.  
  1050.  
  1051.   /*
  1052.    *    Fill internal area.
  1053.    */
  1054.   if (enabled)
  1055.     {
  1056.       points [0].x = x + thickness;
  1057.       points [0].y = y + half_width;
  1058.       points [1].x = x + half_width;
  1059.       points [1].y = y + thickness;
  1060.       points [2].x = x + width - thickness;
  1061.       points [2].y = y + half_width;
  1062.       points [3].x = x + half_width;
  1063.       points [3].y = y + width - thickness;
  1064.       XFillPolygon (dpy,
  1065.             window,
  1066.             select_gc,
  1067.             points,
  1068.             4, 
  1069.             Convex,
  1070.             CoordModeOrigin
  1071.             );
  1072.     }
  1073. }
  1074.  
  1075. static void
  1076. separator_decoration_draw (
  1077.                XlwMenuWidget mw,
  1078.                Window window,
  1079.                int x, int y,
  1080.                unsigned width,
  1081.                Boolean vertical,
  1082.                shadow_type type
  1083.                )
  1084. {
  1085.   Display *dpy = XtDisplay (mw);
  1086.   GC top_gc;
  1087.   GC bottom_gc;
  1088.   unsigned offset = 0;
  1089.   unsigned num_separators = 1;
  1090.   unsigned top_line_thickness = 0;
  1091.   unsigned bottom_line_thickness = 0;
  1092.   Boolean dashed = False;
  1093.   int i;
  1094.  
  1095.   switch (type)
  1096.     {
  1097.     case SHADOW_NO_LINE: /* nothing to do */
  1098.       return; 
  1099.     case SHADOW_DOUBLE_LINE:
  1100.       num_separators = 2;
  1101.     case SHADOW_SINGLE_LINE:
  1102.       top_gc = bottom_gc = mw->menu.foreground_gc;
  1103.       top_line_thickness = 1;
  1104.       break;
  1105.     case SHADOW_DOUBLE_DASHED_LINE:
  1106.       num_separators = 2;
  1107.     case SHADOW_SINGLE_DASHED_LINE:
  1108.       top_gc = bottom_gc = mw->menu.foreground_gc;
  1109.       top_line_thickness = 1;
  1110.       dashed = True;
  1111.       break;
  1112.     case SHADOW_DOUBLE_ETCHED_OUT_DASH:
  1113.       num_separators = 2;
  1114.     case SHADOW_ETCHED_OUT_DASH:
  1115.       top_gc = mw->menu.shadow_top_gc;
  1116.       bottom_gc = mw->menu.shadow_bottom_gc;
  1117.       top_line_thickness = mw->menu.shadow_thickness/2;
  1118.       bottom_line_thickness = mw->menu.shadow_thickness - top_line_thickness;
  1119.       dashed = True;
  1120.       break;
  1121.     case SHADOW_DOUBLE_ETCHED_IN_DASH:
  1122.       num_separators = 2;
  1123.     case SHADOW_ETCHED_IN_DASH:
  1124.       top_gc = mw->menu.shadow_bottom_gc;
  1125.       bottom_gc = mw->menu.shadow_top_gc;
  1126.       top_line_thickness = mw->menu.shadow_thickness/2;
  1127.       bottom_line_thickness = mw->menu.shadow_thickness - top_line_thickness;
  1128.       dashed = True;
  1129.       break;
  1130.     case SHADOW_DOUBLE_ETCHED_OUT:
  1131.       num_separators = 2;
  1132.     case SHADOW_ETCHED_OUT:
  1133.       top_gc = mw->menu.shadow_top_gc;
  1134.       bottom_gc = mw->menu.shadow_bottom_gc;
  1135.       top_line_thickness = mw->menu.shadow_thickness/2;
  1136.       bottom_line_thickness = mw->menu.shadow_thickness - top_line_thickness;
  1137.       break;
  1138.     case SHADOW_DOUBLE_ETCHED_IN:
  1139.       num_separators = 2;
  1140.     case SHADOW_ETCHED_IN:
  1141.     default:
  1142.       top_gc = mw->menu.shadow_bottom_gc;
  1143.       bottom_gc = mw->menu.shadow_top_gc;
  1144.       top_line_thickness = mw->menu.shadow_thickness/2;
  1145.       bottom_line_thickness = mw->menu.shadow_thickness - top_line_thickness;
  1146.       break;
  1147.     }
  1148.  
  1149.   if (dashed)
  1150.     {
  1151.       XGCValues values;
  1152.       values.line_style = LineOnOffDash;
  1153.       if (top_line_thickness > 0)
  1154.     XChangeGC (dpy, top_gc, GCLineStyle, &values);
  1155.       if (bottom_line_thickness > 0 && bottom_gc != top_gc)
  1156.     XChangeGC (dpy, bottom_gc, GCLineStyle, &values);
  1157.     }
  1158.   
  1159.   while (num_separators--)
  1160.     {
  1161.       for (i = 0; i < top_line_thickness; i++)
  1162.     XDrawLine (dpy, window, top_gc, x, y + i, x + width, y + i);
  1163.       
  1164.       for (i = 0; i < bottom_line_thickness; i++)
  1165.     XDrawLine (
  1166.            dpy, window, bottom_gc, 
  1167.            x, y + top_line_thickness + offset + i,
  1168.            x + width, y + top_line_thickness + offset + i
  1169.            );
  1170.       y += (top_line_thickness + offset + bottom_line_thickness + 1);
  1171.     }
  1172.  
  1173.   if (dashed)
  1174.     {
  1175.       XGCValues values;
  1176.       values.line_style = LineSolid;
  1177.       if (top_line_thickness > 0)
  1178.     XChangeGC (dpy, top_gc, GCLineStyle, &values);
  1179.       if (bottom_line_thickness > 0 && bottom_gc != top_gc)
  1180.     XChangeGC (dpy, bottom_gc, GCLineStyle, &values);
  1181.     }
  1182. }
  1183.  
  1184. #define SLOPPY_TYPES 0        /* 0=off, 1=error check, 2=easy to please */
  1185. #if SLOPPY_TYPES
  1186. #if SLOPPY_TYPES < 2
  1187.  
  1188. static char *wv_types[] =
  1189. {
  1190.   "UNSPECIFIED",
  1191.   "BUTTON",
  1192.   "TOGGLE",
  1193.   "RADIO",
  1194.   "TEXT",
  1195.   "SEPARATOR",
  1196.   "CASCADE",
  1197.   "PUSHRIGHT",
  1198.   "INCREMENTAL"
  1199. };
  1200.  
  1201. static void
  1202. print_widget_value (widget_value *wv, int just_one, int depth)
  1203. {
  1204.   char d [200];
  1205.   int i;
  1206.   for (i = 0; i < depth; i++) d[i] = ' ';
  1207.   d[depth]=0;
  1208.   if (!wv)
  1209.     {
  1210.       printf ("%s(null widget value pointer)\n", d);
  1211.       return;
  1212.     }
  1213.   printf ("%stype:    %s\n", d, wv_types [wv->type]);
  1214. #if 0
  1215.   printf ("%sname:    %s\n", d, (wv->name ? wv->name : "(null)"));
  1216. #else
  1217.   if (wv->name)  printf ("%sname:    %s\n", d, wv->name);
  1218. #endif
  1219.   if (wv->value) printf ("%svalue:   %s\n", d, wv->value);
  1220.   if (wv->key)   printf ("%skey:     %s\n", d, wv->key);
  1221.   printf ("%senabled: %d\n", d, wv->enabled);
  1222.   if (wv->contents)
  1223.     {
  1224.       printf ("\n%scontents: \n", d);
  1225.       print_widget_value (wv->contents, 0, depth + 5);
  1226.     }
  1227.   if (!just_one && wv->next)
  1228.     {
  1229.       printf ("\n");
  1230.       print_widget_value (wv->next, 0, depth);
  1231.     }
  1232. }
  1233. #endif
  1234.  
  1235. static Boolean
  1236. all_dashes_p (char *s)
  1237. {
  1238.   char *p;
  1239.   if (!s || s[0] == '\0')
  1240.     return False;
  1241.   for (p = s; *p == '-'; p++);
  1242.  
  1243.   if (*p == '!' || *p == '\0')
  1244.     return True;
  1245.   return False;
  1246. }
  1247. #endif
  1248.  
  1249. static widget_value_type
  1250. menu_item_type (widget_value *val)
  1251. {
  1252.   if (val->type != UNSPECIFIED_TYPE)
  1253.     return val->type;
  1254.   else
  1255.     {
  1256. #if SLOPPY_TYPES
  1257.       if (all_dashes_p(val->name))
  1258.     return SEPARATOR_TYPE;
  1259.       else if (val->name && val->name[0] == '\0') /* push right */
  1260.     return PUSHRIGHT_TYPE;
  1261.       else if (val->contents) /* cascade */
  1262.     return CASCADE_TYPE;
  1263.       else if (val->call_data) /* push button */
  1264.     return BUTTON_TYPE;
  1265.       else
  1266.     return TEXT_TYPE;
  1267. #else 
  1268.     abort();
  1269. #endif 
  1270.     }
  1271. }
  1272.  
  1273. static void
  1274. label_button_size (
  1275.            XlwMenuWidget mw,
  1276.            widget_value *val,
  1277.            Boolean in_menubar,
  1278.            unsigned *toggle_width,
  1279.            unsigned *label_width,
  1280.            unsigned *bindings_width,
  1281.            unsigned *height
  1282.            )
  1283. {
  1284.   *height = (mw->menu.font_ascent + mw->menu.font_descent +
  1285.          2 * mw->menu.vertical_margin +
  1286.          2 * mw->menu.shadow_thickness);
  1287.   /* no left column decoration */
  1288.   *toggle_width = mw->menu.horizontal_margin + mw->menu.shadow_thickness;;
  1289.   
  1290.   *label_width  = string_width (mw, resource_widget_value (mw, val));
  1291.   *bindings_width =  mw->menu.horizontal_margin + mw->menu.shadow_thickness;
  1292. }
  1293.  
  1294. static void
  1295. label_button_draw (
  1296.            XlwMenuWidget mw, 
  1297.            widget_value *val,
  1298.            Boolean       in_menubar,
  1299.            Boolean       highlighted,
  1300.            Window        window, 
  1301.            int x, int y, 
  1302.            unsigned width,
  1303.            unsigned height,
  1304.            unsigned label_offset,
  1305.            unsigned binding_tab
  1306.            )
  1307. {
  1308.   int y_offset = mw->menu.shadow_thickness + mw->menu.vertical_margin;
  1309.   
  1310.   if (!label_offset)
  1311.     label_offset = mw->menu.shadow_thickness + mw->menu.horizontal_margin;
  1312.  
  1313.   /*
  1314.    *    Draw the label string.
  1315.    */
  1316.   string_draw (
  1317.            mw,
  1318.            window,
  1319.            x + label_offset, y + y_offset, 
  1320.            mw->menu.foreground_gc,
  1321.            resource_widget_value (mw, val)
  1322.            );
  1323. }
  1324.  
  1325. static void
  1326. push_button_size (
  1327.           XlwMenuWidget mw,
  1328.           widget_value *val,
  1329.           Boolean in_menubar,
  1330.           unsigned *toggle_width,
  1331.           unsigned *label_width,
  1332.           unsigned *bindings_width,
  1333.           unsigned *height
  1334.           )
  1335. {
  1336.   /* inherit */
  1337.   label_button_size (
  1338.              mw, val, in_menubar,
  1339.              toggle_width, label_width, bindings_width,
  1340.              height
  1341.              );
  1342.   
  1343.   /* key bindings to display? */
  1344.   if (!in_menubar && val->key)
  1345.     {
  1346.       int w;
  1347. #ifdef NEED_MOTIF
  1348.       XmString key = XmStringCreateLtoR (val->key, XmSTRING_DEFAULT_CHARSET);
  1349.       w = string_width(mw, key);
  1350.       XmStringFree (key);
  1351. #else
  1352.       char *key = val->key;
  1353.       w = string_width (mw, key);
  1354. #endif
  1355.       *bindings_width += w + mw->menu.column_spacing;
  1356.     }
  1357. }
  1358.  
  1359. static void
  1360. push_button_draw (
  1361.           XlwMenuWidget mw, 
  1362.           widget_value *val,
  1363.           Boolean       in_menubar,
  1364.           Boolean       highlighted,
  1365.           Window        window, 
  1366.           int x, int y, 
  1367.           unsigned width, unsigned height,
  1368.           unsigned      label_offset,
  1369.           unsigned      binding_offset
  1370.           )
  1371. {
  1372.   int y_offset = mw->menu.shadow_thickness + mw->menu.vertical_margin;
  1373.   GC gc;
  1374.   shadow_type type;
  1375.   Boolean menu_pb = in_menubar && (menu_item_type (val) == BUTTON_TYPE);
  1376.   
  1377.   /*
  1378.    *    Draw the label string.
  1379.    */
  1380.   if (!label_offset)
  1381.     label_offset = mw->menu.shadow_thickness + mw->menu.horizontal_margin;
  1382.   
  1383.   if (menu_pb)
  1384.     {
  1385.       if (val->enabled)
  1386.     gc = mw->menu.button_gc;
  1387.       else
  1388.     gc = mw->menu.inactive_button_gc;
  1389.     }
  1390.   else
  1391.     {
  1392.       if (val->enabled)
  1393.     gc = mw->menu.foreground_gc;
  1394.       else
  1395.     gc = mw->menu.inactive_gc;
  1396.     }
  1397.  
  1398.   string_draw (
  1399.            mw,
  1400.            window,
  1401.            x + label_offset, y + y_offset, 
  1402.            gc,
  1403.            resource_widget_value(mw, val)
  1404.            );
  1405.   
  1406.   /*
  1407.    *    Draw the keybindings
  1408.    */
  1409.   if (val->key)
  1410.     {
  1411.       if (!binding_offset)
  1412.     {
  1413.       unsigned s_width = string_width (mw, resource_widget_value(mw, val));
  1414.       binding_offset = label_offset + s_width +  mw->menu.shadow_thickness;
  1415.     }
  1416.       binding_draw (mw, window,
  1417.             x + binding_offset + mw->menu.column_spacing,
  1418.             y + y_offset, gc, val->key);
  1419.     }
  1420.   
  1421.   /*
  1422.    *    Draw the shadow
  1423.    */
  1424.   if (menu_pb)
  1425.     {
  1426.       if (highlighted)
  1427.     type = SHADOW_OUT;
  1428.       else 
  1429.     type = (val->selected ? SHADOW_ETCHED_OUT : SHADOW_ETCHED_IN);
  1430.     }
  1431.   else
  1432.     {
  1433.       if (highlighted)
  1434.     type = SHADOW_OUT;
  1435.       else 
  1436.     type = SHADOW_BACKGROUND;
  1437.     }
  1438.  
  1439.   shadow_draw (mw, window, x, y, width, height, type);
  1440. }
  1441.  
  1442. static unsigned int
  1443. arrow_decoration_height (XlwMenuWidget mw)
  1444. {
  1445.   unsigned int result =
  1446.     (mw->menu.font_ascent + mw->menu.font_descent) / (unsigned int)2;
  1447.   
  1448.   result += 2 * mw->menu.shadow_thickness;
  1449.  
  1450.   if (result > (mw->menu.font_ascent + mw->menu.font_descent))
  1451.     result = mw->menu.font_ascent + mw->menu.font_descent;
  1452.  
  1453.   return result;
  1454. }
  1455.  
  1456. static void
  1457. cascade_button_size (
  1458.              XlwMenuWidget mw,
  1459.              widget_value *val,
  1460.              Boolean in_menubar,
  1461.              unsigned *toggle_width,
  1462.              unsigned *label_width,
  1463.              unsigned *arrow_width,
  1464.              unsigned *height
  1465.              )
  1466. {
  1467.   /* inherit */
  1468.   label_button_size (
  1469.              mw, val, in_menubar,
  1470.              toggle_width, label_width, arrow_width,
  1471.              height
  1472.              );
  1473.   /* we have a pull aside arrow */
  1474.   if (!in_menubar)
  1475.     {
  1476.       *arrow_width += arrow_decoration_height(mw) + mw->menu.column_spacing;
  1477.     }
  1478. }
  1479.  
  1480. static void
  1481. cascade_button_draw (
  1482.              XlwMenuWidget mw, 
  1483.              widget_value *val,
  1484.              Boolean       in_menubar,
  1485.              Boolean       highlighted,
  1486.              Window        window, 
  1487.              int x, int y, 
  1488.              unsigned width, unsigned height,
  1489.              unsigned      label_offset,
  1490.              unsigned      binding_offset
  1491.              )
  1492. {
  1493.   shadow_type type;
  1494.  
  1495.   /*
  1496.    *    Draw the label string.
  1497.    */
  1498.   label_button_draw (mw, val, in_menubar, highlighted,
  1499.              window, x, y, width, height, label_offset,
  1500.              binding_offset);
  1501.  
  1502.   /*
  1503.    *    Draw the pull aside arrow
  1504.    */
  1505.   if (!in_menubar && val->contents)
  1506.     {
  1507.       int y_offset;
  1508.       unsigned arrow_height = arrow_decoration_height (mw);
  1509.       
  1510.       y_offset = mw->menu.shadow_thickness + mw->menu.vertical_margin +
  1511.     (mw->menu.font_ascent+mw->menu.font_descent - arrow_height)/2;
  1512.       
  1513.       if (!binding_offset)
  1514.     {
  1515.       unsigned s_width = string_width(mw, resource_widget_value (mw, val));
  1516.       
  1517.       if (!label_offset)
  1518.         label_offset = mw->menu.shadow_thickness +
  1519.           mw->menu.horizontal_margin;
  1520.       
  1521.       binding_offset = label_offset + s_width +  mw->menu.shadow_thickness;
  1522.     }
  1523.       
  1524.       arrow_decoration_draw (
  1525.                  mw,
  1526.                  window,
  1527.                  x + binding_offset + mw->menu.column_spacing,
  1528.                  y + y_offset,
  1529.                  arrow_height,
  1530.                  highlighted
  1531.                  );
  1532.     }
  1533.   
  1534.   /*
  1535.    *    Draw the shadow
  1536.    */
  1537.   if (highlighted)
  1538.     type = SHADOW_OUT;
  1539.   else
  1540.     type = SHADOW_BACKGROUND;
  1541.   
  1542.   shadow_draw(mw, window, x, y, width, height, type);
  1543. }
  1544.  
  1545. static unsigned
  1546. toggle_decoration_height(XlwMenuWidget mw)
  1547. {
  1548.   unsigned rv;
  1549.   if (mw->menu.indicator_size > 0)
  1550.     rv = mw->menu.indicator_size;
  1551.   else
  1552.     rv = mw->menu.font_ascent;
  1553.   
  1554.   if (rv > (mw->menu.font_ascent+mw->menu.font_descent))
  1555.     rv = mw->menu.font_ascent+mw->menu.font_descent;
  1556.   
  1557.   return rv;
  1558. }
  1559.  
  1560. static void
  1561. toggle_button_size (
  1562.             XlwMenuWidget mw,
  1563.             widget_value *val,
  1564.             Boolean in_menubar,
  1565.             unsigned *toggle_width,
  1566.             unsigned *label_width,
  1567.             unsigned *bindings_width,
  1568.             unsigned *height
  1569.             )
  1570. {
  1571.   /* inherit */
  1572.   push_button_size (
  1573.             mw, val, in_menubar,
  1574.             toggle_width, label_width, bindings_width,
  1575.             height
  1576.             );
  1577.   /* we have a toggle */
  1578.   *toggle_width += toggle_decoration_height(mw) + mw->menu.column_spacing;
  1579. }
  1580.  
  1581. static void
  1582. toggle_button_draw (
  1583.             XlwMenuWidget mw, 
  1584.             widget_value *val,
  1585.             Boolean       in_menubar,
  1586.             Boolean highlighted,
  1587.             Window        window, 
  1588.             int x, int y, 
  1589.             unsigned width, unsigned height,
  1590.             unsigned      label_tab,
  1591.             unsigned      binding_tab
  1592.             )
  1593. {
  1594.   int x_offset;
  1595.   int y_offset;
  1596.   unsigned t_height = toggle_decoration_height(mw);
  1597.   
  1598.   /*
  1599.    *    Draw a toggle.
  1600.    */
  1601.   x_offset = mw->menu.shadow_thickness + mw->menu.horizontal_margin;
  1602.   y_offset = mw->menu.shadow_thickness + mw->menu.vertical_margin;
  1603.   y_offset += (mw->menu.font_ascent + mw->menu.font_descent - t_height)/2;
  1604.   
  1605.   toggle_decoration_draw (mw, window, x + x_offset, y + y_offset,
  1606.               t_height, val->selected);
  1607.  
  1608.   /*
  1609.    *    Draw the pushbutton parts.
  1610.    */
  1611.   push_button_draw (mw, val, in_menubar, highlighted, window, x, y, width,
  1612.             height, label_tab, binding_tab);
  1613. }
  1614.  
  1615. static unsigned
  1616. radio_decoration_height(XlwMenuWidget mw)
  1617. {
  1618.   return toggle_decoration_height(mw);
  1619. }
  1620.  
  1621. static void
  1622. radio_button_draw (
  1623.            XlwMenuWidget mw, 
  1624.            widget_value *val,
  1625.            Boolean       in_menubar,
  1626.            Boolean       highlighted,
  1627.            Window        window, 
  1628.            int x, int y, 
  1629.            unsigned width, unsigned height,
  1630.            unsigned      label_tab,
  1631.            unsigned      binding_tab
  1632.            )
  1633. {
  1634.   int x_offset;
  1635.   int y_offset;
  1636.   unsigned r_height = radio_decoration_height(mw);
  1637.   
  1638.   /*
  1639.    *    Draw a toggle.
  1640.    */
  1641.   x_offset = mw->menu.shadow_thickness + mw->menu.horizontal_margin;
  1642.   y_offset = mw->menu.shadow_thickness + mw->menu.vertical_margin;
  1643.   y_offset += (mw->menu.font_ascent + mw->menu.font_descent - r_height)/2;
  1644.  
  1645.   radio_decoration_draw (mw, window, x + x_offset, y + y_offset, r_height,
  1646.              val->selected);
  1647.  
  1648.   /*
  1649.    *    Draw the pushbutton parts.
  1650.    */
  1651.   push_button_draw (mw, val, in_menubar, highlighted, window, x, y, width,
  1652.             height, label_tab, binding_tab);
  1653. }
  1654.  
  1655. static struct _shadow_names
  1656. {
  1657.   char *      name;
  1658.   shadow_type type;
  1659. } shadow_names[] =
  1660. {
  1661.   /* Motif */
  1662.   { "singleLine", SHADOW_SINGLE_LINE },
  1663.   { "doubleLine", SHADOW_DOUBLE_LINE },
  1664.   { "singleDashedLine", SHADOW_SINGLE_DASHED_LINE },
  1665.   { "doubleDashedLine", SHADOW_DOUBLE_DASHED_LINE },
  1666.   { "noLine", SHADOW_NO_LINE },
  1667.   { "shadowEtchedIn", SHADOW_ETCHED_IN },
  1668.   { "shadowEtchedOut", SHADOW_ETCHED_OUT },
  1669.   { "shadowEtchedInDash", SHADOW_ETCHED_IN_DASH },
  1670.   { "shadowEtchedOutDash", SHADOW_ETCHED_OUT_DASH },
  1671.   /* non-Motif */
  1672.   { "shadowDoubleEtchedIn", SHADOW_DOUBLE_ETCHED_IN },
  1673.   { "shadowDoubleEtchedOut", SHADOW_DOUBLE_ETCHED_OUT },
  1674.   { "shadowDoubleEtchedInDash", SHADOW_DOUBLE_ETCHED_IN_DASH },
  1675.   { "shadowDoubleEtchedOutDash", SHADOW_DOUBLE_ETCHED_OUT_DASH }
  1676. };
  1677.  
  1678. static shadow_type
  1679. separator_type (char *name)
  1680. {
  1681.   int i;
  1682.  
  1683.   if (name)
  1684.     {
  1685.       for (i = 0; i < XtNumber(shadow_names); i++ )
  1686.     {
  1687.       if (strcmp (name, shadow_names[i].name) == 0)
  1688.         return shadow_names[i].type;
  1689.     }
  1690.     }
  1691.   return SHADOW_BACKGROUND;
  1692. }
  1693.  
  1694. static unsigned
  1695. separator_decoration_height (XlwMenuWidget mw, widget_value *val)
  1696. {
  1697.  
  1698.   switch (separator_type(val->value))
  1699.     {
  1700.     case SHADOW_NO_LINE:
  1701.     case SHADOW_SINGLE_LINE:
  1702.     case SHADOW_SINGLE_DASHED_LINE:
  1703.       return 1;
  1704.     case SHADOW_DOUBLE_LINE:
  1705.     case SHADOW_DOUBLE_DASHED_LINE:
  1706.       return 3;
  1707.     case SHADOW_DOUBLE_ETCHED_OUT:
  1708.     case SHADOW_DOUBLE_ETCHED_IN:
  1709.     case SHADOW_DOUBLE_ETCHED_OUT_DASH:
  1710.     case SHADOW_DOUBLE_ETCHED_IN_DASH:
  1711.       return (1 + 2 * mw->menu.shadow_thickness);
  1712.     case SHADOW_ETCHED_OUT:
  1713.     case SHADOW_ETCHED_IN:
  1714.     default:
  1715.       return mw->menu.shadow_thickness;
  1716.     }
  1717. }
  1718.  
  1719. static void
  1720. separator_size (XlwMenuWidget mw,
  1721.         widget_value *val,
  1722.         Boolean in_menubar,
  1723.         unsigned *toggle_width,
  1724.         unsigned *label_width,
  1725.         unsigned *rest_width,
  1726.         unsigned *height
  1727.         )
  1728. {
  1729.   *height = separator_decoration_height (mw, val);
  1730.   *label_width = 1;
  1731.   *toggle_width = *rest_width = 0;
  1732. }
  1733.  
  1734. static void
  1735. separator_draw (XlwMenuWidget mw, 
  1736.         widget_value *val,
  1737.         Boolean       in_menubar,
  1738.         Boolean       highlighted,
  1739.         Window        window, 
  1740.         int x, int y, 
  1741.         unsigned width, unsigned height,
  1742.         unsigned      label_tab,
  1743.         unsigned      binding_tab
  1744.         )
  1745. {
  1746.   unsigned sep_width;
  1747.  
  1748.   if (in_menubar)
  1749.     sep_width = height;
  1750.   else
  1751.     sep_width = width;
  1752.  
  1753.   separator_decoration_draw (mw,
  1754.                  window,
  1755.                  x,
  1756.                  y,
  1757.                  sep_width,
  1758.                  in_menubar,
  1759.                  separator_type(val->value)
  1760.                  );
  1761. }
  1762.  
  1763. static void
  1764. pushright_size (XlwMenuWidget mw,
  1765.         widget_value *val,
  1766.         Boolean in_menubar,
  1767.         unsigned *toggle_width,
  1768.         unsigned *label_width,
  1769.         unsigned *rest_width,
  1770.         unsigned *height
  1771. )
  1772. {
  1773.   *height = *label_width = *toggle_width = *rest_width = 0;
  1774. }
  1775.  
  1776. static void
  1777. size_menu_item (XlwMenuWidget mw,
  1778.         widget_value *val,
  1779.         int horizontal,
  1780.         unsigned *toggle_width,
  1781.         unsigned *label_width,
  1782.         unsigned *rest_width,
  1783.         unsigned *height
  1784. )
  1785. {
  1786.  
  1787.   void (*function_ptr) (
  1788.             XlwMenuWidget mw,
  1789.             widget_value *val,
  1790.             Boolean in_menubar,
  1791.             unsigned *toggle_width,
  1792.             unsigned *label_width,
  1793.             unsigned *rest_width,
  1794.             unsigned *height
  1795.             );
  1796.   switch (menu_item_type (val))
  1797.     {
  1798.     case TOGGLE_TYPE:
  1799.     case RADIO_TYPE:
  1800.       function_ptr = toggle_button_size;
  1801.       break;
  1802.     case SEPARATOR_TYPE:
  1803.       function_ptr = separator_size;
  1804.       break;
  1805.     case INCREMENTAL_TYPE:
  1806.     case CASCADE_TYPE:
  1807.       function_ptr = cascade_button_size;
  1808.       break;
  1809.     case BUTTON_TYPE:
  1810.       function_ptr = push_button_size;
  1811.       break;
  1812.     case PUSHRIGHT_TYPE:
  1813.       function_ptr = pushright_size;
  1814.       break;
  1815.     case TEXT_TYPE:
  1816.     default:
  1817.       function_ptr = label_button_size;
  1818.       break;
  1819.     }
  1820.  
  1821.   (*function_ptr) (
  1822.            mw,
  1823.            val,
  1824.            horizontal,
  1825.            toggle_width,
  1826.            label_width,
  1827.            rest_width,
  1828.            height
  1829.            );
  1830. }
  1831.  
  1832. static void
  1833. display_menu_item (
  1834.            XlwMenuWidget mw,
  1835.            widget_value *val,
  1836.            window_state *ws,
  1837.            XPoint *where,
  1838.            Boolean highlighted,
  1839.            Boolean horizontal,
  1840.            Boolean just_compute
  1841.            )
  1842. {
  1843.   
  1844.   int x = where->x /* + mw->menu.shadow_thickness */ ;
  1845.   int y = where->y /* + mw->menu.shadow_thickness */ ;
  1846.   unsigned toggle_width;
  1847.   unsigned label_width;
  1848.   unsigned binding_width;
  1849.   unsigned width;
  1850.   unsigned height;
  1851.   unsigned label_tab;
  1852.   unsigned binding_tab;
  1853.   void (*function_ptr) (
  1854.             XlwMenuWidget mw,
  1855.             widget_value *val,
  1856.             Boolean in_menubar,
  1857.             Boolean highlighted,
  1858.             Window        window, 
  1859.             int x, int y, 
  1860.             unsigned width, unsigned height,
  1861.             unsigned      label_tab,
  1862.             unsigned      binding_tab
  1863.             );
  1864.  
  1865.   size_menu_item (
  1866.           mw, val, horizontal,
  1867.           &toggle_width, &label_width, &binding_width, &height
  1868.           );
  1869.  
  1870.   if (horizontal)
  1871.     {
  1872.       width = toggle_width + label_width + binding_width;
  1873.       height = ws->height - 2 * mw->menu.shadow_thickness;
  1874.     }
  1875.   else
  1876.     {
  1877.       width = ws->width - 2 * mw->menu.shadow_thickness;
  1878.       toggle_width = ws->toggle_width;
  1879.       label_width = ws->label_width;
  1880.     }
  1881.   
  1882.   where->x += width;
  1883.   where->y += height;
  1884.   
  1885.   if (just_compute)
  1886.     return;
  1887.   
  1888.   label_tab = toggle_width;
  1889.   binding_tab = toggle_width + label_width;
  1890.  
  1891.   switch (menu_item_type (val))
  1892.     {
  1893.     case TOGGLE_TYPE:
  1894.       function_ptr = toggle_button_draw;
  1895.       break;
  1896.     case RADIO_TYPE:
  1897.       function_ptr = radio_button_draw;
  1898.       break;
  1899.     case SEPARATOR_TYPE:
  1900.       function_ptr = separator_draw;
  1901.       break;
  1902.     case INCREMENTAL_TYPE:
  1903.     case CASCADE_TYPE:
  1904.       function_ptr = cascade_button_draw;
  1905.       break;
  1906.     case BUTTON_TYPE:
  1907.       function_ptr = push_button_draw;
  1908.       break;
  1909.     case TEXT_TYPE:
  1910.       function_ptr = label_button_draw;
  1911.       break;
  1912.     default: /* do no drawing */
  1913.       return;
  1914.     }
  1915.  
  1916.   (*function_ptr) (
  1917.            mw,
  1918.            val,
  1919.            horizontal,
  1920.            highlighted,
  1921.            ws->window, 
  1922.            x, y, 
  1923.            width, height,
  1924.            label_tab,
  1925.            binding_tab
  1926.            );
  1927. }
  1928.  
  1929. static void
  1930. size_menu (XlwMenuWidget mw, int level)
  1931. {
  1932.   unsigned      toggle_width;
  1933.   unsigned    label_width;
  1934.   unsigned    rest_width;
  1935.   unsigned    height;
  1936.   unsigned    max_toggle_width = 0;
  1937.   unsigned    max_label_width = 0;
  1938.   unsigned    max_rest_width = 0;
  1939.   unsigned    max_height = 0;
  1940.   int        horizontal_p = mw->menu.horizontal && (level == 0);
  1941.   widget_value*    val;
  1942.   window_state*    ws;
  1943.  
  1944.   if (level >= mw->menu.old_depth)
  1945.     abort ();
  1946.  
  1947.   ws = &mw->menu.windows [level];  
  1948.  
  1949.   for (val = mw->menu.old_stack [level]->contents; val; val = val->next)
  1950.     {
  1951.       size_menu_item (
  1952.               mw,
  1953.               val,
  1954.               horizontal_p,
  1955.               &toggle_width,
  1956.               &label_width,
  1957.               &rest_width,
  1958.               &height
  1959.               );
  1960.       if (horizontal_p)
  1961.     {
  1962.       max_label_width += toggle_width + label_width + rest_width;
  1963.       if (height > max_height)
  1964.         max_height = height;
  1965.     }
  1966.       else
  1967.     {
  1968.       if (toggle_width > max_toggle_width)
  1969.         max_toggle_width = toggle_width;
  1970.       if (label_width > max_label_width)
  1971.         max_label_width = label_width;
  1972.       if (rest_width > max_rest_width)
  1973.         max_rest_width = rest_width;
  1974.       max_height += height;
  1975.     }
  1976.     }
  1977.   
  1978.   ws->height = max_height;
  1979.   ws->width = max_label_width + max_rest_width + max_toggle_width;
  1980.   ws->toggle_width = max_toggle_width;
  1981.   ws->label_width = max_label_width;
  1982.  
  1983.   ws->width += 2 * mw->menu.shadow_thickness;
  1984.   ws->height += 2 * mw->menu.shadow_thickness;
  1985. }
  1986.  
  1987. static void
  1988. display_menu (XlwMenuWidget mw, int level, Boolean just_compute_p,
  1989.           XPoint *highlighted_pos, XPoint *hit, widget_value **hit_return,
  1990.           widget_value *this, widget_value *that)
  1991. {
  1992.   widget_value *val;
  1993.   widget_value *following_item;
  1994.   window_state *ws;
  1995.   XPoint    where;
  1996.   int horizontal_p = mw->menu.horizontal && (level == 0);
  1997.   int highlighted_p;
  1998.   int just_compute_this_one_p;
  1999.  
  2000.   if (level >= mw->menu.old_depth)
  2001.     abort ();
  2002.  
  2003.   if (level < mw->menu.old_depth - 1)
  2004.     following_item = mw->menu.old_stack [level + 1];
  2005.   else 
  2006.     following_item = NULL;
  2007.  
  2008. #if SLOPPY_TYPES == 1
  2009.   puts("===================================================================");
  2010.   print_widget_value (following_item, 1, 0);
  2011. #endif 
  2012.   if (following_item
  2013.       && following_item->type == CASCADE_TYPE
  2014.       && following_item->contents
  2015.       && following_item->contents->type == INCREMENTAL_TYPE)
  2016.     {
  2017.       /* okay, we're now doing a lisp callback to incrementally generate
  2018.      more of the menu. */
  2019.       XtCallCallbackList ((Widget)mw,
  2020.               mw->menu.open,
  2021.               (XtPointer)following_item->contents);
  2022. #if SLOPPY_TYPES == 1
  2023.   puts("==== NEW ==== NEW ==== NEW ==== NEW ==== NEW ==== NEW ==== NEW ====");
  2024.   print_widget_value(following_item, 1, 0);
  2025. #endif 
  2026.     }
  2027.  
  2028.   if (hit)
  2029.     *hit_return = NULL;
  2030.  
  2031.   where.x = mw->menu.shadow_thickness;
  2032.   where.y = mw->menu.shadow_thickness;
  2033.  
  2034.   ws = &mw->menu.windows [level];
  2035.   for (val = mw->menu.old_stack [level]->contents; val; val = val->next)
  2036.     {
  2037.       XPoint start;
  2038.  
  2039.       highlighted_p = (val == following_item);
  2040.       /* If this is the partition (the dummy item which says that menus
  2041.      after this should be flushright) then figure out how big the
  2042.      following items are.  This means we walk down the tail of the
  2043.      list twice, but that's no big deal - it's short.
  2044.        */
  2045.       if (horizontal_p && (menu_item_type (val) == PUSHRIGHT_TYPE))
  2046.     {
  2047.       widget_value *rest;
  2048.       XPoint flushright_size;
  2049.       int new_x;
  2050.       flushright_size.x = 0;
  2051.       flushright_size.y = 0;
  2052.       for (rest = val; rest; rest = rest->next)
  2053.         display_menu_item (mw, rest, ws, &flushright_size,
  2054.                    highlighted_p, horizontal_p, True);
  2055.       new_x = ws->width - (flushright_size.x + mw->menu.shadow_thickness);
  2056.       if (new_x > where.x)
  2057.         where.x = new_x;
  2058.       /* We know what we need; don't draw this item. */
  2059.       continue;
  2060.     }
  2061.  
  2062.       if (highlighted_p && highlighted_pos)
  2063.     {
  2064.       if (horizontal_p)
  2065.         highlighted_pos->x = where.x;
  2066.       else
  2067.         highlighted_pos->y = where.y;
  2068.     }
  2069.       
  2070.       just_compute_this_one_p =
  2071.     just_compute_p || ((this || that) && val != this &&  val != that);
  2072.  
  2073.       start.x = where.x;
  2074.       start.y = where.y;
  2075.       display_menu_item (mw, val, ws, &where, highlighted_p, horizontal_p,
  2076.              just_compute_this_one_p);
  2077.  
  2078.       if (highlighted_p && highlighted_pos)
  2079.     {
  2080.       if (horizontal_p)
  2081.         highlighted_pos->y = ws->height;
  2082.       else
  2083.         highlighted_pos->x = ws->width;
  2084.     }
  2085.  
  2086.       if (hit && !*hit_return && (val->type != SEPARATOR_TYPE))
  2087.     {
  2088.       if (horizontal_p && hit->x > start.x && hit->x < where.x)
  2089.         *hit_return = val;
  2090.       else if (!horizontal_p && hit->y > start.y && hit->y < where.y)
  2091.         *hit_return = val;
  2092.     }
  2093.  
  2094.       if (horizontal_p)
  2095.     where.y = mw->menu.shadow_thickness;
  2096.       else
  2097.     where.x = mw->menu.shadow_thickness;
  2098.     }
  2099.  
  2100.   /* Draw slab edges around menu */
  2101.   if (!just_compute_p)
  2102.     shadow_draw(mw, ws->window, 0, 0, ws->width, ws->height, SHADOW_OUT);
  2103. }
  2104.  
  2105. /* Motion code */
  2106. static void
  2107. set_new_state (XlwMenuWidget mw, widget_value *val, int level)
  2108. {
  2109.   int i;
  2110.   
  2111.   mw->menu.new_depth = 0;
  2112.   for (i = 0; i < level; i++)
  2113.     push_new_stack (mw, mw->menu.old_stack [i]);
  2114.   if (val)
  2115.     push_new_stack (mw, val);
  2116. }
  2117.  
  2118. static void
  2119. make_windows_if_needed (XlwMenuWidget mw, int n)
  2120. {
  2121.   int i;
  2122.   int start_at;
  2123.   XSetWindowAttributes xswa;
  2124.   int mask;
  2125. #define ROOT_PARENT
  2126. #ifdef ROOT_PARENT
  2127.   Window root = RootWindowOfScreen (DefaultScreenOfDisplay (XtDisplay (mw)));
  2128. #endif 
  2129.   window_state *windows;
  2130.   
  2131.   if (mw->menu.windows_length >= n)
  2132.     return;
  2133.  
  2134.   xswa.save_under = True;
  2135.   xswa.override_redirect = True;
  2136.   xswa.background_pixel = mw->core.background_pixel;
  2137.   xswa.border_pixel = mw->core.border_pixel;
  2138.   xswa.event_mask = (ExposureMask | ButtonMotionMask
  2139.              | ButtonReleaseMask | ButtonPressMask);
  2140.   xswa.cursor = mw->menu.cursor_shape;
  2141.   mask = CWSaveUnder | CWOverrideRedirect | CWBackPixel | CWBorderPixel
  2142.     | CWEventMask | CWCursor;
  2143.  
  2144.   if (mw->menu.use_backing_store)
  2145.     {
  2146.       xswa.backing_store = Always;
  2147.       mask |= CWBackingStore;
  2148.     }
  2149.   
  2150.   if (!mw->menu.windows)
  2151.     {
  2152.       mw->menu.windows =
  2153.     (window_state *) XtMalloc (n * sizeof (window_state));
  2154.       start_at = 0;
  2155.     }
  2156.   else
  2157.     {
  2158.       mw->menu.windows =
  2159.     (window_state *) XtRealloc ((char*)mw->menu.windows,
  2160.                     n * sizeof (window_state));
  2161.       start_at = mw->menu.windows_length;
  2162.     }
  2163.   mw->menu.windows_length = n;
  2164.  
  2165.   windows = mw->menu.windows;
  2166.  
  2167.   for (i = start_at; i < n; i++)
  2168.    {
  2169.      windows [i].x = 0;
  2170.      windows [i].y = 0;
  2171.      windows [i].width = 1;
  2172.      windows [i].height = 1;
  2173.      windows [i].window =
  2174.        XCreateWindow (XtDisplay (mw),
  2175. #ifdef ROOT_PARENT
  2176.               root,
  2177. #else 
  2178.               ((i >  0)
  2179.                ? windows[0].window
  2180.                : XtWindow (XtParent (mw))),
  2181. #endif 
  2182.               0, 0, 1, 1,
  2183.               0, 0, CopyFromParent, CopyFromParent, mask, &xswa);
  2184.   }
  2185. }
  2186.  
  2187. /* Make the window fit in the screen */
  2188. static void
  2189. fit_to_screen (XlwMenuWidget mw, window_state *ws, window_state *previous_ws,
  2190.            Boolean horizontal_p)
  2191. {
  2192.   int screen_width = WidthOfScreen (XtScreen (mw));
  2193.   int screen_height = HeightOfScreen (XtScreen (mw));
  2194.  
  2195.   if (ws->x < 0)
  2196.     ws->x = 0;
  2197.   else if ((int) (ws->x + ws->width) > screen_width)
  2198.     {
  2199.       if (!horizontal_p)
  2200.     ws->x = previous_ws->x - ws->width;
  2201.       else
  2202.     {
  2203.       ws->x = screen_width - ws->width;
  2204.  
  2205.       /* This check is to make sure we cut off the right side
  2206.              instead of the left side if the menu is wider than the
  2207.              screen. */
  2208.       if (ws->x < 0)
  2209.         ws->x = 0;
  2210.     }
  2211.     }
  2212.   if (ws->y < 0)
  2213.     ws->y = 0;
  2214.   else if ((int) (ws->y + ws->height) > screen_height)
  2215.     {
  2216.       if (horizontal_p)
  2217.     {
  2218.       /* A pulldown must either be entirely above or below the menubar.
  2219.          If we're here, the pulldown doesn't fit below the menubar, so
  2220.              let's determine if it will fit above the menubar.
  2221.              Only put it above if there is more room above than below.
  2222.          Note shadow_thickness offset to allow for slab surround.
  2223.          */
  2224.       if (ws->y > (screen_height / 2))
  2225.         ws->y = previous_ws->y - ws->height + mw->menu.shadow_thickness;
  2226.     }
  2227.       else
  2228.     {
  2229.       ws->y = screen_height - ws->height;
  2230.        /* if it's taller than the screen, display the topmost part
  2231.           that will fit, beginning at the top of the screen. */
  2232.       if (ws->y < 0)
  2233.         ws->y = 0;
  2234.     }
  2235.     }
  2236. }
  2237.  
  2238. /* Updates old_stack from new_stack and redisplays. */
  2239. static void
  2240. remap_menubar (XlwMenuWidget mw)
  2241. {
  2242.   int i;
  2243.   int last_same;
  2244.   XPoint selection_position;
  2245.   int old_depth = mw->menu.old_depth;
  2246.   int new_depth = mw->menu.new_depth;
  2247.   widget_value **old_stack;
  2248.   widget_value **new_stack;
  2249.   window_state *windows;
  2250.   widget_value *old_selection;
  2251.   widget_value *new_selection;
  2252.  
  2253.   /* Check that enough windows and old_stack are ready. */
  2254.   make_windows_if_needed (mw, new_depth);
  2255.   make_old_stack_space (mw, new_depth);
  2256.   windows = mw->menu.windows;
  2257.   old_stack = mw->menu.old_stack;
  2258.   new_stack = mw->menu.new_stack;
  2259.  
  2260.   /* compute the last identical different entry */
  2261.   for (i = 1; i < old_depth && i < new_depth; i++)
  2262.     if (old_stack [i] != new_stack [i])
  2263.       break;
  2264.   last_same = i - 1;
  2265.  
  2266.   /* Memorize the previously selected item to be able to refresh it */
  2267.   old_selection = last_same + 1 < old_depth ? old_stack [last_same + 1] : NULL;
  2268.   if (old_selection && !old_selection->enabled)
  2269.     old_selection = NULL;
  2270.   new_selection = last_same + 1 < new_depth ? new_stack [last_same + 1] : NULL;
  2271.   if (new_selection && !new_selection->enabled)
  2272.     new_selection = NULL;
  2273.  
  2274.   /* updates old_state from new_state.  It has to be done now because
  2275.      display_menu (called below) uses the old_stack to know what to display. */
  2276.   for (i = last_same + 1; i < new_depth; i++)
  2277.     old_stack [i] = new_stack [i];
  2278.   mw->menu.old_depth = new_depth;
  2279.  
  2280.   /* refresh the last seletion */
  2281.   selection_position.x = 0;
  2282.   selection_position.y = 0;
  2283.   display_menu (mw, last_same, new_selection == old_selection,
  2284.         &selection_position, NULL, NULL, old_selection, new_selection);
  2285.  
  2286.   /* Now popup the new menus */
  2287.   for (i = last_same + 1; i < new_depth && new_stack [i]->contents; i++)
  2288.     {
  2289.       window_state *previous_ws = &windows [i - 1];
  2290.       window_state *ws = &windows [i];
  2291.  
  2292.       ws->x = previous_ws->x + selection_position.x;
  2293.       ws->y = previous_ws->y + selection_position.y;
  2294.  
  2295.       /* take into account the slab around the new menu */
  2296.       ws->y -= mw->menu.shadow_thickness;
  2297.  
  2298.       size_menu (mw, i);
  2299.  
  2300.       fit_to_screen (mw, ws, previous_ws, mw->menu.horizontal && i == 1);
  2301.  
  2302.       XClearWindow (XtDisplay (mw), ws->window);
  2303.       XMoveResizeWindow (XtDisplay (mw), ws->window, ws->x, ws->y,
  2304.              ws->width, ws->height);
  2305.       XMapRaised (XtDisplay (mw), ws->window);
  2306.       display_menu (mw, i, False, &selection_position, NULL, NULL, NULL, NULL);
  2307.     }
  2308.  
  2309.   /* unmap the menus that popped down */
  2310.   for (i = new_depth - 1; i < old_depth; i++)
  2311.     if (i >= new_depth || !new_stack [i]->contents)
  2312.       XUnmapWindow (XtDisplay (mw), windows [i].window);
  2313. }
  2314.  
  2315. static Boolean
  2316. motion_event_is_in_menu (XlwMenuWidget mw, XMotionEvent *ev, int level,
  2317.              XPoint *relative_pos)
  2318. {
  2319.   window_state *ws = &mw->menu.windows [level];
  2320.   int x = level == 0 ? ws->x : ws->x + mw->menu.shadow_thickness;
  2321.   int y = level == 0 ? ws->y : ws->y + mw->menu.shadow_thickness;
  2322.   relative_pos->x = ev->x_root - x;
  2323.   relative_pos->y = ev->y_root - y;
  2324.   return (x < ev->x_root && ev->x_root < (int) (x + ws->width)
  2325.       && y < ev->y_root && ev->y_root < (int) (y + ws->height));
  2326. }
  2327.  
  2328. static Boolean
  2329. map_event_to_widget_value (XlwMenuWidget mw, XMotionEvent *ev,
  2330.                widget_value **val_ptr, int *level,
  2331.                Boolean *inside_menu)
  2332. {
  2333.   int         i;
  2334.   XPoint    relative_pos;
  2335.   window_state*    ws;
  2336.  
  2337.   *val_ptr = NULL;
  2338.   *inside_menu = False;
  2339.   
  2340.   /* Find the window */
  2341.   for (i = mw->menu.old_depth - 1; i >= 0; i--)
  2342.     {
  2343.       ws = &mw->menu.windows [i];
  2344.       if (ws && motion_event_is_in_menu (mw, ev, i, &relative_pos))
  2345.     {
  2346.       *inside_menu = True;    /* special logic for menubar below... */
  2347.       if ((ev->type == ButtonPress) ||
  2348.           (ev->state != 0))
  2349.         {
  2350.           display_menu (mw, i, True, NULL, &relative_pos,
  2351.                 val_ptr, NULL, NULL);
  2352.           if (*val_ptr)
  2353.         {
  2354.           *level = i + 1;
  2355.           *inside_menu = True;
  2356.           return True;
  2357.         }
  2358.           else if (mw->menu.horizontal || i == 0)
  2359.         {
  2360.           /* if we're clicking on empty part of the menubar, then
  2361.              unpost the stay-up menu */
  2362.           *inside_menu = False;
  2363.         }
  2364.         }
  2365.     }
  2366.     }
  2367.   return False;
  2368. }
  2369.  
  2370. /* Procedures */
  2371. static void
  2372. make_drawing_gcs (XlwMenuWidget mw)
  2373. {
  2374.   XGCValues xgcv;
  2375.   unsigned long flags = (GCFont | GCForeground | GCBackground);
  2376.  
  2377. #ifdef NEED_MOTIF
  2378.   xgcv.font = default_font_of_font_list (mw->menu.font_list)->fid;
  2379. #else
  2380.   xgcv.font = mw->menu.font->fid;
  2381. #endif
  2382.  
  2383.   xgcv.foreground = mw->core.background_pixel;
  2384.   xgcv.background = mw->menu.foreground;
  2385.   mw->menu.background_gc = XtGetGC ((Widget)mw, flags, &xgcv);
  2386.  
  2387.   xgcv.foreground = mw->menu.foreground;
  2388.   xgcv.background = mw->core.background_pixel;
  2389.   mw->menu.foreground_gc = XtGetGC ((Widget)mw, flags, &xgcv);
  2390.  
  2391.   if (mw->menu.select_color != (Pixel)-1)
  2392.     {
  2393.       xgcv.foreground = mw->menu.select_color;
  2394.     }
  2395.   else
  2396.     {
  2397.       Display *dpy = XtDisplay(mw);
  2398.       if (CellsOfScreen(DefaultScreenOfDisplay(dpy)) <= 2)
  2399.     { /* mono */
  2400.       xgcv.foreground = mw->menu.foreground;
  2401.     }
  2402.       else
  2403.     { /* color */
  2404.       XColor xcolor;
  2405.       Display *dpy = XtDisplay ((Widget) mw);
  2406.       Colormap cmap = DefaultColormapOfScreen (XtScreen ((Widget) mw));
  2407.       xcolor.pixel = mw->core.background_pixel;
  2408.       XQueryColor (dpy, cmap, &xcolor);
  2409.       xcolor.red   *= 0.85;
  2410.       xcolor.green *= 0.85;
  2411.       xcolor.blue  *= 0.85;
  2412.       if (XAllocColor (dpy, cmap, &xcolor))
  2413.         xgcv.foreground = xcolor.pixel;
  2414.     }
  2415.     }
  2416.   xgcv.background = mw->core.background_pixel;
  2417.   mw->menu.select_gc = XtGetGC ((Widget)mw, flags, &xgcv);
  2418.   
  2419.   xgcv.foreground = mw->menu.foreground;
  2420.   xgcv.background = mw->core.background_pixel;
  2421.   xgcv.fill_style = FillStippled;
  2422.   xgcv.stipple = mw->menu.gray_pixmap;
  2423.   mw->menu.inactive_gc = XtGetGC ((Widget)mw,
  2424.                   (flags | GCFillStyle | GCStipple),
  2425.                   &xgcv);
  2426.  
  2427.   xgcv.foreground = mw->menu.button_foreground;
  2428.   xgcv.background = mw->core.background_pixel;
  2429.   mw->menu.button_gc = XtGetGC ((Widget)mw, flags, &xgcv);
  2430.   
  2431.   xgcv.fill_style = FillStippled;
  2432.   xgcv.stipple = mw->menu.gray_pixmap;
  2433.   mw->menu.inactive_button_gc = XtGetGC ((Widget)mw,
  2434.                   (flags | GCFillStyle | GCStipple),
  2435.                      &xgcv);
  2436. }
  2437.  
  2438. static void
  2439. release_drawing_gcs (XlwMenuWidget mw)
  2440. {
  2441.   XtReleaseGC ((Widget) mw, mw->menu.foreground_gc);
  2442.   XtReleaseGC ((Widget) mw, mw->menu.button_gc);
  2443.   XtReleaseGC ((Widget) mw, mw->menu.inactive_gc);
  2444.   XtReleaseGC ((Widget) mw, mw->menu.inactive_button_gc);
  2445.   XtReleaseGC ((Widget) mw, mw->menu.background_gc);
  2446.   XtReleaseGC ((Widget) mw, mw->menu.select_gc);
  2447.   /* let's get some segvs if we try to use these... */
  2448.   mw->menu.foreground_gc = (GC) -1;
  2449.   mw->menu.button_gc = (GC) -1;
  2450.   mw->menu.inactive_gc = (GC) -1;
  2451.   mw->menu.inactive_button_gc = (GC) -1;
  2452.   mw->menu.background_gc = (GC) -1;
  2453.   mw->menu.select_gc = (GC) -1;
  2454. }
  2455.  
  2456. #define MINL(x,y) ((((unsigned long) (x)) < ((unsigned long) (y))) \
  2457.            ? ((unsigned long) (x)) : ((unsigned long) (y)))
  2458.  
  2459. static void
  2460. make_shadow_gcs (XlwMenuWidget mw)
  2461. {
  2462.   XGCValues xgcv;
  2463.   unsigned long pm = 0;
  2464.   Display *dpy = XtDisplay ((Widget) mw);
  2465.   Colormap cmap = DefaultColormapOfScreen (XtScreen ((Widget) mw));
  2466.   XColor topc, botc;
  2467.   int top_frobbed = 0, bottom_frobbed = 0;
  2468.  
  2469.   if (mw->menu.top_shadow_color == -1)
  2470.     mw->menu.top_shadow_color = mw->core.background_pixel;
  2471.   if (mw->menu.bottom_shadow_color == -1)
  2472.     mw->menu.bottom_shadow_color = mw->menu.foreground;
  2473.  
  2474.   if (mw->menu.top_shadow_color == mw->core.background_pixel ||
  2475.       mw->menu.top_shadow_color == mw->menu.foreground)
  2476.     {
  2477.       topc.pixel = mw->core.background_pixel;
  2478.       XQueryColor (dpy, cmap, &topc);
  2479.       /* don't overflow/wrap! */
  2480.       topc.red   = MINL (65535, topc.red   * 1.2);
  2481.       topc.green = MINL (65535, topc.green * 1.2);
  2482.       topc.blue  = MINL (65535, topc.blue  * 1.2);
  2483.       if (XAllocColor (dpy, cmap, &topc))
  2484.     {
  2485.           if (topc.pixel == mw->core.background_pixel)
  2486.         {
  2487.           XFreeColors( dpy, cmap, &topc.pixel, 1, 0);
  2488.           topc.red   = MINL (65535, topc.red   + 0x8000);
  2489.           topc.green = MINL (65535, topc.green + 0x8000);
  2490.           topc.blue  = MINL (65535, topc.blue  + 0x8000);
  2491.           if (XAllocColor (dpy, cmap, &topc))
  2492.         {
  2493.           mw->menu.top_shadow_color = topc.pixel;
  2494.         }  
  2495.         }
  2496.       else
  2497.         {
  2498.           mw->menu.top_shadow_color = topc.pixel;
  2499.         }
  2500.  
  2501.       top_frobbed = 1;
  2502.     }
  2503.     }
  2504.   if (mw->menu.bottom_shadow_color == mw->menu.foreground ||
  2505.       mw->menu.bottom_shadow_color == mw->core.background_pixel)
  2506.     {
  2507.       botc.pixel = mw->core.background_pixel;
  2508.       XQueryColor (dpy, cmap, &botc);
  2509.       botc.red   *= 0.6;
  2510.       botc.green *= 0.6;
  2511.       botc.blue  *= 0.6;
  2512.       if (XAllocColor (dpy, cmap, &botc))
  2513.     {
  2514.       if (botc.pixel == mw->core.background_pixel)
  2515.         {
  2516.           XFreeColors (dpy, cmap, &botc.pixel, 1, 0);
  2517.           botc.red   = MINL (65535, botc.red   + 0x4000);
  2518.           botc.green = MINL (65535, botc.green + 0x4000);
  2519.           botc.blue  = MINL (65535, botc.blue  + 0x4000);
  2520.           if (XAllocColor (dpy, cmap, &botc))
  2521.         {
  2522.           mw->menu.bottom_shadow_color = botc.pixel;
  2523.         }  
  2524.         }
  2525.       else
  2526.         {
  2527.           mw->menu.bottom_shadow_color = botc.pixel;
  2528.         }
  2529.  
  2530.           bottom_frobbed = 1;
  2531.     }
  2532.     }
  2533.  
  2534.   if (top_frobbed && bottom_frobbed)
  2535.     {
  2536.       int top_avg = ((topc.red / 3) + (topc.green / 3) + (topc.blue / 3));
  2537.       int bot_avg = ((botc.red / 3) + (botc.green / 3) + (botc.blue / 3));
  2538.       if (bot_avg > top_avg)
  2539.     {
  2540.       Pixel tmp = mw->menu.top_shadow_color;
  2541.       mw->menu.top_shadow_color = mw->menu.bottom_shadow_color;
  2542.       mw->menu.bottom_shadow_color = tmp;
  2543.     }
  2544.       else if (topc.pixel == botc.pixel)
  2545.     {
  2546.       if (botc.pixel == mw->menu.foreground)
  2547.         mw->menu.top_shadow_color = mw->core.background_pixel;
  2548.       else
  2549.         mw->menu.bottom_shadow_color = mw->menu.foreground;
  2550.     }
  2551.     }
  2552.  
  2553.   if (!mw->menu.top_shadow_pixmap &&
  2554.       mw->menu.top_shadow_color == mw->core.background_pixel)
  2555.     {
  2556.       mw->menu.top_shadow_pixmap = mw->menu.gray_pixmap;
  2557.       mw->menu.top_shadow_color = mw->menu.foreground;
  2558.     }
  2559.   if (!mw->menu.bottom_shadow_pixmap &&
  2560.       mw->menu.bottom_shadow_color == mw->core.background_pixel)
  2561.     {
  2562.       mw->menu.bottom_shadow_pixmap = mw->menu.gray_pixmap;
  2563.       mw->menu.bottom_shadow_color = mw->menu.foreground;
  2564.     }
  2565.  
  2566.   xgcv.fill_style = FillOpaqueStippled;
  2567.   xgcv.foreground = mw->menu.top_shadow_color;
  2568.   xgcv.background = mw->core.background_pixel;
  2569.   xgcv.stipple = mw->menu.top_shadow_pixmap;
  2570.   pm = (xgcv.stipple ? GCStipple|GCFillStyle : 0);
  2571.   mw->menu.shadow_top_gc =
  2572.     XtGetGC((Widget)mw, GCForeground|GCBackground|pm, &xgcv);
  2573.  
  2574.   xgcv.foreground = mw->menu.bottom_shadow_color;
  2575.   xgcv.stipple = mw->menu.bottom_shadow_pixmap;
  2576.   pm = (xgcv.stipple ? GCStipple|GCFillStyle : 0);
  2577.   mw->menu.shadow_bottom_gc =
  2578.     XtGetGC ((Widget)mw, GCForeground|GCBackground|pm, &xgcv);
  2579. }
  2580.  
  2581.  
  2582. static void
  2583. release_shadow_gcs (XlwMenuWidget mw)
  2584. {
  2585.   XtReleaseGC ((Widget) mw, mw->menu.shadow_top_gc);
  2586.   XtReleaseGC ((Widget) mw, mw->menu.shadow_bottom_gc);
  2587. }
  2588.  
  2589. static void
  2590. extract_font_extents (XlwMenuWidget mw)
  2591. {
  2592. #ifdef NEED_MOTIF
  2593.   /* Find the maximal ascent/descent of the fonts in the font list
  2594.      so that all menu items can be the same height... */
  2595.   mw->menu.font_ascent  = 0;
  2596.   mw->menu.font_descent = 0;
  2597.   
  2598.   {
  2599.     XmFontContext context;
  2600. #if (XmVersion >= 1002)
  2601.     XmFontListEntry fontentry;
  2602. #else    
  2603.     XmStringCharSet charset;
  2604. #endif
  2605.     XFontStruct *font;
  2606.  
  2607.     if (! XmFontListInitFontContext (&context, mw->menu.font_list))
  2608.       abort ();
  2609. #if (XmVersion >= 1002)
  2610.     /* There is a BUG in the 1.2 version of XmFontListGetNextFont() (or more
  2611.        specifically, in _XmGetFirstFont()) that can cause a null pointer to be
  2612.        passed to XFontsOfFontSet.  Use XmFontListNextEntry(), which is the
  2613.        newer equivalent, instead.  Also, it supports font sets, and the
  2614.        older function doesn't. */
  2615.     while ((fontentry = XmFontListNextEntry (context)))
  2616.       {
  2617.     char *one_of_them;
  2618.     XmFontType rettype; 
  2619.     
  2620.     one_of_them = XmFontListEntryGetFont (fontentry, &rettype);
  2621.     if (rettype == XmFONT_IS_FONTSET)
  2622.       {
  2623.         XFontSet fontset = (XFontSet) one_of_them;
  2624.         XFontStruct **fontstruct_list;
  2625.         char **fontname_list;
  2626.         int fontcount = XFontsOfFontSet (fontset, &fontstruct_list,
  2627.                          &fontname_list);
  2628.         while (--fontcount >= 0)
  2629.           {
  2630.         font = fontstruct_list[fontcount];
  2631.         if (font->ascent > (int) mw->menu.font_ascent)
  2632.           mw->menu.font_ascent = font->ascent;
  2633.         if (font->descent > (int) mw->menu.font_descent)
  2634.           mw->menu.font_descent = font->descent;
  2635.           }
  2636.       }
  2637.     else /* XmFONT_IS_FONT */
  2638.       {
  2639.         font = (XFontStruct *) one_of_them;
  2640.         if (font->ascent > (int) mw->menu.font_ascent)
  2641.           mw->menu.font_ascent = font->ascent;
  2642.         if (font->descent > (int) mw->menu.font_descent)
  2643.           mw->menu.font_descent = font->descent;
  2644.       }
  2645.       }
  2646. #else /* motif 1.1 */
  2647.     while (XmFontListGetNextFont (context, &charset, &font))
  2648.       {
  2649.     if (font->ascent > (int) mw->menu.font_ascent)
  2650.       mw->menu.font_ascent = font->ascent;
  2651.     if (font->descent > (int) mw->menu.font_descent)
  2652.       mw->menu.font_descent = font->descent;
  2653.     XtFree (charset);
  2654.       }
  2655. #endif    
  2656.     XmFontListFreeFontContext (context);
  2657.   }
  2658. #else
  2659.   mw->menu.font_ascent  = mw->menu.font->ascent;
  2660.   mw->menu.font_descent = mw->menu.font->descent;
  2661. #endif
  2662. }
  2663.  
  2664. #ifdef NEED_MOTIF
  2665. static XFontStruct *
  2666. default_font_of_font_list (XmFontList font_list)
  2667. {
  2668.   XFontStruct *font = 0;
  2669. # if 0
  2670.   /* Xm/Label.c does this: */
  2671.   _XmFontListGetDefaultFont (font_list, &font);
  2672. # else  /* !0 */
  2673.   {
  2674.     XmFontContext context;
  2675. #if (XmVersion >= 1002)
  2676.     XmFontListEntry fontentry;
  2677.     XmFontType rettype;
  2678.     char *one_of_them;
  2679. #else    
  2680.     XmStringCharSet charset;
  2681. #endif
  2682.     
  2683.     if (! XmFontListInitFontContext (&context, font_list))
  2684.       abort ();
  2685. #if (XmVersion >= 1002)
  2686.     /* There is a BUG in the 1.2 version of XmFontListGetNextFont() (or more
  2687.        specifically, in _XmGetFirstFont()) that can cause a null pointer to be
  2688.        passed to XFontsOfFontSet.  Use XmFontListNextEntry(), which is the
  2689.        newer equivalent, instead. */
  2690.     fontentry = XmFontListNextEntry (context);
  2691.     one_of_them = XmFontListEntryGetFont (fontentry, &rettype);
  2692.     if (rettype == XmFONT_IS_FONTSET)
  2693.       {
  2694.     XFontSet fontset = (XFontSet) one_of_them;
  2695.     XFontStruct **fontstruct_list;
  2696.     char **fontname_list;
  2697.     (void) XFontsOfFontSet (fontset, &fontstruct_list, &fontname_list);
  2698.     font = fontstruct_list[0];
  2699.       }
  2700.     else /* XmFONT_IS_FONT */
  2701.       {
  2702.     font = (XFontStruct *) one_of_them;
  2703.       }
  2704. #else    
  2705.     if (! XmFontListGetNextFont (context, &charset, &font))
  2706.       abort ();
  2707.     XtFree (charset);
  2708. #endif    
  2709.     XmFontListFreeFontContext (context);
  2710.   }
  2711. # endif /* !0 */
  2712.  
  2713.   if (! font) abort ();
  2714.   return font;
  2715. }
  2716. #endif
  2717.  
  2718. static void
  2719. XlwMenuInitialize (Widget request, Widget new, ArgList args,
  2720.            Cardinal *num_args)
  2721. {
  2722.   /* Get the GCs and the widget size */
  2723.   XlwMenuWidget mw = (XlwMenuWidget)new;
  2724.   
  2725.   XSetWindowAttributes xswa;
  2726.   int mask;
  2727.   
  2728.   Window window = RootWindowOfScreen (DefaultScreenOfDisplay (XtDisplay (mw)));
  2729.   Display *display = XtDisplay (mw);
  2730.   
  2731. /*  mw->menu.cursor = XCreateFontCursor (display, mw->menu.cursor_shape); */
  2732.   mw->menu.cursor = mw->menu.cursor_shape;
  2733.   
  2734.   mw->menu.gray_pixmap = XCreatePixmapFromBitmapData (display, window,
  2735.                               (char *) gray_bits,
  2736.                               gray_width,
  2737.                               gray_height, 1, 0, 1);
  2738.   
  2739. #ifdef NEED_MOTIF
  2740.   /* The menu.font_list slot came from the *fontList resource (Motif standard.)
  2741.      The menu.font_list_2 slot came from the *font resource, for backward
  2742.      compatibility with older versions of this code, and consistency with the
  2743.      rest of emacs.  If both font and fontList are specified, we use font.
  2744.      If only one is specified, we use that.  If neither are specified, we
  2745.      use the "fallback" value.  What a kludge!!!
  2746.  
  2747.      Note that this has the bug that a more general wildcard like "*fontList:"
  2748.      will override a more specific resoure like "Emacs*menubar.font:".  But
  2749.      I can't think of a way around that.
  2750.    */
  2751.   if (mw->menu.font_list)      /* if *fontList is specified, use that */
  2752.     ;
  2753.   else if (mw->menu.font_list_2)  /* else if *font is specified, use that */
  2754.     mw->menu.font_list = mw->menu.font_list_2;
  2755.   else                  /* otherwise use default */
  2756.     mw->menu.font_list = mw->menu.fallback_font_list;
  2757. #endif
  2758.  
  2759.   make_drawing_gcs (mw);
  2760.   make_shadow_gcs (mw);
  2761.   extract_font_extents (mw);
  2762.  
  2763.   xswa.background_pixel = mw->core.background_pixel;
  2764.   xswa.border_pixel = mw->core.border_pixel;
  2765.   mask = CWBackPixel | CWBorderPixel;
  2766.   
  2767.   mw->menu.popped_up = False;
  2768.   mw->menu.pointer_grabbed = False;
  2769.   mw->menu.next_release_must_exit = False;
  2770.   
  2771.   mw->menu.old_depth = 1;
  2772.   mw->menu.old_stack = (widget_value**)XtMalloc (sizeof (widget_value*));
  2773.   mw->menu.old_stack_length = 1;
  2774.   mw->menu.old_stack [0] = mw->menu.contents;
  2775.   
  2776.   mw->menu.new_depth = 0;
  2777.   mw->menu.new_stack = 0;
  2778.   mw->menu.new_stack_length = 0;
  2779.   push_new_stack (mw, mw->menu.contents);
  2780.   
  2781.   mw->menu.windows = (window_state*)XtMalloc (sizeof (window_state));
  2782.   mw->menu.windows_length = 1;
  2783.   mw->menu.windows [0].x = 0;
  2784.   mw->menu.windows [0].y = 0;
  2785.   mw->menu.windows [0].width = 0;
  2786.   mw->menu.windows [0].height = 0;
  2787.   size_menu (mw, 0);
  2788.   
  2789.   mw->core.width = mw->menu.windows [0].width;
  2790.   mw->core.height = mw->menu.windows [0].height;
  2791. }
  2792.  
  2793. static void
  2794. XlwMenuClassInitialize (void)
  2795. {
  2796. }
  2797.  
  2798. static void
  2799. XlwMenuRealize (Widget w, Mask *valueMask, XSetWindowAttributes *attributes)
  2800. {
  2801.   XlwMenuWidget mw = (XlwMenuWidget)w;
  2802.   XSetWindowAttributes xswa;
  2803.   int mask;
  2804.  
  2805.   (*xlwMenuWidgetClass->core_class.superclass->core_class.realize)
  2806.     (w, valueMask, attributes);
  2807.  
  2808.   xswa.save_under = True;
  2809.   xswa.cursor = mw->menu.cursor_shape;
  2810.   mask = CWSaveUnder | CWCursor;
  2811.   if (mw->menu.use_backing_store)
  2812.     {
  2813.       xswa.backing_store = Always;
  2814.       mask |= CWBackingStore;
  2815.     }
  2816.   XChangeWindowAttributes (XtDisplay (w), XtWindow (w), mask, &xswa);
  2817.  
  2818.   mw->menu.windows [0].window = XtWindow (w);
  2819.   mw->menu.windows [0].x = w->core.x;
  2820.   mw->menu.windows [0].y = w->core.y;
  2821.   mw->menu.windows [0].width = w->core.width;
  2822.   mw->menu.windows [0].height = w->core.height;
  2823. }
  2824.  
  2825. /* Only the toplevel menubar/popup is a widget so it's the only one that
  2826.    receives expose events through Xt.  So we repaint all the other panes
  2827.    when receiving an Expose event. */
  2828. static void 
  2829. XlwMenuRedisplay (Widget w, XEvent *ev, Region region)
  2830. {
  2831.   XlwMenuWidget mw = (XlwMenuWidget)w;
  2832.   int i;
  2833.  
  2834.   if (mw->core.being_destroyed) return;
  2835.  
  2836.   for (i = 0; i < mw->menu.old_depth; i++)
  2837.     display_menu (mw, i, False, NULL, NULL, NULL, NULL, NULL);
  2838.   set_new_state (mw, NULL, mw->menu.old_depth); /* #### - ??? */
  2839.   remap_menubar (mw);        /* #### - do these two lines do anything? */
  2840. }
  2841.  
  2842. static void 
  2843. XlwMenuDestroy (Widget w)
  2844. {
  2845.   int i;
  2846.   XlwMenuWidget mw = (XlwMenuWidget) w;
  2847.  
  2848.   if (mw->menu.pointer_grabbed)
  2849.     {
  2850.       XtUngrabPointer (w, CurrentTime);
  2851.       mw->menu.pointer_grabbed = False;
  2852.     }
  2853.   
  2854.   release_drawing_gcs (mw);
  2855.   release_shadow_gcs (mw);
  2856.  
  2857.   /* this doesn't come from the resource db but is created explicitly
  2858.      so we must free it ourselves. */
  2859.   XFreePixmap (XtDisplay (mw), mw->menu.gray_pixmap);
  2860.   mw->menu.gray_pixmap = (Pixmap) -1;
  2861.  
  2862.   /* Don't free mw->menu.contents because that comes from our creator.
  2863.      The `*_stack' elements are just pointers into `contents' so leave
  2864.      that alone too.  But free the stacks themselves. */
  2865.   if (mw->menu.old_stack) XtFree ((char *) mw->menu.old_stack);
  2866.   if (mw->menu.new_stack) XtFree ((char *) mw->menu.new_stack);
  2867.  
  2868.   /* Remember, you can't free anything that came from the resource
  2869.      database.  This includes:
  2870.          mw->menu.cursor
  2871.          mw->menu.top_shadow_pixmap
  2872.          mw->menu.bottom_shadow_pixmap
  2873.          mw->menu.font
  2874.          mw->menu.font_set
  2875.      Also the color cells of top_shadow_color, bottom_shadow_color,
  2876.      foreground, and button_foreground will never be freed until this
  2877.      client exits.  Nice, eh?
  2878.    */
  2879.  
  2880.   /* start from 1 because the one in slot 0 is w->core.window */
  2881.   for (i = 1; i < mw->menu.windows_length; i++)
  2882.     XDestroyWindow (XtDisplay (mw), mw->menu.windows [i].window);
  2883.   if (mw->menu.windows)
  2884.     XtFree ((char *) mw->menu.windows);
  2885. }
  2886.  
  2887. static Boolean 
  2888. XlwMenuSetValues (Widget current, Widget request, Widget new, ArgList args,
  2889.           Cardinal *num_args)
  2890. {
  2891.   XlwMenuWidget oldmw = (XlwMenuWidget)current;
  2892.   XlwMenuWidget newmw = (XlwMenuWidget)new;
  2893.   Boolean redisplay = False;
  2894.   int i;
  2895.  
  2896.   if (newmw->menu.contents
  2897.       && newmw->menu.contents->contents
  2898.       && newmw->menu.contents->contents->change >= VISIBLE_CHANGE)
  2899.     redisplay = True;
  2900.  
  2901.   if (newmw->core.background_pixel != oldmw->core.background_pixel
  2902.       || newmw->menu.foreground != oldmw->menu.foreground
  2903.       /* For the XEditResource protocol, which may want to change the font. */
  2904. #ifdef NEED_MOTIF
  2905.       || newmw->menu.font_list != oldmw->menu.font_list
  2906.       || newmw->menu.font_list_2 != oldmw->menu.font_list_2
  2907.       || newmw->menu.fallback_font_list != oldmw->menu.fallback_font_list
  2908. #else
  2909.       || newmw->menu.font != oldmw->menu.font
  2910. #endif
  2911.       )
  2912.     {
  2913.       release_drawing_gcs (newmw);
  2914.       make_drawing_gcs (newmw);
  2915.       redisplay = True;
  2916.       
  2917.       for (i = 0; i < oldmw->menu.windows_length; i++)
  2918.     {
  2919.       XSetWindowBackground (XtDisplay (oldmw),
  2920.                 oldmw->menu.windows [i].window,
  2921.                 newmw->core.background_pixel);
  2922.       /* clear windows and generate expose events */
  2923.       XClearArea (XtDisplay (oldmw), oldmw->menu.windows[i].window,
  2924.               0, 0, 0, 0, True);
  2925.     }
  2926.     }
  2927.  
  2928.   return redisplay;
  2929. }
  2930.  
  2931. static void 
  2932. XlwMenuResize (Widget w)
  2933. {
  2934.   XlwMenuWidget mw = (XlwMenuWidget)w;
  2935.  
  2936.   mw->menu.windows [0].width = mw->core.width;
  2937.   mw->menu.windows [0].height = mw->core.height;
  2938. }
  2939.  
  2940. /* Action procedures */
  2941. static void
  2942. handle_single_motion_event (XlwMenuWidget mw, XMotionEvent *ev,
  2943.                 Boolean select_p)
  2944. {
  2945.   widget_value *val;
  2946.   Boolean      stay_up;
  2947.   int           level;
  2948.  
  2949.   if (!map_event_to_widget_value (mw, ev, &val, &level, &stay_up))
  2950.     {
  2951.       /* we wind up here when: (a) the event is in the menubar, (b) the
  2952.      event isn't in the menubar or any of the panes, (c) the event is on
  2953.      a disabled menu item */
  2954.       pop_new_stack_if_no_contents (mw);
  2955.       if (select_p && !stay_up) {
  2956.     /* pop down all menus and exit */
  2957.     mw->menu.next_release_must_exit = True;
  2958.     set_new_state(mw, (val = NULL), 1); 
  2959.       }
  2960.     }
  2961.   else
  2962.     {
  2963.       /* we wind up here when: (a) the event pops up a pull_right menu,
  2964.      (b) a menu item that is not disabled is highlighted */
  2965.       if (select_p && mw->menu.bounce_down
  2966.            && close_to_reference_time((Widget)mw,
  2967.                       mw->menu.menu_bounce_time,
  2968.                       (XEvent *)ev))
  2969.     {
  2970.       /* motion can cause more than one event.  Don't bounce right back
  2971.          up if we've just bounced down. */
  2972.       val = NULL;
  2973.     }
  2974.       else if (select_p && mw->menu.bounce_down &&
  2975.            mw->menu.last_selected_val &&
  2976.            (mw->menu.last_selected_val == val))
  2977.     {
  2978.       val = NULL;        /* assigned to mw->last_selected_val below */
  2979.       mw->menu.menu_bounce_time = ev->time;
  2980.       /* popdown last menu if we're selecting the same menu item as we did
  2981.          last time and the XlwMenu.bounceDown resource is set, if the
  2982.          item is on the menubar itself, then exit. */
  2983.       if (level == (mw->menu.popped_up ? 0 : 1))
  2984.         mw->menu.next_release_must_exit = True;
  2985.     }    
  2986.       else
  2987.     mw->menu.menu_bounce_time = 0;
  2988.       set_new_state (mw, val, level);
  2989.     }
  2990.   mw->menu.last_selected_val = val;
  2991.   remap_menubar (mw);
  2992.   
  2993.   /* Sync with the display.  Makes it feel better on X terms. */
  2994.   XFlush (XtDisplay (mw));
  2995. }
  2996.  
  2997. static void
  2998. handle_motion_event (XlwMenuWidget mw, XMotionEvent *ev,
  2999.              Boolean select_p)
  3000. {
  3001.   int x = ev->x_root;
  3002.   int y = ev->y_root;
  3003.   int state = ev->state;
  3004.   XMotionEvent *event= ev, dummy;
  3005.  
  3006.   /* allow motion events to be generated again */
  3007.   dummy.window = ev->window;
  3008.   if (ev->is_hint
  3009.       && XQueryPointer (XtDisplay (mw), dummy.window,
  3010.             &dummy.root, &dummy.subwindow,
  3011.             &dummy.x_root, &dummy.y_root,
  3012.             &dummy.x, &dummy.y,
  3013.             &dummy.state)
  3014.       && dummy.state == state
  3015.       && (dummy.x_root != x || dummy.y_root != y))
  3016.     {
  3017.       /* don't handle the event twice or that breaks bounce_down.  --Stig */
  3018.       dummy.type = ev->type;
  3019.       event = &dummy;
  3020.     }
  3021.  
  3022.   handle_single_motion_event (mw, event, select_p);
  3023. }
  3024.  
  3025. static void 
  3026. Start (Widget w, XEvent *ev, String *params, Cardinal *num_params)
  3027. {
  3028.   XlwMenuWidget mw = (XlwMenuWidget)w;
  3029.  
  3030.   if (!mw->menu.pointer_grabbed)
  3031.     {
  3032.       mw->menu.menu_post_time = ev->xbutton.time;
  3033.       mw->menu.menu_bounce_time = 0;
  3034.       mw->menu.next_release_must_exit = True;
  3035.       mw->menu.last_selected_val = NULL;
  3036.  
  3037.       XtCallCallbackList ((Widget)mw, mw->menu.open, NULL);
  3038.       
  3039.       /* notes the absolute position of the menubar window */
  3040.       mw->menu.windows [0].x = ev->xmotion.x_root - ev->xmotion.x;
  3041.       mw->menu.windows [0].y = ev->xmotion.y_root - ev->xmotion.y;
  3042.       
  3043.       XtGrabPointer ((Widget)mw, False,
  3044.              (ButtonMotionMask | ButtonReleaseMask | ButtonPressMask),
  3045.              GrabModeAsync, GrabModeAsync,
  3046.              None, mw->menu.cursor_shape,
  3047.              ((XButtonPressedEvent*)ev)->time);
  3048.       mw->menu.pointer_grabbed = True;
  3049.     }
  3050.  
  3051.   /* handles the down like a move, slots are mostly compatible */
  3052.   handle_motion_event (mw, &ev->xmotion, True);
  3053. }
  3054.  
  3055. static void 
  3056. Drag (Widget w, XEvent *ev, String *params, Cardinal *num_params)
  3057. {
  3058.   XlwMenuWidget mw = (XlwMenuWidget)w;
  3059.   handle_motion_event (mw, &ev->xmotion, False);
  3060. }
  3061.  
  3062. static void 
  3063. Select (Widget w, XEvent *ev, String *params, Cardinal *num_params)
  3064. {
  3065.   XlwMenuWidget mw = (XlwMenuWidget)w;
  3066.   widget_value *selected_item = mw->menu.old_stack [mw->menu.old_depth - 1];
  3067.   
  3068.   /* If user releases the button quickly, without selecting anything,
  3069.      after the initial down-click that brought the menu up,
  3070.      do nothing. */
  3071.   if ((selected_item == 0 || selected_item->call_data == 0)
  3072.       && (!mw->menu.next_release_must_exit
  3073.       || close_to_reference_time(w, mw->menu.menu_post_time, ev)))
  3074.     {
  3075.       mw->menu.next_release_must_exit = False;
  3076.       return;
  3077.     }
  3078.  
  3079.   /* pop down everything */
  3080.   mw->menu.new_depth = 1;
  3081.   remap_menubar (mw);
  3082.       
  3083.       /* Destroy() only gets called for popup menus.  Menubar widgets aren't
  3084.      destroyed when their menu panes get nuked. */
  3085.   if (mw->menu.pointer_grabbed)
  3086.     {
  3087.       XtUngrabPointer ((Widget)w, ev->xmotion.time);
  3088.       mw->menu.pointer_grabbed = False;
  3089.     }
  3090.   
  3091.   if (mw->menu.popped_up)
  3092.     {
  3093.       mw->menu.popped_up = False;
  3094.       XtPopdown (XtParent (mw));
  3095.     }
  3096.   
  3097.   /* callback */
  3098.   XtCallCallbackList ((Widget)mw, mw->menu.select, (XtPointer)selected_item);
  3099. }
  3100.  
  3101.  
  3102. /* Special code to pop-up a menu */
  3103. void
  3104. xlw_pop_up_menu (XlwMenuWidget mw, XButtonPressedEvent *event)
  3105. {
  3106.   int        x = event->x_root;
  3107.   int        y = event->y_root;
  3108.   int        w;
  3109.   int        h;
  3110.   int        borderwidth = mw->menu.shadow_thickness;
  3111.   Screen*    screen = XtScreen (mw);
  3112.  
  3113.   mw->menu.menu_post_time = event->time;
  3114.   mw->menu.menu_bounce_time = 0;
  3115.   mw->menu.next_release_must_exit = True;
  3116.   mw->menu.last_selected_val = NULL;
  3117.  
  3118.   XtCallCallbackList ((Widget)mw, mw->menu.open, NULL);
  3119.  
  3120.   size_menu (mw, 0);
  3121.  
  3122.   w = mw->menu.windows [0].width;
  3123.   h = mw->menu.windows [0].height;
  3124.  
  3125.   x -= borderwidth;
  3126.   y -= borderwidth;
  3127.   if (x < borderwidth)
  3128.     x = borderwidth;
  3129.   if (x + w + 2 * borderwidth > WidthOfScreen (screen))
  3130.     x = WidthOfScreen (screen) - w - 2 * borderwidth;
  3131.   if (y < borderwidth)
  3132.     y = borderwidth;
  3133.   if (y + h + 2 * borderwidth> HeightOfScreen (screen))
  3134.     y = HeightOfScreen (screen) - h - 2 * borderwidth;
  3135.  
  3136.   mw->menu.popped_up = True;
  3137.   XtConfigureWidget (XtParent (mw), x, y, w, h,
  3138.              XtParent (mw)->core.border_width);
  3139.   XtPopup (XtParent (mw), XtGrabExclusive);
  3140.   display_menu (mw, 0, False, NULL, NULL, NULL, NULL, NULL);
  3141.   if (!mw->menu.pointer_grabbed)
  3142.     {
  3143.       XtGrabPointer ((Widget)mw, False,
  3144.              (ButtonMotionMask | ButtonReleaseMask | ButtonPressMask),
  3145.              GrabModeAsync, GrabModeAsync,
  3146.              None, mw->menu.cursor_shape, event->time);
  3147.       mw->menu.pointer_grabbed = True;
  3148.     }
  3149.  
  3150.   mw->menu.windows [0].x = x + borderwidth;
  3151.   mw->menu.windows [0].y = y + borderwidth;
  3152.  
  3153.   handle_motion_event (mw, (XMotionEvent *) event, True);
  3154. }
  3155.  
  3156. /* #### unused */
  3157. #if 0
  3158. /*
  3159.  *    This is a horrible function which should not be needed.
  3160.  *    use it to put the resize method back the way the XlwMenu
  3161.  *    class initializer put it. Motif screws with this when
  3162.  *    the XlwMenu class gets instantiated.
  3163.  */
  3164. void
  3165. xlw_unmunge_class_resize (Widget w)
  3166. {
  3167.   if (w->core.widget_class->core_class.resize != XlwMenuResize)
  3168.     w->core.widget_class->core_class.resize = XlwMenuResize;
  3169. }
  3170. #endif /* 0 */
  3171.  
  3172.