Context Navigation

source: trunk/dll/treecnr.c@ 1741

Visit:

Last change on this file since 1741 was 1741, checked in by Gregg Young, 11 years ago
Fix warn readonly yes don't ask to work when recursing directories.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 90.8 KB

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

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

Download in other formats: