?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Initial import of Scalos. To decrease size I have
[AROS-Contrib.git] / scalos / main / MenuCommand.c
blob22ddea295fca227f40058ce965c6d499d2cc0dfb
1 // MenuCommand.c
2 // $Date$
3 // $Revision$
4
5
6 #include <exec/types.h>
7 #include <graphics/gels.h>
8 #include <graphics/rastport.h>
9 #include <intuition/classes.h>
10 #include <intuition/classusr.h>
11 #include <utility/hooks.h>
12 #include <intuition/gadgetclass.h>
13 #include <workbench/workbench.h>
14 #include <workbench/startup.h>
15 #include <libraries/asl.h>
16 #include <cybergraphx/cybergraphics.h>
17 #include <datatypes/pictureclass.h>
18 #include <dos/dos.h>
19 #include <dos/dostags.h>
20 #include <dos/exall.h>
21
22 #define __USE_SYSBASE
23
24 #include <proto/asl.h>
25 #include <proto/dos.h>
26 #include <proto/exec.h>
27 #include <proto/layers.h>
28 #include <proto/graphics.h>
29 #include <proto/intuition.h>
30 #include <proto/iconobject.h>
31 #include <proto/utility.h>
32 #include <proto/icon.h>
33 #include <proto/gadtools.h>
34 #include <proto/datatypes.h>
35 #include <proto/cybergraphics.h>
36 #include <proto/wb.h>
37 #include "debug.h"
38 #include <proto/scalos.h>
39
40 #include <clib/alib_protos.h>
41
42 #include <defs.h>
43 #include <datatypes/iconobject.h>
44 #include <scalos/scalos.h>
45
46 #include <stdlib.h>
47 #include <string.h>
48 #include <stdio.h>
49 #include <stdarg.h>
50 #include <limits.h>
51
52 #include <DefIcons.h>
53
54 #include "scalos_structures.h"
55 #include "FsAbstraction.h"
56 #include "locale.h"
57 #include "functions.h"
58 #include "Variables.h"
59
60 //----------------------------------------------------------------------------
61
62 // local data structures
63
64
65 // extended SM_AsyncRoutine to run xxxProg() asynchronously
66 struct SM_AsyncProg
67 {
68 struct SM_AsyncRoutine sma_Async;
69 struct MenuCmdArg sma_CmdArg;
70 };
71
72 // xxxProg() Function called by ProgTask()
73 typedef void (*PROGFUNC)(struct internalScaWindowTask *, const struct MenuCmdArg *);
74
75 struct SM_StartProg
76 {
77 PROGFUNC spr_ProgFunc;
78
79 struct internalScaWindowTask *spr_WindowTask;
80
81 struct MenuCmdArg spr_Arg;
82 };
83
84 struct CloneArg
85 {
86 struct WBArg *cla_wbArg;
87 ULONG cla_NumArgs; // number of entries in cla_wbArg
88 };
89
90 //----------------------------------------------------------------------------
91
92 // local functions
93
94 static void SizeToFitProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
95 static void WindowPropertiesProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
96 static void SelectContentsProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
97 static void NewDrawerProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
98 static void RenameProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
99 static void MenuInfoProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
100 static void IconPropertiesProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
101 static void BackDropProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
102 static void RedrawAllProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
103 static void ViewByIconProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
104 static void ViewByTextProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
105 static void ViewByDateProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
106 static void ViewBySizeProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
107 static void ViewByTypeProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
108 static void ViewByDefaultProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
109 static void CloneProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
110 static void ThumbnailCacheCleanupProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
111 static void UpdateProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
112 static void CloseProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
113 static void FindProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
114 static void FormatDiskProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
115 static void ShutdownProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
116 static void ShowOnlyIconsProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
117 static void ShowAllFilesProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
118 static void ShowDefaultProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
119 static void CleanupProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
120 static void CleanupByNameProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
121 static void CleanupByDateProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
122 static void CleanupBySizeProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
123 static void CleanupByTypeProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
124 static void MenuOpenProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
125 static void MenuOpenNewProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
126 static void MenuOpenBrowserWindowProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
127 static void OpenParentProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
128 static void ExecuteCmdProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
129 static void LastMessageProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
130 static void IconifyProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
131 static void RedrawProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
132 static void ResetScalosProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
133 static void AsyncResetScalosProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *dummy);
134 static void MenuSnapshotProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
135 static void MenuUnsnapshotProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
136 static void MenuUndoProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
137 static void MenuRedoProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
138 static void SnapshotAllProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
139 static void SnapshotWindowProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
140 static void LeaveOutProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
141 static void PutAwayProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
142 static void EmptyTrashProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
143 static void MenuCopyProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
144 static void MenuCutProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
145 static void MenuPasteProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
146 static void MenuCreateThumbnailProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
147
148 static void AsyncPasteProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
149 static void SnapshotWindow(struct internalScaWindowTask *iwt);
150 static BOOL StartProgTask(struct internalScaWindowTask *iwt,
151 const struct MenuCmdArg *mcArg, PROGFUNC ProgProc, struct MsgPort *ReplyPort);
152 static SAVEDS(ULONG) ProgTask(struct SM_StartProg *sMsg, struct SM_RunProcess *msg);
153 static void AsyncNewDrawerProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
154 static void WBIconPropertiesStart(struct internalScaWindowTask *iwt, struct ScaIconNode *in, APTR undoStep);
155 static SAVEDS(ULONG) IconPropertiesStart(APTR aptr, struct SM_RunProcess *msg);
156 static void AsyncWindowPropertiesProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
157 void AsyncRenameProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
158 void AsyncDeleteProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
159 static void LeaveOutIcon(struct internalScaWindowTask *iwt, struct ScaIconNode *in, APTR undoStep);
160 static void PutAwayIconNode(struct internalScaWindowTask *iwt, struct ScaIconNode *in, APTR undoStep);
161 static void DoForAllWindowsShared(struct internalScaWindowTask *iwt,
162 void (*IconProc)(struct internalScaWindowTask *iwt, struct ScaIconNode *in, APTR undoStep),
163 void (*WindowProc)(struct internalScaWindowTask *iwt));
164 static void DoForAllIconsShared(struct internalScaWindowTask *iwt,
165 void (*IconProc)(struct internalScaWindowTask *iwt, struct ScaIconNode *in, APTR undoStep),
166 APTR undoStep);
167 static void DoForAllWindows(struct internalScaWindowTask *iwt,
168 void (*IconProc)(struct internalScaWindowTask *iwt, struct ScaIconNode *in, APTR undoStep));
169 static void DoForAllIconsExclusive(struct internalScaWindowTask *iwt,
170 void (*IconProc)(struct internalScaWindowTask *iwt, struct ScaIconNode *in, APTR undoStep),
171 APTR undoStep);
172 static SAVEDS(ULONG) InfoStart(APTR aptr, struct SM_RunProcess *msg);
173 //static struct ScaIconNode *FindIconGlobal(BPTR dirLock, CONST_STRPTR Name);
174 static void ClearSelectionInWindow(struct internalScaWindowTask *iwt);
175 static void MakeCloneArgs(struct internalScaWindowTask *iwt,
176 struct WBArg **wbArg, ULONG *ArgCount);
177 static void CloneInfoStart(struct internalScaWindowTask *iwt,
178 struct WBArg **wbArg, ULONG *ArgCount);
179 static BOOL CloneWBArg(struct internalScaWindowTask *iwt, struct WBArg **wbArg,
180 struct ScaIconNode *in, ULONG *ArgCount);
181 static SAVEDS(ULONG) CloneFilesStart(APTR aptr, struct SM_RunProcess *msg);
182 static SAVEDS(LONG) IconCompareFunc(struct Hook *hook, struct ScaIconNode *in2, struct ScaIconNode *in1);
183 static void SnapshotIcon(struct internalScaWindowTask *iwt, struct ScaIconNode *in, APTR undoStep);
184 static void UnsnapshotIconAndSave(struct internalScaWindowTask *iwt, struct ScaIconNode *in, APTR undoStep);
185 static void UnsnapshotIcon(struct internalScaWindowTask *iwt, struct ScaIconNode *in, BOOL SaveIcon, APTR undoStep);
186 static void AfterUnsnapshotIcon(struct internalScaWindowTask *iwt);
187 static void SetRect(struct ScaIconNode *in);
188 static void SetRect2(struct ScaIconNode *in, BPTR iconLock);
189 static void CloseWindowProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
190 static ULONG FindIconType(struct WBArg *Arg);
191 static BOOL CallGlobalDeleteHook(struct WBArg *wbArg, ULONG nArgs, ULONG Action);
192 static void DeleteModuleKludge(struct WBArg *wbArg, ULONG nArgs);
193 static void RememberFilesToCopy(struct internalScaWindowTask *iwt, struct ScaIconNode *in, APTR undoStep);
194 static void RememberFilesToCut(struct internalScaWindowTask *iwt, struct ScaIconNode *in, APTR undoStep);
195 static ULONG CallTextInputHook(ULONG Action, STRPTR Prompt);
196 static STRPTR FindUniqueName(STRPTR Name, size_t MaxLength);
197 static BOOL CanBeSizedMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in);
198 static BOOL IsMainWindowMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in);
199 static BOOL NotMainWindowMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in);
200 static BOOL NotRootWindowMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in);
201 static BOOL MustHaveLockMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in);
202 static BOOL IconsSelectedAndWriteableMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in);
203 static BOOL IconsSelectedMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in);
204 static BOOL IconsSelectedBrowserModeMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in);
205 static BOOL IconsSelectedNotBrowserModeMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in);
206 static BOOL EmptyTrashMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in);
207 static BOOL FormatDiskMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in);
208 static BOOL LeaveOutMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in);
209 static BOOL PutAwayMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in);
210 static BOOL PasteMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in);
211 static BOOL UndoMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in);
212 static BOOL RedoMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in);
213 static BOOL NotMainWindowAndNotReadingMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in);
214 static BOOL SnapshotMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in);
215 static BOOL NotReadingMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in);
216 static BOOL IsWriteableMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in);
217 static BOOL IconsSelectedNoDiskMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in); // +jmc+ - Diable menu item if in->in_Device.
218 static SAVEDS(ULONG) AsyncStartModule(APTR aptr, struct SM_RunProcess *msg, CONST_STRPTR ModuleName);
219 static void CreateThumbnailStart(struct internalScaWindowTask *iwt, struct ScaIconNode *in, APTR undoStep);
220 static void DoForAppIcons(ULONG AppMsgClass);
221
222 //--- +jmc+ --- CopyTo/MoveTo ------------------------------------------------
223
224 static void CopyToProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
225 static SAVEDS(ULONG) CopyToStart(APTR aptr, struct SM_RunProcess *msg);
226
227 static void MoveToProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg);
228 static SAVEDS(ULONG) MoveToStart(APTR aptr, struct SM_RunProcess *msg);
229
230 static void CopyToMakeCloneArgs(struct internalScaWindowTask *iwt,
231 struct WBArg **wbArg, ULONG *ArgCount, ULONG MaxArgs);
232 static void CopyToCloneInfoStart(struct internalScaWindowTask *iwt,
233 struct WBArg **wbArg, ULONG *ArgCount, ULONG MaxArgs);
234 static BOOL CopyToCloneWBArg(struct internalScaWindowTask *iwt, struct WBArg **wbArg,
235 struct ScaIconNode *in, ULONG *ArgCount, ULONG MaxArgs);
236
237 static void MoveToMakeCloneArgs(struct internalScaWindowTask *iwt,
238 struct WBArg **wbArg, ULONG *ArgCount, ULONG MaxArgs);
239 static void MoveToCloneInfoStart(struct internalScaWindowTask *iwt,
240 struct WBArg **wbArg, ULONG *ArgCount, ULONG MaxArgs);
241
242 //----------------------------------------------------------------------------
243
244
245 //----------------------------------------------------------------------------
246
247 // local Data items
248
249 //----------------------------------------------------------------------------
250
251 // public data items
252
253 struct ScalosMenuCommand MenuCommandTable[] =
254 {
255 { "about", SMCOMFLAGF_RunFromRootWindow, MITYPE_NOTHING, AboutProg, NULL },
256 { "backdrop", SMCOMFLAGF_RunFromRootWindow, MITYPEF_Backdrop, BackDropProg, IsMainWindowMenuEnable },
257 { "cleanup", 0, MITYPE_NOTHING, CleanupProg, NULL },
258 { "cleanupbyname", 0, MITYPE_NOTHING, CleanupByNameProg, NULL },
259 { "cleanupbydate", 0, MITYPE_NOTHING, CleanupByDateProg, NULL },
260 { "cleanupbysize", 0, MITYPE_NOTHING, CleanupBySizeProg, NULL },
261 { "cleanupbytype", 0, MITYPE_NOTHING, CleanupByTypeProg, NULL },
262 { "clearselection", 0, MITYPE_NOTHING, ClearSelectionProg, NULL },
263 { "createthumbnail", 0, MITYPE_NOTHING, MenuCreateThumbnailProg, IconsSelectedAndWriteableMenuEnable },
264 { "clone", 0, MITYPE_NOTHING, CloneProg, IconsSelectedAndWriteableMenuEnable },
265 { "close", 0, MITYPE_NOTHING, CloseProg, NotMainWindowMenuEnable },
266 { "copy", 0, MITYPE_NOTHING, MenuCopyProg, IconsSelectedMenuEnable },
267 { "copyto", 0, MITYPE_NOTHING, CopyToProg, IconsSelectedMenuEnable },
268 { "cut", 0, MITYPE_NOTHING, MenuCutProg, IconsSelectedNoDiskMenuEnable }, // IconsSelectedAndWriteableMenuEnable
269 { "delete", 0, MITYPE_NOTHING, DeleteProg, IconsSelectedAndWriteableMenuEnable },
270 { "emptytrashcan", 0, MITYPE_NOTHING, EmptyTrashProg, EmptyTrashMenuEnable },
271 { "executecommand", 0, MITYPE_NOTHING, ExecuteCmdProg, NULL },
272 { "find", 0, MITYPE_NOTHING, FindProg, NULL },
273 { "formatdisk", 0, MITYPE_NOTHING, FormatDiskProg, FormatDiskMenuEnable },
274 { "iconify", 0, MITYPE_NOTHING, IconifyProg, CanBeSizedMenuEnable },
275 { "iconinfo", 0, MITYPE_NOTHING, MenuInfoProg, IconsSelectedMenuEnable },
276 { "iconproperties", 0, MITYPE_NOTHING, IconPropertiesProg, IconsSelectedMenuEnable },
277 { "lastmsg", 0, MITYPE_NOTHING, LastMessageProg, NULL },
278 { "leaveout", 0, MITYPE_NOTHING, LeaveOutProg, LeaveOutMenuEnable },
279 { "makedir", 0, MITYPE_NOTHING, NewDrawerProg, MustHaveLockMenuEnable },
280 { "moveto", 0, MITYPE_NOTHING, MoveToProg, IconsSelectedNoDiskMenuEnable }, // IconsSelectedAndWriteableMenuEnable
281 { "open", 0, MITYPE_NOTHING, MenuOpenProg, IconsSelectedMenuEnable },
282 { "openinbrowserwindow",0, MITYPE_NOTHING, MenuOpenBrowserWindowProg, IconsSelectedNotBrowserModeMenuEnable },
283 { "openinnewwindow", 0, MITYPE_NOTHING, MenuOpenNewProg, IconsSelectedBrowserModeMenuEnable },
284 { "parent", 0, MITYPE_NOTHING, OpenParentProg, NotRootWindowMenuEnable },
285 { "paste", 0, MITYPE_NOTHING, MenuPasteProg, PasteMenuEnable },
286 { "putaway", 0, MITYPE_NOTHING, PutAwayProg, PutAwayMenuEnable },
287 { "quit", SMCOMFLAGF_RunFromRootWindow, MITYPE_NOTHING, CloseWindowProg, NULL },
288 { "redo", 0, MITYPE_NOTHING, MenuRedoProg, RedoMenuEnable },
289 { "redraw", 0, MITYPE_NOTHING, RedrawProg, NULL },
290 { "redrawall", SMCOMFLAGF_RunFromRootWindow, MITYPE_NOTHING, RedrawAllProg, NULL },
291 { "rename", 0, MITYPE_NOTHING, RenameProg, IconsSelectedAndWriteableMenuEnable },
292 { "reset", SMCOMFLAGF_RunFromRootWindow, MITYPE_NOTHING, ResetScalosProg, NULL },
293 { "selectall", 0, MITYPE_NOTHING, SelectContentsProg, NULL },
294 { "showallfiles", 0, MITYPEF_ShowAllFiles, ShowAllFilesProg, NotMainWindowAndNotReadingMenuEnable },
295 { "showonlyicons", 0, MITYPEF_ShowOnlyIcons, ShowOnlyIconsProg, NotMainWindowAndNotReadingMenuEnable },
296 { "showdefault", 0, MITYPEF_ShowDefault, ShowDefaultProg, NotMainWindowAndNotReadingMenuEnable },
297 { "shutdown", SMCOMFLAGF_RunFromRootWindow, MITYPE_NOTHING, ShutdownProg, NULL },
298 { "sizetofit", 0, MITYPE_NOTHING, SizeToFitProg, CanBeSizedMenuEnable },
299 { "snapshot", 0, MITYPE_NOTHING, MenuSnapshotProg, SnapshotMenuEnable },
300 { "snapshotall", 0, MITYPE_NOTHING, SnapshotAllProg, IsWriteableMenuEnable },
301 { "snapshotwindow", 0, MITYPE_NOTHING, SnapshotWindowProg, IsWriteableMenuEnable },
302 { "thumbnailcachecleanup", 0, MITYPE_NOTHING, ThumbnailCacheCleanupProg, NULL },
303 { "undo", 0, MITYPE_NOTHING, MenuUndoProg, UndoMenuEnable },
304 { "unsnapshot", 0, MITYPE_NOTHING, MenuUnsnapshotProg, SnapshotMenuEnable },
305 { "update", 0, MITYPE_NOTHING, UpdateProg, NotReadingMenuEnable },
306 { "updateall", SMCOMFLAGF_RunFromRootWindow, MITYPE_NOTHING, UpdateAllProg, NULL },
307 { "viewbydate", 0, MITYPEF_ViewByDate, ViewByDateProg, NotMainWindowAndNotReadingMenuEnable },
308 { "viewbyicon", 0, MITYPEF_ViewByIcon, ViewByIconProg, NotMainWindowAndNotReadingMenuEnable },
309 { "viewbysize", 0, MITYPEF_ViewBySize, ViewBySizeProg, NotMainWindowAndNotReadingMenuEnable },
310 { "viewbytype", 0, MITYPEF_ViewByType, ViewByTypeProg, NotMainWindowAndNotReadingMenuEnable },
311 { "viewbytext", 0, MITYPEF_ViewByText, ViewByTextProg, NotMainWindowAndNotReadingMenuEnable },
312 { "viewbydefault", 0, MITYPEF_ViewByDefault, ViewByDefaultProg, NotMainWindowAndNotReadingMenuEnable },
313 { "windowproperties", 0, MITYPE_NOTHING, WindowPropertiesProg, NotReadingMenuEnable },
314 { NULL, 0, 0, NULL, NULL },
315 };
316
317 struct List globalCopyClipBoard; // Clipboard for files/directories via copy/cut/paste
318 SCALOSSEMAPHORE ClipboardSemaphore; // Semaphore to protect globalCopyClipBoard
319
320 //----------------------------------------------------------------------------
321
322 static void MenuInfoProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
323 {
324 d1(KPrintF("%s/%s/%ld: START iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
325 d1(KPrintF("%s/%s/%ld: mca_IconNode=%08lx\n", __FILE__, __FUNC__, __LINE__, mcArg->mca_IconNode));
326
327 if (mcArg->mca_IconNode)
328 {
329 SCA_LockWindowList(SCA_LockWindowList_Shared);
330 WBInfoStart(iwt, mcArg->mca_IconNode, NULL);
331 SCA_UnLockWindowList();
332 }
333 else
334 {
335 DoForAllWindowsShared(iwt, WBInfoStart, NULL);
336 }
337 }
338
339 //----------------------------------------------------------------------------
340
341 static void IconPropertiesProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
342 {
343 d1(KPrintF("%s/%s/%ld: START iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
344 d1(kprintf("%s/%s/%ld: mca_IconNode=%08lx\n", __FILE__, __FUNC__, __LINE__, mcArg->mca_IconNode));
345
346 if (mcArg->mca_IconNode)
347 {
348 SCA_LockWindowList(SCA_LockWindowList_Shared);
349 WBIconPropertiesStart(iwt, mcArg->mca_IconNode, NULL);
350 SCA_UnLockWindowList();
351 }
352 else
353 {
354 DoForAllWindowsShared(iwt, WBIconPropertiesStart, NULL);
355 }
356 }
357
358 //----------------------------------------------------------------------------
359
360 static void DoForAllWindowsShared(struct internalScaWindowTask *iwt,
361 void (*IconProc)(struct internalScaWindowTask *iwt, struct ScaIconNode *in, APTR undoStep),
362 void (*WindowProc)(struct internalScaWindowTask *iwt))
363 {
364 struct ScaWindowStruct *ws;
365 APTR undoStep;
366
367 d1(KPrintF("%s/%s/%ld: START iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
368
369 undoStep = UndoBeginStep();
370
371 SCA_LockWindowList(SCA_LockWindowList_Shared);
372
373 d1(kprintf("%s/%s/%ld:\n", __FILE__, __FUNC__, __LINE__));
374
375 DoForAllIconsShared(iwt, IconProc, undoStep);
376 if (WindowProc)
377 (*WindowProc)(iwt);
378
379 d1(kprintf("%s/%s/%ld:\n", __FILE__, __FUNC__, __LINE__));
380
381 for (ws=winlist.wl_WindowStruct; ws; ws = (struct ScaWindowStruct *) ws->ws_Node.mln_Succ)
382 {
383 if (ws != iwt->iwt_WindowTask.mt_WindowStruct)
384 {
385 DoForAllIconsShared((struct internalScaWindowTask *) ws->ws_WindowTask, IconProc, undoStep);
386 if (WindowProc)
387 (*WindowProc)((struct internalScaWindowTask *) ws->ws_WindowTask);
388 }
389 }
390
391 d1(kprintf("%s/%s/%ld:\n", __FILE__, __FUNC__, __LINE__));
392
393 SCA_UnLockWindowList();
394
395 UndoEndStep(iwt, undoStep);
396
397 d1(kprintf("%s/%s/%ld:\n", __FILE__, __FUNC__, __LINE__));
398 }
399
400
401 static void DoForAllIconsShared(struct internalScaWindowTask *iwt,
402 void (*IconProc)(struct internalScaWindowTask *iwt, struct ScaIconNode *in, APTR undoStep),
403 APTR undoStep)
404 {
405 struct ScaIconNode *in;
406
407 d1(KPrintF("%s/%s/%ld: START iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
408
409 ScalosLockIconListShared(iwt);
410
411 for (in=iwt->iwt_WindowTask.wt_IconList; in; in = (struct ScaIconNode *) in->in_Node.mln_Succ)
412 {
413 struct ExtGadget *gg = (struct ExtGadget *) in->in_Icon;
414
415 if (gg->Flags & GFLG_SELECTED)
416 {
417 d1(kprintf("%s/%s/%ld: iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, in, GetIconName(in)));
418 (*IconProc)(iwt, in, undoStep);
419 }
420 }
421
422 ScalosUnLockIconList(iwt);
423 }
424
425
426 static void DoForAllWindows(struct internalScaWindowTask *iwt,
427 void (*IconProc)(struct internalScaWindowTask *iwt, struct ScaIconNode *in, APTR undoStep))
428 {
429 struct ScaWindowStruct *ws;
430 APTR undoStep;
431
432 d1(KPrintF("%s/%s/%ld: START iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
433
434 undoStep = UndoBeginStep();
435
436 SCA_LockWindowList(SCA_LockWindowList_Shared);
437
438 DoForAllIconsExclusive(iwt, IconProc, undoStep);
439
440 for (ws=winlist.wl_WindowStruct; ws; ws = (struct ScaWindowStruct *) ws->ws_Node.mln_Succ)
441 {
442 if (ws != iwt->iwt_WindowTask.mt_WindowStruct)
443 DoForAllIconsExclusive((struct internalScaWindowTask *) ws->ws_WindowTask, IconProc, undoStep);
444 }
445
446 SCA_UnLockWindowList();
447
448 UndoEndStep(iwt, undoStep);
449 }
450
451
452 // IconProc might modify wt_IconList !!
453 static void DoForAllIconsExclusive(struct internalScaWindowTask *iwt,
454 void (*IconProc)(struct internalScaWindowTask *iwt, struct ScaIconNode *in, APTR undoStep),
455 APTR undoStep)
456 {
457 ULONG IconCount;
458 struct ScaIconNode *in;
459
460 d1(KPrintF("%s/%s/%ld: START iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
461
462 ScalosLockIconListExclusive(iwt);
463
464 // Count icons in window
465 for (IconCount = 0, in=iwt->iwt_WindowTask.wt_IconList; in; in = (struct ScaIconNode *) in->in_Node.mln_Succ)
466 IconCount++;
467
468 if (IconCount)
469 {
470 struct ScaIconNode **IconArray;
471
472 IconArray = ScalosAlloc(IconCount * sizeof(struct ScaIconNode *));
473 if (IconArray)
474 {
475 ULONG n;
476
477 // Collect addresses of all icons in IconArray
478 for (n = 0, in=iwt->iwt_WindowTask.wt_IconList; in; in = (struct ScaIconNode *) in->in_Node.mln_Succ)
479 IconArray[n++] = in;
480
481 // Now iterate through the collected icons
482 for (n = 0; n < IconCount; n++)
483 {
484 // verify that IconArray[n] is still present
485 for (in=iwt->iwt_WindowTask.wt_IconList; in; in = (struct ScaIconNode *) in->in_Node.mln_Succ)
486 {
487 if (in == IconArray[n])
488 {
489 struct ExtGadget *gg = (struct ExtGadget *) in->in_Icon;
490
491 if (gg->Flags & GFLG_SELECTED)
492 (*IconProc)(iwt, in, undoStep);
493 break;
494 }
495 }
496 }
497
498 ScalosFree(IconArray);
499 }
500 }
501
502 ScalosUnLockIconList(iwt);
503 }
504
505 //----------------------------------------------------------------------------
506
507 void WBInfoStart(struct internalScaWindowTask *iwt, struct ScaIconNode *in, APTR undoStep)
508 {
509 ULONG IconType;
510
511 d1(KPrintF("%s/%s/%ld: iwt=%08lx in=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, in, GetIconName(in)));
512
513 (void) undoStep;
514
515 GetAttr(IDTA_Type, in->in_Icon, &IconType);
516
517 if (WBAPPICON == IconType)
518 {
519 WindowSendAppIconMsg(iwt, AMCLASSICON_Information, in);
520 }
521 else
522 {
523 struct WBArg InfoArgs;
524
525 if (in->in_DeviceIcon)
526 {
527 InfoArgs.wa_Lock = DiskInfoLock(in);
528 InfoArgs.wa_Name = AllocCopyString("Disk"); // look for "Disk.info"
529 }
530 else
531 {
532 InfoArgs.wa_Name = AllocCopyString(GetIconName(in));
533
534 if (in->in_Lock)
535 InfoArgs.wa_Lock = DupLock(in->in_Lock);
536 else
537 InfoArgs.wa_Lock = DupLock(iwt->iwt_WindowTask.mt_WindowStruct->ws_Lock);
538 }
539
540 d1(KPrintF("%s/%s/%ld: InfoArgs.wa_Name=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, \
541 InfoArgs.wa_Name, InfoArgs.wa_Name ? InfoArgs.wa_Name : (BYTE *) ""));
542 debugLock_d1(InfoArgs.wa_Lock);
543
544 RunProcess(&iwt->iwt_WindowTask, InfoStart, sizeof(InfoArgs)/sizeof(ULONG), &InfoArgs, iInfos.xii_iinfos.ii_MainMsgPort);
545 }
546 }
547
548
549 static SAVEDS(ULONG) InfoStart(APTR aptr, struct SM_RunProcess *msg)
550 {
551 return AsyncStartModule(aptr, msg, "Information.module");
552 }
553
554 //----------------------------------------------------------------------------
555
556 static void SizeToFitProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
557 {
558 struct Rectangle VirtRect;
559 WORD NewInnerWidth, NewInnerHeight;
560 WORD NewLeft, NewTop, NewWidth, NewHeight;
561
562 d1(KPrintF("%s/%s/%ld: START iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
563 d1(kprintf("%s/%s/%ld: vWidth=%ld vHeight=%ld iWidth=%ld iHeight=%ld\n", __FILE__, __FUNC__, __LINE__, \
564 iwt->iwt_InvisibleWidth, iwt->iwt_InvisibleHeight, iwt->iwt_InnerWidth, iwt->iwt_InnerHeight));
565
566 if (iwt->iwt_BackDrop)
567 return;
568
569 ScalosObtainSemaphoreShared(iwt->iwt_WindowTask.wt_WindowSemaphore);
570
571 GetIconsBoundingBox(iwt, &VirtRect);
572
573 d1(kprintf("%s/%s/%ld: MinX=%ld MinY=%ld MaxX=%ld MaxY=%ld\n", __FILE__, __FUNC__, __LINE__, \
574 VirtRect.MinX, VirtRect.MinY, VirtRect.MaxX, VirtRect.MaxY));
575
576 if (NULL == iwt->iwt_WindowTask.wt_Window)
577 {
578 ScalosReleaseSemaphore(iwt->iwt_WindowTask.wt_WindowSemaphore);
579 return;
580 }
581
582 NewInnerWidth = VirtRect.MaxX - VirtRect.MinX + 1;
583 NewInnerHeight = VirtRect.MaxY - VirtRect.MinY + 1;
584
585 NewLeft = iwt->iwt_WindowTask.wt_Window->LeftEdge;
586 NewTop = iwt->iwt_WindowTask.wt_Window->TopEdge;
587 NewWidth = iwt->iwt_WindowTask.wt_Window->Width;
588 NewHeight = iwt->iwt_WindowTask.wt_Window->Height;
589
590 if (iwt->iwt_InnerWidth != NewInnerWidth)
591 {
592 NewWidth = NewInnerWidth + iwt->iwt_InnerLeft + iwt->iwt_InnerRight;
593
594 if (NewWidth > iwt->iwt_WinScreen->Width)
595 NewWidth = iwt->iwt_WinScreen->Width;
596 if (NewLeft + NewWidth > iwt->iwt_WinScreen->Width)
597 NewLeft = iwt->iwt_WinScreen->Width - NewWidth;
598 }
599 if (iwt->iwt_InnerHeight != NewInnerHeight)
600 {
601 NewHeight = NewInnerHeight + iwt->iwt_InnerTop + iwt->iwt_InnerBottom;
602
603 if (NewHeight > iwt->iwt_WinScreen->Height)
604 NewHeight = iwt->iwt_WinScreen->Height;
605 if (NewLeft + NewHeight > iwt->iwt_WinScreen->Height)
606 NewLeft = iwt->iwt_WinScreen->Height - NewHeight;
607 }
608
609 UndoAddEvent(iwt, UNDO_SizeWindow,
610 UNDOTAG_WindowTask, iwt,
611 UNDOTAG_OldWindowLeft, iwt->iwt_WindowTask.wt_Window->LeftEdge,
612 UNDOTAG_OldWindowTop, iwt->iwt_WindowTask.wt_Window->TopEdge,
613 UNDOTAG_OldWindowWidth, iwt->iwt_WindowTask.wt_Window->Width,
614 UNDOTAG_OldWindowHeight, iwt->iwt_WindowTask.wt_Window->Height,
615 UNDOTAG_NewWindowLeft, NewLeft,
616 UNDOTAG_NewWindowTop, NewTop,
617 UNDOTAG_NewWindowWidth, NewWidth,
618 UNDOTAG_NewWindowHeight, NewHeight,
619 UNDOTAG_OldWindowVirtX, iwt->iwt_WindowTask.wt_XOffset,
620 UNDOTAG_OldWindowVirtY, iwt->iwt_WindowTask.wt_YOffset,
621 UNDOTAG_NewWindowVirtX, VirtRect.MinX,
622 UNDOTAG_NewWindowVirtY, VirtRect.MinY,
623 TAG_END);
624
625 d1(kprintf("%s/%s/%ld: XOffset=%ld YOffset=%ld\n", __FILE__, __FUNC__, __LINE__, \
626 iwt->iwt_WindowTask.wt_XOffset, iwt->iwt_WindowTask.wt_YOffset));
627
628 DoMethod(iwt->iwt_WindowTask.mt_MainObject, SCCM_IconWin_DeltaMove,
629 VirtRect.MinX - iwt->iwt_WindowTask.wt_XOffset,
630 VirtRect.MinY - iwt->iwt_WindowTask.wt_YOffset);
631
632 d1(KPrintF("%s/%s/%ld: Left=%ld Top=%ld Width=%ld Height=%ld\n", __FILE__, __FUNC__, __LINE__, \
633 NewLeft, NewTop, NewWidth, NewHeight));
634
635 ChangeWindowBox(iwt->iwt_WindowTask.wt_Window, NewLeft, NewTop, NewWidth, NewHeight);
636
637 ScalosReleaseSemaphore(iwt->iwt_WindowTask.wt_WindowSemaphore);
638 }
639
640 //----------------------------------------------------------------------------
641
642 static void WindowPropertiesProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
643 {
644 d1(kprintf("%s/%s/%ld: mca_IconNode=%08lx\n", __FILE__, __FUNC__, __LINE__, mcArg->mca_IconNode));
645
646 ScalosObtainSemaphoreShared(iwt->iwt_WindowTask.wt_WindowSemaphore); // prevent window from closing
647
648 StartProgTask(iwt, mcArg, AsyncWindowPropertiesProg, (struct MsgPort *) SCCV_RunProcess_WaitReply);
649
650 d1(kprintf("%s/%s/%ld: Release WindowSemaphore iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
651
652 ScalosReleaseSemaphore(iwt->iwt_WindowTask.wt_WindowSemaphore);
653 }
654
655 //----------------------------------------------------------------------------
656
657 void ClearSelectionProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
658 {
659 struct ScaWindowStruct *ws;
660
661 d1(KPrintF("%s/%s/%ld: START iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
662
663 SCA_LockWindowList(SCA_LockWindowList_Shared);
664
665 // Deselect all icons in all windows
666 for (ws=winlist.wl_WindowStruct; ws; ws = (struct ScaWindowStruct *) ws->ws_Node.mln_Succ)
667 {
668 ClearSelectionInWindow((struct internalScaWindowTask *) ws->ws_WindowTask);
669 }
670
671 SCA_UnLockWindowList();
672
673 AdjustIconActive(iwt);
674
675 SetMenuOnOff(iwt);
676 }
677
678
679 static void SelectContentsProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
680 {
681 struct ScaIconNode *in;
682 struct ScaWindowStruct *ws;
683
684 d1(KPrintF("%s/%s/%ld: START iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
685
686 SCA_LockWindowList(SCA_LockWindowList_Shared);
687
688 // Deselect all icons in other windows
689 for (ws=winlist.wl_WindowStruct; ws; ws = (struct ScaWindowStruct *) ws->ws_Node.mln_Succ)
690 {
691 if (ws != iwt->iwt_WindowTask.mt_WindowStruct)
692 ClearSelectionInWindow((struct internalScaWindowTask *) ws->ws_WindowTask);
693 }
694
695 ScalosLockIconListExclusive(iwt);
696
697 for (in=iwt->iwt_WindowTask.wt_IconList; in; in = (struct ScaIconNode *) in->in_Node.mln_Succ)
698 {
699 ClassSelectIcon(iwt->iwt_WindowTask.mt_WindowStruct, in, TRUE);
700 }
701
702 ScalosUnLockIconList(iwt);
703
704 SCA_UnLockWindowList();
705
706 AdjustIconActive(iwt);
707
708 SetMenuOnOff(iwt);
709 }
710
711
712 static void NewDrawerProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
713 {
714 LONG Result;
715 char NewDrawerName[108];
716
717 d1(kprintf("%s/%s/%ld: Obtain WindowSemaphore iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
718
719 ScalosObtainSemaphoreShared(iwt->iwt_WindowTask.wt_WindowSemaphore); // prevent window from closing
720
721 stccpy(NewDrawerName, GetLocString(MSGID_NEW_DRAWER_NAME), sizeof(NewDrawerName));
722
723 Result = CallTextInputHook(TIACTION_NewDrawer, FindUniqueName(NewDrawerName, sizeof(NewDrawerName)));
724
725 if (Result)
726 StartProgTask(iwt, mcArg, AsyncNewDrawerProg, (struct MsgPort *) SCCV_RunProcess_WaitReply);
727
728 d1(kprintf("%s/%s/%ld: Release WindowSemaphore iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
729
730 ScalosReleaseSemaphore(iwt->iwt_WindowTask.wt_WindowSemaphore);
731 }
732
733
734 static void RenameProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
735 {
736 d1(kprintf("%s/%s/%ld: Obtain WindowSemaphore iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
737
738 ScalosObtainSemaphoreShared(iwt->iwt_WindowTask.wt_WindowSemaphore); // prevent window from closing
739
740 StartProgTask(iwt, mcArg, AsyncRenameProg, (struct MsgPort *) SCCV_RunProcess_WaitReply);
741
742 d1(kprintf("%s/%s/%ld: Release WindowSemaphore iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
743
744 ScalosReleaseSemaphore(iwt->iwt_WindowTask.wt_WindowSemaphore);
745 }
746
747
748 void DeleteProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
749 {
750 d1(kprintf("%s/%s/%ld: Obtain WindowSemaphore iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
751
752 ScalosObtainSemaphoreShared(iwt->iwt_WindowTask.wt_WindowSemaphore); // prevent window from closing
753
754 StartProgTask(iwt, mcArg, AsyncDeleteProg, (struct MsgPort *) SCCV_RunProcess_WaitReply);
755
756 d1(kprintf("%s/%s/%ld: Release WindowSemaphore iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
757
758 ScalosReleaseSemaphore(iwt->iwt_WindowTask.wt_WindowSemaphore);
759 }
760
761
762 static BOOL StartProgTask(struct internalScaWindowTask *iwt,
763 const struct MenuCmdArg *mcArg, PROGFUNC ProgProc, struct MsgPort *ReplyPort)
764 {
765 struct SM_StartProg sMsg;
766 BOOL Success;
767
768 sMsg.spr_ProgFunc = ProgProc;
769 sMsg.spr_WindowTask = iwt;
770 sMsg.spr_Arg = *mcArg;
771
772 Success = DoMethod(iwt->iwt_WindowTask.mt_MainObject, SCCM_RunProcess, ProgTask,
773 &sMsg, sizeof(sMsg), ReplyPort);
774
775 return Success;
776 }
777
778
779 static SAVEDS(ULONG) ProgTask(struct SM_StartProg *sMsg, struct SM_RunProcess *msg)
780 {
781 static CONST_STRPTR ProgTaskName = "Scalos_RunProg";
782 struct internalScaWindowTask *iwt;
783 PROGFUNC ProgFunc;
784 APTR prWindowPtr;
785 struct MenuCmdArg Arg;
786 struct Process *myProc = (struct Process *) FindTask(NULL);
787
788 d1(kprintf("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
789
790 prWindowPtr = myProc->pr_WindowPtr;
791 myProc->pr_WindowPtr = (APTR) ~0; // suppress error requesters
792
793 myProc->pr_Task.tc_Node.ln_Name = (STRPTR) ProgTaskName;
794 SetProgramName(ProgTaskName);
795
796 iwt = sMsg->spr_WindowTask;
797 ProgFunc = sMsg->spr_ProgFunc;
798 Arg = sMsg->spr_Arg;
799
800 d1(kprintf("%s/%s/%ld: Obtain WindowSemaphore iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
801
802 ScalosObtainSemaphoreShared(iwt->iwt_WindowTask.wt_WindowSemaphore);
803
804 (*ProgFunc)(iwt, &Arg);
805
806 d1(kprintf("%s/%s/%ld: Release WindowSemaphore iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
807
808 ScalosReleaseSemaphore(iwt->iwt_WindowTask.wt_WindowSemaphore);
809
810 // restore pr_WindowPtr
811 myProc->pr_WindowPtr = prWindowPtr;
812
813 return 0;
814 }
815
816 //----------------------------------------------------------------------------
817
818 static void AsyncNewDrawerProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
819 {
820 BOOL Success;
821 struct WBArg wbArg[2];
822
823 wbArg[1].wa_Name = NULL;
824 wbArg[1].wa_Lock = DupLock(iwt->iwt_WindowTask.mt_WindowStruct->ws_Lock);
825 if ((BPTR)NULL == wbArg[1].wa_Lock)
826 return;
827
828 wbArg[0].wa_Name = (STRPTR) "newdrawer.module";
829 wbArg[0].wa_Lock = LockScaModsDir();
830 if ((BPTR)NULL == wbArg[0].wa_Lock)
831 {
832 UnLock(wbArg[1].wa_Lock);
833 return;
834 }
835
836 // SCA_WBStart()
837 Success = SCA_WBStartTags(wbArg, 2,
838 SCA_Stacksize, CurrentPrefs.pref_DefaultStackSize,
839 SCA_Flags, SCAF_WBStart_Wait,
840 SCA_WaitTimeout, 0,
841 TAG_END);
842
843 if (!Success)
844 {
845 UnLock(wbArg[0].wa_Lock);
846 UnLock(wbArg[1].wa_Lock);
847 }
848
849 DoMethod(iwt->iwt_WindowTask.mt_MainObject, SCCM_IconWin_ImmediateCheckUpdate);
850 }
851
852 //----------------------------------------------------------------------------
853
854 static void WBIconPropertiesStart(struct internalScaWindowTask *iwt, struct ScaIconNode *in, APTR undoStep)
855 {
856 struct WBArg InfoArgs;
857
858 d1(KPrintF("%s/%s/%ld: START iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
859 d1(kprintf("%s/%s/%ld: iwt=%08lx in=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, in, GetIconName(in)));
860
861 if (in->in_DeviceIcon)
862 {
863 InfoArgs.wa_Lock = DiskInfoLock(in);
864 InfoArgs.wa_Name = AllocCopyString("Disk"); // look for "Disk.info"
865 }
866 else
867 {
868 InfoArgs.wa_Name = AllocCopyString(GetIconName(in));
869
870 if (in->in_Lock)
871 InfoArgs.wa_Lock = DupLock(in->in_Lock);
872 else
873 InfoArgs.wa_Lock = DupLock(iwt->iwt_WindowTask.mt_WindowStruct->ws_Lock);
874 }
875
876 d1(kprintf("%s/%s/%ld: InfoArgs.wa_Name=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, \
877 InfoArgs.wa_Name, InfoArgs.wa_Name ? InfoArgs.wa_Name : ""));
878 debugLock_d1(InfoArgs.wa_Lock);
879
880 RunProcess(&iwt->iwt_WindowTask, IconPropertiesStart, sizeof(InfoArgs)/sizeof(ULONG), &InfoArgs, iInfos.xii_iinfos.ii_MainMsgPort);
881 }
882
883
884 static SAVEDS(ULONG) IconPropertiesStart(APTR aptr, struct SM_RunProcess *msg)
885 {
886 ULONG Result;
887
888 d1(KPrintF("%s/%s/%ld: START aptr=%08lx msg=%08lx\n", __FILE__, __FUNC__, __LINE__, aptr, msg));
889 Result = AsyncStartModule(aptr, msg, "iconproperties.module");
890 d1(KPrintF("%s/%s/%ld: END Result=%ld\n", __FILE__, __FUNC__, __LINE__, Result));
891
892 return Result;
893 }
894
895 //----------------------------------------------------------------------------
896
897 static void AsyncWindowPropertiesProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
898 {
899 BOOL Success;
900 struct WBArg wbArg[2];
901
902 wbArg[1].wa_Name = NULL;
903 wbArg[1].wa_Lock = DupLock(iwt->iwt_WindowTask.mt_WindowStruct->ws_Lock);
904 if ((BPTR)NULL == wbArg[1].wa_Lock)
905 return;
906
907 wbArg[0].wa_Name = (STRPTR) "windowproperties.module";
908 wbArg[0].wa_Lock = LockScaModsDir();
909 if ((BPTR)NULL == wbArg[0].wa_Lock)
910 {
911 UnLock(wbArg[1].wa_Lock);
912 return;
913 }
914
915 // SCA_WBStart()
916 Success = SCA_WBStartTags(wbArg, 2,
917 SCA_Stacksize, CurrentPrefs.pref_DefaultStackSize,
918 SCA_Flags, SCAF_WBStart_Wait,
919 SCA_WaitTimeout, 0,
920 TAG_END);
921
922 if (!Success)
923 {
924 UnLock(wbArg[0].wa_Lock);
925 UnLock(wbArg[1].wa_Lock);
926 }
927
928 DoMethod(iwt->iwt_WindowTask.mt_MainObject, SCCM_IconWin_ImmediateCheckUpdate);
929 }
930
931 //----------------------------------------------------------------------------
932
933 void AsyncRenameProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
934 {
935 BOOL Success;
936 struct WBArg *wbArg;
937 ULONG nArgs;
938
939 d1(KPrintF("%s/%s/%ld: START iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
940
941 do {
942 ULONG tiResult;
943 ULONG n;
944 ULONG NumberOfWbArgs = 1;
945
946 d1(KPrintF("%s/%s/%ld: mca_IconNode=%08lx\n", __FILE__, __FUNC__, __LINE__, mcArg->mca_IconNode));
947
948 if (mcArg->mca_IconNode)
949 NumberOfWbArgs += 1;
950 else
951 NumberOfWbArgs += SCA_CountWBArgs(mcArg->mca_IconNode);
952
953 d1(KPrintF("%s/%s/%ld: NumberOfWbArgs=%lu\n", __FILE__, __FUNC__, __LINE__, NumberOfWbArgs));
954
955 wbArg = ScalosAlloc(NumberOfWbArgs * sizeof(struct WBArg));
956 d1(KPrintF("%s/%s/%ld: wbArg=%08lx\n", __FILE__, __FUNC__, __LINE__, wbArg));
957 if (NULL == wbArg)
958 return;
959
960 wbArg[0].wa_Name = (STRPTR) "rename.module";
961 wbArg[0].wa_Lock = LockScaModsDir();
962 if ((BPTR)NULL == wbArg[0].wa_Lock)
963 break;
964
965 nArgs = 1; // first argument is program itself
966
967 if (NumberOfWbArgs > 1)
968 {
969 if (mcArg->mca_IconNode)
970 {
971 nArgs += DoMethod(iwt->iwt_WindowTask.mt_MainObject, SCCM_IconWin_MakeWBArg,
972 mcArg->mca_IconNode, &wbArg[1]);
973 }
974 else
975 {
976 nArgs += SCA_MakeWBArgs(&wbArg[1], NULL, NumberOfWbArgs - 1);
977 }
978 }
979
980 d1(KPrintF("%s/%s/%ld: nArgs=%lu\n", __FILE__, __FUNC__, __LINE__, nArgs));
981
982 DoForAppIcons(AMCLASSICON_Rename);
983
984 if (nArgs < 2)
985 break;
986
987 for (n=1, tiResult=0; !tiResult && n<nArgs; n++)
988 {
989 BPTR oldDir = CurrentDir(wbArg[n].wa_Lock);
990
991 if (strlen(wbArg[n].wa_Name) > 0)
992 {
993 tiResult = CallTextInputHook(TIACTION_Rename, wbArg[n].wa_Name);
994 }
995 else
996 {
997 STRPTR VolumeName = AllocPathBuffer();
998
999 if (VolumeName)
1000 {
1001 NameFromLock(wbArg[n].wa_Lock, VolumeName, Max_PathLen);
1002 StripTrailingColon(VolumeName);
1003
1004 tiResult = CallTextInputHook(TIACTION_RelabelVolume, VolumeName);
1005 FreePathBuffer(VolumeName);
1006 }
1007 else
1008 tiResult = 1;
1009 }
1010
1011 CurrentDir(oldDir);
1012 }
1013
1014 d1(KPrintF("%s/%s/%ld: tiResult=%lu\n", __FILE__, __FUNC__, __LINE__, tiResult));
1015
1016 if (tiResult)
1017 {
1018 // SCA_WBStart()
1019 Success = SCA_WBStartTags(wbArg, nArgs,
1020 SCA_Stacksize, CurrentPrefs.pref_DefaultStackSize,
1021 SCA_Flags, SCAF_WBStart_Wait,
1022 SCA_WaitTimeout, 0,
1023 TAG_END);
1024
1025 d1(KPrintF("%s/%s/%ld: Success=%lu\n", __FILE__, __FUNC__, __LINE__, Success));
1026
1027 if (NumberOfWbArgs > 1)
1028 {
1029 SCA_FreeWBArgs(&wbArg[1], nArgs - 1,
1030 Success ? SCAF_FreeNames : SCAF_FreeNames | SCAF_FreeLocks);
1031 }
1032 if (Success)
1033 wbArg[0].wa_Lock = (BPTR)NULL;
1034
1035 DoMethod(iwt->iwt_WindowTask.mt_MainObject, SCCM_IconWin_ImmediateCheckUpdate);
1036 }
1037 else
1038 {
1039 // Rename done by TextInputHook
1040 if (NumberOfWbArgs > 1)
1041 {
1042 SCA_FreeWBArgs(&wbArg[1], nArgs - 1, SCAF_FreeNames | SCAF_FreeLocks);
1043 }
1044 }
1045
1046 } while (0);
1047
1048 d1(KPrintF("%s/%s/%ld: wbArg=%08lx\n", __FILE__, __FUNC__, __LINE__, wbArg));
1049
1050 if (wbArg)
1051 {
1052 if (wbArg[0].wa_Lock)
1053 UnLock(wbArg[0].wa_Lock);
1054
1055 ScalosFree(wbArg);
1056 }
1057
1058 d1(KPrintF("%s/%s/%ld: END", __FILE__, __FUNC__, __LINE__));
1059 }
1060
1061 //----------------------------------------------------------------------------
1062
1063 void AsyncDeleteProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
1064 {
1065 BOOL Success = FALSE;
1066 struct WBArg *wbArg;
1067
1068 do {
1069 ULONG nArgs = 1;
1070 ULONG NumberOfWbArgs = 1;
1071
1072 if (mcArg->mca_IconNode)
1073 NumberOfWbArgs += 1;
1074 else
1075 NumberOfWbArgs += SCA_CountWBArgs(mcArg->mca_IconNode);
1076
1077 wbArg = ScalosAlloc(NumberOfWbArgs * sizeof(struct WBArg));
1078 if (NULL == wbArg)
1079 return;
1080
1081 if (NumberOfWbArgs > 1)
1082 {
1083 if (mcArg->mca_IconNode)
1084 {
1085 nArgs += DoMethod(iwt->iwt_WindowTask.mt_MainObject, SCCM_IconWin_MakeWBArg,
1086 mcArg->mca_IconNode, &wbArg[1]
1087 );
1088 }
1089 else
1090 {
1091 nArgs += SCA_MakeWBArgs(&wbArg[1], NULL, NumberOfWbArgs - 1);
1092 }
1093 }
1094
1095 DoForAppIcons(AMCLASSICON_Delete);
1096
1097 if (nArgs < 2)
1098 break;
1099
1100 ScalosObtainSemaphoreShared(&DeleteHookSemaphore);
1101
1102 if (globalDeleteHook)
1103 {
1104 Success = CallGlobalDeleteHook(&wbArg[1], nArgs - 1, DLACTION_BeginDiscard);
1105 }
1106 else
1107 {
1108 wbArg[0].wa_Name = (STRPTR) "delete.module";
1109 wbArg[0].wa_Lock = LockScaModsDir();
1110 if ((BPTR)NULL == wbArg[0].wa_Lock)
1111 break;
1112
1113 DeleteModuleKludge(wbArg, nArgs);
1114 }
1115
1116 ScalosReleaseSemaphore(&DeleteHookSemaphore);
1117
1118 if (!Success)
1119 {
1120 // SCA_WBStart()
1121 Success = SCA_WBStartTags(wbArg, nArgs,
1122 SCA_Stacksize, CurrentPrefs.pref_DefaultStackSize,
1123 SCA_Flags, SCAF_WBStart_Wait,
1124 SCA_WaitTimeout, 0,
1125 TAG_END);
1126
1127 if (NumberOfWbArgs > 1)
1128 {
1129 SCA_FreeWBArgs(&wbArg[1], nArgs - 1,
1130 Success ? SCAF_FreeNames : SCAF_FreeNames | SCAF_FreeLocks);
1131 }
1132 if (Success)
1133 wbArg[0].wa_Lock = (BPTR)NULL;
1134 }
1135
1136 DoMethod(iwt->iwt_WindowTask.mt_MainObject, SCCM_IconWin_ImmediateCheckUpdate);
1137 } while (0);
1138
1139 if (wbArg)
1140 {
1141 if (wbArg[0].wa_Lock)
1142 UnLock(wbArg[0].wa_Lock);
1143
1144 ScalosFree(wbArg);
1145 }
1146 }
1147
1148 //----------------------------------------------------------------------------
1149
1150 static void LeaveOutIcon(struct internalScaWindowTask *iwt, struct ScaIconNode *in, APTR undoStep)
1151 {
1152 ULONG IconType = 0;
1153
1154 d1(KPrintF("%s/%s/%ld: START iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
1155 d1(KPrintF("%s/%s/%ld: Icon=<%s> Lock=%08lx\n", __FILE__, __FUNC__, __LINE__, IconName, in->in_Lock));
1156
1157 GetAttr(IDTA_Type, in->in_Icon, &IconType);
1158
1159 if (0 == IconType)
1160 return;
1161
1162 if (WBAPPICON == IconType)
1163 {
1164 WindowSendAppIconMsg(iwt, AMCLASSICON_LeaveOut, in);
1165 return;
1166 }
1167 else
1168 {
1169 BPTR DirLock;
1170
1171 if (in->in_Lock)
1172 DirLock = in->in_Lock;
1173 else
1174 DirLock = iwt->iwt_WindowTask.mt_WindowStruct->ws_Lock;
1175
1176 UndoAddEvent(iwt, UNDO_Leaveout,
1177 UNDOTAG_UndoMultiStep, undoStep,
1178 UNDOTAG_IconName, GetIconName(in),
1179 UNDOTAG_IconDirLock, DirLock,
1180 UNDOTAG_IconPosX, NO_ICON_POSITION_SHORT,
1181 UNDOTAG_IconPosY, NO_ICON_POSITION_SHORT,
1182 TAG_END);
1183
1184 DoLeaveOutIcon(iwt, DirLock, GetIconName(in),
1185 NO_ICON_POSITION_SHORT, NO_ICON_POSITION_SHORT);
1186
1187 d1(KPrintF("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
1188 }
1189
1190 d1(kprintf("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
1191 }
1192
1193
1194 static void PutAwayIconNode(struct internalScaWindowTask *iwt, struct ScaIconNode *in, APTR undoStep)
1195 {
1196 ULONG IconType = 0;
1197
1198 d1(KPrintF("%s/%s/%ld: START iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
1199 d1(KPrintF("%s/%s/%ld: Icon=<%s> Lock=%08lx\n", __FILE__, __FUNC__, __LINE__, GetIconName(in), in->in_Lock));
1200
1201 GetAttr(IDTA_Type, in->in_Icon, &IconType);
1202
1203 if (0 == IconType)
1204 return;
1205
1206 if (WBAPPICON == IconType)
1207 {
1208 WindowSendAppIconMsg(iwt, AMCLASSICON_PutAway, in);
1209 return;
1210 }
1211 else
1212 {
1213 STRPTR Path = NULL;
1214 STRPTR IconName;
1215 BPTR iconDirLockClone = (BPTR)NULL;
1216
1217 do {
1218 BPTR iconDirLock;
1219 struct ScaWindowStruct *wsDest;
1220
1221 if (in->in_Lock)
1222 iconDirLock = in->in_Lock;
1223 else
1224 iconDirLock = iwt->iwt_WindowTask.mt_WindowStruct->ws_Lock;
1225
1226 IconName = AllocCopyString(GetIconName(in));
1227 if (NULL == IconName)
1228 break;
1229
1230 debugLock_d1(iconDirLock);
1231
1232 iconDirLockClone = DupLock(iconDirLock);
1233 if ((BPTR)NULL == iconDirLockClone)
1234 break;
1235
1236 UndoAddEvent(iwt, UNDO_PutAway,
1237 UNDOTAG_UndoMultiStep, undoStep,
1238 UNDOTAG_IconName, IconName,
1239 UNDOTAG_IconDirLock, iconDirLock,
1240 TAG_END);
1241
1242 // !!! side effects: UnLocks(iconDirLock) and frees <in> !!!
1243 PutAwayIcon(iwt, iconDirLock, IconName, TRUE);
1244
1245 d1(KPrintF("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
1246
1247 // add icon to owning drawer window
1248 SCA_LockWindowList(SCA_LockWindowList_Shared);
1249
1250 for (wsDest = winlist.wl_WindowStruct; wsDest; wsDest = (struct ScaWindowStruct *) wsDest->ws_Node.mln_Succ)
1251 {
1252 debugLock_d1(iconDirLockClone);
1253 d1(if (wsDest->ws_Lock) debugLock_d1(wsDest->ws_Lock));
1254
1255 if (wsDest->ws_Lock && LOCK_SAME == ScaSameLock(iconDirLockClone, wsDest->ws_Lock))
1256 {
1257 struct internalScaWindowTask *iwtDest = (struct internalScaWindowTask *) wsDest->ws_WindowTask;
1258
1259 d1(KPrintF("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
1260
1261 DoMethod(iwtDest->iwt_WindowTask.mt_MainObject,
1262 SCCM_IconWin_ReadIcon,
1263 IconName,
1264 NULL);
1265
1266 // Special handling for "view all" textwindows.
1267 // here both object and icon are separate entries, which must be removed both!
1268 if (!IsIwtViewByIcon(iwtDest) &&
1269 IsShowAll(iwtDest->iwt_WindowTask.mt_WindowStruct))
1270 {
1271 Path = AllocPathBuffer();
1272 if (NULL == Path)
1273 break;
1274
1275 stccpy(Path, IconName, Max_PathLen);
1276 SafeStrCat(Path, ".info", Max_PathLen);
1277
1278 DoMethod(iwtDest->iwt_WindowTask.mt_MainObject,
1279 SCCM_IconWin_ReadIcon,
1280 Path,
1281 NULL);
1282 }
1283 }
1284 }
1285
1286 SCA_UnLockWindowList();
1287
1288 d1(KPrintF("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
1289 } while (0);
1290
1291 if (IconName)
1292 FreeCopyString(IconName);
1293 if (iconDirLockClone)
1294 UnLock(iconDirLockClone);
1295 if (Path)
1296 FreePathBuffer(Path);
1297 }
1298
1299 d1(KPrintF("%s/%s/%ld: END\n", __FILE__, __FUNC__, __LINE__));
1300 }
1301
1302
1303 static void SnapshotWindow(struct internalScaWindowTask *iwt)
1304 {
1305 struct ScaWindowStruct *ws = iwt->iwt_WindowTask.mt_WindowStruct;
1306 CONST_STRPTR iconName;
1307 Object *IconObj, *allocIconObj = NULL;
1308 BPTR parentLock = (BPTR)NULL;
1309
1310 d1(KPrintF("%s/%s/%ld: START iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
1311
1312 do {
1313 struct IBox WinRect;
1314 ULONG IconViewMode;
1315 ULONG ddFlags;
1316
1317 WinRect.Left = ws->ws_Left;
1318 WinRect.Top = ws->ws_Top;
1319 WinRect.Width = ws->ws_Width;
1320 WinRect.Height = ws->ws_Height;
1321
1322 IconObj = ClassGetWindowIconObject(iwt, &allocIconObj);
1323
1324 d1(KPrintF("%s/%s/%ld: iconName=<%s> IconObj=%08lx\n", __FILE__, __FUNC__, __LINE__, iconName, IconObj));
1325 if (NULL == IconObj)
1326 break;
1327
1328 IconViewMode = TranslateViewModesToIcon(ws->ws_Viewmodes);
1329 ddFlags = ws->ws_ViewAll;
1330 if (SortOrder_Ascending == ws->ws_SortOrder)
1331 ddFlags |= DDFLAGS_SORTASC;
1332 else if (SortOrder_Descending == ws->ws_SortOrder)
1333 ddFlags |= DDFLAGS_SORTDESC;
1334
1335 d1(KPrintF("%s/%s/%ld: ws_ViewAll=%04lx ddFlags=%08lx\n", __FILE__, __FUNC__, __LINE__, ws->ws_ViewAll, ddFlags));
1336
1337 SetAttrs(IconObj,
1338 IDTA_ViewModes, IconViewMode,
1339 IDTA_Flags, ddFlags,
1340 IDTA_WindowRect, (ULONG) &WinRect,
1341 IDTA_WinCurrentY, ws->ws_yoffset,
1342 IDTA_WinCurrentX, ws->ws_xoffset,
1343 TAG_END);
1344
1345 GetAttr(DTA_Name, IconObj, (APTR) &iconName);
1346
1347 d1(kprintf("%s/%s/%ld: iconName=<%s> IconObj=%08lx\n", __FILE__, __FUNC__, __LINE__, iconName, IconObj));
1348
1349 if (ws->ws_Flags & WSV_FlagF_RootWindow)
1350 parentLock = DupLock(ws->ws_Lock);
1351 else
1352 parentLock = ParentDir(ws->ws_Lock);
1353 if ((BPTR)NULL == parentLock)
1354 break;
1355
1356 SaveIconObject(IconObj, parentLock, iconName, FALSE, NULL);
1357 } while (0);
1358
1359 if (allocIconObj)
1360 DisposeIconObject(allocIconObj);
1361 if (parentLock)
1362 UnLock(parentLock);
1363 }
1364
1365 #if 0
1366 static struct ScaIconNode *FindIconGlobal(BPTR dirLock, CONST_STRPTR Name)
1367 {
1368 struct ScaWindowStruct *ws;
1369 struct ScaIconNode *in = NULL;
1370 STRPTR allocName = NULL;
1371 BPTR parentLock = NULL;
1372
1373 d1(kprintf("%s/%s/%ld: dirLock=%08lx Name=<%s>\n", __FILE__, __FUNC__, __LINE__, dirLock, Name));
1374 debugLock_d1(dirLock);
1375
1376 if (strlen(Name) < 1)
1377 {
1378 // dirLock is really ObjectLock
1379 parentLock = ParentDir(dirLock);
1380 if (NULL == parentLock)
1381 return NULL;
1382
1383 allocName = AllocPathBuffer();
1384 if (NULL == allocName)
1385 {
1386 UnLock(parentLock);
1387 return NULL;
1388 }
1389
1390 NameFromLock(dirLock, allocName, Max_PathLen - 1);
1391 Name = FilePart(allocName);
1392 dirLock = parentLock;
1393
1394 d1(kprintf("%s/%s/%ld: allocName=<%s>\n", __FILE__, __FUNC__, __LINE__, allocName));
1395
1396 d1(kprintf("%s/%s/%ld: dirLock=%08lx Name=<%s>\n", __FILE__, __FUNC__, __LINE__, dirLock, Name));
1397 debugLock_d1(dirLock);
1398 }
1399
1400 SCA_LockWindowList(SCA_LockWindowList_Shared);
1401
1402 for (ws=winlist.wl_WindowStruct; NULL == in && ws; ws = (struct ScaWindowStruct *) ws->ws_Node.mln_Succ)
1403 {
1404 if (LOCK_SAME == ScaSameLock(ws->ws_Lock, dirLock))
1405 {
1406 struct ScaIconNode *inx;
1407 struct internalScaWindowTask *iwt = (struct internalScaWindowTask *) ws->ws_WindowTask;
1408
1409 d1(kprintf("%s/%s/%ld: Window FOUND iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
1410
1411 ScalosLockIconListShared(iwt);
1412
1413 for (inx=iwt->iwt_WindowTask.wt_IconList; NULL == in && inx; inx = (struct ScaIconNode *) inx->in_Node.mln_Succ)
1414 {
1415 if (0 == Stricmp(inx->in_Name, Name))
1416 in = inx;
1417 }
1418
1419 ScalosUnLockIconList(iwt);
1420 }
1421 }
1422
1423 if (NULL == in)
1424 {
1425 // no icon found.
1426 // now look in main window for left-out (=backdrop) icons.
1427
1428 struct internalScaWindowTask *iwt = (struct internalScaWindowTask *) iInfos.xii_iinfos.ii_MainWindowStruct->ws_WindowTask;
1429 struct ScaIconNode *inx;
1430
1431 ScalosLockIconListShared(iwt);
1432
1433 for (inx=iwt->iwt_WindowTask.wt_IconList; NULL == in && inx; inx = (struct ScaIconNode *) inx->in_Node.mln_Succ)
1434 {
1435 if (inx->in_Lock &&
1436 LOCK_SAME == ScaSameLock(inx->in_Lock, dirLock) &&
1437 0 == Stricmp(inx->in_Name, Name))
1438 {
1439 in = inx;
1440 }
1441 }
1442
1443 ScalosUnLockIconList(iwt);
1444 }
1445
1446 SCA_UnLockWindowList();
1447
1448 d1(kprintf("%s/%s/%ld: in=%08lx\n", __FILE__, __FUNC__, __LINE__, in));
1449
1450 if (allocName)
1451 FreePathBuffer(allocName);
1452 if (parentLock)
1453 UnLock(parentLock);
1454
1455 return in;
1456 }
1457 #endif
1458
1459 static void BackDropProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
1460 {
1461 UBYTE newState;
1462
1463 newState = mcArg->mca_State != 0;
1464
1465 d1(KPrintF("%s/%s/%ld: START iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
1466 d1(kprintf("%s/%s/%ld: State=%ld\n", __FILE__, __FUNC__, __LINE__, mcArg->mca_State));
1467 d1(kprintf("%s/%s/%ld: CommandName=%08lx\n", __FILE__, __FUNC__, __LINE__, mcArg->mca_CommandName));
1468
1469 d1(kprintf("%s/%s/%ld: iwt_BackDrop=%ld newState=%ld\n", __FILE__, __FUNC__, __LINE__, iwt->iwt_BackDrop, newState));
1470
1471 if (newState != iwt->iwt_BackDrop)
1472 {
1473 struct ScaWindowStruct *ws = iwt->iwt_WindowTask.mt_WindowStruct;
1474 struct PatternNode *ptNode;
1475
1476 SCA_LockWindowList(SCA_LockWindowList_Shared);
1477
1478 DoMethod(iwt->iwt_WindowTask.mt_MainObject, SCCM_IconWin_Sleep);
1479
1480 iwt->iwt_BackDrop = newState;
1481
1482 if (iwt->iwt_BackDrop)
1483 {
1484 iwt->iwt_WindowTask.mt_WindowStruct->ws_Flags |= WSV_FlagF_Backdrop;
1485 iwt->iwt_WindowTask.wt_XOffset = iwt->iwt_WindowTask.mt_WindowStruct->ws_xoffset = 0;
1486 iwt->iwt_WindowTask.wt_YOffset = iwt->iwt_WindowTask.mt_WindowStruct->ws_yoffset = 0;
1487 }
1488 else
1489 iwt->iwt_WindowTask.mt_WindowStruct->ws_Flags &= ~WSV_FlagF_Backdrop;
1490
1491 DoMethod(iwt->iwt_WindowTask.mt_MainObject, SCCM_IconWin_WakeUp, 1);
1492
1493 ptNode = ws->ws_PatternNode;
1494
1495 d1(kprintf("%s/%s/%ld: type=%ld\n", __FILE__, __FUNC__, __LINE__, ptNode->ptn_type));
1496
1497 if (PatternPrefs.patt_NewRenderFlag && ptNode &&
1498 ((SCP_RenderType_FitSize == ptNode->ptn_type)
1499 || (SCP_RenderType_ScaledMin == ptNode->ptn_type)
1500 || (SCP_RenderType_Centered == ptNode->ptn_type))
1501 && GuiGFXBase && iwt->iwt_WindowTask.wt_PatternInfo.ptinf_bitmap)
1502 {
1503 d1(KPrintF("%s/%s/%ld:\n", __FILE__, __FUNC__, __LINE__));
1504
1505 NewWindowPatternMsg(iwt, NULL, &ptNode);
1506 }
1507
1508 SCA_UnLockWindowList();
1509 }
1510 }
1511
1512
1513 void UpdateAllProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
1514 {
1515 struct ScaWindowStruct *ws;
1516
1517 d1(KPrintF("%s/%s/%ld: START iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
1518
1519 (void) mcArg;
1520
1521 SCA_LockWindowList(SCA_LockWindowList_Shared);
1522
1523 for (ws=winlist.wl_WindowStruct; ws; ws = (struct ScaWindowStruct *) ws->ws_Node.mln_Succ)
1524 {
1525 d1(KPrintF("%s/%s/%ld: Name=<%s> Flags=%08lx\n", __FILE__, __FUNC__, __LINE__, ws->ws_Name, ws->ws_Flags));
1526
1527 if (!(ws->ws_Flags & WSV_FlagF_TaskSleeps))
1528 {
1529 struct ScalosMessage *msg;
1530
1531 msg = SCA_AllocMessage(MTYP_Update, 0);
1532
1533 if (msg)
1534 PutMsg(ws->ws_MessagePort, &msg->sm_Message);
1535 }
1536 }
1537
1538 SCA_UnLockWindowList();
1539
1540 d1(KPrintF("%s/%s/%ld: END iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
1541
1542 }
1543
1544
1545 static void RedrawAllProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
1546 {
1547 struct ScaWindowStruct *ws;
1548
1549 SCA_LockWindowList(SCA_LockWindowList_Shared);
1550
1551 for (ws=winlist.wl_WindowStruct; ws; ws = (struct ScaWindowStruct *) ws->ws_Node.mln_Succ)
1552 {
1553 if (!(ws->ws_Flags & WSV_FlagF_TaskSleeps))
1554 {
1555 struct ScalosMessage *msg;
1556
1557 msg = SCA_AllocMessage(MTYP_Redraw, 0);
1558
1559 if (msg)
1560 PutMsg(ws->ws_MessagePort, &msg->sm_Message);
1561 }
1562 }
1563
1564 SCA_UnLockWindowList();
1565 }
1566
1567
1568 void GetIconsBoundingBox(struct internalScaWindowTask *iwt, struct Rectangle *BBox)
1569 {
1570 struct ScaIconNode *in;
1571
1572 BBox->MinX = BBox->MinY = SHRT_MAX;
1573 BBox->MaxX = BBox->MaxY = SHRT_MIN;
1574
1575 ScalosLockIconListShared(iwt);
1576
1577 for (in=iwt->iwt_WindowTask.wt_IconList; in; in = (struct ScaIconNode *) in->in_Node.mln_Succ)
1578 {
1579 struct ExtGadget *gg = (struct ExtGadget *) in->in_Icon;
1580
1581 if (BBox->MinX > gg->BoundsLeftEdge)
1582 BBox->MinX = gg->BoundsLeftEdge;
1583 if (BBox->MinY > gg->BoundsTopEdge)
1584 BBox->MinY = gg->BoundsTopEdge;
1585
1586 if (BBox->MaxX < gg->BoundsLeftEdge + gg->BoundsWidth - 1)
1587 BBox->MaxX = gg->BoundsLeftEdge + gg->BoundsWidth - 1;
1588 if (BBox->MaxY < gg->BoundsTopEdge + gg->BoundsHeight - 1)
1589 BBox->MaxY = gg->BoundsTopEdge + gg->BoundsHeight - 1;
1590 }
1591
1592 BBox->MinX -= CurrentPrefs.pref_CleanupSpace.Left;
1593 BBox->MaxX += CurrentPrefs.pref_CleanupSpace.Left;
1594 BBox->MinY -= CurrentPrefs.pref_CleanupSpace.Top;
1595 BBox->MaxY += CurrentPrefs.pref_CleanupSpace.Top;
1596
1597 ScalosUnLockIconList(iwt);
1598 }
1599
1600
1601 static void ClearSelectionInWindow(struct internalScaWindowTask *iwt)
1602 {
1603 struct ScaIconNode *in;
1604
1605 d1(KPrintF("%s/%s/%ld: START iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
1606
1607 ScalosLockIconListShared(iwt);
1608
1609 for (in=iwt->iwt_WindowTask.wt_IconList; in; in = (struct ScaIconNode *) in->in_Node.mln_Succ)
1610 {
1611 ClassSelectIcon(iwt->iwt_WindowTask.mt_WindowStruct, in, FALSE);
1612 }
1613
1614 ScalosUnLockIconList(iwt);
1615 }
1616
1617
1618 static void ViewByIconProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
1619 {
1620 ViewWindowBy(iwt, IDTV_ViewModes_Icon);
1621 }
1622
1623
1624 static void ViewByTextProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
1625 {
1626 ViewWindowBy(iwt, IDTV_ViewModes_Name);
1627 }
1628
1629
1630 static void ViewByDateProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
1631 {
1632 ViewWindowBy(iwt, IDTV_ViewModes_Date);
1633 }
1634
1635
1636 static void ViewBySizeProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
1637 {
1638 ViewWindowBy(iwt, IDTV_ViewModes_Size);
1639 }
1640
1641
1642 static void ViewByTypeProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
1643 {
1644 ViewWindowBy(iwt, IDTV_ViewModes_Type);
1645 }
1646
1647 static void ViewByDefaultProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
1648 {
1649 ViewWindowBy(iwt, IDTV_ViewModes_Default);
1650 }
1651
1652 BOOL ViewWindowBy(struct internalScaWindowTask *iwt, UBYTE NewViewByType)
1653 {
1654 struct ScaWindowStruct *ws = iwt->iwt_WindowTask.mt_WindowStruct;
1655 Object *newObject;
1656 UBYTE OldViewByType;
1657 BOOL Updated = FALSE;
1658
1659 d1(KPrintF("%s/%s/%ld: START iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
1660 d1(KPrintF("%s/%s/%ld: ws_Viewmodes=%ld NewViewByType=%ld\n", \
1661 __FILE__, __FUNC__, __LINE__, ws->ws_Viewmodes, NewViewByType));
1662
1663 if (ws->ws_Viewmodes == NewViewByType)
1664 return Updated;
1665
1666 FlushThumbnailEntries(iwt);
1667
1668 OldViewByType = ws->ws_Viewmodes;
1669
1670 newObject = (Object *) DoMethod(iwt->iwt_WindowTask.mt_MainObject, SCCM_IconWin_NewViewMode, NewViewByType);
1671 d1(KPrintF("%s/%s/%ld: newObject=%08lx\n", __FILE__, __FUNC__, __LINE__, newObject));
1672 if (newObject)
1673 {
1674 Object *oldObject;
1675 ws->ws_Viewmodes = OldViewByType;
1676
1677 if (iwt->iwt_WindowTask.wt_Window)
1678 {
1679 struct Region *origClipRegion = iwt->iwt_RemRegion;
1680
1681 d1(kprintf("%s/%s/%ld: iwt_RemRegion=%08lx\n", __FILE__, __FUNC__, __LINE__, iwt->iwt_RemRegion));
1682 iwt->iwt_RemRegion = NULL;
1683
1684 DoMethod(iwt->iwt_WindowTask.mt_WindowObject, SCCM_Window_RemClipRegion, origClipRegion);
1685 }
1686
1687 oldObject = iwt->iwt_WindowTask.mt_MainObject;
1688 iwt->iwt_WindowTask.mt_MainObject = newObject;
1689
1690 ws->ws_Viewmodes = NewViewByType;
1691
1692 DisposeObject(oldObject);
1693 }
1694
1695 DoMethod(iwt->iwt_WindowTask.mt_WindowObject, SCCM_Window_SetInnerSize);
1696
1697 iwt->iwt_WindowTask.wt_XOffset = 0;
1698 iwt->iwt_WindowTask.wt_YOffset = 0;
1699
1700 ws->ws_xoffset = iwt->iwt_WindowTask.wt_XOffset;
1701 ws->ws_yoffset = iwt->iwt_WindowTask.wt_YOffset;
1702
1703 d1(KPrintF("%s/%s/%ld: newObject=%08lx\n", __FILE__, __FUNC__, __LINE__, newObject));
1704 if (newObject)
1705 {
1706 // switch between icon/text window
1707 DoMethod(iwt->iwt_WindowTask.mt_MainObject, SCCM_IconWin_Update);
1708 Updated = TRUE;
1709 }
1710 else
1711 {
1712 // all text window, different sorting
1713 if (!IsIwtViewByIcon(iwt))
1714 DoMethod(iwt->iwt_WindowTask.mt_MainObject, SCCM_TextWin_DrawColumnHeaders);
1715
1716 DoMethod(iwt->iwt_WindowTask.mt_MainObject, SCCM_IconWin_CleanUp);
1717 }
1718 d1(KPrintF("%s/%s/%ld: END Updated=%ld\n", __FILE__, __FUNC__, __LINE__, Updated));
1719
1720 return Updated;
1721 }
1722
1723
1724 static void CloneProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
1725 {
1726 struct WBArg *wbArg, *wbArgAlloc;
1727 ULONG ArgCount = 0;
1728
1729 d1(KPrintF("%s/%s/%ld: START iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
1730
1731 do {
1732 struct CloneArg processArgs;
1733 ULONG NumberOfWbArgs = 1;
1734
1735 if (mcArg->mca_IconNode)
1736 NumberOfWbArgs += 1;
1737 else
1738 NumberOfWbArgs += SCA_CountWBArgs(mcArg->mca_IconNode);
1739
1740 wbArg = wbArgAlloc = ScalosAlloc(NumberOfWbArgs * sizeof(struct WBArg));
1741 if (NULL == wbArgAlloc)
1742 return;
1743
1744 if (mcArg->mca_IconNode)
1745 {
1746 ULONG IconType;
1747
1748 GetAttr(IDTA_Type, mcArg->mca_IconNode->in_Icon, &IconType);
1749
1750 if (WB_TEXTICON_TOOL != IconType &&
1751 WB_TEXTICON_DRAWER != IconType &&
1752 WBDRAWER != IconType &&
1753 WBTOOL != IconType &&
1754 WBPROJECT != IconType)
1755 {
1756 break;
1757 }
1758
1759 if (!CloneWBArg(iwt, &wbArg, mcArg->mca_IconNode, &ArgCount))
1760 break;
1761
1762 ArgCount++;
1763
1764 d1(kprintf("%s/%s/%ld: NumArgs=%ld\n", __FILE__, __FUNC__, __LINE__, ArgCount));
1765 }
1766 else
1767 {
1768 MakeCloneArgs(iwt, &wbArg, &ArgCount);
1769 }
1770
1771 d1(KPrintF("%s/%s/%ld: NumArgs=%ld iwt=%08lx\n", __FILE__, __FUNC__, __LINE__, ArgCount, iwt));
1772
1773 DoForAppIcons(AMCLASSICON_Copy);
1774
1775 if (ArgCount < 1)
1776 break;
1777
1778 processArgs.cla_wbArg = wbArgAlloc;
1779 processArgs.cla_NumArgs = ArgCount;
1780
1781 RunProcess(&iwt->iwt_WindowTask, CloneFilesStart,
1782 sizeof(processArgs)/sizeof(ULONG), (struct WBArg *)(APTR) &processArgs, NULL);
1783
1784 // wbArgAlloc will be freed inside <CloneFilesStart>
1785 wbArgAlloc = NULL;
1786 ArgCount = 0;
1787 } while (0);
1788
1789 if (wbArgAlloc)
1790 {
1791 if (ArgCount > 0)
1792 SCA_FreeWBArgs(wbArgAlloc, ArgCount, SCAF_FreeNames | SCAF_FreeLocks);
1793
1794 ScalosFree(wbArgAlloc);
1795 }
1796 }
1797
1798
1799 static void MakeCloneArgs(struct internalScaWindowTask *iwt,
1800 struct WBArg **wbArg, ULONG *ArgCount)
1801 {
1802 struct ScaWindowStruct *ws;
1803
1804 SCA_LockWindowList(SCA_LockWindowList_Shared);
1805
1806 CloneInfoStart(iwt, wbArg, ArgCount);
1807
1808 for (ws=winlist.wl_WindowStruct; ws; ws = (struct ScaWindowStruct *) ws->ws_Node.mln_Succ)
1809 {
1810 if (ws != iwt->iwt_WindowTask.mt_WindowStruct)
1811 CloneInfoStart((struct internalScaWindowTask *) ws->ws_WindowTask, wbArg, ArgCount);
1812 }
1813
1814 SCA_UnLockWindowList();
1815 }
1816
1817
1818 static void CloneInfoStart(struct internalScaWindowTask *iwt,
1819 struct WBArg **wbArg, ULONG *ArgCount)
1820 {
1821 struct ScaIconNode *in;
1822
1823 ScalosLockIconListShared(iwt);
1824
1825 for (in=iwt->iwt_WindowTask.wt_IconList; in; in = (struct ScaIconNode *) in->in_Node.mln_Succ)
1826 {
1827 struct ExtGadget *gg = (struct ExtGadget *) in->in_Icon;
1828
1829 if (gg->Flags & GFLG_SELECTED)
1830 {
1831 ULONG IconType;
1832
1833 GetAttr(IDTA_Type, in->in_Icon, &IconType);
1834
1835 switch (IconType)
1836 {
1837 case WB_TEXTICON_TOOL:
1838 case WB_TEXTICON_DRAWER:
1839 case WBDRAWER:
1840 case WBTOOL:
1841 case WBPROJECT:
1842 d1(kprintf("%s/%s/%ld: icon=<%s> NumArgs=%ld\n", __FILE__, __FUNC__, __LINE__, GetIconName(in), *ArgCount));
1843 CloneWBArg(iwt, wbArg, in, ArgCount);
1844 break;
1845 default:
1846 break;
1847 }
1848 }
1849 }
1850
1851 ScalosUnLockIconList(iwt);
1852 }
1853
1854
1855 static BOOL CloneWBArg(struct internalScaWindowTask *iwt, struct WBArg **wbArg,
1856 struct ScaIconNode *in, ULONG *ArgCount)
1857 {
1858 if (NULL == in->in_Name)
1859 return FALSE;
1860
1861 if (in->in_Lock)
1862 {
1863 (*wbArg)->wa_Lock = DupLock(in->in_Lock);
1864 }
1865 else
1866 {
1867 if (iwt->iwt_WindowTask.mt_WindowStruct->ws_Lock)
1868 (*wbArg)->wa_Lock = DupLock(iwt->iwt_WindowTask.mt_WindowStruct->ws_Lock);
1869 else
1870 (*wbArg)->wa_Lock = (BPTR)NULL;
1871
1872 }
1873
1874 (*wbArg)->wa_Name = AllocCopyString(GetIconName(in));
1875
1876 if (NULL == (*wbArg)->wa_Name)
1877 {
1878 if ((*wbArg)->wa_Lock)
1879 UnLock((*wbArg)->wa_Lock);
1880
1881 return FALSE;
1882 }
1883
1884 (*wbArg)++;
1885 (*ArgCount)++;
1886
1887 return TRUE;
1888 }
1889
1890 //---------------------------------------------------------------------------------------
1891
1892 static SAVEDS(ULONG) CloneFilesStart(APTR aptr, struct SM_RunProcess *msg)
1893 {
1894 struct CloneArg *arg = aptr;
1895 STRPTR NewName;
1896 STRPTR OldIconName = NULL;
1897 APTR undoStep;
1898 Object *fileTransObj = NULL;
1899 ULONG n;
1900
1901 do {
1902 undoStep = UndoBeginStep();
1903
1904 NewName = AllocPathBuffer();
1905 if (NULL == NewName)
1906 break;
1907
1908 OldIconName = AllocPathBuffer();
1909 if (NULL == OldIconName)
1910 break;
1911
1912 fileTransObj = SCA_NewScalosObjectTags((STRPTR) "FileTransfer.sca",
1913 SCCA_FileTrans_Screen, (ULONG) iInfos.xii_iinfos.ii_Screen,
1914 SCCA_FileTrans_Number, arg->cla_NumArgs,
1915 SCCA_FileTrans_ReplaceMode, SCCV_ReplaceMode_Ask,
1916 TAG_END);
1917 if (NULL == fileTransObj)
1918 break;
1919
1920 d1(kprintf("%s/%s/%ld: NumArgs=%ld\n", __FILE__, __FUNC__, __LINE__, arg->cla_NumArgs));
1921
1922 for (n=0; n < arg->cla_NumArgs; n++)
1923 {
1924 BumpRevision(NewName, arg->cla_wbArg[n].wa_Name);
1925
1926 debugLock_d1(arg->cla_wbArg[n].wa_Lock);
1927 d1(kprintf("%s/%s/%ld: wa_Name=<%s>\n", __FILE__, __FUNC__, __LINE__, arg->cla_wbArg[n].wa_Name));
1928
1929 d1(kprintf("%s/%s/%ld: OldName=<%s> NewName=<%s>\n", __FILE__, __FUNC__, __LINE__, arg->cla_wbArg[n].wa_Name, NewName));
1930
1931 UndoAddEvent((struct internalScaWindowTask *) msg->WindowTask, UNDO_Copy,
1932 UNDOTAG_UndoMultiStep, undoStep,
1933 UNDOTAG_CopySrcDirLock, arg->cla_wbArg[n].wa_Lock,
1934 UNDOTAG_CopyDestDirLock, arg->cla_wbArg[n].wa_Lock,
1935 UNDOTAG_CopySrcName, arg->cla_wbArg[n].wa_Name,
1936 UNDOTAG_CopyDestName, NewName,
1937 TAG_END);
1938
1939 // clone file/drawer
1940 DoMethod(fileTransObj, SCCM_FileTrans_Copy,
1941 arg->cla_wbArg[n].wa_Lock, arg->cla_wbArg[n].wa_Lock,
1942 arg->cla_wbArg[n].wa_Name, NewName);
1943 }
1944 } while (0);
1945
1946 SCA_FreeWBArgs(arg->cla_wbArg, arg->cla_NumArgs, SCAF_FreeNames | SCAF_FreeLocks);
1947 ScalosFree(arg->cla_wbArg);
1948
1949 if (undoStep)
1950 UndoEndStep((struct internalScaWindowTask *) msg->WindowTask, undoStep);
1951 if (fileTransObj)
1952 SCA_DisposeScalosObject(fileTransObj);
1953 if (OldIconName)
1954 FreePathBuffer(OldIconName);
1955 if (NewName)
1956 FreePathBuffer(NewName);
1957
1958 return 0;
1959 }
1960
1961 //---------------------------------------------------------------------------------------
1962
1963 static void ThumbnailCacheCleanupProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
1964 {
1965 d1(KPrintF("%s/%s/%ld: START iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
1966
1967 ThumbnailsStartCleanup(TRUE);
1968 }
1969
1970 //---------------------------------------------------------------------------------------
1971
1972 static void UpdateProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
1973 {
1974 d1(KPrintF("%s/%s/%ld: START iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
1975
1976 DoMethod(iwt->iwt_WindowTask.mt_MainObject, SCCM_IconWin_Update);
1977 }
1978
1979 //---------------------------------------------------------------------------------------
1980
1981 static void CloseProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
1982 {
1983 iwt->iwt_CloseWindow = TRUE;
1984 }
1985
1986
1987 //---------------------------------------------------------------------------------------
1988
1989 static void FindProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
1990 {
1991 struct WBArg *wbArg;
1992
1993 d1(KPrintF("%s/%s/%ld: START iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
1994
1995 do {
1996 ULONG NumberOfWbArgs = 1;
1997 ULONG nArgs = 0;
1998 BOOL Success;
1999
2000 if (mcArg->mca_IconNode)
2001 NumberOfWbArgs += 1;
2002 else
2003 NumberOfWbArgs += SCA_CountWBArgs(mcArg->mca_IconNode);
2004
2005 wbArg = ScalosAlloc(NumberOfWbArgs * sizeof(struct WBArg));
2006 if (NULL == wbArg)
2007 return;
2008
2009 wbArg[0].wa_Name = (STRPTR) "Find.module";
2010 wbArg[0].wa_Lock = LockScaModsDir();
2011 if ((BPTR)NULL == wbArg[0].wa_Lock)
2012 break;
2013
2014 nArgs++;
2015 d1(KPrintF("%s/%s/%ld: nArgs=%ld\n", __FILE__, __FUNC__, __LINE__, nArgs));
2016
2017 if (NumberOfWbArgs > 1)
2018 {
2019 if (mcArg->mca_IconNode)
2020 {
2021 d1(KPrintF("%s/%s/%ld: NumberOfWbArgs=%ld\n", __FILE__, __FUNC__, __LINE__, NumberOfWbArgs));
2022 DoMethod(iwt->iwt_WindowTask.mt_MainObject, SCCM_IconWin_MakeWBArg,
2023 mcArg->mca_IconNode, &wbArg[1]);
2024 nArgs++;
2025 }
2026 else
2027 {
2028 d1(KPrintF("%s/%s/%ld: NumberOfWbArgs=%ld\n", __FILE__, __FUNC__, __LINE__, NumberOfWbArgs));
2029 nArgs += SCA_MakeWBArgs(&wbArg[1], NULL, NumberOfWbArgs - 1);
2030 }
2031 }
2032
2033 d1(KPrintF("%s/%s/%ld: nArgs=%ld\n", __FILE__, __FUNC__, __LINE__, nArgs));
2034
2035 // SCA_WBStart()
2036 Success = SCA_WBStartTags(wbArg, nArgs,
2037 SCA_Stacksize, CurrentPrefs.pref_DefaultStackSize,
2038 // SCA_Flags, SCAF_WBStart_Wait,
2039 // SCA_WaitTimeout, 0,
2040 TAG_END);
2041
2042 d1(KPrintF("%s/%s/%ld: Success=%ld\n", __FILE__, __FUNC__, __LINE__, Success));
2043
2044 if (NumberOfWbArgs > 1)
2045 {
2046 SCA_FreeWBArgs(&wbArg[1], nArgs - 1,
2047 Success ? SCAF_FreeNames : SCAF_FreeNames | SCAF_FreeLocks);
2048 }
2049 if (Success)
2050 wbArg[0].wa_Lock = (BPTR)NULL;
2051 } while (0);
2052
2053 d1(KPrintF("%s/%s/%ld: wbArg=%08lx\n", __FILE__, __FUNC__, __LINE__, wbArg));
2054
2055 if (wbArg)
2056 {
2057 if (wbArg[0].wa_Lock)
2058 UnLock(wbArg[0].wa_Lock);
2059
2060 ScalosFree(wbArg);
2061 }
2062
2063 d1(KPrintF("%s/%s/%ld: END iwt=%08lx iwt_WinTitle=<%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
2064 }
2065
2066 //---------------------------------------------------------------------------------------
2067
2068 static void FormatDiskProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
2069 {
2070 struct WBArg *wbArg;
2071
2072 d1(KPrintF("%s/%s/%ld: START iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
2073
2074 do {
2075 ULONG NumberOfWbArgs = 1;
2076 ULONG nArgs = 0;
2077 BOOL Success;
2078
2079 if (mcArg->mca_IconNode)
2080 NumberOfWbArgs += 1;
2081 else
2082 NumberOfWbArgs += SCA_CountWBArgs(mcArg->mca_IconNode);
2083
2084 wbArg = ScalosAlloc(NumberOfWbArgs * sizeof(struct WBArg));
2085 if (NULL == wbArg)
2086 return;
2087
2088 wbArg[0].wa_Name = (STRPTR) "Format_Disk.module";
2089 wbArg[0].wa_Lock = LockScaModsDir();
2090 if ((BPTR)NULL == wbArg[0].wa_Lock)
2091 break;
2092
2093 nArgs++;
2094
2095 if (NumberOfWbArgs > 1)
2096 {
2097 if (mcArg->mca_IconNode)
2098 {
2099 DoMethod(iwt->iwt_WindowTask.mt_MainObject, SCCM_IconWin_MakeWBArg,
2100 mcArg->mca_IconNode, &wbArg[1]
2101 );
2102 nArgs++;
2103 }
2104 else
2105 {
2106 nArgs += SCA_MakeWBArgs(&wbArg[1], NULL, NumberOfWbArgs - 1);
2107 }
2108 }
2109
2110 DoForAppIcons(AMCLASSICON_FormatDisk);
2111
2112 if (nArgs < 2)
2113 break;
2114
2115 // SCA_WBStart()
2116 Success = SCA_WBStartTags(wbArg, nArgs,
2117 SCA_Stacksize, CurrentPrefs.pref_DefaultStackSize,
2118 SCA_Flags, SCAF_WBStart_Wait,
2119 SCA_WaitTimeout, 0,
2120 TAG_END);
2121
2122 if (NumberOfWbArgs > 1)
2123 {
2124 SCA_FreeWBArgs(&wbArg[1], nArgs - 1,
2125 Success ? SCAF_FreeNames : SCAF_FreeNames | SCAF_FreeLocks);
2126 }
2127 if (Success)
2128 wbArg[0].wa_Lock = (BPTR)NULL;
2129 } while (0);
2130
2131 d1(KPrintF("%s/%s/%ld: START wbArg=%08lx\n", __FILE__, __FUNC__, __LINE__, wbArg));
2132
2133 if (wbArg)
2134 {
2135 if (wbArg[0].wa_Lock)
2136 UnLock(wbArg[0].wa_Lock);
2137
2138 ScalosFree(wbArg);
2139 }
2140
2141 d1(KPrintF("%s/%s/%ld: END iwt=%08lx iwt_WinTitle=<%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
2142 }
2143
2144
2145 static void ShutdownProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
2146 {
2147 BOOL Success;
2148 struct WBArg wbArg[2];
2149
2150 do {
2151 wbArg[0].wa_Name = (STRPTR) "Shutdown.module";
2152 wbArg[0].wa_Lock = LockScaModsDir();
2153 if ((BPTR)NULL == wbArg[0].wa_Lock)
2154 break;
2155
2156 // SCA_WBStart()
2157 Success = SCA_WBStartTags(wbArg, 1,
2158 SCA_Stacksize, CurrentPrefs.pref_DefaultStackSize,
2159 SCA_Flags, SCAF_WBStart_Wait,
2160 SCA_WaitTimeout, 0,
2161 TAG_END);
2162
2163 if (!Success)
2164 UnLock(wbArg[0].wa_Lock);
2165 } while (0);
2166 }
2167
2168 //---------------------------------------------------------------------------------------
2169
2170 static void ShowOnlyIconsProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
2171 {
2172 SetAttrs(iwt->iwt_WindowTask.mt_MainObject,
2173 SCCA_IconWin_ShowType, DDFLAGS_SHOWICONS,
2174 TAG_END);
2175 }
2176
2177 //---------------------------------------------------------------------------------------
2178
2179 static void ShowAllFilesProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
2180 {
2181 SetAttrs(iwt->iwt_WindowTask.mt_MainObject,
2182 SCCA_IconWin_ShowType, DDFLAGS_SHOWALL,
2183 TAG_END);
2184 }
2185
2186 //---------------------------------------------------------------------------------------
2187
2188 static void ShowDefaultProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
2189 {
2190 SetAttrs(iwt->iwt_WindowTask.mt_MainObject,
2191 SCCA_IconWin_ShowType, DDFLAGS_SHOWDEFAULT,
2192 TAG_END);
2193 }
2194
2195 //---------------------------------------------------------------------------------------
2196
2197 static void CleanupProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
2198 {
2199 struct Hook SortHook;
2200 struct ScaIconNode *in, *inNext;
2201
2202 if (!IsIwtViewByIcon(iwt))
2203 return;
2204
2205 ScalosLockIconListExclusive(iwt);
2206
2207 UndoAddEvent(iwt, UNDO_Cleanup,
2208 UNDOTAG_IconList, iwt->iwt_WindowTask.wt_IconList,
2209 UNDOTAG_WindowTask, iwt,
2210 UNDOTAG_CleanupMode, CLEANUP_Default,
2211 TAG_END);
2212
2213 for (in=iwt->iwt_WindowTask.wt_LateIconList; in; in=inNext)
2214 {
2215 inNext = (struct ScaIconNode *) in->in_Node.mln_Succ;
2216
2217 SCA_MoveIconNode(&iwt->iwt_WindowTask.wt_LateIconList, &iwt->iwt_WindowTask.wt_IconList, in);
2218 }
2219
2220 for (in=iwt->iwt_WindowTask.wt_IconList; in; in = (struct ScaIconNode *) in->in_Node.mln_Succ)
2221 {
2222 in->in_Flags &= ~INF_IconVisible;
2223
2224 in->in_OldLeftEdge = NO_ICON_POSITION_SHORT;
2225 in->in_OldTopEdge = NO_ICON_POSITION_SHORT;
2226 }
2227
2228 iwt->iwt_WindowTask.wt_LateIconList = iwt->iwt_WindowTask.wt_IconList;
2229 iwt->iwt_WindowTask.wt_IconList = NULL;
2230
2231 SETHOOKFUNC(SortHook, IconCompareFunc);
2232 SortHook.h_Data = NULL;
2233
2234 SCA_SortNodes((struct ScalosNodeList *) &iwt->iwt_WindowTask.wt_LateIconList, &SortHook, SCA_SortType_Best);
2235
2236 ScalosUnLockIconList(iwt);
2237
2238 iwt->iwt_WindowTask.wt_XOffset = iwt->iwt_WindowTask.wt_YOffset = 0;
2239 iwt->iwt_WindowTask.mt_WindowStruct->ws_xoffset = iwt->iwt_WindowTask.mt_WindowStruct->ws_yoffset = 0;
2240
2241 if (iwt->iwt_WindowTask.wt_Window)
2242 {
2243 EraseRect(iwt->iwt_WindowTask.wt_Window->RPort, 0, 0,
2244 iwt->iwt_WindowTask.wt_Window->Width - 1,
2245 iwt->iwt_WindowTask.wt_Window->Height -1);
2246
2247 DoMethod(iwt->iwt_WindowTask.mt_MainObject, SCCM_IconWin_CleanUp);
2248
2249 DoMethod(iwt->iwt_WindowTask.mt_MainObject, SCCM_IconWin_SetVirtSize,
2250 SETVIRTF_AdjustBottomSlider | SETVIRTF_AdjustRightSlider);
2251 }
2252 else
2253 {
2254 DoMethod(iwt->iwt_WindowTask.mt_MainObject, SCCM_IconWin_CleanUp);
2255 }
2256 }
2257
2258 //---------------------------------------------------------------------------------------
2259
2260 static void CleanupByNameProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
2261 {
2262 UndoAddEvent(iwt, UNDO_Cleanup,
2263 UNDOTAG_IconList, iwt->iwt_WindowTask.wt_IconList,
2264 UNDOTAG_WindowTask, iwt,
2265 UNDOTAG_CleanupMode, CLEANUP_ByName,
2266 TAG_END);
2267
2268 DoMethod(iwt->iwt_WindowTask.mt_MainObject, SCCM_IconWin_CleanUpByName);
2269 }
2270
2271 //---------------------------------------------------------------------------------------
2272
2273 static void CleanupByDateProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
2274 {
2275 UndoAddEvent(iwt, UNDO_Cleanup,
2276 UNDOTAG_IconList, iwt->iwt_WindowTask.wt_IconList,
2277 UNDOTAG_WindowTask, iwt,
2278 UNDOTAG_CleanupMode, CLEANUP_ByDate,
2279 TAG_END);
2280
2281 DoMethod(iwt->iwt_WindowTask.mt_MainObject, SCCM_IconWin_CleanUpByDate);
2282 }
2283
2284 //---------------------------------------------------------------------------------------
2285
2286 static void CleanupBySizeProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
2287 {
2288 UndoAddEvent(iwt, UNDO_Cleanup,
2289 UNDOTAG_IconList, iwt->iwt_WindowTask.wt_IconList,
2290 UNDOTAG_WindowTask, iwt,
2291 UNDOTAG_CleanupMode, CLEANUP_BySize,
2292 TAG_END);
2293
2294 DoMethod(iwt->iwt_WindowTask.mt_MainObject, SCCM_IconWin_CleanUpBySize);
2295 }
2296
2297 //---------------------------------------------------------------------------------------
2298
2299 static void CleanupByTypeProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
2300 {
2301 UndoAddEvent(iwt, UNDO_Cleanup,
2302 UNDOTAG_IconList, iwt->iwt_WindowTask.wt_IconList,
2303 UNDOTAG_WindowTask, iwt,
2304 UNDOTAG_CleanupMode, CLEANUP_ByType,
2305 TAG_END);
2306
2307 DoMethod(iwt->iwt_WindowTask.mt_MainObject, SCCM_IconWin_CleanUpByType);
2308 }
2309
2310 //---------------------------------------------------------------------------------------
2311
2312 static SAVEDS(LONG) IconCompareFunc(struct Hook *hook, struct ScaIconNode *in2, struct ScaIconNode *in1)
2313 {
2314 struct ExtGadget *gg1 = (struct ExtGadget *) in1->in_Icon;
2315 struct ExtGadget *gg2 = (struct ExtGadget *) in2->in_Icon;
2316 WORD xDiff, yDiff;
2317
2318 (void) hook;
2319
2320 d1(kprintf("%s/%s/%ld: in1=%08lx in2=%08lx\n", __FILE__, __FUNC__, __LINE__, in1, in2));
2321
2322 xDiff = gg1->LeftEdge - gg2->LeftEdge;
2323
2324 if (xDiff > 16)
2325 return -1;
2326 else if (xDiff < -16)
2327 return 1;
2328
2329 yDiff = gg1->TopEdge - gg2->TopEdge;
2330 if (yDiff < 0)
2331 return 1;
2332 else if (yDiff > 0)
2333 return -1;
2334
2335 return 0;
2336 }
2337
2338 //---------------------------------------------------------------------------------------
2339
2340 static void MenuOpenProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
2341 {
2342 ULONG IconType = 0;
2343
2344 if (mcArg->mca_IconNode)
2345 GetAttr(IDTA_Type, mcArg->mca_IconNode->in_Icon, &IconType);
2346
2347 if (WBAPPICON == IconType)
2348 {
2349 WindowSendAppIconMsg(iwt, AMCLASSICON_LeaveOut, mcArg->mca_IconNode);
2350 return;
2351 }
2352 else
2353 {
2354 d1(KPrintF("%s/%s/%ld: iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
2355
2356 DoMethod(iwt->iwt_WindowTask.mt_MainObject,
2357 SCCM_IconWin_Open,
2358 mcArg->mca_IconNode,
2359 ICONWINOPENF_IgnoreFileTypes);
2360 }
2361 }
2362
2363 //---------------------------------------------------------------------------------------
2364
2365 static void MenuOpenNewProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
2366 {
2367 d1(KPrintF("%s/%s/%ld: START iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
2368
2369 DoMethod(iwt->iwt_WindowTask.mt_MainObject,
2370 SCCM_IconWin_Open,
2371 mcArg->mca_IconNode,
2372 ICONWINOPENF_IgnoreFileTypes | ICONWINOPENF_NewWindow);
2373 }
2374
2375 //---------------------------------------------------------------------------------------
2376
2377 static void MenuOpenBrowserWindowProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
2378 {
2379 d1(KPrintF("%s/%s/%ld: START iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
2380
2381 DoMethod(iwt->iwt_WindowTask.mt_MainObject,
2382 SCCM_IconWin_Open,
2383 mcArg->mca_IconNode,
2384 ICONWINOPENF_IgnoreFileTypes | ICONWINOPENF_BrowserWindow);
2385 }
2386
2387 //---------------------------------------------------------------------------------------
2388
2389 static void OpenParentProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
2390 {
2391 struct ScaWindowStruct *ws = iwt->iwt_WindowTask.mt_WindowStruct;
2392 BPTR parentLock = (BPTR)NULL;
2393 STRPTR ParentName = NULL;
2394
2395 d1(KPrintF("%s/%s/%ld: START iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
2396
2397 do {
2398 if ((BPTR)NULL == ws->ws_Lock)
2399 break;
2400
2401 parentLock = ParentDir(ws->ws_Lock);
2402 if ((BPTR)NULL == parentLock)
2403 break;
2404
2405 ParentName = AllocPathBuffer();
2406 if (NULL == ParentName)
2407 break;
2408
2409 if (!NameFromLock(parentLock, ParentName, Max_PathLen))
2410 break;
2411
2412 d1(kprintf("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
2413
2414 if (ws->ws_Flags & WSV_FlagF_BrowserMode)
2415 {
2416 WindowNewPath(iwt, ParentName);
2417 }
2418 else
2419 {
2420 SCA_OpenIconWindowTags(SCA_Flags, SCAF_OpenWindow_ScalosPort,
2421 SCA_Path, (ULONG) ParentName,
2422 SCA_CheckOverlappingIcons, CurrentPrefs.pref_CheckOverlappingIcons,
2423 TAG_END);
2424 }
2425
2426 d1(kprintf("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
2427 } while (0);
2428
2429 if (ParentName)
2430 FreePathBuffer(ParentName);
2431 if (parentLock)
2432 UnLock(parentLock);
2433 }
2434
2435 //---------------------------------------------------------------------------------------
2436
2437 static void ExecuteCmdProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
2438 {
2439 CONST_STRPTR ProgramName;
2440 ULONG Result;
2441
2442 if (mcArg->mca_IconNode)
2443 ProgramName = GetIconName(mcArg->mca_IconNode);
2444 else
2445 ProgramName = "";
2446
2447 Result = CallTextInputHook(TIACTION_Execute, (STRPTR) ProgramName);
2448
2449 if (Result)
2450 {
2451 struct WBArg Args[2];
2452
2453 Args[0].wa_Lock = LockScaModsDir();
2454
2455 if (Args[0].wa_Lock)
2456 {
2457 Args[0].wa_Name = (STRPTR) "Execute_Command.module";
2458 Args[1].wa_Lock = DupLock(iwt->iwt_WindowTask.mt_WindowStruct->ws_Lock);
2459 Args[1].wa_Name = (STRPTR) ProgramName;
2460
2461 // SCA_WBStart()
2462 SCA_WBStartTags(Args, 2,
2463 SCA_Stacksize, CurrentPrefs.pref_DefaultStackSize,
2464 TAG_END);
2465 }
2466 }
2467 }
2468
2469 //---------------------------------------------------------------------------------------
2470
2471 static void LastMessageProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
2472 {
2473 SCA_ScreenTitleMsg((CONST_STRPTR) ~0, NULL);
2474 }
2475
2476 //---------------------------------------------------------------------------------------
2477
2478 static void IconifyProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
2479 {
2480 DoMethod(iwt->iwt_WindowTask.mt_WindowObject, SCCM_Window_Iconify);
2481 }
2482
2483 //---------------------------------------------------------------------------------------
2484
2485 static void RedrawProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
2486 {
2487 DoMethod(iwt->iwt_WindowTask.mt_MainObject, SCCM_IconWin_Redraw, REDRAWF_DontRefreshWindowFrame);
2488 }
2489
2490 //---------------------------------------------------------------------------------------
2491
2492 static void ResetScalosProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
2493 {
2494 struct MenuCmdArg DummyArg;
2495
2496 StartProgTask(iwt, &DummyArg, AsyncResetScalosProg, (struct MsgPort *) SCCV_RunProcess_NoReply);
2497 }
2498
2499 //---------------------------------------------------------------------------------------
2500
2501 static void AsyncResetScalosProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *dummy)
2502 {
2503 struct ScaWindowStruct *WinList = NULL;
2504 struct ScaWindowStruct *ws, *wsNext;
2505 struct MsgPort *ReplyPort;
2506 ULONG iLock;
2507
2508 d1(KPrintF("%s/%s/%ld: START iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
2509
2510 (void) dummy;
2511
2512 ReplyPort = CreateMsgPort();
2513
2514 d1(kprintf("%s/%s/%ld: ReplyPort=%08lx\n", __FILE__, __FUNC__, __LINE__, ReplyPort));
2515 if (ReplyPort)
2516 {
2517 struct SM_AppSleep *smas = (struct SM_AppSleep *) SCA_AllocMessage(MTYP_AppSleep, 0);
2518 if (smas)
2519 {
2520 smas->ScalosMessage.sm_Message.mn_ReplyPort = ReplyPort;
2521
2522 d1(kprintf("%s/%s/%ld: Before PutMsg\n", __FILE__, __FUNC__, __LINE__));
2523 PutMsg(iInfos.xii_iinfos.ii_MainMsgPort, &smas->ScalosMessage.sm_Message);
2524 d1(kprintf("%s/%s/%ld: After PutMsg\n", __FILE__, __FUNC__, __LINE__));
2525
2526 WaitReply(ReplyPort, iwt, MTYP_AppSleep);
2527 d1(kprintf("%s/%s/%ld: After WaitReply\n", __FILE__, __FUNC__, __LINE__));
2528 }
2529 }
2530
2531 SCA_LockWindowList(SCA_LockWindowList_Exclusiv);
2532 d1(kprintf("%s/%s/%ld: Window List Loecked\n", __FILE__, __FUNC__, __LINE__));
2533
2534 iLock = ScaLockIBase(0);
2535 d1(kprintf("%s/%s/%ld: iLock=%08lx\n", __FILE__, __FUNC__, __LINE__, iLock));
2536
2537 for (ws=winlist.wl_WindowStruct; ws; ws=wsNext)
2538 {
2539 wsNext = (struct ScaWindowStruct *) ws->ws_Node.mln_Succ;
2540
2541 if (ws->ws_Window)
2542 {
2543 BOOL Found = FALSE;
2544 struct Window *win;
2545
2546 for (win=iwt->iwt_WinScreen->FirstWindow; win; win=win->NextWindow)
2547 {
2548 if (win == ws->ws_Window)
2549 {
2550 Found = TRUE;
2551 break;
2552 }
2553 }
2554
2555 if (!Found)
2556 {
2557 SCA_MoveWSNode(&winlist.wl_WindowStruct, &WinList, ws);
2558 }
2559 }
2560 }
2561
2562 ScaUnlockIBase(iLock);
2563 d1(kprintf("%s/%s/%ld: After UnlockIBase\n", __FILE__, __FUNC__, __LINE__));
2564
2565 for (ws=WinList; ws; ws=wsNext)
2566 {
2567 wsNext = (struct ScaWindowStruct *) ws->ws_Node.mln_Succ;
2568
2569 d1(kprintf("%s/%s/%ld: ws=%08lx\n", __FILE__, __FUNC__, __LINE__, ws));
2570
2571 FreeBackFill(&((struct internalScaWindowTask *) ws->ws_WindowTask)->iwt_WindowTask.wt_PatternInfo);
2572 ScalosFree(ws->ws_WindowTask);
2573
2574 SCA_FreeNode((struct ScalosNodeList *)(APTR) &WinList, &ws->ws_Node);
2575 }
2576
2577 SCA_UnLockWindowList();
2578 d1(kprintf("%s/%s/%ld: Window List Unlocked\n", __FILE__, __FUNC__, __LINE__));
2579
2580 if (ReplyPort)
2581 {
2582 struct SM_AppWakeup *smaw = (struct SM_AppWakeup *) SCA_AllocMessage(MTYP_AppWakeup, 0);
2583 if (smaw)
2584 {
2585 smaw->ScalosMessage.sm_Message.mn_ReplyPort = ReplyPort;
2586 smaw->smaw_ReLayout = FALSE;
2587
2588 d1(kprintf("%s/%s/%ld: Before PutMsg\n", __FILE__, __FUNC__, __LINE__));
2589 PutMsg(iInfos.xii_iinfos.ii_MainMsgPort, &smaw->ScalosMessage.sm_Message);
2590 d1(kprintf("%s/%s/%ld: After PutMsg\n", __FILE__, __FUNC__, __LINE__));
2591
2592 WaitReply(ReplyPort, iwt, MTYP_AppWakeup);
2593 d1(kprintf("%s/%s/%ld: After WaitReply\n", __FILE__, __FUNC__, __LINE__));
2594 }
2595
2596 DeleteMsgPort(ReplyPort);
2597 }
2598
2599 d1(kprintf("%s/%s/%ld: END\n", __FILE__, __FUNC__, __LINE__));
2600 }
2601
2602 //---------------------------------------------------------------------------------------
2603
2604 static void MenuSnapshotProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
2605 {
2606 d1(KPrintF("%s/%s/%ld: START iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
2607 d1(kprintf("%s/%s/%ld: mca_IconNode=%08lx\n", __FILE__, __FUNC__, __LINE__, mcArg->mca_IconNode));
2608
2609 if (mcArg->mca_IconNode)
2610 {
2611 UndoAddEvent(iwt, UNDO_Snapshot,
2612 UNDOTAG_IconNode, mcArg->mca_IconNode,
2613 UNDOTAG_IconDirLock, mcArg->mca_IconNode->in_Lock ?
2614 mcArg->mca_IconNode->in_Lock :
2615 iwt->iwt_WindowTask.mt_WindowStruct->ws_Lock,
2616 UNDOTAG_SaveIcon, TRUE,
2617 TAG_END);
2618
2619 SCA_LockWindowList(SCA_LockWindowList_Shared);
2620 SnapshotIcon(iwt, mcArg->mca_IconNode, NULL);
2621 SCA_UnLockWindowList();
2622 }
2623 else
2624 {
2625 DoForAllWindowsShared(iwt, SnapshotIcon, NULL);
2626 }
2627 }
2628
2629 //---------------------------------------------------------------------------------------
2630
2631 static void MenuUnsnapshotProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
2632 {
2633 d1(KPrintF("%s/%s/%ld: START iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
2634 d1(KPrintF("%s/%s/%ld: mca_IconNode=%08lx\n", __FILE__, __FUNC__, __LINE__, mcArg->mca_IconNode));
2635
2636 if (mcArg->mca_IconNode)
2637 {
2638 UndoAddEvent(iwt, UNDO_Unsnapshot,
2639 UNDOTAG_IconNode, mcArg->mca_IconNode,
2640 UNDOTAG_IconDirLock, mcArg->mca_IconNode->in_Lock ?
2641 mcArg->mca_IconNode->in_Lock :
2642 iwt->iwt_WindowTask.mt_WindowStruct->ws_Lock,
2643 UNDOTAG_SaveIcon, TRUE,
2644 TAG_END);
2645
2646 SCA_LockWindowList(SCA_LockWindowList_Shared);
2647 UnsnapshotIcon(iwt, mcArg->mca_IconNode, TRUE, NULL);
2648 AfterUnsnapshotIcon(iwt);
2649 SCA_UnLockWindowList();
2650 }
2651 else
2652 {
2653 DoForAllWindowsShared(iwt, UnsnapshotIconAndSave, AfterUnsnapshotIcon);
2654 }
2655 }
2656
2657 //---------------------------------------------------------------------------------------
2658
2659 static void MenuUndoProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
2660 {
2661 d1(KPrintF("%s/%s/%ld: START iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
2662 d1(KPrintF("%s/%s/%ld: mca_IconNode=%08lx\n", __FILE__, __FUNC__, __LINE__, mcArg->mca_IconNode));
2663
2664 Undo(iwt);
2665 }
2666
2667 //---------------------------------------------------------------------------------------
2668
2669 static void MenuRedoProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
2670 {
2671 d1(KPrintF("%s/%s/%ld: START iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
2672 d1(KPrintF("%s/%s/%ld: mca_IconNode=%08lx\n", __FILE__, __FUNC__, __LINE__, mcArg->mca_IconNode));
2673
2674 Redo(iwt);
2675 }
2676
2677 //---------------------------------------------------------------------------------------
2678
2679 static void SnapshotIcon(struct internalScaWindowTask *iwt, struct ScaIconNode *in, APTR undoStep)
2680 {
2681 ULONG IconType = 0;
2682
2683 d1(KPrintF("%s/%s/%ld: START iwt=%08lx in=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, in, GetIconName(in)));
2684
2685 GetAttr(IDTA_Type, in->in_Icon, &IconType);
2686
2687 if (0 == IconType)
2688 return;
2689
2690 if (WBAPPICON == IconType)
2691 {
2692 WindowSendAppIconMsg(iwt, AMCLASSICON_Snapshot, in);
2693 return;
2694 }
2695 else
2696 {
2697 BPTR destDirLock;
2698
2699 SetIconWindowRect(in);
2700
2701 if (in->in_DeviceIcon)
2702 {
2703 destDirLock = DiskInfoLock(in);
2704
2705 if (destDirLock)
2706 {
2707 UndoAddEvent(iwt, UNDO_Snapshot,
2708 UNDOTAG_UndoMultiStep, undoStep,
2709 UNDOTAG_IconNode, in,
2710 UNDOTAG_IconDirLock, destDirLock,
2711 UNDOTAG_SaveIcon, TRUE,
2712 TAG_END);
2713
2714 ScalosPutIcon(in, destDirLock, in->in_Flags & INF_DefaultIcon);
2715
2716 UnLock(destDirLock);
2717 }
2718 }
2719 else
2720 {
2721 if (in->in_Lock)
2722 destDirLock = in->in_Lock;
2723 else
2724 destDirLock = iwt->iwt_WindowTask.mt_WindowStruct->ws_Lock;
2725
2726 UndoAddEvent(iwt, UNDO_Snapshot,
2727 UNDOTAG_UndoMultiStep, undoStep,
2728 UNDOTAG_IconNode, in,
2729 UNDOTAG_IconDirLock, destDirLock,
2730 UNDOTAG_SaveIcon, TRUE,
2731 TAG_END);
2732
2733 ScalosPutIcon(in, destDirLock, in->in_Flags & INF_DefaultIcon);
2734 }
2735
2736 in->in_Flags &= ~INF_FreeIconPosition;
2737 in->in_SupportFlags |= INF_SupportsUnSnapshot;
2738 }
2739
2740 d1(KPrintF("%s/%s/%ld: END in=%08lx <%s> inFlags=%08lx\n", __FILE__, __FUNC__, __LINE__, in, GetIconName(in), in->in_Flags));
2741 }
2742
2743 //---------------------------------------------------------------------------------------
2744
2745 static void UnsnapshotIconAndSave(struct internalScaWindowTask *iwt, struct ScaIconNode *in, APTR undoStep)
2746 {
2747 UnsnapshotIcon(iwt, in, TRUE, undoStep);
2748 }
2749
2750 //---------------------------------------------------------------------------------------
2751
2752 static void UnsnapshotIcon(struct internalScaWindowTask *iwt,
2753 struct ScaIconNode *in, BOOL SaveIcon, APTR undoStep)
2754 {
2755 ULONG IconType = 0;
2756
2757 d1(KPrintF("%s/%s/%ld: iwt=%08lx in=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, in, GetIconName(in)));
2758
2759 GetAttr(IDTA_Type, in->in_Icon, &IconType);
2760
2761 if (0 == IconType)
2762 return;
2763
2764 if (WBAPPICON == IconType)
2765 {
2766 WindowSendAppIconMsg(iwt, AMCLASSICON_UnSnapshot, in);
2767 return;
2768 }
2769 else
2770 {
2771 struct ExtGadget *gg = (struct ExtGadget *) in->in_Icon;
2772 BPTR destDirLock;
2773 WORD LeftEdge, TopEdge;
2774
2775 d1(kprintf("%s/%s/%ld:\n", __FILE__, __FUNC__, __LINE__));
2776
2777 SetIconWindowRect(in);
2778
2779 d1(kprintf("%s/%s/%ld:\n", __FILE__, __FUNC__, __LINE__));
2780
2781 LeftEdge = gg->LeftEdge;
2782 TopEdge = gg->TopEdge;
2783
2784 if (in->in_DeviceIcon)
2785 {
2786 destDirLock = DiskInfoLock(in);
2787
2788 d1(kprintf("%s/%s/%ld:\n", __FILE__, __FUNC__, __LINE__));
2789
2790 if (destDirLock)
2791 {
2792 UndoAddEvent(iwt, UNDO_Unsnapshot,
2793 UNDOTAG_UndoMultiStep, undoStep,
2794 UNDOTAG_IconNode, in,
2795 UNDOTAG_IconDirLock, destDirLock,
2796 UNDOTAG_SaveIcon, SaveIcon,
2797 TAG_END);
2798
2799 gg->LeftEdge = gg->TopEdge = NO_ICON_POSITION_SHORT;
2800
2801 if (SaveIcon)
2802 ScalosPutIcon(in, destDirLock, in->in_Flags & INF_DefaultIcon);
2803
2804 UnLock(destDirLock);
2805 }
2806 }
2807 else
2808 {
2809 d1(kprintf("%s/%s/%ld:\n", __FILE__, __FUNC__, __LINE__));
2810
2811 if (in->in_Lock)
2812 destDirLock = in->in_Lock;
2813 else
2814 destDirLock = iwt->iwt_WindowTask.mt_WindowStruct->ws_Lock;
2815
2816 d1(kprintf("%s/%s/%ld:\n", __FILE__, __FUNC__, __LINE__));
2817
2818 UndoAddEvent(iwt, UNDO_Unsnapshot,
2819 UNDOTAG_UndoMultiStep, undoStep,
2820 UNDOTAG_IconNode, in,
2821 UNDOTAG_IconDirLock, destDirLock,
2822 UNDOTAG_SaveIcon, SaveIcon,
2823 TAG_END);
2824
2825 gg->LeftEdge = gg->TopEdge = NO_ICON_POSITION_SHORT;
2826
2827 if (SaveIcon)
2828 ScalosPutIcon(in, destDirLock, in->in_Flags & INF_DefaultIcon);
2829
2830 d1(kprintf("%s/%s/%ld:\n", __FILE__, __FUNC__, __LINE__));
2831 }
2832
2833 gg->LeftEdge = LeftEdge;
2834 gg->TopEdge = TopEdge;
2835
2836 in->in_Flags |= INF_FreeIconPosition;
2837 in->in_SupportFlags |= INF_SupportsSnapshot;
2838 in->in_SupportFlags &= ~INF_SupportsUnSnapshot;
2839 }
2840
2841 d1(KPrintF("%s/%s/%ld: in=%08lx <%s> inFlags=%08lx\n", __FILE__, __FUNC__, __LINE__, in, GetIconName(in), in->in_Flags));
2842 }
2843
2844 //---------------------------------------------------------------------------------------
2845
2846 static void AfterUnsnapshotIcon(struct internalScaWindowTask *iwt)
2847 {
2848 d1(KPrintF("%s/%s/%ld:START\n", __FILE__, __FUNC__, __LINE__));
2849
2850 if (IsIwtViewByIcon(iwt))
2851 {
2852 DoMethod(iwt->iwt_WindowTask.mt_MainObject, SCCM_IconWin_UnCleanUp);
2853 d1(KPrintF("%s/%s/%ld:\n", __FILE__, __FUNC__, __LINE__));
2854 DoMethod(iwt->iwt_WindowTask.mt_MainObject, SCCM_IconWin_CleanUp);
2855 d1(KPrintF("%s/%s/%ld:\n", __FILE__, __FUNC__, __LINE__));
2856 DoMethod(iwt->iwt_WindowTask.mt_MainObject, SCCM_IconWin_SetVirtSize,
2857 SETVIRTF_AdjustBottomSlider | SETVIRTF_AdjustRightSlider);
2858 }
2859
2860 d1(KPrintF("%s/%s/%ld:END\n", __FILE__, __FUNC__, __LINE__));
2861 }
2862
2863 //---------------------------------------------------------------------------------------
2864
2865 void SetIconWindowRect(struct ScaIconNode *in)
2866 {
2867 if (in->in_Lock)
2868 {
2869 BPTR oldDir = CurrentDir(in->in_Lock);
2870
2871 SetRect(in);
2872
2873 CurrentDir(oldDir);
2874 }
2875 else
2876 {
2877 ULONG IconType = 0;
2878
2879 GetAttr(IDTA_Type, in->in_Icon, &IconType);
2880
2881 if (WBDISK == IconType)
2882 {
2883 SetRect2(in, DiskInfoLock(in));
2884 }
2885 else
2886 SetRect(in);
2887 }
2888 }
2889
2890 //---------------------------------------------------------------------------------------
2891
2892 static void SetRect(struct ScaIconNode *in)
2893 {
2894 if (in->in_Name)
2895 {
2896 BPTR iconLock = Lock((STRPTR) GetIconName(in), ACCESS_READ);
2897
2898 if (iconLock)
2899 {
2900 SetRect2(in, iconLock);
2901 UnLock(iconLock);
2902 }
2903 }
2904 }
2905
2906 //---------------------------------------------------------------------------------------
2907
2908 static void SetRect2(struct ScaIconNode *in, BPTR iconLock)
2909 {
2910 if (iconLock)
2911 {
2912 struct ScaWindowStruct *ws;
2913
2914 SCA_LockWindowList(SCA_LockWindowList_Shared);
2915
2916 for (ws=winlist.wl_WindowStruct; ws; ws = (struct ScaWindowStruct *) ws->ws_Node.mln_Succ)
2917 {
2918 if (LOCK_SAME == ScaSameLock(iconLock, ws->ws_Lock))
2919 {
2920 ULONG ddFlags;
2921 struct IBox WinRect;
2922 ULONG IconViewMode = TranslateViewModesToIcon(ws->ws_Viewmodes);
2923
2924 WinRect.Left = ws->ws_Left;
2925 WinRect.Top = ws->ws_Top;
2926 WinRect.Width = ws->ws_Width;
2927 WinRect.Height = ws->ws_Height;
2928
2929 ddFlags = ws->ws_ViewAll;
2930 if (SortOrder_Ascending == ws->ws_SortOrder)
2931 ddFlags |= DDFLAGS_SORTASC;
2932 else if (SortOrder_Descending == ws->ws_SortOrder)
2933 ddFlags |= DDFLAGS_SORTDESC;
2934
2935 d1(KPrintF("%s/%s/%ld: ws_ViewAll=%04lx ddFlags=%08lx\n", __FILE__, __FUNC__, __LINE__, ws->ws_ViewAll, ddFlags));
2936
2937 SetAttrs(in->in_Icon,
2938 IDTA_ViewModes, IconViewMode,
2939 IDTA_Flags, ddFlags,
2940 IDTA_WindowRect, (ULONG) &WinRect,
2941 IDTA_WinCurrentY, ws->ws_yoffset,
2942 IDTA_WinCurrentX, ws->ws_xoffset,
2943 TAG_END);
2944 }
2945 }
2946
2947 SCA_UnLockWindowList();
2948 }
2949 }
2950
2951
2952 static void SnapshotAllProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
2953 {
2954 struct ScaIconNode *in;
2955
2956 ScalosLockIconListShared(iwt);
2957
2958 if (IsIwtViewByIcon(iwt))
2959 {
2960 APTR undoStep = UndoBeginStep();
2961
2962 for (in=iwt->iwt_WindowTask.wt_IconList; in; in = (struct ScaIconNode *) in->in_Node.mln_Succ)
2963 {
2964 SnapshotIcon(iwt, in, undoStep);
2965 }
2966 UndoEndStep(iwt, undoStep);
2967 }
2968
2969 ScalosUnLockIconList(iwt);
2970
2971 SnapshotWindowProg(iwt, mcArg);
2972 }
2973
2974 //---------------------------------------------------------------------------------------
2975
2976 static void SnapshotWindowProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
2977 {
2978 if (iInfos.xii_iinfos.ii_MainWindowStruct == iwt->iwt_WindowTask.mt_WindowStruct)
2979 WriteWBConfig();
2980 else
2981 SnapshotWindow(iwt);
2982 }
2983
2984 //---------------------------------------------------------------------------------------
2985
2986 static void LeaveOutProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
2987 {
2988 d1(kprintf("%s/%s/%ld: mca_IconNode=%08lx\n", __FILE__, __FUNC__, __LINE__, mcArg->mca_IconNode));
2989
2990 if (mcArg->mca_IconNode)
2991 {
2992 SCA_LockWindowList(SCA_LockWindowList_Shared);
2993 LeaveOutIcon(iwt, mcArg->mca_IconNode, NULL);
2994 SCA_UnLockWindowList();
2995 }
2996 else
2997 {
2998 DoForAllWindows(iwt, LeaveOutIcon);
2999 }
3000 }
3001
3002 //---------------------------------------------------------------------------------------
3003
3004 static void PutAwayProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
3005 {
3006 d1(kprintf("%s/%s/%ld: mca_IconNode=%08lx\n", __FILE__, __FUNC__, __LINE__, mcArg->mca_IconNode));
3007
3008 if (mcArg->mca_IconNode)
3009 {
3010 SCA_LockWindowList(SCA_LockWindowList_Shared);
3011 PutAwayIconNode(iwt, mcArg->mca_IconNode, NULL);
3012 SCA_UnLockWindowList();
3013 }
3014 else
3015 {
3016 DoForAllWindows(iwt, PutAwayIconNode);
3017 }
3018 }
3019
3020 //---------------------------------------------------------------------------------------
3021
3022 static void EmptyTrashProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
3023 {
3024 BOOL Success = FALSE;
3025 struct WBArg *wbArg;
3026 ULONG nArgs = 0;
3027
3028 do {
3029 ULONG NumberOfWbArgs = 1;
3030
3031 if (mcArg->mca_IconNode)
3032 NumberOfWbArgs += 1;
3033 else
3034 NumberOfWbArgs += SCA_CountWBArgs(mcArg->mca_IconNode);
3035
3036 wbArg = ScalosAlloc(NumberOfWbArgs * sizeof(struct WBArg));
3037 if (NULL == wbArg)
3038 return;
3039
3040 wbArg[0].wa_Name = (STRPTR) "Empty_Trashcan.module";
3041 wbArg[0].wa_Lock = LockScaModsDir();
3042 if ((BPTR)NULL == wbArg[0].wa_Lock)
3043 break;
3044
3045 nArgs++;
3046
3047 if (NumberOfWbArgs > 1)
3048 {
3049 if (mcArg->mca_IconNode)
3050 {
3051 ULONG IconType;
3052
3053 GetAttr(IDTA_Type, mcArg->mca_IconNode->in_Icon, &IconType);
3054
3055 if (WBGARBAGE != IconType)
3056 break;
3057
3058 DoMethod(iwt->iwt_WindowTask.mt_MainObject, SCCM_IconWin_MakeWBArg,
3059 mcArg->mca_IconNode, &wbArg[1]
3060 );
3061 nArgs++;
3062 }
3063 else
3064 {
3065 struct ScaWindowStruct *ws;
3066 struct WBArg *WBArgPtr = &wbArg[1];
3067
3068 SCA_LockWindowList(SCA_LockWindowList_Shared);
3069
3070 for (ws=winlist.wl_WindowStruct; ws; ws = (struct ScaWindowStruct *) ws->ws_Node.mln_Succ)
3071 {
3072 struct internalScaWindowTask *iwtx = (struct internalScaWindowTask *) ws->ws_WindowTask;
3073 struct ScaIconNode *in;
3074
3075 ScalosLockIconListShared(iwtx);
3076
3077 for (in=iwtx->iwt_WindowTask.wt_IconList; in; in = (struct ScaIconNode *) in->in_Node.mln_Succ)
3078 {
3079 struct ExtGadget *gg = (struct ExtGadget *) in->in_Icon;
3080
3081 if (gg->Flags & GFLG_SELECTED)
3082 {
3083 ULONG IconType;
3084
3085 GetAttr(IDTA_Type, in->in_Icon, &IconType);
3086
3087 if (WBGARBAGE == IconType)
3088 {
3089 if (DoMethod(iwt->iwt_WindowTask.mt_MainObject, SCCM_IconWin_MakeWBArg,
3090 in, WBArgPtr))
3091 {
3092 nArgs++;
3093 WBArgPtr++;
3094 }
3095 }
3096 }
3097 }
3098
3099 ScalosUnLockIconList(iwtx);
3100 }
3101
3102 SCA_UnLockWindowList();
3103 }
3104 }
3105
3106 DoForAppIcons(AMCLASSICON_EmptyTrash);
3107
3108 if (nArgs < 2)
3109 break;
3110
3111 ScalosObtainSemaphoreShared(&DeleteHookSemaphore);
3112
3113 if (globalDeleteHook)
3114 {
3115 Success = CallGlobalDeleteHook(&wbArg[1], nArgs - 1, DLACTION_BeginEmptyTrash);
3116 }
3117
3118 ScalosReleaseSemaphore(&DeleteHookSemaphore);
3119
3120 if (!Success)
3121 {
3122 // SCA_WBStart()
3123 Success = SCA_WBStartTags(wbArg, nArgs,
3124 SCA_Stacksize, CurrentPrefs.pref_DefaultStackSize,
3125 SCA_Flags, SCAF_WBStart_Wait,
3126 SCA_WaitTimeout, 0,
3127 TAG_END);
3128
3129 if (NumberOfWbArgs > 1)
3130 {
3131 SCA_FreeWBArgs(&wbArg[1], nArgs - 1,
3132 Success ? SCAF_FreeNames : SCAF_FreeNames | SCAF_FreeLocks);
3133 }
3134 if (Success)
3135 wbArg[0].wa_Lock = (BPTR)NULL;
3136
3137 }
3138
3139 DoMethod(iwt->iwt_WindowTask.mt_MainObject, SCCM_IconWin_ImmediateCheckUpdate);
3140 } while (0);
3141
3142 if (wbArg)
3143 {
3144 if (wbArg[0].wa_Lock)
3145 UnLock(wbArg[0].wa_Lock);
3146
3147 ScalosFree(wbArg);
3148 }
3149 }
3150
3151 //---------------------------------------------------------------------------------------
3152
3153 static void CloseWindowProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
3154 {
3155 iwt->iwt_CloseWindow = TRUE;
3156 }
3157
3158 //---------------------------------------------------------------------------------------
3159
3160 static ULONG FindIconType(struct WBArg *Arg)
3161 {
3162 struct ScaWindowStruct *ws;
3163 ULONG IconType = 0;
3164 BOOL Found = FALSE;
3165
3166 SCA_LockWindowList(SCA_LockWindowList_Shared);
3167
3168 for (ws=winlist.wl_WindowStruct; !Found && ws; ws = (struct ScaWindowStruct *) ws->ws_Node.mln_Succ)
3169 {
3170 struct internalScaWindowTask *iwt = (struct internalScaWindowTask *) ws->ws_WindowTask;
3171
3172 if (ws->ws_Lock)
3173 {
3174 if (LOCK_SAME == ScaSameLock(Arg->wa_Lock, ws->ws_Lock))
3175 {
3176 struct ScaIconNode *in;
3177
3178 ScalosLockIconListShared(iwt);
3179
3180 for (in=iwt->iwt_WindowTask.wt_IconList; !Found && in; in = (struct ScaIconNode *) in->in_Node.mln_Succ)
3181 {
3182 if (0 == strcmp(Arg->wa_Name, GetIconName(in)))
3183 {
3184 GetAttr(IDTA_Type, in->in_Icon, &IconType);
3185 Found = TRUE;
3186 }
3187 }
3188
3189 ScalosUnLockIconList(iwt);
3190 }
3191 }
3192 else
3193 {
3194 struct ScaIconNode *in;
3195
3196 ScalosLockIconListShared(iwt);
3197
3198 for (in=iwt->iwt_WindowTask.wt_IconList; !Found && in; in = (struct ScaIconNode *) in->in_Node.mln_Succ)
3199 {
3200 if (in->in_DeviceIcon)
3201 {
3202 if ((BPTR)NULL == Arg->wa_Lock
3203 && (0 == strcmp(Arg->wa_Name, GetIconName(in))))
3204 {
3205 GetAttr(IDTA_Type, in->in_Icon, &IconType);
3206 Found = TRUE;
3207 }
3208 }
3209 if (in->in_Lock)
3210 {
3211 if (LOCK_SAME == ScaSameLock(in->in_Lock, Arg->wa_Lock)
3212 && (0 == strcmp(Arg->wa_Name, GetIconName(in))))
3213 {
3214 GetAttr(IDTA_Type, in->in_Icon, &IconType);
3215 Found = TRUE;
3216 }
3217 }
3218
3219 }
3220
3221 ScalosUnLockIconList(iwt);
3222 }
3223 }
3224
3225 SCA_UnLockWindowList();
3226
3227 return IconType;
3228 }
3229
3230 //---------------------------------------------------------------------------------------
3231
3232 static BOOL CallGlobalDeleteHook(struct WBArg *wbArg, ULONG nArgs, ULONG Action)
3233 {
3234 BOOL Success = FALSE;
3235 ULONG Result;
3236
3237 do {
3238 ULONG n;
3239 struct DeleteBeginMsg dbm;
3240 struct DeleteEndMsg dem;
3241
3242 dbm.dbm_Length = sizeof(dbm);
3243 dbm.dbm_Action = Action;
3244
3245 Result = CallHookPkt(globalDeleteHook, NULL, &dbm);
3246 if (RETURN_OK != Result)
3247 break;
3248
3249 for (n=0; n<nArgs; n++)
3250 {
3251 struct DeleteDataMsg ddm;
3252 BOOL isDrawer;
3253 BOOL isTrashcan = FALSE;
3254
3255 switch (FindIconType(&wbArg[n]))
3256 {
3257 case WBGARBAGE:
3258 isTrashcan = TRUE;
3259 isDrawer = TRUE;
3260 break;
3261 case WBDRAWER:
3262 case WBDEVICE:
3263 case WBKICK:
3264 case WB_TEXTICON_DRAWER:
3265 isDrawer = TRUE;
3266 break;
3267 default:
3268 isDrawer = FALSE;
3269 break;
3270 }
3271
3272 ddm.ddm_Length = sizeof(ddm);
3273 ddm.ddm_Action = isDrawer ? DLACTION_DeleteContents : DLACTION_DeleteObject;
3274 ddm.ddm_Lock = wbArg[n].wa_Lock;
3275 ddm.ddm_Name = wbArg[n].wa_Name;
3276
3277 d1(kprintf("%s/%s/%ld: ddm.ddm_Name=<%s>\n", __FILE__, __FUNC__, __LINE__, ddm.ddm_Name));
3278 debugLock_d1(ddm.ddm_Lock);
3279
3280 Result = CallHookPkt(globalDeleteHook, NULL, &ddm);
3281 if (RETURN_OK != Result)
3282 break;
3283
3284 if (isDrawer && !isTrashcan)
3285 {
3286 ddm.ddm_Length = sizeof(ddm);
3287 ddm.ddm_Action = DLACTION_DeleteObject;
3288 ddm.ddm_Lock = wbArg[n].wa_Lock;
3289 ddm.ddm_Name = wbArg[n].wa_Name;
3290
3291 d1(kprintf("%s/%s/%ld: ddm.ddm_Name=<%s>\n", __FILE__, __FUNC__, __LINE__, ddm.ddm_Name));
3292 debugLock_d1(ddm.ddm_Lock);
3293
3294 Result = CallHookPkt(globalDeleteHook, NULL, &ddm);
3295 }
3296 }
3297
3298 if (RETURN_OK != Result)
3299 break;
3300
3301 dem.dem_Length = sizeof(dem);
3302 dem.dem_Action = DLACTION_End;
3303
3304 Result = CallHookPkt(globalDeleteHook, NULL, &dem);
3305
3306 if (RETURN_OK != Result)
3307 break;
3308
3309 Success = TRUE;
3310 SCA_FreeWBArgs(wbArg, nArgs, SCAF_FreeNames | SCAF_FreeLocks);
3311 } while (0);
3312
3313 return Success;
3314 }
3315
3316 //---------------------------------------------------------------------------------------
3317
3318 // Workaround for broken "delete.module" implementations.
3319 // every directory WBArg gets changed
3320 // from <Lock to Parent-Dir> <Directory-Name>
3321 // to <Lock to Directory> <empty-Name>
3322 static void DeleteModuleKludge(struct WBArg *wbArg, ULONG nArgs)
3323 {
3324 T_ExamineData *fib;
3325
3326 d1(kprintf("%s/%s/%ld: START fib=%08lx\n", __FILE__, __FUNC__, __LINE__, fib));
3327
3328 if (ScalosExamineBegin(&fib))
3329 {
3330 ULONG n;
3331
3332 // do not change wbArg[0] here!
3333 for (n=1; n<nArgs; n++)
3334 {
3335 BPTR oldDir;
3336 BPTR oldLock = (BPTR)NULL;
3337 BPTR dirLock;
3338
3339 oldDir = CurrentDir(wbArg[n].wa_Lock);
3340
3341 dirLock = Lock(wbArg[n].wa_Name, ACCESS_READ);
3342 if (dirLock)
3343 {
3344 if (ScalosExamineLock(dirLock, &fib) && ScalosExamineIsDrawer(fib))
3345 {
3346 FreeCopyString(wbArg[n].wa_Name);
3347 oldLock = wbArg[n].wa_Lock;
3348
3349 wbArg[n].wa_Lock = DupLock(dirLock);
3350 wbArg[n].wa_Name = AllocCopyString("");
3351 }
3352
3353 UnLock(dirLock);
3354 }
3355
3356 CurrentDir(oldDir);
3357
3358 if (oldLock)
3359 UnLock(oldLock);
3360
3361 d1(kprintf("%s/%s/%ld: wa_Name=<%s>\n", __FILE__, __FUNC__, __LINE__, wbArg[n].wa_Name));
3362 debugLock_d1(wbArg[n].wa_Lock);
3363 }
3364
3365 ScalosExamineEnd(&fib);
3366 }
3367 }
3368
3369 //---------------------------------------------------------------------------------------
3370
3371 static void MenuCopyProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
3372 {
3373 d1(kprintf("%s/%s/%ld: mca_IconNode=%08lx\n", __FILE__, __FUNC__, __LINE__, mcArg->mca_IconNode));
3374
3375 DoMethod(iwt->iwt_WindowTask.mt_MainObject, SCCM_ClearClipboard);
3376
3377 if (mcArg->mca_IconNode)
3378 {
3379 SCA_LockWindowList(SCA_LockWindowList_Shared);
3380 RememberFilesToCopy(iwt, mcArg->mca_IconNode, NULL);
3381 SCA_UnLockWindowList();
3382 }
3383 else
3384 {
3385 DoForAllWindowsShared(iwt, RememberFilesToCopy, NULL);
3386 }
3387 }
3388
3389 //---------------------------------------------------------------------------------------
3390
3391 static void MenuCutProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
3392 {
3393 d1(kprintf("%s/%s/%ld: mca_IconNode=%08lx\n", __FILE__, __FUNC__, __LINE__, mcArg->mca_IconNode));
3394
3395 DoMethod(iwt->iwt_WindowTask.mt_MainObject, SCCM_ClearClipboard);
3396
3397 if (mcArg->mca_IconNode)
3398 {
3399 SCA_LockWindowList(SCA_LockWindowList_Shared);
3400 RememberFilesToCut(iwt, mcArg->mca_IconNode, NULL);
3401 SCA_UnLockWindowList();
3402 }
3403 else
3404 {
3405 DoForAllWindowsShared(iwt, RememberFilesToCut, NULL);
3406 }
3407 }
3408
3409 //---------------------------------------------------------------------------------------
3410
3411 static void MenuPasteProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
3412 {
3413 d1(kprintf("%s/%s/%ld: Obtain WindowSemaphore iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
3414
3415 ScalosObtainSemaphoreShared(iwt->iwt_WindowTask.wt_WindowSemaphore); // prevent window from closing
3416
3417 StartProgTask(iwt, mcArg, AsyncPasteProg, SCCV_RunProcess_NoReply);
3418
3419 d1(kprintf("%s/%s/%ld: Release WindowSemaphore iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
3420
3421 ScalosReleaseSemaphore(iwt->iwt_WindowTask.wt_WindowSemaphore);
3422 }
3423
3424 //---------------------------------------------------------------------------------------
3425
3426 static void AsyncPasteProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
3427 {
3428 Object *fileTransObj;
3429 BPTR DestLock = (BPTR)NULL;
3430 APTR undoStep = NULL;
3431
3432 d1(kprintf("%s/%s/%ld: mca_IconNode=%08lx\n", __FILE__, __FUNC__, __LINE__, mcArg->mca_IconNode));
3433
3434 if (mcArg->mca_IconNode)
3435 {
3436 BPTR parentDirLock;
3437 BPTR newLock = (BPTR)NULL;
3438 ULONG IconType = 0;
3439
3440 d1(kprintf("%s/%s/%ld: mca_IconNode=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, mcArg->mca_IconNode, GetIconName(mcArg->mca_IconNode)));
3441
3442 GetAttr(IDTA_Type, mcArg->mca_IconNode->in_Icon, &IconType);
3443
3444 switch (IconType)
3445 {
3446 case WBDISK:
3447 case WBDRAWER:
3448 case WBDEVICE:
3449 case WBGARBAGE: // +++ JMC 26.11.2004
3450 case WB_TEXTICON_DRAWER:
3451 if (mcArg->mca_IconNode->in_DeviceIcon)
3452 {
3453 parentDirLock = newLock = DiskInfoLock(mcArg->mca_IconNode);
3454 }
3455 else
3456 {
3457 if (mcArg->mca_IconNode->in_Lock)
3458 parentDirLock = mcArg->mca_IconNode->in_Lock;
3459 else
3460 parentDirLock = iwt->iwt_WindowTask.mt_WindowStruct->ws_Lock;
3461 }
3462
3463 debugLock_d1(parentDirLock);
3464
3465 if (parentDirLock)
3466 {
3467 BPTR oldDir= CurrentDir(parentDirLock);
3468
3469 DestLock = Lock((STRPTR) GetIconName(mcArg->mca_IconNode), ACCESS_READ);
3470 debugLock_d1(DestLock);
3471
3472 CurrentDir(oldDir);
3473 }
3474 break;
3475 }
3476
3477 if (newLock)
3478 UnLock(newLock);
3479 }
3480
3481 if ((BPTR)NULL == DestLock)
3482 DestLock = iwt->iwt_WindowTask.mt_WindowStruct->ws_Lock;
3483
3484 debugLock_d1(DestLock);
3485
3486 fileTransObj = SCA_NewScalosObjectTags((STRPTR) "FileTransfer.sca",
3487 SCCA_FileTrans_Screen, (ULONG) iInfos.xii_iinfos.ii_Screen,
3488 // SCCA_FileTrans_Number, ArgCount,
3489 SCCA_FileTrans_ReplaceMode, SCCV_ReplaceMode_Ask,
3490 TAG_END);
3491
3492 if (fileTransObj)
3493 {
3494 struct FileTransArg *fta;
3495 ULONG Result = RETURN_OK;
3496
3497 undoStep = UndoBeginStep();
3498
3499 while (RETURN_OK == Result)
3500 {
3501 CONST_STRPTR destName;
3502 STRPTR destNameCopy = NULL;
3503 size_t len;
3504
3505 ScalosObtainSemaphore(&ClipboardSemaphore);
3506 fta = (struct FileTransArg *) RemHead(&globalCopyClipBoard);
3507 ScalosReleaseSemaphore(&ClipboardSemaphore);
3508
3509 if (NULL == fta)
3510 break;
3511
3512 debugLock_d1(fta->ftarg_Arg.wa_Lock);
3513 d1(kprintf("%s/%s/%ld: ftarg_Arg.wa_Name=<%s> OpCode=%ld\n", \
3514 __FILE__, __FUNC__, __LINE__, fta->ftarg_Arg.wa_Name, fta->ftarg_Opcode));
3515
3516 switch (fta->ftarg_Opcode)
3517 {
3518 case FTOPCODE_Copy:
3519 len = strlen(fta->ftarg_Arg.wa_Name);
3520 destName = fta->ftarg_Arg.wa_Name;
3521 if (':' == destName[len - 1])
3522 {
3523 // Replace trailing ":" by "/" for copying volumes/disks to directories
3524
3525 destNameCopy = AllocCopyString(destName);
3526 if (destNameCopy)
3527 {
3528 fta->ftarg_Arg.wa_Name[0] = '\0';
3529
3530 destName = destNameCopy;
3531 StripTrailingColon(destNameCopy);
3532 }
3533 }
3534
3535 UndoAddEvent(iwt, UNDO_Copy,
3536 UNDOTAG_UndoMultiStep, undoStep,
3537 UNDOTAG_CopySrcDirLock, fta->ftarg_Arg.wa_Lock,
3538 UNDOTAG_CopyDestDirLock, DestLock,
3539 UNDOTAG_CopySrcName, fta->ftarg_Arg.wa_Name,
3540 UNDOTAG_CopyDestName, destName,
3541 TAG_END);
3542
3543 Result = DoMethod(fileTransObj, SCCM_FileTrans_Copy,
3544 fta->ftarg_Arg.wa_Lock, DestLock,
3545 fta->ftarg_Arg.wa_Name, // srcName
3546 destName, // destName
3547 NO_ICON_POSITION_SHORT, NO_ICON_POSITION_SHORT);
3548 break;
3549
3550 case FTOPCODE_Move:
3551 UndoAddEvent(iwt, UNDO_Move,
3552 UNDOTAG_UndoMultiStep, undoStep,
3553 UNDOTAG_CopySrcDirLock, fta->ftarg_Arg.wa_Lock,
3554 UNDOTAG_CopyDestDirLock, DestLock,
3555 UNDOTAG_CopySrcName, fta->ftarg_Arg.wa_Name,
3556 TAG_END);
3557
3558 Result = DoMethod(fileTransObj, SCCM_FileTrans_Move,
3559 fta->ftarg_Arg.wa_Lock, DestLock,
3560 fta->ftarg_Arg.wa_Name,
3561 NO_ICON_POSITION_SHORT, NO_ICON_POSITION_SHORT);
3562 break;
3563 }
3564
3565 if (destNameCopy)
3566 FreeCopyString(destNameCopy);
3567 if (fta->ftarg_Arg.wa_Name)
3568 {
3569 FreeCopyString(fta->ftarg_Arg.wa_Name);
3570 fta->ftarg_Arg.wa_Name = NULL;
3571 }
3572 if (fta->ftarg_Arg.wa_Lock)
3573 {
3574 UnLock(fta->ftarg_Arg.wa_Lock);
3575 fta->ftarg_Arg.wa_Lock = (BPTR)NULL;
3576 }
3577
3578 ScalosFree(fta);
3579
3580 d1(kprintf("%s/%s/%ld: Result=%ld\n", __FILE__, __FUNC__, __LINE__, Result));
3581 }
3582
3583 SCA_DisposeScalosObject(fileTransObj);
3584 }
3585
3586 UndoEndStep(iwt, undoStep);
3587
3588 DoMethod(iwt->iwt_WindowTask.mt_MainObject, SCCM_ClearClipboard);
3589 }
3590
3591 //---------------------------------------------------------------------------------------
3592
3593 static void MenuCreateThumbnailProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
3594 {
3595 d1(KPrintF("%s/%s/%ld: START mca_IconNode=%08lx\n", __FILE__, __FUNC__, __LINE__, mcArg->mca_IconNode));
3596
3597 if (mcArg->mca_IconNode)
3598 {
3599 CreateThumbnailStart(iwt, mcArg->mca_IconNode, NULL);
3600 }
3601 else
3602 {
3603 DoForAllWindows(iwt, CreateThumbnailStart);
3604 }
3605 d1(KPrintF("%s/%s/%ld: END mca_IconNode=%08lx\n", __FILE__, __FUNC__, __LINE__, mcArg->mca_IconNode));
3606 }
3607
3608 //---------------------------------------------------------------------------------------
3609
3610 static void RememberFilesToCopy(struct internalScaWindowTask *iwt, struct ScaIconNode *in, APTR undoStep)
3611 {
3612 (void) undoStep;
3613
3614 DoMethod(iwt->iwt_WindowTask.mt_MainObject, SCCM_AddToClipboard, iwt, in, FTOPCODE_Copy);
3615 }
3616
3617 //---------------------------------------------------------------------------------------
3618
3619 static void RememberFilesToCut(struct internalScaWindowTask *iwt, struct ScaIconNode *in, APTR undoStep)
3620 {
3621 struct ScaIconNode inCopy;
3622 struct ScaIconNode *IconList = &inCopy;
3623 ULONG UserFlags = 0L;
3624
3625 (void) undoStep;
3626
3627 GetAttr(IDTA_UserFlags, in->in_Icon, &UserFlags);
3628 UserFlags |= ICONOBJ_USERFLAGF_DrawShadowed;
3629 SetAttrs(in->in_Icon, IDTA_UserFlags, UserFlags, TAG_END);
3630
3631 inCopy = *in;
3632 inCopy.in_Node.mln_Succ = NULL;
3633
3634 DoMethod(iwt->iwt_WindowTask.mt_MainObject, SCCM_AddToClipboard, iwt, in, FTOPCODE_Move);
3635
3636 RemoveIcons(iwt, &IconList);
3637 RefreshIconList(iwt, IconList, NULL);
3638 }
3639
3640 //---------------------------------------------------------------------------------------
3641
3642 static ULONG CallTextInputHook(ULONG Action, STRPTR Prompt)
3643 {
3644 struct TextInputMsg tim;
3645
3646 if (NULL == globalTextInputHook)
3647 return 1;
3648
3649 tim.tim_Length = sizeof(tim);
3650 tim.tim_Action = Action;
3651 tim.tim_Prompt = Prompt;
3652
3653 return CallHookPkt(globalTextInputHook, NULL, &tim);
3654 }
3655
3656 //---------------------------------------------------------------------------------------
3657
3658 static STRPTR FindUniqueName(STRPTR Name, size_t MaxLength)
3659 {
3660 STRPTR lp = Name + strlen(Name);
3661 ULONG Nr = 0;
3662 BPTR fLock;
3663
3664 do {
3665 *lp = '\0';
3666
3667 if (Nr)
3668 {
3669 char NrString[20];
3670
3671 ScaFormatStringMaxLength(NrString, sizeof(NrString), "_%lu", Nr);
3672 SafeStrCat(Name, NrString, MaxLength);
3673 }
3674
3675 fLock = Lock(Name, ACCESS_READ);
3676 if (fLock)
3677 {
3678 Nr++;
3679 UnLock(fLock);
3680 }
3681 } while (fLock);
3682
3683 return Name;
3684 }
3685
3686 //---------------------------------------------------------------------------------------
3687
3688 static BOOL CanBeSizedMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in)
3689 {
3690 (void) in;
3691
3692 if (iwt->iwt_BackDrop)
3693 return FALSE;
3694 else
3695 return TRUE;
3696 }
3697
3698 //---------------------------------------------------------------------------------------
3699
3700 static BOOL IsMainWindowMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in)
3701 {
3702 (void) in;
3703
3704 return (BOOL) (WSV_Type_DeviceWindow == iwt->iwt_WindowTask.mt_WindowStruct->ws_WindowType);
3705 }
3706
3707 //---------------------------------------------------------------------------------------
3708
3709 static BOOL NotMainWindowMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in)
3710 {
3711 (void) in;
3712
3713 return (BOOL) !(WSV_Type_DeviceWindow == iwt->iwt_WindowTask.mt_WindowStruct->ws_WindowType);
3714 }
3715
3716 //---------------------------------------------------------------------------------------
3717
3718 static BOOL NotRootWindowMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in)
3719 {
3720 (void) in;
3721
3722 return (BOOL) !(iwt->iwt_WindowTask.mt_WindowStruct->ws_Flags & WSV_FlagF_RootWindow);
3723 }
3724
3725 //---------------------------------------------------------------------------------------
3726
3727 static BOOL MustHaveLockMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in)
3728 {
3729 if (iwt->iwt_WindowTask.mt_WindowStruct->ws_Lock)
3730 return TRUE;
3731
3732 if (in && in->in_Lock)
3733 return TRUE;
3734
3735 return FALSE;
3736 }
3737
3738 //---------------------------------------------------------------------------------------
3739
3740 static BOOL IconsSelectedAndWriteableMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in)
3741 {
3742 d1(KPrintF("%s/%s/%ld: in=%08lx IconActive=%ld\n", __FILE__, __FUNC__, __LINE__, in, IconActive));
3743
3744 if (NULL == in && 0 == IconActive)
3745 return FALSE;
3746 if (iwt->iwt_ReadOnly)
3747 return FALSE;
3748
3749 if (in && (in->in_Flags & INF_VolumeWriteProtected))
3750 return FALSE;
3751
3752 return TRUE;
3753 }
3754
3755 //---------------------------------------------------------------------------------------
3756
3757 static BOOL IconsSelectedNoDiskMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in)
3758 {
3759 if (NULL == in && 0 == IconActive)
3760 return FALSE;
3761
3762 if (in && in->in_DeviceIcon)
3763 return FALSE;
3764
3765 if (iwt->iwt_ReadOnly)
3766 return FALSE;
3767
3768 if (in && (in->in_Flags & INF_VolumeWriteProtected))
3769 return FALSE;
3770
3771 return TRUE;
3772 }
3773
3774 //---------------------------------------------------------------------------------------
3775
3776 static BOOL IconsSelectedMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in)
3777 {
3778 if (NULL == in && 0 == IconActive)
3779 return FALSE;
3780
3781 return TRUE;
3782 }
3783
3784 //---------------------------------------------------------------------------------------
3785
3786 static BOOL IconsSelectedBrowserModeMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in)
3787 {
3788 if (!(iwt->iwt_WindowTask.mt_WindowStruct->ws_Flags & WSV_FlagF_BrowserMode))
3789 return FALSE; // only enabled if browser mode
3790
3791 return IconsSelectedMenuEnable(iwt, in);
3792 }
3793
3794 //---------------------------------------------------------------------------------------
3795
3796 static BOOL IconsSelectedNotBrowserModeMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in)
3797 {
3798 if (iwt->iwt_WindowTask.mt_WindowStruct->ws_Flags & WSV_FlagF_BrowserMode)
3799 return FALSE; // only enabled if not browser mode
3800
3801 return IconsSelectedMenuEnable(iwt, in);
3802 }
3803
3804 //---------------------------------------------------------------------------------------
3805
3806 static BOOL EmptyTrashMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in)
3807 {
3808 if (NULL == in && 0 == IconActive)
3809 return FALSE;
3810
3811 // ???
3812
3813 return TRUE;
3814 }
3815
3816 //---------------------------------------------------------------------------------------
3817
3818 static BOOL FormatDiskMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in)
3819 {
3820 if (NULL == in && 0 == IconActive)
3821 return FALSE;
3822
3823 // ???
3824
3825 return TRUE;
3826 }
3827
3828 //---------------------------------------------------------------------------------------
3829
3830 static BOOL LeaveOutMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in)
3831 {
3832 if (NULL == in && 0 == IconActive)
3833 return FALSE;
3834 if (iwt->iwt_ReadOnly)
3835 return FALSE;
3836 if (WSV_Type_DeviceWindow == iwt->iwt_WindowTask.mt_WindowStruct->ws_WindowType)
3837 return FALSE; // "leave out" not allowed from desktop window
3838
3839 // ???
3840
3841 return TRUE;
3842 }
3843
3844 //---------------------------------------------------------------------------------------
3845
3846 static BOOL PutAwayMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in)
3847 {
3848 if (NULL == in && 0 == IconActive)
3849 return FALSE;
3850 if (iwt->iwt_ReadOnly)
3851 return FALSE;
3852 if (WSV_Type_DeviceWindow != iwt->iwt_WindowTask.mt_WindowStruct->ws_WindowType)
3853 return FALSE; // "put away" only allowed from desktop window
3854
3855 // ???
3856
3857 return TRUE;
3858 }
3859
3860 //---------------------------------------------------------------------------------------
3861
3862 static BOOL PasteMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in)
3863 {
3864 BOOL ClipboardEmpty;
3865
3866 d1(KPrintF("%s/%s/%ld: in=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, in, GetIconName(in)));
3867
3868 if (iwt->iwt_ReadOnly)
3869 return FALSE;
3870
3871 d1(KPrintF("%s/%s/%ld: in=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, in, GetIconName(in)));
3872
3873 ScalosObtainSemaphoreShared(&ClipboardSemaphore);
3874 ClipboardEmpty = IsListEmpty(&globalCopyClipBoard);
3875 ScalosReleaseSemaphore(&ClipboardSemaphore);
3876 if (ClipboardEmpty)
3877 return FALSE;
3878
3879 d1(KPrintF("%s/%s/%ld: in=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, in, GetIconName(in)));
3880
3881 if (iwt->iwt_WindowTask.mt_WindowStruct->ws_Lock)
3882 return TRUE;
3883
3884 d1(KPrintF("%s/%s/%ld: in=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, in, GetIconName(in)));
3885
3886 // Desktop window, left-out icon
3887 if (in && in->in_Lock)
3888 return TRUE;
3889
3890 // Desktop window, device icon
3891 if (in && in->in_DeviceIcon)
3892 return TRUE;
3893
3894 d1(KPrintF("%s/%s/%ld: in=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, in, GetIconName(in)));
3895
3896 return FALSE;
3897 }
3898
3899 //---------------------------------------------------------------------------------------
3900
3901 static BOOL UndoMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in)
3902 {
3903 BOOL UndoListEmpty;
3904
3905 ScalosObtainSemaphoreShared(&UndoListListSemaphore);
3906 UndoListEmpty = IsListEmpty(&globalUndoList);
3907 ScalosReleaseSemaphore(&UndoListListSemaphore);
3908 if (UndoListEmpty)
3909 return FALSE;
3910
3911 return TRUE;
3912 }
3913
3914 //---------------------------------------------------------------------------------------
3915
3916 static BOOL RedoMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in)
3917 {
3918 BOOL RedoListEmpty;
3919
3920 ScalosObtainSemaphoreShared(&RedoListListSemaphore);
3921 RedoListEmpty = IsListEmpty(&globalRedoList);
3922 ScalosReleaseSemaphore(&RedoListListSemaphore);
3923 if (RedoListEmpty)
3924 return FALSE;
3925
3926 return TRUE;
3927 }
3928
3929 //---------------------------------------------------------------------------------------
3930
3931 static BOOL NotMainWindowAndNotReadingMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in)
3932 {
3933 if (WSV_Type_DeviceWindow == iwt->iwt_WindowTask.mt_WindowStruct->ws_WindowType)
3934 return FALSE;
3935 if (iwt->iwt_Reading)
3936 return FALSE;
3937
3938 return TRUE;
3939 }
3940
3941 //---------------------------------------------------------------------------------------
3942
3943 static BOOL SnapshotMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in)
3944 {
3945 if (!IsIwtViewByIcon(iwt))
3946 return FALSE;
3947 if (NULL == in && 0 == IconActive)
3948 return FALSE;
3949 if (iwt->iwt_ReadOnly)
3950 return FALSE;
3951
3952 return TRUE;
3953 }
3954
3955 //---------------------------------------------------------------------------------------
3956
3957 static BOOL NotReadingMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in)
3958 {
3959 (void) in;
3960
3961 if (iwt->iwt_Reading)
3962 return FALSE;
3963
3964 return TRUE;
3965 }
3966
3967 //---------------------------------------------------------------------------------------
3968
3969 static BOOL IsWriteableMenuEnable(struct internalScaWindowTask *iwt, struct ScaIconNode *in)
3970 {
3971 if (iwt->iwt_ReadOnly)
3972 return FALSE;
3973 if (in && (in->in_Flags & INF_VolumeWriteProtected))
3974 return FALSE;
3975
3976 return TRUE;
3977 }
3978
3979 //----------------------------------------------------------------------------
3980
3981 static SAVEDS(ULONG) AsyncStartModule(APTR aptr, struct SM_RunProcess *msg, CONST_STRPTR ModuleName)
3982 {
3983 struct WBArg *arg = aptr;
3984 BPTR ModsDirLock;
3985 BPTR oldDir = NOT_A_LOCK;
3986 BPTR infoModLock = (BPTR)NULL;
3987 BOOL Ok = FALSE;
3988
3989 debugLock_d1(arg->wa_Lock);
3990 d1(kprintf("%s/%s/%ld: START arg->wa_Name=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, arg->wa_Name, arg->wa_Name ? arg->wa_Name : ""));
3991
3992 do {
3993 ModsDirLock = LockScaModsDir();
3994
3995 d1(kprintf("%s/%s/%ld: arg->wa_Name=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, arg->wa_Name, arg->wa_Name ? arg->wa_Name : ""));
3996 debugLock_d1(ModsDirLock);
3997 if ((BPTR)NULL == ModsDirLock)
3998 break;
3999
4000 oldDir = CurrentDir(ModsDirLock);
4001 infoModLock = Lock((STRPTR) ModuleName, ACCESS_READ);
4002
4003 d1(kprintf("%s/%s/%ld: arg->wa_Name=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, arg->wa_Name, arg->wa_Name ? arg->wa_Name : ""));
4004 debugLock_d1(infoModLock);
4005 if (infoModLock)
4006 {
4007 struct WBArg argArray[2];
4008
4009 argArray[0].wa_Name = (STRPTR) ModuleName;
4010 argArray[0].wa_Lock = ModsDirLock;
4011 argArray[1] = *arg;
4012
4013 if (SCA_WBStartTags(argArray, 2,
4014 SCA_Stacksize, CurrentPrefs.pref_DefaultStackSize,
4015 TAG_END))
4016 {
4017 d1(kprintf("%s/%s/%ld: SCA_WBStartTags Ok\n", __FILE__, __FUNC__, __LINE__));
4018
4019 arg->wa_Lock = (BPTR)NULL;
4020 ModsDirLock = (BPTR)NULL; // will be UnLock()ed
4021
4022 Ok = TRUE;
4023 }
4024 }
4025 } while (0);
4026
4027 d1(kprintf("%s/%s/%ld: arg->wa_Name=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, arg->wa_Name, arg->wa_Name ? arg->wa_Name : ""));
4028
4029 if (!Ok)
4030 WBInfo(arg->wa_Lock, arg->wa_Name, iInfos.xii_iinfos.ii_Screen);
4031
4032 if (IS_VALID_LOCK(oldDir))
4033 CurrentDir(oldDir);
4034 if (ModsDirLock)
4035 UnLock(ModsDirLock);
4036 if (infoModLock)
4037 UnLock(infoModLock);
4038 if (arg->wa_Lock)
4039 UnLock(arg->wa_Lock);
4040 if (arg->wa_Name)
4041 FreeCopyString(arg->wa_Name);
4042
4043 d1(kprintf("%s/%s/%ld: END\n", __FILE__, __FUNC__, __LINE__));
4044
4045 return 0;
4046 }
4047
4048 //---------------------------------------------------------------------------------------
4049 //------- CopyTo: MakeCloneArgs/CopyToCloneInfoStart/CopyToCloneWBArg -------------------
4050
4051 static void CopyToMakeCloneArgs(struct internalScaWindowTask *iwt,
4052 struct WBArg **wbArg, ULONG *ArgCount, ULONG MaxArgs)
4053 {
4054 struct ScaWindowStruct *ws;
4055
4056 SCA_LockWindowList(SCA_LockWindowList_Shared);
4057
4058 CopyToCloneInfoStart(iwt, wbArg, ArgCount, MaxArgs);
4059
4060 for (ws=winlist.wl_WindowStruct; ws; ws = (struct ScaWindowStruct *) ws->ws_Node.mln_Succ)
4061 {
4062 if (ws != iwt->iwt_WindowTask.mt_WindowStruct)
4063 CopyToCloneInfoStart((struct internalScaWindowTask *) ws->ws_WindowTask, wbArg, ArgCount, MaxArgs);
4064 }
4065
4066 SCA_UnLockWindowList();
4067 }
4068
4069 //---------------------------------------------------------------------------------------
4070
4071 static void CopyToCloneInfoStart(struct internalScaWindowTask *iwt,
4072 struct WBArg **wbArg, ULONG *ArgCount, ULONG MaxArgs)
4073 {
4074 struct ScaIconNode *in;
4075
4076 if ((*ArgCount) < MaxArgs)
4077 {
4078 ScalosLockIconListShared(iwt);
4079
4080 for (in=iwt->iwt_WindowTask.wt_IconList; in; in = (struct ScaIconNode *) in->in_Node.mln_Succ)
4081 {
4082 struct ExtGadget *gg = (struct ExtGadget *) in->in_Icon;
4083
4084 if (gg->Flags & GFLG_SELECTED)
4085 {
4086 ULONG IconType;
4087
4088 GetAttr(IDTA_Type, in->in_Icon, &IconType);
4089
4090 switch (IconType)
4091 {
4092 case WB_TEXTICON_TOOL:
4093 case WB_TEXTICON_DRAWER:
4094 case WBDRAWER:
4095 case WBGARBAGE:
4096 case WBTOOL:
4097 case WBPROJECT:
4098 case WBDISK:
4099 d1(kprintf("%s/%s/%ld: icon=<%s> NumArgs=%ld\n", __FILE__, __FUNC__, __LINE__, GetIconName(in), *ArgCount));
4100 CopyToCloneWBArg(iwt, wbArg, in, ArgCount, MaxArgs);
4101 break;
4102 default:
4103 break;
4104 }
4105 }
4106 }
4107
4108 ScalosUnLockIconList(iwt);
4109 }
4110 }
4111
4112 //---------------------------------------------------------------------------------------
4113
4114 static BOOL CopyToCloneWBArg(struct internalScaWindowTask *iwt, struct WBArg **wbArg,
4115 struct ScaIconNode *in, ULONG *ArgCount, ULONG MaxArgs)
4116 {
4117 CONST_STRPTR newName;
4118 size_t len;
4119 BPTR NLock= (BPTR)NULL;
4120
4121 if ((*ArgCount) < MaxArgs)
4122 {
4123 if (NULL == in->in_Name)
4124 return FALSE;
4125
4126 (*wbArg)->wa_Name = AllocCopyString(GetIconName(in));
4127 len = strlen((*wbArg)->wa_Name);
4128 newName = (*wbArg)->wa_Name;
4129
4130 if (':' == newName[len - 1])
4131 {
4132 NLock = Lock((*wbArg)->wa_Name, SHARED_LOCK);
4133 (*wbArg)->wa_Lock = DupLock(NLock);
4134 }
4135 else
4136 {
4137 if (in->in_Lock)
4138 {
4139 (*wbArg)->wa_Lock = DupLock(in->in_Lock);
4140 d1(kprintf("%s/%s/%ld: (*wbArg)->wa_Lock = <%s>\n", __FILE__, __FUNC__, __LINE__, TestLock));
4141 }
4142 else
4143 {
4144 if (iwt->iwt_WindowTask.mt_WindowStruct->ws_Lock)
4145 (*wbArg)->wa_Lock = DupLock(iwt->iwt_WindowTask.mt_WindowStruct->ws_Lock);
4146 else
4147 (*wbArg)->wa_Lock = (BPTR)NULL;
4148 }
4149 }
4150
4151 // (*wbArg)->wa_Name = AllocCopyString(GetIconName(in));
4152
4153 d1(kprintf("%s/%s/%ld: (*wbArg)->wa_Name = <%s>\n", __FILE__, __FUNC__, __LINE__, (*wbArg)->wa_Name));
4154
4155 if (NULL == (*wbArg)->wa_Name)
4156 {
4157 if ((*wbArg)->wa_Lock)
4158 UnLock((*wbArg)->wa_Lock);
4159
4160 return FALSE;
4161 }
4162
4163 if (NLock)
4164 UnLock(NLock);
4165
4166 (*wbArg)++;
4167 (*ArgCount)++;
4168
4169 return TRUE;
4170 }
4171
4172 return FALSE;
4173 }
4174
4175 //---------------------------------------------------------------------------------------
4176
4177 static void CopyToProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
4178 {
4179 struct WBArg *wbArg, *wbArgAlloc;
4180 ULONG ArgCount = 0;
4181
4182 do {
4183 struct CloneArg processArgs;
4184 ULONG NumberOfWbArgs = 1;
4185
4186 if (mcArg->mca_IconNode)
4187 NumberOfWbArgs += 1;
4188 else
4189 NumberOfWbArgs += SCA_CountWBArgs(mcArg->mca_IconNode);
4190
4191 wbArg = wbArgAlloc = ScalosAlloc(NumberOfWbArgs * sizeof(struct WBArg));
4192 if (NULL == wbArgAlloc)
4193 return;
4194
4195 if (mcArg->mca_IconNode)
4196 {
4197 ULONG IconType;
4198
4199 GetAttr(IDTA_Type, mcArg->mca_IconNode->in_Icon, &IconType);
4200
4201 d1(kprintf("%s/%s/%ld: IconType = [%08lx] Name=<%s>\n", __FILE__, __FUNC__, __LINE__, IconType, mcArg->mca_IconNode->in_Name));
4202
4203 if (WBKICK == IconType)
4204 {
4205 d1(kprintf("%s/%s/%ld: IconType WBKICK = %08lx\n", __FILE__, __FUNC__, __LINE__, IconType));
4206 break;
4207 }
4208
4209 if (!CopyToCloneWBArg(iwt, &wbArg, mcArg->mca_IconNode, &ArgCount, NumberOfWbArgs))
4210 break;
4211
4212 // ArgCount++;
4213
4214 d1(kprintf("%s/%s/%ld: CopyToCloneWBArg() ArgCount=%ld\n", __FILE__, __FUNC__, __LINE__, ArgCount));
4215 }
4216 else
4217 {
4218 CopyToMakeCloneArgs(iwt, &wbArg, &ArgCount, NumberOfWbArgs);
4219
4220 d1(kprintf("%s/%s/%ld: CopyToMakeCloneArgs() iwt=[%08lx] &ArgCount=[%ld])\n", __FILE__, __FUNC__, __LINE__, iwt, ArgCount));
4221 }
4222
4223 processArgs.cla_wbArg = wbArgAlloc;
4224 processArgs.cla_NumArgs = ArgCount;
4225
4226 RunProcess(&iwt->iwt_WindowTask, CopyToStart,
4227 sizeof(processArgs)/sizeof(ULONG), (struct WBArg *)(APTR) &processArgs, NULL);
4228
4229 // wbArgAlloc will be freed inside <CopyToStart>
4230 wbArgAlloc = NULL;
4231 ArgCount = 0;
4232 } while (0);
4233
4234 if (wbArgAlloc)
4235 {
4236 if (ArgCount > 0)
4237 SCA_FreeWBArgs(wbArgAlloc, ArgCount, SCAF_FreeNames | SCAF_FreeLocks);
4238
4239 ScalosFree(wbArgAlloc);
4240 }
4241 }
4242
4243 //---------------------------------------------------------------------------------------
4244
4245 static SAVEDS(ULONG) CopyToStart(APTR aptr, struct SM_RunProcess *msg)
4246 {
4247 struct CloneArg *arg = aptr;
4248 Object *fileTransObj = NULL;
4249 ULONG n;
4250 BPTR dirLock = (BPTR)NULL;
4251 APTR undoStep = NULL;
4252 struct FileRequester *dirReq;
4253
4254 do {
4255 BOOL Success;
4256 char Path[512];
4257
4258
4259 NameFromLock(arg->cla_wbArg[0].wa_Lock, Path, sizeof(Path));
4260
4261 d1(kprintf("%s/%s/%ld: arg->cla_wbArg[0].wa_Lock=<%s>\n", __FILE__, __FUNC__, __LINE__, Path));
4262
4263 // AllocAslRequest()
4264 dirReq = AllocAslRequestTags(ASL_FileRequest,
4265 ASLFR_PrivateIDCMP, TRUE,
4266 ASLFR_Screen, (ULONG) iInfos.xii_iinfos.ii_Screen,
4267 ASLFR_TitleText, (ULONG) GetLocString(MSGID_COPYTO_ASLTITLE),
4268 ASLFR_DoSaveMode, TRUE,
4269 ASLFR_DrawersOnly, TRUE,
4270 TAG_END);
4271
4272 if (NULL == dirReq)
4273 break;
4274
4275 // AslRequest()
4276 Success = AslRequestTags(dirReq,
4277 ASLFR_InitialDrawer, (ULONG) Path,
4278 TAG_END);
4279
4280 if (Success)
4281 {
4282 CONST_STRPTR destName;
4283 STRPTR destNameCopy = NULL;
4284 size_t len;
4285 char NLockName[512];
4286 char LockdirName[256];
4287 char TestRootName[256];
4288 BOOL ErrorFound;
4289
4290 undoStep = UndoBeginStep();
4291
4292 dirLock = Lock(dirReq->fr_Drawer, ACCESS_READ);
4293 if ((BPTR)NULL == dirLock)
4294 break;
4295
4296 stccpy(LockdirName, dirReq->fr_Drawer, sizeof(LockdirName));
4297
4298 fileTransObj = SCA_NewScalosObjectTags((STRPTR) "FileTransfer.sca",
4299 SCCA_FileTrans_Screen, (ULONG) iInfos.xii_iinfos.ii_Screen,
4300 SCCA_FileTrans_Number, arg->cla_NumArgs,
4301 SCCA_FileTrans_ReplaceMode, SCCV_ReplaceMode_Ask,
4302 TAG_END);
4303
4304 if (NULL == fileTransObj)
4305 break;
4306
4307 d1(kprintf("%s/%s/%ld: NumArgs=%ld\n", __FILE__, __FUNC__, __LINE__, arg->cla_NumArgs));
4308
4309 for (n=0; n < arg->cla_NumArgs; n++)
4310 {
4311 ErrorFound = FALSE;
4312
4313 debugLock_d1(arg->cla_wbArg[n].wa_Lock);
4314
4315 NameFromLock(arg->cla_wbArg[n].wa_Lock, NLockName, sizeof(NLockName));
4316
4317 if (arg->cla_wbArg[n].wa_Name && strlen(arg->cla_wbArg[n].wa_Name) > 0)
4318 AddPart(NLockName, arg->cla_wbArg[n].wa_Name, sizeof(NLockName));
4319
4320 if (LOCK_SAME == ScaSameLock(dirLock, arg->cla_wbArg[n].wa_Lock)) // Can't copy a object to itself!
4321 {
4322 DisplayBeep(NULL);
4323 ErrorFound = TRUE;
4324 d1(kprintf("%s/%s/%ld: ERROR SAME LOCK!: ErrorFound=[%ld] Source Lock=<%s> Destination Lock=<%s>\n", \
4325 __FILE__, __FUNC__, __LINE__, ErrorFound, NLockName, dirReq->fr_Drawer));
4326 }
4327
4328 if (!ErrorFound)
4329 {
4330 stccpy(TestRootName, LockdirName, strlen(NLockName) + 1); // Check if destination with a max string lenght
4331 if (0 == Stricmp(TestRootName, NLockName)) // from source's string lenght = source.
4332 {
4333 DisplayBeep(NULL);
4334 ErrorFound = TRUE;
4335 d1(kprintf("%s/%s/%ld: SAME! : ErrorFound=[%ld] NLockName=<%s> TestRootname=<%s>\n", \
4336 __FILE__, __FUNC__, __LINE__, ErrorFound, NLockName, TestRootName));
4337 }
4338 }
4339
4340 if (!ErrorFound)
4341 {
4342 len = strlen(arg->cla_wbArg[n].wa_Name);
4343 destName = arg->cla_wbArg[n].wa_Name;
4344
4345
4346 d1(kprintf("%s/%s/%ld: Copy NLockName=<%s> to Destination=<%s>\n", __FILE__, __FUNC__, __LINE__, NLockName, LockdirName));
4347
4348 if (':' == destName[len - 1])
4349 {
4350 // Replace trailing ":" by "/" for copying volumes/disks to directories
4351 destNameCopy = AllocCopyString(destName);
4352 if (destNameCopy)
4353 {
4354 arg->cla_wbArg[n].wa_Name[0] = '\0';
4355 destName = destNameCopy;
4356 StripTrailingColon(destNameCopy);
4357 d1(kprintf("%s/%s/%ld: destName=<%s> destNameCopy=<%s>\n", __FILE__, __FUNC__, __LINE__, destName, destNameCopy));
4358 }
4359 }
4360
4361 UndoAddEvent((struct internalScaWindowTask *) msg->WindowTask, UNDO_Copy,
4362 UNDOTAG_UndoMultiStep, undoStep,
4363 UNDOTAG_CopySrcDirLock, arg->cla_wbArg[n].wa_Lock,
4364 UNDOTAG_CopyDestDirLock, dirLock,
4365 UNDOTAG_CopySrcName, arg->cla_wbArg[n].wa_Name,
4366 UNDOTAG_CopyDestName, destName,
4367 TAG_END);
4368
4369 DoMethod(fileTransObj, SCCM_FileTrans_Copy,
4370 arg->cla_wbArg[n].wa_Lock, dirLock,
4371 arg->cla_wbArg[n].wa_Name,
4372 destName,
4373 NO_ICON_POSITION_SHORT, NO_ICON_POSITION_SHORT);
4374 }
4375 }
4376
4377 if (destNameCopy)
4378 FreeCopyString(destNameCopy);
4379 }
4380 } while (0);
4381
4382 UndoEndStep((struct internalScaWindowTask *) msg->WindowTask, undoStep);
4383
4384 SCA_FreeWBArgs(arg->cla_wbArg, arg->cla_NumArgs, SCAF_FreeNames | SCAF_FreeLocks);
4385 ScalosFree(arg->cla_wbArg);
4386
4387 if (fileTransObj)
4388 SCA_DisposeScalosObject(fileTransObj);
4389
4390 if (dirLock)
4391 UnLock(dirLock);
4392
4393 if (dirReq)
4394 FreeAslRequest(dirReq);
4395
4396 return 0;
4397 }
4398
4399 //---------------------------------------------------------------------------------------
4400 //------- MoveTo: MoveToMakeCloneArgs/MoveToCloneInfoStart ------------------------------
4401 //---------------------------------------------------------------------------------------
4402
4403 static void MoveToMakeCloneArgs(struct internalScaWindowTask *iwt,
4404 struct WBArg **wbArg, ULONG *ArgCount, ULONG MaxArgs)
4405 {
4406 struct ScaWindowStruct *ws;
4407
4408 SCA_LockWindowList(SCA_LockWindowList_Shared);
4409
4410 MoveToCloneInfoStart(iwt, wbArg, ArgCount, MaxArgs);
4411
4412 for (ws=winlist.wl_WindowStruct; ws; ws = (struct ScaWindowStruct *) ws->ws_Node.mln_Succ)
4413 {
4414 if (ws != iwt->iwt_WindowTask.mt_WindowStruct)
4415 MoveToCloneInfoStart((struct internalScaWindowTask *) ws->ws_WindowTask, wbArg, ArgCount, MaxArgs);
4416 }
4417 SCA_UnLockWindowList();
4418 }
4419
4420 //---------------------------------------------------------------------------------------
4421
4422 static void MoveToCloneInfoStart(struct internalScaWindowTask *iwt,
4423 struct WBArg **wbArg, ULONG *ArgCount, ULONG MaxArgs)
4424 {
4425 struct ScaIconNode *in;
4426
4427 if ((*ArgCount) <= MaxArgs)
4428 {
4429 ScalosLockIconListShared(iwt);
4430
4431 d1(KPrintF("%s/%s/%ld: ScalosLockIconListShared(iwt)\n", __FILE__, __FUNC__, __LINE__));
4432
4433 for (in=iwt->iwt_WindowTask.wt_IconList; in; in = (struct ScaIconNode *) in->in_Node.mln_Succ)
4434 {
4435 struct ExtGadget *gg = (struct ExtGadget *) in->in_Icon;
4436
4437 if (gg->Flags & GFLG_SELECTED)
4438 {
4439 ULONG IconType;
4440
4441 GetAttr(IDTA_Type, in->in_Icon, &IconType);
4442
4443 switch (IconType)
4444 {
4445 case WBDISK:
4446 case WBDEVICE:
4447 case WBKICK:
4448 d1(kprintf("%s/%s/%ld: icon=<%s> NumArgs=[%ld] IconType=%08lx\n", __FILE__, __FUNC__, __LINE__, GetIconName(in), *ArgCount, IconType));
4449
4450 DisplayBeep(NULL);
4451
4452 UseRequestArgs(NULL, MSGID_MOVETO_DEVICE, MSGID_OKNAME, 1, GetIconName(in));
4453
4454 ClassSelectIcon(iwt->iwt_WindowTask.mt_WindowStruct, in, FALSE); // UnSelect drive icon.
4455
4456 CopyToCloneWBArg(iwt, wbArg, in, ArgCount, MaxArgs);
4457 //CloneWBArg(iwt, wbArg, in, ArgCount);
4458 break;
4459 case WB_TEXTICON_TOOL:
4460 case WB_TEXTICON_DRAWER:
4461 case WBDRAWER:
4462 case WBGARBAGE:
4463 case WBTOOL:
4464 case WBPROJECT:
4465 d1(kprintf("%s/%s/%ld: icon=<%s> NumArgs=%ld\n", __FILE__, __FUNC__, __LINE__, GetIconName(in), *ArgCount));
4466 //CloneWBArg(iwt, wbArg, in, ArgCount);
4467 CopyToCloneWBArg(iwt, wbArg, in, ArgCount, MaxArgs);
4468 break;
4469
4470 default:
4471 break;
4472 }
4473 }
4474 }
4475
4476 ScalosUnLockIconList(iwt);
4477 }
4478 }
4479
4480 //---------------------------------------------------------------------------------------
4481
4482 static void MoveToProg(struct internalScaWindowTask *iwt, const struct MenuCmdArg *mcArg)
4483 {
4484 struct WBArg *wbArg, *wbArgAlloc;
4485 ULONG ArgCount = 0;
4486
4487 do {
4488 struct CloneArg processArgs;
4489 ULONG NumberOfWbArgs = 1;
4490
4491 if (mcArg->mca_IconNode)
4492 NumberOfWbArgs += 1;
4493 else
4494 NumberOfWbArgs += SCA_CountWBArgs(mcArg->mca_IconNode);
4495
4496 wbArg = wbArgAlloc = ScalosAlloc(NumberOfWbArgs * sizeof(struct WBArg));
4497 if (NULL == wbArgAlloc)
4498 return;
4499
4500 if (mcArg->mca_IconNode)
4501 {
4502 ULONG IconType;
4503
4504 GetAttr(IDTA_Type, mcArg->mca_IconNode->in_Icon, &IconType);
4505
4506 if (WBDISK == IconType ||
4507 WBDEVICE == IconType ||
4508 WBKICK == IconType)
4509 {
4510 DisplayBeep(NULL);
4511 break;
4512 }
4513
4514 if (!CopyToCloneWBArg(iwt, &wbArg, mcArg->mca_IconNode, &ArgCount, NumberOfWbArgs))
4515 break;
4516
4517 // ArgCount++;
4518
4519 d1(kprintf("%s/%s/%ld: [a] ArgCount=[%ld]\n", __FILE__, __FUNC__, __LINE__, ArgCount));
4520 }
4521 else
4522 {
4523 MoveToMakeCloneArgs(iwt, &wbArg, &ArgCount, NumberOfWbArgs);
4524 }
4525
4526 d1(KPrintF("%s/%s/%ld: [b] ArgCount=[%ld] iwt=%08lx\n", __FILE__, __FUNC__, __LINE__, ArgCount, iwt));
4527
4528 processArgs.cla_wbArg = wbArgAlloc;
4529 processArgs.cla_NumArgs = ArgCount;
4530
4531 RunProcess(&iwt->iwt_WindowTask, MoveToStart,
4532 sizeof(processArgs)/sizeof(ULONG), (struct WBArg *)(APTR) &processArgs, NULL);
4533
4534 // wbArgAlloc will be freed inside <MoveToStart>
4535 wbArgAlloc = NULL;
4536 ArgCount = 0;
4537 } while (0);
4538
4539 if (wbArgAlloc)
4540 {
4541 if (ArgCount > 0)
4542 SCA_FreeWBArgs(wbArgAlloc, ArgCount, SCAF_FreeNames | SCAF_FreeLocks);
4543
4544 ScalosFree(wbArgAlloc);
4545 }
4546 }
4547
4548 //---------------------------------------------------------------------------------------
4549
4550 static SAVEDS(ULONG) MoveToStart(APTR aptr, struct SM_RunProcess *msg)
4551 {
4552 struct CloneArg *arg = aptr;
4553 Object *fileTransObj = NULL;
4554 ULONG n;
4555 BPTR dirLock = (BPTR)NULL;
4556 APTR undoStep = NULL;
4557 struct FileRequester *dirReq;
4558
4559
4560 d1(kprintf("%s/%s/%ld: START NumArgs=[%ld]\n", __FILE__, __FUNC__, __LINE__, arg->cla_NumArgs));
4561
4562 do {
4563 BOOL Success;
4564 ULONG np = 0;
4565 char Path[512];
4566
4567 // AllocAslRequest()
4568 dirReq = AllocAslRequestTags(ASL_FileRequest,
4569 ASLFR_PrivateIDCMP, TRUE,
4570 ASLFR_Screen, (ULONG) iInfos.xii_iinfos.ii_Screen,
4571 ASLFR_TitleText, (ULONG) GetLocString(MSGID_MOVETO_ASLTITLE),
4572 ASLFR_DoSaveMode, TRUE,
4573 ASLFR_DrawersOnly, TRUE,
4574 TAG_END);
4575
4576 if (NULL == dirReq)
4577 break;
4578
4579 for (n=0; n < arg->cla_NumArgs; n++)
4580 {
4581 np++;
4582 if (':' == arg->cla_wbArg[n].wa_Name[strlen(arg->cla_wbArg[n].wa_Name) - 1]) // Check number of drives if selected from workbench
4583 np--; // Decrease "np" variable if a drive is found.
4584 else
4585 {
4586 if ((BPTR)NULL != arg->cla_wbArg[n].wa_Lock) // If object isn't a drive, select last valid path found
4587 NameFromLock(arg->cla_wbArg[n].wa_Lock, Path, sizeof(Path)); // for "ASLFR_InitialDrawer" field.
4588 }
4589
4590 d1(kprintf("%s/%s/%ld: CHECKING ARGS: n=[%ld] np=[%ld] NumArgs=[%ld] Path=<%s> arg->cla_wbArg[%ld]=<%s>\n", \
4591 __FILE__, __FUNC__, __LINE__, n, np, arg->cla_NumArgs, Path, n, arg->cla_wbArg[n].wa_Name));
4592 }
4593
4594 d1(kprintf("%s/%s/%ld: END np=[%ld] NumArgs=[%ld]\n", __FILE__, __FUNC__, __LINE__, np, arg->cla_NumArgs));
4595
4596 if (0 == np) // if "np= 0" all objects found are drives,
4597 { // so abort MoveTo function.
4598 d1(kprintf("%s/%s/%ld: np=[%ld] NumArgs=[%ld]\n", \
4599 __FILE__, __FUNC__, __LINE__, np, arg->cla_NumArgs));
4600 break;
4601 }
4602
4603 // AslRequest()
4604 Success = AslRequestTags(dirReq,
4605 ASLFR_InitialDrawer, (ULONG) Path,
4606 TAG_END);
4607
4608 if (Success)
4609 {
4610 char NLockName[512];
4611 char ProgramIcon[512];
4612 char LockdirName[256];
4613 char TestRootName[256];
4614 CONST_STRPTR SrcName;
4615 size_t len;
4616 BOOL ErrorFound;
4617
4618 undoStep = UndoBeginStep();
4619
4620 dirLock = Lock(dirReq->fr_Drawer, ACCESS_READ);
4621 if ((BPTR)NULL == dirLock)
4622 break;
4623
4624 stccpy(LockdirName, dirReq->fr_Drawer, sizeof(LockdirName));
4625
4626 fileTransObj = SCA_NewScalosObjectTags((STRPTR) "FileTransfer.sca",
4627 SCCA_FileTrans_Screen, (ULONG) iInfos.xii_iinfos.ii_Screen,
4628 SCCA_FileTrans_Number, arg->cla_NumArgs,
4629 SCCA_FileTrans_ReplaceMode, SCCV_ReplaceMode_Ask,
4630 TAG_END);
4631
4632 if (NULL == fileTransObj)
4633 break;
4634
4635 d1(kprintf("%s/%s/%ld: NumArgs=%ld\n", __FILE__, __FUNC__, __LINE__, arg->cla_NumArgs));
4636
4637 for (n=0; n <arg->cla_NumArgs; n++)
4638 {
4639 ErrorFound = FALSE;
4640
4641 debugLock_d1(arg->cla_wbArg[n].wa_Lock);
4642
4643 len = strlen(arg->cla_wbArg[n].wa_Name);
4644 SrcName = arg->cla_wbArg[n].wa_Name;
4645
4646 NameFromLock(arg->cla_wbArg[n].wa_Lock, NLockName, sizeof(NLockName));
4647
4648 if (SrcName && len > 0)
4649 AddPart(NLockName, SrcName, sizeof(NLockName));
4650
4651 if (LOCK_SAME == ScaSameLock(dirLock, arg->cla_wbArg[n].wa_Lock)) // Can't copy a object to itself!
4652 {
4653 DisplayBeep(NULL);
4654 ErrorFound = TRUE;
4655 d1(kprintf("%s/%s/%ld: ERROR SAME LOCK!: ErrorFound=[%ld] Source Lock=<%s> Destination Lock=<%s>\n", \
4656 __FILE__, __FUNC__, __LINE__, ErrorFound, NLockName, dirReq->fr_Drawer));
4657 }
4658
4659 if (!ErrorFound)
4660 {
4661 stccpy(TestRootName, LockdirName, strlen(NLockName) + 1); // Check if destination with a max string lenght
4662 if (0 == Stricmp(TestRootName, NLockName)) // from source's string lenght = source.
4663 {
4664 DisplayBeep(NULL);
4665 ErrorFound = TRUE;
4666 d1(kprintf("%s/%s/%ld: SAME! : ErrorFound=[%ld] NLockName=<%s> TestRootname=<%s>\n", \
4667 __FILE__, __FUNC__, __LINE__, ErrorFound, NLockName, TestRootName));
4668 }
4669 }
4670
4671 if (!ErrorFound)
4672 {
4673 if (':' == SrcName[len - 1]) // Skip all drives found, from wb arg.
4674 ErrorFound = TRUE;
4675 }
4676
4677 if (!ErrorFound)
4678 {
4679 BPTR IconLock;
4680
4681 d1(kprintf("%s/%s/%ld: NUMBER=[%ld] ErrorFound=[%ld] [Move <%s> - Full path = <%s>] To =<%s>\n", \
4682 __FILE__, __FUNC__, __LINE__, n, ErrorFound, SrcName, NLockName, LockdirName));
4683
4684 UndoAddEvent((struct internalScaWindowTask *) msg->WindowTask, UNDO_Move,
4685 UNDOTAG_UndoMultiStep, undoStep,
4686 UNDOTAG_CopySrcDirLock, arg->cla_wbArg[n].wa_Lock,
4687 UNDOTAG_CopyDestDirLock, dirLock,
4688 UNDOTAG_CopySrcName, SrcName,
4689 TAG_END);
4690
4691 DoMethod(fileTransObj, SCCM_FileTrans_Move,
4692 arg->cla_wbArg[n].wa_Lock, dirLock,
4693 SrcName,
4694 NO_ICON_POSITION_SHORT, NO_ICON_POSITION_SHORT);
4695
4696 snprintf(ProgramIcon, sizeof(ProgramIcon), "%s.info", SrcName);
4697
4698 if (IconLock = Lock(ProgramIcon, SHARED_LOCK))
4699 {
4700 UnLock(IconLock);
4701
4702 d1(kprintf("%s/%s/%ld: FOUND ICON HERE!!!: [Move Icon <%s>] To =<%s>\n", \
4703 __FILE__, __FUNC__, __LINE__, ProgramIcon, LockdirName));
4704
4705 UndoAddEvent((struct internalScaWindowTask *) msg->WindowTask, UNDO_Move,
4706 UNDOTAG_UndoMultiStep, undoStep,
4707 UNDOTAG_CopySrcDirLock, arg->cla_wbArg[n].wa_Lock,
4708 UNDOTAG_CopyDestDirLock, dirLock,
4709 UNDOTAG_CopySrcName, ProgramIcon,
4710 TAG_END);
4711
4712 DoMethod(fileTransObj, SCCM_FileTrans_Move,
4713 arg->cla_wbArg[n].wa_Lock, dirLock,
4714 ProgramIcon,
4715 NO_ICON_POSITION_SHORT, NO_ICON_POSITION_SHORT);
4716
4717 }
4718 }
4719 }
4720 }
4721 } while (0);
4722
4723 UndoEndStep((struct internalScaWindowTask *) msg->WindowTask, undoStep);
4724
4725 SCA_FreeWBArgs(arg->cla_wbArg, arg->cla_NumArgs, SCAF_FreeNames | SCAF_FreeLocks);
4726 ScalosFree(arg->cla_wbArg);
4727
4728 if (fileTransObj)
4729 SCA_DisposeScalosObject(fileTransObj);
4730
4731 if (dirLock)
4732 UnLock(dirLock);
4733
4734 if (dirReq)
4735 FreeAslRequest(dirReq);
4736
4737 return 0;
4738 }
4739
4740 //----------------------------------------------------------------------------
4741
4742 static void CreateThumbnailStart(struct internalScaWindowTask *iwt, struct ScaIconNode *in, APTR undoStep)
4743 {
4744 BPTR IconDirLock;
4745 Object *OrigIconObj;
4746
4747 d1(KPrintF("%s/%s/%ld: START iwt=%08lx in=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, in, GetIconName(in)));
4748
4749 if (in->in_Lock)
4750 IconDirLock = in->in_Lock;
4751 else
4752 IconDirLock = iwt->iwt_WindowTask.mt_WindowStruct->ws_Lock;
4753
4754 OrigIconObj = CloneIconObject(in->in_Icon);
4755
4756 if (AddThumbnailIcon(iwt, in->in_Icon,
4757 IconDirLock,
4758 GetIconName(in),
4759 THUMBNAILICONF_SAVEICON | THUMBNAILICONF_NOICONPOSITION,
4760 undoStep))
4761 {
4762 d1(KPrintF("%s/%s/%ld: AddThumbnailIcon succeeded\n", __FILE__, __FUNC__, __LINE__));
4763
4764 UnsnapshotIcon(iwt, in, FALSE, undoStep);
4765
4766 d1(KPrintF("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
4767
4768 DoMethod(in->in_Icon, IDTM_FreeLayout, IOFREELAYOUTF_ScreenAvailable);
4769 DoMethod(iwt->iwt_WindowTask.mt_MainObject, SCCM_IconWin_LayoutIcon,
4770 in->in_Icon, IOLAYOUTF_NormalImage);
4771
4772 d1(KPrintF("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
4773
4774 AfterUnsnapshotIcon(iwt);
4775
4776 d1(KPrintF("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
4777
4778 // Start thumbnail generation process
4779 GenerateThumbnails(iwt);
4780 }
4781
4782 if (OrigIconObj)
4783 DisposeIconObject(OrigIconObj);
4784
4785 d1(KPrintF("%s/%s/%ld: END iwt=%08lx\n", __FILE__, __FUNC__, __LINE__, iwt));
4786 }
4787
4788 //---------------------------------------------------------------------------------------
4789
4790 static void DoForAppIcons(ULONG AppMsgClass)
4791 {
4792 struct ScaWindowStruct *ws;
4793
4794 SCA_LockWindowList(SCA_LockWindowList_Shared);
4795
4796 for (ws=winlist.wl_WindowStruct; ws; ws = (struct ScaWindowStruct *) ws->ws_Node.mln_Succ)
4797 {
4798 if (!(ws->ws_Flags & WSV_FlagF_TaskSleeps)
4799 && ws->ws_Window
4800 && (0 == ws->ws_Lock) )
4801 {
4802 struct internalScaWindowTask *iwt = (struct internalScaWindowTask *) ws->ws_WindowTask;
4803 struct ScaIconNode *in;
4804
4805 d1(KPrintF("%s/%s/%ld: START iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, iwt, iwt->iwt_WinTitle));
4806
4807 ScalosLockIconListShared(iwt);
4808
4809 for (in=iwt->iwt_WindowTask.wt_IconList; in; in = (struct ScaIconNode *) in->in_Node.mln_Succ)
4810 {
4811 struct ExtGadget *gg = (struct ExtGadget *) in->in_Icon;
4812
4813 if (gg->Flags & GFLG_SELECTED)
4814 {
4815 ULONG IconType;
4816
4817 GetAttr(IDTA_Type, in->in_Icon, &IconType);
4818
4819 if (WBAPPICON == IconType)
4820 {
4821 d1(KPrintF("%s/%s/%ld: iwt=%08lx <%s>\n", __FILE__, __FUNC__, __LINE__, in, GetIconName(in)));
4822 WindowSendAppIconMsg(iwt, AppMsgClass, in);
4823 }
4824 }
4825 }
4826
4827 ScalosUnLockIconList(iwt);
4828
4829 break;
4830 }
4831 }
4832
4833 SCA_UnLockWindowList();
4834 }
4835
4836 //---------------------------------------------------------------------------------------
4837
4838
Mirror of AROS' Contrib svn.