source: trunk/dll/newview.c@ 574

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

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