Context Navigation

source: trunk/dll/mainwnd2.c@ 1209

Visit:

Last change on this file since 1209 was 1186, checked in by John Small, 17 years ago
Ticket 187: Draft 2: Move remaining function declarations
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 39.0 KB

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

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

Download in other formats: