source: trunk/dll/newview.c@ 892

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

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