Context Navigation

source: trunk/dll/misc.c@ 397

Visit:

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

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

Download in other formats: