source: trunk/dll/worker.c@ 888

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

runemf2 now quotes executable strings if needed (Ticket 180); it also reports where it was called from on errors
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 41.3 KB
Line 
1
2/***********************************************************************
3
4 $Id: worker.c 888 2007-12-22 22:02:11Z 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, pszSrcFile, __LINE__, 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, pszSrcFile, __LINE__,
860 NULL, NULL,
861 "%s %s %s",
862 dircompare,
863 BldQuotedFileName(szQuotedDirName, wk->li->targetpath),
864 BldQuotedFileName(szQuotedFileName, wk->li->list[x]));
865 }
866 }
867 else if (*compare) {
868 CHAR *fakelist[3];
869
870 fakelist[0] = wk->li->list[x];
871 fakelist[1] = wk->li->targetpath;
872 fakelist[2] = NULL;
873 ExecOnList(wk->hwndFrame,
874 compare,
875 WINDOWED | SEPARATEKEEP, NULL, fakelist, NULL,
876 pszSrcFile, __LINE__);
877 }
878 else {
879 FCOMPARE fc;
880
881 memset(&fc, 0, sizeof(fc));
882 fc.size = sizeof(fc);
883 fc.hwndParent = wk->hwndParent;
884 strcpy(fc.file1, wk->li->list[x]);
885 strcpy(fc.file2, wk->li->targetpath);
886 if (WinDlgBox(HWND_DESKTOP,
887 wk->hwndFrame,
888 CFileDlgProc,
889 FM3ModHandle, FCMP_FRAME, (PVOID) & fc))
890 goto Abort;
891 }
892 break;
893 } // switch
894 DosSleep(0);
895 } // for list
896
897 switch (wk->li->type) {
898 case IDM_MOVE:
899 case IDM_COPY:
900 case IDM_WPSMOVE:
901 case IDM_WPSCOPY:
902 case IDM_RENAME:
903 sprintf(message,
904 GetPString(IDS_OPSCOMPLETETEXT),
905 (wk->li->type == IDM_MOVE) ?
906 GetPString(IDS_MOVETEXT) :
907 (wk->li->type == IDM_COPY) ?
908 GetPString(IDS_COPYTEXT) :
909 (wk->li->type == IDM_WPSMOVE) ?
910 GetPString(IDS_WPSMOVETEXT) :
911 (wk->li->type == IDM_WPSCOPY) ?
912 GetPString(IDS_WPSCOPYTEXT) :
913 GetPString(IDS_RENAMETEXT),
914 &"s"[x == 1],
915 (wk->li->type == IDM_MOVE ||
916 wk->li->type == IDM_COPY ||
917 wk->li->type == IDM_WPSMOVE ||
918 wk->li->type == IDM_WPSCOPY) ?
919 GetPString(IDS_TOTEXT) :
920 NullStr,
921 (wk->li->type == IDM_MOVE ||
922 wk->li->type == IDM_COPY ||
923 wk->li->type == IDM_WPSMOVE ||
924 wk->li->type == IDM_WPSCOPY) ?
925 wk->li->targetpath :
926 NullStr,
927 (x != 1) ?
928 GetPString(IDS_ARETEXT) : GetPString(IDS_ISTEXT));
929 Notify(message);
930 if (toupper(*wk->li->targetpath) < 'C')
931 DosBeep(1000, 25); // Wake up user
932 DosSleep(16);//05 Aug 07 GKY 33
933 if (wk->li->type == IDM_WPSMOVE || wk->li->type == IDM_WPSCOPY)
934 DosSleep(48);//05 Aug 07 GKY 96
935 break;
936 default:
937 break;
938 }
939 }
940
941 Abort:
942
943 if (files) {
944 Broadcast(hab2,
945 wk->hwndCnr,
946 UM_UPDATERECORDLIST, MPFROMP(files), MPVOID);
947 FreeList(files);
948 }
949
950 if (WinIsWindow(hab2, wk->hwndCnr))
951 PostMsg(wk->hwndCnr, UM_RESCAN, MPVOID, MPVOID);
952
953 WinDestroyMsgQueue(hmq2);
954 }
955 DecrThreadUsage();
956 WinTerminate(hab2);
957 }
958 }
959
960 if (wk->li)
961 FreeListInfo(wk->li);
962 free(wk);
963 DosPostEventSem(CompactSem);
964 }
965}
966
967VOID MassAction(VOID * args)
968{
969 WORKER *wk = (WORKER *) args;
970 HAB hab2;
971 HMQ hmq2;
972 CHAR **files = NULL;
973 register CHAR *p, *pp;
974 INT numfiles = 0, numalloc = 0;
975
976 if (wk) {
977 if (wk->li && wk->li->list && wk->li->list[0]) {
978 hab2 = WinInitialize(0);
979 if (hab2) {
980 hmq2 = WinCreateMsgQueue(hab2, 0);
981 if (hmq2) {
982 WinCancelShutdown(hmq2, TRUE);
983 IncrThreadUsage();
984 DosError(FERR_DISABLEHARDERR);
985 if (IsRoot(wk->li->list[0]) || !IsFile(wk->li->list[0])) {
986 if (wk->li->type == IDM_VIEW)
987 wk->li->type = IDM_INFO;
988 if (wk->li->type == IDM_EDIT)
989 wk->li->type = IDM_EAS;
990 }
991 switch (wk->li->type) {
992 case IDM_INFO:
993 if (WinDlgBox(HWND_DESKTOP,
994 wk->hwndFrame,
995 FileInfoProc,
996 FM3ModHandle, FLE_FRAME, (PVOID) wk->li->list) != 2)
997 {
998 break;
999 }
1000 /* else intentional fallthru */
1001 case IDM_UPDATE:
1002 Broadcast(hab2,
1003 wk->hwndCnr,
1004 UM_UPDATERECORDLIST, MPFROMP(wk->li->list), MPVOID);
1005 break;
1006
1007 case IDM_EAS:
1008 if (WinDlgBox(HWND_DESKTOP,
1009 wk->hwndFrame,
1010 DisplayEAsProc,
1011 FM3ModHandle, EA_FRAME, (PVOID) wk->li->list))
1012 Broadcast(hab2,
1013 wk->hwndCnr,
1014 UM_UPDATERECORDLIST, MPFROMP(wk->li->list), MPVOID);
1015 break;
1016
1017 case IDM_DOITYOURSELF:
1018 ExecOnList(wk->hwndFrame,
1019 "%a",
1020 WINDOWED | SEPARATE | PROMPT,
1021 NULL, wk->li->list, GetPString(IDS_DOITYOURSELFTEXT),
1022 pszSrcFile, __LINE__);
1023 break;
1024
1025 case IDM_MCIPLAY:
1026 {
1027 register INT x;
1028 register ULONG total;
1029 CHAR fbuf[CCHMAXPATH];
1030
1031 if (DosSearchPath(SEARCH_IGNORENETERRS | SEARCH_ENVIRONMENT |
1032 SEARCH_CUR_DIRECTORY,
1033 "PATH", "FM2PLAY.EXE", fbuf, CCHMAXPATH - 1))
1034 total += strlen("..\\FM2UTILS\\FM2PLAY.EXE ");
1035 else
1036 total = strlen(fbuf);
1037 for (x = 0; wk->li->list[x]; x++)
1038 total += (strlen(wk->li->list[x]) + 1 +
1039 (needs_quoting(wk->li->list[x]) * 2));
1040 if (total > 1000) {
1041
1042 FILE *fp;
1043
1044 fp = xfopen("$FM2PLAY.$$$", "w", pszSrcFile, __LINE__);
1045 if (fp) {
1046 fprintf(fp, "%s", ";FM/2-built FM2Play listfile\n");
1047 for (x = 0; wk->li->list[x]; x++)
1048 fprintf(fp, "%s\n", wk->li->list[x]);
1049 fprintf(fp, ";end\n");
1050 fclose(fp);
1051 RunFM2Util("FM2PLAY.EXE", "/#$FM2PLAY.$$$");
1052 break;
1053 }
1054 }
1055 }
1056 /* intentional fallthru */
1057 case IDM_FAKEEXTRACT:
1058 case IDM_FAKEEXTRACTM:
1059 if (wk->li->type == IDM_MCIPLAY ||
1060 (*wk->li->arcname && wk->li->info &&
1061 wk->li->info->extract && *wk->li->targetpath)) {
1062
1063 CHAR szBuffer[1025];
1064 CHAR fbuf[CCHMAXPATH];
1065 register INT x;
1066
1067 if (wk->li->type == IDM_FAKEEXTRACT ||
1068 wk->li->type == IDM_FAKEEXTRACTM) {
1069 strcpy(szBuffer,
1070 (wk->li->info->exwdirs) ?
1071 wk->li->info->exwdirs : wk->li->info->extract);
1072 strcat(szBuffer, " ");
1073 BldQuotedFileName(szBuffer + strlen(szBuffer), wk->li->arcname);
1074 }
1075 else {
1076 if (DosSearchPath(SEARCH_IGNORENETERRS | SEARCH_ENVIRONMENT |
1077 SEARCH_CUR_DIRECTORY,
1078 "PATH", "FM2PLAY.EXE", fbuf, CCHMAXPATH - 1))
1079 strcpy(szBuffer, "UTILS\\FM2PLAY.EXE");
1080 else
1081 strcpy(szBuffer, "FM2PLAY.EXE");
1082 }
1083 p = &szBuffer[strlen(szBuffer)];
1084 strcat(szBuffer, " ");
1085 x = 0;
1086 while (wk->li->list[x]) {
1087 pp = wk->li->list[x];
1088 while (*pp) {
1089 if (*pp == '/')
1090 *pp = '\\';
1091 pp++;
1092 }
1093 BldQuotedFileName(szBuffer + strlen(szBuffer), wk->li->list[x]);
1094 x++;
1095 if (!wk->li->list[x] || strlen(szBuffer) +
1096 strlen(wk->li->list[x]) + 5 > 1024) {
1097 runemf2(SEPARATE | WINDOWED | BACKGROUND | MINIMIZED | WAIT,
1098 HWND_DESKTOP, pszSrcFile, __LINE__,
1099 (wk->li->type == IDM_FAKEEXTRACT ||
1100 wk->li->type == IDM_FAKEEXTRACTM) ?
1101 wk->li->targetpath : NULL,
1102 NULL,
1103 "%s", szBuffer);
1104 DosSleep(1);
1105 *p = 0;
1106 }
1107 strcat(szBuffer, " ");
1108 }
1109 if (wk->li->type == IDM_MCIPLAY)
1110 break;
1111 strcpy(szBuffer, wk->li->targetpath);
1112 if (wk->li->targetpath[strlen(wk->li->targetpath) - 1] != '\\')
1113 strcat(szBuffer, "\\");
1114 p = szBuffer + strlen(szBuffer);
1115 for (x = 0; wk->li->list[x]; x++) {
1116 strcpy(p, wk->li->list[x]);
1117 free(wk->li->list[x]);
1118 wk->li->list[x] = xstrdup(szBuffer, pszSrcFile, __LINE__);
1119 }
1120 if (wk->li->list[0])
1121 Broadcast(hab2,
1122 wk->hwndCnr,
1123 UM_UPDATERECORDLIST, MPFROMP(wk->li->list), MPVOID);
1124 }
1125 break;
1126
1127 case IDM_SETICON:
1128 if (*wk->li->targetpath) {
1129
1130 ICONINFO ici;
1131
1132 memset(&ici, 0, sizeof(ICONINFO));
1133 ici.cb = sizeof(ICONINFO);
1134 ici.fFormat = ICON_FILE;
1135 ici.pszFileName = wk->li->list[0];
1136 if (!WinSetFileIcon((PSZ) wk->li->targetpath,
1137 (PICONINFO) & ici)) {
1138 ici.fFormat = ICON_CLEAR;
1139 WinSetFileIcon((PSZ) wk->li->targetpath, (PICONINFO) & ici);
1140 }
1141 Broadcast(hab2,
1142 wk->hwndCnr,
1143 UM_UPDATERECORD, MPFROMP(wk->li->targetpath), MPVOID);
1144 }
1145 break;
1146
1147 case IDM_APPENDTOCLIP:
1148 case IDM_SAVETOCLIP:
1149 ListToClipboardHab(hab2,
1150 wk->li->list,
1151 (wk->li->type == IDM_APPENDTOCLIP));
1152 break;
1153
1154 case IDM_ARCHIVEM:
1155 case IDM_ARCHIVE:
1156 {
1157 DIRCNRDATA ad;
1158 CHAR szBuffer[1025];
1159 ARC_TYPE *info = NULL;
1160 char *pch;
1161 register INT x;
1162
1163 memset(&ad, 0, sizeof(DIRCNRDATA));
1164 strcpy(ad.arcname, wk->li->targetpath);
1165 if (*wk->li->targetpath && IsFile(wk->li->targetpath) > 0) {
1166 info = find_type(wk->li->targetpath, NULL);
1167 ad.namecanchange = 0;
1168 }
1169 else {
1170 if (*wk->li->targetpath && !IsFile(wk->li->targetpath))
1171 if (wk->li->targetpath[strlen(wk->li->targetpath) - 1] !=
1172 '\\')
1173 strcat(wk->li->targetpath, "\\");
1174 ad.namecanchange = 1;
1175 }
1176 strcpy(ad.arcname, wk->li->targetpath);
1177 if (wk->li->type == IDM_ARCHIVEM)
1178 ad.fmoving = TRUE;
1179 if (!info) {
1180 ad.info = arcsighead; // Hide dups
1181 if (!WinDlgBox(HWND_DESKTOP,
1182 wk->hwndFrame,
1183 SBoxDlgProc,
1184 FM3ModHandle,
1185 ASEL_FRAME, (PVOID) & ad.info) || !ad.info) {
1186 break; /* we blew it */
1187 }
1188 }
1189 else
1190 ad.info = info;
1191 if (!ad.info || (!ad.info->create &&
1192 !ad.info->move &&
1193 !ad.info->createwdirs &&
1194 !ad.info->movewdirs &&
1195 !ad.info->createrecurse))
1196 break;
1197 if (!*wk->li->targetpath && *wk->directory) {
1198 strcpy(ad.arcname, wk->directory);
1199 if (ad.arcname[strlen(ad.arcname) - 1] != '\\')
1200 strcat(ad.arcname, "\\");
1201 }
1202 if (!WinDlgBox(HWND_DESKTOP, wk->hwndFrame, ArchiveDlgProc, FM3ModHandle, ARCH_FRAME, (PVOID) & ad) || !*ad.arcname || !*ad.command) /* we blew it */
1203 break;
1204 // Provide extension so containers work
1205 pch = strrchr(ad.arcname, '\\');
1206 if (pch)
1207 pch = strrchr(pch, '.');
1208 else
1209 pch = strrchr(ad.arcname, '.');
1210 if (!pch && ad.info->ext) {
1211 strcat(ad.arcname, ".");
1212 strcat(ad.arcname, ad.info->ext);
1213 }
1214 /* build the sucker */
1215 strcpy(szBuffer, ad.command);
1216 strcat(szBuffer, " ");
1217 BldQuotedFileName(szBuffer + strlen(szBuffer), ad.arcname);
1218 p = &szBuffer[strlen(szBuffer)];
1219 if (ad.mask.szMask) {
1220 strcat(szBuffer, " ");
1221 strcat(szBuffer, ad.mask.szMask);
1222 }
1223 strcat(szBuffer, " ");
1224 x = 0;
1225 while (wk->li->list[x]) {
1226 FILESTATUS3 fsa;
1227 memset(&fsa, 0, sizeof(FILESTATUS3));
1228 DosError(FERR_DISABLEHARDERR);
1229 DosQueryPathInfo(wk->li->list[x],
1230 FIL_STANDARD,
1231 &fsa, (ULONG) sizeof(FILESTATUS3));
1232 if (fsa.attrFile & FILE_DIRECTORY) {
1233 BldQuotedFullPathName(szBuffer + strlen(szBuffer), wk->li->list[x], "*");
1234 }
1235 else
1236 BldQuotedFileName(szBuffer + strlen(szBuffer), wk->li->list[x]);
1237 x++;
1238 if (!wk->li->list[x] ||
1239 strlen(szBuffer) + strlen(wk->li->list[x]) + 5 > 1024) {
1240 runemf2(SEPARATE | WINDOWED | WAIT |
1241 (fArcStuffVisible ? 0 : (BACKGROUND | MINIMIZED)),
1242 HWND_DESKTOP, pszSrcFile, __LINE__, NULL, NULL,
1243 "%s", szBuffer);
1244 DosSleep(1);
1245 *p = 0;
1246 }
1247 strcat(szBuffer, " ");
1248 }
1249 Broadcast(hab2,
1250 wk->hwndCnr,
1251 UM_UPDATERECORDLIST, MPFROMP(wk->li->list), MPVOID);
1252 Broadcast(hab2,
1253 wk->hwndCnr,
1254 UM_UPDATERECORD, MPFROMP(ad.arcname), MPVOID);
1255 }
1256 break;
1257
1258 case IDM_VIEW:
1259 if (!TestBinary(wk->li->list[0])) {
1260 wk->li->type = IDM_VIEWTEXT;
1261 goto SkipViewing;
1262 }
1263 else
1264 wk->li->type = IDM_VIEWBINARY;
1265 /* intentional fallthru */
1266 case IDM_VIEWBINARY:
1267 if (*binview) {
1268 ExecOnList((HWND) 0,
1269 binview,
1270 WINDOWED | SEPARATE, NULL, wk->li->list, NULL,
1271 pszSrcFile, __LINE__);
1272 break;
1273 }
1274 /* else intentional fallthru */
1275 case IDM_VIEWTEXT:
1276 SkipViewing:
1277 if (*viewer)
1278 ExecOnList((HWND) 0, viewer,
1279 WINDOWED | SEPARATE |
1280 ((fViewChild) ? CHILD : 0),
1281 NULL, wk->li->list, NULL,
1282 pszSrcFile, __LINE__);
1283 else {
1284
1285 CHAR *temp;
1286 register INT x;
1287 ULONG viewtype;
1288
1289 viewtype = (wk->li->type == IDM_VIEWTEXT) ? 8 :
1290 (wk->li->type == IDM_VIEWBINARY) ? 16 : 0;
1291 for (x = 0; wk->li->list[x]; x++) {
1292 temp = xstrdup(wk->li->list[x], pszSrcFile, __LINE__);
1293 if (temp && WinIsWindow(hab2, wk->hwndCnr)) {
1294 if (!PostMsg(wk->hwndCnr,
1295 UM_LOADFILE,
1296 MPFROMLONG(5 + viewtype), MPFROMP(temp)))
1297 free(temp);
1298 }
1299 DosSleep(1);
1300 }
1301 }
1302 break;
1303
1304 case IDM_EDIT:
1305 if (!TestBinary(wk->li->list[0])) {
1306 wk->li->type = IDM_EDITTEXT;
1307 goto SkipEditing;
1308 }
1309 else
1310 wk->li->type = IDM_EDITBINARY;
1311 /* intentional fallthru */
1312 case IDM_EDITBINARY:
1313 if (*bined) {
1314 ExecOnList((HWND) 0,
1315 bined,
1316 WINDOWED | SEPARATE, NULL, wk->li->list, NULL,
1317 pszSrcFile, __LINE__);
1318 break;
1319 }
1320 /* else intentional fallthru */
1321 case IDM_EDITTEXT:
1322 SkipEditing:
1323 if (*editor)
1324 ExecOnList((HWND) 0,
1325 editor,
1326 WINDOWED | SEPARATE, NULL, wk->li->list, NULL,
1327 pszSrcFile, __LINE__);
1328 else {
1329
1330 CHAR *temp;
1331 register INT x;
1332 ULONG viewtype;
1333
1334 viewtype = (wk->li->type == IDM_EDITTEXT) ? 8 :
1335 (wk->li->type == IDM_EDITBINARY) ? 16 : 0;
1336 for (x = 0; wk->li->list[x]; x++) {
1337 temp = xstrdup(wk->li->list[x], pszSrcFile, __LINE__);
1338 if (temp && WinIsWindow(hab2, wk->hwndCnr)) {
1339 if (!PostMsg(wk->hwndCnr,
1340 UM_LOADFILE,
1341 MPFROMLONG(4 + viewtype), MPFROMP(temp)))
1342 free(temp);
1343 }
1344 DosSleep(1);
1345 }
1346 }
1347 break;
1348
1349 case IDM_SHADOW2:
1350 case IDM_OBJECT:
1351 case IDM_SHADOW:
1352 {
1353 CHAR objectpath[CCHMAXPATH];
1354 APIRET rc;
1355
1356 if (!*wk->li->targetpath || IsFile(wk->li->targetpath)) {
1357 GetDesktopName(objectpath, sizeof(objectpath));
1358 rc = WinDlgBox(HWND_DESKTOP,
1359 wk->hwndFrame,
1360 ObjCnrDlgProc,
1361 FM3ModHandle,
1362 OBJCNR_FRAME, MPFROMP(objectpath));
1363 if (rc) {
1364 if (rc > 1)
1365 strcpy(objectpath, "<WP_DESKTOP>");
1366 }
1367 else
1368 break;
1369 }
1370 else
1371 strcpy(objectpath, wk->li->targetpath);
1372 AddNote(GetPString(IDS_MAKINGOBJSTEXT));
1373 MakeShadows(wk->hwndFrame,
1374 wk->li->list,
1375 (wk->li->type == IDM_SHADOW) +
1376 (wk->li->type == IDM_SHADOW2) * 2,
1377 objectpath, NULL);
1378 AddNote(GetPString(IDS_MADEOBJSTEXT));
1379 }
1380 break;
1381
1382 case IDM_PRINT:
1383 if (WinDlgBox(HWND_DESKTOP,
1384 wk->hwndFrame,
1385 PrintDlgProc,
1386 FM3ModHandle, PRN_FRAME, MPFROMP(wk->li))) {
1387 if (wk->li && wk->li->list && wk->li->list[0]) {
1388 strcpy(wk->li->targetpath, printer);
1389 if (_beginthread(PrintListThread, NULL, 65536, (PVOID) wk->li)
1390 == -1)
1391 Runtime_Error(pszSrcFile, __LINE__,
1392 GetPString(IDS_COULDNTSTARTTHREADTEXT));
1393 else
1394 wk->li = NULL; /* prevent LISTINFO li from being freed */
1395 }
1396 }
1397 break;
1398
1399 case IDM_ATTRS:
1400 if (WinDlgBox(HWND_DESKTOP,
1401 wk->hwndFrame,
1402 AttrListDlgProc,
1403 FM3ModHandle, ATR_FRAME, MPFROMP(wk->li))) {
1404 if (wk->li && wk->li->list && wk->li->list[0])
1405 Broadcast(hab2,
1406 wk->hwndCnr,
1407 UM_UPDATERECORDLIST, MPFROMP(wk->li->list), MPVOID);
1408 }
1409 break;
1410
1411 case IDM_PERMDELETE:
1412 case IDM_DELETE:
1413 {
1414 CHECKLIST cl;
1415 INT isdir = 0, sysdir = 0, ro = 0, hs = 0;
1416 register INT x;
1417 FILESTATUS3 fsa;
1418 CHAR prompt[CCHMAXPATH * 3];
1419 APIRET error;
1420
1421 for (x = 0; wk->li->list[x]; x++) {
1422 if (IsRoot(wk->li->list[x])) {
1423 wk->li->list = RemoveFromList(wk->li->list,
1424 wk->li->list[x]);
1425 if (!wk->li->list)
1426 break;
1427 x--;
1428 continue;
1429 }
1430 DosError(FERR_DISABLEHARDERR);
1431 if (DosQueryPathInfo(wk->li->list[x],
1432 FIL_STANDARD, &fsa,
1433 (ULONG) sizeof(FILESTATUS3))) {
1434 wk->li->list = RemoveFromList(wk->li->list,
1435 wk->li->list[x]);
1436 if (!wk->li->list)
1437 break;
1438 x--;
1439 continue;
1440 }
1441 if (fsa.attrFile & FILE_DIRECTORY) {
1442 isdir++;
1443 if (stristr(wk->li->list[x], ":\\OS2\\") ||
1444 !stricmp(wk->li->list[x] + 1, ":\\OS2"))
1445 sysdir++;
1446 }
1447 else {
1448 if (fsa.attrFile & (FILE_HIDDEN | FILE_SYSTEM))
1449 hs++;
1450 if (fsa.attrFile & FILE_READONLY)
1451 ro++;
1452 }
1453 }
1454 if (!wk->li->list)
1455 break;
1456 if (fConfirmDelete || isdir || hs || ro) {
1457 memset(&cl, 0, sizeof(cl));
1458 cl.size = sizeof(cl);
1459 cl.list = wk->li->list;
1460 cl.prompt = prompt;
1461 cl.flags |= CHECK_FILES;
1462 cl.cmd = wk->li->type;
1463 sprintf(prompt,
1464 GetPString(IDS_DELPROMPT1TEXT),
1465 (wk->li->type == IDM_DELETE) ?
1466 NullStr :
1467 GetPString(IDS_PERMANENTLYTEXT),
1468 &"s"[wk->li->list[1] == NULL]);
1469 if (isdir) {
1470 sprintf(&prompt[strlen(prompt)],
1471 GetPString(IDS_DELPROMPT2TEXT),
1472 isdir,
1473 (isdir > 1) ?
1474 GetPString(IDS_ARETEXT) :
1475 GetPString(IDS_ISTEXT),
1476 (isdir == 1) ?
1477 GetPString(IDS_ATEXT) :
1478 NullStr,
1479 (isdir > 1) ?
1480 GetPString(IDS_IESTEXT) : GetPString(IDS_YTEXT));
1481 if (sysdir)
1482 sprintf(&prompt[strlen(prompt)],
1483 GetPString(IDS_DELPROMPT3TEXT),
1484 sysdir,
1485 (sysdir == 1) ?
1486 GetPString(IDS_YTEXT) : GetPString(IDS_IESTEXT));
1487 }
1488 if (ro)
1489 sprintf(&prompt[strlen(prompt)],
1490 GetPString(IDS_DELPROMPT4TEXT),
1491 ro,
1492 &"s"[ro == 1],
1493 (ro > 1) ?
1494 GetPString(IDS_ARETEXT) : GetPString(IDS_ISTEXT));
1495 if (hs)
1496 sprintf(&prompt[strlen(prompt)],
1497 GetPString(IDS_DELPROMPT5TEXT),
1498 hs,
1499 &"s"[hs == 1],
1500 (hs > 1) ?
1501 GetPString(IDS_ARETEXT) : GetPString(IDS_ISTEXT));
1502 if (ro || hs || sysdir)
1503 DosBeep(300, 100); // Wake up user
1504 strcat(prompt, GetPString(IDS_DELPROMPT6TEXT));
1505 error = WinDlgBox(HWND_DESKTOP,
1506 wk->hwndFrame,
1507 CheckListProc,
1508 FM3ModHandle, CHECK_FRAME, MPFROMP(&cl));
1509 if (!error || error == 65535)
1510 break;
1511 wk->li->list = cl.list;
1512 if (!wk->li->list || !wk->li->list[0])
1513 break;
1514 }
1515 for (x = 0; wk->li->list[x]; x++) {
1516 fsa.attrFile = 0;
1517 DosError(FERR_DISABLEHARDERR);
1518 DosQueryPathInfo(wk->li->list[x],
1519 FIL_STANDARD,
1520 &fsa, (ULONG) sizeof(FILESTATUS3));
1521 if (fsa.attrFile & FILE_DIRECTORY) {
1522 sprintf(prompt,
1523 GetPString(IDS_DELETINGTEXT), wk->li->list[x]);
1524 AddNote(prompt);
1525 error = (APIRET) wipeallf("%s%s*",
1526 wk->li->list[x],
1527 (*wk->li->list[x] &&
1528 wk->li->
1529 list[x][strlen(wk->li->list[x]) -
1530 1] !=
1531 '\\') ? "\\" : NullStr);
1532 DosError(FERR_DISABLEHARDERR);
1533 if (!error)
1534 error = DosDeleteDir(wk->li->list[x]);
1535 else
1536 DosDeleteDir(wk->li->list[x]);
1537 }
1538 else {
1539 sprintf(prompt,
1540 GetPString(IDS_DELETINGTEXT), wk->li->list[x]);
1541 AddNote(prompt);
1542 DosError(FERR_DISABLEHARDERR);
1543 if (wk->li->type == IDM_DELETE)
1544 error = DosDelete(wk->li->list[x]);
1545 else
1546 error = DosForceDelete(wk->li->list[x]);
1547 if (error) {
1548 DosError(FERR_DISABLEHARDERR);
1549 make_deleteable(wk->li->list[x]);
1550 if (wk->li->type == IDM_DELETE)
1551 error = DosDelete(wk->li->list[x]);
1552 else
1553 error = DosForceDelete(wk->li->list[x]);
1554 }
1555 }
1556 if (error) {
1557 if (LogFileHandle)
1558 fprintf(LogFileHandle,
1559 GetPString(IDS_DELETEFAILED1TEXT),
1560 wk->li->list[x], error);
1561 if (Dos_Error(MB_ENTERCANCEL,
1562 error,
1563 wk->hwndFrame,
1564 pszSrcFile,
1565 __LINE__,
1566 GetPString(IDS_DELETEFAILED2TEXT),
1567 wk->li->list[x]) == MBID_CANCEL)
1568 break;
1569 }
1570 else {
1571 if (LogFileHandle)
1572 fprintf(LogFileHandle,
1573 GetPString(IDS_DELETEDTEXT), wk->li->list[x]);
1574 sprintf(prompt,
1575 GetPString(IDS_DELETEDTEXT), wk->li->list[x]);
1576 AddNote(prompt);
1577 }
1578 if (fSyncUpdates ||
1579 AddToList(wk->li->list[x], &files, &numfiles, &numalloc))
1580 Broadcast(hab2,
1581 wk->hwndCnr,
1582 UM_UPDATERECORD,
1583 MPFROMP(wk->li->list[x]), MPVOID);
1584 }
1585 }
1586 break;
1587 } // switch
1588 if (files) {
1589 Broadcast(hab2,
1590 wk->hwndCnr,
1591 UM_UPDATERECORDLIST, MPFROMP(files), MPVOID);
1592 FreeList(files);
1593 }
1594 if (WinIsWindow(hab2, wk->hwndCnr))
1595 PostMsg(wk->hwndCnr, UM_RESCAN, MPVOID, MPVOID);
1596
1597 WinDestroyMsgQueue(hmq2);
1598 }
1599 DecrThreadUsage();
1600 WinTerminate(hab2);
1601 }
1602 }
1603 if (wk->li)
1604 FreeListInfo(wk->li);
1605 free(wk);
1606 DosPostEventSem(CompactSem);
1607 }
1608}
1609#pragma alloc_text(MASSACTION,MassAction)
1610#pragma alloc_text(ACTION,Action)
1611#pragma alloc_text(UNDO,FreeUndo,Undo)
Note: See TracBrowser for help on using the repository browser.