source: trunk/dll/worker.c@ 219

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

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