Context Navigation

source: trunk/dll/autoview.c@ 859

Visit:

Last change on this file since 859 was 858, checked in by Steven Levine, 18 years ago
Correct NTFS driver small file read fix - broke for large files - oops
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 22.4 KB

Rev	Line
[41]	1
	2	/***********************************************************************
	3
	4	$Id: autoview.c 858 2007-11-05 17:47:12Z stevenhl $
	5
	6	Auto view
	7
	8	Copyright (c) 1993-98 M. Kimes
[291]	9	Copyright (c) 2001, 2006 Steven H.Levine
[41]	10
[130]	11	12 Sep 02 SHL AutoObjProc: catch buff2 overflows
	12	25 Oct 02 SHL CreateHexDump: catch buffer overflow
	13	12 Feb 03 SHL AutoObjProc: standardize EA math
	14	23 May 05 SHL Use QWL_USER
[291]	15	29 May 06 SHL Sync with archiver.bb2 mods
[341]	16	22 Jul 06 SHL Check more run time errors
[439]	17	15 Aug 06 SHL Use Runtime_Error more
[531]	18	03 Nov 06 SHL Renames
[689]	19	30 Mar 07 GKY Remove GetPString for window class names
[793]	20	20 Aug 07 GKY Move #pragma alloc_text to end for OpenWatcom compat
[827]	21	01 Sep 07 GKY Use xDosSetPathInfo to fix case where FS3 buffer crosses 64k boundry
[846]	22	27 Sep 07 SHL Correct ULONGLONG size formatting
[41]	23
	24	***********************************************************************/
	25
[2]	26	#define INCL_DOS
	27	#define INCL_WIN
	28	#define INCL_GPI
[841]	29	#define INCL_LONGLONG
[341]	30	#include <os2.h>
[2]	31
	32	#include <stdlib.h>
	33	#include <stdio.h>
	34	#include <string.h>
	35	#include <ctype.h>
[689]	36	#include <process.h> // _beginthread
[341]	37
[2]	38	#include "fm3dll.h"
	39	#include "fm3dlg.h"
	40	#include "fm3str.h"
	41	#include "mle.h"
	42
	43	#pragma data_seg(DATA1)
[341]	44
	45	static PSZ pszSrcFile = __FILE__;
	46
	47	static HWND hwndAutoObj;
[2]	48	static CHAR stopflag;
	49	static CHAR currfile[CCHMAXPATH];
	50
[551]	51	BOOL WriteEA(HWND hwnd, CHAR * filename, CHAR * eaname, USHORT type,
	52	CHAR * data)
[341]	53	{
[2]	54	/* save an ea to disk */
	55
	56	FEA2LIST *pfealist = NULL;
[551]	57	EAOP2 eaop;
	58	APIRET rc;
	59	ULONG ealen;
	60	USHORT len, num, plen, usCodepage;
	61	CHAR p, eaval;
	62	BOOL ret = FALSE;
[2]	63
[551]	64	if (!filename \|\| !eaname)
[2]	65	return ret;
[551]	66	usCodepage = (USHORT) WinQueryCp(WinQueryWindowULong(hwnd, QWL_HMQ));
[2]	67	len = (data) ? strlen(data) : 0;
[551]	68	ealen = sizeof(FEA2LIST) + 24L + strlen(eaname) + 1L + (ULONG) len + 4L;
	69	switch (type) {
	70	case EAT_EA:
	71	case EAT_ASCII:
	72	break;
	73	case EAT_MVST:
	74	if (data) {
	75	ealen += sizeof(USHORT) * 5;
	76	p = data;
	77	while (*p) {
	78	if (p == '\n' && (p + 1))
	79	ealen += sizeof(USHORT);
	80	p++;
	81	}
	82	}
	83	break;
	84	case EAT_MVMT:
	85	if (data) {
	86	ealen += sizeof(USHORT) * 5;
	87	p = data;
	88	while (*p) {
	89	if (p == '\n' && (p + 1))
	90	ealen += (sizeof(USHORT) * 2);
	91	p++;
	92	}
	93	}
	94	break;
	95	default:
	96	return ret;
	97	}
	98
	99	rc = DosAllocMem((PPVOID) & pfealist, ealen, PAG_COMMIT \| PAG_READ \|
	100	PAG_WRITE \| OBJ_TILE);
	101	if (rc \|\| !pfealist)
	102	Dos_Error(MB_CANCEL, rc, hwnd, pszSrcFile, __LINE__,
	103	GetPString(IDS_OUTOFMEMORY));
	104	else {
	105	memset(pfealist, 0, ealen);
	106	pfealist->list[0].cbName = strlen(eaname);
	107	memcpy(pfealist->list[0].szName, eaname, pfealist->list[0].cbName + 1);
	108	eaval = pfealist->list[0].szName + pfealist->list[0].cbName + 1;
	109	switch (type) {
[2]	110	case EAT_EA:
	111	case EAT_ASCII:
[551]	112	if (data) {
	113	(USHORT ) eaval = (USHORT) type;
	114	eaval += sizeof(USHORT);
	115	(USHORT ) eaval = (USHORT) len;
	116	eaval += sizeof(USHORT);
	117	memcpy(eaval, data, len);
	118	eaval += len;
	119	}
[2]	120	break;
	121	case EAT_MVST:
[551]	122	if (data) {
	123	(USHORT ) eaval = (USHORT) EAT_MVST;
	124	eaval += sizeof(USHORT);
	125	(USHORT ) eaval = usCodepage;
	126	eaval += sizeof(USHORT);
	127	num = (USHORT *) eaval;
	128	*num = 0;
	129	eaval += sizeof(USHORT);
	130	(USHORT ) eaval = (USHORT) EAT_ASCII;
	131	eaval += sizeof(USHORT);
	132	plen = (USHORT *) eaval;
	133	*plen = 0;
	134	eaval += sizeof(USHORT);
	135	p = data;
	136	while (*p) {
	137	while (*p) {
	138	if (*p == '\n') {
	139	p++;
	140	break;
	141	}
	142	eaval++ = p++;
	143	(*plen)++;
	144	}
	145	if (p \|\| plen)
	146	(*num)++;
	147	if (*p) {
	148	plen = (USHORT *) eaval;
	149	*plen = 0;
	150	eaval += sizeof(USHORT);
	151	}
	152	}
[2]	153	}
	154	break;
	155	case EAT_MVMT:
[551]	156	if (data) {
	157	(USHORT ) eaval = (USHORT) EAT_MVMT;
	158	eaval += sizeof(USHORT);
	159	(USHORT ) eaval = usCodepage;
	160	eaval += sizeof(USHORT);
	161	num = (USHORT *) eaval;
	162	*num = 0;
	163	eaval += sizeof(USHORT);
	164	(USHORT ) eaval = (USHORT) EAT_ASCII;
	165	eaval += sizeof(USHORT);
	166	plen = (USHORT *) eaval;
	167	*plen = 0;
	168	eaval += sizeof(USHORT);
	169	p = data;
	170	while (*p) {
	171	while (*p) {
	172	if (*p == '\n') {
	173	p++;
	174	break;
	175	}
	176	eaval++ = p++;
	177	(*plen)++;
	178	}
	179	if (p \|\| plen)
	180	(*num)++;
	181	if (*p) {
	182	(USHORT ) eaval = (USHORT) EAT_ASCII;
	183	eaval += sizeof(USHORT);
	184	plen = (USHORT *) eaval;
	185	*plen = 0;
	186	eaval += sizeof(USHORT);
	187	}
	188	}
[2]	189	}
	190	break;
	191	}
[551]	192	pfealist->list[0].cbValue = (ULONG) (eaval -
	193	(pfealist->list[0].szName +
	194	pfealist->list[0].cbName + 1));
	195	memset(&eaop, 0, sizeof(eaop));
[2]	196	eaop.fpFEA2List = pfealist;
[841]	197	pfealist->cbList = 13 + (ULONG) pfealist->list[0].cbName +
[551]	198	(ULONG) pfealist->list[0].cbValue;
[827]	199	rc = xDosSetPathInfo(filename, FIL_QUERYEASIZE,
	200	&eaop, sizeof(eaop), DSPI_WRTTHRU);
[2]	201	DosFreeMem(pfealist);
[551]	202	if (!rc)
[2]	203	ret = TRUE;
	204	}
	205	return ret;
	206	}
	207
[551]	208	BOOL PutComments(HWND hwnd, CHAR * filename, CHAR * comments)
[341]	209	{
[2]	210	register CHAR *p;
	211
[551]	212	if (comments) { /* check -- is it empty? */
[2]	213	p = comments;
[551]	214	while (p && isspace(p))
[2]	215	p++;
[551]	216	if (!*p)
[2]	217	comments = NULL;
	218	}
[551]	219	return WriteEA(hwnd, filename, ".COMMENTS", EAT_MVMT, comments);
[2]	220	}
	221
[439]	222	static PSZ pszBufOvfMsg = "Buffer overflow";
[2]	223
[551]	224	ULONG CreateHexDump(CHAR * pchInBuf, ULONG cbInBuf,
	225	CHAR * pchOutBuf, ULONG cbOutBuf,
	226	ULONG cOffset, BOOL fLongAddr)
[41]	227	{
[551]	228	register CHAR pchIn, pchReset, *pchOut;
	229	register ULONG ibIn = 0, ibIn2, ibInFill;
[41]	230	ULONG cbOutLine = 6 + (fLongAddr ? 4 : 0) + 16 * 3 + 1 + 16 + 1;
[2]	231
[551]	232	if (pchInBuf && cbInBuf && pchOutBuf && cbOutBuf) {
[41]	233	pchIn = pchInBuf;
	234	pchOut = pchOutBuf;
[551]	235	if (cOffset)
[41]	236	*pchOut++ = '\n';
	237	while (ibIn < cbInBuf) {
	238	if (pchOut - pchOutBuf + cbOutLine >= cbOutBuf) {
[551]	239	Runtime_Error(pszSrcFile, __LINE__, pszBufOvfMsg);
[41]	240	break;
	241	}
	242	pchReset = pchIn;
	243	ibIn2 = ibIn;
[551]	244	if (fLongAddr)
	245	sprintf(pchOut, "%08lx ", ibIn + cOffset);
[2]	246	else
[551]	247	sprintf(pchOut, "%04lx ", ibIn + cOffset);
[41]	248	pchOut += 6 + (fLongAddr ? 4 : 0);
[2]	249	do {
[551]	250	sprintf(pchOut, "%02hx ", *pchIn);
	251	pchOut += 3;
	252	pchIn++;
	253	ibIn++;
	254	} while (ibIn < cbInBuf && (ibIn % 16));
	255	if (ibIn % 16) {
	256	ibInFill = ibIn;
	257	while (ibInFill % 16) {
	258	*pchOut++ = ' ';
	259	*pchOut++ = ' ';
	260	*pchOut++ = ' ';
	261	ibInFill++;
	262	}
[2]	263	}
[41]	264	*pchOut++ = ' ';
	265	pchIn = pchReset;
[2]	266	do {
[551]	267	if (pchIn && pchIn != '\n' && pchIn != '\r' && pchIn != '\t'
	268	&& *pchIn != '\x1a')
	269	pchOut++ = pchIn++;
	270	else {
	271	*pchOut++ = '.';
	272	pchIn++;
	273	}
	274	ibIn2++;
	275	} while (ibIn2 < ibIn);
	276	if (ibIn < cbInBuf)
	277	*pchOut++ = '\n';
	278	} // while ibIn
[41]	279	*pchOut = 0;
[551]	280	return (ULONG) (pchOut - pchOutBuf);
[2]	281	}
	282	return 0L;
	283	}
	284
[551]	285	MRESULT EXPENTRY AutoObjProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
[51]	286	{
[551]	287	switch (msg) {
	288	case UM_LOADFILE:
	289	*currfile = 0;
	290	stopflag--;
	291	if (fAutoView) {
	292	WinSetWindowText((fComments) ? hwndAutoMLE : hwndAutoview, "");
	293	MLEsetreadonly(hwndAutoMLE, TRUE);
	294	MLEsetchanged(hwndAutoMLE, FALSE);
	295	}
	296	if (mp1) {
	297	if (fAutoView) {
	298	strcpy(currfile, (CHAR *) mp1);
	299	if (!fComments) {
	300	if (IsFile((CHAR *) mp1) == 1) {
[2]	301
[551]	302	HFILE handle;
[858]	303	ULONG olen, ibufflen, action, obufflen, l;
[850]	304	CHAR ibuff, obuff, *p;
	305	// 06 Oct 07 SHL Protect against NTFS driver small buffer defect
	306	// CHAR buffer[80];
	307	CHAR buffer[4096];
[551]	308	ARC_TYPE *info;
[2]	309
[844]	310	if (!DosOpen((CHAR *) mp1,
	311	&handle,
	312	&action,
	313	0,
	314	0,
	315	OPEN_ACTION_FAIL_IF_NEW \| OPEN_ACTION_OPEN_IF_EXISTS,
	316	OPEN_FLAGS_FAIL_ON_ERROR \| OPEN_FLAGS_NOINHERIT \|
	317	OPEN_FLAGS_RANDOMSEQUENTIAL \| OPEN_SHARE_DENYNONE \|
	318	OPEN_ACCESS_READONLY, 0)) {
[850]	319	ibufflen = AutoviewHeight < 96 ? 512 : 3072;
	320	// 06 Oct 07 SHL protect against NTFS driver small buffer defect
[858]	321	// ibuff = xmalloc(ibufflen + 2, pszSrcFile, __LINE__); // 05 Nov 07 SHL
	322	ibuff = xmalloc(max(ibufflen + 2, 4096), pszSrcFile, __LINE__);
[551]	323	if (ibuff) {
	324	// Depends on CreateHexDump line width
	325	obufflen = (ibufflen / 16) * (6 + 3 * 16 + 1 + 16 + 1) + 80;
	326	obuff = xmalloc(obufflen + 1, pszSrcFile, __LINE__);
	327	if (obuff) {
	328	*obuff = 0;
[850]	329	if (!DosRead(handle, ibuff, ibufflen, &ibufflen) &&
	330	ibufflen)
	331	{
[551]	332	ibuff[ibufflen] = 0;
	333	p = obuff;
	334	if (IsBinary(ibuff, ibufflen)) {
	335	olen = ibufflen;
	336	// Check archive
	337	if (!arcsigsloaded)
	338	load_archivers();
	339	info = arcsighead;
	340	while (info) {
	341	if (info->signature && *info->signature) {
	342	l = strlen(info->signature);
	343	l = min(l, 79);
	344	if (!DosChgFilePtr(handle, abs(info->file_offset),
	345	(info->file_offset >= 0L) ?
	346	FILE_BEGIN :
	347	FILE_END, &ibufflen)) {
	348	if (!DosRead(handle,
	349	buffer,
	350	l, &ibufflen) && ibufflen == l) {
	351	if (!memcmp(info->signature, buffer, l))
	352	break;
	353	}
	354	}
	355	}
	356	info = info->next;
	357	}
	358	if (info) {
	359	sprintf(p, "**%s%s%s\n",
[773]	360	info->id ? info->id : "",
	361	info->id ? " " : "",
[551]	362	GetPString(IDS_ARCHIVETEXT));
	363	p += strlen(p);
	364	}
	365	CreateHexDump(ibuff, // Input buffer
	366	olen, // Input buffer size
	367	p, // Output buffer
	368	obufflen - (p - obuff), // Output buffer size
	369	0, // Address offest
	370	FALSE); // Short addresses
	371	}
	372	else {
	373	// Text file
	374	register CHAR src, dest;
	375	CHAR *endsrc;
[2]	376
[551]	377	src = ibuff;
	378	dest = obuff;
	379	endsrc = ibuff + ibufflen;
	380	while (src < endsrc) {
	381	if (dest == obuff && (src == '\t' \|\| src == ' ' \|\|
	382	src == '\r' \|\| src == '\n')) {
	383	src++;
	384	}
	385	else if (src == '\t' \|\| !src) {
	386	*dest = ' ';
	387	dest++;
	388	src++;
	389	}
	390	else if (src == '\r' \|\| src == '\n') {
	391	dest = src;
	392	while ((src + 1) == '\r' \|\| (src + 1) == '\n' \|\|
	393	(src + 1) == ' ' \|\| (src + 1) == '\t')
	394	src++;
	395	dest++;
	396	src++;
	397	}
	398	else {
	399	dest = src;
	400	src++;
	401	dest++;
	402	}
	403	} // while
	404	*dest = 0;
	405	if (dest - obuff >= obufflen)
	406	Runtime_Error(pszSrcFile, __LINE__, pszBufOvfMsg);
	407	}
	408	if (*obuff)
	409	WinSetWindowText(hwndAutoview, obuff);
	410	}
	411	free(obuff);
	412	}
	413	free(ibuff);
	414	}
	415	DosClose(handle);
	416	}
	417	}
	418	else if (!IsFile(currfile)) {
[2]	419
[841]	420	static FILEFINDBUF4L ffb[130];
[773]	421	CHAR fullname[CCHMAXPATH + 4];
[551]	422	HDIR hdir = HDIR_CREATE;
	423	ULONG x, nm, ml, mc, bufflen;
	424	PBYTE fb;
[841]	425	PFILEFINDBUF4L pffbFile;
[773]	426	PSZ pszBuf;
	427	PSZ p;
	428	APIRET rc;
[2]	429
[773]	430	BldFullPathName(fullname, currfile, "*");
[763]	431	//sprintf(fullname,
	432	// "%s%s*",
	433	// currfile,
	434	// (currfile[strlen(currfile) - 1] == '\\') ? "" : "\\");
[551]	435	DosError(FERR_DISABLEHARDERR);
[841]	436	nm = sizeof(ffb) / sizeof(FILEFINDBUF4L);
[551]	437	if (AutoviewHeight < 96)
	438	nm /= 2;
[838]	439	rc = xDosFindFirst(fullname,
[858]	440	&hdir,
	441	FILE_NORMAL \| FILE_DIRECTORY \|
	442	FILE_READONLY \| FILE_ARCHIVED \|
	443	FILE_SYSTEM \| FILE_HIDDEN,
	444	&ffb, sizeof(ffb), &nm, FIL_QUERYEASIZEL);
[551]	445	if (!rc && nm) {
	446	fb = (PBYTE) & ffb;
	447	x = ml = 0;
	448	while (x < nm) {
[841]	449	pffbFile = (PFILEFINDBUF4L) fb;
[551]	450	mc = (ULONG) pffbFile->cchName +
	451	((pffbFile->attrFile & FILE_DIRECTORY) != 0);
	452	ml = max(ml, mc);
	453	if (!pffbFile->oNextEntryOffset)
	454	break;
	455	fb += pffbFile->oNextEntryOffset;
	456	x++;
	457	}
	458	bufflen = (CCHMAXPATHCOMP + 42) * nm;
[773]	459	pszBuf = xmalloc(bufflen, pszSrcFile, __LINE__);
	460	if (pszBuf) {
	461	p = pszBuf;
[551]	462	*p = 0;
	463	fb = (PBYTE) & ffb;
	464	x = 0;
	465	while (x < nm) {
[841]	466	pffbFile = (PFILEFINDBUF4L) fb;
[551]	467	if (!(!*pffbFile->achName \|\|
	468	(((pffbFile->attrFile & FILE_DIRECTORY) &&
	469	pffbFile->achName[0] == '.') &&
	470	(!pffbFile->achName[1] \|\|
	471	(pffbFile->achName[1] == '.' &&
	472	!pffbFile->achName[2]))))) {
[846]	473	// 27 Sep 07 SHL fixme to use CommaFmtULL
[551]	474	sprintf(p,
[846]	475	"%s%-.s %-8llu [%s%s%s%s] %04lu/%02lu/%02lu "
	476	"%02lu:%02lu:%02lu\r",
	477	pffbFile->attrFile & FILE_DIRECTORY ? "\\" : " ",
[551]	478	ml,
	479	ml,
	480	pffbFile->achName,
	481	pffbFile->cbFile +
[846]	482	CBLIST_TO_EASIZE(pffbFile->cbList),
	483	pffbFile->attrFile & FILE_READONLY ? "R" : "-",
	484	pffbFile->attrFile & FILE_ARCHIVED ? "A" : "-",
	485	pffbFile->attrFile & FILE_HIDDEN ? "H" : "-",
	486	pffbFile->attrFile & FILE_SYSTEM ? "S" : "-",
[551]	487	pffbFile->fdateLastWrite.year + 1980,
	488	pffbFile->fdateLastWrite.month,
	489	pffbFile->fdateLastWrite.day,
	490	pffbFile->ftimeLastWrite.hours,
	491	pffbFile->ftimeLastWrite.minutes,
	492	pffbFile->ftimeLastWrite.twosecs * 2);
	493	p += strlen(p);
	494	}
	495	if (!pffbFile->oNextEntryOffset)
	496	break;
	497	fb += pffbFile->oNextEntryOffset;
	498	x++;
	499	} // while
[773]	500	if (p - pszBuf >= bufflen)
[551]	501	Runtime_Error(pszSrcFile, __LINE__, pszBufOvfMsg);
[773]	502	if (*pszBuf)
	503	WinSetWindowText(hwndAutoview, pszBuf);
	504	free(pszBuf);
[551]	505	}
	506	}
	507	if (!rc)
	508	DosFindClose(hdir);
	509	}
	510	}
	511	else {
[2]	512
[551]	513	APIRET rc;
	514	EAOP2 eaop;
	515	PGEA2LIST pgealist;
	516	PFEA2LIST pfealist;
	517	PGEA2 pgea;
	518	PFEA2 pfea;
[773]	519	CHAR value, pszBuf, p, data;
[551]	520	USHORT len, type, plen, dlen;
	521	BOOL readonly = FALSE;
[2]	522
[551]	523	pgealist = xmallocz(sizeof(GEA2LIST) + 64, pszSrcFile, __LINE__);
	524	if (pgealist) {
	525	pgea = &pgealist->list[0];
	526	strcpy(pgea->szName, ".COMMENTS");
	527	pgea->cbName = strlen(pgea->szName);
	528	pgea->oNextEntryOffset = 0L;
	529	pgealist->cbList = (sizeof(GEA2LIST) + pgea->cbName);
	530	pfealist = xmallocz(65536, pszSrcFile, __LINE__);
	531	if (pfealist) {
	532	pfealist->cbList = 65536;
	533	eaop.fpGEA2List = pgealist;
	534	eaop.fpFEA2List = pfealist;
	535	eaop.oError = 0L;
	536	rc = DosQueryPathInfo((CHAR *) mp1, FIL_QUERYEASFROMLIST,
	537	(PVOID) & eaop, (ULONG) sizeof(EAOP2));
	538	free(pgealist);
	539	if (!rc) {
	540	pfea = &eaop.fpFEA2List->list[0];
	541	if (pfea->cbName && pfea->cbValue) {
	542	value = pfea->szName + pfea->cbName + 1;
	543	value[pfea->cbValue] = 0;
	544	if ((USHORT ) value == EAT_MVMT) {
[773]	545	pszBuf = xmalloc(65536, pszSrcFile, __LINE__);
	546	if (pszBuf) {
	547	p = pszBuf;
	548	*pszBuf = 0;
[551]	549	data = value + (sizeof(USHORT) * 3);
	550	type = (USHORT ) data;
	551	data += sizeof(USHORT);
	552	len = (USHORT ) data;
	553	data += sizeof(USHORT);
	554	while ((data - value) - len < pfea->cbValue) {
	555	if (type == EAT_ASCII) {
	556	dlen = plen = 0;
	557	while (dlen < len) {
	558	if (data[dlen] == '\r') {
	559	dlen++;
	560	if (dlen < len && data[dlen] != '\n')
	561	p[plen++] = '\n';
	562	}
	563	else
	564	p[plen++] = data[dlen++];
	565	}
	566	if ((!len \|\| !plen \|\| p[plen - 1] != '\n') &&
	567	(data - value) + len < pfea->cbValue)
	568	p[plen++] = '\n';
	569	p += plen;
	570	*p = 0;
	571	}
	572	else
	573	readonly = TRUE;
	574	data += len;
	575	if (data - value >= pfea->cbValue)
[41]	576	break;
[551]	577	type = (USHORT ) data;
	578	data += sizeof(USHORT);
	579	len = (USHORT ) data;
	580	data += sizeof(USHORT);
	581	} // while
[773]	582	if (p - pszBuf >= 65536) {
[551]	583	Runtime_Error(pszSrcFile, __LINE__, pszBufOvfMsg);
[773]	584	pszBuf[65535] = 0; // Try to stay alive
[551]	585	break;
	586	}
[773]	587	WinSetWindowText(hwndAutoMLE, pszBuf);
	588	free(pszBuf);
[551]	589	}
	590	}
	591	else
	592	readonly = TRUE;
	593	}
	594	/* else EA not present */
	595	MLEsetchanged(hwndAutoMLE, FALSE);
	596	MLEsetreadonly(hwndAutoMLE, readonly);
	597	}
	598	else {
	599	MLEsetchanged(hwndAutoMLE, FALSE);
	600	MLEsetreadonly(hwndAutoMLE, FALSE);
	601	}
	602	free(pfealist);
	603	}
	604	}
	605	}
[2]	606	}
[551]	607	free((CHAR *) mp1);
	608	}
	609	return 0;
[2]	610
[551]	611	case UM_CLOSE:
	612	if (!PostMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID))
	613	WinSendMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID);
	614	WinDestroyWindow(hwnd);
	615	return 0;
[2]	616	}
[551]	617	return WinDefWindowProc(hwnd, msg, mp1, mp2);
[2]	618	}
	619
[551]	620	static VOID MakeAutoWinThread(VOID * args)
[341]	621	{
[551]	622	HAB hab2;
	623	HMQ hmq2;
	624	HWND hwndParent = (HWND) args;
	625	QMSG qmsg2;
[2]	626
	627	hab2 = WinInitialize(0);
[551]	628	if (hab2) {
	629	hmq2 = WinCreateMsgQueue(hab2, 128);
	630	if (hmq2) {
[2]	631	DosError(FERR_DISABLEHARDERR);
	632	WinRegisterClass(hab2,
[593]	633	WC_OBJECTWINDOW,
[551]	634	AutoObjProc, 0, sizeof(PVOID));
[2]	635	hwndAutoObj = WinCreateWindow(HWND_OBJECT,
[593]	636	WC_OBJECTWINDOW,
[551]	637	(PSZ) NULL,
	638	0,
	639	0L,
	640	0L,
	641	0L,
	642	0L, 0L, HWND_TOP, OBJ_FRAME, NULL, NULL);
[377]	643	if (!hwndAutoObj) {
[551]	644	Win_Error2(HWND_OBJECT, HWND_DESKTOP, pszSrcFile, __LINE__,
	645	IDS_WINCREATEWINDOW);
	646	if (!PostMsg(hwndParent, UM_CLOSE, MPVOID, MPVOID))
	647	WinSendMsg(hwndParent, UM_CLOSE, MPVOID, MPVOID);
[377]	648	}
	649	else {
[551]	650	WinSetWindowULong(hwndAutoObj, QWL_USER, hwndParent);
	651	priority_normal();
	652	while (WinGetMsg(hab2, &qmsg2, (HWND) 0, 0, 0))
	653	WinDispatchMsg(hab2, &qmsg2);
	654	WinDestroyWindow(hwndAutoObj);
	655	hwndAutoObj = (HWND) 0;
[2]	656	}
	657	WinDestroyMsgQueue(hmq2);
	658	}
	659	else
	660	WinTerminate(hab2);
	661	}
	662	}
	663
[551]	664	MRESULT EXPENTRY AutoViewProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
[341]	665	{
[551]	666	USHORT id = WinQueryWindowUShort(hwnd, QWS_ID);
[2]	667
[551]	668	switch (msg) {
	669	case WM_CREATE:
	670	{
	671	MRESULT mr;
[2]	672
[551]	673	if (!hwndAutoObj) {
	674	if (_beginthread(MakeAutoWinThread, NULL, 65536, (PVOID) hwnd) == -1) {
	675	Runtime_Error(pszSrcFile, __LINE__,
	676	GetPString(IDS_COULDNTSTARTTHREADTEXT));
	677	PostMsg(hwnd, UM_CLOSE, MPVOID, MPVOID);
[341]	678	}
[2]	679	}
[551]	680	mr = PFNWPStatic(hwnd, msg, mp1, mp2);
	681	SetPresParams(hwnd,
	682	&RGBGREY,
	683	&RGBBLACK, &RGBGREY, GetPString(IDS_4SYSTEMVIOTEXT));
	684	stopflag = 0;
	685	return mr;
	686	}
[2]	687
[551]	688	case UM_SETUP:
	689	MLEsetlimit(hwnd, 32768);
	690	MLEsetformat(hwnd, MLFIE_NOTRANS);
	691	MLEsetchanged(hwnd, FALSE);
	692	return 0;
[2]	693
[551]	694	case WM_BUTTON1DOWN:
	695	{
	696	SWP swp;
[2]	697
[551]	698	WinQueryWindowPos(hwnd, &swp);
	699	if (SHORT2FROMMP(mp1) > swp.cy - 4) {
[2]	700
[551]	701	HPS hps = WinGetPS(WinQueryWindow(hwnd, QW_PARENT));
	702	SWP swpC;
	703	TRACKINFO track;
[2]	704
[551]	705	if (hps) {
	706	WinQueryWindowPos(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
	707	FID_CLIENT), &swpC);
	708	track.cxBorder = 4;
	709	track.cyBorder = 4;
	710	track.cxGrid = 1;
	711	track.cyGrid = 8;
	712	track.cxKeyboard = 8;
	713	track.rclTrack.yBottom = swp.y;
	714	track.rclTrack.yTop = swp.y + swp.cy;
	715	track.rclTrack.xLeft = swp.x;
	716	track.rclTrack.xRight = swp.x + swp.cx;
	717	track.rclBoundary = track.rclTrack;
	718	track.rclBoundary.yTop = (swpC.cy + swp.y + swp.cy) - 116;
	719	track.ptlMinTrackSize.x = swp.x + swp.cx;
	720	track.ptlMinTrackSize.y = 36;
	721	track.ptlMaxTrackSize.x = swp.x + swp.cx;
	722	track.ptlMaxTrackSize.y = (swpC.cy + swp.cy) - 116;
	723	track.fs = TF_TOP;
	724	if (WinTrackRect(hwnd, hps, &track)) {
	725	AutoviewHeight = track.rclTrack.yTop - track.rclTrack.yBottom;
	726	PrfWriteProfileData(fmprof,
	727	FM3Str,
	728	"AutoviewHeight",
	729	&AutoviewHeight, sizeof(ULONG));
	730	WinSendMsg(WinQueryWindow(hwnd, QW_PARENT),
	731	WM_UPDATEFRAME, MPFROMLONG(FCF_SIZEBORDER), MPVOID);
	732	}
	733	WinReleasePS(hps);
	734	}
	735	return (MRESULT) TRUE;
[2]	736	}
[551]	737	else if (id != MAIN_AUTOVIEWMLE)
	738	return CommonTextButton(hwnd, msg, mp1, mp2);
	739	}
	740	break;
[2]	741
[551]	742	case WM_BUTTON3DOWN:
	743	case WM_BUTTON1UP:
	744	case WM_BUTTON3UP:
	745	if (id != MAIN_AUTOVIEWMLE)
	746	return CommonTextButton(hwnd, msg, mp1, mp2);
	747	break;
[2]	748
[551]	749	case WM_MOUSEMOVE:
	750	shiftstate = (SHORT2FROMMP(mp2) & (KC_ALT \| KC_SHIFT \| KC_CTRL));
	751	{
	752	SWP swp;
[2]	753
[551]	754	WinQueryWindowPos(hwnd, &swp);
	755	if (SHORT2FROMMP(mp1) > swp.cy - 4) {
	756	WinSetPointer(HWND_DESKTOP, hptrNS);
	757	return (MRESULT) TRUE;
[2]	758	}
[551]	759	}
	760	break;
[2]	761
[551]	762	case WM_PAINT:
	763	PostMsg(hwnd, UM_PAINT, MPVOID, MPVOID);
	764	break;
[2]	765
[551]	766	case UM_PAINT:
	767	PaintRecessedWindow(hwnd, (HPS) 0, TRUE, TRUE);
	768	return 0;
[2]	769
[551]	770	case WM_SETFOCUS:
	771	switch (id) {
	772	case MAIN_AUTOVIEWMLE:
	773	if (!mp2 && !AutoMenu) {
	774	if (*currfile) {
	775	if (MLEgetchanged(hwnd)) {
	776	CHAR *ea = xmalloc(32768, pszSrcFile, __LINE__);
	777
	778	if (ea) {
	779	*ea = 0;
	780	WinQueryWindowText(hwnd, 32767, ea);
	781	PutComments(hwnd, currfile, ea);
	782	PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_RESCAN, 0), MPVOID);
	783	free(ea);
	784	}
	785	}
	786	}
[2]	787	}
	788	break;
