diff lwlib/lwlib.c @ 5626:93bb7e0935ba

Initial revision

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/lwlib/lwlib.c	Tue Jan 18 23:47:41 1994 +0000
@@ -0,0 +1,1111 @@
+/* A general interface to the widgets of different toolkits.
+   Copyright (C) 1992, 1993 Lucid, Inc.
+
+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 GNU Emacs; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#ifdef NeXT
+#undef __STRICT_BSD__ /* ick */
+#endif
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <string.h>
+#include <stdio.h>
+#include <X11/StringDefs.h>
+#include "lwlib-internal.h"
+#include "lwlib-utils.h"
+
+#if defined(__GNUC__) && !defined(alloca)
+#define alloca __builtin_alloca
+#endif
+
+#if ((!__GNUC__) && !defined(__hpux)) && !defined(AIXV3)
+#include <alloca.h>
+#endif
+
+#if defined(AIXV3)
+#pragma alloca
+#endif
+
+#if defined (USE_LUCID)
+#include "lwlib-Xlw.h"
+#endif
+#if defined (USE_MOTIF)
+#include "lwlib-Xm.h"
+#endif
+#if defined (USE_OLIT)
+#include "lwlib-Xol.h"
+#endif
+
+#if !defined (USE_LUCID) && !defined (USE_MOTIF) && !defined (USE_OLIT)
+ERROR!  At least one of USE_LUCID, USE_MOTIF or USE_OLIT must be defined.
+#endif
+
+#if defined (USE_MOTIF) && defined (USE_OLIT)
+ERROR! no more than one of USE_MOTIF and USE_OLIT may be defined.
+#endif
+
+/* List of all widgets managed by the library. */
+static widget_info*
+all_widget_info = NULL;
+
+/* Forward declarations */
+static void
+instanciate_widget_instance (widget_instance* instance);
+
+/* utility functions for widget_instance and widget_info */
+static char *
+safe_strdup (char* s)
+{
+  char *result;
+  if (! s) return 0;
+  result = (char *) malloc (strlen (s) + 1);
+  if (! result)
+    return 0;
+  strcpy (result, s);
+  return result;
+}
+
+static void
+safe_free_str (char* s)
+{
+  if (s) free (s);
+}
+
+static widget_value *widget_value_free_list = 0;
+
+widget_value *
+malloc_widget_value ()
+{
+  widget_value *wv;
+  if (widget_value_free_list)
+    {
+      wv = widget_value_free_list;
+      widget_value_free_list = wv->free_list;
+      wv->free_list = 0;
+    }
+  else
+    {
+      wv = (widget_value *) malloc (sizeof (widget_value));
+    }
+  memset (wv, 0, sizeof (widget_value));
+  return wv;
+}
+
+/* this is analagous to free().  It frees only what was allocated
+   by malloc_widget_value(), and no substructures. 
+ */
+void
+free_widget_value (wv)
+     widget_value *wv;
+{
+  if (wv->free_list)
+    abort ();
+  wv->free_list = widget_value_free_list;
+  widget_value_free_list = wv;
+}
+
+static void
+free_widget_value_tree (widget_value* wv)
+{
+  if (!wv)
+    return;
+
+  if (wv->name) free (wv->name);
+  if (wv->value) free (wv->value);
+  if (wv->key) free (wv->key);
+
+  wv->name = wv->value = wv->key = (char *) 0xDEADBEEF;
+
+  if (wv->toolkit_data && wv->free_toolkit_data)
+    {
+      free (wv->toolkit_data);
+      wv->toolkit_data = (void *) 0xDEADBEEF;
+    }
+
+  if (wv->contents && (wv->contents != (widget_value*)1))
+    {
+      free_widget_value_tree (wv->contents);
+      wv->contents = (widget_value *) 0xDEADBEEF;
+    }
+  if (wv->next)
+    {
+      free_widget_value_tree (wv->next);
+      wv->next = (widget_value *) 0xDEADBEEF;
+    }
+  free_widget_value (wv);
+}
+
+static widget_value *
+copy_widget_value_tree (widget_value* val, change_type change)
+{
+  widget_value* copy;
+  
+  if (!val)
+    return NULL;
+  if (val == (widget_value *) 1)
+    return val;
+
+  copy = malloc_widget_value ();
+  copy->name = safe_strdup (val->name);
+  copy->value = safe_strdup (val->value);
+  copy->key = safe_strdup (val->key);
+  copy->enabled = val->enabled;
+  copy->selected = val->selected;
+  copy->edited = False;
+  copy->change = change;
+  copy->contents = copy_widget_value_tree (val->contents, change);
+  copy->call_data = val->call_data;
+  copy->next = copy_widget_value_tree (val->next, change);
+  copy->toolkit_data = NULL;
+  copy->free_toolkit_data = False;
+  return copy;
+}
+
+static widget_info *
+allocate_widget_info (char* type, char* name, LWLIB_ID id, widget_value* val,
+		      lw_callback pre_activate_cb, lw_callback selection_cb,
+		      lw_callback post_activate_cb)
+{
+  widget_info* info = (widget_info*)malloc (sizeof (widget_info));
+  info->type = safe_strdup (type);
+  info->name = safe_strdup (name);
+  info->id = id;
+  info->val = copy_widget_value_tree (val, STRUCTURAL_CHANGE);
+  info->busy = False;
+  info->pre_activate_cb = pre_activate_cb;
+  info->selection_cb = selection_cb;
+  info->post_activate_cb = post_activate_cb;
+  info->instances = NULL;
+
+  info->next = all_widget_info;
+  all_widget_info = info;
+
+  return info;
+}
+
+static void
+free_widget_info (widget_info* info)
+{
+  safe_free_str (info->type);
+  safe_free_str (info->name);
+  free_widget_value_tree (info->val);
+  memset ((void*)info, 0xDEADBEEF, sizeof (widget_info));
+  free (info);
+}
+
+static void
+mark_widget_destroyed (Widget widget, XtPointer closure, XtPointer call_data)
+{
+  widget_instance* instance = (widget_instance*)closure;
+
+  /* be very conservative */
+  if (instance->widget == widget)
+    instance->widget = NULL;
+}
+
+static widget_instance *
+allocate_widget_instance (widget_info* info, Widget parent, Boolean pop_up_p)
+{
+  widget_instance* instance =
+    (widget_instance*)malloc (sizeof (widget_instance));
+  instance->parent = parent;
+  instance->pop_up_p = pop_up_p;
+  instance->info = info;
+  instance->next = info->instances;
+  info->instances = instance;
+
+  instanciate_widget_instance (instance);
+
+  XtAddCallback (instance->widget, XtNdestroyCallback,
+		 mark_widget_destroyed, (XtPointer)instance);
+  return instance;
+}
+
+static void
+free_widget_instance (widget_instance* instance)
+{
+  memset ((void*)instance, 0xDEADBEEF, sizeof (widget_instance));
+  free (instance);
+}
+
+static widget_info *
+get_widget_info (LWLIB_ID id, Boolean remove_p)
+{
+  widget_info* info;
+  widget_info* prev;
+  for (prev = NULL, info = all_widget_info;
+       info;
+       prev = info, info = info->next)
+    if (info->id == id)
+     {
+       if (remove_p)
+	 {
+	   if (prev)
+	     prev->next = info->next;
+	   else
+	     all_widget_info = info->next;
+	 }
+      return info;
+     }
+  return NULL;
+}
+
+static widget_instance *
+get_widget_instance (Widget widget, Boolean remove_p)
+{
+  widget_info* info;
+  widget_instance* instance;
+  widget_instance* prev;
+  for (info = all_widget_info; info; info = info->next)
+    for (prev = NULL, instance = info->instances;
+	 instance;
+	 prev = instance, instance = instance->next)
+      if (instance->widget == widget)
+	{
+	  if (remove_p)
+	    {
+	      if (prev)
+		prev->next = instance->next;
+	      else
+		info->instances = instance->next;
+	    }
+	  return instance;
+	}
+  return (widget_instance *) 0;
+}
+
+static widget_instance*
+find_instance (LWLIB_ID id, Widget parent, Boolean pop_up_p)
+{
+  widget_info* info = get_widget_info (id, False);
+  widget_instance* instance;
+
+  if (info)
+    for (instance = info->instances; instance; instance = instance->next)
+      if (instance->parent == parent && instance->pop_up_p == pop_up_p)
+	return instance;
+
+  return NULL;
+}
+
+
+/* utility function for widget_value */
+static Boolean
+safe_strcmp (char* s1, char* s2)
+{
+  if (!!s1 ^ !!s2) return True;
+  return (s1 && s2) ? strcmp (s1, s2) : s1 ? False : !!s2;
+}
+
+static int
+max (int i1, int i2)
+{
+  return i1 > i2 ? i1 : i2;
+}
+
+
+#if 0
+# define EXPLAIN(name, oc, nc, desc, a1, a2)				\
+   printf ("Change: \"%s\"\tmax(%s=%d,%s=%d)\t%s %d %d\n",		\
+	   name,							\
+	   (oc == NO_CHANGE ? "none" :					\
+	    (oc == INVISIBLE_CHANGE ? "invisible" :			\
+	     (oc == VISIBLE_CHANGE ? "visible" :			\
+	      (oc == STRUCTURAL_CHANGE ? "structural" : "???")))),	\
+	   oc,								\
+	   (nc == NO_CHANGE ? "none" :					\
+	    (nc == INVISIBLE_CHANGE ? "invisible" :			\
+	     (nc == VISIBLE_CHANGE ? "visible" :			\
+	      (nc == STRUCTURAL_CHANGE ? "structural" : "???")))),	\
+	   nc, desc, a1, a2)
+#else
+# define EXPLAIN(name, oc, nc, desc, a1, a2)
+#endif
+
+
+static widget_value *
+merge_widget_value (widget_value* val1, widget_value* val2, int level)
+{
+  change_type change;
+  widget_value* merged_next;
+  widget_value* merged_contents;
+
+  if (!val1)
+    {
+      if (val2)
+	return copy_widget_value_tree (val2, STRUCTURAL_CHANGE);
+      else
+	return NULL;
+    }
+  if (!val2)
+    {
+      free_widget_value_tree (val1);
+      return NULL;
+    }
+  
+  change = NO_CHANGE;
+
+  if (safe_strcmp (val1->name, val2->name))
+    {
+      EXPLAIN (val1->name, change, STRUCTURAL_CHANGE, "name change",
+	       val1->name, val2->name);
+      change = max (change, STRUCTURAL_CHANGE);
+      safe_free_str (val1->name);
+      val1->name = safe_strdup (val2->name);
+    }
+  if (safe_strcmp (val1->value, val2->value))
+    {
+      EXPLAIN (val1->name, change, VISIBLE_CHANGE, "value change",
+	       val1->value, val2->value);
+      change = max (change, VISIBLE_CHANGE);
+      safe_free_str (val1->value);
+      val1->value = safe_strdup (val2->value);
+    }
+  if (safe_strcmp (val1->key, val2->key))
+    {
+      EXPLAIN (val1->name, change, VISIBLE_CHANGE, "key change",
+	       val1->key, val2->key);
+      change = max (change, VISIBLE_CHANGE);
+      safe_free_str (val1->key);
+      val1->key = safe_strdup (val2->key);
+    }
+  if (val1->enabled != val2->enabled)
+    {
+      EXPLAIN (val1->name, change, VISIBLE_CHANGE, "enablement change",
+	       val1->enabled, val2->enabled);
+      change = max (change, VISIBLE_CHANGE);
+      val1->enabled = val2->enabled;
+    }
+  if (val1->selected != val2->selected)
+    {
+      EXPLAIN (val1->name, change, VISIBLE_CHANGE, "selection change",
+	       val1->selected, val2->selected);
+      change = max (change, VISIBLE_CHANGE);
+      val1->selected = val2->selected;
+    }
+  if (val1->call_data != val2->call_data)
+    {
+      EXPLAIN (val1->name, change, INVISIBLE_CHANGE, "call-data change",
+	       val1->call_data, val2->call_data);
+      change = max (change, INVISIBLE_CHANGE);
+      val1->call_data = val2->call_data;
+    }
+
+  if (level > 0)
+    {
+      merged_contents =
+	merge_widget_value (val1->contents, val2->contents, level - 1);
+      
+      if (val1->contents && !merged_contents)
+	{
+	  EXPLAIN (val1->name, change, INVISIBLE_CHANGE, "(contents gone)",
+		   0, 0);
+	  change = max (change, INVISIBLE_CHANGE);
+	}
+      else if (merged_contents && merged_contents->change != NO_CHANGE)
+	{
+	  EXPLAIN (val1->name, change, INVISIBLE_CHANGE, "(contents change)",
+		   0, 0);
+	  change = max (change, INVISIBLE_CHANGE);
+	}
+      
+      val1->contents = merged_contents;
+    }
+
+  merged_next = merge_widget_value (val1->next, val2->next, level);
+
+  if (val1->next && !merged_next)
+    {
+      EXPLAIN (val1->name, change, STRUCTURAL_CHANGE, "(following gone)",
+	       0, 0);
+      change = max (change, STRUCTURAL_CHANGE);
+    }
+  else if (merged_next)
+    {
+      if (merged_next->change)
+	EXPLAIN (val1->name, change, merged_next->change, "(following change)",
+		 0, 0);
+      change = max (change, merged_next->change);
+    }
+
+  val1->next = merged_next;
+
+  val1->change = change;
+  
+  if (change > NO_CHANGE && val1->toolkit_data)
+    {
+      if (val1->free_toolkit_data)
+	free (val1->toolkit_data);
+      val1->toolkit_data = NULL;
+    }
+
+  return val1;
+}
+
+
+/* modifying the widgets */
+static Widget
+name_to_widget (widget_instance* instance, char* name)
+{
+  Widget widget = NULL;
+
+  if (!instance->widget)
+    return NULL;
+
+  if (!strcmp (XtName (instance->widget), name))
+    widget = instance->widget;
+  else
+    {
+      int length = strlen (name) + 2;
+      char* real_name = (char *) alloca (length);
+      real_name [0] = '*';
+      strcpy (real_name + 1, name);
+      
+      widget = XtNameToWidget (instance->widget, real_name);
+    }
+  return widget;
+}
+
+static void
+set_one_value (widget_instance* instance, widget_value* val, Boolean deep_p)
+{
+  Widget widget = name_to_widget (instance, val->name);
+  
+  if (widget)
+    {
+#if defined (USE_LUCID)
+      if (lw_lucid_widget_p (instance->widget))
+	xlw_update_one_widget (instance, widget, val, deep_p);
+#endif
+#if defined (USE_MOTIF)
+      if (lw_motif_widget_p (instance->widget))
+	xm_update_one_widget (instance, widget, val, deep_p);
+#endif
+#if defined (USE_OLIT)
+      if (lw_olit_widget_p (instance->widget))
+	xol_update_one_widget (instance, widget, val, deep_p);
+#endif
+    }
+}
+
+static void
+update_one_widget_instance (widget_instance* instance, Boolean deep_p)
+{
+  widget_value *val;
+
+  if (!instance->widget)
+    /* the widget was destroyed */
+    return;
+
+  for (val = instance->info->val; val; val = val->next)
+    if (val->change != NO_CHANGE)
+      set_one_value (instance, val, deep_p);
+}
+
+static void
+update_all_widget_values (widget_info* info, Boolean deep_p)
+{
+  widget_instance* instance;
+  widget_value* val;
+
+  for (instance = info->instances; instance; instance = instance->next)
+    update_one_widget_instance (instance, deep_p);
+
+  for (val = info->val; val; val = val->next)
+    val->change = NO_CHANGE;
+}
+
+void
+lw_modify_all_widgets (LWLIB_ID id, widget_value* val, Boolean deep_p)
+{
+  widget_info* info = get_widget_info (id, False);
+  widget_value* new_val;
+  widget_value* next_new_val;
+  widget_value* cur;
+  widget_value* prev;
+  widget_value* next;
+  int		found;
+
+  if (!info)
+    return;
+
+  for (new_val = val; new_val; new_val = new_val->next)
+    {
+      next_new_val = new_val->next;
+      new_val->next = NULL;
+      found = False;
+      for (prev = NULL, cur = info->val; cur; prev = cur, cur = cur->next)
+	if (!strcmp (cur->name, new_val->name))
+	  {
+	    found = True;
+	    next = cur->next;
+	    cur->next = NULL;
+	    cur = merge_widget_value (cur, new_val, deep_p ? 1000 : 1);
+	    if (prev)
+	      prev->next = cur ? cur : next;
+	    else
+	      info->val = cur ? cur : next;
+	    if (cur)
+	      cur->next = next;
+	    break;
+	  }
+      if (!found)
+	{
+	  /* Could not find it, add it */
+	  if (prev)
+	    prev->next = copy_widget_value_tree (new_val, STRUCTURAL_CHANGE);
+	  else
+	    info->val = copy_widget_value_tree (new_val, STRUCTURAL_CHANGE);
+	}
+      new_val->next = next_new_val;
+    }
+
+  update_all_widget_values (info, deep_p);
+}
+
+
+/* creating the widgets */
+
+static void
+initialize_widget_instance (widget_instance* instance)
+{
+  widget_value* val;
+
+  for (val = instance->info->val; val; val = val->next)
+    val->change = STRUCTURAL_CHANGE;
+
+  update_one_widget_instance (instance, True);
+
+  for (val = instance->info->val; val; val = val->next)
+    val->change = NO_CHANGE;
+}
+
+
+static widget_creation_function
+find_in_table (char* type, widget_creation_entry* table)
+{
+  widget_creation_entry* cur;
+  for (cur = table; cur->type; cur++)
+    if (!strcasecmp (type, cur->type))
+      return cur->function;
+  return NULL;
+}
+
+static Boolean
+dialog_spec_p (char* name)
+{
+  /* return True if name matches [EILPQeilpq][1-9][Bb] or 
+     [EILPQeilpq][1-9][Bb][Rr][1-9] */
+  if (!name)
+    return False;
+  
+  switch (name [0])
+    {
+    case 'E': case 'I': case 'L': case 'P': case 'Q':
+    case 'e': case 'i': case 'l': case 'p': case 'q':
+      if (name [1] >= '0' && name [1] <= '9')
+	{
+	  if (name [2] != 'B' && name [2] != 'b')
+	    return False;
+	  if (!name [3])
+	    return True;
+	  if ((name [3] == 'T' || name [3] == 't') && !name [4])
+	    return True;
+	  if ((name [3] == 'R' || name [3] == 'r')
+	      && name [4] >= '0' && name [4] <= '9' && !name [5])
+	    return True;
+	  return False;
+	}
+      else
+	return False;
+    
+    default:
+      return False;
+    }
+}
+
+static void
+instanciate_widget_instance (widget_instance* instance)
+{
+  widget_creation_function function = NULL;
+
+#if defined (USE_LUCID)
+  if (!function)
+    function = find_in_table (instance->info->type, xlw_creation_table);
+#endif
+#if defined(USE_MOTIF)
+  if (!function)
+    function = find_in_table (instance->info->type, xm_creation_table);
+#endif
+#if defined (USE_OLIT)
+  if (!function)
+    function = find_in_table (instance->info->type, xol_creation_table);
+#endif
+
+  if (!function)
+    {
+      if (dialog_spec_p (instance->info->type))
+	{
+#if defined (USE_LUCID)
+	  /* not yet */
+#endif
+#if defined(USE_MOTIF)
+	  if (!function)
+	    function = xm_create_dialog;
+#endif
+#if defined (USE_OLIT)
+	  /* not yet */
+#endif
+	}
+    }
+  
+  if (!function)
+    {
+      printf ("No creation function for widget type %s\n",
+	      instance->info->type);
+      abort ();
+    }
+
+  instance->widget = (*function) (instance);
+
+  if (!instance->widget)
+    abort ();
+
+  /*   XtRealizeWidget (instance->widget);*/
+}
+
+void 
+lw_register_widget (char* type, char* name, LWLIB_ID id, widget_value* val,
+		    lw_callback pre_activate_cb, lw_callback selection_cb,
+		    lw_callback post_activate_cb)
+{
+  if (!get_widget_info (id, False))
+    allocate_widget_info (type, name, id, val, pre_activate_cb, selection_cb,
+			  post_activate_cb);
+}
+
+Widget
+lw_get_widget (LWLIB_ID id, Widget parent, Boolean pop_up_p)
+{
+  widget_instance* instance;
+  
+  instance = find_instance (id, parent, pop_up_p);
+  return instance ? instance->widget : NULL;
+}
+
+Widget
+lw_make_widget (LWLIB_ID id, Widget parent, Boolean pop_up_p)
+{
+  widget_instance* instance;
+  widget_info* info;
+  
+  instance = find_instance (id, parent, pop_up_p);
+  if (!instance)
+    {
+      info = get_widget_info (id, False);
+      if (!info)
+	return NULL;
+      instance = allocate_widget_instance (info, parent, pop_up_p);
+      initialize_widget_instance (instance);
+    }
+  if (!instance->widget)
+    abort ();
+  return instance->widget;
+}
+
+Widget
+lw_create_widget (char* type, char* name, LWLIB_ID id, widget_value* val,
+		  Widget parent, Boolean pop_up_p, lw_callback pre_activate_cb,
+		  lw_callback selection_cb, lw_callback post_activate_cb)
+{
+  lw_register_widget (type, name, id, val, pre_activate_cb, selection_cb,
+		      post_activate_cb);
+  return lw_make_widget (id, parent, pop_up_p);
+}
+		  
+
+/* destroying the widgets */
+static void
+destroy_one_instance (widget_instance* instance)
+{
+  /* Remove the destroy callback on the widget; that callback will try to
+     dereference the instance object (to set its widget slot to 0, since the
+     widget is dead.)  Since the instance is now dead, we don't have to worry
+     about the fact that its widget is dead too.
+
+     This happens in the Phase2Destroy of the widget, so this callback would
+     not have been run until arbitrarily long after the instance was freed.
+   */
+  if (instance->widget)
+    XtRemoveCallback (instance->widget, XtNdestroyCallback,
+		      mark_widget_destroyed, (XtPointer)instance);
+
+  if (instance->widget)
+    {
+      /* The else are pretty tricky here, including the empty statement
+	 at the end because it would be very bad to destroy a widget
+	 twice. */
+#if defined (USE_LUCID)
+      if (lw_lucid_widget_p (instance->widget))
+	xlw_destroy_instance (instance);
+      else
+#endif
+#if defined (USE_MOTIF)
+      if (lw_motif_widget_p (instance->widget))
+	xm_destroy_instance (instance);
+      else
+#endif
+#if defined (USE_OLIT)
+      if (lw_olit_widget_p (instance->widget))
+	xol_destroy_instance (instance);
+      else
+#endif
+	/* do not remove the empty statement */
+	;
+    }
+
+  free_widget_instance (instance);
+}
+
+void
+lw_destroy_widget (Widget w)
+{
+  widget_instance* instance = get_widget_instance (w, True);
+  
+  if (instance)
+    {
+      widget_info *info = instance->info;
+      /* instance has already been removed from the list; free it */
+      destroy_one_instance (instance);
+      /* if there are no instances left, free the info too */
+      if (!info->instances)
+	lw_destroy_all_widgets (info->id);
+    }
+}
+
+void
+lw_destroy_all_widgets (LWLIB_ID id)
+{
+  widget_info* info = get_widget_info (id, True);
+  widget_instance* instance;
+  widget_instance* next;
+
+  if (info)
+    {
+      for (instance = info->instances; instance; )
+	{
+	  next = instance->next;
+	  destroy_one_instance (instance);
+	  instance = next;
+	}
+      free_widget_info (info);
+    }
+}
+
+void
+lw_destroy_everything ()
+{
+  while (all_widget_info)
+    lw_destroy_all_widgets (all_widget_info->id);
+}
+
+void
+lw_destroy_all_pop_ups ()
+{
+  widget_info* info;
+  widget_info* next;
+  widget_instance* instance;
+
+  for (info = all_widget_info; info; info = next)
+    {
+      next = info->next;
+      instance = info->instances;
+      if (instance && instance->pop_up_p)
+	lw_destroy_all_widgets (info->id);
+    }
+}
+
+#ifdef USE_MOTIF
+extern Widget first_child (Widget);	/* garbage */
+#endif
+
+Widget
+lw_raise_all_pop_up_widgets ()
+{
+  widget_info* info;
+  widget_instance* instance;
+  Widget result = NULL;
+
+  for (info = all_widget_info; info; info = info->next)
+    for (instance = info->instances; instance; instance = instance->next)
+      if (instance->pop_up_p)
+	{
+	  Widget widget = instance->widget;
+	  if (widget)
+	    {
+	      if (XtIsManaged (widget)
+#ifdef USE_MOTIF
+		  /* What a complete load of crap!!!!
+		     When a dialogShell is on the screen, it is not managed!
+		   */
+		  || (lw_motif_widget_p (instance->widget) &&
+		      XtIsManaged (first_child (widget)))
+#endif
+		  )
+		{
+		  if (!result)
+		    result = widget;
+		  XMapRaised (XtDisplay (widget), XtWindow (widget));
+		}
+	    }
+	}
+  return result;
+}
+
+static void
+lw_pop_all_widgets (LWLIB_ID id, Boolean up)
+{
+  widget_info* info = get_widget_info (id, False);
+  widget_instance* instance;
+
+  if (info)
+    for (instance = info->instances; instance; instance = instance->next)
+      if (instance->pop_up_p && instance->widget)
+	{
+	  if (!XtIsRealized (instance->widget))
+	    XtRealizeWidget (instance->widget);
+#if defined (USE_LUCID)
+	  if (lw_lucid_widget_p (instance->widget))
+	    xlw_pop_instance (instance, up);
+#endif
+#if defined (USE_MOTIF)
+	  if (lw_motif_widget_p (instance->widget))
+	    xm_pop_instance (instance, up);
+#endif
+#if defined (USE_OLIT)
+	  if (lw_olit_widget_p (instance->widget))
+	    xol_pop_instance (instance, up);
+#endif
+	}
+}
+
+void
+lw_pop_up_all_widgets (LWLIB_ID id)
+{
+  lw_pop_all_widgets (id, True);
+}
+
+void
+lw_pop_down_all_widgets (LWLIB_ID id)
+{
+  lw_pop_all_widgets (id, False);
+}
+
+void
+lw_popup_menu (Widget widget)
+{
+#if defined (USE_LUCID)
+  if (lw_lucid_widget_p (widget))
+    xlw_popup_menu (widget);
+#endif
+#if defined (USE_MOTIF)
+  if (lw_motif_widget_p (widget))
+    xm_popup_menu (widget);
+#endif
+#if defined (USE_OLIT)
+  if (lw_olit_widget_p (widget))
+    xol_popup_menu (widget);
+#endif
+}
+
+/* get the values back */
+static Boolean
+get_one_value (widget_instance* instance, widget_value* val)
+{
+  Widget widget = name_to_widget (instance, val->name);
+      
+  if (widget)
+    {
+#if defined (USE_LUCID)
+      if (lw_lucid_widget_p (instance->widget))
+	xlw_update_one_value (instance, widget, val);
+#endif
+#if defined (USE_MOTIF)
+      if (lw_motif_widget_p (instance->widget))
+	xm_update_one_value (instance, widget, val);
+#endif
+#if defined (USE_OLIT)
+      if (lw_olit_widget_p (instance->widget))
+	xol_update_one_value (instance, widget, val);
+#endif
+      return True;
+    }
+  else
+    return False;
+}
+
+Boolean
+lw_get_some_values (LWLIB_ID id, widget_value* val_out)
+{
+  widget_info* info = get_widget_info (id, False);
+  widget_instance* instance;
+  widget_value* val;
+  Boolean result = False;
+
+  if (!info)
+    return False;
+
+  instance = info->instances;
+  if (!instance)
+    return False;
+
+  for (val = val_out; val; val = val->next)
+    if (get_one_value (instance, val))
+      result = True;
+
+  return result;
+}
+
+widget_value*
+lw_get_all_values (LWLIB_ID id)
+{
+  widget_info* info = get_widget_info (id, False);
+  widget_value* val = info->val;
+  if (lw_get_some_values (id, val))
+    return val;
+  else
+    return NULL;
+}
+
+/* internal function used by the library dependent implementation to get the
+   widget_value for a given widget in an instance */
+widget_value*
+lw_get_widget_value_for_widget (widget_instance* instance, Widget w)
+{
+  char* name = XtName (w);
+  widget_value* cur;
+  for (cur = instance->info->val; cur; cur = cur->next)
+    if (!strcmp (cur->name, name))
+      return cur;
+  return NULL;
+}
+
+/* update other instances value when one thing changed */
+/* This function can be used as a an XtCallback for the widgets that get 
+  modified to update other instances of the widgets.  Closure should be the
+  widget_instance. */
+void
+lw_internal_update_other_instances (Widget widget, XtPointer closure,
+				    XtPointer call_data)
+{
+  /* To forbid recursive calls */
+  static Boolean updating;
+  
+  widget_instance* instance = (widget_instance*)closure;
+  char* name = XtName (widget);
+  widget_info* info;
+  widget_instance* cur;
+  widget_value* val;
+
+  /* never recurse as this could cause infinite recursions. */
+  if (updating)
+    return;
+
+  /* protect against the widget being destroyed */
+  if (XtWidgetBeingDestroyedP (widget))
+    return;
+
+  /* Return immediately if there are no other instances */
+  info = instance->info;
+  if (!info->instances->next)
+    return;
+
+  updating = True;
+
+  for (val = info->val; val && strcmp (val->name, name); val = val->next);
+
+  if (val && get_one_value (instance, val))
+    for (cur = info->instances; cur; cur = cur->next)
+      if (cur != instance)
+	set_one_value (cur, val, True);
+
+  updating = False;
+}
+
+
+/* get the id */
+
+LWLIB_ID
+lw_get_widget_id (Widget w)
+{
+  widget_instance* instance = get_widget_instance (w, False);
+
+  return instance ? instance->info->id : 0;
+}
+
+/* set the keyboard focus */
+void
+lw_set_keyboard_focus (Widget parent, Widget w)
+{
+#if defined (USE_MOTIF)
+  xm_set_keyboard_focus (parent, w);
+#else
+  XtSetKeyboardFocus (parent, w);
+#endif
+}
+
+/* Show busy */
+static void
+show_one_widget_busy (Widget w, Boolean flag)
+{
+  Pixel foreground = 0;
+  Pixel background = 1;
+  Widget widget_to_invert = XtNameToWidget (w, "*sheet");
+  if (!widget_to_invert)
+    widget_to_invert = w;
+  
+  XtVaGetValues (widget_to_invert,
+		 XtNforeground, &foreground,
+		 XtNbackground, &background,
+		 0);
+  XtVaSetValues (widget_to_invert,
+		 XtNforeground, background,
+		 XtNbackground, foreground,
+		 0);
+}
+
+void
+lw_show_busy (Widget w, Boolean busy)
+{
+  widget_instance* instance = get_widget_instance (w, False);
+  widget_info* info;
+  widget_instance* next;
+
+  if (instance)
+    {
+      info = instance->info;
+      if (info->busy != busy)
+	{
+	  for (next = info->instances; next; next = next->next)
+	    if (next->widget)
+	      show_one_widget_busy (next->widget, busy);
+	  info->busy = busy;
+	}
+    }
+}