source: trunk/dll/newview.c@ 850

Last change on this file since 850 was 850, checked in by Steven Levine, 18 years ago

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