source: trunk/dll/newview.c@ 893

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

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