Context Navigation

source: trunk/dll/treecnr.c@ 1860

Visit:

Last change on this file since 1860 was 1860, checked in by Steven Levine, 10 years ago
Rework FlesWaitForWorkListEmpty to support wait for parents of path Add more wrappers for mutex and event semaphores Clean up some obsolete code
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 94.1 KB

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

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

Download in other formats: