source: trunk/dll/worker.c@ 627

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

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