?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Don't use Listview attributes on List objects.
[AROS.git] / workbench / tools / HDToolBox / gui.c
blob910637f7cc7114e8125f9845850f51a46697fdf1
1 /*
2 Copyright © 1995-2014, The AROS Development Team. All rights reserved.
3 $Id$
4 */
5
6 /* "TODO: fs support" */
7
8 #include <proto/alib.h>
9 #include <proto/dos.h>
10 #include <proto/exec.h>
11 #include <proto/icon.h>
12 #include <proto/intuition.h>
13 #include <proto/muimaster.h>
14
15 #include <exec/memory.h>
16 #include <intuition/gadgetclass.h>
17 #include <intuition/icclass.h>
18 #include <intuition/intuition.h>
19 #include <intuition/sghooks.h>
20 #include <libraries/asl.h>
21 #include <libraries/locale.h>
22 #include <libraries/mui.h>
23 #include <resources/filesysres.h>
24 #include <workbench/workbench.h>
25 #ifdef HAVE_COOLIMAGES
26 #include <libraries/coolimages.h>
27 #endif
28
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <strings.h>
32
33 #define DEBUG 0
34 #include "debug.h"
35
36 #include "gui.h"
37 #include "devices.h"
38 #include "error.h"
39 #include "harddisks.h"
40 #include "hdtoolbox_support.h"
41 #include "locale.h"
42 #include "platform.h"
43 #include "ptclass.h"
44 #include "prefs.h"
45
46 #undef CATCOMP_STRINGS
47 #undef CATCOMP_NUMBERS
48 #define CATCOMP_NUMBERS
49 #include "strings.h"
50
51 #define SIMPLEBUTTON(text) SimpleButton(MSG(text))
52
53 #ifdef HAVE_COOLIMAGES
54 #define IMAGEBUTTON(text,imgid) CoolImageIDButton(MSG(text),imgid)
55 #else
56 #define IMAGEBUTTON(text,imgid) SIMPLEBUTTON(text)
57 #endif
58
59 struct Library *MUIMasterBase = NULL;
60
61 Object *app;
62 Object *mainwin;
63 Object *about_item;
64 Object *quit_item;
65 Object *part_item;
66 Object *createml_item;
67 struct GUIGadgets gadgets;
68
69 struct Hook hook_display;
70 struct Hook hook_buttons;
71 struct Hook hook_createml;
72 struct Hook hook_lv_doubleclick;
73 struct Hook hook_lv_click;
74
75 struct AddDeviceGadgets {
76 Object *win;
77 Object *disk;
78 Object *file;
79 Object *ok;
80 Object *cancel;
81 } adddevicegadgets;
82
83 Class *ptclass;
84
85 struct AddPartitionGadgets {
86 Object *win;
87 Object *pt;
88 Object *ok;
89 Object *cancel;
90 } addpartitiongadgets;
91
92 struct PartitionTypeGadgets {
93 Object *win;
94 struct TableTypeNode *ttn;
95 Object *lv;
96 Object *base;
97 struct Hook hook_hexidedit;
98 Object *hexid;
99 struct PartitionType type;
100 struct ListNode *iln;
101 Object *ok;
102 Object *cancel;
103 } partitiontypegadgets;
104
105 struct PartitionTableTypeGadgets {
106 Object *win;
107 Object *lv;
108 struct ListNode *iln;
109 Object *ok;
110 Object *cancel;
111 } partitiontabletypegadgets;
112
113 struct ResizeMoveGadgets {
114 Object *win;
115 Object *pt;
116 Object *lowcyl;
117 Object *highcyl;
118 Object *totalcyl;
119 Object *size;
120 Object *ok;
121 Object *cancel;
122 } resizemovegadgets;
123
124 struct RenameGadgets {
125 Object *win;
126 Object *name;
127 struct ListNode *iln;
128 Object *ok;
129 Object *cancel;
130 } renamegadgets;
131
132 struct DosEnvecGadgets {
133 Object *win;
134 Object *mask;
135 Object *maxtransfer;
136 Object *custboot;
137 Object *numcustboot;
138 Object *reservedblocksstart;
139 Object *reservedblocksend;
140 Object *blocksize;
141 Object *buffers;
142 struct ListNode *iln;
143 Object *ok;
144 Object *cancel;
145 } dosenvecgadgets;
146
147 struct MountBootGadgets {
148 Object *win;
149 Object *active;
150 Object *automount;
151 Object *bootable;
152 Object *bootpri;
153 struct ListNode *iln;
154 Object *ok;
155 Object *cancel;
156 } mountbootgadgets;
157
158 char *editcycleentries[] = {"0x", NULL};
159 char *blocksizecycleentries[] = {"512","1024","2048","4096", NULL};
160
161 void setChanged(struct ListNode *iln)
162 {
163 struct ListNode *parent = iln;
164
165 D(bug("[HDToolBox] setChanged()\n"));
166
167 while (parent)
168 {
169 parent->change_count++;
170 parent = parent->parent;
171 }
172 DoMethod(gadgets.leftlv, MUIM_List_Redraw, MUIV_List_Redraw_All);
173 set(gadgets.leftlv, MUIA_Listview_SelectChange, TRUE);
174 }
175
176 void unsetChanged(struct ListNode *iln)
177 {
178 struct ListNode *sub = iln;
179 struct ListNode *parent;
180
181 D(bug("[HDToolBox] unsetChanged()\n"));
182
183 /* remove changed from all first generation child partitions */
184 sub = (struct ListNode *)iln->list.lh_Head;
185 while (sub->ln.ln_Succ)
186 {
187 if (sub->change_count)
188 {
189 parent = sub->parent;
190 while (parent)
191 {
192 parent->change_count -= sub->change_count;
193 parent = parent->parent;
194 }
195 sub->change_count = 0;
196 }
197 sub = (struct ListNode *)sub->ln.ln_Succ;
198 }
199 if (iln->flags & LNF_ToSave)
200 {
201 iln->flags &= ~LNF_ToSave;
202 /* we saved it so there can't be a change_count */
203 if (iln->change_count)
204 {
205 parent = iln->parent;
206 while (parent)
207 {
208 parent->change_count -= iln->change_count;
209 parent = parent->parent;
210 }
211 iln->change_count = 0;
212 }
213 }
214 DoMethod(gadgets.leftlv, MUIM_List_Redraw, MUIV_List_Redraw_Active);
215 }
216
217 AROS_UFH3(void, hexidedit_function,
218 AROS_UFHA(struct Hook *, h, A0),
219 AROS_UFHA(struct SGWork *, sgwork, A2),
220 AROS_UFHA(ULONG *, msg, A1))
221 {
222 AROS_USERFUNC_INIT
223
224 D(bug("[HDToolBox] hexidedit_function()\n"));
225
226 if (*msg == SGH_KEY)
227 {
228 D(bug("[HDToolBox] hexidedit_function: KEY PRESS\n"));
229 }
230
231 AROS_USERFUNC_EXIT
232 }
233
234 AROS_UFH3(void, display_function,
235 AROS_UFHA(struct Hook *, h, A0),
236 AROS_UFHA(const char **, strings, A2),
237 AROS_UFHA(struct ListNode *, entry, A1))
238 {
239 AROS_USERFUNC_INIT
240
241 static char buf[16];
242 static char bu2[64];
243
244 D(bug("[HDToolBox] display_function()\n"));
245
246 if (entry)
247 {
248 int i=0;
249 if (entry->change_count)
250 buf[i++] = '*';
251 if (entry->flags & LNF_ToSave)
252 buf[i++] = 'S';
253 buf[i] = 0;
254 strings[0] = buf;
255 if ((entry->flags & LNF_Listable) || (entry->ln.ln_Type == LNT_Parent))
256 {
257 sprintf(bu2,"\0333%s",entry->ln.ln_Name);
258 strings[1] = bu2;
259 }
260 else
261 strings[1] = entry->ln.ln_Name;
262 }
263 else
264 {
265 strings[0] = MSG(WORD_Changed);
266 strings[1] = MSG(WORD_Name);
267 }
268
269 AROS_USERFUNC_EXIT
270 }
271
272 void setTypeString(struct PartitionType *type, Object *strgad)
273 {
274 char str[256];
275 char *cur=str;
276 LONG len=0;
277
278 D(bug("[HDToolBox] setTypeString()\n"));
279
280 while (len!=type->id_len)
281 {
282 sprintf(cur, "%02x ", type->id[len]);
283 cur += 3;
284 len++;
285 }
286 cur[-1]=0;
287 set(strgad, MUIA_String_Contents, str);
288 }
289
290 LONG askSave(STRPTR name)
291 {
292 struct EasyStruct es =
293 {
294 sizeof(struct EasyStruct), 0,
295 "HDToolBox",
296 MSG(MSG_ASK_SAVE),
297 NULL
298 };
299 char yesno[32];
300
301 D(bug("[HDToolBox] askSave('%s')\n", name));
302
303 sprintf(yesno, "%s|%s|%s", MSG_STD(YESSTR), MSG(WORD_All), MSG_STD(NOSTR));
304 es.es_GadgetFormat = yesno;
305 return EasyRequestArgs(0, &es, 0, &name);
306 }
307
308
309 LONG saveChanges(struct ListNode *iln, LONG asksave)
310 {
311 struct ListNode *sub;
312
313 D(bug("[HDToolBox] saveChanges()\n"));
314
315 if (iln->change_count)
316 {
317 sub = (struct ListNode *)iln->list.lh_Head;
318 while (sub->ln.ln_Succ)
319 {
320 asksave = saveChanges(sub, asksave);
321 sub = (struct ListNode *)sub->ln.ln_Succ;
322 }
323 if (iln->flags & LNF_ToSave)
324 {
325 struct HDTBPartition *partition;
326 partition = (struct HDTBPartition *)iln;
327 if (partition->table)
328 {
329 LONG result=1;
330 if (asksave)
331 result = askSave(iln->ln.ln_Name);
332 if (result == 2)
333 asksave = FALSE;
334 if (result)
335 {
336 if (WritePartitionTable(partition->ph) == 0)
337 unsetChanged(iln);
338 else
339 set(gadgets.text, MUIA_Text_Contents, MSG(MSG_WriteTableError));
340 }
341 }
342 }
343 }
344 return asksave;
345 }
346
347 AROS_UFH3(void, buttons_function,
348 AROS_UFHA(struct Hook *, h, A0),
349 AROS_UFHA(Object *, object, A2),
350 AROS_UFHA(ULONG *, arg, A1))
351 {
352 AROS_USERFUNC_INIT
353
354 LONG active = MUIV_List_Active_Off;
355 struct ListNode *iln;
356 int i;
357
358 D(bug("[HDToolBox] buttons_function()\n"));
359
360 for (i=GB_FIRST;i<=GB_LAST;i++)
361 if (object == gadgets.buttons[i])
362 break;
363
364 if (i > GB_LAST)
365 {
366 if (object == gadgets.leftlv)
367 {
368 }
369 else if (object == adddevicegadgets.ok)
370 {
371 char *str = NULL;
372 struct HDTBDevice *dn;
373
374 get(adddevicegadgets.file, MUIA_String_Contents, &str);
375 if (str[0])
376 dn = addDeviceName(str);
377
378 if (!dn) {
379 /* FIXME: Should we fail here? */
380 }
381 }
382 else if (object == addpartitiongadgets.ok)
383 {
384 struct DosEnvec *de = NULL;
385
386 get(addpartitiongadgets.pt, PTCT_ActivePartition, &de);
387 if (de)
388 {
389 struct HDTBPartition *table;
390 struct HDTBPartition *partition;
391
392 get(addpartitiongadgets.pt, PTCT_PartitionTable, &iln);
393 table = (struct HDTBPartition *)iln;
394 partition = addPartition(table, de);
395 if (partition)
396 {
397 setChanged(&partition->listnode);
398 partition->listnode.parent->flags |= LNF_ToSave;
399 InsertList(gadgets.leftlv, &partition->listnode);
400 }
401 else
402 set(gadgets.text, MUIA_Text_Contents, MSG(MSG_NO_MEMORY));
403 }
404 }
405 else if (object == addpartitiongadgets.pt);
406 else if (object == partitiontypegadgets.hexid)
407 {
408 char *str = NULL;
409
410 DoMethod(gadgets.leftlv, MUIM_List_GetEntry, active, (IPTR)&iln);
411 get(object, MUIA_String_Contents, &str);
412 partitiontypegadgets.type.id_len=strcpyESC(partitiontypegadgets.type.id, str);
413 }
414 else if (object == partitiontypegadgets.lv)
415 {
416 get(partitiontypegadgets.lv, MUIA_List_Active, &active);
417 if (active != MUIV_List_Active_Off)
418 {
419 struct TypeNode *tn;
420 STRPTR name;
421 DoMethod(partitiontypegadgets.lv, MUIM_List_GetEntry, active, (IPTR)&name);
422 tn = (struct TypeNode *)FindName(partitiontypegadgets.ttn->typelist, name);
423 setTypeString(&tn->type, partitiontypegadgets.hexid);
424 CopyMem(&tn->type, &partitiontypegadgets.type, sizeof(struct PartitionType));
425 }
426 }
427 else if (object == partitiontypegadgets.ok)
428 {
429 struct HDTBPartition *partition;
430 partition = (struct HDTBPartition *)partitiontypegadgets.iln;
431 CopyMem(&partitiontypegadgets.type, &partition->type, sizeof(struct PartitionType));
432 SetPartitionAttrsA(partition->ph, PT_TYPE, &partition->type, TAG_DONE);
433 GetPartitionAttrsA(partition->ph, PT_DOSENVEC, &partition->de, TAG_DONE);
434 partitiontypegadgets.iln->parent->flags |= LNF_ToSave;
435 setChanged(partitiontypegadgets.iln);
436 }
437 else if (object == partitiontabletypegadgets.ok)
438 {
439 get(partitiontabletypegadgets.lv, MUIA_List_Active, &active);
440 if (active != MUIV_List_Active_Off)
441 {
442 struct TableTypeNode *ttn;
443 struct HDTBPartition *table;
444 STRPTR name;
445 DoMethod(partitiontabletypegadgets.lv, MUIM_List_GetEntry, active, (IPTR)&name);
446 ttn = findTableTypeNodeName(name);
447 table = (struct HDTBPartition *)partitiontabletypegadgets.iln;
448 if (
449 (table->table == NULL) ||
450 (ttn->pti->pti_Type != table->table->type)
451 )
452 {
453 if (makePartitionTable(table, ttn->pti->pti_Type))
454 {
455 table->listnode.flags |= LNF_Listable;
456 table->listnode.flags |= LNF_ToSave;
457 setChanged(partitiontabletypegadgets.iln);
458 }
459 else
460 set(gadgets.text, MUIA_Text_Contents, MSG(MSG_CreateTableError));
461 }
462 }
463 }
464 else if (object == resizemovegadgets.ok)
465 {
466 struct HDTBPartition *table = NULL;
467 struct HDTBPartition *partition;
468
469 get(resizemovegadgets.pt, PTCT_PartitionTable, &table);
470 partition = (struct HDTBPartition *)table->listnode.list.lh_Head;
471 table->listnode.flags |= LNF_ToSave;
472 while (partition->listnode.ln.ln_Succ)
473 {
474 if (partition->listnode.flags & LNF_IntermedChange)
475 {
476 partition->listnode.flags &= ~LNF_IntermedChange;
477 setChanged(&partition->listnode);
478 SetPartitionAttrsA(partition->ph, PT_DOSENVEC, &partition->de, TAG_DONE);
479 }
480 partition = (struct HDTBPartition *)partition->listnode.ln.ln_Succ;
481 }
482 }
483 else if (object == resizemovegadgets.cancel)
484 {
485 struct HDTBPartition *table = NULL;
486 struct HDTBPartition *partition;
487
488 get(resizemovegadgets.pt, PTCT_PartitionTable, &table);
489 partition = (struct HDTBPartition *)table->listnode.list.lh_Head;
490 while (partition->listnode.ln.ln_Succ)
491 {
492 if (partition->listnode.flags & LNF_IntermedChange)
493 {
494 partition->listnode.flags &= ~LNF_IntermedChange;
495 GetPartitionAttrsA(partition->ph, PT_DOSENVEC, &partition->de, TAG_DONE);
496 }
497 partition = (struct HDTBPartition *)partition->listnode.ln.ln_Succ;
498 }
499 }
500 else if (object == resizemovegadgets.pt)
501 {
502 LONG type = 0;
503 struct DosEnvec *de = NULL;
504 char str[32];
505
506 D(bug("[HDToolBox] buttons_function() - Resize/Move Partition Display:\n"));
507 get(resizemovegadgets.pt, PTCT_ActiveType, &type);
508 if (type == PTS_EMPTY_AREA)
509 {
510 get(resizemovegadgets.pt, PTCT_ActivePartition, &de);
511 }
512 else
513 {
514 struct HDTBPartition *partition = NULL;
515
516 get(resizemovegadgets.pt, PTCT_ActivePartition, &partition);
517 de = &partition->de;
518 if (*arg == PTCT_PartitionMove)
519 {
520 partition->listnode.flags |= LNF_IntermedChange;
521 }
522 }
523 nnset(resizemovegadgets.lowcyl, MUIA_String_Integer, de->de_LowCyl);
524 nnset(resizemovegadgets.highcyl, MUIA_String_Integer, de->de_HighCyl);
525 nnset(resizemovegadgets.totalcyl, MUIA_String_Integer, de->de_HighCyl-de->de_LowCyl+1);
526 getSizeStr(str, (((de->de_HighCyl - de->de_LowCyl + 1) * de->de_Surfaces * de->de_BlocksPerTrack)-1)/2);
527 nnset(resizemovegadgets.size, MUIA_String_Contents, str);
528 D(bug("[HDToolBox] buttons_function() - Resize/Move Partition Display successful\n"));
529 }
530 else if (object == resizemovegadgets.lowcyl)
531 {
532 LONG type = 0;
533 ULONG value = 0;
534
535 D(bug("[HDToolBox] buttons_function() - Resize/Move Lowcyl:\n"));
536 get(object, MUIA_String_Integer, &value);
537 get(resizemovegadgets.pt, PTCT_ActiveType, &type);
538 if (type == PTS_PARTITION)
539 {
540 struct HDTBPartition *table = NULL;
541 struct HDTBPartition *partition = NULL;
542 ULONG block;
543
544 get(resizemovegadgets.pt, PTCT_PartitionTable, &table);
545 get(resizemovegadgets.pt, PTCT_ActivePartition, &partition);
546 D(bug("[HDToolBox] - Type : Partition\n"));
547 D(bug("[HDToolBox] - Old value : %ld\n", partition->de.de_LowCyl));
548 D(bug("[HDToolBox] - New value : %ld\n", value));
549 D(bug("[HDToolBox] - Partition table : %p\n", table));
550 D(bug("[HDToolBox] - Active partition : %p\n", partition));
551 if (value != partition->de.de_LowCyl)
552 {
553 block =
554 value*partition->de.de_Surfaces*partition->de.de_BlocksPerTrack;
555 if (validValue(table, partition, block))
556 {
557 char str[32];
558 partition->listnode.flags |= LNF_IntermedChange;
559 partition->de.de_LowCyl = value;
560 set(resizemovegadgets.totalcyl, MUIA_String_Integer, partition->de.de_HighCyl-partition->de.de_LowCyl+1);
561 set(resizemovegadgets.pt, PTCT_PartitionTable, table);
562 getSizeStr
563 (
564 str,
565 (
566 (
567 (partition->de.de_HighCyl-partition->de.de_LowCyl+1)*
568 partition->de.de_Surfaces*partition->de.de_BlocksPerTrack
569 )-1
570 )/2
571 );
572 set(resizemovegadgets.size, MUIA_String_Contents, str);
573 }
574 else
575 set(object, MUIA_String_Integer, partition->de.de_LowCyl);
576 }
577 }
578 else if (type == PTS_EMPTY_AREA)
579 {
580 struct DosEnvec *de = NULL;
581
582 get(resizemovegadgets.pt, PTCT_ActivePartition, &de);
583 if (value != de->de_LowCyl)
584 set(object, MUIA_String_Integer, de->de_LowCyl);
585 }
586 else
587 set(object, MUIA_String_Integer, 0);
588 }
589 else if (object == resizemovegadgets.highcyl)
590 {
591 LONG type = 0;
592 ULONG value = 0;
593
594 D(bug("[HDToolBox] buttons_function() - Resize/Move Highcyl:\n"));
595 get(object, MUIA_String_Integer, &value);
596 get(resizemovegadgets.pt, PTCT_ActiveType, &type);
597 if (type == PTS_PARTITION)
598 {
599 struct HDTBPartition *table = NULL;
600 struct HDTBPartition *partition = NULL;
601 ULONG block;
602
603 get(resizemovegadgets.pt, PTCT_PartitionTable, &table);
604 get(resizemovegadgets.pt, PTCT_ActivePartition, &partition);
605 D(bug("[HDToolBox] - Type : Partition\n"));
606 D(bug("[HDToolBox] - Old value : %ld\n", partition->de.de_HighCyl));
607 D(bug("[HDToolBox] - New value : %ld\n", value));
608 D(bug("[HDToolBox] - Partition table : %p\n", table));
609 D(bug("[HDToolBox] - Active partition : %p\n", partition));
610 if (value != partition->de.de_HighCyl)
611 {
612 block =
613 (
614 (value+1)*
615 partition->de.de_Surfaces*partition->de.de_BlocksPerTrack
616 )-1;
617 if (validValue(table, partition, block))
618 {
619 char str[32];
620 partition->listnode.flags |= LNF_IntermedChange;
621 partition->de.de_HighCyl = value;
622 nnset(resizemovegadgets.totalcyl, MUIA_String_Integer, partition->de.de_HighCyl-partition->de.de_LowCyl+1);
623 nnset(resizemovegadgets.pt, PTCT_PartitionTable, table);
624 getSizeStr
625 (
626 str,
627 (
628 (
629 (partition->de.de_HighCyl-partition->de.de_LowCyl+1)*
630 partition->de.de_Surfaces*partition->de.de_BlocksPerTrack
631 )-1
632 )/2
633 );
634 nnset(resizemovegadgets.size, MUIA_String_Contents, str);
635 }
636 else
637 nnset(object, MUIA_String_Integer, partition->de.de_HighCyl);
638 }
639 }
640 else if (type == PTS_EMPTY_AREA)
641 {
642 struct DosEnvec *de = NULL;
643
644 D(bug("[HDToolBox] - Type : Empty Area\n"));
645 get(resizemovegadgets.pt, PTCT_ActivePartition, &de);
646 if (value != de->de_HighCyl)
647 set(object, MUIA_String_Integer, de->de_HighCyl);
648 }
649 else
650 nnset(object, MUIA_String_Integer, 0);
651 }
652 else if (object == resizemovegadgets.totalcyl)
653 {
654 LONG type = 0;
655 ULONG value = 0;
656
657 get(object, MUIA_String_Integer, &value);
658 get(resizemovegadgets.pt, PTCT_ActiveType, &type);
659 if (type == PTS_PARTITION)
660 {
661 struct HDTBPartition *table = NULL;
662 struct HDTBPartition *partition = NULL;
663 ULONG block;
664
665 get(resizemovegadgets.pt, PTCT_PartitionTable, &table);
666 get(resizemovegadgets.pt, PTCT_ActivePartition, &partition);
667 if (value != (partition->de.de_HighCyl-partition->de.de_LowCyl+1))
668 {
669 block =
670 (
671 (partition->de.de_LowCyl+value)*
672 partition->de.de_Surfaces*partition->de.de_BlocksPerTrack
673 )-1;
674 if (validValue(table, partition, block))
675 {
676 char str[32];
677 partition->listnode.flags |= LNF_IntermedChange;
678 partition->de.de_HighCyl = partition->de.de_LowCyl+value-1;
679 set(resizemovegadgets.highcyl, MUIA_String_Integer, partition->de.de_HighCyl);
680 set(resizemovegadgets.pt, PTCT_PartitionTable, table);
681 getSizeStr
682 (
683 str,
684 (
685 (
686 (partition->de.de_HighCyl-partition->de.de_LowCyl+1)*
687 partition->de.de_Surfaces*partition->de.de_BlocksPerTrack
688 )-1
689 )/2
690 );
691 set(resizemovegadgets.size, MUIA_String_Contents, str);
692 }
693 else
694 set(object, MUIA_String_Integer, partition->de.de_HighCyl-partition->de.de_LowCyl+1);
695 }
696 }
697 else if (type == PTS_EMPTY_AREA)
698 {
699 struct DosEnvec *de = NULL;
700
701 get(resizemovegadgets.pt, PTCT_ActivePartition, &de);
702 if (value != (de->de_HighCyl-de->de_LowCyl+1))
703 set(object, MUIA_String_Integer, de->de_HighCyl-de->de_LowCyl+1);
704 }
705 else
706 set(object, MUIA_String_Integer, 0);
707 }
708 else if (object == resizemovegadgets.size)
709 {
710 char val[32];
711 struct DosEnvec *de = NULL;
712 STRPTR *str = NULL;
713 ULONG size = 0;
714 ULONG type = 0;
715
716 get(resizemovegadgets.pt, PTCT_ActiveType, &type);
717 if (type == PTS_PARTITION)
718 {
719 struct HDTBPartition *partition = NULL;
720
721 get(resizemovegadgets.pt, PTCT_ActivePartition, &partition);
722 de = &partition->de;
723 get(object, MUIA_String_Contents, &str);
724 size = sizeStrToUL((STRPTR)str);
725 size = (size*2+1)/partition->de.de_BlocksPerTrack/partition->de.de_Surfaces+1;
726 }
727 else if (type == PTS_EMPTY_AREA)
728 {
729 get(resizemovegadgets.pt, PTCT_ActivePartition, &de);
730 }
731 set(resizemovegadgets.totalcyl, MUIA_String_Integer, size);
732 set(resizemovegadgets.totalcyl, MUIA_String_Acknowledge, TRUE);
733 getSizeStr
734 (
735 val,
736 (
737 (
738 (de->de_HighCyl-de->de_LowCyl+1)*
739 de->de_Surfaces*de->de_BlocksPerTrack
740 )-1
741 )/2
742 );
743 set(resizemovegadgets.size, MUIA_String_Contents, val);
744 }
745 else if (object == renamegadgets.ok)
746 {
747 struct HDTBPartition *partition;
748 STRPTR name = NULL;
749
750 partition = (struct HDTBPartition *)renamegadgets.iln;
751 get(renamegadgets.name, MUIA_String_Contents, &name);
752 if (strcmp(name, partition->listnode.ln.ln_Name) != 0)
753 {
754 SetPartitionAttrsA(partition->ph, PT_NAME, name, TAG_DONE);
755 strcpy(partition->listnode.ln.ln_Name, name);
756 renamegadgets.iln->parent->flags |= LNF_ToSave;
757 setChanged(renamegadgets.iln);
758 }
759 }
760 else if (object == dosenvecgadgets.ok)
761 {
762 BOOL changed = FALSE;
763 LONG check = 0;
764 ULONG value = 0;
765 STRPTR str = NULL;
766 char *end;
767 struct HDTBPartition *partition;
768
769 partition = (struct HDTBPartition *)dosenvecgadgets.iln;
770 get(dosenvecgadgets.mask, MUIA_String_Integer, &value);
771 if (value != partition->de.de_Mask)
772 {
773 partition->de.de_Mask = value;
774 changed = TRUE;
775 }
776 get(dosenvecgadgets.maxtransfer, MUIA_String_Contents, &str);
777 value = strtoul(str, &end, 0);
778 if (*end == 0)
779 {
780 if (value != partition->de.de_MaxTransfer)
781 {
782 partition->de.de_MaxTransfer = value;
783 changed = TRUE;
784 }
785 }
786 get(dosenvecgadgets.custboot, MUIA_Selected, &check);
787 if (check)
788 {
789 if (partition->de.de_TableSize<(DE_BOOTBLOCKS+1))
790 {
791 partition->de.de_TableSize = DE_BOOTBLOCKS+1;
792 changed = TRUE;
793 }
794 get(dosenvecgadgets.numcustboot, MUIA_String_Integer, &value);
795 if (value != partition->de.de_BootBlocks)
796 {
797 partition->de.de_BootBlocks = value;
798 changed = TRUE;
799 }
800 }
801 else
802 {
803 if (partition->de.de_TableSize>=(DE_BOOTBLOCKS+1))
804 {
805 partition->de.de_TableSize = DE_BOOTBLOCKS;
806 partition->de.de_BootBlocks = 0;
807 changed = TRUE;
808 }
809 }
810 get(dosenvecgadgets.reservedblocksstart, MUIA_String_Integer, &value);
811 if (value != partition->de.de_Reserved)
812 {
813 partition->de.de_Reserved = value;
814 changed = TRUE;
815 }
816 get(dosenvecgadgets.reservedblocksend, MUIA_String_Integer, &value);
817 if (value != partition->de.de_PreAlloc)
818 {
819 partition->de.de_PreAlloc = value;
820 changed = TRUE;
821 }
822 get(dosenvecgadgets.blocksize, MUIA_Cycle_Active, &value);
823 value = 1<<(value+7);
824 if (value != partition->de.de_SizeBlock)
825 {
826 partition->de.de_SizeBlock = value;
827 changed = TRUE;
828 }
829 get(dosenvecgadgets.buffers, MUIA_String_Integer, &value);
830 if (value != partition->de.de_NumBuffers)
831 {
832 partition->de.de_NumBuffers = value;
833 changed = TRUE;
834 }
835 if (changed)
836 {
837 SetPartitionAttrsA(partition->ph, PT_DOSENVEC, &partition->de, TAG_DONE);
838 dosenvecgadgets.iln->parent->flags |= LNF_ToSave;
839 setChanged(dosenvecgadgets.iln);
840 }
841 }
842 else if (object == mountbootgadgets.ok)
843 {
844 struct HDTBPartition *partition;
845 BOOL changeda = FALSE;
846 BOOL changed = FALSE;
847 LONG check = 0;
848 ULONG value = 0;
849
850 partition = (struct HDTBPartition *)mountbootgadgets.iln;
851 get(mountbootgadgets.active, MUIA_Selected, &check);
852 if (check)
853 {
854 if (!(partition->flags & PNF_ACTIVE))
855 {
856 partition->flags |= PNF_ACTIVE;
857 changeda = TRUE;
858 }
859 }
860 else
861 {
862 if (partition->flags & PNF_ACTIVE)
863 {
864 partition->flags &= ~PNF_ACTIVE;
865 changeda = TRUE;
866 }
867 }
868 if (changeda)
869 {
870 if (partition->flags & PNF_ACTIVE)
871 {
872 struct HDTBPartition *other;
873 other = (struct HDTBPartition *)partition->listnode.ln.ln_Pred;
874 while (other->listnode.ln.ln_Pred)
875 {
876 if (other->listnode.ln.ln_Type == LNT_Partition)
877 {
878 if (other->flags & PNF_ACTIVE)
879 {
880 other->flags &= ~PNF_ACTIVE;
881 SetPartitionAttrsA(other->ph, PT_ACTIVE, FALSE, TAG_DONE);
882 setChanged(&other->listnode);
883 }
884 }
885 other = (struct HDTBPartition *)other->listnode.ln.ln_Pred;
886 }
887 other = (struct HDTBPartition *)partition->listnode.ln.ln_Succ;
888 while (other->listnode.ln.ln_Succ)
889 {
890 if (other->listnode.ln.ln_Type == LNT_Partition)
891 {
892 if (other->flags & PNF_ACTIVE)
893 {
894 other->flags &= ~PNF_ACTIVE;
895 SetPartitionAttrsA(other->ph, PT_ACTIVE, FALSE, TAG_DONE);
896 setChanged(&other->listnode);
897 }
898 }
899 other = (struct HDTBPartition *)other->listnode.ln.ln_Succ;
900 }
901 }
902 SetPartitionAttrsA(partition->ph, PT_ACTIVE, check, TAG_DONE);
903 changed = TRUE;
904 }
905 changeda = FALSE;
906 get(mountbootgadgets.automount, MUIA_Selected, &check);
907 if (check)
908 {
909 if (!(partition->flags & PNF_AUTOMOUNT))
910 {
911 partition->flags |= PNF_AUTOMOUNT;
912 changeda = TRUE;
913 }
914 }
915 else
916 {
917 if (partition->flags & PNF_AUTOMOUNT)
918 {
919 partition->flags &= ~PNF_AUTOMOUNT;
920 changeda = TRUE;
921 }
922 }
923 if (changeda)
924 {
925 SetPartitionAttrsA(partition->ph, PT_AUTOMOUNT, check, TAG_DONE);
926 changed = TRUE;
927 }
928 changeda = FALSE;
929 get(mountbootgadgets.bootable, MUIA_Selected, &check);
930 if (check)
931 {
932 if (!(partition->flags & PNF_BOOTABLE))
933 {
934 partition->flags |= PNF_BOOTABLE;
935 changeda = TRUE;
936 }
937 get(mountbootgadgets.bootpri, MUIA_String_Integer, &value);
938 if (value != partition->de.de_BootPri)
939 {
940 partition->de.de_BootPri = value;
941 changeda = TRUE;
942 }
943 }
944 else
945 {
946 if (partition->flags & PNF_BOOTABLE)
947 {
948 partition->flags &= ~PNF_BOOTABLE;
949 partition->de.de_BootPri = 0;
950 changeda = TRUE;
951 }
952 }
953 if (changeda)
954 {
955 SetPartitionAttrsA(partition->ph, PT_BOOTABLE, check, PT_DOSENVEC, &partition->de, TAG_DONE);
956 changed = TRUE;
957 }
958 if (changed)
959 {
960 mountbootgadgets.iln->parent->flags |= LNF_ToSave;
961 setChanged(mountbootgadgets.iln);
962 }
963 }
964 }
965 else
966 {
967 switch (i)
968 {
969 case GB_ADD_ENTRY:
970 DoMethod(gadgets.leftlv, MUIM_List_GetEntry, 0, (IPTR)&iln);
971 if (
972 (iln == NULL) ||
973 ((iln) && (iln->parent->parent == NULL))
974 )
975 {
976 set(adddevicegadgets.win, MUIA_Window_Open, TRUE);
977 }
978 else if ((iln->parent->ln.ln_Type == LNT_Harddisk) || (iln->parent->ln.ln_Type == LNT_Partition))
979 {
980 struct HDTBPartition *table;
981 table = (struct HDTBPartition *)iln->parent;
982 if (
983 (
984 (table->table->max_partitions) &&
985 (countNodes(&table->listnode.list, LNT_Partition)<table->table->max_partitions)
986 ) ||
987 (table->table->max_partitions == 0)
988 )
989 {
990 DoMethod
991 (
992 addpartitiongadgets.win,
993 MUIM_Notify, MUIA_Window_Open, TRUE, (IPTR)addpartitiongadgets.pt, 3,
994 MUIM_Set, PTCT_PartitionTable, (IPTR)table
995 );
996 set(addpartitiongadgets.win, MUIA_Window_Open, TRUE);
997 }
998 else
999 set(gadgets.text, MUIA_Text_Contents, MSG(MSG_PARTITION_TABLE_FULL));
1000 }
1001 break;
1002 case GB_REMOVE_ENTRY:
1003 get(gadgets.leftlv, MUIA_List_Active, &active);
1004 if (active != MUIV_List_Active_Off)
1005 {
1006 DoMethod(gadgets.leftlv, MUIM_List_GetEntry, active, (IPTR)&iln);
1007 switch (iln->ln.ln_Type)
1008 {
1009 case LNT_Device:
1010 DoMethod(gadgets.leftlv, MUIM_List_Remove, active);
1011 Remove(&iln->ln);
1012 freeDeviceNode((struct HDTBDevice *)iln);
1013 break;
1014 case LNT_Partition:
1015 {
1016 struct HDTBPartition *partition;
1017 partition = (struct HDTBPartition *)iln;
1018 iln->parent->flags |= LNF_ToSave;
1019 setChanged(iln);
1020 DoMethod(gadgets.leftlv, MUIM_List_Remove, active);
1021 Remove(&iln->ln);
1022 DeletePartition(partition->ph);
1023 freePartitionNode(partition);
1024 }
1025 }
1026 }
1027 break;
1028 case GB_CREATE_TABLE:
1029 case GB_CHANGE_TYPE:
1030 get(gadgets.leftlv, MUIA_List_Active, &active);
1031 if (active != MUIV_List_Active_Off)
1032 {
1033 DoMethod(gadgets.leftlv, MUIM_List_GetEntry, active, (IPTR)&iln);
1034 if (
1035 (iln->ln.ln_Type == LNT_Harddisk) ||
1036 ((i==2) && (iln->ln.ln_Type == LNT_Partition))
1037 )
1038 {
1039 struct HDTBPartition *table;
1040 ULONG type = 0;
1041 partitiontabletypegadgets.iln = iln;
1042 table = (struct HDTBPartition *)iln;
1043 if (table->table)
1044 type = table->table->type;
1045 DoMethod(partitiontabletypegadgets.lv, MUIM_List_Clear);
1046 for (i=0;PartitionBase->tables[i] != NULL;i++)
1047 {
1048 DoMethod
1049 (
1050 partitiontabletypegadgets.lv,
1051 MUIM_List_InsertSingle, (IPTR)PartitionBase->tables[i]->pti_Name, MUIV_List_Insert_Bottom
1052 );
1053 if (type == PartitionBase->tables[i]->pti_Type)
1054 set(partitiontabletypegadgets.lv, MUIA_List_Active, i);
1055 }
1056 set(partitiontabletypegadgets.win, MUIA_Window_Open, TRUE);
1057 }
1058 else if ((i==3) && (iln->ln.ln_Type == LNT_Partition))
1059 {
1060 struct TypeNode *tn;
1061 struct HDTBPartition *partition;
1062 partitiontypegadgets.iln = iln;
1063 i = 0;
1064 DoMethod(partitiontypegadgets.lv, MUIM_List_Clear);
1065 partition = (struct HDTBPartition *)iln;
1066 partitiontypegadgets.ttn = findTableTypeNode(partition->root->table->type);
1067 if (partitiontypegadgets.ttn)
1068 {
1069 tn = (struct TypeNode *)partitiontypegadgets.ttn->typelist->lh_Head;
1070 while (tn->ln.ln_Succ)
1071 {
1072 DoMethod
1073 (
1074 partitiontypegadgets.lv,
1075 MUIM_List_InsertSingle, (IPTR)tn->ln.ln_Name, MUIV_List_Insert_Bottom
1076 );
1077 if (tn->type.id_len == partition->type.id_len)
1078 if (memcmp(tn->type.id, partition->type.id, tn->type.id_len) == 0)
1079 set(partitiontypegadgets.lv, MUIA_List_Active, i);
1080 tn = (struct TypeNode *)tn->ln.ln_Succ;
1081 i++;
1082 }
1083 }
1084 setTypeString(&partition->type, partitiontypegadgets.hexid);
1085 set(partitiontypegadgets.win, MUIA_Window_Open, TRUE);
1086 }
1087 }
1088 break;
1089 case GB_RESIZE_MOVE:
1090 break;
1091 case GB_PARENT:
1092 DoMethod(gadgets.leftlv, MUIM_List_GetEntry, 0, (IPTR)&iln);
1093 if (iln->ln.ln_Type == LNT_Parent)
1094 {
1095 set(gadgets.leftlv, MUIA_List_Active, 0);
1096 set(gadgets.leftlv, MUIA_Listview_DoubleClick, TRUE);
1097 }
1098 break;
1099 case GB_RENAME:
1100 get(gadgets.leftlv, MUIA_List_Active, &active);
1101 if (active != MUIV_List_Active_Off)
1102 {
1103 DoMethod(gadgets.leftlv, MUIM_List_GetEntry, active, (IPTR)&iln);
1104 if (iln->ln.ln_Type == LNT_Partition)
1105 {
1106 struct HDTBPartition *partition;
1107 partition = (struct HDTBPartition *)iln;
1108 if (getAttrInfo(partition->root->table->pattrlist, PTA_NAME) & PLAM_READ)
1109 {
1110 renamegadgets.iln = iln;
1111 set(renamegadgets.name, MUIA_String_Contents, iln->ln.ln_Name);
1112 set(renamegadgets.win, MUIA_Window_Open, TRUE);
1113 }
1114 }
1115 }
1116 break;
1117 case GB_DOSENVEC:
1118 get(gadgets.leftlv, MUIA_List_Active, &active);
1119 if (active != MUIV_List_Active_Off)
1120 {
1121 DoMethod(gadgets.leftlv, MUIM_List_GetEntry, active, (IPTR)&iln);
1122 if (iln->ln.ln_Type == LNT_Partition)
1123 {
1124 struct HDTBPartition *partition;
1125 partition = (struct HDTBPartition *)iln;
1126 if (getAttrInfo(partition->root->table->pattrlist, PTA_DOSENVEC) & PLAM_READ)
1127 {
1128 char str[32];
1129 dosenvecgadgets.iln = iln;
1130 set(dosenvecgadgets.mask, MUIA_String_Integer, partition->de.de_Mask);
1131 sprintf(str, "0x%08lx", partition->de.de_MaxTransfer);
1132 set(dosenvecgadgets.maxtransfer, MUIA_String_Contents, str);
1133 if (partition->de.de_TableSize>=(DE_BOOTBLOCKS+1))
1134 {
1135 set(dosenvecgadgets.custboot, MUIA_Selected, TRUE);
1136 set(dosenvecgadgets.numcustboot, MUIA_String_Integer, partition->de.de_BootBlocks);
1137 }
1138 else
1139 set(dosenvecgadgets.custboot, MUIA_Selected, FALSE);
1140 set(dosenvecgadgets.reservedblocksstart, MUIA_String_Integer, partition->de.de_Reserved);
1141 set(dosenvecgadgets.reservedblocksend, MUIA_String_Integer, partition->de.de_PreAlloc);
1142 set(dosenvecgadgets.blocksize, MUIA_Cycle_Active, getBitNum(partition->de.de_SizeBlock>>7));
1143 set(dosenvecgadgets.buffers, MUIA_String_Integer, partition->de.de_NumBuffers);
1144 set(dosenvecgadgets.win, MUIA_Window_Open, TRUE);
1145 }
1146 }
1147 }
1148 break;
1149 case GB_SWITCHES:
1150 get(gadgets.leftlv, MUIA_List_Active, &active);
1151 if (active != MUIV_List_Active_Off)
1152 {
1153 DoMethod(gadgets.leftlv, MUIM_List_GetEntry, active, (IPTR)&iln);
1154 if (iln->ln.ln_Type == LNT_Partition)
1155 {
1156 struct HDTBPartition *partition;
1157 BOOL active;
1158 BOOL automount;
1159 BOOL bootable;
1160 partition = (struct HDTBPartition *)iln;
1161 active = getAttrInfo(partition->root->table->pattrlist, PTA_ACTIVE);
1162 automount = getAttrInfo(partition->root->table->pattrlist, PTA_AUTOMOUNT);
1163 bootable = getAttrInfo(partition->root->table->pattrlist, PTA_BOOTABLE);
1164 if ((active | automount | bootable) & PLAM_READ)
1165 {
1166 mountbootgadgets.iln = iln;
1167 set(mountbootgadgets.active, MUIA_Disabled, !(active & PLAM_READ));
1168 set(mountbootgadgets.automount, MUIA_Disabled, !(automount & PLAM_READ));
1169 set(mountbootgadgets.bootable, MUIA_Disabled, !(bootable & PLAM_READ));
1170 set(mountbootgadgets.bootpri, MUIA_Disabled, !(bootable & PLAM_READ));
1171 set(mountbootgadgets.active, MUIA_Selected, (partition->flags & PNF_ACTIVE) ? TRUE : FALSE);
1172 set(mountbootgadgets.automount, MUIA_Selected, (partition->flags & PNF_AUTOMOUNT) ? TRUE : FALSE);
1173 if (partition->flags & PNF_BOOTABLE)
1174 {
1175 set(mountbootgadgets.bootable, MUIA_Selected, TRUE);
1176 set(mountbootgadgets.bootpri, MUIA_String_Integer, partition->de.de_BootPri);
1177 }
1178 else
1179 set(mountbootgadgets.bootable, MUIA_Selected, FALSE);
1180 set(mountbootgadgets.win, MUIA_Window_Open, TRUE);
1181 }
1182 }
1183 }
1184 break;
1185 case GB_SAVE_CHANGES:
1186 get(gadgets.leftlv, MUIA_List_Active, &active);
1187 if (active != MUIV_List_Active_Off)
1188 {
1189 DoMethod(gadgets.leftlv, MUIM_List_GetEntry, active, (IPTR)&iln);
1190 saveChanges(iln, TRUE);
1191 }
1192 break;
1193 }
1194 }
1195
1196 AROS_USERFUNC_EXIT
1197 }
1198
1199 /*
1200 * DosEnvec of all partitions holds cylinder numbers relative to partition start.
1201 * This function returns absolute start cylinder number for the partition.
1202 */
1203 static ULONG GetStartCyl(struct HDTBPartition *part)
1204 {
1205 ULONG blockspercyl = part->de.de_Surfaces * part->de.de_BlocksPerTrack;
1206 ULONG ret = 0;
1207
1208 while (part->listnode.parent)
1209 {
1210 part = (struct HDTBPartition *)part->listnode.parent;
1211
1212 if (part->listnode.ln.ln_Type != LNT_Partition)
1213 break;
1214
1215 /*
1216 * Calculate start offset in blocks. This can be done because theoretically
1217 * partitions can have different virtual geometries.
1218 */
1219 ret += part->de.de_LowCyl * part->de.de_Surfaces * part->de.de_BlocksPerTrack;
1220 }
1221
1222 /*
1223 * FIXME: What if this can't be divided in interegs?
1224 * This can happen for example if the disk was partitioned on another machine where
1225 * disk driver reported different (virtual) geometry. In this case we should be able
1226 * to adjust mountlist geometry (Surfaces and BlocksPerTrack) so that division works
1227 * correctly and CHS-LBA relationship is still not broken.
1228 */
1229 return ret / blockspercyl;
1230 }
1231
1232 static struct FileSysEntry *FindFileSysEntry(ULONG dostype)
1233 {
1234 struct FileSysEntry *fse;
1235 struct FileSysResource *fsr = OpenResource("FileSystem.resource");
1236
1237 if (!fsr)
1238 return NULL;
1239
1240 ForeachNode(&fsr->fsr_FileSysEntries, fse)
1241 {
1242 if (fse->fse_DosType == dostype)
1243 return fse;
1244 }
1245
1246 return NULL;
1247 }
1248
1249 AROS_UFH3(void, createml_function,
1250 AROS_UFHA(struct Hook *, h, A0),
1251 AROS_UFHA(Object *, object, A2),
1252 AROS_UFHA(ULONG *, arg, A1))
1253 {
1254 AROS_USERFUNC_INIT
1255
1256 IPTR active = MUIA_List_Active;
1257 struct HDTBPartition *partition = NULL;
1258
1259 get(gadgets.leftlv, MUIA_List_Active, &active);
1260 if (active != MUIV_List_Active_Off)
1261 {
1262 struct FileRequester *req;
1263 struct TagItem asltags[] =
1264 {
1265 {ASLFR_InitialDrawer, (IPTR)"SYS:Storage/DOSDrivers"},
1266 {ASLFR_InitialFile , 0},
1267 {ASLFR_DoSaveMode , TRUE},
1268 {TAG_DONE , 0}
1269 };
1270
1271 DoMethod(gadgets.leftlv, MUIM_List_GetEntry, active, &partition);
1272 asltags[1].ti_Data = (IPTR)partition->listnode.ln.ln_Name;
1273
1274 req = MUI_AllocAslRequest(ASL_FileRequest, asltags);
1275
1276 if (!req)
1277 return;
1278
1279 if (MUI_AslRequest(req, NULL))
1280 {
1281 ULONG len = strlen(req->fr_Drawer) + strlen(req->fr_File) + 2;
1282 STRPTR pathname = AllocMem(len, MEMF_ANY);
1283
1284 if (pathname)
1285 {
1286 BPTR file;
1287
1288 strcpy(pathname, req->fr_Drawer);
1289 AddPart(pathname, req->fr_File, len);
1290
1291 file = Open(pathname, MODE_NEWFILE);
1292 FreeMem(pathname, len);
1293
1294 if (file)
1295 {
1296 struct DiskObject *icon;
1297 IPTR args[20];
1298 struct FileSysEntry *fse;
1299 ULONG startcyl = GetStartCyl(partition);
1300
1301 args[ 0] = (IPTR)"";
1302 args[ 1] = (IPTR)partition->ph->bd->ioreq->iotd_Req.io_Device->dd_Library.lib_Node.ln_Name;
1303 args[ 2] = ((struct HDNode *)partition->root)->unit;
1304 args[ 3] = partition->de.de_SizeBlock * 4; /* block size in longs */
1305 args[ 4] = partition->de.de_Surfaces;
1306 args[ 5] = partition->de.de_SectorPerBlock;
1307 args[ 6] = partition->de.de_BlocksPerTrack;
1308 args[ 7] = partition->de.de_Reserved;
1309 args[ 8] = partition->de.de_PreAlloc;
1310 args[ 9] = partition->de.de_Interleave;
1311 args[10] = partition->de.de_MaxTransfer;
1312 args[11] = partition->de.de_Mask;
1313 args[12] = partition->de.de_LowCyl + startcyl;
1314 args[13] = partition->de.de_HighCyl + startcyl;
1315 args[14] = partition->de.de_NumBuffers;
1316 args[15] = partition->de.de_BufMemType;
1317 args[16] = 16384;
1318 args[17] = 0;
1319 args[18] = -1;
1320 args[19] = partition->de.de_DosType;
1321
1322 /*
1323 * Some things can be fetched only from FileSystem.resource.
1324 * Let's try to do it.
1325 */
1326 fse = FindFileSysEntry(partition->de.de_DosType);
1327 if (fse)
1328 {
1329 if (fse->fse_PatchFlags & FSEF_HANDLER)
1330 args[0] = (IPTR)AROS_BSTR_ADDR(fse->fse_Handler);
1331
1332 if (fse->fse_PatchFlags & FSEF_STACKSIZE)
1333 args[16] = fse->fse_StackSize;
1334
1335 if (fse->fse_PatchFlags & FSEF_PRIORITY)
1336 args[17] = fse->fse_Priority;
1337
1338 if (fse->fse_PatchFlags & FSEF_GLOBALVEC)
1339 args[18] = (IPTR)fse->fse_GlobalVec;
1340 }
1341
1342 VFPrintf(file, "FileSystem = %s\n"
1343 "Device = %s\n"
1344 "Unit = %ld\n"
1345 "BlockSize = %ld\n"
1346 "Surfaces = %ld\n"
1347 "SectorsPerBlock = %ld\n"
1348 "BlocksPerTrack = %ld\n"
1349 "Reserved = %ld\n"
1350 "PreAlloc = %ld\n"
1351 "Interleave = %ld\n"
1352 "MaxTransfer = 0x%08lx\n"
1353 "Mask = 0x%08lx\n"
1354 "LowCyl = %ld\n"
1355 "HighCyl = %ld\n"
1356 "Buffers = %ld\n"
1357 "BufMemType = %ld\n"
1358 "StackSize = %ld\n"
1359 "Priority = %ld\n"
1360 "GlobVec = %ld\n"
1361 "DosType = 0x%08lx\n"
1362 "Activate = 1\n",
1363 args);
1364
1365 Close(file);
1366
1367 icon = GetDiskObject("ENVARC:Sys/def_Mountlist");
1368 if (icon)
1369 {
1370 PutDiskObject(pathname, icon);
1371 FreeDiskObject(icon);
1372 }
1373 }
1374 }
1375 }
1376
1377 MUI_FreeAslRequest(req);
1378 }
1379
1380 AROS_USERFUNC_EXIT
1381 }
1382
1383 /************************* general List functions ***************************/
1384
1385 LONG InitListNode(struct ListNode *node, struct ListNode *parent)
1386 {
1387 struct ListNode *new;
1388
1389 D(bug("[HDToolBox] InitListNode()\n"));
1390
1391 NEWLIST(&node->list);
1392 new = AllocMem(sizeof(struct ListNode), MEMF_PUBLIC | MEMF_CLEAR);
1393 if (new)
1394 {
1395 node->parent = parent;
1396 new->ln.ln_Name = "..";
1397 new->ln.ln_Type = LNT_Parent;
1398 new->ln.ln_Pri = 127;
1399 new->parent = node;
1400 AddTail(&node->list, &new->ln);
1401 return TRUE;
1402 }
1403 return FALSE;
1404 }
1405
1406 void UninitListNode(struct ListNode *node)
1407 {
1408 struct ListNode *parent, *next;
1409
1410 D(bug("[HDToolBox] UninitListNode()\n"));
1411
1412 /* free parent entry */
1413 parent = (struct ListNode *)node->list.lh_Head;
1414 while (parent->ln.ln_Succ)
1415 {
1416 next = (struct ListNode *)parent->ln.ln_Succ;
1417 if (parent->ln.ln_Type == LNT_Parent)
1418 {
1419 Remove(&parent->ln);
1420 FreeMem(parent, sizeof(struct ListNode));
1421 return;
1422 }
1423 parent = next;
1424 }
1425 }
1426
1427 void InsertList(Object *list, struct ListNode *node)
1428 {
1429 D(bug("[HDToolBox] InsertList()\n"));
1430
1431 DoMethod(list, MUIM_List_InsertSingle, (IPTR)node, MUIV_List_Insert_Bottom);
1432 }
1433
1434 void ShowList(Object *list, struct List *lh)
1435 {
1436 struct ListNode *lnode;
1437
1438 D(bug("[HDToolBox] ShowList()\n"));
1439
1440 DoMethod(list, MUIM_List_Clear);
1441 lnode = (struct ListNode *)lh->lh_Head;
1442 while (lnode->ln.ln_Succ)
1443 {
1444 if (
1445 (
1446 ((lnode->ln.ln_Type == LNT_Parent) && (lnode->parent->parent != NULL)) ||
1447 (lnode->ln.ln_Type != LNT_Parent)
1448 ) &&
1449 (!(lnode->flags & LNF_Invalid))
1450 )
1451 {
1452 DoMethod(list, MUIM_List_InsertSingle, (IPTR)lnode, MUIV_List_Insert_Bottom);
1453 }
1454 lnode = (struct ListNode *)lnode->ln.ln_Succ;
1455 }
1456 }
1457
1458 void disableObject(Object *object)
1459 {
1460 LONG disabled = FALSE;
1461
1462 D(bug("[HDToolBox] disableObject()\n"));
1463
1464 get(object, MUIA_Disabled, &disabled);
1465 if (disabled == FALSE)
1466 {
1467 set(object, MUIA_Disabled, TRUE);
1468 }
1469 }
1470
1471 void enableObject(Object *object)
1472 {
1473 LONG disabled = FALSE;
1474
1475 D(bug("[HDToolBox] enableObject()\n"));
1476
1477 get(object, MUIA_Disabled, &disabled);
1478 if (disabled == TRUE)
1479 {
1480 set(object, MUIA_Disabled, FALSE);
1481 }
1482 }
1483
1484
1485 /********************************** Left Listview ***************************/
1486
1487 AROS_UFH3(void, lv_doubleclick,
1488 AROS_UFHA(struct Hook *, h, A0),
1489 AROS_UFHA(Object *, object, A2),
1490 AROS_UFHA(void *, arg, A1))
1491 {
1492 AROS_USERFUNC_INIT
1493
1494 LONG active = MUIV_List_Active_Off;
1495 LONG type = -1;
1496 struct ListNode *iln;
1497
1498 D(bug("[HDToolBox] lv_doubleclick()\n"));
1499
1500 get(object, MUIA_List_Active, &active);
1501 if (active != MUIV_List_Active_Off)
1502 {
1503 DoMethod(object,MUIM_List_GetEntry,active, (IPTR)&iln);
1504 if (iln->flags & LNF_Listable)
1505 {
1506 ShowList(object, &iln->list);
1507 type = iln->ln.ln_Type;
1508 }
1509 else if (iln->ln.ln_Type == LNT_Parent)
1510 {
1511 if (iln->parent->parent)
1512 {
1513 ShowList(object, &iln->parent->parent->list);
1514 type = iln->parent->parent->ln.ln_Type;
1515 iln = iln->parent;
1516 }
1517 }
1518 switch (type)
1519 {
1520 case LNT_Root:
1521 enableObject(gadgets.buttons[GB_ADD_ENTRY]);
1522 disableObject(gadgets.buttons[GB_REMOVE_ENTRY]);
1523 disableObject(gadgets.buttons[GB_CREATE_TABLE]);
1524 disableObject(gadgets.buttons[GB_CHANGE_TYPE]);
1525 disableObject(gadgets.buttons[GB_RESIZE_MOVE]);
1526 disableObject(gadgets.buttons[GB_PARENT]);
1527 disableObject(gadgets.buttons[GB_RENAME]);
1528 disableObject(gadgets.buttons[GB_DOSENVEC]);
1529 disableObject(gadgets.buttons[GB_SWITCHES]);
1530 disableObject(gadgets.buttons[GB_SAVE_CHANGES]);
1531 break;
1532 case LNT_Device:
1533 disableObject(gadgets.buttons[GB_ADD_ENTRY]);
1534 disableObject(gadgets.buttons[GB_REMOVE_ENTRY]);
1535 disableObject(gadgets.buttons[GB_CREATE_TABLE]);
1536 disableObject(gadgets.buttons[GB_CHANGE_TYPE]);
1537 disableObject(gadgets.buttons[GB_RESIZE_MOVE]);
1538 enableObject(gadgets.buttons[GB_PARENT]);
1539 disableObject(gadgets.buttons[GB_RENAME]);
1540 disableObject(gadgets.buttons[GB_DOSENVEC]);
1541 disableObject(gadgets.buttons[GB_SWITCHES]);
1542 disableObject(gadgets.buttons[GB_SAVE_CHANGES]);
1543 break;
1544 case LNT_Harddisk:
1545 case LNT_Partition:
1546 enableObject(gadgets.buttons[GB_ADD_ENTRY]);
1547 disableObject(gadgets.buttons[GB_REMOVE_ENTRY]);
1548 disableObject(gadgets.buttons[GB_CREATE_TABLE]);
1549 disableObject(gadgets.buttons[GB_CHANGE_TYPE]);
1550 enableObject(gadgets.buttons[GB_RESIZE_MOVE]);
1551 enableObject(gadgets.buttons[GB_PARENT]);
1552 disableObject(gadgets.buttons[GB_RENAME]);
1553 disableObject(gadgets.buttons[GB_DOSENVEC]);
1554 disableObject(gadgets.buttons[GB_SWITCHES]);
1555 disableObject(gadgets.buttons[GB_SAVE_CHANGES]);
1556 DoMethod(gadgets.buttons[GB_RESIZE_MOVE], MUIM_KillNotify, MUIA_Pressed);
1557 DoMethod
1558 (
1559 gadgets.buttons[GB_RESIZE_MOVE],
1560 MUIM_Notify, MUIA_Pressed, FALSE, (IPTR)resizemovegadgets.win, 3,
1561 MUIM_Set, MUIA_Window_Open, TRUE
1562 );
1563 DoMethod
1564 (
1565 resizemovegadgets.win,
1566 MUIM_Notify, MUIA_Window_Open, TRUE, (IPTR)resizemovegadgets.pt, 3,
1567 MUIM_Set, PTCT_PartitionTable, (IPTR)iln
1568 );
1569 break;
1570 }
1571 }
1572
1573 AROS_USERFUNC_EXIT
1574 }
1575
1576 AROS_UFH3(void, lv_click,
1577 AROS_UFHA(struct Hook *, h, A0),
1578 AROS_UFHA(Object *, object, A2),
1579 AROS_UFHA(void *, arg, A1))
1580 {
1581 AROS_USERFUNC_INIT
1582
1583 LONG active = MUIV_List_Active_Off;
1584 struct ListNode *iln;
1585 char str[64];
1586 char sizestr[16];
1587
1588 D(bug("[HDToolBox] lv_click()\n"));
1589
1590 get(object, MUIA_List_Active, &active);
1591 if (active != MUIV_List_Active_Off)
1592 {
1593 DoMethod(object,MUIM_List_GetEntry,active, (IPTR)&iln);
1594 DoMethod(gadgets.rightlv, MUIM_List_Clear);
1595 switch (iln->ln.ln_Type)
1596 {
1597 case LNT_Device:
1598 sprintf(str, "%s: %d", MSG(WORD_Units),(int)countNodes(&iln->list, LNT_Harddisk));
1599 DoMethod(gadgets.rightlv, MUIM_List_InsertSingle, (IPTR)str, MUIV_List_Insert_Bottom);
1600 enableObject(gadgets.buttons[GB_REMOVE_ENTRY]);
1601 if (iln->change_count > 0)
1602 enableObject(gadgets.buttons[GB_SAVE_CHANGES]);
1603 else
1604 disableObject(gadgets.buttons[GB_SAVE_CHANGES]);
1605 break;
1606 case LNT_Harddisk:
1607 case LNT_Partition:
1608 {
1609 struct HDTBPartition *partition;
1610 partition = (struct HDTBPartition *)iln;
1611 getSizeStr
1612 (
1613 sizestr,
1614 (
1615 (
1616 (partition->de.de_HighCyl-partition->de.de_LowCyl+1)*
1617 partition->de.de_Surfaces*partition->de.de_BlocksPerTrack
1618 )-1
1619 )/2
1620 );
1621 sprintf(str, "%s: %s", MSG(WORD_Size), sizestr);
1622 DoMethod(gadgets.rightlv, MUIM_List_InsertSingle, (IPTR)str, MUIV_List_Insert_Bottom);
1623 sprintf(str, "%s: ", MSG(WORD_Partition_Table));
1624 if (partition->table)
1625 {
1626 struct TableTypeNode *ttn;
1627 ttn = findTableTypeNode(partition->table->type);
1628 strcat(str, ttn->pti->pti_Name);
1629 DoMethod(gadgets.rightlv, MUIM_List_InsertSingle, (IPTR)str, MUIV_List_Insert_Bottom);
1630 sprintf(str, "%s: %d", MSG(WORD_Partitions), (int)countNodes(&iln->list, LNT_Partition));
1631 DoMethod(gadgets.rightlv, MUIM_List_InsertSingle, (IPTR)str, MUIV_List_Insert_Bottom);
1632 }
1633 else
1634 {
1635 strcat(str, MSG(WORD_Unknown));
1636 DoMethod(gadgets.rightlv, MUIM_List_InsertSingle, (IPTR)str, MUIV_List_Insert_Bottom);
1637 }
1638 if (iln->ln.ln_Type == LNT_Partition)
1639 {
1640 struct TypeNode *type;
1641 type = findPartitionType(&partition->type, partition->root->table->type);
1642 sprintf(str, "%s: ", MSG(WORD_Partition_Type));
1643 if (type)
1644 strcat(str, type->ln.ln_Name);
1645 else
1646 strcat(str, MSG(WORD_Unknown));
1647 DoMethod(gadgets.rightlv, MUIM_List_InsertSingle, (IPTR)str, MUIV_List_Insert_Bottom);
1648 sprintf(str, "%s: ", MSG(WORD_Active));
1649 if (partition->flags & PNF_ACTIVE)
1650 strcat(str, MSG_STD(YESSTR));
1651 else
1652 strcat(str, MSG_STD(NOSTR));
1653 DoMethod(gadgets.rightlv, MUIM_List_InsertSingle, (IPTR)str, MUIV_List_Insert_Bottom);
1654 sprintf(str, "%s: ", MSG(WORD_Bootable));
1655 if (partition->flags & PNF_BOOTABLE)
1656 strcat(str, MSG_STD(YESSTR));
1657 else
1658 strcat(str, MSG_STD(NOSTR));
1659 DoMethod(gadgets.rightlv, MUIM_List_InsertSingle, (IPTR)str, MUIV_List_Insert_Bottom);
1660 sprintf(str, "%s: ", MSG(WORD_Automount));
1661 if (partition->flags & PNF_AUTOMOUNT)
1662 strcat(str, MSG_STD(YESSTR));
1663 else
1664 strcat(str, MSG_STD(NOSTR));
1665 DoMethod(gadgets.rightlv, MUIM_List_InsertSingle, (IPTR)str, MUIV_List_Insert_Bottom);
1666 enableObject(gadgets.buttons[GB_REMOVE_ENTRY]);
1667 enableObject(gadgets.buttons[GB_RENAME]);
1668 enableObject(gadgets.buttons[GB_DOSENVEC]);
1669 enableObject(gadgets.buttons[GB_SWITCHES]);
1670 SetAttrs(part_item, MUIA_Menuitem_Enabled, !partition->table, TAG_DONE);
1671 }
1672 else if (iln->ln.ln_Type == LNT_Harddisk)
1673 {
1674 if (iln->change_count > 0)
1675 enableObject(gadgets.buttons[GB_SAVE_CHANGES]);
1676 else
1677 disableObject(gadgets.buttons[GB_SAVE_CHANGES]);
1678 }
1679 enableObject(gadgets.buttons[GB_CREATE_TABLE]);
1680 enableObject(gadgets.buttons[GB_CHANGE_TYPE]);
1681 }
1682 break;
1683 case LNT_Parent:
1684 disableObject(gadgets.buttons[GB_REMOVE_ENTRY]);
1685 disableObject(gadgets.buttons[GB_RENAME]);
1686 disableObject(gadgets.buttons[GB_DOSENVEC]);
1687 disableObject(gadgets.buttons[GB_SWITCHES]);
1688 disableObject(gadgets.buttons[GB_CREATE_TABLE]);
1689 disableObject(gadgets.buttons[GB_CHANGE_TYPE]);
1690 disableObject(gadgets.buttons[GB_SAVE_CHANGES]);
1691 SetAttrs(part_item, MUIA_Menuitem_Enabled, FALSE, TAG_DONE);
1692 break;
1693 }
1694 }
1695
1696 AROS_USERFUNC_EXIT
1697 }
1698
1699 /**************************************** Main ******************************/
1700
1701 LONG initGUI(void)
1702 {
1703 int i;
1704
1705 D(bug("[HDToolBox] initGUI()\n"));
1706
1707 MUIMasterBase = OpenLibrary("muimaster.library", 0);
1708 if (!MUIMasterBase)
1709 return ERR_MUIMASTER;
1710
1711 ptclass = makePTClass();
1712 if (ptclass == NULL)
1713 return ERR_GADGETS;
1714
1715 hook_display.h_Entry = (HOOKFUNC)display_function;
1716 hook_buttons.h_Entry = (HOOKFUNC)buttons_function;
1717 hook_createml.h_Entry = (HOOKFUNC)createml_function;
1718 hook_lv_doubleclick.h_Entry = (HOOKFUNC)lv_doubleclick;
1719 hook_lv_click.h_Entry = (HOOKFUNC)lv_click;
1720 partitiontypegadgets.hook_hexidedit.h_Entry = (HOOKFUNC)hexidedit_function;
1721
1722 app = ApplicationObject,
1723 MUIA_Application_Title , "HDToolBox",
1724 MUIA_Application_Version , "$VER: HDToolBox 0.3 (21.1.2014)",
1725 MUIA_Application_Copyright , "(c) 1995-2014 AROS Development Team",
1726 MUIA_Application_Author , "Bearly, Ogun, Fats and others at AROS",
1727 MUIA_Application_Description, "Partition your disks.",
1728 MUIA_Application_Base , "HDTOOLBOX",
1729 MUIA_Application_Menustrip, MenuitemObject,
1730 MUIA_Family_Child, MenuitemObject,
1731 MUIA_Menuitem_Title, MSG(WORD_MENU_Project),
1732 MUIA_Family_Child,
1733 about_item = MenuitemObject, MUIA_Menuitem_Title, MSG(WORD_MENU_About),
1734 End,
1735 MUIA_Family_Child,
1736 quit_item = MenuitemObject, MUIA_Menuitem_Title, MSG(WORD_MENU_Quit),
1737 End,
1738 End,
1739 MUIA_Family_Child,
1740 part_item = MenuitemObject,
1741 MUIA_Menuitem_Title, MSG(WORD_MENU_Partition),
1742 MUIA_Menuitem_Enabled, FALSE,
1743 MUIA_Family_Child,
1744 createml_item = MenuitemObject,
1745 MUIA_Menuitem_Title, MSG(WORD_MENU_CreateMountlist),
1746 End,
1747 End,
1748 End,
1749 SubWindow, mainwin = WindowObject,
1750 MUIA_Window_Title, "HDToolBox",
1751 MUIA_Window_ID, MAKE_ID('H','D','T','B'),
1752 MUIA_Window_Activate, TRUE,
1753 MUIA_Window_Height, MUIV_Window_Height_Visible(50),
1754 MUIA_Window_Width, MUIV_Window_Width_Visible(60),
1755 WindowContents, VGroup,
1756 Child, VGroup,
1757 GroupFrame,
1758 Child, gadgets.text = TextObject,
1759 TextFrame,
1760 MUIA_Text_Contents, MSG(MSG_Welcome),
1761 End,
1762 Child, HGroup,
1763 Child, (gadgets.leftlv = ListviewObject,
1764 MUIA_Listview_List, ListObject,
1765 InputListFrame,
1766 MUIA_List_DisplayHook, &hook_display,
1767 MUIA_List_Format, ",",
1768 MUIA_List_Title, TRUE,
1769 End,
1770 End),
1771 Child, ListviewObject,
1772 MUIA_Listview_List, (gadgets.rightlv = ListObject,
1773 ReadListFrame,
1774 MUIA_List_Title, TRUE,
1775 MUIA_List_ConstructHook, MUIV_List_ConstructHook_String,
1776 MUIA_List_DestructHook, MUIV_List_DestructHook_String,
1777 End),
1778 MUIA_Listview_Input, FALSE,
1779 End,
1780 End,
1781 End,
1782 Child, VGroup,
1783 GroupFrame,
1784 Child, HGroup,
1785 Child, VGroup,
1786 Child, gadgets.buttons[GB_ADD_ENTRY] = SIMPLEBUTTON(WORD_AddEntry),
1787 Child, gadgets.buttons[GB_REMOVE_ENTRY] = SIMPLEBUTTON(WORD_RemoveEntry),
1788 End,
1789 Child, VGroup,
1790 Child, gadgets.buttons[GB_CREATE_TABLE] = SIMPLEBUTTON(WORD_Create_Table),
1791 Child, gadgets.buttons[GB_CHANGE_TYPE] = SIMPLEBUTTON(WORD_Change_Type),
1792 End,
1793 Child, VGroup,
1794 Child, gadgets.buttons[GB_RESIZE_MOVE] = SIMPLEBUTTON(WORD_Resize_Move),
1795 Child, gadgets.buttons[GB_PARENT] = SIMPLEBUTTON(WORD_Parent),
1796 End,
1797 Child, VGroup,
1798 Child, gadgets.buttons[GB_RENAME] = SIMPLEBUTTON(WORD_Rename),
1799 Child, gadgets.buttons[GB_DOSENVEC] = SIMPLEBUTTON(WORD_DosEnvec),
1800 End,
1801 Child, VGroup,
1802 Child, gadgets.buttons[GB_SWITCHES] = SIMPLEBUTTON(WORD_Switches),
1803 Child, HVSpace,
1804 End,
1805 End,
1806 Child, HGroup,
1807 MUIA_Group_SameWidth, TRUE,
1808 MUIA_FixHeight, 1,
1809 Child, gadgets.buttons[GB_SAVE_CHANGES] = IMAGEBUTTON(WORD_Save_Changes, COOL_SAVEIMAGE_ID),
1810 Child, gadgets.buttons[GB_EXIT] = IMAGEBUTTON(WORD_Exit, COOL_CANCELIMAGE_ID),
1811 End,
1812 End,
1813 End,
1814 End,
1815 SubWindow, adddevicegadgets.win = WindowObject,
1816 MUIA_Window_Title, MSG(WORD_Devices),
1817 MUIA_Window_Activate, TRUE,
1818 WindowContents, VGroup,
1819 Child, PopaslObject,
1820 MUIA_Popstring_String, adddevicegadgets.file = StringObject,
1821 StringFrame,
1822 End,
1823 MUIA_Popstring_Button, PopButton(MUII_PopFile),
1824 End,
1825 Child, HGroup,
1826 MUIA_Group_SameWidth, TRUE,
1827 MUIA_FixHeight, 1,
1828 Child, adddevicegadgets.ok = IMAGEBUTTON(WORD_Ok, COOL_USEIMAGE_ID),
1829 Child, adddevicegadgets.cancel = IMAGEBUTTON(WORD_Cancel, COOL_CANCELIMAGE_ID),
1830 End,
1831 End,
1832 End,
1833 SubWindow, addpartitiongadgets.win = WindowObject,
1834 MUIA_Window_Title, MSG(MSG_Select_Empty_Area),
1835 MUIA_Window_Activate, TRUE,
1836 WindowContents, VGroup,
1837 Child, addpartitiongadgets.pt = BoopsiObject,
1838 GroupFrame,
1839 MUIA_Boopsi_Class, ptclass,
1840 MUIA_Boopsi_MinWidth, 600,
1841 MUIA_Boopsi_MinHeight, 100,
1842 MUIA_Boopsi_TagDrawInfo, GA_DrawInfo,
1843 MUIA_Boopsi_Remember, PTCT_PartitionTable,
1844 MUIA_Boopsi_Remember, PTCT_Flags,
1845 PTCT_Flags, PTCTF_NoPartitionMove | PTCTF_EmptySelectOnly,
1846 GA_Left, 0,
1847 GA_Top, 0,
1848 GA_Width, 0,
1849 GA_Height, 0,
1850 GA_DrawInfo, 0,
1851 MUIA_VertWeight, 10,
1852 ICA_TARGET, ICTARGET_IDCMP,
1853 End,
1854 Child, HGroup,
1855 MUIA_Group_SameWidth, TRUE,
1856 MUIA_FixHeight, 1,
1857 Child, addpartitiongadgets.ok = IMAGEBUTTON(WORD_Ok, COOL_USEIMAGE_ID),
1858 Child, addpartitiongadgets.cancel = IMAGEBUTTON(WORD_Cancel, COOL_CANCELIMAGE_ID),
1859 End,
1860 End,
1861 End,
1862 SubWindow, partitiontypegadgets.win = WindowObject,
1863 MUIA_Window_Title, MSG(WORD_Partition_Type),
1864 MUIA_Window_Activate, TRUE,
1865 WindowContents, VGroup,
1866 Child, partitiontypegadgets.lv = ListviewObject,
1867 MUIA_Listview_List, ListObject,
1868 InputListFrame,
1869 MUIA_List_ConstructHook, MUIV_List_ConstructHook_String,
1870 MUIA_List_DestructHook, MUIV_List_DestructHook_String,
1871 MUIA_List_Title, TRUE,
1872 End,
1873 End,
1874 Child, HGroup,
1875 Child, partitiontypegadgets.base = CycleObject,
1876 ButtonFrame,
1877 MUIA_Cycle_Entries, editcycleentries,
1878 MUIA_HorizWeight, 1,
1879 End,
1880 Child, partitiontypegadgets.hexid = StringObject,
1881 StringFrame,
1882 MUIA_String_EditHook, &partitiontypegadgets.hook_hexidedit,
1883 End,
1884 End,
1885 Child, HGroup,
1886 MUIA_Group_SameWidth, TRUE,
1887 MUIA_FixHeight, 1,
1888 Child, partitiontypegadgets.ok = IMAGEBUTTON(WORD_Ok, COOL_USEIMAGE_ID),
1889 Child, partitiontypegadgets.cancel = IMAGEBUTTON(WORD_Cancel, COOL_CANCELIMAGE_ID),
1890 End,
1891 End,
1892 End,
1893 SubWindow, partitiontabletypegadgets.win = WindowObject,
1894 MUIA_Window_Title, MSG(WORD_Partition_Table_Type),
1895 MUIA_Window_Activate, TRUE,
1896 WindowContents, VGroup,
1897 Child, partitiontabletypegadgets.lv = ListviewObject,
1898 MUIA_Listview_List, ListObject,
1899 InputListFrame,
1900 MUIA_List_ConstructHook, MUIV_List_ConstructHook_String,
1901 MUIA_List_DestructHook, MUIV_List_DestructHook_String,
1902 MUIA_List_Title, TRUE,
1903 End,
1904 End,
1905 Child, HGroup,
1906 MUIA_Group_SameWidth, TRUE,
1907 MUIA_FixHeight, 1,
1908 Child, partitiontabletypegadgets.ok = IMAGEBUTTON(WORD_Ok, COOL_USEIMAGE_ID),
1909 Child, partitiontabletypegadgets.cancel = IMAGEBUTTON(WORD_Cancel, COOL_CANCELIMAGE_ID),
1910 End,
1911 End,
1912 End,
1913 SubWindow, resizemovegadgets.win = WindowObject,
1914 MUIA_Window_Title, MSG(MSG_Select_Partition_Resize_Move),
1915 MUIA_Window_Activate, TRUE,
1916 WindowContents, VGroup,
1917 Child, resizemovegadgets.pt = BoopsiObject,
1918 GroupFrame,
1919 MUIA_Boopsi_Class, ptclass,
1920 MUIA_Boopsi_MinWidth, 600,
1921 MUIA_Boopsi_MinHeight, 100,
1922 MUIA_Boopsi_TagDrawInfo, GA_DrawInfo,
1923 MUIA_Boopsi_Remember, PTCT_PartitionTable,
1924 MUIA_Boopsi_Remember, PTCT_Flags,
1925 PTCT_Flags, 0,
1926 GA_Left, 0,
1927 GA_Top, 0,
1928 GA_Width, 0,
1929 GA_Height, 0,
1930 GA_DrawInfo, 0,
1931 MUIA_VertWeight, 10,
1932 ICA_TARGET, ICTARGET_IDCMP,
1933 End,
1934 Child, VGroup,
1935 GroupFrame,
1936 MUIA_FrameTitle, MSG(WORD_Geometry),
1937 Child, HGroup,
1938 Child, VGroup,
1939 Child, HGroup,
1940 Child, Label2("Low Cyl"),
1941 Child, resizemovegadgets.lowcyl=StringObject,
1942 StringFrame,
1943 MUIA_String_Integer, 0,
1944 MUIA_String_Accept, "0123456789",
1945 End,
1946 End,
1947 Child, HGroup,
1948 Child, Label2("High Cyl"),
1949 Child, resizemovegadgets.highcyl=StringObject,
1950 StringFrame,
1951 MUIA_String_Integer, 0,
1952 MUIA_String_Accept, "0123456789",
1953 End,
1954 End,
1955 Child, HGroup,
1956 Child, Label2("Total Cyl"),
1957 Child, resizemovegadgets.totalcyl=StringObject,
1958 StringFrame,
1959 MUIA_String_Integer, 0,
1960 MUIA_String_Accept, "0123456789",
1961 End,
1962 End,
1963 MUIA_HorizWeight, 10,
1964 End,
1965 Child, Label2("Size"),
1966 Child, resizemovegadgets.size=StringObject,
1967 ButtonFrame,
1968 MUIA_String_Accept, "0123456789GM.",
1969 MUIA_HorizWeight, 3,
1970 End,
1971 End,
1972 End,
1973 Child, HGroup,
1974 MUIA_Group_SameWidth, TRUE,
1975 MUIA_FixHeight, 1,
1976 Child, resizemovegadgets.ok = IMAGEBUTTON(WORD_Ok, COOL_USEIMAGE_ID),
1977 Child, resizemovegadgets.cancel = IMAGEBUTTON(WORD_Cancel, COOL_CANCELIMAGE_ID),
1978 End,
1979 End,
1980 End,
1981 SubWindow, renamegadgets.win = WindowObject,
1982 MUIA_Window_Title, MSG(WORD_Rename),
1983 MUIA_Window_Activate, TRUE,
1984 WindowContents, VGroup,
1985 Child, renamegadgets.name = StringObject,
1986 StringFrame,
1987 End,
1988 Child, HGroup,
1989 MUIA_Group_SameWidth, TRUE,
1990 MUIA_FixHeight, 1,
1991 Child, renamegadgets.ok = IMAGEBUTTON(WORD_Ok, COOL_USEIMAGE_ID),
1992 Child, renamegadgets.cancel = IMAGEBUTTON(WORD_Cancel, COOL_CANCELIMAGE_ID),
1993 End,
1994 End,
1995 End,
1996 SubWindow, dosenvecgadgets.win = WindowObject,
1997 MUIA_Window_Title, MSG(WORD_DosEnvec),
1998 MUIA_Window_Activate, TRUE,
1999 WindowContents, VGroup,
2000 Child, VGroup,
2001 GroupFrame,
2002 Child, HGroup,
2003 Child, Label2("Mask"),
2004 Child, dosenvecgadgets.mask=StringObject,
2005 StringFrame,
2006 MUIA_String_Integer, -2,
2007 MUIA_String_Accept, "0123456789",
2008 End,
2009 End,
2010 Child, HGroup,
2011 Child, Label2("MaxTransfer"),
2012 Child, dosenvecgadgets.maxtransfer=StringObject,
2013 StringFrame,
2014 MUIA_String_Contents, "0x7FFFFF",
2015 MUIA_String_Accept, "0123456789x",
2016 End,
2017 End,
2018 End,
2019 Child, VGroup,
2020 GroupFrame,
2021 Child, HGroup,
2022 Child, Label("_Custom Bootcode"),
2023 Child, HVSpace,
2024 Child, dosenvecgadgets.custboot=MUI_MakeObject
2025 (
2026 MUIO_Checkmark,
2027 (IPTR)"_Custom Bootcode"
2028 ),
2029 End,
2030 Child, HGroup,
2031 Child, Label2("Nr. of Custom Bootblocks"),
2032 Child, dosenvecgadgets.numcustboot=StringObject,
2033 StringFrame,
2034 MUIA_String_Integer, 0,
2035 MUIA_String_Accept, "0123456789",
2036 End,
2037 End,
2038 End,
2039 Child, VGroup,
2040 GroupFrame,
2041 MUIA_FrameTitle, "Reserved Blocks at",
2042 Child, HGroup,
2043 Child, Label2("Beginning"),
2044 Child, dosenvecgadgets.reservedblocksstart=StringObject,
2045 StringFrame,
2046 MUIA_String_Integer, 0,
2047 MUIA_String_Accept, "0123456789",
2048 End,
2049 End,
2050 Child, HGroup,
2051 Child, Label2("End"),
2052 Child, dosenvecgadgets.reservedblocksend=StringObject,
2053 StringFrame,
2054 MUIA_String_Integer, 0,
2055 MUIA_String_Accept, "0123456789",
2056 End,
2057 End,
2058 End,
2059 Child, VGroup,
2060 GroupFrame,
2061 Child, HGroup,
2062 Child, Label("BlockSize"),
2063 Child, dosenvecgadgets.blocksize=CycleObject,
2064 ButtonFrame,
2065 MUIA_Cycle_Entries, blocksizecycleentries,
2066 End,
2067 End,
2068 Child, HGroup,
2069 Child, Label2("Buffers"),
2070 Child, dosenvecgadgets.buffers=StringObject,
2071 StringFrame,
2072 MUIA_String_Integer, 20,
2073 MUIA_String_Accept, "0123456789",
2074 End,
2075 End,
2076 End,
2077 Child, HGroup,
2078 MUIA_Group_SameWidth, TRUE,
2079 MUIA_FixHeight, 1,
2080 Child, dosenvecgadgets.ok = IMAGEBUTTON(WORD_Ok, COOL_USEIMAGE_ID),
2081 Child, dosenvecgadgets.cancel = IMAGEBUTTON(WORD_Cancel, COOL_CANCELIMAGE_ID),
2082 End,
2083 End,
2084 End,
2085 SubWindow, mountbootgadgets.win = WindowObject,
2086 MUIA_Window_Title, MSG(WORD_Switches),
2087 MUIA_Window_Activate, TRUE,
2088 WindowContents, VGroup,
2089 Child, HGroup,
2090 Child, Label(MSG(WORD_Active)),
2091 Child, HVSpace,
2092 Child, mountbootgadgets.active=MUI_MakeObject
2093 (
2094 MUIO_Checkmark,
2095 MSG(WORD_Active)
2096 ),
2097 End,
2098 Child, HGroup,
2099 Child, Label(MSG(WORD_Automount)),
2100 Child, HVSpace,
2101 Child, mountbootgadgets.automount=MUI_MakeObject
2102 (
2103 MUIO_Checkmark,
2104 MSG(WORD_Automount)
2105 ),
2106 End,
2107 Child, HGroup,
2108 Child, Label(MSG(WORD_Bootable)),
2109 Child, HVSpace,
2110 Child, mountbootgadgets.bootable=MUI_MakeObject
2111 (
2112 MUIO_Checkmark,
2113 MSG(WORD_Bootable)
2114 ),
2115 End,
2116 Child, HGroup,
2117 Child, Label(MSG(WORD_BootPri)),
2118 Child, mountbootgadgets.bootpri=StringObject,
2119 StringFrame,
2120 MUIA_String_Integer, 0,
2121 MUIA_String_Accept, "-0123456789",
2122 End,
2123 End,
2124 Child, HGroup,
2125 MUIA_Group_SameWidth, TRUE,
2126 MUIA_FixHeight, 1,
2127 Child, mountbootgadgets.ok = IMAGEBUTTON(WORD_Ok, COOL_USEIMAGE_ID),
2128 Child, mountbootgadgets.cancel = IMAGEBUTTON(WORD_Cancel, COOL_CANCELIMAGE_ID),
2129 End,
2130 End,
2131 End,
2132 End;
2133
2134 if (!app)
2135 return ERR_GADGETS;
2136
2137 /* Main Window */
2138 DoMethod
2139 (
2140 mainwin, MUIM_Notify, MUIA_Window_CloseRequest, TRUE, (IPTR)app, 2,
2141 MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit
2142 );
2143 DoMethod
2144 (
2145 gadgets.buttons[GB_EXIT], MUIM_Notify, MUIA_Pressed, FALSE, (IPTR)app, 2,
2146 MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit
2147 );
2148 DoMethod
2149 (
2150 gadgets.leftlv,
2151 MUIM_Notify, MUIA_Listview_DoubleClick, TRUE, (IPTR)gadgets.leftlv, 2,
2152 MUIM_CallHook, (IPTR)&hook_lv_doubleclick
2153 );
2154 DoMethod
2155 (
2156 gadgets.leftlv,
2157 MUIM_Notify, MUIA_Listview_SelectChange, TRUE, (IPTR)gadgets.leftlv, 2,
2158 MUIM_CallHook, (IPTR)&hook_lv_click
2159 );
2160 for (i=GB_FIRST;i<GB_EXIT;i++)
2161 {
2162 DoMethod
2163 (
2164 gadgets.buttons[i],
2165 MUIM_Notify, MUIA_Pressed, FALSE, (IPTR)gadgets.buttons[i], 2,
2166 MUIM_CallHook, (IPTR)&hook_buttons
2167 );
2168 /* MUIM_CallHook, hook */
2169 }
2170 disableObject(gadgets.buttons[GB_REMOVE_ENTRY]);
2171 disableObject(gadgets.buttons[GB_CREATE_TABLE]);
2172 disableObject(gadgets.buttons[GB_CHANGE_TYPE]);
2173 disableObject(gadgets.buttons[GB_RESIZE_MOVE]);
2174 disableObject(gadgets.buttons[GB_PARENT]);
2175 disableObject(gadgets.buttons[GB_RENAME]);
2176 disableObject(gadgets.buttons[GB_DOSENVEC]);
2177 disableObject(gadgets.buttons[GB_SWITCHES]);
2178 disableObject(gadgets.buttons[GB_SAVE_CHANGES]);
2179 DoMethod
2180 (
2181 quit_item,
2182 MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime, (IPTR)app, 2,
2183 MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit
2184 );
2185 DoMethod(createml_item,
2186 MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime, app, 2,
2187 MUIM_CallHook, &hook_createml);
2188 /* add device window */
2189 DoMethod
2190 (
2191 adddevicegadgets.win,
2192 MUIM_Notify, MUIA_Window_Open, TRUE, (IPTR)mainwin, 3,
2193 MUIM_Set, MUIA_Window_Sleep, TRUE
2194 );
2195 DoMethod
2196 (
2197 adddevicegadgets.win,
2198 MUIM_Notify, MUIA_Window_Open, FALSE, (IPTR)mainwin, 3,
2199 MUIM_Set, MUIA_Window_Sleep, FALSE
2200 );
2201 DoMethod
2202 (
2203 adddevicegadgets.win,
2204 MUIM_Notify, MUIA_Window_CloseRequest, TRUE, (IPTR)adddevicegadgets.win, 3,
2205 MUIM_Set, MUIA_Window_Open, FALSE
2206 );
2207 DoMethod
2208 (
2209 adddevicegadgets.ok,
2210 MUIM_Notify, MUIA_Pressed, FALSE, (IPTR)adddevicegadgets.ok, 2,
2211 MUIM_CallHook, (IPTR)&hook_buttons
2212 );
2213 DoMethod
2214 (
2215 adddevicegadgets.ok,
2216 MUIM_Notify, MUIA_Pressed, FALSE, (IPTR)adddevicegadgets.win, 3,
2217 MUIM_Set, MUIA_Window_Open, FALSE
2218 );
2219 DoMethod
2220 (
2221 adddevicegadgets.cancel,
2222 MUIM_Notify, MUIA_Pressed, FALSE, (IPTR)adddevicegadgets.win, 3,
2223 MUIM_Set, MUIA_Window_Open, FALSE
2224 );
2225 /* add partition window */
2226 DoMethod
2227 (
2228 addpartitiongadgets.win,
2229 MUIM_Notify, MUIA_Window_CloseRequest, TRUE, (IPTR)addpartitiongadgets.win, 3,
2230 MUIM_Set, MUIA_Window_Open, FALSE
2231 );
2232 DoMethod
2233 (
2234 addpartitiongadgets.ok,
2235 MUIM_Notify, MUIA_Pressed, FALSE, (IPTR)addpartitiongadgets.ok, 2,
2236 MUIM_CallHook, (IPTR)&hook_buttons
2237 );
2238 DoMethod
2239 (
2240 addpartitiongadgets.ok,
2241 MUIM_Notify, MUIA_Pressed, FALSE, (IPTR)addpartitiongadgets.win, 3,
2242 MUIM_Set, MUIA_Window_Open, FALSE
2243 );
2244 DoMethod
2245 (
2246 addpartitiongadgets.cancel,
2247 MUIM_Notify, MUIA_Pressed, FALSE, (IPTR)addpartitiongadgets.win, 3,
2248 MUIM_Set, MUIA_Window_Open, FALSE
2249 );
2250 DoMethod
2251 (
2252 addpartitiongadgets.pt,
2253 MUIM_Notify, PTCT_Selected, TRUE, (IPTR)addpartitiongadgets.pt, 2,
2254 MUIM_CallHook, (IPTR)&hook_buttons
2255 );
2256 /* partition type window */
2257 DoMethod
2258 (
2259 partitiontypegadgets.win,
2260 MUIM_Notify, MUIA_Window_CloseRequest, TRUE, (IPTR)partitiontypegadgets.win, 3,
2261 MUIM_Set, MUIA_Window_Open, FALSE
2262 );
2263 DoMethod
2264 (
2265 partitiontypegadgets.hexid,
2266 MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
2267 (IPTR)partitiontypegadgets.hexid, 2,
2268 MUIM_CallHook, (IPTR)&hook_buttons
2269 );
2270 /* "FIXME: notify doesn't work" */
2271 DoMethod
2272 (
2273 partitiontypegadgets.ok,
2274 MUIM_Notify, MUIA_Pressed, FALSE, (IPTR)partitiontypegadgets.ok, 2,
2275 MUIM_CallHook, (IPTR)&hook_buttons
2276 );
2277 DoMethod
2278 (
2279 partitiontypegadgets.ok,
2280 MUIM_Notify, MUIA_Pressed, FALSE, (IPTR)partitiontypegadgets.win, 3,
2281 MUIM_Set, MUIA_Window_Open, FALSE
2282 );
2283 DoMethod
2284 (
2285 partitiontypegadgets.cancel,
2286 MUIM_Notify, MUIA_Pressed, FALSE, (IPTR)partitiontypegadgets.win, 3,
2287 MUIM_Set, MUIA_Window_Open, FALSE
2288 );
2289 DoMethod
2290 (
2291 partitiontypegadgets.lv,
2292 MUIM_Notify, MUIA_Listview_SelectChange, TRUE, (IPTR)partitiontypegadgets.lv, 2,
2293 MUIM_CallHook, (IPTR)&hook_buttons
2294 );
2295 /* partition table type window */
2296 DoMethod
2297 (
2298 partitiontabletypegadgets.win,
2299 MUIM_Notify, MUIA_Window_CloseRequest, TRUE, (IPTR)partitiontabletypegadgets.win, 3,
2300 MUIM_Set, MUIA_Window_Open, FALSE
2301 );
2302 DoMethod
2303 (
2304 partitiontabletypegadgets.ok,
2305 MUIM_Notify, MUIA_Pressed, FALSE, (IPTR)partitiontabletypegadgets.ok, 2,
2306 MUIM_CallHook, (IPTR)&hook_buttons
2307 );
2308 DoMethod
2309 (
2310 partitiontabletypegadgets.ok,
2311 MUIM_Notify, MUIA_Pressed, FALSE, (IPTR)partitiontabletypegadgets.win, 3,
2312 MUIM_Set, MUIA_Window_Open, FALSE
2313 );
2314 DoMethod
2315 (
2316 partitiontabletypegadgets.cancel,
2317 MUIM_Notify, MUIA_Pressed, FALSE, (IPTR)partitiontabletypegadgets.win, 3,
2318 MUIM_Set, MUIA_Window_Open, FALSE
2319 );
2320 /* resize/move window */
2321 DoMethod
2322 (
2323 resizemovegadgets.win,
2324 MUIM_Notify, MUIA_Window_CloseRequest, TRUE, (IPTR)resizemovegadgets.win, 3,
2325 MUIM_Set, MUIA_Window_Open, FALSE
2326 );
2327 DoMethod
2328 (
2329 resizemovegadgets.ok,
2330 MUIM_Notify, MUIA_Pressed, FALSE, (IPTR)resizemovegadgets.ok, 2,
2331 MUIM_CallHook, (IPTR)&hook_buttons
2332 );
2333 DoMethod
2334 (
2335 resizemovegadgets.ok,
2336 MUIM_Notify, MUIA_Pressed, FALSE, (IPTR)resizemovegadgets.win, 3,
2337 MUIM_Set, MUIA_Window_Open, FALSE
2338 );
2339 DoMethod
2340 (
2341 resizemovegadgets.size,
2342 MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
2343 (IPTR)resizemovegadgets.size, 2,
2344 MUIM_CallHook, (IPTR)&hook_buttons
2345 );
2346 DoMethod
2347 (
2348 resizemovegadgets.cancel,
2349 MUIM_Notify, MUIA_Pressed, FALSE, (IPTR)resizemovegadgets.cancel, 2,
2350 MUIM_CallHook, (IPTR)&hook_buttons
2351 );
2352 DoMethod
2353 (
2354 resizemovegadgets.cancel,
2355 MUIM_Notify, MUIA_Pressed, FALSE, (IPTR)resizemovegadgets.win, 3,
2356 MUIM_Set, MUIA_Window_Open, FALSE
2357 );
2358 DoMethod
2359 (
2360 resizemovegadgets.pt,
2361 MUIM_Notify, PTCT_Selected, TRUE, (IPTR)resizemovegadgets.pt, 3,
2362 MUIM_CallHook, (IPTR)&hook_buttons, PTCT_Selected
2363 );
2364 DoMethod
2365 (
2366 resizemovegadgets.pt,
2367 MUIM_Notify, PTCT_PartitionMove, TRUE, (IPTR)resizemovegadgets.pt, 3,
2368 MUIM_CallHook, (IPTR)&hook_buttons, PTCT_PartitionMove
2369 );
2370 DoMethod
2371 (
2372 resizemovegadgets.highcyl,
2373 MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime, (IPTR)resizemovegadgets.highcyl, 2,
2374 MUIM_CallHook, (IPTR)&hook_buttons
2375 );
2376 DoMethod
2377 (
2378 resizemovegadgets.lowcyl,
2379 MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime, (IPTR)resizemovegadgets.lowcyl, 2,
2380 MUIM_CallHook, (IPTR)&hook_buttons
2381 );
2382 DoMethod
2383 (
2384 resizemovegadgets.totalcyl,
2385 MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime, (IPTR)resizemovegadgets.totalcyl, 2,
2386 MUIM_CallHook, (IPTR)&hook_buttons
2387 );
2388 /* rename window */
2389 DoMethod
2390 (
2391 renamegadgets.win,
2392 MUIM_Notify, MUIA_Window_CloseRequest, TRUE, (IPTR)renamegadgets.win, 3,
2393 MUIM_Set, MUIA_Window_Open, FALSE
2394 );
2395 DoMethod
2396 (
2397 renamegadgets.ok,
2398 MUIM_Notify, MUIA_Pressed, FALSE, (IPTR)renamegadgets.ok, 2,
2399 MUIM_CallHook, (IPTR)&hook_buttons
2400 );
2401 DoMethod
2402 (
2403 renamegadgets.ok,
2404 MUIM_Notify, MUIA_Pressed, FALSE, (IPTR)renamegadgets.win, 3,
2405 MUIM_Set, MUIA_Window_Open, FALSE
2406 );
2407 DoMethod
2408 (
2409 renamegadgets.cancel,
2410 MUIM_Notify, MUIA_Pressed, FALSE, (IPTR)renamegadgets.win, 3,
2411 MUIM_Set, MUIA_Window_Open, FALSE
2412 );
2413 /* dosenvec window */
2414 DoMethod
2415 (
2416 dosenvecgadgets.win,
2417 MUIM_Notify, MUIA_Window_CloseRequest, TRUE, (IPTR)dosenvecgadgets.win, 3,
2418 MUIM_Set, MUIA_Window_Open, FALSE
2419 );
2420 DoMethod
2421 (
2422 dosenvecgadgets.ok,
2423 MUIM_Notify, MUIA_Pressed, FALSE, (IPTR)dosenvecgadgets.ok, 2,
2424 MUIM_CallHook, (IPTR)&hook_buttons
2425 );
2426 DoMethod
2427 (
2428 dosenvecgadgets.ok,
2429 MUIM_Notify, MUIA_Pressed, FALSE, (IPTR)dosenvecgadgets.win, 3,
2430 MUIM_Set, MUIA_Window_Open, FALSE
2431 );
2432 DoMethod
2433 (
2434 dosenvecgadgets.cancel,
2435 MUIM_Notify, MUIA_Pressed, FALSE, (IPTR)dosenvecgadgets.win, 3,
2436 MUIM_Set, MUIA_Window_Open, FALSE
2437 );
2438 /* automount/boot window */
2439 DoMethod
2440 (
2441 mountbootgadgets.win,
2442 MUIM_Notify, MUIA_Window_CloseRequest, TRUE, (IPTR)mountbootgadgets.win, 3,
2443 MUIM_Set, MUIA_Window_Open, FALSE
2444 );
2445 DoMethod
2446 (
2447 mountbootgadgets.ok,
2448 MUIM_Notify, MUIA_Pressed, FALSE, (IPTR)mountbootgadgets.ok, 2,
2449 MUIM_CallHook, (IPTR)&hook_buttons
2450 );
2451 DoMethod
2452 (
2453 mountbootgadgets.ok,
2454 MUIM_Notify, MUIA_Pressed, FALSE, (IPTR)mountbootgadgets.win, 3,
2455 MUIM_Set, MUIA_Window_Open, FALSE
2456 );
2457 DoMethod
2458 (
2459 mountbootgadgets.cancel,
2460 MUIM_Notify, MUIA_Pressed, FALSE, (IPTR)mountbootgadgets.win, 3,
2461 MUIM_Set, MUIA_Window_Open, FALSE
2462 );
2463 set(mainwin, MUIA_Window_Open, TRUE);
2464 return 0;
2465 }
2466
2467 void deinitGUI()
2468 {
2469 D(bug("[HDToolBox] deinitGUI()\n"));
2470
2471 if (app)
2472 MUI_DisposeObject(app);
2473 if (ptclass != NULL)
2474 FreeClass(ptclass);
2475 if (MUIMasterBase)
2476 CloseLibrary(MUIMasterBase);
2477 }
2478
2479 BOOL QuitGUI(ULONG *sigs)
2480 {
2481 // moved debug from this place because it produces too much garbage
2482
2483 if ((IPTR)DoMethod(app, MUIM_Application_NewInput, (IPTR)sigs) == MUIV_Application_ReturnID_Quit)
2484 {
2485 D(bug("[HDToolBox] QuitGUI()\n"));
2486 return TRUE;
2487 }
2488 return FALSE;
2489 }
Mirror of AROS' svn.