Context Navigation

source: trunk/dll/worker.c@ 1859

Visit:

Last change on this file since 1859 was 1859, checked in by John Small, 10 years ago
Corrected typo in previous comment.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 53.6 KB

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

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

Download in other formats: