?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
tools/llvm: Do not build with symbols
[minix3.git] / external / bsd / nvi / dist / motif_l / m_options.c
blob8fa73f46dca75daf7bc7c20c001256f5d640f9f3
1 /*-
2 * Copyright (c) 1996
3 * Rob Zimmermann. All rights reserved.
4 * Copyright (c) 1996
5 * Keith Bostic. All rights reserved.
6 *
7 * See the LICENSE file for redistribution information.
8 */
9
10 #include "config.h"
11
12 #ifndef lint
13 static const char sccsid[] = "Id: m_options.c,v 8.22 2003/11/05 17:09:59 skimo Exp (Berkeley) Date: 2003/11/05 17:09:59 ";
14 #endif /* not lint */
15
16 #include <sys/types.h>
17 #include <sys/queue.h>
18
19 #include <X11/X.h>
20 #include <X11/Intrinsic.h>
21 #include <Xm/DialogS.h>
22 #include <Xm/Form.h>
23 #include <Xm/Frame.h>
24 #include <Xm/LabelG.h>
25 #include <Xm/PushBG.h>
26 #include <Xm/TextF.h>
27 #include <Xm/ToggleBG.h>
28 #include <Xm/RowColumn.h>
29
30 #include <bitstring.h>
31 #include <stdio.h>
32 #include <stdlib.h>
33 #include <string.h>
34
35 #undef LOCK_SUCCESS
36 #include "../common/common.h"
37 #include "../ipc/ip.h"
38 #include "m_motif.h"
39
40 extern int vi_ofd;
41
42 static void set_opt __P((Widget, XtPointer, XtPointer));
43
44 \f
45 /* constants */
46
47 #if defined(SelfTest)
48
49 /* in production, get these from the resource list */
50
51 #define toggleColumns 6
52
53 #endif
54
55 \f
56 /*
57 * global data
58 */
59
60 static Widget preferences = NULL;
61
62 static optData display[] = {
63 { optToggle, "comment", },
64 { optToggle, "flash", },
65 { optToggle, "leftright", },
66 { optToggle, "list", },
67 { optToggle, "number", },
68 { optToggle, "octal", },
69 { optToggle, "ruler", },
70 { optToggle, "showmode", },
71 { optToggle, "slowopen", },
72 { optToggle, "verbose", },
73 { optToggle, "windowname", },
74 { optTerminator, },
75 }, display_int[] = {
76 { optInteger, "report", },
77 { optInteger, "scroll", },
78 { optInteger, "shiftwidth", },
79 { optInteger, "sidescroll", },
80 { optInteger, "tabstop", },
81 { optInteger, "window", },
82 { optTerminator, },
83 }, display_str[] = {
84 { optString, "noprint", },
85 { optString, "print", },
86 { optTerminator, },
87 }, files[] = {
88 { optToggle, "autowrite", },
89 { optToggle, "lock", },
90 { optToggle, "readonly", },
91 { optToggle, "writeany", },
92 { optTerminator, },
93 }, files_str[] = {
94 { optString, "backup", },
95 { optString, "path", },
96 { optTerminator, },
97 }, general[] = {
98 { optToggle, "exrc", },
99 { optToggle, "lisp", },
100 { optToggle, "modeline", },
101 { optToggle, "sourceany", },
102 { optToggle, "tildeop", },
103 { optTerminator, },
104 }, general_int[] = {
105 { optInteger, "taglength", },
106 { optTerminator, },
107 }, general_str[] = {
108 { optString, "cdpath", },
109 { optString, "directory", },
110 { optString, "msgcat", },
111 { optString, "recdir", },
112 { optString, "shell", },
113 { optString, "shellmeta", },
114 { optString, "tags", },
115 { optTerminator, },
116 }, input[] = {
117 { optToggle, "altwerase", },
118 { optToggle, "autoindent", },
119 { optToggle, "remap", },
120 { optToggle, "showmatch", },
121 { optToggle, "ttywerase", },
122 { optTerminator, },
123 }, input_int[] = {
124 { optInteger, "escapetime", },
125 { optInteger, "keytime", },
126 { optInteger, "matchtime", },
127 { optInteger, "timeout", },
128 { optInteger, "wraplen", },
129 { optInteger, "wrapmargin", },
130 { optTerminator, },
131 }, input_str[] = {
132 { optString, "cedit", },
133 { optString, "filec", },
134 { optTerminator, },
135 }, search[] = {
136 { optToggle, "extended", },
137 { optToggle, "iclower", },
138 { optToggle, "ignorecase", },
139 { optToggle, "magic", },
140 { optToggle, "searchincr", },
141 { optToggle, "wrapscan", },
142 { optTerminator, },
143 }, search_str[] = {
144 { optString, "paragraphs", },
145 { optString, "sections", },
146 { optTerminator, },
147 };
148
149 /* ********* NOTE ***********
150 * Sheet 0 will always be shown first. It does not matter to the Xt code
151 * which sheet that is, so it ought to be the one users interact with most.
152 * Best guess is that's general editor options, but it might be Search/re.
153 * ********* NOTE ***********
154 */
155 static optSheet sheets[] = {
156 { "Display",
157 "These options control how text is displayed on the screen",
158 NULL,
159 display,
160 display_int,
161 display_str,
162 },
163 { "Files",
164 "These options control how the editor handles files",
165 NULL,
166 files,
167 NULL,
168 files_str,
169 },
170 { "Input",
171 "These options control text input behavior",
172 NULL,
173 input,
174 input_int,
175 input_str,
176 },
177 { "Search/RE",
178 "These options control searching and Regular Expression behavior",
179 NULL,
180 search,
181 NULL,
182 search_str,
183 },
184 { "Editor",
185 "These options control general editor configuration",
186 NULL,
187 general,
188 general_int,
189 general_str,
190 },
191 };
192
193 \f
194 /* callbacks */
195
196 #if defined(SelfTest)
197 void __vi_cancel_cb()
198 {
199 puts( "cancelled" );
200 }
201 #endif
202
203
204 static void destroyed(void)
205 {
206 int i;
207
208 puts( "destroyed" );
209
210 /* some window managers destroy us upon popdown */
211 for (i=0; i<XtNumber(sheets); i++) {
212 sheets[i].holder = NULL;
213 }
214 preferences = NULL;
215 }
216
217
218 static void window_unmapped(Widget w, XtPointer ptr, XEvent *ev, Boolean *cont)
219 {
220 if ( ev->type == UnmapNotify ) {
221 #if defined(SelfTest)
222 puts( "unmapped" );
223 #endif
224 XtPopdown( XtParent( preferences ) );
225 }
226 }
227
228 /*
229 * __vi_editopt --
230 * Set an edit option based on a core message.
231 *
232 * PUBLIC: int __vi_editopt __P((IPVI *, const char *, u_int32_t, const char *, u_int32_t, u_int32_t));
233 */
234 int
235 __vi_editopt(IPVI *ipvi, const char *str1, u_int32_t len1, const char *str2, u_int32_t len2, u_int32_t val1)
236 {
237 optData *opt;
238
239 #undef NSEARCH
240 #define NSEARCH(list) { \
241 for (opt = list; opt->kind != optTerminator; ++opt) \
242 if (!strcmp(opt->name, str1)) \
243 goto found; \
244 }
245
246 NSEARCH(display);
247 NSEARCH(display_int);
248 NSEARCH(display_str);
249 NSEARCH(files);
250 NSEARCH(files_str);
251 NSEARCH(general);
252 NSEARCH(general_int);
253 NSEARCH(general_str);
254 NSEARCH(input);
255 NSEARCH(input_int);
256 NSEARCH(input_str);
257 NSEARCH(search);
258 NSEARCH(search_str);
259
260 return (0);
261
262 found: switch (opt->kind) {
263 case optToggle:
264 opt->value = (void *)val1;
265 break;
266 case optInteger:
267 if (opt->value != NULL)
268 free(opt->value);
269 if ((opt->value = malloc(8)) != NULL)
270 (void)snprintf(opt->value,
271 8, "%lu", (u_long)val1);
272 break;
273 case optString:
274 case optFile:
275 if (opt->value != NULL)
276 free(opt->value);
277 if ((opt->value = malloc(len2)) != NULL)
278 memcpy(opt->value, str2, len2);
279 break;
280 case optTerminator:
281 abort();
282 }
283 return (0);
284 }
285
286 /*
287 * set_opt --
288 * Send a set-edit-option message to core.
289 */
290 static void
291 set_opt(Widget w, XtPointer closure, XtPointer call_data)
292 {
293 optData *opt;
294 Boolean set;
295 IP_BUF ipb;
296 String str;
297 extern IPVI ipvi_motif;
298
299 opt = closure;
300
301 ipb.code = VI_EDITOPT;
302 ipb.str1 = opt->name;
303 ipb.len1 = strlen(opt->name);
304
305 switch (opt->kind) {
306 case optToggle:
307 XtVaGetValues(w, XmNset, &set, 0);
308 ipb.val1 = set;
309 ipb.len2 = 0;
310
311 vi_wsend(&ipvi_motif, "ab1", &ipb);
312 if (ipb.val1) {
313 opt->value = (void *)!set;
314 /*
315 * RAZ:
316 * How do we turn off the button? We don't want to
317 * go recursive where we set it and it calls set_opt
318 * to tell the core. Is that possible?
319 */
320 XtVaSetValues(w, XmNset, &set, 0);
321 break;
322 }
323
324 if (strcmp(opt->name, "ruler") == 0)
325 if (set)
326 __vi_show_text_ruler_dialog(
327 __vi_screen->area, "Ruler");
328 else
329 __vi_clear_text_ruler_dialog();
330 break;
331 case optInteger:
332 str = XmTextFieldGetString(w);
333 ipb.val1 = atoi(str);
334 ipb.len2 = 0;
335 vi_send(vi_ofd, "ab1", &ipb);
336 break;
337 case optFile:
338 case optString:
339 ipb.str2 = XmTextFieldGetString(w);
340 ipb.len2 = strlen(ipb.str2);
341 vi_send(vi_ofd, "ab1", &ipb);
342 break;
343 case optTerminator:
344 abort();
345 }
346 }
347
348 \f
349 /* add toggles to the property sheet */
350
351 #if defined(__STDC__)
352 static void add_toggle( Widget parent, optData *option )
353 #else
354 static void add_toggle( parent, option )
355 Widget parent;
356 optData *option;
357 #endif
358 {
359 Widget w;
360
361 w = XtVaCreateManagedWidget( option->name,
362 xmToggleButtonGadgetClass,
363 parent,
364 XmNset, (Boolean) option->value,
365 0
366 );
367 XtAddCallback( w, XmNvalueChangedCallback, set_opt, option );
368 }
369
370
371 static Widget create_toggles(Widget outer, optData *toggles)
372 {
373 Widget inner;
374 int i;
375
376 inner = XtVaCreateWidget( "toggleOptions",
377 xmRowColumnWidgetClass,
378 outer,
379 XmNpacking, XmPACK_COLUMN,
380 XmNnumColumns, 4,
381 XmNtopAttachment, XmATTACH_FORM,
382 XmNrightAttachment, XmATTACH_FORM,
383 XmNleftAttachment, XmATTACH_FORM,
384 0
385 );
386
387 /* first the booleans */
388 for (i=0; toggles[i].kind != optTerminator; i++) {
389 add_toggle( inner, &toggles[i] );
390 }
391 XtManageChild( inner );
392
393 return inner;
394 }
395
396 \f
397 /* draw text fields and their labels */
398
399 #if defined(__STDC__)
400 static void add_string_options( Widget parent,
401 optData *options
402 )
403 #else
404 static void add_string_options( parent, options )
405 Widget parent;
406 optData *options;
407 #endif
408 {
409 int i;
410 Widget f, w;
411
412 for ( i=0; options[i].kind != optTerminator; i++ ) {
413
414 f = XtVaCreateWidget( "form",
415 xmFormWidgetClass,
416 parent,
417 0
418 );
419
420 XtVaCreateManagedWidget( options[i].name,
421 xmLabelGadgetClass,
422 f,
423 XmNtopAttachment, XmATTACH_FORM,
424 XmNbottomAttachment, XmATTACH_FORM,
425 XmNleftAttachment, XmATTACH_FORM,
426 XmNrightAttachment, XmATTACH_POSITION,
427 XmNrightPosition, 20,
428 XmNalignment, XmALIGNMENT_END,
429 0
430 );
431
432 w = XtVaCreateManagedWidget( "text",
433 xmTextFieldWidgetClass,
434 f,
435 XmNtopAttachment, XmATTACH_FORM,
436 XmNbottomAttachment, XmATTACH_FORM,
437 XmNrightAttachment, XmATTACH_FORM,
438 XmNleftAttachment, XmATTACH_POSITION,
439 XmNleftPosition, 20,
440 0
441 );
442
443 XmTextFieldSetString( w, (char *) options[i].value );
444 XtAddCallback( w, XmNactivateCallback, set_opt, &options[i] );
445 XtManageChild( f );
446 }
447 }
448
449 \f
450 /* draw and display a single page of properties */
451
452 #if defined(__STDC__)
453 static Widget create_sheet( Widget parent, optSheet *sheet )
454 #else
455 static Widget create_sheet( parent, sheet )
456 Widget parent;
457 optSheet *sheet;
458 #endif
459 {
460 Widget outer, inner, frame;
461 Dimension height;
462 XmString str;
463
464 outer = XtVaCreateWidget( sheet->name,
465 xmFormWidgetClass,
466 parent,
467 XmNtopAttachment, XmATTACH_FORM,
468 XmNrightAttachment, XmATTACH_FORM,
469 XmNbottomAttachment, XmATTACH_FORM,
470 XmNleftAttachment, XmATTACH_FORM,
471 XmNshadowType, XmSHADOW_ETCHED_IN,
472 XmNshadowThickness, 2,
473 XmNverticalSpacing, 4,
474 XmNhorizontalSpacing, 4,
475 0
476 );
477
478 /* add descriptive text */
479 frame = XtVaCreateManagedWidget( "frame",
480 xmFrameWidgetClass,
481 outer,
482 XmNtopAttachment, XmATTACH_FORM,
483 XmNrightAttachment, XmATTACH_FORM,
484 XmNleftAttachment, XmATTACH_FORM,
485 0
486 );
487 str = XmStringCreateLtoR( sheet->description, XmSTRING_DEFAULT_CHARSET );
488 XtVaCreateManagedWidget( "description",
489 xmLabelGadgetClass,
490 frame,
491 XmNlabelString, str,
492 0
493 );
494 XmStringFree( str );
495
496 /* Add the toggles. */
497 inner = create_toggles( outer, sheet->toggles );
498 XtVaSetValues( inner,
499 XmNtopAttachment, XmATTACH_WIDGET,
500 XmNtopWidget, frame,
501 0
502 );
503
504 /* the string options go here */
505 inner = XtVaCreateWidget( "otherOptions",
506 xmRowColumnWidgetClass,
507 outer,
508 XmNpacking, XmPACK_COLUMN,
509 XmNtopAttachment, XmATTACH_WIDGET,
510 XmNtopWidget, inner,
511 XmNrightAttachment, XmATTACH_FORM,
512 XmNbottomAttachment, XmATTACH_FORM,
513 XmNleftAttachment, XmATTACH_FORM,
514 0
515 );
516
517 /* Optionally, the ints. */
518 if ( sheet->ints != NULL )
519 add_string_options( inner, sheet->ints );
520
521 /* Optionally, the rest. */
522 if ( sheet->others != NULL )
523 add_string_options( inner, sheet->others );
524
525 XtManageChild( inner );
526
527 /* finally, force resize of the parent */
528 XtVaGetValues( outer, XmNheight, &height, 0 );
529 XtVaSetValues( parent, XmNheight, height, 0 );
530
531 return outer;
532 }
533
534 \f
535 /* change preferences to another sheet */
536
537 static void change_sheet(Widget parent, int current)
538 {
539 static int current_sheet = -1;
540
541 /* create a new one? */
542 if ( sheets[current].holder == NULL )
543 sheets[current].holder = create_sheet( parent, &sheets[current] );
544
545 /* done with the old one? */
546 if ( current_sheet != -1 && sheets[current_sheet].holder != NULL )
547 XtUnmanageChild( sheets[current_sheet].holder );
548
549 current_sheet = current;
550 XtManageChild( sheets[current].holder );
551 XtManageChild( parent );
552 }
553
554 \f
555 /* Draw and display a dialog the describes vi options */
556
557 #if defined(__STDC__)
558 static Widget create_options_dialog( Widget parent, String title )
559 #else
560 static Widget create_options_dialog( parent, title )
561 Widget parent;
562 String title;
563 #endif
564 {
565 Widget box, form, inner;
566 int i;
567 char buffer[1024];
568
569 /* already built? */
570 if ( preferences != NULL ) return preferences;
571
572 box = XtVaCreatePopupShell( title,
573 xmDialogShellWidgetClass,
574 parent,
575 XmNtitle, title,
576 XmNallowShellResize, False,
577 0
578 );
579 XtAddCallback( box, XmNpopdownCallback, __vi_cancel_cb, 0 );
580 XtAddCallback( box, XmNdestroyCallback, destroyed, 0 );
581 XtAddEventHandler( box,
582 SubstructureNotifyMask,
583 False,
584 window_unmapped,
585 NULL
586 );
587
588 form = XtVaCreateWidget( "options",
589 xmFormWidgetClass,
590 box,
591 0
592 );
593
594 /* copy the pointers to the sheet names */
595 *buffer = '\0';
596 for (i=0; i<XtNumber(sheets); i++) {
597 strcat( buffer, "|" );
598 strcat( buffer, sheets[i].name );
599 }
600
601 inner = __vi_CreateTabbedFolder( "tabs",
602 form,
603 buffer,
604 XtNumber(sheets),
605 change_sheet
606 );
607
608 /* build the property sheets early */
609 for ( i=0; i<XtNumber(sheets); i++ )
610 change_sheet( inner, i );
611
612 /* manage all of the sheets right now */
613 for ( i=0; i<XtNumber(sheets); i++ )
614 XtManageChild( sheets[i].holder );
615 XtManageChild( form );
616
617 /* remove all but the first one */
618 for ( i=0; i<XtNumber(sheets); i++ )
619 XtUnmanageChild( sheets[i].holder );
620 change_sheet( inner, 0 ); /* show first sheet first */
621
622 /* keep this global, we might destroy it later */
623 preferences = form;
624
625 /* done */
626 return form;
627 }
628
629
630 \f
631 /*
632 * module entry point
633 *
634 * __vi_show_options_dialog --
635 *
636 *
637 * PUBLIC: void __vi_show_options_dialog __P((Widget, String));
638 */
639 void
640 __vi_show_options_dialog(Widget parent, String title)
641 {
642 Widget db = create_options_dialog( parent, title );
643 #if defined(SelfTest)
644 Widget shell = XtParent( db );
645 #endif
646
647 XtManageChild( db );
648
649 #if defined(SelfTest)
650 /* wait until it goes away */
651 XtPopup( shell, XtGrabNone );
652 #else
653 /* wait until it goes away */
654 __vi_modal_dialog( db );
655 #endif
656 }
657
658
659 \f
660 /* module entry point
661 * Utilities for the search dialog
662 *
663 * __vi_toggle --
664 * Returns the current value of a toggle.
665 *
666 * PUBLIC: int __vi_toggle __P((char *));
667 */
668 int
669 __vi_toggle(char *name)
670 {
671 optData *opt;
672
673 #undef NSEARCH
674 #define NSEARCH(list) { \
675 for (opt = list; opt->kind != optTerminator; ++opt) \
676 if (!strcmp(opt->name, name)) \
677 return ((int)opt->value); \
678 }
679 NSEARCH(display);
680 NSEARCH(files);
681 NSEARCH(general);
682 NSEARCH(input);
683 NSEARCH(search);
684
685 return (0);
686 }
687
688 /*
689 * __vi_create_search_toggles --
690 * Creates the search toggles. This is so the options and search widgets
691 * share their appearance.
692 *
693 * PUBLIC: Widget __vi_create_search_toggles __P((Widget, optData[]));
694 */
695 Widget
696 __vi_create_search_toggles(Widget parent, optData *list)
697 {
698 optData *opt;
699
700 /*
701 * Copy current options information into the search table.
702 *
703 * XXX
704 * This is an O(M*N) loop, but I don't think it matters.
705 */
706 for (opt = list; opt->kind != optTerminator; ++opt)
707 opt->value = (void *)__vi_toggle(opt->name);
708
709 return (create_toggles(parent, list));
710 }
711
712 \f
713 #if defined(SelfTest)
714
715 #if defined(__STDC__)
716 static void show_options( Widget w, XtPointer data, XtPointer cbs )
717 #else
718 static void show_options( w, data, cbs )
719 Widget w;
720 XtPointer data;
721 XtPointer cbs;
722 #endif
723 {
724 __vi_show_options_dialog( data, "Preferences" );
725 }
726
727 main( int argc, char *argv[] )
728 {
729 XtAppContext ctx;
730 Widget top_level, rc, button;
731 extern exit();
732
733 /* create a top-level shell for the window manager */
734 top_level = XtVaAppInitialize( &ctx,
735 argv[0],
736 NULL, 0, /* options */
737 (ArgcType) &argc,
738 argv, /* might get modified */
739 NULL,
740 NULL
741 );
742
743 rc = XtVaCreateManagedWidget( "rc",
744 xmRowColumnWidgetClass,
745 top_level,
746 0
747 );
748
749 button = XtVaCreateManagedWidget( "Pop up options dialog",
750 xmPushButtonGadgetClass,
751 rc,
752 0
753 );
754 XtAddCallback( button, XmNactivateCallback, show_options, rc );
755
756 button = XtVaCreateManagedWidget( "Quit",
757 xmPushButtonGadgetClass,
758 rc,
759 0
760 );
761 XtAddCallback( button, XmNactivateCallback, exit, 0 );
762
763 XtRealizeWidget(top_level);
764 XtAppMainLoop(ctx);
765 }
766 #endif
MINIX 3 (repo.or.cz mirror)