Context Navigation

source: trunk/dll/misc.c@ 1028

Visit:

Last change on this file since 1028 was 1028, checked in by Gregg Young, 17 years ago
Fix for bug 237 that is actually correct; code clean up
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 67.0 KB

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

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

Download in other formats: