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