Context Navigation

source: trunk/dll/misc.c@ 922

Visit:

Last change on this file since 922 was 922, checked in by Gregg Young, 18 years ago
Get Subjectwidth/left working in the collector
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 65.8 KB

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

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

Download in other formats: