source: trunk/dll/newview.c@ 895

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

Added remove_first_occurence_of_character to strip.c; Refined mailrun to use <mailto:> syntax;
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 114.1 KB
Line 
1
2/***********************************************************************
3
4 $Id: newview.c 895 2007-12-29 23:46:11Z gyoung $
5
6 New internal viewer
7
8 Copyright (c) 1993-98 M. Kimes
9 Copyright (c) 2001, 2007 Steven H. Levine
10
11 01 Dec 03 SHL Comments
12 02 Dec 03 SHL Correct WM_VSCROLL math
13 23 May 05 SHL Use QWL_USER
14 06 Jun 05 SHL Indent -i2
15 06 Jun 05 SHL Correct reversed wrap logic
16 17 Jul 06 SHL Use Runtime_Error
17 26 Jul 06 SHL Use chop_at_crnl and convert_nl_to_nul
18 03 Nov 06 SHL Renames
19 03 Nov 06 SHL Count thread usage
20 22 Mar 07 GKY Use QWL_USER
21 30 Mar 07 GKY Remove GetPString for window class names
22 06 Aug 07 GKY Reduce DosSleep times (ticket 148)
23 20 Aug 07 GKY Move #pragma alloc_text to end for OpenWatcom compat
24 26 Aug 07 GKY Fixed fast viewer text load failure
25 28 Aug 07 GKY Reversed horizontal scrollbar behavior to be present for unwrapped text and absent for wrapped text & hex.
26 14 Sep 07 SHL Another attempt to correct the fast viewer text load failure
27 10 Oct 07 SHL Correct ReLineThread typo
28 17 Dec 07 GKY Make WPURLDEFAULTSETTINGS the fall back for ftp/httprun
29 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, NULL, "%s %s", httprun, urld->url);
2402 }
2403 free(urld);
2404 goto NoAdd;
2405 case 2:
2406 if (*urld->url){
2407 if (fFtpRunWPSDefault) {
2408 CHAR WPSDefaultFtpRun[CCHMAXPATH], WPSDefaultFtpRunDir[CCHMAXPATH];
2409
2410 size = sizeof(WPSDefaultFtpRun);
2411 PrfQueryProfileData(HINI_USERPROFILE, "WPURLDEFAULTSETTINGS",
2412 "DefaultBrowserExe", WPSDefaultFtpRun, &size);
2413 size = sizeof(WPSDefaultFtpRunDir);
2414 PrfQueryProfileData(HINI_USERPROFILE, "WPURLDEFAULTSETTINGS",
2415 "DefaultWorkingDir", WPSDefaultFtpRunDir, &size);
2416 runemf2(SEPARATE | WINDOWED,
2417 hwnd, pszSrcFile, __LINE__,
2418 WPSDefaultFtpRunDir,
2419 fLibPathStrictFtpRun ? "SET LIBPATHSTRICT=TRUE" : NULL,
2420 "%s %s", WPSDefaultFtpRun, urld->url);
2421 }
2422 else
2423 runemf2(SEPARATE | WINDOWED,
2424 hwnd, pszSrcFile, __LINE__,
2425 ftprundir, NULL, "%s %s", ftprun, urld->url);
2426 }
2427 case 3:
2428 if (*urld->url){
2429 runemf2(SEPARATE | WINDOWED,
2430 hwnd, pszSrcFile, __LINE__,
2431 mailrundir, NULL, "%s %s", mailrun, urld->url);
2432 }
2433 free(urld);
2434 goto NoAdd;
2435 default:
2436 break;
2437 }
2438 free(urld);
2439 }
2440 }
2441 }
2442 numsels = (SHORT) WinSendDlgItemMsg(ad->hwndFrame, NEWVIEW_LISTBOX,
2443 LM_QUERYITEMCOUNT, MPVOID,
2444 MPVOID);
2445 if (numsels > 0) {
2446 for (sSelect = 0; sSelect < numsels; sSelect++) {
2447 linenum =
2448 (ULONG) WinSendDlgItemMsg(ad->hwndFrame, NEWVIEW_LISTBOX,
2449 LM_QUERYITEMHANDLE,
2450 MPFROM2SHORT(sSelect, 0), MPVOID);
2451 if (linenum == whichline)
2452 goto NoAdd;
2453 }
2454 }
2455 {
2456 CHAR *s = NULL, *p;
2457
2458 if (!ad->hex && ad->lines) {
2459 s = xmalloc(width + 2, pszSrcFile, __LINE__);
2460 if (!s)
2461 goto NoAdd;
2462 strncpy(s, ad->lines[whichline], width + 1);
2463 s[width + 1] = 0;
2464 p = s;
2465 while (*p) {
2466 if (*p == '\r' || *p == '\n') {
2467 *p = 0;
2468 break;
2469 }
2470 p++;
2471 }
2472 }
2473 else {
2474
2475 register ULONG x;
2476
2477 width = ad->textsize - (whichline * 16);
2478 width = min(width, 16);
2479 s = xmalloc(80, pszSrcFile, __LINE__);
2480 if (!s)
2481 goto NoAdd;
2482 sprintf(s, "%08lx ", whichline * 16);
2483 p = s + 9;
2484 for (x = 0; x < width; x++) {
2485 sprintf(p, " %02x", (UCHAR)ad->text[(whichline * 16) + x]);
2486 p += 3;
2487 }
2488 *p = ' ';
2489 p++;
2490 *p = ' ';
2491 p++;
2492 for (x = 0; x < width; x++) {
2493 *p = ad->text[(whichline * 16) + x];
2494 p++;
2495 }
2496 *p = 0;
2497 }
2498 if (s) {
2499 if (*s) {
2500 ad->dummy = TRUE;
2501 numinserted = (SHORT) WinSendDlgItemMsg(ad->hwndFrame,
2502 NEWVIEW_LISTBOX,
2503 LM_INSERTITEM,
2504 MPFROM2SHORT(LIT_END,
2505 0),
2506 MPFROMP(s));
2507 ad->dummy = FALSE;
2508 if (numinserted >= 0)
2509 WinSendDlgItemMsg(ad->hwndFrame, NEWVIEW_LISTBOX,
2510 LM_SETITEMHANDLE,
2511 MPFROM2SHORT(numinserted, 0),
2512 MPFROMLONG(whichline));
2513 }
2514 free(s);
2515 }
2516 }
2517 if (!numsels)
2518 WinSendMsg(ad->hwndFrame, WM_UPDATEFRAME,
2519 MPFROMLONG(FCF_SIZEBORDER), MPVOID);
2520 }
2521 NoAdd:
2522 DosReleaseMutexSem(ad->ScanSem);
2523 DosPostEventSem(CompactSem);
2524 }
2525 break;
2526
2527 case WM_MENUEND:
2528 if (ad && ad->hwndPopup == (HWND) mp2) {
2529 WinDestroyWindow(ad->hwndPopup);
2530 ad->hwndPopup = (HWND) 0;
2531 }
2532 break;
2533
2534 case UM_CONTEXTMENU:
2535 case WM_CONTEXTMENU:
2536 if (ad) {
2537 if (!ad->hwndPopup) {
2538 ad->hwndPopup =
2539 WinLoadMenu(HWND_DESKTOP, FM3ModHandle, NEWVIEW_POPUP);
2540 if (ad->hwndPopup)
2541 WinSetPresParam(ad->hwndPopup,
2542 PP_FONTNAMESIZE,
2543 strlen(GetPString(IDS_8HELVTEXT)) + 1,
2544 GetPString(IDS_8HELVTEXT));
2545 }
2546 if (ad->hwndPopup) {
2547
2548 APIRET rc;
2549 SHORT sSelect;
2550
2551 rc = DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN);
2552 WinEnableMenuItem(ad->hwndPopup, IDM_SAVETOCLIP, (rc == 0 &&
2553 ad->selected != 0));
2554 WinEnableMenuItem(ad->hwndPopup, IDM_APPENDTOCLIP, (rc == 0 &&
2555 ad->selected !=
2556 0));
2557 WinEnableMenuItem(ad->hwndPopup, IDM_SAVETOLIST,
2558 (rc == 0 && ad->selected != 0));
2559 sSelect =
2560 (SHORT) WinSendDlgItemMsg(ad->hwndFrame, NEWVIEW_LISTBOX,
2561 LM_QUERYITEMCOUNT, MPVOID, MPVOID);
2562 WinEnableMenuItem(ad->hwndPopup, IDM_SAVETOCLIP2,
2563 (rc == 0 && sSelect > 0));
2564 WinEnableMenuItem(ad->hwndPopup, IDM_APPENDTOCLIP2,
2565 (rc == 0 && sSelect > 0));
2566 WinEnableMenuItem(ad->hwndPopup, IDM_SAVETOLIST2,
2567 (rc == 0 && sSelect > 0));
2568 WinEnableMenuItem(ad->hwndPopup, IDM_SELECTALL,
2569 (rc == 0 && ad->numlines != 0 && ad->markedlines));
2570 WinEnableMenuItem(ad->hwndPopup, IDM_DESELECTALL,
2571 (rc == 0 && ad->numlines != 0 && ad->markedlines
2572 && ad->selected != 0));
2573 WinEnableMenuItem(ad->hwndPopup, IDM_PREVSELECTED,
2574 (rc == 0 && ad->numlines != 0 && ad->markedlines
2575 && ad->selected != 0));
2576 WinEnableMenuItem(ad->hwndPopup, IDM_NEXTSELECTED,
2577 (rc == 0 && ad->numlines != 0 && ad->markedlines
2578 && ad->selected != 0));
2579 WinEnableMenuItem(ad->hwndPopup, IDM_SELECTFOUND,
2580 (rc == 0 && ad->numlines != 0 && ad->markedlines
2581 && ad->found != 0));
2582 WinEnableMenuItem(ad->hwndPopup, IDM_DESELECTFOUND,
2583 (rc == 0 && ad->numlines != 0 && ad->markedlines
2584 && ad->selected != 0 && ad->found != 0));
2585 WinEnableMenuItem(ad->hwndPopup, IDM_INVERT,
2586 (rc == 0 && ad->numlines != 0 && ad->markedlines));
2587 WinEnableMenuItem(ad->hwndPopup, IDM_FINDFIRST,
2588 (rc == 0 && ad->numlines != 0 && ad->markedlines));
2589 WinEnableMenuItem(ad->hwndPopup, IDM_FINDNEXT,
2590 (rc == 0 && ad->numlines != 0 && ad->markedlines
2591 && ad->found));
2592 WinEnableMenuItem(ad->hwndPopup, IDM_FINDPREV,
2593 (rc == 0 && ad->numlines != 0 && ad->markedlines
2594 && ad->found));
2595 WinEnableMenuItem(ad->hwndPopup, IDM_GOTOLINE,
2596 (rc == 0 && ad->numlines != 0));
2597 WinEnableMenuItem(ad->hwndPopup, IDM_GOTOOFFSET,
2598 (rc == 0 && ad->textsize != 0));
2599 if (!rc)
2600 DosReleaseMutexSem(ad->ScanSem);
2601 PopupMenu(hwnd, hwnd, ad->hwndPopup);
2602 }
2603 }
2604 break;
2605
2606 case UM_SETUP3:
2607 if (ad && !ad->busy &&
2608 !DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN)) {
2609 ad->multiplier = ad->numlines / 32767;
2610 if (ad->multiplier * 32767 != ad->numlines)
2611 ad->multiplier++;
2612 if (!ad->multiplier)
2613 ad->multiplier++;
2614 {
2615 RECTL Rectl;
2616 ULONG numlines;
2617
2618 WinQueryWindowRect(hwnd, &Rectl);
2619 numlines = NumLines(&Rectl, ad);
2620 if (numlines) {
2621 WinSendMsg(ad->hhscroll, SBM_SETTHUMBSIZE,
2622 MPFROM2SHORT((SHORT) Rectl.xRight, (SHORT) ad->maxx),
2623 MPVOID);
2624 WinSendMsg(ad->hvscroll, SBM_SETTHUMBSIZE,
2625 MPFROM2SHORT((SHORT) numlines,
2626 (SHORT) min(ad->numlines, 32767)), MPVOID);
2627 if (ad->multiplier)
2628 WinSendMsg(ad->hvscroll, SBM_SETSCROLLBAR,
2629 MPFROMSHORT((SHORT) (ad->topline / ad->multiplier)),
2630 MPFROM2SHORT(1, (SHORT) ((ad->numlines + 1) /
2631 ad->multiplier) - numlines));
2632 WinSendMsg(ad->hhscroll, SBM_SETSCROLLBAR,
2633 MPFROMSHORT((SHORT) abs(ad->horzscroll)),
2634 MPFROM2SHORT(0, (SHORT) (ad->maxx - Rectl.xRight)));
2635 if (ad->numlines - ad->topline < numlines) {
2636 ad->topline = ((ad->numlines - ad->topline) - numlines);
2637 WinInvalidateRect(hwnd, NULL, FALSE);
2638 }
2639 }
2640 }
2641 DosReleaseMutexSem(ad->ScanSem);
2642 }
2643 return 0;
2644
2645 case UM_SETUP4:
2646 if (ad && !ad->busy &&
2647 !DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN)) {
2648
2649 CHAR s[140], t[34];
2650 ULONG numlines;
2651 RECTL Rectl;
2652
2653 WinQueryWindowRect(hwnd, &Rectl);
2654 numlines = NumLines(&Rectl, ad);
2655 commafmt(t, sizeof(t), ad->cursored);
2656 strcpy(s, GetPString(IDS_LINECOLONTEXT));
2657 strcat(s, t);
2658 if (ad->selected) {
2659 if (ad->selected > ad->numlines)
2660 ad->selected = 0;
2661 else {
2662 commafmt(t, sizeof(t), ad->selected);
2663 strcat(s, " (");
2664 strcat(s, t);
2665 strcat(s, GetPString(IDS_SELECTEDPARENTEXT));
2666 }
2667 }
2668 if (ad->found) {
2669 if (ad->found > ad->numlines)
2670 ad->found = 0;
2671 else {
2672 commafmt(t, sizeof(t), ad->found);
2673 strcat(s, " (");
2674 strcat(s, t);
2675 strcat(s, GetPString(IDS_FOUNDPARENTEXT));
2676 }
2677 }
2678 WinSetWindowText(ad->hwndStatus2, s);
2679 if (!ad->hex && ad->lines)
2680 commafmt(t, sizeof(t), ad->lines[ad->cursored - 1] - ad->text);
2681 else
2682 commafmt(t, sizeof(t), (ad->cursored - 1) * 16);
2683 strcpy(s, GetPString(IDS_OFFSETCOLONTEXT));
2684 strcat(s, t);
2685 WinSetWindowText(ad->hwndStatus3, s);
2686 if (ad->multiplier)
2687 WinSendMsg(ad->hvscroll, SBM_SETSCROLLBAR,
2688 MPFROMSHORT((SHORT) (ad->topline / ad->multiplier)),
2689 MPFROM2SHORT(1, (SHORT) ((ad->numlines + 1) /
2690 ad->multiplier) - numlines));
2691 WinSendMsg(ad->hhscroll, SBM_SETSCROLLBAR,
2692 MPFROMSHORT((SHORT) abs(ad->horzscroll)),
2693 MPFROM2SHORT(0, (SHORT) (ad->maxx - Rectl.xRight)));
2694 DosReleaseMutexSem(ad->ScanSem);
2695 }
2696 return 0;
2697
2698 case UM_CONTAINER_FILLED:
2699 if (ad && !ad->busy &&
2700 !DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN)) {
2701 ad->stopflag = 0;
2702 ad->topline = 1;
2703 ad->cursored = 1;
2704 ad->multiplier = 1;
2705 PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
2706 WinEnableWindow(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
2707 IDM_NEXTBLANKLINE), !ad->hex);
2708 WinEnableWindow(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
2709 IDM_PREVBLANKLINE), !ad->hex);
2710 if (ad->numlines)
2711 {
2712 if (mp1 && (ULONG) mp1 < ad->numlines + 1) {
2713
2714 RECTL Rectl;
2715 ULONG numlines;
2716
2717 WinQueryWindowRect(hwnd, &Rectl);
2718 numlines = NumLines(&Rectl, ad);
2719 if (numlines) {
2720 ad->topline = (ULONG) mp1;
2721 if (ad->numlines - ad->topline < numlines)
2722 ad->topline = ad->numlines - numlines;
2723 ad->cursored = (ULONG) mp1;
2724 if (mp2) {
2725 ad->cursored = (ULONG) mp2;
2726 if (ad->cursored > (ad->topline - 1) + numlines)
2727 ad->cursored = (ad->topline - 1) + numlines;
2728 }
2729 }
2730 }
2731 WinSendMsg(hwnd, UM_SETUP3, MPVOID, MPVOID);
2732 PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
2733 WinInvalidateRect(hwnd, NULL, FALSE);
2734 }
2735 DosReleaseMutexSem(ad->ScanSem);
2736 }
2737 else if (ad)
2738 ad->needrefreshing = TRUE;
2739 return 0;
2740
2741 case WM_ERASEBACKGROUND:
2742 WinFillRect((HPS) mp1, (PRECTL) mp2,
2743 standardcolors[ad->colors[COLORS_NORMALBACK]]);
2744 return 0;
2745
2746 case WM_PAINT:
2747 if (ad) {
2748
2749 HPS hpsp;
2750 RECTL Rectl;
2751 register ULONG x;
2752 ULONG numlines, wascursored = ad->cursored;
2753
2754 hpsp = WinBeginPaint(hwnd, ad->hps, &Rectl);
2755 WinFillRect(hpsp, &Rectl,
2756 standardcolors[ad->colors[COLORS_NORMALBACK]]);
2757 if (!ad->stopflag && !ad->busy &&
2758 !DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN)) {
2759 WinQueryWindowRect(hwnd, &Rectl);
2760 numlines = NumLines(&Rectl, ad);
2761 if (numlines) {
2762 if (ad->numlines && (ad->lines || ad->hex)) {
2763 if (ad->topline > (ad->numlines + 1) - numlines)
2764 ad->topline = (ad->numlines + 1) - numlines;
2765 if (ad->topline > ad->numlines)
2766 ad->topline = 1;
2767 if (!ad->topline)
2768 ad->topline = 1;
2769 if (ad->cursored < ad->topline)
2770 ad->cursored = ad->topline;
2771 else if (ad->cursored > (ad->topline + numlines) - 1)
2772 ad->cursored = (ad->topline + numlines) - 1;
2773 if (ad->cursored > ad->numlines)
2774 ad->cursored = ad->numlines;
2775 if (wascursored != ad->cursored)
2776 PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
2777 }
2778 else
2779 ad->topline = ad->cursored = 1;
2780 if (ad->numlines && (ad->lines || ad->hex)) {
2781 for (x = ad->topline - 1; x < ad->numlines; x++) {
2782 if (((LONG) (Rectl.yTop -
2783 (ad->lMaxHeight *
2784 (((x + 1) - ad->topline) + 1))) -
2785 ad->lMaxDescender) <= 0)
2786 break;
2787 PaintLine(hwnd, hpsp, x, ad->topline, &Rectl);
2788 }
2789 }
2790 }
2791 if (ad->multiplier)
2792 WinSendMsg(ad->hvscroll, SBM_SETSCROLLBAR,
2793 MPFROMSHORT((SHORT) (ad->topline / ad->multiplier)),
2794 MPFROM2SHORT(1, (SHORT) ((ad->numlines + 1) /
2795 ad->multiplier) - numlines));
2796 WinSendMsg(ad->hhscroll, SBM_SETSCROLLBAR,
2797 MPFROMSHORT((SHORT) abs(ad->horzscroll)),
2798 MPFROM2SHORT(0, (SHORT) (ad->maxx - Rectl.xRight)));
2799 WinSendMsg(ad->hhscroll, SBM_SETTHUMBSIZE,
2800 MPFROM2SHORT((SHORT) Rectl.xRight, (SHORT) ad->maxx),
2801 MPVOID);
2802 DosReleaseMutexSem(ad->ScanSem);
2803 ad->needrefreshing = FALSE;
2804 }
2805 else
2806 ad->needrefreshing = TRUE;
2807 WinEndPaint(hpsp);
2808 }
2809 else {
2810
2811 HPS hpsp;
2812
2813 hpsp = WinBeginPaint(hwnd, (HPS) 0, NULL);
2814 WinEndPaint(hpsp);
2815 }
2816 PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
2817 break;
2818
2819 case WM_HSCROLL:
2820 {
2821 RECTL rectl;
2822 BOOL invalidate = TRUE;
2823
2824 WinQueryWindowRect(hwnd, &rectl);
2825 switch (SHORT2FROMMP(mp2)) {
2826 case SB_PAGERIGHT:
2827 if (abs(ad->horzscroll) <= ad->maxx - rectl.xRight) {
2828 ad->horzscroll -= rectl.xRight;
2829 if (abs(ad->horzscroll) > ad->maxx - rectl.xRight)
2830 ad->horzscroll = -((ad->maxx - rectl.xRight) +
2831 ad->fattrs.lAveCharWidth);
2832 }
2833 else
2834 invalidate = FALSE;
2835 break;
2836
2837 case SB_PAGELEFT:
2838 if (ad->horzscroll < 0) {
2839 ad->horzscroll += rectl.xRight;
2840 if (ad->horzscroll > 0)
2841 ad->horzscroll = 0;
2842 }
2843 else
2844 invalidate = FALSE;
2845 break;
2846
2847 case SB_LINERIGHT:
2848 if (abs(ad->horzscroll) <= ad->maxx - rectl.xRight)
2849 ad->horzscroll -= ad->fattrs.lAveCharWidth;
2850 else
2851 invalidate = FALSE;
2852 break;
2853
2854 case SB_LINELEFT:
2855 if (ad->horzscroll < 0)
2856 ad->horzscroll += ad->fattrs.lAveCharWidth;
2857 else
2858 invalidate = FALSE;
2859 break;
2860
2861 case SB_SLIDERTRACK:
2862 ad->horzscroll = (SHORT1FROMMP(mp2) / ad->fattrs.lAveCharWidth) *
2863 ad->fattrs.lAveCharWidth;
2864 ad->horzscroll = -(ad->horzscroll);
2865 if (ad->horzscroll > 0)
2866 ad->horzscroll = 0;
2867 if (abs(ad->horzscroll) > (ad->maxx - rectl.xRight) +
2868 ad->fattrs.lAveCharWidth)
2869 ad->horzscroll = -(ad->maxx - rectl.xRight);
2870 break;
2871
2872 default:
2873 invalidate = FALSE;
2874 break;
2875 }
2876 if (invalidate)
2877 WinInvalidateRect(hwnd, NULL, FALSE);
2878 }
2879 break;
2880
2881 case WM_VSCROLL:
2882 if (ad && !ad->stopflag && ad->text && ad->numlines && !ad->busy &&
2883 !DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN)) {
2884
2885 ULONG numlines, wascursored;
2886 RECTL rcl;
2887
2888 WinQueryWindowRect(hwnd, &rcl);
2889 numlines = NumLines(&rcl, ad);
2890 if (numlines) {
2891 wascursored = ad->cursored;
2892 switch (SHORT2FROMMP(mp2)) {
2893 case SB_PAGEUP:
2894 if (ad->topline > 1) {
2895 ad->topline -= numlines;
2896 if (ad->topline > ad->numlines ||
2897 ad->topline + numlines > (ad->numlines + 1))
2898 ad->topline = 1;
2899 if (ad->cursored > ad->topline + numlines)
2900 ad->cursored = ad->topline + numlines;
2901 if (ad->cursored > ad->numlines)
2902 ad->cursored = ad->numlines;
2903 WinInvalidateRect(hwnd, NULL, FALSE);
2904 }
2905 break;
2906 case SB_PAGEDOWN:
2907 if (ad->topline + numlines <= ad->numlines) {
2908 ad->topline += numlines;
2909 if (ad->topline + numlines > ad->numlines + 1)
2910 ad->topline = (ad->numlines + 1) - numlines;
2911 if (ad->cursored < ad->topline)
2912 ad->cursored = ad->topline;
2913 if (ad->cursored + 1 > ad->topline + numlines)
2914 ad->cursored = (ad->topline + numlines) - 1;
2915 if (ad->cursored > ad->numlines)
2916 ad->cursored = ad->numlines;
2917 WinInvalidateRect(hwnd, NULL, FALSE);
2918 }
2919 break;
2920 case SB_LINEDOWN:
2921 if (ad->topline + numlines <= ad->numlines) {
2922
2923 RECTL Rectl, iRectl;
2924
2925 ad->topline++;
2926 if (ad->cursored < ad->topline)
2927 ad->cursored = ad->topline;
2928 else if (ad->cursored + 1 > ad->topline + numlines)
2929 ad->cursored = (ad->topline + numlines) - 1;
2930 if (ad->cursored > ad->numlines)
2931 ad->cursored = ad->numlines;
2932 WinQueryWindowRect(hwnd, &Rectl);
2933 WinScrollWindow(hwnd, 0, ad->lMaxHeight,
2934 NULL, NULL, NULLHANDLE, &iRectl, 0);
2935 WinFillRect(ad->hps, &iRectl,
2936 standardcolors[ad->colors[COLORS_NORMALBACK]]);
2937 PaintLine(hwnd, ad->hps, (ad->topline + numlines) - 2,
2938 ad->topline, &Rectl);
2939 if (ad->cursored != ad->topline + numlines)
2940 PaintLine(hwnd, ad->hps, ad->cursored - 1, ad->topline, &Rectl);
2941 if (wascursored != ad->cursored &&
2942 wascursored < ad->topline + numlines &&
2943 wascursored >= ad->topline)
2944 PaintLine(hwnd, ad->hps, wascursored - 1, ad->topline, &Rectl);
2945 if (numlines >= ad->numlines)
2946 numlines = 0;
2947 if (ad->multiplier)
2948 WinSendMsg(ad->hvscroll, SBM_SETSCROLLBAR,
2949 MPFROMSHORT((SHORT) (ad->topline / ad->multiplier)),
2950 MPFROM2SHORT(1, (SHORT) ((ad->numlines + 1) /
2951 ad->multiplier) -
2952 numlines));
2953 WinSendMsg(ad->hhscroll, SBM_SETSCROLLBAR,
2954 MPFROMSHORT((SHORT) abs(ad->horzscroll)),
2955 MPFROM2SHORT(0, (SHORT) (ad->maxx - Rectl.xRight)));
2956 }
2957 break;
2958 case SB_LINEUP:
2959 if (ad->topline > 1) {
2960
2961 RECTL Rectl, iRectl;
2962
2963 ad->topline--;
2964 if (ad->cursored < ad->topline)
2965 ad->cursored = ad->topline;
2966 else if (ad->cursored + 1 > ad->topline + numlines)
2967 ad->cursored = (ad->topline + numlines) - 1;
2968 if (ad->cursored > ad->numlines)
2969 ad->cursored = ad->numlines;
2970 WinQueryWindowRect(hwnd, &Rectl);
2971 WinScrollWindow(hwnd, 0, -ad->lMaxHeight,
2972 NULL, NULL, NULLHANDLE, &iRectl, 0);
2973 WinFillRect(ad->hps, &iRectl,
2974 standardcolors[ad->colors[COLORS_NORMALBACK]]);
2975 iRectl = Rectl;
2976 iRectl.yTop -= ((numlines * ad->lMaxHeight) + ad->lMaxDescender);
2977 WinFillRect(ad->hps, &iRectl,
2978 standardcolors[ad->colors[COLORS_NORMALBACK]]);
2979 PaintLine(hwnd, ad->hps, ad->topline - 1, ad->topline, &Rectl);
2980 if (ad->cursored != ad->topline)
2981 PaintLine(hwnd, ad->hps, ad->cursored - 1, ad->topline, &Rectl);
2982 if (ad->cursored != wascursored &&
2983 wascursored >= ad->topline &&
2984 wascursored < ad->topline + numlines)
2985 PaintLine(hwnd, ad->hps, wascursored - 1, ad->topline, &Rectl);
2986 if (numlines >= ad->numlines)
2987 numlines = 0;
2988 if (ad->multiplier)
2989 WinSendMsg(ad->hvscroll, SBM_SETSCROLLBAR,
2990 MPFROMSHORT((SHORT) (ad->topline / ad->multiplier)),
2991 MPFROM2SHORT(1, (SHORT) ((ad->numlines + 1) /
2992 ad->multiplier) -
2993 numlines));
2994 WinSendMsg(ad->hhscroll, SBM_SETSCROLLBAR,
2995 MPFROMSHORT((SHORT) abs(ad->horzscroll)),
2996 MPFROM2SHORT(0, (SHORT) (ad->maxx - Rectl.xRight)));
2997 }
2998 break;
2999 case SB_SLIDERTRACK:
3000 if ((SHORT1FROMMP(mp2) >= 1) || (SHORT1FROMMP(mp2)) <= ad->numlines) {
3001 ad->topline = (ULONG) SHORT1FROMMP(mp2) * ad->multiplier;
3002 if (ad->topline + numlines > ad->numlines + 1)
3003 ad->topline = (ad->numlines + 1) - numlines;
3004 if (!ad->topline)
3005 ad->topline = 1;
3006 if (ad->cursored < ad->topline)
3007 ad->cursored = ad->topline;
3008 else if (ad->cursored > ad->topline + numlines)
3009 ad->cursored = ad->topline + numlines;
3010 if (ad->cursored > ad->numlines)
3011 ad->cursored = ad->numlines;
3012 WinInvalidateRect(hwnd, NULL, FALSE);
3013 }
3014 else
3015 WinAlarm(HWND_DESKTOP, WA_NOTE);
3016 break;
3017 }
3018 if (ad->cursored != wascursored)
3019 PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
3020 }
3021 DosReleaseMutexSem(ad->ScanSem);
3022 }
3023 break;
3024
3025 case WM_INITMENU:
3026 switch (SHORT1FROMMP(mp1)) {
3027 case IDM_FILESMENU:
3028 {
3029 APIRET rc;
3030 SHORT sSelect;
3031
3032 rc = DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN);
3033 WinEnableMenuItem((HWND) mp2, IDM_SAVETOCLIP, (rc == 0 &&
3034 ad->selected != 0));
3035 WinEnableMenuItem((HWND) mp2, IDM_APPENDTOCLIP, (rc == 0 &&
3036 ad->selected != 0));
3037 WinEnableMenuItem((HWND) mp2, IDM_SAVETOLIST, (rc == 0 &&
3038 ad->selected != 0));
3039 sSelect = (SHORT) WinSendDlgItemMsg(ad->hwndFrame, NEWVIEW_LISTBOX,
3040 LM_QUERYITEMCOUNT, MPVOID,
3041 MPVOID);
3042 WinEnableMenuItem((HWND) mp2, IDM_SAVETOCLIP2,
3043 (rc == 0 && sSelect > 0));
3044 WinEnableMenuItem((HWND) mp2, IDM_APPENDTOCLIP2,
3045 (rc == 0 && sSelect > 0));
3046 WinEnableMenuItem((HWND) mp2, IDM_SAVETOLIST2,
3047 (rc == 0 && sSelect > 0));
3048 if (!rc)
3049 DosReleaseMutexSem(ad->ScanSem);
3050 }
3051 break;
3052
3053 case IDM_VIEWSMENU:
3054 {
3055 APIRET rc;
3056
3057 rc = DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN);
3058 WinEnableMenuItem((HWND) mp2, IDM_FONTPALETTE, (rc == 0));
3059 WinEnableMenuItem((HWND) mp2, IDM_HEXMODE, (rc == 0));
3060 WinEnableMenuItem((HWND) mp2, IDM_WRAP, (rc == 0));
3061 WinEnableMenuItem((HWND) mp2, IDM_CODEPAGE, (rc == 0));
3062 if (!rc)
3063 DosReleaseMutexSem(ad->ScanSem);
3064 }
3065 WinCheckMenuItem((HWND) mp2, IDM_HEXMODE, ad->hex);
3066 WinCheckMenuItem((HWND) mp2, IDM_WRAP, ad->wrapon);
3067 WinCheckMenuItem((HWND) mp2, IDM_IGNOREFTP, ad->ignoreftp);
3068 WinCheckMenuItem((HWND) mp2, IDM_IGNOREHTTP, ad->ignorehttp);
3069 WinCheckMenuItem((HWND) mp2, IDM_IGNOREMAIL, ad->ignoremail);
3070 break;
3071
3072 case IDM_SEARCHMENU:
3073 {
3074 APIRET rc;
3075
3076 rc = DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN);
3077 WinEnableMenuItem((HWND) mp2, IDM_FINDFIRST, (rc == 0 &&
3078 ad->numlines != 0 &&
3079 ad->markedlines));
3080 WinEnableMenuItem((HWND) mp2, IDM_FINDNEXT, (rc == 0 &&
3081 ad->numlines != 0 &&
3082 ad->markedlines &&
3083 ad->found != 0));
3084 WinEnableMenuItem((HWND) mp2, IDM_FINDPREV, (rc == 0 &&
3085 ad->numlines != 0 &&
3086 ad->markedlines &&
3087 ad->found != 0));
3088 WinEnableMenuItem((HWND) mp2, IDM_NEXTBLANKLINE, (rc == 0 &&
3089 ad->numlines != 0 &&
3090 !ad->hex));
3091 WinEnableMenuItem((HWND) mp2, IDM_PREVBLANKLINE, (rc == 0 &&
3092 ad->numlines != 0 &&
3093 !ad->hex));
3094 WinEnableMenuItem((HWND) mp2, IDM_GOTOLINE, (rc == 0 &&
3095 ad->numlines != 0));
3096 WinEnableMenuItem((HWND) mp2, IDM_GOTOOFFSET, (rc == 0 &&
3097 ad->textsize != 0));
3098 if (!rc)
3099 DosReleaseMutexSem(ad->ScanSem);
3100 }
3101 break;
3102
3103 case IDM_SELECTSUBMENU:
3104 {
3105 APIRET rc;
3106
3107 rc = DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN);
3108 WinEnableMenuItem((HWND) mp2, IDM_SELECTALL, (rc == 0 &&
3109 ad->numlines != 0 &&
3110 ad->markedlines &&
3111 (ad->selected !=
3112 ad->numlines ||
3113 !ad->selected)));
3114 WinEnableMenuItem((HWND) mp2, IDM_DESELECTALL, (rc == 0 &&
3115 ad->numlines != 0 &&
3116 ad->markedlines &&
3117 ad->selected != 0));
3118 WinEnableMenuItem((HWND) mp2, IDM_DESELECTFOUND, (rc == 0 &&
3119 ad->numlines != 0 &&
3120 ad->markedlines &&
3121 ad->selected != 0 &&
3122 ad->found != 0));
3123 WinEnableMenuItem((HWND) mp2, IDM_SELECTFOUND, (rc == 0 &&
3124 ad->numlines != 0 &&
3125 ad->markedlines &&
3126 ad->found != 0 &&
3127 (ad->numlines !=
3128 ad->selected ||
3129 !ad->selected)));
3130 WinEnableMenuItem((HWND) mp2, IDM_NEXTSELECTED, (rc == 0 &&
3131 ad->numlines != 0 &&
3132 ad->markedlines &&
3133 ad->selected != 0));
3134 WinEnableMenuItem((HWND) mp2, IDM_PREVSELECTED, (rc == 0 &&
3135 ad->numlines != 0 &&
3136 ad->markedlines &&
3137 ad->selected != 0));
3138 WinEnableMenuItem((HWND) mp2, IDM_INVERT, (rc == 0 &&
3139 ad->numlines != 0 &&
3140 ad->markedlines));
3141 if (!rc)
3142 DosReleaseMutexSem(ad->ScanSem);
3143 }
3144 break;
3145 }
3146 break;
3147
3148 case UM_CONTROL:
3149 switch (SHORT1FROMMP(mp1)) {
3150 case NEWVIEW_LISTBOX:
3151 switch (SHORT2FROMMP(mp1)) {
3152 case LN_SETFOCUS:
3153 if (ad) {
3154 if (!ad->clientfocused) {
3155 PostMsg(hwnd,
3156 WM_COMMAND, MPFROM2SHORT(IDM_NEXTWINDOW, 0), MPVOID);
3157 break;
3158 }
3159 ad->clientfocused = FALSE;
3160 }
3161 PostMsg(hwnd,
3162 UM_CONTROL, MPFROM2SHORT(NEWVIEW_LISTBOX, LN_SELECT), MPVOID);
3163 break;
3164 case LN_KILLFOCUS:
3165 if (ad) {
3166 ad->clientfocused = TRUE;
3167 WinSetFocus(HWND_DESKTOP, hwnd);
3168 }
3169 break;
3170 case LN_SELECT:
3171 if (ad && !ad->dummy) {
3172
3173 ULONG linenum, numlines;
3174 SHORT sSelect;
3175 HWND hwndUL = WinWindowFromID(ad->hwndFrame,
3176 SHORT1FROMMP(mp1));
3177 RECTL Rectl;
3178
3179 sSelect = (SHORT) WinSendMsg(hwndUL,
3180 LM_QUERYSELECTION,
3181 MPFROM2SHORT(LIT_FIRST, 0), MPVOID);
3182 if (sSelect >= 0) {
3183 linenum = (ULONG) WinSendMsg(hwndUL,
3184 LM_QUERYITEMHANDLE,
3185 MPFROM2SHORT(sSelect, 0), MPVOID);
3186 if (ad->topline != linenum + 1 && linenum < ad->numlines) {
3187 WinQueryWindowRect(hwnd, &Rectl);
3188 numlines = NumLines(&Rectl, ad);
3189 ad->topline = linenum + 1;
3190 if (ad->numlines - ad->topline < numlines)
3191 ad->topline = ad->numlines - numlines;
3192 ad->cursored = linenum + 1;
3193 WinInvalidateRect(hwnd, NULL, FALSE);
3194 PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
3195 PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
3196 }
3197 }
3198 else
3199 PostMsg(hwndUL, LM_SELECTITEM, MPFROM2SHORT(0, 0),
3200 MPFROM2SHORT(TRUE, 0));
3201 }
3202 break;
3203
3204 case LN_ENTER:
3205 if (ad) {
3206
3207 SHORT sSelect;
3208 HWND hwndUL = WinWindowFromID(ad->hwndFrame,
3209 SHORT1FROMMP(mp1));
3210
3211 sSelect = (SHORT) WinSendMsg(hwndUL,
3212 LM_QUERYSELECTION,
3213 MPFROM2SHORT(LIT_FIRST, 0), MPVOID);
3214 if (sSelect >= 0) {
3215 ad->dummy = TRUE;
3216 WinSendMsg(hwndUL, LM_DELETEITEM,
3217 MPFROM2SHORT(sSelect, 0), MPVOID);
3218 ad->dummy = FALSE;
3219 sSelect = (SHORT) WinSendMsg(hwndUL,
3220 LM_QUERYITEMCOUNT, MPVOID, MPVOID);
3221 if (sSelect <= 0) {
3222 PostMsg(ad->hwndFrame, WM_UPDATEFRAME,
3223 MPFROMLONG(FCF_SIZEBORDER), MPVOID);
3224 WinSetFocus(HWND_DESKTOP, hwnd);
3225 }
3226 }
3227 }
3228 break;
3229
3230 default:
3231 break;
3232 }
3233 break;
3234
3235 default:
3236 break;
3237 }
3238 return 0;
3239
3240 case WM_COMMAND:
3241 switch (SHORT1FROMMP(mp1)) {
3242 case IDM_EDIT:
3243 if (*editor) {
3244
3245 CHAR *dummy[2];
3246
3247 dummy[0] = ad->filename;
3248 dummy[1] = NULL;
3249 ExecOnList(hwnd, editor, WINDOWED | SEPARATE, NULL, dummy, NULL,
3250 pszSrcFile, __LINE__);
3251 }
3252 else
3253 StartMLEEditor(ad->hwndParent, 4, ad->filename, ad->hwndFrame);
3254 ad->hwndRestore = (HWND) 0;
3255 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
3256 break;
3257
3258 case IDM_IGNOREFTP:
3259 ad->ignoreftp = (ad->ignoreftp) ? FALSE : TRUE;
3260 ad->ftpin = FALSE;
3261 if (ad->text && (*ftprun || fFtpRunWPSDefault) &&
3262 !ad->ignoreftp && strstr(ad->text, "ftp://"))
3263 ad->ftpin = TRUE;
3264 IgnoreFTP = ad->ignoreftp;
3265 PrfWriteProfileData(fmprof, appname, "Viewer.IgnoreFTP",
3266 &ad->ignoreftp, sizeof(BOOL));
3267 WinInvalidateRect(hwnd, NULL, FALSE);
3268 break;
3269
3270 case IDM_IGNOREHTTP:
3271 ad->ignorehttp = (ad->ignorehttp) ? FALSE : TRUE;
3272 ad->httpin = FALSE;
3273 if (ad->text && (*httprun || fHttpRunWPSDefault) && !ad->ignorehttp &&
3274 strstr(ad->text, "http://"))
3275 ad->httpin = TRUE;
3276 IgnoreHTTP = ad->ignorehttp;
3277 PrfWriteProfileData(fmprof, appname, "Viewer.IgnoreHTTP",
3278 &ad->ignorehttp, sizeof(BOOL));
3279 WinInvalidateRect(hwnd, NULL, FALSE);
3280 break;
3281
3282 case IDM_IGNOREMAIL:
3283 ad->ignoremail = (ad->ignoremail) ? FALSE : TRUE;
3284 ad->mailin = FALSE;
3285 if (ad->text && *mailrun && !ad->ignoremail &&
3286 strstr(ad->text, "@"))
3287 ad->mailin = TRUE;
3288 IgnoreMail = ad->ignoremail;
3289 PrfWriteProfileData(fmprof, appname, "Viewer.IgnoreMail",
3290 &ad->ignoremail, sizeof(BOOL));
3291 WinInvalidateRect(hwnd, NULL, FALSE);
3292 break;
3293
3294 case IDM_PREVBLANKLINE:
3295 if (!ad->hex && ad->lines) {
3296
3297 ULONG x;
3298
3299 x = ad->cursored - 2;
3300 if (x >= ad->numlines)
3301 x = 0;
3302 while (x < ad->numlines &&
3303 (*ad->lines[x] == '\r' || *ad->lines[x] == '\n'))
3304 x--;
3305 if (x >= ad->numlines)
3306 x = 0;
3307 for (; x < ad->numlines; x--) {
3308 if (*ad->lines[x] == '\r' || *ad->lines[x] == '\n') {
3309 if (x < ad->numlines - 1)
3310 x++;
3311 break;
3312 }
3313 }
3314 if (x < ad->numlines) {
3315 ad->topline = ad->cursored = x;
3316 WinInvalidateRect(hwnd, NULL, FALSE);
3317 }
3318 }
3319 break;
3320
3321 case IDM_NEXTBLANKLINE:
3322 if (!ad->hex && ad->lines) {
3323
3324 ULONG x;
3325
3326 x = ad->cursored;
3327 while (x < ad->numlines &&
3328 (*ad->lines[x] == '\r' || *ad->lines[x] == '\n'))
3329 x++;
3330 for (; x < ad->numlines; x++) {
3331 if (*ad->lines[x] == '\r' || *ad->lines[x] == '\n') {
3332 if (x < ad->numlines - 1)
3333 x++;
3334 break;
3335 }
3336 }
3337 if (x < ad->numlines) {
3338 while (x < ad->numlines &&
3339 (*ad->lines[x] == '\r' || *ad->lines[x] == '\n'))
3340 x++;
3341 if (x < ad->numlines) {
3342 ad->topline = ad->cursored = x;
3343 WinInvalidateRect(hwnd, NULL, FALSE);
3344 }
3345 }
3346 }
3347 break;
3348
3349 case IDM_VIEW:
3350 case IDM_OBJECT:
3351 if (!ad->hex && ad->lines) {
3352
3353 CHAR line[CCHMAXPATH], filename[CCHMAXPATH], *p;
3354
3355 strncpy(line, ad->lines[ad->cursored - 1], CCHMAXPATH);
3356 line[CCHMAXPATH - 1] = 0;
3357 chop_at_crnl(line);
3358 if (*line == '\"') {
3359 memmove(line, line + 1, strlen(line));
3360 p = strchr(line, '\"');
3361 lstrip(line);
3362 if (p)
3363 *p = 0;
3364 rstrip(line);
3365 }
3366 else {
3367 lstrip(line);
3368 p = strchr(line, ' ');
3369 if (p)
3370 *p = 0;
3371 rstrip(line);
3372 }
3373 if (!strchr(line, '\\') && !strchr(line, '/') && !strchr(line, ':')) {
3374 strcpy(filename, ad->filename);
3375 p = strrchr(filename, '\\');
3376 if (p)
3377 p++;
3378 else
3379 p = filename;
3380 strcpy(p, line);
3381 }
3382 else
3383 strcpy(filename, line);
3384 MakeFullName(filename);
3385 if (*filename && IsFile(filename) == 1) {
3386 if (SHORT1FROMMP(mp1) == IDM_OBJECT)
3387 OpenObject(filename, Default, ad->hwndFrame);
3388 else
3389 DefaultView(hwnd, ad->hwndFrame, HWND_DESKTOP, NULL, 0, filename);
3390 }
3391 }
3392 break;
3393
3394 case IDM_COLORPALETTE:
3395 {
3396 COLORS co;
3397 LONG temp[COLORS_MAX];
3398
3399 memset(&co, 0, sizeof(co));
3400 co.size = sizeof(co);
3401 co.numcolors = COLORS_MAX;
3402 co.colors = ad->colors;
3403 co.descriptions = IDS_NVCOLORS1TEXT;
3404 co.origs = temp;
3405 co.prompt = IDS_NVCOLORSPROMPTTEXT;
3406 memcpy(temp, ad->colors, sizeof(LONG) * COLORS_MAX);
3407 if (WinDlgBox(HWND_DESKTOP,
3408 hwnd,
3409 ColorDlgProc,
3410 FM3ModHandle, COLOR_FRAME, (PVOID) & co)) {
3411 memcpy(Colors, ad->colors, sizeof(LONG) * COLORS_MAX);
3412 PrfWriteProfileData(fmprof,
3413 appname,
3414 "Viewer.Colors",
3415 &ad->colors, sizeof(LONG) * COLORS_MAX);
3416 WinInvalidateRect(hwnd, NULL, FALSE);
3417 WinInvalidateRect(ad->hwndStatus1, NULL, FALSE);
3418 WinInvalidateRect(ad->hwndStatus2, NULL, FALSE);
3419 WinInvalidateRect(ad->hwndStatus3, NULL, FALSE);
3420 }
3421 }
3422 break;
3423
3424 case IDM_NEXTWINDOW:
3425 case IDM_PREVWINDOW:
3426 {
3427 SHORT sSelect;
3428
3429 sSelect = (SHORT) WinSendDlgItemMsg(ad->hwndFrame,
3430 NEWVIEW_LISTBOX,
3431 LM_QUERYITEMCOUNT,
3432 MPVOID, MPVOID);
3433 if (sSelect) {
3434 if (!ad->clientfocused)
3435 WinSetFocus(HWND_DESKTOP, hwnd);
3436 else
3437 WinSetFocus(HWND_DESKTOP,
3438 WinWindowFromID(ad->hwndFrame, NEWVIEW_LISTBOX));
3439 }
3440 else
3441 WinSetFocus(HWND_DESKTOP, hwnd);
3442 }
3443 break;
3444
3445 case IDM_FINDFIRST:
3446 {
3447 APIRET rc;
3448
3449 rc = DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN);
3450 if (!rc) {
3451 if (!ad->busy && ad->text && ad->numlines && ad->markedlines) {
3452
3453 ULONG numlines;
3454 RECTL Rectl;
3455 static char test[SEARCHSTRINGLEN];
3456
3457 WinQueryWindowRect(hwnd, &Rectl);
3458 numlines = NumLines(&Rectl, ad);
3459 if (!numlines)
3460 break;
3461 strcpy(test, ad->searchtext);
3462 if (WinDlgBox(HWND_DESKTOP, hwnd, FindStrDlgProc, FM3ModHandle,
3463 NEWFIND_FRAME, (PVOID) & hwnd)) {
3464 if (*ad->searchtext && strcmp(test, ad->searchtext))
3465 PrfWriteProfileString(fmprof,
3466 appname,
3467 "Viewer.Searchtext",
3468 (PVOID) ad->searchtext);
3469 if (_beginthread(SearchThread, NULL, 524288, (PVOID) hwnd) ==
3470 -1)
3471 Runtime_Error(pszSrcFile, __LINE__,
3472 GetPString(IDS_COULDNTSTARTTHREADTEXT));
3473 }
3474 }
3475 DosReleaseMutexSem(ad->ScanSem);
3476 }
3477 }
3478 break;
3479
3480 case IDM_PREVSELECTED:
3481 case IDM_NEXTSELECTED:
3482 case IDM_FINDPREV:
3483 case IDM_FINDNEXT:
3484 {
3485 APIRET rc;
3486
3487 rc = DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN);
3488 if (!rc) {
3489 if (!ad->busy && ad->text && ad->markedlines) {
3490
3491 RECTL Rectl;
3492 register ULONG x;
3493 ULONG numlines;
3494 CHAR markedwith;
3495
3496 markedwith = (SHORT1FROMMP(mp1) == IDM_FINDNEXT ||
3497 SHORT1FROMMP(mp1) == IDM_FINDPREV) ?
3498 VF_FOUND : VF_SELECTED;
3499 WinQueryWindowRect(hwnd, &Rectl);
3500 numlines = NumLines(&Rectl, ad);
3501 if (!numlines)
3502 break;
3503 WinSetPointer(HWND_DESKTOP, hptrBusy);
3504 if (SHORT1FROMMP(mp1) == IDM_PREVSELECTED ||
3505 SHORT1FROMMP(mp1) == IDM_FINDPREV) {
3506 for (x = ad->cursored - 2; x < ULONG_MAX - 1; x--) {
3507 if (ad->markedlines[x] & markedwith) {
3508 ad->topline = x + 1;
3509 if (ad->numlines - ad->topline < numlines)
3510 ad->topline = ad->numlines - numlines;
3511 ad->cursored = x + 1;
3512 WinInvalidateRect(hwnd, NULL, FALSE);
3513 PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
3514 break;
3515 }
3516 }
3517 }
3518 else {
3519 for (x = ad->cursored; x < ad->numlines; x++) {
3520 if (ad->markedlines[x] & markedwith) {
3521 ad->topline = x + 1;
3522 if (ad->numlines - ad->topline < numlines)
3523 ad->topline = ad->numlines - numlines;
3524 ad->cursored = x + 1;
3525 WinInvalidateRect(hwnd, NULL, FALSE);
3526 PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
3527 break;
3528 }
3529 }
3530 }
3531 WinSetPointer(HWND_DESKTOP, hptrArrow);
3532 if (x >= ad->numlines)
3533 DosBeep(50, 100);
3534 }
3535 DosReleaseMutexSem(ad->ScanSem);
3536 }
3537 }
3538 break;
3539
3540 case IDM_SELECTFOUND:
3541 case IDM_DESELECTFOUND:
3542 {
3543 APIRET rc;
3544
3545 rc = DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN);
3546 if (!rc) {
3547 if (!ad->busy && ad->text && ad->markedlines) {
3548
3549 RECTL Rectl;
3550 register ULONG x;
3551 ULONG numlines;
3552
3553 WinQueryWindowRect(hwnd, &Rectl);
3554 numlines = NumLines(&Rectl, ad);
3555 if (!numlines)
3556 break;
3557 WinSetPointer(HWND_DESKTOP, hptrBusy);
3558 for (x = 0; x < ad->numlines; x++) {
3559 if (SHORT1FROMMP(mp1) == IDM_SELECTFOUND) {
3560 if ((ad->markedlines[x] & VF_FOUND) &&
3561 !(ad->markedlines[x] & VF_SELECTED)) {
3562 ad->markedlines[x] |= VF_SELECTED;
3563 ad->selected++;
3564 }
3565 }
3566 else {
3567 if ((ad->markedlines[x] & VF_FOUND) &&
3568 (ad->markedlines[x] & VF_SELECTED)) {
3569 ad->markedlines[x] &= (~VF_SELECTED);
3570 ad->selected--;
3571 }
3572 }
3573 }
3574 WinSendMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
3575 WinSetPointer(HWND_DESKTOP, hptrArrow);
3576 WinInvalidateRect(hwnd, NULL, FALSE);
3577 }
3578 DosReleaseMutexSem(ad->ScanSem);
3579 }
3580 }
3581 break;
3582
3583 case IDM_GOTOLINE:
3584 case IDM_GOTOOFFSET:
3585 {
3586 APIRET rc;
3587
3588 rc = DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN);
3589 if (!rc) {
3590 if (!ad->busy && ad->numlines) {
3591
3592 ULONG numlines, linenum;
3593 CHAR s[34], ss[134];
3594 STRINGINPARMS sip;
3595 RECTL Rectl;
3596 register ULONG x;
3597
3598 WinQueryWindowRect(hwnd, &Rectl);
3599 numlines = NumLines(&Rectl, ad);
3600 if (!numlines)
3601 break;
3602 if (ad->numlines <= numlines) {
3603 DosBeep(500, 100);
3604 break;
3605 }
3606 sip.help = (SHORT1FROMMP(mp1) == IDM_GOTOLINE) ?
3607 GetPString(IDS_NVLINEJUMPTEXT) : GetPString(IDS_NVBYTEJUMPTEXT);
3608 sip.ret = s;
3609 *s = 0;
3610 sip.prompt = ss;
3611 sip.inputlen = 34;
3612 sip.title = (SHORT1FROMMP(mp1) == IDM_GOTOLINE) ?
3613 GetPString(IDS_NVLINEJUMPTITLETEXT) :
3614 GetPString(IDS_NVBYTEJUMPTITLETEXT);
3615 sprintf(sip.prompt,
3616 GetPString(IDS_NVJUMPTEXT),
3617 (SHORT1FROMMP(mp1) == IDM_GOTOLINE) ?
3618 GetPString(IDS_LINETEXT) :
3619 GetPString(IDS_OFFSETTEXT),
3620 (SHORT1FROMMP(mp1) == IDM_GOTOLINE) ?
3621 1 :
3622 0,
3623 (SHORT1FROMMP(mp1) == IDM_GOTOLINE) ?
3624 ad->numlines : ad->textsize - 1);
3625 WinDlgBox(HWND_DESKTOP,
3626 hwnd, InputDlgProc, FM3ModHandle, STR_FRAME, &sip);
3627 if (*s) {
3628 s[33] = 0;
3629 linenum = atol(s);
3630 switch (SHORT1FROMMP(mp1)) {
3631 case IDM_GOTOLINE:
3632 if (linenum > 0 && linenum <= ad->numlines) {
3633 ad->topline = linenum;
3634 ad->cursored = ad->topline;
3635 if (ad->numlines - ad->topline < numlines)
3636 ad->topline = (ad->numlines - numlines) + 1;
3637 WinInvalidateRect(hwnd, NULL, FALSE);
3638 }
3639 break;
3640 case IDM_GOTOOFFSET:
3641 if (linenum < ad->textsize) {
3642 if (ad->hex)
3643 ad->topline = (linenum / 16) + 1;
3644 else if (ad->lines) {
3645 ad->topline = (ULONG) - 1;
3646 for (x = 0; x < ad->numlines; x++) {
3647 if (ad->lines[x] > ad->text + linenum) {
3648 ad->topline = x + 1;
3649 break;
3650 }
3651 }
3652 if (ad->topline == (ULONG) - 1)
3653 ad->topline = ad->numlines;
3654 }
3655 ad->cursored = ad->topline;
3656 if (ad->numlines - ad->topline < numlines)
3657 ad->topline = (ad->numlines - numlines) + 1;
3658 WinInvalidateRect(hwnd, NULL, FALSE);
3659 }
3660 break;
3661 }
3662 }
3663 PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
3664 }
3665 DosReleaseMutexSem(ad->ScanSem);
3666 }
3667 }
3668 break;
3669
3670 case IDM_CODEPAGE:
3671 {
3672 INT cp;
3673
3674 cp = PickCodepage(hwnd);
3675 if (cp != -1) {
3676 ad->fattrs.usCodePage = (USHORT) cp;
3677 Codepage = ad->fattrs.usCodePage;
3678 PrfWriteProfileData(fmprof,
3679 appname,
3680 "Viewer.Codepage",
3681 &ad->fattrs.usCodePage, sizeof(USHORT));
3682 GpiDeleteSetId(ad->hps, FIXED_FONT_LCID);
3683 GpiAssociate(ad->hps, 0);
3684 GpiDestroyPS(ad->hps);
3685 ad->hps = InitWindow(hwnd);
3686 WinSendMsg(hwnd, UM_SETUP3, MPVOID, MPVOID);
3687 PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
3688 WinInvalidateRect(hwnd, NULL, FALSE);
3689 }
3690 }
3691 break;
3692
3693 case IDM_SAVETOLIST2:
3694 case IDM_SAVETOCLIP2:
3695 case IDM_APPENDTOCLIP2:
3696 case IDM_SAVETOLIST:
3697 case IDM_SAVETOCLIP:
3698 case IDM_APPENDTOCLIP:
3699 {
3700 APIRET rc;
3701
3702 rc = DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN);
3703 if (!rc) {
3704 if (!ad->busy) {
3705 ad->cliptype = SHORT1FROMMP(mp1);
3706 if (_beginthread(ClipboardThread, NULL, 524288, (PVOID) hwnd) ==
3707 -1)
3708 Runtime_Error(pszSrcFile, __LINE__,
3709 GetPString(IDS_COULDNTSTARTTHREADTEXT));
3710 }
3711 DosReleaseMutexSem(ad->ScanSem);
3712 }
3713 }
3714 break;
3715
3716 case IDM_SELECTALL:
3717 case IDM_DESELECTALL:
3718 case IDM_INVERT:
3719 {
3720 APIRET rc;
3721
3722 rc = DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN);
3723 if (!rc) {
3724 if (!ad->busy && ad->markedlines) {
3725
3726 register ULONG x;
3727
3728 for (x = 0; x < ad->numlines; x++) {
3729 switch (SHORT1FROMMP(mp1)) {
3730 case IDM_SELECTALL:
3731 if (!(ad->markedlines[x] & VF_SELECTED)) {
3732 ad->markedlines[x] |= VF_SELECTED;
3733 ad->selected++;
3734 }
3735 break;
3736 case IDM_DESELECTALL:
3737 if (ad->markedlines[x] & VF_SELECTED) {
3738 ad->markedlines[x] &= (~VF_SELECTED);
3739 ad->selected--;
3740 }
3741 break;
3742 case IDM_INVERT:
3743 if (ad->markedlines[x] & VF_SELECTED) {
3744 ad->markedlines[x] &= (~VF_SELECTED);
3745 ad->selected--;
3746 }
3747 else {
3748 ad->markedlines[x] |= VF_SELECTED;
3749 ad->selected++;
3750 }
3751 break;
3752 }
3753 }
3754 WinSendMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
3755 WinInvalidateRect(hwnd, NULL, FALSE);
3756 }
3757 DosReleaseMutexSem(ad->ScanSem);
3758 }
3759 }
3760 break;
3761
3762 case IDM_WRAP:
3763 {
3764 APIRET rc;
3765
3766 rc = DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN);
3767 if (!rc) {
3768 if (!ad->busy) {
3769 ad->wrapon = ad->wrapon ? FALSE : TRUE;
3770 WrapOn = ad->wrapon;
3771 PrfWriteProfileData(fmprof, appname, "Viewer.WrapOn",
3772 &ad->wrapon, sizeof(BOOL));
3773 PostMsg(hwnd, UM_SETUP2, MPVOID, MPVOID);
3774 PostMsg(hwnd, UM_SETUP3, MPVOID, MPVOID);
3775 PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
3776 if (WinSendDlgItemMsg(ad->hwndFrame, NEWVIEW_LISTBOX,
3777 LM_QUERYITEMCOUNT, MPVOID, MPVOID))
3778 WinSendDlgItemMsg(ad->hwndFrame, NEWVIEW_LISTBOX, LM_DELETEALL,
3779 MPVOID, MPVOID);
3780 ad->oldwidth = -1;
3781 WinSendMsg(ad->hvscroll, SBM_SETTHUMBSIZE,
3782 MPFROM2SHORT(1, 1), MPVOID);
3783 WinSendMsg(ad->hvscroll, SBM_SETSCROLLBAR,
3784 MPFROMSHORT(1), MPFROM2SHORT(1, 1));
3785 WinSendMsg(ad->hhscroll, SBM_SETTHUMBSIZE,
3786 MPFROM2SHORT(1, 1), MPVOID);
3787 WinSendMsg(ad->hhscroll, SBM_SETSCROLLBAR,
3788 MPFROMSHORT(1), MPFROM2SHORT(1, 1));
3789 WinSendMsg(ad->hwndFrame, WM_UPDATEFRAME,
3790 MPFROMLONG(FCF_SIZEBORDER), MPVOID);
3791 WinInvalidateRect(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
3792 NEWVIEW_DRAG), NULL, FALSE);
3793 //WinInvalidateRect(ad->hhscroll, NULL, FALSE);
3794 }
3795 DosReleaseMutexSem(ad->ScanSem);
3796 }
3797 }
3798 break;
3799
3800 case IDM_HEXMODE:
3801 {
3802 APIRET rc;
3803
3804 rc = DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN);
3805 if (!rc) {
3806 if (!ad->busy) {
3807 ad->hex = (ad->hex) ? FALSE : TRUE;
3808 WinEnableWindow(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
3809 IDM_NEXTBLANKLINE), !ad->hex);
3810 WinEnableWindow(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
3811 IDM_PREVBLANKLINE), !ad->hex);
3812 PostMsg(hwnd, UM_SETUP2, MPVOID, MPVOID);
3813 PostMsg(hwnd, UM_SETUP3, MPVOID, MPVOID);
3814 PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
3815 if (WinSendDlgItemMsg(ad->hwndFrame, NEWVIEW_LISTBOX,
3816 LM_QUERYITEMCOUNT, MPVOID, MPVOID))
3817 WinSendDlgItemMsg(ad->hwndFrame, NEWVIEW_LISTBOX, LM_DELETEALL,
3818 MPVOID, MPVOID);
3819 ad->oldwidth = -1;
3820 WinSendMsg(ad->hvscroll, SBM_SETTHUMBSIZE,
3821 MPFROM2SHORT(1, 1), MPVOID);
3822 WinSendMsg(ad->hvscroll, SBM_SETSCROLLBAR,
3823 MPFROMSHORT(1), MPFROM2SHORT(1, 1));
3824 WinSendMsg(ad->hhscroll, SBM_SETTHUMBSIZE,
3825 MPFROM2SHORT(1, 1), MPVOID);
3826 WinSendMsg(ad->hhscroll, SBM_SETSCROLLBAR,
3827 MPFROMSHORT(1), MPFROM2SHORT(1, 1));
3828 WinSendMsg(ad->hwndFrame, WM_UPDATEFRAME,
3829 MPFROMLONG(FCF_SIZEBORDER), MPVOID);
3830 WinInvalidateRect(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
3831 NEWVIEW_DRAG), NULL, FALSE);
3832 //WinInvalidateRect(ad->hhscroll, NULL, FALSE);
3833 }
3834 DosReleaseMutexSem(ad->ScanSem);
3835 }
3836 }
3837 break;
3838
3839 case IDM_FONTPALETTE:
3840 {
3841 APIRET rc;
3842
3843 rc = DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN);
3844 if (!rc) {
3845 SetMLEFont(hwnd, &ad->fattrs, 11);
3846 PrfWriteProfileData(fmprof, appname, "Viewer.Fattrs",
3847 &ad->fattrs, sizeof(FATTRS));
3848 Fattrs = ad->fattrs;
3849 GpiDeleteSetId(ad->hps, FIXED_FONT_LCID);
3850 GpiAssociate(ad->hps, 0);
3851 GpiDestroyPS(ad->hps);
3852 ad->hps = InitWindow(hwnd);
3853 DosReleaseMutexSem(ad->ScanSem);
3854 WinSendMsg(hwnd, UM_SETUP2, MPVOID, MPVOID);
3855 WinInvalidateRect(hwnd, NULL, FALSE);
3856 }
3857 }
3858 break;
3859
3860 case IDM_HELP:
3861 if (hwndHelp)
3862 WinSendMsg(hwndHelp, HM_DISPLAY_HELP,
3863 MPFROM2SHORT(HELP_NEWVIEW, 0), MPFROMSHORT(HM_RESOURCEID));
3864 break;
3865 }
3866 return 0;
3867
3868 case WM_SETFOCUS:
3869 if (mp2)
3870 WinSendMsg(hwnd, UM_SETUP5, MPVOID, MPVOID);
3871 if (mp2 && ad && ad->needrefreshing && !ad->stopflag &&
3872 !DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN)) {
3873 ad->needrefreshing = FALSE;
3874 DosReleaseMutexSem(ad->ScanSem);
3875 WinInvalidateRect(hwnd, NULL, TRUE);
3876 }
3877 break;
3878
3879 case WM_SIZE:
3880 if (SHORT1FROMMP(mp2) && SHORT2FROMMP(mp2)) {
3881 PostMsg(hwnd, UM_SETUP2, MPVOID, MPVOID);
3882 PostMsg(hwnd, UM_SETUP3, MPVOID, MPVOID);
3883 }
3884 break;
3885
3886 case WM_SAVEAPPLICATION:
3887 if (ad && ParentIsDesktop(hwnd, ad->hwndParent)) {
3888
3889 SWP swp;
3890
3891 WinQueryWindowPos(ad->hwndFrame, &swp);
3892 if (!(swp.fl & (SWP_HIDE | SWP_MINIMIZE | SWP_MAXIMIZE)))
3893 PrfWriteProfileData(fmprof,
3894 appname, "NewViewSizePos", &swp, sizeof(swp));
3895 }
3896 break;
3897
3898 case WM_CLOSE:
3899 if (ad)
3900 ad->stopflag = 1;
3901 WinDestroyWindow(WinQueryWindow(hwnd, QW_PARENT));
3902 return 0;
3903
3904 case WM_DESTROY:
3905 {
3906 BOOL dontclose = FALSE;
3907 HWND hwndRestore = (HWND) 0;
3908
3909 WinStopTimer(WinQueryAnchorBlock(hwnd), hwnd, ID_TIMER5);
3910 if (ad) {
3911 ad->stopflag = 1;
3912 if (ad->ScanSem) {
3913 DosRequestMutexSem(ad->ScanSem, 15000);
3914 DosCloseMutexSem(ad->ScanSem);
3915 }
3916 if (ad->busy)
3917 DosSleep(100); //05 Aug 07 GKY 128
3918 if (ad->hps) {
3919 GpiDeleteSetId(ad->hps, FIXED_FONT_LCID);
3920 GpiAssociate(ad->hps, 0);
3921 GpiDestroyPS(ad->hps);
3922 }
3923 hwndRestore = ad->hwndRestore;
3924 dontclose = ((ad->flags & 4) != 0) ? TRUE : FALSE;
3925 FreeViewerMem(hwnd);
3926 WinSetWindowPtr(hwnd, QWL_USER, NULL);
3927 free(ad);
3928 }
3929 if (hwndRestore && hwndRestore != HWND_DESKTOP) {
3930
3931 ULONG fl = SWP_SHOW | SWP_ACTIVATE | SWP_ZORDER;
3932 SWP swp;
3933
3934 if (WinQueryWindowPos(hwndRestore, &swp)) {
3935 if (!(swp.fl & SWP_MAXIMIZE))
3936 fl |= SWP_RESTORE;
3937 WinSetWindowPos(hwndRestore, HWND_TOP, 0, 0, 0, 0, fl);
3938 }
3939 }
3940 if (!dontclose &&
3941 ParentIsDesktop(hwnd, WinQueryWindow(WinQueryWindow(hwnd,
3942 QW_PARENT),
3943 QW_PARENT))) {
3944 if (!PostMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID))
3945 DosExit(EXIT_PROCESS, 1);
3946 }
3947 }
3948 break;
3949 }
3950
3951 return WinDefWindowProc(hwnd, msg, mp1, mp2);
3952}
3953
3954HWND StartViewer(HWND hwndParent, USHORT flags, CHAR * filename,
3955 HWND hwndRestore)
3956{
3957 HWND hwndFrame = (HWND) 0, hwndClient;
3958 VIEWDATA *ad;
3959 ULONG FrameFlags = FCF_TITLEBAR | FCF_SYSMENU |
3960 FCF_SIZEBORDER | FCF_MINMAX |
3961 FCF_NOBYTEALIGN | FCF_VERTSCROLL |
3962 FCF_MENU | FCF_ICON | FCF_ACCELTABLE | FCF_HORZSCROLL;
3963
3964 if (strcmp(realappname, FM3Str))
3965 hwndParent = HWND_DESKTOP;
3966 if (ParentIsDesktop(hwndParent, hwndParent))
3967 FrameFlags |= FCF_TASKLIST;
3968 // saymsg(MB_ENTER,HWND_DESKTOP,DEBUG_STRING,"\"%s\"\r\rparent %s desktop",filename,(ParentIsDesktop(hwndParent,hwndParent)) ? "is" : "isn't");
3969 hwndFrame = WinCreateStdWindow(hwndParent,
3970 0,
3971 &FrameFlags,
3972 WC_NEWVIEW,
3973 GetPString(IDS_FM2VIEWERTITLETEXT),
3974 fwsAnimate,
3975 FM3ModHandle, NEWVIEW_FRAME, &hwndClient);
3976 if (hwndFrame) {
3977
3978 HWND hwndMenu = WinWindowFromID(hwndFrame, FID_MENU);
3979
3980 if (!fToolbar && hwndMenu) {
3981 WinSendMsg(hwndMenu, MM_DELETEITEM,
3982 MPFROM2SHORT(IDM_FINDFIRST, FALSE), MPVOID);
3983 WinSendMsg(hwndMenu, MM_DELETEITEM,
3984 MPFROM2SHORT(IDM_FINDNEXT, FALSE), MPVOID);
3985 WinSendMsg(hwndMenu, MM_DELETEITEM,
3986 MPFROM2SHORT(IDM_FINDPREV, FALSE), MPVOID);
3987 WinSendMsg(hwndMenu, MM_DELETEITEM,
3988 MPFROM2SHORT(IDM_SAVETOCLIP, FALSE), MPVOID);
3989 }
3990 ad = xmallocz(sizeof(VIEWDATA), pszSrcFile, __LINE__);
3991 if (!ad) {
3992 WinDestroyWindow(hwndFrame);
3993 hwndFrame = (HWND)0;
3994 }
3995 else {
3996 ad->size = sizeof(VIEWDATA);
3997 ad->stopflag = 0;
3998 ad->multiplier = 1;
3999 ad->hwndRestore = hwndRestore;
4000 ad->hwndFrame = hwndFrame;
4001 ad->hwndParent = hwndParent;
4002 ad->clientfocused = TRUE;
4003 ad->oldwidth = -1;
4004 strcpy(ad->filename, filename);
4005 ad->flags = flags;
4006 if (ad->flags & 16)
4007 ad->hex = TRUE;
4008 WinSetWindowPtr(hwndClient, QWL_USER, (PVOID) ad);
4009 if (Firsttime) {
4010
4011 ULONG size;
4012
4013 size = sizeof(BOOL);
4014 PrfQueryProfileData(fmprof, appname, "Viewer.Sensitive",
4015 (PVOID) & Sensitive, &size);
4016 size = sizeof(USHORT);
4017 PrfQueryProfileData(fmprof, appname, "Viewer.Codepage",
4018 (PVOID) & Codepage, &size);
4019 size = sizeof(BOOL);
4020 PrfQueryProfileData(fmprof, appname, "Viewer.LiteralSearch",
4021 (PVOID) & LiteralSearch, &size);
4022 size = sizeof(BOOL);
4023 PrfQueryProfileData(fmprof, appname, "Viewer.AlsoSelect",
4024 (PVOID) & AlsoSelect, &size);
4025 size = sizeof(BOOL);
4026 PrfQueryProfileData(fmprof, appname, "Viewer.WrapOn",
4027 (PVOID) & WrapOn, &size);
4028 size = sizeof(BOOL);
4029 PrfQueryProfileData(fmprof, appname, "Viewer.IgnoreFTP",
4030 (PVOID) & IgnoreFTP, &size);
4031 size = sizeof(BOOL);
4032 PrfQueryProfileData(fmprof, appname, "Viewer.IgnoreHTTP",
4033 (PVOID) & IgnoreHTTP, &size);
4034 size = sizeof(BOOL);
4035 PrfQueryProfileData(fmprof, appname, "Viewer.IgnoreMail",
4036 (PVOID) & IgnoreMail, &size);
4037 memset(&Fattrs, 0, sizeof(FATTRS));
4038 size = sizeof(FATTRS);
4039 Fattrs.usRecordLength = sizeof(FATTRS);
4040 Fattrs.lMaxBaselineExt = 16;
4041 Fattrs.lAveCharWidth = 8;
4042 Fattrs.usCodePage = Codepage;
4043 strcpy(Fattrs.szFacename, GetPString(IDS_SYSMONOTEXT));
4044 PrfQueryProfileData(fmprof, appname, "Viewer.Fattrs",
4045 (PVOID) & Fattrs, &size);
4046 size = sizeof(LONG) * COLORS_MAX;
4047 PrfQueryProfileData(fmprof, appname, "Viewer.Colors",
4048 (PVOID) Colors, &size);
4049 Firsttime = FALSE;
4050 }
4051 {
4052 ULONG size = sizeof(ad->searchtext);
4053
4054 PrfQueryProfileData(fmprof, appname, "Viewer.Searchtext",
4055 (PVOID) ad->searchtext, &size);
4056 ad->searchtext[sizeof(ad->searchtext) - 1] = 0;
4057 }
4058 ad->sensitive = Sensitive;
4059 ad->literalsearch = LiteralSearch;
4060 ad->fattrs = Fattrs;
4061 ad->alsoselect = AlsoSelect;
4062 ad->fattrs.usCodePage = Codepage;
4063 ad->wrapon = WrapOn;
4064 ad->ignorehttp = IgnoreHTTP;
4065 ad->ignoreftp = IgnoreFTP;
4066 ad->ignoremail = IgnoreMail;
4067 memcpy(ad->colors, Colors, sizeof(LONG) * COLORS_MAX);
4068 WinSetWindowPtr(hwndClient, QWL_USER, (PVOID) ad);
4069 if (!WinSendMsg(hwndClient, UM_SETUP, MPVOID, MPVOID))
4070 hwndFrame = (HWND) 0;
4071 else {
4072 //DosSleep(32);
4073 if (!(FrameFlags & FCF_TASKLIST) && !(flags & 2)) {
4074 SWP swp;
4075
4076 FillClient(hwndParent, &swp, NULL, FALSE);
4077 WinSetWindowPos(hwndFrame, HWND_TOP, swp.x, swp.y, swp.cx, swp.cy,
4078 SWP_SIZE | SWP_MOVE | SWP_SHOW | SWP_RESTORE |
4079 SWP_ZORDER | SWP_ACTIVATE);
4080 }
4081 else if (FrameFlags & FCF_TASKLIST) {
4082
4083 SWP swp, swpD;
4084 ULONG size = sizeof(swp);
4085 LONG cxScreen, cyScreen;
4086
4087 WinQueryTaskSizePos(WinQueryAnchorBlock(hwndFrame), 0, &swp);
4088 if (PrfQueryProfileData(fmprof,
4089 appname, "NewViewSizePos", &swpD, &size)) {
4090 cxScreen = WinQuerySysValue(HWND_DESKTOP, SV_CXSCREEN);
4091 cyScreen = WinQuerySysValue(HWND_DESKTOP, SV_CYSCREEN);
4092 if (swp.x + swpD.cx > cxScreen)
4093 swp.x = cxScreen - swpD.cx;
4094 if (swp.y + swpD.cy > cyScreen)
4095 swp.y = cyScreen - swpD.cy;
4096 swp.cx = swpD.cx;
4097 swp.cy = swpD.cy;
4098 }
4099 WinSetWindowPos(hwndFrame, HWND_TOP, swp.x, swp.y, swp.cx, swp.cy,
4100 SWP_SIZE | SWP_MOVE | SWP_SHOW | SWP_ZORDER |
4101 SWP_ACTIVATE);
4102 }
4103 }
4104 }
4105 }
4106 return hwndFrame;
4107}
4108
4109#pragma alloc_text(NEWVIEW,ViewStatusProc,FreeViewerMem,LoadFileThread)
4110#pragma alloc_text(NEWVIEW,InitWindow,PaintLine,ViewWndProc)
4111#pragma alloc_text(NEWVIEW,ViewFrameWndProc,StartViewer,ReLineThread)
4112#pragma alloc_text(NEWVIEW,BuildAList,SearchThread,ClipboardThread,FindStrDlgProc)
4113#pragma alloc_text(NEWVIEW,BuildAList2,UrlDlgProc)
Note: See TracBrowser for help on using the repository browser.