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-2012  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   xfree (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       xfree (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   xfree (wv->name);
 196   xfree (wv->value);
 197   xfree (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   xfree (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   xfree (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) ((void) 0)
 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       xfree (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         {
 916           /* Empty compound statement to terminate if-then-else chain.  */
 917         }
 918     }
 919
 920   free_widget_instance (instance);
 921 }
 922
 923 void
 924 lw_destroy_widget (Widget w)
 925 {
 926   widget_instance* instance = get_widget_instance (w, True);
 927
 928   if (instance)
 929     {
 930       widget_info *info = instance->info;
 931       /* instance has already been removed from the list; free it */
 932       destroy_one_instance (instance);
 933       /* if there are no instances left, free the info too */
 934       if (!info->instances)
 935         lw_destroy_all_widgets (info->id);
 936     }
 937 }
 938
 939 void
 940 lw_destroy_all_widgets (LWLIB_ID id)
 941 {
 942   widget_info* info = get_widget_info (id, True);
 943   widget_instance* instance;
 944   widget_instance* next;
 945
 946   if (info)
 947     {
 948       for (instance = info->instances; instance; )
 949         {
 950           next = instance->next;
 951           destroy_one_instance (instance);
 952           instance = next;
 953         }
 954       free_widget_info (info);
 955     }
 956 }
 957
 958 void
 959 lw_destroy_everything (void)
 960 {
 961   while (all_widget_info)
 962     lw_destroy_all_widgets (all_widget_info->id);
 963 }
 964
 965 void
 966 lw_destroy_all_pop_ups (void)
 967 {
 968   widget_info* info;
 969   widget_info* next;
 970   widget_instance* instance;
 971
 972   for (info = all_widget_info; info; info = next)
 973     {
 974       next = info->next;
 975       instance = info->instances;
 976       if (instance && instance->pop_up_p)
 977         lw_destroy_all_widgets (info->id);
 978     }
 979 }
 980
 981 #ifdef USE_MOTIF
 982 extern Widget first_child (Widget);     /* garbage */
 983 #endif
 984
 985 Widget
 986 lw_raise_all_pop_up_widgets (void)
 987 {
 988   widget_info* info;
 989   widget_instance* instance;
 990   Widget result = NULL;
 991
 992   for (info = all_widget_info; info; info = info->next)
 993     for (instance = info->instances; instance; instance = instance->next)
 994       if (instance->pop_up_p)
 995         {
 996           Widget widget = instance->widget;
 997           if (widget)
 998             {
 999               if (XtIsManaged (widget)
1000 #ifdef USE_MOTIF
1001                   /* What a complete load of crap!!!!
1002                      When a dialogShell is on the screen, it is not managed!
1003                    */
1004                   || (lw_motif_widget_p (instance->widget) &&
1005                       XtIsManaged (first_child (widget)))
1006 #endif
1007                   )
1008                 {
1009                   if (!result)
1010                     result = widget;
1011                   XMapRaised (XtDisplay (widget), XtWindow (widget));
1012                 }
1013             }
1014         }
1015   return result;
1016 }
1017
1018 static void
1019 lw_pop_all_widgets (LWLIB_ID id, Boolean up)
1020 {
1021   widget_info* info = get_widget_info (id, False);
1022   widget_instance* instance;
1023
1024   if (info)
1025     for (instance = info->instances; instance; instance = instance->next)
1026       if (instance->pop_up_p && instance->widget)
1027         {
1028 #if defined (USE_LUCID)
1029           if (lw_lucid_widget_p (instance->widget))
1030             {
1031               XtRealizeWidget (instance->widget);
1032               xlw_pop_instance (instance, up);
1033             }
1034 #endif
1035 #if defined (USE_MOTIF)
1036           if (lw_motif_widget_p (instance->widget))
1037             {
1038               XtRealizeWidget (instance->widget);
1039               xm_pop_instance (instance, up);
1040             }
1041 #endif
1042 #if defined (USE_XAW)
1043           if (lw_xaw_widget_p (instance->widget))
1044             {
1045               XtRealizeWidget (XtParent (instance->widget));
1046               XtRealizeWidget (instance->widget);
1047               xaw_pop_instance (instance, up);
1048             }
1049 #endif
1050         }
1051 }
1052
1053 void
1054 lw_pop_up_all_widgets (LWLIB_ID id)
1055 {
1056   lw_pop_all_widgets (id, True);
1057 }
1058
1059 void
1060 lw_pop_down_all_widgets (LWLIB_ID id)
1061 {
1062   lw_pop_all_widgets (id, False);
1063 }
1064
1065 void
1066 lw_popup_menu (Widget widget, XEvent *event)
1067 {
1068 #if defined (USE_LUCID)
1069   if (lw_lucid_widget_p (widget))
1070     xlw_popup_menu (widget, event);
1071 #endif
1072 #if defined (USE_MOTIF)
1073   if (lw_motif_widget_p (widget))
1074     xm_popup_menu (widget, event);
1075 #endif
1076 #if defined (USE_XAW)
1077   if (lw_xaw_widget_p (widget))
1078     xaw_popup_menu (widget, event);
1079 #endif
1080 }
1081
1082 \f/* get the values back */
1083 static Boolean
1084 get_one_value (widget_instance *instance, widget_value *val)
1085 {
1086   Widget widget = name_to_widget (instance, val->name);
1087
1088   if (widget)
1089     {
1090 #if defined (USE_LUCID)
1091       if (lw_lucid_widget_p (instance->widget))
1092         xlw_update_one_value (instance, widget, val);
1093 #endif
1094 #if defined (USE_MOTIF)
1095       if (lw_motif_widget_p (instance->widget))
1096         xm_update_one_value (instance, widget, val);
1097 #endif
1098 #if defined (USE_XAW)
1099       if (lw_xaw_widget_p (instance->widget))
1100         xaw_update_one_value (instance, widget, val);
1101 #endif
1102       return True;
1103     }
1104   else
1105     return False;
1106 }
1107
1108 Boolean
1109 lw_get_some_values (LWLIB_ID id, widget_value *val_out)
1110 {
1111   widget_info* info = get_widget_info (id, False);
1112   widget_instance* instance;
1113   widget_value* val;
1114   Boolean result = False;
1115
1116   if (!info)
1117     return False;
1118
1119   instance = info->instances;
1120   if (!instance)
1121     return False;
1122
1123   for (val = val_out; val; val = val->next)
1124     if (get_one_value (instance, val))
1125       result = True;
1126
1127   return result;
1128 }
1129
1130 widget_value*
1131 lw_get_all_values (LWLIB_ID id)
1132 {
1133   widget_info* info = get_widget_info (id, False);
1134   widget_value* val = info->val;
1135   if (lw_get_some_values (id, val))
1136     return val;
1137   else
1138     return NULL;
1139 }
1140
1141 /* internal function used by the library dependent implementation to get the
1142    widget_value for a given widget in an instance */
1143 widget_value*
1144 lw_get_widget_value_for_widget (widget_instance *instance, Widget w)
1145 {
1146   char* name = XtName (w);
1147   widget_value* cur;
1148   for (cur = instance->info->val; cur; cur = cur->next)
1149     if (!strcmp (cur->name, name))
1150       return cur;
1151   return NULL;
1152 }
1153
1154 \f/* update other instances value when one thing changed */
1155
1156 /* To forbid recursive calls */
1157 static Boolean lwlib_updating;
1158
1159 /* This function can be used as an XtCallback for the widgets that get
1160    modified to update other instances of the widgets.  Closure should be the
1161    widget_instance. */
1162 void
1163 lw_internal_update_other_instances (Widget widget,
1164                                     XtPointer closure,
1165                                     XtPointer call_data)
1166 {
1167   widget_instance* instance = (widget_instance*)closure;
1168   char* name = XtName (widget);
1169   widget_info* info;
1170   widget_instance* cur;
1171   widget_value* val;
1172
1173   /* Avoid possibly infinite recursion.  */
1174   if (lwlib_updating)
1175     return;
1176
1177   /* protect against the widget being destroyed */
1178   if (XtWidgetBeingDestroyedP (widget))
1179     return;
1180
1181   /* Return immediately if there are no other instances */
1182   info = instance->info;
1183   if (!info->instances->next)
1184     return;
1185
1186   lwlib_updating = True;
1187
1188   for (val = info->val; val && strcmp (val->name, name); val = val->next);
1189
1190   if (val && get_one_value (instance, val))
1191     for (cur = info->instances; cur; cur = cur->next)
1192       if (cur != instance)
1193         set_one_value (cur, val, True);
1194
1195   lwlib_updating = False;
1196 }
1197
1198
1199 \f/* get the id */
1200
1201 LWLIB_ID
1202 lw_get_widget_id (Widget w)
1203 {
1204   widget_instance* instance = get_widget_instance (w, False);
1205
1206   return instance ? instance->info->id : 0;
1207 }
1208
1209 \f/* set the keyboard focus */
1210 void
1211 lw_set_keyboard_focus (Widget parent, Widget w)
1212 {
1213 #if defined (USE_MOTIF)
1214   xm_set_keyboard_focus (parent, w);
1215 #else
1216   XtSetKeyboardFocus (parent, w);
1217 #endif
1218 }
1219
1220 \f/* Show busy */
1221 static void
1222 show_one_widget_busy (Widget w, Boolean flag)
1223 {
1224   Pixel foreground = 0;
1225   Pixel background = 1;
1226   Widget widget_to_invert = XtNameToWidget (w, "*sheet");
1227   if (!widget_to_invert)
1228     widget_to_invert = w;
1229
1230   XtVaGetValues (widget_to_invert,
1231                  XtNforeground, &foreground,
1232                  XtNbackground, &background,
1233                  NULL);
1234   XtVaSetValues (widget_to_invert,
1235                  XtNforeground, background,
1236                  XtNbackground, foreground,
1237                  NULL);
1238 }
1239
1240 void
1241 lw_show_busy (Widget w, Boolean busy)
1242 {
1243   widget_instance* instance = get_widget_instance (w, False);
1244   widget_info* info;
1245   widget_instance* next;
1246
1247   if (instance)
1248     {
1249       info = instance->info;
1250       if (info->busy != busy)
1251         {
1252           for (next = info->instances; next; next = next->next)
1253             if (next->widget)
1254               show_one_widget_busy (next->widget, busy);
1255           info->busy = busy;
1256         }
1257     }
1258 }
1259
1260 /* This hack exists because Lucid/Athena need to execute the strange
1261    function below to support geometry management. */
1262 void
1263 lw_refigure_widget (Widget w, Boolean doit)
1264 {
1265 #if defined (USE_XAW)
1266   XawPanedSetRefigureMode (w, doit);
1267 #endif
1268 #if defined (USE_MOTIF)
1269   if (doit)
1270     XtManageChild (w);
1271   else
1272     XtUnmanageChild (w);
1273 #endif
1274 }
1275
1276 /* Toolkit independent way of determining if an event window is in the
1277    menubar. */
1278 Boolean
1279 lw_window_is_in_menubar (Window win, Widget menubar_widget)
1280 {
1281   return menubar_widget
1282 #if defined (USE_LUCID)
1283       && XtWindow (menubar_widget) == win;
1284 #endif
1285 #if defined (USE_MOTIF)
1286       && ((XtWindow (menubar_widget) == win)
1287           || (XtWindowToWidget (XtDisplay (menubar_widget), win)
1288               && (XtParent (XtWindowToWidget (XtDisplay (menubar_widget), win))
1289                   == menubar_widget)));
1290 #endif
1291 }
1292
1293 /* Motif hack to set the main window areas. */
1294 void
1295 lw_set_main_areas (Widget parent, Widget menubar, Widget work_area)
1296 {
1297 #if defined (USE_MOTIF)
1298   xm_set_main_areas (parent, menubar, work_area);
1299 #endif
1300 }
1301
1302 /* Manage resizing for Motif.  This disables resizing when the menubar
1303    is about to be modified. */
1304 void
1305 lw_allow_resizing (Widget w, Boolean flag)
1306 {
1307 #if defined (USE_MOTIF)
1308   xm_manage_resizing (w, flag);
1309 #endif
1310 }
1311
1312
1313 /* Value is non-zero if LABEL is a menu separator.  If it is, *TYPE is
1314    set to an appropriate enumerator of type enum menu_separator.
1315    MOTIF_P non-zero means map separator types not supported by Motif
1316    to similar ones that are supported.  */
1317
1318 int
1319 lw_separator_p (const char *label, enum menu_separator *type, int motif_p)
1320 {
1321   int separator_p = 0;
1322
1323   if (strlen (label) >= 3
1324       && memcmp (label, "--:", 3) == 0)
1325     {
1326       static struct separator_table
1327       {
1328         const char *name;
1329         enum menu_separator type;
1330       }
1331       separator_names[] =
1332       {
1333         {"space",                     SEPARATOR_NO_LINE},
1334         {"noLine",                    SEPARATOR_NO_LINE},
1335         {"singleLine",                SEPARATOR_SINGLE_LINE},
1336         {"doubleLine",                SEPARATOR_DOUBLE_LINE},
1337         {"singleDashedLine",          SEPARATOR_SINGLE_DASHED_LINE},
1338         {"doubleDashedLine",          SEPARATOR_DOUBLE_DASHED_LINE},
1339         {"shadowEtchedIn",            SEPARATOR_SHADOW_ETCHED_IN},
1340         {"shadowEtchedOut",           SEPARATOR_SHADOW_ETCHED_OUT},
1341         {"shadowEtchedInDash",        SEPARATOR_SHADOW_ETCHED_IN_DASH},
1342         {"shadowEtchedOutDash",       SEPARATOR_SHADOW_ETCHED_OUT_DASH},
1343         {"shadowDoubleEtchedIn",      SEPARATOR_SHADOW_DOUBLE_ETCHED_IN},
1344         {"shadowDoubleEtchedOut",     SEPARATOR_SHADOW_DOUBLE_ETCHED_OUT},
1345         {"shadowDoubleEtchedInDash",  SEPARATOR_SHADOW_DOUBLE_ETCHED_IN_DASH},
1346         {"shadowDoubleEtchedOutDash", SEPARATOR_SHADOW_DOUBLE_ETCHED_OUT_DASH},
1347         {0,0}
1348       };
1349
1350       int i;
1351
1352       label += 3;
1353       for (i = 0; separator_names[i].name; ++i)
1354         if (strcmp (label, separator_names[i].name) == 0)
1355           {
1356             separator_p = 1;
1357             *type = separator_names[i].type;
1358
1359             /* If separator type is not supported under Motif,
1360                use a similar one.  */
1361             if (motif_p && *type >= SEPARATOR_SHADOW_DOUBLE_ETCHED_IN)
1362               *type -= 4;
1363             break;
1364           }
1365     }
1366   else if (strlen (label) > 3
1367            && memcmp (label, "--", 2) == 0
1368            && label[2] != '-')
1369     {
1370       /* Alternative, more Emacs-style names.  */
1371       static struct separator_table
1372       {
1373         const char *name;
1374         enum menu_separator type;
1375       }
1376       separator_names[] =
1377       {
1378         {"space",                        SEPARATOR_NO_LINE},
1379         {"no-line",                      SEPARATOR_NO_LINE},
1380         {"single-line",                  SEPARATOR_SINGLE_LINE},
1381         {"double-line",                  SEPARATOR_DOUBLE_LINE},
1382         {"single-dashed-line",           SEPARATOR_SINGLE_DASHED_LINE},
1383         {"double-dashed-line",           SEPARATOR_DOUBLE_DASHED_LINE},
1384         {"shadow-etched-in",             SEPARATOR_SHADOW_ETCHED_IN},
1385         {"shadow-etched-out",            SEPARATOR_SHADOW_ETCHED_OUT},
1386         {"shadow-etched-in-dash",        SEPARATOR_SHADOW_ETCHED_IN_DASH},
1387         {"shadow-etched-out-dash",       SEPARATOR_SHADOW_ETCHED_OUT_DASH},
1388         {"shadow-double-etched-in",      SEPARATOR_SHADOW_DOUBLE_ETCHED_IN},
1389         {"shadow-double-etched-out",     SEPARATOR_SHADOW_DOUBLE_ETCHED_OUT},
1390         {"shadow-double-etched-in-dash", SEPARATOR_SHADOW_DOUBLE_ETCHED_IN_DASH},
1391         {"shadow-double-etched-out-dash",SEPARATOR_SHADOW_DOUBLE_ETCHED_OUT_DASH},
1392         {0,0}
1393       };
1394
1395       int i;
1396
1397       label += 2;
1398       for (i = 0; separator_names[i].name; ++i)
1399         if (strcmp (label, separator_names[i].name) == 0)
1400           {
1401             separator_p = 1;
1402             *type = separator_names[i].type;
1403
1404             /* If separator type is not supported under Motif,
1405                use a similar one.  */
1406             if (motif_p && *type >= SEPARATOR_SHADOW_DOUBLE_ETCHED_IN)
1407               *type -= 4;
1408             break;
1409           }
1410     }
1411   else
1412     {
1413       /* Old-style separator, maybe.  It's a separator if it contains
1414          only dashes.  */
1415       while (*label == '-')
1416         ++label;
1417       separator_p = *label == 0;
1418       *type = SEPARATOR_SHADOW_ETCHED_IN;
1419     }
1420
1421   return separator_p;
1422 }