source: trunk/dll/newview.c@ 946

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

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