source: trunk/dll/collect.c@ 145

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

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