?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Don't keep asking for S2EVENT_CONNECT reports if driver doen't
[AROS.git] / workbench / tools / InstallAROS / main.c
blob2cc720f46ccf2077da2969286f7651680cbc88d8
1 /*
2 Copyright © 2003-2011, The AROS Development Team. All rights reserved.
3 $Id$
4 */
5
6 #define INTUITION_NO_INLINE_STDARG
7
8 #define DEBUG 0
9 #include <aros/debug.h>
10
11 #include <libraries/mui.h>
12
13 #include <dos/dos.h>
14 #include <exec/types.h>
15 #include <stdlib.h>
16 #include <stdio.h>
17 #include <string.h>
18
19 #include <clib/alib_protos.h>
20
21 #include <intuition/gadgetclass.h>
22 #include <intuition/icclass.h>
23 #include <gadgets/colorwheel.h>
24
25 #include <libraries/asl.h>
26 #include <libraries/expansionbase.h>
27
28 #include <devices/trackdisk.h>
29 #include <devices/scsidisk.h>
30
31 #include <proto/exec.h>
32 #include <proto/intuition.h>
33 #include <proto/dos.h>
34 #include <proto/partition.h>
35 #include <proto/muimaster.h>
36 #include <proto/graphics.h>
37 #include <proto/utility.h>
38
39 #include <mui/TextEditor_mcc.h>
40
41 #include "install.h"
42
43
44
45 #define kBufSize (4*65536)
46 #define kExallBufSize (4096)
47
48 #define SYS_PART_NAME "DH0"
49 #define WORK_PART_NAME "DH1"
50 #define USB_SYS_PART_NAME "DU0"
51 #define USB_WORK_PART_NAME "DU1"
52 #define SYS_VOL_NAME "AROS"
53 #define WORK_VOL_NAME "Work"
54 #define USB_SYS_VOL_NAME "AROS Live Drive"
55 #define USB_WORK_VOL_NAME "Briefcase"
56
57 #define MAX_FFS_SIZE (4L * 1024)
58 #define MAX_SFS_SIZE (124L * 1024)
59
60 #define INSTALLER_TMP_PATH "T:Installer"
61 #define INSTALLAROS_TMP_PATH "T:Installer/InstallAROS"
62
63 #define localeFile_path "Prefs/Locale\""
64 #define inputFile_path "Prefs/Input\""
65 #define prefssrc_path "ENV:SYS"
66 #define prefs_path "Prefs/Env-Archive/SYS"
67 #define BOOT_PATH "boot"
68 #define GRUB_PATH "grub"
69
70 #define locale_prfs_file "locale.prefs" /* please note the suffixed \" */
71 #define input_prfs_file "input.prefs"
72
73 #define DEF_INSTALL_IMAGE "IMAGES:Logos/install.logo"
74 #define DEF_BACK_IMAGE "IMAGES:Logos/install.logo"
75 #define DEF_LIGHTBACK_IMAGE "IMAGES:Logos/install.logo"
76
77 #define POST_INSTALL_SCRIPT "PROGDIR:InstallAROS-Post-Install"
78 #define AROS_BOOT_FILE "AROS.boot"
79
80 #define GRUB_COPY_FILE_LOOP(files) \
81 SET(data->gauge2, MUIA_Gauge_Current, 0); \
82 \
83 while (files[file_count] != NULL && data->inst_success == MUIV_Inst_InProgress) \
84 { \
85 ULONG newSrcLen = strlen(srcPath) + strlen(files[file_count]) + 2; \
86 ULONG newDstLen = strlen(dstPath) + strlen(files[file_count + 1]) + 2; \
87 \
88 TEXT srcFile[newSrcLen]; \
89 TEXT dstFile[newDstLen]; \
90 \
91 sprintf(srcFile, "%s", srcPath); \
92 sprintf(dstFile, "%s", dstPath); \
93 AddPart(srcFile, files[file_count], newSrcLen); \
94 AddPart(dstFile, files[file_count + 1], newDstLen); \
95 \
96 DoMethod(self, MUIM_IC_CopyFile, srcFile, dstFile); \
97 \
98 file_count += 2; \
99 \
100 if (numgrubfiles > 0) \
101 { \
102 SET(data->gauge2, MUIA_Gauge_Current, \
103 (LONG)((100.0 / numgrubfiles) * (file_count / 2.0))); \
104 } \
105 }
106
107 #define OPTION_PREPDRIVES 1
108 #define OPTION_FORMAT 2
109 #define OPTION_LANGUAGE 3
110 #define OPTION_CORE 4
111 #define OPTION_EXTRAS 5
112 #define OPTION_BOOTLOADER 6
113
114 #define INSTV_TITLE 101001
115 #define INSTV_LOGO 101002
116 #define INSTV_PAGE 101003
117
118 #define INSTV_TEXT 101004
119 #define INSTV_SPACE 101005
120 #define INSTV_BOOL 101006
121 #define INSTV_RETURN 101007
122
123 #define INSTV_CURR 101100
124
125 enum BootLoaderTypes
126 {
127 BOOTLOADER_NONE = -1,
128 BOOTLOADER_GRUB1,
129 BOOTLOADER_GRUB2
130 };
131
132 /* Files to check for. Must be in the same order as enum values before */
133 STRPTR BootLoaderFiles[] = {
134 "boot/grub/stage1",
135 "boot/grub/core.img",
136 NULL
137 };
138
139 #define BOOTLOADER_PATH_LEN 20 /* Length of the largest string in BootLoaders array plus 2 */
140
141 struct ExpansionBase *ExpansionBase = NULL;
142
143 char *source_Path = NULL; /* full path to source "tree" */
144 char *extras_source = NULL;
145
146 char *dest_Path = NULL; /* DOS DEVICE NAME of part used to store "aros" */
147 char *work_Path = NULL; /* DOS DEVICE NAME of part used to store "work" */
148 TEXT *extras_path = NULL; /* DOS DEVICE NAME of part used to store extras */
149
150 char *boot_Device = "ata.device";
151 ULONG boot_Unit = 0;
152
153 Object *check_copytowork = NULL;
154 Object *check_work = NULL;
155 Object *show_formatsys = NULL;
156 Object *show_formatwork = NULL;
157 Object *check_formatsys = NULL;
158 Object *check_formatwork = NULL;
159 Object *cycle_fstypesys = NULL;
160 Object *cycle_fstypework = NULL;
161 Object *cycle_sysunits = NULL;
162 Object *cycle_workunits = NULL;
163
164 Object *dest_volume = NULL;
165 Object *work_volume = NULL;
166
167 Object *dest_device = NULL;
168 Object *cycle_drivetype = NULL;
169 Object *dest_unit = NULL;
170 Object *show_sizesys = NULL;
171 Object *show_sizework = NULL;
172 Object *check_sizesys = NULL;
173 Object *check_sizework = NULL;
174 Object *check_creatework = NULL;
175 Object *sys_size = NULL;
176 Object *work_size = NULL;
177 Object *sys_devname = NULL;
178 Object *work_devname = NULL;
179
180 Object *grub_device = NULL;
181 Object *grub_unit = NULL;
182
183 Object *reboot_group = NULL;
184 LONG BootLoaderType;
185
186 ULONG GuessFirstHD(CONST_STRPTR device);
187 static struct FileSysStartupMsg *getDiskFSSM(CONST_STRPTR path);
188 static LONG GetPartitionSize(BOOL get_work);
189 static LONG FindWindowsPartition(STRPTR device, LONG unit);
190 LONG CopyDirArray(Class * CLASS, Object * self, CONST_STRPTR sourcePath,
191 CONST_STRPTR destinationPath, CONST_STRPTR directories[]);
192
193 IPTR Install__OM_NEW(Class * CLASS, Object * self, struct opSet *message)
194 {
195 self = (Object *) DoSuperMethodA(CLASS, self, (Msg) message);
196
197 struct Install_DATA *data = INST_DATA(CLASS, self);
198 BPTR lock = NULL;
199 char sys_path[100];
200
201 /* We will generate this info shortly */
202
203 /* IO Related */
204
205 data->IO_Always_overwrite = IIO_Overwrite_Ask;
206
207 /* Main stuff */
208
209 data->welcomeMsg =
210 (APTR) GetTagData(MUIA_WelcomeMsg, (IPTR) NULL,
211 message->ops_AttrList);
212 data->doneMsg =
213 (APTR) GetTagData(MUIA_FinishedMsg, (IPTR) NULL,
214 message->ops_AttrList);
215
216 data->page =
217 (APTR) GetTagData(MUIA_Page, (IPTR) NULL, message->ops_AttrList);
218 data->gauge1 =
219 (APTR) GetTagData(MUIA_Gauge1, (IPTR) NULL, message->ops_AttrList);
220 data->gauge2 =
221 (APTR) GetTagData(MUIA_Gauge2, (IPTR) NULL, message->ops_AttrList);
222 data->label =
223 (APTR) GetTagData(MUIA_Install, (IPTR) NULL, message->ops_AttrList);
224
225 data->installer =
226 (APTR) GetTagData(MUIA_OBJ_Installer, (IPTR) NULL,
227 message->ops_AttrList);
228
229 data->window =
230 (APTR) GetTagData(MUIA_OBJ_Window, (IPTR) NULL,
231 message->ops_AttrList);
232 data->contents =
233 (APTR) GetTagData(MUIA_OBJ_WindowContent, (IPTR) NULL,
234 message->ops_AttrList);
235
236 data->pagetitle =
237 (APTR) GetTagData(MUIA_OBJ_PageTitle, (IPTR) NULL,
238 message->ops_AttrList);
239 data->pageheader =
240 (APTR) GetTagData(MUIA_OBJ_PageHeader, (IPTR) NULL,
241 message->ops_AttrList);
242
243 data->actioncurrent =
244 (APTR) GetTagData(MUIA_OBJ_CActionStrng, (IPTR) NULL,
245 message->ops_AttrList);
246 data->back =
247 (APTR) GetTagData(MUIA_OBJ_Back, (IPTR) NULL,
248 message->ops_AttrList);
249 data->proceed =
250 (APTR) GetTagData(MUIA_OBJ_Proceed, (IPTR) NULL,
251 message->ops_AttrList);
252 data->cancel =
253 (APTR) GetTagData(MUIA_OBJ_Cancel, (IPTR) NULL,
254 message->ops_AttrList);
255
256 data->instc_lic_file =
257 (char *)GetTagData(MUIA_IC_License_File, (IPTR) NULL,
258 message->ops_AttrList);
259 data->instc_copt_licensemandatory =
260 (BOOL) GetTagData(MUIA_IC_License_Mandatory, (IPTR) FALSE,
261 message->ops_AttrList);
262
263 data->instc_options_main =
264 (APTR) GetTagData(MUIA_List_Options, (IPTR) NULL,
265 message->ops_AttrList);
266 data->instc_options_grub =
267 (APTR) GetTagData(MUIA_Grub_Options, (IPTR) NULL,
268 message->ops_AttrList);
269
270 data->instc_copt_undoenabled =
271 (BOOL) GetTagData(MUIA_IC_EnableUndo, (IPTR) FALSE,
272 message->ops_AttrList);
273
274 data->instc_options_main->partitioned = FALSE;
275 data->instc_options_main->bootloaded = FALSE;
276 data->instc_options_grub->bootinfo = FALSE;
277
278 GET(data->window, MUIA_Window_Width, &data->cur_width);
279 GET(data->window, MUIA_Window_Height, &data->cur_height);
280
281 SET(data->welcomeMsg, MUIA_Text_Contents, KMsgWelcome);
282 SET(data->back, MUIA_Disabled, TRUE);
283
284 data->instc_stage_next = EPartitionOptionsStage;
285
286 data->inst_success = FALSE;
287 data->disable_back = FALSE;
288
289 data->instc_cflag_driveset = (BOOL) DoMethod(self, MUIM_FindDrives);
290
291 /* Default to USB if a USB system volume appears to be present and we
292 * haven't booted from it */
293
294 lock = Lock("SYS:", SHARED_LOCK);
295 NameFromLock(lock, sys_path, 100);
296 if (getDiskFSSM(USB_SYS_PART_NAME ":") != NULL
297 && strncmp(sys_path, USB_SYS_VOL_NAME ":",
298 strlen(USB_SYS_VOL_NAME) + 1))
299 {
300 SET(dest_volume, MUIA_String_Contents, USB_SYS_PART_NAME);
301 SET(work_volume, MUIA_String_Contents, USB_WORK_PART_NAME);
302
303 SET(cycle_drivetype, MUIA_Cycle_Active, 1);
304 }
305 UnLock(lock);
306
307 boot_Unit = GuessFirstHD(boot_Device);
308
309 DoMethod(data->proceed, MUIM_Notify, MUIA_Pressed, FALSE, (IPTR) self,
310 1, MUIM_IC_NextStep);
311 DoMethod(data->back, MUIM_Notify, MUIA_Pressed, FALSE, (IPTR) self, 1,
312 MUIM_IC_PrevStep);
313 DoMethod(data->cancel, MUIM_Notify, MUIA_Pressed, FALSE, (IPTR) self, 1,
314 MUIM_IC_CancelInstall);
315
316 DoMethod(self, MUIM_Notify, MUIA_InstallComplete, TRUE, (IPTR) self, 1,
317 MUIM_Reboot);
318
319 /* set up the license info */
320
321 if (data->instc_lic_file)
322 {
323 register struct FileInfoBlock *fib = NULL;
324 BPTR from = NULL;
325 LONG s = 0;
326
327 lock = (BPTR) Lock(data->instc_lic_file, SHARED_LOCK);
328 if (lock != NULL)
329 {
330 fib = (void *)AllocVec(sizeof(*fib), MEMF_PUBLIC);
331 Examine(lock, fib);
332 }
333
334 if ((from = Open(data->instc_lic_file, MODE_OLDFILE)))
335 {
336 D(bug
337 ("[INSTALLER.i] Allocating buffer [%d] for license file '%s'!",
338 fib->fib_Size, data->instc_lic_file));
339 data->instc_lic_buffer =
340 AllocVec(fib->fib_Size + 1, MEMF_CLEAR | MEMF_PUBLIC);
341 if ((s = Read(from, data->instc_lic_buffer,
342 fib->fib_Size)) == -1)
343 {
344 D(bug("[INSTALLER.i] Error processing license file!"));
345 if ((BOOL) data->instc_copt_licensemandatory)
346 {
347 Close(from);
348 UnLock(lock);
349 return 0;
350 }
351 }
352 else
353 {
354 DoMethod(data->instc_options_main->opt_lic_box,
355 MUIM_TextEditor_InsertText, data->instc_lic_buffer,
356 MUIV_TextEditor_InsertText_Top);
357 }
358 Close(from);
359 }
360
361 if (lock != NULL)
362 {
363 if (fib)
364 FreeVec(fib);
365 UnLock(lock);
366 }
367
368 if (!data->instc_copt_licensemandatory)
369 SET(data->instc_options_main->opt_lic_mgrp, MUIA_ShowMe, FALSE);
370 else
371 DoMethod(data->instc_options_main->opt_license, MUIM_Notify,
372 MUIA_Selected, MUIV_EveryTime, (IPTR) data->proceed, 3,
373 MUIM_Set, MUIA_Disabled, MUIV_NotTriggerValue);
374 }
375
376 /* UNDO Record */
377
378 if (data->instc_copt_undoenabled)
379 {
380 lock = 0;
381 NEWLIST((struct List *)&data->instc_undorecord);
382 D(bug("[INSTALLER.i] Prepared UNDO list @ %p\n",
383 &data->instc_undorecord));
384
385 if ((lock = Lock(INSTALLER_TMP_PATH, ACCESS_READ)) != NULL)
386 {
387 D(bug("[INSTALLER.i] Dir '%s' Exists - no nead to create\n",
388 INSTALLER_TMP_PATH));
389 UnLock(lock);
390 }
391 else
392 {
393 lock = CreateDir(INSTALLER_TMP_PATH);
394 if (lock != NULL)
395 UnLock(lock);
396 else
397 {
398 D(bug("[INSTALLER.i] Failed to create dir '%s'!!\n",
399 INSTALLER_TMP_PATH));
400 data->inst_success = MUIV_Inst_Failed;
401 return 0;
402 }
403 }
404
405 if ((lock = Lock(INSTALLAROS_TMP_PATH, ACCESS_READ)) != NULL)
406 {
407 D(bug("[INSTALLER.i] Dir '%s' Exists - no nead to create\n",
408 INSTALLAROS_TMP_PATH));
409 UnLock(lock);
410 }
411 else
412 {
413 lock = CreateDir(INSTALLAROS_TMP_PATH);
414 if (lock != NULL)
415 UnLock(lock);
416 else
417 {
418 D(bug("[INSTALLER.i] Failed to create dir '%s'!!\n",
419 INSTALLAROS_TMP_PATH));
420 data->inst_success = MUIV_Inst_Failed;
421 return 0;
422 }
423 }
424 }
425
426 return (IPTR) self;
427 }
428
429 /* make page */
430
431 ULONG AskRetry(Class * CLASS, Object * self, CONST_STRPTR message,
432 CONST_STRPTR file, CONST_STRPTR opt1, CONST_STRPTR opt2,
433 CONST_STRPTR opt3)
434 {
435 struct Install_DATA *data = INST_DATA(CLASS, self);
436 STRPTR finalmessage = NULL;
437 STRPTR finaloptions = NULL;
438 ULONG result = -1;
439
440 finalmessage =
441 AllocVec(strlen(message) + strlen(file) + 2,
442 MEMF_CLEAR | MEMF_PUBLIC);
443 finaloptions =
444 AllocVec(strlen(opt1) + strlen(opt2) + strlen(opt3) + 5,
445 MEMF_CLEAR | MEMF_PUBLIC);
446
447 sprintf(finalmessage, message, file);
448 sprintf(finaloptions, "%s|%s|%s", opt1, opt2, opt3);
449
450 result =
451 MUI_RequestA(data->installer, data->window, 0,
452 "IO Error has occured", finaloptions, finalmessage, NULL);
453 FreeVec(finalmessage);
454 FreeVec(finaloptions);
455
456 return result - 1;
457 }
458
459 /* Return the unit number of the drive that's likely to be the first in the
460 * system, or zero if none found */
461 ULONG GuessFirstHD(CONST_STRPTR device)
462 {
463 struct PartitionHandle *ph;
464 ULONG i;
465 BOOL found = FALSE;
466
467 for (i = 0; i < 8 && !found; i++)
468 {
469 ph = OpenRootPartition(device, i);
470 if (ph != NULL)
471 {
472 found = TRUE;
473 CloseRootPartition(ph);
474 }
475 }
476 if (!found)
477 i = 1;
478
479 return i - 1;
480 }
481
482 /* Return TRUE if we suspect a floppy disk */
483 BOOL myCheckFloppy(struct DosEnvec * DriveEnv)
484 {
485 switch (DriveEnv->de_HighCyl)
486 {
487 case 79:
488 /* Standard Floppy size
489 for PC floppies, DD = 9, HD = 18
490 for Amiga floppies, DD = 11, HD = 22
491 */
492 if ((DriveEnv->de_BlocksPerTrack == 18) ||
493 (DriveEnv->de_BlocksPerTrack == 9) ||
494 (DriveEnv->de_BlocksPerTrack == 22) ||
495 (DriveEnv->de_BlocksPerTrack == 11))
496 return TRUE;
497
498 break;
499 case 2890:
500 /* Standard Zip (95Mb) */
501 if ((DriveEnv->de_BlocksPerTrack == 60) ||
502 (DriveEnv->de_BlocksPerTrack == 68))
503 return TRUE;
504 case 196601:
505 case 196607:
506 /* Standard Zip & LS120 sizes */
507 if (DriveEnv->de_BlocksPerTrack == 1)
508 return TRUE;
509 default:
510 break;
511 }
512 /* OK - shouldn't be a floppy... */
513 return FALSE;
514 }
515
516 /* Returns the first AROS-supported filesystem's name */
517 char *FindPartition(struct PartitionHandle *root)
518 {
519 struct PartitionHandle *partition = NULL;
520 char *success = NULL;
521 char *name = NULL;
522 struct PartitionType *type = NULL;
523
524 ForeachNode(&root->table->list, partition)
525 {
526 D(bug("[INSTALLER.fp] checking part\n"));
527 if (OpenPartitionTable(partition) == 0)
528 {
529 D(bug("[INSTALLER.fp] checking Child Parts... \n"));
530 success = FindPartition(partition);
531 ClosePartitionTable(partition);
532 D(bug("[INSTALLER.fp] Children Done...\n"));
533 if (success != NULL)
534 {
535 D(bug("[INSTALLER.fp] Found '%s'\n", success));
536 break;
537 }
538 }
539 else
540 {
541 D(bug("[INSTALLER.fp] checking PARTITION\n"));
542 struct PartitionType pttype;
543
544 name = AllocVec(100, MEMF_CLEAR | MEMF_PUBLIC);
545
546 GetPartitionAttrsTags
547 (partition,
548 PT_NAME, (IPTR) name, PT_TYPE, (IPTR) & pttype, TAG_DONE);
549
550 type = &pttype;
551
552 if (type->id_len == 4)
553 {
554 D(bug("[INSTALLER.fp] Found RDB Partition!\n"));
555 if ((type->id[0] == 68) && (type->id[1] == 79)
556 && (type->id[2] == 83))
557 {
558 D(bug("[INSTALLER.fp] Found AFFS Partition! '%s'\n",
559 name));
560 success = name;
561 break;
562 }
563 if ((type->id[0] == 83) && (type->id[1] == 70)
564 && (type->id[2] == 83))
565 {
566 D(bug("[INSTALLER.fp] Found SFS Partition! '%s'\n",
567 name));
568 success = name;
569 break;
570 }
571 }
572 }
573 }
574
575 if ((!success) && (name))
576 FreeVec(name);
577
578 return success;
579 }
580
581 IPTR Install__MUIM_FindDrives(Class * CLASS, Object * self, Msg message)
582 {
583 struct BootNode *CurBootNode = NULL;
584 struct PartitionHandle *root;
585
586 struct DevInfo *devnode = NULL;
587 struct FileSysStartupMsg *StartMess = NULL;
588 struct DosEnvec *DriveEnv = NULL;
589
590 char *result = NULL;
591 BOOL founddisk = FALSE;
592
593 ForeachNode(&ExpansionBase->MountList, CurBootNode)
594 {
595 devnode = CurBootNode->bn_DeviceNode;
596 StartMess = devnode->dvi_Startup;
597 if (!StartMess)
598 continue;
599 D(bug("[INSTALLER.fd] Drive found [%s unit %d]\n",
600 StartMess->fssm_Device, StartMess->fssm_Unit));
601
602 DriveEnv = StartMess->fssm_Environ;
603
604 if (!myCheckFloppy(DriveEnv))
605 {
606 if ((root =
607 OpenRootPartition(StartMess->fssm_Device,
608 StartMess->fssm_Unit)) != NULL)
609 {
610 if (!founddisk)
611 {
612 /* First drive in system - save its info for grub */
613 D(bug
614 ("[INSTALLER.fd] First DRIVE found [%s unit %d]...\n",
615 StartMess->fssm_Device, StartMess->fssm_Unit));
616 founddisk = TRUE;
617 // boot_Device = StartMess->fssm_Device;
618 // boot_Unit = StartMess->fssm_Unit;
619 }
620
621 if (OpenPartitionTable(root) == 0)
622 {
623 result = FindPartition(root);
624 D(bug("[INSTALLER.fd] Partition '%s'\n", result));
625 ClosePartitionTable(root);
626 }
627 CloseRootPartition(root);
628 }
629 }
630 }
631
632 return (IPTR) result;
633 }
634
635 static struct FileSysStartupMsg *getDiskFSSM(CONST_STRPTR path)
636 {
637 struct DosList *dl;
638 struct DeviceNode *dn;
639 TEXT dname[32];
640 UBYTE i;
641
642 D(bug("[install] getDiskFSSM('%s')\n", path));
643
644 for (i = 0; (path[i]) && (path[i] != ':'); i++)
645 dname[i] = path[i];
646 if (path[i] == ':')
647 {
648 dname[i] = 0;
649 dl = LockDosList(LDF_READ);
650 if (dl)
651 {
652 dn = (struct DeviceNode *)FindDosEntry(dl, dname, LDF_DEVICES);
653 UnLockDosList(LDF_READ);
654 if (dn)
655 {
656 if (IsFileSystem(dname))
657 {
658 return (struct FileSysStartupMsg *)BADDR(dn->
659 dn_Startup);
660 }
661 else
662 printf("device '%s' doesn't contain a file system\n",
663 dname);
664 }
665 // else
666 // PrintFault(ERROR_OBJECT_NOT_FOUND, dname);
667 }
668 }
669 else
670 printf("'%s' doesn't contain a device name\n", path);
671 return NULL;
672 }
673
674 void w2strcpy(STRPTR name, UWORD * wstr, ULONG len)
675 {
676 while (len)
677 {
678 *((UWORD *) name) = AROS_BE2WORD(*wstr);
679 name += sizeof(UWORD);
680 len -= 2;
681 wstr++;
682 }
683
684 name -= 2;
685
686 while ((*name == 0) || (*name == ' '))
687 *name-- = 0;
688 }
689
690 void identify(struct IOStdReq *ioreq, STRPTR name)
691 {
692 struct SCSICmd scsicmd;
693 UWORD data[256];
694 UBYTE cmd = 0xEC; /* identify */
695
696 scsicmd.scsi_Data = data;
697 scsicmd.scsi_Length = 512;
698 scsicmd.scsi_Command = &cmd;
699 scsicmd.scsi_CmdLength = 1;
700 ioreq->io_Command = HD_SCSICMD;
701 ioreq->io_Data = &scsicmd;
702 ioreq->io_Length = sizeof(struct SCSICmd);
703 if (DoIO((struct IORequest *)ioreq))
704 return;
705
706 w2strcpy(name, &data[27], 40);
707 }
708
709 IPTR Install__MUIM_IC_NextStep(Class * CLASS, Object * self, Msg message)
710 {
711 struct Install_DATA *data = INST_DATA(CLASS, self);
712 IPTR this_page = 0, next_stage = 0, option = 0;
713
714 GET(data->page, MUIA_Group_ActivePage, &this_page);
715
716 if ((EDoneStage == this_page) && (this_page == data->instc_stage_next))
717 set(self, MUIA_InstallComplete, TRUE); //ALL DONE!!
718
719 SET(data->back, MUIA_Disabled, (BOOL) data->disable_back);
720
721 next_stage = data->instc_stage_next;
722 data->instc_stage_prev = this_page;
723
724 SET(data->back, MUIA_Selected, FALSE);
725 SET(data->proceed, MUIA_Selected, FALSE);
726 SET(data->cancel, MUIA_Selected, FALSE);
727
728 switch (data->instc_stage_next)
729 {
730
731 case ELicenseStage:
732 if (data->instc_lic_file)
733 {
734 if (data->instc_copt_licensemandatory)
735 {
736 /* Force acceptance of the license */
737 SET(data->instc_options_main->opt_license, MUIA_Selected,
738 FALSE);
739 SET(data->proceed, MUIA_Disabled, TRUE);
740 }
741 data->instc_stage_next = EInstallOptionsStage;
742 next_stage = ELicenseStage;
743 break;
744 }
745 /* if no license we ignore this step... and go to partition options */
746
747 case EPartitionOptionsStage:
748 if (data->instc_cflag_driveset)
749 SET(data->instc_options_main->opt_partmethod, MUIA_Radio_Active,
750 2);
751 else
752 SET(dest_unit, MUIA_String_Integer, boot_Unit);
753 data->instc_stage_next = EPartitioningStage;
754 next_stage = EPartitionOptionsStage;
755 break;
756
757 case EInstallOptionsStage:
758 SET(data->welcomeMsg, MUIA_Text_Contents, KMsgInstallOptions);
759 data->instc_stage_next = EDestOptionsStage;
760 next_stage = EInstallOptionsStage;
761 break;
762
763 case EDestOptionsStage:
764 if ((BOOL) XGET(data->instc_options_main->opt_format,
765 MUIA_Selected))
766 {
767 SET(show_formatsys, MUIA_ShowMe, TRUE);
768 SET(show_formatwork, MUIA_ShowMe, TRUE);
769 }
770 else
771 {
772 SET(check_formatsys, MUIA_Selected, FALSE);
773 SET(check_formatwork, MUIA_Selected, FALSE);
774 SET(show_formatsys, MUIA_ShowMe, FALSE);
775 SET(show_formatwork, MUIA_ShowMe, FALSE);
776 }
777 data->instc_stage_next = EInstallMessageStage;
778 next_stage = EDestOptionsStage;
779 break;
780
781 case EInstallMessageStage:
782 /* PARTITION DRIVES */
783
784 /* have we already done this? */
785 if (!data->instc_options_main->partitioned)
786 {
787 data->instc_options_main->partitioned = TRUE;
788 data->instc_stage_next = EPartitioningStage;
789 next_stage = EPartitionOptionsStage;
790 data->instc_stage_prev = this_page;
791 break;
792 }
793
794 /* BOOTLOADER */
795
796 option = 0;
797
798 GET(data->instc_options_main->opt_bootloader, MUIA_Selected,
799 &option);
800 if (option != 0)
801 {
802 //have we already done this?
803 if (!data->instc_options_main->bootloaded)
804 {
805 data->instc_options_main->bootloaded = TRUE;
806
807 if (!data->instc_options_grub->bootinfo)
808 {
809 #if 0
810 char *tmp_drive = NULL;
811 char *tmp_device = NULL;
812 #endif
813 char *tmp_grub = NULL;
814 #if 0
815 struct IOStdReq *ioreq = NULL;
816 struct MsgPort *mp = NULL;
817 #endif
818 struct FileSysStartupMsg *fssm;
819
820 data->instc_options_grub->bootinfo = TRUE;
821
822 #if 0
823 tmp_drive = AllocVec(100, MEMF_CLEAR | MEMF_PUBLIC);
824 tmp_device = AllocVec(100, MEMF_CLEAR | MEMF_PUBLIC);
825 #endif
826 tmp_grub = AllocVec(100, MEMF_CLEAR | MEMF_PUBLIC);
827
828 GET(dest_volume, MUIA_String_Contents, &option);
829 sprintf(tmp_grub, "%s:boot/grub",
830 (CONST_STRPTR) option);
831
832 /* Guess the best disk to install GRUB's bootblock to */
833 fssm = getDiskFSSM(tmp_grub);
834 if (fssm != NULL)
835 {
836 boot_Device = fssm->fssm_Device;
837 if (strcmp(fssm->fssm_Device, "ata.device") != 0)
838 boot_Unit = fssm->fssm_Unit;
839 }
840 else
841 boot_Device = "";
842
843 SET(grub_device, MUIA_String_Contents,
844 (IPTR) boot_Device);
845 SET(grub_unit, MUIA_String_Integer, boot_Unit);
846
847 #if 0
848 mp = CreateMsgPort();
849 if (mp)
850 {
851 ioreq =
852 (struct IOStdReq *)CreateIORequest(mp,
853 sizeof(struct IOStdReq));
854 if (ioreq)
855 {
856 if (OpenDevice(boot_Device, boot_Unit,
857 (struct IORequest *)ioreq, 0) == 0)
858 {
859 identify(ioreq, tmp_drive);
860 sprintf(tmp_device, "%s [%s unit %d]",
861 tmp_drive, boot_Device, boot_Unit);
862 CloseDevice((struct IORequest *)ioreq);
863 }
864 else
865 sprintf(tmp_device,
866 "Unknown Drive [%s unit %d]",
867 boot_Device, boot_Unit);
868 DeleteIORequest((struct IORequest *)ioreq);
869 }
870 else
871 sprintf(tmp_device,
872 "Unknown Drive [%s unit %d]", boot_Device,
873 boot_Unit);
874 DeleteMsgPort(mp);
875 }
876 else
877 sprintf(tmp_device, "Unknown Drive [%s unit %d]",
878 boot_Device, boot_Unit);
879
880 SET(data->instc_options_grub->gopt_drive,
881 MUIA_Text_Contents, tmp_device);
882 #endif
883 SET(data->instc_options_grub->gopt_grub,
884 MUIA_Text_Contents, tmp_grub);
885 }
886
887 data->instc_stage_next = EInstallMessageStage;
888 next_stage = EGrubOptionsStage;
889 data->instc_stage_prev = EInstallOptionsStage;
890 break;
891 }
892 else if (strlen((STRPTR) XGET(grub_device,
893 MUIA_String_Contents)) == 0)
894 {
895 /* Go back if user hasn't entered a device name for GRUB */
896 MUI_RequestA(data->installer, data->window, 0, "Error",
897 "OK", KMsgNoGrubDevice, NULL);
898 data->instc_stage_next = EInstallMessageStage;
899 next_stage = EGrubOptionsStage;
900 data->instc_stage_prev = EInstallOptionsStage;
901 return 0;
902 }
903 }
904
905 if (XGET(check_formatsys, MUIA_Selected)
906 || XGET(check_formatwork, MUIA_Selected))
907 SET(data->welcomeMsg, MUIA_Text_Contents,
908 KMsgBeginWithPartition);
909 else
910 SET(data->welcomeMsg, MUIA_Text_Contents,
911 KMsgBeginWithoutPartition);
912 data->instc_stage_next = EInstallStage;
913 next_stage = EMessageStage;
914 break;
915
916 case EPartitioningStage:
917 get(data->instc_options_main->opt_partmethod, MUIA_Radio_Active,
918 &option);
919 if ((int)option == 0 || (int)option == 1)
920 {
921 LONG syssize, worksize;
922 IPTR systype = 0, worktype = 0;
923
924 /* Let user try again if either partition size is too big.
925 Note that C:Partition will ensure that automatically sized
926 partitions are within size limits */
927 syssize = GetPartitionSize(FALSE);
928 worksize = GetPartitionSize(TRUE);
929
930 get(cycle_fstypesys, MUIA_Cycle_Active, &systype);
931 get(cycle_fstypework, MUIA_Cycle_Active, &worktype);
932
933 if (syssize > (systype ? MAX_SFS_SIZE : MAX_FFS_SIZE) ||
934 worksize > (worktype ? MAX_SFS_SIZE : MAX_FFS_SIZE))
935 {
936 TEXT msg[sizeof(KMsgPartitionTooBig) + 40];
937 sprintf(msg, KMsgPartitionTooBig,
938 MAX_SFS_SIZE / 1024, MAX_SFS_SIZE,
939 MAX_FFS_SIZE / 1024, MAX_FFS_SIZE);
940 MUI_RequestA(data->installer, data->window, 0, "Error",
941 "OK", msg, NULL);
942 return 0;
943 }
944
945 /* Warn user about using non FFS-Intl filesystem for system
946 partition with GRUB */
947 if ((BootLoaderType == BOOTLOADER_GRUB1) && (systype != 0))
948 {
949 if (MUI_RequestA(data->installer, data->window, 0,
950 "Warning",
951 "Continue Partitioning|*Cancel Partitioning",
952 KMsgGRUBNonFFSWarning, NULL) != 1)
953 return 0;
954 }
955 }
956 data->disable_back = TRUE;
957
958 SET(data->page, MUIA_Group_ActivePage, EPartitioningStage);
959
960 switch (option)
961 {
962 case 0:
963 case 1:
964 if (DoMethod(self, MUIM_Partition) != RETURN_OK)
965 {
966 D(bug("[INSTALLER] Partitioning FAILED!!!!\n"));
967 data->disable_back = FALSE;
968 SET(data->page, MUIA_Group_ActivePage,
969 EInstallMessageStage);
970 data->instc_stage_next = EPartitioningStage;
971 data->instc_options_main->partitioned = FALSE;
972 MUI_RequestA(data->installer, data->window, 0, "Error",
973 "Quit", KMsgPartitioningFailed, NULL);
974 DoMethod(self, MUIM_IC_QuitInstall);
975 return 0;
976 }
977 data->instc_options_main->partitioned = TRUE;
978 next_stage = EDoneStage;
979 DoMethod(data->page, MUIM_Group_InitChange);
980 if (XGET(cycle_drivetype, MUIA_Cycle_Active) == 0)
981 SET(data->doneMsg, MUIA_Text_Contents, KMsgDoneReboot);
982 else
983 SET(data->doneMsg, MUIA_Text_Contents, KMsgDoneUSB);
984 SET(reboot_group, MUIA_ShowMe, TRUE);
985 if (XGET(cycle_drivetype, MUIA_Cycle_Active) == 0)
986 SET(data->instc_options_main->opt_reboot, MUIA_Selected,
987 TRUE);
988 DoMethod(data->page, MUIM_Group_ExitChange);
989 SET(data->back, MUIA_Disabled, TRUE);
990 SET(data->cancel, MUIA_Disabled, TRUE);
991 data->instc_stage_next = EDoneStage;
992 break;
993 case 2:
994 data->disable_back = FALSE;
995 data->instc_options_main->partitioned = TRUE;
996 data->instc_stage_next = EDestOptionsStage;
997 next_stage = EInstallOptionsStage;
998 break;
999 default:
1000 D(bug("[INSTALLER] Launching QuickPart...\n"));
1001 Execute("SYS:Tools/QuickPart", NULL, NULL);
1002 break;
1003 }
1004 break;
1005
1006 case EInstallStage:
1007 data->disable_back = TRUE;
1008 SET(data->page, MUIA_Group_ActivePage, EInstallStage);
1009
1010 DoMethod(self, MUIM_IC_Install);
1011
1012 next_stage = EDoneStage;
1013 SET(data->back, MUIA_Disabled, TRUE);
1014 SET(data->cancel, MUIA_Disabled, TRUE);
1015 data->instc_stage_next = EDoneStage;
1016 break;
1017
1018 default:
1019 break;
1020 }
1021
1022 SET(data->page, MUIA_Group_ActivePage, next_stage);
1023 return 0;
1024 }
1025
1026 IPTR Install__MUIM_IC_PrevStep(Class * CLASS, Object * self, Msg message)
1027 {
1028 struct Install_DATA *data = INST_DATA(CLASS, self);
1029 IPTR this_page = 0;
1030
1031 GET(data->page, MUIA_Group_ActivePage, &this_page);
1032 SET(data->back, MUIA_Selected, FALSE);
1033 SET(data->proceed, MUIA_Selected, FALSE);
1034 SET(data->cancel, MUIA_Selected, FALSE);
1035
1036 SET(data->back, MUIA_Disabled, (BOOL) data->disable_back);
1037 data->instc_stage_next = this_page;
1038
1039 switch (this_page)
1040 {
1041 case EMessageStage:
1042 /* BACK should only be possible when page != first_page */
1043 if (data->instc_stage_prev != EMessageStage)
1044 {
1045 SET(data->welcomeMsg, MUIA_Text_Contents,
1046 KMsgBeginWithPartition);
1047 if (data->instc_stage_prev == EDestOptionsStage)
1048 {
1049 SET(data->page, MUIA_Group_ActivePage, EDestOptionsStage);
1050
1051 data->instc_stage_prev = EInstallOptionsStage;
1052 }
1053 else
1054 {
1055 if (!data->instc_options_grub->bootinfo)
1056 {
1057 SET(data->page, MUIA_Group_ActivePage,
1058 EPartitionOptionsStage);
1059 }
1060 else
1061 {
1062 SET(data->page, MUIA_Group_ActivePage,
1063 EGrubOptionsStage);
1064 }
1065 data->instc_stage_prev = EDestOptionsStage;
1066 }
1067 data->instc_stage_next = EInstallMessageStage;
1068 }
1069 break;
1070
1071 case EPartitionOptionsStage:
1072 if (data->instc_lic_file)
1073 {
1074 SET(data->instc_options_main->opt_license, MUIA_Selected,
1075 FALSE);
1076 SET(data->proceed, MUIA_Disabled, TRUE);
1077 SET(data->page, MUIA_Group_ActivePage, EPartitionOptionsStage);
1078 data->instc_stage_prev = ELicenseStage;
1079 break;
1080 }
1081
1082 case ELicenseStage:
1083 SET(data->proceed, MUIA_Disabled, FALSE);
1084 SET(data->back, MUIA_Disabled, TRUE);
1085 SET(data->welcomeMsg, MUIA_Text_Contents, KMsgWelcome);
1086 SET(data->page, MUIA_Group_ActivePage, EMessageStage);
1087 data->instc_stage_prev = EMessageStage;
1088 break;
1089
1090 case EInstallOptionsStage:
1091 SET(data->instc_options_main->opt_license, MUIA_Selected, FALSE);
1092 SET(data->page, MUIA_Group_ActivePage, EPartitionOptionsStage);
1093 data->instc_stage_prev = ELicenseStage;
1094 data->instc_stage_next = EPartitioningStage;
1095 break;
1096
1097 case EDestOptionsStage:
1098 SET(data->page, MUIA_Group_ActivePage, EInstallOptionsStage);
1099 data->instc_stage_next = EDestOptionsStage;
1100 data->instc_stage_prev = EMessageStage;
1101 break;
1102
1103 case EGrubOptionsStage:
1104 SET(data->page, MUIA_Group_ActivePage, EDestOptionsStage);
1105 data->instc_options_main->bootloaded = FALSE;
1106 data->instc_options_grub->bootinfo = FALSE;
1107 data->instc_stage_next = EInstallMessageStage;
1108 data->instc_stage_prev = EInstallOptionsStage;
1109 break;
1110
1111 case EInstallMessageStage:
1112
1113 /* Back is disabled from here on... */
1114
1115 case EPartitioningStage:
1116 case EInstallStage:
1117 case EDoneStage:
1118 default:
1119 break;
1120 }
1121
1122 return TRUE;
1123 }
1124
1125 IPTR Install__MUIM_IC_CancelInstall
1126 (Class * CLASS, Object * self, Msg message)
1127 {
1128 struct Install_DATA *data = INST_DATA(CLASS, self);
1129 struct optionstmp *backupOptions = NULL;
1130 IPTR this_page = 0;
1131 const char *cancelmessage = NULL;
1132
1133 if ((backupOptions = data->instc_options_backup) == NULL)
1134 {
1135 backupOptions =
1136 AllocMem(sizeof(struct optionstmp), MEMF_CLEAR | MEMF_PUBLIC);
1137 data->instc_options_backup = backupOptions;
1138 }
1139
1140 GET(data->page, MUIA_Group_ActivePage, &this_page);
1141
1142 GET(data->back, MUIA_Disabled, &data->status_back);
1143 GET(data->proceed, MUIA_Disabled, &data->status_proceed);
1144 GET(data->cancel, MUIA_Disabled, &data->status_cancel);
1145
1146 switch (this_page)
1147 {
1148 case EPartitioningStage:
1149 case EInstallStage:
1150 case EDoneStage:
1151 cancelmessage = KMsgCancelDanger;
1152 break;
1153
1154 case EInstallOptionsStage:
1155 GET(data->instc_options_main->opt_format, MUIA_Disabled,
1156 &backupOptions->opt_format);
1157 GET(data->instc_options_main->opt_locale, MUIA_Disabled,
1158 &backupOptions->opt_locale);
1159 GET(data->instc_options_main->opt_copycore, MUIA_Disabled,
1160 &backupOptions->opt_copycore);
1161 GET(data->instc_options_main->opt_copyextra, MUIA_Disabled,
1162 &backupOptions->opt_copyextra);
1163 GET(data->instc_options_main->opt_development, MUIA_Disabled,
1164 &backupOptions->opt_development);
1165 GET(data->instc_options_main->opt_bootloader, MUIA_Disabled,
1166 &backupOptions->opt_bootloader);
1167 GET(data->instc_options_main->opt_reboot, MUIA_Disabled,
1168 &backupOptions->opt_reboot);
1169
1170 SET(data->instc_options_main->opt_format, MUIA_Disabled, TRUE);
1171 SET(data->instc_options_main->opt_locale, MUIA_Disabled, TRUE);
1172 SET(data->instc_options_main->opt_copycore, MUIA_Disabled, TRUE);
1173 SET(data->instc_options_main->opt_copyextra, MUIA_Disabled, TRUE);
1174 SET(data->instc_options_main->opt_development, MUIA_Disabled, TRUE);
1175 SET(data->instc_options_main->opt_bootloader, MUIA_Disabled, TRUE);
1176 SET(data->instc_options_main->opt_reboot, MUIA_Disabled, TRUE);
1177 goto donecancel;
1178
1179 case EDestOptionsStage:
1180 SET(dest_volume, MUIA_Disabled, TRUE);
1181 SET(work_volume, MUIA_Disabled, TRUE);
1182 SET(check_copytowork, MUIA_Disabled, TRUE);
1183 SET(check_work, MUIA_Disabled, TRUE);
1184 goto donecancel;
1185
1186 case EPartitionOptionsStage:
1187 SET(data->instc_options_main->opt_partmethod, MUIA_Disabled, TRUE);
1188 goto donecancel;
1189
1190 case EGrubOptionsStage:
1191 goto donecancel;
1192
1193 default:
1194 donecancel:
1195 cancelmessage = KMsgCancelOK;
1196 break;
1197 }
1198
1199 SET(data->back, MUIA_Selected, FALSE);
1200 SET(data->back, MUIA_Disabled, TRUE);
1201
1202 SET(data->proceed, MUIA_Selected, FALSE);
1203 SET(data->proceed, MUIA_Disabled, TRUE);
1204
1205 SET(data->cancel, MUIA_Selected, FALSE);
1206 SET(data->cancel, MUIA_Disabled, TRUE);
1207
1208 if (!MUI_RequestA(data->installer, data->window, 0,
1209 "Cancel Installation...", "*Continue Install|Cancel Install",
1210 cancelmessage, NULL))
1211 {
1212 DoMethod(self, MUIM_IC_QuitInstall);
1213 }
1214 else
1215 DoMethod(self, MUIM_IC_ContinueInstall);
1216
1217 return 0;
1218 }
1219
1220 IPTR Install__MUIM_IC_ContinueInstall
1221 (Class * CLASS, Object * self, Msg message)
1222 {
1223 struct Install_DATA *data = INST_DATA(CLASS, self);
1224 struct optionstmp *backupOptions = NULL;
1225 IPTR this_page = 0;
1226
1227 backupOptions = data->instc_options_backup;
1228
1229 GET(data->page, MUIA_Group_ActivePage, &this_page);
1230
1231 if (!(BOOL) data->disable_back)
1232 SET(data->back, MUIA_Disabled, data->status_back);
1233 else
1234 SET(data->back, MUIA_Disabled, TRUE);
1235 SET(data->back, MUIA_Selected, FALSE);
1236
1237 SET(data->proceed, MUIA_Disabled, data->status_proceed);
1238 SET(data->proceed, MUIA_Selected, FALSE);
1239
1240 SET(data->cancel, MUIA_Disabled, data->status_cancel);
1241 SET(data->cancel, MUIA_Selected, FALSE);
1242
1243 switch (this_page)
1244 {
1245 case EInstallOptionsStage:
1246 SET(data->instc_options_main->opt_format, MUIA_Disabled,
1247 (BOOL) backupOptions->opt_format);
1248 SET(data->instc_options_main->opt_locale, MUIA_Disabled,
1249 (BOOL) backupOptions->opt_locale);
1250 SET(data->instc_options_main->opt_copycore, MUIA_Disabled,
1251 (BOOL) backupOptions->opt_copycore);
1252 SET(data->instc_options_main->opt_copyextra, MUIA_Disabled,
1253 (BOOL) backupOptions->opt_copyextra);
1254 SET(data->instc_options_main->opt_development, MUIA_Disabled,
1255 (BOOL) backupOptions->opt_development);
1256 SET(data->instc_options_main->opt_bootloader, MUIA_Disabled,
1257 (BOOL) backupOptions->opt_bootloader);
1258 SET(data->instc_options_main->opt_reboot, MUIA_Disabled,
1259 (BOOL) backupOptions->opt_reboot);
1260 break;
1261
1262 case EDestOptionsStage:
1263 SET(dest_volume, MUIA_Disabled, FALSE);
1264 SET(check_work, MUIA_Disabled, FALSE);
1265
1266 IPTR reenable = 0;
1267 GET(check_work, MUIA_Selected, &reenable);
1268
1269 if (reenable)
1270 {
1271 SET(check_copytowork, MUIA_Disabled, FALSE);
1272 SET(work_volume, MUIA_Disabled, FALSE);
1273 }
1274 break;
1275
1276 case EPartitionOptionsStage:
1277 SET(data->instc_options_main->opt_partmethod, MUIA_Disabled, FALSE);
1278 break;
1279
1280 case EGrubOptionsStage:
1281 break;
1282
1283 default:
1284 break;
1285 }
1286
1287 return 0;
1288 }
1289
1290 IPTR Install__MUIM_IC_QuitInstall(Class * CLASS, Object * self, Msg message)
1291 {
1292 struct Install_DATA *data = INST_DATA(CLASS, self);
1293
1294 if (data->inst_success == MUIV_Inst_InProgress)
1295 {
1296 data->inst_success = MUIV_Inst_Cancelled;
1297
1298 DoMethod(self, MUIM_Reboot);
1299 }
1300
1301 return 0;
1302 }
1303
1304 /* ****** FUNCTION IS CALLED BY THE PROCEDURE PROCESSOR
1305
1306 IT LAUNCHES THE NECESSARY FUNCTION TO PERFORM WHATEVER IS BEING ASKED TO DO
1307 */
1308
1309 IPTR Install__MUIM_DispatchInstallProcedure
1310 (Class * CLASS, Object * self, Msg message)
1311 {
1312 // struct Install_DATA* data = INST_DATA(CLASS, self);
1313
1314 return 0;
1315 }
1316
1317
1318 static LONG GetPartitionSize(BOOL get_work)
1319 {
1320 LONG size = -1;
1321 IPTR tmp = 0;
1322
1323 if (!get_work)
1324 {
1325 if ((BOOL) XGET(check_sizesys, MUIA_Selected))
1326 {
1327 GET(sys_size, MUIA_String_Integer, &tmp);
1328 size = (LONG) tmp;
1329 if (XGET(cycle_sysunits, MUIA_Cycle_Active) == 1)
1330 size *= 1024;
1331 }
1332 }
1333 else
1334 {
1335 if ((BOOL) XGET(check_sizework, MUIA_Selected))
1336 {
1337 GET(work_size, MUIA_String_Integer, &tmp);
1338 size = (LONG) tmp;
1339 if (XGET(cycle_workunits, MUIA_Cycle_Active) == 1)
1340 size *= 1024;
1341 }
1342 }
1343
1344 return size;
1345 }
1346
1347 IPTR Install__MUIM_Partition(Class * CLASS, Object * self, Msg message)
1348 {
1349 struct Install_DATA *data = INST_DATA(CLASS, self);
1350 IPTR option = FALSE;
1351 IPTR tmp = 0;
1352
1353 if (data->inst_success == MUIV_Inst_InProgress)
1354 {
1355 SET(data->back, MUIA_Disabled, TRUE);
1356 SET(data->proceed, MUIA_Disabled, TRUE);
1357
1358 char tmpcmd[150], tmparg[100];
1359 GET(dest_device, MUIA_String_Contents, &tmp);
1360 GET(dest_unit, MUIA_String_Integer, &option);
1361 sprintf(tmpcmd, "C:Partition DEVICE=%s UNIT=%ld FORCE QUIET",
1362 (char *)tmp, option);
1363
1364 /* Specify SYS size */
1365 GET(check_sizesys, MUIA_Selected, &option);
1366 if (option)
1367 {
1368 tmp = GetPartitionSize(FALSE);
1369 sprintf(tmparg, " SYSSIZE=%ld", tmp);
1370 strcat(tmpcmd, tmparg);
1371 }
1372
1373 /* Specify SYS name */
1374 GET(sys_devname, MUIA_String_Contents, &tmp);
1375 sprintf(tmparg, " SYSNAME=\"%s\"", (char *)tmp);
1376 strcat(tmpcmd, tmparg);
1377
1378 /* Specify SYS filesystem (defaults to FFSIntl) */
1379 get(cycle_fstypesys, MUIA_Cycle_Active, &tmp);
1380 if ((int)tmp == 1)
1381 strcat(tmpcmd, " SYSTYPE=SFS");
1382 else
1383 strcat(tmpcmd, " SYSTYPE=FFSIntl");
1384
1385 /* Specify Work size */
1386 GET(check_creatework, MUIA_Selected, &option);
1387 if (option)
1388 {
1389 GET(check_sizework, MUIA_Selected, &option);
1390 if (option)
1391 {
1392 tmp = GetPartitionSize(TRUE);
1393 sprintf(tmparg, " WORKSIZE=%ld", tmp);
1394 strcat(tmpcmd, tmparg);
1395 }
1396 else
1397 {
1398 strcat(tmpcmd, " MAXWORK");
1399 }
1400
1401 /* Specify WORK filesystem (defaults to SFS) */
1402 get(cycle_fstypework, MUIA_Cycle_Active, &tmp);
1403 if ((int)tmp == 0)
1404 strcat(tmpcmd, " WORKTYPE=FFSIntl");
1405 else
1406 strcat(tmpcmd, " WORKTYPE=SFS");
1407
1408 /* Specify WORK name */
1409 GET(work_devname, MUIA_String_Contents, &tmp);
1410 sprintf(tmparg, " WORKNAME=\"%s\"", (char *)tmp);
1411 strcat(tmpcmd, tmparg);
1412 }
1413
1414 /* Specify whether to wipe disk or not */
1415 GET(data->instc_options_main->opt_partmethod, MUIA_Radio_Active,
1416 &option);
1417 if (option == 1)
1418 {
1419 D(bug("[INSTALLER] Partitioning EVERYTHING! MUAHAHAHA...\n"));
1420 strcat(tmpcmd, " WIPE");
1421 }
1422 else
1423 D(bug("[INSTALLER] Partitioning Free Space...\n"));
1424
1425 D(bug("[INSTALLER] ### Executing '%s'\n", &tmpcmd));
1426 tmp = SystemTagList(tmpcmd, NULL);
1427
1428 SET(data->proceed, MUIA_Disabled, FALSE);
1429 }
1430
1431 return tmp;
1432 }
1433
1434 void create_environment_variable(CONST_STRPTR envarchiveDisk,
1435 CONST_STRPTR name, CONST_STRPTR value)
1436 {
1437 BPTR env_variable_fh = NULL;
1438 TEXT env_variable_path[100];
1439
1440 if ((envarchiveDisk == NULL) || (name == NULL) || (value == NULL))
1441 return;
1442
1443
1444 sprintf(env_variable_path, "%s:", envarchiveDisk);
1445 AddPart(env_variable_path, "Prefs/Env-Archive/", 100);
1446 AddPart(env_variable_path, name, 100);
1447
1448 D(bug
1449 ("[INSTALLER] create_environment_variable: Setting Var '%s' to '%s'\n",
1450 env_variable_path, value));
1451
1452 if ((env_variable_fh = Open(env_variable_path, MODE_NEWFILE)) != NULL)
1453 {
1454 FPuts(env_variable_fh, value);
1455 Close(env_variable_fh);
1456 }
1457 }
1458
1459 static BOOL read_environment_variable(CONST_STRPTR envarchiveDisk,
1460 CONST_STRPTR name, STRPTR buffer, ULONG size)
1461 {
1462 BPTR env_variable_fh = NULL;
1463 TEXT env_variable_path[100];
1464
1465 if ((envarchiveDisk == NULL) || (name == NULL) || (buffer == NULL))
1466 return FALSE;
1467
1468 sprintf(env_variable_path, "%s:", envarchiveDisk);
1469 AddPart(env_variable_path, "Prefs/Env-Archive/", 100);
1470 AddPart(env_variable_path, name, 100);
1471
1472 D(bug("[INSTALLER] read_environment_variable: Getting Var '%s'\n",
1473 env_variable_path));
1474
1475 if ((env_variable_fh = Open(env_variable_path, MODE_OLDFILE)) != NULL)
1476 {
1477 FGets(env_variable_fh, buffer, size);
1478 Close(env_variable_fh);
1479 return TRUE;
1480 }
1481 return FALSE;
1482 }
1483
1484 LONG CountFiles(CONST_STRPTR directory, CONST_STRPTR fileMask,
1485 BOOL recursive)
1486 {
1487 UBYTE *buffer = NULL;
1488 TEXT matchString[3 * strlen(fileMask)];
1489 BPTR dirLock = NULL;
1490 LONG fileCount = 0;
1491
1492 D(bug("[INSTALLER.Count] Entry, directory: %s, mask: %s\n", directory,
1493 fileMask));
1494
1495 /* Check if directory exists */
1496 dirLock = Lock(directory, SHARED_LOCK);
1497
1498 if (dirLock == NULL)
1499 {
1500 return -1;
1501 }
1502
1503 buffer = AllocVec(kExallBufSize, MEMF_CLEAR | MEMF_PUBLIC);
1504
1505 if (buffer == NULL)
1506 {
1507 UnLock(dirLock);
1508 return -1;
1509 }
1510
1511 if (ParsePatternNoCase(fileMask, matchString, 3 * strlen(fileMask)) < 0)
1512 {
1513 UnLock(dirLock);
1514 FreeVec(buffer);
1515 return -1;
1516 }
1517
1518 struct ExAllData *ead = (struct ExAllData *)buffer;
1519 struct ExAllControl *eac = AllocDosObject(DOS_EXALLCONTROL, NULL);
1520 eac->eac_LastKey = 0;
1521
1522 BOOL loop;
1523 struct ExAllData *oldEad = ead;
1524
1525 do
1526 {
1527 ead = oldEad;
1528 loop = ExAll(dirLock, ead, kExallBufSize, ED_COMMENT, eac);
1529
1530 if (!loop && IoErr() != ERROR_NO_MORE_ENTRIES)
1531 break;
1532
1533 if (eac->eac_Entries != 0)
1534 {
1535 do
1536 {
1537 if (ead->ed_Type == ST_FILE
1538 && MatchPatternNoCase(matchString, ead->ed_Name))
1539 fileCount++;
1540
1541 if (ead->ed_Type == ST_USERDIR && recursive)
1542 {
1543 LONG subFileCount = 0;
1544 ULONG subDirNameLen =
1545 strlen(directory) + strlen(ead->ed_Name) + 2;
1546 TEXT subDirName[subDirNameLen];
1547
1548 sprintf(subDirName, "%s", directory);
1549 AddPart(subDirName, ead->ed_Name, subDirNameLen);
1550
1551 subFileCount =
1552 CountFiles(subDirName, fileMask, recursive);
1553
1554 if (subFileCount >= 0)
1555 fileCount += subFileCount;
1556 else
1557 {
1558 /* Error at lower level */
1559 FreeDosObject(DOS_EXALLCONTROL, eac);
1560 UnLock(dirLock);
1561 FreeVec(buffer);
1562 return -1;
1563 }
1564 }
1565 ead = ead->ed_Next;
1566 }
1567 while (ead != NULL);
1568 }
1569 }
1570 while (loop);
1571
1572 FreeDosObject(DOS_EXALLCONTROL, eac);
1573 UnLock(dirLock);
1574 FreeVec(buffer);
1575
1576 return fileCount;
1577 }
1578
1579 LONG InternalCopyFiles(Class * CLASS, Object * self, CONST_STRPTR srcDir,
1580 CONST_STRPTR dstDir, CONST_STRPTR fileMask, BOOL recursive,
1581 LONG totalFiles, LONG totalFilesCopied)
1582 {
1583 struct Install_DATA *data = INST_DATA(CLASS, self);
1584 UBYTE *buffer = NULL;
1585 TEXT matchString[3 * strlen(fileMask)];
1586 BPTR srcDirLock = NULL, dstDirLock = NULL;
1587 LONG totalFilesCopiedThis = 0;
1588
1589 /* Check entry condition */
1590 if (data->inst_success != MUIV_Inst_InProgress)
1591 return totalFilesCopied;
1592
1593 /* Check if source directory exists */
1594 do
1595 {
1596 srcDirLock = Lock(srcDir, SHARED_LOCK);
1597
1598 if (srcDirLock == NULL)
1599 {
1600 ULONG retry =
1601 AskRetry(CLASS, self, "Could not find %s\nRetry?", srcDir,
1602 "Yes", "Skip", "Quit");
1603 switch (retry)
1604 {
1605 case 0: /*retry */
1606 break;
1607 case 1: /* skip */
1608 return -1;
1609 default: /* quit */
1610 DoMethod(self, MUIM_IC_QuitInstall);
1611 return -1;
1612 }
1613 }
1614 }
1615 while (srcDirLock == NULL);
1616
1617 /* Check if destination directory exists and create it */
1618 dstDirLock = Lock(dstDir, SHARED_LOCK);
1619
1620 if (dstDirLock != NULL)
1621 UnLock(dstDirLock);
1622 else
1623 {
1624 dstDirLock = CreateDir(dstDir);
1625 if (dstDirLock != NULL)
1626 UnLock(dstDirLock);
1627 else
1628 {
1629 UnLock(srcDirLock);
1630 return -1;
1631 }
1632 }
1633
1634 /* Allocate buffer for ExAll */
1635 buffer = AllocVec(kExallBufSize, MEMF_CLEAR | MEMF_PUBLIC);
1636
1637 if (buffer == NULL)
1638 {
1639 UnLock(srcDirLock);
1640 return -1;
1641 }
1642
1643 if (ParsePatternNoCase(fileMask, matchString, 3 * strlen(fileMask)) < 0)
1644 {
1645 UnLock(srcDirLock);
1646 FreeVec(buffer);
1647 return -1;
1648 }
1649
1650 struct ExAllData *ead = (struct ExAllData *)buffer;
1651 struct ExAllControl *eac = AllocDosObject(DOS_EXALLCONTROL, NULL);
1652 eac->eac_LastKey = 0;
1653
1654 BOOL loop;
1655 struct ExAllData *oldEad = ead;
1656
1657
1658 /* Main copy file loop */
1659 do
1660 {
1661 ead = oldEad;
1662 loop = ExAll(srcDirLock, ead, kExallBufSize, ED_COMMENT, eac);
1663
1664 if (!loop && IoErr() != ERROR_NO_MORE_ENTRIES)
1665 break;
1666
1667 if (eac->eac_Entries != 0)
1668 {
1669 do
1670 {
1671 if (((ead->ed_Type == ST_FILE)
1672 && MatchPatternNoCase(matchString, ead->ed_Name))
1673 || ((ead->ed_Type == ST_USERDIR) && recursive))
1674 {
1675 ULONG srcLen = strlen(srcDir);
1676 ULONG dstLen = strlen(dstDir);
1677 ULONG newSrcLen = srcLen + strlen(ead->ed_Name) + 2;
1678 ULONG newDstLen = dstLen + strlen(ead->ed_Name) + 2;
1679
1680 TEXT srcFile[newSrcLen];
1681 TEXT dstFile[newDstLen];
1682
1683 sprintf(srcFile, "%s", srcDir);
1684 sprintf(dstFile, "%s", dstDir);
1685
1686 AddPart(srcFile, ead->ed_Name, newSrcLen);
1687 AddPart(dstFile, ead->ed_Name, newDstLen);
1688
1689 if (ead->ed_Type == ST_FILE)
1690 {
1691 totalFilesCopiedThis +=
1692 (ULONG) DoMethod(self, MUIM_IC_CopyFile,
1693 srcFile, dstFile);
1694
1695 if (totalFiles > 0)
1696 {
1697 SET(data->gauge2, MUIA_Gauge_Current,
1698 (LONG) ((100.0 / totalFiles) *
1699 (totalFilesCopied +
1700 totalFilesCopiedThis)));
1701 }
1702 }
1703
1704 if (ead->ed_Type == ST_USERDIR)
1705 {
1706
1707 LONG totalFilesCopiedSub =
1708 InternalCopyFiles(CLASS, self, srcFile, dstFile,
1709 fileMask,
1710 recursive, totalFiles,
1711 totalFilesCopied + totalFilesCopiedThis);
1712 if (totalFilesCopiedSub >= 0)
1713 totalFilesCopiedThis += totalFilesCopiedSub;
1714 else
1715 {
1716 /* Do nothing. It will be caught at level of Install__MUIM_IC_CopyFiles */
1717 }
1718 }
1719 }
1720
1721 ead = ead->ed_Next;
1722 }
1723 while ((ead != NULL)
1724 && (data->inst_success == MUIV_Inst_InProgress));
1725 }
1726 }
1727 while ((loop) && (data->inst_success == MUIV_Inst_InProgress));
1728
1729 FreeDosObject(DOS_EXALLCONTROL, eac);
1730 UnLock(srcDirLock);
1731 FreeVec(buffer);
1732
1733 return totalFilesCopiedThis;
1734 }
1735
1736 IPTR Install__MUIM_IC_CopyFiles
1737 (Class * CLASS, Object * self, struct MUIP_CopyFiles * message)
1738 {
1739 struct Install_DATA *data = INST_DATA(CLASS, self);
1740 LONG totalFiles = -1, totalFilesCopied = 0;
1741
1742
1743 D(bug("[INSTALLER.CFs] Entry, src: %s, dst: %s, mask: %s\n",
1744 message->srcDir, message->dstDir, message->fileMask));
1745
1746 /* Check entry condition */
1747 if (data->inst_success != MUIV_Inst_InProgress)
1748 {
1749 D(bug("[INSTALLER.CFs] Installation failed\n"));
1750 return totalFilesCopied;
1751 }
1752
1753 SET(data->gauge2, MUIA_Gauge_Current, 0);
1754
1755 /* Get file count */
1756 do
1757 {
1758 totalFiles =
1759 CountFiles(message->srcDir, message->fileMask,
1760 message->recursive);
1761 D(bug("[INSTALLER.CFs] Found %ld files in %s\n", totalFiles,
1762 message->srcDir));
1763
1764 if (totalFiles < 0)
1765 {
1766 ULONG retry =
1767 AskRetry(CLASS, self, "Error scanning %s\nRetry?",
1768 message->srcDir, "Yes", "Skip", "Quit");
1769 switch (retry)
1770 {
1771 case 0: /* retry */
1772 break;
1773 case 1: /* skip */
1774 totalFiles = 0;
1775 break;
1776 default: /* quit */
1777 DoMethod(self, MUIM_IC_QuitInstall);
1778 return totalFilesCopied;
1779 }
1780 }
1781 }
1782 while (totalFiles < 0);
1783
1784 /* Copy files */
1785 totalFilesCopied =
1786 InternalCopyFiles(CLASS, self, message->srcDir, message->dstDir,
1787 message->fileMask, message->recursive, totalFiles,
1788 totalFilesCopied);
1789
1790 /* Check final condition */
1791 if ((data->inst_success == MUIV_Inst_InProgress)
1792 && (totalFiles != totalFilesCopied))
1793 {
1794 TEXT msg[strlen(KMsgNotAllFilesCopied) + strlen(message->srcDir) +
1795 3];
1796 sprintf(msg, KMsgNotAllFilesCopied, message->srcDir);
1797
1798 if (MUI_RequestA(data->installer, data->window, 0, "Error",
1799 "Continue|*Quit", msg, NULL) != 1)
1800 DoMethod(self, MUIM_IC_QuitInstall);
1801
1802 return totalFilesCopied;
1803 }
1804
1805 return totalFilesCopied;
1806 }
1807
1808 IPTR Install__MUIM_IC_Install(Class * CLASS, Object * self, Msg message)
1809 {
1810 struct Install_DATA *data = INST_DATA(CLASS, self);
1811 BPTR lock = NULL;
1812 IPTR option = FALSE;
1813
1814 GET(dest_volume, MUIA_String_Contents, &option);
1815 strcpy(dest_Path, (STRPTR) option);
1816 GET(work_volume, MUIA_String_Contents, &option);
1817 strcpy(work_Path, (STRPTR) option);
1818
1819 SET(data->back, MUIA_Disabled, TRUE);
1820 SET(data->proceed, MUIA_Disabled, TRUE);
1821
1822 SET(data->pagetitle, MUIA_Text_Contents, "Installing AROS...");
1823
1824 /* set up destination Work name to use */
1825
1826 GET(check_copytowork, MUIA_Selected, &option);
1827 if (option && (data->inst_success == MUIV_Inst_InProgress))
1828 extras_path = work_Path;
1829 else
1830 extras_path = dest_Path;
1831
1832 /* STEP : FORMAT */
1833
1834 GET(data->instc_options_main->opt_format, MUIA_Selected, &option);
1835 if (option && data->inst_success == MUIV_Inst_InProgress)
1836 {
1837 GET(data->instc_options_main->opt_partmethod, MUIA_Radio_Active,
1838 &option);
1839
1840 DoMethod(self, MUIM_Format);
1841 }
1842
1843 /* MAKE SURE THE WORK PART EXISTS TO PREVENT CRASHING! */
1844
1845 if ((BOOL) XGET(check_work, MUIA_Selected))
1846 {
1847 char tmp[100];
1848 sprintf(tmp, "%s:", work_Path);
1849 D(bug
1850 ("[INSTALLER] Install : Using a Work partition - checking validity..."));
1851 if ((lock = Lock(tmp, SHARED_LOCK))) /* check the dest dir exists */
1852 {
1853 D(bug("OK!\n"));
1854 UnLock(lock);
1855 }
1856 else
1857 {
1858 D(bug
1859 ("FAILED!\n[INSTALLER] (Warning) INSTALL - Failed to locate chosen work partition '%s' : defaulting to sys only\n",
1860 work_Path));
1861 extras_path = dest_Path;
1862 }
1863 lock = 0;
1864 }
1865 else
1866 {
1867 D(bug("[INSTALLER] Install: Using SYS partition only (%s)\n",
1868 dest_Path));
1869 }
1870
1871 DoMethod(data->installer, MUIM_Application_InputBuffered);
1872
1873 /* STEP : LOCALE */
1874
1875 GET(data->instc_options_main->opt_locale, MUIA_Selected, &option);
1876 if (option && (data->inst_success == MUIV_Inst_InProgress))
1877 {
1878 D(bug("[INSTALLER] Launching Locale Prefs...\n"));
1879
1880 ULONG srcLen = strlen(source_Path), dstLen =
1881 (strlen(dest_Path) + 1);
1882 ULONG envsrcLen = strlen(prefssrc_path), envdstLen =
1883 strlen(prefs_path);
1884
1885 ULONG localeFileLen = srcLen + strlen(localeFile_path) + 3;
1886 ULONG inputFileLen = srcLen + strlen(inputFile_path) + 3;
1887
1888 ULONG localePFileLen =
1889 dstLen + envdstLen + strlen(locale_prfs_file) + 4;
1890
1891 ULONG inputPFileLen =
1892 dstLen + envdstLen + strlen(input_prfs_file) + 4;
1893
1894 ULONG envdstdirLen = 1024;
1895 TEXT envDstDir[envdstdirLen]; /* "DH0:Prefs/Env-Archive/SYS" */
1896
1897 TEXT localeFile[localeFileLen]; /* "CD0:Prefs/Locale" */
1898 TEXT localesrcPFile[localePFileLen]; /* "ENV:SYS/locale.prefs" */
1899 TEXT localePFile[localePFileLen]; /* "DH0:Prefs/Env-Archive/SYS/locale.prefs" */
1900 TEXT inputFile[inputFileLen]; /* "CD0:Prefs/Input" */
1901 TEXT inputsrcPFile[inputPFileLen]; /* "ENV:SYS/input.prefs" */
1902 TEXT inputPFile[inputPFileLen]; /* "DH0:Prefs/Env-Archive/SYS/input.prefs" */
1903
1904 sprintf(envDstDir, "%s:", dest_Path);
1905 sprintf(localeFile, "\"%s", source_Path);
1906 CopyMem(prefssrc_path, localesrcPFile, envsrcLen + 1);
1907 sprintf(localePFile, "%s:", dest_Path);
1908 sprintf(inputFile, "\"%s", source_Path);
1909 CopyMem(prefssrc_path, inputsrcPFile, envsrcLen + 1);
1910 sprintf(inputPFile, "%s:", dest_Path);
1911
1912 AddPart(localeFile, inputFile_path, localeFileLen);
1913
1914 AddPart(localesrcPFile, locale_prfs_file, localePFileLen);
1915
1916 AddPart(localePFile, prefs_path, localePFileLen);
1917 AddPart(localePFile, locale_prfs_file, localePFileLen);
1918
1919 AddPart(inputFile, localeFile_path, inputFileLen);
1920
1921 AddPart(inputsrcPFile, input_prfs_file, inputPFileLen);
1922
1923 AddPart(inputPFile, prefs_path, inputPFileLen);
1924 AddPart(inputPFile, input_prfs_file, inputPFileLen);
1925
1926 D(bug("[INSTALLER] Excecuting '%s'...\n", localeFile));
1927
1928 Execute(localeFile, NULL, NULL);
1929
1930 DoMethod(data->installer, MUIM_Application_InputBuffered);
1931
1932 D(bug("[INSTALLER] Excecuting '%s'...\n", inputFile));
1933
1934 Execute(inputFile, NULL, NULL);
1935
1936 DoMethod(data->installer, MUIM_Application_InputBuffered);
1937
1938 D(bug("[INSTALLER] Copying Locale Settings...\n"));
1939
1940 //create the dirs "Prefs","Prefs/Env-Archive" and "Prefs/Env-Archive/SYS"
1941 AddPart(envDstDir, "Prefs", dstLen + envdstLen);
1942 D(bug("[INSTALLER] Create Dir '%s' \n", envDstDir));
1943
1944 BPTR bootDirLock = NULL;
1945
1946 if ((lock = Lock(envDstDir, ACCESS_READ)) != NULL)
1947 {
1948 D(bug("[INSTALLER] Dir '%s' Exists - no nead to create\n",
1949 envDstDir));
1950 UnLock(lock);
1951 }
1952 else
1953 {
1954 bootDirLock = CreateDir(envDstDir);
1955 if (bootDirLock != NULL)
1956 UnLock(bootDirLock);
1957 else
1958 {
1959 createdirfaild:
1960 D(bug("[INSTALLER] Failed to create %s dir!!\n",
1961 envDstDir));
1962 /* TODO: Should prompt on failure to try again/continue anyhow/exit */
1963 goto localecopydone;
1964 //data->inst_success = MUIV_Inst_Failed;
1965 //return 0;
1966 }
1967 }
1968
1969 bootDirLock = NULL;
1970 lock = 0;
1971
1972 AddPart(envDstDir, "Env-Archive", envdstdirLen);
1973 D(bug("[INSTALLER] Create Dir '%s' \n", envDstDir));
1974 if ((lock = Lock(envDstDir, ACCESS_READ)) != NULL)
1975 {
1976 D(bug("[INSTALLER] Dir '%s' Exists - no nead to create\n",
1977 envDstDir));
1978 UnLock(lock);
1979 }
1980 else
1981 {
1982 bootDirLock = CreateDir(envDstDir);
1983 if (bootDirLock != NULL)
1984 UnLock(bootDirLock);
1985 else
1986 goto createdirfaild;
1987 }
1988
1989 bootDirLock = NULL;
1990 lock = 0;
1991
1992 AddPart(envDstDir, "SYS", envdstdirLen);
1993 D(bug("[INSTALLER] Create Dir '%s' \n", envDstDir));
1994 if ((lock = Lock(envDstDir, ACCESS_READ)) != NULL)
1995 {
1996 D(bug("[INSTALLER] Dir '%s' Exists - no nead to create\n",
1997 envDstDir));
1998 UnLock(lock);
1999 }
2000 else
2001 {
2002 bootDirLock = CreateDir(envDstDir);
2003 if (bootDirLock != NULL)
2004 UnLock(bootDirLock);
2005 else
2006 goto createdirfaild;
2007 }
2008
2009 bootDirLock = NULL;
2010 lock = 0;
2011
2012 D(bug("[INSTALLER] Copying files\n"));
2013
2014 if ((lock = Lock(localesrcPFile, ACCESS_READ)) != NULL)
2015 {
2016 UnLock(lock);
2017 DoMethod(self, MUIM_IC_CopyFile, localesrcPFile, localePFile);
2018 }
2019
2020 bootDirLock = NULL;
2021 lock = 0;
2022
2023 if ((lock = Lock(inputsrcPFile, ACCESS_READ)) != NULL)
2024 {
2025 UnLock(lock);
2026 DoMethod(self, MUIM_IC_CopyFile, inputsrcPFile, inputPFile);
2027 }
2028 localecopydone:
2029 ;
2030 }
2031
2032 DoMethod(data->installer, MUIM_Application_InputBuffered);
2033
2034 /* STEP : COPY CORE */
2035
2036 GET(data->instc_options_main->opt_copycore, MUIA_Selected, &option);
2037 if (option && (data->inst_success == MUIV_Inst_InProgress))
2038 {
2039 TEXT tmp[100];
2040 BOOL success = FALSE;
2041 CONST_STRPTR core_dirs[] = {
2042 "C", "C",
2043 "Classes", "Classes",
2044 "Devs", "Devs",
2045 "Fonts", "Fonts",
2046 "L", "L",
2047 "Libs", "Libs",
2048 "Locale", "Locale",
2049 "Prefs", "Prefs",
2050 "Rexxc", "Rexxc",
2051 "S", "S",
2052 "Storage", "Storage",
2053 "System", "System",
2054 "Tools", "Tools",
2055 "Utilities", "Utilities",
2056 "WBStartup", "WBStartup",
2057 NULL
2058 };
2059 ULONG dstLen = strlen(dest_Path) + strlen(AROS_BOOT_FILE) + 2;
2060 TEXT destinationPath[dstLen];
2061
2062 /* Copying Core system Files */
2063 D(bug("[INSTALLER] Copying Core files...\n"));
2064 SET(data->label, MUIA_Text_Contents,
2065 "Copying Core System files...");
2066 sprintf(destinationPath, "%s:", dest_Path);
2067 CopyDirArray(CLASS, self, source_Path, destinationPath, core_dirs);
2068
2069 /* Copy kernel files */
2070 strcpy(tmp, source_Path);
2071 AddPart(tmp, BOOT_PATH, 100);
2072 sprintf(destinationPath, "%s:%s", dest_Path, BOOT_PATH);
2073 DoMethod(self, MUIM_IC_CopyFiles, tmp, destinationPath, "#?",
2074 FALSE);
2075
2076 /* Copy AROS.boot file */
2077 sprintf(tmp, "%s", source_Path);
2078 sprintf(destinationPath, "%s:" AROS_BOOT_FILE, dest_Path);
2079 AddPart(tmp, AROS_BOOT_FILE, 100);
2080 DoMethod(self, MUIM_IC_CopyFile, tmp, destinationPath);
2081
2082 /* Make Env-Archive Writeable */
2083 sprintf(tmp, "Protect ADD FLAGS=W ALL QUIET %s:Prefs/Env-Archive",
2084 dest_Path);
2085 D(bug
2086 ("[INSTALLER] Changing Protection on Env Files (command='%s')\n",
2087 tmp));
2088 success = (BOOL) Execute(tmp, NULL, NULL);
2089
2090 if (!success)
2091 {
2092 D(bug
2093 ("[INSTALLER] Changing Protection on Env Files failed: %d\n",
2094 IOErr()));
2095 }
2096 }
2097
2098 DoMethod(data->installer, MUIM_Application_InputBuffered);
2099
2100 /* STEP : COPY EXTRAS */
2101
2102 GET(data->instc_options_main->opt_copyextra, MUIA_Selected, &option);
2103 if (option && data->inst_success == MUIV_Inst_InProgress)
2104 {
2105 CONST_STRPTR extras_dirs[] = {
2106 "Demos", "Demos",
2107 "Extras", "Extras",
2108 NULL
2109 };
2110
2111 TEXT extraspath[100];
2112 BOOL undoenabled = data->instc_copt_undoenabled;
2113
2114 /* Explicitly disable undo. Some users might not have RAM for backup */
2115 data->instc_copt_undoenabled = FALSE;
2116
2117 /* Copying Extras */
2118 D(bug("[INSTALLER] Copying Extras to '%s'...\n", extras_path));
2119 SET(data->label, MUIA_Text_Contents, "Copying Extra Software...");
2120 sprintf(extraspath, "%s:", extras_path);
2121 CopyDirArray(CLASS, self, extras_source, extraspath, extras_dirs);
2122
2123 /* Set EXTRASPATH environment variable */
2124 AddPart(extraspath, "Extras", 100);
2125 create_environment_variable(dest_Path, "EXTRASPATH", extraspath);
2126
2127 /* Restore undo state */
2128 data->instc_copt_undoenabled = undoenabled;
2129 }
2130
2131 DoMethod(data->installer, MUIM_Application_InputBuffered);
2132
2133 /* STEP : COPY DEVELOPMENT */
2134
2135 GET(data->instc_options_main->opt_development, MUIA_Selected, &option);
2136 if (option && (data->inst_success == MUIV_Inst_InProgress))
2137 {
2138 ULONG srcLen = strlen(source_Path);
2139 ULONG developerDirLen = srcLen + strlen("Development") + 2;
2140 TEXT developerDir[srcLen + developerDirLen];
2141
2142 CopyMem(source_Path, &developerDir, srcLen + 1);
2143 AddPart(developerDir, "Development", srcLen + developerDirLen);
2144
2145 if ((lock = Lock(developerDir, SHARED_LOCK)) != NULL)
2146 {
2147 CONST_STRPTR developer_dirs[] = {
2148 "Development", "Development",
2149 "Tests", "Tests",
2150 NULL
2151 };
2152 TEXT developmentpath[100];
2153 BOOL undoenabled = data->instc_copt_undoenabled;
2154
2155 /* Explicitly disable undo. Some users might not have RAM for backup */
2156 data->instc_copt_undoenabled = FALSE;
2157
2158 UnLock(lock);
2159
2160 /* Copying Developer stuff */
2161 D(bug("[INSTALLER] Copying Developer Files...\n"));
2162 SET(data->label, MUIA_Text_Contents,
2163 "Copying Developer Files...");
2164 sprintf(developmentpath, "%s:", extras_path);
2165 CopyDirArray(CLASS, self, source_Path, developmentpath,
2166 developer_dirs);
2167
2168 /* Set DEVELPATH environment variable */
2169 AddPart(developmentpath, "Development", 100);
2170 create_environment_variable(dest_Path, "DEVELPATH",
2171 developmentpath);
2172
2173 /* Restore undo state */
2174 data->instc_copt_undoenabled = undoenabled;
2175 }
2176 else
2177 D(bug("[INSTALLER] Couldn't locate Developer Files...\n"));
2178 }
2179
2180 if (!option && (data->inst_success == MUIV_Inst_InProgress))
2181 {
2182 /* If not installing Development, delete the package file */
2183 TEXT packagePath[100];
2184 sprintf(packagePath, "%s:Prefs/Env-Archive/SYS/Packages/Developer",
2185 dest_Path);
2186 D(bug("[INSTALLER] Deleting Developer Package...\n"));
2187 DeleteFile(packagePath);
2188 }
2189
2190 DoMethod(data->installer, MUIM_Application_InputBuffered);
2191
2192 /* STEP : INSTALL BOOTLOADER */
2193
2194 GET(data->instc_options_main->opt_bootloader, MUIA_Selected, &option);
2195 if (option && (data->inst_success == MUIV_Inst_InProgress))
2196 {
2197 int numgrubfiles = 0, file_count = 0;
2198 LONG part_no;
2199 ULONG srcLen =
2200 strlen(source_Path) + strlen(BOOT_PATH) + strlen(GRUB_PATH) + 4;
2201 ULONG dstLen =
2202 strlen(dest_Path) + strlen(BOOT_PATH) + strlen(GRUB_PATH) + 4;
2203 TEXT srcPath[srcLen];
2204 TEXT dstPath[dstLen];
2205 TEXT tmp[256];
2206
2207 /* Installing GRUB */
2208 D(bug("[INSTALLER] Installing Grub...\n"));
2209 SET(data->label, MUIA_Text_Contents, "Installing Grub...");
2210 SET(data->pageheader, MUIA_Text_Contents, KMsgBootLoader);
2211 SET(data->label, MUIA_Text_Contents, "Copying BOOT files...");
2212
2213 strcpy(srcPath, source_Path);
2214 AddPart(srcPath, BOOT_PATH, srcLen);
2215 sprintf(dstPath, "%s:%s", dest_Path, BOOT_PATH);
2216 AddPart(srcPath, GRUB_PATH, srcLen);
2217 AddPart(dstPath, GRUB_PATH, dstLen);
2218 /* Warning: do not modify srcPath or dstPath beyond this point */
2219
2220 /* Get drive chosen to install GRUB bootblock to */
2221 GET(grub_device, MUIA_String_Contents, &option);
2222 strcpy(boot_Device, (STRPTR) option);
2223 boot_Unit = XGET(grub_unit, MUIA_String_Integer);
2224
2225 switch (BootLoaderType)
2226 {
2227 case BOOTLOADER_GRUB2:
2228
2229 DoMethod(self, MUIM_IC_CopyFiles, srcPath, dstPath, "#?.mod",
2230 FALSE);
2231
2232 TEXT *grub2_files[] = {
2233 "boot.img", "boot.img",
2234 "core.img", "core.img",
2235 "grub.cfg", "grub.cfg",
2236 "splash.png", "splash.png",
2237 "_unicode.pf2", "_unicode.pf2",
2238 "command.lst", "command.lst",
2239 "fs.lst", "fs.lst",
2240 "moddep.lst", "moddep.lst",
2241 NULL
2242 };
2243 numgrubfiles = (sizeof(grub2_files) / sizeof(TEXT *) - 1) / 2;
2244
2245 GRUB_COPY_FILE_LOOP(grub2_files);
2246
2247 /* Grub 2 text/gfx mode */
2248 GET(data->instc_options_grub->gopt_grub2mode, MUIA_Cycle_Active,
2249 &option);
2250 if (option == 1)
2251 {
2252 /* gfx mode - copy _unicode.pf2 -> unicode.pf2 */
2253 ULONG newDstLen =
2254 strlen(dstPath) + strlen("_unicode.pf2") + 2;
2255 TEXT srcFile[newDstLen];
2256 TEXT dstFile[newDstLen];
2257
2258 sprintf(srcFile, "%s", dstPath);
2259 sprintf(dstFile, "%s", dstPath);
2260 AddPart(srcFile, "_unicode.pf2", newDstLen);
2261 AddPart(dstFile, "unicode.pf2", newDstLen);
2262
2263 DoMethod(self, MUIM_IC_CopyFile, srcFile, dstFile);
2264 }
2265 else
2266 {
2267 /* other - delete unicode.pf2 */
2268 ULONG newDstLen =
2269 strlen(dstPath) + strlen("unicode.pf2") + 2;
2270 TEXT dstFile[newDstLen];
2271
2272 sprintf(dstFile, "%s", dstPath);
2273 AddPart(dstFile, "unicode.pf2", newDstLen);
2274
2275 DeleteFile(dstFile);
2276 }
2277
2278 /* Add entry to boot MS Windows if present */
2279 if ((part_no =
2280 FindWindowsPartition(boot_Device, boot_Unit)) != -1
2281 && XGET(cycle_drivetype, MUIA_Cycle_Active) == 0)
2282 {
2283 sprintf(tmp, "%s", dstPath);
2284 AddPart(tmp, "grub.cfg", 256);
2285
2286 BPTR menu_file = Open(tmp, MODE_READWRITE);
2287
2288 if (menu_file != NULL)
2289 {
2290 Seek(menu_file, 0, OFFSET_END);
2291 FPrintf(menu_file, "\nmenuentry \"Microsoft Windows\" {\n chainloader (hd%ld,%ld)+1\n}\n\n", 0, part_no + 1); /* GRUB2 counts partitions from 1 */
2292 Close(menu_file);
2293 }
2294 D(bug
2295 ("[INSTALLER] Windows partition found. Adding Windows option to GRUB2 menu.\n"));
2296 }
2297
2298 sprintf(tmp,
2299 "C:Install-grub2-i386-pc DEVICE \"%s\" UNIT %d GRUB \"%s\"",
2300 boot_Device, boot_Unit, dstPath);
2301
2302 break;
2303 case BOOTLOADER_GRUB1:
2304
2305 CreateDir(dstPath);
2306
2307 numgrubfiles = 3;
2308
2309 TEXT *grub_files[] = {
2310 "stage1", "stage1",
2311 "stage2_hdisk", "stage2",
2312 "menu.lst.DH0", "menu.lst",
2313 NULL
2314 };
2315
2316 GRUB_COPY_FILE_LOOP(grub_files);
2317
2318 /* Add entry to boot MS Windows if present */
2319 if ((part_no =
2320 FindWindowsPartition(boot_Device, boot_Unit)) != -1)
2321 {
2322 sprintf(tmp, "%s", dstPath);
2323 AddPart(tmp, "menu.lst", 256);
2324
2325 BPTR menu_file = Open(tmp, MODE_READWRITE);
2326 if (menu_file != NULL)
2327 {
2328 Seek(menu_file, 0, OFFSET_END);
2329 FPrintf(menu_file,
2330 "\ntitle Microsoft Windows\nrootnoverify (hd%ld,%ld)\nchainloader +1\n",
2331 0, part_no);
2332 Close(menu_file);
2333 }
2334 D(bug
2335 ("[INSTALLER] Windows partition found. Adding Windows option to GRUB menu.\n"));
2336 }
2337
2338 sprintf(tmp,
2339 "C:install-i386-pc DEVICE \"%s\" UNIT %d GRUB \"%s\" FORCELBA",
2340 boot_Device, boot_Unit, dstPath);
2341
2342 break;
2343 /* TODO: support more bootloaders */
2344 }
2345
2346 D(bug("[INSTALLER] execute: %s\n", tmp));
2347 Execute(tmp, NULL, NULL);
2348 SET(data->gauge2, MUIA_Gauge_Current, 100);
2349 }
2350
2351 SET(data->proceed, MUIA_Disabled, FALSE);
2352
2353 /* STEP : PACKAGE CLEANUP */
2354 /* REMOVED - handled by DEVELPATH and EXTRASPATH variables */
2355
2356 /* STEP : CREATE ENVIRONMENT VARIABLES THAT POINT TO INSTALLATION LOCATIONS */
2357 {
2358 TEXT varval[255];
2359 IPTR optcheck = 0;
2360
2361 /* Volume name of installed SYS */
2362 sprintf(varval, "%s:", dest_Path);
2363 SetVar("INSTALLEDSYS", varval, strlen(varval), GVF_GLOBAL_ONLY);
2364
2365 /* Volume name of installed WORK */
2366 GET(check_work, MUIA_Selected, &optcheck);
2367 if (optcheck)
2368 {
2369 sprintf(varval, "%s:", work_Path);
2370 SetVar("INSTALLEDWORK", varval, strlen(varval),
2371 GVF_GLOBAL_ONLY);
2372 }
2373 else
2374 SetVar("INSTALLEDWORK", "", 0, GVF_GLOBAL_ONLY);
2375
2376 /* Path to Extras */
2377 sprintf(varval, "%s:", extras_path);
2378 AddPart(varval, "Extras", 255);
2379 SetVar("INSTALLEDEXTRAS", varval, strlen(varval), GVF_GLOBAL_ONLY);
2380 }
2381
2382
2383 /* STEP : EXECUTE EXTERNAL POST-INSTALL SCRIPT */
2384 if ((BOOL) XGET(data->instc_options_main->opt_copycore, MUIA_Selected))
2385 {
2386 BPTR scriptfile = Open(POST_INSTALL_SCRIPT, MODE_OLDFILE);
2387 if (scriptfile)
2388 {
2389
2390 D(bug("[INSTALLER] Running post-install script...\n"));
2391 SET(data->label, MUIA_Text_Contents,
2392 "Running post-install script...");
2393 SET(data->pageheader, MUIA_Text_Contents, KMsgPostInstall);
2394 SET(data->gauge2, MUIA_Gauge_Current, 0);
2395 SET(data->actioncurrent, MUIA_Text_Contents,
2396 POST_INSTALL_SCRIPT);
2397
2398
2399 /* Post install script (at this momement) does not allow user interaction.
2400 Set SYS_Input to opened console and SYS_Background to FALSE to allow it. */
2401
2402 struct TagItem tags[] = {
2403 {SYS_Input, (IPTR) NULL},
2404 {SYS_Output, (IPTR) NULL},
2405 {SYS_Error, (IPTR) NULL},
2406 {SYS_ScriptInput, (IPTR) scriptfile},
2407 {SYS_UserShell, TRUE},
2408 {TAG_DONE, 0}
2409 };
2410
2411 D(bug("[INSTALLER] execute: %s\n", POST_INSTALL_SCRIPT));
2412
2413 SystemTagList("", tags);
2414
2415 /* Do not close scriptfile. It was closed by SystemTagList */
2416
2417 SET(data->gauge2, MUIA_Gauge_Current, 100);
2418 }
2419 D(
2420 else
2421 bug("[INSTALLER] no post-install script\n"));
2422 }
2423
2424 /* STEP : UNDORECORD CLEANUP */
2425
2426 D(bug
2427 ("[INSTALLER] Reached end of Install Function - cleaning up undo logs @ %p...\n",
2428 &data->instc_undorecord));
2429
2430 struct InstallC_UndoRecord *CurUndoNode = NULL;
2431 struct Node *undonode_tmp = NULL;
2432
2433 ForeachNodeSafe(&data->instc_undorecord, CurUndoNode, undonode_tmp)
2434 {
2435 D(bug("[INSTALLER] Removing undo record @ %p\n", CurUndoNode));
2436 Remove((struct Node *)CurUndoNode);
2437
2438 switch (CurUndoNode->undo_method)
2439 {
2440 case MUIM_IC_CopyFile:
2441 D(bug("[INSTALLER] Deleting undo file '%s'\n",
2442 CurUndoNode->undo_src));
2443 DeleteFile(CurUndoNode->undo_src);
2444
2445 FreeVec(CurUndoNode->undo_dst);
2446 FreeVec(CurUndoNode->undo_src);
2447 break;
2448 default:
2449 continue;
2450 }
2451 FreeMem(CurUndoNode, sizeof(struct InstallC_UndoRecord));
2452 }
2453
2454 return 0;
2455 }
2456
2457 IPTR Install__MUIM_RefreshWindow(Class * CLASS, Object * self, Msg message)
2458 {
2459 struct Install_DATA *data = INST_DATA(CLASS, self);
2460 ULONG cur_width = 0, cur_height = 0;
2461
2462 GET(data->window, MUIA_Window_Width, &cur_width);
2463 GET(data->window, MUIA_Window_Height, &cur_height);
2464
2465 if ((data->cur_width != cur_width) || (data->cur_height != cur_height))
2466 {
2467 DoMethod(data->contents, MUIM_Hide);
2468 DoMethod(data->contents, MUIM_Layout);
2469 DoMethod(data->contents, MUIM_Show);
2470 }
2471 else
2472 MUI_Redraw(data->contents, MADF_DRAWOBJECT);
2473
2474 return 0;
2475 }
2476
2477 static LONG FindWindowsPartition(STRPTR device, LONG unit)
2478 {
2479 IPTR active, id;
2480 struct PartitionType type;
2481 struct PartitionHandle *root, *partition;
2482 LONG partition_no = -1, i = 0;
2483
2484 if ((root = OpenRootPartition(device, unit)) != NULL)
2485 {
2486 if (OpenPartitionTable(root) == 0)
2487 {
2488 /* Look for an active partition with a Windows FS */
2489 ForeachNode(&root->table->list, partition)
2490 {
2491 GetPartitionAttrsTags
2492 (partition,
2493 PT_ACTIVE, (IPTR) & active,
2494 PT_TYPE, (IPTR) & type, TAG_DONE);
2495 id = type.id[0];
2496 if (active && (id == 0x7 || id == 0xb || id == 0xc))
2497 partition_no = i;
2498 i++;
2499 }
2500 ClosePartitionTable(root);
2501 }
2502 CloseRootPartition(root);
2503 }
2504
2505 return partition_no;
2506 }
2507
2508
2509 LONG CopyDirArray(Class * CLASS, Object * self, CONST_STRPTR sourcePath,
2510 CONST_STRPTR destinationPath, CONST_STRPTR directories[])
2511 {
2512 struct Install_DATA *data = INST_DATA(CLASS, self);
2513 LONG numdirs = 0, dir_count = 0;
2514 BPTR lock = 0;
2515
2516 while (directories[numdirs] != NULL)
2517 numdirs++;
2518
2519 numdirs = (numdirs - 1) / 2;
2520
2521 D(bug("[INSTALLER.CDA] Copying %d Dirs...\n", numdirs));
2522
2523 while ((directories[dir_count] != NULL)
2524 && (data->inst_success == MUIV_Inst_InProgress))
2525 {
2526 ULONG newSrcLen =
2527 strlen(sourcePath) + strlen(directories[dir_count]) + 2;
2528 ULONG newDstLen =
2529 strlen(destinationPath) + strlen(directories[dir_count + 1]) +
2530 2;
2531
2532 TEXT srcDirs[newSrcLen + strlen(".info")];
2533 TEXT dstDirs[newDstLen + strlen(".info")];
2534
2535 sprintf(srcDirs, "%s", sourcePath);
2536 sprintf(dstDirs, "%s", destinationPath);
2537 AddPart(srcDirs, directories[dir_count], newSrcLen);
2538 AddPart(dstDirs, directories[dir_count + 1], newDstLen);
2539
2540 SET(data->actioncurrent, MUIA_Text_Contents, strchr(srcDirs,
2541 ':') + 1);
2542
2543 /* OK Now copy the contents */
2544 DoMethod(self, MUIM_IC_CopyFiles, srcDirs, dstDirs, "#?", TRUE);
2545
2546 if (data->inst_success == MUIV_Inst_InProgress)
2547 {
2548 /* Check if folder has an icon */
2549 CopyMem(".info", srcDirs + strlen(srcDirs),
2550 strlen(".info") + 1);
2551 CopyMem(".info", dstDirs + strlen(dstDirs),
2552 strlen(".info") + 1);
2553 /* If the icon already exists in the destination, don't overwrite it.
2554 It may contain snapshotted position and/or edited tooltypes.
2555 TODO: may be consider replacing icon's image here using icon.library ? */
2556 lock = Lock(dstDirs, SHARED_LOCK);
2557 if (!lock)
2558 {
2559 UnLock(lock);
2560 if ((lock = Lock(srcDirs, SHARED_LOCK)) != NULL)
2561 {
2562 UnLock(lock);
2563 DoMethod(self, MUIM_IC_CopyFile, srcDirs, dstDirs);
2564 }
2565 }
2566 }
2567
2568 /* Folder copied */
2569 dir_count += 2;
2570 }
2571
2572 return dir_count / 2; /* Return no. of copied dirs */
2573 }
2574
2575 BOOL FormatPartition(CONST_STRPTR device, CONST_STRPTR name, ULONG dostype)
2576 {
2577 BOOL success = FALSE;
2578
2579 if (Inhibit(device, DOSTRUE))
2580 {
2581 success = Format(device, name, dostype);
2582 Inhibit(device, DOSFALSE);
2583 }
2584
2585 return success;
2586 }
2587
2588 IPTR Install__MUIM_Format(Class * CLASS, Object * self, Msg message)
2589 {
2590 struct Install_DATA *data = INST_DATA(CLASS, self);
2591 char dev_nametmp[100];
2592 char vol_nametmp[100] = SYS_VOL_NAME;
2593 char fmt_nametmp[100];
2594 BOOL success = FALSE;
2595 IPTR option = FALSE;
2596 BPTR lock = NULL;
2597 char tmp[100];
2598
2599 if ((BOOL) XGET(check_formatsys, MUIA_Selected))
2600 {
2601 /* Format Vol0 */
2602 sprintf(fmt_nametmp, "Formatting '%s'...", dest_Path);
2603 D(bug("[INSTALLER] %s\n", fmt_nametmp));
2604 SET(data->label, MUIA_Text_Contents, fmt_nametmp);
2605 SET(data->gauge2, MUIA_Gauge_Current, 0);
2606
2607 /* Change volume name if installing to a USB drive */
2608 GET(grub_device, MUIA_String_Contents, &option);
2609 if (strcmp((char *)option, "usbscsi.device") == 0)
2610 strcpy(vol_nametmp, USB_SYS_VOL_NAME);
2611
2612 sprintf(dev_nametmp, "%s:", dest_Path);
2613
2614 /* XXX HACK
2615 * If partition is FFS -> it will format it for FFS
2616 * If partition is SFS -> it will format it for SFS
2617 * Correct way of doing things: read type for DH0 and DH1, apply correct
2618 * type when formatting
2619 */
2620 D(bug("[INSTALLER] (info) Using FormatPartition\n"));
2621 success =
2622 FormatPartition(dev_nametmp, vol_nametmp, ID_INTER_FFS_DISK);
2623
2624 if (success)
2625 set(data->gauge2, MUIA_Gauge_Current, 100);
2626 }
2627
2628 GET(check_work, MUIA_Selected, &option);
2629 if (option && XGET(check_formatwork, MUIA_Selected))
2630 {
2631 /* Format Vol1 */
2632 sprintf(fmt_nametmp, "Formatting '%s'...", work_Path);
2633 D(bug("[INSTALLER] %s\n", fmt_nametmp));
2634 SET(data->label, MUIA_Text_Contents, fmt_nametmp);
2635
2636 SET(data->gauge2, MUIA_Gauge_Current, 0);
2637
2638 /* Change volume name if installing to a USB drive */
2639 GET(grub_device, MUIA_String_Contents, &option);
2640 if (strcmp((char *)option, "usbscsi.device") == 0)
2641 strcpy(vol_nametmp, USB_WORK_VOL_NAME);
2642 else
2643 strcpy(vol_nametmp, WORK_VOL_NAME);
2644
2645 sprintf(dev_nametmp, "%s:", work_Path);
2646
2647 /* XXX HACK
2648 * If partition is FFS -> it will format it for FFS
2649 * If partition is SFS -> it will format it for SFS
2650 * Correct way of doing things: read type for DH0 and DH1, apply
2651 * correct type when formatting (ID_INTER_FFS_DISK or ID_SFS_BE_DISK)
2652 */
2653 D(bug("[INSTALLER] (info) Using FormatPartition\n"));
2654 success =
2655 FormatPartition(dev_nametmp, vol_nametmp, ID_INTER_FFS_DISK);
2656
2657 if (success)
2658 {
2659 sprintf(tmp, "%s:", work_Path);
2660 SET(data->gauge2, MUIA_Gauge_Current, 100);
2661 lock = Lock(tmp, SHARED_LOCK); /* check the dest dir exists */
2662 if (lock == 0)
2663 {
2664 D(bug
2665 ("[INSTALLER] (Warning) FORMAT: Failed for chosen work partition '%s' : defaulting to sys only\n",
2666 tmp));
2667 extras_path = dest_Path;
2668 }
2669 else
2670 {
2671 UnLock(lock);
2672 lock = 0;
2673 }
2674 }
2675 }
2676 if (success)
2677 SET(data->gauge2, MUIA_Gauge_Current, 100);
2678
2679 return success;
2680 }
2681
2682 BPTR RecursiveCreateDir(CONST_STRPTR dirpath)
2683 {
2684 /* Will create directory even if top level directory does not exist */
2685
2686 BPTR lock = NULL;
2687 ULONG lastdirseparator = 0;
2688 ULONG dirpathlen = strlen(dirpath);
2689 STRPTR tmpdirpath = AllocVec(dirpathlen + 2, MEMF_CLEAR | MEMF_PUBLIC);
2690
2691 CopyMem(dirpath, tmpdirpath, dirpathlen);
2692
2693 /* Recurvice directory creation */
2694 while (TRUE)
2695 {
2696 if (lastdirseparator >= dirpathlen)
2697 break;
2698
2699 for (; lastdirseparator < dirpathlen; lastdirseparator++)
2700 if (tmpdirpath[lastdirseparator] == '/')
2701 break;
2702
2703 tmpdirpath[lastdirseparator] = '\0'; /* cut */
2704
2705 /* Unlock any lock from previous interation. Last iteration lock will be returned. */
2706 if (lock != NULL)
2707 {
2708 UnLock(lock);
2709 lock = NULL;
2710 }
2711
2712 /* Check if directory exists */
2713 lock = Lock(tmpdirpath, SHARED_LOCK);
2714 if (lock == NULL)
2715 {
2716 lock = CreateDir(tmpdirpath);
2717 if (lock == NULL)
2718 break; /* Error with creation */
2719 }
2720
2721 tmpdirpath[lastdirseparator] = '/'; /* restore */
2722 lastdirseparator++;
2723 }
2724
2725 FreeVec(tmpdirpath);
2726 return lock;
2727 }
2728
2729 BOOL BackUpFile(CONST_STRPTR filepath, CONST_STRPTR backuppath,
2730 struct InstallC_UndoRecord * undorecord)
2731 {
2732 ULONG filepathlen = strlen(filepath);
2733 ULONG backuppathlen = strlen(backuppath);
2734 ULONG i = 0;
2735 STRPTR tmp = NULL;
2736 STRPTR pathpart = NULL;
2737 BPTR lock = NULL, from = NULL, to = NULL;
2738 static TEXT buffer[kBufSize];
2739 BOOL err = FALSE;
2740
2741 if (undorecord == NULL)
2742 return FALSE;
2743
2744 undorecord->undo_src =
2745 AllocVec(filepathlen + backuppathlen + 3, MEMF_CLEAR | MEMF_PUBLIC);
2746 undorecord->undo_dst =
2747 AllocVec(filepathlen + 2, MEMF_CLEAR | MEMF_PUBLIC);
2748
2749 /* Create backup file name */
2750 tmp = AllocVec(filepathlen + 2, MEMF_CLEAR | MEMF_PUBLIC);
2751 CopyMem(filepath, tmp, filepathlen);
2752 for (i = 0; i < filepathlen; i++)
2753 if (tmp[i] == ':')
2754 tmp[i] = '/'; /* Substitute : with / */
2755 sprintf(undorecord->undo_src, "%s/%s", backuppath, tmp);
2756 FreeVec(tmp);
2757
2758 /* Create source file name */
2759 CopyMem(filepath, undorecord->undo_dst, filepathlen);
2760
2761 /* Create backup file path */
2762 tmp =
2763 AllocVec(strlen(undorecord->undo_src) + 2,
2764 MEMF_CLEAR | MEMF_PUBLIC);
2765 CopyMem(undorecord->undo_src, tmp, strlen(undorecord->undo_src));
2766 pathpart = PathPart(tmp);
2767 if (pathpart == NULL)
2768 {
2769 FreeVec(tmp);
2770 return FALSE;
2771 }
2772 *pathpart = '\0'; /* 'cut' string at end of path */
2773
2774 D(bug("[INSTALLER.CF] Backup '%s' @ '%s'\n", undorecord->undo_dst,
2775 undorecord->undo_src));
2776
2777 undorecord->undo_method = MUIM_IC_CopyFile;
2778
2779 /* Create backup directory */
2780 if ((lock = Lock(tmp, SHARED_LOCK)) != NULL)
2781 {
2782 D(bug("[INSTALLER.CF] Dir '%s' Exists - no need to create\n", tmp));
2783 UnLock(lock);
2784 }
2785 else
2786 {
2787 lock = RecursiveCreateDir(tmp);
2788 if (lock != NULL)
2789 UnLock(lock);
2790 else
2791 {
2792 D(bug("[INSTALLER.CF] Failed to create %s dir!!\n", tmp));
2793 FreeVec(tmp);
2794 return FALSE;
2795 }
2796 }
2797
2798 FreeVec(tmp);
2799
2800 /* Copy file */
2801 if ((from = Open(undorecord->undo_dst, MODE_OLDFILE)))
2802 {
2803 if ((to = Open(undorecord->undo_src, MODE_NEWFILE)))
2804 {
2805 LONG s = 0;
2806
2807 do
2808 {
2809 if ((s = Read(from, buffer, kBufSize)) == -1)
2810 {
2811 err = TRUE;
2812 break;
2813 };
2814
2815 if (Write(to, buffer, s) == -1)
2816 {
2817 err = TRUE;
2818 break;
2819 };
2820
2821 }
2822 while (s == kBufSize && !err);
2823
2824 Close(to);
2825 }
2826
2827 Close(from);
2828 }
2829
2830 return !err;
2831 }
2832
2833 IPTR Install__MUIM_IC_CopyFile
2834 (Class * CLASS, Object * self, struct MUIP_CopyFile * message)
2835 {
2836 struct Install_DATA *data = INST_DATA(CLASS, self);
2837 static TEXT buffer[kBufSize];
2838 struct InstallC_UndoRecord *undorecord = NULL;
2839 ULONG retry = 0;
2840 ULONG filescopied = 0;
2841 BPTR from = NULL, to = NULL;
2842
2843 /* Display copied file name */
2844 SET(data->actioncurrent, MUIA_Text_Contents, strchr(message->srcFile,
2845 ':') + 1);
2846
2847 DoMethod(data->installer, MUIM_Application_InputBuffered);
2848
2849 /* Check if destination file exists */
2850 if ((to = Open(message->dstFile, MODE_OLDFILE)))
2851 {
2852 /* File exists */
2853 ULONG l;
2854
2855 Close(to);
2856
2857 /* Do not overwrite existing icons and preferences.
2858 TODO: May be ask about it too? */
2859 l = strlen(message->dstFile);
2860 if ((l > 4) && (!stricmp(&message->dstFile[l - 5], ".info")))
2861 {
2862 /* Count the file as copied because otherwise installer will warn that
2863 not everything was copied. */
2864 filescopied = 1;
2865 goto copy_skip;
2866 }
2867 else if ((l > 5) && (!stricmp(&message->dstFile[l - 6], ".prefs")))
2868 {
2869 filescopied = 1;
2870 goto copy_skip;
2871 }
2872 else
2873 {
2874 switch (data->IO_Always_overwrite)
2875 {
2876 case IIO_Overwrite_Ask:
2877 retry =
2878 AskRetry(CLASS, self,
2879 "File Already Exists\nReplace %s?", message->dstFile,
2880 "Yes", "Yes [Always]", "No");
2881 switch (retry)
2882 {
2883 case 0: /* Yes */
2884 goto copy_backup;
2885 case 1: /* Always */
2886 data->IO_Always_overwrite = IIO_Overwrite_Always;
2887 goto copy_backup;
2888 default: /* NO! */
2889 goto copy_skip;
2890 }
2891 case IIO_Overwrite_Always:
2892 goto copy_backup;
2893 case IIO_Overwrite_Never:
2894 goto copy_skip;
2895 }
2896 }
2897 }
2898 else
2899 goto copy_retry;
2900
2901 copy_backup:
2902
2903 /* if the user has requested - backup all replaced files */
2904
2905 if (data->instc_copt_undoenabled)
2906 {
2907 if ((undorecord =
2908 AllocMem(sizeof(struct InstallC_UndoRecord),
2909 MEMF_CLEAR | MEMF_PUBLIC)) == NULL)
2910 DoMethod(self, MUIM_IC_QuitInstall);
2911
2912 if (!BackUpFile(message->dstFile, INSTALLAROS_TMP_PATH, undorecord))
2913 {
2914 data->inst_success = MUIV_Inst_Failed;
2915 return 0;
2916 }
2917 }
2918
2919 /* Main copy code */
2920 copy_retry:
2921
2922 if ((from = Open(message->srcFile, MODE_OLDFILE)))
2923 {
2924 if ((to = Open(message->dstFile, MODE_NEWFILE)))
2925 {
2926 LONG s = 0;
2927
2928 do
2929 {
2930 if ((s = Read(from, buffer, kBufSize)) == -1)
2931 {
2932 D(bug("[INSTALLER.CF] Failed to read: %s [ioerr=%d]\n",
2933 message->srcFile, IoErr()));
2934
2935 Close(to);
2936 Close(from);
2937
2938 retry =
2939 AskRetry(CLASS, self, "Couldn't Open %s",
2940 message->srcFile, "Retry", "Skip", "Cancel");
2941 switch (retry)
2942 {
2943 case 0: /* Retry */
2944 goto copy_retry;
2945 case 1: /*Skip */
2946 goto copy_skip;
2947 default:
2948 DoMethod(self, MUIM_IC_QuitInstall);
2949 goto copy_skip;
2950 }
2951 }
2952
2953 DoMethod(data->installer, MUIM_Application_InputBuffered);
2954
2955 if (Write(to, buffer, s) == -1)
2956 {
2957 D(bug
2958 ("[INSTALLER.CF] Failed to write: %s [%d bytes, ioerr=%d]\n",
2959 message->dstFile, s, IoErr()));
2960
2961 if (IoErr() == 103)
2962 retry =
2963 AskRetry(CLASS, self,
2964 "Couldn't Write to %s\nDisk Full!",
2965 message->dstFile, "Retry", "Skip", "Cancel");
2966 else
2967 retry =
2968 AskRetry(CLASS, self, "Couldn't Write to %s",
2969 message->dstFile, "Retry", "Skip", "Cancel");
2970
2971 Close(to);
2972 Close(from);
2973
2974 switch (retry)
2975 {
2976 case 0: /* Retry */
2977 goto copy_retry;
2978 case 1: /*Skip */
2979 goto copy_skip;
2980 default:
2981 DoMethod(self, MUIM_IC_QuitInstall);
2982 goto copy_skip;
2983 }
2984 }
2985 }
2986 while ((s == kBufSize)
2987 && (data->inst_success == MUIV_Inst_InProgress));
2988
2989 if (data->inst_success == MUIV_Inst_InProgress)
2990 filescopied = 1;
2991
2992 Close(to);
2993 }
2994 else
2995 {
2996 D(bug
2997 ("[INSTALLER.CF] Failed to open '%s' for writing [ioerr=%d]\n",
2998 message->dstFile, IoErr()));
2999 data->inst_success = MUIV_Inst_Failed;
3000 }
3001 Close(from);
3002
3003 copy_skip:
3004 /* Add the undo record */
3005 if (undorecord != NULL)
3006 {
3007 if (filescopied > 0)
3008 {
3009 D(bug
3010 ("[INSTALLER.CF] Adding undo record @ %x to undo list @ %x \n",
3011 undorecord, &data->instc_undorecord));
3012 AddHead(&data->instc_undorecord, (struct Node *)undorecord);
3013 }
3014 else
3015 {
3016 D(bug("[INSTALLER.CF] Freeing undo record\n"));
3017 /* remove the backup file */
3018
3019 DeleteFile(undorecord->undo_src);
3020
3021 /* remove the undo record */
3022 FreeVec(undorecord->undo_dst);
3023 FreeVec(undorecord->undo_src);
3024 FreeMem(undorecord, sizeof(struct InstallC_UndoRecord));
3025 }
3026 }
3027 }
3028 else
3029 {
3030 D(bug("[INSTALLER.CF] Failed to open: %s [ioerr=%d]\n",
3031 message->srcFile, IoErr()));
3032 data->inst_success = MUIV_Inst_Failed;
3033 }
3034
3035 return filescopied;
3036 }
3037
3038 IPTR Install__MUIM_IC_UndoSteps(Class * CLASS, Object * self, Msg message)
3039 {
3040 struct Install_DATA *data = INST_DATA(CLASS, self);
3041 struct InstallC_UndoRecord *CurUndoNode = NULL;
3042
3043 D(bug("[INSTALLER.US] Performing UNDO steps...\n"));
3044
3045 /* Disbale "UNDO" mode to prevent new records */
3046 data->instc_copt_undoenabled = FALSE;
3047
3048 ForeachNode(&data->instc_undorecord, CurUndoNode)
3049 {
3050 D(bug("[INSTALLER.US] Removing undo record @ %x\n", CurUndoNode));
3051 Remove((struct Node *)CurUndoNode);
3052
3053 switch (CurUndoNode->undo_method)
3054 {
3055 case MUIM_IC_CopyFile:
3056 D(bug("[INSTALLER.US] Reverting file '%s'\n",
3057 CurUndoNode->undo_dst));
3058
3059 DoMethod(self, CurUndoNode->undo_method, CurUndoNode->undo_src,
3060 CurUndoNode->undo_dst);
3061
3062 D(bug("[INSTALLER.US] Deleting undo file '%s'\n",
3063 CurUndoNode->undo_src));
3064 DeleteFile(CurUndoNode->undo_src);
3065
3066 FreeVec(CurUndoNode->undo_dst);
3067 FreeVec(CurUndoNode->undo_src);
3068 break;
3069 default:
3070 continue;
3071 }
3072 FreeMem(CurUndoNode, sizeof(struct InstallC_UndoRecord));
3073 }
3074
3075 D(bug("[INSTALLER.US] UNDO complete\n"));
3076
3077 return 0;
3078 }
3079
3080 IPTR Install__MUIM_Reboot(Class * CLASS, Object * self, Msg message)
3081 {
3082 struct Install_DATA *data = INST_DATA(CLASS, self);
3083
3084 IPTR option = FALSE;
3085
3086 /* Make sure the user wants to reboot */
3087 GET(data->instc_options_main->opt_reboot, MUIA_Selected, &option);
3088 if (option && (data->inst_success == MUIV_Inst_InProgress))
3089 {
3090 D(bug("[INSTALLER] Cold rebooting...\n"));
3091 ShutdownA(SD_ACTION_COLDREBOOT);
3092 }
3093 else
3094 {
3095 D(bug("[INSTALLER] Install Finished [no reboot]...\n"));
3096 if (data->inst_success == MUIV_Inst_InProgress)
3097 data->inst_success = MUIV_Inst_Completed;
3098 SET(data->window, MUIA_Window_CloseRequest, TRUE);
3099 }
3100
3101 return TRUE; /* Keep the compiler happy... */
3102 }
3103
3104 IPTR Install__OM_SET(Class * CLASS, Object * self, struct opSet * message)
3105 {
3106 return DoSuperMethodA(CLASS, self, (Msg) message);
3107 }
3108
3109 BOOPSI_DISPATCHER(IPTR, Install_Dispatcher, CLASS, self, message)
3110 {
3111 switch (message->MethodID)
3112 {
3113 case OM_NEW:
3114 return Install__OM_NEW(CLASS, self, (struct opSet *)message);
3115
3116 case OM_SET:
3117 return Install__OM_SET(CLASS, self, (struct opSet *)message);
3118
3119 case MUIM_FindDrives:
3120 return Install__MUIM_FindDrives(CLASS, self, message);
3121
3122 case MUIM_IC_NextStep:
3123 return Install__MUIM_IC_NextStep(CLASS, self, message);
3124
3125 case MUIM_IC_PrevStep:
3126 return Install__MUIM_IC_PrevStep(CLASS, self, message);
3127 //cancel control methods
3128 case MUIM_IC_CancelInstall:
3129 return Install__MUIM_IC_CancelInstall(CLASS, self, message);
3130
3131 case MUIM_IC_ContinueInstall:
3132 return Install__MUIM_IC_ContinueInstall(CLASS, self, message);
3133
3134 case MUIM_IC_QuitInstall:
3135 return Install__MUIM_IC_QuitInstall(CLASS, self, message);
3136
3137 case MUIM_Reboot:
3138 return Install__MUIM_Reboot(CLASS, self, message);
3139
3140 //This should disappear
3141 case MUIM_RefreshWindow:
3142 return Install__MUIM_RefreshWindow(CLASS, self, message);
3143
3144 case MUIM_IC_Install:
3145 return Install__MUIM_IC_Install(CLASS, self, message);
3146
3147 //These will be consumed by the io task
3148 case MUIM_Partition:
3149 return Install__MUIM_Partition(CLASS, self, message);
3150
3151 case MUIM_Format:
3152 return Install__MUIM_Format(CLASS, self, message);
3153
3154 case MUIM_IC_CopyFiles:
3155 return Install__MUIM_IC_CopyFiles(CLASS, self,
3156 (struct MUIP_CopyFiles *)message);
3157
3158 case MUIM_IC_CopyFile:
3159 return Install__MUIM_IC_CopyFile(CLASS, self,
3160 (struct MUIP_CopyFile *)message);
3161
3162 case MUIM_IC_UndoSteps:
3163 return Install__MUIM_IC_UndoSteps(CLASS, self, message);
3164
3165 default:
3166 return DoSuperMethodA(CLASS, self, message);
3167 }
3168
3169 return 0;
3170 }
3171
3172 BOOPSI_DISPATCHER_END void FindBootLoader(void)
3173 {
3174 ULONG newSrcLen = strlen(source_Path) + BOOTLOADER_PATH_LEN;
3175 TEXT srcFile[newSrcLen];
3176 LONG i;
3177 BPTR lock;
3178
3179 for (i = 0; BootLoaderFiles[i]; i++)
3180 {
3181 strcpy(srcFile, source_Path);
3182 AddPart(srcFile, BootLoaderFiles[i], newSrcLen);
3183 lock = Lock(srcFile, ACCESS_READ);
3184 if (lock)
3185 {
3186 UnLock(lock);
3187 BootLoaderType = i;
3188 return;
3189 }
3190 }
3191 BootLoaderType = BOOTLOADER_NONE;
3192 }
3193
3194 int main(int argc, char *argv[])
3195 {
3196 Object *wnd = NULL; /* installer window objects - will get swallowed into the class eventually */
3197 Object *wndcontents = NULL;
3198 Object *page = NULL;
3199
3200 Object *welcomeMsg = NULL;
3201 Object *LicenseMsg = NULL;
3202 Object *doneMsg = NULL;
3203
3204 Object *pagetitle = NULL;
3205 Object *pageheader = NULL;
3206 Object *currentaction = NULL;
3207
3208 Object *radio_part = NULL;
3209
3210 Object *gad_back = SimpleButton("<< _Back...");
3211 Object *gad_proceed = SimpleButton(KMsgProceed);
3212 Object *gad_cancel = SimpleButton("_Cancel");
3213
3214 Object *grub_drive = NULL;
3215 Object *grub_grub = NULL;
3216
3217 Object *LicenseMandGrp = NULL;
3218 Object *check_license =
3219 ImageObject, ImageButtonFrame, MUIA_InputMode,
3220 MUIV_InputMode_Toggle, MUIA_Image_Spec, MUII_CheckMark,
3221 MUIA_Image_FreeVert, TRUE, MUIA_Background, MUII_ButtonBack,
3222 MUIA_ShowSelState, FALSE, MUIA_Selected, FALSE, End;
3223
3224 Object *check_format =
3225 ImageObject, ImageButtonFrame, MUIA_InputMode,
3226 MUIV_InputMode_Toggle, MUIA_Image_Spec, MUII_CheckMark,
3227 MUIA_Image_FreeVert, TRUE, MUIA_Background, MUII_ButtonBack,
3228 MUIA_ShowSelState, FALSE, MUIA_Selected, TRUE, End;
3229 Object *check_locale =
3230 ImageObject, ImageButtonFrame, MUIA_InputMode,
3231 MUIV_InputMode_Toggle, MUIA_Image_Spec, MUII_CheckMark,
3232 MUIA_Image_FreeVert, TRUE, MUIA_Background, MUII_ButtonBack,
3233 MUIA_ShowSelState, FALSE, MUIA_Selected, FALSE, End;
3234 Object *check_core =
3235 ImageObject, ImageButtonFrame, MUIA_InputMode,
3236 MUIV_InputMode_Toggle, MUIA_Image_Spec, MUII_CheckMark,
3237 MUIA_Image_FreeVert, TRUE, MUIA_Background, MUII_ButtonBack,
3238 MUIA_ShowSelState, FALSE, MUIA_Selected, TRUE, End;
3239 Object *check_dev =
3240 ImageObject, ImageButtonFrame, MUIA_InputMode,
3241 MUIV_InputMode_Toggle, MUIA_Image_Spec, MUII_CheckMark,
3242 MUIA_Image_FreeVert, TRUE, MUIA_Background, MUII_ButtonBack,
3243 MUIA_ShowSelState, FALSE, MUIA_Selected, FALSE, End;
3244 Object *check_extras =
3245 ImageObject, ImageButtonFrame, MUIA_InputMode,
3246 MUIV_InputMode_Toggle, MUIA_Image_Spec, MUII_CheckMark,
3247 MUIA_Image_FreeVert, TRUE, MUIA_Background, MUII_ButtonBack,
3248 MUIA_ShowSelState, FALSE, MUIA_Selected, TRUE, End;
3249 Object *check_bootloader;
3250
3251 Object *check_reboot =
3252 ImageObject, ImageButtonFrame, MUIA_InputMode,
3253 MUIV_InputMode_Toggle, MUIA_Image_Spec, MUII_CheckMark,
3254 MUIA_Image_FreeVert, TRUE, MUIA_Background, MUII_ButtonBack,
3255 MUIA_ShowSelState, FALSE, End;
3256
3257 Object *gauge1 =
3258 (GaugeObject, MUIA_Gauge_InfoText, "%ld %%", MUIA_Gauge_Horiz, TRUE,
3259 MUIA_Gauge_Current, 0, End);
3260 Object *gauge2 =
3261 (GaugeObject, MUIA_Gauge_InfoText, "%ld %%", MUIA_Gauge_Horiz, TRUE,
3262 MUIA_Gauge_Current, 0, End);
3263 Object *gauge3 =
3264 (GaugeObject, MUIA_Gauge_InfoText, "%ld %%", MUIA_Gauge_Horiz, TRUE,
3265 MUIA_Gauge_Current, 0, End);
3266
3267 static char *opt_drivetypes[] = {
3268 "IDE/SATA",
3269 "USB",
3270 NULL
3271 };
3272
3273 Object *label = NULL;
3274 static char *opt_partentries[] = {
3275 "Only use free space",
3276 "Wipe disk",
3277 "Use existing AROS partitions (on any drive)",
3278 NULL
3279 };
3280 struct Install_Options *install_opts = NULL;
3281 struct Grub_Options *grub_opts = NULL;
3282 char *source_path = NULL;
3283 char *dest_path = NULL;
3284 char *work_path = NULL;
3285
3286 IPTR pathend = 0;
3287
3288 check_copytowork =
3289 ImageObject, ImageButtonFrame, MUIA_InputMode,
3290 MUIV_InputMode_Toggle, MUIA_Image_Spec, MUII_CheckMark,
3291 MUIA_Image_FreeVert, TRUE, MUIA_Background, MUII_ButtonBack,
3292 MUIA_ShowSelState, FALSE, MUIA_Disabled, TRUE, End;
3293 check_work =
3294 ImageObject, ImageButtonFrame, MUIA_InputMode,
3295 MUIV_InputMode_Toggle, MUIA_Image_Spec, MUII_CheckMark,
3296 MUIA_Image_FreeVert, TRUE, MUIA_Background, MUII_ButtonBack,
3297 MUIA_ShowSelState, FALSE, MUIA_Selected, FALSE, End;
3298 check_formatsys =
3299 ImageObject, ImageButtonFrame, MUIA_InputMode,
3300 MUIV_InputMode_Toggle, MUIA_Image_Spec, MUII_CheckMark,
3301 MUIA_Image_FreeVert, TRUE, MUIA_Background, MUII_ButtonBack,
3302 MUIA_ShowSelState, FALSE, MUIA_Selected, TRUE, End;
3303 check_formatwork =
3304 ImageObject, ImageButtonFrame, MUIA_InputMode,
3305 MUIV_InputMode_Toggle, MUIA_Image_Spec, MUII_CheckMark,
3306 MUIA_Image_FreeVert, TRUE, MUIA_Background, MUII_ButtonBack,
3307 MUIA_ShowSelState, FALSE, MUIA_Disabled, TRUE, End;
3308
3309 check_sizesys = ImageObject, ImageButtonFrame, MUIA_InputMode,
3310 MUIV_InputMode_Toggle, MUIA_Image_Spec, MUII_CheckMark,
3311 MUIA_Image_FreeVert, TRUE, MUIA_Background, MUII_ButtonBack,
3312 MUIA_ShowSelState, FALSE, MUIA_Selected, FALSE, End;
3313 check_sizework = ImageObject, ImageButtonFrame, MUIA_InputMode,
3314 MUIV_InputMode_Toggle, MUIA_Image_Spec, MUII_CheckMark,
3315 MUIA_Image_FreeVert, TRUE, MUIA_Background, MUII_ButtonBack,
3316 MUIA_ShowSelState, FALSE, MUIA_Selected, FALSE, MUIA_Disabled, TRUE,
3317 End;
3318 check_creatework = ImageObject, ImageButtonFrame, MUIA_InputMode,
3319 MUIV_InputMode_Toggle, MUIA_Image_Spec, MUII_CheckMark,
3320 MUIA_Image_FreeVert, TRUE, MUIA_Background, MUII_ButtonBack,
3321 MUIA_ShowSelState, FALSE, MUIA_Selected, FALSE, MUIA_Disabled, TRUE,
3322 End;
3323
3324 static char *opt_fstypes[] = {
3325 "FFS-Intl",
3326 "SFS",
3327 NULL
3328 };
3329
3330 cycle_fstypework =
3331 CycleObject, MUIA_Cycle_Entries, opt_fstypes, MUIA_Disabled, TRUE,
3332 MUIA_Cycle_Active, 1, End;
3333
3334 static char *opt_sizeunits[] = {
3335 "MB",
3336 "GB",
3337 NULL
3338 };
3339
3340 cycle_sysunits =
3341 CycleObject, MUIA_Cycle_Entries, opt_sizeunits, MUIA_Disabled, TRUE,
3342 MUIA_Cycle_Active, 1, End;
3343 cycle_workunits =
3344 CycleObject, MUIA_Cycle_Entries, opt_sizeunits, MUIA_Disabled, TRUE,
3345 MUIA_Cycle_Active, 1, End;
3346
3347 static char *opt_grub2mode[] = {
3348 "Text",
3349 "Graphics",
3350 NULL
3351 };
3352
3353 Object *cycle_grub2mode =
3354 CycleObject, MUIA_Cycle_Entries, opt_grub2mode, MUIA_Disabled,
3355 FALSE, MUIA_Cycle_Active, 0, End;
3356
3357 install_opts =
3358 AllocMem(sizeof(struct Install_Options), MEMF_CLEAR | MEMF_PUBLIC);
3359 grub_opts =
3360 AllocMem(sizeof(struct Grub_Options), MEMF_CLEAR | MEMF_PUBLIC);
3361 source_path = AllocVec(256, MEMF_CLEAR | MEMF_PUBLIC);
3362 extras_source = AllocVec(256, MEMF_CLEAR | MEMF_PUBLIC);
3363
3364 dest_path = AllocVec(256, MEMF_CLEAR | MEMF_PUBLIC);
3365 work_path = AllocVec(256, MEMF_CLEAR | MEMF_PUBLIC);
3366
3367 BPTR lock = 0;
3368
3369 if (!(ExpansionBase =
3370 (struct ExpansionBase *)OpenLibrary("expansion.library", 0)))
3371 goto main_error;
3372
3373 if (!NameFromLock(GetProgramDir(), source_path, 255))
3374 {
3375 D(bug("[INST-APP] Couldn't get progdir\n"));
3376 goto main_error;
3377 }
3378 pathend = (IPTR) FilePart(source_path);
3379 pathend = pathend - (IPTR) source_path;
3380
3381 D(bug("[INST-APP] Path length = %d bytes\n", pathend));
3382
3383 source_Path = AllocVec(pathend + 1, MEMF_CLEAR | MEMF_PUBLIC);
3384 CopyMem(source_path, source_Path, pathend);
3385 D(bug("[INST-APP] Launched from '%s'\n", source_Path));
3386 FreeVec(source_path);
3387
3388 /* Get source location for Extras dir */
3389 if (read_environment_variable(source_Path, "EXTRASPATH", extras_source,
3390 256))
3391 *PathPart(extras_source) = '\0';
3392 else
3393 strcpy(extras_source, source_Path);
3394
3395 dest_Path = dest_path;
3396 sprintf(dest_Path, "" SYS_PART_NAME);
3397
3398 work_Path = work_path;
3399 sprintf(work_Path, "" WORK_PART_NAME);
3400
3401 FindBootLoader();
3402 cycle_fstypesys =
3403 CycleObject, MUIA_Cycle_Entries, opt_fstypes, MUIA_Disabled, FALSE,
3404 MUIA_Cycle_Active, BootLoaderType == BOOTLOADER_GRUB1 ? 0 : 1, End;
3405 check_bootloader =
3406 ImageObject, ImageButtonFrame, MUIA_InputMode,
3407 MUIV_InputMode_Toggle, MUIA_Image_Spec, MUII_CheckMark,
3408 MUIA_Image_FreeVert, TRUE, MUIA_Background, MUII_ButtonBack,
3409 MUIA_ShowSelState, FALSE, MUIA_Selected,
3410 BootLoaderType == BOOTLOADER_NONE ? FALSE : TRUE, MUIA_Disabled,
3411 BootLoaderType == BOOTLOADER_NONE ? TRUE : FALSE, End;
3412
3413 lock = Lock(DEF_INSTALL_IMAGE, ACCESS_READ);
3414 UnLock(lock);
3415
3416 LicenseMsg = MUI_NewObject(MUIC_TextEditor,
3417 MUIA_Background, MUII_SHINE,
3418 MUIA_TextEditor_ReadOnly, TRUE, TAG_DONE);
3419
3420 if (!LicenseMsg)
3421 {
3422 D(bug("[INST-APP] Failed to create LicenseMsg Object\n"));
3423 exit(5);
3424 }
3425
3426 Object *app = ApplicationObject,
3427 MUIA_Application_Title, (IPTR) "AROS Installer",
3428 MUIA_Application_Version, (IPTR) "$VER: InstallAROS 1.12 (16.12.2011)",
3429 MUIA_Application_Copyright, (IPTR) "Copyright © 2003-2011, The AROS Development Team. All rights reserved.",
3430 MUIA_Application_Author, (IPTR) "John \"Forgoil\" Gustafsson, Nic Andrews & Neil Cafferkey",
3431 MUIA_Application_Description, (IPTR) "Installs AROS on to a PC.",
3432 MUIA_Application_Base, (IPTR) "INSTALLER",
3433
3434 SubWindow, (IPTR) (wnd = WindowObject,
3435 MUIA_Window_Title, (IPTR) "AROS Installer",
3436 MUIA_Window_ID, MAKE_ID('f','o','r','g'),
3437 MUIA_Window_SizeGadget, TRUE,
3438 WindowContents, (IPTR) (wndcontents = VGroup,
3439
3440 Child, (IPTR) VGroup,
3441 Child, (IPTR) HGroup,
3442 Child, (IPTR) VGroup,
3443 MUIA_Background, MUII_SHADOW,
3444
3445 Child, (IPTR) ImageObject,
3446 MUIA_Frame, MUIV_Frame_None,
3447 MUIA_Image_Spec, (IPTR) "3:"DEF_INSTALL_IMAGE,
3448 End,
3449 Child, (IPTR) HVSpace,
3450 End,
3451
3452 Child, (IPTR) ScrollgroupObject,
3453 MUIA_Scrollgroup_FreeHoriz, FALSE,
3454 MUIA_Scrollgroup_FreeVert, TRUE,
3455 MUIA_Scrollgroup_Contents, (IPTR) (page = VGroup,
3456 MUIA_Group_PageMode, TRUE,
3457 ReadListFrame,
3458
3459 /* each page represents an install time page... you must have one for each enumerated install progress page */
3460
3461 Child, (IPTR) VGroup,
3462 Child, (IPTR) VGroup,
3463 Child, (IPTR) (welcomeMsg = FreeCLabel("")),
3464 Child, (IPTR) HVSpace,
3465 End,
3466 End,
3467
3468 Child, (IPTR) VGroup,
3469 Child, (IPTR) VGroup,
3470 Child, (IPTR) LicenseMsg,
3471 Child, (IPTR) (LicenseMandGrp = HGroup,
3472 Child, (IPTR) HVSpace,
3473 Child, (IPTR) check_license,
3474 Child, (IPTR) LLabel("Accept License Agreement?"),
3475 Child, (IPTR) HVSpace,
3476 End),
3477 End,
3478 End,
3479
3480 /* Partitioning options */
3481 Child, (IPTR) VGroup,
3482 Child, (IPTR) VGroup,
3483 Child, (IPTR) CLabel(KMsgPartitionOptions),
3484 Child, (IPTR) HVSpace,
3485
3486 Child, (IPTR) HVSpace,
3487 Child, (IPTR) (radio_part = RadioObject,
3488 GroupFrame,
3489 MUIA_Radio_Entries, (IPTR) opt_partentries,
3490 End),
3491
3492 Child, (IPTR) HVSpace,
3493
3494 Child, (IPTR) LLabel(MUIX_B "Drive:" MUIX_N),
3495 Child, (IPTR) ColGroup(6),
3496 Child, (IPTR) LLabel("Type:"),
3497 Child, (IPTR) (cycle_drivetype =
3498 CycleObject,
3499 MUIA_Cycle_Entries, (IPTR) opt_drivetypes,
3500 MUIA_Cycle_Active, 0,
3501 End),
3502 Child, (IPTR) HVSpace,
3503 Child, (IPTR) LLabel("Device:"),
3504 Child, (IPTR) (dest_device =
3505 StringObject,
3506 MUIA_String_Contents, (IPTR) boot_Device,
3507 MUIA_String_Reject, " \"\'*",
3508 MUIA_Frame, MUIV_Frame_String,
3509 MUIA_HorizWeight, 300,
3510 End),
3511 Child, (IPTR) LLabel("Unit:"),
3512 Child, (IPTR) (dest_unit =
3513 StringObject,
3514 MUIA_String_Integer, 0,
3515 MUIA_String_Accept, "0123456789",
3516 MUIA_Frame, MUIV_Frame_String,
3517 MUIA_HorizWeight, 20,
3518 End),
3519 End,
3520
3521 Child, (IPTR) HVSpace,
3522
3523 Child, (IPTR) LLabel(KMsgDestPartition),
3524 Child, (IPTR) ColGroup(7),
3525 Child, (IPTR) LLabel("Name:"),
3526 Child, (IPTR) (sys_devname = StringObject,
3527 MUIA_String_Contents, SYS_PART_NAME,
3528 MUIA_Disabled, TRUE,
3529 MUIA_Frame, MUIV_Frame_String,
3530 End),
3531 Child, (IPTR) HVSpace,
3532 Child, (IPTR) HVSpace,
3533 Child, (IPTR) HVSpace,
3534 Child, (IPTR) HVSpace,
3535 Child, (IPTR) HVSpace,
3536 Child, (IPTR) LLabel("Filesystem:"),
3537 Child, (IPTR) cycle_fstypesys,
3538 Child, (IPTR) LLabel("Size:"),
3539 Child, (IPTR) (sys_size = StringObject,
3540 MUIA_String_Accept, "0123456789",
3541 MUIA_String_Integer, 0,
3542 MUIA_Disabled, TRUE,
3543 MUIA_Frame, MUIV_Frame_String,
3544 End),
3545 Child, (IPTR) cycle_sysunits,
3546 Child, (IPTR) check_sizesys,
3547 Child, (IPTR) LLabel("Specify Size"),
3548 End,
3549
3550 Child, (IPTR) HVSpace,
3551
3552 Child, (IPTR) LLabel(KMsgWorkPartition),
3553 Child, (IPTR) ColGroup(7),
3554 Child, (IPTR) LLabel("Name:"),
3555 Child, (IPTR) (work_devname = StringObject,
3556 MUIA_String_Contents, WORK_PART_NAME,
3557 MUIA_Disabled, TRUE,
3558 MUIA_Frame, MUIV_Frame_String,
3559 End),
3560 Child, (IPTR) HVSpace,
3561 Child, (IPTR) HVSpace,
3562 Child, (IPTR) HVSpace,
3563 Child, (IPTR) check_creatework,
3564 Child, (IPTR) LLabel("Create"),
3565 Child, (IPTR) LLabel("Filesystem:"),
3566 Child, (IPTR) cycle_fstypework,
3567 Child, (IPTR) LLabel("Size:"),
3568 Child, (IPTR) (work_size = StringObject,
3569 MUIA_String_Accept, "0123456789",
3570 MUIA_String_Integer, 0,
3571 MUIA_Disabled, TRUE,
3572 MUIA_Frame, MUIV_Frame_String,
3573 End),
3574 Child, (IPTR) cycle_workunits,
3575 Child, (IPTR) check_sizework,
3576 Child, (IPTR) LLabel("Specify Size"),
3577 End,
3578 End,
3579 End,
3580
3581 Child, (IPTR) VGroup,
3582 Child, (IPTR) VGroup,
3583 Child, (IPTR) CLabel(KMsgInstallOptions),
3584 Child, (IPTR) HVSpace,
3585 Child, (IPTR) ColGroup(2),
3586 Child, (IPTR) check_locale,
3587 Child, (IPTR) LLabel("Choose Language Options"),
3588 Child, (IPTR) check_core,
3589 Child, (IPTR) LLabel("Install AROS Core System"),
3590 Child, (IPTR) check_extras,
3591 Child, (IPTR) LLabel("Install Extra Software"),
3592 Child, (IPTR) check_dev,
3593 Child, (IPTR) LLabel("Install Development Software"),
3594 Child, (IPTR) check_bootloader,
3595 Child, (IPTR) LLabel("Install Bootloader"),
3596 End,
3597 Child, (IPTR) HVSpace,
3598 End,
3599 End,
3600
3601 Child, (IPTR) VGroup,
3602 Child, (IPTR) VGroup,
3603 Child, (IPTR) CLabel(KMsgDestOptions),
3604 Child, (IPTR) HVSpace,
3605 Child, (IPTR) ColGroup(2),
3606 Child, (IPTR) ColGroup(2),
3607 Child, (IPTR) LLabel(KMsgDestVolume),
3608 Child, (IPTR) HVSpace,
3609 End,
3610 Child, (IPTR) (show_formatsys = ColGroup(2),
3611 Child, (IPTR) check_formatsys,
3612 Child, (IPTR) LLabel("Format Partition"),
3613 End),
3614 End,
3615 Child, (IPTR) HVSpace,
3616 Child, (IPTR) (dest_volume = StringObject,
3617 MUIA_String_Contents, (IPTR) dest_Path,
3618 MUIA_Frame, MUIV_Frame_String,
3619 End),
3620 Child, (IPTR) HVSpace,
3621 Child, (IPTR) ColGroup(2),
3622 Child, (IPTR) check_work,
3623 Child, (IPTR) LLabel("Use 'Work' Partition"),
3624 Child, (IPTR) check_copytowork,
3625 Child, (IPTR) LLabel("Use 'Work' Partition for Extras and Developer Files"),
3626 End,
3627 Child, (IPTR) HVSpace,
3628
3629 Child, (IPTR) ColGroup(2),
3630 Child, (IPTR) ColGroup(2),
3631 Child, (IPTR) LLabel(KMsgWorkVolume),
3632 Child, (IPTR) HVSpace,
3633 End,
3634 Child, (IPTR) (show_formatwork = ColGroup(2),
3635 Child, (IPTR) check_formatwork,
3636 Child, (IPTR) LLabel("Format Partition"),
3637 End),
3638 End,
3639 Child, (IPTR) HVSpace,
3640 Child, (IPTR) (work_volume =
3641 StringObject,
3642 MUIA_String_Contents,
3643 (IPTR) work_Path,
3644 MUIA_Disabled, TRUE,
3645 MUIA_Frame, MUIV_Frame_String,
3646 End),
3647 Child, (IPTR) HVSpace,
3648 End,
3649 End,
3650
3651 /* Bootloader options */
3652 Child, (IPTR) VGroup,
3653 Child, (IPTR) VGroup,
3654 Child, (IPTR) CLabel(KMsgGrubOptions),
3655 Child, (IPTR) HVSpace,
3656 Child, (IPTR) LLabel(KMsgGrubGOptions),
3657 Child, (IPTR) LLabel(KMsgGrubDrive),
3658 Child, (IPTR) HVSpace,
3659
3660 Child, (IPTR) ColGroup(5),
3661 Child, (IPTR) HVSpace,
3662 Child, (IPTR) LLabel("Device:"),
3663 Child, (IPTR) (grub_device =
3664 StringObject,
3665 MUIA_String_Reject, " \"\'*",
3666 MUIA_Frame, MUIV_Frame_String,
3667 MUIA_HorizWeight, 200,
3668 End),
3669 Child, (IPTR) HVSpace,
3670 Child, (IPTR) LLabel("Unit:"),
3671 Child, (IPTR) (grub_unit =
3672 StringObject,
3673 MUIA_String_Integer, 0,
3674 MUIA_String_Accept, "0123456789",
3675 MUIA_Frame, MUIV_Frame_String,
3676 MUIA_HorizWeight, 20,
3677 End),
3678 End,
3679
3680 Child, (IPTR) (grub_drive = TextObject, MUIA_Text_PreParse, (IPTR) "" MUIX_C, MUIA_Text_Contents, (IPTR)" ",End),
3681 Child, (IPTR) HVSpace,
3682 Child, (IPTR) LLabel(KMsgGrubGrub),
3683 Child, (IPTR) HVSpace,
3684 Child, (IPTR) (grub_grub = TextObject, MUIA_Text_PreParse, (IPTR) "" MUIX_C, MUIA_Text_Contents, (IPTR)" ",End),
3685 Child, (IPTR) HVSpace,
3686 Child, (IPTR) ColGroup(4),
3687 Child, (IPTR) LLabel("Menu Mode:"),
3688 Child, (IPTR) cycle_grub2mode,
3689 Child, (IPTR) HVSpace,
3690 End,
3691 Child, (IPTR) HVSpace,
3692 End,
3693 End,
3694
3695 Child, (IPTR) VGroup,
3696 Child, (IPTR) VGroup,
3697 Child, (IPTR) CLabel(KMsgPartitioning),
3698 Child, (IPTR) HVSpace,
3699 Child, (IPTR) VGroup, GaugeFrame,MUIA_Background, MUII_HSHINEBACK, Child, gauge1, End,
3700 Child, (IPTR) ScaleObject, End,
3701 Child, (IPTR) HVSpace,
3702 End,
3703 End,
3704
3705 Child, (IPTR) VGroup,
3706 Child, (IPTR) VGroup,
3707 Child, (IPTR) CLabel(KMsgPartitioning),
3708 Child, (IPTR) HVSpace,
3709 Child, (IPTR) VGroup, GaugeFrame,MUIA_Background, MUII_HSHINEBACK, Child, (IPTR) gauge3, End,
3710 Child, (IPTR) ScaleObject, End,
3711 Child, (IPTR) HVSpace,
3712 End,
3713 End,
3714
3715 Child, (IPTR) VGroup,
3716 Child, (IPTR) VGroup,
3717 Child, (IPTR) (pagetitle = CLabel(" ")),
3718 Child, (IPTR) HVSpace,
3719 Child, (IPTR) (pageheader = FreeCLabel(KMsgInstall)),
3720 Child, (IPTR) HVSpace,
3721 Child, (IPTR) (label = FreeLLabel("YOU SHOULD NOT SEE THIS")),
3722 Child, (IPTR) HVSpace,
3723 Child, (IPTR) (currentaction = TextObject,MUIA_Text_Contents,(IPTR)" ",End),
3724 Child, (IPTR) VGroup, GaugeFrame,MUIA_Background, MUII_HSHINEBACK, Child, gauge2, End,
3725 Child, (IPTR) HVSpace,
3726 End,
3727 End,
3728
3729 /* Completed page */
3730 Child, (IPTR) VGroup,
3731 Child, (IPTR) VGroup,
3732 MUIA_Group_SameHeight, FALSE,
3733 Child, (IPTR) (doneMsg = FreeCLabel(KMsgDone)),
3734 Child, (IPTR) HVSpace,
3735 Child, (IPTR) (reboot_group = ColGroup(2),
3736 MUIA_Weight,0,
3737 MUIA_ShowMe, FALSE,
3738 Child, (IPTR) check_reboot,
3739 Child, (IPTR) LLabel("Reboot AROS now"),
3740 End),
3741 End,
3742 End,
3743 End),
3744 End,
3745 End,
3746 End,
3747
3748 Child, (IPTR) HGroup,
3749 Child, (IPTR) HVSpace,
3750 Child, (IPTR) gad_back,
3751 Child, (IPTR) gad_proceed,
3752 Child, (IPTR) gad_cancel,
3753 End,
3754 End),
3755 End),
3756
3757 End;
3758
3759 if (!app)
3760 {
3761 D(bug("[INST-APP] Failed to create Installer GUI\n"));
3762 exit(5);
3763 }
3764
3765 /* Update GUI in response to certain user actions */
3766
3767 /* Notifications on partitioning action */
3768 DoMethod(radio_part, MUIM_Notify, (IPTR) MUIA_Radio_Active, 0,
3769 (IPTR) check_sizesys, 3, MUIM_Set, MUIA_Disabled, FALSE);
3770 DoMethod(radio_part, MUIM_Notify, (IPTR) MUIA_Radio_Active, 1,
3771 (IPTR) check_sizesys, 3, MUIM_Set, MUIA_Disabled, FALSE);
3772 DoMethod(radio_part, MUIM_Notify, (IPTR) MUIA_Radio_Active, 2,
3773 (IPTR) check_sizesys, 3, MUIM_Set, MUIA_Disabled, TRUE);
3774 DoMethod(radio_part, MUIM_Notify, (IPTR) MUIA_Radio_Active, 2,
3775 (IPTR) check_sizesys, 3, MUIM_Set, MUIA_Selected, FALSE);
3776
3777 /* Notifications upon selection of drive type */
3778 DoMethod(cycle_drivetype, MUIM_Notify, (IPTR) MUIA_Cycle_Active, 0,
3779 (IPTR) dest_device, 3, MUIM_Set,
3780 MUIA_String_Contents, "ata.device");
3781 DoMethod(cycle_drivetype, MUIM_Notify, (IPTR) MUIA_Cycle_Active, 1,
3782 (IPTR) dest_device, 3, MUIM_Set,
3783 MUIA_String_Contents, "usbscsi.device");
3784 DoMethod(cycle_drivetype, MUIM_Notify, MUIA_Cycle_Active,
3785 MUIV_EveryTime, (IPTR) dest_unit, 3, MUIM_Set, MUIA_String_Integer,
3786 0);
3787 DoMethod(cycle_drivetype, MUIM_Notify, (IPTR) MUIA_Cycle_Active, 0,
3788 (IPTR) sys_devname, 3, MUIM_Set, MUIA_String_Contents,
3789 SYS_PART_NAME);
3790 DoMethod(cycle_drivetype, MUIM_Notify, (IPTR) MUIA_Cycle_Active, 1,
3791 (IPTR) sys_devname, 3, MUIM_Set, MUIA_String_Contents,
3792 USB_SYS_PART_NAME);
3793 DoMethod(cycle_drivetype, MUIM_Notify, (IPTR) MUIA_Cycle_Active, 0,
3794 (IPTR) work_devname, 3, MUIM_Set, MUIA_String_Contents,
3795 WORK_PART_NAME);
3796 DoMethod(cycle_drivetype, MUIM_Notify, (IPTR) MUIA_Cycle_Active, 1,
3797 (IPTR) work_devname, 3, MUIM_Set, MUIA_String_Contents,
3798 USB_WORK_PART_NAME);
3799
3800 /* Notifications on change of enable status of 'enter size of sys volume'
3801 * (this tells us if we are using existing partitions) */
3802 DoMethod(check_sizesys, MUIM_Notify, MUIA_Disabled, MUIV_EveryTime,
3803 (IPTR) sys_devname, 3, MUIM_Set, MUIA_Disabled, MUIV_TriggerValue);
3804 DoMethod(check_sizesys, MUIM_Notify, MUIA_Disabled, MUIV_EveryTime,
3805 (IPTR) cycle_drivetype, 3, MUIM_Set,
3806 MUIA_Disabled, MUIV_TriggerValue);
3807 DoMethod(check_sizesys, MUIM_Notify, MUIA_Disabled, MUIV_EveryTime,
3808 (IPTR) dest_device, 3, MUIM_Set, MUIA_Disabled, MUIV_TriggerValue);
3809 DoMethod(check_sizesys, MUIM_Notify, MUIA_Disabled, MUIV_EveryTime,
3810 (IPTR) dest_unit, 3, MUIM_Set, MUIA_Disabled, MUIV_TriggerValue);
3811 DoMethod(check_sizesys, MUIM_Notify, MUIA_Disabled, MUIV_EveryTime,
3812 (IPTR) cycle_fstypesys, 3, MUIM_Set,
3813 MUIA_Disabled, MUIV_TriggerValue);
3814
3815 /* Notifications on change of selected status of 'enter size of sys volume' */
3816 DoMethod(check_sizesys, MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
3817 (IPTR) check_creatework, 3, MUIM_Set,
3818 MUIA_Disabled, MUIV_NotTriggerValue);
3819 DoMethod(check_sizesys, MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
3820 (IPTR) sys_size, 3, MUIM_Set, MUIA_Disabled, MUIV_NotTriggerValue);
3821 DoMethod(check_sizesys, MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
3822 (IPTR) cycle_sysunits, 3, MUIM_Set,
3823 MUIA_Disabled, MUIV_NotTriggerValue);
3824 DoMethod(check_sizesys, MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
3825 (IPTR) check_creatework, 3, MUIM_Set, MUIA_Selected, FALSE);
3826
3827 /* Notifications on change of selected status of 'create work volume' */
3828 DoMethod(check_creatework, MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
3829 (IPTR) work_devname, 3, MUIM_Set,
3830 MUIA_Disabled, MUIV_NotTriggerValue);
3831 DoMethod(check_creatework, MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
3832 (IPTR) check_sizework, 3, MUIM_Set,
3833 MUIA_Disabled, MUIV_NotTriggerValue);
3834 DoMethod(check_creatework, MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
3835 (IPTR) cycle_fstypework, 3, MUIM_Set,
3836 MUIA_Disabled, MUIV_NotTriggerValue);
3837 DoMethod(check_creatework, MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
3838 (IPTR) check_sizework, 3, MUIM_Set, MUIA_Selected, FALSE);
3839
3840 /* Notifications on change of selected status of 'enter size of work volume' */
3841 DoMethod(check_sizework, MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
3842 (IPTR) work_size, 3, MUIM_Set, MUIA_Disabled, MUIV_NotTriggerValue);
3843 DoMethod(check_sizework, MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
3844 (IPTR) cycle_workunits, 3, MUIM_Set,
3845 MUIA_Disabled, MUIV_NotTriggerValue);
3846
3847 #if 0 /* Notification doesn't seem to work on String gadgets */
3848 DoMethod(dest_volume, MUIM_Notify, MUIA_String_Contents, MUIV_EveryTime,
3849 (IPTR) dest_volume, 3, MUIM_WriteString,
3850 MUIV_TriggerValue, dest_Path);
3851 #endif
3852 /* Notifications on installing bootloader */
3853 DoMethod(check_bootloader, MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
3854 (IPTR) cycle_grub2mode, 3, MUIM_Set,
3855 MUIA_Disabled, MUIV_NotTriggerValue);
3856
3857
3858 DoMethod(check_core, MUIM_Notify, MUIA_Selected, FALSE,
3859 (IPTR) check_formatsys, 3, MUIM_Set, MUIA_Selected, FALSE);
3860 DoMethod(check_work, MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
3861 (IPTR) check_copytowork, 3, MUIM_Set,
3862 MUIA_Disabled, MUIV_NotTriggerValue);
3863 DoMethod(check_work, MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
3864 (IPTR) check_copytowork, 3, MUIM_Set, MUIA_Selected, FALSE);
3865 DoMethod(check_work, MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
3866 (IPTR) check_formatwork, 3, MUIM_Set,
3867 MUIA_Disabled, MUIV_NotTriggerValue);
3868 DoMethod(check_work, MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
3869 (IPTR) check_formatwork, 3, MUIM_Set, MUIA_Selected, FALSE);
3870 DoMethod(check_work, MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
3871 (IPTR) work_volume, 3, MUIM_Set,
3872 MUIA_Disabled, MUIV_NotTriggerValue);
3873
3874 install_opts->opt_license = check_license;
3875 install_opts->opt_lic_box = LicenseMsg;
3876 install_opts->opt_lic_mgrp = LicenseMandGrp;
3877
3878 install_opts->opt_partmethod = radio_part;
3879
3880 install_opts->opt_format = check_format;
3881 install_opts->opt_locale = check_locale;
3882 install_opts->opt_copycore = check_core;
3883 install_opts->opt_copyextra = check_extras;
3884 install_opts->opt_development = check_dev;
3885 install_opts->opt_bootloader = check_bootloader;
3886
3887 install_opts->opt_reboot = check_reboot;
3888
3889 grub_opts->gopt_drive = grub_drive;
3890 grub_opts->gopt_grub = grub_grub;
3891 grub_opts->gopt_grub2mode = cycle_grub2mode;
3892
3893 struct MUI_CustomClass *mcc =
3894 MUI_CreateCustomClass(NULL, MUIC_Notify, NULL,
3895 sizeof(struct Install_DATA), Install_Dispatcher);
3896 Object *installer = NewObject(mcc->mcc_Class, NULL,
3897
3898 MUIA_Page, (IPTR) page,
3899 MUIA_Gauge1, (IPTR) gauge1,
3900 MUIA_Gauge2, (IPTR) gauge2,
3901 MUIA_Install, (IPTR) label,
3902
3903 MUIA_OBJ_Installer, (IPTR) app,
3904
3905 MUIA_WelcomeMsg, (IPTR) welcomeMsg,
3906 MUIA_FinishedMsg, (IPTR) doneMsg,
3907
3908 MUIA_List_Options, (IPTR) install_opts,
3909 MUIA_Grub_Options, (IPTR) grub_opts,
3910
3911 MUIA_OBJ_WindowContent, (IPTR) wndcontents,
3912 MUIA_OBJ_Window, (IPTR) wnd,
3913
3914 MUIA_OBJ_PageTitle, (IPTR) pagetitle,
3915 MUIA_OBJ_PageHeader, (IPTR) pageheader,
3916 MUIA_OBJ_CActionStrng, (IPTR) currentaction,
3917 MUIA_OBJ_Back, (IPTR) gad_back,
3918 MUIA_OBJ_Proceed, (IPTR) gad_proceed,
3919 MUIA_OBJ_Cancel, (IPTR) gad_cancel,
3920
3921 MUIA_IC_EnableUndo, TRUE,
3922
3923 // MUIA_IC_License_File,"HELP:English/license", /* License can only be viewed by highlighting text and dragging */
3924 MUIA_IC_License_Mandatory, TRUE,
3925
3926 TAG_DONE);
3927
3928 DoMethod(wnd, MUIM_Notify, MUIA_Window_CloseRequest, TRUE, app, 2,
3929 MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
3930
3931 SET(wnd, MUIA_Window_Open, TRUE);
3932 {
3933 ULONG sigs = 0;
3934
3935 while (DoMethod(app, MUIM_Application_NewInput,
3936 &sigs) != MUIV_Application_ReturnID_Quit)
3937 {
3938 if (sigs)
3939 {
3940 sigs = Wait(sigs | SIGBREAKF_CTRL_C);
3941 if (sigs & SIGBREAKF_CTRL_C)
3942 break;
3943 }
3944 }
3945 }
3946
3947 D(bug("[INST-APP] Closing Window\n"));
3948
3949 SET(wnd, MUIA_Window_Open, FALSE);
3950
3951 D(bug("[INST-APP] Disposing of Installer Object\n"));
3952
3953 DisposeObject(installer);
3954
3955 D(bug("[INST-APP] Removing Custom Class\n"));
3956
3957 MUI_DeleteCustomClass(mcc);
3958
3959 D(bug("[INST-APP] Removing App Object\n"));
3960
3961 MUI_DisposeObject(app);
3962
3963 FreeVec(extras_source);
3964 FreeVec(source_Path);
3965
3966 main_error:
3967 return 0;
3968 }
Mirror of AROS' svn.