Context Navigation

source: trunk/dll/misc.c@ 369

Visit:

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

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

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

Download in other formats: