lwlib/lwlib.c

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