source: trunk/dll/worker.c@ 886

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

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