source: trunk/dll/worker.c@ 1101

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

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