1 /* The lwlib interface to Motif widgets.
2 Copyright (C) 1992 Lucid, Inc.
4 This file is part of the Lucid Widget Library.
6 The Lucid Widget Library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 1, or (at your option)
11 The Lucid Widget Library is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
26 #include <X11/StringDefs.h>
27 #include <X11/IntrinsicP.h>
28 #include <X11/ObjectP.h>
29 #include <X11/CoreP.h>
30 #include <X11/CompositeP.h>
33 #include "lwlib-utils.h"
35 #include <Xm/BulletinB.h>
36 #include <Xm/CascadeB.h>
37 #include <Xm/CascadeBG.h>
38 #include <Xm/DrawingA.h>
39 #include <Xm/FileSB.h>
43 #include <Xm/MenuShell.h>
44 #include <Xm/MessageB.h>
45 #include <Xm/PanedW.h>
47 #include <Xm/PushBG.h>
48 #include <Xm/ArrowB.h>
49 #include <Xm/SelectioB.h>
52 #include <Xm/ToggleB.h>
53 #include <Xm/ToggleBG.h>
54 #include <Xm/RowColumn.h>
55 #include <Xm/ScrolledW.h>
56 #include <Xm/Separator.h>
57 #include <Xm/DialogS.h>
60 static void xm_pull_down_callback (/* Widget, XtPointer, XtPointer */);
61 static void xm_internal_update_other_instances (/* Widget, XtPointer,
63 static void xm_generic_callback (/* Widget, XtPointer, XtPointer */);
64 static void xm_nosel_callback (/* Widget, XtPointer, XtPointer */);
65 static void xm_pop_down_callback (/* Widget, XtPointer, XtPointer */);
67 static void xm_update_menu (/* widget_instance*, Widget, widget_value*,
71 \f/* Structures to keep destroyed instances */
72 typedef struct _destroyed_instance
79 struct _destroyed_instance
* next
;
82 static destroyed_instance
*
83 all_destroyed_instances
= NULL
;
85 static destroyed_instance
*
86 make_destroyed_instance (name
, type
, widget
, parent
, pop_up_p
)
93 destroyed_instance
* instance
=
94 (destroyed_instance
*)malloc (sizeof (destroyed_instance
));
95 instance
->name
= safe_strdup (name
);
96 instance
->type
= safe_strdup (type
);
97 instance
->widget
= widget
;
98 instance
->parent
= parent
;
99 instance
->pop_up_p
= pop_up_p
;
100 instance
->next
= NULL
;
105 free_destroyed_instance (instance
)
106 destroyed_instance
* instance
;
108 free (instance
->name
);
109 free (instance
->type
);
113 \f/* motif utility functions */
118 return ((CompositeWidget
)widget
)->composite
.children
[0];
122 lw_motif_widget_p (widget
)
126 XtClass (widget
) == xmDialogShellWidgetClass
127 || XmIsPrimitive (widget
) || XmIsManager (widget
) || XmIsGadget (widget
);
131 resource_motif_string (widget
, name
)
138 resource
.resource_name
= name
;
139 resource
.resource_class
= XmCXmString
;
140 resource
.resource_type
= XmRXmString
;
141 resource
.resource_size
= sizeof (XmString
);
142 resource
.resource_offset
= 0;
143 resource
.default_type
= XtRImmediate
;
144 resource
.default_addr
= 0;
146 XtGetSubresources (widget
, (XtPointer
)&result
, "dialogString",
147 "DialogString", &resource
, 1, NULL
, 0);
151 /* Destroy all of the children of WIDGET
152 starting with number FIRST_CHILD_TO_DESTROY. */
155 destroy_all_children (widget
, first_child_to_destroy
)
157 int first_child_to_destroy
;
163 children
= XtCompositeChildren (widget
, &number
);
166 XtUnmanageChildren (children
+ first_child_to_destroy
,
167 number
- first_child_to_destroy
);
169 /* Unmanage all children and destroy them. They will only be
170 really destroyed when we get out of DispatchEvent. */
171 for (i
= first_child_to_destroy
; i
< number
; i
++)
175 /* Cascade buttons have submenus,and these submenus
176 need to be freed. But they are not included in
177 XtCompositeChildren. So get it out of the cascade button
178 and free it. If this child is not a cascade button,
179 then submenu should remain unchanged. */
180 XtSetArg (al
[0], XmNsubMenuId
, &submenu
);
181 XtGetValues (children
[i
], al
, 1);
183 XtDestroyWidget (submenu
);
184 XtDestroyWidget (children
[i
]);
187 XtFree ((char *) children
);
191 \f/* update the label of anything subclass of a label */
193 xm_update_label (instance
, widget
, val
)
194 widget_instance
* instance
;
198 XmString res_string
= 0;
199 XmString built_string
= 0;
200 XmString key_string
= 0;
208 res_string
= resource_motif_string (widget
, val
->value
);
212 XtSetArg (al
[ac
], XmNlabelString
, res_string
); ac
++;
217 XmStringCreateLtoR (val
->value
, XmSTRING_DEFAULT_CHARSET
);
218 XtSetArg (al
[ac
], XmNlabelString
, built_string
); ac
++;
220 XtSetArg (al
[ac
], XmNlabelType
, XmSTRING
); ac
++;
225 key_string
= XmStringCreateLtoR (val
->key
, XmSTRING_DEFAULT_CHARSET
);
226 XtSetArg (al
[ac
], XmNacceleratorText
, key_string
); ac
++;
230 XtSetValues (widget
, al
, ac
);
233 XmStringFree (built_string
);
236 XmStringFree (key_string
);
239 \f/* update of list */
241 xm_update_list (instance
, widget
, val
)
242 widget_instance
* instance
;
248 XtRemoveAllCallbacks (widget
, XmNsingleSelectionCallback
);
249 XtAddCallback (widget
, XmNsingleSelectionCallback
, xm_generic_callback
,
251 for (cur
= val
->contents
, i
= 0; cur
; cur
= cur
->next
)
254 XmString xmstr
= XmStringCreate (cur
->value
, XmSTRING_DEFAULT_CHARSET
);
256 XmListAddItem (widget
, xmstr
, 0);
258 XmListSelectPos (widget
, i
, False
);
259 XmStringFree (xmstr
);
263 \f/* update of buttons */
265 xm_update_pushbutton (instance
, widget
, val
)
266 widget_instance
* instance
;
270 XtVaSetValues (widget
, XmNalignment
, XmALIGNMENT_CENTER
, 0);
271 XtRemoveAllCallbacks (widget
, XmNactivateCallback
);
272 XtAddCallback (widget
, XmNactivateCallback
, xm_generic_callback
, instance
);
276 xm_update_cascadebutton (instance
, widget
, val
)
277 widget_instance
* instance
;
281 /* Should also rebuild the menu by calling ...update_menu... */
282 XtRemoveAllCallbacks (widget
, XmNcascadingCallback
);
283 XtAddCallback (widget
, XmNcascadingCallback
, xm_pull_down_callback
,
287 \f/* update toggle and radiobox */
289 xm_update_toggle (instance
, widget
, val
)
290 widget_instance
* instance
;
294 XtRemoveAllCallbacks (widget
, XmNvalueChangedCallback
);
295 XtAddCallback (widget
, XmNvalueChangedCallback
,
296 xm_internal_update_other_instances
, instance
);
297 XtVaSetValues (widget
, XmNset
, val
->selected
,
298 XmNalignment
, XmALIGNMENT_BEGINNING
, 0);
302 xm_update_radiobox (instance
, widget
, val
)
303 widget_instance
* instance
;
311 /* update the callback */
312 XtRemoveAllCallbacks (widget
, XmNentryCallback
);
313 XtAddCallback (widget
, XmNentryCallback
, xm_generic_callback
, instance
);
315 /* first update all the toggles */
316 /* Energize kernel interface is currently bad. It sets the selected widget
317 with the selected flag but returns it by its name. So we currently
318 have to support both setting the selection with the selected slot
319 of val contents and setting it with the "value" slot of val. The latter
320 has a higher priority. This to be removed when the kernel is fixed. */
321 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
323 toggle
= XtNameToWidget (widget
, cur
->value
);
326 XtVaSetValues (toggle
, XmNsensitive
, cur
->enabled
, 0);
327 if (!val
->value
&& cur
->selected
)
328 XtVaSetValues (toggle
, XmNset
, cur
->selected
, 0);
329 if (val
->value
&& strcmp (val
->value
, cur
->value
))
330 XtVaSetValues (toggle
, XmNset
, False
, 0);
334 /* The selected was specified by the value slot */
337 toggle
= XtNameToWidget (widget
, val
->value
);
339 XtVaSetValues (toggle
, XmNset
, True
, 0);
343 \f/* update a popup menu, pulldown menu or a menubar */
355 /* KEEP_FIRST_CHILDREN gives the number of initial children to keep. */
358 make_menu_in_widget (instance
, widget
, val
, keep_first_children
)
359 widget_instance
* instance
;
362 int keep_first_children
;
364 Widget
* children
= 0;
374 Widget
* old_children
;
375 unsigned int old_num_children
;
377 old_children
= XtCompositeChildren (widget
, &old_num_children
);
379 /* Allocate the children array */
380 for (num_children
= 0, cur
= val
; cur
; num_children
++, cur
= cur
->next
);
381 children
= (Widget
*)XtMalloc (num_children
* sizeof (Widget
));
383 /* tricky way to know if this RowColumn is a menubar or a pulldown... */
385 XtSetArg (al
[0], XmNisHomogeneous
, &menubar_p
);
386 XtGetValues (widget
, al
, 1);
388 /* add the unmap callback for popups and pulldowns */
389 /*** this sounds bogus ***/
391 XtAddCallback (XtParent (widget
), XmNpopdownCallback
,
392 xm_pop_down_callback
, (XtPointer
)instance
);
394 /* Preserve the first KEEP_FIRST_CHILDREN old children. */
395 for (child_index
= 0, cur
= val
; child_index
< keep_first_children
;
396 child_index
++, cur
= cur
->next
)
397 children
[child_index
] = old_children
[child_index
];
399 /* Check that those are all we have
400 (the caller should have deleted the rest). */
401 if (old_num_children
!= keep_first_children
)
404 /* Create the rest. */
405 for (child_index
= keep_first_children
; cur
; child_index
++, cur
= cur
->next
)
408 XtSetArg (al
[ac
], XmNsensitive
, cur
->enabled
); ac
++;
409 XtSetArg (al
[ac
], XmNalignment
, XmALIGNMENT_BEGINNING
); ac
++;
410 XtSetArg (al
[ac
], XmNuserData
, cur
->call_data
); ac
++;
412 if (instance
->pop_up_p
&& !cur
->contents
&& !cur
->call_data
413 && !all_dashes_p (cur
->name
))
416 XtSetArg (al
[ac
], XmNalignment
, XmALIGNMENT_CENTER
); ac
++;
417 button
= XmCreateLabel (widget
, cur
->name
, al
, ac
);
419 else if (all_dashes_p (cur
->name
))
421 button
= XmCreateSeparator (widget
, cur
->name
, NULL
, 0);
423 else if (!cur
->contents
)
426 button
= XmCreateCascadeButton (widget
, cur
->name
, al
, ac
);
427 else if (!cur
->call_data
)
428 button
= XmCreateLabel (widget
, cur
->name
, al
, ac
);
430 button
= XmCreatePushButtonGadget (widget
, cur
->name
, al
, ac
);
432 xm_update_label (instance
, button
, cur
);
434 /* don't add a callback to a simple label */
436 XtAddCallback (button
, XmNactivateCallback
, xm_generic_callback
,
437 (XtPointer
)instance
);
441 menu
= XmCreatePulldownMenu (widget
, cur
->name
, NULL
, 0);
442 make_menu_in_widget (instance
, menu
, cur
->contents
, 0);
443 XtSetArg (al
[ac
], XmNsubMenuId
, menu
); ac
++;
444 /* non-zero values don't work reliably in
445 conjunction with Emacs' event loop */
446 XtSetArg (al
[ac
], XmNmappingDelay
, 0); ac
++;
447 button
= XmCreateCascadeButtonGadget (widget
, cur
->name
, al
, ac
);
449 xm_update_label (instance
, button
, cur
);
451 XtAddCallback (button
, XmNcascadingCallback
, xm_pull_down_callback
,
452 (XtPointer
)instance
);
455 children
[child_index
] = button
;
458 XtManageChildren (children
, num_children
);
460 /* Last entry is the help button. Has to be done after managing
461 * the buttons otherwise the menubar is only 4 pixels high... */
465 XtSetArg (al
[ac
], XmNmenuHelpWidget
, button
); ac
++;
466 XtSetValues (widget
, al
, ac
);
469 XtFree ((char *) children
);
471 XtFree ((char *) old_children
);
475 update_one_menu_entry (instance
, widget
, val
, deep_p
)
476 widget_instance
* instance
;
484 widget_value
* contents
;
486 if (val
->this_one_change
== NO_CHANGE
)
489 /* update the sensitivity and userdata */
490 /* Common to all widget types */
491 XtVaSetValues (widget
,
492 XmNsensitive
, val
->enabled
,
493 XmNuserData
, val
->call_data
,
496 /* update the menu button as a label. */
497 if (val
->this_one_change
>= VISIBLE_CHANGE
)
498 xm_update_label (instance
, widget
, val
);
500 /* update the pulldown/pullaside as needed */
503 XtSetArg (al
[ac
], XmNsubMenuId
, &menu
); ac
++;
504 XtGetValues (widget
, al
, ac
);
506 contents
= val
->contents
;
512 menu
= XmCreatePulldownMenu (XtParent (widget
), XtName (widget
), NULL
, 0);
513 make_menu_in_widget (instance
, menu
, contents
, 0);
515 XtSetArg (al
[ac
], XmNsubMenuId
, menu
); ac
++;
516 XtSetValues (widget
, al
, ac
);
522 XtSetArg (al
[ac
], XmNsubMenuId
, NULL
); ac
++;
523 XtSetValues (widget
, al
, ac
);
524 XtDestroyWidget (menu
);
526 else if (deep_p
&& contents
->change
!= NO_CHANGE
)
527 xm_update_menu (instance
, menu
, val
, 1);
531 xm_update_menu (instance
, widget
, val
, deep_p
)
532 widget_instance
* instance
;
538 unsigned int num_children
;
539 int num_children_to_keep
= 0;
543 children
= XtCompositeChildren (widget
, &num_children
);
545 /* Widget is a RowColumn widget whose contents have to be updated
546 * to reflect the list of items in val->contents */
548 /* See how many buttons we can keep, and how many we
549 must completely replace. */
550 if (val
->contents
== 0)
551 num_children_to_keep
= 0;
552 else if (val
->contents
->change
== STRUCTURAL_CHANGE
)
556 for (i
= 0, cur
= val
->contents
; i
< num_children
;
557 i
++, cur
= cur
->next
)
559 if (cur
->this_one_change
== STRUCTURAL_CHANGE
)
563 num_children_to_keep
= i
;
567 num_children_to_keep
= num_children
;
569 /* Update all the buttons of the RowColumn, in order,
570 except for those we are going to replace entirely. */
573 for (i
= 0, cur
= val
->contents
; i
< num_children_to_keep
; i
++)
577 if (children
[i
]->core
.being_destroyed
578 || strcmp (XtName (children
[i
]), cur
->name
))
580 update_one_menu_entry (instance
, children
[i
], cur
, deep_p
);
585 /* Now replace from scratch all the buttons after the last
586 place that the top-level structure changed. */
587 if (val
->contents
->change
== STRUCTURAL_CHANGE
)
589 destroy_all_children (widget
, num_children_to_keep
);
590 make_menu_in_widget (instance
, widget
, val
->contents
,
591 num_children_to_keep
);
594 XtFree ((char *) children
);
598 /* update text widgets */
601 xm_update_text (instance
, widget
, val
)
602 widget_instance
* instance
;
606 XmTextSetString (widget
, val
->value
? val
->value
: "");
607 XtRemoveAllCallbacks (widget
, XmNactivateCallback
);
608 XtAddCallback (widget
, XmNactivateCallback
, xm_generic_callback
, instance
);
609 XtRemoveAllCallbacks (widget
, XmNvalueChangedCallback
);
610 XtAddCallback (widget
, XmNvalueChangedCallback
,
611 xm_internal_update_other_instances
, instance
);
615 xm_update_text_field (instance
, widget
, val
)
616 widget_instance
* instance
;
620 XmTextFieldSetString (widget
, val
->value
? val
->value
: "");
621 XtRemoveAllCallbacks (widget
, XmNactivateCallback
);
622 XtAddCallback (widget
, XmNactivateCallback
, xm_generic_callback
, instance
);
623 XtRemoveAllCallbacks (widget
, XmNvalueChangedCallback
);
624 XtAddCallback (widget
, XmNvalueChangedCallback
,
625 xm_internal_update_other_instances
, instance
);
629 /* update a motif widget */
632 xm_update_one_widget (instance
, widget
, val
, deep_p
)
633 widget_instance
* instance
;
640 /* Mark as not edited */
643 /* Common to all widget types */
644 XtVaSetValues (widget
,
645 XmNsensitive
, val
->enabled
,
646 XmNuserData
, val
->call_data
,
649 /* Common to all label like widgets */
650 if (XtIsSubclass (widget
, xmLabelWidgetClass
))
651 xm_update_label (instance
, widget
, val
);
653 class = XtClass (widget
);
654 /* Class specific things */
655 if (class == xmPushButtonWidgetClass
||
656 class == xmArrowButtonWidgetClass
)
658 xm_update_pushbutton (instance
, widget
, val
);
660 else if (class == xmCascadeButtonWidgetClass
)
662 xm_update_cascadebutton (instance
, widget
, val
);
664 else if (class == xmToggleButtonWidgetClass
665 || class == xmToggleButtonGadgetClass
)
667 xm_update_toggle (instance
, widget
, val
);
669 else if (class == xmRowColumnWidgetClass
)
671 Boolean radiobox
= 0;
675 XtSetArg (al
[ac
], XmNradioBehavior
, &radiobox
); ac
++;
676 XtGetValues (widget
, al
, ac
);
679 xm_update_radiobox (instance
, widget
, val
);
681 xm_update_menu (instance
, widget
, val
, deep_p
);
683 else if (class == xmTextWidgetClass
)
685 xm_update_text (instance
, widget
, val
);
687 else if (class == xmTextFieldWidgetClass
)
689 xm_update_text_field (instance
, widget
, val
);
691 else if (class == xmListWidgetClass
)
693 xm_update_list (instance
, widget
, val
);
697 \f/* getting the value back */
699 xm_update_one_value (instance
, widget
, val
)
700 widget_instance
* instance
;
704 WidgetClass
class = XtClass (widget
);
705 widget_value
*old_wv
;
707 /* copy the call_data slot into the "return" widget_value */
708 for (old_wv
= instance
->info
->val
->contents
; old_wv
; old_wv
= old_wv
->next
)
709 if (!strcmp (val
->name
, old_wv
->name
))
711 val
->call_data
= old_wv
->call_data
;
715 if (class == xmToggleButtonWidgetClass
|| class == xmToggleButtonGadgetClass
)
717 XtVaGetValues (widget
, XmNset
, &val
->selected
, 0);
720 else if (class == xmTextWidgetClass
)
724 val
->value
= XmTextGetString (widget
);
727 else if (class == xmTextFieldWidgetClass
)
731 val
->value
= XmTextFieldGetString (widget
);
734 else if (class == xmRowColumnWidgetClass
)
736 Boolean radiobox
= 0;
740 XtSetArg (al
[ac
], XmNradioBehavior
, &radiobox
); ac
++;
741 XtGetValues (widget
, al
, ac
);
745 CompositeWidget radio
= (CompositeWidget
)widget
;
747 for (i
= 0; i
< radio
->composite
.num_children
; i
++)
750 Widget toggle
= radio
->composite
.children
[i
];
752 XtVaGetValues (toggle
, XmNset
, &set
, 0);
757 val
->value
= safe_strdup (XtName (toggle
));
763 else if (class == xmListWidgetClass
)
767 if (XmListGetSelectedPos (widget
, &pos_list
, &pos_cnt
))
771 for (cur
= val
->contents
, i
= 0; cur
; cur
= cur
->next
)
775 cur
->selected
= False
;
777 for (j
= 0; j
< pos_cnt
; j
++)
778 if (pos_list
[j
] == i
)
780 cur
->selected
= True
;
781 val
->value
= safe_strdup (cur
->name
);
785 XtFree ((char *) pos_list
);
791 /* This function is for activating a button from a program. It's wrong because
792 we pass a NULL argument in the call_data which is not Motif compatible.
793 This is used from the XmNdefaultAction callback of the List widgets to
794 have a double-click put down a dialog box like the button would do.
795 I could not find a way to do that with accelerators.
798 activate_button (widget
, closure
, call_data
)
803 Widget button
= (Widget
)closure
;
804 XtCallCallbacks (button
, XmNactivateCallback
, NULL
);
807 /* creation functions */
811 make_dialog (name
, parent
, pop_up_p
, shell_title
, icon_name
, text_input_slot
,
812 radio_box
, list
, left_buttons
, right_buttons
)
818 Boolean text_input_slot
;
828 Widget icon_separator
;
833 Widget children
[16]; /* for the final XtManageChildren */
835 Arg al
[64]; /* Arg List */
836 int ac
; /* Arg Count */
842 XtSetArg(al
[ac
], XmNtitle
, shell_title
); ac
++;
843 XtSetArg(al
[ac
], XtNallowShellResize
, True
); ac
++;
844 XtSetArg(al
[ac
], XmNdeleteResponse
, XmUNMAP
); ac
++;
845 result
= XmCreateDialogShell (parent
, "dialog", al
, ac
);
847 XtSetArg(al
[ac
], XmNautoUnmanage
, FALSE
); ac
++;
848 /* XtSetArg(al[ac], XmNautoUnmanage, TRUE); ac++; */ /* ####is this ok? */
849 XtSetArg(al
[ac
], XmNnavigationType
, XmTAB_GROUP
); ac
++;
850 form
= XmCreateForm (result
, shell_title
, al
, ac
);
855 XtSetArg(al
[ac
], XmNautoUnmanage
, FALSE
); ac
++;
856 XtSetArg(al
[ac
], XmNnavigationType
, XmTAB_GROUP
); ac
++;
857 form
= XmCreateForm (parent
, shell_title
, al
, ac
);
861 n_children
= left_buttons
+ right_buttons
+ 1;
863 XtSetArg(al
[ac
], XmNpacking
, n_children
== 3?
864 XmPACK_COLUMN
: XmPACK_TIGHT
); ac
++;
865 XtSetArg(al
[ac
], XmNorientation
, n_children
== 3?
866 XmVERTICAL
: XmHORIZONTAL
); ac
++;
867 XtSetArg(al
[ac
], XmNnumColumns
, left_buttons
+ right_buttons
+ 1); ac
++;
868 XtSetArg(al
[ac
], XmNmarginWidth
, 0); ac
++;
869 XtSetArg(al
[ac
], XmNmarginHeight
, 0); ac
++;
870 XtSetArg(al
[ac
], XmNspacing
, 13); ac
++;
871 XtSetArg(al
[ac
], XmNadjustLast
, False
); ac
++;
872 XtSetArg(al
[ac
], XmNalignment
, XmALIGNMENT_CENTER
); ac
++;
873 XtSetArg(al
[ac
], XmNisAligned
, True
); ac
++;
874 XtSetArg(al
[ac
], XmNtopAttachment
, XmATTACH_NONE
); ac
++;
875 XtSetArg(al
[ac
], XmNbottomAttachment
, XmATTACH_FORM
); ac
++;
876 XtSetArg(al
[ac
], XmNbottomOffset
, 13); ac
++;
877 XtSetArg(al
[ac
], XmNleftAttachment
, XmATTACH_FORM
); ac
++;
878 XtSetArg(al
[ac
], XmNleftOffset
, 13); ac
++;
879 XtSetArg(al
[ac
], XmNrightAttachment
, XmATTACH_FORM
); ac
++;
880 XtSetArg(al
[ac
], XmNrightOffset
, 13); ac
++;
881 row
= XmCreateRowColumn (form
, "row", al
, ac
);
884 for (i
= 0; i
< left_buttons
; i
++)
886 char button_name
[16];
887 sprintf (button_name
, "button%d", i
+ 1);
891 XtSetArg(al
[ac
], XmNhighlightThickness
, 1); ac
++;
892 XtSetArg(al
[ac
], XmNshowAsDefault
, TRUE
); ac
++;
894 XtSetArg(al
[ac
], XmNmarginWidth
, 10); ac
++;
895 XtSetArg(al
[ac
], XmNnavigationType
, XmTAB_GROUP
); ac
++;
896 children
[n_children
] = XmCreatePushButton (row
, button_name
, al
, ac
);
900 button
= children
[n_children
];
902 XtSetArg(al
[ac
], XmNdefaultButton
, button
); ac
++;
903 XtSetValues (row
, al
, ac
);
909 /* invisible separator button */
911 XtSetArg (al
[ac
], XmNmappedWhenManaged
, FALSE
); ac
++;
912 children
[n_children
] = XmCreateLabel (row
, "separator_button", al
, ac
);
915 for (i
= 0; i
< right_buttons
; i
++)
917 char button_name
[16];
918 sprintf (button_name
, "button%d", left_buttons
+ i
+ 1);
920 XtSetArg(al
[ac
], XmNmarginWidth
, 10); ac
++;
921 XtSetArg(al
[ac
], XmNnavigationType
, XmTAB_GROUP
); ac
++;
922 children
[n_children
] = XmCreatePushButton (row
, button_name
, al
, ac
);
923 if (! button
) button
= children
[n_children
];
927 XtManageChildren (children
, n_children
);
930 XtSetArg(al
[ac
], XmNtopAttachment
, XmATTACH_NONE
); ac
++;
931 XtSetArg(al
[ac
], XmNbottomAttachment
, XmATTACH_WIDGET
); ac
++;
932 XtSetArg(al
[ac
], XmNbottomOffset
, 13); ac
++;
933 XtSetArg(al
[ac
], XmNbottomWidget
, row
); ac
++;
934 XtSetArg(al
[ac
], XmNleftAttachment
, XmATTACH_FORM
); ac
++;
935 XtSetArg(al
[ac
], XmNleftOffset
, 0); ac
++;
936 XtSetArg(al
[ac
], XmNrightAttachment
, XmATTACH_FORM
); ac
++;
937 XtSetArg(al
[ac
], XmNrightOffset
, 0); ac
++;
938 separator
= XmCreateSeparator (form
, "", al
, ac
);
941 XtSetArg(al
[ac
], XmNlabelType
, XmPIXMAP
); ac
++;
942 XtSetArg(al
[ac
], XmNtopAttachment
, XmATTACH_FORM
); ac
++;
943 XtSetArg(al
[ac
], XmNtopOffset
, 13); ac
++;
944 XtSetArg(al
[ac
], XmNbottomAttachment
, XmATTACH_NONE
); ac
++;
945 XtSetArg(al
[ac
], XmNleftAttachment
, XmATTACH_FORM
); ac
++;
946 XtSetArg(al
[ac
], XmNleftOffset
, 13); ac
++;
947 XtSetArg(al
[ac
], XmNrightAttachment
, XmATTACH_NONE
); ac
++;
948 icon
= XmCreateLabel (form
, icon_name
, al
, ac
);
951 XtSetArg(al
[ac
], XmNmappedWhenManaged
, FALSE
); ac
++;
952 XtSetArg(al
[ac
], XmNtopAttachment
, XmATTACH_WIDGET
); ac
++;
953 XtSetArg(al
[ac
], XmNtopOffset
, 6); ac
++;
954 XtSetArg(al
[ac
], XmNtopWidget
, icon
); ac
++;
955 XtSetArg(al
[ac
], XmNbottomAttachment
, XmATTACH_WIDGET
); ac
++;
956 XtSetArg(al
[ac
], XmNbottomOffset
, 6); ac
++;
957 XtSetArg(al
[ac
], XmNbottomWidget
, separator
); ac
++;
958 XtSetArg(al
[ac
], XmNleftAttachment
, XmATTACH_NONE
); ac
++;
959 XtSetArg(al
[ac
], XmNrightAttachment
, XmATTACH_NONE
); ac
++;
960 icon_separator
= XmCreateLabel (form
, "", al
, ac
);
965 XtSetArg(al
[ac
], XmNcolumns
, 50); ac
++;
966 XtSetArg(al
[ac
], XmNtopAttachment
, XmATTACH_NONE
); ac
++;
967 XtSetArg(al
[ac
], XmNbottomAttachment
, XmATTACH_WIDGET
); ac
++;
968 XtSetArg(al
[ac
], XmNbottomOffset
, 13); ac
++;
969 XtSetArg(al
[ac
], XmNbottomWidget
, separator
); ac
++;
970 XtSetArg(al
[ac
], XmNleftAttachment
, XmATTACH_WIDGET
); ac
++;
971 XtSetArg(al
[ac
], XmNleftOffset
, 13); ac
++;
972 XtSetArg(al
[ac
], XmNleftWidget
, icon
); ac
++;
973 XtSetArg(al
[ac
], XmNrightAttachment
, XmATTACH_FORM
); ac
++;
974 XtSetArg(al
[ac
], XmNrightOffset
, 13); ac
++;
975 value
= XmCreateTextField (form
, "value", al
, ac
);
981 XtSetArg(al
[ac
], XmNmarginWidth
, 0); ac
++;
982 XtSetArg(al
[ac
], XmNmarginHeight
, 0); ac
++;
983 XtSetArg(al
[ac
], XmNspacing
, 13); ac
++;
984 XtSetArg(al
[ac
], XmNalignment
, XmALIGNMENT_CENTER
); ac
++;
985 XtSetArg(al
[ac
], XmNorientation
, XmHORIZONTAL
); ac
++;
986 XtSetArg(al
[ac
], XmNbottomAttachment
, XmATTACH_WIDGET
); ac
++;
987 XtSetArg(al
[ac
], XmNbottomOffset
, 13); ac
++;
988 XtSetArg(al
[ac
], XmNbottomWidget
, separator
); ac
++;
989 XtSetArg(al
[ac
], XmNleftAttachment
, XmATTACH_WIDGET
); ac
++;
990 XtSetArg(al
[ac
], XmNleftOffset
, 13); ac
++;
991 XtSetArg(al
[ac
], XmNleftWidget
, icon
); ac
++;
992 XtSetArg(al
[ac
], XmNrightAttachment
, XmATTACH_FORM
); ac
++;
993 XtSetArg(al
[ac
], XmNrightOffset
, 13); ac
++;
994 value
= XmCreateRadioBox (form
, "radiobutton1", al
, ac
);
997 radio_butt
= XmCreateToggleButtonGadget (value
, "radio1", al
, ac
);
998 children
[i
++] = radio_butt
;
999 radio_butt
= XmCreateToggleButtonGadget (value
, "radio2", al
, ac
);
1000 children
[i
++] = radio_butt
;
1001 radio_butt
= XmCreateToggleButtonGadget (value
, "radio3", al
, ac
);
1002 children
[i
++] = radio_butt
;
1003 XtManageChildren (children
, i
);
1008 XtSetArg(al
[ac
], XmNvisibleItemCount
, 5); ac
++;
1009 XtSetArg(al
[ac
], XmNtopAttachment
, XmATTACH_NONE
); ac
++;
1010 XtSetArg(al
[ac
], XmNbottomAttachment
, XmATTACH_WIDGET
); ac
++;
1011 XtSetArg(al
[ac
], XmNbottomOffset
, 13); ac
++;
1012 XtSetArg(al
[ac
], XmNbottomWidget
, separator
); ac
++;
1013 XtSetArg(al
[ac
], XmNleftAttachment
, XmATTACH_WIDGET
); ac
++;
1014 XtSetArg(al
[ac
], XmNleftOffset
, 13); ac
++;
1015 XtSetArg(al
[ac
], XmNleftWidget
, icon
); ac
++;
1016 XtSetArg(al
[ac
], XmNrightAttachment
, XmATTACH_FORM
); ac
++;
1017 XtSetArg(al
[ac
], XmNrightOffset
, 13); ac
++;
1018 value
= XmCreateScrolledList (form
, "list", al
, ac
);
1020 /* this is the easiest way I found to have the dble click in the
1021 list activate the default button */
1022 XtAddCallback (value
, XmNdefaultActionCallback
, activate_button
, button
);
1026 XtSetArg(al
[ac
], XmNalignment
, XmALIGNMENT_BEGINNING
); ac
++;
1027 XtSetArg(al
[ac
], XmNtopAttachment
, XmATTACH_FORM
); ac
++;
1028 XtSetArg(al
[ac
], XmNtopOffset
, 13); ac
++;
1029 XtSetArg(al
[ac
], XmNbottomAttachment
, XmATTACH_WIDGET
); ac
++;
1030 XtSetArg(al
[ac
], XmNbottomOffset
, 13); ac
++;
1031 XtSetArg(al
[ac
], XmNbottomWidget
,
1032 text_input_slot
|| radio_box
|| list
? value
: separator
); ac
++;
1033 XtSetArg(al
[ac
], XmNleftAttachment
, XmATTACH_WIDGET
); ac
++;
1034 XtSetArg(al
[ac
], XmNleftOffset
, 13); ac
++;
1035 XtSetArg(al
[ac
], XmNleftWidget
, icon
); ac
++;
1036 XtSetArg(al
[ac
], XmNrightAttachment
, XmATTACH_FORM
); ac
++;
1037 XtSetArg(al
[ac
], XmNrightOffset
, 13); ac
++;
1038 message
= XmCreateLabel (form
, "message", al
, ac
);
1041 XtManageChild (value
);
1044 children
[i
] = row
; i
++;
1045 children
[i
] = separator
; i
++;
1046 if (text_input_slot
|| radio_box
)
1048 children
[i
] = value
; i
++;
1050 children
[i
] = message
; i
++;
1051 children
[i
] = icon
; i
++;
1052 children
[i
] = icon_separator
; i
++;
1053 XtManageChildren (children
, i
);
1055 if (text_input_slot
|| list
)
1057 XtInstallAccelerators (value
, button
);
1058 XtSetKeyboardFocus (result
, value
);
1062 XtInstallAccelerators (form
, button
);
1063 XtSetKeyboardFocus (result
, button
);
1069 static destroyed_instance
*
1070 find_matching_instance (instance
)
1071 widget_instance
* instance
;
1073 destroyed_instance
* cur
;
1074 destroyed_instance
* prev
;
1075 char* type
= instance
->info
->type
;
1076 char* name
= instance
->info
->name
;
1078 for (prev
= NULL
, cur
= all_destroyed_instances
;
1080 prev
= cur
, cur
= cur
->next
)
1082 if (!strcmp (cur
->name
, name
)
1083 && !strcmp (cur
->type
, type
)
1084 && cur
->parent
== instance
->parent
1085 && cur
->pop_up_p
== instance
->pop_up_p
)
1088 prev
->next
= cur
->next
;
1090 all_destroyed_instances
= cur
->next
;
1093 /* do some cleanup */
1094 else if (!cur
->widget
)
1097 prev
->next
= cur
->next
;
1099 all_destroyed_instances
= cur
->next
;
1100 free_destroyed_instance (cur
);
1101 cur
= prev
? prev
: all_destroyed_instances
;
1108 mark_dead_instance_destroyed (widget
, closure
, call_data
)
1111 XtPointer call_data
;
1113 destroyed_instance
* instance
= (destroyed_instance
*)closure
;
1114 instance
->widget
= NULL
;
1118 recenter_widget (widget
)
1121 Widget parent
= XtParent (widget
);
1122 Screen
* screen
= XtScreen (widget
);
1123 Dimension screen_width
= WidthOfScreen (screen
);
1124 Dimension screen_height
= HeightOfScreen (screen
);
1125 Dimension parent_width
= 0;
1126 Dimension parent_height
= 0;
1127 Dimension child_width
= 0;
1128 Dimension child_height
= 0;
1132 XtVaGetValues (widget
, XtNwidth
, &child_width
, XtNheight
, &child_height
, 0);
1133 XtVaGetValues (parent
, XtNwidth
, &parent_width
, XtNheight
, &parent_height
,
1136 x
= (((Position
)parent_width
) - ((Position
)child_width
)) / 2;
1137 y
= (((Position
)parent_height
) - ((Position
)child_height
)) / 2;
1139 XtTranslateCoords (parent
, x
, y
, &x
, &y
);
1141 if (x
+ child_width
> screen_width
)
1142 x
= screen_width
- child_width
;
1146 if (y
+ child_height
> screen_height
)
1147 y
= screen_height
- child_height
;
1151 XtVaSetValues (widget
, XtNx
, x
, XtNy
, y
, 0);
1155 recycle_instance (instance
)
1156 destroyed_instance
* instance
;
1158 Widget widget
= instance
->widget
;
1160 /* widget is NULL if the parent was destroyed. */
1166 /* Remove the destroy callback as the instance is not in the list
1168 XtRemoveCallback (instance
->parent
, XtNdestroyCallback
,
1169 mark_dead_instance_destroyed
,
1170 (XtPointer
)instance
);
1172 /* Give the focus to the initial item */
1173 focus
= XtNameToWidget (widget
, "*value");
1175 focus
= XtNameToWidget (widget
, "*button1");
1177 XtSetKeyboardFocus (widget
, focus
);
1179 /* shrink the separator label back to their original size */
1180 separator
= XtNameToWidget (widget
, "*separator_button");
1182 XtVaSetValues (separator
, XtNwidth
, 5, XtNheight
, 5, 0);
1184 /* Center the dialog in its parent */
1185 recenter_widget (widget
);
1187 free_destroyed_instance (instance
);
1192 xm_create_dialog (instance
)
1193 widget_instance
* instance
;
1195 char* name
= instance
->info
->type
;
1196 Widget parent
= instance
->parent
;
1198 Boolean pop_up_p
= instance
->pop_up_p
;
1199 char* shell_name
= 0;
1201 Boolean text_input_slot
= False
;
1202 Boolean radio_box
= False
;
1203 Boolean list
= False
;
1205 int left_buttons
= 0;
1206 int right_buttons
= 1;
1207 destroyed_instance
* dead_one
;
1209 /* try to find a widget to recycle */
1210 dead_one
= find_matching_instance (instance
);
1213 Widget recycled_widget
= recycle_instance (dead_one
);
1214 if (recycled_widget
)
1215 return recycled_widget
;
1220 icon_name
= "dbox-error";
1221 shell_name
= "Error";
1225 icon_name
= "dbox-info";
1226 shell_name
= "Information";
1231 icon_name
= "dbox-question";
1232 shell_name
= "Prompt";
1236 text_input_slot
= True
;
1237 icon_name
= "dbox-question";
1238 shell_name
= "Prompt";
1242 icon_name
= "dbox-question";
1243 shell_name
= "Question";
1247 total_buttons
= name
[1] - '0';
1249 if (name
[3] == 'T' || name
[3] == 't')
1251 text_input_slot
= False
;
1255 right_buttons
= name
[4] - '0';
1257 left_buttons
= total_buttons
- right_buttons
;
1259 widget
= make_dialog (name
, parent
, pop_up_p
,
1260 shell_name
, icon_name
, text_input_slot
, radio_box
,
1261 list
, left_buttons
, right_buttons
);
1263 XtAddCallback (widget
, XmNpopdownCallback
, xm_nosel_callback
,
1264 (XtPointer
) instance
);
1269 make_menubar (instance
)
1270 widget_instance
* instance
;
1272 return XmCreateMenuBar (instance
->parent
, instance
->info
->name
, NULL
, 0);
1276 remove_grabs (shell
, closure
, call_data
)
1279 XtPointer call_data
;
1281 Widget menu
= (Widget
) closure
;
1282 XmRemoveFromPostFromList (menu
, XtParent (XtParent (menu
)));
1286 make_popup_menu (instance
)
1287 widget_instance
* instance
;
1289 Widget parent
= instance
->parent
;
1290 Window parent_window
= parent
->core
.window
;
1293 /* sets the parent window to 0 to fool Motif into not generating a grab */
1294 parent
->core
.window
= 0;
1295 result
= XmCreatePopupMenu (parent
, instance
->info
->name
, NULL
, 0);
1296 XtAddCallback (XtParent (result
), XmNpopdownCallback
, remove_grabs
,
1298 parent
->core
.window
= parent_window
;
1302 make_main (instance
)
1303 widget_instance
* instance
;
1305 Widget parent
= instance
->parent
;
1311 XtSetArg (al
[ac
], XtNborderWidth
, 0); ac
++;
1312 XtSetArg (al
[ac
], XmNspacing
, 0); ac
++;
1313 result
= XmCreateMainWindow (parent
, instance
->info
->name
, al
, ac
);
1317 \f/* Table of functions to create widgets */
1321 /* interface with the XDesigner generated functions */
1322 typedef Widget (*widget_maker
) (Widget
);
1323 extern Widget
create_project_p_sheet (Widget parent
);
1324 extern Widget
create_debugger_p_sheet (Widget parent
);
1325 extern Widget
create_breaklist_p_sheet (Widget parent
);
1326 extern Widget
create_le_browser_p_sheet (Widget parent
);
1327 extern Widget
create_class_browser_p_sheet (Widget parent
);
1328 extern Widget
create_call_browser_p_sheet (Widget parent
);
1329 extern Widget
create_build_dialog (Widget parent
);
1330 extern Widget
create_editmode_dialog (Widget parent
);
1331 extern Widget
create_search_dialog (Widget parent
);
1332 extern Widget
create_project_display_dialog (Widget parent
);
1335 make_one (widget_instance
* instance
, widget_maker fn
)
1341 if (instance
->pop_up_p
)
1343 XtSetArg (al
[ac
], XmNallowShellResize
, TRUE
); ac
++;
1344 result
= XmCreateDialogShell (instance
->parent
, "dialog", NULL
, 0);
1345 XtAddCallback (result
, XmNpopdownCallback
, &xm_nosel_callback
,
1346 (XtPointer
) instance
);
1351 result
= (*fn
) (instance
->parent
);
1352 XtRealizeWidget (result
);
1358 make_project_p_sheet (widget_instance
* instance
)
1360 return make_one (instance
, create_project_p_sheet
);
1364 make_debugger_p_sheet (widget_instance
* instance
)
1366 return make_one (instance
, create_debugger_p_sheet
);
1370 make_breaklist_p_sheet (widget_instance
* instance
)
1372 return make_one (instance
, create_breaklist_p_sheet
);
1376 make_le_browser_p_sheet (widget_instance
* instance
)
1378 return make_one (instance
, create_le_browser_p_sheet
);
1382 make_class_browser_p_sheet (widget_instance
* instance
)
1384 return make_one (instance
, create_class_browser_p_sheet
);
1388 make_call_browser_p_sheet (widget_instance
* instance
)
1390 return make_one (instance
, create_call_browser_p_sheet
);
1394 make_build_dialog (widget_instance
* instance
)
1396 return make_one (instance
, create_build_dialog
);
1400 make_editmode_dialog (widget_instance
* instance
)
1402 return make_one (instance
, create_editmode_dialog
);
1406 make_search_dialog (widget_instance
* instance
)
1408 return make_one (instance
, create_search_dialog
);
1412 make_project_display_dialog (widget_instance
* instance
)
1414 return make_one (instance
, create_project_display_dialog
);
1417 #endif /* ENERGIZE */
1419 widget_creation_entry
1420 xm_creation_table
[] =
1422 {"menubar", make_menubar
},
1423 {"popup", make_popup_menu
},
1424 {"main", make_main
},
1426 {"project_p_sheet", make_project_p_sheet
},
1427 {"debugger_p_sheet", make_debugger_p_sheet
},
1428 {"breaklist_psheet", make_breaklist_p_sheet
},
1429 {"leb_psheet", make_le_browser_p_sheet
},
1430 {"class_browser_psheet", make_class_browser_p_sheet
},
1431 {"ctree_browser_psheet", make_call_browser_p_sheet
},
1432 {"build", make_build_dialog
},
1433 {"editmode", make_editmode_dialog
},
1434 {"search", make_search_dialog
},
1435 {"project_display", make_project_display_dialog
},
1436 #endif /* ENERGIZE */
1440 \f/* Destruction of instances */
1442 xm_destroy_instance (instance
)
1443 widget_instance
* instance
;
1445 Widget widget
= instance
->widget
;
1446 /* recycle the dialog boxes */
1447 /* Disable the recycling until we can find a way to have the dialog box
1448 get reasonable layout after we modify its contents. */
1450 && XtClass (widget
) == xmDialogShellWidgetClass
)
1452 destroyed_instance
* dead_instance
=
1453 make_destroyed_instance (instance
->info
->name
,
1454 instance
->info
->type
,
1457 instance
->pop_up_p
);
1458 dead_instance
->next
= all_destroyed_instances
;
1459 all_destroyed_instances
= dead_instance
;
1460 XtUnmanageChild (first_child (instance
->widget
));
1461 XFlush (XtDisplay (instance
->widget
));
1462 XtAddCallback (instance
->parent
, XtNdestroyCallback
,
1463 mark_dead_instance_destroyed
, (XtPointer
)dead_instance
);
1467 /* This might not be necessary now that the nosel is attached to
1468 popdown instead of destroy, but it can't hurt. */
1469 XtRemoveCallback (instance
->widget
, XtNdestroyCallback
,
1470 xm_nosel_callback
, (XtPointer
)instance
);
1471 XtDestroyWidget (instance
->widget
);
1475 \f/* popup utility */
1477 xm_popup_menu (widget
, event
)
1481 XButtonPressedEvent dummy
;
1485 dummy
.type
= ButtonPress
;
1487 dummy
.send_event
= 0;
1488 dummy
.display
= XtDisplay (widget
);
1489 dummy
.window
= XtWindow (XtParent (widget
));
1492 XQueryPointer (dummy
.display
, dummy
.window
, &dummy
.root
,
1493 &dummy
.subwindow
, &dummy
.x_root
, &dummy
.y_root
,
1494 &dummy
.x
, &dummy
.y
, &dummy
.state
);
1495 event
= (XEvent
*) &dummy
;
1498 if (event
->type
== ButtonPress
|| event
->type
== ButtonRelease
)
1500 /* This is so totally ridiculous: there's NO WAY to tell Motif
1501 that *any* button can select a menu item. Only one button
1502 can have that honor.
1505 if (event
->xbutton
.state
& Button5Mask
) trans
= "<Btn5Down>";
1506 else if (event
->xbutton
.state
& Button4Mask
) trans
= "<Btn4Down>";
1507 else if (event
->xbutton
.state
& Button3Mask
) trans
= "<Btn3Down>";
1508 else if (event
->xbutton
.state
& Button2Mask
) trans
= "<Btn2Down>";
1509 else if (event
->xbutton
.state
& Button1Mask
) trans
= "<Btn1Down>";
1510 if (trans
) XtVaSetValues (widget
, XmNmenuPost
, trans
, 0);
1511 XmMenuPosition (widget
, (XButtonPressedEvent
*) event
);
1513 XtManageChild (widget
);
1517 set_min_dialog_size (w
)
1522 XtVaGetValues (w
, XmNwidth
, &width
, XmNheight
, &height
, 0);
1523 XtVaSetValues (w
, XmNminWidth
, width
, XmNminHeight
, height
, 0);
1527 xm_pop_instance (instance
, up
)
1528 widget_instance
* instance
;
1531 Widget widget
= instance
->widget
;
1533 if (XtClass (widget
) == xmDialogShellWidgetClass
)
1535 Widget widget_to_manage
= first_child (widget
);
1538 XtManageChild (widget_to_manage
);
1539 set_min_dialog_size (widget
);
1540 XtSetKeyboardFocus (instance
->parent
, widget
);
1543 XtUnmanageChild (widget_to_manage
);
1548 XtManageChild (widget
);
1550 XtUnmanageChild (widget
);
1555 /* motif callback */
1557 enum do_call_type
{ pre_activate
, selection
, no_selection
, post_activate
};
1560 do_call (widget
, closure
, type
)
1563 enum do_call_type type
;
1567 XtPointer user_data
;
1568 widget_instance
* instance
= (widget_instance
*)closure
;
1569 Widget instance_widget
;
1574 if (widget
->core
.being_destroyed
)
1577 instance_widget
= instance
->widget
;
1578 if (!instance_widget
)
1581 id
= instance
->info
->id
;
1584 XtSetArg (al
[ac
], XmNuserData
, &user_data
); ac
++;
1585 XtGetValues (widget
, al
, ac
);
1589 if (instance
->info
->pre_activate_cb
)
1590 instance
->info
->pre_activate_cb (widget
, id
, user_data
);
1593 if (instance
->info
->selection_cb
)
1594 instance
->info
->selection_cb (widget
, id
, user_data
);
1597 if (instance
->info
->selection_cb
)
1598 instance
->info
->selection_cb (widget
, id
, (XtPointer
) -1);
1601 if (instance
->info
->post_activate_cb
)
1602 instance
->info
->post_activate_cb (widget
, id
, user_data
);
1609 /* Like lw_internal_update_other_instances except that it does not do
1610 anything if its shell parent is not managed. This is to protect
1611 lw_internal_update_other_instances to dereference freed memory
1612 if the widget was ``destroyed'' by caching it in the all_destroyed_instances
1615 xm_internal_update_other_instances (widget
, closure
, call_data
)
1618 XtPointer call_data
;
1621 for (parent
= widget
; parent
; parent
= XtParent (parent
))
1622 if (XtIsShell (parent
))
1624 else if (!XtIsManaged (parent
))
1626 lw_internal_update_other_instances (widget
, closure
, call_data
);
1630 xm_generic_callback (widget
, closure
, call_data
)
1633 XtPointer call_data
;
1635 lw_internal_update_other_instances (widget
, closure
, call_data
);
1636 do_call (widget
, closure
, selection
);
1640 xm_nosel_callback (widget
, closure
, call_data
)
1643 XtPointer call_data
;
1645 /* This callback is only called when a dialog box is dismissed with the wm's
1646 destroy button (WM_DELETE_WINDOW.) We want the dialog box to be destroyed
1647 in that case, not just unmapped, so that it releases its keyboard grabs.
1648 But there are problems with running our callbacks while the widget is in
1649 the process of being destroyed, so we set XmNdeleteResponse to XmUNMAP
1650 instead of XmDESTROY and then destroy it ourself after having run the
1653 do_call (widget
, closure
, no_selection
);
1654 XtDestroyWidget (widget
);
1658 xm_pull_down_callback (widget
, closure
, call_data
)
1661 XtPointer call_data
;
1663 do_call (widget
, closure
, pre_activate
);
1667 xm_pop_down_callback (widget
, closure
, call_data
)
1670 XtPointer call_data
;
1672 widget_instance
*instance
= (widget_instance
*) closure
;
1674 if ((!instance
->pop_up_p
&& (XtParent (widget
) == instance
->widget
))
1675 || (XtParent (widget
) == instance
->parent
))
1676 do_call (widget
, closure
, post_activate
);
1680 /* set the keyboard focus */
1682 xm_set_keyboard_focus (parent
, w
)
1686 XmProcessTraversal (w
, 0);
1687 XtSetKeyboardFocus (parent
, w
);
1690 /* Motif hack to set the main window areas. */
1692 xm_set_main_areas (parent
, menubar
, work_area
)
1697 XmMainWindowSetAreas (parent
,
1698 menubar
, /* menubar (maybe 0) */
1699 0, /* command area (psheets) */
1700 0, /* horizontal scroll */
1701 0, /* vertical scroll */
1702 work_area
); /* work area */
1705 /* Motif hack to control resizing on the menubar. */
1707 xm_manage_resizing (w
, flag
)
1713 /* Enable the edit widget for resizing. */
1716 XtSetArg (al
[0], XtNallowShellResize
, 0);
1717 XtSetValues (w
, al
, 1);
1721 /* Disable the edit widget from resizing. */
1724 XtSetArg (al
[0], XtNallowShellResize
, 0);
1725 XtSetValues (w
, al
, 1);