#include <Xm/BulletinB.h>
#include <Xm/CascadeB.h>
+#include <Xm/CascadeBG.h>
#include <Xm/DrawingA.h>
#include <Xm/FileSB.h>
#include <Xm/Label.h>
return result;
}
+/* Destroy all of the children of WIDGET
+ starting with number FIRST_CHILD_TO_DESTROY. */
+
static void
-destroy_all_children (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);
}
}
return True;
}
+/* KEEP_FIRST_CHILDREN gives the number of initial children to keep. */
+
static void
-make_menu_in_widget (instance, widget, 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++;
else
{
menu = XmCreatePulldownMenu (widget, cur->name, NULL, 0);
- make_menu_in_widget (instance, menu, cur->contents);
- XtSetArg (al [ac], XmNsubMenuId, menu); ac++;
- button = XmCreateCascadeButton (widget, cur->name, al, ac);
+ 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
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 (XtParent (widget), XtName (widget), 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)
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
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 (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