source: trunk/dll/worker.c@ 1077

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

Enhance Fortify infrastructure
Add Fortify_SetOwner Fortify_ChangeOwner Fortify_ChangeScope
Add FORTIFY_VERBOSE_SCOPE_ENTER_EXIT support
Add more fm/2 Fortify tooling and rework existing tooling for correct nesting
Still lots to do for cross-thread allocations
Add misc.h
Add walkem.h
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 42.3 KB
Line 
1
2/***********************************************************************
3
4 $Id: worker.c 1077 2008-07-18 18:11:54Z stevenhl $
5
6 Worker thread
7
8 Copyright (c) 1993-98 M. Kimes
9 Copyright (c) 2001, 2008 Steven H. Levine
10
11 16 Oct 02 SHL Comments
12 18 Oct 02 SHL MassAction:Archive - force extension so file found
13 06 Jun 05 SHL Indent -i2
14 06 Jun 05 SHL Rework Action for VAC3.65 compat
15 27 Jul 05 SHL IDM_DOITYOURSELF - avoid need to strip in ExecOnList
16 22 Jul 06 SHL Comments
17 22 Jul 06 SHL Check more run time errors
18 03 Nov 06 SHL Renames
19 03 Nov 06 SHL Count thread usage
20 21 Apr 07 GKY Find FM2Utils by path or utils directory
21 16 Jun 07 SHL Update for OpenWatcom
22 06 Aug 07 GKY Reduce DosSleep times (ticket 148)
23 07 Aug 07 SHL Use BldQuotedFileName
24 20 Aug 07 GKY Move #pragma alloc_text to end for OpenWatcom compat
25 26 Aug 07 SHL Revert to DosSleep(0)
26 29 Feb 08 GKY 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_ChangeOwner(wk);
1004 Fortify_EnterScope();
1005# endif
1006 if (wk->li && wk->li->list && wk->li->list[0]) {
1007 hab2 = WinInitialize(0);
1008 if (hab2) {
1009 hmq2 = WinCreateMsgQueue(hab2, 0);
1010 if (hmq2) {
1011 WinCancelShutdown(hmq2, TRUE);
1012 IncrThreadUsage();
1013 DosError(FERR_DISABLEHARDERR);
1014 if (IsRoot(wk->li->list[0]) || !IsFile(wk->li->list[0])) {
1015 if (wk->li->type == IDM_VIEW)
1016 wk->li->type = IDM_INFO;
1017 if (wk->li->type == IDM_EDIT)
1018 wk->li->type = IDM_EAS;
1019 }
1020 switch (wk->li->type) {
1021 case IDM_INFO:
1022 if (WinDlgBox(HWND_DESKTOP,
1023 wk->hwndFrame,
1024 FileInfoProc,
1025 FM3ModHandle, FLE_FRAME, (PVOID) wk->li->list) != 2)
1026 {
1027 break;
1028 }
1029 /* else intentional fallthru */
1030 case IDM_UPDATE:
1031 Broadcast(hab2,
1032 wk->hwndCnr,
1033 UM_UPDATERECORDLIST, MPFROMP(wk->li->list), MPVOID);
1034 break;
1035
1036 case IDM_EAS:
1037 if (WinDlgBox(HWND_DESKTOP,
1038 wk->hwndFrame,
1039 DisplayEAsProc,
1040 FM3ModHandle, EA_FRAME, (PVOID) wk->li->list))
1041 Broadcast(hab2,
1042 wk->hwndCnr,
1043 UM_UPDATERECORDLIST, MPFROMP(wk->li->list), MPVOID);
1044 break;
1045
1046 case IDM_DOITYOURSELF:
1047 ExecOnList(wk->hwndFrame,
1048 "%a",
1049 WINDOWED | SEPARATE | PROMPT,
1050 NULL, wk->li->list, GetPString(IDS_DOITYOURSELFTEXT),
1051 pszSrcFile, __LINE__);
1052 break;
1053
1054 case IDM_MCIPLAY:
1055 {
1056 register INT x;
1057 register ULONG total;
1058 CHAR fbuf[CCHMAXPATH];
1059
1060 if (DosSearchPath(SEARCH_IGNORENETERRS | SEARCH_ENVIRONMENT |
1061 SEARCH_CUR_DIRECTORY,
1062 "PATH", "FM2PLAY.EXE", fbuf, CCHMAXPATH - 1))
1063 total += strlen("..\\FM2UTILS\\FM2PLAY.EXE ");
1064 else
1065 total = strlen(fbuf);
1066 for (x = 0; wk->li->list[x]; x++)
1067 total += (strlen(wk->li->list[x]) + 1 +
1068 (needs_quoting(wk->li->list[x]) * 2));
1069 if (total > 1000) {
1070
1071 FILE *fp;
1072 CHAR szTempFile[CCHMAXPATH];
1073
1074 BldFullPathName(szTempFile, pTmpDir, "$FM2PLAY.$$$");
1075 fp = xfopen(szTempFile, "w", pszSrcFile, __LINE__);
1076 if (fp) {
1077 fprintf(fp, "%s", ";AV/2-built FM2Play listfile\n");
1078 for (x = 0; wk->li->list[x]; x++)
1079 fprintf(fp, "%s\n", wk->li->list[x]);
1080 fprintf(fp, ";end\n");
1081 fclose(fp);
1082 strrev(szTempFile);
1083 strcat(szTempFile, "@/");
1084 strrev(szTempFile);
1085 RunFM2Util("FM2PLAY.EXE", szTempFile);
1086 }
1087 }
1088 }
1089 /* intentional fallthru */
1090 case IDM_FAKEEXTRACT:
1091 case IDM_FAKEEXTRACTM:
1092 if (wk->li->type == IDM_MCIPLAY ||
1093 (*wk->li->arcname && wk->li->info &&
1094 wk->li->info->extract && *wk->li->targetpath)) {
1095
1096 CHAR szBuffer[1025];
1097 CHAR fbuf[CCHMAXPATH];
1098 register INT x;
1099
1100 if (wk->li->type == IDM_FAKEEXTRACT ||
1101 wk->li->type == IDM_FAKEEXTRACTM) {
1102 strcpy(szBuffer,
1103 (wk->li->info->exwdirs) ?
1104 wk->li->info->exwdirs : wk->li->info->extract);
1105 strcat(szBuffer, " ");
1106 BldQuotedFileName(szBuffer + strlen(szBuffer), wk->li->arcname);
1107 }
1108 else {
1109 if (DosSearchPath(SEARCH_IGNORENETERRS | SEARCH_ENVIRONMENT |
1110 SEARCH_CUR_DIRECTORY,
1111 "PATH", "FM2PLAY.EXE", fbuf, CCHMAXPATH - 1))
1112 strcpy(szBuffer, "UTILS\\FM2PLAY.EXE");
1113 else
1114 strcpy(szBuffer, "FM2PLAY.EXE");
1115 }
1116 p = &szBuffer[strlen(szBuffer)];
1117 strcat(szBuffer, " ");
1118 x = 0;
1119 while (wk->li->list[x]) {
1120 pp = wk->li->list[x];
1121 while (*pp) {
1122 if (*pp == '/')
1123 *pp = '\\';
1124 pp++;
1125 }
1126 BldQuotedFileName(szBuffer + strlen(szBuffer), wk->li->list[x]);
1127 x++;
1128 if (!wk->li->list[x] || strlen(szBuffer) +
1129 strlen(wk->li->list[x]) + 5 > 1024) {
1130 runemf2(SEPARATE | WINDOWED | BACKGROUND | MINIMIZED | WAIT,
1131 HWND_DESKTOP, pszSrcFile, __LINE__,
1132 (wk->li->type == IDM_FAKEEXTRACT ||
1133 wk->li->type == IDM_FAKEEXTRACTM) ?
1134 wk->li->targetpath : NULL,
1135 NULL,
1136 "%s", szBuffer);
1137 DosSleep(1);
1138 *p = 0;
1139 }
1140 strcat(szBuffer, " ");
1141 }
1142 if (wk->li->type == IDM_MCIPLAY)
1143 break;
1144 strcpy(szBuffer, wk->li->targetpath);
1145 if (wk->li->targetpath[strlen(wk->li->targetpath) - 1] != '\\')
1146 strcat(szBuffer, "\\");
1147 p = szBuffer + strlen(szBuffer);
1148 for (x = 0; wk->li->list[x]; x++) {
1149 strcpy(p, wk->li->list[x]);
1150 free(wk->li->list[x]);
1151 wk->li->list[x] = xstrdup(szBuffer, pszSrcFile, __LINE__);
1152 }
1153 if (wk->li->list[0])
1154 Broadcast(hab2,
1155 wk->hwndCnr,
1156 UM_UPDATERECORDLIST, MPFROMP(wk->li->list), MPVOID);
1157 }
1158 break;
1159
1160 case IDM_SETICON:
1161 if (*wk->li->targetpath) {
1162
1163 ICONINFO ici;
1164
1165 memset(&ici, 0, sizeof(ICONINFO));
1166 ici.cb = sizeof(ICONINFO);
1167 ici.fFormat = ICON_FILE;
1168 ici.pszFileName = wk->li->list[0];
1169 if (!WinSetFileIcon((PSZ) wk->li->targetpath,
1170 (PICONINFO) & ici)) {
1171 ici.fFormat = ICON_CLEAR;
1172 WinSetFileIcon((PSZ) wk->li->targetpath, (PICONINFO) & ici);
1173 }
1174 Broadcast(hab2,
1175 wk->hwndCnr,
1176 UM_UPDATERECORD, MPFROMP(wk->li->targetpath), MPVOID);
1177 }
1178 break;
1179
1180 case IDM_APPENDTOCLIP:
1181 case IDM_SAVETOCLIP:
1182 ListToClipboardHab(hab2,
1183 wk->li->list,
1184 (wk->li->type == IDM_APPENDTOCLIP));
1185 break;
1186
1187 case IDM_ARCHIVEM:
1188 case IDM_ARCHIVE:
1189 {
1190 DIRCNRDATA ad;
1191 CHAR szBuffer[1025];
1192 ARC_TYPE *info = NULL;
1193 char *pch;
1194 register INT x;
1195
1196 memset(&ad, 0, sizeof(DIRCNRDATA));
1197 strcpy(ad.arcname, wk->li->targetpath);
1198 if (*wk->li->targetpath && IsFile(wk->li->targetpath) > 0) {
1199 info = find_type(wk->li->targetpath, NULL);
1200 ad.namecanchange = 0;
1201 }
1202 else {
1203 if (*wk->li->targetpath && !IsFile(wk->li->targetpath))
1204 if (wk->li->targetpath[strlen(wk->li->targetpath) - 1] !=
1205 '\\')
1206 strcat(wk->li->targetpath, "\\");
1207 ad.namecanchange = 1;
1208 }
1209 strcpy(ad.arcname, wk->li->targetpath);
1210 if (wk->li->type == IDM_ARCHIVEM)
1211 ad.fmoving = TRUE;
1212 if (!info) {
1213 ad.info = arcsighead; // Hide dups
1214 if (!WinDlgBox(HWND_DESKTOP,
1215 wk->hwndFrame,
1216 SBoxDlgProc,
1217 FM3ModHandle,
1218 ASEL_FRAME, (PVOID) & ad.info) || !ad.info) {
1219 break; /* we blew it */
1220 }
1221 }
1222 else
1223 ad.info = info;
1224 if (!ad.info || (!ad.info->create &&
1225 !ad.info->move &&
1226 !ad.info->createwdirs &&
1227 !ad.info->movewdirs &&
1228 !ad.info->createrecurse))
1229 break;
1230 if (!*wk->li->targetpath && *wk->directory) {
1231 strcpy(ad.arcname, wk->directory);
1232 if (ad.arcname[strlen(ad.arcname) - 1] != '\\')
1233 strcat(ad.arcname, "\\");
1234 }
1235 if (!WinDlgBox(HWND_DESKTOP, wk->hwndFrame, ArchiveDlgProc, FM3ModHandle, ARCH_FRAME, (PVOID) & ad) || !*ad.arcname || !*ad.command) /* we blew it */
1236 break;
1237 // Provide extension so containers work
1238 pch = strrchr(ad.arcname, '\\');
1239 if (pch)
1240 pch = strrchr(pch, '.');
1241 else
1242 pch = strrchr(ad.arcname, '.');
1243 if (!pch && ad.info->ext) {
1244 strcat(ad.arcname, ".");
1245 strcat(ad.arcname, ad.info->ext);
1246 }
1247 /* build the sucker */
1248 strcpy(szBuffer, ad.command);
1249 strcat(szBuffer, " ");
1250 BldQuotedFileName(szBuffer + strlen(szBuffer), ad.arcname);
1251 p = &szBuffer[strlen(szBuffer)];
1252 if (ad.mask.szMask) {
1253 strcat(szBuffer, " ");
1254 strcat(szBuffer, ad.mask.szMask);
1255 }
1256 strcat(szBuffer, " ");
1257 x = 0;
1258 while (wk->li->list[x]) {
1259 FILESTATUS3 fsa;
1260 memset(&fsa, 0, sizeof(FILESTATUS3));
1261 DosError(FERR_DISABLEHARDERR);
1262 DosQueryPathInfo(wk->li->list[x],
1263 FIL_STANDARD,
1264 &fsa, (ULONG) sizeof(FILESTATUS3));
1265 if (fsa.attrFile & FILE_DIRECTORY) {
1266 BldQuotedFullPathName(szBuffer + strlen(szBuffer), wk->li->list[x], "*");
1267 }
1268 else
1269 BldQuotedFileName(szBuffer + strlen(szBuffer), wk->li->list[x]);
1270 x++;
1271 if (!wk->li->list[x] ||
1272 strlen(szBuffer) + strlen(wk->li->list[x]) + 5 > 1024) {
1273 runemf2(SEPARATE | WINDOWED | WAIT |
1274 (fArcStuffVisible ? 0 : (BACKGROUND | MINIMIZED)),
1275 HWND_DESKTOP, pszSrcFile, __LINE__, NULL, NULL,
1276 "%s", szBuffer);
1277 DosSleep(1);
1278 *p = 0;
1279 }
1280 strcat(szBuffer, " ");
1281 }
1282 Broadcast(hab2,
1283 wk->hwndCnr,
1284 UM_UPDATERECORDLIST, MPFROMP(wk->li->list), MPVOID);
1285 Broadcast(hab2,
1286 wk->hwndCnr,
1287 UM_UPDATERECORD, MPFROMP(ad.arcname), MPVOID);
1288 }
1289 break;
1290
1291 case IDM_VIEW:
1292 if (!TestBinary(wk->li->list[0])) {
1293 wk->li->type = IDM_VIEWTEXT;
1294 goto SkipViewing;
1295 }
1296 else
1297 wk->li->type = IDM_VIEWBINARY;
1298 /* intentional fallthru */
1299 case IDM_VIEWBINARY:
1300 if (*binview) {
1301 ExecOnList((HWND) 0,
1302 binview,
1303 WINDOWED | SEPARATE, NULL, wk->li->list, NULL,
1304 pszSrcFile, __LINE__);
1305 break;
1306 }
1307 /* else intentional fallthru */
1308 case IDM_VIEWTEXT:
1309 SkipViewing:
1310 if (*viewer)
1311 ExecOnList((HWND) 0, viewer,
1312 WINDOWED | SEPARATE |
1313 ((fViewChild) ? CHILD : 0),
1314 NULL, wk->li->list, NULL,
1315 pszSrcFile, __LINE__);
1316 else {
1317
1318 CHAR *temp;
1319 register INT x;
1320 ULONG viewtype;
1321
1322 viewtype = (wk->li->type == IDM_VIEWTEXT) ? 8 :
1323 (wk->li->type == IDM_VIEWBINARY) ? 16 : 0;
1324 for (x = 0; wk->li->list[x]; x++) {
1325 temp = xstrdup(wk->li->list[x], pszSrcFile, __LINE__);
1326 if (temp && WinIsWindow(hab2, wk->hwndCnr)) {
1327 if (!PostMsg(wk->hwndCnr,
1328 UM_LOADFILE,
1329 MPFROMLONG(5 + viewtype), MPFROMP(temp)))
1330 free(temp);
1331 }
1332 DosSleep(1);
1333 }
1334 }
1335 break;
1336
1337 case IDM_EDIT:
1338 if (!TestBinary(wk->li->list[0])) {
1339 wk->li->type = IDM_EDITTEXT;
1340 goto SkipEditing;
1341 }
1342 else
1343 wk->li->type = IDM_EDITBINARY;
1344 /* intentional fallthru */
1345 case IDM_EDITBINARY:
1346 if (*bined) {
1347 ExecOnList((HWND) 0,
1348 bined,
1349 WINDOWED | SEPARATE, NULL, wk->li->list, NULL,
1350 pszSrcFile, __LINE__);
1351 break;
1352 }
1353 /* else intentional fallthru */
1354 case IDM_EDITTEXT:
1355 SkipEditing:
1356 if (*editor)
1357 ExecOnList((HWND) 0,
1358 editor,
1359 WINDOWED | SEPARATE, NULL, wk->li->list, NULL,
1360 pszSrcFile, __LINE__);
1361 else {
1362
1363 CHAR *temp;
1364 register INT x;
1365 ULONG viewtype;
1366
1367 viewtype = (wk->li->type == IDM_EDITTEXT) ? 8 :
1368 (wk->li->type == IDM_EDITBINARY) ? 16 : 0;
1369 for (x = 0; wk->li->list[x]; x++) {
1370 temp = xstrdup(wk->li->list[x], pszSrcFile, __LINE__);
1371 if (temp && WinIsWindow(hab2, wk->hwndCnr)) {
1372 if (!PostMsg(wk->hwndCnr,
1373 UM_LOADFILE,
1374 MPFROMLONG(4 + viewtype), MPFROMP(temp)))
1375 free(temp);
1376 }
1377 DosSleep(1);
1378 }
1379 }
1380 break;
1381
1382 case IDM_SHADOW2:
1383 case IDM_OBJECT:
1384 case IDM_SHADOW:
1385 {
1386 CHAR objectpath[CCHMAXPATH];
1387 APIRET rc;
1388
1389 if (!*wk->li->targetpath || IsFile(wk->li->targetpath)) {
1390 GetDesktopName(objectpath, sizeof(objectpath));
1391 rc = WinDlgBox(HWND_DESKTOP,
1392 wk->hwndFrame,
1393 ObjCnrDlgProc,
1394 FM3ModHandle,
1395 OBJCNR_FRAME, MPFROMP(objectpath));
1396 if (rc) {
1397 if (rc > 1)
1398 strcpy(objectpath, "<WP_DESKTOP>");
1399 }
1400 else
1401 break;
1402 }
1403 else
1404 strcpy(objectpath, wk->li->targetpath);
1405 AddNote(GetPString(IDS_MAKINGOBJSTEXT));
1406 MakeShadows(wk->hwndFrame,
1407 wk->li->list,
1408 (wk->li->type == IDM_SHADOW) +
1409 (wk->li->type == IDM_SHADOW2) * 2,
1410 objectpath, NULL);
1411 AddNote(GetPString(IDS_MADEOBJSTEXT));
1412 }
1413 break;
1414
1415 case IDM_PRINT:
1416 if (WinDlgBox(HWND_DESKTOP,
1417 wk->hwndFrame,
1418 PrintDlgProc,
1419 FM3ModHandle, PRN_FRAME, MPFROMP(wk->li))) {
1420 if (wk->li && wk->li->list && wk->li->list[0]) {
1421 strcpy(wk->li->targetpath, printer);
1422 if (_beginthread(PrintListThread, NULL, 65536, (PVOID) wk->li)
1423 == -1)
1424 Runtime_Error(pszSrcFile, __LINE__,
1425 GetPString(IDS_COULDNTSTARTTHREADTEXT));
1426 else
1427 wk->li = NULL; /* prevent LISTINFO li from being freed */
1428 }
1429 }
1430 break;
1431
1432 case IDM_ATTRS:
1433 if (WinDlgBox(HWND_DESKTOP,
1434 wk->hwndFrame,
1435 AttrListDlgProc,
1436 FM3ModHandle, ATR_FRAME, MPFROMP(wk->li))) {
1437 if (wk->li && wk->li->list && wk->li->list[0])
1438 Broadcast(hab2,
1439 wk->hwndCnr,
1440 UM_UPDATERECORDLIST, MPFROMP(wk->li->list), MPVOID);
1441 }
1442 break;
1443
1444 case IDM_PERMDELETE:
1445 case IDM_DELETE:
1446 {
1447 CHECKLIST cl;
1448 INT isdir = 0, sysdir = 0, ro = 0, hs = 0;
1449 register INT x;
1450 FILESTATUS3 fsa;
1451 CHAR prompt[CCHMAXPATH * 3];
1452 APIRET error;
1453 HOBJECT hObjectdest, hObjectofObject;
1454
1455 for (x = 0; wk->li->list[x]; x++) {
1456 if (IsRoot(wk->li->list[x])) {
1457 wk->li->list = RemoveFromList(wk->li->list,
1458 wk->li->list[x]);
1459 if (!wk->li->list)
1460 break;
1461 x--;
1462 continue;
1463 }
1464 DosError(FERR_DISABLEHARDERR);
1465 if (DosQueryPathInfo(wk->li->list[x],
1466 FIL_STANDARD, &fsa,
1467 (ULONG) sizeof(FILESTATUS3))) {
1468 wk->li->list = RemoveFromList(wk->li->list,
1469 wk->li->list[x]);
1470 if (!wk->li->list)
1471 break;
1472 x--;
1473 continue;
1474 }
1475 if (fsa.attrFile & FILE_DIRECTORY) {
1476 isdir++;
1477 if (stristr(wk->li->list[x], ":\\OS2\\") ||
1478 !stricmp(wk->li->list[x] + 1, ":\\OS2"))
1479 sysdir++;
1480 }
1481 else {
1482 if (fsa.attrFile & (FILE_HIDDEN | FILE_SYSTEM))
1483 hs++;
1484 if (fsa.attrFile & FILE_READONLY)
1485 ro++;
1486 }
1487 }
1488 if (!wk->li->list)
1489 break;
1490 if (fConfirmDelete || isdir || hs || ro) {
1491 memset(&cl, 0, sizeof(cl));
1492 cl.size = sizeof(cl);
1493 cl.list = wk->li->list;
1494 cl.prompt = prompt;
1495 cl.flags |= CHECK_FILES;
1496 cl.cmd = wk->li->type;
1497 sprintf(prompt,
1498 GetPString(IDS_DELPROMPT1TEXT),
1499 (wk->li->type == IDM_DELETE) ?
1500 NullStr :
1501 GetPString(IDS_PERMANENTLYTEXT),
1502 &"s"[wk->li->list[1] == NULL]);
1503 if (isdir) {
1504 sprintf(&prompt[strlen(prompt)],
1505 GetPString(IDS_DELPROMPT2TEXT),
1506 isdir,
1507 (isdir > 1) ?
1508 GetPString(IDS_ARETEXT) :
1509 GetPString(IDS_ISTEXT),
1510 (isdir == 1) ?
1511 GetPString(IDS_ATEXT) :
1512 NullStr,
1513 (isdir > 1) ?
1514 GetPString(IDS_IESTEXT) : GetPString(IDS_YTEXT));
1515 if (sysdir)
1516 sprintf(&prompt[strlen(prompt)],
1517 GetPString(IDS_DELPROMPT3TEXT),
1518 sysdir,
1519 (sysdir == 1) ?
1520 GetPString(IDS_YTEXT) : GetPString(IDS_IESTEXT));
1521 }
1522 if (ro)
1523 sprintf(&prompt[strlen(prompt)],
1524 GetPString(IDS_DELPROMPT4TEXT),
1525 ro,
1526 &"s"[ro == 1],
1527 (ro > 1) ?
1528 GetPString(IDS_ARETEXT) : GetPString(IDS_ISTEXT));
1529 if (hs)
1530 sprintf(&prompt[strlen(prompt)],
1531 GetPString(IDS_DELPROMPT5TEXT),
1532 hs,
1533 &"s"[hs == 1],
1534 (hs > 1) ?
1535 GetPString(IDS_ARETEXT) : GetPString(IDS_ISTEXT));
1536 if (ro || hs || sysdir)
1537 DosBeep(300, 100); // Wake up user
1538 strcat(prompt, GetPString(IDS_DELPROMPT6TEXT));
1539 error = WinDlgBox(HWND_DESKTOP,
1540 wk->hwndFrame,
1541 CheckListProc,
1542 FM3ModHandle, CHECK_FRAME, MPFROMP(&cl));
1543 if (!error || error == 65535)
1544 break;
1545 wk->li->list = cl.list;
1546 if (!wk->li->list || !wk->li->list[0])
1547 break;
1548 }
1549 for (x = 0; wk->li->list[x]; x++) {
1550 fsa.attrFile = 0;
1551 DosError(FERR_DISABLEHARDERR);
1552 DosQueryPathInfo(wk->li->list[x],
1553 FIL_STANDARD,
1554 &fsa, (ULONG) sizeof(FILESTATUS3));
1555 if (fsa.attrFile & FILE_DIRECTORY) {
1556 sprintf(prompt,
1557 GetPString(IDS_DELETINGTEXT), wk->li->list[x]);
1558 AddNote(prompt);
1559 error = (APIRET) wipeallf("%s%s*",
1560 wk->li->list[x],
1561 (*wk->li->list[x] &&
1562 wk->li->
1563 list[x][strlen(wk->li->list[x]) -
1564 1] !=
1565 '\\') ? "\\" : NullStr);
1566 DosError(FERR_DISABLEHARDERR);
1567 if (!error)
1568 error = DosDeleteDir(wk->li->list[x]);
1569 else
1570 DosDeleteDir(wk->li->list[x]);
1571 }
1572 else {
1573 sprintf(prompt,
1574 GetPString(IDS_DELETINGTEXT), wk->li->list[x]);
1575 AddNote(prompt);
1576 DosError(FERR_DISABLEHARDERR);
1577 if (wk->li->type == IDM_DELETE){
1578 hObjectdest = WinQueryObject("<XWP_TRASHCAN>");
1579 if (hObjectdest != NULLHANDLE){
1580 hObjectofObject = WinQueryObject(wk->li->list[x]);
1581 error = WinMoveObject(hObjectofObject, hObjectdest, 0);
1582 }
1583 else
1584 error = DosDelete(wk->li->list[x]);
1585 }
1586 else
1587 error = DosForceDelete(wk->li->list[x]);
1588 if (error) {
1589 DosError(FERR_DISABLEHARDERR);
1590 make_deleteable(wk->li->list[x]);
1591 if (wk->li->type == IDM_DELETE){
1592 hObjectdest = WinQueryObject("<XWP_TRASHCAN>");
1593 if (hObjectdest != NULLHANDLE){
1594 hObjectofObject = WinQueryObject(wk->li->list[x]);
1595 error = WinMoveObject(hObjectofObject, hObjectdest, 0);
1596 }
1597 else
1598 error = DosDelete(wk->li->list[x]);
1599 }
1600 else
1601 error = DosForceDelete(wk->li->list[x]);
1602 }
1603 }
1604 if (error) {
1605 if (LogFileHandle)
1606 fprintf(LogFileHandle,
1607 GetPString(IDS_DELETEFAILED1TEXT),
1608 wk->li->list[x], error);
1609 if (Dos_Error(MB_ENTERCANCEL,
1610 error,
1611 wk->hwndFrame,
1612 pszSrcFile,
1613 __LINE__,
1614 GetPString(IDS_DELETEFAILED2TEXT),
1615 wk->li->list[x]) == MBID_CANCEL)
1616 break;
1617 }
1618 else {
1619 if (LogFileHandle)
1620 fprintf(LogFileHandle,
1621 GetPString(IDS_DELETEDTEXT), wk->li->list[x]);
1622 sprintf(prompt,
1623 GetPString(IDS_DELETEDTEXT), wk->li->list[x]);
1624 AddNote(prompt);
1625 }
1626 if (fSyncUpdates ||
1627 AddToList(wk->li->list[x], &files, &numfiles, &numalloc))
1628 Broadcast(hab2,
1629 wk->hwndCnr,
1630 UM_UPDATERECORD,
1631 MPFROMP(wk->li->list[x]), MPVOID);
1632 }
1633 }
1634 break;
1635 } // switch
1636 if (files) {
1637 Broadcast(hab2,
1638 wk->hwndCnr,
1639 UM_UPDATERECORDLIST, MPFROMP(files), MPVOID);
1640 FreeList(files);
1641 }
1642 if (WinIsWindow(hab2, wk->hwndCnr))
1643 PostMsg(wk->hwndCnr, UM_RESCAN, MPVOID, MPVOID);
1644
1645 WinDestroyMsgQueue(hmq2);
1646 }
1647 DecrThreadUsage();
1648 WinTerminate(hab2);
1649 }
1650 }
1651 if (wk->li)
1652 FreeListInfo(wk->li);
1653 free(wk);
1654# ifdef FORTIFY
1655 Fortify_LeaveScope();
1656# endif
1657 DosPostEventSem(CompactSem);
1658 }
1659}
1660#pragma alloc_text(MASSACTION,MassAction)
1661#pragma alloc_text(ACTION,Action)
1662#pragma alloc_text(UNDO,FreeUndo,Undo)
Note: See TracBrowser for help on using the repository browser.