Context Navigation

source: trunk/dll/misc.c@ 736

Visit:

Last change on this file since 736 was 733, checked in by Steven Levine, 18 years ago
Comments
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 63.1 KB

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

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

Download in other formats: