source: trunk/dll/collect.c@ 536

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

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