source: trunk/dll/worker.c@ 689

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

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