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   /* 1 if we are unable to avoid an overlap between
 785      this menu and the parent menu in the X dimension.  */
 786   int horizontal_overlap = 0;
 787
 788   if (ws->x < 0)
 789     ws->x = 0;
 790   else if (ws->x + ws->width > screen_width)
 791     {
 792       if (!horizontal_p)
 793         ws->x = previous_ws->x - ws->width;
 794       else
 795         ws->x = screen_width - ws->width;
 796       if (ws->x < 0)
 797         {
 798           ws->x = 0;
 799           horizontal_overlap = 1;
 800         }
 801     }
 802   /* If we overlap in X, try to avoid overlap in Y.  */
 803   if (horizontal_overlap
 804       && ws->y < previous_ws->y + previous_ws->height
 805       && previous_ws->y < ws->y + ws->height)
 806     {
 807       /* Put this menu right below or right above PREVIOUS_WS
 808          if there's room.  */
 809       if (previous_ws->y + previous_ws->height + ws->height < screen_height)
 810         ws->y = previous_ws->y + previous_ws->height;
 811       else if (previous_ws->y - ws->height > 0)
 812         ws->y = previous_ws->y - ws->height;
 813     }
 814
 815   if (ws->y < 0)
 816     ws->y = 0;
 817   else if (ws->y + ws->height > screen_height)
 818     {
 819       if (horizontal_p)
 820         ws->y = previous_ws->y - ws->height;
 821       else
 822         ws->y = screen_height - ws->height;
 823       if (ws->y < 0)
 824         ws->y = 0;
 825     }
 826 }
 827
 828 /* Updates old_stack from new_stack and redisplays. */
 829 static void
 830 remap_menubar (mw)
 831      XlwMenuWidget mw;
 832 {
 833   int i;
 834   int last_same;
 835   XPoint selection_position;
 836   int old_depth = mw->menu.old_depth;
 837   int new_depth = mw->menu.new_depth;
 838   widget_value** old_stack;
 839   widget_value** new_stack;
 840   window_state* windows;
 841   widget_value* old_selection;
 842   widget_value* new_selection;
 843
 844   /* Check that enough windows and old_stack are ready. */
 845   make_windows_if_needed (mw, new_depth);
 846   make_old_stack_space (mw, new_depth);
 847   windows = mw->menu.windows;
 848   old_stack = mw->menu.old_stack;
 849   new_stack = mw->menu.new_stack;
 850
 851   /* compute the last identical different entry */
 852   for (i = 1; i < old_depth && i < new_depth; i++)
 853     if (old_stack [i] != new_stack [i])
 854       break;
 855   last_same = i - 1;
 856
 857   /* Memorize the previously selected item to be able to refresh it */
 858   old_selection = last_same + 1 < old_depth ? old_stack [last_same + 1] : NULL;
 859   if (old_selection && !old_selection->enabled)
 860     old_selection = NULL;
 861   new_selection = last_same + 1 < new_depth ? new_stack [last_same + 1] : NULL;
 862   if (new_selection && !new_selection->enabled)
 863     new_selection = NULL;
 864
 865   /* updates old_state from new_state.  It has to be done now because
 866      display_menu (called below) uses the old_stack to know what to display. */
 867   for (i = last_same + 1; i < new_depth; i++)
 868     old_stack [i] = new_stack [i];
 869   mw->menu.old_depth = new_depth;
 870
 871   /* refresh the last selection */
 872   selection_position.x = 0;
 873   selection_position.y = 0;
 874   display_menu (mw, last_same, new_selection == old_selection,
 875                 &selection_position, NULL, NULL, old_selection, new_selection);
 876
 877   /* Now place the new menus.  */
 878   for (i = last_same + 1; i < new_depth && new_stack[i]->contents; i++)
 879     {
 880       window_state *previous_ws = &windows[i - 1];
 881       window_state *ws = &windows[i];
 882
 883       ws->x
 884         = previous_ws->x + selection_position.x + mw->menu.shadow_thickness;
 885       if (!mw->menu.horizontal || i > 1)
 886         ws->x += mw->menu.shadow_thickness;
 887       ws->y
 888         = previous_ws->y + selection_position.y + mw->menu.shadow_thickness;
 889
 890       size_menu (mw, i);
 891
 892       fit_to_screen (mw, ws, previous_ws, mw->menu.horizontal && i == 1);
 893
 894       XClearWindow (XtDisplay (mw), ws->window);
 895       XMoveResizeWindow (XtDisplay (mw), ws->window, ws->x, ws->y,
 896                          ws->width, ws->height);
 897       XMapRaised (XtDisplay (mw), ws->window);
 898       display_menu (mw, i, False, &selection_position, NULL, NULL, NULL, NULL);
 899     }
 900
 901   /* unmap the menus that popped down */
 902   for (i = new_depth - 1; i < old_depth; i++)
 903     if (i >= new_depth || !new_stack[i]->contents)
 904       XUnmapWindow (XtDisplay (mw), windows[i].window);
 905 }
 906
 907 static Boolean
 908 motion_event_is_in_menu (mw, ev, level, relative_pos)
 909      XlwMenuWidget mw;
 910      XMotionEvent* ev;
 911      int level;
 912      XPoint* relative_pos;
 913 {
 914   window_state* ws = &mw->menu.windows [level];
 915   int x = level == 0 ? ws->x : ws->x + mw->menu.shadow_thickness;
 916   int y = level == 0 ? ws->y : ws->y + mw->menu.shadow_thickness;
 917   relative_pos->x = ev->x_root - x;
 918   relative_pos->y = ev->y_root - y;
 919   return (x < ev->x_root && ev->x_root < x + ws->width
 920           && y < ev->y_root && ev->y_root < y + ws->height);
 921 }
 922
 923 static Boolean
 924 map_event_to_widget_value (mw, ev, val, level)
 925      XlwMenuWidget mw;
 926      XMotionEvent* ev;
 927      widget_value** val;
 928      int* level;
 929 {
 930   int           i;
 931   XPoint        relative_pos;
 932   window_state* ws;
 933
 934   *val = NULL;
 935
 936   /* Find the window */
 937   for (i = mw->menu.old_depth - 1; i >= 0; i--)
 938     {
 939       ws = &mw->menu.windows [i];
 940       if (ws && motion_event_is_in_menu (mw, ev, i, &relative_pos))
 941         {
 942           display_menu (mw, i, True, NULL, &relative_pos, val, NULL, NULL);
 943
 944           if (*val)
 945             {
 946               *level = i + 1;
 947               return True;
 948             }
 949         }
 950     }
 951   return False;
 952 }
 953
 954 \f/* Procedures */
 955 static void
 956 make_drawing_gcs (mw)
 957      XlwMenuWidget mw;
 958 {
 959   XGCValues xgcv;
 960
 961   xgcv.font = mw->menu.font->fid;
 962   xgcv.foreground = mw->menu.foreground;
 963   xgcv.background = mw->core.background_pixel;
 964   mw->menu.foreground_gc = XtGetGC ((Widget)mw,
 965                                     GCFont | GCForeground | GCBackground,
 966                                     &xgcv);
 967
 968   xgcv.font = mw->menu.font->fid;
 969   xgcv.foreground = mw->menu.button_foreground;
 970   xgcv.background = mw->core.background_pixel;
 971   mw->menu.button_gc = XtGetGC ((Widget)mw,
 972                                 GCFont | GCForeground | GCBackground,
 973                                 &xgcv);
 974
 975   xgcv.font = mw->menu.font->fid;
 976   xgcv.foreground = mw->menu.foreground;
 977   xgcv.background = mw->core.background_pixel;
 978   xgcv.fill_style = FillStippled;
 979   xgcv.stipple = mw->menu.gray_pixmap;
 980   mw->menu.inactive_gc = XtGetGC ((Widget)mw,
 981                                   (GCFont | GCForeground | GCBackground
 982                                    | GCFillStyle | GCStipple), &xgcv);
 983
 984   xgcv.font = mw->menu.font->fid;
 985   xgcv.foreground = mw->menu.button_foreground;
 986   xgcv.background = mw->core.background_pixel;
 987   xgcv.fill_style = FillStippled;
 988   xgcv.stipple = mw->menu.gray_pixmap;
 989   mw->menu.inactive_button_gc = XtGetGC ((Widget)mw,
 990                                   (GCFont | GCForeground | GCBackground
 991                                    | GCFillStyle | GCStipple), &xgcv);
 992
 993   xgcv.font = mw->menu.font->fid;
 994   xgcv.foreground = mw->core.background_pixel;
 995   xgcv.background = mw->menu.foreground;
 996   mw->menu.background_gc = XtGetGC ((Widget)mw,
 997                                     GCFont | GCForeground | GCBackground,
 998                                     &xgcv);
 999 }
