workbench/system/Wanderer/iconwindow.c

   1 /*
   2     Copyright  2004-2006, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #define MUIMASTER_YES_INLINE_STDARG
   7
   8 #define ICONWINDOW_OPTION_NOSEARCHBUTTON
   9
  10 #define DEBUG 0
  11 #include <aros/debug.h>
  12
  13 #include <exec/types.h>
  14 #include <libraries/mui.h>
  15 #include <zune/customclasses.h>
  16
  17 #include <proto/utility.h>
  18 #include <proto/intuition.h>
  19 #include <proto/graphics.h>
  20 #include <proto/muimaster.h>
  21 #include <proto/exec.h>
  22 #include <proto/datatypes.h>
  23
  24 #include <dos/dos.h>
  25 #include <proto/dos.h>
  26
  27 #include <stdio.h>
  28 #include <string.h>
  29
  30 #include <intuition/screens.h>
  31 #include <datatypes/pictureclass.h>
  32 #include <clib/macros.h>
  33 #include <clib/alib_protos.h>
  34
  35 #include <prefs/wanderer.h>
  36
  37 #include "../../libs/muimaster/classes/iconlist.h"
  38 #include "../../libs/muimaster/classes/iconlist_attributes.h"
  39 #include "wanderer.h"
  40 #include "wandererprefs.h"
  41
  42 #include "iconwindow.h"
  43 #include "iconwindow_attributes.h"
  44 #include "iconwindowcontents.h"
  45 #include "iconwindowbackfill.h"
  46
  47 static char __intern_wintitle_wanderer[] = "Wanderer";
  48
  49 /*** Private Global Data *********************************************************/
  50
  51 static struct List                     iconwindow_BackFillNodes;
  52 struct IconWindow_BackFill_Descriptor  *iconwindow_BackFill_Active = NULL;
  53
  54 /*** Hook functions *********************************************************/
  55
  56 AROS_UFH3(
  57     void, IconWindow__HookFunc_ToolbarLocationStringFunc,
  58     AROS_UFHA(struct Hook *,    hook,   A0),
  59     AROS_UFHA(APTR *,           obj,    A2),
  60     AROS_UFHA(APTR,             param,  A1)
  61 )
  62 {
  63     AROS_USERFUNC_INIT
  64
  65     /* Get data */
  66     Object                *self = ( Object *)obj;
  67     Class                 *CLASS = *( Class **)param;
  68         STRPTR                str = NULL;
  69     BPTR                  fp = NULL;
  70     struct FileInfoBlock  *fib;
  71
  72 #warning "stegerg: doesn't allocate fib with AllocDOSObject"
  73
  74     SETUP_ICONWINDOW_INST_DATA;
  75
  76     /* Only change dir if it is a valid directory/volume */
  77     GET(data->iwd_Toolbar_LocationStringObj, MUIA_String_Contents, &str);
  78
  79 #warning "TODO: Signal that it is a wrong path"
  80     /* so that the user understands (here where we abort with return) */
  81
  82     fib = AllocDosObject(DOS_FIB, NULL);
  83     if (!fib)
  84         return;
  85
  86     if (!(fp = Lock(str, ACCESS_READ)))
  87     {
  88         FreeDosObject(DOS_FIB, fib);
  89         return;
  90     }
  91
  92     if (!(Examine(fp, fib)))
  93     {
  94         UnLock (fp );
  95         FreeDosObject(DOS_FIB, fib);
  96         return;
  97     }
  98
  99     /* Change directory! */
 100     if (fib->fib_DirEntryType >= 0)
 101         SET(self, MUIA_IconWindow_Location, (IPTR)str);
 102
 103     UnLock(fp);
 104
 105     FreeDosObject(DOS_FIB, fib);
 106
 107     AROS_USERFUNC_EXIT
 108 }
 109
 110
 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     AROS_USERFUNC_INIT
 119
 120     /* Get our private data */
 121     Object *self = ( Object *)obj;
 122     Class *CLASS = *( Class **)param;
 123
 124     SETUP_ICONWINDOW_INST_DATA;
 125
 126     D(bug("[IconWindow] IconWindow__HookFunc_PrefsUpdatedFunc()\n"));
 127
 128         IPTR changed_state = 0;
 129         GET(self, MUIA_IconWindow_Changed, &changed_state);
 130
 131         if ((changed_state) && (data->iwd_IconListObj))
 132         {
 133         D(bug("[IconWindow] IconWindow__HookFunc_PrefsUpdatedFunc: Window contents have changed .. updating display ..\n"));
 134                 DoMethod(data->iwd_IconListObj, MUIM_IconList_Update);
 135                 SET(self, MUIA_IconWindow_Changed, FALSE);
 136     }
 137
 138     AROS_USERFUNC_EXIT
 139 }
 140
 141
 142 AROS_UFH3(
 143     void, IconWindow__HookFunc_ProcessBackgroundFunc,
 144     AROS_UFHA(struct Hook *,    hook,   A0),
 145     AROS_UFHA(APTR *,           obj,    A2),
 146     AROS_UFHA(APTR,             param,  A1)
 147 )
 148 {
 149     AROS_USERFUNC_INIT
 150
 151     /* Get our private data */
 152     Object *self = ( Object *)obj,
 153                *prefs = NULL;
 154     Class *CLASS = *( Class **)param;
 155
 156     SETUP_ICONWINDOW_INST_DATA;
 157
 158     D(bug("[IconWindow] IconWindow__HookFunc_ProcessBackgroundFunc()\n"));
 159
 160         DoMethod(self, MUIM_IconWindow_BackFill_ProcessBackground, data->iwd_BackFillInfo, data->iwd_RootViewObj);
 161
 162         GET(_app(self), MUIA_Wanderer_Prefs, &prefs);
 163
 164         if (prefs)
 165         {
 166                 BOOL    options_changed = FALSE;
 167                 IPTR    prefs_Processing = 0;
 168
 169                 GET(prefs, MUIA_WandererPrefs_Processing, &prefs_Processing);
 170                 if (!prefs_Processing)
 171                 {
 172 #warning "TODO: We arent in prefs-processing so cause an update!"
 173                 }
 174         }
 175
 176     AROS_USERFUNC_EXIT
 177 }
 178
 179 AROS_UFH3(
 180     void, IconWindow__HookFunc_WandererBackFillFunc,
 181     AROS_UFHA(struct Hook *,        Hook,   A0),
 182     AROS_UFHA(struct RastPort *,    RP,    A2),
 183     AROS_UFHA(struct BackFillMsg *, BFM,  A1)
 184 )
 185 {
 186     AROS_USERFUNC_INIT
 187
 188     D(bug("[IconWindow] IconWindow__HookFunc_WandererBackFillFunc()\n"));
 189         struct IconWindow_BackFillHookData *HookData = NULL;
 190
 191         if ((HookData = Hook->h_Data) && (iconwindow_BackFill_Active != NULL))
 192         {
 193                 Class                              *CLASS = HookData->bfhd_IWClass;
 194                 Object                                                     *self = HookData->bfhd_IWObject;
 195
 196                 SETUP_ICONWINDOW_INST_DATA;
 197
 198                 struct RastPort                   *DrawBackGround_RastPort = _rp(data->iwd_RootViewObj);
 199                 struct IconWindowBackFillMsg  DrawBackGround_BackFillMsg;
 200
 201                 DrawBackGround_BackFillMsg.Layer = DrawBackGround_RastPort->Layer;
 202
 203                 DrawBackGround_BackFillMsg.AreaBounds.MinX = _mleft(data->iwd_RootViewObj);
 204                 DrawBackGround_BackFillMsg.AreaBounds.MinY = _mtop(data->iwd_RootViewObj);
 205                 DrawBackGround_BackFillMsg.AreaBounds.MaxX = _mleft(data->iwd_RootViewObj) + _mwidth(data->iwd_RootViewObj) - 1;
 206                 DrawBackGround_BackFillMsg.AreaBounds.MaxY = _mtop(data->iwd_RootViewObj) + _mheight(data->iwd_RootViewObj) - 1;
 207
 208                 DrawBackGround_BackFillMsg.DrawBounds.MinX = BFM->Bounds.MinX;
 209                 DrawBackGround_BackFillMsg.DrawBounds.MinY = BFM->Bounds.MinY;
 210                 DrawBackGround_BackFillMsg.DrawBounds.MaxX = BFM->Bounds.MaxX;
 211                 DrawBackGround_BackFillMsg.DrawBounds.MaxY = BFM->Bounds.MaxY;
 212
 213                 /* Offset into source image (ala scroll bar position) */
 214                 DrawBackGround_BackFillMsg.OffsetX = BFM->OffsetX;
 215                 DrawBackGround_BackFillMsg.OffsetY = BFM->OffsetY;
 216                 return DoMethod(self, MUIM_IconWindow_BackFill_DrawBackground, data->iwd_BackFillInfo, &DrawBackGround_BackFillMsg, DrawBackGround_RastPort);
 217         }
 218
 219     AROS_USERFUNC_EXIT
 220 }
 221
 222 /*** Methods ****************************************************************/
 223 void IconWindow__SetupToolbar(Class *CLASS, Object *self, Object *prefs)
 224 {
 225     SETUP_ICONWINDOW_INST_DATA;
 226
 227     D(bug("[IconWindow] IconWindow__SetupToolbar()\n"));
 228
 229     Object          *strObj = NULL,
 230                     *bt_dirup = NULL,
 231                     *bt_search = NULL;
 232
 233     D(bug("[IconWindow] IconWindow__SetupToolbar: App PrefsObj @ %x\n", prefs));
 234
 235         if (prefs != NULL)
 236         {
 237                 data->iwd_Toolbar_PrefsNotificationObject = DoMethod(prefs,
 238                                                                                                                         MUIM_WandererPrefs_ViewSettings_GetNotifyObject,
 239                                                                                                                         "Toolbar");
 240                 //Set up our prefs notification handlers ..
 241
 242         }
 243
 244     /* Create the "ToolBar" panel object .. */
 245     Object *toolbarPanel = VGroup,
 246         InnerSpacing(0, 0),
 247         MUIA_Frame, MUIV_Frame_None,
 248         Child, (IPTR)HGroup,
 249             InnerSpacing(4, 4),
 250                 MUIA_Frame, MUIV_Frame_None,
 251             MUIA_Weight, 100,
 252                         Child, (IPTR)HGroup,
 253                                 InnerSpacing(0, 0),
 254                                 MUIA_Weight, 100,
 255                                 Child, (IPTR)( strObj = StringObject,
 256                                         MUIA_String_Contents, (IPTR)"",
 257                                         MUIA_CycleChain, 1,
 258                                         MUIA_Frame, MUIV_Frame_String,
 259                                 End ),
 260                         End,
 261                         Child, (IPTR)HGroup,
 262                                 InnerSpacing(0, 0),
 263                                 MUIA_HorizWeight,   0,
 264                                 MUIA_VertWeight,    100,
 265                                 Child, (IPTR) (bt_dirup = ImageButton("", "THEME:Images/Gadgets/Prefs/Revert")),
 266 #if !defined(ICONWINDOW_OPTION_NOSEARCHBUTTON)
 267                                 Child, (IPTR) (bt_search = ImageButton("", "THEME:Images/Gadgets/Prefs/Test")),
 268 #endif
 269                         End,
 270                 End,
 271                 Child, (IPTR)HGroup,
 272                         InnerSpacing(0, 0),
 273                         MUIA_Group_Spacing, 0,
 274                         MUIA_FixHeight, 1,
 275                 MUIA_Frame, MUIV_Frame_None,
 276                         MUIA_Background, MUII_SHADOW,
 277             Child, (IPTR)RectangleObject,
 278                                 MUIA_Frame, MUIV_Frame_None,
 279                         End,
 280                 End,
 281         End;
 282
 283     /* Got a toolbarpanel? setup notifies and other values are
 284        copied to the data of the object */
 285     if ( toolbarPanel != NULL )
 286     {
 287         SET(bt_dirup, MUIA_Background, XGET( toolbarPanel, MUIA_Background ) );
 288                 SET(bt_dirup, MUIA_CycleChain, 1);
 289         SET(bt_dirup, MUIA_Frame, MUIV_Frame_None );
 290 #if !defined(ICONWINDOW_OPTION_NOSEARCHBUTTON)
 291         SET(bt_search, MUIA_Background, XGET( toolbarPanel, MUIA_Background ) );
 292                 SET(bt_search, MUIA_CycleChain, 1);
 293         SET(bt_search, MUIA_Frame, MUIV_Frame_None );
 294 #endif
 295
 296         if (DoMethod( data->iwd_ExtensionGroupObj, MUIM_Group_InitChange ))
 297                 {
 298                         DoMethod(data->iwd_ExtensionGroupObj, OM_ADDMEMBER, (IPTR)toolbarPanel);
 299                         if (data->iwd_ExtensionGroupSpacerObj)
 300                         {
 301                                 DoMethod(data->iwd_ExtensionGroupObj, OM_REMMEMBER, (IPTR)data->iwd_ExtensionGroupSpacerObj);
 302                                 data->iwd_ExtensionGroupSpacerObj = NULL;
 303                         }
 304
 305                         DoMethod(data->iwd_ExtensionGroupObj, MUIM_Group_ExitChange);
 306                         data->iwd_Toolbar_PanelObj = toolbarPanel;
 307                 }
 308
 309                 if (data->iwd_Toolbar_PanelObj)
 310                 {
 311                         DoMethod(
 312                                 bt_dirup, MUIM_Notify, MUIA_Pressed, FALSE,
 313                                 (IPTR)self, 1, MUIM_IconWindow_DirectoryUp
 314                         );
 315
 316                         data->iwd_Toolbar_LocationStringObj = strObj;
 317
 318                         data->iwd_pathStrHook.h_Entry = ( HOOKFUNC )IconWindow__HookFunc_ToolbarLocationStringFunc;
 319                         SET(
 320                                 data->iwd_Toolbar_LocationStringObj, MUIA_String_Contents,
 321                                 XGET(data->iwd_IconListObj, MUIA_IconDrawerList_Drawer)
 322                         );
 323
 324                         /* Make changes to string contents change dir on enter */
 325                         DoMethod (
 326                                 strObj, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
 327                                 (IPTR)self, 3, MUIM_CallHook, &data->iwd_pathStrHook, (IPTR)CLASS
 328                         );
 329                 }
 330     }
 331     else
 332     {
 333         data->iwd_Toolbar_PanelObj = NULL;
 334     }
 335 }
 336
 337 Object *IconWindow__OM_NEW(Class *CLASS, Object *self, struct opSet *message)
 338 {
 339     struct Screen                       *_newIconWin__Screen = NULL;
 340     Object                          *_newIconWin__IconListObj = NULL,
 341                                             *_newIconWin__RootViewObj = NULL,
 342                                     *_newIconWin__ExtensionContainerObj = NULL, // around extension group
 343                                     *_newIconWin__ExtensionGroupObj = NULL,     // extension group top
 344                                     *_newIconWin__ExtensionGroupSpacerObj = NULL,     // extension group top
 345                                                                         *prefs = NULL;
 346
 347     char                            *_newIconWin__Title = NULL;
 348
 349     BOOL                            isRoot = FALSE,
 350                                                                         isBackdrop = FALSE,
 351                                     hasToolbar = FALSE;
 352
 353     struct Hook                         *actionHook = NULL;
 354     struct TextFont                 *_newIconWin__WindowFont = NULL;
 355
 356         struct Hook                                     *_newIconWin__BackFillHook = NULL;
 357
 358         APTR                            WindowBF_TAG = TAG_IGNORE;
 359
 360 #warning "TODO: We should probably obtain the windows coords/dimensions from a .info file ?"
 361         IPTR                            _newIconWin__WindowWidth = 300;
 362         IPTR                            _newIconWin__WindowHeight = 300;
 363         IPTR                            _newIconWin__WindowTop = 0;
 364         IPTR                            _newIconWin__WindowLeft = 0;
 365
 366     D(bug("[iconwindow] IconWindow__OM_NEW()\n"));
 367
 368     /* More than one GetTagData is not very efficient, however since this isn't called very often... */
 369
 370     isBackdrop = (BOOL)GetTagData(MUIA_IconWindow_IsBackdrop, (IPTR)FALSE, message->ops_AttrList);
 371
 372     if (!(isRoot = (BOOL)GetTagData(MUIA_IconWindow_IsRoot, (IPTR)FALSE, message->ops_AttrList)))
 373                 hasToolbar = (BOOL)GetTagData(MUIA_IconWindowExt_Toolbar_Enabled, (IPTR)FALSE, message->ops_AttrList);
 374
 375     actionHook = (struct Hook *)GetTagData(MUIA_IconWindow_ActionHook, (IPTR) NULL, message->ops_AttrList);
 376     _newIconWin__WindowFont = (struct TextFont *)GetTagData(MUIA_IconWindow_Font, (IPTR) NULL, message->ops_AttrList);
 377         prefs = (Object *)GetTagData(MUIA_Wanderer_Prefs, (IPTR) NULL, message->ops_AttrList);
 378
 379         /* Request the screen we should use .. */
 380
 381         if (!(_newIconWin__Screen = (struct Hook *)GetTagData(MUIA_Wanderer_Screen, (IPTR) NULL, message->ops_AttrList)))
 382         {
 383         D(bug("[IconWindow] IconWindow__OM_NEW: NO SCREEN SET!\n"));
 384                 return NULL;
 385         }
 386     D(bug("[iconwindow] IconWindow__OM_NEW: Screen @ %x\n", _newIconWin__Screen));
 387
 388         if ((_newIconWin__BackFillHook = AllocVec(sizeof(struct Hook), MEMF_CLEAR|MEMF_PUBLIC))!=NULL)
 389         {
 390         D(bug("[IconWindow] IconWindow__OM_NEW: Allocated WindowBackFillHook @ %x\n", _newIconWin__BackFillHook));
 391                 _newIconWin__BackFillHook->h_Entry = ( HOOKFUNC )IconWindow__HookFunc_WandererBackFillFunc;
 392 #if defined(__MORPHOS__)
 393                 WindowBF_TAG = MUIA_Window_BackFillHook;
 394 #else
 395                 WindowBF_TAG = WA_BackFill;
 396 #endif
 397         }
 398
 399     if (isRoot)
 400     {
 401         _newIconWin__IconListObj = (IPTR)IconWindowIconVolumeListObject,
 402             MUIA_Font, (IPTR)_newIconWin__WindowFont,
 403         End;
 404
 405                 _newIconWin__WindowWidth = GetBitMapAttr(_newIconWin__Screen->RastPort.BitMap, BMA_WIDTH);
 406                 _newIconWin__WindowHeight = GetBitMapAttr(_newIconWin__Screen->RastPort.BitMap, BMA_HEIGHT);
 407         D(bug("[iconwindow] IconWindow__OM_NEW: Screen dimensions ..  %d x %d\n", _newIconWin__WindowWidth, _newIconWin__WindowHeight));
 408
 409                 if (isBackdrop)
 410                 {
 411             D(bug("[iconwindow] IconWindow__OM_NEW: BACKDROP ROOT Window\n"));
 412                         _newIconWin__Title = NULL;
 413                 }
 414                 else
 415                 {
 416             D(bug("[iconwindow] IconWindow__OM_NEW: Plain ROOT Window\n"));
 417                         _newIconWin__Title = __intern_wintitle_wanderer;
 418                 }
 419
 420                 _newIconWin__WindowTop = _newIconWin__Screen->BarHeight + 1;
 421                 _newIconWin__WindowLeft = 0;
 422
 423                 _newIconWin__WindowHeight -= _newIconWin__WindowTop;
 424     }
 425     else
 426     {
 427         D(bug("[iconwindow] IconWindow__OM_NEW: Directory Window\n"));
 428         _newIconWin__Title = (STRPTR) GetTagData(MUIA_IconWindow_Location, (IPTR)NULL, message->ops_AttrList);
 429
 430         _newIconWin__IconListObj = (IPTR)IconWindowIconDrawerListObject,
 431             MUIA_Font, (IPTR)_newIconWin__WindowFont,
 432             MUIA_IconDrawerList_Drawer, (IPTR) _newIconWin__Title,
 433         End;
 434
 435                 _newIconWin__ExtensionGroupObj = GroupObject,
 436             InnerSpacing(0,0),
 437             MUIA_Frame, MUIV_Frame_None,
 438             MUIA_Group_Spacing, 0,
 439                         Child, (_newIconWin__ExtensionGroupSpacerObj = HSpace(0)),
 440                 End;
 441
 442                 if (_newIconWin__ExtensionGroupObj)
 443                 {
 444                         _newIconWin__ExtensionContainerObj = HGroup,
 445                                 InnerSpacing(0,0),
 446                                 MUIA_HorizWeight,   100,
 447                                 MUIA_VertWeight,    0,
 448                                 MUIA_Frame,         MUIV_Frame_None,
 449                                 MUIA_Group_Spacing, 3,
 450                                 /* extension on top of the list */
 451                                 Child, (IPTR)_newIconWin__ExtensionGroupObj,
 452                         End;
 453                 }
 454                 _newIconWin__WindowTop = MUIV_Window_TopEdge_Centered;
 455                 _newIconWin__WindowLeft = MUIV_Window_LeftEdge_Centered;
 456     }
 457     D(bug("[iconwindow] IconWindow__OM_NEW: Using dimensions ..  %d x %d\n", _newIconWin__WindowWidth, _newIconWin__WindowHeight));
 458
 459         _newIconWin__RootViewObj = (IPTR) IconListviewObject,
 460                         MUIA_Weight,                           100,
 461                         MUIA_IconListview_UseWinBorder,        TRUE,
 462                         MUIA_IconListview_IconList,     (IPTR) _newIconWin__IconListObj,
 463                 End;
 464
 465     D(bug("[iconwindow] IconWindow__OM_NEW: Font @ %x\n", _newIconWin__WindowFont));
 466
 467     self = (Object *) DoSuperNewTags
 468     (
 469         CLASS, self, NULL,
 470
 471                 MUIA_Window_Screen,                                    _newIconWin__Screen,
 472                 MUIA_Window_Backdrop,                                  isBackdrop ? TRUE : FALSE,
 473                 MUIA_Window_Borderless,                                isBackdrop ? TRUE : FALSE,
 474         MUIA_Window_Width,                                     _newIconWin__WindowWidth,
 475         MUIA_Window_Height,                                    _newIconWin__WindowHeight,
 476         MUIA_Window_LeftEdge,                                  _newIconWin__WindowLeft,
 477         MUIA_Window_TopEdge,                                   _newIconWin__WindowTop,
 478         (!isBackdrop) ? MUIA_Window_AltWidth : TAG_IGNORE,     100,
 479         (!isBackdrop) ? MUIA_Window_AltHeight : TAG_IGNORE,    80,
 480                 MUIA_Window_Title,                                     (IPTR)_newIconWin__Title,
 481
 482                 MUIA_Window_DragBar,                                   (!isBackdrop) ? TRUE : FALSE,
 483                 MUIA_Window_CloseGadget,                               (!isBackdrop) ? TRUE : FALSE,
 484                 MUIA_Window_SizeGadget,                                (!isBackdrop) ? TRUE : FALSE,
 485                 MUIA_Window_DepthGadget,                               (!isBackdrop) ? TRUE : FALSE,
 486 #if defined(MUIA_Window_ZoomGadget)
 487                 MUIA_Window_ZoomGadget,                                (!isBackdrop) ? TRUE : FALSE,
 488 #endif
 489                 MUIA_Window_UseBottomBorderScroller,                   (!isBackdrop) ? TRUE : FALSE,
 490                 MUIA_Window_UseRightBorderScroller,                    (!isBackdrop) ? TRUE : FALSE,
 491         MUIA_Window_IsSubWindow,                               TRUE,
 492                 WindowBF_TAG,                                          _newIconWin__BackFillHook,
 493         MUIA_Window_ScreenTitle,                               (IPTR) "",
 494         MUIA_Font,                                             (IPTR) _newIconWin__WindowFont,
 495
 496         WindowContents, (IPTR) VGroup,
 497             MUIA_Group_Spacing,  0,
 498                         MUIA_Group_SameSize, FALSE,
 499             InnerSpacing(0,0),
 500
 501             /* "Extension" group */
 502             _newIconWin__ExtensionContainerObj ? Child : TAG_IGNORE, (IPTR)_newIconWin__ExtensionContainerObj,
 503
 504             /* icon list */
 505             Child, (IPTR) _newIconWin__RootViewObj,
 506
 507         End,
 508
 509         TAG_MORE, (IPTR) message->ops_AttrList
 510     );
 511
 512     if (self != NULL)
 513     {
 514         SETUP_ICONWINDOW_INST_DATA;
 515
 516         D(bug("[iconwindow] IconWindow__OM_NEW: SELF = %x\n", self));
 517
 518                 data->iwd_Title                   = _newIconWin__Title;
 519
 520                 data->iwd_RootViewObj             = _newIconWin__RootViewObj;
 521
 522         data->iwd_IconListObj             = _newIconWin__IconListObj;
 523
 524                 SET(data->iwd_RootViewObj, MUIA_IconWindow_Window,      self);
 525
 526         data->iwd_ActionHook              = actionHook;
 527
 528         data->iwd_ExtensionGroupObj       = _newIconWin__ExtensionGroupObj;
 529         data->iwd_ExtensionContainerObj   = _newIconWin__ExtensionContainerObj;
 530         data->iwd_ExtensionGroupSpacerObj = _newIconWin__ExtensionGroupSpacerObj;
 531
 532         data->iwd_Toolbar_PanelObj         = NULL;
 533
 534         data->iwd_Flag_ISROOT             = isRoot;
 535         data->iwd_Flag_ISBACKDROP         = isBackdrop;
 536
 537         data->iwd_WindowFont              = _newIconWin__WindowFont;
 538
 539                 data->iwd_ViewSettings_Attrib = data->iwd_Flag_ISROOT
 540                     ? "Workbench"
 541                     : "Drawer";
 542
 543                 if (prefs)
 544                 {
 545                         data->iwd_PrefsUpdated_hook.h_Entry = ( HOOKFUNC )IconWindow__HookFunc_PrefsUpdatedFunc;
 546
 547                         DoMethod
 548                         (
 549                                 prefs, MUIM_Notify, MUIA_WandererPrefs_Processing, FALSE,
 550                                 (IPTR) self, 3,
 551                                 MUIM_CallHook, &data->iwd_PrefsUpdated_hook, (IPTR)CLASS
 552                         );
 553
 554                         data->iwd_ViewSettings_PrefsNotificationObject = DoMethod(prefs,
 555                                                                         MUIM_WandererPrefs_ViewSettings_GetNotifyObject,
 556                                                                                                                                 data->iwd_ViewSettings_Attrib);
 557
 558                         if (data->iwd_ExtensionContainerObj)
 559                         {
 560                                 DoMethod
 561                                 (
 562                                         prefs, MUIM_Notify, MUIA_IconWindowExt_Toolbar_Enabled, MUIV_EveryTime,
 563                                         (IPTR)self, 3, MUIM_Set, MUIA_IconWindowExt_Toolbar_Enabled, MUIV_TriggerValue
 564                                 );
 565                         }
 566                 }
 567
 568                 data->iwd_ProcessBackground_hook.h_Entry = ( HOOKFUNC )IconWindow__HookFunc_ProcessBackgroundFunc;
 569                 if (data->iwd_BackFill_hook = _newIconWin__BackFillHook)
 570                 {
 571                         data->iwd_BackFillHookData.bfhd_IWClass = CLASS;
 572                         data->iwd_BackFillHookData.bfhd_IWObject = self;
 573                         data->iwd_BackFill_hook->h_Data = &data->iwd_BackFillHookData;
 574                 }
 575
 576                 if (iconwindow_BackFill_Active)
 577                 {
 578                         data->iwd_BackFillInfo = DoMethod(self, MUIM_IconWindow_BackFill_Setup);
 579             D(bug("[iconwindow] IconWindow__OM_NEW: Window BackFill_Data @ %x for '%s'\n", data->iwd_BackFillInfo, iconwindow_BackFill_Active->bfd_BackFillID));
 580                 }
 581
 582         /* no tool bar when root */
 583         if (!isRoot && hasToolbar && data->iwd_ExtensionContainerObj)
 584                         IconWindow__SetupToolbar(CLASS, self, prefs);
 585
 586         /* If double clicked then we call our own private methods, that's
 587                    easier then using Hooks */
 588         DoMethod
 589         (
 590             _newIconWin__IconListObj, MUIM_Notify, MUIA_IconList_DoubleClick, TRUE,
 591             (IPTR) self, 1, MUIM_IconWindow_DoubleClicked
 592         );
 593
 594         /* notify when icons dropped on another (wanderer) window */
 595         DoMethod
 596         (
 597             _newIconWin__IconListObj, MUIM_Notify, MUIA_IconList_IconsDropped, MUIV_EveryTime,
 598             (IPTR) self, 1, MUIM_IconWindow_IconsDropped
 599         );
 600
 601         /* notify when icons dropped on custom application */
 602         DoMethod
 603         (
 604             _newIconWin__IconListObj, MUIM_Notify, MUIA_IconList_AppWindowDrop, MUIV_EveryTime,
 605             (IPTR) self, 1, MUIM_IconWindow_AppWindowDrop
 606         );
 607
 608         DoMethod
 609         (
 610             _newIconWin__IconListObj, MUIM_Notify, MUIA_IconList_Clicked, MUIV_EveryTime,
 611             (IPTR) self, 1, MUIM_IconWindow_Clicked
 612         );
 613     }
 614
 615     return self;
 616 }
 617
 618 IPTR IconWindow__OM_DISPOSE(Class *CLASS, Object *self, Msg message)
 619 {
 620     SETUP_ICONWINDOW_INST_DATA;
 621
 622     Object *prefs = NULL;
 623
 624     GET(_app(self), MUIA_Wanderer_Prefs, &prefs);
 625
 626     if (prefs)
 627     {
 628         DoMethod
 629         (
 630             prefs,
 631             MUIM_KillNotifyObj, MUIA_WandererPrefs_Processing, (IPTR) self
 632         );
 633
 634         DoMethod
 635         (
 636             prefs,
 637             MUIM_KillNotifyObj, MUIA_IconWindowExt_Toolbar_Enabled, (IPTR) self
 638         );
 639     }
 640
 641     if (data->iwd_BackFill_hook)
 642         FreeVec(data->iwd_BackFill_hook);
 643
 644     return DoSuperMethodA(CLASS, self, message);
 645 }
 646
 647 IPTR IconWindow__OM_SET(Class *CLASS, Object *self, struct opSet *message)
 648 {
 649     SETUP_ICONWINDOW_INST_DATA;
 650
 651     struct TagItem  *tstate = message->ops_AttrList, *tag;
 652     BOOL                        UpdateIconlist = FALSE;
 653         IPTR                    focusicon = NULL;
 654     IPTR                        rv = TRUE;
 655
 656     while ((tag = NextTagItem((const struct TagItem**)&tstate)) != NULL)
 657     {
 658         switch (tag->ti_Tag)
 659         {
 660                 case MUIA_IconWindow_Changed:
 661                         data->iwd_Flag_NEEDSUPDATE = (BOOL)tag->ti_Data;
 662                         break;
 663
 664                 case MUIA_Window_Open:
 665                         {
 666                                 /* Commented out for unknown reason - please elaborate here!
 667                                 if (data->iwd_WindowFont)
 668                                 {
 669 D(bug("[iconwindow] MUIA_Window_Open: Setting Window Font [%x]\n", data->iwd_WindowFont));
 670                                         SetFont(_rp(self), data->iwd_WindowFont);
 671                                 }
 672                                 */
 673                                 break;
 674                         }
 675
 676                 case MUIA_Window_Activate:
 677                         if (data->iwd_IconListObj)
 678                                 GET(data->iwd_IconListObj, MUIA_IconList_FocusIcon, &focusicon);
 679
 680                         break;
 681
 682                 case MUIA_IconWindow_Font:
 683                         data->iwd_WindowFont = (struct TextFont  *)tag->ti_Data;
 684             D(bug("[iconwindow] IconWindow__OM_SET: MUIA_IconWindow_Font [font @ %x]\n", data->iwd_WindowFont));
 685
 686                         if ( data->iwd_WindowFont != 1 )
 687                                 SetFont(_rp(self), data->iwd_WindowFont);
 688
 689                         break;
 690
 691                 case MUIA_IconWindow_Location:
 692                         strcpy(data->iwd_DirectoryPath, (IPTR)tag->ti_Data);
 693             D(bug("[iconwindow] IconWindow__OM_SET: MUIA_IconWindow_Location [drawer '%s']\n", data->iwd_DirectoryPath));
 694
 695                         SET(data->iwd_IconListObj, MUIA_IconDrawerList_Drawer, (IPTR) data->iwd_DirectoryPath);
 696                         if (!data->iwd_Flag_ISROOT)
 697                         {
 698                                 SET(self, MUIA_Window_Title, (IPTR)data->iwd_DirectoryPath);
 699                                 SET(data->iwd_Toolbar_LocationStringObj, MUIA_String_Contents, (IPTR)data->iwd_DirectoryPath);
 700                         }
 701                         break;
 702
 703                 case MUIA_IconWindow_BackgroundAttrib:
 704             D(bug("[iconwindow] IconWindow__OM_SET: MUIA_IconWindow_BackgroundAttrib (not implemented)\n"));
 705                         break;
 706
 707                 case MUIA_IconWindowExt_Toolbar_Enabled:
 708                         if ((!(data->iwd_Flag_ISROOT)) && (data->iwd_ExtensionContainerObj))
 709                         {
 710                                 // remove toolbar
 711                                 if (!(( BOOL )tag->ti_Data))
 712                                 {
 713                                         if (data->iwd_Toolbar_PanelObj != NULL)
 714                                         {
 715                                                 data->iwd_ExtensionGroupSpacerObj = HSpace(0);
 716
 717                                                 SET(data->iwd_ExtensionContainerObj, MUIA_Frame, MUIV_Frame_None);
 718                                                 SET(data->iwd_ExtensionContainerObj, MUIA_Group_Spacing, 0);
 719
 720                                                 if ((data->iwd_ExtensionGroupSpacerObj) && (DoMethod(data->iwd_ExtensionGroupObj, MUIM_Group_InitChange)))
 721                                                 {
 722                                                         DoMethod(data->iwd_ExtensionGroupObj, OM_REMMEMBER, (IPTR)data->iwd_Toolbar_PanelObj);
 723                                                         DoMethod(data->iwd_ExtensionGroupObj, OM_ADDMEMBER, (IPTR)data->iwd_ExtensionGroupSpacerObj);
 724                                                         DoMethod(data->iwd_ExtensionGroupObj, MUIM_Group_ExitChange);
 725                                                         data->iwd_Toolbar_PanelObj = NULL;
 726                                                 }
 727                                         }
 728                                         //Force classic navigation when the toolbar is disabled ..
 729                                         Object *prefs = NULL;
 730
 731                                         GET(_app(self), MUIA_Wanderer_Prefs, &prefs);
 732                                         if (prefs)
 733                                                 SET(prefs, MUIA_IconWindowExt_Toolbar_NavigationMethod, WPD_NAVIGATION_CLASSIC);
 734                                 }
 735                                 else
 736                                 {
 737                                         // setup toolbar
 738                                         if (data->iwd_Toolbar_PanelObj == NULL)
 739                                         {
 740                                                 Object *prefs = NULL;
 741                                                 GET(_app(self), MUIA_Wanderer_Prefs, &prefs);
 742                                                 IconWindow__SetupToolbar(CLASS, self, prefs);
 743                                         }
 744                                  }
 745                                  data->iwd_Flag_EXT_TOOLBARENABLED = (IPTR)tag->ti_Data;
 746                          }
 747                          break;
 748         }
 749     }
 750
 751     if (UpdateIconlist)
 752         DoMethod(data->iwd_IconListObj, MUIM_IconList_Update);
 753
 754         rv = DoSuperMethodA(CLASS, self, (Msg) message);
 755
 756         if (focusicon)
 757         {
 758         D(bug("[iconwindow] IconWindow__OM_SET: Updating focused icon (@ %x)\n", focusicon));
 759                 DoMethod(data->iwd_IconListObj, MUIM_IconList_DrawEntry, focusicon, ICONENTRY_DRAWMODE_PLAIN);
 760                 DoMethod(data->iwd_IconListObj, MUIM_IconList_DrawEntryLabel, focusicon, ICONENTRY_DRAWMODE_PLAIN);
 761         }
 762
 763     return rv;
 764 }
 765
 766
 767 IPTR IconWindow__OM_GET(Class *CLASS, Object *self, struct opGet *message)
 768 {
 769     SETUP_ICONWINDOW_INST_DATA;
 770
 771     IPTR *store = message->opg_Storage;
 772     IPTR  rv    = TRUE;
 773
 774     switch (message->opg_AttrID)
 775     {
 776                 case MUIA_IconWindow_Changed:
 777                         *store = (IPTR)data->iwd_Flag_NEEDSUPDATE;
 778                         break;
 779
 780                 case MUIA_IconWindow_Window:
 781             *store = (IPTR)self;
 782             break;
 783
 784         case MUIA_IconWindow_Location:
 785             *store = !data->iwd_Flag_ISROOT
 786                 ? XGET(data->iwd_IconListObj, MUIA_IconDrawerList_Drawer)
 787                 : (IPTR)NULL;
 788             break;
 789
 790         case MUIA_IconWindow_IconList:
 791             *store = (IPTR)data->iwd_IconListObj;
 792             break;
 793
 794         case MUIA_IconWindowExt_Toolbar_Enabled:
 795             *store = (IPTR)data->iwd_Flag_EXT_TOOLBARENABLED;
 796             break;
 797
 798         case MUIA_IconWindow_IsRoot:
 799             *store = (IPTR)data->iwd_Flag_ISROOT;
 800             break;
 801
 802                 case MUIA_IconWindow_IsBackdrop:
 803                         *store = (IPTR)data->iwd_Flag_ISBACKDROP;
 804                         break;
 805
 806                 case MUIA_IconWindow_BackFillData:
 807                         *store = (IPTR)data->iwd_BackFillInfo;
 808             break;
 809
 810                 case MUIA_IconWindow_BackgroundAttrib:
 811                         *store = (IPTR)data->iwd_ViewSettings_Attrib;
 812             break;
 813
 814         default:
 815             rv = DoSuperMethodA(CLASS, self, (Msg) message);
 816     }
 817
 818     return rv;
 819 }
 820
 821 IPTR IconWindow__MUIM_Window_Setup
 822 (
 823     Class *CLASS, Object *self, Msg message
 824 )
 825 {
 826     SETUP_ICONWINDOW_INST_DATA;
 827
 828     D(bug("[IconWindow] IconWindow__MUIM_Window_Setup()\n"));
 829
 830         Object *prefs = NULL;
 831
 832     if (!DoSuperMethodA(CLASS, self, message)) return FALSE;
 833
 834         GET(_app(self), MUIA_Wanderer_Prefs, &prefs);
 835
 836     D(bug("[IconWindow] IconWindow__MUIM_Window_Setup: App PrefsObj @ %x\n", prefs));
 837
 838         if ((prefs) && (data->iwd_ViewSettings_PrefsNotificationObject))
 839         {
 840         D(bug("[IconWindow] IconWindow__MUIM_Window_Setup: Setting up window background change hook\n"));
 841
 842                 /* Set-up a hook to call ProcessBackground on prefs notification */
 843                 DoMethod
 844                 (
 845                         data->iwd_ViewSettings_PrefsNotificationObject, MUIM_Notify, MUIA_Background, MUIV_EveryTime,
 846                         (IPTR) self, 3,
 847                         MUIM_CallHook, &data->iwd_ProcessBackground_hook, (IPTR)CLASS
 848                 );
 849
 850                 if (data->iwd_Flag_ISROOT)
 851                 {
 852                         DoMethod
 853                         (
 854                                 data->iwd_ViewSettings_PrefsNotificationObject, MUIM_Notify, MUIA_IconWindowExt_ImageBackFill_BGRenderMode, MUIV_EveryTime,
 855                                 (IPTR) self, 3,
 856                                 MUIM_CallHook, &data->iwd_ProcessBackground_hook, (IPTR)CLASS
 857                         );
 858                 }
 859
 860                 DoMethod
 861                 (
 862                         data->iwd_ViewSettings_PrefsNotificationObject, MUIM_Notify, MUIA_IconWindowExt_ImageBackFill_BGTileMode, MUIV_EveryTime,
 863                         (IPTR) self, 3,
 864                         MUIM_CallHook, &data->iwd_ProcessBackground_hook, (IPTR)CLASS
 865                 );
 866
 867                 DoMethod
 868                 (
 869                         data->iwd_ViewSettings_PrefsNotificationObject, MUIM_Notify, MUIA_IconWindowExt_ImageBackFill_BGXOffset, MUIV_EveryTime,
 870                         (IPTR) self, 3,
 871                         MUIM_CallHook, &data->iwd_ProcessBackground_hook, (IPTR)CLASS
 872                 );
 873
 874                 DoMethod
 875                 (
 876                         data->iwd_ViewSettings_PrefsNotificationObject, MUIM_Notify, MUIA_IconWindowExt_ImageBackFill_BGYOffset, MUIV_EveryTime,
 877                         (IPTR) self, 3,
 878                         MUIM_CallHook, &data->iwd_ProcessBackground_hook, (IPTR)CLASS
 879                 );
 880         }
 881
 882     D(bug("[iconwindow] IconWindow__MUIM_Window_Setup: Setup complete!\n"));
 883
 884     return TRUE;
 885 }
 886
 887 IPTR IconWindow__MUIM_Window_Cleanup
 888 (
 889     Class *CLASS, Object *self, Msg message
 890 )
 891 {
 892     SETUP_ICONWINDOW_INST_DATA;
 893
 894     D(bug("[IconWindow] IconWindow__MUIM_Window_Cleanup()\n"));
 895
 896         if (data->iwd_BackFillInfo)
 897         {
 898                 DoMethod(self, MUIM_IconWindow_BackFill_Cleanup, data->iwd_BackFillInfo);
 899                 data->iwd_BackFillInfo = NULL;
 900         }
 901
 902         if (data->iwd_ViewSettings_PrefsNotificationObject)
 903         {
 904                 DoMethod
 905                 (
 906                         data->iwd_ViewSettings_PrefsNotificationObject,
 907                         MUIM_KillNotifyObj, MUIA_IconWindowExt_ImageBackFill_BGYOffset, (IPTR) self
 908                 );
 909
 910                 DoMethod
 911                 (
 912                         data->iwd_ViewSettings_PrefsNotificationObject,
 913                         MUIM_KillNotifyObj, MUIA_IconWindowExt_ImageBackFill_BGXOffset, (IPTR) self
 914                 );
 915
 916                 DoMethod
 917                 (
 918                         data->iwd_ViewSettings_PrefsNotificationObject,
 919                         MUIM_KillNotifyObj, MUIA_IconWindowExt_ImageBackFill_BGTileMode, (IPTR) self
 920                 );
 921
 922                 if (data->iwd_Flag_ISROOT)
 923                 {
 924                         DoMethod
 925                         (
 926                                 data->iwd_ViewSettings_PrefsNotificationObject,
 927                                 MUIM_KillNotifyObj, MUIA_IconWindowExt_ImageBackFill_BGRenderMode, (IPTR) self
 928                         );
 929                 }
 930
 931                 DoMethod
 932                 (
 933                         data->iwd_ViewSettings_PrefsNotificationObject,
 934                         MUIM_KillNotifyObj, MUIA_Background, (IPTR) self
 935                 );
 936         }
 937     return DoSuperMethodA(CLASS, self, message);
 938 }
 939
 940 IPTR IconWindow__MUIM_IconWindow_DoubleClicked
 941 (
 942     Class *CLASS, Object *self, Msg message
 943 )
 944 {
 945     SETUP_ICONWINDOW_INST_DATA;
 946
 947     D(bug("[IconWindow] IconWindow__MUIM_IconWindow_DoubleClicked()\n"));
 948
 949     if (data->iwd_ActionHook)
 950     {
 951         struct IconWindow_ActionMsg msg;
 952         msg.type     = ICONWINDOW_ACTION_OPEN;
 953         msg.iconlist = data->iwd_IconListObj;
 954         msg.isroot   = data->iwd_Flag_ISROOT;
 955         msg.click    = NULL;
 956         CallHookPkt(data->iwd_ActionHook, self, &msg);
 957     }
 958
 959     return TRUE;
 960 }
 961
 962 IPTR IconWindow__MUIM_IconWindow_Clicked
 963 (
 964     Class *CLASS, Object *self, Msg message
 965 )
 966 {
 967     SETUP_ICONWINDOW_INST_DATA;
 968
 969     D(bug("[IconWindow] IconWindow__MUIM_IconWindow_Clicked()\n"));
 970
 971     if (data->iwd_ActionHook)
 972     {
 973         struct IconWindow_ActionMsg msg;
 974         msg.type     = ICONWINDOW_ACTION_CLICK;
 975         msg.iconlist = data->iwd_IconListObj;
 976         msg.isroot   = data->iwd_Flag_ISROOT;
 977                 GET(data->iwd_IconListObj, MUIA_IconList_Clicked, &msg.click);
 978         CallHookPkt(data->iwd_ActionHook, self, &msg);
 979     }
 980
 981     return TRUE;
 982 }
 983
 984 IPTR IconWindow__MUIM_IconWindow_IconsDropped
 985 (
 986     Class *CLASS, Object *self, Msg message
 987 )
 988 {
 989     SETUP_ICONWINDOW_INST_DATA;
 990
 991     D(bug("[IconWindow] IconWindow__MUIM_IconWindow_IconsDropped()\n"));
 992
 993     if (data->iwd_ActionHook)
 994     {
 995         struct IconWindow_ActionMsg msg;
 996         msg.type     = ICONWINDOW_ACTION_ICONDROP;
 997         msg.iconlist = data->iwd_IconListObj;
 998         msg.isroot   = data->iwd_Flag_ISROOT;
 999         GET(data->iwd_IconListObj, MUIA_IconList_IconsDropped, &msg.drop);
1000         CallHookPkt(data->iwd_ActionHook, self, &msg);
1001     }
1002
1003     return TRUE;
1004 }
1005
1006 IPTR IconWindow__MUIM_IconWindow_AppWindowDrop
1007 (
1008     Class *CLASS, Object *self, Msg message
1009 )
1010 {
1011     SETUP_ICONWINDOW_INST_DATA;
1012
1013 D(bug("[IconWindow] IconWindow__MUIM_IconWindow_AppWindowDrop()\n"));
1014
1015     if (data->iwd_ActionHook)
1016     {
1017         struct IconWindow_ActionMsg msg;
1018         msg.type     = ICONWINDOW_ACTION_APPWINDOWDROP;
1019         msg.iconlist = data->iwd_IconListObj;
1020         msg.isroot   = data->iwd_Flag_ISROOT;
1021         GET(data->iwd_IconListObj, MUIA_IconList_IconsDropped, &msg.drop);
1022         CallHookPkt(data->iwd_ActionHook, self, &msg);
1023     }
1024
1025     return TRUE;
1026 }
1027
1028 IPTR IconWindow__MUIM_IconWindow_Open
1029 (
1030     Class *CLASS, Object *self, Msg message
1031 )
1032 {
1033     SETUP_ICONWINDOW_INST_DATA;
1034
1035     D(bug("[IconWindow] IconWindow__MUIM_IconWindow_Open()\n"));
1036
1037     if (!XGET(self, MUIA_Window_Open))
1038     {
1039         DoMethod(data->iwd_IconListObj, MUIM_IconList_Clear);
1040         SET(self, MUIA_Window_Open, TRUE);
1041
1042         D(bug("[IconWindow] IconWindow__MUIM_IconWindow_Open: Process the background ..\n"));
1043                 DoMethod(self, MUIM_IconWindow_BackFill_ProcessBackground, data->iwd_BackFillInfo, data->iwd_RootViewObj);
1044     }
1045     D(bug("[IconWindow] IconWindow__MUIM_IconWindow_Open: Force an update of the list ..\n"));
1046     DoMethod(data->iwd_IconListObj, MUIM_IconList_Update);
1047
1048     D(bug("[IconWindow] IconWindow__MUIM_IconWindow_Open: Setting window as active ..\n"));
1049     SET(self, MUIA_Window_Activate, TRUE);
1050
1051     D(bug("[IconWindow] IconWindow__MUIM_IconWindow_Open: All done\n"));
1052     return TRUE;
1053 }
1054
1055 IPTR IconWindow__MUIM_IconWindow_DirectoryUp
1056 (
1057     Class *CLASS, Object *self, Msg message
1058 )
1059 {
1060     SETUP_ICONWINDOW_INST_DATA;
1061
1062     D(bug("[IconWindow] IconWindow__MUIM_IconWindow_DirectoryUp()\n"));
1063
1064     if (data->iwd_ActionHook)
1065     {
1066         struct IconWindow_ActionMsg msg;
1067         msg.type     = ICONWINDOW_ACTION_DIRUP;
1068         msg.iconlist = data->iwd_IconListObj;
1069         msg.isroot   = data->iwd_Flag_ISROOT;
1070         msg.click    = NULL;
1071         CallHookPkt(data->iwd_ActionHook, self, &msg);
1072
1073     }
1074
1075     return TRUE;
1076 }
1077
1078 IPTR IconWindow__MUIM_IconWindow_UnselectAll
1079 (
1080     Class *CLASS, Object *self, Msg message
1081 )
1082 {
1083     SETUP_ICONWINDOW_INST_DATA;
1084
1085     D(bug("[IconWindow] IconWindow__MUIM_IconWindow_UnselectAll()\n"));
1086
1087     DoMethod(data->iwd_IconListObj, MUIM_IconList_UnselectAll);
1088
1089     return TRUE;
1090 }
1091
1092 IPTR IconWindow__MUIM_IconWindow_Remove
1093 (
1094     Class *CLASS, Object *self, Msg message
1095 )
1096 {
1097     SETUP_ICONWINDOW_INST_DATA;
1098
1099     D(bug("[IconWindow] IconWindow__MUIM_IconWindow_Remove()\n"));
1100
1101     // Remove window
1102     SET( self, MUIA_Window_Open, FALSE );
1103     DoMethod ( _app(self), OM_REMMEMBER, self );
1104     DisposeObject(self);
1105
1106     return TRUE;
1107 }
1108
1109 /*** Stubs for Backfill Hooks ******************************************************************/
1110
1111 IPTR IconWindow__MUIM_IconWindow_BackFill_Register
1112 (
1113     Class *CLASS, Object *self, struct MUIP_IconWindow_BackFill_Register *message
1114 )
1115 {
1116 //    SETUP_ICONWINDOW_INST_DATA;
1117
1118     D(bug("[IconWindow] IconWindow__MUIM_IconWindow_BackFill_Register('%s')\n", message->register_Node->bfd_BackFillID));
1119
1120         AddTail(&iconwindow_BackFillNodes, message->register_Node);
1121         if (iconwindow_BackFill_Active == NULL) iconwindow_BackFill_Active = message->register_Node;
1122
1123     return TRUE;
1124 }
1125
1126 IPTR IconWindow__MUIM_IconWindow_BackFill_Setup
1127 (
1128     Class *CLASS, Object *self, struct MUIP_IconWindow_BackFill_Setup *message
1129 )
1130 {
1131     SETUP_ICONWINDOW_INST_DATA;
1132
1133     D(bug("[IconWindow] IconWindow__MUIM_IconWindow_BackFill_Setup()\n"));
1134
1135         if (iconwindow_BackFill_Active == NULL) return FALSE;
1136
1137         return (iconwindow_BackFill_Active->bfd_MUIM_IconWindow_BackFill_Setup)(CLASS, self, message);
1138 }
1139
1140 IPTR IconWindow__MUIM_IconWindow_BackFill_Cleanup
1141 (
1142     Class *CLASS, Object *self, struct MUIP_IconWindow_BackFill_Cleanup *message
1143 )
1144 {
1145     SETUP_ICONWINDOW_INST_DATA;
1146
1147     D(bug("[IconWindow] IconWindow__MUIM_IconWindow_BackFill_Cleanup()\n"));
1148
1149         if (iconwindow_BackFill_Active == NULL) return FALSE;
1150
1151         return (iconwindow_BackFill_Active->bfd_MUIM_IconWindow_BackFill_Cleanup)(CLASS, self, message);
1152 }
1153
1154 IPTR IconWindow__MUIM_IconWindow_BackFill_ProcessBackground
1155 (
1156     Class *CLASS, Object *self, struct MUIP_IconWindow_BackFill_ProcessBackground *message
1157 )
1158 {
1159     SETUP_ICONWINDOW_INST_DATA;
1160
1161         IPTR retVal = (IPTR)FALSE;
1162
1163     D(bug("[IconWindow] IconWindow__MUIM_IconWindow_BackFill_ProcessBackground()\n"));
1164
1165         if (iconwindow_BackFill_Active != NULL)
1166         {
1167         D(bug("[IconWindow] IconWindow__MUIM_IconWindow_BackFill_ProcessBackground: Asking module @ %x to process ..\n", iconwindow_BackFill_Active));
1168                 retVal = (iconwindow_BackFill_Active->bfd_MUIM_IconWindow_BackFill_ProcessBackground)(CLASS, self, message);
1169         }
1170
1171         if ((retVal == (IPTR)FALSE) && (data->iwd_RootViewObj != NULL))
1172         {
1173                 Object                *IconWindowPB_PrefsObj = NULL;
1174
1175         D(bug("[IconWindow] IconWindow__MUIM_IconWindow_BackFill_ProcessBackground: No BackFill module/ module cant render mode\n"));
1176         D(bug("[IconWindow] IconWindow__MUIM_IconWindow_BackFill_ProcessBackground: Using default MUI functions ..\n"));
1177
1178                 GET(_app(self), MUIA_Wanderer_Prefs, &IconWindowPB_PrefsObj);
1179                 if (IconWindowPB_PrefsObj)
1180                 {
1181                         IPTR IconWindowPB_Background = 0;
1182                         IPTR IconWindowPB_BGMode     = 0;
1183                         IPTR IconWindowPB_BGTileMode = 0;
1184
1185                         if ((IconWindowPB_Background = DoMethod(IconWindowPB_PrefsObj, MUIM_WandererPrefs_ViewSettings_GetAttribute, data->iwd_ViewSettings_Attrib, MUIA_Background)) != -1)
1186                         {
1187                                 if ((IconWindowPB_BGMode = DoMethod(IconWindowPB_PrefsObj, MUIM_WandererPrefs_ViewSettings_GetAttribute,
1188                                                                                                 data->iwd_ViewSettings_Attrib, MUIA_IconWindowExt_ImageBackFill_BGRenderMode)) == -1)
1189                                         IconWindowPB_BGMode = IconWindowExt_ImageBackFill_RenderMode_Tiled;
1190
1191                                 if ((IconWindowPB_BGTileMode = DoMethod(IconWindowPB_PrefsObj, MUIM_WandererPrefs_ViewSettings_GetAttribute,
1192                                                                                                                                         data->iwd_ViewSettings_Attrib, MUIA_IconWindowExt_ImageBackFill_BGTileMode)) == -1)
1193                                         IconWindowPB_BGTileMode = IconWindowExt_ImageBackFill_TileMode_Float;
1194
1195                                 SET(data->iwd_RootViewObj, MUIA_Background, IconWindowPB_Background);
1196
1197                                 char *bgmode_string = IconWindowPB_Background;
1198                                 BYTE this_mode = bgmode_string[0] - 48;
1199
1200                 D(bug("[IconWindow] IconWindow__MUIM_IconWindow_BackFill_ProcessBackground: MUI BG Mode = %d\n", this_mode));
1201
1202                                 switch (this_mode)
1203                                 {
1204                                     case 5:
1205                                             //Image =D
1206                                             if (IconWindowPB_BGMode == IconWindowExt_ImageBackFill_RenderMode_Scale)
1207                                             {
1208                                                     SET(data->iwd_RootViewObj, MUIA_IconListview_ScaledBackground, TRUE);
1209                                                     break;
1210                                             }
1211                                             else
1212                                                     SET(data->iwd_RootViewObj, MUIA_IconListview_ScaledBackground, FALSE);
1213
1214                                     case 0:
1215                                             //MUI Pattern
1216                                             if (IconWindowPB_BGTileMode == IconWindowExt_ImageBackFill_TileMode_Fixed)
1217                                                     SET(data->iwd_RootViewObj, MUIA_IconListview_FixedBackground, TRUE);
1218                                             else
1219                                                     SET(data->iwd_RootViewObj, MUIA_IconListview_FixedBackground, FALSE);
1220                                             break;
1221                                 }
1222                         }
1223                 }
1224                 retVal = FALSE;
1225         }
1226
1227         return retVal;
1228 }
1229
1230 IPTR IconWindow__MUIM_IconWindow_BackFill_DrawBackground
1231 (
1232     Class *CLASS, Object *self, struct MUIP_IconWindow_BackFill_DrawBackground *message
1233 )
1234 {
1235     SETUP_ICONWINDOW_INST_DATA;
1236
1237     D(bug("[IconWindow] IconWindow__MUIM_IconWindow_BackFill_DrawBackground()\n"));
1238
1239         if (iconwindow_BackFill_Active == NULL) return FALSE;
1240
1241         return (iconwindow_BackFill_Active->bfd_MUIM_IconWindow_BackFill_DrawBackground)(CLASS, self, message);
1242 }
1243
1244 IPTR IconWindow__SetupClass()
1245 {
1246     D(bug("[IconWindow] IconWindow__SetupClass()\n"));
1247
1248         NewList(&iconwindow_BackFillNodes);
1249         iconwindow_BackFill_Active = NULL;
1250
1251         return TRUE;
1252 }
1253
1254 /*** Setup ******************************************************************/
1255 ICONWINDOW_CUSTOMCLASS
1256 (
1257     IconWindow, NULL, MUIC_Window, NULL,
1258     OM_NEW,                                     struct opSet *,
1259     OM_DISPOSE,                                 Msg,
1260     OM_SET,                                     struct opSet *,
1261     OM_GET,                                     struct opGet *,
1262     MUIM_Window_Setup,                          Msg,
1263     MUIM_Window_Cleanup,                        Msg,
1264     MUIM_IconWindow_Open,                       Msg,
1265     MUIM_IconWindow_UnselectAll,                Msg,
1266     MUIM_IconWindow_DoubleClicked,              Msg,
1267     MUIM_IconWindow_IconsDropped,               Msg,
1268     MUIM_IconWindow_Clicked,                    Msg,
1269     MUIM_IconWindow_DirectoryUp,                Msg,
1270     MUIM_IconWindow_AppWindowDrop,              Msg,
1271     MUIM_IconWindow_Remove,                     Msg,
1272     MUIM_IconWindow_BackFill_Register,          struct MUIP_IconWindow_BackFill_Register *,
1273     MUIM_IconWindow_BackFill_Setup,             struct MUIP_IconWindow_BackFill_Setup *,
1274     MUIM_IconWindow_BackFill_Cleanup,           struct MUIP_IconWindow_BackFill_Cleanup *,
1275         MUIM_IconWindow_BackFill_ProcessBackground, struct MUIP_IconWindow_BackFill_ProcessBackground *,
1276         MUIM_IconWindow_BackFill_DrawBackground,    struct MUIP_IconWindow_BackFill_DrawBackground *
1277 );
1278
1279 ADD2INIT(IconWindow__SetupClass, 0);