source: trunk/dll/newview.c@ 816

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

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