source: trunk/dll/worker.c@ 1398

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

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