Context Navigation

source: trunk/dll/misc.c@ 934

Visit:

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

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

Download in other formats: