source: trunk/dll/collect.c@ 443

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

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