source: trunk/dll/worker.c@ 559

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

Update svn:ignore
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 40.5 KB
Line 
1
2/***********************************************************************
3
4 $Id: worker.c 559 2007-03-09 20:33:54Z 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 else {
464 if (!WinDlgBox(HWND_DESKTOP,
465 HWND_DESKTOP,
466 DrvInfoProc,
467 FM3ModHandle,
468 INFO_FRAME, (PVOID) wk->li->list[x]))
469 goto Abort;
470 }
471 }
472 break;
473
474 case IDM_OPENWINDOW:
475 if (!IsFile(wk->li->list[x]) &&
476 WinIsWindow(hab2, wk->hwndCnr))
477 WinSendMsg(wk->hwndCnr,
478 UM_OPENWINDOWFORME,
479 MPFROMP(wk->li->list[x]), MPVOID);
480 break;
481
482 case IDM_OPENICON:
483 case IDM_OPENDETAILS:
484 case IDM_OPENTREE:
485 {
486 FILESTATUS3 fsa;
487
488 DosError(FERR_DISABLEHARDERR);
489 if (DosQueryPathInfo(wk->li->list[x],
490 FIL_STANDARD,
491 &fsa,
492 (ULONG) sizeof(FILESTATUS3)) ||
493 !(fsa.attrFile & FILE_DIRECTORY))
494 break;
495 }
496 /* else intentional fallthru */
497 case IDM_OPENDEFAULT:
498 case IDM_OPENSETTINGS:
499 {
500 CHAR *s;
501
502 switch (wk->li->type) {
503 case IDM_OPENICON:
504 s = "ICON";
505 break;
506 case IDM_OPENDETAILS:
507 s = "DETAILS";
508 break;
509 case IDM_OPENTREE:
510 s = "TREE";
511 break;
512 case IDM_OPENSETTINGS:
513 s = Settings;
514 break;
515 default:
516 s = Default;
517 break;
518 }
519 OpenObject(wk->li->list[x], s, wk->hwndFrame);
520 }
521 break;
522
523 case IDM_WPSMOVE:
524 case IDM_WPSCOPY:
525 case IDM_MOVE:
526 case IDM_COPY:
527 case IDM_RENAME:
528 if (!*wk->li->targetpath && (wk->li->type == IDM_MOVE ||
529 wk->li->type == IDM_COPY ||
530 wk->li->type == IDM_WPSMOVE ||
531 wk->li->type == IDM_WPSCOPY)) {
532
533 APIRET rc = 1;
534
535 usedtarget = FALSE;
536 if (hwndMain) {
537 if (!*targetdir)
538 TopWindowName(hwndMain,
539 wk->hwndFrame, wk->li->targetpath);
540 else {
541 strcpy(wk->li->targetpath, targetdir);
542 usedtarget = TRUE;
543 }
544 }
545 if (!*wk->li->targetpath)
546 strcpy(wk->li->targetpath, wk->directory);
547 if (!*wk->li->targetpath) {
548 strcpy(wk->li->targetpath, wk->li->list[0]);
549 p = strrchr(wk->li->targetpath, '\\');
550 if (p) {
551 if (*(p - 1) == ':')
552 p++;
553 *p = 0;
554 }
555 }
556 MakeValidDir(wk->li->targetpath);
557 if (fConfirmTarget ||
558 (!*targetdir && strcmp(realappname, "FM/4"))) {
559 RetryPath:
560 usedtarget = FALSE;
561 if (wk->li->type == IDM_MOVE ||
562 wk->li->type == IDM_WPSMOVE) {
563 rc = WinDlgBox(HWND_DESKTOP,
564 wk->hwndFrame,
565 WalkMoveDlgProc,
566 FM3ModHandle,
567 WALK_FRAME, MPFROMP(wk->li->targetpath));
568 }
569 else if (wk->li->type == IDM_COPY ||
570 wk->li->type == IDM_WPSCOPY) {
571 rc = WinDlgBox(HWND_DESKTOP,
572 wk->hwndFrame,
573 WalkCopyDlgProc,
574 FM3ModHandle,
575 WALK_FRAME, MPFROMP(wk->li->targetpath));
576 }
577 else
578 rc = WinDlgBox(HWND_DESKTOP,
579 wk->hwndFrame,
580 WalkDlgProc,
581 FM3ModHandle,
582 WALK_FRAME, MPFROMP(wk->li->targetpath));
583 }
584 if (!rc || !*wk->li->targetpath)
585 goto Abort;
586 if (driveflags[toupper(*wk->li->targetpath) - 'A'] &
587 DRIVE_NOTWRITEABLE) {
588 saymsg(MB_CANCEL,
589 wk->hwndFrame,
590 GetPString(IDS_ERRORTEXT),
591 "%s", GetPString(IDS_NOTWRITENOTARGETTEXT));
592 goto RetryPath;
593 }
594 }
595 Retry:
596 {
597 CHAR newname[CCHMAXPATH], *moving, *move, *moved;
598 APIRET rc;
599 INT type;
600 FILESTATUS4 fs4;
601 BOOL isnewer, existed;
602
603 type = (wk->li->type == IDM_RENAME) ? MOVE :
604 (wk->li->type == IDM_MOVE) ? MOVE :
605 (wk->li->type == IDM_WPSMOVE) ? WPSMOVE :
606 (wk->li->type == IDM_WPSCOPY) ? WPSCOPY : COPY;
607 moving = (wk->li->type == IDM_RENAME) ?
608 GetPString(IDS_RENAMINGTEXT) :
609 (wk->li->type == IDM_MOVE ||
610 wk->li->type == IDM_WPSMOVE) ?
611 GetPString(IDS_MOVINGTEXT) : GetPString(IDS_COPYINGTEXT);
612 move = (wk->li->type == IDM_RENAME) ?
613 GetPString(IDS_RENAMETEXT) :
614 (wk->li->type == IDM_MOVE ||
615 wk->li->type == IDM_WPSMOVE) ?
616 GetPString(IDS_MOVETEXT) : GetPString(IDS_COPYTEXT);
617 moved = (wk->li->type == IDM_RENAME) ?
618 GetPString(IDS_RENAMEDTEXT) :
619 (wk->li->type == IDM_MOVE ||
620 wk->li->type == IDM_WPSMOVE) ?
621 GetPString(IDS_MOVEDTEXT) : GetPString(IDS_COPIEDTEXT);
622 if (*wk->li->targetpath) {
623 strcpy(newname, wk->li->targetpath);
624 if (newname[strlen(newname) - 1] != '\\')
625 strcat(newname, "\\");
626 if (plen)
627 p = wk->li->list[x] + plen;
628 else {
629 p = strrchr(wk->li->list[x], '\\');
630 if (p)
631 p++;
632 else
633 p = wk->li->list[x];
634 }
635 strcat(newname, p);
636 }
637 else
638 strcpy(newname, wk->li->list[x]);
639 if ((wildcarding || wk->li->type == IDM_RENAME) &&
640 *wildname) {
641
642 CHAR testname[CCHMAXPATH];
643
644 strcpy(testname, wildname);
645 if (AdjustWildcardName(newname, testname))
646 strcpy(newname, testname);
647 }
648 existed = (IsFile(newname) != -1);
649 isnewer = IsNewer(wk->li->list[x], newname);
650 /*
651 {
652 char temp[CCHMAXPATH * 3];
653 sprintf(temp,"Target: %s\rSource: %s\rOverold: %lu\rOvernew: %lu\rIsNewer: %lu\rExisted: %lu",newname,wk->li->list[x],overold,overnew,isnewer,existed);
654 saymsg(MB_ENTER,HWND_DESKTOP,DEBUG_STRING,temp);
655 }
656 */
657 if (existed && wk->li->type != IDM_RENAME && dontask) {
658 if (!overold && !overnew)
659 break;
660 if (!overold && !isnewer)
661 break;
662 if (!overnew && isnewer)
663 break;
664 }
665 if ((wk->li->type == IDM_RENAME &&
666 (!dontask || !*wildname)) ||
667 (!dontask && existed) ||
668 (!dontask && wildcarding) ||
669 (IsFile(newname) == 0 && IsFile(wk->li->list[x]) > 0)) {
670
671 MOVEIT mv;
672
673 memset(&mv, 0, sizeof(MOVEIT));
674 mv.rename = (wk->li->type == IDM_RENAME);
675 mv.source = wk->li->list[x];
676 strcpy(mv.target, newname);
677 rc = WinDlgBox(HWND_DESKTOP,
678 wk->hwndFrame,
679 RenameProc,
680 FM3ModHandle, REN_FRAME, (PVOID) & mv);
681 if (!rc)
682 goto Abort;
683 DosSleep(1L);
684 if (mv.skip || !*mv.target)
685 break;
686 if (mv.dontask)
687 dontask = TRUE;
688 if (mv.overold)
689 overold = TRUE;
690 if (mv.overnew)
691 overnew = TRUE;
692 if (wildcarding || wk->li->type == IDM_RENAME) {
693 p = strrchr(mv.target, '\\');
694 if (p && (strchr(p, '*') || strchr(p, '?'))) {
695 strcpy(wildname, mv.target);
696 AdjustWildcardName(wk->li->list[x], mv.target);
697 }
698 else
699 *wildname = 0;
700 }
701 strcpy(newname, mv.target);
702 existed = (IsFile(newname) != -1);
703 isnewer = IsNewer(wk->li->list[x], newname);
704 if (!mv.overwrite) {
705 if (existed && wk->li->type != IDM_RENAME && dontask) {
706 if (!overold && !overnew)
707 break;
708 if (!overold && !isnewer)
709 break;
710 if (!overnew && isnewer)
711 break;
712 }
713 }
714 }
715 if (!strcmp(wk->li->list[x], newname) ||
716 (wk->li->type == IDM_COPY &&
717 !stricmp(wk->li->list[x], newname)))
718 break;
719 sprintf(message,
720 " %s \"%s\" %s\"%s\"%s",
721 moving,
722 wk->li->list[x],
723 GetPString(IDS_TOTEXT),
724 newname,
725 (usedtarget) ? GetPString(IDS_TOTARGETTEXT) :
726 NullStr);
727 AddNote(message);
728 if (plen) {
729 /* make directory/ies, if required */
730
731 CHAR dirpart[CCHMAXPATH];
732
733 strcpy(dirpart, newname);
734 p = strrchr(dirpart, '\\');
735 if (p) {
736 *p = 0;
737 if (p > dirpart + 3)
738 MassMkdir((hwndMain) ? hwndMain : wk->hwndCnr,
739 dirpart);
740 }
741 }
742 if (fRealIdle)
743 priority_idle();
744 rc = docopyf(type, wk->li->list[x], "%s", newname);
745 priority_normal();
746 if (rc) {
747 if ((rc == ERROR_DISK_FULL ||
748 rc == ERROR_HANDLE_DISK_FULL) &&
749 isalpha(*newname) &&
750 (driveflags[toupper(*newname) - 'A'] &
751 DRIVE_REMOVABLE)
752 && !(driveflags[toupper(*newname) - 'A'] &
753 DRIVE_NOTWRITEABLE)
754 && toupper(*newname) != toupper(*wk->li->list[x])
755 && !DosQueryPathInfo(wk->li->list[x], FIL_QUERYEASIZE,
756 &fs4, sizeof(fs4))
757 && !(fs4.attrFile & FILE_DIRECTORY)) {
758
759 FSALLOCATE fsa;
760 ULONG clFreeBytes;
761 CHAR *ptr;
762 INT cntr;
763
764 Notify(GetPString(IDS_FITTINGTEXT));
765 DosError(FERR_DISABLEHARDERR);
766 if (!DosQueryFSInfo(toupper(*newname) - '@',
767 FSIL_ALLOC,
768 &fsa, sizeof(FSALLOCATE))) {
769 // Assume <2GB since file did not fit
770 clFreeBytes = fsa.cUnitAvail * fsa.cSectorUnit *
771 fsa.cbSector;
772 if (clFreeBytes) {
773 // Find item that will fit in available space
774 for (cntr = x + 1; wk->li->list[cntr]; cntr++) {
775 DosError(FERR_DISABLEHARDERR);
776 if (!DosQueryPathInfo(wk->li->list[cntr],
777 FIL_QUERYEASIZE,
778 &fs4,
779 sizeof(fs4)) &&
780 !(fs4.attrFile & FILE_DIRECTORY) &&
781 // fixme to use CBLIST_TO_EASIZE?
782 fs4.cbFile + fs4.cbList <= clFreeBytes) {
783 // Swap with failing item
784 ptr = wk->li->list[x];
785 wk->li->list[x] = wk->li->list[cntr];
786 wk->li->list[cntr] = ptr;
787 goto Retry;
788 }
789 }
790 Notify(GetPString(IDS_COULDNTFITTEXT));
791 }
792 }
793 rc = saymsg(MB_ABORTRETRYIGNORE | MB_ICONEXCLAMATION,
794 wk->hwndFrame,
795 GetPString(IDS_DISKFULLTEXT),
796 "%s", GetPString(IDS_ANOTHERDISKTEXT));
797 if (rc == MBID_RETRY)
798 goto Retry;
799 if (rc == MBID_ABORT)
800 goto Abort;
801 }
802 else {
803 if (LogFileHandle)
804 fprintf(LogFileHandle,
805 GetPString(IDS_LOGTOFAILEDTEXT),
806 move, wk->li->list[x], newname, rc);
807 rc = Dos_Error(MB_ENTERCANCEL,
808 rc,
809 wk->hwndFrame,
810 pszSrcFile,
811 __LINE__,
812 "%s %s \"%s\" %s\"%s\" %s.",
813 move,
814 GetPString(IDS_OFTEXT),
815 wk->li->list[x],
816 GetPString(IDS_TOTEXT),
817 newname, GetPString(IDS_FAILEDTEXT));
818 if (rc == MBID_CANCEL)
819 goto Abort;
820 }
821 }
822 else {
823 if (LogFileHandle)
824 fprintf(LogFileHandle,
825 "%s \"%s\" %s\"%s\"\n",
826 moved,
827 wk->li->list[x],
828 GetPString(IDS_TOTEXT), newname);
829 if (fSyncUpdates ||
830 AddToList(wk->li->list[x],
831 &files, &numfiles, &numalloc))
832 Broadcast(hab2,
833 wk->hwndCnr,
834 UM_UPDATERECORD,
835 MPFROMP(wk->li->list[x]), MPVOID);
836 if (fSyncUpdates ||
837 AddToList(newname, &files, &numfiles, &numalloc))
838 Broadcast(hab2,
839 wk->hwndCnr,
840 UM_UPDATERECORD, MPFROMP(newname), MPVOID);
841 }
842 }
843 break;
844
845 case IDM_COMPARE:
846 if ((!IsFile(wk->li->targetpath) ||
847 IsRoot(wk->li->targetpath)) &&
848 (!IsFile(wk->li->list[x]) || IsRoot(wk->li->list[x]))) {
849 if (!*dircompare && WinIsWindow(hab2, wk->hwndCnr))
850 WinSendMsg(wk->hwndCnr,
851 UM_COMPARE,
852 MPFROMP(wk->li->targetpath),
853 MPFROMP(wk->li->list[x]));
854 else {
855 CHAR d1[] = "\"";
856 CHAR d2[] = "\"";
857
858 if (!needs_quoting(wk->li->targetpath))
859 *d1 = 0;
860 if (!needs_quoting(wk->li->list[x]))
861 *d2 = 0;
862 runemf2(SEPARATE,
863 HWND_DESKTOP,
864 NULL,
865 NULL,
866 "%s %s%s%s %s%s%s",
867 dircompare,
868 d1,
869 wk->li->targetpath, d1, d2, wk->li->list[x], d2);
870 }
871 }
872 else if (*compare) {
873 CHAR *fakelist[3];
874
875 fakelist[0] = wk->li->list[x];
876 fakelist[1] = wk->li->targetpath;
877 fakelist[2] = NULL;
878 ExecOnList(wk->hwndFrame,
879 compare,
880 WINDOWED | SEPARATEKEEP, NULL, fakelist, NULL);
881 }
882 else {
883 FCOMPARE fc;
884
885 memset(&fc, 0, sizeof(fc));
886 fc.size = sizeof(fc);
887 fc.hwndParent = wk->hwndParent;
888 strcpy(fc.file1, wk->li->list[x]);
889 strcpy(fc.file2, wk->li->targetpath);
890 if (WinDlgBox(HWND_DESKTOP,
891 wk->hwndFrame,
892 CFileDlgProc,
893 FM3ModHandle, FCMP_FRAME, (PVOID) & fc))
894 goto Abort;
895 }
896 break;
897 } // switch
898 DosSleep(0L);
899 } // for list
900
901 switch (wk->li->type) {
902 case IDM_MOVE:
903 case IDM_COPY:
904 case IDM_WPSMOVE:
905 case IDM_WPSCOPY:
906 case IDM_RENAME:
907 sprintf(message,
908 GetPString(IDS_OPSCOMPLETETEXT),
909 (wk->li->type == IDM_MOVE) ?
910 GetPString(IDS_MOVETEXT) :
911 (wk->li->type == IDM_COPY) ?
912 GetPString(IDS_COPYTEXT) :
913 (wk->li->type == IDM_WPSMOVE) ?
914 GetPString(IDS_WPSMOVETEXT) :
915 (wk->li->type == IDM_WPSCOPY) ?
916 GetPString(IDS_WPSCOPYTEXT) :
917 GetPString(IDS_RENAMETEXT),
918 &"s"[x == 1],
919 (wk->li->type == IDM_MOVE ||
920 wk->li->type == IDM_COPY ||
921 wk->li->type == IDM_WPSMOVE ||
922 wk->li->type == IDM_WPSCOPY) ?
923 GetPString(IDS_TOTEXT) :
924 NullStr,
925 (wk->li->type == IDM_MOVE ||
926 wk->li->type == IDM_COPY ||
927 wk->li->type == IDM_WPSMOVE ||
928 wk->li->type == IDM_WPSCOPY) ?
929 wk->li->targetpath :
930 NullStr,
931 (x != 1) ?
932 GetPString(IDS_ARETEXT) : GetPString(IDS_ISTEXT));
933 Notify(message);
934 if (toupper(*wk->li->targetpath) < 'C')
935 DosBeep(1000, 25); // Wake up user
936 DosSleep(33L);
937 if (wk->li->type == IDM_WPSMOVE || wk->li->type == IDM_WPSCOPY)
938 DosSleep(96L);
939 break;
940 default:
941 break;
942 }
943 }
944
945 Abort:
946
947 if (files) {
948 Broadcast(hab2,
949 wk->hwndCnr,
950 UM_UPDATERECORDLIST, MPFROMP(files), MPVOID);
951 FreeList(files);
952 }
953
954 if (WinIsWindow(hab2, wk->hwndCnr))
955 PostMsg(wk->hwndCnr, UM_RESCAN, MPVOID, MPVOID);
956
957 WinDestroyMsgQueue(hmq2);
958 }
959 DecrThreadUsage();
960 WinTerminate(hab2);
961 }
962 }
963
964 if (wk->li)
965 FreeListInfo(wk->li);
966 free(wk);
967 DosPostEventSem(CompactSem);
968 }
969}
970
971VOID MassAction(VOID * args)
972{
973 WORKER *wk = (WORKER *) args;
974 HAB hab2;
975 HMQ hmq2;
976 CHAR **files = NULL;
977 register CHAR *p, *pp;
978 INT numfiles = 0, numalloc = 0;
979
980 if (wk) {
981 if (wk->li && wk->li->list && wk->li->list[0]) {
982 hab2 = WinInitialize(0);
983 if (hab2) {
984 hmq2 = WinCreateMsgQueue(hab2, 0);
985 if (hmq2) {
986 WinCancelShutdown(hmq2, TRUE);
987 IncrThreadUsage();
988 DosError(FERR_DISABLEHARDERR);
989 if (IsRoot(wk->li->list[0]) || !IsFile(wk->li->list[0])) {
990 if (wk->li->type == IDM_VIEW)
991 wk->li->type = IDM_INFO;
992 if (wk->li->type == IDM_EDIT)
993 wk->li->type = IDM_EAS;
994 }
995 switch (wk->li->type) {
996 case IDM_INFO:
997 if (WinDlgBox(HWND_DESKTOP,
998 wk->hwndFrame,
999 FileInfoProc,
1000 FM3ModHandle, FLE_FRAME, (PVOID) wk->li->list) != 2)
1001 break;
1002 /* else intentional fallthru */
1003 case IDM_UPDATE:
1004 Broadcast(hab2,
1005 wk->hwndCnr,
1006 UM_UPDATERECORDLIST, MPFROMP(wk->li->list), MPVOID);
1007 break;
1008
1009 case IDM_EAS:
1010 if (WinDlgBox(HWND_DESKTOP,
1011 wk->hwndFrame,
1012 DisplayEAsProc,
1013 FM3ModHandle, EA_FRAME, (PVOID) wk->li->list))
1014 Broadcast(hab2,
1015 wk->hwndCnr,
1016 UM_UPDATERECORDLIST, MPFROMP(wk->li->list), MPVOID);
1017 break;
1018
1019 case IDM_DOITYOURSELF:
1020 ExecOnList(wk->hwndFrame,
1021 "%a",
1022 WINDOWED | SEPARATE | PROMPT,
1023 NULL, wk->li->list, GetPString(IDS_DOITYOURSELFTEXT));
1024 break;
1025
1026 case IDM_MCIPLAY:
1027 {
1028 register INT x;
1029 register ULONG total = strlen("FM2PLAY.EXE ");
1030
1031 if (fAddUtils)
1032 total += strlen("UTILS\\");
1033 for (x = 0; wk->li->list[x]; x++)
1034 total += (strlen(wk->li->list[x]) + 1 +
1035 (needs_quoting(wk->li->list[x]) * 2));
1036 if (total > 1000) {
1037
1038 FILE *fp;
1039
1040 fp = xfopen("$FM2PLAY.$$$", "w", pszSrcFile, __LINE__);
1041 if (fp) {
1042 fprintf(fp, "%s", ";FM/2-built FM2Play listfile\n");
1043 for (x = 0; wk->li->list[x]; x++)
1044 fprintf(fp, "%s\n", wk->li->list[x]);
1045 fprintf(fp, ";end\n");
1046 fclose(fp);
1047 runemf2(SEPARATE | WINDOWED,
1048 HWND_DESKTOP,
1049 NULL,
1050 NULL,
1051 "%sFM2PLAY.EXE /#$FM2PLAY.$$$",
1052 (fAddUtils) ? "UTILS\\" : NullStr);
1053 break;
1054 }
1055 }
1056 }
1057 /* intentional fallthru */
1058 case IDM_FAKEEXTRACT:
1059 case IDM_FAKEEXTRACTM:
1060 if (wk->li->type == IDM_MCIPLAY ||
1061 (*wk->li->arcname && wk->li->info &&
1062 wk->li->info->extract && *wk->li->targetpath)) {
1063
1064 CHAR szBuffer[1025];
1065 register INT x;
1066
1067 if (wk->li->type == IDM_FAKEEXTRACT ||
1068 wk->li->type == IDM_FAKEEXTRACTM) {
1069 strcpy(szBuffer,
1070 (wk->li->info->exwdirs) ?
1071 wk->li->info->exwdirs : wk->li->info->extract);
1072 strcat(szBuffer, " ");
1073 if (needs_quoting(wk->li->arcname))
1074 strcat(szBuffer, "\"");
1075 strcat(szBuffer, wk->li->arcname);
1076 if (needs_quoting(wk->li->arcname))
1077 strcat(szBuffer, "\"");
1078 }
1079 else {
1080 if (fAddUtils)
1081 strcpy(szBuffer, "UTILS\\FM2PLAY.EXE");
1082 else
1083 strcpy(szBuffer, "FM2PLAY.EXE");
1084 }
1085 p = &szBuffer[strlen(szBuffer)];
1086 strcat(szBuffer, " ");
1087 x = 0;
1088 while (wk->li->list[x]) {
1089 pp = wk->li->list[x];
1090 while (*pp) {
1091 if (*pp == '/')
1092 *pp = '\\';
1093 pp++;
1094 }
1095 if (needs_quoting(wk->li->list[x]))
1096 strcat(szBuffer, "\"");
1097 strcat(szBuffer, wk->li->list[x]);
1098 if (needs_quoting(wk->li->list[x]))
1099 strcat(szBuffer, "\"");
1100 x++;
1101 if (!wk->li->list[x] || strlen(szBuffer) +
1102 strlen(wk->li->list[x]) + 5 > 1024) {
1103 runemf2(SEPARATE | WINDOWED | BACKGROUND | MINIMIZED | WAIT,
1104 HWND_DESKTOP,
1105 ((wk->li->type == IDM_FAKEEXTRACT ||
1106 wk->li->type == IDM_FAKEEXTRACTM) ?
1107 wk->li->targetpath : NULL), NULL, "%s", szBuffer);
1108 DosSleep(1L);
1109 *p = 0;
1110 }
1111 strcat(szBuffer, " ");
1112 }
1113 if (wk->li->type == IDM_MCIPLAY)
1114 break;
1115 strcpy(szBuffer, wk->li->targetpath);
1116 if (wk->li->targetpath[strlen(wk->li->targetpath) - 1] != '\\')
1117 strcat(szBuffer, "\\");
1118 p = szBuffer + strlen(szBuffer);
1119 for (x = 0; wk->li->list[x]; x++) {
1120 strcpy(p, wk->li->list[x]);
1121 free(wk->li->list[x]);
1122 wk->li->list[x] = xstrdup(szBuffer, pszSrcFile, __LINE__);
1123 }
1124 if (wk->li->list[0])
1125 Broadcast(hab2,
1126 wk->hwndCnr,
1127 UM_UPDATERECORDLIST, MPFROMP(wk->li->list), MPVOID);
1128 }
1129 break;
1130
1131 case IDM_SETICON:
1132 if (*wk->li->targetpath) {
1133
1134 ICONINFO ici;
1135
1136 memset(&ici, 0, sizeof(ICONINFO));
1137 ici.cb = sizeof(ICONINFO);
1138 ici.fFormat = ICON_FILE;
1139 ici.pszFileName = wk->li->list[0];
1140 if (!WinSetFileIcon((PSZ) wk->li->targetpath,
1141 (PICONINFO) & ici)) {
1142 ici.fFormat = ICON_CLEAR;
1143 WinSetFileIcon((PSZ) wk->li->targetpath, (PICONINFO) & ici);
1144 }
1145 Broadcast(hab2,
1146 wk->hwndCnr,
1147 UM_UPDATERECORD, MPFROMP(wk->li->targetpath), MPVOID);
1148 }
1149 break;
1150
1151 case IDM_APPENDTOCLIP:
1152 case IDM_SAVETOCLIP:
1153 ListToClipboardHab(hab2,
1154 wk->li->list,
1155 (wk->li->type == IDM_APPENDTOCLIP));
1156 break;
1157
1158 case IDM_ARCHIVEM:
1159 case IDM_ARCHIVE:
1160 {
1161 DIRCNRDATA ad;
1162 CHAR szBuffer[1025];
1163 ARC_TYPE *info = NULL;
1164 char *pch;
1165 register INT x;
1166
1167 memset(&ad, 0, sizeof(DIRCNRDATA));
1168 strcpy(ad.arcname, wk->li->targetpath);
1169 if (*wk->li->targetpath && IsFile(wk->li->targetpath) > 0) {
1170 info = find_type(wk->li->targetpath, NULL);
1171 ad.namecanchange = 0;
1172 }
1173 else {
1174 if (*wk->li->targetpath && !IsFile(wk->li->targetpath))
1175 if (wk->li->targetpath[strlen(wk->li->targetpath) - 1] !=
1176 '\\')
1177 strcat(wk->li->targetpath, "\\");
1178 ad.namecanchange = 1;
1179 }
1180 strcpy(ad.arcname, wk->li->targetpath);
1181 if (wk->li->type == IDM_ARCHIVEM)
1182 ad.fmoving = TRUE;
1183 if (!info) {
1184 ad.info = arcsighead; // Hide dups
1185 if (!WinDlgBox(HWND_DESKTOP,
1186 wk->hwndFrame,
1187 SBoxDlgProc,
1188 FM3ModHandle,
1189 ASEL_FRAME, (PVOID) & ad.info) || !ad.info) {
1190 break; /* we blew it */
1191 }
1192 }
1193 else
1194 ad.info = info;
1195 if (!ad.info || (!ad.info->create &&
1196 !ad.info->move &&
1197 !ad.info->createwdirs &&
1198 !ad.info->movewdirs &&
1199 !ad.info->createrecurse))
1200 break;
1201 if (!*wk->li->targetpath && *wk->directory) {
1202 strcpy(ad.arcname, wk->directory);
1203 if (ad.arcname[strlen(ad.arcname) - 1] != '\\')
1204 strcat(ad.arcname, "\\");
1205 }
1206 if (!WinDlgBox(HWND_DESKTOP, wk->hwndFrame, ArchiveDlgProc, FM3ModHandle, ARCH_FRAME, (PVOID) & ad) || !*ad.arcname || !*ad.command) /* we blew it */
1207 break;
1208 // Provide extension so containers work
1209 pch = strrchr(ad.arcname, '\\');
1210 if (pch)
1211 pch = strrchr(pch, '.');
1212 else
1213 pch = strrchr(ad.arcname, '.');
1214 if (!pch && ad.info->ext) {
1215 strcat(ad.arcname, ".");
1216 strcat(ad.arcname, ad.info->ext);
1217 }
1218 /* build the sucker */
1219 strcpy(szBuffer, ad.command);
1220 strcat(szBuffer, " ");
1221 if (needs_quoting(ad.arcname))
1222 strcat(szBuffer, "\"");
1223 strcat(szBuffer, ad.arcname);
1224 if (needs_quoting(ad.arcname))
1225 strcat(szBuffer, "\"");
1226 p = &szBuffer[strlen(szBuffer)];
1227 if (ad.mask.szMask) {
1228 strcat(szBuffer, " ");
1229 strcat(szBuffer, ad.mask.szMask);
1230 }
1231 strcat(szBuffer, " ");
1232 x = 0;
1233 while (wk->li->list[x]) {
1234
1235 FILESTATUS3 fsa;
1236 BOOL spaces;
1237
1238 if (needs_quoting(wk->li->list[x])) {
1239 spaces = TRUE;
1240 strcat(szBuffer, "\"");
1241 }
1242 else
1243 spaces = FALSE;
1244 strcat(szBuffer, wk->li->list[x]);
1245 memset(&fsa, 0, sizeof(FILESTATUS3));
1246 DosError(FERR_DISABLEHARDERR);
1247 DosQueryPathInfo(wk->li->list[x],
1248 FIL_STANDARD,
1249 &fsa, (ULONG) sizeof(FILESTATUS3));
1250 if (fsa.attrFile & FILE_DIRECTORY) {
1251 if (szBuffer[strlen(szBuffer) - 1] != '\\')
1252 strcat(szBuffer, "\\");
1253 strcat(szBuffer, "*");
1254 }
1255 if (spaces)
1256 strcat(szBuffer, "\"");
1257 x++;
1258 if (!wk->li->list[x] ||
1259 strlen(szBuffer) + strlen(wk->li->list[x]) + 5 > 1024) {
1260 runemf2(SEPARATE | WINDOWED |
1261 ((fArcStuffVisible) ? 0 :
1262 (BACKGROUND | MINIMIZED)) |
1263 WAIT, HWND_DESKTOP, NULL, NULL, "%s", szBuffer);
1264 DosSleep(1L);
1265 *p = 0;
1266 }
1267 strcat(szBuffer, " ");
1268 }
1269 Broadcast(hab2,
1270 wk->hwndCnr,
1271 UM_UPDATERECORDLIST, MPFROMP(wk->li->list), MPVOID);
1272 Broadcast(hab2,
1273 wk->hwndCnr,
1274 UM_UPDATERECORD, MPFROMP(ad.arcname), MPVOID);
1275 }
1276 break;
1277
1278 case IDM_VIEW:
1279 if (!TestBinary(wk->li->list[0])) {
1280 wk->li->type = IDM_VIEWTEXT;
1281 goto SkipViewing;
1282 }
1283 else
1284 wk->li->type = IDM_VIEWBINARY;
1285 /* intentional fallthru */
1286 case IDM_VIEWBINARY:
1287 if (*binview) {
1288 ExecOnList((HWND) 0,
1289 binview,
1290 WINDOWED | SEPARATE, NULL, wk->li->list, NULL);
1291 break;
1292 }
1293 /* else intentional fallthru */
1294 case IDM_VIEWTEXT:
1295 SkipViewing:
1296 if (*viewer)
1297 ExecOnList((HWND) 0, viewer,
1298 WINDOWED | SEPARATE |
1299 ((fViewChild) ? CHILD : 0),
1300 NULL, wk->li->list, NULL);
1301 else {
1302
1303 CHAR *temp;
1304 register INT x;
1305 ULONG viewtype;
1306
1307 viewtype = (wk->li->type == IDM_VIEWTEXT) ? 8 :
1308 (wk->li->type == IDM_VIEWBINARY) ? 16 : 0;
1309 for (x = 0; wk->li->list[x]; x++) {
1310 temp = xstrdup(wk->li->list[x], pszSrcFile, __LINE__);
1311 if (temp && WinIsWindow(hab2, wk->hwndCnr)) {
1312 if (!PostMsg(wk->hwndCnr,
1313 UM_LOADFILE,
1314 MPFROMLONG(5L + viewtype), MPFROMP(temp)))
1315 free(temp);
1316 }
1317 DosSleep(1L);
1318 }
1319 }
1320 break;
1321
1322 case IDM_EDIT:
1323 if (!TestBinary(wk->li->list[0])) {
1324 wk->li->type = IDM_EDITTEXT;
1325 goto SkipEditing;
1326 }
1327 else
1328 wk->li->type = IDM_EDITBINARY;
1329 /* intentional fallthru */
1330 case IDM_EDITBINARY:
1331 if (*bined) {
1332 ExecOnList((HWND) 0,
1333 bined,
1334 WINDOWED | SEPARATE, NULL, wk->li->list, NULL);
1335 break;
1336 }
1337 /* else intentional fallthru */
1338 case IDM_EDITTEXT:
1339 SkipEditing:
1340 if (*editor)
1341 ExecOnList((HWND) 0,
1342 editor,
1343 WINDOWED | SEPARATE, NULL, wk->li->list, NULL);
1344 else {
1345
1346 CHAR *temp;
1347 register INT x;
1348 ULONG viewtype;
1349
1350 viewtype = (wk->li->type == IDM_EDITTEXT) ? 8 :
1351 (wk->li->type == IDM_EDITBINARY) ? 16 : 0;
1352 for (x = 0; wk->li->list[x]; x++) {
1353 temp = xstrdup(wk->li->list[x], pszSrcFile, __LINE__);
1354 if (temp && WinIsWindow(hab2, wk->hwndCnr)) {
1355 if (!PostMsg(wk->hwndCnr,
1356 UM_LOADFILE,
1357 MPFROMLONG(4L + viewtype), MPFROMP(temp)))
1358 free(temp);
1359 }
1360 DosSleep(1L);
1361 }
1362 }
1363 break;
1364
1365 case IDM_SHADOW2:
1366 case IDM_OBJECT:
1367 case IDM_SHADOW:
1368 {
1369 CHAR objectpath[CCHMAXPATH];
1370 APIRET rc;
1371
1372 if (!*wk->li->targetpath || IsFile(wk->li->targetpath)) {
1373 GetDesktopName(objectpath, sizeof(objectpath));
1374 rc = WinDlgBox(HWND_DESKTOP,
1375 wk->hwndFrame,
1376 ObjCnrDlgProc,
1377 FM3ModHandle,
1378 OBJCNR_FRAME, MPFROMP(objectpath));
1379 if (rc) {
1380 if (rc > 1)
1381 strcpy(objectpath, "<WP_DESKTOP>");
1382 }
1383 else
1384 break;
1385 }
1386 else
1387 strcpy(objectpath, wk->li->targetpath);
1388 AddNote(GetPString(IDS_MAKINGOBJSTEXT));
1389 MakeShadows(wk->hwndFrame,
1390 wk->li->list,
1391 (wk->li->type == IDM_SHADOW) +
1392 (wk->li->type == IDM_SHADOW2) * 2,
1393 objectpath, NULL);
1394 AddNote(GetPString(IDS_MADEOBJSTEXT));
1395 }
1396 break;
1397
1398 case IDM_PRINT:
1399 if (WinDlgBox(HWND_DESKTOP,
1400 wk->hwndFrame,
1401 PrintDlgProc,
1402 FM3ModHandle, PRN_FRAME, MPFROMP(wk->li))) {
1403 if (wk->li && wk->li->list && wk->li->list[0]) {
1404 strcpy(wk->li->targetpath, printer);
1405 if (_beginthread(PrintListThread, NULL, 65536, (PVOID) wk->li)
1406 == -1)
1407 Runtime_Error(pszSrcFile, __LINE__,
1408 GetPString(IDS_COULDNTSTARTTHREADTEXT));
1409 else
1410 wk->li = NULL; /* prevent LISTINFO li from being freed */
1411 }
1412 }
1413 break;
1414
1415 case IDM_ATTRS:
1416 if (WinDlgBox(HWND_DESKTOP,
1417 wk->hwndFrame,
1418 AttrListDlgProc,
1419 FM3ModHandle, ATR_FRAME, MPFROMP(wk->li))) {
1420 if (wk->li && wk->li->list && wk->li->list[0])
1421 Broadcast(hab2,
1422 wk->hwndCnr,
1423 UM_UPDATERECORDLIST, MPFROMP(wk->li->list), MPVOID);
1424 }
1425 break;
1426
1427 case IDM_PERMDELETE:
1428 case IDM_DELETE:
1429 {
1430 CHECKLIST cl;
1431 INT isdir = 0, sysdir = 0, ro = 0, hs = 0;
1432 register INT x;
1433 FILESTATUS3 fsa;
1434 CHAR prompt[CCHMAXPATH * 3];
1435 APIRET error;
1436
1437 for (x = 0; wk->li->list[x]; x++) {
1438 if (IsRoot(wk->li->list[x])) {
1439 wk->li->list = RemoveFromList(wk->li->list,
1440 wk->li->list[x]);
1441 if (!wk->li->list)
1442 break;
1443 x--;
1444 continue;
1445 }
1446 DosError(FERR_DISABLEHARDERR);
1447 if (DosQueryPathInfo(wk->li->list[x],
1448 FIL_STANDARD, &fsa,
1449 (ULONG) sizeof(FILESTATUS3))) {
1450 wk->li->list = RemoveFromList(wk->li->list,
1451 wk->li->list[x]);
1452 if (!wk->li->list)
1453 break;
1454 x--;
1455 continue;
1456 }
1457 if (fsa.attrFile & FILE_DIRECTORY) {
1458 isdir++;
1459 if (stristr(wk->li->list[x], ":\\OS2\\") ||
1460 !stricmp(wk->li->list[x] + 1, ":\\OS2"))
1461 sysdir++;
1462 }
1463 else {
1464 if (fsa.attrFile & (FILE_HIDDEN | FILE_SYSTEM))
1465 hs++;
1466 if (fsa.attrFile & FILE_READONLY)
1467 ro++;
1468 }
1469 }
1470 if (!wk->li->list)
1471 break;
1472 if (fConfirmDelete || isdir || hs || ro) {
1473 memset(&cl, 0, sizeof(cl));
1474 cl.size = sizeof(cl);
1475 cl.list = wk->li->list;
1476 cl.prompt = prompt;
1477 cl.flags |= CHECK_FILES;
1478 cl.cmd = wk->li->type;
1479 sprintf(prompt,
1480 GetPString(IDS_DELPROMPT1TEXT),
1481 (wk->li->type == IDM_DELETE) ?
1482 NullStr :
1483 GetPString(IDS_PERMANENTLYTEXT),
1484 &"s"[wk->li->list[1] == NULL]);
1485 if (isdir) {
1486 sprintf(&prompt[strlen(prompt)],
1487 GetPString(IDS_DELPROMPT2TEXT),
1488 isdir,
1489 (isdir > 1) ?
1490 GetPString(IDS_ARETEXT) :
1491 GetPString(IDS_ISTEXT),
1492 (isdir == 1) ?
1493 GetPString(IDS_ATEXT) :
1494 NullStr,
1495 (isdir > 1) ?
1496 GetPString(IDS_IESTEXT) : GetPString(IDS_YTEXT));
1497 if (sysdir)
1498 sprintf(&prompt[strlen(prompt)],
1499 GetPString(IDS_DELPROMPT3TEXT),
1500 sysdir,
1501 (sysdir == 1) ?
1502 GetPString(IDS_YTEXT) : GetPString(IDS_IESTEXT));
1503 }
1504 if (ro)
1505 sprintf(&prompt[strlen(prompt)],
1506 GetPString(IDS_DELPROMPT4TEXT),
1507 ro,
1508 &"s"[ro == 1],
1509 (ro > 1) ?
1510 GetPString(IDS_ARETEXT) : GetPString(IDS_ISTEXT));
1511 if (hs)
1512 sprintf(&prompt[strlen(prompt)],
1513 GetPString(IDS_DELPROMPT5TEXT),
1514 hs,
1515 &"s"[hs == 1],
1516 (hs > 1) ?
1517 GetPString(IDS_ARETEXT) : GetPString(IDS_ISTEXT));
1518 if (ro || hs || sysdir)
1519 DosBeep(300, 100); // Wake up user
1520 strcat(prompt, GetPString(IDS_DELPROMPT6TEXT));
1521 error = WinDlgBox(HWND_DESKTOP,
1522 wk->hwndFrame,
1523 CheckListProc,
1524 FM3ModHandle, CHECK_FRAME, MPFROMP(&cl));
1525 if (!error || error == 65535)
1526 break;
1527 wk->li->list = cl.list;
1528 if (!wk->li->list || !wk->li->list[0])
1529 break;
1530 }
1531 for (x = 0; wk->li->list[x]; x++) {
1532 fsa.attrFile = 0;
1533 DosError(FERR_DISABLEHARDERR);
1534 DosQueryPathInfo(wk->li->list[x],
1535 FIL_STANDARD,
1536 &fsa, (ULONG) sizeof(FILESTATUS3));
1537 if (fsa.attrFile & FILE_DIRECTORY) {
1538 sprintf(prompt,
1539 GetPString(IDS_DELETINGTEXT), wk->li->list[x]);
1540 AddNote(prompt);
1541 error = (APIRET) wipeallf("%s%s*",
1542 wk->li->list[x],
1543 (*wk->li->list[x] &&
1544 wk->li->
1545 list[x][strlen(wk->li->list[x]) -
1546 1] !=
1547 '\\') ? "\\" : NullStr);
1548 DosError(FERR_DISABLEHARDERR);
1549 if (!error)
1550 error = DosDeleteDir(wk->li->list[x]);
1551 else
1552 DosDeleteDir(wk->li->list[x]);
1553 }
1554 else {
1555 sprintf(prompt,
1556 GetPString(IDS_DELETINGTEXT), wk->li->list[x]);
1557 AddNote(prompt);
1558 DosError(FERR_DISABLEHARDERR);
1559 if (wk->li->type == IDM_DELETE)
1560 error = DosDelete(wk->li->list[x]);
1561 else
1562 error = DosForceDelete(wk->li->list[x]);
1563 if (error) {
1564 DosError(FERR_DISABLEHARDERR);
1565 make_deleteable(wk->li->list[x]);
1566 if (wk->li->type == IDM_DELETE)
1567 error = DosDelete(wk->li->list[x]);
1568 else
1569 error = DosForceDelete(wk->li->list[x]);
1570 }
1571 }
1572 if (error) {
1573 if (LogFileHandle)
1574 fprintf(LogFileHandle,
1575 GetPString(IDS_DELETEFAILED1TEXT),
1576 wk->li->list[x], error);
1577 if (Dos_Error(MB_ENTERCANCEL,
1578 error,
1579 wk->hwndFrame,
1580 pszSrcFile,
1581 __LINE__,
1582 GetPString(IDS_DELETEFAILED2TEXT),
1583 wk->li->list[x]) == MBID_CANCEL)
1584 break;
1585 }
1586 else {
1587 if (LogFileHandle)
1588 fprintf(LogFileHandle,
1589 GetPString(IDS_DELETEDTEXT), wk->li->list[x]);
1590 sprintf(prompt,
1591 GetPString(IDS_DELETEDTEXT), wk->li->list[x]);
1592 AddNote(prompt);
1593 }
1594 if (fSyncUpdates ||
1595 AddToList(wk->li->list[x], &files, &numfiles, &numalloc))
1596 Broadcast(hab2,
1597 wk->hwndCnr,
1598 UM_UPDATERECORD,
1599 MPFROMP(wk->li->list[x]), MPVOID);
1600 }
1601 }
1602 break;
1603 } // switch
1604 if (files) {
1605 Broadcast(hab2,
1606 wk->hwndCnr,
1607 UM_UPDATERECORDLIST, MPFROMP(files), MPVOID);
1608 FreeList(files);
1609 }
1610 Abort:
1611 if (WinIsWindow(hab2, wk->hwndCnr))
1612 PostMsg(wk->hwndCnr, UM_RESCAN, MPVOID, MPVOID);
1613
1614 WinDestroyMsgQueue(hmq2);
1615 }
1616 DecrThreadUsage();
1617 WinTerminate(hab2);
1618 }
1619 }
1620 if (wk->li)
1621 FreeListInfo(wk->li);
1622 free(wk);
1623 DosPostEventSem(CompactSem);
1624 }
1625}
Note: See TracBrowser for help on using the repository browser.