source: trunk/dll/worker.c@ 1033

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

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