source: trunk/dll/collect.c@ 96

Last change on this file since 96 was 96, checked in by root, 21 years ago

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