pack/unarc/unarcgroup_class.c

   1 /*
   2     Copyright © 2012, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <proto/dos.h>
   7 #include <proto/muimaster.h>
   8 #include <proto/intuition.h>
   9 #include <proto/asl.h>
  10 #include <proto/utility.h>
  11 #include <proto/xadmaster.h>
  12 #include <proto/alib.h>
  13
  14 //#define DEBUG 1
  15 #include <aros/debug.h>
  16
  17 #include <libraries/mui.h>
  18 #include <mui/NList_mcc.h>
  19 #include <mui/NListview_mcc.h>
  20 #include <zune/customclasses.h>
  21
  22 #include <stdio.h>
  23
  24 #include "unarcgroup_class.h"
  25 #include "locale.h"
  26
  27 #define PATHNAMESIZE (1024)
  28
  29
  30 struct UnarcGroup_DATA
  31 {
  32     Object *btn_all, *btn_none, *btn_invert, *btn_start, *btn_cancel;
  33     Object *str_file, *str_targetdir, *lst_content, *ga_progress;
  34     Object *txt_status_total, *txt_status_select;
  35     struct Hook start_hook, change_selection_hook, read_file_hook, expand_dest_hook;
  36     struct xadArchiveInfo *ai;
  37     ULONG total_entry_cnt;
  38     ULONG total_size;
  39     ULONG select_entry_cnt;
  40     ULONG select_size;
  41     STRPTR targetpathname;
  42 };
  43
  44
  45 struct Listentry
  46 {
  47     BOOL selected;
  48     struct xadFileInfo *fi;
  49 };
  50
  51 static struct Hook list_display_hook, list_constr_hook, list_destr_hook;
  52
  53 enum
  54 {
  55     INVERTSINGLE,
  56     INVERTALL,
  57     CLEARALL,
  58     SETALL
  59 };
  60
  61
  62 static STRPTR alloc_name_from_lock(CONST_STRPTR filename)
  63 {
  64     STRPTR result = NULL;
  65     STRPTR buffer = AllocVec(PATHNAMESIZE, MEMF_ANY);
  66     if (buffer)
  67     {
  68         BPTR lock = Lock(filename, ACCESS_READ);
  69         if (lock)
  70         {
  71             if (NameFromLock(lock, buffer, PATHNAMESIZE))
  72             {
  73                 result = buffer;
  74             }
  75             UnLock(lock);
  76         }
  77     }
  78     return result;
  79 }
  80
  81
  82 static BOOL is_file(CONST_STRPTR filename)
  83 {
  84     if (filename == NULL)
  85     {
  86         return FALSE;
  87     }
  88
  89     BOOL retval = FALSE;
  90
  91     BPTR lock = Lock(filename, ACCESS_READ);
  92     if (lock)
  93     {
  94         struct FileInfoBlock *fib = AllocDosObject(DOS_FIB, NULL);
  95         if (fib)
  96         {
  97             BOOL ex = Examine(lock, fib);
  98             if (ex)
  99             {
 100                 D(bug("[is_file] file %s direntry_type %d\n", filename, fib->fib_DirEntryType));
 101                 if (fib->fib_DirEntryType < 0) // File
 102                 {
 103                     retval = TRUE;
 104                 }
 105             }
 106             FreeDosObject(DOS_FIB, fib);
 107         }
 108         UnLock(lock);
 109     }
 110     return retval;
 111 }
 112
 113
 114 AROS_UFH3(APTR, list_constr_func,
 115     AROS_UFHA(struct Hook *, h, A0),
 116     AROS_UFHA(APTR, pool, A2),
 117     AROS_UFHA(struct Listentry *, li, A1))
 118 {
 119     AROS_USERFUNC_INIT
 120
 121     struct Listentry *newentry = AllocPooled(pool, sizeof(struct Listentry));
 122     if (newentry)
 123     {
 124         *newentry = *li;
 125     }
 126     return newentry;
 127
 128     AROS_USERFUNC_EXIT
 129 }
 130
 131
 132 AROS_UFH3(void, list_destr_func,
 133     AROS_UFHA(struct Hook *, h, A0),
 134     AROS_UFHA(APTR, pool, A2),
 135     AROS_UFHA(struct Listentry *, li, A1))
 136 {
 137     AROS_USERFUNC_INIT
 138
 139     FreePooled(pool, li, sizeof(struct Listentry));
 140
 141     AROS_USERFUNC_EXIT
 142 }
 143
 144
 145 AROS_UFH3S(LONG, list_display_func,
 146     AROS_UFHA(struct Hook *, h, A0),
 147     AROS_UFHA(char **, array, A2),
 148     AROS_UFHA(struct Listentry *, li, A1))
 149 {
 150     AROS_USERFUNC_INIT
 151
 152     if (li)
 153     {
 154         static TEXT protbuf[8], sizebuf[20], crsizebuf[20], percentbuf[8];
 155         static TEXT datebuf[20], timebuf[20];
 156         struct DateTime dt;
 157
 158         // Protection bits
 159         protbuf[0] = li->fi->xfi_Protection & FIBF_SCRIPT  ? 's' : '-';
 160         protbuf[1] = li->fi->xfi_Protection & FIBF_PURE    ? 'p' : '-';
 161         protbuf[2] = li->fi->xfi_Protection & FIBF_ARCHIVE ? 'a' : '-';
 162
 163         // The following bits are high-active!
 164         protbuf[3] = li->fi->xfi_Protection & FIBF_READ    ? '-' : 'r';
 165         protbuf[4] = li->fi->xfi_Protection & FIBF_WRITE   ? '-' : 'w';
 166         protbuf[5] = li->fi->xfi_Protection & FIBF_EXECUTE ? '-' : 'e';
 167         protbuf[6] = li->fi->xfi_Protection & FIBF_DELETE  ? '-' : 'd';
 168         protbuf[7] = '\0';
 169
 170         // Sizes
 171         snprintf(sizebuf, sizeof sizebuf, "%lu", (long unsigned int)li->fi->xfi_Size);
 172         snprintf(crsizebuf, sizeof crsizebuf, "%lu", (long unsigned int)li->fi->xfi_CrunchSize);
 173         if (li->fi->xfi_Size)
 174         {
 175             snprintf(percentbuf, sizeof percentbuf, "%u %%", (unsigned int)(100 - li->fi->xfi_CrunchSize * 100 / li->fi->xfi_Size));
 176         }
 177         else
 178         {
 179             strlcpy(percentbuf, "100 %", sizeof percentbuf);
 180         }
 181
 182         // Date
 183         datebuf[0] = '\0';
 184         timebuf[0] = '\0';
 185         dt.dat_Format = FORMAT_DEF;
 186         dt.dat_Flags = 0;
 187         dt.dat_StrDay = NULL;
 188         dt.dat_StrDate = datebuf;
 189         dt.dat_StrTime = timebuf;
 190         if (xadConvertDates(XAD_DATEXADDATE, &li->fi->xfi_Date, XAD_GETDATEDATESTAMP, &dt, TAG_DONE) == 0)
 191         {
 192             DateToStr(&dt);
 193         }
 194
 195         if (li->selected)
 196         {
 197             *array++ = "\033I[5:PROGDIR:Images/selected]";
 198         }
 199         else
 200         {
 201             *array++ = "\033I[5:PROGDIR:Images/unselected]";
 202         }
 203         *array++ = li->fi->xfi_FileName;
 204         *array++ = protbuf;
 205         *array++ = sizebuf;
 206         *array++ = crsizebuf;
 207         *array++ = percentbuf;
 208         *array++ = datebuf;
 209         *array++ = timebuf;
 210     }
 211     else
 212     {
 213         *array++ = "";
 214         *array++ = (STRPTR)_(MSG_LBL_NAME);
 215         *array++ = (STRPTR)_(MSG_LBL_PROTECTION);
 216         *array++ = (STRPTR)_(MSG_LBL_SIZE);
 217         *array++ = (STRPTR)_(MSG_LBL_PACKSIZE);
 218         *array++ = (STRPTR)_(MSG_LBL_RATE);
 219         *array++ = (STRPTR)_(MSG_LBL_DATE);
 220         *array++ = (STRPTR)_(MSG_LBL_TIME);
 221     }
 222
 223     return 0;
 224
 225     AROS_USERFUNC_EXIT
 226 }
 227
 228
 229 AROS_UFH3S(void, change_selection_func,
 230     AROS_UFHA(struct Hook *, h, A0),
 231     AROS_UFHA(Object *, obj, A2),
 232     AROS_UFHA(APTR, msg, A1))
 233 {
 234     AROS_USERFUNC_INIT
 235
 236     struct UnarcGroup_DATA *data = h->h_Data;
 237     ULONG status = *(ULONG *)msg;
 238     struct Listentry *oldentry, newentry;
 239     LONG i;
 240     TEXT buffer[50];
 241
 242     D(bug("[change_selection_func] status %u\n", status));
 243
 244     SET(data->lst_content, MUIA_List_Quiet, TRUE);
 245
 246     switch(status)
 247     {
 248         case SETALL:
 249             data->select_size = data->total_size;
 250             data->select_entry_cnt = data->total_entry_cnt;
 251             for (i = 0; ; i++)
 252             {
 253                 DoMethod(data->lst_content, MUIM_NList_GetEntry, i, &oldentry);
 254                 if (!oldentry)
 255                     break;
 256                 if (!oldentry->selected)
 257                 {
 258                     newentry.selected = TRUE;
 259                     newentry.fi = oldentry->fi;
 260                     DoMethod(data->lst_content, MUIM_NList_Remove, i);
 261                     DoMethod(data->lst_content, MUIM_NList_InsertSingle, &newentry, i);
 262                 }
 263             }
 264             break;
 265
 266         case CLEARALL:
 267             data->select_size = 0;
 268             data->select_entry_cnt = 0;
 269             for (i = 0; ; i++)
 270             {
 271                 DoMethod(data->lst_content, MUIM_NList_GetEntry, i, &oldentry);
 272                 if (!oldentry)
 273                     break;
 274                 if (oldentry->selected)
 275                 {
 276                     newentry.selected = FALSE;
 277                     newentry.fi = oldentry->fi;
 278                     DoMethod(data->lst_content, MUIM_NList_Remove, i);
 279                     DoMethod(data->lst_content, MUIM_NList_InsertSingle, &newentry, i);
 280                 }
 281             }
 282             break;
 283
 284         case INVERTALL:
 285             data->select_size = 0;
 286             data->select_entry_cnt = 0;
 287             for (i = 0; ; i++)
 288             {
 289                 DoMethod(data->lst_content, MUIM_NList_GetEntry, i, &oldentry);
 290                 if (!oldentry)
 291                     break;
 292                 newentry.selected = oldentry->selected ? FALSE : TRUE;
 293                 newentry.fi = oldentry->fi;
 294                 DoMethod(data->lst_content, MUIM_NList_Remove, i);
 295                 DoMethod(data->lst_content, MUIM_NList_InsertSingle, &newentry, i);
 296                 if (newentry.selected)
 297                 {
 298                     data->select_size += newentry.fi->xfi_Size;
 299                     data->select_entry_cnt++;
 300                 }
 301             }
 302             break;
 303
 304         case INVERTSINGLE:
 305             i = XGET(data->lst_content, MUIA_NList_EntryClick);
 306             if (i >= 0)
 307             {
 308                 DoMethod(data->lst_content, MUIM_NList_GetEntry, i, &oldentry);
 309                 newentry.selected = oldentry->selected ? FALSE : TRUE;
 310                 newentry.fi = oldentry->fi;
 311                 DoMethod(data->lst_content, MUIM_NList_Remove, i);
 312                 DoMethod(data->lst_content, MUIM_NList_InsertSingle, &newentry, i);
 313                 if (newentry.selected)
 314                 {
 315                     data->select_size += newentry.fi->xfi_Size;
 316                     data->select_entry_cnt++;
 317                 }
 318                 else
 319                 {
 320                     data->select_size -= newentry.fi->xfi_Size;
 321                     data->select_entry_cnt--;
 322                 }
 323             }
 324             break;
 325     }
 326
 327     SET(data->lst_content, MUIA_List_Quiet, FALSE);
 328     snprintf(buffer, sizeof buffer, _(MSG_TXT_STATUS_SEL), data->select_size, data->select_entry_cnt);
 329     SET(data->txt_status_select, MUIA_Text_Contents, buffer);
 330
 331     AROS_USERFUNC_EXIT
 332 }
 333
 334
 335 AROS_UFH3S(void, start_func,
 336     AROS_UFHA(struct Hook *, h, A0),
 337     AROS_UFHA(Object *, obj, A2),
 338     AROS_UFHA(APTR, msg, A1))
 339 {
 340     AROS_USERFUNC_INIT
 341
 342     D(bug("[start_func] called\n"));
 343
 344     struct UnarcGroup_DATA *data = h->h_Data;
 345     struct Listentry *entry;
 346     LONG i, result;
 347
 348     STRPTR destination = (STRPTR)XGET(data->str_targetdir, MUIA_String_Contents);
 349     if (destination[0] == '\0')
 350     {
 351         // FIXME: what if user selects "" as destination when starting from CLI?
 352         MUI_Request
 353         (
 354             _app(obj), _win(obj), 0, _(MSG_ERR),
 355             _(MSG_OK), _(MSG_ERR_NODEST)
 356         );
 357         return;
 358     }
 359
 360     for (i = 0; ; i++)
 361     {
 362         DoMethod(obj, MUIM_NList_GetEntry, i, &entry);
 363         if (!entry)
 364             break;
 365         if (entry->selected)
 366         {
 367             strlcpy(data->targetpathname, destination, PATHNAMESIZE);
 368             result = AddPart(data->targetpathname, entry->fi->xfi_FileName, PATHNAMESIZE);
 369             if (!result)
 370             {
 371                MUI_Request
 372                 (
 373                     _app(obj), _win(obj), 0, _(MSG_ERR),
 374                     _(MSG_OK), _(MSG_ERR_ADDPART), data->targetpathname, result
 375                 );
 376                 return;
 377             }
 378             D(bug("[start_func] filename %s\n", data->targetpathname));
 379             result = xadFileUnArc
 380             (
 381                 data->ai,
 382                 XAD_ENTRYNUMBER, i + 1,
 383                 XAD_OUTFILENAME, data->targetpathname,
 384                 XAD_MAKEDIRECTORY, TRUE,
 385                 XAD_OVERWRITE, TRUE,
 386                 TAG_DONE
 387             );
 388             D(bug("[start_func] xadFileUnArc result %d\n", result));
 389             if (result !=0 && result != XADERR_BADPARAMS) // FIXME: why do I have to catch that error?
 390             {
 391                 if
 392                 (
 393                     MUI_Request
 394                     (
 395                         _app(obj), _win(obj), 0, _(MSG_ERR),
 396                         _(MSG_SKIP_CANCEL), _(MSG_ERR_CANT_UNPACK), data->targetpathname, xadGetErrorText(result)
 397                     ) == 0
 398                 )
 399                 {
 400                     return;
 401                 }
 402             }
 403         }
 404         SET(data->ga_progress, MUIA_Gauge_Current, i);
 405     }
 406
 407     AROS_USERFUNC_EXIT
 408 }
 409
 410
 411 AROS_UFH3S(void, read_file_func,
 412     AROS_UFHA(struct Hook *, h, A0),
 413     AROS_UFHA(Object *, obj, A2),
 414     AROS_UFHA(APTR, msg, A1))
 415 {
 416     AROS_USERFUNC_INIT
 417
 418     D(bug("[read_file_func] called\n"));
 419
 420     struct UnarcGroup_DATA *data = h->h_Data;
 421     LONG result;
 422     TEXT buffer[50];
 423
 424     STRPTR filename = (STRPTR)XGET(data->str_file, MUIA_String_Contents);
 425     STRPTR newfilename = alloc_name_from_lock(filename); // expand to full path
 426     if (newfilename)
 427     {
 428         NNSET(data->str_file, MUIA_String_Contents, newfilename);
 429         filename = (STRPTR)XGET(data->str_file, MUIA_String_Contents);
 430         FreeVec(newfilename);
 431     }
 432
 433     DoMethod(data->lst_content, MUIM_NList_Clear);
 434
 435     xadFreeInfo(data->ai);
 436     data->total_entry_cnt = 0;
 437     data->total_size = 0;
 438     SET(data->ga_progress, MUIA_Gauge_Current, 0);
 439     SET(data->btn_all, MUIA_Disabled, TRUE);
 440     SET(data->btn_none, MUIA_Disabled, TRUE);
 441     SET(data->btn_invert, MUIA_Disabled, TRUE);
 442     SET(data->btn_start, MUIA_Disabled, TRUE);
 443
 444     result = xadGetInfo(data->ai, XAD_INFILENAME, filename, TAG_DONE);
 445     if (!result)
 446     {
 447         struct xadFileInfo *fi = data->ai->xai_FileInfo;
 448         while (fi)
 449         {
 450             struct Listentry newentry;
 451             newentry.selected = TRUE;
 452             newentry.fi = fi;
 453             DoMethod(data->lst_content, MUIM_NList_InsertSingle, &newentry, MUIV_List_Insert_Bottom);
 454             data->total_entry_cnt++;
 455             data->total_size += fi->xfi_Size;
 456             fi = fi->xfi_Next;
 457         }
 458         SET(data->ga_progress, MUIA_Gauge_Max, data->total_entry_cnt - 1);
 459         SET(data->btn_all, MUIA_Disabled, FALSE);
 460         SET(data->btn_none, MUIA_Disabled, FALSE);
 461         SET(data->btn_invert, MUIA_Disabled, FALSE);
 462         SET(data->btn_start, MUIA_Disabled, FALSE);
 463     }
 464     else
 465     {
 466         MUI_RequestA
 467         (
 468             NULL, NULL, 0, _(MSG_ERR),
 469             _(MSG_OK), _(MSG_ERR_NO_ARC), NULL
 470         );
 471     }
 472     snprintf(buffer, sizeof buffer, _(MSG_TXT_STATUS_ALL), data->total_size, data->total_entry_cnt);
 473     SET(data->txt_status_total, MUIA_Text_Contents, buffer);
 474
 475     data->select_entry_cnt = data->total_entry_cnt;
 476     data->select_size = data->total_size;
 477     snprintf(buffer, sizeof buffer, _(MSG_TXT_STATUS_SEL), data->select_size, data->select_entry_cnt);
 478     SET(data->txt_status_select, MUIA_Text_Contents, buffer);
 479
 480     AROS_USERFUNC_EXIT
 481 }
 482
 483
 484 AROS_UFH3S(void, expand_dest_func,
 485     AROS_UFHA(struct Hook *, h, A0),
 486     AROS_UFHA(Object *, obj, A2),
 487     AROS_UFHA(APTR, msg, A1))
 488 {
 489     AROS_USERFUNC_INIT
 490
 491     D(bug("[expand_dest_func] called\n"));
 492
 493     struct UnarcGroup_DATA *data = h->h_Data;
 494
 495     STRPTR targetdir = (STRPTR)XGET(data->str_targetdir, MUIA_String_Contents);
 496     STRPTR newtargetdir = alloc_name_from_lock(targetdir); // expand to full path
 497     if (newtargetdir)
 498     {
 499         NNSET(data->str_targetdir, MUIA_String_Contents, newtargetdir);
 500         FreeVec(newtargetdir);
 501     }
 502
 503     AROS_USERFUNC_EXIT
 504 }
 505
 506
 507 Object *UnarcGroup__OM_NEW(Class *CLASS, Object *self, struct opSet *message)
 508 {
 509     Object *btn_all, *btn_none, *btn_invert, *btn_start, *btn_cancel;
 510     Object *str_file, *str_targetdir, *lst_content, *ga_progress;
 511     Object *txt_status_total, *txt_status_select;
 512     STRPTR archive = NULL, destination = NULL;
 513
 514     struct xadArchiveInfo *ai = xadAllocObjectA(XADOBJ_ARCHIVEINFO, 0);
 515     STRPTR targetpathname = AllocVec(PATHNAMESIZE, MEMF_ANY);
 516
 517     if (ai == NULL || targetpathname == NULL)
 518     {
 519         // FIXME: I get memory corruption alert if I leave function here
 520         MUI_RequestA
 521         (
 522             NULL, NULL, 0, _(MSG_ERR),
 523             _(MSG_OK), _(MSG_ERR_NO_MEM), NULL
 524         );
 525         return NULL;
 526     }
 527
 528     struct TagItem  *tstate = message->ops_AttrList;
 529     struct TagItem  *tag    = NULL;
 530
 531     while ((tag = NextTagItem(&tstate)) != NULL)
 532     {
 533         switch (tag->ti_Tag)
 534         {
 535             case MUIA_UnarcGroup_Archive:
 536                 archive = (STRPTR)tag->ti_Data;
 537                 break;
 538
 539             case MUIA_UnarcGroup_Destination:
 540                 destination = (STRPTR)tag->ti_Data;
 541                 break;
 542         }
 543     }
 544
 545     if (archive == NULL) archive = "SYS:";
 546     if (destination == NULL) destination = "RAM:";
 547
 548     list_constr_hook.h_Entry = (HOOKFUNC)list_constr_func;
 549     list_destr_hook.h_Entry = (HOOKFUNC)list_destr_func;
 550     list_display_hook.h_Entry = (HOOKFUNC)list_display_func;
 551
 552     self = (Object *) DoSuperNewTags
 553     (
 554         CLASS, self, NULL,
 555         Child, ColGroup(2),
 556             Child, Label(_(MSG_LA_ARCHIVE)),
 557             Child, PopaslObject,
 558                 MUIA_Popasl_Type , ASL_FileRequest,
 559                 ASLFR_TitleText, _(MSG_FREQ_ARCHIVE_TITLE),
 560                 ASLFR_RejectIcons, TRUE,
 561                 MUIA_Popstring_String, str_file = StringObject,
 562                     StringFrame,
 563                     MUIA_String_Contents, archive,
 564                 End,
 565                 MUIA_Popstring_Button, PopButton(MUII_PopFile),
 566             End,
 567             Child, Label(_(MSG_LA_DESTINATION)),
 568             Child, PopaslObject,
 569                 MUIA_Popasl_Type , ASL_FileRequest,
 570                 ASLFR_TitleText, _(MSG_FREQ_DESTINATION_TITLE),
 571                 ASLFR_DrawersOnly, TRUE,
 572                 MUIA_Popstring_String, str_targetdir = StringObject,
 573                     StringFrame,
 574                     MUIA_String_Contents, destination,
 575                 End,
 576                 MUIA_Popstring_Button, PopButton(MUII_PopDrawer),
 577             End,
 578         End,
 579         Child, ga_progress = GaugeObject,
 580             GaugeFrame,
 581             MUIA_FixHeight, 15,
 582             MUIA_Gauge_Horiz, TRUE,
 583             MUIA_Gauge_Max, 100,
 584         End,
 585         Child, NListviewObject,
 586             MUIA_NListview_NList, lst_content = NListObject,
 587                 MUIA_Frame, MUIV_Frame_InputList,
 588                 MUIA_NList_Input, FALSE,
 589                 MUIA_NList_Format, "BAR,BAR,P=\33r BAR,P=\33r BAR,P=\33r BAR,P=\33r BAR,BAR,",
 590                 MUIA_NList_Title, TRUE,
 591                 MUIA_NList_DisplayHook, &list_display_hook,
 592                 MUIA_NList_ConstructHook, &list_constr_hook,
 593                 MUIA_NList_DestructHook, &list_destr_hook,
 594             End,
 595         End,
 596         Child, HGroup,
 597             Child, txt_status_total = TextObject,
 598                 TextFrame,
 599             End,
 600             Child, txt_status_select = TextObject,
 601                 TextFrame,
 602             End,
 603         End,
 604         Child, HGroup,
 605             Child, btn_all = SimpleButton(_(MSG_BT_ALL)),
 606             Child, btn_none = SimpleButton(_(MSG_BT_NONE)),
 607             Child, btn_invert = SimpleButton(_(MSG_BT_INVERT)),
 608         End,
 609         Child, (IPTR) RectangleObject,
 610             MUIA_Rectangle_HBar, TRUE,
 611             MUIA_FixHeight,      2,
 612         End,
 613         Child, HGroup,
 614             Child, btn_start = SimpleButton(_(MSG_BT_START)),
 615             Child, HVSpace,
 616             Child, btn_cancel = SimpleButton(_(MSG_BT_CANCEL)),
 617         End,
 618         TAG_MORE, (IPTR)message->ops_AttrList,
 619         TAG_DONE
 620     );
 621
 622     if (self)
 623     {
 624         struct UnarcGroup_DATA *data = INST_DATA(CLASS, self);
 625
 626         data->btn_all           = btn_all;
 627         data->btn_none          = btn_none;
 628         data->btn_invert        = btn_invert;
 629         data->btn_start         = btn_start;
 630         data->btn_cancel        = btn_cancel;
 631         data->str_file          = str_file;
 632         data->str_targetdir     = str_targetdir;
 633         data->lst_content       = lst_content;
 634         data->ga_progress       = ga_progress;
 635         data->txt_status_total  = txt_status_total;
 636         data->txt_status_select = txt_status_select;
 637         data->ai                = ai;
 638
 639         data->start_hook.h_Entry = (HOOKFUNC)start_func;
 640         data->start_hook.h_Data = data;
 641         data->read_file_hook.h_Entry = (HOOKFUNC)read_file_func;
 642         data->read_file_hook.h_Data = data;
 643         data->change_selection_hook.h_Entry = (HOOKFUNC)change_selection_func;
 644         data->change_selection_hook.h_Data = data;
 645         data->expand_dest_hook.h_Entry = (HOOKFUNC)expand_dest_func;
 646         data->expand_dest_hook.h_Data = data;
 647
 648         data->targetpathname = targetpathname;
 649
 650         SET(data->btn_all, MUIA_Disabled, TRUE);
 651         SET(data->btn_none, MUIA_Disabled, TRUE);
 652         SET(data->btn_invert, MUIA_Disabled, TRUE);
 653         SET(data->btn_start, MUIA_Disabled, TRUE);
 654
 655         DoMethod
 656         (
 657             data->btn_cancel, MUIM_Notify, MUIA_Pressed, FALSE,
 658             MUIV_Notify_Application, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit
 659         );
 660
 661         DoMethod
 662         (
 663             data->btn_all, MUIM_Notify, MUIA_Pressed, FALSE,
 664             data->lst_content, 3, MUIM_CallHook, &data->change_selection_hook, SETALL
 665         );
 666
 667         DoMethod
 668         (
 669             data->btn_none, MUIM_Notify, MUIA_Pressed, FALSE,
 670             data->lst_content, 3, MUIM_CallHook, &data->change_selection_hook, CLEARALL
 671         );
 672
 673         DoMethod
 674         (
 675             data->btn_invert, MUIM_Notify, MUIA_Pressed, FALSE,
 676             data->lst_content, 3, MUIM_CallHook, &data->change_selection_hook, INVERTALL
 677         );
 678
 679         DoMethod
 680         (
 681             data->lst_content, MUIM_Notify, MUIA_NList_EntryClick, MUIV_EveryTime,
 682             data->lst_content, 3, MUIM_CallHook, &data->change_selection_hook, INVERTSINGLE
 683         );
 684
 685         DoMethod
 686         (
 687             data->btn_start, MUIM_Notify, MUIA_Pressed, FALSE,
 688             data->lst_content, 2, MUIM_CallHook, &data->start_hook
 689         );
 690
 691         DoMethod
 692         (
 693             data->str_file, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
 694             data->lst_content, 2, MUIM_CallHook, &data->read_file_hook
 695         );
 696
 697         DoMethod
 698         (
 699             data->str_targetdir, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
 700             data->str_targetdir, 2, MUIM_CallHook, &data->expand_dest_hook
 701         );
 702
 703         if (is_file(archive))
 704         {
 705             // fill the list if we have an existing file
 706             DoMethod
 707             (
 708                 data->lst_content, MUIM_CallHook, &data->read_file_hook
 709             );
 710         }
 711     }
 712     return self;
 713 }
 714
 715
 716 IPTR UnarcGroup__OM_DISPOSE(Class *CLASS, Object *self, Msg message)
 717 {
 718     struct UnarcGroup_DATA *data = INST_DATA(CLASS, self);
 719
 720     if (data->ai)
 721     {
 722         xadFreeInfo(data->ai);
 723         xadFreeObjectA(data->ai, 0);
 724     }
 725     FreeVec(data->targetpathname);
 726
 727     return DoSuperMethodA(CLASS, self, message);
 728 }
 729
 730
 731 ZUNE_CUSTOMCLASS_2
 732 (
 733     UnarcGroup, NULL, MUIC_Group, NULL,
 734     OM_NEW,             struct opSet *,
 735     OM_DISPOSE,         Msg
 736 );