source: trunk/dll/collect.c@ 953

Last change on this file since 953 was 953, checked in by Steven Levine, 18 years ago

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