source: trunk/dll/worker.c@ 546

Last change on this file since 546 was 533, checked in by root, 19 years ago

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