source: trunk/dll/newview.c@ 350

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

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