xemacs-beta: lwlib/lwlib-Xm.c comparison

comparison lwlib/lwlib-Xm.c @ 420:41dbb7a9d5f2 r21-2-18

Import from CVS: tag r21-2-18

author	cvs
date	Mon, 13 Aug 2007 11:24:09 +0200
parents	697ef44129c6
children	11054d720c21

comparison

equal deleted inserted replaced

-:66615b78f1a5
+:41dbb7a9d5f2
 Copyright (C) 1992, 1993, 1994 Lucid, Inc.
 Copyright (C) 1995 Tinker Systems and INS Engineering Corp.
 This file is part of the Lucid Widget Library.
 The Lucid Widget Library is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2, or (at your option)
 any later version.
 The Lucid Widget Library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 You should have received a copy of the GNU General Public License
 along with XEmacs; see the file COPYING.  If not, write to
 #include <Xm/RowColumn.h>
 #include <Xm/ScrolledW.h>
 #include <Xm/Separator.h>
 #include <Xm/DialogS.h>
 #include <Xm/Form.h>
+#include <Xm/Scale.h>
+#if XmVERSION > 1
+#include <Xm/ComboBox.h>
+#endif
 #ifdef LWLIB_MENUBARS_MOTIF
 static void xm_pull_down_callback (Widget, XtPointer, XtPointer);
-#if 0
-static void xm_pop_down_callback (Widget, XtPointer, XtPointer);
-#endif /* 0 */
 #endif
 static void xm_internal_update_other_instances (Widget, XtPointer,
 						XtPointer);
+static void xm_pop_down_callback (Widget, XtPointer, XtPointer);
 static void xm_generic_callback (Widget, XtPointer, XtPointer);
 #ifdef LWLIB_DIALOGS_MOTIF
 static void xm_nosel_callback (Widget, XtPointer, XtPointer);
 #endif
 #ifdef LWLIB_SCROLLBARS_MOTIF
 xm_update_menu (widget_instance* instance, Widget widget, widget_value* val,
 		Boolean deep_p);
 #endif
 /* Structures to keep destroyed instances */
 typedef struct _destroyed_instance
 {
 char*		name;
 char*		type;
 Widget 	widget;
 Widget	parent;
 instance->parent = parent;
 instance->pop_up_p = pop_up_p;
 instance->next = NULL;
 return instance;
 }
 static void
 free_destroyed_instance (destroyed_instance* instance)
 {
 free (instance->name);
 free (instance->type);
 }
 Boolean
 lw_motif_widget_p (Widget widget)
 {
 return
 #ifdef LWLIB_DIALOGS_MOTIF
 XtClass (widget) == xmDialogShellWidgetClass ||
 #endif
 XmIsPrimitive (widget) || XmIsManager (widget) || XmIsGadget (widget);
 }
 static char *
 resource_string (Widget widget, char *name)
 {
 XtResource resource;
 char *result = NULL;
 resource.resource_name  = "labelString";
 resource.resource_class = "LabelString"; /* #### should be Xmsomething... */
 resource.resource_type = XtRString;
 resource.resource_size = sizeof (String);
 resource.resource_offset = 0;
 int i;
 children = XtCompositeChildren (widget, &number);
 if (children)
 {
 /* Unmanage all children and destroy them.  They will only be
 * really destroyed when we get out of DispatchEvent. */
 for (i = 0; i < number; i++)
 	{
 	  Widget child = children [i];
 	  if (!child->core.being_destroyed)
 	}
 XtSetArg (al [ac], XmNlabelString, built_string); ac++;
 XtSetArg (al [ac], XmNlabelType, XmSTRING);	ac++;
 }
 if (val->key)
 {
 key_string = XmStringCreateLtoR (val->key, XmSTRING_DEFAULT_CHARSET);
 XtSetArg (al [ac], XmNacceleratorText, key_string); ac++;
 }
 } else {
 XtRemoveAllCallbacks (widget, XmNcascadingCallback);
 XtAddCallback (widget, XmNcascadingCallback, xm_pull_down_callback,
 		     instance);
 }
 }
 #endif /* LWLIB_MENUBARS_MOTIF */
 /* update toggle and radiobox */
 		   xm_pop_down_callback, (XtPointer)instance);
 */
 num_children = 0;
 for (child_index = 0, cur = val; cur; child_index++, cur = cur->next)
 {
 ac = 0;
 button = 0;
 XtSetArg (al [ac], XmNsensitive, cur->enabled);		ac++;
 XtSetArg (al [ac], XmNalignment, XmALIGNMENT_BEGINNING);	ac++;
 XtSetArg (al [ac], XmNuserData, cur->call_data);		ac++;
 /* update the pulldown/pullaside as needed */
 menu = NULL;
 XtSetArg (al [0], XmNsubMenuId, &menu);
 XtGetValues (widget, al, 1);
 contents = val->contents;
 if (!menu)
 {
 if (contents)
 }
 #endif /* LWLIB_MENUBARS_MOTIF */
-#ifdef LWLIB_DIALOGS_MOTIF
 /* update text widgets */
 static void
 xm_update_text (widget_instance* instance, Widget widget, widget_value* val)
 {
 XtRemoveAllCallbacks (widget, XmNvalueChangedCallback);
 XtAddCallback (widget, XmNvalueChangedCallback,
 		 xm_internal_update_other_instances, instance);
 }
-#endif /* LWLIB_DIALOGS_MOTIF */
 #ifdef LWLIB_SCROLLBARS_MOTIF
 /*
 * If this function looks like it does a lot more work than it needs to,
 xm_update_one_widget (widget_instance* instance, Widget widget,
 		      widget_value* val, Boolean deep_p)
 {
 WidgetClass class;
 Arg al [2];
 /* Mark as not edited */
 val->edited = False;
 /* Common to all widget types */
 XtSetArg (al [0], XmNsensitive, val->enabled);
 #if defined (LWLIB_DIALOGS_MOTIF) || defined (LWLIB_MENUBARS_MOTIF)
 /* Common to all label like widgets */
 if (XtIsSubclass (widget, xmLabelWidgetClass))
 xm_update_label (instance, widget, val);
-#endif
+#endif /* defined (LWLIB_DIALOGS_MOTIF) || defined (LWLIB_MENUBARS_MOTIF) */
 class = XtClass (widget);
 /* Class specific things */
 if (class == xmPushButtonWidgetClass ||
 class == xmArrowButtonWidgetClass)
 {
 {
 Boolean radiobox = 0;
 XtSetArg (al [0], XmNradioBehavior, &radiobox);
 XtGetValues (widget, al, 1);
 if (radiobox)
 	xm_update_radiobox (instance, widget, val);
 #ifdef LWLIB_MENUBARS_MOTIF
 else
 	xm_update_menu (instance, widget, val, deep_p);
 #endif
 }
-#ifdef LWLIB_DIALOGS_MOTIF
 else if (class == xmTextWidgetClass)
 {
 xm_update_text (instance, widget, val);
 }
 else if (class == xmTextFieldWidgetClass)
 {
 xm_update_text_field (instance, widget, val);
 }
-#endif
 else if (class == xmListWidgetClass)
 {
 xm_update_list (instance, widget, val);
 }
 #ifdef LWLIB_SCROLLBARS_MOTIF
 if (!strcmp (val->name, old_wv->name))
 {
 	val->call_data = old_wv->call_data;
 	break;
 }
 if (class == xmToggleButtonWidgetClass || class == xmToggleButtonGadgetClass)
 {
 Arg al [1];
 XtSetArg (al [0], XmNset, &val->selected);
 XtGetValues (widget, al, 1);
 val->edited = True;
 }
-#ifdef LWLIB_DIALOGS_MOTIF
 else if (class == xmTextWidgetClass)
 {
 if (val->value)
 	free (val->value);
 val->value = XmTextGetString (widget);
 if (val->value)
 	free (val->value);
 val->value = XmTextFieldGetString (widget);
 val->edited = True;
 }
-#endif
 else if (class == xmRowColumnWidgetClass)
 {
 Boolean radiobox = 0;
 {
 	Arg al [1];
 /* 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)
 {
 #ifdef DND_KLUDGE
 /* This is a kludge to disable drag-and-drop in dialog boxes.  The symptom
 was a segv down in libXm somewhere if you used the middle button on a
 dialog box to begin a drag; when you released the button to make a drop
 things would lose if you were not over the button where you started the
 drag (canceling the operation).  This was probably due to the fact that
 the dialog boxes were not set up to handle a drag but were trying to do
 so anyway for some reason.
 So we disable drag-and-drop in dialog boxes by turning off the binding for
 Widget children [16];		/* for the final XtManageChildren */
 int	n_children;
 Arg 	al[64];			/* Arg List */
 int 	ac;			/* Arg Count */
 int 	i;
 #ifdef DND_KLUDGE
 XtTranslations dnd_override = XtParseTranslationTable (disable_dnd_trans);
 # define DO_DND_KLUDGE(widget) XtOverrideTranslations ((widget), dnd_override)
 #else  /* ! DND_KLUDGE */
 # define DO_DND_KLUDGE(widget)
 XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM);	ac++;
 XtSetArg(al[ac], XmNleftOffset, 13);			ac++;
 XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM);	ac++;
 XtSetArg(al[ac], XmNrightOffset, 13);			ac++;
 row = XmCreateRowColumn (form, "row", al, ac);
 n_children = 0;
 for (i = 0; i < left_buttons; i++)
 {
 char button_name [16];
 sprintf (button_name, "button%d", i + 1);
 XtSetArg (al[ac], XmNmappedWhenManaged, FALSE); ac++;
 children [n_children] = XmCreateLabel (row, "separator_button",
 					 al, ac);
 DO_DND_KLUDGE (children [n_children]);
 n_children++;
 for (i = 0; i < right_buttons; i++)
 {
 char button_name [16];
 sprintf (button_name, "button%d", left_buttons + i + 1);
 ac = 0;
 children [n_children] = XmCreatePushButton (row, button_name, al, ac);
 DO_DND_KLUDGE (children [n_children]);
 if (! button) button = children [n_children];
 n_children++;
 }
 XtManageChildren (children, n_children);
 ac = 0;
 XtSetArg(al[ac], XmNtopAttachment, XmATTACH_NONE);		ac++;
 XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_WIDGET);	ac++;
 XtSetArg(al[ac], XmNbottomOffset, 13);			ac++;
 XtSetArg(al[ac], XmNbottomWidget, row);			ac++;
 /* this is the easiest way I found to have the dble click in the
 	 list activate the default button */
 XtAddCallback (value, XmNdefaultActionCallback, activate_button, button);
 }
 ac = 0;
 XtSetArg(al[ac], XmNalignment, XmALIGNMENT_BEGINNING);	ac++;
 XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM);		ac++;
 XtSetArg(al[ac], XmNtopOffset, 13);				ac++;
 XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_WIDGET);	ac++;
 XtSetArg(al[ac], XmNleftWidget, icon);			ac++;
 XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM);		ac++;
 XtSetArg(al[ac], XmNrightOffset, 13);				ac++;
 message = XmCreateLabel (form, "message", al, ac);
 DO_DND_KLUDGE (message);
 if (list)
 XtManageChild (value);
 i = 0;
 children [i] = row; i++;
 }
 children [i] = message; i++;
 children [i] = icon; i++;
 children [i] = icon_separator; i++;
 XtManageChildren (children, i);
 if (text_input_slot || list)
 {
 XtInstallAccelerators (value, button);
 XmProcessTraversal(value, XmTRAVERSE_CURRENT);
 }
 else
 {
 XtInstallAccelerators (form, button);
 XmProcessTraversal(value, XmTRAVERSE_CURRENT);
 }
 #ifdef DND_KLUDGE
 XtFree ((char *) dnd_override);
 #endif
 #undef DO_DND_KLUDGE
 XtSetArg (al [1], XtNheight, &parent_height);
 XtGetValues (parent, al, 2);
 x = (Position) ((parent_width  - child_width)  / 2);
 y = (Position) ((parent_height - child_height) / 2);
 XtTranslateCoords (parent, x, y, &x, &y);
 if ((Dimension) (x + child_width) > screen_width)
 x = screen_width - child_width;
 if (x < 0)
 case 'Q': case 'q':
 icon_name = "dbox-question";
 shell_name = "Question";
 break;
 }
 total_buttons = name [1] - '0';
 if (name [3] == 'T' || name [3] == 't')
 {
 text_input_slot = False;
 radio_box = True;
 }
 else if (name [3])
 right_buttons = name [4] - '0';
 left_buttons = total_buttons - right_buttons;
 widget = make_dialog (name, parent, pop_up_p,
 			shell_name, icon_name, text_input_slot, radio_box,
 			list, left_buttons, right_buttons);
 XtAddCallback (widget, XmNpopdownCallback, xm_nosel_callback,
 int ac = 0;
 static XtCallbackRec callbacks[2] =
 { {xm_scrollbar_callback, NULL}, {NULL, NULL} };
 callbacks[0].closure  = (XtPointer) instance;
 XtSetArg (al[ac], XmNminimum,       1); ac++;
 XtSetArg (al[ac], XmNmaximum, INT_MAX); ac++;
 XtSetArg (al[ac], XmNincrement,     1); ac++;
 XtSetArg (al[ac], XmNpageIncrement, 1); ac++;
 XtSetArg (al[ac], XmNborderWidth,   0); ac++;
 return make_scrollbar (instance, 0);
 }
 #endif /* LWLIB_SCROLLBARS_MOTIF */
-/* Table of functions to create widgets */
+/* glyph widgets */
+static Widget
+make_button (widget_instance *instance)
+{
+Arg al[20];
+int ac = 0;
+Widget button = 0;
+widget_value* val = instance->info->val;
+XtSetArg (al [ac], XmNsensitive, val->enabled);		ac++;
+XtSetArg (al [ac], XmNalignment, XmALIGNMENT_BEGINNING);	ac++;
+XtSetArg (al [ac], XmNuserData, val->call_data);		ac++;
+XtSetArg (al [ac], XmNmappedWhenManaged, FALSE);	ac++;
+/* The highlight doesn't appear to be dynamically set which makes it
+look ugly.  I think this may be a LessTif bug but for now we just
+get rid of it. */
+XtSetArg (al [ac], XmNhighlightThickness, (Dimension)0);ac++;
+/* add any args the user supplied for creation time */
+lw_add_value_args_to_args (val, al, &ac);
+if (!val->call_data)
+button = XmCreateLabel (instance->parent, val->name, al, ac);
+else if (val->type == TOGGLE_TYPE || val->type == RADIO_TYPE)
+{
+XtSetArg (al [ac], XmNset, val->selected);	ac++;
+XtSetArg (al [ac], XmNindicatorType,
+		(val->type == TOGGLE_TYPE ?
+		 XmN_OF_MANY : XmONE_OF_MANY));    ac++;
+XtSetArg (al [ac], XmNvisibleWhenOff, True); ac++;
+button = XmCreateToggleButton (instance->parent, val->name, al, ac);
+XtRemoveAllCallbacks (button, XmNvalueChangedCallback);
+XtAddCallback (button, XmNvalueChangedCallback, xm_generic_callback,
+		     (XtPointer)instance);
+}
+else
+{
+button = XmCreatePushButton (instance->parent, val->name, al, ac);
+XtAddCallback (button, XmNactivateCallback, xm_generic_callback,
+		     (XtPointer)instance);
+}
+XtManageChild (button);
+return button;
+}
+static Widget
+make_progress (widget_instance *instance)
+{
+Arg al[20];
+int ac = 0;
+Widget scale = 0;
+widget_value* val = instance->info->val;
+XtSetArg (al [ac], XmNsensitive, val->enabled);		ac++;
+XtSetArg (al [ac], XmNalignment, XmALIGNMENT_BEGINNING);	ac++;
+XtSetArg (al [ac], XmNuserData, val->call_data);		ac++;
+XtSetArg (al [ac], XmNmappedWhenManaged, FALSE);	ac++;
+XtSetArg (al [ac], XmNorientation, XmHORIZONTAL);	ac++;
+/* The highlight doesn't appear to be dynamically set which makes it
+look ugly.  I think this may be a LessTif bug but for now we just
+get rid of it. */
+XtSetArg (al [ac], XmNhighlightThickness, (Dimension)0);ac++;
+if (!val->call_data)
+XtSetArg (al [ac], XmNsensitive, False);		ac++;
+/* add any args the user supplied for creation time */
+lw_add_value_args_to_args (val, al, &ac);
+scale = XmCreateScale (instance->parent, val->name, al, ac);
+if (val->call_data)
+XtAddCallback (scale, XmNvalueChangedCallback, xm_generic_callback,
+		   (XtPointer)instance);
+XtManageChild (scale);
+return scale;
+}
+static Widget
+make_text_field (widget_instance *instance)
+{
+Arg al[20];
+int ac = 0;
+Widget text = 0;
+widget_value* val = instance->info->val;
+XtSetArg (al [ac], XmNsensitive, val->enabled && val->call_data);		ac++;
+XtSetArg (al [ac], XmNalignment, XmALIGNMENT_BEGINNING);	ac++;
+XtSetArg (al [ac], XmNuserData, val->call_data);		ac++;
+XtSetArg (al [ac], XmNmappedWhenManaged, FALSE);	ac++;
+/* The highlight doesn't appear to be dynamically set which makes it
+look ugly.  I think this may be a LessTif bug but for now we just
+get rid of it. */
+XtSetArg (al [ac], XmNhighlightThickness, (Dimension)0);ac++;
+/* add any args the user supplied for creation time */
+lw_add_value_args_to_args (val, al, &ac);
+text = XmCreateTextField (instance->parent, val->name, al, ac);
+if (val->call_data)
+XtAddCallback (text, XmNvalueChangedCallback, xm_generic_callback,
+		   (XtPointer)instance);
+XtManageChild (text);
+return text;
+}
+#if XmVERSION > 1
+static Widget
+make_combo_box (widget_instance *instance)
+{
+Arg al[20];
+int ac = 0;
+Widget combo = 0;
+widget_value* val = instance->info->val;
+XtSetArg (al [ac], XmNsensitive, val->enabled);		ac++;
+XtSetArg (al [ac], XmNalignment, XmALIGNMENT_BEGINNING);	ac++;
+XtSetArg (al [ac], XmNuserData, val->call_data);		ac++;
+XtSetArg (al [ac], XmNmappedWhenManaged, FALSE);	ac++;
+/* The highlight doesn't appear to be dynamically set which makes it
+look ugly.  I think this may be a LessTif bug but for now we just
+get rid of it. */
+XtSetArg (al [ac], XmNhighlightThickness, (Dimension)0);ac++;
+/* add any args the user supplied for creation time */
+lw_add_value_args_to_args (val, al, &ac);
+combo = XmCreateComboBox (instance->parent, val->name, al, ac);
+if (val->call_data)
+XtAddCallback (combo, XmNselectionCallback, xm_generic_callback,
+		   (XtPointer)instance);
+XtManageChild (combo);
+return combo;
+}
+#endif
+/* Table of functions to create widgets */
 widget_creation_entry
 xm_creation_table [] =
 {
 #ifdef LWLIB_MENUBARS_MOTIF
 {"menubar", 			make_menubar},
 {"popup",			make_popup_menu},
 #endif
 #ifdef LWLIB_SCROLLBARS_MOTIF
 {"vertical-scrollbar",	make_vertical_scrollbar},
 {"horizontal-scrollbar",	make_horizontal_scrollbar},
+#endif
+{"button",		make_button},
+{"progress",		make_progress},
+{"text-field",		make_text_field},
+#if XmVERSION > 1
+{"combo-box",		make_combo_box},
 #endif
 {NULL, NULL}
 };
 /* Destruction of instances */
 #endif
 {
 if (up)
 	XtManageChild (widget);
 else
 	XtUnmanageChild (widget);
 }
 }
 /* motif callback */
 enum do_call_type { pre_activate, selection, no_selection, post_activate };
 static void
 do_call (Widget widget, XtPointer closure, enum do_call_type type)
 abort ();
 }
 }
 /* Like lw_internal_update_other_instances except that it does not do
 anything if its shell parent is not managed.  This is to protect
 lw_internal_update_other_instances to dereference freed memory
 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,
 XtGetValues (widget, al, 1);
 XtSetArg (al [0], XmNset, !check);
 XtSetValues (widget, al, 1);
 }
 #endif
 lw_internal_update_other_instances (widget, closure, call_data);
 do_call (widget, closure, selection);
+}
+static void
+xm_pop_down_callback (Widget widget, XtPointer closure, XtPointer call_data)
+{
+do_call (widget, closure, post_activate);
 }
 #ifdef LWLIB_DIALOGS_MOTIF
 static void
 {
 #if 0
 if (call_data)
 {
 /* new behavior for incremental menu construction */
 }
 else
 #endif
 do_call (widget, closure, pre_activate);
 }
-#if 0
-static void
-xm_pop_down_callback (Widget widget, XtPointer closure, XtPointer call_data)
-{
-do_call (widget, closure, post_activate);
-}
-#endif /* 0 */
 #endif /* LWLIB_MENUBARS_MOTIF */
 #ifdef LWLIB_SCROLLBARS_MOTIF
 static void

Mercurial > hg > xemacs-beta

comparison lwlib/lwlib-Xm.c @ 420:41dbb7a9d5f2 r21-2-18