source: trunk/dll/collect.c@ 188

Last change on this file since 188 was 186, checked in by root, 20 years ago

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