Debian Codegraph @

src/SimpleMenu.c

raw
1 /*
2 Copyright 1989, 1994, 1998 The Open Group
3
4 Permission to use, copy, modify, distribute, and sell this software and its
5 documentation for any purpose is hereby granted without fee, provided that
6 the above copyright notice appear in all copies and that both that
7 copyright notice and this permission notice appear in supporting
8 documentation.
9
10 The above copyright notice and this permission notice shall be included in
11 all copies or substantial portions of the Software.
12
13 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
17 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
18 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
19
20 Except as contained in this notice, the name of The Open Group shall not be
21 used in advertising or otherwise to promote the sale, use or other dealings
22 in this Software without prior written authorization from The Open Group.
23 */
24
25 /*
26 * SimpleMenu.c - Source code file for SimpleMenu widget.
27 *
28 * Date: April 3, 1989
29 *
30 * By: Chris D. Peterson
31 * MIT X Consortium
32 * [email protected]
33 */
34
35 #ifdef HAVE_CONFIG_H
36 #include <config.h>
37 #endif
38 #include <stdio.h>
39 #include <X11/IntrinsicP.h>
40 #include <X11/StringDefs.h>
41 #include <X11/Xmu/Initer.h>
42 #include <X11/Xaw/Cardinals.h>
43 #include <X11/Xaw/SimpleMenP.h>
44 #include <X11/Xaw/SmeBSBP.h>
45 #include <X11/Xaw/XawInit.h>
46 #include "Private.h"
47
48 #define streq(a, b) (strcmp((a), (b)) == 0)
49
50 #define ForAllChildren(smw, childP) \
51 for ((childP) = (SmeObject *)(smw)->composite.children; \
52 (childP) < (SmeObject *)((smw)->composite.children \
53 + (smw)->composite.num_children); \
54 (childP)++)
55
56 #ifndef OLDXAW
57 #define SMW_UNMAPPING 0x01
58 #define SMW_POPLEFT 0x02
59 #endif
60
61 /*
62 * Class Methods
63 */
64 static void XawSimpleMenuChangeManaged(Widget);
65 static void XawSimpleMenuClassInitialize(void);
66 static void XawSimpleMenuClassPartInitialize(WidgetClass);
67 static XtGeometryResult XawSimpleMenuGeometryManager(Widget, XtWidgetGeometry*,
68 XtWidgetGeometry*);
69 static void XawSimpleMenuInitialize(Widget, Widget, ArgList, Cardinal*);
70 static void XawSimpleMenuRealize(Widget, XtValueMask*, XSetWindowAttributes*);
71 static void XawSimpleMenuRedisplay(Widget, XEvent*, Region);
72 static void XawSimpleMenuResize(Widget);
73 static Boolean XawSimpleMenuSetValues(Widget, Widget, Widget,
74 ArgList, Cardinal*);
75 static Boolean XawSimpleMenuSetValuesHook(Widget, ArgList, Cardinal*);
76 #ifndef OLDXAW
77 static void PopupSubMenu(SimpleMenuWidget);
78 static void PopdownSubMenu(SimpleMenuWidget);
79 static void PopupCB(Widget, XtPointer, XtPointer);
80 #endif
81
82 /*
83 * Prototypes
84 */
85 static void AddPositionAction(XtAppContext, XPointer);
86 static void CalculateNewSize(Widget, Dimension*, Dimension*);
87 static void ChangeCursorOnGrab(Widget, XtPointer, XtPointer);
88 static void CreateLabel(Widget);
89 static SmeObject DoGetEventEntry(Widget, int, int);
90 static Widget FindMenu(Widget, String);
91 static SmeObject GetEventEntry(Widget, XEvent*);
92 static void Layout(Widget, Dimension*, Dimension*);
93 static void MakeResizeRequest(Widget);
94 static void MakeSetValuesRequest(Widget, unsigned int, unsigned int);
95 static void MoveMenu(Widget, int, int);
96 static void PositionMenu(Widget, XPoint*);
97
98 /*
99 * Actions
100 */
101 static void Highlight(Widget, XEvent*, String*, Cardinal*);
102 static void Notify(Widget, XEvent*, String*, Cardinal*);
103 #ifndef OLDXAW
104 static void Popdown(Widget, XEvent*, String*, Cardinal*);
105 #endif
106 static void PositionMenuAction(Widget, XEvent*, String*, Cardinal*);
107 static void Unhighlight(Widget, XEvent*, String*, Cardinal*);
108
109 /*
110 * Initialization
111 */
112 #define offset(field) XtOffsetOf(SimpleMenuRec, simple_menu.field)
113
114 static XtResource resources[] = {
115 /* label */
116 {
117 XtNlabel,
118 XtCLabel,
119 XtRString,
120 sizeof(String),
121 offset(label_string),
122 XtRString,
123 NULL
124 },
125 {
126 XtNlabelClass,
127 XtCLabelClass,
128 XtRPointer,
129 sizeof(WidgetClass),
130 offset(label_class),
131 XtRImmediate,
132 NULL
133 },
134
135 /* layout */
136 {
137 XtNrowHeight,
138 XtCRowHeight,
139 XtRDimension,
140 sizeof(Dimension),
141 offset(row_height),
142 XtRImmediate,
143 (XtPointer)0
144 },
145 {
146 XtNtopMargin,
147 XtCVerticalMargins,
148 XtRDimension,
149 sizeof(Dimension),
150 offset(top_margin),
151 XtRImmediate,
152 (XtPointer)0
153 },
154 {
155 XtNbottomMargin,
156 XtCVerticalMargins,
157 XtRDimension,
158 sizeof(Dimension),
159 offset(bottom_margin),
160 XtRImmediate,
161 (XtPointer)0
162 },
163 #ifndef OLDXAW
164 {
165 XtNleftMargin,
166 XtCHorizontalMargins,
167 XtRDimension,
168 sizeof(Dimension),
169 offset(left_margin),
170 XtRImmediate,
171 (XtPointer)0
172 },
173 {
174 XtNrightMargin,
175 XtCHorizontalMargins,
176 XtRDimension,
177 sizeof(Dimension),
178 offset(right_margin),
179 XtRImmediate,
180 (XtPointer)0
181 },
182 #endif
183
184 /* misc */
185 {
186 XtNallowShellResize,
187 XtCAllowShellResize,
188 XtRBoolean,
189 sizeof(Boolean),
190 XtOffsetOf(SimpleMenuRec, shell.allow_shell_resize),
191 XtRImmediate,
192 (XtPointer)True
193 },
194 {
195 XtNcursor,
196 XtCCursor,
197 XtRCursor,
198 sizeof(Cursor),
199 offset(cursor),
200 XtRImmediate,
201 (XtPointer)None
202 },
203 {
204 XtNmenuOnScreen,
205 XtCMenuOnScreen,
206 XtRBoolean,
207 sizeof(Boolean),
208 offset(menu_on_screen),
209 XtRImmediate,
210 (XtPointer)True
211 },
212 {
213 XtNpopupOnEntry,
214 XtCPopupOnEntry,
215 XtRWidget,
216 sizeof(Widget),
217 offset(popup_entry),
218 XtRWidget,
219 NULL
220 },
221 {
222 XtNbackingStore,
223 XtCBackingStore,
224 XtRBackingStore,
225 sizeof(int),
226 offset(backing_store),
227 XtRImmediate,
228 (XtPointer)(Always + WhenMapped + NotUseful)
229 },
230 #ifndef OLDXAW
231 {
232 XawNdisplayList,
233 XawCDisplayList,
234 XawRDisplayList,
235 sizeof(XawDisplayList*),
236 offset(display_list),
237 XtRImmediate,
238 NULL
239 },
240 #endif
241 };
242 #undef offset
243
244 static char defaultTranslations[] =
245 "<Enter>:" "highlight()\n"
246 "<Leave>:" "unhighlight()\n"
247 "<BtnMotion>:" "highlight()\n"
248 #ifndef OLDXAW
249 "<BtnUp>:" "popdown() notify() unhighlight()\n"
250 #else
251 "<BtnUp>:" "MenuPopdown() notify() unhighlight()\n"
252 #endif
253 ;
254
255 static XtActionsRec actionsList[] =
256 {
257 {"notify", Notify},
258 {"highlight", Highlight},
259 {"unhighlight", Unhighlight},
260 #ifndef OLDXAW
261 {"popdown", Popdown},
262 {"set-values", XawSetValuesAction},
263 {"get-values", XawGetValuesAction},
264 {"declare", XawDeclareAction},
265 {"call-proc", XawCallProcAction},
266 #endif
267 };
268
269 static CompositeClassExtensionRec extension_rec = {
270 NULL, /* next_extension */
271 NULLQUARK, /* record_type */
272 XtCompositeExtensionVersion, /* version */
273 sizeof(CompositeClassExtensionRec), /* record_size */
274 True, /* accepts_objects */
275 #ifndef OLDXAW
276 False, /* allows_change_managed_set */
277 #endif
278 };
279
280 #define Superclass (&overrideShellClassRec)
281 SimpleMenuClassRec simpleMenuClassRec = {
282 /* core */
283 {
284 (WidgetClass)Superclass, /* superclass */
285 "SimpleMenu", /* class_name */
286 sizeof(SimpleMenuRec), /* size */
287 XawSimpleMenuClassInitialize, /* class_initialize */
288 XawSimpleMenuClassPartInitialize, /* class_part_initialize */
289 False, /* class_inited */
290 XawSimpleMenuInitialize, /* initialize */
291 NULL, /* initialize_hook */
292 XawSimpleMenuRealize, /* realize */
293 actionsList, /* actions */
294 XtNumber(actionsList), /* num_actions */
295 resources, /* resources */
296 XtNumber(resources), /* num_resources */
297 NULLQUARK, /* xrm_class */
298 True, /* compress_motion */
299 True, /* compress_exposure */
300 True, /* compress_enterleave */
301 False, /* visible_interest */
302 NULL, /* destroy */
303 XawSimpleMenuResize, /* resize */
304 XawSimpleMenuRedisplay, /* expose */
305 XawSimpleMenuSetValues, /* set_values */
306 XawSimpleMenuSetValuesHook, /* set_values_hook */
307 XtInheritSetValuesAlmost, /* set_values_almost */
308 NULL, /* get_values_hook */
309 NULL, /* accept_focus */
310 XtVersion, /* intrinsics version */
311 NULL, /* callback offsets */
312 defaultTranslations, /* tm_table */
313 NULL, /* query_geometry */
314 NULL, /* display_accelerator */
315 NULL, /* extension */
316 },
317 /* composite */
318 {
319 XawSimpleMenuGeometryManager, /* geometry_manager */
320 XawSimpleMenuChangeManaged, /* change_managed */
321 XtInheritInsertChild, /* insert_child */
322 XtInheritDeleteChild, /* delete_child */
323 NULL, /* extension */
324 },
325 /* shell */
326 {
327 NULL, /* extension */
328 },
329 /* override */
330 {
331 NULL, /* extension */
332 },
333 /* simple_menu */
334 {
335 NULL, /* extension */
336 },
337 };
338
339 WidgetClass simpleMenuWidgetClass = (WidgetClass)&simpleMenuClassRec;
340
341 /*
342 * Implementation
343 */
344 /*
345 * Function:
346 * XawSimpleMenuClassInitialize
347 *
348 * Description:
349 * Class Initialize routine, called only once.
350 */
351 static void
352 XawSimpleMenuClassInitialize(void)
353 {
354 XawInitializeWidgetSet();
355 XtAddConverter(XtRString, XtRBackingStore, XmuCvtStringToBackingStore,
356 NULL, 0);
357 XtSetTypeConverter(XtRBackingStore, XtRString, XmuCvtBackingStoreToString,
358 NULL, 0, XtCacheNone, NULL);
359 XmuAddInitializer(AddPositionAction, NULL);
360 }
361
362 /*
363 * Function:
364 * XawSimpleMenuClassPartInitialize
365 * Arguments: wc - the widget class of the subclass.
366 *
367 * Description:
368 * Class Part Initialize routine, called for every subclass. Makes
369 * sure that the subclasses pick up the extension record.
370 */
371 static void
372 XawSimpleMenuClassPartInitialize(WidgetClass wc)
373 {
374 SimpleMenuWidgetClass smwc = (SimpleMenuWidgetClass)wc;
375
376 /*
377 * Make sure that our subclass gets the extension rec too
378 */
379 extension_rec.next_extension = smwc->composite_class.extension;
380 smwc->composite_class.extension = (XtPointer) &extension_rec;
381 }
382
383 /*
384 * Function:
385 * XawSimpleMenuInitialize
386 *
387 * Parameters:
388 * request - widget requested by the argument list
389 * cnew - new widget with both resource and non resource values
390 *
391 * Description:
392 * Initializes the simple menu widget.
393 */
394 /*ARGSUSED*/
395 static void
396 XawSimpleMenuInitialize(Widget request _X_UNUSED, Widget cnew,
397 ArgList args _X_UNUSED, Cardinal *num_args _X_UNUSED)
398 {
399 SimpleMenuWidget smw = (SimpleMenuWidget)cnew;
400 Dimension width, height;
401
402 XmuCallInitializers(XtWidgetToApplicationContext(cnew));
403
404 if (smw->simple_menu.label_class == NULL)
405 smw->simple_menu.label_class = smeBSBObjectClass;
406
407 smw->simple_menu.label = NULL;
408 smw->simple_menu.entry_set = NULL;
409 smw->simple_menu.recursive_set_values = False;
410 #ifndef OLDXAW
411 smw->simple_menu.sub_menu = NULL;
412 smw->simple_menu.state = 0;
413
414 XtAddCallback(cnew, XtNpopupCallback, PopupCB, NULL);
415 #endif
416
417 if (smw->simple_menu.label_string != NULL)
418 CreateLabel(cnew);
419
420 width = height = 0;
421 CalculateNewSize(cnew, &width, &height);
422
423 smw->simple_menu.menu_width = True;
424
425 if (XtWidth(smw) == 0) {
426 smw->simple_menu.menu_width = False;
427 XtWidth(smw) = width;
428 }
429
430 smw->simple_menu.menu_height = True;
431
432 if (XtHeight(smw) == 0) {
433 smw->simple_menu.menu_height = False;
434 XtHeight(smw) = height;
435 }
436
437 /*
438 * Add a popup_callback routine for changing the cursor
439 */
440 XtAddCallback(cnew, XtNpopupCallback, ChangeCursorOnGrab, NULL);
441 }
442
443 /*
444 * Function:
445 * XawSimpleMenuRedisplay
446 *
447 * Parameters:
448 * w - simple menu widget
449 * event - X event that caused this redisplay
450 * region - region the needs to be repainted
451 *
452 * Description:
453 * Redisplays the contents of the widget.
454 */
455 /*ARGSUSED*/
456 static void
457 XawSimpleMenuRedisplay(Widget w, XEvent *event _X_UNUSED, Region region)
458 {
459 SimpleMenuWidget smw = (SimpleMenuWidget)w;
460 SmeObject *entry;
461 SmeObjectClass cclass;
462
463 if (region == NULL)
464 XClearWindow(XtDisplay(w), XtWindow(w));
465
466 #ifndef OLDXAW
467 if (smw->simple_menu.display_list)
468 XawRunDisplayList(w, smw->simple_menu.display_list, event, region);
469 #endif
470
471 /*
472 * Check and Paint each of the entries - including the label
473 */
474 ForAllChildren(smw, entry) {
475 if (!XtIsManaged((Widget)*entry))
476 continue;
477
478 if (region != NULL)
479 switch(XRectInRegion(region, XtX(*entry),XtY(*entry),
480 XtWidth(*entry), XtHeight(*entry))) {
481 case RectangleIn:
482 case RectanglePart:
483 break;
484 default:
485 continue;
486 }
487
488 cclass = (SmeObjectClass)(*entry)->object.widget_class;
489
490 if (cclass->rect_class.expose != NULL)
491 (cclass->rect_class.expose)((Widget)*entry, NULL, NULL);
492 }
493 }
494
495 /*
496 * Function:
497 * XawSimpleMenuRealize
498 *
499 * Parameters:
500 * w - simple menu widget
501 * mask - value mask for the window to create
502 * attrs - attributes for the window to create
503 *
504 * Description:
505 * Realizes the widget.
506 */
507 static void
508 XawSimpleMenuRealize(Widget w, XtValueMask *mask, XSetWindowAttributes *attrs)
509 {
510 SimpleMenuWidget smw = (SimpleMenuWidget)w;
511 #ifndef OLDXAW
512 XawPixmap *pixmap;
513 #endif
514
515 attrs->cursor = smw->simple_menu.cursor;
516 *mask |= CWCursor;
517 if (smw->simple_menu.backing_store == Always ||
518 smw->simple_menu.backing_store == NotUseful ||
519 smw->simple_menu.backing_store == WhenMapped) {
520 *mask |= CWBackingStore;
521 attrs->backing_store = smw->simple_menu.backing_store;
522 }
523 else
524 *mask &= (XtValueMask)(~CWBackingStore);
525
526 (*Superclass->core_class.realize)(w, mask, attrs);
527
528 #ifndef OLDXAW
529 if (w->core.background_pixmap > XtUnspecifiedPixmap) {
530 pixmap = XawPixmapFromXPixmap(w->core.background_pixmap, XtScreen(w),
531 w->core.colormap, (int)w->core.depth);
532 if (pixmap && pixmap->mask)
533 XawReshapeWidget(w, pixmap);
534 }
535 #endif
536 }
537
538 /*
539 * Function:
540 * XawSimpleMenuResize
541 *
542 * Parameters:
543 * w - simple menu widget
544 *
545 * Description:
546 * Handle the menu being resized.
547 */
548 static void
549 XawSimpleMenuResize(Widget w)
550 {
551 if (!XtIsRealized(w))
552 return;
553
554 Layout(w, NULL, NULL);
555
556 XawSimpleMenuRedisplay(w, NULL, NULL);
557 }
558
559 /*
560 * Function:
561 * XawSimpleMenuSetValues
562 *
563 * Parameters:
564 * current - current state of the widget
565 * request - what was requested
566 * cnew - what the widget will become
567 *
568 * Description:
569 * Relayout the menu when one of the resources is changed.
570 */
571 /*ARGSUSED*/
572 static Boolean
573 XawSimpleMenuSetValues(Widget current, Widget request _X_UNUSED, Widget cnew,
574 ArgList args _X_UNUSED, Cardinal *num_args _X_UNUSED)
575 {
576 SimpleMenuWidget smw_old = (SimpleMenuWidget)current;
577 SimpleMenuWidget smw_new = (SimpleMenuWidget)cnew;
578 Boolean ret_val = False, layout = False;
579
580 if (!XtIsRealized(current))
581 return (False);
582
583 if (!smw_new->simple_menu.recursive_set_values) {
584 if (XtWidth(smw_new) != XtWidth(smw_old)) {
585 smw_new->simple_menu.menu_width = XtWidth(smw_new) != 0;
586 layout = True;
587 }
588 if (XtHeight(smw_new) != XtHeight(smw_old)) {
589 smw_new->simple_menu.menu_height = XtHeight(smw_new) != 0;
590 layout = True;
591 }
592 }
593
594 if (smw_old->simple_menu.cursor != smw_new->simple_menu.cursor)
595 XDefineCursor(XtDisplay(cnew), XtWindow(cnew),
596 smw_new->simple_menu.cursor);
597
598 if (smw_old->simple_menu.label_string !=smw_new->simple_menu.label_string) {
599 if (smw_new->simple_menu.label_string == NULL) /* Destroy */
600 XtDestroyWidget((Widget)smw_old->simple_menu.label);
601 else if (smw_old->simple_menu.label_string == NULL) /* Create */
602 CreateLabel(cnew);
603 else { /* Change */
604 Arg arglist[1];
605
606 XtSetArg(arglist[0], XtNlabel, smw_new->simple_menu.label_string);
607 XtSetValues((Widget)smw_new->simple_menu.label, arglist, ONE);
608 }
609 }
610
611 if (smw_old->simple_menu.label_class != smw_new->simple_menu.label_class)
612 XtAppWarning(XtWidgetToApplicationContext(cnew),
613 "No Dynamic class change of the SimpleMenu Label.");
614
615 if (smw_old->simple_menu.top_margin != smw_new->simple_menu.top_margin
616 || smw_old->simple_menu.bottom_margin
617 != smw_new->simple_menu.bottom_margin) {
618 layout = True;
619 ret_val = True;
620 }
621
622 #ifndef OLDXAW
623 if (smw_old->core.background_pixmap != smw_new->core.background_pixmap) {
624 XawPixmap *opix, *npix;
625
626 opix = XawPixmapFromXPixmap(smw_old->core.background_pixmap,
627 XtScreen(smw_old), smw_old->core.colormap,
628 (int)smw_old->core.depth);
629 npix = XawPixmapFromXPixmap(smw_new->core.background_pixmap,
630 XtScreen(smw_new), smw_new->core.colormap,
631 (int)smw_new->core.depth);
632 if ((npix && npix->mask) || (opix && opix->mask))
633 XawReshapeWidget(cnew, npix);
634 }
635 #endif
636
637 if (layout)
638 Layout(cnew, NULL, NULL);
639
640 return (ret_val);
641 }
642
643 /*
644 * Function:
645 * XawSimpleMenuSetValuesHook
646 *
647 * Parameters:
648 * w - menu widget
649 * arglist - argument list passed to XtSetValues
650 * num_args - number of args
651 *
652 * Description:
653 * To handle a special case, this is passed the actual arguments.
654 */
655 static Boolean
656 XawSimpleMenuSetValuesHook(Widget w, ArgList arglist, Cardinal *num_args)
657 {
658 Cardinal i;
659 Dimension width, height;
660
661 width = XtWidth(w);
662 height = XtHeight(w);
663
664 for (i = 0 ; i < *num_args ; i++) {
665 if (streq(arglist[i].name, XtNwidth))
666 width = (Dimension)arglist[i].value;
667 if (streq(arglist[i].name, XtNheight))
668 height = (Dimension) arglist[i].value;
669 }
670
671 if (width != XtWidth(w) || height != XtHeight(w))
672 MakeSetValuesRequest(w, width, height);
673
674 return (False);
675 }
676
677 /*
678 * Geometry Management routines
679 */
680 /*
681 * Function:
682 * XawSimpleMenuGeometryManager
683 *
684 * Parameters:
685 * w - Menu Entry making the request
686 * request - requested new geometry
687 * reply - the allowed geometry.
688 *
689 * Description:
690 * This is the SimpleMenu Widget's Geometry Manager.
691 *
692 * Returns:
693 * XtGeometry{Yes, No, Almost}
694 */
695 static XtGeometryResult
696 XawSimpleMenuGeometryManager(Widget w, XtWidgetGeometry *request,
697 XtWidgetGeometry *reply)
698 {
699 SimpleMenuWidget smw = (SimpleMenuWidget)XtParent(w);
700 SmeObject entry = (SmeObject)w;
701 XtGeometryMask mode = request->request_mode;
702 XtGeometryResult answer;
703 Dimension old_height, old_width;
704
705 if (!(mode & CWWidth) && !(mode & CWHeight))
706 return (XtGeometryNo);
707
708 reply->width = request->width;
709 reply->height = request->height;
710
711 old_width = XtWidth(entry);
712 old_height = XtHeight(entry);
713
714 Layout(w, &reply->width, &reply->height);
715
716 /*
717 * Since we are an override shell and have no parent there is no one to
718 * ask to see if this geom change is okay, so I am just going to assume
719 * we can do whatever we want. If you subclass be very careful with this
720 * assumption, it could bite you.
721 *
722 * Chris D. Peterson - Sept. 1989.
723 */
724 if ((!(mode & CWWidth) || reply->width == request->width)
725 && (!(mode & CWHeight) || reply->height == request->height)) {
726 if (mode & XtCWQueryOnly) { /* Actually perform the layout */
727 XtWidth(entry) = old_width;
728 XtHeight(entry) = old_height;
729 }
730 else
731 Layout((Widget)smw, NULL, NULL);
732 answer = XtGeometryDone;
733 }
734 else {
735 XtWidth(entry) = old_width;
736 XtHeight(entry) = old_height;
737
738 if ((reply->width == request->width && !(mode & CWHeight))
739 || (reply->height == request->height && !(mode & CWWidth))
740 || (reply->width == request->width
741 && reply->height == request->height))
742 answer = XtGeometryNo;
743 else {
744 answer = XtGeometryAlmost;
745 reply->request_mode = 0;
746 if (reply->width != request->width)
747 reply->request_mode |= CWWidth;
748 if (reply->height != request->height)
749 reply->request_mode |= CWHeight;
750 }
751 }
752
753 return (answer);
754 }
755
756 /*
757 * Function:
758 * XawSimpleMenuChangeManaged
759 *
760 * Parameters:
761 * w - simple menu widget
762 *
763 * Description:
764 * Called whenever a new child is managed.
765 */
766 static void
767 XawSimpleMenuChangeManaged(Widget w)
768 {
769 Layout(w, NULL, NULL);
770 }
771
772 /*
773 * Global Action Routines
774 *
775 * These actions routines will be added to the application's
776 * global action list
777 */
778 /*
779 * Function:
780 * PositionMenuAction
781 *
782 * Parameters:
783 * w - a widget (no the simple menu widget)
784 * event - the event that caused this action
785 * params - parameters passed to the routine.
786 * we expect the name of the menu here.
787 * num_params - ""
788 *
789 * Description:
790 * Positions the simple menu widget.
791 */
792 /*ARGSUSED*/
793 static void
794 PositionMenuAction(Widget w, XEvent *event,
795 String *params, Cardinal *num_params)
796 {
797 Widget menu;
798 XPoint loc;
799
800 if (*num_params != 1) {
801 XtAppWarning(XtWidgetToApplicationContext(w),
802 "SimpleMenuWidget: position menu action expects "
803 "only one parameter which is the name of the menu.");
804 return;
805 }
806
807 if ((menu = FindMenu(w, params[0])) == NULL) {
808 char error_buf[BUFSIZ];
809
810 snprintf(error_buf, sizeof(error_buf),
811 "SimpleMenuWidget: could not find menu named %s.",
812 params[0]);
813 XtAppWarning(XtWidgetToApplicationContext(w), error_buf);
814 return;
815 }
816
817 switch (event->type) {
818 case ButtonPress:
819 case ButtonRelease:
820 loc.x = (short)event->xbutton.x_root;
821 loc.y = (short)event->xbutton.y_root;
822 PositionMenu(menu, &loc);
823 break;
824 case EnterNotify:
825 case LeaveNotify:
826 loc.x = (short)event->xcrossing.x_root;
827 loc.y = (short)event->xcrossing.y_root;
828 PositionMenu(menu, &loc);
829 break;
830 case MotionNotify:
831 loc.x = (short)event->xmotion.x_root;
832 loc.y = (short)event->xmotion.y_root;
833 PositionMenu(menu, &loc);
834 break;
835 default:
836 PositionMenu(menu, NULL);
837 break;
838 }
839 }
840
841 /*
842 * Widget Action Routines
843 */
844 /*
845 * Function:
846 * Unhighlight
847 *
848 * Parameters:
849 * w - simple menu widget
850 * event - event that caused this action
851 * params - not used
852 * num_params - ""
853 *
854 * Description:
855 * Unhighlights current entry.
856 */
857 /*ARGSUSED*/
858 static void
859 Unhighlight(Widget w, XEvent *event _X_UNUSED, String *params _X_UNUSED, Cardinal *num_params _X_UNUSED)
860 {
861 SimpleMenuWidget smw = (SimpleMenuWidget)w;
862 SmeObject entry = smw->simple_menu.entry_set;
863
864 if (entry == NULL)
865 return;
866
867 #ifndef OLDXAW
868 if (!smw->simple_menu.sub_menu)
869 #endif
870 {
871 SmeObjectClass cclass;
872
873 smw->simple_menu.entry_set = NULL;
874 cclass = (SmeObjectClass)entry->object.widget_class;
875 (cclass->sme_class.unhighlight)((Widget)entry);
876 }
877 }
878
879 /*
880 * Function:
881 * Highlight
882 *
883 * Parameters:
884 * w - simple menu widget
885 * event - event that caused this action
886 * params - not used
887 * num_params - ""
888 *
889 * Description:
890 * Highlights current entry.
891 */
892 /*ARGSUSED*/
893 static void
894 Highlight(Widget w, XEvent *event, String *params, Cardinal *num_params)
895 {
896 SimpleMenuWidget smw = (SimpleMenuWidget)w;
897 SmeObject entry;
898
899 if (!XtIsSensitive(w))
900 return;
901
902 entry = GetEventEntry(w, event);
903
904 if (entry == smw->simple_menu.entry_set)
905 return;
906
907 #ifndef OLDXAW
908 if (!smw->simple_menu.sub_menu)
909 #endif
910 Unhighlight(w, event, params, num_params);
911
912 if (entry == NULL)
913 return;
914
915 if (!XtIsSensitive((Widget)entry))
916 return;
917
918 #ifndef OLDXAW
919 if (smw->simple_menu.sub_menu)
920 PopdownSubMenu(smw);
921 #endif
922
923 Unhighlight(w, event, params, num_params);
924
925 #ifndef OLDXAW
926 if (!(smw->simple_menu.state & SMW_UNMAPPING))
927 #endif
928 {
929 SmeObjectClass cclass;
930
931 smw->simple_menu.entry_set = entry;
932 cclass = (SmeObjectClass)entry->object.widget_class;
933
934 (cclass->sme_class.highlight)((Widget)entry);
935
936 #ifndef OLDXAW
937 if (XtIsSubclass((Widget)entry, smeBSBObjectClass))
938 PopupSubMenu(smw);
939 #endif
940 }
941 }
942
943 /*
944 * Function:
945 * Notify
946 *
947 * Parameters:
948 * w - simple menu widget
949 * event - event that caused this action
950 * params - not used
951 * num_params - ""
952 *
953 * Description:
954 * Notify user of current entry.
955 */
956 /*ARGSUSED*/
957 static void
958 Notify(Widget w, XEvent *event, String *params _X_UNUSED, Cardinal *num_params _X_UNUSED)
959 {
960 SmeObject entry;
961 SmeObjectClass cclass;
962
963 /* may be a propagated event from a sub menu, need to check it */
964 if (XtWindow(w) != event->xany.window)
965 return;
966 entry = GetEventEntry(w, event);
967 if (entry == NULL || !XtIsSensitive((Widget)entry))
968 return;
969
970 cclass = (SmeObjectClass) entry->object.widget_class;
971 (cclass->sme_class.notify)((Widget)entry);
972 }
973
974 /*
975 * Public Functions
976 */
977 /*
978 * Function:
979 * XawSimpleMenuAddGlobalActions
980 *
981 * Arguments:
982 * app_con - appcontext
983 *
984 * Description:
985 * Adds the global actions to the simple menu widget.
986 */
987 void
988 XawSimpleMenuAddGlobalActions(XtAppContext app_con)
989 {
990 XtInitializeWidgetClass(simpleMenuWidgetClass);
991 XmuCallInitializers(app_con);
992 }
993
994 /*
995 * Function:
996 * XawSimpleMenuGetActiveEntry
997 *
998 * Parameters:
999 * w - smw widget
1000 *
1001 * Description:
1002 * Gets the currently active (set) entry.
1003 *
1004 * Returns:
1005 * The currently set entry or NULL if none is set
1006 */
1007 Widget
1008 XawSimpleMenuGetActiveEntry(Widget w)
1009 {
1010 SimpleMenuWidget smw = (SimpleMenuWidget)w;
1011
1012 return ((Widget)smw->simple_menu.entry_set);
1013 }
1014
1015 /*
1016 * Function:
1017 * XawSimpleMenuClearActiveEntry
1018 *
1019 * Parameters:
1020 * w - smw widget
1021 *
1022 * Description:
1023 * Unsets the currently active (set) entry.
1024 */
1025 void
1026 XawSimpleMenuClearActiveEntry(Widget w)
1027 {
1028 SimpleMenuWidget smw = (SimpleMenuWidget)w;
1029
1030 smw->simple_menu.entry_set = NULL;
1031 }
1032
1033 /*
1034 * Private Functions
1035 */
1036 /*
1037 * Function:
1038 * CreateLabel
1039 *
1040 * Parameters:
1041 * w - smw widget
1042 *
1043 * Description:
1044 * Creates the label object and makes sure it is the first child in
1045 * in the list.
1046 */
1047 static void
1048 CreateLabel(Widget w)
1049 {
1050 SimpleMenuWidget smw = (SimpleMenuWidget)w;
1051 Widget *child, *next_child;
1052 int i;
1053 Arg args[2];
1054
1055 if (smw->simple_menu.label_string == NULL ||
1056 smw->simple_menu.label != NULL) {
1057 XtAppWarning(XtWidgetToApplicationContext(w),
1058 "Xaw Simple Menu Widget: label string is NULL or "
1059 "label already exists, no label is being created.");
1060 return;
1061 }
1062
1063 XtSetArg(args[0], XtNlabel, smw->simple_menu.label_string);
1064 XtSetArg(args[1], XtNjustify, XtJustifyCenter);
1065 smw->simple_menu.label = (SmeObject)
1066 XtCreateManagedWidget("menuLabel",
1067 smw->simple_menu.label_class, w, args, TWO);
1068
1069 next_child = NULL;
1070 for (child = smw->composite.children + smw->composite.num_children,
1071 i = (int)smw->composite.num_children; i > 0; i--, child--) {
1072 if (next_child != NULL)
1073 *next_child = *child;
1074 next_child = child;
1075 }
1076
1077 if (child != NULL)
1078 *child = (Widget)smw->simple_menu.label;
1079 }
1080
1081 /*
1082 * Function:
1083 * Layout
1084 *
1085 * Arguments:
1086 * w - See below
1087 * width_ret - returned width
1088 * height_ret - returned height
1089 *
1090 * Note:
1091 * if width == NULL || height == NULL then it assumes the you do not care
1092 * about the return values, and just want a relayout.
1093 *
1094 * if this is not the case then it will set width_ret and height_ret
1095 * to be width and height that the child would get if it were laid out
1096 * at this time.
1097 *
1098 * "w" can be the simple menu widget or any of its object children.
1099 */
1100 static void
1101 Layout(Widget w, Dimension *width_ret, Dimension *height_ret)
1102 {
1103 SmeObject current_entry;
1104 SimpleMenuWidget smw;
1105 Dimension width, height;
1106 Boolean allow_change_size;
1107 Widget kid;
1108 Cardinal i, count, n;
1109 int width_kid, height_kid, tmp_w, tmp_h;
1110 short vadd, hadd, x_ins, y_ins;
1111 Dimension *widths;
1112
1113 if (XtIsSubclass(w, simpleMenuWidgetClass)) {
1114 smw = (SimpleMenuWidget)w;
1115 current_entry = NULL;
1116 }
1117 else {
1118 smw = (SimpleMenuWidget)XtParent(w);
1119 current_entry = (SmeObject)w;
1120 }
1121
1122 allow_change_size = (!XtIsRealized((Widget)smw)
1123 || smw->shell.allow_shell_resize);
1124
1125 for (i = smw->simple_menu.label ? 1 : 0;
1126 i < smw->composite.num_children;
1127 i++) {
1128 XtWidgetGeometry preferred;
1129
1130 kid = smw->composite.children[i];
1131 if (!XtIsManaged(kid))
1132 continue;
1133 if (smw->simple_menu.row_height != 0)
1134 XtHeight(kid) = smw->simple_menu.row_height;
1135 XtQueryGeometry(kid, NULL, &preferred);
1136 if (preferred.request_mode & CWWidth)
1137 XtWidth(kid) = preferred.width;
1138 }
1139
1140 if (smw->simple_menu.label
1141 && XtIsManaged((Widget)smw->simple_menu.label)) {
1142 XtWidgetGeometry preferred;
1143
1144 kid = (Widget)smw->simple_menu.label;
1145 XtQueryGeometry(kid, NULL, &preferred);
1146 if (preferred.request_mode & CWWidth)
1147 XtWidth(kid) = preferred.width;
1148 if (preferred.request_mode & CWHeight)
1149 XtHeight(kid) = preferred.height;
1150 }
1151
1152 /* reset */
1153 if (!smw->simple_menu.menu_width)
1154 XtWidth(smw) = 0;
1155 if (!smw->simple_menu.menu_height)
1156 XtHeight(smw) = 0;
1157 if (!XtWidth(smw) || !XtHeight(smw))
1158 MakeResizeRequest((Widget)smw);
1159
1160 widths = (Dimension *)XtMalloc(sizeof(Dimension));
1161 #ifndef OLDXAW
1162 hadd = (short)smw->simple_menu.left_margin;
1163 #else
1164 hadd = 0;
1165 #endif
1166 vadd = (short)smw->simple_menu.top_margin;
1167 if (smw->simple_menu.label)
1168 vadd = (short)(vadd + XtHeight(smw->simple_menu.label));
1169
1170 count = 1;
1171 width = (Dimension)(tmp_w = tmp_h = (int)(n = 0));
1172 height = (Dimension)vadd;
1173
1174 for (i = smw->simple_menu.label ? 1 : 0;
1175 i < smw->composite.num_children;
1176 i++) {
1177 kid = smw->composite.children[i];
1178 if (!XtIsManaged(kid))
1179 continue;
1180 width_kid = XtWidth(kid);
1181 height_kid = XtHeight(kid);
1182
1183 if (n && (height + height_kid + smw->simple_menu.bottom_margin
1184 > XtHeight(smw))) {
1185 ++count;
1186 widths = (Dimension *)XtRealloc((char *)widths,
1187 (Cardinal)(sizeof(Dimension) * count));
1188 widths[count - 1] = (Dimension)width_kid;
1189 width = (Dimension)(width + tmp_w);
1190 tmp_w = width_kid;
1191 height = (Dimension)(height_kid + vadd);
1192 }
1193 else
1194 height = (Dimension)(height + height_kid);
1195 if (height > tmp_h)
1196 tmp_h = height;
1197 if (width_kid > tmp_w)
1198 widths[count - 1] = (Dimension)(tmp_w = width_kid);
1199 ++n;
1200 }
1201
1202 height = (Dimension)(tmp_h + smw->simple_menu.bottom_margin);
1203 width = (Dimension)(width + tmp_w);
1204
1205 if (smw->simple_menu.label && width < XtWidth(smw->simple_menu.label)) {
1206 float inc;
1207
1208 inc = (float)(XtWidth(smw->simple_menu.label) - width) / (float)count;
1209 width = XtWidth(smw->simple_menu.label);
1210 for (n = 0; n < count; n++)
1211 widths[n] = (Dimension)(widths[n] + inc);
1212 }
1213
1214 #ifndef OLDXAW
1215 width = (Dimension)(width + (hadd + smw->simple_menu.right_margin));
1216 #endif
1217
1218 x_ins = (short)(n = count = 0);
1219 tmp_w = widths[0];
1220 tmp_h = vadd;
1221
1222 for (i = smw->simple_menu.label ? 1 : 0;
1223 i < smw->composite.num_children;
1224 i++) {
1225 kid = smw->composite.children[i];
1226 if (!XtIsManaged(kid))
1227 continue;
1228
1229 height_kid = XtHeight(kid);
1230
1231 if (n && (tmp_h + height_kid + smw->simple_menu.bottom_margin
1232 > XtHeight(smw))) {
1233 x_ins = (short)tmp_w;
1234 y_ins = vadd;
1235 ++count;
1236 tmp_w += widths[count];
1237 tmp_h = height_kid + vadd;
1238 }
1239 else {
1240 y_ins = (short)tmp_h;
1241 tmp_h += height_kid;
1242 }
1243 ++n;
1244
1245 XtX(kid) = (Position)(x_ins + hadd);
1246 XtY(kid) = y_ins;
1247 XtWidth(kid) = widths[count];
1248 }
1249
1250 XtFree((char *)widths);
1251
1252 if (allow_change_size)
1253 MakeSetValuesRequest((Widget) smw, width, height);
1254
1255 if (smw->simple_menu.label) {
1256 XtX(smw->simple_menu.label) = 0;
1257 XtY(smw->simple_menu.label) = (Position)smw->simple_menu.top_margin;
1258 XtWidth(smw->simple_menu.label) = (Dimension)(XtWidth(smw)
1259 #ifndef OLDXAW
1260 - (smw->simple_menu.left_margin + smw->simple_menu.right_margin)
1261 #endif
1262 );
1263 }
1264 if (current_entry) {
1265 if (width_ret)
1266 *width_ret = XtWidth(current_entry);
1267 if (height_ret)
1268 *height_ret = XtHeight(current_entry);
1269 }
1270 }
1271
1272 /*
1273 * Function:
1274 * AddPositionAction
1275 *
1276 * Parameters:
1277 * app_con - application context
1278 * data - (not used)
1279 *
1280 * Description:
1281 * Adds the XawPositionSimpleMenu action to the global
1282 * action list for this appcon.
1283 */
1284 /*ARGSUSED*/
1285 static void
1286 AddPositionAction(XtAppContext app_con, XPointer data _X_UNUSED)
1287 {
1288 static XtActionsRec pos_action[] = {
1289 {"XawPositionSimpleMenu", PositionMenuAction},
1290 };
1291
1292 XtAppAddActions(app_con, pos_action, XtNumber(pos_action));
1293 }
1294
1295 /*
1296 * Function:
1297 * FindMenu
1298 *
1299 * Parameters:
1300 * widget - reference widget
1301 * name - menu widget's name
1302 *
1303 * Description:
1304 * Find the menu give a name and reference widget
1305 *
1306 * Returns:
1307 * The menu widget or NULL.
1308 */
1309 static Widget
1310 FindMenu(Widget widget, String name)
1311 {
1312 Widget w;
1313
1314 for (w = widget; w != NULL; w = XtParent(w)) {
1315 Widget menu = XtNameToWidget(w, name);
1316
1317 if (menu != NULL)
1318 return (menu);
1319 }
1320 return (NULL);
1321 }
1322
1323 /*
1324 * Function:
1325 * PositionMenu
1326 *
1327 * Parameters:
1328 * w - simple menu widget
1329 * location - pointer the the position or NULL
1330 *
1331 * Description:
1332 * Places the menu
1333 */
1334 static void
1335 PositionMenu(Widget w, XPoint *location)
1336 {
1337 SimpleMenuWidget smw = (SimpleMenuWidget)w;
1338 SmeObject entry;
1339 XPoint t_point;
1340
1341 if (location == NULL) {
1342 Window temp1, temp2;
1343 int root_x, root_y, tempX, tempY;
1344 unsigned int tempM;
1345
1346 location = &t_point;
1347 if (XQueryPointer(XtDisplay(w), XtWindow(w), &temp1, &temp2,
1348 &root_x, &root_y, &tempX, &tempY, &tempM) == False) {
1349 XtAppWarning(XtWidgetToApplicationContext(w),
1350 "Xaw Simple Menu Widget: "
1351 "Could not find location of mouse pointer");
1352 return;
1353 }
1354 location->x = (short) root_x;
1355 location->y = (short) root_y;
1356 }
1357
1358 /*
1359 * The width will not be correct unless it is realized
1360 */
1361 XtRealizeWidget(w);
1362
1363 location->x = (short)(location->x - (XtWidth(w) >> 1));
1364
1365 if (smw->simple_menu.popup_entry == NULL)
1366 entry = smw->simple_menu.label;
1367 else
1368 entry = smw->simple_menu.popup_entry;
1369
1370 if (entry != NULL)
1371 location->y = (short)(location->y - (XtY(entry) + (XtHeight(entry) >> 1)));
1372
1373 MoveMenu(w, location->x, location->y);
1374 }
1375
1376 /*
1377 * Function:
1378 * MoveMenu
1379 *
1380 * Parameters:
1381 * w - simple menu widget
1382 * x - current location of the widget
1383 * y - ""
1384 *
1385 * Description:
1386 * Actually moves the menu, may force it to
1387 * to be fully visible if menu_on_screen is True.
1388 */
1389 static void
1390 MoveMenu(Widget w, int x, int y)
1391 {
1392 Arg arglist[2];
1393 Cardinal num_args = 0;
1394 SimpleMenuWidget smw = (SimpleMenuWidget)w;
1395
1396 if (smw->simple_menu.menu_on_screen) {
1397 int width = XtWidth(w) + (XtBorderWidth(w) << 1);
1398 int height = XtHeight(w) + (XtBorderWidth(w) << 1);
1399
1400 if (x >= 0) {
1401 int scr_width = WidthOfScreen(XtScreen(w));
1402
1403 if (x + width > scr_width)
1404 x = scr_width - width;
1405 }
1406 if (x < 0)
1407 x = 0;
1408
1409 if (y >= 0) {
1410 int scr_height = HeightOfScreen(XtScreen(w));
1411
1412 if (y + height > scr_height)
1413 y = scr_height - height;
1414 }
1415 if (y < 0)
1416 y = 0;
1417 }
1418
1419 XtSetArg(arglist[num_args], XtNx, x); num_args++;
1420 XtSetArg(arglist[num_args], XtNy, y); num_args++;
1421 XtSetValues(w, arglist, num_args);
1422 }
1423
1424 /*
1425 * Function:
1426 * ChangeCursorOnGrab
1427 *
1428 * Parameters:
1429 * w - menu widget
1430 * temp1 - not used
1431 * temp2 - ""
1432 *
1433 * Description:
1434 * Changes the cursor on the active grab to the one
1435 * specified in out resource list.
1436 */
1437 /*ARGSUSED*/
1438 static void
1439 ChangeCursorOnGrab(Widget w, XtPointer temp1 _X_UNUSED, XtPointer temp2 _X_UNUSED)
1440 {
1441 SimpleMenuWidget smw = (SimpleMenuWidget)w;
1442
1443 /*
1444 * The event mask here is what is currently in the MIT implementation.
1445 * There really needs to be a way to get the value of the mask out
1446 * of the toolkit (CDP 5/26/89).
1447 */
1448 XChangeActivePointerGrab(XtDisplay(w), ButtonPressMask | ButtonReleaseMask,
1449 smw->simple_menu.cursor,
1450 XtLastTimestampProcessed(XtDisplay(w)));
1451 }
1452
1453 /*
1454 * Function:
1455 * MakeSetValuesRequest
1456 *
1457 * Parameters:
1458 * w - simple menu widget
1459 * width - size requested
1460 * height - ""
1461 */
1462 static void
1463 MakeSetValuesRequest(Widget w, unsigned int width, unsigned int height)
1464 {
1465 SimpleMenuWidget smw = (SimpleMenuWidget)w;
1466
1467 if (!smw->simple_menu.recursive_set_values) {
1468 if (XtWidth(smw) != width || XtHeight(smw) != height) {
1469 Arg arglist[2];
1470 Cardinal num_args = 0;
1471
1472 smw->simple_menu.recursive_set_values = True;
1473 XtSetArg(arglist[num_args], XtNwidth, width); num_args++;
1474 XtSetArg(arglist[num_args], XtNheight, height); num_args++;
1475 XtSetValues(w, arglist, num_args);
1476 }
1477 else if (XtIsRealized((Widget)smw))
1478 XawSimpleMenuRedisplay((Widget)smw, NULL, NULL);
1479 }
1480 smw->simple_menu.recursive_set_values = False;
1481 }
1482
1483 static SmeObject
1484 DoGetEventEntry(Widget w, int x_loc, int y_loc)
1485 {
1486 SimpleMenuWidget smw = (SimpleMenuWidget)w;
1487 SmeObject *entry;
1488
1489 ForAllChildren(smw, entry) {
1490 if (!XtIsManaged((Widget)*entry))
1491 continue;
1492
1493 if (x_loc > XtX(*entry)
1494 && x_loc <= XtX(*entry) + XtWidth(*entry)
1495 && y_loc > XtY(*entry)
1496 && y_loc <= XtY(*entry) + XtHeight(*entry)) {
1497 if (*entry == smw->simple_menu.label)
1498 return (NULL); /* cannot select the label */
1499 else
1500 return (*entry);
1501 }
1502 }
1503
1504 return (NULL);
1505 }
1506
1507 /*
1508 * Function:
1509 * GetEventEntry
1510 *
1511 * Parameters:
1512 * w - simple menu widget
1513 * event - X event
1514 *
1515 * Description:
1516 * Gets an entry given an event that has X and Y coords.
1517 *
1518 * Returns:
1519 * The entry that this point is in
1520 */
1521 static SmeObject
1522 GetEventEntry(Widget w, XEvent *event)
1523 {
1524 int x_loc, y_loc, x_root;
1525 SimpleMenuWidget smw = (SimpleMenuWidget)w;
1526 SmeObject entry;
1527 int warp, move;
1528
1529 switch (event->type) {
1530 case MotionNotify:
1531 x_loc = event->xmotion.x;
1532 y_loc = event->xmotion.y;
1533 x_root = event->xmotion.x_root;
1534 break;
1535 case EnterNotify:
1536 case LeaveNotify:
1537 x_loc = event->xcrossing.x;
1538 y_loc = event->xcrossing.y;
1539 x_root = event->xcrossing.x_root;
1540 break;
1541 case ButtonPress:
1542 case ButtonRelease:
1543 x_loc = event->xbutton.x;
1544 y_loc = event->xbutton.y;
1545 x_root = event->xbutton.x_root;
1546 break;
1547 default:
1548 XtAppError(XtWidgetToApplicationContext(w),
1549 "Unknown event type in GetEventEntry().");
1550 return (NULL);
1551 }
1552
1553 if (x_loc < 0 || x_loc >= XtWidth(smw) ||
1554 y_loc < 0 || y_loc >= XtHeight(smw))
1555 return (NULL);
1556
1557 /* Move the menu if it's outside the screen, does not check
1558 * smw->simple_menu.menu_on_screen because menus is bigger than screen
1559 */
1560 if (x_root == WidthOfScreen(XtScreen(w)) - 1 &&
1561 XtX(w) + XtWidth(w) + (XtBorderWidth(w)) > x_root) {
1562 if (smw->simple_menu.entry_set) {
1563 entry = DoGetEventEntry(w,
1564 XtX(smw->simple_menu.entry_set)
1565 + XtWidth(smw->simple_menu.entry_set) + 1,
1566 y_loc);
1567 Unhighlight(w, event, NULL, NULL);
1568 if (entry) {
1569 warp = -(int)XtWidth(entry) >> 1;
1570 move = x_loc - XtWidth(entry) - XtX(entry) + XtBorderWidth(w);
1571 }
1572 else {
1573 warp = 0;
1574 move = WidthOfScreen(XtScreen(w)) -
1575 (XtX(w) + XtWidth(w) + (XtBorderWidth(w) << 1));
1576 }
1577 }
1578 else {
1579 warp = 0;
1580 move = WidthOfScreen(XtScreen(w)) -
1581 (XtX(w) + XtWidth(w) + (XtBorderWidth(w) << 1));
1582 }
1583 }
1584 else if (x_root == 0 && XtX(w) < 0) {
1585 warp = 8;
1586 if (smw->simple_menu.entry_set) {
1587 entry = DoGetEventEntry(w, XtX(smw->simple_menu.entry_set) - 1,
1588 y_loc);
1589 Unhighlight(w, event, NULL, NULL);
1590 if (entry) {
1591 warp = XtWidth(entry) >> 1;
1592 move = x_loc - XtX(entry);
1593 }
1594 else
1595 move = x_loc + XtBorderWidth(w);
1596 }
1597 else
1598 move = x_loc + XtBorderWidth(w);
1599 }
1600 else
1601 move = warp = 0;
1602
1603 if (move)
1604 XtMoveWidget(w, (Position)(XtX(w) + move), XtY(w));
1605 if (warp)
1606 XWarpPointer(XtDisplay(w), None, None, 0, 0, 0, 0, warp, 0);
1607
1608 return (DoGetEventEntry(w, x_loc, y_loc));
1609 }
1610
1611 static void
1612 CalculateNewSize(Widget w, Dimension *width_return, Dimension *height_return)
1613 {
1614 SimpleMenuWidget xaw = (SimpleMenuWidget)w;
1615 Widget kid;
1616 Cardinal i;
1617 int width_kid, height_kid;
1618 int width, height, tmp_w, tmp_h, max_dim;
1619 short vadd, hadd;
1620 int n, columns, test_h, num_children = 0;
1621 Boolean try_layout = False;
1622
1623 #ifndef OLDXAW
1624 hadd = (short)(xaw->simple_menu.left_margin + xaw->simple_menu.right_margin);
1625 #else
1626 hadd = 0;
1627 #endif
1628 vadd = (short)(xaw->simple_menu.top_margin + xaw->simple_menu.bottom_margin);
1629 if (xaw->simple_menu.label)
1630 vadd = (short)(vadd + XtHeight(xaw->simple_menu.label));
1631
1632 if (*height_return)
1633 max_dim = *height_return;
1634 else if (!XtHeight(w)) {
1635 max_dim = HeightOfScreen(XtScreen(w));
1636 try_layout = True;
1637 }
1638 else
1639 max_dim = XtHeight(w);
1640 max_dim -= vadd;
1641
1642 width = height = tmp_w = tmp_h = n = test_h = 0;
1643 columns = 1;
1644 for (i = xaw->simple_menu.label ? 1 : 0;
1645 i < xaw->composite.num_children;
1646 i++) {
1647 kid = xaw->composite.children[i];
1648 if (!XtIsManaged(kid))
1649 continue;
1650 ++num_children;
1651 width_kid = XtWidth(kid);
1652 height_kid = XtHeight(kid);
1653
1654 if (try_layout) {
1655 if (!test_h)
1656 test_h = height_kid;
1657 else if (test_h != height_kid)
1658 try_layout = False;
1659 }
1660
1661 if (n && (height + height_kid > max_dim)) {
1662 ++columns;
1663 width += tmp_w;
1664 tmp_w = width_kid;
1665 height = height_kid;
1666 }
1667 else
1668 height += height_kid;
1669 if (height > tmp_h)
1670 tmp_h = height;
1671 if (width_kid > tmp_w)
1672 tmp_w = width_kid;
1673 ++n;
1674 }
1675
1676 height = tmp_h + vadd;
1677 width += tmp_w + hadd;
1678
1679 if (xaw->simple_menu.label)
1680 width = XawMax(width, XtWidth(xaw->simple_menu.label) + hadd);
1681
1682 *width_return = (Dimension)width;
1683 *height_return = (Dimension)height;
1684
1685 if (try_layout && columns > 1 && num_children > 2) {
1686 int space;
1687
1688 height = test_h * (xaw->simple_menu.label ?
1689 num_children - 1 :
1690 num_children);
1691
1692 max_dim -= max_dim % test_h;
1693 space = max_dim - (height % max_dim);
1694 if (space >= test_h * columns) {
1695 height = max_dim - space / columns;
1696 if (height % test_h)
1697 height += test_h - (height % test_h);
1698 *height_return = (Dimension)(height + vadd);
1699 CalculateNewSize(w, width_return, height_return);
1700 }
1701 }
1702 }
1703
1704 static void
1705 MakeResizeRequest(Widget w)
1706 {
1707 int tries;
1708 Dimension width, height;
1709
1710 width = XtWidth(w);
1711 height = XtHeight(w);
1712
1713 for (tries = 0; tries < 100; tries++) {
1714 CalculateNewSize(w, &width, &height);
1715 if (width == XtWidth(w) && height == XtHeight(w))
1716 break;
1717 if (XtMakeResizeRequest(w, width, height, &width, &height) ==
1718 XtGeometryNo)
1719 break;
1720 }
1721 }
1722
1723 #ifndef OLDXAW
1724 static void
1725 Popdown(Widget w, XEvent *event, String *params, Cardinal *num_params)
1726 {
1727 SimpleMenuWidget smw = (SimpleMenuWidget)w;
1728
1729 while (XtParent(w) &&
1730 XtIsSubclass(XtParent(w), simpleMenuWidgetClass)) {
1731 if (((SimpleMenuWidget)XtParent(w))->simple_menu.sub_menu == (Widget)w) {
1732 w = XtParent(w);
1733 smw = (SimpleMenuWidget)w;
1734 smw->simple_menu.entry_set = NULL;
1735 }
1736 else
1737 break;
1738 }
1739
1740 smw->simple_menu.state |= SMW_UNMAPPING;
1741 if (smw->simple_menu.sub_menu)
1742 PopdownSubMenu(smw);
1743 XtCallActionProc(w, "XtMenuPopdown", event, params, *num_params);
1744 }
1745
1746 static void
1747 PopupSubMenu(SimpleMenuWidget smw)
1748 {
1749 Arg args[2];
1750 Cardinal num_args;
1751 Widget menu;
1752 SmeBSBObject entry = (SmeBSBObject)smw->simple_menu.entry_set;
1753 Position menu_x, menu_y;
1754 Bool popleft;
1755
1756 if (entry->sme_bsb.menu_name == NULL)
1757 return;
1758
1759 if ((menu = FindMenu((Widget)smw, entry->sme_bsb.menu_name)) == NULL)
1760 return;
1761
1762 smw->simple_menu.sub_menu = menu;
1763
1764 if (!XtIsRealized(menu))
1765 XtRealizeWidget(menu);
1766
1767 popleft = (smw->simple_menu.state & SMW_POPLEFT) != 0;
1768
1769 if (popleft)
1770 XtTranslateCoords((Widget)smw,
1771 (Position)(-(int)XtWidth(menu)),
1772 (Position)(XtY(entry) - XtBorderWidth(menu)),
1773 &menu_x, &menu_y);
1774 else
1775 XtTranslateCoords((Widget)smw,
1776 (Position)XtWidth(smw),
1777 (Position)(XtY(entry) - XtBorderWidth(menu)),
1778 &menu_x, &menu_y);
1779
1780 if (!popleft && menu_x >= 0) {
1781 int scr_width = WidthOfScreen(XtScreen(menu));
1782
1783 if (menu_x + XtWidth(menu) > scr_width) {
1784 menu_x = (Position)(menu_x - (XtWidth(menu) + XtWidth(smw)));
1785 popleft = True;
1786 }
1787 }
1788 else if (popleft && menu_x < 0) {
1789 menu_x = 0;
1790 popleft = False;
1791 }
1792 if (menu_y >= 0) {
1793 int scr_height = HeightOfScreen(XtScreen(menu));
1794
1795 if (menu_y + XtHeight(menu) > scr_height)
1796 menu_y = (Position)(scr_height - XtHeight(menu) - XtBorderWidth(menu));
1797 }
1798 if (menu_y < 0)
1799 menu_y = 0;
1800
1801 num_args = 0;
1802 XtSetArg(args[num_args], XtNx, menu_x); num_args++;
1803 XtSetArg(args[num_args], XtNy, menu_y); num_args++;
1804 XtSetValues(menu, args, num_args);
1805
1806 if (popleft)
1807 ((SimpleMenuWidget)menu)->simple_menu.state |= SMW_POPLEFT;
1808 else
1809 ((SimpleMenuWidget)menu)->simple_menu.state &= (unsigned char)(~SMW_POPLEFT);
1810
1811 XtPopup(menu, XtGrabNone);
1812 }
1813
1814 static void
1815 PopdownSubMenu(SimpleMenuWidget smw)
1816 {
1817 SimpleMenuWidget menu = (SimpleMenuWidget)smw->simple_menu.sub_menu;
1818
1819 if (!menu)
1820 return;
1821
1822 menu->simple_menu.state |= SMW_UNMAPPING;
1823 PopdownSubMenu(menu);
1824
1825 XtPopdown((Widget)menu);
1826
1827 smw->simple_menu.sub_menu = NULL;
1828 }
1829
1830 /*ARGSUSED*/
1831 static void
1832 PopupCB(Widget w, XtPointer client_data _X_UNUSED, XtPointer call_data _X_UNUSED)
1833 {
1834 SimpleMenuWidget smw = (SimpleMenuWidget)w;
1835
1836 smw->simple_menu.state &= (unsigned char)(~(SMW_UNMAPPING | SMW_POPLEFT));
1837 }
1838 #endif /* OLDXAW */