HCoop / bpt / emacs.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
*** empty log message ***
[bpt/emacs.git] / lwlib / xlwmenu.c
CommitLineData
5c520e0a 1/* Implements a lightweight menubar widget.
07bf635f
RS		 2 Copyright (C) 1992 Lucid, Inc.
3
4This file is part of the Lucid Widget Library.
5
5c520e0a 6The Lucid Widget Library is free software; you can redistribute it and/or
07bf635f
RS		 7modify it under the terms of the GNU General Public License as published by
8the Free Software Foundation; either version 2, or (at your option)
9any later version.
10
11The Lucid Widget Library is distributed in the hope that it will be useful,
5c520e0a 12but WITHOUT ANY WARRANTY; without even the implied warranty of
07bf635f
RS		 13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14GNU General Public License for more details.
15
16You should have received a copy of the GNU General Public License
1fb87c77
KH		 17along with GNU Emacs; see the file COPYING. If not, write to the
18Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19Boston, MA 02111-1307, USA. */
07bf635f
RS		 20
21/* Created by devin@lucid.com */
22
0f0912e6
PE		 23#ifdef HAVE_CONFIG_H
24#include <config.h>
25#endif
26
07bf635f
RS		 27#include <stdio.h>
28
29#include <sys/types.h>
5c520e0a
SS		 30#if (defined __sun) && !(defined SUNOS41)
31#define SUNOS41
07bf635f 32#include <X11/Xos.h>
5c520e0a
SS		 33#undef SUNOS41
34#else
35#include <X11/Xos.h>
36#endif
07bf635f 37#include <X11/IntrinsicP.h>
2289f3f4 38#include <X11/ObjectP.h>
07bf635f
RS		 39#include <X11/StringDefs.h>
40#include <X11/cursorfont.h>
07bf635f 41#include "xlwmenuP.h"
fc8fefed 42
a57a1605 43#ifdef emacs
f1c16db4
GM		 44
45/* Defined in xfns.c. When config.h defines `static' as empty, we get
46 redefinition errors when gray_bitmap is included more than once, so
47 we're referring to the one include in xfns.c here. */
48
49extern int gray_bitmap_width;
50extern int gray_bitmap_height;
51extern unsigned char *gray_bitmap_bits;
52
a57a1605
DL		 53/* Defined in xterm.c. */
54extern int x_alloc_nearest_color_for_widget __P ((Widget, Colormap, XColor*));
65c0ae05
MB		 55extern int x_alloc_lighter_color_for_widget __P ((Widget, Display*, Colormap,
56 unsigned long *,
57 double, int));
a57a1605
DL		 58extern int x_catch_errors __P ((Display*));
59extern int x_uncatch_errors __P ((Display*, int));
60extern int x_had_errors_p __P ((Display*));
61extern int x_clear_errors __P ((Display*));
fc8fefed
GM		 62extern unsigned long x_copy_dpy_color __P ((Display *, Colormap,
63 unsigned long));
64
65/* Defined in xfaces.c. */
66extern void x_free_dpy_colors __P ((Display *, Screen *, Colormap,
67 unsigned long *pixels, int npixels));
f1c16db4
GM		 68#else /* not emacs */
69
70#include <X11/bitmaps/gray>
71#define gray_bitmap_width gray_width
72#define gray_bitmap_height gray_height
73#define gray_bitmap_bits gray_bits
74
75#endif /* not emacs */
d398028f
PR		 76
77static int pointer_grabbed;
78static XEvent menu_post_event;
07bf635f 79
47d52240
RS		 80XFontStruct *xlwmenu_default_font;
81
5c520e0a
SS		 82static char
83xlwMenuTranslations [] =
ba624d0f
RS		 84"<BtnDown>: start()\n\
85<Motion>: drag()\n\
86<BtnUp>: select()\n\
87<Key>Shift_L: nothing()\n\
88<Key>Shift_R: nothing()\n\
89<Key>Meta_L: nothing()\n\
90<Key>Meta_R: nothing()\n\
91<Key>Control_L: nothing()\n\
92<Key>Control_R: nothing()\n\
93<Key>Hyper_L: nothing()\n\
94<Key>Hyper_R: nothing()\n\
95<Key>Super_L: nothing()\n\
96<Key>Super_R: nothing()\n\
97<Key>Alt_L: nothing()\n\
98<Key>Alt_R: nothing()\n\
99<Key>Caps_Lock: nothing()\n\
100<Key>Shift_Lock: nothing()\n\
101<KeyUp>Shift_L: nothing()\n\
102<KeyUp>Shift_R: nothing()\n\
103<KeyUp>Meta_L: nothing()\n\
104<KeyUp>Meta_R: nothing()\n\
105<KeyUp>Control_L: nothing()\n\
106<KeyUp>Control_R: nothing()\n\
107<KeyUp>Hyper_L: nothing()\n\
108<KeyUp>Hyper_R: nothing()\n\
109<KeyUp>Super_L: nothing()\n\
110<KeyUp>Super_R: nothing()\n\
111<KeyUp>Alt_L: nothing()\n\
112<KeyUp>Alt_R: nothing()\n\
113<KeyUp>Caps_Lock: nothing()\n\
114<KeyUp>Shift_Lock:nothing()\n\
115<Key>: key()\n\
116<KeyUp>: key()\n\
07bf635f
RS		 117";
118
119#define offset(field) XtOffset(XlwMenuWidget, field)
5c520e0a 120static XtResource
07bf635f 121xlwMenuResources[] =
5c520e0a 122{
07bf635f
RS		 123 {XtNfont, XtCFont, XtRFontStruct, sizeof(XFontStruct *),
124 offset(menu.font),XtRString, "XtDefaultFont"},
125 {XtNforeground, XtCForeground, XtRPixel, sizeof(Pixel),
126 offset(menu.foreground), XtRString, "XtDefaultForeground"},
127 {XtNbuttonForeground, XtCButtonForeground, XtRPixel, sizeof(Pixel),
128 offset(menu.button_foreground), XtRString, "XtDefaultForeground"},
129 {XtNmargin, XtCMargin, XtRDimension, sizeof(Dimension),
be06a3df 130 offset(menu.margin), XtRImmediate, (XtPointer) 4},
07bf635f
RS		 131 {XtNhorizontalSpacing, XtCMargin, XtRDimension, sizeof(Dimension),
132 offset(menu.horizontal_spacing), XtRImmediate, (XtPointer)3},
133 {XtNverticalSpacing, XtCMargin, XtRDimension, sizeof(Dimension),
134 offset(menu.vertical_spacing), XtRImmediate, (XtPointer)1},
135 {XtNarrowSpacing, XtCMargin, XtRDimension, sizeof(Dimension),
136 offset(menu.arrow_spacing), XtRImmediate, (XtPointer)10},
137
d398028f 138 {XmNshadowThickness, XmCShadowThickness, XtRDimension,
07bf635f
RS		 139 sizeof (Dimension), offset (menu.shadow_thickness),
140 XtRImmediate, (XtPointer) 2},
141 {XmNtopShadowColor, XmCTopShadowColor, XtRPixel, sizeof (Pixel),
142 offset (menu.top_shadow_color), XtRImmediate, (XtPointer)-1},
143 {XmNbottomShadowColor, XmCBottomShadowColor, XtRPixel, sizeof (Pixel),
144 offset (menu.bottom_shadow_color), XtRImmediate, (XtPointer)-1},
145 {XmNtopShadowPixmap, XmCTopShadowPixmap, XtRPixmap, sizeof (Pixmap),
146 offset (menu.top_shadow_pixmap), XtRImmediate, (XtPointer)None},
147 {XmNbottomShadowPixmap, XmCBottomShadowPixmap, XtRPixmap, sizeof (Pixmap),
148 offset (menu.bottom_shadow_pixmap), XtRImmediate, (XtPointer)None},
149
5c520e0a 150 {XtNopen, XtCCallback, XtRCallback, sizeof(XtPointer),
07bf635f 151 offset(menu.open), XtRCallback, (XtPointer)NULL},
5c520e0a 152 {XtNselect, XtCCallback, XtRCallback, sizeof(XtPointer),
07bf635f 153 offset(menu.select), XtRCallback, (XtPointer)NULL},
5c520e0a 154 {XtNhighlightCallback, XtCCallback, XtRCallback, sizeof(XtPointer),
d6fd6371 155 offset(menu.highlight), XtRCallback, (XtPointer)NULL},
07bf635f
RS		 156 {XtNmenu, XtCMenu, XtRPointer, sizeof(XtPointer),
157 offset(menu.contents), XtRImmediate, (XtPointer)NULL},
158 {XtNcursor, XtCCursor, XtRCursor, sizeof(Cursor),
159 offset(menu.cursor_shape), XtRString, (XtPointer)"right_ptr"},
160 {XtNhorizontal, XtCHorizontal, XtRInt, sizeof(int),
161 offset(menu.horizontal), XtRImmediate, (XtPointer)True},
162};
163#undef offset
164
165static Boolean XlwMenuSetValues();
166static void XlwMenuRealize();
167static void XlwMenuRedisplay();
168static void XlwMenuResize();
169static void XlwMenuInitialize();
170static void XlwMenuRedisplay();
171static void XlwMenuDestroy();
172static void XlwMenuClassInitialize();
173static void Start();
174static void Drag();
175static void Select();
ba624d0f
RS		 176static void Key();
177static void Nothing();
be06a3df 178static int separator_height ();
07bf635f 179
5c520e0a 180static XtActionsRec
07bf635f
RS		 181xlwMenuActionsList [] =
182{
183 {"start", Start},
184 {"drag", Drag},
185 {"select", Select},
ba624d0f
RS		 186 {"key", Key},
187 {"nothing", Nothing},
07bf635f
RS		 188};
189
190#define SuperClass ((CoreWidgetClass)&coreClassRec)
191
192XlwMenuClassRec xlwMenuClassRec =
193{
194 { /* CoreClass fields initialization */
5c520e0a 195 (WidgetClass) SuperClass, /* superclass */
07bf635f
RS		 196 "XlwMenu", /* class_name */
197 sizeof(XlwMenuRec), /* size */
198 XlwMenuClassInitialize, /* class_initialize */
199 NULL, /* class_part_initialize */
200 FALSE, /* class_inited */
201 XlwMenuInitialize, /* initialize */
202 NULL, /* initialize_hook */
203 XlwMenuRealize, /* realize */
204 xlwMenuActionsList, /* actions */
205 XtNumber(xlwMenuActionsList), /* num_actions */
206 xlwMenuResources, /* resources */
207 XtNumber(xlwMenuResources), /* resource_count */
208 NULLQUARK, /* xrm_class */
209 TRUE, /* compress_motion */
210 TRUE, /* compress_exposure */
211 TRUE, /* compress_enterleave */
212 FALSE, /* visible_interest */
213 XlwMenuDestroy, /* destroy */
214 XlwMenuResize, /* resize */
215 XlwMenuRedisplay, /* expose */
216 XlwMenuSetValues, /* set_values */
217 NULL, /* set_values_hook */
218 XtInheritSetValuesAlmost, /* set_values_almost */
219 NULL, /* get_values_hook */
220 NULL, /* accept_focus */
221 XtVersion, /* version */
222 NULL, /* callback_private */
223 xlwMenuTranslations, /* tm_table */
224 XtInheritQueryGeometry, /* query_geometry */
225 XtInheritDisplayAccelerator, /* display_accelerator */
226 NULL /* extension */
227 }, /* XlwMenuClass fields initialization */
228 {
229 0 /* dummy */
230 },
231};
232
233WidgetClass xlwMenuWidgetClass = (WidgetClass) &xlwMenuClassRec;
234
d398028f
PR		 235int submenu_destroyed;
236
237static int next_release_must_exit;
238
07bf635f 239\f/* Utilities */
be06a3df
GM		 240
241
242/* Like abort, but remove grabs from widget W before. */
243
244static void
245abort_gracefully (w)
246 Widget w;
247{
248 if (XtIsShell (XtParent (w)))
249 XtRemoveGrab (w);
250 XtUngrabPointer (w, CurrentTime);
251 abort ();
252}
253
07bf635f 254static void
d398028f
PR		 255push_new_stack (mw, val)
256 XlwMenuWidget mw;
257 widget_value* val;
07bf635f
RS		 258{
259 if (!mw->menu.new_stack)
260 {
261 mw->menu.new_stack_length = 10;
262 mw->menu.new_stack =
263 (widget_value**)XtCalloc (mw->menu.new_stack_length,
264 sizeof (widget_value*));
265 }
266 else if (mw->menu.new_depth == mw->menu.new_stack_length)
267 {
268 mw->menu.new_stack_length *= 2;
269 mw->menu.new_stack =
270 (widget_value**)XtRealloc ((char*)mw->menu.new_stack,
271 mw->menu.new_stack_length * sizeof (widget_value*));
272 }
273 mw->menu.new_stack [mw->menu.new_depth++] = val;
274}
275
276static void
d398028f
PR		 277pop_new_stack_if_no_contents (mw)
278 XlwMenuWidget mw;
07bf635f
RS		 279{
280 if (mw->menu.new_depth)
281 {
282 if (!mw->menu.new_stack [mw->menu.new_depth - 1]->contents)
283 mw->menu.new_depth -= 1;
284 }
285}
286
287static void
d398028f
PR		 288make_old_stack_space (mw, n)
289 XlwMenuWidget mw;
290 int n;
07bf635f
RS		 291{
292 if (!mw->menu.old_stack)
293 {
294 mw->menu.old_stack_length = 10;
295 mw->menu.old_stack =
296 (widget_value**)XtCalloc (mw->menu.old_stack_length,
297 sizeof (widget_value*));
298 }
299 else if (mw->menu.old_stack_length < n)
300 {
301 mw->menu.old_stack_length *= 2;
302 mw->menu.old_stack =
303 (widget_value**)XtRealloc ((char*)mw->menu.old_stack,
304 mw->menu.old_stack_length * sizeof (widget_value*));
305 }
306}
307
308\f/* Size code */
d398028f
PR		 309int
310string_width (mw, s)
311 XlwMenuWidget mw;
312 char *s;
07bf635f
RS		 313{
314 XCharStruct xcs;
315 int drop;
5c520e0a 316
07bf635f
RS		 317 XTextExtents (mw->menu.font, s, strlen (s), &drop, &drop, &drop, &xcs);
318 return xcs.width;
319}
320
321static int
d398028f
PR		 322arrow_width (mw)
323 XlwMenuWidget mw;
07bf635f 324{
be06a3df 325 return (mw->menu.font->ascent * 3/4) | 1;
07bf635f
RS		 326}
327
be06a3df
GM		 328/* Return the width of toggle buttons of widget MW. */
329
330static int
331toggle_button_width (mw)
332 XlwMenuWidget mw;
333{
334 return ((mw->menu.font->ascent + mw->menu.font->descent) * 2 / 3) | 1;
335}
336
337
338/* Return the width of radio buttons of widget MW. */
339
340static int
341radio_button_width (mw)
342 XlwMenuWidget mw;
343{
344 return toggle_button_width (mw) * 1.41;
345}
346
347
07bf635f
RS		 348static XtResource
349nameResource[] =
5c520e0a 350{
07bf635f
RS		 351 {"labelString", "LabelString", XtRString, sizeof(String),
352 0, XtRImmediate, 0},
353};
354
355static char*
d398028f
PR		 356resource_widget_value (mw, val)
357 XlwMenuWidget mw;
358 widget_value *val;
07bf635f
RS		 359{
360 if (!val->toolkit_data)
361 {
362 char* resourced_name = NULL;
363 char* complete_name;
364 XtGetSubresources ((Widget) mw,
365 (XtPointer) &resourced_name,
366 val->name, val->name,
367 nameResource, 1, NULL, 0);
368 if (!resourced_name)
369 resourced_name = val->name;
370 if (!val->value)
d97342f3
RS		 371 {
372 complete_name = (char *) XtMalloc (strlen (resourced_name) + 1);
373 strcpy (complete_name, resourced_name);
374 }
07bf635f
RS		 375 else
376 {
377 int complete_length =
378 strlen (resourced_name) + strlen (val->value) + 2;
379 complete_name = XtMalloc (complete_length);
380 *complete_name = 0;
381 strcat (complete_name, resourced_name);
382 strcat (complete_name, " ");
383 strcat (complete_name, val->value);
384 }
385
386 val->toolkit_data = complete_name;
387 val->free_toolkit_data = True;
388 }
389 return (char*)val->toolkit_data;
390}
391
392/* Returns the sizes of an item */
393static void
be06a3df
GM		 394size_menu_item (mw, val, horizontal_p, label_width, rest_width, button_width,
395 height)
d398028f
PR		 396 XlwMenuWidget mw;
397 widget_value* val;
398 int horizontal_p;
399 int* label_width;
400 int* rest_width;
be06a3df 401 int* button_width;
d398028f 402 int* height;
07bf635f 403{
be06a3df 404 enum menu_separator separator;
5c520e0a 405
be06a3df 406 if (lw_separator_p (val->name, &separator, 0))
07bf635f 407 {
be06a3df 408 *height = separator_height (separator);
07bf635f
RS		 409 *label_width = 1;
410 *rest_width = 0;
be06a3df 411 *button_width = 0;
07bf635f
RS		 412 }
413 else
414 {
415 *height =
416 mw->menu.font->ascent + mw->menu.font->descent
417 + 2 * mw->menu.vertical_spacing + 2 * mw->menu.shadow_thickness;
5c520e0a 418
07bf635f
RS		 419 *label_width =
420 string_width (mw, resource_widget_value (mw, val))
421 + mw->menu.horizontal_spacing + mw->menu.shadow_thickness;
5c520e0a 422
07bf635f
RS		 423 *rest_width = mw->menu.horizontal_spacing + mw->menu.shadow_thickness;
424 if (!horizontal_p)
425 {
426 if (val->contents)
be06a3df 427 /* Add width of the arrow displayed for submenus. */
07bf635f
RS		 428 *rest_width += arrow_width (mw) + mw->menu.arrow_spacing;
429 else if (val->key)
be06a3df
GM		 430 /* Add width of key equivalent string. */
431 *rest_width += (string_width (mw, val->key)
432 + mw->menu.arrow_spacing);
433
434 if (val->button_type == BUTTON_TYPE_TOGGLE)
435 *button_width = (toggle_button_width (mw)
436 + mw->menu.horizontal_spacing);
437 else if (val->button_type == BUTTON_TYPE_RADIO)
438 *button_width = (radio_button_width (mw)
439 + mw->menu.horizontal_spacing);
07bf635f
RS		 440 }
441 }
442}
443
444static void
d398028f
PR		 445size_menu (mw, level)
446 XlwMenuWidget mw;
447 int level;
07bf635f 448{
ccf589a6 449 unsigned int label_width = 0;
07bf635f 450 int rest_width = 0;
be06a3df 451 int button_width = 0;
07bf635f 452 int max_rest_width = 0;
be06a3df 453 int max_button_width = 0;
ccf589a6 454 unsigned int height = 0;
07bf635f
RS		 455 int horizontal_p = mw->menu.horizontal && (level == 0);
456 widget_value* val;
457 window_state* ws;
458
459 if (level >= mw->menu.old_depth)
be06a3df 460 abort_gracefully ((Widget) mw);
07bf635f 461
5c520e0a 462 ws = &mw->menu.windows [level];
07bf635f
RS		 463 ws->width = 0;
464 ws->height = 0;
465 ws->label_width = 0;
be06a3df 466 ws->button_width = 0;
07bf635f
RS		 467
468 for (val = mw->menu.old_stack [level]->contents; val; val = val->next)
469 {
470 size_menu_item (mw, val, horizontal_p, &label_width, &rest_width,
be06a3df 471 &button_width, &height);
07bf635f
RS		 472 if (horizontal_p)
473 {
474 ws->width += label_width + rest_width;
475 if (height > ws->height)
476 ws->height = height;
477 }
478 else
479 {
480 if (label_width > ws->label_width)
481 ws->label_width = label_width;
482 if (rest_width > max_rest_width)
483 max_rest_width = rest_width;
be06a3df
GM		 484 if (button_width > max_button_width)
485 max_button_width = button_width;
07bf635f
RS		 486 ws->height += height;
487 }
488 }
5c520e0a 489
07bf635f 490 if (horizontal_p)
be06a3df 491 ws->label_width = ws->button_width = 0;
07bf635f 492 else
be06a3df
GM		 493 {
494 ws->width = ws->label_width + max_rest_width + max_button_width;
495 ws->button_width = max_button_width;
496 }
07bf635f
RS		 497
498 ws->width += 2 * mw->menu.shadow_thickness;
499 ws->height += 2 * mw->menu.shadow_thickness;
be06a3df
GM		 500
501 if (horizontal_p)
502 {
503 ws->width += 2 * mw->menu.margin;
504 ws->height += 2 * mw->menu.margin;
505 }
07bf635f
RS		 506}
507
508
509\f/* Display code */
be06a3df 510
07bf635f 511static void
be06a3df 512draw_arrow (mw, window, gc, x, y, width, down_p)
d398028f
PR		 513 XlwMenuWidget mw;
514 Window window;
515 GC gc;
516 int x;
517 int y;
518 int width;
be06a3df 519 int down_p;
07bf635f 520{
be06a3df
GM		 521 Display *dpy = XtDisplay (mw);
522 GC top_gc = mw->menu.shadow_top_gc;
523 GC bottom_gc = mw->menu.shadow_bottom_gc;
524 int thickness = mw->menu.shadow_thickness;
525 int height = width;
526 XPoint pt[10];
527 /* alpha = atan (0.5)
528 factor = (1 + sin (alpha)) / cos (alpha) */
529 double factor = 1.62;
530 int thickness2 = thickness * factor;
5c520e0a 531
be06a3df 532 y += (mw->menu.font->ascent + mw->menu.font->descent - height) / 2;
5c520e0a 533
be06a3df
GM		 534 if (down_p)
535 {
536 GC temp;
537 temp = top_gc;
538 top_gc = bottom_gc;
539 bottom_gc = temp;
540 }
541
542 pt[0].x = x;
543 pt[0].y = y + height;
544 pt[1].x = x + thickness;
545 pt[1].y = y + height - thickness2;
546 pt[2].x = x + thickness2;
547 pt[2].y = y + thickness2;
548 pt[3].x = x;
549 pt[3].y = y;
550 XFillPolygon (dpy, window, top_gc, pt, 4, Convex, CoordModeOrigin);
5c520e0a 551
be06a3df
GM		 552 pt[0].x = x;
553 pt[0].y = y;
554 pt[1].x = x + thickness;
555 pt[1].y = y + thickness2;
556 pt[2].x = x + width - thickness2;
557 pt[2].y = y + height / 2;
558 pt[3].x = x + width;
559 pt[3].y = y + height / 2;
560 XFillPolygon (dpy, window, top_gc, pt, 4, Convex, CoordModeOrigin);
5c520e0a 561
be06a3df
GM		 562 pt[0].x = x;
563 pt[0].y = y + height;
564 pt[1].x = x + thickness;
565 pt[1].y = y + height - thickness2;
566 pt[2].x = x + width - thickness2;
567 pt[2].y = y + height / 2;
568 pt[3].x = x + width;
569 pt[3].y = y + height / 2;
570 XFillPolygon (dpy, window, bottom_gc, pt, 4, Convex, CoordModeOrigin);
07bf635f
RS		 571}
572
be06a3df
GM		 573
574
07bf635f 575static void
be06a3df 576draw_shadow_rectangle (mw, window, x, y, width, height, erase_p, down_p)
d398028f
PR		 577 XlwMenuWidget mw;
578 Window window;
579 int x;
580 int y;
581 int width;
582 int height;
583 int erase_p;
be06a3df 584 int down_p;
07bf635f
RS		 585{
586 Display *dpy = XtDisplay (mw);
587 GC top_gc = !erase_p ? mw->menu.shadow_top_gc : mw->menu.background_gc;
588 GC bottom_gc = !erase_p ? mw->menu.shadow_bottom_gc : mw->menu.background_gc;
589 int thickness = mw->menu.shadow_thickness;
590 XPoint points [4];
be06a3df
GM		 591
592 if (!erase_p && down_p)
593 {
594 GC temp;
595 temp = top_gc;
596 top_gc = bottom_gc;
597 bottom_gc = temp;
598 }
5c520e0a 599
07bf635f
RS		 600 points [0].x = x;
601 points [0].y = y;
602 points [1].x = x + width;
603 points [1].y = y;
604 points [2].x = x + width - thickness;
605 points [2].y = y + thickness;
606 points [3].x = x;
607 points [3].y = y + thickness;
608 XFillPolygon (dpy, window, top_gc, points, 4, Convex, CoordModeOrigin);
609 points [0].x = x;
610 points [0].y = y + thickness;
611 points [1].x = x;
612 points [1].y = y + height;
613 points [2].x = x + thickness;
614 points [2].y = y + height - thickness;
615 points [3].x = x + thickness;
616 points [3].y = y + thickness;
617 XFillPolygon (dpy, window, top_gc, points, 4, Convex, CoordModeOrigin);
618 points [0].x = x + width;
619 points [0].y = y;
620 points [1].x = x + width - thickness;
621 points [1].y = y + thickness;
622 points [2].x = x + width - thickness;
623 points [2].y = y + height - thickness;
624 points [3].x = x + width;
625 points [3].y = y + height - thickness;
626 XFillPolygon (dpy, window, bottom_gc, points, 4, Convex, CoordModeOrigin);
627 points [0].x = x;
628 points [0].y = y + height;
629 points [1].x = x + width;
630 points [1].y = y + height;
631 points [2].x = x + width;
632 points [2].y = y + height - thickness;
633 points [3].x = x + thickness;
634 points [3].y = y + height - thickness;
635 XFillPolygon (dpy, window, bottom_gc, points, 4, Convex, CoordModeOrigin);
636}
637
638
be06a3df
GM		 639static void
640draw_shadow_rhombus (mw, window, x, y, width, height, erase_p, down_p)
641 XlwMenuWidget mw;
642 Window window;
643 int x;
644 int y;
645 int width;
646 int height;
647 int erase_p;
648 int down_p;
649{
650 Display *dpy = XtDisplay (mw);
651 GC top_gc = !erase_p ? mw->menu.shadow_top_gc : mw->menu.background_gc;
652 GC bottom_gc = !erase_p ? mw->menu.shadow_bottom_gc : mw->menu.background_gc;
653 int thickness = mw->menu.shadow_thickness;
654 XPoint points [4];
be06a3df
GM		 655
656 if (!erase_p && down_p)
657 {
658 GC temp;
659 temp = top_gc;
660 top_gc = bottom_gc;
661 bottom_gc = temp;
662 }
663
664 points [0].x = x;
665 points [0].y = y + height / 2;
666 points [1].x = x + thickness;
667 points [1].y = y + height / 2;
668 points [2].x = x + width / 2;
669 points [2].y = y + thickness;
670 points [3].x = x + width / 2;
671 points [3].y = y;
672 XFillPolygon (dpy, window, top_gc, points, 4, Convex, CoordModeOrigin);
673 points [0].x = x + width / 2;
674 points [0].y = y;
675 points [1].x = x + width / 2;
676 points [1].y = y + thickness;
677 points [2].x = x + width - thickness;
678 points [2].y = y + height / 2;
679 points [3].x = x + width;
680 points [3].y = y + height / 2;
681 XFillPolygon (dpy, window, top_gc, points, 4, Convex, CoordModeOrigin);
682 points [0].x = x;
683 points [0].y = y + height / 2;
684 points [1].x = x + thickness;
685 points [1].y = y + height / 2;
686 points [2].x = x + width / 2;
687 points [2].y = y + height - thickness;
688 points [3].x = x + width / 2;
689 points [3].y = y + height;
690 XFillPolygon (dpy, window, bottom_gc, points, 4, Convex, CoordModeOrigin);
691 points [0].x = x + width / 2;
692 points [0].y = y + height;
693 points [1].x = x + width / 2;
694 points [1].y = y + height - thickness;
695 points [2].x = x + width - thickness;
696 points [2].y = y + height / 2;
697 points [3].x = x + width;
698 points [3].y = y + height / 2;
699 XFillPolygon (dpy, window, bottom_gc, points, 4, Convex, CoordModeOrigin);
700}
701
702
703/* Draw a toggle button on widget MW, X window WINDOW. X/Y is the
704 top-left corner of the menu item. SELECTED_P non-zero means the
705 toggle button is selected. */
706
707static void
708draw_toggle (mw, window, x, y, selected_p)
709 XlwMenuWidget mw;
710 Window window;
711 int x, y, selected_p;
712{
713 int width, height;
714
715 width = toggle_button_width (mw);
716 height = width;
717 x += mw->menu.horizontal_spacing;
718 y += (mw->menu.font->ascent - height) / 2;
719 draw_shadow_rectangle (mw, window, x, y, width, height, False, selected_p);
720}
721
722
723/* Draw a radio button on widget MW, X window WINDOW. X/Y is the
724 top-left corner of the menu item. SELECTED_P non-zero means the
725 toggle button is selected. */
726
727static void
728draw_radio (mw, window, x, y, selected_p)
729 XlwMenuWidget mw;
730 Window window;
731 int x, y, selected_p;
732{
733 int width, height;
734
735 width = radio_button_width (mw);
736 height = width;
737 x += mw->menu.horizontal_spacing;
738 y += (mw->menu.font->ascent - height) / 2;
739 draw_shadow_rhombus (mw, window, x, y, width, height, False, selected_p);
740}
741
742
743/* Draw a menu separator on widget MW, X window WINDOW. X/Y is the
744 top-left corner of the menu item. WIDTH is the width of the
745 separator to draw. TYPE is the separator type. */
746
747static void
748draw_separator (mw, window, x, y, width, type)
749 XlwMenuWidget mw;
750 Window window;
751 int x, y, width;
752 enum menu_separator type;
753{
754 Display *dpy = XtDisplay (mw);
755 XGCValues xgcv;
756
757 switch (type)
758 {
759 case SEPARATOR_NO_LINE:
760 break;
5c520e0a 761
be06a3df
GM		 762 case SEPARATOR_SINGLE_LINE:
763 XDrawLine (dpy, window, mw->menu.foreground_gc,
764 x, y, x + width, y);
765 break;
5c520e0a 766
be06a3df
GM		 767 case SEPARATOR_DOUBLE_LINE:
768 draw_separator (mw, window, x, y, width, SEPARATOR_SINGLE_LINE);
769 draw_separator (mw, window, x, y + 2, width, SEPARATOR_SINGLE_LINE);
770 break;
5c520e0a 771
be06a3df
GM		 772 case SEPARATOR_SINGLE_DASHED_LINE:
773 xgcv.line_style = LineOnOffDash;
774 XChangeGC (dpy, mw->menu.foreground_gc, GCLineStyle, &xgcv);
775 XDrawLine (dpy, window, mw->menu.foreground_gc,
776 x, y, x + width, y);
777 xgcv.line_style = LineSolid;
778 XChangeGC (dpy, mw->menu.foreground_gc, GCLineStyle, &xgcv);
779 break;
5c520e0a 780
be06a3df
GM		 781 case SEPARATOR_DOUBLE_DASHED_LINE:
782 draw_separator (mw, window, x, y, width,
783 SEPARATOR_SINGLE_DASHED_LINE);
784 draw_separator (mw, window, x, y + 2, width,
785 SEPARATOR_SINGLE_DASHED_LINE);
786 break;
5c520e0a 787
be06a3df
GM		 788 case SEPARATOR_SHADOW_ETCHED_IN:
789 XDrawLine (dpy, window, mw->menu.shadow_bottom_gc,
790 x, y, x + width, y);
791 XDrawLine (dpy, window, mw->menu.shadow_top_gc,
792 x, y + 1, x + width, y + 1);
793 break;
794
795 case SEPARATOR_SHADOW_ETCHED_OUT:
796 XDrawLine (dpy, window, mw->menu.shadow_top_gc,
797 x, y, x + width, y);
798 XDrawLine (dpy, window, mw->menu.shadow_bottom_gc,
799 x, y + 1, x + width, y + 1);
800 break;
5c520e0a 801
be06a3df
GM		 802 case SEPARATOR_SHADOW_ETCHED_IN_DASH:
803 xgcv.line_style = LineOnOffDash;
804 XChangeGC (dpy, mw->menu.shadow_bottom_gc, GCLineStyle, &xgcv);
805 XChangeGC (dpy, mw->menu.shadow_top_gc, GCLineStyle, &xgcv);
2f90328f 806 draw_separator (mw, window, x, y, width, SEPARATOR_SHADOW_ETCHED_IN);
be06a3df
GM		 807 xgcv.line_style = LineSolid;
808 XChangeGC (dpy, mw->menu.shadow_bottom_gc, GCLineStyle, &xgcv);
809 XChangeGC (dpy, mw->menu.shadow_top_gc, GCLineStyle, &xgcv);
810 break;
5c520e0a 811
be06a3df
GM		 812 case SEPARATOR_SHADOW_ETCHED_OUT_DASH:
813 xgcv.line_style = LineOnOffDash;
814 XChangeGC (dpy, mw->menu.shadow_bottom_gc, GCLineStyle, &xgcv);
815 XChangeGC (dpy, mw->menu.shadow_top_gc, GCLineStyle, &xgcv);
2f90328f 816 draw_separator (mw, window, x, y, width, SEPARATOR_SHADOW_ETCHED_OUT);
be06a3df
GM		 817 xgcv.line_style = LineSolid;
818 XChangeGC (dpy, mw->menu.shadow_bottom_gc, GCLineStyle, &xgcv);
819 XChangeGC (dpy, mw->menu.shadow_top_gc, GCLineStyle, &xgcv);
820 break;
821
822 case SEPARATOR_SHADOW_DOUBLE_ETCHED_IN:
823 draw_separator (mw, window, x, y, width, SEPARATOR_SHADOW_ETCHED_IN);
824 draw_separator (mw, window, x, y + 3, width, SEPARATOR_SHADOW_ETCHED_IN);
825 break;
5c520e0a 826
be06a3df
GM		 827 case SEPARATOR_SHADOW_DOUBLE_ETCHED_OUT:
828 draw_separator (mw, window, x, y, width,
829 SEPARATOR_SHADOW_ETCHED_OUT);
830 draw_separator (mw, window, x, y + 3, width,
831 SEPARATOR_SHADOW_ETCHED_OUT);
832 break;
5c520e0a 833
be06a3df
GM		 834 case SEPARATOR_SHADOW_DOUBLE_ETCHED_IN_DASH:
835 xgcv.line_style = LineOnOffDash;
836 XChangeGC (dpy, mw->menu.shadow_bottom_gc, GCLineStyle, &xgcv);
837 XChangeGC (dpy, mw->menu.shadow_top_gc, GCLineStyle, &xgcv);
838 draw_separator (mw, window, x, y, width,
839 SEPARATOR_SHADOW_DOUBLE_ETCHED_IN);
840 xgcv.line_style = LineSolid;
841 XChangeGC (dpy, mw->menu.shadow_bottom_gc, GCLineStyle, &xgcv);
842 XChangeGC (dpy, mw->menu.shadow_top_gc, GCLineStyle, &xgcv);
843 break;
844
845 case SEPARATOR_SHADOW_DOUBLE_ETCHED_OUT_DASH:
846 xgcv.line_style = LineOnOffDash;
847 XChangeGC (dpy, mw->menu.shadow_bottom_gc, GCLineStyle, &xgcv);
848 XChangeGC (dpy, mw->menu.shadow_top_gc, GCLineStyle, &xgcv);
849 draw_separator (mw, window, x, y, width,
850 SEPARATOR_SHADOW_DOUBLE_ETCHED_OUT);
851 xgcv.line_style = LineSolid;
852 XChangeGC (dpy, mw->menu.shadow_bottom_gc, GCLineStyle, &xgcv);
853 XChangeGC (dpy, mw->menu.shadow_top_gc, GCLineStyle, &xgcv);
854 break;
855
856 default:
857 abort ();
858 }
859}
860
861
862/* Return the pixel height of menu separator SEPARATOR. */
863
864static int
865separator_height (separator)
866 enum menu_separator separator;
867{
868 switch (separator)
869 {
870 case SEPARATOR_NO_LINE:
871 return 2;
5c520e0a 872
be06a3df
GM		 873 case SEPARATOR_SINGLE_LINE:
874 case SEPARATOR_SINGLE_DASHED_LINE:
875 return 1;
5c520e0a 876
be06a3df
GM		 877 case SEPARATOR_DOUBLE_LINE:
878 case SEPARATOR_DOUBLE_DASHED_LINE:
879 return 3;
5c520e0a 880
be06a3df
GM		 881 case SEPARATOR_SHADOW_ETCHED_IN:
882 case SEPARATOR_SHADOW_ETCHED_OUT:
883 case SEPARATOR_SHADOW_ETCHED_IN_DASH:
884 case SEPARATOR_SHADOW_ETCHED_OUT_DASH:
885 return 2;
5c520e0a 886
be06a3df
GM		 887 case SEPARATOR_SHADOW_DOUBLE_ETCHED_IN:
888 case SEPARATOR_SHADOW_DOUBLE_ETCHED_OUT:
889 case SEPARATOR_SHADOW_DOUBLE_ETCHED_IN_DASH:
890 case SEPARATOR_SHADOW_DOUBLE_ETCHED_OUT_DASH:
891 return 5;
5c520e0a 892
be06a3df
GM		 893 default:
894 abort ();
895 }
896}
897
898
07bf635f 899/* Display the menu item and increment where.x and where.y to show how large
be06a3df
GM		 900 the menu item was. */
901
07bf635f 902static void
be06a3df
GM		 903display_menu_item (mw, val, ws, where, highlighted_p, horizontal_p,
904 just_compute_p)
d398028f
PR		 905 XlwMenuWidget mw;
906 widget_value* val;
907 window_state* ws;
908 XPoint* where;
909 Boolean highlighted_p;
910 Boolean horizontal_p;
911 Boolean just_compute_p;
07bf635f
RS		 912{
913 GC deco_gc;
914 GC text_gc;
915 int font_ascent = mw->menu.font->ascent;
916 int font_descent = mw->menu.font->descent;
917 int shadow = mw->menu.shadow_thickness;
be06a3df 918 int margin = mw->menu.margin;
07bf635f
RS		 919 int h_spacing = mw->menu.horizontal_spacing;
920 int v_spacing = mw->menu.vertical_spacing;
921 int label_width;
922 int rest_width;
be06a3df 923 int button_width;
07bf635f
RS		 924 int height;
925 int width;
be06a3df
GM		 926 enum menu_separator separator;
927 int separator_p = lw_separator_p (val->name, &separator, 0);
07bf635f
RS		 928
929 /* compute the sizes of the item */
be06a3df
GM		 930 size_menu_item (mw, val, horizontal_p, &label_width, &rest_width,
931 &button_width, &height);
07bf635f
RS		 932
933 if (horizontal_p)
934 width = label_width + rest_width;
935 else
936 {
937 label_width = ws->label_width;
938 width = ws->width - 2 * shadow;
939 }
940
07bf635f
RS		 941 /* Only highlight an enabled item that has a callback. */
942 if (highlighted_p)
943 if (!val->enabled || !(val->call_data || val->contents))
944 highlighted_p = 0;
945
946 /* do the drawing. */
947 if (!just_compute_p)
948 {
949 /* Add the shadow border of the containing menu */
950 int x = where->x + shadow;
951 int y = where->y + shadow;
952
be06a3df
GM		 953 if (horizontal_p)
954 {
955 x += margin;
956 y += margin;
957 }
958
07bf635f
RS		 959 /* pick the foreground and background GC. */
960 if (val->enabled)
be06a3df 961 text_gc = mw->menu.foreground_gc;
07bf635f 962 else
be06a3df 963 text_gc = mw->menu.inactive_gc;
07bf635f
RS		 964 deco_gc = mw->menu.foreground_gc;
965
966 if (separator_p)
967 {
be06a3df 968 draw_separator (mw, ws->window, x, y, width, separator);
07bf635f 969 }
5c520e0a 970 else
07bf635f 971 {
84593cae 972 int x_offset = x + h_spacing + shadow;
07bf635f 973 char* display_string = resource_widget_value (mw, val);
be06a3df
GM		 974 draw_shadow_rectangle (mw, ws->window, x, y, width, height, True,
975 False);
84593cae
PR		 976
977 /* Deal with centering a menu title. */
978 if (!horizontal_p && !val->contents && !val->call_data)
979 {
980 int l = string_width (mw, display_string);
981
982 if (width > l)
983 x_offset = (width - l) >> 1;
984 }
be06a3df
GM		 985 else if (!horizontal_p && ws->button_width)
986 x_offset += ws->button_width;
5c520e0a
SS		 987
988
84593cae 989 XDrawString (XtDisplay (mw), ws->window, text_gc, x_offset,
07bf635f
RS		 990 y + v_spacing + shadow + font_ascent,
991 display_string, strlen (display_string));
5c520e0a 992
07bf635f
RS		 993 if (!horizontal_p)
994 {
be06a3df
GM		 995 if (val->button_type == BUTTON_TYPE_TOGGLE)
996 draw_toggle (mw, ws->window, x, y + v_spacing + shadow,
997 val->selected);
998 else if (val->button_type == BUTTON_TYPE_RADIO)
999 draw_radio (mw, ws->window, x, y + v_spacing + shadow,
1000 val->selected);
5c520e0a 1001
07bf635f
RS		 1002 if (val->contents)
1003 {
1004 int a_w = arrow_width (mw);
1005 draw_arrow (mw, ws->window, deco_gc,
be06a3df 1006 x + width - a_w
5c520e0a 1007 - mw->menu.horizontal_spacing
d398028f 1008 - mw->menu.shadow_thickness,
be06a3df
GM		 1009 y + v_spacing + shadow, a_w,
1010 highlighted_p);
07bf635f
RS		 1011 }
1012 else if (val->key)
1013 {
1014 XDrawString (XtDisplay (mw), ws->window, text_gc,
1015 x + label_width + mw->menu.arrow_spacing,
1016 y + v_spacing + shadow + font_ascent,
1017 val->key, strlen (val->key));
1018 }
1019 }
d398028f
PR		 1020 else
1021 {
5c520e0a 1022 XDrawRectangle (XtDisplay (mw), ws->window,
d398028f
PR		 1023 mw->menu.background_gc,
1024 x + shadow, y + shadow,
1025 label_width + h_spacing - 1,
1026 font_ascent + font_descent + 2 * v_spacing - 1);
1027 draw_shadow_rectangle (mw, ws->window, x, y, width, height,
be06a3df 1028 True, False);
d398028f 1029 }
07bf635f
RS		 1030
1031 if (highlighted_p)
be06a3df
GM		 1032 draw_shadow_rectangle (mw, ws->window, x, y, width, height, False,
1033 False);
07bf635f
RS		 1034 }
1035 }
5c520e0a 1036
07bf635f
RS		 1037 where->x += width;
1038 where->y += height;
1039}
1040
1041static void
d398028f
PR		 1042display_menu (mw, level, just_compute_p, highlighted_pos, hit, hit_return,
1043 this, that)
1044 XlwMenuWidget mw;
1045 int level;
1046 Boolean just_compute_p;
1047 XPoint* highlighted_pos;
1048 XPoint* hit;
1049 widget_value** hit_return;
1050 widget_value* this;
1051 widget_value* that;
07bf635f
RS		 1052{
1053 widget_value* val;
1054 widget_value* following_item;
1055 window_state* ws;
1056 XPoint where;
1057 int horizontal_p = mw->menu.horizontal && (level == 0);
1058 int highlighted_p;
1059 int just_compute_this_one_p;
ccc1cac0
RS		 1060 /* This is set nonzero if the element containing HIGHLIGHTED_POS
1061 is disabled, so that we do not return any subsequent element either. */
1062 int no_return = 0;
be06a3df 1063 enum menu_separator separator;
07bf635f
RS		 1064
1065 if (level >= mw->menu.old_depth)
be06a3df 1066 abort_gracefully ((Widget) mw);
07bf635f
RS		 1067
1068 if (level < mw->menu.old_depth - 1)
1069 following_item = mw->menu.old_stack [level + 1];
5c520e0a 1070 else
07bf635f
RS		 1071 following_item = NULL;
1072
1073 if (hit)
1074 *hit_return = NULL;
1075
1076 where.x = 0;
1077 where.y = 0;
1078
1079 ws = &mw->menu.windows [level];
1080 for (val = mw->menu.old_stack [level]->contents; val; val = val->next)
1081 {
1082 highlighted_p = val == following_item;
1083 if (highlighted_p && highlighted_pos)
1084 {
1085 if (horizontal_p)
1086 highlighted_pos->x = where.x;
1087 else
1088 highlighted_pos->y = where.y;
1089 }
5c520e0a 1090
07bf635f
RS		 1091 just_compute_this_one_p =
1092 just_compute_p || ((this || that) && val != this && val != that);
1093
1094 display_menu_item (mw, val, ws, &where, highlighted_p, horizontal_p,
1095 just_compute_this_one_p);
1096
1097 if (highlighted_p && highlighted_pos)
1098 {
1099 if (horizontal_p)
1100 highlighted_pos->y = where.y;
1101 else
1102 highlighted_pos->x = where.x;
1103 }
1104
1105 if (hit
1106 && !*hit_return
1107 && (horizontal_p ? hit->x < where.x : hit->y < where.y)
be06a3df 1108 && !lw_separator_p (val->name, &separator, 0)
ccc1cac0
RS		 1109 && !no_return)
1110 {
1111 if (val->enabled)
1112 *hit_return = val;
1113 else
1114 no_return = 1;
1115 }
07bf635f
RS		 1116
1117 if (horizontal_p)
1118 where.y = 0;
1119 else
1120 where.x = 0;
1121 }
5c520e0a 1122
07bf635f 1123 if (!just_compute_p)
be06a3df
GM		 1124 draw_shadow_rectangle (mw, ws->window, 0, 0, ws->width, ws->height,
1125 False, False);
07bf635f
RS		 1126}
1127
1128\f/* Motion code */
1129static void
d398028f
PR		 1130set_new_state (mw, val, level)
1131 XlwMenuWidget mw;
1132 widget_value* val;
1133 int level;
07bf635f
RS		 1134{
1135 int i;
5c520e0a 1136
07bf635f
RS		 1137 mw->menu.new_depth = 0;
1138 for (i = 0; i < level; i++)
1139 push_new_stack (mw, mw->menu.old_stack [i]);
1140 push_new_stack (mw, val);
1141}
1142
1143static void
d398028f
PR		 1144make_windows_if_needed (mw, n)
1145 XlwMenuWidget mw;
1146 int n;
07bf635f
RS		 1147{
1148 int i;
1149 int start_at;
1150 XSetWindowAttributes xswa;
1151 int mask;
1152 Window root = RootWindowOfScreen (DefaultScreenOfDisplay (XtDisplay (mw)));
1153 window_state* windows;
5c520e0a 1154
07bf635f
RS		 1155 if (mw->menu.windows_length >= n)
1156 return;
1157
1158 xswa.save_under = True;
1159 xswa.override_redirect = True;
1160 xswa.background_pixel = mw->core.background_pixel;
1161 xswa.border_pixel = mw->core.border_pixel;
1162 xswa.event_mask =
d398028f 1163 ExposureMask | PointerMotionMask | PointerMotionHintMask
07bf635f
RS		 1164 | ButtonReleaseMask | ButtonPressMask;
1165 xswa.cursor = mw->menu.cursor_shape;
1166 mask = CWSaveUnder | CWOverrideRedirect | CWBackPixel | CWBorderPixel
1167 | CWEventMask | CWCursor;
5c520e0a 1168
07bf635f
RS		 1169 if (!mw->menu.windows)
1170 {
1171 mw->menu.windows =
1172 (window_state*)XtMalloc (n * sizeof (window_state));
1173 start_at = 0;
1174 }
1175 else
1176 {
1177 mw->menu.windows =
1178 (window_state*)XtRealloc ((char*)mw->menu.windows,
1179 n * sizeof (window_state));
1180 start_at = mw->menu.windows_length;
1181 }
1182 mw->menu.windows_length = n;
1183
1184 windows = mw->menu.windows;
1185
1186 for (i = start_at; i < n; i++)
1187 {
1188 windows [i].x = 0;
1189 windows [i].y = 0;
1190 windows [i].width = 1;
1191 windows [i].height = 1;
1192 windows [i].window =
1193 XCreateWindow (XtDisplay (mw), root, 0, 0, 1, 1,
1194 0, 0, CopyFromParent, CopyFromParent, mask, &xswa);
1195 }
1196}
1197
1198/* Make the window fit in the screen */
1199static void
d398028f
PR		 1200fit_to_screen (mw, ws, previous_ws, horizontal_p)
1201 XlwMenuWidget mw;
1202 window_state* ws;
1203 window_state* previous_ws;
1204 Boolean horizontal_p;
07bf635f 1205{
ccf589a6
RS		 1206 unsigned int screen_width = WidthOfScreen (XtScreen (mw));
1207 unsigned int screen_height = HeightOfScreen (XtScreen (mw));
1ba46f7d
RS		 1208 /* 1 if we are unable to avoid an overlap between
1209 this menu and the parent menu in the X dimension. */
1210 int horizontal_overlap = 0;
07bf635f
RS		 1211
1212 if (ws->x < 0)
1213 ws->x = 0;
1214 else if (ws->x + ws->width > screen_width)
1215 {
1216 if (!horizontal_p)
b7fa4a06
MB		 1217 /* The addition of shadow-thickness for a sub-menu's position is
1218 to reflect a similar adjustment when the menu is displayed to
1219 the right of the invoking menu-item; it makes the sub-menu
1220 look more `attached' to the menu-item. */
1221 ws->x = previous_ws->x - ws->width + mw->menu.shadow_thickness;
07bf635f
RS		 1222 else
1223 ws->x = screen_width - ws->width;
525b8232 1224 if (ws->x < 0)
1ba46f7d
RS		 1225 {
1226 ws->x = 0;
1227 horizontal_overlap = 1;
1228 }
1229 }
1230 /* If we overlap in X, try to avoid overlap in Y. */
1231 if (horizontal_overlap
1232 && ws->y < previous_ws->y + previous_ws->height
1233 && previous_ws->y < ws->y + ws->height)
1234 {
1235 /* Put this menu right below or right above PREVIOUS_WS
1236 if there's room. */
1237 if (previous_ws->y + previous_ws->height + ws->height < screen_height)
1238 ws->y = previous_ws->y + previous_ws->height;
1239 else if (previous_ws->y - ws->height > 0)
1240 ws->y = previous_ws->y - ws->height;
07bf635f 1241 }
1ba46f7d 1242
07bf635f
RS		 1243 if (ws->y < 0)
1244 ws->y = 0;
1245 else if (ws->y + ws->height > screen_height)
1246 {
1247 if (horizontal_p)
1248 ws->y = previous_ws->y - ws->height;
1249 else
1250 ws->y = screen_height - ws->height;
5c520e0a 1251 if (ws->y < 0)
525b8232 1252 ws->y = 0;
07bf635f
RS		 1253 }
1254}
1255
1256/* Updates old_stack from new_stack and redisplays. */
1257static void
d398028f
PR		 1258remap_menubar (mw)
1259 XlwMenuWidget mw;
07bf635f
RS		 1260{
1261 int i;
1262 int last_same;
1263 XPoint selection_position;
1264 int old_depth = mw->menu.old_depth;
1265 int new_depth = mw->menu.new_depth;
1266 widget_value** old_stack;
1267 widget_value** new_stack;
1268 window_state* windows;
1269 widget_value* old_selection;
1270 widget_value* new_selection;
1271
1272 /* Check that enough windows and old_stack are ready. */
1273 make_windows_if_needed (mw, new_depth);
1274 make_old_stack_space (mw, new_depth);
1275 windows = mw->menu.windows;
1276 old_stack = mw->menu.old_stack;
1277 new_stack = mw->menu.new_stack;
1278
1279 /* compute the last identical different entry */
1280 for (i = 1; i < old_depth && i < new_depth; i++)
1281 if (old_stack [i] != new_stack [i])
1282 break;
1283 last_same = i - 1;
1284
1285 /* Memorize the previously selected item to be able to refresh it */
1286 old_selection = last_same + 1 < old_depth ? old_stack [last_same + 1] : NULL;
1287 if (old_selection && !old_selection->enabled)
1288 old_selection = NULL;
1289 new_selection = last_same + 1 < new_depth ? new_stack [last_same + 1] : NULL;
1290 if (new_selection && !new_selection->enabled)
1291 new_selection = NULL;
1292
d6fd6371
GM		 1293 /* Call callback when the hightlighted item changes. */
1294 if (old_selection || new_selection)
1295 XtCallCallbackList ((Widget)mw, mw->menu.highlight,
1296 (XtPointer) new_selection);
1297
07bf635f
RS		 1298 /* updates old_state from new_state. It has to be done now because
1299 display_menu (called below) uses the old_stack to know what to display. */
1300 for (i = last_same + 1; i < new_depth; i++)
1301 old_stack [i] = new_stack [i];
1302 mw->menu.old_depth = new_depth;
1303
908ff139 1304 /* refresh the last selection */
07bf635f
RS		 1305 selection_position.x = 0;
1306 selection_position.y = 0;
1307 display_menu (mw, last_same, new_selection == old_selection,
1308 &selection_position, NULL, NULL, old_selection, new_selection);
1309
1ba46f7d
RS		 1310 /* Now place the new menus. */
1311 for (i = last_same + 1; i < new_depth && new_stack[i]->contents; i++)
07bf635f 1312 {
1ba46f7d
RS		 1313 window_state *previous_ws = &windows[i - 1];
1314 window_state *ws = &windows[i];
07bf635f 1315
be06a3df
GM		 1316 ws->x = (previous_ws->x + selection_position.x
1317 + mw->menu.shadow_thickness);
b7fa4a06 1318 if (mw->menu.horizontal && i == 1)
be06a3df
GM		 1319 ws->x += mw->menu.margin;
1320
1321#if 0
07bf635f
RS		 1322 if (!mw->menu.horizontal || i > 1)
1323 ws->x += mw->menu.shadow_thickness;
be06a3df 1324#endif
5c520e0a 1325
be06a3df
GM		 1326 ws->y = (previous_ws->y + selection_position.y
1327 + mw->menu.shadow_thickness);
b7fa4a06 1328 if (mw->menu.horizontal && i == 1)
be06a3df 1329 ws->y += mw->menu.margin;
07bf635f
RS		 1330
1331 size_menu (mw, i);
1332
1333 fit_to_screen (mw, ws, previous_ws, mw->menu.horizontal && i == 1);
1334
1335 XClearWindow (XtDisplay (mw), ws->window);
1336 XMoveResizeWindow (XtDisplay (mw), ws->window, ws->x, ws->y,
1337 ws->width, ws->height);
1338 XMapRaised (XtDisplay (mw), ws->window);
1339 display_menu (mw, i, False, &selection_position, NULL, NULL, NULL, NULL);
1340 }
1341
1342 /* unmap the menus that popped down */
1343 for (i = new_depth - 1; i < old_depth; i++)
1ba46f7d
RS		 1344 if (i >= new_depth || !new_stack[i]->contents)
1345 XUnmapWindow (XtDisplay (mw), windows[i].window);
07bf635f
RS		 1346}
1347
1348static Boolean
d398028f
PR		 1349motion_event_is_in_menu (mw, ev, level, relative_pos)
1350 XlwMenuWidget mw;
1351 XMotionEvent* ev;
1352 int level;
1353 XPoint* relative_pos;
07bf635f
RS		 1354{
1355 window_state* ws = &mw->menu.windows [level];
4f08464c
RS		 1356 int shadow = level == 0 ? 0 : mw->menu.shadow_thickness;
1357 int x = ws->x + shadow;
1358 int y = ws->y + shadow;
07bf635f
RS		 1359 relative_pos->x = ev->x_root - x;
1360 relative_pos->y = ev->y_root - y;
4f08464c
RS		 1361 return (x - shadow < ev->x_root && ev->x_root < x + ws->width
1362 && y - shadow < ev->y_root && ev->y_root < y + ws->height);
07bf635f
RS		 1363}
1364
1365static Boolean
d398028f
PR		 1366map_event_to_widget_value (mw, ev, val, level)
1367 XlwMenuWidget mw;
1368 XMotionEvent* ev;
1369 widget_value** val;
1370 int* level;
07bf635f
RS		 1371{
1372 int i;
1373 XPoint relative_pos;
1374 window_state* ws;
1375
1376 *val = NULL;
5c520e0a 1377
07bf635f
RS		 1378 /* Find the window */
1379 for (i = mw->menu.old_depth - 1; i >= 0; i--)
1380 {
1381 ws = &mw->menu.windows [i];
1382 if (ws && motion_event_is_in_menu (mw, ev, i, &relative_pos))
1383 {
1384 display_menu (mw, i, True, NULL, &relative_pos, val, NULL, NULL);
1385
1386 if (*val)
1387 {
1388 *level = i + 1;
1389 return True;
1390 }
1391 }
1392 }
1393 return False;
1394}
1395
1396\f/* Procedures */
1397static void
d398028f
PR		 1398make_drawing_gcs (mw)
1399 XlwMenuWidget mw;
07bf635f
RS		 1400{
1401 XGCValues xgcv;
1402
1403 xgcv.font = mw->menu.font->fid;
1404 xgcv.foreground = mw->menu.foreground;
1405 xgcv.background = mw->core.background_pixel;
1406 mw->menu.foreground_gc = XtGetGC ((Widget)mw,
1407 GCFont | GCForeground | GCBackground,
1408 &xgcv);
5c520e0a 1409
07bf635f
RS		 1410 xgcv.font = mw->menu.font->fid;
1411 xgcv.foreground = mw->menu.button_foreground;
1412 xgcv.background = mw->core.background_pixel;
1413 mw->menu.button_gc = XtGetGC ((Widget)mw,
1414 GCFont | GCForeground | GCBackground,
1415 &xgcv);
5c520e0a 1416
07bf635f
RS		 1417 xgcv.font = mw->menu.font->fid;
1418 xgcv.foreground = mw->menu.foreground;
1419 xgcv.background = mw->core.background_pixel;
1420 xgcv.fill_style = FillStippled;
1421 xgcv.stipple = mw->menu.gray_pixmap;
1422 mw->menu.inactive_gc = XtGetGC ((Widget)mw,
1423 (GCFont | GCForeground | GCBackground
1424 | GCFillStyle | GCStipple), &xgcv);
5c520e0a 1425
07bf635f
RS		 1426 xgcv.font = mw->menu.font->fid;
1427 xgcv.foreground = mw->menu.button_foreground;
1428 xgcv.background = mw->core.background_pixel;
1429 xgcv.fill_style = FillStippled;
1430 xgcv.stipple = mw->menu.gray_pixmap;
1431 mw->menu.inactive_button_gc = XtGetGC ((Widget)mw,
1432 (GCFont | GCForeground | GCBackground
1433 | GCFillStyle | GCStipple), &xgcv);
5c520e0a 1434
07bf635f
RS		 1435 xgcv.font = mw->menu.font->fid;
1436 xgcv.foreground = mw->core.background_pixel;
1437 xgcv.background = mw->menu.foreground;
1438 mw->menu.background_gc = XtGetGC ((Widget)mw,
1439 GCFont | GCForeground | GCBackground,
1440 &xgcv);
1441}
1442
1443static void
d398028f
PR		 1444release_drawing_gcs (mw)
1445 XlwMenuWidget mw;
07bf635f
RS		 1446{
1447 XtReleaseGC ((Widget) mw, mw->menu.foreground_gc);
1448 XtReleaseGC ((Widget) mw, mw->menu.button_gc);
1449 XtReleaseGC ((Widget) mw, mw->menu.inactive_gc);
1450 XtReleaseGC ((Widget) mw, mw->menu.inactive_button_gc);
1451 XtReleaseGC ((Widget) mw, mw->menu.background_gc);
1452 /* let's get some segvs if we try to use these... */
1453 mw->menu.foreground_gc = (GC) -1;
1454 mw->menu.button_gc = (GC) -1;
1455 mw->menu.inactive_gc = (GC) -1;
1456 mw->menu.inactive_button_gc = (GC) -1;
1457 mw->menu.background_gc = (GC) -1;
1458}
1459
1460#define MINL(x,y) ((((unsigned long) (x)) < ((unsigned long) (y))) \
1461 ? ((unsigned long) (x)) : ((unsigned long) (y)))
1462
1463static void
d398028f
PR		 1464make_shadow_gcs (mw)
1465 XlwMenuWidget mw;
07bf635f
RS		 1466{
1467 XGCValues xgcv;
1468 unsigned long pm = 0;
1469 Display *dpy = XtDisplay ((Widget) mw);
be06a3df 1470 Screen *screen = XtScreen ((Widget) mw);
b0404f9f 1471 Colormap cmap = mw->core.colormap;
07bf635f
RS		 1472 XColor topc, botc;
1473 int top_frobbed = 0, bottom_frobbed = 0;
1474
bba2a923
GM		 1475 mw->menu.free_top_shadow_color_p = 0;
1476 mw->menu.free_bottom_shadow_color_p = 0;
1477
07bf635f
RS		 1478 if (mw->menu.top_shadow_color == -1)
1479 mw->menu.top_shadow_color = mw->core.background_pixel;
bba2a923
GM		 1480 else
1481 mw->menu.top_shadow_color = mw->menu.top_shadow_color;
5c520e0a 1482
07bf635f
RS		 1483 if (mw->menu.bottom_shadow_color == -1)
1484 mw->menu.bottom_shadow_color = mw->menu.foreground;
bba2a923
GM		 1485 else
1486 mw->menu.bottom_shadow_color = mw->menu.bottom_shadow_color;
07bf635f
RS		 1487
1488 if (mw->menu.top_shadow_color == mw->core.background_pixel ||
1489 mw->menu.top_shadow_color == mw->menu.foreground)
1490 {
1491 topc.pixel = mw->core.background_pixel;
65c0ae05
MB		 1492#ifdef emacs
1493 if (x_alloc_lighter_color_for_widget ((Widget) mw, dpy, cmap,
1494 &topc.pixel,
1495 1.2, 0x8000))
1496#else
07bf635f
RS		 1497 XQueryColor (dpy, cmap, &topc);
1498 /* don't overflow/wrap! */
1499 topc.red = MINL (65535, topc.red * 1.2);
1500 topc.green = MINL (65535, topc.green * 1.2);
1501 topc.blue = MINL (65535, topc.blue * 1.2);
1502 if (XAllocColor (dpy, cmap, &topc))
be06a3df 1503#endif
07bf635f
RS		 1504 {
1505 mw->menu.top_shadow_color = topc.pixel;
bba2a923 1506 mw->menu.free_top_shadow_color_p = 1;
07bf635f
RS		 1507 top_frobbed = 1;
1508 }
1509 }
1510 if (mw->menu.bottom_shadow_color == mw->menu.foreground ||
1511 mw->menu.bottom_shadow_color == mw->core.background_pixel)
1512 {
1513 botc.pixel = mw->core.background_pixel;
65c0ae05
MB		 1514#ifdef emacs
1515 if (x_alloc_lighter_color_for_widget ((Widget) mw, dpy, cmap,
1516 &botc.pixel,
1517 0.6, 0x4000))
1518#else
07bf635f
RS		 1519 XQueryColor (dpy, cmap, &botc);
1520 botc.red *= 0.6;
1521 botc.green *= 0.6;
1522 botc.blue *= 0.6;
1523 if (XAllocColor (dpy, cmap, &botc))
be06a3df 1524#endif
07bf635f
RS		 1525 {
1526 mw->menu.bottom_shadow_color = botc.pixel;
bba2a923 1527 mw->menu.free_bottom_shadow_color_p = 1;
07bf635f
RS		 1528 bottom_frobbed = 1;
1529 }
1530 }
1531
1532 if (top_frobbed && bottom_frobbed)
1533 {
65c0ae05 1534 if (topc.pixel == botc.pixel)
07bf635f
RS		 1535 {
1536 if (botc.pixel == mw->menu.foreground)
fc8fefed 1537 {
bba2a923
GM		 1538 if (mw->menu.free_top_shadow_color_p)
1539 {
1540 x_free_dpy_colors (dpy, screen, cmap,
1541 &mw->menu.top_shadow_color, 1);
1542 mw->menu.free_top_shadow_color_p = 0;
1543 }
1544 mw->menu.top_shadow_color = mw->core.background_pixel;
fc8fefed 1545 }
07bf635f 1546 else
fc8fefed 1547 {
bba2a923
GM		 1548 if (mw->menu.free_bottom_shadow_color_p)
1549 {
1550 x_free_dpy_colors (dpy, screen, cmap,
1551 &mw->menu.bottom_shadow_color, 1);
1552 mw->menu.free_bottom_shadow_color_p = 0;
1553 }
1554 mw->menu.bottom_shadow_color = mw->menu.foreground;
fc8fefed 1555 }
07bf635f
RS		 1556 }
1557 }
1558
1559 if (!mw->menu.top_shadow_pixmap &&
1560 mw->menu.top_shadow_color == mw->core.background_pixel)
1561 {
1562 mw->menu.top_shadow_pixmap = mw->menu.gray_pixmap;
bba2a923
GM		 1563 if (mw->menu.free_top_shadow_color_p)
1564 {
1565 x_free_dpy_colors (dpy, screen, cmap, &mw->menu.top_shadow_color, 1);
1566 mw->menu.free_top_shadow_color_p = 0;
1567 }
1568 mw->menu.top_shadow_color = mw->menu.foreground;
07bf635f
RS		 1569 }
1570 if (!mw->menu.bottom_shadow_pixmap &&
1571 mw->menu.bottom_shadow_color == mw->core.background_pixel)
1572 {
1573 mw->menu.bottom_shadow_pixmap = mw->menu.gray_pixmap;
bba2a923
GM		 1574 if (mw->menu.free_bottom_shadow_color_p)
1575 {
1576 x_free_dpy_colors (dpy, screen, cmap,
1577 &mw->menu.bottom_shadow_color, 1);
1578 mw->menu.free_bottom_shadow_color_p = 0;
1579 }
1580 mw->menu.bottom_shadow_color = mw->menu.foreground;
07bf635f
RS		 1581 }
1582
1583 xgcv.fill_style = FillStippled;
1584 xgcv.foreground = mw->menu.top_shadow_color;
1585 xgcv.stipple = mw->menu.top_shadow_pixmap;
1586 pm = (xgcv.stipple ? GCStipple|GCFillStyle : 0);
1587 mw->menu.shadow_top_gc = XtGetGC ((Widget)mw, GCForeground | pm, &xgcv);
1588
1589 xgcv.foreground = mw->menu.bottom_shadow_color;
1590 xgcv.stipple = mw->menu.bottom_shadow_pixmap;
1591 pm = (xgcv.stipple ? GCStipple|GCFillStyle : 0);
1592 mw->menu.shadow_bottom_gc = XtGetGC ((Widget)mw, GCForeground | pm, &xgcv);
1593}
1594
1595
1596static void
d398028f
PR		 1597release_shadow_gcs (mw)
1598 XlwMenuWidget mw;
07bf635f 1599{
fc8fefed
GM		 1600 Display *dpy = XtDisplay ((Widget) mw);
1601 Screen *screen = XtScreen ((Widget) mw);
1602 Colormap cmap = mw->core.colormap;
1603 Pixel px[2];
bba2a923
GM		 1604 int i = 0;
1605
1606 if (mw->menu.free_top_shadow_color_p)
1607 px[i++] = mw->menu.top_shadow_color;
1608 if (mw->menu.free_bottom_shadow_color_p)
1609 px[i++] = mw->menu.bottom_shadow_color;
1610 if (i > 0)
1611 x_free_dpy_colors (dpy, screen, cmap, px, i);
5c520e0a 1612
07bf635f
RS		 1613 XtReleaseGC ((Widget) mw, mw->menu.shadow_top_gc);
1614 XtReleaseGC ((Widget) mw, mw->menu.shadow_bottom_gc);
1615}
1616
1617static void
47d52240 1618XlwMenuInitialize (request, mw, args, num_args)
d398028f 1619 Widget request;
47d52240 1620 XlwMenuWidget mw;
d398028f
PR		 1621 ArgList args;
1622 Cardinal *num_args;
07bf635f
RS		 1623{
1624 /* Get the GCs and the widget size */
07bf635f
RS		 1625 XSetWindowAttributes xswa;
1626 int mask;
5c520e0a 1627
07bf635f
RS		 1628 Window window = RootWindowOfScreen (DefaultScreenOfDisplay (XtDisplay (mw)));
1629 Display* display = XtDisplay (mw);
5c520e0a 1630
d398028f
PR		 1631#if 0
1632 widget_value *tem = (widget_value *) XtMalloc (sizeof (widget_value));
1633
1634 /* _XtCreate is freeing the object that was passed to us,
1635 so make a copy that we will actually keep. */
1636 lwlib_bcopy (mw->menu.contents, tem, sizeof (widget_value));
1637 mw->menu.contents = tem;
1638#endif
1639
07bf635f
RS		 1640/* mw->menu.cursor = XCreateFontCursor (display, mw->menu.cursor_shape); */
1641 mw->menu.cursor = mw->menu.cursor_shape;
5c520e0a 1642
a504c8fa 1643 mw->menu.gray_pixmap
f1c16db4
GM		 1644 = XCreatePixmapFromBitmapData (display, window, gray_bitmap_bits,
1645 gray_bitmap_width, gray_bitmap_height,
a504c8fa 1646 (unsigned long)1, (unsigned long)0, 1);
5c520e0a 1647
47d52240
RS		 1648 /* I don't understand why this ends up 0 sometimes,
1649 but it does. This kludge works around it.
1650 Can anyone find a real fix? -- rms. */
1651 if (mw->menu.font == 0)
1652 mw->menu.font = xlwmenu_default_font;
1653
07bf635f
RS		 1654 make_drawing_gcs (mw);
1655 make_shadow_gcs (mw);
5c520e0a 1656
07bf635f
RS		 1657 xswa.background_pixel = mw->core.background_pixel;
1658 xswa.border_pixel = mw->core.border_pixel;
1659 mask = CWBackPixel | CWBorderPixel;
5c520e0a 1660
07bf635f 1661 mw->menu.popped_up = False;
5c520e0a 1662
07bf635f
RS		 1663 mw->menu.old_depth = 1;
1664 mw->menu.old_stack = (widget_value**)XtMalloc (sizeof (widget_value*));
1665 mw->menu.old_stack_length = 1;
1666 mw->menu.old_stack [0] = mw->menu.contents;
5c520e0a 1667
07bf635f
RS		 1668 mw->menu.new_depth = 0;
1669 mw->menu.new_stack = 0;
1670 mw->menu.new_stack_length = 0;
1671 push_new_stack (mw, mw->menu.contents);
5c520e0a 1672
07bf635f
RS		 1673 mw->menu.windows = (window_state*)XtMalloc (sizeof (window_state));
1674 mw->menu.windows_length = 1;
1675 mw->menu.windows [0].x = 0;
1676 mw->menu.windows [0].y = 0;
1677 mw->menu.windows [0].width = 0;
1678 mw->menu.windows [0].height = 0;
1679 size_menu (mw, 0);
5c520e0a 1680
07bf635f
RS		 1681 mw->core.width = mw->menu.windows [0].width;
1682 mw->core.height = mw->menu.windows [0].height;
1683}
1684
1685static void
1686XlwMenuClassInitialize ()
1687{
1688}
1689
1690static void
d398028f
PR		 1691XlwMenuRealize (w, valueMask, attributes)
1692 Widget w;
1693 Mask *valueMask;
1694 XSetWindowAttributes *attributes;
07bf635f
RS		 1695{
1696 XlwMenuWidget mw = (XlwMenuWidget)w;
1697 XSetWindowAttributes xswa;
1698 int mask;
1699
1700 (*xlwMenuWidgetClass->core_class.superclass->core_class.realize)
1701 (w, valueMask, attributes);
1702
1703 xswa.save_under = True;
1704 xswa.cursor = mw->menu.cursor_shape;
1705 mask = CWSaveUnder | CWCursor;
1706 XChangeWindowAttributes (XtDisplay (w), XtWindow (w), mask, &xswa);
1707
1708 mw->menu.windows [0].window = XtWindow (w);
1709 mw->menu.windows [0].x = w->core.x;
1710 mw->menu.windows [0].y = w->core.y;
1711 mw->menu.windows [0].width = w->core.width;
1712 mw->menu.windows [0].height = w->core.height;
1713}
1714
1715/* Only the toplevel menubar/popup is a widget so it's the only one that
1716 receives expose events through Xt. So we repaint all the other panes
1717 when receiving an Expose event. */
5c520e0a 1718static void
d398028f
PR		 1719XlwMenuRedisplay (w, ev, region)
1720 Widget w;
1721 XEvent* ev;
1722 Region region;
07bf635f
RS		 1723{
1724 XlwMenuWidget mw = (XlwMenuWidget)w;
1725 int i;
1726
d398028f
PR		 1727 /* If we have a depth beyond 1, it's because a submenu was displayed.
1728 If the submenu has been destroyed, set the depth back to 1. */
1729 if (submenu_destroyed)
1730 {
1731 mw->menu.old_depth = 1;
1732 submenu_destroyed = 0;
1733 }
1734
07bf635f
RS		 1735 for (i = 0; i < mw->menu.old_depth; i++)
1736 display_menu (mw, i, False, NULL, NULL, NULL, NULL, NULL);
1737}
1738
f3c9e544
GM		 1739
1740/* Part of a hack to make the menu redisplay when a tooltip frame
1741 over a menu item is unmapped. */
1742
1743void
1744xlwmenu_redisplay (w)
1745 Widget w;
1746{
1747 XlwMenuRedisplay (w, NULL, None);
1748}
1749
5c520e0a 1750static void
d398028f
PR		 1751XlwMenuDestroy (w)
1752 Widget w;
07bf635f
RS		 1753{
1754 int i;
1755 XlwMenuWidget mw = (XlwMenuWidget) w;
1756
d398028f
PR		 1757 if (pointer_grabbed)
1758 XtUngrabPointer ((Widget)w, CurrentTime);
1759 pointer_grabbed = 0;
1760
1761 submenu_destroyed = 1;
1762
07bf635f
RS		 1763 release_drawing_gcs (mw);
1764 release_shadow_gcs (mw);
1765
1766 /* this doesn't come from the resource db but is created explicitly
1767 so we must free it ourselves. */
1768 XFreePixmap (XtDisplay (mw), mw->menu.gray_pixmap);
1769 mw->menu.gray_pixmap = (Pixmap) -1;
1770
d398028f
PR		 1771#if 0
1772 /* Do free mw->menu.contents because nowadays we copy it
1773 during initialization. */
1774 XtFree (mw->menu.contents);
1775#endif
1776
07bf635f
RS		 1777 /* Don't free mw->menu.contents because that comes from our creator.
1778 The `*_stack' elements are just pointers into `contents' so leave
1779 that alone too. But free the stacks themselves. */
1780 if (mw->menu.old_stack) XtFree ((char *) mw->menu.old_stack);
1781 if (mw->menu.new_stack) XtFree ((char *) mw->menu.new_stack);
1782
1783 /* Remember, you can't free anything that came from the resource
1784 database. This includes:
1785 mw->menu.cursor
1786 mw->menu.top_shadow_pixmap
1787 mw->menu.bottom_shadow_pixmap
1788 mw->menu.font
1789 Also the color cells of top_shadow_color, bottom_shadow_color,
1790 foreground, and button_foreground will never be freed until this
1791 client exits. Nice, eh?
1792 */
1793
1794 /* start from 1 because the one in slot 0 is w->core.window */
1795 for (i = 1; i < mw->menu.windows_length; i++)
1796 XDestroyWindow (XtDisplay (mw), mw->menu.windows [i].window);
1797 if (mw->menu.windows)
1798 XtFree ((char *) mw->menu.windows);
1799}
1800
5c520e0a 1801static Boolean
d398028f
PR		 1802XlwMenuSetValues (current, request, new)
1803 Widget current;
1804 Widget request;
1805 Widget new;
07bf635f
RS		 1806{
1807 XlwMenuWidget oldmw = (XlwMenuWidget)current;
1808 XlwMenuWidget newmw = (XlwMenuWidget)new;
1809 Boolean redisplay = False;
1810 int i;
1811
1812 if (newmw->menu.contents
1813 && newmw->menu.contents->contents
1814 && newmw->menu.contents->contents->change >= VISIBLE_CHANGE)
1815 redisplay = True;
ba624d0f
RS		 1816 /* Do redisplay if the contents are entirely eliminated. */
1817 if (newmw->menu.contents
1818 && newmw->menu.contents->contents == 0
1819 && newmw->menu.contents->change >= VISIBLE_CHANGE)
1820 redisplay = True;
07bf635f
RS		 1821
1822 if (newmw->core.background_pixel != oldmw->core.background_pixel
d398028f
PR		 1823 || newmw->menu.foreground != oldmw->menu.foreground
1824 || newmw->menu.font != oldmw->menu.font)
07bf635f
RS		 1825 {
1826 release_drawing_gcs (newmw);
1827 make_drawing_gcs (newmw);
90c7e9f0
MB		 1828
1829 release_shadow_gcs (newmw);
1830 /* Cause the shadow colors to be recalculated. */
1831 newmw->menu.top_shadow_color = -1;
1832 newmw->menu.bottom_shadow_color = -1;
1833 make_shadow_gcs (newmw);
1834
07bf635f 1835 redisplay = True;
5c520e0a 1836
43aa2f1b 1837 if (XtIsRealized (current))
da353f23
MB		 1838 /* If the menu is currently displayed, change the display. */
1839 for (i = 0; i < oldmw->menu.windows_length; i++)
1840 {
1841 XSetWindowBackground (XtDisplay (oldmw),
1842 oldmw->menu.windows [i].window,
1843 newmw->core.background_pixel);
1844 /* clear windows and generate expose events */
1845 XClearArea (XtDisplay (oldmw), oldmw->menu.windows[i].window,
1846 0, 0, 0, 0, True);
1847 }
07bf635f
RS		 1848 }
1849
1850 return redisplay;
1851}
1852
5c520e0a 1853static void
d398028f
PR		 1854XlwMenuResize (w)
1855 Widget w;
07bf635f
RS		 1856{
1857 XlwMenuWidget mw = (XlwMenuWidget)w;
1858
d398028f
PR		 1859 if (mw->menu.popped_up)
1860 {
1861 /* Don't allow the popup menu to resize itself. */
1862 mw->core.width = mw->menu.windows [0].width;
1863 mw->core.height = mw->menu.windows [0].height;
1864 mw->core.parent->core.width = mw->core.width ;
1865 mw->core.parent->core.height = mw->core.height ;
1866 }
1867 else
1868 {
1869 mw->menu.windows [0].width = mw->core.width;
1870 mw->menu.windows [0].height = mw->core.height;
1871 }
07bf635f
RS		 1872}
1873
1874\f/* Action procedures */
1875static void
d398028f
PR		 1876handle_single_motion_event (mw, ev)
1877 XlwMenuWidget mw;
1878 XMotionEvent* ev;
07bf635f
RS		 1879{
1880 widget_value* val;
1881 int level;
1882
1883 if (!map_event_to_widget_value (mw, ev, &val, &level))
1884 pop_new_stack_if_no_contents (mw);
1885 else
1886 set_new_state (mw, val, level);
1887 remap_menubar (mw);
5c520e0a 1888
07bf635f
RS		 1889 /* Sync with the display. Makes it feel better on X terms. */
1890 XSync (XtDisplay (mw), False);
1891}
1892
1893static void
d398028f
PR		 1894handle_motion_event (mw, ev)
1895 XlwMenuWidget mw;
1896 XMotionEvent* ev;
07bf635f
RS		 1897{
1898 int x = ev->x_root;
1899 int y = ev->y_root;
1900 int state = ev->state;
1901
1902 handle_single_motion_event (mw, ev);
1903
1904 /* allow motion events to be generated again */
1905 if (ev->is_hint
1906 && XQueryPointer (XtDisplay (mw), ev->window,
1907 &ev->root, &ev->subwindow,
1908 &ev->x_root, &ev->y_root,
1909 &ev->x, &ev->y,
1910 &ev->state)
1911 && ev->state == state
1912 && (ev->x_root != x || ev->y_root != y))
1913 handle_single_motion_event (mw, ev);
1914}
1915
5c520e0a 1916static void
d398028f
PR		 1917Start (w, ev, params, num_params)
1918 Widget w;
1919 XEvent *ev;
1920 String *params;
1921 Cardinal *num_params;
07bf635f
RS		 1922{
1923 XlwMenuWidget mw = (XlwMenuWidget)w;
1924
d398028f
PR		 1925 if (!mw->menu.popped_up)
1926 {
1927 menu_post_event = *ev;
a57a1605 1928 pop_up_menu (mw, (XButtonPressedEvent*) ev);
d398028f
PR		 1929 }
1930 else
4cc76151
PR		 1931 {
1932 /* If we push a button while the menu is posted semipermanently,
1933 releasing the button should always pop the menu down. */
1934 next_release_must_exit = 1;
d398028f 1935
4cc76151
PR		 1936 /* notes the absolute position of the menubar window */
1937 mw->menu.windows [0].x = ev->xmotion.x_root - ev->xmotion.x;
1938 mw->menu.windows [0].y = ev->xmotion.y_root - ev->xmotion.y;
07bf635f 1939
4cc76151
PR		 1940 /* handles the down like a move, slots are compatible */
1941 handle_motion_event (mw, &ev->xmotion);
1942 }
07bf635f
RS		 1943}
1944
5c520e0a 1945static void
d398028f
PR		 1946Drag (w, ev, params, num_params)
1947 Widget w;
1948 XEvent *ev;
1949 String *params;
1950 Cardinal *num_params;
07bf635f
RS		 1951{
1952 XlwMenuWidget mw = (XlwMenuWidget)w;
3c9ce1c4
KH		 1953 if (mw->menu.popped_up)
1954 handle_motion_event (mw, &ev->xmotion);
07bf635f
RS		 1955}
1956
ba624d0f
RS		 1957/* Do nothing.
1958 This is how we handle presses and releases of modifier keys. */
1959static void
1960Nothing (w, ev, params, num_params)
1961 Widget w;
1962 XEvent *ev;
1963 String *params;
1964 Cardinal *num_params;
1965{
1966}
1967
1968/* Handle key press and release events while menu is popped up.
1969 Our action is to get rid of the menu. */
1970static void
1971Key (w, ev, params, num_params)
1972 Widget w;
1973 XEvent *ev;
1974 String *params;
1975 Cardinal *num_params;
1976{
1977 XlwMenuWidget mw = (XlwMenuWidget)w;
1978
1979 /* Pop down everything. */
1980 mw->menu.new_depth = 1;
1981 remap_menubar (mw);
1982
1983 if (mw->menu.popped_up)
1984 {
1985 mw->menu.popped_up = False;
1986 XtUngrabPointer ((Widget)mw, ev->xmotion.time);
1987 if (XtIsShell (XtParent ((Widget) mw)))
1988 XtPopdown (XtParent ((Widget) mw));
1989 else
1990 {
1991 XtRemoveGrab ((Widget) mw);
1992 display_menu (mw, 0, False, NULL, NULL, NULL, NULL, NULL);
1993 }
1994 }
1995
1996 /* callback */
1997 XtCallCallbackList ((Widget)mw, mw->menu.select, (XtPointer)0);
1998}
1999
2000static void
d398028f
PR		 2001Select (w, ev, params, num_params)
2002 Widget w;
2003 XEvent *ev;
2004 String *params;
2005 Cardinal *num_params;
07bf635f
RS		 2006{
2007 XlwMenuWidget mw = (XlwMenuWidget)w;
2008 widget_value* selected_item = mw->menu.old_stack [mw->menu.old_depth - 1];
5c520e0a 2009
d398028f
PR		 2010 /* If user releases the button quickly, without selecting anything,
2011 after the initial down-click that brought the menu up,
2012 do nothing. */
2013 if ((selected_item == 0
2014 || ((widget_value *) selected_item)->call_data == 0)
2015 && !next_release_must_exit
2016 && (ev->xbutton.time - menu_post_event.xbutton.time
2017 < XtGetMultiClickTime (XtDisplay (w))))
2018 return;
2019
2020 /* pop down everything. */
07bf635f
RS		 2021 mw->menu.new_depth = 1;
2022 remap_menubar (mw);
2023
2024 if (mw->menu.popped_up)
2025 {
2026 mw->menu.popped_up = False;
2027 XtUngrabPointer ((Widget)mw, ev->xmotion.time);
2289f3f4
PR		 2028 if (XtIsShell (XtParent ((Widget) mw)))
2029 XtPopdown (XtParent ((Widget) mw));
4cc76151
PR		 2030 else
2031 {
2032 XtRemoveGrab ((Widget) mw);
2033 display_menu (mw, 0, False, NULL, NULL, NULL, NULL, NULL);
2034 }
07bf635f
RS		 2035 }
2036
2037 /* callback */
2038 XtCallCallbackList ((Widget)mw, mw->menu.select, (XtPointer)selected_item);
07bf635f
RS		 2039}
2040
2041
2042\f/* Special code to pop-up a menu */
2043void
d398028f
PR		 2044pop_up_menu (mw, event)
2045 XlwMenuWidget mw;
2046 XButtonPressedEvent* event;
07bf635f
RS		 2047{
2048 int x = event->x_root;
2049 int y = event->y_root;
2050 int w;
2051 int h;
2052 int borderwidth = mw->menu.shadow_thickness;
2053 Screen* screen = XtScreen (mw);
8400b9ed 2054 Display *display = XtDisplay (mw);
5efb61c7 2055 int count;
07bf635f 2056
d398028f
PR		 2057 next_release_must_exit = 0;
2058
07bf635f
RS		 2059 XtCallCallbackList ((Widget)mw, mw->menu.open, NULL);
2060
2289f3f4 2061 if (XtIsShell (XtParent ((Widget)mw)))
4cc76151 2062 size_menu (mw, 0);
07bf635f
RS		 2063
2064 w = mw->menu.windows [0].width;
2065 h = mw->menu.windows [0].height;
2066
2067 x -= borderwidth;
2068 y -= borderwidth;
2069 if (x < borderwidth)
2070 x = borderwidth;
2071 if (x + w + 2 * borderwidth > WidthOfScreen (screen))
2072 x = WidthOfScreen (screen) - w - 2 * borderwidth;
2073 if (y < borderwidth)
2074 y = borderwidth;
2075 if (y + h + 2 * borderwidth> HeightOfScreen (screen))
2076 y = HeightOfScreen (screen) - h - 2 * borderwidth;
2077
2078 mw->menu.popped_up = True;
2289f3f4 2079 if (XtIsShell (XtParent ((Widget)mw)))
4cc76151 2080 {
2289f3f4
PR		 2081 XtConfigureWidget (XtParent ((Widget)mw), x, y, w, h,
2082 XtParent ((Widget)mw)->core.border_width);
2083 XtPopup (XtParent ((Widget)mw), XtGrabExclusive);
4cc76151
PR		 2084 display_menu (mw, 0, False, NULL, NULL, NULL, NULL, NULL);
2085 mw->menu.windows [0].x = x + borderwidth;
2086 mw->menu.windows [0].y = y + borderwidth;
2087 }
2088 else
2089 {
2090 XEvent *ev = (XEvent *) event;
2091
87a559bf 2092 XtAddGrab ((Widget) mw, True, True);
4cc76151
PR		 2093
2094 /* notes the absolute position of the menubar window */
2095 mw->menu.windows [0].x = ev->xmotion.x_root - ev->xmotion.x;
2096 mw->menu.windows [0].y = ev->xmotion.y_root - ev->xmotion.y;
2097 }
2098
d398028f 2099#ifdef emacs
5efb61c7 2100 count = x_catch_errors (display);
d398028f 2101#endif
87a559bf
PR		 2102 XtGrabPointer ((Widget)mw, False,
2103 (PointerMotionMask
2104 | PointerMotionHintMask
2105 | ButtonReleaseMask
2106 | ButtonPressMask),
2107 GrabModeAsync, GrabModeAsync, None,
2108 mw->menu.cursor_shape,
2109 event->time);
2110 pointer_grabbed = 1;
d398028f 2111#ifdef emacs
8400b9ed 2112 if (x_had_errors_p (display))
d398028f
PR		 2113 {
2114 pointer_grabbed = 0;
2115 XtUngrabPointer ((Widget)mw, event->time);
2116 }
5efb61c7 2117 x_uncatch_errors (display, count);
d398028f 2118#endif
07bf635f 2119
07bf635f
RS		 2120 handle_motion_event (mw, (XMotionEvent*)event);
2121}
Unnamed repository; edit this file 'description' to name the repository.