source: trunk/dll/worker.c@ 443

Last change on this file since 443 was 396, checked in by root, 19 years ago

Clean
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 43.9 KB
Line 
1
2/***********************************************************************
3
4 $Id: worker.c 396 2006-07-28 18:42:35Z 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
19***********************************************************************/
20
21#define INCL_DOS
22#define INCL_WIN
23#define INCL_DOSERRORS
24#include <os2.h>
25
26#include <stdarg.h>
27#include <stdio.h>
28#include <stdlib.h>
29#include <string.h>
30#include <ctype.h>
31#include <stddef.h>
32#include <share.h>
33#include <time.h>
34
35#include "fm3dll.h"
36#include "fm3dlg.h"
37#include "fm3str.h"
38
39#pragma data_seg(DATA2)
40
41static PSZ pszSrcFile = __FILE__;
42
43#pragma alloc_text(MASSACTION,MassAction)
44#pragma alloc_text(ACTION,Action)
45#pragma alloc_text(UNDO,FreeUndo,Undo)
46
47BOOL APIENTRY WinQueryObjectPath(HOBJECT hobject,
48 PSZ pszPathName,
49 ULONG ulSize);
50
51#ifdef UNDO
52
53static VOID LINFO undo;
54
55VOID FreeUndo(VOID)
56{
57 if (undo -> list)
58 FreeList(undo -> list);
59 memset(&undo, 0, sizeof(undo));
60}
61
62VOID Undo(HWND hwndCnr, HWND hwndFrame, HWND hwndClient, HWND hwndParent)
63{
64 LISTINFO *li;
65 WORKER *wk;
66
67 if (undo -> type &&
68 undo -> list &&
69 undo -> list[0])
70 {
71 switch (undo -> type)
72 {
73 case IDM_MOVE
74 case IDM_COPY:
75 case IDM_EXTRACT:
76 {
77 li = xmallocz(sizeof(LISTINFO),pszSrcFile,__LINE__);
78 if (li) {
79 wk = xmallocz(sizeof(WORKER),pszSrcFile,__LINE__);
80 if (wk) {
81 wk -> size = sizeof(WORKER);
82 wk -> hwndCnr = hwndCnr;
83 wk -> hwndParent = hwndParent;
84 wk -> hwndFrame = hwndFrame;
85 wk -> hwndClient = hwndClient;
86 wk -> li = li;
87 *wk -> li = *undo;
88 switch (undo -> type)
89 {
90 case IDM_COPY:
91 case IDM_EXTRACT:
92 li -> type = IDM_PERMDELETE;
93 break;
94 }
95 if (_beginthread(MassAction,NULL,122880,(PVOID) wk) == -1)
96 {
97 Runtime_Error(pszSrcFile, __LINE__, GetPString(IDS_COULDNTSTARTTHREADTEXT));
98 FreeListInfo(wk -> li);
99 free(wk);
100 }
101 }
102 else
103 FreeListInfo(li);
104 }
105 }
106 break;
107 }
108 }
109 FreeUndo();
110}
111
112#endif // defined(UNDO)
113
114VOID Action(VOID * args)
115{
116 WORKER *wk = (WORKER *) args;
117 HAB hab2;
118 HMQ hmq2;
119 CHAR **files = NULL;
120 INT numfiles = 0, numalloc = 0, plen = 0;
121 register CHAR *p, *pp;
122
123 if (wk)
124 {
125 if (wk -> li &&
126 wk -> li -> list &&
127 wk -> li -> list[0])
128 {
129 hab2 = WinInitialize(0);
130 if (hab2)
131 {
132 hmq2 = WinCreateMsgQueue(hab2, 0);
133 if (hmq2)
134 {
135
136 CHAR message[(CCHMAXPATH * 2) + 80], wildname[CCHMAXPATH];
137 register INT x;
138 BOOL dontask = FALSE, wildcarding = FALSE, overold = FALSE, overnew = FALSE,
139 usedtarget;
140
141 WinCancelShutdown(hmq2, TRUE);
142 if (hwndMain)
143 WinSendMsg(hwndMain,
144 UM_THREADUSE,
145 MPFROMLONG(1L),
146 MPVOID);
147 *wildname = 0;
148 switch (wk -> li -> type)
149 {
150 case IDM_MERGE:
151 if (wk -> li -> type == IDM_MERGE)
152 {
153 if (TestBinary(wk -> li -> list[0]))
154 wk -> li -> type = IDM_MERGEBINARY;
155 else
156 wk -> li -> type = IDM_MERGETEXT;
157 }
158 strcpy(wk -> li -> targetpath, wk -> li -> list[0]);
159 p = strrchr(wk -> li -> targetpath, '\\');
160 if (p)
161 {
162 p++;
163 *p = 0;
164 }
165 else
166 strcat(wk -> li -> targetpath, "\\");
167 sprintf(wk -> li -> targetpath + strlen(wk -> li -> targetpath),
168 "MERGE.%03x",
169 (clock() & 4095L));
170 if (!WinDlgBox(HWND_DESKTOP,
171 wk -> hwndFrame,
172 MergeDlgProc,
173 FM3ModHandle,
174 MRG_FRAME,
175 (PVOID) wk))
176 goto Abort;
177 if (!wk -> li -> type ||
178 !*wk -> li -> targetpath ||
179 !wk -> li -> list ||
180 !wk -> li -> list[0])
181 goto Abort;
182 if (IsFile(wk -> li -> targetpath) != 1 &&
183 !wk -> li -> list[1])
184 {
185 saymsg(MB_CANCEL | MB_ICONEXCLAMATION,
186 wk -> hwndFrame,
187 GetPString(IDS_AHEMTEXT),
188 GetPString(IDS_SILLYMERGETEXT));
189 goto Abort;
190 }
191 break;
192 case IDM_WILDMOVE:
193 wildcarding = TRUE;
194 wk -> li -> type = IDM_MOVE;
195 break;
196 case IDM_WILDRENAME:
197 wildcarding = TRUE;
198 wk -> li -> type = IDM_RENAME;
199 break;
200 case IDM_WILDCOPY:
201 wildcarding = TRUE;
202 wk -> li -> type = IDM_COPY;
203 break;
204 case IDM_MOVEPRESERVE:
205 {
206 CHAR preserve[CCHMAXPATH], *end;
207
208 wk -> li -> type = IDM_MOVE;
209 strcpy(preserve, wk -> li -> list[0] + 2);
210 end = strrchr(preserve, '\\');
211 if (end)
212 {
213 end++;
214 for (x = 1; wk -> li -> list[x]; x++)
215 {
216 p = preserve;
217 pp = wk -> li -> list[x] + 2;
218 while (p < end && toupper(*p) == toupper(*pp))
219 {
220 p++;
221 pp++;
222 }
223 if (*p == '\\')
224 p++;
225 if (p < end)
226 end = p;
227 }
228 *end = 0;
229 }
230 else
231 *preserve = 0;
232 plen = strlen(preserve);
233 if (plen)
234 plen += 2;
235 }
236 break;
237 case IDM_COPYPRESERVE:
238 {
239 CHAR preserve[CCHMAXPATH], *end;
240
241 wk -> li -> type = IDM_COPY;
242 strcpy(preserve, wk -> li -> list[0] + 2);
243 end = strrchr(preserve, '\\');
244 if (end)
245 {
246 end++;
247 for (x = 1; wk -> li -> list[x]; x++)
248 {
249 p = preserve;
250 pp = wk -> li -> list[x] + 2;
251 while (p < end && toupper(*p) == toupper(*pp))
252 {
253 p++;
254 pp++;
255 }
256 if (*p == '\\')
257 p++;
258 if (p < end)
259 end = p;
260 }
261 *end = 0;
262 }
263 else
264 *preserve = 0;
265 plen = strlen(preserve);
266 if (plen)
267 plen += 2;
268 }
269 break;
270 }
271 if (wk -> li && wk -> li -> list && wk -> li -> list[0])
272 {
273 for (x = 0; wk -> li -> list[x]; x++)
274 {
275 switch (wk -> li -> type)
276 {
277 case IDM_COLLECTFROMFILE:
278 if (Collector)
279 {
280
281 CHAR *temp = xstrdup(wk -> li -> list[x],pszSrcFile,__LINE__);
282
283 if (temp)
284 {
285 if (!PostMsg(Collector,
286 UM_COLLECTFROMFILE,
287 MPFROMP(temp),
288 MPVOID))
289 free(temp);
290 }
291 }
292 break;
293
294 case IDM_MERGEBINARY:
295 case IDM_MERGETEXT:
296 case IDM_MERGEBINARYAPPEND:
297 case IDM_MERGETEXTAPPEND:
298 {
299 FILE *in, *out;
300 CHAR *moder, *modew;
301 int c;
302
303 switch (wk -> li -> type)
304 {
305 case IDM_MERGEBINARY:
306 moder = "rb";
307 modew = "wb";
308 break;
309 case IDM_MERGEBINARYAPPEND:
310 moder = "rb";
311 modew = "a+b";
312 break;
313 case IDM_MERGETEXTAPPEND:
314 moder = "r";
315 modew = "a+";
316 break;
317 default:
318 moder = "r";
319 modew = "w";
320 break;
321 }
322 in = _fsopen(wk -> li -> list[x], moder, SH_DENYWR);
323 if (!in)
324 {
325 if (saymsg(MB_ENTERCANCEL,
326 HWND_DESKTOP,
327 GetPString(IDS_MERGEERRORTEXT),
328 GetPString(IDS_CANTOPENINPUTTEXT),
329 wk -> li -> list[x]) == MBID_CANCEL)
330 goto Abort;
331 }
332 else {
333 out = _fsopen(wk -> li -> targetpath, modew, SH_DENYWR);
334 if (out)
335 {
336 fseek(out, 0L, SEEK_END);
337 switch (wk -> li -> type)
338 {
339 case IDM_MERGEBINARY:
340 wk -> li -> type = IDM_MERGEBINARYAPPEND;
341 break;
342 default:
343 wk -> li -> type = IDM_MERGETEXTAPPEND;
344 break;
345 }
346 sprintf(message,
347 GetPString(IDS_MERGINGTEXT),
348 wk -> li -> list[x],
349 wk -> li -> targetpath);
350 AddNote(message);
351 while ((c = fgetc(in)) != EOF)
352 fputc(c, out);
353 fclose(out);
354 sprintf(message,
355 GetPString(IDS_MERGECOMPLETETEXT),
356 wk -> li -> list[x],
357 wk -> li -> targetpath);
358 AddNote(message);
359 }
360 else
361 {
362 saymsg(MB_CANCEL,
363 HWND_DESKTOP,
364 GetPString(IDS_MERGEERRORTEXT),
365 GetPString(IDS_CANTOPENOUTPUTTEXT),
366 wk -> li -> targetpath);
367 fclose(in);
368 goto Abort;
369 }
370 fclose(in);
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; // Say calling for editing - fixme to know why?
416
417 if (WinDlgBox(HWND_DESKTOP,
418 wk -> hwndFrame,
419 SBoxDlgProc,
420 FM3ModHandle,
421 ASEL_FRAME,
422 (PVOID)&info) &&
423 info)
424 {
425 WinSendMsg(wk -> hwndCnr,
426 UM_OPENWINDOWFORME,
427 MPFROMP(wk -> li -> list[x]),
428 MPFROMP(info));
429 }
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 pszSrcFile,
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); // Wake up user
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 = xfopen("$FM2PLAY.$$$", "w",pszSrcFile,__LINE__);
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] = xstrdup(szBuffer,pszSrcFile,__LINE__);
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; // Hide dups
1412 if (!WinDlgBox(HWND_DESKTOP,
1413 wk -> hwndFrame,
1414 SBoxDlgProc,
1415 FM3ModHandle,
1416 ASEL_FRAME,
1417 (PVOID)&ad.info) ||
1418 !ad.info)
1419 {
1420 break; /* we blew it */
1421 }
1422 }
1423 else
1424 ad.info = info;
1425 if (!ad.info || (!ad.info -> create &&
1426 !ad.info -> move &&
1427 !ad.info -> createwdirs &&
1428 !ad.info -> movewdirs &&
1429 !ad.info -> createrecurse))
1430 break;
1431 if (!*wk -> li -> targetpath && *wk -> directory)
1432 {
1433 strcpy(ad.arcname, wk -> directory);
1434 if (ad.arcname[strlen(ad.arcname) - 1] != '\\')
1435 strcat(ad.arcname, "\\");
1436 }
1437 if (!WinDlgBox(HWND_DESKTOP,
1438 wk -> hwndFrame,
1439 ArchiveDlgProc,
1440 FM3ModHandle,
1441 ARCH_FRAME,
1442 (PVOID) & ad) ||
1443 !*ad.arcname ||
1444 !*ad.command) /* we blew it */
1445 break;
1446 // Provide extension so containers work
1447 pch = strrchr(ad.arcname, '\\');
1448 if (pch)
1449 pch = strrchr(pch, '.');
1450 else
1451 pch = strrchr(ad.arcname, '.');
1452 if (!pch && ad.info -> ext)
1453 {
1454 strcat(ad.arcname, ".");
1455 strcat(ad.arcname, ad.info -> ext);
1456 }
1457 /* build the sucker */
1458 strcpy(szBuffer, ad.command);
1459 strcat(szBuffer, " ");
1460 if (needs_quoting(ad.arcname))
1461 strcat(szBuffer, "\"");
1462 strcat(szBuffer, ad.arcname);
1463 if (needs_quoting(ad.arcname))
1464 strcat(szBuffer, "\"");
1465 p = &szBuffer[strlen(szBuffer)];
1466 if (ad.mask.szMask)
1467 {
1468 strcat(szBuffer, " ");
1469 strcat(szBuffer, ad.mask.szMask);
1470 }
1471 strcat(szBuffer, " ");
1472 x = 0;
1473 while (wk -> li -> list[x])
1474 {
1475
1476 FILESTATUS3 fsa;
1477 BOOL spaces;
1478
1479 if (needs_quoting(wk -> li -> list[x]))
1480 {
1481 spaces = TRUE;
1482 strcat(szBuffer, "\"");
1483 }
1484 else
1485 spaces = FALSE;
1486 strcat(szBuffer, wk -> li -> list[x]);
1487 memset(&fsa, 0, sizeof(FILESTATUS3));
1488 DosError(FERR_DISABLEHARDERR);
1489 DosQueryPathInfo(wk -> li -> list[x],
1490 FIL_STANDARD,
1491 &fsa,
1492 (ULONG) sizeof(FILESTATUS3));
1493 if (fsa.attrFile & FILE_DIRECTORY)
1494 {
1495 if (szBuffer[strlen(szBuffer) - 1] != '\\')
1496 strcat(szBuffer, "\\");
1497 strcat(szBuffer, "*");
1498 }
1499 if (spaces)
1500 strcat(szBuffer, "\"");
1501 x++;
1502 if (!wk -> li -> list[x] ||
1503 strlen(szBuffer) +
1504 strlen(wk -> li -> list[x]) + 5 > 1024)
1505 {
1506 runemf2(SEPARATE | WINDOWED |
1507 ((fArcStuffVisible) ? 0 :
1508 (BACKGROUND | MINIMIZED)) |
1509 WAIT,
1510 HWND_DESKTOP,
1511 NULL,
1512 NULL,
1513 "%s",
1514 szBuffer);
1515 DosSleep(1L);
1516 *p = 0;
1517 }
1518 strcat(szBuffer, " ");
1519 }
1520 Broadcast(hab2,
1521 wk -> hwndCnr,
1522 UM_UPDATERECORDLIST,
1523 MPFROMP(wk -> li -> list),
1524 MPVOID);
1525 Broadcast(hab2,
1526 wk -> hwndCnr,
1527 UM_UPDATERECORD,
1528 MPFROMP(ad.arcname),
1529 MPVOID);
1530 }
1531 break;
1532
1533 case IDM_VIEW:
1534 if (!TestBinary(wk -> li -> list[0]))
1535 {
1536 wk -> li -> type = IDM_VIEWTEXT;
1537 goto SkipViewing;
1538 }
1539 else
1540 wk -> li -> type = IDM_VIEWBINARY;
1541 /* intentional fallthru */
1542 case IDM_VIEWBINARY:
1543 if (*binview)
1544 {
1545 ExecOnList((HWND)0,
1546 binview,
1547 WINDOWED | SEPARATE,
1548 NULL,
1549 wk -> li -> list,
1550 NULL);
1551 break;
1552 }
1553 /* else intentional fallthru */
1554 case IDM_VIEWTEXT:
1555 SkipViewing:
1556 if (*viewer)
1557 ExecOnList((HWND)0, viewer,
1558 WINDOWED | SEPARATE |
1559 ((fViewChild) ? CHILD : 0),
1560 NULL,
1561 wk -> li -> list,
1562 NULL);
1563 else
1564 {
1565
1566 CHAR *temp;
1567 register INT x;
1568 ULONG viewtype;
1569
1570 viewtype = (wk -> li -> type == IDM_VIEWTEXT) ? 8 :
1571 (wk -> li -> type == IDM_VIEWBINARY) ? 16 : 0;
1572 for (x = 0; wk -> li -> list[x]; x++)
1573 {
1574 temp = xstrdup(wk -> li -> list[x],pszSrcFile,__LINE__);
1575 if (temp && WinIsWindow(hab2, wk -> hwndCnr))
1576 {
1577 if (!PostMsg(wk -> hwndCnr,
1578 UM_LOADFILE,
1579 MPFROMLONG(5L + viewtype),
1580 MPFROMP(temp)))
1581 free(temp);
1582 }
1583 DosSleep(1L);
1584 }
1585 }
1586 break;
1587
1588 case IDM_EDIT:
1589 if (!TestBinary(wk -> li -> list[0]))
1590 {
1591 wk -> li -> type = IDM_EDITTEXT;
1592 goto SkipEditing;
1593 }
1594 else
1595 wk -> li -> type = IDM_EDITBINARY;
1596 /* intentional fallthru */
1597 case IDM_EDITBINARY:
1598 if (*bined)
1599 {
1600 ExecOnList((HWND)0,
1601 bined,
1602 WINDOWED | SEPARATE,
1603 NULL,
1604 wk -> li -> list,
1605 NULL);
1606 break;
1607 }
1608 /* else intentional fallthru */
1609 case IDM_EDITTEXT:
1610 SkipEditing:
1611 if (*editor)
1612 ExecOnList((HWND)0,
1613 editor,
1614 WINDOWED | SEPARATE,
1615 NULL,
1616 wk -> li -> list,
1617 NULL);
1618 else
1619 {
1620
1621 CHAR *temp;
1622 register INT x;
1623 ULONG viewtype;
1624
1625 viewtype = (wk -> li -> type == IDM_EDITTEXT) ? 8 :
1626 (wk -> li -> type == IDM_EDITBINARY) ? 16 : 0;
1627 for (x = 0; wk -> li -> list[x]; x++)
1628 {
1629 temp = xstrdup(wk -> li -> list[x],pszSrcFile,__LINE__);
1630 if (temp && WinIsWindow(hab2, wk -> hwndCnr))
1631 {
1632 if (!PostMsg(wk -> hwndCnr,
1633 UM_LOADFILE,
1634 MPFROMLONG(4L + viewtype),
1635 MPFROMP(temp)))
1636 free(temp);
1637 }
1638 DosSleep(1L);
1639 }
1640 }
1641 break;
1642
1643 case IDM_SHADOW2:
1644 case IDM_OBJECT:
1645 case IDM_SHADOW:
1646 {
1647 CHAR objectpath[CCHMAXPATH];
1648 APIRET rc;
1649
1650 if (!*wk -> li -> targetpath || IsFile(wk -> li -> targetpath))
1651 {
1652 GetDesktopName(objectpath, sizeof(objectpath));
1653 rc = WinDlgBox(HWND_DESKTOP,
1654 wk -> hwndFrame,
1655 ObjCnrDlgProc,
1656 FM3ModHandle,
1657 OBJCNR_FRAME,
1658 MPFROMP(objectpath));
1659 if (rc)
1660 {
1661 if (rc > 1)
1662 strcpy(objectpath, "<WP_DESKTOP>");
1663 }
1664 else
1665 break;
1666 }
1667 else
1668 strcpy(objectpath, wk -> li -> targetpath);
1669 AddNote(GetPString(IDS_MAKINGOBJSTEXT));
1670 MakeShadows(wk -> hwndFrame,
1671 wk -> li -> list,
1672 (wk -> li -> type == IDM_SHADOW) +
1673 (wk -> li -> type == IDM_SHADOW2) * 2,
1674 objectpath,
1675 NULL);
1676 AddNote(GetPString(IDS_MADEOBJSTEXT));
1677 }
1678 break;
1679
1680 case IDM_PRINT:
1681 if (WinDlgBox(HWND_DESKTOP,
1682 wk -> hwndFrame,
1683 PrintDlgProc,
1684 FM3ModHandle,
1685 PRN_FRAME,
1686 MPFROMP(wk -> li)))
1687 {
1688 if (wk -> li && wk -> li -> list && wk -> li -> list[0])
1689 {
1690 strcpy(wk -> li -> targetpath, printer);
1691 if (_beginthread(PrintList,NULL,65536,(PVOID) wk -> li) == -1)
1692 Runtime_Error(pszSrcFile, __LINE__, GetPString(IDS_COULDNTSTARTTHREADTEXT));
1693 else
1694 wk -> li = NULL; /* prevent LISTINFO li from being freed */
1695 }
1696 }
1697 break;
1698
1699 case IDM_ATTRS:
1700 if (WinDlgBox(HWND_DESKTOP,
1701 wk -> hwndFrame,
1702 AttrListDlgProc,
1703 FM3ModHandle,
1704 ATR_FRAME,
1705 MPFROMP(wk -> li)))
1706 {
1707 if (wk -> li && wk -> li -> list && wk -> li -> list[0])
1708 Broadcast(hab2,
1709 wk -> hwndCnr,
1710 UM_UPDATERECORDLIST,
1711 MPFROMP(wk -> li -> list),
1712 MPVOID);
1713 }
1714 break;
1715
1716 case IDM_PERMDELETE:
1717 case IDM_DELETE:
1718 {
1719 CHECKLIST cl;
1720 INT isdir = 0, sysdir = 0, ro = 0, hs = 0;
1721 register INT x;
1722 FILESTATUS3 fsa;
1723 CHAR prompt[CCHMAXPATH * 3];
1724 APIRET error;
1725
1726 for (x = 0; wk -> li -> list[x]; x++)
1727 {
1728 if (IsRoot(wk -> li -> list[x]))
1729 {
1730 wk -> li -> list = RemoveFromList(wk -> li -> list,
1731 wk -> li -> list[x]);
1732 if (!wk -> li -> list)
1733 break;
1734 x--;
1735 continue;
1736 }
1737 DosError(FERR_DISABLEHARDERR);
1738 if (DosQueryPathInfo(wk -> li -> list[x],
1739 FIL_STANDARD, &fsa,
1740 (ULONG) sizeof(FILESTATUS3)))
1741 {
1742 wk -> li -> list = RemoveFromList(wk -> li -> list,
1743 wk -> li -> list[x]);
1744 if (!wk -> li -> list)
1745 break;
1746 x--;
1747 continue;
1748 }
1749 if (fsa.attrFile & FILE_DIRECTORY)
1750 {
1751 isdir++;
1752 if (stristr(wk -> li -> list[x], ":\\OS2\\") ||
1753 !stricmp(wk -> li -> list[x] + 1, ":\\OS2"))
1754 sysdir++;
1755 }
1756 else
1757 {
1758 if (fsa.attrFile & (FILE_HIDDEN | FILE_SYSTEM))
1759 hs++;
1760 if (fsa.attrFile & FILE_READONLY)
1761 ro++;
1762 }
1763 }
1764 if (!wk -> li -> list)
1765 break;
1766 if (fConfirmDelete || isdir || hs || ro)
1767 {
1768 memset(&cl, 0, sizeof(cl));
1769 cl.size = sizeof(cl);
1770 cl.list = wk -> li -> list;
1771 cl.prompt = prompt;
1772 cl.flags |= CHECK_FILES;
1773 cl.cmd = wk -> li -> type;
1774 sprintf(prompt,
1775 GetPString(IDS_DELPROMPT1TEXT),
1776 (wk -> li -> type == IDM_DELETE) ?
1777 NullStr :
1778 GetPString(IDS_PERMANENTLYTEXT),
1779 &"s"[wk -> li -> list[1] == NULL]);
1780 if (isdir)
1781 {
1782 sprintf(&prompt[strlen(prompt)],
1783 GetPString(IDS_DELPROMPT2TEXT),
1784 isdir,
1785 (isdir > 1) ?
1786 GetPString(IDS_ARETEXT) :
1787 GetPString(IDS_ISTEXT),
1788 (isdir == 1) ?
1789 GetPString(IDS_ATEXT) :
1790 NullStr,
1791 (isdir > 1) ?
1792 GetPString(IDS_IESTEXT) :
1793 GetPString(IDS_YTEXT));
1794 if (sysdir)
1795 sprintf(&prompt[strlen(prompt)],
1796 GetPString(IDS_DELPROMPT3TEXT),
1797 sysdir,
1798 (sysdir == 1) ?
1799 GetPString(IDS_YTEXT) :
1800 GetPString(IDS_IESTEXT));
1801 }
1802 if (ro)
1803 sprintf(&prompt[strlen(prompt)],
1804 GetPString(IDS_DELPROMPT4TEXT),
1805 ro,
1806 &"s"[ro == 1],
1807 (ro > 1) ?
1808 GetPString(IDS_ARETEXT) :
1809 GetPString(IDS_ISTEXT));
1810 if (hs)
1811 sprintf(&prompt[strlen(prompt)],
1812 GetPString(IDS_DELPROMPT5TEXT),
1813 hs,
1814 &"s"[hs == 1],
1815 (hs > 1) ?
1816 GetPString(IDS_ARETEXT) :
1817 GetPString(IDS_ISTEXT));
1818 if (ro || hs || sysdir)
1819 DosBeep(300, 100); // Wake up user
1820 strcat(prompt,
1821 GetPString(IDS_DELPROMPT6TEXT));
1822 error = WinDlgBox(HWND_DESKTOP,
1823 wk -> hwndFrame,
1824 CheckListProc,
1825 FM3ModHandle,
1826 CHECK_FRAME,
1827 MPFROMP(&cl));
1828 if (!error || error == 65535)
1829 break;
1830 wk -> li -> list = cl.list;
1831 if (!wk -> li -> list || !wk -> li -> list[0])
1832 break;
1833 }
1834 for (x = 0; wk -> li -> list[x]; x++)
1835 {
1836 fsa.attrFile = 0;
1837 DosError(FERR_DISABLEHARDERR);
1838 DosQueryPathInfo(wk -> li -> list[x],
1839 FIL_STANDARD,
1840 &fsa,
1841 (ULONG) sizeof(FILESTATUS3));
1842 if (fsa.attrFile & FILE_DIRECTORY)
1843 {
1844 sprintf(prompt,
1845 GetPString(IDS_DELETINGTEXT),
1846 wk -> li -> list[x]);
1847 AddNote(prompt);
1848 error = (APIRET) wipeallf("%s%s*",
1849 wk -> li -> list[x],
1850 (*wk -> li -> list[x] &&
1851 wk -> li -> list[x][strlen(wk -> li -> list[x]) - 1] !=
1852 '\\') ?
1853 "\\" :
1854 NullStr);
1855 DosError(FERR_DISABLEHARDERR);
1856 if (!error)
1857 error = DosDeleteDir(wk -> li -> list[x]);
1858 else
1859 DosDeleteDir(wk -> li -> list[x]);
1860 }
1861 else
1862 {
1863 sprintf(prompt,
1864 GetPString(IDS_DELETINGTEXT),
1865 wk -> li -> list[x]);
1866 AddNote(prompt);
1867 DosError(FERR_DISABLEHARDERR);
1868 if (wk -> li -> type == IDM_DELETE)
1869 error = DosDelete(wk -> li -> list[x]);
1870 else
1871 error = DosForceDelete(wk -> li -> list[x]);
1872 if (error)
1873 {
1874 DosError(FERR_DISABLEHARDERR);
1875 make_deleteable(wk -> li -> list[x]);
1876 if (wk -> li -> type == IDM_DELETE)
1877 error = DosDelete(wk -> li -> list[x]);
1878 else
1879 error = DosForceDelete(wk -> li -> list[x]);
1880 }
1881 }
1882 if (error)
1883 {
1884 if (LogFileHandle)
1885 fprintf(LogFileHandle,
1886 GetPString(IDS_DELETEFAILED1TEXT),
1887 wk -> li -> list[x],
1888 error);
1889 if (Dos_Error(MB_ENTERCANCEL,
1890 error,
1891 wk -> hwndFrame,
1892 pszSrcFile,
1893 __LINE__,
1894 GetPString(IDS_DELETEFAILED2TEXT),
1895 wk -> li -> list[x]) ==
1896 MBID_CANCEL)
1897 break;
1898 }
1899 else
1900 {
1901 if (LogFileHandle)
1902 fprintf(LogFileHandle,
1903 GetPString(IDS_DELETEDTEXT),
1904 wk -> li -> list[x]);
1905 sprintf(prompt,
1906 GetPString(IDS_DELETEDTEXT),
1907 wk -> li -> list[x]);
1908 AddNote(prompt);
1909 }
1910 if (fSyncUpdates ||
1911 AddToList(wk -> li -> list[x],
1912 &files,
1913 &numfiles,
1914 &numalloc))
1915 Broadcast(hab2,
1916 wk -> hwndCnr,
1917 UM_UPDATERECORD,
1918 MPFROMP(wk -> li -> list[x]),
1919 MPVOID);
1920 }
1921 }
1922 break;
1923 }
1924 if (files)
1925 {
1926 Broadcast(hab2,
1927 wk -> hwndCnr,
1928 UM_UPDATERECORDLIST,
1929 MPFROMP(files),
1930 MPVOID);
1931 FreeList(files);
1932 }
1933 Abort:
1934 if (WinIsWindow(hab2, wk -> hwndCnr))
1935 PostMsg(wk -> hwndCnr,
1936 UM_RESCAN,
1937 MPVOID,
1938 MPVOID);
1939
1940 if (hwndMain)
1941 WinSendMsg(hwndMain,
1942 UM_THREADUSE,
1943 MPVOID,
1944 MPVOID);
1945 WinDestroyMsgQueue(hmq2);
1946 }
1947 WinTerminate(hab2);
1948 }
1949 }
1950 if (wk -> li)
1951 FreeListInfo(wk -> li);
1952 free(wk);
1953 DosPostEventSem(CompactSem);
1954 }
1955}
Note: See TracBrowser for help on using the repository browser.