source: trunk/dll/worker.c@ 773

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

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