Changeset 551 for trunk/dll/autoview.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/autoview.c

    r531 r551  
    2020***********************************************************************/
    2121
    22 
    2322#define INCL_DOS
    2423#define INCL_WIN
    … …  
    4746static CHAR currfile[CCHMAXPATH];
    4847
    49 BOOL WriteEA (HWND hwnd,CHAR *filename,CHAR *eaname,USHORT type,CHAR *data)
     48BOOL WriteEA(HWND hwnd, CHAR * filename, CHAR * eaname, USHORT type,
     49             CHAR * data)
    5050{
    5151  /* save an ea to disk */
    5252
    5353  FEA2LIST *pfealist = NULL;
    54   EAOP2     eaop;
    55   APIRET    rc;
    56   ULONG     ealen;
    57   USHORT    len,*num,*plen,usCodepage;
    58   CHAR     *p,*eaval;
    59   BOOL      ret = FALSE;
    60 
    61   if(!filename || !eaname)
     54  EAOP2 eaop;
     55  APIRET rc;
     56  ULONG ealen;
     57  USHORT len, *num, *plen, usCodepage;
     58  CHAR *p, *eaval;
     59  BOOL ret = FALSE;
     60
     61  if (!filename || !eaname)
    6262    return ret;
    63   usCodepage = (USHORT)WinQueryCp(WinQueryWindowULong(hwnd,QWL_HMQ));
     63  usCodepage = (USHORT) WinQueryCp(WinQueryWindowULong(hwnd, QWL_HMQ));
    6464  len = (data) ? strlen(data) : 0;
    65   ealen = sizeof(FEA2LIST) + 24L + strlen(eaname) + 1L +
    66           (ULONG)len + 4L;
    67   switch(type) {
     65  ealen = sizeof(FEA2LIST) + 24L + strlen(eaname) + 1L + (ULONG) len + 4L;
     66  switch (type) {
     67  case EAT_EA:
     68  case EAT_ASCII:
     69    break;
     70  case EAT_MVST:
     71    if (data) {
     72      ealen += sizeof(USHORT) * 5;
     73      p = data;
     74      while (*p) {
     75        if (*p == '\n' && *(p + 1))
     76          ealen += sizeof(USHORT);
     77        p++;
     78      }
     79    }
     80    break;
     81  case EAT_MVMT:
     82    if (data) {
     83      ealen += sizeof(USHORT) * 5;
     84      p = data;
     85      while (*p) {
     86        if (*p == '\n' && *(p + 1))
     87          ealen += (sizeof(USHORT) * 2);
     88        p++;
     89      }
     90    }
     91    break;
     92  default:
     93    return ret;
     94  }
     95
     96  rc = DosAllocMem((PPVOID) & pfealist, ealen, PAG_COMMIT | PAG_READ |
     97                   PAG_WRITE | OBJ_TILE);
     98  if (rc || !pfealist)
     99    Dos_Error(MB_CANCEL, rc, hwnd, pszSrcFile, __LINE__,
     100              GetPString(IDS_OUTOFMEMORY));
     101  else {
     102    memset(pfealist, 0, ealen);
     103    pfealist->list[0].cbName = strlen(eaname);
     104    memcpy(pfealist->list[0].szName, eaname, pfealist->list[0].cbName + 1);
     105    eaval = pfealist->list[0].szName + pfealist->list[0].cbName + 1;
     106    switch (type) {
    68107    case EAT_EA:
    69108    case EAT_ASCII:
     109      if (data) {
     110        *(USHORT *) eaval = (USHORT) type;
     111        eaval += sizeof(USHORT);
     112        *(USHORT *) eaval = (USHORT) len;
     113        eaval += sizeof(USHORT);
     114        memcpy(eaval, data, len);
     115        eaval += len;
     116      }
    70117      break;
    71118    case EAT_MVST:
    72       if(data) {
    73         ealen += sizeof(USHORT) * 5;
    74         p = data;
    75         while(*p) {
    76           if(*p == '\n' && *(p + 1))
    77             ealen += sizeof(USHORT);
    78           p++;
    79         }
     119      if (data) {
     120        *(USHORT *) eaval = (USHORT) EAT_MVST;
     121        eaval += sizeof(USHORT);
     122        *(USHORT *) eaval = usCodepage;
     123        eaval += sizeof(USHORT);
     124        num = (USHORT *) eaval;
     125        *num = 0;
     126        eaval += sizeof(USHORT);
     127        *(USHORT *) eaval = (USHORT) EAT_ASCII;
     128        eaval += sizeof(USHORT);
     129        plen = (USHORT *) eaval;
     130        *plen = 0;
     131        eaval += sizeof(USHORT);
     132        p = data;
     133        while (*p) {
     134          while (*p) {
     135            if (*p == '\n') {
     136              p++;
     137              break;
     138            }
     139            *eaval++ = *p++;
     140            (*plen)++;
     141          }
     142          if (*p || *plen)
     143            (*num)++;
     144          if (*p) {
     145            plen = (USHORT *) eaval;
     146            *plen = 0;
     147            eaval += sizeof(USHORT);
     148          }
     149        }
    80150      }
    81151      break;
    82152    case EAT_MVMT:
    83       if(data) {
    84         ealen += sizeof(USHORT) * 5;
    85         p = data;
    86         while(*p) {
    87           if(*p == '\n' && *(p + 1))
    88             ealen += (sizeof(USHORT) * 2);
    89           p++;
    90         }
    91       }
    92       break;
    93     default:
    94       return ret;
    95   }
    96 
    97   rc = DosAllocMem((PPVOID)&pfealist,ealen,PAG_COMMIT | PAG_READ |
    98                    PAG_WRITE | OBJ_TILE);
    99   if (rc || !pfealist)
    100     Dos_Error(MB_CANCEL,rc,hwnd,pszSrcFile,__LINE__,GetPString(IDS_OUTOFMEMORY));
    101   else {
    102     memset(pfealist,0,ealen);
    103     pfealist->list[0].cbName = strlen(eaname);
    104     memcpy(pfealist->list[0].szName,eaname,pfealist->list[0].cbName + 1);
    105     eaval = pfealist->list[0].szName + pfealist->list[0].cbName + 1;
    106     switch(type) {
    107       case EAT_EA:
    108       case EAT_ASCII:
    109         if(data) {
    110           *(USHORT *)eaval = (USHORT)type;
    111           eaval += sizeof(USHORT);
    112           *(USHORT *)eaval = (USHORT)len;
    113           eaval += sizeof(USHORT);
    114           memcpy(eaval,data,len);
    115           eaval += len;
    116         }
    117         break;
    118       case EAT_MVST:
    119         if(data) {
    120           *(USHORT *)eaval = (USHORT)EAT_MVST;
    121           eaval += sizeof(USHORT);
    122           *(USHORT *)eaval = usCodepage;
    123           eaval += sizeof(USHORT);
    124           num = (USHORT *)eaval;
    125           *num = 0;
    126           eaval += sizeof(USHORT);
    127           *(USHORT *)eaval = (USHORT)EAT_ASCII;
    128           eaval += sizeof(USHORT);
    129           plen = (USHORT *)eaval;
    130           *plen = 0;
    131           eaval += sizeof(USHORT);
    132           p = data;
    133           while(*p) {
    134             while(*p) {
    135               if(*p == '\n') {
    136                 p++;
    137                 break;
    138               }
    139               *eaval++ = *p++;
    140               (*plen)++;
    141             }
    142             if(*p || *plen)
    143               (*num)++;
    144             if(*p) {
    145               plen = (USHORT *)eaval;
    146               *plen = 0;
    147               eaval += sizeof(USHORT);
    148             }
    149           }
    150         }
    151         break;
    152       case EAT_MVMT:
    153         if(data) {
    154           *(USHORT *)eaval = (USHORT)EAT_MVMT;
    155           eaval += sizeof(USHORT);
    156           *(USHORT *)eaval = usCodepage;
    157           eaval += sizeof(USHORT);
    158           num = (USHORT *)eaval;
    159           *num = 0;
    160           eaval += sizeof(USHORT);
    161           *(USHORT *)eaval = (USHORT)EAT_ASCII;
    162           eaval += sizeof(USHORT);
    163           plen = (USHORT *)eaval;
    164           *plen = 0;
    165           eaval += sizeof(USHORT);
    166           p = data;
    167           while(*p) {
    168             while(*p) {
    169               if(*p == '\n') {
    170                 p++;
    171                 break;
    172               }
    173               *eaval++ = *p++;
    174               (*plen)++;
    175             }
    176             if(*p || *plen)
    177               (*num)++;
    178             if(*p) {
    179               *(USHORT *)eaval = (USHORT)EAT_ASCII;
    180               eaval += sizeof(USHORT);
    181               plen = (USHORT *)eaval;
    182               *plen = 0;
    183               eaval += sizeof(USHORT);
    184             }
    185           }
    186         }
    187         break;
    188     }
    189     pfealist->list[0].cbValue = (ULONG)(eaval -
    190                                 (pfealist->list[0].szName +
    191                                  pfealist->list[0].cbName + 1));
    192     memset(&eaop,0,sizeof(eaop));
     153      if (data) {
     154        *(USHORT *) eaval = (USHORT) EAT_MVMT;
     155        eaval += sizeof(USHORT);
     156        *(USHORT *) eaval = usCodepage;
     157        eaval += sizeof(USHORT);
     158        num = (USHORT *) eaval;
     159        *num = 0;
     160        eaval += sizeof(USHORT);
     161        *(USHORT *) eaval = (USHORT) EAT_ASCII;
     162        eaval += sizeof(USHORT);
     163        plen = (USHORT *) eaval;
     164        *plen = 0;
     165        eaval += sizeof(USHORT);
     166        p = data;
     167        while (*p) {
     168          while (*p) {
     169            if (*p == '\n') {
     170              p++;
     171              break;
     172            }
     173            *eaval++ = *p++;
     174            (*plen)++;
     175          }
     176          if (*p || *plen)
     177            (*num)++;
     178          if (*p) {
     179            *(USHORT *) eaval = (USHORT) EAT_ASCII;
     180            eaval += sizeof(USHORT);
     181            plen = (USHORT *) eaval;
     182            *plen = 0;
     183            eaval += sizeof(USHORT);
     184          }
     185        }
     186      }
     187      break;
     188    }
     189    pfealist->list[0].cbValue = (ULONG) (eaval -
     190                                         (pfealist->list[0].szName +
     191                                          pfealist->list[0].cbName + 1));
     192    memset(&eaop, 0, sizeof(eaop));
    193193    eaop.fpFEA2List = pfealist;
    194     pfealist->cbList = 13L + (ULONG)pfealist->list[0].cbName +
    195                        (ULONG)pfealist->list[0].cbValue;
    196     rc = DosSetPathInfo(filename,FIL_QUERYEASIZE,(PVOID)&eaop,
    197                         (ULONG)sizeof(EAOP2),DSPI_WRTTHRU);
     194    pfealist->cbList = 13L + (ULONG) pfealist->list[0].cbName +
     195      (ULONG) pfealist->list[0].cbValue;
     196    rc = DosSetPathInfo(filename, FIL_QUERYEASIZE, (PVOID) & eaop,
     197                        (ULONG) sizeof(EAOP2), DSPI_WRTTHRU);
    198198    DosFreeMem(pfealist);
    199     if(!rc)
     199    if (!rc)
    200200      ret = TRUE;
    201201  }
    … …  
    203203}
    204204
    205 
    206 BOOL PutComments (HWND hwnd,CHAR *filename,CHAR *comments)
     205BOOL PutComments(HWND hwnd, CHAR * filename, CHAR * comments)
    207206{
    208207  register CHAR *p;
    209208
    210   if(comments) {  /* check -- is it empty? */
     209  if (comments) {                       /* check -- is it empty? */
    211210    p = comments;
    212     while(*p && isspace(*p))
     211    while (*p && isspace(*p))
    213212      p++;
    214     if(!*p)
     213    if (!*p)
    215214      comments = NULL;
    216215  }
    217   return WriteEA(hwnd,filename,".COMMENTS",EAT_MVMT,comments);
     216  return WriteEA(hwnd, filename, ".COMMENTS", EAT_MVMT, comments);
    218217}
    219218
    220219static PSZ pszBufOvfMsg = "Buffer overflow";
    221220
    222 ULONG CreateHexDump (CHAR *pchInBuf,ULONG cbInBuf,
    223                      CHAR *pchOutBuf,ULONG cbOutBuf,
    224                      ULONG cOffset,BOOL fLongAddr)
     221ULONG CreateHexDump(CHAR * pchInBuf, ULONG cbInBuf,
     222                    CHAR * pchOutBuf, ULONG cbOutBuf,
     223                    ULONG cOffset, BOOL fLongAddr)
    225224{
    226   register CHAR  *pchIn,*pchReset,*pchOut;
    227   register ULONG  ibIn = 0,ibIn2,ibInFill;
     225  register CHAR *pchIn, *pchReset, *pchOut;
     226  register ULONG ibIn = 0, ibIn2, ibInFill;
    228227  ULONG cbOutLine = 6 + (fLongAddr ? 4 : 0) + 16 * 3 + 1 + 16 + 1;
    229228
    230   if(pchInBuf && cbInBuf && pchOutBuf && cbOutBuf) {
     229  if (pchInBuf && cbInBuf && pchOutBuf && cbOutBuf) {
    231230    pchIn = pchInBuf;
    232231    pchOut = pchOutBuf;
    233     if(cOffset)
     232    if (cOffset)
    234233      *pchOut++ = '\n';
    235234    while (ibIn < cbInBuf) {
    236235      if (pchOut - pchOutBuf + cbOutLine >= cbOutBuf) {
    237         Runtime_Error(pszSrcFile, __LINE__, pszBufOvfMsg);
     236        Runtime_Error(pszSrcFile, __LINE__, pszBufOvfMsg);
    238237        break;
    239238      }
    240239      pchReset = pchIn;
    241240      ibIn2 = ibIn;
    242       if(fLongAddr)
    243         sprintf(pchOut,"%08lx  ",ibIn + cOffset);
     241      if (fLongAddr)
     242        sprintf(pchOut, "%08lx  ", ibIn + cOffset);
    244243      else
    245         sprintf(pchOut,"%04lx  ",ibIn + cOffset);
     244        sprintf(pchOut, "%04lx  ", ibIn + cOffset);
    246245      pchOut += 6 + (fLongAddr ? 4 : 0);
    247246      do {
    248         sprintf(pchOut,"%02hx ",*pchIn);
    249         pchOut += 3;
    250         pchIn++;
    251         ibIn++;
    252       } while(ibIn < cbInBuf && (ibIn % 16));
    253       if(ibIn % 16) {
    254         ibInFill = ibIn;
    255         while(ibInFill % 16) {
    256           *pchOut++ = ' ';
    257           *pchOut++ = ' ';
    258           *pchOut++ = ' ';
    259           ibInFill++;
    260         }
     247        sprintf(pchOut, "%02hx ", *pchIn);
     248        pchOut += 3;
     249        pchIn++;
     250        ibIn++;
     251      } while (ibIn < cbInBuf && (ibIn % 16));
     252      if (ibIn % 16) {
     253        ibInFill = ibIn;
     254        while (ibInFill % 16) {
     255          *pchOut++ = ' ';
     256          *pchOut++ = ' ';
     257          *pchOut++ = ' ';
     258          ibInFill++;
     259        }
    261260      }
    262261      *pchOut++ = ' ';
    263262      pchIn = pchReset;
    264263      do {
    265         if(*pchIn && *pchIn != '\n' && *pchIn != '\r' && *pchIn != '\t' && *pchIn != '\x1a')
    266           *pchOut++ = *pchIn++;
    267         else {
    268           *pchOut++ = '.';
    269           pchIn++;
    270         }
    271         ibIn2++;
    272       } while(ibIn2 < ibIn);
    273       if(ibIn < cbInBuf)
    274         *pchOut++ = '\n';
    275     } // while ibIn
     264        if (*pchIn && *pchIn != '\n' && *pchIn != '\r' && *pchIn != '\t'
     265            && *pchIn != '\x1a')
     266          *pchOut++ = *pchIn++;
     267        else {
     268          *pchOut++ = '.';
     269          pchIn++;
     270        }
     271        ibIn2++;
     272      } while (ibIn2 < ibIn);
     273      if (ibIn < cbInBuf)
     274        *pchOut++ = '\n';
     275    }                                   // while ibIn
    276276    *pchOut = 0;
    277     return (ULONG)(pchOut - pchOutBuf);
     277    return (ULONG) (pchOut - pchOutBuf);
    278278  }
    279279  return 0L;
    280280}
    281281
    282 
    283 MRESULT EXPENTRY AutoObjProc (HWND hwnd,ULONG msg,MPARAM mp1,MPARAM mp2)
     282MRESULT EXPENTRY AutoObjProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
    284283{
    285   switch(msg) {
    286     case UM_LOADFILE:
    287       *currfile = 0;
    288       stopflag--;
    289       if(fAutoView) {
    290         WinSetWindowText((fComments) ? hwndAutoMLE : hwndAutoview,"");
    291         MLEsetreadonly(hwndAutoMLE,TRUE);
    292         MLEsetchanged(hwndAutoMLE,FALSE);
    293       }
    294       if(mp1) {
    295         if(fAutoView) {
    296           strcpy(currfile,(CHAR *)mp1);
    297           if(!fComments) {
    298             if(IsFile((CHAR *)mp1) == 1) {
    299 
    300               HFILE     handle;
    301               ULONG     action,olen,ibufflen,obufflen,l;
    302               CHAR     *ibuff,*obuff,*p,buffer[80];
    303               ARC_TYPE *info;
    304 
    305               if(!DosOpen((CHAR *)mp1,
    306                           &handle,
    307                           &action,
    308                           0L,
    309                           0L,
    310                           OPEN_ACTION_FAIL_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS,
    311                           OPEN_FLAGS_FAIL_ON_ERROR | OPEN_FLAGS_NOINHERIT |
    312                           OPEN_FLAGS_RANDOMSEQUENTIAL | OPEN_SHARE_DENYNONE |
    313                           OPEN_ACCESS_READONLY,
    314                           0L)) {
    315                 ibufflen = (AutoviewHeight < 96) ? 512 : 3072;
    316                 ibuff = xmalloc(ibufflen + 2,pszSrcFile,__LINE__);
    317                 if (ibuff) {
    318                   // Depends on CreateHexDump line width
    319                   obufflen = (ibufflen / 16) * (6 + 3 * 16 + 1 + 16 + 1) + 80;
    320                   obuff = xmalloc(obufflen + 1,pszSrcFile,__LINE__);
    321                   if (obuff) {
    322                     *obuff = 0;
    323                     if(!DosRead(handle,
    324                                 ibuff,
    325                                 ibufflen,
    326                                 &ibufflen) &&
    327                        ibufflen) {
    328                       ibuff[ibufflen] = 0;
    329                       p = obuff;
    330                       if(IsBinary(ibuff,ibufflen)) {
    331                         olen = ibufflen;
    332                         // Check archive
    333                         if(!arcsigsloaded)
    334                           load_archivers();
    335                         info = arcsighead;
    336                         while(info) {
    337                             if(info->signature &&
    338                                *info->signature) {
    339                               l = strlen(info->signature);
    340                               l = min(l,79);
    341                               if(!DosChgFilePtr(handle,abs(info->file_offset),
    342                                                 (info->file_offset >= 0L) ?
    343                                                  FILE_BEGIN :
    344                                                  FILE_END,
    345                                                 &ibufflen)) {
    346                               if(!DosRead(handle,
    347                                           buffer,
    348                                           l,
    349                                           &ibufflen) &&
    350                                  ibufflen == l) {
    351                                 if(!memcmp(info->signature,
    352                                            buffer,
    353                                            l))
    354                                   break;
    355                               }
    356                             }
    357                           }
    358                           info = info->next;
    359                         }
    360                         if(info) {
    361                           sprintf(p,"**%s%s%s\n",
    362                                   (info->id) ? info->id : "",
    363                                 (info->id) ? " " : "",
    364                                     GetPString(IDS_ARCHIVETEXT));
    365                           p += strlen(p);
    366                         }
    367                         CreateHexDump(ibuff,            // Input buffer
    368                                       olen,             // Input buffer size
    369                                       p,                // Output buffer
    370                                       obufflen - (p - obuff),   // Output buffer size
    371                                       0,                // Address offest
    372                                       FALSE);           // Short addresses
    373                       }
    374                       else {
    375                         // Text file
    376                         register CHAR *src,*dest;
    377                         CHAR          *endsrc;
    378 
    379                         src = ibuff;
    380                         dest = obuff;
    381                         endsrc = ibuff + ibufflen;
    382                         while(src < endsrc) {
    383                           if(dest == obuff && (*src == '\t' || *src == ' ' ||
    384                              *src == '\r' || *src == '\n')) {
    385                             src++;
    386                           }
    387                           else if(*src == '\t' || !*src) {
    388                             *dest = ' ';
    389                             dest++;
    390                             src++;
    391                           }
    392                           else if(*src == '\r' || *src == '\n') {
    393                             *dest = *src;
    394                             while(*(src + 1) == '\r' || *(src + 1) == '\n' ||
    395                                   *(src + 1) == ' ' || *(src + 1) == '\t')
    396                               src++;
    397                             dest++;
    398                             src++;
    399                           }
    400                           else {
    401                             *dest = *src;
    402                             src++;
    403                             dest++;
    404                           }
    405                         } // while
    406                         *dest = 0;
    407                         if (dest - obuff >= obufflen)
    408                           Runtime_Error(pszSrcFile, __LINE__, pszBufOvfMsg);
    409                       }
    410                       if(*obuff)
    411                         WinSetWindowText(hwndAutoview,obuff);
    412                     }
    413                     free(obuff);
    414                   }
    415                   free(ibuff);
    416                 }
    417                 DosClose(handle);
    418               }
    419             }
    420             else if(!IsFile(currfile)) {
    421 
    422               static FILEFINDBUF4 ffb[130];
    423               static char         fullname[CCHMAXPATH + 4];
    424               HDIR                hdir = HDIR_CREATE;
    425               ULONG               x,nm,ml,mc,bufflen;
    426               PBYTE               fb;
    427               PFILEFINDBUF4       pffbFile;
    428               char               *buff,*p;
    429               APIRET              rc;
    430 
    431               sprintf(fullname,
    432                       "%s%s*",
    433                       currfile,
    434                       (currfile[strlen(currfile) - 1] == '\\') ? "" : "\\");
    435               DosError(FERR_DISABLEHARDERR);
    436               nm = sizeof(ffb) / sizeof(FILEFINDBUF4);
    437               if(AutoviewHeight < 96)
    438                 nm /= 2;
    439               rc = DosFindFirst(fullname,
    440                                 &hdir,
    441                                 FILE_NORMAL   | FILE_DIRECTORY |
    442                                 FILE_READONLY | FILE_ARCHIVED  |
    443                                 FILE_SYSTEM   | FILE_HIDDEN,
    444                                 &ffb,
    445                                 sizeof(ffb),
    446                                 &nm,
    447                                 FIL_QUERYEASIZE);
    448               if(!rc && nm) {
    449                 fb = (PBYTE)&ffb;
    450                 x = ml = 0;
    451                 while(x < nm) {
    452                   pffbFile = (PFILEFINDBUF4)fb;
    453                   mc = (ULONG)pffbFile->cchName +
    454                               ((pffbFile->attrFile & FILE_DIRECTORY) != 0);
    455                   ml = max(ml,mc);
    456                   if(!pffbFile->oNextEntryOffset)
    457                     break;
    458                   fb += pffbFile->oNextEntryOffset;
    459                   x++;
    460                 }
    461                 bufflen = (CCHMAXPATHCOMP + 42) * nm;
    462                 buff = xmalloc(bufflen,pszSrcFile,__LINE__);
    463                 if (buff) {
    464                   p = buff;
    465                   *p = 0;
    466                   fb = (PBYTE)&ffb;
    467                   x = 0;
    468                   while(x < nm) {
    469                     pffbFile = (PFILEFINDBUF4)fb;
    470                     if(!(!*pffbFile->achName ||
    471                         (((pffbFile->attrFile & FILE_DIRECTORY) &&
    472                           pffbFile->achName[0] == '.') &&
    473                          (!pffbFile->achName[1] ||
    474                           (pffbFile->achName[1] == '.' &&
    475                            !pffbFile->achName[2]))))) {
    476                       sprintf(p,
    477                               "%s%-*.*s  %-8lu  [%s%s%s%s]  %04lu/%02lu/%02lu "
    478                               "%02lu:%02lu:%02lu\r",
    479                               ((pffbFile->attrFile & FILE_DIRECTORY) != 0) ?
    480                                "\\" : " ",
    481                               ml,
    482                               ml,
    483                               pffbFile->achName,
    484                               pffbFile->cbFile +
    485                                CBLIST_TO_EASIZE(pffbFile->cbList),
    486                               ((pffbFile->attrFile & FILE_READONLY) != 0) ?
    487                                "R" : "-",
    488                               ((pffbFile->attrFile & FILE_ARCHIVED) != 0) ?
    489                                "A" : "-",
    490                               ((pffbFile->attrFile & FILE_HIDDEN) != 0) ?
    491                                "H" : "-",
    492                               ((pffbFile->attrFile & FILE_SYSTEM) != 0) ?
    493                                "S" : "-",
    494                               pffbFile->fdateLastWrite.year + 1980,
    495                               pffbFile->fdateLastWrite.month,
    496                               pffbFile->fdateLastWrite.day,
    497                               pffbFile->ftimeLastWrite.hours,
    498                               pffbFile->ftimeLastWrite.minutes,
    499                               pffbFile->ftimeLastWrite.twosecs * 2);
    500                       p += strlen(p);
    501                     }
    502                     if(!pffbFile->oNextEntryOffset)
    503                       break;
    504                     fb += pffbFile->oNextEntryOffset;
    505                     x++;
    506                   } // while
    507                   if (p - buff >= bufflen)
    508                     Runtime_Error(pszSrcFile, __LINE__, pszBufOvfMsg);
    509                   if(*buff)
    510                     WinSetWindowText(hwndAutoview,buff);
    511                   free(buff);
    512                 }
    513               }
    514               if(!rc)
    515                 DosFindClose(hdir);
    516             }
    517           }
    518           else {
    519 
    520             APIRET        rc;
    521             EAOP2         eaop;
    522             PGEA2LIST     pgealist;
    523             PFEA2LIST     pfealist;
    524             PGEA2         pgea;
    525             PFEA2         pfea;
    526             CHAR         *value,*buff,*p,*data;
    527             USHORT        len,type,plen,dlen;
    528             BOOL          readonly = FALSE;
    529 
    530             pgealist = xmallocz(sizeof(GEA2LIST) + 64,pszSrcFile,__LINE__);
    531             if (pgealist) {
    532               pgea = &pgealist->list[0];
    533               strcpy(pgea->szName,".COMMENTS");
    534               pgea->cbName = strlen(pgea->szName);
    535               pgea->oNextEntryOffset = 0L;
    536               pgealist->cbList = (sizeof(GEA2LIST) + pgea->cbName);
    537               pfealist = xmallocz(65536,pszSrcFile,__LINE__);
    538               if (pfealist) {
    539                 pfealist->cbList = 65536;
    540                 eaop.fpGEA2List = pgealist;
    541                 eaop.fpFEA2List = pfealist;
    542                 eaop.oError = 0L;
    543                 rc = DosQueryPathInfo((CHAR *)mp1,FIL_QUERYEASFROMLIST,
    544                                       (PVOID)&eaop,
    545                                       (ULONG)sizeof(EAOP2));
    546                 free(pgealist);
    547                 if(!rc) {
    548                   pfea = &eaop.fpFEA2List->list[0];
    549                   if(pfea->cbName && pfea->cbValue) {
    550                     value = pfea->szName + pfea->cbName + 1;
    551                     value[pfea->cbValue] = 0;
    552                     if(*(USHORT *)value == EAT_MVMT) {
    553                       buff = xmalloc(65536,pszSrcFile,__LINE__);
    554                       if (buff) {
    555                         p = buff;
    556                         *buff = 0;
    557                         data = value + (sizeof(USHORT) * 3);
    558                         type = *(USHORT *)data;
    559                         data += sizeof(USHORT);
    560                         len = *(USHORT *)data;
    561                         data += sizeof(USHORT);
    562                         while((data - value) - len < pfea->cbValue) {
    563                           if(type == EAT_ASCII) {
    564                             dlen = plen = 0;
    565                             while(dlen < len) {
    566                               if(data[dlen] == '\r') {
    567                                 dlen++;
    568                                 if(dlen < len && data[dlen] != '\n')
    569                                   p[plen++] = '\n';
    570                               }
    571                               else
    572                                 p[plen++] = data[dlen++];
    573                             }
    574                             if((!len || !plen || p[plen - 1] != '\n') &&
    575                                (data - value) + len < pfea->cbValue)
    576                               p[plen++] = '\n';
    577                             p += plen;
    578                             *p = 0;
    579                           }
    580                           else
    581                             readonly = TRUE;
    582                           data += len;
    583                           if(data - value >= pfea->cbValue)
    584                             break;
    585                           type = *(USHORT *)data;
    586                           data += sizeof(USHORT);
    587                           len = *(USHORT *)data;
    588                           data += sizeof(USHORT);
    589                         } // while
    590                         if (p - buff >= 65536) {
    591                           Runtime_Error(pszSrcFile, __LINE__, pszBufOvfMsg);
    592                           buff[65535] = 0;      // Try to stay alive
     284  switch (msg) {
     285  case UM_LOADFILE:
     286    *currfile = 0;
     287    stopflag--;
     288    if (fAutoView) {
     289      WinSetWindowText((fComments) ? hwndAutoMLE : hwndAutoview, "");
     290      MLEsetreadonly(hwndAutoMLE, TRUE);
     291      MLEsetchanged(hwndAutoMLE, FALSE);
     292    }
     293    if (mp1) {
     294      if (fAutoView) {
     295        strcpy(currfile, (CHAR *) mp1);
     296        if (!fComments) {
     297          if (IsFile((CHAR *) mp1) == 1) {
     298
     299            HFILE handle;
     300            ULONG action, olen, ibufflen, obufflen, l;
     301            CHAR *ibuff, *obuff, *p, buffer[80];
     302            ARC_TYPE *info;
     303
     304            if (!DosOpen((CHAR *) mp1,
     305                         &handle,
     306                         &action,
     307                         0L,
     308                         0L,
     309                         OPEN_ACTION_FAIL_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS,
     310                         OPEN_FLAGS_FAIL_ON_ERROR | OPEN_FLAGS_NOINHERIT |
     311                         OPEN_FLAGS_RANDOMSEQUENTIAL | OPEN_SHARE_DENYNONE |
     312                         OPEN_ACCESS_READONLY, 0L)) {
     313              ibufflen = (AutoviewHeight < 96) ? 512 : 3072;
     314              ibuff = xmalloc(ibufflen + 2, pszSrcFile, __LINE__);
     315              if (ibuff) {
     316                // Depends on CreateHexDump line width
     317                obufflen = (ibufflen / 16) * (6 + 3 * 16 + 1 + 16 + 1) + 80;
     318                obuff = xmalloc(obufflen + 1, pszSrcFile, __LINE__);
     319                if (obuff) {
     320                  *obuff = 0;
     321                  if (!DosRead(handle,
     322                               ibuff, ibufflen, &ibufflen) && ibufflen) {
     323                    ibuff[ibufflen] = 0;
     324                    p = obuff;
     325                    if (IsBinary(ibuff, ibufflen)) {
     326                      olen = ibufflen;
     327                      // Check archive
     328                      if (!arcsigsloaded)
     329                        load_archivers();
     330                      info = arcsighead;
     331                      while (info) {
     332                        if (info->signature && *info->signature) {
     333                          l = strlen(info->signature);
     334                          l = min(l, 79);
     335                          if (!DosChgFilePtr(handle, abs(info->file_offset),
     336                                             (info->file_offset >= 0L) ?
     337                                             FILE_BEGIN :
     338                                             FILE_END, &ibufflen)) {
     339                            if (!DosRead(handle,
     340                                         buffer,
     341                                         l, &ibufflen) && ibufflen == l) {
     342                              if (!memcmp(info->signature, buffer, l))
     343                                break;
     344                            }
     345                          }
     346                        }
     347                        info = info->next;
     348                      }
     349                      if (info) {
     350                        sprintf(p, "**%s%s%s\n",
     351                                (info->id) ? info->id : "",
     352                                (info->id) ? " " : "",
     353                                GetPString(IDS_ARCHIVETEXT));
     354                        p += strlen(p);
     355                      }
     356                      CreateHexDump(ibuff,      // Input buffer
     357                                    olen,       // Input buffer size
     358                                    p,  // Output buffer
     359                                    obufflen - (p - obuff),     // Output buffer size
     360                                    0,  // Address offest
     361                                    FALSE);     // Short addresses
     362                    }
     363                    else {
     364                      // Text file
     365                      register CHAR *src, *dest;
     366                      CHAR *endsrc;
     367
     368                      src = ibuff;
     369                      dest = obuff;
     370                      endsrc = ibuff + ibufflen;
     371                      while (src < endsrc) {
     372                        if (dest == obuff && (*src == '\t' || *src == ' ' ||
     373                                              *src == '\r' || *src == '\n')) {
     374                          src++;
     375                        }
     376                        else if (*src == '\t' || !*src) {
     377                          *dest = ' ';
     378                          dest++;
     379                          src++;
     380                        }
     381                        else if (*src == '\r' || *src == '\n') {
     382                          *dest = *src;
     383                          while (*(src + 1) == '\r' || *(src + 1) == '\n' ||
     384                                 *(src + 1) == ' ' || *(src + 1) == '\t')
     385                            src++;
     386                          dest++;
     387                          src++;
     388                        }
     389                        else {
     390                          *dest = *src;
     391                          src++;
     392                          dest++;
     393                        }
     394                      }                 // while
     395                      *dest = 0;
     396                      if (dest - obuff >= obufflen)
     397                        Runtime_Error(pszSrcFile, __LINE__, pszBufOvfMsg);
     398                    }
     399                    if (*obuff)
     400                      WinSetWindowText(hwndAutoview, obuff);
     401                  }
     402                  free(obuff);
     403                }
     404                free(ibuff);
     405              }
     406              DosClose(handle);
     407            }
     408          }
     409          else if (!IsFile(currfile)) {
     410
     411            static FILEFINDBUF4 ffb[130];
     412            static char fullname[CCHMAXPATH + 4];
     413            HDIR hdir = HDIR_CREATE;
     414            ULONG x, nm, ml, mc, bufflen;
     415            PBYTE fb;
     416            PFILEFINDBUF4 pffbFile;
     417            char *buff, *p;
     418            APIRET rc;
     419
     420            sprintf(fullname,
     421                    "%s%s*",
     422                    currfile,
     423                    (currfile[strlen(currfile) - 1] == '\\') ? "" : "\\");
     424            DosError(FERR_DISABLEHARDERR);
     425            nm = sizeof(ffb) / sizeof(FILEFINDBUF4);
     426            if (AutoviewHeight < 96)
     427              nm /= 2;
     428            rc = DosFindFirst(fullname,
     429                              &hdir,
     430                              FILE_NORMAL | FILE_DIRECTORY |
     431                              FILE_READONLY | FILE_ARCHIVED |
     432                              FILE_SYSTEM | FILE_HIDDEN,
     433                              &ffb, sizeof(ffb), &nm, FIL_QUERYEASIZE);
     434            if (!rc && nm) {
     435              fb = (PBYTE) & ffb;
     436              x = ml = 0;
     437              while (x < nm) {
     438                pffbFile = (PFILEFINDBUF4) fb;
     439                mc = (ULONG) pffbFile->cchName +
     440                  ((pffbFile->attrFile & FILE_DIRECTORY) != 0);
     441                ml = max(ml, mc);
     442                if (!pffbFile->oNextEntryOffset)
     443                  break;
     444                fb += pffbFile->oNextEntryOffset;
     445                x++;
     446              }
     447              bufflen = (CCHMAXPATHCOMP + 42) * nm;
     448              buff = xmalloc(bufflen, pszSrcFile, __LINE__);
     449              if (buff) {
     450                p = buff;
     451                *p = 0;
     452                fb = (PBYTE) & ffb;
     453                x = 0;
     454                while (x < nm) {
     455                  pffbFile = (PFILEFINDBUF4) fb;
     456                  if (!(!*pffbFile->achName ||
     457                        (((pffbFile->attrFile & FILE_DIRECTORY) &&
     458                          pffbFile->achName[0] == '.') &&
     459                         (!pffbFile->achName[1] ||
     460                          (pffbFile->achName[1] == '.' &&
     461                           !pffbFile->achName[2]))))) {
     462                    sprintf(p,
     463                            "%s%-*.*s  %-8lu  [%s%s%s%s]  %04lu/%02lu/%02lu "
     464                            "%02lu:%02lu:%02lu\r",
     465                            ((pffbFile->attrFile & FILE_DIRECTORY) != 0) ?
     466                            "\\" : " ",
     467                            ml,
     468                            ml,
     469                            pffbFile->achName,
     470                            pffbFile->cbFile +
     471                            CBLIST_TO_EASIZE(pffbFile->cbList),
     472                            ((pffbFile->attrFile & FILE_READONLY) != 0) ?
     473                            "R" : "-",
     474                            ((pffbFile->attrFile & FILE_ARCHIVED) != 0) ?
     475                            "A" : "-",
     476                            ((pffbFile->attrFile & FILE_HIDDEN) != 0) ?
     477                            "H" : "-",
     478                            ((pffbFile->attrFile & FILE_SYSTEM) != 0) ?
     479                            "S" : "-",
     480                            pffbFile->fdateLastWrite.year + 1980,
     481                            pffbFile->fdateLastWrite.month,
     482                            pffbFile->fdateLastWrite.day,
     483                            pffbFile->ftimeLastWrite.hours,
     484                            pffbFile->ftimeLastWrite.minutes,
     485                            pffbFile->ftimeLastWrite.twosecs * 2);
     486                    p += strlen(p);
     487                  }
     488                  if (!pffbFile->oNextEntryOffset)
     489                    break;
     490                  fb += pffbFile->oNextEntryOffset;
     491                  x++;
     492                }                       // while
     493                if (p - buff >= bufflen)
     494                  Runtime_Error(pszSrcFile, __LINE__, pszBufOvfMsg);
     495                if (*buff)
     496                  WinSetWindowText(hwndAutoview, buff);
     497                free(buff);
     498              }
     499            }
     500            if (!rc)
     501              DosFindClose(hdir);
     502          }
     503        }
     504        else {
     505
     506          APIRET rc;
     507          EAOP2 eaop;
     508          PGEA2LIST pgealist;
     509          PFEA2LIST pfealist;
     510          PGEA2 pgea;
     511          PFEA2 pfea;
     512          CHAR *value, *buff, *p, *data;
     513          USHORT len, type, plen, dlen;
     514          BOOL readonly = FALSE;
     515
     516          pgealist = xmallocz(sizeof(GEA2LIST) + 64, pszSrcFile, __LINE__);
     517          if (pgealist) {
     518            pgea = &pgealist->list[0];
     519            strcpy(pgea->szName, ".COMMENTS");
     520            pgea->cbName = strlen(pgea->szName);
     521            pgea->oNextEntryOffset = 0L;
     522            pgealist->cbList = (sizeof(GEA2LIST) + pgea->cbName);
     523            pfealist = xmallocz(65536, pszSrcFile, __LINE__);
     524            if (pfealist) {
     525              pfealist->cbList = 65536;
     526              eaop.fpGEA2List = pgealist;
     527              eaop.fpFEA2List = pfealist;
     528              eaop.oError = 0L;
     529              rc = DosQueryPathInfo((CHAR *) mp1, FIL_QUERYEASFROMLIST,
     530                                    (PVOID) & eaop, (ULONG) sizeof(EAOP2));
     531              free(pgealist);
     532              if (!rc) {
     533                pfea = &eaop.fpFEA2List->list[0];
     534                if (pfea->cbName && pfea->cbValue) {
     535                  value = pfea->szName + pfea->cbName + 1;
     536                  value[pfea->cbValue] = 0;
     537                  if (*(USHORT *) value == EAT_MVMT) {
     538                    buff = xmalloc(65536, pszSrcFile, __LINE__);
     539                    if (buff) {
     540                      p = buff;
     541                      *buff = 0;
     542                      data = value + (sizeof(USHORT) * 3);
     543                      type = *(USHORT *) data;
     544                      data += sizeof(USHORT);
     545                      len = *(USHORT *) data;
     546                      data += sizeof(USHORT);
     547                      while ((data - value) - len < pfea->cbValue) {
     548                        if (type == EAT_ASCII) {
     549                          dlen = plen = 0;
     550                          while (dlen < len) {
     551                            if (data[dlen] == '\r') {
     552                              dlen++;
     553                              if (dlen < len && data[dlen] != '\n')
     554                                p[plen++] = '\n';
     555                            }
     556                            else
     557                              p[plen++] = data[dlen++];
     558                          }
     559                          if ((!len || !plen || p[plen - 1] != '\n') &&
     560                              (data - value) + len < pfea->cbValue)
     561                            p[plen++] = '\n';
     562                          p += plen;
     563                          *p = 0;
     564                        }
     565                        else
     566                          readonly = TRUE;
     567                        data += len;
     568                        if (data - value >= pfea->cbValue)
    593569                          break;
    594                         }
    595                         WinSetWindowText(hwndAutoMLE,buff);
    596                         free(buff);
    597                       }
    598                     }
    599                     else
    600                       readonly = TRUE;
    601                   }
    602                   /* else EA not present */
    603                   MLEsetchanged(hwndAutoMLE,FALSE);
    604                   MLEsetreadonly(hwndAutoMLE,readonly);
    605                 }
    606                 else {
    607                   MLEsetchanged(hwndAutoMLE,FALSE);
    608                   MLEsetreadonly(hwndAutoMLE,FALSE);
    609                 }
    610                 free(pfealist);
    611               }
    612             }
    613           }
    614         }
    615         free((CHAR *)mp1);
    616       }
    617       return 0;
    618 
    619     case UM_CLOSE:
    620       if(!PostMsg((HWND)0,WM_QUIT,MPVOID,MPVOID))
    621         WinSendMsg((HWND)0,WM_QUIT,MPVOID,MPVOID);
    622       WinDestroyWindow(hwnd);
    623       return 0;
     570                        type = *(USHORT *) data;
     571                        data += sizeof(USHORT);
     572                        len = *(USHORT *) data;
     573                        data += sizeof(USHORT);
     574                      }                 // while
     575                      if (p - buff >= 65536) {
     576                        Runtime_Error(pszSrcFile, __LINE__, pszBufOvfMsg);
     577                        buff[65535] = 0;        // Try to stay alive
     578                        break;
     579                      }
     580                      WinSetWindowText(hwndAutoMLE, buff);
     581                      free(buff);
     582                    }
     583                  }
     584                  else
     585                    readonly = TRUE;
     586                }
     587                /* else EA not present */
     588                MLEsetchanged(hwndAutoMLE, FALSE);
     589                MLEsetreadonly(hwndAutoMLE, readonly);
     590              }
     591              else {
     592                MLEsetchanged(hwndAutoMLE, FALSE);
     593                MLEsetreadonly(hwndAutoMLE, FALSE);
     594              }
     595              free(pfealist);
     596            }
     597          }
     598        }
     599      }
     600      free((CHAR *) mp1);
     601    }
     602    return 0;
     603
     604  case UM_CLOSE:
     605    if (!PostMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID))
     606      WinSendMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID);
     607    WinDestroyWindow(hwnd);
     608    return 0;
    624609  }
    625   return WinDefWindowProc(hwnd,msg,mp1,mp2);
     610  return WinDefWindowProc(hwnd, msg, mp1, mp2);
    626611}
    627612
    628 
    629 static VOID MakeAutoWinThread(VOID *args)
     613static VOID MakeAutoWinThread(VOID * args)
    630614{
    631   HAB         hab2;
    632   HMQ         hmq2;
    633   HWND        hwndParent = (HWND)args;
    634   QMSG        qmsg2;
     615  HAB hab2;
     616  HMQ hmq2;
     617  HWND hwndParent = (HWND) args;
     618  QMSG qmsg2;
    635619
    636620  hab2 = WinInitialize(0);
    637   if(hab2) {
    638     hmq2 = WinCreateMsgQueue(hab2,128);
    639     if(hmq2) {
     621  if (hab2) {
     622    hmq2 = WinCreateMsgQueue(hab2, 128);
     623    if (hmq2) {
    640624      DosError(FERR_DISABLEHARDERR);
    641625      WinRegisterClass(hab2,
    642                        GetPString(IDS_WCOBJECTWINDOW),
    643                        AutoObjProc,
    644                        0,
    645                        sizeof(PVOID));
     626                       GetPString(IDS_WCOBJECTWINDOW),
     627                       AutoObjProc, 0, sizeof(PVOID));
    646628      hwndAutoObj = WinCreateWindow(HWND_OBJECT,
    647                                     GetPString(IDS_WCOBJECTWINDOW),
    648                                     (PSZ)NULL,
    649                                     0,
    650                                     0L,
    651                                     0L,
    652                                     0L,
    653                                     0L,
    654                                     0L,
    655                                     HWND_TOP,
    656                                     OBJ_FRAME,
    657                                     NULL,
    658                                     NULL);
     629                                    GetPString(IDS_WCOBJECTWINDOW),
     630                                    (PSZ) NULL,
     631                                    0,
     632                                    0L,
     633                                    0L,
     634                                    0L,
     635                                    0L, 0L, HWND_TOP, OBJ_FRAME, NULL, NULL);
    659636      if (!hwndAutoObj) {
    660         Win_Error2(HWND_OBJECT,HWND_DESKTOP,pszSrcFile,__LINE__,IDS_WINCREATEWINDOW);
    661         if(!PostMsg(hwndParent,UM_CLOSE,MPVOID,MPVOID))
    662           WinSendMsg(hwndParent,UM_CLOSE,MPVOID,MPVOID);
     637        Win_Error2(HWND_OBJECT, HWND_DESKTOP, pszSrcFile, __LINE__,
     638                   IDS_WINCREATEWINDOW);
     639        if (!PostMsg(hwndParent, UM_CLOSE, MPVOID, MPVOID))
     640          WinSendMsg(hwndParent, UM_CLOSE, MPVOID, MPVOID);
    663641      }
    664642      else {
    665         WinSetWindowULong(hwndAutoObj,QWL_USER,hwndParent);
    666         priority_normal();
    667         while(WinGetMsg(hab2,&qmsg2,(HWND)0,0,0))
    668           WinDispatchMsg(hab2,&qmsg2);
    669         WinDestroyWindow(hwndAutoObj);
    670         hwndAutoObj = (HWND)0;
     643        WinSetWindowULong(hwndAutoObj, QWL_USER, hwndParent);
     644        priority_normal();
     645        while (WinGetMsg(hab2, &qmsg2, (HWND) 0, 0, 0))
     646          WinDispatchMsg(hab2, &qmsg2);
     647        WinDestroyWindow(hwndAutoObj);
     648        hwndAutoObj = (HWND) 0;
    671649      }
    672650      WinDestroyMsgQueue(hmq2);
    … …  
    677655}
    678656
    679 
    680 MRESULT EXPENTRY AutoViewProc (HWND hwnd,ULONG msg,MPARAM mp1,MPARAM mp2)
     657MRESULT EXPENTRY AutoViewProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
    681658{
    682   USHORT id = WinQueryWindowUShort(hwnd,QWS_ID);
    683 
    684   switch(msg) {
    685     case WM_CREATE:
    686       {
    687         MRESULT mr;
    688 
    689         if (!hwndAutoObj) {
    690           if (_beginthread(MakeAutoWinThread,NULL,65536,(PVOID)hwnd) == -1) {
    691             Runtime_Error(pszSrcFile, __LINE__, GetPString(IDS_COULDNTSTARTTHREADTEXT));
    692             PostMsg(hwnd,UM_CLOSE,MPVOID,MPVOID);
     659  USHORT id = WinQueryWindowUShort(hwnd, QWS_ID);
     660
     661  switch (msg) {
     662  case WM_CREATE:
     663    {
     664      MRESULT mr;
     665
     666      if (!hwndAutoObj) {
     667        if (_beginthread(MakeAutoWinThread, NULL, 65536, (PVOID) hwnd) == -1) {
     668          Runtime_Error(pszSrcFile, __LINE__,
     669                        GetPString(IDS_COULDNTSTARTTHREADTEXT));
     670          PostMsg(hwnd, UM_CLOSE, MPVOID, MPVOID);
     671        }
     672      }
     673      mr = PFNWPStatic(hwnd, msg, mp1, mp2);
     674      SetPresParams(hwnd,
     675                    &RGBGREY,
     676                    &RGBBLACK, &RGBGREY, GetPString(IDS_4SYSTEMVIOTEXT));
     677      stopflag = 0;
     678      return mr;
     679    }
     680
     681  case UM_SETUP:
     682    MLEsetlimit(hwnd, 32768);
     683    MLEsetformat(hwnd, MLFIE_NOTRANS);
     684    MLEsetchanged(hwnd, FALSE);
     685    return 0;
     686
     687  case WM_BUTTON1DOWN:
     688    {
     689      SWP swp;
     690
     691      WinQueryWindowPos(hwnd, &swp);
     692      if (SHORT2FROMMP(mp1) > swp.cy - 4) {
     693
     694        HPS hps = WinGetPS(WinQueryWindow(hwnd, QW_PARENT));
     695        SWP swpC;
     696        TRACKINFO track;
     697
     698        if (hps) {
     699          WinQueryWindowPos(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
     700                                            FID_CLIENT), &swpC);
     701          track.cxBorder = 4;
     702          track.cyBorder = 4;
     703          track.cxGrid = 1;
     704          track.cyGrid = 8;
     705          track.cxKeyboard = 8;
     706          track.rclTrack.yBottom = swp.y;
     707          track.rclTrack.yTop = swp.y + swp.cy;
     708          track.rclTrack.xLeft = swp.x;
     709          track.rclTrack.xRight = swp.x + swp.cx;
     710          track.rclBoundary = track.rclTrack;
     711          track.rclBoundary.yTop = (swpC.cy + swp.y + swp.cy) - 116;
     712          track.ptlMinTrackSize.x = swp.x + swp.cx;
     713          track.ptlMinTrackSize.y = 36;
     714          track.ptlMaxTrackSize.x = swp.x + swp.cx;
     715          track.ptlMaxTrackSize.y = (swpC.cy + swp.cy) - 116;
     716          track.fs = TF_TOP;
     717          if (WinTrackRect(hwnd, hps, &track)) {
     718            AutoviewHeight = track.rclTrack.yTop - track.rclTrack.yBottom;
     719            PrfWriteProfileData(fmprof,
     720                                FM3Str,
     721                                "AutoviewHeight",
     722                                &AutoviewHeight, sizeof(ULONG));
     723            WinSendMsg(WinQueryWindow(hwnd, QW_PARENT),
     724                       WM_UPDATEFRAME, MPFROMLONG(FCF_SIZEBORDER), MPVOID);
     725          }
     726          WinReleasePS(hps);
     727        }
     728        return (MRESULT) TRUE;
     729      }
     730      else if (id != MAIN_AUTOVIEWMLE)
     731        return CommonTextButton(hwnd, msg, mp1, mp2);
     732    }
     733    break;
     734
     735  case WM_BUTTON3DOWN:
     736  case WM_BUTTON1UP:
     737  case WM_BUTTON3UP:
     738    if (id != MAIN_AUTOVIEWMLE)
     739      return CommonTextButton(hwnd, msg, mp1, mp2);
     740    break;
     741
     742  case WM_MOUSEMOVE:
     743    shiftstate = (SHORT2FROMMP(mp2) & (KC_ALT | KC_SHIFT | KC_CTRL));
     744    {
     745      SWP swp;
     746
     747      WinQueryWindowPos(hwnd, &swp);
     748      if (SHORT2FROMMP(mp1) > swp.cy - 4) {
     749        WinSetPointer(HWND_DESKTOP, hptrNS);
     750        return (MRESULT) TRUE;
     751      }
     752    }
     753    break;
     754
     755  case WM_PAINT:
     756    PostMsg(hwnd, UM_PAINT, MPVOID, MPVOID);
     757    break;
     758
     759  case UM_PAINT:
     760    PaintRecessedWindow(hwnd, (HPS) 0, TRUE, TRUE);
     761    return 0;
     762
     763  case WM_SETFOCUS:
     764    switch (id) {
     765    case MAIN_AUTOVIEWMLE:
     766      if (!mp2 && !AutoMenu) {
     767        if (*currfile) {
     768          if (MLEgetchanged(hwnd)) {
     769            CHAR *ea = xmalloc(32768, pszSrcFile, __LINE__);
     770
     771            if (ea) {
     772              *ea = 0;
     773              WinQueryWindowText(hwnd, 32767, ea);
     774              PutComments(hwnd, currfile, ea);
     775              PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_RESCAN, 0), MPVOID);
     776              free(ea);
     777            }
    693778          }
    694779        }
    695         mr = PFNWPStatic(hwnd,msg,mp1,mp2);
    696         SetPresParams(hwnd,
    697                       &RGBGREY,
    698                       &RGBBLACK,
    699                       &RGBGREY,
    700                       GetPString(IDS_4SYSTEMVIOTEXT));
    701         stopflag = 0;
    702         return mr;
    703       }
    704 
    705     case UM_SETUP:
    706       MLEsetlimit(hwnd,32768);
    707       MLEsetformat(hwnd,MLFIE_NOTRANS);
    708       MLEsetchanged(hwnd,FALSE);
    709       return 0;
    710 
    711     case WM_BUTTON1DOWN:
     780      }
     781      break;
     782    default:
     783      if (mp2)
     784        PostMsg(hwnd, UM_FOCUSME, mp1, mp2);
     785      break;
     786    }
     787    break;
     788
     789  case UM_FOCUSME:
     790    if (mp2) {
     791
     792      PID pid;
     793      TID tid;
     794
     795      if (WinQueryWindowProcess((HWND) mp1, &pid, &tid) && pid == mypid)
     796        WinSetFocus(HWND_DESKTOP, (HWND) mp1);
     797      else
     798        WinSetFocus(HWND_DESKTOP, hwndTree);
     799    }
     800    return 0;
     801
     802  case UM_CLICKED:
     803  case UM_CLICKED3:
     804    if (id != MAIN_AUTOVIEWMLE) {
     805      PostMsg(hwnd,
     806              WM_COMMAND,
     807              MPFROM2SHORT(((msg == UM_CLICKED3) ?
     808                            IDM_EAS : IDM_VIEWORARC), 0), MPVOID);
     809    }
     810    return 0;
     811
     812  case WM_COMMAND:
     813    PostMsg(hwnd, UM_COMMAND, mp1, mp2);
     814    return 0;
     815
     816  case UM_COMMAND:
     817    switch (SHORT1FROMMP(mp1)) {
     818    case IDM_RESCAN:
     819      if (*currfile) {
     820
     821        CHAR *cf = xstrdup(currfile, pszSrcFile, __LINE__);
     822
     823        if (cf) {
     824          stopflag++;
     825          if (!PostMsg(hwndAutoObj, UM_LOADFILE, MPFROMP(cf), MPVOID))
     826            free(cf);
     827        }
     828      }
     829      break;
     830
     831    case IDM_INFO:
     832      DefaultView(hwnd, (HWND) 0, hwndMain, NULL, 16, currfile);
     833      break;
     834
     835    case IDM_VIEW:
     836      DefaultView(hwnd, (HWND) 0, hwndMain, NULL, 0, currfile);
     837      break;
     838
     839    case IDM_EDIT:
     840      DefaultView(hwnd, (HWND) 0, hwndMain, NULL, 8, currfile);
     841      break;
     842
     843    case IDM_EAS:
    712844      {
    713         SWP swp;
    714 
    715         WinQueryWindowPos(hwnd,&swp);
    716         if(SHORT2FROMMP(mp1) > swp.cy - 4) {
    717 
    718           HPS       hps = WinGetPS(WinQueryWindow(hwnd,QW_PARENT));
    719           SWP       swpC;
    720           TRACKINFO track;
    721 
    722           if(hps) {
    723             WinQueryWindowPos(WinWindowFromID(WinQueryWindow(hwnd,QW_PARENT),
    724                               FID_CLIENT),&swpC);
    725             track.cxBorder = 4;
    726             track.cyBorder = 4;
    727             track.cxGrid = 1;
    728             track.cyGrid = 8;
    729             track.cxKeyboard = 8;
    730             track.rclTrack.yBottom = swp.y;
    731             track.rclTrack.yTop = swp.y + swp.cy;
    732             track.rclTrack.xLeft = swp.x;
    733             track.rclTrack.xRight = swp.x + swp.cx;
    734             track.rclBoundary = track.rclTrack;
    735             track.rclBoundary.yTop = (swpC.cy + swp.y + swp.cy) - 116;
    736             track.ptlMinTrackSize.x = swp.x + swp.cx;
    737             track.ptlMinTrackSize.y = 36;
    738             track.ptlMaxTrackSize.x = swp.x + swp.cx;
    739             track.ptlMaxTrackSize.y = (swpC.cy + swp.cy) - 116;
    740             track.fs = TF_TOP;
    741             if(WinTrackRect(hwnd,hps,&track)) {
    742               AutoviewHeight = track.rclTrack.yTop - track.rclTrack.yBottom;
    743               PrfWriteProfileData(fmprof,
    744                                   FM3Str,
    745                                   "AutoviewHeight",
    746                                   &AutoviewHeight,
    747                                   sizeof(ULONG));
    748               WinSendMsg(WinQueryWindow(hwnd,QW_PARENT),
    749                          WM_UPDATEFRAME,
    750                          MPFROMLONG(FCF_SIZEBORDER),
    751                          MPVOID);
    752             }
    753             WinReleasePS(hps);
    754           }
    755           return (MRESULT)TRUE;
    756         }
    757         else if(id != MAIN_AUTOVIEWMLE)
    758           return CommonTextButton(hwnd,msg,mp1,mp2);
    759       }
    760       break;
    761 
    762     case WM_BUTTON3DOWN:
    763     case WM_BUTTON1UP:
    764     case WM_BUTTON3UP:
    765       if(id != MAIN_AUTOVIEWMLE)
    766         return CommonTextButton(hwnd,msg,mp1,mp2);
    767       break;
    768 
    769     case WM_MOUSEMOVE:
    770       shiftstate = (SHORT2FROMMP(mp2) & (KC_ALT | KC_SHIFT | KC_CTRL));
    771       {
    772         SWP swp;
    773 
    774         WinQueryWindowPos(hwnd,&swp);
    775         if(SHORT2FROMMP(mp1) > swp.cy - 4) {
    776           WinSetPointer(HWND_DESKTOP,hptrNS);
    777           return (MRESULT)TRUE;
    778         }
    779       }
    780       break;
    781 
    782     case WM_PAINT:
    783       PostMsg(hwnd,
    784               UM_PAINT,
    785               MPVOID,
    786               MPVOID);
    787       break;
    788 
    789     case UM_PAINT:
    790       PaintRecessedWindow(hwnd,(HPS)0,TRUE,TRUE);
    791       return 0;
    792 
    793     case WM_SETFOCUS:
    794       switch(id) {
    795         case MAIN_AUTOVIEWMLE:
    796           if(!mp2 && !AutoMenu) {
    797             if(*currfile) {
    798               if(MLEgetchanged(hwnd)) {
    799                 CHAR *ea = xmalloc(32768,pszSrcFile,__LINE__);
    800                 if (ea) {
    801                   *ea = 0;
    802                   WinQueryWindowText(hwnd,32767,ea);
    803                   PutComments(hwnd,
    804                               currfile,
    805                               ea);
    806                   PostMsg(hwnd,
    807                           WM_COMMAND,
    808                           MPFROM2SHORT(IDM_RESCAN,0),
    809                           MPVOID);
    810                   free(ea);
    811                 }
    812               }
    813             }
    814           }
    815           break;
    816         default:
    817           if(mp2)
    818             PostMsg(hwnd,
    819                     UM_FOCUSME,
    820                     mp1,
    821                     mp2);
    822           break;
    823       }
    824       break;
    825 
    826     case UM_FOCUSME:
    827       if(mp2) {
    828 
    829         PID pid;
    830         TID tid;
    831 
    832         if(WinQueryWindowProcess((HWND)mp1,
    833                                  &pid,
    834                                  &tid) &&
    835            pid == mypid)
    836           WinSetFocus(HWND_DESKTOP,
    837                       (HWND)mp1);
    838         else
    839           WinSetFocus(HWND_DESKTOP,
    840                       hwndTree);
    841       }
    842       return 0;
    843 
    844     case UM_CLICKED:
    845     case UM_CLICKED3:
    846       if(id != MAIN_AUTOVIEWMLE) {
    847         PostMsg(hwnd,
    848                 WM_COMMAND,
    849                 MPFROM2SHORT(((msg == UM_CLICKED3) ?
    850                                IDM_EAS :
    851                                IDM_VIEWORARC),
    852                              0),
    853                 MPVOID);
    854       }
    855       return 0;
    856 
    857     case WM_COMMAND:
    858       PostMsg(hwnd,
    859               UM_COMMAND,
    860               mp1,
    861               mp2);
    862       return 0;
    863 
    864     case UM_COMMAND:
    865       switch(SHORT1FROMMP(mp1)) {
    866         case IDM_RESCAN:
    867           if(*currfile) {
    868 
    869             CHAR *cf = xstrdup(currfile,pszSrcFile,__LINE__);
    870 
    871             if (cf) {
    872               stopflag++;
    873               if(!PostMsg(hwndAutoObj,
    874                           UM_LOADFILE,
    875                           MPFROMP(cf),
    876                           MPVOID))
    877                 free(cf);
    878             }
    879           }
    880           break;
    881 
    882         case IDM_INFO:
    883           DefaultView(hwnd,
    884                       (HWND)0,
    885                       hwndMain,
    886                       NULL,
    887                       16,
    888                       currfile);
    889           break;
    890 
    891         case IDM_VIEW:
    892           DefaultView(hwnd,
    893                       (HWND)0,
    894                       hwndMain,
    895                       NULL,
    896                       0,
    897                       currfile);
    898           break;
    899 
    900         case IDM_EDIT:
    901           DefaultView(hwnd,
    902                       (HWND)0,
    903                       hwndMain,
    904                       NULL,
    905                       8,
    906                       currfile);
    907           break;
    908 
    909         case IDM_EAS:
    910           {
    911             char *list[2];
    912 
    913             list[0] = currfile;
    914             list[1] = NULL;
    915 
    916             WinDlgBox(HWND_DESKTOP,
    917                       hwndMain,
    918                       DisplayEAsProc,
    919                       FM3ModHandle,
    920                       EA_FRAME,
    921                       (PVOID)list);
    922           }
    923           break;
    924 
    925         default:
    926           PostMsg(hwndMain,
    927                   msg,
    928                   mp1,
    929                   mp2);
    930       }
    931       return 0;
    932 
    933     case WM_MENUEND:
    934       if((HWND)mp2 == AutoMenu) {
    935         WinDestroyWindow(AutoMenu);
    936         AutoMenu = (HWND)0;
    937       }
    938       break;
    939 
    940     case WM_CONTEXTMENU:
    941       CheckMenu(&AutoMenu,(id == MAIN_AUTOVIEWMLE) ?
    942                            IDM_AUTOVIEWMLE : IDM_AUTOVIEW);
    943       WinCheckMenuItem(AutoMenu,
    944                        IDM_AUTOVIEWFILE,
    945                        !fComments);
    946       WinCheckMenuItem(AutoMenu,
    947                        IDM_AUTOVIEWCOMMENTS,
    948                        fComments);
    949       WinEnableMenuItem(AutoMenu,
    950                         IDM_VIEW,
    951                         (IsFile(currfile) == 1));
    952       WinEnableMenuItem(AutoMenu,
    953                         IDM_EDIT,
    954                         (IsFile(currfile) == 1));
    955       WinEnableMenuItem(AutoMenu,
    956                         IDM_INFO,
    957                         (*currfile != 0));
    958       PopupMenu(hwnd,
    959                 hwnd,
    960                 AutoMenu);
    961       break;
    962 
    963     case UM_LOADFILE:
    964       stopflag++;
    965       if(!PostMsg(hwndAutoObj,
    966                   msg,
    967                   mp1,
    968                   mp2)) {
    969         if(mp1)
    970           free((CHAR *)mp1);
    971       }
    972       return 0;
    973 
    974     case UM_CLOSE:
    975       if(AutoMenu) {
    976         WinDestroyWindow(AutoMenu);
    977         AutoMenu = (HWND)0;
    978       }
    979       WinDestroyWindow(hwnd);
    980       return 0;
    981 
    982     case WM_CLOSE:
    983       WinSendMsg(hwnd,
    984                  UM_CLOSE,
    985                  MPVOID,
    986                  MPVOID);
    987       return 0;
    988 
    989     case WM_DESTROY:
    990       if(id != MAIN_AUTOVIEWMLE) {
    991         if(hwndAutoObj)
    992           if(!PostMsg(hwndAutoObj,
    993                       WM_CLOSE,
    994                       MPVOID,
    995                       MPVOID))
    996             WinSendMsg(hwndAutoObj,
    997                        WM_CLOSE,
    998                        MPVOID,
    999                        MPVOID);
    1000         break;
    1001       }
    1002       break;
     845        char *list[2];
     846
     847        list[0] = currfile;
     848        list[1] = NULL;
     849
     850        WinDlgBox(HWND_DESKTOP,
     851                  hwndMain,
     852                  DisplayEAsProc, FM3ModHandle, EA_FRAME, (PVOID) list);
     853      }
     854      break;
     855
     856    default:
     857      PostMsg(hwndMain, msg, mp1, mp2);
     858    }
     859    return 0;
     860
     861  case WM_MENUEND:
     862    if ((HWND) mp2 == AutoMenu) {
     863      WinDestroyWindow(AutoMenu);
     864      AutoMenu = (HWND) 0;
     865    }
     866    break;
     867
     868  case WM_CONTEXTMENU:
     869    CheckMenu(&AutoMenu, (id == MAIN_AUTOVIEWMLE) ?
     870              IDM_AUTOVIEWMLE : IDM_AUTOVIEW);
     871    WinCheckMenuItem(AutoMenu, IDM_AUTOVIEWFILE, !fComments);
     872    WinCheckMenuItem(AutoMenu, IDM_AUTOVIEWCOMMENTS, fComments);
     873    WinEnableMenuItem(AutoMenu, IDM_VIEW, (IsFile(currfile) == 1));
     874    WinEnableMenuItem(AutoMenu, IDM_EDIT, (IsFile(currfile) == 1));
     875    WinEnableMenuItem(AutoMenu, IDM_INFO, (*currfile != 0));
     876    PopupMenu(hwnd, hwnd, AutoMenu);
     877    break;
     878
     879  case UM_LOADFILE:
     880    stopflag++;
     881    if (!PostMsg(hwndAutoObj, msg, mp1, mp2)) {
     882      if (mp1)
     883        free((CHAR *) mp1);
     884    }
     885    return 0;
     886
     887  case UM_CLOSE:
     888    if (AutoMenu) {
     889      WinDestroyWindow(AutoMenu);
     890      AutoMenu = (HWND) 0;
     891    }
     892    WinDestroyWindow(hwnd);
     893    return 0;
     894
     895  case WM_CLOSE:
     896    WinSendMsg(hwnd, UM_CLOSE, MPVOID, MPVOID);
     897    return 0;
     898
     899  case WM_DESTROY:
     900    if (id != MAIN_AUTOVIEWMLE) {
     901      if (hwndAutoObj)
     902        if (!PostMsg(hwndAutoObj, WM_CLOSE, MPVOID, MPVOID))
     903          WinSendMsg(hwndAutoObj, WM_CLOSE, MPVOID, MPVOID);
     904      break;
     905    }
     906    break;
    1003907  }
    1004908
    1005   if(id == MAIN_AUTOVIEWMLE)
    1006     return PFNWPMLE(hwnd,msg,mp1,mp2);
    1007   return PFNWPStatic(hwnd,msg,mp1,mp2);
     909  if (id == MAIN_AUTOVIEWMLE)
     910    return PFNWPMLE(hwnd, msg, mp1, mp2);
     911  return PFNWPStatic(hwnd, msg, mp1, mp2);
    1008912}
Note: See TracChangeset for help on using the changeset viewer.