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