?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
prism2.device: Compiler delint
[AROS.git] / workbench / utilities / Installer / gui_zune.c
blob540eac35db95d9269e0795d168ff9e06798cb138
1 /*
2 Copyright © 1995-2003, The AROS Development Team. All rights reserved.
3 $Id$
4 */
5
6 /* gui_zune.c -- here are all functions for the ZUNE gui */
7
8 #include "Installer.h"
9 #include "cleanup.h"
10 #include "execute.h"
11 #include "locale.h"
12 #include "texts.h"
13 #include "misc.h"
14 #include "gui.h"
15 #include "variables.h"
16
17 /* External variables */
18 extern BPTR inputfile;
19 extern char buffer[MAXARGSIZE];
20 extern char *filename;
21 extern InstallerPrefs preferences;
22 extern int error, grace_exit;
23 extern int doing_abort;
24
25 #include <exec/types.h>
26 #include <stdlib.h>
27 #include <stdio.h>
28 #include <string.h>
29
30 #include <proto/intuition.h>
31 #include <proto/muimaster.h>
32 #include <libraries/mui.h>
33 #ifdef __AROS__
34 #include <libraries/coolimages.h>
35 #else
36 #define HBar(x) MUI_MakeObject(MUIO_HBar,x)
37 #define CoolImageIDButton(label,imageid) SimpleButton(label)
38 #endif
39
40 Object *app;
41 Object *wnd;
42 Object *reqwnd, *helpwnd, *helptext;
43 Object *reqroot, *root;
44 Object *btproceed, *btabort, *btskip, *bthelp;
45 Object *intermediate = NULL;
46
47 enum
48 {
49 Push_NULL,
50 Push_Proceed,
51 Push_Abort,
52 Push_Skip,
53 Push_Help,
54 Push_About,
55 Push_Ok,
56 Push_Cancel,
57 Push_Last
58 };
59
60
61 /* ######################################################################## */
62
63 void AddContents(Object *obj)
64 {
65 DoMethod(root, MUIM_Group_InitChange);
66 if (intermediate != NULL)
67 {
68 DoMethod(root, OM_REMMEMBER, (IPTR)intermediate);
69 MUI_DisposeObject(intermediate);
70 intermediate = NULL;
71 }
72 DoMethod(root, OM_ADDMEMBER, (IPTR)obj);
73 DoMethod(root, MUIM_Group_ExitChange);
74 }
75 void DelContents(Object *obj)
76 {
77 DoMethod(root, MUIM_Group_InitChange);
78 DoMethod(root, OM_REMMEMBER, (IPTR)obj);
79 DoMethod(root, MUIM_Group_ExitChange);
80 MUI_DisposeObject(obj);
81 }
82
83 #define WaitCTRL(sigs) \
84 if (sigs) \
85 { \
86 sigs = Wait(sigs | SIGBREAKF_CTRL_C | SIGBREAKF_CTRL_D); \
87 if (sigs & SIGBREAKF_CTRL_C) break; \
88 if (sigs & SIGBREAKF_CTRL_D) break; \
89 }
90
91 #define disable_abort(val) set(btabort, MUIA_Disabled, val)
92 #define disable_skip(val) set(btskip, MUIA_Disabled, val)
93 #define disable_help(val) set(bthelp, MUIA_Disabled, val)
94
95 #define NeedPROMPT(pl) \
96 if ( GetPL(pl, _PROMPT).intval == 0 ) \
97 { \
98 error = SCRIPTERROR; \
99 traperr("Missing prompt!\n", NULL); \
100 }
101
102 #define NeedHELP(pl) \
103 if ( GetPL(pl, _HELP).intval == 0 ) \
104 { \
105 error = SCRIPTERROR; \
106 traperr("Missing help!\n", NULL); \
107 }
108
109 #define TRANSSCRIPT() \
110 if ( preferences.transcriptstream != BNULL ) \
111 { \
112 int len = 0; \
113 char *out; \
114 int m = GetPL(pl, _PROMPT).intval; \
115 for ( i = 0 ; i < m ; i ++ ) \
116 { \
117 len += strlen(GetPL(pl, _PROMPT).arg[i]) + 2; \
118 } \
119 out = AllocVec((len+2)*sizeof(char), MEMF_PUBLIC); \
120 outofmem(out); \
121 out[0] = 0; \
122 for ( i = 0 ; i < m ; i ++ ) \
123 { \
124 strcat(out,">"); \
125 strcat(out,GetPL(pl, _PROMPT).arg[i]); \
126 strcat(out,"\n"); \
127 } \
128 Write(preferences.transcriptstream, out, len); \
129 FreeVec(out); \
130 }
131
132 /*
133 * Ask user if he really wants to abort
134 */
135 void abort_install()
136 {
137 BOOL running = TRUE, quit = FALSE;
138 LONG sigs = 0;
139 Object *wc;
140 Object *btok, *btcancel;
141
142 wc = VGroup,
143 Child, TextObject,
144 GroupFrameT(_(MSG_MESSAGE)),
145 MUIA_Text_Contents, (IPTR)ASKQUIT_STRING,
146 End,
147 Child, HBar(TRUE),
148 Child, HGroup,
149 MUIA_Group_SameSize, TRUE,
150 Child, btok = CoolImageIDButton(_(MSG_OK), COOL_USEIMAGE_ID),
151 Child, btcancel = CoolImageIDButton(_(MSG_CANCEL), COOL_CANCELIMAGE_ID),
152 End,
153 End;
154 set(btok,MUIA_CycleChain,1);
155 set(btcancel,MUIA_CycleChain,1);
156 DoMethod(btok, MUIM_Notify, MUIA_Pressed, FALSE,(IPTR)app, 2, MUIM_Application_ReturnID, Push_Ok);
157 DoMethod(btcancel, MUIM_Notify, MUIA_Pressed, FALSE,(IPTR)app, 2, MUIM_Application_ReturnID, Push_Cancel);
158 DoMethod(reqroot, OM_ADDMEMBER, (IPTR)wc);
159
160 set(reqwnd, MUIA_Window_Open, TRUE);
161 while (running)
162 {
163 switch (DoMethod(app,MUIM_Application_NewInput,(IPTR)&sigs))
164 {
165 case Push_Cancel:
166 running = FALSE;
167 break;
168 case Push_Ok:
169 quit = TRUE;
170 running = FALSE;
171 break;
172 default:
173 break;
174 }
175 WaitCTRL(sigs);
176 }
177 set(reqwnd, MUIA_Window_Open, FALSE);
178
179 DoMethod(reqroot, OM_REMMEMBER, (IPTR)wc);
180 MUI_DisposeObject(wc);
181
182 if (quit)
183 {
184 error = USERABORT;
185 grace_exit = TRUE;
186 /* Execute trap(1) */
187 traperr( "User aborted!\n", NULL );
188 }
189 }
190
191
192 /* ######################################################################## */
193
194
195 const char GuiWinTitle[] ="AROS - Installer V43.3";
196
197
198 #define WINDOWWIDTH 400
199 #define WINDOWHEIGHT 300
200
201 void helpwin(char *title, char *text)
202 {
203 BOOL running = TRUE;
204 LONG sigs = 0;
205
206 set(helptext, MUIA_Text_Contents, text);
207 set(helpwnd, MUIA_Window_Title, title);
208 set(helpwnd, MUIA_Window_Open, TRUE);
209 while (running)
210 {
211 switch (DoMethod(app,MUIM_Application_NewInput,(IPTR)&sigs))
212 {
213 case MUIV_Application_ReturnID_Quit:
214 running = FALSE;
215 break;
216 default:
217 break;
218 }
219 WaitCTRL(sigs);
220 }
221 set(helpwnd, MUIA_Window_Open, FALSE);
222 }
223
224
225 void helpwinpl(char *title, struct ParameterList *pl, int what)
226 {
227 char *text;
228
229 text = collatestrings(GetPL(pl, what).intval, GetPL(pl, what).arg);
230 if ( text != NULL )
231 {
232 helpwin(title, text);
233 FreeVec(text);
234 }
235 }
236
237
238 /*
239 * Initialize the GUI
240 */
241 void init_gui()
242 {
243 struct Screen *scr;
244
245 scr = LockPubScreen(NULL);
246
247 app = ApplicationObject,
248 MUIA_Application_Title, "AROS - Installer",
249 MUIA_Application_DoubleStart, TRUE,
250
251 SubWindow, wnd = WindowObject,
252 MUIA_Window_Title, GuiWinTitle,
253 MUIA_Window_Width, WINDOWWIDTH,
254 MUIA_Window_Height, WINDOWHEIGHT,
255 MUIA_Window_CloseGadget, FALSE,
256 MUIA_Window_NoMenus, TRUE,
257 MUIA_Window_ID, MAKE_ID('A','I','N','S'),
258 WindowContents, VGroup,
259 Child, root = VGroup, End,
260 Child, HBar(TRUE),
261 Child, HGroup,
262 MUIA_Group_SameSize, TRUE,
263 Child, btproceed = CoolImageIDButton("Proceed", COOL_USEIMAGE_ID),
264 Child, btabort = CoolImageIDButton("Abort", COOL_CANCELIMAGE_ID),
265 Child, btskip = CoolImageIDButton("Skip", COOL_WARNIMAGE_ID),
266 Child, bthelp = CoolImageIDButton("Help", COOL_INFOIMAGE_ID),
267 End,
268 End,
269 End,
270 SubWindow, helpwnd = WindowObject,
271 MUIA_Window_Width, WINDOWWIDTH,
272 MUIA_Window_Height, WINDOWHEIGHT,
273 MUIA_Window_CloseGadget, TRUE,
274 MUIA_Window_SizeGadget, FALSE,
275 MUIA_Window_NoMenus, TRUE,
276 WindowContents, VGroup,
277 Child, helptext = TextObject,
278 GroupFrame,
279 MUIA_Background, MUII_GroupBack,
280 MUIA_Text_Contents, (IPTR)NULL,
281 End,
282 Child, VSpace(1),
283 End,
284 End,
285 SubWindow, reqwnd = WindowObject,
286 MUIA_Window_Width, WINDOWWIDTH,
287 MUIA_Window_Height, WINDOWHEIGHT,
288 MUIA_Window_CloseGadget, FALSE,
289 MUIA_Window_SizeGadget, FALSE,
290 MUIA_Window_NoMenus, TRUE,
291 WindowContents, VGroup,
292 Child, reqroot = VGroup, End,
293 End,
294 End,
295 End;
296 if (app == NULL)
297 {
298 /* failed to initialize GUI */
299 #if DEBUG
300 printf("Failed to intialize Zune GUI\n");
301 #endif
302 exit(-1);
303 }
304 set(btproceed,MUIA_CycleChain,1);
305 set(btabort,MUIA_CycleChain,1);
306 set(btskip,MUIA_CycleChain,1);
307 set(bthelp,MUIA_CycleChain,1);
308 DoMethod(helpwnd, MUIM_Notify, MUIA_Window_CloseRequest, TRUE, (IPTR)app, 2,
309 MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
310
311 DoMethod(btproceed, MUIM_Notify, MUIA_Pressed, FALSE,(IPTR)app, 2,
312 MUIM_Application_ReturnID, Push_Proceed);
313 DoMethod(btabort, MUIM_Notify, MUIA_Pressed, FALSE,(IPTR)app, 2,
314 MUIM_Application_ReturnID, Push_Abort);
315 DoMethod(btskip, MUIM_Notify, MUIA_Pressed, FALSE,(IPTR)app, 2,
316 MUIM_Application_ReturnID, Push_Skip);
317 DoMethod(bthelp, MUIM_Notify, MUIA_Pressed, FALSE,(IPTR)app, 2,
318 MUIM_Application_ReturnID, Push_Help);
319 set(wnd, MUIA_Window_Open, TRUE);
320 UnlockPubScreen(NULL, scr);
321 }
322
323 /*
324 * Close GUI
325 */
326 void deinit_gui()
327 {
328 set(wnd, MUIA_Window_Open, FALSE);
329 MUI_DisposeObject(app);
330 }
331
332
333 /*
334 * Show user that we are going to "(abort)" install
335 * Don't confuse NOVICE...
336 */
337 void show_abort(char *msg)
338 {
339 BOOL running = TRUE;
340 ULONG sigs = 0;
341 Object *wc;
342
343 if ( get_var_int("@user-level") > _NOVICE )
344 {
345 disable_abort(TRUE);
346 disable_skip(TRUE);
347 disable_help(TRUE);
348
349 wc = VGroup,
350 Child, TextObject,
351 GroupFrameT("Aborting Installation:"),
352 MUIA_Text_Contents, (IPTR)(msg),
353 End,
354 End;
355
356 if (wc)
357 {
358 AddContents(wc);
359
360 while (running)
361 {
362 switch (DoMethod(app,MUIM_Application_NewInput,(IPTR)&sigs))
363 {
364 case Push_Proceed:
365 running = FALSE;
366 break;
367 default:
368 break;
369 }
370 WaitCTRL(sigs);
371 }
372
373 DelContents(wc);
374 }
375
376 disable_abort(FALSE);
377 disable_skip(FALSE);
378 disable_help(FALSE);
379 }
380
381 }
382
383
384 /*
385 * Show user how much we have completed yet
386 */
387 void show_complete(long int percent)
388 {
389 char *text;
390
391 text = AllocVec(strlen(GuiWinTitle) + 13, MEMF_PUBLIC);
392 if ( text == NULL )
393 {
394 end_alloc();
395 }
396 sprintf(text, "%s (Done %3ld%%)", GuiWinTitle, percent);
397 set(wnd, MUIA_Window_Title, text);
398 FreeVec(text);
399 }
400
401
402 /*
403 * Show user that we "(exit)" the installation
404 */
405 void show_exit(char *msg)
406 {
407 BOOL running = TRUE;
408 ULONG sigs = 0;
409 Object *wc;
410 char *msg2;
411
412 msg2 = AllocVec((strlen(msg)+strlen(DONE_TEXT))*sizeof(char), MEMF_PUBLIC);
413 msg2[0] = 0;
414 strcat(msg2,msg);
415 strcat(msg2,DONE_TEXT);
416 disable_abort(TRUE);
417 disable_skip(TRUE);
418 disable_help(TRUE);
419
420 wc = VGroup,
421 Child, TextObject,
422 GroupFrameT("Aborting Installation:"),
423 MUIA_Text_Contents, (IPTR)(msg2),
424 End,
425 End;
426
427 if (wc)
428 {
429 AddContents(wc);
430
431 while (running)
432 {
433 switch (DoMethod(app,MUIM_Application_NewInput,(IPTR)&sigs))
434 {
435 case Push_Proceed:
436 running = FALSE;
437 break;
438 default:
439 break;
440 }
441 WaitCTRL(sigs);
442 }
443
444 DelContents(wc);
445 }
446
447 disable_abort(FALSE);
448 disable_skip(FALSE);
449 disable_help(FALSE);
450 }
451
452
453 /*
454 * Show the line which caused the parse-error
455 */
456 void show_parseerror(char * msg, int errline)
457 {
458 }
459
460
461 /*
462 * Tell user that some big task is to be done
463 * "Be patient..."
464 */
465 void show_working(char *msg)
466 {
467 if (intermediate != NULL)
468 {
469 DelContents(intermediate);
470 }
471
472 intermediate = VGroup,
473 Child, TextObject,
474 GroupFrameT(_(MSG_MESSAGE)),
475 MUIA_Text_Contents, (IPTR)(msg),
476 End,
477 End;
478
479 if (intermediate)
480 {
481 DoMethod(root, MUIM_Group_InitChange);
482 DoMethod(root, OM_ADDMEMBER, (IPTR)intermediate);
483 DoMethod(root, MUIM_Group_ExitChange);
484 }
485 }
486
487
488 /*
489 * Display a "(message)" to the user
490 * Don't confuse NOVICE unless "(all)" users want to get this info
491 */
492 void show_message(char * msg, struct ParameterList * pl)
493 {
494 BOOL running = TRUE;
495 ULONG sigs = 0;
496 Object *wc;
497
498 if ( GetPL(pl, _ALL).used == 1 || get_var_int("@user-level") > _NOVICE )
499 {
500 disable_skip(TRUE);
501 if ( GetPL(pl, _HELP).used != 1 )
502 {
503 disable_help(TRUE);
504 }
505
506 wc = VGroup,
507 Child, TextObject,
508 GroupFrameT(_(MSG_MESSAGE)),
509 MUIA_Text_Contents, (IPTR)(msg),
510 End,
511 End;
512
513 if (wc)
514 {
515 AddContents(wc);
516
517 while (running)
518 {
519 switch (DoMethod(app,MUIM_Application_NewInput,(IPTR)&sigs))
520 {
521 case Push_Abort:
522 abort_install();
523 break;
524 case Push_Proceed:
525 running = FALSE;
526 break;
527 case Push_Help:
528 helpwinpl(HELP_ON_MESSAGE, pl, _HELP);
529 break;
530 default:
531 break;
532 }
533 WaitCTRL(sigs);
534 }
535
536 DelContents(wc);
537 }
538
539 disable_skip(FALSE);
540 disable_help(FALSE);
541 }
542 }
543
544
545 /*
546 * Ask user for his user-level
547 */
548 void request_userlevel(char *msg)
549 {
550 BOOL running = TRUE;
551 ULONG sigs = 0;
552 Object *wc;
553 Object *btabout;
554
555 LONG usrlevel, logval;
556 char *welcome;
557
558 Object *levelmx;
559 char **mxlabels;
560
561 /* Ask for User Level */
562 usrlevel = preferences.defusrlevel;
563 disable_skip(TRUE);
564
565 if ( msg != NULL )
566 {
567 welcome = StrDup(msg);
568 }
569 else
570 {
571 welcome = AllocVec(sizeof(char *)*(strlen(WELCOME_TEMPLATE)+strlen(get_var_arg("@app-name"))), MEMF_PUBLIC);
572 outofmem(welcome);
573 sprintf(welcome, WELCOME_TEMPLATE, get_var_arg("@app-name"));
574 }
575 mxlabels = AllocVec(4*sizeof(STRPTR), MEMF_PUBLIC);
576 mxlabels[0] = StrDup(NOVICE_NAME);
577 mxlabels[1] = StrDup(ADVANCED_NAME);
578 mxlabels[2] = StrDup(EXPERT_NAME);
579 mxlabels[3] = NULL;
580
581
582 wc = VGroup,
583 Child, VGroup, GroupFrame,
584 Child, TextObject,
585 GroupFrame,
586 MUIA_Background, MUII_GroupBack,
587 MUIA_Text_Contents, (IPTR)(welcome),
588 End,
589 Child, levelmx = RadioObject,
590 GroupFrameT(USERLEVEL_REQUEST),
591 MUIA_Radio_Entries, (IPTR)(mxlabels),
592 End,
593 Child, btabout = CoolImageIDButton("About Installer" ,COOL_ASKIMAGE_ID),
594 End,
595 End;
596
597 if (wc)
598 {
599 set(levelmx, MUIA_Radio_Active, usrlevel);
600 DoMethod(btabout, MUIM_Notify, MUIA_Pressed, FALSE,(IPTR)app, 2, MUIM_Application_ReturnID, Push_About);
601 AddContents(wc);
602
603 while (running)
604 {
605 switch (DoMethod(app,MUIM_Application_NewInput,(IPTR)&sigs))
606 {
607 case Push_Abort:
608 abort_install();
609 break;
610 case Push_Proceed:
611 running = FALSE;
612 break;
613 case Push_Help:
614 helpwin(HELP_ON_USERLEVEL, USERLEVEL_HELP);
615 break;
616 case Push_About:
617 {
618 char *helptext;
619
620 /* TODO: help/about for Installer */
621 helptext = AllocVec(512 * sizeof(char), MEMF_PUBLIC);
622 sprintf(helptext, ABOUT_INSTALLER, INSTALLER_VERSION, INSTALLER_REVISION);
623 helpwin(ABOUT_ON_INSTALLER, helptext);
624 FreeVec(helptext);
625 }
626 break;
627 default:
628 break;
629 }
630 WaitCTRL(sigs);
631 }
632 GetAttr(MUIA_Radio_Active, levelmx, (IPTR *)&usrlevel);
633 set_variable("@user-level", NULL, usrlevel);
634
635 DelContents(wc);
636 }
637 FreeVec(welcome);
638 FreeVec(mxlabels[0]);
639 FreeVec(mxlabels[1]);
640 FreeVec(mxlabels[2]);
641
642 /* Ask for Logfile creation */
643 if ( usrlevel > 0 )
644 {
645 mxlabels[0] = StrDup(LOG_FILE_TEXT);
646 mxlabels[1] = StrDup(LOG_PRINT_TEXT);
647 mxlabels[2] = StrDup(LOG_NOLOG_TEXT);
648
649 wc = VGroup,
650 Child, levelmx = RadioObject,
651 GroupFrameT(LOG_QUESTION),
652 MUIA_Radio_Entries, (IPTR)(mxlabels),
653 End,
654 End;
655
656 if (wc)
657 {
658 AddContents(wc);
659
660 running = TRUE;
661 while (running)
662 {
663 switch (DoMethod(app,MUIM_Application_NewInput,(IPTR)&sigs))
664 {
665 case Push_Abort:
666 abort_install();
667 break;
668 case Push_Proceed:
669 running = FALSE;
670 break;
671 case Push_Help:
672 {
673 char *helptext;
674
675 /* TODO: help for logfile-requester */
676 helptext = AllocVec(512 * sizeof(char), MEMF_PUBLIC);
677 sprintf(helptext, LOG_HELP, preferences.transcriptfile);
678 helpwin(HELP_ON_LOGFILES, helptext);
679 FreeVec(helptext);
680 }
681 break;
682 default:
683 break;
684 }
685 WaitCTRL(sigs);
686 }
687 GetAttr(MUIA_Radio_Active, levelmx, (IPTR *)&logval);
688 switch (logval)
689 {
690 case 0: /* Log to file */
691 /* TODO: Handle Logging output selection */
692 break;
693 case 1: /* Log to printer */
694 FreeVec(preferences.transcriptfile);
695 preferences.transcriptfile = StrDup("PRT:");
696 break;
697 case 2: /* No Log */
698 FreeVec(preferences.transcriptfile);
699 preferences.transcriptfile = NULL;
700 break;
701 }
702
703 DelContents(wc);
704 }
705 FreeVec(mxlabels[0]);
706 FreeVec(mxlabels[1]);
707 FreeVec(mxlabels[2]);
708
709 if (!preferences.nopretend)
710 {
711 mxlabels[0] = StrDup(NOPRETEND_TEXT);
712 mxlabels[1] = StrDup(PRETEND_TEXT);
713 mxlabels[2] = NULL;
714
715 wc = VGroup,
716 Child, levelmx = RadioObject,
717 GroupFrameT(PRETEND_QUESTION),
718 MUIA_Radio_Entries, (IPTR)(mxlabels),
719 End,
720 End;
721
722 if (wc)
723 {
724 AddContents(wc);
725
726 running = TRUE;
727 while (running)
728 {
729 switch (DoMethod(app,MUIM_Application_NewInput,(IPTR)&sigs))
730 {
731 case Push_Abort:
732 abort_install();
733 break;
734 case Push_Proceed:
735 running = FALSE;
736 break;
737 case Push_Help:
738 helpwin(HELP_ON_PRETEND, PRETEND_HELP);
739 break;
740 default:
741 break;
742 }
743 WaitCTRL(sigs);
744 }
745 GetAttr(MUIA_Radio_Active, levelmx, (IPTR *)&logval);
746 switch (logval)
747 {
748 case 0: /* Really Install */
749 preferences.pretend = FALSE;
750 break;
751 case 1: /* Only pretend to install */
752 preferences.pretend = TRUE;
753 break;
754 }
755
756 DelContents(wc);
757 }
758
759 FreeVec(mxlabels[0]);
760 FreeVec(mxlabels[1]);
761 }
762 }
763
764 FreeVec(mxlabels);
765 disable_skip(FALSE);
766 }
767
768
769 /*
770 * Ask user for a boolean
771 */
772 long int request_bool(struct ParameterList *pl)
773 {
774 long int retval;
775 char **mxlabels;
776 int i, m;
777
778 NeedPROMPT(pl);
779 NeedHELP(pl);
780
781 m = GetPL(pl, _PROMPT).intval;
782
783 retval = ( GetPL(pl, _DEFAULT).intval != 0 );
784
785 mxlabels = AllocVec(3*sizeof(STRPTR), MEMF_PUBLIC);
786 outofmem(mxlabels);
787 if ( GetPL(pl, _CHOICES).used == 1 )
788 {
789 if (GetPL(pl, _CHOICES).intval >= 2)
790 {
791 mxlabels[0] = StrDup(GetPL(pl, _CHOICES).arg[0]);
792 mxlabels[1] = StrDup(GetPL(pl, _CHOICES).arg[1]);
793 }
794 else if (GetPL(pl, _CHOICES).intval == 1)
795 {
796 mxlabels[0] = StrDup(GetPL(pl, _CHOICES).arg[0]);
797 mxlabels[1] = StrDup(_(MSG_NO));
798 }
799 else
800 {
801 mxlabels[0] = StrDup(_(MSG_YES));
802 mxlabels[1] = StrDup(_(MSG_NO));
803 }
804 }
805 else
806 {
807 mxlabels[0] = StrDup(_(MSG_YES));
808 mxlabels[1] = StrDup(_(MSG_NO));
809 }
810 mxlabels[2] = NULL;
811
812 TRANSSCRIPT();
813
814 if ( get_var_int("@user-level") > _NOVICE )
815 {
816 char *out;
817 BOOL running = TRUE;
818 Object *levelmx, *wc;
819 ULONG sigs = 0;
820
821 disable_skip(TRUE);
822 out = collatestrings(m, GetPL(pl, _PROMPT).arg);
823
824 wc = VGroup,
825 Child, VGroup, GroupFrame,
826 MUIA_Background, MUII_GroupBack,
827 Child, TextObject,
828 MUIA_Text_Contents, (IPTR)(out),
829 End,
830 Child, levelmx = RadioObject,
831 MUIA_Radio_Entries, (IPTR)(mxlabels),
832 End,
833 End,
834 End;
835
836 if (wc)
837 {
838 AddContents(wc);
839
840 while (running)
841 {
842 switch (DoMethod(app,MUIM_Application_NewInput,(IPTR)&sigs))
843 {
844 case Push_Abort:
845 abort_install();
846 break;
847 case Push_Proceed:
848 running = FALSE;
849 break;
850 case Push_Help:
851 if (GetPL(pl, _HELP).intval)
852 {
853 helpwinpl(HELP_ON_ASKNUMBER, pl, _HELP);
854 }
855 else
856 {
857 helpwin(HELP_ON_ASKNUMBER, get_var_arg("@asknumber-help"));
858 }
859 break;
860 default:
861 break;
862 }
863 WaitCTRL(sigs);
864 }
865 GetAttr(MUIA_Radio_Active, levelmx, &retval);
866
867 DelContents(wc);
868 }
869 FreeVec(out);
870 disable_skip(FALSE);
871 }
872 if ( preferences.transcriptstream != BNULL )
873 {
874 Write(preferences.transcriptstream, "Ask Question: Result was \"", 26);
875 Write(preferences.transcriptstream, mxlabels[retval], strlen(mxlabels[retval]));
876 Write(preferences.transcriptstream, "\".\n\n", 4);
877 }
878 FreeVec(mxlabels[0]);
879 FreeVec(mxlabels[1]);
880 FreeVec(mxlabels);
881
882 return retval;
883 }
884
885
886 /*
887 * Ask user for a number
888 */
889 long int request_number(struct ParameterList *pl)
890 {
891 long int retval;
892 long int i, min, max;
893 char minmax[MAXARGSIZE];
894
895 retval = GetPL( pl, _DEFAULT ).intval;
896 if ( GetPL( pl, _RANGE ).used == 1 )
897 {
898 min = GetPL( pl, _RANGE ).intval;
899 max = GetPL( pl, _RANGE ).intval2;
900 /* Wrong order ? Change order */
901 if ( max < min )
902 {
903 i = min;
904 min = max;
905 max = i;
906 }
907 sprintf(minmax, "Range = [%ld, %ld]", min, max);
908 }
909 else
910 {
911 minmax[0] = 0;
912 #define INTMAX 32767
913 max = INTMAX;
914 min = ( retval < 0 ) ? retval : 0;
915 }
916
917
918 TRANSSCRIPT();
919 if ( get_var_int( "@user-level" ) > _NOVICE )
920 {
921 char *out;
922 BOOL running = TRUE;
923 Object *st, *wc;
924 ULONG sigs = 0;
925
926 disable_skip(TRUE);
927 out = collatestrings(GetPL(pl, _PROMPT).intval, GetPL(pl, _PROMPT).arg);
928
929 wc = VGroup,
930 Child, VGroup, GroupFrame,
931 MUIA_Background, MUII_GroupBack,
932 Child, TextObject,
933 MUIA_Text_Contents, (IPTR)(out),
934 End,
935 Child, st = StringObject,
936 StringFrame,
937 MUIA_String_Accept, (IPTR)"-0123456789",
938 MUIA_String_Integer, retval,
939 MUIA_String_AdvanceOnCR,TRUE,
940 MUIA_CycleChain, TRUE,
941 End,
942 Child, TextObject,
943 MUIA_Text_Contents, (IPTR)(minmax),
944 End,
945 End,
946 End;
947
948 if (wc)
949 {
950 AddContents(wc);
951
952 while (running)
953 {
954 switch (DoMethod(app,MUIM_Application_NewInput,(IPTR)&sigs))
955 {
956 case Push_Abort:
957 abort_install();
958 break;
959 case Push_Proceed:
960 GetAttr(MUIA_String_Integer, st, &retval);
961 if ( retval <= max && retval >= min)
962 {
963 running = FALSE;
964 }
965 break;
966 case Push_Help:
967 if (GetPL(pl, _HELP).intval)
968 {
969 helpwinpl(HELP_ON_ASKSTRING, pl, _HELP);
970 }
971 else
972 {
973 helpwin(HELP_ON_ASKNUMBER, get_var_arg("@asknumber-help"));
974 }
975 break;
976 default:
977 break;
978 }
979 WaitCTRL(sigs);
980 }
981 GetAttr(MUIA_String_Integer, st, &retval);
982
983 DelContents(wc);
984 }
985 FreeVec(out);
986 disable_skip(FALSE);
987 }
988 if ( preferences.transcriptstream != BNULL )
989 {
990 char tmpbuf[MAXARGSIZE];
991 Write(preferences.transcriptstream, "Ask Number: Result was \"", 24);
992 sprintf(tmpbuf, "%ld", retval);
993 Write(preferences.transcriptstream, tmpbuf, strlen(tmpbuf));
994 Write(preferences.transcriptstream, "\".\n\n", 4);
995 }
996
997 return retval;
998 }
999
1000
1001 /*
1002 * Ask user for a string
1003 */
1004 char *request_string(struct ParameterList *pl)
1005 {
1006 char *retval, *string = NULL;
1007 int i;
1008
1009 if ( GetPL(pl, _DEFAULT).used == 1 )
1010 {
1011 string = StrDup(GetPL(pl, _DEFAULT).arg[0]);
1012 }
1013 else
1014 {
1015 string = StrDup(EMPTY_STRING);
1016 }
1017 TRANSSCRIPT();
1018 if ( get_var_int( "@user-level" ) > _NOVICE )
1019 {
1020 char *out;
1021 BOOL running = TRUE;
1022 Object *st, *wc;
1023 ULONG sigs = 0;
1024
1025 disable_skip(TRUE);
1026 out = collatestrings(GetPL(pl, _PROMPT).intval, GetPL(pl, _PROMPT).arg);
1027
1028 wc = VGroup,
1029 Child, VGroup, GroupFrame,
1030 MUIA_Background, MUII_GroupBack,
1031 Child, TextObject,
1032 MUIA_Text_Contents, (IPTR)(out),
1033 End,
1034 Child, st = StringObject,
1035 StringFrame,
1036 MUIA_String_Contents, (IPTR)string,
1037 MUIA_String_MaxLen, 128,
1038 MUIA_String_AdvanceOnCR,TRUE,
1039 MUIA_CycleChain, TRUE,
1040 End,
1041 End,
1042 End;
1043
1044 if (wc)
1045 {
1046 char *str = "";
1047 AddContents(wc);
1048
1049 while (running)
1050 {
1051 switch (DoMethod(app,MUIM_Application_NewInput,(IPTR)&sigs))
1052 {
1053 case Push_Abort:
1054 abort_install();
1055 break;
1056 case Push_Proceed:
1057 running = FALSE;
1058 break;
1059 case Push_Help:
1060 if (GetPL(pl, _HELP).intval)
1061 {
1062 helpwinpl(HELP_ON_ASKSTRING, pl, _HELP);
1063 }
1064 else
1065 {
1066 helpwin(HELP_ON_ASKNUMBER, get_var_arg("@asknumber-help"));
1067 }
1068 break;
1069 default:
1070 break;
1071 }
1072 WaitCTRL(sigs);
1073 }
1074 FreeVec(string);
1075 get(st, MUIA_String_Contents, &str);
1076 string = StrDup(str);
1077
1078 DelContents(wc);
1079 }
1080 FreeVec(out);
1081 disable_skip(FALSE);
1082 }
1083 retval = addquotes(string);
1084 FreeVec(string);
1085 if ( preferences.transcriptstream != BNULL )
1086 {
1087 Write(preferences.transcriptstream, "Ask String: Result was ", 23);
1088 Write(preferences.transcriptstream, retval, strlen(retval));
1089 Write(preferences.transcriptstream, ".\n\n", 3);
1090 }
1091
1092 return retval;
1093 }
1094
1095 /*
1096 * Ask user to choose one of N items
1097 */
1098 long int request_choice(struct ParameterList *pl)
1099 {
1100 long int retval;
1101 char **mxlabels = NULL;
1102 int i, max = 0;
1103
1104 NeedPROMPT(pl);
1105
1106 retval = GetPL(pl, _DEFAULT).intval;
1107
1108 if ( GetPL(pl, _CHOICES).used == 1 )
1109 {
1110 max = GetPL(pl, _CHOICES).intval;
1111
1112 if ( max > 32 )
1113 {
1114 error = SCRIPTERROR;
1115 traperr("More than 32 choices given!\n", NULL);
1116 }
1117
1118 mxlabels = AllocVec((max+1)*sizeof(STRPTR), MEMF_PUBLIC);
1119 outofmem(mxlabels);
1120
1121 for ( i = 0 ; i < max ; i++ )
1122 {
1123 mxlabels[i] = StrDup(GetPL(pl, _CHOICES).arg[i]);
1124 }
1125 mxlabels[i] = NULL;
1126 }
1127 else
1128 {
1129 error = SCRIPTERROR;
1130 traperr("No choices given!\n", NULL);
1131 }
1132
1133 TRANSSCRIPT();
1134
1135 if ( get_var_int("@user-level") > _NOVICE )
1136 {
1137 char *out;
1138 BOOL running = TRUE;
1139 Object *levelmx, *wc;
1140 ULONG sigs = 0;
1141
1142 disable_skip(TRUE);
1143 out = collatestrings(GetPL(pl, _PROMPT).intval, GetPL(pl, _PROMPT).arg);
1144
1145 wc = VGroup,
1146 Child, VGroup, GroupFrame,
1147 MUIA_Background, MUII_GroupBack,
1148 Child, TextObject,
1149 MUIA_Text_Contents, (IPTR)(out),
1150 End,
1151 Child, levelmx = RadioObject,
1152 MUIA_Radio_Entries, (IPTR)(mxlabels),
1153 End,
1154 End,
1155 End;
1156
1157 if (wc)
1158 {
1159 AddContents(wc);
1160
1161 while (running)
1162 {
1163 switch (DoMethod(app,MUIM_Application_NewInput,(IPTR)&sigs))
1164 {
1165 case Push_Abort:
1166 abort_install();
1167 break;
1168 case Push_Proceed:
1169 running = FALSE;
1170 break;
1171 case Push_Help:
1172 if (GetPL(pl, _HELP).intval)
1173 {
1174 helpwinpl(HELP_ON_ASKCHOICE, pl, _HELP);
1175 }
1176 else
1177 {
1178 helpwin(HELP_ON_ASKCHOICE, get_var_arg("@asknumber-help"));
1179 }
1180 break;
1181 default:
1182 break;
1183 }
1184 WaitCTRL(sigs);
1185 }
1186 GetAttr(MUIA_Radio_Active, levelmx, &retval);
1187
1188 DelContents(wc);
1189 }
1190 FreeVec(out);
1191 disable_skip(FALSE);
1192 }
1193 if ( preferences.transcriptstream != BNULL )
1194 {
1195 Write(preferences.transcriptstream, "Ask Choice: Result was \"", 24);
1196 Write(preferences.transcriptstream, mxlabels[retval], strlen(mxlabels[retval]));
1197 Write(preferences.transcriptstream, "\".\n\n", 4);
1198 }
1199 for ( i = 0 ; i < max ; i++ )
1200 {
1201 FreeVec(mxlabels[i]);
1202 }
1203 FreeVec(mxlabels);
1204
1205 return retval;
1206 }
1207
1208
1209 /*
1210 * Ask user for a directory
1211 */
1212 char *request_dir(struct ParameterList *pl)
1213 {
1214 char *retval, *string;
1215
1216 if ( GetPL(pl, _DEFAULT).used == 0 )
1217 {
1218 error = SCRIPTERROR;
1219 traperr("No default specified!", NULL);
1220 }
1221 string = GetPL(pl, _DEFAULT).arg[0];
1222
1223 /* TODO: write whole function request_dir() */
1224
1225 retval = addquotes(string);
1226
1227 return retval;
1228 }
1229
1230
1231 /*
1232 * Ask user to insert a specific disk
1233 */
1234 char *request_disk(struct ParameterList *pl)
1235 {
1236 char *retval, *string;
1237
1238 if ( GetPL(pl, _DEST).used == 0 )
1239 {
1240 error = SCRIPTERROR;
1241 traperr("No dest specified!", NULL);
1242 }
1243 string = GetPL(pl, _DEST).arg[0];
1244
1245 /* TODO: write whole function request_disk() */
1246
1247 retval = addquotes(string);
1248
1249 return retval;
1250 }
1251
1252
1253 /*
1254 * Ask user for a file
1255 */
1256 char *request_file(struct ParameterList *pl)
1257 {
1258 char *retval, *string;
1259
1260 if ( GetPL(pl, _DEFAULT).used == 0 )
1261 {
1262 error = SCRIPTERROR;
1263 traperr("No default specified!", NULL);
1264 }
1265 string = GetPL(pl, _DEFAULT).arg[0];
1266
1267 /* TODO: write whole function request_file() */
1268
1269 retval = addquotes(string);
1270
1271 return retval;
1272 }
1273
1274
1275 /*
1276 * Ask user for a selection of multiple items (choose m of n items)
1277 */
1278 long int request_options(struct ParameterList *pl)
1279 {
1280 long int retval;
1281 char **mxlabels = NULL;
1282 int i, max = 0;
1283 Object *marks[33];
1284 Object *labels[33];
1285 long int val;
1286 BOOL j;
1287
1288 NeedPROMPT(pl);
1289
1290 retval = GetPL(pl, _DEFAULT).intval;
1291
1292 if ( GetPL(pl, _CHOICES).used == 1 )
1293 {
1294 max = GetPL(pl, _CHOICES).intval;
1295
1296 if ( max > 32 )
1297 {
1298 error = SCRIPTERROR;
1299 traperr("More than 32 choices given!\n", NULL);
1300 }
1301
1302 mxlabels = AllocVec((max+1)*sizeof(STRPTR), MEMF_PUBLIC);
1303 outofmem(mxlabels);
1304
1305 for ( i = 0 ; i < max ; i++ )
1306 {
1307 mxlabels[i] = StrDup(GetPL(pl, _CHOICES).arg[i]);
1308 marks[i] = MUI_MakeObject(MUIO_Checkmark, (IPTR)mxlabels[i]);
1309 labels[i] = LLabel(mxlabels[i]);
1310
1311 set(marks[i], MUIA_CycleChain, TRUE);
1312 if ( (retval & 1<<i) != 0 )
1313 set(marks[i], MUIA_Selected, TRUE);
1314 }
1315 mxlabels[i] = NULL;
1316 }
1317 else
1318 {
1319 error = SCRIPTERROR;
1320 traperr("No choices given!\n", NULL);
1321 }
1322
1323 TRANSSCRIPT();
1324
1325 if ( get_var_int("@user-level") > _NOVICE )
1326 {
1327 char *out;
1328 BOOL running = TRUE;
1329 Object *levelmx, *wc;
1330 ULONG sigs = 0;
1331
1332 disable_skip(TRUE);
1333 out = collatestrings(GetPL(pl, _PROMPT).intval, GetPL(pl, _PROMPT).arg);
1334
1335 wc = VGroup,
1336 Child, VGroup, GroupFrame,
1337 MUIA_Background, MUII_GroupBack,
1338 Child, TextObject,
1339 MUIA_Text_Contents, (IPTR)(out),
1340 End,
1341 Child, levelmx = ColGroup(2),
1342 GroupFrame,
1343 MUIA_Background, MUII_GroupBack,
1344 End,
1345 End,
1346 End;
1347
1348 if (wc)
1349 {
1350 for ( i = 0 ; i < max ; i++ )
1351 {
1352 DoMethod(levelmx, OM_ADDMEMBER, (IPTR)marks[i]);
1353 DoMethod(levelmx, OM_ADDMEMBER, (IPTR)labels[i]);
1354 }
1355 AddContents(wc);
1356
1357 while (running)
1358 {
1359 switch (DoMethod(app,MUIM_Application_NewInput,(IPTR)&sigs))
1360 {
1361 case Push_Abort:
1362 abort_install();
1363 break;
1364 case Push_Proceed:
1365 running = FALSE;
1366 break;
1367 case Push_Help:
1368 if (GetPL(pl, _HELP).intval)
1369 {
1370 helpwinpl(HELP_ON_ASKCHOICE, pl, _HELP);
1371 }
1372 else
1373 {
1374 helpwin(HELP_ON_ASKCHOICE, get_var_arg("@asknumber-help"));
1375 }
1376 break;
1377 default:
1378 break;
1379 }
1380 WaitCTRL(sigs);
1381 }
1382 retval = 0;
1383 for ( i = 0 ; i < max ; i++ )
1384 {
1385 GetAttr(MUIA_Selected, marks[i], &val);
1386 if (val)
1387 {
1388 retval |= 1<<i;
1389 }
1390 }
1391
1392 DelContents(wc);
1393 }
1394 FreeVec(out);
1395 disable_skip(FALSE);
1396 }
1397 if ( preferences.transcriptstream != BNULL )
1398 {
1399 Write(preferences.transcriptstream, "Ask Options: Result was \"", 24);
1400 j = FALSE;
1401 for ( i = 0 ; i < max ; i++ )
1402 {
1403 if ( (retval & (1<<i)) != 0 )
1404 {
1405 if ( j )
1406 {
1407 Write(preferences.transcriptstream, "\", \"", 4);
1408 }
1409 Write(preferences.transcriptstream, mxlabels[i], strlen(mxlabels[i]));
1410 j = TRUE;
1411 }
1412 }
1413 Write(preferences.transcriptstream, "\".\n\n", 4);
1414 }
1415 for ( i = 0 ; i < max ; i++ )
1416 {
1417 FreeVec(mxlabels[i]);
1418 }
1419 FreeVec(mxlabels);
1420
1421 return retval;
1422 }
1423
1424
1425 /*
1426 * Ask user to confirm
1427 */
1428 int request_confirm(struct ParameterList * pl)
1429 {
1430 int retval = 1;
1431 BOOL running = TRUE;
1432 Object *wc;
1433 ULONG sigs = 0;
1434 char *out;
1435
1436 NeedPROMPT(pl);
1437 NeedHELP(pl);
1438
1439 if ( get_var_int("@user-level") >= GetPL(pl, _CONFIRM).intval )
1440 {
1441 out = collatestrings(GetPL(pl, _PROMPT).intval, GetPL(pl, _PROMPT).arg);
1442
1443 wc = VGroup,
1444 Child, TextObject,
1445 GroupFrame,
1446 MUIA_Background, MUII_GroupBack,
1447 MUIA_Text_Contents, (IPTR)(out),
1448 End,
1449 End;
1450
1451 if (wc)
1452 {
1453 AddContents(wc);
1454
1455 while (running)
1456 {
1457 switch (DoMethod(app,MUIM_Application_NewInput,(IPTR)&sigs))
1458 {
1459 case Push_Abort:
1460 abort_install();
1461 break;
1462 case Push_Proceed:
1463 running = FALSE;
1464 break;
1465 case Push_Skip:
1466 retval = 0;
1467 running = FALSE;
1468 break;
1469 case Push_Help:
1470 helpwinpl(HELP_ON_CONFIRM, pl, _HELP);
1471 break;
1472 default:
1473 break;
1474 }
1475 WaitCTRL(sigs);
1476 }
1477
1478 DelContents(wc);
1479 }
1480 FreeVec(out);
1481 }
1482
1483 return retval;
1484 }
1485
1486
1487 /*
1488 * Give a short summary on what was done
1489 */
1490 void final_report()
1491 {
1492 #ifdef DEBUG
1493 printf("Application has been installed in %s.\n", get_var_arg("@default-dest"));
1494 #endif /* DEBUG */
1495 }
1496
1497
1498 void display_text(char * msg)
1499 {
1500 BOOL running = TRUE;
1501 LONG sigs = 0;
1502 Object *wc;
1503 Object *btok;
1504
1505 wc = VGroup,
1506 Child, TextObject,
1507 GroupFrameT(_(MSG_MESSAGE)),
1508 MUIA_Text_Contents, (IPTR)msg,
1509 End,
1510 Child, HBar(TRUE),
1511 Child, HGroup,
1512 Child, btok = CoolImageIDButton(_(MSG_OK), COOL_USEIMAGE_ID),
1513 End,
1514 End;
1515 set(btok,MUIA_CycleChain,1);
1516 DoMethod(btok, MUIM_Notify, MUIA_Pressed, FALSE,(IPTR)app, 2, MUIM_Application_ReturnID, Push_Ok);
1517 DoMethod(reqroot, OM_ADDMEMBER, (IPTR)wc);
1518
1519 set(reqwnd, MUIA_Window_Open, TRUE);
1520 while (running)
1521 {
1522 switch (DoMethod(app,MUIM_Application_NewInput,(IPTR)&sigs))
1523 {
1524 case Push_Ok:
1525 running = FALSE;
1526 break;
1527 default:
1528 break;
1529 }
1530 WaitCTRL(sigs);
1531 }
1532 set(reqwnd, MUIA_Window_Open, FALSE);
1533
1534 DoMethod(reqroot, OM_REMMEMBER, (IPTR)wc);
1535 MUI_DisposeObject(wc);
1536 }
1537
1538
Mirror of AROS' svn.