workbench/system/Wanderer/iconwindow.c

   1 /*
   2   Copyright  2004-2010, The AROS Development Team. All rights reserved.
   3   $Id$
   4 */
   5 #define DOPENWINDOW(x) /* Window positioning and size */
   6
   7 #define ZCC_QUIET
   8
   9 #include "portable_macros.h"
  10 #ifdef __AROS__
  11 #define MUIMASTER_YES_INLINE_STDARG
  12 #endif
  13
  14 #define ICONWINDOW_NODETAILVIEWCLASS
  15 //#define ICONWINDOW_BUFFERLIST
  16
  17 #ifdef __AROS__
  18 #define DEBUG 0
  19 #include <aros/debug.h>
  20 #endif
  21
  22 #include <exec/types.h>
  23 #include <libraries/mui.h>
  24
  25 #ifdef __AROS__
  26 #include <zune/customclasses.h>
  27 #else
  28 #include <zune_AROS/customclasses.h>
  29 #endif
  30
  31 #include <proto/utility.h>
  32
  33 #include <proto/graphics.h>
  34
  35 #include <proto/exec.h>
  36 #include <proto/datatypes.h>
  37
  38 #include <dos/dos.h>
  39 #include <proto/dos.h>
  40
  41 #include <proto/icon.h>
  42
  43 #include <stdio.h>
  44 #include <string.h>
  45
  46 #include <intuition/screens.h>
  47 #include <datatypes/pictureclass.h>
  48 #include <clib/macros.h>
  49
  50 #ifdef __AROS__
  51 #include <clib/alib_protos.h>
  52
  53 #include <prefs/wanderer.h>
  54 #else
  55 #include <prefs_AROS/wanderer.h>
  56 #endif
  57
  58 #if defined(__AMIGA__) && !defined(__PPC__)
  59 #define NO_INLINE_STDARG
  60 #endif
  61 #ifndef _PROTO_INTUITION_H
  62 #include <proto/intuition.h>
  63 #endif
  64 #include <proto/muimaster.h>
  65
  66 #include "Classes/iconlist.h"
  67 #include "Classes/iconlistview.h"
  68 #include "Classes/iconlist_attributes.h"
  69 #include "wanderer.h"
  70 #include "wandererprefs.h"
  71
  72 #include "iconwindow.h"
  73 #include "iconwindow_attributes.h"
  74 #include "iconwindow_iconlist.h"
  75 #include "iconwindowbackfill.h"
  76
  77 #ifndef __AROS__
  78 #define DEBUG 1
  79
  80 #ifdef DEBUG
  81   #define D(x) if (DEBUG) x
  82   #ifdef __amigaos4__
  83   #define bug DebugPrintF
  84   #else
  85   #define bug kprintf
  86   #endif
  87 #else
  88   #define  D(...)
  89 #endif
  90 #endif
  91
  92 #if defined(ICONWINDOW_NODETAILVIEWCLASS)
  93 struct MUI_CustomClass *IconWindowDetailDrawerList_CLASS;
  94 #endif
  95
  96 #define WIWVERS       1
  97 #define WIWREV        0
  98
  99 /*** Private Global Data *********************************************************/
 100
 101 static struct List                      iconwindow_BackFillNodes;
 102 struct List                             iconwindow_Extensions;
 103 struct IconWindow_BackFill_Descriptor  *iconwindow_BackFill_Active;
 104
 105 static const char __intern_wintitle_wanderer[] = "Wanderer";
 106
 107 /*** Hook functions *********************************************************/
 108
 109 ///IconWindow__HookFunc_PrefsUpdatedFunc()
 110 #ifdef __AROS__
 111 AROS_UFH3(
 112     void, IconWindow__HookFunc_PrefsUpdatedFunc,
 113     AROS_UFHA(struct Hook *,    hook,   A0),
 114     AROS_UFHA(APTR *,           obj,    A2),
 115     AROS_UFHA(APTR,             param,  A1)
 116 )
 117 {
 118 #else
 119 HOOKPROTO(IconWindow__HookFunc_PrefsUpdatedFunc, void, APTR *obj, APTR param)
 120 {
 121 #endif
 122     AROS_USERFUNC_INIT
 123
 124     /* Get our private data */
 125     Object *self = ( Object *)obj;
 126     Class *CLASS = *( Class **)param;
 127     IPTR changed_state;
 128
 129     SETUP_ICONWINDOW_INST_DATA;
 130
 131     D(bug("[Wanderer:IconWindow]: %s()\n", __PRETTY_FUNCTION__));
 132
 133     changed_state = 0;
 134     GET(self, MUIA_IconWindow_Changed, &changed_state);
 135
 136     if ((changed_state) && (data->iwd_IconListObj))
 137     {
 138         D(bug("[Wanderer:IconWindow] %s: Window contents have changed .. updating display ..\n", __PRETTY_FUNCTION__));
 139         DoMethod(data->iwd_IconListObj, MUIM_IconList_Update);
 140         DoMethod(data->iwd_IconListObj, MUIM_IconList_Sort);
 141         SET(self, MUIA_IconWindow_Changed, FALSE);
 142     }
 143
 144     AROS_USERFUNC_EXIT
 145 }
 146 #ifndef __AROS__
 147 MakeStaticHook(iwd_PrefsUpdated_hook,IconWindow__HookFunc_PrefsUpdatedFunc);
 148 #endif
 149 ///
 150
 151 ///IconWindow__HookFunc_ProcessBackgroundFunc()
 152 #ifdef __AROS__
 153 AROS_UFH3(
 154     void, IconWindow__HookFunc_ProcessBackgroundFunc,
 155     AROS_UFHA(struct Hook *,    hook,   A0),
 156     AROS_UFHA(APTR *,           obj,    A2),
 157     AROS_UFHA(APTR,             param,  A1)
 158 )
 159 {
 160 #else
 161 HOOKPROTO(IconWindow__HookFunc_ProcessBackgroundFunc, void, APTR *obj, APTR param)
 162 {
 163 #endif
 164     AROS_USERFUNC_INIT
 165
 166     /* Get our private data */
 167     Object      *self = ( Object *)obj,
 168                 *prefs = NULL;
 169     Class *CLASS = *( Class **)param;
 170
 171     SETUP_ICONWINDOW_INST_DATA;
 172
 173     D(bug("[Wanderer:IconWindow]: %s()\n", __PRETTY_FUNCTION__));
 174
 175     DoMethod(self, MUIM_IconWindow_BackFill_ProcessBackground, data->iwd_BackFillInfo, data->iwd_RootViewObj);
 176
 177     GET(_app(self), MUIA_Wanderer_Prefs, &prefs);
 178
 179     if (prefs)
 180     {
 181         //BOOL    options_changed = FALSE;
 182         IPTR  prefs_Processing = 0;
 183
 184         GET(prefs, MUIA_WandererPrefs_Processing, &prefs_Processing);
 185         if (!prefs_Processing)
 186         {
 187 #warning "TODO: We arent in prefs-processing so cause an update!"
 188         }
 189     }
 190
 191     AROS_USERFUNC_EXIT
 192 }
 193 #ifndef __AROS__
 194 MakeStaticHook(iwd_ProcessBackground_hook,IconWindow__HookFunc_ProcessBackgroundFunc);
 195 #endif
 196 ///
 197
 198 ///IconWindow__HookFunc_WandererBackFillFunc()
 199 #ifdef __AROS__
 200 AROS_UFH3(
 201     void, IconWindow__HookFunc_WandererBackFillFunc,
 202     AROS_UFHA(struct Hook *,        hook,   A0),
 203     AROS_UFHA(struct RastPort *,    RP,    A2),
 204     AROS_UFHA(struct BackFillMsg *, BFM,  A1)
 205 )
 206 {
 207 #else
 208 HOOKPROTO(IconWindow__HookFunc_WandererBackFillFunc, void, struct RastPort *RP, struct BackFillMsg *BFM)
 209 {
 210 #endif
 211     AROS_USERFUNC_INIT
 212
 213     struct IconWindow_BackFillHookData *HookData = NULL;
 214
 215 D(bug("[Wanderer:IconWindow]: %s()\n", __PRETTY_FUNCTION__));
 216
 217     if ((HookData = hook->h_Data) && (iconwindow_BackFill_Active != NULL))
 218     {
 219         Class                              *CLASS = HookData->bfhd_IWClass;
 220         Object                 *self = HookData->bfhd_IWObject;
 221
 222         SETUP_ICONWINDOW_INST_DATA;
 223
 224         struct RastPort           *DrawBackGround_RastPort = NULL;
 225         struct IconWindowBackFillMsg  DrawBackGround_BackFillMsg;
 226
 227         GET(data->iwd_IconListObj, MUIA_IconList_BufferRastport, &DrawBackGround_RastPort);
 228
 229         if (DrawBackGround_RastPort != NULL)
 230         {
 231             if ((DrawBackGround_BackFillMsg.Layer = DrawBackGround_RastPort->Layer) == NULL)
 232             {
 233   D(bug("[Wanderer:IconWindow] %s: Rastport Layer = NULL!\n", __PRETTY_FUNCTION__));
 234             }
 235
 236             GET(data->iwd_IconListObj,MUIA_IconList_BufferLeft, &DrawBackGround_BackFillMsg.AreaBounds.MinX);
 237             GET(data->iwd_IconListObj,MUIA_IconList_BufferTop, &DrawBackGround_BackFillMsg.AreaBounds.MinY);
 238             GET(data->iwd_IconListObj,MUIA_IconList_BufferWidth, &DrawBackGround_BackFillMsg.AreaBounds.MaxX);
 239             GET(data->iwd_IconListObj,MUIA_IconList_BufferHeight, &DrawBackGround_BackFillMsg.AreaBounds.MaxY);
 240
 241             DrawBackGround_BackFillMsg.AreaBounds.MaxX += DrawBackGround_BackFillMsg.AreaBounds.MinX - 1;
 242             DrawBackGround_BackFillMsg.AreaBounds.MaxY += DrawBackGround_BackFillMsg.AreaBounds.MinY - 1;
 243
 244             DrawBackGround_BackFillMsg.DrawBounds.MinX = BFM->Bounds.MinX;
 245             DrawBackGround_BackFillMsg.DrawBounds.MinY = BFM->Bounds.MinY;
 246             DrawBackGround_BackFillMsg.DrawBounds.MaxX = BFM->Bounds.MaxX;
 247             DrawBackGround_BackFillMsg.DrawBounds.MaxY = BFM->Bounds.MaxY;
 248
 249             /* Offset into source image (ala scroll bar position) */
 250             DrawBackGround_BackFillMsg.OffsetX = BFM->OffsetX;
 251             DrawBackGround_BackFillMsg.OffsetY = BFM->OffsetY;
 252             DoMethod(self, MUIM_IconWindow_BackFill_DrawBackground, data->iwd_BackFillInfo, &DrawBackGround_BackFillMsg, DrawBackGround_RastPort);
 253         }
 254
 255     }
 256
 257     AROS_USERFUNC_EXIT
 258 }
 259 #ifndef __AROS__
 260 MakeStaticHook(Hook_WandererBackFillFunc,IconWindow__HookFunc_WandererBackFillFunc);
 261 #endif
 262 ///
 263
 264 ///OM_NEW()
 265 Object *IconWindow__OM_NEW(Class *CLASS, Object *self, struct opSet *message)
 266 {
 267     struct iconWindow_Extension *iw_Extension = NULL;
 268
 269     struct Screen               *_newIconWin__Screen = NULL;
 270     Object                      *_newIconWin__IconListObj = NULL,
 271                                 *_newIconWin__RootViewObj = NULL,
 272
 273                                 *_newIconWin__TopPanelContainerObj = NULL,
 274                                 *_newIconWin__TopPanelRootGroupObj = NULL,
 275                                 *_newIconWin__TopPanelSpacerObj = NULL,
 276
 277                                 *_newIconWin__LeftPanelContainerObj = NULL,
 278                                 *_newIconWin__LeftPanelRootGroupObj = NULL,
 279                                 *_newIconWin__LeftPanelSpacerObj = NULL,
 280
 281                                 *_newIconWin__BottomPanelContainerObj = NULL,
 282                                 *_newIconWin__BottomPanelRootGroupObj = NULL,
 283                                 *_newIconWin__BottomPanelSpacerObj = NULL,
 284
 285                                 *prefs = NULL;
 286
 287     char                        *_newIconWin__Title = NULL;
 288
 289     UBYTE                       _newIconWin__VOLVIEWMODE = MUIV_IconWindow_VolumeInfoMode_ShowAllIfNoInfo;
 290
 291     BOOL                        isRoot = FALSE,
 292                                 isBackdrop = FALSE;
 293
 294     struct Hook                 *actionHook = NULL;
 295     struct TextFont             *_newIconWin__WindowFont = NULL;
 296
 297     struct Hook                 *_newIconWin__BackFillHook = NULL;
 298
 299     IPTR                        WindowBF_TAG = (IPTR)TAG_IGNORE;
 300
 301     IPTR                        _newIconWin__WindowWidth = 0;
 302     IPTR                        _newIconWin__WindowHeight = 0;
 303     IPTR                        _newIconWin__WindowLeft = 0;
 304     IPTR                        _newIconWin__WindowTop = 0;
 305
 306     IPTR                        _newIconWin__FSNotifyPort = (IPTR)NULL;
 307     struct MUI_CustomClass      *iconviewclass = NULL;
 308 #if defined(ICONWINDOW_NODETAILVIEWCLASS)
 309     IconWindowDetailDrawerList_CLASS = IconWindowDrawerList_CLASS;
 310 #endif
 311
 312 D(bug("[Wanderer:IconWindow]: %s()\n", __PRETTY_FUNCTION__));
 313
 314     /* More than one GetTagData is not very efficient, however since this isn't called very often... */
 315     isBackdrop = (BOOL)GetTagData(MUIA_IconWindow_IsBackdrop, (IPTR)FALSE, message->ops_AttrList);
 316
 317     isRoot = (BOOL)GetTagData(MUIA_IconWindow_IsRoot, (IPTR)FALSE, message->ops_AttrList);
 318
 319     actionHook = (struct Hook *)GetTagData(MUIA_IconWindow_ActionHook, (IPTR) NULL, message->ops_AttrList);
 320     _newIconWin__WindowFont = (struct TextFont *)GetTagData(MUIA_IconWindow_Font, (IPTR) NULL, message->ops_AttrList);
 321     prefs = (Object *)GetTagData(MUIA_Wanderer_Prefs, (IPTR) NULL, message->ops_AttrList);
 322
 323     _newIconWin__FSNotifyPort = (IPTR)GetTagData(MUIA_Wanderer_FileSysNotifyPort, (IPTR) NULL, message->ops_AttrList);
 324
 325     /* Request the screen we should use .. */
 326     if (!(_newIconWin__Screen = (struct Screen *)GetTagData(MUIA_Wanderer_Screen, (IPTR) NULL, message->ops_AttrList)))
 327     {
 328             D(bug("[Wanderer:IconWindow] %s: NO SCREEN SET!\n", __PRETTY_FUNCTION__));
 329             return NULL;
 330     }
 331 D(bug("[Wanderer:IconWindow] %s: Screen @ 0x%p\n", __PRETTY_FUNCTION__, _newIconWin__Screen));
 332
 333     if ((_newIconWin__BackFillHook = AllocVec(sizeof(struct Hook), MEMF_CLEAR|MEMF_PUBLIC))!=NULL)
 334     {
 335 D(bug("[Wanderer:IconWindow] %s: Allocated WindowBackFillHook @ 0x%p\n", __PRETTY_FUNCTION__, _newIconWin__BackFillHook));
 336
 337 #ifdef __AROS__
 338             _newIconWin__BackFillHook->h_Entry = ( HOOKFUNC )IconWindow__HookFunc_WandererBackFillFunc;
 339 #else
 340             _newIconWin__BackFillHook = &Hook_WandererBackFillFunc;
 341 #endif
 342
 343 //#if defined(__MORPHOS__)
 344 //        WindowBF_TAG = MUIA_Window_BackFillHook;
 345 //#else
 346         WindowBF_TAG = (APTR)WA_BackFill;
 347 //#endif
 348     }
 349
 350     if (isRoot)
 351     {
 352         iconviewclass = IconWindowVolumeList_CLASS;
 353         _newIconWin__IconListObj = (Object *)NewObject(iconviewclass->mcc_Class, NULL,
 354                                                     MUIA_Font, (IPTR)_newIconWin__WindowFont,
 355                                                     TAG_DONE);
 356
 357         _newIconWin__WindowWidth = _newIconWin__Screen->Width;
 358         _newIconWin__WindowHeight = _newIconWin__Screen->Height;
 359         DOPENWINDOW(bug("[Wanderer:IconWindow] %s: Screen dimensions ..  %ld x %ld\n", __PRETTY_FUNCTION__, _newIconWin__WindowWidth, _newIconWin__WindowHeight));
 360
 361         if (isBackdrop)
 362         {
 363             DOPENWINDOW(bug("[Wanderer:IconWindow] %s: BACKDROP ROOT Window\n", __PRETTY_FUNCTION__));
 364             _newIconWin__Title = NULL;
 365         }
 366         else
 367         {
 368             DOPENWINDOW(bug("[Wanderer:IconWindow] %s: Plain ROOT Window\n", __PRETTY_FUNCTION__));
 369             _newIconWin__Title = __intern_wintitle_wanderer;
 370         }
 371
 372         _newIconWin__WindowTop = _newIconWin__Screen->BarHeight + 1;
 373         _newIconWin__WindowLeft = 0;
 374
 375         _newIconWin__WindowHeight -= _newIconWin__WindowTop;
 376     }
 377     else
 378     {
 379         struct DiskObject       *drawericon = NULL;
 380         IPTR                    geticon_error = 0, geticon_isdefault = 0;
 381         IPTR                    _newIconWin__TitleLen = 0;
 382         IPTR                    current_DispFlags = 0, current_SortFlags = 0;
 383         IPTR                    icon__DispFlags = 0,icon__DispFlagMask = ~0;
 384
 385         _newIconWin__WindowTop = MUIV_Window_TopEdge_Centered;
 386         _newIconWin__WindowLeft = MUIV_Window_LeftEdge_Centered;
 387         _newIconWin__WindowWidth = 300;
 388         _newIconWin__WindowHeight = 300;
 389
 390         _newIconWin__Title = (STRPTR) GetTagData(MUIA_IconWindow_Location, (IPTR)NULL, message->ops_AttrList);
 391         _newIconWin__TitleLen = strlen(_newIconWin__Title);
 392
 393         if (_newIconWin__Title[_newIconWin__TitleLen - 1] == ':')
 394         {
 395 D(bug("[Wanderer:IconWindow] %s: Opening Volume Root Window '%s'\n", __PRETTY_FUNCTION__, _newIconWin__Title));
 396         }
 397         else
 398         {
 399 D(bug("[Wanderer:IconWindow] %s: Opening Drawer Window '%s'\n", __PRETTY_FUNCTION__, _newIconWin__Title));
 400         }
 401
 402         drawericon = GetIconTags(_newIconWin__Title,
 403                                 ICONGETA_FailIfUnavailable, FALSE,
 404                                 ICONGETA_IsDefaultIcon, &geticon_isdefault,
 405                                 ICONA_ErrorCode, &geticon_error,
 406                                 TAG_DONE);
 407
 408         if ((drawericon) && (drawericon->do_DrawerData))
 409         {
 410 D(bug("[Wanderer:IconWindow] %s: Directory Icon has DRAWER data!\n", __PRETTY_FUNCTION__));
 411             _newIconWin__WindowTop = drawericon->do_DrawerData->dd_NewWindow.TopEdge;
 412             _newIconWin__WindowLeft = drawericon->do_DrawerData->dd_NewWindow.LeftEdge;
 413             _newIconWin__WindowWidth = drawericon->do_DrawerData->dd_NewWindow.Width;
 414             _newIconWin__WindowHeight = drawericon->do_DrawerData->dd_NewWindow.Height;
 415         }
 416
 417         iconviewclass = IconWindowDrawerList_CLASS;
 418         if ((drawericon) && (drawericon->do_Gadget.UserData > 0))
 419         {
 420 D(bug("[Wanderer:IconWindow] %s: Directory Icons has OS 2.x/3.x data: FLAGS %x [\n", __PRETTY_FUNCTION__, drawericon->do_DrawerData->dd_Flags));
 421             switch (drawericon->do_DrawerData->dd_Flags)
 422             {
 423                 case 0:
 424                 {
 425                     D(bug("Default"));
 426                     break;
 427                 }
 428                 case 1:
 429                 {
 430                     D(bug("Show only icons"));
 431                     icon__DispFlags |= ICONLIST_DISP_SHOWINFO;
 432                     break;
 433                 }
 434                 case 2:
 435                 {
 436                     D(bug("Show all files"));
 437                     icon__DispFlagMask &= ~ICONLIST_DISP_SHOWINFO;
 438                     break;
 439                 }
 440                 case 3:
 441                 {
 442                     D(bug("Show all files"));
 443                     icon__DispFlags |= ICONLIST_DISP_SHOWHIDDEN;
 444                     icon__DispFlagMask &= ~ICONLIST_DISP_SHOWINFO;
 445                     break;
 446                 }
 447                 default:
 448                 {
 449                     D(bug("INVALID"));
 450                 }
 451             }
 452
 453 D(bug("] VIEWMODES %x [", drawericon->do_DrawerData->dd_ViewModes));
 454
 455             switch (drawericon->do_DrawerData->dd_ViewModes)
 456             {
 457                 case 0:
 458                 {
 459                     D(bug("Default (inherit from parent)"));
 460                     break;
 461                 }
 462                 case 1:
 463                 {
 464                     D(bug("View as icons"));
 465                     break;
 466                 }
 467                 case 2:
 468                 {
 469                     D(bug("View as text, sorted by name"));
 470                     iconviewclass = IconWindowDetailDrawerList_CLASS;
 471                     break;
 472                 }
 473                 case 3:
 474                 {
 475                     D(bug("View as text, sorted by date"));
 476                     iconviewclass = IconWindowDetailDrawerList_CLASS;
 477                     break;
 478                 }
 479                 case 4:
 480                 {
 481                     D(bug("View as text, sorted by size"));
 482                     iconviewclass = IconWindowDetailDrawerList_CLASS;
 483                     break;
 484                 }
 485                 case 5:
 486                 {
 487                     D(bug("View as text, sorted by type"));
 488                     iconviewclass = IconWindowDetailDrawerList_CLASS;
 489                     break;
 490                 }
 491                 default:
 492                 {
 493                     D(bug("INVALID"));
 494                 }
 495             }
 496 D(bug("]\n"));
 497         }
 498
 499         if ((_newIconWin__Title[_newIconWin__TitleLen - 1] == ':') &&
 500                 (((geticon_isdefault) && (_newIconWin__VOLVIEWMODE == MUIV_IconWindow_VolumeInfoMode_ShowAllIfNoInfo)) ||
 501                 (_newIconWin__VOLVIEWMODE == MUIV_IconWindow_VolumeInfoMode_ShowAll)))
 502         {
 503 D(bug("[Wanderer:IconWindow] %s: setting 'SHOW ALL FILES'\n", __PRETTY_FUNCTION__));
 504                 icon__DispFlagMask &= ~ICONLIST_DISP_SHOWINFO;
 505         }
 506
 507         _newIconWin__IconListObj = (Object *) NewObject(iconviewclass->mcc_Class, NULL,
 508                                                                  MUIA_Font, (IPTR)_newIconWin__WindowFont,
 509                                                                  MUIA_IconDrawerList_Drawer, (IPTR) _newIconWin__Title,
 510                                                                  MUIA_Wanderer_FileSysNotifyPort, _newIconWin__FSNotifyPort,
 511                                                                 TAG_DONE);
 512
 513         GET(_newIconWin__IconListObj, MUIA_IconList_DisplayFlags, &current_DispFlags);
 514         SET(_newIconWin__IconListObj, MUIA_IconList_DisplayFlags, ((current_DispFlags & icon__DispFlagMask)|icon__DispFlags));
 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     DOPENWINDOW(bug("[Wanderer:IconWindow] %s: Window Co-ords %d,%d [%d x %d]\n", __PRETTY_FUNCTION__, _newIconWin__WindowLeft, _newIconWin__WindowTop, _newIconWin__WindowWidth, _newIconWin__WindowHeight));
 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                 DoMethod(data->iwd_IconListObj, MUIM_IconList_Sort);
 936                 return rv;
 937             }
 938             break;
 939
 940         case MUIA_Window_Activate:
 941             if (data->iwd_IconListObj)
 942                 GET(data->iwd_IconListObj, MUIA_IconList_FocusIcon, &focusicon);
 943
 944             break;
 945
 946         case MUIA_IconWindow_Font:
 947             data->iwd_WindowFont = (struct TextFont  *)tag->ti_Data;
 948             D(bug("[Wanderer:IconWindow] %s: MUIA_IconWindow_Font [font @ 0x%p]\n", __PRETTY_FUNCTION__, data->iwd_WindowFont));
 949
 950             if (!data->iwd_WindowFont)
 951                 SetFont(_rp(self), data->iwd_WindowFont);
 952
 953             break;
 954
 955         case MUIA_IconWindow_Location:
 956             D(bug("[Wanderer:IconWindow] %s: MUIA_IconWindow_Location [drawer '%s']\n", __PRETTY_FUNCTION__, data->iwd_DirectoryPath));
 957
 958             if (!(data->iwd_Flags & IWDFLAG_ISROOT))
 959             {
 960                 strcpy(data->iwd_DirectoryPath, (STRPTR)tag->ti_Data);
 961                 SET(self, MUIA_Window_Title, (IPTR)data->iwd_DirectoryPath);
 962                 SET(data->iwd_IconListObj, MUIA_IconDrawerList_Drawer, (IPTR)data->iwd_DirectoryPath);
 963             }
 964             break;
 965
 966         case MUIA_IconWindow_BackgroundAttrib:
 967             D(bug("[Wanderer:IconWindow] %s: MUIA_IconWindow_BackgroundAttrib (not implemented)\n", __PRETTY_FUNCTION__));
 968             break;
 969
 970         }
 971     }
 972
 973     rv = DoSuperMethodA(CLASS, self, (Msg) message);
 974
 975     if (data->iwd_Flags & IWDFLAG_SETUP)
 976     {
 977         ForeachNode(&iconwindow_Extensions, iw_Extension)
 978         {
 979             D(bug("[Wanderer:IconWindow] %s: Checking '%s'\n", __PRETTY_FUNCTION__, iw_Extension->iwe_Node.ln_Name));
 980             iw_Extension->iwe_Set(CLASS, self, message);
 981         }
 982     }
 983
 984     if (UpdateIconlist)
 985     {
 986         DoMethod(data->iwd_IconListObj, MUIM_IconList_Update);
 987         DoMethod(data->iwd_IconListObj, MUIM_IconList_Sort);
 988     }
 989
 990     if (focusicon)
 991     {
 992         D(bug("[Wanderer:IconWindow] %s: Updating focused icon (@ 0x%p)\n", __PRETTY_FUNCTION__, focusicon));
 993         //MUI_Redraw(data->iwd_IconListObj, MADF_DRAWOBJECT);
 994     }
 995
 996     return rv;
 997 }
 998 ///
 999
1000 ///OM_GET()
1001 IPTR IconWindow__OM_GET(Class *CLASS, Object *self, struct opGet *message)
1002 {
1003     SETUP_ICONWINDOW_INST_DATA;
1004     struct iconWindow_Extension *iw_Extension = NULL;
1005     IPTR *store = message->opg_Storage;
1006     IPTR  rv    = TRUE;
1007
1008     switch (message->opg_AttrID)
1009     {
1010     case MUIA_IconWindow_Changed:
1011         *store = (IPTR)(data->iwd_Flags & IWDFLAG_NEEDSUPDATE);
1012         break;
1013
1014     case MUIA_IconWindow_Window:
1015         *store = (IPTR)self;
1016         break;
1017
1018     case MUIA_IconWindow_Location:
1019         *store = !(data->iwd_Flags & IWDFLAG_ISROOT)
1020             ? XGET(data->iwd_IconListObj, MUIA_IconDrawerList_Drawer)
1021             : (IPTR)NULL;
1022         break;
1023
1024     case MUIA_IconWindow_IconList:
1025         *store = (IPTR)data->iwd_IconListObj;
1026         break;
1027
1028     case MUIA_IconWindow_IsRoot:
1029         *store = (IPTR)(data->iwd_Flags & IWDFLAG_ISROOT);
1030         break;
1031
1032     case MUIA_IconWindow_IsBackdrop:
1033         *store = (IPTR)(data->iwd_Flags & IWDFLAG_ISBACKDROP);
1034         break;
1035
1036     case MUIA_IconWindow_BackFillData:
1037         *store = (IPTR)data->iwd_BackFillInfo;
1038         break;
1039
1040     case MUIA_IconWindow_BackgroundAttrib:
1041         *store = (IPTR)data->iwd_ViewSettings_Attrib;
1042         break;
1043
1044     case MUIA_Version:
1045         *store = (IPTR)WIWVERS;
1046         break;
1047
1048     case MUIA_Revision:
1049         *store = (IPTR)WIWREV;
1050         break;
1051
1052     default:
1053         rv = FALSE;
1054     }
1055
1056     if (!rv)
1057         rv = DoSuperMethodA(CLASS, self, (Msg) message);
1058
1059     if (!rv)
1060     {
1061         ForeachNode(&iconwindow_Extensions, iw_Extension)
1062         {
1063             D(bug("[Wanderer:IconWindow] %s: Checking '%s'\n", __PRETTY_FUNCTION__, iw_Extension->iwe_Node.ln_Name));
1064             if ((rv = iw_Extension->iwe_Get(CLASS, self, message)) == TRUE)
1065                 break;
1066         }
1067     }
1068
1069     return rv;
1070 }
1071 ///
1072
1073 ///IconWindow__MUIM_Window_Setup()
1074 IPTR IconWindow__MUIM_Window_Setup
1075 (
1076     Class *CLASS, Object *self, Msg message
1077 )
1078 {
1079     SETUP_ICONWINDOW_INST_DATA;
1080
1081     Object *prefs = NULL;
1082
1083     D(bug("[Wanderer:IconWindow]: %s()\n", __PRETTY_FUNCTION__));
1084
1085     if (!DoSuperMethodA(CLASS, self, message)) return FALSE;
1086
1087     if (iconwindow_BackFill_Active)
1088     {
1089         data->iwd_BackFillInfo =(struct BackFillInfo *) DoMethod(self, MUIM_IconWindow_BackFill_Setup);
1090         D(bug("[Wanderer:IconWindow] %s: Window BackFill_Data @ 0x%p for '%s'\n", __PRETTY_FUNCTION__, data->iwd_BackFillInfo, iconwindow_BackFill_Active->bfd_BackFillID));
1091     }
1092
1093     GET(_app(self), MUIA_Wanderer_Prefs, &prefs);
1094
1095     D(bug("[Wanderer:IconWindow] %s: App PrefsObj @ 0x%p\n", __PRETTY_FUNCTION__, prefs));
1096
1097     if ((prefs) && (data->iwd_ViewSettings_PrefsNotificationObject))
1098     {
1099         D(bug("[Wanderer:IconWindow] %s: Setting up window background change hook\n", __PRETTY_FUNCTION__));
1100
1101         /* Set-up a hook to call ProcessBackground on prefs notification */
1102         DoMethod
1103           (
1104             data->iwd_ViewSettings_PrefsNotificationObject, MUIM_Notify, MUIA_Background, MUIV_EveryTime,
1105             (IPTR) self, 3,
1106             MUIM_CallHook, &data->iwd_ProcessBackground_hook, (IPTR)CLASS
1107           );
1108
1109         if ((data->iwd_Flags & IWDFLAG_ISROOT))
1110         {
1111             DoMethod
1112               (
1113                 data->iwd_ViewSettings_PrefsNotificationObject, MUIM_Notify, MUIA_IconWindowExt_ImageBackFill_BGRenderMode, MUIV_EveryTime,
1114                 (IPTR) self, 3,
1115                 MUIM_CallHook, &data->iwd_ProcessBackground_hook, (IPTR)CLASS
1116               );
1117         }
1118
1119         DoMethod
1120           (
1121             data->iwd_ViewSettings_PrefsNotificationObject, MUIM_Notify, MUIA_IconWindowExt_ImageBackFill_BGTileMode, MUIV_EveryTime,
1122             (IPTR) self, 3,
1123             MUIM_CallHook, &data->iwd_ProcessBackground_hook, (IPTR)CLASS
1124           );
1125
1126         DoMethod
1127           (
1128             data->iwd_ViewSettings_PrefsNotificationObject, MUIM_Notify, MUIA_IconWindowExt_ImageBackFill_BGXOffset, MUIV_EveryTime,
1129             (IPTR) self, 3,
1130             MUIM_CallHook, &data->iwd_ProcessBackground_hook, (IPTR)CLASS
1131           );
1132
1133         DoMethod
1134           (
1135             data->iwd_ViewSettings_PrefsNotificationObject, MUIM_Notify, MUIA_IconWindowExt_ImageBackFill_BGYOffset, MUIV_EveryTime,
1136             (IPTR) self, 3,
1137             MUIM_CallHook, &data->iwd_ProcessBackground_hook, (IPTR)CLASS
1138           );
1139     }
1140
1141     D(bug("[Wanderer:IconWindow] %s: Setup complete!\n", __PRETTY_FUNCTION__));
1142
1143     return TRUE;
1144 }
1145 ///
1146
1147 ///IconWindow__MUIM_Window_Cleanup()
1148 IPTR IconWindow__MUIM_Window_Cleanup
1149 (
1150     Class *CLASS, Object *self, Msg message
1151 )
1152 {
1153     SETUP_ICONWINDOW_INST_DATA;
1154
1155     D(bug("[Wanderer:IconWindow]: %s()\n", __PRETTY_FUNCTION__));
1156
1157     if (data->iwd_BackFillInfo)
1158     {
1159         DoMethod(self, MUIM_IconWindow_BackFill_Cleanup, data->iwd_BackFillInfo);
1160         data->iwd_BackFillInfo = NULL;
1161     }
1162
1163     if (data->iwd_ViewSettings_PrefsNotificationObject)
1164     {
1165         DoMethod
1166           (
1167             data->iwd_ViewSettings_PrefsNotificationObject,
1168             MUIM_KillNotifyObj, MUIA_IconWindowExt_ImageBackFill_BGYOffset, (IPTR) self
1169           );
1170
1171         DoMethod
1172           (
1173             data->iwd_ViewSettings_PrefsNotificationObject,
1174             MUIM_KillNotifyObj, MUIA_IconWindowExt_ImageBackFill_BGXOffset, (IPTR) self
1175           );
1176
1177         DoMethod
1178           (
1179             data->iwd_ViewSettings_PrefsNotificationObject,
1180             MUIM_KillNotifyObj, MUIA_IconWindowExt_ImageBackFill_BGTileMode, (IPTR) self
1181           );
1182
1183         if ((data->iwd_Flags & IWDFLAG_ISROOT))
1184         {
1185             DoMethod
1186               (
1187                 data->iwd_ViewSettings_PrefsNotificationObject,
1188                 MUIM_KillNotifyObj, MUIA_IconWindowExt_ImageBackFill_BGRenderMode, (IPTR) self
1189               );
1190         }
1191
1192         DoMethod
1193           (
1194             data->iwd_ViewSettings_PrefsNotificationObject,
1195             MUIM_KillNotifyObj, MUIA_Background, (IPTR) self
1196           );
1197     }
1198     return DoSuperMethodA(CLASS, self, message);
1199 }
1200 ///
1201
1202 ///IconWindow__MUIM_IconWindow_DoubleClicked()
1203 IPTR IconWindow__MUIM_IconWindow_DoubleClicked
1204 (
1205     Class *CLASS, Object *self, Msg message
1206 )
1207 {
1208     SETUP_ICONWINDOW_INST_DATA;
1209
1210     D(bug("[Wanderer:IconWindow]: %s()\n", __PRETTY_FUNCTION__));
1211
1212     if (data->iwd_ActionHook)
1213     {
1214         struct IconWindow_ActionMsg msg;
1215         msg.type     = ICONWINDOW_ACTION_OPEN;
1216         msg.iconlist = data->iwd_IconListObj;
1217         msg.isroot   = (data->iwd_Flags & IWDFLAG_ISROOT);
1218         msg.click    = NULL;
1219         CallHookPkt(data->iwd_ActionHook, self, &msg);
1220     }
1221
1222     return TRUE;
1223 }
1224 ///
1225
1226 ///IconWindow__MUIM_IconWindow_Clicked()
1227 IPTR IconWindow__MUIM_IconWindow_Clicked
1228 (
1229     Class *CLASS, Object *self, Msg message
1230 )
1231 {
1232     SETUP_ICONWINDOW_INST_DATA;
1233
1234     D(bug("[Wanderer:IconWindow]: %s()\n", __PRETTY_FUNCTION__));
1235
1236     if (data->iwd_ActionHook)
1237     {
1238         struct IconWindow_ActionMsg msg;
1239         msg.type     = ICONWINDOW_ACTION_CLICK;
1240         msg.iconlist = data->iwd_IconListObj;
1241         msg.isroot   = (data->iwd_Flags & IWDFLAG_ISROOT);
1242         GET(data->iwd_IconListObj, MUIA_IconList_Clicked, &msg.click);
1243         CallHookPkt(data->iwd_ActionHook, self, &msg);
1244     }
1245
1246     return TRUE;
1247 }
1248 ///
1249
1250 ///IconWindow__MUIM_IconWindow_IconsDropped()
1251 IPTR IconWindow__MUIM_IconWindow_IconsDropped
1252 (
1253     Class *CLASS, Object *self, Msg message
1254 )
1255 {
1256     SETUP_ICONWINDOW_INST_DATA;
1257
1258     D(bug("[Wanderer:IconWindow]: %s()\n", __PRETTY_FUNCTION__));
1259
1260     if (data->iwd_ActionHook)
1261     {
1262         struct IconWindow_ActionMsg msg;
1263         msg.type     = ICONWINDOW_ACTION_ICONDROP;
1264         msg.iconlist = data->iwd_IconListObj;
1265         msg.isroot   = (data->iwd_Flags & IWDFLAG_ISROOT);
1266         GET(data->iwd_IconListObj, MUIA_IconList_IconsDropped, &msg.drop);
1267         if (msg.drop)
1268         {
1269             NNSET(data->iwd_IconListObj, MUIA_IconList_IconsDropped, NULL);
1270             CallHookPkt(data->iwd_ActionHook, self, &msg);
1271         }
1272     }
1273
1274     return TRUE;
1275 }
1276 ///
1277
1278 ///IconWindow__MUIM_IconWindow_AppWindowDrop()
1279 IPTR IconWindow__MUIM_IconWindow_AppWindowDrop
1280 (
1281     Class *CLASS, Object *self, Msg message
1282 )
1283 {
1284     SETUP_ICONWINDOW_INST_DATA;
1285
1286 D(bug("[Wanderer:IconWindow]: %s()\n", __PRETTY_FUNCTION__));
1287
1288     if (data->iwd_ActionHook)
1289     {
1290         struct IconWindow_ActionMsg msg;
1291         msg.type     = ICONWINDOW_ACTION_APPWINDOWDROP;
1292         msg.iconlist = data->iwd_IconListObj;
1293         msg.isroot   = (data->iwd_Flags & IWDFLAG_ISROOT);
1294         GET(data->iwd_IconListObj, MUIA_IconList_IconsDropped, &msg.drop);
1295         CallHookPkt(data->iwd_ActionHook, self, &msg);
1296     }
1297
1298     return TRUE;
1299 }
1300 ///
1301
1302 ///IconWindow__MUIM_IconWindow_Open()
1303 IPTR IconWindow__MUIM_IconWindow_Open
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 (!XGET(self, MUIA_Window_Open))
1313     {
1314         SET(self, MUIA_Window_Open, TRUE);
1315     }
1316
1317 D(bug("[Wanderer:IconWindow] %s: Setting window as active ..\n", __PRETTY_FUNCTION__));
1318     SET(self, MUIA_Window_Activate, TRUE);
1319
1320 D(bug("[Wanderer:IconWindow] %s: All done\n", __PRETTY_FUNCTION__));
1321
1322     return TRUE;
1323 }
1324 ///
1325
1326 ///IconWindow__MUIM_IconWindow_DirectoryUp()
1327 IPTR IconWindow__MUIM_IconWindow_DirectoryUp
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_DIRUP;
1340     msg.iconlist = data->iwd_IconListObj;
1341     msg.isroot   = (data->iwd_Flags & IWDFLAG_ISROOT);
1342     msg.click    = NULL;
1343     CallHookPkt(data->iwd_ActionHook, self, &msg);
1344
1345   }
1346
1347   return TRUE;
1348 }
1349 ///
1350
1351 ///IconWindow__MUIM_IconWindow_UnselectAll()
1352 IPTR IconWindow__MUIM_IconWindow_UnselectAll
1353 (
1354   Class *CLASS, Object *self, Msg message
1355 )
1356 {
1357   SETUP_ICONWINDOW_INST_DATA;
1358
1359   D(bug("[Wanderer:IconWindow]: %s()\n", __PRETTY_FUNCTION__));
1360
1361   DoMethod(data->iwd_IconListObj, MUIM_IconList_UnselectAll);
1362
1363   return TRUE;
1364 }
1365 ///
1366
1367 ///IconWindow__MUIM_IconWindow_Remove()
1368 IPTR IconWindow__MUIM_IconWindow_Remove
1369 (
1370   Class *CLASS, Object *self, Msg message
1371 )
1372 {
1373 //  SETUP_ICONWINDOW_INST_DATA;
1374
1375   D(bug("[Wanderer:IconWindow]: %s()\n", __PRETTY_FUNCTION__));
1376
1377   // Remove window
1378   SET( self, MUIA_Window_Open, FALSE );
1379   DoMethod ( _app(self), OM_REMMEMBER, self );
1380   DisposeObject(self);
1381
1382   return TRUE;
1383 }
1384 ///
1385
1386 /*** Stubs for Backfill Hooks ******************************************************************/
1387 ///IconWindow__MUIM_IconWindow_BackFill_Register()
1388 IPTR IconWindow__MUIM_IconWindow_BackFill_Register
1389 (
1390   Class *CLASS, Object *self, struct MUIP_IconWindow_BackFill_Register *message
1391 )
1392 {
1393 //    SETUP_ICONWINDOW_INST_DATA;
1394
1395   D(bug("[Wanderer:IconWindow]: %s('%s')\n", __PRETTY_FUNCTION__, message->register_Node->bfd_BackFillID));
1396
1397   AddTail(&iconwindow_BackFillNodes, (struct Node *)message->register_Node);
1398   if (iconwindow_BackFill_Active == NULL) iconwindow_BackFill_Active = message->register_Node;
1399
1400   return TRUE;
1401 }
1402 ///
1403
1404 ///IconWindow__MUIM_IconWindow_BackFill_Setup()
1405 IPTR IconWindow__MUIM_IconWindow_BackFill_Setup
1406 (
1407   Class *CLASS, Object *self, struct MUIP_IconWindow_BackFill_Setup *message
1408 )
1409 {
1410 //  SETUP_ICONWINDOW_INST_DATA;
1411
1412   D(bug("[Wanderer:IconWindow]: %s()\n", __PRETTY_FUNCTION__));
1413
1414   if (iconwindow_BackFill_Active == NULL) return FALSE;
1415
1416   return (iconwindow_BackFill_Active->bfd_MUIM_IconWindow_BackFill_Setup)(CLASS, self, message);
1417 }
1418 ///
1419
1420 ///IconWindow__MUIM_IconWindow_BackFill_Cleanup()
1421 IPTR IconWindow__MUIM_IconWindow_BackFill_Cleanup
1422 (
1423   Class *CLASS, Object *self, struct MUIP_IconWindow_BackFill_Cleanup *message
1424 )
1425 {
1426   //SETUP_ICONWINDOW_INST_DATA;
1427
1428   D(bug("[Wanderer:IconWindow]: %s()\n", __PRETTY_FUNCTION__));
1429
1430   if (iconwindow_BackFill_Active == NULL) return FALSE;
1431
1432   return (iconwindow_BackFill_Active->bfd_MUIM_IconWindow_BackFill_Cleanup)(CLASS, self, message);
1433 }
1434 ///
1435
1436 ///IconWindow__MUIM_IconWindow_BackFill_ProcessBackground()
1437 IPTR IconWindow__MUIM_IconWindow_BackFill_ProcessBackground
1438 (
1439   Class *CLASS, Object *self, struct MUIP_IconWindow_BackFill_ProcessBackground *message
1440 )
1441 {
1442   SETUP_ICONWINDOW_INST_DATA;
1443
1444   IPTR retVal = (IPTR)FALSE;
1445
1446   D(bug("[Wanderer:IconWindow]: %s()\n", __PRETTY_FUNCTION__));
1447
1448   if (iconwindow_BackFill_Active != NULL)
1449   {
1450     D(bug("[Wanderer:IconWindow] %s: Asking module @ 0x%p to process ..\n", __PRETTY_FUNCTION__, iconwindow_BackFill_Active));
1451     retVal = (iconwindow_BackFill_Active->bfd_MUIM_IconWindow_BackFill_ProcessBackground)(CLASS, self, message);
1452   }
1453
1454   if ((retVal == (IPTR)FALSE) && (data->iwd_RootViewObj != NULL))
1455   {
1456     Object                *IconWindowPB_PrefsObj = NULL;
1457
1458     D(bug("[Wanderer:IconWindow] %s: No BackFill module/ module cant render mode\n", __PRETTY_FUNCTION__));
1459     D(bug("[Wanderer:IconWindow] %s: Using default MUI functions ..\n", __PRETTY_FUNCTION__));
1460
1461     GET(_app(self), MUIA_Wanderer_Prefs, &IconWindowPB_PrefsObj);
1462     if (IconWindowPB_PrefsObj)
1463     {
1464       IPTR IconWindowPB_Background = 0;
1465       IPTR IconWindowPB_BGMode     = 0;
1466       IPTR IconWindowPB_BGTileMode = 0;
1467
1468       if ((IconWindowPB_Background = DoMethod(IconWindowPB_PrefsObj, MUIM_WandererPrefs_ViewSettings_GetAttribute, data->iwd_ViewSettings_Attrib, MUIA_Background)) != -1)
1469       {
1470         char *bgmode_string;
1471         BYTE this_mode;
1472
1473         if ((IconWindowPB_BGMode = DoMethod(IconWindowPB_PrefsObj, MUIM_WandererPrefs_ViewSettings_GetAttribute,
1474                         data->iwd_ViewSettings_Attrib, MUIA_IconWindowExt_ImageBackFill_BGRenderMode)) == -1)
1475           IconWindowPB_BGMode = IconWindowExt_ImageBackFill_RenderMode_Tiled;
1476
1477         if ((IconWindowPB_BGTileMode = DoMethod(IconWindowPB_PrefsObj, MUIM_WandererPrefs_ViewSettings_GetAttribute,
1478                                   data->iwd_ViewSettings_Attrib, MUIA_IconWindowExt_ImageBackFill_BGTileMode)) == -1)
1479           IconWindowPB_BGTileMode = IconWindowExt_ImageBackFill_TileMode_Float;
1480
1481         SET(data->iwd_RootViewObj, MUIA_Background, IconWindowPB_Background);
1482
1483         bgmode_string =(STRPTR) IconWindowPB_Background;
1484         this_mode = bgmode_string[0] - 48;
1485
1486         D(bug("[Wanderer:IconWindow] %s: MUI BG Mode = %d\n", __PRETTY_FUNCTION__, this_mode));
1487
1488         switch (this_mode)
1489         {
1490           case 5:
1491             //Image =D
1492             if (IconWindowPB_BGMode == IconWindowExt_ImageBackFill_RenderMode_Scale)
1493             {
1494               SET(data->iwd_RootViewObj, MUIA_IconListview_ScaledBackground, TRUE);
1495               break;
1496             }
1497             else
1498               SET(data->iwd_RootViewObj, MUIA_IconListview_ScaledBackground, FALSE);
1499
1500           case 0:
1501             //MUI Pattern
1502             if (IconWindowPB_BGTileMode == IconWindowExt_ImageBackFill_TileMode_Fixed)
1503               SET(data->iwd_RootViewObj, MUIA_IconListview_FixedBackground, TRUE);
1504             else
1505               SET(data->iwd_RootViewObj, MUIA_IconListview_FixedBackground, FALSE);
1506             break;
1507         }
1508       }
1509     }
1510     retVal = FALSE;
1511   }
1512
1513   return retVal;
1514 }
1515 ///
1516
1517 ///IconWindow__MUIM_IconWindow_BackFill_DrawBackground()
1518 IPTR IconWindow__MUIM_IconWindow_BackFill_DrawBackground
1519 (
1520   Class *CLASS, Object *self, struct MUIP_IconWindow_BackFill_DrawBackground *message
1521 )
1522 {
1523 //  SETUP_ICONWINDOW_INST_DATA;
1524
1525   D(bug("[Wanderer:IconWindow]: %s()\n", __PRETTY_FUNCTION__));
1526
1527   if (iconwindow_BackFill_Active == NULL) return FALSE;
1528
1529   return (iconwindow_BackFill_Active->bfd_MUIM_IconWindow_BackFill_DrawBackground)(CLASS, self, message);
1530 }
1531 ///
1532
1533 ///
1534 IPTR IconWindow__SetupClass()
1535 {
1536     D(bug("[Wanderer:IconWindow]: %s()\n", __PRETTY_FUNCTION__));
1537
1538     NewList(&iconwindow_BackFillNodes);
1539     D(bug("[Wanderer:IconWindow] %s: iconwindow_BackFillNodes @ %p\n", __PRETTY_FUNCTION__, &iconwindow_BackFillNodes));
1540     NewList(&iconwindow_Extensions);
1541     D(bug("[Wanderer:IconWindow] %s: iconwindow_Extensions @ %p\n", __PRETTY_FUNCTION__, &iconwindow_Extensions));
1542     iconwindow_BackFill_Active = NULL;
1543
1544     return TRUE;
1545 }
1546 ///
1547 /*** Setup ******************************************************************/
1548 ICONWINDOW_CUSTOMCLASS
1549 (
1550   IconWindow, NULL, MUIC_Window, NULL,
1551   OM_NEW,                                     struct opSet *,
1552   OM_DISPOSE,                         Msg,
1553   OM_SET,                                     struct opSet *,
1554   OM_GET,                                     struct opGet *,
1555   MUIM_Window_Setup,                          Msg,
1556   MUIM_Window_Cleanup,                        Msg,
1557   MUIM_IconWindow_Open,                       Msg,
1558   MUIM_IconWindow_UnselectAll,                Msg,
1559   MUIM_IconWindow_DoubleClicked,              Msg,
1560   MUIM_IconWindow_IconsDropped,               Msg,
1561   MUIM_IconWindow_Clicked,                    Msg,
1562   MUIM_IconWindow_DirectoryUp,                Msg,
1563   MUIM_IconWindow_AppWindowDrop,              Msg,
1564   MUIM_IconWindow_Remove,                     Msg,
1565   MUIM_IconWindow_BackFill_Register,          struct MUIP_IconWindow_BackFill_Register *,
1566   MUIM_IconWindow_BackFill_Setup,             struct MUIP_IconWindow_BackFill_Setup *,
1567   MUIM_IconWindow_BackFill_Cleanup,           struct MUIP_IconWindow_BackFill_Cleanup *,
1568   MUIM_IconWindow_BackFill_ProcessBackground, struct MUIP_IconWindow_BackFill_ProcessBackground *,
1569   MUIM_IconWindow_BackFill_DrawBackground,    struct MUIP_IconWindow_BackFill_DrawBackground *
1570 );
1571
1572 ADD2INIT(IconWindow__SetupClass, 0);
1573
1574 #ifndef __AROS__
1575 int initIconWindowClass(void)
1576 {
1577   IPTR ret1 = IconWindow_Initialize();
1578
1579   IPTR ret2 = IconWindow__SetupClass();
1580
1581   IPTR ret3 = ImageBackFill__SetupClass();
1582
1583   if (ret1 && ret2 && ret3)
1584     return TRUE;
1585   else
1586     return FALSE;
1587
1588 }
1589 #endif