source: trunk/dll/collect.c@ 136

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

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