source: trunk/dll/treecnr.c@ 1830

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

Comments for CS [1827}
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 91.8 KB
Line 
1
2/***********************************************************************
3
4 $Id: treecnr.c 1828 2015-07-12 21:51:19Z gyoung $
5
6 Tree containers
7
8 Copyright (c) 1993-98 M. Kimes
9 Copyright (c) 2001-2012 Steven H. Levine
10
11 16 Oct 02 SHL Handle large partitions
12 11 Jun 03 SHL Add JFS and FAT32 support
13 25 May 05 SHL Rename comnam to szCommonName and fix typo
14 25 May 05 SHL Use ULONGLONG and CommaFmtULL
15 26 May 05 SHL More large file formatting updates
16 05 Jun 05 SHL Use QWL_USER
17 06 Aug 05 SHL Renames
18 08 Dec 05 SHL TreeCnrWndProc: disable menu items if drive not ready
19 17 Jul 06 SHL Use Runtime_Error
20 15 Aug 06 SHL Rework SetMask args
21 31 Aug 06 JS Add more partitioning menu items
22 22 Oct 06 GKY Add NDFS32 support
23 29 Dec 06 GKY Fixed menu gray out for remote drives (added variable "remote")
24 29 Dec 06 GKY Enabled edit of drive flags on "not ready" drives
25 18 Feb 07 GKY More drive type and icon support
26 08 Mar 07 SHL Ensure drive icon updates after drive flags change
27 09 Mar 07 GKY Use SelectDriveIcon
28 30 Mar 07 GKY Remove GetPString for window class names
29 06 Apr 07 GKY Work around PM DragInfo and DrgFreeDISH limits
30 06 Apr 07 GKY Add some error checking in drag/drop
31 19 Apr 07 SHL Sync with AcceptOneDrop GetOneDrop mods
32 19 Apr 07 SHL Add more drag/drop error checking
33 12 May 07 SHL Use dcd->ulItemsToUnHilite; sync with UnHilite arg mods
34 10 Jun 07 GKY Add CheckPmDrgLimit including IsFm2Window as part of work around PM drag limit
35 10 Jun 07 GKY Mouse button 3 white space click to fail silently
36 05 Jul 07 SHL Disable leftover debug code
37 02 Aug 07 SHL Sync with CNRITEM mods
38 06 Aug 07 GKY Reduce DosSleep times (ticket 148)
39 14 Aug 07 SHL Revert ShowTreeRec DosSleep to 0
40 14 Aug 07 SHL Optimze ShowTreeRec collapse - was really slow
41 20 Aug 07 GKY Move #pragma alloc_text to end for OpenWatcom compat
42 22 Aug 07 SHL Disable DbgMsgs shipped with 3.0.8beta1
43 26 Aug 07 SHL Revert to DosSleep(0)
44 22 Nov 07 GKY Use CopyPresParams to fix presparam inconsistencies in menus
45 10 Jan 08 SHL Sync with CfgDlgProc mods
46 15 Feb 08 SHL Sync with settings menu rework
47 15 Feb 08 SHL Avoid death if tree container 0 width
48 19 Jul 08 GKY Replace save_dir2(dir) with pFM2SaveDirectory
49 02 Aug 08 GKY Always pass temp variable point to UM_SHOWME to avoid freeing pci->pszFileName early
50 19 Oct 08 GKY Fixed logic for greying menu items (Format etc) on remote and virtual drives (it was reversed)
51 19 Oct 08 GKY Fixed context menu to be "drives" menu on unformatted drives
52 28 Nov 08 GKY Remove unneeded DosEnterCriSec calls
53 10 Dec 08 SHL Integrate exception handler support
54 25 Dec 08 GKY Add code to allow write verify to be turned off on a per drive basis
55 26 Dec 08 GKY Implemented DROPHELP for the tree container
56 27 Dec 08 GKY Add refresh removable media to tree container menus
57 28 Dec 08 GKY Rework partition submenu to gray out unavailable items (check for existence of files)
58 and have no default choice.
59 01 Jan 09 GKY Add Seek and Scan to drives & directory context menus pass drive/dir as search root
60 11 Jan 09 GKY Replace font names in the string file with global set at compile in init.c
61 07 Feb 09 GKY Allow user to turn off alert and/or error beeps in settings notebook.
62 07 Feb 09 GKY Add *DateFormat functions to format dates based on locale
63 07 Feb 09 GKY Eliminate Win_Error2 by moving function names to PCSZs used in Win_Error
64 08 Mar 09 GKY Renamed commafmt.h i18nutil.h
65 08 Mar 09 GKY Additional strings move to PCSZs in init.c
66 12 Mar 09 SHL Use common SearchContainer
67 14 Mar 09 GKY Prevent execution of UM_SHOWME while drive scan is occuring
68 06 Jun 09 GKY Add option to show file system type or drive label in tree
69 06 Jun 09 GKY Status line to show file sys/label not shown in tree; shortened to fit split status
70 07 Jun 09 GKY Fixed double names in tree container when collapsed tree is accessed
71 before recursive scan
72 12 Jul 09 GKY Add option to show file system type or drive label in tree
73 (get NOPRESCAN drives working)
74 22 Jul 09 GKY Code changes to use semaphores to serialize drive scanning
75 22 Jul 09 GKY Consolidated driveflag setting code in DriveFlagsOne
76 22 Jul 09 GKY Streamline scanning code for faster Tree rescans
77 14 Sep 09 SHL Drop experimental code
78 15 Sep 09 SHL Use UM_GREP when passing pathname
79 15 Nov 09 GKY Add semaphore to fix double names in tree container caused by UM_SHOWME
80 before scan completes
81 22 Nov 09 GKY Add LVM.EXE to partition submenu
82 17 JAN 10 GKY Changes to get working with Watcom 1.9 Beta (1/16/10). Mostly cast
83 CHAR CONSTANT * as CHAR *.
84 11 Apr 10 GKY Fix drive tree rescan failure and program hang caused by event sem
85 never being posted
86 20 Nov 10 GKY Rework scanning code to remove redundant scans, prevent double directory
87 entries in the tree container, fix related semaphore performance using
88 combination of event and mutex semaphores
89 04 Aug 12 GKY Fix trap reported by Ben
90 30 Dec 12 GKY Changed refresh removable media to query LVM directly to call Rediscover_PRMs (Ticket 472);
91 Also added a tree rescan following volume detach.
92 22 Feb 14 GKY Fix warn readonly yes don't ask to work when recursing directories.
93 07 Sep 14 GKY Fix tree container mis-draws (stacked icons with RWS) The problem was magnified
94 by RWS but I think the occasional extra blank directory or duplicating
95 directories is related.
96 16 Mar 15 GKY Add semaphore hmtxFiltering to prevent freeing dcd while filtering. Prevents
97 a trap when FM2 is shutdown or the container is closed while tree
98 container is still populating
99 02 May 15 GKY Changes to allow a JAVA executable object to be created using "Real object"
100 menu item on a jar file.
101 12 Jul 15 GKY Fixed trap caused by pci->pszFileName being NullStr
102
103***********************************************************************/
104
105#include <stdlib.h>
106#include <string.h>
107#include <ctype.h>
108// #include <process.h> // _beginthread
109
110#define INCL_DOS
111#define INCL_WIN
112#define INCL_LONGLONG
113#define INCL_DOSERRORS
114
115#include "fm3dll.h"
116#include "fm3dll2.h" // #define's for UM_*, control id's, etc.
117#include "treecnr.h"
118#include "mainwnd2.h" // Data declaration(s)
119#include "grep.h" // Data declaration(s)
120#include "dircnrs.h" // Data declaration(s)
121#include "info.h" // Data declaration(s)
122#include "fm3dlg.h"
123#include "fm3str.h"
124#include "mle.h"
125#include "comp.h" // COMPARE
126#include "filldir.h" // RemoveCnrItems...
127#include "errutil.h" // Dos_Error...
128#include "strutil.h" // GetPString
129#include "notebook.h" // CfgDlgProc
130#include "command.h" // RunCommand
131#include "worker.h" // Action, MassAction
132#include "mainwnd.h" // BubbleHelp, FindDirCnrByName, GetNextWindowPos
133#include "misc.h" // CnrDirectEdit, EmphasizeButton, FindDirCnr
134 // FindDirCnr, FixSwitchList, OpenEdit, QuickPopup
135 // SetSortChecks, SwitchCommand, CheckMenu
136 // CurrentRecord, IsFm2Window
137#include "common.h" // CommonCnrProc, CommonDriveCmd, CommonFrameWndProc
138 // CommonTextProc
139#include "valid.h" // CheckDrive, DriveFlagsOne, IsValidDrive
140#include "chklist.h" // DropListProc
141#include "select.h" // ExpandAll
142#include "findrec.h" // FindCnrRecord, FindParentRecord, ShowCnrRecord
143#include "flesh.h" // Flesh, UnFlesh
144#include "notify.h" // HideNote
145#include "objwin.h" // MakeObjWin
146#include "notify.h" // NotifyError
147#include "remap.h" // RemapDlgProc
148#include "saveclip.h" // SaveListDlgProc
149#include "update.h" // SelectDriveIcon, UpdateCnrList, UpdateCnrRecord
150#include "sortcnr.h" // SortTreeCnr
151#include "droplist.h" // AcceptOneDrop, CheckPmDrgLimit, DropHelp, GetOneDrop
152#include "presparm.h" // CopyPresParams
153#include "defview.h" // DefaultViewKeys
154#include "draglist.h" // DoFileDrag
155#include "filter.h" // Filter
156#include "shadow.h" // OpenObject
157#include "mkdir.h" // PMMkDir
158#include "collect.h" // StartCollector
159#include "viewer.h" // StartMLEEditor
160#include "newview.h" // StartViewer
161#include "walkem.h" // WalkAllDlgProc
162#include "i18nutil.h" // CommaFmtULL
163#include "wrappers.h" // xDosFindFirst
164#include "systemf.h" // runemf2
165#include "dirs.h" // save_dir2
166#include "fortify.h"
167#include "init.h" // GetTidForWindow
168#include "excputil.h" // xbeginthread
169#include "copyf.h" // ignorereadonly
170
171// Data definitions
172
173#pragma data_seg(GLOBAL1)
174HWND LastDir;
175HWND TreeCnrMenu;
176INT driveserial[26];
177BOOL fDCOpens;
178BOOL fDummy;
179BOOL fFollowTree;
180BOOL fTopDir;
181BOOL fLVMGui;
182BOOL fDFSee;
183BOOL fFDisk;
184BOOL fMiniLVM;
185BOOL fLVM;
186HPOINTER hptrDunno;
187HWND hwndMainMenu;
188
189#pragma data_seg(GLOBAL2)
190ULONG FM3UL;
191INT TreesortFlags;
192
193#pragma data_seg(DATA1)
194
195static PSZ pszSrcFile = __FILE__;
196static BOOL fOkayMinimize;
197
198APIRET16 APIENTRY16 Dos16MemAvail(PULONG pulAvailMem);
199
200typedef struct APPNOTIFY
201{
202 HAPP happ;
203 CHAR device;
204 struct APPNOTIFY *next;
205 struct APPNOTIFY *prev;
206}
207APPNOTIFY;
208
209MRESULT EXPENTRY OpenButtonProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
210{
211 static BOOL emphasized = FALSE;
212
213 switch (msg) {
214 case WM_CREATE:
215 {
216 MRESULT rc;
217
218 rc = PFNWPButton(hwnd, msg, mp1, mp2);
219 //fixme to allow user to change presparams 1-10-09 GKY
220 WinSetPresParam(hwnd, PP_FONTNAMESIZE,
221 strlen(FNT_8TIMESNEWROMAN) + 1,
222 (PVOID) FNT_8TIMESNEWROMAN);
223 return rc;
224 }
225
226 case WM_MOUSEMOVE:
227 BubbleHelp(hwnd, TRUE, FALSE, TRUE, GetPString(IDS_OPENBUTTONHELP));
228 break;
229
230 case WM_CONTEXTMENU:
231 PostMsg(WinQueryWindow(hwnd, QW_PARENT),
232 WM_COMMAND, MPFROM2SHORT(IDM_OPENWALK, 0), MPVOID);
233 return 0;
234
235 case DM_DRAGOVER:
236 if (!emphasized) {
237 emphasized = TRUE;
238 EmphasizeButton(hwnd, emphasized);
239 }
240 if (AcceptOneDrop(hwnd, mp1, mp2))
241 return MRFROM2SHORT(DOR_DROP, DO_MOVE);
242 return MRFROM2SHORT(DOR_NEVERDROP, 0);
243
244 case DM_DRAGLEAVE:
245 if (emphasized) {
246 emphasized = FALSE;
247 EmphasizeButton(hwnd, emphasized);
248 }
249 break;
250
251 case DM_DROPHELP:
252 DropHelp(mp1, mp2, hwnd, GetPString(IDS_OPENDROPHELP));
253 return 0;
254
255 case DM_DROP:
256 {
257 char szFrom[CCHMAXPATH + 2];
258
259 if (emphasized) {
260 emphasized = FALSE;
261 EmphasizeButton(hwnd, emphasized);
262 }
263 if (GetOneDrop(hwnd, mp1, mp2, szFrom, sizeof(szFrom))) {
264 MakeValidDir(szFrom);
265 WinSendMsg(WinQueryWindow(hwnd, QW_PARENT),
266 UM_OPENWINDOWFORME, MPFROMP(szFrom), MPVOID);
267 }
268 }
269 return 0;
270
271 }
272 return PFNWPButton(hwnd, msg, mp1, mp2);
273}
274
275VOID ShowTreeRec(HWND hwndCnr,
276 CHAR *dirname,
277 BOOL collapsefirst,
278 BOOL maketop)
279{
280 /**
281 * Find a record in tree view, move it so it shows in container and
282 * make it the current record
283 */
284
285 PCNRITEM pci, pciToSelect, pciP;
286 BOOL quickbail = FALSE;
287 CHAR szDir[CCHMAXPATH], *p;
288
289 // already positioned to requested record?
290 pci = WinSendMsg(hwndCnr,
291 CM_QUERYRECORDEMPHASIS,
292 MPFROMLONG(CMA_FIRST), MPFROMSHORT(CRA_CURSORED));
293 if (pci && (INT) pci != -1 && !stricmp(pci->pszFileName, dirname)) {
294 quickbail = TRUE; // Bypass repositioning
295 goto MakeTop;
296 }
297 WinEnableWindowUpdate(hwndCnr, FALSE);
298 pci = FindCnrRecord(hwndCnr, dirname, NULL, TRUE, FALSE, TRUE);
299 if (!pci || (INT) pci == -1) {
300 *szDir = *dirname;
301 szDir[1] = ':';
302 szDir[2] = '\\';
303 szDir[3] = 0;
304 p = szDir + 3; // Point after root backslash
305 for (;;) {
306 pciP = FindCnrRecord(hwndCnr, szDir, NULL, TRUE, FALSE, TRUE);
307 if (pciP && (INT) pciP != -1) {
308 if (!stricmp(dirname, pciP->pszFileName))
309 break; // Found it
310 if (~pciP->rc.flRecordAttr & CRA_EXPANDED)
311 WinSendMsg(hwndCnr, CM_EXPANDTREE, MPFROMP(pciP), MPVOID);
312 strcpy(szDir, dirname);
313 if (p - szDir >= strlen(szDir))
314 break; // Not root dir
315 p = strchr(p, '\\');
316 if (p) {
317 *p = 0; // fixme?
318 p++;
319 }
320 else
321 break;
322 }
323 else
324 break;
325 DosSleep(0);
326 } // for
327 pci = FindCnrRecord(hwndCnr, dirname, NULL, TRUE, FALSE, TRUE);
328 }
329 if (pci && (INT) pci != -1) {
330 if (~pci->rc.flRecordAttr & CRA_CURSORED) {
331 if (collapsefirst) {
332 pciP = WinSendMsg(hwndCnr,
333 CM_QUERYRECORD,
334 MPVOID, MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
335 while (pciP && (INT) pciP != -1) {
336#if 1 // 05 Jan 08 SHL fixme to be sure this is correct code
337 if (pciP->rc.flRecordAttr & CRA_EXPANDED) {
338 // collapse top level of all branches
339 WinSendMsg(hwndCnr, CM_COLLAPSETREE, MPFROMP(pciP), MPVOID);
340 }
341#else // fixme to be gone
342 if (toupper(*pciP->pszFileName) == toupper(*dirname)) {
343 // collapse all levels if branch is our drive
344 if (pciP->rc.flRecordAttr & CRA_EXPANDED)
345 ExpandAll(hwndCnr, FALSE, pciP);
346 }
347 else if (pciP->rc.flRecordAttr & CRA_EXPANDED) {
348 // collapse top level of all branches
349 WinSendMsg(hwndCnr, CM_COLLAPSETREE, MPFROMP(pciP), MPVOID);
350 }
351#endif
352 pciP = WinSendMsg(hwndCnr,
353 CM_QUERYRECORD,
354 MPFROMP(pciP),
355 MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
356 } // while
357 }
358 // expand all parent branches
359 pciToSelect = pci;
360 for (;;) {
361 pciP = WinSendMsg(hwndCnr,
362 CM_QUERYRECORD,
363 MPFROMP(pciToSelect),
364 MPFROM2SHORT(CMA_PARENT, CMA_ITEMORDER));
365 if (pciP && (INT) pciP != -1) {
366 if (!(pciP->rc.flRecordAttr & CRA_EXPANDED))
367 WinSendMsg(hwndCnr, CM_EXPANDTREE, MPFROMP(pciP), MPVOID);
368 pciToSelect = pciP;
369 }
370 else
371 break;
372 DosSleep(0); // Let GUI update
373 } // for
374 }
375 // make record visible
376 MakeTop:
377 pciToSelect = pci;
378 if (pciToSelect && (INT) pciToSelect != -1) {
379 //DbgMsg(pszSrcFile, __LINE__, "TOP %i %i", fTopDir, maketop);
380 if (fSwitchTreeExpand && ~pciToSelect->rc.flRecordAttr & CRA_EXPANDED)
381 WinSendMsg(hwndCnr, CM_EXPANDTREE, MPFROMP(pciToSelect), MPVOID);
382 if (fTopDir || maketop) {
383 ShowCnrRecord(hwndCnr, (PMINIRECORDCORE) pciToSelect);
384 }
385 if (!quickbail) {
386 WinSendMsg(hwndCnr,
387 CM_SETRECORDEMPHASIS,
388 MPFROMP(pciToSelect),
389 MPFROM2SHORT(TRUE, CRA_SELECTED | CRA_CURSORED));
390 }
391 }
392 }
393 WinEnableWindowUpdate(hwndCnr, TRUE);
394}
395
396MRESULT EXPENTRY TreeTitleWndProc(HWND hwnd, ULONG msg, MPARAM mp1,
397 MPARAM mp2)
398{
399 PFNWP oldproc = (PFNWP) WinQueryWindowPtr(hwnd, QWL_USER);
400
401 switch (msg) {
402 case WM_CONTEXTMENU:
403 return WinSendMsg(WinQueryWindow(hwnd, QW_PARENT),
404 UM_CONTEXTMENU, mp1, mp2);
405 }
406 return oldproc(hwnd, msg, mp1, mp2);
407}
408
409MRESULT EXPENTRY TreeStatProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
410{
411 switch (msg) {
412 case WM_CREATE:
413 return CommonTextProc(hwnd, msg, mp1, mp2);
414
415 case WM_CONTEXTMENU:
416 PostMsg(WinQueryWindow(hwnd, QW_PARENT), msg, mp1, mp2);
417 return 0;
418
419 case WM_PAINT:
420 {
421 MRESULT mr = PFNWPStatic(hwnd, msg, mp1, mp2);
422
423 PaintRecessedWindow(hwnd, (HPS) 0, FALSE, FALSE);
424 return mr;
425 }
426
427 case WM_SETFOCUS:
428 if (mp2)
429 PostMsg(hwnd, UM_FOCUSME, MPVOID, MPVOID);
430 break;
431
432 case UM_FOCUSME:
433 WinSetFocus(HWND_DESKTOP, WinQueryWindow(hwnd, QW_PARENT));
434 return 0;
435 }
436 return PFNWPStatic(hwnd, msg, mp1, mp2);
437}
438
439MRESULT EXPENTRY TreeFrameWndProc(HWND hwnd, ULONG msg, MPARAM mp1,
440 MPARAM mp2)
441{
442 switch (msg) {
443 case UM_RESCAN:
444 PostMsg(WinQueryWindow(hwnd, QW_PARENT), msg, mp1, mp2);
445 return 0;
446
447 case WM_ADJUSTWINDOWPOS:
448 {
449 SWP *pswp;
450
451 pswp = (SWP *) mp1;
452 if (ParentIsDesktop(hwnd, (HWND) 0)) {
453 if (pswp->fl & (SWP_HIDE | SWP_MINIMIZE))
454 HideNote();
455 }
456 }
457 break;
458
459 case WM_TRACKFRAME:
460 if (!fFreeTree && !ParentIsDesktop(hwnd, (HWND) 0)) {
461 switch (SHORT1FROMMP(mp1) & TF_MOVE) {
462 case TF_MOVE:
463 case TF_LEFT:
464 case TF_TOP:
465 case (TF_LEFT | TF_BOTTOM):
466 case (TF_LEFT | TF_TOP):
467 {
468 SWP swp;
469
470 WinQueryWindowPos(hwnd, &swp);
471 if (!(swp.fl & SWP_ACTIVATE))
472 WinSetWindowPos(hwnd, HWND_TOP, 0, 0, 0, 0,
473 SWP_ZORDER | SWP_ACTIVATE);
474 }
475 return 0;
476 }
477 }
478 break;
479
480 case WM_CALCFRAMERECT:
481 if (*(ULONG *) realappname != FM3UL) {
482
483 MRESULT mr;
484 PRECTL prectl;
485
486 mr = CommonFrameWndProc(TREE_CNR, hwnd, msg, mp1, mp2);
487
488 /**
489 * Calculate the position of the client rectangle.
490 * Otherwise, we'll see a lot of redraw when we move the
491 * client during WM_FORMATFRAME.
492 */
493
494 if (mr && mp2) {
495 prectl = (PRECTL) mp1;
496 prectl->yTop -= 22;
497 }
498 return mr;
499 }
500 break;
501
502 case WM_FORMATFRAME:
503 {
504 SHORT sCount;
505 PSWP pswp, pswpClient, pswpNew;
506
507 sCount = (SHORT) CommonFrameWndProc(TREE_CNR, hwnd, msg, mp1, mp2);
508
509 // Reformat the frame to "squeeze" the client
510
511 pswp = (PSWP) mp1;
512 {
513 SHORT x;
514
515 for (x = 0; x < sCount; x++) {
516 if (WinQueryWindowUShort(pswp->hwnd, QWS_ID) == FID_CLIENT) {
517 pswpClient = pswp;
518 break;
519 }
520 pswp++;
521 }
522 }
523 pswpNew = (PSWP) mp1 + sCount;
524 *pswpNew = *pswpClient;
525 pswpNew->hwnd = WinWindowFromID(hwnd, MAIN_STATUS);
526 if (*(ULONG *) realappname == FM3UL) {
527
528 PSWP pswpTitlebar = (PSWP) 0, pswpMinbutton = (PSWP) 0;
529 SHORT x;
530
531 pswpNew->hwnd = WinWindowFromID(hwnd, IDM_OPENWINDOW);
532 pswp = (PSWP) mp1;
533 for (x = 0; x < sCount; x++) {
534 if (WinQueryWindowUShort(pswp->hwnd, QWS_ID) == FID_TITLEBAR)
535 pswpTitlebar = pswp;
536 else if (WinQueryWindowUShort(pswp->hwnd, QWS_ID) == FID_MINMAX)
537 pswpMinbutton = pswp;
538 if (pswpTitlebar && pswpMinbutton)
539 break;
540 pswp++;
541 }
542 pswpNew->cy = pswpMinbutton->cy + 3;
543 pswpNew->cx = min(pswpNew->cy, (pswpMinbutton->cx / 2) + 3);
544 pswpTitlebar->cx -= (pswpNew->cx + 1);
545 pswpNew->x = pswpTitlebar->x + pswpTitlebar->cx;
546 pswpNew->y = pswpMinbutton->y - 1;
547 }
548 else {
549 pswpNew->x = pswpClient->x + 3;
550 pswpNew->y = (pswpClient->y + pswpClient->cy) - 20;
551 pswpNew->cx = pswpClient->cx - 6;
552 pswpNew->cy = 18;
553 pswpClient->cy -= 22;
554 }
555 sCount++;
556 return MRFROMSHORT(sCount);
557 }
558
559 case WM_QUERYFRAMECTLCOUNT:
560 {
561 SHORT sCount;
562
563 sCount = (SHORT) CommonFrameWndProc(TREE_CNR, hwnd, msg, mp1, mp2);
564 sCount++;
565 return MRFROMSHORT(sCount);
566 }
567 }
568 return CommonFrameWndProc(TREE_CNR, hwnd, msg, mp1, mp2);
569}
570
571MRESULT EXPENTRY TreeClientWndProc(HWND hwnd, ULONG msg, MPARAM mp1,
572 MPARAM mp2)
573{
574 switch (msg) {
575 case UM_CONTAINERHWND:
576 return MRFROMLONG(WinWindowFromID(hwnd, TREE_CNR));
577
578 case UM_VIEWSMENU:
579 return MRFROMLONG(CheckMenu(hwndMainMenu, &TreeCnrMenu, TREECNR_POPUP));
580
581 case UM_TIMER:
582 case UM_ACTION:
583 case UM_SHOWME:
584 case UM_OPENWINDOWFORME:
585 case UM_MINIMIZE:
586 case UM_MAXIMIZE:
587 case WM_INITMENU:
588 case UM_INITMENU:
589 case UM_FILTER:
590 case UM_FILESMENU:
591 case UM_UPDATERECORD:
592 case UM_UPDATERECORDLIST:
593 case MM_PORTHOLEINIT:
594 case UM_DRIVECMD:
595 case WM_CLOSE:
596 case WM_CONTROL:
597 case UM_COMMAND:
598 case WM_COMMAND:
599 return WinSendMsg(WinWindowFromID(hwnd, TREE_CNR), msg, mp1, mp2);
600
601 case WM_PSETFOCUS:
602 case WM_SETFOCUS:
603 if (mp2)
604 PostMsg(hwnd, UM_FOCUSME, MPVOID, MPVOID);
605 break;
606
607 case UM_FOCUSME:
608 WinSetFocus(HWND_DESKTOP, WinWindowFromID(hwnd, TREE_CNR));
609 break;
610
611 case WM_ERASEBACKGROUND:
612 WinFillRect((HPS) mp1, (PRECTL) mp2, 0x00d0d0d0);
613 return 0;
614
615 case WM_PAINT:
616 {
617 HPS hps;
618 RECTL rcl;
619
620 hps = WinBeginPaint(hwnd, (HPS) 0, NULL);
621 if (hps) {
622 WinQueryWindowRect(hwnd, &rcl);
623 WinFillRect(hps, &rcl, CLR_PALEGRAY);
624 PaintRecessedWindow(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
625 MAIN_STATUS), hps, FALSE, FALSE);
626 WinEndPaint(hps);
627 }
628 }
629 break;
630
631 case WM_SIZE:
632 WinSetWindowPos(WinWindowFromID(hwnd, TREE_CNR),
633 HWND_TOP,
634 0,
635 0,
636 SHORT1FROMMP(mp2),
637 SHORT2FROMMP(mp2), SWP_SHOW | SWP_MOVE | SWP_SIZE);
638 if (hwndMain)
639 PostMsg(hwndMain, UM_SIZE, MPVOID, MPVOID);
640 break;
641
642 case WM_CONTEXTMENU:
643 case UM_CONTEXTMENU:
644 PostMsg(WinWindowFromID(hwnd, TREE_CNR),
645 WM_CONTROL, MPFROM2SHORT(TREE_CNR, CN_CONTEXTMENU), MPVOID);
646 return 0;
647 }
648 return WinDefWindowProc(hwnd, msg, mp1, mp2);
649}
650
651MRESULT EXPENTRY TreeObjWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
652{
653 DIRCNRDATA *dcd;
654
655 switch (msg) {
656 case UM_SHOWME:
657 if (mp1) {
658# ifdef FORTIFY
659 Fortify_BecomeOwner(mp1);
660# endif
661 dcd = INSTDATA(hwnd);
662 if (dcd) {
663 BOOL tempsusp, tempfollow, temptop;
664
665 DosWaitEventSem(hevTreeCnrScanComplete, SEM_INDEFINITE_WAIT);
666 tempsusp = dcd->suspendview;
667 dcd->suspendview = TRUE;
668 tempfollow = fFollowTree;
669 fFollowTree = FALSE;
670 if (mp2) {
671 temptop = fTopDir;
672 fTopDir = TRUE;
673 }
674 ShowTreeRec(dcd->hwndCnr, (CHAR *)mp1, fCollapseFirst, TRUE);
675 PostMsg(hwndTree, WM_COMMAND, MPFROM2SHORT(IDM_UPDATE, 0), MPVOID);
676 dcd->suspendview = (USHORT) tempsusp;
677 fFollowTree = tempfollow;
678 if (mp2)
679 fTopDir = temptop;
680 }
681 free((CHAR *)mp1);
682 }
683 return 0;
684
685 case DM_PRINTOBJECT:
686 return MRFROMLONG(DRR_TARGET);
687
688 case DM_DISCARDOBJECT:
689 dcd = INSTDATA(hwnd);
690 if (fFM2Deletes && dcd) {
691
692 LISTINFO *li;
693 CNRDRAGINFO cni;
694
695 cni.pRecord = NULL;
696 cni.pDragInfo = (PDRAGINFO) mp1;
697 li = DoFileDrop(dcd->hwndCnr,
698 dcd->directory, FALSE, MPVOID, MPFROMP(&cni));
699 CheckPmDrgLimit(cni.pDragInfo);
700 if (li) {
701 li->type = ((fDefaultDeletePerm) ? IDM_PERMDELETE : IDM_DELETE);
702 if (!PostMsg(hwnd, UM_MASSACTION, MPFROMP(li), MPVOID))
703 FreeListInfo(li);
704 else
705 return MRFROMLONG(DRR_SOURCE);
706 }
707 }
708 return MRFROMLONG(DRR_TARGET);
709
710 case UM_EXPAND:
711 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
712 if (!dcd)
713 Runtime_Error(pszSrcFile, __LINE__, NULL);
714 else {
715 BOOL tempsusp = dcd->suspendview;
716
717 dcd->suspendview = TRUE;
718 ExpandAll(dcd->hwndCnr,
719 (SHORT1FROMMP(mp1) == IDM_EXPAND), (PCNRITEM) mp2);
720 DosSleep(1); // Fixes tree epansion (dir text and icons all placed on
721 // the same line as the drive) failure on startup using RWS
722 dcd->suspendview = (USHORT) tempsusp;
723 PostMsg(dcd->hwndCnr, UM_FILTER, MPVOID, MPVOID);
724 }
725 return 0;
726
727 case UM_UPDATERECORDLIST:
728 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
729 if (!dcd || !mp1)
730 Runtime_Error(pszSrcFile, __LINE__, NULL);
731 else {
732 INT numentries = 0;
733 CHAR **list = (CHAR **) mp1;
734
735 while (list[numentries])
736 numentries++;
737 if (numentries)
738 UpdateCnrList(dcd->hwndCnr, list, numentries, TRUE, dcd);
739 }
740 return 0;
741
742 case UM_SETUP:
743# ifdef FORTIFY
744 Fortify_EnterScope();
745# endif
746 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
747 if (!dcd)
748 Runtime_Error(pszSrcFile, __LINE__, NULL);
749 else {
750# ifdef FORTIFY
751 Fortify_BecomeOwner(dcd);
752# endif
753 dcd->hwndObject = hwnd;
754 if (ParentIsDesktop(hwnd, dcd->hwndParent))
755 DosSleep(100); //05 Aug 07 GKY 250
756 }
757 return 0;
758
759 case UM_RESCAN2:
760 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
761 if (!dcd)
762 Runtime_Error(pszSrcFile, __LINE__, NULL);
763 // Bypass if not running integrated (i.e if vtree)
764 else if (hwndStatus &&
765 dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent)) {
766 CHAR s[CCHMAXPATH * 2];
767 PCNRITEM pci = (PCNRITEM) mp1;
768 FSALLOCATE fsa;
769 struct
770 {
771 ULONG serial;
772 CHAR volumelength;
773 CHAR volumelabel[CCHMAXPATH];
774 }
775 volser;
776 CHAR tb[64];
777 CHAR szFree[64];
778 CNRINFO cnri;
779 CHAR FileSystem[CCHMAXPATH * 2];
780 CHAR szTmpLabel[CCHMAXPATH];
781 ULONG type;
782
783 strcpy(s, GetPString(IDS_TREETEXT));
784 memset(&cnri, 0, sizeof(CNRINFO));
785 cnri.cb = sizeof(CNRINFO);
786 WinSendMsg(dcd->hwndCnr,
787 CM_QUERYCNRINFO,
788 MPFROMP(&cnri), MPFROMLONG(sizeof(CNRINFO)));
789 if (cnri.cRecords) {
790 sprintf(s, GetPString(IDS_NUMDRIVESTEXT), cnri.cRecords);
791 if (pci && (INT) pci != -1 && pci->pszFileName != NullStr) { //fixme? will try checking pci->pszFileName instead of the pointer
792 if (!(driveflags[toupper(*pci->pszFileName) - 'A'] &
793 DRIVE_REMOVABLE) ||
794 driveserial[toupper(*pci->pszFileName) - 'A'] != -1) {
795 memset(&volser, 0, sizeof(volser));
796 DosError(FERR_DISABLEHARDERR);
797 if (!DosQueryFSInfo(toupper(*pci->pszFileName) - '@',
798 FSIL_VOLSER,
799 &volser,
800 (ULONG) sizeof(volser)) &&
801 dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent)) {
802 DosError(FERR_DISABLEHARDERR);
803 if (!DosQueryFSInfo(toupper(*pci->pszFileName) - '@',
804 FSIL_ALLOC, &fsa, sizeof(FSALLOCATE))) {
805 CommaFmtULL(tb, sizeof(tb),
806 (ULONGLONG) fsa.cUnitAvail * (fsa.cSectorUnit *
807 fsa.cbSector), 'M');
808 sprintf(szFree, " %s %s", tb, GetPString(IDS_FREETEXT));
809 }
810 else
811 *szFree = 0;
812 //Show information on status line not shown in the tree container
813 driveserial[toupper(*pci->pszFileName) - 'A'] = volser.serial;
814 if (CheckDrive(toupper(*pci->pszFileName), FileSystem, &type) == -1 ||
815 fShowFSTypeInTree)
816 strcpy(FileSystem, NullStr);
817 if (fShowDriveLabelInTree)
818 strcpy(szTmpLabel, NullStr);
819 else
820 strcpy(szTmpLabel, volser.volumelabel);
821 if (fSplitStatus) {
822 CHAR temp[CCHMAXPATH] = " [";
823
824 strcat(temp, s);
825 strcat(temp, "]");
826 sprintf(s,
827 GetPString(fShowFSTypeInTree ? IDS_TREESTATUSSTART1TEXT :
828 fShowDriveLabelInTree ? IDS_TREESTATUSSTART2TEXT :
829 IDS_TREESTATUSSTARTTEXT), toupper(*pci->pszFileName),
830 FileSystem, szTmpLabel, volser.serial, szFree);
831 strcat(s, temp);
832 }
833 else {
834 strcat(s, " [");
835 sprintf(&s[strlen(s)],
836 GetPString(fShowFSTypeInTree ? IDS_TREESTATUSSTART1TEXT :
837 fShowDriveLabelInTree ? IDS_TREESTATUSSTART2TEXT :
838 IDS_TREESTATUSSTARTTEXT), toupper(*pci->pszFileName),
839 FileSystem, szTmpLabel, volser.serial, szFree);
840 strcat(s, "]");
841 }
842 if (!fMoreButtons) {
843 if (*dcd->mask.szMask ||
844 (dcd->mask.attrFile != ALLATTRS ||
845 ((fFilesInTree ||
846 (driveflags[toupper(*pci->pszFileName)] &
847 DRIVE_INCLUDEFILES)) ?
848 dcd->mask.antiattr :
849 (dcd->mask.antiattr &&
850 dcd->mask.antiattr != FILE_DIRECTORY)))) {
851 sprintf(&s[strlen(s)],
852 " (%s)",
853 (*dcd->mask.szMask) ?
854 dcd->mask.szMask : GetPString(IDS_ATTRTEXT));
855 }
856 }
857 }
858 }
859 else {
860 // find root record and strip it
861 pci = FindParentRecord(dcd->hwndCnr, pci);
862 driveserial[toupper(*pci->pszFileName) - 'A'] = -1;
863 UnFlesh(dcd->hwndCnr, pci);
864 }
865 }
866 }
867 // 21 Sep 09 SHL fixme to know why checking again - focus change?
868 if (dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent))
869 WinSetWindowText(hwndStatus, s);
870 }
871 return 0;
872
873 case UM_RESCAN:
874 // populate container
875 DosWaitEventSem(hevTreeCnrScanComplete, SEM_INDEFINITE_WAIT);
876 DosResetEventSem(hevTreeCnrScanComplete, &ulScanPostCnt);
877 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
878 if (!dcd)
879 Runtime_Error(pszSrcFile, __LINE__, NULL);
880 else {
881 RemoveCnrItems(dcd->hwndCnr, NULL, 0, CMA_FREE | CMA_INVALIDATE | CMA_ERASE);
882 WinSendMsg(dcd->hwndCnr,
883 CM_SCROLLWINDOW, MPFROMSHORT(CMA_VERTICAL), MPFROMLONG(-1));
884 WinSendMsg(dcd->hwndCnr,
885 CM_SCROLLWINDOW,
886 MPFROMSHORT(CMA_HORIZONTAL), MPFROMLONG(-1));
887 FillTreeCnr(dcd->hwndCnr, dcd->hwndParent);
888 if (fOkayMinimize) {
889 PostMsg(dcd->hwndCnr, UM_MINIMIZE, MPVOID, MPVOID);
890 fOkayMinimize = FALSE;
891 }
892 WinSendMsg(dcd->hwndCnr,
893 CM_INVALIDATERECORD,
894 MPVOID, MPFROM2SHORT(0, CMA_ERASE | CMA_REPOSITION));
895 PostMsg(dcd->hwndCnr, UM_RESCAN, MPVOID, MPVOID);
896 }
897 return 0;
898
899 case UM_COMMAND:
900 if (mp1) {
901
902 LISTINFO *li = (LISTINFO *) mp1;
903
904 switch (li->type) {
905 case IDM_DOITYOURSELF:
906 case IDM_APPENDTOCLIP:
907 case IDM_SAVETOCLIP:
908 case IDM_ARCHIVE:
909 case IDM_VIEW:
910 case IDM_EDIT:
911 case IDM_OBJECT:
912 case IDM_SHADOW:
913 case IDM_SHADOW2:
914 case IDM_JAVAEXE:
915 case IDM_PRINT:
916 case IDM_ATTRS:
917 case IDM_DELETE:
918 case IDM_PERMDELETE:
919 if (li->type == IDM_DELETE)
920 ignorereadonly = FALSE;
921 if (PostMsg(hwnd, UM_MASSACTION, mp1, mp2))
922 return (MRESULT) TRUE;
923 default:
924 if (PostMsg(hwnd, UM_ACTION, mp1, mp2))
925 return (MRESULT) TRUE;
926 }
927 }
928 return 0;
929
930 case UM_MASSACTION:
931 if (mp1) {
932
933 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
934 if (!dcd)
935 Runtime_Error(pszSrcFile, __LINE__, NULL);
936 else {
937 WORKER *wk;
938# ifdef FORTIFY
939 Fortify_EnterScope();
940# endif
941 wk = xmallocz(sizeof(WORKER), pszSrcFile, __LINE__);
942 if (!wk)
943 FreeListInfo((LISTINFO *) mp1);
944 else {
945 wk->size = sizeof(WORKER);
946 wk->hwndCnr = dcd->hwndCnr;
947 wk->hwndParent = dcd->hwndParent;
948 wk->hwndFrame = dcd->hwndFrame;
949 wk->hwndClient = dcd->hwndClient;
950 wk->li = (LISTINFO *) mp1;
951 strcpy(wk->directory, dcd->directory);
952 if (xbeginthread(MassAction,
953 122880,
954 wk,
955 pszSrcFile,
956 __LINE__) == -1)
957 {
958 free(wk);
959 FreeListInfo((LISTINFO *) mp1);
960 }
961 }
962# ifdef FORTIFY
963 Fortify_LeaveScope();
964# endif
965 }
966 }
967 return 0;
968
969 case UM_ACTION:
970# ifdef FORTIFY
971 Fortify_EnterScope();
972# endif
973 if (mp1) {
974# ifdef FORTIFY
975 Fortify_BecomeOwner(mp1);
976# endif
977 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
978 if (!dcd)
979 Runtime_Error(pszSrcFile, __LINE__, NULL);
980 else {
981 WORKER *wk;
982 wk = xmallocz(sizeof(WORKER), pszSrcFile, __LINE__);
983 if (!wk)
984 FreeListInfo((LISTINFO *) mp1);
985 else {
986 wk->size = sizeof(WORKER);
987 wk->hwndCnr = dcd->hwndCnr;
988 wk->hwndParent = dcd->hwndParent;
989 wk->hwndFrame = dcd->hwndFrame;
990 wk->hwndClient = dcd->hwndClient;
991 wk->li = (LISTINFO *) mp1;
992 strcpy(wk->directory, dcd->directory);
993 if (xbeginthread(Action,
994 122880,
995 wk,
996 pszSrcFile,
997 __LINE__) == -1)
998 {
999 free(wk);
1000 FreeListInfo((LISTINFO *) mp1);
1001 }
1002 }
1003 }
1004 }
1005# ifdef FORTIFY
1006 Fortify_LeaveScope();
1007# endif
1008 return 0;
1009
1010 case WM_CLOSE:
1011 WinDestroyWindow(hwnd);
1012 break;
1013
1014 case WM_DESTROY:
1015 hwndTree = (HWND) 0;
1016 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
1017 if (dcd) {
1018 WinSendMsg(dcd->hwndCnr,
1019 UM_CLOSE, MPFROMLONG(dcd->dontclose != FALSE), MPVOID);
1020 WinSetWindowPtr(dcd->hwndCnr, QWL_USER, NULL); // 13 Apr 10 SHL Set NULL before freeing dcd
1021 free(dcd);
1022# ifdef FORTIFY
1023 Fortify_LeaveScope();
1024# endif
1025 }
1026 DosPostEventSem(CompactSem);
1027 if (!PostMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID))
1028 WinSendMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID);
1029 break;
1030 }
1031 return WinDefWindowProc(hwnd, msg, mp1, mp2);
1032}
1033
1034MRESULT EXPENTRY TreeCnrWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
1035{
1036 static APPNOTIFY *apphead = NULL, *apptail = NULL;
1037 DIRCNRDATA *dcd = INSTDATA(hwnd);
1038 PCNRITEM pci;
1039
1040 switch (msg) {
1041 case DM_PRINTOBJECT:
1042 return MRFROMLONG(DRR_TARGET);
1043
1044 case DM_DISCARDOBJECT:
1045 if (dcd)
1046 return WinSendMsg(dcd->hwndObject, msg, mp1, mp2);
1047 else
1048 return MRFROMLONG(DRR_TARGET);
1049
1050 case WM_CHAR:
1051 shiftstate = (SHORT1FROMMP(mp1) & (KC_SHIFT | KC_ALT | KC_CTRL));
1052 if (SHORT1FROMMP(mp1) & KC_KEYUP)
1053 return (MRESULT) TRUE;
1054 if (SHORT1FROMMP(mp1) & KC_VIRTUALKEY) {
1055 switch (SHORT2FROMMP(mp2)) {
1056 case VK_INSERT:
1057 if ((shiftstate & KC_CTRL) == KC_CTRL)
1058 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_MKDIR, 0), MPVOID);
1059 break;
1060 case VK_DELETE:
1061 if ((shiftstate & KC_CTRL) == KC_CTRL)
1062 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_PERMDELETE, 0), MPVOID);
1063 else if ((shiftstate & KC_SHIFT) == KC_SHIFT)
1064 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_SAVETOCLIP, 0), MPVOID);
1065 else
1066 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_DELETE, 0), MPVOID);
1067 break;
1068 } // switch
1069 }
1070
1071 if (SearchContainer(hwnd, msg, mp1, mp2))
1072 return (MRESULT)TRUE; // Avoid default handler
1073
1074 break; // Let default handler see key
1075
1076 case WM_MOUSEMOVE:
1077 case WM_BUTTON1UP:
1078 case WM_BUTTON2UP:
1079 case WM_BUTTON3UP:
1080 shiftstate = (SHORT2FROMMP(mp2) & (KC_SHIFT | KC_ALT | KC_CTRL));
1081 break;
1082
1083 case UM_TIMER:
1084 if (dcd && dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent) &&
1085 hwndStatus2) {
1086 FILEFINDBUF3L ffb;
1087 ULONG nm = 1;
1088 HDIR hdir = HDIR_CREATE;
1089
1090 if (*SwapperDat) {
1091 if (!xDosFindFirst(SwapperDat,
1092 &hdir,
1093 FILE_NORMAL | FILE_HIDDEN |
1094 FILE_SYSTEM | FILE_ARCHIVED | FILE_READONLY,
1095 &ffb, sizeof(ffb), &nm, FIL_STANDARDL)) {
1096 CHAR tb[39], tm[39], tpm[39], s[163];
1097 ULONG amem;
1098
1099 priority_bumped();
1100 DosFindClose(hdir);
1101 if (!DosQuerySysInfo(QSV_TOTAVAILMEM,
1102 QSV_TOTAVAILMEM,
1103 (PVOID) & amem, sizeof(amem))) {
1104 CommaFmtULL(tpm, sizeof(tpm), amem, 'M');
1105 }
1106 else
1107 *tpm = 0;
1108 if (!Dos16MemAvail(&amem))
1109 CommaFmtULL(tm, sizeof(tm), amem, 'M');
1110 else
1111 *tm = 0;
1112 CommaFmtULL(tb, sizeof(tb), ffb.cbFile, 'M');
1113 sprintf(s, " %s %s%s%s%s%s",
1114 GetPString(IDS_SWAPFILETEXT),
1115 tb,
1116 *tm ? GetPString(IDS_TREEMEMTEXT) : NullStr,
1117 tm, *tpm ? "/" : NullStr, tpm);
1118 WinSetWindowText(hwndStatus2, s);
1119 }
1120 else
1121 WinSetWindowText(hwndStatus2, NullStr);
1122 }
1123 else
1124 WinSetWindowText(hwndStatus2, NullStr);
1125 }
1126 // 13 Jul 09 SHL fixme to make sense
1127 if (msg == UM_TIMER)
1128 return 0;
1129 break;
1130
1131 case WM_PRESPARAMCHANGED:
1132 PresParamChanged(hwnd, PCSZ_TREECNR, mp1, mp2);
1133 break;
1134
1135 case UM_FILESMENU:
1136 {
1137 HWND menuHwnd = (HWND) 0;
1138 FSALLOCATE fsa;
1139
1140 pci = (PCNRITEM) CurrentRecord(hwnd);
1141 if (pci && (INT) pci != -1) {
1142 if (IsRoot(pci->pszFileName) || !DosQueryFSInfo(toupper(*pci->pszFileName) - '@',
1143 FSIL_ALLOC, &fsa,
1144 sizeof(FSALLOCATE)))
1145 menuHwnd = CheckMenu(hwndMainMenu, &TreeMenu, TREE_POPUP);
1146 else {
1147 menuHwnd = CheckMenu(hwndMainMenu, &DirMenu, DIR_POPUP);
1148// WinEnableMenuItem(DirMenu,
1149// IDM_TREE,
1150// FALSE);
1151 }
1152 if (!(pci->attrFile & FILE_DIRECTORY))
1153 menuHwnd = CheckMenu(hwndMainMenu, &FileMenu, FILE_POPUP);
1154 }
1155 return MRFROMLONG(menuHwnd);
1156 }
1157
1158 case UM_COMPARE:
1159 if (dcd && mp1 && mp2) {
1160
1161 COMPARE *cmp;
1162 CHAR *leftdir = (CHAR *)mp1, *rightdir = (CHAR *)mp2;
1163
1164 if (!IsFile(leftdir) && !IsFile(rightdir)) {
1165 cmp = xmallocz(sizeof(COMPARE), pszSrcFile, __LINE__);
1166 if (cmp) {
1167 cmp->size = sizeof(COMPARE);
1168 strcpy(cmp->leftdir, leftdir);
1169 strcpy(cmp->rightdir, rightdir);
1170 cmp->hwndParent = dcd->hwndParent;
1171 cmp->dcd.hwndParent = dcd->hwndParent;
1172 WinDlgBox(HWND_DESKTOP,
1173 HWND_DESKTOP,
1174 CompareDlgProc, FM3ModHandle, COMP_FRAME, MPFROMP(cmp));
1175 }
1176 }
1177 }
1178 return 0;
1179
1180 case UM_UPDATERECORDLIST:
1181 if (dcd && mp1)
1182 WinSendMsg(dcd->hwndObject, msg, mp1, mp2);
1183 return 0;
1184
1185 case UM_UPDATERECORD:
1186 if (dcd && mp1) {
1187 CHAR *filename;
1188 filename = mp1;
1189 if (filename) {
1190 UpdateCnrRecord(hwnd, filename, TRUE, dcd);
1191 }
1192 }
1193 return 0;
1194
1195 case WM_SETFOCUS:
1196 if (dcd && hwndStatus && mp2) {
1197 WinSendMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
1198 if (hwndMain)
1199 PostMsg(hwndMain, UM_ADVISEFOCUS, MPFROMLONG(dcd->hwndFrame), MPVOID);
1200 }
1201 break;
1202
1203 case UM_RESCAN:
1204
1205 if (dcd && dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent)) {
1206 // put name of our window on status line
1207
1208 PCNRITEM pci = NULL;
1209 CHAR str[CCHMAXPATH + 6];
1210
1211 if (fAutoView && hwndMain) {
1212 pci = WinSendMsg(hwnd,
1213 CM_QUERYRECORDEMPHASIS,
1214 MPFROMLONG(CMA_FIRST), MPFROMSHORT(CRA_CURSORED));
1215 if (pci && (INT) pci != -1 && fComments &&
1216 !(driveflags[toupper(*pci->pszFileName) - 'A'] & DRIVE_SLOW))
1217 WinSendMsg(hwndMain, UM_LOADFILE, MPFROMP(pci->pszFileName), MPVOID);
1218 else
1219 WinSendMsg(hwndMain, UM_LOADFILE, MPVOID, MPVOID);
1220 }
1221 if (!fAutoView || !hwndMain)
1222 pci = (PCNRITEM) WinSendMsg(hwnd,
1223 CM_QUERYRECORDEMPHASIS,
1224 MPFROMLONG(CMA_FIRST),
1225 MPFROMSHORT(CRA_CURSORED));
1226 if ((INT) pci == -1)
1227 pci = NULL;
1228 if (pci) {
1229 if (*(ULONG *) realappname == FM3UL) {
1230 sprintf(str, "%s %s", GetPString(IDS_DTTEXT), pci->pszFileName);
1231 WinSetWindowText(dcd->hwndFrame, str);
1232 WinSetWindowText(WinWindowFromID(dcd->hwndFrame, FID_TITLEBAR),
1233 str);
1234 }
1235 else
1236 WinSetWindowText(WinWindowFromID(dcd->hwndFrame,
1237 MAIN_STATUS), pci->pszFileName);
1238 if (fMoreButtons && hwndName) {
1239 CHAR szDate[DATE_BUF_BYTES];
1240
1241 DateFormat(szDate, pci->date);
1242 WinSetWindowText(hwndName, pci->pszFileName);
1243 sprintf(str, "%s %02u%s%02u%s%02u", szDate,
1244 pci->time.hours, TimeSeparator,
1245 pci->time.minutes, TimeSeparator, pci->time.seconds);
1246 WinSetWindowText(hwndDate, str);
1247 WinSetWindowText(hwndAttr, pci->pszDispAttr);
1248 }
1249 }
1250 PostMsg(dcd->hwndObject, UM_RESCAN2, MPFROMP(pci), MPVOID);
1251 if (hwndStatus2)
1252 PostMsg(hwnd, UM_TIMER, MPVOID, MPVOID);
1253 }
1254 return 0;
1255
1256 case UM_SETUP2:
1257 {
1258 PCNRITEM pci = (PCNRITEM) mp1;
1259
1260 if (pci)
1261 NotifyError(pci->pszFileName, (ULONG) mp2);
1262 }
1263 return 0;
1264
1265 case UM_SETUP:
1266# ifdef FORTIFY
1267 // Balance WM_DESTROY
1268 Fortify_EnterScope();
1269# endif
1270
1271 if (!dcd) {
1272 Runtime_Error(pszSrcFile, __LINE__, NULL);
1273 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
1274 return 0;
1275 }
1276 else {
1277 if (!dcd->hwndObject) {
1278 // first time through -- set things up
1279 CNRINFO cnri;
1280
1281# ifdef FORTIFY
1282 Fortify_EnterScope();
1283# endif
1284
1285 RestorePresParams(hwnd, PCSZ_TREECNR);
1286 memset(&cnri, 0, sizeof(CNRINFO));
1287 cnri.cb = sizeof(CNRINFO);
1288 WinSendMsg(hwnd,
1289 CM_QUERYCNRINFO,
1290 MPFROMP(&cnri), MPFROMLONG(sizeof(CNRINFO)));
1291 cnri.cyLineSpacing = 0;
1292 cnri.cxTreeIndent = 12;
1293 cnri.pSortRecord = (PVOID) SortTreeCnr;
1294 cnri.flWindowAttr &= (~(CV_NAME | CV_DETAIL | CV_TEXT));
1295 cnri.flWindowAttr |= (CV_TREE | CA_TREELINE | CV_ICON | CV_MINI);
1296 {
1297 ULONG size = sizeof(ULONG);
1298
1299 PrfQueryProfileData(fmprof,
1300 appname,
1301 "TreeflWindowAttr",
1302 (PVOID) & cnri.flWindowAttr, &size);
1303 size = sizeof(MASK);
1304 *dcd->mask.prompt = 0;
1305 if (!*dcd->mask.szMask && !dcd->mask.attrFile) {
1306 if (PrfQueryProfileSize(fmprof,
1307 appname, "TreeFilter", &size) && size) {
1308 PrfQueryProfileData(fmprof,
1309 appname, "TreeFilter", &dcd->mask, &size);
1310 SetMask(NULL, &dcd->mask);
1311 }
1312 else
1313 dcd->mask.attrFile = (FILE_READONLY | FILE_NORMAL |
1314 FILE_ARCHIVED | FILE_DIRECTORY |
1315 FILE_HIDDEN | FILE_SYSTEM);
1316 }
1317 dcd->mask.attrFile |= FILE_DIRECTORY;
1318 }
1319 cnri.flWindowAttr &= (~(CA_MIXEDTARGETEMPH | CA_ORDEREDTARGETEMPH));
1320 cnri.flWindowAttr |= CV_FLOW;
1321 dcd->flWindowAttr = cnri.flWindowAttr;
1322 WinSendMsg(hwnd,
1323 CM_SETCNRINFO,
1324 MPFROMP(&cnri),
1325 MPFROMLONG(CMA_FLWINDOWATTR | CMA_LINESPACING |
1326 CMA_CXTREEINDENT | CMA_PSORTRECORD));
1327 if (xbeginthread(MakeObjWin,
1328 327680,
1329 dcd,
1330 pszSrcFile,
1331 __LINE__) == -1)
1332 {
1333 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
1334 }
1335 else
1336 DosSleep(1);
1337# ifdef FORTIFY
1338 Fortify_LeaveScope();
1339# endif
1340 }
1341 }
1342 return 0;
1343
1344 case WM_BUTTON3CLICK:
1345 case WM_CHORD:
1346 {
1347 PCNRITEM pci = NULL;
1348 QUERYRECFROMRECT pqr;
1349 NOTIFYRECORDENTER nr;
1350 BOOL tbool = fDCOpens;
1351 RECTL rectl;
1352 POINTL ptl;
1353
1354 shiftstate = (SHORT2FROMMP(mp2) & (KC_SHIFT | KC_ALT | KC_CTRL));
1355 if (msg == WM_CHORD) {
1356 if (!WinQueryPointerPos(HWND_DESKTOP, &ptl))
1357 break;
1358 WinMapWindowPoints(HWND_DESKTOP, hwnd, &ptl, 1);
1359 }
1360 else {
1361 ptl.x = SHORT1FROMMP(mp1);
1362 ptl.y = SHORT2FROMMP(mp1);
1363 }
1364 memset(&rectl, 0, sizeof(rectl));
1365 memset(&pqr, 0, sizeof(pqr));
1366 pqr.cb = sizeof(pqr);
1367 pqr.rect.xLeft = ptl.x - 1;
1368 pqr.rect.xRight = ptl.x + 1;
1369 pqr.rect.yTop = ptl.y + 1;
1370 pqr.rect.yBottom = ptl.y - 1;
1371 pqr.fsSearch = CMA_PARTIAL;
1372 pci = (PCNRITEM) WinSendMsg(hwnd,
1373 CM_QUERYRECORDFROMRECT,
1374 MPFROMLONG(CMA_FIRST), MPFROMP(&pqr));
1375 if (!pci || (INT) pci == -1)
1376 break; //Probable B3 click on white space
1377 else {
1378 memset(&nr, 0, sizeof(nr));
1379 nr.hwndCnr = hwnd;
1380 nr.pRecord = (PRECORDCORE) pci;
1381 fDCOpens = TRUE;
1382 WinSendMsg(hwnd,
1383 WM_CONTROL,
1384 MPFROM2SHORT(WinQueryWindowUShort(hwnd,
1385 QWS_ID),
1386 CN_ENTER), MPFROMP(&nr));
1387 PostMsg(hwnd, UM_RESTOREDC, MPFROMLONG(tbool), MPVOID);
1388 }
1389 }
1390 break;
1391
1392 case UM_RESTOREDC:
1393 fDCOpens = (BOOL) mp1;
1394 return 0;
1395
1396 case WM_CONTROL:
1397 DosError(FERR_DISABLEHARDERR);
1398 if (dcd) {
1399 switch (SHORT2FROMMP(mp1)) {
1400 case CN_BEGINEDIT:
1401 case CN_REALLOCPSZ:
1402 case CN_ENDEDIT:
1403 {
1404 MRESULT mre;
1405
1406 mre = CnrDirectEdit(hwnd, msg, mp1, mp2);
1407 if (mre != (MRESULT) - 1)
1408 return mre;
1409 }
1410 break;
1411
1412 case CN_DRAGLEAVE:
1413 if (mp2) {
1414
1415 PDRAGINFO pDInfo;
1416
1417 // fixme to know why - seems superfluous
1418 pDInfo = ((PCNRDRAGINFO) mp2)->pDragInfo;
1419 DrgAccessDraginfo(pDInfo);
1420 DrgFreeDraginfo(pDInfo);
1421 }
1422 return 0;
1423
1424 case CN_DROPHELP:
1425 if (mp2) {
1426
1427 PDRAGINFO pDInfo;
1428 PCNRITEM pci;
1429 ULONG numitems;
1430 USHORT usOperation;
1431
1432 pci = (PCNRITEM) ((PCNRDRAGINFO) mp2)->pRecord;
1433 pDInfo = (PDRAGINFO) ((PCNRDRAGINFO) mp2)->pDragInfo;
1434 if (!DrgAccessDraginfo(pDInfo)) {
1435 Win_Error(hwnd, hwnd, pszSrcFile, __LINE__,
1436 GetPString(IDS_DROPERRORTEXT));
1437 }
1438 else {
1439 numitems = DrgQueryDragitemCount(pDInfo);
1440 usOperation = pDInfo->usOperation;
1441 if (usOperation == DO_DEFAULT)
1442 usOperation = fCopyDefault ? DO_COPY : DO_MOVE;
1443 FreeDragInfoData(hwnd, pDInfo);
1444 saymsg(MB_ENTER | MB_ICONASTERISK,
1445 hwnd,
1446 GetPString(IDS_DROPHELPHDRTEXT),
1447 GetPString(IDS_DROPHELPTEXT),
1448 numitems,
1449 &"s"[numitems == 1L],
1450 pci ? NullStr : GetPString(IDS_NOTEXT),
1451 pci ? NullStr : " ",
1452 pci ? pci->pszFileName : NullStr,
1453 pci ? " " : NullStr,
1454 GetPString((usOperation == DO_MOVE) ?
1455 IDS_MOVETEXT :
1456 (usOperation == DO_LINK) ?
1457 IDS_LINKTEXT : IDS_COPYTEXT));
1458 }
1459 }
1460 return 0;
1461
1462 case CN_DRAGAFTER:
1463 case CN_DRAGOVER:
1464 if (mp2) {
1465
1466 PDRAGITEM pDItem;
1467 PDRAGINFO pDInfo;
1468 PCNRITEM pci;
1469 USHORT uso;
1470
1471 pDInfo = ((PCNRDRAGINFO) mp2)->pDragInfo;
1472 if (!DrgAccessDraginfo(pDInfo)) {
1473 Win_Error(hwnd, hwnd, pszSrcFile, __LINE__,
1474 PCSZ_DRGACCESSDRAGINFO);
1475 return (MRFROM2SHORT(DOR_NODROP, 0)); // Drop not valid
1476 }
1477 pci = (PCNRITEM) ((PCNRDRAGINFO) mp2)->pRecord;
1478 if ((INT) pci == -1)
1479 pci = NULL;
1480 if (pci && (pci->flags & (RECFLAGS_ENV | RECFLAGS_NODROP))) {
1481 DrgFreeDraginfo(pDInfo);
1482 return MRFROM2SHORT(DOR_NODROP, 0);
1483 }
1484 if (!WinIsWindowEnabled(dcd->hwndFrame)) {
1485 DrgFreeDraginfo(pDInfo);
1486 return MRFROM2SHORT(DOR_NODROP, 0);
1487 }
1488 if (pci) {
1489 uso = pDInfo->usOperation;
1490 if (uso == DO_DEFAULT)
1491 uso = (fCopyDefault) ? DO_COPY : DO_MOVE;
1492 if (!(pci->attrFile & FILE_DIRECTORY)) {
1493 if (uso != DO_LINK && uso != DO_COPY && uso != DO_MOVE) {
1494 DrgFreeDraginfo(pDInfo);
1495 return (MRFROM2SHORT(DOR_NODROP, 0));
1496 }
1497 if (uso != DO_LINK &&
1498 !(driveflags[toupper(*pci->pszFileName) - 'A'] &
1499 DRIVE_NOTWRITEABLE)) {
1500
1501 ARC_TYPE *info;
1502
1503 if (!fQuickArcFind &&
1504 !(driveflags[toupper(*pci->pszFileName) - 'A'] &
1505 DRIVE_SLOW))
1506 info = find_type(pci->pszFileName, NULL);
1507 else
1508 info = quick_find_type(pci->pszFileName, NULL);
1509 if (!info || ((uso == DO_MOVE && !info->move) ||
1510 (uso == DO_COPY && !info->create))) {
1511 DrgFreeDraginfo(pDInfo);
1512 return (MRFROM2SHORT(DOR_NODROP, 0));
1513 }
1514 }
1515 }
1516 }
1517 pDItem = DrgQueryDragitemPtr(pDInfo, // Access DRAGITEM
1518 0); // Index to DRAGITEM
1519 if (DrgVerifyRMF(pDItem, // Check valid rendering
1520 (CHAR *) DRM_OS2FILE, // mechanisms and data
1521 NULL) || DrgVerifyRMF(pDItem,
1522 (CHAR *) DRM_FM2ARCMEMBER,
1523 (CHAR *) DRF_FM2ARCHIVE)) { // formats
1524 DrgFreeDraginfo(pDInfo); // Free DRAGINFO
1525 if (!pci || (INT) pci == -1)
1526 return MRFROM2SHORT(DOR_DROP, DO_MOVE);
1527 if (driveflags[toupper(*pci->pszFileName) - 'A'] &
1528 DRIVE_NOTWRITEABLE)
1529 return MRFROM2SHORT(DOR_DROP, DO_LINK);
1530 if (toupper(*pci->pszFileName) < 'C')
1531 return MRFROM2SHORT(DOR_DROP, DO_COPY);
1532 return MRFROM2SHORT(DOR_DROP, // Return okay to drop
1533 ((fCopyDefault) ? DO_COPY : DO_MOVE));
1534 }
1535 DrgFreeDraginfo(pDInfo); // Free DRAGINFO
1536 }
1537 return MRFROM2SHORT(DOR_NODROP, 0); // Drop not valid
1538
1539 case CN_INITDRAG:
1540 {
1541 PCNRDRAGINIT pcd = (PCNRDRAGINIT) mp2;
1542 PCNRITEM pci;
1543
1544 if (!pcd) {
1545 Runtime_Error(pszSrcFile, __LINE__, NULL);
1546 break;
1547 }
1548 else {
1549 pci = (PCNRITEM) pcd->pRecord;
1550 if (!pci || (INT) pci == -1) {
1551 Runtime_Error(pszSrcFile, __LINE__, NULL);
1552 break;
1553 }
1554 if (pci->flags & (RECFLAGS_ENV | RECFLAGS_NODRAG)) {
1555 Runtime_Error(pszSrcFile, __LINE__, "drag not allowed");
1556 break;
1557 }
1558 if (hwndStatus2) {
1559 WinSetWindowText(hwndStatus2, (IsRoot(pci->pszFileName)) ?
1560 (CHAR *) GetPString(IDS_DRAGROOTTEXT) :
1561 (pci->attrFile & FILE_DIRECTORY) ?
1562 (CHAR *) GetPString(IDS_DRAGDIRTEXT) :
1563 (CHAR *) GetPString(IDS_DRAGFILETEXT));
1564 }
1565 DoFileDrag(hwnd, dcd->hwndObject, mp2, NULL, NULL, TRUE);
1566 if (hwndStatus2) {
1567 PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
1568 }
1569 }
1570 }
1571 return 0;
1572
1573 case CN_DROP:
1574 {
1575 LISTINFO *li;
1576 ULONG action = UM_ACTION;
1577
1578 li = DoFileDrop(hwnd, NULL, TRUE, mp1, mp2);
1579 CheckPmDrgLimit(((PCNRDRAGINFO)mp2)->pDragInfo);
1580 if (li) {
1581 if (!*li->targetpath) {
1582 if (li->list[0])
1583 PMMkDir(dcd->hwndParent, li->list[0], FALSE);
1584 FreeListInfo(li);
1585 return 0;
1586 }
1587 if (li->list && li->list[0] && IsRoot(li->list[0]))
1588 li->type = DO_LINK;
1589 else if (fDragndropDlg && (!*li->arcname || !li->info)) {
1590
1591 CHECKLIST cl;
1592
1593 memset(&cl, 0, sizeof(cl));
1594 cl.size = sizeof(cl);
1595 cl.flags = li->type;
1596 cl.list = li->list;
1597 cl.cmd = li->type;
1598 cl.prompt = li->targetpath;
1599 li->type = WinDlgBox(HWND_DESKTOP,
1600 dcd->hwndParent,
1601 DropListProc,
1602 FM3ModHandle, DND_FRAME, MPFROMP(&cl));
1603 if (li->type == DID_ERROR)
1604 Win_Error(hwnd, HWND_DESKTOP, pszSrcFile, __LINE__,
1605 GetPString(IDS_DRAGDROPDIALOGTEXT));
1606 if (!li->type) {
1607 FreeListInfo(li);
1608 return 0;
1609 }
1610 li->list = cl.list;
1611 if (!li->list || !li->list[0]) {
1612 FreeListInfo(li);
1613 return 0;
1614 }
1615 }
1616 switch (li->type) {
1617 case DO_LINK:
1618 if (fLinkSetsIcon) {
1619 li->type = IDM_SETICON;
1620 action = UM_MASSACTION;
1621 }
1622 else
1623 li->type = IDM_COMPARE;
1624 break;
1625 case DND_EXTRACT:
1626 if (*li->targetpath && !IsFile(li->targetpath))
1627 li->type = IDM_EXTRACT;
1628 break;
1629 case DND_MOVE:
1630 li->type = IDM_MOVE;
1631 if (*li->targetpath && IsFile(li->targetpath) == 1) {
1632 action = UM_MASSACTION;
1633 li->type = IDM_ARCHIVEM;
1634 }
1635 break;
1636 case DND_WILDMOVE:
1637 li->type = IDM_WILDMOVE;
1638 if (*li->targetpath && IsFile(li->targetpath) == 1) {
1639 action = UM_MASSACTION;
1640 li->type = IDM_ARCHIVEM;
1641 }
1642 break;
1643 case DND_OBJECT:
1644 li->type = IDM_OBJECT;
1645 action = UM_MASSACTION;
1646 break;
1647 case DND_SHADOW:
1648 li->type = IDM_SHADOW;
1649 action = UM_MASSACTION;
1650 break;
1651 case DND_COMPARE:
1652 li->type = IDM_COMPARE;
1653 break;
1654 case DND_SETICON:
1655 action = UM_MASSACTION;
1656 li->type = IDM_SETICON;
1657 break;
1658 case DND_COPY:
1659 li->type = IDM_COPY;
1660 if (*li->targetpath && IsFile(li->targetpath) == 1) {
1661 action = UM_MASSACTION;
1662 li->type = IDM_ARCHIVE;
1663 }
1664 break;
1665 case DND_WILDCOPY:
1666 li->type = IDM_WILDCOPY;
1667 if (*li->targetpath && IsFile(li->targetpath) == 1) {
1668 action = UM_MASSACTION;
1669 li->type = IDM_ARCHIVE;
1670 }
1671 break;
1672 default:
1673 if (*li->arcname && li->info) {
1674 action = UM_MASSACTION;
1675 li->type = (li->type == DO_MOVE) ?
1676 IDM_FAKEEXTRACTM : IDM_FAKEEXTRACT;
1677 }
1678 else if (*li->targetpath && IsFile(li->targetpath) == 1) {
1679 action = UM_MASSACTION;
1680 li->type = (li->type == DO_MOVE) ? IDM_ARCHIVEM : IDM_ARCHIVE;
1681 }
1682 else
1683 li->type = (li->type == DO_MOVE) ? IDM_MOVE : IDM_COPY;
1684 break;
1685 }
1686 if (!li->list || !li->list[0])
1687 FreeListInfo(li);
1688 else if (!PostMsg(dcd->hwndObject, action, MPFROMP(li), MPVOID))
1689 FreeListInfo(li);
1690 else {
1691
1692 USHORT usop = 0;
1693
1694 switch (li->type) {
1695 case IDM_COPY:
1696 case IDM_WILDCOPY:
1697 usop = DO_COPY;
1698 break;
1699 case IDM_MOVE:
1700 case IDM_WILDMOVE:
1701 case IDM_ARCHIVEM:
1702 usop = DO_MOVE;
1703 break;
1704 }
1705 if (usop)
1706 return MRFROM2SHORT(DOR_DROP, usop);
1707 }
1708 }
1709 }
1710 return 0;
1711
1712 case CN_EMPHASIS:
1713 if (!fDummy) {
1714
1715 PNOTIFYRECORDEMPHASIS pre = mp2;
1716
1717 if (pre->fEmphasisMask & CRA_SELECTED) {
1718 if (pre->pRecord->flRecordAttr & CRA_SELECTED) {
1719 if (((PCNRITEM) (pre->pRecord))->attrFile & FILE_DIRECTORY) {
1720 PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
1721 if (fFollowTree &&
1722 !(driveflags
1723 [toupper(*((PCNRITEM) pre->pRecord)->pszFileName) -
1724 'A'] & DRIVE_INVALID)) {
1725 if (!LastDir && !ParentIsDesktop(hwnd, dcd->hwndParent))
1726 LastDir = FindDirCnr(dcd->hwndParent);
1727 if (LastDir) {
1728
1729 NOTIFYRECORDENTER pri;
1730 BOOL tbool = fDCOpens;
1731
1732 fDCOpens = FALSE;
1733 memset(&pri, 0, sizeof(pri));
1734 pri.hwndCnr = hwnd;
1735 pri.fKey = FALSE;
1736 pri.pRecord = pre->pRecord;
1737 WinSendMsg(hwnd,
1738 WM_CONTROL,
1739 MPFROM2SHORT(SHORT1FROMMP(mp1),
1740 CN_ENTER), MPFROMP(&pri));
1741 fDCOpens = tbool;
1742 }
1743 }
1744 if (*(ULONG *) realappname != FM3UL)
1745 WinSetWindowText(WinWindowFromID(dcd->hwndFrame,
1746 MAIN_STATUS),
1747 ((PCNRITEM) (pre->pRecord))->pszFileName);
1748 }
1749 }
1750 }
1751 }
1752 break;
1753
1754 case CN_CONTEXTMENU:
1755 {
1756 PCNRITEM pci = (PCNRITEM) mp2;
1757 BOOL wasFollowing;
1758
1759 //DosEnterCritSec(); //GKY 11-28-08
1760 wasFollowing = fFollowTree;
1761 fFollowTree = FALSE;
1762 //DosExitCritSec();
1763 if (pci && (INT) pci != -1 && !(pci->flags & RECFLAGS_ENV)) {
1764 WinSendMsg(hwnd,
1765 CM_SETRECORDEMPHASIS,
1766 MPFROMP(pci), MPFROM2SHORT(TRUE, CRA_CURSORED));
1767 MarkAll(hwnd, FALSE, FALSE, TRUE);
1768 if (!(pci->attrFile & FILE_DIRECTORY))
1769 dcd->hwndLastMenu = CheckMenu(hwndMainMenu, &FileMenu, FILE_POPUP);
1770 else if (!IsRoot(pci->pszFileName))
1771 dcd->hwndLastMenu = CheckMenu(hwndMainMenu, &DirMenu, DIR_POPUP);
1772 else
1773 dcd->hwndLastMenu = CheckMenu(hwndMainMenu, &TreeMenu, TREE_POPUP);
1774 }
1775 else {
1776 dcd->hwndLastMenu = CheckMenu(hwndMainMenu, &TreeCnrMenu, TREECNR_POPUP);
1777 if (dcd->hwndLastMenu && !dcd->cnremphasized) {
1778 WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPVOID,
1779 MPFROM2SHORT(TRUE, CRA_SOURCE));
1780 dcd->cnremphasized = TRUE;
1781 }
1782 }
1783 if (dcd->hwndLastMenu) {
1784 if (dcd->hwndLastMenu == DirMenu)
1785 WinEnableMenuItem(DirMenu, IDM_TREE, FALSE);
1786 if (dcd->hwndLastMenu == TreeCnrMenu) {
1787 if (dcd->flWindowAttr & CV_MINI)
1788 WinCheckMenuItem(dcd->hwndLastMenu, IDM_MINIICONS, TRUE);
1789 }
1790 if (!PopupMenu(hwnd, hwnd, dcd->hwndLastMenu)) {
1791 if (dcd->cnremphasized) {
1792 WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPVOID,
1793 MPFROM2SHORT(FALSE, CRA_SOURCE));
1794 dcd->cnremphasized = FALSE;
1795 }
1796 if (dcd->hwndLastMenu != TreeCnrMenu)
1797 MarkAll(hwnd, TRUE, FALSE, TRUE);
1798 }
1799 }
1800 //DosEnterCritSec(); //GKY 11-28-08
1801 fFollowTree = wasFollowing;
1802 //DosExitCritSec();
1803 }
1804 break;
1805
1806 case CN_ENTER:
1807 if (mp2) {
1808 PCNRITEM pci = (PCNRITEM) ((PNOTIFYRECORDENTER) mp2)->pRecord;
1809
1810 PostMsg(hwnd, UM_ENTER, MPFROMP(pci), MPVOID);
1811 }
1812 break;
1813
1814 case CN_COLLAPSETREE:
1815 case CN_EXPANDTREE:
1816 {
1817 PCNRITEM pci = (PCNRITEM) mp2;
1818
1819 if (pci && (INT) pci != -1 && !(pci->flags & RECFLAGS_ENV)) {
1820 if (driveflags[toupper(*pci->pszFileName) - 'A'] & DRIVE_REMOVABLE) {
1821
1822 struct
1823 {
1824 ULONG serial;
1825 CHAR volumelength;
1826 CHAR volumelabel[CCHMAXPATH];
1827 }
1828 volser;
1829
1830 memset(&volser, 0, sizeof(volser));
1831 DosError(FERR_DISABLEHARDERR);
1832 if (!DosQueryFSInfo(toupper(*pci->pszFileName) - '@',
1833 FSIL_VOLSER, &volser,
1834 (ULONG) sizeof(volser))) {
1835 if (SHORT2FROMMP(mp1) == CN_COLLAPSETREE &&
1836 !volser.serial ||
1837 driveserial[toupper(*pci->pszFileName) - 'A'] !=
1838 volser.serial)
1839 UnFlesh(hwnd, pci);
1840 if (SHORT2FROMMP(mp1) != CN_COLLAPSETREE ||
1841 (!volser.serial ||
1842 driveserial[toupper(*pci->pszFileName) - 'A'] !=
1843 volser.serial)) {
1844 if (SHORT2FROMMP(mp1) == CN_EXPANDTREE && Flesh(hwnd, pci)
1845 &&!dcd->suspendview && fTopDir) {
1846 PostMsg(hwnd, UM_TOPDIR, MPFROMP(pci), MPVOID);
1847 //DbgMsg(pszSrcFile, __LINE__, "UM_TOPDIR %p pci %p", hwnd, pci);
1848 }
1849 }
1850 driveserial[toupper(*pci->pszFileName) - 'A'] = volser.serial;
1851 }
1852 else {
1853 driveserial[toupper(*pci->pszFileName) - 'A'] = -1;
1854 UnFlesh(hwnd, pci);
1855 PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
1856 if (!fAlertBeepOff)
1857 DosBeep(250, 100);
1858 }
1859 }
1860 else if (SHORT2FROMMP(mp1) == CN_EXPANDTREE) {
1861 if (Flesh(hwnd, pci) && !dcd->suspendview && fTopDir){
1862 PostMsg(hwnd, UM_TOPDIR, MPFROMP(pci), MPVOID);
1863 //DbgMsg(pszSrcFile, __LINE__, "UM_TOPDIR %p pci %p", hwnd, pci);
1864 }
1865 }
1866 if (SHORT2FROMMP(mp1) == CN_EXPANDTREE && !dcd->suspendview){
1867 WinSendMsg(hwnd, UM_FILTER, MPVOID, MPVOID);
1868 //DbgMsg(pszSrcFile, __LINE__, "UM_FILTER %p pci %p", hwnd, pci);
1869 }
1870 }
1871 }
1872 break;
1873 } // switch WM_CONTROL
1874 }
1875 return 0;
1876
1877 case UM_ACTION:
1878 if (mp1) {
1879
1880 LISTINFO *li = mp1;
1881 ULONG action = (ULONG) mp2;
1882
1883 if (!li->list || !li->list[0] ||
1884 !PostMsg(dcd->hwndObject, action, MPFROMP(li), MPVOID))
1885 FreeListInfo(li);
1886 }
1887 return 0;
1888
1889 case UM_SHOWME:
1890 if (mp1 && dcd) {
1891 CHAR *dir = xstrdup((CHAR *)mp1, pszSrcFile, __LINE__);
1892
1893 if (dir) {
1894 if (!PostMsg(dcd->hwndObject, UM_SHOWME, MPFROMP(dir), MPVOID))
1895 free(dir);
1896 }
1897 }
1898 return 0;
1899
1900 case UM_TOPDIR:
1901 if (mp1) {
1902
1903 PCNRITEM pci = (PCNRITEM) mp1;
1904
1905 ShowCnrRecord(hwnd, (PMINIRECORDCORE) pci);
1906 }
1907 return 0;
1908
1909 case UM_ENTER:
1910 {
1911 FILEFINDBUF3 ffb;
1912 HDIR hDir = HDIR_CREATE;
1913 ULONG nm = 1;
1914 APIRET status;
1915 BOOL IsOk = FALSE;
1916 ULONG ulDriveNum, ulDriveMap;
1917 PCNRITEM pciP, pciL, pci;
1918 ULONG fl = SWP_ACTIVATE;
1919 INT x;
1920
1921 DosRequestMutexSem(hmtxScanning, SEM_INDEFINITE_WAIT);
1922 DosQueryEventSem(hevTreeCnrScanComplete, &ulScanPostCnt);
1923 if (ulScanPostCnt < 1)
1924 return 0;
1925 DosResetEventSem(hevTreeCnrScanComplete, &ulScanPostCnt);
1926 if (fFollowTree)
1927 fl = 0;
1928 SetShiftState();
1929 pci = (PCNRITEM) mp1;
1930 if (pci &&
1931 (INT) pci != -1 &&
1932 !(pci->rc.flRecordAttr & CRA_INUSE) &&
1933 !(pci->flags & RECFLAGS_ENV) && IsFullName(pci->pszFileName)) {
1934 x = (INT) (toupper(*pci->pszFileName) - 'A');
1935 if (driveflags[x] & DRIVE_INVALID) {
1936 if (!fAlertBeepOff)
1937 DosBeep(50, 100);
1938 if (hwndStatus)
1939 WinSetWindowText(hwndStatus, (CHAR *) GetPString(IDS_RESCANSUGTEXT));
1940 DosPostEventSem(hevTreeCnrScanComplete);
1941 return 0;
1942 }
1943 DosError(FERR_DISABLEHARDERR);
1944 if (!DosQCurDisk(&ulDriveNum, &ulDriveMap)) {
1945 if (!(ulDriveMap & 1 << x)) {
1946 pciL = pciP = pci;
1947 for (;;) {
1948 pciP = WinSendMsg(hwnd,
1949 CM_QUERYRECORD,
1950 MPFROMP(pciL),
1951 MPFROM2SHORT(CMA_PARENT, CMA_ITEMORDER));
1952 if (pciP && (INT) pciP != -1)
1953 pciL = pciP;
1954 else {
1955 pciP = pciL;
1956 break;
1957 }
1958 } // for
1959 RemoveCnrItems(hwnd, pciP, 1, CMA_FREE | CMA_INVALIDATE);
1960 DosPostEventSem(hevTreeCnrScanComplete);
1961 return 0;
1962 }
1963 }
1964 if (driveflags[x] & (DRIVE_REMOVABLE | DRIVE_NOPRESCAN)) {
1965
1966 struct
1967 {
1968 ULONG serial;
1969 CHAR volumelength;
1970 CHAR volumelabel[CCHMAXPATH];
1971 }
1972 volser;
1973 CHAR FileSystem[CCHMAXPATH];
1974 CHAR szBuf[CCHMAXPATH];
1975
1976 pciL = pciP = pci;
1977 for (;;) {
1978 pciP = WinSendMsg(hwnd,
1979 CM_QUERYRECORD,
1980 MPFROMP(pciL),
1981 MPFROM2SHORT(CMA_PARENT, CMA_ITEMORDER));
1982 if (pciP && (INT) pciP != -1)
1983 pciL = pciP;
1984 else {
1985 pciP = pciL;
1986 break;
1987 }
1988 }
1989 if ((driveflags[x] & DRIVE_NOPRESCAN) || (toupper(*pci->pszFileName) > 'B' &&
1990 !(driveflags[x] & DRIVE_CDROM))) {
1991 DriveFlagsOne(x, FileSystem, &volser);
1992 SelectDriveIcon(pciP);
1993 if (hwndMain)
1994 PostMsg(hwndMain, UM_BUILDDRIVEBAR, MPVOID, MPVOID);
1995 }
1996 memset(&volser, 0, sizeof(volser));
1997 DosError(FERR_DISABLEHARDERR);
1998 status = DosQueryFSInfo(toupper(*pci->pszFileName) - '@',
1999 FSIL_VOLSER, &volser,
2000 (ULONG) sizeof(volser));
2001 if (!status) {
2002 if (!volser.serial || driveserial[x] != volser.serial) {
2003 Flesh(hwnd, pciP);
2004 driveserial[x] = volser.serial;
2005 }
2006 pciL = WinSendMsg(hwnd,
2007 CM_QUERYRECORD,
2008 MPFROMP(pciP),
2009 MPFROM2SHORT(CMA_FIRSTCHILD, CMA_ITEMORDER));
2010 if (!pciL) {
2011 Flesh(hwnd, pciP);
2012 }
2013 if ((fShowFSTypeInTree || fShowDriveLabelInTree) &&
2014 strlen(pciP->pszFileName) < 4) {
2015 strcpy(szBuf, pciP->pszFileName);
2016 strcat(szBuf, " [");
2017 strcat(szBuf, fShowFSTypeInTree ? FileSystem : volser.volumelabel);
2018 strcat(szBuf, "]");
2019 pciP->pszDisplayName = xstrdup(szBuf, pszSrcFile, __LINE__);
2020 pciP->rc.pszIcon = pciP->pszDisplayName;
2021 }
2022 WinSendMsg(hwnd,
2023 CM_INVALIDATERECORD,
2024 MPFROMP(&pciP),
2025 MPFROM2SHORT(1, CMA_ERASE | CMA_REPOSITION));
2026 }
2027 else {
2028 driveserial[x] = -1;
2029 UnFlesh(hwnd, pci);
2030 PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
2031 PostMsg(hwnd, UM_SETUP2, MPFROMP(pci), MPFROMLONG(status));
2032 DosPostEventSem(hevTreeCnrScanComplete);
2033 return 0;
2034 }
2035 }
2036 status = 0;
2037 IsOk = (IsRoot(pci->pszFileName) &&
2038 IsValidDrive(toupper(*pci->pszFileName)));
2039 if (!IsOk) {
2040 DosError(FERR_DISABLEHARDERR);
2041 status = DosFindFirst(pci->pszFileName, &hDir,
2042 FILE_NORMAL | FILE_DIRECTORY |
2043 FILE_ARCHIVED | FILE_READONLY |
2044 FILE_HIDDEN | FILE_SYSTEM,
2045 &ffb, sizeof(ffb), &nm, FIL_STANDARD);
2046 priority_bumped();
2047 }
2048 if (!status) {
2049 if (!IsOk)
2050 DosFindClose(hDir);
2051 if (IsOk || (ffb.attrFile & FILE_DIRECTORY)) {
2052 if ((shiftstate & (KC_CTRL | KC_ALT)) == (KC_CTRL | KC_ALT)) {
2053 PostMsg(hwnd,
2054 WM_COMMAND, MPFROM2SHORT(IDM_SHOWALLFILES, 0), MPVOID);
2055 DosPostEventSem(hevTreeCnrScanComplete);
2056 return 0;
2057 }
2058 if ((shiftstate & (KC_CTRL | KC_SHIFT)) == (KC_CTRL | KC_SHIFT)) {
2059 OpenObject(pci->pszFileName, Settings, dcd->hwndFrame);
2060 DosPostEventSem(hevTreeCnrScanComplete);
2061 return 0;
2062 }
2063 if (!(shiftstate & (KC_CTRL | KC_SHIFT))) {
2064 if (!ParentIsDesktop(hwnd, dcd->hwndParent)) {
2065 if (FindDirCnrByName(pci->pszFileName, TRUE)) {
2066 DosPostEventSem(hevTreeCnrScanComplete);
2067 return 0;
2068 }
2069 }
2070 }
2071 if ((shiftstate & KC_CTRL) ||
2072 (!(shiftstate & KC_SHIFT) &&
2073 ParentIsDesktop(hwnd, dcd->hwndParent) && fVTreeOpensWPS)) {
2074
2075 ULONG size = sizeof(ULONG), flWindowAttr = CV_ICON;
2076 CHAR s[33];
2077
2078 strcpy(s, PCSZ_ICON);
2079 PrfQueryProfileData(fmprof,
2080 appname,
2081 "DirflWindowAttr",
2082 (PVOID) & flWindowAttr, &size);
2083 if (flWindowAttr & CV_DETAIL) {
2084 if (IsRoot(pci->pszFileName))
2085 strcpy(s, PCSZ_TREE);
2086 else
2087 strcpy(s, Details);
2088 }
2089 OpenObject(pci->pszFileName, s, dcd->hwndFrame);
2090 DosPostEventSem(hevTreeCnrScanComplete);
2091 return 0;
2092 }
2093 if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
2094 !fDCOpens && !LastDir && !(shiftstate & KC_SHIFT))
2095 LastDir = FindDirCnr(dcd->hwndParent);
2096 if (LastDir && !fDCOpens && !(shiftstate & KC_SHIFT)) {
2097 WinSendMsg(LastDir,
2098 UM_SETDIR, MPFROMP(pci->pszFileName), MPVOID);
2099 WinSetWindowPos(WinQueryWindow(WinQueryWindow(LastDir,
2100 QW_PARENT),
2101 QW_PARENT),
2102 HWND_TOP, 0, 0, 0, 0, SWP_ZORDER | fl);
2103 }
2104 else
2105 OpenDirCnr(hwnd,
2106 dcd->hwndParent,
2107 dcd->hwndFrame, FALSE, pci->pszFileName);
2108 }
2109 else {
2110 if (!(driveflags[x] & DRIVE_INCLUDEFILES))
2111 RemoveCnrItems(hwnd, pci, 1, CMA_FREE | CMA_INVALIDATE);
2112 else {
2113
2114 SWP swp;
2115
2116 WinQueryWindowPos(dcd->hwndFrame, &swp);
2117 DefaultViewKeys(hwnd,
2118 dcd->hwndFrame,
2119 dcd->hwndParent, &swp, pci->pszFileName);
2120 }
2121 }
2122 }
2123 else {
2124 if (!IsRoot(pci->pszFileName)) {
2125 NotifyError(pci->pszFileName, status);
2126 RemoveCnrItems(hwnd, pci, 1, CMA_FREE | CMA_INVALIDATE);
2127 }
2128 }
2129 }
2130 else if (!pci)
2131 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_MKDIR, 0), MPVOID);
2132 if (fFollowTree)
2133 WinSetFocus(HWND_DESKTOP, hwnd);
2134 DosPostEventSem(hevTreeCnrScanComplete);
2135 }
2136 return 0;
2137
2138 case WM_MENUEND:
2139 if (dcd) {
2140
2141 HWND hwndMenu = (HWND) mp2;
2142
2143 if (hwndMenu == TreeCnrMenu || hwndMenu == TreeMenu ||
2144 hwndMenu == DirMenu) {
2145 MarkAll(hwnd, TRUE, FALSE, TRUE);
2146 if (dcd->cnremphasized) {
2147 WinSendMsg(hwnd,
2148 CM_SETRECORDEMPHASIS,
2149 MPVOID, MPFROM2SHORT(FALSE, CRA_SOURCE));
2150 dcd->cnremphasized = FALSE;
2151 }
2152 }
2153 }
2154 break;
2155
2156 case UM_OPENWINDOWFORME:
2157 if (dcd) {
2158 if (mp1 && !IsFile((CHAR *)mp1))
2159 OpenDirCnr(hwnd, dcd->hwndParent, dcd->hwndFrame, FALSE, (char *)mp1);
2160 }
2161 return 0;
2162
2163 case MM_PORTHOLEINIT:
2164 if (dcd) {
2165 switch (SHORT1FROMMP(mp1)) {
2166 case 0:
2167 case 1:
2168 {
2169 ULONG wmsg;
2170
2171 wmsg = ((SHORT1FROMMP(mp1) == 0) ? UM_FILESMENU : UM_VIEWSMENU);
2172 PortholeInit((HWND) WinSendMsg(dcd->hwndClient,
2173 wmsg, MPVOID, MPVOID), mp1, mp2);
2174 }
2175 break;
2176 }
2177 }
2178 break;
2179
2180 case UM_INITMENU:
2181 case WM_INITMENU:
2182 if (dcd) {
2183
2184 switch (SHORT1FROMMP(mp1)) {
2185 case IDM_FILESMENU:
2186 {
2187 PCNRITEM pci;
2188
2189 pci = (PCNRITEM) CurrentRecord(hwnd);
2190 if (pci && (INT) pci != -1) {
2191 BOOL rdy;
2192 BOOL writeable;
2193 BOOL removable;
2194 BOOL local;
2195 BOOL underenv;
2196 CHAR chDrvU;
2197 CHAR szDrv[CCHMAXPATH];
2198
2199 strcpy(szDrv, pci->pszFileName);
2200 chDrvU = *pci->pszFileName;
2201 chDrvU = toupper(chDrvU);
2202 MakeValidDir(szDrv);
2203 rdy = *szDrv == chDrvU; // Drive not ready if MakeValidDir changes drive letter
2204 removable = rdy
2205 && (driveflags[chDrvU - 'A'] & DRIVE_REMOVABLE) != 0;
2206 writeable = rdy
2207 && !(driveflags[chDrvU - 'A'] & DRIVE_NOTWRITEABLE);
2208 local = rdy && (!(driveflags[chDrvU - 'A'] & (DRIVE_REMOTE | DRIVE_VIRTUAL)));
2209 underenv = (pci->flags & RECFLAGS_UNDERENV) != 0;
2210
2211 CopyPresParams((HWND) mp2, hwndMainMenu);
2212 WinEnableMenuItem((HWND) mp2, IDM_INFO, rdy);
2213
2214 WinEnableMenuItem((HWND) mp2, IDM_ATTRS, writeable);
2215 WinEnableMenuItem((HWND) mp2, IDM_EAS, writeable);
2216 WinEnableMenuItem((HWND) mp2, IDM_SUBJECT, writeable);
2217 WinEnableMenuItem((HWND) mp2, IDM_DRVFLAGS, 1); // fixme to allow if not ready
2218
2219 WinEnableMenuItem((HWND) mp2, IDM_ARCHIVE, rdy);
2220
2221 WinEnableMenuItem((HWND) mp2, IDM_UPDATE, !underenv);
2222 WinEnableMenuItem((HWND) mp2, IDM_EXPANDSUBMENU, !underenv);
2223 WinEnableMenuItem((HWND) mp2, IDM_EXPAND, !underenv);
2224 WinEnableMenuItem((HWND) mp2, IDM_COLLAPSE, !underenv);
2225
2226 WinEnableMenuItem((HWND) mp2, IDM_SIZES, rdy);
2227 WinEnableMenuItem((HWND) mp2, IDM_MKDIR, writeable);
2228 WinEnableMenuItem((HWND) mp2, IDM_SHOWALLFILES, rdy);
2229 WinEnableMenuItem((HWND) mp2, IDM_UNDELETE, writeable);
2230
2231 WinEnableMenuItem((HWND) mp2, IDM_CHKDSK, writeable && local);
2232 WinEnableMenuItem((HWND) mp2, IDM_FORMAT, writeable && local);
2233 WinEnableMenuItem((HWND) mp2, IDM_OPTIMIZE, writeable && local);
2234 WinEnableMenuItem((HWND) mp2, IDM_PARTITIONSMENU, local);
2235 WinEnableMenuItem((HWND) mp2, IDM_PARTITION, fMiniLVM);
2236 WinEnableMenuItem((HWND) mp2, IDM_PARTITIONDF, fDFSee);
2237 WinEnableMenuItem((HWND) mp2, IDM_PARTITIONLVMG, fLVMGui);
2238 WinEnableMenuItem((HWND) mp2, IDM_PARTITIONLVM, fLVM);
2239 WinEnableMenuItem((HWND) mp2, IDM_PARTITIONFD, fFDisk);
2240
2241 WinEnableMenuItem((HWND) mp2, IDM_DETACH, !local);
2242
2243 WinEnableMenuItem((HWND) mp2, IDM_EJECT, removable);
2244
2245 WinEnableMenuItem((HWND) mp2, IDM_LOCK, removable);
2246 WinEnableMenuItem((HWND) mp2, IDM_UNLOCK, removable);
2247
2248 WinEnableMenuItem((HWND) mp2, IDM_DELETE, !underenv && writeable);
2249 WinEnableMenuItem((HWND) mp2, IDM_PERMDELETE, !underenv
2250 && writeable);
2251 WinEnableMenuItem((HWND) mp2, IDM_DELETESUBMENU, !underenv
2252 && writeable);
2253 WinEnableMenuItem((HWND) mp2, IDM_MOVEMENU, !underenv
2254 && writeable);
2255 WinEnableMenuItem((HWND) mp2, IDM_RENAME, !underenv && writeable);
2256
2257 }
2258 }
2259 break;
2260
2261 case IDM_VIEWSMENU:
2262 WinCheckMenuItem((HWND) mp2,
2263 IDM_MINIICONS, ((dcd->flWindowAttr & CV_MINI) != 0));
2264 CopyPresParams((HWND) mp2, hwndMainMenu);
2265 WinEnableMenuItem((HWND) mp2, IDM_RESELECT, FALSE);
2266 WinEnableMenuItem((HWND) mp2, IDM_PARTITION, fMiniLVM);
2267 WinEnableMenuItem((HWND) mp2, IDM_PARTITIONDF, fDFSee);
2268 WinEnableMenuItem((HWND) mp2, IDM_PARTITIONLVMG, fLVMGui);
2269 WinEnableMenuItem((HWND) mp2, IDM_PARTITIONLVM, fLVM);
2270 WinEnableMenuItem((HWND) mp2, IDM_PARTITIONFD, fFDisk);
2271 break;
2272
2273 case IDM_COMMANDSMENU:
2274 SetupCommandMenu((HWND) mp2, hwnd);
2275 CopyPresParams((HWND) mp2, hwndMainMenu);
2276 break;
2277
2278 case IDM_SORTSUBMENU:
2279 SetSortChecks((HWND) mp2, TreesortFlags);
2280 CopyPresParams((HWND) mp2, hwndMainMenu);
2281 break;
2282
2283 case IDM_WINDOWSMENU:
2284 SetupWinList((HWND) mp2,
2285 (hwndMain) ? hwndMain : (HWND) 0, dcd->hwndFrame);
2286 CopyPresParams((HWND) mp2, hwndMainMenu);
2287 break;
2288 }
2289 dcd->hwndLastMenu = (HWND) mp2;
2290 }
2291 if (msg == WM_INITMENU)
2292 break;
2293 return 0;
2294
2295 case UM_COMMAND:
2296 if (!mp1)
2297 Runtime_Error(pszSrcFile, __LINE__, NULL);
2298 else {
2299 if (!dcd) {
2300 Runtime_Error(pszSrcFile, __LINE__, NULL);
2301 FreeListInfo((LISTINFO *) mp1);
2302 }
2303 else {
2304 if (!PostMsg(dcd->hwndObject, UM_COMMAND, mp1, mp2)) {
2305 Runtime_Error(pszSrcFile, __LINE__, PCSZ_POSTMSG);
2306 FreeListInfo((LISTINFO *) mp1);
2307 }
2308 else
2309 return (MRESULT) TRUE;
2310 }
2311 }
2312 return 0;
2313
2314 case UM_LOADFILE:
2315 if (dcd && mp2) {
2316
2317 HWND hwnd;
2318
2319 if ((INT)mp1 == 5 || (INT)mp1 == 13 || (INT)mp1 == 21)
2320 hwnd = StartViewer(HWND_DESKTOP, (INT)mp1,
2321 (CHAR *)mp2, dcd->hwndFrame);
2322 else
2323 hwnd = StartMLEEditor(dcd->hwndParent,
2324 (INT)mp1, (CHAR *)mp2, dcd->hwndFrame);
2325 free((CHAR *)mp2);
2326 return MRFROMLONG(hwnd);
2327 }
2328 return 0;
2329
2330 case UM_FIXCNRMLE:
2331 case UM_FIXEDITNAME:
2332 return CommonCnrProc(hwnd, msg, mp1, mp2);
2333
2334 case UM_NOTIFY:
2335 if (mp2)
2336 Notify((CHAR *)mp2);
2337 return 0;
2338
2339 case UM_FILTER:
2340 if (dcd) {
2341
2342 BOOL tempsusp = dcd->suspendview;
2343
2344 if (mp1)
2345 SetMask((CHAR *)mp1, &dcd->mask);
2346
2347 dcd->suspendview = TRUE;
2348 dcd->mask.attrFile |= FILE_DIRECTORY;
2349 WinSendMsg(hwnd, CM_FILTER, MPFROMP(Filter), MPFROMP(&dcd->mask));
2350 dcd->suspendview = (USHORT) tempsusp;
2351 PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
2352 //DbgMsg(pszSrcFile, __LINE__, "UM_RESCAN %p pci %s", hwnd, (CHAR *) mp1);
2353 }
2354 return 0;
2355
2356 case UM_DRIVECMD:
2357 if (mp1) {
2358 ShowTreeRec(hwnd, (CHAR *)mp1, FALSE, TRUE);
2359 PostMsg(hwndTree, WM_COMMAND, MPFROM2SHORT(IDM_UPDATE, 0), MPVOID);
2360 }
2361 return 0;
2362
2363 case WM_APPTERMINATENOTIFY:
2364 {
2365 APPNOTIFY *info;
2366 PCNRITEM pci;
2367 CHAR s[] = " :\\";
2368
2369 if (!mp2) {
2370 if (hwndMain)
2371 PostMsg(hwndMain, UM_BUILDDRIVEBAR, MPVOID, MPVOID);
2372 }
2373 info = apphead;
2374 while (info) {
2375 if (info->happ == (HAPP) mp1) {
2376 *s = info->device;
2377 pci = FindCnrRecord(hwnd, s, NULL, FALSE, FALSE, TRUE);
2378 if (pci && (INT) pci != -1) {
2379 INT x = info->device - 'A';
2380 CHAR FileSystem[CCHMAXPATH];
2381
2382 driveserial[x] = -1;
2383 DriveFlagsOne(x, FileSystem, NULL);
2384 if (driveflags[x] &
2385 (DRIVE_INVALID | DRIVE_IGNORE))
2386 RemoveCnrItems(hwnd, pci, 1, CMA_FREE);
2387 else
2388 Flesh(hwnd, pci);
2389 }
2390 if (info->prev)
2391 info->prev->next = info->next;
2392 if (info->next)
2393 info->next->prev = info->prev;
2394 if (apphead == info)
2395 apphead = info->next;
2396 if (apptail == info)
2397 apptail = info->prev;
2398 free(info);
2399 break;
2400 }
2401 info = info->next;
2402 }
2403 }
2404 break;
2405
2406 case WM_COMMAND:
2407 DosError(FERR_DISABLEHARDERR);
2408 if (dcd) {
2409 if (SwitchCommand(dcd->hwndLastMenu, SHORT1FROMMP(mp1)))
2410 return 0;
2411 switch (SHORT1FROMMP(mp1)) {
2412 case IDM_SETTARGET:
2413 SetTargetDir(hwnd, FALSE, NULL);
2414 break;
2415
2416 case IDM_DETACH:
2417 {
2418 CHAR d[3] = " :";
2419 PCNRITEM pci;
2420 PROGDETAILS pgd;
2421 CHAR params[368], *p;
2422 HAPP happ;
2423
2424 pci = (PCNRITEM) CurrentRecord(hwnd);
2425 if (pci && (INT) pci != -1 && isalpha(*pci->pszFileName)) {
2426 *d = toupper(*pci->pszFileName);
2427 p = GetCmdSpec(FALSE);
2428 memset(&pgd, 0, sizeof(pgd));
2429 pgd.Length = sizeof(pgd);
2430 pgd.progt.progc = PROG_WINDOWABLEVIO;
2431 pgd.progt.fbVisible = SHE_VISIBLE;
2432 pgd.pszTitle = (PSZ)GetPString(IDS_DETACHREQUESTTEXT);
2433 pgd.pszExecutable = p;
2434 pgd.pszParameters = params;
2435 pgd.pszStartupDir = NULL;
2436 pgd.pszIcon = NULL;
2437 pgd.pszEnvironment = NULL;
2438 pgd.swpInitial.hwndInsertBehind = HWND_TOP;
2439 pgd.swpInitial.hwnd = hwnd;
2440 pgd.swpInitial.fl = SWP_SHOW | SWP_ACTIVATE;
2441 sprintf(params, "/C NET USE %s /D", d);
2442 happ = WinStartApp(hwnd, &pgd, pgd.pszParameters,
2443 NULL, SAF_MAXIMIZED);
2444 if (!happ) {
2445 saymsg(MB_CANCEL | MB_ICONEXCLAMATION, hwnd,
2446 GetPString(IDS_ERRORTEXT),
2447 GetPString(IDS_CANTSTARTTEXT), p, params);
2448 }
2449 else {
2450 APPNOTIFY *info;
2451
2452 info = xmallocz(sizeof(APPNOTIFY), pszSrcFile, __LINE__);
2453 if (info) {
2454 info->happ = happ;
2455 info->device = *d;
2456 if (!apphead)
2457 apphead = info;
2458 else {
2459 apptail->next = info;
2460 info->prev = apptail;
2461 }
2462 apptail = info;
2463 }
2464 PostMsg(hwndTree, WM_COMMAND, MPFROM2SHORT(IDM_RESCAN, 0), MPVOID);
2465 }
2466 }
2467 }
2468 break;
2469
2470 case IDM_REMAP:
2471 WinDlgBox(HWND_DESKTOP, hwnd, RemapDlgProc,
2472 FM3ModHandle, MAP_FRAME, NULL);
2473 break;
2474
2475 case IDM_CONTEXTMENU:
2476 {
2477 PCNRITEM pci;
2478
2479 pci = (PCNRITEM) CurrentRecord(hwnd);
2480 PostMsg(hwnd, WM_CONTROL, MPFROM2SHORT(DIR_CNR, CN_CONTEXTMENU),
2481 MPFROMP(pci));
2482 }
2483 break;
2484
2485 case IDM_FINDINTREE:
2486 {
2487 PSZ pszTempDir;
2488 PCNRITEM pci;
2489
2490 pci = (PCNRITEM) CurrentRecord(hwnd);
2491 if (pci && (INT) pci != -1) {
2492 pszTempDir = xstrdup(pci->pszFileName, pszSrcFile, __LINE__);
2493 if (pszTempDir)
2494 MakeValidDir(pszTempDir);
2495 }
2496 else
2497 pszTempDir = xstrdup(pFM2SaveDirectory, pszSrcFile, __LINE__);
2498 if (pszTempDir) {
2499 if (WinDlgBox(HWND_DESKTOP, dcd->hwndParent,
2500 WalkAllDlgProc,
2501 FM3ModHandle, WALK_FRAME, MPFROMP(pszTempDir))) {
2502 if (!WinSendMsg(hwnd, UM_SHOWME, MPFROMP(pszTempDir), MPFROMLONG(1)))
2503 free(pszTempDir);
2504 }
2505 else
2506 free(pszTempDir);
2507 }
2508 }
2509 break;
2510
2511 case IDM_BEGINEDIT:
2512 OpenEdit(hwnd);
2513 break;
2514
2515 case IDM_ENDEDIT:
2516 WinSendMsg(hwnd, CM_CLOSEEDIT, MPVOID, MPVOID);
2517 break;
2518
2519 case IDM_FILTER:
2520 {
2521 BOOL empty = FALSE;
2522 PCNRITEM pci;
2523
2524 pci = (PCNRITEM) CurrentRecord(hwnd);
2525 if (!*dcd->mask.szMask)
2526 empty = TRUE;
2527 dcd->mask.fIsTree = TRUE;
2528 *dcd->mask.prompt = 0;
2529 if (pci && (INT) pci != -1)
2530 dcd->mask.fFilesIncluded =
2531 ((driveflags[toupper(*pci->pszFileName) - 'A'] &
2532 DRIVE_INCLUDEFILES) != 0);
2533 else
2534 dcd->mask.fFilesIncluded = FALSE;
2535 if (WinDlgBox(HWND_DESKTOP, hwnd, PickMaskDlgProc,
2536 FM3ModHandle, MSK_FRAME, MPFROMP(&dcd->mask)))
2537 WinSendMsg(hwnd, UM_FILTER, MPVOID, MPVOID);
2538 else if (empty)
2539 *dcd->mask.szMask = 0;
2540 PrfWriteProfileData(fmprof, appname, "TreeFilter", &dcd->mask,
2541 sizeof(MASK));
2542 }
2543 break;
2544
2545 case IDM_SHOWSORT:
2546 QuickPopup(hwnd, dcd, CheckMenu(hwndMainMenu, &TreeCnrMenu, TREECNR_POPUP),
2547 IDM_SORTSUBMENU);
2548 break;
2549
2550 case IDM_SHOWSELECT:
2551 QuickPopup(hwnd, dcd, CheckMenu(hwndMainMenu, &TreeCnrMenu, TREECNR_POPUP),
2552 IDM_SELECTSUBMENU);
2553 break;
2554
2555 case IDM_TREECNRVIEWSETTINGS:
2556 if (!ParentIsDesktop(dcd->hwndParent, dcd->hwndParent))
2557 PostMsg(dcd->hwndParent, msg, MPFROMLONG(IDM_TREECNRVIEWSETTINGS), mp2);
2558 else {
2559 WinDlgBox(HWND_DESKTOP,
2560 hwnd,
2561 CfgDlgProc,
2562 FM3ModHandle,
2563 CFG_FRAME,
2564 MPFROMLONG(IDM_TREECNRVIEWSETTINGS));
2565 }
2566 break;
2567
2568 case IDM_WALKDIR:
2569 case IDM_OPENWALK:
2570 {
2571 CHAR newpath[CCHMAXPATH];
2572 PCNRITEM pci;
2573
2574 pci = (PCNRITEM) CurrentRecord(hwnd);
2575 if (pci && (INT) pci != -1) {
2576 strcpy(newpath, pci->pszFileName);
2577 MakeValidDir(newpath);
2578 }
2579 else
2580 strcpy(newpath, pFM2SaveDirectory);
2581 if (!WinDlgBox(HWND_DESKTOP, dcd->hwndParent, WalkAllDlgProc,
2582 FM3ModHandle, WALK_FRAME,
2583 MPFROMP(newpath)) || !*newpath)
2584 break;
2585 WinSendMsg(hwnd, UM_OPENWINDOWFORME, MPFROMP(newpath), MPVOID);
2586 }
2587 break;
2588
2589 case IDM_HELP:
2590 if (hwndHelp) {
2591 if (!ParentIsDesktop(dcd->hwndFrame, dcd->hwndParent))
2592 PostMsg(dcd->hwndParent, UM_COMMAND, mp1, mp2);
2593 else
2594 WinSendMsg(hwndHelp, HM_HELP_CONTENTS, MPVOID, MPVOID);
2595 }
2596 break;
2597
2598 case IDM_PARTITION:
2599 runemf2(SEPARATE | WINDOWED, HWND_DESKTOP, pszSrcFile, __LINE__,
2600 NULL, NULL,
2601 "%s", PCSZ_MINILVMEXE);
2602 break;
2603
2604 case IDM_PARTITIONDF:
2605 runemf2(SEPARATE | WINDOWED, HWND_DESKTOP, pszSrcFile, __LINE__,
2606 NULL, NULL,
2607 "%s", PCSZ_DFSOS2EXE);
2608 break;
2609
2610 case IDM_PARTITIONLVMG:
2611 runemf2(SEPARATE | WINDOWED, HWND_DESKTOP, pszSrcFile, __LINE__,
2612 NULL, NULL,
2613 "%s", PCSZ_LVMGUICMD);
2614 break;
2615
2616 case IDM_PARTITIONLVM:
2617 runemf2(SEPARATE | WINDOWED, HWND_DESKTOP, pszSrcFile, __LINE__,
2618 NULL, NULL,
2619 "%s", PCSZ_LVMEXE);
2620 break;
2621
2622 case IDM_PARTITIONFD:
2623 runemf2(SEPARATE | WINDOWED, HWND_DESKTOP, pszSrcFile, __LINE__,
2624 NULL, NULL,
2625 "%s", PCSZ_FDISKPMEXE);
2626 break;
2627
2628 case IDM_REFRESHREMOVABLES:
2629 {
2630 PFN Rediscover_PRMs;
2631 HMODULE hmod = 0;
2632 APIRET rc;
2633 CHAR objerr[CCHMAXPATH];
2634
2635 rc = DosLoadModule(objerr, sizeof(objerr), "LVM", &hmod);
2636 if (!rc) {
2637 rc = DosQueryProcAddr(hmod, 70, NULL, &Rediscover_PRMs);
2638 if (!rc)
2639 Rediscover_PRMs(&rc);
2640 DosFreeModule(hmod);
2641 }
2642 if (!rc)
2643 PostMsg(hwndTree, WM_COMMAND, MPFROM2SHORT(IDM_RESCAN, 0), MPVOID);
2644 break;
2645 }
2646
2647 case IDM_SORTNAME:
2648 case IDM_SORTFILENAME:
2649 case IDM_SORTSIZE:
2650 case IDM_SORTEASIZE:
2651 case IDM_SORTFIRST:
2652 case IDM_SORTLAST:
2653 case IDM_SORTLWDATE:
2654 case IDM_SORTLADATE:
2655 case IDM_SORTCRDATE:
2656 TreesortFlags &= (SORT_REVERSE | SORT_DIRSFIRST | SORT_DIRSLAST);
2657 case IDM_SORTDIRSFIRST:
2658 case IDM_SORTDIRSLAST:
2659 case IDM_SORTREVERSE:
2660 switch (SHORT1FROMMP(mp1)) {
2661 case IDM_SORTFILENAME:
2662 TreesortFlags |= SORT_FILENAME;
2663 break;
2664 case IDM_SORTSIZE:
2665 TreesortFlags |= SORT_SIZE;
2666 break;
2667 case IDM_SORTEASIZE:
2668 TreesortFlags |= SORT_EASIZE;
2669 break;
2670 case IDM_SORTFIRST:
2671 TreesortFlags |= SORT_FIRSTEXTENSION;
2672 break;
2673 case IDM_SORTLAST:
2674 TreesortFlags |= SORT_LASTEXTENSION;
2675 break;
2676 case IDM_SORTLWDATE:
2677 TreesortFlags |= SORT_LWDATE;
2678 break;
2679 case IDM_SORTLADATE:
2680 TreesortFlags |= SORT_LADATE;
2681 break;
2682 case IDM_SORTCRDATE:
2683 TreesortFlags |= SORT_CRDATE;
2684 break;
2685 case IDM_SORTDIRSFIRST:
2686 if (TreesortFlags & SORT_DIRSFIRST)
2687 TreesortFlags &= (~SORT_DIRSFIRST);
2688 else {
2689 TreesortFlags |= SORT_DIRSFIRST;
2690 TreesortFlags &= (~SORT_DIRSLAST);
2691 }
2692 break;
2693 case IDM_SORTDIRSLAST:
2694 if (TreesortFlags & SORT_DIRSLAST)
2695 TreesortFlags &= (~SORT_DIRSLAST);
2696 else {
2697 TreesortFlags |= SORT_DIRSLAST;
2698 TreesortFlags &= (~SORT_DIRSFIRST);
2699 }
2700 break;
2701 case IDM_SORTREVERSE:
2702 if (TreesortFlags & SORT_REVERSE)
2703 TreesortFlags &= (~SORT_REVERSE);
2704 else
2705 TreesortFlags |= SORT_REVERSE;
2706 break;
2707 }
2708 PrfWriteProfileData(fmprof, appname, "TreeSort", &TreesortFlags,
2709 sizeof(INT));
2710 WinSendMsg(hwnd, CM_SORTRECORD, MPFROMP(SortTreeCnr), MPVOID);
2711 break;
2712
2713 case IDM_COLLECT:
2714 case IDM_GREP:
2715 if (!Collector) {
2716
2717 HWND hwndC;
2718 SWP swp;
2719
2720 if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
2721 !fAutoTile &&
2722 (!fExternalCollector && *(ULONG *) realappname == FM3UL))
2723 GetNextWindowPos(dcd->hwndParent, &swp, NULL, NULL);
2724 hwndC = StartCollector((fExternalCollector ||
2725 *(ULONG *) realappname != FM3UL) ?
2726 HWND_DESKTOP : dcd->hwndParent, 4);
2727 if (hwndC) {
2728 if (!ParentIsDesktop(hwnd,
2729 dcd->hwndParent) &&
2730 !fAutoTile &&
2731 (!fExternalCollector && *(ULONG *) realappname == FM3UL))
2732 WinSetWindowPos(hwndC,
2733 HWND_TOP,
2734 swp.x,
2735 swp.y,
2736 swp.cx,
2737 swp.cy,
2738 SWP_MOVE | SWP_SIZE | SWP_SHOW | SWP_ZORDER);
2739 else if (!ParentIsDesktop(hwnd,
2740 dcd->hwndParent) &&
2741 fAutoTile && *(ULONG *) realappname == FM3UL)
2742 TileChildren(dcd->hwndParent, TRUE);
2743 }
2744 WinSetWindowPos(hwndC, HWND_TOP, 0, 0, 0, 0, SWP_ACTIVATE);
2745 DosSleep(100);//05 Aug 07 GKY 250
2746 }
2747 else
2748 StartCollector(dcd->hwndParent, 4);
2749 if (SHORT1FROMMP(mp1) == IDM_GREP) {
2750 PCNRITEM pci = NULL;
2751
2752 pci = WinSendMsg(hwnd,
2753 CM_QUERYRECORDEMPHASIS,
2754 MPFROMLONG(CMA_FIRST), MPFROMSHORT(CRA_CURSORED));
2755 if (pci && (INT) pci != -1)
2756 PostMsg(Collector, WM_COMMAND,
2757 MPFROM2SHORT(UM_GREP, 0), MPFROMP(pci->pszFileName));
2758 else
2759 PostMsg(Collector, WM_COMMAND,
2760 MPFROM2SHORT(IDM_GREP, 0), MPVOID);
2761 }
2762 else
2763 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_COLLECTOR, 0), MPVOID);
2764 break;
2765
2766 case IDM_COLLECTOR:
2767 DosSleep(32);//05 Aug 07 GKY 64
2768 {
2769 CHAR **list;
2770
2771 list = BuildList(hwnd);
2772 if (list) {
2773 if (Collector) {
2774 if (!PostMsg(Collector, WM_COMMAND,
2775 MPFROM2SHORT(IDM_COLLECTOR, 0), MPFROMP(list)))
2776 FreeList(list);
2777 }
2778 else
2779 FreeList(list);
2780 }
2781 }
2782 break;
2783
2784 case IDM_COLLAPSEALL:
2785 WinSendMsg(hwnd, CM_COLLAPSETREE, MPVOID, MPVOID);
2786 break;
2787
2788 case IDM_COLLAPSE:
2789 case IDM_EXPAND:
2790 {
2791 PCNRITEM pci = NULL;
2792
2793 pci = (PCNRITEM) CurrentRecord(hwnd);
2794 if (pci && (INT) pci != -1) {
2795 if (pci->flags & RECFLAGS_UNDERENV)
2796 break;
2797 PostMsg(dcd->hwndObject, UM_EXPAND, mp1, MPFROMP(pci));
2798 }
2799 }
2800 break;
2801
2802 case IDM_UPDATE:
2803 {
2804 PCNRITEM pci = (PCNRITEM)CurrentRecord(hwnd);
2805 if (pci && (INT)pci != -1) {
2806 struct
2807 {
2808 ULONG serial;
2809 CHAR volumelength;
2810 CHAR volumelabel[CCHMAXPATH];
2811 }
2812 volser;
2813 INT x = toupper(*pci->pszFileName) - 'A';
2814 CHAR FileSystem[CCHMAXPATH], szBuf[CCHMAXPATH];
2815
2816 UINT driveflag = driveflags[x];
2817 if (pci->attrFile & FILE_DIRECTORY) {
2818 if (pci->flags & RECFLAGS_UNDERENV)
2819 break;
2820 DosRequestMutexSem(hmtxScanning, SEM_INDEFINITE_WAIT);
2821 DosResetEventSem(hevTreeCnrScanComplete, &ulScanPostCnt);
2822 UnFlesh(hwnd, pci);
2823 // Check if drive type might need update
2824 if ((driveflag & (DRIVE_INVALID | DRIVE_NOPRESCAN)) ||
2825 (~driveflag & DRIVE_NOPRESCAN && pci->rc.hptrIcon == hptrDunno)) {
2826 DriveFlagsOne(x, FileSystem, &volser);
2827 driveflag = driveflags[x];
2828 if (driveflag & DRIVE_INVALID)
2829 pci->rc.hptrIcon = hptrDunno;
2830 else if (strlen(pci->pszFileName) < 4) {
2831 SelectDriveIcon(pci);
2832 if (fShowFSTypeInTree || fShowDriveLabelInTree) {
2833 strcpy(szBuf, pci->pszFileName);
2834 strcat(szBuf, " [");
2835 strcat(szBuf, fShowFSTypeInTree ? FileSystem : volser.volumelabel);
2836 strcat(szBuf, "]");
2837 pci->pszDisplayName = xstrdup(szBuf, pszSrcFile, __LINE__);
2838 pci->rc.pszIcon = pci->pszDisplayName;
2839 }
2840 }
2841 WinSendMsg(hwnd,
2842 CM_INVALIDATERECORD,
2843 MPFROMP(&pci),
2844 MPFROM2SHORT(1, CMA_ERASE | CMA_REPOSITION));
2845 if (hwndMain)
2846 PostMsg(hwndMain, UM_BUILDDRIVEBAR, MPVOID, MPVOID);
2847 }
2848 if (~driveflag & DRIVE_INVALID)
2849 Flesh(hwnd, pci);
2850 DosPostEventSem(hevTreeCnrScanComplete);
2851 }
2852 }
2853 }
2854 break;
2855
2856 case IDM_RESCAN:
2857 PostMsg(dcd->hwndObject, UM_RESCAN, MPVOID, MPVOID);
2858 break;
2859
2860 case IDM_RESORT:
2861 WinSendMsg(hwnd, CM_SORTRECORD, MPFROMP(SortTreeCnr), MPVOID);
2862 break;
2863
2864 case IDM_TEXT:
2865 case IDM_MINIICONS:
2866 {
2867 CNRINFO cnri;
2868
2869 memset(&cnri, 0, sizeof(CNRINFO));
2870 cnri.cb = sizeof(CNRINFO);
2871 WinSendMsg(hwnd,
2872 CM_QUERYCNRINFO,
2873 MPFROMP(&cnri), MPFROMLONG(sizeof(CNRINFO)));
2874 if (SHORT1FROMMP(mp1) == IDM_MINIICONS) {
2875 if (cnri.flWindowAttr & CV_MINI)
2876 cnri.flWindowAttr &= (~CV_MINI);
2877 else
2878 cnri.flWindowAttr |= CV_MINI;
2879 }
2880 else {
2881 if (cnri.flWindowAttr & CV_TEXT) {
2882 cnri.flWindowAttr &= (~CV_TEXT);
2883 cnri.flWindowAttr |= CV_ICON;
2884 }
2885 else {
2886 cnri.flWindowAttr &= (~CV_ICON);
2887 cnri.flWindowAttr |= CV_TEXT;
2888 }
2889 }
2890 dcd->flWindowAttr = cnri.flWindowAttr;
2891 PrfWriteProfileData(fmprof,
2892 appname,
2893 "TreeflWindowAttr",
2894 &cnri.flWindowAttr, sizeof(ULONG));
2895 WinSendMsg(hwnd,
2896 CM_SETCNRINFO,
2897 MPFROMP(&cnri),
2898 MPFROMLONG(CMA_FLWINDOWATTR | CMA_TREEICON |
2899 CMA_SLTREEBITMAPORICON));
2900 }
2901 break;
2902
2903 case IDM_SIZES:
2904 case IDM_DRVFLAGS:
2905 case IDM_SHOWALLFILES:
2906 case IDM_UNDELETE:
2907 case IDM_OPTIMIZE:
2908 case IDM_CHKDSK:
2909 case IDM_FORMAT:
2910 case IDM_MKDIR:
2911 case IDM_LOCK:
2912 case IDM_UNLOCK:
2913 case IDM_EJECT:
2914 case IDM_CLOSETRAY:
2915 {
2916 PCNRITEM pci;
2917
2918 pci = (PCNRITEM) CurrentRecord(hwnd);
2919 if (pci && (INT) pci != -1)
2920 CommonDriveCmd(hwnd, pci->pszFileName, SHORT1FROMMP(mp1));
2921 }
2922 break;
2923
2924 case IDM_SAVETOLIST:
2925 WinDlgBox(HWND_DESKTOP,
2926 hwnd,
2927 SaveListDlgProc, FM3ModHandle, SAV_FRAME, MPFROMP(&hwnd));
2928 break;
2929
2930 case IDM_DELETE:
2931 case IDM_PERMDELETE:
2932 case IDM_MOVE:
2933 case IDM_WPSMOVE:
2934 case IDM_WILDMOVE:
2935 case IDM_RENAME:
2936 {
2937 PCNRITEM pci;
2938
2939 pci = (PCNRITEM) CurrentRecord(hwnd);
2940 if (pci && (INT) pci != -1) {
2941 if (pci->flags & RECFLAGS_UNDERENV)
2942 break;
2943 }
2944 }
2945 // else intentional fallthru
2946 case IDM_ATTRS:
2947 case IDM_INFO:
2948 case IDM_COPY:
2949 case IDM_WPSCOPY:
2950 case IDM_WILDCOPY:
2951 case IDM_DOITYOURSELF:
2952 case IDM_OPENWINDOW:
2953 case IDM_OPENSETTINGS:
2954 case IDM_OPENDEFAULT:
2955 case IDM_OPENICON:
2956 case IDM_OPENDETAILS:
2957 case IDM_OPENTREE:
2958 case IDM_SHADOW:
2959 case IDM_SHADOW2:
2960 case IDM_COMPARE:
2961 case IDM_VIEW:
2962 case IDM_VIEWTEXT:
2963 case IDM_VIEWBINARY:
2964 case IDM_EDIT:
2965 case IDM_EDITTEXT:
2966 case IDM_EDITBINARY:
2967 case IDM_EAS:
2968 case IDM_SUBJECT:
2969 case IDM_APPENDTOCLIP:
2970 case IDM_SAVETOCLIP:
2971 case IDM_ARCHIVE:
2972 case IDM_MCIPLAY:
2973 case IDM_UUDECODE:
2974 {
2975 LISTINFO *li;
2976 ULONG action = UM_ACTION;
2977# ifdef FORTIFY
2978 Fortify_EnterScope();
2979# endif
2980 li = xmallocz(sizeof(LISTINFO), pszSrcFile, __LINE__);
2981 if (li) {
2982 li->type = SHORT1FROMMP(mp1);
2983 li->hwnd = hwnd;
2984 li->list = BuildList(hwnd);
2985 if (!li->list || !li->list[0]) {
2986 free(li);
2987 break;
2988 }
2989 if (IsRoot(li->list[0])) {
2990 switch (SHORT1FROMMP(mp1)) {
2991 case IDM_MOVE:
2992 case IDM_COPY:
2993 case IDM_WILDCOPY:
2994 case IDM_WILDMOVE:
2995 case IDM_WPSMOVE:
2996 case IDM_WPSCOPY:
2997 case IDM_RENAME:
2998 case IDM_DELETE:
2999 case IDM_PERMDELETE:
3000 mp1 = MPFROM2SHORT(IDM_INFO, SHORT2FROMMP(mp1));
3001 li->type = IDM_INFO;
3002 }
3003 }
3004 switch (SHORT1FROMMP(mp1)) {
3005 case IDM_APPENDTOCLIP:
3006 case IDM_SAVETOCLIP:
3007 case IDM_ARCHIVE:
3008 case IDM_DELETE:
3009 case IDM_PERMDELETE:
3010 case IDM_ATTRS:
3011 case IDM_SHADOW:
3012 case IDM_SHADOW2:
3013 case IDM_DOITYOURSELF:
3014 case IDM_EAS:
3015 case IDM_VIEW:
3016 case IDM_VIEWTEXT:
3017 case IDM_VIEWBINARY:
3018 case IDM_EDIT:
3019 case IDM_EDITTEXT:
3020 case IDM_EDITBINARY:
3021 case IDM_MCIPLAY:
3022 action = UM_MASSACTION;
3023 }
3024 if (li->type == IDM_DELETE)
3025 ignorereadonly = FALSE;
3026 if (SHORT1FROMMP(mp1) == IDM_SHADOW ||
3027 SHORT1FROMMP(mp1) == IDM_SHADOW2)
3028 *li->targetpath = 0;
3029 if (!PostMsg(dcd->hwndObject, action, MPFROMP(li), MPVOID)) {
3030 Runtime_Error(pszSrcFile, __LINE__, PCSZ_POSTMSG);
3031 FreeListInfo(li);
3032 }
3033 }
3034# ifdef FORTIFY
3035 Fortify_LeaveScope();
3036# endif
3037 }
3038 break;
3039
3040 default:
3041 if (SHORT1FROMMP(mp1) >= IDM_COMMANDSTART &&
3042 SHORT1FROMMP(mp1) < IDM_QUICKTOOLSTART) {
3043
3044 INT x;
3045
3046 if (!cmdloaded)
3047 load_commands();
3048 x = SHORT1FROMMP(mp1);// - IDM_COMMANDSTART;
3049 if (x >= 0) {
3050 //x++;
3051 RunCommand(hwnd, x);
3052 if (fUnHilite)
3053 UnHilite(hwnd, TRUE, &dcd->lastselection, 0);
3054 }
3055 }
3056 break;
3057 }
3058 }
3059 return 0;
3060
3061 case WM_SAVEAPPLICATION:
3062 if (dcd && !ParentIsDesktop(hwnd, dcd->hwndParent)) {
3063
3064 SWP swp, swpP;
3065 INT ratio;
3066
3067 WinQueryWindowPos(dcd->hwndFrame, &swp);
3068 if (!(swp.fl & (SWP_MINIMIZE | SWP_MAXIMIZE | SWP_HIDE))) {
3069 WinQueryWindowPos(dcd->hwndParent, &swpP);
3070 if (swp.cx) {
3071 ratio = (swpP.cx * 100) / swp.cx;
3072 if (ratio > 0)
3073 PrfWriteProfileData(fmprof, appname, "TreeWindowRatio",
3074 &ratio, sizeof(INT));
3075 }
3076 }
3077 }
3078 else if (dcd && ParentIsDesktop(hwnd, dcd->hwndParent)) {
3079
3080 SWP swp;
3081
3082 WinQueryWindowPos(dcd->hwndFrame, &swp);
3083 if (!(swp.fl & (SWP_HIDE | SWP_MINIMIZE | SWP_MAXIMIZE)))
3084 WinStoreWindowPos((CHAR *) FM2Str, "VTreeWindowPos", dcd->hwndFrame);
3085 }
3086 break;
3087
3088 case UM_MINIMIZE:
3089 if (dcd && hwndMain) {
3090 fOkayMinimize = TRUE;
3091 if (dcd->hwndObject && !fDummy) {
3092 DosSleep(50);//05 Aug 07 GKY 100
3093 if (!fDummy) {
3094 fOkayMinimize = FALSE;
3095 WinSetWindowPos(((hwndMain) ? WinQueryWindow(hwndMain, QW_PARENT) :
3096 dcd->hwndFrame), HWND_TOP, 0, 0, 0, 0,
3097 SWP_MINIMIZE | SWP_DEACTIVATE);
3098 }
3099 }
3100 }
3101 return 0;
3102
3103 case UM_MAXIMIZE:
3104 if (dcd || hwndMain)
3105 WinSetWindowPos(((hwndMain) ? WinQueryWindow(hwndMain, QW_PARENT) :
3106 dcd->hwndFrame), HWND_TOP, 0, 0, 0, 0, SWP_MAXIMIZE |
3107 SWP_SHOW);
3108 return 0;
3109
3110 case UM_CLOSE:
3111 {
3112 HWND hwndParent = WinQueryWindow(WinQueryWindow(WinQueryWindow(hwnd,
3113 QW_PARENT),
3114 QW_PARENT), QW_PARENT);
3115
3116 if (!mp1) {
3117 if (!PostMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID))
3118 WinSendMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID);
3119 if (hwndParent && !ParentIsDesktop(hwnd, hwndParent))
3120 WinDestroyWindow(hwndParent);
3121 }
3122 else
3123 WinDestroyWindow(WinQueryWindow(WinQueryWindow(hwnd, QW_PARENT),
3124 QW_PARENT));
3125 }
3126 return 0;
3127
3128 case WM_CLOSE:
3129 WinSendMsg(hwnd, WM_SAVEAPPLICATION, MPVOID, MPVOID);
3130 if (dcd)
3131 dcd->stopflag++;
3132 if (dcd && dcd->hwndObject) {
3133 // kill object window
3134 if (WinIsWindow((HAB) 0, dcd->hwndObject)) {
3135 if (!PostMsg(dcd->hwndObject, WM_CLOSE, MPVOID, MPVOID))
3136 WinSendMsg(dcd->hwndObject, WM_CLOSE, MPVOID, MPVOID);
3137 }
3138 }
3139 else
3140 WinSendMsg(hwnd, UM_CLOSE, MPFROMLONG(1), MPVOID);
3141 return 0;
3142
3143 case WM_DESTROY:
3144# ifdef FORTIFY
3145 DbgMsg(pszSrcFile, __LINE__, "WM_DESTROY hwnd %p TID %u", hwnd, GetTidForThread()); // 18 Jul 08 SHL fixme
3146# endif
3147 if (TreeCnrMenu)
3148 WinDestroyWindow(TreeCnrMenu);
3149 if (DirMenu)
3150 WinDestroyWindow(DirMenu);
3151 if (FileMenu)
3152 WinDestroyWindow(FileMenu);
3153 TreeCnrMenu = FileMenu = DirMenu = (HWND) 0;
3154 EmptyCnr(hwnd);
3155 if (apphead) {
3156 APPNOTIFY *info, *next;
3157
3158 info = apphead;
3159 while (info) {
3160 next = info->next;
3161 free(info);
3162 info = next;
3163 }
3164 apphead = apptail = NULL;
3165 }
3166# ifdef FORTIFY
3167 Fortify_LeaveScope();
3168# endif
3169 break; // WM_DESTROY
3170 } // switch
3171 if (dcd && dcd->oldproc){
3172 return dcd->oldproc(hwnd, msg, mp1, mp2);
3173 }
3174 else
3175 return PFNWPCnr(hwnd, msg, mp1, mp2);
3176}
3177
3178/**
3179 * Start drive tree container
3180 * @returns tree handle or NULLHANDLE
3181 */
3182
3183HWND StartTreeCnr(HWND hwndParent, ULONG flags)
3184{
3185 /**
3186 * bitmapped flags:
3187 * 0x00000001 = don't close app when window closes
3188 * 0x00000002 = no frame controls
3189 * 0x00000004 = no close or move button
3190 */
3191
3192 HWND hwndFrame = NULLHANDLE;
3193 HWND hwndSysMenu = NULLHANDLE;
3194 HWND hwndClient;
3195 ULONG FrameFlags = FCF_TITLEBAR | FCF_SYSMENU |
3196 FCF_SIZEBORDER | FCF_MINMAX | FCF_ICON | FCF_NOBYTEALIGN | FCF_ACCELTABLE;
3197 DIRCNRDATA *dcd;
3198
3199 if (!hwndParent)
3200 hwndParent = HWND_DESKTOP;
3201 if (ParentIsDesktop(hwndParent, hwndParent))
3202 FrameFlags |= (FCF_TASKLIST | FCF_MENU);
3203 if (flags & 2)
3204 FrameFlags &= (~(FCF_TITLEBAR | FCF_SYSMENU | FCF_SIZEBORDER |
3205 FCF_MINMAX | FCF_ICON));
3206 hwndFrame = WinCreateStdWindow(hwndParent,
3207 WS_VISIBLE,
3208 &FrameFlags,
3209 (CHAR *) WC_TREECONTAINER,
3210 NULL,
3211 WS_VISIBLE | fwsAnimate,
3212 FM3ModHandle, TREE_FRAME, &hwndClient);
3213 if (hwndParent != HWND_DESKTOP) {
3214 hwndSysMenu = WinWindowFromID(hwndFrame, FID_SYSMENU);
3215 if (hwndSysMenu != NULLHANDLE)
3216 WinSendMsg(hwndSysMenu, MM_SETITEMATTR,
3217 MPFROM2SHORT(SC_CLOSE, TRUE),
3218 MPFROM2SHORT(MIA_DISABLED, MIA_DISABLED));
3219 if (!fFreeTree)
3220 WinSendMsg(hwndSysMenu, MM_SETITEMATTR,
3221 MPFROM2SHORT(SC_MOVE, TRUE),
3222 MPFROM2SHORT(MIA_DISABLED, MIA_DISABLED));
3223 }
3224 if (hwndFrame && hwndClient) {
3225# ifdef FORTIFY
3226 Fortify_EnterScope();
3227# endif
3228 dcd = xmallocz(sizeof(DIRCNRDATA), pszSrcFile, __LINE__);
3229 if (!dcd) {
3230 Runtime_Error(pszSrcFile, __LINE__, GetPString(IDS_OUTOFMEMORY));
3231 PostMsg(hwndClient, WM_CLOSE, MPVOID, MPVOID);
3232 hwndFrame = (HWND) 0;
3233 }
3234 else {
3235 SWP swp;
3236 WinQueryWindowPos(hwndFrame, &swp);
3237 if (*(ULONG *) realappname == FM3UL) {
3238 if (!WinCreateWindow(hwndFrame,
3239 (CHAR *) WC_TREEOPENBUTTON,
3240 "#303",
3241 WS_VISIBLE | BS_PUSHBUTTON | BS_NOPOINTERFOCUS | BS_BITMAP,
3242 ((swp.cx -
3243 WinQuerySysValue(HWND_DESKTOP,
3244 SV_CXMINMAXBUTTON)) -
3245 WinQuerySysValue(HWND_DESKTOP,
3246 SV_CXMINMAXBUTTON) / 2) -
3247 WinQuerySysValue(HWND_DESKTOP, SV_CXSIZEBORDER),
3248 (swp.cy -
3249 WinQuerySysValue(HWND_DESKTOP,
3250 SV_CYMINMAXBUTTON)) -
3251 WinQuerySysValue(HWND_DESKTOP, SV_CYSIZEBORDER),
3252 WinQuerySysValue(HWND_DESKTOP,
3253 SV_CXMINMAXBUTTON) / 2,
3254 WinQuerySysValue(HWND_DESKTOP,
3255 SV_CYMINMAXBUTTON), hwndFrame,
3256 HWND_TOP, IDM_OPENWINDOW, NULL, NULL)) {
3257 Win_Error(hwndFrame, hwndParent, pszSrcFile, __LINE__,
3258 PCSZ_WINCREATEWINDOW);
3259 }
3260 }
3261 else {
3262 if (!WinCreateWindow(hwndFrame,
3263 (CHAR *) WC_TREESTATUS,
3264 (CHAR *) GetPString(IDS_YOUAREHERETEXT),
3265 WS_VISIBLE | SS_TEXT | DT_LEFT | DT_VCENTER,
3266 swp.x + 4 + WinQuerySysValue(HWND_DESKTOP,
3267 SV_CXSIZEBORDER),
3268 swp.cy - (22 + WinQuerySysValue(HWND_DESKTOP,
3269 SV_CYSIZEBORDER)),
3270 (swp.cx - 8) - (WinQuerySysValue(HWND_DESKTOP,
3271 SV_CXSIZEBORDER)
3272 * 2), 22, hwndFrame, HWND_TOP,
3273 MAIN_STATUS, NULL, NULL)) {
3274 Win_Error(hwndFrame, hwndParent, pszSrcFile, __LINE__,
3275 PCSZ_WINCREATEWINDOW);
3276 }
3277 }
3278 memset(dcd, 0, sizeof(DIRCNRDATA));
3279 dcd->size = sizeof(DIRCNRDATA);
3280 dcd->type = TREE_FRAME;
3281 dcd->dontclose = (flags & 1) != 0;
3282 dcd->hwndParent = hwndParent ? hwndParent : HWND_DESKTOP;
3283 dcd->hwndClient = hwndClient;
3284 dcd->hwndFrame = hwndFrame;
3285 {
3286 PFNWP oldproc;
3287
3288 oldproc = WinSubclassWindow(hwndFrame, TreeFrameWndProc);
3289 WinSetWindowPtr(hwndFrame, QWL_USER, (PVOID) oldproc);
3290 oldproc = WinSubclassWindow(WinWindowFromID(hwndFrame, FID_TITLEBAR),
3291 (PFNWP) TreeTitleWndProc);
3292 WinSetWindowPtr(WinWindowFromID(hwndFrame, FID_TITLEBAR),
3293 QWL_USER, (PVOID) oldproc);
3294 }
3295 dcd->hwndCnr = WinCreateWindow(hwndClient,
3296 WC_CONTAINER,
3297 NULL,
3298 CCS_AUTOPOSITION | CCS_MINIICONS |
3299 CCS_MINIRECORDCORE,
3300 0,
3301 0,
3302 0,
3303 0,
3304 hwndClient,
3305 HWND_TOP, (ULONG) TREE_CNR, NULL, NULL);
3306 if (!dcd->hwndCnr) {
3307 Win_Error(hwndClient, hwndClient, pszSrcFile, __LINE__,
3308 PCSZ_WINCREATEWINDOW);
3309 PostMsg(hwndClient, WM_CLOSE, MPVOID, MPVOID);
3310 free(dcd);
3311 dcd = NULL;
3312 hwndFrame = (HWND) 0;
3313 }
3314 else {
3315 WinSetWindowPtr(dcd->hwndCnr, QWL_USER, (PVOID) dcd);
3316 if (ParentIsDesktop(hwndFrame, hwndParent)) {
3317 WinSetWindowText(WinWindowFromID(hwndFrame, FID_TITLEBAR), "VTree");
3318 FixSwitchList(hwndFrame, "VTree");
3319 }
3320 else {
3321 WinSetWindowText(hwndFrame, (CHAR *) GetPString(IDS_TREETEXT));
3322 WinSetWindowText(WinWindowFromID(hwndFrame, FID_TITLEBAR),
3323 (CHAR *) GetPString(IDS_TREETEXT));
3324 }
3325 dcd->oldproc = WinSubclassWindow(dcd->hwndCnr, TreeCnrWndProc);
3326 // fixme to document 01 test?
3327 if (dcd->oldproc == 0)
3328 Win_Error(HWND_DESKTOP, HWND_DESKTOP, pszSrcFile, __LINE__,
3329 "WinSubclassWindow");
3330 if (!PostMsg(dcd->hwndCnr, UM_SETUP, MPVOID, MPVOID))
3331 WinSendMsg(dcd->hwndCnr, UM_SETUP, MPVOID, MPVOID);
3332 }
3333 }
3334# ifdef FORTIFY
3335 if (dcd)
3336 Fortify_ChangeScope(dcd, -1);
3337 Fortify_LeaveScope();
3338 if (dcd)
3339 Fortify_ChangeScope(dcd, +1);
3340# endif
3341 }
3342 WinShowWindow(hwndFrame, FALSE);
3343 return hwndFrame;
3344}
3345
3346#pragma alloc_text(TREECNR,TreeCnrWndProc,TreeObjWndProc,TreeClientWndProc)
3347#pragma alloc_text(TREECNR,TreeFrameWndProc,TreeTitleWndProc,ShowTreeRec)
3348#pragma alloc_text(TREECNR,TreeStatProc,OpenButtonProc)
3349#pragma alloc_text(STARTUP,StartTreeCnr)
Note: See TracBrowser for help on using the repository browser.