Context Navigation

source: trunk/dll/misc.c@ 397

Visit:

Last change on this file since 397 was 397, checked in by root, 19 years ago
Comments, apply indent
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 61.9 KB

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

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

Download in other formats: