Context Navigation

source: trunk/dll/misc.c@ 940

Visit:

Last change on this file since 940 was 940, checked in by Gregg Young, 18 years ago
Minor cleanup, added comments and History for recent changes
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 66.4 KB

Line
1
2	/***********************************************************************
3
4	$Id: misc.c 940 2008-01-21 21:55:00Z 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
723	retlen = WinQueryWindowText(hwndMLE, sizeof(szSubject), szSubject);
724	szSubject[retlen + 1] = 0;
725	bstrip(szSubject);
726	if (pci->pszSubject != NullStr)
727	pci->pszSubject = xrealloc(pci->pszSubject, retlen + 1, pszSrcFile, __LINE__);
728	else
729	pci->pszSubject = xstrdup(szSubject, pszSrcFile, __LINE__);
730	len = strlen(szSubject);
731	if (len)
732	ealen = sizeof(FEA2LIST) + 9 + len + 4;
733	else
734	ealen = sizeof(FEALIST) + 9;
735	rc = DosAllocMem((PPVOID) & pfealist, ealen + 64,
736	OBJ_TILE \| PAG_COMMIT \| PAG_READ \| PAG_WRITE);
737	if (rc)
738	Dos_Error(MB_CANCEL, rc, HWND_DESKTOP, pszSrcFile,
739	__LINE__, GetPString(IDS_OUTOFMEMORY));
740	else {
741	memset(pfealist, 0, ealen + 1);
742	pfealist->cbList = ealen;
743	pfealist->list[0].oNextEntryOffset = 0;
744	pfealist->list[0].fEA = 0;
745	pfealist->list[0].cbName = 8;
746	strcpy(pfealist->list[0].szName, SUBJECT);
747	if (len) {
748	eaval = pfealist->list[0].szName + 9;
749	(USHORT ) eaval = (USHORT) EAT_ASCII;
750	eaval += sizeof(USHORT);
751	(USHORT ) eaval = (USHORT) len;
752	eaval += sizeof(USHORT);
753	memcpy(eaval, szSubject, len);
754	pfealist->list[0].cbValue = len + (sizeof(USHORT) * 2);
755	}
756	else
757	pfealist->list[0].cbValue = 0;
758	eaop.fpGEA2List = (PGEA2LIST) 0;
759	eaop.fpFEA2List = pfealist;
760	eaop.oError = 0;
761	rc = xDosSetPathInfo(pci->pszFileName, FIL_QUERYEASIZE,
762	&eaop, sizeof(eaop), DSPI_WRTTHRU);
763	DosFreeMem(pfealist);
764	if (rc)
765	return FALSE;
766	}
767	return (MRESULT) TRUE;
768	}
769	else if (pfi && pfi->offStruct == FIELDOFFSET(CNRITEM, pszLongName)) {
770
771	CHAR longname[CCHMAXPATHCOMP];
772	LONG retlen;
773
774	*longname = 0;
775	retlen = WinQueryWindowText(hwndMLE, sizeof(longname), longname);
776	longname[retlen + 1] = 0;
777	chop_at_crnl(longname);
778	bstrip(longname);
779	WinSetWindowText(hwndMLE, longname);
780	if (pci->pszLongName != NullStr)
781	pci->pszLongName = xrealloc(pci->pszLongName, retlen + 1, pszSrcFile, __LINE__);
782	else
783	pci->pszLongName = xstrdup(longname, pszSrcFile, __LINE__);
784	return (MRESULT) WriteLongName(pci->pszFileName, longname);
785	}
786	else {
787	WinQueryWindowText(hwndMLE, sizeof(szData), szData);
788	if (strchr(szData, '?') \|\|
789	strchr(szData, '*') \|\| IsRoot(pci->pszFileName))
790	return (MRESULT) FALSE;
791	/* If the text changed, rename the file system object. */
792	chop_at_crnl(szData);
793	bstrip(szData);
794	if (!IsFullName(szData))
795	Runtime_Error(pszSrcFile, __LINE__, "bad name");
796	else {
797	if (DosQueryPathInfo(szData,
798	FIL_QUERYFULLNAME,
799	testname, sizeof(testname)))
800	return FALSE;
801	if (DosQueryPathInfo(pci->pszFileName,
802	FIL_QUERYFULLNAME,
803	szData,
804	sizeof(szData)))
805	{
806	pci->pszFileName = xrealloc(pci->pszFileName, sizeof(szData), pszSrcFile, __LINE__);
807	strcpy(szData, pci->pszFileName);
808	}
809	WinSetWindowText(hwndMLE, szData);
810	if (strcmp(szData, testname)) {
811	if (stricmp(szData, testname) && IsFile(testname) != -1) {
812	DosBeep(50, 100); /* exists; disallow */
813	return (MRESULT) FALSE;
814	}
815	if (docopyf(MOVE, szData, "%s", testname))
816	Runtime_Error(pszSrcFile, __LINE__, "docopyf");
817	else {
818	CHAR *filename;
819
820	filename = xstrdup(testname, pszSrcFile, __LINE__);
821	if (filename) {
822	if (!PostMsg(hwnd,
823	UM_FIXEDITNAME, MPVOID, MPFROMP(filename)))
824	free(filename);
825	}
826	if (stricmp(testname, pci->pszFileName)) {
827	PostMsg(hwnd, UM_FIXEDITNAME, MPFROMLONG(-1), MPFROMP(pci));
828	filename = xstrdup(pci->pszFileName, pszSrcFile, __LINE__);
829	if (filename) {
830	if (!PostMsg(hwnd,
831	UM_FIXEDITNAME, MPVOID, MPFROMP(filename)))
832	free(filename);
833	}
834	}
835	}
836	}
837	}
838	}
839	}
840	}
841	return FALSE;
842
843	case CN_ENDEDIT:
844	if (mp2) {
845	PFIELDINFO pfi = ((PCNREDITDATA) mp2)->pFieldInfo;
846	PCNRITEM pci = (PCNRITEM) ((PCNREDITDATA) mp2)->pRecord;
847
848	if (pci && (INT) pci != -1 && !IsRoot(pci->pszFileName)) {
849	WinSendMsg(hwnd,
850	CM_INVALIDATERECORD,
851	MPFROMP(&pci),
852	MPFROM2SHORT(1, CMA_ERASE \| CMA_TEXTCHANGED));
853	if (pfi && pfi->offStruct == FIELDOFFSET(CNRITEM, pszDisplayName))
854	PostMsg(hwnd, UM_SORTRECORD, MPVOID, MPVOID);
855	}
856	else {
857	USHORT cmd = 0;
858
859	if (!pfi \|\| pfi->offStruct == FIELDOFFSET(CNRITEM, pszDisplayName))
860	cmd = IDM_SORTSMARTNAME;
861	else if (pfi->offStruct == FIELDOFFSET(CNRITEM, cbFile))
862	cmd = IDM_SORTSIZE;
863	else if (pfi->offStruct == FIELDOFFSET(CNRITEM, easize))
864	cmd = IDM_SORTEASIZE;
865	else if (pfi->offStruct == FIELDOFFSET(CNRITEM, date))
866	cmd = IDM_SORTLWDATE;
867	else if (pfi->offStruct == FIELDOFFSET(CNRITEM, time))
868	cmd = IDM_SORTLWDATE;
869	else if (pfi->offStruct == FIELDOFFSET(CNRITEM, ladate))
870	cmd = IDM_SORTLADATE;
871	else if (pfi->offStruct == FIELDOFFSET(CNRITEM, latime))
872	cmd = IDM_SORTLADATE;
873	else if (pfi->offStruct == FIELDOFFSET(CNRITEM, crdate))
874	cmd = IDM_SORTCRDATE;
875	else if (pfi->offStruct == FIELDOFFSET(CNRITEM, crtime))
876	cmd = IDM_SORTCRDATE;
877	if (cmd)
878	PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(cmd, 0), MPVOID);
879	}
880	}
881	break;
882	}
883	return (MRESULT) - 1;
884	}
885
886	BOOL SetMenuCheck(HWND hwndMenu, USHORT id, BOOL * bool, BOOL toggle,
887	CHAR * savename)
888	{
889	if (toggle) {
890	bool = bool ? FALSE : TRUE;
891	if (savename && *savename)
892	PrfWriteProfileData(fmprof, appname, savename, bool, sizeof(BOOL));
893	}
894	WinSendMsg(hwndMenu, MM_SETITEMATTR,
895	MPFROM2SHORT(id, 1),
896	MPFROM2SHORT(MIA_CHECKED, (*bool ? MIA_CHECKED : 0)));
897	return *bool;
898	}
899
900	//== disable_menuitem() disable or enable_menuitem ==
901
902	VOID disable_menuitem(HWND hwndMenu, USHORT id, BOOL disable)
903	{
904	WinSendMsg(hwndMenu, MM_SETITEMATTR,
905	MPFROM2SHORT(id, TRUE),
906	MPFROM2SHORT(MIA_DISABLED, (disable ? MIA_DISABLED : 0)));
907	}
908
909	//== ViewHelp() invoke view.exe, return TRUE if OK ==
910
911	BOOL ViewHelp(CHAR * filename)
912	{
913	CHAR s[CCHMAXPATH + 81];
914	CHAR szQuotedFileName[CCHMAXPATH];
915	FILE *fp;
916	INT ret = -1;
917
918	fp = _fsopen(filename, "rb", SH_DENYNO);
919	if (fp) {
920	*s = 0;
921	fread(s, 1, 3, fp);
922	if (*s != 'H' \|\| s[1] != 'S' \|\| s[2] != 'P') {
923	fclose(fp);
924	return FALSE;
925	}
926	fclose(fp);
927	ret = runemf2(SEPARATE \| WINDOWED, HWND_DESKTOP, pszSrcFile, __LINE__,
928	NULL, NULL,
929	"VIEW.EXE \"%s\"",
930	BldQuotedFileName(szQuotedFileName, filename));
931	}
932
933	return (ret != -1);
934	}
935
936	//== ExecFile() run file, return 1 if OK 0 if skipped -1 if can't run ==
937
938	INT ExecFile(HWND hwnd, CHAR * filename)
939	{
940	EXECARGS ex;
941	CHAR cl[1001], path[CCHMAXPATH], *p;
942	APIRET ret;
943	static INT lastflags = 0;
944
945	strcpy(path, filename);
946	p = strrchr(path, '\\');
947	if (!p)
948	p = strrchr(path, ':');
949	if (p) {
950	if (*p == ':') {
951	p++;
952	*p = '\\';
953	p++;
954	}
955	*p = 0;
956	}
957	else
958	*path = 0;
959	*cl = 0;
960	BldQuotedFileName(cl, filename);
961	memset(&ex, 0, sizeof(ex));
962	ex.flags = lastflags;
963	ex.commandline = cl;
964	*ex.path = 0;
965	*ex.environment = 0;
966	ret = WinDlgBox(HWND_DESKTOP, hwnd, CmdLineDlgProc, FM3ModHandle,
967	EXEC_FRAME, &ex);
968	if (ret == 1) {
969	lastflags = ex.flags;
970	return runemf2(ex.flags, hwnd, pszSrcFile, __LINE__, path,
971	*ex.environment ? ex.environment : NULL,
972	"%s", cl) != -1;
973	}
974	else if (ret != 0)
975	return -1;
976	return 0;
977	}
978
979	VOID SetDetailsSwitches(HWND hwnd, DIRCNRDATA * dcd)
980	{
981	WinCheckMenuItem(hwnd, IDM_SHOWLNAMES,
982	dcd ? dcd->detailslongname : detailslongname);
983	WinCheckMenuItem(hwnd, IDM_SHOWSUBJECT,
984	dcd ? dcd->detailssubject : detailssubject);
985	WinCheckMenuItem(hwnd, IDM_SHOWEAS, dcd ? dcd->detailsea : detailsea);
986	WinCheckMenuItem(hwnd, IDM_SHOWSIZE,
987	dcd ? dcd->detailssize : detailssize);
988	WinCheckMenuItem(hwnd, IDM_SHOWICON,
989	dcd ? dcd->detailsicon : detailsicon);
990	WinCheckMenuItem(hwnd, IDM_SHOWLWDATE,
991	dcd ? dcd->detailslwdate : detailslwdate);
992	WinCheckMenuItem(hwnd, IDM_SHOWLWTIME,
993	dcd ? dcd->detailslwtime : detailslwtime);
994	WinCheckMenuItem(hwnd, IDM_SHOWLADATE,
995	dcd ? dcd->detailsladate : detailsladate);
996	WinCheckMenuItem(hwnd, IDM_SHOWLATIME,
997	dcd ? dcd->detailslatime : detailslatime);
998	WinCheckMenuItem(hwnd, IDM_SHOWCRDATE,
999	dcd ? dcd->detailscrdate : detailscrdate);
1000	WinCheckMenuItem(hwnd, IDM_SHOWCRTIME,
1001	dcd ? dcd->detailscrtime : detailscrtime);
1002	WinCheckMenuItem(hwnd, IDM_SHOWATTR,
1003	dcd ? dcd->detailsattr : detailsattr);
1004	}
1005
1006	VOID AdjustDetailsSwitches(HWND hwnd, HWND hwndMenu, USHORT cmd,
1007	CHAR * directory, CHAR * keyroot,
1008	DIRCNRDATA * dcd, BOOL compare)
1009	{
1010	// JBS CHAR s[CCHMAXPATH], *eos = s;
1011	BOOL *bool = NULL;
1012
1013	// JBS *s = 0;
1014	// JBS if (keyroot) {
1015	// JBS strcpy(s, keyroot);
1016	// JBS strcat(s, ".");
1017	// JBS eos = &s[strlen(s)];
1018	// JBS }
1019	switch (cmd) {
1020	case IDM_SHOWLNAMES:
1021	bool = dcd ? &dcd->detailslongname : &detailslongname;
1022	// JBS strcpy(eos, "DetailsLongname");
1023	break;
1024	case IDM_SHOWSUBJECT:
1025	bool = dcd ? &dcd->detailssubject : &detailssubject;
1026	// JBS strcpy(eos, "DetailsSubject");
1027	break;
1028	case IDM_SHOWEAS:
1029	bool = dcd ? &dcd->detailsea : &detailsea;
1030	// JBS strcpy(eos, "DetailsEA");
1031	break;
1032	case IDM_SHOWSIZE:
1033	bool = dcd ? &dcd->detailssize : &detailssize;
1034	// JBS strcpy(eos, "DetailsSize");
1035	break;
1036	case IDM_SHOWICON:
1037	bool = dcd ? &dcd->detailsicon : &detailsicon;
1038	// JBS strcpy(eos, "DetailsIcon");
1039	break;
1040	case IDM_SHOWLWDATE:
1041	bool = dcd ? &dcd->detailslwdate : &detailslwdate;
1042	// JBS strcpy(eos, "DetailsLWDate");
1043	break;
1044	case IDM_SHOWLWTIME:
1045	bool = dcd ? &dcd->detailslwtime : &detailslwtime;
1046	// JBS strcpy(eos, "DetailsLWTime");
1047	break;
1048	case IDM_SHOWLADATE:
1049	bool = dcd ? &dcd->detailsladate : &detailsladate;
1050	// JBS strcpy(eos, "DetailsLADate");
1051	break;
1052	case IDM_SHOWLATIME:
1053	bool = dcd ? &dcd->detailslatime : &detailslatime;
1054	// JBS strcpy(eos, "DetailsLATime");
1055	break;
1056	case IDM_SHOWCRDATE:
1057	bool = dcd ? &dcd->detailscrdate : &detailscrdate;
1058	// JBS strcpy(eos, "DetailsCRDate");
1059	break;
1060	case IDM_SHOWCRTIME:
1061	bool = dcd ? &dcd->detailscrtime : &detailscrtime;
1062	// JBS strcpy(eos, "DetailsCRTime");
1063	break;
1064	case IDM_SHOWATTR:
1065	bool = dcd ? &dcd->detailsattr : &detailsattr;
1066	// JBS strcpy(eos, "DetailsAttr");
1067	break;
1068	default:
1069	if (hwndMenu)
1070	SetDetailsSwitches(hwndMenu, dcd);
1071	return;
1072	}
1073	if (bool)
1074	bool = bool ? FALSE : TRUE;
1075	// JBS if (*s && bool)
1076	// JBS PrfWriteProfileData(fmprof, appname, s, bool, sizeof(BOOL));
1077	if (hwnd)
1078	AdjustCnrColsForPref(hwnd, directory, dcd, compare);
1079	if (hwndMenu)
1080	SetDetailsSwitches(hwndMenu, dcd);
1081	}
1082
1083	/**
1084	* Set default menu item to invoke for top level conditional cascade menu
1085	* @param def is default menu id (i.e. IDM_...)
1086	*/
1087
1088	VOID SetConditionalCascade(HWND hwndMenu, USHORT id, USHORT def)
1089	{
1090	MENUITEM mi;
1091
1092	mi.iPosition = MIT_END;
1093	mi.hItem = 0;
1094	mi.hwndSubMenu = (HWND)0;
1095	mi.afAttribute = 0;
1096	mi.afStyle = MIS_TEXT;
1097	if (WinSendMsg(hwndMenu,
1098	MM_QUERYITEM,
1099	MPFROM2SHORT(id, TRUE),
1100	MPFROMP(&mi)))
1101	{
1102	WinSetWindowBits(mi.hwndSubMenu, QWL_STYLE, MS_CONDITIONALCASCADE,
1103	MS_CONDITIONALCASCADE);
1104	WinSendMsg(mi.hwndSubMenu, MM_SETDEFAULTITEMID, MPFROMSHORT(def), MPVOID);
1105	WinCheckMenuItem(mi.hwndSubMenu, def, TRUE);
1106	}
1107	}
1108
1109	VOID SetSortChecks(HWND hwndMenu, INT sortflags)
1110	{
1111	WinCheckMenuItem(hwndMenu, IDM_SORTNONE, FALSE);
1112	WinCheckMenuItem(hwndMenu, IDM_SORTFIRST, FALSE);
1113	WinCheckMenuItem(hwndMenu, IDM_SORTLAST, FALSE);
1114	WinCheckMenuItem(hwndMenu, IDM_SORTSIZE, FALSE);
1115	WinCheckMenuItem(hwndMenu, IDM_SORTEASIZE, FALSE);
1116	WinCheckMenuItem(hwndMenu, IDM_SORTLWDATE, FALSE);
1117	WinCheckMenuItem(hwndMenu, IDM_SORTLADATE, FALSE);
1118	WinCheckMenuItem(hwndMenu, IDM_SORTCRDATE, FALSE);
1119	WinCheckMenuItem(hwndMenu, IDM_SORTFILENAME, FALSE);
1120	WinCheckMenuItem(hwndMenu, IDM_SORTNAME, FALSE);
1121	WinCheckMenuItem(hwndMenu, IDM_SORTSUBJECT, FALSE);
1122	WinCheckMenuItem(hwndMenu, IDM_SORTDIRSFIRST, FALSE);
1123	WinCheckMenuItem(hwndMenu, IDM_SORTDIRSLAST, FALSE);
1124	WinCheckMenuItem(hwndMenu, IDM_SORTREVERSE, FALSE);
1125	if (sortflags & SORT_FIRSTEXTENSION)
1126	WinCheckMenuItem(hwndMenu, IDM_SORTFIRST, TRUE);
1127	else if (sortflags & SORT_LASTEXTENSION)
1128	WinCheckMenuItem(hwndMenu, IDM_SORTLAST, TRUE);
1129	else if (sortflags & SORT_SIZE)
1130	WinCheckMenuItem(hwndMenu, IDM_SORTSIZE, TRUE);
1131	else if (sortflags & SORT_EASIZE)
1132	WinCheckMenuItem(hwndMenu, IDM_SORTEASIZE, TRUE);
1133	else if (sortflags & SORT_LWDATE)
1134	WinCheckMenuItem(hwndMenu, IDM_SORTLWDATE, TRUE);
1135	else if (sortflags & SORT_LADATE)
1136	WinCheckMenuItem(hwndMenu, IDM_SORTLADATE, TRUE);
1137	else if (sortflags & SORT_CRDATE)
1138	WinCheckMenuItem(hwndMenu, IDM_SORTCRDATE, TRUE);
1139	else if (sortflags & SORT_FILENAME)
1140	WinCheckMenuItem(hwndMenu, IDM_SORTFILENAME, TRUE);
1141	else if (sortflags & SORT_NOSORT)
1142	WinCheckMenuItem(hwndMenu, IDM_SORTNONE, TRUE);
1143	else if (sortflags & SORT_SUBJECT)
1144	WinCheckMenuItem(hwndMenu, IDM_SORTSUBJECT, TRUE);
1145	else
1146	WinCheckMenuItem(hwndMenu, IDM_SORTNAME, TRUE);
1147	if (sortflags & SORT_DIRSFIRST)
1148	WinCheckMenuItem(hwndMenu, IDM_SORTDIRSFIRST, TRUE);
1149	else if (sortflags & SORT_DIRSLAST)
1150	WinCheckMenuItem(hwndMenu, IDM_SORTDIRSLAST, TRUE);
1151	if (sortflags & SORT_REVERSE)
1152	WinCheckMenuItem(hwndMenu, IDM_SORTREVERSE, TRUE);
1153	}
1154
1155	VOID FcloseFile(FILE * fp)
1156	{
1157	/* for use by apps that don't use the DLLs runtime library */
1158	fclose(fp);
1159	}
1160
1161	VOID SetupCommandMenu(HWND hwndMenu, HWND hwndCnr)
1162	{
1163	MENUITEM mi, mit;
1164	INT x;
1165	SHORT numitems;
1166	LINKCMDS *info;
1167
1168	if (!cmdloaded)
1169	load_commands();
1170	mi.iPosition = MIT_END;
1171	mi.hwndSubMenu = (HWND) 0;
1172	mi.hItem = 0L;
1173	mi.afAttribute = 0;
1174	mi.afStyle = MIS_TEXT;
1175	memset(&mit, 0, sizeof(MENUITEM));
1176	if (WinQueryWindowUShort(hwndMenu, QWS_ID) == IDM_COMMANDSMENU)
1177	mit.hwndSubMenu = hwndMenu;
1178	else
1179	WinSendMsg(hwndMenu, MM_QUERYITEM,
1180	MPFROM2SHORT(IDM_COMMANDSMENU, TRUE), MPFROMP(&mit));
1181	if (mit.hwndSubMenu) {
1182	numitems = (SHORT) WinSendMsg(mit.hwndSubMenu, MM_QUERYITEMCOUNT,
1183	MPVOID, MPVOID);
1184	WinSendMsg(mit.hwndSubMenu, MM_DELETEITEM, MPFROMSHORT(-1), MPVOID);
1185	for (x = 0; x < numitems; x++)
1186	WinSendMsg(mit.hwndSubMenu, MM_DELETEITEM,
1187	MPFROMSHORT((SHORT) (x + IDM_COMMANDSTART)), MPVOID);
1188	if (hwndCnr && cmdhead) {
1189	x = 0;
1190	info = cmdhead;
1191	while (info) {
1192
1193	CHAR s[CCHMAXPATH + 24];
1194
1195	sprintf(s,
1196	"%s%s%s",
1197	info->title,
1198	x < 20 ? "\tCtrl + " : NullStr,
1199	x < 20 && x > 9 ? "Shift + " : NullStr);
1200	if (x < 20)
1201	sprintf(&s[strlen(s)], "%d",
1202	((x % 10) + 1) == 10 ? 0 : (x % 10) + 1);
1203	mi.id = IDM_COMMANDSTART + x;
1204	mi.afAttribute = (info->flags & ONCE ? MIA_CHECKED : 0) \|
1205	(info->flags & PROMPT ? MIA_FRAMED : 0);
1206	mi.afStyle = MIS_TEXT;
1207	if (!(x % 24) && x && info->next)
1208	mi.afStyle \|= MIS_BREAK;
1209	WinSendMsg(mit.hwndSubMenu, MM_INSERTITEM, MPFROMP(&mi), MPFROMP(s));
1210	x++;
1211	info = info->next;
1212	}
1213	}
1214	}
1215	}
1216
1217	VOID LoadDetailsSwitches(CHAR * keyroot, DIRCNRDATA * dcd)
1218	{
1219	ULONG size;
1220	CHAR s[CCHMAXPATH], *eos = s;
1221	BOOL *bool;
1222
1223	// JBS - No calls to LoadDetailsSwitches have a NULL keyroot.
1224	// *s = 0;
1225	// if (keyroot) {
1226	strcpy(s, keyroot);
1227	strcat(s, ".");
1228	eos = &s[strlen(s)];
1229	// }
1230	strcpy(eos, "DetailsLongname");
1231	if (dcd)
1232	bool = &dcd->detailslongname;
1233	else
1234	bool = &detailslongname;
1235	*bool = detailslongname;
1236	size = sizeof(BOOL);
1237	PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size);
1238	strcpy(eos, "DetailsSubject");
1239	if (dcd)
1240	bool = &dcd->detailssubject;
1241	else
1242	bool = &detailssubject;
1243	*bool = detailssubject;
1244	size = sizeof(BOOL);
1245	PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size);
1246	strcpy(eos, "DetailsEA");
1247	if (dcd)
1248	bool = &dcd->detailsea;
1249	else
1250	bool = &detailsea;
1251	*bool = detailsea;
1252	size = sizeof(BOOL);
1253	PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size);
1254	strcpy(eos, "DetailsSize");
1255	if (dcd)
1256	bool = &dcd->detailssize;
1257	else
1258	bool = &detailssize;
1259	*bool = detailssize;
1260	size = sizeof(BOOL);
1261	PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size);
1262	strcpy(eos, "DetailsIcon");
1263	if (dcd)
1264	bool = &dcd->detailsicon;
1265	else
1266	bool = &detailsicon;
1267	*bool = detailsicon;
1268	size = sizeof(BOOL);
1269	PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size);
1270	strcpy(eos, "DetailsAttr");
1271	if (dcd)
1272	bool = &dcd->detailsattr;
1273	else
1274	bool = &detailsattr;
1275	*bool = detailsattr;
1276	size = sizeof(BOOL);
1277	PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size);
1278	strcpy(eos, "DetailsCRDate");
1279	if (dcd)
1280	bool = &dcd->detailscrdate;
1281	else
1282	bool = &detailscrdate;
1283	*bool = detailscrdate;
1284	size = sizeof(BOOL);
1285	PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size);
1286	strcpy(eos, "DetailsCRTime");
1287	if (dcd)
1288	bool = &dcd->detailscrtime;
1289	else
1290	bool = &detailscrtime;
1291	*bool = detailscrtime;
1292	size = sizeof(BOOL);
1293	PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size);
1294	strcpy(eos, "DetailsLWDate");
1295	if (dcd)
1296	bool = &dcd->detailslwdate;
1297	else
1298	bool = &detailslwdate;
1299	*bool = detailslwdate;
1300	size = sizeof(BOOL);
1301	PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size);
1302	strcpy(eos, "DetailsLWTime");
1303	if (dcd)
1304	bool = &dcd->detailslwtime;
1305	else
1306	bool = &detailslwtime;
1307	*bool = detailslwtime;
1308	size = sizeof(BOOL);
1309	PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size);
1310	strcpy(eos, "DetailsLADate");
1311	if (dcd)
1312	bool = &dcd->detailsladate;
1313	else
1314	bool = &detailsladate;
1315	*bool = detailsladate;
1316	size = sizeof(BOOL);
1317	PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size);
1318	strcpy(eos, "DetailsLATime");
1319	if (dcd)
1320	bool = &dcd->detailslatime;
1321	else
1322	bool = &detailslatime;
1323	*bool = detailslatime;
1324	size = sizeof(BOOL);
1325	PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size);
1326	strcpy(eos, "SubjectInLeftPane");
1327	if (dcd)
1328	bool = &dcd->fSubjectInLeftPane;
1329	else
1330	bool = &fSubjectInLeftPane;
1331	*bool = fSubjectInLeftPane;
1332	size = sizeof(BOOL);
1333	PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size);
1334	strcpy(eos, "SubjectLengthMax");
1335	if (dcd)
1336	bool = &dcd->fSubjectLengthMax;
1337	else
1338	bool = &fSubjectLengthMax;
1339	*bool = fSubjectLengthMax;
1340	size = sizeof(BOOL);
1341	PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size);
1342	if (dcd) {
1343	if (dcd->fSubjectLengthMax)
1344	dcd->SubjectDisplayWidth = 0;
1345	else {
1346	strcpy(eos, "SubjectDisplayWidth");
1347	bool = &dcd->SubjectDisplayWidth;
1348	*bool = SubjectDisplayWidth;
1349	size = sizeof(ULONG);
1350	PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size);
1351	if (dcd->SubjectDisplayWidth < 50)
1352	dcd->SubjectDisplayWidth = 0;
1353	else if (dcd->SubjectDisplayWidth > 1000)
1354	dcd->SubjectDisplayWidth = 1000;
1355	}
1356	}
1357	else {
1358	if (fSubjectLengthMax)
1359	SubjectDisplayWidth = 0;
1360	else {
1361	strcpy(eos, "SubjectDisplayWidth");
1362	bool = &SubjectDisplayWidth;
1363	*bool = SubjectDisplayWidth;
1364	size = sizeof(ULONG);
1365	PrfQueryProfileData(fmprof, appname, s, (PVOID) bool, &size);
1366	if (SubjectDisplayWidth < 50)
1367	SubjectDisplayWidth = 0;
1368	else if (SubjectDisplayWidth > 1000)
1369	SubjectDisplayWidth = 1000;
1370	}
1371	}
1372	}
1373
1374	HWND FindDirCnr(HWND hwndParent)
1375	{
1376	HWND found, hwndDir = (HWND) 0;
1377	HENUM henum;
1378
1379	henum = WinBeginEnumWindows(hwndParent);
1380	while ((found = WinGetNextWindow(henum)) != NULLHANDLE) {
1381	hwndDir = WinWindowFromID(found, FID_CLIENT);
1382	if (hwndDir) {
1383	hwndDir = WinWindowFromID(hwndDir, DIR_CNR);
1384	if (hwndDir)
1385	break;
1386	hwndDir = (HWND) 0;
1387	}
1388	}
1389	WinEndEnumWindows(henum);
1390
1391	return hwndDir;
1392	}
1393
1394	VOID HeapThread(VOID * dummy)
1395	{
1396	ULONG postcount;
1397	APIRET rc;
1398
1399	rc = DosCreateEventSem(NULL, &CompactSem, 0L, FALSE);
1400	if (rc)
1401	Dos_Error(MB_CANCEL, rc, HWND_DESKTOP, pszSrcFile, __LINE__,
1402	"DosCreateEventSem");
1403	else {
1404	priority_normal();
1405	for (;;) {
1406	if (DosWaitEventSem(CompactSem, SEM_INDEFINITE_WAIT))
1407	break;
1408	_heapmin();
1409	DosResetEventSem(CompactSem, &postcount);
1410	}
1411	}
1412	}
1413
1414	VOID FixSwitchList(HWND hwnd, CHAR * text)
1415	{
1416	HSWITCH hswitch;
1417	SWCNTRL swctl;
1418
1419	hswitch = WinQuerySwitchHandle(hwnd, 0);
1420	if (hswitch) {
1421	if (!WinQuerySwitchEntry(hswitch, &swctl)) {
1422	strcpy(swctl.szSwtitle, "FM/2");
1423	WinChangeSwitchEntry(hswitch, &swctl);
1424	}
1425	}
1426	}
1427
1428	VOID QuickPopup(HWND hwnd, DIRCNRDATA * dcd, HWND hwndMenu, USHORT id)
1429	{
1430	dcd->hwndLastMenu = hwndMenu;
1431	if (dcd->hwndLastMenu && !dcd->cnremphasized) {
1432	WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPVOID,
1433	MPFROM2SHORT(TRUE, CRA_SOURCE));
1434	dcd->cnremphasized = TRUE;
1435	}
1436	if (dcd->flWindowAttr & CV_MINI)
1437	WinCheckMenuItem(dcd->hwndLastMenu, IDM_MINIICONS, TRUE);
1438	if (!WinPopupMenu(hwnd, hwnd, dcd->hwndLastMenu,
1439	8, 8, 0,
1440	PU_HCONSTRAIN \| PU_VCONSTRAIN \|
1441	PU_KEYBOARD \| PU_MOUSEBUTTON1)) {
1442	if (dcd->cnremphasized) {
1443	WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPVOID,
1444	MPFROM2SHORT(FALSE, CRA_SOURCE));
1445	dcd->cnremphasized = FALSE;
1446	}
1447	}
1448	else
1449	WinSendMsg(dcd->hwndLastMenu, MM_SELECTITEM,
1450	MPFROM2SHORT(id, TRUE), MPFROM2SHORT(0, FALSE));
1451	}
1452
1453	PMINIRECORDCORE CurrentRecord(HWND hwndCnr)
1454	{
1455	SHORT attrib = fSelectedAlways ? CRA_SELECTED : CRA_CURSORED;
1456	PMINIRECORDCORE pmi;
1457
1458	for (;;) {
1459	pmi = (PMINIRECORDCORE) WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS,
1460	MPFROMLONG(CMA_FIRST),
1461	MPFROMSHORT(attrib));
1462	if ((!pmi \|\| (INT) pmi == -1) && attrib == CRA_SELECTED) /* punt */
1463	attrib = CRA_CURSORED;
1464	else
1465	break;
1466	}
1467	return ((INT)pmi == -1) ? NULL : pmi;
1468	}
1469
1470	BOOL PostMsg(HWND h, ULONG msg, MPARAM mp1, MPARAM mp2)
1471	{
1472	BOOL rc = WinPostMsg(h, msg, mp1, mp2);
1473
1474	if (!rc) {
1475
1476	// If window owned by some other process or some other thread?
1477	if (!IsFm2Window(h, 1)) {
1478	QMSG qmsg;
1479	for (;;) {
1480	DosSleep(1);
1481	rc = WinPostMsg(h, msg, mp1, mp2);
1482	if (rc)
1483	break; // OK
1484	if (!WinIsWindow((HAB) 0, h))
1485	break; // Window gone
1486	if (WinPeekMsg((HAB) 0, &qmsg, (HWND) 0, 0, 0, PM_NOREMOVE))
1487	break; // Queue has message(s)
1488	} // for
1489	}
1490	}
1491	return rc;
1492	}
1493
1494	VOID OpenEdit(HWND hwnd)
1495	{
1496	CNREDITDATA ced;
1497	PCNRITEM pci;
1498	PFIELDINFO pfi;
1499
1500	pci = (PCNRITEM) WinSendMsg(hwnd,
1501	CM_QUERYRECORDEMPHASIS,
1502	MPFROMLONG(CMA_FIRST),
1503	MPFROMSHORT(CRA_CURSORED));
1504	if (pci && (INT) pci != -1) {
1505	memset(&ced, 0, sizeof(ced));
1506	ced.cb = sizeof(ced);
1507	ced.hwndCnr = hwnd;
1508	ced.id = WinQueryWindowUShort(hwnd, QWS_ID);
1509	ced.pRecord = (PRECORDCORE) pci;
1510	pfi = (PFIELDINFO) WinSendMsg(hwnd,
1511	CM_QUERYDETAILFIELDINFO,
1512	MPVOID, MPFROMSHORT(CMA_FIRST));
1513	if (!pfi)
1514	WinSendMsg(hwnd, CM_OPENEDIT, MPFROMP(&ced), MPVOID);
1515	else {
1516	while (pfi && (INT) pfi != -1 &&
1517	pfi->offStruct != FIELDOFFSET(CNRITEM, pszFileName))
1518	pfi = (PFIELDINFO) WinSendMsg(hwnd,
1519	CM_QUERYDETAILFIELDINFO,
1520	MPFROMP(pfi), MPFROMSHORT(CMA_NEXT));
1521	if (pfi && (INT) pfi != -1) {
1522	ced.pFieldInfo = pfi;
1523	{
1524	CNRINFO cnri;
1525
1526	memset(&cnri, 0, sizeof(CNRINFO));
1527	cnri.cb = sizeof(CNRINFO);
1528	WinSendMsg(hwnd,
1529	CM_QUERYCNRINFO,
1530	MPFROMP(&cnri), MPFROMLONG(sizeof(CNRINFO)));
1531	if (cnri.flWindowAttr & CV_DETAIL)
1532	ced.id = CID_LEFTDVWND;
1533	}
1534	WinSendMsg(hwnd, CM_OPENEDIT, MPFROMP(&ced), MPVOID);
1535	}
1536	}
1537	}
1538	}
1539
1540	#ifdef NEVER
1541	VOID QuickView(HWND hwnd, CHAR * filename)
1542	{
1543	if (filename && IsFile(filename) == 1) {
1544	if (TestBinary(filename) && *binview) {
1545
1546	CHAR *list[2];
1547
1548	list[0] = filename;
1549	list[1] = NULL;
1550	ExecOnList(hwnd, binview, WINDOWED \| SEPARATE, NULL, list, NULL,
1551	pszSrcFile, __LINE__);
1552	return;
1553	}
1554	else if (*viewer) {
1555
1556	CHAR *list[2];
1557
1558	list[0] = filename;
1559	list[1] = NULL;
1560	ExecOnList(hwnd, viewer,
1561	WINDOWED \| SEPARATE \| (fViewChild ? CHILD : 0),
1562	NULL, list, NULL, pszSrcFile, __LINE__);
1563	return;
1564	}
1565	StartMLEEditor(HWND_DESKTOP, 5, filename, (HWND) 0);
1566	}
1567	}
1568
1569	VOID QuickEdit(HWND hwnd, CHAR * filename)
1570	{
1571	if (filename && IsFile(filename) == 1) {
1572	if (TestBinary(filename) && *bined) {
1573
1574	CHAR *list[2];
1575
1576	list[0] = filename;
1577	list[1] = NULL;
1578	ExecOnList(hwnd, bined, WINDOWED \| SEPARATE, NULL, list, NULL,
1579	pszSrcFile, __LINE__);
1580	return;
1581	}
1582	else if (*editor) {
1583
1584	CHAR *list[2];
1585
1586	list[0] = filename;
1587	list[1] = NULL;
1588	ExecOnList(hwnd, editor, WINDOWED \| SEPARATE, NULL, list, NULL,
1589	pszSrcFile, __LINE__);
1590	return;
1591	}
1592	StartMLEEditor(HWND_DESKTOP, 4, filename, (HWND) 0);
1593	}
1594	}
1595	#endif
1596
1597	VOID PortholeInit(HWND hwndNew, MPARAM mp1, MPARAM mp2)
1598	{
1599	static HWND DefMenu = (HWND) 0;
1600	HWND hwndMenu = (HWND) mp2;
1601
1602	{
1603	ULONG style;
1604
1605	style = WinQueryWindowULong(hwndMenu, QWL_STYLE);
1606	if (!(style & MS_ACTIONBAR))
1607	return;
1608	}
1609
1610	switch (SHORT1FROMMP(mp1)) {
1611	case 0:
1612	{
1613	HWND hwndNow;
1614	MENUITEM mi;
1615	ULONG ulStyle;
1616
1617	memset(&mi, 0, sizeof(mi));
1618	mi.iPosition = MIT_END;
1619	mi.afStyle = MIS_TEXT;
1620	WinSendMsg(hwndMenu, MM_QUERYITEM,
1621	MPFROM2SHORT(IDM_FILESMENU, TRUE), MPFROMP(&mi));
1622	if (!DefMenu)
1623	DefMenu = WinLoadMenu(HWND_DESKTOP, FM3ModHandle, DEFMENU);
1624	hwndNow = mi.hwndSubMenu;
1625	mi.hwndSubMenu = hwndNew;
1626	if (!mi.hwndSubMenu)
1627	mi.hwndSubMenu = DefMenu;
1628	WinSetParent(hwndNow, WinQueryObjectWindow(HWND_DESKTOP), FALSE);
1629	WinSetOwner(hwndNow, WinQueryObjectWindow(HWND_DESKTOP));
1630	WinSetOwner(mi.hwndSubMenu, hwndMenu);
1631	WinSetParent(mi.hwndSubMenu, hwndMenu, FALSE);
1632	WinSetWindowUShort(mi.hwndSubMenu, QWS_ID, IDM_FILESMENU);
1633	mi.afStyle = MIS_SUBMENU;
1634	ulStyle = WinQueryWindowULong(mi.hwndSubMenu, QWL_STYLE);
1635	ulStyle &= -WS_SAVEBITS;
1636	ulStyle \|= MS_POPUP \| WS_CLIPSIBLINGS \| WS_SAVEBITS;
1637	WinSetWindowULong(mi.hwndSubMenu, QWL_STYLE, ulStyle);
1638	WinSendMsg(hwndMenu, MM_SETITEM, MPFROM2SHORT(0, TRUE), MPFROMP(&mi));
1639	}
1640	break;
1641
1642	case 1:
1643	{
1644	HWND hwndNow;
1645	MENUITEM mi;
1646	ULONG ulStyle;
1647
1648	memset(&mi, 0, sizeof(mi));
1649	mi.iPosition = MIT_END;
1650	mi.afStyle = MIS_TEXT;
1651	WinSendMsg(hwndMenu, MM_QUERYITEM,
1652	MPFROM2SHORT(IDM_VIEWSMENU, TRUE), MPFROMP(&mi));
1653	if (!DefMenu)
1654	DefMenu = WinLoadMenu(HWND_DESKTOP, FM3ModHandle, DEFMENU);
1655	hwndNow = mi.hwndSubMenu;
1656	mi.hwndSubMenu = hwndNew;
1657	if (!mi.hwndSubMenu)
1658	mi.hwndSubMenu = DefMenu;
1659	WinSetParent(hwndNow, WinQueryObjectWindow(HWND_DESKTOP), FALSE);
1660	WinSetOwner(hwndNow, WinQueryObjectWindow(HWND_DESKTOP));
1661	WinSetOwner(mi.hwndSubMenu, hwndMenu);
1662	WinSetParent(mi.hwndSubMenu, hwndMenu, FALSE);
1663	WinSetWindowUShort(mi.hwndSubMenu, QWS_ID, IDM_VIEWSMENU);
1664	mi.afStyle = MIS_SUBMENU;
1665	ulStyle = WinQueryWindowULong(mi.hwndSubMenu, QWL_STYLE);
1666	ulStyle &= -WS_SAVEBITS;
1667	ulStyle \|= MS_POPUP \| WS_CLIPSIBLINGS \| WS_SAVEBITS;
1668	WinSetWindowULong(mi.hwndSubMenu, QWL_STYLE, ulStyle);
1669	WinSendMsg(hwndMenu, MM_SETITEM, MPFROM2SHORT(0, TRUE), MPFROMP(&mi));
1670	}
1671	break;
1672	}
1673	}
1674
1675	HWND CheckMenu(HWND hwnd, HWND * hwndMenu, USHORT id)
1676	{
1677	/* load and adjust menus as required */
1678	if (!hwndMenu \|\| !WinIsWindow((HAB) 0, hwndMenu)) {
1679	*hwndMenu = WinLoadMenu(HWND_DESKTOP, FM3ModHandle, id);
1680	CopyPresParams(*hwndMenu, hwnd);
1681	if (hwndMenu == &DirMenu) {
1682	WinSetWindowUShort(DirMenu, QWS_ID, IDM_FILESMENU);
1683	SetConditionalCascade(DirMenu, IDM_COMMANDSMENU, IDM_DOITYOURSELF);
1684	SetConditionalCascade(DirMenu, IDM_COPYMENU, IDM_COPY);
1685	SetConditionalCascade(DirMenu, IDM_MOVEMENU, IDM_MOVE);
1686	SetConditionalCascade(DirMenu, IDM_SAVESUBMENU, IDM_SAVETOCLIP);
1687	SetConditionalCascade(DirMenu, IDM_VIEWSUBMENU, IDM_INFO);
1688	SetConditionalCascade(DirMenu, IDM_EDITSUBMENU, IDM_ATTRS);
1689	SetConditionalCascade(DirMenu, IDM_DELETESUBMENU,
1690	fDefaultDeletePerm ? IDM_PERMDELETE : IDM_DELETE);
1691	SetConditionalCascade(DirMenu, IDM_MISCSUBMENU, IDM_SIZES);
1692	SetConditionalCascade(DirMenu, IDM_OPENSUBMENU, IDM_OPENWINDOW);
1693	if (fWorkPlace) {
1694	WinSendMsg(DirMenu, MM_DELETEITEM,
1695	MPFROM2SHORT(IDM_OPENSUBMENU, TRUE), MPVOID);
1696	WinSendMsg(DirMenu, MM_DELETEITEM,
1697	MPFROM2SHORT(IDM_OBJECTSUBMENU, TRUE), MPVOID);
1698	}
1699	}
1700	else if (hwndMenu == &TreeMenu) {
1701	WinSetWindowUShort(TreeMenu, QWS_ID, IDM_FILESMENU);
1702	SetConditionalCascade(TreeMenu, IDM_COMMANDSMENU, IDM_DOITYOURSELF);
1703	SetConditionalCascade(TreeMenu, IDM_SAVESUBMENU, IDM_SAVETOCLIP);
1704	SetConditionalCascade(TreeMenu, IDM_EDITSUBMENU, IDM_ATTRS);
1705	SetConditionalCascade(TreeMenu, IDM_EXPANDSUBMENU, IDM_EXPAND);
1706	SetConditionalCascade(TreeMenu, IDM_MISCSUBMENU, IDM_SIZES);
1707	SetConditionalCascade(TreeMenu, IDM_OPENSUBMENU, IDM_OPENWINDOW);
1708	if (fWorkPlace) {
1709	WinSendMsg(TreeMenu, MM_DELETEITEM,
1710	MPFROM2SHORT(IDM_OPENSUBMENU, TRUE), MPVOID);
1711	WinSendMsg(TreeMenu, MM_DELETEITEM,
1712	MPFROM2SHORT(IDM_OBJECTSUBMENU, TRUE), MPVOID);
1713	}
1714	}
1715	else if (hwndMenu == &ArcMenu) {
1716	WinSetWindowUShort(ArcMenu, QWS_ID, IDM_FILESMENU);
1717	SetConditionalCascade(ArcMenu, IDM_EXTRACTSUBMENU, IDM_EXTRACT);
1718	SetConditionalCascade(ArcMenu, IDM_EDITSUBMENU, IDM_EDIT);
1719	SetConditionalCascade(ArcMenu, IDM_VIEWSUBMENU, IDM_VIEW);
1720	if (fWorkPlace)
1721	WinSendMsg(ArcMenu, MM_DELETEITEM,
1722	MPFROM2SHORT(IDM_FOLDERAFTEREXTRACT, TRUE), MPVOID);
1723	}
1724	else if (hwndMenu == &FileMenu) {
1725	WinSetWindowUShort(FileMenu, QWS_ID, IDM_FILESMENU);
1726	SetConditionalCascade(FileMenu, IDM_COMMANDSMENU, IDM_DOITYOURSELF);
1727	SetConditionalCascade(FileMenu, IDM_COPYMENU, IDM_COPY);
1728	SetConditionalCascade(FileMenu, IDM_MOVEMENU, IDM_MOVE);
1729	SetConditionalCascade(FileMenu, IDM_SAVESUBMENU, IDM_SAVETOCLIP);
1730	SetConditionalCascade(FileMenu, IDM_VIEWSUBMENU, IDM_VIEW);
1731	SetConditionalCascade(FileMenu, IDM_EDITSUBMENU, IDM_EDIT);
1732	SetConditionalCascade(FileMenu, IDM_COLLECTMENU, IDM_COLLECT);
1733	SetConditionalCascade(FileMenu, IDM_DELETESUBMENU,
1734	fDefaultDeletePerm ? IDM_PERMDELETE : IDM_DELETE);
1735	SetConditionalCascade(FileMenu, IDM_OPENSUBMENU, IDM_OPENDEFAULT);
1736	SetConditionalCascade(FileMenu, IDM_OBJECTSUBMENU, IDM_SHADOW);
1737	if (fWorkPlace) {
1738	WinSendMsg(FileMenu, MM_DELETEITEM,
1739	MPFROM2SHORT(IDM_OPENSUBMENU, TRUE), MPVOID);
1740	WinSendMsg(FileMenu, MM_DELETEITEM,
1741	MPFROM2SHORT(IDM_OBJECTSUBMENU, TRUE), MPVOID);
1742	}
1743	}
1744	else if (hwndMenu == &DirCnrMenu) {
1745	WinSetWindowUShort(DirCnrMenu, QWS_ID, IDM_VIEWSMENU);
1746	SetConditionalCascade(DirCnrMenu, IDM_MISCSUBMENU, IDM_SIZES);
1747	SetConditionalCascade(DirCnrMenu, IDM_OPENSUBMENU, IDM_OPENSETTINGSME);
1748	if (fWorkPlace)
1749	WinSendMsg(DirCnrMenu, MM_DELETEITEM,
1750	MPFROM2SHORT(IDM_OPENSUBMENU, TRUE), MPVOID);
1751	}
1752	else if (hwndMenu == &TreeCnrMenu) {
1753	WinSetWindowUShort(TreeCnrMenu, QWS_ID, IDM_VIEWSMENU);
1754	SetConditionalCascade(TreeCnrMenu, IDM_PARTITIONSMENU, IDM_PARTITION);
1755	}
1756	else if (hwndMenu == &ArcCnrMenu) {
1757	WinSetWindowUShort(ArcCnrMenu, QWS_ID, IDM_VIEWSMENU);
1758	SetConditionalCascade(ArcCnrMenu, IDM_EXTRACTSUBMENU, IDM_ARCEXTRACT);
1759	if (fWorkPlace)
1760	WinSendMsg(ArcCnrMenu, MM_DELETEITEM,
1761	MPFROM2SHORT(IDM_FOLDERAFTEREXTRACT, TRUE), MPVOID);
1762	}
1763	else if (hwndMenu == &CollectorCnrMenu) {
1764	WinSetWindowUShort(CollectorCnrMenu, QWS_ID, IDM_VIEWSMENU);
1765	SetConditionalCascade(CollectorCnrMenu, IDM_COLLECTMENU,
1766	IDM_COLLECTFROMCLIP);
1767	}
1768	else if (hwndMenu == &CollectorFileMenu) {
1769	WinSetWindowUShort(CollectorFileMenu, QWS_ID, IDM_FILESMENU);
1770	SetConditionalCascade(CollectorFileMenu, IDM_COMMANDSMENU,
1771	IDM_DOITYOURSELF);
1772	SetConditionalCascade(CollectorFileMenu, IDM_COPYMENU, IDM_COPY);
1773	SetConditionalCascade(CollectorFileMenu, IDM_MOVEMENU, IDM_MOVE);
1774	SetConditionalCascade(CollectorFileMenu, IDM_SAVESUBMENU,
1775	IDM_SAVETOCLIP);
1776	SetConditionalCascade(CollectorFileMenu, IDM_VIEWSUBMENU, IDM_VIEW);
1777	SetConditionalCascade(CollectorFileMenu, IDM_EDITSUBMENU, IDM_EDIT);
1778	SetConditionalCascade(CollectorFileMenu, IDM_DELETESUBMENU,
1779	fDefaultDeletePerm ? IDM_PERMDELETE : IDM_DELETE);
1780	SetConditionalCascade(CollectorFileMenu, IDM_OPENSUBMENU,
1781	IDM_OPENDEFAULT);
1782	SetConditionalCascade(CollectorFileMenu, IDM_OBJECTSUBMENU, IDM_SHADOW);
1783	if (fWorkPlace) {
1784	WinSendMsg(CollectorFileMenu, MM_DELETEITEM,
1785	MPFROM2SHORT(IDM_OPENSUBMENU, TRUE), MPVOID);
1786	WinSendMsg(CollectorFileMenu, MM_DELETEITEM,
1787	MPFROM2SHORT(IDM_OBJECTSUBMENU, TRUE), MPVOID);
1788	}
1789	}
1790	else if (hwndMenu == &CollectorDirMenu) {
1791	WinSetWindowUShort(CollectorDirMenu, QWS_ID, IDM_FILESMENU);
1792	SetConditionalCascade(CollectorDirMenu, IDM_COMMANDSMENU,
1793	IDM_DOITYOURSELF);
1794	SetConditionalCascade(CollectorDirMenu, IDM_COPYMENU, IDM_COPY);
1795	SetConditionalCascade(CollectorDirMenu, IDM_MOVEMENU, IDM_MOVE);
1796	SetConditionalCascade(CollectorDirMenu, IDM_SAVESUBMENU,
1797	IDM_SAVETOCLIP);
1798	SetConditionalCascade(CollectorDirMenu, IDM_VIEWSUBMENU, IDM_INFO);
1799	SetConditionalCascade(CollectorDirMenu, IDM_EDITSUBMENU, IDM_ATTRS);
1800	SetConditionalCascade(CollectorDirMenu, IDM_DELETESUBMENU,
1801	fDefaultDeletePerm ? IDM_PERMDELETE : IDM_DELETE);
1802	SetConditionalCascade(CollectorDirMenu, IDM_MISCSUBMENU, IDM_SIZES);
1803	SetConditionalCascade(CollectorDirMenu, IDM_OPENSUBMENU,
1804	IDM_OPENWINDOW);
1805	if (fWorkPlace) {
1806	WinSendMsg(CollectorDirMenu, MM_DELETEITEM,
1807	MPFROM2SHORT(IDM_OPENSUBMENU, TRUE), MPVOID);
1808	WinSendMsg(CollectorDirMenu, MM_DELETEITEM,
1809	MPFROM2SHORT(IDM_OBJECTSUBMENU, TRUE), MPVOID);
1810	}
1811	}
1812	else if (hwndMenu == &MainPopupMenu) {
1813	WinSetWindowUShort(MainPopupMenu, QWS_ID, IDM_MAINPOPUP);
1814	SetConditionalCascade(MainPopupMenu, IDM_TOOLSUBMENU, IDM_TOOLBAR);
1815	SetConditionalCascade(MainPopupMenu, IDM_AUTOVIEWSUBMENU, IDM_AUTOVIEW);
1816	}
1817	}
1818	CopyPresParams(*hwndMenu, hwnd);
1819	return *hwndMenu;
1820	}
1821
1822	SHORT AddToListboxBottom(HWND hwnd, CHAR * str)
1823	{
1824	SHORT ln;
1825
1826	ln = (SHORT) WinSendMsg(hwnd, LM_INSERTITEM, MPFROM2SHORT(LIT_END, 0),
1827	MPFROMP(str));
1828	if (ln)
1829	WinSendMsg(hwnd, LM_SELECTITEM, MPFROM2SHORT(ln, 0), MPVOID);
1830	return ln;
1831	}
1832
1833	VOID SetSysMenu(HWND hwndSysMenu)
1834	{
1835	CHAR s[128], *p;
1836
1837	if (WinSendMsg(hwndSysMenu, MM_QUERYITEMTEXT,
1838	MPFROM2SHORT(SC_RESTORE, 128), MPFROMP(s))) {
1839	p = strchr(s, '\t');
1840	if (p) {
1841	p++;
1842	strcpy(p, "Ctrl+Alt+F5");
1843	WinSetMenuItemText(hwndSysMenu, SC_RESTORE, s);
1844	}
1845	}
1846	if (WinSendMsg(hwndSysMenu, MM_QUERYITEMTEXT,
1847	MPFROM2SHORT(SC_CLOSE, 128), MPFROMP(s))) {
1848	p = strchr(s, '\t');
1849	if (p) {
1850	p++;
1851	strcpy(p, "Ctrl+Alt+F4");
1852	WinSetMenuItemText(hwndSysMenu, SC_CLOSE, s);
1853	}
1854	}
1855	if (WinSendMsg(hwndSysMenu, MM_QUERYITEMTEXT,
1856	MPFROM2SHORT(SC_MOVE, 128), MPFROMP(s))) {
1857	p = strchr(s, '\t');
1858	if (p) {
1859	p++;
1860	strcpy(p, "Ctrl+Alt+F7");
1861	WinSetMenuItemText(hwndSysMenu, SC_MOVE, s);
1862	}
1863	}
1864	if (WinSendMsg(hwndSysMenu, MM_QUERYITEMTEXT,
1865	MPFROM2SHORT(SC_SIZE, 128), MPFROMP(s))) {
1866	p = strchr(s, '\t');
1867	if (p) {
1868	p++;
1869	strcpy(p, "Ctrl+Alt+F8");
1870	WinSetMenuItemText(hwndSysMenu, SC_SIZE, s);
1871	}
1872	}
1873	if (WinSendMsg(hwndSysMenu, MM_QUERYITEMTEXT,
1874	MPFROM2SHORT(SC_MINIMIZE, 128), MPFROMP(s))) {
1875	p = strchr(s, '\t');
1876	if (p) {
1877	p++;
1878	strcpy(p, "Ctrl+Alt+F9");
1879	WinSetMenuItemText(hwndSysMenu, SC_MINIMIZE, s);
1880	}
1881	}
1882	if (WinSendMsg(hwndSysMenu,
1883	MM_QUERYITEMTEXT,
1884	MPFROM2SHORT(SC_MAXIMIZE, 128), MPFROMP(s))) {
1885	p = strchr(s, '\t');
1886	if (p) {
1887	p++;
1888	strcpy(p, "Ctrl+Alt+F10");
1889	WinSetMenuItemText(hwndSysMenu, SC_MAXIMIZE, s);
1890	}
1891	}
1892	if (WinSendMsg(hwndSysMenu,
1893	MM_QUERYITEMTEXT, MPFROM2SHORT(SC_HIDE, 128), MPFROMP(s))) {
1894	p = strchr(s, '\t');
1895	if (p) {
1896	p++;
1897	strcpy(p, "Ctrl+Alt+F11");
1898	WinSetMenuItemText(hwndSysMenu, SC_HIDE, s);
1899	}
1900	}
1901	}
1902
1903	VOID LoadLibPath(CHAR * str, LONG len)
1904	{
1905	ULONG ver[2];
1906	CHAR configsys[] = "C:\\CONFIG.SYS";
1907	static CHAR var[8192], beg[16384], end[16384];
1908	BOOL warp;
1909	FILE *fp;
1910	PFN DQELIBPATH = NULL;
1911	HMODULE hmod;
1912
1913	if (str && len) {
1914	*str = 0;
1915	if (DosQuerySysInfo(QSV_BOOT_DRIVE,
1916	QSV_BOOT_DRIVE, (PVOID) ver, (ULONG) sizeof(ULONG)))
1917	ver[0] = 3L;
1918	*configsys = (CHAR) ver[0] + '@';
1919	if (!DosQuerySysInfo(QSV_VERSION_MAJOR,
1920	QSV_VERSION_MINOR,
1921	(PVOID) ver, (ULONG) sizeof(ver)) && ver[1] >= 30)
1922	warp = TRUE;
1923	var = beg = *end = 0;
1924	if (warp) {
1925	if (!DosLoadModule(var, sizeof(var), "DOSCALL1.DLL", &hmod)) {
1926	if (!DosQueryProcAddr(hmod,
1927	ORD_DOS32QUERYEXTLIBPATH,
1928	NULL, (PFN *) & DQELIBPATH)) {
1929	DQELIBPATH(beg, BEGIN_LIBPATH);
1930	DQELIBPATH(end, END_LIBPATH);
1931	}
1932	DosFreeModule(hmod);
1933	}
1934	*var = 0;
1935	}
1936	fp = xfopen(configsys, "r", pszSrcFile, __LINE__);
1937	if (fp) {
1938	while (!feof(fp)) {
1939	if (!xfgets_bstripcr(var, sizeof(var), fp, pszSrcFile, __LINE__))
1940	break;
1941	if (!strnicmp(var, "LIBPATH=", 8)) {
1942	memmove(var, var + 8, strlen(var + 8) + 1);
1943	lstrip(var);
1944	break;
1945	}
1946	}
1947	fclose(fp);
1948	}
1949	strncpy(str, beg, len);
1950	strncat(str, var, len - strlen(str));
1951	strncat(str, end, len - strlen(str));
1952	str[len - 1] = 0;
1953	}
1954	}
1955
1956	void SetViewMenu(HWND hwndMenu, ULONG flWindowAttr)
1957	{
1958	WinCheckMenuItem(hwndMenu, IDM_MINIICONS, ((flWindowAttr & CV_MINI)));
1959	WinCheckMenuItem(hwndMenu, IDM_TEXT, ((flWindowAttr & CV_TEXT)));
1960	WinCheckMenuItem(hwndMenu, IDM_ICON, ((flWindowAttr & CV_ICON) &&
1961	!(flWindowAttr & CV_TREE)));
1962	WinCheckMenuItem(hwndMenu, IDM_TREEVIEW, ((flWindowAttr & CV_TREE)));
1963	WinCheckMenuItem(hwndMenu, IDM_DETAILS, ((flWindowAttr & CV_DETAIL)));
1964	WinCheckMenuItem(hwndMenu, IDM_NAME, ((flWindowAttr & CV_NAME)));
1965	}
1966
1967	void SaySort(HWND hwnd, INT sortflags, BOOL archive)
1968	{
1969	char *s = NULL;
1970
1971	s = xmalloc(CCHMAXPATH, pszSrcFile, __LINE__);
1972	if (s) {
1973	sprintf(s, "S:%s%s",
1974	sortflags & SORT_REVERSE ? "^" : NullStr,
1975	(sortflags & SORT_FIRSTEXTENSION) ?
1976	GetPString(IDS_FIRSTX) : (sortflags & SORT_LASTEXTENSION) ?
1977	GetPString(IDS_LASTX) : (sortflags & SORT_SIZE) ?
1978	"Size" : (sortflags & SORT_EASIZE) ?
1979	(archive == 0) ?
1980	GetPString(IDS_EASIZE) : GetPString(IDS_CSIZE) :
1981	(sortflags & SORT_LWDATE) ?
1982	(archive == 0) ?
1983	GetPString(IDS_LWDATE) : GetPString(IDS_DATE) :
1984	(sortflags & SORT_LADATE) ?
1985	GetPString(IDS_LADATE) : (sortflags & SORT_CRDATE) ?
1986	GetPString(IDS_CRDATE) :
1987	(sortflags & SORT_PATHNAME) ?
1988	GetPString(IDS_PATH) : (sortflags & SORT_NOSORT) ?
1989	GetPString(IDS_NONE) : (sortflags & SORT_SUBJECT) ?
1990	GetPString(IDS_SUBJ) : GetPString(IDS_NAME));
1991	WinSetWindowText(hwnd, s);
1992	free(s);
1993	}
1994	}
1995
1996	void SayView(HWND hwnd, ULONG flWindowAttr)
1997	{
1998	char *s = NULL;
1999
2000	s = xmalloc(CCHMAXPATH, pszSrcFile, __LINE__);
2001	if (s) {
2002	sprintf(s, "V:%s%s",
2003	(flWindowAttr & CV_TREE) ? GetPString(IDS_TREE) :
2004	(flWindowAttr & CV_NAME) ? GetPString(IDS_NAME) :
2005	(flWindowAttr & CV_DETAIL) ? GetPString(IDS_DETAIL) :
2006	(flWindowAttr & CV_TEXT) ? GetPString(IDS_TEXT) :
2007	GetPString(IDS_ICON),
2008	((flWindowAttr & CV_MINI) &&
2009	!(flWindowAttr & CV_TEXT)) ? GetPString(IDS_MINI) : NullStr);
2010	WinSetWindowText(hwnd, s);
2011	free(s);
2012	}
2013	}
2014
2015	void SayFilter(HWND hwnd, MASK * mask, BOOL archive)
2016	{
2017	char *s = NULL;
2018
2019	s = xmalloc(CCHMAXPATH * 2, pszSrcFile, __LINE__);
2020	if (s) {
2021	sprintf(s, "F:%s%s",
2022	mask->szMask,
2023	(!archive && (mask->attrFile != ALLATTRS \|\|
2024	mask->antiattr != 0)) ? " " : NullStr,
2025	(!archive && (mask->attrFile != ALLATTRS \|\|
2026	mask->antiattr !=
2027	0)) ? GetPString(IDS_ATTRTEXT) : NullStr);
2028	if (!s[2])
2029	sprintf(s, "F:%s", GetPString(IDS_ALLTEXT));
2030	WinSetWindowText(hwnd, s);
2031	free(s);
2032	}
2033	}
2034
2035	char *GetCmdSpec(BOOL dos)
2036	{
2037	char *cmspec;
2038
2039	if (!dos) {
2040	cmspec = getenv("OS2_SHELL");
2041	if (!cmspec)
2042	cmspec = getenv("COMSPEC");
2043	if (!cmspec)
2044	cmspec = "CMD.EXE";
2045	}
2046	else {
2047	cmspec = getenv("DOS_SHELL");
2048	if (!cmspec)
2049	cmspec = "COMMAND.COM";
2050	}
2051	return cmspec;
2052	}
2053
2054	void Broadcast(HAB hab, HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
2055	{
2056	if (hwndMain)
2057	WinBroadcastMsg(hwndMain, msg, mp1, mp2, BMSG_SEND \| BMSG_FRAMEONLY);
2058	if (hwnd &&
2059	hwnd != HWND_DESKTOP &&
2060	hwnd != hwndMain &&
2061	hwnd != WinQueryDesktopWindow(hab, NULLHANDLE) &&
2062	WinIsWindow(hab, hwnd) && (!hwndMain \|\| !WinIsChild(hwnd, hwndMain)))
2063	WinSendMsg(hwnd, msg, mp1, mp2);
2064	}
2065
2066	void SetupWinList(HWND hwndMenu, HWND hwndTop, HWND hwndFrame)
2067	{
2068	/*
2069	* add switchlist entries to end of pulldown menu
2070	*/
2071
2072	SHORT sItemCount, x = 0, y = 0;
2073	MENUITEM mi;
2074
2075	sItemCount = (SHORT) WinSendMsg(hwndMenu,
2076	MM_QUERYITEMCOUNT, MPVOID, MPVOID);
2077
2078	/* clean out old additions */
2079	while ((SHORT) WinSendMsg(hwndMenu,
2080	MM_DELETEITEM,
2081	MPFROM2SHORT(IDM_SWITCHSTART + x++,
2082	TRUE), MPVOID) < sItemCount)
2083	sItemCount--;
2084	x = 0;
2085	while ((SHORT) WinSendMsg(hwndMenu,
2086	MM_DELETEITEM,
2087	MPFROM2SHORT(IDM_WINDOWSTART + x++,
2088	TRUE), MPVOID) < sItemCount)
2089	sItemCount--;
2090
2091	x = 0;
2092	if (hwndTop) {
2093
2094	char wtext[CCHMAXPATH + 8];
2095	HENUM henum;
2096	HWND hwndChild;
2097
2098	/* add children of the main FM/2 client */
2099	henum = WinBeginEnumWindows(hwndTop);
2100	memset(&mi, 0, sizeof(mi));
2101	while ((hwndChild = WinGetNextWindow(henum)) != NULLHANDLE) {
2102	if (WinQueryWindowUShort(hwndChild, QWS_ID) && hwndChild != hwndFrame) {
2103	*wtext = 0;
2104	WinQueryWindowText(hwndChild, CCHMAXPATH + 8, wtext);
2105	if (*wtext) {
2106	wtext[CCHMAXPATH + 7] = 0;
2107	mi.afStyle = MIS_TEXT;
2108	if (!((x + sItemCount) % 28))
2109	mi.afStyle \|= MIS_BREAK;
2110	mi.id = IDM_WINDOWSTART + x;
2111	mi.iPosition = MIT_END;
2112	if ((SHORT) WinSendMsg(hwndMenu,
2113	MM_INSERTITEM,
2114	MPFROMP(&mi), MPFROMP(wtext)) >= 0)
2115	x++;
2116	}
2117	}
2118	}
2119	WinEndEnumWindows(henum);
2120	}
2121
2122	/* add external FM/2 windows */
2123	{
2124	PSWBLOCK pswb;
2125	ULONG ulSize, ulcEntries;
2126	HWND hwndTopFrame;
2127	register INT i;
2128
2129	hwndTopFrame = hwndTop ? WinQueryWindow(hwndTop, QW_PARENT) : (HWND)0;
2130	/* Get the switch list information */
2131	x = 0;
2132	ulcEntries = WinQuerySwitchList(0, NULL, 0);
2133	ulSize = sizeof(SWBLOCK) + sizeof(HSWITCH) + (ulcEntries + 4L) *
2134	(LONG) sizeof(SWENTRY);
2135	/* Allocate memory for list */
2136	pswb = xmalloc(ulSize, pszSrcFile, __LINE__);
2137	if (pswb) {
2138	/* Put the info in the list */
2139	ulcEntries = WinQuerySwitchList(0, pswb, ulSize - sizeof(SWENTRY));
2140	/* do the dirty deed */
2141	memset(&mi, 0, sizeof(mi));
2142	for (i = 0; i < pswb->cswentry; i++) {
2143	if (pswb->aswentry[i].swctl.uchVisibility == SWL_VISIBLE &&
2144	pswb->aswentry[i].swctl.fbJump == SWL_JUMPABLE &&
2145	(pswb->aswentry[i].swctl.idProcess != mypid \|\|
2146	!hwndFrame \|\|
2147	pswb->aswentry[i].swctl.hwnd != hwndFrame) &&
2148	(pswb->aswentry[i].swctl.idProcess != mypid \|\|
2149	!hwndTopFrame \|\|
2150	pswb->aswentry[i].swctl.hwnd != hwndTopFrame \|\|
2151	!WinIsChild(hwndFrame, hwndTop))) {
2152	if (!strnicmp(pswb->aswentry[i].swctl.szSwtitle, "AV/2", 4)
2153	\|\| !stricmp(pswb->aswentry[i].swctl.szSwtitle, "File Manager/2")
2154	\|\| !stricmp(pswb->aswentry[i].swctl.szSwtitle, "Collector")
2155	\|\| !strnicmp(pswb->aswentry[i].swctl.szSwtitle, "VTree", 5)
2156	\|\| !strnicmp(pswb->aswentry[i].swctl.szSwtitle, "VDir", 4)
2157	\|\| !strnicmp(pswb->aswentry[i].swctl.szSwtitle, FM2Str, 4)) {
2158	mi.afStyle = MIS_TEXT;
2159	if (x && !(x % 28))
2160	mi.afStyle \|= MIS_BREAK;
2161	mi.id = IDM_SWITCHSTART + y;
2162	mi.iPosition = MIT_END;
2163	switches[y] = pswb->aswentry[i].hswitch;
2164	if ((SHORT) WinSendMsg(hwndMenu,
2165	MM_INSERTITEM,
2166	MPFROMP(&mi),
2167	MPFROMP(pswb->aswentry[i].
2168	swctl.szSwtitle)) >= 0) {
2169	y++;
2170	x++;
2171	}
2172	}
2173	}
2174	}
2175	numswitches = y;
2176	free(pswb);
2177	DosPostEventSem(CompactSem);
2178	}
2179	}
2180	}
2181
2182	BOOL SwitchCommand(HWND hwndMenu, USHORT cmd)
2183	{
2184	BOOL ret = FALSE;
2185
2186	if (hwndMain && hwndMenu && cmd >= IDM_WINDOWSTART && cmd < IDM_SWITCHSTART) {
2187	/*
2188	* select a child window (of client)
2189	*/
2190
2191	MENUITEM mi;
2192	HWND hwndSubMenu = (HWND) 0, hwndChild;
2193	CHAR s[CCHMAXPATH + 8];
2194
2195	if (WinQueryWindowUShort(hwndMenu, QWS_ID) != IDM_WINDOWSMENU) {
2196	memset(&mi, 0, sizeof(mi));
2197	mi.iPosition = MIT_END;
2198	mi.afStyle = MIS_TEXT;
2199	if (WinSendMsg(hwndMenu,
2200	MM_QUERYITEM,
2201	MPFROM2SHORT(IDM_WINDOWSMENU, TRUE), MPFROMP(&mi)))
2202	hwndSubMenu = mi.hwndSubMenu;
2203	}
2204	else
2205	hwndSubMenu = hwndMenu;
2206	if (hwndSubMenu) {
2207	*s = 0;
2208	if (WinSendMsg(hwndSubMenu,
2209	MM_QUERYITEMTEXT,
2210	MPFROM2SHORT(cmd, CCHMAXPATH + 8), MPFROMP(s)) && *s) {
2211
2212	HENUM henum;
2213	CHAR checkText[CCHMAXPATH + 8];
2214	SWP swp;
2215
2216	s[CCHMAXPATH + 7] = 0;
2217	henum = WinBeginEnumWindows(hwndMain);
2218	while ((hwndChild = WinGetNextWindow(henum)) != NULLHANDLE) {
2219	if (WinQueryWindowUShort(hwndChild, QWS_ID)) {
2220	*checkText = 0;
2221	WinQueryWindowText(hwndChild, CCHMAXPATH + 8, checkText);
2222	checkText[CCHMAXPATH + 7] = 0;
2223	if (!stricmp(checkText, s)) {
2224	if (WinQueryWindowPos(hwndChild, &swp)) {
2225	if (swp.fl & (SWP_MINIMIZE \| SWP_HIDE))
2226	WinSetWindowPos(hwndChild,
2227	HWND_TOP,
2228	0, 0, 0, 0, SWP_RESTORE \| SWP_ZORDER);
2229	}
2230	WinSetActiveWindow(HWND_DESKTOP, hwndChild);
2231	ret = TRUE;
2232	break;
2233	}
2234	}
2235	}
2236	WinEndEnumWindows(henum);
2237	}
2238	}
2239	}
2240	else if (cmd >= IDM_SWITCHSTART && cmd < IDM_SWITCHSTART + 499) {
2241	if (cmd - IDM_SWITCHSTART < numswitches) {
2242	WinSwitchToProgram(switches[cmd - IDM_SWITCHSTART]);
2243	ret = TRUE;
2244	}
2245	}
2246
2247	return ret;
2248	}
2249
2250	#pragma alloc_text(MAINWND5,SetSysMenu)
2251	#pragma alloc_text(MISC1,BoxWindow,PaintRecessedWindow,PostMsg,PaintSTextWindow,IsFm2Window)
2252	#pragma alloc_text(MISC1,FixSwitchList,FindDirCnr,CurrentRecord,SetShiftState,AddToListboxBottom)
2253	#pragma alloc_text(CNR_MISC1,AdjustCnrColVis,AdjustCnrColsForFSType)
2254	#pragma alloc_text(CNR_MISC1,AdjustCnrColsForPref,SetCnrCols)
2255	#pragma alloc_text(CNR_MISC2,CnrDirectEdit,OpenEdit)
2256	#pragma alloc_text(MISC2,SetMenuCheck,disable_menuitem,SetSortChecks)
2257	#pragma alloc_text(MISC2,SetDetailsSwitches,SetViewMenu)
2258	#pragma alloc_text(MISC3,SetupCommandMenu,AdjustDetailsSwitches)
2259	#pragma alloc_text(MISC3,ViewHelp,GetCmdSpec)
2260	#pragma alloc_text(MISC3,ExecFile,SetConditionalCascade,LoadDetailsSwitches)
2261	#pragma alloc_text(MISC4,PortholeInit,CheckMenu,Broadcast,SetupWinList,SwitchCommand)
2262	#pragma alloc_text(MISC6,DrawTargetEmphasis,EmphasizeButton)
2263	#pragma alloc_text(MISC_LIBPATH,LoadLibPath)
2264	#pragma alloc_text(MISC_SAY,SayView,SaySort,SayFilter)
2265

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

Download in other formats: