source: trunk/dll/worker.c@ 244

Last change on this file since 244 was 244, checked in by root, 20 years ago

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