source: trunk/dll/newview.c@ 551

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

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