Context Navigation

source: trunk/dll/mainwnd2.c@ 133

Visit:

Last change on this file since 133 was 133, checked in by root, 20 years ago
Use datamin.h
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 38.6 KB

Rev	Line
[133]	1
	2	/***********************************************************************
	3
	4	$Id: mainwnd2.c 133 2005-05-24 23:28:12Z root $
	5
	6	Main window
	7
	8	Copyright (c) 1993-98 M. Kimes
	9	Copyright (c) 2005 Steven H.Levine
	10
	11	23 May 05 SHL Use datamin.h
	12
	13	***********************************************************************/
	14
[2]	15	#define INCL_DOS
	16	#define INCL_WIN
	17	#define INCL_GPI
	18
	19	#include <os2.h>
	20	#include <stdlib.h>
	21	#include <stdio.h>
	22	#include <string.h>
	23	#include <ctype.h>
	24	#include <share.h>
[133]	25
[2]	26	#include "fm3dll.h"
	27	#include "fm3dlg.h"
	28	#include "fm3str.h"
	29	#include "tools.h"
[133]	30	#include "datamin.h"
[2]	31
[133]	32	typedef struct
	33	{
	34	USHORT size;
	35	USHORT dummy;
	36	HWND hwndDir1;
	37	HWND hwndDir2;
	38	HWND hwndCurr;
	39	HWND hwndLastDir;
	40	HWND hwndMax;
	41	}
	42	PERSON1DATA;
[2]	43
[133]	44	extern TOOL *toolhead;
[2]	45
	46	#pragma alloc_text(PERSON11,MainFrameWndProc2,MainWndProc2)
	47	#pragma alloc_text(PERSON12,StartFM32,MainWMOnce2)
	48	#pragma alloc_text(PERSON13,MainWMCommand2)
	49
[133]	50	MRESULT EXPENTRY MainFrameWndProc2(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
	51	{
[2]	52
[133]	53	PFNWP oldproc = (PFNWP) WinQueryWindowPtr(hwnd, 0);
[2]	54
[133]	55	switch (msg)
	56	{
	57	case WM_ADJUSTWINDOWPOS:
	58	{
	59	SWP *pswp;
[2]	60
[133]	61	pswp = (SWP *) mp1;
	62	if (pswp -> fl & (SWP_SHOW \| SWP_RESTORE))
	63	PostMsg(WinWindowFromID(hwnd, FID_CLIENT), UM_SIZE, MPVOID, MPVOID);
	64	if (fDataMin && !fAmClosing)
[2]	65	{
[133]	66	if (pswp -> fl & (SWP_HIDE \| SWP_MINIMIZE))
	67	{
[2]	68
[133]	69	SWP swp;
[2]	70
[133]	71	WinQueryWindowPos(hwnd, &swp);
	72	PostMsg(hwnd, UM_FOCUSME, MPFROMLONG(swp.fl), MPVOID);
	73	HideNote();
	74	}
	75	else if (pswp -> fl & (SWP_SHOW \| SWP_RESTORE))
	76	{
	77	if (DataHwnd)
	78	PostMsg(DataHwnd, WM_CLOSE, MPVOID, MPVOID);
	79	}
[2]	80	}
[133]	81	if (!fAmClosing)
	82	{
	83	if (pswp -> fl & (SWP_HIDE \| SWP_MINIMIZE))
	84	HideNote();
	85	}
	86	}
	87	break;
[2]	88
[133]	89	case UM_FOCUSME:
	90	CreateDataBar(HWND_DESKTOP, (ULONG) mp1);
	91	return 0;
[2]	92
[133]	93	case WM_BUTTON1UP:
	94	case WM_BUTTON2UP:
	95	case WM_BUTTON3UP:
	96	case WM_MOUSEMOVE:
	97	case WM_CHORD:
	98	shiftstate = (SHORT2FROMMP(mp2) & (KC_ALT \| KC_SHIFT \| KC_CTRL));
	99	break;
[2]	100
[133]	101	case WM_CHAR:
	102	shiftstate = (SHORT1FROMMP(mp1) & (KC_SHIFT \| KC_ALT \| KC_CTRL));
	103	break;
[2]	104
[133]	105	case WM_CONTROL:
	106	return WinSendMsg(WinWindowFromID(hwnd, FID_CLIENT), UM_CONTROL, mp1, mp2);
[2]	107
[133]	108	case WM_COMMAND:
	109	return WinSendMsg(WinWindowFromID(hwnd, FID_CLIENT), msg, mp1, mp2);
[2]	110
[133]	111	case WM_CALCFRAMERECT:
	112	{
	113	MRESULT mr;
	114	PRECTL prectl;
	115	LONG sheight = 20, bheight = 20;
[2]	116
[133]	117	mr = (oldproc) ? oldproc(hwnd, msg, mp1, mp2) :
	118	PFNWPFrame(hwnd, msg, mp1, mp2);
[2]	119
[133]	120	/*
	121	* Calculate the position of the client rectangle.
	122	* Otherwise, we'll see a lot of redraw when we move the
	123	* client during WM_FORMATFRAME.
	124	*/
[2]	125
[133]	126	if (mr && mp2)
	127	{
	128	prectl = (PRECTL) mp1;
	129	if (prectl -> yBottom != prectl -> yTop)
	130	{
	131	{
	132	HPS hps;
	133	POINTL aptl[TXTBOX_COUNT];
[2]	134
[133]	135	hps = WinGetPS(hwndStatus);
	136	GpiQueryTextBox(hps, 6, "$`WjgT", TXTBOX_COUNT, aptl);
	137	WinReleasePS(hps);
	138	sheight = aptl[TXTBOX_TOPLEFT].y + 6;
	139	hps = WinGetPS(hwndName);
	140	GpiQueryTextBox(hps, 6, "$`WjgT", TXTBOX_COUNT, aptl);
	141	WinReleasePS(hps);
	142	bheight = aptl[TXTBOX_TOPLEFT].y + 6;
	143	}
	144	prectl -> yBottom += (sheight + 4);
	145	prectl -> yTop -= (sheight + 4);
	146	prectl -> yBottom += (bheight + 4);
	147	prectl -> yTop -= (bheight + 4);
	148	if (fToolbar)
	149	{
	150	if (!fTextTools)
	151	prectl -> yTop -= ((fToolTitles) ? 50 : 40);
	152	else
	153	prectl -> yTop -= 32;
	154	}
	155	ResizeDrives(WinWindowFromID(hwnd, MAIN_DRIVES),
	156	((prectl -> xRight -
	157	(WinQuerySysValue(HWND_DESKTOP,
	158	SV_CYSIZEBORDER) * 2)) - 4));
	159	prectl -> yTop -= (16 * (DriveLines * 18));
	160	prectl -> yTop -= 2;
	161	if (fAutoView)
	162	{
	163	AutoviewHeight = min(AutoviewHeight,
	164	(prectl -> yTop - prectl -> yBottom) - 116);
	165	AutoviewHeight = max(AutoviewHeight, 36);
	166	prectl -> yBottom += (AutoviewHeight + 6);
	167	}
	168	}
[2]	169	}
[133]	170	return mr;
	171	}
[2]	172
[133]	173	case WM_FORMATFRAME:
	174	{
	175	SHORT sCount, soldCount;
	176	PSWP pswp, pswpClient, pswpNew;
	177	SWP swpClient;
	178	ULONG theight = 48L, dheight = 20, bheight = 20, sheight = 20;
	179	LONG width, lastx;
[2]	180
[133]	181	sCount = (SHORT) ((oldproc) ? oldproc(hwnd, msg, mp1, mp2) :
	182	PFNWPFrame(hwnd, msg, mp1, mp2));
	183	soldCount = sCount;
	184	/*
	185	* Reformat the frame to "squeeze" the client
	186	* and make room for status window sibling beneath
	187	* and toolbar above (if toolbar's on) and userlists
	188	* (if userlists are on).
	189	*/
[2]	190
[133]	191	pswp = (PSWP) mp1;
	192	{
	193	SHORT x;
[2]	194
[133]	195	for (x = 0; x < sCount; x++)
	196	{
	197	if (WinQueryWindowUShort(pswp -> hwnd, QWS_ID) == FID_CLIENT)
	198	{
	199	pswpClient = pswp;
	200	break;
	201	}
	202	pswp++;
	203	}
	204	}
[2]	205
[133]	206	{
	207	HPS hps;
	208	POINTL aptl[TXTBOX_COUNT];
[2]	209
[133]	210	hps = WinGetPS(hwndStatus);
	211	GpiQueryTextBox(hps, 6, "$`WjgT", TXTBOX_COUNT, aptl);
	212	WinReleasePS(hps);
	213	bheight = sheight = aptl[TXTBOX_TOPLEFT].y + 6;
	214	hps = WinGetPS(hwndName);
	215	GpiQueryTextBox(hps, 6, "$`WjgT", TXTBOX_COUNT, aptl);
	216	WinReleasePS(hps);
	217	bheight = aptl[TXTBOX_TOPLEFT].y + 6;
	218	}
[2]	219
[133]	220	pswpNew = (PSWP) mp1 + soldCount;
	221	pswpNew = pswpClient;
	222	swpClient = *pswpClient;
	223	pswpNew -> hwnd = hwndStatus;
	224	pswpNew -> x = swpClient.x + 3;
	225	pswpNew -> y = swpClient.y + 2;
	226	width = (swpClient.cx / 2) - 6;
	227	width = max(width, 10);
	228	pswpNew -> cx = width - 6;
	229	pswpNew -> cy = sheight;
	230	pswpClient -> y = pswpNew -> y + pswpNew -> cy + 3;
	231	pswpClient -> cy = (swpClient.cy - pswpNew -> cy) - 3;
	232	sCount++;
[2]	233
[133]	234	pswpNew = (PSWP) mp1 + (soldCount + 1);
	235	pswpNew = pswpClient;
	236	pswpNew -> hwnd = hwndStatus2;
	237	pswpNew -> x = width + 8;
	238	pswpNew -> y = swpClient.y + 2;
	239	pswpNew -> cx = width - 6;
	240	pswpNew -> cy = sheight;
	241	sCount++;
[2]	242
[133]	243	if (fToolbar)
	244	{
	245	if (fTextTools)
	246	theight = 32L;
	247	else if (!fToolTitles)
	248	theight = 40L;
	249	pswpNew = (PSWP) mp1 + (soldCount + 2);
	250	pswpNew = pswpClient;
	251	pswpNew -> hwnd = WinWindowFromID(hwnd, MAIN_TOOLS);
	252	pswpNew -> x = swpClient.x + 2;
	253	pswpNew -> y = (swpClient.y + swpClient.cy) - (theight - 2);
	254	pswpNew -> cx = swpClient.cx - 4;
	255	pswpNew -> cy = theight - 4;
	256	pswpClient -> cy -= theight;
	257	sCount++;
	258	}
	259	else
	260	WinShowWindow(WinWindowFromID(hwnd, MAIN_TOOLS), FALSE);
[2]	261
[133]	262	ResizeDrives(WinWindowFromID(hwnd, MAIN_DRIVES),
	263	pswpClient -> cx - 4);
	264	pswpNew = (PSWP) mp1 + (soldCount + 2 + (fToolbar != FALSE));
	265	pswpNew = pswpClient;
	266	pswpNew -> hwnd = WinWindowFromID(hwnd, MAIN_DRIVES);
	267	pswpNew -> x = swpClient.x + 2;
	268	dheight += ((dheight - 2) * DriveLines);
	269	pswpNew -> y = (swpClient.y + swpClient.cy) - (dheight - 2);
	270	if (fToolbar)
	271	pswpNew -> y -= theight;
	272	pswpNew -> cx = swpClient.cx - 4;
	273	pswpNew -> cy = dheight - 4;
	274	pswpClient -> cy -= dheight;
	275	pswpClient -> cy -= 2;
	276	sCount++;
[2]	277
[133]	278	if (fAutoView)
	279	{
	280	pswpNew = (PSWP) mp1 + (soldCount + 3 + (fToolbar != FALSE));
	281	pswpNew = pswpClient;
	282	pswpNew -> hwnd = (fComments) ? hwndAutoMLE : hwndAutoview;
	283	pswpNew -> x = pswpClient -> x + 3;
	284	pswpNew -> y = pswpClient -> y + 3;
	285	if (fMoreButtons)
	286	pswpNew -> y += (bheight + 4);
	287	pswpNew -> cx = pswpClient -> cx - 6;
	288	AutoviewHeight = min(AutoviewHeight,
	289	pswpClient -> cy - 116);
	290	AutoviewHeight = max(AutoviewHeight, 36);
	291	pswpNew -> cy = AutoviewHeight;
	292	pswpClient -> y += (AutoviewHeight + 6);
	293	pswpClient -> cy -= (AutoviewHeight + 6);
	294	sCount++;
	295	WinShowWindow((fComments) ? hwndAutoview : hwndAutoMLE, FALSE);
	296	}
	297	else
	298	{
	299	WinShowWindow(hwndAutoview, FALSE);
	300	WinShowWindow(hwndAutoMLE, FALSE);
	301	}
[2]	302
[133]	303	pswpNew = (PSWP) mp1 + (soldCount + 3 + (fToolbar != FALSE) +
	304	(fAutoView != FALSE));
	305	pswpNew = pswpClient;
	306	pswpNew -> hwnd = WinWindowFromID(hwnd, MAIN_LED);
	307	pswpNew -> x = (swpClient.x + swpClient.cx) - 12;
	308	pswpNew -> y = swpClient.y;
	309	pswpNew -> cx = 12;
	310	pswpNew -> cy = 12;
	311	sCount++;
[2]	312
[133]	313	pswpNew = (PSWP) mp1 + (soldCount + 4 + (fToolbar != FALSE) +
	314	(fAutoView != FALSE));
	315	pswpNew = pswpClient;
	316	pswpNew -> hwnd = WinWindowFromID(hwnd, MAIN_LEDHDR);
	317	pswpNew -> x = (swpClient.x + swpClient.cx) - 12;
	318	pswpNew -> y = swpClient.y + 12;
	319	pswpNew -> cx = 12;
	320	pswpNew -> cy = sheight - 8;
	321	sCount++;
[2]	322
[133]	323	pswpNew = (PSWP) mp1 + (soldCount + 5 + (fToolbar != FALSE) +
	324	(fAutoView != FALSE));
	325	pswpNew = pswpClient;
	326	pswpNew -> hwnd = hwndName;
	327	pswpNew -> x = swpClient.x + 3;
	328	pswpNew -> y = swpClient.y + (sheight + 6);
	329	pswpNew -> cx = ((swpClient.cx / 2) + (swpClient.cx / 5)) - 3;
	330	lastx = pswpNew -> x + pswpNew -> cx;
	331	pswpNew -> cy = bheight;
	332	pswpClient -> y += (bheight + 4);
	333	pswpClient -> cy -= (bheight + 4);
	334	sCount++;
[2]	335
[133]	336	pswpNew = (PSWP) mp1 + (soldCount + 6 + (fToolbar != FALSE) +
	337	(fAutoView != FALSE));
	338	pswpNew = pswpClient;
	339	pswpNew -> hwnd = hwndDate;
	340	pswpNew -> x = lastx + 3;
	341	pswpNew -> y = swpClient.y + (sheight + 6);
	342	pswpNew -> cx = (swpClient.cx / 6) + (swpClient.cx / 16) - 3;
	343	lastx = pswpNew -> x + pswpNew -> cx;
	344	pswpNew -> cy = bheight;
	345	sCount++;
[2]	346
[133]	347	pswpNew = (PSWP) mp1 + (soldCount + 7 + (fToolbar != FALSE) +
	348	(fAutoView != FALSE));
	349	pswpNew = pswpClient;
	350	pswpNew -> hwnd = hwndAttr;
	351	pswpNew -> x = lastx + 3;
	352	pswpNew -> y = swpClient.y + (sheight + 6);
	353	pswpNew -> cx = (swpClient.cx - pswpNew -> x) - 1;
	354	pswpNew -> cy = bheight;
	355	sCount++;
[2]	356
[133]	357	return MRFROMSHORT(sCount);
	358	}
[2]	359
[133]	360	case WM_QUERYFRAMECTLCOUNT:
	361	{
	362	SHORT sCount;
[2]	363
[133]	364	sCount = (SHORT) ((oldproc) ? oldproc(hwnd, msg, mp1, mp2) :
	365	PFNWPFrame(hwnd, msg, mp1, mp2));
	366	sCount += 8;
	367	if (fToolbar)
	368	sCount++;
	369	if (fAutoView)
	370	sCount++;
	371	return MRFROMSHORT(sCount);
	372	}
[2]	373
[133]	374	case WM_CLOSE:
	375	WinSendMsg(WinWindowFromID(hwnd, FID_CLIENT), msg, mp1, mp2);
	376	return 0;
[2]	377	}
[133]	378	return (oldproc) ? oldproc(hwnd, msg, mp1, mp2) :
	379	PFNWPFrame(hwnd, msg, mp1, mp2);
[2]	380	}
	381
[133]	382	MRESULT EXPENTRY MainWMCommand2(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
	383	{
[2]	384
	385	PERSON1DATA *pd;
	386
	387	SetShiftState();
[133]	388	switch (SHORT1FROMMP(mp1))
	389	{
	390	case IDM_TOAUTOMLE:
	391	case IDM_CLI:
	392	case IDM_CREATETOOL:
	393	case IDM_ABOUT:
	394	case IDM_WINFULLSCREEN:
	395	case IDM_DOSCOMMANDLINE:
	396	case IDM_INIVIEWER:
	397	case IDM_EDITASSOC:
	398	case IDM_COMMANDLINE:
	399	case IDM_KILLPROC:
	400	case IDM_TOOLBAR:
	401	case IDM_TEXTTOOLS:
	402	case IDM_TOOLTITLES:
	403	case IDM_TOOLLEFT:
	404	case IDM_TOOLRIGHT:
	405	case IDM_AUTOVIEWCOMMENTS:
	406	case IDM_AUTOVIEWFILE:
	407	case IDM_AUTOVIEW:
[2]	408	// case IDM_SYSINFO:
[133]	409	case IDM_HIDENOTEWND:
	410	case IDM_SHOWNOTEWND:
	411	case IDM_INSTANT:
	412	case IDM_HELPCONTEXT:
	413	case IDM_HELPHINTS:
	414	case IDM_HELPPIX:
	415	case IDM_KILLME:
	416	case IDM_EXIT:
	417	case IDM_HELPTUTOR:
	418	case IDM_HELPCONTENTS:
	419	case IDM_HELPGENERAL:
	420	case IDM_HELPKEYS:
	421	case IDM_HELPMOUSE:
	422	case IDM_HELP:
	423	return MainWMCommand(hwnd, msg, mp1, mp2);
[2]	424
[133]	425	case IDM_REMAP:
	426	WinDlgBox(HWND_DESKTOP,
	427	hwnd,
	428	RemapDlgProc,
	429	FM3ModHandle,
	430	MAP_FRAME,
	431	NULL);
	432	break;
[2]	433
[133]	434	case IDM_TWODIRS:
	435	pd = WinQueryWindowPtr(hwnd, 4);
	436	if (pd)
	437	{
[2]	438
[133]	439	WALK2 wa;
[2]	440
[133]	441	memset(&wa, 0, sizeof(wa));
	442	wa.size = sizeof(wa);
	443	*wa.szCurrentPath1 = 0;
	444	WinSendMsg(pd -> hwndDir1,
	445	UM_CONTAINERDIR,
	446	MPFROMP(wa.szCurrentPath1),
	447	MPVOID);
	448	MakeValidDir(wa.szCurrentPath1);
	449	*wa.szCurrentPath2 = 0;
	450	WinSendMsg(pd -> hwndDir2,
	451	UM_CONTAINERDIR,
	452	MPFROMP(wa.szCurrentPath2),
	453	MPVOID);
	454	MakeValidDir(wa.szCurrentPath2);
	455	if (WinDlgBox(HWND_DESKTOP,
	456	hwnd,
	457	WalkTwoSetDlgProc,
	458	FM3ModHandle,
	459	WALK2_FRAME,
	460	MPFROMP(&wa)) &&
	461	(IsRoot(wa.szCurrentPath1) \|\|
	462	!IsFile(wa.szCurrentPath1)) &&
	463	(IsRoot(wa.szCurrentPath2) \|\|
	464	!IsFile(wa.szCurrentPath2)))
	465	{
	466	WinSendMsg(WinWindowFromID(WinWindowFromID(pd -> hwndDir1,
	467	FID_CLIENT), DIR_CNR),
	468	UM_SETDIR,
	469	MPFROMP(wa.szCurrentPath1),
	470	MPVOID);
	471	WinSendMsg(WinWindowFromID(WinWindowFromID(pd -> hwndDir2,
	472	FID_CLIENT), DIR_CNR),
	473	UM_SETDIR,
	474	MPFROMP(wa.szCurrentPath2),
	475	MPVOID);
[2]	476	}
[133]	477	}
	478	break;
[2]	479
[133]	480	case IDM_COMPARE:
	481	pd = WinQueryWindowPtr(hwnd, 4);
	482	if (pd)
	483	{
[2]	484
[133]	485	WALK2 wa;
[2]	486
[133]	487	memset(&wa, 0, sizeof(wa));
	488	wa.size = sizeof(wa);
	489	*wa.szCurrentPath1 = 0;
	490	WinSendMsg(pd -> hwndDir1,
	491	UM_CONTAINERDIR,
	492	MPFROMP(wa.szCurrentPath1),
	493	MPVOID);
	494	MakeValidDir(wa.szCurrentPath1);
	495	*wa.szCurrentPath2 = 0;
	496	WinSendMsg(pd -> hwndDir2,
	497	UM_CONTAINERDIR,
	498	MPFROMP(wa.szCurrentPath2),
	499	MPVOID);
	500	MakeValidDir(wa.szCurrentPath2);
	501	if (WinDlgBox(HWND_DESKTOP,
	502	hwnd,
	503	WalkTwoCmpDlgProc,
	504	FM3ModHandle,
	505	WALK2_FRAME,
	506	MPFROMP(&wa)) &&
	507	(IsRoot(wa.szCurrentPath1) \|\|
	508	!IsFile(wa.szCurrentPath1)) &&
	509	(IsRoot(wa.szCurrentPath2) \|\|
	510	!IsFile(wa.szCurrentPath2)))
	511	{
	512	if (!*dircompare)
	513	{
[2]	514
[133]	515	COMPARE *cmp;
[2]	516
[133]	517	cmp = malloc(sizeof(COMPARE));
	518	if (cmp)
	519	{
	520	memset(cmp, 0, sizeof(COMPARE));
	521	cmp -> size = sizeof(COMPARE);
	522	strcpy(cmp -> leftdir, wa.szCurrentPath1);
	523	strcpy(cmp -> rightdir, wa.szCurrentPath2);
	524	cmp -> hwndParent = hwnd;
	525	cmp -> dcd.hwndParent = hwnd;
	526	WinDlgBox(HWND_DESKTOP,
	527	HWND_DESKTOP,
	528	CompareDlgProc,
	529	FM3ModHandle,
	530	COMP_FRAME,
	531	MPFROMP(cmp));
	532	}
	533	}
	534	else
	535	{
[2]	536
[133]	537	CHAR d1 = "\"", d2 = "\"";
[2]	538
[133]	539	if (!needs_quoting(wa.szCurrentPath1))
	540	*d1 = 0;
	541	if (!needs_quoting(wa.szCurrentPath2))
	542	*d2 = 0;
	543	runemf2(SEPARATE,
	544	HWND_DESKTOP,
	545	NULL,
	546	NULL,
	547	"%s %s%s%s %s%s%s",
	548	dircompare,
	549	d1,
	550	wa.szCurrentPath1,
	551	d1,
	552	d2,
	553	wa.szCurrentPath2,
	554	d2);
	555	}
[2]	556	}
[133]	557	}
	558	break;
[2]	559
[133]	560	case IDM_VTREE:
	561	WinSendMsg(hwnd,
	562	UM_SETUP2,
	563	MPFROMLONG(1),
	564	MPVOID);
	565	if (hwndTree)
	566	{
	567	WinShowWindow(hwndTree, FALSE);
	568	PostMsg(hwndTree,
	569	WM_CLOSE,
	570	MPVOID,
	571	MPVOID);
	572	hwndTree = (HWND) 0;
	573	}
	574	else
	575	{
[2]	576
[133]	577	ULONG size = sizeof(ULONG);
[2]	578
[133]	579	hwndTree = StartTreeCnr(hwnd, 3);
	580	PrfQueryProfileData(fmprof,
	581	realappname,
	582	"FM/4 TreeWidth",
	583	(PVOID) & TreeWidth,
	584	&size);
	585	TreeWidth = max(TreeWidth, 80);
	586	}
	587	{
	588	BOOL dummy = (hwndTree != (HWND) 0);
[2]	589
	590	PrfWriteProfileData(fmprof,
[133]	591	realappname,
	592	"FM/4 TreeUp",
	593	(PVOID) & dummy,
	594	sizeof(dummy));
	595	}
	596	PostMsg(hwnd,
	597	UM_SIZE,
	598	MPVOID,
	599	MPVOID);
	600	break;
[2]	601
[133]	602	case IDM_TILEBACKWARDS:
	603	WinSendMsg(hwnd,
	604	UM_SETUP2,
	605	MPFROMLONG(1),
	606	MPVOID);
	607	fTileBackwards = (fTileBackwards) ? FALSE : TRUE;
	608	PrfWriteProfileData(fmprof,
	609	FM3Str,
	610	"TileBackwards",
	611	(PVOID) & fTileBackwards,
	612	sizeof(BOOL));
	613	PostMsg(hwnd,
	614	UM_SIZE,
	615	MPVOID,
	616	MPVOID);
	617	break;
[2]	618
[133]	619	case IDM_NEXTWINDOW:
	620	case IDM_PREVWINDOW:
	621	pd = WinQueryWindowPtr(hwnd, 4);
	622	if (pd)
	623	{
[2]	624
[133]	625	HWND hwndFocus;
	626
	627	if (hwndTree)
	628	{
	629	if (pd -> hwndMax)
	630	{
	631	if (hwndTree == pd -> hwndCurr)
	632	hwndFocus = pd -> hwndMax;
	633	else
	634	hwndFocus = hwndTree;
	635	}
	636	else
	637	{
	638	if (hwndTree == pd -> hwndCurr)
	639	hwndFocus = (SHORT1FROMMP(mp1) == IDM_PREVWINDOW) ?
	640	pd -> hwndDir1 : pd -> hwndDir2;
	641	else if (pd -> hwndDir1 == pd -> hwndCurr)
	642	hwndFocus = (SHORT1FROMMP(mp1) == IDM_PREVWINDOW) ?
	643	pd -> hwndDir2 : hwndTree;
	644	else
	645	hwndFocus = (SHORT1FROMMP(mp1) == IDM_PREVWINDOW) ?
	646	hwndTree : pd -> hwndDir1;
	647	}
[2]	648	}
[133]	649	else
	650	{
	651	if (pd -> hwndMax)
	652	hwndFocus = pd -> hwndMax;
	653	else
	654	hwndFocus = (pd -> hwndCurr == pd -> hwndDir1) ?
	655	pd -> hwndDir2 : pd -> hwndDir1;
	656	}
	657	WinSetFocus(HWND_DESKTOP, hwndFocus);
	658	}
	659	break;
[2]	660
[133]	661	case IDM_NOTEBOOK:
	662	WinDlgBox(HWND_DESKTOP,
	663	hwnd,
	664	CfgDlgProc,
	665	FM3ModHandle,
	666	CFG_FRAME,
	667	MPFROMP(realappname));
	668	PostMsg(hwnd,
	669	UM_SIZE,
	670	MPVOID,
	671	MPVOID);
	672	break;
[2]	673
[133]	674	case IDM_SEEALL:
	675	case IDM_GREP:
	676	case IDM_COLLECTOR:
	677	{
	678	HWND hwndC;
	679
	680	hwndC = StartCollector(HWND_DESKTOP, 4);
	681	if (hwndC)
[2]	682	{
[133]	683	WinSetWindowPos(hwndC,
	684	HWND_TOP,
	685	0,
	686	0,
	687	0,
	688	0,
	689	SWP_SHOW \| SWP_RESTORE \| SWP_ACTIVATE);
	690	if (SHORT1FROMMP(mp1) == IDM_GREP)
	691	PostMsg(WinWindowFromID(hwndC, FID_CLIENT),
	692	WM_COMMAND,
	693	MPFROM2SHORT(IDM_GREP, 0),
	694	MPVOID);
	695	if (SHORT1FROMMP(mp1) == IDM_SEEALL)
	696	PostMsg(WinWindowFromID(hwndC, FID_CLIENT),
	697	WM_COMMAND,
	698	MPFROM2SHORT(IDM_SEEALL, 0),
	699	MPVOID);
[2]	700	}
[133]	701	}
	702	break;
[2]	703
[133]	704	case IDM_EDITCOMMANDS:
	705	EditCommands(hwnd);
	706	break;
	707
	708	default:
	709	if (SHORT1FROMMP(mp1) >= IDM_SWITCHSTART &&
	710	SHORT1FROMMP(mp1) < IDM_SWITCHSTART + 499)
	711	{
	712	if (SHORT1FROMMP(mp1) - IDM_SWITCHSTART < numswitches)
	713	WinSwitchToProgram(switches[SHORT1FROMMP(mp1) -
	714	IDM_SWITCHSTART]);
[2]	715	break;
[133]	716	}
	717	else if (SHORT1FROMMP(mp1) >= IDM_COMMANDSTART &&
	718	SHORT1FROMMP(mp1) < IDM_QUICKTOOLSTART)
	719	{
[2]	720
[133]	721	INT x;
	722	HWND hwndCnr;
	723
	724	if (!cmdloaded)
	725	load_commands();
	726	hwndCnr = TopWindow(hwnd, (HWND) 0);
	727	hwndCnr = (HWND) WinSendMsg(WinWindowFromID(hwndCnr, FID_CLIENT),
	728	UM_CONTAINERHWND,
	729	MPVOID,
	730	MPVOID);
	731	if (!hwndCnr)
	732	{
	733	DosBeep(50, 100);
	734	break;
[2]	735	}
[133]	736	x = SHORT1FROMMP(mp1) - IDM_COMMANDSTART;
	737	if (x >= 0)
	738	{
	739	x++;
	740	RunCommand(hwndCnr, x);
	741	if (fUnHilite)
	742	{
[2]	743
[133]	744	PCNRITEM pci;
	745	DIRCNRDATA *dcd = NULL;
[2]	746
[133]	747	if (WinQueryWindowUShort(hwndCnr, QWS_ID) != TREE_CNR)
	748	dcd = INSTDATA(hwndCnr);
	749	pci = (PCNRITEM) WinSendMsg(hwndCnr,
	750	CM_QUERYRECORDEMPHASIS,
	751	MPFROMLONG(CMA_FIRST),
	752	MPFROMSHORT(CRA_CURSORED));
	753	if (pci && (INT) pci != -1 &&
	754	(pci -> rc.flRecordAttr & CRA_SELECTED))
	755	UnHilite(hwnd,
	756	TRUE,
	757	((dcd) ? &dcd -> lastselection : NULL));
	758	}
[2]	759	}
[133]	760	}
	761	else if (SHORT1FROMMP(mp1) >= IDM_QUICKTOOLSTART &&
	762	SHORT1FROMMP(mp1) < IDM_QUICKTOOLSTART + 50)
	763	{
	764	if (!qtloaded)
	765	load_quicktools();
	766	if (quicktool[SHORT1FROMMP(mp1) - IDM_QUICKTOOLSTART])
	767	{
	768	if (fToolsChanged)
	769	save_tools(NULL);
	770	if (!load_tools(quicktool[SHORT1FROMMP(mp1) - IDM_QUICKTOOLSTART]))
	771	load_tools(NULL);
	772	else
	773	{
	774	strcpy(lasttoolbox, quicktool[SHORT1FROMMP(mp1) - IDM_QUICKTOOLSTART]);
	775	PrfWriteProfileString(fmprof,
	776	FM3Str,
	777	"LastToolBox",
	778	lasttoolbox);
	779	}
	780	BuildTools(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
	781	MAIN_TOOLS),
	782	TRUE);
[2]	783	}
[133]	784	}
	785	else
	786	{
[2]	787
[133]	788	HWND hwndActive;
[2]	789
[133]	790	hwndActive = TopWindow(hwnd, (HWND) 0);
	791	if (hwndActive)
	792	PostMsg(WinWindowFromID(hwndActive, FID_CLIENT),
	793	msg,
	794	mp1,
	795	mp2);
	796	}
	797	break;
[2]	798	}
	799	return 0;
	800	}
	801
[133]	802	MRESULT EXPENTRY MainWMOnce2(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
	803	{
[2]	804
	805	PERSON1DATA *pd;
	806
[133]	807	switch (msg)
	808	{
	809	case WM_CREATE:
	810	{
	811	TID tid;
[2]	812
[133]	813	WinQueryWindowProcess(hwnd, &mypid, &tid);
	814	}
	815	hwndMain = hwnd;
	816	WinSetWindowUShort(hwnd, QWL_USER + 8, 0);
	817	WinSetWindowUShort(hwnd, QWL_USER + 10, 0);
	818	WinSetWindowUShort(hwnd, QWL_USER + 12, 0);
	819	WinSetWindowUShort(hwnd, QWL_USER + 16, 0);
	820	if (_beginthread(MakeMainObjWin,
	821	NULL,
	822	245760,
	823	MPVOID) == -1)
	824	{
	825	PostMsg(hwnd,
	826	WM_CLOSE,
	827	MPVOID,
	828	MPVOID);
	829	return 0;
	830	}
	831	else
	832	DosSleep(64);
[2]	833
[133]	834	pd = malloc(sizeof(PERSON1DATA));
	835	if (!pd)
	836	WinDestroyWindow(WinQueryWindow(hwnd, QW_PARENT));
	837	else
	838	{
	839	memset(pd, 0, sizeof(PERSON1DATA));
	840	pd -> size = sizeof(PERSON1DATA);
	841	WinSetWindowPtr(hwnd, 4, (PVOID) pd);
	842	}
	843	{
	844	SWP swp;
	845	PFNWP oldproc;
[2]	846
[133]	847	/*
	848	* create frame children (not client children, frame children)
	849	*/
	850	DosSleep(1L);
	851	WinQueryWindowPos(WinQueryWindow(hwnd, QW_PARENT), &swp);
	852	oldproc = WinSubclassWindow(WinQueryWindow(hwnd, QW_PARENT),
	853	(PFNWP) MainFrameWndProc2);
	854	if (oldproc)
	855	WinSetWindowPtr(WinQueryWindow(hwnd, QW_PARENT),
	856	0,
	857	(PVOID) oldproc);
	858	CommonCreateMainChildren(hwnd, &swp);
[2]	859
[133]	860	{
	861	HWND hwndMenu;
[2]	862
[133]	863	hwndMenu = WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
	864	FID_MENU);
	865	WinSetWindowULong(hwnd,
	866	0,
	867	hwndMenu);
	868	SetConditionalCascade(hwndMenu,
	869	IDM_COMMANDSMENU,
	870	IDM_DOITYOURSELF);
	871	SetConditionalCascade(hwndMenu,
	872	IDM_TOOLSUBMENU,
	873	IDM_TOOLBAR);
[2]	874	}
[133]	875	}
	876	WinSetWindowText(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
	877	FID_TITLEBAR),
	878	"FM/2 Lite");
	879	FixSwitchList(WinQueryWindow(hwnd, QW_PARENT),
	880	NULL);
	881	SetSysMenu(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
	882	FID_SYSMENU));
	883	break;
[2]	884
[133]	885	case UM_SETUP:
	886	pd = WinQueryWindowPtr(hwnd, 4);
	887	if (pd)
	888	{
[2]	889
[133]	890	CHAR s[CCHMAXPATH];
	891	ULONG size;
	892	DIRCNRDATA *dcd;
	893	HWND hwndC;
	894	BOOL dummy = TRUE;
[2]	895
[133]	896	size = sizeof(BOOL);
	897	PrfQueryProfileData(fmprof,
	898	realappname,
	899	"FM/4 TreeUp",
	900	(PVOID) & dummy,
	901	&size);
	902	if (dummy)
	903	{
	904	size = sizeof(ULONG);
	905	hwndTree = StartTreeCnr(hwnd, 3);
	906	PrfQueryProfileData(fmprof,
	907	realappname,
	908	"FM/4 TreeWidth",
	909	(PVOID) & TreeWidth,
	910	&size);
	911	TreeWidth = max(TreeWidth, 80);
	912	}
	913	size = sizeof(BOOL);
	914	if (PrfQueryProfileData(fmprof,
	915	FM3Str,
	916	"Toolbar",
	917	&dummy,
	918	&size) &&
	919	size && !dummy)
	920	WinSendMsg(hwnd,
	921	WM_COMMAND,
	922	MPFROM2SHORT(IDM_TOOLBAR, 0),
	923	MPVOID);
[2]	924
[133]	925	size = sizeof(s);
	926	*s = 0;
	927	if (PrfQueryProfileData(fmprof,
	928	realappname,
	929	"FM/4 Dir1",
	930	s,
	931	&size) &&
	932	*s)
	933	MakeValidDir(s);
	934	else
	935	save_dir(s);
	936	pd -> hwndLastDir = pd -> hwndCurr = pd -> hwndDir1 =
	937	StartDirCnr(hwnd, s, (HWND) 0, 3);
	938	size = sizeof(s);
	939	*s = 0;
	940	if (PrfQueryProfileData(fmprof,
	941	realappname,
	942	"FM/4 Dir2",
	943	s,
	944	&size) &&
	945	*s)
	946	MakeValidDir(s);
	947	else
	948	save_dir(s);
	949	pd -> hwndDir2 = StartDirCnr(hwnd, s, (HWND) 0, 3);
	950	WinSetFocus(HWND_DESKTOP,
	951	pd -> hwndCurr);
[2]	952
[133]	953	hwndC = WinWindowFromID(pd -> hwndDir1, FID_CLIENT);
	954	if (hwndC)
	955	{
	956	dcd = WinQueryWindowPtr(WinWindowFromID(hwndC, DIR_CNR), 0);
	957	if (dcd)
	958	{
	959	size = sizeof(INT);
	960	if (PrfQueryProfileData(fmprof,
	961	realappname,
	962	"FM/4 Dir1.Sort",
	963	(PVOID) & dcd -> sortFlags,
	964	&size) &&
	965	size == sizeof(INT))
	966	{
	967	if (!dcd -> sortFlags)
	968	dcd -> sortFlags = SORT_PATHNAME;
	969	}
	970	size = sizeof(MASK);
	971	if (PrfQueryProfileData(fmprof,
	972	realappname,
	973	"FM/4 Dir1.Filter",
	974	(PVOID) & dcd -> mask,
	975	&size) &&
	976	size)
	977	{
	978	if (*dcd -> mask.szMask)
	979	WinSendMsg(WinWindowFromID(hwndC, DIR_CNR),
	980	UM_FILTER,
	981	MPFROMP(dcd -> mask.szMask),
	982	MPVOID);
	983	}
	984	*(dcd -> mask.prompt) = 0;
	985	size = sizeof(ULONG);
	986	if (PrfQueryProfileData(fmprof,
	987	realappname,
	988	"FM/4 Dir1.View",
	989	(PVOID) & dcd -> flWindowAttr,
	990	&size) &&
	991	size == sizeof(ULONG))
	992	{
[2]	993
[133]	994	CNRINFO cnri;
[2]	995
[133]	996	memset(&cnri, 0, sizeof(CNRINFO));
	997	cnri.cb = sizeof(CNRINFO);
	998	if (WinSendMsg(WinWindowFromID(hwndC, DIR_CNR),
	999	CM_QUERYCNRINFO,
	1000	MPFROMP(&cnri),
	1001	MPFROMLONG(sizeof(CNRINFO))))
	1002	{
	1003	cnri.flWindowAttr = dcd -> flWindowAttr;
	1004	WinSendMsg(WinWindowFromID(hwndC, DIR_CNR),
	1005	CM_SETCNRINFO,
	1006	MPFROMP(&cnri),
	1007	MPFROMLONG(CMA_FLWINDOWATTR));
	1008	}
	1009	}
	1010	}
	1011	}
[2]	1012
[133]	1013	hwndC = WinWindowFromID(pd -> hwndDir2, FID_CLIENT);
	1014	if (hwndC)
	1015	{
	1016	dcd = WinQueryWindowPtr(WinWindowFromID(hwndC, DIR_CNR), 0);
	1017	if (dcd)
	1018	{
	1019	size = sizeof(INT);
	1020	if (PrfQueryProfileData(fmprof,
	1021	realappname,
	1022	"FM/4 Dir2.Sort",
	1023	(PVOID) & dcd -> sortFlags,
	1024	&size) &&
	1025	size == sizeof(INT))
	1026	{
	1027	if (!dcd -> sortFlags)
	1028	dcd -> sortFlags = SORT_PATHNAME;
	1029	}
	1030	size = sizeof(MASK);
	1031	if (PrfQueryProfileData(fmprof,
	1032	realappname,
	1033	"FM/4 Dir2.Filter",
	1034	(PVOID) & dcd -> mask,
	1035	&size) &&
	1036	size)
	1037	{
	1038	if (*dcd -> mask.szMask)
	1039	WinSendMsg(WinWindowFromID(hwndC, DIR_CNR),
	1040	UM_FILTER,
	1041	MPFROMP(dcd -> mask.szMask),
	1042	MPVOID);
	1043	}
	1044	*(dcd -> mask.prompt) = 0;
	1045	size = sizeof(ULONG);
	1046	if (PrfQueryProfileData(fmprof,
	1047	realappname,
	1048	"FM/4 Dir2.View",
	1049	(PVOID) & dcd -> flWindowAttr,
	1050	&size) &&
	1051	size == sizeof(ULONG))
	1052	{
[2]	1053
[133]	1054	CNRINFO cnri;
[2]	1055
[133]	1056	memset(&cnri, 0, sizeof(CNRINFO));
	1057	cnri.cb = sizeof(CNRINFO);
	1058	if (WinSendMsg(WinWindowFromID(hwndC, DIR_CNR),
	1059	CM_QUERYCNRINFO,
	1060	MPFROMP(&cnri),
	1061	MPFROMLONG(sizeof(CNRINFO))))
	1062	{
	1063	cnri.flWindowAttr = dcd -> flWindowAttr;
	1064	WinSendMsg(WinWindowFromID(hwndC, DIR_CNR),
	1065	CM_SETCNRINFO,
	1066	MPFROMP(&cnri),
	1067	MPFROMLONG(CMA_FLWINDOWATTR));
	1068	}
	1069	}
	1070	}
[2]	1071	}
[133]	1072	}
	1073	{
	1074	ULONG which = 0, size = sizeof(ULONG);
	1075
	1076	if (PrfQueryProfileData(fmprof,
	1077	realappname,
	1078	"FM/4 Max",
	1079	(PVOID) & which,
	1080	&size) &&
	1081	size == sizeof(ULONG) &&
	1082	which)
[2]	1083	{
[133]	1084	PostMsg(hwnd,
	1085	UM_MAXIMIZE,
	1086	MPFROMLONG(((which == 1) ?
	1087	pd -> hwndDir1 :
	1088	pd -> hwndDir2)),
	1089	MPVOID);
[2]	1090	}
[133]	1091	}
	1092	PostMsg(hwnd,
	1093	UM_SIZE,
	1094	MPVOID,
	1095	MPVOID);
	1096	if (!hwndTree)
[2]	1097	PostMsg(hwnd,
[133]	1098	UM_BUILDDRIVES,
	1099	MPVOID,
	1100	MPVOID);
	1101	load_tools(NULL);
	1102	BuildTools(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
	1103	MAIN_TOOLS),
	1104	TRUE);
	1105	fRunning = TRUE;
	1106	return 0;
[2]	1107
[133]	1108	case WM_SAVEAPPLICATION:
	1109	WinStoreWindowPos(FM2Str,
	1110	"MainWindowPos2",
	1111	WinQueryWindow(hwnd, QW_PARENT));
	1112	pd = WinQueryWindowPtr(hwnd, 4);
	1113	if (pd)
	1114	{
[2]	1115
[133]	1116	CHAR s[CCHMAXPATH];
	1117	HWND hwndC;
	1118	DIRCNRDATA *dcd;
	1119	ULONG flWindowAttr;
[2]	1120
[133]	1121	*s = 0;
	1122	WinSendMsg(pd -> hwndDir1,
	1123	UM_CONTAINERDIR,
	1124	MPFROMP(s),
	1125	MPVOID);
	1126	if (*s)
	1127	{
	1128	MakeValidDir(s);
	1129	PrfWriteProfileString(fmprof,
	1130	realappname,
	1131	"FM/4 Dir1",
	1132	s);
	1133	}
	1134	*s = 0;
	1135	WinSendMsg(pd -> hwndDir2,
	1136	UM_CONTAINERDIR,
	1137	MPFROMP(s),
	1138	MPVOID);
	1139	if (*s)
	1140	{
	1141	MakeValidDir(s);
	1142	PrfWriteProfileString(fmprof,
	1143	realappname,
	1144	"FM/4 Dir2",
	1145	s);
	1146	}
	1147	flWindowAttr = (pd -> hwndMax == pd -> hwndDir1) ?
	1148	1 :
	1149	(pd -> hwndMax == pd -> hwndDir2) ?
	1150	2 :
	1151	0;
	1152	PrfWriteProfileData(fmprof,
	1153	realappname,
	1154	"FM/4 Max",
	1155	&flWindowAttr,
	1156	sizeof(flWindowAttr));
	1157	hwndC = WinWindowFromID(pd -> hwndDir1, FID_CLIENT);
	1158	if (hwndC)
	1159	{
	1160	dcd = WinQueryWindowPtr(WinWindowFromID(hwndC, DIR_CNR), 0);
	1161	if (dcd)
	1162	{
	1163	flWindowAttr = dcd -> flWindowAttr;
	1164	if (!fLeaveTree && (flWindowAttr & CV_TREE))
	1165	{
	1166	flWindowAttr &= (~(CV_TREE \| CV_ICON \| CV_DETAIL \| CV_TEXT));
	1167	if (dcd -> lastattr)
	1168	{
	1169	if (dcd -> lastattr & CV_TEXT)
	1170	flWindowAttr \|= CV_TEXT;
	1171	else if (dcd -> lastattr & CV_DETAIL)
	1172	flWindowAttr \|= CV_DETAIL;
	1173	else if (dcd -> lastattr & CV_ICON)
	1174	flWindowAttr \|= CV_ICON;
	1175	else
	1176	flWindowAttr \|= CV_NAME;
	1177	}
	1178	else
	1179	flWindowAttr \|= CV_NAME;
	1180	}
	1181	PrfWriteProfileData(fmprof,
	1182	realappname,
	1183	"FM/4 Dir1.Sort",
	1184	(PVOID) & dcd -> sortFlags,
	1185	sizeof(INT));
	1186	PrfWriteProfileData(fmprof,
	1187	realappname,
	1188	"FM/4 Dir1.Filter",
	1189	(PVOID) & dcd -> mask,
	1190	sizeof(MASK));
	1191	PrfWriteProfileData(fmprof,
	1192	realappname,
	1193	"FM/4 Dir1.View",
	1194	(PVOID) & flWindowAttr,
	1195	sizeof(ULONG));
	1196	}
	1197	}
[2]	1198
[133]	1199	hwndC = WinWindowFromID(pd -> hwndDir2, FID_CLIENT);
	1200	if (hwndC)
	1201	{
	1202	dcd = WinQueryWindowPtr(WinWindowFromID(hwndC, DIR_CNR), 0);
	1203	if (dcd)
	1204	{
	1205	flWindowAttr = dcd -> flWindowAttr;
	1206	if (!fLeaveTree && (flWindowAttr & CV_TREE))
	1207	{
	1208	flWindowAttr &= (~(CV_TREE \| CV_ICON \| CV_DETAIL \| CV_TEXT));
	1209	if (dcd -> lastattr)
	1210	{
	1211	if (dcd -> lastattr & CV_TEXT)
	1212	flWindowAttr \|= CV_TEXT;
	1213	else if (dcd -> lastattr & CV_DETAIL)
	1214	flWindowAttr \|= CV_DETAIL;
	1215	else if (dcd -> lastattr & CV_ICON)
	1216	flWindowAttr \|= CV_ICON;
	1217	else
	1218	flWindowAttr \|= CV_NAME;
	1219	}
	1220	else
	1221	flWindowAttr \|= CV_NAME;
	1222	}
	1223	PrfWriteProfileData(fmprof,
	1224	realappname,
	1225	"FM/4 Dir2.Sort",
	1226	(PVOID) & dcd -> sortFlags,
	1227	sizeof(INT));
	1228	PrfWriteProfileData(fmprof,
	1229	realappname,
	1230	"FM/4 Dir2.Filter",
	1231	(PVOID) & dcd -> mask,
	1232	sizeof(MASK));
	1233	PrfWriteProfileData(fmprof,
	1234	realappname,
	1235	"FM/4 Dir2.View",
	1236	(PVOID) & flWindowAttr,
	1237	sizeof(ULONG));
	1238	}
[2]	1239	}
[133]	1240	}
	1241	break;
[2]	1242	}
[133]	1243	return WinDefWindowProc(hwnd, msg, mp1, mp2);
[2]	1244	}
	1245
[133]	1246	MRESULT EXPENTRY MainWndProc2(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
	1247	{
[2]	1248
	1249	PERSON1DATA *pd;
	1250
[133]	1251	switch (msg)
	1252	{
	1253	case WM_SAVEAPPLICATION:
	1254	case UM_SETUP:
	1255	case WM_CREATE:
	1256	return MainWMOnce2(hwnd, msg, mp1, mp2);
[2]	1257
[133]	1258	case UM_THREADUSE:
	1259	case UM_LOADFILE:
	1260	case UM_BUILDDRIVES:
	1261	return CommonMainWndProc(hwnd, msg, mp1, mp2);
[2]	1262
[133]	1263	case UM_SETUP2:
	1264	pd = WinQueryWindowPtr(hwnd, 4);
	1265	if (pd)
	1266	{
	1267	if (mp1)
	1268	{
	1269	if (pd -> hwndDir1 &&
	1270	(!pd -> hwndMax \|\| pd -> hwndMax == pd -> hwndDir1))
	1271	BoxWindow(pd -> hwndDir1,
	1272	(HPS) 0,
	1273	CLR_PALEGRAY);
	1274	if (pd -> hwndDir2 &&
	1275	(!pd -> hwndMax \|\| pd -> hwndMax == pd -> hwndDir2))
	1276	BoxWindow(pd -> hwndDir2,
	1277	(HPS) 0,
	1278	CLR_PALEGRAY);
	1279	if (hwndTree)
	1280	BoxWindow(hwndTree,
	1281	(HPS) 0,
	1282	CLR_PALEGRAY);
[2]	1283	}
[133]	1284	else
	1285	{
	1286	if (hwndTree)
	1287	BoxWindow(hwndTree,
	1288	(HPS) 0,
	1289	(pd -> hwndCurr == hwndTree) ?
	1290	CLR_RED :
	1291	CLR_WHITE);
	1292	if (!pd -> hwndMax \|\|
	1293	pd -> hwndMax == pd -> hwndDir1)
	1294	BoxWindow(pd -> hwndDir1,
	1295	(HPS) 0,
	1296	(pd -> hwndDir1 == pd -> hwndCurr) ?
	1297	CLR_RED :
	1298	(pd -> hwndDir1 == pd -> hwndLastDir) ?
	1299	CLR_DARKRED :
	1300	CLR_PALEGRAY);
	1301	if (!pd -> hwndMax \|\|
	1302	pd -> hwndMax == pd -> hwndDir2)
	1303	BoxWindow(pd -> hwndDir2,
	1304	(HPS) 0,
	1305	(pd -> hwndDir2 == pd -> hwndCurr) ?
	1306	CLR_RED :
	1307	(pd -> hwndDir2 == pd -> hwndLastDir) ?
	1308	CLR_DARKRED :
	1309	CLR_PALEGRAY);
	1310	}
	1311	}
	1312	return 0;
[2]	1313
[133]	1314	case WM_BUTTON1DOWN:
	1315	shiftstate = (SHORT2FROMMP(mp2) & (KC_ALT \| KC_SHIFT \| KC_CTRL));
	1316	if (hwndTree)
	1317	{
[2]	1318
[133]	1319	SWP swp;
[2]	1320
[133]	1321	WinQueryWindowPos(hwndTree, &swp);
	1322	if (SHORT1FROMMP(mp1) > (swp.x + swp.cx) - 3 &&
	1323	SHORT1FROMMP(mp1) < (swp.x + swp.cx) + 3)
	1324	{
[2]	1325
[133]	1326	SWP swpC;
	1327	TRACKINFO track;
[2]	1328
[133]	1329	WinQueryWindowPos(hwnd, &swpC);
	1330	track.cxBorder = 4;
	1331	track.cyBorder = 4;
	1332	track.cxGrid = 1;
	1333	track.cyGrid = 1;
	1334	track.cxKeyboard = 8;
	1335	track.cyKeyboard = 8;
	1336	track.rclTrack.yBottom = 2;
	1337	track.rclTrack.yTop = swpC.cy - 4;
	1338	track.rclTrack.xLeft = 2;
	1339	track.rclTrack.xRight = swp.x + swp.cx + 2;
	1340	track.rclBoundary = track.rclTrack;
	1341	track.rclBoundary.xRight = swpC.cx - 80;
	1342	track.ptlMinTrackSize.x = 80;
	1343	track.ptlMinTrackSize.y = swpC.cy - 4;
	1344	track.ptlMaxTrackSize.x = swpC.cx - 80;
	1345	track.ptlMaxTrackSize.y = swpC.cy - 4;
	1346	track.fs = TF_RIGHT;
	1347	if (WinTrackRect(hwnd, (HPS) 0, &track))
	1348	{
	1349	TreeWidth = track.rclTrack.xRight - track.rclTrack.xLeft;
	1350	PrfWriteProfileData(fmprof,
	1351	realappname,
	1352	"FM/4 TreeWidth",
	1353	&TreeWidth,
	1354	sizeof(ULONG));
	1355	WinSendMsg(hwnd,
	1356	UM_SETUP2,
	1357	MPFROMLONG(1),
	1358	MPVOID);
	1359	PostMsg(hwnd,
	1360	UM_SIZE,
	1361	MPVOID,
	1362	MPVOID);
	1363	}
	1364	return (MRESULT) TRUE;
[2]	1365	}
[133]	1366	}
	1367	break;
[2]	1368
[133]	1369	case WM_MOUSEMOVE:
	1370	shiftstate = (SHORT2FROMMP(mp2) & (KC_ALT \| KC_SHIFT \| KC_CTRL));
	1371	if (hwndTree)
	1372	{
[2]	1373
[133]	1374	SWP swp;
[2]	1375
[133]	1376	if (WinQueryWindowPos(hwndTree, &swp))
	1377	{
	1378	if (SHORT1FROMMP(mp1) > (swp.x + swp.cx) - 3 &&
	1379	SHORT1FROMMP(mp1) < (swp.x + swp.cx) + 3)
	1380	WinSetPointer(HWND_DESKTOP, hptrEW);
	1381	else
	1382	WinSetPointer(HWND_DESKTOP, hptrArrow);
[2]	1383	}
[133]	1384	else
	1385	WinSetPointer(HWND_DESKTOP, hptrArrow);
	1386	}
	1387	return (MRESULT) TRUE;
[2]	1388
[133]	1389	case WM_BUTTON1UP:
	1390	case WM_BUTTON2UP:
	1391	case WM_BUTTON3UP:
	1392	case WM_CHAR:
	1393	shiftstate = (SHORT1FROMMP(mp1) & (KC_SHIFT \| KC_ALT \| KC_CTRL));
	1394	break;
[2]	1395
[133]	1396	case UM_ADVISEFOCUS:
	1397	pd = WinQueryWindowPtr(hwnd, 4);
	1398	if (mp1 &&
	1399	pd &&
	1400	(HWND) mp1 != pd -> hwndCurr)
	1401	{
	1402	if ((HWND) mp1 != hwndTree)
	1403	pd -> hwndLastDir = (HWND) mp1;
	1404	pd -> hwndCurr = (HWND) mp1;
	1405	WinSendMsg(hwnd,
	1406	UM_SETUP2,
	1407	MPVOID,
	1408	MPVOID);
	1409	}
	1410	return 0;
[2]	1411
[133]	1412	case UM_MAXIMIZE:
	1413	if (mp1)
	1414	{
	1415	pd = WinQueryWindowPtr(hwnd, 4);
	1416	if (pd)
	1417	{
	1418	WinSendMsg(hwnd,
	1419	UM_SETUP2,
	1420	MPFROMLONG(1),
	1421	MPVOID);
	1422	if (pd -> hwndMax != (HWND) mp1)
	1423	{
	1424	pd -> hwndMax = (HWND) mp1;
	1425	WinSetFocus(HWND_DESKTOP,
	1426	pd -> hwndMax);
	1427	}
	1428	else
	1429	pd -> hwndMax = (HWND) 0;
	1430	PostMsg(hwnd,
	1431	UM_SIZE,
	1432	MPVOID,
	1433	MPVOID);
[2]	1434	}
[133]	1435	}
	1436	return 0;
[2]	1437
[133]	1438	case WM_INITMENU:
	1439	switch (SHORT1FROMMP(mp1))
	1440	{
	1441	case IDM_FILESMENU:
	1442	case IDM_VIEWSMENU:
	1443	case IDM_DETAILSSETUP:
	1444	case IDM_COMMANDSMENU:
	1445	case IDM_SORTSUBMENU:
	1446	pd = WinQueryWindowPtr(hwnd, 4);
	1447	if (pd)
	1448	WinSendMsg(pd -> hwndCurr,
	1449	UM_INITMENU,
	1450	mp1,
	1451	mp2);
[2]	1452	break;
[133]	1453	case IDM_CONFIGMENU:
	1454	WinCheckMenuItem((HWND) mp2,
	1455	IDM_TOOLSUBMENU,
	1456	fToolbar);
	1457	WinCheckMenuItem((HWND) mp2,
	1458	IDM_AUTOVIEW,
	1459	fAutoView);
[2]	1460	break;
[133]	1461	case IDM_TOOLSUBMENU:
	1462	WinCheckMenuItem((HWND) mp2,
	1463	IDM_TOOLBAR,
	1464	fToolbar);
	1465	WinCheckMenuItem((HWND) mp2,
	1466	IDM_TEXTTOOLS,
	1467	fTextTools);
	1468	WinCheckMenuItem((HWND) mp2,
	1469	IDM_TOOLTITLES,
	1470	fToolTitles);
	1471	break;
	1472	case IDM_WINDOWSMENU:
	1473	WinCheckMenuItem((HWND) mp2,
	1474	IDM_VTREE,
	1475	(hwndTree != (HWND) 0));
	1476	WinCheckMenuItem((HWND) mp2,
	1477	IDM_TILEBACKWARDS,
	1478	fTileBackwards);
	1479	SetupWinList((HWND) mp2,
	1480	hwnd,
	1481	WinQueryWindow(hwnd, QW_PARENT));
	1482	break;
	1483	}
	1484	break;
[2]	1485
[133]	1486	case WM_SETFOCUS:
	1487	if (mp2)
	1488	PostMsg(hwnd,
	1489	UM_FOCUSME,
	1490	MPVOID,
	1491	MPVOID);
	1492	break;
[2]	1493
[133]	1494	case UM_FOCUSME:
	1495	pd = WinQueryWindowPtr(hwnd, 4);
	1496	if (pd)
	1497	WinSetFocus(HWND_DESKTOP,
	1498	pd -> hwndCurr);
	1499	return 0;
[2]	1500
[133]	1501	case UM_RESCAN:
	1502	return 0;
	1503
	1504	case UM_SIZE:
	1505	{
	1506	SWP swp;
	1507
	1508	if (WinQueryWindowPos(hwnd, &swp))
[2]	1509	{
[133]	1510	mp1 = MPFROM2SHORT(swp.cx, swp.cy);
	1511	mp2 = MPFROM2SHORT(swp.cx, swp.cy);
[2]	1512	}
[133]	1513	else
	1514	return 0;
	1515	}
	1516	/* intentional fallthru */
	1517	case WM_SIZE:
	1518	pd = WinQueryWindowPtr(hwnd, 4);
	1519	if (mp1 &&
	1520	mp2 &&
	1521	pd &&
	1522	pd -> hwndDir1 &&
	1523	pd -> hwndDir2)
	1524	{
	1525	if (hwndTree)
	1526	WinSetWindowPos(hwndTree,
	1527	HWND_TOP,
	1528	2,
	1529	2,
	1530	TreeWidth - 4,
	1531	SHORT2FROMMP(mp2) - 4,
	1532	SWP_SHOW \| SWP_MOVE \| SWP_SIZE);
	1533	else
	1534	TreeWidth = 0;
	1535	if (!pd -> hwndMax)
	1536	{
	1537	if (fTileBackwards)
	1538	{
	1539	WinSetWindowPos(pd -> hwndDir1, HWND_TOP,
	1540	(((SHORT1FROMMP(mp2) - TreeWidth) / 2) +
	1541	TreeWidth) + 2,
	1542	2,
	1543	((SHORT1FROMMP(mp2) - TreeWidth) / 2) - 4,
	1544	SHORT2FROMMP(mp2) - 4,
	1545	SWP_SHOW \| SWP_MOVE \| SWP_SIZE);
	1546	WinSetWindowPos(pd -> hwndDir2, HWND_TOP,
	1547	TreeWidth + 2,
	1548	2,
	1549	((SHORT1FROMMP(mp2) - TreeWidth) / 2) - 4,
	1550	SHORT2FROMMP(mp2) - 4,
	1551	SWP_SHOW \| SWP_MOVE \| SWP_SIZE);
	1552	}
	1553	else
	1554	{
	1555	WinSetWindowPos(pd -> hwndDir1, HWND_TOP,
	1556	TreeWidth + 2,
	1557	2,
	1558	(SHORT1FROMMP(mp2) - TreeWidth) - 4,
	1559	(SHORT2FROMMP(mp2) / 2) - 4,
	1560	SWP_SHOW \| SWP_MOVE \| SWP_SIZE);
	1561	WinSetWindowPos(pd -> hwndDir2, HWND_TOP,
	1562	TreeWidth + 2,
	1563	(SHORT2FROMMP(mp2) / 2) + 2,
	1564	(SHORT1FROMMP(mp2) - TreeWidth) - 4,
	1565	(SHORT2FROMMP(mp2) / 2) - 4,
	1566	SWP_SHOW \| SWP_MOVE \| SWP_SIZE);
	1567	}
	1568	}
	1569	else
	1570	{
[2]	1571
[133]	1572	HWND hwndOther;
[2]	1573
[133]	1574	WinSetWindowPos(pd -> hwndMax, HWND_TOP,
	1575	TreeWidth + 2,
	1576	2,
	1577	(SHORT1FROMMP(mp2) - TreeWidth) - 4,
	1578	SHORT2FROMMP(mp2) - 4,
	1579	SWP_SHOW \| SWP_MOVE \| SWP_SIZE);
	1580	hwndOther = (pd -> hwndMax == pd -> hwndDir1) ?
	1581	pd -> hwndDir2 : pd -> hwndDir1;
	1582	WinSetWindowPos(hwndOther, HWND_BOTTOM, 0, 0, 0, 0, SWP_HIDE);
[2]	1583	}
[133]	1584	WinSendMsg(hwnd,
	1585	UM_SETUP2,
	1586	MPVOID,
	1587	MPVOID);
	1588	}
	1589	if (msg == UM_SIZE)
[2]	1590	return 0;
[133]	1591	break;
[2]	1592
[133]	1593	case WM_ERASEBACKGROUND:
	1594	WinFillRect((HPS) mp1,
	1595	(PRECTL) mp2,
	1596	0x00d0d0d0);
	1597	return 0;
	1598
	1599	case WM_PAINT:
	1600	{
	1601	HPS hps;
	1602	RECTL rcl;
	1603
	1604	hps = WinBeginPaint(hwnd,
	1605	NULLHANDLE,
	1606	NULL);
	1607	if (hps)
[2]	1608	{
[133]	1609	WinQueryWindowRect(hwnd, &rcl);
	1610	WinFillRect(hps,
	1611	(PRECTL) & rcl,
	1612	CLR_PALEGRAY);
	1613	WinEndPaint(hps);
	1614	WinSendMsg(hwnd,
	1615	UM_SETUP2,
	1616	MPVOID,
	1617	MPVOID);
[2]	1618	}
[133]	1619	}
	1620	break;
[2]	1621
[133]	1622	case UM_COMMAND:
	1623	case WM_COMMAND:
	1624	return MainWMCommand2(hwnd, msg, mp1, mp2);
[2]	1625
[133]	1626	case WM_CLOSE:
	1627	fAmClosing = TRUE;
	1628	WinSendMsg(hwnd,
	1629	WM_SAVEAPPLICATION,
	1630	MPVOID,
	1631	MPVOID);
	1632	CloseChildren(hwnd);
	1633	PostMsg(hwnd,
	1634	UM_CLOSE,
	1635	MPVOID,
	1636	MPVOID);
	1637	DosSleep(1L);
	1638	return 0;
[2]	1639
[133]	1640	case UM_CLOSE:
	1641	WinDestroyWindow(WinQueryWindow(hwnd, QW_PARENT));
	1642	return 0;
[2]	1643
[133]	1644	case WM_DESTROY:
	1645	hwndMain = (HWND) 0;
	1646	pd = WinQueryWindowPtr(hwnd, 4);
	1647	if (pd)
	1648	free(pd);
	1649	if (!PostMsg((HWND) 0,
	1650	WM_QUIT,
	1651	MPVOID,
	1652	MPVOID))
	1653	WinSendMsg((HWND) 0,
	1654	WM_QUIT,
	1655	MPVOID,
	1656	MPVOID);
	1657	break;
[2]	1658	}
[133]	1659	return WinDefWindowProc(hwnd, msg, mp1, mp2);
[2]	1660	}
	1661
[133]	1662	HWND StartFM32(HAB hab, INT argc, CHAR ** argv)
	1663	{
[2]	1664
[133]	1665	HWND hwndFrame, hwndClient;
	1666	ULONG FrameFlags = FCF_TITLEBAR \| FCF_SYSMENU \|
	1667	FCF_SIZEBORDER \| FCF_MINMAX \|
	1668	FCF_ACCELTABLE \| FCF_MENU \|
	1669	FCF_ICON \| FCF_TASKLIST \|
	1670	FCF_NOBYTEALIGN;
[2]	1671
	1672	{
	1673	INT x;
	1674
[133]	1675	for (x = 1; x < argc; x++)
	1676	{
	1677	if (*argv[x] == '+' && !argv[x][1])
	1678	fLogFile = TRUE;
	1679	if (*argv[x] == '-')
	1680	{
	1681	if (argv[x][1])
	1682	strcpy(profile, &argv[x][1]);
[2]	1683	}
	1684	}
	1685	}
	1686	{
[133]	1687	CHAR inipath[CCHMAXPATH], fullpath[CCHMAXPATH];
[2]	1688	FILESTATUS3 fsa;
	1689
[133]	1690	if (PrfQueryProfileString(HINI_USERPROFILE,
	1691	FM2Str,
	1692	"Home",
	1693	NULL,
	1694	inipath,
	1695	sizeof(inipath)))
	1696	{
	1697	if (!DosQueryPathInfo(inipath,
	1698	FIL_STANDARD,
	1699	&fsa,
	1700	(ULONG) sizeof(fsa)))
	1701	{
	1702	if (fsa.attrFile & FILE_DIRECTORY)
	1703	{
	1704	if (DosQueryPathInfo(inipath,
	1705	FIL_QUERYFULLNAME,
	1706	fullpath,
	1707	sizeof(fullpath)))
	1708	strcpy(fullpath, inipath);
	1709	switch_to(fullpath);
	1710	}
[2]	1711	}
	1712	}
	1713	}
	1714
	1715	hwndFrame = WinCreateStdWindow(HWND_DESKTOP,
[133]	1716	WS_VISIBLE,
	1717	&FrameFlags,
	1718	GetPString(IDS_WCMAINWND2),
	1719	NULL,
	1720	WS_VISIBLE \| WS_ANIMATE,
	1721	FM3ModHandle,
	1722	MAIN2_FRAME,
	1723	&hwndClient);
	1724	if (hwndFrame)
	1725	{
	1726	if (!WinRestoreWindowPos(FM2Str,
	1727	"MainWindowPos2",
	1728	hwndFrame))
	1729	{
[2]	1730
[133]	1731	ULONG fl = SWP_MOVE \| SWP_SIZE;
[2]	1732	RECTL rcl;
[133]	1733	ULONG icz = WinQuerySysValue(HWND_DESKTOP, SV_CYICON) * 3L;
	1734	ULONG bsz = WinQuerySysValue(HWND_DESKTOP, SV_CYSIZEBORDER);
[2]	1735
[133]	1736	WinQueryWindowRect(HWND_DESKTOP, &rcl);
[2]	1737	rcl.yBottom += icz;
	1738	rcl.yTop -= bsz;
	1739	rcl.xLeft += bsz;
	1740	rcl.xRight -= bsz;
	1741	WinSetWindowPos(hwndFrame,
[133]	1742	HWND_TOP,
	1743	rcl.xLeft,
	1744	rcl.yBottom,
	1745	rcl.xRight - rcl.xLeft,
	1746	rcl.yTop - rcl.yBottom,
	1747	fl);
[2]	1748	}
[133]	1749	if (fLogFile)
	1750	LogFileHandle = _fsopen("FM2.LOG", "a+", SH_DENYWR);
	1751	if (hwndHelp)
	1752	WinAssociateHelpInstance(hwndHelp, hwndFrame);
[2]	1753	PostMsg(hwndClient,
[133]	1754	UM_SETUP,
	1755	MPFROMLONG(argc),
	1756	MPFROMP(argv));
[2]	1757	}
	1758	return hwndFrame;
	1759	}

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

Download in other formats: