source: trunk/dll/collect.c@ 304

Last change on this file since 304 was 280, checked in by root, 20 years ago

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