Context Navigation

source: trunk/dll/newview.c@ 368

Visit:

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

Line
1
2	/***********************************************************************
3
4	$Id: newview.c 368 2006-07-27 02:20:16Z root $
5
6	New internal viewer
7
8	Copyright (c) 1993-98 M. Kimes
9	Copyright (c) 2001, 2006 Steven H. Levine
10
11	01 Dec 03 SHL Comments
12	02 Dec 03 SHL Correct WM_VSCROLL math
13	23 May 05 SHL Use QWL_USER
14	06 Jun 05 SHL Indent -i2
15	06 Jun 05 SHL Correct reversed wrap logic
16	17 Jul 06 SHL Use Runtime_Error
17	26 Jul 06 SHL Use chop_at_crnl and convert_nl_to_nul
18
19	***********************************************************************/
20
21	#define INCL_DOS
22	#define INCL_WIN
23	#define INCL_GPI
24	#include <os2.h>
25
26	#include <stdlib.h>
27	#include <stdio.h>
28	#include <string.h>
29	#include <ctype.h>
30	#include <process.h>
31	#include <limits.h>
32	#include <share.h>
33
34	#include "fm3dll.h"
35	#include "fm3dlg.h"
36	#include "fm3str.h"
37	#include "mle.h"
38
39	#pragma data_seg(DATA2)
40
41	static PSZ pszSrcFile = __FILE__;
42
43	#pragma alloc_text(NEWVIEW,ViewStatusProc,FreeViewerMem,LoadFile)
44	#pragma alloc_text(NEWVIEW,InitWindow,PaintLine,ViewWndProc)
45	#pragma alloc_text(NEWVIEW,ViewFrameWndProc,StartViewer,ReLine)
46	#pragma alloc_text(NEWVIEW,BuildAList,Search,Clipboard,FindStrDlgProc)
47	#pragma alloc_text(NEWVIEW,BuildAList2,UrlDlgProc)
48
49	#define VF_SELECTED 0x01
50	#define VF_FOUND 0x02
51	#define VF_HTTP 0x04
52	#define VF_FTP 0x08
53
54	#define FIXED_FONT_LCID 5
55
56	#define COLORS_MAX 12
57
58	#define COLORS_CURSOREDNORMALBACK 0
59	#define COLORS_CURSOREDSELECTEDBACK 1
60	#define COLORS_NORMALBACK 2
61	#define COLORS_SELECTEDBACK 3
62	#define COLORS_NORMALFORE 4
63	#define COLORS_FOUNDFORE 5
64	#define COLORS_SELECTEDFORE 6
65	#define COLORS_SELECTEDFOUNDFORE 7
66	#define COLORS_HTTPBACK 8
67	#define COLORS_HTTPFORE 9
68	#define COLORS_FTPBACK 10
69	#define COLORS_FTPFORE 11
70
71	static LONG Colors[COLORS_MAX] = {COLR_WHITE, COLR_DARKGRAY,
72	COLR_PALEGRAY, COLR_BLACK,
73	COLR_BLACK, COLR_RED,
74	COLR_WHITE, COLR_YELLOW,
75	COLR_PALEGRAY, COLR_DARKBLUE,
76	COLR_PALEGRAY, COLR_DARKGREEN};
77
78	#define SEARCHSTRINGLEN 1024
79
80	typedef struct
81	{
82	USHORT size;
83	USHORT flags;
84	USHORT cliptype;
85	CHAR filename[CCHMAXPATH];
86	CHAR *text;
87	CHAR *lines, markedlines;
88	CHAR searchtext[SEARCHSTRINGLEN], *lastpos, szFacename[FACESIZE];
89	ULONG textsize, numlines, topline, cursored, selected, numalloc, multiplier,
90	lastselected, found;
91	CHAR stopflag, busy;
92	LONG oldwidth, lastdirection, lMaxAscender, lMaxDescender, lMaxHeight,
93	maxx, horzscroll;
94	BOOL hex, mousecaptured, sensitive, dummy, literalsearch, clientfocused,
95	alsoselect, wrapon, relining, httpin, ftpin, ignorehttp, ignoreftp,
96	needrefreshing;
97	HMTX ScanSem;
98	HWND hvscroll, hwndMenu, hwndStatus1, hwndStatus2, hwndStatus3, hwndRestore,
99	hwndPopup, hwndListbox, hwndFrame, hwndDrag, hwndParent, hhscroll;
100	HPS hps;
101	FATTRS fattrs;
102	LONG colors[12];
103	}
104	VIEWDATA;
105
106	typedef struct
107	{
108	USHORT size;
109	USHORT dummy;
110	ULONG len;
111	CHAR *line;
112	CHAR url[SEARCHSTRINGLEN];
113	}
114	URLDATA;
115
116	static BOOL Sensitive = FALSE;
117	static USHORT Codepage = 0;
118	static BOOL Firsttime = TRUE;
119	static BOOL LiteralSearch = FALSE;
120	static BOOL AlsoSelect = FALSE;
121	static BOOL WrapOn = FALSE;
122	static BOOL IgnoreFTP = FALSE;
123	static BOOL IgnoreHTTP = FALSE;
124	static FATTRS Fattrs;
125
126	MRESULT EXPENTRY UrlDlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
127	{
128	URLDATA *urld;
129
130	switch (msg)
131	{
132	case WM_INITDLG:
133	if (mp2)
134	{
135	CHAR p, e, *pp;
136	SHORT count;
137
138	WinSetWindowPtr(hwnd, QWL_USER, mp2);
139	urld = mp2;
140	e = urld -> line + urld -> len + 1;
141	p = urld -> line;
142	do
143	{
144	p = strnstr(p, "http://", e - p);
145	if (p)
146	{
147	strncpy(urld -> url, p, min(e - p, SEARCHSTRINGLEN - 1));
148	urld -> url[min(e - p, SEARCHSTRINGLEN - 1)] = 0;
149	pp = urld -> url;
150	while (pp && pp != ' ' && pp != '\r' && pp != '\n' &&
151	*pp != '\"')
152	pp++;
153	*pp = 0;
154	WinSendDlgItemMsg(hwnd, URL_LISTBOX, LM_INSERTITEM,
155	MPFROM2SHORT(LIT_END, 0),
156	MPFROMP(urld -> url));
157	p++;
158	}
159	}
160	while (p && *p && p < e);
161	p = urld -> line;
162	do
163	{
164	p = strnstr(p, "ftp://", e - p);
165	if (p)
166	{
167	strncpy(urld -> url, p, min(e - p, SEARCHSTRINGLEN - 1));
168	urld -> url[min(e - p, SEARCHSTRINGLEN - 1)] = 0;
169	pp = urld -> url;
170	while (pp && pp != ' ' && pp != '\r' && pp != '\n' &&
171	*pp != '\"')
172	pp++;
173	*pp = 0;
174	WinSendDlgItemMsg(hwnd, URL_LISTBOX, LM_INSERTITEM,
175	MPFROM2SHORT(LIT_END, 0),
176	MPFROMP(urld -> url));
177	p++;
178	}
179	}
180	while (p && *p && p < e);
181	*urld -> url = 0;
182	count = (SHORT) WinSendDlgItemMsg(hwnd, URL_LISTBOX, LM_QUERYITEMCOUNT,
183	MPVOID, MPVOID);
184	if (count)
185	{
186	WinSendDlgItemMsg(hwnd, URL_LISTBOX, LM_SELECTITEM,
187	MPFROMSHORT(0), MPFROMSHORT(TRUE));
188	if (count == 1)
189	WinSendMsg(hwnd, WM_COMMAND, MPFROM2SHORT(DID_OK, 0), MPVOID);
190	else
191	PostMsg(hwnd, UM_SETUP, MPVOID, MPVOID);
192	break;
193	}
194	}
195	WinDismissDlg(hwnd, 0);
196	break;
197
198	case UM_SETUP:
199	WinShowWindow(hwnd, TRUE);
200	return 0;
201
202	case WM_CONTROL:
203	switch (SHORT1FROMMP(mp1))
204	{
205	case URL_LISTBOX:
206	switch (SHORT2FROMMP(mp1))
207	{
208	case LN_ENTER:
209	PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(DID_OK, 0), MPVOID);
210	break;
211	}
212	break;
213	}
214	return 0;
215
216	case WM_COMMAND:
217	switch (SHORT1FROMMP(mp1))
218	{
219	case URL_BOOKMARK:
220	WinDismissDlg(hwnd, 3);
221	break;
222
223	case DID_OK:
224	{
225	SHORT select;
226
227	urld = WinQueryWindowPtr(hwnd, QWL_USER);
228	if (urld)
229	{
230	select = (SHORT) WinSendDlgItemMsg(hwnd, URL_LISTBOX,
231	LM_QUERYSELECTION,
232	MPFROMSHORT(LIT_FIRST),
233	MPVOID);
234	if (select >= 0)
235	{
236	*urld -> url = 0;
237	WinSendDlgItemMsg(hwnd, URL_LISTBOX, LM_QUERYITEMTEXT,
238	MPFROM2SHORT(select, sizeof(urld -> url)),
239	MPFROMP(urld -> url));
240	if (*urld -> url)
241	{
242	if (!strncmp(urld -> url, "http://", 7))
243	{
244	WinDismissDlg(hwnd, 1);
245	break;
246	}
247	else if (!strncmp(urld -> url, "ftp://", 6))
248	{
249	memmove(urld -> url, urld -> url + 6, strlen(urld -> url) + 1);
250	if (*urld -> url)
251	{
252	WinDismissDlg(hwnd, 2);
253	break;
254	}
255	}
256	}
257	}
258	}
259	}
260	Runtime_Error(pszSrcFile, __LINE__, "no data");
261	break;
262
263	case DID_CANCEL:
264	WinDismissDlg(hwnd, 0);
265	break;
266
267	case IDM_HELP:
268	break;
269	}
270	return 0;
271	}
272	return WinDefDlgProc(hwnd, msg, mp1, mp2);
273	}
274
275	static ULONG NumLines(RECTL * rcl, VIEWDATA * ad)
276	{
277	ULONG numlines;
278
279	numlines = (rcl -> yTop - rcl -> yBottom) / ad -> lMaxHeight;
280	if (ad -> lMaxDescender && numlines &&
281	((rcl -> yTop - rcl -> yBottom) -
282	(numlines * ad -> lMaxHeight) <= ad -> lMaxDescender))
283	numlines--;
284	return numlines;
285	}
286
287	static CHAR **BuildAList(HWND hwnd)
288	{
289	VIEWDATA *ad = WinQueryWindowPtr(hwnd, QWL_USER);
290	register ULONG x, y, z = 0;
291	ULONG width;
292	RECTL Rectl;
293	CHAR **list = NULL, s[SEARCHSTRINGLEN], a;
294	register CHAR p, e;
295	INT numlines = 0, numalloc = 0;
296
297	if (ad && ad -> selected)
298	{
299	WinQueryWindowRect(hwnd, &Rectl);
300	width = (Rectl.xRight - Rectl.xLeft) / ad -> fattrs.lAveCharWidth;
301	if (!width && !ad -> hex)
302	return list;
303	for (x = 0; x < ad -> numlines; x++)
304	{
305	if (ad -> stopflag)
306	break;
307	if (ad -> markedlines[x] & VF_SELECTED)
308	{
309	if (ad -> hex)
310	{
311	width = ad -> textsize - (x * 16);
312	width = min(width, 16);
313	sprintf(s, "%08lx ", x * 16);
314	p = s + 9;
315	for (y = 0; y < width; y++)
316	{
317	sprintf(p, " %02hx", ad -> text[(x * 16) + y]);
318	p += 3;
319	}
320	*p = ' ';
321	p++;
322	*p = ' ';
323	p++;
324	for (y = 0; y < width; y++)
325	{
326	a = ad -> text[(x * 16) + y];
327	if (a && a != '\n' && a != '\r' && a != '\t' && a != '\x1a')
328	p = ad -> text[(x 16) + y];
329	else
330	*p = '.';
331	p++;
332	}
333	*p = 0;
334	}
335	else
336	{
337	if (!ad -> wrapon)
338	{
339	e = p = ad -> lines[x];
340	while (e != '\r' && e != '\n' && e < ad -> text + ad -> textsize)
341	e++;
342	/*
343	if((e == '\r' \|\| e == '\n') && e > p)
344	e--;
345	*/
346	width = e - p;
347	}
348	else
349	{
350	p = ad -> lines[x];
351	e = p + (width - 1);
352	if (e - ad -> text > ad -> textsize)
353	e = ad -> text + ad -> textsize;
354	while (p < e)
355	{
356	if (p == '\r' \|\| p == '\n')
357	{
358	e = p;
359	break;
360	}
361	p++;
362	}
363	}
364	strncpy(s, ad -> lines[x], e - ad -> lines[x]);
365	s[e - ad -> lines[x]] = 0;
366	}
367	if (AddToList(s, &list, &numlines, &numalloc))
368	break;
369	z++;
370	if (z >= ad -> selected)
371	break;
372	}
373	}
374	}
375	return list;
376	}
377
378	static CHAR **BuildAList2(HWND hwnd)
379	{
380	VIEWDATA *ad = WinQueryWindowPtr(hwnd, QWL_USER);
381	CHAR **list = NULL, s[SEARCHSTRINGLEN];
382	SHORT x, z;
383	INT numlines = 0, numalloc = 0;
384
385	if (ad)
386	{
387	z = (SHORT) WinSendDlgItemMsg(ad -> hwndFrame, NEWVIEW_LISTBOX,
388	LM_QUERYITEMCOUNT, MPVOID, MPVOID);
389	z = max(z, 0);
390	for (x = 0; x < z; x++)
391	{
392	if (ad -> stopflag)
393	break;
394	*s = 0;
395	WinSendDlgItemMsg(ad -> hwndFrame, NEWVIEW_LISTBOX, LM_QUERYITEMTEXT,
396	MPFROM2SHORT(x, SEARCHSTRINGLEN), MPFROMP(s));
397	if (*s)
398	if (AddToList(s, &list, &numlines, &numalloc))
399	break;
400	}
401	}
402	return list;
403	}
404
405	MRESULT EXPENTRY ViewStatusProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
406	{
407	switch (msg)
408	{
409	case WM_CREATE:
410	return CommonTextProc(hwnd, msg, mp1, mp2);
411
412	case WM_MOUSEMOVE:
413	{
414	USHORT id = WinQueryWindowUShort(hwnd, QWS_ID);
415
416	if (fOtherHelp)
417	{
418	if ((!hwndBubble \|\| WinQueryWindowULong(hwndBubble, QWL_USER) != hwnd) &&
419	!WinQueryCapture(HWND_DESKTOP))
420	{
421
422	char *s = NULL;
423
424	switch (id)
425	{
426	case NEWVIEW_STATUS2:
427	s = GetPString(IDS_NVSTATUS2HELPTEXT);
428	break;
429	case NEWVIEW_STATUS3:
430	s = GetPString(IDS_NVSTATUS3HELPTEXT);
431	break;
432	case NEWVIEW_DRAG:
433	s = GetPString(IDS_NVDRAGHELPTEXT);
434	break;
435	}
436	if (s && *s)
437	MakeBubble(hwnd, TRUE, s);
438	else if (hwndBubble)
439	WinDestroyWindow(hwndBubble);
440	}
441	}
442	switch (id)
443	{
444	case NEWVIEW_STATUS1:
445	break;
446	default:
447	return CommonTextButton(hwnd, msg, mp1, mp2);
448	}
449	}
450	break;
451
452	case WM_BUTTON3UP:
453	case WM_BUTTON1UP:
454	case WM_BUTTON1DOWN:
455	case WM_BUTTON3DOWN:
456	{
457	USHORT id;
458
459	id = WinQueryWindowUShort(hwnd, QWS_ID);
460	switch (id)
461	{
462	case NEWVIEW_STATUS1:
463	break;
464	default:
465	return CommonTextButton(hwnd, msg, mp1, mp2);
466	}
467	}
468	break;
469
470	case UM_CLICKED:
471	case UM_CLICKED3:
472	{
473	USHORT id = WinQueryWindowUShort(hwnd, QWS_ID), cmd = 0;
474
475	switch (id)
476	{
477	case NEWVIEW_DRAG:
478	if (msg == UM_CLICKED)
479	cmd = (msg == UM_CLICKED) ? IDM_HEXMODE : IDM_DESELECTALL;
480	break;
481	case NEWVIEW_STATUS2:
482	cmd = (msg == UM_CLICKED) ? IDM_GOTOLINE : IDM_FINDFIRST;
483	break;
484	case NEWVIEW_STATUS3:
485	cmd = (msg == UM_CLICKED) ? IDM_GOTOOFFSET : IDM_FINDNEXT;
486	break;
487	default:
488	break;
489	}
490	PostMsg(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
491	FID_CLIENT),
492	WM_COMMAND,
493	MPFROM2SHORT(cmd, 0),
494	MPVOID);
495	}
496	return 0;
497
498	case WM_BEGINDRAG:
499	{
500	USHORT id = WinQueryWindowUShort(hwnd, QWS_ID);
501
502	switch (id)
503	{
504	case NEWVIEW_STATUS1:
505	case NEWVIEW_DRAG:
506	{
507	VIEWDATA *ad = WinQueryWindowPtr(WinWindowFromID(
508	WinQueryWindow(hwnd,
509	QW_PARENT),
510	FID_CLIENT), 0);
511
512	if (ad)
513	DragOne(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
514	FID_CLIENT), (HWND) 0, ad -> filename, FALSE);
515	}
516	break;
517	default:
518	break;
519	}
520	}
521	break;
522
523	case WM_CONTEXTMENU:
524	PostMsg(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
525	FID_CLIENT),
526	UM_CONTEXTMENU,
527	MPVOID,
528	MPVOID);
529	break;
530
531	case WM_SETFOCUS:
532	if (mp2)
533	PostMsg(hwnd, UM_FOCUSME, MPVOID, MPVOID);
534	break;
535
536	case WM_PAINT:
537	{
538	USHORT id = WinQueryWindowUShort(hwnd, QWS_ID);
539	ULONG color;
540	VIEWDATA *ad = WinQueryWindowPtr(WinWindowFromID(WinQueryWindow(hwnd,
541	QW_PARENT), FID_CLIENT), 0);
542	SWP swp;
543	POINTL ptl;
544	HPS hps;
545
546	switch (id)
547	{
548	case NEWVIEW_STATUS1:
549	PaintRecessedWindow(hwnd, (HPS) 0, FALSE, FALSE);
550	break;
551	default:
552	PaintRecessedWindow(hwnd, (HPS) 0, TRUE, FALSE);
553	break;
554	}
555	hps = WinGetPS(WinQueryWindow(hwnd, QW_PARENT));
556	if (hps)
557	{
558	WinQueryWindowPos(hwnd, &swp);
559	ptl.x = swp.x - 1;
560	ptl.y = swp.y + swp.cy + 2;
561	GpiMove(hps, &ptl);
562	switch (id)
563	{
564	case NEWVIEW_STATUS1:
565	if (ad)
566	color = (standardcolors[ad -> colors[COLORS_NORMALBACK]] == CLR_WHITE) ?
567	CLR_PALEGRAY : CLR_WHITE;
568	else
569	color = CLR_WHITE;
570	break;
571	default:
572	if (ad)
573	color = (standardcolors[ad -> colors[COLORS_NORMALBACK]] == CLR_PALEGRAY) ?
574	CLR_DARKGRAY : CLR_PALEGRAY;
575	else
576	color = CLR_PALEGRAY;
577	break;
578	}
579	GpiSetColor(hps, color);
580	ptl.x = swp.x + swp.cx;
581	GpiLine(hps, &ptl);
582	WinReleasePS(hps);
583	}
584	}
585	break;
586
587	case UM_FOCUSME:
588	WinSetFocus(HWND_DESKTOP,
589	WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
590	FID_CLIENT));
591	return 0;
592	}
593	return PFNWPStatic(hwnd, msg, mp1, mp2);
594	}
595
596	static VOID FreeViewerMem(HWND hwnd)
597	{
598	VIEWDATA *ad = WinQueryWindowPtr(hwnd, QWL_USER);
599
600	if (ad)
601	{
602	ad -> selected = ad -> textsize = ad -> numlines = ad -> numalloc = 0;
603	if (ad -> text)
604	free(ad -> text);
605	if (ad -> lines)
606	free(ad -> lines);
607	if (ad -> markedlines)
608	free(ad -> markedlines);
609	ad -> text = NULL;
610	ad -> lines = NULL;
611	ad -> markedlines = NULL;
612	DosPostEventSem(CompactSem);
613	}
614	}
615
616	static HPS InitWindow(HWND hwnd)
617	{
618	VIEWDATA *ad = WinQueryWindowPtr(hwnd, QWL_USER);
619	HPS hps = (HPS) 0;
620	SIZEL sizel;
621	FONTMETRICS FontMetrics;
622
623	if (ad)
624	{
625	sizel.cx = sizel.cy = 0;
626	hps = GpiCreatePS(WinQueryAnchorBlock(hwnd), WinOpenWindowDC(hwnd),
627	(PSIZEL) & sizel, PU_PELS \| GPIF_DEFAULT \| GPIT_MICRO \|
628	GPIA_ASSOC);
629	if (hps)
630	{
631	GpiSetCp(hps, (ULONG) ad -> fattrs.usCodePage);
632	GpiCreateLogFont(hps, NULL, FIXED_FONT_LCID, &ad -> fattrs);
633	GpiSetCharSet(hps, FIXED_FONT_LCID);
634	GpiQueryFontMetrics(hps, (long) sizeof(FONTMETRICS), &FontMetrics);
635	ad -> fattrs.lAveCharWidth = FontMetrics.lAveCharWidth;
636	ad -> fattrs.lMaxBaselineExt = FontMetrics.lMaxBaselineExt;
637	ad -> lMaxAscender = max(FontMetrics.lMaxAscender, 0);
638	ad -> lMaxDescender = max(FontMetrics.lMaxDescender, 0);
639	ad -> lMaxHeight = ad -> lMaxAscender + ad -> lMaxDescender;
640	if (ad -> fattrs.usCodePage != FontMetrics.usCodePage)
641	{
642	ad -> fattrs.usCodePage = FontMetrics.usCodePage;
643	Codepage = ad -> fattrs.usCodePage;
644	PrfWriteProfileData(fmprof,
645	appname,
646	"Viewer.Codepage",
647	&ad -> fattrs.usCodePage,
648	sizeof(USHORT));
649	}
650	else if (ad -> fattrs.usCodePage)
651	{
652
653	HMQ hmq;
654	ULONG cps[50], len, x;
655
656	if (!DosQueryCp(sizeof(cps), cps, &len))
657	{
658	for (x = 0; x < len / sizeof(ULONG); x++)
659	{
660	if (cps[x] == (ULONG) ad -> fattrs.usCodePage)
661	{
662	hmq = WinQueryWindowULong(hwnd, QWL_HMQ);
663	WinSetCp(hmq, ad -> fattrs.usCodePage);
664	break;
665	}
666	}
667	}
668	DosSetProcessCp((ULONG) ad -> fattrs.usCodePage);
669	}
670	GpiSetBackMix(hps, BM_OVERPAINT);
671	SetPresParamFromFattrs(WinWindowFromID(ad -> hwndFrame, NEWVIEW_LISTBOX),
672	&ad -> fattrs, FontMetrics.sNominalPointSize,
673	MAKEFIXED(FontMetrics.sNominalPointSize / 10, 0));
674	}
675	}
676	return (hps);
677	}
678
679	static VOID PaintLine(HWND hwnd, HPS hps, ULONG whichline, ULONG topline,
680	RECTL * Rectl)
681	{
682	VIEWDATA *ad = WinQueryWindowPtr(hwnd, QWL_USER);
683	POINTL ptl;
684	ULONG width;
685	register CHAR p, e;
686	CHAR marker[] = " >";
687	RECTL rcl2;
688
689	if (ad && (ad -> hex \|\| ad -> lines))
690	{
691	ptl.y = (Rectl -> yTop - (ad -> lMaxHeight *
692	(((whichline + 1) - topline) + 1)));
693	ptl.x = 0;
694	GpiMove(hps, &ptl);
695	GpiSetBackMix(hps, BM_OVERPAINT);
696	if (ad -> markedlines)
697	{
698	if (ad -> markedlines[whichline] & VF_SELECTED)
699	{
700	GpiSetColor(hps, ((ad -> markedlines[whichline] & VF_FOUND) != 0) ?
701	standardcolors[ad -> colors[COLORS_SELECTEDFOUNDFORE]] :
702	standardcolors[ad -> colors[COLORS_SELECTEDFORE]]);
703	GpiSetBackColor(hps, (whichline == ad -> cursored - 1) ?
704	standardcolors[ad -> colors[COLORS_CURSOREDSELECTEDBACK]] :
705	standardcolors[ad -> colors[COLORS_SELECTEDBACK]]);
706	}
707	else if (ad -> markedlines[whichline] & VF_FOUND)
708	{
709	GpiSetColor(hps, standardcolors[ad -> colors[COLORS_FOUNDFORE]]);
710	GpiSetBackColor(hps, (whichline == ad -> cursored - 1) ?
711	standardcolors[ad -> colors[COLORS_CURSOREDNORMALBACK]] :
712	standardcolors[ad -> colors[COLORS_NORMALBACK]]);
713	}
714	else
715	{
716	GpiSetColor(hps, standardcolors[ad -> colors[COLORS_NORMALFORE]]);
717	GpiSetBackColor(hps, (whichline == ad -> cursored - 1) ?
718	standardcolors[ad -> colors[COLORS_CURSOREDNORMALBACK]] :
719	standardcolors[ad -> colors[COLORS_NORMALBACK]]);
720	}
721	}
722	else
723	{
724	GpiSetColor(hps, standardcolors[ad -> colors[COLORS_NORMALFORE]]);
725	GpiSetBackColor(hps, (whichline == ad -> cursored - 1) ?
726	standardcolors[ad -> colors[COLORS_CURSOREDNORMALBACK]] :
727	standardcolors[ad -> colors[COLORS_NORMALBACK]]);
728	}
729	if (!ad -> hex)
730	{
731	if (ad -> wrapon)
732	{
733	width = (Rectl -> xRight - Rectl -> xLeft) / ad -> fattrs.lAveCharWidth;
734	if (width)
735	{
736	GpiCharString(hps, 1, marker + (whichline == ad -> cursored - 1));
737	p = ad -> lines[whichline];
738	e = p + (width - 1);
739	if (e - ad -> text > ad -> textsize)
740	e = ad -> text + ad -> textsize;
741	while (p < e)
742	{
743	if (p == '\r' \|\| p == '\n')
744	{
745	e = p;
746	break;
747	}
748	p++;
749	}
750	if (ad -> ftpin && whichline != ad -> cursored - 1 && (!ad -> markedlines \|\|
751	!(ad -> markedlines[whichline] & (VF_SELECTED \| VF_FOUND))) &&
752	strnstr(ad -> lines[whichline], "ftp://", e - ad -> lines[whichline]))
753	{
754	GpiSetColor(hps, standardcolors[ad -> colors[COLORS_FTPFORE]]);
755	GpiSetBackColor(hps, standardcolors[ad -> colors[COLORS_FTPBACK]]);
756	}
757	if (ad -> httpin && whichline != ad -> cursored - 1 && (!ad -> markedlines \|\|
758	!(ad -> markedlines[whichline] & (VF_SELECTED \| VF_FOUND))) &&
759	strnstr(ad -> lines[whichline], "http://", e - ad -> lines[whichline]))
760	{
761	GpiSetColor(hps, standardcolors[ad -> colors[COLORS_HTTPFORE]]);
762	GpiSetBackColor(hps, standardcolors[ad -> colors[COLORS_HTTPBACK]]);
763	}
764	rcl2 = *Rectl;
765	rcl2.yTop = ptl.y + ad -> lMaxAscender;
766	rcl2.yBottom = ptl.y - ad -> lMaxDescender;
767	GpiCharString(hps, e - ad -> lines[whichline], ad -> lines[whichline]);
768	GpiQueryCurrentPosition(hps, &ptl);
769	rcl2.xLeft = ptl.x;
770	WinFillRect(hps, &rcl2,
771	standardcolors[ad -> colors[COLORS_NORMALBACK]]);
772	}
773	}
774	else
775	{
776	width = (Rectl -> xRight - Rectl -> xLeft) / ad -> fattrs.lAveCharWidth;
777	if (width)
778	{
779	GpiCharString(hps, 1, marker + (whichline == ad -> cursored - 1));
780	p = ad -> lines[whichline];
781	e = p + (abs(ad -> horzscroll) / ad -> fattrs.lAveCharWidth);
782	if (e - ad -> text > ad -> textsize)
783	e = ad -> text + ad -> textsize;
784	while (p < e)
785	{
786	if (p == '\r' \|\| p == '\n')
787	break;
788	p++;
789	}
790	if (p != '\r' && p != '\n')
791	{
792
793	CHAR *pp;
794
795	e = p + (width - 1);
796	if (e - ad -> text > ad -> textsize)
797	e = ad -> text + ad -> textsize;
798	pp = p;
799	while (pp < e)
800	{
801	if (pp == '\r' \|\| pp == '\n')
802	{
803	e = pp;
804	break;
805	}
806	pp++;
807	}
808	}
809	else
810	e = p;
811	if (ad -> ftpin && whichline != ad -> cursored - 1 && (!ad -> markedlines \|\|
812	!(ad -> markedlines[whichline] & (VF_SELECTED \| VF_FOUND))) &&
813	strnstr(ad -> lines[whichline], "ftp://", e - ad -> lines[whichline]))
814	{
815	GpiSetColor(hps, standardcolors[ad -> colors[COLORS_FTPFORE]]);
816	GpiSetBackColor(hps, standardcolors[ad -> colors[COLORS_FTPBACK]]);
817	}
818	if (ad -> httpin && whichline != ad -> cursored - 1 && (!ad -> markedlines \|\|
819	!(ad -> markedlines[whichline] & (VF_SELECTED \| VF_FOUND))) &&
820	strnstr(ad -> lines[whichline], "http://", e - ad -> lines[whichline]))
821	{
822	GpiSetColor(hps, standardcolors[ad -> colors[COLORS_HTTPFORE]]);
823	GpiSetBackColor(hps, standardcolors[ad -> colors[COLORS_HTTPBACK]]);
824	}
825	rcl2 = *Rectl;
826	rcl2.yTop = ptl.y + ad -> lMaxAscender;
827	rcl2.yBottom = ptl.y - ad -> lMaxDescender;
828	GpiCharString(hps, e - p, p);
829	GpiQueryCurrentPosition(hps, &ptl);
830	rcl2.xLeft = ptl.x;
831	WinFillRect(hps, &rcl2,
832	standardcolors[ad -> colors[COLORS_NORMALBACK]]);
833	}
834	}
835	}
836	else
837	{
838
839	CHAR s[80];
840	register ULONG x;
841
842	rcl2 = *Rectl;
843	rcl2.yTop = ptl.y + ad -> lMaxAscender;
844	rcl2.yBottom = ptl.y - ad -> lMaxDescender;
845	GpiCharString(hps, 1, marker + (whichline == ad -> cursored - 1));
846	width = ad -> textsize - (whichline * 16);
847	width = min(width, 16);
848	sprintf(s,
849	"%08lx ",
850	whichline * 16);
851	p = s + 9;
852	for (x = 0; x < width; x++)
853	{
854	sprintf(p,
855	" %02hx",
856	ad -> text[(whichline * 16) + x]);
857	p += 3;
858	}
859	for (; x < 16; x++)
860	{
861	*p = ' ';
862	p++;
863	*p = ' ';
864	p++;
865	*p = ' ';
866	p++;
867	}
868	*p = ' ';
869	p++;
870	*p = ' ';
871	p++;
872	for (x = 0; x < width; x++)
873	{
874	p = ad -> text[(whichline 16) + x];
875	p++;
876	}
877	*p = 0;
878	GpiCharString(hps, (p - s) - (abs(ad -> horzscroll) /
879	ad -> fattrs.lAveCharWidth),
880	s + (abs(ad -> horzscroll) / ad -> fattrs.lAveCharWidth));
881	GpiQueryCurrentPosition(hps, &ptl);
882	if (ptl.x + abs(ad -> horzscroll) + ad -> fattrs.lAveCharWidth + 1 > ad -> maxx)
883	{
884	ad -> maxx = ptl.x + abs(ad -> horzscroll) + ad -> fattrs.lAveCharWidth + 1;
885	WinSendMsg(ad -> hhscroll, SBM_SETTHUMBSIZE,
886	MPFROM2SHORT((SHORT) Rectl -> xRight, (SHORT) ad -> maxx),
887	MPVOID);
888	}
889	rcl2.xLeft = ptl.x;
890	WinFillRect(hps, &rcl2, standardcolors[ad -> colors[COLORS_NORMALBACK]]);
891	}
892	}
893	}
894
895	static VOID Search(VOID * args)
896	{
897	HWND hwnd = (HWND) args;
898	HAB hab2;
899	HMQ hmq2;
900	VIEWDATA *ad;
901	register CHAR *p;
902	RECTL Rectl;
903	ULONG width, numlines, lastline, whichline, firstline = ULONG_MAX;
904	register ULONG x;
905	CHAR s[SEARCHSTRINGLEN], s2[SEARCHSTRINGLEN], t, n, markwith;
906
907	priority_normal();
908	hab2 = WinInitialize(0);
909	if (hab2)
910	{
911	hmq2 = WinCreateMsgQueue(hab2, 0);
912	if (hmq2)
913	{
914	WinCancelShutdown(hmq2, TRUE);
915	ad = WinQueryWindowPtr(hwnd, QWL_USER);
916	if (ad)
917	{
918	if (!DosRequestMutexSem(ad -> ScanSem, SEM_INDEFINITE_WAIT))
919	{
920	markwith = VF_FOUND \| ((ad -> alsoselect) ? VF_SELECTED : 0);
921	strcpy(s, ad -> searchtext);
922	if (*s)
923	{
924	WinQueryWindowRect(hwnd, &Rectl);
925	width = (Rectl.xRight - Rectl.xLeft) / ad -> fattrs.lAveCharWidth;
926	numlines = NumLines(&Rectl, ad);
927	WinSetWindowText(WinWindowFromID(ad -> hwndFrame,
928	NEWVIEW_STATUS1),
929	GetPString(IDS_SEARCHINGTEXT));
930	if (numlines && width && ad -> markedlines && ad -> numlines &&
931	ad -> text && ad -> textsize)
932	{
933	for (x = 0; x < ad -> numlines && !ad -> stopflag; x++)
934	ad -> markedlines[x] &= (~VF_FOUND);
935	ad -> found = 0;
936	t = s;
937	while (t && !ad -> stopflag)
938	{
939	lastline = 1;
940	n = convert_nl_to_nul(t);
941	if (*t)
942	{
943	strcpy(s2, t);
944	if (ad -> literalsearch)
945	literal(s2);
946	p = ad -> text;
947	while (p && !ad -> stopflag)
948	{
949	p = findstring(s2, strlen(s2), p,
950	ad -> textsize - (p - ad -> text),
951	ad -> sensitive);
952	if (p)
953	{
954	if (ad -> hex)
955	{
956	whichline = (p - ad -> text) / 16;
957	if (whichline < firstline)
958	firstline = whichline;
959	if (!(ad -> markedlines[whichline] & VF_FOUND))
960	ad -> found++;
961	if (markwith & VF_SELECTED)
962	{
963	if (!(ad -> markedlines[whichline] & VF_SELECTED))
964	ad -> selected++;
965	}
966	ad -> markedlines[whichline] \|= markwith;
967	if ((p - ad -> text) + strlen(s2) > (whichline + 1) * 16)
968	{
969	whichline++;
970	if (!(ad -> markedlines[whichline] & VF_FOUND))
971	ad -> found++;
972	if (markwith & VF_SELECTED)
973	{
974	if (!(ad -> markedlines[whichline] & VF_SELECTED))
975	ad -> selected++;
976	}
977	ad -> markedlines[whichline] \|= markwith;
978	}
979	p = ad -> text + ((whichline + 1) * 16);
980	if (p >= ad -> text + ad -> textsize)
981	break;
982	}
983	else
984	{
985	for (x = lastline; x < ad -> numlines; x++)
986	{
987	if (ad -> lines[x] > p)
988	{
989	if (x - 1 < firstline)
990	firstline = x - 1;
991	if (!(ad -> markedlines[x - 1] & VF_FOUND))
992	ad -> found++;
993	if (markwith & VF_SELECTED)
994	{
995	if (!(ad -> markedlines[x - 1] & VF_SELECTED))
996	ad -> selected++;
997	}
998	ad -> markedlines[x - 1] \|= markwith;
999	if (x + 1 < ad -> numlines &&
1000	p + strlen(s2) > ad -> lines[x])
1001	{
1002	x++;
1003	if (!(ad -> markedlines[x - 1] & VF_FOUND))
1004	ad -> found++;
1005	if (markwith & VF_SELECTED)
1006	{
1007	if (!(ad -> markedlines[x - 1] & VF_SELECTED))
1008	ad -> selected++;
1009	}
1010	ad -> markedlines[x - 1] \|= markwith;
1011	}
1012	lastline = x;
1013	p = ad -> lines[x];
1014	break;
1015	}
1016	}
1017	if (x >= ad -> numlines)
1018	{
1019	if (markwith & VF_SELECTED)
1020	{
1021	if (!(ad -> markedlines[numlines - 1] & VF_SELECTED))
1022	ad -> selected++;
1023	if (!(ad -> markedlines[numlines - 1] & VF_FOUND))
1024	ad -> found++;
1025	}
1026	ad -> markedlines[ad -> numlines - 1] \|= markwith;
1027	break;
1028	}
1029	}
1030	}
1031	}
1032	}
1033	t = n;
1034	}
1035	}
1036	DosReleaseMutexSem(ad -> ScanSem);
1037	if (!ad -> stopflag && firstline == ULONG_MAX)
1038	{
1039	DosBeep(50, 50);
1040	WinSetWindowText(WinWindowFromID(ad -> hwndFrame,
1041	NEWVIEW_STATUS1),
1042	GetPString(IDS_NOMATCHINGTEXT));
1043	DosSleep(1500);
1044	PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
1045	PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
1046	}
1047	else if (!ad -> stopflag)
1048	{
1049	PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
1050	PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
1051	PostMsg(hwnd, UM_CONTAINER_FILLED,
1052	MPFROMLONG(firstline + 1),
1053	MPFROMLONG(firstline + 1));
1054	}
1055	}
1056	else
1057	DosReleaseMutexSem(ad -> ScanSem);
1058	}
1059	}
1060	WinDestroyMsgQueue(hmq2);
1061	}
1062	WinTerminate(hab2);
1063	}
1064	DosPostEventSem(CompactSem);
1065	}
1066
1067	static VOID Clipboard(VOID * args)
1068	{
1069	HWND hwnd = (HWND) args;
1070	HAB hab2;
1071	HMQ hmq2;
1072	VIEWDATA *ad;
1073	CHAR **list;
1074	USHORT cmd;
1075	register ULONG x;
1076	BOOL released = FALSE;
1077
1078	priority_normal();
1079	hab2 = WinInitialize(0);
1080	if (hab2)
1081	{
1082	hmq2 = WinCreateMsgQueue(hab2, 0);
1083	if (hmq2)
1084	{
1085	WinCancelShutdown(hmq2, TRUE);
1086	ad = WinQueryWindowPtr(hwnd, QWL_USER);
1087	if (ad)
1088	{
1089	if (!DosRequestMutexSem(ad -> ScanSem, SEM_INDEFINITE_WAIT))
1090	{
1091	cmd = ad -> cliptype;
1092	if (ad -> numlines && ad -> text && ad -> textsize && ad -> markedlines &&
1093	!ad -> stopflag)
1094	{
1095	WinSetWindowText(WinWindowFromID(ad -> hwndFrame,
1096	NEWVIEW_STATUS1),
1097	GetPString(IDS_BUILDINGLINELISTTEXT));
1098	if (cmd == IDM_SAVETOCLIP \|\| cmd == IDM_APPENDTOCLIP \|\|
1099	cmd == IDM_SAVETOLIST)
1100	list = BuildAList(hwnd);
1101	else
1102	list = BuildAList2(hwnd);
1103	if (list)
1104	{
1105	if (!ad -> stopflag)
1106	{
1107	WinSetWindowText(WinWindowFromID(ad -> hwndFrame,
1108	NEWVIEW_STATUS1),
1109	(cmd == IDM_SAVETOCLIP \|\|
1110	cmd == IDM_SAVETOCLIP2) ?
1111	GetPString(IDS_SAVETOCLIPTEXT) :
1112	(cmd == IDM_APPENDTOCLIP \|\|
1113	cmd == IDM_APPENDTOCLIP2) ?
1114	GetPString(IDS_APPENDTOCLIPTEXT) :
1115	GetPString(IDS_WRITETOFILETEXT));
1116	DosReleaseMutexSem(ad -> ScanSem);
1117	released = TRUE;
1118	if (cmd == IDM_SAVETOCLIP \|\| cmd == IDM_APPENDTOCLIP \|\|
1119	cmd == IDM_SAVETOCLIP2 \|\| cmd == IDM_APPENDTOCLIP2)
1120	ListToClipboardHab(hab2, list, (cmd == IDM_APPENDTOCLIP \|\|
1121	cmd == IDM_APPENDTOCLIP2));
1122	else
1123	{
1124
1125	FILE *fp;
1126	CHAR filename[CCHMAXPATH];
1127
1128	*filename = 0;
1129	if (export_filename(hwnd, filename, FALSE))
1130	{
1131	fp = _fsopen(filename, "a+", SH_DENYWR);
1132	if (!fp) {
1133	saymsg(MB_CANCEL,
1134	hwnd,
1135	GetPString(IDS_ERRORTEXT),
1136	GetPString(IDS_CANTOPENFORWRITETEXT),
1137	filename);
1138	}
1139	else {
1140	fseek(fp, 0L, SEEK_END);
1141	for (x = 0; list[x]; x++)
1142	fprintf(fp,
1143	"%s\n",
1144	list[x]);
1145	fclose(fp);
1146	}
1147	}
1148	}
1149	}
1150	FreeList(list);
1151	}
1152	else
1153	{
1154	DosReleaseMutexSem(ad -> ScanSem);
1155	released = TRUE;
1156	DosBeep(50, 100);
1157	WinSetWindowText(WinWindowFromID(ad -> hwndFrame,
1158	NEWVIEW_STATUS1),
1159	GetPString(IDS_NVNOLINESSELTEXT));
1160	DosSleep(1500);
1161	}
1162	}
1163	if (!released)
1164	DosReleaseMutexSem(ad -> ScanSem);
1165	PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
1166	}
1167	}
1168	WinDestroyMsgQueue(hmq2);
1169	}
1170	WinTerminate(hab2);
1171	}
1172	DosPostEventSem(CompactSem);
1173	}
1174
1175	static VOID ReLine(VOID * args)
1176	{
1177	HWND hwnd = (HWND) args;
1178	HAB hab2;
1179	HMQ hmq2;
1180	VIEWDATA *ad;
1181	CHAR p, pp, e, whereiam = NULL;
1182	RECTL Rectl;
1183	ULONG width, numlines, firstline = 1, cursored = 1;
1184
1185	priority_normal();
1186	hab2 = WinInitialize(0);
1187	if (hab2)
1188	{
1189	hmq2 = WinCreateMsgQueue(hab2, 0);
1190	if (hmq2)
1191	{
1192	WinCancelShutdown(hmq2, TRUE);
1193	ad = WinQueryWindowPtr(hwnd, QWL_USER);
1194	if (ad)
1195	{
1196	ad -> relining = TRUE;
1197	if (!DosRequestMutexSem(ad -> ScanSem, SEM_INDEFINITE_WAIT))
1198	{
1199	ad -> busy++;
1200	ad -> maxx = 0;
1201	if (ad -> text && ad -> textsize)
1202	{
1203	if (ad -> hex)
1204	{
1205	firstline = ad -> topline;
1206	cursored = ad -> cursored;
1207	}
1208	else if (ad -> lines)
1209	whereiam = ad -> lines[ad -> cursored - 1];
1210	ad -> found = 0;
1211	ad -> selected = ad -> numlines = ad -> numalloc = 0;
1212	if (ad -> lines)
1213	free(ad -> lines);
1214	if (ad -> markedlines)
1215	free(ad -> markedlines);
1216	ad -> lines = NULL;
1217	ad -> markedlines = NULL;
1218	WinSetWindowText(WinWindowFromID(ad -> hwndFrame,
1219	NEWVIEW_STATUS1),
1220	GetPString(IDS_FORMATTINGTEXT));
1221	if (!ad -> hex)
1222	{
1223	if (WinSendDlgItemMsg(ad -> hwndFrame, NEWVIEW_LISTBOX,
1224	LM_QUERYITEMCOUNT, MPVOID, MPVOID))
1225	{
1226	WinSendDlgItemMsg(ad -> hwndFrame, NEWVIEW_LISTBOX, LM_DELETEALL,
1227	MPVOID, MPVOID);
1228	PostMsg(ad -> hwndFrame, WM_UPDATEFRAME,
1229	MPFROMLONG(FCF_SIZEBORDER), MPVOID);
1230	}
1231	}
1232	WinSetFocus(HWND_DESKTOP, hwnd);
1233	if (!ad -> hex)
1234	{
1235	WinQueryWindowRect(hwnd, &Rectl);
1236	width = (Rectl.xRight - Rectl.xLeft) / ad -> fattrs.lAveCharWidth;
1237	numlines = NumLines(&Rectl, ad);
1238	ad -> oldwidth = width;
1239	p = ad -> text;
1240	if (width)
1241	{
1242	while (p - ad -> text < ad -> textsize && !ad -> stopflag)
1243	{
1244	if (ad -> wrapon)
1245	{
1246	e = p + (width - 1);
1247	if (e - ad -> text > ad -> textsize)
1248	e = ad -> text + ad -> textsize;
1249	pp = p;
1250	while (pp < e)
1251	{
1252	if (pp == '\r' \|\| pp == '\n')
1253	{
1254	e = pp;
1255	break;
1256	}
1257	pp++;
1258	}
1259	}
1260	else
1261	{
1262	pp = p;
1263	while (pp - ad -> text < ad -> textsize &&
1264	pp != '\r' && pp != '\n')
1265	pp++;
1266	e = pp;
1267	if (ad -> maxx <
1268	(((e - p) + 1) * ad -> fattrs.lAveCharWidth) + 1)
1269	ad -> maxx = (((e - p) + 1) *
1270	ad -> fattrs.lAveCharWidth) + 1;
1271	}
1272	if (whereiam && p >= whereiam && e <= whereiam)
1273	{
1274	cursored = firstline = ad -> numlines + 1;
1275	whereiam = NULL;
1276	}
1277	/* assign ad->lines[ad->numlines] */
1278	if (ad -> numlines + 1 > ad -> numalloc)
1279	{
1280
1281	CHAR **temp;
1282
1283	temp = xrealloc(ad -> lines, sizeof(CHAR )
1284	(ad -> numalloc + 256),pszSrcFile,__LINE__);
1285	if (!temp)
1286	break;
1287	ad -> lines = temp;
1288	ad -> numalloc += 256;
1289	}
1290	ad -> lines[ad -> numlines] = p;
1291	ad -> numlines++;
1292	if (ad -> numlines == numlines)
1293	{
1294	/* display first page */
1295	register INT x;
1296
1297	for (x = 0; x < ad -> numlines; x++)
1298	{
1299	if ((LONG) (Rectl.yTop -
1300	(ad -> lMaxHeight * (((x + 1) -
1301	ad -> topline) + 1))) < 0)
1302	break;
1303	PaintLine(hwnd, ad -> hps, x, 1, &Rectl);
1304	}
1305	}
1306	p = e;
1307	if (p - ad -> text < ad -> textsize)
1308	{
1309	if (*p == '\r')
1310	p++;
1311	}
1312	if (p - ad -> text < ad -> textsize)
1313	{
1314	if (*p == '\n')
1315	p++;
1316	}
1317	}
1318	}
1319	if (ad -> numalloc != ad -> numlines)
1320	{
1321
1322	CHAR **temp;
1323
1324	temp = xrealloc(ad -> lines, sizeof(CHAR ) ad -> numlines,pszSrcFile,__LINE__);
1325	if (temp)
1326	{
1327	ad -> lines = temp;
1328	ad -> numalloc = ad -> numlines;
1329	}
1330	}
1331	}
1332	else
1333	{
1334	ad -> numlines = ad -> textsize / 16;
1335	if (ad -> numlines * 16 < ad -> textsize)
1336	ad -> numlines++;
1337	}
1338	if (ad -> numlines)
1339	{
1340	ad -> markedlines = xmalloc(ad -> numlines,pszSrcFile,__LINE__);
1341	if (ad -> markedlines)
1342	{
1343	memset(ad -> markedlines, 0, ad -> numlines);
1344	ad -> selected = 0;
1345	}
1346	if (*ftprun && !ad -> ignoreftp && strstr(ad -> text, "ftp://"))
1347	ad -> ftpin = TRUE;
1348	if (*httprun && !ad -> ignorehttp && strstr(ad -> text, "http://"))
1349	ad -> httpin = TRUE;
1350	}
1351	}
1352	DosReleaseMutexSem(ad -> ScanSem);
1353	PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
1354	PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
1355	ad -> busy--;
1356	}
1357	}
1358	WinDestroyMsgQueue(hmq2);
1359	}
1360	WinTerminate(hab2);
1361	}
1362	DosPostEventSem(CompactSem);
1363	if (ad && !ad -> stopflag)
1364	{
1365	PostMsg(hwnd, UM_CONTAINER_FILLED, MPFROMLONG(firstline),
1366	MPFROMLONG(cursored));
1367	ad -> relining = FALSE;
1368	}
1369	}
1370
1371	static VOID LoadFile(VOID * args)
1372	{
1373	HWND hwnd = (HWND) args;
1374	HAB hab2;
1375	HMQ hmq2;
1376	VIEWDATA *ad;
1377	HFILE handle;
1378	ULONG action, len;
1379	APIRET rc;
1380	BOOL error = TRUE;
1381
1382	hab2 = WinInitialize(0);
1383	if (hab2)
1384	{
1385	hmq2 = WinCreateMsgQueue(hab2, 0);
1386	if (hmq2)
1387	{
1388	WinCancelShutdown(hmq2, TRUE);
1389	ad = WinQueryWindowPtr(hwnd, QWL_USER);
1390	if (ad)
1391	{
1392	if (!DosRequestMutexSem(ad -> ScanSem, SEM_INDEFINITE_WAIT))
1393	{
1394	ad -> busy++;
1395	priority_normal();
1396	if (*ad -> filename)
1397	{
1398	if (ad -> text)
1399	free(ad -> text);
1400	if (ad -> lines)
1401	free(ad -> lines);
1402	if (ad -> markedlines)
1403	free(ad -> markedlines);
1404	ad -> text = NULL;
1405	ad -> lines = NULL;
1406	ad -> markedlines = NULL;
1407	ad -> ftpin = ad -> httpin = FALSE;
1408	ad -> selected = ad -> numlines = ad -> textsize = ad -> numalloc = 0;
1409	WinSendDlgItemMsg(ad -> hwndFrame, NEWVIEW_LISTBOX, LM_DELETEALL,
1410	MPVOID, MPVOID);
1411	PostMsg(ad -> hwndFrame, WM_UPDATEFRAME,
1412	MPFROMLONG(FCF_SIZEBORDER), MPVOID);
1413	WinSetFocus(HWND_DESKTOP, hwnd);
1414	rc = DosOpen(ad -> filename, &handle, &action, 0L, 0L,
1415	OPEN_ACTION_FAIL_IF_NEW \| OPEN_ACTION_OPEN_IF_EXISTS,
1416	OPEN_FLAGS_FAIL_ON_ERROR \| OPEN_FLAGS_NOINHERIT \|
1417	OPEN_FLAGS_SEQUENTIAL \| OPEN_SHARE_DENYNONE \|
1418	OPEN_ACCESS_READONLY, 0L);
1419	if (rc) {
1420	Dos_Error(MB_CANCEL,
1421	rc,
1422	hwnd,
1423	pszSrcFile,
1424	__LINE__,
1425	GetPString(IDS_COMPCANTOPENTEXT),
1426	ad -> filename);
1427	}
1428	else {
1429	DosChgFilePtr(handle, 0L, FILE_END, &len);
1430	DosChgFilePtr(handle, 0L, FILE_BEGIN, &action);
1431	if (!len) {
1432	saymsg(MB_CANCEL,
1433	hwnd,
1434	GetPString(IDS_ERRORTEXT),
1435	GetPString(IDS_ZEROLENGTHTEXT),
1436	ad -> filename);
1437	}
1438	else {
1439	ad -> text = xmalloc(len + 2,pszSrcFile,__LINE__);
1440	if (ad -> text)
1441	{
1442	*ad -> text = 0;
1443	ad -> text[len] = 0;
1444	rc = DosRead(handle, ad -> text, len, &ad -> textsize);
1445	if (rc) {
1446	Dos_Error(MB_CANCEL,
1447	rc,
1448	hwnd,
1449	pszSrcFile,
1450	__LINE__,
1451	GetPString(IDS_ERRORREADINGTEXT),
1452	ad -> filename);
1453	free(ad -> text);
1454	ad -> text = NULL;
1455	ad -> textsize = 0;
1456	}
1457	else {
1458	ad -> text[ad -> textsize] = 0;
1459	if (!ad -> hex && !(ad -> flags & (8 \| 16)) && ad -> textsize)
1460	{
1461	ULONG x;
1462	x = min(512, ad -> textsize);
1463	if (fGuessType && IsBinary(ad -> text, x))
1464	ad -> hex = TRUE;
1465	}
1466	if (ad -> textsize) {
1467	if (_beginthread(ReLine, NULL, 524288, (PVOID) hwnd) == -1)
1468	Runtime_Error(pszSrcFile, __LINE__, GetPString(IDS_COULDNTSTARTTHREADTEXT));
1469	else
1470	error = FALSE;
1471	}
1472	}
1473	}
1474	}
1475	DosClose(handle);
1476	}
1477	}
1478	ad -> busy--;
1479	DosReleaseMutexSem(ad -> ScanSem);
1480	}
1481	}
1482	WinDestroyMsgQueue(hmq2);
1483	}
1484	WinTerminate(hab2);
1485	}
1486	if (error)
1487	PostMsg(hwnd, UM_CONTAINER_FILLED, MPVOID, MPVOID);
1488	DosPostEventSem(CompactSem);
1489	}
1490
1491	MRESULT EXPENTRY ViewFrameWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
1492	{
1493	PFNWP oldproc = (PFNWP) WinQueryWindowPtr(hwnd, QWL_USER);
1494
1495	switch (msg)
1496	{
1497	case WM_CHAR:
1498	shiftstate = (SHORT1FROMMP(mp1) & (KC_SHIFT \| KC_ALT \| KC_CTRL));
1499	break;
1500
1501	case WM_CONTROL:
1502	switch (SHORT1FROMMP(mp1))
1503	{
1504	case NEWVIEW_LISTBOX:
1505	return WinSendMsg(WinWindowFromID(hwnd, FID_CLIENT), UM_CONTROL,
1506	mp1, mp2);
1507	}
1508	break;
1509
1510	case WM_CALCFRAMERECT:
1511	{
1512	MRESULT mr;
1513	PRECTL prectl;
1514	SHORT sSelect;
1515
1516	mr = oldproc(hwnd, msg, mp1, mp2);
1517
1518	/*
1519	* Calculate the position of the client rectangle.
1520	* Otherwise, we'll see a lot of redraw when we move the
1521	* client during WM_FORMATFRAME.
1522	*/
1523
1524	if (mr && mp2)
1525	{
1526	prectl = (PRECTL) mp1;
1527	prectl -> yBottom += 22;
1528	prectl -> yTop -= 22;
1529	sSelect = (SHORT) WinSendDlgItemMsg(hwnd, NEWVIEW_LISTBOX,
1530	LM_QUERYITEMCOUNT,
1531	MPVOID, MPVOID);
1532	if (sSelect > 0)
1533	prectl -> yTop -= 48;
1534	}
1535	return mr;
1536	}
1537
1538	case WM_FORMATFRAME:
1539	{
1540	SHORT sCount, soldCount, sSelect;
1541	PSWP pswp, pswpClient, pswpNew1, pswpNew2, pswpNew3, pswpList, pswpScroll,
1542	pswpNew4, pswpUp, pswpDn;
1543
1544	sCount = (SHORT) oldproc(hwnd, msg, mp1, mp2);
1545	soldCount = sCount;
1546
1547	/*
1548	* Reformat the frame to "squeeze" the client
1549	* and make room for status window sibling beneath
1550	*/
1551
1552	pswp = (PSWP) mp1;
1553	{
1554	SHORT x;
1555
1556	for (x = 0; x < sCount; x++)
1557	{
1558	if (WinQueryWindowUShort(pswp -> hwnd, QWS_ID) == FID_CLIENT)
1559	{
1560	pswpClient = pswp;
1561	break;
1562	}
1563	pswp++;
1564	}
1565	}
1566	pswpNew1 = (PSWP) mp1 + soldCount;
1567	pswpNew2 = (PSWP) mp1 + (soldCount + 1);
1568	pswpNew3 = (PSWP) mp1 + (soldCount + 2);
1569	pswpNew4 = (PSWP) mp1 + (soldCount + 3);
1570	pswpNew1 = pswpClient;
1571	pswpNew1 -> hwnd = WinWindowFromID(hwnd, NEWVIEW_STATUS1);
1572	pswpNew1 -> x = pswpClient -> x + 2;
1573	pswpNew1 -> y = pswpClient -> y + 2;
1574	pswpNew1 -> cx = (pswpClient -> cx / 3) - 3;
1575	pswpNew1 -> cy = 20;
1576	pswpClient -> y = pswpNew1 -> y + pswpNew1 -> cy + 3;
1577	pswpClient -> cy = (pswpClient -> cy - pswpNew1 -> cy) - 5;
1578	pswpNew2 = pswpNew1;
1579	pswpNew3 = pswpNew1;
1580	pswpNew4 = pswpNew1;
1581	pswpNew2 -> hwnd = WinWindowFromID(hwnd, NEWVIEW_STATUS2);
1582	pswpNew3 -> hwnd = WinWindowFromID(hwnd, NEWVIEW_STATUS3);
1583	pswpNew4 -> hwnd = WinWindowFromID(hwnd, NEWVIEW_DRAG);
1584	pswpNew2 -> x = pswpNew1 -> x + pswpNew1 -> cx + 3;
1585	pswpNew3 -> x = pswpNew2 -> x + pswpNew2 -> cx + 3;
1586	pswpNew3 -> cx = ((pswpClient -> x + pswpClient -> cx) - pswpNew3 -> x) - 26;
1587	pswpNew4 -> x = pswpNew3 -> x + pswpNew3 -> cx + 3;
1588	pswpNew4 -> cx = 20;
1589	sCount += 4;
1590	pswpScroll = (PSWP) mp1;
1591	while (pswpScroll < pswpClient)
1592	{
1593	if (WinQueryWindowUShort(pswpScroll -> hwnd, QWS_ID) == FID_VERTSCROLL)
1594	break;
1595	pswpScroll++;
1596	}
1597	if (pswpScroll == pswpClient)
1598	pswpScroll = NULL;
1599	sSelect = (SHORT) WinSendDlgItemMsg(hwnd, NEWVIEW_LISTBOX,
1600	LM_QUERYITEMCOUNT,
1601	MPVOID, MPVOID);
1602	if (sSelect > 0)
1603	{
1604	pswpList = (PSWP) mp1 + (soldCount + 4);
1605	pswpList = pswpClient;
1606	pswpList -> hwnd = WinWindowFromID(hwnd, NEWVIEW_LISTBOX);
1607	pswpList -> x = pswpClient -> x;
1608	pswpList -> cx = pswpClient -> cx;
1609	if (pswpScroll)
1610	{
1611	pswpList -> cx += pswpScroll -> cx;
1612	pswpScroll -> cy -= 48;
1613	}
1614	pswpList -> y = (pswpClient -> y + pswpClient -> cy) - 48;
1615	pswpList -> cy = 48;
1616	pswpClient -> cy -= 48;
1617	sCount++;
1618	}
1619	WinShowWindow(WinWindowFromID(hwnd, NEWVIEW_LISTBOX), (sSelect > 0));
1620
1621	if (pswpScroll)
1622	{
1623	pswpUp = (PSWP) mp1 + (soldCount + 4 + (sSelect > 0));
1624	pswpUp = pswpClient;
1625	pswpUp -> hwnd = WinWindowFromID(hwnd, IDM_PREVBLANKLINE);
1626	pswpUp -> cx = pswpScroll -> cx;
1627	pswpUp -> x = pswpScroll -> x;
1628	pswpUp -> cy = WinQuerySysValue(HWND_DESKTOP, SV_CYVSCROLLARROW);
1629	pswpUp -> y = (pswpScroll -> y + pswpScroll -> cy) - (pswpUp -> cy + 1);
1630	pswpScroll -> cy -= ((pswpUp -> cy * 2) + 1);
1631	pswpDn = (PSWP) mp1 + (soldCount + 5 + (sSelect > 0));
1632	pswpDn = pswpUp;
1633	pswpDn -> y = pswpScroll -> y;
1634	pswpDn -> hwnd = WinWindowFromID(hwnd, IDM_NEXTBLANKLINE);
1635	pswpScroll -> y += pswpUp -> cy;
1636	sCount += 2;
1637	}
1638	else
1639	{
1640	WinShowWindow(WinWindowFromID(hwnd, IDM_PREVBLANKLINE), FALSE);
1641	WinShowWindow(WinWindowFromID(hwnd, IDM_NEXTBLANKLINE), FALSE);
1642	}
1643	return MRFROMSHORT(sCount);
1644	}
1645
1646	case WM_QUERYFRAMECTLCOUNT:
1647	{
1648	SHORT sCount, sSelect;
1649
1650	sCount = (SHORT) oldproc(hwnd, msg, mp1, mp2);
1651	sCount += 6;
1652	sSelect = (SHORT) WinSendDlgItemMsg(hwnd, NEWVIEW_LISTBOX,
1653	LM_QUERYITEMCOUNT,
1654	MPVOID, MPVOID);
1655	if (sSelect > 0)
1656	sCount++;
1657	return MRFROMSHORT(sCount);
1658	}
1659	}
1660	return oldproc(hwnd, msg, mp1, mp2);
1661	}
1662
1663	MRESULT EXPENTRY FindStrDlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
1664	{
1665	VIEWDATA *ad;
1666
1667	switch (msg)
1668	{
1669	case WM_INITDLG:
1670	if (!mp2)
1671	WinDismissDlg(hwnd, 0);
1672	else
1673	{
1674
1675	HWND hwndClient = (HWND ) mp2;
1676
1677	WinSetWindowULong(hwnd, QWL_USER, (ULONG) hwndClient);
1678	ad = (VIEWDATA *) WinQueryWindowPtr(hwndClient, QWL_USER);
1679	MLEsetwrap(WinWindowFromID(hwnd, NEWFIND_MLE), FALSE);
1680	MLEsetlimit(WinWindowFromID(hwnd, NEWFIND_MLE), SEARCHSTRINGLEN);
1681	MLEsetformat(WinWindowFromID(hwnd, NEWFIND_MLE), MLFIE_NOTRANS);
1682	if (*ad -> searchtext)
1683	{
1684
1685	IPT here = 0;
1686	ULONG len = strlen(ad -> searchtext);
1687
1688	WinSendMsg(WinWindowFromID(hwnd, NEWFIND_MLE),
1689	MLM_SETIMPORTEXPORT,
1690	MPFROMP(ad -> searchtext),
1691	MPFROMLONG(SEARCHSTRINGLEN));
1692	WinSendMsg(WinWindowFromID(hwnd, NEWFIND_MLE),
1693	MLM_IMPORT,
1694	MPFROMP(&here),
1695	MPFROMLONG(len));
1696	}
1697	WinCheckButton(hwnd, NEWFIND_ALSOSELECT, ad -> alsoselect);
1698	WinCheckButton(hwnd, NEWFIND_SENSITIVE, ad -> sensitive);
1699	WinCheckButton(hwnd, NEWFIND_LITERAL, ad -> literalsearch);
1700	}
1701	break;
1702
1703	case WM_COMMAND:
1704	switch (SHORT1FROMMP(mp1))
1705	{
1706	case DID_OK:
1707	{
1708	CHAR s[SEARCHSTRINGLEN];
1709	IPT here = 0;
1710	ULONG len;
1711	HWND hwndClient = WinQueryWindowULong(hwnd, QWL_USER);
1712
1713	ad = (VIEWDATA *) WinQueryWindowPtr(hwndClient, QWL_USER);
1714	memset(s, 0, SEARCHSTRINGLEN);
1715	WinSendMsg(WinWindowFromID(hwnd, NEWFIND_MLE),
1716	MLM_SETIMPORTEXPORT,
1717	MPFROMP(s),
1718	MPFROMLONG(SEARCHSTRINGLEN));
1719	len = SEARCHSTRINGLEN;
1720	WinSendMsg(WinWindowFromID(hwnd, NEWFIND_MLE),
1721	MLM_EXPORT,
1722	MPFROMP(&here),
1723	MPFROMLONG(&len));
1724	s[SEARCHSTRINGLEN - 1] = 0;
1725	if (!*s)
1726	{
1727	DosBeep(250, 100); // Complain
1728	break;
1729	}
1730	strcpy(ad -> searchtext, s);
1731	ad -> sensitive = WinQueryButtonCheckstate(hwnd, NEWFIND_SENSITIVE);
1732	if (ad -> sensitive != Sensitive)
1733	{
1734	Sensitive = ad -> sensitive;
1735	PrfWriteProfileData(fmprof,
1736	appname,
1737	"Viewer.Sensitive",
1738	&ad -> sensitive,
1739	sizeof(BOOL));
1740	}
1741	ad -> literalsearch = WinQueryButtonCheckstate(hwnd, NEWFIND_LITERAL);
1742	if (ad -> literalsearch != LiteralSearch)
1743	{
1744	LiteralSearch = ad -> literalsearch;
1745	PrfWriteProfileData(fmprof,
1746	appname,
1747	"Viewer.LiteralSearch",
1748	&ad -> literalsearch,
1749	sizeof(BOOL));
1750	}
1751	ad -> alsoselect = WinQueryButtonCheckstate(hwnd, NEWFIND_ALSOSELECT);
1752	if (ad -> alsoselect != AlsoSelect)
1753	{
1754	AlsoSelect = ad -> alsoselect;
1755	PrfWriteProfileData(fmprof,
1756	appname,
1757	"Viewer.AlsoSelect",
1758	&ad -> alsoselect,
1759	sizeof(BOOL));
1760	}
1761	}
1762	WinDismissDlg(hwnd, 1);
1763	break;
1764	case DID_CANCEL:
1765	WinDismissDlg(hwnd, 0);
1766	break;
1767	}
1768	return 0;
1769	}
1770	return WinDefDlgProc(hwnd, msg, mp1, mp2);
1771	}
1772
1773	MRESULT EXPENTRY ViewWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
1774	{
1775	VIEWDATA *ad = WinQueryWindowPtr(hwnd, QWL_USER);
1776
1777	switch (msg)
1778	{
1779	case WM_CREATE:
1780	{
1781	HWND temphwnd;
1782
1783	temphwnd = WinCreateWindow(WinQueryWindow(hwnd, QW_PARENT),
1784	WC_BUTTON,
1785	"<",
1786	WS_VISIBLE \|
1787	BS_PUSHBUTTON \| BS_NOPOINTERFOCUS,
1788	0,
1789	0,
1790	0,
1791	0,
1792	WinQueryWindow(hwnd, QW_PARENT),
1793	HWND_TOP,
1794	IDM_PREVBLANKLINE,
1795	NULL,
1796	NULL);
1797	WinSetPresParam(temphwnd,
1798	PP_FONTNAMESIZE,
1799	strlen(GetPString(IDS_8HELVTEXT)) + 1,
1800	(PVOID) GetPString(IDS_8HELVTEXT));
1801	temphwnd = WinCreateWindow(WinQueryWindow(hwnd, QW_PARENT),
1802	WC_BUTTON,
1803	">",
1804	WS_VISIBLE \|
1805	BS_PUSHBUTTON \| BS_NOPOINTERFOCUS,
1806	0,
1807	0,
1808	0,
1809	0,
1810	WinQueryWindow(hwnd, QW_PARENT),
1811	HWND_TOP,
1812	IDM_NEXTBLANKLINE,
1813	NULL,
1814	NULL);
1815	WinSetPresParam(temphwnd,
1816	PP_FONTNAMESIZE,
1817	strlen(GetPString(IDS_8HELVTEXT)) + 1,
1818	(PVOID) GetPString(IDS_8HELVTEXT));
1819	WinStartTimer(WinQueryAnchorBlock(hwnd),
1820	hwnd,
1821	ID_TIMER5,
1822	1000L);
1823	}
1824	break;
1825
1826	case WM_TIMER:
1827	if (ad &&
1828	ad -> needrefreshing &&
1829	!ad -> stopflag &&
1830	!ad -> relining &&
1831	!DosRequestMutexSem(ad -> ScanSem,
1832	SEM_IMMEDIATE_RETURN))
1833	{
1834	ad -> needrefreshing = FALSE;
1835	DosReleaseMutexSem(ad -> ScanSem);
1836	WinInvalidateRect(hwnd, NULL, TRUE);
1837	}
1838	break;
1839
1840	case UM_SETUP:
1841	if (!ad) {
1842	Runtime_Error(pszSrcFile, __LINE__, "no data");
1843	}
1844	else {
1845	CHAR s[CCHMAXPATH + 8];
1846	APIRET rc;
1847	ad -> hwndMenu = WinWindowFromID(ad -> hwndFrame, FID_MENU);
1848	ad -> hvscroll = WinWindowFromID(ad -> hwndFrame, FID_VERTSCROLL);
1849	ad -> hhscroll = WinWindowFromID(ad -> hwndFrame, FID_HORZSCROLL);
1850	WinSendMsg(ad -> hhscroll,
1851	SBM_SETTHUMBSIZE,
1852	MPFROM2SHORT(1, 1),
1853	MPVOID);
1854	WinSendMsg(ad -> hvscroll,
1855	SBM_SETTHUMBSIZE,
1856	MPFROM2SHORT(1, 1),
1857	MPVOID);
1858	sprintf(s,
1859	"%s: %s",
1860	FM2Str,
1861	ad -> filename);
1862	WinSetWindowText(ad -> hwndFrame,
1863	s);
1864	rc = DosCreateMutexSem(NULL, &ad -> ScanSem, 0L, FALSE);
1865	if (rc)
1866	Dos_Error(MB_CANCEL,rc,hwnd,pszSrcFile,__LINE__,"DosCreateMutexSem");
1867	else {
1868	PFNWP oldproc;
1869	WinSendMsg(ad -> hvscroll,
1870	SBM_SETSCROLLBAR,
1871	MPFROMSHORT(1),
1872	MPFROM2SHORT(1, 1));
1873	WinSendMsg(ad -> hhscroll, SBM_SETSCROLLBAR, MPFROMSHORT(1),
1874	MPFROM2SHORT(1, 1));
1875	ad -> hwndStatus1 = WinCreateWindow(ad -> hwndFrame,
1876	GetPString(IDS_WCVIEWSTATUS),
1877	GetPString(IDS_LOADINGTEXT),
1878	WS_VISIBLE \| SS_TEXT \|
1879	DT_LEFT \| DT_VCENTER,
1880	0,
1881	0,
1882	0,
1883	0,
1884	ad -> hwndFrame,
1885	HWND_TOP,
1886	NEWVIEW_STATUS1,
1887	NULL,
1888	NULL);
1889	ad -> hwndStatus2 = WinCreateWindow(ad -> hwndFrame,
1890	GetPString(IDS_WCVIEWSTATUS),
1891	NULL,
1892	WS_VISIBLE \| SS_TEXT \|
1893	DT_LEFT \| DT_VCENTER,
1894	0,
1895	0,
1896	0,
1897	0,
1898	ad -> hwndFrame,
1899	HWND_TOP,
1900	NEWVIEW_STATUS2,
1901	NULL,
1902	NULL);
1903	ad -> hwndStatus3 = WinCreateWindow(ad -> hwndFrame,
1904	GetPString(IDS_WCVIEWSTATUS),
1905	NULL,
1906	WS_VISIBLE \| SS_TEXT \|
1907	DT_LEFT \| DT_VCENTER,
1908	0,
1909	0,
1910	0,
1911	0,
1912	ad -> hwndFrame,
1913	HWND_TOP,
1914	NEWVIEW_STATUS3,
1915	NULL,
1916	NULL);
1917	ad -> hwndListbox = WinCreateWindow(ad -> hwndFrame,
1918	WC_LISTBOX,
1919	NULL,
1920	LS_NOADJUSTPOS,
1921	0,
1922	0,
1923	0,
1924	0,
1925	ad -> hwndFrame,
1926	HWND_TOP,
1927	NEWVIEW_LISTBOX,
1928	NULL,
1929	NULL);
1930	ad -> hwndDrag = WinCreateWindow(ad -> hwndFrame,
1931	GetPString(IDS_WCVIEWSTATUS),
1932	"#100",
1933	WS_VISIBLE \| SS_BITMAP,
1934	0,
1935	0,
1936	0,
1937	0,
1938	ad -> hwndFrame,
1939	HWND_TOP,
1940	NEWVIEW_DRAG,
1941	NULL,
1942	NULL);
1943	oldproc = WinSubclassWindow(ad -> hwndFrame, (PFNWP) ViewFrameWndProc);
1944	if (oldproc)
1945	WinSetWindowPtr(ad -> hwndFrame, QWL_USER, (PVOID) oldproc);
1946	ad -> hps = InitWindow(hwnd);
1947	if (_beginthread(LoadFile, NULL, 524288, (PVOID) hwnd) == -1)
1948	Runtime_Error(pszSrcFile, __LINE__, GetPString(IDS_COULDNTSTARTTHREADTEXT));
1949	else {
1950	WinSendMsg(hwnd, UM_SETUP5, MPVOID, MPVOID);
1951	DosSleep(32L);
1952	return (MRESULT)1;
1953	}
1954	}
1955	}
1956	// Oops
1957	WinDestroyWindow(WinQueryWindow(hwnd, QW_PARENT));
1958	return 0;
1959
1960	case UM_SETUP5:
1961	if (ad)
1962	{
1963	if (ad -> hwndFrame ==
1964	WinQueryActiveWindow(WinQueryWindow(ad -> hwndFrame,
1965	QW_PARENT)) &&
1966	!ParentIsDesktop(ad -> hwndFrame, (HWND) 0))
1967	{
1968	if (hwndStatus2)
1969	WinSetWindowText(hwndStatus2,
1970	(*ad -> filename) ?
1971	ad -> filename :
1972	GetPString(IDS_UNTITLEDTEXT));
1973	if (fMoreButtons)
1974	{
1975	WinSetWindowText(hwndName,
1976	(*ad -> filename) ?
1977	ad -> filename :
1978	GetPString(IDS_UNTITLEDTEXT));
1979	WinSetWindowText(hwndDate, NullStr);
1980	WinSetWindowText(hwndAttr, NullStr);
1981	}
1982	if (hwndStatus)
1983	WinSetWindowText(hwndStatus,
1984	GetPString(IDS_INTERNALVIEWERTITLETEXT));
1985	}
1986	}
1987	return 0;
1988
1989	case DM_DISCARDOBJECT:
1990	case DM_PRINTOBJECT:
1991	return MRFROMLONG(DRR_TARGET);
1992
1993	case UM_RESCAN:
1994	if (ad)
1995	{
1996	if (!ad -> busy &&
1997	!DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN))
1998	{
1999	if (ad -> numlines)
2000	{
2001
2002	CHAR s[80], tb[34], tl[34];
2003
2004	commafmt(tb, sizeof(tb), ad -> textsize);
2005	commafmt(tl, sizeof(tl), ad -> numlines);
2006	sprintf(s,
2007	" %s %s%s %s %s%s",
2008	tb,
2009	GetPString(IDS_BYTETEXT),
2010	&"s"[ad -> textsize == 1],
2011	tl,
2012	GetPString(IDS_LINETEXT),
2013	&"s"[ad -> numlines == 1]);
2014	WinSetWindowText(ad -> hwndStatus1, s);
2015	}
2016	else
2017	WinSetWindowText(ad -> hwndStatus1,
2018	GetPString(IDS_NVNOLINESTEXT));
2019	DosReleaseMutexSem(ad -> ScanSem);
2020	}
2021	else
2022	WinSetWindowText(ad -> hwndStatus1,
2023	GetPString(IDS_WORKINGTEXT));
2024	}
2025	return 0;
2026
2027	case UM_SETUP2:
2028	/*
2029	* calculate width of client in characters, recalc lines if
2030	* oldwidth != newwidth, set ad->oldwidth for later comparison
2031	*/
2032	if (ad)
2033	{
2034
2035	BOOL invalidate = FALSE;
2036
2037	if (!ad -> wrapon && !ad -> hex)
2038	{
2039	if (WinQueryWindow(ad -> hhscroll, QW_PARENT) == ad -> hwndFrame)
2040	{
2041	invalidate = TRUE;
2042	WinSetOwner(ad -> hhscroll, HWND_OBJECT);
2043	WinSetParent(ad -> hhscroll, HWND_OBJECT, TRUE);
2044	ad -> maxx = 0;
2045	ad -> horzscroll = 0;
2046	}
2047	}
2048	else
2049	{
2050	if (WinQueryWindow(ad -> hhscroll, QW_PARENT) != ad -> hwndFrame)
2051	{
2052	invalidate = TRUE;
2053	WinSetOwner(ad -> hhscroll, ad -> hwndFrame);
2054	WinSetParent(ad -> hhscroll, ad -> hwndFrame, TRUE);
2055	}
2056	}
2057	if (invalidate)
2058	{
2059	WinSendMsg(ad -> hwndFrame, WM_UPDATEFRAME, MPFROMLONG(FCF_SIZEBORDER),
2060	MPVOID);
2061	WinInvalidateRect(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
2062	NEWVIEW_DRAG), NULL, FALSE);
2063	WinInvalidateRect(ad -> hhscroll, NULL, FALSE);
2064	}
2065	}
2066
2067	if (ad && !ad -> busy &&
2068	!DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN))
2069	{
2070
2071	RECTL rcl;
2072	ULONG newwidth;
2073
2074	WinQueryWindowRect(hwnd, &rcl);
2075	newwidth = (rcl.xRight - rcl.xLeft) / ad -> fattrs.lAveCharWidth;
2076	if ((!ad -> hex \|\| ad -> oldwidth == -1) &&
2077	newwidth != ad -> oldwidth && ad -> text && ad -> textsize)
2078	{
2079	ad -> oldwidth = newwidth;
2080	if (!ad -> relining)
2081	{
2082	if (_beginthread(ReLine, NULL, 524288, (PVOID) hwnd) == -1)
2083	{
2084	Runtime_Error(pszSrcFile, __LINE__, GetPString(IDS_COULDNTSTARTTHREADTEXT));
2085	DosReleaseMutexSem(ad -> ScanSem);
2086	WinDestroyWindow(WinQueryWindow(hwnd, QW_PARENT));
2087	return 0;
2088	}
2089	}
2090	}
2091	ad -> oldwidth = newwidth;
2092	DosReleaseMutexSem(ad -> ScanSem);
2093	}
2094	return MRFROMLONG(TRUE);
2095
2096	case WM_CHAR:
2097	shiftstate = (SHORT1FROMMP(mp1) & (KC_SHIFT \| KC_ALT \| KC_CTRL));
2098	if (ad && !ad -> busy && !(SHORT1FROMMP(mp1) & KC_KEYUP) &&
2099	!DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN))
2100	{
2101
2102	ULONG numlines, wascursored = ad -> cursored;
2103	RECTL rcl;
2104
2105	WinQueryWindowRect(hwnd, &rcl);
2106	numlines = NumLines(&rcl, ad);
2107	if (numlines)
2108	{
2109	if (SHORT1FROMMP(mp1) & KC_VIRTUALKEY)
2110	{
2111	switch (SHORT2FROMMP(mp2))
2112	{
2113	case VK_LEFT:
2114	WinSendMsg(hwnd, WM_HSCROLL, MPFROM2SHORT(FID_HORZSCROLL, 0),
2115	MPFROM2SHORT(0, SB_LINELEFT));
2116	break;
2117	case VK_RIGHT:
2118	WinSendMsg(hwnd, WM_HSCROLL, MPFROM2SHORT(FID_HORZSCROLL, 0),
2119	MPFROM2SHORT(0, SB_LINERIGHT));
2120	break;
2121	case VK_PAGEUP:
2122	PostMsg(hwnd, WM_VSCROLL, MPFROM2SHORT(FID_VERTSCROLL, 0),
2123	MPFROM2SHORT(0, SB_PAGEUP));
2124	break;
2125	case VK_PAGEDOWN:
2126	PostMsg(hwnd, WM_VSCROLL, MPFROM2SHORT(FID_VERTSCROLL, 0),
2127	MPFROM2SHORT(0, SB_PAGEDOWN));
2128	break;
2129	case VK_UP:
2130	if (ad -> cursored > 1)
2131	{
2132	if (shiftstate & KC_SHIFT)
2133	WinSendMsg(hwnd, WM_BUTTON1CLICK,
2134	MPFROM2SHORT(ad -> fattrs.lAveCharWidth + 2,
2135	((rcl.yTop - (ad -> lMaxHeight *
2136	((ad -> cursored) - ad -> topline))) -
2137	ad -> lMaxDescender) - 1),
2138	MPFROM2SHORT(TRUE, 0));
2139	ad -> cursored--;
2140	if (ad -> cursored < ad -> topline)
2141	{
2142	PaintLine(hwnd, ad -> hps, ad -> cursored, ad -> topline, &rcl);
2143	WinSendMsg(hwnd, WM_VSCROLL, MPFROM2SHORT(FID_VERTSCROLL, 0),
2144	MPFROM2SHORT(0, SB_LINEUP));
2145	}
2146	else
2147	{
2148	PaintLine(hwnd, ad -> hps, ad -> cursored - 1, ad -> topline, &rcl);
2149	PaintLine(hwnd, ad -> hps, ad -> cursored, ad -> topline, &rcl);
2150	PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
2151	}
2152	}
2153	break;
2154	case VK_DOWN:
2155	if (ad -> cursored < ad -> numlines &&
2156	ad -> cursored < ad -> topline + numlines)
2157	{
2158	if (shiftstate & KC_SHIFT)
2159	WinSendMsg(hwnd, WM_BUTTON1CLICK,
2160	MPFROM2SHORT(ad -> fattrs.lAveCharWidth + 2,
2161	((rcl.yTop - (ad -> lMaxHeight *
2162	((ad -> cursored) - ad -> topline))) -
2163	ad -> lMaxDescender) - 1),
2164	MPFROM2SHORT(TRUE, 0));
2165	ad -> cursored++;
2166	if (ad -> cursored >= ad -> topline + numlines)
2167	{
2168	PaintLine(hwnd, ad -> hps, ad -> cursored - 2, ad -> topline, &rcl);
2169	WinSendMsg(hwnd, WM_VSCROLL, MPFROM2SHORT(FID_VERTSCROLL, 0),
2170	MPFROM2SHORT(0, SB_LINEDOWN));
2171	}
2172	else
2173	{
2174	PaintLine(hwnd, ad -> hps, ad -> cursored - 1, ad -> topline, &rcl);
2175	PaintLine(hwnd, ad -> hps, ad -> cursored - 2, ad -> topline, &rcl);
2176	PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
2177	}
2178	}
2179	break;
2180	case VK_END:
2181	if ((shiftstate & KC_CTRL) \|\|
2182	ad -> cursored == (ad -> topline - 1) + numlines)
2183	{
2184	ad -> cursored = ad -> numlines;
2185	ad -> topline = (ad -> numlines + 1) - numlines;
2186	if (ad -> topline > ad -> numlines)
2187	ad -> topline = 1;
2188	WinInvalidateRect(hwnd, NULL, FALSE);
2189	}
2190	else
2191	{
2192	ad -> cursored = (ad -> topline - 1) + numlines;
2193	if (ad -> cursored > ad -> numlines)
2194	ad -> cursored = ad -> numlines;
2195	PaintLine(hwnd, ad -> hps, ad -> cursored - 1, ad -> topline, &rcl);
2196	PaintLine(hwnd, ad -> hps, wascursored - 1, ad -> topline, &rcl);
2197	PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
2198	}
2199	PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
2200	break;
2201	case VK_HOME:
2202	if ((shiftstate & KC_CTRL) \|\|
2203	ad -> cursored == ad -> topline)
2204	{
2205	ad -> topline = 1;
2206	ad -> cursored = 1;
2207	WinInvalidateRect(hwnd, NULL, FALSE);
2208	}
2209	else
2210	{
2211	ad -> cursored = ad -> topline;
2212	PaintLine(hwnd, ad -> hps, ad -> cursored - 1, ad -> topline, &rcl);
2213	PaintLine(hwnd, ad -> hps, wascursored - 1, ad -> topline, &rcl);
2214	PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
2215	}
2216	PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
2217	break;
2218	case VK_SPACE:
2219	WinSendMsg(hwnd, WM_BUTTON1CLICK,
2220	MPFROM2SHORT(ad -> fattrs.lAveCharWidth + 2,
2221	((rcl.yTop - (ad -> lMaxHeight *
2222	((ad -> cursored) - ad -> topline))) -
2223	ad -> lMaxDescender) - 1),
2224	MPFROM2SHORT(TRUE, 0));
2225	break;
2226	case VK_NEWLINE:
2227	case VK_ENTER:
2228	WinSendMsg(hwnd, WM_BUTTON1DBLCLK,
2229	MPFROM2SHORT(ad -> fattrs.lAveCharWidth + 2,
2230	((rcl.yTop - (ad -> lMaxHeight *
2231	((ad -> cursored) - ad -> topline))) -
2232	ad -> lMaxDescender) - 1),
2233	MPFROM2SHORT(0, 0));
2234	break;
2235	}
2236	}
2237	else if (SHORT1FROMMP(mp1) & KC_CHAR)
2238	{
2239	switch (SHORT1FROMMP(mp2))
2240	{
2241	case '\r':
2242	case '\n':
2243	WinSendMsg(hwnd, WM_BUTTON1DBLCLK,
2244	MPFROM2SHORT(ad -> fattrs.lAveCharWidth + 2,
2245	(rcl.yTop - (ad -> lMaxHeight *
2246	((ad -> cursored) - ad -> topline))) - 1),
2247	MPFROM2SHORT(0, 0));
2248	break;
2249	default:
2250	break;
2251	}
2252	}
2253	if (wascursored != ad -> cursored)
2254	PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
2255	}
2256	DosReleaseMutexSem(ad -> ScanSem);
2257	}
2258	break;
2259
2260	case WM_BUTTON1MOTIONSTART:
2261	WinSetFocus(HWND_DESKTOP, hwnd);
2262	if (ad && !ad -> stopflag && !ad -> busy &&
2263	!DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN))
2264	{
2265	ad -> mousecaptured = TRUE;
2266	ad -> lastselected = ULONG_MAX;
2267	ad -> lastdirection = 0;
2268	WinSetCapture(HWND_DESKTOP, hwnd);
2269	WinSendMsg(hwnd, WM_BUTTON1CLICK, mp1, MPFROM2SHORT(TRUE, 0));
2270	}
2271	break;
2272
2273	case WM_MOUSEMOVE:
2274	shiftstate = (SHORT2FROMMP(mp2) & (KC_SHIFT \| KC_ALT \| KC_CTRL));
2275	if (ad && ad -> mousecaptured)
2276	{
2277
2278	ULONG numlines, whichline, x;
2279	LONG inc;
2280	RECTL Rectl;
2281	POINTS pts;
2282	BOOL outofwindow = FALSE;
2283
2284	WinQueryWindowRect(hwnd, &Rectl);
2285	numlines = NumLines(&Rectl, ad);
2286	if (numlines)
2287	{
2288	pts.x = SHORT1FROMMP(mp1);
2289	pts.y = SHORT2FROMMP(mp1);
2290	if (pts.y < 0)
2291	{
2292	WinSendMsg(hwnd, WM_VSCROLL, MPFROM2SHORT(FID_VERTSCROLL, 0),
2293	MPFROM2SHORT(0, SB_LINEDOWN));
2294	pts.y = 1;
2295	outofwindow = TRUE;
2296	}
2297	else if (pts.y > Rectl.yTop - Rectl.yBottom)
2298	{
2299	WinSendMsg(hwnd, WM_VSCROLL, MPFROM2SHORT(FID_VERTSCROLL, 0),
2300	MPFROM2SHORT(0, SB_LINEUP));
2301	pts.y = (Rectl.yTop - Rectl.yBottom) - 1;
2302	outofwindow = TRUE;
2303	}
2304	whichline = ((Rectl.yTop - Rectl.yBottom) -
2305	((LONG) pts.y + ad -> lMaxDescender)) /
2306	ad -> lMaxHeight;
2307	if (whichline > numlines - 1)
2308	whichline = numlines - 1;
2309	whichline += (ad -> topline - 1);
2310	if (whichline < ad -> numlines && ad -> lastselected != whichline)
2311	{
2312	if (ad -> lastselected != ULONG_MAX)
2313	{
2314	inc = (ad -> lastselected < whichline) ? 1 : -1;
2315	for (x = ad -> lastselected + inc;
2316	x != whichline && x < ad -> numlines;
2317	(ad -> lastselected < whichline) ? x++ : x--)
2318	{
2319	if (ad -> markedlines)
2320	{
2321	if (ad -> markedlines[x] & VF_SELECTED)
2322	{
2323	ad -> markedlines[x] &= (~VF_SELECTED);
2324	ad -> selected--;
2325	}
2326	else
2327	{
2328	ad -> markedlines[x] \|= VF_SELECTED;
2329	ad -> selected++;
2330	}
2331	}
2332	PaintLine(hwnd, ad -> hps, x, ad -> topline, &Rectl);
2333	}
2334	WinSendMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
2335	}
2336	WinSendMsg(hwnd, WM_BUTTON1CLICK, MPFROM2SHORT(pts.x, pts.y),
2337	MPFROM2SHORT(TRUE, 0));
2338	}
2339	}
2340	if (outofwindow)
2341	{
2342
2343	POINTL ptl;
2344
2345	WinQueryPointerPos(HWND_DESKTOP, &ptl);
2346	WinMapWindowPoints(HWND_DESKTOP, hwnd, &ptl, 1L);
2347	if ((SHORT) ptl.y == (SHORT) SHORT2FROMMP(mp1) &&
2348	(SHORT) ptl.x == (SHORT) SHORT1FROMMP(mp1) &&
2349	((SHORT) ptl.y < 0 \|\| ptl.y > (Rectl.yTop - Rectl.yBottom)))
2350	{
2351	PostMsg(hwnd, UM_MOUSEMOVE, mp1, MPVOID);
2352	DosSleep(1L);
2353	}
2354	}
2355	}
2356	break;
2357
2358	case UM_MOUSEMOVE:
2359	if (ad && ad -> mousecaptured)
2360	{
2361
2362	POINTL ptl;
2363	RECTL Rectl;
2364
2365	WinQueryWindowRect(hwnd, &Rectl);
2366	WinQueryPointerPos(HWND_DESKTOP, &ptl);
2367	WinMapWindowPoints(HWND_DESKTOP, hwnd, &ptl, 1L);
2368	if ((SHORT) ptl.y == (SHORT) SHORT2FROMMP(mp1) &&
2369	(SHORT) ptl.x == (SHORT) SHORT1FROMMP(mp1) &&
2370	((SHORT) ptl.y < 0 \|\| ptl.y > (Rectl.yTop - Rectl.yBottom)))
2371	{
2372	DosSleep(1L);
2373	PostMsg(hwnd, WM_MOUSEMOVE, mp1, MPFROM2SHORT(TRUE, 0));
2374	}
2375	}
2376	return 0;
2377
2378	case WM_BUTTON1UP:
2379	case WM_BUTTON1MOTIONEND:
2380	WinSetFocus(HWND_DESKTOP, hwnd);
2381	if (ad && ad -> mousecaptured)
2382	{
2383	ad -> mousecaptured = FALSE;
2384	ad -> lastselected = ULONG_MAX;
2385	ad -> lastdirection = 0;
2386	DosReleaseMutexSem(ad -> ScanSem);
2387	WinSetCapture(HWND_DESKTOP, NULLHANDLE);
2388	}
2389	break;
2390
2391	case WM_BUTTON1DBLCLK:
2392	case WM_BUTTON1CLICK:
2393	WinSetFocus(HWND_DESKTOP, hwnd);
2394	if (ad && !ad -> stopflag && ad -> numlines && ad -> text && !ad -> busy &&
2395	!DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN))
2396	{
2397
2398	ULONG numlines, whichline, wascursored, width;
2399	RECTL Rectl;
2400	POINTS pts;
2401
2402	WinQueryWindowRect(hwnd, &Rectl);
2403	numlines = NumLines(&Rectl, ad);
2404	if (!numlines)
2405	break;
2406	pts.x = SHORT1FROMMP(mp1);
2407	pts.y = SHORT2FROMMP(mp1);
2408	whichline = ((Rectl.yTop - Rectl.yBottom) -
2409	((LONG) pts.y + ad -> lMaxDescender)) /
2410	ad -> lMaxHeight;
2411	if (whichline > numlines - 1)
2412	whichline = numlines - 1;
2413	whichline += (ad -> topline - 1);
2414	if (whichline + 1 > ad -> numlines)
2415	break;
2416	wascursored = ad -> cursored;
2417	ad -> cursored = whichline + 1;
2418	if (msg == WM_BUTTON1CLICK)
2419	{
2420	if (ad -> lastselected != ULONG_MAX)
2421	{
2422	if (whichline > ad -> lastselected)
2423	ad -> lastdirection = 1;
2424	else
2425	ad -> lastdirection = 2;
2426	}
2427	else
2428	ad -> lastdirection = 0;
2429	ad -> lastselected = whichline;
2430	if (whichline < ad -> numlines)
2431	{
2432	if (ad -> markedlines)
2433	{
2434	if (ad -> markedlines[whichline] & VF_SELECTED)
2435	{
2436	ad -> selected--;
2437	ad -> markedlines[whichline] &= (~VF_SELECTED);
2438	}
2439	else
2440	{
2441	ad -> selected++;
2442	ad -> markedlines[whichline] \|= VF_SELECTED;
2443	}
2444	}
2445	WinSendMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
2446	}
2447	PaintLine(hwnd, ad -> hps, whichline, ad -> topline, &Rectl);
2448	if (ad -> cursored != wascursored)
2449	{
2450	PaintLine(hwnd, ad -> hps, wascursored - 1, ad -> topline, &Rectl);
2451	PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
2452	}
2453	}
2454	else
2455	{
2456
2457	SHORT numsels, sSelect = 0, numinserted;
2458	ULONG linenum;
2459
2460	if (!ad -> hex && ad -> lines)
2461	{
2462
2463	CHAR p, e;
2464
2465	width = (Rectl.xRight - Rectl.xLeft) / ad -> fattrs.lAveCharWidth;
2466	e = p = ad -> lines[whichline];
2467	while (e != '\r' && e != '\n' && e < ad -> text + ad -> textsize)
2468	{
2469	if (ad -> wrapon && e - p == width)
2470	break;
2471	e++;
2472	}
2473	if ((e == '\r' \|\| e == '\n') && e > p)
2474	e--;
2475	width = e - p;
2476	if (!width)
2477	goto NoAdd;
2478
2479	if ((ad -> httpin && *httprun &&
2480	strnstr(ad -> lines[whichline], "http://", width)) \|\|
2481	(ad -> ftpin && *ftprun &&
2482	strnstr(ad -> lines[whichline], "ftp://", width)))
2483	{
2484
2485	USHORT ret;
2486	URLDATA *urld;
2487
2488	urld = xmallocz(sizeof(URLDATA),pszSrcFile,__LINE__);
2489	if (urld) {
2490	urld -> size = sizeof(URLDATA);
2491	urld -> line = ad -> lines[whichline];
2492	urld -> len = width;
2493	ret = (USHORT) WinDlgBox(HWND_DESKTOP, hwnd, UrlDlgProc,
2494	FM3ModHandle, URL_FRAME, urld);
2495	switch (ret) {
2496	case 0:
2497	free(urld);
2498	goto NoAdd;
2499	case 1:
2500	if (*urld -> url)
2501	runemf2(SEPARATE \| WINDOWED,
2502	hwnd,
2503	NULL,
2504	NULL,
2505	"%s %s",
2506	httprun,
2507	urld -> url);
2508	free(urld);
2509	goto NoAdd;
2510	case 2:
2511	if (*urld -> url)
2512	runemf2(SEPARATE \| WINDOWED,
2513	hwnd,
2514	NULL,
2515	NULL,
2516	"%s %s",
2517	ftprun,
2518	urld -> url);
2519	free(urld);
2520	goto NoAdd;
2521	default:
2522	break;
2523	}
2524	free(urld);
2525	}
2526	}
2527	}
2528	numsels = (SHORT) WinSendDlgItemMsg(ad -> hwndFrame, NEWVIEW_LISTBOX,
2529	LM_QUERYITEMCOUNT, MPVOID, MPVOID);
2530	if (numsels > 0)
2531	{
2532	for (sSelect = 0; sSelect < numsels; sSelect++)
2533	{
2534	linenum = (ULONG) WinSendDlgItemMsg(ad -> hwndFrame, NEWVIEW_LISTBOX,
2535	LM_QUERYITEMHANDLE,
2536	MPFROM2SHORT(sSelect, 0),
2537	MPVOID);
2538	if (linenum == whichline)
2539	goto NoAdd;
2540	}
2541	}
2542	{
2543	CHAR s = NULL, p;
2544
2545	if (!ad -> hex && ad -> lines)
2546	{
2547	s = xmalloc(width + 2,pszSrcFile,__LINE__);
2548	if (!s)
2549	goto NoAdd;
2550	strncpy(s, ad -> lines[whichline], width + 1);
2551	s[width + 1] = 0;
2552	p = s;
2553	while (*p)
2554	{
2555	if (p == '\r' \|\| p == '\n')
2556	{
2557	*p = 0;
2558	break;
2559	}
2560	p++;
2561	}
2562	}
2563	else
2564	{
2565
2566	register ULONG x;
2567
2568	width = ad -> textsize - (whichline * 16);
2569	width = min(width, 16);
2570	s = xmalloc(80,pszSrcFile,__LINE__);
2571	if (!s)
2572	goto NoAdd;
2573	sprintf(s, "%08lx ", whichline * 16);
2574	p = s + 9;
2575	for (x = 0; x < width; x++)
2576	{
2577	sprintf(p, " %02hx", ad -> text[(whichline * 16) + x]);
2578	p += 3;
2579	}
2580	*p = ' ';
2581	p++;
2582	*p = ' ';
2583	p++;
2584	for (x = 0; x < width; x++)
2585	{
2586	p = ad -> text[(whichline 16) + x];
2587	p++;
2588	}
2589	*p = 0;
2590	}
2591	if (s)
2592	{
2593	if (*s)
2594	{
2595	ad -> dummy = TRUE;
2596	numinserted = (SHORT) WinSendDlgItemMsg(ad -> hwndFrame,
2597	NEWVIEW_LISTBOX,
2598	LM_INSERTITEM,
2599	MPFROM2SHORT(LIT_END, 0),
2600	MPFROMP(s));
2601	ad -> dummy = FALSE;
2602	if (numinserted >= 0)
2603	WinSendDlgItemMsg(ad -> hwndFrame, NEWVIEW_LISTBOX,
2604	LM_SETITEMHANDLE,
2605	MPFROM2SHORT(numinserted, 0),
2606	MPFROMLONG(whichline));
2607	}
2608	free(s);
2609	}
2610	}
2611	if (!numsels)
2612	WinSendMsg(ad -> hwndFrame, WM_UPDATEFRAME,
2613	MPFROMLONG(FCF_SIZEBORDER), MPVOID);
2614	}
2615	NoAdd:
2616	DosReleaseMutexSem(ad -> ScanSem);
2617	DosPostEventSem(CompactSem);
2618	}
2619	break;
2620
2621	case WM_MENUEND:
2622	if (ad && ad -> hwndPopup == (HWND) mp2)
2623	{
2624	WinDestroyWindow(ad -> hwndPopup);
2625	ad -> hwndPopup = (HWND) 0;
2626	}
2627	break;
2628
2629	case UM_CONTEXTMENU:
2630	case WM_CONTEXTMENU:
2631	if (ad)
2632	{
2633	if (!ad -> hwndPopup)
2634	{
2635	ad -> hwndPopup = WinLoadMenu(HWND_DESKTOP, FM3ModHandle, NEWVIEW_POPUP);
2636	if (ad -> hwndPopup)
2637	WinSetPresParam(ad -> hwndPopup,
2638	PP_FONTNAMESIZE,
2639	strlen(GetPString(IDS_8HELVTEXT)) + 1,
2640	GetPString(IDS_8HELVTEXT));
2641	}
2642	if (ad -> hwndPopup)
2643	{
2644
2645	APIRET rc;
2646	SHORT sSelect;
2647
2648	rc = DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN);
2649	WinEnableMenuItem(ad -> hwndPopup, IDM_SAVETOCLIP, (rc == 0 &&
2650	ad -> selected != 0));
2651	WinEnableMenuItem(ad -> hwndPopup, IDM_APPENDTOCLIP, (rc == 0 &&
2652	ad -> selected != 0));
2653	WinEnableMenuItem(ad -> hwndPopup, IDM_SAVETOLIST, (rc == 0 &&
2654	ad -> selected != 0));
2655	sSelect = (SHORT) WinSendDlgItemMsg(ad -> hwndFrame, NEWVIEW_LISTBOX,
2656	LM_QUERYITEMCOUNT, MPVOID, MPVOID);
2657	WinEnableMenuItem(ad -> hwndPopup, IDM_SAVETOCLIP2, (rc == 0 &&
2658	sSelect > 0));
2659	WinEnableMenuItem(ad -> hwndPopup, IDM_APPENDTOCLIP2, (rc == 0 &&
2660	sSelect > 0));
2661	WinEnableMenuItem(ad -> hwndPopup, IDM_SAVETOLIST2, (rc == 0 &&
2662	sSelect > 0));
2663	WinEnableMenuItem(ad -> hwndPopup, IDM_SELECTALL, (rc == 0 &&
2664	ad -> numlines != 0 &&
2665	ad -> markedlines));
2666	WinEnableMenuItem(ad -> hwndPopup, IDM_DESELECTALL, (rc == 0 &&
2667	ad -> numlines != 0 &&
2668	ad -> markedlines &&
2669	ad -> selected != 0));
2670	WinEnableMenuItem(ad -> hwndPopup, IDM_PREVSELECTED, (rc == 0 &&
2671	ad -> numlines != 0 &&
2672	ad -> markedlines &&
2673	ad -> selected != 0));
2674	WinEnableMenuItem(ad -> hwndPopup, IDM_NEXTSELECTED, (rc == 0 &&
2675	ad -> numlines != 0 &&
2676	ad -> markedlines &&
2677	ad -> selected != 0));
2678	WinEnableMenuItem(ad -> hwndPopup, IDM_SELECTFOUND, (rc == 0 &&
2679	ad -> numlines != 0 &&
2680	ad -> markedlines &&
2681	ad -> found != 0));
2682	WinEnableMenuItem(ad -> hwndPopup, IDM_DESELECTFOUND, (rc == 0 &&
2683	ad -> numlines != 0 &&
2684	ad -> markedlines &&
2685	ad -> selected != 0 &&
2686	ad -> found != 0));
2687	WinEnableMenuItem(ad -> hwndPopup, IDM_INVERT, (rc == 0 &&
2688	ad -> numlines != 0 &&
2689	ad -> markedlines));
2690	WinEnableMenuItem(ad -> hwndPopup, IDM_FINDFIRST, (rc == 0 &&
2691	ad -> numlines != 0 &&
2692	ad -> markedlines));
2693	WinEnableMenuItem(ad -> hwndPopup, IDM_FINDNEXT, (rc == 0 &&
2694	ad -> numlines != 0 &&
2695	ad -> markedlines &&
2696	ad -> found));
2697	WinEnableMenuItem(ad -> hwndPopup, IDM_FINDPREV, (rc == 0 &&
2698	ad -> numlines != 0 &&
2699	ad -> markedlines &&
2700	ad -> found));
2701	WinEnableMenuItem(ad -> hwndPopup, IDM_GOTOLINE, (rc == 0 &&
2702	ad -> numlines != 0));
2703	WinEnableMenuItem(ad -> hwndPopup, IDM_GOTOOFFSET, (rc == 0 &&
2704	ad -> textsize != 0));
2705	if (!rc)
2706	DosReleaseMutexSem(ad -> ScanSem);
2707	PopupMenu(hwnd, hwnd, ad -> hwndPopup);
2708	}
2709	}
2710	break;
2711
2712	case UM_SETUP3:
2713	if (ad && !ad -> busy &&
2714	!DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN))
2715	{
2716	ad -> multiplier = ad -> numlines / 32767;
2717	if (ad -> multiplier * 32767 != ad -> numlines)
2718	ad -> multiplier++;
2719	if (!ad -> multiplier)
2720	ad -> multiplier++;
2721	{
2722	RECTL Rectl;
2723	ULONG numlines;
2724
2725	WinQueryWindowRect(hwnd, &Rectl);
2726	numlines = NumLines(&Rectl, ad);
2727	if (numlines)
2728	{
2729	WinSendMsg(ad -> hhscroll, SBM_SETTHUMBSIZE,
2730	MPFROM2SHORT((SHORT) Rectl.xRight, (SHORT) ad -> maxx),
2731	MPVOID);
2732	WinSendMsg(ad -> hvscroll, SBM_SETTHUMBSIZE,
2733	MPFROM2SHORT((SHORT) numlines,
2734	(SHORT) min(ad -> numlines, 32767)), MPVOID);
2735	if (ad -> multiplier)
2736	WinSendMsg(ad -> hvscroll, SBM_SETSCROLLBAR,
2737	MPFROMSHORT((SHORT) (ad -> topline / ad -> multiplier)),
2738	MPFROM2SHORT(1, (SHORT) ((ad -> numlines + 1) /
2739	ad -> multiplier) - numlines));
2740	WinSendMsg(ad -> hhscroll, SBM_SETSCROLLBAR,
2741	MPFROMSHORT((SHORT) abs(ad -> horzscroll)),
2742	MPFROM2SHORT(0, (SHORT) (ad -> maxx - Rectl.xRight)));
2743	if (ad -> numlines - ad -> topline < numlines)
2744	{
2745	ad -> topline = ((ad -> numlines - ad -> topline) - numlines);
2746	WinInvalidateRect(hwnd, NULL, FALSE);
2747	}
2748	}
2749	}
2750	DosReleaseMutexSem(ad -> ScanSem);
2751	}
2752	return 0;
2753
2754	case UM_SETUP4:
2755	if (ad && !ad -> busy &&
2756	!DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN))
2757	{
2758
2759	CHAR s[140], t[34];
2760	ULONG numlines;
2761	RECTL Rectl;
2762
2763	WinQueryWindowRect(hwnd, &Rectl);
2764	numlines = NumLines(&Rectl, ad);
2765	commafmt(t, sizeof(t), ad -> cursored);
2766	strcpy(s, GetPString(IDS_LINECOLONTEXT));
2767	strcat(s, t);
2768	if (ad -> selected)
2769	{
2770	if (ad -> selected > ad -> numlines)
2771	ad -> selected = 0;
2772	else
2773	{
2774	commafmt(t, sizeof(t), ad -> selected);
2775	strcat(s, " (");
2776	strcat(s, t);
2777	strcat(s, GetPString(IDS_SELECTEDPARENTEXT));
2778	}
2779	}
2780	if (ad -> found)
2781	{
2782	if (ad -> found > ad -> numlines)
2783	ad -> found = 0;
2784	else
2785	{
2786	commafmt(t, sizeof(t), ad -> found);
2787	strcat(s, " (");
2788	strcat(s, t);
2789	strcat(s, GetPString(IDS_FOUNDPARENTEXT));
2790	}
2791	}
2792	WinSetWindowText(ad -> hwndStatus2, s);
2793	if (!ad -> hex && ad -> lines)
2794	commafmt(t, sizeof(t), ad -> lines[ad -> cursored - 1] - ad -> text);
2795	else
2796	commafmt(t, sizeof(t), (ad -> cursored - 1) * 16);
2797	strcpy(s, GetPString(IDS_OFFSETCOLONTEXT));
2798	strcat(s, t);
2799	WinSetWindowText(ad -> hwndStatus3, s);
2800	if (ad -> multiplier)
2801	WinSendMsg(ad -> hvscroll, SBM_SETSCROLLBAR,
2802	MPFROMSHORT((SHORT) (ad -> topline / ad -> multiplier)),
2803	MPFROM2SHORT(1, (SHORT) ((ad -> numlines + 1) /
2804	ad -> multiplier) - numlines));
2805	WinSendMsg(ad -> hhscroll, SBM_SETSCROLLBAR,
2806	MPFROMSHORT((SHORT) abs(ad -> horzscroll)),
2807	MPFROM2SHORT(0, (SHORT) (ad -> maxx - Rectl.xRight)));
2808	DosReleaseMutexSem(ad -> ScanSem);
2809	}
2810	return 0;
2811
2812	case UM_CONTAINER_FILLED:
2813	if (ad && !ad -> busy &&
2814	!DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN))
2815	{
2816	ad -> stopflag = 0;
2817	ad -> topline = 1;
2818	ad -> cursored = 1;
2819	ad -> multiplier = 1;
2820	PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
2821	WinEnableWindow(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
2822	IDM_NEXTBLANKLINE), !ad -> hex);
2823	WinEnableWindow(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
2824	IDM_PREVBLANKLINE), !ad -> hex);
2825	if (!ad -> numlines)
2826	{
2827	if (!ad -> text)
2828	Runtime_Error(pszSrcFile, __LINE__, "no data");
2829	PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
2830	}
2831	else
2832	{
2833	if (mp1 && (ULONG) mp1 < ad -> numlines + 1)
2834	{
2835
2836	RECTL Rectl;
2837	ULONG numlines;
2838
2839	WinQueryWindowRect(hwnd, &Rectl);
2840	numlines = NumLines(&Rectl, ad);
2841	if (numlines)
2842	{
2843	ad -> topline = (ULONG) mp1;
2844	if (ad -> numlines - ad -> topline < numlines)
2845	ad -> topline = ad -> numlines - numlines;
2846	ad -> cursored = (ULONG) mp1;
2847	if (mp2)
2848	{
2849	ad -> cursored = (ULONG) mp2;
2850	if (ad -> cursored > (ad -> topline - 1) + numlines)
2851	ad -> cursored = (ad -> topline - 1) + numlines;
2852	}
2853	}
2854	}
2855	WinSendMsg(hwnd, UM_SETUP3, MPVOID, MPVOID);
2856	PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
2857	WinInvalidateRect(hwnd, NULL, FALSE);
2858	}
2859	DosReleaseMutexSem(ad -> ScanSem);
2860	}
2861	else if (ad)
2862	ad -> needrefreshing = TRUE;
2863	return 0;
2864
2865	case WM_ERASEBACKGROUND:
2866	WinFillRect((HPS) mp1, (PRECTL) mp2,
2867	standardcolors[ad -> colors[COLORS_NORMALBACK]]);
2868	return 0;
2869
2870	case WM_PAINT:
2871	if (ad)
2872	{
2873
2874	HPS hpsp;
2875	RECTL Rectl;
2876	register ULONG x;
2877	ULONG numlines, wascursored = ad -> cursored;
2878
2879	hpsp = WinBeginPaint(hwnd, ad -> hps, &Rectl);
2880	WinFillRect(hpsp, &Rectl,
2881	standardcolors[ad -> colors[COLORS_NORMALBACK]]);
2882	if (!ad -> stopflag && !ad -> busy &&
2883	!DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN))
2884	{
2885	WinQueryWindowRect(hwnd, &Rectl);
2886	numlines = NumLines(&Rectl, ad);
2887	if (numlines)
2888	{
2889	if (ad -> numlines && (ad -> lines \|\| ad -> hex))
2890	{
2891	if (ad -> topline > (ad -> numlines + 1) - numlines)
2892	ad -> topline = (ad -> numlines + 1) - numlines;
2893	if (ad -> topline > ad -> numlines)
2894	ad -> topline = 1;
2895	if (!ad -> topline)
2896	ad -> topline = 1;
2897	if (ad -> cursored < ad -> topline)
2898	ad -> cursored = ad -> topline;
2899	else if (ad -> cursored > (ad -> topline + numlines) - 1)
2900	ad -> cursored = (ad -> topline + numlines) - 1;
2901	if (ad -> cursored > ad -> numlines)
2902	ad -> cursored = ad -> numlines;
2903	if (wascursored != ad -> cursored)
2904	PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
2905	}
2906	else
2907	ad -> topline = ad -> cursored = 1;
2908	if (ad -> numlines && (ad -> lines \|\| ad -> hex))
2909	{
2910	for (x = ad -> topline - 1; x < ad -> numlines; x++)
2911	{
2912	if (((LONG) (Rectl.yTop -
2913	(ad -> lMaxHeight *
2914	(((x + 1) - ad -> topline) + 1))) - ad -> lMaxDescender) <= 0)
2915	break;
2916	PaintLine(hwnd, hpsp, x, ad -> topline, &Rectl);
2917	}
2918	}
2919	}
2920	if (ad -> multiplier)
2921	WinSendMsg(ad -> hvscroll, SBM_SETSCROLLBAR,
2922	MPFROMSHORT((SHORT) (ad -> topline / ad -> multiplier)),
2923	MPFROM2SHORT(1, (SHORT) ((ad -> numlines + 1) /
2924	ad -> multiplier) - numlines));
2925	WinSendMsg(ad -> hhscroll, SBM_SETSCROLLBAR,
2926	MPFROMSHORT((SHORT) abs(ad -> horzscroll)),
2927	MPFROM2SHORT(0, (SHORT) (ad -> maxx - Rectl.xRight)));
2928	WinSendMsg(ad -> hhscroll, SBM_SETTHUMBSIZE,
2929	MPFROM2SHORT((SHORT) Rectl.xRight, (SHORT) ad -> maxx),
2930	MPVOID);
2931	DosReleaseMutexSem(ad -> ScanSem);
2932	ad -> needrefreshing = FALSE;
2933	}
2934	else
2935	ad -> needrefreshing = TRUE;
2936	WinEndPaint(hpsp);
2937	}
2938	else
2939	{
2940
2941	HPS hpsp;
2942
2943	hpsp = WinBeginPaint(hwnd, (HPS) 0, NULL);
2944	WinEndPaint(hpsp);
2945	}
2946	PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
2947	break;
2948
2949	case WM_HSCROLL:
2950	{
2951	RECTL rectl;
2952	BOOL invalidate = TRUE;
2953
2954	WinQueryWindowRect(hwnd, &rectl);
2955	switch (SHORT2FROMMP(mp2))
2956	{
2957	case SB_PAGERIGHT:
2958	if (abs(ad -> horzscroll) <= ad -> maxx - rectl.xRight)
2959	{
2960	ad -> horzscroll -= rectl.xRight;
2961	if (abs(ad -> horzscroll) > ad -> maxx - rectl.xRight)
2962	ad -> horzscroll = -((ad -> maxx - rectl.xRight) +
2963	ad -> fattrs.lAveCharWidth);
2964	}
2965	else
2966	invalidate = FALSE;
2967	break;
2968
2969	case SB_PAGELEFT:
2970	if (ad -> horzscroll < 0)
2971	{
2972	ad -> horzscroll += rectl.xRight;
2973	if (ad -> horzscroll > 0)
2974	ad -> horzscroll = 0;
2975	}
2976	else
2977	invalidate = FALSE;
2978	break;
2979
2980	case SB_LINERIGHT:
2981	if (abs(ad -> horzscroll) <= ad -> maxx - rectl.xRight)
2982	ad -> horzscroll -= ad -> fattrs.lAveCharWidth;
2983	else
2984	invalidate = FALSE;
2985	break;
2986
2987	case SB_LINELEFT:
2988	if (ad -> horzscroll < 0)
2989	ad -> horzscroll += ad -> fattrs.lAveCharWidth;
2990	else
2991	invalidate = FALSE;
2992	break;
2993
2994	case SB_SLIDERTRACK:
2995	ad -> horzscroll = (SHORT1FROMMP(mp2) / ad -> fattrs.lAveCharWidth) *
2996	ad -> fattrs.lAveCharWidth;
2997	ad -> horzscroll = -(ad -> horzscroll);
2998	if (ad -> horzscroll > 0)
2999	ad -> horzscroll = 0;
3000	if (abs(ad -> horzscroll) > (ad -> maxx - rectl.xRight) +
3001	ad -> fattrs.lAveCharWidth)
3002	ad -> horzscroll = -(ad -> maxx - rectl.xRight);
3003	break;
3004
3005	default:
3006	invalidate = FALSE;
3007	break;
3008	}
3009	if (invalidate)
3010	WinInvalidateRect(hwnd, NULL, FALSE);
3011	}
3012	break;
3013
3014	case WM_VSCROLL:
3015	if (ad && !ad -> stopflag && ad -> text && ad -> numlines && !ad -> busy &&
3016	!DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN))
3017	{
3018
3019	ULONG numlines, wascursored;
3020	RECTL rcl;
3021
3022	WinQueryWindowRect(hwnd, &rcl);
3023	numlines = NumLines(&rcl, ad);
3024	if (numlines)
3025	{
3026	wascursored = ad -> cursored;
3027	switch (SHORT2FROMMP(mp2))
3028	{
3029	case SB_PAGEUP:
3030	if (ad -> topline > 1)
3031	{
3032	ad -> topline -= numlines;
3033	if (ad -> topline > ad -> numlines \|\|
3034	ad -> topline + numlines > (ad -> numlines + 1))
3035	ad -> topline = 1;
3036	if (ad -> cursored > ad -> topline + numlines)
3037	ad -> cursored = ad -> topline + numlines;
3038	if (ad -> cursored > ad -> numlines)
3039	ad -> cursored = ad -> numlines;
3040	WinInvalidateRect(hwnd, NULL, FALSE);
3041	}
3042	break;
3043	case SB_PAGEDOWN:
3044	if (ad -> topline + numlines <= ad -> numlines)
3045	{
3046	ad -> topline += numlines;
3047	if (ad -> topline + numlines > ad -> numlines + 1)
3048	ad -> topline = (ad -> numlines + 1) - numlines;
3049	if (ad -> cursored < ad -> topline)
3050	ad -> cursored = ad -> topline;
3051	if (ad -> cursored + 1 > ad -> topline + numlines)
3052	ad -> cursored = (ad -> topline + numlines) - 1;
3053	if (ad -> cursored > ad -> numlines)
3054	ad -> cursored = ad -> numlines;
3055	WinInvalidateRect(hwnd, NULL, FALSE);
3056	}
3057	break;
3058	case SB_LINEDOWN:
3059	if (ad -> topline + numlines <= ad -> numlines)
3060	{
3061
3062	RECTL Rectl, iRectl;
3063
3064	ad -> topline++;
3065	if (ad -> cursored < ad -> topline)
3066	ad -> cursored = ad -> topline;
3067	else if (ad -> cursored + 1 > ad -> topline + numlines)
3068	ad -> cursored = (ad -> topline + numlines) - 1;
3069	if (ad -> cursored > ad -> numlines)
3070	ad -> cursored = ad -> numlines;
3071	WinQueryWindowRect(hwnd, &Rectl);
3072	WinScrollWindow(hwnd, 0, ad -> lMaxHeight,
3073	NULL, NULL, NULLHANDLE, &iRectl, 0);
3074	WinFillRect(ad -> hps, &iRectl,
3075	standardcolors[ad -> colors[COLORS_NORMALBACK]]);
3076	PaintLine(hwnd, ad -> hps, (ad -> topline + numlines) - 2,
3077	ad -> topline, &Rectl);
3078	if (ad -> cursored != ad -> topline + numlines)
3079	PaintLine(hwnd, ad -> hps, ad -> cursored - 1, ad -> topline, &Rectl);
3080	if (wascursored != ad -> cursored &&
3081	wascursored < ad -> topline + numlines &&
3082	wascursored >= ad -> topline)
3083	PaintLine(hwnd, ad -> hps, wascursored - 1, ad -> topline, &Rectl);
3084	if (numlines >= ad -> numlines)
3085	numlines = 0;
3086	if (ad -> multiplier)
3087	WinSendMsg(ad -> hvscroll, SBM_SETSCROLLBAR,
3088	MPFROMSHORT((SHORT) (ad -> topline / ad -> multiplier)),
3089	MPFROM2SHORT(1, (SHORT) ((ad -> numlines + 1) /
3090	ad -> multiplier) -
3091	numlines));
3092	WinSendMsg(ad -> hhscroll, SBM_SETSCROLLBAR,
3093	MPFROMSHORT((SHORT) abs(ad -> horzscroll)),
3094	MPFROM2SHORT(0, (SHORT) (ad -> maxx - Rectl.xRight)));
3095	}
3096	break;
3097	case SB_LINEUP:
3098	if (ad -> topline > 1)
3099	{
3100
3101	RECTL Rectl, iRectl;
3102
3103	ad -> topline--;
3104	if (ad -> cursored < ad -> topline)
3105	ad -> cursored = ad -> topline;
3106	else if (ad -> cursored + 1 > ad -> topline + numlines)
3107	ad -> cursored = (ad -> topline + numlines) - 1;
3108	if (ad -> cursored > ad -> numlines)
3109	ad -> cursored = ad -> numlines;
3110	WinQueryWindowRect(hwnd, &Rectl);
3111	WinScrollWindow(hwnd, 0, -ad -> lMaxHeight,
3112	NULL, NULL, NULLHANDLE, &iRectl, 0);
3113	WinFillRect(ad -> hps, &iRectl,
3114	standardcolors[ad -> colors[COLORS_NORMALBACK]]);
3115	iRectl = Rectl;
3116	iRectl.yTop -= ((numlines * ad -> lMaxHeight) +
3117	ad -> lMaxDescender);
3118	WinFillRect(ad -> hps, &iRectl,
3119	standardcolors[ad -> colors[COLORS_NORMALBACK]]);
3120	PaintLine(hwnd, ad -> hps, ad -> topline - 1, ad -> topline, &Rectl);
3121	if (ad -> cursored != ad -> topline)
3122	PaintLine(hwnd, ad -> hps, ad -> cursored - 1, ad -> topline, &Rectl);
3123	if (ad -> cursored != wascursored &&
3124	wascursored >= ad -> topline &&
3125	wascursored < ad -> topline + numlines)
3126	PaintLine(hwnd, ad -> hps, wascursored - 1, ad -> topline, &Rectl);
3127	if (numlines >= ad -> numlines)
3128	numlines = 0;
3129	if (ad -> multiplier)
3130	WinSendMsg(ad -> hvscroll, SBM_SETSCROLLBAR,
3131	MPFROMSHORT((SHORT) (ad -> topline / ad -> multiplier)),
3132	MPFROM2SHORT(1, (SHORT) ((ad -> numlines + 1) /
3133	ad -> multiplier) -
3134	numlines));
3135	WinSendMsg(ad -> hhscroll, SBM_SETSCROLLBAR,
3136	MPFROMSHORT((SHORT) abs(ad -> horzscroll)),
3137	MPFROM2SHORT(0, (SHORT) (ad -> maxx - Rectl.xRight)));
3138	}
3139	break;
3140	case SB_SLIDERTRACK:
3141	if ((SHORT1FROMMP(mp2) >= 1) \|\|
3142	(SHORT1FROMMP(mp2)) <= ad -> numlines)
3143	{
3144	ad -> topline = (ULONG) SHORT1FROMMP(mp2) * ad -> multiplier;
3145	if (ad -> topline + numlines > ad -> numlines + 1)
3146	ad -> topline = (ad -> numlines + 1) - numlines;
3147	if (!ad -> topline)
3148	ad -> topline = 1;
3149	if (ad -> cursored < ad -> topline)
3150	ad -> cursored = ad -> topline;
3151	else if (ad -> cursored > ad -> topline + numlines)
3152	ad -> cursored = ad -> topline + numlines;
3153	if (ad -> cursored > ad -> numlines)
3154	ad -> cursored = ad -> numlines;
3155	WinInvalidateRect(hwnd, NULL, FALSE);
3156	}
3157	else
3158	WinAlarm(HWND_DESKTOP, WA_NOTE);
3159	break;
3160	}
3161	if (ad -> cursored != wascursored)
3162	PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
3163	}
3164	DosReleaseMutexSem(ad -> ScanSem);
3165	}
3166	break;
3167
3168	case WM_INITMENU:
3169	switch (SHORT1FROMMP(mp1))
3170	{
3171	case IDM_FILESMENU:
3172	{
3173	APIRET rc;
3174	SHORT sSelect;
3175
3176	rc = DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN);
3177	WinEnableMenuItem((HWND) mp2, IDM_SAVETOCLIP, (rc == 0 &&
3178	ad -> selected != 0));
3179	WinEnableMenuItem((HWND) mp2, IDM_APPENDTOCLIP, (rc == 0 &&
3180	ad -> selected != 0));
3181	WinEnableMenuItem((HWND) mp2, IDM_SAVETOLIST, (rc == 0 &&
3182	ad -> selected != 0));
3183	sSelect = (SHORT) WinSendDlgItemMsg(ad -> hwndFrame, NEWVIEW_LISTBOX,
3184	LM_QUERYITEMCOUNT, MPVOID, MPVOID);
3185	WinEnableMenuItem((HWND) mp2, IDM_SAVETOCLIP2, (rc == 0 &&
3186	sSelect > 0));
3187	WinEnableMenuItem((HWND) mp2, IDM_APPENDTOCLIP2, (rc == 0 &&
3188	sSelect > 0));
3189	WinEnableMenuItem((HWND) mp2, IDM_SAVETOLIST2, (rc == 0 &&
3190	sSelect > 0));
3191	if (!rc)
3192	DosReleaseMutexSem(ad -> ScanSem);
3193	}
3194	break;
3195
3196	case IDM_VIEWSMENU:
3197	{
3198	APIRET rc;
3199
3200	rc = DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN);
3201	WinEnableMenuItem((HWND) mp2, IDM_FONTPALETTE, (rc == 0));
3202	WinEnableMenuItem((HWND) mp2, IDM_HEXMODE, (rc == 0));
3203	WinEnableMenuItem((HWND) mp2, IDM_WRAP, (rc == 0));
3204	WinEnableMenuItem((HWND) mp2, IDM_CODEPAGE, (rc == 0));
3205	if (!rc)
3206	DosReleaseMutexSem(ad -> ScanSem);
3207	}
3208	WinCheckMenuItem((HWND) mp2, IDM_HEXMODE, ad -> hex);
3209	WinCheckMenuItem((HWND) mp2, IDM_WRAP, ad -> wrapon);
3210	WinCheckMenuItem((HWND) mp2, IDM_IGNOREFTP, ad -> ignoreftp);
3211	WinCheckMenuItem((HWND) mp2, IDM_IGNOREHTTP, ad -> ignorehttp);
3212	break;
3213
3214	case IDM_SEARCHMENU:
3215	{
3216	APIRET rc;
3217
3218	rc = DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN);
3219	WinEnableMenuItem((HWND) mp2, IDM_FINDFIRST, (rc == 0 &&
3220	ad -> numlines != 0 &&
3221	ad -> markedlines));
3222	WinEnableMenuItem((HWND) mp2, IDM_FINDNEXT, (rc == 0 &&
3223	ad -> numlines != 0 &&
3224	ad -> markedlines &&
3225	ad -> found != 0));
3226	WinEnableMenuItem((HWND) mp2, IDM_FINDPREV, (rc == 0 &&
3227	ad -> numlines != 0 &&
3228	ad -> markedlines &&
3229	ad -> found != 0));
3230	WinEnableMenuItem((HWND) mp2, IDM_NEXTBLANKLINE, (rc == 0 &&
3231	ad -> numlines != 0 &&
3232	!ad -> hex));
3233	WinEnableMenuItem((HWND) mp2, IDM_PREVBLANKLINE, (rc == 0 &&
3234	ad -> numlines != 0 &&
3235	!ad -> hex));
3236	WinEnableMenuItem((HWND) mp2, IDM_GOTOLINE, (rc == 0 &&
3237	ad -> numlines != 0));
3238	WinEnableMenuItem((HWND) mp2, IDM_GOTOOFFSET, (rc == 0 &&
3239	ad -> textsize != 0));
3240	if (!rc)
3241	DosReleaseMutexSem(ad -> ScanSem);
3242	}
3243	break;
3244
3245	case IDM_SELECTSUBMENU:
3246	{
3247	APIRET rc;
3248
3249	rc = DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN);
3250	WinEnableMenuItem((HWND) mp2, IDM_SELECTALL, (rc == 0 &&
3251	ad -> numlines != 0 &&
3252	ad -> markedlines &&
3253	(ad -> selected !=
3254	ad -> numlines \|\|
3255	!ad -> selected)));
3256	WinEnableMenuItem((HWND) mp2, IDM_DESELECTALL, (rc == 0 &&
3257	ad -> numlines != 0 &&
3258	ad -> markedlines &&
3259	ad -> selected != 0));
3260	WinEnableMenuItem((HWND) mp2, IDM_DESELECTFOUND, (rc == 0 &&
3261	ad -> numlines != 0 &&
3262	ad -> markedlines &&
3263	ad -> selected != 0 &&
3264	ad -> found != 0));
3265	WinEnableMenuItem((HWND) mp2, IDM_SELECTFOUND, (rc == 0 &&
3266	ad -> numlines != 0 &&
3267	ad -> markedlines &&
3268	ad -> found != 0 &&
3269	(ad -> numlines !=
3270	ad -> selected \|\|
3271	!ad -> selected)));
3272	WinEnableMenuItem((HWND) mp2, IDM_NEXTSELECTED, (rc == 0 &&
3273	ad -> numlines != 0 &&
3274	ad -> markedlines &&
3275	ad -> selected != 0));
3276	WinEnableMenuItem((HWND) mp2, IDM_PREVSELECTED, (rc == 0 &&
3277	ad -> numlines != 0 &&
3278	ad -> markedlines &&
3279	ad -> selected != 0));
3280	WinEnableMenuItem((HWND) mp2, IDM_INVERT, (rc == 0 &&
3281	ad -> numlines != 0 &&
3282	ad -> markedlines));
3283	if (!rc)
3284	DosReleaseMutexSem(ad -> ScanSem);
3285	}
3286	break;
3287	}
3288	break;
3289
3290	case UM_CONTROL:
3291	switch (SHORT1FROMMP(mp1))
3292	{
3293	case NEWVIEW_LISTBOX:
3294	switch (SHORT2FROMMP(mp1))
3295	{
3296	case LN_SETFOCUS:
3297	if (ad)
3298	{
3299	if (!ad -> clientfocused)
3300	{
3301	PostMsg(hwnd,
3302	WM_COMMAND,
3303	MPFROM2SHORT(IDM_NEXTWINDOW, 0),
3304	MPVOID);
3305	break;
3306	}
3307	ad -> clientfocused = FALSE;
3308	}
3309	PostMsg(hwnd,
3310	UM_CONTROL,
3311	MPFROM2SHORT(NEWVIEW_LISTBOX,
3312	LN_SELECT),
3313	MPVOID);
3314	break;
3315	case LN_KILLFOCUS:
3316	if (ad)
3317	{
3318	ad -> clientfocused = TRUE;
3319	WinSetFocus(HWND_DESKTOP, hwnd);
3320	}
3321	break;
3322	case LN_SELECT:
3323	if (ad && !ad -> dummy)
3324	{
3325
3326	ULONG linenum, numlines;
3327	SHORT sSelect;
3328	HWND hwndUL = WinWindowFromID(ad -> hwndFrame,
3329	SHORT1FROMMP(mp1));
3330	RECTL Rectl;
3331
3332	sSelect = (SHORT) WinSendMsg(hwndUL,
3333	LM_QUERYSELECTION,
3334	MPFROM2SHORT(LIT_FIRST, 0),
3335	MPVOID);
3336	if (sSelect >= 0)
3337	{
3338	linenum = (ULONG) WinSendMsg(hwndUL,
3339	LM_QUERYITEMHANDLE,
3340	MPFROM2SHORT(sSelect, 0),
3341	MPVOID);
3342	if (ad -> topline != linenum + 1 &&
3343	linenum < ad -> numlines)
3344	{
3345	WinQueryWindowRect(hwnd, &Rectl);
3346	numlines = NumLines(&Rectl, ad);
3347	ad -> topline = linenum + 1;
3348	if (ad -> numlines - ad -> topline < numlines)
3349	ad -> topline = ad -> numlines - numlines;
3350	ad -> cursored = linenum + 1;
3351	WinInvalidateRect(hwnd, NULL, FALSE);
3352	PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
3353	PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
3354	}
3355	}
3356	else
3357	PostMsg(hwndUL, LM_SELECTITEM, MPFROM2SHORT(0, 0),
3358	MPFROM2SHORT(TRUE, 0));
3359	}
3360	break;
3361
3362	case LN_ENTER:
3363	if (ad)
3364	{
3365
3366	SHORT sSelect;
3367	HWND hwndUL = WinWindowFromID(ad -> hwndFrame,
3368	SHORT1FROMMP(mp1));
3369
3370	sSelect = (SHORT) WinSendMsg(hwndUL,
3371	LM_QUERYSELECTION,
3372	MPFROM2SHORT(LIT_FIRST, 0),
3373	MPVOID);
3374	if (sSelect >= 0)
3375	{
3376	ad -> dummy = TRUE;
3377	WinSendMsg(hwndUL, LM_DELETEITEM,
3378	MPFROM2SHORT(sSelect, 0), MPVOID);
3379	ad -> dummy = FALSE;
3380	sSelect = (SHORT) WinSendMsg(hwndUL,
3381	LM_QUERYITEMCOUNT,
3382	MPVOID,
3383	MPVOID);
3384	if (sSelect <= 0)
3385	{
3386	PostMsg(ad -> hwndFrame, WM_UPDATEFRAME,
3387	MPFROMLONG(FCF_SIZEBORDER), MPVOID);
3388	WinSetFocus(HWND_DESKTOP, hwnd);
3389	}
3390	}
3391	}
3392	break;
3393
3394	default:
3395	break;
3396	}
3397	break;
3398
3399	default:
3400	break;
3401	}
3402	return 0;
3403
3404	case WM_COMMAND:
3405	switch (SHORT1FROMMP(mp1))
3406	{
3407	case IDM_EDIT:
3408	if (*editor)
3409	{
3410
3411	CHAR *dummy[2];
3412
3413	dummy[0] = ad -> filename;
3414	dummy[1] = NULL;
3415	ExecOnList(hwnd, editor, WINDOWED \| SEPARATE, NULL, dummy, NULL);
3416	}
3417	else
3418	StartMLEEditor(ad -> hwndParent, 4, ad -> filename,
3419	ad -> hwndFrame);
3420	ad -> hwndRestore = (HWND) 0;
3421	PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
3422	break;
3423
3424	case IDM_IGNOREFTP:
3425	ad -> ignoreftp = (ad -> ignoreftp) ? FALSE : TRUE;
3426	ad -> ftpin = FALSE;
3427	if (ad -> text && *ftprun && !ad -> ignoreftp &&
3428	strstr(ad -> text, "ftp://"))
3429	ad -> ftpin = TRUE;
3430	IgnoreFTP = ad -> ignoreftp;
3431	PrfWriteProfileData(fmprof, appname, "Viewer.IgnoreFTP",
3432	&ad -> ignoreftp, sizeof(BOOL));
3433	WinInvalidateRect(hwnd, NULL, FALSE);
3434	break;
3435
3436	case IDM_IGNOREHTTP:
3437	ad -> ignorehttp = (ad -> ignorehttp) ? FALSE : TRUE;
3438	ad -> httpin = FALSE;
3439	if (ad -> text && *httprun && !ad -> ignorehttp &&
3440	strstr(ad -> text, "http://"))
3441	ad -> httpin = TRUE;
3442	IgnoreHTTP = ad -> ignorehttp;
3443	PrfWriteProfileData(fmprof, appname, "Viewer.IgnoreHTTP",
3444	&ad -> ignorehttp, sizeof(BOOL));
3445	WinInvalidateRect(hwnd, NULL, FALSE);
3446	break;
3447
3448	case IDM_PREVBLANKLINE:
3449	if (!ad -> hex && ad -> lines)
3450	{
3451
3452	ULONG x;
3453
3454	x = ad -> cursored - 2;
3455	if (x >= ad -> numlines)
3456	x = 0;
3457	while (x < ad -> numlines &&
3458	(ad -> lines[x] == '\r' \|\| ad -> lines[x] == '\n'))
3459	x--;
3460	if (x >= ad -> numlines)
3461	x = 0;
3462	for (; x < ad -> numlines; x--)
3463	{
3464	if (ad -> lines[x] == '\r' \|\| ad -> lines[x] == '\n')
3465	{
3466	if (x < ad -> numlines - 1)
3467	x++;
3468	break;
3469	}
3470	}
3471	if (x < ad -> numlines)
3472	{
3473	ad -> topline = ad -> cursored = x;
3474	WinInvalidateRect(hwnd, NULL, FALSE);
3475	}
3476	}
3477	break;
3478
3479	case IDM_NEXTBLANKLINE:
3480	if (!ad -> hex && ad -> lines)
3481	{
3482
3483	ULONG x;
3484
3485	x = ad -> cursored;
3486	while (x < ad -> numlines &&
3487	(ad -> lines[x] == '\r' \|\| ad -> lines[x] == '\n'))
3488	x++;
3489	for (; x < ad -> numlines; x++)
3490	{
3491	if (ad -> lines[x] == '\r' \|\| ad -> lines[x] == '\n')
3492	{
3493	if (x < ad -> numlines - 1)
3494	x++;
3495	break;
3496	}
3497	}
3498	if (x < ad -> numlines)
3499	{
3500	while (x < ad -> numlines &&
3501	(ad -> lines[x] == '\r' \|\| ad -> lines[x] == '\n'))
3502	x++;
3503	if (x < ad -> numlines)
3504	{
3505	ad -> topline = ad -> cursored = x;
3506	WinInvalidateRect(hwnd, NULL, FALSE);
3507	}
3508	}
3509	}
3510	break;
3511
3512	case IDM_VIEW:
3513	case IDM_OBJECT:
3514	if (!ad -> hex && ad -> lines)
3515	{
3516
3517	CHAR line[CCHMAXPATH], filename[CCHMAXPATH], *p;
3518
3519	strncpy(line, ad -> lines[ad -> cursored - 1], CCHMAXPATH);
3520	line[CCHMAXPATH - 1] = 0;
3521	chop_at_crnl(line);
3522	if (*line == '\"')
3523	{
3524	memmove(line, line + 1, strlen(line));
3525	p = strchr(line, '\"');
3526	lstrip(line);
3527	if (p)
3528	*p = 0;
3529	rstrip(line);
3530	}
3531	else
3532	{
3533	lstrip(line);
3534	p = strchr(line, ' ');
3535	if (p)
3536	*p = 0;
3537	rstrip(line);
3538	}
3539	if (!strchr(line, '\\') && !strchr(line, '/') && !strchr(line, ':'))
3540	{
3541	strcpy(filename, ad -> filename);
3542	p = strrchr(filename, '\\');
3543	if (p)
3544	p++;
3545	else
3546	p = filename;
3547	strcpy(p, line);
3548	}
3549	else
3550	strcpy(filename, line);
3551	MakeFullName(filename);
3552	if (*filename &&
3553	IsFile(filename) == 1)
3554	{
3555	if (SHORT1FROMMP(mp1) == IDM_OBJECT)
3556	OpenObject(filename,
3557	Default,
3558	ad -> hwndFrame);
3559	else
3560	DefaultView(hwnd,
3561	ad -> hwndFrame,
3562	HWND_DESKTOP,
3563	NULL,
3564	0,
3565	filename);
3566	}
3567	}
3568	break;
3569
3570	case IDM_COLORPALETTE:
3571	{
3572	COLORS co;
3573	LONG temp[COLORS_MAX];
3574
3575	memset(&co, 0, sizeof(co));
3576	co.size = sizeof(co);
3577	co.numcolors = COLORS_MAX;
3578	co.colors = ad -> colors;
3579	co.descriptions = IDS_NVCOLORS1TEXT;
3580	co.origs = temp;
3581	co.prompt = IDS_NVCOLORSPROMPTTEXT;
3582	memcpy(temp,
3583	ad -> colors,
3584	sizeof(LONG) * COLORS_MAX);
3585	if (WinDlgBox(HWND_DESKTOP,
3586	hwnd,
3587	ColorDlgProc,
3588	FM3ModHandle,
3589	COLOR_FRAME,
3590	(PVOID) & co))
3591	{
3592	memcpy(Colors,
3593	ad -> colors,
3594	sizeof(LONG) * COLORS_MAX);
3595	PrfWriteProfileData(fmprof,
3596	appname,
3597	"Viewer.Colors",
3598	&ad -> colors,
3599	sizeof(LONG) * COLORS_MAX);
3600	WinInvalidateRect(hwnd,
3601	NULL,
3602	FALSE);
3603	WinInvalidateRect(ad -> hwndStatus1,
3604	NULL,
3605	FALSE);
3606	WinInvalidateRect(ad -> hwndStatus2,
3607	NULL,
3608	FALSE);
3609	WinInvalidateRect(ad -> hwndStatus3,
3610	NULL,
3611	FALSE);
3612	}
3613	}
3614	break;
3615
3616	case IDM_NEXTWINDOW:
3617	case IDM_PREVWINDOW:
3618	{
3619	SHORT sSelect;
3620
3621	sSelect = (SHORT) WinSendDlgItemMsg(ad -> hwndFrame,
3622	NEWVIEW_LISTBOX,
3623	LM_QUERYITEMCOUNT,
3624	MPVOID,
3625	MPVOID);
3626	if (sSelect)
3627	{
3628	if (!ad -> clientfocused)
3629	WinSetFocus(HWND_DESKTOP, hwnd);
3630	else
3631	WinSetFocus(HWND_DESKTOP,
3632	WinWindowFromID(ad -> hwndFrame,
3633	NEWVIEW_LISTBOX));
3634	}
3635	else
3636	WinSetFocus(HWND_DESKTOP, hwnd);
3637	}
3638	break;
3639
3640	case IDM_FINDFIRST:
3641	{
3642	APIRET rc;
3643
3644	rc = DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN);
3645	if (!rc)
3646	{
3647	if (!ad -> busy && ad -> text && ad -> numlines && ad -> markedlines)
3648	{
3649
3650	ULONG numlines;
3651	RECTL Rectl;
3652	static char test[SEARCHSTRINGLEN];
3653
3654	WinQueryWindowRect(hwnd, &Rectl);
3655	numlines = NumLines(&Rectl, ad);
3656	if (!numlines)
3657	break;
3658	strcpy(test, ad -> searchtext);
3659	if (WinDlgBox(HWND_DESKTOP, hwnd, FindStrDlgProc, FM3ModHandle,
3660	NEWFIND_FRAME, (PVOID) & hwnd))
3661	{
3662	if (*ad -> searchtext &&
3663	strcmp(test, ad -> searchtext))
3664	PrfWriteProfileString(fmprof,
3665	appname,
3666	"Viewer.Searchtext",
3667	(PVOID) ad -> searchtext);
3668	if (_beginthread(Search, NULL, 524288, (PVOID) hwnd) == -1)
3669	Runtime_Error(pszSrcFile, __LINE__, GetPString(IDS_COULDNTSTARTTHREADTEXT));
3670	}
3671	}
3672	DosReleaseMutexSem(ad -> ScanSem);
3673	}
3674	}
3675	break;
3676
3677	case IDM_PREVSELECTED:
3678	case IDM_NEXTSELECTED:
3679	case IDM_FINDPREV:
3680	case IDM_FINDNEXT:
3681	{
3682	APIRET rc;
3683
3684	rc = DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN);
3685	if (!rc)
3686	{
3687	if (!ad -> busy && ad -> text && ad -> markedlines)
3688	{
3689
3690	RECTL Rectl;
3691	register ULONG x;
3692	ULONG numlines;
3693	CHAR markedwith;
3694
3695	markedwith = (SHORT1FROMMP(mp1) == IDM_FINDNEXT \|\|
3696	SHORT1FROMMP(mp1) == IDM_FINDPREV) ?
3697	VF_FOUND : VF_SELECTED;
3698	WinQueryWindowRect(hwnd, &Rectl);
3699	numlines = NumLines(&Rectl, ad);
3700	if (!numlines)
3701	break;
3702	WinSetPointer(HWND_DESKTOP, hptrBusy);
3703	if (SHORT1FROMMP(mp1) == IDM_PREVSELECTED \|\|
3704	SHORT1FROMMP(mp1) == IDM_FINDPREV)
3705	{
3706	for (x = ad -> cursored - 2; x < ULONG_MAX - 1; x--)
3707	{
3708	if (ad -> markedlines[x] & markedwith)
3709	{
3710	ad -> topline = x + 1;
3711	if (ad -> numlines - ad -> topline < numlines)
3712	ad -> topline = ad -> numlines - numlines;
3713	ad -> cursored = x + 1;
3714	WinInvalidateRect(hwnd, NULL, FALSE);
3715	PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
3716	break;
3717	}
3718	}
3719	}
3720	else
3721	{
3722	for (x = ad -> cursored; x < ad -> numlines; x++)
3723	{
3724	if (ad -> markedlines[x] & markedwith)
3725	{
3726	ad -> topline = x + 1;
3727	if (ad -> numlines - ad -> topline < numlines)
3728	ad -> topline = ad -> numlines - numlines;
3729	ad -> cursored = x + 1;
3730	WinInvalidateRect(hwnd, NULL, FALSE);
3731	PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
3732	break;
3733	}
3734	}
3735	}
3736	WinSetPointer(HWND_DESKTOP, hptrArrow);
3737	if (x >= ad -> numlines)
3738	DosBeep(50, 100);
3739	}
3740	DosReleaseMutexSem(ad -> ScanSem);
3741	}
3742	}
3743	break;
3744
3745	case IDM_SELECTFOUND:
3746	case IDM_DESELECTFOUND:
3747	{
3748	APIRET rc;
3749
3750	rc = DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN);
3751	if (!rc)
3752	{
3753	if (!ad -> busy && ad -> text && ad -> markedlines)
3754	{
3755
3756	RECTL Rectl;
3757	register ULONG x;
3758	ULONG numlines;
3759
3760	WinQueryWindowRect(hwnd, &Rectl);
3761	numlines = NumLines(&Rectl, ad);
3762	if (!numlines)
3763	break;
3764	WinSetPointer(HWND_DESKTOP, hptrBusy);
3765	for (x = 0; x < ad -> numlines; x++)
3766	{
3767	if (SHORT1FROMMP(mp1) == IDM_SELECTFOUND)
3768	{
3769	if ((ad -> markedlines[x] & VF_FOUND) &&
3770	!(ad -> markedlines[x] & VF_SELECTED))
3771	{
3772	ad -> markedlines[x] \|= VF_SELECTED;
3773	ad -> selected++;
3774	}
3775	}
3776	else
3777	{
3778	if ((ad -> markedlines[x] & VF_FOUND) &&
3779	(ad -> markedlines[x] & VF_SELECTED))
3780	{
3781	ad -> markedlines[x] &= (~VF_SELECTED);
3782	ad -> selected--;
3783	}
3784	}
3785	}
3786	WinSendMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
3787	WinSetPointer(HWND_DESKTOP, hptrArrow);
3788	WinInvalidateRect(hwnd, NULL, FALSE);
3789	}
3790	DosReleaseMutexSem(ad -> ScanSem);
3791	}
3792	}
3793	break;
3794
3795	case IDM_GOTOLINE:
3796	case IDM_GOTOOFFSET:
3797	{
3798	APIRET rc;
3799
3800	rc = DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN);
3801	if (!rc)
3802	{
3803	if (!ad -> busy && ad -> numlines)
3804	{
3805
3806	ULONG numlines, linenum;
3807	CHAR s[34], ss[134];
3808	STRINGINPARMS sip;
3809	RECTL Rectl;
3810	register ULONG x;
3811
3812	WinQueryWindowRect(hwnd, &Rectl);
3813	numlines = NumLines(&Rectl, ad);
3814	if (!numlines)
3815	break;
3816	if (ad -> numlines <= numlines)
3817	{
3818	DosBeep(500, 100);
3819	break;
3820	}
3821	sip.help = (SHORT1FROMMP(mp1) == IDM_GOTOLINE) ?
3822	GetPString(IDS_NVLINEJUMPTEXT) :
3823	GetPString(IDS_NVBYTEJUMPTEXT);
3824	sip.ret = s;
3825	*s = 0;
3826	sip.prompt = ss;
3827	sip.inputlen = 34;
3828	sip.title = (SHORT1FROMMP(mp1) == IDM_GOTOLINE) ?
3829	GetPString(IDS_NVLINEJUMPTITLETEXT) :
3830	GetPString(IDS_NVBYTEJUMPTITLETEXT);
3831	sprintf(sip.prompt,
3832	GetPString(IDS_NVJUMPTEXT),
3833	(SHORT1FROMMP(mp1) == IDM_GOTOLINE) ?
3834	GetPString(IDS_LINETEXT) :
3835	GetPString(IDS_OFFSETTEXT),
3836	(SHORT1FROMMP(mp1) == IDM_GOTOLINE) ?
3837	1 :
3838	0,
3839	(SHORT1FROMMP(mp1) == IDM_GOTOLINE) ?
3840	ad -> numlines :
3841	ad -> textsize - 1);
3842	WinDlgBox(HWND_DESKTOP,
3843	hwnd,
3844	InputDlgProc,
3845	FM3ModHandle,
3846	STR_FRAME,
3847	&sip);
3848	if (*s)
3849	{
3850	s[33] = 0;
3851	linenum = atol(s);
3852	switch (SHORT1FROMMP(mp1))
3853	{
3854	case IDM_GOTOLINE:
3855	if (linenum > 0 &&
3856	linenum <= ad -> numlines)
3857	{
3858	ad -> topline = linenum;
3859	ad -> cursored = ad -> topline;
3860	if (ad -> numlines - ad -> topline < numlines)
3861	ad -> topline = (ad -> numlines - numlines) + 1;
3862	WinInvalidateRect(hwnd,
3863	NULL,
3864	FALSE);
3865	}
3866	break;
3867	case IDM_GOTOOFFSET:
3868	if (linenum < ad -> textsize)
3869	{
3870	if (ad -> hex)
3871	ad -> topline = (linenum / 16) + 1;
3872	else if (ad -> lines)
3873	{
3874	ad -> topline = (ULONG) - 1;
3875	for (x = 0; x < ad -> numlines; x++)
3876	{
3877	if (ad -> lines[x] > ad -> text + linenum)
3878	{
3879	ad -> topline = x + 1;
3880	break;
3881	}
3882	}
3883	if (ad -> topline == (ULONG) - 1)
3884	ad -> topline = ad -> numlines;
3885	}
3886	ad -> cursored = ad -> topline;
3887	if (ad -> numlines - ad -> topline < numlines)
3888	ad -> topline = (ad -> numlines - numlines) + 1;
3889	WinInvalidateRect(hwnd,
3890	NULL,
3891	FALSE);
3892	}
3893	break;
3894	}
3895	}
3896	PostMsg(hwnd,
3897	UM_SETUP4,
3898	MPVOID,
3899	MPVOID);
3900	}
3901	DosReleaseMutexSem(ad -> ScanSem);
3902	}
3903	}
3904	break;
3905
3906	case IDM_CODEPAGE:
3907	{
3908	INT cp;
3909
3910	cp = PickCodepage(hwnd);
3911	if (cp != -1)
3912	{
3913	ad -> fattrs.usCodePage = (USHORT) cp;
3914	Codepage = ad -> fattrs.usCodePage;
3915	PrfWriteProfileData(fmprof,
3916	appname,
3917	"Viewer.Codepage",
3918	&ad -> fattrs.usCodePage,
3919	sizeof(USHORT));
3920	GpiDeleteSetId(ad -> hps,
3921	FIXED_FONT_LCID);
3922	GpiAssociate(ad -> hps, 0);
3923	GpiDestroyPS(ad -> hps);
3924	ad -> hps = InitWindow(hwnd);
3925	WinSendMsg(hwnd,
3926	UM_SETUP3,
3927	MPVOID,
3928	MPVOID);
3929	PostMsg(hwnd,
3930	UM_SETUP4,
3931	MPVOID,
3932	MPVOID);
3933	WinInvalidateRect(hwnd,
3934	NULL,
3935	FALSE);
3936	}
3937	}
3938	break;
3939
3940	case IDM_SAVETOLIST2:
3941	case IDM_SAVETOCLIP2:
3942	case IDM_APPENDTOCLIP2:
3943	case IDM_SAVETOLIST:
3944	case IDM_SAVETOCLIP:
3945	case IDM_APPENDTOCLIP:
3946	{
3947	APIRET rc;
3948
3949	rc = DosRequestMutexSem(ad -> ScanSem,
3950	SEM_IMMEDIATE_RETURN);
3951	if (!rc)
3952	{
3953	if (!ad -> busy)
3954	{
3955	ad -> cliptype = SHORT1FROMMP(mp1);
3956	if (_beginthread(Clipboard,NULL,524288,(PVOID) hwnd) == -1)
3957	Runtime_Error(pszSrcFile, __LINE__, GetPString(IDS_COULDNTSTARTTHREADTEXT));
3958	}
3959	DosReleaseMutexSem(ad -> ScanSem);
3960	}
3961	}
3962	break;
3963
3964	case IDM_SELECTALL:
3965	case IDM_DESELECTALL:
3966	case IDM_INVERT:
3967	{
3968	APIRET rc;
3969
3970	rc = DosRequestMutexSem(ad -> ScanSem,
3971	SEM_IMMEDIATE_RETURN);
3972	if (!rc)
3973	{
3974	if (!ad -> busy && ad -> markedlines)
3975	{
3976
3977	register ULONG x;
3978
3979	for (x = 0; x < ad -> numlines; x++)
3980	{
3981	switch (SHORT1FROMMP(mp1))
3982	{
3983	case IDM_SELECTALL:
3984	if (!(ad -> markedlines[x] & VF_SELECTED))
3985	{
3986	ad -> markedlines[x] \|= VF_SELECTED;
3987	ad -> selected++;
3988	}
3989	break;
3990	case IDM_DESELECTALL:
3991	if (ad -> markedlines[x] & VF_SELECTED)
3992	{
3993	ad -> markedlines[x] &= (~VF_SELECTED);
3994	ad -> selected--;
3995	}
3996	break;
3997	case IDM_INVERT:
3998	if (ad -> markedlines[x] & VF_SELECTED)
3999	{
4000	ad -> markedlines[x] &= (~VF_SELECTED);
4001	ad -> selected--;
4002	}
4003	else
4004	{
4005	ad -> markedlines[x] \|= VF_SELECTED;
4006	ad -> selected++;
4007	}
4008	break;
4009	}
4010	}
4011	WinSendMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
4012	WinInvalidateRect(hwnd, NULL, FALSE);
4013	}
4014	DosReleaseMutexSem(ad -> ScanSem);
4015	}
4016	}
4017	break;
4018
4019	case IDM_WRAP:
4020	{
4021	APIRET rc;
4022
4023	rc = DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN);
4024	if (!rc)
4025	{
4026	if (!ad -> busy)
4027	{
4028	ad -> wrapon = ad -> wrapon ? FALSE : TRUE;
4029	WrapOn = ad -> wrapon;
4030	PrfWriteProfileData(fmprof, appname, "Viewer.WrapOn",
4031	&ad -> wrapon, sizeof(BOOL));
4032	PostMsg(hwnd, UM_SETUP2, MPVOID, MPVOID);
4033	PostMsg(hwnd, UM_SETUP3, MPVOID, MPVOID);
4034	PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
4035	if (WinSendDlgItemMsg(ad -> hwndFrame, NEWVIEW_LISTBOX,
4036	LM_QUERYITEMCOUNT, MPVOID, MPVOID))
4037	WinSendDlgItemMsg(ad -> hwndFrame, NEWVIEW_LISTBOX, LM_DELETEALL,
4038	MPVOID, MPVOID);
4039	ad -> oldwidth = -1;
4040	WinSendMsg(ad -> hvscroll, SBM_SETTHUMBSIZE,
4041	MPFROM2SHORT(1, 1),
4042	MPVOID);
4043	WinSendMsg(ad -> hvscroll, SBM_SETSCROLLBAR,
4044	MPFROMSHORT(1), MPFROM2SHORT(1, 1));
4045	WinSendMsg(ad -> hhscroll, SBM_SETTHUMBSIZE,
4046	MPFROM2SHORT(1, 1),
4047	MPVOID);
4048	WinSendMsg(ad -> hhscroll, SBM_SETSCROLLBAR,
4049	MPFROMSHORT(1), MPFROM2SHORT(1, 1));
4050	WinSendMsg(ad -> hwndFrame, WM_UPDATEFRAME,
4051	MPFROMLONG(FCF_SIZEBORDER), MPVOID);
4052	WinInvalidateRect(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
4053	NEWVIEW_DRAG), NULL, FALSE);
4054	WinInvalidateRect(ad -> hhscroll, NULL, FALSE);
4055	}
4056	DosReleaseMutexSem(ad -> ScanSem);
4057	}
4058	}
4059	break;
4060
4061	case IDM_HEXMODE:
4062	{
4063	APIRET rc;
4064
4065	rc = DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN);
4066	if (!rc)
4067	{
4068	if (!ad -> busy)
4069	{
4070	ad -> hex = (ad -> hex) ? FALSE : TRUE;
4071	WinEnableWindow(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
4072	IDM_NEXTBLANKLINE), !ad -> hex);
4073	WinEnableWindow(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
4074	IDM_PREVBLANKLINE), !ad -> hex);
4075	PostMsg(hwnd, UM_SETUP2, MPVOID, MPVOID);
4076	PostMsg(hwnd, UM_SETUP3, MPVOID, MPVOID);
4077	PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
4078	if (WinSendDlgItemMsg(ad -> hwndFrame, NEWVIEW_LISTBOX,
4079	LM_QUERYITEMCOUNT, MPVOID, MPVOID))
4080	WinSendDlgItemMsg(ad -> hwndFrame, NEWVIEW_LISTBOX, LM_DELETEALL,
4081	MPVOID, MPVOID);
4082	ad -> oldwidth = -1;
4083	WinSendMsg(ad -> hvscroll, SBM_SETTHUMBSIZE,
4084	MPFROM2SHORT(1, 1),
4085	MPVOID);
4086	WinSendMsg(ad -> hvscroll, SBM_SETSCROLLBAR,
4087	MPFROMSHORT(1), MPFROM2SHORT(1, 1));
4088	WinSendMsg(ad -> hhscroll, SBM_SETTHUMBSIZE,
4089	MPFROM2SHORT(1, 1),
4090	MPVOID);
4091	WinSendMsg(ad -> hhscroll, SBM_SETSCROLLBAR,
4092	MPFROMSHORT(1), MPFROM2SHORT(1, 1));
4093	WinSendMsg(ad -> hwndFrame, WM_UPDATEFRAME,
4094	MPFROMLONG(FCF_SIZEBORDER), MPVOID);
4095	WinInvalidateRect(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
4096	NEWVIEW_DRAG), NULL, FALSE);
4097	WinInvalidateRect(ad -> hhscroll, NULL, FALSE);
4098	}
4099	DosReleaseMutexSem(ad -> ScanSem);
4100	}
4101	}
4102	break;
4103
4104	case IDM_FONTPALETTE:
4105	{
4106	APIRET rc;
4107
4108	rc = DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN);
4109	if (!rc)
4110	{
4111	SetMLEFont(hwnd, &ad -> fattrs, 11);
4112	PrfWriteProfileData(fmprof, appname, "Viewer.Fattrs",
4113	&ad -> fattrs, sizeof(FATTRS));
4114	Fattrs = ad -> fattrs;
4115	GpiDeleteSetId(ad -> hps, FIXED_FONT_LCID);
4116	GpiAssociate(ad -> hps, 0);
4117	GpiDestroyPS(ad -> hps);
4118	ad -> hps = InitWindow(hwnd);
4119	DosReleaseMutexSem(ad -> ScanSem);
4120	WinSendMsg(hwnd, UM_SETUP2, MPVOID, MPVOID);
4121	WinInvalidateRect(hwnd, NULL, FALSE);
4122	}
4123	}
4124	break;
4125
4126	case IDM_HELP:
4127	if (hwndHelp)
4128	WinSendMsg(hwndHelp, HM_DISPLAY_HELP,
4129	MPFROM2SHORT(HELP_NEWVIEW, 0),
4130	MPFROMSHORT(HM_RESOURCEID));
4131	break;
4132	}
4133	return 0;
4134
4135	case WM_SETFOCUS:
4136	if (mp2)
4137	WinSendMsg(hwnd, UM_SETUP5, MPVOID, MPVOID);
4138	if (mp2 && ad && ad -> needrefreshing && !ad -> stopflag &&
4139	!DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN))
4140	{
4141	ad -> needrefreshing = FALSE;
4142	DosReleaseMutexSem(ad -> ScanSem);
4143	WinInvalidateRect(hwnd, NULL, TRUE);
4144	}
4145	break;
4146
4147	case WM_SIZE:
4148	if (SHORT1FROMMP(mp2) && SHORT2FROMMP(mp2))
4149	{
4150	PostMsg(hwnd, UM_SETUP2, MPVOID, MPVOID);
4151	PostMsg(hwnd, UM_SETUP3, MPVOID, MPVOID);
4152	}
4153	break;
4154
4155	case WM_SAVEAPPLICATION:
4156	if (ad && ParentIsDesktop(hwnd, ad -> hwndParent))
4157	{
4158
4159	SWP swp;
4160
4161	WinQueryWindowPos(ad -> hwndFrame, &swp);
4162	if (!(swp.fl & (SWP_HIDE \| SWP_MINIMIZE \| SWP_MAXIMIZE)))
4163	PrfWriteProfileData(fmprof,
4164	appname,
4165	"NewViewSizePos",
4166	&swp,
4167	sizeof(swp));
4168	}
4169	break;
4170
4171	case WM_CLOSE:
4172	if (ad)
4173	ad -> stopflag = 1;
4174	WinDestroyWindow(WinQueryWindow(hwnd, QW_PARENT));
4175	return 0;
4176
4177	case WM_DESTROY:
4178	{
4179	BOOL dontclose = FALSE;
4180	HWND hwndRestore = (HWND) 0;
4181
4182	WinStopTimer(WinQueryAnchorBlock(hwnd), hwnd, ID_TIMER5);
4183	if (ad)
4184	{
4185	ad -> stopflag = 1;
4186	if (ad -> ScanSem)
4187	{
4188	DosRequestMutexSem(ad -> ScanSem, 15000L);
4189	DosCloseMutexSem(ad -> ScanSem);
4190	}
4191	if (ad -> busy)
4192	DosSleep(128L);
4193	if (ad -> hps)
4194	{
4195	GpiDeleteSetId(ad -> hps, FIXED_FONT_LCID);
4196	GpiAssociate(ad -> hps, 0);
4197	GpiDestroyPS(ad -> hps);
4198	}
4199	hwndRestore = ad -> hwndRestore;
4200	dontclose = ((ad -> flags & 4) != 0) ? TRUE : FALSE;
4201	FreeViewerMem(hwnd);
4202	WinSetWindowPtr(hwnd, QWL_USER, NULL);
4203	free(ad);
4204	}
4205	if (hwndRestore && hwndRestore != HWND_DESKTOP)
4206	{
4207
4208	ULONG fl = SWP_SHOW \| SWP_ACTIVATE \| SWP_ZORDER;
4209	SWP swp;
4210
4211	if (WinQueryWindowPos(hwndRestore, &swp))
4212	{
4213	if (!(swp.fl & SWP_MAXIMIZE))
4214	fl \|= SWP_RESTORE;
4215	WinSetWindowPos(hwndRestore, HWND_TOP, 0, 0, 0, 0, fl);
4216	}
4217	}
4218	if (!dontclose &&
4219	ParentIsDesktop(hwnd, WinQueryWindow(WinQueryWindow(hwnd,
4220	QW_PARENT), QW_PARENT)))
4221	{
4222	if (!PostMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID))
4223	DosExit(EXIT_PROCESS, 1);
4224	}
4225	}
4226	break;
4227	}
4228
4229	return WinDefWindowProc(hwnd, msg, mp1, mp2);
4230	}
4231
4232	HWND StartViewer(HWND hwndParent, USHORT flags, CHAR * filename,
4233	HWND hwndRestore)
4234	{
4235	HWND hwndFrame = (HWND) 0, hwndClient;
4236	VIEWDATA *ad;
4237	ULONG FrameFlags = FCF_TITLEBAR \| FCF_SYSMENU \|
4238	FCF_SIZEBORDER \| FCF_MINMAX \|
4239	FCF_NOBYTEALIGN \| FCF_VERTSCROLL \|
4240	FCF_MENU \| FCF_ICON \|
4241	FCF_ACCELTABLE \| FCF_HORZSCROLL;
4242
4243	if (strcmp(realappname, FM3Str))
4244	hwndParent = HWND_DESKTOP;
4245	if (ParentIsDesktop(hwndParent, hwndParent))
4246	FrameFlags \|= FCF_TASKLIST;
4247	// saymsg(MB_ENTER,HWND_DESKTOP,DEBUG_STRING,"\"%s\"\r\rparent %s desktop",filename,(ParentIsDesktop(hwndParent,hwndParent)) ? "is" : "isn't");
4248	hwndFrame = WinCreateStdWindow(hwndParent,
4249	0,
4250	&FrameFlags,
4251	GetPString(IDS_WCNEWVIEW),
4252	GetPString(IDS_FM2VIEWERTITLETEXT),
4253	fwsAnimate,
4254	FM3ModHandle,
4255	NEWVIEW_FRAME,
4256	&hwndClient);
4257	if (hwndFrame)
4258	{
4259
4260	HWND hwndMenu = WinWindowFromID(hwndFrame, FID_MENU);
4261
4262	if (!fToolbar && hwndMenu)
4263	{
4264	WinSendMsg(hwndMenu, MM_DELETEITEM,
4265	MPFROM2SHORT(IDM_FINDFIRST, FALSE), MPVOID);
4266	WinSendMsg(hwndMenu, MM_DELETEITEM,
4267	MPFROM2SHORT(IDM_FINDNEXT, FALSE), MPVOID);
4268	WinSendMsg(hwndMenu, MM_DELETEITEM,
4269	MPFROM2SHORT(IDM_FINDPREV, FALSE), MPVOID);
4270	WinSendMsg(hwndMenu, MM_DELETEITEM,
4271	MPFROM2SHORT(IDM_SAVETOCLIP, FALSE), MPVOID);
4272	}
4273	ad = xmallocz(sizeof(VIEWDATA),pszSrcFile,__LINE__);
4274	if (!ad) {
4275	WinDestroyWindow(hwndFrame);
4276	hwndFrame = (HWND) 0;
4277	}
4278	else {
4279	ad -> size = sizeof(VIEWDATA);
4280	ad -> stopflag = 0;
4281	ad -> multiplier = 1;
4282	ad -> hwndRestore = hwndRestore;
4283	ad -> hwndFrame = hwndFrame;
4284	ad -> hwndParent = hwndParent;
4285	ad -> clientfocused = TRUE;
4286	ad -> oldwidth = -1;
4287	strcpy(ad -> filename, filename);
4288	ad -> flags = flags;
4289	if (ad -> flags & 16)
4290	ad -> hex = TRUE;
4291	WinSetWindowPtr(hwndClient, QWL_USER, (PVOID) ad);
4292	if (Firsttime)
4293	{
4294
4295	ULONG size;
4296
4297	size = sizeof(BOOL);
4298	PrfQueryProfileData(fmprof, appname, "Viewer.Sensitive",
4299	(PVOID) & Sensitive, &size);
4300	size = sizeof(USHORT);
4301	PrfQueryProfileData(fmprof, appname, "Viewer.Codepage",
4302	(PVOID) & Codepage, &size);
4303	size = sizeof(BOOL);
4304	PrfQueryProfileData(fmprof, appname, "Viewer.LiteralSearch",
4305	(PVOID) & LiteralSearch, &size);
4306	size = sizeof(BOOL);
4307	PrfQueryProfileData(fmprof, appname, "Viewer.AlsoSelect",
4308	(PVOID) & AlsoSelect, &size);
4309	size = sizeof(BOOL);
4310	PrfQueryProfileData(fmprof, appname, "Viewer.WrapOn",
4311	(PVOID) & WrapOn, &size);
4312	size = sizeof(BOOL);
4313	PrfQueryProfileData(fmprof, appname, "Viewer.IgnoreFTP",
4314	(PVOID) & IgnoreFTP, &size);
4315	size = sizeof(BOOL);
4316	PrfQueryProfileData(fmprof, appname, "Viewer.IgnoreHTTP",
4317	(PVOID) & IgnoreHTTP, &size);
4318	memset(&Fattrs, 0, sizeof(FATTRS));
4319	size = sizeof(FATTRS);
4320	Fattrs.usRecordLength = sizeof(FATTRS);
4321	Fattrs.lMaxBaselineExt = 16;
4322	Fattrs.lAveCharWidth = 8;
4323	Fattrs.usCodePage = Codepage;
4324	strcpy(Fattrs.szFacename, GetPString(IDS_SYSMONOTEXT));
4325	PrfQueryProfileData(fmprof, appname, "Viewer.Fattrs",
4326	(PVOID) & Fattrs, &size);
4327	size = sizeof(LONG) * COLORS_MAX;
4328	PrfQueryProfileData(fmprof, appname, "Viewer.Colors",
4329	(PVOID) Colors, &size);
4330	Firsttime = FALSE;
4331	}
4332	{
4333	ULONG size = sizeof(ad -> searchtext);
4334
4335	PrfQueryProfileData(fmprof, appname, "Viewer.Searchtext",
4336	(PVOID) ad -> searchtext, &size);
4337	ad -> searchtext[sizeof(ad -> searchtext) - 1] = 0;
4338	}
4339	ad -> sensitive = Sensitive;
4340	ad -> literalsearch = LiteralSearch;
4341	ad -> fattrs = Fattrs;
4342	ad -> alsoselect = AlsoSelect;
4343	ad -> fattrs.usCodePage = Codepage;
4344	ad -> wrapon = WrapOn;
4345	ad -> ignorehttp = IgnoreHTTP;
4346	ad -> ignoreftp = IgnoreFTP;
4347	memcpy(ad -> colors, Colors, sizeof(LONG) * COLORS_MAX);
4348	WinSetWindowPtr(hwndClient, QWL_USER, (PVOID) ad);
4349	if (!WinSendMsg(hwndClient, UM_SETUP, MPVOID, MPVOID))
4350	hwndFrame = (HWND)0;
4351	else {
4352	// DosSleep(64L);
4353	if (!(FrameFlags & FCF_TASKLIST) && !(flags & 2))
4354	{
4355	SWP swp;
4356	FillClient(hwndParent, &swp, NULL, FALSE);
4357	WinSetWindowPos(hwndFrame, HWND_TOP, swp.x, swp.y, swp.cx, swp.cy,
4358	SWP_SIZE \| SWP_MOVE \| SWP_SHOW \| SWP_RESTORE \|
4359	SWP_ZORDER \| SWP_ACTIVATE);
4360	}
4361	else if (FrameFlags & FCF_TASKLIST)
4362	{
4363
4364	SWP swp, swpD;
4365	ULONG size = sizeof(swp);
4366	LONG cxScreen, cyScreen;
4367
4368	WinQueryTaskSizePos(WinQueryAnchorBlock(hwndFrame), 0, &swp);
4369	if (PrfQueryProfileData(fmprof,
4370	appname,
4371	"NewViewSizePos",
4372	&swpD,
4373	&size))
4374	{
4375	cxScreen = WinQuerySysValue(HWND_DESKTOP, SV_CXSCREEN);
4376	cyScreen = WinQuerySysValue(HWND_DESKTOP, SV_CYSCREEN);
4377	if (swp.x + swpD.cx > cxScreen)
4378	swp.x = cxScreen - swpD.cx;
4379	if (swp.y + swpD.cy > cyScreen)
4380	swp.y = cyScreen - swpD.cy;
4381	swp.cx = swpD.cx;
4382	swp.cy = swpD.cy;
4383	}
4384	WinSetWindowPos(hwndFrame, HWND_TOP, swp.x, swp.y, swp.cx, swp.cy,
4385	SWP_SIZE \| SWP_MOVE \| SWP_SHOW \| SWP_ZORDER \|
4386	SWP_ACTIVATE);
4387	}
4388	}
4389	}
4390	}
4391	return hwndFrame;
4392	}

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

Download in other formats: