Context Navigation

source: trunk/dll/worker.c@ 38

Visit:

Last change on this file since 38 was 36, checked in by root, 23 years ago
Handle large partitions
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 67.6 KB

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

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

Download in other formats: