source: trunk/dll/worker.c@ 1009

Last change on this file since 1009 was 1009, checked in by Steven Levine, 17 years ago

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