Context Navigation

source: trunk/dll/misc.c@ 1060

Visit:

Last change on this file since 1060 was 1039, checked in by Gregg Young, 17 years ago
Removed unnecessary xfrees and included fortify.h where needed; moved several misplaced (x)frees;
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 66.8 KB

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

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

Download in other formats: