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 <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 \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   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 \f
 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 \f
 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 \f
 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 \f
 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 \f/* 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 \f/* 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 \f/* 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 \f/* 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 \f/* 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