?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Some compiler warnings removed.
[cake.git] / workbench / system / Wanderer / wanderer.c
blobc34e00f231474f6bd2ae643af88cd82eae9d4df8
1 /*
2 Copyright 2004-2009, The AROS Development Team. All rights reserved.
3 $Id$
4 */
5 #include "portable_macros.h"
6
7 #ifdef __AROS__
8 #define MUIMASTER_YES_INLINE_STDARG
9
10 #define DEBUG 0
11 #include <aros/debug.h>
12 #endif
13
14 #define WANDERER_DEFAULT_BACKDROP
15
16 #include <exec/types.h>
17 #include <libraries/gadtools.h>
18 #include <libraries/mui.h>
19
20 #ifdef __AROS__
21 #include <zune/customclasses.h>
22 #else
23 #include <zune_AROS/customclasses.h>
24 #endif
25
26 #include <dos/notify.h>
27
28 #ifdef __AROS__
29 #include <workbench/handler.h>
30 #else
31 #include <workbench_AROS/handler.h>
32 #endif
33
34 #include <proto/graphics.h>
35 #include <proto/utility.h>
36
37 #include <proto/dos.h>
38
39 #include <proto/icon.h>
40
41 #ifdef __AROS__
42 #include <proto/workbench.h>
43 #endif
44
45 #include <proto/layers.h>
46
47 #ifdef __AROS__
48 #include <proto/alib.h>
49 #endif
50
51 #include <string.h>
52 #include <stdio.h>
53 #include <time.h>
54
55
56 #ifdef __AROS__
57 #include <aros/detach.h>
58 #include <prefs/wanderer.h>
59 #else
60 #include <prefs_AROS/wanderer.h>
61 #endif
62
63 #if defined(__AMIGA__) && !defined(__PPC__)
64 #define NO_INLINE_STDARG
65 #endif
66 #include <proto/intuition.h>
67 #include <proto/muimaster.h>
68
69
70 #include "iconwindow.h"
71 #include "iconwindow_attributes.h"
72 #include "iconwindowcontents.h"
73 #include "wandererprefs.h"
74 #include "wandererprefsintern.h"
75 #include "filesystems.h"
76 #include "wanderer.h"
77 #include "Classes/iconlist.h"
78 #include "Classes/iconlist_attributes.h"
79 #include "locale.h"
80
81 #include "version.h"
82
83 #ifndef __AROS__
84 #define DEBUG 1
85
86 #ifdef DEBUG
87 #define D(x) if (DEBUG) x
88 #ifdef __amigaos4__
89 #define bug DebugPrintF
90 #else
91 #define bug kprintf
92 #endif
93 #else
94 #define D(...)
95 #endif
96 #endif
97
98 #ifndef NO_ICON_POSITION
99 #define NO_ICON_POSITION (0x8000000) /* belongs to workbench/workbench.h */
100 #endif
101
102 #define KeyButton(name,key) TextObject, ButtonFrame, MUIA_Font, MUIV_Font_Button, MUIA_Text_Contents, (IPTR)(name), MUIA_Text_PreParse, "\33c", MUIA_Text_HiChar, (IPTR)(key), MUIA_ControlChar, key, MUIA_InputMode, MUIV_InputMode_RelVerify, MUIA_Background, MUII_ButtonBack, TAG_DONE)
103
104 extern IPTR InitWandererPrefs(void);
105 VOID DoAllMenuNotifies(Object *strip, STRPTR path);
106 Object *FindMenuitem(Object* strip, int id);
107 Object *Wanderer__Func_CreateWandererIntuitionMenu(BOOL isRoot, BOOL useBackdrop);
108 void wanderer_menufunc_window_update(void);
109 void execute_open_with_command(BPTR cd, STRPTR contents);
110 void DisposeCopyDisplay(struct MUIDisplayObjects *d);
111 BOOL CreateCopyDisplay(UWORD flags, struct MUIDisplayObjects *d);
112
113 /* Stored in the main wanderer executable */
114 extern Object *_WandererIntern_AppObj;
115 extern Class *_WandererIntern_CLASS;
116 /* Internal Hooks */
117 #ifdef __AROS__
118 struct Hook _WandererIntern_hook_standard;
119 struct Hook _WandererIntern_hook_action;
120 struct Hook _WandererIntern_hook_backdrop;
121 #else
122 struct Hook *_WandererIntern_hook_standard;
123 struct Hook *_WandererIntern_hook_action;
124 struct Hook *_WandererIntern_hook_backdrop;
125 #endif
126
127 /*** Instance Data **********************************************************/
128 struct Wanderer_DATA
129 {
130 struct Screen *wd_Screen;
131
132 Object *wd_Prefs,
133 *wd_ActiveWindow,
134 *wd_WorkbenchWindow;
135
136 struct MUI_InputHandlerNode wd_TimerIHN;
137 struct MsgPort *wd_CommandPort;
138 struct MUI_InputHandlerNode wd_CommandIHN;
139 struct MsgPort *wd_NotifyPort;
140 struct MUI_InputHandlerNode wd_NotifyIHN;
141 struct NotifyRequest wd_PrefsNotifyRequest;
142
143 IPTR wd_PrefsIntern;
144 BOOL wd_Option_BackDropMode;
145 };
146
147 /*** Macros *****************************************************************/
148 #define SETUP_WANDERER_INST_DATA struct Wanderer_DATA *data = INST_DATA(CLASS, self)
149
150 /**************************************************************************
151 * HOOK FUNCS *
152 **************************************************************************/
153 ///Wanderer__HookFunc_DisplayCopyFunc()
154 #ifdef __AROS__
155 AROS_UFH3
156 (
157 BOOL, Wanderer__HookFunc_DisplayCopyFunc,
158 AROS_UFHA(struct Hook *, hook, A0),
159 AROS_UFHA(struct dCopyStruct *, obj, A2),
160 AROS_UFHA(APTR, unused_param, A1)
161 )
162 {
163 #else
164 HOOKPROTO(Wanderer__HookFunc_DisplayCopyFunc, BOOL, struct dCopyStruct *obj, APTR unused_param)
165 {
166 #endif
167 AROS_USERFUNC_INIT
168
169 struct MUIDisplayObjects *d = (struct MUIDisplayObjects *) obj->userdata;
170
171 if ((obj->flags & ACTION_UPDATE) == 0)
172 {
173 d->updateme = TRUE;
174
175 if ((obj->filelen < 8192) && (d->numfiles > 0))
176 {
177 d->smallobjects++;
178 if (d->smallobjects >= 20) d->smallobjects = 0;
179 }
180 else
181 {
182 d->smallobjects = 0;
183 }
184
185 if (d->smallobjects > 0)
186 d->updateme = FALSE;
187
188 if (d->updateme)
189 {
190 SET(d->fileObject, MUIA_Text_Contents, obj->file);
191 SET(d->sourceObject, MUIA_Text_Contents, obj->spath);
192 }
193 }
194 if (d->action != ACTION_DELETE)
195 {
196 d->bytes += obj->actlen;
197
198 if ((obj->flags & ACTION_UPDATE) == 0)
199 {
200 if (d->updateme)
201 {
202 SET(d->gauge, MUIA_Gauge_Current, 0);
203 SET(d->destObject, MUIA_Text_Contents, obj->dpath);
204 }
205 d->numfiles++;
206 }
207 else
208 {
209 if (d->updateme &&(obj->totallen <= obj->filelen))
210 {
211 double rate = (double) (((double) obj->totallen) / (((double) obj->difftime) / ((double) CLOCKS_PER_SEC))) / 1024.0;
212 if (rate < 1024.0) sprintf(d->SpeedBuffer, "%.2f kBytes/s", rate); else sprintf(d->SpeedBuffer, "%.2f MBytes/s", rate / 1024.0);
213 SetAttrs(d->gauge, MUIA_Gauge_Current, (ULONG) (32768.0 * (double) obj->totallen / (double) obj->filelen), MUIA_Gauge_InfoText, d->SpeedBuffer, TAG_DONE);
214 }
215 }
216
217 if (d->updateme)
218 {
219 if (d->bytes < 1048576)
220 {
221 if (obj->filelen < 1048576)
222 {
223 sprintf(
224 d->Buffer, "%s %ld %s %.2f kBytes %s %.2f kBytes",
225 _(MSG_WANDERER_FILEACCESS_NOOFFILES), d->numfiles, _(MSG_WANDERER_FILEACCESS_ACTUAL), (double) obj->filelen / 1024.0, _(MSG_WANDERER_FILEACCESS_TOTAL), (double) d->bytes / 1024.0
226 );
227 }
228 else
229 {
230 sprintf(
231 d->Buffer, "%s %ld %s %.2f MBytes %s %.2f kBytes",
232 _(MSG_WANDERER_FILEACCESS_NOOFFILES), d->numfiles, _(MSG_WANDERER_FILEACCESS_ACTUAL), (double) obj->filelen / 1048576.0, _(MSG_WANDERER_FILEACCESS_TOTAL), (double) d->bytes / 1024.0
233 );
234 }
235 }
236 else
237 {
238 if (obj->filelen < 1048576)
239 {
240 sprintf(
241 d->Buffer, "%s %ld %s %.2f kBytes %s %.2f MBytes",
242 _(MSG_WANDERER_FILEACCESS_NOOFFILES), d->numfiles, _(MSG_WANDERER_FILEACCESS_ACTUAL), (double) obj->filelen / 1024.0, _(MSG_WANDERER_FILEACCESS_TOTAL), (double) d->bytes / 1048576.0
243 );
244 }
245 else
246 {
247 sprintf(
248 d->Buffer, "%s %ld %s %.2f MBytes %s %.2f MBytes",
249 _(MSG_WANDERER_FILEACCESS_NOOFFILES), d->numfiles, _(MSG_WANDERER_FILEACCESS_ACTUAL), (double) obj->filelen / 1048576.0, _(MSG_WANDERER_FILEACCESS_TOTAL), (double) d->bytes / 1048576.0
250 );
251 }
252 }
253 SET(d->performanceObject, MUIA_Text_Contents, d->Buffer);
254 }
255 }
256
257 DoMethod(d->copyApp, MUIM_Application_InputBuffered);
258
259 /* read the stopflag and return TRUE if the user wanted to stop actionDir() */
260 if (d->stopflag == 1)
261 return TRUE;
262 else
263 return FALSE;
264
265 AROS_USERFUNC_EXIT
266 }
267 #ifndef __AROS__
268 MakeStaticHook(Hook_DisplayCopyFunc,Wanderer__HookFunc_DisplayCopyFunc);
269 #endif
270 ///
271
272 ///Wanderer__HookFunc_AskDeleteFunc()
273 #ifdef __AROS__
274 AROS_UFH3
275 (
276 ULONG, Wanderer__HookFunc_AskDeleteFunc,
277 AROS_UFHA(struct Hook *, hook, A0),
278 AROS_UFHA(struct dCopyStruct *, obj, A2),
279 AROS_UFHA(APTR, unused_param, A1)
280 )
281 {
282 #else
283 HOOKPROTO(Wanderer__HookFunc_AskDeleteFunc, ULONG, struct dCopyStruct *obj, APTR unused_param)
284 {
285 #endif
286 AROS_USERFUNC_INIT
287
288 ULONG back = DELMODE_NONE;
289
290 UWORD ret = 0;
291 char *string = NULL;
292
293 if (obj->file)
294 {
295 if (obj->type == 0)
296 {
297 string = CombineString("%s\n\033b%s\033n\n%s\n\033b%s\033n %s",
298 _(MSG_REQU_DELETE_FILE_S), obj->file, _(MSG_REQU_DELETE_FILE_M), obj->spath, _(MSG_REQU_DELETE_FILE_E) );
299 }
300 else if (obj->type == 1)
301 {
302 string = CombineString("%s\n\033b%s\033n\n%s\n\033b%s\033n %s",
303 _(MSG_REQU_FILEUNPROTECT_S), obj->file, _(MSG_REQU_FILEUNPROTECT_M), obj->spath, _(MSG_REQU_FILEUNPROTECT_E) );
304 }
305 else if (obj->type == 2)
306 {
307 string = CombineString("%s\n\033b%s\033n\n%s\n\033b%s\033n %s",
308 _(MSG_REQU_OVERWRITE_S), obj->file, _(MSG_REQU_OVERWRITE_M), obj->spath, _(MSG_REQU_OVERWRITE_E) );
309 }
310 else
311 {
312 string = CombineString("%s\n\033b%s\033n\n%s\n\033b%s\033n%s",
313 _(MSG_NOFILEACCESS_S), obj->file, _(MSG_NOFILEACCESS_M), obj->spath, _(MSG_NOFILEACCESS_E) );
314 }
315 }
316 else
317 {
318 if (obj->type == 0) string = CombineString("%s \033b%s\033n %s", _(MSG_REQU_DELETE_DRAWER_S), obj->spath, _(MSG_REQU_DELETE_DRAWER_E) );
319 else if (obj->type == 1) string = CombineString("%s\n\033b%s\033n %s", _(MSG_REQU_PROTECTION_UNPROTECTDRAWER_S), obj->spath, _(MSG_REQU_PROTECTION_UNPROTECTDRAWER_E) );
320 else if (obj->type == 3) string = CombineString("%s\n\033b%s %s", _(MSG_NODRAWERACCESS_S), obj->spath, _(MSG_NODRAWERACCESS_E) );
321 }
322
323 if (string)
324 {
325 if (obj->type == 0) ret = AskChoiceCentered( _(MSG_REQU_DELETE), string, _(MSG_REQU_DELETE_YESNO), 0);
326 else if (obj->type == 1) ret = AskChoiceCentered( _(MSG_REQU_PROTECTION), string, _(MSG_REQU_PROTECTION_UNPROTECT), 0);
327 else if (obj->type == 2) ret = AskChoiceCentered( _(MSG_REQU_OVERWRITE), string, _(MSG_REQU_OVERWRITE_YESNO), 0);
328 else ret = AskChoiceCentered( _(MSG_REQU_OVERWRITE), string, _(MSG_REQU_OVERWRITE_SKIPABORT), 0);
329 freeString(NULL, string);
330 }
331
332 if (ret == 0) back = DELMODE_NONE;
333 else if (ret == 1) back = DELMODE_DELETE;
334 else if (ret == 2) back = DELMODE_ALL;
335 else if (ret == 3) back = DELMODE_NO;
336
337 return back;
338
339 AROS_USERFUNC_EXIT
340 }
341 #ifndef __AROS__
342 MakeStaticHook(Hook_AskDeleteFunc,Wanderer__HookFunc_AskDeleteFunc);
343 #endif
344 ///
345
346 ///Wanderer__Func_CopyDropEntries()
347 void Wanderer__Func_CopyDropEntries()
348 {
349 /* get filelist from user message */
350 struct Wanderer_FilelistMsg *message_filelist = FindTask(NULL)->tc_UserData;
351
352 D(bug("[Wanderer] Wanderer__Func_CopyDropEntries()\n" ));
353
354 if (message_filelist)
355 {
356
357 struct MUIDisplayObjects dobjects;
358 struct Wanderer_FileEntry *currententry;
359 #ifdef __AROS__
360 struct Hook displayCopyHook;
361 struct Hook displayDelHook;
362 #else
363 struct Hook *displayCopyHook;
364 struct Hook *displayDelHook;
365 #endif
366
367 #ifdef __AROS__
368 displayCopyHook.h_Entry = (HOOKFUNC) Wanderer__HookFunc_DisplayCopyFunc;
369 displayDelHook.h_Entry = (HOOKFUNC) Wanderer__HookFunc_AskDeleteFunc;
370 #else
371 displayCopyHook = &Hook_DisplayCopyFunc;
372 displayDelHook = &Hook_AskDeleteFunc;
373 #endif
374
375 if (CreateCopyDisplay(ACTION_COPY, &dobjects))
376 {
377 /* process all selected entries */
378 while ((currententry = (struct Wanderer_FileEntry *)RemTail(&message_filelist->files)) != NULL)
379 {
380 /* copy via filesystems.c */
381 D(bug("[Wanderer] Wanderer__Func_CopyDropEntries: Copying '%s' to '%s'\n", &currententry->filename, &message_filelist->destination_string));
382
383 CopyContent(NULL,
384 (char *)&currententry->filename, (char *)&message_filelist->destination_string,
385 TRUE, ACTION_COPY, &displayCopyHook, &displayDelHook, (APTR) &dobjects);
386
387 FreeVec( currententry );
388 }
389 /* delete copy window */
390 DisposeCopyDisplay(&dobjects);
391 }
392 }
393
394 /* free msg memory */
395 FreeMem(message_filelist, sizeof(struct Wanderer_FilelistMsg));
396
397 return;
398 }
399 ///
400
401 ///Wanderer__HookFunc_ActionFunc()
402 #ifdef __AROS__
403 AROS_UFH3
404 (
405 void, Wanderer__HookFunc_ActionFunc,
406 AROS_UFHA(struct Hook *, hook, A0),
407 AROS_UFHA(Object *, obj, A2),
408 AROS_UFHA(struct IconWindow_ActionMsg *, msg, A1)
409 )
410 {
411 #else
412 HOOKPROTO(Wanderer__HookFunc_ActionFunc, void, Object *obj, struct IconWindow_ActionMsg *msg)
413 {
414 #endif
415 AROS_USERFUNC_INIT
416
417 if (msg->type == ICONWINDOW_ACTION_OPEN)
418 {
419 static unsigned char buf[1024];
420 IPTR offset;
421 struct IconList_Entry *ent = (void*)MUIV_IconList_NextIcon_Start;
422
423 DoMethod(msg->iconlist, MUIM_IconList_NextIcon, MUIV_IconList_NextIcon_Selected, (IPTR)&ent);
424 if ((IPTR)ent == (IPTR)MUIV_IconList_NextIcon_End)
425 {
426 D(bug("[WANDERER] Wanderer__HookFunc_ActionFunc: ICONWINDOW_ACTION_OPEN: NextIcon returned MUIV_IconList_NextIcon_TAG_DONE)\n"));
427 return;
428 }
429
430 offset = strlen(ent->filename) - 5;
431
432 if ((msg->isroot) && (ent->type == ST_ROOT))
433 {
434 strcpy((STRPTR)buf, ent->label);
435 }
436 else
437 {
438 strcpy((STRPTR)buf, ent->filename);
439 }
440
441 D(bug("[WANDERER] Wanderer__HookFunc_ActionFunc: ICONWINDOW_ACTION_OPEN - offset = %d, buf = %s\n", offset, buf);)
442
443 if ((ent->type == ST_ROOT) || (ent->type == ST_USERDIR) || (ent->type == ST_LINKDIR))
444 {
445 Object *cstate = (Object*)(((struct List*)XGET(_app(obj), MUIA_Application_WindowList))->lh_Head);
446 Object *prefs = (Object*) XGET(_app(obj), MUIA_Wanderer_Prefs);
447 Object *child;
448
449 /* open new window if root or classic navigation set */
450 if ( (msg->isroot) || (XGET(prefs, MUIA_IconWindowExt_Toolbar_NavigationMethod) == WPD_NAVIGATION_CLASSIC) )
451 {
452 while ((child = NextObject(&cstate)))
453 {
454 if (XGET(child, MUIA_UserData))
455 {
456 STRPTR child_drawer = (STRPTR)XGET(child, MUIA_IconWindow_Location);
457 if (child_drawer && !Stricmp(buf,(CONST_STRPTR)child_drawer))
458 {
459 BOOL is_open = ( BOOL )XGET(child, MUIA_Window_Open);
460
461 if (!is_open)
462 {
463 DoMethod(child, MUIM_IconWindow_Open);
464 }
465 else
466 {
467 DoMethod(child, MUIM_Window_ToFront);
468 SET(child, MUIA_Window_Activate, TRUE);
469 }
470
471 return;
472 }
473 }
474 }
475
476 /* Check if the window for this drawer is already opened */
477 DoMethod(_WandererIntern_AppObj, MUIM_Wanderer_CreateDrawerWindow, (IPTR) buf);
478 // FIXME: error handling
479 }
480 else
481 {
482 /* open drawer in same window */
483 SET(obj, MUIA_IconWindow_Location, (IPTR) buf);
484 }
485
486 }
487 else if ((ent->type == ST_FILE) || (ent->type == ST_LINKFILE))
488 {
489 BPTR newwd, oldwd, file;
490
491 /* Set the CurrentDir to the path of the executable to be started */
492 file = Lock(ent->filename, SHARED_LOCK);
493 if(file)
494 {
495 newwd = ParentDir(file);
496 oldwd = CurrentDir(newwd);
497
498 if (!OpenWorkbenchObject(ent->filename, TAG_DONE))
499 {
500 execute_open_with_command(newwd, FilePart(ent->filename));
501 }
502
503 CurrentDir(oldwd);
504 UnLock(newwd);
505 UnLock(file);
506 }
507 }
508 }
509 else if (msg->type == ICONWINDOW_ACTION_DIRUP)
510 {
511
512 STRPTR actual_drawer = (STRPTR)XGET(obj, MUIA_IconWindow_Location);
513 STRPTR parent_drawer = strrchr(actual_drawer,'/');
514 STRPTR root_drawer = strrchr(actual_drawer,':');
515
516 /* check if dir is not drive root dir */
517 if ( strlen(root_drawer) > 1 )
518 {
519 /* check if second or third level directory*/
520 if (!parent_drawer)
521 {
522 (*(root_drawer+1)) = 0;
523 SET(obj, MUIA_IconWindow_Location, actual_drawer);
524
525 }
526 else
527 {
528 (*parent_drawer) = 0;
529 SET(obj, MUIA_IconWindow_Location, actual_drawer);
530 }
531
532 }
533 }
534 else if (msg->type == ICONWINDOW_ACTION_CLICK)
535 {
536 if (!msg->click->shift)
537 {
538 Object *cstate = (Object*)(((struct List*)XGET(_WandererIntern_AppObj, MUIA_Application_WindowList))->lh_Head);
539 Object *child;
540
541 while ((child = NextObject(&cstate)))
542 {
543 if (XGET(child, MUIA_UserData))
544 {
545 if (child != obj) DoMethod(child, MUIM_IconWindow_UnselectAll);
546 }
547 }
548 }
549 }
550 else if (msg->type == ICONWINDOW_ACTION_ICONDROP)
551 {
552 struct Process *child;
553
554 struct IconList_Drop *drop = (struct IconList_Drop *)msg->drop;
555 struct IconList_Entry *ent = (void*)MUIV_IconList_NextIcon_Start;
556 struct Wanderer_FileEntry *file_recordtmp;
557
558 struct Wanderer_FilelistMsg *message_filelist = NULL;
559
560 if ((message_filelist = AllocMem(sizeof(struct Wanderer_FilelistMsg), MEMF_CLEAR|MEMF_PUBLIC )) != NULL)
561 {
562 strcpy( (char*)&message_filelist->destination_string,(STRPTR) drop->destination_string);
563 #ifdef __AROS__
564 NEWLIST(&message_filelist->files);
565 #else
566 NEW_LIST(&message_filelist->files);
567 #endif
568 /* process all selected entries */
569 do
570 {
571 DoMethod((Object *)drop->source_iconlistobj, MUIM_IconList_NextIcon, MUIV_IconList_NextIcon_Selected, (IPTR) &ent);
572
573 /* if not end of selection, process */
574 if ( (int)ent != MUIV_IconList_NextIcon_End)
575 {
576 file_recordtmp = AllocVec( sizeof(struct Wanderer_FileEntry), MEMF_CLEAR|MEMF_PUBLIC );
577 strcpy( (char*)&file_recordtmp->filename, ent->filename);
578 AddTail(&message_filelist->files, (struct Node *)file_recordtmp);
579 }
580 }
581 while ((int)ent != MUIV_IconList_NextIcon_End);
582
583 {
584 /* create process and copy files within */
585 const struct TagItem tags[]=
586 {
587 {NP_Entry , (IPTR)Wanderer__Func_CopyDropEntries },
588 {NP_Name , (IPTR)"wanderer copy" },
589 {NP_UserData , (IPTR)message_filelist },
590 {NP_StackSize, 40000 },
591 {TAG_DONE , 0 }
592 };
593
594 child = CreateNewProc(tags);
595 }
596 #warning "TODO: update list contents"
597 /* this one should be solved through file notofications, as files are copied in a seperate process now */
598 }
599 }
600 else if (msg->type == ICONWINDOW_ACTION_APPWINDOWDROP)
601 {
602 struct Screen *wscreen = NULL;
603 struct Layer *layer;
604
605 /* get wanderers screen struct and the layer located at cursor position afterwards */
606 get( obj, MUIA_Window_Screen, &wscreen);
607 layer = WhichLayer(&wscreen->LayerInfo,wscreen->MouseX,wscreen->MouseY);
608
609 if (layer)
610 {
611 struct Window *win = (struct Window *) layer->Window;
612 if (win)
613 {
614 struct List AppList;
615 ULONG files = 0;
616 BOOL fail = FALSE;
617 struct IconList_Entry *ent;
618
619 NewList(&AppList);
620
621 ent = (void*)MUIV_IconList_NextIcon_Start;
622 /* process all selected entries */
623 do
624 {
625 DoMethod(msg->iconlist, MUIM_IconList_NextIcon, MUIV_IconList_NextIcon_Selected, (IPTR) &ent);
626 /* if not end of selection, process */
627 if ( (int)ent != MUIV_IconList_NextIcon_End )
628 {
629 struct AppW *a = AllocVec(sizeof(struct AppW), MEMF_CLEAR);
630 if (a)
631 {
632 a->name = AllocVec(strlen(ent->filename)+1, MEMF_CLEAR);
633 if (a->name)
634 {
635 files++;
636 strcpy(a->name, ent->filename);
637 AddTail(&AppList, (struct Node *) a);
638 }
639 else
640 {
641 FreeVec(a);
642 fail = TRUE;
643 }
644 }
645 else fail = TRUE;
646 }
647 }
648 while ( ((int)ent != MUIV_IconList_NextIcon_End) && !fail);
649
650 if (!fail && (files > 0))
651 {
652 STRPTR *filelist = AllocVec(sizeof(STRPTR) * files, MEMF_CLEAR);
653 if (filelist != NULL)
654 {
655 STRPTR *flist = filelist;
656 if (!IsListEmpty(&AppList))
657 {
658 struct Node *succ;
659 struct Node *s = AppList.lh_Head;
660 while (((succ = ((struct Node*) s)->ln_Succ) != NULL) && !fail)
661 {
662 *flist ++ = ((struct AppW *) s)->name;
663 s = succ;
664 }
665
666 D(bug("[WANDERER] AppWindowMsg: win:%s files:%s mx:%d my:%d\n",win->Title, filelist, wscreen->MouseX - win->LeftEdge, wscreen->MouseY - win->TopEdge);)
667 /* send appwindow msg struct containing selected files to destination */
668 SendAppWindowMessage(win, files, (char **)filelist, 0, wscreen->MouseX - win->LeftEdge, wscreen->MouseY - win->TopEdge, 0, 0);
669
670 }
671 FreeVec(filelist);
672 }
673 }
674 if (!IsListEmpty(&AppList))
675 {
676 struct Node *succ;
677 struct Node *s = AppList.lh_Head;
678 while (((succ = ((struct Node*) s)->ln_Succ) != NULL))
679 {
680 if ( ((struct AppW *) s)->name != NULL )
681 FreeVec(((struct AppW *) s)->name);
682 if ( s != NULL )
683 FreeVec(s);
684 s = succ;
685 }
686 }
687 }
688 }
689 }
690
691 AROS_USERFUNC_EXIT
692 }
693 #ifndef __AROS__
694 MakeStaticHook(Hook_ActionFunc,Wanderer__HookFunc_ActionFunc);
695 #endif
696 ///
697
698 ///Wanderer__HookFunc_StandardFunc()
699 #ifdef __AROS__
700 AROS_UFH3
701 (
702 void, Wanderer__HookFunc_StandardFunc,
703 AROS_UFHA(struct Hook *, hook, A0),
704 AROS_UFHA(void *, dummy, A2),
705 AROS_UFHA(void **, funcptr, A1)
706 )
707 {
708 #else
709 HOOKPROTO(Wanderer__HookFunc_StandardFunc, void, void *dummy, void **funcptr)
710 {
711 #endif
712 AROS_USERFUNC_INIT
713
714 void (*func) (ULONG *) = (void (*)(ULONG *)) (*funcptr);
715 if (func) func((ULONG *)(funcptr + 1));
716
717 AROS_USERFUNC_EXIT
718 }
719 #ifndef __AROS__
720 MakeStaticHook(Hook_StandardFunc,Wanderer__HookFunc_StandardFunc);
721 #endif
722 ///
723
724 ///Wanderer__HookFunc_BackdropFunc()
725 #ifdef __AROS__
726 AROS_UFH3
727 (
728 void, Wanderer__HookFunc_BackdropFunc,
729 AROS_UFHA(struct Hook *, hook, A0),
730 AROS_UFHA(void *, dummy, A2),
731 AROS_UFHA(void **, funcptr, A1)
732 )
733 {
734 #else
735 HOOKPROTO(Wanderer__HookFunc_BackdropFunc, void, void *dummy, void **funcptr)
736 {
737 #endif
738 AROS_USERFUNC_INIT
739
740 struct Wanderer_DATA *data = INST_DATA(_WandererIntern_CLASS, _WandererIntern_AppObj);
741 BOOL wb_iscurrentlybd;
742
743 D(bug("[WANDERER] Wanderer__HookFunc_BackdropFunc()\n"));
744 D(bug("[WANDERER] Wanderer__HookFunc_BackdropFunc: Private data @ %x\n", data));
745
746 if (!data->wd_WorkbenchWindow)
747 {
748 D(bug("[WANDERER] Wanderer__HookFunc_BackdropFunc: No Workbench Window\n"));
749 return;
750 }
751
752 wb_iscurrentlybd = (BOOL)XGET(data->wd_WorkbenchWindow, MUIA_IconWindow_IsBackdrop);
753
754 if (wb_iscurrentlybd != data->wd_Option_BackDropMode)
755 {
756 BOOL isOpen = (BOOL)XGET(data->wd_WorkbenchWindow, MUIA_Window_Open);
757 Object *win_Active = NULL;
758
759 D(bug("[WANDERER] Wanderer__HookFunc_BackdropFunc: Backdrop mode change requested!\n"));
760 D(bug("[WANDERER] Wanderer__HookFunc_BackdropFunc: Disposing of existing Workbench window Obj ..\n"));
761 if (isOpen)
762 SET(data->wd_WorkbenchWindow, MUIA_Window_Open, FALSE);
763
764 if (data->wd_WorkbenchWindow == data->wd_ActiveWindow)
765 {
766 data->wd_ActiveWindow = NULL;
767 }
768 else
769 {
770 win_Active = data->wd_ActiveWindow;
771 }
772
773 /* Kill our close request notification .. */
774 DoMethod
775 (
776 data->wd_WorkbenchWindow, MUIM_KillNotify, MUIA_Window_CloseRequest
777 );
778
779 /* .. And dispose of the window */
780 DoMethod(_WandererIntern_AppObj, OM_REMMEMBER, data->wd_WorkbenchWindow);
781 MUI_DisposeObject(data->wd_WorkbenchWindow);
782 data->wd_WorkbenchWindow = NULL;
783
784 #if defined(DEBUG)
785 if (data->wd_Option_BackDropMode)
786 {
787 D(bug("[WANDERER] Wanderer__HookFunc_BackdropFunc: Creating new Workbench window Obj (BACKDROP MODE)..\n"));
788 }
789 else
790 {
791 D(bug("[WANDERER] Wanderer__HookFunc_BackdropFunc: Creating new Workbench window Obj (NORMAL MODE)..\n"));
792 }
793 #endif
794 data->wd_WorkbenchWindow = (Object *) DoMethod
795 (
796 _WandererIntern_AppObj, MUIM_Wanderer_CreateDrawerWindow, (IPTR) NULL
797 );
798
799 if ((data->wd_WorkbenchWindow) && (isOpen))
800 {
801 D(bug("[WANDERER] Wanderer__HookFunc_BackdropFunc: Making Workbench window visable..\n"));
802 DoMethod(data->wd_WorkbenchWindow, MUIM_IconWindow_Open);
803 DoMethod(data->wd_WorkbenchWindow, MUIM_Window_ToBack);
804 }
805
806 if (win_Active)
807 {
808 SET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow, win_Active);
809 }
810 else if (data->wd_WorkbenchWindow)
811 {
812 SET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow, data->wd_WorkbenchWindow);
813 }
814 }
815 AROS_USERFUNC_EXIT
816 }
817 #ifndef __AROS__
818 MakeStaticHook(Hook_BackdropFunc,Wanderer__HookFunc_BackdropFunc);
819 #endif
820 ///
821 /******** code from workbench/c/Info.c *******************/
822 ///fmtlarge()
823 static void fmtlarge(UBYTE *buf, ULONG num)
824 {
825 UQUAD d;
826 UBYTE *ch;
827 struct
828 {
829 IPTR val;
830 IPTR dec;
831 } array =
832 {
833 num,
834 0
835 };
836
837 if (num >= 0x40000000)
838 {
839 array.val = num >> 30;
840 d = ((UQUAD)num * 10 + 0x20000000) / 0x40000000;
841 array.dec = d % 10;
842 //ch = 'G';
843 ch = _(MSG_MEM_G);
844 }
845 else if (num >= 0x100000)
846 {
847 array.val = num >> 20;
848 d = ((UQUAD)num * 10 + 0x80000) / 0x100000;
849 array.dec = d % 10;
850 //ch = 'M';
851 ch = _(MSG_MEM_M);
852 }
853 else if (num >= 0x400)
854 {
855 array.val = num >> 10;
856 d = (num * 10 + 0x200) / 0x400;
857 array.dec = d % 10;
858 //ch = 'K';
859 ch = _(MSG_MEM_K);
860 }
861 else
862 {
863 array.val = num;
864 array.dec = 0;
865 d = 0;
866 //ch = 'B';
867 ch = _(MSG_MEM_B);
868 }
869
870 if (!array.dec && (d > array.val * 10))
871 {
872 array.val++;
873 }
874
875 RawDoFmt(array.dec ? "%lu.%lu" : "%lu", &array, NULL, buf);
876 while (*buf) { buf++; }
877 *buf++ = *ch;
878 *buf = '\0';
879 }
880 ///
881
882 ///GetScreenTitle()
883 STRPTR GetScreenTitle(VOID)
884 {
885 static TEXT title[256];
886 UBYTE chip[10], fast[10];
887 ULONG __availMem;
888
889 __availMem = AvailMem(MEMF_CHIP);
890 fmtlarge(chip, __availMem);
891 __availMem = AvailMem(MEMF_FAST);
892 fmtlarge(fast, __availMem);
893
894 sprintf(title, _(MSG_SCREENTITLE), chip, fast);
895
896 return title;
897 }
898 ///
899
900 ///GetUserScreenTitle()
901 STRPTR GetUserScreenTitle(Object *self)
902 {
903 /*Work in progress :-)
904 */
905 char *screentitlestr;
906 int screentitleleng;
907
908 GET(self, MUIA_IconWindowExt_ScreenTitle_String, &screentitlestr);
909
910 screentitleleng = strlen(screentitlestr);
911
912 if (screentitleleng<1)
913 {
914 return GetScreenTitle();
915 }
916 return screentitlestr;
917
918 }
919 ///
920
921 ///ExpandEnvName()
922 /* Expand a passed in env: string to its full location */
923 /* Wanderer doesnt free this mem at the moment but should
924 incase it is every closed */
925 STRPTR ExpandEnvName(STRPTR env_path)
926 {
927 BOOL ok = FALSE;
928 char tmp_envbuff[1024];
929 STRPTR fullpath = NULL;
930 BPTR env_lock = (BPTR) NULL;
931
932 env_lock = Lock("ENV:", SHARED_LOCK);
933 if (env_lock)
934 {
935 if (NameFromLock(env_lock, tmp_envbuff, 256)) ok = TRUE;
936 UnLock(env_lock);
937 }
938
939 if (ok)
940 {
941 if ((fullpath = AllocVec(strlen(tmp_envbuff) + strlen(env_path) + 1 + 1 - 4, MEMF_CLEAR | MEMF_PUBLIC)) != NULL)
942 {
943 strcpy(fullpath, tmp_envbuff);
944 AddPart(fullpath, env_path + 4, 1019);
945 return fullpath;
946 }
947 }
948
949 //We couldnt expand it so just use as is ..
950 return env_path;
951 }
952 ///
953
954 enum
955 {
956 MEN_WANDERER = 1,
957 MEN_WANDERER_BACKDROP,
958 MEN_WANDERER_EXECUTE,
959 MEN_WANDERER_SHELL,
960 MEN_WANDERER_AROS_GUISETTINGS,
961 MEN_WANDERER_AROS_ABOUT,
962 MEN_WANDERER_ABOUT,
963 MEN_WANDERER_QUIT,
964 MEN_WANDERER_SHUTDOWN,
965
966 MEN_WINDOW_NEW_DRAWER,
967 MEN_WINDOW_OPEN_PARENT,
968 MEN_WINDOW_CLOSE,
969 MEN_WINDOW_UPDATE,
970
971 MEN_WINDOW_SELECT,
972 MEN_WINDOW_CLEAR,
973
974 MEN_WINDOW_SNAP_WIN,
975 MEN_WINDOW_SNAP_ALL,
976
977 MEN_WINDOW_VIEW_ICON,
978 MEN_WINDOW_VIEW_DETAIL,
979 MEN_WINDOW_VIEW_ALL,
980 MEN_WINDOW_VIEW_HIDDEN,
981
982 MEN_WINDOW_SORT_NOW,
983 MEN_WINDOW_SORT_NAME,
984 MEN_WINDOW_SORT_TYPE,
985 MEN_WINDOW_SORT_DATE,
986 MEN_WINDOW_SORT_SIZE,
987 MEN_WINDOW_SORT_REVERSE,
988 MEN_WINDOW_SORT_TOPDRAWERS,
989 MEN_WINDOW_SORT_GROUP,
990
991 MEN_ICON_OPEN,
992 MEN_ICON_RENAME,
993 MEN_ICON_INFORMATION,
994 MEN_ICON_SNAPSHOT,
995 MEN_ICON_UNSNAPSHOT,
996 MEN_ICON_LEAVEOUT,
997 MEN_ICON_PUTAWAY,
998 MEN_ICON_DELETE,
999 MEN_ICON_FORMAT,
1000 MEN_ICON_EMPTYTRASH
1001 };
1002
1003
1004 ///execute_open_with_command()
1005 /**************************************************************************
1006 Open the execute window. Similar to below but you can also set the
1007 command. Called when item is openend
1008 **************************************************************************/
1009 void execute_open_with_command(BPTR cd, STRPTR contents)
1010 {
1011 BPTR lock;
1012
1013 if (cd !=(BPTR) NULL) lock = cd;
1014 else lock = Lock("RAM:", ACCESS_READ);
1015
1016 OpenWorkbenchObject
1017 (
1018 "WANDERER:Tools/ExecuteCommand",
1019 WBOPENA_ArgLock, (IPTR) lock,
1020 WBOPENA_ArgName, (IPTR) contents,
1021 TAG_DONE
1022 );
1023
1024 if (cd ==(BPTR) NULL) UnLock(lock);
1025 }
1026 ///
1027
1028 ///wanderer_menufunc_wanderer_execute()
1029 /**************************************************************************
1030 Open the execute window
1031
1032 This function will always get the current drawer as argument
1033 **************************************************************************/
1034 VOID wanderer_menufunc_wanderer_execute(STRPTR *cdptr)
1035 {
1036 //TODO: remove the STRPTR *cdptr from top
1037 //TODO:remove this commented out stuff
1038 //BPTR lock = NULL;
1039 //if (cdptr != NULL) lock = Lock(*cdptr, SHARED_LOCK);
1040 Object *win = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1041 STRPTR dr = ( STRPTR )XGET( win, MUIA_IconWindow_Location );
1042 BPTR cd = Lock(dr,SHARED_LOCK);
1043 execute_open_with_command(cd, NULL);
1044 if (cd) UnLock(cd);
1045 }
1046 /*******************************/
1047 ///
1048
1049 ///wanderer_menufunc_wanderer_shell()
1050 void wanderer_menufunc_wanderer_shell(STRPTR *cd_ptr)
1051 {
1052 //TODO: remove the STRPTR *cdptr from top
1053 //TODO:remove this commented out stuff
1054 //BPTR cd = Lock(*cd_ptr,ACCESS_READ);
1055 Object *win = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1056 STRPTR dr = ( STRPTR )XGET( win, MUIA_IconWindow_Location );
1057 BPTR cd;
1058
1059 if (!dr)
1060 {
1061 dr = "";
1062 }
1063
1064 cd = Lock(dr, ACCESS_READ);
1065 if (SystemTags("NewShell", NP_CurrentDir, (IPTR)cd, TAG_DONE) == -1)
1066 {
1067 UnLock(cd);
1068 }
1069 }
1070 ///
1071
1072 ///wanderer_menufunc_wanderer_backdrop()
1073 void wanderer_menufunc_wanderer_backdrop(Object **pstrip)
1074 {
1075 struct Wanderer_DATA *data = INST_DATA(_WandererIntern_CLASS, _WandererIntern_AppObj);
1076 Object *strip = *pstrip;
1077 Object *item = FindMenuitem(strip, MEN_WANDERER_BACKDROP);
1078
1079 D(bug("[WANDERER] wanderer_menufunc_wanderer_backdrop()\n"));
1080
1081 if (item != NULL)
1082 {
1083 data->wd_Option_BackDropMode = (BOOL)XGET(item, MUIA_Menuitem_Checked);
1084 SET(data->wd_WorkbenchWindow, MUIA_IconWindow_IsBackdrop, data->wd_Option_BackDropMode);
1085 }
1086 }
1087 ///
1088
1089 ///wanderer_menufunc_window_newdrawer()
1090 void wanderer_menufunc_window_newdrawer(STRPTR *cdptr)
1091 {
1092 //TODO: remove the STRPTR *cdptr from top
1093
1094 Object *win = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1095 STRPTR dr = ( STRPTR )XGET( win, MUIA_IconWindow_Location );
1096 Object *actwindow = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1097 Object *wbwindow = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_WorkbenchWindow);
1098 BPTR lock;
1099
1100 D(bug("[wanderer] wanderer_menufunc_window_newdrawer(%s)\n", dr));
1101 if (actwindow == wbwindow)
1102 {
1103 /* This check is necessary because WorkbenchWindow has path RAM: */
1104 D(bug("[wanderer] wanderer_menufunc_window_newdrawer: Can't call WBNewDrawer for WorkbenchWindow\n"));
1105 return;
1106 }
1107 if ( XGET(actwindow, MUIA_Window_Open) == FALSE )
1108 {
1109 D(bug("[wanderer] wanderer_menufunc_window_newdrawer: Can't call WBNewDrawer: the active window isn't open\n"));
1110 return;
1111 }
1112
1113 lock = Lock(dr, ACCESS_READ);
1114 OpenWorkbenchObject
1115 (
1116 "WANDERER:Tools/WBNewDrawer",
1117 WBOPENA_ArgLock, (IPTR) lock,
1118 WBOPENA_ArgName, 0,
1119 TAG_DONE
1120 );
1121 UnLock(lock);
1122 }
1123 ///
1124
1125 ///wanderer_menufunc_window_openparent()
1126 void wanderer_menufunc_window_openparent(STRPTR *cdptr)
1127 {
1128 //TODO: Remove the **cdptr stuff from top
1129 Object *win = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1130 STRPTR dr = ( STRPTR )XGET( win, MUIA_IconWindow_Location );
1131
1132 IPTR path_len=0;
1133 STRPTR last_letter=NULL;
1134 STRPTR thispath;
1135 STRPTR buf;
1136 Object *cstate;
1137 Object *child;
1138 BOOL foundSlash, foundColon;
1139 int i = 0;
1140
1141 last_letter = &dr[ strlen(dr) - 1 ];
1142
1143 thispath = FilePart(dr);
1144
1145 if (*last_letter==0x3a) return; /* Top Drawer has no parent to open */
1146
1147 last_letter = &thispath[strlen(thispath)-1];
1148
1149 if (*last_letter==0x3a)
1150 path_len = (IPTR)(thispath-(IPTR)(dr));
1151 else
1152 path_len = (IPTR)((thispath-(IPTR)(dr))-1);
1153
1154 buf = AllocVec((path_len+1),MEMF_PUBLIC|MEMF_CLEAR);
1155 CopyMem(dr, buf, path_len);
1156
1157 cstate = (Object*)(((struct List*)XGET(_WandererIntern_AppObj, MUIA_Application_WindowList))->lh_Head);
1158
1159
1160 // Make sure we have a correct path
1161 foundSlash = FALSE, foundColon = FALSE;
1162 i = 0; for ( ; i < path_len; i++ )
1163 {
1164 if ( buf[ i ] == '/' ) foundSlash = TRUE;
1165 if ( buf[ i ] == ':' ) foundColon = TRUE;
1166 }
1167 if ( !foundColon && !foundSlash )
1168 {
1169 STRPTR newbuf = AllocVec ((path_len + 2), MEMF_PUBLIC|MEMF_CLEAR);
1170 sprintf(newbuf,"%s:",buf);
1171 FreeVec (buf);
1172 buf = newbuf;
1173 }
1174 // Done with path correction check
1175
1176 while ((child = NextObject(&cstate)))
1177 {
1178 if (XGET(child, MUIA_UserData))
1179 {
1180 STRPTR child_drawer = (STRPTR)XGET(child, MUIA_IconWindow_Location);
1181 if (child_drawer && !Stricmp(buf,child_drawer))
1182 {
1183 int is_open = XGET(child, MUIA_Window_Open);
1184 if (!is_open)
1185 DoMethod(child, MUIM_IconWindow_Open);
1186 else
1187 {
1188 DoMethod(child, MUIM_Window_ToFront);
1189 SET(child, MUIA_Window_Activate, TRUE);
1190 }
1191 FreeVec(buf);
1192 return;
1193 }
1194 }
1195 }
1196
1197 DoMethod(_WandererIntern_AppObj, MUIM_Wanderer_CreateDrawerWindow, (IPTR) buf);
1198 FreeVec(buf);
1199 }
1200 ///
1201
1202 ///wanderer_menufunc_window_close()
1203 void wanderer_menufunc_window_close()
1204 {
1205 Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1206 SET(window, MUIA_Window_CloseRequest, TRUE);
1207 }
1208 ///
1209
1210 ///wanderer_menufunc_window_update()
1211 void wanderer_menufunc_window_update()
1212 {
1213 Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1214 Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1215
1216 if (iconList != NULL)
1217 {
1218 DoMethod(iconList, MUIM_IconList_Update);
1219 }
1220 }
1221 ///
1222
1223 ///wanderer_menufunc_window_clear()
1224 void wanderer_menufunc_window_clear()
1225 {
1226 Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1227 Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1228
1229 if (iconList != NULL)
1230 {
1231 DoMethod(iconList, MUIM_IconList_UnselectAll);
1232 }
1233 }
1234 ///
1235
1236 ///wanderer_menufunc_window_select()
1237 void wanderer_menufunc_window_select()
1238 {
1239 Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1240 Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1241
1242 if (iconList != NULL)
1243 {
1244 DoMethod(iconList, MUIM_IconList_SelectAll);
1245 }
1246 }
1247 ///
1248
1249 ///wanderer_menufunc_window_snapshot()
1250 void wanderer_menufunc_window_snapshot(IPTR *flags)
1251 {
1252 Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1253 Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1254 char *dir_name = (char *)XGET(window, MUIA_IconWindow_Location);
1255 struct DiskObject *drawericon = NULL;
1256 IPTR geticon_error = 0;
1257 IPTR display_bits = 0, sort_bits = 0;
1258 BOOL snapshot_all = *flags;
1259
1260 D(bug("[wanderer] wanderer_menufunc_window_snapshot()\n"));
1261 D(bug("[wanderer] wanderer_menufunc_window_snapshot: Dir '%s'\n", dir_name));
1262
1263 if (snapshot_all == TRUE)
1264 {
1265 struct IconList_Entry *icon_entry = (IPTR)MUIV_IconList_NextIcon_Start;
1266 struct IconEntry *node = NULL;
1267 struct TagItem icon_tags[] =
1268 {
1269 { ICONPUTA_OnlyUpdatePosition, TRUE },
1270 { TAG_DONE, 0 }
1271 };
1272 D(bug("[wanderer] wanderer_menufunc_window_snapshot: snapshot ALL\n"));
1273
1274 do
1275 {
1276 DoMethod(iconList, MUIM_IconList_NextIcon, MUIV_IconList_NextIcon_Visible, (IPTR)&icon_entry);
1277
1278 if ((IPTR)icon_entry != MUIV_IconList_NextIcon_End)
1279 {
1280 node = (struct IconEntry *)((IPTR)icon_entry - ((IPTR)&node->ile_IconListEntry - (IPTR)node));
1281 D(bug("[wanderer] wanderer_menufunc_window_snapshot: SNAPSHOT entry = '%s' @ %p, (%p)\n", icon_entry->filename, icon_entry, node));
1282 if (node->ile_DiskObj)
1283 {
1284 node->ile_DiskObj->do_CurrentX = node->ile_IconX;
1285 node->ile_DiskObj->do_CurrentY = node->ile_IconY;
1286 PutIconTagList(icon_entry->filename, node->ile_DiskObj, icon_tags);
1287 }
1288 else
1289 {
1290 D(bug("[wanderer] wanderer_menufunc_window_snapshot: icon has no diskobj!\n"));
1291 }
1292 }
1293 else
1294 {
1295 break;
1296 }
1297 } while (TRUE);
1298 }
1299 else
1300 {
1301 D(bug("[wanderer] wanderer_menufunc_window_snapshot: snapshot WINDOW\n"));
1302 }
1303
1304 drawericon = GetIconTags(dir_name,
1305 ICONGETA_FailIfUnavailable, FALSE,
1306 ICONA_ErrorCode, &geticon_error,
1307 TAG_DONE);
1308
1309 if (drawericon != NULL)
1310 {
1311 if (drawericon->do_DrawerData == NULL)
1312 {
1313 D(bug("[wanderer] wanderer_menufunc_window_snapshot: Icon for '%s' has no DRAWER data!\n", dir_name));
1314 drawericon->do_DrawerData = AllocMem(sizeof(struct DrawerData), MEMF_CLEAR|MEMF_PUBLIC);
1315 }
1316
1317 drawericon->do_Gadget.UserData = (APTR)1;
1318
1319 drawericon->do_DrawerData->dd_NewWindow.TopEdge = XGET(window, MUIA_Window_TopEdge);
1320 drawericon->do_DrawerData->dd_NewWindow.LeftEdge = XGET(window, MUIA_Window_LeftEdge);
1321 drawericon->do_DrawerData->dd_NewWindow.Width = XGET(window, MUIA_Window_Width);
1322 drawericon->do_DrawerData->dd_NewWindow.Height = XGET(window, MUIA_Window_Height);
1323
1324 GET(iconList, MUIA_IconList_DisplayFlags, &display_bits);
1325 if (display_bits & ICONLIST_DISP_SHOWINFO)
1326 {
1327 D(bug("[wanderer] wanderer_menufunc_window_snapshot: ICONLIST_DISP_SHOWINFO\n"));
1328 drawericon->do_DrawerData->dd_Flags = 1;
1329 }
1330 else
1331 {
1332 drawericon->do_DrawerData->dd_Flags = 2;
1333 }
1334
1335 #warning "TODO: Icon sort flags are only really for text list mode ... fix"
1336 GET(iconList, MUIA_IconList_SortFlags, &sort_bits);
1337 if (sort_bits & ICONLIST_SORT_BY_DATE)
1338 {
1339 drawericon->do_DrawerData->dd_ViewModes = 3;
1340 }
1341 else if (sort_bits & ICONLIST_SORT_BY_SIZE)
1342 {
1343 drawericon->do_DrawerData->dd_ViewModes = 4;
1344 }
1345 else
1346 {
1347 drawericon->do_DrawerData->dd_ViewModes = 2;
1348 }
1349 PutDiskObject(dir_name, drawericon);
1350 }
1351 }
1352 ///
1353
1354 ///wanderer_menufunc_window_view_icons(Object **pstrip)
1355 void wanderer_menufunc_window_view_icons(Object **pstrip)
1356 {
1357 Object *strip = *pstrip;
1358 Object *item = FindMenuitem(strip, MEN_WINDOW_VIEW_ALL);
1359 Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1360 Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1361
1362 if ((item != NULL) && (iconList != NULL))
1363 {
1364 IPTR display_bits = 0, menu_view_state = 0;
1365 GET(iconList, MUIA_IconList_DisplayFlags, &display_bits);
1366
1367 GET(item, MUIA_Menuitem_Checked, &menu_view_state);
1368
1369 if (menu_view_state)
1370 {
1371 display_bits &= ~ICONLIST_DISP_SHOWINFO;
1372 }
1373 else
1374 {
1375 display_bits |= ICONLIST_DISP_SHOWINFO;
1376 }
1377
1378 SET(iconList, MUIA_IconList_DisplayFlags, display_bits);
1379 DoMethod(iconList, MUIM_IconList_Sort);
1380 }
1381 }
1382 ///
1383
1384 ///wanderer_menufunc_window_view_hidden(Object **pstrip)
1385 void wanderer_menufunc_window_view_hidden(Object **pstrip)
1386 {
1387 Object *strip = *pstrip;
1388 Object *item = FindMenuitem(strip, MEN_WINDOW_VIEW_HIDDEN);
1389 Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1390 Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1391
1392 if ((item != NULL) && (iconList != NULL))
1393 {
1394 IPTR display_bits = 0, menu_view_state = 0;
1395 GET(iconList, MUIA_IconList_DisplayFlags, &display_bits);
1396
1397 GET(item, MUIA_Menuitem_Checked, &menu_view_state);
1398
1399 if (menu_view_state)
1400 {
1401 display_bits |= ICONLIST_DISP_SHOWHIDDEN;
1402 }
1403 else
1404 {
1405 display_bits &= ~ICONLIST_DISP_SHOWHIDDEN;
1406 }
1407
1408 SET(iconList, MUIA_IconList_DisplayFlags, display_bits);
1409 DoMethod(iconList, MUIM_IconList_Sort);
1410 }
1411 }
1412 ///
1413
1414 ///wanderer_menufunc_window_sort_name()
1415 void wanderer_menufunc_window_sort_name(Object **pstrip)
1416 {
1417 Object *strip = *pstrip;
1418 Object *item = FindMenuitem(strip, MEN_WINDOW_SORT_NAME);
1419 Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1420 Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1421
1422 if (item != NULL && iconList != NULL)
1423 {
1424 IPTR sort_bits = 0;
1425 GET(iconList, MUIA_IconList_SortFlags, &sort_bits);
1426
1427 /*name = date and size bit both NOT set*/
1428 sort_bits &= ~ICONLIST_SORT_MASK;
1429 if( XGET(item, MUIA_Menuitem_Checked) )
1430 {
1431 sort_bits |= ICONLIST_SORT_BY_NAME;
1432 }
1433 SET(iconList, MUIA_IconList_SortFlags, sort_bits);
1434 DoMethod(iconList, MUIM_IconList_Sort);
1435 }
1436 }
1437 ///
1438
1439 ///wanderer_menufunc_window_sort_date()
1440 void wanderer_menufunc_window_sort_date(Object **pstrip)
1441 {
1442 Object *strip = *pstrip;
1443 Object *item = FindMenuitem(strip, MEN_WINDOW_SORT_DATE);
1444 Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1445 Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1446
1447 if (item != NULL && iconList != NULL)
1448 {
1449 IPTR sort_bits = 0;
1450 GET(iconList, MUIA_IconList_SortFlags, &sort_bits);
1451
1452 /*exclude size bit*/
1453 sort_bits &= ~ICONLIST_SORT_MASK;
1454 if( XGET(item, MUIA_Menuitem_Checked) )
1455 {
1456 sort_bits |= ICONLIST_SORT_BY_DATE;
1457 }
1458 SET(iconList, MUIA_IconList_SortFlags, sort_bits);
1459 DoMethod(iconList, MUIM_IconList_Sort);
1460 }
1461 }
1462 ///
1463
1464 ///wanderer_menufunc_window_sort_size()
1465 void wanderer_menufunc_window_sort_size(Object **pstrip)
1466 {
1467 Object *strip = *pstrip;
1468 Object *item = FindMenuitem(strip, MEN_WINDOW_SORT_SIZE);
1469 Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1470 Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1471
1472 if (item != NULL && iconList != NULL)
1473 {
1474 IPTR sort_bits = 0;
1475 GET(iconList, MUIA_IconList_SortFlags, &sort_bits);
1476
1477 /*exclude date bit*/
1478 sort_bits &= ~ICONLIST_SORT_MASK;
1479 if( XGET(item, MUIA_Menuitem_Checked) )
1480 {
1481 sort_bits |= ICONLIST_SORT_BY_SIZE;
1482 }
1483 SET(iconList, MUIA_IconList_SortFlags, sort_bits);
1484 DoMethod(iconList, MUIM_IconList_Sort);
1485 }
1486 }
1487 ///
1488
1489 ///wanderer_menufunc_window_sort_type()
1490 void wanderer_menufunc_window_sort_type(Object **pstrip)
1491 {
1492 Object *strip = *pstrip;
1493 Object *item = FindMenuitem(strip, MEN_WINDOW_SORT_TYPE);
1494 Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1495 Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1496
1497 if (item != NULL && iconList != NULL)
1498 {
1499 IPTR sort_bits = 0;
1500 GET(iconList, MUIA_IconList_SortFlags, &sort_bits);
1501
1502 /*type = all sort bits set (name+date+size) */
1503 sort_bits &= ~ICONLIST_SORT_MASK;
1504 if( XGET(item, MUIA_Menuitem_Checked) )
1505 {
1506 sort_bits |= ICONLIST_SORT_MASK;
1507 }
1508 SET(iconList, MUIA_IconList_SortFlags, sort_bits);
1509 DoMethod(iconList, MUIM_IconList_Sort);
1510 }
1511 }
1512 ///
1513
1514 ///wanderer_menufunc_window_sort_reverse()
1515 void wanderer_menufunc_window_sort_reverse(Object **pstrip)
1516 {
1517 Object *strip = *pstrip;
1518 Object *item = FindMenuitem(strip, MEN_WINDOW_SORT_REVERSE);
1519 Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1520 Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1521
1522 if (item != NULL && iconList != NULL)
1523 {
1524 IPTR sort_bits = 0;
1525 GET(iconList, MUIA_IconList_SortFlags, &sort_bits);
1526
1527 if( XGET(item, MUIA_Menuitem_Checked) )
1528 {
1529 sort_bits |= ICONLIST_SORT_REVERSE;
1530 }
1531 else
1532 {
1533 sort_bits &= ~ICONLIST_SORT_REVERSE;
1534 }
1535
1536 SET(iconList, MUIA_IconList_SortFlags, sort_bits);
1537 DoMethod(iconList, MUIM_IconList_Sort);
1538 }
1539 }
1540 ///
1541
1542 ///wanderer_menufunc_window_sort_topdrawers()
1543 void wanderer_menufunc_window_sort_topdrawers(Object **pstrip)
1544 {
1545 Object *strip = *pstrip;
1546 Object *item = FindMenuitem(strip, MEN_WINDOW_SORT_TOPDRAWERS);
1547 Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1548 Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1549
1550 if (item != NULL && iconList != NULL)
1551 {
1552 IPTR sort_bits = 0;
1553 GET(iconList, MUIA_IconList_SortFlags, &sort_bits);
1554
1555 if( XGET(item, MUIA_Menuitem_Checked) )
1556 {
1557 sort_bits &= !ICONLIST_SORT_DRAWERS_MIXED;
1558 }
1559 else
1560 {
1561 sort_bits |= ICONLIST_SORT_DRAWERS_MIXED;
1562 }
1563
1564 SET(iconList, MUIA_IconList_SortFlags, sort_bits);
1565 DoMethod(iconList, MUIM_IconList_Sort);
1566 }
1567 }
1568 ///
1569
1570 ///wanderer_menufunc_icon_open()
1571 void wanderer_menufunc_icon_open()
1572 {
1573 Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1574 DoMethod(window, MUIM_IconWindow_DoubleClicked);
1575 }
1576 ///
1577
1578 ///wanderer_menufunc_icon_rename()
1579 void wanderer_menufunc_icon_rename(void)
1580 {
1581 Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1582 Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1583 struct IconList_Entry *entry = (APTR) MUIV_IconList_NextIcon_Start;
1584
1585 do
1586 {
1587 DoMethod(iconList, MUIM_IconList_NextIcon, MUIV_IconList_NextIcon_Selected, (IPTR) &entry);
1588
1589 if ((int)entry != MUIV_IconList_NextIcon_End)
1590 {
1591 BPTR lock = Lock(entry->filename, ACCESS_READ);
1592 BPTR parent = ParentDir(lock);
1593 UnLock(lock);
1594
1595 D(bug("[wanderer] wanderer_menufunc_icon_rename: selected = '%s'\n", entry->filename));
1596
1597 OpenWorkbenchObject
1598 (
1599 "WANDERER:Tools/WBRename",
1600 WBOPENA_ArgLock, (IPTR) parent,
1601 WBOPENA_ArgName, (IPTR) FilePart(entry->filename),
1602 TAG_DONE
1603 );
1604
1605 D(bug("[wanderer] wanderer_menufunc_icon_rename: selected = '%s'\n", entry->filename));
1606
1607 UnLock(parent);
1608 }
1609 else
1610 {
1611 break;
1612 }
1613 } while (TRUE);
1614 }
1615 ///
1616
1617 ///wanderer_menufunc_icon_information()
1618 void wanderer_menufunc_icon_information()
1619 {
1620 Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1621 Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1622 struct IconList_Entry *entry = (IPTR)MUIV_IconList_NextIcon_Start;
1623
1624 do
1625 {
1626 DoMethod(iconList, MUIM_IconList_NextIcon, MUIV_IconList_NextIcon_Selected, (IPTR)&entry);
1627
1628 if ((IPTR)entry != MUIV_IconList_NextIcon_End)
1629 {
1630 BPTR lock, parent;
1631 STRPTR name;
1632
1633 D(bug("[wanderer] wanderer_menufunc_icon_information: selected = '%s'\n", entry->filename));
1634 lock = Lock(entry->filename, ACCESS_READ);
1635 name = FilePart(entry->filename);
1636 if (name[0]) {
1637 parent = ParentDir(lock);
1638 UnLock(lock);
1639 } else
1640 parent = lock;
1641
1642 D(bug("[wanderer] wanderer_menufunc_icon_information: name = '%s' lock = 0x%08lX\n", name, lock));
1643 WBInfo(parent, name, NULL);
1644
1645 UnLock(parent);
1646 }
1647 else
1648 {
1649 break;
1650 }
1651 } while (TRUE);
1652 }
1653 ///
1654
1655 ///wanderer_menufunc_icon_snapshot()
1656 void wanderer_menufunc_icon_snapshot(IPTR *flags)
1657 {
1658 Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1659 Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1660 struct IconList_Entry *entry = (IPTR)MUIV_IconList_NextIcon_Start;
1661 struct IconEntry *node = NULL;
1662 BOOL snapshot = *flags;
1663 struct TagItem icontags[] =
1664 {
1665 { ICONPUTA_OnlyUpdatePosition, TRUE },
1666 { TAG_DONE, 0 }
1667 };
1668
1669 D(bug("[wanderer] wanderer_menufunc_icon_snapshot()\n"));
1670
1671 do
1672 {
1673 DoMethod(iconList, MUIM_IconList_NextIcon, MUIV_IconList_NextIcon_Selected, (IPTR)&entry);
1674
1675 if ((IPTR)entry != MUIV_IconList_NextIcon_End)
1676 {
1677 node = (struct IconEntry *)((IPTR)entry - ((IPTR)&node->ile_IconListEntry - (IPTR)node));
1678 D(bug("[wanderer] wanderer_menufunc_icon_snapshot: %s entry = '%s' @ %p, (%p)\n", (snapshot) ? "SNAPSHOT" : "UNSNAPSHOT", entry->filename, entry, node));
1679 if (node->ile_DiskObj)
1680 {
1681 if (snapshot)
1682 {
1683 node->ile_DiskObj->do_CurrentX = node->ile_IconX;
1684 node->ile_DiskObj->do_CurrentY = node->ile_IconY;
1685 }
1686 else
1687 {
1688 node->ile_DiskObj->do_CurrentX = NO_ICON_POSITION;
1689 node->ile_DiskObj->do_CurrentY = NO_ICON_POSITION;
1690 }
1691 PutIconTagList(entry->filename, node->ile_DiskObj, icontags);
1692 D(bug("[wanderer] wanderer_menufunc_icon_snapshot: saved ..\n"));
1693 }
1694 else
1695 {
1696 D(bug("[wanderer] wanderer_menufunc_icon_snapshot: icon has no diskobj!\n"));
1697 }
1698 }
1699 else
1700 {
1701 break;
1702 }
1703 } while (TRUE);
1704 D(bug("[wanderer] wanderer_menufunc_icon_snapshot: finished ..\n"));
1705 }
1706
1707 ///wanderer_menufunc_icon_leaveout()
1708 void wanderer_menufunc_icon_leaveout(void)
1709 {
1710 Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1711 Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1712 struct IconList_Entry *entry = (IPTR)MUIV_IconList_NextIcon_Start;
1713 struct IconEntry *node = NULL;
1714 char *leavout_dir = NULL;
1715
1716 D(bug("[wanderer] wanderer_menufunc_icon_leaveout()\n"));
1717
1718 GET(window, MUIA_IconWindow_Location, &leavout_dir);
1719
1720 if (leavout_dir != NULL)
1721 {
1722 D(bug("[wanderer] wanderer_menufunc_icon_leaveout: dir '%s'\n", leavout_dir));
1723 do
1724 {
1725 DoMethod(iconList, MUIM_IconList_NextIcon, MUIV_IconList_NextIcon_Selected, (IPTR)&entry);
1726
1727 if (((IPTR)entry != MUIV_IconList_NextIcon_End) && ((entry->type == ST_FILE) || (entry->type == ST_USERDIR)))
1728 {
1729 node = (struct IconEntry *)((IPTR)entry - ((IPTR)&node->ile_IconListEntry - (IPTR)node));
1730 D(bug("[wanderer] wanderer_menufunc_icon_leaveout: entry = '%s' @ %p, (%p)\n", entry->filename, entry, node));
1731 }
1732 else
1733 {
1734 break;
1735 }
1736 } while (TRUE);
1737 }
1738
1739 D(bug("[wanderer] wanderer_menufunc_icon_leaveout: finished ..\n"));
1740 }
1741
1742 ///wanderer_menufunc_icon_putaway()
1743 void wanderer_menufunc_icon_putaway(void)
1744 {
1745 Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1746 Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1747 struct IconList_Entry *entry = (IPTR)MUIV_IconList_NextIcon_Start;
1748 struct IconEntry *node = NULL;
1749 struct List putawayicons;
1750
1751 D(bug("[wanderer] wanderer_menufunc_icon_putaway()\n"));
1752
1753 NEWLIST(&putawayicons);
1754
1755 do
1756 {
1757 DoMethod(iconList, MUIM_IconList_NextIcon, MUIV_IconList_NextIcon_Selected, (IPTR)&entry);
1758
1759 if (((IPTR)entry != MUIV_IconList_NextIcon_End) && ((entry->type == ST_LINKFILE) || (entry->type == ST_LINKDIR)))
1760 {
1761 node = (struct IconEntry *)((IPTR)entry - ((IPTR)&node->ile_IconListEntry - (IPTR)node));
1762 D(bug("[wanderer] wanderer_menufunc_icon_putaway: entry = '%s' @ %p, (%p)\n", entry->filename, entry, node));
1763 /* Remove the node from the iconlist .. */
1764 /* Add it to our internal list for cleanup.. */
1765 //AddTail(&putawayicons, node);
1766 }
1767 else
1768 {
1769 break;
1770 }
1771 } while (TRUE);
1772 D(bug("[wanderer] wanderer_menufunc_icon_putaway: finished ..\n"));
1773 }
1774
1775 ///DisposeCopyDisplay()
1776 /* dispose the file copy display */
1777 void DisposeCopyDisplay(struct MUIDisplayObjects *d)
1778 {
1779 if (d->copyApp)
1780 {
1781 //SET(d->win,MUIA_Window_Open,FALSE);
1782 MUI_DisposeObject(d->copyApp);
1783 }
1784 }
1785 ///
1786
1787 ///CreateCopyDisplay()
1788 /* create the file copy window */
1789 BOOL CreateCopyDisplay(UWORD flags, struct MUIDisplayObjects *d)
1790 {
1791 BOOL back = FALSE;
1792
1793 Object *group, *fromObject, *toObject, *fileTextObject, *fileLengthObject, *gaugeGroup;
1794
1795 d->stopflag = 0; // will be set to 1 when clicking on stop, than the displayhook can tell actionDir() to stop copy
1796 d->bytes = 0;
1797 d->numfiles = 0;
1798 d->action = flags;
1799 d->smallobjects = 0;
1800 d->copyApp = MUI_NewObject(MUIC_Application,
1801 MUIA_Application_Title, (IPTR)"CopyRequester",
1802 MUIA_Application_Base, (IPTR)"WANDERER_COPY",
1803 MUIA_Application_Window, (IPTR)(d->win = MUI_NewObject(MUIC_Window,
1804 MUIA_Window_Title, (IPTR)_(MSG_WANDERER_FILEACCESS),
1805 MUIA_Window_Activate, TRUE,
1806 MUIA_Window_DepthGadget, TRUE,
1807 MUIA_Window_DragBar, TRUE,
1808 MUIA_Window_SizeGadget, TRUE,
1809 MUIA_Window_AppWindow, FALSE,
1810 MUIA_Window_CloseGadget, FALSE,
1811 MUIA_Window_Borderless, FALSE,
1812 MUIA_Window_TopEdge, MUIV_Window_TopEdge_Centered,
1813 MUIA_Window_LeftEdge, MUIV_Window_LeftEdge_Centered,
1814 MUIA_Window_Width, MUIV_Window_Width_Visible(60),
1815 WindowContents, (group = MUI_NewObject(MUIC_Group,
1816 Child, (IPTR)(fromObject = MUI_NewObject(MUIC_Text,
1817 MUIA_InnerLeft,(8),
1818 MUIA_InnerRight,(8),
1819 MUIA_InnerTop,(2),
1820 MUIA_InnerBottom,(2),
1821 MUIA_Text_PreParse, (IPTR)"\33c",
1822 TAG_DONE)),
1823 Child, (IPTR)(d->sourceObject = MUI_NewObject(MUIC_Text,
1824 TextFrame,
1825 MUIA_InnerLeft,(8),
1826 MUIA_InnerRight,(8),
1827 MUIA_InnerTop,(2),
1828 MUIA_InnerBottom,(2),
1829 MUIA_Background, MUII_TextBack,
1830 MUIA_Text_PreParse, (IPTR)"\33c",
1831 MUIA_Text_Contents, (IPTR)"---",
1832 TAG_DONE)),
1833 Child, (IPTR)(toObject = MUI_NewObject(MUIC_Text,
1834 MUIA_InnerLeft,(8),
1835 MUIA_InnerRight,(8),
1836 MUIA_InnerTop,(2),
1837 MUIA_InnerBottom,(2),
1838 MUIA_Text_PreParse, (IPTR)"\33c",
1839 TAG_DONE)),
1840 Child, (IPTR)(d->destObject = MUI_NewObject(MUIC_Text,
1841 TextFrame,
1842 MUIA_InnerLeft,(8),
1843 MUIA_InnerRight,(8),
1844 MUIA_InnerTop,(2),
1845 MUIA_InnerBottom,(2),
1846 MUIA_Background, MUII_TextBack,
1847 MUIA_Text_PreParse, (IPTR)"\33c",
1848 MUIA_Text_Contents, (IPTR)"---",
1849 TAG_DONE)),
1850 Child, (IPTR)(fileTextObject = MUI_NewObject(MUIC_Text,
1851 MUIA_InnerLeft,(8),
1852 MUIA_InnerRight,(8),
1853 MUIA_InnerTop,(2),
1854 MUIA_InnerBottom,(2),
1855 MUIA_Text_PreParse, (IPTR)"\33c",
1856 TAG_DONE)),
1857 Child, (IPTR)(d->fileObject = MUI_NewObject(MUIC_Text,
1858 TextFrame,
1859 MUIA_InnerLeft,(8),
1860 MUIA_InnerRight,(8),
1861 MUIA_InnerTop,(2),
1862 MUIA_InnerBottom,(2),
1863 MUIA_Background, MUII_TextBack,
1864 MUIA_Text_PreParse, (IPTR)"\33c",
1865 MUIA_Text_Contents, (IPTR)"---",
1866 TAG_DONE)),
1867 Child, (IPTR)(fileLengthObject = MUI_NewObject(MUIC_Text,
1868 MUIA_InnerLeft,(8),
1869 MUIA_InnerRight,(8),
1870 MUIA_InnerTop,(2),
1871 MUIA_InnerBottom,(2),
1872 MUIA_Text_PreParse, (IPTR)"\33c",
1873 TAG_DONE)),
1874 Child, (IPTR)(gaugeGroup = MUI_NewObject(MUIC_Group,
1875 TextFrame,
1876 Child, d->gauge = MUI_NewObject(MUIC_Gauge,
1877 MUIA_Gauge_Horiz, TRUE,
1878 MUIA_Gauge_Max, 32768,
1879 MUIA_Gauge_InfoText, _(MSG_WANDERER_FILEACCESS_PROCESSING),
1880 TAG_DONE),
1881 Child, MUI_NewObject(MUIC_Scale,
1882 MUIA_Scale_Horiz, TRUE,
1883 TAG_DONE),
1884 TAG_DONE)),
1885 Child, (IPTR)( d->performanceObject = MUI_NewObject(MUIC_Text,
1886 TextFrame,
1887 MUIA_InnerLeft,(8),
1888 MUIA_InnerRight,(8),
1889 MUIA_InnerTop,(2),
1890 MUIA_InnerBottom,(2),
1891 MUIA_Background, MUII_TextBack,
1892 MUIA_Text_PreParse, (IPTR)"\33c",
1893 MUIA_Text_Contents, (IPTR)"...........0 Bytes...........",
1894 TAG_DONE)),
1895
1896 Child, (IPTR)( d->stopObject = SimpleButton( _(MSG_WANDERER_FILEACCESS_STOP) ) ),
1897 TAG_DONE)),
1898 TAG_DONE)),
1899 TAG_DONE);
1900
1901
1902 if (d->copyApp)
1903 {
1904 if ((flags & (ACTION_COPY|ACTION_DELETE)) == (ACTION_COPY|ACTION_DELETE))
1905 {
1906 SET(fromObject, MUIA_Text_Contents, (IPTR) _(MSG_WANDERER_FILEACCESS_MOVEFROM) );
1907 SET(toObject, MUIA_Text_Contents, (IPTR) _(MSG_WANDERER_FILEACCESS_MOVETO) );
1908 SET(fileTextObject, MUIA_Text_Contents, (IPTR) _(MSG_WANDERER_FILEACCESS_FILE) );
1909 SET(fileLengthObject, MUIA_Text_Contents, (IPTR) _(MSG_WANDERER_FILEACCESS_TRAFFIC) );
1910 }
1911 else if ((flags & ACTION_COPY) == ACTION_COPY)
1912 {
1913 SET(fromObject, MUIA_Text_Contents, (IPTR) _(MSG_WANDERER_FILEACCESS_COPYFROM) );
1914 SET(toObject, MUIA_Text_Contents, (IPTR) _(MSG_WANDERER_FILEACCESS_COPYTO) );
1915 SET(fileTextObject, MUIA_Text_Contents, (IPTR) _(MSG_WANDERER_FILEACCESS_FILE) );
1916 SET(fileLengthObject, MUIA_Text_Contents, (IPTR) _(MSG_WANDERER_FILEACCESS_TRAFFIC) );
1917
1918 }
1919 else if ((flags & ACTION_DELETE) == ACTION_DELETE)
1920 {
1921 SET(fromObject, MUIA_Text_Contents, _(MSG_WANDERER_FILEACCESS_DELETEFROM) );
1922 DoMethod(group, MUIM_Group_InitChange);
1923 DoMethod(group, OM_REMMEMBER, toObject);
1924 DoMethod(group, OM_REMMEMBER, fileLengthObject);
1925 DoMethod(group, OM_REMMEMBER, d->performanceObject);
1926 DoMethod(group, OM_REMMEMBER, d->destObject);
1927 DoMethod(group, OM_REMMEMBER, gaugeGroup);
1928 DoMethod(group, MUIM_Group_ExitChange);
1929 SET(fileTextObject, MUIA_Text_Contents, _(MSG_WANDERER_FILEACCESS_FILETODELETE) );
1930 }
1931
1932 SET(d->win,MUIA_Window_Open,TRUE);
1933 DoMethod(d->stopObject,MUIM_Notify, MUIA_Pressed, FALSE, d->stopObject, 3, MUIM_WriteLong, 1 ,&d->stopflag);
1934 back = TRUE;
1935 }
1936 return back;
1937 }
1938 ///
1939
1940 ///wanderer_menufunc_icon_delete()
1941 void wanderer_menufunc_icon_delete(void)
1942 {
1943 Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1944 Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1945 struct IconList_Entry *entry = ( void*) MUIV_IconList_NextIcon_Start;
1946 struct MUIDisplayObjects dobjects;
1947 struct Hook displayCopyHook;
1948 struct Hook displayDelHook;
1949 ULONG updatedIcons;
1950
1951 DoMethod(iconList, MUIM_IconList_NextIcon, MUIV_IconList_NextIcon_Selected, (IPTR) &entry);
1952 displayCopyHook.h_Entry = (HOOKFUNC) Wanderer__HookFunc_DisplayCopyFunc;
1953 displayDelHook.h_Entry = (HOOKFUNC) Wanderer__HookFunc_AskDeleteFunc;
1954
1955 updatedIcons = 0;
1956
1957 /* Process all selected entries */
1958 if (CreateCopyDisplay(ACTION_DELETE, &dobjects))
1959 {
1960 do
1961 {
1962 if ((int)entry != MUIV_IconList_NextIcon_End)
1963 {
1964 /* copy via filesystems.c */
1965 D(bug("[WANDERER] Delete \"%s\"\n", entry->filename);)
1966 CopyContent( NULL, entry->filename, NULL, TRUE, ACTION_DELETE, &displayCopyHook, &displayDelHook, (APTR) &dobjects);
1967 updatedIcons++;
1968 }
1969 DoMethod(iconList, MUIM_IconList_NextIcon, MUIV_IconList_NextIcon_Selected, (IPTR) &entry);
1970 }
1971 while ( (int)entry != MUIV_IconList_NextIcon_End );
1972 DisposeCopyDisplay(&dobjects);
1973 }
1974 // Only update list if anything happened to the icons!
1975 if ( updatedIcons > 0 )
1976 {
1977 DoMethod(window, MUIM_IconWindow_UnselectAll);
1978 DoMethod ( iconList, MUIM_IconList_Update );
1979 }
1980 }
1981 ///
1982
1983 ///wanderer_menufunc_icon_format()
1984 void wanderer_menufunc_icon_format(void)
1985 {
1986 Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1987 Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1988 struct IconList_Entry *entry = ( void*) MUIV_IconList_NextIcon_Start;
1989
1990 DoMethod(iconList, MUIM_IconList_NextIcon, MUIV_IconList_NextIcon_Selected, (IPTR) &entry);
1991
1992 /* Process only first selected entry */
1993 if ((int)entry != MUIV_IconList_NextIcon_End)
1994 {
1995 BPTR lock = Lock(entry->filename, ACCESS_READ);
1996 D(bug("[WANDERER] Format \"%s\"\n", entry->filename);)
1997 /* Usually we pass object name and parent lock. Here we do the same thing.
1998 Just object name is empty string and its parent is device's root. */
1999 OpenWorkbenchObject
2000 (
2001 "SYS:System/Format",
2002 WBOPENA_ArgLock, (IPTR) lock,
2003 WBOPENA_ArgName, lock ? (IPTR)"" : (IPTR)entry->filename,
2004 TAG_DONE
2005 );
2006 if (lock)
2007 UnLock(lock);
2008 }
2009 }
2010 ///
2011
2012 ///wanderer_menufunc_wanderer_AROS_guisettings()
2013 void wanderer_menufunc_wanderer_AROS_guisettings(void)
2014 {
2015 //DoMethod(_WandererIntern_AppObj, MUIM_Application_OpenConfigWindow);
2016 OpenWorkbenchObject("SYS:Prefs/Zune",
2017 WBOPENA_ArgName, (IPTR) "WANDERER",
2018 TAG_DONE);
2019 }
2020 ///
2021
2022 ///wanderer_menufunc_wanderer_AROS_about()
2023 void wanderer_menufunc_wanderer_AROS_about(void)
2024 {
2025 OpenWorkbenchObject("SYS:System/About", TAG_DONE);
2026 }
2027 ///
2028
2029 ///wanderer_menufunc_wanderer_about()
2030 void wanderer_menufunc_wanderer_about(void)
2031 {
2032 /* Display Information about this version of wanderer */
2033 #warning "TODO: Add a requestor with ABOUT info"
2034 }
2035 ///
2036
2037 ///wanderer_menufunc_wanderer_quit()
2038 void wanderer_menufunc_wanderer_quit(void)
2039 {
2040 if (OpenWorkbenchObject("WANDERER:Tools/Quit", TAG_DONE))
2041 ;
2042 else
2043 {
2044 if (MUI_RequestA(_WandererIntern_AppObj, NULL, 0, "Wanderer", _(MSG_YESNO), _(MSG_REALLYQUIT), NULL))
2045 DoMethod(_WandererIntern_AppObj, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
2046
2047 }
2048 }
2049 ///
2050
2051 ///wanderer_menufunc_wanderer_shutdown()
2052 void wanderer_menufunc_wanderer_shutdown(void)
2053 {
2054 LONG action;
2055
2056 action = MUI_RequestA(_WandererIntern_AppObj, NULL, 0, _(MSG_SHUTDOWN_TITLE), _(MSG_SHUTDOWN_BUTTONS), _(MSG_SHUTDOWN_BODY), NULL);
2057 switch (action) {
2058 case 0:
2059 return;
2060 case 1:
2061 ShutdownA(SD_ACTION_POWEROFF);
2062 break;
2063 case 2:
2064 ShutdownA(SD_ACTION_COLDREBOOT);
2065 break;
2066 case 3:
2067 ColdReboot();
2068 }
2069 MUI_RequestA(_WandererIntern_AppObj, NULL, 0, _(MSG_SHUTDOWN_TITLE), _(MSG_OK), _(MSG_ACTION_NOT_SUPPORTED), NULL);
2070 }
2071 ///
2072
2073
2074 ///FindMenuitem()
2075 /**************************************************************************
2076 This function returns a Menu Object with the given id
2077 **************************************************************************/
2078 Object *FindMenuitem(Object* strip, int id)
2079 {
2080 return (Object*)DoMethod(strip, MUIM_FindUData, id);
2081 }
2082 ///
2083
2084 ///DoMenuNotify()
2085 /**************************************************************************
2086 This connects a notify to the given menu entry id
2087 **************************************************************************/
2088 VOID DoMenuNotify(Object* strip, int id, void *function, void *arg)
2089 {
2090 Object *entry;
2091 entry = FindMenuitem(strip,id);
2092 if (entry)
2093 {
2094 DoMethod
2095 (
2096 entry, MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime,
2097 (IPTR) entry, 4, MUIM_CallHook, (IPTR) &_WandererIntern_hook_standard,
2098 (IPTR) function, (IPTR) arg
2099 );
2100 }
2101 }
2102 ///
2103
2104 ///DoAllMenuNotifies()
2105 VOID DoAllMenuNotifies(Object *strip, STRPTR path)
2106 {
2107 Object *item;
2108
2109 if (!strip) return;
2110
2111 DoMenuNotify(strip, MEN_WANDERER_EXECUTE,
2112 wanderer_menufunc_wanderer_execute, path);
2113 DoMenuNotify(strip, MEN_WANDERER_SHELL,
2114 wanderer_menufunc_wanderer_shell, path);
2115 DoMenuNotify(strip, MEN_WANDERER_AROS_GUISETTINGS,
2116 wanderer_menufunc_wanderer_AROS_guisettings, NULL);
2117 DoMenuNotify(strip, MEN_WANDERER_AROS_ABOUT,
2118 wanderer_menufunc_wanderer_AROS_about, NULL);
2119 DoMenuNotify(strip, MEN_WANDERER_QUIT,
2120 wanderer_menufunc_wanderer_quit, NULL);
2121 DoMenuNotify(strip, MEN_WANDERER_SHUTDOWN,
2122 wanderer_menufunc_wanderer_shutdown, NULL);
2123
2124 DoMenuNotify(strip, MEN_WINDOW_NEW_DRAWER,
2125 wanderer_menufunc_window_newdrawer, path);
2126 DoMenuNotify(strip, MEN_WINDOW_OPEN_PARENT,
2127 wanderer_menufunc_window_openparent, path);
2128 DoMenuNotify(strip, MEN_WINDOW_CLOSE,
2129 wanderer_menufunc_window_close, NULL);
2130 DoMenuNotify(strip, MEN_WINDOW_UPDATE,
2131 wanderer_menufunc_window_update, NULL);
2132 DoMenuNotify(strip, MEN_WINDOW_CLEAR,
2133 wanderer_menufunc_window_clear, NULL);
2134
2135 DoMenuNotify(strip, MEN_WINDOW_SNAP_WIN,
2136 wanderer_menufunc_window_snapshot, FALSE);
2137 DoMenuNotify(strip, MEN_WINDOW_SNAP_ALL,
2138 wanderer_menufunc_window_snapshot, (APTR)TRUE);
2139
2140 DoMenuNotify(strip, MEN_WINDOW_SELECT,
2141 wanderer_menufunc_window_select, NULL);
2142 DoMenuNotify(strip, MEN_WINDOW_VIEW_ALL,
2143 wanderer_menufunc_window_view_icons, strip);
2144 DoMenuNotify(strip, MEN_WINDOW_VIEW_HIDDEN,
2145 wanderer_menufunc_window_view_hidden, strip);
2146 DoMenuNotify(strip, MEN_WINDOW_SORT_NAME,
2147 wanderer_menufunc_window_sort_name, strip);
2148 DoMenuNotify(strip, MEN_WINDOW_SORT_TYPE,
2149 wanderer_menufunc_window_sort_type, strip);
2150 DoMenuNotify(strip, MEN_WINDOW_SORT_DATE,
2151 wanderer_menufunc_window_sort_date, strip);
2152 DoMenuNotify(strip, MEN_WINDOW_SORT_SIZE,
2153 wanderer_menufunc_window_sort_size, strip);
2154 DoMenuNotify(strip, MEN_WINDOW_SORT_REVERSE,
2155 wanderer_menufunc_window_sort_reverse, strip);
2156 DoMenuNotify(strip, MEN_WINDOW_SORT_TOPDRAWERS,
2157 wanderer_menufunc_window_sort_topdrawers, strip);
2158
2159 DoMenuNotify(strip, MEN_ICON_OPEN,
2160 wanderer_menufunc_icon_open, NULL);
2161 DoMenuNotify(strip, MEN_ICON_RENAME,
2162 wanderer_menufunc_icon_rename, NULL);
2163 DoMenuNotify(strip, MEN_ICON_INFORMATION,
2164 wanderer_menufunc_icon_information, NULL);
2165 DoMenuNotify(strip, MEN_ICON_SNAPSHOT,
2166 wanderer_menufunc_icon_snapshot, (APTR)TRUE);
2167 DoMenuNotify(strip, MEN_ICON_UNSNAPSHOT,
2168 wanderer_menufunc_icon_snapshot, FALSE);
2169 DoMenuNotify(strip, MEN_ICON_LEAVEOUT,
2170 wanderer_menufunc_icon_leaveout, NULL);
2171 DoMenuNotify(strip, MEN_ICON_PUTAWAY,
2172 wanderer_menufunc_icon_putaway, NULL);
2173 DoMenuNotify(strip, MEN_ICON_DELETE,
2174 wanderer_menufunc_icon_delete, NULL);
2175 DoMenuNotify(strip, MEN_ICON_FORMAT,
2176 wanderer_menufunc_icon_format, NULL);
2177
2178 if ((item = FindMenuitem(strip, MEN_WANDERER_BACKDROP)))
2179 {
2180 DoMethod
2181 (
2182 item, MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime,
2183 (IPTR) _WandererIntern_AppObj, 7, MUIM_Application_PushMethod,
2184 (IPTR) _WandererIntern_AppObj, 4, MUIM_CallHook, (IPTR) &_WandererIntern_hook_standard,
2185 (IPTR) wanderer_menufunc_wanderer_backdrop, (IPTR) strip
2186 );
2187 }
2188 }
2189 ///
2190
2191 ///Wanderer__Func_UpdateMenuStates()
2192 VOID Wanderer__Func_UpdateMenuStates(Object *WindowObj, Object *IconlistObj)
2193 {
2194 IPTR current_DispFlags = 0, current_SortFlags = 0;
2195 Object *current_Menustrip = NULL, *current_MenuItem = NULL;
2196 struct IconList_Entry *icon_entry = (IPTR)MUIV_IconList_NextIcon_Start;
2197 int selected_count = 0;
2198
2199 BOOL icon_men_PutAway = FALSE;
2200 BOOL icon_men_LeaveOut = FALSE;
2201 BOOL icon_men_Format = FALSE;
2202 BOOL icon_men_EmptyTrash = FALSE;
2203
2204 if (IconlistObj == NULL)
2205 return;
2206
2207 D(bug("[Wanderer] Wanderer__Func_UpdateMenuStates(IconList @ %p)\n", IconlistObj));
2208
2209 GET(IconlistObj, MUIA_IconList_SortFlags, &current_SortFlags);
2210 GET(IconlistObj, MUIA_IconList_DisplayFlags, &current_DispFlags);
2211 GET(WindowObj, MUIA_Window_Menustrip, &current_Menustrip);
2212
2213 D(bug("[Wanderer] Wanderer__Func_UpdateMenuStates: Menu @ %p, Display Flags : %x, Sort Flags : %x\n", current_Menustrip, current_DispFlags, current_SortFlags));
2214
2215 do
2216 {
2217 DoMethod(IconlistObj, MUIM_IconList_NextIcon, MUIV_IconList_NextIcon_Selected, (IPTR)&icon_entry);
2218
2219 if ((IPTR)icon_entry != MUIV_IconList_NextIcon_End)
2220 {
2221 if (icon_entry->type == ST_ROOT)
2222 {
2223 D(bug("[Wanderer] Wanderer__Func_UpdateMenuStates: ST_ROOT\n"));
2224 icon_men_Format = TRUE;
2225 }
2226 if ((icon_entry->type == ST_LINKDIR) || (icon_entry->type == ST_LINKFILE))
2227 {
2228 D(bug("[Wanderer] Wanderer__Func_UpdateMenuStates: ST_LINKDIR/ST_LINKFILE\n"));
2229 icon_men_PutAway = TRUE;
2230 }
2231 if ((icon_entry->type == ST_USERDIR) || (icon_entry->type == ST_FILE))
2232 {
2233 D(bug("[Wanderer] Wanderer__Func_UpdateMenuStates: ST_USERDIR/ST_FILE\n"));
2234 icon_men_LeaveOut = TRUE;
2235 }
2236 selected_count++;
2237 }
2238 else
2239 {
2240 break;
2241 }
2242 } while (TRUE);
2243
2244 if (current_Menustrip != NULL)
2245 {
2246 if (selected_count > 0)
2247 {
2248 if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_ICON_OPEN)) != NULL)
2249 {
2250 SET(current_MenuItem, MUIA_Menuitem_Enabled, TRUE);
2251 }
2252 if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_ICON_RENAME)) != NULL)
2253 {
2254 SET(current_MenuItem, MUIA_Menuitem_Enabled, TRUE);
2255 }
2256 if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_ICON_INFORMATION)) != NULL)
2257 {
2258 SET(current_MenuItem, MUIA_Menuitem_Enabled, TRUE);
2259 }
2260 if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_ICON_SNAPSHOT)) != NULL)
2261 {
2262 SET(current_MenuItem, MUIA_Menuitem_Enabled, TRUE);
2263 }
2264 if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_ICON_UNSNAPSHOT)) != NULL)
2265 {
2266 SET(current_MenuItem, MUIA_Menuitem_Enabled, TRUE);
2267 }
2268 if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_ICON_DELETE)) != NULL)
2269 {
2270 SET(current_MenuItem, MUIA_Menuitem_Enabled, TRUE);
2271 }
2272 if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_ICON_FORMAT)) != NULL)
2273 {
2274 SET(current_MenuItem, MUIA_Menuitem_Enabled, icon_men_Format);
2275 }
2276 if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_ICON_LEAVEOUT)) != NULL)
2277 {
2278 SET(current_MenuItem, MUIA_Menuitem_Enabled, icon_men_LeaveOut);
2279 }
2280 if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_ICON_PUTAWAY)) != NULL)
2281 {
2282 SET(current_MenuItem, MUIA_Menuitem_Enabled, icon_men_PutAway);
2283 }
2284 if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_ICON_EMPTYTRASH)) != NULL)
2285 {
2286 SET(current_MenuItem, MUIA_Menuitem_Enabled, icon_men_EmptyTrash);
2287 }
2288 if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_WINDOW_CLEAR)) != NULL)
2289 {
2290 SET(current_MenuItem, MUIA_Menuitem_Enabled, TRUE);
2291 }
2292 }
2293 else
2294 {
2295 if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_ICON_OPEN)) != NULL)
2296 {
2297 SET(current_MenuItem, MUIA_Menuitem_Enabled, FALSE);
2298 }
2299 if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_ICON_RENAME)) != NULL)
2300 {
2301 SET(current_MenuItem, MUIA_Menuitem_Enabled, FALSE);
2302 }
2303 if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_ICON_INFORMATION)) != NULL)
2304 {
2305 SET(current_MenuItem, MUIA_Menuitem_Enabled, FALSE);
2306 }
2307 if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_ICON_SNAPSHOT)) != NULL)
2308 {
2309 SET(current_MenuItem, MUIA_Menuitem_Enabled, FALSE);
2310 }
2311 if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_ICON_UNSNAPSHOT)) != NULL)
2312 {
2313 SET(current_MenuItem, MUIA_Menuitem_Enabled, FALSE);
2314 }
2315 if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_ICON_DELETE)) != NULL)
2316 {
2317 SET(current_MenuItem, MUIA_Menuitem_Enabled, FALSE);
2318 }
2319 if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_ICON_FORMAT)) != NULL)
2320 {
2321 SET(current_MenuItem, MUIA_Menuitem_Enabled, FALSE);
2322 }
2323 if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_ICON_LEAVEOUT)) != NULL)
2324 {
2325 SET(current_MenuItem, MUIA_Menuitem_Enabled, FALSE);
2326 }
2327 if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_ICON_PUTAWAY)) != NULL)
2328 {
2329 SET(current_MenuItem, MUIA_Menuitem_Enabled, FALSE);
2330 }
2331 if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_ICON_EMPTYTRASH)) != NULL)
2332 {
2333 SET(current_MenuItem, MUIA_Menuitem_Enabled, FALSE);
2334 }
2335 if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_WINDOW_CLEAR)) != NULL)
2336 {
2337 SET(current_MenuItem, MUIA_Menuitem_Enabled, FALSE);
2338 }
2339 }
2340 if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_WINDOW_VIEW_ALL)) != NULL)
2341 {
2342 SET(current_MenuItem, MUIA_Menuitem_Checked, (BOOL)!(current_DispFlags & ICONLIST_DISP_SHOWINFO));
2343 }
2344 if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_WINDOW_VIEW_HIDDEN)) != NULL)
2345 {
2346 SET(current_MenuItem, MUIA_Menuitem_Checked, (BOOL)(current_DispFlags & ICONLIST_DISP_SHOWHIDDEN));
2347 }
2348 if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_WINDOW_SORT_NAME)) != NULL)
2349 {
2350 SET(current_MenuItem, MUIA_Menuitem_Checked, (BOOL)((current_SortFlags & ICONLIST_SORT_MASK) == ICONLIST_SORT_BY_NAME));
2351 }
2352 if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_WINDOW_SORT_DATE)) != NULL)
2353 {
2354 SET(current_MenuItem, MUIA_Menuitem_Checked, (BOOL)((current_SortFlags & ICONLIST_SORT_MASK) == ICONLIST_SORT_BY_DATE));
2355 }
2356 if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_WINDOW_SORT_SIZE)) != NULL)
2357 {
2358 SET(current_MenuItem, MUIA_Menuitem_Checked, (BOOL)((current_SortFlags & ICONLIST_SORT_MASK) == ICONLIST_SORT_BY_SIZE));
2359 }
2360 if ((current_MenuItem = FindMenuitem(current_Menustrip, MEN_WINDOW_SORT_TYPE)) != NULL)
2361 {
2362 SET(current_MenuItem, MUIA_Menuitem_Checked, (BOOL)((current_SortFlags & ICONLIST_SORT_MASK) == ICONLIST_SORT_MASK));
2363 }
2364 }
2365 }
2366
2367 ///Wanderer__HookFunc_UpdateMenuStatesFunc()
2368 #ifdef __AROS__
2369 AROS_UFH3
2370 (
2371 ULONG, Wanderer__HookFunc_UpdateMenuStatesFunc,
2372 AROS_UFHA(struct Hook *, hook, A0),
2373 AROS_UFHA(APTR *, obj, A2),
2374 AROS_UFHA(APTR, param, A1)
2375 )
2376 {
2377 #else
2378 HOOKPROTO(Wanderer__HookFunc_UpdateMenuStatesFunc, ULONG, struct dCopyStruct *obj, APTR param)
2379 {
2380 #endif
2381 AROS_USERFUNC_INIT
2382 Object *window = *( Object **)param;
2383 Object *iconlist = NULL;
2384
2385 D(bug("[Wanderer] Wanderer__HookFunc_UpdateMenuStatesFunc(self @ %p, window @ %p)\n", self, window));
2386
2387 GET(window, MUIA_IconWindow_IconList, &iconlist);
2388
2389 D(bug("[Wanderer] Wanderer__HookFunc_UpdateMenuStatesFunc: iconlist @ %p\n", iconlist));
2390
2391 Wanderer__Func_UpdateMenuStates(window, iconlist);
2392
2393 D(bug("[Wanderer] Wanderer__HookFunc_UpdateMenuStatesFunc: Update Complete.\n"));
2394
2395 return 0;
2396
2397 AROS_USERFUNC_EXIT
2398 }
2399
2400 /*** Methods ****************************************************************/
2401 ///OM_NEW()
2402 Object *Wanderer__OM_NEW(Class *CLASS, Object *self, struct opSet *message)
2403 {
2404 D(bug("[Wanderer] Wanderer__OM_NEW()\n"));
2405
2406 self = (Object *) DoSuperNewTags
2407 (
2408 CLASS, self, NULL,
2409
2410 MUIA_Application_Title, (IPTR) "Wanderer",
2411 MUIA_Application_Base, (IPTR) "WANDERER",
2412 MUIA_Application_Version, (IPTR) VERSION,
2413 MUIA_Application_Description, (IPTR) _(MSG_DESCRIPTION),
2414 MUIA_Application_SingleTask, TRUE,
2415
2416 TAG_MORE, (IPTR) message->ops_AttrList
2417 );
2418
2419 if (self != NULL)
2420 {
2421 SETUP_WANDERER_INST_DATA;
2422
2423 // ULONG updatedIcons;
2424 D(bug("[Wanderer] Wanderer__OM_NEW: SELF = %d, Private data @ %x\n", self, data));
2425
2426 _WandererIntern_CLASS = CLASS;
2427
2428 #if defined(WANDERER_DEFAULT_BACKDROP)
2429 data->wd_Option_BackDropMode = TRUE;
2430 #else
2431 data->wd_Option_BackDropMode = FALSE;
2432 #endif
2433
2434 /*-- Setup hooks structures ----------------------------------------*/
2435 #ifdef __AROS__
2436 _WandererIntern_hook_standard.h_Entry = (HOOKFUNC) Wanderer__HookFunc_StandardFunc;
2437 _WandererIntern_hook_action.h_Entry = (HOOKFUNC) Wanderer__HookFunc_ActionFunc;
2438 _WandererIntern_hook_backdrop.h_Entry = (HOOKFUNC) Wanderer__HookFunc_BackdropFunc;
2439 #else
2440 _WandererIntern_hook_standard = &Hook_StandardFunc;
2441 _WandererIntern_hook_action = &Hook_ActionFunc;
2442 _WandererIntern_hook_backdrop = &Hook_BackdropFunc;
2443 #endif
2444
2445 // ---
2446 if ((data->wd_CommandPort = CreateMsgPort()) == NULL)
2447 {
2448 CoerceMethod(CLASS, self, OM_DISPOSE);
2449 return NULL;
2450 }
2451
2452 if ((data->wd_NotifyPort = CreateMsgPort()) == NULL)
2453 {
2454 CoerceMethod(CLASS, self, OM_DISPOSE);
2455 return NULL;
2456 }
2457
2458 RegisterWorkbench(data->wd_CommandPort);
2459
2460 /* Setup command port handler --------------------------------------*/
2461 data->wd_CommandIHN.ihn_Signals = 1UL << data->wd_CommandPort->mp_SigBit;
2462 data->wd_CommandIHN.ihn_Object = self;
2463 data->wd_CommandIHN.ihn_Method = MUIM_Wanderer_HandleCommand;
2464
2465 DoMethod
2466 (
2467 self, MUIM_Application_AddInputHandler, (IPTR) &data->wd_CommandIHN
2468 );
2469
2470 /* Setup timer handler ---------------------------------------------*/
2471 data->wd_TimerIHN.ihn_Flags = MUIIHNF_TIMER;
2472 data->wd_TimerIHN.ihn_Millis = 3000;
2473 data->wd_TimerIHN.ihn_Object = self;
2474 data->wd_TimerIHN.ihn_Method = MUIM_Wanderer_HandleTimer;
2475
2476 DoMethod
2477 (
2478 self, MUIM_Application_AddInputHandler, (IPTR) &data->wd_TimerIHN
2479 );
2480
2481 /* Setup filesystem notification handler ---------------------------*/
2482 data->wd_NotifyIHN.ihn_Signals = 1UL << data->wd_NotifyPort->mp_SigBit;
2483 data->wd_NotifyIHN.ihn_Object = self;
2484 data->wd_NotifyIHN.ihn_Method = MUIM_Wanderer_HandleNotify;
2485
2486 DoMethod
2487 (
2488 self, MUIM_Application_AddInputHandler, (IPTR) &data->wd_NotifyIHN
2489 );
2490
2491 // All the following should be moved to InitWandererPrefs
2492
2493 /* Setup notification on prefs file --------------------------------*/
2494 data->wd_PrefsNotifyRequest.nr_Name = ExpandEnvName("ENV:SYS/Wanderer.prefs");
2495 data->wd_PrefsNotifyRequest.nr_Flags = NRF_SEND_MESSAGE;
2496 data->wd_PrefsNotifyRequest.nr_stuff.nr_Msg.nr_Port = data->wd_NotifyPort;
2497
2498 if (StartNotify(&data->wd_PrefsNotifyRequest))
2499 {
2500 D(bug("[Wanderer] Wanderer__OM_NEW: Prefs-notification setup on '%s'\n", data->wd_PrefsNotifyRequest.nr_Name));
2501 }
2502 else
2503 {
2504 D(bug("[Wanderer] Wanderer__OM_NEW: FAILED to setup Prefs-notification!\n"));
2505 }
2506 #ifdef __AROS__
2507 data->wd_Prefs = (Object *)WandererPrefsObject, End; // FIXME: error handling
2508 #else
2509 data->wd_Prefs = NewObject(WandererPrefs_CLASS->mcc_Class, NULL, TAG_DONE); // FIXME: error handling
2510 #endif
2511
2512 if (data->wd_Prefs)
2513 {
2514 D(bug("[Wanderer] Wanderer__OM_NEW: Prefs-Screentitle = '%s'\n",XGET(data->wd_Prefs, MUIA_IconWindowExt_ScreenTitle_String)));
2515 data->wd_PrefsIntern = InitWandererPrefs();
2516 }
2517 }
2518 D(bug("[Wanderer] obj = %ld\n", self));
2519 return self;
2520 }
2521 ///
2522
2523 ///OM_DISPOSE()
2524 IPTR Wanderer__OM_DISPOSE(Class *CLASS, Object *self, Msg message)
2525 {
2526 SETUP_WANDERER_INST_DATA;
2527
2528 if (data->wd_CommandPort)
2529 {
2530 /*
2531 They only have been added if the creation of the msg port was
2532 successful
2533 */
2534 DoMethod(self, MUIM_Application_RemInputHandler, (IPTR) &data->wd_TimerIHN);
2535 DoMethod(self, MUIM_Application_RemInputHandler, (IPTR) &data->wd_CommandIHN);
2536 DoMethod(self, MUIM_Application_RemInputHandler, (IPTR) &data->wd_NotifyIHN);
2537
2538 UnregisterWorkbench(data->wd_CommandPort);
2539
2540 EndNotify(&data->wd_PrefsNotifyRequest);
2541
2542 DeleteMsgPort(data->wd_NotifyPort);
2543 data->wd_NotifyPort = NULL;
2544
2545 DeleteMsgPort(data->wd_CommandPort);
2546 data->wd_CommandPort = NULL;
2547
2548 DisposeObject(data->wd_Prefs);
2549 data->wd_Prefs = NULL;
2550 }
2551
2552 return DoSuperMethodA(CLASS, self, (Msg) message);
2553 }
2554 ///
2555
2556 ///OM_SET()
2557 IPTR Wanderer__OM_SET(Class *CLASS, Object *self, struct opSet *message)
2558 {
2559 SETUP_WANDERER_INST_DATA;
2560 struct TagItem *tstate = message->ops_AttrList, *tag;
2561
2562 while ((tag = NextTagItem((TAGITEM)&tstate)) != NULL)
2563 {
2564 switch (tag->ti_Tag)
2565 {
2566 case MUIA_Wanderer_Screen:
2567 D(bug("[Wanderer] Wanderer__OM_SET: MUIA_Wanderer_Screen = %p\n", tag->ti_Data));
2568 D(bug("[Wanderer] Wanderer__OM_SET: setting MUIA_Wanderer_Screen isnt yet handled!\n"));
2569 break;
2570
2571 case MUIA_Wanderer_ActiveWindow:
2572 data->wd_ActiveWindow = (Object *) tag->ti_Data;
2573 D(bug("[Wanderer] Wanderer__OM_SET: MUIA_Wanderer_ActiveWindow = %p\n", tag->ti_Data));
2574 if (!(XGET(data->wd_ActiveWindow, MUIA_Window_Activate)))
2575 {
2576 NNSET(data->wd_ActiveWindow, MUIA_Window_Activate, TRUE);
2577 }
2578 Object *activatewin_Iconlist = NULL;
2579
2580 GET(data->wd_ActiveWindow, MUIA_IconWindow_IconList, &activatewin_Iconlist);
2581 Wanderer__Func_UpdateMenuStates(data->wd_ActiveWindow, activatewin_Iconlist);
2582 break;
2583
2584 case MUIA_Application_Iconified:
2585 /* Wanderer itself cannot be iconified,
2586 just hide, instead. */
2587 tag->ti_Tag = MUIA_ShowMe;
2588 tag->ti_Data = !tag->ti_Data;
2589 break;
2590 }
2591 }
2592
2593 return DoSuperMethodA(CLASS, self, (Msg) message);
2594 }
2595 ///
2596
2597 ///OM_GET()
2598 IPTR Wanderer__OM_GET(Class *CLASS, Object *self, struct opGet *message)
2599 {
2600 SETUP_WANDERER_INST_DATA;
2601 IPTR *store = message->opg_Storage;
2602 IPTR rv = TRUE;
2603
2604 switch (message->opg_AttrID)
2605 {
2606 case MUIA_Wanderer_Screen:
2607 *store = (IPTR)data->wd_Screen;
2608 break;
2609
2610 case MUIA_Wanderer_Prefs:
2611 *store = (IPTR)data->wd_Prefs;
2612 break;
2613
2614 case MUIA_Wanderer_ActiveWindow:
2615 *store = (IPTR)data->wd_ActiveWindow;
2616 break;
2617
2618 case MUIA_Wanderer_WorkbenchWindow:
2619 *store = (IPTR)data->wd_WorkbenchWindow;
2620 break;
2621
2622 case MUIA_Wanderer_FileSysNotifyPort:
2623 *store = (IPTR)data->wd_NotifyPort;
2624 break;
2625
2626 default:
2627 rv = DoSuperMethodA(CLASS, self, (Msg) message);
2628 }
2629
2630 return rv;
2631 }
2632 ///
2633
2634 ///Wanderer__MUIM_Application_Execute()
2635 /* Main entry point for Wanderer Application Object */
2636 /*
2637 When the executable creates our object it calls zune
2638 to handle basic "control" ... which results in Zune
2639 calling this method ..
2640 */
2641 IPTR Wanderer__MUIM_Application_Execute
2642 (
2643 Class *CLASS, Object *self, Msg message
2644 )
2645 {
2646 SETUP_WANDERER_INST_DATA;
2647
2648 D(bug("[Wanderer] Wanderer__MUIM_Application_Execute() ##\n[Wanderer] Wanderer__MUIM_Application_Execute: Creating 'Workbench' Window..\n"));
2649
2650 data->wd_WorkbenchWindow = (Object *) DoMethod
2651 (
2652 self, MUIM_Wanderer_CreateDrawerWindow, (IPTR) NULL
2653 );
2654
2655 if (data->wd_WorkbenchWindow != NULL)
2656 {
2657 D(bug("[Wanderer] Wanderer__MUIM_Application_Execute: Workbench Window Obj @ %x\n", data->wd_WorkbenchWindow));
2658
2659 Detach();
2660
2661 D(bug("[Wanderer] Wanderer__MUIM_Application_Execute: Really handing control to Zune ..\n"));
2662
2663 #ifdef __AROS__
2664 DoSuperMethodA(CLASS, self, message);
2665 #else
2666 {
2667 IPTR sigs = 0;
2668 while (DoMethod(self,MUIM_Application_NewInput,&sigs) != MUIV_Application_ReturnID_Quit)
2669 {
2670 if (sigs)
2671 {
2672 sigs = Wait(sigs | SIGBREAKF_CTRL_C);
2673 if (sigs & SIGBREAKF_CTRL_C) break;
2674 }
2675 }
2676
2677 return 0;
2678 }
2679 #endif
2680
2681 return RETURN_OK;
2682 }
2683
2684 #warning "TODO: Report an error if we fail to create the Workbench's window ..."
2685
2686 return RETURN_ERROR;
2687 }
2688 ///
2689
2690 ///Wanderer__MUIM_Wanderer_HandleTimer()
2691 /*This function uses GetScreenTitle() function...*/
2692
2693 IPTR Wanderer__MUIM_Wanderer_HandleTimer
2694 (
2695 Class *CLASS, Object *self, Msg message
2696 )
2697 {
2698 SETUP_WANDERER_INST_DATA;
2699 Object *cstate = (Object*)(((struct List*)XGET(self, MUIA_Application_WindowList))->lh_Head);
2700 Object *child = NULL;
2701
2702 STRPTR scr_title = GetUserScreenTitle(data->wd_Prefs);
2703
2704 while ((child = NextObject(&cstate)))
2705 SET(child, MUIA_Window_ScreenTitle, (IPTR) scr_title);
2706
2707 return TRUE;
2708 }
2709 ///
2710
2711 ///Wanderer__MUIM_Wanderer_HandleCommand()
2712 IPTR Wanderer__MUIM_Wanderer_HandleCommand
2713 (
2714 Class *CLASS, Object *self, Msg message
2715 )
2716 {
2717 SETUP_WANDERER_INST_DATA;
2718 struct WBHandlerMessage *wbhm = NULL;
2719 struct List *pub_screen_list;
2720 struct PubScreenNode *pub_screen_node;
2721 WORD visitor_count = 0;
2722 D(bug("[Wanderer] %s()\n", __PRETTY_FUNCTION__));
2723 D(bug("[Wanderer] %s: Recieved signal at notification port\n", __PRETTY_FUNCTION__));
2724
2725 while ((wbhm = WBHM(GetMsg(data->wd_CommandPort))) != NULL)
2726 {
2727 D(bug("[Wanderer] %s: Recieved message from handler, type = %ld\n", __PRETTY_FUNCTION__, wbhm->wbhm_Type));
2728
2729 switch (wbhm->wbhm_Type)
2730 {
2731 case WBHM_TYPE_SHOW:
2732 D(bug("[Wanderer] %s: WBHM_TYPE_SHOW\n", __PRETTY_FUNCTION__));
2733 if ((data->wd_Screen = LockPubScreen(NULL)) != NULL)
2734 {
2735 D(bug("[Wanderer] %s: Unlocking access to screen @ %x\n", __PRETTY_FUNCTION__, data->wd_Screen));
2736 UnlockPubScreen(NULL, data->wd_Screen);
2737 SET(self, MUIA_ShowMe, TRUE);
2738 }
2739 else
2740 {
2741 #warning "TODO: We need to handle the possiblity that we fail to lock the pubscreen..."
2742 D(bug("[Wanderer] %s: Couldnt Lock WB Screen!!\n", __PRETTY_FUNCTION__));
2743 }
2744 break;
2745
2746 case WBHM_TYPE_HIDE:
2747 D(bug("[Wanderer] %s: WBHM_TYPE_HIDE\n", __PRETTY_FUNCTION__));
2748 pub_screen_list = LockPubScreenList();
2749
2750 #ifdef __AROS__
2751 ForeachNode (pub_screen_list, pub_screen_node)
2752 #else
2753 Foreach_Node(pub_screen_list, pub_screen_node);
2754 #endif
2755 {
2756 if (pub_screen_node->psn_Screen == data->wd_Screen)
2757 visitor_count = pub_screen_node->psn_VisitorCount;
2758 }
2759 UnlockPubScreenList();
2760 if (visitor_count == 0)
2761 SET(self, MUIA_ShowMe, FALSE);
2762 break;
2763
2764 case WBHM_TYPE_UPDATE:
2765 D(bug("[Wanderer] %s: WBHM_TYPE_UPDATE\n", __PRETTY_FUNCTION__));
2766 {
2767 CONST_STRPTR name = wbhm->wbhm_Data.Update.Name;
2768 ULONG length;
2769
2770 switch (wbhm->wbhm_Data.Update.Type)
2771 {
2772 case WBDISK:
2773 case WBDRAWER:
2774 case WBGARBAGE:
2775 length = strlen(name);
2776 break;
2777
2778 default:
2779 length = PathPart(name) - name;
2780 break;
2781 }
2782
2783 D(bug("[Wanderer] %s: name = %s, length = %ld\n", __PRETTY_FUNCTION__, name, length));
2784
2785 {
2786 Object *cstate = (Object*)(((struct List*)XGET(self, MUIA_Application_WindowList))->lh_Head);
2787 Object *child = NULL;
2788
2789 while ((child = NextObject(&cstate)))
2790 {
2791 if (XGET(child, MUIA_UserData))
2792 {
2793 STRPTR child_drawer = (STRPTR)XGET(child, MUIA_IconWindow_Location);
2794
2795 if
2796 (
2797 child_drawer != NULL
2798 && strncmp(name, child_drawer, length) == 0
2799 && strlen(child_drawer) == length
2800 )
2801 {
2802 Object *iconlist = (Object *) XGET(child, MUIA_IconWindow_IconList);
2803
2804 D(bug("[Wanderer] %s: Drawer found: %s!\n", __PRETTY_FUNCTION__, child_drawer));
2805
2806 if (iconlist != NULL)
2807 {
2808 DoMethod ( iconlist, MUIM_IconList_Update );
2809 }
2810 break;
2811 }
2812 }
2813 }
2814 }
2815 }
2816 break;
2817
2818 case WBHM_TYPE_OPEN:
2819 D(bug("[Wanderer] %s: WBHM_TYPE_OPEN\n", __PRETTY_FUNCTION__));
2820
2821 {
2822 Object *cstate = (Object*)(((struct List*)XGET(self, MUIA_Application_WindowList))->lh_Head);
2823 Object *child;
2824 CONST_STRPTR buf = wbhm->wbhm_Data.Open.Name;
2825
2826 while ((child = NextObject(&cstate)))
2827 {
2828 if (XGET(child, MUIA_UserData))
2829 {
2830 STRPTR child_drawer = (STRPTR)XGET(child, MUIA_IconWindow_Location);
2831 if (child_drawer && !Stricmp(buf,child_drawer))
2832 {
2833 int is_open = XGET(child, MUIA_Window_Open);
2834 if (!is_open)
2835 DoMethod(child, MUIM_IconWindow_Open);
2836 else
2837 {
2838 DoMethod(child, MUIM_Window_ToFront);
2839 SET(child, MUIA_Window_Activate, TRUE);
2840 }
2841 return 0;
2842 }
2843 }
2844 }
2845
2846 DoMethod
2847 (
2848 _WandererIntern_AppObj, MUIM_Wanderer_CreateDrawerWindow, (IPTR) buf
2849 );
2850 }
2851 break;
2852 } /* switch */
2853
2854 ReplyMsg((struct Message *) wbhm);
2855 }
2856
2857 return 0;
2858 }
2859 ///
2860
2861 ///Wanderer__MUIM_Wanderer_HandleNotify()
2862 IPTR Wanderer__MUIM_Wanderer_HandleNotify
2863 (
2864 Class *CLASS, Object *self, Msg message
2865 )
2866 {
2867 SETUP_WANDERER_INST_DATA;
2868 struct Message *plainMessage = NULL;
2869
2870 while ((plainMessage = GetMsg(data->wd_NotifyPort)) != NULL)
2871 {
2872 struct NotifyMessage *notifyMessage = (struct NotifyMessage *) plainMessage;
2873 IPTR notifyMessage_UserData = notifyMessage->nm_NReq->nr_UserData;
2874 D(bug("[Wanderer] Wanderer__MUIM_Wanderer_HandleNotify: got FS notification ('%s' @ 0x%p) userdata = 0x%p!\n", notifyMessage->nm_NReq->nr_Name, notifyMessage, notifyMessage_UserData));
2875
2876 if ((notifyMessage_UserData ==(IPTR) NULL) && (strcmp(notifyMessage->nm_NReq->nr_Name, data->wd_PrefsNotifyRequest.nr_Name) == 0))
2877 {
2878 /* reload prefs file */
2879 D(bug("[Wanderer] Wanderer__MUIM_Wanderer_HandleNotify: Wanderer Prefs-File Changed .. Reloading\n"));
2880
2881 DoMethod(data->wd_Prefs, MUIM_WandererPrefs_Reload);
2882 }
2883 else if (notifyMessage_UserData != (IPTR) NULL)
2884 {
2885 D(bug("[Wanderer] Wanderer__MUIM_Wanderer_HandleNotify: Drawer Window contents changed .. Updating\n"));
2886 DoMethod((Object *)notifyMessage_UserData, MUIM_IconList_Update);
2887 }
2888
2889 ReplyMsg((struct Message *)notifyMessage);
2890 }
2891
2892 return 0;
2893 }
2894 ///
2895
2896 ///Wanderer__Func_CreateWandererIntuitionMenu()
2897 /* Some differences here between volumes and subwindows */
2898 Object * Wanderer__Func_CreateWandererIntuitionMenu( BOOL isRoot, BOOL isBackdrop)
2899 {
2900 Object *_NewWandIntMenu__menustrip = NULL;
2901 IPTR _NewWandIntMenu__OPTION_BACKDROP = CHECKIT|MENUTOGGLE;
2902 IPTR _NewWandIntMenu__OPTION_SHOWALL = CHECKIT|MENUTOGGLE;
2903
2904 if (isBackdrop)
2905 {
2906 _NewWandIntMenu__OPTION_BACKDROP |= CHECKED;
2907 }
2908
2909 if ( isRoot )
2910 {
2911 struct NewMenu nm[] = {
2912 {NM_TITLE, _(MSG_MEN_WANDERER)},
2913 {NM_ITEM, _(MSG_MEN_BACKDROP),_(MSG_MEN_SC_BACKDROP), _NewWandIntMenu__OPTION_BACKDROP , 0, (APTR) MEN_WANDERER_BACKDROP},
2914 {NM_ITEM, _(MSG_MEN_EXECUTE), _(MSG_MEN_SC_EXECUTE) , 0 , 0, (APTR) MEN_WANDERER_EXECUTE},
2915
2916 {NM_ITEM, _(MSG_MEN_SHELL), _(MSG_MEN_SC_SHELL) , 0 , 0, (APTR) MEN_WANDERER_SHELL},
2917 #if defined(__AROS__)
2918 {NM_ITEM, "AROS"},
2919 {NM_SUB, _(MSG_MEN_ABOUT), NULL , 0 , 0, (APTR) MEN_WANDERER_AROS_ABOUT},
2920 {NM_SUB, _(MSG_MEN_GUISET), NULL , 0 , 0, (APTR) MEN_WANDERER_AROS_GUISETTINGS},
2921 #endif
2922 {NM_ITEM, _(MSG_MEN_QUIT) , _(MSG_MEN_SC_QUIT) , 0 , 0, (APTR) MEN_WANDERER_QUIT},
2923 {NM_ITEM, _(MSG_MEN_SHUTDOWN), NULL , 0 , 0, (APTR) MEN_WANDERER_SHUTDOWN},
2924 {NM_TITLE, _(MSG_MEN_WINDOW), NULL, 0},
2925 {NM_ITEM, _(MSG_MEN_UPDATE), NULL , 0 , 0, (APTR) MEN_WINDOW_UPDATE},
2926 {NM_ITEM, NM_BARLABEL},
2927 {NM_ITEM, _(MSG_MEN_CONTENTS), _(MSG_MEN_SC_CONTENTS), 0 , 0, (APTR) MEN_WINDOW_SELECT},
2928 {NM_ITEM, _(MSG_MEN_CLRSEL), _(MSG_MEN_SC_CLRSEL) , 0 , 0, (APTR) MEN_WINDOW_CLEAR},
2929 {NM_ITEM, NM_BARLABEL},
2930 {NM_ITEM, _(MSG_MEN_SNAPSHT) },
2931 {NM_SUB, _(MSG_MEN_WINDOW), NULL , 0 , 0, (APTR) MEN_WINDOW_SNAP_WIN},
2932 {NM_SUB, _(MSG_MEN_ALL), NULL , 0 , 0, (APTR) MEN_WINDOW_SNAP_ALL},
2933 {NM_ITEM, NM_BARLABEL},
2934 {NM_ITEM, _(MSG_MEN_VIEW)},
2935 {NM_SUB, _(MSG_MEN_ICVIEW), NULL , CHECKIT|CHECKED , 8+16+32, (APTR) MEN_WINDOW_VIEW_ICON},
2936 {NM_SUB, _(MSG_MEN_DCVIEW), NULL , CHECKIT , 4+16+32, (APTR) MEN_WINDOW_VIEW_DETAIL},
2937 {NM_SUB, NM_BARLABEL},
2938 {NM_SUB, _(MSG_MEN_ALLFIL), NULL , _NewWandIntMenu__OPTION_SHOWALL , 0, (APTR) MEN_WINDOW_VIEW_ALL},
2939 {NM_ITEM, _(MSG_MEN_SORTIC)},
2940 {NM_SUB, _(MSG_MEN_CLNUP), _(MSG_MEN_SC_CLNUP) , 0 , 0, (APTR) MEN_WINDOW_SORT_NOW},
2941 {NM_SUB, NM_BARLABEL},
2942 {NM_SUB, _(MSG_MEN_BYNAME), NULL , CHECKIT|MENUTOGGLE , 8+16+32, (APTR) MEN_WINDOW_SORT_NAME},
2943 {NM_SUB, _(MSG_MEN_BYDATE), NULL , CHECKIT|MENUTOGGLE , 4+16+32, (APTR) MEN_WINDOW_SORT_DATE},
2944 {NM_SUB, _(MSG_MEN_BYSIZE), NULL , CHECKIT|MENUTOGGLE , 4+8+32, (APTR) MEN_WINDOW_SORT_SIZE},
2945 {NM_SUB, _(MSG_MEN_BYTYPE), NULL , CHECKIT|MENUTOGGLE , 4+8+16, (APTR) MEN_WINDOW_SORT_TYPE},
2946 {NM_SUB, NM_BARLABEL},
2947 {NM_SUB, _(MSG_MEN_REVERSE), NULL , CHECKIT|MENUTOGGLE , 0, (APTR) MEN_WINDOW_SORT_REVERSE},
2948 {NM_SUB, _(MSG_MEN_DRWFRST), NULL , CHECKIT|MENUTOGGLE|CHECKED , 0, (APTR) MEN_WINDOW_SORT_TOPDRAWERS},
2949 //{NM_SUB, "Group Icons", NULL, CHECKIT|MENUTOGGLE|CHECKED, 0, (APTR) MEN_WINDOW_SORT_GROUP},
2950 {NM_TITLE, _(MSG_MEN_ICON), NULL, 0},
2951 {NM_ITEM, _(MSG_MEN_OPEN), _(MSG_MEN_SC_OPEN), ITEMENABLED, 0, (APTR) MEN_ICON_OPEN},
2952 //{NM_ITEM, "Close","C" },
2953 {NM_ITEM, _(MSG_MEN_RENAME), _(MSG_MEN_SC_RENAME), ITEMENABLED, 0, (APTR) MEN_ICON_RENAME},
2954 {NM_ITEM, _(MSG_MEN_INFO), _(MSG_MEN_SC_INFO), ITEMENABLED, 0, (APTR) MEN_ICON_INFORMATION},
2955 {NM_ITEM, _(MSG_SNAPSHOT), "S", ITEMENABLED, 0, (APTR) MEN_ICON_SNAPSHOT},
2956 {NM_ITEM, _(MSG_UNSNAPSHOT), "U", ITEMENABLED, 0, (APTR) MEN_ICON_UNSNAPSHOT},
2957 {NM_ITEM, _(MSG_LEAVE_OUT), "L", ITEMENABLED, 0, (APTR) MEN_ICON_LEAVEOUT},
2958 {NM_ITEM, _(MSG_PUT_AWAY), "P", ITEMENABLED, 0, (APTR) MEN_ICON_PUTAWAY},
2959 {NM_ITEM, NM_BARLABEL},
2960 {NM_ITEM, _(MSG_MEN_DELETE), NULL, ITEMENABLED, 0, (APTR) MEN_ICON_DELETE},
2961 {NM_ITEM, _(MSG_MEN_FORMAT), NULL, ITEMENABLED, 0, (APTR) MEN_ICON_FORMAT},
2962 {NM_ITEM, _(MSG_EMPTY_TRASH), NULL, ITEMENABLED},
2963 {NM_TITLE, _(MSG_MEN_TOOLS), NULL, 0},
2964 //{NM_ITEM, "ResetWanderer" },
2965 {NM_END}
2966 };
2967 _NewWandIntMenu__menustrip = MUI_MakeObject(MUIO_MenustripNM, nm, (IPTR) NULL);
2968 }
2969 else
2970 {
2971 struct NewMenu nm[] = {
2972 {NM_TITLE, _(MSG_MEN_WANDERER)},
2973 {NM_ITEM, _(MSG_MEN_BACKDROP),_(MSG_MEN_SC_BACKDROP), _NewWandIntMenu__OPTION_BACKDROP, 0, (APTR) MEN_WANDERER_BACKDROP},
2974 {NM_ITEM, _(MSG_MEN_EXECUTE), _(MSG_MEN_SC_EXECUTE) , 0 , 0, (APTR) MEN_WANDERER_EXECUTE},
2975
2976 {NM_ITEM, _(MSG_MEN_SHELL), _(MSG_MEN_SC_SHELL) , 0 , 0, (APTR) MEN_WANDERER_SHELL},
2977 #if defined(__AROS__)
2978 {NM_ITEM, "AROS"},
2979 {NM_SUB, _(MSG_MEN_ABOUT), NULL , 0 , 0, (APTR) MEN_WANDERER_AROS_ABOUT},
2980 {NM_SUB, _(MSG_MEN_GUISET), NULL , 0 , 0, (APTR) MEN_WANDERER_AROS_GUISETTINGS},
2981 #endif
2982 {NM_ITEM, _(MSG_MEN_QUIT) , _(MSG_MEN_SC_QUIT) , 0 , 0, (APTR) MEN_WANDERER_QUIT},
2983 {NM_ITEM, _(MSG_MEN_SHUTDOWN), NULL , 0 , 0, (APTR) MEN_WANDERER_SHUTDOWN},
2984
2985 {NM_TITLE, _(MSG_MEN_WINDOW), NULL, 0},
2986
2987 {NM_ITEM, _(MSG_MEN_NEWDRAW), _(MSG_MEN_SC_NEWDRAW) , 0 , 0, (APTR) MEN_WINDOW_NEW_DRAWER},
2988 {NM_ITEM, _(MSG_MEN_OPENPAR), NULL , 0 , 0, (APTR) MEN_WINDOW_OPEN_PARENT},
2989 {NM_ITEM, _(MSG_MEN_CLOSE), _(MSG_MEN_SC_CLOSE) , 0 , 0, (APTR) MEN_WINDOW_CLOSE},
2990 {NM_ITEM, _(MSG_MEN_UPDATE), NULL , 0 , 0, (APTR) MEN_WINDOW_UPDATE},
2991 {NM_ITEM, NM_BARLABEL},
2992 {NM_ITEM, _(MSG_MEN_CONTENTS), _(MSG_MEN_SC_CONTENTS), 0 , 0, (APTR) MEN_WINDOW_SELECT},
2993 {NM_ITEM, _(MSG_MEN_CLRSEL), _(MSG_MEN_SC_CLRSEL) , 0 , 0, (APTR) MEN_WINDOW_CLEAR},
2994 {NM_ITEM, NM_BARLABEL},
2995 {NM_ITEM, _(MSG_MEN_SNAPSHT) },
2996 {NM_SUB, _(MSG_MEN_WINDOW), NULL , 0 , 0, (APTR) MEN_WINDOW_SNAP_WIN},
2997 {NM_SUB, _(MSG_MEN_ALL), NULL , 0 , 0, (APTR) MEN_WINDOW_SNAP_ALL},
2998 {NM_ITEM, NM_BARLABEL},
2999 {NM_ITEM, _(MSG_MEN_VIEW)},
3000 {NM_SUB, _(MSG_MEN_ICVIEW), NULL , CHECKIT|CHECKED ,8+16+32, (APTR) MEN_WINDOW_VIEW_ICON},
3001 {NM_SUB, _(MSG_MEN_DCVIEW), NULL , CHECKIT ,4+16+32, (APTR) MEN_WINDOW_VIEW_DETAIL},
3002 {NM_SUB, NM_BARLABEL},
3003 {NM_SUB, _(MSG_MEN_ALLFIL), NULL , _NewWandIntMenu__OPTION_SHOWALL, 0, (APTR) MEN_WINDOW_VIEW_ALL},
3004 {NM_ITEM, _(MSG_MEN_SORTIC)},
3005 {NM_SUB, _(MSG_MEN_CLNUP), _(MSG_MEN_SC_CLNUP) , 0 , 0, (APTR) MEN_WINDOW_SORT_NOW},
3006 {NM_SUB, NM_BARLABEL},
3007 {NM_SUB, _(MSG_MEN_BYNAME), NULL , CHECKIT|MENUTOGGLE , 8+16+32, (APTR) MEN_WINDOW_SORT_NAME},
3008 {NM_SUB, _(MSG_MEN_BYDATE), NULL , CHECKIT|MENUTOGGLE , 4+16+32, (APTR) MEN_WINDOW_SORT_DATE},
3009 {NM_SUB, _(MSG_MEN_BYSIZE), NULL , CHECKIT|MENUTOGGLE , 4+8+32, (APTR) MEN_WINDOW_SORT_SIZE},
3010 {NM_SUB, _(MSG_MEN_BYTYPE), NULL , CHECKIT|MENUTOGGLE|ITEMENABLED , 4+8+16, (APTR) MEN_WINDOW_SORT_TYPE},
3011 {NM_SUB, NM_BARLABEL},
3012 {NM_SUB, _(MSG_MEN_REVERSE), NULL , CHECKIT|MENUTOGGLE , 0, (APTR) MEN_WINDOW_SORT_REVERSE},
3013 {NM_SUB, _(MSG_MEN_DRWFRST), NULL , CHECKIT|MENUTOGGLE|CHECKED, 0, (APTR) MEN_WINDOW_SORT_TOPDRAWERS},
3014 //{NM_SUB, "Group Icons", NULL, CHECKIT|MENUTOGGLE|CHECKED, 0, (APTR) MEN_WINDOW_SORT_GROUP},
3015 {NM_TITLE, _(MSG_MEN_ICON), NULL, 0},
3016 {NM_ITEM, _(MSG_MEN_OPEN), _(MSG_MEN_SC_OPEN), ITEMENABLED, 0, (APTR) MEN_ICON_OPEN},
3017 // {NM_ITEM, "Close","C" },
3018 {NM_ITEM, _(MSG_MEN_RENAME), _(MSG_MEN_SC_RENAME), ITEMENABLED, 0, (APTR) MEN_ICON_RENAME},
3019 {NM_ITEM, _(MSG_MEN_INFO), _(MSG_MEN_SC_INFO), ITEMENABLED, 0, (APTR) MEN_ICON_INFORMATION},
3020 {NM_ITEM, _(MSG_SNAPSHOT), "S", ITEMENABLED, 0, (APTR) MEN_ICON_SNAPSHOT},
3021 {NM_ITEM, _(MSG_UNSNAPSHOT), "U", ITEMENABLED, 0, (APTR) MEN_ICON_UNSNAPSHOT},
3022 {NM_ITEM, _(MSG_LEAVE_OUT), "L", ITEMENABLED, 0, (APTR) MEN_ICON_LEAVEOUT},
3023 {NM_ITEM, _(MSG_PUT_AWAY), "P", ITEMENABLED, 0, (APTR) MEN_ICON_PUTAWAY},
3024 {NM_ITEM, NM_BARLABEL},
3025 {NM_ITEM, _(MSG_MEN_DELETE), NULL, ITEMENABLED, 0, (APTR) MEN_ICON_DELETE},
3026 {NM_ITEM, _(MSG_MEN_FORMAT), NULL, ITEMENABLED},
3027 {NM_ITEM, _(MSG_EMPTY_TRASH),NULL, ITEMENABLED},
3028
3029 {NM_TITLE, _(MSG_MEN_TOOLS), NULL, 0},
3030 // {NM_ITEM, "ResetWanderer" },
3031 {NM_END}
3032 };
3033 _NewWandIntMenu__menustrip = MUI_MakeObject(MUIO_MenustripNM, nm, (IPTR) NULL);
3034 }
3035 return _NewWandIntMenu__menustrip;
3036 }
3037 ///
3038
3039 ///Wanderer__MUIM_Wanderer_CreateDrawerWindow()
3040 Object *Wanderer__MUIM_Wanderer_CreateDrawerWindow
3041 (
3042 Class *CLASS, Object *self,
3043 struct MUIP_Wanderer_CreateDrawerWindow *message
3044 )
3045 {
3046 SETUP_WANDERER_INST_DATA;
3047
3048 Object *window = NULL;
3049 BOOL isWorkbenchWindow = FALSE;
3050 BOOL useBackdrop = FALSE;
3051 BOOL hasToolbar;
3052 IPTR TAG_IconWindow_Drawer;
3053 IPTR useFont;
3054 Object *_NewWandDrawerMenu__menustrip;
3055
3056 Object *window_IconList = NULL;
3057
3058 D(bug("[Wanderer] Wanderer__MUIM_Wanderer_CreateDrawerWindow()\n"));
3059
3060 if ((isWorkbenchWindow = (message->drawer == NULL ? TRUE : FALSE)))
3061 {
3062 useBackdrop = data->wd_Option_BackDropMode;
3063 }
3064
3065 hasToolbar = XGET(data->wd_Prefs, MUIA_IconWindowExt_Toolbar_Enabled);
3066
3067 TAG_IconWindow_Drawer = isWorkbenchWindow ? TAG_IGNORE : MUIA_IconWindow_Location;
3068
3069 useFont = (IPTR)NULL;
3070
3071 data->wd_Screen = LockPubScreen(NULL);
3072
3073 if(data->wd_Screen == NULL)
3074 {
3075 D(bug("[Wanderer] Wanderer__MUIM_Wanderer_CreateDrawerWindow: Couldn't lock screen!\n"));
3076 CoerceMethod(CLASS, self, OM_DISPOSE);
3077 return NULL;
3078 }
3079 D(bug("[Wanderer] Wanderer__MUIM_Wanderer_CreateDrawerWindow: Using Screen @ %x\n", data->wd_Screen));
3080
3081 if (data->wd_PrefsIntern)
3082 {
3083 useFont = (IPTR)((struct WandererInternalPrefsData *)data->wd_PrefsIntern)->WIPD_IconFont;
3084 }
3085
3086 _NewWandDrawerMenu__menustrip = Wanderer__Func_CreateWandererIntuitionMenu (isWorkbenchWindow, useBackdrop);
3087
3088 //D(bug("1\n\n")); Delay(100);
3089 /* Create a new icon drawer window with the correct drawer being set */
3090
3091 #ifdef __AROS__
3092 window = (Object *)IconWindowObject,
3093 MUIA_UserData, 1,
3094 MUIA_Wanderer_Prefs, (IPTR)data->wd_Prefs,
3095 MUIA_Wanderer_Screen, (IPTR)data->wd_Screen,
3096 MUIA_Window_ScreenTitle, (IPTR)GetUserScreenTitle(data->wd_Prefs),
3097 MUIA_Window_Menustrip, (IPTR) _NewWandDrawerMenu__menustrip,
3098 TAG_IconWindow_Drawer, (IPTR) message->drawer,
3099 MUIA_IconWindow_Font, useFont,
3100 MUIA_IconWindow_ActionHook, (IPTR) &_WandererIntern_hook_action,
3101 MUIA_IconWindow_IsRoot, isWorkbenchWindow ? TRUE : FALSE,
3102 isWorkbenchWindow ? MUIA_IconWindow_IsBackdrop : TAG_IGNORE, useBackdrop,
3103 isWorkbenchWindow ? TAG_IGNORE : MUIA_Wanderer_FileSysNotifyPort, (IPTR)data->wd_NotifyPort,
3104 MUIA_Window_IsSubWindow, isWorkbenchWindow ? FALSE : TRUE,
3105 MUIA_IconWindowExt_Toolbar_Enabled, hasToolbar ? TRUE : FALSE,
3106 End;
3107 #else
3108 window = NewObject(IconWindow_CLASS->mcc_Class, NULL,
3109 MUIA_UserData, 1,
3110 MUIA_Wanderer_Prefs, data->wd_Prefs,
3111 MUIA_Wanderer_Screen, data->wd_Screen,
3112 MUIA_Window_ScreenTitle, GetUserScreenTitle(data->wd_Prefs),
3113 MUIA_Window_Menustrip, (IPTR) _NewWandDrawerMenu__menustrip,
3114 TAG_IconWindow_Drawer, (IPTR) message->drawer,
3115 MUIA_IconWindow_Font, useFont,
3116 MUIA_IconWindow_ActionHook, (IPTR) &_WandererIntern_hook_action,
3117 MUIA_IconWindow_IsRoot, isWorkbenchWindow ? TRUE : FALSE,
3118 isWorkbenchWindow ? MUIA_IconWindow_IsBackdrop : TAG_IGNORE, useBackdrop,
3119 isWorkbenchWindow ? TAG_IGNORE : MUIA_Wanderer_FileSysNotifyPort, data->wd_NotifyPort,
3120 MUIA_Window_IsSubWindow, isWorkbenchWindow ? FALSE : TRUE,
3121 MUIA_IconWindowExt_Toolbar_Enabled, hasToolbar ? TRUE : FALSE,
3122 TAG_DONE);
3123 #endif
3124 //D(bug("2\n\n")); Delay(100);
3125 if (data->wd_Screen)
3126 {
3127 D(bug("[Wanderer] Wanderer__MUIM_Wanderer_CreateDrawerWindow: Unlocking access to screen @ %x\n", data->wd_Screen));
3128 UnlockPubScreen(NULL, data->wd_Screen);
3129 }
3130
3131 if (window != NULL)
3132 {
3133 D(bug("Wanderer__MUIM_Wanderer_CreateDrawerWindow: window != NULL\n"));
3134 /* Get the drawer path back so we can use it also outside this function */
3135 STRPTR drw = NULL;
3136 BOOL freeDrwStr = FALSE;
3137
3138 if (!isWorkbenchWindow) drw = (STRPTR) XGET(window, MUIA_IconWindow_Location);
3139 else
3140 {
3141 D(bug("Wanderer__MUIM_Wanderer_CreateDrawerWindow: call AllocVec()\n"));
3142 drw = AllocVec ( 5, MEMF_CLEAR );
3143 sprintf ( drw, "RAM:" );
3144 freeDrwStr = TRUE;
3145 }
3146
3147 if (isWorkbenchWindow)
3148 {
3149 D(bug("Wanderer__MUIM_Wanderer_CreateDrawerWindow: isWorkbenchWindow\n"));
3150 DoMethod
3151 (
3152 window, MUIM_Notify, MUIA_Window_CloseRequest, TRUE,
3153 (IPTR)self, 3, MUIM_CallHook, (IPTR)&_WandererIntern_hook_standard, (IPTR)wanderer_menufunc_wanderer_quit
3154 );
3155 }
3156 else
3157 {
3158 DoMethod
3159 (
3160 window, MUIM_Notify, MUIA_Window_CloseRequest, TRUE,
3161 (IPTR)_app(self), 4, MUIM_Application_PushMethod, (IPTR)window, 1, MUIM_IconWindow_Remove
3162 );
3163 }
3164
3165 D(bug("Wanderer__MUIM_Wanderer_CreateDrawerWindow: call get with MUIA_IconWindow_IconList\n"));
3166 GET(window, MUIA_IconWindow_IconList, &window_IconList);
3167
3168 D(bug("[Wanderer] Wanderer__MUIM_Wanderer_CreateDrawerWindow: IconWindows IconList @ %x\n", window_IconList));
3169
3170 if (window_IconList != NULL)
3171 {
3172 struct Hook *_wand_UpdateMenuStates_hook = NULL;
3173
3174 if ((_wand_UpdateMenuStates_hook = AllocMem(sizeof(struct Hook), MEMF_CLEAR|MEMF_PUBLIC)) != NULL)
3175 {
3176 _wand_UpdateMenuStates_hook->h_Entry = ( HOOKFUNC )Wanderer__HookFunc_UpdateMenuStatesFunc;
3177 DoMethod
3178 (
3179 window_IconList, MUIM_Notify, MUIA_IconList_SelectionChanged, MUIV_EveryTime,
3180 (IPTR) self, 3,
3181 MUIM_CallHook, _wand_UpdateMenuStates_hook, (IPTR)window
3182 );
3183 }
3184 Wanderer__Func_UpdateMenuStates(window, window_IconList);
3185 }
3186 D(bug("Wanderer__MUIM_Wanderer_CreateDrawerWindow: setup notifications\n"));
3187 DoMethod
3188 (
3189 window, MUIM_Notify, MUIA_Window_Activate, TRUE,
3190 (IPTR)_app(self), 3, MUIM_Set, MUIA_Wanderer_ActiveWindow, (IPTR) window
3191 );
3192
3193 #if 1
3194 DoMethod
3195 (
3196 window, MUIM_Notify, MUIA_IconWindow_IsBackdrop, MUIV_EveryTime,
3197 (IPTR)_app(self), 5, MUIM_Application_PushMethod, (IPTR)_app(self), 2, MUIM_CallHook, (IPTR)&_WandererIntern_hook_backdrop
3198 );
3199 #else
3200 DoMethod
3201 (
3202 window, MUIM_Notify, MUIA_IconWindow_IsBackdrop, MUIV_EveryTime,
3203 (IPTR)_app(self), 2, MUIM_CallHook, (IPTR) &_WandererIntern_hook_backdrop
3204 );
3205 #endif
3206 D(bug("Wanderer__MUIM_Wanderer_CreateDrawerWindow: execute all notifies\n"));
3207 /* If "Execute Command" entry is clicked open the execute window */
3208 DoAllMenuNotifies(_NewWandDrawerMenu__menustrip, drw);
3209
3210 D(bug("Wanderer__MUIM_Wanderer_CreateDrawerWindow: add window to app\n"));
3211 /* Add the window to the application */
3212 #ifdef __AROS__
3213 DoMethod(_app(self), OM_ADDMEMBER, (IPTR) window);
3214 #else
3215 DoMethod(self, OM_ADDMEMBER, (IPTR) window);
3216 #endif
3217 D(bug("Wanderer__MUIM_Wanderer_CreateDrawerWindow: open window\n"));
3218 /* And now open it */
3219 DoMethod(window, MUIM_IconWindow_Open);
3220 D(bug("Wanderer__MUIM_Wanderer_CreateDrawerWindow: clean up memory\n"));
3221 /* Clean up ram string */
3222 if ( freeDrwStr && drw ) FreeVec ( drw );
3223 }
3224 D(bug("Wanderer__MUIM_Wanderer_CreateDrawerWindow: exit\n"));
3225 return window;
3226 }
3227 ///
3228 /*** Setup ******************************************************************/
3229 ZUNE_CUSTOMCLASS_9
3230 (
3231 Wanderer, NULL, MUIC_Application, NULL,
3232 OM_NEW, struct opSet *,
3233 OM_DISPOSE, Msg,
3234 OM_SET, struct opSet *,
3235 OM_GET, struct opGet *,
3236 MUIM_Application_Execute, Msg,
3237 MUIM_Wanderer_HandleTimer, Msg,
3238 MUIM_Wanderer_HandleCommand, Msg,
3239 MUIM_Wanderer_HandleNotify, Msg,
3240 MUIM_Wanderer_CreateDrawerWindow, struct MUIP_Wanderer_CreateDrawerWindow *
3241 );
The AROS cake. Goodness baked in, have it and eat it too. Delicious!