Context Navigation

source: trunk/dll/worker.c@ 51

Visit:

Last change on this file since 51 was 51, checked in by root, 23 years ago
Standardize EA match
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 51 2003-02-12 20:22:14Z 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	// fixme to use CBLIST_TO_EASIZE?
849	fs4.cbFile + fs4.cbList <= clFreeBytes) {
850	// Swap with failing item
851	ptr = wk->li->list[x];
852	wk->li->list[x] = wk->li->list[cntr];
853	wk->li->list[cntr] = ptr;
854	goto Retry;
855	}
856	}
857	Notify(GetPString(IDS_COULDNTFITTEXT));
858	}
859	}
860	rc = saymsg(MB_ABORTRETRYIGNORE \| MB_ICONEXCLAMATION,
861	wk->hwndFrame,
862	GetPString(IDS_DISKFULLTEXT),
863	"%s",
864	GetPString(IDS_ANOTHERDISKTEXT));
865	if(rc == MBID_RETRY)
866	goto Retry;
867	if(rc == MBID_ABORT)
868	goto Abort;
869	}
870	else {
871	if(LogFileHandle)
872	fprintf(LogFileHandle,
873	GetPString(IDS_LOGTOFAILEDTEXT),
874	move,
875	wk->li->list[x],
876	newname,rc);
877	rc = Dos_Error(MB_ENTERCANCEL,
878	rc,
879	wk->hwndFrame,
880	__FILE__,
881	__LINE__,
882	"%s %s \"%s\" %s\"%s\" %s.",
883	move,
884	GetPString(IDS_OFTEXT),
885	wk->li->list[x],
886	GetPString(IDS_TOTEXT),
887	newname,
888	GetPString(IDS_FAILEDTEXT));
889	if(rc == MBID_CANCEL)
890	goto Abort;
891	}
892	}
893	else {
894	if(LogFileHandle)
895	fprintf(LogFileHandle,
896	"%s \"%s\" %s\"%s\"\n",
897	moved,
898	wk->li->list[x],
899	GetPString(IDS_TOTEXT),
900	newname);
901	if(fSyncUpdates \|\|
902	AddToList(wk->li->list[x],
903	&files,
904	&numfiles,
905	&numalloc))
906	Broadcast(hab2,
907	wk->hwndCnr,
908	UM_UPDATERECORD,
909	MPFROMP(wk->li->list[x]),
910	MPVOID);
911	if(fSyncUpdates \|\|
912	AddToList(newname,
913	&files,
914	&numfiles,
915	&numalloc))
916	Broadcast(hab2,
917	wk->hwndCnr,
918	UM_UPDATERECORD,
919	MPFROMP(newname),
920	MPVOID);
921	}
922	}
923	break;
924
925	case IDM_COMPARE:
926	if((!IsFile(wk->li->targetpath) \|\|
927	IsRoot(wk->li->targetpath)) &&
928	(!IsFile(wk->li->list[x]) \|\|
929	IsRoot(wk->li->list[x]))) {
930	if(!*dircompare &&
931	WinIsWindow(hab2,wk->hwndCnr))
932	WinSendMsg(wk->hwndCnr,
933	UM_COMPARE,
934	MPFROMP(wk->li->targetpath),
935	MPFROMP(wk->li->list[x]));
936	else {
937
938	CHAR d1 = "\"",d2 = "\"";
939
940	if(!needs_quoting(wk->li->targetpath))
941	*d1 = 0;
942	if(!needs_quoting(wk->li->list[x]))
943	*d2 = 0;
944	runemf2(SEPARATE,
945	HWND_DESKTOP,
946	NULL,
947	NULL,
948	"%s %s%s%s %s%s%s",
949	dircompare,
950	d1,
951	wk->li->targetpath,
952	d1,
953	d2,
954	wk->li->list[x],
955	d2);
956	}
957	}
958	else if(*compare) {
959
960	CHAR *fakelist[3];
961
962	fakelist[0] = wk->li->list[x];
963	fakelist[1] = wk->li->targetpath;
964	fakelist[2] = NULL;
965	ExecOnList(wk->hwndFrame,
966	compare,
967	WINDOWED \| SEPARATEKEEP,
968	NULL,
969	fakelist,
970	NULL);
971	}
972	else {
973
974	FCOMPARE fc;
975
976	memset(&fc,0,sizeof(fc));
977	fc.size = sizeof(fc);
978	fc.hwndParent = wk->hwndParent;
979	strcpy(fc.file1,wk->li->list[x]);
980	strcpy(fc.file2,wk->li->targetpath);
981	if(WinDlgBox(HWND_DESKTOP,
982	wk->hwndFrame,
983	CFileDlgProc,
984	FM3ModHandle,
985	FCMP_FRAME,
986	(PVOID)&fc))
987	goto Abort;
988	}
989	break;
990	}
991	DosSleep(0L);
992	}
993
994	switch(wk->li->type) {
995	case IDM_MOVE:
996	case IDM_COPY:
997	case IDM_WPSMOVE:
998	case IDM_WPSCOPY:
999	case IDM_RENAME:
1000	sprintf(message,
1001	GetPString(IDS_OPSCOMPLETETEXT),
1002	(wk->li->type == IDM_MOVE) ?
1003	GetPString(IDS_MOVETEXT) :
1004	(wk->li->type == IDM_COPY) ?
1005	GetPString(IDS_COPYTEXT) :
1006	(wk->li->type == IDM_WPSMOVE) ?
1007	GetPString(IDS_WPSMOVETEXT) :
1008	(wk->li->type == IDM_WPSCOPY) ?
1009	GetPString(IDS_WPSCOPYTEXT) :
1010	GetPString(IDS_RENAMETEXT),
1011	&"s"[x == 1],
1012	(wk->li->type == IDM_MOVE \|\|
1013	wk->li->type == IDM_COPY \|\|
1014	wk->li->type == IDM_WPSMOVE \|\|
1015	wk->li->type == IDM_WPSCOPY) ?
1016	GetPString(IDS_TOTEXT) :
1017	NullStr,
1018	(wk->li->type == IDM_MOVE \|\|
1019	wk->li->type == IDM_COPY \|\|
1020	wk->li->type == IDM_WPSMOVE \|\|
1021	wk->li->type == IDM_WPSCOPY) ?
1022	wk->li->targetpath :
1023	NullStr,
1024	(x != 1) ?
1025	GetPString(IDS_ARETEXT) :
1026	GetPString(IDS_ISTEXT));
1027	Notify(message);
1028	if(toupper(*wk->li->targetpath) < 'C')
1029	DosBeep(1000,25);
1030	DosSleep(33L);
1031	if(wk->li->type == IDM_WPSMOVE \|\|
1032	wk->li->type == IDM_WPSCOPY)
1033	DosSleep(96L);
1034	break;
1035	default:
1036	break;
1037	}
1038	}
1039
1040	Abort:
1041
1042	if(files) {
1043	Broadcast(hab2,
1044	wk->hwndCnr,
1045	UM_UPDATERECORDLIST,
1046	MPFROMP(files),
1047	MPVOID);
1048	FreeList(files);
1049	}
1050
1051	if(WinIsWindow(hab2,wk->hwndCnr))
1052	PostMsg(wk->hwndCnr,
1053	UM_RESCAN,
1054	MPVOID,
1055	MPVOID);
1056
1057	if(hwndMain)
1058	WinSendMsg(hwndMain,
1059	UM_THREADUSE,
1060	MPVOID,
1061	MPVOID);
1062	WinDestroyMsgQueue(hmq2);
1063	}
1064	WinTerminate(hab2);
1065	}
1066	}
1067
1068	if(wk->li)
1069	FreeListInfo(wk->li);
1070	free(wk);
1071	DosPostEventSem(CompactSem);
1072	}
1073	}
1074
1075
1076	VOID MassAction (VOID *args) {
1077
1078	WORKER wk = (WORKER )args;
1079	HAB hab2;
1080	HMQ hmq2;
1081	CHAR **files = NULL;
1082	register CHAR p,pp;
1083	INT numfiles = 0,numalloc = 0;
1084
1085	if(wk) {
1086	if(wk->li && wk->li->list && wk->li->list[0]) {
1087	hab2 = WinInitialize(0);
1088	if(hab2) {
1089	hmq2 = WinCreateMsgQueue(hab2,0);
1090	if(hmq2) {
1091	WinCancelShutdown(hmq2,TRUE);
1092	if(hwndMain)
1093	WinSendMsg(hwndMain,
1094	UM_THREADUSE,
1095	MPFROMLONG(1L),
1096	MPVOID);
1097	DosError(FERR_DISABLEHARDERR);
1098	if(IsRoot(wk->li->list[0]) \|\|
1099	!IsFile(wk->li->list[0])) {
1100	if(wk->li->type == IDM_VIEW)
1101	wk->li->type = IDM_INFO;
1102	if(wk->li->type == IDM_EDIT)
1103	wk->li->type = IDM_EAS;
1104	}
1105	switch(wk->li->type) {
1106	case IDM_INFO:
1107	if(WinDlgBox(HWND_DESKTOP,
1108	wk->hwndFrame,
1109	FileInfoProc,
1110	FM3ModHandle,
1111	FLE_FRAME,
1112	(PVOID)wk->li->list) != 2)
1113	break;
1114	/* else intentional fallthru */
1115	case IDM_UPDATE:
1116	Broadcast(hab2,
1117	wk->hwndCnr,
1118	UM_UPDATERECORDLIST,
1119	MPFROMP(wk->li->list),
1120	MPVOID);
1121	break;
1122
1123	case IDM_EAS:
1124	if(WinDlgBox(HWND_DESKTOP,
1125	wk->hwndFrame,
1126	DisplayEAsProc,
1127	FM3ModHandle,
1128	EA_FRAME,
1129	(PVOID)wk->li->list))
1130	Broadcast(hab2,
1131	wk->hwndCnr,
1132	UM_UPDATERECORDLIST,
1133	MPFROMP(wk->li->list),
1134	MPVOID);
1135	break;
1136
1137	case IDM_DOITYOURSELF:
1138	ExecOnList(wk->hwndFrame,
1139	" %a",
1140	WINDOWED \| SEPARATE \| PROMPT,
1141	NULL,
1142	wk->li->list,
1143	GetPString(IDS_DOITYOURSELFTEXT));
1144	break;
1145
1146	case IDM_MCIPLAY:
1147	{
1148	register INT x;
1149	register ULONG total = strlen("FM2PLAY.EXE ");
1150
1151	if(fAddUtils)
1152	total += strlen("UTILS\\");
1153	for(x = 0;wk->li->list[x];x++)
1154	total += (strlen(wk->li->list[x]) + 1 +
1155	(needs_quoting(wk->li->list[x]) * 2));
1156	if(total > 1000) {
1157
1158	FILE *fp;
1159
1160	fp = fopen("$FM2PLAY.$$$","w");
1161	if(fp) {
1162	fprintf(fp,
1163	"%s",
1164	";FM/2-built FM2Play listfile\n");
1165	for(x = 0;wk->li->list[x];x++)
1166	fprintf(fp,
1167	"%s\n",
1168	wk->li->list[x]);
1169	fprintf(fp,
1170	";end\n");
1171	fclose(fp);
1172	runemf2(SEPARATE \| WINDOWED,
1173	HWND_DESKTOP,
1174	NULL,
1175	NULL,
1176	"%sFM2PLAY.EXE /#$FM2PLAY.$$$",
1177	(fAddUtils) ?
1178	"UTILS\\" :
1179	NullStr);
1180	break;
1181	}
1182	}
1183	}
1184	/* intentional fallthru */
1185	case IDM_FAKEEXTRACT:
1186	case IDM_FAKEEXTRACTM:
1187	if(wk->li->type == IDM_MCIPLAY \|\|
1188	(*wk->li->arcname && wk->li->info &&
1189	wk->li->info->extract && *wk->li->targetpath)) {
1190
1191	CHAR szBuffer[1025];
1192	register INT x;
1193
1194	if(wk->li->type == IDM_FAKEEXTRACT \|\|
1195	wk->li->type == IDM_FAKEEXTRACTM) {
1196	strcpy(szBuffer,
1197	(wk->li->info->exwdirs) ?
1198	wk->li->info->exwdirs :
1199	wk->li->info->extract);
1200	strcat(szBuffer," ");
1201	if(needs_quoting(wk->li->arcname))
1202	strcat(szBuffer,"\"");
1203	strcat(szBuffer,wk->li->arcname);
1204	if(needs_quoting(wk->li->arcname))
1205	strcat(szBuffer,"\"");
1206	}
1207	else {
1208	if(fAddUtils)
1209	strcpy(szBuffer,"UTILS\\FM2PLAY.EXE");
1210	else
1211	strcpy(szBuffer,"FM2PLAY.EXE");
1212	}
1213	p = &szBuffer[strlen(szBuffer)];
1214	strcat(szBuffer," ");
1215	x = 0;
1216	while(wk->li->list[x]) {
1217	pp = wk->li->list[x];
1218	while(*pp) {
1219	if(*pp == '/')
1220	*pp = '\\';
1221	pp++;
1222	}
1223	if(needs_quoting(wk->li->list[x]))
1224	strcat(szBuffer,"\"");
1225	strcat(szBuffer,wk->li->list[x]);
1226	if(needs_quoting(wk->li->list[x]))
1227	strcat(szBuffer,"\"");
1228	x++;
1229	if(!wk->li->list[x] \|\| strlen(szBuffer) +
1230	strlen(wk->li->list[x]) + 5 > 1024) {
1231	runemf2(SEPARATE \| WINDOWED \| BACKGROUND \| MINIMIZED \| WAIT,
1232	HWND_DESKTOP,
1233	((wk->li->type == IDM_FAKEEXTRACT \|\|
1234	wk->li->type == IDM_FAKEEXTRACTM) ?
1235	wk->li->targetpath : NULL),
1236	NULL,"%s",szBuffer);
1237	DosSleep(1L);
1238	*p = 0;
1239	}
1240	strcat(szBuffer," ");
1241	}
1242	if(wk->li->type == IDM_MCIPLAY)
1243	break;
1244	strcpy(szBuffer,wk->li->targetpath);
1245	if(wk->li->targetpath[strlen(wk->li->targetpath) - 1] != '\\')
1246	strcat(szBuffer,"\\");
1247	p = szBuffer + strlen(szBuffer);
1248	for(x = 0;wk->li->list[x];x++) {
1249	strcpy(p,wk->li->list[x]);
1250	free(wk->li->list[x]);
1251	wk->li->list[x] = strdup(szBuffer);
1252	}
1253	if(wk->li->list[0])
1254	Broadcast(hab2,
1255	wk->hwndCnr,
1256	UM_UPDATERECORDLIST,
1257	MPFROMP(wk->li->list),
1258	MPVOID);
1259	}
1260	break;
1261
1262	case IDM_SETICON:
1263	if(*wk->li->targetpath) {
1264
1265	ICONINFO ici;
1266
1267	memset(&ici,0,sizeof(ICONINFO));
1268	ici.cb = sizeof(ICONINFO);
1269	ici.fFormat = ICON_FILE;
1270	ici.pszFileName = wk->li->list[0];
1271	if(!WinSetFileIcon((PSZ)wk->li->targetpath,
1272	(PICONINFO)&ici)) {
1273	ici.fFormat = ICON_CLEAR;
1274	WinSetFileIcon((PSZ)wk->li->targetpath,
1275	(PICONINFO)&ici);
1276	}
1277	Broadcast(hab2,
1278	wk->hwndCnr,
1279	UM_UPDATERECORD,
1280	MPFROMP(wk->li->targetpath),
1281	MPVOID);
1282	}
1283	break;
1284
1285	case IDM_APPENDTOCLIP:
1286	case IDM_SAVETOCLIP:
1287	ListToClipboardHab(hab2,
1288	wk->li->list,
1289	(wk->li->type == IDM_APPENDTOCLIP));
1290	break;
1291
1292	case IDM_ARCHIVEM:
1293	case IDM_ARCHIVE:
1294	{
1295	DIRCNRDATA ad;
1296	CHAR szBuffer[1025];
1297	ARC_TYPE *info = NULL;
1298	char *pch;
1299	register INT x;
1300
1301	memset(&ad,0,sizeof(DIRCNRDATA));
1302	strcpy(ad.arcname,wk->li->targetpath);
1303	if(*wk->li->targetpath &&
1304	IsFile(wk->li->targetpath) > 0) {
1305	info = find_type(wk->li->targetpath,NULL);
1306	ad.namecanchange = 0;
1307	}
1308	else {
1309	if(*wk->li->targetpath &&
1310	!IsFile(wk->li->targetpath))
1311	if(wk->li->targetpath[strlen(wk->li->targetpath) - 1] != '\\')
1312	strcat(wk->li->targetpath,"\\");
1313	ad.namecanchange = 1;
1314	}
1315	strcpy(ad.arcname,wk->li->targetpath);
1316	if(wk->li->type == IDM_ARCHIVEM)
1317	ad.fmoving = TRUE;
1318	if(!info) {
1319	ad.info = arcsighead;
1320	if(!WinDlgBox(HWND_DESKTOP,
1321	wk->hwndFrame,
1322	SBoxDlgProc,
1323	FM3ModHandle,
1324	ASEL_FRAME,
1325	(PVOID)&ad.info) \|\|
1326	!ad.info) /* we blew it */
1327	break;
1328	}
1329	else
1330	ad.info = info;
1331	if(!ad.info \|\| (!ad.info->create &&
1332	!ad.info->move &&
1333	!ad.info->createwdirs &&
1334	!ad.info->movewdirs &&
1335	!ad.info->createrecurse))
1336	break;
1337	if(!wk->li->targetpath && wk->directory) {
1338	strcpy(ad.arcname,wk->directory);
1339	if(ad.arcname[strlen(ad.arcname) - 1] != '\\')
1340	strcat(ad.arcname,"\\");
1341	}
1342	if(!WinDlgBox(HWND_DESKTOP,
1343	wk->hwndFrame,
1344	ArchiveDlgProc,
1345	FM3ModHandle,
1346	ARCH_FRAME,
1347	(PVOID)&ad) \|\|
1348	!*ad.arcname \|\|
1349	!ad.command) / we blew it */
1350	break;
1351	// Provide extension so containers work
1352	pch = strrchr(ad.arcname, '\\');
1353	if (pch)
1354	pch = strrchr(pch, '.');
1355	else
1356	pch = strrchr(ad.arcname, '.');
1357	if (!pch && ad.info -> ext)
1358	{
1359	strcat(ad.arcname, ".");
1360	strcat(ad.arcname, ad.info -> ext);
1361	}
1362	/* build the sucker */
1363	strcpy(szBuffer,ad.command);
1364	strcat(szBuffer," ");
1365	if(needs_quoting(ad.arcname))
1366	strcat(szBuffer,"\"");
1367	strcat(szBuffer,ad.arcname);
1368	if(needs_quoting(ad.arcname))
1369	strcat(szBuffer,"\"");
1370	p = &szBuffer[strlen(szBuffer)];
1371	if(ad.mask.szMask) {
1372	strcat(szBuffer," ");
1373	strcat(szBuffer,ad.mask.szMask);
1374	}
1375	strcat(szBuffer," ");
1376	x = 0;
1377	while(wk->li->list[x]) {
1378
1379	FILESTATUS3 fsa;
1380	BOOL spaces;
1381
1382	if(needs_quoting(wk->li->list[x])) {
1383	spaces = TRUE;
1384	strcat(szBuffer,"\"");
1385	}
1386	else
1387	spaces = FALSE;
1388	strcat(szBuffer,wk->li->list[x]);
1389	memset(&fsa,0,sizeof(FILESTATUS3));
1390	DosError(FERR_DISABLEHARDERR);
1391	DosQueryPathInfo(wk->li->list[x],
1392	FIL_STANDARD,
1393	&fsa,
1394	(ULONG)sizeof(FILESTATUS3));
1395	if(fsa.attrFile & FILE_DIRECTORY) {
1396	if(szBuffer[strlen(szBuffer) - 1] != '\\')
1397	strcat(szBuffer,"\\");
1398	strcat(szBuffer,"*");
1399	}
1400	if(spaces)
1401	strcat(szBuffer,"\"");
1402	x++;
1403	if(!wk->li->list[x] \|\|
1404	strlen(szBuffer) +
1405	strlen(wk->li->list[x]) + 5 > 1024) {
1406	runemf2(SEPARATE \| WINDOWED \|
1407	((fArcStuffVisible) ? 0 :
1408	(BACKGROUND \| MINIMIZED)) \|
1409	WAIT,
1410	HWND_DESKTOP,
1411	NULL,
1412	NULL,
1413	"%s",
1414	szBuffer);
1415	DosSleep(1L);
1416	*p = 0;
1417	}
1418	strcat(szBuffer," ");
1419	}
1420	Broadcast(hab2,
1421	wk->hwndCnr,
1422	UM_UPDATERECORDLIST,
1423	MPFROMP(wk->li->list),
1424	MPVOID);
1425	Broadcast(hab2,
1426	wk->hwndCnr,
1427	UM_UPDATERECORD,
1428	MPFROMP(ad.arcname),
1429	MPVOID);
1430	}
1431	break;
1432
1433	case IDM_VIEW:
1434	if(!TestBinary(wk->li->list[0])) {
1435	wk->li->type = IDM_VIEWTEXT;
1436	goto SkipViewing;
1437	}
1438	else
1439	wk->li->type = IDM_VIEWBINARY;
1440	/* intentional fallthru */
1441	case IDM_VIEWBINARY:
1442	if(*binview) {
1443	ExecOnList((HWND)0,
1444	binview,
1445	WINDOWED \| SEPARATE,
1446	NULL,
1447	wk->li->list,
1448	NULL);
1449	break;
1450	}
1451	/* else intentional fallthru */
1452	case IDM_VIEWTEXT:
1453	SkipViewing:
1454	if(*viewer)
1455	ExecOnList((HWND)0,viewer,
1456	WINDOWED \| SEPARATE \|
1457	((fViewChild) ? CHILD : 0),
1458	NULL,
1459	wk->li->list,
1460	NULL);
1461	else {
1462
1463	CHAR *temp;
1464	register INT x;
1465	ULONG viewtype;
1466
1467	viewtype = (wk->li->type == IDM_VIEWTEXT) ? 8 :
1468	(wk->li->type == IDM_VIEWBINARY) ? 16 : 0;
1469	for(x = 0;wk->li->list[x];x++) {
1470	temp = strdup(wk->li->list[x]);
1471	if(temp && WinIsWindow(hab2,wk->hwndCnr)) {
1472	if(!PostMsg(wk->hwndCnr,
1473	UM_LOADFILE,
1474	MPFROMLONG(5L + viewtype),
1475	MPFROMP(temp)))
1476	free(temp);
1477	}
1478	DosSleep(1L);
1479	}
1480	}
1481	break;
1482
1483	case IDM_EDIT:
1484	if(!TestBinary(wk->li->list[0])) {
1485	wk->li->type = IDM_EDITTEXT;
1486	goto SkipEditing;
1487	}
1488	else
1489	wk->li->type = IDM_EDITBINARY;
1490	/* intentional fallthru */
1491	case IDM_EDITBINARY:
1492	if(*bined) {
1493	ExecOnList((HWND)0,
1494	bined,
1495	WINDOWED \| SEPARATE,
1496	NULL,
1497	wk->li->list,
1498	NULL);
1499	break;
1500	}
1501	/* else intentional fallthru */
1502	case IDM_EDITTEXT:
1503	SkipEditing:
1504	if(*editor)
1505	ExecOnList((HWND)0,
1506	editor,
1507	WINDOWED \| SEPARATE,
1508	NULL,
1509	wk->li->list,
1510	NULL);
1511	else {
1512
1513	CHAR *temp;
1514	register INT x;
1515	ULONG viewtype;
1516
1517	viewtype = (wk->li->type == IDM_EDITTEXT) ? 8 :
1518	(wk->li->type == IDM_EDITBINARY) ? 16 : 0;
1519	for(x = 0;wk->li->list[x];x++) {
1520	temp = strdup(wk->li->list[x]);
1521	if(temp && WinIsWindow(hab2,wk->hwndCnr)) {
1522	if(!PostMsg(wk->hwndCnr,
1523	UM_LOADFILE,
1524	MPFROMLONG(4L + viewtype),
1525	MPFROMP(temp)))
1526	free(temp);
1527	}
1528	DosSleep(1L);
1529	}
1530	}
1531	break;
1532
1533	case IDM_SHADOW2:
1534	case IDM_OBJECT:
1535	case IDM_SHADOW:
1536	{
1537	CHAR objectpath[CCHMAXPATH];
1538	APIRET rc;
1539
1540	if(!*wk->li->targetpath \|\| IsFile(wk->li->targetpath)) {
1541	GetDesktopName(objectpath,sizeof(objectpath));
1542	rc = WinDlgBox(HWND_DESKTOP,
1543	wk->hwndFrame,
1544	ObjCnrDlgProc,
1545	FM3ModHandle,
1546	OBJCNR_FRAME,
1547	MPFROMP(objectpath));
1548	if(rc) {
1549	if(rc > 1)
1550	strcpy(objectpath,"<WP_DESKTOP>");
1551	}
1552	else
1553	break;
1554	}
1555	else
1556	strcpy(objectpath,wk->li->targetpath);
1557	AddNote(GetPString(IDS_MAKINGOBJSTEXT));
1558	MakeShadows(wk->hwndFrame,
1559	wk->li->list,
1560	(wk->li->type == IDM_SHADOW) +
1561	(wk->li->type == IDM_SHADOW2) * 2,
1562	objectpath,
1563	NULL);
1564	AddNote(GetPString(IDS_MADEOBJSTEXT));
1565	}
1566	break;
1567
1568	case IDM_PRINT:
1569	if(WinDlgBox(HWND_DESKTOP,
1570	wk->hwndFrame,
1571	PrintDlgProc,
1572	FM3ModHandle,
1573	PRN_FRAME,
1574	MPFROMP(wk->li))) {
1575	if(wk->li && wk->li->list && wk->li->list[0]) {
1576	strcpy(wk->li->targetpath,printer);
1577	if(_beginthread(PrintList,
1578	NULL,
1579	65536,
1580	(PVOID)wk->li) != -1)
1581	wk->li = NULL; /* prevent LISTINFO li from being freed */
1582	}
1583	}
1584	break;
1585
1586	case IDM_ATTRS:
1587	if(WinDlgBox(HWND_DESKTOP,
1588	wk->hwndFrame,
1589	AttrListDlgProc,
1590	FM3ModHandle,
1591	ATR_FRAME,
1592	MPFROMP(wk->li))) {
1593	if(wk->li && wk->li->list && wk->li->list[0])
1594	Broadcast(hab2,
1595	wk->hwndCnr,
1596	UM_UPDATERECORDLIST,
1597	MPFROMP(wk->li->list),
1598	MPVOID);
1599	}
1600	break;
1601
1602	case IDM_PERMDELETE:
1603	case IDM_DELETE:
1604	{
1605	CHECKLIST cl;
1606	INT isdir = 0,sysdir = 0,ro = 0,hs = 0;
1607	register INT x;
1608	FILESTATUS3 fsa;
1609	CHAR prompt[CCHMAXPATH * 3];
1610	APIRET error;
1611
1612	for(x = 0;wk->li->list[x];x++) {
1613	if(IsRoot(wk->li->list[x])) {
1614	wk->li->list = RemoveFromList(wk->li->list,
1615	wk->li->list[x]);
1616	if(!wk->li->list)
1617	break;
1618	x--;
1619	continue;
1620	}
1621	DosError(FERR_DISABLEHARDERR);
1622	if(DosQueryPathInfo(wk->li->list[x],
1623	FIL_STANDARD,&fsa,
1624	(ULONG)sizeof(FILESTATUS3))) {
1625	wk->li->list = RemoveFromList(wk->li->list,
1626	wk->li->list[x]);
1627	if(!wk->li->list)
1628	break;
1629	x--;
1630	continue;
1631	}
1632	if(fsa.attrFile & FILE_DIRECTORY) {
1633	isdir++;
1634	if(stristr(wk->li->list[x],":\\OS2\\") \|\|
1635	!stricmp(wk->li->list[x] + 1,":\\OS2"))
1636	sysdir++;
1637	}
1638	else {
1639	if(fsa.attrFile & (FILE_HIDDEN \| FILE_SYSTEM))
1640	hs++;
1641	if(fsa.attrFile & FILE_READONLY)
1642	ro++;
1643	}
1644	}
1645	if(!wk->li->list)
1646	break;
1647	if(fConfirmDelete \|\| isdir \|\| hs \|\| ro) {
1648	memset(&cl,0,sizeof(cl));
1649	cl.size = sizeof(cl);
1650	cl.list = wk->li->list;
1651	cl.prompt = prompt;
1652	cl.flags \|= CHECK_FILES;
1653	cl.cmd = wk->li->type;
1654	sprintf(prompt,
1655	GetPString(IDS_DELPROMPT1TEXT),
1656	(wk->li->type == IDM_DELETE) ?
1657	NullStr :
1658	GetPString(IDS_PERMANENTLYTEXT),
1659	&"s"[wk->li->list[1] == NULL]);
1660	if(isdir) {
1661	sprintf(&prompt[strlen(prompt)],
1662	GetPString(IDS_DELPROMPT2TEXT),
1663	isdir,
1664	(isdir > 1) ?
1665	GetPString(IDS_ARETEXT) :
1666	GetPString(IDS_ISTEXT),
1667	(isdir == 1) ?
1668	GetPString(IDS_ATEXT) :
1669	NullStr,
1670	(isdir > 1) ?
1671	GetPString(IDS_IESTEXT) :
1672	GetPString(IDS_YTEXT));
1673	if(sysdir)
1674	sprintf(&prompt[strlen(prompt)],
1675	GetPString(IDS_DELPROMPT3TEXT),
1676	sysdir,
1677	(sysdir == 1) ?
1678	GetPString(IDS_YTEXT) :
1679	GetPString(IDS_IESTEXT));
1680	}
1681	if(ro)
1682	sprintf(&prompt[strlen(prompt)],
1683	GetPString(IDS_DELPROMPT4TEXT),
1684	ro,
1685	&"s"[ro == 1],
1686	(ro > 1) ?
1687	GetPString(IDS_ARETEXT) :
1688	GetPString(IDS_ISTEXT));
1689	if(hs)
1690	sprintf(&prompt[strlen(prompt)],
1691	GetPString(IDS_DELPROMPT5TEXT),
1692	hs,
1693	&"s"[hs == 1],
1694	(hs > 1) ?
1695	GetPString(IDS_ARETEXT) :
1696	GetPString(IDS_ISTEXT));
1697	if(ro \|\| hs \|\| sysdir)
1698	DosBeep(300,100);
1699	strcat(prompt,
1700	GetPString(IDS_DELPROMPT6TEXT));
1701	error = WinDlgBox(HWND_DESKTOP,
1702	wk->hwndFrame,
1703	CheckListProc,
1704	FM3ModHandle,
1705	CHECK_FRAME,
1706	MPFROMP(&cl));
1707	if(!error \|\| error == 65535)
1708	break;
1709	wk->li->list = cl.list;
1710	if(!wk->li->list \|\| !wk->li->list[0])
1711	break;
1712	}
1713	for(x = 0;wk->li->list[x];x++) {
1714	fsa.attrFile = 0;
1715	DosError(FERR_DISABLEHARDERR);
1716	DosQueryPathInfo(wk->li->list[x],
1717	FIL_STANDARD,
1718	&fsa,
1719	(ULONG)sizeof(FILESTATUS3));
1720	if(fsa.attrFile & FILE_DIRECTORY) {
1721	sprintf(prompt,
1722	GetPString(IDS_DELETINGTEXT),
1723	wk->li->list[x]);
1724	AddNote(prompt);
1725	error = (APIRET)wipeallf("%s%s*",
1726	wk->li->list[x],
1727	(*wk->li->list[x] &&
1728	wk->li->list[x][strlen(wk->li->list[x]) - 1] !=
1729	'\\') ?
1730	"\\" :
1731	NullStr);
1732	DosError(FERR_DISABLEHARDERR);
1733	if(!error)
1734	error = DosDeleteDir(wk->li->list[x]);
1735	else
1736	DosDeleteDir(wk->li->list[x]);
1737	}
1738	else {
1739	sprintf(prompt,
1740	GetPString(IDS_DELETINGTEXT),
1741	wk->li->list[x]);
1742	AddNote(prompt);
1743	DosError(FERR_DISABLEHARDERR);
1744	if(wk->li->type == IDM_DELETE)
1745	error = DosDelete(wk->li->list[x]);
1746	else
1747	error = DosForceDelete(wk->li->list[x]);
1748	if(error) {
1749	DosError(FERR_DISABLEHARDERR);
1750	make_deleteable(wk->li->list[x]);
1751	if(wk->li->type == IDM_DELETE)
1752	error = DosDelete(wk->li->list[x]);
1753	else
1754	error = DosForceDelete(wk->li->list[x]);
1755	}
1756	}
1757	if(error) {
1758	if(LogFileHandle)
1759	fprintf(LogFileHandle,
1760	GetPString(IDS_DELETEFAILED1TEXT),
1761	wk->li->list[x],
1762	error);
1763	if(Dos_Error(MB_ENTERCANCEL,
1764	error,
1765	wk->hwndFrame,
1766	__FILE__,
1767	__LINE__,
1768	GetPString(IDS_DELETEFAILED2TEXT),
1769	wk->li->list[x]) ==
1770	MBID_CANCEL)
1771	break;
1772	}
1773	else {
1774	if(LogFileHandle)
1775	fprintf(LogFileHandle,
1776	GetPString(IDS_DELETEDTEXT),
1777	wk->li->list[x]);
1778	sprintf(prompt,
1779	GetPString(IDS_DELETEDTEXT),
1780	wk->li->list[x]);
1781	AddNote(prompt);
1782	}
1783	if(fSyncUpdates \|\|
1784	AddToList(wk->li->list[x],
1785	&files,
1786	&numfiles,
1787	&numalloc))
1788	Broadcast(hab2,
1789	wk->hwndCnr,
1790	UM_UPDATERECORD,
1791	MPFROMP(wk->li->list[x]),
1792	MPVOID);
1793	}
1794	}
1795	break;
1796	}
1797	if(files) {
1798	Broadcast(hab2,
1799	wk->hwndCnr,
1800	UM_UPDATERECORDLIST,
1801	MPFROMP(files),
1802	MPVOID);
1803	FreeList(files);
1804	}
1805	Abort:
1806	if(WinIsWindow(hab2,wk->hwndCnr))
1807	PostMsg(wk->hwndCnr,
1808	UM_RESCAN,
1809	MPVOID,
1810	MPVOID);
1811
1812	if(hwndMain)
1813	WinSendMsg(hwndMain,
1814	UM_THREADUSE,
1815	MPVOID,
1816	MPVOID);
1817	WinDestroyMsgQueue(hmq2);
1818	}
1819	WinTerminate(hab2);
1820	}
1821	}
1822	if(wk->li)
1823	FreeListInfo(wk->li);
1824	free(wk);
1825	DosPostEventSem(CompactSem);
1826	}
1827	}

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

Download in other formats: