source: trunk/dll/newview.c@ 201

Last change on this file since 201 was 191, checked in by root, 20 years ago

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