Context Navigation

source: trunk/dll/misc.c@ 737

Visit:

Last change on this file since 737 was 737, checked in by Steven Levine, 18 years ago
More ticket #24 updates
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 62.9 KB

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

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

Download in other formats: