Context Navigation

source: trunk/dll/misc.c@ 945

Visit:

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

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

Download in other formats: