]> code.delx.au - gnu-emacs/blob - lwlib/lwlib.c
delx.au / code / gnu-emacs / blob


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