Changeset 191


Ignore:
Timestamp:
Jun 6, 2005, 9:30:37 PM (20 years ago)
Author:
root
Message:

Indent -i2

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/dll/newview.c

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