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