source: trunk/dll/worker.c@ 1047

Last change on this file since 1047 was 1047, checked in by Gregg Young, 17 years ago

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