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