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