workbench/system/Wanderer/iconwindow.c

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