source: trunk/dll/newview.c@ 546

Last change on this file since 546 was 533, checked in by root, 19 years ago

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