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