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