Context Navigation

source: trunk/dll/misc.c@ 689

Visit:

Last change on this file since 689 was 689, checked in by Steven Levine, 18 years ago
Commit OpenWatcom compatibility updates
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 63.4 KB

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

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

Download in other formats: