Context Navigation

source: trunk/dll/misc.c@ 245

Visit:

Last change on this file since 245 was 245, checked in by root, 20 years ago
Correct longname display option
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 62.9 KB

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

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

Download in other formats: