Context Navigation

source: trunk/dll/misc.c@ 406

Visit:

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

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

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

Download in other formats: