source: trunk/dll/newview.c@ 593

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

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