workbench/system/Wanderer/wanderer.c

   1 /*
   2     Copyright  2004-2009, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5 #include "portable_macros.h"
   6
   7 #ifdef __AROS__
   8 #define MUIMASTER_YES_INLINE_STDARG
   9
  10 #define DEBUG 0
  11 #include <aros/debug.h>
  12 #endif
  13
  14 #define WANDERER_DEFAULT_BACKDROP
  15
  16 #include <exec/types.h>
  17 #include <libraries/gadtools.h>
  18 #include <libraries/mui.h>
  19
  20 #ifdef __AROS__
  21 #include <zune/customclasses.h>
  22 #else
  23 #include <zune_AROS/customclasses.h>
  24 #endif
  25
  26 #include <dos/notify.h>
  27
  28 #ifdef __AROS__
  29 #include <workbench/handler.h>
  30 #else
  31 #include <workbench_AROS/handler.h>
  32 #endif
  33
  34 #include <proto/graphics.h>
  35 #include <proto/utility.h>
  36
  37 #include <proto/dos.h>
  38
  39 #include <proto/icon.h>
  40
  41 #ifdef __AROS__
  42 #include <proto/workbench.h>
  43 #endif
  44
  45 #include <proto/layers.h>
  46
  47 #ifdef __AROS__
  48 #include <proto/alib.h>
  49 #endif
  50
  51 #include <string.h>
  52 #include <stdio.h>
  53 #include <time.h>
  54
  55
  56 #ifdef __AROS__
  57 #include <aros/detach.h>
  58 #include <prefs/wanderer.h>
  59 #else
  60 #include <prefs_AROS/wanderer.h>
  61 #endif
  62
  63 #if defined(__AMIGA__) && !defined(__PPC__)
  64 #define NO_INLINE_STDARG
  65 #endif
  66 #include <proto/intuition.h>
  67 #include <proto/muimaster.h>
  68
  69
  70 #include "iconwindow.h"
  71 #include "iconwindow_attributes.h"
  72 #include "iconwindowcontents.h"
  73 #include "wandererprefs.h"
  74 #include "wandererprefsintern.h"
  75 #include "filesystems.h"
  76 #include "wanderer.h"
  77 #include "Classes/iconlist.h"
  78 #include "Classes/iconlist_attributes.h"
  79 #include "locale.h"
  80
  81 #include "version.h"
  82
  83 #ifndef __AROS__
  84 #define DEBUG 1
  85
  86 #ifdef DEBUG
  87   #define D(x) if (DEBUG) x
  88   #ifdef __amigaos4__
  89   #define bug DebugPrintF
  90   #else
  91   #define bug kprintf
  92   #endif
  93 #else
  94   #define  D(...)
  95 #endif
  96 #endif
  97
  98 #ifndef NO_ICON_POSITION
  99 #define NO_ICON_POSITION                               (0x8000000) /* belongs to workbench/workbench.h */
 100 #endif
 101
 102 #define KeyButton(name,key) TextObject, ButtonFrame, MUIA_Font, MUIV_Font_Button, MUIA_Text_Contents, (IPTR)(name), MUIA_Text_PreParse, "\33c", MUIA_Text_HiChar, (IPTR)(key), MUIA_ControlChar, key, MUIA_InputMode, MUIV_InputMode_RelVerify, MUIA_Background, MUII_ButtonBack, TAG_DONE)
 103
 104 extern IPTR InitWandererPrefs(void);
 105 VOID        DoAllMenuNotifies(Object *strip, STRPTR path);
 106 Object      *FindMenuitem(Object* strip, int id);
 107 Object      *Wanderer__Func_CreateWandererIntuitionMenu(BOOL isRoot, BOOL useBackdrop);
 108 void        wanderer_menufunc_window_update(void);
 109 void        execute_open_with_command(BPTR cd, STRPTR contents);
 110 void        DisposeCopyDisplay(struct MUIDisplayObjects *d);
 111 BOOL        CreateCopyDisplay(UWORD flags, struct MUIDisplayObjects *d);
 112
 113 /* Stored in the main wanderer executable */
 114 extern Object       *_WandererIntern_AppObj;
 115 extern Class        *_WandererIntern_CLASS;
 116 /* Internal Hooks */
 117 #ifdef __AROS__
 118 struct Hook          _WandererIntern_hook_standard;
 119 struct Hook          _WandererIntern_hook_action;
 120 struct Hook          _WandererIntern_hook_backdrop;
 121 #else
 122 struct Hook          *_WandererIntern_hook_standard;
 123 struct Hook          *_WandererIntern_hook_action;
 124 struct Hook          *_WandererIntern_hook_backdrop;
 125 #endif
 126
 127 /*** Instance Data **********************************************************/
 128 struct Wanderer_DATA
 129 {
 130     struct Screen               *wd_Screen;
 131
 132     Object                      *wd_Prefs,
 133                                 *wd_ActiveWindow,
 134                                 *wd_WorkbenchWindow;
 135
 136     struct MUI_InputHandlerNode  wd_TimerIHN;
 137     struct MsgPort              *wd_CommandPort;
 138     struct MUI_InputHandlerNode  wd_CommandIHN;
 139     struct MsgPort              *wd_NotifyPort;
 140     struct MUI_InputHandlerNode  wd_NotifyIHN;
 141     struct NotifyRequest         wd_PrefsNotifyRequest;
 142
 143     IPTR                         wd_PrefsIntern;
 144     BOOL                         wd_Option_BackDropMode;
 145 };
 146
 147 /*** Macros *****************************************************************/
 148 #define SETUP_WANDERER_INST_DATA struct Wanderer_DATA *data = INST_DATA(CLASS, self)
 149
 150 /**************************************************************************
 151 * HOOK FUNCS                                                              *
 152 **************************************************************************/
 153 ///Wanderer__HookFunc_DisplayCopyFunc()
 154 #ifdef __AROS__
 155 AROS_UFH3
 156 (
 157     BOOL, Wanderer__HookFunc_DisplayCopyFunc,
 158     AROS_UFHA(struct Hook *, hook, A0),
 159     AROS_UFHA(struct dCopyStruct *, obj, A2),
 160     AROS_UFHA(APTR, unused_param, A1)
 161 )
 162 {
 163 #else
 164 HOOKPROTO(Wanderer__HookFunc_DisplayCopyFunc, BOOL, struct dCopyStruct *obj, APTR unused_param)
 165 {
 166 #endif
 167     AROS_USERFUNC_INIT
 168
 169     struct MUIDisplayObjects *d = (struct MUIDisplayObjects *) obj->userdata;
 170
 171     if ((obj->flags & ACTION_UPDATE) == 0)
 172     {
 173         d->updateme = TRUE;
 174
 175         if ((obj->filelen < 8192) && (d->numfiles > 0))
 176         {
 177             d->smallobjects++;
 178             if (d->smallobjects >= 20) d->smallobjects = 0;
 179         }
 180         else
 181         {
 182             d->smallobjects = 0;
 183         }
 184
 185         if (d->smallobjects > 0)
 186                         d->updateme = FALSE;
 187
 188         if (d->updateme)
 189         {
 190             SET(d->fileObject, MUIA_Text_Contents, obj->file);
 191             SET(d->sourceObject, MUIA_Text_Contents, obj->spath);
 192         }
 193     }
 194     if (d->action != ACTION_DELETE)
 195     {
 196         d->bytes += obj->actlen;
 197
 198         if ((obj->flags & ACTION_UPDATE) == 0)
 199         {
 200             if (d->updateme)
 201             {
 202                 SET(d->gauge, MUIA_Gauge_Current, 0);
 203                 SET(d->destObject, MUIA_Text_Contents, obj->dpath);
 204             }
 205             d->numfiles++;
 206         }
 207         else
 208         {
 209             if (d->updateme &&(obj->totallen <= obj->filelen))
 210             {
 211                 double rate = (double) (((double) obj->totallen) / (((double) obj->difftime) / ((double) CLOCKS_PER_SEC))) / 1024.0;
 212                 if (rate < 1024.0) sprintf(d->SpeedBuffer, "%.2f kBytes/s",  rate); else sprintf(d->SpeedBuffer, "%.2f MBytes/s",  rate / 1024.0);
 213                 SetAttrs(d->gauge, MUIA_Gauge_Current, (ULONG) (32768.0 * (double) obj->totallen / (double) obj->filelen),  MUIA_Gauge_InfoText, d->SpeedBuffer, TAG_DONE);
 214             }
 215         }
 216
 217         if (d->updateme)
 218         {
 219             if (d->bytes < 1048576)
 220             {
 221                 if (obj->filelen < 1048576)
 222                 {
 223                     sprintf(
 224                         d->Buffer, "%s %ld   %s %.2f kBytes   %s %.2f kBytes",
 225                         _(MSG_WANDERER_FILEACCESS_NOOFFILES), d->numfiles, _(MSG_WANDERER_FILEACCESS_ACTUAL), (double) obj->filelen / 1024.0, _(MSG_WANDERER_FILEACCESS_TOTAL), (double) d->bytes / 1024.0
 226                     );
 227                 }
 228                 else
 229                 {
 230                     sprintf(
 231                         d->Buffer, "%s %ld   %s %.2f MBytes   %s %.2f kBytes",
 232                         _(MSG_WANDERER_FILEACCESS_NOOFFILES), d->numfiles, _(MSG_WANDERER_FILEACCESS_ACTUAL), (double) obj->filelen / 1048576.0, _(MSG_WANDERER_FILEACCESS_TOTAL), (double) d->bytes / 1024.0
 233                     );
 234                 }
 235             }
 236             else
 237             {
 238                 if (obj->filelen < 1048576)
 239                 {
 240                     sprintf(
 241                         d->Buffer, "%s %ld   %s %.2f kBytes   %s %.2f MBytes",
 242                         _(MSG_WANDERER_FILEACCESS_NOOFFILES), d->numfiles, _(MSG_WANDERER_FILEACCESS_ACTUAL), (double) obj->filelen / 1024.0, _(MSG_WANDERER_FILEACCESS_TOTAL), (double) d->bytes / 1048576.0
 243                     );
 244                 }
 245                 else
 246                 {
 247                     sprintf(
 248                         d->Buffer, "%s %ld   %s %.2f MBytes   %s %.2f MBytes",
 249                         _(MSG_WANDERER_FILEACCESS_NOOFFILES), d->numfiles, _(MSG_WANDERER_FILEACCESS_ACTUAL), (double) obj->filelen / 1048576.0, _(MSG_WANDERER_FILEACCESS_TOTAL), (double) d->bytes / 1048576.0
 250                     );
 251                 }
 252             }
 253             SET(d->performanceObject, MUIA_Text_Contents, d->Buffer);
 254         }
 255     }
 256
 257     DoMethod(d->copyApp, MUIM_Application_InputBuffered);
 258
 259     /* read the stopflag and return TRUE if the user wanted to stop actionDir() */
 260     if (d->stopflag == 1)
 261                 return TRUE;
 262         else
 263                 return FALSE;
 264
 265     AROS_USERFUNC_EXIT
 266 }
 267 #ifndef __AROS__
 268 MakeStaticHook(Hook_DisplayCopyFunc,Wanderer__HookFunc_DisplayCopyFunc);
 269 #endif
 270 ///
 271
 272 ///Wanderer__HookFunc_AskDeleteFunc()
 273 #ifdef __AROS__
 274 AROS_UFH3
 275 (
 276     ULONG, Wanderer__HookFunc_AskDeleteFunc,
 277     AROS_UFHA(struct Hook *, hook, A0),
 278     AROS_UFHA(struct dCopyStruct *, obj, A2),
 279     AROS_UFHA(APTR, unused_param, A1)
 280 )
 281 {
 282 #else
 283 HOOKPROTO(Wanderer__HookFunc_AskDeleteFunc, ULONG, struct dCopyStruct *obj, APTR unused_param)
 284 {
 285 #endif
 286     AROS_USERFUNC_INIT
 287
 288     ULONG back = DELMODE_NONE;
 289
 290     UWORD    ret = 0;
 291     char     *string = NULL;
 292
 293     if (obj->file)
 294     {
 295         if (obj->type == 0)
 296         {
 297             string = CombineString("%s\n\033b%s\033n\n%s\n\033b%s\033n %s",
 298                 _(MSG_REQU_DELETE_FILE_S), obj->file, _(MSG_REQU_DELETE_FILE_M), obj->spath, _(MSG_REQU_DELETE_FILE_E) );
 299         }
 300         else if (obj->type == 1)
 301         {
 302             string = CombineString("%s\n\033b%s\033n\n%s\n\033b%s\033n %s",
 303                 _(MSG_REQU_FILEUNPROTECT_S), obj->file, _(MSG_REQU_FILEUNPROTECT_M), obj->spath, _(MSG_REQU_FILEUNPROTECT_E) );
 304         }
 305         else if (obj->type == 2)
 306         {
 307             string = CombineString("%s\n\033b%s\033n\n%s\n\033b%s\033n %s",
 308                 _(MSG_REQU_OVERWRITE_S), obj->file, _(MSG_REQU_OVERWRITE_M), obj->spath, _(MSG_REQU_OVERWRITE_E) );
 309         }
 310         else
 311         {
 312             string = CombineString("%s\n\033b%s\033n\n%s\n\033b%s\033n%s",
 313                 _(MSG_NOFILEACCESS_S), obj->file, _(MSG_NOFILEACCESS_M), obj->spath, _(MSG_NOFILEACCESS_E) );
 314         }
 315     }
 316     else
 317     {
 318         if (obj->type == 0) string = CombineString("%s \033b%s\033n %s", _(MSG_REQU_DELETE_DRAWER_S), obj->spath, _(MSG_REQU_DELETE_DRAWER_E) );
 319         else if (obj->type == 1) string = CombineString("%s\n\033b%s\033n %s", _(MSG_REQU_PROTECTION_UNPROTECTDRAWER_S), obj->spath, _(MSG_REQU_PROTECTION_UNPROTECTDRAWER_E) );
 320         else if (obj->type == 3) string = CombineString("%s\n\033b%s %s", _(MSG_NODRAWERACCESS_S), obj->spath, _(MSG_NODRAWERACCESS_E) );
 321     }
 322
 323     if (string)
 324     {
 325         if (obj->type == 0) ret = AskChoiceCentered( _(MSG_REQU_DELETE), string, _(MSG_REQU_DELETE_YESNO), 0);
 326         else if (obj->type == 1) ret = AskChoiceCentered( _(MSG_REQU_PROTECTION), string, _(MSG_REQU_PROTECTION_UNPROTECT), 0);
 327         else if (obj->type == 2) ret = AskChoiceCentered( _(MSG_REQU_OVERWRITE), string, _(MSG_REQU_OVERWRITE_YESNO), 0);
 328         else ret = AskChoiceCentered( _(MSG_REQU_OVERWRITE), string, _(MSG_REQU_OVERWRITE_SKIPABORT), 0);
 329         freeString(NULL, string);
 330     }
 331
 332     if (ret == 0) back = DELMODE_NONE;
 333     else if (ret == 1) back = DELMODE_DELETE;
 334     else if (ret == 2) back = DELMODE_ALL;
 335     else if (ret == 3) back = DELMODE_NO;
 336
 337     return back;
 338
 339     AROS_USERFUNC_EXIT
 340 }
 341 #ifndef __AROS__
 342 MakeStaticHook(Hook_AskDeleteFunc,Wanderer__HookFunc_AskDeleteFunc);
 343 #endif
 344 ///
 345
 346 ///Wanderer__Func_CopyDropEntries()
 347 void Wanderer__Func_CopyDropEntries()
 348 {
 349     /* get filelist from user message */
 350     struct Wanderer_FilelistMsg *message_filelist = FindTask(NULL)->tc_UserData;
 351
 352 D(bug("[Wanderer] Wanderer__Func_CopyDropEntries()\n" ));
 353
 354     if (message_filelist)
 355     {
 356
 357         struct MUIDisplayObjects dobjects;
 358         struct Wanderer_FileEntry *currententry;
 359 #ifdef __AROS__
 360         struct Hook displayCopyHook;
 361         struct Hook displayDelHook;
 362 #else
 363         struct Hook *displayCopyHook;
 364         struct Hook *displayDelHook;
 365 #endif
 366
 367 #ifdef __AROS__
 368         displayCopyHook.h_Entry = (HOOKFUNC) Wanderer__HookFunc_DisplayCopyFunc;
 369         displayDelHook.h_Entry = (HOOKFUNC) Wanderer__HookFunc_AskDeleteFunc;
 370 #else
 371         displayCopyHook = &Hook_DisplayCopyFunc;
 372         displayDelHook = &Hook_AskDeleteFunc;
 373 #endif
 374
 375         if (CreateCopyDisplay(ACTION_COPY, &dobjects))
 376         {
 377             /* process all selected entries */
 378             while ((currententry = (struct Wanderer_FileEntry *)RemTail(&message_filelist->files)) != NULL)
 379             {
 380                 /* copy via filesystems.c */
 381 D(bug("[Wanderer] Wanderer__Func_CopyDropEntries: Copying '%s' to '%s'\n", &currententry->filename, &message_filelist->destination_string));
 382
 383                 CopyContent(NULL,
 384                                         (char *)&currententry->filename, (char *)&message_filelist->destination_string,
 385                                         TRUE, ACTION_COPY, &displayCopyHook, &displayDelHook, (APTR) &dobjects);
 386
 387                 FreeVec( currententry );
 388             }
 389             /* delete copy window */
 390             DisposeCopyDisplay(&dobjects);
 391         }
 392     }
 393
 394     /* free msg memory */
 395     FreeMem(message_filelist, sizeof(struct Wanderer_FilelistMsg));
 396
 397     return;
 398 }
 399 ///
 400
 401 ///Wanderer__HookFunc_ActionFunc()
 402 #ifdef __AROS__
 403 AROS_UFH3
 404 (
 405     void, Wanderer__HookFunc_ActionFunc,
 406     AROS_UFHA(struct Hook *, hook, A0),
 407     AROS_UFHA(Object *, obj, A2),
 408     AROS_UFHA(struct IconWindow_ActionMsg *, msg, A1)
 409 )
 410 {
 411 #else
 412 HOOKPROTO(Wanderer__HookFunc_ActionFunc, void, Object *obj, struct IconWindow_ActionMsg *msg)
 413 {
 414 #endif
 415     AROS_USERFUNC_INIT
 416
 417     if (msg->type == ICONWINDOW_ACTION_OPEN)
 418     {
 419         static unsigned char  buf[1024];
 420                 IPTR                  offset;
 421         struct IconList_Entry *ent = (void*)MUIV_IconList_NextIcon_Start;
 422
 423         DoMethod(msg->iconlist, MUIM_IconList_NextIcon, MUIV_IconList_NextIcon_Selected, (IPTR)&ent);
 424         if ((IPTR)ent == (IPTR)MUIV_IconList_NextIcon_End)
 425         {
 426 D(bug("[WANDERER] Wanderer__HookFunc_ActionFunc: ICONWINDOW_ACTION_OPEN: NextIcon returned MUIV_IconList_NextIcon_TAG_DONE)\n"));
 427             return;
 428         }
 429
 430         offset = strlen(ent->filename) - 5;
 431
 432         if ((msg->isroot) && (ent->type == ST_ROOT))
 433         {
 434             strcpy((STRPTR)buf, ent->label);
 435         }
 436         else
 437         {
 438             strcpy((STRPTR)buf, ent->filename);
 439         }
 440
 441 D(bug("[WANDERER] Wanderer__HookFunc_ActionFunc: ICONWINDOW_ACTION_OPEN - offset = %d, buf = %s\n", offset, buf);)
 442
 443         if  ((ent->type == ST_ROOT) || (ent->type == ST_USERDIR) || (ent->type == ST_LINKDIR))
 444         {
 445             Object *cstate = (Object*)(((struct List*)XGET(_app(obj), MUIA_Application_WindowList))->lh_Head);
 446             Object *prefs = (Object*) XGET(_app(obj), MUIA_Wanderer_Prefs);
 447             Object *child;
 448
 449             /* open new window if root or classic navigation set */
 450             if ( (msg->isroot) || (XGET(prefs, MUIA_IconWindowExt_Toolbar_NavigationMethod) == WPD_NAVIGATION_CLASSIC) )
 451             {
 452                 while ((child = NextObject(&cstate)))
 453                 {
 454                     if (XGET(child, MUIA_UserData))
 455                     {
 456                         STRPTR child_drawer = (STRPTR)XGET(child, MUIA_IconWindow_Location);
 457                         if (child_drawer && !Stricmp(buf,(CONST_STRPTR)child_drawer))
 458                         {
 459                             BOOL is_open = ( BOOL )XGET(child, MUIA_Window_Open);
 460
 461                             if (!is_open)
 462                             {
 463                                 DoMethod(child, MUIM_IconWindow_Open);
 464                             }
 465                             else
 466                             {
 467                                 DoMethod(child, MUIM_Window_ToFront);
 468                                 SET(child, MUIA_Window_Activate, TRUE);
 469                             }
 470
 471                             return;
 472                         }
 473                     }
 474                 }
 475
 476                 /* Check if the window for this drawer is already opened */
 477                 DoMethod(_WandererIntern_AppObj, MUIM_Wanderer_CreateDrawerWindow, (IPTR) buf);
 478                 // FIXME: error handling
 479             }
 480             else
 481             {
 482                 /* open drawer in same window */
 483                 SET(obj, MUIA_IconWindow_Location, (IPTR) buf);
 484             }
 485
 486         }
 487         else if ((ent->type == ST_FILE) || (ent->type == ST_LINKFILE))
 488         {
 489             BPTR newwd, oldwd, file;
 490
 491             /* Set the CurrentDir to the path of the executable to be started */
 492             file = Lock(ent->filename, SHARED_LOCK);
 493             if(file)
 494             {
 495                 newwd = ParentDir(file);
 496                 oldwd = CurrentDir(newwd);
 497
 498                 if (!OpenWorkbenchObject(ent->filename, TAG_DONE))
 499                 {
 500                     execute_open_with_command(newwd, FilePart(ent->filename));
 501                 }
 502
 503                 CurrentDir(oldwd);
 504                 UnLock(newwd);
 505                 UnLock(file);
 506             }
 507         }
 508     }
 509     else  if (msg->type == ICONWINDOW_ACTION_DIRUP)
 510     {
 511
 512         STRPTR actual_drawer = (STRPTR)XGET(obj, MUIA_IconWindow_Location);
 513         STRPTR parent_drawer = strrchr(actual_drawer,'/');
 514         STRPTR root_drawer = strrchr(actual_drawer,':');
 515
 516         /* check if dir is not drive root dir */
 517         if ( strlen(root_drawer) > 1 )
 518         {
 519             /* check if second or third level directory*/
 520             if (!parent_drawer)
 521             {
 522                 (*(root_drawer+1)) = 0;
 523                 SET(obj, MUIA_IconWindow_Location, actual_drawer);
 524
 525             }
 526             else
 527             {
 528                 (*parent_drawer) = 0;
 529                 SET(obj, MUIA_IconWindow_Location, actual_drawer);
 530             }
 531
 532         }
 533     }
 534     else if (msg->type == ICONWINDOW_ACTION_CLICK)
 535     {
 536         if (!msg->click->shift)
 537         {
 538             Object *cstate = (Object*)(((struct List*)XGET(_WandererIntern_AppObj, MUIA_Application_WindowList))->lh_Head);
 539             Object *child;
 540
 541             while ((child = NextObject(&cstate)))
 542             {
 543                 if (XGET(child, MUIA_UserData))
 544                 {
 545                     if (child != obj)  DoMethod(child, MUIM_IconWindow_UnselectAll);
 546                 }
 547             }
 548         }
 549     }
 550     else if (msg->type == ICONWINDOW_ACTION_ICONDROP)
 551     {
 552                 struct Process *child;
 553
 554                 struct IconList_Drop *drop = (struct IconList_Drop *)msg->drop;
 555         struct IconList_Entry *ent = (void*)MUIV_IconList_NextIcon_Start;
 556                 struct Wanderer_FileEntry *file_recordtmp;
 557
 558                 struct Wanderer_FilelistMsg *message_filelist = NULL;
 559
 560                 if ((message_filelist = AllocMem(sizeof(struct Wanderer_FilelistMsg), MEMF_CLEAR|MEMF_PUBLIC )) != NULL)
 561                 {
 562                         strcpy( (char*)&message_filelist->destination_string,(STRPTR) drop->destination_string);
 563 #ifdef __AROS__
 564                         NEWLIST(&message_filelist->files);
 565 #else
 566                         NEW_LIST(&message_filelist->files);
 567 #endif
 568             /* process all selected entries */
 569             do
 570             {
 571                                 DoMethod(drop->source_iconlistobj, MUIM_IconList_NextIcon, MUIV_IconList_NextIcon_Selected, (IPTR) &ent);
 572
 573                                 /* if not end of selection, process */
 574                                 if ( (int)ent != MUIV_IconList_NextIcon_End)
 575                                 {
 576                                         file_recordtmp = AllocVec( sizeof(struct Wanderer_FileEntry), MEMF_CLEAR|MEMF_PUBLIC );
 577                                         strcpy( (char*)&file_recordtmp->filename, ent->filename);
 578                                         AddTail(&message_filelist->files, (struct Node *)file_recordtmp);
 579                                 }
 580             }
 581             while ((int)ent != MUIV_IconList_NextIcon_End);
 582
 583                         {
 584                                 /* create process and copy files within */
 585                                 const struct TagItem       tags[]=
 586                                 {
 587                                         {NP_Entry    , (IPTR)Wanderer__Func_CopyDropEntries     },
 588                                         {NP_Name     , (IPTR)"wanderer copy"                    },
 589                                         {NP_UserData , (IPTR)message_filelist                           },
 590                                         {NP_StackSize, 40000                                                            },
 591                                         {TAG_DONE    , NULL                                                                     }
 592                                 };
 593
 594                                 child = CreateNewProc(tags);
 595                         }
 596 #warning "TODO: update list contents"
 597                         /* this one should be solved through file notofications, as files are copied in a seperate process now  */
 598                 }
 599     }
 600     else if (msg->type == ICONWINDOW_ACTION_APPWINDOWDROP)
 601     {
 602         struct Screen *wscreen = NULL;
 603         struct Layer *layer;
 604
 605         /* get wanderers screen struct and the layer located at cursor position afterwards */
 606         get( obj, MUIA_Window_Screen, &wscreen);
 607         layer = WhichLayer(&wscreen->LayerInfo,wscreen->MouseX,wscreen->MouseY);
 608
 609         if (layer)
 610         {
 611             struct Window *win = (struct Window *) layer->Window;
 612             if (win)
 613             {
 614                 struct List AppList;
 615                 ULONG files = 0;
 616                 BOOL  fail  = FALSE;
 617                                 struct IconList_Entry *ent;
 618
 619                 NewList(&AppList);
 620
 621                 ent = (void*)MUIV_IconList_NextIcon_Start;
 622                 /* process all selected entries */
 623                 do
 624                 {
 625                     DoMethod(msg->iconlist, MUIM_IconList_NextIcon, MUIV_IconList_NextIcon_Selected, (IPTR) &ent);
 626                     /*  if not end of selection, process */
 627                     if ( (int)ent != MUIV_IconList_NextIcon_End )
 628                     {
 629                         struct AppW *a = AllocVec(sizeof(struct AppW), MEMF_CLEAR);
 630                         if (a)
 631                         {
 632                             a->name = AllocVec(strlen(ent->filename)+1, MEMF_CLEAR);
 633                             if (a->name)
 634                             {
 635                                 files++;
 636                                 strcpy(a->name, ent->filename);
 637                                 AddTail(&AppList, (struct Node *) a);
 638                             }
 639                             else
 640                             {
 641                                 FreeVec(a);
 642                                 fail = TRUE;
 643                             }
 644                         }
 645                         else fail = TRUE;
 646                     }
 647                 }
 648                 while ( ((int)ent != MUIV_IconList_NextIcon_End) && !fail);
 649
 650                 if (!fail && (files > 0))
 651                 {
 652                     STRPTR *filelist = AllocVec(sizeof(STRPTR) * files, MEMF_CLEAR);
 653                     if (filelist != NULL)
 654                     {
 655                         STRPTR *flist = filelist;
 656                         if (!IsListEmpty(&AppList))
 657                         {
 658                             struct Node *succ;
 659                             struct Node *s = AppList.lh_Head;
 660                             while (((succ = ((struct Node*) s)->ln_Succ) != NULL) && !fail)
 661                             {
 662                                 *flist ++ = ((struct AppW *) s)->name;
 663                                 s =  succ;
 664                             }
 665
 666 D(bug("[WANDERER] AppWindowMsg: win:%s files:%s mx:%d my:%d\n",win->Title, filelist, wscreen->MouseX - win->LeftEdge, wscreen->MouseY - win->TopEdge);)
 667                             /* send appwindow msg struct containing selected files to destination */
 668                             SendAppWindowMessage(win, files, filelist, 0, wscreen->MouseX - win->LeftEdge, wscreen->MouseY - win->TopEdge, 0, 0);
 669
 670                         }
 671                         FreeVec(filelist);
 672                     }
 673                 }
 674                 if (!IsListEmpty(&AppList))
 675                 {
 676                     struct Node *succ;
 677                     struct Node *s = AppList.lh_Head;
 678                     while (((succ = ((struct Node*) s)->ln_Succ) != NULL))
 679                     {
 680                         if ( ((struct AppW *) s)->name != NULL )
 681                             FreeVec(((struct AppW *) s)->name);
 682                         if ( s != NULL )
 683                             FreeVec(s);
 684                         s =  succ;
 685                     }
 686                 }
 687             }
 688         }
 689     }
 690
 691     AROS_USERFUNC_EXIT
 692 }
 693 #ifndef __AROS__
 694 MakeStaticHook(Hook_ActionFunc,Wanderer__HookFunc_ActionFunc);
 695 #endif
 696 ///
 697
 698 ///Wanderer__HookFunc_StandardFunc()
 699 #ifdef __AROS__
 700 AROS_UFH3
 701 (
 702     void, Wanderer__HookFunc_StandardFunc,
 703     AROS_UFHA(struct Hook *, hook, A0),
 704     AROS_UFHA(void *, dummy, A2),
 705     AROS_UFHA(void **, funcptr, A1)
 706 )
 707 {
 708 #else
 709 HOOKPROTO(Wanderer__HookFunc_StandardFunc, void, void *dummy, void **funcptr)
 710 {
 711 #endif
 712     AROS_USERFUNC_INIT
 713
 714     void (*func) (ULONG *) = (void (*)(ULONG *)) (*funcptr);
 715     if (func) func((ULONG *)(funcptr + 1));
 716
 717     AROS_USERFUNC_EXIT
 718 }
 719 #ifndef __AROS__
 720 MakeStaticHook(Hook_StandardFunc,Wanderer__HookFunc_StandardFunc);
 721 #endif
 722 ///
 723
 724 ///Wanderer__HookFunc_BackdropFunc()
 725 #ifdef __AROS__
 726 AROS_UFH3
 727 (
 728     void, Wanderer__HookFunc_BackdropFunc,
 729     AROS_UFHA(struct Hook *, hook, A0),
 730     AROS_UFHA(void *, dummy, A2),
 731     AROS_UFHA(void **, funcptr, A1)
 732 )
 733 {
 734 #else
 735 HOOKPROTO(Wanderer__HookFunc_BackdropFunc, void, void *dummy, void **funcptr)
 736 {
 737 #endif
 738     AROS_USERFUNC_INIT
 739
 740     struct Wanderer_DATA *data = INST_DATA(_WandererIntern_CLASS, _WandererIntern_AppObj);
 741     BOOL    wb_iscurrentlybd;
 742
 743 D(bug("[WANDERER] Wanderer__HookFunc_BackdropFunc()\n"));
 744 D(bug("[WANDERER] Wanderer__HookFunc_BackdropFunc: Private data @ %x\n", data));
 745
 746     if (!data->wd_WorkbenchWindow)
 747     {
 748 D(bug("[WANDERER] Wanderer__HookFunc_BackdropFunc: No Workbench Window\n"));
 749         return;
 750     }
 751
 752     wb_iscurrentlybd = (BOOL)XGET(data->wd_WorkbenchWindow, MUIA_IconWindow_IsBackdrop);
 753
 754     if (wb_iscurrentlybd != data->wd_Option_BackDropMode)
 755     {
 756         BOOL          isOpen = (BOOL)XGET(data->wd_WorkbenchWindow, MUIA_Window_Open);
 757         Object        *win_Active = NULL;
 758
 759 D(bug("[WANDERER] Wanderer__HookFunc_BackdropFunc: Backdrop mode change requested!\n"));
 760 D(bug("[WANDERER] Wanderer__HookFunc_BackdropFunc: Disposing of existing Workbench window Obj ..\n"));
 761         if (isOpen)
 762             SET(data->wd_WorkbenchWindow, MUIA_Window_Open, FALSE);
 763
 764         if (data->wd_WorkbenchWindow == data->wd_ActiveWindow)
 765         {
 766             data->wd_ActiveWindow = NULL;
 767         }
 768         else
 769         {
 770             win_Active = data->wd_ActiveWindow;
 771         }
 772
 773         /* Kill our close request notification .. */
 774         DoMethod
 775         (
 776             data->wd_WorkbenchWindow, MUIM_KillNotify, MUIA_Window_CloseRequest
 777         );
 778
 779         /* .. And dispose of the window */
 780         DoMethod(_WandererIntern_AppObj, OM_REMMEMBER, data->wd_WorkbenchWindow);
 781         MUI_DisposeObject(data->wd_WorkbenchWindow);
 782         data->wd_WorkbenchWindow = NULL;
 783
 784 #if defined(DEBUG)
 785         if (data->wd_Option_BackDropMode)
 786         {
 787 D(bug("[WANDERER] Wanderer__HookFunc_BackdropFunc: Creating new Workbench window Obj (BACKDROP MODE)..\n"));
 788         }
 789         else
 790         {
 791 D(bug("[WANDERER] Wanderer__HookFunc_BackdropFunc: Creating new Workbench window Obj (NORMAL MODE)..\n"));
 792         }
 793 #endif
 794         data->wd_WorkbenchWindow = (Object *) DoMethod
 795         (
 796             _WandererIntern_AppObj, MUIM_Wanderer_CreateDrawerWindow, (IPTR) NULL
 797         );
 798
 799         if ((data->wd_WorkbenchWindow) && (isOpen))
 800         {
 801 D(bug("[WANDERER] Wanderer__HookFunc_BackdropFunc: Making Workbench window visable..\n"));
 802             DoMethod(data->wd_WorkbenchWindow, MUIM_IconWindow_Open);
 803             DoMethod(data->wd_WorkbenchWindow, MUIM_Window_ToBack);
 804         }
 805
 806         if (win_Active)
 807         {
 808             SET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow, win_Active);
 809         }
 810         else if (data->wd_WorkbenchWindow)
 811         {
 812             SET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow, data->wd_WorkbenchWindow);
 813         }
 814     }
 815     AROS_USERFUNC_EXIT
 816 }
 817 #ifndef __AROS__
 818 MakeStaticHook(Hook_BackdropFunc,Wanderer__HookFunc_BackdropFunc);
 819 #endif
 820 ///
 821 /******** code from workbench/c/Info.c *******************/
 822 ///fmtlarge()
 823 static void fmtlarge(UBYTE *buf, ULONG num)
 824 {
 825     UQUAD d;
 826     UBYTE *ch;
 827     struct
 828     {
 829         IPTR val;
 830         IPTR  dec;
 831     } array =
 832     {
 833         num,
 834         0
 835     };
 836
 837     if (num >= 0x40000000)
 838     {
 839         array.val = num >> 30;
 840         d = ((UQUAD)num * 10 + 0x20000000) / 0x40000000;
 841         array.dec = d % 10;
 842         //ch = 'G';
 843         ch = _(MSG_MEM_G);
 844     }
 845     else if (num >= 0x100000)
 846     {
 847         array.val = num >> 20;
 848         d = ((UQUAD)num * 10 + 0x80000) / 0x100000;
 849         array.dec = d % 10;
 850         //ch = 'M';
 851         ch = _(MSG_MEM_M);
 852     }
 853     else if (num >= 0x400)
 854     {
 855         array.val = num >> 10;
 856         d = (num * 10 + 0x200) / 0x400;
 857         array.dec = d % 10;
 858         //ch = 'K';
 859         ch = _(MSG_MEM_K);
 860     }
 861     else
 862     {
 863         array.val = num;
 864         array.dec = 0;
 865         d = 0;
 866         //ch = 'B';
 867                 ch = _(MSG_MEM_B);
 868     }
 869
 870     if (!array.dec && (d > array.val * 10))
 871     {
 872         array.val++;
 873     }
 874
 875     RawDoFmt(array.dec ? "%lu.%lu" : "%lu", &array, NULL, buf);
 876     while (*buf) { buf++; }
 877     *buf++ = *ch;
 878     *buf   = '\0';
 879 }
 880 ///
 881
 882 ///GetScreenTitle()
 883 STRPTR GetScreenTitle(VOID)
 884 {
 885     static TEXT         title[256];
 886     UBYTE               chip[10], fast[10];
 887     ULONG               __availMem;
 888
 889     __availMem = AvailMem(MEMF_CHIP);
 890     fmtlarge(chip, __availMem);
 891     __availMem = AvailMem(MEMF_FAST);
 892     fmtlarge(fast, __availMem);
 893
 894     sprintf(title, _(MSG_SCREENTITLE), chip, fast);
 895
 896     return title;
 897 }
 898 ///
 899
 900 ///GetUserScreenTitle()
 901 STRPTR GetUserScreenTitle(Object *self)
 902 {
 903   /*Work in progress :-)
 904    */
 905     char *screentitlestr;
 906     int screentitleleng;
 907
 908     GET(self, MUIA_IconWindowExt_ScreenTitle_String, &screentitlestr);
 909
 910     screentitleleng = strlen(screentitlestr);
 911
 912     if (screentitleleng<1)
 913     {
 914         return GetScreenTitle();
 915     }
 916     return screentitlestr;
 917
 918 }
 919 ///
 920
 921 ///ExpandEnvName()
 922 /* Expand a passed in env: string to its full location */
 923 /* Wanderer doesnt free this mem at the moment but should
 924    incase it is every closed */
 925 STRPTR ExpandEnvName(STRPTR env_path)
 926 {
 927     BOOL     ok = FALSE;
 928     char     tmp_envbuff[1024];
 929     STRPTR   fullpath = NULL;
 930     BPTR     env_lock = (BPTR) NULL;
 931
 932     env_lock = Lock("ENV:", SHARED_LOCK);
 933     if (env_lock)
 934     {
 935         if (NameFromLock(env_lock, tmp_envbuff, 256)) ok = TRUE;
 936         UnLock(env_lock);
 937     }
 938
 939     if (ok)
 940     {
 941         if ((fullpath = AllocVec(strlen(tmp_envbuff) + strlen(env_path) + 1 + 1 - 4, MEMF_CLEAR | MEMF_PUBLIC)) != NULL)
 942         {
 943             strcpy(fullpath, tmp_envbuff);
 944             AddPart(fullpath, env_path + 4, 1019);
 945             return fullpath;
 946         }
 947     }
 948
 949     //We couldnt expand it so just use as is ..
 950     return env_path;
 951 }
 952 ///
 953
 954 enum
 955 {
 956     MEN_WANDERER = 1,
 957     MEN_WANDERER_BACKDROP,
 958     MEN_WANDERER_EXECUTE,
 959     MEN_WANDERER_SHELL,
 960     MEN_WANDERER_AROS_GUISETTINGS,
 961     MEN_WANDERER_AROS_ABOUT,
 962         MEN_WANDERER_ABOUT,
 963     MEN_WANDERER_QUIT,
 964     MEN_WANDERER_SHUTDOWN,
 965
 966     MEN_WINDOW_NEW_DRAWER,
 967     MEN_WINDOW_OPEN_PARENT,
 968     MEN_WINDOW_CLOSE,
 969     MEN_WINDOW_UPDATE,
 970
 971     MEN_WINDOW_SELECT,
 972     MEN_WINDOW_CLEAR,
 973
 974     MEN_WINDOW_SNAP_WIN,
 975     MEN_WINDOW_SNAP_ALL,
 976
 977     MEN_WINDOW_VIEW_ICON,
 978     MEN_WINDOW_VIEW_DETAIL,
 979     MEN_WINDOW_VIEW_ALL,
 980         MEN_WINDOW_VIEW_HIDDEN,
 981
 982     MEN_WINDOW_SORT_NOW,
 983     MEN_WINDOW_SORT_NAME,
 984     MEN_WINDOW_SORT_TYPE,
 985     MEN_WINDOW_SORT_DATE,
 986     MEN_WINDOW_SORT_SIZE,
 987     MEN_WINDOW_SORT_REVERSE,
 988     MEN_WINDOW_SORT_TOPDRAWERS,
 989     MEN_WINDOW_SORT_GROUP,
 990
 991     MEN_ICON_OPEN,
 992     MEN_ICON_RENAME,
 993     MEN_ICON_INFORMATION,
 994         MEN_ICON_SNAPSHOT,
 995         MEN_ICON_UNSNAPSHOT,
 996         MEN_ICON_LEAVEOUT,
 997         MEN_ICON_PUTAWAY,
 998     MEN_ICON_DELETE,
 999     MEN_ICON_FORMAT,
1000         MEN_ICON_EMPTYTRASH
1001 };
1002
1003
1004 ///execute_open_with_command()
1005 /**************************************************************************
1006 Open the execute window. Similar to below but you can also set the
1007 command. Called when item is openend
1008 **************************************************************************/
1009 void execute_open_with_command(BPTR cd, STRPTR contents)
1010 {
1011     BPTR lock;
1012
1013     if (cd !=(BPTR) NULL) lock =  cd;
1014     else            lock = Lock("RAM:", ACCESS_READ);
1015
1016     OpenWorkbenchObject
1017     (
1018         "WANDERER:Tools/ExecuteCommand",
1019         WBOPENA_ArgLock, (IPTR) lock,
1020         WBOPENA_ArgName, (IPTR) contents,
1021         TAG_DONE
1022     );
1023
1024     if (cd ==(BPTR) NULL) UnLock(lock);
1025 }
1026 ///
1027
1028 ///wanderer_menufunc_wanderer_execute()
1029 /**************************************************************************
1030 Open the execute window
1031
1032 This function will always get the current drawer as argument
1033 **************************************************************************/
1034 VOID wanderer_menufunc_wanderer_execute(STRPTR *cdptr)
1035 {
1036     //TODO: remove the STRPTR *cdptr from top
1037     //TODO:remove this commented out stuff
1038     //BPTR lock = NULL;
1039     //if (cdptr != NULL) lock = Lock(*cdptr, SHARED_LOCK);
1040     Object *win = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1041     STRPTR dr = ( STRPTR )XGET( win, MUIA_IconWindow_Location );
1042     BPTR cd = Lock(dr,SHARED_LOCK);
1043     execute_open_with_command(cd, NULL);
1044     if (cd) UnLock(cd);
1045 }
1046 /*******************************/
1047 ///
1048
1049 ///wanderer_menufunc_wanderer_shell()
1050 void wanderer_menufunc_wanderer_shell(STRPTR *cd_ptr)
1051 {
1052     //TODO: remove the STRPTR *cdptr from top
1053     //TODO:remove this commented out stuff
1054     //BPTR cd = Lock(*cd_ptr,ACCESS_READ);
1055     Object *win = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1056     STRPTR dr = ( STRPTR )XGET( win, MUIA_IconWindow_Location );
1057     BPTR cd;
1058
1059     if (!dr)
1060     {
1061         dr = "";
1062     }
1063
1064     cd = Lock(dr, ACCESS_READ);
1065     if (SystemTags("NewShell", NP_CurrentDir, (IPTR)cd, TAG_DONE) == -1)
1066     {
1067         UnLock(cd);
1068     }
1069 }
1070 ///
1071
1072 ///wanderer_menufunc_wanderer_backdrop()
1073 void wanderer_menufunc_wanderer_backdrop(Object **pstrip)
1074 {
1075     struct Wanderer_DATA *data = INST_DATA(_WandererIntern_CLASS, _WandererIntern_AppObj);
1076     Object *strip = *pstrip;
1077     Object *item = FindMenuitem(strip, MEN_WANDERER_BACKDROP);
1078
1079 D(bug("[WANDERER] wanderer_menufunc_wanderer_backdrop()\n"));
1080
1081     if (item != NULL)
1082     {
1083         data->wd_Option_BackDropMode = (BOOL)XGET(item, MUIA_Menuitem_Checked);
1084         SET(data->wd_WorkbenchWindow, MUIA_IconWindow_IsBackdrop, data->wd_Option_BackDropMode);
1085     }
1086 }
1087 ///
1088
1089 ///wanderer_menufunc_window_newdrawer()
1090 void wanderer_menufunc_window_newdrawer(STRPTR *cdptr)
1091 {
1092     //TODO: remove the STRPTR *cdptr from top
1093
1094     Object *win = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1095     STRPTR dr = ( STRPTR )XGET( win, MUIA_IconWindow_Location );
1096     Object *actwindow = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1097     Object *wbwindow = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_WorkbenchWindow);
1098     BPTR lock;
1099
1100 D(bug("[wanderer] wanderer_menufunc_window_newdrawer(%s)\n", dr));
1101     if (actwindow == wbwindow)
1102     {
1103         /* This check is necessary because WorkbenchWindow has path RAM: */
1104 D(bug("[wanderer] wanderer_menufunc_window_newdrawer: Can't call WBNewDrawer for WorkbenchWindow\n"));
1105         return;
1106     }
1107     if ( XGET(actwindow, MUIA_Window_Open) == FALSE )
1108     {
1109 D(bug("[wanderer] wanderer_menufunc_window_newdrawer: Can't call WBNewDrawer: the active window isn't open\n"));
1110         return;
1111     }
1112
1113     lock = Lock(dr, ACCESS_READ);
1114     OpenWorkbenchObject
1115     (
1116         "WANDERER:Tools/WBNewDrawer",
1117         WBOPENA_ArgLock, (IPTR) lock,
1118         WBOPENA_ArgName, 0,
1119         TAG_DONE
1120     );
1121     UnLock(lock);
1122 }
1123 ///
1124
1125 ///wanderer_menufunc_window_openparent()
1126 void wanderer_menufunc_window_openparent(STRPTR *cdptr)
1127 {
1128     //TODO: Remove the **cdptr stuff from top
1129     Object *win = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1130     STRPTR dr = ( STRPTR )XGET( win, MUIA_IconWindow_Location );
1131
1132     IPTR  path_len=0;
1133     STRPTR  last_letter=NULL;
1134     STRPTR thispath;
1135     STRPTR buf;
1136     Object *cstate;
1137     Object *child;
1138     BOOL foundSlash, foundColon;
1139     int i = 0;
1140
1141     last_letter = &dr[ strlen(dr) - 1 ];
1142
1143     thispath = FilePart(dr);
1144
1145     if (*last_letter==0x3a) return; /* Top Drawer has no parent to open */
1146
1147     last_letter = &thispath[strlen(thispath)-1];
1148
1149     if (*last_letter==0x3a)
1150        path_len = (IPTR)(thispath-(IPTR)(dr));
1151     else
1152        path_len = (IPTR)((thispath-(IPTR)(dr))-1);
1153
1154     buf = AllocVec((path_len+1),MEMF_PUBLIC|MEMF_CLEAR);
1155     CopyMem(dr, buf, path_len);
1156
1157     cstate = (Object*)(((struct List*)XGET(_WandererIntern_AppObj, MUIA_Application_WindowList))->lh_Head);
1158
1159
1160     // Make sure we have a correct path
1161     foundSlash = FALSE, foundColon = FALSE;
1162     i = 0; for ( ; i < path_len; i++ )
1163     {
1164         if ( buf[ i ] == '/' ) foundSlash = TRUE;
1165         if ( buf[ i ] == ':' ) foundColon = TRUE;
1166     }
1167     if ( !foundColon && !foundSlash )
1168     {
1169         STRPTR newbuf = AllocVec ((path_len + 2), MEMF_PUBLIC|MEMF_CLEAR);
1170         sprintf(newbuf,"%s:",buf);
1171         FreeVec (buf);
1172         buf = newbuf;
1173     }
1174     // Done with path correction check
1175
1176     while ((child = NextObject(&cstate)))
1177     {
1178         if (XGET(child, MUIA_UserData))
1179         {
1180             STRPTR child_drawer = (STRPTR)XGET(child, MUIA_IconWindow_Location);
1181             if (child_drawer && !Stricmp(buf,child_drawer))
1182             {
1183                 int is_open = XGET(child, MUIA_Window_Open);
1184                 if (!is_open)
1185                     DoMethod(child, MUIM_IconWindow_Open);
1186                 else
1187                 {
1188                     DoMethod(child, MUIM_Window_ToFront);
1189                     SET(child, MUIA_Window_Activate, TRUE);
1190                 }
1191                 FreeVec(buf);
1192                 return;
1193             }
1194         }
1195     }
1196
1197     DoMethod(_WandererIntern_AppObj, MUIM_Wanderer_CreateDrawerWindow, (IPTR) buf);
1198     FreeVec(buf);
1199 }
1200 ///
1201
1202 ///wanderer_menufunc_window_close()
1203 void wanderer_menufunc_window_close()
1204 {
1205     Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1206     SET(window, MUIA_Window_CloseRequest, TRUE);
1207 }
1208 ///
1209
1210 ///wanderer_menufunc_window_update()
1211 void wanderer_menufunc_window_update()
1212 {
1213     Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1214     Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1215
1216     if (iconList != NULL)
1217     {
1218         DoMethod(iconList, MUIM_IconList_Update);
1219     }
1220 }
1221 ///
1222
1223 ///wanderer_menufunc_window_clear()
1224 void wanderer_menufunc_window_clear()
1225 {
1226     Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1227     Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1228
1229     if (iconList != NULL)
1230     {
1231         DoMethod(iconList, MUIM_IconList_UnselectAll);
1232     }
1233 }
1234 ///
1235
1236 ///wanderer_menufunc_window_select()
1237 void wanderer_menufunc_window_select()
1238 {
1239     Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1240     Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1241
1242     if (iconList != NULL)
1243     {
1244         DoMethod(iconList, MUIM_IconList_SelectAll);
1245     }
1246 }
1247 ///
1248
1249 ///wanderer_menufunc_window_snapshot()
1250 void wanderer_menufunc_window_snapshot(IPTR *flags)
1251 {
1252     Object              *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1253         Object                          *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1254         char                *dir_name = XGET(window, MUIA_IconWindow_Location);
1255         struct DiskObject       *drawericon = NULL;
1256         IPTR                            geticon_error = NULL;
1257         IPTR                            display_bits = 0, sort_bits = 0;
1258         BOOL                            snapshot_all = *flags;
1259
1260 D(bug("[wanderer] wanderer_menufunc_window_snapshot()\n"));
1261 D(bug("[wanderer] wanderer_menufunc_window_snapshot: Dir '%s'\n", dir_name));
1262
1263         if (snapshot_all == TRUE)
1264         {
1265                 struct IconList_Entry *icon_entry    = (IPTR)MUIV_IconList_NextIcon_Start;
1266                 struct IconEntry      *node = NULL;
1267                 struct TagItem            icon_tags[] =
1268                 {
1269                         { ICONPUTA_OnlyUpdatePosition, TRUE },
1270                         { TAG_DONE, NULL                    }
1271                 };
1272 D(bug("[wanderer] wanderer_menufunc_window_snapshot: snapshot ALL\n"));
1273
1274                 do
1275                 {
1276                         DoMethod(iconList, MUIM_IconList_NextIcon, MUIV_IconList_NextIcon_Visible, (IPTR)&icon_entry);
1277
1278                         if ((IPTR)icon_entry != MUIV_IconList_NextIcon_End)
1279                         {
1280                                 node = (struct IconEntry *)((IPTR)icon_entry - ((IPTR)&node->ile_IconListEntry - (IPTR)node));
1281 D(bug("[wanderer] wanderer_menufunc_window_snapshot: SNAPSHOT entry = '%s' @ %p, (%p)\n", icon_entry->filename, icon_entry, node));
1282                                 if (node->ile_DiskObj)
1283                                 {
1284                                         node->ile_DiskObj->do_CurrentX = node->ile_IconX;
1285                                         node->ile_DiskObj->do_CurrentY = node->ile_IconY;
1286                                         PutIconTagList(icon_entry->filename, node->ile_DiskObj, icon_tags);
1287                                 }
1288                                 else
1289                                 {
1290 D(bug("[wanderer] wanderer_menufunc_window_snapshot: icon has no diskobj!\n"));
1291                                 }
1292                         }
1293                         else
1294                         {
1295                                 break;
1296                         }
1297                 } while (TRUE);
1298         }
1299         else
1300         {
1301 D(bug("[wanderer] wanderer_menufunc_window_snapshot: snapshot WINDOW\n"));
1302         }
1303
1304         drawericon = GetIconTags(dir_name,
1305                                                 ICONGETA_FailIfUnavailable, FALSE,
1306                                                 ICONA_ErrorCode, &geticon_error,
1307                                                 TAG_DONE);
1308
1309         if (drawericon != NULL)
1310         {
1311                 if (drawericon->do_DrawerData == NULL)
1312                 {
1313 D(bug("[wanderer] wanderer_menufunc_window_snapshot: Icon for '%s' has no DRAWER data!\n", dir_name));
1314                         drawericon->do_DrawerData = AllocMem(sizeof(struct DrawerData), MEMF_CLEAR|MEMF_PUBLIC);
1315                 }
1316
1317                 drawericon->do_Gadget.UserData = 1;
1318
1319                 drawericon->do_DrawerData->dd_NewWindow.TopEdge = XGET(window, MUIA_Window_TopEdge);
1320                 drawericon->do_DrawerData->dd_NewWindow.LeftEdge = XGET(window, MUIA_Window_LeftEdge);
1321                 drawericon->do_DrawerData->dd_NewWindow.Width = XGET(window, MUIA_Window_Width);
1322                 drawericon->do_DrawerData->dd_NewWindow.Height = XGET(window, MUIA_Window_Height);
1323
1324                 GET(iconList, MUIA_IconList_DisplayFlags, &display_bits);
1325                 if (display_bits & ICONLIST_DISP_SHOWINFO)
1326                 {
1327 D(bug("[wanderer] wanderer_menufunc_window_snapshot: ICONLIST_DISP_SHOWINFO\n"));
1328                         drawericon->do_DrawerData->dd_Flags = 1;
1329                 }
1330                 else
1331                 {
1332                         drawericon->do_DrawerData->dd_Flags = 2;
1333                 }
1334
1335 #warning "TODO: Icon sort flags are only really for text list mode ... fix"
1336                 GET(iconList, MUIA_IconList_SortFlags, &sort_bits);
1337                 if (sort_bits & ICONLIST_SORT_BY_DATE)
1338                 {
1339                         drawericon->do_DrawerData->dd_ViewModes = 3;
1340                 }
1341                 else if (sort_bits & ICONLIST_SORT_BY_SIZE)
1342                 {
1343                         drawericon->do_DrawerData->dd_ViewModes = 4;
1344                 }
1345                 else
1346                 {
1347                         drawericon->do_DrawerData->dd_ViewModes = 2;
1348                 }
1349                 PutDiskObject(dir_name, drawericon);
1350         }
1351 }
1352 ///
1353
1354 ///wanderer_menufunc_window_view_icons(Object **pstrip)
1355 void wanderer_menufunc_window_view_icons(Object **pstrip)
1356 {
1357     Object *strip = *pstrip;
1358     Object *item = FindMenuitem(strip, MEN_WINDOW_VIEW_ALL);
1359     Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1360     Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1361
1362     if ((item != NULL) && (iconList != NULL))
1363     {
1364         IPTR display_bits = 0, menu_view_state = 0;
1365         GET(iconList, MUIA_IconList_DisplayFlags, &display_bits);
1366
1367         GET(item, MUIA_Menuitem_Checked, &menu_view_state);
1368
1369         if (menu_view_state)
1370         {
1371             display_bits &= ~ICONLIST_DISP_SHOWINFO;
1372         }
1373         else
1374         {
1375             display_bits |= ICONLIST_DISP_SHOWINFO;
1376         }
1377
1378         SET(iconList, MUIA_IconList_DisplayFlags, display_bits);
1379         DoMethod(iconList, MUIM_IconList_Sort);
1380     }
1381 }
1382 ///
1383
1384 ///wanderer_menufunc_window_view_hidden(Object **pstrip)
1385 void wanderer_menufunc_window_view_hidden(Object **pstrip)
1386 {
1387     Object *strip = *pstrip;
1388     Object *item = FindMenuitem(strip, MEN_WINDOW_VIEW_HIDDEN);
1389     Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1390     Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1391
1392     if ((item != NULL) && (iconList != NULL))
1393     {
1394         IPTR display_bits = 0, menu_view_state = 0;
1395         GET(iconList, MUIA_IconList_DisplayFlags, &display_bits);
1396
1397         GET(item, MUIA_Menuitem_Checked, &menu_view_state);
1398
1399         if (menu_view_state)
1400         {
1401             display_bits |= ICONLIST_DISP_SHOWHIDDEN;
1402         }
1403         else
1404         {
1405             display_bits &= ~ICONLIST_DISP_SHOWHIDDEN;
1406         }
1407
1408         SET(iconList, MUIA_IconList_DisplayFlags, display_bits);
1409         DoMethod(iconList, MUIM_IconList_Sort);
1410     }
1411 }
1412 ///
1413
1414 ///wanderer_menufunc_window_sort_name()
1415 void wanderer_menufunc_window_sort_name(Object **pstrip)
1416 {
1417     Object *strip = *pstrip;
1418     Object *item = FindMenuitem(strip, MEN_WINDOW_SORT_NAME);
1419     Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1420     Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1421
1422     if (item != NULL && iconList != NULL)
1423     {
1424         IPTR sort_bits = 0;
1425         GET(iconList, MUIA_IconList_SortFlags, &sort_bits);
1426
1427         /*name = date and size bit both NOT set*/
1428                 sort_bits &= ~ICONLIST_SORT_MASK;
1429         if( XGET(item, MUIA_Menuitem_Checked) )
1430         {
1431             sort_bits |= ICONLIST_SORT_BY_NAME;
1432         }
1433         SET(iconList, MUIA_IconList_SortFlags, sort_bits);
1434         DoMethod(iconList, MUIM_IconList_Sort);
1435     }
1436 }
1437 ///
1438
1439 ///wanderer_menufunc_window_sort_date()
1440 void wanderer_menufunc_window_sort_date(Object **pstrip)
1441 {
1442     Object *strip = *pstrip;
1443     Object *item = FindMenuitem(strip, MEN_WINDOW_SORT_DATE);
1444     Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1445     Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1446
1447     if (item != NULL && iconList != NULL)
1448     {
1449         IPTR sort_bits = 0;
1450         GET(iconList, MUIA_IconList_SortFlags, &sort_bits);
1451
1452         /*exclude size bit*/
1453                 sort_bits &= ~ICONLIST_SORT_MASK;
1454         if( XGET(item, MUIA_Menuitem_Checked) )
1455         {
1456             sort_bits |= ICONLIST_SORT_BY_DATE;
1457         }
1458         SET(iconList, MUIA_IconList_SortFlags, sort_bits);
1459         DoMethod(iconList, MUIM_IconList_Sort);
1460     }
1461 }
1462 ///
1463
1464 ///wanderer_menufunc_window_sort_size()
1465 void wanderer_menufunc_window_sort_size(Object **pstrip)
1466 {
1467     Object *strip = *pstrip;
1468     Object *item = FindMenuitem(strip, MEN_WINDOW_SORT_SIZE);
1469     Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1470     Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1471
1472     if (item != NULL && iconList != NULL)
1473     {
1474         IPTR sort_bits = 0;
1475         GET(iconList, MUIA_IconList_SortFlags, &sort_bits);
1476
1477         /*exclude date bit*/
1478                 sort_bits &= ~ICONLIST_SORT_MASK;
1479         if( XGET(item, MUIA_Menuitem_Checked) )
1480         {
1481             sort_bits |= ICONLIST_SORT_BY_SIZE;
1482         }
1483         SET(iconList, MUIA_IconList_SortFlags, sort_bits);
1484         DoMethod(iconList, MUIM_IconList_Sort);
1485     }
1486 }
1487 ///
1488
1489 ///wanderer_menufunc_window_sort_type()
1490 void wanderer_menufunc_window_sort_type(Object **pstrip)
1491 {
1492     Object *strip = *pstrip;
1493     Object *item = FindMenuitem(strip, MEN_WINDOW_SORT_TYPE);
1494     Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1495     Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1496
1497     if (item != NULL && iconList != NULL)
1498     {
1499         IPTR sort_bits = 0;
1500         GET(iconList, MUIA_IconList_SortFlags, &sort_bits);
1501
1502         /*type = all sort bits set (name+date+size) */
1503                 sort_bits &= ~ICONLIST_SORT_MASK;
1504         if( XGET(item, MUIA_Menuitem_Checked) )
1505         {
1506             sort_bits |= ICONLIST_SORT_MASK;
1507         }
1508         SET(iconList, MUIA_IconList_SortFlags, sort_bits);
1509         DoMethod(iconList, MUIM_IconList_Sort);
1510     }
1511 }
1512 ///
1513
1514 ///wanderer_menufunc_window_sort_reverse()
1515 void wanderer_menufunc_window_sort_reverse(Object **pstrip)
1516 {
1517     Object *strip = *pstrip;
1518     Object *item = FindMenuitem(strip, MEN_WINDOW_SORT_REVERSE);
1519     Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1520     Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1521
1522     if (item != NULL && iconList != NULL)
1523     {
1524         IPTR sort_bits = 0;
1525         GET(iconList, MUIA_IconList_SortFlags, &sort_bits);
1526
1527         if( XGET(item, MUIA_Menuitem_Checked) )
1528         {
1529             sort_bits |= ICONLIST_SORT_REVERSE;
1530         }
1531         else
1532         {
1533             sort_bits &= ~ICONLIST_SORT_REVERSE;
1534         }
1535
1536         SET(iconList, MUIA_IconList_SortFlags, sort_bits);
1537         DoMethod(iconList, MUIM_IconList_Sort);
1538     }
1539 }
1540 ///
1541
1542 ///wanderer_menufunc_window_sort_topdrawers()
1543 void wanderer_menufunc_window_sort_topdrawers(Object **pstrip)
1544 {
1545     Object *strip = *pstrip;
1546     Object *item = FindMenuitem(strip, MEN_WINDOW_SORT_TOPDRAWERS);
1547     Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1548     Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1549
1550     if (item != NULL && iconList != NULL)
1551     {
1552         IPTR sort_bits = 0;
1553         GET(iconList, MUIA_IconList_SortFlags, &sort_bits);
1554
1555         if( XGET(item, MUIA_Menuitem_Checked) )
1556         {
1557             sort_bits &= !ICONLIST_SORT_DRAWERS_MIXED;
1558         }
1559         else
1560         {
1561             sort_bits |= ICONLIST_SORT_DRAWERS_MIXED;
1562         }
1563
1564         SET(iconList, MUIA_IconList_SortFlags, sort_bits);
1565         DoMethod(iconList, MUIM_IconList_Sort);
1566     }
1567 }
1568 ///
1569
1570 ///wanderer_menufunc_icon_open()
1571 void wanderer_menufunc_icon_open()
1572 {
1573     Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1574     DoMethod(window, MUIM_IconWindow_DoubleClicked);
1575 }
1576 ///
1577
1578 ///wanderer_menufunc_icon_rename()
1579 void wanderer_menufunc_icon_rename(void)
1580 {
1581     Object                *window   = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1582     Object                *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1583     struct IconList_Entry *entry    = (APTR) MUIV_IconList_NextIcon_Start;
1584
1585     do
1586     {
1587         DoMethod(iconList, MUIM_IconList_NextIcon, MUIV_IconList_NextIcon_Selected, (IPTR) &entry);
1588
1589         if ((int)entry != MUIV_IconList_NextIcon_End)
1590         {
1591             BPTR lock   = Lock(entry->filename, ACCESS_READ);
1592             BPTR parent = ParentDir(lock);
1593             UnLock(lock);
1594
1595 D(bug("[wanderer] wanderer_menufunc_icon_rename: selected = '%s'\n", entry->filename));
1596
1597             OpenWorkbenchObject
1598             (
1599                 "WANDERER:Tools/WBRename",
1600                 WBOPENA_ArgLock, (IPTR) parent,
1601                 WBOPENA_ArgName, (IPTR) FilePart(entry->filename),
1602                 TAG_DONE
1603             );
1604
1605 D(bug("[wanderer] wanderer_menufunc_icon_rename: selected = '%s'\n", entry->filename));
1606
1607             UnLock(parent);
1608         }
1609         else
1610         {
1611             break;
1612         }
1613     } while (TRUE);
1614 }
1615 ///
1616
1617 ///wanderer_menufunc_icon_information()
1618 void wanderer_menufunc_icon_information()
1619 {
1620     Object                *window   = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1621     Object                *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1622     struct IconList_Entry *entry    = (IPTR)MUIV_IconList_NextIcon_Start;
1623
1624     do
1625     {
1626         DoMethod(iconList, MUIM_IconList_NextIcon, MUIV_IconList_NextIcon_Selected, (IPTR)&entry);
1627
1628         if ((IPTR)entry != MUIV_IconList_NextIcon_End)
1629         {
1630             BPTR lock, parent;
1631                         STRPTR name;
1632
1633 D(bug("[wanderer] wanderer_menufunc_icon_information: selected = '%s'\n", entry->filename));
1634                         lock = Lock(entry->filename, ACCESS_READ);
1635                         name = FilePart(entry->filename);
1636                         if (name[0]) {
1637                                 parent = ParentDir(lock);
1638                                 UnLock(lock);
1639                         } else
1640                                 parent = lock;
1641
1642                         D(bug("[wanderer] wanderer_menufunc_icon_information: name = '%s' lock = 0x%08lX\n", name, lock));
1643             WBInfo(parent, name, NULL);
1644
1645             UnLock(parent);
1646         }
1647         else
1648         {
1649             break;
1650         }
1651     } while (TRUE);
1652 }
1653 ///
1654
1655 ///wanderer_menufunc_icon_snapshot()
1656 void wanderer_menufunc_icon_snapshot(IPTR *flags)
1657 {
1658     Object                *window   = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1659     Object                *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1660     struct IconList_Entry *entry    = (IPTR)MUIV_IconList_NextIcon_Start;
1661     struct IconEntry      *node = NULL;
1662         BOOL                              snapshot  = *flags;
1663         struct TagItem            icontags[] =
1664         {
1665                 { ICONPUTA_OnlyUpdatePosition, TRUE },
1666                 { TAG_DONE, NULL                    }
1667         };
1668
1669 D(bug("[wanderer] wanderer_menufunc_icon_snapshot()\n"));
1670
1671     do
1672     {
1673         DoMethod(iconList, MUIM_IconList_NextIcon, MUIV_IconList_NextIcon_Selected, (IPTR)&entry);
1674
1675         if ((IPTR)entry != MUIV_IconList_NextIcon_End)
1676         {
1677                         node = (struct IconEntry *)((IPTR)entry - ((IPTR)&node->ile_IconListEntry - (IPTR)node));
1678 D(bug("[wanderer] wanderer_menufunc_icon_snapshot: %s entry = '%s' @ %p, (%p)\n", (snapshot) ? "SNAPSHOT" : "UNSNAPSHOT", entry->filename, entry, node));
1679                         if (node->ile_DiskObj)
1680                         {
1681                                 if (snapshot)
1682                                 {
1683                                         node->ile_DiskObj->do_CurrentX = node->ile_IconX;
1684                                         node->ile_DiskObj->do_CurrentY = node->ile_IconY;
1685                                 }
1686                                 else
1687                                 {
1688                                         node->ile_DiskObj->do_CurrentX = NO_ICON_POSITION;
1689                                         node->ile_DiskObj->do_CurrentY = NO_ICON_POSITION;
1690                                 }
1691                                 PutIconTagList(entry->filename, node->ile_DiskObj, icontags);
1692 D(bug("[wanderer] wanderer_menufunc_icon_snapshot: saved ..\n"));
1693                         }
1694                         else
1695                         {
1696 D(bug("[wanderer] wanderer_menufunc_icon_snapshot: icon has no diskobj!\n"));
1697                         }
1698                 }
1699         else
1700         {
1701             break;
1702         }
1703     } while (TRUE);
1704 D(bug("[wanderer] wanderer_menufunc_icon_snapshot: finished ..\n"));
1705 }
1706
1707 ///wanderer_menufunc_icon_leaveout()
1708 void wanderer_menufunc_icon_leaveout(void)
1709 {
1710     Object                *window   = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1711     Object                *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1712     struct IconList_Entry *entry    = (IPTR)MUIV_IconList_NextIcon_Start;
1713     struct IconEntry      *node = NULL;
1714         char                              *leavout_dir = NULL;
1715
1716 D(bug("[wanderer] wanderer_menufunc_icon_leaveout()\n"));
1717
1718         GET(window, MUIA_IconWindow_Location, &leavout_dir);
1719
1720         if (leavout_dir != NULL)
1721         {
1722 D(bug("[wanderer] wanderer_menufunc_icon_leaveout: dir '%s'\n", leavout_dir));
1723                 do
1724                 {
1725                         DoMethod(iconList, MUIM_IconList_NextIcon, MUIV_IconList_NextIcon_Selected, (IPTR)&entry);
1726
1727                         if (((IPTR)entry != MUIV_IconList_NextIcon_End) && ((entry->type == ST_FILE) || (entry->type == ST_USERDIR)))
1728                         {
1729                                 node = (struct IconEntry *)((IPTR)entry - ((IPTR)&node->ile_IconListEntry - (IPTR)node));
1730 D(bug("[wanderer] wanderer_menufunc_icon_leaveout: entry = '%s' @ %p, (%p)\n", entry->filename, entry, node));
1731                         }
1732                         else
1733                         {
1734                                 break;
1735                         }
1736                 } while (TRUE);
1737         }
1738
1739 D(bug("[wanderer] wanderer_menufunc_icon_leaveout: finished ..\n"));
1740 }
1741
1742 ///wanderer_menufunc_icon_putaway()
1743 void wanderer_menufunc_icon_putaway(void)
1744 {
1745     Object                *window   = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1746     Object                *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1747     struct IconList_Entry *entry    = (IPTR)MUIV_IconList_NextIcon_Start;
1748     struct IconEntry      *node = NULL;
1749     struct List            putawayicons;
1750
1751 D(bug("[wanderer] wanderer_menufunc_icon_putaway()\n"));
1752
1753         NEWLIST(&putawayicons);
1754
1755     do
1756     {
1757         DoMethod(iconList, MUIM_IconList_NextIcon, MUIV_IconList_NextIcon_Selected, (IPTR)&entry);
1758
1759         if (((IPTR)entry != MUIV_IconList_NextIcon_End) && ((entry->type == ST_LINKFILE) || (entry->type == ST_LINKDIR)))
1760         {
1761                         node = (struct IconEntry *)((IPTR)entry - ((IPTR)&node->ile_IconListEntry - (IPTR)node));
1762 D(bug("[wanderer] wanderer_menufunc_icon_putaway: entry = '%s' @ %p, (%p)\n", entry->filename, entry, node));
1763                         /* Remove the node from the iconlist .. */
1764                         /* Add it to our internal list for cleanup.. */
1765                         //AddTail(&putawayicons, node);
1766                 }
1767         else
1768         {
1769             break;
1770         }
1771     } while (TRUE);
1772 D(bug("[wanderer] wanderer_menufunc_icon_putaway: finished ..\n"));
1773 }
1774
1775 ///DisposeCopyDisplay()
1776 /* dispose the file copy display */
1777 void DisposeCopyDisplay(struct MUIDisplayObjects *d)
1778 {
1779     if (d->copyApp)
1780     {
1781         //SET(d->win,MUIA_Window_Open,FALSE);
1782        MUI_DisposeObject(d->copyApp);
1783     }
1784 }
1785 ///
1786
1787 ///CreateCopyDisplay()
1788 /* create the file copy window */
1789 BOOL CreateCopyDisplay(UWORD flags, struct MUIDisplayObjects *d)
1790 {
1791     BOOL    back = FALSE;
1792
1793     Object  *group, *fromObject, *toObject, *fileTextObject, *fileLengthObject, *gaugeGroup;
1794
1795     d->stopflag = 0; // will be set to 1 when clicking on stop, than the displayhook can tell actionDir() to stop copy
1796     d->bytes = 0;
1797     d->numfiles = 0;
1798     d->action = flags;
1799     d->smallobjects = 0;
1800     d->copyApp = MUI_NewObject(MUIC_Application,
1801         MUIA_Application_Title,     (IPTR)"CopyRequester",
1802         MUIA_Application_Base,      (IPTR)"WANDERER_COPY",
1803         MUIA_Application_Window, (IPTR)(d->win = MUI_NewObject(MUIC_Window,
1804             MUIA_Window_Title,          (IPTR)_(MSG_WANDERER_FILEACCESS),
1805             MUIA_Window_Activate,       TRUE,
1806             MUIA_Window_DepthGadget,    TRUE,
1807             MUIA_Window_DragBar,        TRUE,
1808             MUIA_Window_SizeGadget,     TRUE,
1809             MUIA_Window_AppWindow,      FALSE,
1810             MUIA_Window_CloseGadget,    FALSE,
1811             MUIA_Window_Borderless,     FALSE,
1812             MUIA_Window_TopEdge,        MUIV_Window_TopEdge_Centered,
1813             MUIA_Window_LeftEdge,       MUIV_Window_LeftEdge_Centered,
1814             MUIA_Window_Width,          MUIV_Window_Width_Visible(60),
1815             WindowContents, (group = MUI_NewObject(MUIC_Group,
1816                 Child, (IPTR)(fromObject = MUI_NewObject(MUIC_Text,
1817                     MUIA_InnerLeft,(8),
1818                     MUIA_InnerRight,(8),
1819                     MUIA_InnerTop,(2),
1820                     MUIA_InnerBottom,(2),
1821                     MUIA_Text_PreParse, (IPTR)"\33c",
1822                 TAG_DONE)),
1823                 Child, (IPTR)(d->sourceObject = MUI_NewObject(MUIC_Text,
1824                     TextFrame,
1825                     MUIA_InnerLeft,(8),
1826                     MUIA_InnerRight,(8),
1827                     MUIA_InnerTop,(2),
1828                     MUIA_InnerBottom,(2),
1829                     MUIA_Background,    MUII_TextBack,
1830                     MUIA_Text_PreParse, (IPTR)"\33c",
1831                     MUIA_Text_Contents, (IPTR)"---",
1832                 TAG_DONE)),
1833                 Child, (IPTR)(toObject = MUI_NewObject(MUIC_Text,
1834                     MUIA_InnerLeft,(8),
1835                     MUIA_InnerRight,(8),
1836                     MUIA_InnerTop,(2),
1837                     MUIA_InnerBottom,(2),
1838                     MUIA_Text_PreParse, (IPTR)"\33c",
1839                 TAG_DONE)),
1840                 Child, (IPTR)(d->destObject = MUI_NewObject(MUIC_Text,
1841                     TextFrame,
1842                     MUIA_InnerLeft,(8),
1843                     MUIA_InnerRight,(8),
1844                     MUIA_InnerTop,(2),
1845                     MUIA_InnerBottom,(2),
1846                     MUIA_Background,    MUII_TextBack,
1847                     MUIA_Text_PreParse, (IPTR)"\33c",
1848                     MUIA_Text_Contents, (IPTR)"---",
1849                 TAG_DONE)),
1850                 Child, (IPTR)(fileTextObject = MUI_NewObject(MUIC_Text,
1851                     MUIA_InnerLeft,(8),
1852                     MUIA_InnerRight,(8),
1853                     MUIA_InnerTop,(2),
1854                     MUIA_InnerBottom,(2),
1855                     MUIA_Text_PreParse, (IPTR)"\33c",
1856                 TAG_DONE)),
1857                 Child, (IPTR)(d->fileObject = MUI_NewObject(MUIC_Text,
1858                     TextFrame,
1859                     MUIA_InnerLeft,(8),
1860                     MUIA_InnerRight,(8),
1861                     MUIA_InnerTop,(2),
1862                     MUIA_InnerBottom,(2),
1863                     MUIA_Background,    MUII_TextBack,
1864                     MUIA_Text_PreParse, (IPTR)"\33c",
1865                     MUIA_Text_Contents, (IPTR)"---",
1866                 TAG_DONE)),
1867                 Child, (IPTR)(fileLengthObject = MUI_NewObject(MUIC_Text,
1868                     MUIA_InnerLeft,(8),
1869                     MUIA_InnerRight,(8),
1870                     MUIA_InnerTop,(2),
1871                     MUIA_InnerBottom,(2),
1872                     MUIA_Text_PreParse, (IPTR)"\33c",
1873                 TAG_DONE)),
1874                 Child, (IPTR)(gaugeGroup = MUI_NewObject(MUIC_Group,
1875                     TextFrame,
1876                     Child, d->gauge = MUI_NewObject(MUIC_Gauge,
1877                         MUIA_Gauge_Horiz, TRUE,
1878                         MUIA_Gauge_Max, 32768,
1879                         MUIA_Gauge_InfoText, _(MSG_WANDERER_FILEACCESS_PROCESSING),
1880                     TAG_DONE),
1881                     Child, MUI_NewObject(MUIC_Scale,
1882                         MUIA_Scale_Horiz, TRUE,
1883                     TAG_DONE),
1884                 TAG_DONE)),
1885                 Child, (IPTR)( d->performanceObject = MUI_NewObject(MUIC_Text,
1886                     TextFrame,
1887                     MUIA_InnerLeft,(8),
1888                     MUIA_InnerRight,(8),
1889                     MUIA_InnerTop,(2),
1890                     MUIA_InnerBottom,(2),
1891                     MUIA_Background,     MUII_TextBack,
1892                     MUIA_Text_PreParse, (IPTR)"\33c",
1893                     MUIA_Text_Contents, (IPTR)"...........0 Bytes...........",
1894                 TAG_DONE)),
1895
1896                 Child, (IPTR)( d->stopObject = SimpleButton( _(MSG_WANDERER_FILEACCESS_STOP) ) ),
1897             TAG_DONE)),
1898         TAG_DONE)),
1899     TAG_DONE);
1900
1901
1902     if (d->copyApp)
1903     {
1904         if ((flags & (ACTION_COPY|ACTION_DELETE)) == (ACTION_COPY|ACTION_DELETE))
1905         {
1906             SET(fromObject, MUIA_Text_Contents, (IPTR) _(MSG_WANDERER_FILEACCESS_MOVEFROM) );
1907             SET(toObject, MUIA_Text_Contents, (IPTR) _(MSG_WANDERER_FILEACCESS_MOVETO) );
1908             SET(fileTextObject, MUIA_Text_Contents, (IPTR) _(MSG_WANDERER_FILEACCESS_FILE) );
1909             SET(fileLengthObject, MUIA_Text_Contents, (IPTR) _(MSG_WANDERER_FILEACCESS_TRAFFIC) );
1910         }
1911         else if ((flags & ACTION_COPY) == ACTION_COPY)
1912         {
1913             SET(fromObject, MUIA_Text_Contents, (IPTR) _(MSG_WANDERER_FILEACCESS_COPYFROM) );
1914             SET(toObject, MUIA_Text_Contents, (IPTR) _(MSG_WANDERER_FILEACCESS_COPYTO) );
1915             SET(fileTextObject, MUIA_Text_Contents, (IPTR) _(MSG_WANDERER_FILEACCESS_FILE) );
1916             SET(fileLengthObject, MUIA_Text_Contents, (IPTR) _(MSG_WANDERER_FILEACCESS_TRAFFIC) );
1917
1918         }
1919         else if ((flags & ACTION_DELETE) == ACTION_DELETE)
1920         {
1921             SET(fromObject, MUIA_Text_Contents, _(MSG_WANDERER_FILEACCESS_DELETEFROM) );
1922             DoMethod(group, MUIM_Group_InitChange);
1923             DoMethod(group, OM_REMMEMBER, toObject);
1924             DoMethod(group, OM_REMMEMBER, fileLengthObject);
1925             DoMethod(group, OM_REMMEMBER, d->performanceObject);
1926             DoMethod(group, OM_REMMEMBER, d->destObject);
1927             DoMethod(group, OM_REMMEMBER, gaugeGroup);
1928             DoMethod(group, MUIM_Group_ExitChange);
1929             SET(fileTextObject, MUIA_Text_Contents, _(MSG_WANDERER_FILEACCESS_FILETODELETE) );
1930         }
1931
1932         SET(d->win,MUIA_Window_Open,TRUE);
1933         DoMethod(d->stopObject,MUIM_Notify, MUIA_Pressed, FALSE, d->stopObject, 3, MUIM_WriteLong, 1 ,&d->stopflag);
1934         back = TRUE;
1935     }
1936     return back;
1937 }
1938 ///
1939
1940 ///wanderer_menufunc_icon_delete()
1941 void wanderer_menufunc_icon_delete(void)
1942 {
1943     Object                *window   = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1944     Object                *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1945     struct IconList_Entry *entry    = ( void*) MUIV_IconList_NextIcon_Start;
1946     struct MUIDisplayObjects dobjects;
1947     struct Hook displayCopyHook;
1948     struct Hook displayDelHook;
1949     ULONG updatedIcons;
1950
1951     DoMethod(iconList, MUIM_IconList_NextIcon, MUIV_IconList_NextIcon_Selected, (IPTR) &entry);
1952     displayCopyHook.h_Entry = (HOOKFUNC) Wanderer__HookFunc_DisplayCopyFunc;
1953     displayDelHook.h_Entry = (HOOKFUNC) Wanderer__HookFunc_AskDeleteFunc;
1954
1955     updatedIcons = 0;
1956
1957     /* Process all selected entries */
1958     if (CreateCopyDisplay(ACTION_DELETE, &dobjects))
1959     {
1960         do
1961         {
1962             if ((int)entry != MUIV_IconList_NextIcon_End)
1963             {
1964                 /* copy via filesystems.c */
1965                 D(bug("[WANDERER] Delete \"%s\"\n", entry->filename);)
1966                 CopyContent( NULL, entry->filename, NULL, TRUE, ACTION_DELETE, &displayCopyHook, &displayDelHook, (APTR) &dobjects);
1967                 updatedIcons++;
1968             }
1969             DoMethod(iconList, MUIM_IconList_NextIcon, MUIV_IconList_NextIcon_Selected, (IPTR) &entry);
1970         }
1971         while ( (int)entry != MUIV_IconList_NextIcon_End );
1972         DisposeCopyDisplay(&dobjects);
1973     }
1974     // Only update list if anything happened to the icons!
1975     if ( updatedIcons > 0 )
1976     {
1977         DoMethod(window, MUIM_IconWindow_UnselectAll);
1978         DoMethod ( iconList, MUIM_IconList_Update );
1979     }
1980 }
1981 ///
1982
1983 ///wanderer_menufunc_icon_format()
1984 void wanderer_menufunc_icon_format(void)
1985 {
1986     Object                *window   = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1987     Object                *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1988     struct IconList_Entry *entry    = ( void*) MUIV_IconList_NextIcon_Start;
1989     struct MUIDisplayObjects dobjects;
1990     struct Hook displayCopyHook;
1991     struct Hook displayDelHook;
1992
1993     DoMethod(iconList, MUIM_IconList_NextIcon, MUIV_IconList_NextIcon_Selected, (IPTR) &entry);
1994
1995     /* Process only first selected entry */
1996     if ((int)entry != MUIV_IconList_NextIcon_End)
1997     {
1998         BPTR lock   = Lock(entry->filename, ACCESS_READ);
1999         D(bug("[WANDERER] Format \"%s\"\n", entry->filename);)
2000         /* Usually we pass object name and parent lock. Here we do the same thing.
2001            Just object name is empty string and its parent is device's root. */
2002         OpenWorkbenchObject
2003         (
2004             "SYS:System/Format",
2005             WBOPENA_ArgLock, (IPTR) lock,
2006             WBOPENA_ArgName, lock ? (IPTR)"" : (IPTR)entry->filename,
2007             TAG_DONE
2008         );
2009         if (lock)
2010             UnLock(lock);
2011     }
2012 }
2013 ///
2014
2015 ///wanderer_menufunc_wanderer_AROS_guisettings()
2016 void wanderer_menufunc_wanderer_AROS_guisettings(void)
2017 {
2018     //DoMethod(_WandererIntern_AppObj, MUIM_Application_OpenConfigWindow);
2019     OpenWorkbenchObject("SYS:Prefs/Zune",
2020                 WBOPENA_ArgName, (IPTR) "WANDERER",
2021                 TAG_DONE);
2022 }
2023 ///
2024
2025 ///wanderer_menufunc_wanderer_AROS_about()
2026 void wanderer_menufunc_wanderer_AROS_about(void)
2027 {
2028     OpenWorkbenchObject("SYS:System/About", TAG_DONE);
2029 }
2030 ///
2031
2032 ///wanderer_menufunc_wanderer_about()
2033 void wanderer_menufunc_wanderer_about(void)
2034 {
2035         /* Display Information about this version of wanderer */
2036 #warning "TODO: Add a requestor with ABOUT info"
2037 }
2038 ///
2039
2040 ///wanderer_menufunc_wanderer_quit()
2041 void wanderer_menufunc_wanderer_quit(void)
2042 {
2043     if (OpenWorkbenchObject("WANDERER:Tools/Quit", TAG_DONE))
2044     ;
2045     else
2046     {
2047         if (MUI_RequestA(_WandererIntern_AppObj, NULL, 0, "Wanderer", _(MSG_YESNO), _(MSG_REALLYQUIT), NULL))
2048         DoMethod(_WandererIntern_AppObj, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
2049
2050     }
2051 }
2052 ///
2053
2054 ///wanderer_menufunc_wanderer_shutdown()
2055 void wanderer_menufunc_wanderer_shutdown(void)
2056 {
2057     LONG action;
2058
2059     action = MUI_RequestA(_WandererIntern_AppObj, NULL, 0, _(MSG_SHUTDOWN_TITLE), _(MSG_SHUTDOWN_BUTTONS), _(MSG_SHUTDOWN_BODY), NULL);
2060     switch (action) {
2061     case 0:
2062         return;
2063     case 1:
2064         ShutdownA(SD_ACTION_POWEROFF);
2065         break;
2066     case 2:
2067         ShutdownA(SD_ACTION_COLDREBOOT);
2068         break;
2069     case 3:
2070         ColdReboot();
2071     }
2072     MUI_RequestA(_WandererIntern_AppObj, NULL, 0, _(MSG_SHUTDOWN_TITLE), _(MSG_OK), _(MSG_ACTION_NOT_SUPPORTED), NULL);
2073 }
2074 ///
2075
2076
2077 ///FindMenuitem()
2078 /**************************************************************************
2079 This function returns a Menu Object with the given id
2080 **************************************************************************/
2081 Object *FindMenuitem(Object* strip, int id)
2082 {
2083     return (Object*)DoMethod(strip, MUIM_FindUData, id);
2084 }
2085 ///
2086
2087 ///DoMenuNotify()
2088 /**************************************************************************
2089 This connects a notify to the given menu entry id
2090 **************************************************************************/
2091 VOID DoMenuNotify(Object* strip, int id, void *function, void *arg)
2092 {
2093     Object *entry;
2094     entry = FindMenuitem(strip,id);
2095     if (entry)
2096     {
2097     DoMethod
2098         (
2099             entry, MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime,
2100             (IPTR) entry, 4, MUIM_CallHook, (IPTR) &_WandererIntern_hook_standard,
2101             (IPTR) function, (IPTR) arg
2102         );
2103     }
2104 }
2105 ///
2106
2107 ///DoAllMenuNotifies()
2108 VOID DoAllMenuNotifies(Object *strip, STRPTR path)
2109 {
2110     Object *item;
2111
2112     if (!strip) return;
2113
2114     DoMenuNotify(strip, MEN_WANDERER_EXECUTE,
2115                                 wanderer_menufunc_wanderer_execute, path);
2116     DoMenuNotify(strip, MEN_WANDERER_SHELL,
2117                                 wanderer_menufunc_wanderer_shell, path);
2118     DoMenuNotify(strip, MEN_WANDERER_AROS_GUISETTINGS,
2119                                 wanderer_menufunc_wanderer_AROS_guisettings, NULL);
2120     DoMenuNotify(strip, MEN_WANDERER_AROS_ABOUT,
2121                                 wanderer_menufunc_wanderer_AROS_about, NULL);
2122     DoMenuNotify(strip, MEN_WANDERER_QUIT,
2123                                 wanderer_menufunc_wanderer_quit, NULL);
2124     DoMenuNotify(strip, MEN_WANDERER_SHUTDOWN,
2125                                 wanderer_menufunc_wanderer_shutdown, NULL);
2126
2127     DoMenuNotify(strip, MEN_WINDOW_NEW_DRAWER,
2128                                 wanderer_menufunc_window_newdrawer, path);
2129     DoMenuNotify(strip, MEN_WINDOW_OPEN_PARENT,
2130                                 wanderer_menufunc_window_openparent, path);
2131     DoMenuNotify(strip, MEN_WINDOW_CLOSE,
2132                                 wanderer_menufunc_window_close, NULL);
2133     DoMenuNotify(strip, MEN_WINDOW_UPDATE,
2134                                 wanderer_menufunc_window_update, NULL);
2135     DoMenuNotify(strip, MEN_WINDOW_CLEAR,
2136                                 wanderer_menufunc_window_clear, NULL);
2137
2138         DoMenuNotify(strip, MEN_WINDOW_SNAP_WIN,
2139                                 wanderer_menufunc_window_snapshot, FALSE);
2140         DoMenuNotify(strip, MEN_WINDOW_SNAP_ALL,
2141                                 wanderer_menufunc_window_snapshot, TRUE);
2142
2143     DoMenuNotify(strip, MEN_WINDOW_SELECT,
2144                                 wanderer_menufunc_window_select, NULL);
2145     DoMenuNotify(strip, MEN_WINDOW_VIEW_ALL,
2146                                 wanderer_menufunc_window_view_icons, strip);
2147     DoMenuNotify(strip, MEN_WINDOW_VIEW_HIDDEN,
2148                                 wanderer_menufunc_window_view_hidden, strip);
2149     DoMenuNotify(strip, MEN_WINDOW_SORT_NAME,
2150                                 wanderer_menufunc_window_sort_name, strip);
2151     DoMenuNotify(strip, MEN_WINDOW_SORT_TYPE,
2152                                 wanderer_menufunc_window_sort_type, strip);
2153     DoMenuNotify(strip, MEN_WINDOW_SORT_DATE,
2154                                 wanderer_menufunc_window_sort_date, strip);
2155     DoMenuNotify(strip, MEN_WINDOW_SORT_SIZE,
2156                                 wanderer_menufunc_window_sort_size, strip);
2157     DoMenuNotify(strip, MEN_WINDOW_SORT_REVERSE,
2158                                 wanderer_menufunc_window_sort_reverse, strip);
2159     DoMenuNotify(strip, MEN_WINDOW_SORT_TOPDRAWERS,
2160                                 wanderer_menufunc_window_sort_topdrawers, strip);
2161
2162     DoMenuNotify(strip, MEN_ICON_OPEN,
2163                                 wanderer_menufunc_icon_open, NULL);
2164     DoMenuNotify(strip, MEN_ICON_RENAME,
2165                                 wanderer_menufunc_icon_rename, NULL);
2166     DoMenuNotify(strip, MEN_ICON_INFORMATION,
2167                                 wanderer_menufunc_icon_information, NULL);
2168     DoMenuNotify(strip, MEN_ICON_SNAPSHOT,
2169                                 wanderer_menufunc_icon_snapshot,TRUE);
2170     DoMenuNotify(strip, MEN_ICON_UNSNAPSHOT,
2171                                 wanderer_menufunc_icon_snapshot, FALSE);
2172     DoMenuNotify(strip, MEN_ICON_LEAVEOUT,
2173                                 wanderer_menufunc_icon_leaveout, NULL);
2174     DoMenuNotify(strip, MEN_ICON_PUTAWAY,
2175                                 wanderer_menufunc_icon_putaway, NULL);
2176     DoMenuNotify(strip, MEN_ICON_DELETE,
2177                                 wanderer_menufunc_icon_delete, NULL);
2178     DoMenuNotify(strip, MEN_ICON_FORMAT,
2179                                 wanderer_menufunc_icon_format, NULL);
2180
2181     if ((item = FindMenuitem(strip, MEN_WANDERER_BACKDROP)))
2182     {
2183         DoMethod
2184         (
2185             item, MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime,
2186             (IPTR) _WandererIntern_AppObj, 7, MUIM_Application_PushMethod,
2187             (IPTR) _WandererIntern_AppObj, 4, MUIM_CallHook, (IPTR) &_WandererIntern_hook_standard,
2188             (IPTR) wanderer_menufunc_wanderer_backdrop, (IPTR) strip
2189         );
2190     }
2191 }
2192 ///
2193
2194 ///Wanderer__Func_UpdateMenuStates()
2195 VOID Wanderer__Func_UpdateMenuStates(Object *WindowObj, Object *IconlistObj)
2196 {
2197         IPTR   current_DispFlags = NULL, current_SortFlags = NULL;
2198         Object *current_Menustrip = NULL, *current_MenuItem = NULL;
2199         struct IconList_Entry *icon_entry    = (IPTR)MUIV_IconList_NextIcon_Start;
2200         int selected_count = 0;
2201
2202         BOOL icon_men_PutAway = FALSE;
2203         BOOL icon_men_LeaveOut = FALSE;
2204         BOOL icon_men_Format = FALSE;
2205         BOOL icon_men_EmptyTrash = FALSE;
2206
2207         if (IconlistObj == NULL)
2208                 return;
2209
2210 D(bug("[Wanderer] Wanderer__Func_UpdateMenuStates(IconList @ %p)\n", IconlistObj));
2211
2212         GET(IconlistObj, MUIA_IconList_SortFlags, &current_SortFlags);
2213         GET(IconlistObj, MUIA_IconList_DisplayFlags, &current_DispFlags);
2214         GET(WindowObj, MUIA_Window_Menustrip, &current_Menustrip);
2215
2216 D(bug("[Wanderer] Wanderer__Func_UpdateMenuStates: Menu @ %p, Display Flags : %x, Sort Flags : %x\n", current_Menustrip, current_DispFlags, current_SortFlags));
2217
2218         do
2219         {
2220                 DoMethod(IconlistObj, MUIM_IconList_NextIcon, MUIV_IconList_NextIcon_Selected, (IPTR)&icon_entry);
2221
2222                 if ((IPTR)icon_entry != MUIV_IconList_NextIcon_End)
2223                 {
2224                         if (icon_entry->type == ST_ROOT)
2225                         {
2226 D(bug("[Wanderer] Wanderer__Func_UpdateMenuStates: ST_ROOT\n"));
2227                                 icon_men_Format = TRUE;
2228                         }
2229                         if ((icon_entry->type == ST_LINKDIR) || (icon_entry->type == ST_LINKFILE))
2230                         {
2231 D(bug("[Wanderer] Wanderer__Func_UpdateMenuStates: ST_LINKDIR/ST_LINKFILE\n"));
2232                                 icon_men_PutAway = TRUE;
2233                         }
2234                         if ((icon_entry->type == ST_USERDIR) || (icon_entry->type == ST_FILE))
2235                         {
2236 D(bug("[Wanderer] Wanderer__Func_UpdateMenuStates: ST_USERDIR/ST_FILE\n"));
2237                                 icon_men_LeaveOut = TRUE;
2238                         }
2239                         selected_count++;
2240                 }
2241                 else
2242                 {
2243                         break;
2244                 }
2245         } while (TRUE);
2246
2247         if (current_Menustrip != NULL)
2248         {
2249                 if (selected_count > 0)
2250                 {
2251                         if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_ICON_OPEN)) != NULL)
2252                         {
2253                                 SET(current_MenuItem, MUIA_Menuitem_Enabled, TRUE);
2254                         }
2255                         if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_ICON_RENAME)) != NULL)
2256                         {
2257                                 SET(current_MenuItem, MUIA_Menuitem_Enabled, TRUE);
2258                         }
2259                         if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_ICON_INFORMATION)) != NULL)
2260                         {
2261                                 SET(current_MenuItem, MUIA_Menuitem_Enabled, TRUE);
2262                         }
2263                         if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_ICON_SNAPSHOT)) != NULL)
2264                         {
2265                                 SET(current_MenuItem, MUIA_Menuitem_Enabled, TRUE);
2266                         }
2267                         if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_ICON_UNSNAPSHOT)) != NULL)
2268                         {
2269                                 SET(current_MenuItem, MUIA_Menuitem_Enabled, TRUE);
2270                         }
2271                         if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_ICON_DELETE)) != NULL)
2272                         {
2273                                 SET(current_MenuItem, MUIA_Menuitem_Enabled, TRUE);
2274                         }
2275                         if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_ICON_FORMAT)) != NULL)
2276                         {
2277                                 SET(current_MenuItem, MUIA_Menuitem_Enabled, icon_men_Format);
2278                         }
2279                         if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_ICON_LEAVEOUT)) != NULL)
2280                         {
2281                                 SET(current_MenuItem, MUIA_Menuitem_Enabled, icon_men_LeaveOut);
2282                         }
2283                         if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_ICON_PUTAWAY)) != NULL)
2284                         {
2285                                 SET(current_MenuItem, MUIA_Menuitem_Enabled, icon_men_PutAway);
2286                         }
2287                         if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_ICON_EMPTYTRASH)) != NULL)
2288                         {
2289                                 SET(current_MenuItem, MUIA_Menuitem_Enabled, icon_men_EmptyTrash);
2290                         }
2291                         if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_WINDOW_CLEAR)) != NULL)
2292                         {
2293                                 SET(current_MenuItem, MUIA_Menuitem_Enabled, TRUE);
2294                         }
2295                 }
2296                 else
2297                 {
2298                         if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_ICON_OPEN)) != NULL)
2299                         {
2300                                 SET(current_MenuItem, MUIA_Menuitem_Enabled, FALSE);
2301                         }
2302                         if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_ICON_RENAME)) != NULL)
2303                         {
2304                                 SET(current_MenuItem, MUIA_Menuitem_Enabled, FALSE);
2305                         }
2306                         if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_ICON_INFORMATION)) != NULL)
2307                         {
2308                                 SET(current_MenuItem, MUIA_Menuitem_Enabled, FALSE);
2309                         }
2310                         if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_ICON_SNAPSHOT)) != NULL)
2311                         {
2312                                 SET(current_MenuItem, MUIA_Menuitem_Enabled, FALSE);
2313                         }
2314                         if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_ICON_UNSNAPSHOT)) != NULL)
2315                         {
2316                                 SET(current_MenuItem, MUIA_Menuitem_Enabled, FALSE);
2317                         }
2318                         if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_ICON_DELETE)) != NULL)
2319                         {
2320                                 SET(current_MenuItem, MUIA_Menuitem_Enabled, FALSE);
2321                         }
2322                         if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_ICON_FORMAT)) != NULL)
2323                         {
2324                                 SET(current_MenuItem, MUIA_Menuitem_Enabled, FALSE);
2325                         }
2326                         if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_ICON_LEAVEOUT)) != NULL)
2327                         {
2328                                 SET(current_MenuItem, MUIA_Menuitem_Enabled, FALSE);
2329                         }
2330                         if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_ICON_PUTAWAY)) != NULL)
2331                         {
2332                                 SET(current_MenuItem, MUIA_Menuitem_Enabled, FALSE);
2333                         }
2334                         if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_ICON_EMPTYTRASH)) != NULL)
2335                         {
2336                                 SET(current_MenuItem, MUIA_Menuitem_Enabled, FALSE);
2337                         }
2338                         if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_WINDOW_CLEAR)) != NULL)
2339                         {
2340                                 SET(current_MenuItem, MUIA_Menuitem_Enabled, FALSE);
2341                         }
2342                 }
2343                 if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_WINDOW_VIEW_ALL)) != NULL)
2344                 {
2345                         SET(current_MenuItem, MUIA_Menuitem_Checked, (BOOL)!(current_DispFlags & ICONLIST_DISP_SHOWINFO));
2346                 }
2347                 if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_WINDOW_VIEW_HIDDEN)) != NULL)
2348                 {
2349                         SET(current_MenuItem, MUIA_Menuitem_Checked, (BOOL)(current_DispFlags & ICONLIST_DISP_SHOWHIDDEN));
2350                 }
2351                 if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_WINDOW_SORT_NAME)) != NULL)
2352                 {
2353                         SET(current_MenuItem, MUIA_Menuitem_Checked, (BOOL)((current_SortFlags & ICONLIST_SORT_MASK) == ICONLIST_SORT_BY_NAME));
2354                 }
2355                 if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_WINDOW_SORT_DATE)) != NULL)
2356                 {
2357                         SET(current_MenuItem, MUIA_Menuitem_Checked, (BOOL)((current_SortFlags & ICONLIST_SORT_MASK) == ICONLIST_SORT_BY_DATE));
2358                 }
2359                 if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_WINDOW_SORT_SIZE)) != NULL)
2360                 {
2361                         SET(current_MenuItem, MUIA_Menuitem_Checked, (BOOL)((current_SortFlags & ICONLIST_SORT_MASK) == ICONLIST_SORT_BY_SIZE));
2362                 }
2363                 if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_WINDOW_SORT_TYPE)) != NULL)
2364                 {
2365                         SET(current_MenuItem, MUIA_Menuitem_Checked, (BOOL)((current_SortFlags & ICONLIST_SORT_MASK) == ICONLIST_SORT_MASK));
2366                 }
2367         }
2368 }
2369
2370 ///Wanderer__HookFunc_UpdateMenuStatesFunc()
2371 #ifdef __AROS__
2372 AROS_UFH3
2373 (
2374     ULONG, Wanderer__HookFunc_UpdateMenuStatesFunc,
2375         AROS_UFHA(struct Hook *,    hook,   A0),
2376         AROS_UFHA(APTR *,           obj,    A2),
2377         AROS_UFHA(APTR,             param,  A1)
2378 )
2379 {
2380 #else
2381 HOOKPROTO(Wanderer__HookFunc_UpdateMenuStatesFunc, ULONG, struct dCopyStruct *obj, APTR param)
2382 {
2383 #endif
2384     AROS_USERFUNC_INIT
2385         Object  *self = ( Object *)obj;
2386         Object  *window = *( Object **)param;
2387         Object  *iconlist = NULL;
2388
2389 D(bug("[Wanderer] Wanderer__HookFunc_UpdateMenuStatesFunc(self @ %p, window @ %p)\n", self, window));
2390
2391         GET(window, MUIA_IconWindow_IconList, &iconlist);
2392
2393 D(bug("[Wanderer] Wanderer__HookFunc_UpdateMenuStatesFunc: iconlist @ %p\n", iconlist));
2394
2395         Wanderer__Func_UpdateMenuStates(window, iconlist);
2396
2397 D(bug("[Wanderer] Wanderer__HookFunc_UpdateMenuStatesFunc: Update Complete.\n"));
2398
2399     AROS_USERFUNC_EXIT
2400 }
2401
2402 /*** Methods ****************************************************************/
2403 ///OM_NEW()
2404 Object *Wanderer__OM_NEW(Class *CLASS, Object *self, struct opSet *message)
2405 {
2406 D(bug("[Wanderer] Wanderer__OM_NEW()\n"));
2407
2408     self = (Object *) DoSuperNewTags
2409     (
2410         CLASS, self, NULL,
2411
2412         MUIA_Application_Title,       (IPTR) "Wanderer",
2413         MUIA_Application_Base,        (IPTR) "WANDERER",
2414         MUIA_Application_Version,     (IPTR) VERSION,
2415         MUIA_Application_Description, (IPTR) _(MSG_DESCRIPTION),
2416         MUIA_Application_SingleTask,         TRUE,
2417
2418         TAG_MORE, (IPTR) message->ops_AttrList
2419     );
2420
2421     if (self != NULL)
2422     {
2423         SETUP_WANDERER_INST_DATA;
2424
2425     //    ULONG updatedIcons;
2426 D(bug("[Wanderer] Wanderer__OM_NEW: SELF = %d, Private data @ %x\n", self, data));
2427
2428         _WandererIntern_CLASS = CLASS;
2429
2430 #if defined(WANDERER_DEFAULT_BACKDROP)
2431         data->wd_Option_BackDropMode = TRUE;
2432 #else
2433         data->wd_Option_BackDropMode = FALSE;
2434 #endif
2435
2436         /*-- Setup hooks structures ----------------------------------------*/
2437         #ifdef __AROS__
2438         _WandererIntern_hook_standard.h_Entry = (HOOKFUNC) Wanderer__HookFunc_StandardFunc;
2439         _WandererIntern_hook_action.h_Entry   = (HOOKFUNC) Wanderer__HookFunc_ActionFunc;
2440         _WandererIntern_hook_backdrop.h_Entry   = (HOOKFUNC) Wanderer__HookFunc_BackdropFunc;
2441         #else
2442          _WandererIntern_hook_standard = &Hook_StandardFunc;
2443         _WandererIntern_hook_action   = &Hook_ActionFunc;
2444         _WandererIntern_hook_backdrop   = &Hook_BackdropFunc;
2445         #endif
2446
2447         // ---
2448         if ((data->wd_CommandPort = CreateMsgPort()) == NULL)
2449         {
2450             CoerceMethod(CLASS, self, OM_DISPOSE);
2451             return NULL;
2452         }
2453
2454         if ((data->wd_NotifyPort = CreateMsgPort()) == NULL)
2455         {
2456             CoerceMethod(CLASS, self, OM_DISPOSE);
2457             return NULL;
2458         }
2459
2460         RegisterWorkbench(data->wd_CommandPort);
2461
2462         /* Setup command port handler --------------------------------------*/
2463         data->wd_CommandIHN.ihn_Signals = 1UL << data->wd_CommandPort->mp_SigBit;
2464         data->wd_CommandIHN.ihn_Object  = self;
2465         data->wd_CommandIHN.ihn_Method  = MUIM_Wanderer_HandleCommand;
2466
2467         DoMethod
2468         (
2469             self, MUIM_Application_AddInputHandler, (IPTR) &data->wd_CommandIHN
2470         );
2471
2472         /* Setup timer handler ---------------------------------------------*/
2473         data->wd_TimerIHN.ihn_Flags  = MUIIHNF_TIMER;
2474         data->wd_TimerIHN.ihn_Millis = 3000;
2475         data->wd_TimerIHN.ihn_Object = self;
2476         data->wd_TimerIHN.ihn_Method = MUIM_Wanderer_HandleTimer;
2477
2478         DoMethod
2479         (
2480             self, MUIM_Application_AddInputHandler, (IPTR) &data->wd_TimerIHN
2481         );
2482
2483         /* Setup filesystem notification handler ---------------------------*/
2484         data->wd_NotifyIHN.ihn_Signals = 1UL << data->wd_NotifyPort->mp_SigBit;
2485         data->wd_NotifyIHN.ihn_Object  = self;
2486         data->wd_NotifyIHN.ihn_Method  = MUIM_Wanderer_HandleNotify;
2487
2488         DoMethod
2489         (
2490             self, MUIM_Application_AddInputHandler, (IPTR) &data->wd_NotifyIHN
2491         );
2492
2493         // All the following should be moved to InitWandererPrefs
2494
2495         /* Setup notification on prefs file --------------------------------*/
2496         data->wd_PrefsNotifyRequest.nr_Name                 = ExpandEnvName("ENV:SYS/Wanderer.prefs");
2497         data->wd_PrefsNotifyRequest.nr_Flags                = NRF_SEND_MESSAGE;
2498         data->wd_PrefsNotifyRequest.nr_stuff.nr_Msg.nr_Port = data->wd_NotifyPort;
2499
2500         if (StartNotify(&data->wd_PrefsNotifyRequest))
2501         {
2502 D(bug("[Wanderer] Wanderer__OM_NEW: Prefs-notification setup on '%s'\n", data->wd_PrefsNotifyRequest.nr_Name));
2503         }
2504         else
2505         {
2506 D(bug("[Wanderer] Wanderer__OM_NEW: FAILED to setup Prefs-notification!\n"));
2507         }
2508     #ifdef __AROS__
2509         data->wd_Prefs = WandererPrefsObject, End; // FIXME: error handling
2510     #else
2511     data->wd_Prefs = NewObject(WandererPrefs_CLASS->mcc_Class, NULL, TAG_DONE); // FIXME: error handling
2512     #endif
2513
2514         if (data->wd_Prefs)
2515         {
2516 D(bug("[Wanderer] Wanderer__OM_NEW: Prefs-Screentitle = '%s'\n",XGET(data->wd_Prefs, MUIA_IconWindowExt_ScreenTitle_String)));
2517             data->wd_PrefsIntern = InitWandererPrefs();
2518         }
2519     }
2520 D(bug("[Wanderer] obj = %ld\n", self));
2521     return self;
2522 }
2523 ///
2524
2525 ///OM_DISPOSE()
2526 IPTR Wanderer__OM_DISPOSE(Class *CLASS, Object *self, Msg message)
2527 {
2528     SETUP_WANDERER_INST_DATA;
2529
2530     if (data->wd_CommandPort)
2531     {
2532     /*
2533             They only have been added if the creation of the msg port was
2534         successful
2535         */
2536         DoMethod(self, MUIM_Application_RemInputHandler, (IPTR) &data->wd_TimerIHN);
2537         DoMethod(self, MUIM_Application_RemInputHandler, (IPTR) &data->wd_CommandIHN);
2538         DoMethod(self, MUIM_Application_RemInputHandler, (IPTR) &data->wd_NotifyIHN);
2539
2540         UnregisterWorkbench(data->wd_CommandPort);
2541
2542         EndNotify(&data->wd_PrefsNotifyRequest);
2543
2544         DeleteMsgPort(data->wd_NotifyPort);
2545         data->wd_NotifyPort = NULL;
2546
2547         DeleteMsgPort(data->wd_CommandPort);
2548         data->wd_CommandPort = NULL;
2549
2550         DisposeObject(data->wd_Prefs);
2551         data->wd_Prefs = NULL;
2552     }
2553
2554     return DoSuperMethodA(CLASS, self, (Msg) message);
2555 }
2556 ///
2557
2558 ///OM_SET()
2559 IPTR Wanderer__OM_SET(Class *CLASS, Object *self, struct opSet *message)
2560 {
2561     SETUP_WANDERER_INST_DATA;
2562     struct TagItem *tstate = message->ops_AttrList, *tag;
2563
2564     while ((tag = NextTagItem((TAGITEM)&tstate)) != NULL)
2565     {
2566         switch (tag->ti_Tag)
2567         {
2568         case MUIA_Wanderer_Screen:
2569 D(bug("[Wanderer] Wanderer__OM_SET: MUIA_Wanderer_Screen = %p\n", tag->ti_Data));
2570 D(bug("[Wanderer] Wanderer__OM_SET: setting MUIA_Wanderer_Screen isnt yet handled!\n"));
2571                 break;
2572
2573         case MUIA_Wanderer_ActiveWindow:
2574                 data->wd_ActiveWindow = (Object *) tag->ti_Data;
2575 D(bug("[Wanderer] Wanderer__OM_SET: MUIA_Wanderer_ActiveWindow = %p\n", tag->ti_Data));
2576                 if (!(XGET(data->wd_ActiveWindow, MUIA_Window_Activate)))
2577                                 {
2578                     NNSET(data->wd_ActiveWindow, MUIA_Window_Activate, TRUE);
2579                                 }
2580                                 Object *activatewin_Iconlist = NULL;
2581
2582                                 GET(data->wd_ActiveWindow, MUIA_IconWindow_IconList, &activatewin_Iconlist);
2583                                 Wanderer__Func_UpdateMenuStates(data->wd_ActiveWindow, activatewin_Iconlist);
2584                 break;
2585
2586         case MUIA_Application_Iconified:
2587             /* Wanderer itself cannot be iconified,
2588         just hide, instead.  */
2589             tag->ti_Tag  = MUIA_ShowMe;
2590             tag->ti_Data = !tag->ti_Data;
2591         break;
2592         }
2593     }
2594
2595     return DoSuperMethodA(CLASS, self, (Msg) message);
2596 }
2597 ///
2598
2599 ///OM_GET()
2600 IPTR Wanderer__OM_GET(Class *CLASS, Object *self, struct opGet *message)
2601 {
2602     SETUP_WANDERER_INST_DATA;
2603     IPTR *store = message->opg_Storage;
2604     IPTR  rv    = TRUE;
2605
2606     switch (message->opg_AttrID)
2607     {
2608         case MUIA_Wanderer_Screen:
2609             *store = (IPTR)data->wd_Screen;
2610             break;
2611
2612         case MUIA_Wanderer_Prefs:
2613             *store = (IPTR)data->wd_Prefs;
2614             break;
2615
2616         case MUIA_Wanderer_ActiveWindow:
2617             *store = (IPTR)data->wd_ActiveWindow;
2618             break;
2619
2620         case MUIA_Wanderer_WorkbenchWindow:
2621             *store = (IPTR)data->wd_WorkbenchWindow;
2622             break;
2623
2624         case MUIA_Wanderer_FileSysNotifyPort:
2625             *store = (IPTR)data->wd_NotifyPort;
2626             break;
2627
2628         default:
2629             rv = DoSuperMethodA(CLASS, self, (Msg) message);
2630     }
2631
2632     return rv;
2633 }
2634 ///
2635
2636 ///Wanderer__MUIM_Application_Execute()
2637 /* Main entry point for Wanderer Application Object */
2638 /*
2639     When the executable creates our object it calls zune
2640     to handle basic "control" ... which results in Zune
2641     calling this method ..
2642 */
2643 IPTR Wanderer__MUIM_Application_Execute
2644 (
2645     Class *CLASS, Object *self, Msg message
2646 )
2647 {
2648     SETUP_WANDERER_INST_DATA;
2649
2650 D(bug("[Wanderer] Wanderer__MUIM_Application_Execute() ##\n[Wanderer] Wanderer__MUIM_Application_Execute: Creating 'Workbench' Window..\n"));
2651
2652     data->wd_WorkbenchWindow = (Object *) DoMethod
2653     (
2654         self, MUIM_Wanderer_CreateDrawerWindow, (IPTR) NULL
2655     );
2656
2657     if (data->wd_WorkbenchWindow != NULL)
2658     {
2659 D(bug("[Wanderer] Wanderer__MUIM_Application_Execute: Workbench Window Obj @ %x\n", data->wd_WorkbenchWindow));
2660
2661         Detach();
2662
2663 D(bug("[Wanderer] Wanderer__MUIM_Application_Execute: Really handing control to Zune ..\n"));
2664
2665          #ifdef __AROS__
2666         DoSuperMethodA(CLASS, self, message);
2667         #else
2668         {
2669           IPTR sigs = 0;
2670           while (DoMethod(self,MUIM_Application_NewInput,&sigs) != MUIV_Application_ReturnID_Quit)
2671           {
2672             if (sigs)
2673             {
2674               sigs = Wait(sigs | SIGBREAKF_CTRL_C);
2675               if (sigs & SIGBREAKF_CTRL_C) break;
2676             }
2677           }
2678
2679           return 0;
2680         }
2681         #endif
2682
2683         return RETURN_OK;
2684     }
2685
2686 #warning "TODO: Report an error if we fail to create the Workbench's window ..."
2687
2688     return RETURN_ERROR;
2689 }
2690 ///
2691
2692 ///Wanderer__MUIM_Wanderer_HandleTimer()
2693 /*This function uses GetScreenTitle() function...*/
2694
2695 IPTR Wanderer__MUIM_Wanderer_HandleTimer
2696 (
2697     Class *CLASS, Object *self, Msg message
2698 )
2699 {
2700     SETUP_WANDERER_INST_DATA;
2701     Object *cstate = (Object*)(((struct List*)XGET(self, MUIA_Application_WindowList))->lh_Head);
2702     Object *child = NULL;
2703
2704     STRPTR scr_title = GetUserScreenTitle(data->wd_Prefs);
2705
2706     while ((child = NextObject(&cstate)))
2707        SET(child, MUIA_Window_ScreenTitle, (IPTR) scr_title);
2708
2709     return TRUE;
2710 }
2711 ///
2712
2713 ///Wanderer__MUIM_Wanderer_HandleCommand()
2714 IPTR Wanderer__MUIM_Wanderer_HandleCommand
2715 (
2716     Class *CLASS, Object *self, Msg message
2717 )
2718 {
2719     SETUP_WANDERER_INST_DATA;
2720     struct WBHandlerMessage *wbhm = NULL;
2721     struct List *pub_screen_list;
2722     struct PubScreenNode *pub_screen_node;
2723     WORD visitor_count = 0;
2724 D(bug("[Wanderer] %s()\n", __PRETTY_FUNCTION__));
2725 D(bug("[Wanderer] %s: Recieved signal at notification port\n", __PRETTY_FUNCTION__));
2726
2727     while ((wbhm = WBHM(GetMsg(data->wd_CommandPort))) != NULL)
2728     {
2729 D(bug("[Wanderer] %s: Recieved message from handler, type = %ld\n", __PRETTY_FUNCTION__, wbhm->wbhm_Type));
2730
2731         switch (wbhm->wbhm_Type)
2732         {
2733             case WBHM_TYPE_SHOW:
2734 D(bug("[Wanderer] %s: WBHM_TYPE_SHOW\n", __PRETTY_FUNCTION__));
2735                 if ((data->wd_Screen = LockPubScreen(NULL)) != NULL)
2736                 {
2737 D(bug("[Wanderer] %s: Unlocking access to screen @ %x\n", __PRETTY_FUNCTION__, data->wd_Screen));
2738                     UnlockPubScreen(NULL, data->wd_Screen);
2739                     SET(self, MUIA_ShowMe, TRUE);
2740                 }
2741                 else
2742                 {
2743 #warning "TODO: We need to handle the possiblity that we fail to lock the pubscreen..."
2744 D(bug("[Wanderer] %s: Couldnt Lock WB Screen!!\n", __PRETTY_FUNCTION__));
2745                 }
2746                 break;
2747
2748             case WBHM_TYPE_HIDE:
2749 D(bug("[Wanderer] %s: WBHM_TYPE_HIDE\n", __PRETTY_FUNCTION__));
2750                 pub_screen_list = LockPubScreenList();
2751
2752                 #ifdef __AROS__
2753                 ForeachNode (pub_screen_list, pub_screen_node)
2754                 #else
2755     Foreach_Node(pub_screen_list, pub_screen_node);
2756                 #endif
2757                 {
2758                     if (pub_screen_node->psn_Screen == data->wd_Screen)
2759                         visitor_count = pub_screen_node->psn_VisitorCount;
2760                 }
2761                 UnlockPubScreenList();
2762                 if (visitor_count == 0)
2763                     SET(self, MUIA_ShowMe, FALSE);
2764                 break;
2765
2766             case WBHM_TYPE_UPDATE:
2767 D(bug("[Wanderer] %s: WBHM_TYPE_UPDATE\n", __PRETTY_FUNCTION__));
2768                 {
2769                     CONST_STRPTR name = wbhm->wbhm_Data.Update.Name;
2770                     ULONG        length;
2771
2772                     switch (wbhm->wbhm_Data.Update.Type)
2773                     {
2774                         case WBDISK:
2775                         case WBDRAWER:
2776                         case WBGARBAGE:
2777                             length = strlen(name);
2778                             break;
2779
2780                         default:
2781                             length = PathPart(name) - name;
2782                             break;
2783                     }
2784
2785 D(bug("[Wanderer] %s: name = %s, length = %ld\n", __PRETTY_FUNCTION__, name, length));
2786
2787                     {
2788                         Object *cstate = (Object*)(((struct List*)XGET(self, MUIA_Application_WindowList))->lh_Head);
2789                         Object *child = NULL;
2790
2791                         while ((child = NextObject(&cstate)))
2792                         {
2793                             if (XGET(child, MUIA_UserData))
2794                             {
2795                                 STRPTR child_drawer = (STRPTR)XGET(child, MUIA_IconWindow_Location);
2796
2797                                 if
2798                                 (
2799                                     child_drawer != NULL
2800                                     && strncmp(name, child_drawer, length) == 0
2801                                     && strlen(child_drawer) == length
2802                                 )
2803                                 {
2804                                     Object *iconlist = (Object *) XGET(child, MUIA_IconWindow_IconList);
2805
2806 D(bug("[Wanderer] %s: Drawer found: %s!\n", __PRETTY_FUNCTION__, child_drawer));
2807
2808                                     if (iconlist != NULL)
2809                                     {
2810                                         DoMethod ( iconlist, MUIM_IconList_Update );
2811                                     }
2812                                     break;
2813                                 }
2814                             }
2815                         }
2816                     }
2817                 }
2818                 break;
2819
2820             case WBHM_TYPE_OPEN:
2821 D(bug("[Wanderer] %s: WBHM_TYPE_OPEN\n", __PRETTY_FUNCTION__));
2822
2823                 {
2824                     Object *cstate = (Object*)(((struct List*)XGET(self, MUIA_Application_WindowList))->lh_Head);
2825                     Object *child;
2826                     CONST_STRPTR buf = wbhm->wbhm_Data.Open.Name;
2827
2828                     while ((child = NextObject(&cstate)))
2829                     {
2830                         if (XGET(child, MUIA_UserData))
2831                         {
2832                             STRPTR child_drawer = (STRPTR)XGET(child, MUIA_IconWindow_Location);
2833                             if (child_drawer && !Stricmp(buf,child_drawer))
2834                             {
2835                                 int is_open = XGET(child, MUIA_Window_Open);
2836                                 if (!is_open)
2837                                     DoMethod(child, MUIM_IconWindow_Open);
2838                                 else
2839                                 {
2840                                     DoMethod(child, MUIM_Window_ToFront);
2841                                     SET(child, MUIA_Window_Activate, TRUE);
2842                                 }
2843                                 return 0;
2844                             }
2845                         }
2846                     }
2847
2848                     DoMethod
2849                     (
2850                         _WandererIntern_AppObj, MUIM_Wanderer_CreateDrawerWindow, (IPTR) buf
2851                     );
2852                 }
2853                 break;
2854         } /* switch */
2855
2856         ReplyMsg((struct Message *) wbhm);
2857     }
2858
2859     return 0;
2860 }
2861 ///
2862
2863 ///Wanderer__MUIM_Wanderer_HandleNotify()
2864 IPTR Wanderer__MUIM_Wanderer_HandleNotify
2865 (
2866     Class *CLASS, Object *self, Msg message
2867 )
2868 {
2869     SETUP_WANDERER_INST_DATA;
2870     struct Message *plainMessage = NULL;
2871
2872     while ((plainMessage = GetMsg(data->wd_NotifyPort)) != NULL)
2873     {
2874         struct NotifyMessage *notifyMessage = (struct NotifyMessage *) plainMessage;
2875         IPTR                  notifyMessage_UserData = notifyMessage->nm_NReq->nr_UserData;
2876 D(bug("[Wanderer] Wanderer__MUIM_Wanderer_HandleNotify: got FS notification ('%s' @ 0x%p) userdata = 0x%p!\n", notifyMessage->nm_NReq->nr_Name, notifyMessage, notifyMessage_UserData));
2877
2878         if ((notifyMessage_UserData ==(IPTR) NULL) && (strcmp(notifyMessage->nm_NReq->nr_Name, data->wd_PrefsNotifyRequest.nr_Name) == 0))
2879         {
2880             /* reload prefs file */
2881 D(bug("[Wanderer] Wanderer__MUIM_Wanderer_HandleNotify: Wanderer Prefs-File Changed .. Reloading\n"));
2882
2883             DoMethod(data->wd_Prefs, MUIM_WandererPrefs_Reload);
2884         }
2885         else if (notifyMessage_UserData != (IPTR) NULL)
2886         {
2887 D(bug("[Wanderer] Wanderer__MUIM_Wanderer_HandleNotify: Drawer Window contents changed .. Updating\n"));
2888             DoMethod(notifyMessage_UserData, MUIM_IconList_Update);
2889         }
2890
2891         ReplyMsg((struct Message *)notifyMessage);
2892     }
2893
2894     return 0;
2895 }
2896 ///
2897
2898 ///Wanderer__Func_CreateWandererIntuitionMenu()
2899 /* Some differences here between volumes and subwindows */
2900 Object * Wanderer__Func_CreateWandererIntuitionMenu( BOOL isRoot, BOOL isBackdrop)
2901 {
2902     Object   *_NewWandIntMenu__menustrip = NULL;
2903     IPTR     _NewWandIntMenu__OPTION_BACKDROP = CHECKIT|MENUTOGGLE;
2904     IPTR     _NewWandIntMenu__OPTION_SHOWALL  = CHECKIT|MENUTOGGLE;
2905
2906     if (isBackdrop)
2907     {
2908         _NewWandIntMenu__OPTION_BACKDROP |= CHECKED;
2909     }
2910
2911     if ( isRoot )
2912     {
2913         struct NewMenu nm[] = {
2914             {NM_TITLE,     _(MSG_MEN_WANDERER)},
2915             {NM_ITEM,  _(MSG_MEN_BACKDROP),_(MSG_MEN_SC_BACKDROP), _NewWandIntMenu__OPTION_BACKDROP     , 0, (APTR) MEN_WANDERER_BACKDROP},
2916             {NM_ITEM,  _(MSG_MEN_EXECUTE), _(MSG_MEN_SC_EXECUTE) , 0                                    , 0, (APTR) MEN_WANDERER_EXECUTE},
2917
2918             {NM_ITEM,  _(MSG_MEN_SHELL),   _(MSG_MEN_SC_SHELL)   , 0                                    , 0, (APTR) MEN_WANDERER_SHELL},
2919 #if defined(__AROS__)
2920             {NM_ITEM,  "AROS"},
2921             {NM_SUB,   _(MSG_MEN_ABOUT),   NULL                  , 0                                    , 0, (APTR) MEN_WANDERER_AROS_ABOUT},
2922             {NM_SUB,   _(MSG_MEN_GUISET),  NULL                  , 0                                    , 0, (APTR) MEN_WANDERER_AROS_GUISETTINGS},
2923 #endif
2924             {NM_ITEM,  _(MSG_MEN_QUIT) ,   _(MSG_MEN_SC_QUIT)    , 0                                    , 0, (APTR) MEN_WANDERER_QUIT},
2925             {NM_ITEM,  _(MSG_MEN_SHUTDOWN), NULL                 , 0                                            , 0, (APTR) MEN_WANDERER_SHUTDOWN},
2926             {NM_TITLE, _(MSG_MEN_WINDOW),  NULL, 0},
2927             {NM_ITEM,  _(MSG_MEN_UPDATE),  NULL                  , 0                                    , 0, (APTR) MEN_WINDOW_UPDATE},
2928             {NM_ITEM, NM_BARLABEL},
2929             {NM_ITEM, _(MSG_MEN_CONTENTS), _(MSG_MEN_SC_CONTENTS), 0                                    , 0, (APTR) MEN_WINDOW_SELECT},
2930             {NM_ITEM,  _(MSG_MEN_CLRSEL),  _(MSG_MEN_SC_CLRSEL)  , 0                                    , 0, (APTR) MEN_WINDOW_CLEAR},
2931             {NM_ITEM, NM_BARLABEL},
2932             {NM_ITEM,  _(MSG_MEN_SNAPSHT) },
2933             {NM_SUB,   _(MSG_MEN_WINDOW),  NULL                  , 0                                    , 0, (APTR) MEN_WINDOW_SNAP_WIN},
2934             {NM_SUB,   _(MSG_MEN_ALL),     NULL                  , 0                                    , 0, (APTR) MEN_WINDOW_SNAP_ALL},
2935             {NM_ITEM, NM_BARLABEL},
2936             {NM_ITEM,  _(MSG_MEN_VIEW)},
2937             {NM_SUB,   _(MSG_MEN_ICVIEW),  NULL                  , CHECKIT|CHECKED                      , 8+16+32, (APTR) MEN_WINDOW_VIEW_ICON},
2938             {NM_SUB,   _(MSG_MEN_DCVIEW),  NULL                  , CHECKIT                              , 4+16+32, (APTR) MEN_WINDOW_VIEW_DETAIL},
2939             {NM_SUB, NM_BARLABEL},
2940             {NM_SUB,   _(MSG_MEN_ALLFIL),  NULL                  , _NewWandIntMenu__OPTION_SHOWALL      , 0, (APTR) MEN_WINDOW_VIEW_ALL},
2941             {NM_ITEM,  _(MSG_MEN_SORTIC)},
2942             {NM_SUB,   _(MSG_MEN_CLNUP),   _(MSG_MEN_SC_CLNUP)   , 0                                    , 0, (APTR) MEN_WINDOW_SORT_NOW},
2943             {NM_SUB, NM_BARLABEL},
2944             {NM_SUB,   _(MSG_MEN_BYNAME),  NULL                  , CHECKIT|MENUTOGGLE                   , 8+16+32, (APTR) MEN_WINDOW_SORT_NAME},
2945             {NM_SUB,   _(MSG_MEN_BYDATE),  NULL                  , CHECKIT|MENUTOGGLE                   , 4+16+32, (APTR) MEN_WINDOW_SORT_DATE},
2946             {NM_SUB,   _(MSG_MEN_BYSIZE),  NULL                  , CHECKIT|MENUTOGGLE                   , 4+8+32, (APTR) MEN_WINDOW_SORT_SIZE},
2947                         {NM_SUB,   _(MSG_MEN_BYTYPE),  NULL                                      , CHECKIT|MENUTOGGLE                                   , 4+8+16, (APTR) MEN_WINDOW_SORT_TYPE},
2948             {NM_SUB, NM_BARLABEL},
2949             {NM_SUB,  _(MSG_MEN_REVERSE),  NULL                  , CHECKIT|MENUTOGGLE                   , 0, (APTR) MEN_WINDOW_SORT_REVERSE},
2950             {NM_SUB,  _(MSG_MEN_DRWFRST),  NULL                  , CHECKIT|MENUTOGGLE|CHECKED           , 0, (APTR) MEN_WINDOW_SORT_TOPDRAWERS},
2951             //{NM_SUB,  "Group Icons",           NULL, CHECKIT|MENUTOGGLE|CHECKED, 0, (APTR) MEN_WINDOW_SORT_GROUP},
2952             {NM_TITLE,    _(MSG_MEN_ICON), NULL, 0},
2953             {NM_ITEM,  _(MSG_MEN_OPEN), _(MSG_MEN_SC_OPEN), ITEMENABLED, 0, (APTR) MEN_ICON_OPEN},
2954             //{NM_ITEM,  "Close","C" },
2955             {NM_ITEM,  _(MSG_MEN_RENAME), _(MSG_MEN_SC_RENAME), ITEMENABLED, 0, (APTR) MEN_ICON_RENAME},
2956             {NM_ITEM,  _(MSG_MEN_INFO), _(MSG_MEN_SC_INFO), ITEMENABLED, 0, (APTR) MEN_ICON_INFORMATION},
2957                         {NM_ITEM,  _(MSG_SNAPSHOT),    "S", ITEMENABLED, 0, (APTR) MEN_ICON_SNAPSHOT},
2958                         {NM_ITEM,  _(MSG_UNSNAPSHOT),  "U", ITEMENABLED, 0, (APTR) MEN_ICON_UNSNAPSHOT},
2959                         {NM_ITEM,  _(MSG_LEAVE_OUT),   "L", ITEMENABLED, 0, (APTR) MEN_ICON_LEAVEOUT},
2960                         {NM_ITEM,  _(MSG_PUT_AWAY),    "P", ITEMENABLED, 0, (APTR) MEN_ICON_PUTAWAY},
2961             {NM_ITEM, NM_BARLABEL},
2962             {NM_ITEM,  _(MSG_MEN_DELETE),  NULL, ITEMENABLED, 0, (APTR) MEN_ICON_DELETE},
2963             {NM_ITEM,  _(MSG_MEN_FORMAT),  NULL, ITEMENABLED, 0, (APTR) MEN_ICON_FORMAT},
2964                         {NM_ITEM,  _(MSG_EMPTY_TRASH), NULL, ITEMENABLED},
2965             {NM_TITLE, _(MSG_MEN_TOOLS),   NULL, 0},
2966             //{NM_ITEM,  "ResetWanderer" },
2967             {NM_END}
2968         };
2969         _NewWandIntMenu__menustrip = MUI_MakeObject(MUIO_MenustripNM, nm, (IPTR) NULL);
2970     }
2971     else
2972     {
2973         struct NewMenu nm[] = {
2974         {NM_TITLE,     _(MSG_MEN_WANDERER)},
2975             {NM_ITEM,  _(MSG_MEN_BACKDROP),_(MSG_MEN_SC_BACKDROP), _NewWandIntMenu__OPTION_BACKDROP, 0, (APTR) MEN_WANDERER_BACKDROP},
2976             {NM_ITEM,  _(MSG_MEN_EXECUTE), _(MSG_MEN_SC_EXECUTE) , 0                         , 0, (APTR) MEN_WANDERER_EXECUTE},
2977
2978             {NM_ITEM,  _(MSG_MEN_SHELL),   _(MSG_MEN_SC_SHELL)   , 0                         , 0, (APTR) MEN_WANDERER_SHELL},
2979 #if defined(__AROS__)
2980             {NM_ITEM,  "AROS"},
2981             {NM_SUB,   _(MSG_MEN_ABOUT),   NULL                  , 0                         , 0, (APTR) MEN_WANDERER_AROS_ABOUT},
2982             {NM_SUB,   _(MSG_MEN_GUISET),  NULL                  , 0                         , 0, (APTR) MEN_WANDERER_AROS_GUISETTINGS},
2983 #endif
2984             {NM_ITEM,  _(MSG_MEN_QUIT) ,   _(MSG_MEN_SC_QUIT)    , 0                         , 0, (APTR) MEN_WANDERER_QUIT},
2985             {NM_ITEM,  _(MSG_MEN_SHUTDOWN), NULL                 , 0                         , 0, (APTR) MEN_WANDERER_SHUTDOWN},
2986
2987             {NM_TITLE,     _(MSG_MEN_WINDOW),  NULL, 0},
2988
2989             {NM_ITEM,  _(MSG_MEN_NEWDRAW), _(MSG_MEN_SC_NEWDRAW) , 0                         , 0, (APTR) MEN_WINDOW_NEW_DRAWER},
2990             {NM_ITEM,  _(MSG_MEN_OPENPAR),  NULL                 , 0                         , 0, (APTR) MEN_WINDOW_OPEN_PARENT},
2991             {NM_ITEM,  _(MSG_MEN_CLOSE),   _(MSG_MEN_SC_CLOSE)   , 0                         , 0, (APTR) MEN_WINDOW_CLOSE},
2992             {NM_ITEM,  _(MSG_MEN_UPDATE),  NULL                  , 0                         , 0, (APTR) MEN_WINDOW_UPDATE},
2993             {NM_ITEM, NM_BARLABEL},
2994             {NM_ITEM, _(MSG_MEN_CONTENTS), _(MSG_MEN_SC_CONTENTS), 0                         , 0, (APTR) MEN_WINDOW_SELECT},
2995             {NM_ITEM,  _(MSG_MEN_CLRSEL),  _(MSG_MEN_SC_CLRSEL)  , 0                         , 0, (APTR) MEN_WINDOW_CLEAR},
2996             {NM_ITEM, NM_BARLABEL},
2997             {NM_ITEM,  _(MSG_MEN_SNAPSHT) },
2998             {NM_SUB,   _(MSG_MEN_WINDOW),  NULL                  , 0                         , 0, (APTR) MEN_WINDOW_SNAP_WIN},
2999             {NM_SUB,   _(MSG_MEN_ALL),     NULL                  , 0                         , 0, (APTR) MEN_WINDOW_SNAP_ALL},
3000             {NM_ITEM, NM_BARLABEL},
3001             {NM_ITEM,  _(MSG_MEN_VIEW)},
3002             {NM_SUB,   _(MSG_MEN_ICVIEW),  NULL                  , CHECKIT|CHECKED      ,8+16+32, (APTR) MEN_WINDOW_VIEW_ICON},
3003             {NM_SUB,   _(MSG_MEN_DCVIEW),  NULL                  , CHECKIT              ,4+16+32, (APTR) MEN_WINDOW_VIEW_DETAIL},
3004             {NM_SUB, NM_BARLABEL},
3005             {NM_SUB,   _(MSG_MEN_ALLFIL),  NULL                  , _NewWandIntMenu__OPTION_SHOWALL, 0, (APTR) MEN_WINDOW_VIEW_ALL},
3006             {NM_ITEM,  _(MSG_MEN_SORTIC)},
3007             {NM_SUB,   _(MSG_MEN_CLNUP),   _(MSG_MEN_SC_CLNUP)   , 0                         , 0, (APTR) MEN_WINDOW_SORT_NOW},
3008             {NM_SUB, NM_BARLABEL},
3009             {NM_SUB,   _(MSG_MEN_BYNAME),  NULL                  , CHECKIT|MENUTOGGLE                   , 8+16+32, (APTR) MEN_WINDOW_SORT_NAME},
3010             {NM_SUB,   _(MSG_MEN_BYDATE),  NULL                  , CHECKIT|MENUTOGGLE                   , 4+16+32, (APTR) MEN_WINDOW_SORT_DATE},
3011             {NM_SUB,   _(MSG_MEN_BYSIZE),  NULL                  , CHECKIT|MENUTOGGLE                   , 4+8+32, (APTR) MEN_WINDOW_SORT_SIZE},
3012                         {NM_SUB,   _(MSG_MEN_BYTYPE),  NULL                                      , CHECKIT|MENUTOGGLE|ITEMENABLED           , 4+8+16, (APTR) MEN_WINDOW_SORT_TYPE},
3013             {NM_SUB, NM_BARLABEL},
3014             {NM_SUB,  _(MSG_MEN_REVERSE),  NULL                  , CHECKIT|MENUTOGGLE        , 0, (APTR) MEN_WINDOW_SORT_REVERSE},
3015             {NM_SUB,  _(MSG_MEN_DRWFRST),  NULL                  , CHECKIT|MENUTOGGLE|CHECKED, 0, (APTR) MEN_WINDOW_SORT_TOPDRAWERS},
3016             //{NM_SUB,  "Group Icons",           NULL, CHECKIT|MENUTOGGLE|CHECKED, 0, (APTR) MEN_WINDOW_SORT_GROUP},
3017             {NM_TITLE,    _(MSG_MEN_ICON), NULL, 0},
3018             {NM_ITEM,  _(MSG_MEN_OPEN), _(MSG_MEN_SC_OPEN), ITEMENABLED, 0, (APTR) MEN_ICON_OPEN},
3019             //    {NM_ITEM,  "Close","C" },
3020             {NM_ITEM,  _(MSG_MEN_RENAME), _(MSG_MEN_SC_RENAME), ITEMENABLED, 0, (APTR) MEN_ICON_RENAME},
3021             {NM_ITEM,  _(MSG_MEN_INFO), _(MSG_MEN_SC_INFO), ITEMENABLED, 0, (APTR) MEN_ICON_INFORMATION},
3022                         {NM_ITEM,  _(MSG_SNAPSHOT),   "S", ITEMENABLED, 0, (APTR) MEN_ICON_SNAPSHOT},
3023                         {NM_ITEM,  _(MSG_UNSNAPSHOT), "U", ITEMENABLED, 0, (APTR) MEN_ICON_UNSNAPSHOT},
3024                         {NM_ITEM,  _(MSG_LEAVE_OUT),  "L", ITEMENABLED, 0, (APTR) MEN_ICON_LEAVEOUT},
3025                         {NM_ITEM,  _(MSG_PUT_AWAY),   "P", ITEMENABLED, 0, (APTR) MEN_ICON_PUTAWAY},
3026             {NM_ITEM, NM_BARLABEL},
3027             {NM_ITEM,  _(MSG_MEN_DELETE), NULL, ITEMENABLED, 0, (APTR) MEN_ICON_DELETE},
3028                         {NM_ITEM,  _(MSG_MEN_FORMAT), NULL, ITEMENABLED},
3029                         {NM_ITEM,  _(MSG_EMPTY_TRASH),NULL, ITEMENABLED},
3030
3031         {NM_TITLE, _(MSG_MEN_TOOLS),      NULL, 0},
3032     //    {NM_ITEM,  "ResetWanderer" },
3033         {NM_END}
3034         };
3035         _NewWandIntMenu__menustrip = MUI_MakeObject(MUIO_MenustripNM, nm, (IPTR) NULL);
3036     }
3037     return _NewWandIntMenu__menustrip;
3038 }
3039 ///
3040
3041 ///Wanderer__MUIM_Wanderer_CreateDrawerWindow()
3042 Object *Wanderer__MUIM_Wanderer_CreateDrawerWindow
3043 (
3044     Class *CLASS, Object *self,
3045     struct MUIP_Wanderer_CreateDrawerWindow *message
3046 )
3047 {
3048     SETUP_WANDERER_INST_DATA;
3049
3050     Object *window                = NULL;
3051     BOOL    isWorkbenchWindow     = FALSE;
3052     BOOL    useBackdrop           = FALSE;
3053     BOOL    hasToolbar;
3054     IPTR    TAG_IconWindow_Drawer;
3055     IPTR    useFont;
3056     Object *_NewWandDrawerMenu__menustrip;
3057
3058         Object *window_IconList = NULL;
3059
3060 D(bug("[Wanderer] Wanderer__MUIM_Wanderer_CreateDrawerWindow()\n"));
3061
3062     if ((isWorkbenchWindow = (message->drawer == NULL ? TRUE : FALSE)))
3063     {
3064         useBackdrop = data->wd_Option_BackDropMode;
3065     }
3066
3067     hasToolbar            = XGET(data->wd_Prefs, MUIA_IconWindowExt_Toolbar_Enabled);
3068
3069     TAG_IconWindow_Drawer = isWorkbenchWindow ? TAG_IGNORE : MUIA_IconWindow_Location;
3070
3071     useFont = (IPTR)NULL;
3072
3073     data->wd_Screen = LockPubScreen(NULL);
3074
3075     if(data->wd_Screen == NULL)
3076     {
3077 D(bug("[Wanderer] Wanderer__MUIM_Wanderer_CreateDrawerWindow: Couldn't lock screen!\n"));
3078         CoerceMethod(CLASS, self, OM_DISPOSE);
3079         return NULL;
3080     }
3081 D(bug("[Wanderer] Wanderer__MUIM_Wanderer_CreateDrawerWindow: Using Screen @ %x\n", data->wd_Screen));
3082
3083     if (data->wd_PrefsIntern)
3084     {
3085         useFont = (IPTR)((struct WandererInternalPrefsData *)data->wd_PrefsIntern)->WIPD_IconFont;
3086     }
3087
3088     _NewWandDrawerMenu__menustrip = Wanderer__Func_CreateWandererIntuitionMenu (isWorkbenchWindow, useBackdrop);
3089
3090 //D(bug("1\n\n")); Delay(100);
3091     /* Create a new icon drawer window with the correct drawer being set */
3092
3093     #ifdef __AROS__
3094     window = IconWindowObject,
3095                 MUIA_UserData,                      1,
3096                 MUIA_Wanderer_Prefs,                  data->wd_Prefs,
3097                 MUIA_Wanderer_Screen,                 data->wd_Screen,
3098                 MUIA_Window_ScreenTitle,              GetUserScreenTitle(data->wd_Prefs),
3099                 MUIA_Window_Menustrip,                (IPTR) _NewWandDrawerMenu__menustrip,
3100                 TAG_IconWindow_Drawer,                (IPTR) message->drawer,
3101                 MUIA_IconWindow_Font,                 useFont,
3102                 MUIA_IconWindow_ActionHook,           (IPTR) &_WandererIntern_hook_action,
3103                 MUIA_IconWindow_IsRoot,               isWorkbenchWindow ? TRUE : FALSE,
3104                 isWorkbenchWindow ? MUIA_IconWindow_IsBackdrop : TAG_IGNORE, useBackdrop,
3105                 isWorkbenchWindow ? TAG_IGNORE : MUIA_Wanderer_FileSysNotifyPort, data->wd_NotifyPort,
3106                 MUIA_Window_IsSubWindow,              isWorkbenchWindow ? FALSE : TRUE,
3107                 MUIA_IconWindowExt_Toolbar_Enabled,   hasToolbar ? TRUE : FALSE,
3108              End;
3109     #else
3110      window = NewObject(IconWindow_CLASS->mcc_Class, NULL,
3111                 MUIA_UserData,                      1,
3112                 MUIA_Wanderer_Prefs,                  data->wd_Prefs,
3113                 MUIA_Wanderer_Screen,                 data->wd_Screen,
3114                 MUIA_Window_ScreenTitle,              GetUserScreenTitle(data->wd_Prefs),
3115                 MUIA_Window_Menustrip,                (IPTR) _NewWandDrawerMenu__menustrip,
3116                 TAG_IconWindow_Drawer,                (IPTR) message->drawer,
3117                 MUIA_IconWindow_Font,                 useFont,
3118                 MUIA_IconWindow_ActionHook,           (IPTR) &_WandererIntern_hook_action,
3119                 MUIA_IconWindow_IsRoot,               isWorkbenchWindow ? TRUE : FALSE,
3120                 isWorkbenchWindow ? MUIA_IconWindow_IsBackdrop : TAG_IGNORE, useBackdrop,
3121                 isWorkbenchWindow ? TAG_IGNORE : MUIA_Wanderer_FileSysNotifyPort, data->wd_NotifyPort,
3122                 MUIA_Window_IsSubWindow,              isWorkbenchWindow ? FALSE : TRUE,
3123                 MUIA_IconWindowExt_Toolbar_Enabled,   hasToolbar ? TRUE : FALSE,
3124              TAG_DONE);
3125     #endif
3126 //D(bug("2\n\n")); Delay(100);
3127     if (data->wd_Screen)
3128     {
3129 D(bug("[Wanderer] Wanderer__MUIM_Wanderer_CreateDrawerWindow: Unlocking access to screen @ %x\n", data->wd_Screen));
3130         UnlockPubScreen(NULL, data->wd_Screen);
3131     }
3132
3133     if (window != NULL)
3134     {
3135 D(bug("Wanderer__MUIM_Wanderer_CreateDrawerWindow: window != NULL\n"));
3136         /* Get the drawer path back so we can use it also outside this function */
3137         STRPTR drw = NULL;
3138         BOOL freeDrwStr = FALSE;
3139
3140         if (!isWorkbenchWindow) drw = (STRPTR) XGET(window, MUIA_IconWindow_Location);
3141         else
3142         {
3143 D(bug("Wanderer__MUIM_Wanderer_CreateDrawerWindow: call AllocVec()\n"));
3144             drw = AllocVec ( 5, MEMF_CLEAR );
3145             sprintf ( drw, "RAM:" );
3146             freeDrwStr = TRUE;
3147         }
3148
3149         if (isWorkbenchWindow)
3150         {
3151 D(bug("Wanderer__MUIM_Wanderer_CreateDrawerWindow: isWorkbenchWindow\n"));
3152             DoMethod
3153             (
3154                 window, MUIM_Notify, MUIA_Window_CloseRequest, TRUE,
3155                 (IPTR)self, 3, MUIM_CallHook, (IPTR)&_WandererIntern_hook_standard, (IPTR)wanderer_menufunc_wanderer_quit
3156             );
3157         }
3158         else
3159         {
3160             DoMethod
3161             (
3162                 window, MUIM_Notify, MUIA_Window_CloseRequest, TRUE,
3163                 (IPTR)_app(self), 4, MUIM_Application_PushMethod, (IPTR)window, 1, MUIM_IconWindow_Remove
3164             );
3165         }
3166
3167 D(bug("Wanderer__MUIM_Wanderer_CreateDrawerWindow: call get with MUIA_IconWindow_IconList\n"));
3168         GET(window, MUIA_IconWindow_IconList, &window_IconList);
3169
3170 D(bug("[Wanderer] Wanderer__MUIM_Wanderer_CreateDrawerWindow: IconWindows IconList @ %x\n", window_IconList));
3171
3172         if (window_IconList != NULL)
3173         {
3174                         struct Hook          *_wand_UpdateMenuStates_hook = NULL;
3175
3176                         if ((_wand_UpdateMenuStates_hook = AllocMem(sizeof(struct Hook), MEMF_CLEAR|MEMF_PUBLIC)) != NULL)
3177                         {
3178                                 _wand_UpdateMenuStates_hook->h_Entry = ( HOOKFUNC )Wanderer__HookFunc_UpdateMenuStatesFunc;
3179                                 DoMethod
3180                                 (
3181                                   window_IconList, MUIM_Notify, MUIA_IconList_SelectionChanged, MUIV_EveryTime,
3182                                   (IPTR) self, 3,
3183                                   MUIM_CallHook, _wand_UpdateMenuStates_hook, (IPTR)window
3184                                 );
3185                         }
3186                         Wanderer__Func_UpdateMenuStates(window, window_IconList);
3187         }
3188 D(bug("Wanderer__MUIM_Wanderer_CreateDrawerWindow: setup notifications\n"));
3189         DoMethod
3190         (
3191             window, MUIM_Notify, MUIA_Window_Activate, TRUE,
3192             (IPTR)_app(self), 3, MUIM_Set, MUIA_Wanderer_ActiveWindow, (IPTR) window
3193         );
3194
3195 #if 1
3196         DoMethod
3197         (
3198             window, MUIM_Notify, MUIA_IconWindow_IsBackdrop, MUIV_EveryTime,
3199             (IPTR)_app(self), 5, MUIM_Application_PushMethod, (IPTR)_app(self), 2, MUIM_CallHook, (IPTR)&_WandererIntern_hook_backdrop
3200         );
3201 #else
3202         DoMethod
3203         (
3204             window, MUIM_Notify, MUIA_IconWindow_IsBackdrop, MUIV_EveryTime,
3205             (IPTR)_app(self), 2, MUIM_CallHook, (IPTR) &_WandererIntern_hook_backdrop
3206         );
3207 #endif
3208 D(bug("Wanderer__MUIM_Wanderer_CreateDrawerWindow: execute all notifies\n"));
3209         /* If "Execute Command" entry is clicked open the execute window */
3210         DoAllMenuNotifies(_NewWandDrawerMenu__menustrip, drw);
3211
3212 D(bug("Wanderer__MUIM_Wanderer_CreateDrawerWindow: add window to app\n"));
3213         /* Add the window to the application */
3214         #ifdef __AROS__
3215         DoMethod(_app(self), OM_ADDMEMBER, (IPTR) window);
3216         #else
3217         DoMethod(self, OM_ADDMEMBER, (IPTR) window);
3218         #endif
3219 D(bug("Wanderer__MUIM_Wanderer_CreateDrawerWindow: open window\n"));
3220         /* And now open it */
3221         DoMethod(window, MUIM_IconWindow_Open);
3222 D(bug("Wanderer__MUIM_Wanderer_CreateDrawerWindow: clean up memory\n"));
3223         /* Clean up ram string */
3224         if ( freeDrwStr && drw ) FreeVec ( drw );
3225     }
3226 D(bug("Wanderer__MUIM_Wanderer_CreateDrawerWindow: exit\n"));
3227     return window;
3228 }
3229 ///
3230 /*** Setup ******************************************************************/
3231 ZUNE_CUSTOMCLASS_9
3232 (
3233     Wanderer, NULL, MUIC_Application, NULL,
3234     OM_NEW,                           struct opSet *,
3235     OM_DISPOSE,                       Msg,
3236     OM_SET,                           struct opSet *,
3237     OM_GET,                           struct opGet *,
3238     MUIM_Application_Execute,         Msg,
3239     MUIM_Wanderer_HandleTimer,        Msg,
3240     MUIM_Wanderer_HandleCommand,      Msg,
3241     MUIM_Wanderer_HandleNotify,       Msg,
3242     MUIM_Wanderer_CreateDrawerWindow, struct MUIP_Wanderer_CreateDrawerWindow *
3243 );