source: trunk/dll/newview.c@ 790

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

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