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