Context Navigation

source: trunk/dll/worker.c@ 1140

Visit:

Last change on this file since 1140 was 1140, checked in by Gregg Young, 17 years ago
Comments added for recent changes
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 50.8 KB

Line
1
2	/***********************************************************************
3
4	$Id: worker.c 1140 2008-09-01 19:52:06Z gyoung $
5
6	Worker thread
7
8	Copyright (c) 1993-98 M. Kimes
9	Copyright (c) 2001, 2008 Steven H. Levine
10
11	16 Oct 02 SHL Comments
12	18 Oct 02 SHL MassAction:Archive - force extension so file found
13	06 Jun 05 SHL Indent -i2
14	06 Jun 05 SHL Rework Action for VAC3.65 compat
15	27 Jul 05 SHL IDM_DOITYOURSELF - avoid need to strip in ExecOnList
16	22 Jul 06 SHL Comments
17	22 Jul 06 SHL Check more run time errors
18	03 Nov 06 SHL Renames
19	03 Nov 06 SHL Count thread usage
20	21 Apr 07 GKY Find FM2Utils by path or utils directory
21	16 Jun 07 SHL Update for OpenWatcom
22	06 Aug 07 GKY Reduce DosSleep times (ticket 148)
23	07 Aug 07 SHL Use BldQuotedFileName
24	20 Aug 07 GKY Move #pragma alloc_text to end for OpenWatcom compat
25	26 Aug 07 SHL Revert to DosSleep(0)
26	29 Feb 08 GKY Refactor global command line variables to notebook.h
27	22 Jun 08 GKY Made Felete move to xworkplace trash can on systems that have it
28	16 JUL 08 GKY Use TMP directory for temp files
29	20 Jul 08 GKY Add save/append filename to clipboard.
30	02 Aug 08 GKY Limit use of "trash can" to local writable fixed drives or to trash can supported
31	drives list if it exists. Fix ability to deselect use of trash can.
32	01 Sep 08 GKY Add code to retry on Netdrives "pipe error"
33
34	***********************************************************************/
35
36	#include <stdlib.h>
37	#include <string.h>
38	#include <ctype.h>
39	#include <share.h>
40	#include <process.h> // _beginthread
41
42	#define INCL_DOS
43	#define INCL_DOSERRORS
44	#define INCL_WINPROGRAMLIST
45	#define INCL_WINHELP
46	#define INCL_LONGLONG
47	#define INCL_WINPOINTERS
48	#define INCL_WINWORKPLACE
49	#define INCL_WINSHELLDATA
50
51	#include "fm3dlg.h"
52	#include "fm3str.h"
53	#include "comp.h" // FCOMPARE
54	#include "pathutil.h" // BldQuotedFileName
55	#include "makelist.h" // AddToList
56	#include "errutil.h" // Dos_Error...
57	#include "strutil.h" // GetPString
58	#include "notebook.h" // External viewers
59	#include "fm3dll.h"
60
61	#include "fortify.h"
62
63	#pragma data_seg(DATA2)
64
65	static PSZ pszSrcFile = __FILE__;
66
67	#ifdef UNDO
68
69	static VOID LINFO undo;
70
71	VOID FreeUndo(VOID)
72	{
73	if (undo->list)
74	FreeList(undo->list);
75	memset(&undo, 0, sizeof(undo));
76	}
77
78	VOID Undo(HWND hwndCnr, HWND hwndFrame, HWND hwndClient, HWND hwndParent)
79	{
80	LISTINFO *li;
81	WORKER *wk;
82
83	if (undo->type && undo->list && undo->list[0]) {
84	switch (undo->type) {
85	case IDM_MOVE case IDM_COPY:
86	case IDM_EXTRACT:
87	{
88	# ifdef FORTIFY
89	Fortify_EnterScope();
90	# endif
91	li = xmallocz(sizeof(LISTINFO), pszSrcFile, __LINE__);
92	if (li) {
93	wk = xmallocz(sizeof(WORKER), pszSrcFile, __LINE__);
94	if (wk) {
95	wk->size = sizeof(WORKER);
96	wk->hwndCnr = hwndCnr;
97	wk->hwndParent = hwndParent;
98	wk->hwndFrame = hwndFrame;
99	wk->hwndClient = hwndClient;
100	wk->li = li;
101	wk->li = undo;
102	switch (undo->type) {
103	case IDM_COPY:
104	case IDM_EXTRACT:
105	li->type = IDM_PERMDELETE;
106	break;
107	}
108	if (_beginthread(MassAction, NULL, 122880, (PVOID) wk) == -1) {
109	Runtime_Error(pszSrcFile, __LINE__,
110	GetPString(IDS_COULDNTSTARTTHREADTEXT));
111	FreeListInfo(wk->li);
112	free(wk);
113	# ifdef FORTIFY
114	Fortify_LeaveScope();
115	# endif
116	}
117	}
118	else
119	FreeListInfo(li);
120	}
121	}
122	break;
123	}
124	}
125	FreeUndo();
126	# ifdef FORTIFY
127	Fortify_LeaveScope();
128	# endif
129	}
130
131	#endif // defined(UNDO)
132
133	VOID Action(VOID * args)
134	{
135	WORKER wk = (WORKER )args;
136	HAB hab2;
137	HMQ hmq2;
138	CHAR **files = NULL;
139	UINT numfiles = 0, numalloc = 0;
140	INT plen = 0;
141	CHAR p, pp;
142	CHAR szQuotedDirName[CCHMAXPATH];
143	CHAR szQuotedFileName[CCHMAXPATH];
144
145
146	if (wk) {
147	# ifdef FORTIFY
148	Fortify_EnterScope();
149	# endif
150	if (wk->li && wk->li->list && wk->li->list[0]) {
151	hab2 = WinInitialize(0);
152	if (hab2) {
153	hmq2 = WinCreateMsgQueue(hab2, 0);
154	if (hmq2) {
155	CHAR message[(CCHMAXPATH * 2) + 80], wildname[CCHMAXPATH];
156	INT x;
157	BOOL dontask = FALSE, wildcarding = FALSE, overold =
158	FALSE, overnew = FALSE, usedtarget;
159
160	WinCancelShutdown(hmq2, TRUE);
161	IncrThreadUsage();
162	*wildname = 0;
163	switch (wk->li->type) {
164	case IDM_MERGE:
165	if (wk->li->type == IDM_MERGE) {
166	if (TestBinary(wk->li->list[0]))
167	wk->li->type = IDM_MERGEBINARY;
168	else
169	wk->li->type = IDM_MERGETEXT;
170	}
171	strcpy(wk->li->targetpath, wk->li->list[0]);
172	p = strrchr(wk->li->targetpath, '\\');
173	if (p) {
174	p++;
175	*p = 0;
176	}
177	else
178	strcat(wk->li->targetpath, "\\");
179	sprintf(wk->li->targetpath + strlen(wk->li->targetpath),
180	"MERGE.%03x", (clock() & 4095L));
181	if (!WinDlgBox(HWND_DESKTOP,
182	wk->hwndFrame,
183	MergeDlgProc, FM3ModHandle, MRG_FRAME, (PVOID) wk))
184	goto Abort;
185	if (!wk->li->type \|\|
186	!*wk->li->targetpath \|\| !wk->li->list \|\| !wk->li->list[0])
187	goto Abort;
188	if (IsFile(wk->li->targetpath) != 1 && !wk->li->list[1]) {
189	saymsg(MB_CANCEL \| MB_ICONEXCLAMATION,
190	wk->hwndFrame,
191	GetPString(IDS_AHEMTEXT),
192	GetPString(IDS_SILLYMERGETEXT));
193	goto Abort;
194	}
195	break;
196	case IDM_WILDMOVE:
197	wildcarding = TRUE;
198	wk->li->type = IDM_MOVE;
199	break;
200	case IDM_WILDRENAME:
201	wildcarding = TRUE;
202	wk->li->type = IDM_RENAME;
203	break;
204	case IDM_WILDCOPY:
205	wildcarding = TRUE;
206	wk->li->type = IDM_COPY;
207	break;
208	case IDM_MOVEPRESERVE:
209	{
210	CHAR preserve[CCHMAXPATH], *end;
211
212	wk->li->type = IDM_MOVE;
213	strcpy(preserve, wk->li->list[0] + 2);
214	end = strrchr(preserve, '\\');
215	if (end) {
216	end++;
217	for (x = 1; wk->li->list[x]; x++) {
218	p = preserve;
219	pp = wk->li->list[x] + 2;
220	while (p < end && toupper(p) == toupper(pp)) {
221	p++;
222	pp++;
223	}
224	if (*p == '\\')
225	p++;
226	if (p < end)
227	end = p;
228	}
229	*end = 0;
230	}
231	else
232	*preserve = 0;
233	plen = strlen(preserve);
234	if (plen)
235	plen += 2;
236	}
237	break;
238	case IDM_COPYPRESERVE:
239	{
240	CHAR preserve[CCHMAXPATH], *end;
241
242	wk->li->type = IDM_COPY;
243	strcpy(preserve, wk->li->list[0] + 2);
244	end = strrchr(preserve, '\\');
245	if (end) {
246	end++;
247	for (x = 1; wk->li->list[x]; x++) {
248	p = preserve;
249	pp = wk->li->list[x] + 2;
250	while (p < end && toupper(p) == toupper(pp)) {
251	p++;
252	pp++;
253	}
254	if (*p == '\\')
255	p++;
256	if (p < end)
257	end = p;
258	}
259	*end = 0;
260	}
261	else
262	*preserve = 0;
263	plen = strlen(preserve);
264	if (plen)
265	plen += 2;
266	}
267	break;
268	}
269	if (wk->li && wk->li->list && wk->li->list[0]) {
270	for (x = 0; wk->li->list[x]; x++) {
271	switch (wk->li->type) {
272	case IDM_COLLECTFROMFILE:
273	if (Collector) {
274
275	CHAR *temp = xstrdup(wk->li->list[x], pszSrcFile, __LINE__);
276
277	if (temp) {
278	if (!PostMsg(Collector,
279	UM_COLLECTFROMFILE, MPFROMP(temp), MPVOID))
280	free(temp);
281	}
282	}
283	break;
284
285	case IDM_MERGEBINARY:
286	case IDM_MERGETEXT:
287	case IDM_MERGEBINARYAPPEND:
288	case IDM_MERGETEXTAPPEND:
289	{
290	FILE in, out;
291	CHAR moder, modew;
292	int c;
293
294	switch (wk->li->type) {
295	case IDM_MERGEBINARY:
296	moder = "rb";
297	modew = "wb";
298	break;
299	case IDM_MERGEBINARYAPPEND:
300	moder = "rb";
301	modew = "a+b";
302	break;
303	case IDM_MERGETEXTAPPEND:
304	moder = "r";
305	modew = "a+";
306	break;
307	default:
308	moder = "r";
309	modew = "w";
310	break;
311	}
312	in = _fsopen(wk->li->list[x], moder, SH_DENYWR);
313	if (!in) {
314	if (saymsg(MB_ENTERCANCEL,
315	HWND_DESKTOP,
316	GetPString(IDS_MERGEERRORTEXT),
317	GetPString(IDS_CANTOPENINPUTTEXT),
318	wk->li->list[x]) == MBID_CANCEL)
319	goto Abort;
320	}
321	else {
322	out = _fsopen(wk->li->targetpath, modew, SH_DENYWR);
323	if (out) {
324	fseek(out, 0L, SEEK_END);
325	switch (wk->li->type) {
326	case IDM_MERGEBINARY:
327	wk->li->type = IDM_MERGEBINARYAPPEND;
328	break;
329	default:
330	wk->li->type = IDM_MERGETEXTAPPEND;
331	break;
332	}
333	sprintf(message,
334	GetPString(IDS_MERGINGTEXT),
335	wk->li->list[x], wk->li->targetpath);
336	AddNote(message);
337	while ((c = fgetc(in)) != EOF)
338	fputc(c, out);
339	fclose(out);
340	sprintf(message,
341	GetPString(IDS_MERGECOMPLETETEXT),
342	wk->li->list[x], wk->li->targetpath);
343	AddNote(message);
344	}
345	else {
346	saymsg(MB_CANCEL,
347	HWND_DESKTOP,
348	GetPString(IDS_MERGEERRORTEXT),
349	GetPString(IDS_CANTOPENOUTPUTTEXT),
350	wk->li->targetpath);
351	fclose(in);
352	goto Abort;
353	}
354	fclose(in);
355	}
356	}
357	break;
358
359	case IDM_UUDECODE:
360	{
361	CHAR outname[CCHMAXPATH + 2];
362
363	sprintf(message,
364	GetPString(IDS_UUDECODINGTEXT), wk->li->list[x]);
365	AddNote(message);
366	if (UUD(wk->li->list[x], outname) && *outname) {
367	sprintf(message,
368	GetPString(IDS_UUDECODECOMPLETETEXT),
369	wk->li->list[x]);
370	AddNote(message);
371	if (fSyncUpdates \|\|
372	AddToList(outname, &files, &numfiles, &numalloc))
373	Broadcast(hab2,
374	wk->hwndCnr,
375	UM_UPDATERECORD, MPFROMP(outname), MPVOID);
376	}
377	else {
378	sprintf(message,
379	GetPString(IDS_UUDECODEABORTEDTEXT),
380	wk->li->list[x]);
381	AddNote(message);
382	}
383	}
384	break;
385
386	case IDM_VIEWARCHIVE:
387	if (IsFile(wk->li->list[x]) > 0) {
388
389	ARC_TYPE *info = NULL; // Say calling for editing - fixme to know why?
390
391	if (WinDlgBox(HWND_DESKTOP,
392	wk->hwndFrame,
393	SBoxDlgProc,
394	FM3ModHandle,
395	ASEL_FRAME, (PVOID) & info) && info) {
396	WinSendMsg(wk->hwndCnr,
397	UM_OPENWINDOWFORME,
398	MPFROMP(wk->li->list[x]), MPFROMP(info));
399	}
400	}
401	break;
402
403	case IDM_EXTRACT:
404	{
405	EXTRDATA ex;
406	BOOL maskspaces = FALSE;
407
408	memset(&ex, 0, sizeof(EXTRDATA));
409	ex.info = find_type(wk->li->list[x], NULL);
410	if (!ex.info \|\| (!ex.info->extract && !ex.info->exwdirs))
411	break;
412	ex.size = sizeof(EXTRDATA);
413	ex.arcname = wk->li->list[x];
414	strcpy(ex.masks, "*");
415	strcpy(ex.extractdir, wk->li->targetpath);
416	if (!WinDlgBox(HWND_DESKTOP,
417	wk->hwndFrame,
418	ExtractDlgProc,
419	FM3ModHandle,
420	EXT_FRAME,
421	(PVOID) & ex) \|\|
422	!ex.ret \|\|
423	!ex.command \|\| !ex.arcname \|\| !*ex.extractdir)
424	goto Abort;
425	{
426	FILESTATUS3 fsa;
427
428	DosError(FERR_DISABLEHARDERR);
429	if (DosQueryPathInfo(ex.extractdir,
430	FIL_STANDARD,
431	&fsa,
432	(ULONG) sizeof(FILESTATUS3)) \|\|
433	!(fsa.attrFile & FILE_DIRECTORY))
434	goto Abort;
435	}
436	if (needs_quoting(ex.masks) && !strchr(ex.masks, '\"'))
437	maskspaces = TRUE;
438	if (!runemf2(SEPARATE \| WINDOWED \|
439	fArcStuffVisible ? 0 : (BACKGROUND \| MINIMIZED),
440	HWND_DESKTOP, pszSrcFile, __LINE__, ex.extractdir, NULL,
441	"%s %s %s%s%s",
442	ex.command,
443	ex.arcname,
444	maskspaces ? "\"" : NullStr,
445	ex.masks ? ex.masks : "",
446	maskspaces ? "\"" : NullStr) &&
447	!stricmp(ex.extractdir, wk->directory)) {
448	if (WinIsWindow(hab2, wk->hwndCnr))
449	WinSendMsg(wk->hwndCnr,
450	WM_COMMAND,
451	MPFROM2SHORT(IDM_RESCAN, 0), MPVOID);
452	}
453	}
454	break;
455
456	case IDM_SUBJECT:
457	{
458	INT ret;
459
460	ret = Subject(wk->hwndFrame, wk->li->list[x]);
461	if (!ret)
462	goto Abort;
463	if (ret == 1) {
464	if (fSyncUpdates \|\|
465	AddToList(wk->li->list[x],
466	&files, &numfiles, &numalloc))
467	Broadcast(hab2,
468	wk->hwndCnr,
469	UM_UPDATERECORD,
470	MPFROMP(wk->li->list[x]), MPVOID);
471	}
472	}
473	break;
474
475	case IDM_INFO:
476	if (IsFullName(wk->li->list[x]) &&
477	!(driveflags[toupper(*wk->li->list[x]) - 'A'] &
478	DRIVE_INVALID)) {
479	if (!IsRoot(wk->li->list[x])) {
480
481	CHAR *list[2];
482
483	list[0] = wk->li->list[x];
484	list[1] = NULL;
485	if (!WinDlgBox(HWND_DESKTOP,
486	HWND_DESKTOP,
487	FileInfoProc,
488	FM3ModHandle, FLE_FRAME, (PVOID) list)) {
489	goto Abort;
490	}
491	}
492	else {
493	if (!WinDlgBox(HWND_DESKTOP,
494	HWND_DESKTOP,
495	DrvInfoProc,
496	FM3ModHandle,
497	INFO_FRAME, (PVOID) wk->li->list[x]))
498	goto Abort;
499	}
500	}
501	break;
502
503	case IDM_OPENWINDOW:
504	if (!IsFile(wk->li->list[x]) &&
505	WinIsWindow(hab2, wk->hwndCnr))
506	WinSendMsg(wk->hwndCnr,
507	UM_OPENWINDOWFORME,
508	MPFROMP(wk->li->list[x]), MPVOID);
509	break;
510
511	case IDM_OPENICON:
512	case IDM_OPENDETAILS:
513	case IDM_OPENTREE:
514	{
515	FILESTATUS3 fsa;
516
517	DosError(FERR_DISABLEHARDERR);
518	if (DosQueryPathInfo(wk->li->list[x],
519	FIL_STANDARD,
520	&fsa,
521	(ULONG) sizeof(FILESTATUS3)) \|\|
522	!(fsa.attrFile & FILE_DIRECTORY))
523	break;
524	}
525	/* else intentional fallthru */
526	case IDM_OPENDEFAULT:
527	case IDM_OPENSETTINGS:
528	{
529	CHAR *s;
530
531	switch (wk->li->type) {
532	case IDM_OPENICON:
533	s = "ICON";
534	break;
535	case IDM_OPENDETAILS:
536	s = "DETAILS";
537	break;
538	case IDM_OPENTREE:
539	s = "TREE";
540	break;
541	case IDM_OPENSETTINGS:
542	s = Settings;
543	break;
544	default:
545	s = Default;
546	break;
547	}
548	OpenObject(wk->li->list[x], s, wk->hwndFrame);
549	}
550	break;
551
552	case IDM_WPSMOVE:
553	case IDM_WPSCOPY:
554	case IDM_MOVE:
555	case IDM_COPY:
556	case IDM_RENAME:
557	{
558
559	INT iCounter = 0;
560
561	if (!*wk->li->targetpath && (wk->li->type == IDM_MOVE \|\|
562	wk->li->type == IDM_COPY \|\|
563	wk->li->type == IDM_WPSMOVE \|\|
564	wk->li->type == IDM_WPSCOPY)) {
565
566	APIRET rc = 1;
567
568	usedtarget = FALSE;
569	if (hwndMain) {
570	if (!*targetdir)
571	TopWindowName(hwndMain,
572	wk->hwndFrame, wk->li->targetpath);
573	else {
574	strcpy(wk->li->targetpath, targetdir);
575	usedtarget = TRUE;
576	}
577	}
578	if (!*wk->li->targetpath)
579	strcpy(wk->li->targetpath, wk->directory);
580	if (!*wk->li->targetpath) {
581	strcpy(wk->li->targetpath, wk->li->list[0]);
582	p = strrchr(wk->li->targetpath, '\\');
583	if (p) {
584	if (*(p - 1) == ':')
585	p++;
586	*p = 0;
587	}
588	}
589	MakeValidDir(wk->li->targetpath);
590	if (fConfirmTarget \|\|
591	(!*targetdir && strcmp(realappname, "FM/4"))) {
592	RetryPath:
593	usedtarget = FALSE;
594	if (wk->li->type == IDM_MOVE \|\|
595	wk->li->type == IDM_WPSMOVE) {
596	rc = WinDlgBox(HWND_DESKTOP,
597	wk->hwndFrame,
598	WalkMoveDlgProc,
599	FM3ModHandle,
600	WALK_FRAME, MPFROMP(wk->li->targetpath));
601	}
602	else if (wk->li->type == IDM_COPY \|\|
603	wk->li->type == IDM_WPSCOPY) {
604	rc = WinDlgBox(HWND_DESKTOP,
605	wk->hwndFrame,
606	WalkCopyDlgProc,
607	FM3ModHandle,
608	WALK_FRAME, MPFROMP(wk->li->targetpath));
609	}
610	else
611	rc = WinDlgBox(HWND_DESKTOP,
612	wk->hwndFrame,
613	WalkDlgProc,
614	FM3ModHandle,
615	WALK_FRAME, MPFROMP(wk->li->targetpath));
616	}
617	if (!rc \|\| !*wk->li->targetpath)
618	goto Abort;
619	if (driveflags[toupper(*wk->li->targetpath) - 'A'] &
620	DRIVE_NOTWRITEABLE) {
621	saymsg(MB_CANCEL,
622	wk->hwndFrame,
623	GetPString(IDS_ERRORTEXT),
624	"%s", GetPString(IDS_NOTWRITENOTARGETTEXT));
625	goto RetryPath;
626	}
627	}
628	Retry:
629	{
630	CHAR newname[CCHMAXPATH], moving, move, *moved;
631	APIRET rc;
632	INT type;
633	FILESTATUS4L fs4;
634	BOOL isnewer, existed;
635
636	type = (wk->li->type == IDM_RENAME) ? MOVE :
637	(wk->li->type == IDM_MOVE) ? MOVE :
638	(wk->li->type == IDM_WPSMOVE) ? WPSMOVE :
639	(wk->li->type == IDM_WPSCOPY) ? WPSCOPY : COPY;
640	moving = (wk->li->type == IDM_RENAME) ?
641	GetPString(IDS_RENAMINGTEXT) :
642	(wk->li->type == IDM_MOVE \|\|
643	wk->li->type == IDM_WPSMOVE) ?
644	GetPString(IDS_MOVINGTEXT) : GetPString(IDS_COPYINGTEXT);
645	move = (wk->li->type == IDM_RENAME) ?
646	GetPString(IDS_RENAMETEXT) :
647	(wk->li->type == IDM_MOVE \|\|
648	wk->li->type == IDM_WPSMOVE) ?
649	GetPString(IDS_MOVETEXT) : GetPString(IDS_COPYTEXT);
650	moved = (wk->li->type == IDM_RENAME) ?
651	GetPString(IDS_RENAMEDTEXT) :
652	(wk->li->type == IDM_MOVE \|\|
653	wk->li->type == IDM_WPSMOVE) ?
654	GetPString(IDS_MOVEDTEXT) : GetPString(IDS_COPIEDTEXT);
655	if (*wk->li->targetpath) {
656	strcpy(newname, wk->li->targetpath);
657	if (newname[strlen(newname) - 1] != '\\')
658	strcat(newname, "\\");
659	if (plen)
660	p = wk->li->list[x] + plen;
661	else {
662	p = strrchr(wk->li->list[x], '\\');
663	if (p)
664	p++;
665	else
666	p = wk->li->list[x];
667	}
668	strcat(newname, p);
669	}
670	else
671	strcpy(newname, wk->li->list[x]);
672	if ((wildcarding \|\| wk->li->type == IDM_RENAME) &&
673	*wildname) {
674
675	CHAR testname[CCHMAXPATH];
676
677	strcpy(testname, wildname);
678	if (AdjustWildcardName(newname, testname))
679	strcpy(newname, testname);
680	}
681	existed = (IsFile(newname) != -1);
682	isnewer = IsNewer(wk->li->list[x], newname);
683	/*
684	{
685	char temp[CCHMAXPATH * 3];
686	sprintf(temp,"Target: %s\rSource: %s\rOverold: %lu\rOvernew: %lu\rIsNewer: %lu\rExisted: %lu",newname,wk->li->list[x],overold,overnew,isnewer,existed);
687	saymsg(MB_ENTER,HWND_DESKTOP,DEBUG_STRING,temp);
688	}
689	*/
690	if (existed && wk->li->type != IDM_RENAME && dontask) {
691	if (!overold && !overnew)
692	break;
693	if (!overold && !isnewer)
694	break;
695	if (!overnew && isnewer)
696	break;
697	}
698	if ((wk->li->type == IDM_RENAME &&
699	(!dontask \|\| !*wildname)) \|\|
700	(!dontask && existed) \|\|
701	(!dontask && wildcarding) \|\|
702	(IsFile(newname) == 0 && IsFile(wk->li->list[x]) > 0)) {
703
704	MOVEIT mv;
705
706	memset(&mv, 0, sizeof(MOVEIT));
707	mv.rename = (wk->li->type == IDM_RENAME);
708	mv.source = wk->li->list[x];
709	strcpy(mv.target, newname);
710	rc = WinDlgBox(HWND_DESKTOP,
711	wk->hwndFrame,
712	RenameProc,
713	FM3ModHandle, REN_FRAME, (PVOID) & mv);
714	if (!rc)
715	goto Abort;
716	DosSleep(1);
717	if (mv.skip \|\| !*mv.target)
718	break;
719	if (mv.dontask)
720	dontask = TRUE;
721	if (mv.overold)
722	overold = TRUE;
723	if (mv.overnew)
724	overnew = TRUE;
725	if (wildcarding \|\| wk->li->type == IDM_RENAME) {
726	p = strrchr(mv.target, '\\');
727	if (p && (strchr(p, '*') \|\| strchr(p, '?'))) {
728	strcpy(wildname, mv.target);
729	AdjustWildcardName(wk->li->list[x], mv.target);
730	}
731	else
732	*wildname = 0;
733	}
734	strcpy(newname, mv.target);
735	existed = (IsFile(newname) != -1);
736	isnewer = IsNewer(wk->li->list[x], newname);
737	if (!mv.overwrite) {
738	if (existed && wk->li->type != IDM_RENAME && dontask) {
739	if (!overold && !overnew)
740	break;
741	if (!overold && !isnewer)
742	break;
743	if (!overnew && isnewer)
744	break;
745	}
746	}
747	}
748	if (!strcmp(wk->li->list[x], newname) \|\|
749	(wk->li->type == IDM_COPY &&
750	!stricmp(wk->li->list[x], newname)))
751	break;
752	sprintf(message,
753	" %s \"%s\" %s\"%s\"%s",
754	moving,
755	wk->li->list[x],
756	GetPString(IDS_TOTEXT),
757	newname,
758	(usedtarget) ? GetPString(IDS_TOTARGETTEXT) :
759	NullStr);
760	AddNote(message);
761	if (plen) {
762	/* make directory/ies, if required */
763
764	CHAR dirpart[CCHMAXPATH];
765
766	strcpy(dirpart, newname);
767	p = strrchr(dirpart, '\\');
768	if (p) {
769	*p = 0;
770	if (p > dirpart + 3)
771	MassMkdir((hwndMain) ? hwndMain : wk->hwndCnr,
772	dirpart);
773	}
774	}
775	if (fRealIdle)
776	priority_idle();
777	rc = docopyf(type, wk->li->list[x], "%s", newname);
778	priority_normal();
779	if (rc) {
780	if ((rc == ERROR_DISK_FULL \|\|
781	rc == ERROR_HANDLE_DISK_FULL) &&
782	isalpha(*newname) &&
783	(driveflags[toupper(*newname) - 'A'] &
784	DRIVE_REMOVABLE)
785	&& !(driveflags[toupper(*newname) - 'A'] &
786	DRIVE_NOTWRITEABLE)
787	&& toupper(newname) != toupper(wk->li->list[x])
788	&& !DosQueryPathInfo(wk->li->list[x], FIL_QUERYEASIZEL,
789	&fs4, sizeof(fs4))
790	&& !(fs4.attrFile & FILE_DIRECTORY)) {
791
792	FSALLOCATE fsa;
793	ULONGLONG ullFreeBytes;
794	CHAR *ptr;
795	INT cntr;
796
797	Notify(GetPString(IDS_FITTINGTEXT));
798	DosError(FERR_DISABLEHARDERR);
799	if (!DosQueryFSInfo(toupper(*newname) - '@',
800	FSIL_ALLOC,
801	&fsa, sizeof(FSALLOCATE))) {
802	// Assume large file support
803	ullFreeBytes = (ULONGLONG) fsa.cUnitAvail * fsa.cSectorUnit *
804	fsa.cbSector;
805	if (ullFreeBytes) {
806	// Find item that will fit in available space
807	for (cntr = x + 1; wk->li->list[cntr]; cntr++) {
808	DosError(FERR_DISABLEHARDERR);
809	if (!DosQueryPathInfo(wk->li->list[cntr],
810	FIL_QUERYEASIZEL,
811	&fs4,
812	sizeof(fs4)) &&
813	!(fs4.attrFile & FILE_DIRECTORY) &&
814	// fixme to use CBLIST_TO_EASIZE?
815	fs4.cbFile + fs4.cbList <= ullFreeBytes) {
816	// Swap with failing item
817	ptr = wk->li->list[x];
818	wk->li->list[x] = wk->li->list[cntr];
819	wk->li->list[cntr] = ptr;
820	goto Retry;
821	}
822	}
823	Notify(GetPString(IDS_COULDNTFITTEXT));
824	}
825	}
826	rc = saymsg(MB_ABORTRETRYIGNORE \| MB_ICONEXCLAMATION,
827	wk->hwndFrame,
828	GetPString(IDS_DISKFULLTEXT),
829	"%s", GetPString(IDS_ANOTHERDISKTEXT));
830	if (rc == MBID_RETRY)
831	goto Retry;
832	if (rc == MBID_ABORT)
833	goto Abort;
834	}
835	else if (rc == ERROR_PIPE_NOT_CONNECTED && iCounter < 25) {
836	DbgMsg(pszSrcFile, __LINE__, "ERROR_PIPE_NOT_CONNECTED retries %i", iCounter);
837	iCounter ++;
838	DosSleep(200);
839	goto Retry;
840	}
841	else {
842	if (LogFileHandle)
843	fprintf(LogFileHandle,
844	GetPString(IDS_LOGTOFAILEDTEXT),
845	move, wk->li->list[x], newname, rc);
846	rc = Dos_Error(MB_ENTERCANCEL,
847	rc,
848	wk->hwndFrame,
849	pszSrcFile,
850	__LINE__,
851	"%s %s \"%s\" %s\"%s\" %s.",
852	move,
853	GetPString(IDS_OFTEXT),
854	wk->li->list[x],
855	GetPString(IDS_TOTEXT),
856	newname, GetPString(IDS_FAILEDTEXT));
857	if (rc == MBID_CANCEL)
858	goto Abort;
859	}
860	}
861	else {
862	if (LogFileHandle)
863	fprintf(LogFileHandle,
864	"%s \"%s\" %s\"%s\"\n",
865	moved,
866	wk->li->list[x],
867	GetPString(IDS_TOTEXT), newname);
868	if (fSyncUpdates \|\|
869	AddToList(wk->li->list[x],
870	&files, &numfiles, &numalloc))
871	Broadcast(hab2,
872	wk->hwndCnr,
873	UM_UPDATERECORD,
874	MPFROMP(wk->li->list[x]), MPVOID);
875	if (fSyncUpdates \|\|
876	AddToList(newname, &files, &numfiles, &numalloc))
877	Broadcast(hab2,
878	wk->hwndCnr,
879	UM_UPDATERECORD, MPFROMP(newname), MPVOID);
880	}
881	}
882	break;
883	}
884
885	case IDM_COMPARE:
886	if ((!IsFile(wk->li->targetpath) \|\|
887	IsRoot(wk->li->targetpath)) &&
888	(!IsFile(wk->li->list[x]) \|\| IsRoot(wk->li->list[x]))) {
889	if (!*dircompare && WinIsWindow(hab2, wk->hwndCnr))
890	WinSendMsg(wk->hwndCnr,
891	UM_COMPARE,
892	MPFROMP(wk->li->targetpath),
893	MPFROMP(wk->li->list[x]));
894	else {
895	runemf2(SEPARATE,
896	HWND_DESKTOP, pszSrcFile, __LINE__,
897	NULL, NULL,
898	"%s %s %s",
899	dircompare,
900	BldQuotedFileName(szQuotedDirName, wk->li->targetpath),
901	BldQuotedFileName(szQuotedFileName, wk->li->list[x]));
902	}
903	}
904	else if (*compare) {
905	CHAR *fakelist[3];
906
907	fakelist[0] = wk->li->list[x];
908	fakelist[1] = wk->li->targetpath;
909	fakelist[2] = NULL;
910	ExecOnList(wk->hwndFrame,
911	compare,
912	WINDOWED \| SEPARATEKEEP, NULL, fakelist, NULL,
913	pszSrcFile, __LINE__);
914	}
915	else {
916	FCOMPARE fc;
917
918	memset(&fc, 0, sizeof(fc));
919	fc.size = sizeof(fc);
920	fc.hwndParent = wk->hwndParent;
921	strcpy(fc.file1, wk->li->list[x]);
922	strcpy(fc.file2, wk->li->targetpath);
923	if (WinDlgBox(HWND_DESKTOP,
924	wk->hwndFrame,
925	CFileDlgProc,
926	FM3ModHandle, FCMP_FRAME, (PVOID) & fc))
927	goto Abort;
928	}
929	break;
930	} // switch
931	DosSleep(0);
932	} // for list
933
934	switch (wk->li->type) {
935	case IDM_MOVE:
936	case IDM_COPY:
937	case IDM_WPSMOVE:
938	case IDM_WPSCOPY:
939	case IDM_RENAME:
940	sprintf(message,
941	GetPString(IDS_OPSCOMPLETETEXT),
942	(wk->li->type == IDM_MOVE) ?
943	GetPString(IDS_MOVETEXT) :
944	(wk->li->type == IDM_COPY) ?
945	GetPString(IDS_COPYTEXT) :
946	(wk->li->type == IDM_WPSMOVE) ?
947	GetPString(IDS_WPSMOVETEXT) :
948	(wk->li->type == IDM_WPSCOPY) ?
949	GetPString(IDS_WPSCOPYTEXT) :
950	GetPString(IDS_RENAMETEXT),
951	&"s"[x == 1],
952	(wk->li->type == IDM_MOVE \|\|
953	wk->li->type == IDM_COPY \|\|
954	wk->li->type == IDM_WPSMOVE \|\|
955	wk->li->type == IDM_WPSCOPY) ?
956	GetPString(IDS_TOTEXT) :
957	NullStr,
958	(wk->li->type == IDM_MOVE \|\|
959	wk->li->type == IDM_COPY \|\|
960	wk->li->type == IDM_WPSMOVE \|\|
961	wk->li->type == IDM_WPSCOPY) ?
962	wk->li->targetpath :
963	NullStr,
964	(x != 1) ?
965	GetPString(IDS_ARETEXT) : GetPString(IDS_ISTEXT));
966	Notify(message);
967	if (toupper(*wk->li->targetpath) < 'C')
968	DosBeep(1000, 25); // Wake up user
969	DosSleep(16);//05 Aug 07 GKY 33
970	if (wk->li->type == IDM_WPSMOVE \|\| wk->li->type == IDM_WPSCOPY)
971	DosSleep(48);//05 Aug 07 GKY 96
972	break;
973	default:
974	break;
975	}
976	}
977
978	Abort:
979
980	if (files) {
981	Broadcast(hab2,
982	wk->hwndCnr,
983	UM_UPDATERECORDLIST, MPFROMP(files), MPVOID);
984	FreeList(files);
985	}
986
987	if (WinIsWindow(hab2, wk->hwndCnr))
988	PostMsg(wk->hwndCnr, UM_RESCAN, MPVOID, MPVOID);
989
990	WinDestroyMsgQueue(hmq2);
991	}
992	DecrThreadUsage();
993	WinTerminate(hab2);
994	}
995	}
996
997	if (wk->li)
998	FreeListInfo(wk->li);
999	free(wk);
1000	# ifdef FORTIFY
1001	Fortify_LeaveScope();
1002	# endif
1003	DosPostEventSem(CompactSem);
1004	}
1005	}
1006
1007	VOID MassAction(VOID * args)
1008	{
1009	WORKER wk = (WORKER ) args;
1010	HAB hab2;
1011	HMQ hmq2;
1012	CHAR **files = NULL;
1013	register CHAR p, pp;
1014	UINT numfiles = 0, numalloc = 0;
1015
1016
1017	if (wk) {
1018	# ifdef FORTIFY
1019	// Fortify_BecomeOwner(wk);
1020	Fortify_EnterScope();
1021	# endif
1022	if (wk->li && wk->li->list && wk->li->list[0]) {
1023	hab2 = WinInitialize(0);
1024	if (hab2) {
1025	hmq2 = WinCreateMsgQueue(hab2, 0);
1026	if (hmq2) {
1027	WinCancelShutdown(hmq2, TRUE);
1028	IncrThreadUsage();
1029	DosError(FERR_DISABLEHARDERR);
1030	if (IsRoot(wk->li->list[0]) \|\| !IsFile(wk->li->list[0])) {
1031	if (wk->li->type == IDM_VIEW)
1032	wk->li->type = IDM_INFO;
1033	if (wk->li->type == IDM_EDIT)
1034	wk->li->type = IDM_EAS;
1035	}
1036	switch (wk->li->type) {
1037	case IDM_INFO:
1038	if (WinDlgBox(HWND_DESKTOP,
1039	wk->hwndFrame,
1040	FileInfoProc,
1041	FM3ModHandle, FLE_FRAME, (PVOID) wk->li->list) != 2)
1042	{
1043	break;
1044	}
1045	/* else intentional fallthru */
1046	case IDM_UPDATE:
1047	Broadcast(hab2,
1048	wk->hwndCnr,
1049	UM_UPDATERECORDLIST, MPFROMP(wk->li->list), MPVOID);
1050	break;
1051
1052	case IDM_EAS:
1053	if (WinDlgBox(HWND_DESKTOP,
1054	wk->hwndFrame,
1055	DisplayEAsProc,
1056	FM3ModHandle, EA_FRAME, (PVOID) wk->li->list))
1057	Broadcast(hab2,
1058	wk->hwndCnr,
1059	UM_UPDATERECORDLIST, MPFROMP(wk->li->list), MPVOID);
1060	break;
1061
1062	case IDM_DOITYOURSELF:
1063	ExecOnList(wk->hwndFrame,
1064	"%a",
1065	WINDOWED \| SEPARATE \| PROMPT,
1066	NULL, wk->li->list, GetPString(IDS_DOITYOURSELFTEXT),
1067	pszSrcFile, __LINE__);
1068	break;
1069
1070	case IDM_MCIPLAY:
1071	{
1072	register INT x;
1073	register ULONG total;
1074	CHAR fbuf[CCHMAXPATH];
1075
1076	if (DosSearchPath(SEARCH_IGNORENETERRS \| SEARCH_ENVIRONMENT \|
1077	SEARCH_CUR_DIRECTORY,
1078	"PATH", "FM2PLAY.EXE", fbuf, CCHMAXPATH - 1))
1079	total += strlen("..\\FM2UTILS\\FM2PLAY.EXE ");
1080	else
1081	total = strlen(fbuf);
1082	for (x = 0; wk->li->list[x]; x++)
1083	total += (strlen(wk->li->list[x]) + 1 +
1084	(needs_quoting(wk->li->list[x]) * 2));
1085	if (total > 1000) {
1086
1087	FILE *fp;
1088	CHAR szTempFile[CCHMAXPATH];
1089
1090	BldFullPathName(szTempFile, pTmpDir, "$FM2PLAY.$$$");
1091	fp = xfopen(szTempFile, "w", pszSrcFile, __LINE__);
1092	if (fp) {
1093	fprintf(fp, "%s", ";AV/2-built FM2Play listfile\n");
1094	for (x = 0; wk->li->list[x]; x++)
1095	fprintf(fp, "%s\n", wk->li->list[x]);
1096	fprintf(fp, ";end\n");
1097	fclose(fp);
1098	strrev(szTempFile);
1099	strcat(szTempFile, "@/");
1100	strrev(szTempFile);
1101	RunFM2Util("FM2PLAY.EXE", szTempFile);
1102	}
1103	}
1104	}
1105	/* intentional fallthru */
1106	case IDM_FAKEEXTRACT:
1107	case IDM_FAKEEXTRACTM:
1108	if (wk->li->type == IDM_MCIPLAY \|\|
1109	(*wk->li->arcname && wk->li->info &&
1110	wk->li->info->extract && *wk->li->targetpath)) {
1111
1112	CHAR szBuffer[1025];
1113	CHAR fbuf[CCHMAXPATH];
1114	register INT x;
1115
1116	if (wk->li->type == IDM_FAKEEXTRACT \|\|
1117	wk->li->type == IDM_FAKEEXTRACTM) {
1118	strcpy(szBuffer,
1119	(wk->li->info->exwdirs) ?
1120	wk->li->info->exwdirs : wk->li->info->extract);
1121	strcat(szBuffer, " ");
1122	BldQuotedFileName(szBuffer + strlen(szBuffer), wk->li->arcname);
1123	}
1124	else {
1125	if (DosSearchPath(SEARCH_IGNORENETERRS \| SEARCH_ENVIRONMENT \|
1126	SEARCH_CUR_DIRECTORY,
1127	"PATH", "FM2PLAY.EXE", fbuf, CCHMAXPATH - 1))
1128	strcpy(szBuffer, "UTILS\\FM2PLAY.EXE");
1129	else
1130	strcpy(szBuffer, "FM2PLAY.EXE");
1131	}
1132	p = &szBuffer[strlen(szBuffer)];
1133	strcat(szBuffer, " ");
1134	x = 0;
1135	while (wk->li->list[x]) {
1136	pp = wk->li->list[x];
1137	while (*pp) {
1138	if (*pp == '/')
1139	*pp = '\\';
1140	pp++;
1141	}
1142	BldQuotedFileName(szBuffer + strlen(szBuffer), wk->li->list[x]);
1143	x++;
1144	if (!wk->li->list[x] \|\| strlen(szBuffer) +
1145	strlen(wk->li->list[x]) + 5 > 1024) {
1146	runemf2(SEPARATE \| WINDOWED \| BACKGROUND \| MINIMIZED \| WAIT,
1147	HWND_DESKTOP, pszSrcFile, __LINE__,
1148	(wk->li->type == IDM_FAKEEXTRACT \|\|
1149	wk->li->type == IDM_FAKEEXTRACTM) ?
1150	wk->li->targetpath : NULL,
1151	NULL,
1152	"%s", szBuffer);
1153	DosSleep(1);
1154	*p = 0;
1155	}
1156	strcat(szBuffer, " ");
1157	}
1158	if (wk->li->type == IDM_MCIPLAY)
1159	break;
1160	strcpy(szBuffer, wk->li->targetpath);
1161	if (wk->li->targetpath[strlen(wk->li->targetpath) - 1] != '\\')
1162	strcat(szBuffer, "\\");
1163	p = szBuffer + strlen(szBuffer);
1164	for (x = 0; wk->li->list[x]; x++) {
1165	strcpy(p, wk->li->list[x]);
1166	free(wk->li->list[x]);
1167	wk->li->list[x] = xstrdup(szBuffer, pszSrcFile, __LINE__);
1168	}
1169	if (wk->li->list[0])
1170	Broadcast(hab2,
1171	wk->hwndCnr,
1172	UM_UPDATERECORDLIST, MPFROMP(wk->li->list), MPVOID);
1173	}
1174	break;
1175
1176	case IDM_SETICON:
1177	if (*wk->li->targetpath) {
1178
1179	ICONINFO ici;
1180
1181	memset(&ici, 0, sizeof(ICONINFO));
1182	ici.cb = sizeof(ICONINFO);
1183	ici.fFormat = ICON_FILE;
1184	ici.pszFileName = wk->li->list[0];
1185	if (!WinSetFileIcon((PSZ) wk->li->targetpath,
1186	(PICONINFO) & ici)) {
1187	ici.fFormat = ICON_CLEAR;
1188	WinSetFileIcon((PSZ) wk->li->targetpath, (PICONINFO) & ici);
1189	}
1190	Broadcast(hab2,
1191	wk->hwndCnr,
1192	UM_UPDATERECORD, MPFROMP(wk->li->targetpath), MPVOID);
1193	}
1194	break;
1195
1196	case IDM_APPENDTOCLIP:
1197	case IDM_SAVETOCLIP:
1198	case IDM_SAVETOCLIPFILENAME:
1199	case IDM_APPENDTOCLIPFILENAME:
1200	ListToClipboardHab(hab2,
1201	wk->li->list,
1202	wk->li->type);
1203	break;
1204
1205	case IDM_ARCHIVEM:
1206	case IDM_ARCHIVE:
1207	{
1208	DIRCNRDATA ad;
1209	CHAR szBuffer[1025];
1210	ARC_TYPE *info = NULL;
1211	char *pch;
1212	register INT x;
1213
1214	memset(&ad, 0, sizeof(DIRCNRDATA));
1215	strcpy(ad.arcname, wk->li->targetpath);
1216	if (*wk->li->targetpath && IsFile(wk->li->targetpath) > 0) {
1217	info = find_type(wk->li->targetpath, NULL);
1218	ad.namecanchange = 0;
1219	}
1220	else {
1221	if (*wk->li->targetpath && !IsFile(wk->li->targetpath))
1222	if (wk->li->targetpath[strlen(wk->li->targetpath) - 1] !=
1223	'\\')
1224	strcat(wk->li->targetpath, "\\");
1225	ad.namecanchange = 1;
1226	}
1227	strcpy(ad.arcname, wk->li->targetpath);
1228	if (wk->li->type == IDM_ARCHIVEM)
1229	ad.fmoving = TRUE;
1230	if (!info) {
1231	ad.info = arcsighead; // Hide dups
1232	if (!WinDlgBox(HWND_DESKTOP,
1233	wk->hwndFrame,
1234	SBoxDlgProc,
1235	FM3ModHandle,
1236	ASEL_FRAME, (PVOID) & ad.info) \|\| !ad.info) {
1237	break; /* we blew it */
1238	}
1239	}
1240	else
1241	ad.info = info;
1242	if (!ad.info \|\| (!ad.info->create &&
1243	!ad.info->move &&
1244	!ad.info->createwdirs &&
1245	!ad.info->movewdirs &&
1246	!ad.info->createrecurse))
1247	break;
1248	if (!wk->li->targetpath && wk->directory) {
1249	strcpy(ad.arcname, wk->directory);
1250	if (ad.arcname[strlen(ad.arcname) - 1] != '\\')
1251	strcat(ad.arcname, "\\");
1252	}
1253	if (!WinDlgBox(HWND_DESKTOP, wk->hwndFrame, ArchiveDlgProc, FM3ModHandle,
1254	ARCH_FRAME, (PVOID) & ad) \|\| !ad.arcname \|\| !ad.command) /* we blew it */
1255	break;
1256	// Provide extension so containers work
1257	pch = strrchr(ad.arcname, '\\');
1258	if (pch)
1259	pch = strrchr(pch, '.');
1260	else
1261	pch = strrchr(ad.arcname, '.');
1262	if (!pch && ad.info->ext) {
1263	strcat(ad.arcname, ".");
1264	strcat(ad.arcname, ad.info->ext);
1265	}
1266	/* build the sucker */
1267	strcpy(szBuffer, ad.command);
1268	strcat(szBuffer, " ");
1269	BldQuotedFileName(szBuffer + strlen(szBuffer), ad.arcname);
1270	p = &szBuffer[strlen(szBuffer)];
1271	if (ad.mask.szMask) {
1272	strcat(szBuffer, " ");
1273	strcat(szBuffer, ad.mask.szMask);
1274	}
1275	strcat(szBuffer, " ");
1276	x = 0;
1277	while (wk->li->list[x]) {
1278	FILESTATUS3 fsa;
1279	memset(&fsa, 0, sizeof(FILESTATUS3));
1280	DosError(FERR_DISABLEHARDERR);
1281	DosQueryPathInfo(wk->li->list[x],
1282	FIL_STANDARD,
1283	&fsa, (ULONG) sizeof(FILESTATUS3));
1284	if (fsa.attrFile & FILE_DIRECTORY) {
1285	BldQuotedFullPathName(szBuffer + strlen(szBuffer), wk->li->list[x], "*");
1286	}
1287	else
1288	BldQuotedFileName(szBuffer + strlen(szBuffer), wk->li->list[x]);
1289	x++;
1290	if (!wk->li->list[x] \|\|
1291	strlen(szBuffer) + strlen(wk->li->list[x]) + 5 > 1024) {
1292	runemf2(SEPARATE \| WINDOWED \| WAIT \|
1293	(fArcStuffVisible ? 0 : (BACKGROUND \| MINIMIZED)),
1294	HWND_DESKTOP, pszSrcFile, __LINE__, NULL, NULL,
1295	"%s", szBuffer);
1296	DosSleep(1);
1297	*p = 0;
1298	}
1299	strcat(szBuffer, " ");
1300	}
1301	Broadcast(hab2,
1302	wk->hwndCnr,
1303	UM_UPDATERECORDLIST, MPFROMP(wk->li->list), MPVOID);
1304	Broadcast(hab2,
1305	wk->hwndCnr,
1306	UM_UPDATERECORD, MPFROMP(ad.arcname), MPVOID);
1307	}
1308	break;
1309
1310	case IDM_VIEW:
1311	if (!TestBinary(wk->li->list[0])) {
1312	wk->li->type = IDM_VIEWTEXT;
1313	goto SkipViewing;
1314	}
1315	else
1316	wk->li->type = IDM_VIEWBINARY;
1317	/* intentional fallthru */
1318	case IDM_VIEWBINARY:
1319	if (*binview) {
1320	ExecOnList((HWND) 0,
1321	binview,
1322	WINDOWED \| SEPARATE, NULL, wk->li->list, NULL,
1323	pszSrcFile, __LINE__);
1324	break;
1325	}
1326	/* else intentional fallthru */
1327	case IDM_VIEWTEXT:
1328	SkipViewing:
1329	if (*viewer)
1330	ExecOnList((HWND) 0, viewer,
1331	WINDOWED \| SEPARATE \|
1332	((fViewChild) ? CHILD : 0),
1333	NULL, wk->li->list, NULL,
1334	pszSrcFile, __LINE__);
1335	else {
1336
1337	CHAR *temp;
1338	register INT x;
1339	ULONG viewtype;
1340
1341	viewtype = (wk->li->type == IDM_VIEWTEXT) ? 8 :
1342	(wk->li->type == IDM_VIEWBINARY) ? 16 : 0;
1343	for (x = 0; wk->li->list[x]; x++) {
1344	temp = xstrdup(wk->li->list[x], pszSrcFile, __LINE__);
1345	if (temp && WinIsWindow(hab2, wk->hwndCnr)) {
1346	if (!PostMsg(wk->hwndCnr,
1347	UM_LOADFILE,
1348	MPFROMLONG(5 + viewtype), MPFROMP(temp)))
1349	free(temp);
1350	}
1351	DosSleep(1);
1352	}
1353	}
1354	break;
1355
1356	case IDM_EDIT:
1357	if (!TestBinary(wk->li->list[0])) {
1358	wk->li->type = IDM_EDITTEXT;
1359	goto SkipEditing;
1360	}
1361	else
1362	wk->li->type = IDM_EDITBINARY;
1363	/* intentional fallthru */
1364	case IDM_EDITBINARY:
1365	if (*bined) {
1366	ExecOnList((HWND) 0,
1367	bined,
1368	WINDOWED \| SEPARATE, NULL, wk->li->list, NULL,
1369	pszSrcFile, __LINE__);
1370	break;
1371	}
1372	/* else intentional fallthru */
1373	case IDM_EDITTEXT:
1374	SkipEditing:
1375	if (*editor)
1376	ExecOnList((HWND) 0,
1377	editor,
1378	WINDOWED \| SEPARATE, NULL, wk->li->list, NULL,
1379	pszSrcFile, __LINE__);
1380	else {
1381
1382	CHAR *temp;
1383	register INT x;
1384	ULONG viewtype;
1385
1386	viewtype = (wk->li->type == IDM_EDITTEXT) ? 8 :
1387	(wk->li->type == IDM_EDITBINARY) ? 16 : 0;
1388	for (x = 0; wk->li->list[x]; x++) {
1389	temp = xstrdup(wk->li->list[x], pszSrcFile, __LINE__);
1390	if (temp && WinIsWindow(hab2, wk->hwndCnr)) {
1391	if (!PostMsg(wk->hwndCnr,
1392	UM_LOADFILE,
1393	MPFROMLONG(4 + viewtype), MPFROMP(temp)))
1394	free(temp);
1395	}
1396	DosSleep(1);
1397	}
1398	}
1399	break;
1400
1401	case IDM_SHADOW2:
1402	case IDM_OBJECT:
1403	case IDM_SHADOW:
1404	{
1405	CHAR objectpath[CCHMAXPATH];
1406	APIRET rc;
1407
1408	if (!*wk->li->targetpath \|\| IsFile(wk->li->targetpath)) {
1409	GetDesktopName(objectpath, sizeof(objectpath));
1410	rc = WinDlgBox(HWND_DESKTOP,
1411	wk->hwndFrame,
1412	ObjCnrDlgProc,
1413	FM3ModHandle,
1414	OBJCNR_FRAME, MPFROMP(objectpath));
1415	if (rc) {
1416	if (rc > 1)
1417	strcpy(objectpath, "<WP_DESKTOP>");
1418	}
1419	else
1420	break;
1421	}
1422	else
1423	strcpy(objectpath, wk->li->targetpath);
1424	AddNote(GetPString(IDS_MAKINGOBJSTEXT));
1425	MakeShadows(wk->hwndFrame,
1426	wk->li->list,
1427	(wk->li->type == IDM_SHADOW) +
1428	(wk->li->type == IDM_SHADOW2) * 2,
1429	objectpath, NULL);
1430	AddNote(GetPString(IDS_MADEOBJSTEXT));
1431	}
1432	break;
1433
1434	case IDM_PRINT:
1435	if (WinDlgBox(HWND_DESKTOP,
1436	wk->hwndFrame,
1437	PrintDlgProc,
1438	FM3ModHandle, PRN_FRAME, MPFROMP(wk->li))) {
1439	if (wk->li && wk->li->list && wk->li->list[0]) {
1440	strcpy(wk->li->targetpath, printer);
1441	if (_beginthread(PrintListThread, NULL, 65536, (PVOID) wk->li)
1442	== -1)
1443	Runtime_Error(pszSrcFile, __LINE__,
1444	GetPString(IDS_COULDNTSTARTTHREADTEXT));
1445	else
1446	wk->li = NULL; /* prevent LISTINFO li from being freed */
1447	}
1448	}
1449	break;
1450
1451	case IDM_ATTRS:
1452	if (WinDlgBox(HWND_DESKTOP,
1453	wk->hwndFrame,
1454	AttrListDlgProc,
1455	FM3ModHandle, ATR_FRAME, MPFROMP(wk->li))) {
1456	if (wk->li && wk->li->list && wk->li->list[0])
1457	Broadcast(hab2,
1458	wk->hwndCnr,
1459	UM_UPDATERECORDLIST, MPFROMP(wk->li->list), MPVOID);
1460	}
1461	break;
1462
1463	case IDM_PERMDELETE:
1464	case IDM_DELETE:
1465	{
1466	CHECKLIST cl;
1467	INT isdir = 0, sysdir = 0, ro = 0, hs = 0;
1468	register INT x;
1469	FILESTATUS3 fsa;
1470	CHAR prompt[CCHMAXPATH * 3];
1471	APIRET error = 0;
1472	HOBJECT hObjectdest, hObjectofObject;
1473	BYTE G_abSupportedDrives[24] = {0};
1474	ULONG cbSupportedDrives = sizeof(G_abSupportedDrives);
1475
1476	for (x = 0; wk->li->list[x]; x++) {
1477	if (IsRoot(wk->li->list[x])) {
1478	wk->li->list = RemoveFromList(wk->li->list,
1479	wk->li->list[x]);
1480	if (!wk->li->list)
1481	break;
1482	x--;
1483	continue;
1484	}
1485	DosError(FERR_DISABLEHARDERR);
1486	if (DosQueryPathInfo(wk->li->list[x],
1487	FIL_STANDARD, &fsa,
1488	(ULONG) sizeof(FILESTATUS3))) {
1489	wk->li->list = RemoveFromList(wk->li->list,
1490	wk->li->list[x]);
1491	if (!wk->li->list)
1492	break;
1493	x--;
1494	continue;
1495	}
1496	if (fsa.attrFile & FILE_DIRECTORY) {
1497	isdir++;
1498	if (stristr(wk->li->list[x], ":\\OS2\\") \|\|
1499	!stricmp(wk->li->list[x] + 1, ":\\OS2"))
1500	sysdir++;
1501	}
1502	else {
1503	if (fsa.attrFile & (FILE_HIDDEN \| FILE_SYSTEM))
1504	hs++;
1505	if (fsa.attrFile & FILE_READONLY)
1506	ro++;
1507	}
1508	}
1509	if (!wk->li->list)
1510	break;
1511	if (fConfirmDelete \|\| isdir \|\| hs \|\| ro) {
1512	memset(&cl, 0, sizeof(cl));
1513	cl.size = sizeof(cl);
1514	cl.list = wk->li->list;
1515	cl.prompt = prompt;
1516	cl.flags \|= CHECK_FILES;
1517	cl.cmd = wk->li->type;
1518	sprintf(prompt,
1519	GetPString(IDS_DELPROMPT1TEXT),
1520	(wk->li->type == IDM_DELETE) ?
1521	NullStr :
1522	GetPString(IDS_PERMANENTLYTEXT),
1523	&"s"[wk->li->list[1] == NULL]);
1524	if (isdir) {
1525	sprintf(&prompt[strlen(prompt)],
1526	GetPString(IDS_DELPROMPT2TEXT),
1527	isdir,
1528	(isdir > 1) ?
1529	GetPString(IDS_ARETEXT) :
1530	GetPString(IDS_ISTEXT),
1531	(isdir == 1) ?
1532	GetPString(IDS_ATEXT) :
1533	NullStr,
1534	(isdir > 1) ?
1535	GetPString(IDS_IESTEXT) : GetPString(IDS_YTEXT));
1536	if (sysdir)
1537	sprintf(&prompt[strlen(prompt)],
1538	GetPString(IDS_DELPROMPT3TEXT),
1539	sysdir,
1540	(sysdir == 1) ?
1541	GetPString(IDS_YTEXT) : GetPString(IDS_IESTEXT));
1542	}
1543	if (ro)
1544	sprintf(&prompt[strlen(prompt)],
1545	GetPString(IDS_DELPROMPT4TEXT),
1546	ro,
1547	&"s"[ro == 1],
1548	(ro > 1) ?
1549	GetPString(IDS_ARETEXT) : GetPString(IDS_ISTEXT));
1550	if (hs)
1551	sprintf(&prompt[strlen(prompt)],
1552	GetPString(IDS_DELPROMPT5TEXT),
1553	hs,
1554	&"s"[hs == 1],
1555	(hs > 1) ?
1556	GetPString(IDS_ARETEXT) : GetPString(IDS_ISTEXT));
1557	if (ro \|\| hs \|\| sysdir)
1558	DosBeep(300, 100); // Wake up user
1559	strcat(prompt, GetPString(IDS_DELPROMPT6TEXT));
1560	error = WinDlgBox(HWND_DESKTOP,
1561	wk->hwndFrame,
1562	CheckListProc,
1563	FM3ModHandle, CHECK_FRAME, MPFROMP(&cl));
1564	if (!error \|\| error == 65535)
1565	break;
1566	wk->li->list = cl.list;
1567	if (!wk->li->list \|\| !wk->li->list[0])
1568	break;
1569	}
1570	for (x = 0; wk->li->list[x]; x++) {
1571	fsa.attrFile = 0;
1572	DosError(FERR_DISABLEHARDERR);
1573	DosQueryPathInfo(wk->li->list[x],
1574	FIL_STANDARD,
1575	&fsa, (ULONG) sizeof(FILESTATUS3));
1576	if (fsa.attrFile & FILE_DIRECTORY) {
1577	sprintf(prompt,
1578	GetPString(IDS_DELETINGTEXT), wk->li->list[x]);
1579	AddNote(prompt);
1580	error = (APIRET) wipeallf("%s%s*",
1581	wk->li->list[x],
1582	(*wk->li->list[x] &&
1583	wk->li->
1584	list[x][strlen(wk->li->list[x]) -
1585	1] !=
1586	'\\') ? "\\" : NullStr);
1587	DosError(FERR_DISABLEHARDERR);
1588	if (!error)
1589	error = DosDeleteDir(wk->li->list[x]);
1590	else
1591	DosDeleteDir(wk->li->list[x]);
1592	}
1593	else {
1594	sprintf(prompt,
1595	GetPString(IDS_DELETINGTEXT), wk->li->list[x]);
1596	AddNote(prompt);
1597	DosError(FERR_DISABLEHARDERR);
1598	if (wk->li->type == IDM_DELETE){
1599	hObjectdest = WinQueryObject("<XWP_TRASHCAN>");
1600	PrfQueryProfileData(HINI_USER,
1601	"XWorkplace",
1602	"TrashCan::Drives",
1603	G_abSupportedDrives,
1604	&cbSupportedDrives);
1605	if (hObjectdest != NULLHANDLE && fTrashCan &&
1606	(G_abSupportedDrives ? (G_abSupportedDrives[toupper(*wk->li->list[x]) - 'C'] &
1607	1):(!(driveflags[toupper(*wk->li->list[x]) - 'A'] &
1608	(DRIVE_REMOVABLE \| DRIVE_IGNORE \|
1609	DRIVE_REMOTE \| DRIVE_VIRTUAL \|
1610	DRIVE_NOTWRITEABLE \| DRIVE_RAMDISK))))) {
1611	hObjectofObject = WinQueryObject(wk->li->list[x]);
1612	error = WinMoveObject(hObjectofObject, hObjectdest, 0);
1613	}
1614	else
1615	error = DosDelete(wk->li->list[x]);
1616	}
1617	else
1618	error = DosForceDelete(wk->li->list[x]);
1619	if (error) {
1620	DosError(FERR_DISABLEHARDERR);
1621	make_deleteable(wk->li->list[x]);
1622	if (wk->li->type == IDM_DELETE){
1623	hObjectdest = WinQueryObject("<XWP_TRASHCAN>");
1624	PrfQueryProfileData(HINI_USER,
1625	"XWorkplace",
1626	"TrashCan::Drives",
1627	G_abSupportedDrives,
1628	&cbSupportedDrives);
1629	if (hObjectdest != NULLHANDLE && fTrashCan &&
1630	(G_abSupportedDrives ? (G_abSupportedDrives[toupper(*wk->li->list[x]) - 'C'] &
1631	1):(!(driveflags[toupper(*wk->li->list[x]) - 'A'] &
1632	(DRIVE_REMOVABLE \| DRIVE_IGNORE \|
1633	DRIVE_REMOTE \| DRIVE_VIRTUAL \|
1634	DRIVE_NOTWRITEABLE \| DRIVE_RAMDISK))))) {
1635	hObjectofObject = WinQueryObject(wk->li->list[x]);
1636	error = WinMoveObject(hObjectofObject, hObjectdest, 0);
1637	}
1638	else
1639	error = DosDelete(wk->li->list[x]);
1640	}
1641	else
1642	error = DosForceDelete(wk->li->list[x]);
1643	}
1644	}
1645	if (error) {
1646	if (LogFileHandle)
1647	fprintf(LogFileHandle,
1648	GetPString(IDS_DELETEFAILED1TEXT),
1649	wk->li->list[x], error);
1650	if (Dos_Error(MB_ENTERCANCEL,
1651	error,
1652	wk->hwndFrame,
1653	pszSrcFile,
1654	__LINE__,
1655	GetPString(IDS_DELETEFAILED2TEXT),
1656	wk->li->list[x]) == MBID_CANCEL)
1657	break;
1658	}
1659	else {
1660	if (LogFileHandle)
1661	fprintf(LogFileHandle,
1662	GetPString(IDS_DELETEDTEXT), wk->li->list[x]);
1663	sprintf(prompt,
1664	GetPString(IDS_DELETEDTEXT), wk->li->list[x]);
1665	AddNote(prompt);
1666	}
1667	if (fSyncUpdates \|\|
1668	AddToList(wk->li->list[x], &files, &numfiles, &numalloc))
1669	Broadcast(hab2,
1670	wk->hwndCnr,
1671	UM_UPDATERECORD,
1672	MPFROMP(wk->li->list[x]), MPVOID);
1673	}
1674	}
1675	break;
1676	} // switch
1677	if (files) {
1678	Broadcast(hab2,
1679	wk->hwndCnr,
1680	UM_UPDATERECORDLIST, MPFROMP(files), MPVOID);
1681	FreeList(files);
1682	}
1683	if (WinIsWindow(hab2, wk->hwndCnr))
1684	PostMsg(wk->hwndCnr, UM_RESCAN, MPVOID, MPVOID);
1685
1686	WinDestroyMsgQueue(hmq2);
1687	}
1688	DecrThreadUsage();
1689	WinTerminate(hab2);
1690	}
1691	}
1692	if (wk->li)
1693	FreeListInfo(wk->li);
1694	free(wk);
1695	# ifdef FORTIFY
1696	Fortify_LeaveScope();
1697	# endif
1698	DosPostEventSem(CompactSem);
1699	}
1700	}
1701	#pragma alloc_text(MASSACTION,MassAction)
1702	#pragma alloc_text(ACTION,Action)
1703	#pragma alloc_text(UNDO,FreeUndo,Undo)

Note: See TracBrowser for help on using the repository browser.

Download in other formats: