code.delx.au - gnu-emacs/blob - lwlib/xlwmenu.c

   1 /* Implements a lightweight menubar widget.
   2    Copyright (C) 1992 Lucid, Inc.
   3
   4 This file is part of the Lucid Widget Library.
   5
   6 The Lucid Widget Library is free software; you can redistribute it and/or
   7 modify it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 The Lucid Widget Library is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Emacs; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20
  21 /* Created by devin@lucid.com */
  22
  23 #include <stdio.h>
  24
  25 #include <sys/types.h>
  26 #include <X11/Xos.h>
  27 #include <X11/IntrinsicP.h>
  28 #include <X11/ObjectP.h>
  29 #include <X11/StringDefs.h>
  30 #include <X11/cursorfont.h>
  31 #include <X11/bitmaps/gray>
  32 #include "xlwmenuP.h"
  33
  34 static int pointer_grabbed;
  35 static XEvent menu_post_event;
  36
  37 XFontStruct *xlwmenu_default_font;
  38
  39 static char
  40 xlwMenuTranslations [] =
  41 "<BtnDown>:       start()\n\
  42 <Motion>:         drag()\n\
  43 <BtnUp>:          select()\n\
  44 <Key>Shift_L:     nothing()\n\
  45 <Key>Shift_R:     nothing()\n\
  46 <Key>Meta_L:      nothing()\n\
  47 <Key>Meta_R:      nothing()\n\
  48 <Key>Control_L:   nothing()\n\
  49 <Key>Control_R:   nothing()\n\
  50 <Key>Hyper_L:     nothing()\n\
  51 <Key>Hyper_R:     nothing()\n\
  52 <Key>Super_L:     nothing()\n\
  53 <Key>Super_R:     nothing()\n\
  54 <Key>Alt_L:       nothing()\n\
  55 <Key>Alt_R:       nothing()\n\
  56 <Key>Caps_Lock:   nothing()\n\
  57 <Key>Shift_Lock:  nothing()\n\
  58 <KeyUp>Shift_L:   nothing()\n\
  59 <KeyUp>Shift_R:   nothing()\n\
  60 <KeyUp>Meta_L:    nothing()\n\
  61 <KeyUp>Meta_R:    nothing()\n\
  62 <KeyUp>Control_L: nothing()\n\
  63 <KeyUp>Control_R: nothing()\n\
  64 <KeyUp>Hyper_L:   nothing()\n\
  65 <KeyUp>Hyper_R:   nothing()\n\
  66 <KeyUp>Super_L:   nothing()\n\
  67 <KeyUp>Super_R:   nothing()\n\
  68 <KeyUp>Alt_L:     nothing()\n\
  69 <KeyUp>Alt_R:     nothing()\n\
  70 <KeyUp>Caps_Lock: nothing()\n\
  71 <KeyUp>Shift_Lock:nothing()\n\
  72 <Key>:            key()\n\
  73 <KeyUp>:          key()\n\
  74 ";
  75
  76 #define offset(field) XtOffset(XlwMenuWidget, field)
  77 static XtResource
  78 xlwMenuResources[] =
  79 {
  80   {XtNfont,  XtCFont, XtRFontStruct, sizeof(XFontStruct *),
  81      offset(menu.font),XtRString, "XtDefaultFont"},
  82   {XtNforeground, XtCForeground, XtRPixel, sizeof(Pixel),
  83      offset(menu.foreground), XtRString, "XtDefaultForeground"},
  84   {XtNbuttonForeground, XtCButtonForeground, XtRPixel, sizeof(Pixel),
  85      offset(menu.button_foreground), XtRString, "XtDefaultForeground"},
  86   {XtNmargin, XtCMargin, XtRDimension,  sizeof(Dimension),
  87      offset(menu.margin), XtRImmediate, (XtPointer)0},
  88   {XtNhorizontalSpacing, XtCMargin, XtRDimension,  sizeof(Dimension),
  89      offset(menu.horizontal_spacing), XtRImmediate, (XtPointer)3},
  90   {XtNverticalSpacing, XtCMargin, XtRDimension,  sizeof(Dimension),
  91      offset(menu.vertical_spacing), XtRImmediate, (XtPointer)1},
  92   {XtNarrowSpacing, XtCMargin, XtRDimension,  sizeof(Dimension),
  93      offset(menu.arrow_spacing), XtRImmediate, (XtPointer)10},
  94
  95   {XmNshadowThickness, XmCShadowThickness, XtRDimension,
  96      sizeof (Dimension), offset (menu.shadow_thickness),
  97      XtRImmediate, (XtPointer) 2},
  98   {XmNtopShadowColor, XmCTopShadowColor, XtRPixel, sizeof (Pixel),
  99      offset (menu.top_shadow_color), XtRImmediate, (XtPointer)-1},
 100   {XmNbottomShadowColor, XmCBottomShadowColor, XtRPixel, sizeof (Pixel),
 101      offset (menu.bottom_shadow_color), XtRImmediate, (XtPointer)-1},
 102   {XmNtopShadowPixmap, XmCTopShadowPixmap, XtRPixmap, sizeof (Pixmap),
 103      offset (menu.top_shadow_pixmap), XtRImmediate, (XtPointer)None},
 104   {XmNbottomShadowPixmap, XmCBottomShadowPixmap, XtRPixmap, sizeof (Pixmap),
 105      offset (menu.bottom_shadow_pixmap), XtRImmediate, (XtPointer)None},
 106
 107   {XtNopen, XtCCallback, XtRCallback, sizeof(XtPointer),
 108      offset(menu.open), XtRCallback, (XtPointer)NULL},
 109   {XtNselect, XtCCallback, XtRCallback, sizeof(XtPointer),
 110      offset(menu.select), XtRCallback, (XtPointer)NULL},
 111   {XtNmenu, XtCMenu, XtRPointer, sizeof(XtPointer),
 112      offset(menu.contents), XtRImmediate, (XtPointer)NULL},
 113   {XtNcursor, XtCCursor, XtRCursor, sizeof(Cursor),
 114      offset(menu.cursor_shape), XtRString, (XtPointer)"right_ptr"},
 115   {XtNhorizontal, XtCHorizontal, XtRInt, sizeof(int),
 116      offset(menu.horizontal), XtRImmediate, (XtPointer)True},
 117 };
 118 #undef offset
 119
 120 static Boolean XlwMenuSetValues();
 121 static void XlwMenuRealize();
 122 static void XlwMenuRedisplay();
 123 static void XlwMenuResize();
 124 static void XlwMenuInitialize();
 125 static void XlwMenuRedisplay();
 126 static void XlwMenuDestroy();
 127 static void XlwMenuClassInitialize();
 128 static void Start();
 129 static void Drag();
 130 static void Select();
 131 static void Key();
 132 static void Nothing();
 133
 134 static XtActionsRec
 135 xlwMenuActionsList [] =
 136 {
 137   {"start",             Start},
 138   {"drag",              Drag},
 139   {"select",            Select},
 140   {"key",               Key},
 141   {"nothing",           Nothing},
 142 };
 143
 144 #define SuperClass ((CoreWidgetClass)&coreClassRec)
 145
 146 XlwMenuClassRec xlwMenuClassRec =
 147 {
 148   {  /* CoreClass fields initialization */
 149     (WidgetClass) SuperClass,           /* superclass             */
 150     "XlwMenu",                          /* class_name             */
 151     sizeof(XlwMenuRec),                 /* size                   */
 152     XlwMenuClassInitialize,             /* class_initialize       */
 153     NULL,                               /* class_part_initialize  */
 154     FALSE,                              /* class_inited           */
 155     XlwMenuInitialize,                  /* initialize             */
 156     NULL,                               /* initialize_hook        */
 157     XlwMenuRealize,                     /* realize                */
 158     xlwMenuActionsList,                 /* actions                */
 159     XtNumber(xlwMenuActionsList),       /* num_actions            */
 160     xlwMenuResources,                   /* resources              */
 161     XtNumber(xlwMenuResources),         /* resource_count         */
 162     NULLQUARK,                          /* xrm_class              */
 163     TRUE,                               /* compress_motion        */
 164     TRUE,                               /* compress_exposure      */
 165     TRUE,                               /* compress_enterleave    */
 166     FALSE,                              /* visible_interest       */
 167     XlwMenuDestroy,                     /* destroy                */
 168     XlwMenuResize,                      /* resize                 */
 169     XlwMenuRedisplay,                   /* expose                 */
 170     XlwMenuSetValues,                   /* set_values             */
 171     NULL,                               /* set_values_hook        */
 172     XtInheritSetValuesAlmost,           /* set_values_almost      */
 173     NULL,                               /* get_values_hook        */
 174     NULL,                               /* accept_focus           */
 175     XtVersion,                          /* version                */
 176     NULL,                               /* callback_private       */
 177     xlwMenuTranslations,                /* tm_table               */
 178     XtInheritQueryGeometry,             /* query_geometry         */
 179     XtInheritDisplayAccelerator,        /* display_accelerator    */
 180     NULL                                /* extension              */
 181   },  /* XlwMenuClass fields initialization */
 182   {
 183     0                                   /* dummy */
 184   },
 185 };
 186
 187 WidgetClass xlwMenuWidgetClass = (WidgetClass) &xlwMenuClassRec;
 188
 189 int submenu_destroyed;
 190
 191 static int next_release_must_exit;
 192
 193 \f/* Utilities */
 194 static void
 195 push_new_stack (mw, val)
 196      XlwMenuWidget mw;
 197      widget_value* val;
 198 {
 199   if (!mw->menu.new_stack)
 200     {
 201       mw->menu.new_stack_length = 10;
 202       mw->menu.new_stack =
 203         (widget_value**)XtCalloc (mw->menu.new_stack_length,
 204                                   sizeof (widget_value*));
 205     }
 206   else if (mw->menu.new_depth == mw->menu.new_stack_length)
 207     {
 208       mw->menu.new_stack_length *= 2;
 209       mw->menu.new_stack =
 210         (widget_value**)XtRealloc ((char*)mw->menu.new_stack,
 211                                    mw->menu.new_stack_length * sizeof (widget_value*));
 212     }
 213   mw->menu.new_stack [mw->menu.new_depth++] = val;
 214 }
 215
 216 static void
 217 pop_new_stack_if_no_contents (mw)
 218      XlwMenuWidget mw;
 219 {
 220   if (mw->menu.new_depth)
 221     {
 222       if (!mw->menu.new_stack [mw->menu.new_depth - 1]->contents)
 223         mw->menu.new_depth -= 1;
 224     }
 225 }
 226
 227 static void
 228 make_old_stack_space (mw, n)
 229      XlwMenuWidget mw;
 230      int n;
 231 {
 232   if (!mw->menu.old_stack)
 233     {
 234       mw->menu.old_stack_length = 10;
 235       mw->menu.old_stack =
 236         (widget_value**)XtCalloc (mw->menu.old_stack_length,
 237                                   sizeof (widget_value*));
 238     }
 239   else if (mw->menu.old_stack_length < n)
 240     {
 241       mw->menu.old_stack_length *= 2;
 242       mw->menu.old_stack =
 243         (widget_value**)XtRealloc ((char*)mw->menu.old_stack,
 244                                    mw->menu.old_stack_length * sizeof (widget_value*));
 245     }
 246 }
 247
 248 \f/* Size code */
 249 static Boolean
 250 all_dashes_p (s)
 251      char *s;
 252 {
 253   char* p;
 254   for (p = s; *p == '-'; p++);
 255   return !*p;
 256 }
 257
 258 int
 259 string_width (mw, s)
 260      XlwMenuWidget mw;
 261      char *s;
 262 {
 263   XCharStruct xcs;
 264   int drop;
 265
 266   XTextExtents (mw->menu.font, s, strlen (s), &drop, &drop, &drop, &xcs);
 267   return xcs.width;
 268 }
 269
 270 static int
 271 arrow_width (mw)
 272      XlwMenuWidget mw;
 273 {
 274   return mw->menu.font->ascent / 2 | 1;
 275 }
 276
 277 static XtResource
 278 nameResource[] =
 279 {
 280   {"labelString",  "LabelString", XtRString, sizeof(String),
 281      0, XtRImmediate, 0},
 282 };
 283
 284 static char*
 285 resource_widget_value (mw, val)
 286      XlwMenuWidget mw;
 287      widget_value *val;
 288 {
 289   if (!val->toolkit_data)
 290     {
 291       char* resourced_name = NULL;
 292       char* complete_name;
 293       XtGetSubresources ((Widget) mw,
 294                          (XtPointer) &resourced_name,
 295                          val->name, val->name,
 296                          nameResource, 1, NULL, 0);
 297       if (!resourced_name)
 298         resourced_name = val->name;
 299       if (!val->value)
 300         {
 301           complete_name = (char *) XtMalloc (strlen (resourced_name) + 1);
 302           strcpy (complete_name, resourced_name);
 303         }
 304       else
 305         {
 306           int complete_length =
 307             strlen (resourced_name) + strlen (val->value) + 2;
 308           complete_name = XtMalloc (complete_length);
 309           *complete_name = 0;
 310           strcat (complete_name, resourced_name);
 311           strcat (complete_name, " ");
 312           strcat (complete_name, val->value);
 313         }
 314
 315       val->toolkit_data = complete_name;
 316       val->free_toolkit_data = True;
 317     }
 318   return (char*)val->toolkit_data;
 319 }
 320
 321 /* Returns the sizes of an item */
 322 static void
 323 size_menu_item (mw, val, horizontal_p, label_width, rest_width, height)
 324      XlwMenuWidget mw;
 325      widget_value* val;
 326      int horizontal_p;
 327      int* label_width;
 328      int* rest_width;
 329      int* height;
 330 {
 331   if (all_dashes_p (val->name))
 332     {
 333       *height = 2;
 334       *label_width = 1;
 335       *rest_width = 0;
 336     }
 337   else
 338     {
 339       *height =
 340         mw->menu.font->ascent + mw->menu.font->descent
 341           + 2 * mw->menu.vertical_spacing + 2 * mw->menu.shadow_thickness;
 342
 343       *label_width =
 344         string_width (mw, resource_widget_value (mw, val))
 345           + mw->menu.horizontal_spacing + mw->menu.shadow_thickness;
 346
 347       *rest_width =  mw->menu.horizontal_spacing + mw->menu.shadow_thickness;
 348       if (!horizontal_p)
 349         {
 350           if (val->contents)
 351             *rest_width += arrow_width (mw) + mw->menu.arrow_spacing;
 352           else if (val->key)
 353             *rest_width +=
 354               string_width (mw, val->key) + mw->menu.arrow_spacing;
 355         }
 356     }
 357 }
 358
 359 static void
 360 size_menu (mw, level)
 361      XlwMenuWidget mw;
 362      int level;
 363 {
 364   unsigned int  label_width = 0;
 365   int           rest_width = 0;
 366   int           max_rest_width = 0;
 367   unsigned int  height = 0;
 368   int           horizontal_p = mw->menu.horizontal && (level == 0);
 369   widget_value* val;
 370   window_state* ws;
 371
 372   if (level >= mw->menu.old_depth)
 373     abort ();
 374
 375   ws = &mw->menu.windows [level];
 376   ws->width = 0;
 377   ws->height = 0;
 378   ws->label_width = 0;
 379
 380   for (val = mw->menu.old_stack [level]->contents; val; val = val->next)
 381     {
 382       size_menu_item (mw, val, horizontal_p, &label_width, &rest_width,
 383                       &height);
 384       if (horizontal_p)
 385         {
 386           ws->width += label_width + rest_width;
 387           if (height > ws->height)
 388             ws->height = height;
 389         }
 390       else
 391         {
 392           if (label_width > ws->label_width)
 393             ws->label_width = label_width;
 394           if (rest_width > max_rest_width)
 395             max_rest_width = rest_width;
 396           ws->height += height;
 397         }
 398     }
 399
 400   if (horizontal_p)
 401     ws->label_width = 0;
 402   else
 403     ws->width = ws->label_width + max_rest_width;
 404
 405   ws->width += 2 * mw->menu.shadow_thickness;
 406   ws->height += 2 * mw->menu.shadow_thickness;
 407 }
 408
 409
 410 \f/* Display code */
 411 static void
 412 draw_arrow (mw, window, gc, x, y, width)
 413      XlwMenuWidget mw;
 414      Window window;
 415      GC gc;
 416      int x;
 417      int y;
 418      int width;
 419 {
 420   XPoint points [3];
 421   points [0].x = x;
 422   points [0].y = y + mw->menu.font->ascent;
 423   points [1].x = x;
 424   points [1].y = y;
 425   points [2].x = x + width;
 426   points [2].y = y + mw->menu.font->ascent / 2;
 427
 428   XFillPolygon (XtDisplay (mw), window, gc, points, 3, Convex,
 429                 CoordModeOrigin);
 430 }
 431
 432 static void
 433 draw_shadow_rectangle (mw, window, x, y, width, height, erase_p)
 434      XlwMenuWidget mw;
 435      Window window;
 436      int x;
 437      int y;
 438      int width;
 439      int height;
 440      int erase_p;
 441 {
 442   Display *dpy = XtDisplay (mw);
 443   GC top_gc = !erase_p ? mw->menu.shadow_top_gc : mw->menu.background_gc;
 444   GC bottom_gc = !erase_p ? mw->menu.shadow_bottom_gc : mw->menu.background_gc;
 445   int thickness = mw->menu.shadow_thickness;
 446   XPoint points [4];
 447   points [0].x = x;
 448   points [0].y = y;
 449   points [1].x = x + width;
 450   points [1].y = y;
 451   points [2].x = x + width - thickness;
 452   points [2].y = y + thickness;
 453   points [3].x = x;
 454   points [3].y = y + thickness;
 455   XFillPolygon (dpy, window, top_gc, points, 4, Convex, CoordModeOrigin);
 456   points [0].x = x;
 457   points [0].y = y + thickness;
 458   points [1].x = x;
 459   points [1].y = y + height;
 460   points [2].x = x + thickness;
 461   points [2].y = y + height - thickness;
 462   points [3].x = x + thickness;
 463   points [3].y = y + thickness;
 464   XFillPolygon (dpy, window, top_gc, points, 4, Convex, CoordModeOrigin);
 465   points [0].x = x + width;
 466   points [0].y = y;
 467   points [1].x = x + width - thickness;
 468   points [1].y = y + thickness;
 469   points [2].x = x + width - thickness;
 470   points [2].y = y + height - thickness;
 471   points [3].x = x + width;
 472   points [3].y = y + height - thickness;
 473   XFillPolygon (dpy, window, bottom_gc, points, 4, Convex, CoordModeOrigin);
 474   points [0].x = x;
 475   points [0].y = y + height;
 476   points [1].x = x + width;
 477   points [1].y = y + height;
 478   points [2].x = x + width;
 479   points [2].y = y + height - thickness;
 480   points [3].x = x + thickness;
 481   points [3].y = y + height - thickness;
 482   XFillPolygon (dpy, window, bottom_gc, points, 4, Convex, CoordModeOrigin);
 483 }
 484
 485
 486 /* Display the menu item and increment where.x and where.y to show how large
 487 ** the menu item was.
 488 */
 489 static void
 490 display_menu_item (mw, val, ws, where, highlighted_p, horizontal_p, just_compute_p)
 491      XlwMenuWidget mw;
 492      widget_value* val;
 493      window_state* ws;
 494      XPoint* where;
 495      Boolean highlighted_p;
 496      Boolean horizontal_p;
 497      Boolean just_compute_p;
 498 {
 499   GC deco_gc;
 500   GC text_gc;
 501   int font_ascent = mw->menu.font->ascent;
 502   int font_descent = mw->menu.font->descent;
 503   int shadow = mw->menu.shadow_thickness;
 504   int separator_p = all_dashes_p (val->name);
 505   int h_spacing = mw->menu.horizontal_spacing;
 506   int v_spacing = mw->menu.vertical_spacing;
 507   int label_width;
 508   int rest_width;
 509   int height;
 510   int width;
 511   int button_p;
 512
 513   /* compute the sizes of the item */
 514   size_menu_item (mw, val, horizontal_p, &label_width, &rest_width, &height);
 515
 516   if (horizontal_p)
 517     width = label_width + rest_width;
 518   else
 519     {
 520       label_width = ws->label_width;
 521       width = ws->width - 2 * shadow;
 522     }
 523
 524 #if 0
 525   /* see if it should be a button in the menubar */
 526   button_p = horizontal_p && val->call_data;
 527 #endif
 528   button_p = 0;
 529
 530   /* Only highlight an enabled item that has a callback. */
 531   if (highlighted_p)
 532     if (!val->enabled || !(val->call_data || val->contents))
 533       highlighted_p = 0;
 534
 535   /* do the drawing. */
 536   if (!just_compute_p)
 537     {
 538       /* Add the shadow border of the containing menu */
 539       int x = where->x + shadow;
 540       int y = where->y + shadow;
 541
 542       /* pick the foreground and background GC. */
 543       if (val->enabled)
 544         text_gc = button_p ? mw->menu.button_gc : mw->menu.foreground_gc;
 545       else
 546         text_gc =
 547           button_p ? mw->menu.inactive_button_gc : mw->menu.inactive_gc;
 548       deco_gc = mw->menu.foreground_gc;
 549
 550       if (separator_p)
 551         {
 552           XDrawLine (XtDisplay (mw), ws->window, mw->menu.shadow_bottom_gc,
 553                      x, y, x + width, y);
 554           XDrawLine (XtDisplay (mw), ws->window, mw->menu.shadow_top_gc,
 555                      x, y + 1, x + width, y + 1);
 556         }
 557       else
 558         {
 559           int x_offset = x + h_spacing + shadow;
 560           char* display_string = resource_widget_value (mw, val);
 561           draw_shadow_rectangle (mw, ws->window, x, y, width, height, True);
 562
 563           /* Deal with centering a menu title. */
 564           if (!horizontal_p && !val->contents && !val->call_data)
 565             {
 566               int l = string_width (mw, display_string);
 567
 568               if (width > l)
 569                 x_offset = (width - l) >> 1;
 570             }
 571           XDrawString (XtDisplay (mw), ws->window, text_gc, x_offset,
 572                        y + v_spacing + shadow + font_ascent,
 573                        display_string, strlen (display_string));
 574
 575           if (!horizontal_p)
 576             {
 577               if (val->contents)
 578                 {
 579                   int a_w = arrow_width (mw);
 580                   draw_arrow (mw, ws->window, deco_gc,
 581                               x + width - arrow_width (mw)
 582                               - mw->menu.horizontal_spacing
 583                               - mw->menu.shadow_thickness,
 584                               y + v_spacing + shadow, a_w);
 585                 }
 586               else if (val->key)
 587                 {
 588                   XDrawString (XtDisplay (mw), ws->window, text_gc,
 589                                x + label_width + mw->menu.arrow_spacing,
 590                                y + v_spacing + shadow + font_ascent,
 591                                val->key, strlen (val->key));
 592                 }
 593             }
 594
 595           else if (button_p)
 596             {
 597 #if 1
 598               XDrawRectangle (XtDisplay (mw), ws->window, deco_gc,
 599                               x + shadow, y + shadow,
 600                               label_width + h_spacing - 1,
 601                               font_ascent + font_descent + 2 * v_spacing - 1);
 602               draw_shadow_rectangle (mw, ws->window, x, y, width, height,
 603                                      False);
 604 #else
 605               highlighted_p = True;
 606 #endif
 607             }
 608           else
 609             {
 610               XDrawRectangle (XtDisplay (mw), ws->window,
 611                               mw->menu.background_gc,
 612                               x + shadow, y + shadow,
 613                               label_width + h_spacing - 1,
 614                               font_ascent + font_descent + 2 * v_spacing - 1);
 615               draw_shadow_rectangle (mw, ws->window, x, y, width, height,
 616                                      True);
 617             }
 618
 619           if (highlighted_p)
 620             draw_shadow_rectangle (mw, ws->window, x, y, width, height, False);
 621         }
 622     }
 623
 624   where->x += width;
 625   where->y += height;
 626 }
 627
 628 static void
 629 display_menu (mw, level, just_compute_p, highlighted_pos, hit, hit_return,
 630               this, that)
 631      XlwMenuWidget mw;
 632      int level;
 633      Boolean just_compute_p;
 634      XPoint* highlighted_pos;
 635      XPoint* hit;
 636      widget_value** hit_return;
 637      widget_value* this;
 638      widget_value* that;
 639 {
 640   widget_value* val;
 641   widget_value* following_item;
 642   window_state* ws;
 643   XPoint        where;
 644   int horizontal_p = mw->menu.horizontal && (level == 0);
 645   int highlighted_p;
 646   int just_compute_this_one_p;
 647
 648   if (level >= mw->menu.old_depth)
 649     abort ();
 650
 651   if (level < mw->menu.old_depth - 1)
 652     following_item = mw->menu.old_stack [level + 1];
 653   else
 654     following_item = NULL;
 655
 656   if (hit)
 657     *hit_return = NULL;
 658
 659   where.x = 0;
 660   where.y = 0;
 661
 662   ws = &mw->menu.windows [level];
 663   for (val = mw->menu.old_stack [level]->contents; val; val = val->next)
 664     {
 665       highlighted_p = val == following_item;
 666       if (highlighted_p && highlighted_pos)
 667         {
 668           if (horizontal_p)
 669             highlighted_pos->x = where.x;
 670           else
 671             highlighted_pos->y = where.y;
 672         }
 673
 674       just_compute_this_one_p =
 675         just_compute_p || ((this || that) && val != this &&  val != that);
 676
 677       display_menu_item (mw, val, ws, &where, highlighted_p, horizontal_p,
 678                          just_compute_this_one_p);
 679
 680       if (highlighted_p && highlighted_pos)
 681         {
 682           if (horizontal_p)
 683             highlighted_pos->y = where.y;
 684           else
 685             highlighted_pos->x = where.x;
 686         }
 687
 688       if (hit
 689           && !*hit_return
 690           && (horizontal_p ? hit->x < where.x : hit->y < where.y)
 691           && !all_dashes_p (val->name))
 692         *hit_return = val;
 693
 694       if (horizontal_p)
 695         where.y = 0;
 696       else
 697         where.x = 0;
 698     }
 699
 700   if (!just_compute_p)
 701     draw_shadow_rectangle (mw, ws->window, 0, 0, ws->width, ws->height, False);
 702 }
 703
 704 \f/* Motion code */
 705 static void
 706 set_new_state (mw, val, level)
 707      XlwMenuWidget mw;
 708      widget_value* val;
 709      int level;
 710 {
 711   int i;
 712
 713   mw->menu.new_depth = 0;
 714   for (i = 0; i < level; i++)
 715     push_new_stack (mw, mw->menu.old_stack [i]);
 716   push_new_stack (mw, val);
 717 }
 718
 719 static void
 720 make_windows_if_needed (mw, n)
 721      XlwMenuWidget mw;
 722      int n;
 723 {
 724   int i;
 725   int start_at;
 726   XSetWindowAttributes xswa;
 727   int mask;
 728   Window root = RootWindowOfScreen (DefaultScreenOfDisplay (XtDisplay (mw)));
 729   window_state* windows;
 730
 731   if (mw->menu.windows_length >= n)
 732     return;
 733
 734   xswa.save_under = True;
 735   xswa.override_redirect = True;
 736   xswa.background_pixel = mw->core.background_pixel;
 737   xswa.border_pixel = mw->core.border_pixel;
 738   xswa.event_mask =
 739     ExposureMask | PointerMotionMask | PointerMotionHintMask
 740       | ButtonReleaseMask | ButtonPressMask;
 741   xswa.cursor = mw->menu.cursor_shape;
 742   mask = CWSaveUnder | CWOverrideRedirect | CWBackPixel | CWBorderPixel
 743     | CWEventMask | CWCursor;
 744
 745   if (!mw->menu.windows)
 746     {
 747       mw->menu.windows =
 748         (window_state*)XtMalloc (n * sizeof (window_state));
 749       start_at = 0;
 750     }
 751   else
 752     {
 753       mw->menu.windows =
 754         (window_state*)XtRealloc ((char*)mw->menu.windows,
 755                                   n * sizeof (window_state));
 756       start_at = mw->menu.windows_length;
 757     }
 758   mw->menu.windows_length = n;
 759
 760   windows = mw->menu.windows;
 761
 762   for (i = start_at; i < n; i++)
 763    {
 764      windows [i].x = 0;
 765      windows [i].y = 0;
 766      windows [i].width = 1;
 767      windows [i].height = 1;
 768      windows [i].window =
 769        XCreateWindow (XtDisplay (mw), root, 0, 0, 1, 1,
 770                       0, 0, CopyFromParent, CopyFromParent, mask, &xswa);
 771   }
 772 }
 773
 774 /* Make the window fit in the screen */
 775 static void
 776 fit_to_screen (mw, ws, previous_ws, horizontal_p)
 777      XlwMenuWidget mw;
 778      window_state* ws;
 779      window_state* previous_ws;
 780      Boolean horizontal_p;
 781 {
 782   unsigned int screen_width = WidthOfScreen (XtScreen (mw));
 783   unsigned int screen_height = HeightOfScreen (XtScreen (mw));
 784
 785   if (ws->x < 0)
 786     ws->x = 0;
 787   else if (ws->x + ws->width > screen_width)
 788     {
 789       if (!horizontal_p)
 790         ws->x = previous_ws->x - ws->width;
 791       else
 792         ws->x = screen_width - ws->width;
 793       if (ws->x < 0)
 794         ws->x = 0;
 795     }
 796   if (ws->y < 0)
 797     ws->y = 0;
 798   else if (ws->y + ws->height > screen_height)
 799     {
 800       if (horizontal_p)
 801         ws->y = previous_ws->y - ws->height;
 802       else
 803         ws->y = screen_height - ws->height;
 804       if (ws->y < 0)
 805         ws->y = 0;
 806     }
 807 }
 808
 809 /* Updates old_stack from new_stack and redisplays. */
 810 static void
 811 remap_menubar (mw)
 812      XlwMenuWidget mw;
 813 {
 814   int i;
 815   int last_same;
 816   XPoint selection_position;
 817   int old_depth = mw->menu.old_depth;
 818   int new_depth = mw->menu.new_depth;
 819   widget_value** old_stack;
 820   widget_value** new_stack;
 821   window_state* windows;
 822   widget_value* old_selection;
 823   widget_value* new_selection;
 824
 825   /* Check that enough windows and old_stack are ready. */
 826   make_windows_if_needed (mw, new_depth);
 827   make_old_stack_space (mw, new_depth);
 828   windows = mw->menu.windows;
 829   old_stack = mw->menu.old_stack;
 830   new_stack = mw->menu.new_stack;
 831
 832   /* compute the last identical different entry */
 833   for (i = 1; i < old_depth && i < new_depth; i++)
 834     if (old_stack [i] != new_stack [i])
 835       break;
 836   last_same = i - 1;
 837
 838   /* Memorize the previously selected item to be able to refresh it */
 839   old_selection = last_same + 1 < old_depth ? old_stack [last_same + 1] : NULL;
 840   if (old_selection && !old_selection->enabled)
 841     old_selection = NULL;
 842   new_selection = last_same + 1 < new_depth ? new_stack [last_same + 1] : NULL;
 843   if (new_selection && !new_selection->enabled)
 844     new_selection = NULL;
 845
 846   /* updates old_state from new_state.  It has to be done now because
 847      display_menu (called below) uses the old_stack to know what to display. */
 848   for (i = last_same + 1; i < new_depth; i++)
 849     old_stack [i] = new_stack [i];
 850   mw->menu.old_depth = new_depth;
 851
 852   /* refresh the last selection */
 853   selection_position.x = 0;
 854   selection_position.y = 0;
 855   display_menu (mw, last_same, new_selection == old_selection,
 856                 &selection_position, NULL, NULL, old_selection, new_selection);
 857
 858   /* Now popup the new menus */
 859   for (i = last_same + 1; i < new_depth && new_stack [i]->contents; i++)
 860     {
 861       window_state* previous_ws = &windows [i - 1];
 862       window_state* ws = &windows [i];
 863
 864       ws->x =
 865         previous_ws->x + selection_position.x + mw->menu.shadow_thickness;
 866       if (!mw->menu.horizontal || i > 1)
 867         ws->x += mw->menu.shadow_thickness;
 868       ws->y =
 869         previous_ws->y + selection_position.y + mw->menu.shadow_thickness;
 870
 871       size_menu (mw, i);
 872
 873       fit_to_screen (mw, ws, previous_ws, mw->menu.horizontal && i == 1);
 874
 875       XClearWindow (XtDisplay (mw), ws->window);
 876       XMoveResizeWindow (XtDisplay (mw), ws->window, ws->x, ws->y,
 877                          ws->width, ws->height);
 878       XMapRaised (XtDisplay (mw), ws->window);
 879       display_menu (mw, i, False, &selection_position, NULL, NULL, NULL, NULL);
 880     }
 881
 882   /* unmap the menus that popped down */
 883   for (i = new_depth - 1; i < old_depth; i++)
 884     if (i >= new_depth || !new_stack [i]->contents)
 885       XUnmapWindow (XtDisplay (mw), windows [i].window);
 886 }
 887
 888 static Boolean
 889 motion_event_is_in_menu (mw, ev, level, relative_pos)
 890      XlwMenuWidget mw;
 891      XMotionEvent* ev;
 892      int level;
 893      XPoint* relative_pos;
 894 {
 895   window_state* ws = &mw->menu.windows [level];
 896   int x = level == 0 ? ws->x : ws->x + mw->menu.shadow_thickness;
 897   int y = level == 0 ? ws->y : ws->y + mw->menu.shadow_thickness;
 898   relative_pos->x = ev->x_root - x;
 899   relative_pos->y = ev->y_root - y;
 900   return (x < ev->x_root && ev->x_root < x + ws->width
 901           && y < ev->y_root && ev->y_root < y + ws->height);
 902 }
 903
 904 static Boolean
 905 map_event_to_widget_value (mw, ev, val, level)
 906      XlwMenuWidget mw;
 907      XMotionEvent* ev;
 908      widget_value** val;
 909      int* level;
 910 {
 911   int           i;
 912   XPoint        relative_pos;
 913   window_state* ws;
 914
 915   *val = NULL;
 916
 917   /* Find the window */
 918   for (i = mw->menu.old_depth - 1; i >= 0; i--)
 919     {
 920       ws = &mw->menu.windows [i];
 921       if (ws && motion_event_is_in_menu (mw, ev, i, &relative_pos))
 922         {
 923           display_menu (mw, i, True, NULL, &relative_pos, val, NULL, NULL);
 924
 925           if (*val)
 926             {
 927               *level = i + 1;
 928               return True;
 929             }
 930         }
 931     }
 932   return False;
 933 }
 934
 935 \f/* Procedures */
 936 static void
 937 make_drawing_gcs (mw)
 938      XlwMenuWidget mw;
 939 {
 940   XGCValues xgcv;
 941
 942   xgcv.font = mw->menu.font->fid;
 943   xgcv.foreground = mw->menu.foreground;
 944   xgcv.background = mw->core.background_pixel;
 945   mw->menu.foreground_gc = XtGetGC ((Widget)mw,
 946                                     GCFont | GCForeground | GCBackground,
 947                                     &xgcv);
 948
 949   xgcv.font = mw->menu.font->fid;
 950   xgcv.foreground = mw->menu.button_foreground;
 951   xgcv.background = mw->core.background_pixel;
 952   mw->menu.button_gc = XtGetGC ((Widget)mw,
 953                                 GCFont | GCForeground | GCBackground,
 954                                 &xgcv);
 955
 956   xgcv.font = mw->menu.font->fid;
 957   xgcv.foreground = mw->menu.foreground;
 958   xgcv.background = mw->core.background_pixel;
 959   xgcv.fill_style = FillStippled;
 960   xgcv.stipple = mw->menu.gray_pixmap;
 961   mw->menu.inactive_gc = XtGetGC ((Widget)mw,
 962                                   (GCFont | GCForeground | GCBackground
 963                                    | GCFillStyle | GCStipple), &xgcv);
 964
 965   xgcv.font = mw->menu.font->fid;
 966   xgcv.foreground = mw->menu.button_foreground;
 967   xgcv.background = mw->core.background_pixel;
 968   xgcv.fill_style = FillStippled;
 969   xgcv.stipple = mw->menu.gray_pixmap;
 970   mw->menu.inactive_button_gc = XtGetGC ((Widget)mw,
 971                                   (GCFont | GCForeground | GCBackground
 972                                    | GCFillStyle | GCStipple), &xgcv);
 973
 974   xgcv.font = mw->menu.font->fid;
 975   xgcv.foreground = mw->core.background_pixel;
 976   xgcv.background = mw->menu.foreground;
 977   mw->menu.background_gc = XtGetGC ((Widget)mw,
 978                                     GCFont | GCForeground | GCBackground,
 979                                     &xgcv);
 980 }
 981
 982 static void
 983 release_drawing_gcs (mw)
 984      XlwMenuWidget mw;
 985 {
 986   XtReleaseGC ((Widget) mw, mw->menu.foreground_gc);
 987   XtReleaseGC ((Widget) mw, mw->menu.button_gc);
 988   XtReleaseGC ((Widget) mw, mw->menu.inactive_gc);
 989   XtReleaseGC ((Widget) mw, mw->menu.inactive_button_gc);
 990   XtReleaseGC ((Widget) mw, mw->menu.background_gc);
 991   /* let's get some segvs if we try to use these... */
 992   mw->menu.foreground_gc = (GC) -1;
 993   mw->menu.button_gc = (GC) -1;
 994   mw->menu.inactive_gc = (GC) -1;
 995   mw->menu.inactive_button_gc = (GC) -1;
 996   mw->menu.background_gc = (GC) -1;
 997 }
 998
 999 #define MINL(x,y) ((((unsigned long) (x)) < ((unsigned long) (y))) \
1000                    ? ((unsigned long) (x)) : ((unsigned long) (y)))
1001
1002 static void
1003 make_shadow_gcs (mw)
1004      XlwMenuWidget mw;
1005 {
1006   XGCValues xgcv;
1007   unsigned long pm = 0;
1008   Display *dpy = XtDisplay ((Widget) mw);
1009   Colormap cmap = DefaultColormapOfScreen (XtScreen ((Widget) mw));
1010   XColor topc, botc;
1011   int top_frobbed = 0, bottom_frobbed = 0;
1012
1013   if (mw->menu.top_shadow_color == -1)
1014     mw->menu.top_shadow_color = mw->core.background_pixel;
1015   if (mw->menu.bottom_shadow_color == -1)
1016     mw->menu.bottom_shadow_color = mw->menu.foreground;
1017
1018   if (mw->menu.top_shadow_color == mw->core.background_pixel ||
1019       mw->menu.top_shadow_color == mw->menu.foreground)
1020     {
1021       topc.pixel = mw->core.background_pixel;
1022       XQueryColor (dpy, cmap, &topc);
1023       /* don't overflow/wrap! */
1024       topc.red   = MINL (65535, topc.red   * 1.2);
1025       topc.green = MINL (65535, topc.green * 1.2);
1026       topc.blue  = MINL (65535, topc.blue  * 1.2);
1027       if (XAllocColor (dpy, cmap, &topc))
1028         {
1029           mw->menu.top_shadow_color = topc.pixel;
1030           top_frobbed = 1;
1031         }
1032     }
1033   if (mw->menu.bottom_shadow_color == mw->menu.foreground ||
1034       mw->menu.bottom_shadow_color == mw->core.background_pixel)
1035     {
1036       botc.pixel = mw->core.background_pixel;
1037       XQueryColor (dpy, cmap, &botc);
1038       botc.red   *= 0.6;
1039       botc.green *= 0.6;
1040       botc.blue  *= 0.6;
1041       if (XAllocColor (dpy, cmap, &botc))
1042         {
1043           mw->menu.bottom_shadow_color = botc.pixel;
1044           bottom_frobbed = 1;
1045         }
1046     }
1047
1048   if (top_frobbed && bottom_frobbed)
1049     {
1050       int top_avg = ((topc.red / 3) + (topc.green / 3) + (topc.blue / 3));
1051       int bot_avg = ((botc.red / 3) + (botc.green / 3) + (botc.blue / 3));
1052       if (bot_avg > top_avg)
1053         {
1054           Pixel tmp = mw->menu.top_shadow_color;
1055           mw->menu.top_shadow_color = mw->menu.bottom_shadow_color;
1056           mw->menu.bottom_shadow_color = tmp;
1057         }
1058       else if (topc.pixel == botc.pixel)
1059         {
1060           if (botc.pixel == mw->menu.foreground)
1061             mw->menu.top_shadow_color = mw->core.background_pixel;
1062           else
1063             mw->menu.bottom_shadow_color = mw->menu.foreground;
1064         }
1065     }
1066
1067   if (!mw->menu.top_shadow_pixmap &&
1068       mw->menu.top_shadow_color == mw->core.background_pixel)
1069     {
1070       mw->menu.top_shadow_pixmap = mw->menu.gray_pixmap;
1071       mw->menu.top_shadow_color = mw->menu.foreground;
1072     }
1073   if (!mw->menu.bottom_shadow_pixmap &&
1074       mw->menu.bottom_shadow_color == mw->core.background_pixel)
1075     {
1076       mw->menu.bottom_shadow_pixmap = mw->menu.gray_pixmap;
1077       mw->menu.bottom_shadow_color = mw->menu.foreground;
1078     }
1079
1080   xgcv.fill_style = FillStippled;
1081   xgcv.foreground = mw->menu.top_shadow_color;
1082   xgcv.stipple = mw->menu.top_shadow_pixmap;
1083   pm = (xgcv.stipple ? GCStipple|GCFillStyle : 0);
1084   mw->menu.shadow_top_gc = XtGetGC ((Widget)mw, GCForeground | pm, &xgcv);
1085
1086   xgcv.foreground = mw->menu.bottom_shadow_color;
1087   xgcv.stipple = mw->menu.bottom_shadow_pixmap;
1088   pm = (xgcv.stipple ? GCStipple|GCFillStyle : 0);
1089   mw->menu.shadow_bottom_gc = XtGetGC ((Widget)mw, GCForeground | pm, &xgcv);
1090 }
1091
1092
1093 static void
1094 release_shadow_gcs (mw)
1095      XlwMenuWidget mw;
1096 {
1097   XtReleaseGC ((Widget) mw, mw->menu.shadow_top_gc);
1098   XtReleaseGC ((Widget) mw, mw->menu.shadow_bottom_gc);
1099 }
1100
1101 static void
1102 XlwMenuInitialize (request, mw, args, num_args)
1103      Widget request;
1104      XlwMenuWidget mw;
1105      ArgList args;
1106      Cardinal *num_args;
1107 {
1108   /* Get the GCs and the widget size */
1109   XSetWindowAttributes xswa;
1110   int mask;
1111
1112   Window window = RootWindowOfScreen (DefaultScreenOfDisplay (XtDisplay (mw)));
1113   Display* display = XtDisplay (mw);
1114
1115 #if 0
1116   widget_value *tem = (widget_value *) XtMalloc (sizeof (widget_value));
1117
1118   /* _XtCreate is freeing the object that was passed to us,
1119      so make a copy that we will actually keep.  */
1120   lwlib_bcopy (mw->menu.contents, tem, sizeof (widget_value));
1121   mw->menu.contents = tem;
1122 #endif
1123
1124 /*  mw->menu.cursor = XCreateFontCursor (display, mw->menu.cursor_shape); */
1125   mw->menu.cursor = mw->menu.cursor_shape;
1126
1127   mw->menu.gray_pixmap
1128     = XCreatePixmapFromBitmapData (display, window, gray_bits,
1129                                    gray_width, gray_height,
1130                                    (unsigned long)1, (unsigned long)0, 1);
1131
1132   /* I don't understand why this ends up 0 sometimes,
1133      but it does.  This kludge works around it.
1134      Can anyone find a real fix?   -- rms.  */
1135   if (mw->menu.font == 0)
1136     mw->menu.font = xlwmenu_default_font;
1137
1138   make_drawing_gcs (mw);
1139   make_shadow_gcs (mw);
1140
1141   xswa.background_pixel = mw->core.background_pixel;
1142   xswa.border_pixel = mw->core.border_pixel;
1143   mask = CWBackPixel | CWBorderPixel;
1144
1145   mw->menu.popped_up = False;
1146
1147   mw->menu.old_depth = 1;
1148   mw->menu.old_stack = (widget_value**)XtMalloc (sizeof (widget_value*));
1149   mw->menu.old_stack_length = 1;
1150   mw->menu.old_stack [0] = mw->menu.contents;
1151
1152   mw->menu.new_depth = 0;
1153   mw->menu.new_stack = 0;
1154   mw->menu.new_stack_length = 0;
1155   push_new_stack (mw, mw->menu.contents);
1156
1157   mw->menu.windows = (window_state*)XtMalloc (sizeof (window_state));
1158   mw->menu.windows_length = 1;
1159   mw->menu.windows [0].x = 0;
1160   mw->menu.windows [0].y = 0;
1161   mw->menu.windows [0].width = 0;
1162   mw->menu.windows [0].height = 0;
1163   size_menu (mw, 0);
1164
1165   mw->core.width = mw->menu.windows [0].width;
1166   mw->core.height = mw->menu.windows [0].height;
1167 }
1168
1169 static void
1170 XlwMenuClassInitialize ()
1171 {
1172 }
1173
1174 static void
1175 XlwMenuRealize (w, valueMask, attributes)
1176      Widget w;
1177      Mask *valueMask;
1178      XSetWindowAttributes *attributes;
1179 {
1180   XlwMenuWidget mw = (XlwMenuWidget)w;
1181   XSetWindowAttributes xswa;
1182   int mask;
1183
1184   (*xlwMenuWidgetClass->core_class.superclass->core_class.realize)
1185     (w, valueMask, attributes);
1186
1187   xswa.save_under = True;
1188   xswa.cursor = mw->menu.cursor_shape;
1189   mask = CWSaveUnder | CWCursor;
1190   XChangeWindowAttributes (XtDisplay (w), XtWindow (w), mask, &xswa);
1191
1192   mw->menu.windows [0].window = XtWindow (w);
1193   mw->menu.windows [0].x = w->core.x;
1194   mw->menu.windows [0].y = w->core.y;
1195   mw->menu.windows [0].width = w->core.width;
1196   mw->menu.windows [0].height = w->core.height;
1197 }
1198
1199 /* Only the toplevel menubar/popup is a widget so it's the only one that
1200    receives expose events through Xt.  So we repaint all the other panes
1201    when receiving an Expose event. */
1202 static void
1203 XlwMenuRedisplay (w, ev, region)
1204      Widget w;
1205      XEvent* ev;
1206      Region region;
1207 {
1208   XlwMenuWidget mw = (XlwMenuWidget)w;
1209   int i;
1210
1211   /* If we have a depth beyond 1, it's because a submenu was displayed.
1212      If the submenu has been destroyed, set the depth back to 1.  */
1213   if (submenu_destroyed)
1214     {
1215       mw->menu.old_depth = 1;
1216       submenu_destroyed = 0;
1217     }
1218
1219   for (i = 0; i < mw->menu.old_depth; i++)
1220     display_menu (mw, i, False, NULL, NULL, NULL, NULL, NULL);
1221 }
1222
1223 static void
1224 XlwMenuDestroy (w)
1225      Widget w;
1226 {
1227   int i;
1228   XlwMenuWidget mw = (XlwMenuWidget) w;
1229
1230   if (pointer_grabbed)
1231     XtUngrabPointer ((Widget)w, CurrentTime);
1232   pointer_grabbed = 0;
1233
1234   submenu_destroyed = 1;
1235
1236   release_drawing_gcs (mw);
1237   release_shadow_gcs (mw);
1238
1239   /* this doesn't come from the resource db but is created explicitly
1240      so we must free it ourselves. */
1241   XFreePixmap (XtDisplay (mw), mw->menu.gray_pixmap);
1242   mw->menu.gray_pixmap = (Pixmap) -1;
1243
1244 #if 0
1245   /* Do free mw->menu.contents because nowadays we copy it
1246      during initialization.  */
1247   XtFree (mw->menu.contents);
1248 #endif
1249
1250   /* Don't free mw->menu.contents because that comes from our creator.
1251      The `*_stack' elements are just pointers into `contents' so leave
1252      that alone too.  But free the stacks themselves. */
1253   if (mw->menu.old_stack) XtFree ((char *) mw->menu.old_stack);
1254   if (mw->menu.new_stack) XtFree ((char *) mw->menu.new_stack);
1255
1256   /* Remember, you can't free anything that came from the resource
1257      database.  This includes:
1258          mw->menu.cursor
1259          mw->menu.top_shadow_pixmap
1260          mw->menu.bottom_shadow_pixmap
1261          mw->menu.font
1262      Also the color cells of top_shadow_color, bottom_shadow_color,
1263      foreground, and button_foreground will never be freed until this
1264      client exits.  Nice, eh?
1265    */
1266
1267   /* start from 1 because the one in slot 0 is w->core.window */
1268   for (i = 1; i < mw->menu.windows_length; i++)
1269     XDestroyWindow (XtDisplay (mw), mw->menu.windows [i].window);
1270   if (mw->menu.windows)
1271     XtFree ((char *) mw->menu.windows);
1272 }
1273
1274 static Boolean
1275 XlwMenuSetValues (current, request, new)
1276      Widget current;
1277      Widget request;
1278      Widget new;
1279 {
1280   XlwMenuWidget oldmw = (XlwMenuWidget)current;
1281   XlwMenuWidget newmw = (XlwMenuWidget)new;
1282   Boolean redisplay = False;
1283   int i;
1284
1285   if (newmw->menu.contents
1286       && newmw->menu.contents->contents
1287       && newmw->menu.contents->contents->change >= VISIBLE_CHANGE)
1288     redisplay = True;
1289   /* Do redisplay if the contents are entirely eliminated.  */
1290   if (newmw->menu.contents
1291       && newmw->menu.contents->contents == 0
1292       && newmw->menu.contents->change >= VISIBLE_CHANGE)
1293     redisplay = True;
1294
1295   if (newmw->core.background_pixel != oldmw->core.background_pixel
1296       || newmw->menu.foreground != oldmw->menu.foreground
1297       || newmw->menu.font != oldmw->menu.font)
1298     {
1299       release_drawing_gcs (newmw);
1300       make_drawing_gcs (newmw);
1301       redisplay = True;
1302
1303       for (i = 0; i < oldmw->menu.windows_length; i++)
1304         {
1305           XSetWindowBackground (XtDisplay (oldmw),
1306                                 oldmw->menu.windows [i].window,
1307                                 newmw->core.background_pixel);
1308           /* clear windows and generate expose events */
1309           XClearArea (XtDisplay (oldmw), oldmw->menu.windows[i].window,
1310                       0, 0, 0, 0, True);
1311         }
1312     }
1313
1314   return redisplay;
1315 }
1316
1317 static void
1318 XlwMenuResize (w)
1319      Widget w;
1320 {
1321   XlwMenuWidget mw = (XlwMenuWidget)w;
1322
1323   if (mw->menu.popped_up)
1324     {
1325       /* Don't allow the popup menu to resize itself.  */
1326       mw->core.width = mw->menu.windows [0].width;
1327       mw->core.height = mw->menu.windows [0].height;
1328       mw->core.parent->core.width = mw->core.width ;
1329       mw->core.parent->core.height = mw->core.height ;
1330     }
1331   else
1332     {
1333       mw->menu.windows [0].width = mw->core.width;
1334       mw->menu.windows [0].height = mw->core.height;
1335     }
1336 }
1337
1338 \f/* Action procedures */
1339 static void
1340 handle_single_motion_event (mw, ev)
1341      XlwMenuWidget mw;
1342      XMotionEvent* ev;
1343 {
1344   widget_value* val;
1345   int           level;
1346
1347   if (!map_event_to_widget_value (mw, ev, &val, &level))
1348     pop_new_stack_if_no_contents (mw);
1349   else
1350     set_new_state (mw, val, level);
1351   remap_menubar (mw);
1352
1353   /* Sync with the display.  Makes it feel better on X terms. */
1354   XSync (XtDisplay (mw), False);
1355 }
1356
1357 static void
1358 handle_motion_event (mw, ev)
1359      XlwMenuWidget mw;
1360      XMotionEvent* ev;
1361 {
1362   int x = ev->x_root;
1363   int y = ev->y_root;
1364   int state = ev->state;
1365
1366   handle_single_motion_event (mw, ev);
1367
1368   /* allow motion events to be generated again */
1369   if (ev->is_hint
1370       && XQueryPointer (XtDisplay (mw), ev->window,
1371                         &ev->root, &ev->subwindow,
1372                         &ev->x_root, &ev->y_root,
1373                         &ev->x, &ev->y,
1374                         &ev->state)
1375       && ev->state == state
1376       && (ev->x_root != x || ev->y_root != y))
1377     handle_single_motion_event (mw, ev);
1378 }
1379
1380 static void
1381 Start (w, ev, params, num_params)
1382      Widget w;
1383      XEvent *ev;
1384      String *params;
1385      Cardinal *num_params;
1386 {
1387   XlwMenuWidget mw = (XlwMenuWidget)w;
1388
1389   if (!mw->menu.popped_up)
1390     {
1391       menu_post_event = *ev;
1392       pop_up_menu (mw, ev);
1393     }
1394   else
1395     {
1396       /* If we push a button while the menu is posted semipermanently,
1397          releasing the button should always pop the menu down.  */
1398       next_release_must_exit = 1;
1399
1400       /* notes the absolute position of the menubar window */
1401       mw->menu.windows [0].x = ev->xmotion.x_root - ev->xmotion.x;
1402       mw->menu.windows [0].y = ev->xmotion.y_root - ev->xmotion.y;
1403
1404       /* handles the down like a move, slots are compatible */
1405       handle_motion_event (mw, &ev->xmotion);
1406     }
1407 }
1408
1409 static void
1410 Drag (w, ev, params, num_params)
1411      Widget w;
1412      XEvent *ev;
1413      String *params;
1414      Cardinal *num_params;
1415 {
1416   XlwMenuWidget mw = (XlwMenuWidget)w;
1417   if (mw->menu.popped_up)
1418     handle_motion_event (mw, &ev->xmotion);
1419 }
1420
1421 /* Do nothing.
1422    This is how we handle presses and releases of modifier keys.  */
1423 static void
1424 Nothing (w, ev, params, num_params)
1425      Widget w;
1426      XEvent *ev;
1427      String *params;
1428      Cardinal *num_params;
1429 {
1430 }
1431
1432 /* Handle key press and release events while menu is popped up.
1433    Our action is to get rid of the menu.  */
1434 static void
1435 Key (w, ev, params, num_params)
1436      Widget w;
1437      XEvent *ev;
1438      String *params;
1439      Cardinal *num_params;
1440 {
1441   XlwMenuWidget mw = (XlwMenuWidget)w;
1442
1443   /* Pop down everything.  */
1444   mw->menu.new_depth = 1;
1445   remap_menubar (mw);
1446
1447   if (mw->menu.popped_up)
1448     {
1449       mw->menu.popped_up = False;
1450       XtUngrabPointer ((Widget)mw, ev->xmotion.time);
1451       if (XtIsShell (XtParent ((Widget) mw)))
1452         XtPopdown (XtParent ((Widget) mw));
1453       else
1454         {
1455           XtRemoveGrab ((Widget) mw);
1456           display_menu (mw, 0, False, NULL, NULL, NULL, NULL, NULL);
1457         }
1458     }
1459
1460   /* callback */
1461   XtCallCallbackList ((Widget)mw, mw->menu.select, (XtPointer)0);
1462 }
1463
1464 static void
1465 Select (w, ev, params, num_params)
1466      Widget w;
1467      XEvent *ev;
1468      String *params;
1469      Cardinal *num_params;
1470 {
1471   XlwMenuWidget mw = (XlwMenuWidget)w;
1472   widget_value* selected_item = mw->menu.old_stack [mw->menu.old_depth - 1];
1473
1474   /* If user releases the button quickly, without selecting anything,
1475      after the initial down-click that brought the menu up,
1476      do nothing.  */
1477   if ((selected_item == 0
1478        || ((widget_value *) selected_item)->call_data == 0)
1479       && !next_release_must_exit
1480       && (ev->xbutton.time - menu_post_event.xbutton.time
1481           < XtGetMultiClickTime (XtDisplay (w))))
1482     return;
1483
1484   /* pop down everything.  */
1485   mw->menu.new_depth = 1;
1486   remap_menubar (mw);
1487
1488   if (mw->menu.popped_up)
1489     {
1490       mw->menu.popped_up = False;
1491       XtUngrabPointer ((Widget)mw, ev->xmotion.time);
1492       if (XtIsShell (XtParent ((Widget) mw)))
1493         XtPopdown (XtParent ((Widget) mw));
1494       else
1495         {
1496           XtRemoveGrab ((Widget) mw);
1497           display_menu (mw, 0, False, NULL, NULL, NULL, NULL, NULL);
1498         }
1499     }
1500
1501   /* callback */
1502   XtCallCallbackList ((Widget)mw, mw->menu.select, (XtPointer)selected_item);
1503 }
1504
1505
1506 \f/* Special code to pop-up a menu */
1507 void
1508 pop_up_menu (mw, event)
1509      XlwMenuWidget mw;
1510      XButtonPressedEvent* event;
1511 {
1512   int           x = event->x_root;
1513   int           y = event->y_root;
1514   int           w;
1515   int           h;
1516   int           borderwidth = mw->menu.shadow_thickness;
1517   Screen*       screen = XtScreen (mw);
1518   Display       *display = XtDisplay (mw);
1519
1520   next_release_must_exit = 0;
1521
1522   XtCallCallbackList ((Widget)mw, mw->menu.open, NULL);
1523
1524   if (XtIsShell (XtParent ((Widget)mw)))
1525     size_menu (mw, 0);
1526
1527   w = mw->menu.windows [0].width;
1528   h = mw->menu.windows [0].height;
1529
1530   x -= borderwidth;
1531   y -= borderwidth;
1532   if (x < borderwidth)
1533     x = borderwidth;
1534   if (x + w + 2 * borderwidth > WidthOfScreen (screen))
1535     x = WidthOfScreen (screen) - w - 2 * borderwidth;
1536   if (y < borderwidth)
1537     y = borderwidth;
1538   if (y + h + 2 * borderwidth> HeightOfScreen (screen))
1539     y = HeightOfScreen (screen) - h - 2 * borderwidth;
1540
1541   mw->menu.popped_up = True;
1542   if (XtIsShell (XtParent ((Widget)mw)))
1543     {
1544       XtConfigureWidget (XtParent ((Widget)mw), x, y, w, h,
1545                          XtParent ((Widget)mw)->core.border_width);
1546       XtPopup (XtParent ((Widget)mw), XtGrabExclusive);
1547       display_menu (mw, 0, False, NULL, NULL, NULL, NULL, NULL);
1548       mw->menu.windows [0].x = x + borderwidth;
1549       mw->menu.windows [0].y = y + borderwidth;
1550     }
1551   else
1552     {
1553       XEvent *ev = (XEvent *) event;
1554
1555       XtAddGrab ((Widget) mw, True, True);
1556
1557       /* notes the absolute position of the menubar window */
1558       mw->menu.windows [0].x = ev->xmotion.x_root - ev->xmotion.x;
1559       mw->menu.windows [0].y = ev->xmotion.y_root - ev->xmotion.y;
1560     }
1561
1562 #ifdef emacs
1563   x_catch_errors (display);
1564 #endif
1565   XtGrabPointer ((Widget)mw, False,
1566                  (PointerMotionMask
1567                   | PointerMotionHintMask
1568                   | ButtonReleaseMask
1569                   | ButtonPressMask),
1570                  GrabModeAsync, GrabModeAsync, None,
1571                  mw->menu.cursor_shape,
1572                  event->time);
1573   pointer_grabbed = 1;
1574 #ifdef emacs
1575   if (x_had_errors_p (display))
1576     {
1577       pointer_grabbed = 0;
1578       XtUngrabPointer ((Widget)mw, event->time);
1579     }
1580   x_uncatch_errors (display);
1581 #endif
1582
1583   handle_motion_event (mw, (XMotionEvent*)event);
1584 }