workbench/system/Wanderer/iconwindow.c

   1 /*
   2   Copyright © 2004-2012, The AROS Development Team. All rights reserved.
   3   $Id$
   4 */
   5
   6 #define DEBUG 0
   7 #define DOPENWINDOW(x) /* Window positioning and size */
   8
   9 #define ZCC_QUIET
  10
  11 #include "portable_macros.h"
  12 #ifdef __AROS__
  13 #define MUIMASTER_YES_INLINE_STDARG
  14 #endif
  15
  16 #define ICONWINDOW_NODETAILVIEWCLASS
  17 //#define ICONWINDOW_BUFFERLIST
  18
  19 #include <exec/types.h>
  20 #include <libraries/mui.h>
  21
  22 #include <proto/utility.h>
  23
  24 #include <proto/graphics.h>
  25
  26 #include <proto/exec.h>
  27 #include <proto/datatypes.h>
  28
  29 #include <dos/dos.h>
  30 #include <proto/dos.h>
  31
  32 #include <proto/icon.h>
  33
  34 #include <stdio.h>
  35 #include <string.h>
  36
  37 #include <intuition/screens.h>
  38 #include <datatypes/pictureclass.h>
  39 #include <clib/macros.h>
  40
  41 #ifdef __AROS__
  42 #include <aros/debug.h>
  43 #include <clib/alib_protos.h>
  44 #include <prefs/wanderer.h>
  45 #include <zune/customclasses.h>
  46 #else
  47 #include <prefs_AROS/wanderer.h>
  48 #include <zune_AROS/customclasses.h>
  49 #endif
  50
  51 #if defined(__AMIGA__) && !defined(__PPC__)
  52 #define NO_INLINE_STDARG
  53 #endif
  54 #include <proto/intuition.h>
  55 #include <proto/muimaster.h>
  56
  57 #include "Classes/iconlist.h"
  58 #include "Classes/iconlistview.h"
  59 #include "Classes/iconlist_attributes.h"
  60 #include "Classes/icon_attributes.h"
  61 #include "wanderer.h"
  62 #include "wandererprefs.h"
  63
  64 #include "iconwindow.h"
  65 #include "iconwindow_attributes.h"
  66 #include "iconwindow_iconlist.h"
  67 #include "iconwindowbackfill.h"
  68
  69 #include "version.h"
  70
  71 #ifndef __AROS__
  72
  73 #ifdef DEBUG
  74   #define D(x) if (DEBUG) x
  75   #ifdef __amigaos4__
  76   #define bug DebugPrintF
  77   #else
  78   #define bug kprintf
  79   #endif
  80 #else
  81   #define  D(...)
  82 #endif
  83 #endif
  84
  85 #if defined(ICONWINDOW_NODETAILVIEWCLASS)
  86 struct MUI_CustomClass *IconWindowDetailDrawerList_CLASS;
  87 #endif
  88
  89 #define WIWVERS       1
  90 #define WIWREV        0
  91
  92 #ifdef __AROS__
  93 #define DoSuperNew(cl, obj, ...) DoSuperNewTags(cl, obj, NULL, __VA_ARGS__)
  94 #else
  95 #define IconListviewObject NewObject(IconListview_Class->mcc_Class
  96 #endif
  97
  98 /*** Private Global Data *********************************************************/
  99
 100 static struct List                      iconwindow_BackFillNodes;
 101 struct List                             iconwindow_Extensions;
 102 struct IconWindow_BackFill_Descriptor  *iconwindow_BackFill_Active;
 103
 104 static char __intern_wintitle_wanderer[] = WANDERERNAME;
 105
 106 #define TT_WNDRRSRT     "WNDRRSRT"
 107 #define TT_COUNT        1
 108
 109 /*** Helper functions ***********************************************************/
 110 STATIC VOID IconWindow_RestoreSettings(struct DiskObject * dskobj, Object * iconwindowiconlist, BOOL forceshowall)
 111 {
 112     ULONG displayFlags = (ICONLIST_DISP_SHOWINFO | ICONLIST_DISP_MODEDEFAULT);
 113     BOOL displayFlagsRestored = FALSE;
 114
 115     if (dskobj->do_ToolTypes)
 116     {
 117         STRPTR hexFlags = FindToolType(dskobj->do_ToolTypes, TT_WNDRRSRT);
 118         if (hexFlags != NULL)
 119         {
 120             ULONG sortFlags = strtol(hexFlags, NULL, 16);
 121             SET(iconwindowiconlist, MUIA_IconWindowIconList_RestoredSortFlags, (ULONG)sortFlags);
 122         }
 123     }
 124
 125     if (dskobj->do_Gadget.UserData)
 126     {
 127         /*
 128          * Note: it is actually possible when reading icons not snapshoted by Wanderer to end up in situation where
 129          * only one of the dd_Flafs/dd_ViewModes has supported values. In that case however still the complete
 130          * displayFlags are marked as restored. That is why the displayFlags have default value, so not to end
 131          * up with invalid window settings.
 132          */
 133         D(bug("[Wanderer:IconWindow] %s: Drawer Icon has OS 2.x/3.x data: FLAGS %x\n", __PRETTY_FUNCTION__, dskobj->do_DrawerData->dd_Flags));
 134
 135         if (dskobj->do_DrawerData->dd_Flags == DDFLAGS_SHOWICONS)
 136         {
 137             displayFlags |= ICONLIST_DISP_SHOWINFO;
 138             displayFlagsRestored = TRUE;
 139         }
 140         if (dskobj->do_DrawerData->dd_Flags == DDFLAGS_SHOWALL)
 141         {
 142             displayFlags &= ~ICONLIST_DISP_SHOWINFO;
 143             displayFlagsRestored = TRUE;
 144         }
 145         if (dskobj->do_DrawerData->dd_ViewModes == DDVM_BYICON)
 146         {
 147             displayFlags &= ~ICONLIST_DISP_MODE_MASK;
 148             displayFlags |= ICONLIST_DISP_MODEDEFAULT;
 149             displayFlagsRestored = TRUE;
 150         }
 151         if (dskobj->do_DrawerData->dd_ViewModes == DDVM_BYNAME)
 152         {
 153             displayFlags &= ~ICONLIST_DISP_MODE_MASK;
 154             displayFlags |= ICONLIST_DISP_MODELIST;
 155             displayFlagsRestored = TRUE;
 156         }
 157     }
 158
 159     if (forceshowall)
 160     {
 161         displayFlags &= ~ICONLIST_DISP_SHOWINFO;
 162         displayFlagsRestored = TRUE;
 163     }
 164
 165     if (displayFlagsRestored)
 166         SET(iconwindowiconlist, MUIA_IconWindowIconList_RestoredDisplayFlags, displayFlags);
 167 }
 168
 169 STATIC VOID IconWindow_StoreSettings(Object * iconwindow)
 170 {
 171     Object              *iconList = (Object *) XGET(iconwindow, MUIA_IconWindow_IconList);
 172     STRPTR              dir_name = (char *)XGET(iconwindow, MUIA_IconWindow_Location);
 173     struct DiskObject   *drawericon = NULL;
 174     IPTR                geticon_error = 0;
 175     IPTR                display_bits = 0, sort_bits = 0;
 176
 177     drawericon = GetIconTags(dir_name,
 178                             ICONGETA_FailIfUnavailable, FALSE,
 179                             ICONA_ErrorCode, &geticon_error,
 180                             TAG_DONE);
 181
 182     if (drawericon != NULL)
 183     {
 184         if (drawericon->do_DrawerData == NULL)
 185         {
 186             D(bug("[Wanderer:IconWindow] %s: Icon for '%s' has no DRAWER data!\n", __PRETTY_FUNCTION__, dir_name));
 187             drawericon->do_DrawerData = AllocMem(sizeof(struct DrawerData), MEMF_CLEAR|MEMF_PUBLIC);
 188         }
 189
 190         drawericon->do_Gadget.UserData = (APTR)1;
 191
 192         drawericon->do_DrawerData->dd_NewWindow.TopEdge = XGET(iconwindow, MUIA_Window_TopEdge);
 193         drawericon->do_DrawerData->dd_NewWindow.LeftEdge = XGET(iconwindow, MUIA_Window_LeftEdge);
 194         drawericon->do_DrawerData->dd_NewWindow.Width = XGET(iconwindow, MUIA_Window_Width);
 195         drawericon->do_DrawerData->dd_NewWindow.Height = XGET(iconwindow, MUIA_Window_Height);
 196
 197         GET(iconList, MUIA_IconList_DisplayFlags, &display_bits);
 198         if (display_bits & ICONLIST_DISP_SHOWINFO)
 199         {
 200             D(bug("[Wanderer:IconWindow] %s: ICONLIST_DISP_SHOWINFO\n", __PRETTY_FUNCTION__));
 201             drawericon->do_DrawerData->dd_Flags = DDFLAGS_SHOWICONS;
 202         }
 203         else
 204         {
 205             drawericon->do_DrawerData->dd_Flags = DDFLAGS_SHOWALL;
 206         }
 207
 208         if (display_bits & ICONLIST_DISP_MODEDEFAULT)
 209         {
 210             drawericon->do_DrawerData->dd_ViewModes = DDVM_BYICON;
 211         }
 212         if (display_bits & ICONLIST_DISP_MODELIST)
 213         {
 214             /*
 215              * ByName mode is used to encode list-view display mode. Note that actual sorting
 216              * is stored in tool type, so the list-view window stores as DDVM_BYNAME does not
 217              * have to be sorted by name.
 218              */
 219             drawericon->do_DrawerData->dd_ViewModes = DDVM_BYNAME;
 220         }
 221
 222         /* Save settings into Tool Types */
 223         {
 224             LONG i = 0, inew = 0, tocopy = 0;
 225             TEXT buffer[128] = {0};
 226             UBYTE ** oldtooltypes = drawericon->do_ToolTypes;
 227             UBYTE ** newtooltypes = NULL;
 228
 229             /* Find how many need to be copied */
 230             if (oldtooltypes != NULL)
 231             {
 232                 for (i = 0; oldtooltypes[i]; i++)
 233                 {
 234                     if (Strnicmp(oldtooltypes[i], TT_WNDRRSRT, strlen(TT_WNDRRSRT)) == 0)
 235                         continue;
 236                     tocopy++;
 237                 }
 238             }
 239
 240             /* Create new pointer array */
 241             newtooltypes = AllocVec(sizeof(STRPTR) * (tocopy + TT_COUNT + 1), MEMF_CLEAR);
 242
 243             /* Copy, inew will have last index value */
 244             if (oldtooltypes != NULL)
 245             {
 246                 for (i = 0, inew = 0; oldtooltypes[i]; i++)
 247                 {
 248                     if (Strnicmp(oldtooltypes[i], TT_WNDRRSRT, strlen(TT_WNDRRSRT)) == 0)
 249                         continue;
 250                     newtooltypes[inew++] = StrDup(oldtooltypes[i]);
 251                 }
 252             }
 253
 254             /* Add TT_WNDRRSRT value */
 255             GET(iconList, MUIA_IconList_SortFlags, &sort_bits);
 256             __sprintf(buffer, TT_WNDRRSRT"=0x%lx", sort_bits);
 257             newtooltypes[inew++] = StrDup(buffer);
 258
 259             drawericon->do_ToolTypes = newtooltypes;
 260
 261             PutDiskObject(dir_name, drawericon);
 262
 263             drawericon->do_ToolTypes = oldtooltypes;
 264
 265             /* Free memory */
 266             for (i = 0; i < inew; i++)
 267                 FreeVec(newtooltypes[i]);
 268             FreeVec(newtooltypes);
 269         }
 270     }
 271 }
 272
 273
 274 /*** Hook functions *********************************************************/
 275
 276 ///IconWindow__HookFunc_PrefsUpdatedFunc()
 277 #ifdef __AROS__
 278 AROS_UFH3(
 279     void, IconWindow__HookFunc_PrefsUpdatedFunc,
 280     AROS_UFHA(struct Hook *,    hook,   A0),
 281     AROS_UFHA(APTR *,           obj,    A2),
 282     AROS_UFHA(APTR,             param,  A1)
 283 )
 284 {
 285 #else
 286 HOOKPROTO(IconWindow__HookFunc_PrefsUpdatedFunc, void, APTR *obj, APTR param)
 287 {
 288 #endif
 289     AROS_USERFUNC_INIT
 290
 291     /* Get our private data */
 292     Object *self = ( Object *)obj;
 293     Class *CLASS = *( Class **)param;
 294     IPTR changed_state;
 295
 296     SETUP_ICONWINDOW_INST_DATA;
 297
 298     D(bug("[Wanderer:IconWindow]: %s()\n", __PRETTY_FUNCTION__));
 299
 300     changed_state = 0;
 301     GET(self, MUIA_IconWindow_Changed, &changed_state);
 302
 303     if ((changed_state) && (data->iwd_IconListObj))
 304     {
 305         D(bug("[Wanderer:IconWindow] %s: Window contents have changed .. updating display ..\n", __PRETTY_FUNCTION__));
 306         DoMethod(data->iwd_IconListObj, MUIM_IconList_Update);
 307         DoMethod(data->iwd_IconListObj, MUIM_IconList_Sort);
 308         SET(self, MUIA_IconWindow_Changed, FALSE);
 309     }
 310
 311     AROS_USERFUNC_EXIT
 312 }
 313 #ifndef __AROS__
 314 MakeStaticHook(iwd_PrefsUpdated_hook,IconWindow__HookFunc_PrefsUpdatedFunc);
 315 #endif
 316 ///
 317
 318 ///IconWindow__HookFunc_ProcessBackgroundFunc()
 319 #ifdef __AROS__
 320 AROS_UFH3(
 321     void, IconWindow__HookFunc_ProcessBackgroundFunc,
 322     AROS_UFHA(struct Hook *,    hook,   A0),
 323     AROS_UFHA(APTR *,           obj,    A2),
 324     AROS_UFHA(APTR,             param,  A1)
 325 )
 326 {
 327 #else
 328 HOOKPROTO(IconWindow__HookFunc_ProcessBackgroundFunc, void, APTR *obj, APTR param)
 329 {
 330 #endif
 331     AROS_USERFUNC_INIT
 332
 333     /* Get our private data */
 334     Object      *self = ( Object *)obj,
 335                 *prefs = NULL;
 336     Class *CLASS = *( Class **)param;
 337
 338     SETUP_ICONWINDOW_INST_DATA;
 339
 340     D(bug("[Wanderer:IconWindow]: %s()\n", __PRETTY_FUNCTION__));
 341
 342     DoMethod(self, MUIM_IconWindow_BackFill_ProcessBackground, data->iwd_BackFillInfo, data->iwd_RootViewObj);
 343
 344     GET(_app(self), MUIA_Wanderer_Prefs, &prefs);
 345
 346     if (prefs)
 347     {
 348         //BOOL    options_changed = FALSE;
 349         IPTR  prefs_Processing = 0;
 350
 351         GET(prefs, MUIA_WandererPrefs_Processing, &prefs_Processing);
 352         if (!prefs_Processing)
 353         {
 354             /* TODO: We arent in prefs-processing so cause an update! */
 355         }
 356     }
 357
 358     AROS_USERFUNC_EXIT
 359 }
 360 #ifndef __AROS__
 361 MakeStaticHook(iwd_ProcessBackground_hook,IconWindow__HookFunc_ProcessBackgroundFunc);
 362 #endif
 363 ///
 364
 365 ///IconWindow__HookFunc_WandererBackFillFunc()
 366 #ifdef __AROS__
 367 AROS_UFH3(
 368     void, IconWindow__HookFunc_WandererBackFillFunc,
 369     AROS_UFHA(struct Hook *,        hook,   A0),
 370     AROS_UFHA(struct RastPort *,    RP,    A2),
 371     AROS_UFHA(struct BackFillMsg *, BFM,  A1)
 372 )
 373 {
 374 #else
 375 HOOKPROTO(IconWindow__HookFunc_WandererBackFillFunc, void, struct RastPort *RP, struct BackFillMsg *BFM)
 376 {
 377 #endif
 378     AROS_USERFUNC_INIT
 379
 380     struct IconWindow_BackFillHookData *HookData = NULL;
 381
 382 D(bug("[Wanderer:IconWindow]: %s()\n", __PRETTY_FUNCTION__));
 383
 384     if ((HookData = hook->h_Data) && (iconwindow_BackFill_Active != NULL))
 385     {
 386         Class                              *CLASS = HookData->bfhd_IWClass;
 387         Object                 *self = HookData->bfhd_IWObject;
 388
 389         SETUP_ICONWINDOW_INST_DATA;
 390
 391         struct RastPort           *DrawBackGround_RastPort = NULL;
 392         struct IconWindowBackFillMsg  DrawBackGround_BackFillMsg;
 393
 394         GET(data->iwd_IconListObj, MUIA_IconList_BufferRastport, &DrawBackGround_RastPort);
 395
 396         if (DrawBackGround_RastPort != NULL)
 397         {
 398             if ((DrawBackGround_BackFillMsg.Layer = DrawBackGround_RastPort->Layer) == NULL)
 399             {
 400   D(bug("[Wanderer:IconWindow] %s: Rastport Layer = NULL!\n", __PRETTY_FUNCTION__));
 401             }
 402
 403             GET(data->iwd_IconListObj,MUIA_IconList_BufferLeft, &DrawBackGround_BackFillMsg.AreaBounds.MinX);
 404             GET(data->iwd_IconListObj,MUIA_IconList_BufferTop, &DrawBackGround_BackFillMsg.AreaBounds.MinY);
 405             GET(data->iwd_IconListObj,MUIA_IconList_BufferWidth, &DrawBackGround_BackFillMsg.AreaBounds.MaxX);
 406             GET(data->iwd_IconListObj,MUIA_IconList_BufferHeight, &DrawBackGround_BackFillMsg.AreaBounds.MaxY);
 407
 408             DrawBackGround_BackFillMsg.AreaBounds.MaxX += DrawBackGround_BackFillMsg.AreaBounds.MinX - 1;
 409             DrawBackGround_BackFillMsg.AreaBounds.MaxY += DrawBackGround_BackFillMsg.AreaBounds.MinY - 1;
 410
 411             DrawBackGround_BackFillMsg.DrawBounds.MinX = BFM->Bounds.MinX;
 412             DrawBackGround_BackFillMsg.DrawBounds.MinY = BFM->Bounds.MinY;
 413             DrawBackGround_BackFillMsg.DrawBounds.MaxX = BFM->Bounds.MaxX;
 414             DrawBackGround_BackFillMsg.DrawBounds.MaxY = BFM->Bounds.MaxY;
 415
 416             /* Offset into source image (ala scroll bar position) */
 417             DrawBackGround_BackFillMsg.OffsetX = BFM->OffsetX;
 418             DrawBackGround_BackFillMsg.OffsetY = BFM->OffsetY;
 419             DoMethod(self, MUIM_IconWindow_BackFill_DrawBackground, data->iwd_BackFillInfo, &DrawBackGround_BackFillMsg, DrawBackGround_RastPort);
 420         }
 421
 422     }
 423
 424     AROS_USERFUNC_EXIT
 425 }
 426 #ifndef __AROS__
 427 MakeStaticHook(Hook_WandererBackFillFunc,IconWindow__HookFunc_WandererBackFillFunc);
 428 #endif
 429 ///
 430
 431 ///OM_NEW()
 432 Object *IconWindow__OM_NEW(Class *CLASS, Object *self, struct opSet *message)
 433 {
 434     struct iconWindow_Extension *iw_Extension = NULL;
 435
 436     struct Screen               *_newIconWin__Screen = NULL;
 437     Object                      *_newIconWin__IconListObj = NULL,
 438                                 *_newIconWin__RootViewObj = NULL,
 439
 440                                 *_newIconWin__TopPanelContainerObj = NULL,
 441                                 *_newIconWin__TopPanelRootGroupObj = NULL,
 442                                 *_newIconWin__TopPanelSpacerObj = NULL,
 443
 444                                 *_newIconWin__LeftPanelContainerObj = NULL,
 445                                 *_newIconWin__LeftPanelRootGroupObj = NULL,
 446                                 *_newIconWin__LeftPanelSpacerObj = NULL,
 447
 448                                 *_newIconWin__BottomPanelContainerObj = NULL,
 449                                 *_newIconWin__BottomPanelRootGroupObj = NULL,
 450                                 *_newIconWin__BottomPanelSpacerObj = NULL,
 451
 452                                 *prefs = NULL;
 453
 454     char                        *_newIconWin__Title = NULL;
 455
 456     UBYTE                       _newIconWin__VOLVIEWMODE = MUIV_IconWindow_VolumeInfoMode_ShowAllIfNoInfo;
 457
 458     BOOL                        isRoot = FALSE,
 459                                 isBackdrop = FALSE;
 460
 461     struct Hook                 *actionHook = NULL;
 462
 463     struct Hook                 *_newIconWin__BackFillHook = NULL;
 464
 465     IPTR                        WindowBF_TAG = (IPTR)TAG_IGNORE;
 466
 467     IPTR                        _newIconWin__WindowWidth = 0;
 468     IPTR                        _newIconWin__WindowHeight = 0;
 469     IPTR                        _newIconWin__WindowLeft = 0;
 470     IPTR                        _newIconWin__WindowTop = 0;
 471
 472     IPTR                        _newIconWin__FSNotifyPort = (IPTR)NULL;
 473     struct MUI_CustomClass      *iconviewclass = NULL;
 474 #if defined(ICONWINDOW_NODETAILVIEWCLASS)
 475     IconWindowDetailDrawerList_CLASS = IconWindowDrawerList_CLASS;
 476 #endif
 477
 478 D(bug("[Wanderer:IconWindow]: %s()\n", __PRETTY_FUNCTION__));
 479
 480     /* More than one GetTagData is not very efficient, however since this isn't called very often... */
 481     isBackdrop = (BOOL)GetTagData(MUIA_IconWindow_IsBackdrop, (IPTR)FALSE, message->ops_AttrList);
 482
 483     isRoot = (BOOL)GetTagData(MUIA_IconWindow_IsRoot, (IPTR)FALSE, message->ops_AttrList);
 484
 485     actionHook = (struct Hook *)GetTagData(MUIA_IconWindow_ActionHook, (IPTR) NULL, message->ops_AttrList);
 486     prefs = (Object *)GetTagData(MUIA_Wanderer_Prefs, (IPTR) NULL, message->ops_AttrList);
 487
 488     _newIconWin__FSNotifyPort = (IPTR)GetTagData(MUIA_Wanderer_FileSysNotifyPort, (IPTR) NULL, message->ops_AttrList);
 489
 490     /* Request the screen we should use .. */
 491     if (!(_newIconWin__Screen = (struct Screen *)GetTagData(MUIA_Wanderer_Screen, (IPTR) NULL, message->ops_AttrList)))
 492     {
 493             D(bug("[Wanderer:IconWindow] %s: NO SCREEN SET!\n", __PRETTY_FUNCTION__));
 494             return NULL;
 495     }
 496 D(bug("[Wanderer:IconWindow] %s: Screen @ 0x%p\n", __PRETTY_FUNCTION__, _newIconWin__Screen));
 497
 498     if ((_newIconWin__BackFillHook = AllocVec(sizeof(struct Hook), MEMF_CLEAR|MEMF_PUBLIC))!=NULL)
 499     {
 500 D(bug("[Wanderer:IconWindow] %s: Allocated WindowBackFillHook @ 0x%p\n", __PRETTY_FUNCTION__, _newIconWin__BackFillHook));
 501
 502 #ifdef __AROS__
 503             _newIconWin__BackFillHook->h_Entry = ( HOOKFUNC )IconWindow__HookFunc_WandererBackFillFunc;
 504 #else
 505             _newIconWin__BackFillHook = &Hook_WandererBackFillFunc;
 506 #endif
 507
 508 //#if defined(__MORPHOS__)
 509 //        WindowBF_TAG = MUIA_Window_BackFillHook;
 510 //#else
 511         WindowBF_TAG = WA_BackFill;
 512 //#endif
 513     }
 514
 515     if (isRoot)
 516     {
 517         iconviewclass = IconWindowVolumeList_CLASS;
 518         _newIconWin__IconListObj = (Object *)NewObject(iconviewclass->mcc_Class, NULL,
 519                                                     MUIA_Wanderer_FileSysNotifyPort, _newIconWin__FSNotifyPort,
 520                                                     TAG_DONE);
 521
 522         /*
 523          * Use MUI built-in support to keep window aligned to size of screen
 524          * Remember: sizes of screen can change without window being recreated
 525          */
 526         _newIconWin__WindowWidth = MUIV_Window_Width_Screen(100);
 527         _newIconWin__WindowHeight = MUIV_Window_Height_Screen(100);
 528         _newIconWin__WindowTop = MUIV_Window_TopEdge_Delta(0);
 529         _newIconWin__WindowLeft = 0;
 530
 531         DOPENWINDOW(bug("[Wanderer:IconWindow] %s: Screen dimensions ..  %ld x %ld\n", __PRETTY_FUNCTION__, _newIconWin__WindowWidth, _newIconWin__WindowHeight));
 532
 533         if (isBackdrop)
 534         {
 535             DOPENWINDOW(bug("[Wanderer:IconWindow] %s: BACKDROP ROOT Window\n", __PRETTY_FUNCTION__));
 536             _newIconWin__Title = NULL;
 537         }
 538         else
 539         {
 540             DOPENWINDOW(bug("[Wanderer:IconWindow] %s: Plain ROOT Window\n", __PRETTY_FUNCTION__));
 541             _newIconWin__Title = __intern_wintitle_wanderer;
 542         }
 543     }
 544     else
 545     {
 546         struct DiskObject   *drawericon = NULL;
 547         IPTR                geticon_error = 0, geticon_isdefault = 0;
 548         IPTR                _newIconWin__TitleLen = 0;
 549         BOOL                forceshowall = FALSE;
 550         BOOL                isVolume;
 551
 552         _newIconWin__WindowTop = MUIV_Window_TopEdge_Centered;
 553         _newIconWin__WindowLeft = MUIV_Window_LeftEdge_Centered;
 554         _newIconWin__WindowWidth = 300;
 555         _newIconWin__WindowHeight = 300;
 556
 557         _newIconWin__Title = (STRPTR) GetTagData(MUIA_IconWindow_Location, (IPTR)NULL, message->ops_AttrList);
 558         _newIconWin__TitleLen = strlen(_newIconWin__Title);
 559         isVolume = (_newIconWin__Title[_newIconWin__TitleLen - 1] == ':');
 560
 561         D(bug("[Wanderer:IconWindow] %s: Opening %s Window '%s'\n", __PRETTY_FUNCTION__, isVolume ? "Volume Root" : "Drawer", _newIconWin__Title));
 562
 563         drawericon = GetIconTags(_newIconWin__Title,
 564                                 ICONGETA_Screen, _newIconWin__Screen,
 565                                 ICONGETA_FailIfUnavailable, FALSE,
 566                                 ICONGETA_IsDefaultIcon, &geticon_isdefault,
 567                                 ICONA_ErrorCode, &geticon_error,
 568                                 TAG_DONE);
 569
 570         if ((drawericon) && (drawericon->do_DrawerData))
 571         {
 572 D(bug("[Wanderer:IconWindow] %s: Directory Icon has DRAWER data!\n", __PRETTY_FUNCTION__));
 573             _newIconWin__WindowTop = drawericon->do_DrawerData->dd_NewWindow.TopEdge;
 574             _newIconWin__WindowLeft = drawericon->do_DrawerData->dd_NewWindow.LeftEdge;
 575             _newIconWin__WindowWidth = drawericon->do_DrawerData->dd_NewWindow.Width;
 576             _newIconWin__WindowHeight = drawericon->do_DrawerData->dd_NewWindow.Height;
 577         }
 578
 579         iconviewclass = IconWindowDrawerList_CLASS;
 580         if ((drawericon) && (drawericon->do_Gadget.UserData > 0))
 581         {
 582 D(bug("[Wanderer:IconWindow] %s: Directory Icons has OS 2.x/3.x data: FLAGS %x [\n", __PRETTY_FUNCTION__, drawericon->do_DrawerData->dd_Flags));
 583 D(bug("] VIEWMODES %x [", drawericon->do_DrawerData->dd_ViewModes));
 584
 585             switch (drawericon->do_DrawerData->dd_ViewModes)
 586             {
 587                 case 0:
 588                 {
 589                     D(bug("Default (inherit from parent)"));
 590                     break;
 591                 }
 592                 case 1:
 593                 {
 594                     D(bug("View as icons"));
 595                     break;
 596                 }
 597                 case 2:
 598                 {
 599                     D(bug("View as text, sorted by name"));
 600                     iconviewclass = IconWindowDetailDrawerList_CLASS;
 601                     break;
 602                 }
 603                 case 3:
 604                 {
 605                     D(bug("View as text, sorted by date"));
 606                     iconviewclass = IconWindowDetailDrawerList_CLASS;
 607                     break;
 608                 }
 609                 case 4:
 610                 {
 611                     D(bug("View as text, sorted by size"));
 612                     iconviewclass = IconWindowDetailDrawerList_CLASS;
 613                     break;
 614                 }
 615                 case 5:
 616                 {
 617                     D(bug("View as text, sorted by type"));
 618                     iconviewclass = IconWindowDetailDrawerList_CLASS;
 619                     break;
 620                 }
 621                 default:
 622                 {
 623                     D(bug("INVALID"));
 624                 }
 625             }
 626 D(bug("]\n"));
 627         }
 628
 629         if (isVolume &&
 630                 (((geticon_isdefault) && (_newIconWin__VOLVIEWMODE == MUIV_IconWindow_VolumeInfoMode_ShowAllIfNoInfo)) ||
 631                 (_newIconWin__VOLVIEWMODE == MUIV_IconWindow_VolumeInfoMode_ShowAll)))
 632         {
 633             D(bug("[Wanderer:IconWindow] %s: setting 'SHOW ALL FILES'\n", __PRETTY_FUNCTION__));
 634             forceshowall = TRUE;
 635         }
 636
 637         _newIconWin__IconListObj = (Object *) NewObject(iconviewclass->mcc_Class, NULL,
 638                                                                  MUIA_IconDrawerList_Drawer, (IPTR) _newIconWin__Title,
 639                                                                  MUIA_Wanderer_FileSysNotifyPort, _newIconWin__FSNotifyPort,
 640                                                                 TAG_DONE);
 641
 642         if (drawericon)
 643             IconWindow_RestoreSettings(drawericon, _newIconWin__IconListObj, forceshowall);
 644
 645         _newIconWin__TopPanelRootGroupObj = MUI_NewObject(MUIC_Group,
 646                 MUIA_InnerLeft,(0),
 647                 MUIA_InnerRight,(0),
 648                 MUIA_InnerTop,(0),
 649                 MUIA_InnerBottom,(0),
 650                 MUIA_Frame, MUIV_Frame_None,
 651                 MUIA_Group_Spacing, 0,
 652                 Child, (_newIconWin__TopPanelSpacerObj = HSpace(0)),
 653         TAG_DONE);
 654
 655         if (_newIconWin__TopPanelRootGroupObj)
 656         {
 657           _newIconWin__TopPanelContainerObj = MUI_NewObject(MUIC_Group, MUIA_Group_Horiz, TRUE,
 658                 MUIA_ShowMe,            FALSE,
 659                 InnerSpacing(0,0),
 660                 MUIA_HorizWeight,       100,
 661                 MUIA_VertWeight,        0,
 662                 MUIA_Frame,             MUIV_Frame_None,
 663                 MUIA_Group_Spacing,     3,
 664                 Child, (IPTR)_newIconWin__TopPanelRootGroupObj,
 665           TAG_DONE);
 666         }
 667
 668         _newIconWin__BottomPanelRootGroupObj = MUI_NewObject(MUIC_Group,
 669                 MUIA_InnerLeft,(0),
 670                 MUIA_InnerRight,(0),
 671                 MUIA_InnerTop,(0),
 672                 MUIA_InnerBottom,(0),
 673                 MUIA_Frame, MUIV_Frame_None,
 674                 MUIA_Group_Spacing, 0,
 675                 Child, (_newIconWin__BottomPanelSpacerObj = HSpace(0)),
 676         TAG_DONE);
 677
 678         if (_newIconWin__BottomPanelRootGroupObj)
 679         {
 680           _newIconWin__BottomPanelContainerObj = MUI_NewObject(MUIC_Group, MUIA_Group_Horiz, TRUE,
 681                 MUIA_ShowMe,            FALSE,
 682                 InnerSpacing(0,0),
 683                 MUIA_HorizWeight,       100,
 684                 MUIA_VertWeight,        0,
 685                 MUIA_Frame,             MUIV_Frame_None,
 686                 MUIA_Group_Spacing,     3,
 687                 Child, (IPTR)_newIconWin__BottomPanelRootGroupObj,
 688           TAG_DONE);
 689         }
 690
 691         _newIconWin__LeftPanelRootGroupObj = MUI_NewObject(MUIC_Group,
 692                 MUIA_InnerLeft,(0),
 693                 MUIA_InnerRight,(0),
 694                 MUIA_InnerTop,(0),
 695                 MUIA_InnerBottom,(0),
 696                 MUIA_Frame, MUIV_Frame_None,
 697                 MUIA_Group_Spacing, 0,
 698                 Child, (_newIconWin__LeftPanelSpacerObj = HVSpace),
 699         TAG_DONE);
 700
 701         if (_newIconWin__LeftPanelRootGroupObj)
 702         {
 703           _newIconWin__LeftPanelContainerObj = MUI_NewObject(MUIC_Group, MUIA_Group_Horiz, TRUE,
 704                 MUIA_ShowMe,            FALSE,
 705                 InnerSpacing(0,0),
 706                 MUIA_HorizWeight,       0,
 707                 MUIA_VertWeight,        100,
 708                 MUIA_Frame,             MUIV_Frame_None,
 709                 MUIA_Group_Spacing,     3,
 710                 Child, (IPTR)_newIconWin__LeftPanelRootGroupObj,
 711           TAG_DONE);
 712         }
 713     }
 714
 715     _newIconWin__RootViewObj = (Object *) IconListviewObject,
 716                                             MUIA_Weight,                    100,
 717                                             MUIA_IconListview_UseWinBorder, TRUE,
 718                                             MUIA_IconListview_IconList,     (IPTR) _newIconWin__IconListObj,
 719                                         End;
 720
 721     DOPENWINDOW(bug("[Wanderer:IconWindow] %s: Window Co-ords %d,%d [%d x %d]\n", __PRETTY_FUNCTION__, _newIconWin__WindowLeft, _newIconWin__WindowTop, _newIconWin__WindowWidth, _newIconWin__WindowHeight));
 722     D(bug("[Wanderer:IconWindow] %s: Font @ 0x%p\n", __PRETTY_FUNCTION__, _newIconWin__WindowFont));
 723     D(bug("[Wanderer:IconWindow] %s: TopPanelContainerObj 0x%p RootViewObj 0x%p\n", __PRETTY_FUNCTION__, _newIconWin__TopPanelContainerObj, _newIconWin__RootViewObj));
 724
 725     self = (Object *) DoSuperNew(CLASS, self,
 726         MUIA_Window_Screen,                                    _newIconWin__Screen,
 727         MUIA_Window_Backdrop,                                  isBackdrop ? TRUE : FALSE,
 728         MUIA_Window_Borderless,                                isBackdrop ? TRUE : FALSE,
 729         MUIA_Window_Width,                                     _newIconWin__WindowWidth,
 730         MUIA_Window_Height,                                    _newIconWin__WindowHeight,
 731         MUIA_Window_LeftEdge,                                  _newIconWin__WindowLeft,
 732         MUIA_Window_TopEdge,                                   _newIconWin__WindowTop,
 733         (!isBackdrop) ? MUIA_Window_AltWidth : TAG_IGNORE,     100,
 734         (!isBackdrop) ? MUIA_Window_AltHeight : TAG_IGNORE,    80,
 735         MUIA_Window_Title,                                   (IPTR)_newIconWin__Title,
 736
 737         MUIA_Window_DragBar,                                   (!isBackdrop) ? TRUE : FALSE,
 738         MUIA_Window_CloseGadget,                               (!isBackdrop) ? TRUE : FALSE,
 739         MUIA_Window_SizeGadget,                                (!isBackdrop) ? TRUE : FALSE,
 740         MUIA_Window_DepthGadget,                               (!isBackdrop) ? TRUE : FALSE,
 741 #if defined(MUIA_Window_ZoomGadget)
 742         MUIA_Window_ZoomGadget,                                (!isBackdrop) ? TRUE : FALSE,
 743 #endif
 744         MUIA_Window_UseBottomBorderScroller,                   (!isBackdrop) ? TRUE : FALSE,
 745         MUIA_Window_UseRightBorderScroller,                    (!isBackdrop) ? TRUE : FALSE,
 746         MUIA_Window_IsSubWindow,                             TRUE,
 747
 748         WindowBF_TAG,                                        _newIconWin__BackFillHook,
 749
 750         MUIA_Window_ScreenTitle,                             (IPTR) "",
 751
 752         WindowContents, (IPTR) MUI_NewObject(MUIC_Group,
 753             MUIA_Group_Spacing,  0,
 754             MUIA_Group_SameSize, FALSE,
 755             InnerSpacing(0,0),
 756
 757             /* "Extension" group */
 758             _newIconWin__TopPanelContainerObj ? Child : TAG_IGNORE, (IPTR)_newIconWin__TopPanelContainerObj,
 759
 760             Child, HGroup,
 761                 _newIconWin__LeftPanelContainerObj ? Child : TAG_IGNORE, (IPTR)_newIconWin__LeftPanelContainerObj,
 762                 /* icon list */
 763                 Child, (IPTR) _newIconWin__RootViewObj,
 764             End,
 765
 766             _newIconWin__BottomPanelContainerObj ? Child : TAG_IGNORE, (IPTR)_newIconWin__BottomPanelContainerObj,
 767
 768         TAG_DONE),
 769
 770         TAG_MORE, (IPTR) message->ops_AttrList
 771     );
 772
 773     if (self != NULL)
 774     {
 775         SETUP_ICONWINDOW_INST_DATA;
 776
 777         D(bug("[Wanderer:IconWindow] %s: SELF = 0x%p\n", __PRETTY_FUNCTION__, self));
 778
 779         data->iwd_VolViewMode                           = _newIconWin__VOLVIEWMODE;
 780
 781         data->iwd_Screen                                = _newIconWin__Screen;
 782         data->iwd_Title                                 = _newIconWin__Title;
 783
 784         data->iwd_RootViewObj                           = _newIconWin__RootViewObj;
 785         data->iwd_IconListObj                           = _newIconWin__IconListObj;
 786
 787         SET(data->iwd_RootViewObj, MUIA_IconWindow_Window,      self);
 788
 789         data->iwd_ActionHook                            = actionHook;
 790
 791         data->iwd_TopPanel.iwp_PanelGroupObj            = _newIconWin__TopPanelRootGroupObj;
 792         data->iwd_TopPanel.iwp_PanelContainerObj        = _newIconWin__TopPanelContainerObj;
 793         data->iwd_TopPanel.iwp_PanelGroupSpacerObj      = _newIconWin__TopPanelSpacerObj;
 794
 795         data->iwd_LeftPanel.iwp_PanelGroupObj           = _newIconWin__LeftPanelRootGroupObj;
 796         data->iwd_LeftPanel.iwp_PanelContainerObj       = _newIconWin__LeftPanelContainerObj;
 797         data->iwd_LeftPanel.iwp_PanelGroupSpacerObj     = _newIconWin__LeftPanelSpacerObj;
 798
 799         data->iwd_BottomPanel.iwp_PanelGroupObj         = _newIconWin__BottomPanelRootGroupObj;
 800         data->iwd_BottomPanel.iwp_PanelContainerObj     = _newIconWin__BottomPanelContainerObj;
 801         data->iwd_BottomPanel.iwp_PanelGroupSpacerObj   = _newIconWin__BottomPanelSpacerObj;
 802
 803         data->iwd_Flags                                 = 0;
 804
 805         data->iwd_Flags                                 |= (isRoot) ? IWDFLAG_ISROOT : 0;
 806         data->iwd_Flags                                 |= (isBackdrop) ? IWDFLAG_ISBACKDROP : 0;
 807
 808         data->iwd_ViewSettings_Attrib                   = (data->iwd_Flags & IWDFLAG_ISROOT)
 809                                                           ? "Workbench"
 810                                                           : "Drawer";
 811
 812         data->iwd_FSNotifyPort                          = _newIconWin__FSNotifyPort;
 813
 814         if (prefs)
 815         {
 816 #ifdef __AROS__
 817             data->iwd_PrefsUpdated_hook.h_Entry = ( HOOKFUNC )IconWindow__HookFunc_PrefsUpdatedFunc;
 818 #else
 819             data->iwd_PrefsUpdated_hook = &iwd_PrefsUpdated_hook;
 820 #endif
 821
 822             DoMethod
 823               (
 824                 prefs, MUIM_Notify, MUIA_WandererPrefs_Processing, FALSE,
 825                 (IPTR) self, 3,
 826                 MUIM_CallHook, &data->iwd_PrefsUpdated_hook, (IPTR)CLASS
 827               );
 828
 829             data->iwd_ViewSettings_PrefsNotificationObject = (Object *) DoMethod(prefs,
 830                                     MUIM_WandererPrefs_ViewSettings_GetNotifyObject,
 831                                     data->iwd_ViewSettings_Attrib);
 832             data->iwd_WindowFont  = (struct TextFont*)DoMethod(prefs, MUIM_WandererPrefs_ViewSettings_GetAttribute,
 833                     data->iwd_ViewSettings_Attrib, MUIA_IconWindow_Font);
 834             SET(data->iwd_IconListObj, MUIA_Font, data->iwd_WindowFont);
 835         }
 836
 837 #ifdef __AROS__
 838         data->iwd_ProcessBackground_hook.h_Entry = ( HOOKFUNC )IconWindow__HookFunc_ProcessBackgroundFunc;
 839 #else
 840         data->iwd_ProcessBackground_hook = &iwd_ProcessBackground_hook;
 841 #endif
 842
 843         if ((data->iwd_BackFill_hook = _newIconWin__BackFillHook))
 844         {
 845             data->iwd_BackFillHookData.bfhd_IWClass = CLASS;
 846             data->iwd_BackFillHookData.bfhd_IWObject = self;
 847             data->iwd_BackFill_hook->h_Data = &data->iwd_BackFillHookData;
 848         }
 849
 850         ForeachNode(&iconwindow_Extensions, iw_Extension)
 851         {
 852             D(bug("[Wanderer:IconWindow] %s: Setting up '%s' @ %p\n", __PRETTY_FUNCTION__, iw_Extension->iwe_Node.ln_Name, iw_Extension));
 853             iw_Extension->iwe_Setup(CLASS, self, message);
 854         }
 855
 856         data->iwd_Flags |= IWDFLAG_SETUP;
 857
 858         /* If double clicked then we call our own private methods, that's
 859            easier then using Hooks */
 860         DoMethod
 861           (
 862             _newIconWin__IconListObj, MUIM_Notify, MUIA_IconList_DoubleClick, TRUE,
 863             (IPTR) self, 1, MUIM_IconWindow_DoubleClicked
 864           );
 865
 866         /* notify when icons dropped on another (wanderer) window */
 867         DoMethod
 868           (
 869             _newIconWin__IconListObj, MUIM_Notify, MUIA_IconList_IconsDropped, MUIV_EveryTime,
 870             (IPTR) self, 1, MUIM_IconWindow_IconsDropped
 871           );
 872
 873         /* notify when icons dropped on custom application */
 874         DoMethod
 875           (
 876             _newIconWin__IconListObj, MUIM_Notify, MUIA_IconList_AppWindowDrop, MUIV_EveryTime,
 877             (IPTR) self, 1, MUIM_IconWindow_AppWindowDrop
 878           );
 879
 880         DoMethod
 881           (
 882             _newIconWin__IconListObj, MUIM_Notify, MUIA_IconList_Clicked, MUIV_EveryTime,
 883             (IPTR) self, 1, MUIM_IconWindow_Clicked
 884           );
 885     }
 886 D(bug("[Wanderer:IconWindow] obj = %ld\n", self));
 887     return self;
 888 }
 889 ///
 890
 891 ///OM_DISPOSE()
 892 IPTR IconWindow__OM_DISPOSE(Class *CLASS, Object *self, Msg message)
 893 {
 894     SETUP_ICONWINDOW_INST_DATA;
 895
 896     struct iconWindow_Extension *iw_Extension = NULL;
 897     Object *prefs = NULL;
 898
 899     GET(_app(self), MUIA_Wanderer_Prefs, &prefs);
 900
 901     if (prefs)
 902     {
 903         DoMethod
 904           (
 905             prefs,
 906             MUIM_KillNotifyObj, MUIA_WandererPrefs_Processing, (IPTR) self
 907           );
 908
 909         if (data->iwd_Flags & IWDFLAG_SETUP)
 910         {
 911             ForeachNode(&iconwindow_Extensions, iw_Extension)
 912             {
 913                 D(bug("[Wanderer:IconWindow] %s: Cleanup '%s'\n", __PRETTY_FUNCTION__, iw_Extension->iwe_Node.ln_Name));
 914                 iw_Extension->iwe_Cleanup(CLASS, self, message);
 915             }
 916         }
 917     }
 918
 919     if (data->iwd_BackFill_hook)
 920         FreeVec(data->iwd_BackFill_hook);
 921
 922     return DoSuperMethodA(CLASS, self, message);
 923 }
 924 ///
 925
 926 ///OM_SET()
 927 IPTR IconWindow__OM_SET(Class *CLASS, Object *self, struct opSet *message)
 928 {
 929     SETUP_ICONWINDOW_INST_DATA;
 930
 931     struct iconWindow_Extension *iw_Extension = NULL;
 932
 933     struct TagItem  *tstate = message->ops_AttrList, *tag;
 934     BOOL      UpdateIconlist = FALSE;
 935     IPTR      focusicon = (IPTR) NULL;
 936     IPTR        rv = TRUE;
 937
 938     while ((tag = NextTagItem((TAGITEM)&tstate)) != NULL)
 939     {
 940         switch (tag->ti_Tag)
 941         {
 942         case MUIA_Window_Screen:
 943             D(bug("[Wanderer:IconWindow] %s: MUIA_Window_Screen [screen @ %p]\n", __PRETTY_FUNCTION__, tag->ti_Data));
 944             data->iwd_Screen = (struct Screen *) tag->ti_Tag;
 945             break;
 946
 947         case MUIA_ShowMe:
 948             D(bug("[Wanderer:IconWindow] %s: MUIA_ShowMe [%x]\n", __PRETTY_FUNCTION__, tag->ti_Data));
 949             if (tag->ti_Data)
 950             {
 951                 struct Screen *__Wanderer__Screen = NULL;
 952                 GET(_app(self), MUIA_Wanderer_Screen, &__Wanderer__Screen);
 953                 if (__Wanderer__Screen != data->iwd_Screen)
 954                 {
 955                     D(bug("[Wanderer:IconWindow] %s: Screen Changed [old = %p, new = %p]\n", __PRETTY_FUNCTION__, data->iwd_Screen, __Wanderer__Screen));
 956                     SET(self, MUIA_Window_Screen, __Wanderer__Screen);
 957                     if (((data->iwd_Flags & IWDFLAG_ISROOT)) && ((data->iwd_Flags & IWDFLAG_ISBACKDROP)))
 958                     {
 959                         IPTR                            _IconWin__NewWindowWidth = 0;
 960                         IPTR                            _IconWin__NewWindowHeight = 0;
 961 #if 0 /* unused */
 962                         IPTR                            _IconWin__NewWindowLeft = 0;
 963 #endif
 964                         IPTR                            _IconWin__NewWindowTop = 0;
 965
 966                         D(bug("[Wanderer:IconWindow] %s: Updating Backdrop Window Dimensions\n", __PRETTY_FUNCTION__));
 967
 968                         _IconWin__NewWindowWidth = GetBitMapAttr(__Wanderer__Screen->RastPort.BitMap, BMA_WIDTH);
 969                         _IconWin__NewWindowHeight = GetBitMapAttr(__Wanderer__Screen->RastPort.BitMap, BMA_HEIGHT);
 970                         D(bug("[Wanderer:IconWindow] %s: Screen dimensions ..  %d x %d\n", __PRETTY_FUNCTION__, _IconWin__NewWindowWidth, _IconWin__NewWindowHeight));
 971
 972                         _IconWin__NewWindowTop = __Wanderer__Screen->BarHeight + 1;
 973 #if 0 /* unused */
 974                         _IconWin__NewWindowLeft = 0;
 975 #endif
 976
 977                         _IconWin__NewWindowHeight -= _IconWin__NewWindowTop;
 978
 979                         D(bug("[Wanderer:IconWindow] %s: New Window dimensions ..  %d x %d @ %d, %d\n", __PRETTY_FUNCTION__, _IconWin__NewWindowWidth, _IconWin__NewWindowHeight, 0, _IconWin__NewWindowTop));
 980
 981                         SET(self, MUIA_Window_Width, _IconWin__NewWindowWidth);
 982                         SET(self, MUIA_Window_Height, _IconWin__NewWindowHeight);
 983                     }
 984                 }
 985             }
 986             break;
 987
 988         case MUIA_IconWindow_Changed:
 989             data->iwd_Flags |= (tag->ti_Data) ? IWDFLAG_NEEDSUPDATE : 0;
 990             break;
 991
 992         case MUIA_Window_Open:
 993             D(bug("[Wanderer:IconWindow] %s: MUIA_Window_Open [%ld]\n", __PRETTY_FUNCTION__, tag->ti_Data));
 994             if (tag->ti_Data)
 995             {
 996                 DoMethod(data->iwd_IconListObj, MUIM_IconList_Clear);
 997
 998                 rv = DoSuperMethodA(CLASS, self, (Msg) message);
 999 #if defined(ICONWINDOW_BUFFERLIST)
1000                 if (!((data->iwd_Flags & IWDFLAG_ISROOT)))
1001                 {
1002                     IPTR        CURDISPFLAGS = NULL;
1003                     GET(data->iwd_IconListObj, MUIA_IconList_DisplayFlags, &CURDISPFLAGS);
1004                     CURDISPFLAGS |= ICONLIST_DISP_BUFFERED;
1005                     SET(data->iwd_IconListObj, MUIA_IconList_DisplayFlags, CURDISPFLAGS);
1006                 }
1007 #endif
1008                 D(bug("[Wanderer:IconWindow] %s: Process the background ..\n", __PRETTY_FUNCTION__));
1009                 DoMethod(self, MUIM_IconWindow_BackFill_ProcessBackground, data->iwd_BackFillInfo, data->iwd_RootViewObj);
1010
1011                 D(bug("[Wanderer:IconWindow] %s: Force an update of the list ..\n", __PRETTY_FUNCTION__));
1012                 DoMethod(data->iwd_IconListObj, MUIM_IconList_Update);
1013                 DoMethod(data->iwd_IconListObj, MUIM_IconList_Sort);
1014                 return rv;
1015             }
1016             break;
1017
1018         case MUIA_Window_Activate:
1019             if (data->iwd_IconListObj)
1020                 GET(data->iwd_IconListObj, MUIA_IconList_FocusIcon, &focusicon);
1021
1022             break;
1023
1024         case MUIA_IconWindow_Font:
1025             data->iwd_WindowFont = (struct TextFont  *)tag->ti_Data;
1026             D(bug("[Wanderer:IconWindow] %s: MUIA_IconWindow_Font [font @ 0x%p]\n", __PRETTY_FUNCTION__, data->iwd_WindowFont));
1027
1028             if (!data->iwd_WindowFont)
1029                 SetFont(_rp(self), data->iwd_WindowFont);
1030
1031             if (data->iwd_IconListObj)
1032                 SET(data->iwd_IconListObj, MUIA_Font, data->iwd_WindowFont);
1033
1034             break;
1035
1036         case MUIA_IconWindow_Location:
1037             D(bug("[Wanderer:IconWindow] %s: MUIA_IconWindow_Location [drawer '%s']\n", __PRETTY_FUNCTION__, data->iwd_DirectoryPath));
1038
1039             if (!(data->iwd_Flags & IWDFLAG_ISROOT))
1040             {
1041                 strcpy(data->iwd_DirectoryPath, (STRPTR)tag->ti_Data);
1042                 SET(self, MUIA_Window_Title, (IPTR)data->iwd_DirectoryPath);
1043                 SET(data->iwd_IconListObj, MUIA_IconDrawerList_Drawer, (IPTR)data->iwd_DirectoryPath);
1044             }
1045             break;
1046
1047         case MUIA_IconWindow_BackgroundAttrib:
1048             D(bug("[Wanderer:IconWindow] %s: MUIA_IconWindow_BackgroundAttrib (not implemented)\n", __PRETTY_FUNCTION__));
1049             break;
1050
1051         }
1052     }
1053
1054     rv = DoSuperMethodA(CLASS, self, (Msg) message);
1055
1056     if (data->iwd_Flags & IWDFLAG_SETUP)
1057     {
1058         ForeachNode(&iconwindow_Extensions, iw_Extension)
1059         {
1060             D(bug("[Wanderer:IconWindow] %s: Checking '%s'\n", __PRETTY_FUNCTION__, iw_Extension->iwe_Node.ln_Name));
1061             iw_Extension->iwe_Set(CLASS, self, message);
1062         }
1063     }
1064
1065     if (UpdateIconlist)
1066     {
1067         DoMethod(data->iwd_IconListObj, MUIM_IconList_Update);
1068         DoMethod(data->iwd_IconListObj, MUIM_IconList_Sort);
1069     }
1070
1071     if (focusicon)
1072     {
1073         D(bug("[Wanderer:IconWindow] %s: Updating focused icon (@ 0x%p)\n", __PRETTY_FUNCTION__, focusicon));
1074         //MUI_Redraw(data->iwd_IconListObj, MADF_DRAWOBJECT);
1075     }
1076
1077     return rv;
1078 }
1079 ///
1080
1081 ///OM_GET()
1082 IPTR IconWindow__OM_GET(Class *CLASS, Object *self, struct opGet *message)
1083 {
1084     SETUP_ICONWINDOW_INST_DATA;
1085     struct iconWindow_Extension *iw_Extension = NULL;
1086     IPTR *store = message->opg_Storage;
1087     IPTR  rv    = TRUE;
1088
1089     switch (message->opg_AttrID)
1090     {
1091     case MUIA_IconWindow_Changed:
1092         *store = (IPTR)(data->iwd_Flags & IWDFLAG_NEEDSUPDATE);
1093         break;
1094
1095     case MUIA_IconWindow_Window:
1096         *store = (IPTR)self;
1097         break;
1098
1099     case MUIA_IconWindow_Location:
1100         *store = !(data->iwd_Flags & IWDFLAG_ISROOT)
1101             ? XGET(data->iwd_IconListObj, MUIA_IconDrawerList_Drawer)
1102             : (IPTR)NULL;
1103         break;
1104
1105     case MUIA_IconWindow_IconList:
1106         *store = (IPTR)data->iwd_IconListObj;
1107         break;
1108
1109     case MUIA_IconWindow_IsRoot:
1110         *store = (IPTR)(data->iwd_Flags & IWDFLAG_ISROOT);
1111         break;
1112
1113     case MUIA_IconWindow_IsBackdrop:
1114         *store = (IPTR)(data->iwd_Flags & IWDFLAG_ISBACKDROP);
1115         break;
1116
1117     case MUIA_IconWindow_BackFillData:
1118         *store = (IPTR)data->iwd_BackFillInfo;
1119         break;
1120
1121     case MUIA_IconWindow_BackgroundAttrib:
1122         *store = (IPTR)data->iwd_ViewSettings_Attrib;
1123         break;
1124
1125     case MUIA_Version:
1126         *store = (IPTR)WIWVERS;
1127         break;
1128
1129     case MUIA_Revision:
1130         *store = (IPTR)WIWREV;
1131         break;
1132
1133     default:
1134         rv = FALSE;
1135     }
1136
1137     if (!rv)
1138         rv = DoSuperMethodA(CLASS, self, (Msg) message);
1139
1140     if (!rv)
1141     {
1142         ForeachNode(&iconwindow_Extensions, iw_Extension)
1143         {
1144             D(bug("[Wanderer:IconWindow] %s: Checking '%s'\n", __PRETTY_FUNCTION__, iw_Extension->iwe_Node.ln_Name));
1145             if ((rv = iw_Extension->iwe_Get(CLASS, self, message)))
1146                 break;
1147         }
1148     }
1149
1150     return rv;
1151 }
1152 ///
1153
1154 ///IconWindow__MUIM_Window_Setup()
1155 IPTR IconWindow__MUIM_Window_Setup
1156 (
1157     Class *CLASS, Object *self, Msg message
1158 )
1159 {
1160     SETUP_ICONWINDOW_INST_DATA;
1161
1162     Object *prefs = NULL;
1163
1164     D(bug("[Wanderer:IconWindow]: %s()\n", __PRETTY_FUNCTION__));
1165
1166     if (!DoSuperMethodA(CLASS, self, message)) return FALSE;
1167
1168     if (iconwindow_BackFill_Active)
1169     {
1170         data->iwd_BackFillInfo =(struct BackFillInfo *) DoMethod(self, MUIM_IconWindow_BackFill_Setup);
1171         D(bug("[Wanderer:IconWindow] %s: Window BackFill_Data @ 0x%p for '%s'\n", __PRETTY_FUNCTION__, data->iwd_BackFillInfo, iconwindow_BackFill_Active->bfd_BackFillID));
1172     }
1173
1174     GET(_app(self), MUIA_Wanderer_Prefs, &prefs);
1175
1176     D(bug("[Wanderer:IconWindow] %s: App PrefsObj @ 0x%p\n", __PRETTY_FUNCTION__, prefs));
1177
1178     if ((prefs) && (data->iwd_ViewSettings_PrefsNotificationObject))
1179     {
1180         D(bug("[Wanderer:IconWindow] %s: Setting up window prefs change hooks\n", __PRETTY_FUNCTION__));
1181
1182         /* Set-up a hook to call ProcessBackground on prefs notification */
1183         DoMethod
1184           (
1185             data->iwd_ViewSettings_PrefsNotificationObject, MUIM_Notify, MUIA_Background, MUIV_EveryTime,
1186             (IPTR) self, 3,
1187             MUIM_CallHook, &data->iwd_ProcessBackground_hook, (IPTR)CLASS
1188           );
1189
1190         if ((data->iwd_Flags & IWDFLAG_ISROOT))
1191         {
1192             DoMethod
1193               (
1194                 data->iwd_ViewSettings_PrefsNotificationObject, MUIM_Notify, MUIA_IconWindowExt_ImageBackFill_BGRenderMode, MUIV_EveryTime,
1195                 (IPTR) self, 3,
1196                 MUIM_CallHook, &data->iwd_ProcessBackground_hook, (IPTR)CLASS
1197               );
1198         }
1199
1200         DoMethod
1201           (
1202             data->iwd_ViewSettings_PrefsNotificationObject, MUIM_Notify, MUIA_IconWindowExt_ImageBackFill_BGTileMode, MUIV_EveryTime,
1203             (IPTR) self, 3,
1204             MUIM_CallHook, &data->iwd_ProcessBackground_hook, (IPTR)CLASS
1205           );
1206
1207         DoMethod
1208           (
1209             data->iwd_ViewSettings_PrefsNotificationObject, MUIM_Notify, MUIA_IconWindowExt_ImageBackFill_BGXOffset, MUIV_EveryTime,
1210             (IPTR) self, 3,
1211             MUIM_CallHook, &data->iwd_ProcessBackground_hook, (IPTR)CLASS
1212           );
1213
1214         DoMethod
1215           (
1216             data->iwd_ViewSettings_PrefsNotificationObject, MUIM_Notify, MUIA_IconWindowExt_ImageBackFill_BGYOffset, MUIV_EveryTime,
1217             (IPTR) self, 3,
1218             MUIM_CallHook, &data->iwd_ProcessBackground_hook, (IPTR)CLASS
1219           );
1220
1221         /* React to notification on font change */
1222         DoMethod
1223           (
1224             data->iwd_ViewSettings_PrefsNotificationObject, MUIM_Notify, MUIA_IconWindow_Font, MUIV_EveryTime,
1225             (IPTR) self, 3,
1226             MUIM_Set, MUIA_IconWindow_Font, MUIV_TriggerValue
1227           );
1228
1229     }
1230
1231     D(bug("[Wanderer:IconWindow] %s: Setup complete!\n", __PRETTY_FUNCTION__));
1232
1233     return TRUE;
1234 }
1235 ///
1236
1237 ///IconWindow__MUIM_Window_Cleanup()
1238 IPTR IconWindow__MUIM_Window_Cleanup
1239 (
1240     Class *CLASS, Object *self, Msg message
1241 )
1242 {
1243     SETUP_ICONWINDOW_INST_DATA;
1244
1245     D(bug("[Wanderer:IconWindow]: %s()\n", __PRETTY_FUNCTION__));
1246
1247     if (data->iwd_BackFillInfo)
1248     {
1249         DoMethod(self, MUIM_IconWindow_BackFill_Cleanup, data->iwd_BackFillInfo);
1250         data->iwd_BackFillInfo = NULL;
1251     }
1252
1253     if (data->iwd_ViewSettings_PrefsNotificationObject)
1254     {
1255         DoMethod
1256           (
1257             data->iwd_ViewSettings_PrefsNotificationObject,
1258             MUIM_KillNotifyObj, MUIA_IconWindowExt_ImageBackFill_BGYOffset, (IPTR) self
1259           );
1260
1261         DoMethod
1262           (
1263             data->iwd_ViewSettings_PrefsNotificationObject,
1264             MUIM_KillNotifyObj, MUIA_IconWindowExt_ImageBackFill_BGXOffset, (IPTR) self
1265           );
1266
1267         DoMethod
1268           (
1269             data->iwd_ViewSettings_PrefsNotificationObject,
1270             MUIM_KillNotifyObj, MUIA_IconWindowExt_ImageBackFill_BGTileMode, (IPTR) self
1271           );
1272
1273         if ((data->iwd_Flags & IWDFLAG_ISROOT))
1274         {
1275             DoMethod
1276               (
1277                 data->iwd_ViewSettings_PrefsNotificationObject,
1278                 MUIM_KillNotifyObj, MUIA_IconWindowExt_ImageBackFill_BGRenderMode, (IPTR) self
1279               );
1280         }
1281
1282         DoMethod
1283           (
1284             data->iwd_ViewSettings_PrefsNotificationObject,
1285             MUIM_KillNotifyObj, MUIA_Background, (IPTR) self
1286           );
1287
1288         DoMethod
1289           (
1290             data->iwd_ViewSettings_PrefsNotificationObject,
1291             MUIM_KillNotifyObj, MUIA_IconWindow_Font, (IPTR) self
1292           );
1293     }
1294     return DoSuperMethodA(CLASS, self, message);
1295 }
1296 ///
1297
1298 ///IconWindow__MUIM_IconWindow_DoubleClicked()
1299 IPTR IconWindow__MUIM_IconWindow_DoubleClicked
1300 (
1301     Class *CLASS, Object *self, Msg message
1302 )
1303 {
1304     SETUP_ICONWINDOW_INST_DATA;
1305
1306     D(bug("[Wanderer:IconWindow]: %s()\n", __PRETTY_FUNCTION__));
1307
1308     if (data->iwd_ActionHook)
1309     {
1310         struct IconWindow_ActionMsg msg;
1311         msg.type     = ICONWINDOW_ACTION_OPEN;
1312         msg.iconlist = data->iwd_IconListObj;
1313         msg.isroot   = (data->iwd_Flags & IWDFLAG_ISROOT);
1314         msg.click    = NULL;
1315         CallHookPkt(data->iwd_ActionHook, self, &msg);
1316     }
1317
1318     return TRUE;
1319 }
1320 ///
1321
1322 ///IconWindow__MUIM_IconWindow_Clicked()
1323 IPTR IconWindow__MUIM_IconWindow_Clicked
1324 (
1325     Class *CLASS, Object *self, Msg message
1326 )
1327 {
1328     SETUP_ICONWINDOW_INST_DATA;
1329
1330     D(bug("[Wanderer:IconWindow]: %s()\n", __PRETTY_FUNCTION__));
1331
1332     if (data->iwd_ActionHook)
1333     {
1334         struct IconWindow_ActionMsg msg;
1335         msg.type     = ICONWINDOW_ACTION_CLICK;
1336         msg.iconlist = data->iwd_IconListObj;
1337         msg.isroot   = (data->iwd_Flags & IWDFLAG_ISROOT);
1338         GET(data->iwd_IconListObj, MUIA_IconList_Clicked, &msg.click);
1339         CallHookPkt(data->iwd_ActionHook, self, &msg);
1340     }
1341
1342     return TRUE;
1343 }
1344 ///
1345
1346 ///IconWindow__MUIM_IconWindow_IconsDropped()
1347 IPTR IconWindow__MUIM_IconWindow_IconsDropped
1348 (
1349     Class *CLASS, Object *self, Msg message
1350 )
1351 {
1352     SETUP_ICONWINDOW_INST_DATA;
1353
1354     D(bug("[Wanderer:IconWindow]: %s()\n", __PRETTY_FUNCTION__));
1355
1356     if (data->iwd_ActionHook)
1357     {
1358         struct IconWindow_ActionMsg msg;
1359         msg.type     = ICONWINDOW_ACTION_ICONDROP;
1360         msg.iconlist = data->iwd_IconListObj;
1361         msg.isroot   = (data->iwd_Flags & IWDFLAG_ISROOT);
1362         GET(data->iwd_IconListObj, MUIA_IconList_IconsDropped, &msg.drop);
1363         if (msg.drop)
1364         {
1365             NNSET(data->iwd_IconListObj, MUIA_IconList_IconsDropped, NULL);
1366             CallHookPkt(data->iwd_ActionHook, self, &msg);
1367         }
1368     }
1369
1370     return TRUE;
1371 }
1372 ///
1373
1374 ///IconWindow__MUIM_IconWindow_AppWindowDrop()
1375 IPTR IconWindow__MUIM_IconWindow_AppWindowDrop
1376 (
1377     Class *CLASS, Object *self, Msg message
1378 )
1379 {
1380     SETUP_ICONWINDOW_INST_DATA;
1381
1382 D(bug("[Wanderer:IconWindow]: %s()\n", __PRETTY_FUNCTION__));
1383
1384     if (data->iwd_ActionHook)
1385     {
1386         struct IconWindow_ActionMsg msg;
1387         msg.type     = ICONWINDOW_ACTION_APPWINDOWDROP;
1388         msg.iconlist = data->iwd_IconListObj;
1389         msg.isroot   = (data->iwd_Flags & IWDFLAG_ISROOT);
1390         GET(data->iwd_IconListObj, MUIA_IconList_IconsDropped, &msg.drop);
1391         CallHookPkt(data->iwd_ActionHook, self, &msg);
1392     }
1393
1394     return TRUE;
1395 }
1396 ///
1397
1398 ///IconWindow__MUIM_IconWindow_Open()
1399 IPTR IconWindow__MUIM_IconWindow_Open
1400 (
1401     Class *CLASS, Object *self, Msg message
1402 )
1403 {
1404 //    SETUP_ICONWINDOW_INST_DATA;
1405
1406 D(bug("[Wanderer:IconWindow]: %s()\n", __PRETTY_FUNCTION__));
1407
1408     if (!XGET(self, MUIA_Window_Open))
1409     {
1410         SET(self, MUIA_Window_Open, TRUE);
1411     }
1412
1413 D(bug("[Wanderer:IconWindow] %s: Setting window as active ..\n", __PRETTY_FUNCTION__));
1414     SET(self, MUIA_Window_Activate, TRUE);
1415
1416 D(bug("[Wanderer:IconWindow] %s: All done\n", __PRETTY_FUNCTION__));
1417
1418     return TRUE;
1419 }
1420 ///
1421
1422 ///IconWindow__MUIM_IconWindow_DirectoryUp()
1423 IPTR IconWindow__MUIM_IconWindow_DirectoryUp
1424 (
1425   Class *CLASS, Object *self, Msg message
1426 )
1427 {
1428   SETUP_ICONWINDOW_INST_DATA;
1429
1430   D(bug("[Wanderer:IconWindow]: %s()\n", __PRETTY_FUNCTION__));
1431
1432   if (data->iwd_ActionHook)
1433   {
1434     struct IconWindow_ActionMsg msg;
1435     msg.type     = ICONWINDOW_ACTION_DIRUP;
1436     msg.iconlist = data->iwd_IconListObj;
1437     msg.isroot   = (data->iwd_Flags & IWDFLAG_ISROOT);
1438     msg.click    = NULL;
1439     CallHookPkt(data->iwd_ActionHook, self, &msg);
1440
1441   }
1442
1443   return TRUE;
1444 }
1445 ///
1446
1447 ///IconWindow__MUIM_IconWindow_UnselectAll()
1448 IPTR IconWindow__MUIM_IconWindow_UnselectAll
1449 (
1450   Class *CLASS, Object *self, Msg message
1451 )
1452 {
1453   SETUP_ICONWINDOW_INST_DATA;
1454
1455   D(bug("[Wanderer:IconWindow]: %s()\n", __PRETTY_FUNCTION__));
1456
1457   DoMethod(data->iwd_IconListObj, MUIM_IconList_UnselectAll);
1458
1459   return TRUE;
1460 }
1461 ///
1462
1463 ///IconWindow__MUIM_IconWindow_Remove()
1464 IPTR IconWindow__MUIM_IconWindow_Remove
1465 (
1466   Class *CLASS, Object *self, Msg message
1467 )
1468 {
1469 //  SETUP_ICONWINDOW_INST_DATA;
1470
1471   D(bug("[Wanderer:IconWindow]: %s()\n", __PRETTY_FUNCTION__));
1472
1473   // Remove window
1474   SET( self, MUIA_Window_Open, FALSE );
1475   DoMethod ( _app(self), OM_REMMEMBER, self );
1476   DisposeObject(self);
1477
1478   return TRUE;
1479 }
1480 ///
1481
1482 /*** Stubs for Backfill Hooks ******************************************************************/
1483 ///IconWindow__MUIM_IconWindow_BackFill_Register()
1484 IPTR IconWindow__MUIM_IconWindow_BackFill_Register
1485 (
1486   Class *CLASS, Object *self, struct MUIP_IconWindow_BackFill_Register *message
1487 )
1488 {
1489 //    SETUP_ICONWINDOW_INST_DATA;
1490
1491   D(bug("[Wanderer:IconWindow]: %s('%s')\n", __PRETTY_FUNCTION__, message->register_Node->bfd_BackFillID));
1492
1493   AddTail(&iconwindow_BackFillNodes, (struct Node *)message->register_Node);
1494   if (iconwindow_BackFill_Active == NULL) iconwindow_BackFill_Active = message->register_Node;
1495
1496   return TRUE;
1497 }
1498 ///
1499
1500 ///IconWindow__MUIM_IconWindow_BackFill_Setup()
1501 IPTR IconWindow__MUIM_IconWindow_BackFill_Setup
1502 (
1503   Class *CLASS, Object *self, struct MUIP_IconWindow_BackFill_Setup *message
1504 )
1505 {
1506 //  SETUP_ICONWINDOW_INST_DATA;
1507
1508   D(bug("[Wanderer:IconWindow]: %s()\n", __PRETTY_FUNCTION__));
1509
1510   if (iconwindow_BackFill_Active == NULL) return FALSE;
1511
1512   return (iconwindow_BackFill_Active->bfd_MUIM_IconWindow_BackFill_Setup)(CLASS, self, message);
1513 }
1514 ///
1515
1516 ///IconWindow__MUIM_IconWindow_BackFill_Cleanup()
1517 IPTR IconWindow__MUIM_IconWindow_BackFill_Cleanup
1518 (
1519   Class *CLASS, Object *self, struct MUIP_IconWindow_BackFill_Cleanup *message
1520 )
1521 {
1522   //SETUP_ICONWINDOW_INST_DATA;
1523
1524   D(bug("[Wanderer:IconWindow]: %s()\n", __PRETTY_FUNCTION__));
1525
1526   if (iconwindow_BackFill_Active == NULL) return FALSE;
1527
1528   return (iconwindow_BackFill_Active->bfd_MUIM_IconWindow_BackFill_Cleanup)(CLASS, self, message);
1529 }
1530 ///
1531
1532 ///IconWindow__MUIM_IconWindow_BackFill_ProcessBackground()
1533 IPTR IconWindow__MUIM_IconWindow_BackFill_ProcessBackground
1534 (
1535   Class *CLASS, Object *self, struct MUIP_IconWindow_BackFill_ProcessBackground *message
1536 )
1537 {
1538   SETUP_ICONWINDOW_INST_DATA;
1539
1540   IPTR retVal = (IPTR)FALSE;
1541
1542   D(bug("[Wanderer:IconWindow]: %s()\n", __PRETTY_FUNCTION__));
1543
1544   if (iconwindow_BackFill_Active != NULL)
1545   {
1546     D(bug("[Wanderer:IconWindow] %s: Asking module @ 0x%p to process ..\n", __PRETTY_FUNCTION__, iconwindow_BackFill_Active));
1547     retVal = (iconwindow_BackFill_Active->bfd_MUIM_IconWindow_BackFill_ProcessBackground)(CLASS, self, message);
1548   }
1549
1550   if (!retVal && (data->iwd_RootViewObj != NULL))
1551   {
1552     Object                *IconWindowPB_PrefsObj = NULL;
1553
1554     D(bug("[Wanderer:IconWindow] %s: No BackFill module/ module cant render mode\n", __PRETTY_FUNCTION__));
1555     D(bug("[Wanderer:IconWindow] %s: Using default MUI functions ..\n", __PRETTY_FUNCTION__));
1556
1557     GET(_app(self), MUIA_Wanderer_Prefs, &IconWindowPB_PrefsObj);
1558     if (IconWindowPB_PrefsObj)
1559     {
1560       IPTR IconWindowPB_Background = 0;
1561       IPTR IconWindowPB_BGMode     = 0;
1562       IPTR IconWindowPB_BGTileMode = 0;
1563
1564       if ((IconWindowPB_Background = DoMethod(IconWindowPB_PrefsObj, MUIM_WandererPrefs_ViewSettings_GetAttribute, data->iwd_ViewSettings_Attrib, MUIA_Background)) != -1)
1565       {
1566         char *bgmode_string;
1567         BYTE this_mode;
1568
1569         if ((IconWindowPB_BGMode = DoMethod(IconWindowPB_PrefsObj, MUIM_WandererPrefs_ViewSettings_GetAttribute,
1570                         data->iwd_ViewSettings_Attrib, MUIA_IconWindowExt_ImageBackFill_BGRenderMode)) == -1)
1571           IconWindowPB_BGMode = IconWindowExt_ImageBackFill_RenderMode_Tiled;
1572
1573         if ((IconWindowPB_BGTileMode = DoMethod(IconWindowPB_PrefsObj, MUIM_WandererPrefs_ViewSettings_GetAttribute,
1574                                   data->iwd_ViewSettings_Attrib, MUIA_IconWindowExt_ImageBackFill_BGTileMode)) == -1)
1575           IconWindowPB_BGTileMode = IconWindowExt_ImageBackFill_TileMode_Float;
1576
1577         SET(data->iwd_RootViewObj, MUIA_Background, IconWindowPB_Background);
1578
1579         bgmode_string =(STRPTR) IconWindowPB_Background;
1580         this_mode = bgmode_string[0] - 48;
1581
1582         D(bug("[Wanderer:IconWindow] %s: MUI BG Mode = %d\n", __PRETTY_FUNCTION__, this_mode));
1583
1584         switch (this_mode)
1585         {
1586           case 5:
1587             //Image =D
1588             if (IconWindowPB_BGMode == IconWindowExt_ImageBackFill_RenderMode_Scale)
1589             {
1590               SET(data->iwd_RootViewObj, MUIA_IconListview_ScaledBackground, TRUE);
1591               break;
1592             }
1593             else
1594               SET(data->iwd_RootViewObj, MUIA_IconListview_ScaledBackground, FALSE);
1595
1596           case 0:
1597             //MUI Pattern
1598             if (IconWindowPB_BGTileMode == IconWindowExt_ImageBackFill_TileMode_Fixed)
1599               SET(data->iwd_RootViewObj, MUIA_IconListview_FixedBackground, TRUE);
1600             else
1601               SET(data->iwd_RootViewObj, MUIA_IconListview_FixedBackground, FALSE);
1602             break;
1603         }
1604       }
1605     }
1606     retVal = FALSE;
1607   }
1608
1609   return retVal;
1610 }
1611 ///
1612
1613 ///IconWindow__MUIM_IconWindow_BackFill_DrawBackground()
1614 IPTR IconWindow__MUIM_IconWindow_BackFill_DrawBackground
1615 (
1616   Class *CLASS, Object *self, struct MUIP_IconWindow_BackFill_DrawBackground *message
1617 )
1618 {
1619 //  SETUP_ICONWINDOW_INST_DATA;
1620
1621   D(bug("[Wanderer:IconWindow]: %s()\n", __PRETTY_FUNCTION__));
1622
1623   if (iconwindow_BackFill_Active == NULL) return FALSE;
1624
1625   return (iconwindow_BackFill_Active->bfd_MUIM_IconWindow_BackFill_DrawBackground)(CLASS, self, message);
1626 }
1627 ///
1628
1629 ///IconWindow__MUIM_IconWindow_RateLimitRefresh()
1630 IPTR IconWindow__MUIM_IconWindow_RateLimitRefresh
1631 (
1632   Class *CLASS, Object *self, Msg message
1633 )
1634 {
1635     Object * iconList = NULL;
1636
1637     GET(self, MUIA_IconWindow_IconList, &iconList);
1638
1639     if (iconList != NULL)
1640         return DoMethod(iconList, MUIM_IconWindowIconList_RateLimitRefresh);
1641
1642     return (IPTR)FALSE;
1643 }
1644 ///
1645
1646 ///IconWindow__MUIM_IconWindow_Snapshot()
1647 IPTR IconWindow__MUIM_IconWindow_Snapshot
1648 (
1649   Class *CLASS, Object *self, struct MUIP_IconWindow_Snapshot * message
1650 )
1651 {
1652     Object  *iconList = (Object *) XGET(self, MUIA_IconWindow_IconList);
1653
1654     D(bug("[Wanderer:IconWindow]: %s('%s')\n", __PRETTY_FUNCTION__, dir_name));
1655
1656     if (message->snapshotall == TRUE)
1657     {
1658         struct IconList_Entry *icon_entry    = (IPTR)MUIV_IconList_NextIcon_Start;
1659         struct IconEntry      *node = NULL;
1660         struct TagItem            icon_tags[] =
1661         {
1662             { ICONPUTA_OnlyUpdatePosition, TRUE },
1663             { TAG_DONE, 0                       }
1664         };
1665         D(bug("[Wanderer:IconWindow] %s: snapshot ALL\n", __PRETTY_FUNCTION__));
1666
1667         do
1668         {
1669             DoMethod(iconList, MUIM_IconList_NextIcon, MUIV_IconList_NextIcon_Visible, (IPTR)&icon_entry);
1670
1671             if ((IPTR)icon_entry != MUIV_IconList_NextIcon_End)
1672             {
1673                 node = (struct IconEntry *)((IPTR)icon_entry - ((IPTR)&node->ie_IconListEntry - (IPTR)node));
1674                 if (node->ie_Flags & ICONENTRY_FLAG_HASICON)
1675                 {
1676                     /* Snapshot-all should only save positions of objects that already have icons.
1677                      * This is by design and how 3.1 Workbench works. In order to snapshot all objects in window
1678                      * regardless if they have icons or not: 1) make all objects visible, 2) select all objects,
1679                      * 3) select icon->snapshot */
1680                     D(bug("[Wanderer:IconWindow] %s: SNAPSHOT entry = '%s' @ %p, (%p)\n", __PRETTY_FUNCTION__,
1681                             icon_entry->ile_IconEntry->ie_IconNode.ln_Name, icon_entry, node));
1682                     if (node->ie_DiskObj)
1683                     {
1684                         node->ie_DiskObj->do_CurrentX = node->ie_IconX;
1685                         node->ie_DiskObj->do_CurrentY = node->ie_IconY;
1686                         PutIconTagList(icon_entry->ile_IconEntry->ie_IconNode.ln_Name, node->ie_DiskObj, icon_tags);
1687                     }
1688                     else
1689                     {
1690                         D(bug("[[Wanderer:IconWindow] %s: icon has no diskobj!\n", __PRETTY_FUNCTION__));
1691                     }
1692                 }
1693             }
1694             else
1695             {
1696                 break;
1697             }
1698         } while (TRUE);
1699     }
1700     else
1701     {
1702         D(bug("[Wanderer:IconWindow] %s: snapshot WINDOW\n", __PRETTY_FUNCTION__));
1703     }
1704
1705     IconWindow_StoreSettings(self);
1706
1707     return (IPTR)TRUE;
1708 }
1709 ///
1710
1711 ///
1712 IPTR IconWindow__SetupClass()
1713 {
1714     D(bug("[Wanderer:IconWindow]: %s()\n", __PRETTY_FUNCTION__));
1715
1716     NewList(&iconwindow_BackFillNodes);
1717     D(bug("[Wanderer:IconWindow] %s: iconwindow_BackFillNodes @ %p\n", __PRETTY_FUNCTION__, &iconwindow_BackFillNodes));
1718     NewList(&iconwindow_Extensions);
1719     D(bug("[Wanderer:IconWindow] %s: iconwindow_Extensions @ %p\n", __PRETTY_FUNCTION__, &iconwindow_Extensions));
1720     iconwindow_BackFill_Active = NULL;
1721
1722     return TRUE;
1723 }
1724 ///
1725 /*** Setup ******************************************************************/
1726 ICONWINDOW_CUSTOMCLASS
1727 (
1728   IconWindow, NULL, MUIC_Window, NULL,
1729   OM_NEW,                                     struct opSet *,
1730   OM_DISPOSE,                         Msg,
1731   OM_SET,                                     struct opSet *,
1732   OM_GET,                                     struct opGet *,
1733   MUIM_Window_Setup,                          Msg,
1734   MUIM_Window_Cleanup,                        Msg,
1735   MUIM_IconWindow_Open,                       Msg,
1736   MUIM_IconWindow_UnselectAll,                Msg,
1737   MUIM_IconWindow_DoubleClicked,              Msg,
1738   MUIM_IconWindow_IconsDropped,               Msg,
1739   MUIM_IconWindow_Clicked,                    Msg,
1740   MUIM_IconWindow_DirectoryUp,                Msg,
1741   MUIM_IconWindow_AppWindowDrop,              Msg,
1742   MUIM_IconWindow_Remove,                     Msg,
1743   MUIM_IconWindow_RateLimitRefresh,           Msg,
1744   MUIM_IconWindow_Snapshot,                   struct MUIP_IconWindow_Snapshot *,
1745   MUIM_IconWindow_BackFill_Register,          struct MUIP_IconWindow_BackFill_Register *,
1746   MUIM_IconWindow_BackFill_Setup,             struct MUIP_IconWindow_BackFill_Setup *,
1747   MUIM_IconWindow_BackFill_Cleanup,           struct MUIP_IconWindow_BackFill_Cleanup *,
1748   MUIM_IconWindow_BackFill_ProcessBackground, struct MUIP_IconWindow_BackFill_ProcessBackground *,
1749   MUIM_IconWindow_BackFill_DrawBackground,    struct MUIP_IconWindow_BackFill_DrawBackground *
1750 );
1751
1752 ADD2INIT(IconWindow__SetupClass, 0);
1753
1754 #ifndef __AROS__
1755 int initIconWindowClass(void)
1756 {
1757   IPTR ret1 = IconWindow_Initialize();
1758
1759   IPTR ret2 = IconWindow__SetupClass();
1760
1761   IPTR ret3 = ImageBackFill__SetupClass();
1762
1763   if (ret1 && ret2 && ret3)
1764     return TRUE;
1765   else
1766     return FALSE;
1767
1768 }
1769 #endif