Context Navigation

source: trunk/dll/misc.c@ 451

Visit:

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

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

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

Download in other formats: