source: trunk/dll/worker.c@ 1084

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

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