Context Navigation

source: trunk/dll/treecnr.c@ 1357

Visit:

Last change on this file since 1357 was 1357, checked in by Gregg Young, 17 years ago
Fixed DROPHELP issues Tickets 320 & 324
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 87.3 KB

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

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

Download in other formats: