Changeset 551 for trunk/dll/newview.c


Ignore:
Timestamp:
Feb 28, 2007, 2:33:51 AM (19 years ago)
Author:
Gregg Young
Message:

Indentation cleanup

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/dll/newview.c

    r533 r551  
    7171#define COLORS_FTPFORE               11
    7272
    73 static LONG Colors[COLORS_MAX] = {COLR_WHITE, COLR_DARKGRAY,
    74                                   COLR_PALEGRAY, COLR_BLACK,
    75                                   COLR_BLACK, COLR_RED,
    76                                   COLR_WHITE, COLR_YELLOW,
    77                                   COLR_PALEGRAY, COLR_DARKBLUE,
    78                                   COLR_PALEGRAY, COLR_DARKGREEN};
     73static LONG Colors[COLORS_MAX] = { COLR_WHITE, COLR_DARKGRAY,
     74  COLR_PALEGRAY, COLR_BLACK,
     75  COLR_BLACK, COLR_RED,
     76  COLR_WHITE, COLR_YELLOW,
     77  COLR_PALEGRAY, COLR_DARKBLUE,
     78  COLR_PALEGRAY, COLR_DARKGREEN
     79};
    7980
    8081#define SEARCHSTRINGLEN 1024
    … …  
    9091  CHAR searchtext[SEARCHSTRINGLEN], *lastpos, szFacename[FACESIZE];
    9192  ULONG textsize, numlines, topline, cursored, selected, numalloc, multiplier,
    92       lastselected, found;
     93    lastselected, found;
    9394  CHAR stopflag, busy;
    9495  LONG oldwidth, lastdirection, lMaxAscender, lMaxDescender, lMaxHeight,
    95       maxx, horzscroll;
     96    maxx, horzscroll;
    9697  BOOL hex, mousecaptured, sensitive, dummy, literalsearch, clientfocused,
    97       alsoselect, wrapon, relining, httpin, ftpin, ignorehttp, ignoreftp,
    98       needrefreshing;
     98    alsoselect, wrapon, relining, httpin, ftpin, ignorehttp, ignoreftp,
     99    needrefreshing;
    99100  HMTX ScanSem;
    100101  HWND hvscroll, hwndMenu, hwndStatus1, hwndStatus2, hwndStatus3, hwndRestore,
    101       hwndPopup, hwndListbox, hwndFrame, hwndDrag, hwndParent, hhscroll;
     102    hwndPopup, hwndListbox, hwndFrame, hwndDrag, hwndParent, hhscroll;
    102103  HPS hps;
    103104  FATTRS fattrs;
    … …  
    130131  URLDATA *urld;
    131132
    132   switch (msg)
    133   {
     133  switch (msg) {
    134134  case WM_INITDLG:
    135     if (mp2)
    136     {
     135    if (mp2) {
    137136      CHAR *p, *e, *pp;
    138137      SHORT count;
    … …  
    140139      WinSetWindowPtr(hwnd, QWL_USER, mp2);
    141140      urld = mp2;
    142       e = urld -> line + urld -> len + 1;
    143       p = urld -> line;
    144       do
    145       {
     141      e = urld->line + urld->len + 1;
     142      p = urld->line;
     143      do {
    146144        p = strnstr(p, "http://", e - p);
    147         if (p)
    148         {
    149           strncpy(urld -> url, p, min(e - p, SEARCHSTRINGLEN - 1));
    150           urld -> url[min(e - p, SEARCHSTRINGLEN - 1)] = 0;
    151           pp = urld -> url;
     145        if (p) {
     146          strncpy(urld->url, p, min(e - p, SEARCHSTRINGLEN - 1));
     147          urld->url[min(e - p, SEARCHSTRINGLEN - 1)] = 0;
     148          pp = urld->url;
    152149          while (*pp && *pp != ' ' && *pp != '\r' && *pp != '\n' &&
    153150                 *pp != '\"')
    … …  
    155152          *pp = 0;
    156153          WinSendDlgItemMsg(hwnd, URL_LISTBOX, LM_INSERTITEM,
    157                             MPFROM2SHORT(LIT_END, 0),
    158                             MPFROMP(urld -> url));
     154                            MPFROM2SHORT(LIT_END, 0), MPFROMP(urld->url));
    159155          p++;
    160156        }
    161157      }
    162158      while (p && *p && p < e);
    163       p = urld -> line;
    164       do
    165       {
     159      p = urld->line;
     160      do {
    166161        p = strnstr(p, "ftp://", e - p);
    167         if (p)
    168         {
    169           strncpy(urld -> url, p, min(e - p, SEARCHSTRINGLEN - 1));
    170           urld -> url[min(e - p, SEARCHSTRINGLEN - 1)] = 0;
    171           pp = urld -> url;
     162        if (p) {
     163          strncpy(urld->url, p, min(e - p, SEARCHSTRINGLEN - 1));
     164          urld->url[min(e - p, SEARCHSTRINGLEN - 1)] = 0;
     165          pp = urld->url;
    172166          while (*pp && *pp != ' ' && *pp != '\r' && *pp != '\n' &&
    173167                 *pp != '\"')
    … …  
    175169          *pp = 0;
    176170          WinSendDlgItemMsg(hwnd, URL_LISTBOX, LM_INSERTITEM,
    177                             MPFROM2SHORT(LIT_END, 0),
    178                             MPFROMP(urld -> url));
     171                            MPFROM2SHORT(LIT_END, 0), MPFROMP(urld->url));
    179172          p++;
    180173        }
    181174      }
    182175      while (p && *p && p < e);
    183       *urld -> url = 0;
     176      *urld->url = 0;
    184177      count = (SHORT) WinSendDlgItemMsg(hwnd, URL_LISTBOX, LM_QUERYITEMCOUNT,
    185178                                        MPVOID, MPVOID);
    186       if (count)
    187       {
     179      if (count) {
    188180        WinSendDlgItemMsg(hwnd, URL_LISTBOX, LM_SELECTITEM,
    189181                          MPFROMSHORT(0), MPFROMSHORT(TRUE));
    … …  
    203195
    204196  case WM_CONTROL:
    205     switch (SHORT1FROMMP(mp1))
    206     {
     197    switch (SHORT1FROMMP(mp1)) {
    207198    case URL_LISTBOX:
    208       switch (SHORT2FROMMP(mp1))
    209       {
     199      switch (SHORT2FROMMP(mp1)) {
    210200      case LN_ENTER:
    211201        PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(DID_OK, 0), MPVOID);
    … …  
    217207
    218208  case WM_COMMAND:
    219     switch (SHORT1FROMMP(mp1))
    220     {
     209    switch (SHORT1FROMMP(mp1)) {
    221210    case URL_BOOKMARK:
    222211      WinDismissDlg(hwnd, 3);
    … …  
    228217
    229218        urld = WinQueryWindowPtr(hwnd, QWL_USER);
    230         if (urld)
    231         {
     219        if (urld) {
    232220          select = (SHORT) WinSendDlgItemMsg(hwnd, URL_LISTBOX,
    233221                                             LM_QUERYSELECTION,
    234                                              MPFROMSHORT(LIT_FIRST),
    235                                              MPVOID);
    236           if (select >= 0)
    237           {
    238             *urld -> url = 0;
     222                                             MPFROMSHORT(LIT_FIRST), MPVOID);
     223          if (select >= 0) {
     224            *urld->url = 0;
    239225            WinSendDlgItemMsg(hwnd, URL_LISTBOX, LM_QUERYITEMTEXT,
    240                               MPFROM2SHORT(select, sizeof(urld -> url)),
    241                               MPFROMP(urld -> url));
    242             if (*urld -> url)
    243             {
    244               if (!strncmp(urld -> url, "http://", 7))
    245               {
     226                              MPFROM2SHORT(select, sizeof(urld->url)),
     227                              MPFROMP(urld->url));
     228            if (*urld->url) {
     229              if (!strncmp(urld->url, "http://", 7)) {
    246230                WinDismissDlg(hwnd, 1);
    247231                break;
    248232              }
    249               else if (!strncmp(urld -> url, "ftp://", 6))
    250               {
    251                 memmove(urld -> url, urld -> url + 6, strlen(urld -> url) + 1);
    252                 if (*urld -> url)
    253                 {
     233              else if (!strncmp(urld->url, "ftp://", 6)) {
     234                memmove(urld->url, urld->url + 6, strlen(urld->url) + 1);
     235                if (*urld->url) {
    254236                  WinDismissDlg(hwnd, 2);
    255237                  break;
    … …  
    279261  ULONG numlines;
    280262
    281   numlines = (rcl -> yTop - rcl -> yBottom) / ad -> lMaxHeight;
    282   if (ad -> lMaxDescender && numlines &&
    283       ((rcl -> yTop - rcl -> yBottom) -
    284        (numlines * ad -> lMaxHeight) <= ad -> lMaxDescender))
     263  numlines = (rcl->yTop - rcl->yBottom) / ad->lMaxHeight;
     264  if (ad->lMaxDescender && numlines &&
     265      ((rcl->yTop - rcl->yBottom) -
     266       (numlines * ad->lMaxHeight) <= ad->lMaxDescender))
    285267    numlines--;
    286268  return numlines;
    … …  
    297279  INT numlines = 0, numalloc = 0;
    298280
    299   if (ad && ad -> selected)
    300   {
     281  if (ad && ad->selected) {
    301282    WinQueryWindowRect(hwnd, &Rectl);
    302     width = (Rectl.xRight - Rectl.xLeft) / ad -> fattrs.lAveCharWidth;
    303     if (!width && !ad -> hex)
     283    width = (Rectl.xRight - Rectl.xLeft) / ad->fattrs.lAveCharWidth;
     284    if (!width && !ad->hex)
    304285      return list;
    305     for (x = 0; x < ad -> numlines; x++)
    306     {
    307       if (ad -> stopflag)
     286    for (x = 0; x < ad->numlines; x++) {
     287      if (ad->stopflag)
    308288        break;
    309       if (ad -> markedlines[x] & VF_SELECTED)
    310       {
    311         if (ad -> hex)
    312         {
    313           width = ad -> textsize - (x * 16);
     289      if (ad->markedlines[x] & VF_SELECTED) {
     290        if (ad->hex) {
     291          width = ad->textsize - (x * 16);
    314292          width = min(width, 16);
    315293          sprintf(s, "%08lx ", x * 16);
    316294          p = s + 9;
    317           for (y = 0; y < width; y++)
    318           {
    319             sprintf(p, " %02hx", ad -> text[(x * 16) + y]);
     295          for (y = 0; y < width; y++) {
     296            sprintf(p, " %02hx", ad->text[(x * 16) + y]);
    320297            p += 3;
    321298          }
    … …  
    324301          *p = ' ';
    325302          p++;
    326           for (y = 0; y < width; y++)
    327           {
    328             a = ad -> text[(x * 16) + y];
     303          for (y = 0; y < width; y++) {
     304            a = ad->text[(x * 16) + y];
    329305            if (a && a != '\n' && a != '\r' && a != '\t' && a != '\x1a')
    330               *p = ad -> text[(x * 16) + y];
     306              *p = ad->text[(x * 16) + y];
    331307            else
    332308              *p = '.';
    … …  
    335311          *p = 0;
    336312        }
    337         else
    338         {
    339           if (!ad -> wrapon)
    340           {
    341             e = p = ad -> lines[x];
    342             while (*e != '\r' && *e != '\n' && e < ad -> text + ad -> textsize)
     313        else {
     314          if (!ad->wrapon) {
     315            e = p = ad->lines[x];
     316            while (*e != '\r' && *e != '\n' && e < ad->text + ad->textsize)
    343317              e++;
    344318/*
    … …  
    348322            width = e - p;
    349323          }
    350           else
    351           {
    352             p = ad -> lines[x];
     324          else {
     325            p = ad->lines[x];
    353326            e = p + (width - 1);
    354             if (e - ad -> text > ad -> textsize)
    355               e = ad -> text + ad -> textsize;
    356             while (p < e)
    357             {
    358               if (*p == '\r' || *p == '\n')
    359               {
     327            if (e - ad->text > ad->textsize)
     328              e = ad->text + ad->textsize;
     329            while (p < e) {
     330              if (*p == '\r' || *p == '\n') {
    360331                e = p;
    361332                break;
    … …  
    364335            }
    365336          }
    366           strncpy(s, ad -> lines[x], e - ad -> lines[x]);
    367           s[e - ad -> lines[x]] = 0;
     337          strncpy(s, ad->lines[x], e - ad->lines[x]);
     338          s[e - ad->lines[x]] = 0;
    368339        }
    369340        if (AddToList(s, &list, &numlines, &numalloc))
    370341          break;
    371342        z++;
    372         if (z >= ad -> selected)
     343        if (z >= ad->selected)
    373344          break;
    374345      }
    … …  
    385356  INT numlines = 0, numalloc = 0;
    386357
    387   if (ad)
    388   {
    389     z = (SHORT) WinSendDlgItemMsg(ad -> hwndFrame, NEWVIEW_LISTBOX,
     358  if (ad) {
     359    z = (SHORT) WinSendDlgItemMsg(ad->hwndFrame, NEWVIEW_LISTBOX,
    390360                                  LM_QUERYITEMCOUNT, MPVOID, MPVOID);
    391361    z = max(z, 0);
    392     for (x = 0; x < z; x++)
    393     {
    394       if (ad -> stopflag)
     362    for (x = 0; x < z; x++) {
     363      if (ad->stopflag)
    395364        break;
    396365      *s = 0;
    397       WinSendDlgItemMsg(ad -> hwndFrame, NEWVIEW_LISTBOX, LM_QUERYITEMTEXT,
     366      WinSendDlgItemMsg(ad->hwndFrame, NEWVIEW_LISTBOX, LM_QUERYITEMTEXT,
    398367                        MPFROM2SHORT(x, SEARCHSTRINGLEN), MPFROMP(s));
    399368      if (*s)
    … …  
    407376MRESULT EXPENTRY ViewStatusProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
    408377{
    409   switch (msg)
    410   {
     378  switch (msg) {
    411379  case WM_CREATE:
    412380    return CommonTextProc(hwnd, msg, mp1, mp2);
    … …  
    416384      USHORT id = WinQueryWindowUShort(hwnd, QWS_ID);
    417385
    418       if (fOtherHelp)
    419       {
    420         if ((!hwndBubble || WinQueryWindowULong(hwndBubble, QWL_USER) != hwnd) &&
    421             !WinQueryCapture(HWND_DESKTOP))
    422         {
     386      if (fOtherHelp) {
     387        if ((!hwndBubble || WinQueryWindowULong(hwndBubble, QWL_USER) != hwnd)
     388            && !WinQueryCapture(HWND_DESKTOP)) {
    423389
    424390          char *s = NULL;
    425391
    426           switch (id)
    427           {
     392          switch (id) {
    428393          case NEWVIEW_STATUS2:
    429394            s = GetPString(IDS_NVSTATUS2HELPTEXT);
    … …  
    442407        }
    443408      }
    444       switch (id)
    445       {
     409      switch (id) {
    446410      case NEWVIEW_STATUS1:
    447411        break;
    … …  
    460424
    461425      id = WinQueryWindowUShort(hwnd, QWS_ID);
    462       switch (id)
    463       {
     426      switch (id) {
    464427      case NEWVIEW_STATUS1:
    465428        break;
    … …  
    475438      USHORT id = WinQueryWindowUShort(hwnd, QWS_ID), cmd = 0;
    476439
    477       switch (id)
    478       {
     440      switch (id) {
    479441      case NEWVIEW_DRAG:
    480442        if (msg == UM_CLICKED)
    … …  
    492454      PostMsg(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
    493455                              FID_CLIENT),
    494               WM_COMMAND,
    495               MPFROM2SHORT(cmd, 0),
    496               MPVOID);
     456              WM_COMMAND, MPFROM2SHORT(cmd, 0), MPVOID);
    497457    }
    498458    return 0;
    … …  
    502462      USHORT id = WinQueryWindowUShort(hwnd, QWS_ID);
    503463
    504       switch (id)
    505       {
     464      switch (id) {
    506465      case NEWVIEW_STATUS1:
    507466      case NEWVIEW_DRAG:
    508467        {
    509           VIEWDATA *ad = WinQueryWindowPtr(WinWindowFromID(
    510                                                         WinQueryWindow(hwnd,
    511                                                                 QW_PARENT),
    512                                                             FID_CLIENT), 0);
     468          VIEWDATA *ad =
     469            WinQueryWindowPtr(WinWindowFromID(WinQueryWindow(hwnd,
     470                                                            QW_PARENT),
     471                                              FID_CLIENT), 0);
    513472
    514473          if (ad)
    515474            DragOne(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
    516                               FID_CLIENT), (HWND)0, ad -> filename, FALSE);
     475                                    FID_CLIENT), (HWND) 0, ad->filename,
     476                    FALSE);
    517477        }
    518478        break;
    … …  
    525485  case WM_CONTEXTMENU:
    526486    PostMsg(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
    527                             FID_CLIENT),
    528             UM_CONTEXTMENU,
    529             MPVOID,
    530             MPVOID);
     487                            FID_CLIENT), UM_CONTEXTMENU, MPVOID, MPVOID);
    531488    break;
    532489
    … …  
    541498      ULONG color;
    542499      VIEWDATA *ad = WinQueryWindowPtr(WinWindowFromID(WinQueryWindow(hwnd,
    543                                                 QW_PARENT), FID_CLIENT), 0);
     500                                                                      QW_PARENT),
     501                                                       FID_CLIENT), 0);
    544502      SWP swp;
    545503      POINTL ptl;
    546504      HPS hps;
    547505
    548       switch (id)
    549       {
     506      switch (id) {
    550507      case NEWVIEW_STATUS1:
    551508        PaintRecessedWindow(hwnd, (HPS) 0, FALSE, FALSE);
    … …  
    556513      }
    557514      hps = WinGetPS(WinQueryWindow(hwnd, QW_PARENT));
    558       if (hps)
    559       {
     515      if (hps) {
    560516        WinQueryWindowPos(hwnd, &swp);
    561517        ptl.x = swp.x - 1;
    562518        ptl.y = swp.y + swp.cy + 2;
    563519        GpiMove(hps, &ptl);
    564         switch (id)
    565         {
     520        switch (id) {
    566521        case NEWVIEW_STATUS1:
    567522          if (ad)
    568             color = (standardcolors[ad -> colors[COLORS_NORMALBACK]] == CLR_WHITE) ?
    569               CLR_PALEGRAY : CLR_WHITE;
     523            color =
     524              (standardcolors[ad->colors[COLORS_NORMALBACK]] ==
     525               CLR_WHITE) ? CLR_PALEGRAY : CLR_WHITE;
    570526          else
    571527            color = CLR_WHITE;
    … …  
    573529        default:
    574530          if (ad)
    575             color = (standardcolors[ad -> colors[COLORS_NORMALBACK]] == CLR_PALEGRAY) ?
    576               CLR_DARKGRAY : CLR_PALEGRAY;
     531            color =
     532              (standardcolors[ad->colors[COLORS_NORMALBACK]] ==
     533               CLR_PALEGRAY) ? CLR_DARKGRAY : CLR_PALEGRAY;
    577534          else
    578535            color = CLR_PALEGRAY;
    … …  
    589546  case UM_FOCUSME:
    590547    WinSetFocus(HWND_DESKTOP,
    591                 WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
    592                                 FID_CLIENT));
     548                WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT), FID_CLIENT));
    593549    return 0;
    594550  }
    … …  
    600556  VIEWDATA *ad = WinQueryWindowPtr(hwnd, QWL_USER);
    601557
    602   if (ad)
    603   {
    604     ad -> selected = ad -> textsize = ad -> numlines = ad -> numalloc = 0;
    605     if (ad -> text)
    606       free(ad -> text);
    607     if (ad -> lines)
    608       free(ad -> lines);
    609     if (ad -> markedlines)
    610       free(ad -> markedlines);
    611     ad -> text = NULL;
    612     ad -> lines = NULL;
    613     ad -> markedlines = NULL;
     558  if (ad) {
     559    ad->selected = ad->textsize = ad->numlines = ad->numalloc = 0;
     560    if (ad->text)
     561      free(ad->text);
     562    if (ad->lines)
     563      free(ad->lines);
     564    if (ad->markedlines)
     565      free(ad->markedlines);
     566    ad->text = NULL;
     567    ad->lines = NULL;
     568    ad->markedlines = NULL;
    614569    DosPostEventSem(CompactSem);
    615570  }
    … …  
    623578  FONTMETRICS FontMetrics;
    624579
    625   if (ad)
    626   {
     580  if (ad) {
    627581    sizel.cx = sizel.cy = 0;
    628582    hps = GpiCreatePS(WinQueryAnchorBlock(hwnd), WinOpenWindowDC(hwnd),
    629583                      (PSIZEL) & sizel, PU_PELS | GPIF_DEFAULT | GPIT_MICRO |
    630584                      GPIA_ASSOC);
    631     if (hps)
    632     {
    633       GpiSetCp(hps, (ULONG) ad -> fattrs.usCodePage);
    634       GpiCreateLogFont(hps, NULL, FIXED_FONT_LCID, &ad -> fattrs);
     585    if (hps) {
     586      GpiSetCp(hps, (ULONG) ad->fattrs.usCodePage);
     587      GpiCreateLogFont(hps, NULL, FIXED_FONT_LCID, &ad->fattrs);
    635588      GpiSetCharSet(hps, FIXED_FONT_LCID);
    636       GpiQueryFontMetrics(hps, (long) sizeof(FONTMETRICS), &FontMetrics);
    637       ad -> fattrs.lAveCharWidth = FontMetrics.lAveCharWidth;
    638       ad -> fattrs.lMaxBaselineExt = FontMetrics.lMaxBaselineExt;
    639       ad -> lMaxAscender = max(FontMetrics.lMaxAscender, 0);
    640       ad -> lMaxDescender = max(FontMetrics.lMaxDescender, 0);
    641       ad -> lMaxHeight = ad -> lMaxAscender + ad -> lMaxDescender;
    642       if (ad -> fattrs.usCodePage != FontMetrics.usCodePage)
    643       {
    644         ad -> fattrs.usCodePage = FontMetrics.usCodePage;
    645         Codepage = ad -> fattrs.usCodePage;
     589      GpiQueryFontMetrics(hps, (long)sizeof(FONTMETRICS), &FontMetrics);
     590      ad->fattrs.lAveCharWidth = FontMetrics.lAveCharWidth;
     591      ad->fattrs.lMaxBaselineExt = FontMetrics.lMaxBaselineExt;
     592      ad->lMaxAscender = max(FontMetrics.lMaxAscender, 0);
     593      ad->lMaxDescender = max(FontMetrics.lMaxDescender, 0);
     594      ad->lMaxHeight = ad->lMaxAscender + ad->lMaxDescender;
     595      if (ad->fattrs.usCodePage != FontMetrics.usCodePage) {
     596        ad->fattrs.usCodePage = FontMetrics.usCodePage;
     597        Codepage = ad->fattrs.usCodePage;
    646598        PrfWriteProfileData(fmprof,
    647599                            appname,
    648600                            "Viewer.Codepage",
    649                             &ad -> fattrs.usCodePage,
    650                             sizeof(USHORT));
    651       }
    652       else if (ad -> fattrs.usCodePage)
    653       {
     601                            &ad->fattrs.usCodePage, sizeof(USHORT));
     602      }
     603      else if (ad->fattrs.usCodePage) {
    654604
    655605        HMQ hmq;
    656606        ULONG cps[50], len, x;
    657607
    658         if (!DosQueryCp(sizeof(cps), cps, &len))
    659         {
    660           for (x = 0; x < len / sizeof(ULONG); x++)
    661           {
    662             if (cps[x] == (ULONG) ad -> fattrs.usCodePage)
    663             {
     608        if (!DosQueryCp(sizeof(cps), cps, &len)) {
     609          for (x = 0; x < len / sizeof(ULONG); x++) {
     610            if (cps[x] == (ULONG) ad->fattrs.usCodePage) {
    664611              hmq = WinQueryWindowULong(hwnd, QWL_HMQ);
    665               WinSetCp(hmq, ad -> fattrs.usCodePage);
     612              WinSetCp(hmq, ad->fattrs.usCodePage);
    666613              break;
    667614            }
    668615          }
    669616        }
    670         DosSetProcessCp((ULONG) ad -> fattrs.usCodePage);
     617        DosSetProcessCp((ULONG) ad->fattrs.usCodePage);
    671618      }
    672619      GpiSetBackMix(hps, BM_OVERPAINT);
    673       SetPresParamFromFattrs(WinWindowFromID(ad -> hwndFrame, NEWVIEW_LISTBOX),
    674                              &ad -> fattrs, FontMetrics.sNominalPointSize,
    675                           MAKEFIXED(FontMetrics.sNominalPointSize / 10, 0));
     620      SetPresParamFromFattrs(WinWindowFromID(ad->hwndFrame, NEWVIEW_LISTBOX),
     621                             &ad->fattrs, FontMetrics.sNominalPointSize,
     622                             MAKEFIXED(FontMetrics.sNominalPointSize / 10,
     623                                       0));
    676624    }
    677625  }
    … …  
    689637  RECTL rcl2;
    690638
    691   if (ad && (ad -> hex || ad -> lines))
    692   {
    693     ptl.y = (Rectl -> yTop - (ad -> lMaxHeight *
    694                               (((whichline + 1) - topline) + 1)));
     639  if (ad && (ad->hex || ad->lines)) {
     640    ptl.y = (Rectl->yTop - (ad->lMaxHeight *
     641                            (((whichline + 1) - topline) + 1)));
    695642    ptl.x = 0;
    696643    GpiMove(hps, &ptl);
    697644    GpiSetBackMix(hps, BM_OVERPAINT);
    698     if (ad -> markedlines)
    699     {
    700       if (ad -> markedlines[whichline] & VF_SELECTED)
    701       {
    702         GpiSetColor(hps, ((ad -> markedlines[whichline] & VF_FOUND) != 0) ?
    703                     standardcolors[ad -> colors[COLORS_SELECTEDFOUNDFORE]] :
    704                     standardcolors[ad -> colors[COLORS_SELECTEDFORE]]);
    705         GpiSetBackColor(hps, (whichline == ad -> cursored - 1) ?
    706                  standardcolors[ad -> colors[COLORS_CURSOREDSELECTEDBACK]] :
    707                         standardcolors[ad -> colors[COLORS_SELECTEDBACK]]);
    708       }
    709       else if (ad -> markedlines[whichline] & VF_FOUND)
    710       {
    711         GpiSetColor(hps, standardcolors[ad -> colors[COLORS_FOUNDFORE]]);
    712         GpiSetBackColor(hps, (whichline == ad -> cursored - 1) ?
    713                    standardcolors[ad -> colors[COLORS_CURSOREDNORMALBACK]] :
    714                         standardcolors[ad -> colors[COLORS_NORMALBACK]]);
    715       }
    716       else
    717       {
    718         GpiSetColor(hps, standardcolors[ad -> colors[COLORS_NORMALFORE]]);
    719         GpiSetBackColor(hps, (whichline == ad -> cursored - 1) ?
    720                    standardcolors[ad -> colors[COLORS_CURSOREDNORMALBACK]] :
    721                         standardcolors[ad -> colors[COLORS_NORMALBACK]]);
    722       }
    723     }
    724     else
    725     {
    726       GpiSetColor(hps, standardcolors[ad -> colors[COLORS_NORMALFORE]]);
    727       GpiSetBackColor(hps, (whichline == ad -> cursored - 1) ?
    728                    standardcolors[ad -> colors[COLORS_CURSOREDNORMALBACK]] :
    729                       standardcolors[ad -> colors[COLORS_NORMALBACK]]);
    730     }
    731     if (!ad -> hex)
    732     {
    733       if (ad -> wrapon)
    734       {
    735         width = (Rectl -> xRight - Rectl -> xLeft) / ad -> fattrs.lAveCharWidth;
    736         if (width)
    737         {
    738           GpiCharString(hps, 1, marker + (whichline == ad -> cursored - 1));
    739           p = ad -> lines[whichline];
     645    if (ad->markedlines) {
     646      if (ad->markedlines[whichline] & VF_SELECTED) {
     647        GpiSetColor(hps, ((ad->markedlines[whichline] & VF_FOUND) != 0) ?
     648                    standardcolors[ad->colors[COLORS_SELECTEDFOUNDFORE]] :
     649                    standardcolors[ad->colors[COLORS_SELECTEDFORE]]);
     650        GpiSetBackColor(hps, (whichline == ad->cursored - 1) ?
     651                        standardcolors[ad->
     652                                       colors[COLORS_CURSOREDSELECTEDBACK]] :
     653                        standardcolors[ad->colors[COLORS_SELECTEDBACK]]);
     654      }
     655      else if (ad->markedlines[whichline] & VF_FOUND) {
     656        GpiSetColor(hps, standardcolors[ad->colors[COLORS_FOUNDFORE]]);
     657        GpiSetBackColor(hps, (whichline == ad->cursored - 1) ?
     658                        standardcolors[ad->
     659                                       colors[COLORS_CURSOREDNORMALBACK]] :
     660                        standardcolors[ad->colors[COLORS_NORMALBACK]]);
     661      }
     662      else {
     663        GpiSetColor(hps, standardcolors[ad->colors[COLORS_NORMALFORE]]);
     664        GpiSetBackColor(hps, (whichline == ad->cursored - 1) ?
     665                        standardcolors[ad->
     666                                       colors[COLORS_CURSOREDNORMALBACK]] :
     667                        standardcolors[ad->colors[COLORS_NORMALBACK]]);
     668      }
     669    }
     670    else {
     671      GpiSetColor(hps, standardcolors[ad->colors[COLORS_NORMALFORE]]);
     672      GpiSetBackColor(hps, (whichline == ad->cursored - 1) ?
     673                      standardcolors[ad->colors[COLORS_CURSOREDNORMALBACK]] :
     674                      standardcolors[ad->colors[COLORS_NORMALBACK]]);
     675    }
     676    if (!ad->hex) {
     677      if (ad->wrapon) {
     678        width = (Rectl->xRight - Rectl->xLeft) / ad->fattrs.lAveCharWidth;
     679        if (width) {
     680          GpiCharString(hps, 1, marker + (whichline == ad->cursored - 1));
     681          p = ad->lines[whichline];
    740682          e = p + (width - 1);
    741           if (e - ad -> text > ad -> textsize)
    742             e = ad -> text + ad -> textsize;
    743           while (p < e)
    744           {
    745             if (*p == '\r' || *p == '\n')
    746             {
     683          if (e - ad->text > ad->textsize)
     684            e = ad->text + ad->textsize;
     685          while (p < e) {
     686            if (*p == '\r' || *p == '\n') {
    747687              e = p;
    748688              break;
    … …  
    750690            p++;
    751691          }
    752           if (ad -> ftpin && whichline != ad -> cursored - 1 && (!ad -> markedlines ||
    753               !(ad -> markedlines[whichline] & (VF_SELECTED | VF_FOUND))) &&
    754               strnstr(ad -> lines[whichline], "ftp://", e - ad -> lines[whichline]))
    755           {
    756             GpiSetColor(hps, standardcolors[ad -> colors[COLORS_FTPFORE]]);
    757             GpiSetBackColor(hps, standardcolors[ad -> colors[COLORS_FTPBACK]]);
    758           }
    759           if (ad -> httpin && whichline != ad -> cursored - 1 && (!ad -> markedlines ||
    760               !(ad -> markedlines[whichline] & (VF_SELECTED | VF_FOUND))) &&
    761               strnstr(ad -> lines[whichline], "http://", e - ad -> lines[whichline]))
    762           {
    763             GpiSetColor(hps, standardcolors[ad -> colors[COLORS_HTTPFORE]]);
    764             GpiSetBackColor(hps, standardcolors[ad -> colors[COLORS_HTTPBACK]]);
     692          if (ad->ftpin && whichline != ad->cursored - 1
     693              && (!ad->markedlines
     694                  || !(ad->markedlines[whichline] & (VF_SELECTED | VF_FOUND)))
     695              && strnstr(ad->lines[whichline], "ftp://",
     696                         e - ad->lines[whichline])) {
     697            GpiSetColor(hps, standardcolors[ad->colors[COLORS_FTPFORE]]);
     698            GpiSetBackColor(hps, standardcolors[ad->colors[COLORS_FTPBACK]]);
     699          }
     700          if (ad->httpin && whichline != ad->cursored - 1
     701              && (!ad->markedlines
     702                  || !(ad->markedlines[whichline] & (VF_SELECTED | VF_FOUND)))
     703              && strnstr(ad->lines[whichline], "http://",
     704                         e - ad->lines[whichline])) {
     705            GpiSetColor(hps, standardcolors[ad->colors[COLORS_HTTPFORE]]);
     706            GpiSetBackColor(hps, standardcolors[ad->colors[COLORS_HTTPBACK]]);
    765707          }
    766708          rcl2 = *Rectl;
    767           rcl2.yTop = ptl.y + ad -> lMaxAscender;
    768           rcl2.yBottom = ptl.y - ad -> lMaxDescender;
    769           GpiCharString(hps, e - ad -> lines[whichline], ad -> lines[whichline]);
     709          rcl2.yTop = ptl.y + ad->lMaxAscender;
     710          rcl2.yBottom = ptl.y - ad->lMaxDescender;
     711          GpiCharString(hps, e - ad->lines[whichline], ad->lines[whichline]);
    770712          GpiQueryCurrentPosition(hps, &ptl);
    771713          rcl2.xLeft = ptl.x;
    772714          WinFillRect(hps, &rcl2,
    773                       standardcolors[ad -> colors[COLORS_NORMALBACK]]);
    774         }
    775       }
    776       else
    777       {
    778         width = (Rectl -> xRight - Rectl -> xLeft) / ad -> fattrs.lAveCharWidth;
    779         if (width)
    780         {
    781           GpiCharString(hps, 1, marker + (whichline == ad -> cursored - 1));
    782           p = ad -> lines[whichline];
    783           e = p + (abs(ad -> horzscroll) / ad -> fattrs.lAveCharWidth);
    784           if (e - ad -> text > ad -> textsize)
    785             e = ad -> text + ad -> textsize;
    786           while (p < e)
    787           {
     715                      standardcolors[ad->colors[COLORS_NORMALBACK]]);
     716        }
     717      }
     718      else {
     719        width = (Rectl->xRight - Rectl->xLeft) / ad->fattrs.lAveCharWidth;
     720        if (width) {
     721          GpiCharString(hps, 1, marker + (whichline == ad->cursored - 1));
     722          p = ad->lines[whichline];
     723          e = p + (abs(ad->horzscroll) / ad->fattrs.lAveCharWidth);
     724          if (e - ad->text > ad->textsize)
     725            e = ad->text + ad->textsize;
     726          while (p < e) {
    788727            if (*p == '\r' || *p == '\n')
    789728              break;
    790729            p++;
    791730          }
    792           if (*p != '\r' && *p != '\n')
    793           {
     731          if (*p != '\r' && *p != '\n') {
    794732
    795733            CHAR *pp;
    796734
    797735            e = p + (width - 1);
    798             if (e - ad -> text > ad -> textsize)
    799               e = ad -> text + ad -> textsize;
     736            if (e - ad->text > ad->textsize)
     737              e = ad->text + ad->textsize;
    800738            pp = p;
    801             while (pp < e)
    802             {
    803               if (*pp == '\r' || *pp == '\n')
    804               {
     739            while (pp < e) {
     740              if (*pp == '\r' || *pp == '\n') {
    805741                e = pp;
    806742                break;
    … …  
    811747          else
    812748            e = p;
    813           if (ad -> ftpin && whichline != ad -> cursored - 1 && (!ad -> markedlines ||
    814               !(ad -> markedlines[whichline] & (VF_SELECTED | VF_FOUND))) &&
    815               strnstr(ad -> lines[whichline], "ftp://", e - ad -> lines[whichline]))
    816           {
    817             GpiSetColor(hps, standardcolors[ad -> colors[COLORS_FTPFORE]]);
    818             GpiSetBackColor(hps, standardcolors[ad -> colors[COLORS_FTPBACK]]);
    819           }
    820           if (ad -> httpin && whichline != ad -> cursored - 1 && (!ad -> markedlines ||
    821               !(ad -> markedlines[whichline] & (VF_SELECTED | VF_FOUND))) &&
    822               strnstr(ad -> lines[whichline], "http://", e - ad -> lines[whichline]))
    823           {
    824             GpiSetColor(hps, standardcolors[ad -> colors[COLORS_HTTPFORE]]);
    825             GpiSetBackColor(hps, standardcolors[ad -> colors[COLORS_HTTPBACK]]);
     749          if (ad->ftpin && whichline != ad->cursored - 1
     750              && (!ad->markedlines
     751                  || !(ad->markedlines[whichline] & (VF_SELECTED | VF_FOUND)))
     752              && strnstr(ad->lines[whichline], "ftp://",
     753                         e - ad->lines[whichline])) {
     754            GpiSetColor(hps, standardcolors[ad->colors[COLORS_FTPFORE]]);
     755            GpiSetBackColor(hps, standardcolors[ad->colors[COLORS_FTPBACK]]);
     756          }
     757          if (ad->httpin && whichline != ad->cursored - 1
     758              && (!ad->markedlines
     759                  || !(ad->markedlines[whichline] & (VF_SELECTED | VF_FOUND)))
     760              && strnstr(ad->lines[whichline], "http://",
     761                         e - ad->lines[whichline])) {
     762            GpiSetColor(hps, standardcolors[ad->colors[COLORS_HTTPFORE]]);
     763            GpiSetBackColor(hps, standardcolors[ad->colors[COLORS_HTTPBACK]]);
    826764          }
    827765          rcl2 = *Rectl;
    828           rcl2.yTop = ptl.y + ad -> lMaxAscender;
    829           rcl2.yBottom = ptl.y - ad -> lMaxDescender;
     766          rcl2.yTop = ptl.y + ad->lMaxAscender;
     767          rcl2.yBottom = ptl.y - ad->lMaxDescender;
    830768          GpiCharString(hps, e - p, p);
    831769          GpiQueryCurrentPosition(hps, &ptl);
    832770          rcl2.xLeft = ptl.x;
    833771          WinFillRect(hps, &rcl2,
    834                       standardcolors[ad -> colors[COLORS_NORMALBACK]]);
    835         }
    836       }
    837     }
    838     else
    839     {
     772                      standardcolors[ad->colors[COLORS_NORMALBACK]]);
     773        }
     774      }
     775    }
     776    else {
    840777
    841778      CHAR s[80];
    … …  
    843780
    844781      rcl2 = *Rectl;
    845       rcl2.yTop = ptl.y + ad -> lMaxAscender;
    846       rcl2.yBottom = ptl.y - ad -> lMaxDescender;
    847       GpiCharString(hps, 1, marker + (whichline == ad -> cursored - 1));
    848       width = ad -> textsize - (whichline * 16);
     782      rcl2.yTop = ptl.y + ad->lMaxAscender;
     783      rcl2.yBottom = ptl.y - ad->lMaxDescender;
     784      GpiCharString(hps, 1, marker + (whichline == ad->cursored - 1));
     785      width = ad->textsize - (whichline * 16);
    849786      width = min(width, 16);
    850       sprintf(s,
    851               "%08lx ",
    852               whichline * 16);
     787      sprintf(s, "%08lx ", whichline * 16);
    853788      p = s + 9;
    854       for (x = 0; x < width; x++)
    855       {
    856         sprintf(p,
    857                 " %02hx",
    858                 ad -> text[(whichline * 16) + x]);
     789      for (x = 0; x < width; x++) {
     790        sprintf(p, " %02hx", ad->text[(whichline * 16) + x]);
    859791        p += 3;
    860792      }
    861       for (; x < 16; x++)
    862       {
     793      for (; x < 16; x++) {
    863794        *p = ' ';
    864795        p++;
    … …  
    872803      *p = ' ';
    873804      p++;
    874       for (x = 0; x < width; x++)
    875       {
    876         *p = ad -> text[(whichline * 16) + x];
     805      for (x = 0; x < width; x++) {
     806        *p = ad->text[(whichline * 16) + x];
    877807        p++;
    878808      }
    879809      *p = 0;
    880       GpiCharString(hps, (p - s) - (abs(ad -> horzscroll) /
    881                                     ad -> fattrs.lAveCharWidth),
    882                   s + (abs(ad -> horzscroll) / ad -> fattrs.lAveCharWidth));
     810      GpiCharString(hps, (p - s) - (abs(ad->horzscroll) /
     811                                    ad->fattrs.lAveCharWidth),
     812                    s + (abs(ad->horzscroll) / ad->fattrs.lAveCharWidth));
    883813      GpiQueryCurrentPosition(hps, &ptl);
    884       if (ptl.x + abs(ad -> horzscroll) + ad -> fattrs.lAveCharWidth + 1 > ad -> maxx)
    885       {
    886         ad -> maxx = ptl.x + abs(ad -> horzscroll) + ad -> fattrs.lAveCharWidth + 1;
    887         WinSendMsg(ad -> hhscroll, SBM_SETTHUMBSIZE,
    888                    MPFROM2SHORT((SHORT) Rectl -> xRight, (SHORT) ad -> maxx),
     814      if (ptl.x + abs(ad->horzscroll) + ad->fattrs.lAveCharWidth + 1 >
     815          ad->maxx) {
     816        ad->maxx = ptl.x + abs(ad->horzscroll) + ad->fattrs.lAveCharWidth + 1;
     817        WinSendMsg(ad->hhscroll, SBM_SETTHUMBSIZE,
     818                   MPFROM2SHORT((SHORT) Rectl->xRight, (SHORT) ad->maxx),
    889819                   MPVOID);
    890820      }
    891821      rcl2.xLeft = ptl.x;
    892       WinFillRect(hps, &rcl2, standardcolors[ad -> colors[COLORS_NORMALBACK]]);
     822      WinFillRect(hps, &rcl2, standardcolors[ad->colors[COLORS_NORMALBACK]]);
    893823    }
    894824  }
    … …  
    897827static VOID SearchThread(VOID * args)
    898828{
    899   HWND hwnd = (HWND)args;
     829  HWND hwnd = (HWND) args;
    900830  HAB hab2;
    901831  HMQ hmq2;
    … …  
    906836  register ULONG x;
    907837  CHAR s[SEARCHSTRINGLEN], s2[SEARCHSTRINGLEN], *t, *n, markwith;
    908 
    909   priority_normal();
    910   hab2 = WinInitialize(0);
    911   if (hab2)
    912   {
    913     hmq2 = WinCreateMsgQueue(hab2, 0);
    914     if (hmq2) {
    915       WinCancelShutdown(hmq2, TRUE);
    916       IncrThreadUsage();
    917       ad = WinQueryWindowPtr(hwnd, QWL_USER);
    918       if (ad)
    919       {
    920         if (!DosRequestMutexSem(ad -> ScanSem, SEM_INDEFINITE_WAIT))
    921         {
    922           markwith = VF_FOUND | ((ad -> alsoselect) ? VF_SELECTED : 0);
    923           strcpy(s, ad -> searchtext);
    924           if (*s)
    925           {
    926             WinQueryWindowRect(hwnd, &Rectl);
    927             width = (Rectl.xRight - Rectl.xLeft) / ad -> fattrs.lAveCharWidth;
    928             numlines = NumLines(&Rectl, ad);
    929             WinSetWindowText(WinWindowFromID(ad -> hwndFrame,
    930                                              NEWVIEW_STATUS1),
    931                              GetPString(IDS_SEARCHINGTEXT));
    932             if (numlines && width && ad -> markedlines && ad -> numlines &&
    933                 ad -> text && ad -> textsize)
    934             {
    935               for (x = 0; x < ad -> numlines && !ad -> stopflag; x++)
    936                 ad -> markedlines[x] &= (~VF_FOUND);
    937               ad -> found = 0;
    938               t = s;
    939               while (t && !ad -> stopflag)
    940               {
    941                 lastline = 1;
    942                 n = convert_nl_to_nul(t);
    943                 if (*t)
    944                 {
    945                   strcpy(s2, t);
    946                   if (ad -> literalsearch)
    947                     literal(s2);
    948                   p = ad -> text;
    949                   while (p && !ad -> stopflag)
    950                   {
    951                     p = findstring(s2, strlen(s2), p,
    952                                    ad -> textsize - (p - ad -> text),
    953                                    ad -> sensitive);
    954                     if (p)
    955                     {
    956                       if (ad -> hex)
    957                       {
    958                         whichline = (p - ad -> text) / 16;
    959                         if (whichline < firstline)
    960                           firstline = whichline;
    961                         if (!(ad -> markedlines[whichline] & VF_FOUND))
    962                           ad -> found++;
    963                         if (markwith & VF_SELECTED)
    964                         {
    965                           if (!(ad -> markedlines[whichline] & VF_SELECTED))
    966                             ad -> selected++;
    967                         }
    968                         ad -> markedlines[whichline] |= markwith;
    969                         if ((p - ad -> text) + strlen(s2) > (whichline + 1) * 16)
    970                         {
    971                           whichline++;
    972                           if (!(ad -> markedlines[whichline] & VF_FOUND))
    973                             ad -> found++;
    974                           if (markwith & VF_SELECTED)
    975                           {
    976                             if (!(ad -> markedlines[whichline] & VF_SELECTED))
    977                               ad -> selected++;
    978                           }
    979                           ad -> markedlines[whichline] |= markwith;
    980                         }
    981                         p = ad -> text + ((whichline + 1) * 16);
    982                         if (p >= ad -> text + ad -> textsize)
    983                           break;
    984                       }
    985                       else
    986                       {
    987                         for (x = lastline; x < ad -> numlines; x++)
    988                         {
    989                           if (ad -> lines[x] > p)
    990                           {
    991                             if (x - 1 < firstline)
    992                               firstline = x - 1;
    993                             if (!(ad -> markedlines[x - 1] & VF_FOUND))
    994                               ad -> found++;
    995                             if (markwith & VF_SELECTED)
    996                             {
    997                               if (!(ad -> markedlines[x - 1] & VF_SELECTED))
    998                                 ad -> selected++;
    999                             }
    1000                             ad -> markedlines[x - 1] |= markwith;
    1001                             if (x + 1 < ad -> numlines &&
    1002                                 p + strlen(s2) > ad -> lines[x])
    1003                             {
    1004                               x++;
    1005                               if (!(ad -> markedlines[x - 1] & VF_FOUND))
    1006                                 ad -> found++;
    1007                               if (markwith & VF_SELECTED)
    1008                               {
    1009                                 if (!(ad -> markedlines[x - 1] & VF_SELECTED))
    1010                                   ad -> selected++;
    1011                               }
    1012                               ad -> markedlines[x - 1] |= markwith;
    1013                             }
    1014                             lastline = x;
    1015                             p = ad -> lines[x];
    1016                             break;
    1017                           }
    1018                         }
    1019                         if (x >= ad -> numlines)
    1020                         {
    1021                           if (markwith & VF_SELECTED)
    1022                           {
    1023                             if (!(ad -> markedlines[numlines - 1] & VF_SELECTED))
    1024                               ad -> selected++;
    1025                             if (!(ad -> markedlines[numlines - 1] & VF_FOUND))
    1026                               ad -> found++;
    1027                           }
    1028                           ad -> markedlines[ad -> numlines - 1] |= markwith;
    1029                           break;
    1030                         }
    1031                       }
    1032                     }
    1033                   }
    1034                 }
    1035                 t = n;
    1036               }
    1037             }
    1038             DosReleaseMutexSem(ad -> ScanSem);
    1039             if (!ad -> stopflag && firstline == ULONG_MAX)
    1040             {
    1041               DosBeep(50, 50);
    1042               WinSetWindowText(WinWindowFromID(ad -> hwndFrame,
    1043                                                NEWVIEW_STATUS1),
    1044                                GetPString(IDS_NOMATCHINGTEXT));
    1045               DosSleep(1500);
    1046               PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
    1047               PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
    1048             }
    1049             else if (!ad -> stopflag)
    1050             {
    1051               PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
    1052               PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
    1053               PostMsg(hwnd, UM_CONTAINER_FILLED,
    1054                       MPFROMLONG(firstline + 1),
    1055                       MPFROMLONG(firstline + 1));
    1056             }
    1057           }
    1058           else
    1059             DosReleaseMutexSem(ad -> ScanSem);
    1060         }
    1061       }
    1062       WinDestroyMsgQueue(hmq2);
    1063     }
    1064     DecrThreadUsage();
    1065     WinTerminate(hab2);
    1066   }
    1067   DosPostEventSem(CompactSem);
    1068 }
    1069 
    1070 static VOID ClipboardThread(VOID * args)
    1071 {
    1072   HWND hwnd = (HWND)args;
    1073   HAB hab2;
    1074   HMQ hmq2;
    1075   VIEWDATA *ad;
    1076   CHAR **list;
    1077   USHORT cmd;
    1078   register ULONG x;
    1079   BOOL released = FALSE;
    1080 
    1081   priority_normal();
    1082   hab2 = WinInitialize(0);
    1083   if (hab2)
    1084   {
    1085     hmq2 = WinCreateMsgQueue(hab2, 0);
    1086     if (hmq2) {
    1087       WinCancelShutdown(hmq2, TRUE);
    1088       IncrThreadUsage();
    1089       ad = WinQueryWindowPtr(hwnd, QWL_USER);
    1090       if (ad)
    1091       {
    1092         if (!DosRequestMutexSem(ad -> ScanSem, SEM_INDEFINITE_WAIT))
    1093         {
    1094           cmd = ad -> cliptype;
    1095           if (ad -> numlines && ad -> text && ad -> textsize && ad -> markedlines &&
    1096               !ad -> stopflag)
    1097           {
    1098             WinSetWindowText(WinWindowFromID(ad -> hwndFrame,
    1099                                              NEWVIEW_STATUS1),
    1100                              GetPString(IDS_BUILDINGLINELISTTEXT));
    1101             if (cmd == IDM_SAVETOCLIP || cmd == IDM_APPENDTOCLIP ||
    1102                 cmd == IDM_SAVETOLIST)
    1103               list = BuildAList(hwnd);
    1104             else
    1105               list = BuildAList2(hwnd);
    1106             if (list)
    1107             {
    1108               if (!ad -> stopflag)
    1109               {
    1110                 WinSetWindowText(WinWindowFromID(ad -> hwndFrame,
    1111                                                  NEWVIEW_STATUS1),
    1112                                  (cmd == IDM_SAVETOCLIP ||
    1113                                   cmd == IDM_SAVETOCLIP2) ?
    1114                                  GetPString(IDS_SAVETOCLIPTEXT) :
    1115                                  (cmd == IDM_APPENDTOCLIP ||
    1116                                   cmd == IDM_APPENDTOCLIP2) ?
    1117                                  GetPString(IDS_APPENDTOCLIPTEXT) :
    1118                                  GetPString(IDS_WRITETOFILETEXT));
    1119                 DosReleaseMutexSem(ad -> ScanSem);
    1120                 released = TRUE;
    1121                 if (cmd == IDM_SAVETOCLIP || cmd == IDM_APPENDTOCLIP ||
    1122                     cmd == IDM_SAVETOCLIP2 || cmd == IDM_APPENDTOCLIP2)
    1123                   ListToClipboardHab(hab2, list, (cmd == IDM_APPENDTOCLIP ||
    1124                                                   cmd == IDM_APPENDTOCLIP2));
    1125                 else
    1126                 {
    1127 
    1128                   FILE *fp;
    1129                   CHAR filename[CCHMAXPATH];
    1130 
    1131                   *filename = 0;
    1132                   if (export_filename(hwnd, filename, FALSE))
    1133                   {
    1134                     fp = _fsopen(filename, "a+", SH_DENYWR);
    1135                     if (!fp) {
    1136                       saymsg(MB_CANCEL,
    1137                              hwnd,
    1138                              GetPString(IDS_ERRORTEXT),
    1139                              GetPString(IDS_CANTOPENFORWRITETEXT),
    1140                              filename);
    1141                     }
    1142                     else {
    1143                       fseek(fp, 0L, SEEK_END);
    1144                       for (x = 0; list[x]; x++)
    1145                         fprintf(fp,
    1146                                 "%s\n",
    1147                                 list[x]);
    1148                       fclose(fp);
    1149                     }
    1150                   }
    1151                 }
    1152               }
    1153               FreeList(list);
    1154             }
    1155             else
    1156             {
    1157               DosReleaseMutexSem(ad -> ScanSem);
    1158               released = TRUE;
    1159               DosBeep(50, 100);
    1160               WinSetWindowText(WinWindowFromID(ad -> hwndFrame,
    1161                                                NEWVIEW_STATUS1),
    1162                                GetPString(IDS_NVNOLINESSELTEXT));
    1163               DosSleep(1500);
    1164             }
    1165           }
    1166           if (!released)
    1167             DosReleaseMutexSem(ad -> ScanSem);
    1168           PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
    1169         }
    1170       }
    1171       WinDestroyMsgQueue(hmq2);
    1172     }
    1173     DecrThreadUsage();
    1174     WinTerminate(hab2);
    1175   }
    1176   DosPostEventSem(CompactSem);
    1177 }
    1178 
    1179 static VOID ReLineThread(VOID * args)
    1180 {
    1181   HWND hwnd = (HWND)args;
    1182   HAB hab2;
    1183   HMQ hmq2;
    1184   VIEWDATA *ad;
    1185   CHAR *p, *pp, *e, *whereiam = NULL;
    1186   RECTL Rectl;
    1187   ULONG width, numlines, firstline = 1, cursored = 1;
    1188838
    1189839  priority_normal();
    … …  
    1196846      ad = WinQueryWindowPtr(hwnd, QWL_USER);
    1197847      if (ad) {
    1198         ad -> relining = TRUE;
    1199         if (!DosRequestMutexSem(ad -> ScanSem, SEM_INDEFINITE_WAIT)) {
    1200           ad -> busy++;
    1201           ad -> maxx = 0;
    1202           if (ad -> text && ad -> textsize)
    1203           {
    1204             if (ad -> hex)
    1205             {
    1206               firstline = ad -> topline;
    1207               cursored = ad -> cursored;
    1208             }
    1209             else if (ad -> lines)
    1210               whereiam = ad -> lines[ad -> cursored - 1];
    1211             ad -> found = 0;
    1212             ad -> selected = ad -> numlines = ad -> numalloc = 0;
    1213             if (ad -> lines)
    1214               free(ad -> lines);
    1215             if (ad -> markedlines)
    1216               free(ad -> markedlines);
    1217             ad -> lines = NULL;
    1218             ad -> markedlines = NULL;
    1219             WinSetWindowText(WinWindowFromID(ad -> hwndFrame,
     848        if (!DosRequestMutexSem(ad->ScanSem, SEM_INDEFINITE_WAIT)) {
     849          markwith = VF_FOUND | ((ad->alsoselect) ? VF_SELECTED : 0);
     850          strcpy(s, ad->searchtext);
     851          if (*s) {
     852            WinQueryWindowRect(hwnd, &Rectl);
     853            width = (Rectl.xRight - Rectl.xLeft) / ad->fattrs.lAveCharWidth;
     854            numlines = NumLines(&Rectl, ad);
     855            WinSetWindowText(WinWindowFromID(ad->hwndFrame,
     856                                             NEWVIEW_STATUS1),
     857                             GetPString(IDS_SEARCHINGTEXT));
     858            if (numlines && width && ad->markedlines && ad->numlines &&
     859                ad->text && ad->textsize) {
     860              for (x = 0; x < ad->numlines && !ad->stopflag; x++)
     861                ad->markedlines[x] &= (~VF_FOUND);
     862              ad->found = 0;
     863              t = s;
     864              while (t && !ad->stopflag) {
     865                lastline = 1;
     866                n = convert_nl_to_nul(t);
     867                if (*t) {
     868                  strcpy(s2, t);
     869                  if (ad->literalsearch)
     870                    literal(s2);
     871                  p = ad->text;
     872                  while (p && !ad->stopflag) {
     873                    p = findstring(s2, strlen(s2), p,
     874                                   ad->textsize - (p - ad->text),
     875                                   ad->sensitive);
     876                    if (p) {
     877                      if (ad->hex) {
     878                        whichline = (p - ad->text) / 16;
     879                        if (whichline < firstline)
     880                          firstline = whichline;
     881                        if (!(ad->markedlines[whichline] & VF_FOUND))
     882                          ad->found++;
     883                        if (markwith & VF_SELECTED) {
     884                          if (!(ad->markedlines[whichline] & VF_SELECTED))
     885                            ad->selected++;
     886                        }
     887                        ad->markedlines[whichline] |= markwith;
     888                        if ((p - ad->text) + strlen(s2) >
     889                            (whichline + 1) * 16) {
     890                          whichline++;
     891                          if (!(ad->markedlines[whichline] & VF_FOUND))
     892                            ad->found++;
     893                          if (markwith & VF_SELECTED) {
     894                            if (!(ad->markedlines[whichline] & VF_SELECTED))
     895                              ad->selected++;
     896                          }
     897                          ad->markedlines[whichline] |= markwith;
     898                        }
     899                        p = ad->text + ((whichline + 1) * 16);
     900                        if (p >= ad->text + ad->textsize)
     901                          break;
     902                      }
     903                      else {
     904                        for (x = lastline; x < ad->numlines; x++) {
     905                          if (ad->lines[x] > p) {
     906                            if (x - 1 < firstline)
     907                              firstline = x - 1;
     908                            if (!(ad->markedlines[x - 1] & VF_FOUND))
     909                              ad->found++;
     910                            if (markwith & VF_SELECTED) {
     911                              if (!(ad->markedlines[x - 1] & VF_SELECTED))
     912                                ad->selected++;
     913                            }
     914                            ad->markedlines[x - 1] |= markwith;
     915                            if (x + 1 < ad->numlines &&
     916                                p + strlen(s2) > ad->lines[x]) {
     917                              x++;
     918                              if (!(ad->markedlines[x - 1] & VF_FOUND))
     919                                ad->found++;
     920                              if (markwith & VF_SELECTED) {
     921                                if (!(ad->markedlines[x - 1] & VF_SELECTED))
     922                                  ad->selected++;
     923                              }
     924                              ad->markedlines[x - 1] |= markwith;
     925                            }
     926                            lastline = x;
     927                            p = ad->lines[x];
     928                            break;
     929                          }
     930                        }
     931                        if (x >= ad->numlines) {
     932                          if (markwith & VF_SELECTED) {
     933                            if (!
     934                                (ad->markedlines[numlines - 1] & VF_SELECTED))
     935                              ad->selected++;
     936                            if (!(ad->markedlines[numlines - 1] & VF_FOUND))
     937                              ad->found++;
     938                          }
     939                          ad->markedlines[ad->numlines - 1] |= markwith;
     940                          break;
     941                        }
     942                      }
     943                    }
     944                  }
     945                }
     946                t = n;
     947              }
     948            }
     949            DosReleaseMutexSem(ad->ScanSem);
     950            if (!ad->stopflag && firstline == ULONG_MAX) {
     951              DosBeep(50, 50);
     952              WinSetWindowText(WinWindowFromID(ad->hwndFrame,
     953                                               NEWVIEW_STATUS1),
     954                               GetPString(IDS_NOMATCHINGTEXT));
     955              DosSleep(1500);
     956              PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
     957              PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
     958            }
     959            else if (!ad->stopflag) {
     960              PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
     961              PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
     962              PostMsg(hwnd, UM_CONTAINER_FILLED,
     963                      MPFROMLONG(firstline + 1), MPFROMLONG(firstline + 1));
     964            }
     965          }
     966          else
     967            DosReleaseMutexSem(ad->ScanSem);
     968        }
     969      }
     970      WinDestroyMsgQueue(hmq2);
     971    }
     972    DecrThreadUsage();
     973    WinTerminate(hab2);
     974  }
     975  DosPostEventSem(CompactSem);
     976}
     977
     978static VOID ClipboardThread(VOID * args)
     979{
     980  HWND hwnd = (HWND) args;
     981  HAB hab2;
     982  HMQ hmq2;
     983  VIEWDATA *ad;
     984  CHAR **list;
     985  USHORT cmd;
     986  register ULONG x;
     987  BOOL released = FALSE;
     988
     989  priority_normal();
     990  hab2 = WinInitialize(0);
     991  if (hab2) {
     992    hmq2 = WinCreateMsgQueue(hab2, 0);
     993    if (hmq2) {
     994      WinCancelShutdown(hmq2, TRUE);
     995      IncrThreadUsage();
     996      ad = WinQueryWindowPtr(hwnd, QWL_USER);
     997      if (ad) {
     998        if (!DosRequestMutexSem(ad->ScanSem, SEM_INDEFINITE_WAIT)) {
     999          cmd = ad->cliptype;
     1000          if (ad->numlines && ad->text && ad->textsize && ad->markedlines &&
     1001              !ad->stopflag) {
     1002            WinSetWindowText(WinWindowFromID(ad->hwndFrame,
     1003                                             NEWVIEW_STATUS1),
     1004                             GetPString(IDS_BUILDINGLINELISTTEXT));
     1005            if (cmd == IDM_SAVETOCLIP || cmd == IDM_APPENDTOCLIP ||
     1006                cmd == IDM_SAVETOLIST)
     1007              list = BuildAList(hwnd);
     1008            else
     1009              list = BuildAList2(hwnd);
     1010            if (list) {
     1011              if (!ad->stopflag) {
     1012                WinSetWindowText(WinWindowFromID(ad->hwndFrame,
     1013                                                 NEWVIEW_STATUS1),
     1014                                 (cmd == IDM_SAVETOCLIP ||
     1015                                  cmd == IDM_SAVETOCLIP2) ?
     1016                                 GetPString(IDS_SAVETOCLIPTEXT) :
     1017                                 (cmd == IDM_APPENDTOCLIP ||
     1018                                  cmd == IDM_APPENDTOCLIP2) ?
     1019                                 GetPString(IDS_APPENDTOCLIPTEXT) :
     1020                                 GetPString(IDS_WRITETOFILETEXT));
     1021                DosReleaseMutexSem(ad->ScanSem);
     1022                released = TRUE;
     1023                if (cmd == IDM_SAVETOCLIP || cmd == IDM_APPENDTOCLIP ||
     1024                    cmd == IDM_SAVETOCLIP2 || cmd == IDM_APPENDTOCLIP2)
     1025                  ListToClipboardHab(hab2, list, (cmd == IDM_APPENDTOCLIP ||
     1026                                                  cmd == IDM_APPENDTOCLIP2));
     1027                else {
     1028
     1029                  FILE *fp;
     1030                  CHAR filename[CCHMAXPATH];
     1031
     1032                  *filename = 0;
     1033                  if (export_filename(hwnd, filename, FALSE)) {
     1034                    fp = _fsopen(filename, "a+", SH_DENYWR);
     1035                    if (!fp) {
     1036                      saymsg(MB_CANCEL,
     1037                             hwnd,
     1038                             GetPString(IDS_ERRORTEXT),
     1039                             GetPString(IDS_CANTOPENFORWRITETEXT), filename);
     1040                    }
     1041                    else {
     1042                      fseek(fp, 0L, SEEK_END);
     1043                      for (x = 0; list[x]; x++)
     1044                        fprintf(fp, "%s\n", list[x]);
     1045                      fclose(fp);
     1046                    }
     1047                  }
     1048                }
     1049              }
     1050              FreeList(list);
     1051            }
     1052            else {
     1053              DosReleaseMutexSem(ad->ScanSem);
     1054              released = TRUE;
     1055              DosBeep(50, 100);
     1056              WinSetWindowText(WinWindowFromID(ad->hwndFrame,
     1057                                               NEWVIEW_STATUS1),
     1058                               GetPString(IDS_NVNOLINESSELTEXT));
     1059              DosSleep(1500);
     1060            }
     1061          }
     1062          if (!released)
     1063            DosReleaseMutexSem(ad->ScanSem);
     1064          PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
     1065        }
     1066      }
     1067      WinDestroyMsgQueue(hmq2);
     1068    }
     1069    DecrThreadUsage();
     1070    WinTerminate(hab2);
     1071  }
     1072  DosPostEventSem(CompactSem);
     1073}
     1074
     1075static VOID ReLineThread(VOID * args)
     1076{
     1077  HWND hwnd = (HWND) args;
     1078  HAB hab2;
     1079  HMQ hmq2;
     1080  VIEWDATA *ad;
     1081  CHAR *p, *pp, *e, *whereiam = NULL;
     1082  RECTL Rectl;
     1083  ULONG width, numlines, firstline = 1, cursored = 1;
     1084
     1085  priority_normal();
     1086  hab2 = WinInitialize(0);
     1087  if (hab2) {
     1088    hmq2 = WinCreateMsgQueue(hab2, 0);
     1089    if (hmq2) {
     1090      WinCancelShutdown(hmq2, TRUE);
     1091      IncrThreadUsage();
     1092      ad = WinQueryWindowPtr(hwnd, QWL_USER);
     1093      if (ad) {
     1094        ad->relining = TRUE;
     1095        if (!DosRequestMutexSem(ad->ScanSem, SEM_INDEFINITE_WAIT)) {
     1096          ad->busy++;
     1097          ad->maxx = 0;
     1098          if (ad->text && ad->textsize) {
     1099            if (ad->hex) {
     1100              firstline = ad->topline;
     1101              cursored = ad->cursored;
     1102            }
     1103            else if (ad->lines)
     1104              whereiam = ad->lines[ad->cursored - 1];
     1105            ad->found = 0;
     1106            ad->selected = ad->numlines = ad->numalloc = 0;
     1107            if (ad->lines)
     1108              free(ad->lines);
     1109            if (ad->markedlines)
     1110              free(ad->markedlines);
     1111            ad->lines = NULL;
     1112            ad->markedlines = NULL;
     1113            WinSetWindowText(WinWindowFromID(ad->hwndFrame,
    12201114                                             NEWVIEW_STATUS1),
    12211115                             GetPString(IDS_FORMATTINGTEXT));
    1222             if (!ad -> hex)
    1223             {
    1224               if (WinSendDlgItemMsg(ad -> hwndFrame, NEWVIEW_LISTBOX,
    1225                                     LM_QUERYITEMCOUNT, MPVOID, MPVOID))
    1226               {
    1227                 WinSendDlgItemMsg(ad -> hwndFrame, NEWVIEW_LISTBOX, LM_DELETEALL,
    1228                                   MPVOID, MPVOID);
    1229                 PostMsg(ad -> hwndFrame, WM_UPDATEFRAME,
     1116            if (!ad->hex) {
     1117              if (WinSendDlgItemMsg(ad->hwndFrame, NEWVIEW_LISTBOX,
     1118                                    LM_QUERYITEMCOUNT, MPVOID, MPVOID)) {
     1119                WinSendDlgItemMsg(ad->hwndFrame, NEWVIEW_LISTBOX,
     1120                                  LM_DELETEALL, MPVOID, MPVOID);
     1121                PostMsg(ad->hwndFrame, WM_UPDATEFRAME,
    12301122                        MPFROMLONG(FCF_SIZEBORDER), MPVOID);
    12311123              }
    12321124            }
    12331125            WinSetFocus(HWND_DESKTOP, hwnd);
    1234             if (!ad -> hex)
    1235             {
     1126            if (!ad->hex) {
    12361127              WinQueryWindowRect(hwnd, &Rectl);
    1237               width = (Rectl.xRight - Rectl.xLeft) / ad -> fattrs.lAveCharWidth;
     1128              width = (Rectl.xRight - Rectl.xLeft) / ad->fattrs.lAveCharWidth;
    12381129              numlines = NumLines(&Rectl, ad);
    1239               ad -> oldwidth = width;
    1240               p = ad -> text;
    1241               if (width)
    1242               {
    1243                 while (p - ad -> text < ad -> textsize && !ad -> stopflag)
    1244                 {
    1245                   if (ad -> wrapon)
    1246                   {
     1130              ad->oldwidth = width;
     1131              p = ad->text;
     1132              if (width) {
     1133                while (p - ad->text < ad->textsize && !ad->stopflag) {
     1134                  if (ad->wrapon) {
    12471135                    e = p + (width - 1);
    1248                     if (e - ad -> text > ad -> textsize)
    1249                       e = ad -> text + ad -> textsize;
     1136                    if (e - ad->text > ad->textsize)
     1137                      e = ad->text + ad->textsize;
    12501138                    pp = p;
    1251                     while (pp < e)
    1252                     {
    1253                       if (*pp == '\r' || *pp == '\n')
    1254                       {
     1139                    while (pp < e) {
     1140                      if (*pp == '\r' || *pp == '\n') {
    12551141                        e = pp;
    12561142                        break;
    … …  
    12591145                    }
    12601146                  }
    1261                   else
    1262                   {
     1147                  else {
    12631148                    pp = p;
    1264                     while (pp - ad -> text < ad -> textsize &&
     1149                    while (pp - ad->text < ad->textsize &&
    12651150                           *pp != '\r' && *pp != '\n')
    12661151                      pp++;
    12671152                    e = pp;
    1268                     if (ad -> maxx <
    1269                         (((e - p) + 1) * ad -> fattrs.lAveCharWidth) + 1)
    1270                       ad -> maxx = (((e - p) + 1) *
    1271                                     ad -> fattrs.lAveCharWidth) + 1;
     1153                    if (ad->maxx <
     1154                        (((e - p) + 1) * ad->fattrs.lAveCharWidth) + 1)
     1155                      ad->maxx = (((e - p) + 1) *
     1156                                  ad->fattrs.lAveCharWidth) + 1;
    12721157                  }
    1273                   if (whereiam && p >= whereiam && e <= whereiam)
    1274                   {
    1275                     cursored = firstline = ad -> numlines + 1;
     1158                  if (whereiam && p >= whereiam && e <= whereiam) {
     1159                    cursored = firstline = ad->numlines + 1;
    12761160                    whereiam = NULL;
    12771161                  }
    12781162                  /* assign ad->lines[ad->numlines] */
    1279                   if (ad -> numlines + 1 > ad -> numalloc)
    1280                   {
     1163                  if (ad->numlines + 1 > ad->numalloc) {
    12811164
    12821165                    CHAR **temp;
    12831166
    1284                     temp = xrealloc(ad -> lines, sizeof(CHAR *) *
    1285                                    (ad -> numalloc + 256),pszSrcFile,__LINE__);
     1167                    temp = xrealloc(ad->lines, sizeof(CHAR *) *
     1168                                    (ad->numalloc + 256), pszSrcFile,
     1169                                    __LINE__);
    12861170                    if (!temp)
    12871171                      break;
    1288                     ad -> lines = temp;
    1289                     ad -> numalloc += 256;
     1172                    ad->lines = temp;
     1173                    ad->numalloc += 256;
    12901174                  }
    1291                   ad -> lines[ad -> numlines] = p;
    1292                   ad -> numlines++;
    1293                   if (ad -> numlines == numlines)
    1294                   {
     1175                  ad->lines[ad->numlines] = p;
     1176                  ad->numlines++;
     1177                  if (ad->numlines == numlines) {
    12951178                    /* display first page */
    12961179                    register INT x;
    12971180
    1298                     for (x = 0; x < ad -> numlines; x++)
    1299                     {
     1181                    for (x = 0; x < ad->numlines; x++) {
    13001182                      if ((LONG) (Rectl.yTop -
    1301                                   (ad -> lMaxHeight * (((x + 1) -
    1302                                                   ad -> topline) + 1))) < 0)
     1183                                  (ad->lMaxHeight * (((x + 1) -
     1184                                                      ad->topline) + 1))) < 0)
    13031185                        break;
    1304                       PaintLine(hwnd, ad -> hps, x, 1, &Rectl);
     1186                      PaintLine(hwnd, ad->hps, x, 1, &Rectl);
    13051187                    }
    13061188                  }
    13071189                  p = e;
    1308                   if (p - ad -> text < ad -> textsize)
    1309                   {
     1190                  if (p - ad->text < ad->textsize) {
    13101191                    if (*p == '\r')
    13111192                      p++;
    13121193                  }
    1313                   if (p - ad -> text < ad -> textsize)
    1314                   {
     1194                  if (p - ad->text < ad->textsize) {
    13151195                    if (*p == '\n')
    13161196                      p++;
    … …  
    13181198                }
    13191199              }
    1320               if (ad -> numalloc != ad -> numlines)
    1321               {
     1200              if (ad->numalloc != ad->numlines) {
    13221201
    13231202                CHAR **temp;
    13241203
    1325                 temp = xrealloc(ad -> lines, sizeof(CHAR *) * ad -> numlines,pszSrcFile,__LINE__);
    1326                 if (temp)
    1327                 {
    1328                   ad -> lines = temp;
    1329                   ad -> numalloc = ad -> numlines;
     1204                temp =
     1205                  xrealloc(ad->lines, sizeof(CHAR *) * ad->numlines,
     1206                           pszSrcFile, __LINE__);
     1207                if (temp) {
     1208                  ad->lines = temp;
     1209                  ad->numalloc = ad->numlines;
    13301210                }
    13311211              }
    13321212            }
    1333             else
    1334             {
    1335               ad -> numlines = ad -> textsize / 16;
    1336               if (ad -> numlines * 16 < ad -> textsize)
    1337                 ad -> numlines++;
    1338             }
    1339             if (ad -> numlines)
    1340             {
    1341               ad -> markedlines = xmalloc(ad -> numlines,pszSrcFile,__LINE__);
    1342               if (ad -> markedlines)
    1343               {
    1344                 memset(ad -> markedlines, 0, ad -> numlines);
    1345                 ad -> selected = 0;
     1213            else {
     1214              ad->numlines = ad->textsize / 16;
     1215              if (ad->numlines * 16 < ad->textsize)
     1216                ad->numlines++;
     1217            }
     1218            if (ad->numlines) {
     1219              ad->markedlines = xmalloc(ad->numlines, pszSrcFile, __LINE__);
     1220              if (ad->markedlines) {
     1221                memset(ad->markedlines, 0, ad->numlines);
     1222                ad->selected = 0;
    13461223              }
    1347               if (*ftprun && !ad -> ignoreftp && strstr(ad -> text, "ftp://"))
    1348                 ad -> ftpin = TRUE;
    1349               if (*httprun && !ad -> ignorehttp && strstr(ad -> text, "http://"))
    1350                 ad -> httpin = TRUE;
    1351             }
    1352           }
    1353           DosReleaseMutexSem(ad -> ScanSem);
     1224              if (*ftprun && !ad->ignoreftp && strstr(ad->text, "ftp://"))
     1225                ad->ftpin = TRUE;
     1226              if (*httprun && !ad->ignorehttp && strstr(ad->text, "http://"))
     1227                ad->httpin = TRUE;
     1228            }
     1229          }
     1230          DosReleaseMutexSem(ad->ScanSem);
    13541231          PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
    13551232          PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
    1356           ad -> busy--;
     1233          ad->busy--;
    13571234        }
    13581235      }
    … …  
    13631240  }
    13641241  DosPostEventSem(CompactSem);
    1365   if (ad && !ad -> stopflag) {
     1242  if (ad && !ad->stopflag) {
    13661243    PostMsg(hwnd, UM_CONTAINER_FILLED, MPFROMLONG(firstline),
    13671244            MPFROMLONG(cursored));
    1368     ad -> relining = FALSE;
     1245    ad->relining = FALSE;
    13691246  }
    13701247}
    … …  
    13721249static VOID LoadFileThread(VOID * args)
    13731250{
    1374   HWND hwnd = (HWND)args;
     1251  HWND hwnd = (HWND) args;
    13751252  HAB hab2;
    13761253  HMQ hmq2;
    … …  
    13821259
    13831260  hab2 = WinInitialize(0);
    1384   if (hab2)
    1385   {
     1261  if (hab2) {
    13861262    hmq2 = WinCreateMsgQueue(hab2, 0);
    1387     if (hmq2)
    1388     {
     1263    if (hmq2) {
    13891264      WinCancelShutdown(hmq2, TRUE);
    13901265      IncrThreadUsage();
    13911266      ad = WinQueryWindowPtr(hwnd, QWL_USER);
    1392       if (ad)
    1393       {
    1394         if (!DosRequestMutexSem(ad -> ScanSem, SEM_INDEFINITE_WAIT))
    1395         {
    1396           ad -> busy++;
     1267      if (ad) {
     1268        if (!DosRequestMutexSem(ad->ScanSem, SEM_INDEFINITE_WAIT)) {
     1269          ad->busy++;
    13971270          priority_normal();
    1398           if (*ad -> filename)
    1399           {
    1400             if (ad -> text)
    1401               free(ad -> text);
    1402             if (ad -> lines)
    1403               free(ad -> lines);
    1404             if (ad -> markedlines)
    1405               free(ad -> markedlines);
    1406             ad -> text = NULL;
    1407             ad -> lines = NULL;
    1408             ad -> markedlines = NULL;
    1409             ad -> ftpin = ad -> httpin = FALSE;
    1410             ad -> selected = ad -> numlines = ad -> textsize = ad -> numalloc = 0;
    1411             WinSendDlgItemMsg(ad -> hwndFrame, NEWVIEW_LISTBOX, LM_DELETEALL,
     1271          if (*ad->filename) {
     1272            if (ad->text)
     1273              free(ad->text);
     1274            if (ad->lines)
     1275              free(ad->lines);
     1276            if (ad->markedlines)
     1277              free(ad->markedlines);
     1278            ad->text = NULL;
     1279            ad->lines = NULL;
     1280            ad->markedlines = NULL;
     1281            ad->ftpin = ad->httpin = FALSE;
     1282            ad->selected = ad->numlines = ad->textsize = ad->numalloc = 0;
     1283            WinSendDlgItemMsg(ad->hwndFrame, NEWVIEW_LISTBOX, LM_DELETEALL,
    14121284                              MPVOID, MPVOID);
    1413             PostMsg(ad -> hwndFrame, WM_UPDATEFRAME,
     1285            PostMsg(ad->hwndFrame, WM_UPDATEFRAME,
    14141286                    MPFROMLONG(FCF_SIZEBORDER), MPVOID);
    14151287            WinSetFocus(HWND_DESKTOP, hwnd);
    1416             rc = DosOpen(ad -> filename, &handle, &action, 0L, 0L,
    1417                       OPEN_ACTION_FAIL_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS,
     1288            rc = DosOpen(ad->filename, &handle, &action, 0L, 0L,
     1289                        OPEN_ACTION_FAIL_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS,
    14181290                         OPEN_FLAGS_FAIL_ON_ERROR | OPEN_FLAGS_NOINHERIT |
    14191291                         OPEN_FLAGS_SEQUENTIAL | OPEN_SHARE_DENYNONE |
    … …  
    14251297                        pszSrcFile,
    14261298                        __LINE__,
    1427                         GetPString(IDS_COMPCANTOPENTEXT),
    1428                         ad -> filename);
     1299                        GetPString(IDS_COMPCANTOPENTEXT), ad->filename);
    14291300            }
    14301301            else {
    … …  
    14351306                       hwnd,
    14361307                       GetPString(IDS_ERRORTEXT),
    1437                        GetPString(IDS_ZEROLENGTHTEXT),
    1438                        ad -> filename);
     1308                       GetPString(IDS_ZEROLENGTHTEXT), ad->filename);
    14391309              }
    14401310              else {
    1441                 ad -> text = xmalloc(len + 2,pszSrcFile,__LINE__);
    1442                 if (ad -> text)
    1443                 {
    1444                   *ad -> text = 0;
    1445                   ad -> text[len] = 0;
    1446                   rc = DosRead(handle, ad -> text, len, &ad -> textsize);
     1311                ad->text = xmalloc(len + 2, pszSrcFile, __LINE__);
     1312                if (ad->text) {
     1313                  *ad->text = 0;
     1314                  ad->text[len] = 0;
     1315                  rc = DosRead(handle, ad->text, len, &ad->textsize);
    14471316                  if (rc) {
    14481317                    Dos_Error(MB_CANCEL,
    … …  
    14511320                              pszSrcFile,
    14521321                              __LINE__,
    1453                               GetPString(IDS_ERRORREADINGTEXT),
    1454                               ad -> filename);
    1455                     free(ad -> text);
    1456                     ad -> text = NULL;
    1457                     ad -> textsize = 0;
     1322                              GetPString(IDS_ERRORREADINGTEXT), ad->filename);
     1323                    free(ad->text);
     1324                    ad->text = NULL;
     1325                    ad->textsize = 0;
    14581326                  }
    14591327                  else {
    1460                     ad -> text[ad -> textsize] = 0;
    1461                     if (!ad -> hex && !(ad -> flags & (8 | 16)) && ad -> textsize)
    1462                     {
     1328                    ad->text[ad->textsize] = 0;
     1329                    if (!ad->hex && !(ad->flags & (8 | 16)) && ad->textsize) {
    14631330                      ULONG x;
    1464                       x = min(512, ad -> textsize);
    1465                       if (fGuessType && IsBinary(ad -> text, x))
    1466                         ad -> hex = TRUE;
     1331
     1332                      x = min(512, ad->textsize);
     1333                      if (fGuessType && IsBinary(ad->text, x))
     1334                        ad->hex = TRUE;
    14671335                    }
    1468                     if (ad -> textsize) {
    1469                       if (_beginthread(ReLineThread, NULL, 524288, (PVOID) hwnd) == -1)
    1470                         Runtime_Error(pszSrcFile, __LINE__, GetPString(IDS_COULDNTSTARTTHREADTEXT));
     1336                    if (ad->textsize) {
     1337                      if (_beginthread
     1338                          (ReLineThread, NULL, 524288, (PVOID) hwnd) == -1)
     1339                        Runtime_Error(pszSrcFile, __LINE__,
     1340                                      GetPString(IDS_COULDNTSTARTTHREADTEXT));
    14711341                      else
    1472                         error = FALSE;
     1342                        error = FALSE;
    14731343                    }
    14741344                  }
    … …  
    14781348            }
    14791349          }
    1480           ad -> busy--;
    1481           DosReleaseMutexSem(ad -> ScanSem);
     1350          ad->busy--;
     1351          DosReleaseMutexSem(ad->ScanSem);
    14821352        }
    14831353      }
    … …  
    14921362}
    14931363
    1494 MRESULT EXPENTRY ViewFrameWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
     1364MRESULT EXPENTRY ViewFrameWndProc(HWND hwnd, ULONG msg, MPARAM mp1,
     1365                                  MPARAM mp2)
    14951366{
    14961367  PFNWP oldproc = (PFNWP) WinQueryWindowPtr(hwnd, QWL_USER);
    14971368
    1498   switch (msg)
    1499   {
     1369  switch (msg) {
    15001370  case WM_CHAR:
    15011371    shiftstate = (SHORT1FROMMP(mp1) & (KC_SHIFT | KC_ALT | KC_CTRL));
    … …  
    15031373
    15041374  case WM_CONTROL:
    1505     switch (SHORT1FROMMP(mp1))
    1506     {
     1375    switch (SHORT1FROMMP(mp1)) {
    15071376    case NEWVIEW_LISTBOX:
    15081377      return WinSendMsg(WinWindowFromID(hwnd, FID_CLIENT), UM_CONTROL,
    … …  
    15251394       */
    15261395
    1527       if (mr && mp2)
    1528       {
     1396      if (mr && mp2) {
    15291397        prectl = (PRECTL) mp1;
    1530         prectl -> yBottom += 22;
    1531         prectl -> yTop -= 22;
     1398        prectl->yBottom += 22;
     1399        prectl->yTop -= 22;
    15321400        sSelect = (SHORT) WinSendDlgItemMsg(hwnd, NEWVIEW_LISTBOX,
    15331401                                            LM_QUERYITEMCOUNT,
    15341402                                            MPVOID, MPVOID);
    15351403        if (sSelect > 0)
    1536           prectl -> yTop -= 48;
     1404          prectl->yTop -= 48;
    15371405      }
    15381406      return mr;
    … …  
    15421410    {
    15431411      SHORT sCount, soldCount, sSelect;
    1544       PSWP pswp, pswpClient, pswpNew1, pswpNew2, pswpNew3, pswpList, pswpScroll,
    1545           pswpNew4, pswpUp, pswpDn;
     1412      PSWP pswp, pswpClient, pswpNew1, pswpNew2, pswpNew3, pswpList,
     1413        pswpScroll, pswpNew4, pswpUp, pswpDn;
    15461414
    15471415      sCount = (SHORT) oldproc(hwnd, msg, mp1, mp2);
    … …  
    15571425        SHORT x;
    15581426
    1559         for (x = 0; x < sCount; x++)
    1560         {
    1561           if (WinQueryWindowUShort(pswp -> hwnd, QWS_ID) == FID_CLIENT)
    1562           {
     1427        for (x = 0; x < sCount; x++) {
     1428          if (WinQueryWindowUShort(pswp->hwnd, QWS_ID) == FID_CLIENT) {
    15631429            pswpClient = pswp;
    15641430            break;
    … …  
    15721438      pswpNew4 = (PSWP) mp1 + (soldCount + 3);
    15731439      *pswpNew1 = *pswpClient;
    1574       pswpNew1 -> hwnd = WinWindowFromID(hwnd, NEWVIEW_STATUS1);
    1575       pswpNew1 -> x = pswpClient -> x + 2;
    1576       pswpNew1 -> y = pswpClient -> y + 2;
    1577       pswpNew1 -> cx = (pswpClient -> cx / 3) - 3;
    1578       pswpNew1 -> cy = 20;
    1579       pswpClient -> y = pswpNew1 -> y + pswpNew1 -> cy + 3;
    1580       pswpClient -> cy = (pswpClient -> cy - pswpNew1 -> cy) - 5;
     1440      pswpNew1->hwnd = WinWindowFromID(hwnd, NEWVIEW_STATUS1);
     1441      pswpNew1->x = pswpClient->x + 2;
     1442      pswpNew1->y = pswpClient->y + 2;
     1443      pswpNew1->cx = (pswpClient->cx / 3) - 3;
     1444      pswpNew1->cy = 20;
     1445      pswpClient->y = pswpNew1->y + pswpNew1->cy + 3;
     1446      pswpClient->cy = (pswpClient->cy - pswpNew1->cy) - 5;
    15811447      *pswpNew2 = *pswpNew1;
    15821448      *pswpNew3 = *pswpNew1;
    15831449      *pswpNew4 = *pswpNew1;
    1584       pswpNew2 -> hwnd = WinWindowFromID(hwnd, NEWVIEW_STATUS2);
    1585       pswpNew3 -> hwnd = WinWindowFromID(hwnd, NEWVIEW_STATUS3);
    1586       pswpNew4 -> hwnd = WinWindowFromID(hwnd, NEWVIEW_DRAG);
    1587       pswpNew2 -> x = pswpNew1 -> x + pswpNew1 -> cx + 3;
    1588       pswpNew3 -> x = pswpNew2 -> x + pswpNew2 -> cx + 3;
    1589       pswpNew3 -> cx = ((pswpClient -> x + pswpClient -> cx) - pswpNew3 -> x) - 26;
    1590       pswpNew4 -> x = pswpNew3 -> x + pswpNew3 -> cx + 3;
    1591       pswpNew4 -> cx = 20;
     1450      pswpNew2->hwnd = WinWindowFromID(hwnd, NEWVIEW_STATUS2);
     1451      pswpNew3->hwnd = WinWindowFromID(hwnd, NEWVIEW_STATUS3);
     1452      pswpNew4->hwnd = WinWindowFromID(hwnd, NEWVIEW_DRAG);
     1453      pswpNew2->x = pswpNew1->x + pswpNew1->cx + 3;
     1454      pswpNew3->x = pswpNew2->x + pswpNew2->cx + 3;
     1455      pswpNew3->cx = ((pswpClient->x + pswpClient->cx) - pswpNew3->x) - 26;
     1456      pswpNew4->x = pswpNew3->x + pswpNew3->cx + 3;
     1457      pswpNew4->cx = 20;
    15921458      sCount += 4;
    15931459      pswpScroll = (PSWP) mp1;
    1594       while (pswpScroll < pswpClient)
    1595       {
    1596         if (WinQueryWindowUShort(pswpScroll -> hwnd, QWS_ID) == FID_VERTSCROLL)
     1460      while (pswpScroll < pswpClient) {
     1461        if (WinQueryWindowUShort(pswpScroll->hwnd, QWS_ID) == FID_VERTSCROLL)
    15971462          break;
    15981463        pswpScroll++;
    … …  
    16011466        pswpScroll = NULL;
    16021467      sSelect = (SHORT) WinSendDlgItemMsg(hwnd, NEWVIEW_LISTBOX,
    1603                                           LM_QUERYITEMCOUNT,
    1604                                           MPVOID, MPVOID);
    1605       if (sSelect > 0)
    1606       {
     1468                                          LM_QUERYITEMCOUNT, MPVOID, MPVOID);
     1469      if (sSelect > 0) {
    16071470        pswpList = (PSWP) mp1 + (soldCount + 4);
    16081471        *pswpList = *pswpClient;
    1609         pswpList -> hwnd = WinWindowFromID(hwnd, NEWVIEW_LISTBOX);
    1610         pswpList -> x = pswpClient -> x;
    1611         pswpList -> cx = pswpClient -> cx;
    1612         if (pswpScroll)
    1613         {
    1614           pswpList -> cx += pswpScroll -> cx;
    1615           pswpScroll -> cy -= 48;
    1616         }
    1617         pswpList -> y = (pswpClient -> y + pswpClient -> cy) - 48;
    1618         pswpList -> cy = 48;
    1619         pswpClient -> cy -= 48;
     1472        pswpList->hwnd = WinWindowFromID(hwnd, NEWVIEW_LISTBOX);
     1473        pswpList->x = pswpClient->x;
     1474        pswpList->cx = pswpClient->cx;
     1475        if (pswpScroll) {
     1476          pswpList->cx += pswpScroll->cx;
     1477          pswpScroll->cy -= 48;
     1478        }
     1479        pswpList->y = (pswpClient->y + pswpClient->cy) - 48;
     1480        pswpList->cy = 48;
     1481        pswpClient->cy -= 48;
    16201482        sCount++;
    16211483      }
    16221484      WinShowWindow(WinWindowFromID(hwnd, NEWVIEW_LISTBOX), (sSelect > 0));
    16231485
    1624       if (pswpScroll)
    1625       {
     1486      if (pswpScroll) {
    16261487        pswpUp = (PSWP) mp1 + (soldCount + 4 + (sSelect > 0));
    16271488        *pswpUp = *pswpClient;
    1628         pswpUp -> hwnd = WinWindowFromID(hwnd, IDM_PREVBLANKLINE);
    1629         pswpUp -> cx = pswpScroll -> cx;
    1630         pswpUp -> x = pswpScroll -> x;
    1631         pswpUp -> cy = WinQuerySysValue(HWND_DESKTOP, SV_CYVSCROLLARROW);
    1632         pswpUp -> y = (pswpScroll -> y + pswpScroll -> cy) - (pswpUp -> cy + 1);
    1633         pswpScroll -> cy -= ((pswpUp -> cy * 2) + 1);
     1489        pswpUp->hwnd = WinWindowFromID(hwnd, IDM_PREVBLANKLINE);
     1490        pswpUp->cx = pswpScroll->cx;
     1491        pswpUp->x = pswpScroll->x;
     1492        pswpUp->cy = WinQuerySysValue(HWND_DESKTOP, SV_CYVSCROLLARROW);
     1493        pswpUp->y = (pswpScroll->y + pswpScroll->cy) - (pswpUp->cy + 1);
     1494        pswpScroll->cy -= ((pswpUp->cy * 2) + 1);
    16341495        pswpDn = (PSWP) mp1 + (soldCount + 5 + (sSelect > 0));
    16351496        *pswpDn = *pswpUp;
    1636         pswpDn -> y = pswpScroll -> y;
    1637         pswpDn -> hwnd = WinWindowFromID(hwnd, IDM_NEXTBLANKLINE);
    1638         pswpScroll -> y += pswpUp -> cy;
     1497        pswpDn->y = pswpScroll->y;
     1498        pswpDn->hwnd = WinWindowFromID(hwnd, IDM_NEXTBLANKLINE);
     1499        pswpScroll->y += pswpUp->cy;
    16391500        sCount += 2;
    16401501      }
    1641       else
    1642       {
     1502      else {
    16431503        WinShowWindow(WinWindowFromID(hwnd, IDM_PREVBLANKLINE), FALSE);
    16441504        WinShowWindow(WinWindowFromID(hwnd, IDM_NEXTBLANKLINE), FALSE);
    … …  
    16541514      sCount += 6;
    16551515      sSelect = (SHORT) WinSendDlgItemMsg(hwnd, NEWVIEW_LISTBOX,
    1656                                           LM_QUERYITEMCOUNT,
    1657                                           MPVOID, MPVOID);
     1516                                          LM_QUERYITEMCOUNT, MPVOID, MPVOID);
    16581517      if (sSelect > 0)
    16591518        sCount++;
    … …  
    16681527  VIEWDATA *ad;
    16691528
    1670   switch (msg)
    1671   {
     1529  switch (msg) {
    16721530  case WM_INITDLG:
    16731531    if (!mp2)
    16741532      WinDismissDlg(hwnd, 0);
    1675     else
    1676     {
     1533    else {
    16771534
    16781535      HWND hwndClient = *(HWND *) mp2;
    … …  
    16831540      MLEsetlimit(WinWindowFromID(hwnd, NEWFIND_MLE), SEARCHSTRINGLEN);
    16841541      MLEsetformat(WinWindowFromID(hwnd, NEWFIND_MLE), MLFIE_NOTRANS);
    1685       if (*ad -> searchtext)
    1686       {
     1542      if (*ad->searchtext) {
    16871543
    16881544        IPT here = 0;
    1689         ULONG len = strlen(ad -> searchtext);
     1545        ULONG len = strlen(ad->searchtext);
    16901546
    16911547        WinSendMsg(WinWindowFromID(hwnd, NEWFIND_MLE),
    16921548                   MLM_SETIMPORTEXPORT,
    1693                    MPFROMP(ad -> searchtext),
    1694                    MPFROMLONG(SEARCHSTRINGLEN));
     1549                   MPFROMP(ad->searchtext), MPFROMLONG(SEARCHSTRINGLEN));
    16951550        WinSendMsg(WinWindowFromID(hwnd, NEWFIND_MLE),
    1696                    MLM_IMPORT,
    1697                    MPFROMP(&here),
    1698                    MPFROMLONG(len));
    1699       }
    1700       WinCheckButton(hwnd, NEWFIND_ALSOSELECT, ad -> alsoselect);
    1701       WinCheckButton(hwnd, NEWFIND_SENSITIVE, ad -> sensitive);
    1702       WinCheckButton(hwnd, NEWFIND_LITERAL, ad -> literalsearch);
     1551                   MLM_IMPORT, MPFROMP(&here), MPFROMLONG(len));
     1552      }
     1553      WinCheckButton(hwnd, NEWFIND_ALSOSELECT, ad->alsoselect);
     1554      WinCheckButton(hwnd, NEWFIND_SENSITIVE, ad->sensitive);
     1555      WinCheckButton(hwnd, NEWFIND_LITERAL, ad->literalsearch);
    17031556    }
    17041557    break;
    17051558
    17061559  case WM_COMMAND:
    1707     switch (SHORT1FROMMP(mp1))
    1708     {
     1560    switch (SHORT1FROMMP(mp1)) {
    17091561    case DID_OK:
    17101562      {
    … …  
    17181570        WinSendMsg(WinWindowFromID(hwnd, NEWFIND_MLE),
    17191571                   MLM_SETIMPORTEXPORT,
    1720                    MPFROMP(s),
    1721                    MPFROMLONG(SEARCHSTRINGLEN));
     1572                   MPFROMP(s), MPFROMLONG(SEARCHSTRINGLEN));
    17221573        len = SEARCHSTRINGLEN;
    17231574        WinSendMsg(WinWindowFromID(hwnd, NEWFIND_MLE),
    1724                    MLM_EXPORT,
    1725                    MPFROMP(&here),
    1726                    MPFROMLONG(&len));
     1575                   MLM_EXPORT, MPFROMP(&here), MPFROMLONG(&len));
    17271576        s[SEARCHSTRINGLEN - 1] = 0;
    1728         if (!*s)
    1729         {
     1577        if (!*s) {
    17301578          DosBeep(250, 100);            // Complain
    17311579          break;
    17321580        }
    1733         strcpy(ad -> searchtext, s);
    1734         ad -> sensitive = WinQueryButtonCheckstate(hwnd, NEWFIND_SENSITIVE);
    1735         if (ad -> sensitive != Sensitive)
    1736         {
    1737           Sensitive = ad -> sensitive;
     1581        strcpy(ad->searchtext, s);
     1582        ad->sensitive = WinQueryButtonCheckstate(hwnd, NEWFIND_SENSITIVE);
     1583        if (ad->sensitive != Sensitive) {
     1584          Sensitive = ad->sensitive;
    17381585          PrfWriteProfileData(fmprof,
    17391586                              appname,
    17401587                              "Viewer.Sensitive",
    1741                               &ad -> sensitive,
    1742                               sizeof(BOOL));
    1743         }
    1744         ad -> literalsearch = WinQueryButtonCheckstate(hwnd, NEWFIND_LITERAL);
    1745         if (ad -> literalsearch != LiteralSearch)
    1746         {
    1747           LiteralSearch = ad -> literalsearch;
     1588                              &ad->sensitive, sizeof(BOOL));
     1589        }
     1590        ad->literalsearch = WinQueryButtonCheckstate(hwnd, NEWFIND_LITERAL);
     1591        if (ad->literalsearch != LiteralSearch) {
     1592          LiteralSearch = ad->literalsearch;
    17481593          PrfWriteProfileData(fmprof,
    17491594                              appname,
    17501595                              "Viewer.LiteralSearch",
    1751                               &ad -> literalsearch,
    1752                               sizeof(BOOL));
    1753         }
    1754         ad -> alsoselect = WinQueryButtonCheckstate(hwnd, NEWFIND_ALSOSELECT);
    1755         if (ad -> alsoselect != AlsoSelect)
    1756         {
    1757           AlsoSelect = ad -> alsoselect;
     1596                              &ad->literalsearch, sizeof(BOOL));
     1597        }
     1598        ad->alsoselect = WinQueryButtonCheckstate(hwnd, NEWFIND_ALSOSELECT);
     1599        if (ad->alsoselect != AlsoSelect) {
     1600          AlsoSelect = ad->alsoselect;
    17581601          PrfWriteProfileData(fmprof,
    17591602                              appname,
    17601603                              "Viewer.AlsoSelect",
    1761                               &ad -> alsoselect,
    1762                               sizeof(BOOL));
     1604                              &ad->alsoselect, sizeof(BOOL));
    17631605        }
    17641606      }
    … …  
    17781620  VIEWDATA *ad = WinQueryWindowPtr(hwnd, QWL_USER);
    17791621
    1780   switch (msg)
    1781   {
     1622  switch (msg) {
    17821623  case WM_CREATE:
    17831624    {
    … …  
    17951636                                 0,
    17961637                                 hwndFrame,
    1797                                  HWND_TOP,
    1798                                  IDM_PREVBLANKLINE,
    1799                                  NULL,
    1800                                  NULL);
     1638                                 HWND_TOP, IDM_PREVBLANKLINE, NULL, NULL);
    18011639      if (!temphwnd)
    1802         Win_Error2(hwndFrame,hwnd,pszSrcFile,__LINE__,IDS_WINCREATEWINDOW);
     1640        Win_Error2(hwndFrame, hwnd, pszSrcFile, __LINE__,
     1641                   IDS_WINCREATEWINDOW);
    18031642      else {
    1804         WinSetPresParam(temphwnd,
    1805                         PP_FONTNAMESIZE,
    1806                         strlen(GetPString(IDS_8HELVTEXT)) + 1,
    1807                         (PVOID) GetPString(IDS_8HELVTEXT));
     1643        WinSetPresParam(temphwnd,
     1644                        PP_FONTNAMESIZE,
     1645                        strlen(GetPString(IDS_8HELVTEXT)) + 1,
     1646                        (PVOID) GetPString(IDS_8HELVTEXT));
    18081647      }
    18091648      temphwnd = WinCreateWindow(hwndFrame,
    … …  
    18171656                                 0,
    18181657                                 hwndFrame,
    1819                                  HWND_TOP,
    1820                                  IDM_NEXTBLANKLINE,
    1821                                  NULL,
    1822                                  NULL);
     1658                                 HWND_TOP, IDM_NEXTBLANKLINE, NULL, NULL);
    18231659      if (!temphwnd)
    1824         Win_Error2(hwndFrame,hwnd,pszSrcFile,__LINE__,IDS_WINCREATEWINDOW);
     1660        Win_Error2(hwndFrame, hwnd, pszSrcFile, __LINE__,
     1661                   IDS_WINCREATEWINDOW);
    18251662      else {
    1826         WinSetPresParam(temphwnd,
    1827                         PP_FONTNAMESIZE,
    1828                         strlen(GetPString(IDS_8HELVTEXT)) + 1,
    1829                         (PVOID)GetPString(IDS_8HELVTEXT));
    1830       }
    1831       WinStartTimer(WinQueryAnchorBlock(hwnd),
    1832                     hwnd,
    1833                     ID_TIMER5,
    1834                     1000L);
     1663        WinSetPresParam(temphwnd,
     1664                        PP_FONTNAMESIZE,
     1665                        strlen(GetPString(IDS_8HELVTEXT)) + 1,
     1666                        (PVOID) GetPString(IDS_8HELVTEXT));
     1667      }
     1668      WinStartTimer(WinQueryAnchorBlock(hwnd), hwnd, ID_TIMER5, 1000L);
    18351669    }
    18361670    break;
    … …  
    18381672  case WM_TIMER:
    18391673    if (ad &&
    1840         ad -> needrefreshing &&
    1841         !ad -> stopflag &&
    1842         !ad -> relining &&
    1843         !DosRequestMutexSem(ad -> ScanSem,
    1844                             SEM_IMMEDIATE_RETURN))
    1845     {
    1846       ad -> needrefreshing = FALSE;
    1847       DosReleaseMutexSem(ad -> ScanSem);
     1674        ad->needrefreshing &&
     1675        !ad->stopflag &&
     1676        !ad->relining &&
     1677        !DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN)) {
     1678      ad->needrefreshing = FALSE;
     1679      DosReleaseMutexSem(ad->ScanSem);
    18481680      WinInvalidateRect(hwnd, NULL, TRUE);
    18491681    }
    … …  
    18561688      CHAR s[CCHMAXPATH + 8];
    18571689      APIRET rc;
    1858       ad -> hwndMenu = WinWindowFromID(ad -> hwndFrame, FID_MENU);
    1859       ad -> hvscroll = WinWindowFromID(ad -> hwndFrame, FID_VERTSCROLL);
    1860       ad -> hhscroll = WinWindowFromID(ad -> hwndFrame, FID_HORZSCROLL);
    1861       WinSendMsg(ad -> hhscroll,SBM_SETTHUMBSIZE,MPFROM2SHORT(1, 1),MPVOID);
    1862       WinSendMsg(ad -> hvscroll,SBM_SETTHUMBSIZE,MPFROM2SHORT(1, 1),MPVOID);
    1863       sprintf(s,"%s: %s",FM2Str,ad -> filename);
    1864       WinSetWindowText(ad -> hwndFrame,s);
    1865       rc = DosCreateMutexSem(NULL, &ad -> ScanSem, 0L, FALSE);
     1690
     1691      ad->hwndMenu = WinWindowFromID(ad->hwndFrame, FID_MENU);
     1692      ad->hvscroll = WinWindowFromID(ad->hwndFrame, FID_VERTSCROLL);
     1693      ad->hhscroll = WinWindowFromID(ad->hwndFrame, FID_HORZSCROLL);
     1694      WinSendMsg(ad->hhscroll, SBM_SETTHUMBSIZE, MPFROM2SHORT(1, 1), MPVOID);
     1695      WinSendMsg(ad->hvscroll, SBM_SETTHUMBSIZE, MPFROM2SHORT(1, 1), MPVOID);
     1696      sprintf(s, "%s: %s", FM2Str, ad->filename);
     1697      WinSetWindowText(ad->hwndFrame, s);
     1698      rc = DosCreateMutexSem(NULL, &ad->ScanSem, 0L, FALSE);
    18661699      if (rc)
    1867         Dos_Error(MB_CANCEL,rc,hwnd,pszSrcFile,__LINE__,"DosCreateMutexSem");
     1700        Dos_Error(MB_CANCEL, rc, hwnd, pszSrcFile, __LINE__,
     1701                  "DosCreateMutexSem");
    18681702      else {
    18691703        PFNWP oldproc;
    1870         HWND hwndFrame = ad -> hwndFrame;
    1871         WinSendMsg(ad -> hvscroll,
    1872                    SBM_SETSCROLLBAR,
    1873                    MPFROMSHORT(1),
     1704        HWND hwndFrame = ad->hwndFrame;
     1705
     1706        WinSendMsg(ad->hvscroll,
     1707                   SBM_SETSCROLLBAR, MPFROMSHORT(1), MPFROM2SHORT(1, 1));
     1708        WinSendMsg(ad->hhscroll, SBM_SETSCROLLBAR, MPFROMSHORT(1),
    18741709                   MPFROM2SHORT(1, 1));
    1875         WinSendMsg(ad -> hhscroll, SBM_SETSCROLLBAR, MPFROMSHORT(1),
    1876                    MPFROM2SHORT(1, 1));
    1877         ad -> hwndStatus1 = WinCreateWindow(hwndFrame,
    1878                                             GetPString(IDS_WCVIEWSTATUS),
    1879                                             GetPString(IDS_LOADINGTEXT),
    1880                                             WS_VISIBLE | SS_TEXT |
    1881                                             DT_LEFT | DT_VCENTER,
    1882                                             0,
    1883                                             0,
    1884                                             0,
    1885                                             0,
    1886                                             hwndFrame,
    1887                                             HWND_TOP,
    1888                                             NEWVIEW_STATUS1,
    1889                                             NULL,
    1890                                             NULL);
    1891         if (!ad -> hwndStatus1)
    1892           Win_Error2(hwndFrame,hwnd,pszSrcFile,__LINE__,IDS_WINCREATEWINDOW);
    1893 
    1894         ad -> hwndStatus2 = WinCreateWindow(hwndFrame,
    1895                                             GetPString(IDS_WCVIEWSTATUS),
    1896                                             NULL,
    1897                                             WS_VISIBLE | SS_TEXT |
    1898                                             DT_LEFT | DT_VCENTER,
    1899                                             0,
    1900                                             0,
    1901                                             0,
    1902                                             0,
    1903                                             hwndFrame,
    1904                                             HWND_TOP,
    1905                                             NEWVIEW_STATUS2,
    1906                                             NULL,
    1907                                             NULL);
    1908         if (!ad -> hwndStatus2)
    1909           Win_Error2(hwndFrame,hwnd,pszSrcFile,__LINE__,IDS_WINCREATEWINDOW);
    1910 
    1911         ad -> hwndStatus3 = WinCreateWindow(hwndFrame,
    1912                                             GetPString(IDS_WCVIEWSTATUS),
    1913                                             NULL,
    1914                                             WS_VISIBLE | SS_TEXT |
    1915                                             DT_LEFT | DT_VCENTER,
    1916                                             0,
    1917                                             0,
    1918                                             0,
    1919                                             0,
    1920                                             hwndFrame,
    1921                                             HWND_TOP,
    1922                                             NEWVIEW_STATUS3,
    1923                                             NULL,
    1924                                             NULL);
    1925         if (!ad -> hwndStatus3)
    1926           Win_Error2(hwndFrame,hwnd,pszSrcFile,__LINE__,IDS_WINCREATEWINDOW);
    1927 
    1928         ad -> hwndListbox = WinCreateWindow(hwndFrame,
    1929                                             WC_LISTBOX,
    1930                                             NULL,
    1931                                             LS_NOADJUSTPOS,
    1932                                             0,
    1933                                             0,
    1934                                             0,
    1935                                             0,
    1936                                             hwndFrame,
    1937                                             HWND_TOP,
    1938                                             NEWVIEW_LISTBOX,
    1939                                             NULL,
    1940                                             NULL);
    1941         if (!ad -> hwndListbox)
    1942           Win_Error2(hwndFrame,hwnd,pszSrcFile,__LINE__,IDS_WINCREATEWINDOW);
    1943 
    1944         ad -> hwndDrag = WinCreateWindow(hwndFrame,
    1945                                          GetPString(IDS_WCVIEWSTATUS),
    1946                                          "#100",
    1947                                          WS_VISIBLE | SS_BITMAP,
    1948                                          0,
    1949                                          0,
    1950                                          0,
    1951                                          0,
    1952                                          hwndFrame,
    1953                                          HWND_TOP,
    1954                                          NEWVIEW_DRAG,
    1955                                          NULL,
    1956                                          NULL);
    1957         if (!ad -> hwndDrag)
    1958           Win_Error2(hwndFrame,hwnd,pszSrcFile,__LINE__,IDS_WINCREATEWINDOW);
     1710        ad->hwndStatus1 = WinCreateWindow(hwndFrame,
     1711                                          GetPString(IDS_WCVIEWSTATUS),
     1712                                          GetPString(IDS_LOADINGTEXT),
     1713                                          WS_VISIBLE | SS_TEXT |
     1714                                          DT_LEFT | DT_VCENTER,
     1715                                          0,
     1716                                          0,
     1717                                          0,
     1718                                          0,
     1719                                          hwndFrame,
     1720                                          HWND_TOP,
     1721                                          NEWVIEW_STATUS1, NULL, NULL);
     1722        if (!ad->hwndStatus1)
     1723          Win_Error2(hwndFrame, hwnd, pszSrcFile, __LINE__,
     1724                     IDS_WINCREATEWINDOW);
     1725
     1726        ad->hwndStatus2 = WinCreateWindow(hwndFrame,
     1727                                          GetPString(IDS_WCVIEWSTATUS),
     1728                                          NULL,
     1729                                          WS_VISIBLE | SS_TEXT |
     1730                                          DT_LEFT | DT_VCENTER,
     1731                                          0,
     1732                                          0,
     1733                                          0,
     1734                                          0,
     1735                                          hwndFrame,
     1736                                          HWND_TOP,
     1737                                          NEWVIEW_STATUS2, NULL, NULL);
     1738        if (!ad->hwndStatus2)
     1739          Win_Error2(hwndFrame, hwnd, pszSrcFile, __LINE__,
     1740                     IDS_WINCREATEWINDOW);
     1741
     1742        ad->hwndStatus3 = WinCreateWindow(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                                          hwndFrame,
     1752                                          HWND_TOP,
     1753                                          NEWVIEW_STATUS3, NULL, NULL);
     1754        if (!ad->hwndStatus3)
     1755          Win_Error2(hwndFrame, hwnd, pszSrcFile, __LINE__,
     1756                     IDS_WINCREATEWINDOW);
     1757
     1758        ad->hwndListbox = WinCreateWindow(hwndFrame,
     1759                                          WC_LISTBOX,
     1760                                          NULL,
     1761                                          LS_NOADJUSTPOS,
     1762                                          0,
     1763                                          0,
     1764                                          0,
     1765                                          0,
     1766                                          hwndFrame,
     1767                                          HWND_TOP,
     1768                                          NEWVIEW_LISTBOX, NULL, NULL);
     1769        if (!ad->hwndListbox)
     1770          Win_Error2(hwndFrame, hwnd, pszSrcFile, __LINE__,
     1771                     IDS_WINCREATEWINDOW);
     1772
     1773        ad->hwndDrag = WinCreateWindow(hwndFrame,
     1774                                       GetPString(IDS_WCVIEWSTATUS),
     1775                                       "#100",
     1776                                       WS_VISIBLE | SS_BITMAP,
     1777                                       0,
     1778                                       0,
     1779                                       0,
     1780                                       0,
     1781                                       hwndFrame,
     1782                                       HWND_TOP, NEWVIEW_DRAG, NULL, NULL);
     1783        if (!ad->hwndDrag)
     1784          Win_Error2(hwndFrame, hwnd, pszSrcFile, __LINE__,
     1785                     IDS_WINCREATEWINDOW);
    19591786
    19601787        oldproc = WinSubclassWindow(hwndFrame, ViewFrameWndProc);
    1961         WinSetWindowPtr(hwndFrame, QWL_USER, (PVOID)oldproc);
    1962         ad -> hps = InitWindow(hwnd);
     1788        WinSetWindowPtr(hwndFrame, QWL_USER, (PVOID) oldproc);
     1789        ad->hps = InitWindow(hwnd);
    19631790        if (_beginthread(LoadFileThread, NULL, 524288, (PVOID) hwnd) == -1)
    1964           Runtime_Error(pszSrcFile, __LINE__, GetPString(IDS_COULDNTSTARTTHREADTEXT));
     1791          Runtime_Error(pszSrcFile, __LINE__,
     1792                        GetPString(IDS_COULDNTSTARTTHREADTEXT));
    19651793        else {
    19661794          WinSendMsg(hwnd, UM_SETUP5, MPVOID, MPVOID);
    19671795          DosSleep(32L);
    1968           return (MRESULT)1;
     1796          return (MRESULT) 1;
    19691797        }
    19701798      }
    … …  
    19751803
    19761804  case UM_SETUP5:
    1977     if (ad)
    1978     {
    1979       if (ad -> hwndFrame ==
    1980           WinQueryActiveWindow(WinQueryWindow(ad -> hwndFrame,
     1805    if (ad) {
     1806      if (ad->hwndFrame ==
     1807          WinQueryActiveWindow(WinQueryWindow(ad->hwndFrame,
    19811808                                              QW_PARENT)) &&
    1982           !ParentIsDesktop(ad -> hwndFrame, (HWND)0))
    1983       {
     1809          !ParentIsDesktop(ad->hwndFrame, (HWND) 0)) {
    19841810        if (hwndStatus2)
    19851811          WinSetWindowText(hwndStatus2,
    1986                            (*ad -> filename) ?
    1987                            ad -> filename :
    1988                            GetPString(IDS_UNTITLEDTEXT));
    1989         if (fMoreButtons)
    1990         {
     1812                           (*ad->filename) ?
     1813                           ad->filename : GetPString(IDS_UNTITLEDTEXT));
     1814        if (fMoreButtons) {
    19911815          WinSetWindowText(hwndName,
    1992                            (*ad -> filename) ?
    1993                            ad -> filename :
    1994                            GetPString(IDS_UNTITLEDTEXT));
     1816                           (*ad->filename) ?
     1817                           ad->filename : GetPString(IDS_UNTITLEDTEXT));
    19951818          WinSetWindowText(hwndDate, NullStr);
    19961819          WinSetWindowText(hwndAttr, NullStr);
    … …  
    20081831
    20091832  case UM_RESCAN:
    2010     if (ad)
    2011     {
    2012       if (!ad -> busy &&
    2013           !DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN))
    2014       {
    2015         if (ad -> numlines)
    2016         {
     1833    if (ad) {
     1834      if (!ad->busy && !DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN)) {
     1835        if (ad->numlines) {
    20171836
    20181837          CHAR s[80], tb[34], tl[34];
    20191838
    2020           commafmt(tb, sizeof(tb), ad -> textsize);
    2021           commafmt(tl, sizeof(tl), ad -> numlines);
     1839          commafmt(tb, sizeof(tb), ad->textsize);
     1840          commafmt(tl, sizeof(tl), ad->numlines);
    20221841          sprintf(s,
    20231842                  " %s %s%s  %s %s%s",
    20241843                  tb,
    20251844                  GetPString(IDS_BYTETEXT),
    2026                   &"s"[ad -> textsize == 1],
    2027                   tl,
    2028                   GetPString(IDS_LINETEXT),
    2029                   &"s"[ad -> numlines == 1]);
    2030           WinSetWindowText(ad -> hwndStatus1, s);
     1845                  &"s"[ad->textsize == 1],
     1846                  tl, GetPString(IDS_LINETEXT), &"s"[ad->numlines == 1]);
     1847          WinSetWindowText(ad->hwndStatus1, s);
    20311848        }
    20321849        else
    2033           WinSetWindowText(ad -> hwndStatus1,
    2034                            GetPString(IDS_NVNOLINESTEXT));
    2035         DosReleaseMutexSem(ad -> ScanSem);
     1850          WinSetWindowText(ad->hwndStatus1, GetPString(IDS_NVNOLINESTEXT));
     1851        DosReleaseMutexSem(ad->ScanSem);
    20361852      }
    20371853      else
    2038         WinSetWindowText(ad -> hwndStatus1,
    2039                          GetPString(IDS_WORKINGTEXT));
     1854        WinSetWindowText(ad->hwndStatus1, GetPString(IDS_WORKINGTEXT));
    20401855    }
    20411856    return 0;
    … …  
    20461861     * oldwidth != newwidth, set ad->oldwidth for later comparison
    20471862     */
    2048     if (ad)
    2049     {
     1863    if (ad) {
    20501864
    20511865      BOOL invalidate = FALSE;
    20521866
    2053       if (!ad -> wrapon && !ad -> hex)
    2054       {
    2055         if (WinQueryWindow(ad -> hhscroll, QW_PARENT) == ad -> hwndFrame)
    2056         {
     1867      if (!ad->wrapon && !ad->hex) {
     1868        if (WinQueryWindow(ad->hhscroll, QW_PARENT) == ad->hwndFrame) {
    20571869          invalidate = TRUE;
    2058           WinSetOwner(ad -> hhscroll, HWND_OBJECT);
    2059           WinSetParent(ad -> hhscroll, HWND_OBJECT, TRUE);
    2060           ad -> maxx = 0;
    2061           ad -> horzscroll = 0;
    2062         }
    2063       }
    2064       else
    2065       {
    2066         if (WinQueryWindow(ad -> hhscroll, QW_PARENT) != ad -> hwndFrame)
    2067         {
     1870          WinSetOwner(ad->hhscroll, HWND_OBJECT);
     1871          WinSetParent(ad->hhscroll, HWND_OBJECT, TRUE);
     1872          ad->maxx = 0;
     1873          ad->horzscroll = 0;
     1874        }
     1875      }
     1876      else {
     1877        if (WinQueryWindow(ad->hhscroll, QW_PARENT) != ad->hwndFrame) {
    20681878          invalidate = TRUE;
    2069           WinSetOwner(ad -> hhscroll, ad -> hwndFrame);
    2070           WinSetParent(ad -> hhscroll, ad -> hwndFrame, TRUE);
    2071         }
    2072       }
    2073       if (invalidate)
    2074       {
    2075         WinSendMsg(ad -> hwndFrame, WM_UPDATEFRAME, MPFROMLONG(FCF_SIZEBORDER),
     1879          WinSetOwner(ad->hhscroll, ad->hwndFrame);
     1880          WinSetParent(ad->hhscroll, ad->hwndFrame, TRUE);
     1881        }
     1882      }
     1883      if (invalidate) {
     1884        WinSendMsg(ad->hwndFrame, WM_UPDATEFRAME, MPFROMLONG(FCF_SIZEBORDER),
    20761885                   MPVOID);
    20771886        WinInvalidateRect(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
    20781887                                          NEWVIEW_DRAG), NULL, FALSE);
    2079         WinInvalidateRect(ad -> hhscroll, NULL, FALSE);
    2080       }
    2081     }
    2082 
    2083     if (ad && !ad -> busy &&
    2084         !DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN))
    2085     {
     1888        WinInvalidateRect(ad->hhscroll, NULL, FALSE);
     1889      }
     1890    }
     1891
     1892    if (ad && !ad->busy &&
     1893        !DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN)) {
    20861894
    20871895      RECTL rcl;
    … …  
    20891897
    20901898      WinQueryWindowRect(hwnd, &rcl);
    2091       newwidth = (rcl.xRight - rcl.xLeft) / ad -> fattrs.lAveCharWidth;
    2092       if ((!ad -> hex || ad -> oldwidth == -1) &&
    2093           newwidth != ad -> oldwidth && ad -> text && ad -> textsize)
    2094       {
    2095         ad -> oldwidth = newwidth;
    2096         if (!ad -> relining)
    2097         {
    2098           if (_beginthread(ReLineThread, NULL, 524288, (PVOID) hwnd) == -1)
    2099           {
    2100             Runtime_Error(pszSrcFile, __LINE__, GetPString(IDS_COULDNTSTARTTHREADTEXT));
    2101             DosReleaseMutexSem(ad -> ScanSem);
     1899      newwidth = (rcl.xRight - rcl.xLeft) / ad->fattrs.lAveCharWidth;
     1900      if ((!ad->hex || ad->oldwidth == -1) &&
     1901          newwidth != ad->oldwidth && ad->text && ad->textsize) {
     1902        ad->oldwidth = newwidth;
     1903        if (!ad->relining) {
     1904          if (_beginthread(ReLineThread, NULL, 524288, (PVOID) hwnd) == -1) {
     1905            Runtime_Error(pszSrcFile, __LINE__,
     1906                          GetPString(IDS_COULDNTSTARTTHREADTEXT));
     1907            DosReleaseMutexSem(ad->ScanSem);
    21021908            WinDestroyWindow(WinQueryWindow(hwnd, QW_PARENT));
    21031909            return 0;
    … …  
    21051911        }
    21061912      }
    2107       ad -> oldwidth = newwidth;
    2108       DosReleaseMutexSem(ad -> ScanSem);
     1913      ad->oldwidth = newwidth;
     1914      DosReleaseMutexSem(ad->ScanSem);
    21091915    }
    21101916    return MRFROMLONG(TRUE);
    … …  
    21121918  case WM_CHAR:
    21131919    shiftstate = (SHORT1FROMMP(mp1) & (KC_SHIFT | KC_ALT | KC_CTRL));
    2114     if (ad && !ad -> busy && !(SHORT1FROMMP(mp1) & KC_KEYUP) &&
    2115         !DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN))
    2116     {
    2117 
    2118       ULONG numlines, wascursored = ad -> cursored;
     1920    if (ad && !ad->busy && !(SHORT1FROMMP(mp1) & KC_KEYUP) &&
     1921        !DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN)) {
     1922
     1923      ULONG numlines, wascursored = ad->cursored;
    21191924      RECTL rcl;
    21201925
    21211926      WinQueryWindowRect(hwnd, &rcl);
    21221927      numlines = NumLines(&rcl, ad);
    2123       if (numlines)
    2124       {
    2125         if (SHORT1FROMMP(mp1) & KC_VIRTUALKEY)
    2126         {
    2127           switch (SHORT2FROMMP(mp2))
    2128           {
     1928      if (numlines) {
     1929        if (SHORT1FROMMP(mp1) & KC_VIRTUALKEY) {
     1930          switch (SHORT2FROMMP(mp2)) {
    21291931          case VK_LEFT:
    21301932            WinSendMsg(hwnd, WM_HSCROLL, MPFROM2SHORT(FID_HORZSCROLL, 0),
    … …  
    21441946            break;
    21451947          case VK_UP:
    2146             if (ad -> cursored > 1)
    2147             {
     1948            if (ad->cursored > 1) {
    21481949              if (shiftstate & KC_SHIFT)
    21491950                WinSendMsg(hwnd, WM_BUTTON1CLICK,
    2150                            MPFROM2SHORT(ad -> fattrs.lAveCharWidth + 2,
    2151                                         ((rcl.yTop - (ad -> lMaxHeight *
    2152                                       ((ad -> cursored) - ad -> topline))) -
    2153                                          ad -> lMaxDescender) - 1),
     1951                           MPFROM2SHORT(ad->fattrs.lAveCharWidth + 2,
     1952                                        ((rcl.yTop - (ad->lMaxHeight *
     1953                                                      ((ad->cursored) -
     1954                                                       ad->topline))) -
     1955                                         ad->lMaxDescender) - 1),
    21541956                           MPFROM2SHORT(TRUE, 0));
    2155               ad -> cursored--;
    2156               if (ad -> cursored < ad -> topline)
    2157               {
    2158                 PaintLine(hwnd, ad -> hps, ad -> cursored, ad -> topline, &rcl);
     1957              ad->cursored--;
     1958              if (ad->cursored < ad->topline) {
     1959                PaintLine(hwnd, ad->hps, ad->cursored, ad->topline, &rcl);
    21591960                WinSendMsg(hwnd, WM_VSCROLL, MPFROM2SHORT(FID_VERTSCROLL, 0),
    21601961                           MPFROM2SHORT(0, SB_LINEUP));
    21611962              }
    2162               else
    2163               {
    2164                 PaintLine(hwnd, ad -> hps, ad -> cursored - 1, ad -> topline, &rcl);
    2165                 PaintLine(hwnd, ad -> hps, ad -> cursored, ad -> topline, &rcl);
     1963              else {
     1964                PaintLine(hwnd, ad->hps, ad->cursored - 1, ad->topline, &rcl);
     1965                PaintLine(hwnd, ad->hps, ad->cursored, ad->topline, &rcl);
    21661966                PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
    21671967              }
    … …  
    21691969            break;
    21701970          case VK_DOWN:
    2171             if (ad -> cursored < ad -> numlines &&
    2172                 ad -> cursored < ad -> topline + numlines)
    2173             {
     1971            if (ad->cursored < ad->numlines &&
     1972                ad->cursored < ad->topline + numlines) {
    21741973              if (shiftstate & KC_SHIFT)
    21751974                WinSendMsg(hwnd, WM_BUTTON1CLICK,
    2176                            MPFROM2SHORT(ad -> fattrs.lAveCharWidth + 2,
    2177                                         ((rcl.yTop - (ad -> lMaxHeight *
    2178                                       ((ad -> cursored) - ad -> topline))) -
    2179                                          ad -> lMaxDescender) - 1),
     1975                           MPFROM2SHORT(ad->fattrs.lAveCharWidth + 2,
     1976                                        ((rcl.yTop - (ad->lMaxHeight *
     1977                                                      ((ad->cursored) -
     1978                                                       ad->topline))) -
     1979                                         ad->lMaxDescender) - 1),
    21801980                           MPFROM2SHORT(TRUE, 0));
    2181               ad -> cursored++;
    2182               if (ad -> cursored >= ad -> topline + numlines)
    2183               {
    2184                 PaintLine(hwnd, ad -> hps, ad -> cursored - 2, ad -> topline, &rcl);
     1981              ad->cursored++;
     1982              if (ad->cursored >= ad->topline + numlines) {
     1983                PaintLine(hwnd, ad->hps, ad->cursored - 2, ad->topline, &rcl);
    21851984                WinSendMsg(hwnd, WM_VSCROLL, MPFROM2SHORT(FID_VERTSCROLL, 0),
    21861985                           MPFROM2SHORT(0, SB_LINEDOWN));
    21871986              }
    2188               else
    2189               {
    2190                 PaintLine(hwnd, ad -> hps, ad -> cursored - 1, ad -> topline, &rcl);
    2191                 PaintLine(hwnd, ad -> hps, ad -> cursored - 2, ad -> topline, &rcl);
     1987              else {
     1988                PaintLine(hwnd, ad->hps, ad->cursored - 1, ad->topline, &rcl);
     1989                PaintLine(hwnd, ad->hps, ad->cursored - 2, ad->topline, &rcl);
    21921990                PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
    21931991              }
    … …  
    21961994          case VK_END:
    21971995            if ((shiftstate & KC_CTRL) ||
    2198                 ad -> cursored == (ad -> topline - 1) + numlines)
    2199             {
    2200               ad -> cursored = ad -> numlines;
    2201               ad -> topline = (ad -> numlines + 1) - numlines;
    2202               if (ad -> topline > ad -> numlines)
    2203                 ad -> topline = 1;
     1996                ad->cursored == (ad->topline - 1) + numlines) {
     1997              ad->cursored = ad->numlines;
     1998              ad->topline = (ad->numlines + 1) - numlines;
     1999              if (ad->topline > ad->numlines)
     2000                ad->topline = 1;
    22042001              WinInvalidateRect(hwnd, NULL, FALSE);
    22052002            }
    2206             else
    2207             {
    2208               ad -> cursored = (ad -> topline - 1) + numlines;
    2209               if (ad -> cursored > ad -> numlines)
    2210                 ad -> cursored = ad -> numlines;
    2211               PaintLine(hwnd, ad -> hps, ad -> cursored - 1, ad -> topline, &rcl);
    2212               PaintLine(hwnd, ad -> hps, wascursored - 1, ad -> topline, &rcl);
     2003            else {
     2004              ad->cursored = (ad->topline - 1) + numlines;
     2005              if (ad->cursored > ad->numlines)
     2006                ad->cursored = ad->numlines;
     2007              PaintLine(hwnd, ad->hps, ad->cursored - 1, ad->topline, &rcl);
     2008              PaintLine(hwnd, ad->hps, wascursored - 1, ad->topline, &rcl);
    22132009              PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
    22142010            }
    … …  
    22162012            break;
    22172013          case VK_HOME:
    2218             if ((shiftstate & KC_CTRL) ||
    2219                 ad -> cursored == ad -> topline)
    2220             {
    2221               ad -> topline = 1;
    2222               ad -> cursored = 1;
     2014            if ((shiftstate & KC_CTRL) || ad->cursored == ad->topline) {
     2015              ad->topline = 1;
     2016              ad->cursored = 1;
    22232017              WinInvalidateRect(hwnd, NULL, FALSE);
    22242018            }
    2225             else
    2226             {
    2227               ad -> cursored = ad -> topline;
    2228               PaintLine(hwnd, ad -> hps, ad -> cursored - 1, ad -> topline, &rcl);
    2229               PaintLine(hwnd, ad -> hps, wascursored - 1, ad -> topline, &rcl);
     2019            else {
     2020              ad->cursored = ad->topline;
     2021              PaintLine(hwnd, ad->hps, ad->cursored - 1, ad->topline, &rcl);
     2022              PaintLine(hwnd, ad->hps, wascursored - 1, ad->topline, &rcl);
    22302023              PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
    22312024            }
    … …  
    22342027          case VK_SPACE:
    22352028            WinSendMsg(hwnd, WM_BUTTON1CLICK,
    2236                        MPFROM2SHORT(ad -> fattrs.lAveCharWidth + 2,
    2237                                     ((rcl.yTop - (ad -> lMaxHeight *
    2238                                       ((ad -> cursored) - ad -> topline))) -
    2239                                      ad -> lMaxDescender) - 1),
     2029                       MPFROM2SHORT(ad->fattrs.lAveCharWidth + 2,
     2030                                    ((rcl.yTop - (ad->lMaxHeight *
     2031                                                  ((ad->cursored) -
     2032                                                   ad->topline))) -
     2033                                     ad->lMaxDescender) - 1),
    22402034                       MPFROM2SHORT(TRUE, 0));
    22412035            break;
    … …  
    22432037          case VK_ENTER:
    22442038            WinSendMsg(hwnd, WM_BUTTON1DBLCLK,
    2245                        MPFROM2SHORT(ad -> fattrs.lAveCharWidth + 2,
    2246                                     ((rcl.yTop - (ad -> lMaxHeight *
    2247                                       ((ad -> cursored) - ad -> topline))) -
    2248                                      ad -> lMaxDescender) - 1),
    2249                        MPFROM2SHORT(0, 0));
     2039                       MPFROM2SHORT(ad->fattrs.lAveCharWidth + 2,
     2040                                    ((rcl.yTop - (ad->lMaxHeight *
     2041                                                  ((ad->cursored) -
     2042                                                   ad->topline))) -
     2043                                     ad->lMaxDescender) - 1), MPFROM2SHORT(0,
     2044                                                                           0));
    22502045            break;
    22512046          }
    22522047        }
    2253         else if (SHORT1FROMMP(mp1) & KC_CHAR)
    2254         {
    2255           switch (SHORT1FROMMP(mp2))
    2256           {
     2048        else if (SHORT1FROMMP(mp1) & KC_CHAR) {
     2049          switch (SHORT1FROMMP(mp2)) {
    22572050          case '\r':
    22582051          case '\n':
    22592052            WinSendMsg(hwnd, WM_BUTTON1DBLCLK,
    2260                        MPFROM2SHORT(ad -> fattrs.lAveCharWidth + 2,
    2261                                     (rcl.yTop - (ad -> lMaxHeight *
    2262                                   ((ad -> cursored) - ad -> topline))) - 1),
     2053                       MPFROM2SHORT(ad->fattrs.lAveCharWidth + 2,
     2054                                    (rcl.yTop - (ad->lMaxHeight *
     2055                                                 ((ad->cursored) -
     2056                                                  ad->topline))) - 1),
    22632057                       MPFROM2SHORT(0, 0));
    22642058            break;
    … …  
    22672061          }
    22682062        }
    2269         if (wascursored != ad -> cursored)
     2063        if (wascursored != ad->cursored)
    22702064          PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
    22712065      }
    2272       DosReleaseMutexSem(ad -> ScanSem);
     2066      DosReleaseMutexSem(ad->ScanSem);
    22732067    }
    22742068    break;
    … …  
    22762070  case WM_BUTTON1MOTIONSTART:
    22772071    WinSetFocus(HWND_DESKTOP, hwnd);
    2278     if (ad && !ad -> stopflag && !ad -> busy &&
    2279         !DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN))
    2280     {
    2281       ad -> mousecaptured = TRUE;
    2282       ad -> lastselected = ULONG_MAX;
    2283       ad -> lastdirection = 0;
     2072    if (ad && !ad->stopflag && !ad->busy &&
     2073        !DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN)) {
     2074      ad->mousecaptured = TRUE;
     2075      ad->lastselected = ULONG_MAX;
     2076      ad->lastdirection = 0;
    22842077      WinSetCapture(HWND_DESKTOP, hwnd);
    22852078      WinSendMsg(hwnd, WM_BUTTON1CLICK, mp1, MPFROM2SHORT(TRUE, 0));
    … …  
    22892082  case WM_MOUSEMOVE:
    22902083    shiftstate = (SHORT2FROMMP(mp2) & (KC_SHIFT | KC_ALT | KC_CTRL));
    2291     if (ad && ad -> mousecaptured)
    2292     {
     2084    if (ad && ad->mousecaptured) {
    22932085
    22942086      ULONG numlines, whichline, x;
    … …  
    23002092      WinQueryWindowRect(hwnd, &Rectl);
    23012093      numlines = NumLines(&Rectl, ad);
    2302       if (numlines)
    2303       {
     2094      if (numlines) {
    23042095        pts.x = SHORT1FROMMP(mp1);
    23052096        pts.y = SHORT2FROMMP(mp1);
    2306         if (pts.y < 0)
    2307         {
     2097        if (pts.y < 0) {
    23082098          WinSendMsg(hwnd, WM_VSCROLL, MPFROM2SHORT(FID_VERTSCROLL, 0),
    23092099                     MPFROM2SHORT(0, SB_LINEDOWN));
    … …  
    23112101          outofwindow = TRUE;
    23122102        }
    2313         else if (pts.y > Rectl.yTop - Rectl.yBottom)
    2314         {
     2103        else if (pts.y > Rectl.yTop - Rectl.yBottom) {
    23152104          WinSendMsg(hwnd, WM_VSCROLL, MPFROM2SHORT(FID_VERTSCROLL, 0),
    23162105                     MPFROM2SHORT(0, SB_LINEUP));
    … …  
    23192108        }
    23202109        whichline = ((Rectl.yTop - Rectl.yBottom) -
    2321                      ((LONG) pts.y + ad -> lMaxDescender)) /
    2322           ad -> lMaxHeight;
     2110                     ((LONG) pts.y + ad->lMaxDescender)) / ad->lMaxHeight;
    23232111        if (whichline > numlines - 1)
    23242112          whichline = numlines - 1;
    2325         whichline += (ad -> topline - 1);
    2326         if (whichline < ad -> numlines && ad -> lastselected != whichline)
    2327         {
    2328           if (ad -> lastselected != ULONG_MAX)
    2329           {
    2330             inc = (ad -> lastselected < whichline) ? 1 : -1;
    2331             for (x = ad -> lastselected + inc;
    2332                  x != whichline && x < ad -> numlines;
    2333                  (ad -> lastselected < whichline) ? x++ : x--)
    2334             {
    2335               if (ad -> markedlines)
    2336               {
    2337                 if (ad -> markedlines[x] & VF_SELECTED)
    2338                 {
    2339                   ad -> markedlines[x] &= (~VF_SELECTED);
    2340                   ad -> selected--;
     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--;
    23412124                }
    2342                 else
    2343                 {
    2344                   ad -> markedlines[x] |= VF_SELECTED;
    2345                   ad -> selected++;
     2125                else {
     2126                  ad->markedlines[x] |= VF_SELECTED;
     2127                  ad->selected++;
    23462128                }
    23472129              }
    2348               PaintLine(hwnd, ad -> hps, x, ad -> topline, &Rectl);
     2130              PaintLine(hwnd, ad->hps, x, ad->topline, &Rectl);
    23492131            }
    23502132            WinSendMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
    … …  
    23542136        }
    23552137      }
    2356       if (outofwindow)
    2357       {
     2138      if (outofwindow) {
    23582139
    23592140        POINTL ptl;
    … …  
    23632144        if ((SHORT) ptl.y == (SHORT) SHORT2FROMMP(mp1) &&
    23642145            (SHORT) ptl.x == (SHORT) SHORT1FROMMP(mp1) &&
    2365             ((SHORT) ptl.y < 0 || ptl.y > (Rectl.yTop - Rectl.yBottom)))
    2366         {
     2146            ((SHORT) ptl.y < 0 || ptl.y > (Rectl.yTop - Rectl.yBottom))) {
    23672147          PostMsg(hwnd, UM_MOUSEMOVE, mp1, MPVOID);
    23682148          DosSleep(1L);
    … …  
    23732153
    23742154  case UM_MOUSEMOVE:
    2375     if (ad && ad -> mousecaptured)
    2376     {
     2155    if (ad && ad->mousecaptured) {
    23772156
    23782157      POINTL ptl;
    … …  
    23842163      if ((SHORT) ptl.y == (SHORT) SHORT2FROMMP(mp1) &&
    23852164          (SHORT) ptl.x == (SHORT) SHORT1FROMMP(mp1) &&
    2386           ((SHORT) ptl.y < 0 || ptl.y > (Rectl.yTop - Rectl.yBottom)))
    2387       {
     2165          ((SHORT) ptl.y < 0 || ptl.y > (Rectl.yTop - Rectl.yBottom))) {
    23882166        DosSleep(1L);
    23892167        PostMsg(hwnd, WM_MOUSEMOVE, mp1, MPFROM2SHORT(TRUE, 0));
    … …  
    23952173  case WM_BUTTON1MOTIONEND:
    23962174    WinSetFocus(HWND_DESKTOP, hwnd);
    2397     if (ad && ad -> mousecaptured)
    2398     {
    2399       ad -> mousecaptured = FALSE;
    2400       ad -> lastselected = ULONG_MAX;
    2401       ad -> lastdirection = 0;
    2402       DosReleaseMutexSem(ad -> ScanSem);
     2175    if (ad && ad->mousecaptured) {
     2176      ad->mousecaptured = FALSE;
     2177      ad->lastselected = ULONG_MAX;
     2178      ad->lastdirection = 0;
     2179      DosReleaseMutexSem(ad->ScanSem);
    24032180      WinSetCapture(HWND_DESKTOP, NULLHANDLE);
    24042181    }
    … …  
    24082185  case WM_BUTTON1CLICK:
    24092186    WinSetFocus(HWND_DESKTOP, hwnd);
    2410     if (ad && !ad -> stopflag && ad -> numlines && ad -> text && !ad -> busy &&
    2411         !DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN))
    2412     {
     2187    if (ad && !ad->stopflag && ad->numlines && ad->text && !ad->busy &&
     2188        !DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN)) {
    24132189
    24142190      ULONG numlines, whichline, wascursored, width;
    … …  
    24232199      pts.y = SHORT2FROMMP(mp1);
    24242200      whichline = ((Rectl.yTop - Rectl.yBottom) -
    2425                    ((LONG) pts.y + ad -> lMaxDescender)) /
    2426         ad -> lMaxHeight;
     2201                   ((LONG) pts.y + ad->lMaxDescender)) / ad->lMaxHeight;
    24272202      if (whichline > numlines - 1)
    24282203        whichline = numlines - 1;
    2429       whichline += (ad -> topline - 1);
    2430       if (whichline + 1 > ad -> numlines)
     2204      whichline += (ad->topline - 1);
     2205      if (whichline + 1 > ad->numlines)
    24312206        break;
    2432       wascursored = ad -> cursored;
    2433       ad -> cursored = whichline + 1;
    2434       if (msg == WM_BUTTON1CLICK)
    2435       {
    2436         if (ad -> lastselected != ULONG_MAX)
    2437         {
    2438           if (whichline > ad -> lastselected)
    2439             ad -> lastdirection = 1;
     2207      wascursored = ad->cursored;
     2208      ad->cursored = whichline + 1;
     2209      if (msg == WM_BUTTON1CLICK) {
     2210        if (ad->lastselected != ULONG_MAX) {
     2211          if (whichline > ad->lastselected)
     2212            ad->lastdirection = 1;
    24402213          else
    2441             ad -> lastdirection = 2;
     2214            ad->lastdirection = 2;
    24422215        }
    24432216        else
    2444           ad -> lastdirection = 0;
    2445         ad -> lastselected = whichline;
    2446         if (whichline < ad -> numlines)
    2447         {
    2448           if (ad -> markedlines)
    2449           {
    2450             if (ad -> markedlines[whichline] & VF_SELECTED)
    2451             {
    2452               ad -> selected--;
    2453               ad -> markedlines[whichline] &= (~VF_SELECTED);
    2454             }
    2455             else
    2456             {
    2457               ad -> selected++;
    2458               ad -> markedlines[whichline] |= VF_SELECTED;
     2217          ad->lastdirection = 0;
     2218        ad->lastselected = whichline;
     2219        if (whichline < ad->numlines) {
     2220          if (ad->markedlines) {
     2221            if (ad->markedlines[whichline] & VF_SELECTED) {
     2222              ad->selected--;
     2223              ad->markedlines[whichline] &= (~VF_SELECTED);
     2224            }
     2225            else {
     2226              ad->selected++;
     2227              ad->markedlines[whichline] |= VF_SELECTED;
    24592228            }
    24602229          }
    24612230          WinSendMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
    24622231        }
    2463         PaintLine(hwnd, ad -> hps, whichline, ad -> topline, &Rectl);
    2464         if (ad -> cursored != wascursored)
    2465         {
    2466           PaintLine(hwnd, ad -> hps, wascursored - 1, ad -> topline, &Rectl);
     2232        PaintLine(hwnd, ad->hps, whichline, ad->topline, &Rectl);
     2233        if (ad->cursored != wascursored) {
     2234          PaintLine(hwnd, ad->hps, wascursored - 1, ad->topline, &Rectl);
    24672235          PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
    24682236        }
    24692237      }
    2470       else
    2471       {
     2238      else {
    24722239
    24732240        SHORT numsels, sSelect = 0, numinserted;
    24742241        ULONG linenum;
    24752242
    2476         if (!ad -> hex && ad -> lines)
    2477         {
     2243        if (!ad->hex && ad->lines) {
    24782244
    24792245          CHAR *p, *e;
    24802246
    2481           width = (Rectl.xRight - Rectl.xLeft) / ad -> fattrs.lAveCharWidth;
    2482           e = p = ad -> lines[whichline];
    2483           while (*e != '\r' && *e != '\n' && e < ad -> text + ad -> textsize)
    2484           {
    2485             if (ad -> wrapon && e - p == width)
     2247          width = (Rectl.xRight - Rectl.xLeft) / ad->fattrs.lAveCharWidth;
     2248          e = p = ad->lines[whichline];
     2249          while (*e != '\r' && *e != '\n' && e < ad->text + ad->textsize) {
     2250            if (ad->wrapon && e - p == width)
    24862251              break;
    24872252            e++;
    … …  
    24932258            goto NoAdd;
    24942259
    2495           if ((ad -> httpin && *httprun &&
    2496                strnstr(ad -> lines[whichline], "http://", width)) ||
    2497               (ad -> ftpin && *ftprun &&
    2498                strnstr(ad -> lines[whichline], "ftp://", width)))
    2499           {
     2260          if ((ad->httpin && *httprun &&
     2261               strnstr(ad->lines[whichline], "http://", width)) ||
     2262              (ad->ftpin && *ftprun &&
     2263               strnstr(ad->lines[whichline], "ftp://", width))) {
    25002264
    25012265            USHORT ret;
    25022266            URLDATA *urld;
    25032267
    2504             urld = xmallocz(sizeof(URLDATA),pszSrcFile,__LINE__);
     2268            urld = xmallocz(sizeof(URLDATA), pszSrcFile, __LINE__);
    25052269            if (urld) {
    2506               urld -> size = sizeof(URLDATA);
    2507               urld -> line = ad -> lines[whichline];
    2508               urld -> len = width;
     2270              urld->size = sizeof(URLDATA);
     2271              urld->line = ad->lines[whichline];
     2272              urld->len = width;
    25092273              ret = (USHORT) WinDlgBox(HWND_DESKTOP, hwnd, UrlDlgProc,
    25102274                                       FM3ModHandle, URL_FRAME, urld);
    … …  
    25142278                goto NoAdd;
    25152279              case 1:
    2516                 if (*urld -> url)
     2280                if (*urld->url)
    25172281                  runemf2(SEPARATE | WINDOWED,
    2518                           hwnd,
    2519                           NULL,
    2520                           NULL,
    2521                           "%s %s",
    2522                           httprun,
    2523                           urld -> url);
     2282                          hwnd, NULL, NULL, "%s %s", httprun, urld->url);
    25242283                free(urld);
    25252284                goto NoAdd;
    25262285              case 2:
    2527                 if (*urld -> url)
     2286                if (*urld->url)
    25282287                  runemf2(SEPARATE | WINDOWED,
    2529                           hwnd,
    2530                           NULL,
    2531                           NULL,
    2532                           "%s %s",
    2533                           ftprun,
    2534                           urld -> url);
     2288                          hwnd, NULL, NULL, "%s %s", ftprun, urld->url);
    25352289                free(urld);
    25362290                goto NoAdd;
    … …  
    25422296          }
    25432297        }
    2544         numsels = (SHORT) WinSendDlgItemMsg(ad -> hwndFrame, NEWVIEW_LISTBOX,
    2545                                          LM_QUERYITEMCOUNT, MPVOID, MPVOID);
    2546         if (numsels > 0)
    2547         {
    2548           for (sSelect = 0; sSelect < numsels; sSelect++)
    2549           {
    2550             linenum = (ULONG) WinSendDlgItemMsg(ad -> hwndFrame, NEWVIEW_LISTBOX,
    2551                                                 LM_QUERYITEMHANDLE,
    2552                                                 MPFROM2SHORT(sSelect, 0),
    2553                                                 MPVOID);
     2298        numsels = (SHORT) WinSendDlgItemMsg(ad->hwndFrame, NEWVIEW_LISTBOX,
     2299                                            LM_QUERYITEMCOUNT, MPVOID,
     2300                                            MPVOID);
     2301        if (numsels > 0) {
     2302          for (sSelect = 0; sSelect < numsels; sSelect++) {
     2303            linenum =
     2304              (ULONG) WinSendDlgItemMsg(ad->hwndFrame, NEWVIEW_LISTBOX,
     2305                                        LM_QUERYITEMHANDLE,
     2306                                        MPFROM2SHORT(sSelect, 0), MPVOID);
    25542307            if (linenum == whichline)
    25552308              goto NoAdd;
    … …  
    25592312          CHAR *s = NULL, *p;
    25602313
    2561           if (!ad -> hex && ad -> lines)
    2562           {
    2563             s = xmalloc(width + 2,pszSrcFile,__LINE__);
     2314          if (!ad->hex && ad->lines) {
     2315            s = xmalloc(width + 2, pszSrcFile, __LINE__);
    25642316            if (!s)
    25652317              goto NoAdd;
    2566             strncpy(s, ad -> lines[whichline], width + 1);
     2318            strncpy(s, ad->lines[whichline], width + 1);
    25672319            s[width + 1] = 0;
    25682320            p = s;
    2569             while (*p)
    2570             {
    2571               if (*p == '\r' || *p == '\n')
    2572               {
     2321            while (*p) {
     2322              if (*p == '\r' || *p == '\n') {
    25732323                *p = 0;
    25742324                break;
    … …  
    25772327            }
    25782328          }
    2579           else
    2580           {
     2329          else {
    25812330
    25822331            register ULONG x;
    25832332
    2584             width = ad -> textsize - (whichline * 16);
     2333            width = ad->textsize - (whichline * 16);
    25852334            width = min(width, 16);
    2586             s = xmalloc(80,pszSrcFile,__LINE__);
     2335            s = xmalloc(80, pszSrcFile, __LINE__);
    25872336            if (!s)
    25882337              goto NoAdd;
    25892338            sprintf(s, "%08lx ", whichline * 16);
    25902339            p = s + 9;
    2591             for (x = 0; x < width; x++)
    2592             {
    2593               sprintf(p, " %02hx", ad -> text[(whichline * 16) + x]);
     2340            for (x = 0; x < width; x++) {
     2341              sprintf(p, " %02hx", ad->text[(whichline * 16) + x]);
    25942342              p += 3;
    25952343            }
    … …  
    25982346            *p = ' ';
    25992347            p++;
    2600             for (x = 0; x < width; x++)
    2601             {
    2602               *p = ad -> text[(whichline * 16) + x];
     2348            for (x = 0; x < width; x++) {
     2349              *p = ad->text[(whichline * 16) + x];
    26032350              p++;
    26042351            }
    26052352            *p = 0;
    26062353          }
    2607           if (s)
    2608           {
    2609             if (*s)
    2610             {
    2611               ad -> dummy = TRUE;
    2612               numinserted = (SHORT) WinSendDlgItemMsg(ad -> hwndFrame,
     2354          if (s) {
     2355            if (*s) {
     2356              ad->dummy = TRUE;
     2357              numinserted = (SHORT) WinSendDlgItemMsg(ad->hwndFrame,
    26132358                                                      NEWVIEW_LISTBOX,
    26142359                                                      LM_INSERTITEM,
    2615                                                    MPFROM2SHORT(LIT_END, 0),
     2360                                                      MPFROM2SHORT(LIT_END,
     2361                                                                   0),
    26162362                                                      MPFROMP(s));
    2617               ad -> dummy = FALSE;
     2363              ad->dummy = FALSE;
    26182364              if (numinserted >= 0)
    2619                 WinSendDlgItemMsg(ad -> hwndFrame, NEWVIEW_LISTBOX,
     2365                WinSendDlgItemMsg(ad->hwndFrame, NEWVIEW_LISTBOX,
    26202366                                  LM_SETITEMHANDLE,
    26212367                                  MPFROM2SHORT(numinserted, 0),
    … …  
    26262372        }
    26272373        if (!numsels)
    2628           WinSendMsg(ad -> hwndFrame, WM_UPDATEFRAME,
     2374          WinSendMsg(ad->hwndFrame, WM_UPDATEFRAME,
    26292375                     MPFROMLONG(FCF_SIZEBORDER), MPVOID);
    26302376      }
    26312377    NoAdd:
    2632       DosReleaseMutexSem(ad -> ScanSem);
     2378      DosReleaseMutexSem(ad->ScanSem);
    26332379      DosPostEventSem(CompactSem);
    26342380    }
    … …  
    26362382
    26372383  case WM_MENUEND:
    2638     if (ad && ad -> hwndPopup == (HWND)mp2)
    2639     {
    2640       WinDestroyWindow(ad -> hwndPopup);
    2641       ad -> hwndPopup = (HWND)0;
     2384    if (ad && ad->hwndPopup == (HWND) mp2) {
     2385      WinDestroyWindow(ad->hwndPopup);
     2386      ad->hwndPopup = (HWND) 0;
    26422387    }
    26432388    break;
    … …  
    26452390  case UM_CONTEXTMENU:
    26462391  case WM_CONTEXTMENU:
    2647     if (ad)
    2648     {
    2649       if (!ad -> hwndPopup)
    2650       {
    2651         ad -> hwndPopup = WinLoadMenu(HWND_DESKTOP, FM3ModHandle, NEWVIEW_POPUP);
    2652         if (ad -> hwndPopup)
    2653           WinSetPresParam(ad -> hwndPopup,
     2392    if (ad) {
     2393      if (!ad->hwndPopup) {
     2394        ad->hwndPopup =
     2395          WinLoadMenu(HWND_DESKTOP, FM3ModHandle, NEWVIEW_POPUP);
     2396        if (ad->hwndPopup)
     2397          WinSetPresParam(ad->hwndPopup,
    26542398                          PP_FONTNAMESIZE,
    26552399                          strlen(GetPString(IDS_8HELVTEXT)) + 1,
    26562400                          GetPString(IDS_8HELVTEXT));
    26572401      }
    2658       if (ad -> hwndPopup)
    2659       {
     2402      if (ad->hwndPopup) {
    26602403
    26612404        APIRET rc;
    26622405        SHORT sSelect;
    26632406
    2664         rc = DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN);
    2665         WinEnableMenuItem(ad -> hwndPopup, IDM_SAVETOCLIP, (rc == 0 &&
    2666                                                       ad -> selected != 0));
    2667         WinEnableMenuItem(ad -> hwndPopup, IDM_APPENDTOCLIP, (rc == 0 &&
    2668                                                       ad -> selected != 0));
    2669         WinEnableMenuItem(ad -> hwndPopup, IDM_SAVETOLIST, (rc == 0 &&
    2670                                                       ad -> selected != 0));
    2671         sSelect = (SHORT) WinSendDlgItemMsg(ad -> hwndFrame, NEWVIEW_LISTBOX,
    2672                                          LM_QUERYITEMCOUNT, MPVOID, MPVOID);
    2673         WinEnableMenuItem(ad -> hwndPopup, IDM_SAVETOCLIP2, (rc == 0 &&
    2674                                                              sSelect > 0));
    2675         WinEnableMenuItem(ad -> hwndPopup, IDM_APPENDTOCLIP2, (rc == 0 &&
    2676                                                                sSelect > 0));
    2677         WinEnableMenuItem(ad -> hwndPopup, IDM_SAVETOLIST2, (rc == 0 &&
    2678                                                              sSelect > 0));
    2679         WinEnableMenuItem(ad -> hwndPopup, IDM_SELECTALL, (rc == 0 &&
    2680                                                       ad -> numlines != 0 &&
    2681                                                         ad -> markedlines));
    2682         WinEnableMenuItem(ad -> hwndPopup, IDM_DESELECTALL, (rc == 0 &&
    2683                                                       ad -> numlines != 0 &&
    2684                                                         ad -> markedlines &&
    2685                                                       ad -> selected != 0));
    2686         WinEnableMenuItem(ad -> hwndPopup, IDM_PREVSELECTED, (rc == 0 &&
    2687                                                       ad -> numlines != 0 &&
    2688                                                         ad -> markedlines &&
    2689                                                       ad -> selected != 0));
    2690         WinEnableMenuItem(ad -> hwndPopup, IDM_NEXTSELECTED, (rc == 0 &&
    2691                                                       ad -> numlines != 0 &&
    2692                                                         ad -> markedlines &&
    2693                                                       ad -> selected != 0));
    2694         WinEnableMenuItem(ad -> hwndPopup, IDM_SELECTFOUND, (rc == 0 &&
    2695                                                       ad -> numlines != 0 &&
    2696                                                         ad -> markedlines &&
    2697                                                          ad -> found != 0));
    2698         WinEnableMenuItem(ad -> hwndPopup, IDM_DESELECTFOUND, (rc == 0 &&
    2699                                                       ad -> numlines != 0 &&
    2700                                                         ad -> markedlines &&
    2701                                                       ad -> selected != 0 &&
    2702                                                          ad -> found != 0));
    2703         WinEnableMenuItem(ad -> hwndPopup, IDM_INVERT, (rc == 0 &&
    2704                                                       ad -> numlines != 0 &&
    2705                                                         ad -> markedlines));
    2706         WinEnableMenuItem(ad -> hwndPopup, IDM_FINDFIRST, (rc == 0 &&
    2707                                                       ad -> numlines != 0 &&
    2708                                                         ad -> markedlines));
    2709         WinEnableMenuItem(ad -> hwndPopup, IDM_FINDNEXT, (rc == 0 &&
    2710                                                       ad -> numlines != 0 &&
    2711                                                         ad -> markedlines &&
    2712                                                           ad -> found));
    2713         WinEnableMenuItem(ad -> hwndPopup, IDM_FINDPREV, (rc == 0 &&
    2714                                                       ad -> numlines != 0 &&
    2715                                                         ad -> markedlines &&
    2716                                                           ad -> found));
    2717         WinEnableMenuItem(ad -> hwndPopup, IDM_GOTOLINE, (rc == 0 &&
    2718                                                       ad -> numlines != 0));
    2719         WinEnableMenuItem(ad -> hwndPopup, IDM_GOTOOFFSET, (rc == 0 &&
    2720                                                       ad -> textsize != 0));
     2407        rc = DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN);
     2408        WinEnableMenuItem(ad->hwndPopup, IDM_SAVETOCLIP, (rc == 0 &&
     2409                                                          ad->selected != 0));
     2410        WinEnableMenuItem(ad->hwndPopup, IDM_APPENDTOCLIP, (rc == 0 &&
     2411                                                            ad->selected !=
     2412                                                            0));
     2413        WinEnableMenuItem(ad->hwndPopup, IDM_SAVETOLIST,
     2414                          (rc == 0 && ad->selected != 0));
     2415        sSelect =
     2416          (SHORT) WinSendDlgItemMsg(ad->hwndFrame, NEWVIEW_LISTBOX,
     2417                                    LM_QUERYITEMCOUNT, MPVOID, MPVOID);
     2418        WinEnableMenuItem(ad->hwndPopup, IDM_SAVETOCLIP2,
     2419                          (rc == 0 && sSelect > 0));
     2420        WinEnableMenuItem(ad->hwndPopup, IDM_APPENDTOCLIP2,
     2421                          (rc == 0 && sSelect > 0));
     2422        WinEnableMenuItem(ad->hwndPopup, IDM_SAVETOLIST2,
     2423                          (rc == 0 && sSelect > 0));
     2424        WinEnableMenuItem(ad->hwndPopup, IDM_SELECTALL,
     2425                          (rc == 0 && ad->numlines != 0 && ad->markedlines));
     2426        WinEnableMenuItem(ad->hwndPopup, IDM_DESELECTALL,
     2427                          (rc == 0 && ad->numlines != 0 && ad->markedlines
     2428                           && ad->selected != 0));
     2429        WinEnableMenuItem(ad->hwndPopup, IDM_PREVSELECTED,
     2430                          (rc == 0 && ad->numlines != 0 && ad->markedlines
     2431                           && ad->selected != 0));
     2432        WinEnableMenuItem(ad->hwndPopup, IDM_NEXTSELECTED,
     2433                          (rc == 0 && ad->numlines != 0 && ad->markedlines
     2434                           && ad->selected != 0));
     2435        WinEnableMenuItem(ad->hwndPopup, IDM_SELECTFOUND,
     2436                          (rc == 0 && ad->numlines != 0 && ad->markedlines
     2437                           && ad->found != 0));
     2438        WinEnableMenuItem(ad->hwndPopup, IDM_DESELECTFOUND,
     2439                          (rc == 0 && ad->numlines != 0 && ad->markedlines
     2440                           && ad->selected != 0 && ad->found != 0));
     2441        WinEnableMenuItem(ad->hwndPopup, IDM_INVERT,
     2442                          (rc == 0 && ad->numlines != 0 && ad->markedlines));
     2443        WinEnableMenuItem(ad->hwndPopup, IDM_FINDFIRST,
     2444                          (rc == 0 && ad->numlines != 0 && ad->markedlines));
     2445        WinEnableMenuItem(ad->hwndPopup, IDM_FINDNEXT,
     2446                          (rc == 0 && ad->numlines != 0 && ad->markedlines
     2447                           && ad->found));
     2448        WinEnableMenuItem(ad->hwndPopup, IDM_FINDPREV,
     2449                          (rc == 0 && ad->numlines != 0 && ad->markedlines
     2450                           && ad->found));
     2451        WinEnableMenuItem(ad->hwndPopup, IDM_GOTOLINE,
     2452                          (rc == 0 && ad->numlines != 0));
     2453        WinEnableMenuItem(ad->hwndPopup, IDM_GOTOOFFSET,
     2454                          (rc == 0 && ad->textsize != 0));
    27212455        if (!rc)
    2722           DosReleaseMutexSem(ad -> ScanSem);
    2723         PopupMenu(hwnd, hwnd, ad -> hwndPopup);
     2456          DosReleaseMutexSem(ad->ScanSem);
     2457        PopupMenu(hwnd, hwnd, ad->hwndPopup);
    27242458      }
    27252459    }
    … …  
    27272461
    27282462  case UM_SETUP3:
    2729     if (ad && !ad -> busy &&
    2730         !DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN))
    2731     {
    2732       ad -> multiplier = ad -> numlines / 32767;
    2733       if (ad -> multiplier * 32767 != ad -> numlines)
    2734         ad -> multiplier++;
    2735       if (!ad -> multiplier)
    2736         ad -> multiplier++;
     2463    if (ad && !ad->busy &&
     2464        !DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN)) {
     2465      ad->multiplier = ad->numlines / 32767;
     2466      if (ad->multiplier * 32767 != ad->numlines)
     2467        ad->multiplier++;
     2468      if (!ad->multiplier)
     2469        ad->multiplier++;
    27372470      {
    27382471        RECTL Rectl;
    … …  
    27412474        WinQueryWindowRect(hwnd, &Rectl);
    27422475        numlines = NumLines(&Rectl, ad);
    2743         if (numlines)
    2744         {
    2745           WinSendMsg(ad -> hhscroll, SBM_SETTHUMBSIZE,
    2746                      MPFROM2SHORT((SHORT) Rectl.xRight, (SHORT) ad -> maxx),
     2476        if (numlines) {
     2477          WinSendMsg(ad->hhscroll, SBM_SETTHUMBSIZE,
     2478                     MPFROM2SHORT((SHORT) Rectl.xRight, (SHORT) ad->maxx),
    27472479                     MPVOID);
    2748           WinSendMsg(ad -> hvscroll, SBM_SETTHUMBSIZE,
     2480          WinSendMsg(ad->hvscroll, SBM_SETTHUMBSIZE,
    27492481                     MPFROM2SHORT((SHORT) numlines,
    2750                                (SHORT) min(ad -> numlines, 32767)), MPVOID);
    2751           if (ad -> multiplier)
    2752             WinSendMsg(ad -> hvscroll, SBM_SETSCROLLBAR,
    2753                     MPFROMSHORT((SHORT) (ad -> topline / ad -> multiplier)),
    2754                        MPFROM2SHORT(1, (SHORT) ((ad -> numlines + 1) /
    2755                                              ad -> multiplier) - numlines));
    2756           WinSendMsg(ad -> hhscroll, SBM_SETSCROLLBAR,
    2757                      MPFROMSHORT((SHORT) abs(ad -> horzscroll)),
    2758                      MPFROM2SHORT(0, (SHORT) (ad -> maxx - Rectl.xRight)));
    2759           if (ad -> numlines - ad -> topline < numlines)
    2760           {
    2761             ad -> topline = ((ad -> numlines - ad -> topline) - numlines);
     2482                                  (SHORT) min(ad->numlines, 32767)), MPVOID);
     2483          if (ad->multiplier)
     2484            WinSendMsg(ad->hvscroll, SBM_SETSCROLLBAR,
     2485                       MPFROMSHORT((SHORT) (ad->topline / ad->multiplier)),
     2486                       MPFROM2SHORT(1, (SHORT) ((ad->numlines + 1) /
     2487                                                ad->multiplier) - numlines));
     2488          WinSendMsg(ad->hhscroll, SBM_SETSCROLLBAR,
     2489                     MPFROMSHORT((SHORT) abs(ad->horzscroll)),
     2490                     MPFROM2SHORT(0, (SHORT) (ad->maxx - Rectl.xRight)));
     2491          if (ad->numlines - ad->topline < numlines) {
     2492            ad->topline = ((ad->numlines - ad->topline) - numlines);
    27622493            WinInvalidateRect(hwnd, NULL, FALSE);
    27632494          }
    27642495        }
    27652496      }
    2766       DosReleaseMutexSem(ad -> ScanSem);
     2497      DosReleaseMutexSem(ad->ScanSem);
    27672498    }
    27682499    return 0;
    27692500
    27702501  case UM_SETUP4:
    2771     if (ad && !ad -> busy &&
    2772         !DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN))
    2773     {
     2502    if (ad && !ad->busy &&
     2503        !DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN)) {
    27742504
    27752505      CHAR s[140], t[34];
    … …  
    27792509      WinQueryWindowRect(hwnd, &Rectl);
    27802510      numlines = NumLines(&Rectl, ad);
    2781       commafmt(t, sizeof(t), ad -> cursored);
     2511      commafmt(t, sizeof(t), ad->cursored);
    27822512      strcpy(s, GetPString(IDS_LINECOLONTEXT));
    27832513      strcat(s, t);
    2784       if (ad -> selected)
    2785       {
    2786         if (ad -> selected > ad -> numlines)
    2787           ad -> selected = 0;
    2788         else
    2789         {
    2790           commafmt(t, sizeof(t), ad -> selected);
     2514      if (ad->selected) {
     2515        if (ad->selected > ad->numlines)
     2516          ad->selected = 0;
     2517        else {
     2518          commafmt(t, sizeof(t), ad->selected);
    27912519          strcat(s, "  (");
    27922520          strcat(s, t);
    … …  
    27942522        }
    27952523      }
    2796       if (ad -> found)
    2797       {
    2798         if (ad -> found > ad -> numlines)
    2799           ad -> found = 0;
    2800         else
    2801         {
    2802           commafmt(t, sizeof(t), ad -> found);
     2524      if (ad->found) {
     2525        if (ad->found > ad->numlines)
     2526          ad->found = 0;
     2527        else {
     2528          commafmt(t, sizeof(t), ad->found);
    28032529          strcat(s, "  (");
    28042530          strcat(s, t);
    … …  
    28062532        }
    28072533      }
    2808       WinSetWindowText(ad -> hwndStatus2, s);
    2809       if (!ad -> hex && ad -> lines)
    2810         commafmt(t, sizeof(t), ad -> lines[ad -> cursored - 1] - ad -> text);
     2534      WinSetWindowText(ad->hwndStatus2, s);
     2535      if (!ad->hex && ad->lines)
     2536        commafmt(t, sizeof(t), ad->lines[ad->cursored - 1] - ad->text);
    28112537      else
    2812         commafmt(t, sizeof(t), (ad -> cursored - 1) * 16);
     2538        commafmt(t, sizeof(t), (ad->cursored - 1) * 16);
    28132539      strcpy(s, GetPString(IDS_OFFSETCOLONTEXT));
    28142540      strcat(s, t);
    2815       WinSetWindowText(ad -> hwndStatus3, s);
    2816       if (ad -> multiplier)
    2817         WinSendMsg(ad -> hvscroll, SBM_SETSCROLLBAR,
    2818                    MPFROMSHORT((SHORT) (ad -> topline / ad -> multiplier)),
    2819                    MPFROM2SHORT(1, (SHORT) ((ad -> numlines + 1) /
    2820                                             ad -> multiplier) - numlines));
    2821       WinSendMsg(ad -> hhscroll, SBM_SETSCROLLBAR,
    2822                  MPFROMSHORT((SHORT) abs(ad -> horzscroll)),
    2823                  MPFROM2SHORT(0, (SHORT) (ad -> maxx - Rectl.xRight)));
    2824       DosReleaseMutexSem(ad -> ScanSem);
     2541      WinSetWindowText(ad->hwndStatus3, s);
     2542      if (ad->multiplier)
     2543        WinSendMsg(ad->hvscroll, SBM_SETSCROLLBAR,
     2544                   MPFROMSHORT((SHORT) (ad->topline / ad->multiplier)),
     2545                   MPFROM2SHORT(1, (SHORT) ((ad->numlines + 1) /
     2546                                            ad->multiplier) - numlines));
     2547      WinSendMsg(ad->hhscroll, SBM_SETSCROLLBAR,
     2548                 MPFROMSHORT((SHORT) abs(ad->horzscroll)),
     2549                 MPFROM2SHORT(0, (SHORT) (ad->maxx - Rectl.xRight)));
     2550      DosReleaseMutexSem(ad->ScanSem);
    28252551    }
    28262552    return 0;
    28272553
    28282554  case UM_CONTAINER_FILLED:
    2829     if (ad && !ad -> busy &&
    2830         !DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN))
    2831     {
    2832       ad -> stopflag = 0;
    2833       ad -> topline = 1;
    2834       ad -> cursored = 1;
    2835       ad -> multiplier = 1;
     2555    if (ad && !ad->busy &&
     2556        !DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN)) {
     2557      ad->stopflag = 0;
     2558      ad->topline = 1;
     2559      ad->cursored = 1;
     2560      ad->multiplier = 1;
    28362561      PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
    28372562      WinEnableWindow(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
    2838                                       IDM_NEXTBLANKLINE), !ad -> hex);
     2563                                      IDM_NEXTBLANKLINE), !ad->hex);
    28392564      WinEnableWindow(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
    2840                                       IDM_PREVBLANKLINE), !ad -> hex);
    2841       if (!ad -> numlines)
    2842       {
    2843         if (!ad -> text)
    2844           Runtime_Error(pszSrcFile, __LINE__, "no data");
     2565                                      IDM_PREVBLANKLINE), !ad->hex);
     2566      if (!ad->numlines) {
     2567        if (!ad->text)
     2568          Runtime_Error(pszSrcFile, __LINE__, "no data");
    28452569        PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
    28462570      }
    2847       else
    2848       {
    2849         if (mp1 && (ULONG) mp1 < ad -> numlines + 1)
    2850         {
     2571      else {
     2572        if (mp1 && (ULONG) mp1 < ad->numlines + 1) {
    28512573
    28522574          RECTL Rectl;
    … …  
    28552577          WinQueryWindowRect(hwnd, &Rectl);
    28562578          numlines = NumLines(&Rectl, ad);
    2857           if (numlines)
    2858           {
    2859             ad -> topline = (ULONG) mp1;
    2860             if (ad -> numlines - ad -> topline < numlines)
    2861               ad -> topline = ad -> numlines - numlines;
    2862             ad -> cursored = (ULONG) mp1;
    2863             if (mp2)
    2864             {
    2865               ad -> cursored = (ULONG) mp2;
    2866               if (ad -> cursored > (ad -> topline - 1) + numlines)
    2867                 ad -> cursored = (ad -> topline - 1) + numlines;
     2579          if (numlines) {
     2580            ad->topline = (ULONG) mp1;
     2581            if (ad->numlines - ad->topline < numlines)
     2582              ad->topline = ad->numlines - numlines;
     2583            ad->cursored = (ULONG) mp1;
     2584            if (mp2) {
     2585              ad->cursored = (ULONG) mp2;
     2586              if (ad->cursored > (ad->topline - 1) + numlines)
     2587                ad->cursored = (ad->topline - 1) + numlines;
    28682588            }
    28692589          }
    … …  
    28732593        WinInvalidateRect(hwnd, NULL, FALSE);
    28742594      }
    2875       DosReleaseMutexSem(ad -> ScanSem);
     2595      DosReleaseMutexSem(ad->ScanSem);
    28762596    }
    28772597    else if (ad)
    2878       ad -> needrefreshing = TRUE;
     2598      ad->needrefreshing = TRUE;
    28792599    return 0;
    28802600
    28812601  case WM_ERASEBACKGROUND:
    28822602    WinFillRect((HPS) mp1, (PRECTL) mp2,
    2883                 standardcolors[ad -> colors[COLORS_NORMALBACK]]);
     2603                standardcolors[ad->colors[COLORS_NORMALBACK]]);
    28842604    return 0;
    28852605
    28862606  case WM_PAINT:
    2887     if (ad)
    2888     {
     2607    if (ad) {
    28892608
    28902609      HPS hpsp;
    28912610      RECTL Rectl;
    28922611      register ULONG x;
    2893       ULONG numlines, wascursored = ad -> cursored;
    2894 
    2895       hpsp = WinBeginPaint(hwnd, ad -> hps, &Rectl);
     2612      ULONG numlines, wascursored = ad->cursored;
     2613
     2614      hpsp = WinBeginPaint(hwnd, ad->hps, &Rectl);
    28962615      WinFillRect(hpsp, &Rectl,
    2897                   standardcolors[ad -> colors[COLORS_NORMALBACK]]);
    2898       if (!ad -> stopflag && !ad -> busy &&
    2899           !DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN))
    2900       {
     2616                  standardcolors[ad->colors[COLORS_NORMALBACK]]);
     2617      if (!ad->stopflag && !ad->busy &&
     2618          !DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN)) {
    29012619        WinQueryWindowRect(hwnd, &Rectl);
    29022620        numlines = NumLines(&Rectl, ad);
    2903         if (numlines)
    2904         {
    2905           if (ad -> numlines && (ad -> lines || ad -> hex))
    2906           {
    2907             if (ad -> topline > (ad -> numlines + 1) - numlines)
    2908               ad -> topline = (ad -> numlines + 1) - numlines;
    2909             if (ad -> topline > ad -> numlines)
    2910               ad -> topline = 1;
    2911             if (!ad -> topline)
    2912               ad -> topline = 1;
    2913             if (ad -> cursored < ad -> topline)
    2914               ad -> cursored = ad -> topline;
    2915             else if (ad -> cursored > (ad -> topline + numlines) - 1)
    2916               ad -> cursored = (ad -> topline + numlines) - 1;
    2917             if (ad -> cursored > ad -> numlines)
    2918               ad -> cursored = ad -> numlines;
    2919             if (wascursored != ad -> cursored)
     2621        if (numlines) {
     2622          if (ad->numlines && (ad->lines || ad->hex)) {
     2623            if (ad->topline > (ad->numlines + 1) - numlines)
     2624              ad->topline = (ad->numlines + 1) - numlines;
     2625            if (ad->topline > ad->numlines)
     2626              ad->topline = 1;
     2627            if (!ad->topline)
     2628              ad->topline = 1;
     2629            if (ad->cursored < ad->topline)
     2630              ad->cursored = ad->topline;
     2631            else if (ad->cursored > (ad->topline + numlines) - 1)
     2632              ad->cursored = (ad->topline + numlines) - 1;
     2633            if (ad->cursored > ad->numlines)
     2634              ad->cursored = ad->numlines;
     2635            if (wascursored != ad->cursored)
    29202636              PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
    29212637          }
    29222638          else
    2923             ad -> topline = ad -> cursored = 1;
    2924           if (ad -> numlines && (ad -> lines || ad -> hex))
    2925           {
    2926             for (x = ad -> topline - 1; x < ad -> numlines; x++)
    2927             {
     2639            ad->topline = ad->cursored = 1;
     2640          if (ad->numlines && (ad->lines || ad->hex)) {
     2641            for (x = ad->topline - 1; x < ad->numlines; x++) {
    29282642              if (((LONG) (Rectl.yTop -
    2929                            (ad -> lMaxHeight *
    2930               (((x + 1) - ad -> topline) + 1))) - ad -> lMaxDescender) <= 0)
     2643                           (ad->lMaxHeight *
     2644                            (((x + 1) - ad->topline) + 1))) -
     2645                   ad->lMaxDescender) <= 0)
    29312646                break;
    2932               PaintLine(hwnd, hpsp, x, ad -> topline, &Rectl);
    2933             }
    2934           }
    2935         }
    2936         if (ad -> multiplier)
    2937           WinSendMsg(ad -> hvscroll, SBM_SETSCROLLBAR,
    2938                      MPFROMSHORT((SHORT) (ad -> topline / ad -> multiplier)),
    2939                      MPFROM2SHORT(1, (SHORT) ((ad -> numlines + 1) /
    2940                                               ad -> multiplier) - numlines));
    2941         WinSendMsg(ad -> hhscroll, SBM_SETSCROLLBAR,
    2942                    MPFROMSHORT((SHORT) abs(ad -> horzscroll)),
    2943                    MPFROM2SHORT(0, (SHORT) (ad -> maxx - Rectl.xRight)));
    2944         WinSendMsg(ad -> hhscroll, SBM_SETTHUMBSIZE,
    2945                    MPFROM2SHORT((SHORT) Rectl.xRight, (SHORT) ad -> maxx),
     2647              PaintLine(hwnd, hpsp, x, ad->topline, &Rectl);
     2648            }
     2649          }
     2650        }
     2651        if (ad->multiplier)
     2652          WinSendMsg(ad->hvscroll, SBM_SETSCROLLBAR,
     2653                     MPFROMSHORT((SHORT) (ad->topline / ad->multiplier)),
     2654                     MPFROM2SHORT(1, (SHORT) ((ad->numlines + 1) /
     2655                                              ad->multiplier) - numlines));
     2656        WinSendMsg(ad->hhscroll, SBM_SETSCROLLBAR,
     2657                   MPFROMSHORT((SHORT) abs(ad->horzscroll)),
     2658                   MPFROM2SHORT(0, (SHORT) (ad->maxx - Rectl.xRight)));
     2659        WinSendMsg(ad->hhscroll, SBM_SETTHUMBSIZE,
     2660                   MPFROM2SHORT((SHORT) Rectl.xRight, (SHORT) ad->maxx),
    29462661                   MPVOID);
    2947         DosReleaseMutexSem(ad -> ScanSem);
    2948         ad -> needrefreshing = FALSE;
     2662        DosReleaseMutexSem(ad->ScanSem);
     2663        ad->needrefreshing = FALSE;
    29492664      }
    29502665      else
    2951         ad -> needrefreshing = TRUE;
     2666        ad->needrefreshing = TRUE;
    29522667      WinEndPaint(hpsp);
    29532668    }
    2954     else
    2955     {
     2669    else {
    29562670
    29572671      HPS hpsp;
    … …  
    29692683
    29702684      WinQueryWindowRect(hwnd, &rectl);
    2971       switch (SHORT2FROMMP(mp2))
    2972       {
     2685      switch (SHORT2FROMMP(mp2)) {
    29732686      case SB_PAGERIGHT:
    2974         if (abs(ad -> horzscroll) <= ad -> maxx - rectl.xRight)
    2975         {
    2976           ad -> horzscroll -= rectl.xRight;
    2977           if (abs(ad -> horzscroll) > ad -> maxx - rectl.xRight)
    2978             ad -> horzscroll = -((ad -> maxx - rectl.xRight) +
    2979                                  ad -> fattrs.lAveCharWidth);
     2687        if (abs(ad->horzscroll) <= ad->maxx - rectl.xRight) {
     2688          ad->horzscroll -= rectl.xRight;
     2689          if (abs(ad->horzscroll) > ad->maxx - rectl.xRight)
     2690            ad->horzscroll = -((ad->maxx - rectl.xRight) +
     2691                               ad->fattrs.lAveCharWidth);
    29802692        }
    29812693        else
    … …  
    29842696
    29852697      case SB_PAGELEFT:
    2986         if (ad -> horzscroll < 0)
    2987         {
    2988           ad -> horzscroll += rectl.xRight;
    2989           if (ad -> horzscroll > 0)
    2990             ad -> horzscroll = 0;
     2698        if (ad->horzscroll < 0) {
     2699          ad->horzscroll += rectl.xRight;
     2700          if (ad->horzscroll > 0)
     2701            ad->horzscroll = 0;
    29912702        }
    29922703        else
    … …  
    29952706
    29962707      case SB_LINERIGHT:
    2997         if (abs(ad -> horzscroll) <= ad -> maxx - rectl.xRight)
    2998           ad -> horzscroll -= ad -> fattrs.lAveCharWidth;
     2708        if (abs(ad->horzscroll) <= ad->maxx - rectl.xRight)
     2709          ad->horzscroll -= ad->fattrs.lAveCharWidth;
    29992710        else
    30002711          invalidate = FALSE;
    … …  
    30022713
    30032714      case SB_LINELEFT:
    3004         if (ad -> horzscroll < 0)
    3005           ad -> horzscroll += ad -> fattrs.lAveCharWidth;
     2715        if (ad->horzscroll < 0)
     2716          ad->horzscroll += ad->fattrs.lAveCharWidth;
    30062717        else
    30072718          invalidate = FALSE;
    … …  
    30092720
    30102721      case SB_SLIDERTRACK:
    3011         ad -> horzscroll = (SHORT1FROMMP(mp2) / ad -> fattrs.lAveCharWidth) *
    3012           ad -> fattrs.lAveCharWidth;
    3013         ad -> horzscroll = -(ad -> horzscroll);
    3014         if (ad -> horzscroll > 0)
    3015           ad -> horzscroll = 0;
    3016         if (abs(ad -> horzscroll) > (ad -> maxx - rectl.xRight) +
    3017             ad -> fattrs.lAveCharWidth)
    3018           ad -> horzscroll = -(ad -> maxx - rectl.xRight);
     2722        ad->horzscroll = (SHORT1FROMMP(mp2) / ad->fattrs.lAveCharWidth) *
     2723          ad->fattrs.lAveCharWidth;
     2724        ad->horzscroll = -(ad->horzscroll);
     2725        if (ad->horzscroll > 0)
     2726          ad->horzscroll = 0;
     2727        if (abs(ad->horzscroll) > (ad->maxx - rectl.xRight) +
     2728            ad->fattrs.lAveCharWidth)
     2729          ad->horzscroll = -(ad->maxx - rectl.xRight);
    30192730        break;
    30202731
    … …  
    30292740
    30302741  case WM_VSCROLL:
    3031     if (ad && !ad -> stopflag && ad -> text && ad -> numlines && !ad -> busy &&
    3032         !DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN))
    3033     {
     2742    if (ad && !ad->stopflag && ad->text && ad->numlines && !ad->busy &&
     2743        !DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN)) {
    30342744
    30352745      ULONG numlines, wascursored;
    … …  
    30382748      WinQueryWindowRect(hwnd, &rcl);
    30392749      numlines = NumLines(&rcl, ad);
    3040       if (numlines)
    3041       {
    3042         wascursored = ad -> cursored;
    3043         switch (SHORT2FROMMP(mp2))
    3044         {
     2750      if (numlines) {
     2751        wascursored = ad->cursored;
     2752        switch (SHORT2FROMMP(mp2)) {
    30452753        case SB_PAGEUP:
    3046           if (ad -> topline > 1)
    3047           {
    3048             ad -> topline -= numlines;
    3049             if (ad -> topline > ad -> numlines ||
    3050                 ad -> topline + numlines > (ad -> numlines + 1))
    3051               ad -> topline = 1;
    3052             if (ad -> cursored > ad -> topline + numlines)
    3053               ad -> cursored = ad -> topline + numlines;
    3054             if (ad -> cursored > ad -> numlines)
    3055               ad -> cursored = ad -> numlines;
     2754          if (ad->topline > 1) {
     2755            ad->topline -= numlines;
     2756            if (ad->topline > ad->numlines ||
     2757                ad->topline + numlines > (ad->numlines + 1))
     2758              ad->topline = 1;
     2759            if (ad->cursored > ad->topline + numlines)
     2760              ad->cursored = ad->topline + numlines;
     2761            if (ad->cursored > ad->numlines)
     2762              ad->cursored = ad->numlines;
    30562763            WinInvalidateRect(hwnd, NULL, FALSE);
    30572764          }
    30582765          break;
    30592766        case SB_PAGEDOWN:
    3060           if (ad -> topline + numlines <= ad -> numlines)
    3061           {
    3062             ad -> topline += numlines;
    3063             if (ad -> topline + numlines > ad -> numlines + 1)
    3064               ad -> topline = (ad -> numlines + 1) - numlines;
    3065             if (ad -> cursored < ad -> topline)
    3066               ad -> cursored = ad -> topline;
    3067             if (ad -> cursored + 1 > ad -> topline + numlines)
    3068               ad -> cursored = (ad -> topline + numlines) - 1;
    3069             if (ad -> cursored > ad -> numlines)
    3070               ad -> cursored = ad -> numlines;
     2767          if (ad->topline + numlines <= ad->numlines) {
     2768            ad->topline += numlines;
     2769            if (ad->topline + numlines > ad->numlines + 1)
     2770              ad->topline = (ad->numlines + 1) - numlines;
     2771            if (ad->cursored < ad->topline)
     2772              ad->cursored = ad->topline;
     2773            if (ad->cursored + 1 > ad->topline + numlines)
     2774              ad->cursored = (ad->topline + numlines) - 1;
     2775            if (ad->cursored > ad->numlines)
     2776              ad->cursored = ad->numlines;
    30712777            WinInvalidateRect(hwnd, NULL, FALSE);
    30722778          }
    30732779          break;
    30742780        case SB_LINEDOWN:
    3075           if (ad -> topline + numlines <= ad -> numlines)
    3076           {
     2781          if (ad->topline + numlines <= ad->numlines) {
    30772782
    30782783            RECTL Rectl, iRectl;
    30792784
    3080             ad -> topline++;
    3081             if (ad -> cursored < ad -> topline)
    3082               ad -> cursored = ad -> topline;
    3083             else if (ad -> cursored + 1 > ad -> topline + numlines)
    3084               ad -> cursored = (ad -> topline + numlines) - 1;
    3085             if (ad -> cursored > ad -> numlines)
    3086               ad -> cursored = ad -> numlines;
     2785            ad->topline++;
     2786            if (ad->cursored < ad->topline)
     2787              ad->cursored = ad->topline;
     2788            else if (ad->cursored + 1 > ad->topline + numlines)
     2789              ad->cursored = (ad->topline + numlines) - 1;
     2790            if (ad->cursored > ad->numlines)
     2791              ad->cursored = ad->numlines;
    30872792            WinQueryWindowRect(hwnd, &Rectl);
    3088             WinScrollWindow(hwnd, 0, ad -> lMaxHeight,
     2793            WinScrollWindow(hwnd, 0, ad->lMaxHeight,
    30892794                            NULL, NULL, NULLHANDLE, &iRectl, 0);
    3090             WinFillRect(ad -> hps, &iRectl,
    3091                         standardcolors[ad -> colors[COLORS_NORMALBACK]]);
    3092             PaintLine(hwnd, ad -> hps, (ad -> topline + numlines) - 2,
    3093                       ad -> topline, &Rectl);
    3094             if (ad -> cursored != ad -> topline + numlines)
    3095               PaintLine(hwnd, ad -> hps, ad -> cursored - 1, ad -> topline, &Rectl);
    3096             if (wascursored != ad -> cursored &&
    3097                 wascursored < ad -> topline + numlines &&
    3098                 wascursored >= ad -> topline)
    3099               PaintLine(hwnd, ad -> hps, wascursored - 1, ad -> topline, &Rectl);
    3100             if (numlines >= ad -> numlines)
     2795            WinFillRect(ad->hps, &iRectl,
     2796                        standardcolors[ad->colors[COLORS_NORMALBACK]]);
     2797            PaintLine(hwnd, ad->hps, (ad->topline + numlines) - 2,
     2798                      ad->topline, &Rectl);
     2799            if (ad->cursored != ad->topline + numlines)
     2800              PaintLine(hwnd, ad->hps, ad->cursored - 1, ad->topline, &Rectl);
     2801            if (wascursored != ad->cursored &&
     2802                wascursored < ad->topline + numlines &&
     2803                wascursored >= ad->topline)
     2804              PaintLine(hwnd, ad->hps, wascursored - 1, ad->topline, &Rectl);
     2805            if (numlines >= ad->numlines)
    31012806              numlines = 0;
    3102             if (ad -> multiplier)
    3103               WinSendMsg(ad -> hvscroll, SBM_SETSCROLLBAR,
    3104                     MPFROMSHORT((SHORT) (ad -> topline / ad -> multiplier)),
    3105                          MPFROM2SHORT(1, (SHORT) ((ad -> numlines + 1) /
    3106                                                   ad -> multiplier) -
     2807            if (ad->multiplier)
     2808              WinSendMsg(ad->hvscroll, SBM_SETSCROLLBAR,
     2809                         MPFROMSHORT((SHORT) (ad->topline / ad->multiplier)),
     2810                         MPFROM2SHORT(1, (SHORT) ((ad->numlines + 1) /
     2811                                                  ad->multiplier) -
    31072812                                      numlines));
    3108             WinSendMsg(ad -> hhscroll, SBM_SETSCROLLBAR,
    3109                        MPFROMSHORT((SHORT) abs(ad -> horzscroll)),
    3110                        MPFROM2SHORT(0, (SHORT) (ad -> maxx - Rectl.xRight)));
     2813            WinSendMsg(ad->hhscroll, SBM_SETSCROLLBAR,
     2814                       MPFROMSHORT((SHORT) abs(ad->horzscroll)),
     2815                       MPFROM2SHORT(0, (SHORT) (ad->maxx - Rectl.xRight)));
    31112816          }
    31122817          break;
    31132818        case SB_LINEUP:
    3114           if (ad -> topline > 1)
    3115           {
     2819          if (ad->topline > 1) {
    31162820
    31172821            RECTL Rectl, iRectl;
    31182822
    3119             ad -> topline--;
    3120             if (ad -> cursored < ad -> topline)
    3121               ad -> cursored = ad -> topline;
    3122             else if (ad -> cursored + 1 > ad -> topline + numlines)
    3123               ad -> cursored = (ad -> topline + numlines) - 1;
    3124             if (ad -> cursored > ad -> numlines)
    3125               ad -> cursored = ad -> numlines;
     2823            ad->topline--;
     2824            if (ad->cursored < ad->topline)
     2825              ad->cursored = ad->topline;
     2826            else if (ad->cursored + 1 > ad->topline + numlines)
     2827              ad->cursored = (ad->topline + numlines) - 1;
     2828            if (ad->cursored > ad->numlines)
     2829              ad->cursored = ad->numlines;
    31262830            WinQueryWindowRect(hwnd, &Rectl);
    3127             WinScrollWindow(hwnd, 0, -ad -> lMaxHeight,
     2831            WinScrollWindow(hwnd, 0, -ad->lMaxHeight,
    31282832                            NULL, NULL, NULLHANDLE, &iRectl, 0);
    3129             WinFillRect(ad -> hps, &iRectl,
    3130                         standardcolors[ad -> colors[COLORS_NORMALBACK]]);
     2833            WinFillRect(ad->hps, &iRectl,
     2834                        standardcolors[ad->colors[COLORS_NORMALBACK]]);
    31312835            iRectl = Rectl;
    3132             iRectl.yTop -= ((numlines * ad -> lMaxHeight) +
    3133                             ad -> lMaxDescender);
    3134             WinFillRect(ad -> hps, &iRectl,
    3135                         standardcolors[ad -> colors[COLORS_NORMALBACK]]);
    3136             PaintLine(hwnd, ad -> hps, ad -> topline - 1, ad -> topline, &Rectl);
    3137             if (ad -> cursored != ad -> topline)
    3138               PaintLine(hwnd, ad -> hps, ad -> cursored - 1, ad -> topline, &Rectl);
    3139             if (ad -> cursored != wascursored &&
    3140                 wascursored >= ad -> topline &&
    3141                 wascursored < ad -> topline + numlines)
    3142               PaintLine(hwnd, ad -> hps, wascursored - 1, ad -> topline, &Rectl);
    3143             if (numlines >= ad -> numlines)
     2836            iRectl.yTop -= ((numlines * ad->lMaxHeight) + ad->lMaxDescender);
     2837            WinFillRect(ad->hps, &iRectl,
     2838                        standardcolors[ad->colors[COLORS_NORMALBACK]]);
     2839            PaintLine(hwnd, ad->hps, ad->topline - 1, ad->topline, &Rectl);
     2840            if (ad->cursored != ad->topline)
     2841              PaintLine(hwnd, ad->hps, ad->cursored - 1, ad->topline, &Rectl);
     2842            if (ad->cursored != wascursored &&
     2843                wascursored >= ad->topline &&
     2844                wascursored < ad->topline + numlines)
     2845              PaintLine(hwnd, ad->hps, wascursored - 1, ad->topline, &Rectl);
     2846            if (numlines >= ad->numlines)
    31442847              numlines = 0;
    3145             if (ad -> multiplier)
    3146               WinSendMsg(ad -> hvscroll, SBM_SETSCROLLBAR,
    3147                     MPFROMSHORT((SHORT) (ad -> topline / ad -> multiplier)),
    3148                          MPFROM2SHORT(1, (SHORT) ((ad -> numlines + 1) /
    3149                                                   ad -> multiplier) -
     2848            if (ad->multiplier)
     2849              WinSendMsg(ad->hvscroll, SBM_SETSCROLLBAR,
     2850                         MPFROMSHORT((SHORT) (ad->topline / ad->multiplier)),
     2851                         MPFROM2SHORT(1, (SHORT) ((ad->numlines + 1) /
     2852                                                  ad->multiplier) -
    31502853                                      numlines));
    3151             WinSendMsg(ad -> hhscroll, SBM_SETSCROLLBAR,
    3152                        MPFROMSHORT((SHORT) abs(ad -> horzscroll)),
    3153                        MPFROM2SHORT(0, (SHORT) (ad -> maxx - Rectl.xRight)));
     2854            WinSendMsg(ad->hhscroll, SBM_SETSCROLLBAR,
     2855                       MPFROMSHORT((SHORT) abs(ad->horzscroll)),
     2856                       MPFROM2SHORT(0, (SHORT) (ad->maxx - Rectl.xRight)));
    31542857          }
    31552858          break;
    31562859        case SB_SLIDERTRACK:
    3157           if ((SHORT1FROMMP(mp2) >= 1) ||
    3158               (SHORT1FROMMP(mp2)) <= ad -> numlines)
    3159           {
    3160             ad -> topline = (ULONG) SHORT1FROMMP(mp2) * ad -> multiplier;
    3161             if (ad -> topline + numlines > ad -> numlines + 1)
    3162               ad -> topline = (ad -> numlines + 1) - numlines;
    3163             if (!ad -> topline)
    3164               ad -> topline = 1;
    3165             if (ad -> cursored < ad -> topline)
    3166               ad -> cursored = ad -> topline;
    3167             else if (ad -> cursored > ad -> topline + numlines)
    3168               ad -> cursored = ad -> topline + numlines;
    3169             if (ad -> cursored > ad -> numlines)
    3170               ad -> cursored = ad -> numlines;
     2860          if ((SHORT1FROMMP(mp2) >= 1) || (SHORT1FROMMP(mp2)) <= ad->numlines) {
     2861            ad->topline = (ULONG) SHORT1FROMMP(mp2) * ad->multiplier;
     2862            if (ad->topline + numlines > ad->numlines + 1)
     2863              ad->topline = (ad->numlines + 1) - numlines;
     2864            if (!ad->topline)
     2865              ad->topline = 1;
     2866            if (ad->cursored < ad->topline)
     2867              ad->cursored = ad->topline;
     2868            else if (ad->cursored > ad->topline + numlines)
     2869              ad->cursored = ad->topline + numlines;
     2870            if (ad->cursored > ad->numlines)
     2871              ad->cursored = ad->numlines;
    31712872            WinInvalidateRect(hwnd, NULL, FALSE);
    31722873          }
    … …  
    31752876          break;
    31762877        }
    3177         if (ad -> cursored != wascursored)
     2878        if (ad->cursored != wascursored)
    31782879          PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
    31792880      }
    3180       DosReleaseMutexSem(ad -> ScanSem);
     2881      DosReleaseMutexSem(ad->ScanSem);
    31812882    }
    31822883    break;
    31832884
    31842885  case WM_INITMENU:
    3185     switch (SHORT1FROMMP(mp1))
    3186     {
     2886    switch (SHORT1FROMMP(mp1)) {
    31872887    case IDM_FILESMENU:
    31882888      {
    … …  
    31902890        SHORT sSelect;
    31912891
    3192         rc = DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN);
    3193         WinEnableMenuItem((HWND)mp2, IDM_SAVETOCLIP, (rc == 0 &&
    3194                                                        ad -> selected != 0));
    3195         WinEnableMenuItem((HWND)mp2, IDM_APPENDTOCLIP, (rc == 0 &&
    3196                                                       ad -> selected != 0));
    3197         WinEnableMenuItem((HWND)mp2, IDM_SAVETOLIST, (rc == 0 &&
    3198                                                        ad -> selected != 0));
    3199         sSelect = (SHORT) WinSendDlgItemMsg(ad -> hwndFrame, NEWVIEW_LISTBOX,
    3200                                          LM_QUERYITEMCOUNT, MPVOID, MPVOID);
    3201         WinEnableMenuItem((HWND)mp2, IDM_SAVETOCLIP2, (rc == 0 &&
    3202                                                         sSelect > 0));
    3203         WinEnableMenuItem((HWND)mp2, IDM_APPENDTOCLIP2, (rc == 0 &&
    3204                                                           sSelect > 0));
    3205         WinEnableMenuItem((HWND)mp2, IDM_SAVETOLIST2, (rc == 0 &&
    3206                                                         sSelect > 0));
     2892        rc = DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN);
     2893        WinEnableMenuItem((HWND) mp2, IDM_SAVETOCLIP, (rc == 0 &&
     2894                                                       ad->selected != 0));
     2895        WinEnableMenuItem((HWND) mp2, IDM_APPENDTOCLIP, (rc == 0 &&
     2896                                                         ad->selected != 0));
     2897        WinEnableMenuItem((HWND) mp2, IDM_SAVETOLIST, (rc == 0 &&
     2898                                                       ad->selected != 0));
     2899        sSelect = (SHORT) WinSendDlgItemMsg(ad->hwndFrame, NEWVIEW_LISTBOX,
     2900                                            LM_QUERYITEMCOUNT, MPVOID,
     2901                                            MPVOID);
     2902        WinEnableMenuItem((HWND) mp2, IDM_SAVETOCLIP2,
     2903                          (rc == 0 && sSelect > 0));
     2904        WinEnableMenuItem((HWND) mp2, IDM_APPENDTOCLIP2,
     2905                          (rc == 0 && sSelect > 0));
     2906        WinEnableMenuItem((HWND) mp2, IDM_SAVETOLIST2,
     2907                          (rc == 0 && sSelect > 0));
    32072908        if (!rc)
    3208           DosReleaseMutexSem(ad -> ScanSem);
     2909          DosReleaseMutexSem(ad->ScanSem);
    32092910      }
    32102911      break;
    … …  
    32142915        APIRET rc;
    32152916
    3216         rc = DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN);
    3217         WinEnableMenuItem((HWND)mp2, IDM_FONTPALETTE, (rc == 0));
    3218         WinEnableMenuItem((HWND)mp2, IDM_HEXMODE, (rc == 0));
    3219         WinEnableMenuItem((HWND)mp2, IDM_WRAP, (rc == 0));
    3220         WinEnableMenuItem((HWND)mp2, IDM_CODEPAGE, (rc == 0));
     2917        rc = DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN);
     2918        WinEnableMenuItem((HWND) mp2, IDM_FONTPALETTE, (rc == 0));
     2919        WinEnableMenuItem((HWND) mp2, IDM_HEXMODE, (rc == 0));
     2920        WinEnableMenuItem((HWND) mp2, IDM_WRAP, (rc == 0));
     2921        WinEnableMenuItem((HWND) mp2, IDM_CODEPAGE, (rc == 0));
    32212922        if (!rc)
    3222           DosReleaseMutexSem(ad -> ScanSem);
    3223       }
    3224       WinCheckMenuItem((HWND)mp2, IDM_HEXMODE, ad -> hex);
    3225       WinCheckMenuItem((HWND)mp2, IDM_WRAP, ad -> wrapon);
    3226       WinCheckMenuItem((HWND)mp2, IDM_IGNOREFTP, ad -> ignoreftp);
    3227       WinCheckMenuItem((HWND)mp2, IDM_IGNOREHTTP, ad -> ignorehttp);
     2923          DosReleaseMutexSem(ad->ScanSem);
     2924      }
     2925      WinCheckMenuItem((HWND) mp2, IDM_HEXMODE, ad->hex);
     2926      WinCheckMenuItem((HWND) mp2, IDM_WRAP, ad->wrapon);
     2927      WinCheckMenuItem((HWND) mp2, IDM_IGNOREFTP, ad->ignoreftp);
     2928      WinCheckMenuItem((HWND) mp2, IDM_IGNOREHTTP, ad->ignorehttp);
    32282929      break;
    32292930
    … …  
    32322933        APIRET rc;
    32332934
    3234         rc = DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN);
    3235         WinEnableMenuItem((HWND)mp2, IDM_FINDFIRST, (rc == 0 &&
    3236                                                       ad -> numlines != 0 &&
    3237                                                       ad -> markedlines));
    3238         WinEnableMenuItem((HWND)mp2, IDM_FINDNEXT, (rc == 0 &&
    3239                                                      ad -> numlines != 0 &&
    3240                                                      ad -> markedlines &&
    3241                                                      ad -> found != 0));
    3242         WinEnableMenuItem((HWND)mp2, IDM_FINDPREV, (rc == 0 &&
    3243                                                      ad -> numlines != 0 &&
    3244                                                      ad -> markedlines &&
    3245                                                      ad -> found != 0));
    3246         WinEnableMenuItem((HWND)mp2, IDM_NEXTBLANKLINE, (rc == 0 &&
    3247                                                       ad -> numlines != 0 &&
    3248                                                           !ad -> hex));
    3249         WinEnableMenuItem((HWND)mp2, IDM_PREVBLANKLINE, (rc == 0 &&
    3250                                                       ad -> numlines != 0 &&
    3251                                                           !ad -> hex));
    3252         WinEnableMenuItem((HWND)mp2, IDM_GOTOLINE, (rc == 0 &&
    3253                                                      ad -> numlines != 0));
    3254         WinEnableMenuItem((HWND)mp2, IDM_GOTOOFFSET, (rc == 0 &&
    3255                                                        ad -> textsize != 0));
     2935        rc = DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN);
     2936        WinEnableMenuItem((HWND) mp2, IDM_FINDFIRST, (rc == 0 &&
     2937                                                      ad->numlines != 0 &&
     2938                                                      ad->markedlines));
     2939        WinEnableMenuItem((HWND) mp2, IDM_FINDNEXT, (rc == 0 &&
     2940                                                     ad->numlines != 0 &&
     2941                                                     ad->markedlines &&
     2942                                                     ad->found != 0));
     2943        WinEnableMenuItem((HWND) mp2, IDM_FINDPREV, (rc == 0 &&
     2944                                                     ad->numlines != 0 &&
     2945                                                     ad->markedlines &&
     2946                                                     ad->found != 0));
     2947        WinEnableMenuItem((HWND) mp2, IDM_NEXTBLANKLINE, (rc == 0 &&
     2948                                                          ad->numlines != 0 &&
     2949                                                          !ad->hex));
     2950        WinEnableMenuItem((HWND) mp2, IDM_PREVBLANKLINE, (rc == 0 &&
     2951                                                          ad->numlines != 0 &&
     2952                                                          !ad->hex));
     2953        WinEnableMenuItem((HWND) mp2, IDM_GOTOLINE, (rc == 0 &&
     2954                                                     ad->numlines != 0));
     2955        WinEnableMenuItem((HWND) mp2, IDM_GOTOOFFSET, (rc == 0 &&
     2956                                                       ad->textsize != 0));
    32562957        if (!rc)
    3257           DosReleaseMutexSem(ad -> ScanSem);
     2958          DosReleaseMutexSem(ad->ScanSem);
    32582959      }
    32592960      break;
    … …  
    32632964        APIRET rc;
    32642965
    3265         rc = DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN);
    3266         WinEnableMenuItem((HWND)mp2, IDM_SELECTALL, (rc == 0 &&
    3267                                                       ad -> numlines != 0 &&
    3268                                                       ad -> markedlines &&
    3269                                                       (ad -> selected !=
    3270                                                        ad -> numlines ||
    3271                                                        !ad -> selected)));
    3272         WinEnableMenuItem((HWND)mp2, IDM_DESELECTALL, (rc == 0 &&
    3273                                                       ad -> numlines != 0 &&
    3274                                                         ad -> markedlines &&
    3275                                                       ad -> selected != 0));
    3276         WinEnableMenuItem((HWND)mp2, IDM_DESELECTFOUND, (rc == 0 &&
    3277                                                       ad -> numlines != 0 &&
    3278                                                         ad -> markedlines &&
    3279                                                       ad -> selected != 0 &&
    3280                                                           ad -> found != 0));
    3281         WinEnableMenuItem((HWND)mp2, IDM_SELECTFOUND, (rc == 0 &&
    3282                                                       ad -> numlines != 0 &&
    3283                                                         ad -> markedlines &&
    3284                                                         ad -> found != 0 &&
    3285                                                         (ad -> numlines !=
    3286                                                          ad -> selected ||
    3287                                                          !ad -> selected)));
    3288         WinEnableMenuItem((HWND)mp2, IDM_NEXTSELECTED, (rc == 0 &&
    3289                                                       ad -> numlines != 0 &&
    3290                                                          ad -> markedlines &&
    3291                                                       ad -> selected != 0));
    3292         WinEnableMenuItem((HWND)mp2, IDM_PREVSELECTED, (rc == 0 &&
    3293                                                       ad -> numlines != 0 &&
    3294                                                          ad -> markedlines &&
    3295                                                       ad -> selected != 0));
    3296         WinEnableMenuItem((HWND)mp2, IDM_INVERT, (rc == 0 &&
    3297                                                    ad -> numlines != 0 &&
    3298                                                    ad -> markedlines));
     2966        rc = DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN);
     2967        WinEnableMenuItem((HWND) mp2, IDM_SELECTALL, (rc == 0 &&
     2968                                                      ad->numlines != 0 &&
     2969                                                      ad->markedlines &&
     2970                                                      (ad->selected !=
     2971                                                       ad->numlines ||
     2972                                                       !ad->selected)));
     2973        WinEnableMenuItem((HWND) mp2, IDM_DESELECTALL, (rc == 0 &&
     2974                                                        ad->numlines != 0 &&
     2975                                                        ad->markedlines &&
     2976                                                        ad->selected != 0));
     2977        WinEnableMenuItem((HWND) mp2, IDM_DESELECTFOUND, (rc == 0 &&
     2978                                                          ad->numlines != 0 &&
     2979                                                          ad->markedlines &&
     2980                                                          ad->selected != 0 &&
     2981                                                          ad->found != 0));
     2982        WinEnableMenuItem((HWND) mp2, IDM_SELECTFOUND, (rc == 0 &&
     2983                                                        ad->numlines != 0 &&
     2984                                                        ad->markedlines &&
     2985                                                        ad->found != 0 &&
     2986                                                        (ad->numlines !=
     2987                                                         ad->selected ||
     2988                                                         !ad->selected)));
     2989        WinEnableMenuItem((HWND) mp2, IDM_NEXTSELECTED, (rc == 0 &&
     2990                                                         ad->numlines != 0 &&
     2991                                                         ad->markedlines &&
     2992                                                         ad->selected != 0));
     2993        WinEnableMenuItem((HWND) mp2, IDM_PREVSELECTED, (rc == 0 &&
     2994                                                         ad->numlines != 0 &&
     2995                                                         ad->markedlines &&
     2996                                                         ad->selected != 0));
     2997        WinEnableMenuItem((HWND) mp2, IDM_INVERT, (rc == 0 &&
     2998                                                   ad->numlines != 0 &&
     2999                                                   ad->markedlines));
    32993000        if (!rc)
    3300           DosReleaseMutexSem(ad -> ScanSem);
     3001          DosReleaseMutexSem(ad->ScanSem);
    33013002      }
    33023003      break;
    … …  
    33053006
    33063007  case UM_CONTROL:
    3307     switch (SHORT1FROMMP(mp1))
    3308     {
     3008    switch (SHORT1FROMMP(mp1)) {
    33093009    case NEWVIEW_LISTBOX:
    3310       switch (SHORT2FROMMP(mp1))
    3311       {
     3010      switch (SHORT2FROMMP(mp1)) {
    33123011      case LN_SETFOCUS:
    3313         if (ad)
    3314         {
    3315           if (!ad -> clientfocused)
    3316           {
     3012        if (ad) {
     3013          if (!ad->clientfocused) {
    33173014            PostMsg(hwnd,
    3318                     WM_COMMAND,
    3319                     MPFROM2SHORT(IDM_NEXTWINDOW, 0),
    3320                     MPVOID);
     3015                    WM_COMMAND, MPFROM2SHORT(IDM_NEXTWINDOW, 0), MPVOID);
    33213016            break;
    33223017          }
    3323           ad -> clientfocused = FALSE;
     3018          ad->clientfocused = FALSE;
    33243019        }
    33253020        PostMsg(hwnd,
    3326                 UM_CONTROL,
    3327                 MPFROM2SHORT(NEWVIEW_LISTBOX,
    3328                              LN_SELECT),
    3329                 MPVOID);
     3021                UM_CONTROL, MPFROM2SHORT(NEWVIEW_LISTBOX, LN_SELECT), MPVOID);
    33303022        break;
    33313023      case LN_KILLFOCUS:
    3332         if (ad)
    3333         {
    3334           ad -> clientfocused = TRUE;
     3024        if (ad) {
     3025          ad->clientfocused = TRUE;
    33353026          WinSetFocus(HWND_DESKTOP, hwnd);
    33363027        }
    33373028        break;
    33383029      case LN_SELECT:
    3339         if (ad && !ad -> dummy)
    3340         {
     3030        if (ad && !ad->dummy) {
    33413031
    33423032          ULONG linenum, numlines;
    33433033          SHORT sSelect;
    3344           HWND hwndUL = WinWindowFromID(ad -> hwndFrame,
     3034          HWND hwndUL = WinWindowFromID(ad->hwndFrame,
    33453035                                        SHORT1FROMMP(mp1));
    33463036          RECTL Rectl;
    … …  
    33483038          sSelect = (SHORT) WinSendMsg(hwndUL,
    33493039                                       LM_QUERYSELECTION,
    3350                                        MPFROM2SHORT(LIT_FIRST, 0),
    3351                                        MPVOID);
    3352           if (sSelect >= 0)
    3353           {
     3040                                       MPFROM2SHORT(LIT_FIRST, 0), MPVOID);
     3041          if (sSelect >= 0) {
    33543042            linenum = (ULONG) WinSendMsg(hwndUL,
    33553043                                         LM_QUERYITEMHANDLE,
    3356                                          MPFROM2SHORT(sSelect, 0),
    3357                                          MPVOID);
    3358             if (ad -> topline != linenum + 1 &&
    3359                 linenum < ad -> numlines)
    3360             {
     3044                                         MPFROM2SHORT(sSelect, 0), MPVOID);
     3045            if (ad->topline != linenum + 1 && linenum < ad->numlines) {
    33613046              WinQueryWindowRect(hwnd, &Rectl);
    33623047              numlines = NumLines(&Rectl, ad);
    3363               ad -> topline = linenum + 1;
    3364               if (ad -> numlines - ad -> topline < numlines)
    3365                 ad -> topline = ad -> numlines - numlines;
    3366               ad -> cursored = linenum + 1;
     3048              ad->topline = linenum + 1;
     3049              if (ad->numlines - ad->topline < numlines)
     3050                ad->topline = ad->numlines - numlines;
     3051              ad->cursored = linenum + 1;
    33673052              WinInvalidateRect(hwnd, NULL, FALSE);
    33683053              PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
    … …  
    33773062
    33783063      case LN_ENTER:
    3379         if (ad)
    3380         {
     3064        if (ad) {
    33813065
    33823066          SHORT sSelect;
    3383           HWND hwndUL = WinWindowFromID(ad -> hwndFrame,
     3067          HWND hwndUL = WinWindowFromID(ad->hwndFrame,
    33843068                                        SHORT1FROMMP(mp1));
    33853069
    33863070          sSelect = (SHORT) WinSendMsg(hwndUL,
    33873071                                       LM_QUERYSELECTION,
    3388                                        MPFROM2SHORT(LIT_FIRST, 0),
    3389                                        MPVOID);
    3390           if (sSelect >= 0)
    3391           {
    3392             ad -> dummy = TRUE;
     3072                                       MPFROM2SHORT(LIT_FIRST, 0), MPVOID);
     3073          if (sSelect >= 0) {
     3074            ad->dummy = TRUE;
    33933075            WinSendMsg(hwndUL, LM_DELETEITEM,
    33943076                       MPFROM2SHORT(sSelect, 0), MPVOID);
    3395             ad -> dummy = FALSE;
     3077            ad->dummy = FALSE;
    33963078            sSelect = (SHORT) WinSendMsg(hwndUL,
    3397                                          LM_QUERYITEMCOUNT,
    3398                                          MPVOID,
    3399                                          MPVOID);
    3400             if (sSelect <= 0)
    3401             {
    3402               PostMsg(ad -> hwndFrame, WM_UPDATEFRAME,
     3079                                         LM_QUERYITEMCOUNT, MPVOID, MPVOID);
     3080            if (sSelect <= 0) {
     3081              PostMsg(ad->hwndFrame, WM_UPDATEFRAME,
    34033082                      MPFROMLONG(FCF_SIZEBORDER), MPVOID);
    34043083              WinSetFocus(HWND_DESKTOP, hwnd);
    … …  
    34193098
    34203099  case WM_COMMAND:
    3421     switch (SHORT1FROMMP(mp1))
    3422     {
     3100    switch (SHORT1FROMMP(mp1)) {
    34233101    case IDM_EDIT:
    3424       if (*editor)
    3425       {
     3102      if (*editor) {
    34263103
    34273104        CHAR *dummy[2];
    34283105
    3429         dummy[0] = ad -> filename;
     3106        dummy[0] = ad->filename;
    34303107        dummy[1] = NULL;
    34313108        ExecOnList(hwnd, editor, WINDOWED | SEPARATE, NULL, dummy, NULL);
    34323109      }
    34333110      else
    3434         StartMLEEditor(ad -> hwndParent, 4, ad -> filename,
    3435                        ad -> hwndFrame);
    3436       ad -> hwndRestore = (HWND)0;
     3111        StartMLEEditor(ad->hwndParent, 4, ad->filename, ad->hwndFrame);
     3112      ad->hwndRestore = (HWND) 0;
    34373113      PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
    34383114      break;
    34393115
    34403116    case IDM_IGNOREFTP:
    3441       ad -> ignoreftp = (ad -> ignoreftp) ? FALSE : TRUE;
    3442       ad -> ftpin = FALSE;
    3443       if (ad -> text && *ftprun && !ad -> ignoreftp &&
    3444           strstr(ad -> text, "ftp://"))
    3445         ad -> ftpin = TRUE;
    3446       IgnoreFTP = ad -> ignoreftp;
     3117      ad->ignoreftp = (ad->ignoreftp) ? FALSE : TRUE;
     3118      ad->ftpin = FALSE;
     3119      if (ad->text && *ftprun && !ad->ignoreftp && strstr(ad->text, "ftp://"))
     3120        ad->ftpin = TRUE;
     3121      IgnoreFTP = ad->ignoreftp;
    34473122      PrfWriteProfileData(fmprof, appname, "Viewer.IgnoreFTP",
    3448                           &ad -> ignoreftp, sizeof(BOOL));
     3123                          &ad->ignoreftp, sizeof(BOOL));
    34493124      WinInvalidateRect(hwnd, NULL, FALSE);
    34503125      break;
    34513126
    34523127    case IDM_IGNOREHTTP:
    3453       ad -> ignorehttp = (ad -> ignorehttp) ? FALSE : TRUE;
    3454       ad -> httpin = FALSE;
    3455       if (ad -> text && *httprun && !ad -> ignorehttp &&
    3456           strstr(ad -> text, "http://"))
    3457         ad -> httpin = TRUE;
    3458       IgnoreHTTP = ad -> ignorehttp;
     3128      ad->ignorehttp = (ad->ignorehttp) ? FALSE : TRUE;
     3129      ad->httpin = FALSE;
     3130      if (ad->text && *httprun && !ad->ignorehttp &&
     3131          strstr(ad->text, "http://"))
     3132        ad->httpin = TRUE;
     3133      IgnoreHTTP = ad->ignorehttp;
    34593134      PrfWriteProfileData(fmprof, appname, "Viewer.IgnoreHTTP",
    3460                           &ad -> ignorehttp, sizeof(BOOL));
     3135                          &ad->ignorehttp, sizeof(BOOL));
    34613136      WinInvalidateRect(hwnd, NULL, FALSE);
    34623137      break;
    34633138
    34643139    case IDM_PREVBLANKLINE:
    3465       if (!ad -> hex && ad -> lines)
    3466       {
     3140      if (!ad->hex && ad->lines) {
    34673141
    34683142        ULONG x;
    34693143
    3470         x = ad -> cursored - 2;
    3471         if (x >= ad -> numlines)
     3144        x = ad->cursored - 2;
     3145        if (x >= ad->numlines)
    34723146          x = 0;
    3473         while (x < ad -> numlines &&
    3474                (*ad -> lines[x] == '\r' || *ad -> lines[x] == '\n'))
     3147        while (x < ad->numlines &&
     3148               (*ad->lines[x] == '\r' || *ad->lines[x] == '\n'))
    34753149          x--;
    3476         if (x >= ad -> numlines)
     3150        if (x >= ad->numlines)
    34773151          x = 0;
    3478         for (; x < ad -> numlines; x--)
    3479         {
    3480           if (*ad -> lines[x] == '\r' || *ad -> lines[x] == '\n')
    3481           {
    3482             if (x < ad -> numlines - 1)
     3152        for (; x < ad->numlines; x--) {
     3153          if (*ad->lines[x] == '\r' || *ad->lines[x] == '\n') {
     3154            if (x < ad->numlines - 1)
    34833155              x++;
    34843156            break;
    34853157          }
    34863158        }
    3487         if (x < ad -> numlines)
    3488         {
    3489           ad -> topline = ad -> cursored = x;
     3159        if (x < ad->numlines) {
     3160          ad->topline = ad->cursored = x;
    34903161          WinInvalidateRect(hwnd, NULL, FALSE);
    34913162        }
    … …  
    34943165
    34953166    case IDM_NEXTBLANKLINE:
    3496       if (!ad -> hex && ad -> lines)
    3497       {
     3167      if (!ad->hex && ad->lines) {
    34983168
    34993169        ULONG x;
    35003170
    3501         x = ad -> cursored;
    3502         while (x < ad -> numlines &&
    3503                (*ad -> lines[x] == '\r' || *ad -> lines[x] == '\n'))
     3171        x = ad->cursored;
     3172        while (x < ad->numlines &&
     3173               (*ad->lines[x] == '\r' || *ad->lines[x] == '\n'))
    35043174          x++;
    3505         for (; x < ad -> numlines; x++)
    3506         {
    3507           if (*ad -> lines[x] == '\r' || *ad -> lines[x] == '\n')
    3508           {
    3509             if (x < ad -> numlines - 1)
     3175        for (; x < ad->numlines; x++) {
     3176          if (*ad->lines[x] == '\r' || *ad->lines[x] == '\n') {
     3177            if (x < ad->numlines - 1)
    35103178              x++;
    35113179            break;
    35123180          }
    35133181        }
    3514         if (x < ad -> numlines)
    3515         {
    3516           while (x < ad -> numlines &&
    3517                  (*ad -> lines[x] == '\r' || *ad -> lines[x] == '\n'))
     3182        if (x < ad->numlines) {
     3183          while (x < ad->numlines &&
     3184                 (*ad->lines[x] == '\r' || *ad->lines[x] == '\n'))
    35183185            x++;
    3519           if (x < ad -> numlines)
    3520           {
    3521             ad -> topline = ad -> cursored = x;
     3186          if (x < ad->numlines) {
     3187            ad->topline = ad->cursored = x;
    35223188            WinInvalidateRect(hwnd, NULL, FALSE);
    35233189          }
    … …  
    35283194    case IDM_VIEW:
    35293195    case IDM_OBJECT:
    3530       if (!ad -> hex && ad -> lines)
    3531       {
     3196      if (!ad->hex && ad->lines) {
    35323197
    35333198        CHAR line[CCHMAXPATH], filename[CCHMAXPATH], *p;
    35343199
    3535         strncpy(line, ad -> lines[ad -> cursored - 1], CCHMAXPATH);
     3200        strncpy(line, ad->lines[ad->cursored - 1], CCHMAXPATH);
    35363201        line[CCHMAXPATH - 1] = 0;
    35373202        chop_at_crnl(line);
    3538         if (*line == '\"')
    3539         {
     3203        if (*line == '\"') {
    35403204          memmove(line, line + 1, strlen(line));
    35413205          p = strchr(line, '\"');
    … …  
    35453209          rstrip(line);
    35463210        }
    3547         else
    3548         {
     3211        else {
    35493212          lstrip(line);
    35503213          p = strchr(line, ' ');
    … …  
    35533216          rstrip(line);
    35543217        }
    3555         if (!strchr(line, '\\') && !strchr(line, '/') && !strchr(line, ':'))
    3556         {
    3557           strcpy(filename, ad -> filename);
     3218        if (!strchr(line, '\\') && !strchr(line, '/') && !strchr(line, ':')) {
     3219          strcpy(filename, ad->filename);
    35583220          p = strrchr(filename, '\\');
    35593221          if (p)
    … …  
    35663228          strcpy(filename, line);
    35673229        MakeFullName(filename);
    3568         if (*filename &&
    3569             IsFile(filename) == 1)
    3570         {
     3230        if (*filename && IsFile(filename) == 1) {
    35713231          if (SHORT1FROMMP(mp1) == IDM_OBJECT)
    3572             OpenObject(filename,
    3573                        Default,
    3574                        ad -> hwndFrame);
     3232            OpenObject(filename, Default, ad->hwndFrame);
    35753233          else
    3576             DefaultView(hwnd,
    3577                         ad -> hwndFrame,
    3578                         HWND_DESKTOP,
    3579                         NULL,
    3580                         0,
    3581                         filename);
     3234            DefaultView(hwnd, ad->hwndFrame, HWND_DESKTOP, NULL, 0, filename);
    35823235        }
    35833236      }
    … …  
    35923245        co.size = sizeof(co);
    35933246        co.numcolors = COLORS_MAX;
    3594         co.colors = ad -> colors;
     3247        co.colors = ad->colors;
    35953248        co.descriptions = IDS_NVCOLORS1TEXT;
    35963249        co.origs = temp;
    35973250        co.prompt = IDS_NVCOLORSPROMPTTEXT;
    3598         memcpy(temp,
    3599                ad -> colors,
    3600                sizeof(LONG) * COLORS_MAX);
     3251        memcpy(temp, ad->colors, sizeof(LONG) * COLORS_MAX);
    36013252        if (WinDlgBox(HWND_DESKTOP,
    36023253                      hwnd,
    36033254                      ColorDlgProc,
    3604                       FM3ModHandle,
    3605                       COLOR_FRAME,
    3606                       (PVOID) & co))
    3607         {
    3608           memcpy(Colors,
    3609                  ad -> colors,
    3610                  sizeof(LONG) * COLORS_MAX);
     3255                      FM3ModHandle, COLOR_FRAME, (PVOID) & co)) {
     3256          memcpy(Colors, ad->colors, sizeof(LONG) * COLORS_MAX);
    36113257          PrfWriteProfileData(fmprof,
    36123258                              appname,
    36133259                              "Viewer.Colors",
    3614                               &ad -> colors,
    3615                               sizeof(LONG) * COLORS_MAX);
    3616           WinInvalidateRect(hwnd,
    3617                             NULL,
    3618                             FALSE);
    3619           WinInvalidateRect(ad -> hwndStatus1,
    3620                             NULL,
    3621                             FALSE);
    3622           WinInvalidateRect(ad -> hwndStatus2,
    3623                             NULL,
    3624                             FALSE);
    3625           WinInvalidateRect(ad -> hwndStatus3,
    3626                             NULL,
    3627                             FALSE);
     3260                              &ad->colors, sizeof(LONG) * COLORS_MAX);
     3261          WinInvalidateRect(hwnd, NULL, FALSE);
     3262          WinInvalidateRect(ad->hwndStatus1, NULL, FALSE);
     3263          WinInvalidateRect(ad->hwndStatus2, NULL, FALSE);
     3264          WinInvalidateRect(ad->hwndStatus3, NULL, FALSE);
    36283265        }
    36293266      }
    … …  
    36353272        SHORT sSelect;
    36363273
    3637         sSelect = (SHORT) WinSendDlgItemMsg(ad -> hwndFrame,
     3274        sSelect = (SHORT) WinSendDlgItemMsg(ad->hwndFrame,
    36383275                                            NEWVIEW_LISTBOX,
    36393276                                            LM_QUERYITEMCOUNT,
    3640                                             MPVOID,
    3641                                             MPVOID);
    3642         if (sSelect)
    3643         {
    3644           if (!ad -> clientfocused)
     3277                                            MPVOID, MPVOID);
     3278        if (sSelect) {
     3279          if (!ad->clientfocused)
    36453280            WinSetFocus(HWND_DESKTOP, hwnd);
    36463281          else
    36473282            WinSetFocus(HWND_DESKTOP,
    3648                         WinWindowFromID(ad -> hwndFrame,
    3649                                         NEWVIEW_LISTBOX));
     3283                        WinWindowFromID(ad->hwndFrame, NEWVIEW_LISTBOX));
    36503284        }
    36513285        else
    … …  
    36583292        APIRET rc;
    36593293
    3660         rc = DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN);
    3661         if (!rc)
    3662         {
    3663           if (!ad -> busy && ad -> text && ad -> numlines && ad -> markedlines)
    3664           {
     3294        rc = DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN);
     3295        if (!rc) {
     3296          if (!ad->busy && ad->text && ad->numlines && ad->markedlines) {
    36653297
    36663298            ULONG numlines;
    … …  
    36723304            if (!numlines)
    36733305              break;
    3674             strcpy(test, ad -> searchtext);
     3306            strcpy(test, ad->searchtext);
    36753307            if (WinDlgBox(HWND_DESKTOP, hwnd, FindStrDlgProc, FM3ModHandle,
    3676                           NEWFIND_FRAME, (PVOID) & hwnd))
    3677             {
    3678               if (*ad -> searchtext &&
    3679                   strcmp(test, ad -> searchtext))
     3308                          NEWFIND_FRAME, (PVOID) & hwnd)) {
     3309              if (*ad->searchtext && strcmp(test, ad->searchtext))
    36803310                PrfWriteProfileString(fmprof,
    36813311                                      appname,
    36823312                                      "Viewer.Searchtext",
    3683                                       (PVOID) ad -> searchtext);
    3684               if (_beginthread(SearchThread, NULL, 524288, (PVOID) hwnd) == -1)
    3685                 Runtime_Error(pszSrcFile, __LINE__, GetPString(IDS_COULDNTSTARTTHREADTEXT));
    3686             }
    3687           }
    3688           DosReleaseMutexSem(ad -> ScanSem);
     3313                                      (PVOID) ad->searchtext);
     3314              if (_beginthread(SearchThread, NULL, 524288, (PVOID) hwnd) ==
     3315                  -1)
     3316                Runtime_Error(pszSrcFile, __LINE__,
     3317                              GetPString(IDS_COULDNTSTARTTHREADTEXT));
     3318            }
     3319          }
     3320          DosReleaseMutexSem(ad->ScanSem);
    36893321        }
    36903322      }
    … …  
    36983330        APIRET rc;
    36993331
    3700         rc = DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN);
    3701         if (!rc)
    3702         {
    3703           if (!ad -> busy && ad -> text && ad -> markedlines)
    3704           {
     3332        rc = DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN);
     3333        if (!rc) {
     3334          if (!ad->busy && ad->text && ad->markedlines) {
    37053335
    37063336            RECTL Rectl;
    … …  
    37183348            WinSetPointer(HWND_DESKTOP, hptrBusy);
    37193349            if (SHORT1FROMMP(mp1) == IDM_PREVSELECTED ||
    3720                 SHORT1FROMMP(mp1) == IDM_FINDPREV)
    3721             {
    3722               for (x = ad -> cursored - 2; x < ULONG_MAX - 1; x--)
    3723               {
    3724                 if (ad -> markedlines[x] & markedwith)
    3725                 {
    3726                   ad -> topline = x + 1;
    3727                   if (ad -> numlines - ad -> topline < numlines)
    3728                     ad -> topline = ad -> numlines - numlines;
    3729                   ad -> cursored = x + 1;
     3350                SHORT1FROMMP(mp1) == IDM_FINDPREV) {
     3351              for (x = ad->cursored - 2; x < ULONG_MAX - 1; x--) {
     3352                if (ad->markedlines[x] & markedwith) {
     3353                  ad->topline = x + 1;
     3354                  if (ad->numlines - ad->topline < numlines)
     3355                    ad->topline = ad->numlines - numlines;
     3356                  ad->cursored = x + 1;
    37303357                  WinInvalidateRect(hwnd, NULL, FALSE);
    37313358                  PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
    … …  
    37343361              }
    37353362            }
    3736             else
    3737             {
    3738               for (x = ad -> cursored; x < ad -> numlines; x++)
    3739               {
    3740                 if (ad -> markedlines[x] & markedwith)
    3741                 {
    3742                   ad -> topline = x + 1;
    3743                   if (ad -> numlines - ad -> topline < numlines)
    3744                     ad -> topline = ad -> numlines - numlines;
    3745                   ad -> cursored = x + 1;
     3363            else {
     3364              for (x = ad->cursored; x < ad->numlines; x++) {
     3365                if (ad->markedlines[x] & markedwith) {
     3366                  ad->topline = x + 1;
     3367                  if (ad->numlines - ad->topline < numlines)
     3368                    ad->topline = ad->numlines - numlines;
     3369                  ad->cursored = x + 1;
    37463370                  WinInvalidateRect(hwnd, NULL, FALSE);
    37473371                  PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
    … …  
    37513375            }
    37523376            WinSetPointer(HWND_DESKTOP, hptrArrow);
    3753             if (x >= ad -> numlines)
     3377            if (x >= ad->numlines)
    37543378              DosBeep(50, 100);
    37553379          }
    3756           DosReleaseMutexSem(ad -> ScanSem);
     3380          DosReleaseMutexSem(ad->ScanSem);
    37573381        }
    37583382      }
    … …  
    37643388        APIRET rc;
    37653389
    3766         rc = DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN);
    3767         if (!rc)
    3768         {
    3769           if (!ad -> busy && ad -> text && ad -> markedlines)
    3770           {
     3390        rc = DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN);
     3391        if (!rc) {
     3392          if (!ad->busy && ad->text && ad->markedlines) {
    37713393
    37723394            RECTL Rectl;
    … …  
    37793401              break;
    37803402            WinSetPointer(HWND_DESKTOP, hptrBusy);
    3781             for (x = 0; x < ad -> numlines; x++)
    3782             {
    3783               if (SHORT1FROMMP(mp1) == IDM_SELECTFOUND)
    3784               {
    3785                 if ((ad -> markedlines[x] & VF_FOUND) &&
    3786                     !(ad -> markedlines[x] & VF_SELECTED))
    3787                 {
    3788                   ad -> markedlines[x] |= VF_SELECTED;
    3789                   ad -> selected++;
     3403            for (x = 0; x < ad->numlines; x++) {
     3404              if (SHORT1FROMMP(mp1) == IDM_SELECTFOUND) {
     3405                if ((ad->markedlines[x] & VF_FOUND) &&
     3406                    !(ad->markedlines[x] & VF_SELECTED)) {
     3407                  ad->markedlines[x] |= VF_SELECTED;
     3408                  ad->selected++;
    37903409                }
    37913410              }
    3792               else
    3793               {
    3794                 if ((ad -> markedlines[x] & VF_FOUND) &&
    3795                     (ad -> markedlines[x] & VF_SELECTED))
    3796                 {
    3797                   ad -> markedlines[x] &= (~VF_SELECTED);
    3798                   ad -> selected--;
     3411              else {
     3412                if ((ad->markedlines[x] & VF_FOUND) &&
     3413                    (ad->markedlines[x] & VF_SELECTED)) {
     3414                  ad->markedlines[x] &= (~VF_SELECTED);
     3415                  ad->selected--;
    37993416                }
    38003417              }
    … …  
    38043421            WinInvalidateRect(hwnd, NULL, FALSE);
    38053422          }
    3806           DosReleaseMutexSem(ad -> ScanSem);
     3423          DosReleaseMutexSem(ad->ScanSem);
    38073424        }
    38083425      }
    … …  
    38143431        APIRET rc;
    38153432
    3816         rc = DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN);
    3817         if (!rc)
    3818         {
    3819           if (!ad -> busy && ad -> numlines)
    3820           {
     3433        rc = DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN);
     3434        if (!rc) {
     3435          if (!ad->busy && ad->numlines) {
    38213436
    38223437            ULONG numlines, linenum;
    … …  
    38303445            if (!numlines)
    38313446              break;
    3832             if (ad -> numlines <= numlines)
    3833             {
     3447            if (ad->numlines <= numlines) {
    38343448              DosBeep(500, 100);
    38353449              break;
    38363450            }
    38373451            sip.help = (SHORT1FROMMP(mp1) == IDM_GOTOLINE) ?
    3838               GetPString(IDS_NVLINEJUMPTEXT) :
    3839               GetPString(IDS_NVBYTEJUMPTEXT);
     3452              GetPString(IDS_NVLINEJUMPTEXT) : GetPString(IDS_NVBYTEJUMPTEXT);
    38403453            sip.ret = s;
    38413454            *s = 0;
    … …  
    38543467                    0,
    38553468                    (SHORT1FROMMP(mp1) == IDM_GOTOLINE) ?
    3856                     ad -> numlines :
    3857                     ad -> textsize - 1);
     3469                    ad->numlines : ad->textsize - 1);
    38583470            WinDlgBox(HWND_DESKTOP,
    3859                       hwnd,
    3860                       InputDlgProc,
    3861                       FM3ModHandle,
    3862                       STR_FRAME,
    3863                       &sip);
    3864             if (*s)
    3865             {
     3471                      hwnd, InputDlgProc, FM3ModHandle, STR_FRAME, &sip);
     3472            if (*s) {
    38663473              s[33] = 0;
    38673474              linenum = atol(s);
    3868               switch (SHORT1FROMMP(mp1))
    3869               {
     3475              switch (SHORT1FROMMP(mp1)) {
    38703476              case IDM_GOTOLINE:
    3871                 if (linenum > 0 &&
    3872                     linenum <= ad -> numlines)
    3873                 {
    3874                   ad -> topline = linenum;
    3875                   ad -> cursored = ad -> topline;
    3876                   if (ad -> numlines - ad -> topline < numlines)
    3877                     ad -> topline = (ad -> numlines - numlines) + 1;
    3878                   WinInvalidateRect(hwnd,
    3879                                     NULL,
    3880                                     FALSE);
     3477                if (linenum > 0 && linenum <= ad->numlines) {
     3478                  ad->topline = linenum;
     3479                  ad->cursored = ad->topline;
     3480                  if (ad->numlines - ad->topline < numlines)
     3481                    ad->topline = (ad->numlines - numlines) + 1;
     3482                  WinInvalidateRect(hwnd, NULL, FALSE);
    38813483                }
    38823484                break;
    38833485              case IDM_GOTOOFFSET:
    3884                 if (linenum < ad -> textsize)
    3885                 {
    3886                   if (ad -> hex)
    3887                     ad -> topline = (linenum / 16) + 1;
    3888                   else if (ad -> lines)
    3889                   {
    3890                     ad -> topline = (ULONG) - 1;
    3891                     for (x = 0; x < ad -> numlines; x++)
    3892                     {
    3893                       if (ad -> lines[x] > ad -> text + linenum)
    3894                       {
    3895                         ad -> topline = x + 1;
     3486                if (linenum < ad->textsize) {
     3487                  if (ad->hex)
     3488                    ad->topline = (linenum / 16) + 1;
     3489                  else if (ad->lines) {
     3490                    ad->topline = (ULONG) - 1;
     3491                    for (x = 0; x < ad->numlines; x++) {
     3492                      if (ad->lines[x] > ad->text + linenum) {
     3493                        ad->topline = x + 1;
    38963494                        break;
    38973495                      }
    38983496                    }
    3899                     if (ad -> topline == (ULONG) - 1)
    3900                       ad -> topline = ad -> numlines;
     3497                    if (ad->topline == (ULONG) - 1)
     3498                      ad->topline = ad->numlines;
    39013499                  }
    3902                   ad -> cursored = ad -> topline;
    3903                   if (ad -> numlines - ad -> topline < numlines)
    3904                     ad -> topline = (ad -> numlines - numlines) + 1;
    3905                   WinInvalidateRect(hwnd,
    3906                                     NULL,
    3907                                     FALSE);
     3500                  ad->cursored = ad->topline;
     3501                  if (ad->numlines - ad->topline < numlines)
     3502                    ad->topline = (ad->numlines - numlines) + 1;
     3503                  WinInvalidateRect(hwnd, NULL, FALSE);
    39083504                }
    39093505                break;
    39103506              }
    39113507            }
    3912             PostMsg(hwnd,
    3913                     UM_SETUP4,
    3914                     MPVOID,
    3915                     MPVOID);
    3916           }
    3917           DosReleaseMutexSem(ad -> ScanSem);
     3508            PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
     3509          }
     3510          DosReleaseMutexSem(ad->ScanSem);
    39183511        }
    39193512      }
    … …  
    39253518
    39263519        cp = PickCodepage(hwnd);
    3927         if (cp != -1)
    3928         {
    3929           ad -> fattrs.usCodePage = (USHORT) cp;
    3930           Codepage = ad -> fattrs.usCodePage;
     3520        if (cp != -1) {
     3521          ad->fattrs.usCodePage = (USHORT) cp;
     3522          Codepage = ad->fattrs.usCodePage;
    39313523          PrfWriteProfileData(fmprof,
    39323524                              appname,
    39333525                              "Viewer.Codepage",
    3934                               &ad -> fattrs.usCodePage,
    3935                               sizeof(USHORT));
    3936           GpiDeleteSetId(ad -> hps,
    3937                          FIXED_FONT_LCID);
    3938           GpiAssociate(ad -> hps, 0);
    3939           GpiDestroyPS(ad -> hps);
    3940           ad -> hps = InitWindow(hwnd);
    3941           WinSendMsg(hwnd,
    3942                      UM_SETUP3,
    3943                      MPVOID,
    3944                      MPVOID);
    3945           PostMsg(hwnd,
    3946                   UM_SETUP4,
    3947                   MPVOID,
    3948                   MPVOID);
    3949           WinInvalidateRect(hwnd,
    3950                             NULL,
    3951                             FALSE);
     3526                              &ad->fattrs.usCodePage, sizeof(USHORT));
     3527          GpiDeleteSetId(ad->hps, FIXED_FONT_LCID);
     3528          GpiAssociate(ad->hps, 0);
     3529          GpiDestroyPS(ad->hps);
     3530          ad->hps = InitWindow(hwnd);
     3531          WinSendMsg(hwnd, UM_SETUP3, MPVOID, MPVOID);
     3532          PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
     3533          WinInvalidateRect(hwnd, NULL, FALSE);
    39523534        }
    39533535      }
    … …  
    39633545        APIRET rc;
    39643546
    3965         rc = DosRequestMutexSem(ad -> ScanSem,
    3966                                 SEM_IMMEDIATE_RETURN);
    3967         if (!rc)
    3968         {
    3969           if (!ad -> busy)
    3970           {
    3971             ad -> cliptype = SHORT1FROMMP(mp1);
    3972             if (_beginthread(ClipboardThread,NULL,524288,(PVOID) hwnd) == -1)
    3973               Runtime_Error(pszSrcFile, __LINE__, GetPString(IDS_COULDNTSTARTTHREADTEXT));
    3974           }
    3975           DosReleaseMutexSem(ad -> ScanSem);
     3547        rc = DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN);
     3548        if (!rc) {
     3549          if (!ad->busy) {
     3550            ad->cliptype = SHORT1FROMMP(mp1);
     3551            if (_beginthread(ClipboardThread, NULL, 524288, (PVOID) hwnd) ==
     3552                -1)
     3553              Runtime_Error(pszSrcFile, __LINE__,
     3554                            GetPString(IDS_COULDNTSTARTTHREADTEXT));
     3555          }
     3556          DosReleaseMutexSem(ad->ScanSem);
    39763557        }
    39773558      }
    … …  
    39843565        APIRET rc;
    39853566
    3986         rc = DosRequestMutexSem(ad -> ScanSem,
    3987                                 SEM_IMMEDIATE_RETURN);
    3988         if (!rc)
    3989         {
    3990           if (!ad -> busy && ad -> markedlines)
    3991           {
     3567        rc = DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN);
     3568        if (!rc) {
     3569          if (!ad->busy && ad->markedlines) {
    39923570
    39933571            register ULONG x;
    39943572
    3995             for (x = 0; x < ad -> numlines; x++)
    3996             {
    3997               switch (SHORT1FROMMP(mp1))
    3998               {
     3573            for (x = 0; x < ad->numlines; x++) {
     3574              switch (SHORT1FROMMP(mp1)) {
    39993575              case IDM_SELECTALL:
    4000                 if (!(ad -> markedlines[x] & VF_SELECTED))
    4001                 {
    4002                   ad -> markedlines[x] |= VF_SELECTED;
    4003                   ad -> selected++;
     3576                if (!(ad->markedlines[x] & VF_SELECTED)) {
     3577                  ad->markedlines[x] |= VF_SELECTED;
     3578                  ad->selected++;
    40043579                }
    40053580                break;
    40063581              case IDM_DESELECTALL:
    4007                 if (ad -> markedlines[x] & VF_SELECTED)
    4008                 {
    4009                   ad -> markedlines[x] &= (~VF_SELECTED);
    4010                   ad -> selected--;
     3582                if (ad->markedlines[x] & VF_SELECTED) {
     3583                  ad->markedlines[x] &= (~VF_SELECTED);
     3584                  ad->selected--;
    40113585                }
    40123586                break;
    40133587              case IDM_INVERT:
    4014                 if (ad -> markedlines[x] & VF_SELECTED)
    4015                 {
    4016                   ad -> markedlines[x] &= (~VF_SELECTED);
    4017                   ad -> selected--;
     3588                if (ad->markedlines[x] & VF_SELECTED) {
     3589                  ad->markedlines[x] &= (~VF_SELECTED);
     3590                  ad->selected--;
    40183591                }
    4019                 else
    4020                 {
    4021                   ad -> markedlines[x] |= VF_SELECTED;
    4022                   ad -> selected++;
     3592                else {
     3593                  ad->markedlines[x] |= VF_SELECTED;
     3594                  ad->selected++;
    40233595                }
    40243596                break;
    … …  
    40283600            WinInvalidateRect(hwnd, NULL, FALSE);
    40293601          }
    4030           DosReleaseMutexSem(ad -> ScanSem);
     3602          DosReleaseMutexSem(ad->ScanSem);
    40313603        }
    40323604      }
    … …  
    40373609        APIRET rc;
    40383610
    4039         rc = DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN);
    4040         if (!rc)
    4041         {
    4042           if (!ad -> busy)
    4043           {
    4044             ad -> wrapon = ad -> wrapon ? FALSE : TRUE;
    4045             WrapOn = ad -> wrapon;
     3611        rc = DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN);
     3612        if (!rc) {
     3613          if (!ad->busy) {
     3614            ad->wrapon = ad->wrapon ? FALSE : TRUE;
     3615            WrapOn = ad->wrapon;
    40463616            PrfWriteProfileData(fmprof, appname, "Viewer.WrapOn",
    4047                                 &ad -> wrapon, sizeof(BOOL));
     3617                                &ad->wrapon, sizeof(BOOL));
    40483618            PostMsg(hwnd, UM_SETUP2, MPVOID, MPVOID);
    40493619            PostMsg(hwnd, UM_SETUP3, MPVOID, MPVOID);
    40503620            PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
    4051             if (WinSendDlgItemMsg(ad -> hwndFrame, NEWVIEW_LISTBOX,
     3621            if (WinSendDlgItemMsg(ad->hwndFrame, NEWVIEW_LISTBOX,
    40523622                                  LM_QUERYITEMCOUNT, MPVOID, MPVOID))
    4053               WinSendDlgItemMsg(ad -> hwndFrame, NEWVIEW_LISTBOX, LM_DELETEALL,
     3623              WinSendDlgItemMsg(ad->hwndFrame, NEWVIEW_LISTBOX, LM_DELETEALL,
    40543624                                MPVOID, MPVOID);
    4055             ad -> oldwidth = -1;
    4056             WinSendMsg(ad -> hvscroll, SBM_SETTHUMBSIZE,
    4057                        MPFROM2SHORT(1, 1),
    4058                        MPVOID);
    4059             WinSendMsg(ad -> hvscroll, SBM_SETSCROLLBAR,
     3625            ad->oldwidth = -1;
     3626            WinSendMsg(ad->hvscroll, SBM_SETTHUMBSIZE,
     3627                       MPFROM2SHORT(1, 1), MPVOID);
     3628            WinSendMsg(ad->hvscroll, SBM_SETSCROLLBAR,
    40603629                       MPFROMSHORT(1), MPFROM2SHORT(1, 1));
    4061             WinSendMsg(ad -> hhscroll, SBM_SETTHUMBSIZE,
    4062                        MPFROM2SHORT(1, 1),
    4063                        MPVOID);
    4064             WinSendMsg(ad -> hhscroll, SBM_SETSCROLLBAR,
     3630            WinSendMsg(ad->hhscroll, SBM_SETTHUMBSIZE,
     3631                       MPFROM2SHORT(1, 1), MPVOID);
     3632            WinSendMsg(ad->hhscroll, SBM_SETSCROLLBAR,
    40653633                       MPFROMSHORT(1), MPFROM2SHORT(1, 1));
    4066             WinSendMsg(ad -> hwndFrame, WM_UPDATEFRAME,
     3634            WinSendMsg(ad->hwndFrame, WM_UPDATEFRAME,
    40673635                       MPFROMLONG(FCF_SIZEBORDER), MPVOID);
    40683636            WinInvalidateRect(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
    40693637                                              NEWVIEW_DRAG), NULL, FALSE);
    4070             WinInvalidateRect(ad -> hhscroll, NULL, FALSE);
    4071           }
    4072           DosReleaseMutexSem(ad -> ScanSem);
     3638            WinInvalidateRect(ad->hhscroll, NULL, FALSE);
     3639          }
     3640          DosReleaseMutexSem(ad->ScanSem);
    40733641        }
    40743642      }
    … …  
    40793647        APIRET rc;
    40803648
    4081         rc = DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN);
    4082         if (!rc)
    4083         {
    4084           if (!ad -> busy)
    4085           {
    4086             ad -> hex = (ad -> hex) ? FALSE : TRUE;
     3649        rc = DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN);
     3650        if (!rc) {
     3651          if (!ad->busy) {
     3652            ad->hex = (ad->hex) ? FALSE : TRUE;
    40873653            WinEnableWindow(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
    4088                                             IDM_NEXTBLANKLINE), !ad -> hex);
     3654                                            IDM_NEXTBLANKLINE), !ad->hex);
    40893655            WinEnableWindow(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
    4090                                             IDM_PREVBLANKLINE), !ad -> hex);
     3656                                            IDM_PREVBLANKLINE), !ad->hex);
    40913657            PostMsg(hwnd, UM_SETUP2, MPVOID, MPVOID);
    40923658            PostMsg(hwnd, UM_SETUP3, MPVOID, MPVOID);
    40933659            PostMsg(hwnd, UM_SETUP4, MPVOID, MPVOID);
    4094             if (WinSendDlgItemMsg(ad -> hwndFrame, NEWVIEW_LISTBOX,
     3660            if (WinSendDlgItemMsg(ad->hwndFrame, NEWVIEW_LISTBOX,
    40953661                                  LM_QUERYITEMCOUNT, MPVOID, MPVOID))
    4096               WinSendDlgItemMsg(ad -> hwndFrame, NEWVIEW_LISTBOX, LM_DELETEALL,
     3662              WinSendDlgItemMsg(ad->hwndFrame, NEWVIEW_LISTBOX, LM_DELETEALL,
    40973663                                MPVOID, MPVOID);
    4098             ad -> oldwidth = -1;
    4099             WinSendMsg(ad -> hvscroll, SBM_SETTHUMBSIZE,
    4100                        MPFROM2SHORT(1, 1),
    4101                        MPVOID);
    4102             WinSendMsg(ad -> hvscroll, SBM_SETSCROLLBAR,
     3664            ad->oldwidth = -1;
     3665            WinSendMsg(ad->hvscroll, SBM_SETTHUMBSIZE,
     3666                       MPFROM2SHORT(1, 1), MPVOID);
     3667            WinSendMsg(ad->hvscroll, SBM_SETSCROLLBAR,
    41033668                       MPFROMSHORT(1), MPFROM2SHORT(1, 1));
    4104             WinSendMsg(ad -> hhscroll, SBM_SETTHUMBSIZE,
    4105                        MPFROM2SHORT(1, 1),
    4106                        MPVOID);
    4107             WinSendMsg(ad -> hhscroll, SBM_SETSCROLLBAR,
     3669            WinSendMsg(ad->hhscroll, SBM_SETTHUMBSIZE,
     3670                       MPFROM2SHORT(1, 1), MPVOID);
     3671            WinSendMsg(ad->hhscroll, SBM_SETSCROLLBAR,
    41083672                       MPFROMSHORT(1), MPFROM2SHORT(1, 1));
    4109             WinSendMsg(ad -> hwndFrame, WM_UPDATEFRAME,
     3673            WinSendMsg(ad->hwndFrame, WM_UPDATEFRAME,
    41103674                       MPFROMLONG(FCF_SIZEBORDER), MPVOID);
    41113675            WinInvalidateRect(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
    41123676                                              NEWVIEW_DRAG), NULL, FALSE);
    4113             WinInvalidateRect(ad -> hhscroll, NULL, FALSE);
    4114           }
    4115           DosReleaseMutexSem(ad -> ScanSem);
     3677            WinInvalidateRect(ad->hhscroll, NULL, FALSE);
     3678          }
     3679          DosReleaseMutexSem(ad->ScanSem);
    41163680        }
    41173681      }
    … …  
    41223686        APIRET rc;
    41233687
    4124         rc = DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN);
    4125         if (!rc)
    4126         {
    4127           SetMLEFont(hwnd, &ad -> fattrs, 11);
     3688        rc = DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN);
     3689        if (!rc) {
     3690          SetMLEFont(hwnd, &ad->fattrs, 11);
    41283691          PrfWriteProfileData(fmprof, appname, "Viewer.Fattrs",
    4129                               &ad -> fattrs, sizeof(FATTRS));
    4130           Fattrs = ad -> fattrs;
    4131           GpiDeleteSetId(ad -> hps, FIXED_FONT_LCID);
    4132           GpiAssociate(ad -> hps, 0);
    4133           GpiDestroyPS(ad -> hps);
    4134           ad -> hps = InitWindow(hwnd);
    4135           DosReleaseMutexSem(ad -> ScanSem);
     3692                              &ad->fattrs, sizeof(FATTRS));
     3693          Fattrs = ad->fattrs;
     3694          GpiDeleteSetId(ad->hps, FIXED_FONT_LCID);
     3695          GpiAssociate(ad->hps, 0);
     3696          GpiDestroyPS(ad->hps);
     3697          ad->hps = InitWindow(hwnd);
     3698          DosReleaseMutexSem(ad->ScanSem);
    41363699          WinSendMsg(hwnd, UM_SETUP2, MPVOID, MPVOID);
    41373700          WinInvalidateRect(hwnd, NULL, FALSE);
    … …  
    41433706      if (hwndHelp)
    41443707        WinSendMsg(hwndHelp, HM_DISPLAY_HELP,
    4145                    MPFROM2SHORT(HELP_NEWVIEW, 0),
    4146                    MPFROMSHORT(HM_RESOURCEID));
     3708                   MPFROM2SHORT(HELP_NEWVIEW, 0), MPFROMSHORT(HM_RESOURCEID));
    41473709      break;
    41483710    }
    … …  
    41523714    if (mp2)
    41533715      WinSendMsg(hwnd, UM_SETUP5, MPVOID, MPVOID);
    4154     if (mp2 && ad && ad -> needrefreshing && !ad -> stopflag &&
    4155         !DosRequestMutexSem(ad -> ScanSem, SEM_IMMEDIATE_RETURN))
    4156     {
    4157       ad -> needrefreshing = FALSE;
    4158       DosReleaseMutexSem(ad -> ScanSem);
     3716    if (mp2 && ad && ad->needrefreshing && !ad->stopflag &&
     3717        !DosRequestMutexSem(ad->ScanSem, SEM_IMMEDIATE_RETURN)) {
     3718      ad->needrefreshing = FALSE;
     3719      DosReleaseMutexSem(ad->ScanSem);
    41593720      WinInvalidateRect(hwnd, NULL, TRUE);
    41603721    }
    … …  
    41623723
    41633724  case WM_SIZE:
    4164     if (SHORT1FROMMP(mp2) && SHORT2FROMMP(mp2))
    4165     {
     3725    if (SHORT1FROMMP(mp2) && SHORT2FROMMP(mp2)) {
    41663726      PostMsg(hwnd, UM_SETUP2, MPVOID, MPVOID);
    41673727      PostMsg(hwnd, UM_SETUP3, MPVOID, MPVOID);
    … …  
    41703730
    41713731  case WM_SAVEAPPLICATION:
    4172     if (ad && ParentIsDesktop(hwnd, ad -> hwndParent))
    4173     {
     3732    if (ad && ParentIsDesktop(hwnd, ad->hwndParent)) {
    41743733
    41753734      SWP swp;
    41763735
    4177       WinQueryWindowPos(ad -> hwndFrame, &swp);
     3736      WinQueryWindowPos(ad->hwndFrame, &swp);
    41783737      if (!(swp.fl & (SWP_HIDE | SWP_MINIMIZE | SWP_MAXIMIZE)))
    41793738        PrfWriteProfileData(fmprof,
    4180                             appname,
    4181                             "NewViewSizePos",
    4182                             &swp,
    4183                             sizeof(swp));
     3739                            appname, "NewViewSizePos", &swp, sizeof(swp));
    41843740    }
    41853741    break;
    … …  
    41873743  case WM_CLOSE:
    41883744    if (ad)
    4189       ad -> stopflag = 1;
     3745      ad->stopflag = 1;
    41903746    WinDestroyWindow(WinQueryWindow(hwnd, QW_PARENT));
    41913747    return 0;
    … …  
    41943750    {
    41953751      BOOL dontclose = FALSE;
    4196       HWND hwndRestore = (HWND)0;
     3752      HWND hwndRestore = (HWND) 0;
    41973753
    41983754      WinStopTimer(WinQueryAnchorBlock(hwnd), hwnd, ID_TIMER5);
    4199       if (ad)
    4200       {
    4201         ad -> stopflag = 1;
    4202         if (ad -> ScanSem)
    4203         {
    4204           DosRequestMutexSem(ad -> ScanSem, 15000L);
    4205           DosCloseMutexSem(ad -> ScanSem);
    4206         }
    4207         if (ad -> busy)
     3755      if (ad) {
     3756        ad->stopflag = 1;
     3757        if (ad->ScanSem) {
     3758          DosRequestMutexSem(ad->ScanSem, 15000L);
     3759          DosCloseMutexSem(ad->ScanSem);
     3760        }
     3761        if (ad->busy)
    42083762          DosSleep(128L);
    4209         if (ad -> hps)
    4210         {
    4211           GpiDeleteSetId(ad -> hps, FIXED_FONT_LCID);
    4212           GpiAssociate(ad -> hps, 0);
    4213           GpiDestroyPS(ad -> hps);
    4214         }
    4215         hwndRestore = ad -> hwndRestore;
    4216         dontclose = ((ad -> flags & 4) != 0) ? TRUE : FALSE;
     3763        if (ad->hps) {
     3764          GpiDeleteSetId(ad->hps, FIXED_FONT_LCID);
     3765          GpiAssociate(ad->hps, 0);
     3766          GpiDestroyPS(ad->hps);
     3767        }
     3768        hwndRestore = ad->hwndRestore;
     3769        dontclose = ((ad->flags & 4) != 0) ? TRUE : FALSE;
    42173770        FreeViewerMem(hwnd);
    42183771        WinSetWindowPtr(hwnd, QWL_USER, NULL);
    42193772        free(ad);
    42203773      }
    4221       if (hwndRestore && hwndRestore != HWND_DESKTOP)
    4222       {
     3774      if (hwndRestore && hwndRestore != HWND_DESKTOP) {
    42233775
    42243776        ULONG fl = SWP_SHOW | SWP_ACTIVATE | SWP_ZORDER;
    42253777        SWP swp;
    42263778
    4227         if (WinQueryWindowPos(hwndRestore, &swp))
    4228         {
     3779        if (WinQueryWindowPos(hwndRestore, &swp)) {
    42293780          if (!(swp.fl & SWP_MAXIMIZE))
    42303781            fl |= SWP_RESTORE;
    … …  
    42343785      if (!dontclose &&
    42353786          ParentIsDesktop(hwnd, WinQueryWindow(WinQueryWindow(hwnd,
    4236                                                     QW_PARENT), QW_PARENT)))
    4237       {
    4238         if (!PostMsg((HWND)0, WM_QUIT, MPVOID, MPVOID))
     3787                                                              QW_PARENT),
     3788                                               QW_PARENT))) {
     3789        if (!PostMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID))
    42393790          DosExit(EXIT_PROCESS, 1);
    42403791      }
    … …  
    42493800                 HWND hwndRestore)
    42503801{
    4251   HWND hwndFrame = (HWND)0, hwndClient;
     3802  HWND hwndFrame = (HWND) 0, hwndClient;
    42523803  VIEWDATA *ad;
    42533804  ULONG FrameFlags = FCF_TITLEBAR | FCF_SYSMENU |
    4254   FCF_SIZEBORDER | FCF_MINMAX |
    4255   FCF_NOBYTEALIGN | FCF_VERTSCROLL |
    4256   FCF_MENU | FCF_ICON |
    4257   FCF_ACCELTABLE | FCF_HORZSCROLL;
     3805    FCF_SIZEBORDER | FCF_MINMAX |
     3806    FCF_NOBYTEALIGN | FCF_VERTSCROLL |
     3807    FCF_MENU | FCF_ICON | FCF_ACCELTABLE | FCF_HORZSCROLL;
    42583808
    42593809  if (strcmp(realappname, FM3Str))
    … …  
    42683818                                 GetPString(IDS_FM2VIEWERTITLETEXT),
    42693819                                 fwsAnimate,
    4270                                  FM3ModHandle,
    4271                                  NEWVIEW_FRAME,
    4272                                  &hwndClient);
    4273   if (hwndFrame)
    4274   {
     3820                                 FM3ModHandle, NEWVIEW_FRAME, &hwndClient);
     3821  if (hwndFrame) {
    42753822
    42763823    HWND hwndMenu = WinWindowFromID(hwndFrame, FID_MENU);
    42773824
    4278     if (!fToolbar && hwndMenu)
    4279     {
     3825    if (!fToolbar && hwndMenu) {
    42803826      WinSendMsg(hwndMenu, MM_DELETEITEM,
    42813827                 MPFROM2SHORT(IDM_FINDFIRST, FALSE), MPVOID);
    … …  
    42873833                 MPFROM2SHORT(IDM_SAVETOCLIP, FALSE), MPVOID);
    42883834    }
    4289     ad = xmallocz(sizeof(VIEWDATA),pszSrcFile,__LINE__);
     3835    ad = xmallocz(sizeof(VIEWDATA), pszSrcFile, __LINE__);
    42903836    if (!ad) {
    42913837      WinDestroyWindow(hwndFrame);
    4292       hwndFrame = (HWND)0;
     3838      hwndFrame = (HWND) 0;
    42933839    }
    42943840    else {
    4295       ad -> size = sizeof(VIEWDATA);
    4296       ad -> stopflag = 0;
    4297       ad -> multiplier = 1;
    4298       ad -> hwndRestore = hwndRestore;
    4299       ad -> hwndFrame = hwndFrame;
    4300       ad -> hwndParent = hwndParent;
    4301       ad -> clientfocused = TRUE;
    4302       ad -> oldwidth = -1;
    4303       strcpy(ad -> filename, filename);
    4304       ad -> flags = flags;
    4305       if (ad -> flags & 16)
    4306         ad -> hex = TRUE;
     3841      ad->size = sizeof(VIEWDATA);
     3842      ad->stopflag = 0;
     3843      ad->multiplier = 1;
     3844      ad->hwndRestore = hwndRestore;
     3845      ad->hwndFrame = hwndFrame;
     3846      ad->hwndParent = hwndParent;
     3847      ad->clientfocused = TRUE;
     3848      ad->oldwidth = -1;
     3849      strcpy(ad->filename, filename);
     3850      ad->flags = flags;
     3851      if (ad->flags & 16)
     3852        ad->hex = TRUE;
    43073853      WinSetWindowPtr(hwndClient, QWL_USER, (PVOID) ad);
    4308       if (Firsttime)
    4309       {
     3854      if (Firsttime) {
    43103855
    43113856        ULONG size;
    … …  
    43473892      }
    43483893      {
    4349         ULONG size = sizeof(ad -> searchtext);
     3894        ULONG size = sizeof(ad->searchtext);
    43503895
    43513896        PrfQueryProfileData(fmprof, appname, "Viewer.Searchtext",
    4352                             (PVOID) ad -> searchtext, &size);
    4353         ad -> searchtext[sizeof(ad -> searchtext) - 1] = 0;
    4354       }
    4355       ad -> sensitive = Sensitive;
    4356       ad -> literalsearch = LiteralSearch;
    4357       ad -> fattrs = Fattrs;
    4358       ad -> alsoselect = AlsoSelect;
    4359       ad -> fattrs.usCodePage = Codepage;
    4360       ad -> wrapon = WrapOn;
    4361       ad -> ignorehttp = IgnoreHTTP;
    4362       ad -> ignoreftp = IgnoreFTP;
    4363       memcpy(ad -> colors, Colors, sizeof(LONG) * COLORS_MAX);
     3897                            (PVOID) ad->searchtext, &size);
     3898        ad->searchtext[sizeof(ad->searchtext) - 1] = 0;
     3899      }
     3900      ad->sensitive = Sensitive;
     3901      ad->literalsearch = LiteralSearch;
     3902      ad->fattrs = Fattrs;
     3903      ad->alsoselect = AlsoSelect;
     3904      ad->fattrs.usCodePage = Codepage;
     3905      ad->wrapon = WrapOn;
     3906      ad->ignorehttp = IgnoreHTTP;
     3907      ad->ignoreftp = IgnoreFTP;
     3908      memcpy(ad->colors, Colors, sizeof(LONG) * COLORS_MAX);
    43643909      WinSetWindowPtr(hwndClient, QWL_USER, (PVOID) ad);
    43653910      if (!WinSendMsg(hwndClient, UM_SETUP, MPVOID, MPVOID))
    4366         hwndFrame = (HWND)0;
     3911        hwndFrame = (HWND) 0;
    43673912      else {
    4368         // DosSleep(64L);
    4369         if (!(FrameFlags & FCF_TASKLIST) && !(flags & 2))
    4370         {
     3913        // DosSleep(64L);
     3914        if (!(FrameFlags & FCF_TASKLIST) && !(flags & 2)) {
    43713915          SWP swp;
     3916
    43723917          FillClient(hwndParent, &swp, NULL, FALSE);
    43733918          WinSetWindowPos(hwndFrame, HWND_TOP, swp.x, swp.y, swp.cx, swp.cy,
    … …  
    43753920                          SWP_ZORDER | SWP_ACTIVATE);
    43763921        }
    4377         else if (FrameFlags & FCF_TASKLIST)
    4378         {
     3922        else if (FrameFlags & FCF_TASKLIST) {
    43793923
    43803924          SWP swp, swpD;
    … …  
    43843928          WinQueryTaskSizePos(WinQueryAnchorBlock(hwndFrame), 0, &swp);
    43853929          if (PrfQueryProfileData(fmprof,
    4386                                   appname,
    4387                                   "NewViewSizePos",
    4388                                   &swpD,
    4389                                   &size))
    4390           {
     3930                                  appname, "NewViewSizePos", &swpD, &size)) {
    43913931            cxScreen = WinQuerySysValue(HWND_DESKTOP, SV_CXSCREEN);
    43923932            cyScreen = WinQuerySysValue(HWND_DESKTOP, SV_CYSCREEN);
Note: See TracChangeset for help on using the changeset viewer.