source: trunk/dll/newview.c@ 888

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

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