source: trunk/dll/newview.c@ 304

Last change on this file since 304 was 218, checked in by root, 20 years ago

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