Install the actual changes missing in previous revision
[emacs.git] / lwlib / lwlib-Xm.c
blob63668ea65fe6e297eef408969427fd379342fb7f
1 /* The lwlib interface to Motif widgets.
3 Copyright (C) 1994-1997, 1999-2013 Free Software Foundation, Inc.
4 Copyright (C) 1992 Lucid, Inc.
6 This file is part of the Lucid Widget Library.
8 The Lucid Widget Library is free software; you can redistribute it and/or
9 modify it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 1, or (at your option)
11 any later version.
13 The Lucid Widget Library is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
21 #include <config.h>
23 #include <unistd.h>
24 #include <stdio.h>
25 #include <setjmp.h>
27 #include <X11/StringDefs.h>
28 #include <X11/IntrinsicP.h>
29 #include <X11/ObjectP.h>
30 #include <X11/CoreP.h>
31 #include <X11/CompositeP.h>
33 #include <lisp.h>
35 #include "lwlib-Xm.h"
36 #include "lwlib-utils.h"
38 #include <Xm/BulletinB.h>
39 #include <Xm/CascadeB.h>
40 #include <Xm/CascadeBG.h>
41 #include <Xm/DrawingA.h>
42 #include <Xm/FileSB.h>
43 #include <Xm/Label.h>
44 #include <Xm/List.h>
45 #include <Xm/MainW.h>
46 #include <Xm/MenuShell.h>
47 #include <Xm/MessageB.h>
48 #include <Xm/PanedW.h>
49 #include <Xm/PushB.h>
50 #include <Xm/PushBG.h>
51 #include <Xm/ArrowB.h>
52 #include <Xm/SelectioB.h>
53 #include <Xm/Text.h>
54 #include <Xm/TextF.h>
55 #include <Xm/ToggleB.h>
56 #include <Xm/ToggleBG.h>
57 #include <Xm/RowColumn.h>
58 #include <Xm/ScrolledW.h>
59 #include <Xm/Separator.h>
60 #include <Xm/DialogS.h>
61 #include <Xm/Form.h>
63 enum do_call_type { pre_activate, selection, no_selection, post_activate };
66 \f/* Structures to keep destroyed instances */
67 typedef struct _destroyed_instance
69 char* name;
70 char* type;
71 Widget widget;
72 Widget parent;
73 Boolean pop_up_p;
74 struct _destroyed_instance* next;
75 } destroyed_instance;
77 static destroyed_instance *make_destroyed_instance (char *, char *,
78 Widget, Widget,
79 Boolean);
80 static void free_destroyed_instance (destroyed_instance*);
81 Widget first_child (Widget);
82 Boolean lw_motif_widget_p (Widget);
83 static XmString resource_motif_string (Widget, char *);
84 static void destroy_all_children (Widget, int);
85 static void xm_update_label (widget_instance *, Widget, widget_value *);
86 static void xm_update_list (widget_instance *, Widget, widget_value *);
87 static void xm_update_pushbutton (widget_instance *, Widget,
88 widget_value *);
89 static void xm_update_cascadebutton (widget_instance *, Widget,
90 widget_value *);
91 static void xm_update_toggle (widget_instance *, Widget, widget_value *);
92 static void xm_update_radiobox (widget_instance *, Widget, widget_value *);
93 static void make_menu_in_widget (widget_instance *, Widget,
94 widget_value *, int);
95 static void update_one_menu_entry (widget_instance *, Widget,
96 widget_value *, Boolean);
97 static void xm_update_menu (widget_instance *, Widget, widget_value *,
98 Boolean);
99 static void xm_update_text (widget_instance *, Widget, widget_value *);
100 static void xm_update_text_field (widget_instance *, Widget,
101 widget_value *);
102 void xm_update_one_value (widget_instance *, Widget, widget_value *);
103 static void activate_button (Widget, XtPointer, XtPointer);
104 static Widget make_dialog (char *, Widget, Boolean, char *, char *,
105 Boolean, Boolean, Boolean, int, int);
106 static destroyed_instance* find_matching_instance (widget_instance*);
107 static void mark_dead_instance_destroyed (Widget, XtPointer, XtPointer);
108 static void recenter_widget (Widget);
109 static Widget recycle_instance (destroyed_instance*);
110 Widget xm_create_dialog (widget_instance*);
111 static Widget make_menubar (widget_instance*);
112 static void remove_grabs (Widget, XtPointer, XtPointer);
113 static Widget make_popup_menu (widget_instance*);
114 static Widget make_main (widget_instance*);
115 void xm_destroy_instance (widget_instance*);
116 void xm_popup_menu (Widget, XEvent *);
117 static void set_min_dialog_size (Widget);
118 static void do_call (Widget, XtPointer, enum do_call_type);
119 static void xm_generic_callback (Widget, XtPointer, XtPointer);
120 static void xm_nosel_callback (Widget, XtPointer, XtPointer);
121 static void xm_pull_down_callback (Widget, XtPointer, XtPointer);
122 static void xm_pop_down_callback (Widget, XtPointer, XtPointer);
123 void xm_set_keyboard_focus (Widget, Widget);
124 void xm_set_main_areas (Widget, Widget, Widget);
125 static void xm_internal_update_other_instances (Widget, XtPointer,
126 XtPointer);
127 static void xm_arm_callback (Widget, XtPointer, XtPointer);
129 #if 0
130 void xm_update_one_widget (widget_instance *, Widget, widget_value *,
131 Boolean);
132 void xm_pop_instance (widget_instance*, Boolean);
133 void xm_manage_resizing (Widget, Boolean);
134 #endif
137 #if 0
139 /* Print the complete X resource name of widget WIDGET to stderr.
140 This is sometimes handy to have available. */
142 void
143 x_print_complete_resource_name (Widget widget)
145 int i;
146 String names[100];
148 for (i = 0; i < 100 && widget != NULL; ++i)
150 names[i] = XtName (widget);
151 widget = XtParent (widget);
154 for (--i; i >= 1; --i)
155 fprintf (stderr, "%s.", names[i]);
156 fprintf (stderr, "%s\n", names[0]);
159 #endif /* 0 */
162 static destroyed_instance *all_destroyed_instances = NULL;
164 static destroyed_instance*
165 make_destroyed_instance (char* name,
166 char* type,
167 Widget widget,
168 Widget parent,
169 Boolean pop_up_p)
171 destroyed_instance* instance =
172 (destroyed_instance*) xmalloc (sizeof (destroyed_instance));
173 instance->name = safe_strdup (name);
174 instance->type = safe_strdup (type);
175 instance->widget = widget;
176 instance->parent = parent;
177 instance->pop_up_p = pop_up_p;
178 instance->next = NULL;
179 return instance;
182 static void
183 free_destroyed_instance (destroyed_instance* instance)
185 xfree (instance->name);
186 xfree (instance->type);
187 xfree (instance);
190 \f/* motif utility functions */
191 Widget
192 first_child (Widget widget)
194 return ((CompositeWidget)widget)->composite.children [0];
197 Boolean
198 lw_motif_widget_p (Widget widget)
200 return
201 XtClass (widget) == xmDialogShellWidgetClass
202 || XmIsPrimitive (widget) || XmIsManager (widget) || XmIsGadget (widget);
205 static XmString
206 resource_motif_string (Widget widget,
207 char* name)
209 XtResource resource;
210 XmString result = 0;
212 resource.resource_name = name;
213 resource.resource_class = XmCXmString;
214 resource.resource_type = XmRXmString;
215 resource.resource_size = sizeof (XmString);
216 resource.resource_offset = 0;
217 resource.default_type = XtRImmediate;
218 resource.default_addr = 0;
220 XtGetSubresources (widget, (XtPointer)&result, "dialogString",
221 "DialogString", &resource, 1, NULL, 0);
222 return result;
225 /* Destroy all of the children of WIDGET
226 starting with number FIRST_CHILD_TO_DESTROY. */
228 static void
229 destroy_all_children (Widget widget,
230 int first_child_to_destroy)
232 Widget* children;
233 unsigned int number;
234 int i;
236 children = XtCompositeChildren (widget, &number);
237 if (children)
239 XtUnmanageChildren (children + first_child_to_destroy,
240 number - first_child_to_destroy);
242 /* Unmanage all children and destroy them. They will only be
243 really destroyed when we get out of DispatchEvent. */
244 for (i = first_child_to_destroy; i < number; i++)
246 Arg al[2];
247 Widget submenu = 0;
248 /* Cascade buttons have submenus,and these submenus
249 need to be freed. But they are not included in
250 XtCompositeChildren. So get it out of the cascade button
251 and free it. If this child is not a cascade button,
252 then submenu should remain unchanged. */
253 XtSetArg (al[0], XmNsubMenuId, &submenu);
254 XtGetValues (children[i], al, 1);
255 if (submenu)
257 destroy_all_children (submenu, 0);
258 XtDestroyWidget (submenu);
260 XtDestroyWidget (children[i]);
263 XtFree ((char *) children);
269 /* Callback XmNarmCallback and XmNdisarmCallback for buttons in a
270 menu. CLIENT_DATA contains a pointer to the widget_value
271 corresponding to widget W. CALL_DATA contains a
272 XmPushButtonCallbackStruct containing the reason why the callback
273 is called. */
275 static void
276 xm_arm_callback (Widget w, XtPointer client_data, XtPointer call_data)
278 XmPushButtonCallbackStruct *cbs = (XmPushButtonCallbackStruct *) call_data;
279 widget_value *wv = (widget_value *) client_data;
280 widget_instance *instance;
282 /* Get the id of the menu bar or popup menu this widget is in. */
283 while (w != NULL)
285 if (XmIsRowColumn (w))
287 unsigned char type = 0xff;
289 XtVaGetValues (w, XmNrowColumnType, &type, NULL);
290 if (type == XmMENU_BAR || type == XmMENU_POPUP)
291 break;
294 w = XtParent (w);
297 if (w != NULL)
299 instance = lw_get_widget_instance (w);
300 if (instance && instance->info->highlight_cb)
302 call_data = cbs->reason == XmCR_DISARM ? NULL : wv;
303 instance->info->highlight_cb (w, instance->info->id, call_data);
310 /* Update the label of widget WIDGET. WIDGET must be a Label widget
311 or a subclass of Label. WIDGET_INSTANCE is unused. VAL contains
312 the value to update.
314 Menus:
316 Emacs fills VAL->name with the text to display in the menu, and
317 sets VAL->value to null. Function make_menu_in_widget creates
318 widgets with VAL->name as resource name. This works because the
319 Label widget uses its resource name for display if no
320 XmNlabelString is set.
322 Dialogs:
324 VAL->name is again set to the resource name, but VAL->value is
325 not null, and contains the label string to display. */
327 static void
328 xm_update_label (widget_instance* instance,
329 Widget widget,
330 widget_value* val)
332 XmString res_string = 0;
333 XmString built_string = 0;
334 XmString key_string = 0;
335 Arg al [256];
336 int ac;
338 ac = 0;
340 if (val->value)
342 /* A label string is specified, i.e. we are in a dialog. First
343 see if it is overridden by something from the resource file. */
344 res_string = resource_motif_string (widget, val->value);
346 if (res_string)
348 XtSetArg (al [ac], XmNlabelString, res_string); ac++;
350 else
352 built_string =
353 XmStringCreateLocalized (val->value);
354 XtSetArg (al [ac], XmNlabelString, built_string); ac++;
357 XtSetArg (al [ac], XmNlabelType, XmSTRING); ac++;
360 if (val->key)
362 key_string = XmStringCreateLocalized (val->key);
363 XtSetArg (al [ac], XmNacceleratorText, key_string); ac++;
366 if (ac)
367 XtSetValues (widget, al, ac);
369 if (built_string)
370 XmStringFree (built_string);
372 if (key_string)
373 XmStringFree (key_string);
376 \f/* update of list */
377 static void
378 xm_update_list (widget_instance* instance,
379 Widget widget,
380 widget_value* val)
382 widget_value* cur;
383 int i;
384 XtRemoveAllCallbacks (widget, XmNsingleSelectionCallback);
385 XtAddCallback (widget, XmNsingleSelectionCallback, xm_generic_callback,
386 instance);
387 for (cur = val->contents, i = 0; cur; cur = cur->next)
388 if (cur->value)
390 XmString xmstr = XmStringCreateLocalized (cur->value);
391 i += 1;
392 XmListAddItem (widget, xmstr, 0);
393 if (cur->selected)
394 XmListSelectPos (widget, i, False);
395 XmStringFree (xmstr);
399 \f/* update of buttons */
400 static void
401 xm_update_pushbutton (widget_instance* instance,
402 Widget widget,
403 widget_value* val)
405 XtVaSetValues (widget, XmNalignment, XmALIGNMENT_CENTER, NULL);
406 XtRemoveAllCallbacks (widget, XmNactivateCallback);
407 XtAddCallback (widget, XmNactivateCallback, xm_generic_callback, instance);
410 static void
411 xm_update_cascadebutton (widget_instance* instance,
412 Widget widget,
413 widget_value* val)
415 /* Should also rebuild the menu by calling ...update_menu... */
416 XtRemoveAllCallbacks (widget, XmNcascadingCallback);
417 XtAddCallback (widget, XmNcascadingCallback, xm_pull_down_callback,
418 instance);
421 \f/* update toggle and radiobox */
422 static void
423 xm_update_toggle (widget_instance* instance,
424 Widget widget,
425 widget_value* val)
427 XtRemoveAllCallbacks (widget, XmNvalueChangedCallback);
428 XtAddCallback (widget, XmNvalueChangedCallback,
429 xm_generic_callback, instance);
430 XtVaSetValues (widget, XmNset, val->selected,
431 XmNalignment, XmALIGNMENT_BEGINNING, NULL);
434 static void
435 xm_update_radiobox (widget_instance* instance,
436 Widget widget,
437 widget_value* val)
440 Widget toggle;
441 widget_value* cur;
443 /* update the callback */
444 XtRemoveAllCallbacks (widget, XmNentryCallback);
445 XtAddCallback (widget, XmNentryCallback, xm_generic_callback, instance);
447 /* first update all the toggles */
448 /* Energize kernel interface is currently bad. It sets the selected widget
449 with the selected flag but returns it by its name. So we currently
450 have to support both setting the selection with the selected slot
451 of val contents and setting it with the "value" slot of val. The latter
452 has a higher priority. This to be removed when the kernel is fixed. */
453 for (cur = val->contents; cur; cur = cur->next)
455 toggle = XtNameToWidget (widget, cur->value);
456 if (toggle)
458 XtSetSensitive (toggle, cur->enabled);
459 if (!val->value && cur->selected)
460 XtVaSetValues (toggle, XmNset, cur->selected, NULL);
461 if (val->value && strcmp (val->value, cur->value))
462 XtVaSetValues (toggle, XmNset, False, NULL);
466 /* The selected was specified by the value slot */
467 if (val->value)
469 toggle = XtNameToWidget (widget, val->value);
470 if (toggle)
471 XtVaSetValues (toggle, XmNset, True, NULL);
476 /* update a popup menu, pulldown menu or a menubar */
478 /* KEEP_FIRST_CHILDREN gives the number of initial children to keep. */
480 static void
481 make_menu_in_widget (widget_instance* instance,
482 Widget widget,
483 widget_value* val,
484 int keep_first_children)
486 Widget* children = 0;
487 int num_children;
488 int child_index;
489 widget_value* cur;
490 Widget button = 0;
491 Widget menu;
492 Arg al [256];
493 int ac;
494 Boolean menubar_p;
495 unsigned char type;
497 Widget* old_children;
498 unsigned int old_num_children;
500 /* Disable drag and drop for labels in menu bar. */
501 static char overrideTrans[] = "<Btn2Down>: Noop()";
502 XtTranslations override = XtParseTranslationTable (overrideTrans);
504 old_children = XtCompositeChildren (widget, &old_num_children);
506 /* Allocate the children array */
507 for (num_children = 0, cur = val; cur; num_children++, cur = cur->next)
509 children = (Widget*)(void*)XtMalloc (num_children * sizeof (Widget));
511 /* WIDGET should be a RowColumn. */
512 if (!XmIsRowColumn (widget))
513 abort ();
515 /* Determine whether WIDGET is a menu bar. */
516 type = -1;
517 XtSetArg (al[0], XmNrowColumnType, &type);
518 XtGetValues (widget, al, 1);
519 if (type != XmMENU_BAR && type != XmMENU_PULLDOWN && type != XmMENU_POPUP)
520 abort ();
521 menubar_p = type == XmMENU_BAR;
523 /* Add a callback to popups and pulldowns that is called when
524 it is made invisible again. */
525 if (!menubar_p)
526 XtAddCallback (XtParent (widget), XmNpopdownCallback,
527 xm_pop_down_callback, (XtPointer)instance);
529 /* Preserve the first KEEP_FIRST_CHILDREN old children. */
530 for (child_index = 0, cur = val; child_index < keep_first_children;
531 child_index++, cur = cur->next)
532 children[child_index] = old_children[child_index];
534 /* Check that those are all we have
535 (the caller should have deleted the rest). */
536 if (old_num_children != keep_first_children)
537 abort ();
539 /* Create the rest. */
540 for (child_index = keep_first_children; cur; child_index++, cur = cur->next)
542 enum menu_separator separator;
544 ac = 0;
545 XtSetArg (al[ac], XmNsensitive, cur->enabled); ac++;
546 XtSetArg (al[ac], XmNalignment, XmALIGNMENT_BEGINNING); ac++;
547 XtSetArg (al[ac], XmNuserData, cur->call_data); ac++;
549 if (instance->pop_up_p && !cur->contents && !cur->call_data
550 && !lw_separator_p (cur->name, &separator, 1))
552 ac = 0;
553 XtSetArg (al[ac], XmNalignment, XmALIGNMENT_CENTER); ac++;
554 button = XmCreateLabel (widget, cur->name, al, ac);
556 else if (lw_separator_p (cur->name, &separator, 1))
558 ac = 0;
559 XtSetArg (al[ac], XmNseparatorType, separator); ++ac;
560 button = XmCreateSeparator (widget, cur->name, al, ac);
562 else if (!cur->contents)
564 if (menubar_p)
565 button = XmCreateCascadeButton (widget, cur->name, al, ac);
566 else if (!cur->call_data)
567 button = XmCreateLabel (widget, cur->name, al, ac);
568 else if (cur->button_type == BUTTON_TYPE_TOGGLE
569 || cur->button_type == BUTTON_TYPE_RADIO)
571 XtSetArg (al[ac], XmNset, cur->selected); ++ac;
572 XtSetArg (al[ac], XmNvisibleWhenOff, True); ++ac;
573 XtSetArg (al[ac], XmNindicatorType,
574 (cur->button_type == BUTTON_TYPE_TOGGLE
575 ? XmN_OF_MANY : XmONE_OF_MANY));
576 ++ac;
577 button = XmCreateToggleButton (widget, cur->name, al, ac);
578 XtAddCallback (button, XmNarmCallback, xm_arm_callback, cur);
579 XtAddCallback (button, XmNdisarmCallback, xm_arm_callback, cur);
581 else
583 button = XmCreatePushButton (widget, cur->name, al, ac);
584 XtAddCallback (button, XmNarmCallback, xm_arm_callback, cur);
585 XtAddCallback (button, XmNdisarmCallback, xm_arm_callback, cur);
588 xm_update_label (instance, button, cur);
590 /* Add a callback that is called when the button is
591 selected. Toggle buttons don't support
592 XmNactivateCallback, we use XmNvalueChangedCallback in
593 that case. Don't add a callback to a simple label. */
594 if (cur->button_type)
595 xm_update_toggle (instance, button, cur);
596 else if (cur->call_data)
597 XtAddCallback (button, XmNactivateCallback, xm_generic_callback,
598 (XtPointer)instance);
600 else
602 menu = XmCreatePulldownMenu (widget, cur->name, NULL, 0);
604 make_menu_in_widget (instance, menu, cur->contents, 0);
605 XtSetArg (al[ac], XmNsubMenuId, menu); ac++;
606 button = XmCreateCascadeButton (widget, cur->name, al, ac);
608 xm_update_label (instance, button, cur);
610 XtAddCallback (button, XmNcascadingCallback, xm_pull_down_callback,
611 (XtPointer)instance);
612 XtOverrideTranslations (button, override);
616 children[child_index] = button;
619 /* Last entry is the help button. The original comment read "Has to
620 be done after managing the buttons otherwise the menubar is only
621 4 pixels high." This is no longer true, and to make
622 XmNmenuHelpWidget work, we need to set it before managing the
623 children.. --gerd. */
624 if (button)
625 XtVaSetValues (widget, XmNmenuHelpWidget, button, NULL);
627 if (num_children)
628 XtManageChildren (children, num_children);
630 XtFree ((char *) children);
631 if (old_children)
632 XtFree ((char *) old_children);
635 static void
636 update_one_menu_entry (widget_instance* instance,
637 Widget widget,
638 widget_value* val,
639 Boolean deep_p)
641 Arg al [256];
642 int ac;
643 Widget menu;
644 widget_value* contents;
646 if (val->this_one_change == NO_CHANGE)
647 return;
649 /* update the sensitivity and userdata */
650 /* Common to all widget types */
651 XtSetSensitive (widget, val->enabled);
652 XtVaSetValues (widget, XmNuserData, val->call_data, NULL);
654 /* update the menu button as a label. */
655 if (val->this_one_change >= VISIBLE_CHANGE)
657 xm_update_label (instance, widget, val);
658 if (val->button_type)
659 xm_update_toggle (instance, widget, val);
662 /* update the pulldown/pullaside as needed */
663 ac = 0;
664 menu = NULL;
665 XtSetArg (al [ac], XmNsubMenuId, &menu); ac++;
666 XtGetValues (widget, al, ac);
668 contents = val->contents;
670 if (!menu)
672 if (contents)
674 unsigned int old_num_children, i;
675 Widget parent;
676 Widget *widget_list;
678 parent = XtParent (widget);
679 widget_list = XtCompositeChildren (parent, &old_num_children);
681 /* Find the widget position within the parent's widget list. */
682 for (i = 0; i < old_num_children; i++)
683 if (strcmp (XtName (widget_list[i]), XtName (widget)) == 0)
684 break;
685 if (i == old_num_children)
686 abort ();
687 if (XmIsCascadeButton (widget_list[i]))
689 menu = XmCreatePulldownMenu (parent, XtName(widget), NULL, 0);
690 make_menu_in_widget (instance, menu, contents, 0);
691 ac = 0;
692 XtSetArg (al [ac], XmNsubMenuId, menu); ac++;
693 XtSetValues (widget, al, ac);
695 else
697 Widget button;
699 /* The current menuitem is a XmPushButtonGadget, it
700 needs to be replaced by a CascadeButtonGadget */
701 XtDestroyWidget (widget_list[i]);
702 menu = XmCreatePulldownMenu (parent, val->name, NULL, 0);
703 make_menu_in_widget (instance, menu, contents, 0);
704 ac = 0;
705 XtSetArg (al [ac], XmNsubMenuId, menu); ac++;
706 /* Non-zero values don't work reliably in
707 conjunction with Emacs' event loop */
708 XtSetArg (al [ac], XmNmappingDelay, 0); ac++;
709 #ifdef XmNpositionIndex /* This is undefined on SCO ODT 2.0. */
710 /* Tell Motif to put it in the right place */
711 XtSetArg (al [ac], XmNpositionIndex , i); ac++;
712 #endif
713 button = XmCreateCascadeButton (parent, val->name, al, ac);
714 xm_update_label (instance, button, val);
716 XtAddCallback (button, XmNcascadingCallback, xm_pull_down_callback,
717 (XtPointer)instance);
718 XtManageChild (button);
721 if (widget_list)
722 XtFree ((char*) widget_list);
725 else if (!contents)
727 ac = 0;
728 XtSetArg (al [ac], XmNsubMenuId, NULL); ac++;
729 XtSetValues (widget, al, ac);
730 XtDestroyWidget (menu);
732 else if (deep_p && contents->change != NO_CHANGE)
733 xm_update_menu (instance, menu, val, 1);
736 static void
737 xm_update_menu (widget_instance* instance,
738 Widget widget,
739 widget_value* val,
740 Boolean deep_p)
742 Widget* children;
743 unsigned int num_children;
744 int num_children_to_keep = 0;
745 int i;
746 widget_value* cur;
748 children = XtCompositeChildren (widget, &num_children);
750 /* Widget is a RowColumn widget whose contents have to be updated
751 * to reflect the list of items in val->contents */
753 /* See how many buttons we can keep, and how many we
754 must completely replace. */
755 if (val->contents == 0)
756 num_children_to_keep = 0;
757 else if (val->contents->change == STRUCTURAL_CHANGE)
759 if (children)
761 for (i = 0, cur = val->contents;
762 (i < num_children
763 && cur); /* how else to ditch unwanted children ?? - mgd */
764 i++, cur = cur->next)
766 if (cur->this_one_change == STRUCTURAL_CHANGE)
767 break;
770 num_children_to_keep = i;
773 else
774 num_children_to_keep = num_children;
776 /* Update all the buttons of the RowColumn, in order,
777 except for those we are going to replace entirely. */
778 if (children)
780 for (i = 0, cur = val->contents; i < num_children_to_keep; i++)
782 if (!cur)
784 num_children_to_keep = i;
785 break;
787 if (children [i]->core.being_destroyed
788 || strcmp (XtName (children [i]), cur->name))
789 continue;
790 update_one_menu_entry (instance, children [i], cur, deep_p);
791 cur = cur->next;
795 /* Now replace from scratch all the buttons after the last
796 place that the top-level structure changed. */
797 if (val->contents && val->contents->change == STRUCTURAL_CHANGE)
799 destroy_all_children (widget, num_children_to_keep);
800 make_menu_in_widget (instance, widget, val->contents,
801 num_children_to_keep);
804 XtFree ((char *) children);
808 /* update text widgets */
810 static void
811 xm_update_text (widget_instance* instance,
812 Widget widget,
813 widget_value* val)
815 XmTextSetString (widget, val->value ? val->value : "");
816 XtRemoveAllCallbacks (widget, XmNactivateCallback);
817 XtAddCallback (widget, XmNactivateCallback, xm_generic_callback, instance);
818 XtRemoveAllCallbacks (widget, XmNvalueChangedCallback);
819 XtAddCallback (widget, XmNvalueChangedCallback,
820 xm_internal_update_other_instances, instance);
823 static void
824 xm_update_text_field (widget_instance* instance,
825 Widget widget,
826 widget_value* val)
828 XmTextFieldSetString (widget, val->value ? val->value : "");
829 XtRemoveAllCallbacks (widget, XmNactivateCallback);
830 XtAddCallback (widget, XmNactivateCallback, xm_generic_callback, instance);
831 XtRemoveAllCallbacks (widget, XmNvalueChangedCallback);
832 XtAddCallback (widget, XmNvalueChangedCallback,
833 xm_internal_update_other_instances, instance);
837 /* update a motif widget */
839 void
840 xm_update_one_widget (widget_instance* instance,
841 Widget widget,
842 widget_value* val,
843 Boolean deep_p)
845 WidgetClass class;
847 /* Mark as not edited */
848 val->edited = False;
850 /* Common to all widget types */
851 XtSetSensitive (widget, val->enabled);
852 XtVaSetValues (widget, XmNuserData, val->call_data, NULL);
854 /* Common to all label like widgets */
855 if (XtIsSubclass (widget, xmLabelWidgetClass))
856 xm_update_label (instance, widget, val);
858 class = XtClass (widget);
859 /* Class specific things */
860 if (class == xmPushButtonWidgetClass ||
861 class == xmArrowButtonWidgetClass)
863 xm_update_pushbutton (instance, widget, val);
865 else if (class == xmCascadeButtonWidgetClass)
867 xm_update_cascadebutton (instance, widget, val);
869 else if (class == xmToggleButtonWidgetClass
870 || class == xmToggleButtonGadgetClass)
872 xm_update_toggle (instance, widget, val);
874 else if (class == xmRowColumnWidgetClass)
876 Boolean radiobox = 0;
877 int ac = 0;
878 Arg al [1];
880 XtSetArg (al [ac], XmNradioBehavior, &radiobox); ac++;
881 XtGetValues (widget, al, ac);
883 if (radiobox)
884 xm_update_radiobox (instance, widget, val);
885 else
886 xm_update_menu (instance, widget, val, deep_p);
888 else if (class == xmTextWidgetClass)
890 xm_update_text (instance, widget, val);
892 else if (class == xmTextFieldWidgetClass)
894 xm_update_text_field (instance, widget, val);
896 else if (class == xmListWidgetClass)
898 xm_update_list (instance, widget, val);
902 \f/* getting the value back */
903 void
904 xm_update_one_value (widget_instance* instance,
905 Widget widget,
906 widget_value* val)
908 WidgetClass class = XtClass (widget);
909 widget_value *old_wv;
911 /* copy the call_data slot into the "return" widget_value */
912 for (old_wv = instance->info->val->contents; old_wv; old_wv = old_wv->next)
913 if (!strcmp (val->name, old_wv->name))
915 val->call_data = old_wv->call_data;
916 break;
919 if (class == xmToggleButtonWidgetClass || class == xmToggleButtonGadgetClass)
921 XtVaGetValues (widget, XmNset, &val->selected, NULL);
922 val->edited = True;
924 else if (class == xmTextWidgetClass)
926 xfree (val->value);
927 val->value = XmTextGetString (widget);
928 val->edited = True;
930 else if (class == xmTextFieldWidgetClass)
932 xfree (val->value);
933 val->value = XmTextFieldGetString (widget);
934 val->edited = True;
936 else if (class == xmRowColumnWidgetClass)
938 Boolean radiobox = 0;
939 int ac = 0;
940 Arg al [1];
942 XtSetArg (al [ac], XmNradioBehavior, &radiobox); ac++;
943 XtGetValues (widget, al, ac);
945 if (radiobox)
947 CompositeWidget radio = (CompositeWidget)widget;
948 int i;
949 for (i = 0; i < radio->composite.num_children; i++)
951 int set = False;
952 Widget toggle = radio->composite.children [i];
954 XtVaGetValues (toggle, XmNset, &set, NULL);
955 if (set)
957 xfree (val->value);
958 val->value = safe_strdup (XtName (toggle));
961 val->edited = True;
964 else if (class == xmListWidgetClass)
966 int pos_cnt;
967 int* pos_list;
968 if (XmListGetSelectedPos (widget, &pos_list, &pos_cnt))
970 int i;
971 widget_value* cur;
972 for (cur = val->contents, i = 0; cur; cur = cur->next)
973 if (cur->value)
975 int j;
976 cur->selected = False;
977 i += 1;
978 for (j = 0; j < pos_cnt; j++)
979 if (pos_list [j] == i)
981 cur->selected = True;
982 val->value = safe_strdup (cur->name);
985 val->edited = 1;
986 XtFree ((char *) pos_list);
992 /* This function is for activating a button from a program. It's wrong because
993 we pass a NULL argument in the call_data which is not Motif compatible.
994 This is used from the XmNdefaultAction callback of the List widgets to
995 have a double-click put down a dialog box like the button would do.
996 I could not find a way to do that with accelerators.
998 static void
999 activate_button (Widget widget,
1000 XtPointer closure,
1001 XtPointer call_data)
1003 Widget button = (Widget)closure;
1004 XtCallCallbacks (button, XmNactivateCallback, NULL);
1007 /* creation functions */
1009 /* Called for key press in dialogs. Used to pop down dialog on ESC. */
1010 static void
1011 dialog_key_cb (Widget widget,
1012 XtPointer closure,
1013 XEvent *event,
1014 Boolean *continue_to_dispatch)
1016 KeySym sym = 0;
1017 Modifiers modif_ret;
1019 XtTranslateKeycode (event->xkey.display, event->xkey.keycode, 0,
1020 &modif_ret, &sym);
1022 if (sym == osfXK_Cancel)
1024 Widget w = *((Widget *) closure);
1026 while (w && ! XtIsShell (w))
1027 w = XtParent (w);
1029 if (XtIsShell (w)) XtPopdown (w);
1032 *continue_to_dispatch = TRUE;
1035 /* dialogs */
1036 static Widget
1037 make_dialog (char* name,
1038 Widget parent,
1039 Boolean pop_up_p,
1040 char* shell_title,
1041 char* icon_name,
1042 Boolean text_input_slot,
1043 Boolean radio_box,
1044 Boolean list,
1045 int left_buttons,
1046 int right_buttons)
1048 Widget result;
1049 Widget form;
1050 Widget row;
1051 Widget icon;
1052 Widget icon_separator;
1053 Widget message_label;
1054 Widget value = 0;
1055 Widget separator;
1056 Widget button = 0;
1057 Widget children [16]; /* for the final XtManageChildren */
1058 int n_children;
1059 Arg al[64]; /* Arg List */
1060 int ac; /* Arg Count */
1061 int i;
1063 if (pop_up_p)
1065 ac = 0;
1066 XtSetArg(al[ac], XmNtitle, shell_title); ac++;
1067 XtSetArg(al[ac], XtNallowShellResize, True); ac++;
1068 XtSetArg(al[ac], XmNdeleteResponse, XmUNMAP); ac++;
1069 result = XmCreateDialogShell (parent, "dialog", al, ac);
1070 ac = 0;
1071 XtSetArg(al[ac], XmNautoUnmanage, FALSE); ac++;
1072 /* XtSetArg(al[ac], XmNautoUnmanage, TRUE); ac++; */ /* ####is this ok? */
1073 XtSetArg(al[ac], XmNnavigationType, XmTAB_GROUP); ac++;
1074 form = XmCreateForm (result, shell_title, al, ac);
1076 else
1078 ac = 0;
1079 XtSetArg(al[ac], XmNautoUnmanage, FALSE); ac++;
1080 XtSetArg(al[ac], XmNnavigationType, XmTAB_GROUP); ac++;
1081 form = XmCreateForm (parent, shell_title, al, ac);
1082 result = form;
1085 n_children = left_buttons + right_buttons + 1;
1086 ac = 0;
1087 XtSetArg(al[ac], XmNpacking, n_children == 3?
1088 XmPACK_COLUMN: XmPACK_TIGHT); ac++;
1089 XtSetArg(al[ac], XmNorientation, n_children == 3?
1090 XmVERTICAL: XmHORIZONTAL); ac++;
1091 XtSetArg(al[ac], XmNnumColumns, left_buttons + right_buttons + 1); ac++;
1092 XtSetArg(al[ac], XmNmarginWidth, 0); ac++;
1093 XtSetArg(al[ac], XmNmarginHeight, 0); ac++;
1094 XtSetArg(al[ac], XmNspacing, 13); ac++;
1095 XtSetArg(al[ac], XmNadjustLast, False); ac++;
1096 XtSetArg(al[ac], XmNalignment, XmALIGNMENT_CENTER); ac++;
1097 XtSetArg(al[ac], XmNisAligned, True); ac++;
1098 XtSetArg(al[ac], XmNtopAttachment, XmATTACH_NONE); ac++;
1099 XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
1100 XtSetArg(al[ac], XmNbottomOffset, 13); ac++;
1101 XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
1102 XtSetArg(al[ac], XmNleftOffset, 13); ac++;
1103 XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
1104 XtSetArg(al[ac], XmNrightOffset, 13); ac++;
1105 row = XmCreateRowColumn (form, "row", al, ac);
1107 n_children = 0;
1108 for (i = 0; i < left_buttons; i++)
1110 char button_name [16];
1111 sprintf (button_name, "button%d", i + 1);
1112 ac = 0;
1113 if (i == 0)
1115 XtSetArg(al[ac], XmNhighlightThickness, 1); ac++;
1116 XtSetArg(al[ac], XmNshowAsDefault, TRUE); ac++;
1118 XtSetArg(al[ac], XmNmarginWidth, 10); ac++;
1119 XtSetArg(al[ac], XmNnavigationType, XmTAB_GROUP); ac++;
1120 children [n_children] = XmCreatePushButton (row, button_name, al, ac);
1121 XtAddEventHandler (children [n_children],
1122 KeyPressMask, False, dialog_key_cb, result);
1124 if (i == 0)
1126 button = children [n_children];
1127 ac = 0;
1128 XtSetArg(al[ac], XmNdefaultButton, button); ac++;
1129 XtSetValues (row, al, ac);
1132 n_children++;
1135 /* invisible separator button */
1136 ac = 0;
1137 XtSetArg (al[ac], XmNmappedWhenManaged, FALSE); ac++;
1138 children [n_children] = XmCreateLabel (row, "separator_button", al, ac);
1139 n_children++;
1141 for (i = 0; i < right_buttons; i++)
1143 char button_name [16];
1144 sprintf (button_name, "button%d", left_buttons + i + 1);
1145 ac = 0;
1146 XtSetArg(al[ac], XmNmarginWidth, 10); ac++;
1147 XtSetArg(al[ac], XmNnavigationType, XmTAB_GROUP); ac++;
1148 children [n_children] = XmCreatePushButton (row, button_name, al, ac);
1149 XtAddEventHandler (children [n_children],
1150 KeyPressMask, False, dialog_key_cb, result);
1152 if (! button) button = children [n_children];
1153 n_children++;
1156 XtManageChildren (children, n_children);
1158 ac = 0;
1159 XtSetArg(al[ac], XmNtopAttachment, XmATTACH_NONE); ac++;
1160 XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_WIDGET); ac++;
1161 XtSetArg(al[ac], XmNbottomOffset, 13); ac++;
1162 XtSetArg(al[ac], XmNbottomWidget, row); ac++;
1163 XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
1164 XtSetArg(al[ac], XmNleftOffset, 0); ac++;
1165 XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
1166 XtSetArg(al[ac], XmNrightOffset, 0); ac++;
1167 separator = XmCreateSeparator (form, "", al, ac);
1169 ac = 0;
1170 XtSetArg(al[ac], XmNlabelType, XmPIXMAP); ac++;
1171 XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
1172 XtSetArg(al[ac], XmNtopOffset, 13); ac++;
1173 XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
1174 XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
1175 XtSetArg(al[ac], XmNleftOffset, 13); ac++;
1176 XtSetArg(al[ac], XmNrightAttachment, XmATTACH_NONE); ac++;
1177 icon = XmCreateLabel (form, icon_name, al, ac);
1179 ac = 0;
1180 XtSetArg(al[ac], XmNmappedWhenManaged, FALSE); ac++;
1181 XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
1182 XtSetArg(al[ac], XmNtopOffset, 6); ac++;
1183 XtSetArg(al[ac], XmNtopWidget, icon); ac++;
1184 XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_WIDGET); ac++;
1185 XtSetArg(al[ac], XmNbottomOffset, 6); ac++;
1186 XtSetArg(al[ac], XmNbottomWidget, separator); ac++;
1187 XtSetArg(al[ac], XmNleftAttachment, XmATTACH_NONE); ac++;
1188 XtSetArg(al[ac], XmNrightAttachment, XmATTACH_NONE); ac++;
1189 icon_separator = XmCreateLabel (form, "", al, ac);
1191 if (text_input_slot)
1193 ac = 0;
1194 XtSetArg(al[ac], XmNcolumns, 50); ac++;
1195 XtSetArg(al[ac], XmNtopAttachment, XmATTACH_NONE); ac++;
1196 XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_WIDGET); ac++;
1197 XtSetArg(al[ac], XmNbottomOffset, 13); ac++;
1198 XtSetArg(al[ac], XmNbottomWidget, separator); ac++;
1199 XtSetArg(al[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
1200 XtSetArg(al[ac], XmNleftOffset, 13); ac++;
1201 XtSetArg(al[ac], XmNleftWidget, icon); ac++;
1202 XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
1203 XtSetArg(al[ac], XmNrightOffset, 13); ac++;
1204 value = XmCreateTextField (form, "value", al, ac);
1206 else if (radio_box)
1208 Widget radio_butt;
1209 ac = 0;
1210 XtSetArg(al[ac], XmNmarginWidth, 0); ac++;
1211 XtSetArg(al[ac], XmNmarginHeight, 0); ac++;
1212 XtSetArg(al[ac], XmNspacing, 13); ac++;
1213 XtSetArg(al[ac], XmNalignment, XmALIGNMENT_CENTER); ac++;
1214 XtSetArg(al[ac], XmNorientation, XmHORIZONTAL); ac++;
1215 XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_WIDGET); ac++;
1216 XtSetArg(al[ac], XmNbottomOffset, 13); ac++;
1217 XtSetArg(al[ac], XmNbottomWidget, separator); ac++;
1218 XtSetArg(al[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
1219 XtSetArg(al[ac], XmNleftOffset, 13); ac++;
1220 XtSetArg(al[ac], XmNleftWidget, icon); ac++;
1221 XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
1222 XtSetArg(al[ac], XmNrightOffset, 13); ac++;
1223 value = XmCreateRadioBox (form, "radiobutton1", al, ac);
1224 ac = 0;
1225 i = 0;
1226 radio_butt = XmCreateToggleButtonGadget (value, "radio1", al, ac);
1227 children [i++] = radio_butt;
1228 radio_butt = XmCreateToggleButtonGadget (value, "radio2", al, ac);
1229 children [i++] = radio_butt;
1230 radio_butt = XmCreateToggleButtonGadget (value, "radio3", al, ac);
1231 children [i++] = radio_butt;
1232 XtManageChildren (children, i);
1234 else if (list)
1236 ac = 0;
1237 XtSetArg(al[ac], XmNvisibleItemCount, 5); ac++;
1238 XtSetArg(al[ac], XmNtopAttachment, XmATTACH_NONE); ac++;
1239 XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_WIDGET); ac++;
1240 XtSetArg(al[ac], XmNbottomOffset, 13); ac++;
1241 XtSetArg(al[ac], XmNbottomWidget, separator); ac++;
1242 XtSetArg(al[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
1243 XtSetArg(al[ac], XmNleftOffset, 13); ac++;
1244 XtSetArg(al[ac], XmNleftWidget, icon); ac++;
1245 XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
1246 XtSetArg(al[ac], XmNrightOffset, 13); ac++;
1247 value = XmCreateScrolledList (form, "list", al, ac);
1249 /* this is the easiest way I found to have the dble click in the
1250 list activate the default button */
1251 XtAddCallback (value, XmNdefaultActionCallback, activate_button, button);
1254 ac = 0;
1255 XtSetArg(al[ac], XmNalignment, XmALIGNMENT_BEGINNING); ac++;
1256 XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
1257 XtSetArg(al[ac], XmNtopOffset, 13); ac++;
1258 XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_WIDGET); ac++;
1259 XtSetArg(al[ac], XmNbottomOffset, 13); ac++;
1260 XtSetArg(al[ac], XmNbottomWidget,
1261 text_input_slot || radio_box || list ? value : separator); ac++;
1262 XtSetArg(al[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
1263 XtSetArg(al[ac], XmNleftOffset, 13); ac++;
1264 XtSetArg(al[ac], XmNleftWidget, icon); ac++;
1265 XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
1266 XtSetArg(al[ac], XmNrightOffset, 13); ac++;
1267 message_label = XmCreateLabel (form, "message", al, ac);
1269 if (list)
1270 XtManageChild (value);
1272 i = 0;
1273 children [i] = row; i++;
1274 children [i] = separator; i++;
1275 if (text_input_slot || radio_box)
1277 children [i] = value; i++;
1279 children [i] = message_label; i++;
1280 children [i] = icon; i++;
1281 children [i] = icon_separator; i++;
1282 XtManageChildren (children, i);
1284 if (text_input_slot || list)
1286 XtInstallAccelerators (value, button);
1287 XtSetKeyboardFocus (result, value);
1289 else
1291 XtInstallAccelerators (form, button);
1292 XtSetKeyboardFocus (result, button);
1295 return result;
1298 static destroyed_instance*
1299 find_matching_instance (widget_instance* instance)
1301 destroyed_instance* cur;
1302 destroyed_instance* prev;
1303 char* type = instance->info->type;
1304 char* name = instance->info->name;
1306 for (prev = NULL, cur = all_destroyed_instances;
1307 cur;
1308 prev = cur, cur = cur->next)
1310 if (!strcmp (cur->name, name)
1311 && !strcmp (cur->type, type)
1312 && cur->parent == instance->parent
1313 && cur->pop_up_p == instance->pop_up_p)
1315 if (prev)
1316 prev->next = cur->next;
1317 else
1318 all_destroyed_instances = cur->next;
1319 return cur;
1321 /* do some cleanup */
1322 else if (!cur->widget)
1324 if (prev)
1325 prev->next = cur->next;
1326 else
1327 all_destroyed_instances = cur->next;
1328 free_destroyed_instance (cur);
1329 cur = prev ? prev : all_destroyed_instances;
1332 return NULL;
1335 static void
1336 mark_dead_instance_destroyed (Widget widget,
1337 XtPointer closure,
1338 XtPointer call_data)
1340 destroyed_instance* instance = (destroyed_instance*)closure;
1341 instance->widget = NULL;
1344 static void
1345 recenter_widget (Widget widget)
1347 Widget parent = XtParent (widget);
1348 Screen* screen = XtScreen (widget);
1349 Dimension screen_width = WidthOfScreen (screen);
1350 Dimension screen_height = HeightOfScreen (screen);
1351 Dimension parent_width = 0;
1352 Dimension parent_height = 0;
1353 Dimension child_width = 0;
1354 Dimension child_height = 0;
1355 Position x;
1356 Position y;
1358 XtVaGetValues (widget, XtNwidth, &child_width, XtNheight, &child_height, NULL);
1359 XtVaGetValues (parent, XtNwidth, &parent_width, XtNheight, &parent_height,
1360 NULL);
1362 x = (((Position)parent_width) - ((Position)child_width)) / 2;
1363 y = (((Position)parent_height) - ((Position)child_height)) / 2;
1365 XtTranslateCoords (parent, x, y, &x, &y);
1367 if (x + child_width > screen_width)
1368 x = screen_width - child_width;
1369 if (x < 0)
1370 x = 0;
1372 if (y + child_height > screen_height)
1373 y = screen_height - child_height;
1374 if (y < 0)
1375 y = 0;
1377 XtVaSetValues (widget, XtNx, x, XtNy, y, NULL);
1380 static Widget
1381 recycle_instance (destroyed_instance* instance)
1383 Widget widget = instance->widget;
1385 /* widget is NULL if the parent was destroyed. */
1386 if (widget)
1388 Widget focus;
1389 Widget separator;
1391 /* Remove the destroy callback as the instance is not in the list
1392 anymore */
1393 XtRemoveCallback (instance->parent, XtNdestroyCallback,
1394 mark_dead_instance_destroyed,
1395 (XtPointer)instance);
1397 /* Give the focus to the initial item */
1398 focus = XtNameToWidget (widget, "*value");
1399 if (!focus)
1400 focus = XtNameToWidget (widget, "*button1");
1401 if (focus)
1402 XtSetKeyboardFocus (widget, focus);
1404 /* shrink the separator label back to their original size */
1405 separator = XtNameToWidget (widget, "*separator_button");
1406 if (separator)
1407 XtVaSetValues (separator, XtNwidth, 5, XtNheight, 5, NULL);
1409 /* Center the dialog in its parent */
1410 recenter_widget (widget);
1412 free_destroyed_instance (instance);
1413 return widget;
1416 Widget
1417 xm_create_dialog (widget_instance* instance)
1419 char* name = instance->info->type;
1420 Widget parent = instance->parent;
1421 Widget widget;
1422 Boolean pop_up_p = instance->pop_up_p;
1423 char* shell_name = 0;
1424 char* icon_name = 0;
1425 Boolean text_input_slot = False;
1426 Boolean radio_box = False;
1427 Boolean list = False;
1428 int total_buttons;
1429 int left_buttons = 0;
1430 int right_buttons = 1;
1431 destroyed_instance* dead_one;
1433 /* try to find a widget to recycle */
1434 dead_one = find_matching_instance (instance);
1435 if (dead_one)
1437 Widget recycled_widget = recycle_instance (dead_one);
1438 if (recycled_widget)
1439 return recycled_widget;
1442 switch (name [0]){
1443 case 'E': case 'e':
1444 icon_name = "dbox-error";
1445 shell_name = "Error";
1446 break;
1448 case 'I': case 'i':
1449 icon_name = "dbox-info";
1450 shell_name = "Information";
1451 break;
1453 case 'L': case 'l':
1454 list = True;
1455 icon_name = "dbox-question";
1456 shell_name = "Prompt";
1457 break;
1459 case 'P': case 'p':
1460 text_input_slot = True;
1461 icon_name = "dbox-question";
1462 shell_name = "Prompt";
1463 break;
1465 case 'Q': case 'q':
1466 icon_name = "dbox-question";
1467 shell_name = "Question";
1468 break;
1471 total_buttons = name [1] - '0';
1473 if (name [3] == 'T' || name [3] == 't')
1475 text_input_slot = False;
1476 radio_box = True;
1478 else if (name [3])
1479 right_buttons = name [4] - '0';
1481 left_buttons = total_buttons - right_buttons;
1483 widget = make_dialog (name, parent, pop_up_p,
1484 shell_name, icon_name, text_input_slot, radio_box,
1485 list, left_buttons, right_buttons);
1487 XtAddCallback (widget, XmNpopdownCallback, xm_nosel_callback,
1488 (XtPointer) instance);
1490 return widget;
1493 /* Create a menu bar. We turn off the f10 key
1494 because we have not yet managed to make it work right in Motif. */
1496 static Widget
1497 make_menubar (widget_instance* instance)
1499 Arg al[3];
1500 int ac;
1502 ac = 0;
1503 XtSetArg(al[ac], XmNmenuAccelerator, 0); ++ac;
1504 return XmCreateMenuBar (instance->parent, instance->info->name, al, ac);
1507 static void
1508 remove_grabs (Widget shell,
1509 XtPointer closure,
1510 XtPointer call_data)
1512 Widget menu = (Widget) closure;
1513 XmRemoveFromPostFromList (menu, XtParent (XtParent (menu)));
1516 static Widget
1517 make_popup_menu (widget_instance* instance)
1519 Widget parent = instance->parent;
1520 Window parent_window = parent->core.window;
1521 Widget result;
1523 /* sets the parent window to 0 to fool Motif into not generating a grab */
1524 parent->core.window = 0;
1525 result = XmCreatePopupMenu (parent, instance->info->name, NULL, 0);
1526 XtAddCallback (XtParent (result), XmNpopdownCallback, remove_grabs,
1527 (XtPointer)result);
1528 parent->core.window = parent_window;
1529 return result;
1532 static Widget
1533 make_main (widget_instance* instance)
1535 Widget parent = instance->parent;
1536 Widget result;
1537 Arg al[2];
1538 int ac;
1540 ac = 0;
1541 XtSetArg (al[ac], XtNborderWidth, 0); ac++;
1542 XtSetArg (al[ac], XmNspacing, 0); ac++;
1543 result = XmCreateMainWindow (parent, instance->info->name, al, ac);
1544 return result;
1547 \f/* Table of functions to create widgets */
1549 #ifdef ENERGIZE
1551 /* interface with the XDesigner generated functions */
1552 typedef Widget (*widget_maker) (Widget);
1553 extern Widget create_project_p_sheet (Widget parent);
1554 extern Widget create_debugger_p_sheet (Widget parent);
1555 extern Widget create_breaklist_p_sheet (Widget parent);
1556 extern Widget create_le_browser_p_sheet (Widget parent);
1557 extern Widget create_class_browser_p_sheet (Widget parent);
1558 extern Widget create_call_browser_p_sheet (Widget parent);
1559 extern Widget create_build_dialog (Widget parent);
1560 extern Widget create_editmode_dialog (Widget parent);
1561 extern Widget create_search_dialog (Widget parent);
1562 extern Widget create_project_display_dialog (Widget parent);
1564 static Widget
1565 make_one (widget_instance* instance, widget_maker fn)
1567 Widget result;
1568 Arg al [64];
1569 int ac = 0;
1571 if (instance->pop_up_p)
1573 XtSetArg (al [ac], XmNallowShellResize, TRUE); ac++;
1574 result = XmCreateDialogShell (instance->parent, "dialog", NULL, 0);
1575 XtAddCallback (result, XmNpopdownCallback, &xm_nosel_callback,
1576 (XtPointer) instance);
1577 (*fn) (result);
1579 else
1581 result = (*fn) (instance->parent);
1582 XtRealizeWidget (result);
1584 return result;
1587 static Widget
1588 make_project_p_sheet (widget_instance* instance)
1590 return make_one (instance, create_project_p_sheet);
1593 static Widget
1594 make_debugger_p_sheet (widget_instance* instance)
1596 return make_one (instance, create_debugger_p_sheet);
1599 static Widget
1600 make_breaklist_p_sheet (widget_instance* instance)
1602 return make_one (instance, create_breaklist_p_sheet);
1605 static Widget
1606 make_le_browser_p_sheet (widget_instance* instance)
1608 return make_one (instance, create_le_browser_p_sheet);
1611 static Widget
1612 make_class_browser_p_sheet (widget_instance* instance)
1614 return make_one (instance, create_class_browser_p_sheet);
1617 static Widget
1618 make_call_browser_p_sheet (widget_instance* instance)
1620 return make_one (instance, create_call_browser_p_sheet);
1623 static Widget
1624 make_build_dialog (widget_instance* instance)
1626 return make_one (instance, create_build_dialog);
1629 static Widget
1630 make_editmode_dialog (widget_instance* instance)
1632 return make_one (instance, create_editmode_dialog);
1635 static Widget
1636 make_search_dialog (widget_instance* instance)
1638 return make_one (instance, create_search_dialog);
1641 static Widget
1642 make_project_display_dialog (widget_instance* instance)
1644 return make_one (instance, create_project_display_dialog);
1647 #endif /* ENERGIZE */
1649 widget_creation_entry
1650 xm_creation_table [] =
1652 {"menubar", make_menubar},
1653 {"popup", make_popup_menu},
1654 {"main", make_main},
1655 #ifdef ENERGIZE
1656 {"project_p_sheet", make_project_p_sheet},
1657 {"debugger_p_sheet", make_debugger_p_sheet},
1658 {"breaklist_psheet", make_breaklist_p_sheet},
1659 {"leb_psheet", make_le_browser_p_sheet},
1660 {"class_browser_psheet", make_class_browser_p_sheet},
1661 {"ctree_browser_psheet", make_call_browser_p_sheet},
1662 {"build", make_build_dialog},
1663 {"editmode", make_editmode_dialog},
1664 {"search", make_search_dialog},
1665 {"project_display", make_project_display_dialog},
1666 #endif /* ENERGIZE */
1667 {NULL, NULL}
1670 \f/* Destruction of instances */
1671 void
1672 xm_destroy_instance ( widget_instance* instance)
1674 Widget widget = instance->widget;
1675 /* recycle the dialog boxes */
1676 /* Disable the recycling until we can find a way to have the dialog box
1677 get reasonable layout after we modify its contents. */
1678 if (0
1679 && XtClass (widget) == xmDialogShellWidgetClass)
1681 destroyed_instance* dead_instance =
1682 make_destroyed_instance (instance->info->name,
1683 instance->info->type,
1684 instance->widget,
1685 instance->parent,
1686 instance->pop_up_p);
1687 dead_instance->next = all_destroyed_instances;
1688 all_destroyed_instances = dead_instance;
1689 XtUnmanageChild (first_child (instance->widget));
1690 XFlush (XtDisplay (instance->widget));
1691 XtAddCallback (instance->parent, XtNdestroyCallback,
1692 mark_dead_instance_destroyed, (XtPointer)dead_instance);
1694 else
1696 /* This might not be necessary now that the nosel is attached to
1697 popdown instead of destroy, but it can't hurt. */
1698 XtRemoveCallback (instance->widget, XtNdestroyCallback,
1699 xm_nosel_callback, (XtPointer)instance);
1700 XtDestroyWidget (instance->widget);
1704 \f/* popup utility */
1705 void
1706 xm_popup_menu (Widget widget, XEvent *event)
1708 XButtonPressedEvent dummy;
1710 if (event == 0)
1712 dummy.type = ButtonPress;
1713 dummy.serial = 0;
1714 dummy.send_event = 0;
1715 dummy.display = XtDisplay (widget);
1716 dummy.window = XtWindow (XtParent (widget));
1717 dummy.time = 0;
1718 dummy.button = 0;
1719 XQueryPointer (dummy.display, dummy.window, &dummy.root,
1720 &dummy.subwindow, &dummy.x_root, &dummy.y_root,
1721 &dummy.x, &dummy.y, &dummy.state);
1722 event = (XEvent *) &dummy;
1725 if (event->type == ButtonPress || event->type == ButtonRelease)
1727 /* Setting the menuPost resource only required by Motif 1.1 and
1728 LessTif 0.84 and earlier. With later versions of LessTif,
1729 setting menuPost is unnecessary and may cause problems, so
1730 don't do it. */
1731 #if XmVersion < 1002 || (defined LESSTIF_VERSION && LESSTIF_VERSION < 84)
1733 /* This is so totally ridiculous: there's NO WAY to tell Motif
1734 that *any* button can select a menu item. Only one button
1735 can have that honor. */
1737 char *trans = 0;
1738 if (event->xbutton.state & Button5Mask) trans = "<Btn5Down>";
1739 else if (event->xbutton.state & Button4Mask) trans = "<Btn4Down>";
1740 else if (event->xbutton.state & Button3Mask) trans = "<Btn3Down>";
1741 else if (event->xbutton.state & Button2Mask) trans = "<Btn2Down>";
1742 else if (event->xbutton.state & Button1Mask) trans = "<Btn1Down>";
1743 if (trans) XtVaSetValues (widget, XmNmenuPost, trans, NULL);
1745 #endif
1747 XmMenuPosition (widget, (XButtonPressedEvent *) event);
1750 XtManageChild (widget);
1753 static void
1754 set_min_dialog_size (Widget w)
1756 short width;
1757 short height;
1758 XtVaGetValues (w, XmNwidth, &width, XmNheight, &height, NULL);
1759 XtVaSetValues (w, XmNminWidth, width, XmNminHeight, height, NULL);
1762 void
1763 xm_pop_instance (widget_instance* instance, Boolean up)
1765 Widget widget = instance->widget;
1767 if (XtClass (widget) == xmDialogShellWidgetClass)
1769 Widget widget_to_manage = first_child (widget);
1770 if (up)
1772 XtManageChild (widget_to_manage);
1773 set_min_dialog_size (widget);
1774 XtSetKeyboardFocus (instance->parent, widget);
1776 else
1777 XtUnmanageChild (widget_to_manage);
1779 else
1781 if (up)
1782 XtManageChild (widget);
1783 else
1784 XtUnmanageChild (widget);
1789 /* motif callback */
1791 static void
1792 do_call (Widget widget,
1793 XtPointer closure,
1794 enum do_call_type type)
1796 Arg al [256];
1797 int ac;
1798 XtPointer user_data;
1799 widget_instance* instance = (widget_instance*)closure;
1800 Widget instance_widget;
1801 LWLIB_ID id;
1803 if (!instance)
1804 return;
1805 if (widget->core.being_destroyed)
1806 return;
1808 instance_widget = instance->widget;
1809 if (!instance_widget)
1810 return;
1812 id = instance->info->id;
1813 ac = 0;
1814 user_data = NULL;
1815 XtSetArg (al [ac], XmNuserData, &user_data); ac++;
1816 XtGetValues (widget, al, ac);
1818 switch (type)
1820 case pre_activate:
1821 if (instance->info->pre_activate_cb)
1822 instance->info->pre_activate_cb (widget, id, user_data);
1823 break;
1825 case selection:
1826 if (instance->info->selection_cb)
1827 instance->info->selection_cb (widget, id, user_data);
1828 break;
1830 case no_selection:
1831 if (instance->info->selection_cb)
1832 instance->info->selection_cb (widget, id, (XtPointer) -1);
1833 break;
1835 case post_activate:
1836 if (instance->info->post_activate_cb)
1837 instance->info->post_activate_cb (widget, id, user_data);
1838 break;
1840 default:
1841 abort ();
1845 /* Like lw_internal_update_other_instances except that it does not do
1846 anything if its shell parent is not managed. This is to protect
1847 lw_internal_update_other_instances to dereference freed memory
1848 if the widget was ``destroyed'' by caching it in the all_destroyed_instances
1849 list */
1850 static void
1851 xm_internal_update_other_instances (Widget widget,
1852 XtPointer closure,
1853 XtPointer call_data)
1855 Widget parent;
1856 for (parent = widget; parent; parent = XtParent (parent))
1857 if (XtIsShell (parent))
1858 break;
1859 else if (!XtIsManaged (parent))
1860 return;
1861 lw_internal_update_other_instances (widget, closure, call_data);
1864 static void
1865 xm_generic_callback (Widget widget,
1866 XtPointer closure,
1867 XtPointer call_data)
1869 lw_internal_update_other_instances (widget, closure, call_data);
1870 do_call (widget, closure, selection);
1873 static void
1874 xm_nosel_callback (Widget widget,
1875 XtPointer closure,
1876 XtPointer call_data)
1878 /* This callback is only called when a dialog box is dismissed with
1879 the wm's destroy button (WM_DELETE_WINDOW.) We want the dialog
1880 box to be destroyed in that case, not just unmapped, so that it
1881 releases its keyboard grabs. But there are problems with running
1882 our callbacks while the widget is in the process of being
1883 destroyed, so we set XmNdeleteResponse to XmUNMAP instead of
1884 XmDESTROY and then destroy it ourself after having run the
1885 callback. */
1886 do_call (widget, closure, no_selection);
1887 XtDestroyWidget (widget);
1890 static void
1891 xm_pull_down_callback (Widget widget,
1892 XtPointer closure,
1893 XtPointer call_data)
1895 Widget parent = XtParent (widget);
1897 if (XmIsRowColumn (parent))
1899 unsigned char type = 0xff;
1900 XtVaGetValues (parent, XmNrowColumnType, &type, NULL);
1901 if (type == XmMENU_BAR)
1902 do_call (widget, closure, pre_activate);
1907 /* XmNpopdownCallback for MenuShell widgets. WIDGET is the MenuShell,
1908 CLOSURE is a pointer to the widget_instance of the shell,
1910 Note that this callback is called for each cascade button in a
1911 menu, whether or not its submenu is visible. */
1913 static void
1914 xm_pop_down_callback (Widget widget,
1915 XtPointer closure,
1916 XtPointer call_data)
1918 widget_instance *instance = (widget_instance *) closure;
1920 if ((!instance->pop_up_p && XtParent (widget) == instance->widget)
1921 || XtParent (widget) == instance->parent)
1922 do_call (widget, closure, post_activate);
1926 /* set the keyboard focus */
1927 void
1928 xm_set_keyboard_focus (Widget parent, Widget w)
1930 XmProcessTraversal (w, 0);
1931 XtSetKeyboardFocus (parent, w);
1934 /* Motif hack to set the main window areas. */
1935 void
1936 xm_set_main_areas (Widget parent,
1937 Widget menubar,
1938 Widget work_area)
1940 XmMainWindowSetAreas (parent,
1941 menubar, /* menubar (maybe 0) */
1942 0, /* command area (psheets) */
1943 0, /* horizontal scroll */
1944 0, /* vertical scroll */
1945 work_area); /* work area */
1948 /* Motif hack to control resizing on the menubar. */
1949 void
1950 xm_manage_resizing (Widget w, Boolean flag)
1952 XtVaSetValues (w, XtNallowShellResize, flag, NULL);