source: trunk/dll/collect.c@ 593

Last change on this file since 593 was 593, checked in by Gregg Young, 18 years ago

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