workbench/system/Wanderer/iconwindow.c

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