Context Navigation

source: trunk/dll/misc.c@ 105

Visit:

Last change on this file since 105 was 70, checked in by root, 22 years ago
Add JFS and FAT32 support
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 69.9 KB

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

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

Download in other formats: