source: trunk/dll/collect.c@ 1844

Last change on this file since 1844 was 1836, checked in by Gregg Young, 10 years ago

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