Context Navigation

source: trunk/dll/misc.c@ 937

Visit:

Last change on this file since 937 was 937, checked in by Gregg Young, 18 years ago
Fix for subject display corruption with the if else statements included this time
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 66.2 KB

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

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

Download in other formats: