source: trunk/dll/worker.c@ 575

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

Correct FileInfoProc binary file detect (Steven)
Correct FileInfoProc/IconProc race crash (Steven)
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 40.6 KB
Line 
1
2/***********************************************************************
3
4 $Id: worker.c 575 2007-03-24 22:34:09Z stevenhl $
5
6 Worker thread
7
8 Copyright (c) 1993-98 M. Kimes
9 Copyright (c) 2001, 2006 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***********************************************************************/
22
23#define INCL_DOS
24#define INCL_WIN
25#define INCL_DOSERRORS
26#include <os2.h>
27
28#include <stdarg.h>
29#include <stdio.h>
30#include <stdlib.h>
31#include <string.h>
32#include <ctype.h>
33#include <stddef.h>
34#include <share.h>
35#include <time.h>
36
37#include "fm3dll.h"
38#include "fm3dlg.h"
39#include "fm3str.h"
40
41#pragma data_seg(DATA2)
42
43static PSZ pszSrcFile = __FILE__;
44
45#pragma alloc_text(MASSACTION,MassAction)
46#pragma alloc_text(ACTION,Action)
47#pragma alloc_text(UNDO,FreeUndo,Undo)
48
49BOOL APIENTRY WinQueryObjectPath(HOBJECT hobject,
50 PSZ pszPathName, ULONG ulSize);
51
52#ifdef UNDO
53
54static VOID LINFO undo;
55
56VOID FreeUndo(VOID)
57{
58 if (undo->list)
59 FreeList(undo->list);
60 memset(&undo, 0, sizeof(undo));
61}
62
63VOID Undo(HWND hwndCnr, HWND hwndFrame, HWND hwndClient, HWND hwndParent)
64{
65 LISTINFO *li;
66 WORKER *wk;
67
68 if (undo->type && undo->list && undo->list[0]) {
69 switch (undo->type) {
70 case IDM_MOVE case IDM_COPY:
71 case IDM_EXTRACT:
72 {
73 li = xmallocz(sizeof(LISTINFO), pszSrcFile, __LINE__);
74 if (li) {
75 wk = xmallocz(sizeof(WORKER), pszSrcFile, __LINE__);
76 if (wk) {
77 wk->size = sizeof(WORKER);
78 wk->hwndCnr = hwndCnr;
79 wk->hwndParent = hwndParent;
80 wk->hwndFrame = hwndFrame;
81 wk->hwndClient = hwndClient;
82 wk->li = li;
83 *wk->li = *undo;
84 switch (undo->type) {
85 case IDM_COPY:
86 case IDM_EXTRACT:
87 li->type = IDM_PERMDELETE;
88 break;
89 }
90 if (_beginthread(MassAction, NULL, 122880, (PVOID) wk) == -1) {
91 Runtime_Error(pszSrcFile, __LINE__,
92 GetPString(IDS_COULDNTSTARTTHREADTEXT));
93 FreeListInfo(wk->li);
94 free(wk);
95 }
96 }
97 else
98 FreeListInfo(li);
99 }
100 }
101 break;
102 }
103 }
104 FreeUndo();
105}
106
107#endif // defined(UNDO)
108
109VOID Action(VOID * args)
110{
111 WORKER *wk = (WORKER *) args;
112 HAB hab2;
113 HMQ hmq2;
114 CHAR **files = NULL;
115 INT numfiles = 0, numalloc = 0, plen = 0;
116 CHAR *p, *pp;
117
118 if (wk) {
119 if (wk->li && wk->li->list && wk->li->list[0]) {
120 hab2 = WinInitialize(0);
121 if (hab2) {
122 hmq2 = WinCreateMsgQueue(hab2, 0);
123 if (hmq2) {
124 CHAR message[(CCHMAXPATH * 2) + 80], wildname[CCHMAXPATH];
125 register INT x;
126 BOOL dontask = FALSE, wildcarding = FALSE, overold =
127 FALSE, overnew = FALSE, usedtarget;
128
129 WinCancelShutdown(hmq2, TRUE);
130 IncrThreadUsage();
131 *wildname = 0;
132 switch (wk->li->type) {
133 case IDM_MERGE:
134 if (wk->li->type == IDM_MERGE) {
135 if (TestBinary(wk->li->list[0]))
136 wk->li->type = IDM_MERGEBINARY;
137 else
138 wk->li->type = IDM_MERGETEXT;
139 }
140 strcpy(wk->li->targetpath, wk->li->list[0]);
141 p = strrchr(wk->li->targetpath, '\\');
142 if (p) {
143 p++;
144 *p = 0;
145 }
146 else
147 strcat(wk->li->targetpath, "\\");
148 sprintf(wk->li->targetpath + strlen(wk->li->targetpath),
149 "MERGE.%03x", (clock() & 4095L));
150 if (!WinDlgBox(HWND_DESKTOP,
151 wk->hwndFrame,
152 MergeDlgProc, FM3ModHandle, MRG_FRAME, (PVOID) wk))
153 goto Abort;
154 if (!wk->li->type ||
155 !*wk->li->targetpath || !wk->li->list || !wk->li->list[0])
156 goto Abort;
157 if (IsFile(wk->li->targetpath) != 1 && !wk->li->list[1]) {
158 saymsg(MB_CANCEL | MB_ICONEXCLAMATION,
159 wk->hwndFrame,
160 GetPString(IDS_AHEMTEXT),
161 GetPString(IDS_SILLYMERGETEXT));
162 goto Abort;
163 }
164 break;
165 case IDM_WILDMOVE:
166 wildcarding = TRUE;
167 wk->li->type = IDM_MOVE;
168 break;
169 case IDM_WILDRENAME:
170 wildcarding = TRUE;
171 wk->li->type = IDM_RENAME;
172 break;
173 case IDM_WILDCOPY:
174 wildcarding = TRUE;
175 wk->li->type = IDM_COPY;
176 break;
177 case IDM_MOVEPRESERVE:
178 {
179 CHAR preserve[CCHMAXPATH], *end;
180
181 wk->li->type = IDM_MOVE;
182 strcpy(preserve, wk->li->list[0] + 2);
183 end = strrchr(preserve, '\\');
184 if (end) {
185 end++;
186 for (x = 1; wk->li->list[x]; x++) {
187 p = preserve;
188 pp = wk->li->list[x] + 2;
189 while (p < end && toupper(*p) == toupper(*pp)) {
190 p++;
191 pp++;
192 }
193 if (*p == '\\')
194 p++;
195 if (p < end)
196 end = p;
197 }
198 *end = 0;
199 }
200 else
201 *preserve = 0;
202 plen = strlen(preserve);
203 if (plen)
204 plen += 2;
205 }
206 break;
207 case IDM_COPYPRESERVE:
208 {
209 CHAR preserve[CCHMAXPATH], *end;
210
211 wk->li->type = IDM_COPY;
212 strcpy(preserve, wk->li->list[0] + 2);
213 end = strrchr(preserve, '\\');
214 if (end) {
215 end++;
216 for (x = 1; wk->li->list[x]; x++) {
217 p = preserve;
218 pp = wk->li->list[x] + 2;
219 while (p < end && toupper(*p) == toupper(*pp)) {
220 p++;
221 pp++;
222 }
223 if (*p == '\\')
224 p++;
225 if (p < end)
226 end = p;
227 }
228 *end = 0;
229 }
230 else
231 *preserve = 0;
232 plen = strlen(preserve);
233 if (plen)
234 plen += 2;
235 }
236 break;
237 }
238 if (wk->li && wk->li->list && wk->li->list[0]) {
239 for (x = 0; wk->li->list[x]; x++) {
240 switch (wk->li->type) {
241 case IDM_COLLECTFROMFILE:
242 if (Collector) {
243
244 CHAR *temp = xstrdup(wk->li->list[x], pszSrcFile, __LINE__);
245
246 if (temp) {
247 if (!PostMsg(Collector,
248 UM_COLLECTFROMFILE, MPFROMP(temp), MPVOID))
249 free(temp);
250 }
251 }
252 break;
253
254 case IDM_MERGEBINARY:
255 case IDM_MERGETEXT:
256 case IDM_MERGEBINARYAPPEND:
257 case IDM_MERGETEXTAPPEND:
258 {
259 FILE *in, *out;
260 CHAR *moder, *modew;
261 int c;
262
263 switch (wk->li->type) {
264 case IDM_MERGEBINARY:
265 moder = "rb";
266 modew = "wb";
267 break;
268 case IDM_MERGEBINARYAPPEND:
269 moder = "rb";
270 modew = "a+b";
271 break;
272 case IDM_MERGETEXTAPPEND:
273 moder = "r";
274 modew = "a+";
275 break;
276 default:
277 moder = "r";
278 modew = "w";
279 break;
280 }
281 in = _fsopen(wk->li->list[x], moder, SH_DENYWR);
282 if (!in) {
283 if (saymsg(MB_ENTERCANCEL,
284 HWND_DESKTOP,
285 GetPString(IDS_MERGEERRORTEXT),
286 GetPString(IDS_CANTOPENINPUTTEXT),
287 wk->li->list[x]) == MBID_CANCEL)
288 goto Abort;
289 }
290 else {
291 out = _fsopen(wk->li->targetpath, modew, SH_DENYWR);
292 if (out) {
293 fseek(out, 0L, SEEK_END);
294 switch (wk->li->type) {
295 case IDM_MERGEBINARY:
296 wk->li->type = IDM_MERGEBINARYAPPEND;
297 break;
298 default:
299 wk->li->type = IDM_MERGETEXTAPPEND;
300 break;
301 }
302 sprintf(message,
303 GetPString(IDS_MERGINGTEXT),
304 wk->li->list[x], wk->li->targetpath);
305 AddNote(message);
306 while ((c = fgetc(in)) != EOF)
307 fputc(c, out);
308 fclose(out);
309 sprintf(message,
310 GetPString(IDS_MERGECOMPLETETEXT),
311 wk->li->list[x], wk->li->targetpath);
312 AddNote(message);
313 }
314 else {
315 saymsg(MB_CANCEL,
316 HWND_DESKTOP,
317 GetPString(IDS_MERGEERRORTEXT),
318 GetPString(IDS_CANTOPENOUTPUTTEXT),
319 wk->li->targetpath);
320 fclose(in);
321 goto Abort;
322 }
323 fclose(in);
324 }
325 }
326 break;
327
328 case IDM_UUDECODE:
329 {
330 CHAR outname[CCHMAXPATH + 2];
331
332 sprintf(message,
333 GetPString(IDS_UUDECODINGTEXT), wk->li->list[x]);
334 AddNote(message);
335 if (UUD(wk->li->list[x], outname) && *outname) {
336 sprintf(message,
337 GetPString(IDS_UUDECODECOMPLETETEXT),
338 wk->li->list[x]);
339 AddNote(message);
340 if (fSyncUpdates ||
341 AddToList(outname, &files, &numfiles, &numalloc))
342 Broadcast(hab2,
343 wk->hwndCnr,
344 UM_UPDATERECORD, MPFROMP(outname), MPVOID);
345 }
346 else {
347 sprintf(message,
348 GetPString(IDS_UUDECODEABORTEDTEXT),
349 wk->li->list[x]);
350 AddNote(message);
351 }
352 }
353 break;
354
355 case IDM_VIEWARCHIVE:
356 if (IsFile(wk->li->list[x]) > 0) {
357
358 ARC_TYPE *info = NULL; // Say calling for editing - fixme to know why?
359
360 if (WinDlgBox(HWND_DESKTOP,
361 wk->hwndFrame,
362 SBoxDlgProc,
363 FM3ModHandle,
364 ASEL_FRAME, (PVOID) & info) && info) {
365 WinSendMsg(wk->hwndCnr,
366 UM_OPENWINDOWFORME,
367 MPFROMP(wk->li->list[x]), MPFROMP(info));
368 }
369 }
370 break;
371
372 case IDM_EXTRACT:
373 {
374 EXTRDATA ex;
375 BOOL maskspaces = FALSE;
376
377 memset(&ex, 0, sizeof(EXTRDATA));
378 ex.info = find_type(wk->li->list[x], NULL);
379 if (!ex.info || (!ex.info->extract && !ex.info->exwdirs))
380 break;
381 ex.size = sizeof(EXTRDATA);
382 ex.arcname = wk->li->list[x];
383 strcpy(ex.masks, "*");
384 strcpy(ex.extractdir, wk->li->targetpath);
385 if (!WinDlgBox(HWND_DESKTOP,
386 wk->hwndFrame,
387 ExtractDlgProc,
388 FM3ModHandle,
389 EXT_FRAME,
390 (PVOID) & ex) ||
391 !ex.ret ||
392 !*ex.command || !*ex.arcname || !*ex.extractdir)
393 goto Abort;
394 {
395 FILESTATUS3 fsa;
396
397 DosError(FERR_DISABLEHARDERR);
398 if (DosQueryPathInfo(ex.extractdir,
399 FIL_STANDARD,
400 &fsa,
401 (ULONG) sizeof(FILESTATUS3)) ||
402 !(fsa.attrFile & FILE_DIRECTORY))
403 goto Abort;
404 }
405 if (needs_quoting(ex.masks) && !strchr(ex.masks, '\"'))
406 maskspaces = TRUE;
407 if (!runemf2(SEPARATE | WINDOWED |
408 ((fArcStuffVisible) ? 0 :
409 (BACKGROUND | MINIMIZED)),
410 HWND_DESKTOP,
411 ex.extractdir,
412 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(1L);
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 CHAR d1[] = "\"";
857 CHAR d2[] = "\"";
858
859 if (!needs_quoting(wk->li->targetpath))
860 *d1 = 0;
861 if (!needs_quoting(wk->li->list[x]))
862 *d2 = 0;
863 runemf2(SEPARATE,
864 HWND_DESKTOP,
865 NULL,
866 NULL,
867 "%s %s%s%s %s%s%s",
868 dircompare,
869 d1,
870 wk->li->targetpath, d1, d2, wk->li->list[x], d2);
871 }
872 }
873 else if (*compare) {
874 CHAR *fakelist[3];
875
876 fakelist[0] = wk->li->list[x];
877 fakelist[1] = wk->li->targetpath;
878 fakelist[2] = NULL;
879 ExecOnList(wk->hwndFrame,
880 compare,
881 WINDOWED | SEPARATEKEEP, NULL, fakelist, NULL);
882 }
883 else {
884 FCOMPARE fc;
885
886 memset(&fc, 0, sizeof(fc));
887 fc.size = sizeof(fc);
888 fc.hwndParent = wk->hwndParent;
889 strcpy(fc.file1, wk->li->list[x]);
890 strcpy(fc.file2, wk->li->targetpath);
891 if (WinDlgBox(HWND_DESKTOP,
892 wk->hwndFrame,
893 CFileDlgProc,
894 FM3ModHandle, FCMP_FRAME, (PVOID) & fc))
895 goto Abort;
896 }
897 break;
898 } // switch
899 DosSleep(0L);
900 } // for list
901
902 switch (wk->li->type) {
903 case IDM_MOVE:
904 case IDM_COPY:
905 case IDM_WPSMOVE:
906 case IDM_WPSCOPY:
907 case IDM_RENAME:
908 sprintf(message,
909 GetPString(IDS_OPSCOMPLETETEXT),
910 (wk->li->type == IDM_MOVE) ?
911 GetPString(IDS_MOVETEXT) :
912 (wk->li->type == IDM_COPY) ?
913 GetPString(IDS_COPYTEXT) :
914 (wk->li->type == IDM_WPSMOVE) ?
915 GetPString(IDS_WPSMOVETEXT) :
916 (wk->li->type == IDM_WPSCOPY) ?
917 GetPString(IDS_WPSCOPYTEXT) :
918 GetPString(IDS_RENAMETEXT),
919 &"s"[x == 1],
920 (wk->li->type == IDM_MOVE ||
921 wk->li->type == IDM_COPY ||
922 wk->li->type == IDM_WPSMOVE ||
923 wk->li->type == IDM_WPSCOPY) ?
924 GetPString(IDS_TOTEXT) :
925 NullStr,
926 (wk->li->type == IDM_MOVE ||
927 wk->li->type == IDM_COPY ||
928 wk->li->type == IDM_WPSMOVE ||
929 wk->li->type == IDM_WPSCOPY) ?
930 wk->li->targetpath :
931 NullStr,
932 (x != 1) ?
933 GetPString(IDS_ARETEXT) : GetPString(IDS_ISTEXT));
934 Notify(message);
935 if (toupper(*wk->li->targetpath) < 'C')
936 DosBeep(1000, 25); // Wake up user
937 DosSleep(33L);
938 if (wk->li->type == IDM_WPSMOVE || wk->li->type == IDM_WPSCOPY)
939 DosSleep(96L);
940 break;
941 default:
942 break;
943 }
944 }
945
946 Abort:
947
948 if (files) {
949 Broadcast(hab2,
950 wk->hwndCnr,
951 UM_UPDATERECORDLIST, MPFROMP(files), MPVOID);
952 FreeList(files);
953 }
954
955 if (WinIsWindow(hab2, wk->hwndCnr))
956 PostMsg(wk->hwndCnr, UM_RESCAN, MPVOID, MPVOID);
957
958 WinDestroyMsgQueue(hmq2);
959 }
960 DecrThreadUsage();
961 WinTerminate(hab2);
962 }
963 }
964
965 if (wk->li)
966 FreeListInfo(wk->li);
967 free(wk);
968 DosPostEventSem(CompactSem);
969 }
970}
971
972VOID MassAction(VOID * args)
973{
974 WORKER *wk = (WORKER *) args;
975 HAB hab2;
976 HMQ hmq2;
977 CHAR **files = NULL;
978 register CHAR *p, *pp;
979 INT numfiles = 0, numalloc = 0;
980
981 if (wk) {
982 if (wk->li && wk->li->list && wk->li->list[0]) {
983 hab2 = WinInitialize(0);
984 if (hab2) {
985 hmq2 = WinCreateMsgQueue(hab2, 0);
986 if (hmq2) {
987 WinCancelShutdown(hmq2, TRUE);
988 IncrThreadUsage();
989 DosError(FERR_DISABLEHARDERR);
990 if (IsRoot(wk->li->list[0]) || !IsFile(wk->li->list[0])) {
991 if (wk->li->type == IDM_VIEW)
992 wk->li->type = IDM_INFO;
993 if (wk->li->type == IDM_EDIT)
994 wk->li->type = IDM_EAS;
995 }
996 switch (wk->li->type) {
997 case IDM_INFO:
998 if (WinDlgBox(HWND_DESKTOP,
999 wk->hwndFrame,
1000 FileInfoProc,
1001 FM3ModHandle, FLE_FRAME, (PVOID) wk->li->list) != 2)
1002 {
1003 break;
1004 }
1005 /* else intentional fallthru */
1006 case IDM_UPDATE:
1007 Broadcast(hab2,
1008 wk->hwndCnr,
1009 UM_UPDATERECORDLIST, MPFROMP(wk->li->list), MPVOID);
1010 break;
1011
1012 case IDM_EAS:
1013 if (WinDlgBox(HWND_DESKTOP,
1014 wk->hwndFrame,
1015 DisplayEAsProc,
1016 FM3ModHandle, EA_FRAME, (PVOID) wk->li->list))
1017 Broadcast(hab2,
1018 wk->hwndCnr,
1019 UM_UPDATERECORDLIST, MPFROMP(wk->li->list), MPVOID);
1020 break;
1021
1022 case IDM_DOITYOURSELF:
1023 ExecOnList(wk->hwndFrame,
1024 "%a",
1025 WINDOWED | SEPARATE | PROMPT,
1026 NULL, wk->li->list, GetPString(IDS_DOITYOURSELFTEXT));
1027 break;
1028
1029 case IDM_MCIPLAY:
1030 {
1031 register INT x;
1032 register ULONG total = strlen("FM2PLAY.EXE ");
1033
1034 if (fAddUtils)
1035 total += strlen("UTILS\\");
1036 for (x = 0; wk->li->list[x]; x++)
1037 total += (strlen(wk->li->list[x]) + 1 +
1038 (needs_quoting(wk->li->list[x]) * 2));
1039 if (total > 1000) {
1040
1041 FILE *fp;
1042
1043 fp = xfopen("$FM2PLAY.$$$", "w", pszSrcFile, __LINE__);
1044 if (fp) {
1045 fprintf(fp, "%s", ";FM/2-built FM2Play listfile\n");
1046 for (x = 0; wk->li->list[x]; x++)
1047 fprintf(fp, "%s\n", wk->li->list[x]);
1048 fprintf(fp, ";end\n");
1049 fclose(fp);
1050 runemf2(SEPARATE | WINDOWED,
1051 HWND_DESKTOP,
1052 NULL,
1053 NULL,
1054 "%sFM2PLAY.EXE /#$FM2PLAY.$$$",
1055 (fAddUtils) ? "UTILS\\" : NullStr);
1056 break;
1057 }
1058 }
1059 }
1060 /* intentional fallthru */
1061 case IDM_FAKEEXTRACT:
1062 case IDM_FAKEEXTRACTM:
1063 if (wk->li->type == IDM_MCIPLAY ||
1064 (*wk->li->arcname && wk->li->info &&
1065 wk->li->info->extract && *wk->li->targetpath)) {
1066
1067 CHAR szBuffer[1025];
1068 register INT x;
1069
1070 if (wk->li->type == IDM_FAKEEXTRACT ||
1071 wk->li->type == IDM_FAKEEXTRACTM) {
1072 strcpy(szBuffer,
1073 (wk->li->info->exwdirs) ?
1074 wk->li->info->exwdirs : wk->li->info->extract);
1075 strcat(szBuffer, " ");
1076 if (needs_quoting(wk->li->arcname))
1077 strcat(szBuffer, "\"");
1078 strcat(szBuffer, wk->li->arcname);
1079 if (needs_quoting(wk->li->arcname))
1080 strcat(szBuffer, "\"");
1081 }
1082 else {
1083 if (fAddUtils)
1084 strcpy(szBuffer, "UTILS\\FM2PLAY.EXE");
1085 else
1086 strcpy(szBuffer, "FM2PLAY.EXE");
1087 }
1088 p = &szBuffer[strlen(szBuffer)];
1089 strcat(szBuffer, " ");
1090 x = 0;
1091 while (wk->li->list[x]) {
1092 pp = wk->li->list[x];
1093 while (*pp) {
1094 if (*pp == '/')
1095 *pp = '\\';
1096 pp++;
1097 }
1098 if (needs_quoting(wk->li->list[x]))
1099 strcat(szBuffer, "\"");
1100 strcat(szBuffer, wk->li->list[x]);
1101 if (needs_quoting(wk->li->list[x]))
1102 strcat(szBuffer, "\"");
1103 x++;
1104 if (!wk->li->list[x] || strlen(szBuffer) +
1105 strlen(wk->li->list[x]) + 5 > 1024) {
1106 runemf2(SEPARATE | WINDOWED | BACKGROUND | MINIMIZED | WAIT,
1107 HWND_DESKTOP,
1108 ((wk->li->type == IDM_FAKEEXTRACT ||
1109 wk->li->type == IDM_FAKEEXTRACTM) ?
1110 wk->li->targetpath : NULL), NULL, "%s", szBuffer);
1111 DosSleep(1L);
1112 *p = 0;
1113 }
1114 strcat(szBuffer, " ");
1115 }
1116 if (wk->li->type == IDM_MCIPLAY)
1117 break;
1118 strcpy(szBuffer, wk->li->targetpath);
1119 if (wk->li->targetpath[strlen(wk->li->targetpath) - 1] != '\\')
1120 strcat(szBuffer, "\\");
1121 p = szBuffer + strlen(szBuffer);
1122 for (x = 0; wk->li->list[x]; x++) {
1123 strcpy(p, wk->li->list[x]);
1124 free(wk->li->list[x]);
1125 wk->li->list[x] = xstrdup(szBuffer, pszSrcFile, __LINE__);
1126 }
1127 if (wk->li->list[0])
1128 Broadcast(hab2,
1129 wk->hwndCnr,
1130 UM_UPDATERECORDLIST, MPFROMP(wk->li->list), MPVOID);
1131 }
1132 break;
1133
1134 case IDM_SETICON:
1135 if (*wk->li->targetpath) {
1136
1137 ICONINFO ici;
1138
1139 memset(&ici, 0, sizeof(ICONINFO));
1140 ici.cb = sizeof(ICONINFO);
1141 ici.fFormat = ICON_FILE;
1142 ici.pszFileName = wk->li->list[0];
1143 if (!WinSetFileIcon((PSZ) wk->li->targetpath,
1144 (PICONINFO) & ici)) {
1145 ici.fFormat = ICON_CLEAR;
1146 WinSetFileIcon((PSZ) wk->li->targetpath, (PICONINFO) & ici);
1147 }
1148 Broadcast(hab2,
1149 wk->hwndCnr,
1150 UM_UPDATERECORD, MPFROMP(wk->li->targetpath), MPVOID);
1151 }
1152 break;
1153
1154 case IDM_APPENDTOCLIP:
1155 case IDM_SAVETOCLIP:
1156 ListToClipboardHab(hab2,
1157 wk->li->list,
1158 (wk->li->type == IDM_APPENDTOCLIP));
1159 break;
1160
1161 case IDM_ARCHIVEM:
1162 case IDM_ARCHIVE:
1163 {
1164 DIRCNRDATA ad;
1165 CHAR szBuffer[1025];
1166 ARC_TYPE *info = NULL;
1167 char *pch;
1168 register INT x;
1169
1170 memset(&ad, 0, sizeof(DIRCNRDATA));
1171 strcpy(ad.arcname, wk->li->targetpath);
1172 if (*wk->li->targetpath && IsFile(wk->li->targetpath) > 0) {
1173 info = find_type(wk->li->targetpath, NULL);
1174 ad.namecanchange = 0;
1175 }
1176 else {
1177 if (*wk->li->targetpath && !IsFile(wk->li->targetpath))
1178 if (wk->li->targetpath[strlen(wk->li->targetpath) - 1] !=
1179 '\\')
1180 strcat(wk->li->targetpath, "\\");
1181 ad.namecanchange = 1;
1182 }
1183 strcpy(ad.arcname, wk->li->targetpath);
1184 if (wk->li->type == IDM_ARCHIVEM)
1185 ad.fmoving = TRUE;
1186 if (!info) {
1187 ad.info = arcsighead; // Hide dups
1188 if (!WinDlgBox(HWND_DESKTOP,
1189 wk->hwndFrame,
1190 SBoxDlgProc,
1191 FM3ModHandle,
1192 ASEL_FRAME, (PVOID) & ad.info) || !ad.info) {
1193 break; /* we blew it */
1194 }
1195 }
1196 else
1197 ad.info = info;
1198 if (!ad.info || (!ad.info->create &&
1199 !ad.info->move &&
1200 !ad.info->createwdirs &&
1201 !ad.info->movewdirs &&
1202 !ad.info->createrecurse))
1203 break;
1204 if (!*wk->li->targetpath && *wk->directory) {
1205 strcpy(ad.arcname, wk->directory);
1206 if (ad.arcname[strlen(ad.arcname) - 1] != '\\')
1207 strcat(ad.arcname, "\\");
1208 }
1209 if (!WinDlgBox(HWND_DESKTOP, wk->hwndFrame, ArchiveDlgProc, FM3ModHandle, ARCH_FRAME, (PVOID) & ad) || !*ad.arcname || !*ad.command) /* we blew it */
1210 break;
1211 // Provide extension so containers work
1212 pch = strrchr(ad.arcname, '\\');
1213 if (pch)
1214 pch = strrchr(pch, '.');
1215 else
1216 pch = strrchr(ad.arcname, '.');
1217 if (!pch && ad.info->ext) {
1218 strcat(ad.arcname, ".");
1219 strcat(ad.arcname, ad.info->ext);
1220 }
1221 /* build the sucker */
1222 strcpy(szBuffer, ad.command);
1223 strcat(szBuffer, " ");
1224 if (needs_quoting(ad.arcname))
1225 strcat(szBuffer, "\"");
1226 strcat(szBuffer, ad.arcname);
1227 if (needs_quoting(ad.arcname))
1228 strcat(szBuffer, "\"");
1229 p = &szBuffer[strlen(szBuffer)];
1230 if (ad.mask.szMask) {
1231 strcat(szBuffer, " ");
1232 strcat(szBuffer, ad.mask.szMask);
1233 }
1234 strcat(szBuffer, " ");
1235 x = 0;
1236 while (wk->li->list[x]) {
1237
1238 FILESTATUS3 fsa;
1239 BOOL spaces;
1240
1241 if (needs_quoting(wk->li->list[x])) {
1242 spaces = TRUE;
1243 strcat(szBuffer, "\"");
1244 }
1245 else
1246 spaces = FALSE;
1247 strcat(szBuffer, wk->li->list[x]);
1248 memset(&fsa, 0, sizeof(FILESTATUS3));
1249 DosError(FERR_DISABLEHARDERR);
1250 DosQueryPathInfo(wk->li->list[x],
1251 FIL_STANDARD,
1252 &fsa, (ULONG) sizeof(FILESTATUS3));
1253 if (fsa.attrFile & FILE_DIRECTORY) {
1254 if (szBuffer[strlen(szBuffer) - 1] != '\\')
1255 strcat(szBuffer, "\\");
1256 strcat(szBuffer, "*");
1257 }
1258 if (spaces)
1259 strcat(szBuffer, "\"");
1260 x++;
1261 if (!wk->li->list[x] ||
1262 strlen(szBuffer) + strlen(wk->li->list[x]) + 5 > 1024) {
1263 runemf2(SEPARATE | WINDOWED |
1264 ((fArcStuffVisible) ? 0 :
1265 (BACKGROUND | MINIMIZED)) |
1266 WAIT, HWND_DESKTOP, NULL, NULL, "%s", szBuffer);
1267 DosSleep(1L);
1268 *p = 0;
1269 }
1270 strcat(szBuffer, " ");
1271 }
1272 Broadcast(hab2,
1273 wk->hwndCnr,
1274 UM_UPDATERECORDLIST, MPFROMP(wk->li->list), MPVOID);
1275 Broadcast(hab2,
1276 wk->hwndCnr,
1277 UM_UPDATERECORD, MPFROMP(ad.arcname), MPVOID);
1278 }
1279 break;
1280
1281 case IDM_VIEW:
1282 if (!TestBinary(wk->li->list[0])) {
1283 wk->li->type = IDM_VIEWTEXT;
1284 goto SkipViewing;
1285 }
1286 else
1287 wk->li->type = IDM_VIEWBINARY;
1288 /* intentional fallthru */
1289 case IDM_VIEWBINARY:
1290 if (*binview) {
1291 ExecOnList((HWND) 0,
1292 binview,
1293 WINDOWED | SEPARATE, NULL, wk->li->list, NULL);
1294 break;
1295 }
1296 /* else intentional fallthru */
1297 case IDM_VIEWTEXT:
1298 SkipViewing:
1299 if (*viewer)
1300 ExecOnList((HWND) 0, viewer,
1301 WINDOWED | SEPARATE |
1302 ((fViewChild) ? CHILD : 0),
1303 NULL, wk->li->list, NULL);
1304 else {
1305
1306 CHAR *temp;
1307 register INT x;
1308 ULONG viewtype;
1309
1310 viewtype = (wk->li->type == IDM_VIEWTEXT) ? 8 :
1311 (wk->li->type == IDM_VIEWBINARY) ? 16 : 0;
1312 for (x = 0; wk->li->list[x]; x++) {
1313 temp = xstrdup(wk->li->list[x], pszSrcFile, __LINE__);
1314 if (temp && WinIsWindow(hab2, wk->hwndCnr)) {
1315 if (!PostMsg(wk->hwndCnr,
1316 UM_LOADFILE,
1317 MPFROMLONG(5L + viewtype), MPFROMP(temp)))
1318 free(temp);
1319 }
1320 DosSleep(1L);
1321 }
1322 }
1323 break;
1324
1325 case IDM_EDIT:
1326 if (!TestBinary(wk->li->list[0])) {
1327 wk->li->type = IDM_EDITTEXT;
1328 goto SkipEditing;
1329 }
1330 else
1331 wk->li->type = IDM_EDITBINARY;
1332 /* intentional fallthru */
1333 case IDM_EDITBINARY:
1334 if (*bined) {
1335 ExecOnList((HWND) 0,
1336 bined,
1337 WINDOWED | SEPARATE, NULL, wk->li->list, NULL);
1338 break;
1339 }
1340 /* else intentional fallthru */
1341 case IDM_EDITTEXT:
1342 SkipEditing:
1343 if (*editor)
1344 ExecOnList((HWND) 0,
1345 editor,
1346 WINDOWED | SEPARATE, NULL, wk->li->list, NULL);
1347 else {
1348
1349 CHAR *temp;
1350 register INT x;
1351 ULONG viewtype;
1352
1353 viewtype = (wk->li->type == IDM_EDITTEXT) ? 8 :
1354 (wk->li->type == IDM_EDITBINARY) ? 16 : 0;
1355 for (x = 0; wk->li->list[x]; x++) {
1356 temp = xstrdup(wk->li->list[x], pszSrcFile, __LINE__);
1357 if (temp && WinIsWindow(hab2, wk->hwndCnr)) {
1358 if (!PostMsg(wk->hwndCnr,
1359 UM_LOADFILE,
1360 MPFROMLONG(4L + viewtype), MPFROMP(temp)))
1361 free(temp);
1362 }
1363 DosSleep(1L);
1364 }
1365 }
1366 break;
1367
1368 case IDM_SHADOW2:
1369 case IDM_OBJECT:
1370 case IDM_SHADOW:
1371 {
1372 CHAR objectpath[CCHMAXPATH];
1373 APIRET rc;
1374
1375 if (!*wk->li->targetpath || IsFile(wk->li->targetpath)) {
1376 GetDesktopName(objectpath, sizeof(objectpath));
1377 rc = WinDlgBox(HWND_DESKTOP,
1378 wk->hwndFrame,
1379 ObjCnrDlgProc,
1380 FM3ModHandle,
1381 OBJCNR_FRAME, MPFROMP(objectpath));
1382 if (rc) {
1383 if (rc > 1)
1384 strcpy(objectpath, "<WP_DESKTOP>");
1385 }
1386 else
1387 break;
1388 }
1389 else
1390 strcpy(objectpath, wk->li->targetpath);
1391 AddNote(GetPString(IDS_MAKINGOBJSTEXT));
1392 MakeShadows(wk->hwndFrame,
1393 wk->li->list,
1394 (wk->li->type == IDM_SHADOW) +
1395 (wk->li->type == IDM_SHADOW2) * 2,
1396 objectpath, NULL);
1397 AddNote(GetPString(IDS_MADEOBJSTEXT));
1398 }
1399 break;
1400
1401 case IDM_PRINT:
1402 if (WinDlgBox(HWND_DESKTOP,
1403 wk->hwndFrame,
1404 PrintDlgProc,
1405 FM3ModHandle, PRN_FRAME, MPFROMP(wk->li))) {
1406 if (wk->li && wk->li->list && wk->li->list[0]) {
1407 strcpy(wk->li->targetpath, printer);
1408 if (_beginthread(PrintListThread, NULL, 65536, (PVOID) wk->li)
1409 == -1)
1410 Runtime_Error(pszSrcFile, __LINE__,
1411 GetPString(IDS_COULDNTSTARTTHREADTEXT));
1412 else
1413 wk->li = NULL; /* prevent LISTINFO li from being freed */
1414 }
1415 }
1416 break;
1417
1418 case IDM_ATTRS:
1419 if (WinDlgBox(HWND_DESKTOP,
1420 wk->hwndFrame,
1421 AttrListDlgProc,
1422 FM3ModHandle, ATR_FRAME, MPFROMP(wk->li))) {
1423 if (wk->li && wk->li->list && wk->li->list[0])
1424 Broadcast(hab2,
1425 wk->hwndCnr,
1426 UM_UPDATERECORDLIST, MPFROMP(wk->li->list), MPVOID);
1427 }
1428 break;
1429
1430 case IDM_PERMDELETE:
1431 case IDM_DELETE:
1432 {
1433 CHECKLIST cl;
1434 INT isdir = 0, sysdir = 0, ro = 0, hs = 0;
1435 register INT x;
1436 FILESTATUS3 fsa;
1437 CHAR prompt[CCHMAXPATH * 3];
1438 APIRET error;
1439
1440 for (x = 0; wk->li->list[x]; x++) {
1441 if (IsRoot(wk->li->list[x])) {
1442 wk->li->list = RemoveFromList(wk->li->list,
1443 wk->li->list[x]);
1444 if (!wk->li->list)
1445 break;
1446 x--;
1447 continue;
1448 }
1449 DosError(FERR_DISABLEHARDERR);
1450 if (DosQueryPathInfo(wk->li->list[x],
1451 FIL_STANDARD, &fsa,
1452 (ULONG) sizeof(FILESTATUS3))) {
1453 wk->li->list = RemoveFromList(wk->li->list,
1454 wk->li->list[x]);
1455 if (!wk->li->list)
1456 break;
1457 x--;
1458 continue;
1459 }
1460 if (fsa.attrFile & FILE_DIRECTORY) {
1461 isdir++;
1462 if (stristr(wk->li->list[x], ":\\OS2\\") ||
1463 !stricmp(wk->li->list[x] + 1, ":\\OS2"))
1464 sysdir++;
1465 }
1466 else {
1467 if (fsa.attrFile & (FILE_HIDDEN | FILE_SYSTEM))
1468 hs++;
1469 if (fsa.attrFile & FILE_READONLY)
1470 ro++;
1471 }
1472 }
1473 if (!wk->li->list)
1474 break;
1475 if (fConfirmDelete || isdir || hs || ro) {
1476 memset(&cl, 0, sizeof(cl));
1477 cl.size = sizeof(cl);
1478 cl.list = wk->li->list;
1479 cl.prompt = prompt;
1480 cl.flags |= CHECK_FILES;
1481 cl.cmd = wk->li->type;
1482 sprintf(prompt,
1483 GetPString(IDS_DELPROMPT1TEXT),
1484 (wk->li->type == IDM_DELETE) ?
1485 NullStr :
1486 GetPString(IDS_PERMANENTLYTEXT),
1487 &"s"[wk->li->list[1] == NULL]);
1488 if (isdir) {
1489 sprintf(&prompt[strlen(prompt)],
1490 GetPString(IDS_DELPROMPT2TEXT),
1491 isdir,
1492 (isdir > 1) ?
1493 GetPString(IDS_ARETEXT) :
1494 GetPString(IDS_ISTEXT),
1495 (isdir == 1) ?
1496 GetPString(IDS_ATEXT) :
1497 NullStr,
1498 (isdir > 1) ?
1499 GetPString(IDS_IESTEXT) : GetPString(IDS_YTEXT));
1500 if (sysdir)
1501 sprintf(&prompt[strlen(prompt)],
1502 GetPString(IDS_DELPROMPT3TEXT),
1503 sysdir,
1504 (sysdir == 1) ?
1505 GetPString(IDS_YTEXT) : GetPString(IDS_IESTEXT));
1506 }
1507 if (ro)
1508 sprintf(&prompt[strlen(prompt)],
1509 GetPString(IDS_DELPROMPT4TEXT),
1510 ro,
1511 &"s"[ro == 1],
1512 (ro > 1) ?
1513 GetPString(IDS_ARETEXT) : GetPString(IDS_ISTEXT));
1514 if (hs)
1515 sprintf(&prompt[strlen(prompt)],
1516 GetPString(IDS_DELPROMPT5TEXT),
1517 hs,
1518 &"s"[hs == 1],
1519 (hs > 1) ?
1520 GetPString(IDS_ARETEXT) : GetPString(IDS_ISTEXT));
1521 if (ro || hs || sysdir)
1522 DosBeep(300, 100); // Wake up user
1523 strcat(prompt, GetPString(IDS_DELPROMPT6TEXT));
1524 error = WinDlgBox(HWND_DESKTOP,
1525 wk->hwndFrame,
1526 CheckListProc,
1527 FM3ModHandle, CHECK_FRAME, MPFROMP(&cl));
1528 if (!error || error == 65535)
1529 break;
1530 wk->li->list = cl.list;
1531 if (!wk->li->list || !wk->li->list[0])
1532 break;
1533 }
1534 for (x = 0; wk->li->list[x]; x++) {
1535 fsa.attrFile = 0;
1536 DosError(FERR_DISABLEHARDERR);
1537 DosQueryPathInfo(wk->li->list[x],
1538 FIL_STANDARD,
1539 &fsa, (ULONG) sizeof(FILESTATUS3));
1540 if (fsa.attrFile & FILE_DIRECTORY) {
1541 sprintf(prompt,
1542 GetPString(IDS_DELETINGTEXT), wk->li->list[x]);
1543 AddNote(prompt);
1544 error = (APIRET) wipeallf("%s%s*",
1545 wk->li->list[x],
1546 (*wk->li->list[x] &&
1547 wk->li->
1548 list[x][strlen(wk->li->list[x]) -
1549 1] !=
1550 '\\') ? "\\" : NullStr);
1551 DosError(FERR_DISABLEHARDERR);
1552 if (!error)
1553 error = DosDeleteDir(wk->li->list[x]);
1554 else
1555 DosDeleteDir(wk->li->list[x]);
1556 }
1557 else {
1558 sprintf(prompt,
1559 GetPString(IDS_DELETINGTEXT), wk->li->list[x]);
1560 AddNote(prompt);
1561 DosError(FERR_DISABLEHARDERR);
1562 if (wk->li->type == IDM_DELETE)
1563 error = DosDelete(wk->li->list[x]);
1564 else
1565 error = DosForceDelete(wk->li->list[x]);
1566 if (error) {
1567 DosError(FERR_DISABLEHARDERR);
1568 make_deleteable(wk->li->list[x]);
1569 if (wk->li->type == IDM_DELETE)
1570 error = DosDelete(wk->li->list[x]);
1571 else
1572 error = DosForceDelete(wk->li->list[x]);
1573 }
1574 }
1575 if (error) {
1576 if (LogFileHandle)
1577 fprintf(LogFileHandle,
1578 GetPString(IDS_DELETEFAILED1TEXT),
1579 wk->li->list[x], error);
1580 if (Dos_Error(MB_ENTERCANCEL,
1581 error,
1582 wk->hwndFrame,
1583 pszSrcFile,
1584 __LINE__,
1585 GetPString(IDS_DELETEFAILED2TEXT),
1586 wk->li->list[x]) == MBID_CANCEL)
1587 break;
1588 }
1589 else {
1590 if (LogFileHandle)
1591 fprintf(LogFileHandle,
1592 GetPString(IDS_DELETEDTEXT), wk->li->list[x]);
1593 sprintf(prompt,
1594 GetPString(IDS_DELETEDTEXT), wk->li->list[x]);
1595 AddNote(prompt);
1596 }
1597 if (fSyncUpdates ||
1598 AddToList(wk->li->list[x], &files, &numfiles, &numalloc))
1599 Broadcast(hab2,
1600 wk->hwndCnr,
1601 UM_UPDATERECORD,
1602 MPFROMP(wk->li->list[x]), MPVOID);
1603 }
1604 }
1605 break;
1606 } // switch
1607 if (files) {
1608 Broadcast(hab2,
1609 wk->hwndCnr,
1610 UM_UPDATERECORDLIST, MPFROMP(files), MPVOID);
1611 FreeList(files);
1612 }
1613 Abort:
1614 if (WinIsWindow(hab2, wk->hwndCnr))
1615 PostMsg(wk->hwndCnr, UM_RESCAN, MPVOID, MPVOID);
1616
1617 WinDestroyMsgQueue(hmq2);
1618 }
1619 DecrThreadUsage();
1620 WinTerminate(hab2);
1621 }
1622 }
1623 if (wk->li)
1624 FreeListInfo(wk->li);
1625 free(wk);
1626 DosPostEventSem(CompactSem);
1627 }
1628}
Note: See TracBrowser for help on using the repository browser.