source: trunk/dll/newview.c@ 944

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

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