source: trunk/dll/collect.c@ 377

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

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