source: trunk/dll/newview.c@ 897

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

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