source: trunk/dll/collect.c@ 942

Last change on this file since 942 was 942, checked in by Gregg Young, 18 years ago

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