source: trunk/dll/collect.c@ 444

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

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