Context Navigation

source: trunk/dll/misc.c@ 926

Visit:

Last change on this file since 926 was 923, checked in by John Small, 18 years ago
Updated for ticket 150: fixed/improved save and restore of the state of directory containers when FM/2 is closed and re-opened.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 66.0 KB

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

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

Download in other formats: