source: trunk/dll/worker.c@ 928

Last change on this file since 928 was 907, checked in by Steven Levine, 18 years ago

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