[551]	789	default:
	790	if (mp2)
	791	PostMsg(hwnd, UM_FOCUSME, mp1, mp2);
	792	break;
	793	}
	794	break;
[2]	795
[551]	796	case UM_FOCUSME:
	797	if (mp2) {
[2]	798
[551]	799	PID pid;
	800	TID tid;
[2]	801
[551]	802	if (WinQueryWindowProcess((HWND) mp1, &pid, &tid) && pid == mypid)
	803	WinSetFocus(HWND_DESKTOP, (HWND) mp1);
	804	else
	805	WinSetFocus(HWND_DESKTOP, hwndTree);
	806	}
	807	return 0;
[2]	808
[551]	809	case UM_CLICKED:
	810	case UM_CLICKED3:
	811	if (id != MAIN_AUTOVIEWMLE) {
[2]	812	PostMsg(hwnd,
[551]	813	WM_COMMAND,
	814	MPFROM2SHORT(((msg == UM_CLICKED3) ?
	815	IDM_EAS : IDM_VIEWORARC), 0), MPVOID);
	816	}
	817	return 0;
[2]	818
[551]	819	case WM_COMMAND:
	820	PostMsg(hwnd, UM_COMMAND, mp1, mp2);
	821	return 0;
[2]	822
[551]	823	case UM_COMMAND:
	824	switch (SHORT1FROMMP(mp1)) {
	825	case IDM_RESCAN:
	826	if (*currfile) {
[2]	827
[551]	828	CHAR *cf = xstrdup(currfile, pszSrcFile, __LINE__);
[2]	829
[551]	830	if (cf) {
	831	stopflag++;
	832	if (!PostMsg(hwndAutoObj, UM_LOADFILE, MPFROMP(cf), MPVOID))
	833	free(cf);
	834	}
	835	}
	836	break;
[2]	837
[551]	838	case IDM_INFO:
	839	DefaultView(hwnd, (HWND) 0, hwndMain, NULL, 16, currfile);
	840	break;
[2]	841
[551]	842	case IDM_VIEW:
	843	DefaultView(hwnd, (HWND) 0, hwndMain, NULL, 0, currfile);
	844	break;
[2]	845
[551]	846	case IDM_EDIT:
	847	DefaultView(hwnd, (HWND) 0, hwndMain, NULL, 8, currfile);
	848	break;
[2]	849
[551]	850	case IDM_EAS:
	851	{
	852	char *list[2];
[2]	853
[551]	854	list[0] = currfile;
	855	list[1] = NULL;
[2]	856
[551]	857	WinDlgBox(HWND_DESKTOP,
	858	hwndMain,
	859	DisplayEAsProc, FM3ModHandle, EA_FRAME, (PVOID) list);
[2]	860	}
	861	break;
	862
[551]	863	default:
	864	PostMsg(hwndMain, msg, mp1, mp2);
	865	}
	866	return 0;
[2]	867
[551]	868	case WM_MENUEND:
	869	if ((HWND) mp2 == AutoMenu) {
	870	WinDestroyWindow(AutoMenu);
	871	AutoMenu = (HWND) 0;
	872	}
	873	break;
[2]	874
[551]	875	case WM_CONTEXTMENU:
	876	CheckMenu(&AutoMenu, (id == MAIN_AUTOVIEWMLE) ?
	877	IDM_AUTOVIEWMLE : IDM_AUTOVIEW);
	878	WinCheckMenuItem(AutoMenu, IDM_AUTOVIEWFILE, !fComments);
	879	WinCheckMenuItem(AutoMenu, IDM_AUTOVIEWCOMMENTS, fComments);
	880	WinEnableMenuItem(AutoMenu, IDM_VIEW, (IsFile(currfile) == 1));
	881	WinEnableMenuItem(AutoMenu, IDM_EDIT, (IsFile(currfile) == 1));
	882	WinEnableMenuItem(AutoMenu, IDM_INFO, (*currfile != 0));
	883	PopupMenu(hwnd, hwnd, AutoMenu);
	884	break;
[2]	885
[551]	886	case UM_LOADFILE:
	887	stopflag++;
	888	if (!PostMsg(hwndAutoObj, msg, mp1, mp2)) {
	889	if (mp1)
	890	free((CHAR *) mp1);
	891	}
	892	return 0;
[2]	893
[551]	894	case UM_CLOSE:
	895	if (AutoMenu) {
	896	WinDestroyWindow(AutoMenu);
	897	AutoMenu = (HWND) 0;
	898	}
	899	WinDestroyWindow(hwnd);
	900	return 0;
	901
	902	case WM_CLOSE:
	903	WinSendMsg(hwnd, UM_CLOSE, MPVOID, MPVOID);
	904	return 0;
	905
	906	case WM_DESTROY:
	907	if (id != MAIN_AUTOVIEWMLE) {
	908	if (hwndAutoObj)
	909	if (!PostMsg(hwndAutoObj, WM_CLOSE, MPVOID, MPVOID))
	910	WinSendMsg(hwndAutoObj, WM_CLOSE, MPVOID, MPVOID);
[2]	911	break;
[551]	912	}
	913	break;
[2]	914	}
	915
[551]	916	if (id == MAIN_AUTOVIEWMLE)
	917	return PFNWPMLE(hwnd, msg, mp1, mp2);
	918	return PFNWPStatic(hwnd, msg, mp1, mp2);
[2]	919	}
[793]	920
	921	#pragma alloc_text(AUTOVIEW,AutoViewProc,CreateHexDump,AutoObjProc)
	922	#pragma alloc_text(AUTOVIEW2,MakeAutoWinThread,WriteEA,PutComments)

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

Download in other formats: