source: trunk/dll/worker.c@ 194

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

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