Context Navigation

source: trunk/dll/misc.c@ 240

Visit:

Last change on this file since 240 was 231, checked in by root, 20 years ago
Beautify
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 62.6 KB

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

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

Download in other formats: