source: trunk/dll/worker.c@ 1075

Last change on this file since 1075 was 1075, checked in by Gregg Young, 17 years ago

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