source: trunk/dll/collect.c@ 240

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

Make savedSortFlags static to avoid referencing garbage
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 71.4 KB
Line 
1
2/***********************************************************************
3
4 $Id: collect.c 197 2005-06-08 05:52:46Z root $
5
6 Collector
7
8 Copyright (c) 1993-98 M. Kimes
9 Copyright (c) 2003, 2005 Steven H. Levine
10
11 15 Oct 02 MK Baseline
12 10 Jan 04 SHL Avoid -1L byte counts
13 01 Aug 04 SHL Rework lstrip/rstrip usage
14 23 May 05 SHL Use QWL_USER
15 24 May 05 SHL Rework Win_Error usage
16 25 May 05 SHL Use ULONGLONG and CommaFmtULL
17 25 May 05 SHL Rework for FillInRecordFromFFB
18 05 Jun 05 SHL Use QWL_USER
19 06 Jun 05 SHL Indent -i2
20 06 Jun 05 SHL Make savedSortFlags static to avoid referencing garbage
21
22***********************************************************************/
23
24#define INCL_DOS
25#define INCL_WIN
26#define INCL_GPI
27#define INCL_DOSERRORS
28#define INCL_LONGLONG
29#include <os2.h>
30
31#include <stdarg.h>
32#include <stdio.h>
33#include <stdlib.h>
34#include <string.h>
35#include <ctype.h>
36#include <time.h>
37#include <share.h>
38#include <limits.h>
39
40#include "fm3dll.h"
41#include "fm3dlg.h"
42#include "fm3str.h"
43#include "mle.h"
44#include "grep.h"
45
46#pragma data_seg(DATA1)
47#pragma alloc_text(COLLECTOR,CollectorCnrWndProc,CollectorObjWndProc)
48#pragma alloc_text(COLLECTOR,CollectorClientWndProc,CollectorTextProc)
49#pragma alloc_text(COLLECTOR,CollectorFrameWndProc)
50#pragma alloc_text(STARTUP,StartCollector)
51
52MRESULT EXPENTRY CollectorFrameWndProc(HWND hwnd, ULONG msg, MPARAM mp1,
53 MPARAM mp2)
54{
55 return CommonFrameWndProc(COLLECTOR_CNR, hwnd, msg, mp1, mp2);
56}
57
58MRESULT EXPENTRY CollectorTextProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
59{
60 DIRCNRDATA *dcd;
61
62 static BOOL emphasized = FALSE;
63 static HWND hwndButtonPopup = (HWND) 0;
64 static ULONG timestamp = ULONG_MAX;
65 static USHORT lastid = 0;
66
67 switch (msg)
68 {
69 case WM_CREATE:
70 return CommonTextProc(hwnd, msg, mp1, mp2);
71
72 case UM_CONTEXTMENU:
73 case WM_CONTEXTMENU:
74 {
75 USHORT id;
76
77 id = WinQueryWindowUShort(hwnd, QWS_ID);
78 switch (id)
79 {
80 case DIR_SELECTED:
81 case DIR_VIEW:
82 case DIR_SORT:
83 {
84 POINTL ptl = {0, 0};
85 SWP swp;
86
87 if (hwndButtonPopup)
88 WinDestroyWindow(hwndButtonPopup);
89 if (id == lastid)
90 {
91 ULONG check;
92
93 DosQuerySysInfo(QSV_MS_COUNT,
94 QSV_MS_COUNT,
95 &check,
96 sizeof(check));
97 if (check < timestamp + 500)
98 {
99 lastid = 0;
100 goto MenuAbort;
101 }
102 }
103 hwndButtonPopup = WinLoadMenu(HWND_DESKTOP,
104 FM3ModHandle,
105 id);
106 if (hwndButtonPopup)
107 {
108 WinSetWindowUShort(hwndButtonPopup,
109 QWS_ID,
110 id);
111 dcd = WinQueryWindowPtr(WinWindowFromID(WinQueryWindow(hwnd,
112 QW_PARENT),
113 COLLECTOR_CNR),
114 QWL_USER);
115 if (id == DIR_VIEW)
116 {
117 if (dcd)
118 {
119 SetViewMenu(hwndButtonPopup,
120 dcd -> flWindowAttr);
121 SetDetailsSwitches(hwndButtonPopup,
122 dcd);
123 }
124
125 /* don't have tree view in collector */
126 WinSendMsg(hwndButtonPopup,
127 MM_DELETEITEM,
128 MPFROM2SHORT(IDM_TREEVIEW,
129 FALSE),
130 MPVOID);
131
132 }
133 else if (id == DIR_SORT)
134 {
135 if (dcd)
136 SetSortChecks(hwndButtonPopup,
137 dcd -> sortFlags);
138 }
139 ptl.x = 0;
140 if (WinPopupMenu(HWND_OBJECT,
141 HWND_OBJECT,
142 hwndButtonPopup,
143 -32767,
144 -32767,
145 0,
146 0))
147 {
148 WinQueryWindowPos(hwndButtonPopup,
149 &swp);
150 ptl.y = -(swp.cy + 2);
151 }
152 else
153 {
154 WinQueryWindowPos(hwnd,
155 &swp);
156 ptl.y = swp.cy + 2;
157 }
158 if (WinPopupMenu(hwnd,
159 hwnd,
160 hwndButtonPopup,
161 ptl.x,
162 ptl.y,
163 0,
164 PU_HCONSTRAIN | PU_VCONSTRAIN |
165 PU_KEYBOARD | PU_MOUSEBUTTON1))
166 {
167 CenterOverWindow(hwndButtonPopup);
168 PaintRecessedWindow(hwnd,
169 (HPS) 0,
170 FALSE,
171 FALSE);
172 }
173 }
174 }
175 break;
176 default:
177 PostMsg(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
178 COLLECTOR_CNR),
179 WM_CONTROL,
180 MPFROM2SHORT(COLLECTOR_CNR,
181 CN_CONTEXTMENU),
182 MPVOID);
183 break;
184 }
185 }
186 MenuAbort:
187 if (msg == UM_CONTEXTMENU)
188 return 0;
189 break;
190
191 case WM_MENUEND:
192 if (hwndButtonPopup == (HWND) mp2)
193 {
194 lastid = WinQueryWindowUShort((HWND) mp2,
195 QWS_ID);
196 WinDestroyWindow(hwndButtonPopup);
197 hwndButtonPopup = (HWND) 0;
198 DosQuerySysInfo(QSV_MS_COUNT,
199 QSV_MS_COUNT,
200 &timestamp,
201 sizeof(timestamp));
202 switch (lastid)
203 {
204 case DIR_SELECTED:
205 case DIR_VIEW:
206 case DIR_SORT:
207 PaintRecessedWindow(hwnd,
208 (HPS) 0,
209 TRUE,
210 FALSE);
211 break;
212 }
213 }
214 break;
215
216 case WM_COMMAND:
217 {
218 DIRCNRDATA *dcd;
219 MRESULT mr;
220
221 mr = WinSendMsg(WinWindowFromID(WinQueryWindow(hwnd,
222 QW_PARENT),
223 COLLECTOR_CNR),
224 msg,
225 mp1,
226 mp2);
227 if (hwndButtonPopup &&
228 SHORT1FROMMP(mp1) > IDM_DETAILSTITLES &&
229 SHORT1FROMMP(mp1) < IDM_DETAILSSETUP)
230 {
231 dcd = WinQueryWindowPtr(WinWindowFromID(WinQueryWindow(hwnd,
232 QW_PARENT),
233 COLLECTOR_CNR),
234 QWL_USER);
235 if (dcd)
236 SetDetailsSwitches(hwndButtonPopup,
237 dcd);
238 }
239 return mr;
240 }
241
242 case WM_MOUSEMOVE:
243 {
244 USHORT id = WinQueryWindowUShort(hwnd, QWS_ID);
245 char *s = NULL;
246
247 if (fOtherHelp)
248 {
249 if ((!hwndBubble ||
250 WinQueryWindowULong(hwndBubble, QWL_USER) != hwnd) &&
251 !WinQueryCapture(HWND_DESKTOP))
252 {
253 switch (id)
254 {
255 case DIR_SELECTED:
256 s = GetPString(IDS_COLSELECTEDHELP);
257 break;
258 case DIR_TOTALS:
259 s = GetPString(IDS_COLTOTALSHELP);
260 break;
261 case DIR_VIEW:
262 s = GetPString(IDS_DIRCNRVIEWHELP);
263 break;
264 case DIR_SORT:
265 s = GetPString(IDS_DIRCNRSORTHELP);
266 break;
267 case DIR_FILTER:
268 s = GetPString(IDS_DIRCNRFILTERHELP);
269 break;
270 default:
271 break;
272 }
273 if (s)
274 MakeBubble(hwnd, TRUE, s);
275 else if (hwndBubble)
276 WinDestroyWindow(hwndBubble);
277 }
278 }
279 switch (id)
280 {
281 case DIR_FILTER:
282 case DIR_SORT:
283 case DIR_VIEW:
284 case DIR_SELECTED:
285 return CommonTextButton(hwnd, msg, mp1, mp2);
286 }
287 }
288 break;
289
290 case WM_BUTTON3UP:
291 case WM_BUTTON1UP:
292 case WM_BUTTON3DOWN:
293 case WM_BUTTON1DOWN:
294 {
295 USHORT id;
296
297 id = WinQueryWindowUShort(hwnd,
298 QWS_ID);
299 switch (id)
300 {
301 case DIR_FILTER:
302 case DIR_SORT:
303 case DIR_VIEW:
304 case DIR_SELECTED:
305 return CommonTextButton(hwnd, msg, mp1, mp2);
306 }
307 }
308 break;
309
310 case UM_CLICKED:
311 case UM_CLICKED3:
312 {
313 USHORT id, cmd = 0;
314
315 id = WinQueryWindowUShort(hwnd,
316 QWS_ID);
317 switch (id)
318 {
319 case DIR_VIEW:
320 case DIR_SORT:
321 case DIR_SELECTED:
322 PostMsg(hwnd,
323 UM_CONTEXTMENU,
324 MPVOID,
325 MPVOID);
326 break;
327 case DIR_FILTER:
328 cmd = IDM_FILTER;
329 break;
330 default:
331 break;
332 }
333 if (cmd)
334 PostMsg(WinWindowFromID(WinQueryWindow(hwnd,
335 QW_PARENT),
336 COLLECTOR_CNR),
337 WM_COMMAND,
338 MPFROM2SHORT(cmd, 0),
339 MPVOID);
340 }
341 return 0;
342
343 case DM_DROP:
344 case DM_DRAGOVER:
345 case DM_DRAGLEAVE:
346 case DM_DROPHELP:
347 if (msg == DM_DRAGOVER)
348 {
349 if (!emphasized)
350 {
351 emphasized = TRUE;
352 DrawTargetEmphasis(hwnd, emphasized);
353 }
354 }
355 else
356 {
357 if (emphasized)
358 {
359 emphasized = FALSE;
360 DrawTargetEmphasis(hwnd, emphasized);
361 }
362 }
363 {
364 CNRDRAGINFO cnd;
365 USHORT dcmd;
366
367 switch (msg)
368 {
369 case DM_DROP:
370 dcmd = CN_DROP;
371 break;
372 case DM_DRAGOVER:
373 dcmd = CN_DRAGOVER;
374 break;
375 case DM_DRAGLEAVE:
376 dcmd = CN_DRAGLEAVE;
377 break;
378 case DM_DROPHELP:
379 dcmd = CN_DROPHELP;
380 break;
381 }
382 memset(&cnd, 0, sizeof(cnd));
383 cnd.pDragInfo = (PDRAGINFO) mp1;
384 cnd.pRecord = NULL;
385 return WinSendMsg(WinQueryWindow(hwnd, QW_PARENT), WM_CONTROL,
386 MPFROM2SHORT(COLLECTOR_CNR, dcmd), MPFROMP(&cnd));
387 }
388 }
389 return PFNWPStatic(hwnd, msg, mp1, mp2);
390}
391
392MRESULT EXPENTRY CollectorClientWndProc(HWND hwnd, ULONG msg, MPARAM mp1,
393 MPARAM mp2)
394{
395 switch (msg)
396 {
397 case UM_CONTAINERHWND:
398 return MRFROMLONG(WinWindowFromID(hwnd, COLLECTOR_CNR));
399
400 case UM_VIEWSMENU:
401 return MRFROMLONG(CheckMenu(&CollectorCnrMenu, COLLECTORCNR_POPUP));
402
403 case MM_PORTHOLEINIT:
404 case WM_INITMENU:
405 case UM_INITMENU:
406 case UM_CONTAINER_FILLED:
407 case UM_FILESMENU:
408 case UM_UPDATERECORD:
409 case UM_UPDATERECORDLIST:
410 return WinSendMsg(WinWindowFromID(hwnd, COLLECTOR_CNR), msg, mp1, mp2);
411
412 case WM_PSETFOCUS:
413 case WM_SETFOCUS:
414 if (mp2)
415 PostMsg(hwnd, UM_FOCUSME, MPVOID, MPVOID);
416 break;
417
418 case UM_FOCUSME:
419 WinSetFocus(HWND_DESKTOP, WinWindowFromID(hwnd, COLLECTOR_CNR));
420 break;
421
422 case WM_PAINT:
423 {
424 HPS hps;
425 RECTL rcl;
426
427 hps = WinBeginPaint(hwnd, (HPS) 0, NULL);
428 if (hps)
429 {
430 WinQueryWindowRect(hwnd, &rcl);
431 WinFillRect(hps, &rcl, CLR_PALEGRAY);
432 CommonTextPaint(hwnd, hps);
433 WinEndPaint(hps);
434 }
435 }
436 break;
437
438 case UM_SIZE:
439 case WM_SIZE:
440 if (msg == UM_SIZE)
441 {
442 SWP swp;
443
444 WinQueryWindowPos(hwnd, &swp);
445 mp1 = MPFROM2SHORT(swp.cx, swp.cy);
446 mp2 = MPFROM2SHORT(swp.cx, swp.cy);
447 }
448 {
449 USHORT cx, cy, bx;
450
451 cx = SHORT1FROMMP(mp2);
452 cy = SHORT2FROMMP(mp2);
453 WinSetWindowPos(WinWindowFromID(hwnd, COLLECTOR_CNR), HWND_TOP,
454 0,
455 0,
456 cx,
457 cy - 24,
458 SWP_SHOW | SWP_MOVE | SWP_SIZE);
459 WinSetWindowPos(WinWindowFromID(hwnd, DIR_TOTALS), HWND_TOP,
460 2,
461 cy - 22,
462 (cx / 3) - 2,
463 20,
464 SWP_SHOW | SWP_MOVE | SWP_SIZE);
465 WinSetWindowPos(WinWindowFromID(hwnd, DIR_SELECTED), HWND_TOP,
466 2 + (cx / 3) + 2,
467 cy - 22,
468 (cx / 3) - 2,
469 20,
470 SWP_SHOW | SWP_MOVE | SWP_SIZE);
471 bx = (cx - (2 + (((cx / 3) + 2) * 2))) / 3;
472 WinSetWindowPos(WinWindowFromID(hwnd, DIR_VIEW), HWND_TOP,
473 2 + (((cx / 3) + 2) * 2),
474 cy - 22,
475 bx - 4,
476 20,
477 SWP_SHOW | SWP_MOVE | SWP_SIZE);
478 WinSetWindowPos(WinWindowFromID(hwnd, DIR_SORT), HWND_TOP,
479 2 + (((cx / 3) + 2) * 2) + bx,
480 cy - 22,
481 bx - 4,
482 20,
483 SWP_SHOW | SWP_MOVE | SWP_SIZE);
484 WinSetWindowPos(WinWindowFromID(hwnd, DIR_FILTER), HWND_TOP,
485 2 + (((cx / 3) + 2) * 2) + (bx * 2),
486 cy - 22,
487 bx - 4,
488 20,
489 SWP_SHOW | SWP_MOVE | SWP_SIZE);
490 }
491 CommonTextPaint(hwnd, (HPS) 0);
492 if (msg == UM_SIZE)
493 {
494 WinSetWindowPos(WinQueryWindow(hwnd, QW_PARENT), HWND_TOP, 0, 0, 0, 0,
495 SWP_SHOW | SWP_ZORDER | SWP_ACTIVATE);
496 return 0;
497 }
498 break;
499
500 case UM_COMMAND:
501 case WM_COMMAND:
502 case WM_CONTROL:
503 case WM_CLOSE:
504 return WinSendMsg(WinWindowFromID(hwnd, COLLECTOR_CNR), msg, mp1, mp2);
505 }
506 return WinDefWindowProc(hwnd, msg, mp1, mp2);
507}
508
509MRESULT EXPENTRY CollectorObjWndProc(HWND hwnd, ULONG msg, MPARAM mp1,
510 MPARAM mp2)
511{
512 ULONG size;
513 DIRCNRDATA *dcd;
514
515 switch (msg)
516 {
517 case WM_CREATE:
518 break;
519
520 case DM_PRINTOBJECT:
521 return MRFROMLONG(DRR_TARGET);
522
523 case DM_DISCARDOBJECT:
524 dcd = INSTDATA(hwnd);
525 if (fFM2Deletes && dcd)
526 {
527 LISTINFO *li;
528 CNRDRAGINFO cni;
529
530 cni.pRecord = NULL;
531 cni.pDragInfo = (PDRAGINFO) mp1;
532 li = DoFileDrop(dcd -> hwndCnr, NULL, FALSE, MPVOID, MPFROMP(&cni));
533 if (li)
534 {
535 li -> type = (fDefaultDeletePerm) ? IDM_PERMDELETE : IDM_DELETE;
536 if (!PostMsg(hwnd, UM_MASSACTION, MPFROMP(li), MPVOID))
537 FreeListInfo(li);
538 else
539 return MRFROMLONG(DRR_SOURCE);
540 }
541 }
542 return MRFROMLONG(DRR_TARGET);
543
544 case UM_UPDATERECORDLIST:
545 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
546 if (dcd && mp1)
547 {
548 INT numentries = 0;
549 CHAR **list = (CHAR **) mp1;
550
551 while (list[numentries])
552 numentries++;
553 if (numentries)
554 UpdateCnrList(dcd -> hwndCnr, list, numentries, FALSE, dcd);
555 }
556 return 0;
557
558 case UM_SETUP:
559 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
560 if (dcd)
561 {
562 /* set unique id */
563 WinSetWindowUShort(hwnd,
564 QWS_ID,
565 COLLECTOROBJ_FRAME + (COLLECTOR_FRAME - dcd -> id));
566 dcd -> hwndObject = hwnd;
567 if (ParentIsDesktop(hwnd, dcd -> hwndParent))
568 DosSleep(250L);
569 }
570 else
571 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
572 return 0;
573
574 case UM_COMMAND:
575 if (mp1)
576 {
577 LISTINFO *li = (LISTINFO *) mp1;
578
579 switch (li -> type)
580 {
581 case IDM_DOITYOURSELF:
582 case IDM_APPENDTOCLIP:
583 case IDM_SAVETOCLIP:
584 case IDM_ARCHIVE:
585 case IDM_ARCHIVEM:
586 case IDM_VIEW:
587 case IDM_VIEWTEXT:
588 case IDM_VIEWBINARY:
589 case IDM_VIEWARCHIVE:
590 case IDM_EDIT:
591 case IDM_EDITTEXT:
592 case IDM_EDITBINARY:
593 case IDM_OBJECT:
594 case IDM_SHADOW:
595 case IDM_SHADOW2:
596 case IDM_PRINT:
597 case IDM_ATTRS:
598 case IDM_DELETE:
599 case IDM_PERMDELETE:
600 case IDM_FAKEEXTRACT:
601 case IDM_FAKEEXTRACTM:
602 case IDM_MCIPLAY:
603 case IDM_UPDATE:
604 if (PostMsg(hwnd, UM_MASSACTION, mp1, mp2))
605 return (MRESULT) TRUE;
606 break;
607 default:
608 if (PostMsg(hwnd, UM_ACTION, mp1, mp2))
609 return (MRESULT) TRUE;
610 }
611 }
612 return 0;
613
614 case UM_COLLECT:
615 DosError(FERR_DISABLEHARDERR);
616 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
617 if (dcd)
618 {
619 LISTINFO *li = (LISTINFO *) mp1;
620 INT x;
621 FILEFINDBUF4 fb4;
622 HDIR hdir;
623 ULONG nm;
624 PCNRITEM pci, pciFirst, pciT, pciP = NULL;
625 RECORDINSERT ri;
626 ULONG ulMaxFiles;
627 ULONGLONG ullTotalBytes;
628 CHAR fullname[CCHMAXPATH];
629
630 WinSetWindowText(WinWindowFromID(dcd -> hwndClient,
631 DIR_SELECTED),
632 GetPString(IDS_COLLECTINGTEXT));
633 for (x = 0; li -> list[x]; x++)
634 {
635 ;
636 }
637 ulMaxFiles = x;
638 if (ulMaxFiles)
639 {
640 pci = WinSendMsg(dcd -> hwndCnr, CM_ALLOCRECORD,
641 MPFROMLONG(EXTRA_RECORD_BYTES),
642 MPFROMLONG(ulMaxFiles));
643 if (pci)
644 {
645 pciFirst = pci;
646 for (x = 0; li -> list[x]; x++)
647 {
648 nm = 1L;
649 hdir = HDIR_CREATE;
650 DosError(FERR_DISABLEHARDERR);
651 if (*li -> list[x] &&
652 !DosQueryPathInfo(li -> list[x], FIL_QUERYFULLNAME,
653 fullname, sizeof(fullname)) &&
654 !IsRoot(fullname) &&
655 !FindCnrRecord(dcd -> hwndCnr,
656 fullname,
657 NULL,
658 FALSE,
659 FALSE,
660 TRUE) &&
661 !DosFindFirst(fullname,
662 &hdir,
663 FILE_NORMAL | FILE_DIRECTORY |
664 FILE_ARCHIVED | FILE_SYSTEM |
665 FILE_HIDDEN | FILE_READONLY,
666 &fb4,
667 sizeof(fb4),
668 &nm,
669 FIL_QUERYEASIZE))
670 {
671 DosFindClose(hdir);
672 priority_normal();
673 *fb4.achName = 0;
674 ullTotalBytes = FillInRecordFromFFB(dcd -> hwndCnr,
675 pci,
676 fullname,
677 &fb4,
678 FALSE,
679 dcd);
680 dcd -> ullTotalBytes += ullTotalBytes;
681 pciP = pci;
682 pci = (PCNRITEM) pci -> rc.preccNextRecord;
683 }
684 else
685 {
686 pciT = pci;
687 pci = (PCNRITEM) pci -> rc.preccNextRecord;
688 if (pciP)
689 pciP -> rc.preccNextRecord = (PMINIRECORDCORE) pci;
690 else
691 pciFirst = pci;
692 WinSendMsg(hwnd, CM_FREERECORD, MPFROMP(&pciT),
693 MPFROM2SHORT(1, 0));
694 ulMaxFiles--;
695 }
696 DosSleep(1L);
697 }
698 if (ulMaxFiles)
699 {
700 memset(&ri, 0, sizeof(RECORDINSERT));
701 ri.cb = sizeof(RECORDINSERT);
702 ri.pRecordOrder = (PRECORDCORE) CMA_END;
703 ri.pRecordParent = (PRECORDCORE) 0;
704 ri.zOrder = (ULONG) CMA_TOP;
705 ri.cRecordsInsert = ulMaxFiles;
706 ri.fInvalidateRecord = TRUE;
707 WinSendMsg(dcd -> hwndCnr,
708 CM_INSERTRECORD,
709 MPFROMP(pciFirst),
710 MPFROMP(&ri));
711 PostMsg(dcd -> hwndCnr,
712 UM_RESCAN,
713 MPVOID,
714 MPVOID);
715 }
716 }
717 }
718 }
719 if (dcd -> flWindowAttr & CV_DETAIL)
720 WinSendDlgItemMsg(hwnd,
721 COLLECTOR_CNR,
722 CM_INVALIDATERECORD,
723 MPVOID,
724 MPFROM2SHORT(0,
725 CMA_ERASE | CMA_REPOSITION));
726 return 0;
727
728 case UM_COLLECTFROMFILE:
729 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
730 if (dcd && mp1)
731 {
732 FILESTATUS4 fs4;
733 PCNRITEM pci;
734 RECORDINSERT ri;
735 CHAR fullname[1024], *p;
736 FILE *fp;
737 ULONG errs = 0L;
738
739 fp = _fsopen((CHAR *) mp1, "r", SH_DENYNO);
740 if (fp)
741 {
742 while (!feof(fp))
743 {
744 if (!fgets(fullname, 1024, fp))
745 break;
746 fullname[1023] = 0;
747 bstripcr(fullname);
748 if (*fullname == '\"')
749 {
750 memmove(fullname, fullname + 1, strlen(fullname) + 1);
751 lstrip(fullname);
752 p = strchr(fullname, '\"');
753 if (p)
754 *p = 0;
755 rstrip(fullname);
756 }
757 else
758 {
759 p = strchr(fullname, ' ');
760 if (p)
761 *p = 0;
762 }
763 /* fullname now contains name of file to collect */
764 DosError(FERR_DISABLEHARDERR);
765 if (IsFullName(fullname) &&
766 !IsRoot(fullname) &&
767 !DosQueryPathInfo(fullname,
768 FIL_QUERYEASIZE,
769 &fs4,
770 sizeof(fs4)) &&
771 !FindCnrRecord(dcd -> hwndCnr,
772 fullname,
773 NULL,
774 FALSE,
775 FALSE,
776 TRUE))
777 {
778 /* collect it */
779 pci = WinSendMsg(dcd -> hwndCnr,
780 CM_ALLOCRECORD,
781 MPFROMLONG(EXTRA_RECORD_BYTES),
782 MPFROMLONG(1L));
783 if (pci)
784 {
785 dcd -> ullTotalBytes += FillInRecordFromFSA(dcd -> hwndCnr, pci,
786 fullname,
787 &fs4, FALSE, dcd);
788 memset(&ri, 0, sizeof(RECORDINSERT));
789 ri.cb = sizeof(RECORDINSERT);
790 ri.pRecordOrder = (PRECORDCORE) CMA_END;
791 ri.pRecordParent = (PRECORDCORE) 0;
792 ri.zOrder = (ULONG) CMA_TOP;
793 ri.cRecordsInsert = 1L;
794 ri.fInvalidateRecord = TRUE;
795 WinSendMsg(dcd -> hwndCnr, CM_INSERTRECORD,
796 MPFROMP(pci), MPFROMP(&ri));
797 }
798 }
799 else
800 {
801 errs++;
802 if (errs > 50L)
803 { /* prevent runaway on bad file */
804
805 APIRET ret;
806
807 ret = saymsg(MB_YESNO, dcd -> hwndCnr,
808 GetPString(IDS_COLLECTNOLISTHDRTEXT),
809 GetPString(IDS_COLLECTNOLISTTEXT),
810 (CHAR *) mp1);
811 if (ret == MBID_NO)
812 break;
813 errs = 0L;
814 }
815 }
816 }
817 fclose(fp);
818 }
819 }
820 if (mp1)
821 free(mp1);
822 return 0;
823
824 case UM_SELECT:
825 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
826 if (dcd)
827 {
828 switch (SHORT1FROMMP(mp1))
829 {
830 case IDM_SELECTLIST:
831 {
832 CHAR filename[CCHMAXPATH], *p, *pp;
833
834 strcpy(filename, "*.LST");
835 size = CCHMAXPATH;
836 PrfQueryProfileData(fmprof,
837 appname,
838 "SaveToListName",
839 filename,
840 &size);
841 pp = strrchr(filename, '\\');
842 if (!pp)
843 pp = filename;
844 p = strrchr(pp, '.');
845 if (p && *(p + 1) && p > pp + 1)
846 {
847 if (pp > filename)
848 pp++;
849 *pp = '*';
850 pp++;
851 if (p > pp)
852 memmove(pp, p, strlen(p) + 1);
853 }
854 if (insert_filename(hwnd, filename, FALSE, FALSE))
855 SelectList(dcd -> hwndCnr, TRUE, FALSE, FALSE, NULL, filename, NULL);
856 }
857 break;
858 case IDM_SELECTALL:
859 SelectAll(dcd -> hwndCnr, TRUE, TRUE, NULL, NULL, FALSE);
860 break;
861 case IDM_DESELECTALL:
862 DeselectAll(dcd -> hwndCnr, TRUE, TRUE, NULL, NULL, FALSE);
863 break;
864 case IDM_SELECTALLFILES:
865 SelectAll(dcd -> hwndCnr, TRUE, FALSE, NULL, NULL, FALSE);
866 break;
867 case IDM_DESELECTALLFILES:
868 DeselectAll(dcd -> hwndCnr, TRUE, FALSE, NULL, NULL, FALSE);
869 break;
870 case IDM_SELECTALLDIRS:
871 SelectAll(dcd -> hwndCnr, FALSE, TRUE, NULL, NULL, FALSE);
872 break;
873 case IDM_DESELECTALLDIRS:
874 DeselectAll(dcd -> hwndCnr, FALSE, TRUE, NULL, NULL, FALSE);
875 break;
876 case IDM_DESELECTMASK:
877 case IDM_SELECTMASK:
878 {
879 MASK mask;
880 PCNRITEM pci = (PCNRITEM) mp2;
881
882 memset(&mask, 0, sizeof(MASK));
883 mask.fNoAttribs = TRUE;
884 mask.fNoDirs = TRUE;
885 mask.fText = TRUE;
886 strcpy(mask.prompt,
887 GetPString((SHORT1FROMMP(mp1) == IDM_SELECTMASK) ?
888 IDS_SELECTFILTERTEXT :
889 IDS_DESELECTFILTERTEXT));
890 if (pci && (INT) pci != -1)
891 strcpy(mask.szMask, pci -> szFileName);
892 if (WinDlgBox(HWND_DESKTOP, dcd -> hwndCnr, PickMaskDlgProc,
893 FM3ModHandle, MSK_FRAME, MPFROMP(&mask)))
894 {
895 if (SHORT1FROMMP(mp1) == IDM_SELECTMASK)
896 SelectAll(dcd -> hwndCnr, TRUE, TRUE, mask.szMask, mask.szText,
897 FALSE);
898 else
899 DeselectAll(dcd -> hwndCnr, TRUE, TRUE, mask.szMask, mask.szText,
900 FALSE);
901 }
902 }
903
904 case IDM_DESELECTCLIP:
905 case IDM_SELECTCLIP:
906 {
907 CHAR **list;
908
909 list = ListFromClipboard(hwnd);
910 if (list)
911 {
912 SelectList(dcd -> hwndCnr, TRUE, FALSE,
913 (SHORT1FROMMP(mp1) == IDM_DESELECTCLIP),
914 NULL, NULL, list);
915 FreeList(list);
916 }
917 }
918 break;
919
920 case IDM_INVERT:
921 InvertAll(dcd -> hwndCnr);
922 break;
923 }
924 }
925 return 0;
926
927 case UM_MASSACTION:
928 if (mp1)
929 {
930 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
931 if (dcd)
932 {
933 WORKER *wk;
934
935 wk = malloc(sizeof(WORKER));
936 if (wk)
937 {
938 memset(wk, 0, sizeof(WORKER));
939 wk -> size = sizeof(WORKER);
940 wk -> hwndCnr = dcd -> hwndCnr;
941 wk -> hwndParent = dcd -> hwndParent;
942 wk -> hwndFrame = dcd -> hwndFrame;
943 wk -> hwndClient = dcd -> hwndClient;
944 wk -> li = (LISTINFO *) mp1;
945 strcpy(wk -> directory, dcd -> directory);
946 if (_beginthread(MassAction, NULL, 122880, (PVOID) wk) == -1)
947 {
948 free(wk);
949 FreeListInfo((LISTINFO *) mp1);
950 }
951 }
952 else
953 FreeListInfo((LISTINFO *) mp1);
954 }
955 }
956 return 0;
957
958 case UM_ACTION:
959 if (mp1)
960 {
961 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
962 if (dcd)
963 {
964 WORKER *wk;
965
966 wk = malloc(sizeof(WORKER));
967 if (wk)
968 {
969 memset(wk, 0, sizeof(WORKER));
970 wk -> size = sizeof(WORKER);
971 wk -> hwndCnr = dcd -> hwndCnr;
972 wk -> hwndParent = dcd -> hwndParent;
973 wk -> hwndFrame = dcd -> hwndFrame;
974 wk -> hwndClient = dcd -> hwndClient;
975 wk -> li = (LISTINFO *) mp1;
976 strcpy(wk -> directory, dcd -> directory);
977 if (_beginthread(Action, NULL, 122880, (PVOID) wk) == -1)
978 {
979 free(wk);
980 FreeListInfo((LISTINFO *) mp1);
981 }
982 }
983 else
984 FreeListInfo((LISTINFO *) mp1);
985 }
986 }
987 return 0;
988
989 case WM_CLOSE:
990 WinDestroyWindow(hwnd);
991 break;
992
993 case WM_DESTROY:
994 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
995 if (dcd)
996 {
997 INT x = 0;
998
999 dcd -> stopflag = 1;
1000 while (x++ < 10 && dcd -> amextracted)
1001 DosSleep(250L);
1002 WinSendMsg(dcd -> hwndCnr, UM_CLOSE, MPVOID, MPVOID);
1003 FreeList(dcd -> lastselection);
1004 free(dcd);
1005 }
1006 DosPostEventSem(CompactSem);
1007 if (!PostMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID))
1008 WinSendMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID);
1009 break;
1010 }
1011 return WinDefWindowProc(hwnd, msg, mp1, mp2);
1012}
1013
1014MRESULT EXPENTRY CollectorCnrWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
1015{
1016 DIRCNRDATA *dcd = WinQueryWindowPtr(hwnd, QWL_USER);
1017 ULONG size;
1018
1019 static INT savedSortFlags;
1020
1021 switch (msg)
1022 {
1023 case DM_PRINTOBJECT:
1024 return MRFROMLONG(DRR_TARGET);
1025
1026 case DM_DISCARDOBJECT:
1027 if (dcd)
1028 return WinSendMsg(dcd -> hwndObject, msg, mp1, mp2);
1029 else
1030 return MRFROMLONG(DRR_TARGET);
1031
1032 case WM_CHAR:
1033 shiftstate = (SHORT1FROMMP(mp1) & (KC_SHIFT | KC_ALT | KC_CTRL));
1034 if (SHORT1FROMMP(mp1) & KC_KEYUP)
1035 return (MRESULT) TRUE;
1036 if (SHORT1FROMMP(mp1) & KC_VIRTUALKEY)
1037 {
1038 switch (SHORT2FROMMP(mp2))
1039 {
1040 case VK_DELETE:
1041 if ((shiftstate & KC_CTRL) == KC_CTRL)
1042 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_PERMDELETE, 0), MPVOID);
1043 else if ((shiftstate & KC_SHIFT) == KC_SHIFT)
1044 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_SAVETOCLIP, 0), MPVOID);
1045 else
1046 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_DELETE, 0), MPVOID);
1047 break;
1048 }
1049 }
1050 if (shiftstate || fNoSearch)
1051 break;
1052 if (SHORT1FROMMP(mp1) & KC_CHAR)
1053 {
1054 ULONG thistime, len;
1055 SEARCHSTRING srch;
1056 PCNRITEM pci;
1057
1058 if (!dcd)
1059 break;
1060 switch (SHORT1FROMMP(mp2))
1061 {
1062 case '\x1b':
1063 case '\r':
1064 case '\n':
1065 dcd -> lasttime = 0;
1066 *dcd -> szCommonName = 0;
1067 break;
1068 default:
1069 thistime = WinQueryMsgTime(WinQueryAnchorBlock(hwnd));
1070 if (thistime > dcd -> lasttime + 1250)
1071 *dcd -> szCommonName = 0;
1072 dcd -> lasttime = thistime;
1073 if (SHORT1FROMMP(mp2) == ' ' && !dcd -> szCommonName)
1074 break;
1075 KbdRetry:
1076 len = strlen(dcd -> szCommonName);
1077 if (len >= CCHMAXPATH - 1)
1078 {
1079 *dcd -> szCommonName = 0;
1080 len = 0;
1081 }
1082 dcd -> szCommonName[len] = toupper(SHORT1FROMMP(mp2));
1083 dcd -> szCommonName[len + 1] = 0;
1084 memset(&srch, 0, sizeof(SEARCHSTRING));
1085 srch.cb = sizeof(SEARCHSTRING);
1086 srch.pszSearch = dcd -> szCommonName;
1087 srch.fsPrefix = TRUE;
1088 srch.fsCaseSensitive = FALSE;
1089 srch.usView = CV_ICON;
1090 pci = WinSendMsg(hwnd, CM_SEARCHSTRING, MPFROMP(&srch),
1091 MPFROMLONG(CMA_FIRST));
1092 if (pci && (INT) pci != -1)
1093 {
1094 USHORT attrib = CRA_CURSORED;
1095
1096 /* make found item current item */
1097 if (!stricmp(pci -> pszFileName, dcd -> szCommonName))
1098 attrib |= CRA_SELECTED;
1099 WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPFROMP(pci),
1100 MPFROM2SHORT(TRUE, attrib));
1101 /* make sure that record shows in viewport */
1102 ShowCnrRecord(hwnd, (PMINIRECORDCORE) pci);
1103 return (MRESULT) TRUE;
1104 }
1105 else
1106 {
1107 if (SHORT1FROMMP(mp2) == ' ')
1108 {
1109 dcd -> szCommonName[len] = 0;
1110 break;
1111 }
1112 *dcd -> szCommonName = 0;
1113 dcd -> lasttime = 0;
1114 if (len) // retry as first letter if no match
1115
1116 goto KbdRetry;
1117 }
1118 break;
1119 }
1120 }
1121 break;
1122
1123 case WM_MOUSEMOVE:
1124 case WM_BUTTON1UP:
1125 case WM_BUTTON2UP:
1126 case WM_BUTTON3UP:
1127 case WM_CHORD:
1128 shiftstate = (SHORT2FROMMP(mp2) & (KC_SHIFT | KC_ALT | KC_CTRL));
1129 break;
1130
1131 case WM_BUTTON1MOTIONEND:
1132 {
1133 CNRINFO cnri;
1134
1135 memset(&cnri, 0, sizeof(CNRINFO));
1136 cnri.cb = sizeof(CNRINFO);
1137 if (WinSendMsg(hwnd, CM_QUERYCNRINFO, MPFROMP(&cnri),
1138 MPFROMLONG(sizeof(CNRINFO))))
1139 {
1140 if (cnri.flWindowAttr & CV_DETAIL)
1141 PrfWriteProfileData(fmprof, appname, "CollectorCnrSplitBar",
1142 (PVOID) & cnri.xVertSplitbar, sizeof(LONG));
1143 }
1144 }
1145 break;
1146
1147 case WM_PRESPARAMCHANGED:
1148 PresParamChanged(hwnd, "Collector", mp1, mp2);
1149 break;
1150
1151 case UM_COMPARE:
1152 if (dcd && mp1 && mp2)
1153 {
1154 COMPARE *cmp;
1155 CHAR *leftdir = (CHAR *) mp1, *rightdir = (CHAR *) mp2;
1156
1157 if (!IsFile(leftdir) && !IsFile(rightdir))
1158 {
1159 cmp = malloc(sizeof(COMPARE));
1160 if (cmp)
1161 {
1162 memset(cmp, 0, sizeof(COMPARE));
1163 cmp -> size = sizeof(COMPARE);
1164 strcpy(cmp -> leftdir, leftdir);
1165 strcpy(cmp -> rightdir, rightdir);
1166 cmp -> hwndParent = dcd -> hwndParent;
1167 cmp -> dcd.hwndParent = dcd -> hwndParent;
1168 WinDlgBox(HWND_DESKTOP, HWND_DESKTOP, CompareDlgProc,
1169 FM3ModHandle, COMP_FRAME, MPFROMP(cmp));
1170 }
1171 }
1172 }
1173 return 0;
1174
1175 case UM_UPDATERECORDLIST:
1176 if (dcd && mp1)
1177 WinSendMsg(dcd -> hwndObject, msg, mp1, mp2);
1178 return 0;
1179
1180 case UM_UPDATERECORD:
1181 if (dcd && mp1)
1182 {
1183 CHAR *filename;
1184
1185 filename = mp1;
1186 if (filename)
1187 UpdateCnrRecord(hwnd, filename, TRUE, dcd);
1188 }
1189 return 0;
1190
1191 case WM_SETFOCUS:
1192 /*
1193 * put name of our window on status line
1194 */
1195 if (dcd && hwndStatus && mp2)
1196 {
1197 PCNRITEM pci = NULL;
1198
1199 if (fAutoView && hwndMain)
1200 {
1201 pci = WinSendMsg(hwnd,
1202 CM_QUERYRECORDEMPHASIS,
1203 MPFROMLONG(CMA_FIRST),
1204 MPFROMSHORT(CRA_CURSORED));
1205 if (pci && (INT) pci != -1 &&
1206 (!(driveflags[toupper(*pci -> szFileName) - 'A'] & DRIVE_SLOW)))
1207 WinSendMsg(hwndMain,
1208 UM_LOADFILE,
1209 MPFROMP(pci -> szFileName),
1210 MPVOID);
1211 else
1212 WinSendMsg(hwndMain,
1213 UM_LOADFILE,
1214 MPVOID,
1215 MPVOID);
1216 }
1217 if (dcd -> amextracted)
1218 WinSetWindowText(hwndStatus2,
1219 GetPString(IDS_INSEEKSCANTEXT));
1220 WinSendMsg(hwnd,
1221 UM_RESCAN,
1222 MPVOID,
1223 MPVOID);
1224 }
1225 break;
1226
1227 case UM_RESCAN:
1228 if (dcd)
1229 {
1230 CNRINFO cnri;
1231 CHAR s[CCHMAXPATH + 69], tb[81], tf[81], *p;
1232 PCNRITEM pci = NULL;
1233
1234 memset(&cnri, 0, sizeof(CNRINFO));
1235 cnri.cb = sizeof(CNRINFO);
1236 WinSendMsg(hwnd, CM_QUERYCNRINFO, MPFROMP(&cnri),
1237 MPFROMLONG(sizeof(CNRINFO)));
1238 dcd -> totalfiles = cnri.cRecords;
1239 commafmt(tf, sizeof(tf), dcd -> totalfiles);
1240 CommaFmtULL(tb, sizeof(tb), dcd -> ullTotalBytes, ' ');
1241 sprintf(s, "%s / %s", tf, tb);
1242 WinSetDlgItemText(dcd -> hwndClient, DIR_TOTALS, s);
1243
1244 commafmt(tf, sizeof(tf), dcd -> selectedfiles);
1245 CommaFmtULL(tb, sizeof(tb), dcd -> selectedbytes, ' ');
1246 sprintf(s, "%s / %s", tf, tb);
1247 WinSetDlgItemText(dcd -> hwndClient, DIR_SELECTED, s);
1248
1249 if (hwndStatus &&
1250 dcd -> hwndFrame == WinQueryActiveWindow(dcd -> hwndParent))
1251 {
1252 if (hwndMain)
1253 {
1254 pci = WinSendMsg(hwnd, CM_QUERYRECORDEMPHASIS,
1255 MPFROMLONG(CMA_FIRST),
1256 MPFROMSHORT(CRA_CURSORED));
1257 if (pci && (INT) pci != -1)
1258 PostMsg(hwndMain, UM_LOADFILE, MPFROMP(pci -> szFileName), MPVOID);
1259 else
1260 PostMsg(hwndMain, UM_LOADFILE, MPVOID, MPVOID);
1261 }
1262 if (!fMoreButtons)
1263 sprintf(s, " %s%s%s%s", GetPString(IDS_COLLECTORTEXT),
1264 (*dcd -> mask.szMask || dcd -> mask.antiattr ||
1265 dcd -> mask.attrFile != ALLATTRS) ? " (" : NullStr,
1266 (*dcd -> mask.szMask) ? dcd -> mask.szMask :
1267 (dcd -> mask.antiattr ||
1268 dcd -> mask.attrFile != ALLATTRS) ?
1269 GetPString(IDS_ATTRTEXT) : NullStr,
1270 (*dcd -> mask.szMask || dcd -> mask.antiattr ||
1271 dcd -> mask.attrFile != ALLATTRS) ? ")" : NullStr);
1272 else
1273 strcpy(s, GetPString(IDS_COLLECTORTEXT));
1274 WinSetWindowText(hwndStatus, s);
1275 if (!pci)
1276 pci = WinSendMsg(hwnd, CM_QUERYRECORDEMPHASIS,
1277 MPFROMLONG(CMA_FIRST),
1278 MPFROMSHORT(CRA_CURSORED));
1279 if (pci && (INT) pci != -1)
1280 {
1281 if (fSplitStatus && hwndStatus2)
1282 {
1283 if (pci -> attrFile & FILE_DIRECTORY)
1284 p = pci -> pszFileName;
1285 else
1286 {
1287 p = strrchr(pci -> szFileName, '\\');
1288 if (p)
1289 {
1290 if (*(p + 1))
1291 p++;
1292 else
1293 p = pci -> pszFileName;
1294 }
1295 else
1296 p = pci -> pszFileName;
1297 }
1298 CommaFmtULL(tb, sizeof(tb), pci -> cbFile + pci -> easize, ' ');
1299 if (!fMoreButtons)
1300 {
1301 sprintf(s, " %s %04u/%02u/%02u %02u:%02u:%02u [%s] %s",
1302 tb, pci -> date.year, pci -> date.month,
1303 pci -> date.day, pci -> time.hours, pci -> time.minutes,
1304 pci -> time.seconds, pci -> pszDispAttr, p);
1305 }
1306 else
1307 {
1308 if (pci -> cbFile + pci -> easize > 1024)
1309 CommaFmtULL(tf, sizeof(tf), pci -> cbFile + pci -> easize, 'K');
1310 else
1311 *tf = 0;
1312 sprintf(s, GetPString(IDS_STATUSSIZETEXT),
1313 tb,
1314 *tf ? " (" : NullStr,
1315 tf,
1316 *tf ? ")" : NullStr);
1317 }
1318 WinSetWindowText(hwndStatus2, s);
1319 }
1320 if (fMoreButtons)
1321 {
1322 WinSetWindowText(hwndName, pci -> pszFileName);
1323 sprintf(s, "%04u/%02u/%02u %02u:%02u:%02u",
1324 pci -> date.year, pci -> date.month,
1325 pci -> date.day, pci -> time.hours, pci -> time.minutes,
1326 pci -> time.seconds);
1327 WinSetWindowText(hwndDate, s);
1328 WinSetWindowText(hwndAttr, pci -> pszDispAttr);
1329 }
1330 if (dcd -> amextracted && hwndStatus2)
1331 WinSetWindowText(hwndStatus2, GetPString(IDS_INSEEKSCANTEXT));
1332 }
1333 else
1334 {
1335 if (hwndStatus2)
1336 WinSetWindowText(hwndStatus2, NullStr);
1337 if (fMoreButtons)
1338 {
1339 WinSetWindowText(hwndName, NullStr);
1340 WinSetWindowText(hwndDate, NullStr);
1341 WinSetWindowText(hwndAttr, NullStr);
1342 }
1343 }
1344 }
1345 }
1346 return 0;
1347
1348 case UM_CONTAINER_FILLED:
1349 DosBeep(1000, 50);
1350 WinSendMsg(hwnd,
1351 CM_INVALIDATERECORD,
1352 MPVOID,
1353 MPFROM2SHORT(0, CMA_ERASE | CMA_REPOSITION));
1354 WinSendMsg(CollectorCnrMenu,
1355 MM_SETITEMATTR,
1356 MPFROM2SHORT(DID_CANCEL, TRUE),
1357 MPFROM2SHORT(MIA_DISABLED, MIA_DISABLED));
1358 WinSendMsg(CollectorCnrMenu,
1359 MM_SETITEMATTR,
1360 MPFROM2SHORT(IDM_GREP, TRUE),
1361 MPFROM2SHORT(MIA_DISABLED, 0));
1362 PostMsg(hwnd,
1363 UM_RESCAN,
1364 MPVOID,
1365 MPVOID);
1366 if (dcd)
1367 {
1368 dcd -> stopflag = 0;
1369 dcd -> amextracted = FALSE;
1370 if (dcd -> namecanchange)
1371 {
1372 if (!PostMsg(hwnd,
1373 WM_CLOSE,
1374 MPVOID,
1375 MPVOID))
1376 WinSendMsg(hwnd,
1377 WM_CLOSE,
1378 MPVOID,
1379 MPVOID);
1380 }
1381 else
1382 WinSetWindowPos(WinQueryWindow(WinQueryWindow(hwnd, QW_PARENT),
1383 QW_PARENT),
1384 HWND_TOP,
1385 0,
1386 0,
1387 0,
1388 0,
1389 SWP_SHOW | SWP_RESTORE | SWP_ZORDER);
1390 }
1391 return 0;
1392
1393 case UM_SETUP:
1394 if (dcd)
1395 {
1396 if (!dcd -> hwndObject)
1397 {
1398 /*
1399 * first time through -- set things up
1400 */
1401
1402 CNRINFO cnri;
1403
1404 RestorePresParams(hwnd, "Collector");
1405 LoadDetailsSwitches("Collector", dcd);
1406 WinSendMsg(CollectorCnrMenu, MM_SETITEMATTR,
1407 MPFROM2SHORT(DID_CANCEL, TRUE),
1408 MPFROM2SHORT(MIA_DISABLED, MIA_DISABLED));
1409 WinSendMsg(CollectorCnrMenu, MM_SETITEMATTR, MPFROM2SHORT(IDM_GREP, TRUE),
1410 MPFROM2SHORT(MIA_DISABLED, 0));
1411 dcd -> amextracted = FALSE;
1412 dcd -> stopflag = 0;
1413 memset(&cnri, 0, sizeof(CNRINFO));
1414 cnri.cb = sizeof(CNRINFO);
1415 WinSendMsg(hwnd, CM_QUERYCNRINFO, MPFROMP(&cnri),
1416 MPFROMLONG(sizeof(CNRINFO)));
1417 cnri.cyLineSpacing = 0;
1418 cnri.cxTreeIndent = 12L;
1419
1420 cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT |
1421 CV_DETAIL));
1422 cnri.flWindowAttr |= (CV_NAME | CA_DETAILSVIEWTITLES |
1423 CV_MINI | CV_FLOW);
1424 cnri.pSortRecord = (PVOID) SortCollectorCnr;
1425
1426 {
1427 size = sizeof(ULONG);
1428 PrfQueryProfileData(fmprof, appname, "CollectorflWindowAttr",
1429 (PVOID) & cnri.flWindowAttr, &size);
1430 size = sizeof(MASK);
1431 if (PrfQueryProfileSize(fmprof, appname, "CollectorFilter", &size) &&
1432 size)
1433 {
1434 PrfQueryProfileData(fmprof, appname, "CollectorFilter", &dcd -> mask,
1435 &size);
1436 SetMask(dcd -> mask.szMask, &dcd -> mask);
1437 }
1438 else
1439 {
1440 dcd -> mask.attrFile = (FILE_NORMAL | FILE_READONLY |
1441 FILE_DIRECTORY | FILE_HIDDEN |
1442 FILE_SYSTEM | FILE_ARCHIVED);
1443 dcd -> mask.antiattr = 0;
1444 }
1445 *(dcd -> mask.prompt) = 0;
1446 }
1447 cnri.flWindowAttr |= CV_FLOW;
1448 cnri.flWindowAttr &= (~(CA_MIXEDTARGETEMPH | CA_ORDEREDTARGETEMPH));
1449 dcd -> flWindowAttr = cnri.flWindowAttr;
1450 WinSendMsg(hwnd, CM_SETCNRINFO, MPFROMP(&cnri),
1451 MPFROMLONG(CMA_FLWINDOWATTR | CMA_LINESPACING |
1452 CMA_CXTREEINDENT | CMA_PSORTRECORD));
1453 SetCnrCols(hwnd, FALSE);
1454 AdjustCnrColsForPref(hwnd, NULL, dcd, FALSE);
1455
1456 /* fix splitbar for collector container */
1457 cnri.xVertSplitbar = DIR_SPLITBAR_OFFSET - 32;
1458 size = sizeof(LONG);
1459 PrfQueryProfileData(fmprof, appname, "CollectorCnrSplitBar",
1460 &cnri.xVertSplitbar, &size);
1461 if (cnri.xVertSplitbar <= 0)
1462 cnri.xVertSplitbar = DIR_SPLITBAR_OFFSET - 32;
1463 WinSendMsg(hwnd, CM_SETCNRINFO, MPFROMP(&cnri),
1464 MPFROMLONG(CMA_XVERTSPLITBAR));
1465
1466 if (_beginthread(MakeObjWin, NULL, 245760, (PVOID) dcd) == -1)
1467 {
1468 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
1469 return 0;
1470 }
1471 else
1472 DosSleep(64L);
1473 }
1474 SayFilter(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
1475 DIR_FILTER), &dcd -> mask, FALSE);
1476 SaySort(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
1477 DIR_SORT), CollectorsortFlags, FALSE);
1478 SayView(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
1479 DIR_VIEW), dcd -> flWindowAttr);
1480 }
1481 else
1482 {
1483 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
1484 return 0;
1485 }
1486 return 0;
1487
1488 case WM_MENUEND:
1489 if (dcd)
1490 {
1491 HWND hwndMenu = (HWND) mp2;
1492
1493 if (hwndMenu == CollectorCnrMenu || hwndMenu == CollectorFileMenu ||
1494 hwndMenu == CollectorDirMenu)
1495 {
1496 MarkAll(hwnd, TRUE, FALSE, TRUE);
1497 if (dcd -> cnremphasized)
1498 {
1499 WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPVOID,
1500 MPFROM2SHORT(FALSE, CRA_SOURCE));
1501 dcd -> cnremphasized = FALSE;
1502 }
1503 }
1504 }
1505 break;
1506
1507 case UM_OPENWINDOWFORME:
1508 if (dcd)
1509 {
1510 if (mp1 &&
1511 !IsFile((CHAR *) mp1))
1512 OpenDirCnr((HWND) 0,
1513 hwndMain,
1514 dcd -> hwndFrame,
1515 FALSE,
1516 (char *) mp1);
1517 else if (mp1 &&
1518 IsFile(mp1) == 1)
1519 StartArcCnr(HWND_DESKTOP,
1520 dcd -> hwndFrame,
1521 (CHAR *) mp1,
1522 4,
1523 (ARC_TYPE *) mp2);
1524 }
1525 return 0;
1526
1527 case MM_PORTHOLEINIT:
1528 if (dcd)
1529 {
1530 switch (SHORT1FROMMP(mp1))
1531 {
1532 case 0:
1533 case 1:
1534 {
1535 ULONG wmsg;
1536
1537 wmsg = (SHORT1FROMMP(mp1) == 0) ? UM_FILESMENU : UM_VIEWSMENU;
1538 PortholeInit((HWND) WinSendMsg(dcd -> hwndClient, wmsg, MPVOID,
1539 MPVOID), mp1, mp2);
1540 }
1541 break;
1542 }
1543 }
1544 break;
1545
1546 case UM_INITMENU:
1547 case WM_INITMENU:
1548 if (dcd)
1549 {
1550 switch (SHORT1FROMMP(mp1))
1551 {
1552 case IDM_VIEWSMENU:
1553 SetViewMenu((HWND) mp2, dcd -> flWindowAttr);
1554 WinEnableMenuItem((HWND) mp2, IDM_RESELECT,
1555 (dcd -> lastselection != NULL));
1556 break;
1557
1558 case IDM_DETAILSSETUP:
1559 SetDetailsSwitches((HWND) mp2, dcd);
1560 break;
1561
1562 case IDM_COMMANDSMENU:
1563 SetupCommandMenu((HWND) mp2, hwnd);
1564 break;
1565
1566 case IDM_SORTSUBMENU:
1567 SetSortChecks((HWND) mp2, CollectorsortFlags);
1568 break;
1569 }
1570 dcd -> hwndLastMenu = (HWND) mp2;
1571 }
1572 if (msg == WM_INITMENU)
1573 break;
1574 return 0;
1575
1576 case UM_COLLECTFROMFILE:
1577 if (mp1)
1578 {
1579 if (dcd)
1580 {
1581 if (!PostMsg(dcd -> hwndObject, UM_COLLECTFROMFILE, mp1, mp2))
1582 {
1583 free(mp1);
1584 DosBeep(50, 100);
1585 }
1586 }
1587 else
1588 free(mp1);
1589 }
1590 else
1591 free(mp1);
1592 return 0;
1593
1594 case UM_COMMAND:
1595 if (mp1)
1596 {
1597 if (dcd)
1598 {
1599 if (!PostMsg(dcd -> hwndObject, UM_COMMAND, mp1, mp2))
1600 {
1601 FreeListInfo((LISTINFO *) mp1);
1602 DosBeep(50, 100);
1603 }
1604 else
1605 return (MRESULT) TRUE;
1606 }
1607 else
1608 FreeListInfo((LISTINFO *) mp1);
1609 }
1610 return 0;
1611
1612 case UM_NOTIFY:
1613 if (mp2)
1614 AddNote((CHAR *) mp2);
1615 return 0;
1616
1617 case WM_COMMAND:
1618 DosError(FERR_DISABLEHARDERR);
1619 if (dcd)
1620 {
1621 switch (SHORT1FROMMP(mp1))
1622 {
1623 case IDM_SETTARGET:
1624 SetTargetDir(hwnd, FALSE);
1625 break;
1626
1627 case IDM_CONTEXTMENU:
1628 {
1629 PCNRITEM pci;
1630
1631 pci = (PCNRITEM) CurrentRecord(hwnd);
1632 PostMsg(hwnd, WM_CONTROL, MPFROM2SHORT(COLLECTOR_CNR,
1633 CN_CONTEXTMENU), MPFROMP(pci));
1634 }
1635 break;
1636
1637 case IDM_SHOWALLFILES:
1638 {
1639 PCNRITEM pci;
1640
1641 pci = WinSendMsg(hwnd, CM_QUERYRECORDEMPHASIS,
1642 MPFROMLONG(CMA_FIRST),
1643 MPFROMSHORT(CRA_CURSORED));
1644 if (pci && (INT) pci != -1)
1645 {
1646 static CHAR dirname[CCHMAXPATH];
1647
1648 strcpy(dirname, pci -> szFileName);
1649 MakeValidDir(dirname);
1650 StartSeeAll(HWND_DESKTOP, FALSE, dirname);
1651 }
1652 }
1653 break;
1654
1655 case IDM_BEGINEDIT:
1656 OpenEdit(hwnd);
1657 break;
1658
1659 case IDM_ENDEDIT:
1660 WinSendMsg(hwnd, CM_CLOSEEDIT, MPVOID, MPVOID);
1661 break;
1662
1663 case IDM_SHOWSELECT:
1664 QuickPopup(hwnd, dcd, CheckMenu(&CollectorCnrMenu, COLLECTORCNR_POPUP),
1665 IDM_SELECTSUBMENU);
1666 break;
1667
1668 case IDM_SHOWSORT:
1669 QuickPopup(hwnd, dcd, CheckMenu(&CollectorCnrMenu, COLLECTORCNR_POPUP),
1670 IDM_SORTSUBMENU);
1671 break;
1672
1673 case IDM_VIEWORARC:
1674 {
1675 SWP swp;
1676 PCNRITEM pci;
1677
1678 pci = (PCNRITEM) WinSendMsg(hwnd, CM_QUERYRECORDEMPHASIS,
1679 MPFROMLONG(CMA_FIRST),
1680 MPFROMSHORT(CRA_CURSORED));
1681 if (pci && (INT) pci != -1)
1682 {
1683 WinQueryWindowPos(dcd -> hwndFrame, &swp);
1684 DefaultViewKeys(hwnd, dcd -> hwndFrame, dcd -> hwndParent, &swp,
1685 pci -> szFileName);
1686 }
1687 }
1688 break;
1689
1690 case IDM_SEEALL:
1691 StartSeeAll(HWND_DESKTOP,
1692 FALSE,
1693 NULL);
1694 break;
1695
1696 case IDM_COLLECTSELECT:
1697 {
1698 CHAR filename[CCHMAXPATH], *p, *pp;
1699
1700 strcpy(filename, "*.LST");
1701 size = CCHMAXPATH;
1702 PrfQueryProfileData(fmprof, appname, "SaveToListName",
1703 filename, &size);
1704 pp = strrchr(filename, '\\');
1705 if (!pp)
1706 pp = filename;
1707 p = strrchr(pp, '.');
1708 if (p && *(p + 1) && p > pp + 1)
1709 {
1710 if (pp > filename)
1711 pp++;
1712 *pp = '*';
1713 pp++;
1714 if (p > pp)
1715 memmove(pp, p, strlen(p) + 1);
1716 }
1717 if (insert_filename(hwnd, filename, FALSE, FALSE))
1718 {
1719 p = strdup(filename);
1720 if (p)
1721 {
1722 if (!PostMsg(hwnd, UM_COLLECTFROMFILE, MPFROMP(p), MPVOID))
1723 free(p);
1724 }
1725 }
1726 }
1727 break;
1728
1729 case IDM_NOTEBOOK:
1730 if (!ParentIsDesktop(dcd -> hwndParent, dcd -> hwndParent))
1731 PostMsg(dcd -> hwndParent, msg, mp1, mp2);
1732 else
1733 WinDlgBox(HWND_DESKTOP, hwnd, CfgDlgProc, FM3ModHandle,
1734 CFG_FRAME, (PVOID) "Collector");
1735 break;
1736
1737 case IDM_RESELECT:
1738 SelectList(hwnd, FALSE, FALSE, FALSE, NULL, NULL, dcd -> lastselection);
1739 break;
1740
1741 case IDM_HELP:
1742 if (hwndHelp)
1743 WinSendMsg(hwndHelp, HM_DISPLAY_HELP,
1744 MPFROM2SHORT(HELP_COLLECT, 0),
1745 MPFROMSHORT(HM_RESOURCEID));
1746 break;
1747
1748 case IDM_SORTNONE:
1749 case IDM_SORTSMARTNAME:
1750 case IDM_SORTNAME:
1751 case IDM_SORTFILENAME:
1752 case IDM_SORTSIZE:
1753 case IDM_SORTEASIZE:
1754 case IDM_SORTFIRST:
1755 case IDM_SORTLAST:
1756 case IDM_SORTLWDATE:
1757 case IDM_SORTLADATE:
1758 case IDM_SORTCRDATE:
1759 case IDM_SORTSUBJECT:
1760 savedSortFlags = CollectorsortFlags;
1761 CollectorsortFlags &= (SORT_REVERSE | SORT_DIRSFIRST | SORT_DIRSLAST);
1762 case IDM_SORTDIRSFIRST:
1763 case IDM_SORTDIRSLAST:
1764 case IDM_SORTREVERSE:
1765 switch (SHORT1FROMMP(mp1))
1766 {
1767 case IDM_SORTSUBJECT:
1768 CollectorsortFlags |= SORT_SUBJECT;
1769 break;
1770 case IDM_SORTNONE:
1771 CollectorsortFlags |= SORT_NOSORT;
1772 break;
1773 case IDM_SORTSMARTNAME:
1774 if (~savedSortFlags & SORT_FILENAME)
1775 CollectorsortFlags |= SORT_FILENAME;
1776 break;
1777 case IDM_SORTFILENAME:
1778 CollectorsortFlags |= SORT_FILENAME;
1779 break;
1780 case IDM_SORTSIZE:
1781 CollectorsortFlags |= SORT_SIZE;
1782 break;
1783 case IDM_SORTEASIZE:
1784 CollectorsortFlags |= SORT_EASIZE;
1785 break;
1786 case IDM_SORTFIRST:
1787 CollectorsortFlags |= SORT_FIRSTEXTENSION;
1788 break;
1789 case IDM_SORTLAST:
1790 CollectorsortFlags |= SORT_LASTEXTENSION;
1791 break;
1792 case IDM_SORTLWDATE:
1793 CollectorsortFlags |= SORT_LWDATE;
1794 break;
1795 case IDM_SORTLADATE:
1796 CollectorsortFlags |= SORT_LADATE;
1797 break;
1798 case IDM_SORTCRDATE:
1799 CollectorsortFlags |= SORT_CRDATE;
1800 break;
1801 case IDM_SORTDIRSFIRST:
1802 if (CollectorsortFlags & SORT_DIRSFIRST)
1803 CollectorsortFlags &= (~SORT_DIRSFIRST);
1804 else
1805 {
1806 CollectorsortFlags |= SORT_DIRSFIRST;
1807 CollectorsortFlags &= (~SORT_DIRSLAST);
1808 }
1809 break;
1810 case IDM_SORTDIRSLAST:
1811 if (CollectorsortFlags & SORT_DIRSLAST)
1812 CollectorsortFlags &= (~SORT_DIRSLAST);
1813 else
1814 {
1815 CollectorsortFlags |= SORT_DIRSLAST;
1816 CollectorsortFlags &= (~SORT_DIRSFIRST);
1817 }
1818 break;
1819 case IDM_SORTREVERSE:
1820 if (CollectorsortFlags & SORT_REVERSE)
1821 CollectorsortFlags &= (~SORT_REVERSE);
1822 else
1823 CollectorsortFlags |= SORT_REVERSE;
1824 break;
1825 }
1826 PrfWriteProfileData(fmprof, appname, "CollectorSort",
1827 &CollectorsortFlags, sizeof(INT));
1828 WinSendMsg(hwnd, CM_SORTRECORD, MPFROMP(SortCollectorCnr), MPVOID);
1829 SaySort(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
1830 DIR_SORT), CollectorsortFlags, FALSE);
1831 break;
1832
1833 case IDM_COLLECTFROMCLIP:
1834 {
1835 LISTINFO *li;
1836
1837 li = malloc(sizeof(LISTINFO));
1838 if (li)
1839 {
1840 memset(li, 0, sizeof(LISTINFO));
1841 li -> list = ListFromClipboard(hwnd);
1842 if (!li -> list || !li -> list[0])
1843 FreeListInfo(li);
1844 else
1845 {
1846 li -> type = IDM_COLLECT;
1847 if (!PostMsg(dcd -> hwndObject, UM_COLLECT, MPFROMP(li),
1848 MPVOID))
1849 FreeListInfo(li);
1850 }
1851 }
1852 }
1853 break;
1854
1855 case IDM_REMOVE:
1856 if (fAutoView &&
1857 hwndMain)
1858 PostMsg(hwndMain,
1859 UM_LOADFILE,
1860 MPVOID,
1861 MPVOID);
1862 dcd -> suspendview = 1;
1863 RemoveAll(hwnd,
1864 &dcd -> ullTotalBytes,
1865 &dcd -> totalfiles);
1866 dcd -> suspendview = 0;
1867 PostMsg(hwnd,
1868 UM_RESCAN,
1869 MPVOID,
1870 MPVOID);
1871 break;
1872
1873 case IDM_CLEARCNR:
1874 {
1875 PCNRITEM pci;
1876
1877 pci = (PCNRITEM) WinSendMsg(hwnd,
1878 CM_QUERYRECORD,
1879 MPVOID,
1880 MPFROM2SHORT(CMA_FIRST,
1881 CMA_ITEMORDER));
1882 if (pci && (INT) pci != -1)
1883 {
1884 WinSendMsg(hwnd,
1885 CM_REMOVERECORD,
1886 MPVOID,
1887 MPFROM2SHORT(0, CMA_FREE | CMA_INVALIDATE));
1888 dcd -> ullTotalBytes = dcd -> selectedbytes = dcd -> selectedfiles =
1889 dcd -> totalfiles = 0L;
1890 PostMsg(hwnd,
1891 UM_RESCAN,
1892 MPVOID,
1893 MPVOID);
1894 }
1895 }
1896 break;
1897
1898 case DID_CANCEL:
1899 if (dcd -> amextracted)
1900 dcd -> stopflag = 1;
1901 break;
1902
1903 case IDM_COLLECTOR:
1904 if (mp2)
1905 {
1906 LISTINFO *li;
1907
1908 li = malloc(sizeof(LISTINFO));
1909 if (li)
1910 {
1911 memset(li, 0, sizeof(LISTINFO));
1912 li -> list = mp2;
1913 if (!li -> list || !li -> list[0])
1914 FreeListInfo(li);
1915 else
1916 {
1917 li -> type = IDM_COLLECT;
1918 if (!PostMsg(dcd -> hwndObject, UM_COLLECT, MPFROMP(li),
1919 MPVOID))
1920 FreeListInfo(li);
1921 }
1922 }
1923 else
1924 FreeList(mp2);
1925 }
1926 break;
1927
1928 case IDM_UNDELETE:
1929 {
1930 PCNRITEM pci;
1931 CHAR path[CCHMAXPATH];
1932
1933 pci = (PCNRITEM) CurrentRecord(hwnd);
1934 if (pci)
1935 {
1936 strcpy(path, pci -> szFileName);
1937 MakeValidDir(path);
1938 WinDlgBox(HWND_DESKTOP, hwnd, UndeleteDlgProc, FM3ModHandle,
1939 UNDEL_FRAME, MPFROMP(path));
1940 }
1941 }
1942 break;
1943
1944 case IDM_GREP:
1945 if (!dcd -> amextracted)
1946 {
1947 if (WinDlgBox(HWND_DESKTOP, hwnd, GrepDlgProc,
1948 FM3ModHandle, GREP_FRAME, (PVOID) & hwnd))
1949 {
1950 dcd -> amextracted = TRUE;
1951 WinSendMsg(CollectorCnrMenu, MM_SETITEMATTR,
1952 MPFROM2SHORT(DID_CANCEL, TRUE),
1953 MPFROM2SHORT(MIA_DISABLED, 0));
1954 WinSendMsg(CollectorCnrMenu, MM_SETITEMATTR,
1955 MPFROM2SHORT(IDM_GREP, TRUE),
1956 MPFROM2SHORT(MIA_DISABLED, MIA_DISABLED));
1957 PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
1958 }
1959 }
1960 else
1961 DosBeep(50, 100);
1962 break;
1963
1964 case IDM_RESORT:
1965 WinSendMsg(hwnd, CM_SORTRECORD, MPFROMP(SortCollectorCnr), MPVOID);
1966 break;
1967
1968 case IDM_FILTER:
1969 {
1970 BOOL empty = FALSE;
1971 PCNRITEM pci;
1972 CHAR *p;
1973
1974 if (!*dcd -> mask.szMask)
1975 {
1976 empty = TRUE;
1977 pci = (PCNRITEM) CurrentRecord(hwnd);
1978 if (pci && !(pci -> attrFile & FILE_DIRECTORY))
1979 {
1980 p = strrchr(pci -> szFileName, '\\');
1981 if (p)
1982 {
1983 p++;
1984 strcpy(dcd -> mask.szMask, p);
1985 }
1986 }
1987 }
1988 *(dcd -> mask.prompt) = 0;
1989
1990 if (WinDlgBox(HWND_DESKTOP, hwnd, PickMaskDlgProc,
1991 FM3ModHandle, MSK_FRAME, MPFROMP(&dcd -> mask)))
1992 {
1993 size = sizeof(MASK);
1994 PrfWriteProfileData(fmprof, appname, "CollectorFilter",
1995 &dcd -> mask, size);
1996 dcd -> suspendview = 1;
1997 WinSendMsg(hwnd, CM_FILTER, MPFROMP(Filter), MPFROMP(&dcd -> mask));
1998 dcd -> suspendview = 0;
1999 if (fAutoView && hwndMain)
2000 {
2001 pci = WinSendMsg(hwnd, CM_QUERYRECORDEMPHASIS,
2002 MPFROMLONG(CMA_FIRST),
2003 MPFROMSHORT(CRA_CURSORED));
2004 if (pci && (INT) pci != -1 &&
2005 (!(driveflags[toupper(*pci -> szFileName) - 'A'] & DRIVE_SLOW)))
2006 WinSendMsg(hwndMain, UM_LOADFILE, MPFROMP(pci -> szFileName),
2007 MPVOID);
2008 else
2009 WinSendMsg(hwndMain, UM_LOADFILE, MPVOID, MPVOID);
2010 }
2011 PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
2012 }
2013 else if (empty)
2014 *dcd -> mask.szMask = 0;
2015 SayFilter(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
2016 DIR_FILTER), &dcd -> mask, FALSE);
2017 }
2018 break;
2019
2020 case IDM_HIDEALL:
2021 if (fAutoView && hwndMain)
2022 PostMsg(hwndMain, UM_LOADFILE, MPVOID, MPVOID);
2023 dcd -> suspendview = 1;
2024 HideAll(hwnd);
2025 dcd -> suspendview = 0;
2026 PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
2027 break;
2028
2029 case IDM_SELECTLIST:
2030 case IDM_SELECTALL:
2031 case IDM_DESELECTALL:
2032 case IDM_SELECTALLFILES:
2033 case IDM_DESELECTALLFILES:
2034 case IDM_SELECTALLDIRS:
2035 case IDM_DESELECTALLDIRS:
2036 case IDM_SELECTMASK:
2037 case IDM_DESELECTMASK:
2038 case IDM_INVERT:
2039 case IDM_SELECTCLIP:
2040 case IDM_DESELECTCLIP:
2041 {
2042 PCNRITEM pci;
2043
2044 pci = (PCNRITEM) CurrentRecord(hwnd);
2045 if ((INT) pci == -1)
2046 pci = NULL;
2047 if (SHORT1FROMMP(mp1) == IDM_HIDEALL)
2048 {
2049 if (pci)
2050 {
2051 if (!(pci -> rc.flRecordAttr & CRA_SELECTED))
2052 pci -> rc.flRecordAttr |= CRA_FILTERED;
2053 WinSendMsg(hwnd, CM_INVALIDATERECORD, MPFROMP(&pci),
2054 MPFROM2SHORT(1, CMA_ERASE | CMA_REPOSITION));
2055 break;
2056 }
2057 }
2058 PostMsg(dcd -> hwndObject, UM_SELECT, mp1, MPFROMP(pci));
2059 }
2060 break;
2061
2062 case IDM_RESCAN:
2063 PostMsg(dcd -> hwndObject, UM_RESCAN, MPVOID, MPVOID);
2064 break;
2065
2066 case IDM_SHOWLNAMES:
2067 case IDM_SHOWSUBJECT:
2068 case IDM_SHOWEAS:
2069 case IDM_SHOWSIZE:
2070 case IDM_SHOWICON:
2071 case IDM_SHOWLWDATE:
2072 case IDM_SHOWLWTIME:
2073 case IDM_SHOWLADATE:
2074 case IDM_SHOWLATIME:
2075 case IDM_SHOWCRDATE:
2076 case IDM_SHOWCRTIME:
2077 case IDM_SHOWATTR:
2078 AdjustDetailsSwitches(hwnd, dcd -> hwndLastMenu,
2079 SHORT1FROMMP(mp1), NULL,
2080 "Collector", dcd, FALSE);
2081 break;
2082
2083 case IDM_ICON:
2084 case IDM_TEXT:
2085 case IDM_DETAILS:
2086 case IDM_NAME:
2087 case IDM_MINIICONS:
2088 case IDM_DETAILSTITLES:
2089 {
2090 CNRINFO cnri;
2091
2092 memset(&cnri, 0, sizeof(CNRINFO));
2093 cnri.cb = sizeof(CNRINFO);
2094 WinSendMsg(hwnd, CM_QUERYCNRINFO, MPFROMP(&cnri),
2095 MPFROMLONG(sizeof(CNRINFO)));
2096 switch (SHORT1FROMMP(mp1))
2097 {
2098 case IDM_ICON:
2099 cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT |
2100 CV_DETAIL | CV_NAME));
2101 cnri.flWindowAttr |= CV_ICON;
2102 break;
2103 case IDM_NAME:
2104 cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT |
2105 CV_DETAIL | CV_NAME));
2106 cnri.flWindowAttr |= CV_NAME;
2107 break;
2108 case IDM_TEXT:
2109 cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT |
2110 CV_DETAIL | CV_NAME));
2111 cnri.flWindowAttr |= CV_TEXT;
2112 break;
2113 case IDM_DETAILS:
2114 cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT |
2115 CV_DETAIL | CV_NAME));
2116 cnri.flWindowAttr |= CV_DETAIL;
2117 break;
2118 case IDM_MINIICONS:
2119 if (cnri.flWindowAttr & CV_MINI)
2120 cnri.flWindowAttr &= (~CV_MINI);
2121 else
2122 cnri.flWindowAttr |= CV_MINI;
2123 break;
2124 case IDM_DETAILSTITLES:
2125 if (cnri.flWindowAttr & CA_DETAILSVIEWTITLES)
2126 cnri.flWindowAttr &= (~CA_DETAILSVIEWTITLES);
2127 else
2128 cnri.flWindowAttr |= CA_DETAILSVIEWTITLES;
2129 break;
2130 }
2131 cnri.flWindowAttr &= (~(CA_ORDEREDTARGETEMPH |
2132 CA_MIXEDTARGETEMPH));
2133 cnri.flWindowAttr |= CV_FLOW;
2134 dcd -> flWindowAttr = cnri.flWindowAttr;
2135 PrfWriteProfileData(fmprof, appname, "CollectorflWindowAttr",
2136 &cnri.flWindowAttr, sizeof(ULONG));
2137 WinSendMsg(hwnd, CM_SETCNRINFO, MPFROMP(&cnri),
2138 MPFROMLONG(CMA_FLWINDOWATTR));
2139 WinSendMsg(hwnd, CM_INVALIDATERECORD, MPVOID,
2140 MPFROM2SHORT(0, CMA_ERASE | CMA_REPOSITION));
2141 SayView(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
2142 DIR_VIEW), dcd -> flWindowAttr);
2143 }
2144 break;
2145
2146 case IDM_SAVETOLIST:
2147 WinDlgBox(HWND_DESKTOP, hwnd, SaveListDlgProc, FM3ModHandle,
2148 SAV_FRAME, MPFROMP(&hwnd));
2149 break;
2150
2151 case IDM_SIZES:
2152 {
2153 PCNRITEM pci;
2154
2155 pci = (PCNRITEM) CurrentRecord(hwnd);
2156 if (pci && (INT) pci != -1)
2157 WinDlgBox(HWND_DESKTOP, HWND_DESKTOP, DirSizeProc, FM3ModHandle,
2158 DSZ_FRAME, pci -> szFileName);
2159 }
2160 break;
2161
2162 case IDM_MKDIR:
2163 {
2164 PCNRITEM pci;
2165
2166 pci = (PCNRITEM) CurrentRecord(hwnd);
2167 PMMkDir(dcd -> hwndParent, (pci && (INT) pci != -1) ?
2168 pci -> szFileName : NULL, FALSE);
2169 }
2170 break;
2171
2172 case IDM_DOITYOURSELF:
2173 case IDM_UPDATE:
2174 case IDM_COLLECTFROMFILE:
2175 case IDM_OPENWINDOW:
2176 case IDM_OPENSETTINGS:
2177 case IDM_OPENDEFAULT:
2178 case IDM_OPENICON:
2179 case IDM_OPENDETAILS:
2180 case IDM_OPENTREE:
2181 case IDM_OBJECT:
2182 case IDM_SHADOW:
2183 case IDM_SHADOW2:
2184 case IDM_DELETE:
2185 case IDM_PERMDELETE:
2186 case IDM_PRINT:
2187 case IDM_ATTRS:
2188 case IDM_INFO:
2189 case IDM_COPY:
2190 case IDM_MOVE:
2191 case IDM_WPSCOPY:
2192 case IDM_WPSMOVE:
2193 case IDM_COPYPRESERVE:
2194 case IDM_MOVEPRESERVE:
2195 case IDM_WILDCOPY:
2196 case IDM_WILDMOVE:
2197 case IDM_RENAME:
2198 case IDM_COMPARE:
2199 case IDM_EAS:
2200 case IDM_SUBJECT:
2201 case IDM_VIEW:
2202 case IDM_VIEWTEXT:
2203 case IDM_VIEWBINARY:
2204 case IDM_VIEWARCHIVE:
2205 case IDM_EDIT:
2206 case IDM_EDITTEXT:
2207 case IDM_EDITBINARY:
2208 case IDM_SAVETOCLIP:
2209 case IDM_APPENDTOCLIP:
2210 case IDM_ARCHIVE:
2211 case IDM_ARCHIVEM:
2212 case IDM_EXTRACT:
2213 case IDM_MCIPLAY:
2214 case IDM_UUDECODE:
2215 case IDM_MERGE:
2216 {
2217 LISTINFO *li;
2218 ULONG action = UM_ACTION;
2219
2220 li = malloc(sizeof(LISTINFO));
2221 if (li)
2222 {
2223 memset(li, 0, sizeof(LISTINFO));
2224 li -> type = SHORT1FROMMP(mp1);
2225 li -> hwnd = hwnd;
2226 li -> list = BuildList(hwnd);
2227 if (li -> list)
2228 {
2229 switch (SHORT1FROMMP(mp1))
2230 {
2231 case IDM_DOITYOURSELF:
2232 case IDM_APPENDTOCLIP:
2233 case IDM_SAVETOCLIP:
2234 case IDM_ARCHIVE:
2235 case IDM_ARCHIVEM:
2236 case IDM_DELETE:
2237 case IDM_PERMDELETE:
2238 case IDM_ATTRS:
2239 case IDM_PRINT:
2240 case IDM_SHADOW:
2241 case IDM_SHADOW2:
2242 case IDM_OBJECT:
2243 case IDM_VIEW:
2244 case IDM_VIEWTEXT:
2245 case IDM_VIEWBINARY:
2246 case IDM_EDIT:
2247 case IDM_EDITTEXT:
2248 case IDM_EDITBINARY:
2249 case IDM_MCIPLAY:
2250 case IDM_UPDATE:
2251 case IDM_INFO:
2252 case IDM_EAS:
2253 action = UM_MASSACTION;
2254 break;
2255 }
2256 if (li -> type == IDM_SHADOW || li -> type == IDM_OBJECT ||
2257 li -> type == IDM_SHADOW2)
2258 *li -> targetpath = 0;
2259 if (!PostMsg(dcd -> hwndObject, action, MPFROMP(li),
2260 MPVOID))
2261 {
2262 FreeListInfo(li);
2263 DosBeep(50, 100);
2264 }
2265 else if (fUnHilite)
2266 UnHilite(hwnd, TRUE, &dcd -> lastselection);
2267 }
2268 else
2269 free(li);
2270 }
2271 }
2272 break;
2273
2274 default:
2275 if (!cmdloaded)
2276 load_commands();
2277 if (SHORT1FROMMP(mp1) >= IDM_COMMANDSTART &&
2278 SHORT1FROMMP(mp1) < IDM_QUICKTOOLSTART)
2279 {
2280 INT x;
2281
2282 x = SHORT1FROMMP(mp1) - IDM_COMMANDSTART;
2283 if (x >= 0)
2284 {
2285 x++;
2286 RunCommand(hwnd, x);
2287 if (fUnHilite)
2288 UnHilite(hwnd, TRUE, &dcd -> lastselection);
2289 }
2290 }
2291 break;
2292 }
2293 }
2294 return 0;
2295
2296 case UM_FIXCNRMLE:
2297 case UM_FIXEDITNAME:
2298 return CommonCnrProc(hwnd, msg, mp1, mp2);
2299
2300 case UM_FILESMENU:
2301 {
2302 PCNRITEM pci;
2303 HWND menuHwnd = (HWND) 0;
2304
2305 pci = (PCNRITEM) CurrentRecord(hwnd);
2306 if (pci && (INT) pci != -1)
2307 {
2308 if (pci -> attrFile & FILE_DIRECTORY)
2309 menuHwnd = CheckMenu(&CollectorDirMenu, COLLECTORDIR_POPUP);
2310 else
2311 menuHwnd = CheckMenu(&CollectorFileMenu, COLLECTORFILE_POPUP);
2312 }
2313 return MRFROMLONG(menuHwnd);
2314 }
2315
2316 case WM_CONTROL:
2317 DosError(FERR_DISABLEHARDERR);
2318 if (dcd)
2319 {
2320 switch (SHORT2FROMMP(mp1))
2321 {
2322 case CN_CONTEXTMENU:
2323 {
2324 PCNRITEM pci = (PCNRITEM) mp2;
2325
2326 if (pci)
2327 {
2328 WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPFROMP(pci),
2329 MPFROM2SHORT(TRUE, CRA_CURSORED));
2330 MarkAll(hwnd, FALSE, FALSE, TRUE);
2331 if (pci -> attrFile & FILE_DIRECTORY)
2332 dcd -> hwndLastMenu = CheckMenu(&CollectorDirMenu,
2333 COLLECTORDIR_POPUP);
2334 else
2335 dcd -> hwndLastMenu = CheckMenu(&CollectorFileMenu,
2336 COLLECTORFILE_POPUP);
2337 }
2338 else
2339 {
2340 dcd -> hwndLastMenu = CheckMenu(&CollectorCnrMenu,
2341 COLLECTORCNR_POPUP);
2342 if (dcd -> hwndLastMenu && !dcd -> cnremphasized)
2343 {
2344 WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPVOID,
2345 MPFROM2SHORT(TRUE, CRA_SOURCE));
2346 dcd -> cnremphasized = TRUE;
2347 }
2348 }
2349 if (dcd -> hwndLastMenu)
2350 {
2351 if (dcd -> hwndLastMenu == CollectorCnrMenu)
2352 {
2353 SetViewMenu(dcd -> hwndLastMenu, dcd -> flWindowAttr);
2354 SetDetailsSwitches(dcd -> hwndLastMenu, dcd);
2355 if (dcd -> flWindowAttr & CV_MINI)
2356 WinCheckMenuItem(dcd -> hwndLastMenu, IDM_MINIICONS, TRUE);
2357 }
2358 if (!PopupMenu(hwnd, hwnd, dcd -> hwndLastMenu))
2359 {
2360 if (dcd -> cnremphasized)
2361 {
2362 WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPVOID,
2363 MPFROM2SHORT(FALSE, CRA_SOURCE));
2364 dcd -> cnremphasized = TRUE;
2365 }
2366 MarkAll(hwnd, TRUE, FALSE, TRUE);
2367 }
2368 }
2369 }
2370 break;
2371
2372 case CN_DROPHELP:
2373 if (mp2)
2374 {
2375 PDRAGINFO pDInfo;
2376 PCNRITEM pci;
2377 ULONG numitems;
2378 USHORT usOperation;
2379
2380 pci = (PCNRITEM) ((PCNRDRAGINFO) mp2) -> pRecord;
2381 pDInfo = ((PCNRDRAGINFO) mp2) -> pDragInfo;
2382 if (!DrgAccessDraginfo(pDInfo))
2383 {
2384 Win_Error(hwnd, hwnd, __FILE__, __LINE__,
2385 "%s",
2386 GetPString(IDS_DROPERRORTEXT));
2387 break;
2388 }
2389 numitems = DrgQueryDragitemCount(pDInfo);
2390 usOperation = pDInfo -> usOperation;
2391 DrgDeleteDraginfoStrHandles(pDInfo);
2392 DrgFreeDraginfo(pDInfo);
2393 saymsg(MB_ENTER | MB_ICONASTERISK,
2394 hwnd,
2395 GetPString(IDS_DROPHELPHDRTEXT),
2396 GetPString(IDS_DROPHELPTEXT),
2397 numitems,
2398 &"s"[numitems == 1L],
2399 (pci) ? NullStr : GetPString(IDS_NOTEXT),
2400 (pci) ? NullStr : " ",
2401 (pci) ? pci -> szFileName : NullStr,
2402 (pci) ? " " : NullStr,
2403 GetPString((usOperation == DO_COPY) ?
2404 IDS_COPYTEXT :
2405 (usOperation == DO_LINK) ?
2406 IDS_LINKTEXT : IDS_MOVETEXT));
2407 }
2408 return 0;
2409
2410 case CN_DRAGLEAVE:
2411 if (mp2)
2412 {
2413 PDRAGINFO pDInfo;
2414
2415 pDInfo = ((PCNRDRAGINFO) mp2) -> pDragInfo;
2416 DrgAccessDraginfo(pDInfo); /* Access DRAGINFO */
2417 DrgFreeDraginfo(pDInfo); /* Free DRAGINFO */
2418 }
2419 return 0;
2420
2421 case CN_DRAGAFTER:
2422 case CN_DRAGOVER:
2423 if (mp2)
2424 {
2425 PDRAGITEM pDItem; /* Pointer to DRAGITEM */
2426 PDRAGINFO pDInfo; /* Pointer to DRAGINFO */
2427 PCNRITEM pci;
2428 USHORT uso;
2429
2430 pci = (PCNRITEM) ((PCNRDRAGINFO) mp2) -> pRecord;
2431// if(SHORT1FROMMP(mp1) == CN_DRAGAFTER)
2432 // pci = NULL;
2433 pDInfo = ((PCNRDRAGINFO) mp2) -> pDragInfo;
2434 DrgAccessDraginfo(pDInfo); /* Access DRAGINFO */
2435 if (pci)
2436 {
2437 if (pci -> rc.flRecordAttr & CRA_SOURCE)
2438 {
2439 DrgFreeDraginfo(pDInfo);
2440 return (MRFROM2SHORT(DOR_NODROP, 0));
2441 }
2442 uso = pDInfo -> usOperation;
2443 if (uso == DO_DEFAULT)
2444 uso = (fCopyDefault) ? DO_COPY : DO_MOVE;
2445 if (!(pci -> attrFile & FILE_DIRECTORY))
2446 {
2447 if (uso != DO_LINK && uso != DO_MOVE &&
2448 uso != DO_COPY)
2449 {
2450 DrgFreeDraginfo(pDInfo);
2451 return MRFROM2SHORT(DOR_NODROP, 0);
2452 }
2453 if (uso != DO_LINK &&
2454 !(driveflags[toupper(*pci -> szFileName) - 'A'] &
2455 DRIVE_NOTWRITEABLE))
2456 {
2457 ARC_TYPE *info = NULL;
2458
2459 if (!fQuickArcFind &&
2460 !(driveflags[toupper(*pci -> szFileName) - 'A'] &
2461 DRIVE_SLOW))
2462 info = find_type(pci -> szFileName, NULL);
2463 else
2464 info = quick_find_type(pci -> szFileName, NULL);
2465 if (!info || ((uso == DO_MOVE && !info -> move) ||
2466 (uso == DO_COPY && !info -> create)))
2467 {
2468 DrgFreeDraginfo(pDInfo);
2469 return MRFROM2SHORT(DOR_NODROP, 0);
2470 }
2471 }
2472 }
2473 }
2474 pDItem = DrgQueryDragitemPtr(pDInfo, /* Access DRAGITEM */
2475 0); /* Index to DRAGITEM */
2476 if (DrgVerifyRMF(pDItem, /* Check valid rendering */
2477 DRM_OS2FILE, /* mechanisms and data */
2478 NULL))
2479 {
2480 DrgFreeDraginfo(pDInfo); /* Free DRAGINFO */
2481 if (pci)
2482 {
2483 if (driveflags[toupper(*pci -> szFileName) - 'A'] &
2484 DRIVE_NOTWRITEABLE)
2485 return MRFROM2SHORT(DOR_DROP, DO_LINK);
2486 if (toupper(*pci -> szFileName) < 'C')
2487 return MRFROM2SHORT(DOR_DROP, DO_COPY);
2488 return MRFROM2SHORT(DOR_DROP, /* Return okay to drop */
2489 ((fCopyDefault) ?
2490 DO_COPY :
2491 DO_MOVE));
2492 }
2493 else
2494 return MRFROM2SHORT(DOR_DROP, /* Return okay to drop */
2495 DO_COPY);
2496 }
2497 DrgFreeDraginfo(pDInfo); /* Free DRAGINFO */
2498 }
2499 return (MRFROM2SHORT(DOR_NODROP, 0)); /* Drop not valid */
2500
2501 case CN_INITDRAG:
2502 if (mp2)
2503 {
2504 BOOL wasemphasized = FALSE;
2505 PCNRDRAGINIT pcd = (PCNRDRAGINIT) mp2;
2506 PCNRITEM pci;
2507
2508 if (pcd)
2509 {
2510 pci = (PCNRITEM) pcd -> pRecord;
2511 if (pci)
2512 {
2513 if (pci -> rc.flRecordAttr & CRA_SELECTED)
2514 wasemphasized = TRUE;
2515 if (IsRoot(pci -> szFileName))
2516 break;
2517 if (hwndStatus2)
2518 WinSetWindowText(hwndStatus2,
2519 GetPString(IDS_DRAGFILEOBJTEXT));
2520 if (DoFileDrag(hwnd,
2521 dcd -> hwndObject,
2522 mp2,
2523 NULL,
2524 NULL,
2525 TRUE))
2526 {
2527 if (fUnHilite && wasemphasized)
2528 UnHilite(hwnd, TRUE, &dcd -> lastselection);
2529 }
2530 if (hwndStatus2)
2531 PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
2532 }
2533 }
2534 }
2535 return 0;
2536
2537 case CN_DROP:
2538 if (mp2)
2539 {
2540 LISTINFO *li;
2541 ULONG action = UM_ACTION;
2542
2543 li = DoFileDrop(hwnd, NULL, TRUE, mp1, mp2);
2544 if (li)
2545 {
2546 if (!*li -> targetpath)
2547 {
2548 li -> type = IDM_COLLECT;
2549 action = UM_COLLECT;
2550 }
2551 else
2552 {
2553 if (li -> list && li -> list[0] && IsRoot(li -> list[0]))
2554 li -> type = DO_LINK;
2555 else if (fDragndropDlg && (!*li -> arcname || !li -> info))
2556 {
2557 CHECKLIST cl;
2558
2559 memset(&cl, 0, sizeof(cl));
2560 cl.size = sizeof(cl);
2561 cl.flags = li -> type;
2562 cl.list = li -> list;
2563 cl.cmd = li -> type;
2564 cl.prompt = li -> targetpath;
2565 li -> type = WinDlgBox(HWND_DESKTOP, dcd -> hwndParent,
2566 DropListProc, FM3ModHandle,
2567 DND_FRAME, MPFROMP(&cl));
2568 if (!li -> type)
2569 {
2570 FreeListInfo(li);
2571 return 0;
2572 }
2573 li -> list = cl.list;
2574 if (!li -> list || !li -> list[0])
2575 {
2576 FreeListInfo(li);
2577 return 0;
2578 }
2579 }
2580 switch (li -> type)
2581 {
2582 case DND_LAUNCH:
2583 strcat(li -> targetpath, " %a");
2584 ExecOnList(dcd -> hwndParent, li -> targetpath,
2585 PROMPT | WINDOWED, NULL, li -> list, NULL);
2586 FreeList(li -> list);
2587 li -> list = NULL;
2588 break;
2589 case DO_LINK:
2590 if (fLinkSetsIcon)
2591 {
2592 li -> type = IDM_SETICON;
2593 action = UM_MASSACTION;
2594 }
2595 else
2596 li -> type = IDM_COMPARE;
2597 break;
2598 case DND_EXTRACT:
2599 if (*li -> targetpath && !IsFile(li -> targetpath))
2600 li -> type = IDM_EXTRACT;
2601 break;
2602 case DND_MOVE:
2603 li -> type = IDM_MOVE;
2604 if (*li -> targetpath && IsFile(li -> targetpath) == 1)
2605 {
2606 action = UM_MASSACTION;
2607 li -> type = IDM_ARCHIVEM;
2608 }
2609 break;
2610 case DND_WILDMOVE:
2611 li -> type = IDM_WILDMOVE;
2612 if (*li -> targetpath && IsFile(li -> targetpath) == 1)
2613 {
2614 action = UM_MASSACTION;
2615 li -> type = IDM_ARCHIVEM;
2616 }
2617 break;
2618 case DND_OBJECT:
2619 li -> type = IDM_OBJECT;
2620 action = UM_MASSACTION;
2621 break;
2622 case DND_SHADOW:
2623 li -> type = IDM_SHADOW;
2624 action = UM_MASSACTION;
2625 break;
2626 case DND_COMPARE:
2627 li -> type = IDM_COMPARE;
2628 break;
2629 case DND_SETICON:
2630 action = UM_MASSACTION;
2631 li -> type = IDM_SETICON;
2632 break;
2633 case DND_WILDCOPY:
2634 li -> type = IDM_WILDCOPY;
2635 if (*li -> targetpath && IsFile(li -> targetpath) == 1)
2636 {
2637 action = UM_MASSACTION;
2638 li -> type = IDM_ARCHIVE;
2639 }
2640 break;
2641 case DND_COPY:
2642 li -> type = IDM_COPY;
2643 if (*li -> targetpath && IsFile(li -> targetpath) == 1)
2644 {
2645 action = UM_MASSACTION;
2646 li -> type = IDM_ARCHIVE;
2647 }
2648 break;
2649 default:
2650 if (*li -> arcname && li -> info)
2651 {
2652 action = UM_MASSACTION;
2653 li -> type = (li -> type == DO_MOVE) ? IDM_FAKEEXTRACTM : IDM_FAKEEXTRACT;
2654 }
2655 else if (*li -> targetpath && IsFile(li -> targetpath) == 1)
2656 {
2657 action = UM_MASSACTION;
2658 li -> type = (li -> type == DO_MOVE) ? IDM_ARCHIVEM : IDM_ARCHIVE;
2659 }
2660 else
2661 li -> type = (li -> type == DO_MOVE) ? IDM_MOVE : IDM_COPY;
2662 break;
2663 }
2664 }
2665 if (!li -> list || !li -> list[0])
2666 FreeListInfo(li);
2667 else if (!PostMsg(dcd -> hwndObject, action, MPFROMP(li), MPVOID))
2668 FreeListInfo(li);
2669 else
2670 {
2671 USHORT usop = 0;
2672
2673 switch (li -> type)
2674 {
2675 case IDM_COPY:
2676 case IDM_WILDCOPY:
2677 usop = DO_COPY;
2678 break;
2679 case IDM_MOVE:
2680 case IDM_WILDMOVE:
2681 case IDM_ARCHIVEM:
2682 usop = DO_MOVE;
2683 break;
2684 }
2685 if (usop)
2686 return MRFROM2SHORT(DOR_DROP, usop);
2687 }
2688 }
2689 }
2690 return 0;
2691
2692 case CN_BEGINEDIT:
2693 case CN_REALLOCPSZ:
2694 case CN_ENDEDIT:
2695 {
2696 MRESULT mre;
2697
2698 mre = CnrDirectEdit(hwnd, msg, mp1, mp2);
2699 if (mre != (MRESULT) - 1)
2700 return mre;
2701 }
2702 break;
2703
2704 case CN_EMPHASIS:
2705 if (mp2)
2706 {
2707 PNOTIFYRECORDEMPHASIS pre = mp2;
2708 PCNRITEM pci;
2709 CHAR s[CCHMAXPATH + 91], tb[81], tf[81], *p;
2710
2711 pci = (PCNRITEM) ((pre) ? pre -> pRecord : NULL);
2712 if (!pci)
2713 {
2714 if (hwndStatus2)
2715 WinSetWindowText(hwndStatus2, NullStr);
2716 if (fMoreButtons)
2717 {
2718 WinSetWindowText(hwndName, NullStr);
2719 WinSetWindowText(hwndDate, NullStr);
2720 WinSetWindowText(hwndAttr, NullStr);
2721 }
2722 if (hwndMain)
2723 WinSendMsg(hwndMain, UM_LOADFILE, MPVOID, MPVOID);
2724 break;
2725 }
2726 if (pre -> fEmphasisMask & CRA_SELECTED)
2727 {
2728 if (pci -> rc.flRecordAttr & CRA_SELECTED)
2729 {
2730 dcd -> selectedbytes += (pci -> cbFile + pci -> easize);
2731 dcd -> selectedfiles++;
2732 }
2733 else if (dcd -> selectedfiles)
2734 {
2735 dcd -> selectedbytes -= (pci -> cbFile + pci -> easize);
2736 dcd -> selectedfiles--;
2737 }
2738 if (!dcd -> suspendview)
2739 {
2740 commafmt(tf, sizeof(tf), dcd -> selectedfiles);
2741 CommaFmtULL(tb, sizeof(tb), dcd -> selectedbytes, ' ');
2742 sprintf(s, "%s / %s", tf, tb);
2743 WinSetDlgItemText(dcd -> hwndClient, DIR_SELECTED, s);
2744 }
2745 }
2746 else if (!dcd -> suspendview &&
2747 WinQueryActiveWindow(dcd -> hwndParent) ==
2748 dcd -> hwndFrame)
2749 {
2750 if (pre -> fEmphasisMask & CRA_CURSORED)
2751 {
2752 if (pci -> rc.flRecordAttr & CRA_CURSORED)
2753 {
2754 if (fSplitStatus && hwndStatus2)
2755 {
2756 if (pci -> attrFile & FILE_DIRECTORY)
2757 p = pci -> pszFileName;
2758 else
2759 {
2760 p = strrchr(pci -> szFileName, '\\');
2761 if (p)
2762 {
2763 if (*(p + 1))
2764 p++;
2765 else
2766 p = pci -> pszFileName;
2767 }
2768 else
2769 p = pci -> pszFileName;
2770 }
2771 CommaFmtULL(tb, sizeof(tb), pci -> cbFile + pci -> easize, ' ');
2772 if (!fMoreButtons)
2773 sprintf(s, " %s %04u/%02u/%02u %02u:%02u:%02u [%s] %s",
2774 tb, pci -> date.year,
2775 pci -> date.month, pci -> date.day, pci -> time.hours,
2776 pci -> time.minutes, pci -> time.seconds,
2777 pci -> pszDispAttr, p);
2778 else
2779 {
2780 if (pci -> cbFile + pci -> easize > 1024)
2781 CommaFmtULL(tf, sizeof(tf), pci -> cbFile + pci -> easize, ' ');
2782 else
2783 *tf = 0;
2784 sprintf(s, GetPString(IDS_STATUSSIZETEXT),
2785 tb,
2786 *tf ? " (" : NullStr,
2787 tf,
2788 *tf ? ")" : NullStr);
2789 }
2790 WinSetWindowText(hwndStatus2, s);
2791 }
2792 if (fMoreButtons)
2793 {
2794 WinSetWindowText(hwndName, pci -> pszFileName);
2795 sprintf(s, "%04u/%02u/%02u %02u:%02u:%02u",
2796 pci -> date.year, pci -> date.month,
2797 pci -> date.day, pci -> time.hours, pci -> time.minutes,
2798 pci -> time.seconds);
2799 WinSetWindowText(hwndDate, s);
2800 WinSetWindowText(hwndAttr, pci -> pszDispAttr);
2801 }
2802 }
2803 }
2804 }
2805 if (!dcd -> suspendview && hwndMain &&
2806 (pre -> fEmphasisMask & CRA_CURSORED) &&
2807 (pci -> rc.flRecordAttr & CRA_CURSORED) &&
2808 WinQueryActiveWindow(dcd -> hwndParent) == dcd -> hwndFrame)
2809 WinSendMsg(hwndMain, UM_LOADFILE,
2810 MPFROMP(((fComments || (pci -> attrFile & FILE_DIRECTORY) == 0) ?
2811 pci -> szFileName : NULL)), MPVOID);
2812 }
2813 break;
2814
2815 case CN_ENTER:
2816 if (mp2)
2817 {
2818 PCNRITEM pci = (PCNRITEM) ((PNOTIFYRECORDENTER) mp2) -> pRecord;
2819 FILEFINDBUF3 ffb;
2820 HDIR hDir = HDIR_CREATE;
2821 ULONG nm = 1L;
2822 APIRET status = 0;
2823
2824 SetShiftState();
2825 if (pci)
2826 {
2827 if (pci -> rc.flRecordAttr & CRA_INUSE)
2828 break;
2829 DosError(FERR_DISABLEHARDERR);
2830 status = DosFindFirst(pci -> szFileName, &hDir,
2831 FILE_NORMAL | FILE_DIRECTORY |
2832 FILE_ARCHIVED | FILE_READONLY |
2833 FILE_HIDDEN | FILE_SYSTEM,
2834 &ffb, sizeof(ffb), &nm,
2835 FIL_STANDARD);
2836 priority_bumped();
2837 if (!status)
2838 {
2839 DosFindClose(hDir);
2840 if (ffb.attrFile & FILE_DIRECTORY)
2841 {
2842 if ((shiftstate & (KC_CTRL | KC_ALT)) ==
2843 (KC_CTRL | KC_ALT))
2844 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_SHOWALLFILES, 0),
2845 MPVOID);
2846 else if ((shiftstate & (KC_CTRL | KC_SHIFT)) ==
2847 (KC_CTRL | KC_SHIFT))
2848 OpenObject(pci -> szFileName, Settings, dcd -> hwndFrame);
2849 else if (shiftstate & KC_CTRL)
2850 OpenObject(pci -> szFileName, Default, dcd -> hwndFrame);
2851 else
2852 OpenDirCnr((HWND) 0,
2853 hwndMain,
2854 dcd -> hwndFrame,
2855 FALSE,
2856 pci -> szFileName);
2857 }
2858 else
2859 {
2860 SWP swp;
2861
2862 WinSendMsg(hwnd,
2863 CM_SETRECORDEMPHASIS,
2864 MPFROMP(pci),
2865 MPFROM2SHORT(TRUE, CRA_INUSE));
2866 WinQueryWindowPos(dcd -> hwndFrame, &swp);
2867 DefaultViewKeys(hwnd,
2868 dcd -> hwndFrame,
2869 dcd -> hwndParent,
2870 &swp,
2871 pci -> szFileName);
2872 WinSendMsg(hwnd,
2873 CM_SETRECORDEMPHASIS,
2874 MPFROMP(pci),
2875 MPFROM2SHORT(FALSE, CRA_INUSE |
2876 ((fUnHilite) ? CRA_SELECTED : 0)));
2877 }
2878 }
2879 else
2880 WinSendMsg(hwnd,
2881 CM_REMOVERECORD,
2882 MPFROMP(&pci),
2883 MPFROM2SHORT(1,
2884 CMA_FREE | CMA_INVALIDATE | CMA_ERASE));
2885 }
2886 }
2887 break;
2888 }
2889 }
2890 return 0;
2891
2892 case UM_LOADFILE:
2893 if (dcd && mp2)
2894 {
2895 HWND ret;
2896
2897 ret = StartMLEEditor(dcd -> hwndParent,
2898 (INT) mp1,
2899 (CHAR *) mp2,
2900 dcd -> hwndFrame);
2901 if (mp2)
2902 free((CHAR *) mp2);
2903 return MRFROMLONG(ret);
2904 }
2905 return 0;
2906
2907 case UM_CLOSE:
2908 WinDestroyWindow(WinQueryWindow(WinQueryWindow(hwnd, QW_PARENT),
2909 QW_PARENT));
2910 return 0;
2911
2912 case UM_FOLDUP:
2913 if (!PostMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID))
2914 DosExit(EXIT_PROCESS, 1);
2915 return 0;
2916
2917 case WM_CLOSE:
2918 if (dcd)
2919 {
2920 dcd -> namecanchange = TRUE;
2921 dcd -> stopflag = 1;
2922 if (dcd -> amextracted)
2923 return 0;
2924 }
2925 WinSendMsg(hwnd, WM_SAVEAPPLICATION, MPVOID, MPVOID);
2926 if (dcd)
2927 {
2928 if (!dcd -> dontclose && ParentIsDesktop(hwnd, dcd -> hwndParent))
2929 PostMsg(hwnd, UM_FOLDUP, MPVOID, MPVOID);
2930 if (dcd -> hwndObject)
2931 {
2932 DosSleep(64L);
2933 if (!PostMsg(dcd -> hwndObject, WM_CLOSE, MPVOID, MPVOID))
2934 WinSendMsg(dcd -> hwndObject, WM_CLOSE, MPVOID, MPVOID);
2935 }
2936 }
2937 else
2938 WinSendMsg(hwnd, UM_CLOSE, MPVOID, MPVOID);
2939 return 0;
2940
2941 case WM_DESTROY:
2942 if (CollectorDirMenu)
2943 WinDestroyWindow(CollectorDirMenu);
2944 if (CollectorFileMenu)
2945 WinDestroyWindow(CollectorFileMenu);
2946 if (CollectorCnrMenu)
2947 WinDestroyWindow(CollectorCnrMenu);
2948 CollectorCnrMenu = CollectorFileMenu = CollectorDirMenu = (HWND) 0;
2949 Collector = (HWND) 0;
2950 EmptyCnr(hwnd);
2951 break;
2952 }
2953 return (dcd && dcd -> oldproc) ? dcd -> oldproc(hwnd, msg, mp1, mp2) :
2954 PFNWPCnr(hwnd, msg, mp1, mp2);
2955}
2956
2957HWND StartCollector(HWND hwndParent, INT flags)
2958{
2959 HWND hwndFrame = (HWND) 0;
2960 HWND hwndClient;
2961 ULONG FrameFlags = FCF_TITLEBAR | FCF_SYSMENU |
2962 FCF_SIZEBORDER | FCF_MINMAX |
2963 FCF_ICON | FCF_NOBYTEALIGN |
2964 FCF_ACCELTABLE;
2965 USHORT id;
2966 DIRCNRDATA *dcd;
2967
2968 static USHORT idinc = 0;
2969
2970 if (ParentIsDesktop(hwndParent, hwndParent))
2971 FrameFlags |= (FCF_TASKLIST | FCF_SHELLPOSITION | FCF_MENU);
2972 if (Collector)
2973 {
2974 WinSetWindowPos(WinQueryWindow(WinQueryWindow(Collector,
2975 QW_PARENT),
2976 QW_PARENT),
2977 HWND_TOP,
2978 0,
2979 0,
2980 0,
2981 0,
2982 SWP_SHOW | SWP_RESTORE);
2983 return WinQueryWindow(WinQueryWindow(Collector,
2984 QW_PARENT),
2985 QW_PARENT);
2986 }
2987 hwndFrame = WinCreateStdWindow(hwndParent,
2988 WS_VISIBLE,
2989 &FrameFlags,
2990 GetPString(IDS_WCCOLLECTOR),
2991 NULL,
2992 WS_VISIBLE | fwsAnimate,
2993 FM3ModHandle,
2994 COLLECTOR_FRAME,
2995 &hwndClient);
2996 if (hwndFrame && hwndClient)
2997 {
2998 id = COLLECTOR_FRAME + idinc++;
2999 WinSetWindowUShort(hwndFrame, QWS_ID, id);
3000 dcd = malloc(sizeof(DIRCNRDATA));
3001 if (dcd)
3002 {
3003 memset(dcd, 0, sizeof(DIRCNRDATA));
3004 dcd -> size = sizeof(DIRCNRDATA);
3005 dcd -> id = id;
3006 dcd -> type = COLLECTOR_FRAME;
3007 dcd -> hwndParent = (hwndParent) ? hwndParent : HWND_DESKTOP;
3008 dcd -> hwndFrame = hwndFrame;
3009 dcd -> hwndClient = hwndClient;
3010 if (flags & 4)
3011 dcd -> dontclose = TRUE;
3012 {
3013 PFNWP oldproc;
3014
3015 oldproc = WinSubclassWindow(hwndFrame,
3016 (PFNWP) CollectorFrameWndProc);
3017 WinSetWindowPtr(hwndFrame,
3018 QWL_USER,
3019 (PVOID) oldproc);
3020 }
3021 dcd -> hwndCnr = WinCreateWindow(hwndClient,
3022 WC_CONTAINER,
3023 NULL,
3024 CCS_AUTOPOSITION | CCS_MINIICONS |
3025 CCS_MINIRECORDCORE | ulCnrType |
3026 WS_VISIBLE,
3027 0,
3028 0,
3029 0,
3030 0,
3031 hwndClient,
3032 HWND_TOP,
3033 (ULONG) COLLECTOR_CNR,
3034 NULL,
3035 NULL);
3036 if (dcd -> hwndCnr)
3037 {
3038 Collector = dcd -> hwndCnr;
3039 WinSetWindowPtr(dcd -> hwndCnr, QWL_USER, (PVOID) dcd);
3040 WinSetWindowText(hwndFrame,
3041 GetPString(IDS_COLLECTORTITLETEXT));
3042 if (FrameFlags & FCF_MENU)
3043 {
3044 if (!fToolbar)
3045 {
3046 HWND hwndMenu = WinWindowFromID(hwndFrame, FID_MENU);
3047
3048 if (hwndMenu)
3049 {
3050 WinSendMsg(hwndMenu,
3051 MM_DELETEITEM,
3052 MPFROM2SHORT(IDM_SEEALL, FALSE),
3053 MPVOID);
3054 WinSendMsg(hwndMenu,
3055 MM_DELETEITEM,
3056 MPFROM2SHORT(IDM_GREP, FALSE),
3057 MPVOID);
3058 WinSendMsg(hwndMenu,
3059 MM_DELETEITEM,
3060 MPFROM2SHORT(IDM_CLEARCNR, FALSE),
3061 MPVOID);
3062 WinSendMsg(hwndMenu,
3063 MM_DELETEITEM,
3064 MPFROM2SHORT(IDM_REMOVE, FALSE),
3065 MPVOID);
3066 }
3067 }
3068 }
3069 dcd -> oldproc = WinSubclassWindow(dcd -> hwndCnr,
3070 (PFNWP) CollectorCnrWndProc);
3071 {
3072 USHORT ids[] =
3073 {DIR_TOTALS, DIR_SELECTED, DIR_VIEW, DIR_SORT,
3074 DIR_FILTER, 0};
3075
3076 CommonCreateTextChildren(dcd -> hwndClient,
3077 GetPString(IDS_WCCOLSTATUS),
3078 ids);
3079 }
3080 if (FrameFlags & FCF_SHELLPOSITION)
3081 PostMsg(hwndClient,
3082 UM_SIZE,
3083 MPVOID,
3084 MPVOID);
3085 if (!PostMsg(dcd -> hwndCnr,
3086 UM_SETUP,
3087 MPVOID,
3088 MPVOID))
3089 WinSendMsg(dcd -> hwndCnr,
3090 UM_SETUP,
3091 MPVOID,
3092 MPVOID);
3093 }
3094 else
3095 {
3096 PostMsg(hwndClient,
3097 WM_CLOSE,
3098 MPVOID,
3099 MPVOID);
3100 free(dcd);
3101 hwndFrame = (HWND) 0;
3102 }
3103 }
3104 else
3105 {
3106 PostMsg(hwndClient,
3107 WM_CLOSE,
3108 MPVOID,
3109 MPVOID);
3110 hwndFrame = (HWND) 0;
3111 }
3112 }
3113 return hwndFrame;
3114}
Note: See TracBrowser for help on using the repository browser.