Context Navigation

source: trunk/dll/misc.c@ 960

Visit:

Last change on this file since 960 was 960, checked in by Gregg Young, 18 years ago
One more buffer check.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 66.9 KB

Line
1
2	/***********************************************************************
3
4	$Id: misc.c 960 2008-02-18 03:06:14Z gyoung $
5
6	Misc GUI support functions
7
8	Copyright (c) 1993-98 M. Kimes
9	Copyright (c) 2003, 2008 Steven H. Levine
10
11	11 Jun 03 SHL Add JFS and FAT32 support
12	01 Aug 04 SHL Rework lstrip/rstrip usage
13	01 Aug 04 SHL LoadLibPath: avoid buffer overflow
14	07 Jun 05 SHL Drop obsoletes
15	24 Jul 05 SHL Beautify
16	24 Jul 05 SHL Correct longname display option
17	17 Jul 06 SHL Use Runtime_Error
18	26 Jul 06 SHL Use chop_at_crnl
19	27 Jul 06 SHL Comments, apply indent
20	29 Jul 06 SHL Use xfgets_bstripcr
21	16 Aug 06 SHL Comments
22	31 Aug 06 SHL disable_menuitem: rework args to match name - sheesh
23	10 Oct 06 GKY Add NDFS32 support
24	18 Feb 07 GKY More drive type and drive icon support
25	10 Jun 07 GKY Add IsFm2Window as part of work around PM drag limit
26	05 Jul 07 GKY Fix menu removals for WORKPLACE_PROCESS=YES
27	23 Jul 07 SHL Sync with CNRITEM updates (ticket#24)
28	31 Jul 07 SHL Clean up and report errors (ticket#24)
29	03 Aug 07 GKY Direct editting fixed (ticket#24)
30	06 Aug 07 SHL Use BldQuotedFileName
31	06 Aug 07 GKY Increase Subject EA to 1024
32	06 Aug 07 GKY Reduce DosSleep times (ticket 148)
33	14 Aug 07 SHL Delete obsoletes
34	14 Aug 07 SHL Move #pragma alloc_text to end for OpenWatcom compat
35	01 Sep 07 GKY Use xDosSetPathInfo to fix case where FS3 buffer crosses 64k boundry
36	05 Nov 07 GKY Use commafmtULL to display file sizes for large file support
37	22 Nov 07 GKY Use CopyPresParams to fix presparam inconsistencies in menus
38	12 Jan 08 SHL Document SetConditionalCascade
39	13 Jan 08 GKY Get Subjectwidth/Subjectleft working in the collector.
40	xx Jan 08 JBS Ticket 150: fix/improve save and restore of dir cnr state at FM/2 close/reopen
41	21 Jan 08 GKY Stop reallocating NullStr by direct editing of empty subject and longname strings.
42
43	***********************************************************************/
44
45	#include <stdlib.h>
46	#include <string.h>
47	#include <ctype.h>
48	#include <share.h>
49	#include <malloc.h> // _heapmin
50
51	#define INCL_DOS
52	#define INCL_WIN
53	#define INCL_GPI
54	#define INCL_LONGLONG
55
56	#include "fm3dlg.h"
57	#include "fm3str.h"
58	#include "pathutil.h" // BldQuotedFileName
59	#include "errutil.h" // Dos_Error...
60	#include "strutil.h" // GetPString
61	#include "fm3dll.h"
62
63	#pragma data_seg(DATA1)
64
65	static PSZ pszSrcFile = __FILE__;
66
67	#ifndef BEGIN_LIBPATH
68	#define BEGIN_LIBPATH 1
69	#endif
70
71	#ifndef END_LIBPATH
72	#define END_LIBPATH 2
73	#endif
74
75	#ifndef ORD_DOS32QUERYEXTLIBPATH
76	#define ORD_DOS32QUERYEXTLIBPATH 874
77	#endif
78
79	BOOL IsFm2Window(HWND hwnd, BOOL chkTid)
80	{
81	PIB *ppib;
82	TIB *ptib;
83	BOOL yes;
84	APIRET rc = DosGetInfoBlocks(&ptib, &ppib);
85
86	if (rc) {
87	Dos_Error(MB_CANCEL, rc, HWND_DESKTOP, pszSrcFile, __LINE__,
88	"DosGetInfoBlocks");
89	yes = FALSE;
90	}
91	else {
92	PID pid;
93	TID tid;
94
95	// Check window owned by FM2 process
96	// Check say same thread too, if requested
97	// OK for window to be dead - just return FALSE
98	yes = WinQueryWindowProcess(hwnd, &pid, &tid) &&
99	pid == ppib->pib_ulpid &&
100	(!chkTid \|\| tid == ptib->tib_ptib2->tib2_ultid);
101	}
102	return yes;
103	}
104
105	VOID SetShiftState(VOID)
106	{
107	shiftstate = 0;
108	if (WinGetKeyState(HWND_DESKTOP, VK_CTRL) & 0x8000)
109	shiftstate \|= KC_CTRL;
110	if (WinGetKeyState(HWND_DESKTOP, VK_SHIFT) & 0x8000)
111	shiftstate \|= KC_SHIFT;
112	if (WinGetKeyState(HWND_DESKTOP, VK_ALT) & 0x8000)
113	shiftstate \|= KC_ALT;
114	}
115
116	void EmphasizeButton(HWND hwnd, BOOL on)
117	{
118	HPS hps = DrgGetPS(hwnd);
119
120	// fixme to complain?
121	if (hps) {
122	POINTL ptl;
123	SWP swp;
124
125	WinQueryWindowPos(hwnd, &swp);
126	ptl.x = 1;
127	ptl.y = 1;
128	GpiMove(hps, &ptl);
129	GpiSetColor(hps, on ? CLR_BLACK : CLR_PALEGRAY);
130	ptl.x = swp.cx - 2;
131	ptl.y = swp.cy - 2;
132	GpiBox(hps, DRO_OUTLINE, &ptl, 0, 0);
133	DrgReleasePS(hps);
134	if (remove) //fixme always true
135	WinInvalidateRect(hwnd, NULL, FALSE);
136	}
137	}
138
139	void DrawTargetEmphasis(HWND hwnd, BOOL on)
140	{
141	HPS hps = DrgGetPS(WinQueryWindow(hwnd, QW_PARENT));
142
143	if (hps) {
144	BoxWindow(hwnd, hps, on ? CLR_BLACK : CLR_PALEGRAY);
145	DrgReleasePS(hps);
146	}
147	}
148
149	void BoxWindow(HWND hwnd, HPS hps, LONG color)
150	{
151	POINTL ptl;
152	SWP swp;
153	BOOL releaseme = FALSE;
154
155	if (!hps) {
156	hps = WinGetPS(WinQueryWindow(hwnd, QW_PARENT));
157	releaseme = TRUE;
158	}
159	if (hps && WinQueryWindowPos(hwnd, &swp)) {
160	ptl.x = swp.x - 2;
161	ptl.y = swp.y - 2;
162	GpiMove(hps, &ptl);
163	GpiSetColor(hps, color);
164	ptl.x = swp.x + swp.cx + 1;
165	ptl.y = swp.y + swp.cy + 1;
166	GpiBox(hps, DRO_OUTLINE, &ptl, 0, 0);
167	}
168	if (releaseme && hps)
169	WinReleasePS(hps);
170	}
171
172	void PaintSTextWindow(HWND hwnd, HPS hps)
173	{
174	/*
175	* paint a text window such that the rightmost part of the text is
176	* always visible even if the text length exceeds the length of the
177	* window -- otherwise, paint the window so that it is left-justified
178	* and vertically centered.
179	*/
180
181	char *s = NULL;
182	long len;
183	POINTL aptl[TXTBOX_COUNT], ptl;
184	RECTL rcl;
185	char *p;
186	BOOL releaseme = FALSE;
187
188	if (!hps) {
189	releaseme = TRUE;
190	hps = WinGetPS(hwnd);
191	}
192	if (hps) {
193	WinQueryWindowRect(hwnd, &rcl);
194	WinFillRect(hps, &rcl, CLR_PALEGRAY);
195	len = WinQueryWindowTextLength(hwnd);
196	if (len)
197	s = xmalloc(len + 1, pszSrcFile, __LINE__);
198	if (s) {
199	*s = 0;
200	WinQueryWindowText(hwnd, CCHMAXPATH, s);
201	if (*s) {
202	rcl.xRight -= 3;
203	p = s;
204	GpiQueryTextBox(hps, 3, "...", TXTBOX_COUNT, aptl);
205	len = aptl[TXTBOX_TOPRIGHT].x;
206	do {
207	GpiQueryTextBox(hps, strlen(p), p, TXTBOX_COUNT, aptl);
208	if (aptl[TXTBOX_TOPRIGHT].x > (rcl.xRight - (p != s ? len : 0)))
209	p++;
210	else
211	break;
212	}
213	while (*p);
214	if (*p) {
215	GpiSetMix(hps, FM_OVERPAINT);
216	GpiSetColor(hps, CLR_BLACK);
217	ptl.x = 3;
218	ptl.y = ((rcl.yTop / 2) -
219	((aptl[TXTBOX_TOPRIGHT].y +
220	aptl[TXTBOX_BOTTOMLEFT].y) / 2));
221	GpiMove(hps, &ptl);
222	if (p != s)
223	GpiCharString(hps, 3, "...");
224	GpiCharString(hps, strlen(p), p);
225	}
226	}
227	free(s);
228	}
229	if (releaseme)
230	WinReleasePS(hps);
231	}
232	}
233
234	VOID PaintRecessedWindow(HWND hwnd, HPS hps, BOOL outtie, BOOL dbl)
235	{
236	/*
237	* paint a recessed box around the window
238	* two pixels width required around window for painting...
239	*/
240	BOOL releaseme = FALSE;
241
242	if (!hps) {
243	hps = WinGetPS(WinQueryWindow(hwnd, QW_PARENT));
244	releaseme = TRUE;
245	}
246	if (hps) {
247
248	POINTL ptl;
249	SWP swp;
250
251	WinQueryWindowPos(hwnd, &swp);
252	ptl.x = swp.x - 1;
253	ptl.y = swp.y - 1;
254	GpiMove(hps, &ptl);
255	if (!outtie)
256	GpiSetColor(hps, CLR_WHITE);
257	else
258	GpiSetColor(hps, CLR_DARKGRAY);
259	ptl.x = swp.x + swp.cx;
260	GpiLine(hps, &ptl);
261	ptl.y = swp.y + swp.cy;
262	GpiLine(hps, &ptl);
263	if (dbl) {
264	ptl.x = swp.x - 2;
265	ptl.y = swp.y - 2;
266	GpiMove(hps, &ptl);
267	ptl.x = swp.x + swp.cx + 1;
268	GpiLine(hps, &ptl);
269	ptl.y = swp.y + swp.cy + 1;
270	GpiLine(hps, &ptl);
271	}
272	if (!outtie)
273	GpiSetColor(hps, CLR_DARKGRAY);
274	else
275	GpiSetColor(hps, CLR_WHITE);
276	if (dbl) {
277	ptl.x = swp.x - 2;
278	GpiLine(hps, &ptl);
279	ptl.y = swp.y - 2;
280	GpiLine(hps, &ptl);
281	ptl.x = swp.x + swp.cx;
282	ptl.y = swp.y + swp.cy;
283	GpiMove(hps, &ptl);
284	}
285	ptl.x = swp.x - 1;
286	GpiLine(hps, &ptl);
287	ptl.y = swp.y - 1;
288	GpiLine(hps, &ptl);
289	GpiSetColor(hps, CLR_PALEGRAY);
290	ptl.x = swp.x - (2 + (dbl != FALSE));
291	ptl.y = swp.y - (2 + (dbl != FALSE));
292	GpiMove(hps, &ptl);
293	ptl.x = swp.x + swp.cx + (1 + (dbl != FALSE));
294	GpiLine(hps, &ptl);
295	ptl.y = swp.y + swp.cy + (1 + (dbl != FALSE));
296	GpiLine(hps, &ptl);
297	ptl.x = swp.x - (2 + (dbl != FALSE));
298	GpiLine(hps, &ptl);
299	ptl.y = swp.y - (2 + (dbl != FALSE));
300	GpiLine(hps, &ptl);
301	if (releaseme)
302	WinReleasePS(hps);
303	}
304	}
305
306	BOOL AdjustCnrColVis(HWND hwndCnr, CHAR * title, BOOL visible, BOOL toggle)
307	{
308	PFIELDINFO pfi = (PFIELDINFO) WinSendMsg(hwndCnr,
309	CM_QUERYDETAILFIELDINFO,
310	MPVOID, MPFROMSHORT(CMA_FIRST));
311
312	while (pfi) {
313	if (!strcmp(pfi->pTitleData, title)) {
314	if (toggle) {
315	if (pfi->flData & CFA_INVISIBLE)
316	pfi->flData &= (~CFA_INVISIBLE);
317	else
318	pfi->flData \|= CFA_INVISIBLE;
319	return !(pfi->flData & CFA_INVISIBLE);
320	}
321	else {
322	if (visible)
323	pfi->flData &= (~CFA_INVISIBLE);
324	else
325	pfi->flData \|= CFA_INVISIBLE;
326	}
327	return TRUE;
328	}
329	pfi = pfi->pNextFieldInfo;
330	}
331	return FALSE;
332	}
333
334	BOOL AdjustCnrColRO(HWND hwndCnr, CHAR * title, BOOL readonly, BOOL toggle)
335	{
336	PFIELDINFO pfi = (PFIELDINFO) WinSendMsg(hwndCnr,
337	CM_QUERYDETAILFIELDINFO,
338	MPVOID, MPFROMSHORT(CMA_FIRST));
339
340	while (pfi) {
341	if (!strcmp(pfi->pTitleData, title)) {
342	if (toggle) {
343	if (pfi->flData & CFA_FIREADONLY)
344	pfi->flData &= (~CFA_FIREADONLY);
345	else
346	pfi->flData \|= CFA_FIREADONLY;
347	return (pfi->flData & CFA_FIREADONLY);
348	}
349	else {
350	if (!readonly)
351	pfi->flData &= (~CFA_FIREADONLY);
352	else
353	pfi->flData \|= CFA_FIREADONLY;
354	}
355	return TRUE;
356	}
357	pfi = pfi->pNextFieldInfo;
358	}
359	return FALSE;
360	}
361
362	VOID AdjustCnrColsForFSType(HWND hwndCnr, CHAR * directory, DIRCNRDATA * dcd)
363	{
364	CHAR FileSystem[CCHMAXPATH];
365	INT x;
366	BOOL hasCreateDT;
367	BOOL hasAccessDT;
368	BOOL hasLongNames;
369	BOOL *pBool;
370
371	if (!directory \|\| !*directory)
372	return;
373	x = CheckDrive(toupper(*directory), FileSystem, NULL);
374	if (x != -1) {
375	if (!stricmp(FileSystem, HPFS) \|\|
376	!stricmp(FileSystem, JFS) \|\|
377	!stricmp(FileSystem, FAT32) \|\|
378	!stricmp(FileSystem, RAMFS) \|\|
379	!stricmp(FileSystem, NDFS32) \|\|
380	!stricmp(FileSystem, NTFS) \|\|
381	!stricmp(FileSystem, HPFS386)) {
382	hasCreateDT = TRUE;
383	hasAccessDT = TRUE;
384	hasLongNames = TRUE;
385	}
386	else if (!strcmp(FileSystem, CDFS) \|\| !strcmp(FileSystem, ISOFS)) {
387	hasCreateDT = TRUE;
388	hasAccessDT = FALSE;
389	hasLongNames = FALSE;
390	}
391	else {
392	// Assume FAT
393	hasCreateDT = FALSE;
394	hasAccessDT = FALSE;
395	hasLongNames = FALSE;
396	}
397	}
398	else {
399	// Assume FAT
400	hasCreateDT = FALSE;
401	hasAccessDT = FALSE;
402	hasLongNames = FALSE;
403	}
404	pBool = dcd ? &dcd->detailsladate : &detailsladate;
405	AdjustCnrColVis(hwndCnr,
406	GetPString(IDS_LADATE),
407	*pBool ? hasAccessDT : FALSE,
408	FALSE);
409	pBool = dcd ? &dcd->detailslatime : &detailslatime;
410	AdjustCnrColVis(hwndCnr,
411	GetPString(IDS_LATIME),
412	*pBool ? hasAccessDT : FALSE,
413	FALSE);
414	pBool = dcd ? &dcd->detailscrdate : &detailscrdate;
415	AdjustCnrColVis(hwndCnr,
416	GetPString(IDS_CRDATE),
417	*pBool ? hasCreateDT : FALSE,
418	FALSE);
419	pBool = dcd ? &dcd->detailscrtime : &detailscrtime;
420	AdjustCnrColVis(hwndCnr,
421	GetPString(IDS_CRTIME),
422	*pBool ? hasCreateDT : FALSE,
423	FALSE);
424	pBool = dcd ? &dcd->detailslongname : &detailslongname;
425	AdjustCnrColVis(hwndCnr,
426	GetPString(IDS_LNAME),
427	*pBool ? hasLongNames : FALSE,
428	FALSE);
429	WinSendMsg(hwndCnr, CM_INVALIDATEDETAILFIELDINFO, MPVOID, MPVOID);
430	}
431
432	VOID AdjustCnrColsForPref(HWND hwndCnr, CHAR * directory, DIRCNRDATA * dcd,
433	BOOL compare)
434	{
435	BOOL *bool;
436
437	bool = dcd ? &dcd->detailssubject : &detailssubject;
438	AdjustCnrColVis(hwndCnr,
439	compare ? GetPString(IDS_STATUS) : GetPString(IDS_SUBJ),
440	*bool,
441	FALSE);
442
443	bool = dcd ? &dcd->detailsattr : &detailsattr;
444	AdjustCnrColVis(hwndCnr, GetPString(IDS_ATTR), *bool, FALSE);
445	bool = dcd ? &dcd->detailsicon : &detailsicon;
446	AdjustCnrColVis(hwndCnr, GetPString(IDS_ICON), *bool, FALSE);
447	bool = dcd ? &dcd->detailslwdate : &detailslwdate;
448	AdjustCnrColVis(hwndCnr, GetPString(IDS_LWDATE), *bool, FALSE);
449	bool = dcd ? &dcd->detailslwtime : &detailslwtime;
450	AdjustCnrColVis(hwndCnr, GetPString(IDS_LWTIME), *bool, FALSE);
451	bool = dcd ? &dcd->detailsea : &detailsea;
452	AdjustCnrColVis(hwndCnr, GetPString(IDS_EA), *bool, FALSE);
453	bool = dcd ? &dcd->detailssize : &detailssize;
454	AdjustCnrColVis(hwndCnr, GetPString(IDS_SIZE), *bool, FALSE);
455
456	if (!directory) {
457	bool = dcd ? &dcd->detailsladate : &detailsladate;
458	AdjustCnrColVis(hwndCnr, GetPString(IDS_LADATE), *bool, FALSE);
459	bool = dcd ? &dcd->detailslatime : &detailslatime;
460	AdjustCnrColVis(hwndCnr, GetPString(IDS_LATIME), *bool, FALSE);
461	bool = dcd ? &dcd->detailscrdate : &detailscrdate;
462	AdjustCnrColVis(hwndCnr, GetPString(IDS_CRDATE), *bool, FALSE);
463	bool = dcd ? &dcd->detailscrtime : &detailscrtime;
464	AdjustCnrColVis(hwndCnr, GetPString(IDS_CRTIME), *bool, FALSE);
465	bool = dcd ? &dcd->detailslongname : &detailslongname;
466	AdjustCnrColVis(hwndCnr, GetPString(IDS_LNAME), *bool, FALSE);
467	WinSendMsg(hwndCnr, CM_INVALIDATEDETAILFIELDINFO, MPVOID, MPVOID);
468	}
469	else
470	AdjustCnrColsForFSType(hwndCnr, directory, dcd);
471	}
472
473	BOOL SetCnrCols(HWND hwndCnr, BOOL isCompCnr)
474	{
475	BOOL fSuccess = TRUE;
476	PFIELDINFO pfi, pfiLastLeftCol, pfiIconCol;
477
478	// Allocate storage for container column data
479
480	pfi = WinSendMsg(hwndCnr, CM_ALLOCDETAILFIELDINFO,
481	MPFROMLONG(CONTAINER_COLUMNS), NULL);
482
483	if (!pfi) {
484	Win_Error(hwndCnr, HWND_DESKTOP, pszSrcFile, __LINE__, "CM_ALLOCDETAILFIELDINFO");
485	fSuccess = FALSE;
486	}
487	else {
488
489	PFIELDINFO pfiFirst;
490	FIELDINFOINSERT fii;
491
492	// Store original value of pfi so we won't lose it when it changes.
493	// This will be needed on the CM_INSERTDETAILFIELDINFO message.
494
495	pfiFirst = pfi;
496
497	// Fill in column information for the icon column
498
499	pfi->flData = CFA_BITMAPORICON \| CFA_CENTER \| CFA_FIREADONLY;
500	pfi->flTitle = CFA_CENTER \| CFA_FITITLEREADONLY;
501	pfi->pTitleData = GetPString(IDS_ICON);
502	pfi->offStruct = FIELDOFFSET(MINIRECORDCORE, hptrIcon);
503
504	pfiIconCol = pfi;
505
506	// Fill in column information for the file name. Note that we are
507	// using the pszDisplayName variable rather than pszFileName. We do this
508	// because the container does not always display the full path file name.
509
510	pfi = pfi->pNextFieldInfo;
511
512	pfi->flData = CFA_STRING \| CFA_LEFT \| CFA_SEPARATOR;
513	pfi->flTitle = CFA_LEFT;
514	pfi->pTitleData = GetPString(IDS_FILENAME);
515	pfi->offStruct = FIELDOFFSET(CNRITEM, pszDisplayName);
516
517	// Fill in column information for the longname.
518
519	pfi = pfi->pNextFieldInfo;
520	pfi->flData = CFA_STRING \| CFA_LEFT;
521	pfi->flTitle = CFA_LEFT \| CFA_FITITLEREADONLY;
522	pfi->pTitleData = GetPString(IDS_LNAME);
523	pfi->offStruct = FIELDOFFSET(CNRITEM, pszLongName);
524
525	// Fill in column info for subjects
526
527	if (fSubjectInLeftPane) {
528	pfi = pfi->pNextFieldInfo;
529	pfi->flData = CFA_STRING \| CFA_LEFT \| CFA_SEPARATOR;
530	if (isCompCnr)
531	pfi->flData \|= CFA_FIREADONLY;
532	pfi->flTitle = CFA_LEFT \| CFA_FITITLEREADONLY;
533	pfi->pTitleData = isCompCnr ? GetPString(IDS_STATUS) :
534	GetPString(IDS_SUBJ);
535	pfi->offStruct = FIELDOFFSET(CNRITEM, pszSubject);
536	pfi->cxWidth = SubjectDisplayWidth;
537
538	// Store the current pfi value as that will be used to indicate the
539	// last column in the lefthand container window (we have a splitbar)
540
541	pfiLastLeftCol = pfi;
542	}
543	else {
544	// Store the current pfi value as that will be used to indicate the
545	// last column in the lefthand container window (we have a splitbar)
546
547	pfiLastLeftCol = pfi;
548	pfi = pfi->pNextFieldInfo;
549	pfi->flData = CFA_STRING \| CFA_LEFT \| CFA_SEPARATOR;
550	if (isCompCnr)
551	pfi->flData \|= CFA_FIREADONLY;
552	pfi->flTitle = CFA_LEFT \| CFA_FITITLEREADONLY;
553	pfi->pTitleData = isCompCnr ? GetPString(IDS_STATUS) :
554	GetPString(IDS_SUBJ);
555	pfi->offStruct = FIELDOFFSET(CNRITEM, pszSubject);
556	pfi->cxWidth = SubjectDisplayWidth;
557	}
558
559	// Fill in column information for the file size
560
561
562	pfi = pfi->pNextFieldInfo;
563	pfi->flData = CFA_STRING \| CFA_RIGHT \| CFA_SEPARATOR \| CFA_FIREADONLY;
564	pfi->flTitle = CFA_CENTER;
565	pfi->pTitleData = GetPString(IDS_SIZE);
566	pfi->offStruct = FIELDOFFSET(CNRITEM, pszFmtFileSize);
567
568
569	// Fill in the column information for the file's ea size
570
571	pfi = pfi->pNextFieldInfo;
572	pfi->flData = CFA_ULONG \| CFA_RIGHT \| CFA_SEPARATOR \| CFA_FIREADONLY;
573	pfi->flTitle = CFA_CENTER;
574	pfi->pTitleData = GetPString(IDS_EA);
575	pfi->offStruct = FIELDOFFSET(CNRITEM, easize);
576
577	// Fill in the column information for the file attribute
578
579	pfi = pfi->pNextFieldInfo;
580	pfi->flData = CFA_STRING \| CFA_CENTER \| CFA_SEPARATOR \| CFA_FIREADONLY;
581	pfi->flTitle = CFA_CENTER \| CFA_FITITLEREADONLY;
582	pfi->pTitleData = GetPString(IDS_ATTR);
583	pfi->offStruct = FIELDOFFSET(CNRITEM, pszDispAttr);
584
585	// Fill in column information for last write file date
586
587	pfi = pfi->pNextFieldInfo;
588	pfi->flData = CFA_DATE \| CFA_RIGHT \| CFA_FIREADONLY;
589	pfi->flTitle = CFA_CENTER;
590	pfi->pTitleData = GetPString(IDS_LWDATE);
591	pfi->offStruct = FIELDOFFSET(CNRITEM, date);
592
593	// Fill in column information for the last write file time
594
595	pfi = pfi->pNextFieldInfo;
596	pfi->flData = CFA_TIME \| CFA_RIGHT \| CFA_SEPARATOR \| CFA_FIREADONLY;
597	pfi->flTitle = CFA_CENTER;
598	pfi->pTitleData = GetPString(IDS_LWTIME);
599	pfi->offStruct = FIELDOFFSET(CNRITEM, time);
600
601	// Fill in column information for last access file date
602
603	pfi = pfi->pNextFieldInfo;
604	pfi->flData = CFA_DATE \| CFA_RIGHT \| CFA_FIREADONLY;
605	pfi->flTitle = CFA_CENTER;
606	pfi->pTitleData = GetPString(IDS_LADATE);
607	pfi->offStruct = FIELDOFFSET(CNRITEM, ladate);
608
609	// Fill in column information for the last access file time
610
611	pfi = pfi->pNextFieldInfo;
612	pfi->flData = CFA_TIME \| CFA_RIGHT \| CFA_SEPARATOR \| CFA_FIREADONLY;
613	pfi->flTitle = CFA_CENTER;
614	pfi->pTitleData = GetPString(IDS_LATIME);
615	pfi->offStruct = FIELDOFFSET(CNRITEM, latime);
616
617	// Fill in column information for create file date
618
619	pfi = pfi->pNextFieldInfo;
620	pfi->flData = CFA_DATE \| CFA_RIGHT \| CFA_FIREADONLY;
621	pfi->flTitle = CFA_CENTER;
622	pfi->pTitleData = GetPString(IDS_CRDATE);
623	pfi->offStruct = FIELDOFFSET(CNRITEM, crdate);
624
625	// Fill in column information for the create file time
626
627	pfi = pfi->pNextFieldInfo;
628	pfi->flData = CFA_TIME \| CFA_RIGHT \| CFA_FIREADONLY;
629	pfi->flTitle = CFA_CENTER;
630	pfi->pTitleData = GetPString(IDS_CRTIME);
631	pfi->offStruct = FIELDOFFSET(CNRITEM, crtime);
632
633	// Use the CM_INSERTDETAILFIELDINFO message to tell the container
634	// all the column information it needs to function properly. Place
635	// this column info first in the column list and update the display
636	// after they are inserted (fInvalidateFieldInfo = TRUE)
637
638	(void)memset(&fii, 0, sizeof(FIELDINFOINSERT));
639
640	fii.cb = sizeof(FIELDINFOINSERT);
641	fii.pFieldInfoOrder = (PFIELDINFO) CMA_FIRST;
642	fii.cFieldInfoInsert = (SHORT) CONTAINER_COLUMNS;
643	fii.fInvalidateFieldInfo = TRUE;
644
645	if (!WinSendMsg(hwndCnr, CM_INSERTDETAILFIELDINFO, MPFROMP(pfiFirst),
646	MPFROMP(&fii))) {
647	Win_Error(hwndCnr, HWND_DESKTOP, pszSrcFile, __LINE__, "CM_INSERTDETAILFIELDINFO");
648	fSuccess = FALSE;
649	}
650	}
651
652	if (fSuccess) {
653
654	CNRINFO cnri;
655	ULONG size;
656
657	// Tell the container about the splitbar and where it goes
658
659	cnri.cb = sizeof(CNRINFO);
660	cnri.pFieldInfoLast = pfiLastLeftCol;
661	cnri.xVertSplitbar = DIR_SPLITBAR_OFFSET - 32;
662	cnri.pFieldInfoObject = pfiIconCol;
663	size = sizeof(LONG);
664	PrfQueryProfileData(fmprof,
665	appname, "CnrSplitBar", &cnri.xVertSplitbar, &size);
666	if (cnri.xVertSplitbar <= 0)
667	cnri.xVertSplitbar = DIR_SPLITBAR_OFFSET - 32;
668	if (!WinSendMsg(hwndCnr, CM_SETCNRINFO, MPFROMP(&cnri),
669	MPFROMLONG(CMA_PFIELDINFOLAST \| CMA_PFIELDINFOOBJECT \|
670	CMA_XVERTSPLITBAR))) {
671	Win_Error(hwndCnr, HWND_DESKTOP, pszSrcFile, __LINE__, "CM_SETCNRINFO");
672	fSuccess = FALSE;
673	}
674	}
675
676	return fSuccess;
677	}
678
679	MRESULT CnrDirectEdit(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
680	{
681	switch (SHORT2FROMMP(mp1)) {
682	case CN_BEGINEDIT:
683	if (mp2) {
684	PFIELDINFO pfi = ((PCNREDITDATA) mp2)->pFieldInfo;
685	PCNRITEM pci = (PCNRITEM) ((PCNREDITDATA) mp2)->pRecord;
686
687	if (pci &&
688	(INT) pci != -1 &&
689	!IsRoot(pci->pszFileName) &&
690	!(pci->flags & RECFLAGS_ENV) && !(pci->flags & RECFLAGS_UNDERENV)) {
691	if (!pfi \|\| pfi->offStruct == FIELDOFFSET(CNRITEM, pszDisplayName)) {
692	PostMsg(hwnd, UM_FIXEDITNAME, MPFROMP(pci->pszFileName), MPVOID);
693	}
694	else if (pfi->offStruct == FIELDOFFSET(CNRITEM, pszSubject))
695	PostMsg(hwnd, UM_FIXCNRMLE, MPFROMLONG(1048), MPVOID);
696	else
697	PostMsg(hwnd, UM_FIXCNRMLE, MPFROMLONG(CCHMAXPATH), MPVOID);
698	}
699	else
700	PostMsg(hwnd, CM_CLOSEEDIT, MPVOID, MPVOID);
701	}
702	break;
703
704	case CN_REALLOCPSZ:
705	if (mp2) {
706	PFIELDINFO pfi = ((PCNREDITDATA) mp2)->pFieldInfo;
707	PCNRITEM pci = (PCNRITEM) ((PCNREDITDATA) mp2)->pRecord;
708	CHAR szData[CCHMAXPATH], testname[CCHMAXPATH];
709	HWND hwndMLE = WinWindowFromID(hwnd, CID_MLE);
710
711	if (pci && (INT) pci != -1 && !IsRoot(pci->pszFileName)) {
712	if (pfi && pfi->offStruct == FIELDOFFSET(CNRITEM, pszSubject)) {
713
714	APIRET rc;
715	EAOP2 eaop;
716	PFEA2LIST pfealist = NULL;
717	CHAR szSubject[1048];
718	ULONG ealen;
719	USHORT len;
720	CHAR *eaval;
721	LONG retlen;
722	PSZ psz;
723
724	retlen = WinQueryWindowText(hwndMLE, sizeof(szSubject), szSubject);
725	szSubject[retlen + 1] = 0;
726	bstrip(szSubject);
727	if (pci->pszSubject != NullStr) {
728	if (retlen == 0) {
729	psz = pci->pszSubject;
730	pci->pszSubject = NullStr;
731	xfree(psz);
732	}
733	else
734	pci->pszSubject = xrealloc(pci->pszSubject, retlen + 1, pszSrcFile, __LINE__);
735	}
736	else {
737	pci->pszSubject = xmalloc(retlen + 1, pszSrcFile, __LINE__);
738	if (!pci->pszSubject)
739	return FALSE;
740	}
741	len = strlen(szSubject);
742	if (len)
743	ealen = sizeof(FEA2LIST) + 9 + len + 4;
744	else
745	ealen = sizeof(FEALIST) + 9;
746	rc = DosAllocMem((PPVOID) & pfealist, ealen + 64,
747	OBJ_TILE \| PAG_COMMIT \| PAG_READ \| PAG_WRITE);
748	if (rc)
749	Dos_Error(MB_CANCEL, rc, HWND_DESKTOP, pszSrcFile,
750	__LINE__, GetPString(IDS_OUTOFMEMORY));
751	else {
752	memset(pfealist, 0, ealen + 1);
753	pfealist->cbList = ealen;
754	pfealist->list[0].oNextEntryOffset = 0;
755	pfealist->list[0].fEA = 0;
756	pfealist->list[0].cbName = 8;
757	strcpy(pfealist->list[0].szName, SUBJECT);
758	if (len) {
759	eaval = pfealist->list[0].szName + 9;
760	(USHORT ) eaval = (USHORT) EAT_ASCII;
761	eaval += sizeof(USHORT);
762	(USHORT ) eaval = (USHORT) len;
763	eaval += sizeof(USHORT);
764	memcpy(eaval, szSubject, len);
765	pfealist->list[0].cbValue = len + (sizeof(USHORT) * 2);
766	}
767	else
768	pfealist->list[0].cbValue = 0;
769	eaop.fpGEA2List = (PGEA2LIST) 0;
770	eaop.fpFEA2List = pfealist;
771	eaop.oError = 0;
772	rc = xDosSetPathInfo(pci->pszFileName, FIL_QUERYEASIZE,
773	&eaop, sizeof(eaop), DSPI_WRTTHRU);
774	DosFreeMem(pfealist);
775	if (rc)
776	return FALSE;
777	}
778	return (MRESULT) TRUE;
779	}
780	else if (pfi && pfi->offStruct == FIELDOFFSET(CNRITEM, pszLongName)) {
781
782	CHAR longname[CCHMAXPATHCOMP];
783	LONG retlen;
784	PSZ psz;
785
786	*longname = 0;
787	retlen = WinQueryWindowText(hwndMLE, sizeof(longname), longname);
788	longname[retlen + 1] = 0;
789	chop_at_crnl(longname);
790	bstrip(longname);
791	WinSetWindowText(hwndMLE, longname);
792	if (pci->pszLongName != NullStr) {
793	if (retlen == 0) {
794	psz = pci->pszLongName;
795	pci->pszLongName = NullStr;
796	xfree(psz);
797	}
798	else
799	pci->pszLongName = xrealloc(pci->pszLongName, retlen + 1, pszSrcFile, __LINE__);
800	}
801	else {
802	pci->pszLongName = xmalloc(retlen + 1, pszSrcFile, __LINE__);
803	if (!pci->pszLongName)
804	return FALSE;
805	}
806	return (MRESULT) WriteLongName(pci->pszFileName, longname);
807	}
808	else {
809	WinQueryWindowText(hwndMLE, sizeof(szData), szData);
810	if (strchr(szData, '?') \|\|
811	strchr(szData, '*') \|\| IsRoot(pci->pszFileName))
812	return (MRESULT) FALSE;
813	/* If the text changed, rename the file system object. */
814	chop_at_crnl(szData);
815	bstrip(szData);
816	if (!IsFullName(szData))
817	Runtime_Error(pszSrcFile, __LINE__, "bad name");
818	else {
819	if (DosQueryPathInfo(szData,
820	FIL_QUERYFULLNAME,
821	testname, sizeof(testname)))
822	return FALSE;
823	if (DosQueryPathInfo(pci->pszFileName,
824	FIL_QUERYFULLNAME,
825	szData,
826	sizeof(szData)))
827	{
828	pci->pszFileName = xrealloc(pci->pszFileName, sizeof(szData), pszSrcFile, __LINE__);
829	strcpy(szData, pci->pszFileName);
830	}
831	WinSetWindowText(hwndMLE, szData);
832	if (strcmp(szData, testname)) {
833	if (stricmp(szData, testname) && IsFile(testname) != -1) {
834	DosBeep(50, 100); /* exists; disallow */
835	return (MRESULT) FALSE;
836	}
837	if (docopyf(MOVE, szData, "%s", testname))
838	Runtime_Error(pszSrcFile, __LINE__, "docopyf");
839	else {
840	CHAR *filename;
841
842	filename = xstrdup(testname, pszSrcFile, __LINE__);
843	if (filename) {
844	if (!PostMsg(hwnd,
845	UM_FIXEDITNAME, MPVOID, MPFROMP(filename)))
846	free(filename);
847	}
848	if (stricmp(testname, pci->pszFileName)) {
849	PostMsg(hwnd, UM_FIXEDITNAME, MPFROMLONG(-1), MPFROMP(pci));
850	filename = xstrdup(pci->pszFileName, pszSrcFile, __LINE__);
851	if (filename) {
852	if (!PostMsg(hwnd,
853	UM_FIXEDITNAME, MPVOID, MPFROMP(filename)))
854	free(filename);
855	}
856	}
857	}
858	}
859	}
860	}
861	}
862	}
863	return FALSE;
864
865	case CN_ENDEDIT:
866	if (mp2) {
867	PFIELDINFO pfi = ((PCNREDITDATA) mp2)->pFieldInfo;
868	PCNRITEM pci = (PCNRITEM) ((PCNREDITDATA) mp2)->pRecord;
869
870	if (pci && (INT) pci != -1 && !IsRoot(pci->pszFileName)) {
871	WinSendMsg(hwnd,
872	CM_INVALIDATERECORD,
873	MPFROMP(&pci),
874	MPFROM2SHORT(1, CMA_ERASE \| CMA_TEXTCHANGED));
875	if (pfi && pfi->offStruct == FIELDOFFSET(CNRITEM, pszDisplayName))
876	PostMsg(hwnd, UM_SORTRECORD, MPVOID, MPVOID);
877	}
878	else {
879	USHORT cmd = 0;
880
881	if (!pfi \|\| pfi->offStruct == FIELDOFFSET(CNRITEM, pszDisplayName))
882	cmd = IDM_SORTSMARTNAME;
883	else if (pfi->offStruct == FIELDOFFSET(CNRITEM, cbFile))
884	cmd = IDM_SORTSIZE;
885	else if (pfi->offStruct == FIELDOFFSET(CNRITEM, easize))
886	cmd = IDM_SORTEASIZE;
887	else if (pfi->offStruct == FIELDOFFSET(CNRITEM, date))
888	cmd = IDM_SORTLWDATE;
889	else if (pfi->offStruct == FIELDOFFSET(CNRITEM, time))
890	cmd = IDM_SORTLWDATE;
891	else if (pfi->offStruct == FIELDOFFSET(CNRITEM, ladate))
892	cmd = IDM_SORTLADATE;
893	else if (pfi->offStruct == FIELDOFFSET(CNRITEM, latime))
894	cmd = IDM_SORTLADATE;
895	else if (pfi->offStruct == FIELDOFFSET(CNRITEM, crdate))
896	cmd = IDM_SORTCRDATE;
897	else if (pfi->offStruct == FIELDOFFSET(CNRITEM, crtime))
898	cmd = IDM_SORTCRDATE;
899	if (cmd)
900	PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(cmd, 0), MPVOID);
901	}
902	}
903	break;
904	}
905	return (MRESULT) - 1;
906	}
907
908	BOOL SetMenuCheck(HWND hwndMenu, USHORT id, BOOL * bool, BOOL toggle,
909	CHAR * savename)
910	{
911	if (toggle) {
912	bool = bool ? FALSE : TRUE;
913	if (savename && *savename)
914	PrfWriteProfileData(fmprof, appname, savename, bool, sizeof(BOOL));
915	}
916	WinSendMsg(hwndMenu, MM_SETITEMATTR,
917	MPFROM2SHORT(id, 1),
918	MPFROM2SHORT(MIA_CHECKED, (*bool ? MIA_CHECKED : 0)));
919	return *bool;
920	}
921
922	//== disable_menuitem() disable or enable_menuitem ==
923
924	VOID disable_menuitem(HWND hwndMenu, USHORT id, BOOL disable)
925	{
926	WinSendMsg(hwndMenu, MM_SETITEMATTR,
927	MPFROM2SHORT(id, TRUE),
928	MPFROM2SHORT(MIA_DISABLED, (disable ? MIA_DISABLED : 0)));
929	}
930
931	//== ViewHelp() invoke view.exe, return TRUE if OK ==
932
933	BOOL ViewHelp(CHAR * filename)
934	{
935	CHAR s[CCHMAXPATH + 81];
936	CHAR szQuotedFileName[CCHMAXPATH];
937	FILE *fp;
938	INT ret = -1;
939
940	fp = _fsopen(filename, "rb", SH_DENYNO);
941	if (fp) {
942	*s = 0;
943	fread(s, 1, 3, fp);
944	if (*s != 'H' \|\| s[1] != 'S' \|\| s[2] != 'P') {
945	fclose(fp);
946	return FALSE;
947	}
948	fclose(fp);
949	ret = runemf2(SEPARATE \| WINDOWED, HWND_DESKTOP, pszSrcFile, __LINE__,
950	NULL, NULL,
951	"VIEW.EXE \"%s\"",
952	BldQuotedFileName(szQuotedFileName, filename));
953	}
954
955	return (ret != -1);
956	}
957
958	//== ExecFile() run file, return 1 if OK 0 if skipped -1 if can't run ==
959
960	INT ExecFile(HWND hwnd, CHAR * filename)
961	{
962	EXECARGS ex;
963	CHAR cl[1001], path[CCHMAXPATH], *p;
964	APIRET ret;
965	static INT lastflags = 0;
966
967	strcpy(path, filename);
968	p = strrchr(path, '\\');
969	if (!p)
970	p = strrchr(path, ':');
971	if (p) {
972	if (*p == ':') {
973	p++;
974	*p = '\\';
975	p++;
976	}
977	*p = 0;
978	}
979	else
980	*path = 0;
981	*cl = 0;
982	BldQuotedFileName(cl, filename);
983	memset(&ex, 0, sizeof(ex));
984	ex.flags = lastflags;
985	ex.commandline = cl;
986	*ex.path = 0;
987	*ex.environment = 0;
988	ret = WinDlgBox(HWND_DESKTOP, hwnd, CmdLineDlgProc, FM3ModHandle,
989	EXEC_FRAME, &ex);
990	if (ret == 1) {
991	lastflags = ex.flags;
992	return runemf2(ex.flags, hwnd, pszSrcFile, __LINE__, path,
993	*ex.environment ? ex.environment : NULL,
994	"%s", cl) != -1;
995	}
996	else if (ret != 0)
997	return -1;
998	return 0;
999	}
1000
1001	VOID SetDetailsSwitches(HWND hwnd, DIRCNRDATA * dcd)
1002	{
1003	WinCheckMenuItem(hwnd, IDM_SHOWLNAMES,
1004	dcd ? dcd->detailslongname : detailslongname);
1005	WinCheckMenuItem(hwnd, IDM_SHOWSUBJECT,
1006	dcd ? dcd->detailssubject : detailssubject);
1007	WinCheckMenuItem(hwnd, IDM_SHOWEAS, dcd ? dcd->detailsea : detailsea);
1008	WinCheckMenuItem(hwnd, IDM_SHOWSIZE,
1009	dcd ? dcd->detailssize : detailssize);
1010	WinCheckMenuItem(hwnd, IDM_SHOWICON,
1011	dcd ? dcd->detailsicon : detailsicon);
1012	WinCheckMenuItem(hwnd, IDM_SHOWLWDATE,
1013	dcd ? dcd->detailslwdate : detailslwdate);
1014	WinCheckMenuItem(hwnd, IDM_SHOWLWTIME,
1015	dcd ? dcd->detailslwtime : detailslwtime);
1016	WinCheckMenuItem(hwnd, IDM_SHOWLADATE,
1017	dcd ? dcd->detailsladate : detailsladate);
1018	WinCheckMenuItem(hwnd, IDM_SHOWLATIME,
1019	dcd ? dcd->detailslatime : detailslatime);
1020	WinCheckMenuItem(hwnd, IDM_SHOWCRDATE,
1021	dcd ? dcd->detailscrdate : detailscrdate);
1022	WinCheckMenuItem(hwnd, IDM_SHOWCRTIME,
1023	dcd ? dcd->detailscrtime : detailscrtime);
1024	WinCheckMenuItem(hwnd, IDM_SHOWATTR,
1025	dcd ? dcd->detailsattr : detailsattr);
1026	}
1027
1028	VOID AdjustDetailsSwitches(HWND hwnd, HWND hwndMenu, USHORT cmd,
1029	CHAR * directory, CHAR * keyroot,
1030	DIRCNRDATA * dcd, BOOL compare)
1031	{
1032	// JBS CHAR s[CCHMAXPATH], *eos = s;
1033	BOOL *bool = NULL;
1034
1035	// JBS *s = 0;
1036	// JBS if (keyroot) {
1037	// JBS strcpy(s, keyroot);
1038	// JBS strcat(s, ".");
1039	// JBS eos = &s[strlen(s)];
1040	// JBS }
1041	switch (cmd) {
1042	case IDM_SHOWLNAMES:
1043	bool = dcd ? &dcd->detailslongname : &detailslongname;
1044	// JBS strcpy(eos, "DetailsLongname");
1045	break;
1046	case IDM_SHOWSUBJECT:
1047	bool = dcd ? &dcd->detailssubject : &detailssubject;
1048	// JBS strcpy(eos, "DetailsSubject");
1049	break;
1050	case IDM_SHOWEAS:
1051	bool = dcd ? &dcd->detailsea : &detailsea;
1052	// JBS strcpy(eos, "DetailsEA");
1053	break;
1054	case IDM_SHOWSIZE:
1055	bool = dcd ? &dcd->detailssize : &detailssize;
1056	// JBS strcpy(eos, "DetailsSize");
1057	break;
1058	case IDM_SHOWICON:
1059	bool = dcd ? &dcd->detailsicon : &detailsicon;
1060	// JBS strcpy(eos, "DetailsIcon");
1061	break;
1062	case IDM_SHOWLWDATE:
1063	bool = dcd ? &dcd->detailslwdate : &detailslwdate;
1064	// JBS strcpy(eos, "DetailsLWDate");
1065	break;
1066	case IDM_SHOWLWTIME:
1067	bool = dcd ? &dcd->detailslwtime : &detailslwtime;
1068	// JBS strcpy(eos, "DetailsLWTime");
1069	break;
1070	case IDM_SHOWLADATE:
1071	bool = dcd ? &dcd->detailsladate : &detailsladate;
1072	// JBS strcpy(eos, "DetailsLADate");
1073	break;
1074	case IDM_SHOWLATIME:
1075	bool = dcd ? &dcd->detailslatime : &detailslatime;
1076	// JBS strcpy(eos, "DetailsLATime");
1077	break;
1078	case IDM_SHOWCRDATE:
1079	bool = dcd ? &dcd->detailscrdate : &detailscrdate;
1080	// JBS strcpy(eos, "DetailsCRDate");
1081	break;
1082	case IDM_SHOWCRTIME:
1083	bool = dcd ? &dcd->detailscrtime : &detailscrtime;
1084	// JBS strcpy(eos, "DetailsCRTime");
1085	break;
1086	case IDM_SHOWATTR:
1087	bool = dcd ? &dcd->detailsattr : &detailsattr;
1088	// JBS strcpy(eos, "DetailsAttr");
1089	break;
1090	default:
1091	if (hwndMenu)
1092	SetDetailsSwitches(hwndMenu, dcd);
1093	return;
1094	}
1095	if (bool)
1096	bool = bool ? FALSE : TRUE;
1097	// JBS if (*s && bool)
1098	// JBS PrfWriteProfileData(fmprof, appname, s, bool, sizeof(BOOL));
1099	if (hwnd)
1100	AdjustCnrColsForPref(hwnd, directory, dcd, compare);
1101	if (hwndMenu)
1102	SetDetailsSwitches(hwndMenu, dcd);
1103	}
1104
1105	/**
1106	* Set default menu item to invoke for top level conditional cascade menu
1107	* @param def is default menu id (i.e. IDM_...)
1108	*/
1109
1110	VOID SetConditionalCascade(HWND hwndMenu, USHORT id, USHORT def)
1111	{
1112	MENUITEM mi;
1113
1114	mi.iPosition = MIT_END;
1115	mi.hItem = 0;
1116	mi.hwndSubMenu = (HWND)0;
1117	mi.afAttribute = 0;
1118	mi.afStyle = MIS_TEXT;
1119	if (WinSendMsg(hwndMenu,
1120	MM_QUERYITEM,
1121	MPFROM2SHORT(id, TRUE),
1122	MPFROMP(&mi)))
1123	{
1124	WinSetWindowBits(mi.hwndSubMenu, QWL_STYLE, MS_CONDITIONALCASCADE,
1125	MS_CONDITIONALCASCADE);
1126	WinSendMsg(mi.hwndSubMenu, MM_SETDEFAULTITEMID, MPFROMSHORT(def), MPVOID);
1127	WinCheckMenuItem(mi.hwndSubMenu, def, TRUE);
1128	}
1129	}
1130
1131	VOID SetSortChecks(HWND hwndMenu, INT sortflags)
1132	{
1133	WinCheckMenuItem(hwndMenu, IDM_SORTNONE, FALSE);
1134	WinCheckMenuItem(hwndMenu, IDM_SORTFIRST, FALSE);
1135	WinCheckMenuItem(hwndMenu, IDM_SORTLAST, FALSE);
1136	WinCheckMenuItem(hwndMenu, IDM_SORTSIZE, FALSE);
1137	WinCheckMenuItem(hwndMenu, IDM_SORTEASIZE, FALSE);
1138	WinCheckMenuItem(hwndMenu, IDM_SORTLWDATE, FALSE);
1139	WinCheckMenuItem(hwndMenu, IDM_SORTLADATE, FALSE);
1140	WinCheckMenuItem(hwndMenu, IDM_SORTCRDATE, FALSE);
1141	WinCheckMenuItem(hwndMenu, IDM_SORTFILENAME, FALSE);
1142	WinCheckMenuItem(hwndMenu, IDM_SORTNAME, FALSE);
1143	WinCheckMenuItem(hwndMenu, IDM_SORTSUBJECT, FALSE);
1144	WinCheckMenuItem(hwndMenu, IDM_SORTDIRSFIRST, FALSE);
1145	WinCheckMenuItem(hwndMenu, IDM_SORTDIRSLAST, FALSE);
1146	WinCheckMenuItem(hwndMenu, IDM_SORTREVERSE, FALSE);
1147	if (sortflags & SORT_FIRSTEXTENSION)
1148	WinCheckMenuItem(hwndMenu, IDM_SORTFIRST, TRUE);
1149	else if (sortflags & SORT_LASTEXTENSION)
1150	WinCheckMenuItem(hwndMenu, IDM_SORTLAST, TRUE);
1151	else if (sortflags & SORT_SIZE)
1152	WinCheckMenuItem(hwndMenu, IDM_SORTSIZE, TRUE);
1153	else if (sortflags & SORT_EASIZE)
1154	WinCheckMenuItem(hwndMenu, IDM_SORTEASIZE, TRUE);
1155	else if (sortflags & SORT_LWDATE)
1156	WinCheckMenuItem(hwndMenu, IDM_SORTLWDATE, TRUE);
1157	else if (sortflags & SORT_LADATE)
1158	WinCheckMenuItem(hwndMenu, IDM_SORTLADATE, TRUE);
1159	else if (sortflags & SORT_CRDATE)
1160	WinCheckMenuItem(hwndMenu, IDM_SORTCRDATE, TRUE);
1161	else if (sortflags & SORT_FILENAME)
1162	WinCheckMenuItem(hwndMenu, IDM_SORTFILENAME, TRUE);
1163	else if (sortflags & SORT_NOSORT)
1164	WinCheckMenuItem(hwndMenu, IDM_SORTNONE, TRUE);
1165	else if (sortflags & SORT_SUBJECT)
1166	WinCheckMenuItem(hwndMenu, IDM_SORTSUBJECT, TRUE);
1167	else
1168	WinCheckMenuItem(hwndMenu, IDM_SORTNAME, TRUE);
1169	if (sortflags & SORT_DIRSFIRST)
1170	WinCheckMenuItem(hwndMenu, IDM_SORTDIRSFIRST, TRUE);
1171	else if (sortflags & SORT_DIRSLAST)
1172	WinCheckMenuItem(hwndMenu, IDM_SORTDIRSLAST, TRUE);
1173	if (sortflags & SORT_REVERSE)
1174	WinCheckMenuItem(hwndMenu, IDM_SORTREVERSE, TRUE);
1175	}
1176
1177	VOID FcloseFile(FILE * fp)
1178	{
1179	/* for use by apps that don't use the DLLs runtime library */
1180	fclose(fp);
1181	}
1182
1183	VOID SetupCommandMenu(HWND hwndMenu, HWND hwndCnr)
1184	{
1185	MENUITEM mi, mit;
1186	INT x;
1187	SHORT numitems;
1188	LINKCMDS *info;
1189
1190	if (!cmdloaded)
1191	load_commands();
1192	mi.iPosition = MIT_END;
1193	mi.hwndSubMenu = (HWND) 0;
1194	mi.hItem = 0L;
1195	mi.afAttribute = 0;
1196	mi.afStyle = MIS_TEXT;
1197	memset(&mit, 0, sizeof(MENUITEM));
1198	if (WinQueryWindowUShort(hwndMenu, QWS_ID) == IDM_COMMANDSMENU)
1199	mit.hwndSubMenu = hwndMenu;
1200	else
1201	WinSendMsg(hwndMenu, MM_QUERYITEM,
1202	MPFROM2SHORT(IDM_COMMANDSMENU, TRUE), MPFROMP(&mit));
1203	if (mit.hwndSubMenu) {
1204	numitems = (SHORT) WinSendMsg(mit.hwndSubMenu, MM_QUERYITEMCOUNT,
1205	MPVOID, MPVOID);
1206	WinSendMsg(mit.hwndSubMenu, MM_DELETEITEM, MPFROMSHORT(-1), MPVOID);
1207	for (x = 0; x < numitems; x++)
1208	WinSendMsg(mit.hwndSubMenu, MM_DELETEITEM,
1209	MPFROMSHORT((SHORT) (x + IDM_COMMANDSTART)), MPVOID);
1210	if (hwndCnr && cmdhead) {
1211	x = 0;
1212	info = cmdhead;
1213	while (info) {
1214
1215	CHAR s[CCHMAXPATH + 24];
1216
1217	sprintf(s,
1218	"%s%s%s",
1219	info->title,
1220	x < 20 ? "\tCtrl + " : NullStr,
1221	x < 20 && x > 9 ? "Shift + " : NullStr);
1222	if (x < 20)
1223	sprintf(&s[strlen(s)], "%d",
1224	((x % 10) + 1) == 10 ? 0 : (x % 10) + 1);
1225	mi.id = IDM_COMMANDSTART + x;
1226	mi.afAttribute = (info->flags & ONCE ? MIA_CHECKED : 0) \|
1227	(info->flags & PROMPT ? MIA_FRAMED : 0);
1228	mi.afStyle = MIS_TEXT;
1229	if (!(x % 24) && x && info->next)
1230	mi.afStyle \|= MIS_BREAK;
1231	WinSendMsg(mit.hwndSubMenu, MM_INSERTITEM, MPFROMP(&mi), MPFROMP(s));
1232	x++;
1233	info = info->next;
1234	}
1235	}
1236	}
1237	}
1238
1239	VOID LoadDetailsSwitches(CHAR * keyroot, DIRCNRDATA * dcd)
1240	{
1241	ULONG size;
1242	CHAR s[CCHMAXPATH], *eos = s;
1243	BOOL *bool;
1244
1245	// JBS - No calls to LoadDetailsSwitches have a NULL keyroot.
1246	// *s = 0;
1247	// if (keyroot) {
1248	strcpy(s, keyroot);
1249	strcat(s, ".");
1250	eos = &s[strlen(s)];
1251	// }
1252	strcpy(eos, "DetailsLongname");
1253	if (dcd)
1254	bool = &dcd->detailslongname;
1255	else
1256	bool = &detailslongname;
1257	*bool = detailslongname;
1258	size = sizeof(BOOL);
1259	PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size);
1260	strcpy(eos, "DetailsSubject");
1261	if (dcd)
1262	bool = &dcd->detailssubject;
1263	else
1264	bool = &detailssubject;
1265	*bool = detailssubject;
1266	size = sizeof(BOOL);
1267	PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size);
1268	strcpy(eos, "DetailsEA");
1269	if (dcd)
1270	bool = &dcd->detailsea;
1271	else
1272	bool = &detailsea;
1273	*bool = detailsea;
1274	size = sizeof(BOOL);
1275	PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size);
1276	strcpy(eos, "DetailsSize");
1277	if (dcd)
1278	bool = &dcd->detailssize;
1279	else
1280	bool = &detailssize;
1281	*bool = detailssize;
1282	size = sizeof(BOOL);
1283	PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size);
1284	strcpy(eos, "DetailsIcon");
1285	if (dcd)
1286	bool = &dcd->detailsicon;
1287	else
1288	bool = &detailsicon;
1289	*bool = detailsicon;
1290	size = sizeof(BOOL);
1291	PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size);
1292	strcpy(eos, "DetailsAttr");
1293	if (dcd)
1294	bool = &dcd->detailsattr;
1295	else
1296	bool = &detailsattr;
1297	*bool = detailsattr;
1298	size = sizeof(BOOL);
1299	PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size);
1300	strcpy(eos, "DetailsCRDate");
1301	if (dcd)
1302	bool = &dcd->detailscrdate;
1303	else
1304	bool = &detailscrdate;
1305	*bool = detailscrdate;
1306	size = sizeof(BOOL);
1307	PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size);
1308	strcpy(eos, "DetailsCRTime");
1309	if (dcd)
1310	bool = &dcd->detailscrtime;
1311	else
1312	bool = &detailscrtime;
1313	*bool = detailscrtime;
1314	size = sizeof(BOOL);
1315	PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size);
1316	strcpy(eos, "DetailsLWDate");
1317	if (dcd)
1318	bool = &dcd->detailslwdate;
1319	else
1320	bool = &detailslwdate;
1321	*bool = detailslwdate;
1322	size = sizeof(BOOL);
1323	PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size);
1324	strcpy(eos, "DetailsLWTime");
1325	if (dcd)
1326	bool = &dcd->detailslwtime;
1327	else
1328	bool = &detailslwtime;
1329	*bool = detailslwtime;
1330	size = sizeof(BOOL);
1331	PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size);
1332	strcpy(eos, "DetailsLADate");
1333	if (dcd)
1334	bool = &dcd->detailsladate;
1335	else
1336	bool = &detailsladate;
1337	*bool = detailsladate;
1338	size = sizeof(BOOL);
1339	PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size);
1340	strcpy(eos, "DetailsLATime");
1341	if (dcd)
1342	bool = &dcd->detailslatime;
1343	else
1344	bool = &detailslatime;
1345	*bool = detailslatime;
1346	size = sizeof(BOOL);
1347	PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size);
1348	strcpy(eos, "SubjectInLeftPane");
1349	if (dcd)
1350	bool = &dcd->fSubjectInLeftPane;
1351	else
1352	bool = &fSubjectInLeftPane;
1353	*bool = fSubjectInLeftPane;
1354	size = sizeof(BOOL);
1355	PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size);
1356	strcpy(eos, "SubjectLengthMax");
1357	if (dcd)
1358	bool = &dcd->fSubjectLengthMax;
1359	else
1360	bool = &fSubjectLengthMax;
1361	*bool = fSubjectLengthMax;
1362	size = sizeof(BOOL);
1363	PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size);
1364	if (dcd) {
1365	if (dcd->fSubjectLengthMax)
1366	dcd->SubjectDisplayWidth = 0;
1367	else {
1368	strcpy(eos, "SubjectDisplayWidth");
1369	bool = &dcd->SubjectDisplayWidth;
1370	*bool = SubjectDisplayWidth;
1371	size = sizeof(ULONG);
1372	PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size);
1373	if (dcd->SubjectDisplayWidth < 50)
1374	dcd->SubjectDisplayWidth = 0;
1375	else if (dcd->SubjectDisplayWidth > 1000)
1376	dcd->SubjectDisplayWidth = 1000;
1377	}
1378	}
1379	else {
1380	if (fSubjectLengthMax)
1381	SubjectDisplayWidth = 0;
1382	else {
1383	strcpy(eos, "SubjectDisplayWidth");
1384	bool = &SubjectDisplayWidth;
1385	*bool = SubjectDisplayWidth;
1386	size = sizeof(ULONG);
1387	PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size);
1388	if (SubjectDisplayWidth < 50)
1389	SubjectDisplayWidth = 0;
1390	else if (SubjectDisplayWidth > 1000)
1391	SubjectDisplayWidth = 1000;
1392	}
1393	}
1394	}
1395
1396	HWND FindDirCnr(HWND hwndParent)
1397	{
1398	HWND found, hwndDir = (HWND) 0;
1399	HENUM henum;
1400
1401	henum = WinBeginEnumWindows(hwndParent);
1402	while ((found = WinGetNextWindow(henum)) != NULLHANDLE) {
1403	hwndDir = WinWindowFromID(found, FID_CLIENT);
1404	if (hwndDir) {
1405	hwndDir = WinWindowFromID(hwndDir, DIR_CNR);
1406	if (hwndDir)
1407	break;
1408	hwndDir = (HWND) 0;
1409	}
1410	}
1411	WinEndEnumWindows(henum);
1412
1413	return hwndDir;
1414	}
1415
1416	VOID HeapThread(VOID * dummy)
1417	{
1418	ULONG postcount;
1419	APIRET rc;
1420
1421	rc = DosCreateEventSem(NULL, &CompactSem, 0L, FALSE);
1422	if (rc)
1423	Dos_Error(MB_CANCEL, rc, HWND_DESKTOP, pszSrcFile, __LINE__,
1424	"DosCreateEventSem");
1425	else {
1426	priority_normal();
1427	for (;;) {
1428	if (DosWaitEventSem(CompactSem, SEM_INDEFINITE_WAIT))
1429	break;
1430	_heapmin();
1431	DosResetEventSem(CompactSem, &postcount);
1432	}
1433	}
1434	}
1435
1436	VOID FixSwitchList(HWND hwnd, CHAR * text)
1437	{
1438	HSWITCH hswitch;
1439	SWCNTRL swctl;
1440
1441	hswitch = WinQuerySwitchHandle(hwnd, 0);
1442	if (hswitch) {
1443	if (!WinQuerySwitchEntry(hswitch, &swctl)) {
1444	strcpy(swctl.szSwtitle, "FM/2");
1445	WinChangeSwitchEntry(hswitch, &swctl);
1446	}
1447	}
1448	}
1449
1450	VOID QuickPopup(HWND hwnd, DIRCNRDATA * dcd, HWND hwndMenu, USHORT id)
1451	{
1452	dcd->hwndLastMenu = hwndMenu;
1453	if (dcd->hwndLastMenu && !dcd->cnremphasized) {
1454	WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPVOID,
1455	MPFROM2SHORT(TRUE, CRA_SOURCE));
1456	dcd->cnremphasized = TRUE;
1457	}
1458	if (dcd->flWindowAttr & CV_MINI)
1459	WinCheckMenuItem(dcd->hwndLastMenu, IDM_MINIICONS, TRUE);
1460	if (!WinPopupMenu(hwnd, hwnd, dcd->hwndLastMenu,
1461	8, 8, 0,
1462	PU_HCONSTRAIN \| PU_VCONSTRAIN \|
1463	PU_KEYBOARD \| PU_MOUSEBUTTON1)) {
1464	if (dcd->cnremphasized) {
1465	WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPVOID,
1466	MPFROM2SHORT(FALSE, CRA_SOURCE));
1467	dcd->cnremphasized = FALSE;
1468	}
1469	}
1470	else
1471	WinSendMsg(dcd->hwndLastMenu, MM_SELECTITEM,
1472	MPFROM2SHORT(id, TRUE), MPFROM2SHORT(0, FALSE));
1473	}
1474
1475	PMINIRECORDCORE CurrentRecord(HWND hwndCnr)
1476	{
1477	SHORT attrib = fSelectedAlways ? CRA_SELECTED : CRA_CURSORED;
1478	PMINIRECORDCORE pmi;
1479
1480	for (;;) {
1481	pmi = (PMINIRECORDCORE) WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS,
1482	MPFROMLONG(CMA_FIRST),
1483	MPFROMSHORT(attrib));
1484	if ((!pmi \|\| (INT) pmi == -1) && attrib == CRA_SELECTED) /* punt */
1485	attrib = CRA_CURSORED;
1486	else
1487	break;
1488	}
1489	return ((INT)pmi == -1) ? NULL : pmi;
1490	}
1491
1492	BOOL PostMsg(HWND h, ULONG msg, MPARAM mp1, MPARAM mp2)
1493	{
1494	BOOL rc = WinPostMsg(h, msg, mp1, mp2);
1495
1496	if (!rc) {
1497
1498	// If window owned by some other process or some other thread?
1499	if (!IsFm2Window(h, 1)) {
1500	QMSG qmsg;
1501	for (;;) {
1502	DosSleep(1);
1503	rc = WinPostMsg(h, msg, mp1, mp2);
1504	if (rc)
1505	break; // OK
1506	if (!WinIsWindow((HAB) 0, h))
1507	break; // Window gone
1508	if (WinPeekMsg((HAB) 0, &qmsg, (HWND) 0, 0, 0, PM_NOREMOVE))
1509	break; // Queue has message(s)
1510	} // for
1511	}
1512	}
1513	return rc;
1514	}
1515
1516	VOID OpenEdit(HWND hwnd)
1517	{
1518	CNREDITDATA ced;
1519	PCNRITEM pci;
1520	PFIELDINFO pfi;
1521
1522	pci = (PCNRITEM) WinSendMsg(hwnd,
1523	CM_QUERYRECORDEMPHASIS,
1524	MPFROMLONG(CMA_FIRST),
1525	MPFROMSHORT(CRA_CURSORED));
1526	if (pci && (INT) pci != -1) {
1527	memset(&ced, 0, sizeof(ced));
1528	ced.cb = sizeof(ced);
1529	ced.hwndCnr = hwnd;
1530	ced.id = WinQueryWindowUShort(hwnd, QWS_ID);
1531	ced.pRecord = (PRECORDCORE) pci;
1532	pfi = (PFIELDINFO) WinSendMsg(hwnd,
1533	CM_QUERYDETAILFIELDINFO,
1534	MPVOID, MPFROMSHORT(CMA_FIRST));
1535	if (!pfi)
1536	WinSendMsg(hwnd, CM_OPENEDIT, MPFROMP(&ced), MPVOID);
1537	else {
1538	while (pfi && (INT) pfi != -1 &&
1539	pfi->offStruct != FIELDOFFSET(CNRITEM, pszFileName))
1540	pfi = (PFIELDINFO) WinSendMsg(hwnd,
1541	CM_QUERYDETAILFIELDINFO,
1542	MPFROMP(pfi), MPFROMSHORT(CMA_NEXT));
1543	if (pfi && (INT) pfi != -1) {
1544	ced.pFieldInfo = pfi;
1545	{
1546	CNRINFO cnri;
1547
1548	memset(&cnri, 0, sizeof(CNRINFO));
1549	cnri.cb = sizeof(CNRINFO);
1550	WinSendMsg(hwnd,
1551	CM_QUERYCNRINFO,
1552	MPFROMP(&cnri), MPFROMLONG(sizeof(CNRINFO)));
1553	if (cnri.flWindowAttr & CV_DETAIL)
1554	ced.id = CID_LEFTDVWND;
1555	}
1556	WinSendMsg(hwnd, CM_OPENEDIT, MPFROMP(&ced), MPVOID);
1557	}
1558	}
1559	}
1560	}
1561
1562	#ifdef NEVER
1563	VOID QuickView(HWND hwnd, CHAR * filename)
1564	{
1565	if (filename && IsFile(filename) == 1) {
1566	if (TestBinary(filename) && *binview) {
1567
1568	CHAR *list[2];
1569
1570	list[0] = filename;
1571	list[1] = NULL;
1572	ExecOnList(hwnd, binview, WINDOWED \| SEPARATE, NULL, list, NULL,
1573	pszSrcFile, __LINE__);
1574	return;
1575	}
1576	else if (*viewer) {
1577
1578	CHAR *list[2];
1579
1580	list[0] = filename;
1581	list[1] = NULL;
1582	ExecOnList(hwnd, viewer,
1583	WINDOWED \| SEPARATE \| (fViewChild ? CHILD : 0),
1584	NULL, list, NULL, pszSrcFile, __LINE__);
1585	return;
1586	}
1587	StartMLEEditor(HWND_DESKTOP, 5, filename, (HWND) 0);
1588	}
1589	}
1590
1591	VOID QuickEdit(HWND hwnd, CHAR * filename)
1592	{
1593	if (filename && IsFile(filename) == 1) {
1594	if (TestBinary(filename) && *bined) {
1595
1596	CHAR *list[2];
1597
1598	list[0] = filename;
1599	list[1] = NULL;
1600	ExecOnList(hwnd, bined, WINDOWED \| SEPARATE, NULL, list, NULL,
1601	pszSrcFile, __LINE__);
1602	return;
1603	}
1604	else if (*editor) {
1605
1606	CHAR *list[2];
1607
1608	list[0] = filename;
1609	list[1] = NULL;
1610	ExecOnList(hwnd, editor, WINDOWED \| SEPARATE, NULL, list, NULL,
1611	pszSrcFile, __LINE__);
1612	return;
1613	}
1614	StartMLEEditor(HWND_DESKTOP, 4, filename, (HWND) 0);
1615	}
1616	}
1617	#endif
1618
1619	VOID PortholeInit(HWND hwndNew, MPARAM mp1, MPARAM mp2)
1620	{
1621	static HWND DefMenu = (HWND) 0;
1622	HWND hwndMenu = (HWND) mp2;
1623
1624	{
1625	ULONG style;
1626
1627	style = WinQueryWindowULong(hwndMenu, QWL_STYLE);
1628	if (!(style & MS_ACTIONBAR))
1629	return;
1630	}
1631
1632	switch (SHORT1FROMMP(mp1)) {
1633	case 0:
1634	{
1635	HWND hwndNow;
1636	MENUITEM mi;
1637	ULONG ulStyle;
1638
1639	memset(&mi, 0, sizeof(mi));
1640	mi.iPosition = MIT_END;
1641	mi.afStyle = MIS_TEXT;
1642	WinSendMsg(hwndMenu, MM_QUERYITEM,
1643	MPFROM2SHORT(IDM_FILESMENU, TRUE), MPFROMP(&mi));
1644	if (!DefMenu)
1645	DefMenu = WinLoadMenu(HWND_DESKTOP, FM3ModHandle, DEFMENU);
1646	hwndNow = mi.hwndSubMenu;
1647	mi.hwndSubMenu = hwndNew;
1648	if (!mi.hwndSubMenu)
1649	mi.hwndSubMenu = DefMenu;
1650	WinSetParent(hwndNow, WinQueryObjectWindow(HWND_DESKTOP), FALSE);
1651	WinSetOwner(hwndNow, WinQueryObjectWindow(HWND_DESKTOP));
1652	WinSetOwner(mi.hwndSubMenu, hwndMenu);
1653	WinSetParent(mi.hwndSubMenu, hwndMenu, FALSE);
1654	WinSetWindowUShort(mi.hwndSubMenu, QWS_ID, IDM_FILESMENU);
1655	mi.afStyle = MIS_SUBMENU;
1656	ulStyle = WinQueryWindowULong(mi.hwndSubMenu, QWL_STYLE);
1657	ulStyle &= -WS_SAVEBITS;
1658	ulStyle \|= MS_POPUP \| WS_CLIPSIBLINGS \| WS_SAVEBITS;
1659	WinSetWindowULong(mi.hwndSubMenu, QWL_STYLE, ulStyle);
1660	WinSendMsg(hwndMenu, MM_SETITEM, MPFROM2SHORT(0, TRUE), MPFROMP(&mi));
1661	}
1662	break;
1663
1664	case 1:
1665	{
1666	HWND hwndNow;
1667	MENUITEM mi;
1668	ULONG ulStyle;
1669
1670	memset(&mi, 0, sizeof(mi));
1671	mi.iPosition = MIT_END;
1672	mi.afStyle = MIS_TEXT;
1673	WinSendMsg(hwndMenu, MM_QUERYITEM,
1674	MPFROM2SHORT(IDM_VIEWSMENU, TRUE), MPFROMP(&mi));
1675	if (!DefMenu)
1676	DefMenu = WinLoadMenu(HWND_DESKTOP, FM3ModHandle, DEFMENU);
1677	hwndNow = mi.hwndSubMenu;
1678	mi.hwndSubMenu = hwndNew;
1679	if (!mi.hwndSubMenu)
1680	mi.hwndSubMenu = DefMenu;
1681	WinSetParent(hwndNow, WinQueryObjectWindow(HWND_DESKTOP), FALSE);
1682	WinSetOwner(hwndNow, WinQueryObjectWindow(HWND_DESKTOP));
1683	WinSetOwner(mi.hwndSubMenu, hwndMenu);
1684	WinSetParent(mi.hwndSubMenu, hwndMenu, FALSE);
1685	WinSetWindowUShort(mi.hwndSubMenu, QWS_ID, IDM_VIEWSMENU);
1686	mi.afStyle = MIS_SUBMENU;
1687	ulStyle = WinQueryWindowULong(mi.hwndSubMenu, QWL_STYLE);
1688	ulStyle &= -WS_SAVEBITS;
1689	ulStyle \|= MS_POPUP \| WS_CLIPSIBLINGS \| WS_SAVEBITS;
1690	WinSetWindowULong(mi.hwndSubMenu, QWL_STYLE, ulStyle);
1691	WinSendMsg(hwndMenu, MM_SETITEM, MPFROM2SHORT(0, TRUE), MPFROMP(&mi));
1692	}
1693	break;
1694	}
1695	}
1696
1697	HWND CheckMenu(HWND hwnd, HWND * hwndMenu, USHORT id)
1698	{
1699	/* load and adjust menus as required */
1700	if (!hwndMenu \|\| !WinIsWindow((HAB) 0, hwndMenu)) {
1701	*hwndMenu = WinLoadMenu(HWND_DESKTOP, FM3ModHandle, id);
1702	CopyPresParams(*hwndMenu, hwnd);
1703	if (hwndMenu == &DirMenu) {
1704	WinSetWindowUShort(DirMenu, QWS_ID, IDM_FILESMENU);
1705	SetConditionalCascade(DirMenu, IDM_COMMANDSMENU, IDM_DOITYOURSELF);
1706	SetConditionalCascade(DirMenu, IDM_COPYMENU, IDM_COPY);
1707	SetConditionalCascade(DirMenu, IDM_MOVEMENU, IDM_MOVE);
1708	SetConditionalCascade(DirMenu, IDM_SAVESUBMENU, IDM_SAVETOCLIP);
1709	SetConditionalCascade(DirMenu, IDM_VIEWSUBMENU, IDM_INFO);
1710	SetConditionalCascade(DirMenu, IDM_EDITSUBMENU, IDM_ATTRS);
1711	SetConditionalCascade(DirMenu, IDM_DELETESUBMENU,
1712	fDefaultDeletePerm ? IDM_PERMDELETE : IDM_DELETE);
1713	SetConditionalCascade(DirMenu, IDM_MISCSUBMENU, IDM_SIZES);
1714	SetConditionalCascade(DirMenu, IDM_OPENSUBMENU, IDM_OPENWINDOW);
1715	if (fWorkPlace) {
1716	WinSendMsg(DirMenu, MM_DELETEITEM,
1717	MPFROM2SHORT(IDM_OPENSUBMENU, TRUE), MPVOID);
1718	WinSendMsg(DirMenu, MM_DELETEITEM,
1719	MPFROM2SHORT(IDM_OBJECTSUBMENU, TRUE), MPVOID);
1720	}
1721	}
1722	else if (hwndMenu == &TreeMenu) {
1723	WinSetWindowUShort(TreeMenu, QWS_ID, IDM_FILESMENU);
1724	SetConditionalCascade(TreeMenu, IDM_COMMANDSMENU, IDM_DOITYOURSELF);
1725	SetConditionalCascade(TreeMenu, IDM_SAVESUBMENU, IDM_SAVETOCLIP);
1726	SetConditionalCascade(TreeMenu, IDM_EDITSUBMENU, IDM_ATTRS);
1727	SetConditionalCascade(TreeMenu, IDM_EXPANDSUBMENU, IDM_EXPAND);
1728	SetConditionalCascade(TreeMenu, IDM_MISCSUBMENU, IDM_SIZES);
1729	SetConditionalCascade(TreeMenu, IDM_OPENSUBMENU, IDM_OPENWINDOW);
1730	if (fWorkPlace) {
1731	WinSendMsg(TreeMenu, MM_DELETEITEM,
1732	MPFROM2SHORT(IDM_OPENSUBMENU, TRUE), MPVOID);
1733	WinSendMsg(TreeMenu, MM_DELETEITEM,
1734	MPFROM2SHORT(IDM_OBJECTSUBMENU, TRUE), MPVOID);
1735	}
1736	}
1737	else if (hwndMenu == &ArcMenu) {
1738	WinSetWindowUShort(ArcMenu, QWS_ID, IDM_FILESMENU);
1739	SetConditionalCascade(ArcMenu, IDM_EXTRACTSUBMENU, IDM_EXTRACT);
1740	SetConditionalCascade(ArcMenu, IDM_EDITSUBMENU, IDM_EDIT);
1741	SetConditionalCascade(ArcMenu, IDM_VIEWSUBMENU, IDM_VIEW);
1742	if (fWorkPlace)
1743	WinSendMsg(ArcMenu, MM_DELETEITEM,
1744	MPFROM2SHORT(IDM_FOLDERAFTEREXTRACT, TRUE), MPVOID);
1745	}
1746	else if (hwndMenu == &FileMenu) {
1747	WinSetWindowUShort(FileMenu, QWS_ID, IDM_FILESMENU);
1748	SetConditionalCascade(FileMenu, IDM_COMMANDSMENU, IDM_DOITYOURSELF);
1749	SetConditionalCascade(FileMenu, IDM_COPYMENU, IDM_COPY);
1750	SetConditionalCascade(FileMenu, IDM_MOVEMENU, IDM_MOVE);
1751	SetConditionalCascade(FileMenu, IDM_SAVESUBMENU, IDM_SAVETOCLIP);
1752	SetConditionalCascade(FileMenu, IDM_VIEWSUBMENU, IDM_VIEW);
1753	SetConditionalCascade(FileMenu, IDM_EDITSUBMENU, IDM_EDIT);
1754	SetConditionalCascade(FileMenu, IDM_COLLECTMENU, IDM_COLLECT);
1755	SetConditionalCascade(FileMenu, IDM_DELETESUBMENU,
1756	fDefaultDeletePerm ? IDM_PERMDELETE : IDM_DELETE);
1757	SetConditionalCascade(FileMenu, IDM_OPENSUBMENU, IDM_OPENDEFAULT);
1758	SetConditionalCascade(FileMenu, IDM_OBJECTSUBMENU, IDM_SHADOW);
1759	if (fWorkPlace) {
1760	WinSendMsg(FileMenu, MM_DELETEITEM,
1761	MPFROM2SHORT(IDM_OPENSUBMENU, TRUE), MPVOID);
1762	WinSendMsg(FileMenu, MM_DELETEITEM,
1763	MPFROM2SHORT(IDM_OBJECTSUBMENU, TRUE), MPVOID);
1764	}
1765	}
1766	else if (hwndMenu == &DirCnrMenu) {
1767	WinSetWindowUShort(DirCnrMenu, QWS_ID, IDM_VIEWSMENU);
1768	SetConditionalCascade(DirCnrMenu, IDM_MISCSUBMENU, IDM_SIZES);
1769	SetConditionalCascade(DirCnrMenu, IDM_OPENSUBMENU, IDM_OPENSETTINGSME);
1770	if (fWorkPlace)
1771	WinSendMsg(DirCnrMenu, MM_DELETEITEM,
1772	MPFROM2SHORT(IDM_OPENSUBMENU, TRUE), MPVOID);
1773	}
1774	else if (hwndMenu == &TreeCnrMenu) {
1775	WinSetWindowUShort(TreeCnrMenu, QWS_ID, IDM_VIEWSMENU);
1776	SetConditionalCascade(TreeCnrMenu, IDM_PARTITIONSMENU, IDM_PARTITION);
1777	}
1778	else if (hwndMenu == &ArcCnrMenu) {
1779	WinSetWindowUShort(ArcCnrMenu, QWS_ID, IDM_VIEWSMENU);
1780	SetConditionalCascade(ArcCnrMenu, IDM_EXTRACTSUBMENU, IDM_ARCEXTRACT);
1781	if (fWorkPlace)
1782	WinSendMsg(ArcCnrMenu, MM_DELETEITEM,
1783	MPFROM2SHORT(IDM_FOLDERAFTEREXTRACT, TRUE), MPVOID);
1784	}
1785	else if (hwndMenu == &CollectorCnrMenu) {
1786	WinSetWindowUShort(CollectorCnrMenu, QWS_ID, IDM_VIEWSMENU);
1787	SetConditionalCascade(CollectorCnrMenu, IDM_COLLECTMENU,
1788	IDM_COLLECTFROMCLIP);
1789	}
1790	else if (hwndMenu == &CollectorFileMenu) {
1791	WinSetWindowUShort(CollectorFileMenu, QWS_ID, IDM_FILESMENU);
1792	SetConditionalCascade(CollectorFileMenu, IDM_COMMANDSMENU,
1793	IDM_DOITYOURSELF);
1794	SetConditionalCascade(CollectorFileMenu, IDM_COPYMENU, IDM_COPY);
1795	SetConditionalCascade(CollectorFileMenu, IDM_MOVEMENU, IDM_MOVE);
1796	SetConditionalCascade(CollectorFileMenu, IDM_SAVESUBMENU,
1797	IDM_SAVETOCLIP);
1798	SetConditionalCascade(CollectorFileMenu, IDM_VIEWSUBMENU, IDM_VIEW);
1799	SetConditionalCascade(CollectorFileMenu, IDM_EDITSUBMENU, IDM_EDIT);
1800	SetConditionalCascade(CollectorFileMenu, IDM_DELETESUBMENU,
1801	fDefaultDeletePerm ? IDM_PERMDELETE : IDM_DELETE);
1802	SetConditionalCascade(CollectorFileMenu, IDM_OPENSUBMENU,
1803	IDM_OPENDEFAULT);
1804	SetConditionalCascade(CollectorFileMenu, IDM_OBJECTSUBMENU, IDM_SHADOW);
1805	if (fWorkPlace) {
1806	WinSendMsg(CollectorFileMenu, MM_DELETEITEM,
1807	MPFROM2SHORT(IDM_OPENSUBMENU, TRUE), MPVOID);
1808	WinSendMsg(CollectorFileMenu, MM_DELETEITEM,
1809	MPFROM2SHORT(IDM_OBJECTSUBMENU, TRUE), MPVOID);
1810	}
1811	}
1812	else if (hwndMenu == &CollectorDirMenu) {
1813	WinSetWindowUShort(CollectorDirMenu, QWS_ID, IDM_FILESMENU);
1814	SetConditionalCascade(CollectorDirMenu, IDM_COMMANDSMENU,
1815	IDM_DOITYOURSELF);
1816	SetConditionalCascade(CollectorDirMenu, IDM_COPYMENU, IDM_COPY);
1817	SetConditionalCascade(CollectorDirMenu, IDM_MOVEMENU, IDM_MOVE);
1818	SetConditionalCascade(CollectorDirMenu, IDM_SAVESUBMENU,
1819	IDM_SAVETOCLIP);
1820	SetConditionalCascade(CollectorDirMenu, IDM_VIEWSUBMENU, IDM_INFO);
1821	SetConditionalCascade(CollectorDirMenu, IDM_EDITSUBMENU, IDM_ATTRS);
1822	SetConditionalCascade(CollectorDirMenu, IDM_DELETESUBMENU,
1823	fDefaultDeletePerm ? IDM_PERMDELETE : IDM_DELETE);
1824	SetConditionalCascade(CollectorDirMenu, IDM_MISCSUBMENU, IDM_SIZES);
1825	SetConditionalCascade(CollectorDirMenu, IDM_OPENSUBMENU,
1826	IDM_OPENWINDOW);
1827	if (fWorkPlace) {
1828	WinSendMsg(CollectorDirMenu, MM_DELETEITEM,
1829	MPFROM2SHORT(IDM_OPENSUBMENU, TRUE), MPVOID);
1830	WinSendMsg(CollectorDirMenu, MM_DELETEITEM,
1831	MPFROM2SHORT(IDM_OBJECTSUBMENU, TRUE), MPVOID);
1832	}
1833	}
1834	else if (hwndMenu == &MainPopupMenu) {
1835	WinSetWindowUShort(MainPopupMenu, QWS_ID, IDM_MAINPOPUP);
1836	SetConditionalCascade(MainPopupMenu, IDM_TOOLSUBMENU, IDM_TOOLBAR);
1837	SetConditionalCascade(MainPopupMenu, IDM_AUTOVIEWSUBMENU, IDM_AUTOVIEW);
1838	}
1839	}
1840	CopyPresParams(*hwndMenu, hwnd);
1841	return *hwndMenu;
1842	}
1843
1844	SHORT AddToListboxBottom(HWND hwnd, CHAR * str)
1845	{
1846	SHORT ln;
1847
1848	ln = (SHORT) WinSendMsg(hwnd, LM_INSERTITEM, MPFROM2SHORT(LIT_END, 0),
1849	MPFROMP(str));
1850	if (ln)
1851	WinSendMsg(hwnd, LM_SELECTITEM, MPFROM2SHORT(ln, 0), MPVOID);
1852	return ln;
1853	}
1854
1855	VOID SetSysMenu(HWND hwndSysMenu)
1856	{
1857	CHAR s[128], *p;
1858
1859	if (WinSendMsg(hwndSysMenu, MM_QUERYITEMTEXT,
1860	MPFROM2SHORT(SC_RESTORE, 128), MPFROMP(s))) {
1861	p = strchr(s, '\t');
1862	if (p) {
1863	p++;
1864	strcpy(p, "Ctrl+Alt+F5");
1865	WinSetMenuItemText(hwndSysMenu, SC_RESTORE, s);
1866	}
1867	}
1868	if (WinSendMsg(hwndSysMenu, MM_QUERYITEMTEXT,
1869	MPFROM2SHORT(SC_CLOSE, 128), MPFROMP(s))) {
1870	p = strchr(s, '\t');
1871	if (p) {
1872	p++;
1873	strcpy(p, "Ctrl+Alt+F4");
1874	WinSetMenuItemText(hwndSysMenu, SC_CLOSE, s);
1875	}
1876	}
1877	if (WinSendMsg(hwndSysMenu, MM_QUERYITEMTEXT,
1878	MPFROM2SHORT(SC_MOVE, 128), MPFROMP(s))) {
1879	p = strchr(s, '\t');
1880	if (p) {
1881	p++;
1882	strcpy(p, "Ctrl+Alt+F7");
1883	WinSetMenuItemText(hwndSysMenu, SC_MOVE, s);
1884	}
1885	}
1886	if (WinSendMsg(hwndSysMenu, MM_QUERYITEMTEXT,
1887	MPFROM2SHORT(SC_SIZE, 128), MPFROMP(s))) {
1888	p = strchr(s, '\t');
1889	if (p) {
1890	p++;
1891	strcpy(p, "Ctrl+Alt+F8");
1892	WinSetMenuItemText(hwndSysMenu, SC_SIZE, s);
1893	}
1894	}
1895	if (WinSendMsg(hwndSysMenu, MM_QUERYITEMTEXT,
1896	MPFROM2SHORT(SC_MINIMIZE, 128), MPFROMP(s))) {
1897	p = strchr(s, '\t');
1898	if (p) {
1899	p++;
1900	strcpy(p, "Ctrl+Alt+F9");
1901	WinSetMenuItemText(hwndSysMenu, SC_MINIMIZE, s);
1902	}
1903	}
1904	if (WinSendMsg(hwndSysMenu,
1905	MM_QUERYITEMTEXT,
1906	MPFROM2SHORT(SC_MAXIMIZE, 128), MPFROMP(s))) {
1907	p = strchr(s, '\t');
1908	if (p) {
1909	p++;
1910	strcpy(p, "Ctrl+Alt+F10");
1911	WinSetMenuItemText(hwndSysMenu, SC_MAXIMIZE, s);
1912	}
1913	}
1914	if (WinSendMsg(hwndSysMenu,
1915	MM_QUERYITEMTEXT, MPFROM2SHORT(SC_HIDE, 128), MPFROMP(s))) {
1916	p = strchr(s, '\t');
1917	if (p) {
1918	p++;
1919	strcpy(p, "Ctrl+Alt+F11");
1920	WinSetMenuItemText(hwndSysMenu, SC_HIDE, s);
1921	}
1922	}
1923	}
1924
1925	VOID LoadLibPath(CHAR * str, LONG len)
1926	{
1927	ULONG ver[2];
1928	CHAR configsys[] = "C:\\CONFIG.SYS";
1929	static CHAR var[8192], beg[16384], end[16384];
1930	BOOL warp;
1931	FILE *fp;
1932	PFN DQELIBPATH = NULL;
1933	HMODULE hmod;
1934
1935	if (str && len) {
1936	*str = 0;
1937	if (DosQuerySysInfo(QSV_BOOT_DRIVE,
1938	QSV_BOOT_DRIVE, (PVOID) ver, (ULONG) sizeof(ULONG)))
1939	ver[0] = 3L;
1940	*configsys = (CHAR) ver[0] + '@';
1941	if (!DosQuerySysInfo(QSV_VERSION_MAJOR,
1942	QSV_VERSION_MINOR,
1943	(PVOID) ver, (ULONG) sizeof(ver)) && ver[1] >= 30)
1944	warp = TRUE;
1945	var = beg = *end = 0;
1946	if (warp) {
1947	if (!DosLoadModule(var, sizeof(var), "DOSCALL1.DLL", &hmod)) {
1948	if (!DosQueryProcAddr(hmod,
1949	ORD_DOS32QUERYEXTLIBPATH,
1950	NULL, (PFN *) & DQELIBPATH)) {
1951	DQELIBPATH(beg, BEGIN_LIBPATH);
1952	DQELIBPATH(end, END_LIBPATH);
1953	}
1954	DosFreeModule(hmod);
1955	}
1956	*var = 0;
1957	}
1958	fp = xfopen(configsys, "r", pszSrcFile, __LINE__);
1959	if (fp) {
1960	while (!feof(fp)) {
1961	if (!xfgets_bstripcr(var, sizeof(var), fp, pszSrcFile, __LINE__))
1962	break;
1963	if (!strnicmp(var, "LIBPATH=", 8)) {
1964	memmove(var, var + 8, strlen(var + 8) + 1);
1965	lstrip(var);
1966	break;
1967	}
1968	}
1969	fclose(fp);
1970	}
1971	strncpy(str, beg, len);
1972	strncat(str, var, len - strlen(str));
1973	strncat(str, end, len - strlen(str));
1974	str[len - 1] = 0;
1975	}
1976	}
1977
1978	void SetViewMenu(HWND hwndMenu, ULONG flWindowAttr)
1979	{
1980	WinCheckMenuItem(hwndMenu, IDM_MINIICONS, ((flWindowAttr & CV_MINI)));
1981	WinCheckMenuItem(hwndMenu, IDM_TEXT, ((flWindowAttr & CV_TEXT)));
1982	WinCheckMenuItem(hwndMenu, IDM_ICON, ((flWindowAttr & CV_ICON) &&
1983	!(flWindowAttr & CV_TREE)));
1984	WinCheckMenuItem(hwndMenu, IDM_TREEVIEW, ((flWindowAttr & CV_TREE)));
1985	WinCheckMenuItem(hwndMenu, IDM_DETAILS, ((flWindowAttr & CV_DETAIL)));
1986	WinCheckMenuItem(hwndMenu, IDM_NAME, ((flWindowAttr & CV_NAME)));
1987	}
1988
1989	void SaySort(HWND hwnd, INT sortflags, BOOL archive)
1990	{
1991	char *s = NULL;
1992
1993	s = xmalloc(CCHMAXPATH, pszSrcFile, __LINE__);
1994	if (s) {
1995	sprintf(s, "S:%s%s",
1996	sortflags & SORT_REVERSE ? "^" : NullStr,
1997	(sortflags & SORT_FIRSTEXTENSION) ?
1998	GetPString(IDS_FIRSTX) : (sortflags & SORT_LASTEXTENSION) ?
1999	GetPString(IDS_LASTX) : (sortflags & SORT_SIZE) ?
2000	"Size" : (sortflags & SORT_EASIZE) ?
2001	(archive == 0) ?
2002	GetPString(IDS_EASIZE) : GetPString(IDS_CSIZE) :
2003	(sortflags & SORT_LWDATE) ?
2004	(archive == 0) ?
2005	GetPString(IDS_LWDATE) : GetPString(IDS_DATE) :
2006	(sortflags & SORT_LADATE) ?
2007	GetPString(IDS_LADATE) : (sortflags & SORT_CRDATE) ?
2008	GetPString(IDS_CRDATE) :
2009	(sortflags & SORT_PATHNAME) ?
2010	GetPString(IDS_PATH) : (sortflags & SORT_NOSORT) ?
2011	GetPString(IDS_NONE) : (sortflags & SORT_SUBJECT) ?
2012	GetPString(IDS_SUBJ) : GetPString(IDS_NAME));
2013	WinSetWindowText(hwnd, s);
2014	free(s);
2015	}
2016	}
2017
2018	void SayView(HWND hwnd, ULONG flWindowAttr)
2019	{
2020	char *s = NULL;
2021
2022	s = xmalloc(CCHMAXPATH, pszSrcFile, __LINE__);
2023	if (s) {
2024	sprintf(s, "V:%s%s",
2025	(flWindowAttr & CV_TREE) ? GetPString(IDS_TREE) :
2026	(flWindowAttr & CV_NAME) ? GetPString(IDS_NAME) :
2027	(flWindowAttr & CV_DETAIL) ? GetPString(IDS_DETAIL) :
2028	(flWindowAttr & CV_TEXT) ? GetPString(IDS_TEXT) :
2029	GetPString(IDS_ICON),
2030	((flWindowAttr & CV_MINI) &&
2031	!(flWindowAttr & CV_TEXT)) ? GetPString(IDS_MINI) : NullStr);
2032	WinSetWindowText(hwnd, s);
2033	free(s);
2034	}
2035	}
2036
2037	void SayFilter(HWND hwnd, MASK * mask, BOOL archive)
2038	{
2039	char *s = NULL;
2040
2041	s = xmalloc(CCHMAXPATH * 2, pszSrcFile, __LINE__);
2042	if (s) {
2043	sprintf(s, "F:%s%s",
2044	mask->szMask,
2045	(!archive && (mask->attrFile != ALLATTRS \|\|
2046	mask->antiattr != 0)) ? " " : NullStr,
2047	(!archive && (mask->attrFile != ALLATTRS \|\|
2048	mask->antiattr !=
2049	0)) ? GetPString(IDS_ATTRTEXT) : NullStr);
2050	if (!s[2])
2051	sprintf(s, "F:%s", GetPString(IDS_ALLTEXT));
2052	WinSetWindowText(hwnd, s);
2053	free(s);
2054	}
2055	}
2056
2057	char *GetCmdSpec(BOOL dos)
2058	{
2059	char *cmspec;
2060
2061	if (!dos) {
2062	cmspec = getenv("OS2_SHELL");
2063	if (!cmspec)
2064	cmspec = getenv("COMSPEC");
2065	if (!cmspec)
2066	cmspec = "CMD.EXE";
2067	}
2068	else {
2069	cmspec = getenv("DOS_SHELL");
2070	if (!cmspec)
2071	cmspec = "COMMAND.COM";
2072	}
2073	return cmspec;
2074	}
2075
2076	void Broadcast(HAB hab, HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
2077	{
2078	if (hwndMain)
2079	WinBroadcastMsg(hwndMain, msg, mp1, mp2, BMSG_SEND \| BMSG_FRAMEONLY);
2080	if (hwnd &&
2081	hwnd != HWND_DESKTOP &&
2082	hwnd != hwndMain &&
2083	hwnd != WinQueryDesktopWindow(hab, NULLHANDLE) &&
2084	WinIsWindow(hab, hwnd) && (!hwndMain \|\| !WinIsChild(hwnd, hwndMain)))
2085	WinSendMsg(hwnd, msg, mp1, mp2);
2086	}
2087
2088	void SetupWinList(HWND hwndMenu, HWND hwndTop, HWND hwndFrame)
2089	{
2090	/*
2091	* add switchlist entries to end of pulldown menu
2092	*/
2093
2094	SHORT sItemCount, x = 0, y = 0;
2095	MENUITEM mi;
2096
2097	sItemCount = (SHORT) WinSendMsg(hwndMenu,
2098	MM_QUERYITEMCOUNT, MPVOID, MPVOID);
2099
2100	/* clean out old additions */
2101	while ((SHORT) WinSendMsg(hwndMenu,
2102	MM_DELETEITEM,
2103	MPFROM2SHORT(IDM_SWITCHSTART + x++,
2104	TRUE), MPVOID) < sItemCount)
2105	sItemCount--;
2106	x = 0;
2107	while ((SHORT) WinSendMsg(hwndMenu,
2108	MM_DELETEITEM,
2109	MPFROM2SHORT(IDM_WINDOWSTART + x++,
2110	TRUE), MPVOID) < sItemCount)
2111	sItemCount--;
2112
2113	x = 0;
2114	if (hwndTop) {
2115
2116	char wtext[CCHMAXPATH + 8];
2117	HENUM henum;
2118	HWND hwndChild;
2119
2120	/* add children of the main FM/2 client */
2121	henum = WinBeginEnumWindows(hwndTop);
2122	memset(&mi, 0, sizeof(mi));
2123	while ((hwndChild = WinGetNextWindow(henum)) != NULLHANDLE) {
2124	if (WinQueryWindowUShort(hwndChild, QWS_ID) && hwndChild != hwndFrame) {
2125	*wtext = 0;
2126	WinQueryWindowText(hwndChild, CCHMAXPATH + 8, wtext);
2127	if (*wtext) {
2128	wtext[CCHMAXPATH + 7] = 0;
2129	mi.afStyle = MIS_TEXT;
2130	if (!((x + sItemCount) % 28))
2131	mi.afStyle \|= MIS_BREAK;
2132	mi.id = IDM_WINDOWSTART + x;
2133	mi.iPosition = MIT_END;
2134	if ((SHORT) WinSendMsg(hwndMenu,
2135	MM_INSERTITEM,
2136	MPFROMP(&mi), MPFROMP(wtext)) >= 0)
2137	x++;
2138	}
2139	}
2140	}
2141	WinEndEnumWindows(henum);
2142	}
2143
2144	/* add external FM/2 windows */
2145	{
2146	PSWBLOCK pswb;
2147	ULONG ulSize, ulcEntries;
2148	HWND hwndTopFrame;
2149	register INT i;
2150
2151	hwndTopFrame = hwndTop ? WinQueryWindow(hwndTop, QW_PARENT) : (HWND)0;
2152	/* Get the switch list information */
2153	x = 0;
2154	ulcEntries = WinQuerySwitchList(0, NULL, 0);
2155	ulSize = sizeof(SWBLOCK) + sizeof(HSWITCH) + (ulcEntries + 4L) *
2156	(LONG) sizeof(SWENTRY);
2157	/* Allocate memory for list */
2158	pswb = xmalloc(ulSize, pszSrcFile, __LINE__);
2159	if (pswb) {
2160	/* Put the info in the list */
2161	ulcEntries = WinQuerySwitchList(0, pswb, ulSize - sizeof(SWENTRY));
2162	/* do the dirty deed */
2163	memset(&mi, 0, sizeof(mi));
2164	for (i = 0; i < pswb->cswentry; i++) {
2165	if (pswb->aswentry[i].swctl.uchVisibility == SWL_VISIBLE &&
2166	pswb->aswentry[i].swctl.fbJump == SWL_JUMPABLE &&
2167	(pswb->aswentry[i].swctl.idProcess != mypid \|\|
2168	!hwndFrame \|\|
2169	pswb->aswentry[i].swctl.hwnd != hwndFrame) &&
2170	(pswb->aswentry[i].swctl.idProcess != mypid \|\|
2171	!hwndTopFrame \|\|
2172	pswb->aswentry[i].swctl.hwnd != hwndTopFrame \|\|
2173	!WinIsChild(hwndFrame, hwndTop))) {
2174	if (!strnicmp(pswb->aswentry[i].swctl.szSwtitle, "AV/2", 4)
2175	\|\| !stricmp(pswb->aswentry[i].swctl.szSwtitle, "File Manager/2")
2176	\|\| !stricmp(pswb->aswentry[i].swctl.szSwtitle, "Collector")
2177	\|\| !strnicmp(pswb->aswentry[i].swctl.szSwtitle, "VTree", 5)
2178	\|\| !strnicmp(pswb->aswentry[i].swctl.szSwtitle, "VDir", 4)
2179	\|\| !strnicmp(pswb->aswentry[i].swctl.szSwtitle, FM2Str, 4)) {
2180	mi.afStyle = MIS_TEXT;
2181	if (x && !(x % 28))
2182	mi.afStyle \|= MIS_BREAK;
2183	mi.id = IDM_SWITCHSTART + y;
2184	mi.iPosition = MIT_END;
2185	switches[y] = pswb->aswentry[i].hswitch;
2186	if ((SHORT) WinSendMsg(hwndMenu,
2187	MM_INSERTITEM,
2188	MPFROMP(&mi),
2189	MPFROMP(pswb->aswentry[i].
2190	swctl.szSwtitle)) >= 0) {
2191	y++;
2192	x++;
2193	}
2194	}
2195	}
2196	}
2197	numswitches = y;
2198	free(pswb);
2199	DosPostEventSem(CompactSem);
2200	}
2201	}
2202	}
2203
2204	BOOL SwitchCommand(HWND hwndMenu, USHORT cmd)
2205	{
2206	BOOL ret = FALSE;
2207
2208	if (hwndMain && hwndMenu && cmd >= IDM_WINDOWSTART && cmd < IDM_SWITCHSTART) {
2209	/*
2210	* select a child window (of client)
2211	*/
2212
2213	MENUITEM mi;
2214	HWND hwndSubMenu = (HWND) 0, hwndChild;
2215	CHAR s[CCHMAXPATH + 8];
2216
2217	if (WinQueryWindowUShort(hwndMenu, QWS_ID) != IDM_WINDOWSMENU) {
2218	memset(&mi, 0, sizeof(mi));
2219	mi.iPosition = MIT_END;
2220	mi.afStyle = MIS_TEXT;
2221	if (WinSendMsg(hwndMenu,
2222	MM_QUERYITEM,
2223	MPFROM2SHORT(IDM_WINDOWSMENU, TRUE), MPFROMP(&mi)))
2224	hwndSubMenu = mi.hwndSubMenu;
2225	}
2226	else
2227	hwndSubMenu = hwndMenu;
2228	if (hwndSubMenu) {
2229	*s = 0;
2230	if (WinSendMsg(hwndSubMenu,
2231	MM_QUERYITEMTEXT,
2232	MPFROM2SHORT(cmd, CCHMAXPATH + 8), MPFROMP(s)) && *s) {
2233
2234	HENUM henum;
2235	CHAR checkText[CCHMAXPATH + 8];
2236	SWP swp;
2237
2238	s[CCHMAXPATH + 7] = 0;
2239	henum = WinBeginEnumWindows(hwndMain);
2240	while ((hwndChild = WinGetNextWindow(henum)) != NULLHANDLE) {
2241	if (WinQueryWindowUShort(hwndChild, QWS_ID)) {
2242	*checkText = 0;
2243	WinQueryWindowText(hwndChild, CCHMAXPATH + 8, checkText);
2244	checkText[CCHMAXPATH + 7] = 0;
2245	if (!stricmp(checkText, s)) {
2246	if (WinQueryWindowPos(hwndChild, &swp)) {
2247	if (swp.fl & (SWP_MINIMIZE \| SWP_HIDE))
2248	WinSetWindowPos(hwndChild,
2249	HWND_TOP,
2250	0, 0, 0, 0, SWP_RESTORE \| SWP_ZORDER);
2251	}
2252	WinSetActiveWindow(HWND_DESKTOP, hwndChild);
2253	ret = TRUE;
2254	break;
2255	}
2256	}
2257	}
2258	WinEndEnumWindows(henum);
2259	}
2260	}
2261	}
2262	else if (cmd >= IDM_SWITCHSTART && cmd < IDM_SWITCHSTART + 499) {
2263	if (cmd - IDM_SWITCHSTART < numswitches) {
2264	WinSwitchToProgram(switches[cmd - IDM_SWITCHSTART]);
2265	ret = TRUE;
2266	}
2267	}
2268
2269	return ret;
2270	}
2271
2272	#pragma alloc_text(MAINWND5,SetSysMenu)
2273	#pragma alloc_text(MISC1,BoxWindow,PaintRecessedWindow,PostMsg,PaintSTextWindow,IsFm2Window)
2274	#pragma alloc_text(MISC1,FixSwitchList,FindDirCnr,CurrentRecord,SetShiftState,AddToListboxBottom)
2275	#pragma alloc_text(CNR_MISC1,AdjustCnrColVis,AdjustCnrColsForFSType)
2276	#pragma alloc_text(CNR_MISC1,AdjustCnrColsForPref,SetCnrCols)
2277	#pragma alloc_text(CNR_MISC2,CnrDirectEdit,OpenEdit)
2278	#pragma alloc_text(MISC2,SetMenuCheck,disable_menuitem,SetSortChecks)
2279	#pragma alloc_text(MISC2,SetDetailsSwitches,SetViewMenu)
2280	#pragma alloc_text(MISC3,SetupCommandMenu,AdjustDetailsSwitches)
2281	#pragma alloc_text(MISC3,ViewHelp,GetCmdSpec)
2282	#pragma alloc_text(MISC3,ExecFile,SetConditionalCascade,LoadDetailsSwitches)
2283	#pragma alloc_text(MISC4,PortholeInit,CheckMenu,Broadcast,SetupWinList,SwitchCommand)
2284	#pragma alloc_text(MISC6,DrawTargetEmphasis,EmphasizeButton)
2285	#pragma alloc_text(MISC_LIBPATH,LoadLibPath)
2286	#pragma alloc_text(MISC_SAY,SayView,SaySort,SayFilter)
2287

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

Download in other formats: