source: trunk/dll/newview.c @ 885

Last change on this file since 885 was 885, checked in by Gregg Young, 13 years ago

Replace explore.exe with WPURLDEFAULTSETTINGS for runhttp fall back Ticket 179

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