?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
add casts to zune macros to silence some warnings
[tangerine.git] / workbench / system / Wanderer / wanderer.c
blob2d9142696806b4eebbb193ef54be11fd821da445
1 /*
2 Copyright 2004-2006, The AROS Development Team. All rights reserved.
3 $Id$
4 */
5
6 #define MUIMASTER_YES_INLINE_STDARG
7
8 #define DEBUG 0
9 #include <aros/debug.h>
10
11 #define WANDERER_DEFAULT_BACKDROP
12 //#define WANDERER_DEFAULT_SHOWALL
13 //#define WANDERER_DEFAULT_SHOWHIDDEN
14
15 #include <exec/types.h>
16 #include <libraries/gadtools.h>
17 #include <libraries/mui.h>
18 #include <zune/customclasses.h>
19 #include <dos/notify.h>
20 #include <workbench/handler.h>
21 #include <proto/graphics.h>
22 #include <proto/utility.h>
23 #include <proto/intuition.h>
24 #include <proto/muimaster.h>
25 #include <proto/dos.h>
26 #include <proto/workbench.h>
27 #include <proto/layers.h>
28 #include <proto/alib.h>
29
30 #include <string.h>
31 #include <stdio.h>
32 #include <time.h>
33
34 #include <aros/detach.h>
35 #include <prefs/wanderer.h>
36
37 #include "iconwindow.h"
38 #include "iconwindow_attributes.h"
39 #include "iconwindowcontents.h"
40 #include "wandererprefs.h"
41 #include "wandererprefsintern.h"
42 #include "filesystems.h"
43 #include "wanderer.h"
44 #include "../../libs/muimaster/classes/iconlist.h"
45 #include "../../libs/muimaster/classes/iconlist_attributes.h"
46 #include "locale.h"
47
48 #include "version.h"
49
50 #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, End
51
52 extern IPTR InitWandererPrefs(void);
53 VOID DoAllMenuNotifies(Object *strip, STRPTR path);
54 Object *FindMenuitem(Object* strip, int id);
55 Object *__CreateWandererIntuitionMenu__(BOOL isRoot, BOOL useBackdrop);
56 void wanderer_menufunc_window_update(void);
57 void execute_open_with_command(BPTR cd, STRPTR contents);
58 void DisposeCopyDisplay(struct MUIDisplayObjects *d);
59 BOOL CreateCopyDisplay(UWORD flags, struct MUIDisplayObjects *d);
60
61 /* Stored in the main wanderer executable */
62 extern Object *_WandererIntern_AppObj;
63 extern Class *_WandererIntern_CLASS;
64 /* Internal Hooks */
65 struct Hook _WandererIntern_hook_standard;
66 struct Hook _WandererIntern_hook_action;
67 struct Hook _WandererIntern_hook_backdrop;
68
69 static unsigned char strtochar(STRPTR st)
70 {
71 return *st++;
72 }
73
74 /*** Instance Data **********************************************************/
75 struct Wanderer_DATA
76 {
77 struct Screen *wd_Screen;
78
79 Object *wd_Prefs,
80 *wd_ActiveWindow,
81 *wd_WorkbenchWindow;
82
83 struct MUI_InputHandlerNode wd_TimerIHN;
84 struct MsgPort *wd_CommandPort;
85 struct MUI_InputHandlerNode wd_CommandIHN;
86 struct MsgPort *wd_NotifyPort;
87 struct MUI_InputHandlerNode wd_NotifyIHN;
88 struct NotifyRequest pnr;
89
90 IPTR wd_PrefsIntern;
91 BOOL wd_Option_BackDropMode;
92 };
93
94 /*** Macros *****************************************************************/
95 #define SETUP_WANDERER_INST_DATA struct Wanderer_DATA *data = INST_DATA(CLASS, self)
96
97 /**************************************************************************
98 * HOOK FUNCS *
99 **************************************************************************/
100
101 AROS_UFH3
102 (
103 BOOL, Wanderer__HookFunc_DisplayCopyFunc,
104 AROS_UFHA(struct Hook *, h, A0),
105 AROS_UFHA(struct dCopyStruct *, obj, A2),
106 AROS_UFHA(APTR, unused_param, A1)
107 )
108 {
109 AROS_USERFUNC_INIT
110
111 struct MUIDisplayObjects *d = (struct MUIDisplayObjects *) obj->userdata;
112
113
114 if ((obj->flags & ACTION_UPDATE) == 0)
115 {
116 d->updateme = TRUE;
117
118 if ((obj->filelen < 8192) && (d->numfiles > 0))
119 {
120 d->smallobjects++;
121 if (d->smallobjects >= 20) d->smallobjects = 0;
122 }
123 else
124 {
125 d->smallobjects = 0;
126 }
127 if (d->smallobjects > 0) d->updateme = FALSE;
128 if (d->updateme)
129 {
130 SET(d->fileObject, MUIA_Text_Contents, obj->file);
131 SET(d->sourceObject, MUIA_Text_Contents, obj->spath);
132 }
133 }
134 if (d->action != ACTION_DELETE)
135 {
136
137 d->bytes += obj->actlen;
138 if ((obj->flags & ACTION_UPDATE) == 0)
139 {
140 if (d->updateme)
141 {
142 SET(d->gauge, MUIA_Gauge_Current, 0);
143 SET(d->destObject, MUIA_Text_Contents, obj->dpath);
144 }
145 d->numfiles++;
146 }
147 else
148 {
149 if (d->updateme &&(obj->totallen <= obj->filelen))
150 {
151 double rate = (double) (((double) obj->totallen) / (((double) obj->difftime) / ((double) CLOCKS_PER_SEC))) / 1024.0;
152 if (rate < 1024.0) sprintf(d->SpeedBuffer, "Speed: %.2f kBytes/s", rate); else sprintf(d->SpeedBuffer, "Speed: %.2f MBytes/s", rate / 1024.0);
153 SetAttrs(d->gauge, MUIA_Gauge_Current, (ULONG) (32768.0 * (double) obj->totallen / (double) obj->filelen), MUIA_Gauge_InfoText, d->SpeedBuffer, TAG_DONE);
154 }
155 }
156
157
158 if (d->updateme)
159 {
160 if (d->bytes < 1048576)
161 {
162 if (obj->filelen < 1048576)
163 {
164 sprintf(
165 d->Buffer, "# of files: %ld Actual: %.2f kBytes Total: %.2f kBytes",
166 d->numfiles, (double) obj->filelen / 1024.0, (double) d->bytes / 1024.0
167 );
168 }
169 else
170 {
171 sprintf(
172 d->Buffer, "# of files: %ld Actual: %.2f MBytes Total: %.2f kBytes",
173 d->numfiles, (double) obj->filelen / 1048576.0, (double) d->bytes / 1024.0
174 );
175 }
176 }
177 else
178 {
179 if (obj->filelen < 1048576)
180 {
181 sprintf(
182 d->Buffer, "# of files: %ld Actual: %.2f kBytes Total: %.2f MBytes",
183 d->numfiles, (double) obj->filelen / 1024.0, (double) d->bytes / 1048576.0
184 );
185 }
186 else
187 {
188 sprintf(
189 d->Buffer, "# of files: %ld Actual: %.2f MBytes Total: %.2f MBytes",
190 d->numfiles, (double) obj->filelen / 1048576.0, (double) d->bytes / 1048576.0
191 );
192 }
193 }
194 SET(d->performanceObject, MUIA_Text_Contents, d->Buffer);
195 }
196 }
197
198 DoMethod(d->copyApp, MUIM_Application_InputBuffered);
199
200 /* read the stopflag and return TRUE if the user wanted to stop actionDir() */
201
202 if (d->stopflag == 1) return TRUE; else return FALSE;
203
204 AROS_USERFUNC_EXIT
205 }
206
207 AROS_UFH3
208 (
209 ULONG, Wanderer__HookFunc_AskDeleteFunc,
210 AROS_UFHA(struct Hook *, h, A0),
211 AROS_UFHA(struct dCopyStruct *, obj, A2),
212 AROS_UFHA(APTR, unused_param, A1)
213 )
214 {
215 AROS_USERFUNC_INIT
216
217 ULONG back = DELMODE_NONE;
218
219 UWORD ret = 0;
220 char *string = NULL;
221
222 if (obj->file)
223 {
224 if (obj->type == 0)
225 {
226 string = CombineString("Really delete file\n\033b%s\033n\nlocated in\n\033b%s\033n ?",
227 obj->file, obj->spath);
228 }
229 else if (obj->type == 1)
230 {
231 string = CombineString("Do you wish to unprotect file\n\033b%s\033n\nlocated in\n\033b%s\033n ?",
232 obj->file, obj->spath);
233 }
234 else if (obj->type == 2)
235 {
236 string = CombineString("Really overwrite file\n\033b%s\033n\nlocated in\n\033b%s\033n ?",
237 obj->file, obj->spath);
238 }
239 else
240 {
241 string = CombineString("Can't access file\n\033b%s\033n\nlocated in\n\033b%s\033n ?",
242 obj->file, obj->spath);
243 }
244 }
245 else
246 {
247 if (obj->type == 0) string = CombineString("Really delete drawer\n\033b%s\033n ?", obj->spath);
248 else if (obj->type == 1) string = CombineString("Do you wish to unprotect drawer\n\033b%s\033n ?", obj->spath);
249 else if (obj->type == 3) string = CombineString("Can't access drawer\n\033b%s", obj->spath);
250 }
251
252 if (string)
253 {
254 if (obj->type == 0) ret = AskChoiceCentered("Delete Requester:", string, "_Yes|Yes to _All|_No|No _to ALL", 0);
255 else if (obj->type == 1) ret = AskChoiceCentered("Protection Requester:", string, "_Unprotect|Unprotect _All|_No|No _to ALL", 0);
256 else if (obj->type == 2) ret = AskChoiceCentered("Overwrite Requester:", string, "_Overwrite|Overwrite _All|_No|No _to ALL", 0);
257 else ret = AskChoiceCentered("Overwrite Requester:", string, "_Skip|_Abort", 0);
258 freeString(NULL, string);
259 }
260
261 if (ret == 0) back = DELMODE_NONE;
262 else if (ret == 1) back = DELMODE_DELETE;
263 else if (ret == 2) back = DELMODE_ALL;
264 else if (ret == 3) back = DELMODE_NO;
265
266 return back;
267
268 AROS_USERFUNC_EXIT
269 }
270
271
272 void copy_dropentries()
273 {
274 /* get filelist from user message */
275 struct Wanderer_FilelistMsg *message_filelist = FindTask(NULL)->tc_UserData;
276
277 D(bug("[WANDERER COPY] CopyContent \n" ));
278
279 if (message_filelist)
280 {
281
282 struct MUIDisplayObjects dobjects;
283 struct Hook displayCopyHook;
284 struct Hook displayDelHook;
285
286 displayCopyHook.h_Entry = (HOOKFUNC) Wanderer__HookFunc_DisplayCopyFunc;
287 displayDelHook.h_Entry = (HOOKFUNC) Wanderer__HookFunc_AskDeleteFunc;
288
289 struct Wanderer_FileEntry *currententry;
290
291 if (CreateCopyDisplay(ACTION_COPY, &dobjects))
292 {
293
294 /* process all selected entries */
295 while ( (currententry = (struct Wanderer_FileEntry *)RemTail(&message_filelist->files)) != NULL )
296 {
297
298 /* copy via filesystems.c */
299 D(bug("[WANDERER COPY] CopyContent \"%s\" to \"%s\"\n", &currententry->filename,
300 &message_filelist->destination_string ));
301
302 CopyContent(NULL, (char*)&currententry->filename, (char*)&message_filelist->destination_string, TRUE,
303 ACTION_COPY, &displayCopyHook, &displayDelHook, (APTR) &dobjects);
304
305 FreeVec( currententry );
306 }
307
308 /* delete copy window */
309 DisposeCopyDisplay(&dobjects);
310 }
311
312 }
313
314 /* free msg memory */
315 FreeMem( message_filelist, sizeof(struct Wanderer_FilelistMsg) );
316
317 return;
318 }
319
320
321 AROS_UFH3
322 (
323 void, Wanderer__HookFunc_ActionFunc,
324 AROS_UFHA(struct Hook *, h, A0),
325 AROS_UFHA(Object *, obj, A2),
326 AROS_UFHA(struct IconWindow_ActionMsg *, msg, A1)
327 )
328 {
329 AROS_USERFUNC_INIT
330
331 if (msg->type == ICONWINDOW_ACTION_OPEN)
332 {
333 static unsigned char buf[1024];
334
335 struct IconList_Entry *ent = (void*)MUIV_IconList_NextSelected_Start;
336
337 DoMethod(msg->iconlist, MUIM_IconList_NextSelected, (IPTR) &ent);
338 if ((int)ent == MUIV_IconList_NextSelected_End) return;
339
340 IPTR offset = strlen(ent->filename) - 5;
341
342 if ((msg->isroot) && (!Stricmp(ent->filename + offset, ":Disk")))
343 {
344 strcpy(buf,ent->label);
345 strcat(buf,":");
346 }
347 else
348 {
349 strcpy(buf,ent->filename);
350 }
351
352 D(bug("[WANDERER] Wanderer__HookFunc_ActionFunc: ICONWINDOW_ACTION_OPEN - offset = %d, buf = %s\n", offset, buf);)
353
354 if ( (ent->type == ST_ROOT) || (ent->type == ST_USERDIR) )
355 {
356 Object *cstate = (Object*)(((struct List*)XGET(_app(obj), MUIA_Application_WindowList))->lh_Head);
357 Object *prefs = (Object*) XGET(_app(obj), MUIA_Wanderer_Prefs);
358 Object *child;
359
360 /* open new window if root or classic navigation set */
361 if ( (msg->isroot) || (XGET(prefs, MUIA_IconWindowExt_Toolbar_NavigationMethod) == WPD_NAVIGATION_CLASSIC) )
362 {
363 while ((child = NextObject(&cstate)))
364 {
365 if (XGET(child, MUIA_UserData))
366 {
367 STRPTR child_drawer = (STRPTR)XGET(child, MUIA_IconWindow_Location);
368 if (child_drawer && !Stricmp(buf,child_drawer))
369 {
370 BOOL is_open = ( BOOL )XGET(child, MUIA_Window_Open);
371
372 if (!is_open)
373 {
374 DoMethod(child, MUIM_IconWindow_Open);
375 }
376 else
377 {
378 DoMethod(child, MUIM_Window_ToFront);
379 SET(child, MUIA_Window_Activate, TRUE);
380 }
381
382 return;
383 }
384 }
385 }
386
387 /* Check if the window for this drawer is already opened */
388 DoMethod(_WandererIntern_AppObj, MUIM_Wanderer_CreateDrawerWindow, (IPTR) buf);
389 // FIXME: error handling
390 }
391 else
392 {
393 /* open drawer in same window */
394 SET(obj, MUIA_IconWindow_Location, (IPTR) buf);
395 }
396
397 }
398 else if (ent->type == ST_FILE)
399 {
400 BPTR newwd, oldwd, file;
401
402 /* Set the CurrentDir to the path of the executable to be started */
403 file = Lock(ent->filename, SHARED_LOCK);
404 if(file)
405 {
406 newwd = ParentDir(file);
407 oldwd = CurrentDir(newwd);
408
409 if (!OpenWorkbenchObject(ent->filename, TAG_DONE))
410 {
411 execute_open_with_command(newwd, FilePart(ent->filename));
412 }
413
414 CurrentDir(oldwd);
415 UnLock(newwd);
416 UnLock(file);
417 }
418 }
419 }
420 else if (msg->type == ICONWINDOW_ACTION_DIRUP)
421 {
422
423 STRPTR actual_drawer = (STRPTR)XGET(obj, MUIA_IconWindow_Location);
424 STRPTR parent_drawer = strrchr(actual_drawer,'/');
425 STRPTR root_drawer = strrchr(actual_drawer,':');
426
427 /* check if dir is not drive root dir */
428 if ( strlen(root_drawer) > 1 )
429 {
430 /* check if second or third level directory*/
431 if (!parent_drawer)
432 {
433 (*(root_drawer+1)) = 0;
434 SET(obj, MUIA_IconWindow_Location, actual_drawer);
435
436 }
437 else
438 {
439 (*parent_drawer) = 0;
440 SET(obj, MUIA_IconWindow_Location, actual_drawer);
441 }
442
443 }
444 }
445 else if (msg->type == ICONWINDOW_ACTION_CLICK)
446 {
447 if (!msg->click->shift)
448 {
449 Object *cstate = (Object*)(((struct List*)XGET(_WandererIntern_AppObj, MUIA_Application_WindowList))->lh_Head);
450 Object *child;
451
452 while ((child = NextObject(&cstate)))
453 {
454 if (XGET(child, MUIA_UserData))
455 {
456 if (child != obj) DoMethod(child, MUIM_IconWindow_UnselectAll);
457 }
458 }
459 }
460 }
461 else if (msg->type == ICONWINDOW_ACTION_ICONDROP)
462 {
463 struct Process *child;
464
465 struct IconList_Drop *drop = (struct IconList_Drop *)msg->drop;
466 struct IconList_Entry *ent = (void*)MUIV_IconList_NextSelected_Start;
467 struct Wanderer_FileEntry *file_recordtmp;
468
469 struct Wanderer_FilelistMsg *message_filelist = AllocMem( sizeof(struct Wanderer_FilelistMsg), MEMF_CLEAR|MEMF_PUBLIC );
470
471 if (message_filelist != NULL)
472 {
473 strcpy( (char*)&message_filelist->destination_string, drop->destination_string);
474
475 NEWLIST(&message_filelist->files);
476
477 /* process all selected entries */
478 do
479 {
480 DoMethod(drop->source_iconlistobj, MUIM_IconList_NextSelected, (IPTR) &ent);
481
482 /* if not end of selection, process */
483 if ( (int)ent != MUIV_IconList_NextSelected_End )
484 {
485 file_recordtmp = AllocVec( sizeof(struct Wanderer_FileEntry), MEMF_CLEAR|MEMF_PUBLIC );
486 strcpy( (char*)&file_recordtmp->filename, ent->filename);
487 AddTail(&message_filelist->files, (struct Node *)file_recordtmp);
488 }
489 }
490 while ( (int)ent != MUIV_IconList_NextSelected_End );
491
492 /* create process and copy files within */
493 child = CreateNewProcTags(
494 NP_Entry, copy_dropentries,
495 NP_UserData, (IPTR)message_filelist,
496 NP_Name, (ULONG)"wanderer copy",
497 NP_StackSize, 40000,
498 TAG_DONE);
499
500 /* FIXME: update list contents */
501 /* this one should be solved through file notofications, as files are copied in a seperate process now */
502
503 }
504
505
506
507 }
508 else if (msg->type == ICONWINDOW_ACTION_APPWINDOWDROP)
509 {
510 struct Screen *wscreen = NULL;
511 struct Layer *layer;
512
513 /* get wanderers screen struct and the layer located at cursor position afterwards */
514 get( obj, MUIA_Window_Screen, &wscreen);
515 layer = WhichLayer(&wscreen->LayerInfo,wscreen->MouseX,wscreen->MouseY);
516
517 if (layer)
518 {
519 struct Window *win = (struct Window *) layer->Window;
520 if (win)
521 {
522 struct List AppList;
523 ULONG files = 0;
524 BOOL fail = FALSE;
525 NewList(&AppList);
526
527 struct IconList_Entry *ent = (void*)MUIV_IconList_NextSelected_Start;
528 /* process all selected entries */
529 do
530 {
531 DoMethod(msg->iconlist, MUIM_IconList_NextSelected, (IPTR) &ent);
532 /* if not end of selection, process */
533 if ( (int)ent != MUIV_IconList_NextSelected_End )
534 {
535 struct AppW *a = AllocVec(sizeof(struct AppW), MEMF_CLEAR);
536 if (a)
537 {
538 a->name = AllocVec(strlen(ent->filename)+1, MEMF_CLEAR);
539 if (a->name)
540 {
541 files++;
542 strcpy(a->name, ent->filename);
543 AddTail(&AppList, (struct Node *) a);
544 }
545 else
546 {
547 FreeVec(a);
548 fail = TRUE;
549 }
550 }
551 else fail = TRUE;
552 }
553 }
554 while ( ((int)ent != MUIV_IconList_NextSelected_End ) && !fail);
555
556 if (!fail && (files > 0))
557 {
558 STRPTR *filelist = AllocVec(sizeof(STRPTR) * files, MEMF_CLEAR);
559 if (filelist != NULL)
560 {
561 STRPTR *flist = filelist;
562 if (!IsListEmpty(&AppList))
563 {
564 struct Node *succ;
565 struct Node *s = AppList.lh_Head;
566 while (((succ = ((struct Node*) s)->ln_Succ) != NULL) && !fail)
567 {
568 *flist ++ = ((struct AppW *) s)->name;
569 s = succ;
570 }
571
572 D(bug("[WANDERER] AppWindowMsg: win:%s files:%s mx:%d my:%d\n",win->Title, filelist, wscreen->MouseX - win->LeftEdge, wscreen->MouseY - win->TopEdge);)
573 /* send appwindow msg struct containing selected files to destination */
574 SendAppWindowMessage(win, files, filelist, 0, wscreen->MouseX - win->LeftEdge, wscreen->MouseY - win->TopEdge, 0, 0);
575
576 }
577 FreeVec(filelist);
578 }
579 }
580 if (!IsListEmpty(&AppList))
581 {
582 struct Node *succ;
583 struct Node *s = AppList.lh_Head;
584 while (((succ = ((struct Node*) s)->ln_Succ) != NULL))
585 {
586 if ( ((struct AppW *) s)->name != NULL )
587 FreeVec(((struct AppW *) s)->name);
588 if ( s != NULL )
589 FreeVec(s);
590 s = succ;
591 }
592 }
593
594 }
595 }
596
597
598 }
599
600 AROS_USERFUNC_EXIT
601 }
602
603 AROS_UFH3
604 (
605 void, Wanderer__HookFunc_StandardFunc,
606 AROS_UFHA(struct Hook *, h, A0),
607 AROS_UFHA(void *, dummy, A2),
608 AROS_UFHA(void **, funcptr, A1)
609 )
610 {
611 AROS_USERFUNC_INIT
612
613 void (*func) (ULONG *) = (void (*)(ULONG *)) (*funcptr);
614 if (func) func((ULONG *)(funcptr + 1));
615
616 AROS_USERFUNC_EXIT
617 }
618
619 AROS_UFH3
620 (
621 void, Wanderer__HookFunc_BackdropFunc,
622 AROS_UFHA(struct Hook *, h, A0),
623 AROS_UFHA(void *, dummy, A2),
624 AROS_UFHA(void **, funcptr, A1)
625 )
626 {
627 AROS_USERFUNC_INIT
628
629 D(bug("[WANDERER] Wanderer__HookFunc_BackdropFunc()\n"));
630 struct Wanderer_DATA *data = INST_DATA(_WandererIntern_CLASS, _WandererIntern_AppObj);
631
632 D(bug("[WANDERER] Wanderer__HookFunc_BackdropFunc: Private data @ %x\n", data));
633
634 if (!data->wd_WorkbenchWindow)
635 {
636 D(bug("[WANDERER] Wanderer__HookFunc_BackdropFunc: No Workbench Window\n"));
637 return;
638 }
639
640 BOOL wb_iscurrentlybd = (BOOL)XGET(data->wd_WorkbenchWindow, MUIA_IconWindow_IsBackdrop);
641
642 if (wb_iscurrentlybd != data->wd_Option_BackDropMode)
643 {
644 D(bug("[WANDERER] Wanderer__HookFunc_BackdropFunc: Backdrop mode change requested!\n"));
645
646 BOOL isOpen = (BOOL)XGET(data->wd_WorkbenchWindow, MUIA_Window_Open);
647 Object *win_Active = NULL;
648
649 D(bug("[WANDERER] Wanderer__HookFunc_BackdropFunc: Disposing of existing Workbench window Obj ..\n"));
650 if (isOpen)
651 SET(data->wd_WorkbenchWindow, MUIA_Window_Open, FALSE);
652
653 if (data->wd_WorkbenchWindow == data->wd_ActiveWindow)
654 {
655 data->wd_ActiveWindow = NULL;
656 }
657 else
658 {
659 win_Active = data->wd_ActiveWindow;
660 }
661
662 /* Kill our close request notification .. */
663 DoMethod
664 (
665 data->wd_WorkbenchWindow, MUIM_KillNotify, MUIA_Window_CloseRequest
666 );
667
668 /* .. And dispose of the window */
669 DoMethod(_WandererIntern_AppObj, OM_REMMEMBER, data->wd_WorkbenchWindow);
670 MUI_DisposeObject(data->wd_WorkbenchWindow);
671 data->wd_WorkbenchWindow = NULL;
672
673 #if defined(DEBUG)
674 if (data->wd_Option_BackDropMode)
675 {
676 D(bug("[WANDERER] Wanderer__HookFunc_BackdropFunc: Creating new Workbench window Obj (BACKDROP MODE)..\n"));
677 }
678 else
679 {
680 D(bug("[WANDERER] Wanderer__HookFunc_BackdropFunc: Creating new Workbench window Obj (NORMAL MODE)..\n"));
681 }
682 #endif
683
684 data->wd_WorkbenchWindow = (Object *) DoMethod
685 (
686 _WandererIntern_AppObj, MUIM_Wanderer_CreateDrawerWindow, (IPTR) NULL
687 );
688
689 if ((data->wd_WorkbenchWindow) && (isOpen))
690 {
691 D(bug("[WANDERER] Wanderer__HookFunc_BackdropFunc: Making Workbench window visable..\n"));
692 DoMethod(data->wd_WorkbenchWindow, MUIM_IconWindow_Open);
693 DoMethod(data->wd_WorkbenchWindow, MUIM_Window_ToBack);
694 }
695
696 if (win_Active)
697 {
698 SET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow, win_Active);
699 }
700 else if (data->wd_WorkbenchWindow)
701 {
702 SET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow, data->wd_WorkbenchWindow);
703 }
704 }
705 AROS_USERFUNC_EXIT
706 }
707
708 /******** code from workbench/c/Info.c *******************/
709 static void fmtlarge(UBYTE *buf, ULONG num)
710 {
711 UQUAD d;
712 UBYTE ch;
713 struct
714 {
715 ULONG val;
716 LONG dec;
717 } array =
718 {
719 num,
720 0
721 };
722
723 if (num >= 1073741824)
724 {
725 array.val = num >> 30;
726 d = ((UQUAD)num * 10 + 536870912) / 1073741824;
727 array.dec = d % 10;
728 //ch = 'G';
729 ch = strtochar((STRPTR)_(MSG_MEM_G));
730 }
731 else if (num >= 1048576)
732 {
733 array.val = num >> 20;
734 d = ((UQUAD)num * 10 + 524288) / 1048576;
735 array.dec = d % 10;
736 //ch = 'M';
737 ch = strtochar((STRPTR)_(MSG_MEM_M));
738 }
739 else if (num >= 1024)
740 {
741 array.val = num >> 10;
742 d = (num * 10 + 512) / 1024;
743 array.dec = d % 10;
744 //ch = 'K';
745 ch = strtochar((STRPTR)_(MSG_MEM_K));
746 }
747 else
748 {
749 array.val = num;
750 array.dec = 0;
751 d = 0;
752 //ch = 'B';
753 ch = strtochar((STRPTR)_(MSG_MEM_B));
754 }
755
756 if (!array.dec && (d > array.val * 10))
757 {
758 array.val++;
759 }
760
761 RawDoFmt(array.dec ? "%lu.%lu" : "%lu", &array, NULL, buf);
762 while (*buf) { buf++; }
763 *buf++ = ch;
764 *buf = '\0';
765 }
766
767
768
769 STRPTR GetScreenTitle(VOID)
770 {
771 STATIC TEXT title[256];
772 UBYTE chip[10], fast[10];
773 fmtlarge(chip,AvailMem(MEMF_CHIP));
774 fmtlarge(fast,AvailMem(MEMF_FAST));
775
776 /* AROS probably don't have graphics mem but without it looks so empty */
777 sprintf(title, _(MSG_SCREENTITLE), chip, fast);
778
779 return title;
780 }
781
782 STRPTR GetUserScreenTitle(Object *self)
783 {
784 /*Work in progress :-)
785 */
786 char *screentitlestr;
787
788 GET(self, MUIA_IconWindowExt_ScreenTitle_String, &screentitlestr);
789
790 int screentitleleng = strlen(screentitlestr);
791
792 if (screentitleleng<1)
793 {
794 return GetScreenTitle();
795 }
796 return screentitlestr;
797
798 }
799
800 /* Expand a passed in env: string to its full location */
801 /* Wanderer doesnt free this mem at the moment but should
802 incase it is every closed */
803 STRPTR ExpandEnvName(STRPTR env_path)
804 {
805 BOOL ok = FALSE;
806 char tmp_envbuff[1024];
807 STRPTR fullpath = NULL;
808 BPTR env_lock = NULL;
809
810 env_lock = Lock("ENV:", SHARED_LOCK);
811 if (env_lock)
812 {
813 if (NameFromLock(env_lock, tmp_envbuff, 256)) ok = TRUE;
814 UnLock(env_lock);
815 }
816
817 if (ok)
818 {
819 if ((fullpath = AllocVec(strlen(tmp_envbuff) + strlen(env_path) + 1 + 1 - 4, MEMF_CLEAR | MEMF_PUBLIC)) != NULL)
820 {
821 strcpy(fullpath, tmp_envbuff);
822 AddPart(fullpath, env_path + 4, 1019);
823 return fullpath;
824 }
825 }
826
827 //We couldnt expand it so just use as is ..
828 return env_path;
829 }
830
831 enum
832 {
833 MEN_WANDERER = 1,
834 MEN_WANDERER_BACKDROP,
835 MEN_WANDERER_EXECUTE,
836 MEN_WANDERER_SHELL,
837 MEN_WANDERER_GUISETTINGS,
838 MEN_WANDERER_ABOUT,
839 MEN_WANDERER_QUIT,
840
841 MEN_WINDOW_NEW_DRAWER,
842 MEN_WINDOW_OPEN_PARENT,
843 MEN_WINDOW_CLOSE,
844 MEN_WINDOW_UPDATE,
845
846 MEN_WINDOW_SELECT,
847 MEN_WINDOW_CLEAR,
848
849 MEN_WINDOW_SNAP_WIN,
850 MEN_WINDOW_SNAP_ALL,
851
852 MEN_WINDOW_VIEW_ICON,
853 MEN_WINDOW_VIEW_DETAIL,
854 MEN_WINDOW_VIEW_ALL,
855
856 MEN_WINDOW_SORT_NOW,
857 MEN_WINDOW_SORT_NAME,
858 MEN_WINDOW_SORT_TYPE,
859 MEN_WINDOW_SORT_DATE,
860 MEN_WINDOW_SORT_SIZE,
861 MEN_WINDOW_SORT_REVERSE,
862 MEN_WINDOW_SORT_TOPDRAWERS,
863 MEN_WINDOW_SORT_GROUP,
864
865 MEN_ICON_OPEN,
866 MEN_ICON_RENAME,
867 MEN_ICON_INFORMATION,
868 MEN_ICON_DELETE,
869 };
870
871
872
873 /**************************************************************************
874 Open the execute window. Similar to below but you can also set the
875 command. Called when item is openend
876 **************************************************************************/
877 void execute_open_with_command(BPTR cd, STRPTR contents)
878 {
879 BPTR lock;
880
881 if (cd != NULL) lock = cd;
882 else lock = Lock("RAM:", ACCESS_READ);
883
884 OpenWorkbenchObject
885 (
886 "WANDERER:Tools/ExecuteCommand",
887 WBOPENA_ArgLock, (IPTR) lock,
888 WBOPENA_ArgName, (IPTR) contents,
889 TAG_DONE
890 );
891
892 if (cd == NULL) UnLock(lock);
893 }
894
895 /**************************************************************************
896 Open the execute window
897
898 This function will always get the current drawer as argument
899 **************************************************************************/
900 VOID wanderer_menufunc_wanderer_execute(STRPTR *cdptr)
901 {
902 //TODO: remove the STRPTR *cdptr from top
903 //TODO:remove this commented out stuff
904 //BPTR lock = NULL;
905 //if (cdptr != NULL) lock = Lock(*cdptr, SHARED_LOCK);
906 Object *win = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
907 STRPTR dr = ( STRPTR )XGET( win, MUIA_IconWindow_Location );
908 BPTR cd = Lock(dr,SHARED_LOCK);
909 execute_open_with_command(cd, NULL);
910 if (cd) UnLock(cd);
911 }
912
913 /*******************************/
914
915 void wanderer_menufunc_wanderer_shell(STRPTR *cd_ptr)
916 {
917 //TODO: remove the STRPTR *cdptr from top
918 //TODO:remove this commented out stuff
919 //BPTR cd = Lock(*cd_ptr,ACCESS_READ);
920 Object *win = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
921 STRPTR dr = ( STRPTR )XGET( win, MUIA_IconWindow_Location );
922 BPTR cd;
923
924 if (!dr)
925 {
926 bug("wanderer_menufunc_wanderer_shell is broken, fix it please !\n");
927 dr = "";
928 }
929
930 cd = Lock(dr, ACCESS_READ);
931 if (SystemTags("NewShell", NP_CurrentDir, (IPTR)cd, TAG_DONE) == -1)
932 {
933 UnLock(cd);
934 }
935 }
936
937 void wanderer_menufunc_wanderer_backdrop(Object **pstrip)
938 {
939 struct Wanderer_DATA *data = INST_DATA(_WandererIntern_CLASS, _WandererIntern_AppObj);
940 Object *strip = *pstrip;
941 Object *item = FindMenuitem(strip, MEN_WANDERER_BACKDROP);
942
943 D(bug("[WANDERER] wanderer_menufunc_wanderer_backdrop()\n"));
944
945 if (item != NULL)
946 {
947 data->wd_Option_BackDropMode = (BOOL)XGET(item, MUIA_Menuitem_Checked);
948 SET(data->wd_WorkbenchWindow, MUIA_IconWindow_IsBackdrop, data->wd_Option_BackDropMode);
949 }
950 }
951
952 void wanderer_menufunc_window_newdrawer(STRPTR *cdptr)
953 {
954 //TODO: remove the STRPTR *cdptr from top
955
956 Object *win = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
957 STRPTR dr = ( STRPTR )XGET( win, MUIA_IconWindow_Location );
958 D(bug("[wanderer] wanderer_menufunc_window_newdrawer(%s)\n", dr));
959
960 Object *actwindow = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
961 Object *wbwindow = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_WorkbenchWindow);
962 if (actwindow == wbwindow)
963 {
964 /* This check is necessary because WorkbenchWindow has path RAM: */
965 D(bug("[wanderer] wanderer_menufunc_window_newdrawer: Can't call WBNewDrawer for WorkbenchWindow\n"));
966 return;
967 }
968 if ( XGET(actwindow, MUIA_Window_Open) == FALSE )
969 {
970 D(bug("[wanderer] wanderer_menufunc_window_newdrawer: Can't call WBNewDrawer: the active window isn't open\n"));
971 return;
972 }
973
974 BPTR lock = Lock(dr, ACCESS_READ);
975 OpenWorkbenchObject
976 (
977 "WANDERER:Tools/WBNewDrawer",
978 WBOPENA_ArgLock, (IPTR) lock,
979 WBOPENA_ArgName, 0,
980 TAG_DONE
981 );
982 UnLock(lock);
983 }
984
985 void wanderer_menufunc_window_openparent(STRPTR *cdptr)
986 {
987 //TODO: Remove the **cdptr stuff from top
988 Object *win = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
989 STRPTR dr = ( STRPTR )XGET( win, MUIA_IconWindow_Location );
990
991 IPTR path_len=0;
992 STRPTR last_letter=NULL;
993 last_letter = &dr[ strlen(dr) - 1 ];
994
995 STRPTR thispath = FilePart(dr);
996
997 if (*last_letter==0x3a) return; /* Top Drawer has no parent to open */
998
999 last_letter = &thispath[strlen(thispath)-1];
1000
1001 if (*last_letter==0x3a)
1002 path_len = (IPTR)(thispath-(IPTR)(dr));
1003 else
1004 path_len = (IPTR)((thispath-(IPTR)(dr))-1);
1005
1006 STRPTR buf = AllocVec((path_len+1),MEMF_PUBLIC|MEMF_CLEAR);
1007 CopyMem(dr, buf, path_len);
1008
1009 Object *cstate = (Object*)(((struct List*)XGET(_WandererIntern_AppObj, MUIA_Application_WindowList))->lh_Head);
1010 Object *child;
1011
1012 // Make sure we have a correct path
1013 BOOL foundSlash = FALSE, foundColon = FALSE;
1014 int i = 0; for ( ; i < path_len; i++ )
1015 {
1016 if ( buf[ i ] == '/' ) foundSlash = TRUE;
1017 if ( buf[ i ] == ':' ) foundColon = TRUE;
1018 }
1019 if ( !foundColon && !foundSlash )
1020 {
1021 STRPTR newbuf = AllocVec ((path_len + 2), MEMF_PUBLIC|MEMF_CLEAR);
1022 sprintf(newbuf,"%s:",buf);
1023 FreeVec (buf);
1024 buf = newbuf;
1025 }
1026 // Done with path correction check
1027
1028 while ((child = NextObject(&cstate)))
1029 {
1030 if (XGET(child, MUIA_UserData))
1031 {
1032 STRPTR child_drawer = (STRPTR)XGET(child, MUIA_IconWindow_Location);
1033 if (child_drawer && !Stricmp(buf,child_drawer))
1034 {
1035 int is_open = XGET(child, MUIA_Window_Open);
1036 if (!is_open)
1037 DoMethod(child, MUIM_IconWindow_Open);
1038 else
1039 {
1040 DoMethod(child, MUIM_Window_ToFront);
1041 SET(child, MUIA_Window_Activate, TRUE);
1042 }
1043 FreeVec(buf);
1044 return;
1045 }
1046 }
1047 }
1048
1049 DoMethod(_WandererIntern_AppObj, MUIM_Wanderer_CreateDrawerWindow, (IPTR) buf);
1050 FreeVec(buf);
1051 }
1052
1053 void wanderer_menufunc_window_close()
1054 {
1055 Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1056 SET(window, MUIA_Window_CloseRequest, TRUE);
1057 }
1058
1059 void wanderer_menufunc_window_update()
1060 {
1061 Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1062 Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1063
1064 if (iconList != NULL)
1065 {
1066 DoMethod(iconList, MUIM_IconList_Update);
1067 }
1068 }
1069
1070 void wanderer_menufunc_window_clear()
1071 {
1072 Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1073 Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1074
1075 if (iconList != NULL)
1076 {
1077 DoMethod(iconList, MUIM_IconList_UnselectAll);
1078 }
1079 }
1080
1081 void wanderer_menufunc_window_select()
1082 {
1083 Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1084 Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1085
1086 if (iconList != NULL)
1087 {
1088 DoMethod(iconList, MUIM_IconList_SelectAll);
1089 }
1090 }
1091
1092 void wanderer_menufunc_window_view_icons(Object **pstrip)
1093 {
1094 Object *strip = *pstrip;
1095 Object *item = FindMenuitem(strip, MEN_WINDOW_VIEW_ALL);
1096 Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1097 Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1098
1099 if (item != NULL && iconList != NULL)
1100 {
1101 ULONG display_bits = 0, menu_view_state = 0;
1102 GET(iconList, MUIA_IconList_DisplayFlags, &display_bits);
1103
1104 GET(item, MUIA_Menuitem_Checked, &menu_view_state);
1105
1106 if (menu_view_state)
1107 {
1108 display_bits &= ~ICONLIST_DISP_SHOWINFO;
1109 }
1110 else
1111 {
1112 display_bits |= ICONLIST_DISP_SHOWINFO;
1113 }
1114
1115 SET(iconList, MUIA_IconList_DisplayFlags, display_bits);
1116 DoMethod(iconList, MUIM_IconList_Sort);
1117 }
1118 }
1119
1120 void wanderer_menufunc_window_sort_name(Object **pstrip)
1121 {
1122 Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1123 Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1124
1125 if ( iconList != NULL)
1126 {
1127 ULONG sort_bits = 0;
1128 GET(iconList, MUIA_IconList_SortFlags, &sort_bits);
1129
1130 /*name = date and size bit both NOT set*/
1131 if( (sort_bits & ICONLIST_SORT_BY_DATE) || (sort_bits & ICONLIST_SORT_BY_SIZE) )
1132 {
1133 sort_bits &= ~(ICONLIST_SORT_BY_DATE | ICONLIST_SORT_BY_SIZE);
1134 }
1135
1136 SET(iconList, MUIA_IconList_SortFlags, sort_bits);
1137 DoMethod(iconList, MUIM_IconList_Sort);
1138 }
1139 }
1140
1141 void wanderer_menufunc_window_sort_date(Object **pstrip)
1142 {
1143 Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1144 Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1145
1146 if ( iconList != NULL)
1147 {
1148 ULONG sort_bits = 0;
1149 GET(iconList, MUIA_IconList_SortFlags, &sort_bits);
1150
1151 /*exclude size bit*/
1152 if( sort_bits & ICONLIST_SORT_BY_SIZE )
1153 {
1154 sort_bits &= ~ICONLIST_SORT_BY_SIZE;
1155 }
1156
1157 sort_bits |= ICONLIST_SORT_BY_DATE;
1158
1159 SET(iconList, MUIA_IconList_SortFlags, sort_bits);
1160 DoMethod(iconList, MUIM_IconList_Sort);
1161 }
1162 }
1163
1164 void wanderer_menufunc_window_sort_size(Object **pstrip)
1165 {
1166 Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1167 Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1168
1169 if ( iconList != NULL)
1170 {
1171 ULONG sort_bits = 0;
1172 GET(iconList, MUIA_IconList_SortFlags, &sort_bits);
1173
1174 /*exclude date bit*/
1175 if( sort_bits & ICONLIST_SORT_BY_DATE )
1176 {
1177 sort_bits &= ~ICONLIST_SORT_BY_DATE;
1178 }
1179
1180 sort_bits |= ICONLIST_SORT_BY_SIZE;
1181
1182 SET(iconList, MUIA_IconList_SortFlags, sort_bits);
1183 DoMethod(iconList, MUIM_IconList_Sort);
1184 }
1185 }
1186
1187 void wanderer_menufunc_window_sort_type(Object **pstrip)
1188 {
1189 Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1190 Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1191
1192 if ( iconList != NULL)
1193 {
1194 ULONG sort_bits = 0;
1195 GET(iconList, MUIA_IconList_SortFlags, &sort_bits);
1196
1197 /*type = both date and size bits set*/
1198 sort_bits |= (ICONLIST_SORT_BY_DATE | ICONLIST_SORT_BY_SIZE);
1199
1200 SET(iconList, MUIA_IconList_SortFlags, sort_bits);
1201 DoMethod(iconList, MUIM_IconList_Sort);
1202 }
1203 }
1204
1205 void wanderer_menufunc_window_sort_reverse(Object **pstrip)
1206 {
1207 Object *strip = *pstrip;
1208 Object *item = FindMenuitem(strip, MEN_WINDOW_SORT_REVERSE);
1209 Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1210 Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1211
1212 if (item != NULL && iconList != NULL)
1213 {
1214 ULONG sort_bits = 0;
1215 GET(iconList, MUIA_IconList_SortFlags, &sort_bits);
1216
1217 if( XGET(item, MUIA_Menuitem_Checked) )
1218 {
1219 sort_bits |= ICONLIST_SORT_REVERSE;
1220 }
1221 else
1222 {
1223 sort_bits &= ~ICONLIST_SORT_REVERSE;
1224 }
1225
1226 SET(iconList, MUIA_IconList_SortFlags, sort_bits);
1227 DoMethod(iconList, MUIM_IconList_Sort);
1228 }
1229 }
1230
1231 void wanderer_menufunc_window_sort_topdrawers(Object **pstrip)
1232 {
1233 Object *strip = *pstrip;
1234 Object *item = FindMenuitem(strip, MEN_WINDOW_SORT_TOPDRAWERS);
1235 Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1236 Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1237
1238 if (item != NULL && iconList != NULL)
1239 {
1240 ULONG sort_bits = 0;
1241 GET(iconList, MUIA_IconList_SortFlags, &sort_bits);
1242
1243 if( XGET(item, MUIA_Menuitem_Checked) )
1244 {
1245 sort_bits &= !ICONLIST_SORT_DRAWERS_MIXED;
1246 }
1247 else
1248 {
1249 sort_bits |= ICONLIST_SORT_DRAWERS_MIXED;
1250 }
1251
1252 SET(iconList, MUIA_IconList_SortFlags, sort_bits);
1253 DoMethod(iconList, MUIM_IconList_Sort);
1254 }
1255 }
1256
1257 void wanderer_menufunc_icon_open()
1258 {
1259 Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1260 DoMethod(window, MUIM_IconWindow_DoubleClicked);
1261 }
1262
1263 void wanderer_menufunc_icon_rename(void)
1264 {
1265 Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1266 Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1267 struct IconList_Entry *entry = (APTR) MUIV_IconList_NextSelected_Start;
1268
1269 do
1270 {
1271 DoMethod(iconList, MUIM_IconList_NextSelected, (IPTR) &entry);
1272
1273 if ((int)entry != MUIV_IconList_NextSelected_End)
1274 {
1275 BPTR lock = Lock(entry->filename, ACCESS_READ);
1276 BPTR parent = ParentDir(lock);
1277 UnLock(lock);
1278
1279 D(bug("[wanderer] wanderer_menufunc_icon_rename: selected = '%s'\n", entry->filename));
1280
1281 OpenWorkbenchObject
1282 (
1283 "WANDERER:Tools/WBRename",
1284 WBOPENA_ArgLock, (IPTR) parent,
1285 WBOPENA_ArgName, (IPTR) FilePart(entry->filename),
1286 TAG_DONE
1287 );
1288
1289 D(bug("[wanderer] wanderer_menufunc_icon_rename: selected = '%s'\n", entry->filename));
1290
1291 UnLock(parent);
1292 }
1293 else
1294 {
1295 break;
1296 }
1297 } while (TRUE);
1298 }
1299
1300 void wanderer_menufunc_icon_information()
1301 {
1302 Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1303 Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1304 struct IconList_Entry *entry = (APTR) MUIV_IconList_NextSelected_Start;
1305
1306 do
1307 {
1308 DoMethod(iconList, MUIM_IconList_NextSelected, (IPTR) &entry);
1309
1310 if ((int)entry != MUIV_IconList_NextSelected_End)
1311 {
1312 BPTR lock = Lock(entry->filename, ACCESS_READ);
1313 BPTR parent = ParentDir(lock);
1314 UnLock(lock);
1315
1316 D(bug("[wanderer] wanderer_menufunc_icon_information: selected = '%s'\n", entry->filename));
1317
1318 WBInfo(parent, entry->filename, NULL);
1319
1320 UnLock(parent);
1321 }
1322 else
1323 {
1324 break;
1325 }
1326 } while (TRUE);
1327 }
1328
1329 /* dispose the file copy display */
1330
1331 void DisposeCopyDisplay(struct MUIDisplayObjects *d)
1332 {
1333 if (d->copyApp)
1334 {
1335 //SET(d->win,MUIA_Window_Open,FALSE);
1336 MUI_DisposeObject(d->copyApp);
1337 }
1338 }
1339
1340 /* create the file copy window */
1341 BOOL CreateCopyDisplay(UWORD flags, struct MUIDisplayObjects *d)
1342 {
1343 BOOL back = FALSE;
1344
1345 Object *group, *fromObject, *toObject, *fileTextObject, *fileLengthObject, *gaugeGroup;
1346
1347 d->stopflag = 0; // will be set to 1 when clicking on stop, than the displayhook can tell actionDir() to stop copy
1348 d->bytes = 0;
1349 d->numfiles = 0;
1350 d->action = flags;
1351 d->smallobjects = 0;
1352 d->copyApp = ApplicationObject,
1353 MUIA_Application_Title, (IPTR)"CopyRequester",
1354 MUIA_Application_Base, (IPTR)"WANDERER_COPY",
1355 SubWindow, (IPTR)(d->win = WindowObject,
1356 MUIA_Window_Title, (IPTR)"Copy Filesystem",
1357 MUIA_Window_Activate, TRUE,
1358 MUIA_Window_DepthGadget, TRUE,
1359 MUIA_Window_DragBar, TRUE,
1360 MUIA_Window_SizeGadget, TRUE,
1361 MUIA_Window_AppWindow, FALSE,
1362 MUIA_Window_CloseGadget, FALSE,
1363 MUIA_Window_Borderless, FALSE,
1364 MUIA_Window_TopEdge, MUIV_Window_TopEdge_Centered,
1365 MUIA_Window_LeftEdge, MUIV_Window_LeftEdge_Centered,
1366 MUIA_Window_Width, MUIV_Window_Width_Visible(60),
1367 WindowContents, (group = VGroup,
1368 Child, (IPTR)(fromObject = TextObject,
1369 InnerSpacing(8,2),
1370 MUIA_Text_PreParse, (IPTR)"\33c",
1371 End),
1372 Child, (IPTR)(d->sourceObject = TextObject,
1373 TextFrame,
1374 InnerSpacing(8,2),
1375 MUIA_Background, MUII_TextBack,
1376 MUIA_Text_PreParse, (IPTR)"\33c",
1377 MUIA_Text_Contents, (IPTR)"---",
1378 End),
1379 Child, (IPTR)(toObject = TextObject,
1380 InnerSpacing(8,2),
1381 MUIA_Text_PreParse, (IPTR)"\33c",
1382 End),
1383 Child, (IPTR)(d->destObject = TextObject,
1384 TextFrame,
1385 InnerSpacing(8,2),
1386 MUIA_Background, MUII_TextBack,
1387 MUIA_Text_PreParse, (IPTR)"\33c",
1388 MUIA_Text_Contents, (IPTR)"---",
1389 End),
1390 Child, (IPTR)(fileTextObject = TextObject,
1391 InnerSpacing(8,2),
1392 MUIA_Text_PreParse, (IPTR)"\33c",
1393 End),
1394 Child, (IPTR)(d->fileObject = TextObject,
1395 TextFrame,
1396 InnerSpacing(8,2),
1397 MUIA_Background, MUII_TextBack,
1398 MUIA_Text_PreParse, (IPTR)"\33c",
1399 MUIA_Text_Contents, (IPTR)"---",
1400 End),
1401 Child, (IPTR)(fileLengthObject = TextObject,
1402 InnerSpacing(8,2),
1403 MUIA_Text_PreParse, (IPTR)"\33c",
1404 End),
1405 Child, (IPTR)(gaugeGroup = VGroup,
1406 TextFrame,
1407 Child, d->gauge = GaugeObject,
1408 MUIA_Gauge_Horiz, TRUE,
1409 MUIA_Gauge_Max, 32768,
1410 MUIA_Gauge_InfoText, "Processing...",
1411 End,
1412 Child, ScaleObject,
1413 MUIA_Scale_Horiz, TRUE,
1414 End,
1415 End),
1416 Child, (IPTR)( d->performanceObject = TextObject,
1417 TextFrame,
1418 InnerSpacing(8,2),
1419 MUIA_Background, MUII_TextBack,
1420 MUIA_Text_PreParse, (IPTR)"\33c",
1421 MUIA_Text_Contents, (IPTR)"...........0 Bytes...........",
1422 End),
1423
1424 Child, (IPTR)( d->stopObject = SimpleButton("Stop") ),
1425 End),
1426 End),
1427 End;
1428
1429
1430 if (d->copyApp)
1431 {
1432 if ((flags & (ACTION_COPY|ACTION_DELETE)) == (ACTION_COPY|ACTION_DELETE))
1433 {
1434 SET(fromObject, MUIA_Text_Contents, (IPTR)"move from");
1435 SET(toObject, MUIA_Text_Contents, (IPTR)"move to");
1436 SET(fileTextObject, MUIA_Text_Contents, (IPTR)"file");
1437 SET(fileLengthObject, MUIA_Text_Contents, (IPTR)"traffic");
1438 }
1439 else if ((flags & ACTION_COPY) == ACTION_COPY)
1440 {
1441 SET(fromObject, MUIA_Text_Contents, (IPTR)"copy from");
1442 SET(toObject, MUIA_Text_Contents, (IPTR)"copy to");
1443 SET(fileTextObject, MUIA_Text_Contents, (IPTR)"file");
1444 SET(fileLengthObject, MUIA_Text_Contents, (IPTR)"traffic");
1445
1446 }
1447 else if ((flags & ACTION_DELETE) == ACTION_DELETE)
1448 {
1449 SET(fromObject, MUIA_Text_Contents, "delete from");
1450 DoMethod(group, MUIM_Group_InitChange);
1451 DoMethod(group, OM_REMMEMBER, toObject);
1452 DoMethod(group, OM_REMMEMBER, fileLengthObject);
1453 DoMethod(group, OM_REMMEMBER, d->performanceObject);
1454 DoMethod(group, OM_REMMEMBER, d->destObject);
1455 DoMethod(group, OM_REMMEMBER, gaugeGroup);
1456 DoMethod(group, MUIM_Group_ExitChange);
1457 SET(fileTextObject, MUIA_Text_Contents, "file to delete");
1458 }
1459
1460 SET(d->win,MUIA_Window_Open,TRUE);
1461 DoMethod(d->stopObject,MUIM_Notify, MUIA_Pressed, FALSE, d->stopObject, 3, MUIM_WriteLong, 1 ,&d->stopflag);
1462 back = TRUE;
1463 }
1464 return back;
1465 }
1466
1467 void wanderer_menufunc_icon_delete(void)
1468 {
1469 Object *window = (Object *) XGET(_WandererIntern_AppObj, MUIA_Wanderer_ActiveWindow);
1470 Object *iconList = (Object *) XGET(window, MUIA_IconWindow_IconList);
1471 struct IconList_Entry *entry = ( void*) MUIV_IconList_NextSelected_Start;
1472 DoMethod(iconList, MUIM_IconList_NextSelected, (IPTR) &entry);
1473
1474 struct MUIDisplayObjects dobjects;
1475 struct Hook displayCopyHook;
1476 struct Hook displayDelHook;
1477 displayCopyHook.h_Entry = (HOOKFUNC) Wanderer__HookFunc_DisplayCopyFunc;
1478 displayDelHook.h_Entry = (HOOKFUNC) Wanderer__HookFunc_AskDeleteFunc;
1479
1480 ULONG updatedIcons = 0;
1481
1482 /* Process all selected entries */
1483 if (CreateCopyDisplay(ACTION_DELETE, &dobjects))
1484 {
1485 do
1486 {
1487 if ((int)entry != MUIV_IconList_NextSelected_End)
1488 {
1489 /* copy via filesystems.c */
1490 D(bug("[WANDERER] Delete \"%s\"\n", entry->filename);)
1491 CopyContent( NULL, entry->filename, NULL, TRUE, ACTION_DELETE, &displayCopyHook, &displayDelHook, (APTR) &dobjects);
1492 updatedIcons++;
1493 }
1494 DoMethod(iconList, MUIM_IconList_NextSelected, (IPTR) &entry);
1495 }
1496 while ( (int)entry != MUIV_IconList_NextSelected_End );
1497 DisposeCopyDisplay(&dobjects);
1498 }
1499 // Only update list if anything happened to the icons!
1500 if ( updatedIcons > 0 )
1501 {
1502 DoMethod(window, MUIM_IconWindow_UnselectAll);
1503 DoMethod ( iconList, MUIM_IconList_Update );
1504 }
1505 }
1506
1507 void wanderer_menufunc_wanderer_guisettings(void)
1508 {
1509 //DoMethod(_WandererIntern_AppObj, MUIM_Application_OpenConfigWindow);
1510 OpenWorkbenchObject("SYS:Prefs/Zune",
1511 WBOPENA_ArgName, (IPTR) "WANDERER",
1512 TAG_DONE);
1513 }
1514
1515 void wanderer_menufunc_wanderer_about(void)
1516 {
1517 OpenWorkbenchObject("SYS:System/About", TAG_DONE);
1518 }
1519
1520 void wanderer_menufunc_wanderer_quit(void)
1521 {
1522 if (OpenWorkbenchObject("WANDERER:Tools/Quit", TAG_DONE))
1523 ;
1524 else
1525 {
1526 if (MUI_RequestA(_WandererIntern_AppObj, NULL, 0, "Wanderer", _(MSG_YESNO), _(MSG_REALLYQUIT), NULL))
1527 DoMethod(_WandererIntern_AppObj, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
1528
1529 }
1530 }
1531
1532 /**************************************************************************
1533 This function returns a Menu Object with the given id
1534 **************************************************************************/
1535 Object *FindMenuitem(Object* strip, int id)
1536 {
1537 return (Object*)DoMethod(strip, MUIM_FindUData, id);
1538 }
1539
1540 /**************************************************************************
1541 This connects a notify to the given menu entry id
1542 **************************************************************************/
1543 VOID DoMenuNotify(Object* strip, int id, void *function, void *arg)
1544 {
1545 Object *entry;
1546 entry = FindMenuitem(strip,id);
1547 if (entry)
1548 {
1549 DoMethod
1550 (
1551 entry, MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime,
1552 (IPTR) entry, 4, MUIM_CallHook, (IPTR) &_WandererIntern_hook_standard,
1553 (IPTR) function, (IPTR) arg
1554 );
1555 }
1556 }
1557
1558 VOID DoAllMenuNotifies(Object *strip, STRPTR path)
1559 {
1560 Object *item;
1561
1562 if (!strip) return;
1563
1564 DoMenuNotify(strip, MEN_WANDERER_EXECUTE, wanderer_menufunc_wanderer_execute, path);
1565 DoMenuNotify(strip, MEN_WANDERER_SHELL, wanderer_menufunc_wanderer_shell, path);
1566 DoMenuNotify(strip, MEN_WANDERER_GUISETTINGS, wanderer_menufunc_wanderer_guisettings, NULL);
1567 DoMenuNotify(strip, MEN_WANDERER_ABOUT, wanderer_menufunc_wanderer_about, NULL);
1568 DoMenuNotify(strip, MEN_WANDERER_QUIT, wanderer_menufunc_wanderer_quit, NULL);
1569
1570 DoMenuNotify(strip, MEN_WINDOW_NEW_DRAWER, wanderer_menufunc_window_newdrawer, path);
1571 DoMenuNotify(strip, MEN_WINDOW_OPEN_PARENT, wanderer_menufunc_window_openparent, path);
1572 DoMenuNotify(strip, MEN_WINDOW_CLOSE, wanderer_menufunc_window_close, NULL);
1573 DoMenuNotify(strip, MEN_WINDOW_UPDATE, wanderer_menufunc_window_update, NULL);
1574 DoMenuNotify(strip, MEN_WINDOW_CLEAR, wanderer_menufunc_window_clear, NULL);
1575 DoMenuNotify(strip, MEN_WINDOW_SELECT, wanderer_menufunc_window_select, NULL);
1576 DoMenuNotify(strip, MEN_WINDOW_VIEW_ALL, wanderer_menufunc_window_view_icons, strip);
1577 DoMenuNotify(strip, MEN_WINDOW_SORT_NAME, wanderer_menufunc_window_sort_name, strip);
1578 DoMenuNotify(strip, MEN_WINDOW_SORT_TYPE, wanderer_menufunc_window_sort_type, strip);
1579 DoMenuNotify(strip, MEN_WINDOW_SORT_DATE, wanderer_menufunc_window_sort_date, strip);
1580 DoMenuNotify(strip, MEN_WINDOW_SORT_SIZE, wanderer_menufunc_window_sort_size, strip);
1581 DoMenuNotify(strip, MEN_WINDOW_SORT_REVERSE, wanderer_menufunc_window_sort_reverse, strip);
1582 DoMenuNotify(strip, MEN_WINDOW_SORT_TOPDRAWERS, wanderer_menufunc_window_sort_topdrawers, strip);
1583
1584 DoMenuNotify(strip, MEN_ICON_OPEN, wanderer_menufunc_icon_open, NULL);
1585 DoMenuNotify(strip, MEN_ICON_RENAME, wanderer_menufunc_icon_rename, NULL);
1586 DoMenuNotify(strip, MEN_ICON_INFORMATION, wanderer_menufunc_icon_information, NULL);
1587 DoMenuNotify(strip, MEN_ICON_DELETE, wanderer_menufunc_icon_delete, NULL);
1588
1589 if ((item = FindMenuitem(strip, MEN_WANDERER_BACKDROP)))
1590 {
1591 DoMethod
1592 (
1593 item, MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime,
1594 (IPTR) _WandererIntern_AppObj, 7, MUIM_Application_PushMethod,
1595 (IPTR) _WandererIntern_AppObj, 4, MUIM_CallHook, (IPTR) &_WandererIntern_hook_standard,
1596 (IPTR) wanderer_menufunc_wanderer_backdrop, (IPTR) strip
1597 );
1598 }
1599 }
1600
1601 /*** Methods ****************************************************************/
1602 Object *Wanderer__OM_NEW(Class *CLASS, Object *self, struct opSet *message)
1603 {
1604 D(bug("[Wanderer] Wanderer__OM_NEW()\n"));
1605
1606 self = (Object *) DoSuperNewTags
1607 (
1608 CLASS, self, NULL,
1609
1610 MUIA_Application_Title, (IPTR) "Wanderer",
1611 MUIA_Application_Base, (IPTR) "WANDERER",
1612 MUIA_Application_Version, (IPTR) VERSION,
1613 MUIA_Application_Description, (IPTR) _(MSG_DESCRIPTION),
1614 MUIA_Application_SingleTask, TRUE,
1615
1616 TAG_MORE, (IPTR) message->ops_AttrList
1617 );
1618
1619 if (self != NULL)
1620 {
1621 SETUP_WANDERER_INST_DATA;
1622
1623 D(bug("[Wanderer] Wanderer__OM_NEW: SELF = %d, Private data @ %x\n", self, data));
1624
1625 _WandererIntern_CLASS = CLASS;
1626
1627 #if defined(WANDERER_DEFAULT_BACKDROP)
1628 data->wd_Option_BackDropMode = TRUE;
1629 #else
1630 data->wd_Option_BackDropMode = FALSE;
1631 #endif
1632
1633 /*-- Setup hooks structures ----------------------------------------*/
1634 _WandererIntern_hook_standard.h_Entry = (HOOKFUNC) Wanderer__HookFunc_StandardFunc;
1635 _WandererIntern_hook_action.h_Entry = (HOOKFUNC) Wanderer__HookFunc_ActionFunc;
1636 _WandererIntern_hook_backdrop.h_Entry = (HOOKFUNC) Wanderer__HookFunc_BackdropFunc;
1637
1638 // ---
1639 if ((data->wd_CommandPort = CreateMsgPort()) == NULL)
1640 {
1641 CoerceMethod(CLASS, self, OM_DISPOSE);
1642 return NULL;
1643 }
1644
1645 if ((data->wd_NotifyPort = CreateMsgPort()) == NULL)
1646 {
1647 CoerceMethod(CLASS, self, OM_DISPOSE);
1648 return NULL;
1649 }
1650
1651 RegisterWorkbench(data->wd_CommandPort);
1652
1653 /* Setup command port handler --------------------------------------*/
1654 data->wd_CommandIHN.ihn_Signals = 1UL << data->wd_CommandPort->mp_SigBit;
1655 data->wd_CommandIHN.ihn_Object = self;
1656 data->wd_CommandIHN.ihn_Method = MUIM_Wanderer_HandleCommand;
1657
1658 DoMethod
1659 (
1660 self, MUIM_Application_AddInputHandler, (IPTR) &data->wd_CommandIHN
1661 );
1662
1663 /* Setup timer handler ---------------------------------------------*/
1664 data->wd_TimerIHN.ihn_Flags = MUIIHNF_TIMER;
1665 data->wd_TimerIHN.ihn_Millis = 3000;
1666 data->wd_TimerIHN.ihn_Object = self;
1667 data->wd_TimerIHN.ihn_Method = MUIM_Wanderer_HandleTimer;
1668
1669 DoMethod
1670 (
1671 self, MUIM_Application_AddInputHandler, (IPTR) &data->wd_TimerIHN
1672 );
1673
1674 /* Setup filesystem notification handler ---------------------------*/
1675 data->wd_NotifyIHN.ihn_Signals = 1UL << data->wd_NotifyPort->mp_SigBit;
1676 data->wd_NotifyIHN.ihn_Object = self;
1677 data->wd_NotifyIHN.ihn_Method = MUIM_Wanderer_HandleNotify;
1678
1679 DoMethod
1680 (
1681 self, MUIM_Application_AddInputHandler, (IPTR) &data->wd_NotifyIHN
1682 );
1683
1684 // All the following should be moved to InitWandererPrefs
1685
1686 /* Setup notification on prefs file --------------------------------*/
1687 data->pnr.nr_Name = ExpandEnvName("ENV:SYS/Wanderer.prefs");
1688 data->pnr.nr_Flags = NRF_SEND_MESSAGE;
1689 data->pnr.nr_stuff.nr_Msg.nr_Port = data->wd_NotifyPort;
1690
1691 if (StartNotify(&data->pnr))
1692 {
1693 D(bug("[Wanderer] Wanderer__OM_NEW: Prefs-notification setup on '%s'\n", data->pnr.nr_Name));
1694 }
1695 else
1696 {
1697 D(bug("[Wanderer] Wanderer__OM_NEW: FAILED to setup Prefs-notification!\n"));
1698 }
1699
1700 data->wd_Prefs = WandererPrefsObject, End; // FIXME: error handling
1701
1702 D(bug("[Wanderer] Wanderer__OM_NEW: Prefs-SCREENTITLE IS = '%s'\n",XGET(data->wd_Prefs, MUIA_IconWindowExt_ScreenTitle_String)));
1703
1704 if (data->wd_Prefs)
1705 data->wd_PrefsIntern = InitWandererPrefs();
1706 }
1707
1708 return self;
1709 }
1710
1711 IPTR Wanderer__OM_DISPOSE(Class *CLASS, Object *self, Msg message)
1712 {
1713 SETUP_WANDERER_INST_DATA;
1714
1715 if (data->wd_CommandPort)
1716 {
1717 /*
1718 They only have been added if the creation of the msg port was
1719 successful
1720 */
1721 DoMethod(self, MUIM_Application_RemInputHandler, (IPTR) &data->wd_TimerIHN);
1722 DoMethod(self, MUIM_Application_RemInputHandler, (IPTR) &data->wd_CommandIHN);
1723 DoMethod(self, MUIM_Application_RemInputHandler, (IPTR) &data->wd_NotifyIHN);
1724
1725 UnregisterWorkbench(data->wd_CommandPort);
1726
1727 EndNotify(&data->pnr);
1728
1729 DeleteMsgPort(data->wd_NotifyPort);
1730 data->wd_NotifyPort = NULL;
1731
1732 DeleteMsgPort(data->wd_CommandPort);
1733 data->wd_CommandPort = NULL;
1734
1735 DisposeObject(data->wd_Prefs);
1736 data->wd_Prefs = NULL;
1737 }
1738
1739 return DoSuperMethodA(CLASS, self, (Msg) message);
1740 }
1741
1742 IPTR Wanderer__OM_SET(Class *CLASS, Object *self, struct opSet *message)
1743 {
1744 SETUP_WANDERER_INST_DATA;
1745 struct TagItem *tstate = message->ops_AttrList, *tag;
1746
1747 while ((tag = NextTagItem((const struct TagItem**)&tstate)) != NULL)
1748 {
1749 switch (tag->ti_Tag)
1750 {
1751 case MUIA_Wanderer_Screen:
1752 D(bug("[Wanderer] Wanderer__OM_SET: MUIA_Wanderer_Screen = %p\n", tag->ti_Data));
1753 D(bug("[Wanderer] Wanderer__OM_SET: setting MUIA_Wanderer_Screen isnt yet handled!\n"));
1754 break;
1755
1756 case MUIA_Wanderer_ActiveWindow:
1757 data->wd_ActiveWindow = (Object *) tag->ti_Data;
1758 D(bug("[Wanderer] Wanderer__OM_SET: MUIA_Wanderer_ActiveWindow = %p\n", tag->ti_Data));
1759 if (!(XGET(data->wd_ActiveWindow, MUIA_Window_Activate)))
1760 NNSET(data->wd_ActiveWindow, MUIA_Window_Activate, TRUE);
1761
1762 break;
1763
1764 case MUIA_Application_Iconified:
1765 /* Wanderer itself cannot be iconified,
1766 just hide, instead. */
1767 tag->ti_Tag = MUIA_ShowMe;
1768 tag->ti_Data = !tag->ti_Data;
1769 break;
1770 }
1771 }
1772
1773 return DoSuperMethodA(CLASS, self, (Msg) message);
1774 }
1775
1776 IPTR Wanderer__OM_GET(Class *CLASS, Object *self, struct opGet *message)
1777 {
1778 SETUP_WANDERER_INST_DATA;
1779 IPTR *store = message->opg_Storage;
1780 IPTR rv = TRUE;
1781
1782 switch (message->opg_AttrID)
1783 {
1784 case MUIA_Wanderer_Screen:
1785 *store = (IPTR) data->wd_Screen;
1786 break;
1787
1788 case MUIA_Wanderer_Prefs:
1789 *store = (IPTR) data->wd_Prefs;
1790 break;
1791
1792 case MUIA_Wanderer_ActiveWindow:
1793 *store = (IPTR) data->wd_ActiveWindow;
1794 break;
1795
1796 case MUIA_Wanderer_WorkbenchWindow:
1797 *store = (IPTR) data->wd_WorkbenchWindow;
1798 break;
1799
1800 default:
1801 rv = DoSuperMethodA(CLASS, self, (Msg) message);
1802 }
1803
1804 return rv;
1805 }
1806
1807 /* Main entry point for Wanderer Application Object */
1808 /*
1809 When the executable creates our object it calls zune
1810 to handle basic "control" ... which results in Zune
1811 calling this method ..
1812 */
1813 IPTR Wanderer__MUIM_Application_Execute
1814 (
1815 Class *CLASS, Object *self, Msg message
1816 )
1817 {
1818 SETUP_WANDERER_INST_DATA;
1819
1820 D(bug("[Wanderer] Wanderer__MUIM_Application_Execute() ##\n[Wanderer] Wanderer__MUIM_Application_Execute: Creating 'Workbench' Window..\n"));
1821
1822 data->wd_WorkbenchWindow = (Object *) DoMethod
1823 (
1824 self, MUIM_Wanderer_CreateDrawerWindow, (IPTR) NULL
1825 );
1826
1827 if (data->wd_WorkbenchWindow != NULL)
1828 {
1829 D(bug("[Wanderer] Wanderer__MUIM_Application_Execute: Workbench Window Obj @ %x\n", data->wd_WorkbenchWindow));
1830
1831 Detach();
1832
1833 D(bug("[Wanderer] Wanderer__MUIM_Application_Execute: Really handing control to Zune ..\n"));
1834
1835 DoSuperMethodA(CLASS, self, message);
1836
1837 return RETURN_OK;
1838 }
1839
1840 #warning "TODO: Report an error if we fail to create the Workbench's window ..."
1841
1842 return RETURN_ERROR;
1843 }
1844
1845 /*This function uses GetScreenTitle() function...*/
1846
1847 IPTR Wanderer__MUIM_Wanderer_HandleTimer
1848 (
1849 Class *CLASS, Object *self, Msg message
1850 )
1851 {
1852 SETUP_WANDERER_INST_DATA;
1853 Object *cstate = (Object*)(((struct List*)XGET(self, MUIA_Application_WindowList))->lh_Head);
1854 Object *child = NULL;
1855
1856 STRPTR scr_title = GetUserScreenTitle(data->wd_Prefs);
1857
1858 while ((child = NextObject(&cstate)))
1859 SET(child, MUIA_Window_ScreenTitle, (IPTR) scr_title);
1860
1861 return TRUE;
1862 }
1863
1864
1865 IPTR Wanderer__MUIM_Wanderer_HandleCommand
1866 (
1867 Class *CLASS, Object *self, Msg message
1868 )
1869 {
1870 SETUP_WANDERER_INST_DATA;
1871 struct WBHandlerMessage *wbhm = NULL;
1872
1873 D(bug("[Wanderer] Recieved signal at notify port\n"));
1874
1875 while ((wbhm = WBHM(GetMsg(data->wd_CommandPort))) != NULL)
1876 {
1877 D(bug("[Wanderer] Recieved message from handler, type = %ld\n", wbhm->wbhm_Type));
1878
1879 switch (wbhm->wbhm_Type)
1880 {
1881 case WBHM_TYPE_SHOW:
1882 D(bug("[Wanderer] WBHM_TYPE_SHOW\n"));
1883 SET(self, MUIA_ShowMe, TRUE);
1884 break;
1885
1886 case WBHM_TYPE_HIDE:
1887 D(bug("[Wanderer] WBHM_TYPE_HIDE\n"));
1888 SET(self, MUIA_ShowMe, FALSE);
1889 break;
1890
1891 case WBHM_TYPE_UPDATE:
1892 D(bug("[Wanderer] WBHM_TYPE_UPDATE\n"));
1893 {
1894 CONST_STRPTR name = wbhm->wbhm_Data.Update.Name;
1895 ULONG length;
1896
1897 switch (wbhm->wbhm_Data.Update.Type)
1898 {
1899 case WBDISK:
1900 case WBDRAWER:
1901 case WBGARBAGE:
1902 length = strlen(name);
1903 break;
1904
1905 default:
1906 length = PathPart(name) - name;
1907 break;
1908 }
1909
1910 D(bug("[Wanderer] name = %s, length = %ld\n", name, length));
1911
1912 {
1913 Object *cstate = (Object*)(((struct List*)XGET(self, MUIA_Application_WindowList))->lh_Head);
1914 Object *child = NULL;
1915
1916 while ((child = NextObject(&cstate)))
1917 {
1918 if (XGET(child, MUIA_UserData))
1919 {
1920 STRPTR child_drawer = (STRPTR)XGET(child, MUIA_IconWindow_Location);
1921
1922 if
1923 (
1924 child_drawer != NULL
1925 && strncmp(name, child_drawer, length) == 0
1926 && strlen(child_drawer) == length
1927 )
1928 {
1929 Object *iconlist = (Object *) XGET(child, MUIA_IconWindow_IconList);
1930
1931 D(bug("[Wanderer] Drawer found: %s!\n", child_drawer));
1932
1933 if (iconlist != NULL)
1934 {
1935 DoMethod ( iconlist, MUIM_IconList_Update );
1936 }
1937 break;
1938 }
1939 }
1940 }
1941 }
1942 }
1943 break;
1944
1945 case WBHM_TYPE_OPEN:
1946 D(bug("[Wanderer] WBHM_TYPE_OPEN\n"));
1947
1948 {
1949 Object *cstate = (Object*)(((struct List*)XGET(self, MUIA_Application_WindowList))->lh_Head);
1950 Object *child;
1951 CONST_STRPTR buf = wbhm->wbhm_Data.Open.Name;
1952
1953 while ((child = NextObject(&cstate)))
1954 {
1955 if (XGET(child, MUIA_UserData))
1956 {
1957 STRPTR child_drawer = (STRPTR)XGET(child, MUIA_IconWindow_Location);
1958 if (child_drawer && !Stricmp(buf,child_drawer))
1959 {
1960 int is_open = XGET(child, MUIA_Window_Open);
1961 if (!is_open)
1962 DoMethod(child, MUIM_IconWindow_Open);
1963 else
1964 {
1965 DoMethod(child, MUIM_Window_ToFront);
1966 SET(child, MUIA_Window_Activate, TRUE);
1967 }
1968 return 0;
1969 }
1970 }
1971 }
1972
1973 DoMethod
1974 (
1975 _WandererIntern_AppObj, MUIM_Wanderer_CreateDrawerWindow, (IPTR) buf
1976 );
1977 }
1978 break;
1979 } /* switch */
1980
1981 ReplyMsg((struct Message *) wbhm);
1982 }
1983
1984 return 0;
1985 }
1986
1987
1988 IPTR Wanderer__MUIM_Wanderer_HandleNotify
1989 (
1990 Class *CLASS, Object *self, Msg message
1991 )
1992 {
1993 SETUP_WANDERER_INST_DATA;
1994 struct Message *notifyMessage = NULL;
1995
1996 D(bug("[Wanderer] Wanderer__MUIM_Wanderer_HandleNotify: got prefs change notification!\n"));
1997
1998 while ((notifyMessage = GetMsg(data->wd_NotifyPort)) != NULL)
1999 {
2000 ReplyMsg(notifyMessage);
2001 }
2002
2003 /* reload prefs file */
2004 DoMethod(data->wd_Prefs, MUIM_WandererPrefs_Reload);
2005
2006 return 0;
2007 }
2008
2009 /* Some differences here between volumes and subwindows */
2010 Object * __CreateWandererIntuitionMenu__ ( BOOL isRoot, BOOL isBackdrop)
2011 {
2012 Object *_NewWandIntMenu__menustrip = NULL;
2013 IPTR _NewWandIntMenu__OPTION_BACKDROP = CHECKIT|MENUTOGGLE;
2014 IPTR _NewWandIntMenu__OPTION_SHOWALL = CHECKIT|MENUTOGGLE;
2015
2016 if (isBackdrop)
2017 {
2018 _NewWandIntMenu__OPTION_BACKDROP |= CHECKED;
2019 }
2020
2021 #if defined(WANDERER_DEFAULT_SHOWALL)
2022 _NewWandIntMenu__OPTION_SHOWALL |= CHECKED;
2023 #endif
2024
2025 if ( isRoot )
2026 {
2027 struct NewMenu nm[] = {
2028 {NM_TITLE, _(MSG_MEN_WANDERER)},
2029 {NM_ITEM, _(MSG_MEN_BACKDROP),_(MSG_MEN_SC_BACKDROP), _NewWandIntMenu__OPTION_BACKDROP, 0, (APTR) MEN_WANDERER_BACKDROP},
2030 {NM_ITEM, _(MSG_MEN_EXECUTE), _(MSG_MEN_SC_EXECUTE) , 0 , 0, (APTR) MEN_WANDERER_EXECUTE},
2031
2032 {NM_ITEM, _(MSG_MEN_SHELL), _(MSG_MEN_SC_SHELL) , 0 , 0, (APTR) MEN_WANDERER_SHELL},
2033 {NM_ITEM, _(MSG_MEN_GUISET), NULL , 0 , 0, (APTR) MEN_WANDERER_GUISETTINGS},
2034 {NM_ITEM, _(MSG_MEN_ABOUT), _(MSG_MEN_SC_ABOUT) , 0 , 0, (APTR) MEN_WANDERER_ABOUT},
2035 {NM_ITEM, _(MSG_MEN_QUIT) , _(MSG_MEN_SC_QUIT) , 0 , 0, (APTR) MEN_WANDERER_QUIT},
2036
2037 {NM_TITLE, _(MSG_MEN_WINDOW), NULL, 0},
2038
2039 {NM_ITEM, _(MSG_MEN_UPDATE), NULL , 0 , 0, (APTR) MEN_WINDOW_UPDATE},
2040 {NM_ITEM, NM_BARLABEL},
2041 {NM_ITEM, _(MSG_MEN_CONTENTS), _(MSG_MEN_SC_CONTENTS), 0 , 0, (APTR) MEN_WINDOW_SELECT},
2042 {NM_ITEM, _(MSG_MEN_CLRSEL), _(MSG_MEN_SC_CLRSEL) , 0 , 0, (APTR) MEN_WINDOW_CLEAR},
2043 {NM_ITEM, NM_BARLABEL},
2044 {NM_ITEM, _(MSG_MEN_SNAPSHT) },
2045 {NM_SUB, _(MSG_MEN_WINDOW), NULL , 0 , 0, (APTR) MEN_WINDOW_SNAP_WIN},
2046 {NM_SUB, _(MSG_MEN_ALL), NULL , 0 , 0, (APTR) MEN_WINDOW_SNAP_ALL},
2047 {NM_ITEM, NM_BARLABEL},
2048 {NM_ITEM, _(MSG_MEN_VIEW)},
2049 {NM_SUB, _(MSG_MEN_ICVIEW), NULL , CHECKIT|CHECKED ,8+16+32, (APTR) MEN_WINDOW_VIEW_ICON},
2050 {NM_SUB, _(MSG_MEN_DCVIEW), NULL , CHECKIT ,4+16+32, (APTR) MEN_WINDOW_VIEW_DETAIL},
2051 {NM_SUB, NM_BARLABEL},
2052 {NM_SUB, _(MSG_MEN_ALLFIL), NULL , _NewWandIntMenu__OPTION_SHOWALL, 0, (APTR) MEN_WINDOW_VIEW_ALL},
2053 {NM_ITEM, _(MSG_MEN_SORTIC)},
2054 {NM_SUB, _(MSG_MEN_CLNUP), _(MSG_MEN_SC_CLNUP) , 0 , 0, (APTR) MEN_WINDOW_SORT_NOW},
2055 {NM_SUB, NM_BARLABEL},
2056 {NM_SUB, _(MSG_MEN_BYNAME), NULL , CHECKIT|CHECKED ,8+16+32, (APTR) MEN_WINDOW_SORT_NAME},
2057 {NM_SUB, _(MSG_MEN_BYDATE), NULL , CHECKIT ,4+16+32, (APTR) MEN_WINDOW_SORT_DATE},
2058 {NM_SUB, _(MSG_MEN_BYSIZE), NULL , CHECKIT ,4+8+32, (APTR) MEN_WINDOW_SORT_SIZE},
2059 //{NM_SUB, "..by Type", NULL, CHECKIT,4+8+16, (APTR) MEN_WINDOW_SORT_TYPE},
2060 {NM_SUB, NM_BARLABEL},
2061 {NM_SUB, _(MSG_MEN_REVERSE), NULL , CHECKIT|MENUTOGGLE , 0, (APTR) MEN_WINDOW_SORT_REVERSE},
2062 {NM_SUB, _(MSG_MEN_DRWFRST), NULL , CHECKIT|MENUTOGGLE|CHECKED, 0, (APTR) MEN_WINDOW_SORT_TOPDRAWERS},
2063 //{NM_SUB, "Group Icons", NULL, CHECKIT|MENUTOGGLE|CHECKED, 0, (APTR) MEN_WINDOW_SORT_GROUP},
2064
2065 {NM_TITLE, _(MSG_MEN_ICON), NULL, 0},
2066 {NM_ITEM, _(MSG_MEN_OPEN), _(MSG_MEN_SC_OPEN), 0, 0, (APTR) MEN_ICON_OPEN},
2067 // {NM_ITEM, "Close","C" },
2068 {NM_ITEM, _(MSG_MEN_RENAME), _(MSG_MEN_SC_RENAME), 0, 0, (APTR) MEN_ICON_RENAME},
2069 {NM_ITEM, _(MSG_MEN_INFO), _(MSG_MEN_SC_INFO), 0, 0, (APTR) MEN_ICON_INFORMATION},
2070 // {NM_ITEM, "Snapshot", "S" },
2071 // {NM_ITEM, "Unsnapshot", "U" },
2072 // {NM_ITEM, "Leave Out", "L" },
2073 // {NM_ITEM, "Put Away", "P" },
2074 {NM_ITEM, NM_BARLABEL},
2075 {NM_ITEM, _(MSG_MEN_DELETE), NULL, 0, 0, (APTR) MEN_ICON_DELETE},
2076 // {NM_ITEM, "Format Disk..." },
2077 // {NM_ITEM, "Empty Trash..." },
2078
2079 {NM_TITLE, _(MSG_MEN_TOOLS), NULL, 0},
2080 // {NM_ITEM, "ResetWanderer" },
2081 {NM_END}
2082 };
2083 _NewWandIntMenu__menustrip = MUI_MakeObject(MUIO_MenustripNM, nm, (IPTR) NULL);
2084 }
2085 else
2086 {
2087 struct NewMenu nm[] = {
2088 {NM_TITLE, _(MSG_MEN_WANDERER)},
2089 {NM_ITEM, _(MSG_MEN_BACKDROP),_(MSG_MEN_SC_BACKDROP), _NewWandIntMenu__OPTION_BACKDROP, 0, (APTR) MEN_WANDERER_BACKDROP},
2090 {NM_ITEM, _(MSG_MEN_EXECUTE), _(MSG_MEN_SC_EXECUTE) , 0 , 0, (APTR) MEN_WANDERER_EXECUTE},
2091
2092 {NM_ITEM, _(MSG_MEN_SHELL), _(MSG_MEN_SC_SHELL) , 0 , 0, (APTR) MEN_WANDERER_SHELL},
2093 {NM_ITEM, _(MSG_MEN_GUISET), NULL , 0 , 0, (APTR) MEN_WANDERER_GUISETTINGS},
2094 {NM_ITEM, _(MSG_MEN_ABOUT), _(MSG_MEN_SC_ABOUT) , 0 , 0, (APTR) MEN_WANDERER_ABOUT},
2095 {NM_ITEM, _(MSG_MEN_QUIT) , _(MSG_MEN_SC_QUIT) , 0 , 0, (APTR) MEN_WANDERER_QUIT},
2096
2097 {NM_TITLE, _(MSG_MEN_WINDOW), NULL, 0},
2098
2099 {NM_ITEM, _(MSG_MEN_NEWDRAW), _(MSG_MEN_SC_NEWDRAW) , 0 , 0, (APTR) MEN_WINDOW_NEW_DRAWER},
2100 {NM_ITEM, _(MSG_MEN_OPENPAR), NULL , 0 , 0, (APTR) MEN_WINDOW_OPEN_PARENT},
2101 {NM_ITEM, _(MSG_MEN_CLOSE), _(MSG_MEN_SC_CLOSE) , 0 , 0, (APTR) MEN_WINDOW_CLOSE},
2102 {NM_ITEM, _(MSG_MEN_UPDATE), NULL , 0 , 0, (APTR) MEN_WINDOW_UPDATE},
2103 {NM_ITEM, NM_BARLABEL},
2104 {NM_ITEM, _(MSG_MEN_CONTENTS), _(MSG_MEN_SC_CONTENTS), 0 , 0, (APTR) MEN_WINDOW_SELECT},
2105 {NM_ITEM, _(MSG_MEN_CLRSEL), _(MSG_MEN_SC_CLRSEL) , 0 , 0, (APTR) MEN_WINDOW_CLEAR},
2106 {NM_ITEM, NM_BARLABEL},
2107 {NM_ITEM, _(MSG_MEN_SNAPSHT) },
2108 {NM_SUB, _(MSG_MEN_WINDOW), NULL , 0 , 0, (APTR) MEN_WINDOW_SNAP_WIN},
2109 {NM_SUB, _(MSG_MEN_ALL), NULL , 0 , 0, (APTR) MEN_WINDOW_SNAP_ALL},
2110 {NM_ITEM, NM_BARLABEL},
2111 {NM_ITEM, _(MSG_MEN_VIEW)},
2112 {NM_SUB, _(MSG_MEN_ICVIEW), NULL , CHECKIT|CHECKED ,8+16+32, (APTR) MEN_WINDOW_VIEW_ICON},
2113 {NM_SUB, _(MSG_MEN_DCVIEW), NULL , CHECKIT ,4+16+32, (APTR) MEN_WINDOW_VIEW_DETAIL},
2114 {NM_SUB, NM_BARLABEL},
2115 {NM_SUB, _(MSG_MEN_ALLFIL), NULL , _NewWandIntMenu__OPTION_SHOWALL, 0, (APTR) MEN_WINDOW_VIEW_ALL},
2116 {NM_ITEM, _(MSG_MEN_SORTIC)},
2117 {NM_SUB, _(MSG_MEN_CLNUP), _(MSG_MEN_SC_CLNUP) , 0 , 0, (APTR) MEN_WINDOW_SORT_NOW},
2118 {NM_SUB, NM_BARLABEL},
2119 {NM_SUB, _(MSG_MEN_BYNAME), NULL , CHECKIT|CHECKED ,8+16+32, (APTR) MEN_WINDOW_SORT_NAME},
2120 {NM_SUB, _(MSG_MEN_BYDATE), NULL , CHECKIT ,4+16+32, (APTR) MEN_WINDOW_SORT_DATE},
2121 {NM_SUB, _(MSG_MEN_BYSIZE), NULL , CHECKIT ,4+8+32, (APTR) MEN_WINDOW_SORT_SIZE},
2122 //{NM_SUB, "..by Type", NULL, CHECKIT,4+8+16, (APTR) MEN_WINDOW_SORT_TYPE},
2123 {NM_SUB, NM_BARLABEL},
2124 {NM_SUB, _(MSG_MEN_REVERSE), NULL , CHECKIT|MENUTOGGLE , 0, (APTR) MEN_WINDOW_SORT_REVERSE},
2125 {NM_SUB, _(MSG_MEN_DRWFRST), NULL , CHECKIT|MENUTOGGLE|CHECKED, 0, (APTR) MEN_WINDOW_SORT_TOPDRAWERS},
2126 //{NM_SUB, "Group Icons", NULL, CHECKIT|MENUTOGGLE|CHECKED, 0, (APTR) MEN_WINDOW_SORT_GROUP},
2127
2128 {NM_TITLE, _(MSG_MEN_ICON), NULL, 0},
2129 {NM_ITEM, _(MSG_MEN_OPEN), _(MSG_MEN_SC_OPEN), 0, 0, (APTR) MEN_ICON_OPEN},
2130 // {NM_ITEM, "Close","C" },
2131 {NM_ITEM, _(MSG_MEN_RENAME), _(MSG_MEN_SC_RENAME), 0, 0, (APTR) MEN_ICON_RENAME},
2132 {NM_ITEM, _(MSG_MEN_INFO), _(MSG_MEN_SC_INFO), 0, 0, (APTR) MEN_ICON_INFORMATION},
2133 // {NM_ITEM, "Snapshot", "S" },
2134 // {NM_ITEM, "Unsnapshot", "U" },
2135 // {NM_ITEM, "Leave Out", "L" },
2136 // {NM_ITEM, "Put Away", "P" },
2137 {NM_ITEM, NM_BARLABEL},
2138 {NM_ITEM, _(MSG_MEN_DELETE), NULL, 0, 0, (APTR) MEN_ICON_DELETE},
2139 // {NM_ITEM, "Format Disk..." },
2140 // {NM_ITEM, "Empty Trash..." },
2141
2142 {NM_TITLE, _(MSG_MEN_TOOLS), NULL, 0},
2143 // {NM_ITEM, "ResetWanderer" },
2144 {NM_END}
2145 };
2146 _NewWandIntMenu__menustrip = MUI_MakeObject(MUIO_MenustripNM, nm, (IPTR) NULL);
2147 }
2148 return _NewWandIntMenu__menustrip;
2149 }
2150
2151 Object *Wanderer__MUIM_Wanderer_CreateDrawerWindow
2152 (
2153 Class *CLASS, Object *self,
2154 struct MUIP_Wanderer_CreateDrawerWindow *message
2155 )
2156 {
2157 SETUP_WANDERER_INST_DATA;
2158
2159 D(bug("[Wanderer] Wanderer__MUIM_Wanderer_CreateDrawerWindow()\n"));
2160
2161 Object *window = NULL;
2162 BOOL isWorkbenchWindow = FALSE;
2163 BOOL useBackdrop = FALSE;
2164
2165 if (isWorkbenchWindow = (message->drawer == NULL ? TRUE : FALSE))
2166 {
2167 useBackdrop = data->wd_Option_BackDropMode;
2168 }
2169
2170 BOOL hasToolbar = XGET(data->wd_Prefs, MUIA_IconWindowExt_Toolbar_Enabled);
2171
2172 IPTR TAG_IconWindow_Drawer = isWorkbenchWindow ? TAG_IGNORE : MUIA_IconWindow_Location;
2173
2174 IPTR useFont = (IPTR)NULL;
2175
2176 data->wd_Screen = LockPubScreen(NULL);
2177 if(data->wd_Screen == NULL)
2178 {
2179 D(bug("[Wanderer] Wanderer__MUIM_Wanderer_CreateDrawerWindow: Couldn't lock screen!\n"));
2180 CoerceMethod(CLASS, self, OM_DISPOSE);
2181 return NULL;
2182 }
2183 D(bug("[Wanderer] Wanderer__MUIM_Wanderer_CreateDrawerWindow: Using Screen @ %x\n", data->wd_Screen));
2184
2185 if (data->wd_PrefsIntern)
2186 {
2187 useFont = (IPTR)((struct WandererInternalPrefsData *)data->wd_PrefsIntern)->WIPD_IconFont;
2188 }
2189
2190 Object *_NewWandDrawerMenu__menustrip = __CreateWandererIntuitionMenu__ (isWorkbenchWindow, useBackdrop);
2191
2192 /* Create a new icon drawer window with the correct drawer being set */
2193 window = IconWindowObject,
2194 MUIA_UserData, 1,
2195 MUIA_Wanderer_Prefs, data->wd_Prefs,
2196 MUIA_Wanderer_Screen, data->wd_Screen,
2197 MUIA_Window_ScreenTitle, GetUserScreenTitle(data->wd_Prefs),
2198 MUIA_Window_Menustrip, (IPTR) _NewWandDrawerMenu__menustrip,
2199 TAG_IconWindow_Drawer, (IPTR) message->drawer,
2200 MUIA_IconWindow_Font, useFont,
2201 MUIA_IconWindow_ActionHook, (IPTR) &_WandererIntern_hook_action,
2202 MUIA_IconWindow_IsRoot, isWorkbenchWindow ? TRUE : FALSE,
2203 isWorkbenchWindow ? MUIA_IconWindow_IsBackdrop : TAG_IGNORE, useBackdrop,
2204 MUIA_Window_IsSubWindow, isWorkbenchWindow ? FALSE : TRUE,
2205 MUIA_IconWindowExt_Toolbar_Enabled, hasToolbar ? TRUE : FALSE,
2206 End;
2207
2208 if (data->wd_Screen)
2209 {
2210 D(bug("[Wanderer] Wanderer__MUIM_Wanderer_CreateDrawerWindow: Unlocking access to screen @ %x\n", data->wd_Screen));
2211 UnlockPubScreen(NULL, data->wd_Screen);
2212 }
2213
2214 if (window != NULL)
2215 {
2216 /* Get the drawer path back so we can use it also outside this function */
2217 STRPTR drw = NULL;
2218 BOOL freeDrwStr = FALSE;
2219
2220 if (!isWorkbenchWindow) drw = (STRPTR) XGET(window, MUIA_IconWindow_Location);
2221 else
2222 {
2223 drw = AllocVec ( 5, MEMF_CLEAR );
2224 sprintf ( drw, "RAM:" );
2225 freeDrwStr = TRUE;
2226 }
2227
2228 if (isWorkbenchWindow)
2229 {
2230 DoMethod
2231 (
2232 window, MUIM_Notify, MUIA_Window_CloseRequest, TRUE,
2233 (IPTR)self, 3, MUIM_CallHook, (IPTR)&_WandererIntern_hook_standard, (IPTR)wanderer_menufunc_wanderer_quit
2234 );
2235 }
2236 else
2237 {
2238 DoMethod
2239 (
2240 window, MUIM_Notify, MUIA_Window_CloseRequest, TRUE,
2241 (IPTR)_app(self), 4, MUIM_Application_PushMethod, (IPTR)window, 1, MUIM_IconWindow_Remove
2242 );
2243 }
2244
2245 #if defined(WANDERER_DEFAULT_SHOWALL) || defined(WANDERER_DEFAULT_SHOWHIDDEN)
2246 Object *window_IconList = NULL;
2247 ULONG current_DispFlags = 0;
2248
2249 GET(window, MUIA_IconWindow_IconList, &window_IconList);
2250
2251 D(bug("[Wanderer] Wanderer__MUIM_Wanderer_CreateDrawerWindow: IconWindows IconList @ %x\n", window_IconList));
2252
2253 if (window_IconList != NULL)
2254 {
2255 GET(window_IconList, MUIA_IconList_DisplayFlags, &current_DispFlags);
2256
2257 D(bug("[Wanderer] Wanderer__MUIM_Wanderer_CreateDrawerWindow: Old Flags : %x\n", current_DispFlags));
2258
2259 #if defined(WANDERER_DEFAULT_SHOWALL)
2260 D(bug("[Wanderer] Wanderer__MUIM_Wanderer_CreateDrawerWindow: Telling IconList to Show 'ALL' Files\n"));
2261 current_DispFlags &= ~ICONLIST_DISP_SHOWINFO;
2262 #endif
2263 #if defined(WANDERER_DEFAULT_SHOWHIDDEN)
2264 D(bug("[Wanderer] Wanderer__MUIM_Wanderer_CreateDrawerWindow: Telling IconList to Show 'Hidden' Files\n"));
2265 current_DispFlags |= ICONLIST_DISP_SHOWHIDDEN;
2266 #endif
2267 D(bug("[Wanderer] Wanderer__MUIM_Wanderer_CreateDrawerWindow: New Flags : %x\n", current_DispFlags));
2268 SET(window_IconList, MUIA_IconList_DisplayFlags, current_DispFlags);
2269 }
2270 #endif
2271
2272 DoMethod
2273 (
2274 window, MUIM_Notify, MUIA_Window_Activate, TRUE,
2275 (IPTR)_app(self), 3, MUIM_Set, MUIA_Wanderer_ActiveWindow, (IPTR) window
2276 );
2277
2278 #if 1
2279 DoMethod
2280 (
2281 window, MUIM_Notify, MUIA_IconWindow_IsBackdrop, MUIV_EveryTime,
2282 (IPTR)_app(self), 5, MUIM_Application_PushMethod, (IPTR)_app(self), 2, MUIM_CallHook, (IPTR)&_WandererIntern_hook_backdrop
2283 );
2284 #else
2285 DoMethod
2286 (
2287 window, MUIM_Notify, MUIA_IconWindow_IsBackdrop, MUIV_EveryTime,
2288 (IPTR)_app(self), 2, MUIM_CallHook, (IPTR) &_WandererIntern_hook_backdrop
2289 );
2290 #endif
2291
2292 /* If "Execute Command" entry is clicked open the execute window */
2293 DoAllMenuNotifies(_NewWandDrawerMenu__menustrip, drw);
2294
2295 /* Add the window to the application */
2296 DoMethod(_app(self), OM_ADDMEMBER, (IPTR) window);
2297
2298 /* And now open it */
2299 DoMethod(window, MUIM_IconWindow_Open);
2300
2301 /* Clean up ram string */
2302 if ( freeDrwStr && drw ) FreeVec ( drw );
2303 }
2304
2305 return window;
2306 }
2307
2308 /*** Setup ******************************************************************/
2309 ZUNE_CUSTOMCLASS_9
2310 (
2311 Wanderer, NULL, MUIC_Application, NULL,
2312 OM_NEW, struct opSet *,
2313 OM_DISPOSE, Msg,
2314 OM_SET, struct opSet *,
2315 OM_GET, struct opGet *,
2316 MUIM_Application_Execute, Msg,
2317 MUIM_Wanderer_HandleTimer, Msg,
2318 MUIM_Wanderer_HandleCommand, Msg,
2319 MUIM_Wanderer_HandleNotify, Msg,
2320 MUIM_Wanderer_CreateDrawerWindow, struct MUIP_Wanderer_CreateDrawerWindow *
2321 );
A totally sweet operating system