Context Navigation

source: trunk/dll/treecnr.c@ 1402

Visit:

Last change on this file since 1402 was 1402, checked in by Gregg Young, 16 years ago
Remove variable aurgs from docopy & unlinkf (not used); Move more strings to PCSZs and string table; Move PCSZs to compile time initialization; Fix hang on startup caused by a drive scan and a dircnr scan trying to update a drive in the tree at the same time (related to the "treeswitch options); Code cleanup mainly removal of old printfs, SayMsgs, DbgMsg and unneeded %s.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 87.8 KB

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

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

Download in other formats: