source: trunk/dll/collect.c@ 155

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

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