Context Navigation

misc.c@ 869

Visit:

Last change on this file since 869 was 869, checked in by John Small, 18 years ago
A "first draft" of code to address ticket 150.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 64.5 KB

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

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

Context Navigation

source: branches/ticket_150/dll/misc.c@ 869

Download in other formats: