source: trunk/dll/treecnr.c@ 1485

Last change on this file since 1485 was 1480, checked in by Gregg Young, 16 years ago

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