source: trunk/dll/newview.c@ 819

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

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