Context Navigation

source: trunk/dll/treecnr.c@ 1433

Visit:

Last change on this file since 1433 was 1431, checked in by Gregg Young, 16 years ago
Changed 3 way button to radio buttons and added rescan on change to add systype/label to tree enhancement.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 88.0 KB

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

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

Download in other formats: