lwlib/lwlib.c

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