Context Navigation

source: trunk/dll/misc.c@ 1027

Visit:

Last change on this file since 1027 was 1026, checked in by John Small, 17 years ago
Ticket 239: Fix LoadDetailsSwitches so that the INI file is read correctly and details switches are set correctly.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 66.9 KB

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

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

Download in other formats: