Context Navigation

source: trunk/dll/misc.c@ 369

Visit:

Last change on this file since 369 was 369, checked in by root, 19 years ago
Use chop_at_crnl
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 63.1 KB

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

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

Download in other formats: