Context Navigation

source: trunk/dll/misc.c@ 728

Visit:

Last change on this file since 728 was 728, checked in by Gregg Young, 18 years ago
Menu changes to fix unecessary removal of some menu items when WORKPLACE_PROCESS=YES
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 63.3 KB

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

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

Download in other formats: