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