Context Navigation

source: trunk/dll/treecnr.c@ 1862

Visit:

Last change on this file since 1862 was 1862, checked in by Gregg Young, 10 years ago
Improve ability of maketop to get directory position in tree correct on first open of states with large and/or deep tree structures
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 94.6 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: