pack/unarc/unarcgroup_class.c

   1 /*
   2     Copyright © 2012-2017, 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             if (entry->fi->xfi_Flags & XADFIF_DIRECTORY)
 380             {
 381                 // FIXME: create directory (needed if empty)
 382             }
 383             else
 384             {
 385                 result = xadFileUnArc
 386                 (
 387                     data->ai,
 388                     XAD_ENTRYNUMBER, i + 1,
 389                     XAD_OUTFILENAME, data->targetpathname,
 390                     XAD_MAKEDIRECTORY, TRUE,
 391                     XAD_OVERWRITE, TRUE,
 392                     TAG_DONE
 393                 );
 394                 D(bug("[start_func] xadFileUnArc result %d\n", result));
 395                 if (result !=0 && result != XADERR_BADPARAMS) // FIXME: why do I have to catch that error?
 396                 {
 397                     if
 398                     (
 399                         MUI_Request
 400                         (
 401                             _app(obj), _win(obj), 0, _(MSG_ERR),
 402                             _(MSG_SKIP_CANCEL), _(MSG_ERR_CANT_UNPACK),
 403                             data->targetpathname, xadGetErrorText(result)
 404                         ) == 0
 405                     )
 406                     {
 407                         return;
 408                     }
 409                 }
 410             }
 411         }
 412         SET(data->ga_progress, MUIA_Gauge_Current, i);
 413     }
 414
 415     AROS_USERFUNC_EXIT
 416 }
 417
 418
 419 AROS_UFH3S(void, read_file_func,
 420     AROS_UFHA(struct Hook *, h, A0),
 421     AROS_UFHA(Object *, obj, A2),
 422     AROS_UFHA(APTR, msg, A1))
 423 {
 424     AROS_USERFUNC_INIT
 425
 426     D(bug("[read_file_func] called\n"));
 427
 428     struct UnarcGroup_DATA *data = h->h_Data;
 429     LONG result;
 430     TEXT buffer[50];
 431
 432     STRPTR filename = (STRPTR)XGET(data->str_file, MUIA_String_Contents);
 433     STRPTR newfilename = alloc_name_from_lock(filename); // expand to full path
 434     if (newfilename)
 435     {
 436         NNSET(data->str_file, MUIA_String_Contents, newfilename);
 437         filename = (STRPTR)XGET(data->str_file, MUIA_String_Contents);
 438         FreeVec(newfilename);
 439     }
 440
 441     DoMethod(data->lst_content, MUIM_NList_Clear);
 442
 443     xadFreeInfo(data->ai);
 444     data->total_entry_cnt = 0;
 445     data->total_size = 0;
 446     SET(data->ga_progress, MUIA_Gauge_Current, 0);
 447     SET(data->btn_all, MUIA_Disabled, TRUE);
 448     SET(data->btn_none, MUIA_Disabled, TRUE);
 449     SET(data->btn_invert, MUIA_Disabled, TRUE);
 450     SET(data->btn_start, MUIA_Disabled, TRUE);
 451
 452     result = xadGetInfo(data->ai, XAD_INFILENAME, filename, TAG_DONE);
 453     if (!result)
 454     {
 455         struct xadFileInfo *fi = data->ai->xai_FileInfo;
 456         while (fi)
 457         {
 458             struct Listentry newentry;
 459             newentry.selected = TRUE;
 460             newentry.fi = fi;
 461             DoMethod(data->lst_content, MUIM_NList_InsertSingle, &newentry, MUIV_List_Insert_Bottom);
 462             data->total_entry_cnt++;
 463             data->total_size += fi->xfi_Size;
 464             fi = fi->xfi_Next;
 465         }
 466         SET(data->ga_progress, MUIA_Gauge_Max, data->total_entry_cnt - 1);
 467         SET(data->btn_all, MUIA_Disabled, FALSE);
 468         SET(data->btn_none, MUIA_Disabled, FALSE);
 469         SET(data->btn_invert, MUIA_Disabled, FALSE);
 470         SET(data->btn_start, MUIA_Disabled, FALSE);
 471     }
 472     else
 473     {
 474         MUI_RequestA
 475         (
 476             NULL, NULL, 0, _(MSG_ERR),
 477             _(MSG_OK), _(MSG_ERR_NO_ARC), NULL
 478         );
 479     }
 480     snprintf(buffer, sizeof buffer, _(MSG_TXT_STATUS_ALL), data->total_size, data->total_entry_cnt);
 481     SET(data->txt_status_total, MUIA_Text_Contents, buffer);
 482
 483     data->select_entry_cnt = data->total_entry_cnt;
 484     data->select_size = data->total_size;
 485     snprintf(buffer, sizeof buffer, _(MSG_TXT_STATUS_SEL), data->select_size, data->select_entry_cnt);
 486     SET(data->txt_status_select, MUIA_Text_Contents, buffer);
 487
 488     AROS_USERFUNC_EXIT
 489 }
 490
 491
 492 AROS_UFH3S(void, expand_dest_func,
 493     AROS_UFHA(struct Hook *, h, A0),
 494     AROS_UFHA(Object *, obj, A2),
 495     AROS_UFHA(APTR, msg, A1))
 496 {
 497     AROS_USERFUNC_INIT
 498
 499     D(bug("[expand_dest_func] called\n"));
 500
 501     struct UnarcGroup_DATA *data = h->h_Data;
 502
 503     STRPTR targetdir = (STRPTR)XGET(data->str_targetdir, MUIA_String_Contents);
 504     STRPTR newtargetdir = alloc_name_from_lock(targetdir); // expand to full path
 505     if (newtargetdir)
 506     {
 507         NNSET(data->str_targetdir, MUIA_String_Contents, newtargetdir);
 508         FreeVec(newtargetdir);
 509     }
 510
 511     AROS_USERFUNC_EXIT
 512 }
 513
 514
 515 Object *UnarcGroup__OM_NEW(Class *CLASS, Object *self, struct opSet *message)
 516 {
 517     Object *btn_all, *btn_none, *btn_invert, *btn_start, *btn_cancel;
 518     Object *str_file, *str_targetdir, *lst_content, *ga_progress;
 519     Object *txt_status_total, *txt_status_select;
 520     STRPTR archive = NULL, destination = NULL;
 521
 522     struct xadArchiveInfo *ai = xadAllocObjectA(XADOBJ_ARCHIVEINFO, 0);
 523     STRPTR targetpathname = AllocVec(PATHNAMESIZE, MEMF_ANY);
 524
 525     if (ai == NULL || targetpathname == NULL)
 526     {
 527         // FIXME: I get memory corruption alert if I leave function here
 528         MUI_RequestA
 529         (
 530             NULL, NULL, 0, _(MSG_ERR),
 531             _(MSG_OK), _(MSG_ERR_NO_MEM), NULL
 532         );
 533         return NULL;
 534     }
 535
 536     struct TagItem  *tstate = message->ops_AttrList;
 537     struct TagItem  *tag    = NULL;
 538
 539     while ((tag = NextTagItem(&tstate)) != NULL)
 540     {
 541         switch (tag->ti_Tag)
 542         {
 543             case MUIA_UnarcGroup_Archive:
 544                 archive = (STRPTR)tag->ti_Data;
 545                 break;
 546
 547             case MUIA_UnarcGroup_Destination:
 548                 destination = (STRPTR)tag->ti_Data;
 549                 break;
 550         }
 551     }
 552
 553     if (archive == NULL) archive = "SYS:";
 554     if (destination == NULL) destination = "RAM:";
 555
 556     list_constr_hook.h_Entry = (HOOKFUNC)list_constr_func;
 557     list_destr_hook.h_Entry = (HOOKFUNC)list_destr_func;
 558     list_display_hook.h_Entry = (HOOKFUNC)list_display_func;
 559
 560     self = (Object *) DoSuperNewTags
 561     (
 562         CLASS, self, NULL,
 563         Child, ColGroup(2),
 564             Child, Label(_(MSG_LA_ARCHIVE)),
 565             Child, PopaslObject,
 566                 MUIA_Popasl_Type , ASL_FileRequest,
 567                 ASLFR_TitleText, _(MSG_FREQ_ARCHIVE_TITLE),
 568                 ASLFR_RejectIcons, TRUE,
 569                 MUIA_Popstring_String, str_file = StringObject,
 570                     StringFrame,
 571                     MUIA_String_Contents, archive,
 572                 End,
 573                 MUIA_Popstring_Button, PopButton(MUII_PopFile),
 574             End,
 575             Child, Label(_(MSG_LA_DESTINATION)),
 576             Child, PopaslObject,
 577                 MUIA_Popasl_Type , ASL_FileRequest,
 578                 ASLFR_TitleText, _(MSG_FREQ_DESTINATION_TITLE),
 579                 ASLFR_DrawersOnly, TRUE,
 580                 MUIA_Popstring_String, str_targetdir = StringObject,
 581                     StringFrame,
 582                     MUIA_String_Contents, destination,
 583                 End,
 584                 MUIA_Popstring_Button, PopButton(MUII_PopDrawer),
 585             End,
 586         End,
 587         Child, ga_progress = GaugeObject,
 588             GaugeFrame,
 589             MUIA_FixHeight, 15,
 590             MUIA_Gauge_Horiz, TRUE,
 591             MUIA_Gauge_Max, 100,
 592         End,
 593         Child, NListviewObject,
 594             MUIA_NListview_NList, lst_content = NListObject,
 595                 MUIA_Frame, MUIV_Frame_InputList,
 596                 MUIA_NList_Input, FALSE,
 597                 MUIA_NList_Format, "BAR,BAR,P=\33r BAR,P=\33r BAR,P=\33r BAR,P=\33r BAR,BAR,",
 598                 MUIA_NList_Title, TRUE,
 599                 MUIA_NList_DisplayHook, &list_display_hook,
 600                 MUIA_NList_ConstructHook, &list_constr_hook,
 601                 MUIA_NList_DestructHook, &list_destr_hook,
 602             End,
 603         End,
 604         Child, HGroup,
 605             Child, txt_status_total = TextObject,
 606                 TextFrame,
 607             End,
 608             Child, txt_status_select = TextObject,
 609                 TextFrame,
 610             End,
 611         End,
 612         Child, HGroup,
 613             Child, btn_all = SimpleButton(_(MSG_BT_ALL)),
 614             Child, btn_none = SimpleButton(_(MSG_BT_NONE)),
 615             Child, btn_invert = SimpleButton(_(MSG_BT_INVERT)),
 616         End,
 617         Child, (IPTR) RectangleObject,
 618             MUIA_Rectangle_HBar, TRUE,
 619             MUIA_FixHeight,      2,
 620         End,
 621         Child, HGroup,
 622             Child, btn_start = SimpleButton(_(MSG_BT_START)),
 623             Child, HVSpace,
 624             Child, btn_cancel = SimpleButton(_(MSG_BT_CANCEL)),
 625         End,
 626         TAG_MORE, (IPTR)message->ops_AttrList,
 627         TAG_DONE
 628     );
 629
 630     if (self)
 631     {
 632         struct UnarcGroup_DATA *data = INST_DATA(CLASS, self);
 633
 634         data->btn_all           = btn_all;
 635         data->btn_none          = btn_none;
 636         data->btn_invert        = btn_invert;
 637         data->btn_start         = btn_start;
 638         data->btn_cancel        = btn_cancel;
 639         data->str_file          = str_file;
 640         data->str_targetdir     = str_targetdir;
 641         data->lst_content       = lst_content;
 642         data->ga_progress       = ga_progress;
 643         data->txt_status_total  = txt_status_total;
 644         data->txt_status_select = txt_status_select;
 645         data->ai                = ai;
 646
 647         data->start_hook.h_Entry = (HOOKFUNC)start_func;
 648         data->start_hook.h_Data = data;
 649         data->read_file_hook.h_Entry = (HOOKFUNC)read_file_func;
 650         data->read_file_hook.h_Data = data;
 651         data->change_selection_hook.h_Entry = (HOOKFUNC)change_selection_func;
 652         data->change_selection_hook.h_Data = data;
 653         data->expand_dest_hook.h_Entry = (HOOKFUNC)expand_dest_func;
 654         data->expand_dest_hook.h_Data = data;
 655
 656         data->targetpathname = targetpathname;
 657
 658         SET(data->btn_all, MUIA_Disabled, TRUE);
 659         SET(data->btn_none, MUIA_Disabled, TRUE);
 660         SET(data->btn_invert, MUIA_Disabled, TRUE);
 661         SET(data->btn_start, MUIA_Disabled, TRUE);
 662
 663         DoMethod
 664         (
 665             data->btn_cancel, MUIM_Notify, MUIA_Pressed, FALSE,
 666             MUIV_Notify_Application, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit
 667         );
 668
 669         DoMethod
 670         (
 671             data->btn_all, MUIM_Notify, MUIA_Pressed, FALSE,
 672             data->lst_content, 3, MUIM_CallHook, &data->change_selection_hook, SETALL
 673         );
 674
 675         DoMethod
 676         (
 677             data->btn_none, MUIM_Notify, MUIA_Pressed, FALSE,
 678             data->lst_content, 3, MUIM_CallHook, &data->change_selection_hook, CLEARALL
 679         );
 680
 681         DoMethod
 682         (
 683             data->btn_invert, MUIM_Notify, MUIA_Pressed, FALSE,
 684             data->lst_content, 3, MUIM_CallHook, &data->change_selection_hook, INVERTALL
 685         );
 686
 687         DoMethod
 688         (
 689             data->lst_content, MUIM_Notify, MUIA_NList_EntryClick, MUIV_EveryTime,
 690             data->lst_content, 3, MUIM_CallHook, &data->change_selection_hook, INVERTSINGLE
 691         );
 692
 693         DoMethod
 694         (
 695             data->btn_start, MUIM_Notify, MUIA_Pressed, FALSE,
 696             data->lst_content, 2, MUIM_CallHook, &data->start_hook
 697         );
 698
 699         DoMethod
 700         (
 701             data->str_file, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
 702             data->lst_content, 2, MUIM_CallHook, &data->read_file_hook
 703         );
 704
 705         DoMethod
 706         (
 707             data->str_targetdir, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
 708             data->str_targetdir, 2, MUIM_CallHook, &data->expand_dest_hook
 709         );
 710
 711         if (is_file(archive))
 712         {
 713             // fill the list if we have an existing file
 714             DoMethod
 715             (
 716                 data->lst_content, MUIM_CallHook, &data->read_file_hook
 717             );
 718         }
 719     }
 720     return self;
 721 }
 722
 723
 724 IPTR UnarcGroup__OM_DISPOSE(Class *CLASS, Object *self, Msg message)
 725 {
 726     struct UnarcGroup_DATA *data = INST_DATA(CLASS, self);
 727
 728     if (data->ai)
 729     {
 730         xadFreeInfo(data->ai);
 731         xadFreeObjectA(data->ai, 0);
 732     }
 733     FreeVec(data->targetpathname);
 734
 735     return DoSuperMethodA(CLASS, self, message);
 736 }
 737
 738
 739 ZUNE_CUSTOMCLASS_2
 740 (
 741     UnarcGroup, NULL, MUIC_Group, NULL,
 742     OM_NEW,             struct opSet *,
 743     OM_DISPOSE,         Msg
 744 );