Context Navigation

source: trunk/dll/misc.c@ 423

Visit:

Last change on this file since 423 was 406, checked in by root, 19 years ago
Use xfgets_bstripcr
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 61.9 KB

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

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

Download in other formats: