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