source: trunk/dll/collect.c@ 194

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

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