1000
1001 static void
1002 release_drawing_gcs (mw)
1003      XlwMenuWidget mw;
1004 {
1005   XtReleaseGC ((Widget) mw, mw->menu.foreground_gc);
1006   XtReleaseGC ((Widget) mw, mw->menu.button_gc);
1007   XtReleaseGC ((Widget) mw, mw->menu.inactive_gc);
1008   XtReleaseGC ((Widget) mw, mw->menu.inactive_button_gc);
1009   XtReleaseGC ((Widget) mw, mw->menu.background_gc);
1010   /* let's get some segvs if we try to use these... */
1011   mw->menu.foreground_gc = (GC) -1;
1012   mw->menu.button_gc = (GC) -1;
1013   mw->menu.inactive_gc = (GC) -1;
1014   mw->menu.inactive_button_gc = (GC) -1;
1015   mw->menu.background_gc = (GC) -1;
1016 }
1017
1018 #define MINL(x,y) ((((unsigned long) (x)) < ((unsigned long) (y))) \
1019                    ? ((unsigned long) (x)) : ((unsigned long) (y)))
1020
1021 static void
1022 make_shadow_gcs (mw)
1023      XlwMenuWidget mw;
1024 {
1025   XGCValues xgcv;
1026   unsigned long pm = 0;
1027   Display *dpy = XtDisplay ((Widget) mw);
1028   Colormap cmap = DefaultColormapOfScreen (XtScreen ((Widget) mw));
1029   XColor topc, botc;
1030   int top_frobbed = 0, bottom_frobbed = 0;
1031
1032   if (mw->menu.top_shadow_color == -1)
1033     mw->menu.top_shadow_color = mw->core.background_pixel;
1034   if (mw->menu.bottom_shadow_color == -1)
1035     mw->menu.bottom_shadow_color = mw->menu.foreground;
1036
1037   if (mw->menu.top_shadow_color == mw->core.background_pixel ||
1038       mw->menu.top_shadow_color == mw->menu.foreground)
1039     {
1040       topc.pixel = mw->core.background_pixel;
1041       XQueryColor (dpy, cmap, &topc);
1042       /* don't overflow/wrap! */
1043       topc.red   = MINL (65535, topc.red   * 1.2);
1044       topc.green = MINL (65535, topc.green * 1.2);
1045       topc.blue  = MINL (65535, topc.blue  * 1.2);
1046       if (XAllocColor (dpy, cmap, &topc))
1047         {
1048           mw->menu.top_shadow_color = topc.pixel;
1049           top_frobbed = 1;
1050         }
1051     }
1052   if (mw->menu.bottom_shadow_color == mw->menu.foreground ||
1053       mw->menu.bottom_shadow_color == mw->core.background_pixel)
1054     {
1055       botc.pixel = mw->core.background_pixel;
1056       XQueryColor (dpy, cmap, &botc);
1057       botc.red   *= 0.6;
1058       botc.green *= 0.6;
1059       botc.blue  *= 0.6;
1060       if (XAllocColor (dpy, cmap, &botc))
1061         {
1062           mw->menu.bottom_shadow_color = botc.pixel;
1063           bottom_frobbed = 1;
1064         }
1065     }
1066
1067   if (top_frobbed && bottom_frobbed)
1068     {
1069       int top_avg = ((topc.red / 3) + (topc.green / 3) + (topc.blue / 3));
1070       int bot_avg = ((botc.red / 3) + (botc.green / 3) + (botc.blue / 3));
1071       if (bot_avg > top_avg)
1072         {
1073           Pixel tmp = mw->menu.top_shadow_color;
1074           mw->menu.top_shadow_color = mw->menu.bottom_shadow_color;
1075           mw->menu.bottom_shadow_color = tmp;
1076         }
1077       else if (topc.pixel == botc.pixel)
1078         {
1079           if (botc.pixel == mw->menu.foreground)
1080             mw->menu.top_shadow_color = mw->core.background_pixel;
1081           else
1082             mw->menu.bottom_shadow_color = mw->menu.foreground;
1083         }
1084     }
1085
1086   if (!mw->menu.top_shadow_pixmap &&
1087       mw->menu.top_shadow_color == mw->core.background_pixel)
1088     {
1089       mw->menu.top_shadow_pixmap = mw->menu.gray_pixmap;
1090       mw->menu.top_shadow_color = mw->menu.foreground;
1091     }
1092   if (!mw->menu.bottom_shadow_pixmap &&
1093       mw->menu.bottom_shadow_color == mw->core.background_pixel)
1094     {
1095       mw->menu.bottom_shadow_pixmap = mw->menu.gray_pixmap;
1096       mw->menu.bottom_shadow_color = mw->menu.foreground;
1097     }
1098
1099   xgcv.fill_style = FillStippled;
1100   xgcv.foreground = mw->menu.top_shadow_color;
1101   xgcv.stipple = mw->menu.top_shadow_pixmap;
1102   pm = (xgcv.stipple ? GCStipple|GCFillStyle : 0);
1103   mw->menu.shadow_top_gc = XtGetGC ((Widget)mw, GCForeground | pm, &xgcv);
1104
1105   xgcv.foreground = mw->menu.bottom_shadow_color;
1106   xgcv.stipple = mw->menu.bottom_shadow_pixmap;
1107   pm = (xgcv.stipple ? GCStipple|GCFillStyle : 0);
1108   mw->menu.shadow_bottom_gc = XtGetGC ((Widget)mw, GCForeground | pm, &xgcv);
1109 }
1110
1111
1112 static void
1113 release_shadow_gcs (mw)
1114      XlwMenuWidget mw;
1115 {
1116   XtReleaseGC ((Widget) mw, mw->menu.shadow_top_gc);
1117   XtReleaseGC ((Widget) mw, mw->menu.shadow_bottom_gc);
1118 }
1119
1120 static void
1121 XlwMenuInitialize (request, mw, args, num_args)
1122      Widget request;
1123      XlwMenuWidget mw;
1124      ArgList args;
1125      Cardinal *num_args;
1126 {
1127   /* Get the GCs and the widget size */
1128   XSetWindowAttributes xswa;
1129   int mask;
1130
1131   Window window = RootWindowOfScreen (DefaultScreenOfDisplay (XtDisplay (mw)));
1132   Display* display = XtDisplay (mw);
1133
1134 #if 0
1135   widget_value *tem = (widget_value *) XtMalloc (sizeof (widget_value));
1136
1137   /* _XtCreate is freeing the object that was passed to us,
1138      so make a copy that we will actually keep.  */
1139   lwlib_bcopy (mw->menu.contents, tem, sizeof (widget_value));
1140   mw->menu.contents = tem;
1141 #endif
1142
1143 /*  mw->menu.cursor = XCreateFontCursor (display, mw->menu.cursor_shape); */
1144   mw->menu.cursor = mw->menu.cursor_shape;
1145
1146   mw->menu.gray_pixmap
1147     = XCreatePixmapFromBitmapData (display, window, gray_bits,
1148                                    gray_width, gray_height,
1149                                    (unsigned long)1, (unsigned long)0, 1);
1150
1151   /* I don't understand why this ends up 0 sometimes,
1152      but it does.  This kludge works around it.
1153      Can anyone find a real fix?   -- rms.  */
1154   if (mw->menu.font == 0)
1155     mw->menu.font = xlwmenu_default_font;
1156
1157   make_drawing_gcs (mw);
1158   make_shadow_gcs (mw);
1159
1160   xswa.background_pixel = mw->core.background_pixel;
1161   xswa.border_pixel = mw->core.border_pixel;
1162   mask = CWBackPixel | CWBorderPixel;
1163
1164   mw->menu.popped_up = False;
1165
1166   mw->menu.old_depth = 1;
1167   mw->menu.old_stack = (widget_value**)XtMalloc (sizeof (widget_value*));
1168   mw->menu.old_stack_length = 1;
1169   mw->menu.old_stack [0] = mw->menu.contents;
1170
1171   mw->menu.new_depth = 0;
1172   mw->menu.new_stack = 0;
1173   mw->menu.new_stack_length = 0;
1174   push_new_stack (mw, mw->menu.contents);
1175
1176   mw->menu.windows = (window_state*)XtMalloc (sizeof (window_state));
1177   mw->menu.windows_length = 1;
1178   mw->menu.windows [0].x = 0;
1179   mw->menu.windows [0].y = 0;
1180   mw->menu.windows [0].width = 0;
1181   mw->menu.windows [0].height = 0;
1182   size_menu (mw, 0);
1183
1184   mw->core.width = mw->menu.windows [0].width;
1185   mw->core.height = mw->menu.windows [0].height;
1186 }
1187
1188 static void
1189 XlwMenuClassInitialize ()
1190 {
1191 }
1192
1193 static void
1194 XlwMenuRealize (w, valueMask, attributes)
1195      Widget w;
1196      Mask *valueMask;
1197      XSetWindowAttributes *attributes;
1198 {
1199   XlwMenuWidget mw = (XlwMenuWidget)w;
1200   XSetWindowAttributes xswa;
1201   int mask;
1202
1203   (*xlwMenuWidgetClass->core_class.superclass->core_class.realize)
1204     (w, valueMask, attributes);
1205
1206   xswa.save_under = True;
1207   xswa.cursor = mw->menu.cursor_shape;
1208   mask = CWSaveUnder | CWCursor;
1209   XChangeWindowAttributes (XtDisplay (w), XtWindow (w), mask, &xswa);
1210
1211   mw->menu.windows [0].window = XtWindow (w);
1212   mw->menu.windows [0].x = w->core.x;
1213   mw->menu.windows [0].y = w->core.y;
1214   mw->menu.windows [0].width = w->core.width;
1215   mw->menu.windows [0].height = w->core.height;
1216 }
1217
1218 /* Only the toplevel menubar/popup is a widget so it's the only one that
1219    receives expose events through Xt.  So we repaint all the other panes
1220    when receiving an Expose event. */
1221 static void
1222 XlwMenuRedisplay (w, ev, region)
1223      Widget w;
1224      XEvent* ev;
1225      Region region;
1226 {
1227   XlwMenuWidget mw = (XlwMenuWidget)w;
1228   int i;
1229
1230   /* If we have a depth beyond 1, it's because a submenu was displayed.
1231      If the submenu has been destroyed, set the depth back to 1.  */
1232   if (submenu_destroyed)
1233     {
1234       mw->menu.old_depth = 1;
1235       submenu_destroyed = 0;
1236     }
1237
1238   for (i = 0; i < mw->menu.old_depth; i++)
1239     display_menu (mw, i, False, NULL, NULL, NULL, NULL, NULL);
1240 }
1241
1242 static void
1243 XlwMenuDestroy (w)
1244      Widget w;
1245 {
1246   int i;
1247   XlwMenuWidget mw = (XlwMenuWidget) w;
1248
1249   if (pointer_grabbed)
1250     XtUngrabPointer ((Widget)w, CurrentTime);
1251   pointer_grabbed = 0;
1252
1253   submenu_destroyed = 1;
1254
1255   release_drawing_gcs (mw);
1256   release_shadow_gcs (mw);
1257
1258   /* this doesn't come from the resource db but is created explicitly
1259      so we must free it ourselves. */
1260   XFreePixmap (XtDisplay (mw), mw->menu.gray_pixmap);
1261   mw->menu.gray_pixmap = (Pixmap) -1;
1262
1263 #if 0
1264   /* Do free mw->menu.contents because nowadays we copy it
1265      during initialization.  */
1266   XtFree (mw->menu.contents);
1267 #endif
1268
1269   /* Don't free mw->menu.contents because that comes from our creator.
1270      The `*_stack' elements are just pointers into `contents' so leave
1271      that alone too.  But free the stacks themselves. */
1272   if (mw->menu.old_stack) XtFree ((char *) mw->menu.old_stack);
1273   if (mw->menu.new_stack) XtFree ((char *) mw->menu.new_stack);
1274
1275   /* Remember, you can't free anything that came from the resource
1276      database.  This includes:
1277          mw->menu.cursor
1278          mw->menu.top_shadow_pixmap
1279          mw->menu.bottom_shadow_pixmap
1280          mw->menu.font
1281      Also the color cells of top_shadow_color, bottom_shadow_color,
1282      foreground, and button_foreground will never be freed until this
1283      client exits.  Nice, eh?
1284    */
1285
1286   /* start from 1 because the one in slot 0 is w->core.window */
1287   for (i = 1; i < mw->menu.windows_length; i++)
1288     XDestroyWindow (XtDisplay (mw), mw->menu.windows [i].window);
1289   if (mw->menu.windows)
1290     XtFree ((char *) mw->menu.windows);
1291 }
1292
1293 static Boolean
1294 XlwMenuSetValues (current, request, new)
1295      Widget current;
1296      Widget request;
1297      Widget new;
1298 {
1299   XlwMenuWidget oldmw = (XlwMenuWidget)current;
1300   XlwMenuWidget newmw = (XlwMenuWidget)new;
1301   Boolean redisplay = False;
1302   int i;
1303
1304   if (newmw->menu.contents
1305       && newmw->menu.contents->contents
1306       && newmw->menu.contents->contents->change >= VISIBLE_CHANGE)
1307     redisplay = True;
1308   /* Do redisplay if the contents are entirely eliminated.  */
1309   if (newmw->menu.contents
1310       && newmw->menu.contents->contents == 0
1311       && newmw->menu.contents->change >= VISIBLE_CHANGE)
1312     redisplay = True;
1313
1314   if (newmw->core.background_pixel != oldmw->core.background_pixel
1315       || newmw->menu.foreground != oldmw->menu.foreground
1316       || newmw->menu.font != oldmw->menu.font)
1317     {
1318       release_drawing_gcs (newmw);
1319       make_drawing_gcs (newmw);
1320       redisplay = True;
1321
1322       for (i = 0; i < oldmw->menu.windows_length; i++)
1323         {
1324           XSetWindowBackground (XtDisplay (oldmw),
1325                                 oldmw->menu.windows [i].window,
1326                                 newmw->core.background_pixel);
1327           /* clear windows and generate expose events */
1328           XClearArea (XtDisplay (oldmw), oldmw->menu.windows[i].window,
1329                       0, 0, 0, 0, True);
1330         }
1331     }
1332
1333   return redisplay;
1334 }
1335
1336 static void
1337 XlwMenuResize (w)
1338      Widget w;
1339 {
1340   XlwMenuWidget mw = (XlwMenuWidget)w;
1341
1342   if (mw->menu.popped_up)
1343     {
1344       /* Don't allow the popup menu to resize itself.  */
1345       mw->core.width = mw->menu.windows [0].width;
1346       mw->core.height = mw->menu.windows [0].height;
1347       mw->core.parent->core.width = mw->core.width ;
1348       mw->core.parent->core.height = mw->core.height ;
1349     }
1350   else
1351     {
1352       mw->menu.windows [0].width = mw->core.width;
1353       mw->menu.windows [0].height = mw->core.height;
1354     }
1355 }
1356
1357 \f/* Action procedures */
1358 static void
1359 handle_single_motion_event (mw, ev)
1360      XlwMenuWidget mw;
1361      XMotionEvent* ev;
1362 {
1363   widget_value* val;
1364   int           level;
1365
1366   if (!map_event_to_widget_value (mw, ev, &val, &level))
1367     pop_new_stack_if_no_contents (mw);
1368   else
1369     set_new_state (mw, val, level);
1370   remap_menubar (mw);
1371
1372   /* Sync with the display.  Makes it feel better on X terms. */
1373   XSync (XtDisplay (mw), False);
1374 }
1375
1376 static void
1377 handle_motion_event (mw, ev)
1378      XlwMenuWidget mw;
1379      XMotionEvent* ev;
1380 {
1381   int x = ev->x_root;
1382   int y = ev->y_root;
1383   int state = ev->state;
1384
1385   handle_single_motion_event (mw, ev);
1386
1387   /* allow motion events to be generated again */
1388   if (ev->is_hint
1389       && XQueryPointer (XtDisplay (mw), ev->window,
1390                         &ev->root, &ev->subwindow,
1391                         &ev->x_root, &ev->y_root,
1392                         &ev->x, &ev->y,
1393                         &ev->state)
1394       && ev->state == state
1395       && (ev->x_root != x || ev->y_root != y))
1396     handle_single_motion_event (mw, ev);
1397 }
1398
1399 static void
1400 Start (w, ev, params, num_params)
1401      Widget w;
1402      XEvent *ev;
1403      String *params;
1404      Cardinal *num_params;
1405 {
1406   XlwMenuWidget mw = (XlwMenuWidget)w;
1407
1408   if (!mw->menu.popped_up)
1409     {
1410       menu_post_event = *ev;
1411       pop_up_menu (mw, ev);
1412     }
1413   else
1414     {
1415       /* If we push a button while the menu is posted semipermanently,
1416          releasing the button should always pop the menu down.  */
1417       next_release_must_exit = 1;
1418
1419       /* notes the absolute position of the menubar window */
1420       mw->menu.windows [0].x = ev->xmotion.x_root - ev->xmotion.x;
1421       mw->menu.windows [0].y = ev->xmotion.y_root - ev->xmotion.y;
1422
1423       /* handles the down like a move, slots are compatible */
1424       handle_motion_event (mw, &ev->xmotion);
1425     }
1426 }
1427
1428 static void
1429 Drag (w, ev, params, num_params)
1430      Widget w;
1431      XEvent *ev;
1432      String *params;
1433      Cardinal *num_params;
1434 {
1435   XlwMenuWidget mw = (XlwMenuWidget)w;
1436   if (mw->menu.popped_up)
1437     handle_motion_event (mw, &ev->xmotion);
1438 }
1439
1440 /* Do nothing.
1441    This is how we handle presses and releases of modifier keys.  */
1442 static void
1443 Nothing (w, ev, params, num_params)
1444      Widget w;
1445      XEvent *ev;
1446      String *params;
1447      Cardinal *num_params;
1448 {
1449 }
1450
1451 /* Handle key press and release events while menu is popped up.
1452    Our action is to get rid of the menu.  */
1453 static void
1454 Key (w, ev, params, num_params)
1455      Widget w;
1456      XEvent *ev;
1457      String *params;
1458      Cardinal *num_params;
1459 {
1460   XlwMenuWidget mw = (XlwMenuWidget)w;
1461
1462   /* Pop down everything.  */
1463   mw->menu.new_depth = 1;
1464   remap_menubar (mw);
1465
1466   if (mw->menu.popped_up)
1467     {
1468       mw->menu.popped_up = False;
1469       XtUngrabPointer ((Widget)mw, ev->xmotion.time);
1470       if (XtIsShell (XtParent ((Widget) mw)))
1471         XtPopdown (XtParent ((Widget) mw));
1472       else
1473         {
1474           XtRemoveGrab ((Widget) mw);
1475           display_menu (mw, 0, False, NULL, NULL, NULL, NULL, NULL);
1476         }
1477     }
1478
1479   /* callback */
1480   XtCallCallbackList ((Widget)mw, mw->menu.select, (XtPointer)0);
1481 }
1482
1483 static void
1484 Select (w, ev, params, num_params)
1485      Widget w;
1486      XEvent *ev;
1487      String *params;
1488      Cardinal *num_params;
1489 {
1490   XlwMenuWidget mw = (XlwMenuWidget)w;
1491   widget_value* selected_item = mw->menu.old_stack [mw->menu.old_depth - 1];
1492
1493   /* If user releases the button quickly, without selecting anything,
1494      after the initial down-click that brought the menu up,
1495      do nothing.  */
1496   if ((selected_item == 0
1497        || ((widget_value *) selected_item)->call_data == 0)
1498       && !next_release_must_exit
1499       && (ev->xbutton.time - menu_post_event.xbutton.time
1500           < XtGetMultiClickTime (XtDisplay (w))))
1501     return;
1502
1503   /* pop down everything.  */
1504   mw->menu.new_depth = 1;
1505   remap_menubar (mw);
1506
1507   if (mw->menu.popped_up)
1508     {
1509       mw->menu.popped_up = False;
1510       XtUngrabPointer ((Widget)mw, ev->xmotion.time);
1511       if (XtIsShell (XtParent ((Widget) mw)))
1512         XtPopdown (XtParent ((Widget) mw));
1513       else
1514         {
1515           XtRemoveGrab ((Widget) mw);
1516           display_menu (mw, 0, False, NULL, NULL, NULL, NULL, NULL);
1517         }
1518     }
1519
1520   /* callback */
1521   XtCallCallbackList ((Widget)mw, mw->menu.select, (XtPointer)selected_item);
1522 }
1523
1524
1525 \f/* Special code to pop-up a menu */
1526 void
1527 pop_up_menu (mw, event)
1528      XlwMenuWidget mw;
1529      XButtonPressedEvent* event;
1530 {
1531   int           x = event->x_root;
1532   int           y = event->y_root;
1533   int           w;
1534   int           h;
1535   int           borderwidth = mw->menu.shadow_thickness;
1536   Screen*       screen = XtScreen (mw);
1537   Display       *display = XtDisplay (mw);
1538
1539   next_release_must_exit = 0;
1540
1541   XtCallCallbackList ((Widget)mw, mw->menu.open, NULL);
1542
1543   if (XtIsShell (XtParent ((Widget)mw)))
1544     size_menu (mw, 0);
1545
1546   w = mw->menu.windows [0].width;
1547   h = mw->menu.windows [0].height;
1548
1549   x -= borderwidth;
1550   y -= borderwidth;
1551   if (x < borderwidth)
1552     x = borderwidth;
1553   if (x + w + 2 * borderwidth > WidthOfScreen (screen))
1554     x = WidthOfScreen (screen) - w - 2 * borderwidth;
1555   if (y < borderwidth)
1556     y = borderwidth;
1557   if (y + h + 2 * borderwidth> HeightOfScreen (screen))
1558     y = HeightOfScreen (screen) - h - 2 * borderwidth;
1559
1560   mw->menu.popped_up = True;
1561   if (XtIsShell (XtParent ((Widget)mw)))
1562     {
1563       XtConfigureWidget (XtParent ((Widget)mw), x, y, w, h,
1564                          XtParent ((Widget)mw)->core.border_width);
1565       XtPopup (XtParent ((Widget)mw), XtGrabExclusive);
1566       display_menu (mw, 0, False, NULL, NULL, NULL, NULL, NULL);
1567       mw->menu.windows [0].x = x + borderwidth;
1568       mw->menu.windows [0].y = y + borderwidth;
1569     }
1570   else
1571     {
1572       XEvent *ev = (XEvent *) event;
1573
1574       XtAddGrab ((Widget) mw, True, True);
1575
1576       /* notes the absolute position of the menubar window */
1577       mw->menu.windows [0].x = ev->xmotion.x_root - ev->xmotion.x;
1578       mw->menu.windows [0].y = ev->xmotion.y_root - ev->xmotion.y;
1579     }
1580
1581 #ifdef emacs
1582   x_catch_errors (display);
1583 #endif
1584   XtGrabPointer ((Widget)mw, False,
1585                  (PointerMotionMask
1586                   | PointerMotionHintMask
1587                   | ButtonReleaseMask
1588                   | ButtonPressMask),
1589                  GrabModeAsync, GrabModeAsync, None,
1590                  mw->menu.cursor_shape,
1591                  event->time);
1592   pointer_grabbed = 1;
1593 #ifdef emacs
1594   if (x_had_errors_p (display))
1595     {
1596       pointer_grabbed = 0;
1597       XtUngrabPointer ((Widget)mw, event->time);
1598     }
1599   x_uncatch_errors (display);
1600 #endif
1601
1602   handle_motion_event (mw, (XMotionEvent*)event);
1603 }