Context Navigation

source: trunk/dll/treecnr.c@ 1324

Visit:

Last change on this file since 1324 was 1320, checked in by Gregg Young, 17 years ago
Use event semaphore to prevent rescan of drives while StubbySacnTreads are still running; code cleanup.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 86.0 KB

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

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

Download in other formats: