Context Navigation

source: trunk/dll/misc.c@ 245

Visit:

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

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

Download in other formats: