You should have received a copy of the GNU General Public License
along with GNU Emacs; see the file COPYING. If not, write to
-the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA. */
#include <stdlib.h>
#include <unistd.h>
#include <Xm/BulletinB.h>
#include <Xm/CascadeB.h>
+#include <Xm/CascadeBG.h>
#include <Xm/DrawingA.h>
#include <Xm/FileSB.h>
#include <Xm/Label.h>
#include <Xm/DialogS.h>
#include <Xm/Form.h>
-static void xm_pull_down_callback (Widget, XtPointer, XtPointer);
-static void xm_internal_update_other_instances (Widget, XtPointer,
- XtPointer);
-static void xm_generic_callback (Widget, XtPointer, XtPointer);
-static void xm_nosel_callback (Widget, XtPointer, XtPointer);
-static void xm_pop_down_callback (Widget, XtPointer, XtPointer);
+static void xm_pull_down_callback (/* Widget, XtPointer, XtPointer */);
+static void xm_internal_update_other_instances (/* Widget, XtPointer,
+ XtPointer */);
+static void xm_generic_callback (/* Widget, XtPointer, XtPointer */);
+static void xm_nosel_callback (/* Widget, XtPointer, XtPointer */);
+static void xm_pop_down_callback (/* Widget, XtPointer, XtPointer */);
+
+static void xm_update_menu (/* widget_instance*, Widget, widget_value*,
+ Boolean) */);
-static void
-xm_update_menu (widget_instance* instance, Widget widget, widget_value* val,
- Boolean deep_p);
\f/* Structures to keep destroyed instances */
typedef struct _destroyed_instance
all_destroyed_instances = NULL;
static destroyed_instance*
-make_destroyed_instance (char* name, char* type, Widget widget, Widget parent,
- Boolean pop_up_p)
+make_destroyed_instance (name, type, widget, parent, pop_up_p)
+ char* name;
+ char* type;
+ Widget widget;
+ Widget parent;
+ Boolean pop_up_p;
{
destroyed_instance* instance =
(destroyed_instance*)malloc (sizeof (destroyed_instance));
}
static void
-free_destroyed_instance (destroyed_instance* instance)
+free_destroyed_instance (instance)
+ destroyed_instance* instance;
{
free (instance->name);
free (instance->type);
\f/* motif utility functions */
Widget
-first_child (Widget widget)
+first_child (widget)
+ Widget widget;
{
return ((CompositeWidget)widget)->composite.children [0];
}
Boolean
-lw_motif_widget_p (Widget widget)
+lw_motif_widget_p (widget)
+ Widget widget;
{
return
XtClass (widget) == xmDialogShellWidgetClass
}
static XmString
-resource_motif_string (Widget widget, char* name)
+resource_motif_string (widget, name)
+ Widget widget;
+ char* name;
{
XtResource resource;
XmString result = 0;
return result;
}
+/* Destroy all of the children of WIDGET
+ starting with number FIRST_CHILD_TO_DESTROY. */
+
static void
-destroy_all_children (Widget widget)
+destroy_all_children (widget, first_child_to_destroy)
+ Widget widget;
+ int first_child_to_destroy;
{
Widget* children;
unsigned int number;
children = XtCompositeChildren (widget, &number);
if (children)
{
+ XtUnmanageChildren (children + first_child_to_destroy,
+ number - first_child_to_destroy);
+
/* Unmanage all children and destroy them. They will only be
- * really destroyed when we get out of DispatchEvent. */
- for (i = 0; i < number; i++)
+ really destroyed when we get out of DispatchEvent. */
+ for (i = first_child_to_destroy; i < number; i++)
{
- Widget child = children [i];
- if (!child->core.being_destroyed)
- {
- XtUnmanageChild (child);
- XtDestroyWidget (child);
- }
+ Arg al[2];
+ Widget submenu = 0;
+ /* Cascade buttons have submenus,and these submenus
+ need to be freed. But they are not included in
+ XtCompositeChildren. So get it out of the cascade button
+ and free it. If this child is not a cascade button,
+ then submenu should remain unchanged. */
+ XtSetArg (al[0], XmNsubMenuId, &submenu);
+ XtGetValues (children[i], al, 1);
+ if (submenu)
+ XtDestroyWidget (submenu);
+ XtDestroyWidget (children[i]);
}
+
XtFree ((char *) children);
}
}
\f/* update the label of anything subclass of a label */
static void
-xm_update_label (widget_instance* instance, Widget widget, widget_value* val)
+xm_update_label (instance, widget, val)
+ widget_instance* instance;
+ Widget widget;
+ widget_value* val;
{
XmString res_string = 0;
XmString built_string = 0;
\f/* update of list */
static void
-xm_update_list (widget_instance* instance, Widget widget, widget_value* val)
+xm_update_list (instance, widget, val)
+ widget_instance* instance;
+ Widget widget;
+ widget_value* val;
{
widget_value* cur;
int i;
\f/* update of buttons */
static void
-xm_update_pushbutton (widget_instance* instance, Widget widget,
- widget_value* val)
+xm_update_pushbutton (instance, widget, val)
+ widget_instance* instance;
+ Widget widget;
+ widget_value* val;
{
XtVaSetValues (widget, XmNalignment, XmALIGNMENT_CENTER, 0);
XtRemoveAllCallbacks (widget, XmNactivateCallback);
}
static void
-xm_update_cascadebutton (widget_instance* instance, Widget widget,
- widget_value* val)
+xm_update_cascadebutton (instance, widget, val)
+ widget_instance* instance;
+ Widget widget;
+ widget_value* val;
{
/* Should also rebuild the menu by calling ...update_menu... */
XtRemoveAllCallbacks (widget, XmNcascadingCallback);
\f/* update toggle and radiobox */
static void
-xm_update_toggle (widget_instance* instance, Widget widget, widget_value* val)
+xm_update_toggle (instance, widget, val)
+ widget_instance* instance;
+ Widget widget;
+ widget_value* val;
{
XtRemoveAllCallbacks (widget, XmNvalueChangedCallback);
XtAddCallback (widget, XmNvalueChangedCallback,
}
static void
-xm_update_radiobox (widget_instance* instance, Widget widget,
- widget_value* val)
+xm_update_radiobox (instance, widget, val)
+ widget_instance* instance;
+ Widget widget;
+ widget_value* val;
+
{
Widget toggle;
widget_value* cur;
\f/* update a popup menu, pulldown menu or a menubar */
static Boolean
-all_dashes_p (char* s)
+all_dashes_p (s)
+ char* s;
{
char* t;
for (t = s; *t; t++)
return True;
}
+/* KEEP_FIRST_CHILDREN gives the number of initial children to keep. */
+
static void
-make_menu_in_widget (widget_instance* instance, Widget widget,
- widget_value* val)
+make_menu_in_widget (instance, widget, val, keep_first_children)
+ widget_instance* instance;
+ Widget widget;
+ widget_value* val;
+ int keep_first_children;
{
Widget* children = 0;
int num_children;
int ac;
Boolean menubar_p;
+ Widget* old_children;
+ unsigned int old_num_children;
+
+ old_children = XtCompositeChildren (widget, &old_num_children);
+
/* Allocate the children array */
for (num_children = 0, cur = val; cur; num_children++, cur = cur->next);
children = (Widget*)XtMalloc (num_children * sizeof (Widget));
XtAddCallback (XtParent (widget), XmNpopdownCallback,
xm_pop_down_callback, (XtPointer)instance);
- for (child_index = 0, cur = val; cur; child_index++, cur = cur->next)
+ /* Preserve the first KEEP_FIRST_CHILDREN old children. */
+ for (child_index = 0, cur = val; child_index < keep_first_children;
+ child_index++, cur = cur->next)
+ children[child_index] = old_children[child_index];
+
+ /* Check that those are all we have
+ (the caller should have deleted the rest). */
+ if (old_num_children != keep_first_children)
+ abort ();
+
+ /* Create the rest. */
+ for (child_index = keep_first_children; cur; child_index++, cur = cur->next)
{
ac = 0;
XtSetArg (al [ac], XmNsensitive, cur->enabled); ac++;
XtSetArg (al [ac], XmNalignment, XmALIGNMENT_BEGINNING); ac++;
XtSetArg (al [ac], XmNuserData, cur->call_data); ac++;
- if (instance->pop_up_p && !cur->contents && !cur->call_data)
+ if (instance->pop_up_p && !cur->contents && !cur->call_data
+ && !all_dashes_p (cur->name))
{
ac = 0;
XtSetArg (al[ac], XmNalignment, XmALIGNMENT_CENTER); ac++;
}
else
{
- menu = XmCreatePulldownMenu (widget, "pulldown", NULL, 0);
- make_menu_in_widget (instance, menu, cur->contents);
- XtSetArg (al [ac], XmNsubMenuId, menu); ac++;
- button = XmCreateCascadeButton (widget, cur->name, al, ac);
+ menu = XmCreatePulldownMenu (widget, cur->name, NULL, 0);
+ make_menu_in_widget (instance, menu, cur->contents, 0);
+ XtSetArg (al [ac], XmNsubMenuId, menu); ac++;
+ /* non-zero values don't work reliably in
+ conjunction with Emacs' event loop */
+ XtSetArg (al [ac], XmNmappingDelay, 0); ac++;
+ button = XmCreateCascadeButtonGadget (widget, cur->name, al, ac);
xm_update_label (instance, button, cur);
}
XtFree ((char *) children);
+ if (old_children)
+ XtFree ((char *) old_children);
}
static void
-update_one_menu_entry (widget_instance* instance, Widget widget,
- widget_value* val, Boolean deep_p)
+update_one_menu_entry (instance, widget, val, deep_p)
+ widget_instance* instance;
+ Widget widget;
+ widget_value* val;
+ Boolean deep_p;
{
Arg al [256];
int ac;
Widget menu;
widget_value* contents;
- if (val->change == NO_CHANGE)
+ if (val->this_one_change == NO_CHANGE)
return;
/* update the sensitivity and userdata */
0);
/* update the menu button as a label. */
- if (val->change >= VISIBLE_CHANGE)
+ if (val->this_one_change >= VISIBLE_CHANGE)
xm_update_label (instance, widget, val);
/* update the pulldown/pullaside as needed */
{
if (contents)
{
- menu = XmCreatePulldownMenu (widget, "pulldown", NULL, 0);
- make_menu_in_widget (instance, menu, contents);
- ac = 0;
- XtSetArg (al [ac], XmNsubMenuId, menu); ac++;
- XtSetValues (widget, al, ac);
+ unsigned int old_num_children, i;
+ Widget parent;
+ Widget *widget_list;
+
+ parent = XtParent (widget);
+ widget_list = XtCompositeChildren (parent, &old_num_children);
+
+ /* Find the widget position within the parent's widget list. */
+ for (i = 0; i < old_num_children; i++)
+ if (strcmp (XtName (widget_list[i]), XtName (widget)) == 0)
+ break;
+ if (i == old_num_children)
+ abort ();
+ if (XmIsCascadeButton (widget_list[i]))
+ {
+ menu = XmCreatePulldownMenu (parent, XtName(widget), NULL, 0);
+ make_menu_in_widget (instance, menu, contents, 0);
+ ac = 0;
+ XtSetArg (al [ac], XmNsubMenuId, menu); ac++;
+ XtSetValues (widget, al, ac);
+ }
+ else
+ {
+ Widget button;
+
+ /* The current menuitem is a XmPushButtonGadget, it
+ needs to be replaced by a CascadeButtonGadget */
+ XtDestroyWidget (widget_list[i]);
+ menu = XmCreatePulldownMenu (parent, val->name, NULL, 0);
+ make_menu_in_widget (instance, menu, contents, 0);
+ ac = 0;
+ XtSetArg (al [ac], XmNsubMenuId, menu); ac++;
+ /* Non-zero values don't work reliably in
+ conjunction with Emacs' event loop */
+ XtSetArg (al [ac], XmNmappingDelay, 0); ac++;
+ /* Tell Motif to put it in the right place */
+ XtSetArg (al [ac], XmNpositionIndex, i); ac++;
+ button = XmCreateCascadeButtonGadget (parent, val->name, al, ac);
+ xm_update_label (instance, button, val);
+
+ XtAddCallback (button, XmNcascadingCallback, xm_pull_down_callback,
+ (XtPointer)instance);
+ XtManageChild (button);
+ }
}
}
else if (!contents)
}
static void
-xm_update_menu (widget_instance* instance, Widget widget, widget_value* val,
- Boolean deep_p)
+xm_update_menu (instance, widget, val, deep_p)
+ widget_instance* instance;
+ Widget widget;
+ widget_value* val;
+ Boolean deep_p;
{
+ Widget* children;
+ unsigned int num_children;
+ int num_children_to_keep = 0;
+ int i;
+ widget_value* cur;
+
+ children = XtCompositeChildren (widget, &num_children);
+
/* Widget is a RowColumn widget whose contents have to be updated
* to reflect the list of items in val->contents */
- if (val->contents->change == STRUCTURAL_CHANGE)
+
+ /* See how many buttons we can keep, and how many we
+ must completely replace. */
+ if (val->contents == 0)
+ num_children_to_keep = 0;
+ else if (val->contents->change == STRUCTURAL_CHANGE)
{
- destroy_all_children (widget);
- make_menu_in_widget (instance, widget, val->contents);
+ if (children)
+ {
+ for (i = 0, cur = val->contents;
+ (i < num_children
+ && cur); /* how else to ditch unwanted children ?? - mgd */
+ i++, cur = cur->next)
+ {
+ if (cur->this_one_change == STRUCTURAL_CHANGE)
+ break;
+ }
+
+ num_children_to_keep = i;
+ }
}
else
- {
- /* Update all the buttons of the RowColumn in order. */
- Widget* children;
- unsigned int num_children;
- int i;
- widget_value* cur;
+ num_children_to_keep = num_children;
- children = XtCompositeChildren (widget, &num_children);
- if (children)
+ /* Update all the buttons of the RowColumn, in order,
+ except for those we are going to replace entirely. */
+ if (children)
+ {
+ for (i = 0, cur = val->contents; i < num_children_to_keep; i++)
{
- for (i = 0, cur = val->contents; i < num_children; i++)
+ if (!cur)
{
- if (!cur)
- abort ();
- if (children [i]->core.being_destroyed
- || strcmp (XtName (children [i]), cur->name))
- continue;
- update_one_menu_entry (instance, children [i], cur, deep_p);
- cur = cur->next;
+ num_children_to_keep = i;
+ break;
}
- XtFree ((char *) children);
+ if (children [i]->core.being_destroyed
+ || strcmp (XtName (children [i]), cur->name))
+ continue;
+ update_one_menu_entry (instance, children [i], cur, deep_p);
+ cur = cur->next;
}
- if (cur)
- abort ();
}
+
+ /* Now replace from scratch all the buttons after the last
+ place that the top-level structure changed. */
+ if (val->contents->change == STRUCTURAL_CHANGE)
+ {
+ destroy_all_children (widget, num_children_to_keep);
+ make_menu_in_widget (instance, widget, val->contents,
+ num_children_to_keep);
+ }
+
+ XtFree ((char *) children);
}
\f
/* update text widgets */
static void
-xm_update_text (widget_instance* instance, Widget widget, widget_value* val)
+xm_update_text (instance, widget, val)
+ widget_instance* instance;
+ Widget widget;
+ widget_value* val;
{
XmTextSetString (widget, val->value ? val->value : "");
XtRemoveAllCallbacks (widget, XmNactivateCallback);
}
static void
-xm_update_text_field (widget_instance* instance, Widget widget,
- widget_value* val)
+xm_update_text_field (instance, widget, val)
+ widget_instance* instance;
+ Widget widget;
+ widget_value* val;
{
XmTextFieldSetString (widget, val->value ? val->value : "");
XtRemoveAllCallbacks (widget, XmNactivateCallback);
/* update a motif widget */
void
-xm_update_one_widget (widget_instance* instance, Widget widget,
- widget_value* val, Boolean deep_p)
+xm_update_one_widget (instance, widget, val, deep_p)
+ widget_instance* instance;
+ Widget widget;
+ widget_value* val;
+ Boolean deep_p;
{
WidgetClass class;
\f/* getting the value back */
void
-xm_update_one_value (widget_instance* instance, Widget widget,
- widget_value* val)
+xm_update_one_value (instance, widget, val)
+ widget_instance* instance;
+ Widget widget;
+ widget_value* val;
{
WidgetClass class = XtClass (widget);
widget_value *old_wv;
/* This function is for activating a button from a program. It's wrong because
we pass a NULL argument in the call_data which is not Motif compatible.
This is used from the XmNdefaultAction callback of the List widgets to
- have a dble-click put down a dialog box like the button woudl do.
+ have a double-click put down a dialog box like the button would do.
I could not find a way to do that with accelerators.
*/
static void
-activate_button (Widget widget, XtPointer closure, XtPointer call_data)
+activate_button (widget, closure, call_data)
+ Widget widget;
+ XtPointer closure;
+ XtPointer call_data;
{
Widget button = (Widget)closure;
XtCallCallbacks (button, XmNactivateCallback, NULL);
/* dialogs */
static Widget
-make_dialog (char* name, Widget parent, Boolean pop_up_p,
- char* shell_title, char* icon_name, Boolean text_input_slot,
- Boolean radio_box, Boolean list,
- int left_buttons, int right_buttons)
+make_dialog (name, parent, pop_up_p, shell_title, icon_name, text_input_slot,
+ radio_box, list, left_buttons, right_buttons)
+ char* name;
+ Widget parent;
+ Boolean pop_up_p;
+ char* shell_title;
+ char* icon_name;
+ Boolean text_input_slot;
+ Boolean radio_box;
+ Boolean list;
+ int left_buttons;
+ int right_buttons;
{
Widget result;
Widget form;
n_children++;
}
- /* invisible seperator button */
+ /* invisible separator button */
ac = 0;
XtSetArg (al[ac], XmNmappedWhenManaged, FALSE); ac++;
children [n_children] = XmCreateLabel (row, "separator_button", al, ac);
}
static destroyed_instance*
-find_matching_instance (widget_instance* instance)
+find_matching_instance (instance)
+ widget_instance* instance;
{
destroyed_instance* cur;
destroyed_instance* prev;
}
static void
-mark_dead_instance_destroyed (Widget widget, XtPointer closure,
- XtPointer call_data)
+mark_dead_instance_destroyed (widget, closure, call_data)
+ Widget widget;
+ XtPointer closure;
+ XtPointer call_data;
{
destroyed_instance* instance = (destroyed_instance*)closure;
instance->widget = NULL;
}
static void
-recenter_widget (Widget widget)
+recenter_widget (widget)
+ Widget widget;
{
Widget parent = XtParent (widget);
Screen* screen = XtScreen (widget);
}
static Widget
-recycle_instance (destroyed_instance* instance)
+recycle_instance (instance)
+ destroyed_instance* instance;
{
Widget widget = instance->widget;
}
Widget
-xm_create_dialog (widget_instance* instance)
+xm_create_dialog (instance)
+ widget_instance* instance;
{
char* name = instance->info->type;
Widget parent = instance->parent;
return widget;
}
+/* Create a menu bar. We turn off the f10 key
+ because we have not yet managed to make it work right in Motif. */
+
static Widget
-make_menubar (widget_instance* instance)
+make_menubar (instance)
+ widget_instance* instance;
{
- return XmCreateMenuBar (instance->parent, instance->info->name, NULL, 0);
+ Arg al[1];
+ int ac;
+
+ ac = 0;
+ XtSetArg(al[0], XmNmenuAccelerator, 0);
+ return XmCreateMenuBar (instance->parent, instance->info->name, al, 1);
}
static void
-remove_grabs (Widget shell, XtPointer closure, XtPointer call_data)
+remove_grabs (shell, closure, call_data)
+ Widget shell;
+ XtPointer closure;
+ XtPointer call_data;
{
- XmRowColumnWidget menu = (XmRowColumnWidget) closure;
- XmRemoveFromPostFromList (menu, XtParent (XtParent ((Widget) menu)));
+ Widget menu = (Widget) closure;
+ XmRemoveFromPostFromList (menu, XtParent (XtParent (menu)));
}
static Widget
-make_popup_menu (widget_instance* instance)
+make_popup_menu (instance)
+ widget_instance* instance;
{
Widget parent = instance->parent;
Window parent_window = parent->core.window;
return result;
}
static Widget
-make_main (widget_instance* instance)
+make_main (instance)
+ widget_instance* instance;
{
Widget parent = instance->parent;
Widget result;
\f/* Destruction of instances */
void
-xm_destroy_instance (widget_instance* instance)
+xm_destroy_instance (instance)
+ widget_instance* instance;
{
Widget widget = instance->widget;
/* recycle the dialog boxes */
\f/* popup utility */
void
-xm_popup_menu (Widget widget)
+xm_popup_menu (widget, event)
+ Widget widget;
+ XEvent *event;
{
XButtonPressedEvent dummy;
- XEvent* event;
-
- dummy.type = ButtonPress;
- dummy.serial = 0;
- dummy.send_event = 0;
- dummy.display = XtDisplay (widget);
- dummy.window = XtWindow (XtParent (widget));
- dummy.time = 0;
- dummy.button = 0;
- XQueryPointer (dummy.display, dummy.window, &dummy.root,
- &dummy.subwindow, &dummy.x_root, &dummy.y_root,
- &dummy.x, &dummy.y, &dummy.state);
- event = (XEvent *) &dummy;
+
+ if (event == 0)
+ {
+ dummy.type = ButtonPress;
+ dummy.serial = 0;
+ dummy.send_event = 0;
+ dummy.display = XtDisplay (widget);
+ dummy.window = XtWindow (XtParent (widget));
+ dummy.time = 0;
+ dummy.button = 0;
+ XQueryPointer (dummy.display, dummy.window, &dummy.root,
+ &dummy.subwindow, &dummy.x_root, &dummy.y_root,
+ &dummy.x, &dummy.y, &dummy.state);
+ event = (XEvent *) &dummy;
+ }
if (event->type == ButtonPress || event->type == ButtonRelease)
{
}
static void
-set_min_dialog_size (Widget w)
+set_min_dialog_size (w)
+ Widget w;
{
short width;
short height;
}
void
-xm_pop_instance (widget_instance* instance, Boolean up)
+xm_pop_instance (instance, up)
+ widget_instance* instance;
+ Boolean up;
{
Widget widget = instance->widget;
enum do_call_type { pre_activate, selection, no_selection, post_activate };
static void
-do_call (Widget widget, XtPointer closure, enum do_call_type type)
+do_call (widget, closure, type)
+ Widget widget;
+ XtPointer closure;
+ enum do_call_type type;
{
Arg al [256];
int ac;
if the widget was ``destroyed'' by caching it in the all_destroyed_instances
list */
static void
-xm_internal_update_other_instances (Widget widget, XtPointer closure,
- XtPointer call_data)
+xm_internal_update_other_instances (widget, closure, call_data)
+ Widget widget;
+ XtPointer closure;
+ XtPointer call_data;
{
Widget parent;
for (parent = widget; parent; parent = XtParent (parent))
}
static void
-xm_generic_callback (Widget widget, XtPointer closure, XtPointer call_data)
+xm_generic_callback (widget, closure, call_data)
+ Widget widget;
+ XtPointer closure;
+ XtPointer call_data;
{
lw_internal_update_other_instances (widget, closure, call_data);
do_call (widget, closure, selection);
}
static void
-xm_nosel_callback (Widget widget, XtPointer closure, XtPointer call_data)
+xm_nosel_callback (widget, closure, call_data)
+ Widget widget;
+ XtPointer closure;
+ XtPointer call_data;
{
/* This callback is only called when a dialog box is dismissed with the wm's
destroy button (WM_DELETE_WINDOW.) We want the dialog box to be destroyed
}
static void
-xm_pull_down_callback (Widget widget, XtPointer closure, XtPointer call_data)
+xm_pull_down_callback (widget, closure, call_data)
+ Widget widget;
+ XtPointer closure;
+ XtPointer call_data;
{
do_call (widget, closure, pre_activate);
}
static void
-xm_pop_down_callback (Widget widget, XtPointer closure, XtPointer call_data)
+xm_pop_down_callback (widget, closure, call_data)
+ Widget widget;
+ XtPointer closure;
+ XtPointer call_data;
{
- do_call (widget, closure, post_activate);
+ widget_instance *instance = (widget_instance *) closure;
+
+ if ((!instance->pop_up_p && (XtParent (widget) == instance->widget))
+ || (XtParent (widget) == instance->parent))
+ do_call (widget, closure, post_activate);
}
\f
/* set the keyboard focus */
void
-xm_set_keyboard_focus (Widget parent, Widget w)
+xm_set_keyboard_focus (parent, w)
+ Widget parent;
+ Widget w;
{
XmProcessTraversal (w, 0);
XtSetKeyboardFocus (parent, w);