Context Navigation

source: trunk/dll/worker.c@ 40

Visit:

Last change on this file since 40 was 40, checked in by root, 23 years ago
MassAction:Archive - force extension so file found
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 67.9 KB

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

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

Download in other formats: