Context Navigation

source: trunk/dll/newview.c@ 344

Visit:

Last change on this file since 344 was 218, checked in by root, 20 years ago
Correct reversed wrap logic
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 110.9 KB

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

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

Download in other formats: