source: trunk/dll/newview.c@ 886

Last change on this file since 886 was 886, checked in by Gregg Young, 18 years ago

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