source: trunk/dll/newview.c@ 396

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

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