annotate lwlib/lwlib.c @ 40224:12dcadf8cb59

(Finternal_set_lisp_face_attribute) [HAVE_WINDOW_SYSTEM]: Don't do anything for QCfont unless the frame is on a windowed display.

  1 /* A general interface to the widgets of different toolkits.
  2    Copyright (C) 1992, 1993 Lucid, Inc.
  3 
  4 This file is part of the Lucid Widget Library.
  5 
  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 2, or (at your option)
  9 any later version.
 10 
 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.
 15 
 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.  */
 20 
 21 #ifdef NeXT
 22 #undef __STRICT_BSD__ /* ick */
 23 #endif
 24 
 25 #ifdef HAVE_CONFIG_H
 26 #include <config.h>
 27 #endif
 28 
 29 #include <sys/types.h>
 30 #include <stdio.h>
 31 #include <ctype.h>
 32 #include "lwlib-int.h"
 33 #include "lwlib-utils.h"
 34 #include <X11/StringDefs.h>
 35 
 36 extern long *xmalloc();
 37 
 38 #if defined (USE_LUCID)
 39 #include "lwlib-Xlw.h"
 40 #endif
 41 #if defined (USE_MOTIF)
 42 #include "lwlib-Xm.h"
 43 #else /* not USE_MOTIF */
 44 #if defined (USE_LUCID)
 45 #define USE_XAW
 46 #endif /* not USE_MOTIF && USE_LUCID */
 47 #endif
 48 #if defined (USE_OLIT)
 49 #include "lwlib-Xol.h"
 50 #endif
 51 #if defined (USE_XAW)
 52 #include <X11/Xaw/Paned.h>
 53 #include "lwlib-Xaw.h"
 54 #endif
 55 
 56 #if !defined (USE_LUCID) && !defined (USE_MOTIF) && !defined (USE_OLIT)
 57 ERROR!  At least one of USE_LUCID, USE_MOTIF or USE_OLIT must be defined.
 58 #endif
 59 
 60 #if defined (USE_MOTIF) && defined (USE_OLIT)
 61 ERROR! no more than one of USE_MOTIF and USE_OLIT may be defined.
 62 #endif
 63 
 64 #ifndef max
 65 #define max(x, y) ((x) > (y) ? (x) : (y))
 66 #endif
 67 
 68 /* List of all widgets managed by the library. */
 69 static widget_info*
 70 all_widget_info = NULL;
 71 
 72 #ifdef USE_MOTIF
 73 char *lwlib_toolkit_type = "motif";
 74 #else
 75 char *lwlib_toolkit_type = "lucid";
 76 #endif
 77 
 78 #if defined __STDC__ || defined PROTOTYPES
 79 #define P_(x)	x
 80 #else
 81 #define P_(x)	()
 82 #endif
 83 
 84 static widget_value *merge_widget_value P_ ((widget_value *,
 85 					     widget_value *,
 86 					     int, int *));
 87 static void instantiate_widget_instance P_ ((widget_instance *));
 88 static int my_strcasecmp P_ ((char *, char *));
 89 static void safe_free_str P_ ((char *));
 90 static void free_widget_value_tree P_ ((widget_value *));
 91 static widget_value *copy_widget_value_tree P_ ((widget_value *,
 92 						 change_type));
 93 static widget_info *allocate_widget_info P_ ((char *, char *, LWLIB_ID,
 94 					      widget_value *,
 95 					      lw_callback, lw_callback,
 96 					      lw_callback, lw_callback));
 97 static void free_widget_info P_ ((widget_info *));
 98 static void mark_widget_destroyed P_ ((Widget, XtPointer, XtPointer));
 99 static widget_instance *allocate_widget_instance P_ ((widget_info *,
100 						      Widget, Boolean));
101 static void free_widget_instance P_ ((widget_instance *));
102 static widget_info *get_widget_info P_ ((LWLIB_ID, Boolean));
103 static widget_instance *get_widget_instance P_ ((Widget, Boolean));
104 static widget_instance *find_instance P_ ((LWLIB_ID, Widget, Boolean));
105 static Boolean safe_strcmp P_ ((char *, char *));
106 static Widget name_to_widget P_ ((widget_instance *, char *));
107 static void set_one_value P_ ((widget_instance *, widget_value *, Boolean));
108 static void update_one_widget_instance P_ ((widget_instance *, Boolean));
109 static void update_all_widget_values P_ ((widget_info *, Boolean));
110 static void initialize_widget_instance P_ ((widget_instance *));
111 static widget_creation_function find_in_table P_ ((char *, widget_creation_entry *));
112 static Boolean dialog_spec_p P_ ((char *));
113 static void instantiate_widget_instance P_ ((widget_instance *));
114 static void destroy_one_instance P_ ((widget_instance *));
115 static void lw_pop_all_widgets P_ ((LWLIB_ID, Boolean));
116 static Boolean get_one_value P_ ((widget_instance *, widget_value *));
117 static void show_one_widget_busy P_ ((Widget, Boolean));
118      
119 void
120 lwlib_memset (address, value, length)
121      char *address;
122      int value;
123      int length;
124 {
125   int i;
126 
127   for (i = 0; i < length; i++)
128     address[i] = value;
129 }
130 
131 void
132 lwlib_bcopy (from, to, length)
133      char *from;
134      char *to;
135      int length;
136 {
137   int i;
138 
139   for (i = 0; i < length; i++)
140     to[i] = from[i];
141 }
142 /* utility functions for widget_instance and widget_info */
143 char *
144 safe_strdup (s)
145      const char *s;
146 {
147   char *result;
148   if (! s) return 0;
149   result = (char *) malloc (strlen (s) + 1);
150   if (! result)
151     return 0;
152   strcpy (result, s);
153   return result;
154 }
155 
156 /* Like strcmp but ignore differences in case.  */
157 
158 static int
159 my_strcasecmp (s1, s2)
160      char *s1, *s2;
161 {
162   while (1)
163     {
164       int c1 = *s1++;
165       int c2 = *s2++;
166       if (isupper (c1))
167 	c1 = tolower (c1);
168       if (isupper (c2))
169 	c2 = tolower (c2);
170       if (c1 != c2)
171 	return (c1 > c2 ? 1 : -1);
172       if (c1 == 0)
173 	return 0;
174     }
175 }
176 
177 static void
178 safe_free_str (s)
179      char *s;
180 {
181   if (s) free (s);
182 }
183 
184 static widget_value *widget_value_free_list = 0;
185 static int malloc_cpt = 0;
186 
187 widget_value *
188 malloc_widget_value ()
189 {
190   widget_value *wv;
191   if (widget_value_free_list)
192     {
193       wv = widget_value_free_list;
194       widget_value_free_list = wv->free_list;
195       wv->free_list = 0;
196     }
197   else
198     {
199       wv = (widget_value *) malloc (sizeof (widget_value));
200       malloc_cpt++;
201     }
202   lwlib_memset (wv, 0, sizeof (widget_value));
203   return wv;
204 }
205 
206 /* this is analogous to free().  It frees only what was allocated
207    by malloc_widget_value(), and no substructures. 
208  */
209 void
210 free_widget_value (wv)
211      widget_value *wv;
212 {
213   if (wv->free_list)
214     abort ();
215 
216   if (malloc_cpt > 25)
217     {
218       /* When the number of already allocated cells is too big,
219 	 We free it.  */
220       free (wv);
221       malloc_cpt--;
222     }
223   else
224     {
225       wv->free_list = widget_value_free_list;
226       widget_value_free_list = wv;
227     }
228 }
229 
230 static void
231 free_widget_value_tree (wv)
232      widget_value *wv;
233 {
234   if (!wv)
235     return;
236 
237   if (wv->name) free (wv->name);
238   if (wv->value) free (wv->value);
239   if (wv->key) free (wv->key);
240   if (wv->help) free (wv->help);
241 
242   wv->name = wv->value = wv->key = wv->help = (char *) 0xDEADBEEF;
243 
244   if (wv->toolkit_data && wv->free_toolkit_data)
245     {
246       XtFree (wv->toolkit_data);
247       wv->toolkit_data = (void *) 0xDEADBEEF;
248     }
249 
250   if (wv->contents && (wv->contents != (widget_value*)1))
251     {
252       free_widget_value_tree (wv->contents);
253       wv->contents = (widget_value *) 0xDEADBEEF;
254     }
255   if (wv->next)
256     {
257       free_widget_value_tree (wv->next);
258       wv->next = (widget_value *) 0xDEADBEEF;
259     }
260   free_widget_value (wv);
261 }
262 
263 static widget_value *
264 copy_widget_value_tree (val, change)
265      widget_value* val;
266      change_type change;
267 {
268   widget_value* copy;
269   
270   if (!val)
271     return NULL;
272   if (val == (widget_value *) 1)
273     return val;
274 
275   copy = malloc_widget_value ();
276   copy->name = safe_strdup (val->name);
277   copy->value = safe_strdup (val->value);
278   copy->key = safe_strdup (val->key);
279   copy->help = safe_strdup (val->help);
280   copy->enabled = val->enabled;
281   copy->button_type = val->button_type;
282   copy->selected = val->selected;
283   copy->edited = False;
284   copy->change = change;
285   copy->this_one_change = change;
286   copy->contents = copy_widget_value_tree (val->contents, change);
287   copy->call_data = val->call_data;
288   copy->next = copy_widget_value_tree (val->next, change);
289   copy->toolkit_data = NULL;
290   copy->free_toolkit_data = False;
291   return copy;
292 }
293 
294 static widget_info *
295 allocate_widget_info (type, name, id, val, pre_activate_cb,
296 		      selection_cb, post_activate_cb, highlight_cb)
297      char* type;
298      char* name;
299      LWLIB_ID id;
300      widget_value* val;
301      lw_callback pre_activate_cb;
302      lw_callback selection_cb;
303      lw_callback post_activate_cb;
304      lw_callback highlight_cb;
305 {
306   widget_info* info = (widget_info*)malloc (sizeof (widget_info));
307   info->type = safe_strdup (type);
308   info->name = safe_strdup (name);
309   info->id = id;
310   info->val = copy_widget_value_tree (val, STRUCTURAL_CHANGE);
311   info->busy = False;
312   info->pre_activate_cb = pre_activate_cb;
313   info->selection_cb = selection_cb;
314   info->post_activate_cb = post_activate_cb;
315   info->highlight_cb = highlight_cb;
316   info->instances = NULL;
317 
318   info->next = all_widget_info;
319   all_widget_info = info;
320 
321   return info;
322 }
323 
324 static void
325 free_widget_info (info)
326      widget_info* info;
327 {
328   safe_free_str (info->type);
329   safe_free_str (info->name);
330   free_widget_value_tree (info->val);
331   lwlib_memset ((void*)info, 0xDEADBEEF, sizeof (widget_info));
332   free (info);
333 }
334 
335 static void
336 mark_widget_destroyed (widget, closure, call_data)
337      Widget widget;
338      XtPointer closure;
339      XtPointer call_data;
340 {
341   widget_instance* instance = (widget_instance*)closure;
342 
343   /* be very conservative */
344   if (instance->widget == widget)
345     instance->widget = NULL;
346 }
347 
348 static widget_instance *
349 allocate_widget_instance (info, parent, pop_up_p)
350      widget_info* info;
351      Widget parent;
352      Boolean pop_up_p;
353 {
354   widget_instance* instance =
355     (widget_instance*)malloc (sizeof (widget_instance));
356   bzero (instance, sizeof *instance);
357   instance->parent = parent;
358   instance->pop_up_p = pop_up_p;
359   instance->info = info;
360   instance->next = info->instances;
361   info->instances = instance;
362 
363   instantiate_widget_instance (instance);
364 
365   XtAddCallback (instance->widget, XtNdestroyCallback,
366 		 mark_widget_destroyed, (XtPointer)instance);
367   return instance;
368 }
369 
370 static void
371 free_widget_instance (instance)
372      widget_instance* instance;
373 {
374   lwlib_memset ((void*)instance, 0xDEADBEEF, sizeof (widget_instance));
375   free (instance);
376 }
377 
378 static widget_info *
379 get_widget_info (id, remove_p)
380      LWLIB_ID id;
381      Boolean remove_p;
382 {
383   widget_info* info;
384   widget_info* prev;
385   for (prev = NULL, info = all_widget_info;
386        info;
387        prev = info, info = info->next)
388     if (info->id == id)
389      {
390        if (remove_p)
391 	 {
392 	   if (prev)
393 	     prev->next = info->next;
394 	   else
395 	     all_widget_info = info->next;
396 	 }
397       return info;
398      }
399   return NULL;
400 }
401 
402 /* Internal function used by the library dependent implementation to get the
403    widget_value for a given widget in an instance */
404 widget_info *
405 lw_get_widget_info (id)
406      LWLIB_ID id;
407 {
408   return get_widget_info (id, 0);
409 }
410 
411 static widget_instance *
412 get_widget_instance (widget, remove_p)
413      Widget widget;
414      Boolean remove_p;
415 {
416   widget_info* info;
417   widget_instance* instance;
418   widget_instance* prev;
419   for (info = all_widget_info; info; info = info->next)
420     for (prev = NULL, instance = info->instances;
421 	 instance;
422 	 prev = instance, instance = instance->next)
423       if (instance->widget == widget)
424 	{
425 	  if (remove_p)
426 	    {
427 	      if (prev)
428 		prev->next = instance->next;
429 	      else
430 		info->instances = instance->next;
431 	    }
432 	  return instance;
433 	}
434   return (widget_instance *) 0;
435 }
436 
437 /* Value is a pointer to the widget_instance corresponding to
438    WIDGET, or null if WIDGET is not a lwlib widget.  */
439 
440 widget_instance *
441 lw_get_widget_instance (widget)
442      Widget widget;
443 {
444   return get_widget_instance (widget, False);
445 }
446 
447 static widget_instance*
448 find_instance (id, parent, pop_up_p)
449      LWLIB_ID id;
450      Widget parent;
451      Boolean pop_up_p;
452 {
453   widget_info* info = get_widget_info (id, False);
454   widget_instance* instance;
455 
456   if (info)
457     for (instance = info->instances; instance; instance = instance->next)
458       if (instance->parent == parent && instance->pop_up_p == pop_up_p)
459 	return instance;
460 
461   return NULL;
462 }
463 
464 
465 /* utility function for widget_value */
466 static Boolean
467 safe_strcmp (s1, s2)
468      char* s1;
469      char* s2;
470 {
471   if (!!s1 ^ !!s2) return True;
472   return (s1 && s2) ? strcmp (s1, s2) : s1 ? False : !!s2;
473 }
474 
475 
476 #if 0
477 # define EXPLAIN(name, oc, nc, desc, a1, a2)				\
478    printf ("Change: \"%s\"\tmax(%s=%d,%s=%d)\t%s %d %d\n",		\
479 	   name,							\
480 	   (oc == NO_CHANGE ? "none" :					\
481 	    (oc == INVISIBLE_CHANGE ? "invisible" :			\
482 	     (oc == VISIBLE_CHANGE ? "visible" :			\
483 	      (oc == STRUCTURAL_CHANGE ? "structural" : "???")))),	\
484 	   oc,								\
485 	   (nc == NO_CHANGE ? "none" :					\
486 	    (nc == INVISIBLE_CHANGE ? "invisible" :			\
487 	     (nc == VISIBLE_CHANGE ? "visible" :			\
488 	      (nc == STRUCTURAL_CHANGE ? "structural" : "???")))),	\
489 	   nc, desc, a1, a2)
490 #else
491 # define EXPLAIN(name, oc, nc, desc, a1, a2)
492 #endif
493 
494 
495 static widget_value *
496 merge_widget_value (val1, val2, level, change_p)
497      widget_value* val1;
498      widget_value* val2;
499      int level;
500      int *change_p;
501 {
502   change_type change, this_one_change;
503   widget_value* merged_next;
504   widget_value* merged_contents;
505 
506   if (!val1)
507     {
508       if (val2)
509 	{
510 	  *change_p = 1;
511 	  return copy_widget_value_tree (val2, STRUCTURAL_CHANGE);
512 	}
513       else
514 	return NULL;
515     }
516   if (!val2)
517     {
518       *change_p = 1;
519       free_widget_value_tree (val1);
520       return NULL;
521     }
522   
523   change = NO_CHANGE;
524 
525   if (safe_strcmp (val1->name, val2->name))
526     {
527       EXPLAIN (val1->name, change, STRUCTURAL_CHANGE, "name change",
528 	       val1->name, val2->name);
529       change = max (change, STRUCTURAL_CHANGE);
530       safe_free_str (val1->name);
531       val1->name = safe_strdup (val2->name);
532     }
533   if (safe_strcmp (val1->value, val2->value))
534     {
535       EXPLAIN (val1->name, change, VISIBLE_CHANGE, "value change",
536 	       val1->value, val2->value);
537       change = max (change, VISIBLE_CHANGE);
538       safe_free_str (val1->value);
539       val1->value = safe_strdup (val2->value);
540     }
541   if (safe_strcmp (val1->key, val2->key))
542     {
543       EXPLAIN (val1->name, change, VISIBLE_CHANGE, "key change",
544 	       val1->key, val2->key);
545       change = max (change, VISIBLE_CHANGE);
546       safe_free_str (val1->key);
547       val1->key = safe_strdup (val2->key);
548     }
549   if (safe_strcmp (val1->help, val2->help))
550     {
551       EXPLAIN (val1->name, change, VISIBLE_CHANGE, "help change",
552 	       val1->help, val2->help);
553       change = max (change, VISIBLE_CHANGE);
554       safe_free_str (val1->help);
555       val1->help = safe_strdup (val2->help);
556     }
557   if (val1->enabled != val2->enabled)
558     {
559       EXPLAIN (val1->name, change, VISIBLE_CHANGE, "enablement change",
560 	       val1->enabled, val2->enabled);
561       change = max (change, VISIBLE_CHANGE);
562       val1->enabled = val2->enabled;
563     }
564   if (val1->button_type != val2->button_type)
565     {
566       EXPLAIN (val1->name, change, VISIBLE_CHANGE, "button type change",
567 	       val1->button_type, val2->button_type);
568       change = max (change, VISIBLE_CHANGE);
569       val1->button_type = val2->button_type;
570     }
571   if (val1->selected != val2->selected)
572     {
573       EXPLAIN (val1->name, change, VISIBLE_CHANGE, "selection change",
574 	       val1->selected, val2->selected);
575       change = max (change, VISIBLE_CHANGE);
576       val1->selected = val2->selected;
577     }
578   if (val1->call_data != val2->call_data)
579     {
580       EXPLAIN (val1->name, change, INVISIBLE_CHANGE, "call-data change",
581 	       val1->call_data, val2->call_data);
582       change = max (change, INVISIBLE_CHANGE);
583       val1->call_data = val2->call_data;
584     }
585 
586   if (level > 0)
587     {
588       merged_contents =
589 	merge_widget_value (val1->contents, val2->contents, level - 1,
590 			    change_p);
591       
592       if (val1->contents && !merged_contents)
593 	{
594 	  /* This used to say INVISIBLE_CHANGE,
595 	     but it is visible and vitally important when
596 	     the contents of the menu bar itself are entirely deleted.
597 
598 	     But maybe it doesn't matter.  This fails to fix the bug.  */
599 	  EXPLAIN (val1->name, change, STRUCTURAL_CHANGE, "(contents gone)",
600 		   0, 0);
601 	  change = max (change, STRUCTURAL_CHANGE);
602 	}
603       else if (merged_contents && merged_contents->change != NO_CHANGE)
604 	{
605 	  EXPLAIN (val1->name, change, INVISIBLE_CHANGE, "(contents change)",
606 		   0, 0);
607 	  change = max (change, INVISIBLE_CHANGE);
608 #if 0 /* This was replaced by the August 9 1996 change in lwlib-Xm.c.  */
609 #ifdef USE_MOTIF
610 	  change = max (merged_contents->change, change);
611 #endif
612 #endif
613 	}
614       
615       val1->contents = merged_contents;
616     }
617 
618   this_one_change = change;
619 
620   merged_next = merge_widget_value (val1->next, val2->next, level, change_p);
621 
622   if (val1->next && !merged_next)
623     {
624       EXPLAIN (val1->name, change, STRUCTURAL_CHANGE, "(following gone)",
625 	       0, 0);
626       change = max (change, STRUCTURAL_CHANGE);
627     }
628   else if (merged_next)
629     {
630       if (merged_next->change)
631 	EXPLAIN (val1->name, change, merged_next->change, "(following change)",
632 		 0, 0);
633       change = max (change, merged_next->change);
634     }
635 
636   val1->next = merged_next;
637 
638   val1->this_one_change = this_one_change;
639   val1->change = change;
640   
641   if (change > NO_CHANGE && val1->toolkit_data)
642     {
643       *change_p = 1;
644       if (val1->free_toolkit_data)
645 	XtFree (val1->toolkit_data);
646       val1->toolkit_data = NULL;
647     }
648 
649   return val1;
650 }
651 
652 
653 /* modifying the widgets */
654 static Widget
655 name_to_widget (instance, name)
656      widget_instance* instance;
657      char* name;
658 {
659   Widget widget = NULL;
660 
661   if (!instance->widget)
662     return NULL;
663 
664   if (!strcmp (XtName (instance->widget), name))
665     widget = instance->widget;
666   else
667     {
668       int length = strlen (name) + 2;
669       char* real_name = (char *) xmalloc (length);
670       real_name [0] = '*';
671       strcpy (real_name + 1, name);
672       
673       widget = XtNameToWidget (instance->widget, real_name);
674 
675       free (real_name);
676     }
677   return widget;
678 }
679 
680 static void
681 set_one_value (instance, val, deep_p)
682      widget_instance* instance;
683      widget_value* val;
684      Boolean deep_p;
685 {
686   Widget widget = name_to_widget (instance, val->name);
687   
688   if (widget)
689     {
690 #if defined (USE_LUCID)
691       if (lw_lucid_widget_p (instance->widget))
692 	xlw_update_one_widget (instance, widget, val, deep_p);
693 #endif
694 #if defined (USE_MOTIF)
695       if (lw_motif_widget_p (instance->widget))
696 	xm_update_one_widget (instance, widget, val, deep_p);
697 #endif
698 #if defined (USE_OLIT)
699       if (lw_olit_widget_p (instance->widget))
700 	xol_update_one_widget (instance, widget, val, deep_p);
701 #endif
702 #if defined (USE_XAW)
703       if (lw_xaw_widget_p (instance->widget))
704 	xaw_update_one_widget (instance, widget, val, deep_p);
705 #endif
706     }
707 }
708 
709 static void
710 update_one_widget_instance (instance, deep_p)
711      widget_instance* instance;
712      Boolean deep_p;
713 {
714   widget_value *val;
715 
716   if (!instance->widget)
717     /* the widget was destroyed */
718     return;
719 
720   for (val = instance->info->val; val; val = val->next)
721     if (val->change != NO_CHANGE)
722       set_one_value (instance, val, deep_p);
723 }
724 
725 static void
726 update_all_widget_values (info, deep_p)
727      widget_info* info;
728      Boolean deep_p;
729 {
730   widget_instance* instance;
731   widget_value* val;
732 
733   for (instance = info->instances; instance; instance = instance->next)
734     update_one_widget_instance (instance, deep_p);
735 
736   for (val = info->val; val; val = val->next)
737     val->change = NO_CHANGE;
738 }
739 
740 int
741 lw_modify_all_widgets (id, val, deep_p)
742      LWLIB_ID id;
743      widget_value* val;
744      Boolean deep_p;
745 {
746   widget_info* info = get_widget_info (id, False);
747   widget_value* new_val;
748   widget_value* next_new_val;
749   widget_value* cur;
750   widget_value* prev;
751   widget_value* next;
752   int		found;
753   int change_p = 0;
754 
755   if (!info)
756     return 0;
757 
758   for (new_val = val; new_val; new_val = new_val->next)
759     {
760       next_new_val = new_val->next;
761       new_val->next = NULL;
762       found = False;
763       for (prev = NULL, cur = info->val; cur; prev = cur, cur = cur->next)
764 	if (!strcmp (cur->name, new_val->name))
765 	  {
766 	    found = True;
767 	    next = cur->next;
768 	    cur->next = NULL;
769 	    cur = merge_widget_value (cur, new_val, deep_p ? 1000 : 1,
770 				      &change_p);
771 	    if (prev)
772 	      prev->next = cur ? cur : next;
773 	    else
774 	      info->val = cur ? cur : next;
775 	    if (cur)
776 	      cur->next = next;
777 	    break;
778 	  }
779       if (!found)
780 	{
781 	  /* Could not find it, add it */
782 	  if (prev)
783 	    prev->next = copy_widget_value_tree (new_val, STRUCTURAL_CHANGE);
784 	  else
785 	    info->val = copy_widget_value_tree (new_val, STRUCTURAL_CHANGE);
786 	  change_p = 1;
787 	}
788       new_val->next = next_new_val;
789     }
790 
791   update_all_widget_values (info, deep_p);
792   return change_p;
793 }
794 
795 
796 /* creating the widgets */
797 
798 static void
799 initialize_widget_instance (instance)
800      widget_instance* instance;
801 {
802   widget_value* val;
803 
804   for (val = instance->info->val; val; val = val->next)
805     val->change = STRUCTURAL_CHANGE;
806 
807   update_one_widget_instance (instance, True);
808 
809   for (val = instance->info->val; val; val = val->next)
810     val->change = NO_CHANGE;
811 }
812 
813 
814 static widget_creation_function
815 find_in_table (type, table)
816      char* type;
817      widget_creation_entry* table;
818 {
819   widget_creation_entry* cur;
820   for (cur = table; cur->type; cur++)
821     if (!my_strcasecmp (type, cur->type))
822       return cur->function;
823   return NULL;
824 }
825 
826 static Boolean
827 dialog_spec_p (name)
828      char* name;
829 {
830   /* return True if name matches [EILPQeilpq][1-9][Bb] or 
831      [EILPQeilpq][1-9][Bb][Rr][1-9] */
832   if (!name)
833     return False;
834   
835   switch (name [0])
836     {
837     case 'E': case 'I': case 'L': case 'P': case 'Q':
838     case 'e': case 'i': case 'l': case 'p': case 'q':
839       if (name [1] >= '0' && name [1] <= '9')
840 	{
841 	  if (name [2] != 'B' && name [2] != 'b')
842 	    return False;
843 	  if (!name [3])
844 	    return True;
845 	  if ((name [3] == 'T' || name [3] == 't') && !name [4])
846 	    return True;
847 	  if ((name [3] == 'R' || name [3] == 'r')
848 	      && name [4] >= '0' && name [4] <= '9' && !name [5])
849 	    return True;
850 	  return False;
851 	}
852       else
853 	return False;
854     
855     default:
856       return False;
857     }
858 }
859 
860 static void
861 instantiate_widget_instance (instance)
862      widget_instance* instance;
863 {
864   widget_creation_function function = NULL;
865 
866 #if defined (USE_LUCID)
867   if (!function)
868     function = find_in_table (instance->info->type, xlw_creation_table);
869 #endif
870 #if defined(USE_MOTIF)
871   if (!function)
872     function = find_in_table (instance->info->type, xm_creation_table);
873 #endif
874 #if defined (USE_OLIT)
875   if (!function)
876     function = find_in_table (instance->info->type, xol_creation_table);
877 #endif
878 #if defined (USE_XAW)
879   if (!function)
880     function = find_in_table (instance->info->type, xaw_creation_table);
881 #endif
882 
883   if (!function)
884     {
885       if (dialog_spec_p (instance->info->type))
886 	{
887 #if defined (USE_LUCID)
888 	  /* not yet */
889 #endif
890 #if defined(USE_MOTIF)
891 	  if (!function)
892 	    function = xm_create_dialog;
893 #endif
894 #if defined (USE_XAW)
895 	  if (!function)
896 	    function = xaw_create_dialog;
897 #endif
898 #if defined (USE_OLIT)
899 	  /* not yet */
900 #endif
901 	}
902     }
903   
904   if (!function)
905     {
906       printf ("No creation function for widget type %s\n",
907 	      instance->info->type);
908       abort ();
909     }
910 
911   instance->widget = (*function) (instance);
912 
913   if (!instance->widget)
914     abort ();
915 
916   /*   XtRealizeWidget (instance->widget);*/
917 }
918 
919 void 
920 lw_register_widget (type, name, id, val, pre_activate_cb,
921 		    selection_cb, post_activate_cb, highlight_cb)
922      char* type;
923      char* name;
924      LWLIB_ID id;
925      widget_value* val;
926      lw_callback pre_activate_cb;
927      lw_callback selection_cb;
928      lw_callback post_activate_cb;
929      lw_callback highlight_cb;
930 {
931   if (!get_widget_info (id, False))
932     allocate_widget_info (type, name, id, val, pre_activate_cb, selection_cb,
933 			  post_activate_cb, highlight_cb);
934 }
935 
936 Widget
937 lw_get_widget (id, parent, pop_up_p)
938      LWLIB_ID id;
939      Widget parent;
940      Boolean pop_up_p;
941 {
942   widget_instance* instance;
943   
944   instance = find_instance (id, parent, pop_up_p);
945   return instance ? instance->widget : NULL;
946 }
947 
948 Widget
949 lw_make_widget (id, parent, pop_up_p)
950      LWLIB_ID id;
951      Widget parent;
952      Boolean pop_up_p;
953 {
954   widget_instance* instance;
955   widget_info* info;
956   
957   instance = find_instance (id, parent, pop_up_p);
958   if (!instance)
959     {
960       info = get_widget_info (id, False);
961       if (!info)
962 	return NULL;
963       instance = allocate_widget_instance (info, parent, pop_up_p);
964       initialize_widget_instance (instance);
965     }
966   if (!instance->widget)
967     abort ();
968   return instance->widget;
969 }
970 
971 Widget
972 lw_create_widget (type, name, id, val, parent, pop_up_p, pre_activate_cb,
973 		  selection_cb, post_activate_cb, highlight_cb)
974      char* type;
975      char* name;
976      LWLIB_ID id;
977      widget_value* val;
978      Widget parent;
979      Boolean pop_up_p;
980      lw_callback pre_activate_cb;
981      lw_callback selection_cb;
982      lw_callback post_activate_cb;
983      lw_callback highlight_cb;
984 {
985   lw_register_widget (type, name, id, val, pre_activate_cb, selection_cb,
986 		      post_activate_cb, highlight_cb);
987   return lw_make_widget (id, parent, pop_up_p);
988 }
989 		  
990 
991 /* destroying the widgets */
992 static void
993 destroy_one_instance (instance)
994      widget_instance* instance;
995 {
996   /* Remove the destroy callback on the widget; that callback will try to
997      dereference the instance object (to set its widget slot to 0, since the
998      widget is dead.)  Since the instance is now dead, we don't have to worry
999      about the fact that its widget is dead too.
1000 
1001      This happens in the Phase2Destroy of the widget, so this callback would
1002      not have been run until arbitrarily long after the instance was freed.
1003    */
1004   if (instance->widget)
1005     XtRemoveCallback (instance->widget, XtNdestroyCallback,
1006 		      mark_widget_destroyed, (XtPointer)instance);
1007 
1008   if (instance->widget)
1009     {
1010       /* The else are pretty tricky here, including the empty statement
1011 	 at the end because it would be very bad to destroy a widget
1012 	 twice. */
1013 #if defined (USE_LUCID)
1014       if (lw_lucid_widget_p (instance->widget))
1015 	xlw_destroy_instance (instance);
1016       else
1017 #endif
1018 #if defined (USE_MOTIF)
1019       if (lw_motif_widget_p (instance->widget))
1020 	xm_destroy_instance (instance);
1021       else
1022 #endif
1023 #if defined (USE_OLIT)
1024       if (lw_olit_widget_p (instance->widget))
1025 	xol_destroy_instance (instance);
1026       else
1027 #endif
1028 #if defined (USE_XAW)
1029       if (lw_xaw_widget_p (instance->widget))
1030 	xaw_destroy_instance (instance);
1031       else 
1032 #endif
1033 	/* do not remove the empty statement */
1034 	;
1035     }
1036 
1037   free_widget_instance (instance);
1038 }
1039 
1040 void
1041 lw_destroy_widget (w)
1042      Widget w;
1043 {
1044   widget_instance* instance = get_widget_instance (w, True);
1045   
1046   if (instance)
1047     {
1048       widget_info *info = instance->info;
1049       /* instance has already been removed from the list; free it */
1050       destroy_one_instance (instance);
1051       /* if there are no instances left, free the info too */
1052       if (!info->instances)
1053 	lw_destroy_all_widgets (info->id);
1054     }
1055 }
1056 
1057 void
1058 lw_destroy_all_widgets (id)
1059      LWLIB_ID id;
1060 {
1061   widget_info* info = get_widget_info (id, True);
1062   widget_instance* instance;
1063   widget_instance* next;
1064 
1065   if (info)
1066     {
1067       for (instance = info->instances; instance; )
1068 	{
1069 	  next = instance->next;
1070 	  destroy_one_instance (instance);
1071 	  instance = next;
1072 	}
1073       free_widget_info (info);
1074     }
1075 }
1076 
1077 void
1078 lw_destroy_everything ()
1079 {
1080   while (all_widget_info)
1081     lw_destroy_all_widgets (all_widget_info->id);
1082 }
1083 
1084 void
1085 lw_destroy_all_pop_ups ()
1086 {
1087   widget_info* info;
1088   widget_info* next;
1089   widget_instance* instance;
1090 
1091   for (info = all_widget_info; info; info = next)
1092     {
1093       next = info->next;
1094       instance = info->instances;
1095       if (instance && instance->pop_up_p)
1096 	lw_destroy_all_widgets (info->id);
1097     }
1098 }
1099 
1100 #ifdef USE_MOTIF
1101 extern Widget first_child (/* Widget */);	/* garbage */
1102 #endif
1103 
1104 Widget
1105 lw_raise_all_pop_up_widgets ()
1106 {
1107   widget_info* info;
1108   widget_instance* instance;
1109   Widget result = NULL;
1110 
1111   for (info = all_widget_info; info; info = info->next)
1112     for (instance = info->instances; instance; instance = instance->next)
1113       if (instance->pop_up_p)
1114 	{
1115 	  Widget widget = instance->widget;
1116 	  if (widget)
1117 	    {
1118 	      if (XtIsManaged (widget)
1119 #ifdef USE_MOTIF
1120 		  /* What a complete load of crap!!!!
1121 		     When a dialogShell is on the screen, it is not managed!
1122 		   */
1123 		  || (lw_motif_widget_p (instance->widget) &&
1124 		      XtIsManaged (first_child (widget)))
1125 #endif
1126 		  )
1127 		{
1128 		  if (!result)
1129 		    result = widget;
1130 		  XMapRaised (XtDisplay (widget), XtWindow (widget));
1131 		}
1132 	    }
1133 	}
1134   return result;
1135 }
1136 
1137 static void
1138 lw_pop_all_widgets (id, up)
1139      LWLIB_ID id;
1140      Boolean up;
1141 {
1142   widget_info* info = get_widget_info (id, False);
1143   widget_instance* instance;
1144 
1145   if (info)
1146     for (instance = info->instances; instance; instance = instance->next)
1147       if (instance->pop_up_p && instance->widget)
1148 	{
1149 #if defined (USE_LUCID)
1150 	  if (lw_lucid_widget_p (instance->widget))
1151 	    {
1152 	      XtRealizeWidget (instance->widget);
1153 	      xlw_pop_instance (instance, up);
1154 	    }
1155 #endif
1156 #if defined (USE_MOTIF)
1157 	  if (lw_motif_widget_p (instance->widget))
1158 	    {
1159 	      XtRealizeWidget (instance->widget);
1160 	      xm_pop_instance (instance, up);
1161 	    }
1162 #endif
1163 #if defined (USE_OLIT)
1164 	  if (lw_olit_widget_p (instance->widget))
1165 	    {
1166 	      XtRealizeWidget (instance->widget);
1167 	      xol_pop_instance (instance, up);
1168 	    }
1169 #endif
1170 #if defined (USE_XAW)
1171 	  if (lw_xaw_widget_p (instance->widget))
1172 	    {
1173 	      XtRealizeWidget (XtParent (instance->widget));
1174 	      XtRealizeWidget (instance->widget);
1175 	      xaw_pop_instance (instance, up);
1176 	    }
1177 #endif
1178 	}
1179 }
1180 
1181 void
1182 lw_pop_up_all_widgets (id)
1183      LWLIB_ID id;
1184 {
1185   lw_pop_all_widgets (id, True);
1186 }
1187 
1188 void
1189 lw_pop_down_all_widgets (id)
1190      LWLIB_ID id;
1191 {
1192   lw_pop_all_widgets (id, False);
1193 }
1194 
1195 void
1196 lw_popup_menu (widget, event)
1197      Widget widget;
1198      XEvent *event;
1199 {
1200 #if defined (USE_LUCID)
1201   if (lw_lucid_widget_p (widget))
1202     xlw_popup_menu (widget, event);
1203 #endif
1204 #if defined (USE_MOTIF)
1205   if (lw_motif_widget_p (widget))
1206     xm_popup_menu (widget, event);
1207 #endif
1208 #if defined (USE_OLIT)
1209   if (lw_olit_widget_p (widget))
1210     xol_popup_menu (widget, event);
1211 #endif
1212 #if defined (USE_XAW)
1213   if (lw_xaw_widget_p (widget))
1214     xaw_popup_menu (widget, event);
1215 #endif
1216 }
1217 
1218 /* get the values back */
1219 static Boolean
1220 get_one_value (instance, val)
1221      widget_instance* instance;
1222      widget_value* val;
1223 {
1224   Widget widget = name_to_widget (instance, val->name);
1225       
1226   if (widget)
1227     {
1228 #if defined (USE_LUCID)
1229       if (lw_lucid_widget_p (instance->widget))
1230 	xlw_update_one_value (instance, widget, val);
1231 #endif
1232 #if defined (USE_MOTIF)
1233       if (lw_motif_widget_p (instance->widget))
1234 	xm_update_one_value (instance, widget, val);
1235 #endif
1236 #if defined (USE_OLIT)
1237       if (lw_olit_widget_p (instance->widget))
1238 	xol_update_one_value (instance, widget, val);
1239 #endif
1240 #if defined (USE_XAW)
1241       if (lw_xaw_widget_p (instance->widget))
1242 	xaw_update_one_value (instance, widget, val);
1243 #endif
1244       return True;
1245     }
1246   else
1247     return False;
1248 }
1249 
1250 Boolean
1251 lw_get_some_values (id, val_out)
1252      LWLIB_ID id;
1253      widget_value* val_out;
1254 {
1255   widget_info* info = get_widget_info (id, False);
1256   widget_instance* instance;
1257   widget_value* val;
1258   Boolean result = False;
1259 
1260   if (!info)
1261     return False;
1262 
1263   instance = info->instances;
1264   if (!instance)
1265     return False;
1266 
1267   for (val = val_out; val; val = val->next)
1268     if (get_one_value (instance, val))
1269       result = True;
1270 
1271   return result;
1272 }
1273 
1274 widget_value*
1275 lw_get_all_values (id)
1276      LWLIB_ID id;
1277 {
1278   widget_info* info = get_widget_info (id, False);
1279   widget_value* val = info->val;
1280   if (lw_get_some_values (id, val))
1281     return val;
1282   else
1283     return NULL;
1284 }
1285 
1286 /* internal function used by the library dependent implementation to get the
1287    widget_value for a given widget in an instance */
1288 widget_value*
1289 lw_get_widget_value_for_widget (instance, w)
1290      widget_instance* instance;
1291      Widget w;
1292 {
1293   char* name = XtName (w);
1294   widget_value* cur;
1295   for (cur = instance->info->val; cur; cur = cur->next)
1296     if (!strcmp (cur->name, name))
1297       return cur;
1298   return NULL;
1299 }
1300 
1301 /* update other instances value when one thing changed */
1302 
1303 /* To forbid recursive calls */
1304 static Boolean lwlib_updating;
1305 
1306 /* This function can be used as a an XtCallback for the widgets that get 
1307   modified to update other instances of the widgets.  Closure should be the
1308   widget_instance. */
1309 void
1310 lw_internal_update_other_instances (widget, closure, call_data)
1311      Widget widget;
1312      XtPointer closure;
1313      XtPointer call_data;
1314 {
1315   widget_instance* instance = (widget_instance*)closure;
1316   char* name = XtName (widget);
1317   widget_info* info;
1318   widget_instance* cur;
1319   widget_value* val;
1320 
1321   /* Avoid possibly infinite recursion.  */
1322   if (lwlib_updating)
1323     return;
1324 
1325   /* protect against the widget being destroyed */
1326   if (XtWidgetBeingDestroyedP (widget))
1327     return;
1328 
1329   /* Return immediately if there are no other instances */
1330   info = instance->info;
1331   if (!info->instances->next)
1332     return;
1333 
1334   lwlib_updating = True;
1335 
1336   for (val = info->val; val && strcmp (val->name, name); val = val->next);
1337 
1338   if (val && get_one_value (instance, val))
1339     for (cur = info->instances; cur; cur = cur->next)
1340       if (cur != instance)
1341 	set_one_value (cur, val, True);
1342 
1343   lwlib_updating = False;
1344 }
1345 
1346 
1347 /* get the id */
1348 
1349 LWLIB_ID
1350 lw_get_widget_id (w)
1351      Widget w;
1352 {
1353   widget_instance* instance = get_widget_instance (w, False);
1354 
1355   return instance ? instance->info->id : 0;
1356 }
1357 
1358 /* set the keyboard focus */
1359 void
1360 lw_set_keyboard_focus (parent, w)
1361      Widget parent;
1362      Widget w;
1363 {
1364 #if defined (USE_MOTIF)
1365   xm_set_keyboard_focus (parent, w);
1366 #else
1367   XtSetKeyboardFocus (parent, w);
1368 #endif
1369 }
1370 
1371 /* Show busy */
1372 static void
1373 show_one_widget_busy (w, flag)
1374      Widget w;
1375      Boolean flag;
1376 {
1377   Pixel foreground = 0;
1378   Pixel background = 1;
1379   Widget widget_to_invert = XtNameToWidget (w, "*sheet");
1380   if (!widget_to_invert)
1381     widget_to_invert = w;
1382   
1383   XtVaGetValues (widget_to_invert,
1384 		 XtNforeground, &foreground,
1385 		 XtNbackground, &background,
1386 		 NULL);
1387   XtVaSetValues (widget_to_invert,
1388 		 XtNforeground, background,
1389 		 XtNbackground, foreground,
1390 		 NULL);
1391 }
1392 
1393 void
1394 lw_show_busy (w, busy)
1395      Widget w;
1396      Boolean busy;
1397 {
1398   widget_instance* instance = get_widget_instance (w, False);
1399   widget_info* info;
1400   widget_instance* next;
1401 
1402   if (instance)
1403     {
1404       info = instance->info;
1405       if (info->busy != busy)
1406 	{
1407 	  for (next = info->instances; next; next = next->next)
1408 	    if (next->widget)
1409 	      show_one_widget_busy (next->widget, busy);
1410 	  info->busy = busy;
1411 	}
1412     }
1413 }
1414 
1415 /* This hack exists because Lucid/Athena need to execute the strange
1416    function below to support geometry management. */
1417 void
1418 lw_refigure_widget (w, doit)
1419      Widget w;
1420      Boolean doit;
1421 {
1422 #if defined (USE_XAW)  
1423   XawPanedSetRefigureMode (w, doit);
1424 #endif
1425 #if defined (USE_MOTIF)
1426   if (doit)
1427     XtManageChild (w);
1428   else
1429     XtUnmanageChild (w);
1430 #endif
1431 }
1432 
1433 /* Toolkit independent way of determining if an event window is in the
1434    menubar. */
1435 Boolean
1436 lw_window_is_in_menubar (win, menubar_widget)
1437      Window win;
1438      Widget menubar_widget;
1439 {
1440   return menubar_widget
1441 #if defined (USE_LUCID)
1442       && XtWindow (menubar_widget) == win;
1443 #endif
1444 #if defined (USE_MOTIF)
1445       && ((XtWindow (menubar_widget) == win)
1446 	  || (XtWindowToWidget (XtDisplay (menubar_widget), win)
1447 	      && (XtParent (XtWindowToWidget (XtDisplay (menubar_widget), win))
1448 		  == menubar_widget)));
1449 #endif
1450 }
1451 
1452 /* Motif hack to set the main window areas. */
1453 void
1454 lw_set_main_areas (parent, menubar, work_area)
1455      Widget parent;
1456      Widget menubar;
1457      Widget work_area;
1458 {
1459 #if defined (USE_MOTIF)
1460   xm_set_main_areas (parent, menubar, work_area);
1461 #endif
1462 }
1463 
1464 /* Manage resizing for Motif.  This disables resizing when the menubar
1465    is about to be modified. */
1466 void
1467 lw_allow_resizing (w, flag)
1468      Widget w;
1469      Boolean flag;
1470 {
1471 #if defined (USE_MOTIF)
1472   xm_manage_resizing (w, flag);
1473 #endif
1474 }
1475 
1476 
1477 /* Value is non-zero if LABEL is a menu separator.  If it is, *TYPE is
1478    set to an appropriate enumerator of type enum menu_separator.
1479    MOTIF_P non-zero means map separator types not supported by Motif
1480    to similar ones that are supported.  */
1481 
1482 int
1483 lw_separator_p (label, type, motif_p)
1484      char *label;
1485      enum menu_separator *type;
1486      int motif_p;
1487 {
1488   int separator_p = 0;
1489 
1490   if (strlen (label) >= 3
1491       && bcmp (label, "--:", 3) == 0)
1492     {
1493       static struct separator_table
1494       {
1495 	char *name;
1496 	enum menu_separator type;
1497       }
1498       separator_names[] =
1499       {
1500 	"space",		     SEPARATOR_NO_LINE,
1501 	"noLine",		     SEPARATOR_NO_LINE,
1502 	"singleLine",		     SEPARATOR_SINGLE_LINE,
1503 	"doubleLine",		     SEPARATOR_DOUBLE_LINE,
1504 	"singleDashedLine",	     SEPARATOR_SINGLE_DASHED_LINE,
1505 	"doubleDashedLine",	     SEPARATOR_DOUBLE_DASHED_LINE,
1506 	"shadowEtchedIn",	     SEPARATOR_SHADOW_ETCHED_IN,
1507 	"shadowEtchedOut",	     SEPARATOR_SHADOW_ETCHED_OUT,
1508 	"shadowEtchedInDash",	     SEPARATOR_SHADOW_ETCHED_IN_DASH,
1509 	"shadowEtchedOutDash",	     SEPARATOR_SHADOW_ETCHED_OUT_DASH,
1510 	"shadowDoubleEtchedIn",	     SEPARATOR_SHADOW_DOUBLE_ETCHED_IN,
1511 	"shadowDoubleEtchedOut",     SEPARATOR_SHADOW_DOUBLE_ETCHED_OUT,
1512 	"shadowDoubleEtchedInDash",  SEPARATOR_SHADOW_DOUBLE_ETCHED_IN_DASH,
1513 	"shadowDoubleEtchedOutDash", SEPARATOR_SHADOW_DOUBLE_ETCHED_OUT_DASH,
1514 	0
1515       };
1516 
1517       int i;
1518 
1519       label += 3;
1520       for (i = 0; separator_names[i].name; ++i)
1521 	if (strcmp (label, separator_names[i].name) == 0)
1522 	  {
1523 	    separator_p = 1;
1524 	    *type = separator_names[i].type;
1525 
1526 	    /* If separator type is not supported under Motif,
1527 	       use a similar one.  */
1528 	    if (motif_p && *type >= SEPARATOR_SHADOW_DOUBLE_ETCHED_IN)
1529 	      *type -= 4;
1530 	    break;
1531 	  }
1532     }
1533   else if (strlen (label) > 3
1534 	   && bcmp (label, "--", 2) == 0
1535 	   && label[2] != '-')
1536     {
1537       /* Alternative, more Emacs-style names.  */
1538       static struct separator_table
1539       {
1540 	char *name;
1541 	enum menu_separator type;
1542       }
1543       separator_names[] =
1544       {
1545 	"space",			SEPARATOR_NO_LINE,
1546 	"no-line",			SEPARATOR_NO_LINE,
1547 	"single-line",			SEPARATOR_SINGLE_LINE,
1548 	"double-line",			SEPARATOR_DOUBLE_LINE,
1549 	"single-dashed-line",		SEPARATOR_SINGLE_DASHED_LINE,
1550 	"double-dashed-line",		SEPARATOR_DOUBLE_DASHED_LINE,
1551 	"shadow-etched-in",		SEPARATOR_SHADOW_ETCHED_IN,
1552 	"shadow-etched-out",		SEPARATOR_SHADOW_ETCHED_OUT,
1553 	"shadow-etched-in-dash",	SEPARATOR_SHADOW_ETCHED_IN_DASH,
1554 	"shadow-etched-out-dash",	SEPARATOR_SHADOW_ETCHED_OUT_DASH,
1555 	"shadow-double-etched-in",	SEPARATOR_SHADOW_DOUBLE_ETCHED_IN,
1556 	"shadow-double-etched-out",     SEPARATOR_SHADOW_DOUBLE_ETCHED_OUT,
1557 	"shadow-double-etched-in-dash", SEPARATOR_SHADOW_DOUBLE_ETCHED_IN_DASH,
1558 	"shadow-double-etched-out-dash",SEPARATOR_SHADOW_DOUBLE_ETCHED_OUT_DASH,
1559 	0
1560       };
1561 
1562       int i;
1563 
1564       label += 2;
1565       for (i = 0; separator_names[i].name; ++i)
1566 	if (strcmp (label, separator_names[i].name) == 0)
1567 	  {
1568 	    separator_p = 1;
1569 	    *type = separator_names[i].type;
1570 
1571 	    /* If separator type is not supported under Motif,
1572 	       use a similar one.  */
1573 	    if (motif_p && *type >= SEPARATOR_SHADOW_DOUBLE_ETCHED_IN)
1574 	      *type -= 4;
1575 	    break;
1576 	  }
1577     }
1578   else
1579     {
1580       /* Old-style separator, maybe.  It's a separator if it contains
1581 	 only dashes.  */
1582       while (*label == '-')
1583 	++label;
1584       separator_p = *label == 0;
1585       *type = SEPARATOR_SHADOW_ETCHED_IN;
1586     }
1587 
1588   return separator_p;
1589 }
1590