Context Navigation

source: trunk/dll/treecnr.c@ 1498

Visit:

Last change on this file since 1498 was 1498, checked in by Gregg Young, 16 years ago
Changes to get FM2 to compile with the latest watcom 1.9 beta (mostly type casts of CHAR CONSTANT * to CHAR *). Changes to get the environment settings working everywhere again (broken by the change that moved commands to the INI); Added an environment size variable (set to 2048 which was the largest I found hard coded). Still need to find everywhere the environment size is set and use this variable.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 88.8 KB

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

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

Download in other formats: