source: trunk/dll/newview.c@ 818

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

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