Context Navigation

source: trunk/dll/misc.c@ 468

Visit:

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

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

Download in other formats: