source: trunk/dll/newview.c@ 841

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

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