Context Navigation

source: trunk/dll/misc.c@ 743

Visit:

Last change on this file since 743 was 743, checked in by Steven Levine, 18 years ago
Baseline code for ticket 24 CNRITEM remove/free
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 62.4 KB

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

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

Download in other formats: