Changeset 1157 for trunk/dll/eas.c


Ignore:
Timestamp:
Sep 5, 2008, 11:39:52 PM (17 years ago)
Author:
John Small
Message:

Ticket 187: Draft 1: Functions only

File:
1 edited

Legend:

Unmodified
Added
Removed

  • TabularUnified trunk/dll/eas.c

    r1039 r1157  
    3838#include "fm3str.h"
    3939#include "mle.h"
    40 #include "errutil.h"                    // Dos_Error...
    41 #include "strutil.h"                    // GetPString
     40#include "errutil.h"                    // Dos_Error...
     41#include "strutil.h"                    // GetPString
     42#include "defview.h"                    // QuickView
    4243#include "fm3dll.h"
     44#include "eas.h"
    4345#include "fortify.h"
    4446
    … …  
    4749static PSZ pszSrcFile = __FILE__;
    4850
     51static PVOID SaveEA(CHAR * filename, HOLDFEA * current, CHAR * newdata,
     52             BOOL silentfail);
    4953
    5054typedef struct
    … …  
    7276    while (info) {
    7377      if (!strcmp(info->name, eaname))
    74         return info;
     78        return info;
    7579      info = info->next;
    7680    }
    … …  
    108112    WinSetWindowPtr(hwnd, QWL_USER, (PVOID) mp2);
    109113    WinSendDlgItemMsg(hwnd, EAC_NAME, EM_SETTEXTLIMIT,
    110                       MPFROM2SHORT(1024, 0), MPVOID);
     114                      MPFROM2SHORT(1024, 0), MPVOID);
    111115    WinCheckButton(hwnd, EAC_ASCII, TRUE);
    112116    break;
    … …  
    118122  case UM_PAINT:
    119123    PaintRecessedWindow(WinWindowFromID(hwnd, EAC_TEXT), (HPS) 0, FALSE,
    120                         FALSE);
     124                        FALSE);
    121125    return 0;
    122126
    … …  
    131135      filename = add->filename;
    132136      {
    133         CHAR s[1025];
    134         INT x;
    135         USHORT type = EAT_ASCII;
    136 
    137         *s = 0;
    138         WinQueryDlgItemText(hwnd, EAC_NAME, 1024, s);
    139         bstrip(s);
    140         if (!*s)
    141           WinDismissDlg(hwnd, 0);
    142         else {
    143           if (CheckEA(head, s)) {
    144             DosBeep(50, 100);
    145             WinSetDlgItemText(hwnd, EAC_TEXT,
    146                               GetPString(IDS_EANAMEEXISTSTEXT));
    147             break;
    148           }
    149           for (x = 0; *forbidden[x]; x++) {
    150             if (!strcmp(forbidden[x], s)) {
    151               DosBeep(50, 100);
    152               WinSetDlgItemText(hwnd, EAC_TEXT,
    153                                 GetPString(IDS_EANAMERESERVEDTEXT));
    154               return 0;
    155             }
    156           }
    157           if (WinQueryButtonCheckstate(hwnd, EAC_MVST))
    158             type = EAT_MVST;
    159           else if (WinQueryButtonCheckstate(hwnd, EAC_MVMT))
    160             type = EAT_MVMT;
    161           for (x = 0; *restypes[x].name; x++) {
    162             if (!strcmp(restypes[x].name, s)) {
    163               if (type != restypes[x].type) {
    164                 DosBeep(50, 100);
    165                 WinSetDlgItemText(hwnd, EAC_TEXT,
    166                                   GetPString(IDS_EAWRONGTYPETEXT));
    167                 return 0;
    168               }
    169               break;
    170             }
    171           }
    172           /* if we get here, create dummy ea */
    173           {
    174             PFEA2LIST pfealist = NULL;
    175             EAOP2 eaop;
    176             ULONG ealen;
    177             CHAR *eaval;
    178             APIRET rc;
    179 
    180             ealen = sizeof(FEA2LIST) + strlen(s) + 64;
    181             rc = DosAllocMem((PPVOID) & pfealist, ealen + 1,
    182                              OBJ_TILE | PAG_COMMIT | PAG_READ | PAG_WRITE);
    183             if (rc)
    184               Dos_Error(MB_CANCEL, rc, HWND_DESKTOP, pszSrcFile, __LINE__,
    185                         GetPString(IDS_OUTOFMEMORY));
    186             else {
    187               memset(pfealist, 0, ealen + 1);
    188               pfealist->cbList = ealen;
    189               pfealist->list[0].oNextEntryOffset = 0;
    190               pfealist->list[0].fEA = 0;
    191               pfealist->list[0].cbName = strlen(s);
    192               strcpy(pfealist->list[0].szName, s);
    193               eaval = pfealist->list[0].szName + strlen(s) + 1;
    194               *(USHORT *) eaval = (USHORT) type;
    195               eaval += sizeof(USHORT);
    196               if (type == EAT_MVST || type == EAT_MVMT) {
    197                 *(USHORT *) eaval = (USHORT) 0; /* codepage */
    198                 eaval += sizeof(USHORT);
    199                 *(USHORT *) eaval = (USHORT) 1; /* number */
    200                 eaval += sizeof(USHORT);
    201                 *(USHORT *) eaval = (USHORT) EAT_ASCII; /* type */
    202                 eaval += sizeof(USHORT);
    203               }
    204               *(USHORT *) eaval = (USHORT) 4;
    205               eaval += sizeof(USHORT);
    206               memcpy(eaval, GetPString(IDS_FAKETEXT), 4);
    207               pfealist->list[0].cbValue = 4 + (sizeof(USHORT) * 2) +
    208                 ((type == EAT_MVST ||
    209                   type == EAT_MVMT) ? sizeof(USHORT) * 3 : 0);
    210               eaop.fpGEA2List = (PGEA2LIST) 0;
    211               eaop.fpFEA2List = pfealist;
    212               eaop.oError = 0;
    213               xDosSetPathInfo(filename, FIL_QUERYEASIZE,
    214                               &eaop, sizeof(eaop), DSPI_WRTTHRU);
    215               WinDismissDlg(hwnd, 1);
    216             }
    217           }
    218         }
     137        CHAR s[1025];
     138        INT x;
     139        USHORT type = EAT_ASCII;
     140
     141        *s = 0;
     142        WinQueryDlgItemText(hwnd, EAC_NAME, 1024, s);
     143        bstrip(s);
     144        if (!*s)
     145          WinDismissDlg(hwnd, 0);
     146        else {
     147          if (CheckEA(head, s)) {
     148            DosBeep(50, 100);
     149            WinSetDlgItemText(hwnd, EAC_TEXT,
     150                              GetPString(IDS_EANAMEEXISTSTEXT));
     151            break;
     152          }
     153          for (x = 0; *forbidden[x]; x++) {
     154            if (!strcmp(forbidden[x], s)) {
     155              DosBeep(50, 100);
     156              WinSetDlgItemText(hwnd, EAC_TEXT,
     157                                GetPString(IDS_EANAMERESERVEDTEXT));
     158              return 0;
     159            }
     160          }
     161          if (WinQueryButtonCheckstate(hwnd, EAC_MVST))
     162            type = EAT_MVST;
     163          else if (WinQueryButtonCheckstate(hwnd, EAC_MVMT))
     164            type = EAT_MVMT;
     165          for (x = 0; *restypes[x].name; x++) {
     166            if (!strcmp(restypes[x].name, s)) {
     167              if (type != restypes[x].type) {
     168                DosBeep(50, 100);
     169                WinSetDlgItemText(hwnd, EAC_TEXT,
     170                                  GetPString(IDS_EAWRONGTYPETEXT));
     171                return 0;
     172              }
     173              break;
     174            }
     175          }
     176          /* if we get here, create dummy ea */
     177          {
     178            PFEA2LIST pfealist = NULL;
     179            EAOP2 eaop;
     180            ULONG ealen;
     181            CHAR *eaval;
     182            APIRET rc;
     183
     184            ealen = sizeof(FEA2LIST) + strlen(s) + 64;
     185            rc = DosAllocMem((PPVOID) & pfealist, ealen + 1,
     186                             OBJ_TILE | PAG_COMMIT | PAG_READ | PAG_WRITE);
     187            if (rc)
     188              Dos_Error(MB_CANCEL, rc, HWND_DESKTOP, pszSrcFile, __LINE__,
     189                        GetPString(IDS_OUTOFMEMORY));
     190            else {
     191              memset(pfealist, 0, ealen + 1);
     192              pfealist->cbList = ealen;
     193              pfealist->list[0].oNextEntryOffset = 0;
     194              pfealist->list[0].fEA = 0;
     195              pfealist->list[0].cbName = strlen(s);
     196              strcpy(pfealist->list[0].szName, s);
     197              eaval = pfealist->list[0].szName + strlen(s) + 1;
     198              *(USHORT *) eaval = (USHORT) type;
     199              eaval += sizeof(USHORT);
     200              if (type == EAT_MVST || type == EAT_MVMT) {
     201                *(USHORT *) eaval = (USHORT) 0; /* codepage */
     202                eaval += sizeof(USHORT);
     203                *(USHORT *) eaval = (USHORT) 1; /* number */
     204                eaval += sizeof(USHORT);
     205                *(USHORT *) eaval = (USHORT) EAT_ASCII; /* type */
     206                eaval += sizeof(USHORT);
     207              }
     208              *(USHORT *) eaval = (USHORT) 4;
     209              eaval += sizeof(USHORT);
     210              memcpy(eaval, GetPString(IDS_FAKETEXT), 4);
     211              pfealist->list[0].cbValue = 4 + (sizeof(USHORT) * 2) +
     212                ((type == EAT_MVST ||
     213                  type == EAT_MVMT) ? sizeof(USHORT) * 3 : 0);
     214              eaop.fpGEA2List = (PGEA2LIST) 0;
     215              eaop.fpFEA2List = pfealist;
     216              eaop.oError = 0;
     217              xDosSetPathInfo(filename, FIL_QUERYEASIZE,
     218                              &eaop, sizeof(eaop), DSPI_WRTTHRU);
     219              WinDismissDlg(hwnd, 1);
     220            }
     221          }
     222        }
    219223      }
    220224      break;
    … …  
    226230    case IDM_HELP:
    227231      if (hwndHelp)
    228         WinSendMsg(hwndHelp, HM_DISPLAY_HELP,
    229                    MPFROM2SHORT(HELP_ADDEA, 0), MPFROMSHORT(HM_RESOURCEID));
     232        WinSendMsg(hwndHelp, HM_DISPLAY_HELP,
     233                   MPFROM2SHORT(HELP_ADDEA, 0), MPFROMSHORT(HM_RESOURCEID));
    230234      break;
    231235    }
    … …  
    257261      a = s + 6;
    258262      do {
    259         sprintf(a, "%02x ", (UCHAR)*p);
    260         a += 3;
    261         p++;
    262         x++;
     263        sprintf(a, "%02x ", (UCHAR)*p);
     264        a += 3;
     265        p++;
     266        x++;
    263267      }
    264268      while (x < cbValue && (x % 16));
    265269      if (x % 16) {
    266         z = x;
    267         while (z % 16) {
    268           *a++ = ' ';
    269           *a++ = ' ';
    270           *a++ = ' ';
    271           z++;
    272         }
     270        z = x;
     271        while (z % 16) {
     272          *a++ = ' ';
     273          *a++ = ' ';
     274          *a++ = ' ';
     275          z++;
     276        }
    273277      }
    274278      *a++ = ' ';
    275279      p = pp;
    276280      do {
    277         if (*p)
    278           *a++ = *p++;
    279         else {
    280           *a++ = '.';
    281           p++;
    282         }
    283         *a = 0;
    284         y++;
     281        if (*p)
     282          *a++ = *p++;
     283        else {
     284          *a++ = '.';
     285          p++;
     286        }
     287        *a = 0;
     288        y++;
    285289      }
    286290      while (y < x);
    287291      if ((SHORT) WinSendMsg(hwnd, LM_INSERTITEM, MPFROM2SHORT(LIT_END, 0),
    288                              MPFROMP(s)) < 0)
    289         break;
     292                             MPFROMP(s)) < 0)
     293        break;
    290294      pp = p;
    291295    }
    … …  
    329333    WinSetWindowPtr(hwnd, QWL_USER, (PVOID) eap);
    330334    WinSendDlgItemMsg(hwnd,
    331                       EA_ENTRY, EM_SETTEXTLIMIT, MPFROM2SHORT(40, 0), MPVOID);
     335                      EA_ENTRY, EM_SETTEXTLIMIT, MPFROM2SHORT(40, 0), MPVOID);
    332336    MLEsetlimit(WinWindowFromID(hwnd, EA_MLE), 32767);
    333337    MLEsetformat(WinWindowFromID(hwnd, EA_MLE), MLFIE_NOTRANS);
    … …  
    338342
    339343      for (x = 0; eap->list[x]; x++) {
    340         if (DosQueryPathInfo(eap->list[x], FIL_QUERYFULLNAME, s, sizeof(s)))
    341           strcpy(s, eap->list[x]);
    342         if (IsFile(s) != -1)
    343           WinSendDlgItemMsg(hwnd,
    344                             EA_NAMES,
    345                             LM_INSERTITEM,
    346                             MPFROM2SHORT(LIT_SORTASCENDING, 0), MPFROMP(s));
     344        if (DosQueryPathInfo(eap->list[x], FIL_QUERYFULLNAME, s, sizeof(s)))
     345          strcpy(s, eap->list[x]);
     346        if (IsFile(s) != -1)
     347          WinSendDlgItemMsg(hwnd,
     348                            EA_NAMES,
     349                            LM_INSERTITEM,
     350                            MPFROM2SHORT(LIT_SORTASCENDING, 0), MPFROMP(s));
    347351      }
    348352      sSelect = (SHORT) WinSendDlgItemMsg(hwnd,
    349                                           EA_NAMES,
    350                                           LM_QUERYITEMCOUNT, MPVOID, MPVOID);
     353                                          EA_NAMES,
     354                                          LM_QUERYITEMCOUNT, MPVOID, MPVOID);
    351355      if (sSelect > 0)
    352         WinSendDlgItemMsg(hwnd,
    353                           EA_NAMES,
    354                           LM_SELECTITEM,
    355                           MPFROM2SHORT(0, 0), MPFROMSHORT(TRUE));
     356        WinSendDlgItemMsg(hwnd,
     357                          EA_NAMES,
     358                          LM_SELECTITEM,
     359                          MPFROM2SHORT(0, 0), MPFROMSHORT(TRUE));
    356360      else
    357         WinDismissDlg(hwnd, 0);
     361        WinDismissDlg(hwnd, 0);
    358362    }
    359363    break;
    … …  
    362366    if (*eap->filename) {
    363367      if (eap->head)
    364         Free_FEAList(eap->head);
     368        Free_FEAList(eap->head);
    365369      eap->head = GetFileEAs(eap->filename, FALSE, FALSE);
    366370      if (!isalpha(*eap->filename) ||
    367           (driveflags[toupper(*eap->filename) - 'A'] & DRIVE_NOTWRITEABLE)) {
    368         WinEnableWindow(WinWindowFromID(hwnd, EA_CHANGE), FALSE);
    369         WinEnableWindow(WinWindowFromID(hwnd, EA_ADD), FALSE);
    370         WinEnableWindow(WinWindowFromID(hwnd, EA_DELETE), FALSE);
     371          (driveflags[toupper(*eap->filename) - 'A'] & DRIVE_NOTWRITEABLE)) {
     372        WinEnableWindow(WinWindowFromID(hwnd, EA_CHANGE), FALSE);
     373        WinEnableWindow(WinWindowFromID(hwnd, EA_ADD), FALSE);
     374        WinEnableWindow(WinWindowFromID(hwnd, EA_DELETE), FALSE);
    371375      }
    372376      else {
    373         WinEnableWindow(WinWindowFromID(hwnd, EA_CHANGE), TRUE);
    374         WinEnableWindow(WinWindowFromID(hwnd, EA_ADD), TRUE);
    375         WinEnableWindow(WinWindowFromID(hwnd, EA_DELETE), TRUE);
     377        WinEnableWindow(WinWindowFromID(hwnd, EA_CHANGE), TRUE);
     378        WinEnableWindow(WinWindowFromID(hwnd, EA_ADD), TRUE);
     379        WinEnableWindow(WinWindowFromID(hwnd, EA_DELETE), TRUE);
    376380      }
    377381      WinSendMsg(hwnd, UM_SETUP, MPVOID, MPVOID);
    … …  
    394398      info = eap->head;
    395399      while (info) {
    396         WinSendDlgItemMsg(hwnd, EA_LISTBOX, LM_INSERTITEM,
    397                           MPFROM2SHORT(LIT_END, 0), MPFROMP(info->name));
    398         info = info->next;
     400        WinSendDlgItemMsg(hwnd, EA_LISTBOX, LM_INSERTITEM,
     401                          MPFROM2SHORT(LIT_END, 0), MPFROMP(info->name));
     402        info = info->next;
    399403      }
    400404      WinSendDlgItemMsg(hwnd, EA_LISTBOX, LM_SELECTITEM,
    401                         MPFROM2SHORT(0, 0), MPFROM2SHORT(TRUE, 0));
     405                        MPFROM2SHORT(0, 0), MPFROM2SHORT(TRUE, 0));
    402406    }
    403407    else
    … …  
    412416    PaintRecessedWindow(WinWindowFromID(hwnd, EA_HELP), (HPS) 0, FALSE, TRUE);
    413417    PaintRecessedWindow(WinWindowFromID(hwnd, EA_TEXT), (HPS) 0, FALSE,
    414                         FALSE);
     418                        FALSE);
    415419    return 0;
    416420
    … …  
    420424      switch (SHORT2FROMMP(mp1)) {
    421425      case LN_SETFOCUS:
    422         WinSetDlgItemText(hwnd, EA_HELP, GetPString(IDS_EAFILENAMESHELPTEXT));
    423         break;
     426        WinSetDlgItemText(hwnd, EA_HELP, GetPString(IDS_EAFILENAMESHELPTEXT));
     427        break;
    424428      case LN_KILLFOCUS:
    425         WinSetDlgItemText(hwnd, EA_HELP, NullStr);
    426         break;
     429        WinSetDlgItemText(hwnd, EA_HELP, NullStr);
     430        break;
    427431      case LN_ENTER:
    428432      case LN_SELECT:
    429         {
    430           CHAR s[1025];
    431           SHORT sSelect;
    432 
    433           sSelect = (SHORT) WinSendDlgItemMsg(hwnd, EA_NAMES,
    434                                               LM_QUERYSELECTION,
    435                                               MPFROM2SHORT(LIT_FIRST, 0),
    436                                               MPVOID);
    437           if (sSelect >= 0) {
    438             *s = 0;
    439             WinSendDlgItemMsg(hwnd, EA_NAMES, LM_QUERYITEMTEXT,
    440                               MPFROM2SHORT(sSelect, 1024), MPFROMP(s));
    441             if (*s) {
    442               strcpy(eap->filename, s);
    443               if (SHORT2FROMMP(mp1) == LN_SELECT)
    444                 WinSendMsg(hwnd, UM_SETDIR, MPVOID, MPVOID);
    445               else
    446                 QuickView(hwnd, eap->filename);
    447             }
    448           }
    449         }
    450         break;
     433        {
     434          CHAR s[1025];
     435          SHORT sSelect;
     436
     437          sSelect = (SHORT) WinSendDlgItemMsg(hwnd, EA_NAMES,
     438                                              LM_QUERYSELECTION,
     439                                              MPFROM2SHORT(LIT_FIRST, 0),
     440                                              MPVOID);
     441          if (sSelect >= 0) {
     442            *s = 0;
     443            WinSendDlgItemMsg(hwnd, EA_NAMES, LM_QUERYITEMTEXT,
     444                              MPFROM2SHORT(sSelect, 1024), MPFROMP(s));
     445            if (*s) {
     446              strcpy(eap->filename, s);
     447              if (SHORT2FROMMP(mp1) == LN_SELECT)
     448                WinSendMsg(hwnd, UM_SETDIR, MPVOID, MPVOID);
     449              else
     450                QuickView(hwnd, eap->filename);
     451            }
     452          }
     453        }
     454        break;
    451455      }
    452456      break;
    … …  
    455459      switch (SHORT2FROMMP(mp1)) {
    456460      case LN_SETFOCUS:
    457         WinSetDlgItemText(hwnd, EA_HELP, GetPString(IDS_EATYPESHELPTEXT));
    458         break;
     461        WinSetDlgItemText(hwnd, EA_HELP, GetPString(IDS_EATYPESHELPTEXT));
     462        break;
    459463      case LN_KILLFOCUS:
    460         WinSetDlgItemText(hwnd, EA_HELP, NullStr);
    461         break;
     464        WinSetDlgItemText(hwnd, EA_HELP, NullStr);
     465        break;
    462466      case LN_SELECT:
    463         {
    464           CHAR s[1024];
    465           SHORT sSelect;
    466 
    467           eap->current = NULL;
    468           if (eap->head) {
    469             WinSetDlgItemText(hwnd, EA_TEXT, NullStr);
    470             WinShowWindow(WinWindowFromID(hwnd, EA_ENTRY), FALSE);
    471             WinSetDlgItemText(hwnd, EA_ENTRY, NullStr);
    472             MLEclearall(WinWindowFromID(hwnd, EA_MLE));
    473             WinShowWindow(WinWindowFromID(hwnd, EA_MLE), FALSE);
    474             WinShowWindow(WinWindowFromID(hwnd, EA_CHANGE), FALSE);
    475             WinShowWindow(WinWindowFromID(hwnd, EA_DELETE), FALSE);
    476             WinShowWindow(WinWindowFromID(hwnd, EA_HEXDUMP), FALSE);
    477             WinSendDlgItemMsg(hwnd, EA_HEXDUMP, LM_DELETEALL, MPVOID, MPVOID);
    478             *s = 0;
    479             sSelect = (USHORT) WinSendDlgItemMsg(hwnd, EA_LISTBOX,
    480                                                 LM_QUERYSELECTION,
    481                                                 MPFROMSHORT(LIT_FIRST),
    482                                                 MPVOID);
    483             if (sSelect >= 0) {
    484               WinSendDlgItemMsg(hwnd, EA_LISTBOX, LM_QUERYITEMTEXT,
    485                                 MPFROM2SHORT(sSelect, 1024), MPFROMP(s));
    486               if (*s) {
    487 
    488                 USHORT len, num, type;
    489                 CHAR *data;
    490                 CHAR last = '\n';
    491                 const CHAR *linefeed = "\n";
    492                 BOOL alltext;
    493                 IPT pos = 0;
    494 
    495                 info = eap->head;
    496                 while (info) {
    497                   if (!strcmp(s, info->name)) {
    498                     eap->current = info;
    499                     WinShowWindow(WinWindowFromID(hwnd, EA_DELETE), TRUE);
    500                     switch (*(USHORT *) info->value) {
    501                     case EAT_EA:
    502                     case EAT_ASCII:
    503                       if (!strcmp(info->name, SUBJECT))
    504                         WinSendDlgItemMsg(hwnd, EA_ENTRY,
    505                                           EM_SETTEXTLIMIT,
    506                                           MPFROM2SHORT(1024, 0), MPVOID);
    507                       else
    508                         WinSendDlgItemMsg(hwnd, EA_ENTRY,
    509                                           EM_SETTEXTLIMIT,
    510                                           MPFROM2SHORT(1024, 0), MPVOID);
    511                       WinSetDlgItemText(hwnd, EA_ENTRY,
    512                                         info->value + (sizeof(USHORT) * 2));
    513                       WinShowWindow(WinWindowFromID(hwnd, EA_ENTRY), TRUE);
    514                       WinEnableWindow(WinWindowFromID(hwnd, EA_CHANGE),
    515                                       FALSE);
    516                       WinShowWindow(WinWindowFromID(hwnd, EA_CHANGE), TRUE);
    517                       {
    518                         CHAR str[81];
    519 
    520                         sprintf(str,
    521                                 GetPString(IDS_DATAANDBYTESTEXT),
    522                                 (*(USHORT *) info->value == EAT_ASCII) ?
    523                                 GetPString(IDS_TEXTTEXT) :
    524                                 GetPString(IDS_EAREFTEXT), info->cbValue);
    525                         WinSetDlgItemText(hwnd, EA_TEXT, str);
    526                       }
    527                       break;
    528                     case EAT_MVST:
    529                       MLEclearall(WinWindowFromID(hwnd, EA_MLE));
    530                       num = *(USHORT *) (info->value + (sizeof(USHORT) * 2));
    531                       type = *(USHORT *) (info->value + (sizeof(USHORT) * 3));
    532                       if (type == EAT_ASCII) {
    533                         data = info->value + (sizeof(USHORT) * 4);
    534                         len = *(USHORT *) data;
    535                         data += sizeof(USHORT);
    536                         while ((data - info->value) + len <= info->cbValue) {
    537                           if (last != '\n') {
    538                             WinSendDlgItemMsg(hwnd,
    539                                               EA_MLE,
    540                                               MLM_SETIMPORTEXPORT,
    541                                               MPFROMP(linefeed),
    542                                               MPFROMLONG(1));
    543                             WinSendDlgItemMsg(hwnd,
    544                                               EA_MLE,
    545                                               MLM_IMPORT,
    546                                               MPFROMP(&pos), MPFROMLONG(1));
    547                           }
    548                           WinSendDlgItemMsg(hwnd,
    549                                             EA_MLE,
    550                                             MLM_SETIMPORTEXPORT,
    551                                             MPFROMP(data),
    552                                             MPFROMLONG((ULONG) len));
    553                           WinSendDlgItemMsg(hwnd,
    554                                             EA_MLE,
    555                                             MLM_IMPORT,
    556                                             MPFROMP(&pos),
    557                                             MPFROMLONG((ULONG) len));
    558                           data += len;
    559                           last = *(data - 1);
    560                           if (data - info->value >= info->cbValue)
    561                             break;
    562                           len = *(USHORT *) data;
    563                           data += sizeof(USHORT);
    564                         }
    565                         WinShowWindow(WinWindowFromID(hwnd, EA_MLE), TRUE);
    566                         WinEnableWindow(WinWindowFromID(hwnd, EA_CHANGE),
    567                                         FALSE);
    568                         WinShowWindow(WinWindowFromID(hwnd, EA_CHANGE), TRUE);
    569                       }
    570                       else {
    571                         WinShowWindow(WinWindowFromID(hwnd, EA_MLE), FALSE);
    572                         HexDumpEA(hwnd, info);
    573                         WinShowWindow(WinWindowFromID(hwnd, EA_HEXDUMP),
    574                                       TRUE);
    575                       }
    576                       {
    577                         CHAR str[81];
    578 
    579                         sprintf(str,
    580                                 GetPString(IDS_MVSTTEXT),
    581                                 num,
    582                                 (num == 1) ?
    583                                 GetPString(IDS_YTEXT) :
    584                                 GetPString(IDS_IESTEXT), info->cbValue);
    585                         WinSetDlgItemText(hwnd, EA_TEXT, str);
    586                       }
    587                       break;
    588                     case EAT_MVMT:
    589                       MLEclearall(WinWindowFromID(hwnd, EA_MLE));
    590                       num = *(USHORT *) (info->value + (sizeof(USHORT) * 2));
    591                       data = info->value + (sizeof(USHORT) * 3);
    592                       type = *(USHORT *) data;
    593                       data += sizeof(USHORT);
    594                       len = *(USHORT *) data;
    595                       data += sizeof(USHORT);
    596                       alltext = TRUE;
    597                       while ((data - info->value) - len <= info->cbValue) {
    598                         if (type != EAT_ASCII) {
    599                           alltext = FALSE;
    600                           break;
    601                         }
    602                         data += len;
    603                         if (data - info->value >= info->cbValue)
    604                           break;
    605                         type = *(USHORT *) data;
    606                         data += sizeof(USHORT);
    607                         len = *(USHORT *) data;
    608                         data += sizeof(USHORT);
    609                       }
    610                       if (alltext) {
    611                         data = info->value + (sizeof(USHORT) * 3);
    612                         type = *(USHORT *) data;
    613                         data += sizeof(USHORT);
    614                         len = *(USHORT *) data;
    615                         data += sizeof(USHORT);
    616                         while ((data - info->value) - len <= info->cbValue) {
    617                           if (last != '\n') {
    618                             WinSendDlgItemMsg(hwnd,
    619                                               EA_MLE,
    620                                               MLM_SETIMPORTEXPORT,
    621                                               MPFROMP(linefeed),
    622                                               MPFROMLONG(1));
    623                             WinSendDlgItemMsg(hwnd,
    624                                               EA_MLE,
    625                                               MLM_IMPORT,
    626                                               MPFROMP(&pos), MPFROMLONG(1));
    627                           }
    628                           WinSendDlgItemMsg(hwnd,
    629                                             EA_MLE,
    630                                             MLM_SETIMPORTEXPORT,
    631                                             MPFROMP(data),
    632                                             MPFROMLONG((ULONG) len));
    633                           WinSendDlgItemMsg(hwnd,
    634                                             EA_MLE,
    635                                             MLM_IMPORT,
    636                                             MPFROMP(&pos),
    637                                             MPFROMLONG((ULONG) len));
    638                           data += len;
    639                           last = *(data - 1);
    640                           if (data - info->value >= info->cbValue)
    641                             break;
    642                           type = *(USHORT *) data;
    643                           data += sizeof(USHORT);
    644                           len = *(USHORT *) data;
    645                           data += sizeof(USHORT);
    646                         }
    647                       }
    648                       if (alltext) {
    649                         WinShowWindow(WinWindowFromID(hwnd, EA_MLE), TRUE);
    650                         WinEnableWindow(WinWindowFromID(hwnd,
    651                                                         EA_CHANGE), FALSE);
    652                         WinShowWindow(WinWindowFromID(hwnd, EA_CHANGE), TRUE);
    653                       }
    654                       else {
    655                         WinShowWindow(WinWindowFromID(hwnd, EA_MLE), FALSE);
    656                         HexDumpEA(hwnd, info);
    657                         WinShowWindow(WinWindowFromID(hwnd, EA_HEXDUMP),
    658                                       TRUE);
    659                       }
    660                       {
    661                         CHAR str[81];
    662 
    663                         sprintf(str,
    664                                 GetPString(IDS_MVMTTEXT),
    665                                 num,
    666                                 (num == 1) ?
    667                                 GetPString(IDS_YTEXT) :
    668                                 GetPString(IDS_IESTEXT),
    669                                 info->cbValue,
    670                                 (alltext) ?
    671                                 GetPString(IDS_ALLTEXTTEXT) :
    672                                 GetPString(IDS_MIXEDTYPESTEXT));
    673                         WinSetDlgItemText(hwnd, EA_TEXT, str);
    674                       }
    675                       break;
    676                     default:
    677                       HexDumpEA(hwnd, info);
    678                       WinShowWindow(WinWindowFromID(hwnd, EA_HEXDUMP), TRUE);
    679                       switch (*(USHORT *) info->value) {
    680                       case EAT_BINARY:
    681                         {
    682                           CHAR str[81];
    683 
    684                           sprintf(str,
    685                                   GetPString(IDS_BINARYBYTESTEXT),
    686                                   info->cbValue);
    687                           WinSetDlgItemText(hwnd, EA_TEXT, str);
    688                         }
    689                         break;
    690                       case EAT_BITMAP:
    691                         {
    692                           CHAR str[81];
    693 
    694                           sprintf(str,
    695                                   GetPString(IDS_BITMAPBYTESTEXT),
    696                                   info->cbValue);
    697                           WinSetDlgItemText(hwnd, EA_TEXT, str);
    698                         }
    699                         break;
    700                       case EAT_METAFILE:
    701                         {
    702                           CHAR str[81];
    703 
    704                           sprintf(str,
    705                                   GetPString(IDS_METAFILEBYTESTEXT),
    706                                   info->cbValue);
    707                           WinSetDlgItemText(hwnd, EA_TEXT, str);
    708                         }
    709                         break;
    710                       case EAT_ICON:
    711                         {
    712                           CHAR str[81];
    713 
    714                           sprintf(str,
    715                                   GetPString(IDS_ICONBYTESTEXT),
    716                                   info->cbValue);
    717                           WinSetDlgItemText(hwnd, EA_TEXT, str);
    718                         }
    719                         break;
    720                       case EAT_ASN1:
    721                         {
    722                           CHAR str[81];
    723 
    724                           sprintf(str,
    725                                   GetPString(IDS_ASN1BYTESTEXT),
    726                                   info->cbValue);
    727                           WinSetDlgItemText(hwnd, EA_TEXT, str);
    728                         }
    729                         break;
    730                       default:
    731                         {
    732                           CHAR str[81];
    733 
    734                           sprintf(str,
    735                                   GetPString(IDS_UNKNOWNBYTESTEXT),
    736                                   *(USHORT *) info->value, info->cbValue);
    737                           WinSetDlgItemText(hwnd, EA_TEXT, str);
    738                         }
    739                         break;
    740                       }
    741                       break;
    742                     }
    743                   }
    744                   info = info->next;
    745                 }
    746               }
    747             }
    748           }
    749           if (!isalpha(*eap->filename) ||
    750               (driveflags[toupper(*eap->filename) - 'A'] &
    751                DRIVE_NOTWRITEABLE)) {
    752             WinEnableWindow(WinWindowFromID(hwnd, EA_CHANGE), FALSE);
    753             WinEnableWindow(WinWindowFromID(hwnd, EA_ADD), FALSE);
    754             WinEnableWindow(WinWindowFromID(hwnd, EA_DELETE), FALSE);
    755           }
    756           else {
    757             WinEnableWindow(WinWindowFromID(hwnd, EA_CHANGE), TRUE);
    758             WinEnableWindow(WinWindowFromID(hwnd, EA_ADD), TRUE);
    759             WinEnableWindow(WinWindowFromID(hwnd, EA_DELETE), TRUE);
    760           }
    761         }
    762         break;
     467        {
     468          CHAR s[1024];
     469          SHORT sSelect;
     470
     471          eap->current = NULL;
     472          if (eap->head) {
     473            WinSetDlgItemText(hwnd, EA_TEXT, NullStr);
     474            WinShowWindow(WinWindowFromID(hwnd, EA_ENTRY), FALSE);
     475            WinSetDlgItemText(hwnd, EA_ENTRY, NullStr);
     476            MLEclearall(WinWindowFromID(hwnd, EA_MLE));
     477            WinShowWindow(WinWindowFromID(hwnd, EA_MLE), FALSE);
     478            WinShowWindow(WinWindowFromID(hwnd, EA_CHANGE), FALSE);
     479            WinShowWindow(WinWindowFromID(hwnd, EA_DELETE), FALSE);
     480            WinShowWindow(WinWindowFromID(hwnd, EA_HEXDUMP), FALSE);
     481            WinSendDlgItemMsg(hwnd, EA_HEXDUMP, LM_DELETEALL, MPVOID, MPVOID);
     482            *s = 0;
     483            sSelect = (USHORT) WinSendDlgItemMsg(hwnd, EA_LISTBOX,
     484                                                LM_QUERYSELECTION,
     485                                                MPFROMSHORT(LIT_FIRST),
     486                                                MPVOID);
     487            if (sSelect >= 0) {
     488              WinSendDlgItemMsg(hwnd, EA_LISTBOX, LM_QUERYITEMTEXT,
     489                                MPFROM2SHORT(sSelect, 1024), MPFROMP(s));
     490              if (*s) {
     491
     492                USHORT len, num, type;
     493                CHAR *data;
     494                CHAR last = '\n';
     495                const CHAR *linefeed = "\n";
     496                BOOL alltext;
     497                IPT pos = 0;
     498
     499                info = eap->head;
     500                while (info) {
     501                  if (!strcmp(s, info->name)) {
     502                    eap->current = info;
     503                    WinShowWindow(WinWindowFromID(hwnd, EA_DELETE), TRUE);
     504                    switch (*(USHORT *) info->value) {
     505                    case EAT_EA:
     506                    case EAT_ASCII:
     507                      if (!strcmp(info->name, SUBJECT))
     508                        WinSendDlgItemMsg(hwnd, EA_ENTRY,
     509                                          EM_SETTEXTLIMIT,
     510                                          MPFROM2SHORT(1024, 0), MPVOID);
     511                      else
     512                        WinSendDlgItemMsg(hwnd, EA_ENTRY,
     513                                          EM_SETTEXTLIMIT,
     514                                          MPFROM2SHORT(1024, 0), MPVOID);
     515                      WinSetDlgItemText(hwnd, EA_ENTRY,
     516                                        info->value + (sizeof(USHORT) * 2));
     517                      WinShowWindow(WinWindowFromID(hwnd, EA_ENTRY), TRUE);
     518                      WinEnableWindow(WinWindowFromID(hwnd, EA_CHANGE),
     519                                      FALSE);
     520                      WinShowWindow(WinWindowFromID(hwnd, EA_CHANGE), TRUE);
     521                      {
     522                        CHAR str[81];
     523
     524                        sprintf(str,
     525                                GetPString(IDS_DATAANDBYTESTEXT),
     526                                (*(USHORT *) info->value == EAT_ASCII) ?
     527                                GetPString(IDS_TEXTTEXT) :
     528                                GetPString(IDS_EAREFTEXT), info->cbValue);
     529                        WinSetDlgItemText(hwnd, EA_TEXT, str);
     530                      }
     531                      break;
     532                    case EAT_MVST:
     533                      MLEclearall(WinWindowFromID(hwnd, EA_MLE));
     534                      num = *(USHORT *) (info->value + (sizeof(USHORT) * 2));
     535                      type = *(USHORT *) (info->value + (sizeof(USHORT) * 3));
     536                      if (type == EAT_ASCII) {
     537                        data = info->value + (sizeof(USHORT) * 4);
     538                        len = *(USHORT *) data;
     539                        data += sizeof(USHORT);
     540                        while ((data - info->value) + len <= info->cbValue) {
     541                          if (last != '\n') {
     542                            WinSendDlgItemMsg(hwnd,
     543                                              EA_MLE,
     544                                              MLM_SETIMPORTEXPORT,
     545                                              MPFROMP(linefeed),
     546                                              MPFROMLONG(1));
     547                            WinSendDlgItemMsg(hwnd,
     548                                              EA_MLE,
     549                                              MLM_IMPORT,
     550                                              MPFROMP(&pos), MPFROMLONG(1));
     551                          }
     552                          WinSendDlgItemMsg(hwnd,
     553                                            EA_MLE,
     554                                            MLM_SETIMPORTEXPORT,
     555                                            MPFROMP(data),
     556                                            MPFROMLONG((ULONG) len));
     557                          WinSendDlgItemMsg(hwnd,
     558                                            EA_MLE,
     559                                            MLM_IMPORT,
     560                                            MPFROMP(&pos),
     561                                            MPFROMLONG((ULONG) len));
     562                          data += len;
     563                          last = *(data - 1);
     564                          if (data - info->value >= info->cbValue)
     565                            break;
     566                          len = *(USHORT *) data;
     567                          data += sizeof(USHORT);
     568                        }
     569                        WinShowWindow(WinWindowFromID(hwnd, EA_MLE), TRUE);
     570                        WinEnableWindow(WinWindowFromID(hwnd, EA_CHANGE),
     571                                        FALSE);
     572                        WinShowWindow(WinWindowFromID(hwnd, EA_CHANGE), TRUE);
     573                      }
     574                      else {
     575                        WinShowWindow(WinWindowFromID(hwnd, EA_MLE), FALSE);
     576                        HexDumpEA(hwnd, info);
     577                        WinShowWindow(WinWindowFromID(hwnd, EA_HEXDUMP),
     578                                      TRUE);
     579                      }
     580                      {
     581                        CHAR str[81];
     582
     583                        sprintf(str,
     584                                GetPString(IDS_MVSTTEXT),
     585                                num,
     586                                (num == 1) ?
     587                                GetPString(IDS_YTEXT) :
     588                                GetPString(IDS_IESTEXT), info->cbValue);
     589                        WinSetDlgItemText(hwnd, EA_TEXT, str);
     590                      }
     591                      break;
     592                    case EAT_MVMT:
     593                      MLEclearall(WinWindowFromID(hwnd, EA_MLE));
     594                      num = *(USHORT *) (info->value + (sizeof(USHORT) * 2));
     595                      data = info->value + (sizeof(USHORT) * 3);
     596                      type = *(USHORT *) data;
     597                      data += sizeof(USHORT);
     598                      len = *(USHORT *) data;
     599                      data += sizeof(USHORT);
     600                      alltext = TRUE;
     601                      while ((data - info->value) - len <= info->cbValue) {
     602                        if (type != EAT_ASCII) {
     603                          alltext = FALSE;
     604                          break;
     605                        }
     606                        data += len;
     607                        if (data - info->value >= info->cbValue)
     608                          break;
     609                        type = *(USHORT *) data;
     610                        data += sizeof(USHORT);
     611                        len = *(USHORT *) data;
     612                        data += sizeof(USHORT);
     613                      }
     614                      if (alltext) {
     615                        data = info->value + (sizeof(USHORT) * 3);
     616                        type = *(USHORT *) data;
     617                        data += sizeof(USHORT);
     618                        len = *(USHORT *) data;
     619                        data += sizeof(USHORT);
     620                        while ((data - info->value) - len <= info->cbValue) {
     621                          if (last != '\n') {
     622                            WinSendDlgItemMsg(hwnd,
     623                                              EA_MLE,
     624                                              MLM_SETIMPORTEXPORT,
     625                                              MPFROMP(linefeed),
     626                                              MPFROMLONG(1));
     627                            WinSendDlgItemMsg(hwnd,
     628                                              EA_MLE,
     629                                              MLM_IMPORT,
     630                                              MPFROMP(&pos), MPFROMLONG(1));
     631                          }
     632                          WinSendDlgItemMsg(hwnd,
     633                                            EA_MLE,
     634                                            MLM_SETIMPORTEXPORT,
     635                                            MPFROMP(data),
     636                                            MPFROMLONG((ULONG) len));
     637                          WinSendDlgItemMsg(hwnd,
     638                                            EA_MLE,
     639                                            MLM_IMPORT,
     640                                            MPFROMP(&pos),
     641                                            MPFROMLONG((ULONG) len));
     642                          data += len;
     643                          last = *(data - 1);
     644                          if (data - info->value >= info->cbValue)
     645                            break;
     646                          type = *(USHORT *) data;
     647                          data += sizeof(USHORT);
     648                          len = *(USHORT *) data;
     649                          data += sizeof(USHORT);
     650                        }
     651                      }
     652                      if (alltext) {
     653                        WinShowWindow(WinWindowFromID(hwnd, EA_MLE), TRUE);
     654                        WinEnableWindow(WinWindowFromID(hwnd,
     655                                                        EA_CHANGE), FALSE);
     656                        WinShowWindow(WinWindowFromID(hwnd, EA_CHANGE), TRUE);
     657                      }
     658                      else {
     659                        WinShowWindow(WinWindowFromID(hwnd, EA_MLE), FALSE);
     660                        HexDumpEA(hwnd, info);
     661                        WinShowWindow(WinWindowFromID(hwnd, EA_HEXDUMP),
     662                                      TRUE);
     663                      }
     664                      {
     665                        CHAR str[81];
     666
     667                        sprintf(str,
     668                                GetPString(IDS_MVMTTEXT),
     669                                num,
     670                                (num == 1) ?
     671                                GetPString(IDS_YTEXT) :
     672                                GetPString(IDS_IESTEXT),
     673                                info->cbValue,
     674                                (alltext) ?
     675                                GetPString(IDS_ALLTEXTTEXT) :
     676                                GetPString(IDS_MIXEDTYPESTEXT));
     677                        WinSetDlgItemText(hwnd, EA_TEXT, str);
     678                      }
     679                      break;
     680                    default:
     681                      HexDumpEA(hwnd, info);
     682                      WinShowWindow(WinWindowFromID(hwnd, EA_HEXDUMP), TRUE);
     683                      switch (*(USHORT *) info->value) {
     684                      case EAT_BINARY:
     685                        {
     686                          CHAR str[81];
     687
     688                          sprintf(str,
     689                                  GetPString(IDS_BINARYBYTESTEXT),
     690                                  info->cbValue);
     691                          WinSetDlgItemText(hwnd, EA_TEXT, str);
     692                        }
     693                        break;
     694                      case EAT_BITMAP:
     695                        {
     696                          CHAR str[81];
     697
     698                          sprintf(str,
     699                                  GetPString(IDS_BITMAPBYTESTEXT),
     700                                  info->cbValue);
     701                          WinSetDlgItemText(hwnd, EA_TEXT, str);
     702                        }
     703                        break;
     704                      case EAT_METAFILE:
     705                        {
     706                          CHAR str[81];
     707
     708                          sprintf(str,
     709                                  GetPString(IDS_METAFILEBYTESTEXT),
     710                                  info->cbValue);
     711                          WinSetDlgItemText(hwnd, EA_TEXT, str);
     712                        }
     713                        break;
     714                      case EAT_ICON:
     715                        {
     716                          CHAR str[81];
     717
     718                          sprintf(str,
     719                                  GetPString(IDS_ICONBYTESTEXT),
     720                                  info->cbValue);
     721                          WinSetDlgItemText(hwnd, EA_TEXT, str);
     722                        }
     723                        break;
     724                      case EAT_ASN1:
     725                        {
     726                          CHAR str[81];
     727
     728                          sprintf(str,
     729                                  GetPString(IDS_ASN1BYTESTEXT),
     730                                  info->cbValue);
     731                          WinSetDlgItemText(hwnd, EA_TEXT, str);
     732                        }
     733                        break;
     734                      default:
     735                        {
     736                          CHAR str[81];
     737
     738                          sprintf(str,
     739                                  GetPString(IDS_UNKNOWNBYTESTEXT),
     740                                  *(USHORT *) info->value, info->cbValue);
     741                          WinSetDlgItemText(hwnd, EA_TEXT, str);
     742                        }
     743                        break;
     744                      }
     745                      break;
     746                    }
     747                  }
     748                  info = info->next;
     749                }
     750              }
     751            }
     752          }
     753          if (!isalpha(*eap->filename) ||
     754              (driveflags[toupper(*eap->filename) - 'A'] &
     755               DRIVE_NOTWRITEABLE)) {
     756            WinEnableWindow(WinWindowFromID(hwnd, EA_CHANGE), FALSE);
     757            WinEnableWindow(WinWindowFromID(hwnd, EA_ADD), FALSE);
     758            WinEnableWindow(WinWindowFromID(hwnd, EA_DELETE), FALSE);
     759          }
     760          else {
     761            WinEnableWindow(WinWindowFromID(hwnd, EA_CHANGE), TRUE);
     762            WinEnableWindow(WinWindowFromID(hwnd, EA_ADD), TRUE);
     763            WinEnableWindow(WinWindowFromID(hwnd, EA_DELETE), TRUE);
     764          }
     765        }
     766        break;
    763767      }
    764768      break;
    … …  
    767771      switch (SHORT2FROMMP(mp1)) {
    768772      case EN_SETFOCUS:
    769         WinSetDlgItemText(hwnd, EA_HELP, GetPString(IDS_EADATAHELPTEXT));
    770         break;
     773        WinSetDlgItemText(hwnd, EA_HELP, GetPString(IDS_EADATAHELPTEXT));
     774        break;
    771775      case EN_KILLFOCUS:
    772         WinSetDlgItemText(hwnd, EA_HELP, NullStr);
    773         break;
     776        WinSetDlgItemText(hwnd, EA_HELP, NullStr);
     777        break;
    774778      case EN_CHANGE:
    775         WinEnableWindow(WinWindowFromID(hwnd, EA_CHANGE), TRUE);
    776         break;
     779        WinEnableWindow(WinWindowFromID(hwnd, EA_CHANGE), TRUE);
     780        break;
    777781      }
    778782      break;
    … …  
    781785      switch (SHORT2FROMMP(mp1)) {
    782786      case LN_SETFOCUS:
    783         WinSetDlgItemText(hwnd, EA_HELP, GetPString(IDS_EADATAHELPTEXT));
    784         break;
     787        WinSetDlgItemText(hwnd, EA_HELP, GetPString(IDS_EADATAHELPTEXT));
     788        break;
    785789      case LN_KILLFOCUS:
    786         WinSetDlgItemText(hwnd, EA_HELP, NullStr);
    787         break;
     790        WinSetDlgItemText(hwnd, EA_HELP, NullStr);
     791        break;
    788792      }
    789793      break;
    … …  
    792796      switch (SHORT2FROMMP(mp1)) {
    793797      case MLN_SETFOCUS:
    794         WinSetDlgItemText(hwnd, EA_HELP, GetPString(IDS_EADATAHELPTEXT));
    795         break;
     798        WinSetDlgItemText(hwnd, EA_HELP, GetPString(IDS_EADATAHELPTEXT));
     799        break;
    796800      case MLN_KILLFOCUS:
    797         WinSetDlgItemText(hwnd, EA_HELP, NullStr);
    798         break;
     801        WinSetDlgItemText(hwnd, EA_HELP, NullStr);
     802        break;
    799803      case MLN_CHANGE:
    800         WinEnableWindow(WinWindowFromID(hwnd, EA_CHANGE), TRUE);
    801         break;
     804        WinEnableWindow(WinWindowFromID(hwnd, EA_CHANGE), TRUE);
     805        break;
    802806      }
    803807      break;
    … …  
    809813    case EA_ADD:
    810814      {
    811         ADDEA add;
    812 
    813         add.filename = eap->filename;
    814         add.head = eap->head;
    815         if (WinDlgBox(HWND_DESKTOP, hwnd, AddEAProc, FM3ModHandle,
    816                       EAC_FRAME, &add)) {
    817           Free_FEAList(eap->head);
    818           eap->head = GetFileEAs(eap->filename, FALSE, FALSE);
    819           WinSendMsg(hwnd, UM_SETUP, MPVOID, MPVOID);
    820         }
     815        ADDEA add;
     816
     817        add.filename = eap->filename;
     818        add.head = eap->head;
     819        if (WinDlgBox(HWND_DESKTOP, hwnd, AddEAProc, FM3ModHandle,
     820                      EAC_FRAME, &add)) {
     821          Free_FEAList(eap->head);
     822          eap->head = GetFileEAs(eap->filename, FALSE, FALSE);
     823          WinSendMsg(hwnd, UM_SETUP, MPVOID, MPVOID);
     824        }
    821825      }
    822826      break;
    823827    case EA_CHANGE:
    824828      if (!eap->current)
    825         WinShowWindow(WinWindowFromID(hwnd, EA_CHANGE), FALSE);
     829        WinShowWindow(WinWindowFromID(hwnd, EA_CHANGE), FALSE);
    826830      else {
    827831
    828         CHAR *s;
    829         USHORT control;
    830 
    831         if (!eap->head || !*eap->filename)
    832           Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
    833         else {
    834           switch (*(USHORT *) eap->current->value) {
    835           case EAT_EA:
    836           case EAT_ASCII:
    837             control = EA_ENTRY;
    838             break;
    839           case EAT_MVMT:
    840             control = EA_MLE;
    841             break;
    842           case EAT_MVST:
    843             control = EA_MLE;
    844             break;
    845           default:
    846             Runtime_Error(pszSrcFile, __LINE__, "unexpected type");
    847             WinShowWindow(WinWindowFromID(hwnd, EA_CHANGE), FALSE);
    848             control = 0;
    849           }
    850           if (control) {
    851             s = xmalloc(32768, pszSrcFile, __LINE__);
    852             if (s) {
    853               *s = 0;
    854               WinQueryDlgItemText(hwnd, control, 32767, (PCH) s);
    855               if (!*s)
    856                 Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
    857               else {
    858                 PFEA2LIST pfealist;
    859 
    860                 pfealist = SaveEA(eap->filename, eap->current, s, FALSE);
    861                 if (!pfealist)
    862                   Runtime_Error(pszSrcFile, __LINE__, "SaveEA");
    863                 else {
    864                   PFEA2 pfea;
    865 
    866                   pfea = xmalloc(pfealist->cbList, pszSrcFile, __LINE__);
    867                   if (pfea) {
    868                     memcpy(pfea, pfealist->list,
    869                            pfealist->cbList - sizeof(ULONG));
    870                     free(eap->current->pfea);
    871                     eap->current->pfea = pfea;
    872                     eap->current->name = eap->current->pfea->szName;
    873                     eap->current->cbName = eap->current->pfea->cbName;
    874                     eap->current->cbValue = eap->current->pfea->cbValue;
    875                     eap->current->value = eap->current->pfea->szName +
    876                       eap->current->pfea->cbName + 1;
    877                     eap->current->value[eap->current->cbValue] = 0;
    878                     PostMsg(hwnd, WM_CONTROL,
    879                             MPFROM2SHORT(EA_LISTBOX, LN_SELECT), MPVOID);
    880                   }
    881                   DosFreeMem(pfealist);
    882                 }
    883               }
    884               free(s);
    885             }
    886           }
    887         }
     832        CHAR *s;
     833        USHORT control;
     834
     835        if (!eap->head || !*eap->filename)
     836          Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
     837        else {
     838          switch (*(USHORT *) eap->current->value) {
     839          case EAT_EA:
     840          case EAT_ASCII:
     841            control = EA_ENTRY;
     842            break;
     843          case EAT_MVMT:
     844            control = EA_MLE;
     845            break;
     846          case EAT_MVST:
     847            control = EA_MLE;
     848            break;
     849          default:
     850            Runtime_Error(pszSrcFile, __LINE__, "unexpected type");
     851            WinShowWindow(WinWindowFromID(hwnd, EA_CHANGE), FALSE);
     852            control = 0;
     853          }
     854          if (control) {
     855            s = xmalloc(32768, pszSrcFile, __LINE__);
     856            if (s) {
     857              *s = 0;
     858              WinQueryDlgItemText(hwnd, control, 32767, (PCH) s);
     859              if (!*s)
     860                Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
     861              else {
     862                PFEA2LIST pfealist;
     863
     864                pfealist = SaveEA(eap->filename, eap->current, s, FALSE);
     865                if (!pfealist)
     866                  Runtime_Error(pszSrcFile, __LINE__, "SaveEA");
     867                else {
     868                  PFEA2 pfea;
     869
     870                  pfea = xmalloc(pfealist->cbList, pszSrcFile, __LINE__);
     871                  if (pfea) {
     872                    memcpy(pfea, pfealist->list,
     873                           pfealist->cbList - sizeof(ULONG));
     874                    free(eap->current->pfea);
     875                    eap->current->pfea = pfea;
     876                    eap->current->name = eap->current->pfea->szName;
     877                    eap->current->cbName = eap->current->pfea->cbName;
     878                    eap->current->cbValue = eap->current->pfea->cbValue;
     879                    eap->current->value = eap->current->pfea->szName +
     880                      eap->current->pfea->cbName + 1;
     881                    eap->current->value[eap->current->cbValue] = 0;
     882                    PostMsg(hwnd, WM_CONTROL,
     883                            MPFROM2SHORT(EA_LISTBOX, LN_SELECT), MPVOID);
     884                  }
     885                  DosFreeMem(pfealist);
     886                }
     887              }
     888              free(s);
     889            }
     890          }
     891        }
    888892      }
    889893      break;
    … …  
    892896      if (eap->head && eap->current) {
    893897
    894         EAOP2 eaop;
    895         PFEA2LIST pfealist;
    896         GEA2LIST gealist;
    897         APIRET rc;
    898         SHORT sSelect;
    899 
    900         pfealist =
    901           xmallocz(sizeof(FEA2LIST) + eap->current->cbName + 1, pszSrcFile,
    902                    __LINE__);
    903         if (pfealist) {
    904           pfealist->cbList = sizeof(FEA2LIST) + eap->current->cbName + 1;
    905           pfealist->list[0].cbName = eap->current->cbName;
    906           strcpy(pfealist->list[0].szName, eap->current->name);
    907           pfealist->list[0].cbValue = 0;
    908           memset(&gealist, 0, sizeof(GEA2LIST));
    909           gealist.cbList = sizeof(GEA2LIST);
    910           eaop.fpGEA2List = &gealist;
    911           eaop.fpFEA2List = pfealist;
    912           eaop.oError = 0;
    913           rc = xDosSetPathInfo(eap->filename, FIL_QUERYEASIZE,
    914                                &eaop, sizeof(eaop), DSPI_WRTTHRU);
    915           free(pfealist);
    916           if (rc)
    917             Dos_Error(MB_CANCEL, rc, hwnd, pszSrcFile, __LINE__,
    918                       "xDosSetPathInfo");
    919           else {
    920             sSelect = 0;
    921             if (eap->current == eap->head) {
    922               eap->head = eap->head->next;
    923               free(eap->current->pfea);
    924               free(eap->current);
    925               eap->current = NULL;
    926             }
    927             else {
    928               info = eap->head;
    929               while (info) {
    930                 if (info->next == eap->current) {
    931                   sSelect++;
    932                   info->next = eap->current->next;
    933                   free(eap->current->pfea);
    934                   free(eap->current);
    935                   eap->current = NULL;
    936                   break;
    937                 }
    938                 sSelect++;
    939                 info = info->next;
    940               }
    941             }
    942             WinSendDlgItemMsg(hwnd, EA_LISTBOX, LM_DELETEITEM,
    943                               MPFROM2SHORT(sSelect, 0), MPVOID);
    944             WinShowWindow(WinWindowFromID(hwnd, EA_ENTRY), FALSE);
    945             WinShowWindow(WinWindowFromID(hwnd, EA_MLE), FALSE);
    946             WinShowWindow(WinWindowFromID(hwnd, EA_CHANGE), FALSE);
    947             WinShowWindow(WinWindowFromID(hwnd, EA_DELETE), FALSE);
    948             WinShowWindow(WinWindowFromID(hwnd, EA_HEXDUMP), FALSE);
    949             WinSetDlgItemText(hwnd, EA_ENTRY, NullStr);
    950             MLEclearall(WinWindowFromID(hwnd, EA_MLE));
    951             WinSendDlgItemMsg(hwnd, EA_HEXDUMP, LM_DELETEALL, MPVOID, MPVOID);
    952             if (sSelect && (SHORT) WinSendDlgItemMsg(hwnd, EA_LISTBOX,
    953                                                      LM_QUERYITEMCOUNT,
    954                                                      MPVOID, MPVOID) <=
    955                 sSelect)
    956               sSelect--;
    957             WinSendDlgItemMsg(hwnd, EA_LISTBOX, LM_SELECTITEM,
    958                               MPFROM2SHORT(sSelect, 0),
    959                               MPFROM2SHORT(TRUE, 0));
    960           }
    961         }
     898        EAOP2 eaop;
     899        PFEA2LIST pfealist;
     900        GEA2LIST gealist;
     901        APIRET rc;
     902        SHORT sSelect;
     903
     904        pfealist =
     905          xmallocz(sizeof(FEA2LIST) + eap->current->cbName + 1, pszSrcFile,
     906                   __LINE__);
     907        if (pfealist) {
     908          pfealist->cbList = sizeof(FEA2LIST) + eap->current->cbName + 1;
     909          pfealist->list[0].cbName = eap->current->cbName;
     910          strcpy(pfealist->list[0].szName, eap->current->name);
     911          pfealist->list[0].cbValue = 0;
     912          memset(&gealist, 0, sizeof(GEA2LIST));
     913          gealist.cbList = sizeof(GEA2LIST);
     914          eaop.fpGEA2List = &gealist;
     915          eaop.fpFEA2List = pfealist;
     916          eaop.oError = 0;
     917          rc = xDosSetPathInfo(eap->filename, FIL_QUERYEASIZE,
     918                               &eaop, sizeof(eaop), DSPI_WRTTHRU);
     919          free(pfealist);
     920          if (rc)
     921            Dos_Error(MB_CANCEL, rc, hwnd, pszSrcFile, __LINE__,
     922                      "xDosSetPathInfo");
     923          else {
     924            sSelect = 0;
     925            if (eap->current == eap->head) {
     926              eap->head = eap->head->next;
     927              free(eap->current->pfea);
     928              free(eap->current);
     929              eap->current = NULL;
     930            }
     931            else {
     932              info = eap->head;
     933              while (info) {
     934                if (info->next == eap->current) {
     935                  sSelect++;
     936                  info->next = eap->current->next;
     937                  free(eap->current->pfea);
     938                  free(eap->current);
     939                  eap->current = NULL;
     940                  break;
     941                }
     942                sSelect++;
     943                info = info->next;
     944              }
     945            }
     946            WinSendDlgItemMsg(hwnd, EA_LISTBOX, LM_DELETEITEM,
     947                              MPFROM2SHORT(sSelect, 0), MPVOID);
     948            WinShowWindow(WinWindowFromID(hwnd, EA_ENTRY), FALSE);
     949            WinShowWindow(WinWindowFromID(hwnd, EA_MLE), FALSE);
     950            WinShowWindow(WinWindowFromID(hwnd, EA_CHANGE), FALSE);
     951            WinShowWindow(WinWindowFromID(hwnd, EA_DELETE), FALSE);
     952            WinShowWindow(WinWindowFromID(hwnd, EA_HEXDUMP), FALSE);
     953            WinSetDlgItemText(hwnd, EA_ENTRY, NullStr);
     954            MLEclearall(WinWindowFromID(hwnd, EA_MLE));
     955            WinSendDlgItemMsg(hwnd, EA_HEXDUMP, LM_DELETEALL, MPVOID, MPVOID);
     956            if (sSelect && (SHORT) WinSendDlgItemMsg(hwnd, EA_LISTBOX,
     957                                                     LM_QUERYITEMCOUNT,
     958                                                     MPVOID, MPVOID) <=
     959                sSelect)
     960              sSelect--;
     961            WinSendDlgItemMsg(hwnd, EA_LISTBOX, LM_SELECTITEM,
     962                              MPFROM2SHORT(sSelect, 0),
     963                              MPFROM2SHORT(TRUE, 0));
     964          }
     965        }
    962966      }
    963967      if (!eap->head)
    964         WinSetDlgItemText(hwnd, EA_TEXT, GetPString(IDS_EANOEAS));
     968        WinSetDlgItemText(hwnd, EA_TEXT, GetPString(IDS_EANOEAS));
    965969      break;
    966970
    967971    case IDM_HELP:
    968972      if (hwndHelp)
    969         WinSendMsg(hwndHelp, HM_DISPLAY_HELP,
    970                    MPFROM2SHORT(HELP_EAS, 0), MPFROMSHORT(HM_RESOURCEID));
     973        WinSendMsg(hwndHelp, HM_DISPLAY_HELP,
     974                   MPFROM2SHORT(HELP_EAS, 0), MPFROMSHORT(HM_RESOURCEID));
    971975      break;
    972976
    … …  
    987991    if (eap) {
    988992      if (eap->head)
    989         Free_FEAList(eap->head);
     993        Free_FEAList(eap->head);
    990994      free(eap);
    991995      if (hptrIcon)
    992         WinDestroyPointer(hptrIcon);
     996        WinDestroyPointer(hptrIcon);
    993997      hptrIcon = (HPOINTER) 0;
    994998    }
    995999    break;
    996   }                                     // switch
     1000  }                                     // switch
    9971001  return WinDefDlgProc(hwnd, msg, mp1, mp2);
    9981002}
    9991003
    10001004PVOID SaveEA(CHAR * filename, HOLDFEA * current, CHAR * newdata,
    1001              BOOL silentfail)
     1005             BOOL silentfail)
    10021006{
    10031007  /* save an ea to disk */
    … …  
    10141018  len = strlen(newdata);
    10151019  ealen = sizeof(FEA2LIST) + 24 + (ULONG) current->cbName + 1 +
    1016         (ULONG)len + 4;
     1020        (ULONG)len + 4;
    10171021  switch (*(USHORT *) current->value) {
    10181022  case EAT_EA:
    … …  
    10261030    while (*p) {
    10271031      if (*p == '\n' && *(p + 1))
    1028         ealen += sizeof(USHORT);
     1032        ealen += sizeof(USHORT);
    10291033      p++;
    10301034    }
    … …  
    10371041    while (*p) {
    10381042      if (*p == '\n' && *(p + 1))
    1039         ealen += (sizeof(USHORT) * 2);
     1043        ealen += (sizeof(USHORT) * 2);
    10401044      p++;
    10411045    }
    … …  
    10461050
    10471051  rc = DosAllocMem((PPVOID) & pfealist, ealen,
    1048                    OBJ_TILE | PAG_COMMIT | PAG_READ | PAG_WRITE);
     1052                   OBJ_TILE | PAG_COMMIT | PAG_READ | PAG_WRITE);
    10491053  if (rc)
    10501054    Dos_Error(MB_CANCEL, rc, HWND_DESKTOP, pszSrcFile, __LINE__,
    1051               GetPString(IDS_OUTOFMEMORY));
     1055              GetPString(IDS_OUTOFMEMORY));
    10521056  else {
    10531057    memset(pfealist, 0, ealen);
    10541058    pfealist->list[0].oNextEntryOffset = 0;
    1055     pfealist->list[0].fEA = 0;          //current->fEA;
     1059    pfealist->list[0].fEA = 0;          //current->fEA;
    10561060
    10571061    pfealist->list[0].cbName = current->cbName;
    10581062    memcpy(pfealist->list[0].szName, current->name,
    1059            pfealist->list[0].cbName + 1);
     1063           pfealist->list[0].cbName + 1);
    10601064    eaval = pfealist->list[0].szName + pfealist->list[0].cbName + 1;
    10611065    switch (*(USHORT *) current->value) {
    … …  
    10841088      p = newdata;
    10851089      while (*p == '\n')
    1086         p++;
     1090        p++;
    10871091      while (*p) {
    1088         while (*p) {
    1089           if (*p == '\n')
    1090             p++;
    1091           *eaval++ = *p++;
    1092           (*plen)++;
    1093         }
    1094         if (*p || *plen)
    1095           (*num)++;
    1096         if (*p) {
    1097           plen = (USHORT *) eaval;
    1098           *plen = 0;
    1099           eaval += sizeof(USHORT);
    1100         }
     1092        while (*p) {
     1093          if (*p == '\n')
     1094            p++;
     1095          *eaval++ = *p++;
     1096          (*plen)++;
     1097        }
     1098        if (*p || *plen)
     1099          (*num)++;
     1100        if (*p) {
     1101          plen = (USHORT *) eaval;
     1102          *plen = 0;
     1103          eaval += sizeof(USHORT);
     1104        }
    11011105      }
    11021106      break;
    … …  
    11281132      p = newdata;
    11291133      while (*p == '\n')
    1130         p++;
     1134        p++;
    11311135      while (*p) {
    1132         while (*p) {
    1133           if (*p == '\n')
    1134             p++;
    1135           *eaval++ = *p++;
    1136           (*plen)++;
    1137         }
    1138         if (*p || *plen)
    1139           (*num)++;
    1140         if (*p) {
    1141           *(USHORT *) eaval = (USHORT) EAT_ASCII;
    1142           eaval += sizeof(USHORT);
    1143           plen = (USHORT *) eaval;
    1144           *plen = 0;
    1145           eaval += sizeof(USHORT);
    1146         }
     1136        while (*p) {
     1137          if (*p == '\n')
     1138            p++;
     1139          *eaval++ = *p++;
     1140          (*plen)++;
     1141        }
     1142        if (*p || *plen)
     1143          (*num)++;
     1144        if (*p) {
     1145          *(USHORT *) eaval = (USHORT) EAT_ASCII;
     1146          eaval += sizeof(USHORT);
     1147          plen = (USHORT *) eaval;
     1148          *plen = 0;
     1149          eaval += sizeof(USHORT);
     1150        }
    11471151      }
    11481152      break;
    11491153    }
    11501154    pfealist->list[0].cbValue = /*(ULONG)*/ (eaval -
    1151                                         (pfealist->list[0].szName +
    1152                                           pfealist->list[0].cbName + 1));
     1155                                        (pfealist->list[0].szName +
     1156                                          pfealist->list[0].cbName + 1));
    11531157    eaop.fpGEA2List = (PGEA2LIST) 0;
    11541158    eaop.fpFEA2List = pfealist;
    11551159    eaop.oError = 0;
    11561160    pfealist->cbList = 13 + (ULONG) pfealist->list[0].cbName +
    1157                        (ULONG)pfealist->list[0].cbValue;
     1161                       (ULONG)pfealist->list[0].cbValue;
    11581162
    11591163    rc = xDosSetPathInfo(filename, FIL_QUERYEASIZE,
    1160                         &eaop, sizeof(eaop), DSPI_WRTTHRU);
     1164                        &eaop, sizeof(eaop), DSPI_WRTTHRU);
    11611165    if (rc) {
    11621166      DosFreeMem(pfealist);
    … …  
    11651169    if (rc && !silentfail) {
    11661170      if (rc == ERROR_ACCESS_DENIED || rc == ERROR_SHARING_VIOLATION) {
    1167         saymsg(MB_ENTER,
    1168                HWND_DESKTOP,
    1169                GetPString(IDS_OOPSTEXT),
    1170                GetPString(IDS_CANTWRITEEATEXT), current->name, filename);
     1171        saymsg(MB_ENTER,
     1172               HWND_DESKTOP,
     1173               GetPString(IDS_OOPSTEXT),
     1174               GetPString(IDS_CANTWRITEEATEXT), current->name, filename);
    11711175      }
    11721176      else {
    1173         Dos_Error(MB_ENTER,
    1174                   rc,
    1175                   HWND_DESKTOP,
    1176                   pszSrcFile,
    1177                   __LINE__,
    1178                   GetPString(IDS_ERRORWRITEEATEXT),
    1179                   current->name, filename, eaop.oError);
     1177        Dos_Error(MB_ENTER,
     1178                  rc,
     1179                  HWND_DESKTOP,
     1180                  pszSrcFile,
     1181                  __LINE__,
     1182                  GetPString(IDS_ERRORWRITEEATEXT),
     1183                  current->name, filename, eaop.oError);
    11801184      }
    11811185    }
    … …  
    11971201    return head;
    11981202  if (ishandle || !DosOpen(filename, &handle, &action, 0, 0,
    1199                            OPEN_ACTION_FAIL_IF_NEW |
    1200                            OPEN_ACTION_OPEN_IF_EXISTS,
    1201                            OPEN_FLAGS_NOINHERIT |
    1202                            OPEN_SHARE_DENYREADWRITE |
    1203                            OPEN_ACCESS_READWRITE, (PEAOP2)0)) {
     1203                           OPEN_ACTION_FAIL_IF_NEW |
     1204                           OPEN_ACTION_OPEN_IF_EXISTS,
     1205                           OPEN_FLAGS_NOINHERIT |
     1206                           OPEN_SHARE_DENYREADWRITE |
     1207                           OPEN_ACCESS_READWRITE, (PEAOP2)0)) {
    12041208    if (ishandle)
    12051209      handle = *(HFILE *) filename;
    12061210    if (!DosQueryFileInfo(handle, FIL_QUERYEASIZE, (PVOID)&fsa4,
    1207                           (ULONG) sizeof(fsa4)) &&
    1208         fsa4.cbList > 4)
     1211                          (ULONG) sizeof(fsa4)) &&
     1212        fsa4.cbList > 4)
    12091213    {
    12101214      PDENA2 pdena;
    … …  
    12131217      PFEA2LIST pfealist;
    12141218      PGEA2 pgea;
    1215       ULONG ulEntry = 1;                // Ordinal of EA to return
    1216       ULONG ulCount = 1;                // # of EAs to return
     1219      ULONG ulEntry = 1;                // Ordinal of EA to return
     1220      ULONG ulCount = 1;                // # of EAs to return
    12171221
    12181222      pdena = xmalloc(65536 + 1024, pszSrcFile, __LINE__);
    12191223      if (pdena) {
    1220         while (!DosEnumAttribute(ENUMEA_REFTYPE_FHANDLE,
    1221                                 &handle,
    1222                                 ulEntry,
    1223                                 (PVOID)pdena,
    1224                                 (ULONG)65536,
    1225                                 &ulCount,
    1226                                 ENUMEA_LEVEL_NO_VALUE) &&
    1227                ulCount)
    1228         {
    1229           // 64 is for header and spare - fixme to allocate smarter
    1230           pgealist = xmalloc(64 + pdena->cbName, pszSrcFile, __LINE__);
    1231           if (pgealist) {
    1232             pgealist->cbList = 64 + pdena->cbName;
    1233             pgea = pgealist->list;
    1234             pgea->oNextEntryOffset = 0;
    1235             pgea->cbName = pdena->cbName;
    1236             memcpy(pgea->szName, pdena->szName, pdena->cbName + 1);
    1237             pfealist = xmallocz(64 + pdena->cbName + pdena->cbValue,
    1238                                 pszSrcFile, __LINE__);
    1239             if (pfealist) {
    1240               pfealist->cbList = 64 + pdena->cbName + pdena->cbValue;
    1241               eaop.fpGEA2List = pgealist;
    1242               eaop.fpFEA2List = pfealist;
    1243               eaop.oError = 0;
    1244               // saymsg(MB_ENTER,HWND_DESKTOP,"Debug1","\"%s\" %ld",pdena->szName,ulEntry);
    1245               rc =
    1246                 DosQueryFileInfo(handle, FIL_QUERYEASFROMLIST, (PVOID) & eaop,
    1247                                 (ULONG) sizeof(EAOP2));
    1248               if (rc) {
    1249                 if (!silentfail) {
    1250                   Dos_Error(MB_ENTER,
    1251                             rc,
    1252                             HWND_DESKTOP,
    1253                             pszSrcFile,
    1254                             __LINE__,
    1255                             GetPString(IDS_ERRORREADEATEXT), pdena->szName);
    1256                 }
    1257               }
    1258               else {
    1259                 info = xmalloc(sizeof(HOLDFEA), pszSrcFile, __LINE__);
    1260                 if (info) {
    1261                   // 05 Jul 07 SHL was one short
    1262                   info->pfea = xmalloc(eaop.fpFEA2List->cbList - sizeof(ULONG) + 1,
    1263                                        pszSrcFile, __LINE__);
    1264                   memcpy(info->pfea, eaop.fpFEA2List->list,
    1265                         eaop.fpFEA2List->cbList - sizeof(ULONG));
    1266                   info->name = info->pfea->szName;
    1267                   info->cbName = info->pfea->cbName;
    1268                   info->cbValue = info->pfea->cbValue;
    1269                   info->value = info->pfea->szName + info->pfea->cbName + 1;
    1270                   info->value[info->cbValue] = 0;
    1271                   info->next = NULL;
    1272                   if (!head)
    1273                     head = info;
    1274                   else
    1275                     last->next = info;
    1276                   last = info;
    1277                 }
    1278               }
    1279               free(pfealist);
    1280             }
    1281             free(pgealist);
    1282           }
    1283           ulEntry += ulCount;
    1284         } // while
    1285         free(pdena);
    1286         DosPostEventSem(CompactSem);
     1224        while (!DosEnumAttribute(ENUMEA_REFTYPE_FHANDLE,
     1225                                &handle,
     1226                                ulEntry,
     1227                                (PVOID)pdena,
     1228                                (ULONG)65536,
     1229                                &ulCount,
     1230                                ENUMEA_LEVEL_NO_VALUE) &&
     1231               ulCount)
     1232        {
     1233          // 64 is for header and spare - fixme to allocate smarter
     1234          pgealist = xmalloc(64 + pdena->cbName, pszSrcFile, __LINE__);
     1235          if (pgealist) {
     1236            pgealist->cbList = 64 + pdena->cbName;
     1237            pgea = pgealist->list;
     1238            pgea->oNextEntryOffset = 0;
     1239            pgea->cbName = pdena->cbName;
     1240            memcpy(pgea->szName, pdena->szName, pdena->cbName + 1);
     1241            pfealist = xmallocz(64 + pdena->cbName + pdena->cbValue,
     1242                                pszSrcFile, __LINE__);
     1243            if (pfealist) {
     1244              pfealist->cbList = 64 + pdena->cbName + pdena->cbValue;
     1245              eaop.fpGEA2List = pgealist;
     1246              eaop.fpFEA2List = pfealist;
     1247              eaop.oError = 0;
     1248              // saymsg(MB_ENTER,HWND_DESKTOP,"Debug1","\"%s\" %ld",pdena->szName,ulEntry);
     1249              rc =
     1250                DosQueryFileInfo(handle, FIL_QUERYEASFROMLIST, (PVOID) & eaop,
     1251                                (ULONG) sizeof(EAOP2));
     1252              if (rc) {
     1253                if (!silentfail) {
     1254                  Dos_Error(MB_ENTER,
     1255                            rc,
     1256                            HWND_DESKTOP,
     1257                            pszSrcFile,
     1258                            __LINE__,
     1259                            GetPString(IDS_ERRORREADEATEXT), pdena->szName);
     1260                }
     1261              }
     1262              else {
     1263                info = xmalloc(sizeof(HOLDFEA), pszSrcFile, __LINE__);
     1264                if (info) {
     1265                  // 05 Jul 07 SHL was one short
     1266                  info->pfea = xmalloc(eaop.fpFEA2List->cbList - sizeof(ULONG) + 1,
     1267                                       pszSrcFile, __LINE__);
     1268                  memcpy(info->pfea, eaop.fpFEA2List->list,
     1269                        eaop.fpFEA2List->cbList - sizeof(ULONG));
     1270                  info->name = info->pfea->szName;
     1271                  info->cbName = info->pfea->cbName;
     1272                  info->cbValue = info->pfea->cbValue;
     1273                  info->value = info->pfea->szName + info->pfea->cbName + 1;
     1274                  info->value[info->cbValue] = 0;
     1275                  info->next = NULL;
     1276                  if (!head)
     1277                    head = info;
     1278                  else
     1279                    last->next = info;
     1280                  last = info;
     1281                }
     1282              }
     1283              free(pfealist);
     1284            }
     1285            free(pgealist);
     1286          }
     1287          ulEntry += ulCount;
     1288        } // while
     1289        free(pdena);
     1290        DosPostEventSem(CompactSem);
    12871291      }
    12881292    }
    … …  
    12951299    /* try it without opening it */
    12961300    if (!DosQueryPathInfo(filename, FIL_QUERYEASIZE, (PVOID) & fsa4,
    1297                           (ULONG) sizeof(fsa4)) &&
    1298         fsa4.cbList > 4)
     1301                          (ULONG) sizeof(fsa4)) &&
     1302        fsa4.cbList > 4)
    12991303    {
    13001304      PDENA2 pdena;
    … …  
    13071311      pdena = xmalloc(65536 + 1024, pszSrcFile, __LINE__);
    13081312      if (pdena) {
    1309         while (!DosEnumAttribute
    1310                (ENUMEA_REFTYPE_PATH, filename, ulEntry, (PVOID) pdena,
    1311                 (ULONG) 65536, &ulCount, ENUMEA_LEVEL_NO_VALUE) && ulCount)
    1312         {
    1313           pgealist = xmalloc(64 + pdena->cbName, pszSrcFile, __LINE__);
    1314           if (pgealist) {
    1315             pgealist->cbList = 64 + pdena->cbName;
    1316             pgea = pgealist->list;
    1317             pgea->oNextEntryOffset = 0;
    1318             pgea->cbName = pdena->cbName;
    1319             memcpy(pgea->szName, pdena->szName, pdena->cbName + 1);
    1320             pfealist =
    1321               xmallocz(64 + pdena->cbName + pdena->cbValue, pszSrcFile,
    1322                        __LINE__);
    1323             if (pfealist) {
    1324               pfealist->cbList = 64 + pdena->cbName + pdena->cbValue;
    1325               eaop.fpGEA2List = pgealist;
    1326               eaop.fpFEA2List = pfealist;
    1327               eaop.oError = 0;
    1328               // saymsg(MB_ENTER,HWND_DESKTOP,"Debug2","\"%s\" %ld",pdena->szName,ulEntry);
    1329               rc = DosQueryPathInfo(filename, FIL_QUERYEASFROMLIST,
    1330                                     (PVOID) & eaop, (ULONG) sizeof(EAOP2));
    1331               if (!rc) {
    1332                 info = xmalloc(sizeof(HOLDFEA), pszSrcFile, __LINE__);
    1333                 if (info) {
     1313        while (!DosEnumAttribute
     1314               (ENUMEA_REFTYPE_PATH, filename, ulEntry, (PVOID) pdena,
     1315                (ULONG) 65536, &ulCount, ENUMEA_LEVEL_NO_VALUE) && ulCount)
     1316        {
     1317          pgealist = xmalloc(64 + pdena->cbName, pszSrcFile, __LINE__);
     1318          if (pgealist) {
     1319            pgealist->cbList = 64 + pdena->cbName;
     1320            pgea = pgealist->list;
     1321            pgea->oNextEntryOffset = 0;
     1322            pgea->cbName = pdena->cbName;
     1323            memcpy(pgea->szName, pdena->szName, pdena->cbName + 1);
     1324            pfealist =
     1325              xmallocz(64 + pdena->cbName + pdena->cbValue, pszSrcFile,
     1326                       __LINE__);
     1327            if (pfealist) {
     1328              pfealist->cbList = 64 + pdena->cbName + pdena->cbValue;
     1329              eaop.fpGEA2List = pgealist;
     1330              eaop.fpFEA2List = pfealist;
     1331              eaop.oError = 0;
     1332              // saymsg(MB_ENTER,HWND_DESKTOP,"Debug2","\"%s\" %ld",pdena->szName,ulEntry);
     1333              rc = DosQueryPathInfo(filename, FIL_QUERYEASFROMLIST,
     1334                                    (PVOID) & eaop, (ULONG) sizeof(EAOP2));
     1335              if (!rc) {
     1336                info = xmalloc(sizeof(HOLDFEA), pszSrcFile, __LINE__);
     1337                if (info) {
    13341338        // 29 Nov 07 GKY One short (EA search crash)
    1335                   info->pfea =
    1336                     xmalloc(eaop.fpFEA2List->cbList - sizeof(ULONG) + 1,
    1337                             pszSrcFile, __LINE__);
    1338                   memcpy(info->pfea, eaop.fpFEA2List->list,
    1339                         eaop.fpFEA2List->cbList - sizeof(ULONG));
    1340                   info->name = info->pfea->szName;
    1341                   info->cbName = info->pfea->cbName;
    1342                   info->cbValue = info->pfea->cbValue;
    1343                   info->value = info->pfea->szName + info->pfea->cbName + 1;
    1344                   info->value[info->cbValue] = 0;
    1345                   info->next = NULL;
    1346                   if (!head)
    1347                     head = info;
    1348                   else
    1349                     last->next = info;
    1350                   last = info;
    1351                 }
    1352                 else
    1353                   free(pfealist);
    1354               }
    1355               else {
    1356                 free(pfealist);
    1357                 if (!silentfail) {
    1358                   if (rc == ERROR_ACCESS_DENIED
    1359                       || rc == ERROR_SHARING_VIOLATION) {
    1360                     rc =
    1361                       saymsg(MB_ENTER | MB_CANCEL, HWND_DESKTOP,
    1362                              GetPString(IDS_OOPSTEXT),
    1363                              GetPString(IDS_CANTREADEATEXT), filename,
    1364                              pdena->szName);
    1365                     if (rc == MBID_CANCEL) {
    1366                       free(pgealist);
    1367                       break;
    1368                     }
    1369                   }
    1370                   else {
    1371                     Dos_Error(MB_ENTER,
    1372                               rc,
    1373                               HWND_DESKTOP,
    1374                               pszSrcFile,
    1375                               __LINE__,
    1376                               GetPString(IDS_ERRORREADEATEXT), pdena->szName);
    1377                   }
    1378                 }
    1379               }
    1380             }
    1381             free(pgealist);
    1382           }
    1383           ulEntry += ulCount;
    1384         } // while
    1385         free(pdena);
    1386         DosPostEventSem(CompactSem);
     1339                  info->pfea =
     1340                    xmalloc(eaop.fpFEA2List->cbList - sizeof(ULONG) + 1,
     1341                            pszSrcFile, __LINE__);
     1342                  memcpy(info->pfea, eaop.fpFEA2List->list,
     1343                        eaop.fpFEA2List->cbList - sizeof(ULONG));
     1344                  info->name = info->pfea->szName;
     1345                  info->cbName = info->pfea->cbName;
     1346                  info->cbValue = info->pfea->cbValue;
     1347                  info->value = info->pfea->szName + info->pfea->cbName + 1;
     1348                  info->value[info->cbValue] = 0;
     1349                  info->next = NULL;
     1350                  if (!head)
     1351                    head = info;
     1352                  else
     1353                    last->next = info;
     1354                  last = info;
     1355                }
     1356                else
     1357                  free(pfealist);
     1358              }
     1359              else {
     1360                free(pfealist);
     1361                if (!silentfail) {
     1362                  if (rc == ERROR_ACCESS_DENIED
     1363                      || rc == ERROR_SHARING_VIOLATION) {
     1364                    rc =
     1365                      saymsg(MB_ENTER | MB_CANCEL, HWND_DESKTOP,
     1366                             GetPString(IDS_OOPSTEXT),
     1367                             GetPString(IDS_CANTREADEATEXT), filename,
     1368                             pdena->szName);
     1369                    if (rc == MBID_CANCEL) {
     1370                      free(pgealist);
     1371                      break;
     1372                    }
     1373                  }
     1374                  else {
     1375                    Dos_Error(MB_ENTER,
     1376                              rc,
     1377                              HWND_DESKTOP,
     1378                              pszSrcFile,
     1379                              __LINE__,
     1380                              GetPString(IDS_ERRORREADEATEXT), pdena->szName);
     1381                  }
     1382                }
     1383              }
     1384            }
     1385            free(pgealist);
     1386          }
     1387          ulEntry += ulCount;
     1388        } // while
     1389        free(pdena);
     1390        DosPostEventSem(CompactSem);
    13871391      }
    13881392    }
Note: See TracChangeset for help on using the changeset viewer.