Context Navigation

source: trunk/dll/misc.c@ 997

Visit:

Last change on this file since 997 was 997, checked in by John Small, 17 years ago
Ticket 230: Make all INI keys for default directory container settings use the "DirCnr." prefix.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 66.4 KB

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

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

Download in other formats: