Context Navigation

source: trunk/dll/treecnr.c@ 1428

Visit:

Last change on this file since 1428 was 1428, checked in by Gregg Young, 16 years ago
Improvement to status line 1 for selected drives (number of drives is shown at the beginning of the line if split status line is not selected); Comments for recent changes.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 87.8 KB

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

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

Download in other formats: