Context Navigation

source: trunk/dll/treecnr.c@ 1521

Visit:

Last change on this file since 1521 was 1513, checked in by Steven Levine, 16 years ago
Avoid referencing buffer after freeing dcd
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 89.0 KB

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

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

Download in other formats: