source: trunk/dll/worker.c@ 794

Last change on this file since 794 was 794, checked in by Gregg Young, 18 years ago

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