source: trunk/dll/newview.c@ 793

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

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