workbench/system/Wanderer/Tools/Info/main.c

   1 /*
   2     Copyright © 2003-2013, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #define MUIMASTER_YES_INLINE_STDARG
   7
   8 #define DEBUG 0
   9 #include <aros/debug.h>
  10
  11 #include <proto/exec.h>
  12 #include <proto/intuition.h>
  13 #include <proto/muimaster.h>
  14 #include <proto/workbench.h>
  15 #include <proto/dos.h>
  16 #include <proto/alib.h>
  17 #include <proto/icon.h>
  18
  19 #include <dos/dos.h>
  20 #include <dos/datetime.h>
  21 #include <exec/memory.h>
  22 #include <libraries/asl.h>
  23 #include <libraries/commodities.h>
  24 #include <libraries/mui.h>
  25 #include <workbench/startup.h>
  26 #include <workbench/workbench.h>
  27 #include <workbench/icon.h>
  28 #include <devices/inputevent.h>
  29
  30 #include <mui/TextEditor_mcc.h>
  31 #include <zune/iconimage.h>
  32
  33 #include "locale.h"
  34
  35 #include <stdio.h>
  36
  37 #include <string.h>
  38
  39 #define RETURNID_SLEEP      1
  40 #define RETURNID_WAKE       2
  41 #define RETURNID_ABOUT      3
  42 #define RETURNID_NEWKEY     4
  43 #define RETURNID_DELKEY     5
  44 #define RETURNID_LVACK      6
  45 #define RETURNID_STRINGACK  7
  46 #define RETURNID_SAVE       8
  47 #define RETURNID_TOOLACK    9
  48 #define RETURNID_STACKACK   10
  49 #define RETURNID_COMMENTACK 11
  50 #define RETURNID_QUERYVERSION    12
  51 #define RETURNID_PROTECT    13
  52 #define RETURNID_SCANSIZE   14
  53
  54 #define  MAX_PATH_LEN  1024
  55 #define  MAX_TOOLTYPE_LINE 256
  56 #define BUFFERSIZE 1024
  57
  58 #define USE_TEXTEDITOR 1
  59
  60 #define SCANDIE 1
  61 #define SCANRUN 0
  62
  63 static Object *window, *commentspace, *filename_string, *stackspace, *savebutton;
  64 static Object *readobject, *writeobject, *executeobject, *deleteobject;
  65 static Object *scriptobject, *pureobject, *archiveobject, *sizespace = NULL;
  66
  67 struct DirScanProcess
  68 {
  69     struct Process    *scanProcess;
  70     Object         *scanSizeObj;
  71     char        *scanSize;
  72     char        *scanDir;
  73     IPTR        scanState;
  74 };
  75
  76 static struct DirScanProcess *scanStruct = NULL;
  77
  78 #if USE_TEXTEDITOR
  79 static Object *editor, *slider;
  80 #else
  81 static Object *list, *editor, *liststr;
  82 #endif
  83
  84 BOOL file_altered = FALSE;
  85 BOOL icon_altered = FALSE;
  86 char loadedcomment[MAXCOMMENTLENGTH];
  87
  88 void getReadableSize(UBYTE *buf, UQUAD size, BOOL accurate)
  89 {
  90     UQUAD d;
  91     char *ch;
  92     struct
  93     {
  94         ULONG val;
  95         ULONG dec;
  96     } array =
  97     {
  98         size,
  99         0
 100     };
 101
 102     /*if (size >= (1024 * 1024 * 1024 * 1024 * 1024 * 1024))
 103     {
 104         //Exabytes
 105         array.val = size >> 60;
 106         d = (size * 10 + ((1024 * 1024 * 1024 * 1024 * 1024 * 1024) / 2)) / (1024 * 1024 * 1024 * 1024 * 1024 * 1024);
 107         array.dec = d % 10;
 108         ch = "EiB";
 109     }
 110     else if (size >= (1024 * 1024 * 1024 * 1024 * 1024))
 111     {
 112         //Petabytes
 113         array.val = size >> 50;
 114         d = (size * 10 + ((1024 * 1024 * 1024 * 1024 * 1024) / 2)) / (1024 * 1024 * 1024 * 1024 * 1024);
 115         array.dec = d % 10;
 116         ch = "PiB";
 117     }
 118     else if (size >= (1024 * 1024 * 1024 * 1024))
 119     {
 120         //Terabytes
 121         array.val = size >> 40;
 122         d = (size * 10 + ((1024 * 1024 * 1024 * 1024) / 2)) / (1024 * 1024 * 1024 * 1024);
 123         array.dec = d % 10;
 124         ch = "TiB";
 125     }*/
 126     if (size >= (1024 * 1024 * 1024))
 127     {
 128         //Gigabytes
 129         array.val = size >> 30;
 130         d = (size * 10 + ((1024 * 1024 * 1024) / 2)) / (1024 * 1024 * 1024);
 131         array.dec = d % 10;
 132         ch = "GiB";
 133     }
 134     else if (size >= (1024 * 1024))
 135     {
 136         //Megabytes
 137         array.val = size >> 20;
 138         d = (size * 10 + ((1024 * 1024) / 2)) / (1024 * 1024);
 139         array.dec = d % 10;
 140         ch = "MiB";
 141     }
 142     else if (size >= 1024)
 143     {
 144         //Kilobytes
 145         array.val = size >> 10;
 146         d = (size * 10 + (1024 / 2)) / 1024;
 147         array.dec = d % 10;
 148         ch = "KiB";
 149     }
 150     else
 151     {
 152         //Bytes
 153         array.val = size;
 154         array.dec = 0;
 155         d = 0;
 156         if (size == 1)
 157             ch = "Byte";
 158         else
 159             ch = "Bytes";
 160     }
 161
 162     if (!array.dec && (d > array.val * 10))
 163         array.val++;
 164
 165     if (!accurate)
 166     {
 167         buf[0] = '~';
 168         buf++;
 169     }
 170
 171     RawDoFmt(array.dec ? "%lu.%lu" : "%lu", (RAWARG)&array, NULL, buf);
 172
 173     while (*buf)
 174         buf++;
 175
 176     sprintf((char *)buf," %s", ch);
 177 }
 178
 179 #define kExallBufSize          (4096)
 180
 181 UQUAD calculateDirectorySize(struct DirScanProcess *scan, UQUAD base, CONST_STRPTR directory, UQUAD * lastrefreshsize)
 182 {
 183     UBYTE    *buffer = NULL;
 184     BPTR    directoryLock = BNULL;
 185     UQUAD    directorySize = 0;
 186     BOOL    loop = TRUE;
 187
 188 D(bug("[WBInfo] calculateDirectorySize('%s')\n", directory));
 189
 190     directoryLock = Lock(directory, SHARED_LOCK);
 191
 192     /* Allocate buffer for ExAll */
 193     if ((buffer = AllocVec(kExallBufSize, MEMF_CLEAR|MEMF_PUBLIC)) == NULL)
 194     {
 195         UnLock(directoryLock);
 196         return 0;
 197     }
 198
 199     struct ExAllData *ead = (struct ExAllData*)buffer;
 200     struct ExAllControl  *eac = AllocDosObject(DOS_EXALLCONTROL, NULL);
 201     eac->eac_LastKey = 0;
 202
 203     struct ExAllData *oldEad = ead;
 204
 205     do
 206     {
 207     ead = oldEad;
 208     loop = ExAll(directoryLock, ead, kExallBufSize, ED_COMMENT, eac);
 209
 210     if(!loop && IoErr() != ERROR_NO_MORE_ENTRIES) break;
 211
 212     if(eac->eac_Entries != 0)
 213     {
 214         do
 215         {
 216             if (ead->ed_Type == ST_FILE)
 217             {
 218                 directorySize += ead->ed_Size;
 219                 /* Refresh size only every 25% grow */
 220                 if ((((base + directorySize) * 100) / (*lastrefreshsize)) > 125) /* 25 % */
 221                 {
 222                     getReadableSize(scan->scanSize, (base + directorySize), FALSE);
 223                     set(sizespace, MUIA_Text_Contents, (IPTR) scan->scanSize);
 224                     *lastrefreshsize = base + directorySize;
 225                 }
 226             }
 227             else if (ead->ed_Type == ST_USERDIR)
 228             {
 229                 ULONG subdirlen = strlen(directory) + strlen(ead->ed_Name) + 1;
 230                 char * subdirectory = AllocVec(subdirlen + 1, MEMF_CLEAR);
 231                 CopyMem(directory, subdirectory, strlen(directory));
 232                 AddPart(subdirectory, ead->ed_Name, subdirlen + 1);
 233                 directorySize += calculateDirectorySize(scan, (base + directorySize), subdirectory, lastrefreshsize);
 234             }
 235             ead = ead->ed_Next;
 236         } while((ead != NULL) && (scan->scanState == SCANRUN));
 237     }
 238     } while((loop) && (scan->scanState == SCANRUN));
 239
 240     FreeDosObject(DOS_EXALLCONTROL, eac);
 241     UnLock(directoryLock);
 242     FreeVec(buffer);
 243
 244     return directorySize;
 245 }
 246
 247 /*
 248  * child process to calculate directory content size..
 249  */
 250 AROS_UFH3(void, scanDir_Process,
 251     AROS_UFHA(STRPTR,              argPtr, A0),
 252     AROS_UFHA(ULONG,               argSize, D0),
 253     AROS_UFHA(struct ExecBase *,   SysBase, A6))
 254 {
 255     AROS_USERFUNC_INIT
 256
 257     struct Task             *taskSelf = FindTask(NULL);
 258     struct DirScanProcess   *scan = taskSelf->tc_UserData;
 259     UQUAD                   directorySize = 0;
 260
 261     if (scan->scanState == SCANRUN)
 262     {
 263         UQUAD lastrefreshsize = 1;
 264         D(bug("[WBInfo] scanDir_Process('%s')\n", scan->scanDir));
 265         scan->scanSize = AllocVec(64, MEMF_CLEAR);
 266         directorySize = calculateDirectorySize(scan, directorySize, scan->scanDir, &lastrefreshsize);
 267         D(bug("[WBInfo] scanDir_Process: End size = %d bytes\n", directorySize));
 268         getReadableSize(scan->scanSize, directorySize, TRUE);
 269         set(sizespace, MUIA_Text_Contents, (IPTR) scan->scanSize);
 270         FreeVec(scan->scanSize);
 271     }
 272     scan->scanProcess = NULL;
 273
 274     AROS_USERFUNC_EXIT
 275 }
 276
 277 UBYTE **BuildToolTypes(UBYTE **src_ttypes)
 278 {
 279 #if USE_TEXTEDITOR
 280     APTR     pool = CreatePool(MEMF_CLEAR, 200, 200);
 281     STRPTR   contents, sp, *dst_ttypes;
 282     ULONG    lines = 1;
 283
 284     if (!pool) return NULL;
 285     contents = (STRPTR)DoMethod(editor, MUIM_TextEditor_ExportText);
 286
 287     if (!contents || !contents[0])
 288     {
 289         DeletePool(pool);
 290     return NULL;
 291     }
 292
 293     sp = contents;
 294
 295     while((sp = strchr(sp, '\n')))
 296     {
 297         sp++;
 298     lines++;
 299     }
 300
 301     dst_ttypes = AllocPooled(pool, (lines + 3) * sizeof(STRPTR));
 302     if (!dst_ttypes)
 303     {
 304         FreeVec(contents);
 305     DeletePool(pool);
 306     return NULL;
 307     }
 308
 309     *dst_ttypes++ = (STRPTR)pool;
 310     *dst_ttypes++ = (STRPTR)contents;
 311
 312     for(sp = contents, lines = 0; sp; lines++)
 313     {
 314     dst_ttypes[lines] = sp;
 315         sp = strchr(sp, '\n');
 316     if (sp)
 317     {
 318         *sp++ = '\0';
 319     }
 320     }
 321     dst_ttypes[lines] = 0;
 322
 323     return dst_ttypes;
 324 #else
 325     APTR     pool = CreatePool(MEMF_CLEAR, 200, 200);
 326     Object  *listobj = list;
 327     WORD     list_index = 0, num_ttypes = 0, alloc_ttypes = 10;
 328     UBYTE **dst_ttypes;
 329
 330     if (!pool) return NULL;
 331
 332     dst_ttypes = AllocPooled(pool, (alloc_ttypes + 2) * sizeof(UBYTE *));
 333     if (!dst_ttypes)
 334     {
 335         DeletePool(pool);
 336         return NULL;
 337     }
 338
 339     get(listobj, MUIA_List_Entries, &list_index);
 340     while(num_ttypes<list_index)
 341     {
 342         STRPTR text = NULL;
 343         DoMethod(listobj, MUIM_List_GetEntry, num_ttypes, (IPTR)&text);
 344         if (num_ttypes >= alloc_ttypes)
 345         {
 346             UBYTE **new_dst_ttypes = AllocPooled(pool, (alloc_ttypes + 10 + 2) * sizeof(UBYTE *));
 347             if (!new_dst_ttypes)
 348             {
 349                 DeletePool(pool);
 350                 return NULL;
 351             }
 352             CopyMem(dst_ttypes + 1, new_dst_ttypes + 1, alloc_ttypes * sizeof(UBYTE *));
 353             dst_ttypes = new_dst_ttypes;
 354             alloc_ttypes += 10;
 355         }
 356         dst_ttypes[num_ttypes + 1] = AllocPooled(pool, strlen(text) + 1);
 357         if (!dst_ttypes[num_ttypes + 1])
 358         {
 359             DeletePool(pool);
 360             return NULL;
 361         }
 362         CopyMem(text, dst_ttypes[num_ttypes + 1], strlen(text) + 1);
 363 D(bug("[WBInfo] tooltype #%ld %s\n", num_ttypes + 1, text));
 364         num_ttypes++;
 365     }
 366     dst_ttypes[0] = (APTR)pool;
 367     return dst_ttypes + 1;
 368 #endif
 369 }
 370
 371 void FreeToolTypes(UBYTE **ttypes)
 372 {
 373 #if USE_TEXTEDITOR
 374     if (ttypes)
 375     {
 376     FreeVec((APTR)ttypes[-1]);
 377         DeletePool((APTR)ttypes[-2]);
 378     }
 379 #else
 380     if (ttypes)
 381     {
 382         DeletePool((APTR)ttypes[-1]);
 383     }
 384 #endif
 385 }
 386
 387 void SaveIcon(struct DiskObject *icon, STRPTR name, BPTR cd)
 388 {
 389     STRPTR tool = NULL, stack = NULL;
 390     BPTR restored_cd;
 391     long int ls;
 392     UBYTE **ttypes = NULL, **old_ttypes = NULL;
 393
 394     restored_cd = CurrentDir(cd);
 395
 396     switch(icon->do_Type)
 397     {
 398         case WBPROJECT:
 399             get(filename_string, MUIA_String_Contents, &tool);
 400             icon->do_DefaultTool = tool;
 401             get(stackspace, MUIA_String_Contents, &stack);
 402             stcd_l(stack, &ls);
 403             icon->do_StackSize = (LONG)ls;
 404             break;
 405         case WBTOOL:
 406             get(stackspace, MUIA_String_Contents, &stack);
 407             stcd_l(stack, &ls);
 408             icon->do_StackSize = (LONG)ls;
 409             break;
 410     }
 411
 412     old_ttypes = (UBYTE **)icon->do_ToolTypes;
 413     ttypes = BuildToolTypes(old_ttypes);
 414     icon->do_ToolTypes = ttypes;
 415
 416     PutIconTags(name, icon, TAG_DONE);
 417
 418     icon->do_ToolTypes = old_ttypes;
 419     if (ttypes)
 420     {
 421         FreeToolTypes(ttypes);
 422     }
 423     CurrentDir(restored_cd);
 424     icon_altered = FALSE;
 425 }
 426
 427 void SaveFile(struct AnchorPath * ap, BPTR cd)
 428 {
 429     ULONG protection = 0;
 430     STRPTR text=NULL;
 431     BPTR restored_cd;
 432     restored_cd = CurrentDir(cd);
 433
 434     get(commentspace, MUIA_String_Contents, &text);
 435     if (text)
 436         SetComment(ap->ap_Buf, text);
 437
 438     if (XGET(scriptobject, MUIA_Selected))
 439         protection |= FIBF_SCRIPT;
 440     if (XGET(pureobject, MUIA_Selected))
 441         protection |= FIBF_PURE;
 442     if (XGET(archiveobject, MUIA_Selected))
 443         protection |= FIBF_ARCHIVE;
 444
 445     if (! XGET(readobject, MUIA_Selected))
 446         protection |= FIBF_READ;
 447     if (! XGET(writeobject, MUIA_Selected))
 448         protection |= FIBF_WRITE;
 449     if (! XGET(executeobject, MUIA_Selected))
 450         protection |= FIBF_EXECUTE;
 451     if (! XGET(deleteobject, MUIA_Selected))
 452         protection |= FIBF_DELETE;
 453
 454     SetProtection(ap->ap_Buf, protection);
 455
 456     CurrentDir(restored_cd);
 457     file_altered = FALSE;
 458 }
 459
 460 #if !USE_TEXTEDITOR
 461 void ListToString(void)
 462 {
 463     STRPTR text = NULL;
 464     DoMethod(list, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, (IPTR) &text);
 465     if (text)
 466     {
 467         set(liststr, MUIA_String_Contents, text);
 468         nnset(liststr, MUIA_Disabled, FALSE);
 469         set(window, MUIA_Window_ActiveObject, (IPTR)liststr);
 470     }
 471 }
 472
 473 void StringToKey(void)
 474 {
 475     STRPTR  text = NULL;
 476     STRPTR  input = NULL;
 477
 478     icon_altered = TRUE;
 479
 480     DoMethod(list, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, (IPTR) &text);
 481     if (text)
 482     {
 483         get(liststr, MUIA_String_Contents, &input);
 484             DoMethod(list, MUIM_List_InsertSingle, input, MUIV_List_Insert_Active);
 485             set(list, MUIA_List_Active, MUIV_List_Active_Down);
 486             DoMethod(list, MUIM_List_Remove, MUIV_List_Remove_Active);
 487             nnset(liststr, MUIA_String_Contents, (IPTR) "");
 488             nnset(liststr, MUIA_Disabled, TRUE);
 489             set(window, MUIA_Window_ActiveObject, (IPTR)savebutton);
 490     }
 491 }
 492
 493 void NewKey(void)
 494 {
 495     nnset(liststr, MUIA_String_Contents, "");
 496     nnset(liststr, MUIA_Disabled, FALSE);
 497     DoMethod(list, MUIM_List_InsertSingle, "", MUIV_List_Insert_Bottom);
 498     nnset(list, MUIA_List_Active, MUIV_List_Active_Bottom);
 499     set(window, MUIA_Window_ActiveObject, (IPTR) liststr);
 500 }
 501
 502 void DelKey(void)
 503 {
 504     STRPTR  text = NULL;
 505     DoMethod(list, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, (IPTR)&text);
 506
 507     if (text)
 508     {
 509         DoMethod(list, MUIM_List_Remove, MUIV_List_Remove_Active);
 510         DoMethod(list, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, (IPTR)&text);
 511         if (!text)
 512         {
 513             nnset(liststr, MUIA_String_Contents, (IPTR) "");
 514             nnset(liststr, MUIA_Disabled, TRUE);
 515             ListToString();
 516         } else {
 517             ListToString();
 518         }
 519     }
 520 }
 521 #endif
 522
 523 static char * GetVersion(STRPTR name, BPTR cd)
 524 {
 525 D(bug("[WBINFO/Getversion] Name %s\n", name));
 526     STRPTR commandline = NULL;
 527     ULONG commandlineSize;
 528     static TEXT result[100]; // must be static because we return its address
 529     char *retval = result;
 530     TEXT tmpfilename[40];
 531     int nr = 0;
 532     int i;
 533     BPTR output = BNULL;
 534     BPTR restored_cd = (BPTR)-1;
 535
 536     if (name == NULL)
 537     {
 538 D(bug("[WBINFO/Getversion] Name is Null\n"));
 539         goto exit;
 540     }
 541
 542     memset(result, 0, sizeof(result));
 543     result[0] = '?';
 544
 545     commandlineSize = strlen(name) + 20;
 546     commandline = AllocVec(commandlineSize, MEMF_CLEAR);
 547     if (commandline == NULL)
 548     {
 549 D(bug("[WBInfo/GetVersion] Can't allocate RAM for commandline\n"));
 550         goto exit;
 551     }
 552
 553     restored_cd = CurrentDir(cd);
 554
 555     //search for non-existing temp file name
 556     do
 557     {
 558         nr++;
 559         if (nr > 30)
 560         {
 561 D(bug("[WBINFO/Getversion] Can't find non-existing tmpfile"));
 562             goto exit;
 563         }
 564         sprintf(tmpfilename, "t:tmp_version_%d", nr);
 565         output = Open(tmpfilename, MODE_OLDFILE);
 566         if (output)
 567         {
 568             Close(output);
 569         }
 570     } while (output != BNULL);
 571
 572     D(bug("[WBInfo/Getversion] tmpfilename %s\n", tmpfilename));
 573     output = Open(tmpfilename, MODE_NEWFILE);
 574     if (output == BNULL)
 575     {
 576 D(bug("[WBInfo/Getversion] Can't create tmpfile\n"));
 577         goto exit;
 578     }
 579
 580     // call c:version
 581     sprintf(commandline, "c:version \"%s\" full", name);
 582 D(bug("[WBInfo/GetVersion] Commandline %s\n", commandline));
 583     if (SystemTags(commandline,
 584                 SYS_Output,   (IPTR) output,
 585                 //SYS_Error,    (IPTR) NULL,
 586                 NP_StackSize,        16000,
 587                 TAG_DONE) != 0)
 588     {
 589 D(bug("[WBInfo/Getversion] SystemTags failed\n"));
 590         goto exit;
 591     }
 592
 593     // Seek didn't work for me on RAM-Disk, so we reopen the file
 594     Close(output);
 595     output = Open(tmpfilename, MODE_OLDFILE);
 596     if (output == BNULL)
 597     {
 598 D(bug("[WBInfo/GetVersion] Can't open tmpfile\n"));
 599         goto exit;
 600     }
 601     // read result
 602     if (Read(output, result, sizeof(result) - 1) == -1)
 603     {
 604 D(bug("[WBInfo/GetVersion] Can't read from tmpfile\n"));
 605         goto exit;
 606     }
 607 D(bug("[WBInfo/GetVersion] Result %s\n", result));
 608
 609     // remove illegal chars (e.g. newline) from result
 610     for (i = 0 ; result[i] != 0 ; i++)
 611     {
 612         if (result[i] < 32)
 613             result[i] = ' ';
 614     }
 615
 616     // set string pointer after program name
 617     while (*retval != ' ')
 618         retval++;
 619
 620 exit:
 621     FreeVec(commandline);
 622     if (output)
 623     {
 624         Close(output);
 625         DeleteFile(tmpfilename);
 626     }
 627     if (restored_cd != (BPTR)-1)
 628         CurrentDir(restored_cd);
 629
 630     return retval;
 631 }
 632
 633 static void AddStackField(Object * application, Object * group, STRPTR stack)
 634 {
 635     Object * stacklabel = NULL;
 636
 637     stackspace = (Object *)StringObject,
 638         StringFrame,
 639         MUIA_String_MaxLen, 16,
 640         MUIA_String_Contents, (IPTR)stack,
 641         MUIA_String_Format, MUIV_String_Format_Right,
 642         MUIA_String_Accept, (IPTR)"0123456789",
 643         End;
 644
 645     stacklabel = MUI_MakeObject(MUIO_Label, _(MSG_STACK), NULL);
 646
 647     if ((stackspace != NULL) && (stacklabel != NULL))
 648     {
 649         DoMethod(group, MUIM_Group_InitChange);
 650         DoMethod(group, OM_ADDMEMBER, stacklabel);
 651         DoMethod(group, OM_ADDMEMBER, stackspace);
 652         DoMethod(group, MUIM_Group_ExitChange);
 653         SetAttrs(stackspace, MUIA_CycleChain, 1, TAG_DONE);
 654         DoMethod(stackspace, MUIM_Notify,
 655         MUIA_String_Acknowledge, MUIV_EveryTime,
 656         (IPTR) application, 2, MUIM_Application_ReturnID, RETURNID_STACKACK);
 657     }
 658 }
 659
 660 static void AddToolField(Object * application, Object * group, STRPTR tool)
 661 {
 662     Object * toolspace = MUI_NewObject(MUIC_Popasl, ASLFR_DoSaveMode, TRUE,
 663         MUIA_Popstring_String, (IPTR)(filename_string = (Object *)StringObject,
 664         StringFrame,
 665         MUIA_String_MaxLen, MAX_PATH_LEN,
 666         MUIA_String_Contents, (IPTR)tool,
 667         End),
 668         MUIA_Popstring_Button, (IPTR) PopButton(MUII_PopFile), TAG_DONE);
 669
 670     Object * toollabel = MUI_MakeObject(MUIO_Label, _(MSG_DEFTOOL), NULL);
 671
 672     if ((toolspace != NULL) && (toollabel != NULL)&&(filename_string != NULL))
 673     {
 674         DoMethod(group, MUIM_Group_InitChange);
 675         DoMethod(group, OM_ADDMEMBER, toollabel);
 676         DoMethod(group, OM_ADDMEMBER, toolspace);
 677         DoMethod(group, MUIM_Group_ExitChange);
 678
 679         set(toolspace, MUIA_CycleChain, 1);
 680         DoMethod(filename_string, MUIM_Notify,
 681         MUIA_String_Acknowledge, MUIV_EveryTime,
 682         (IPTR) application, 2, MUIM_Application_ReturnID, RETURNID_TOOLACK);
 683     }
 684 }
 685
 686 static void AddEmptySpace(Object * group)
 687 {
 688     Object * emptyspace = MUI_NewObject(MUIC_Rectangle, TAG_DONE);
 689     if ((emptyspace != NULL))
 690     {
 691         DoMethod(group, MUIM_Group_InitChange);
 692         DoMethod(group, OM_ADDMEMBER, emptyspace);
 693         DoMethod(group, MUIM_Group_ExitChange);
 694     }
 695 }
 696
 697 int main(int argc, char **argv)
 698 {
 699     Object *application, *grouptool, *groupstack = NULL;
 700     Object *registergroup = NULL, *infomenu = NULL, *protectmenu = NULL, *toolmenu = NULL;
 701     Object *datespace = NULL, *typespace = NULL, *quit = NULL, *aboutmenu = NULL;
 702     Object *sizegrp = NULL, *versiongrp = NULL, *versionspace = NULL;
 703     Object *cancelbutton = NULL;
 704 #if !USE_TEXTEDITOR
 705     Object *newkey = NULL, *delkey = NULL;
 706 #endif
 707     struct WBStartup *startup;
 708     struct DiskObject *icon = NULL;
 709     struct AnchorPath *ap = NULL;
 710     struct DateStamp *ds = NULL;
 711     struct DateTime dt;
 712 #if 0 /* unused */
 713     IPTR dte;
 714 #endif
 715     STRPTR name = NULL, file = NULL, type = NULL;
 716     BPTR cd, lock;
 717     LONG  returnid = 0;
 718     ULONG protection;
 719     char stack[16];
 720     char deftool[MAX_PATH_LEN];
 721     char size[64];
 722     char date[LEN_DATSTRING];
 723     char time[LEN_DATSTRING];
 724     char  dow[LEN_DATSTRING];
 725     char datetime[2*LEN_DATSTRING];
 726     UBYTE flags[8] = {0}, lname[MAXFILENAMELENGTH];
 727
 728     char *pages[] = {_(MSG_INFORMATION),_(MSG_PROTECTION),_(MSG_TOOLTYPES),NULL};
 729     char * typeNames[] =
 730     {
 731          NULL,      /* not used */
 732         _(MSG_DISK),    /* 1 */
 733         _(MSG_DRAWER),  /* 2 */
 734         _(MSG_TOOL),    /* 3 */
 735         _(MSG_PROJECT), /* 4 */
 736         _(MSG_GARBAGE), /* 5 */
 737         _(MSG_DEVICE),  /* 6 */
 738         _(MSG_KICK),    /* 7 */
 739         _(MSG_APPICON)  /* 8 */
 740     };
 741
 742     int retval = RETURN_OK;
 743
 744     if (argc != 0)
 745     {
 746         /* start from wanderer only */
 747         PrintFault(ERROR_FILE_NOT_OBJECT, argv[0]);
 748         retval = RETURN_FAIL;
 749     goto funcmain_exit;
 750     }
 751
 752     startup = (struct WBStartup *) argv;
 753
 754     if (startup->sm_NumArgs < 2)
 755     {
 756         /* need atleast 1 arg */
 757         PrintFault(ERROR_REQUIRED_ARG_MISSING, argv[0]);
 758 D(bug("[WBInfo] required arg missing\n"));
 759         retval = RETURN_FAIL;
 760     goto funcmain_exit;
 761     }
 762
 763     lock = startup->sm_ArgList[1].wa_Lock;
 764     NameFromLock(lock, lname, MAXFILENAMELENGTH);
 765 D(bug("[WBInfo] arg parent lock 0x%p: '%s'\n", lock, lname));
 766
 767     if (startup->sm_ArgList[1].wa_Name != NULL)
 768     {
 769     if ((name = AllocVec(strlen(startup->sm_ArgList[1].wa_Name) + 1, MEMF_CLEAR)) != NULL)
 770     {
 771         CopyMem(startup->sm_ArgList[1].wa_Name, name, strlen(startup->sm_ArgList[1].wa_Name));
 772         if ((strlen(name) > 5)
 773         && (strcmp(name + strlen(name) - 5, ".info") == 0))
 774         {
 775         file = AllocVec(strlen(name) - 4, MEMF_CLEAR);
 776         CopyMem(name, file , strlen(name) - 5);
 777         }
 778         else
 779         {
 780         file = AllocVec(strlen(name) + 1, MEMF_CLEAR);
 781         CopyMem(name, file, strlen(name));
 782         }
 783     D(bug("[WBInfo] arg name 0x%p: '%s', file = '%s'\n", name, name, file));
 784     }
 785     }
 786     cd = CurrentDir(lock);
 787     if (name == NULL)
 788     {
 789         /* directory not found*/
 790         PrintFault(ERROR_DIR_NOT_FOUND, argv[0]);
 791 D(bug("[WBInfo] dir not found\n"));
 792         retval = RETURN_FAIL;
 793     goto funcmain_exit;
 794     };
 795
 796     ap = AllocVec(sizeof(struct AnchorPath) + MAX_PATH_LEN, MEMF_CLEAR);
 797     if (ap == NULL)
 798     {
 799         PrintFault(ERROR_NO_FREE_STORE, argv[0]);
 800 D(bug("[WBInfo] no free store\n"));
 801         retval = RETURN_FAIL;
 802     goto funcmain_exit;
 803     }
 804
 805     ap->ap_Strlen = MAX_PATH_LEN;
 806
 807     if (0 != MatchFirst(name, ap))
 808     {
 809 D(bug("[WBInfo] pass to diskinfo\n"));
 810         OpenWorkbenchObject(
 811             "WANDERER:Tools/DiskInfo",
 812             WBOPENA_ArgLock, (IPTR) startup->sm_ArgList[1].wa_Lock,
 813             WBOPENA_ArgName, (IPTR) startup->sm_ArgList[1].wa_Name,
 814             TAG_DONE);
 815
 816         retval = RETURN_OK;
 817     goto funcmain_exit;
 818     };
 819
 820     ap->ap_BreakBits = SIGBREAKF_CTRL_C;
 821
 822     if (!(ap->ap_Flags & APF_DIDDIR))
 823     {
 824 D(bug("[WBInfo] scan file\n"));
 825         /* fill comment */
 826         sprintf(loadedcomment,"%s",ap->ap_Info.fib_Comment);
 827
 828         /* fill date and time */
 829         ds = &ap->ap_Info.fib_Date;
 830         DateStamp((struct DateStamp *)&dt);
 831         CopyMem(ds, &dt.dat_Stamp, sizeof(struct DateStamp));
 832         dt.dat_Format = FORMAT_DOS;
 833         dt.dat_Flags = 0;
 834         dt.dat_StrDay = dow;
 835         dt.dat_StrDate = date;
 836         dt.dat_StrTime = time;
 837 #if 0 /* unused */
 838         dte =
 839 #endif
 840                DateToStr(&dt);
 841         sprintf(datetime, "%s %s", time, date);
 842
 843         /* fill size */
 844         getReadableSize(size, ap->ap_Info.fib_Size, TRUE);
 845
 846         /* fill protection */
 847         protection = ap->ap_Info.fib_Protection;
 848
 849     /* Convert the protection bits to a boolean */
 850         flags[0] = protection & FIBF_SCRIPT  ? 1 : 0; /* s */
 851         flags[1] = protection & FIBF_PURE    ? 1 : 0; /* p */
 852         flags[2] = protection & FIBF_ARCHIVE ? 1 : 0; /* a */
 853
 854     /* The following flags are high-active! */
 855         flags[3] = protection & FIBF_READ    ? 0 : 1; /* r */
 856         flags[4] = protection & FIBF_WRITE   ? 0 : 1; /* w */
 857         flags[5] = protection & FIBF_EXECUTE ? 0 : 1; /* e */
 858         flags[6] = protection & FIBF_DELETE  ? 0 : 1; /* d */
 859         flags[7] = 0x00;                              /* h */
 860     }
 861
 862     /* read icon */
 863     icon = GetIconTags(file,
 864             ICONGETA_FailIfUnavailable, FALSE,
 865             ICONGETA_IsDefaultIcon, FALSE,
 866             TAG_DONE);
 867
 868     if (icon != NULL)
 869     {
 870 D(bug("[WBInfo] file has icon\n"));
 871         type = (char *) typeNames[icon->do_Type];
 872 D(bug("[WBInfo] icon type is: %s\n", type));
 873         sprintf(stack, "%d", (int)icon->do_StackSize);
 874         if (icon->do_DefaultTool)
 875             sprintf(deftool, "%s", icon->do_DefaultTool);
 876         else
 877             *deftool = '\0';
 878     } else {
 879         PrintFault(ERROR_OBJECT_WRONG_TYPE, argv[0]);
 880
 881     retval = RETURN_FAIL;
 882         goto funcmain_exit;
 883     }
 884
 885     if (icon->do_Type == 2)
 886     {
 887     sizespace = (Object *)TextObject,
 888         ButtonFrame,
 889         MUIA_Background, MUII_TextBack,
 890         MUIA_Text_PreParse, (IPTR) "\33r",
 891         MUIA_Text_Contents, (IPTR) "?",
 892         MUIA_InputMode, MUIV_InputMode_RelVerify,
 893         End;
 894
 895     versionspace = (Object *)TextObject,
 896         TextFrame,
 897         MUIA_Background, MUII_TextBack,
 898         MUIA_Text_PreParse, (IPTR) "\33r",
 899         MUIA_Text_Contents, (IPTR) "N/A",
 900         End;
 901     }
 902     else
 903     {
 904     sizespace = (Object *)TextObject,
 905         TextFrame,
 906         MUIA_Background, MUII_TextBack,
 907         MUIA_Text_PreParse, (IPTR) "\33r",
 908         MUIA_Text_Contents, (IPTR) size,
 909         End;
 910
 911     versionspace = (Object *)TextObject,
 912         ButtonFrame,
 913         MUIA_Background, MUII_TextBack,
 914         MUIA_Text_PreParse, (IPTR) "\33r",
 915         MUIA_Text_Contents, (IPTR) "?",
 916         MUIA_InputMode, MUIV_InputMode_RelVerify,
 917         End;
 918     }
 919
 920     application = (Object *)ApplicationObject,
 921         MUIA_Application_Title,  __(MSG_TITLE),
 922         MUIA_Application_Version, (IPTR) "$VER: Info 0.8 ("ADATE") © 2003-2011 The AROS Dev Team",
 923         MUIA_Application_Description,  __(MSG_DESCRIPTION),
 924         MUIA_Application_Base, (IPTR) "INFO",
 925         MUIA_Application_Menustrip, (IPTR) MenustripObject,
 926             MUIA_Family_Child, (IPTR) MenuObject,
 927                 MUIA_Menu_Title,  __(MSG_PROJECT),
 928                 MUIA_Family_Child, (IPTR)(infomenu = (Object *)MenuitemObject, MUIA_Menuitem_Title,
 929                         __(MSG_INFORMATION), MUIA_Menuitem_Shortcut, (IPTR) "I", End),
 930                 MUIA_Family_Child, (IPTR)(protectmenu = (Object *)MenuitemObject, MUIA_Menuitem_Title,
 931                         __(MSG_PROTECTION),MUIA_Menuitem_Shortcut, (IPTR) "P", End),
 932                 MUIA_Family_Child, (IPTR)(toolmenu = (Object *)MenuitemObject, MUIA_Menuitem_Title,
 933                         __(MSG_TOOLTYPES),MUIA_Menuitem_Shortcut, (IPTR) "T", End),
 934                 MUIA_Family_Child, (IPTR) MenuitemObject, MUIA_Menuitem_Title, ~0, End,
 935                 MUIA_Family_Child, (IPTR) (aboutmenu = (Object *)MenuitemObject, MUIA_Menuitem_Title,
 936                     __(MSG_ABOUT), (IPTR) MUIA_Menuitem_Shortcut, (IPTR) "?", End),
 937                 MUIA_Family_Child, (IPTR) MenuitemObject, MUIA_Menuitem_Title, ~0, End,
 938                 MUIA_Family_Child, (IPTR) (quit = (Object *)MenuitemObject, MUIA_Menuitem_Title,
 939                     __(MSG_QUIT), MUIA_Menuitem_Shortcut, (IPTR) "Q", End),
 940                 End,
 941             End,
 942         SubWindow, (IPTR) (window = (Object *)WindowObject,
 943             MUIA_Window_Title, (IPTR) __(MSG_TITLE),
 944             MUIA_Window_ID, MAKE_ID('I','N','F','O'),
 945             MUIA_Window_Activate, TRUE,
 946             WindowContents, (IPTR) VGroup,
 947                 Child, (IPTR) HGroup,
 948                     Child, (IPTR) VGroup,
 949                         Child, (IPTR) IconImageObject,
 950                             MUIA_InputMode, MUIV_InputMode_Toggle,
 951                             MUIA_IconImage_File, (IPTR) file,
 952                         End,
 953                     End,
 954                     Child, (IPTR) VGroup,
 955                         Child, (IPTR) TextObject,
 956                             TextFrame,
 957                             MUIA_Background, MUII_TextBack,
 958                             MUIA_Text_PreParse, (IPTR) "\33l",
 959                             MUIA_Text_Contents, (IPTR) FilePart(file),
 960                         End,
 961                     End,
 962                 End,
 963                 Child, (IPTR) (registergroup = (Object *)RegisterGroup(pages),
 964                     MUIA_CycleChain, 1,
 965                     Child, (IPTR) HGroup, /* hgroup information pannel */
 966                         Child, (IPTR) VGroup,
 967                             Child, (IPTR) HGroup,
 968                                 Child, (IPTR) ColGroup(2),
 969                                     Child, (IPTR) Label2(__(MSG_TYPE)),
 970                                     Child, (IPTR) (typespace = (Object *)TextObject,
 971                                         TextFrame,
 972                                         MUIA_Background, MUII_TextBack,
 973                                         MUIA_Text_PreParse, (IPTR) "\33r",
 974                                         MUIA_Text_Contents, (IPTR) type,
 975                                     End),
 976                                    Child, (IPTR) Label2(__(MSG_DATE)),
 977                                     Child, (IPTR) (datespace = (Object *)TextObject,
 978                                         TextFrame,
 979                                         MUIA_Background, MUII_TextBack,
 980                                         MUIA_Text_PreParse, (IPTR) "\33r",
 981                                         MUIA_Text_Contents, (IPTR) datetime,
 982                                     End),
 983                                     Child, (IPTR) Label2(__(MSG_VERSION)),
 984                                     Child, (IPTR) (versiongrp = (Object *)HGroup,
 985                     Child, (IPTR) versionspace,
 986                     End),
 987                                     Child, (IPTR) Label2(__(MSG_SIZE)),
 988                                     Child, (IPTR) (sizegrp = (Object *)HGroup,
 989                     Child, (IPTR) sizespace,
 990                     End),
 991                                  End,
 992                             End,
 993                             Child, (IPTR) HVSpace,
 994                             Child, (IPTR) (grouptool = (Object *)HGroup,
 995                             End),
 996                             Child, (IPTR) (groupstack = (Object *)HGroup,
 997                             End),
 998                             Child, (IPTR) HGroup,
 999                                 Child, (IPTR) Label2(__(MSG_COMMENT)),
1000                                 Child, (IPTR) (commentspace = (Object *)StringObject,
1001                                     StringFrame,
1002                                     MUIA_CycleChain, 1,
1003                                 End),
1004                             End,
1005                         End,
1006                     End, /* end hgroup information pannel */
1007                     Child, (IPTR) HGroup, /* hgroup protections pannel */
1008             Child, (IPTR) HVSpace,
1009                         Child, (IPTR) VGroup,
1010                 Child, (IPTR) HVSpace,
1011                 Child, (IPTR) ColGroup(4),
1012                 Child, (IPTR) Label2(_(MSG_READ)),
1013                 Child, (IPTR) (readobject = MUI_MakeObject(MUIO_Checkmark,NULL)),
1014                 Child, (IPTR) Label2(_(MSG_SCRIPT)),
1015                 Child, (IPTR) (scriptobject = MUI_MakeObject(MUIO_Checkmark,NULL)),
1016                 Child, (IPTR) Label2(_(MSG_WRITE)),
1017                 Child, (IPTR) (writeobject = MUI_MakeObject(MUIO_Checkmark,NULL)),
1018                 Child, (IPTR) Label2(_(MSG_PURE)),
1019                 Child, (IPTR) (pureobject = MUI_MakeObject(MUIO_Checkmark,NULL)),
1020                 Child, (IPTR) Label2(_(MSG_EXECUTE)),
1021                 Child, (IPTR) (executeobject = MUI_MakeObject(MUIO_Checkmark,NULL)),
1022                 Child, (IPTR) Label2(_(MSG_ARCHIVED)),
1023                 Child, (IPTR) (archiveobject = MUI_MakeObject(MUIO_Checkmark,NULL)),
1024                 Child, (IPTR) Label2(_(MSG_DELETE)),
1025                 Child, (IPTR) (deleteobject = MUI_MakeObject(MUIO_Checkmark,NULL)),
1026                 Child, (IPTR) HVSpace,
1027                 Child, (IPTR) HVSpace,
1028                 End,
1029                 Child, (IPTR) HVSpace,
1030                         End,
1031             Child, (IPTR) HVSpace,
1032                     End, /* end hgroup protections pannel */
1033                     Child, (IPTR) HGroup, /* hgroup tooltypes pannel */
1034                         Child, (IPTR) VGroup,
1035                             Child, (IPTR) HGroup,
1036                                 Child, (IPTR) VGroup,
1037                                 GroupSpacing(0),
1038                 #if !USE_TEXTEDITOR
1039                                     Child, (IPTR) ListviewObject,
1040                                         MUIA_Listview_List, (IPTR) (list = ListObject,
1041                                         InputListFrame,
1042                                             MUIA_List_ConstructHook, MUIV_List_ConstructHook_String,
1043                                             MUIA_List_DestructHook, MUIV_List_DestructHook_String,
1044                                             MUIA_List_AutoVisible, TRUE,
1045                                         End),
1046                                     End,
1047                                     Child, (IPTR) (liststr = StringObject,
1048                                         MUIA_Disabled, TRUE,
1049                                         StringFrame,
1050                                     End),
1051                 #else
1052                     Child, (IPTR) HGroup,
1053                         GroupSpacing(0),
1054                         Child, (IPTR) (editor = MUI_NewObject(MUIC_TextEditor,
1055                         TAG_DONE)),
1056                     Child, (IPTR) (slider = (Object *)ScrollbarObject,
1057                     End),
1058                     End,
1059                 #endif
1060                                 End,
1061                             End,
1062             #if !USE_TEXTEDITOR
1063                             Child, (IPTR) HGroup,
1064                                 MUIA_Group_SameSize, TRUE,
1065                                 Child, (IPTR) (newkey = SimpleButton(__(MSG_NEW_KEY))),
1066                                 Child, (IPTR) (delkey = SimpleButton(__(MSG_DELETE_KEY))),
1067                             End,
1068             #endif
1069                         End,
1070                     End, /* end hgroup tooltypes pannel */
1071                 End),
1072                 Child, (IPTR) HGroup,
1073                     MUIA_Group_SameSize, TRUE,
1074                     Child, (IPTR) (savebutton =
1075                      ImageButton(_(MSG_SAVE),"THEME:Images/Gadgets/OK")),
1076                     Child, (IPTR) (cancelbutton =
1077                      ImageButton(_(MSG_CANCEL),"THEME:Images/Gadgets/Cancel")),
1078                 End,
1079             End,
1080         End),
1081     End;
1082
1083     CurrentDir(cd);
1084
1085     if (application != NULL)
1086     {
1087         ULONG signals = 0;
1088
1089     #if !USE_TEXTEDITOR
1090         set(liststr, MUIA_String_AttachedList, (IPTR)list);
1091     #endif
1092
1093         // menu
1094         DoMethod(aboutmenu, MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime,
1095             (IPTR) application, 2,
1096             MUIM_Application_ReturnID, RETURNID_ABOUT);
1097         DoMethod(infomenu, MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime,
1098             (IPTR) registergroup, 3, MUIM_Set, MUIA_Group_ActivePage, 0);
1099         DoMethod(protectmenu, MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime,
1100             (IPTR) registergroup, 3, MUIM_Set, MUIA_Group_ActivePage, 1);
1101         DoMethod(toolmenu, MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime,
1102             (IPTR) registergroup, 3, MUIM_Set, MUIA_Group_ActivePage, 2);
1103         DoMethod(quit, MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime,
1104             (IPTR) application, 2, MUIM_Application_ReturnID,
1105             MUIV_Application_ReturnID_Quit);
1106
1107         DoMethod(cancelbutton, MUIM_Notify, MUIA_Pressed, FALSE,
1108             (IPTR) application, 2,
1109             MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
1110         DoMethod(savebutton, MUIM_Notify, MUIA_Pressed, FALSE,
1111             (IPTR) application, 2,
1112             MUIM_Application_ReturnID, RETURNID_SAVE);
1113         DoMethod(application, MUIM_Notify, MUIA_Application_Sleep, FALSE,
1114             (IPTR) application, 2,
1115             MUIM_Application_ReturnID, RETURNID_WAKE);
1116         DoMethod(application, MUIM_Notify, MUIA_Application_Sleep, TRUE,
1117             (IPTR) application, 2,
1118             MUIM_Application_ReturnID, RETURNID_SLEEP);
1119         DoMethod(window, MUIM_Notify, MUIA_Window_CloseRequest, TRUE,
1120             (IPTR) application, 2, MUIM_Application_ReturnID,
1121             MUIV_Application_ReturnID_Quit );
1122     #if !USE_TEXTEDITOR
1123         DoMethod(newkey, MUIM_Notify, MUIA_Pressed, FALSE,
1124             (IPTR) application, 2, MUIM_Application_ReturnID, RETURNID_NEWKEY);
1125         DoMethod(delkey, MUIM_Notify, MUIA_Pressed, FALSE,
1126             (IPTR) application, 2, MUIM_Application_ReturnID, RETURNID_DELKEY);
1127         DoMethod(list, MUIM_Notify, MUIA_List_Active, MUIV_EveryTime,
1128             (IPTR) application, 2, MUIM_Application_ReturnID, RETURNID_LVACK);
1129         DoMethod(liststr, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
1130             (IPTR) application, 2, MUIM_Application_ReturnID, RETURNID_STRINGACK);
1131     #endif
1132         DoMethod(commentspace, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
1133             (IPTR) application, 2, MUIM_Application_ReturnID, RETURNID_COMMENTACK);
1134         DoMethod(versionspace, MUIM_Notify, MUIA_Pressed, FALSE,
1135             (IPTR) application, 2,
1136             MUIM_Application_ReturnID, RETURNID_QUERYVERSION);
1137     DoMethod(sizespace, MUIM_Notify, MUIA_Pressed, FALSE,
1138         (IPTR) application, 2,
1139         MUIM_Application_ReturnID, RETURNID_SCANSIZE);
1140         DoMethod(readobject, MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
1141             (IPTR) application, 2,
1142             MUIM_Application_ReturnID, RETURNID_PROTECT);
1143         DoMethod(writeobject, MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
1144             (IPTR) application, 2,
1145             MUIM_Application_ReturnID, RETURNID_PROTECT);
1146         DoMethod(executeobject, MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
1147             (IPTR) application, 2,
1148             MUIM_Application_ReturnID, RETURNID_PROTECT);
1149         DoMethod(deleteobject, MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
1150             (IPTR) application, 2,
1151             MUIM_Application_ReturnID, RETURNID_PROTECT);
1152         DoMethod(scriptobject, MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
1153             (IPTR) application, 2,
1154             MUIM_Application_ReturnID, RETURNID_PROTECT);
1155         DoMethod(pureobject, MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
1156             (IPTR) application, 2,
1157             MUIM_Application_ReturnID, RETURNID_PROTECT);
1158         DoMethod(archiveobject, MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
1159             (IPTR) application, 2,
1160             MUIM_Application_ReturnID, RETURNID_PROTECT);
1161
1162     #if USE_TEXTEDITOR
1163         set(editor, MUIA_TextEditor_Slider, slider);
1164
1165         if (icon->do_ToolTypes)
1166         {
1167             char *tt = NULL, *contents;
1168             int   i  = 0;
1169         ULONG len = 0;
1170
1171             while ((tt = icon->do_ToolTypes[i]) != NULL)
1172             {
1173             len += strlen(icon->do_ToolTypes[i]) + 1;
1174         i++;
1175         }
1176
1177         contents = AllocVec(len + 1, MEMF_ANY);
1178         if (contents)
1179         {
1180             contents[0] = 0;
1181         i = 0;
1182         BOOL first = TRUE;
1183
1184             while ((icon->do_ToolTypes[i]) != NULL)
1185             {
1186             if ( ! first )
1187             {
1188             strcat(contents, "\n");
1189             }
1190             first = FALSE;
1191             strcat(contents, icon->do_ToolTypes[i]);
1192
1193             i++;
1194         }
1195
1196                 set(editor, MUIA_TextEditor_Contents, contents);
1197         FreeVec(contents);
1198             }
1199         }
1200     #else
1201
1202         if (icon->do_ToolTypes)
1203         {
1204             char *tt = NULL;
1205             int   i  = 0;
1206             while ((tt = icon->do_ToolTypes[i]) != NULL)
1207             {
1208                 DoMethod(list, MUIM_List_InsertSingle, tt, MUIV_List_Insert_Bottom);
1209                 i++;
1210             }
1211         }
1212     #endif
1213
1214         switch(icon->do_Type)
1215         {
1216             case WBPROJECT:
1217                 AddToolField(application, grouptool, deftool);
1218                 AddStackField(application, groupstack, stack);
1219                 break;
1220             case WBTOOL:
1221                 AddEmptySpace(grouptool);
1222                 AddStackField(application, groupstack, stack);
1223                 break;
1224             case WBDRAWER:
1225                 AddEmptySpace(grouptool);
1226                 AddEmptySpace(groupstack);
1227                 break;
1228         }
1229
1230         if (loadedcomment[0])
1231             nnset(commentspace, MUIA_String_Contents, loadedcomment);
1232
1233         nnset(readobject, MUIA_Selected, flags[3]);
1234         nnset(writeobject, MUIA_Selected, flags[4]);
1235         nnset(executeobject, MUIA_Selected, flags[5]);
1236         nnset(deleteobject, MUIA_Selected, flags[6]);
1237
1238         nnset(scriptobject, MUIA_Selected, flags[0]);
1239         nnset(pureobject, MUIA_Selected, flags[1]);
1240         nnset(archiveobject, MUIA_Selected, flags[2]);
1241
1242         SetAttrs(window, MUIA_Window_Open, TRUE, TAG_DONE);
1243
1244         while (returnid != MUIV_Application_ReturnID_Quit)
1245         {
1246 #ifdef DEBUG
1247             if (returnid)
1248             {
1249 D(bug("[WBInfo] broker command received: %ld\n", returnid));
1250 #endif
1251                 switch(returnid)
1252                 {
1253                     case RETURNID_SLEEP:
1254                         set(window, MUIA_Window_Open, FALSE);
1255                         set(window, MUIA_Window_Activate, TRUE);
1256                         break;
1257                     case RETURNID_WAKE:
1258                         set(window, MUIA_Window_Open, TRUE);
1259                         break;
1260                     case RETURNID_ABOUT:
1261                         if (MUI_RequestA(application, NULL, 0,
1262                             _(MSG_ABOUT), _(MSG_OK), _(MSG_COPYRIGHT), NULL))
1263                         break;
1264         #if !USE_TEXTEDITOR
1265                     case RETURNID_NEWKEY:
1266                         NewKey();
1267                         break;
1268                     case RETURNID_DELKEY:
1269                         DelKey();
1270                         icon_altered = TRUE;
1271                         break;
1272                     case RETURNID_LVACK:
1273                         ListToString();
1274                         break;
1275                     case RETURNID_STRINGACK:
1276                         StringToKey();
1277                         icon_altered = TRUE;
1278                         break;
1279         #endif
1280                     case RETURNID_SAVE:
1281             #if !USE_TEXTEDITOR
1282                         if (icon_altered)
1283             #endif
1284                             SaveIcon(icon, file, lock);
1285                         {
1286                             /* This is a workardound for String.mui not sending notification on contents change */
1287                             STRPTR text = NULL;
1288                             get(commentspace, MUIA_String_Contents, &text);
1289                             if(strcmp(loadedcomment, text) != 0)
1290                                 file_altered = TRUE;
1291                         }
1292
1293                         if (file_altered)
1294                             SaveFile(ap, lock);
1295                         DoMethod(application, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
1296                         break;
1297                     case RETURNID_STACKACK:
1298                         set(window, MUIA_Window_ActiveObject, (IPTR)savebutton);
1299                         icon_altered = TRUE;
1300                         break;
1301                     case RETURNID_TOOLACK:
1302                         set(window, MUIA_Window_ActiveObject, (IPTR)savebutton);
1303                         icon_altered = TRUE;
1304                         break;
1305                     case RETURNID_COMMENTACK:
1306                         set(window, MUIA_Window_ActiveObject, (IPTR)savebutton);
1307                         file_altered = TRUE;
1308                         break;
1309                     case RETURNID_QUERYVERSION:
1310             {
1311                 Object * oldversionspace = versionspace;
1312
1313 D(bug("[WBInfo: RETURNID_QUERYVERSION\n"));
1314
1315                 versionspace = (Object *)TextObject,
1316                     TextFrame,
1317                     MUIA_Background, MUII_TextBack,
1318                     MUIA_Text_SetMin, FALSE,
1319                     MUIA_Text_PreParse, (IPTR) "\33r",
1320                     MUIA_Text_Contents, (IPTR) GetVersion(name, lock),
1321                 End;
1322
1323                 DoMethod(versiongrp, MUIM_Group_InitChange);
1324                 DoMethod(versiongrp, OM_REMMEMBER, oldversionspace);
1325                 DoMethod(versiongrp, OM_ADDMEMBER, versionspace);
1326                 DoMethod(versiongrp, MUIM_Group_ExitChange);
1327             }
1328                         break;
1329             case RETURNID_SCANSIZE:
1330             {
1331                 Object * oldsizespace = sizespace;
1332
1333 D(bug("[WBInfo]: RETURNID_SCANSIZE\n"));
1334                 sizespace = (Object *)TextObject,
1335                     TextFrame,
1336                     MUIA_Background, MUII_TextBack,
1337                     MUIA_Text_PreParse, (IPTR) "\33r",
1338                 End;
1339
1340                 DoMethod(sizegrp, MUIM_Group_InitChange);
1341                 DoMethod(sizegrp, OM_REMMEMBER, oldsizespace);
1342                 DoMethod(sizegrp, OM_ADDMEMBER, sizespace);
1343                 DoMethod(sizegrp, MUIM_Group_ExitChange);
1344
1345                 if (scanStruct == NULL)
1346                 scanStruct = AllocMem(sizeof(struct DirScanProcess), MEMF_CLEAR);
1347
1348                 scanStruct->scanState = SCANDIE;
1349 waitscan:
1350
1351                 if (scanStruct->scanProcess != NULL)
1352                 goto waitscan;
1353
1354                 ULONG dirnamelen = strlen(lname) + strlen(name);
1355                 scanStruct->scanState = SCANRUN;
1356                 scanStruct->scanDir = AllocVec(dirnamelen + 2, MEMF_CLEAR); /* 2 == path separator + \0 at end */
1357 D(bug("[WBInfo]: lname '%s', name '%s', (%d bytes)\n", lname, name, dirnamelen));
1358
1359                 CopyMem(lname, scanStruct->scanDir, strlen(lname));
1360                 AddPart(scanStruct->scanDir, name, dirnamelen + 2);
1361
1362                 char * tmp_Name = AllocVec(strlen(scanStruct->scanDir) + 24, MEMF_CLEAR);
1363                 sprintf(tmp_Name, "Calculating size of %s ..", scanStruct->scanDir);
1364
1365                 /* Fire up child process to perform scan of content size .. */
1366                 scanStruct->scanProcess = CreateNewProcTags(
1367                 NP_Entry, (IPTR)scanDir_Process,
1368                 NP_Name, tmp_Name,
1369                 NP_Synchronous , FALSE,
1370                 NP_Priority, 0,
1371                 NP_UserData, (IPTR)scanStruct,
1372                 NP_StackSize, 140960,
1373                 TAG_DONE);
1374
1375                 FreeVec(tmp_Name);
1376             }
1377             break;
1378                     case RETURNID_PROTECT:
1379                         file_altered = TRUE;
1380 D(bug("[WBInfo: Protection bits changed\n"));
1381                         break;
1382                 }
1383 #ifdef DEBUG
1384             }
1385 #endif
1386             if (signals)
1387             {
1388                 signals = Wait(signals | SIGBREAKF_CTRL_C);
1389                 if(signals & SIGBREAKF_CTRL_C) break;
1390             }
1391
1392         returnid = ((LONG) DoMethod(application, MUIM_Application_NewInput, (IPTR) &signals));
1393         }
1394     if (scanStruct)
1395     {
1396         scanStruct->scanState = SCANDIE;
1397 waitscan2:
1398         if (scanStruct->scanProcess != NULL)
1399         goto waitscan2;
1400     }
1401         SetAttrs(window, MUIA_Window_Open, FALSE, TAG_DONE);
1402         MUI_DisposeObject(application);
1403     } else {
1404         PrintFault(ERROR_INVALID_RESIDENT_LIBRARY, argv[0]);
1405 D(bug("[WBInfo: Couldn't create app\n"));
1406     retval = RETURN_FAIL;
1407     }
1408
1409 funcmain_exit:
1410     if (scanStruct) FreeMem(scanStruct, sizeof(struct DirScanProcess));
1411     if (icon) FreeDiskObject(icon);
1412     FreeVec(ap);
1413     FreeVec(file);
1414     FreeVec(name);
1415     return retval;
1416 }