source: trunk/dll/worker.c@ 1036

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

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