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