source: trunk/dll/worker.c@ 1069

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

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