Changeset 1804


Ignore:
Timestamp:
May 4, 2015, 3:31:59 AM (11 years ago)
Author:
Steven Levine
Message:

Support critical EAs

Location:
trunk/dll
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/dll/eas.c

    r1673 r1804  
    77
    88  Copyright (c) 1993-98 M. Kimes
    9   Copyright (c) 2004, 2010 Steven H. Levine
     9  Copyright (c) 2004, 2014 Steven H. Levine
    1010
    1111  01 Aug 04 SHL Rework lstrip/rstrip usage
    … …  
    2727  23 Oct 10 GKY Added button to allow opening of a new file's eas from the EA dialog.
    2828  26 Aug 11 GKY Add a low mem version of xDosAlloc* wrappers; move error checking into all the
    29                 xDosAlloc* wrappers.
     29                xDosAlloc* wrappers.
     30  10 Feb 14 SHL DisplayEAsProc: Indicate if EA is critical, avoid rewrites if no change
     31  10 Feb 14 SHL SaveEA: Avoid rewrites if no change
    3032
    3133***********************************************************************/
    … …  
    6870static PSZ pszSrcFile = __FILE__;
    6971
    70 static PVOID SaveEA(CHAR * filename, HOLDFEA * current, CHAR * newdata,
     72static PVOID SaveEA(CHAR *filename, HOLDFEA *current, CHAR *newdata,
    7173             BOOL silentfail);
    7274
    … …  
    9597    while (info) {
    9698      if (!strcmp(info->name, eaname))
    97         return info;
     99        return info;
    98100      info = info->next;
    99101    }
    … …  
    131133    WinSetWindowPtr(hwnd, QWL_USER, (PVOID) mp2);
    132134    WinSendDlgItemMsg(hwnd, EAC_NAME, EM_SETTEXTLIMIT,
    133                       MPFROM2SHORT(1024, 0), MPVOID);
     135                      MPFROM2SHORT(1024, 0), MPVOID);
    134136    WinCheckButton(hwnd, EAC_ASCII, TRUE);
    135137    break;
    … …  
    141143  case UM_PAINT:
    142144    PaintRecessedWindow(WinWindowFromID(hwnd, EAC_TEXT), (HPS) 0, FALSE,
    143                         FALSE);
     145                        FALSE);
    144146    return 0;
    145147
    … …  
    154156      filename = add->filename;
    155157      {
    156         CHAR s[1025];
    157         INT x;
    158         USHORT type = EAT_ASCII;
    159 
    160         *s = 0;
    161         WinQueryDlgItemText(hwnd, EAC_NAME, 1024, s);
    162         bstrip(s);
    163         if (!*s)
    164           WinDismissDlg(hwnd, 0);
    165         else {
    166           if (CheckEA(head, s)) {
    167             if (!fAlertBeepOff)
    168               DosBeep(50, 100);
    169             WinSetDlgItemText(hwnd, EAC_TEXT,
    170                               (CHAR *) GetPString(IDS_EANAMEEXISTSTEXT));
    171             break;
    172           }
    173           for (x = 0; *forbidden[x]; x++) {
    174             if (!strcmp(forbidden[x], s)) {
    175               if (!fAlertBeepOff)
    176                 DosBeep(50, 100);
    177               WinSetDlgItemText(hwnd, EAC_TEXT,
    178                                 (CHAR *) GetPString(IDS_EANAMERESERVEDTEXT));
    179               return 0;
    180             }
    181           }
    182           if (WinQueryButtonCheckstate(hwnd, EAC_MVST))
    183             type = EAT_MVST;
    184           else if (WinQueryButtonCheckstate(hwnd, EAC_MVMT))
    185             type = EAT_MVMT;
    186           for (x = 0; *restypes[x].name; x++) {
    187             if (!strcmp(restypes[x].name, s)) {
    188               if (type != restypes[x].type) {
    189                 if (!fAlertBeepOff)
    190                   DosBeep(50, 100);
    191                 WinSetDlgItemText(hwnd, EAC_TEXT,
    192                                   (CHAR *) GetPString(IDS_EAWRONGTYPETEXT));
    193                 return 0;
    194               }
    195               break;
    196             }
    197           }
    198           // if we get here, create dummy ea
    199           {
    200             PFEA2LIST pfealist = NULL;
    201             EAOP2 eaop;
    202             ULONG ealen;
    203             CHAR *eaval;
    204 
    205             ealen = sizeof(FEA2LIST) + strlen(s) + 64;
    206             if (!xDosAllocMem((PPVOID) & pfealist, ealen + 1, pszSrcFile, __LINE__)) {
    207               memset(pfealist, 0, ealen + 1);
    208               pfealist->cbList = ealen;
    209               pfealist->list[0].oNextEntryOffset = 0;
    210               pfealist->list[0].fEA = 0;
    211               pfealist->list[0].cbName = strlen(s);
    212               strcpy(pfealist->list[0].szName, s);
    213               eaval = pfealist->list[0].szName + strlen(s) + 1;
    214               *(USHORT *) eaval = (USHORT) type;
    215               eaval += sizeof(USHORT);
    216               if (type == EAT_MVST || type == EAT_MVMT) {
    217                 *(USHORT *) eaval = (USHORT) 0; // codepage
    218                 eaval += sizeof(USHORT);
    219                 *(USHORT *) eaval = (USHORT) 1; // number
    220                 eaval += sizeof(USHORT);
    221                 *(USHORT *) eaval = (USHORT) EAT_ASCII; // type
    222                 eaval += sizeof(USHORT);
    223               }
    224               *(USHORT *) eaval = (USHORT) 4;
    225               eaval += sizeof(USHORT);
    226               memcpy(eaval, GetPString(IDS_FAKETEXT), 4);
    227               pfealist->list[0].cbValue = 4 + (sizeof(USHORT) * 2) +
    228                 ((type == EAT_MVST ||
    229                   type == EAT_MVMT) ? sizeof(USHORT) * 3 : 0);
    230               eaop.fpGEA2List = (PGEA2LIST) 0;
    231               eaop.fpFEA2List = pfealist;
    232               eaop.oError = 0;
    233               xDosSetPathInfo(filename, FIL_QUERYEASIZE,
    234                               &eaop, sizeof(eaop), DSPI_WRTTHRU);
    235               WinDismissDlg(hwnd, 1);
    236             }
    237           }
    238         }
     158        CHAR s[1025];
     159        INT x;
     160        USHORT type = EAT_ASCII;
     161
     162        *s = 0;
     163        WinQueryDlgItemText(hwnd, EAC_NAME, 1024, s);
     164        bstrip(s);
     165        if (!*s)
     166          WinDismissDlg(hwnd, 0);
     167        else {
     168          if (CheckEA(head, s)) {
     169            if (!fAlertBeepOff)
     170              DosBeep(50, 100);
     171            WinSetDlgItemText(hwnd, EAC_TEXT,
     172                              (CHAR *)GetPString(IDS_EANAMEEXISTSTEXT));
     173            break;
     174          }
     175          for (x = 0; *forbidden[x]; x++) {
     176            if (!strcmp(forbidden[x], s)) {
     177              if (!fAlertBeepOff)
     178                DosBeep(50, 100);
     179              WinSetDlgItemText(hwnd, EAC_TEXT,
     180                                (CHAR *)GetPString(IDS_EANAMERESERVEDTEXT));
     181              return 0;
     182            }
     183          }
     184          if (WinQueryButtonCheckstate(hwnd, EAC_MVST))
     185            type = EAT_MVST;
     186          else if (WinQueryButtonCheckstate(hwnd, EAC_MVMT))
     187            type = EAT_MVMT;
     188          for (x = 0; *restypes[x].name; x++) {
     189            if (!strcmp(restypes[x].name, s)) {
     190              if (type != restypes[x].type) {
     191                if (!fAlertBeepOff)
     192                  DosBeep(50, 100);
     193                WinSetDlgItemText(hwnd, EAC_TEXT,
     194                                  (CHAR *)GetPString(IDS_EAWRONGTYPETEXT));
     195                return 0;
     196              }
     197              break;
     198            }
     199          }
     200          // if we get here, create dummy ea
     201          {
     202            PFEA2LIST pfealist = NULL;
     203            EAOP2 eaop;
     204            ULONG ealen;
     205            CHAR *eaval;
     206
     207            ealen = sizeof(FEA2LIST) + strlen(s) + 64;
     208            if (!xDosAllocMem((PPVOID) & pfealist, ealen + 1, pszSrcFile, __LINE__)) {
     209              memset(pfealist, 0, ealen + 1);
     210              pfealist->cbList = ealen;
     211              pfealist->list[0].oNextEntryOffset = 0;
     212              pfealist->list[0].fEA = 0;
     213              pfealist->list[0].cbName = strlen(s);
     214              strcpy(pfealist->list[0].szName, s);
     215              eaval = pfealist->list[0].szName + strlen(s) + 1;
     216              *(USHORT *)eaval = (USHORT)type;
     217              eaval += sizeof(USHORT);
     218              if (type == EAT_MVST || type == EAT_MVMT) {
     219                *(USHORT *)eaval = (USHORT) 0; // codepage
     220                eaval += sizeof(USHORT);
     221                *(USHORT *)eaval = (USHORT)1; // number
     222                eaval += sizeof(USHORT);
     223                *(USHORT *)eaval = (USHORT)EAT_ASCII; // type
     224                eaval += sizeof(USHORT);
     225              }
     226              *(USHORT *)eaval = (USHORT)4;
     227              eaval += sizeof(USHORT);
     228              memcpy(eaval, GetPString(IDS_FAKETEXT), 4);
     229              pfealist->list[0].cbValue = 4 + (sizeof(USHORT) * 2) +
     230                ((type == EAT_MVST ||
     231                  type == EAT_MVMT) ? sizeof(USHORT) * 3 : 0);
     232              eaop.fpGEA2List = (PGEA2LIST) 0;
     233              eaop.fpFEA2List = pfealist;
     234              eaop.oError = 0;
     235              xDosSetPathInfo(filename, FIL_QUERYEASIZE,
     236                              &eaop, sizeof(eaop), DSPI_WRTTHRU);
     237              WinDismissDlg(hwnd, 1);
     238            }
     239          }
     240        }
    239241      }
    240242      break;
    … …  
    246248    case IDM_HELP:
    247249      if (hwndHelp)
    248         WinSendMsg(hwndHelp, HM_DISPLAY_HELP,
    249                    MPFROM2SHORT(HELP_ADDEA, 0), MPFROMSHORT(HM_RESOURCEID));
     250        WinSendMsg(hwndHelp, HM_DISPLAY_HELP,
     251                   MPFROM2SHORT(HELP_ADDEA, 0), MPFROMSHORT(HM_RESOURCEID));
    250252      break;
    251253    }
    … …  
    277279      a = s + 6;
    278280      do {
    279         sprintf(a, "%02x ", (UCHAR)*p);
    280         a += 3;
    281         p++;
    282         x++;
     281        sprintf(a, "%02x ", (UCHAR)*p);
     282        a += 3;
     283        p++;
     284        x++;
    283285      }
    284286      while (x < cbValue && (x % 16));
    285287      if (x % 16) {
    286         z = x;
    287         while (z % 16) {
    288           *a++ = ' ';
    289           *a++ = ' ';
    290           *a++ = ' ';
    291           z++;
    292         }
     288        z = x;
     289        while (z % 16) {
     290          *a++ = ' ';
     291          *a++ = ' ';
     292          *a++ = ' ';
     293          z++;
     294        }
    293295      }
    294296      *a++ = ' ';
    295297      p = pp;
    296298      do {
    297         if (*p)
    298           *a++ = *p++;
    299         else {
    300           *a++ = '.';
    301           p++;
    302         }
    303         *a = 0;
    304         y++;
     299        if (*p)
     300          *a++ = *p++;
     301        else {
     302          *a++ = '.';
     303          p++;
     304        }
     305        *a = 0;
     306        y++;
    305307      }
    306308      while (y < x);
    307309      if ((SHORT) WinSendMsg(hwnd, LM_INSERTITEM, MPFROM2SHORT(LIT_END, 0),
    308                              MPFROMP(s)) < 0)
    309         break;
     310                             MPFROMP(s)) < 0)
     311        break;
    310312      pp = p;
    311313    }
    … …  
    327329  EAPROCDATA *eap;
    328330  HOLDFEA *info;
     331  CHAR str[81];
     332
    329333  static HPOINTER hptrIcon = (HPOINTER) 0;
    330334
    … …  
    349353    WinSetWindowPtr(hwnd, QWL_USER, (PVOID) eap);
    350354    WinSendDlgItemMsg(hwnd,
    351                       EA_ENTRY, EM_SETTEXTLIMIT, MPFROM2SHORT(40, 0), MPVOID);
     355                      EA_ENTRY, EM_SETTEXTLIMIT, MPFROM2SHORT(40, 0), MPVOID);
    352356    MLEsetlimit(WinWindowFromID(hwnd, EA_MLE), 32767);
    353357    MLEsetformat(WinWindowFromID(hwnd, EA_MLE), MLFIE_NOTRANS);
    … …  
    358362
    359363      for (x = 0; eap->list[x]; x++) {
    360         if (DosQueryPathInfo(eap->list[x], FIL_QUERYFULLNAME, s, sizeof(s)))
    361           strcpy(s, eap->list[x]);
    362         if (IsFile(s) != -1)
    363           WinSendDlgItemMsg(hwnd,
    364                             EA_NAMES,
    365                             LM_INSERTITEM,
    366                             MPFROM2SHORT(LIT_SORTASCENDING, 0), MPFROMP(s));
     364        if (DosQueryPathInfo(eap->list[x], FIL_QUERYFULLNAME, s, sizeof(s)))
     365          strcpy(s, eap->list[x]);
     366        if (IsFile(s) != -1)
     367          WinSendDlgItemMsg(hwnd,
     368                            EA_NAMES,
     369                            LM_INSERTITEM,
     370                            MPFROM2SHORT(LIT_SORTASCENDING, 0), MPFROMP(s));
    367371      }
    368372      sSelect = (SHORT) WinSendDlgItemMsg(hwnd,
    369                                           EA_NAMES,
    370                                           LM_QUERYITEMCOUNT, MPVOID, MPVOID);
     373                                          EA_NAMES,
     374                                          LM_QUERYITEMCOUNT, MPVOID, MPVOID);
    371375      if (sSelect > 0)
    372         WinSendDlgItemMsg(hwnd,
    373                           EA_NAMES,
    374                           LM_SELECTITEM,
    375                           MPFROM2SHORT(0, 0), MPFROMSHORT(TRUE));
     376        WinSendDlgItemMsg(hwnd,
     377                          EA_NAMES,
     378                          LM_SELECTITEM,
     379                          MPFROM2SHORT(0, 0), MPFROMSHORT(TRUE));
    376380      else
    377         WinDismissDlg(hwnd, 0);
     381        WinDismissDlg(hwnd, 0);
    378382    }
    379383    break;
    … …  
    382386    if (*eap->filename) {
    383387      if (eap->head)
    384         Free_FEAList(eap->head);
     388        Free_FEAList(eap->head);
    385389      eap->head = GetFileEAs(eap->filename, FALSE, FALSE);
    386390      if (!isalpha(*eap->filename) ||
    387           (driveflags[toupper(*eap->filename) - 'A'] & DRIVE_NOTWRITEABLE)) {
    388         WinEnableWindow(WinWindowFromID(hwnd, EA_CHANGE), FALSE);
    389         WinEnableWindow(WinWindowFromID(hwnd, EA_ADD), FALSE);
    390         WinEnableWindow(WinWindowFromID(hwnd, EA_DELETE), FALSE);
     391          (driveflags[toupper(*eap->filename) - 'A'] & DRIVE_NOTWRITEABLE)) {
     392        WinEnableWindow(WinWindowFromID(hwnd, EA_CHANGE), FALSE);
     393        WinEnableWindow(WinWindowFromID(hwnd, EA_ADD), FALSE);
     394        WinEnableWindow(WinWindowFromID(hwnd, EA_DELETE), FALSE);
    391395      }
    392396      else {
    393         WinEnableWindow(WinWindowFromID(hwnd, EA_CHANGE), TRUE);
    394         WinEnableWindow(WinWindowFromID(hwnd, EA_ADD), TRUE);
    395         WinEnableWindow(WinWindowFromID(hwnd, EA_DELETE), TRUE);
     397        WinEnableWindow(WinWindowFromID(hwnd, EA_CHANGE), TRUE);
     398        WinEnableWindow(WinWindowFromID(hwnd, EA_ADD), TRUE);
     399        WinEnableWindow(WinWindowFromID(hwnd, EA_DELETE), TRUE);
    396400      }
    397401      WinSendMsg(hwnd, UM_SETUP, MPVOID, MPVOID);
    … …  
    414418      info = eap->head;
    415419      while (info) {
    416         WinSendDlgItemMsg(hwnd, EA_LISTBOX, LM_INSERTITEM,
    417                           MPFROM2SHORT(LIT_END, 0), MPFROMP(info->name));
    418         info = info->next;
     420        WinSendDlgItemMsg(hwnd, EA_LISTBOX, LM_INSERTITEM,
     421                          MPFROM2SHORT(LIT_END, 0), MPFROMP(info->name));
     422        info = info->next;
    419423      }
    420424      WinSendDlgItemMsg(hwnd, EA_LISTBOX, LM_SELECTITEM,
    421                         MPFROM2SHORT(0, 0), MPFROM2SHORT(TRUE, 0));
     425                        MPFROM2SHORT(0, 0), MPFROM2SHORT(TRUE, 0));
    422426    }
    423427    else
    424       WinSetDlgItemText(hwnd, EA_TEXT, (CHAR *) GetPString(IDS_EANOEAS));
     428      WinSetDlgItemText(hwnd, EA_TEXT, (CHAR *)GetPString(IDS_EANOEAS));
    425429    return 0;
    426430
    … …  
    432436    PaintRecessedWindow(WinWindowFromID(hwnd, EA_HELP), (HPS) 0, FALSE, TRUE);
    433437    PaintRecessedWindow(WinWindowFromID(hwnd, EA_TEXT), (HPS) 0, FALSE,
    434                         FALSE);
     438                        FALSE);
    435439    return 0;
    436440
    … …  
    440444      switch (SHORT2FROMMP(mp1)) {
    441445      case LN_SETFOCUS:
    442         WinSetDlgItemText(hwnd, EA_HELP, (CHAR *) GetPString(IDS_EAFILENAMESHELPTEXT));
    443         break;
     446        WinSetDlgItemText(hwnd, EA_HELP, (CHAR *)GetPString(IDS_EAFILENAMESHELPTEXT));
     447        break;
    444448      case LN_KILLFOCUS:
    445         WinSetDlgItemText(hwnd, EA_HELP, NullStr);
    446         break;
     449        WinSetDlgItemText(hwnd, EA_HELP, NullStr);
     450        break;
    447451      case LN_ENTER:
    448452      case LN_SELECT:
    449         {
    450           CHAR s[1025];
    451           SHORT sSelect;
    452 
    453           sSelect = (SHORT) WinSendDlgItemMsg(hwnd, EA_NAMES,
    454                                               LM_QUERYSELECTION,
    455                                               MPFROM2SHORT(LIT_FIRST, 0),
    456                                               MPVOID);
    457           if (sSelect >= 0) {
    458             *s = 0;
    459             WinSendDlgItemMsg(hwnd, EA_NAMES, LM_QUERYITEMTEXT,
    460                               MPFROM2SHORT(sSelect, 1024), MPFROMP(s));
    461             if (*s) {
    462               strcpy(eap->filename, s);
    463               if (SHORT2FROMMP(mp1) == LN_SELECT)
    464                 WinSendMsg(hwnd, UM_SETDIR, MPVOID, MPVOID);
    465               else
    466                 QuickView(hwnd, eap->filename);
    467             }
    468           }
    469         }
    470         break;
     453        {
     454          CHAR s[1025];
     455          SHORT sSelect;
     456
     457          sSelect = (SHORT) WinSendDlgItemMsg(hwnd, EA_NAMES,
     458                                              LM_QUERYSELECTION,
     459                                              MPFROM2SHORT(LIT_FIRST, 0),
     460                                              MPVOID);
     461          if (sSelect >= 0) {
     462            *s = 0;
     463            WinSendDlgItemMsg(hwnd, EA_NAMES, LM_QUERYITEMTEXT,
     464                              MPFROM2SHORT(sSelect, 1024), MPFROMP(s));
     465            if (*s) {
     466              strcpy(eap->filename, s);
     467              if (SHORT2FROMMP(mp1) == LN_SELECT)
     468                WinSendMsg(hwnd, UM_SETDIR, MPVOID, MPVOID);
     469              else
     470                QuickView(hwnd, eap->filename);
     471            }
     472          }
     473        }
     474        break;
    471475      }
    472476      break;
    … …  
    475479      switch (SHORT2FROMMP(mp1)) {
    476480      case LN_SETFOCUS:
    477         WinSetDlgItemText(hwnd, EA_HELP, (CHAR *) GetPString(IDS_EATYPESHELPTEXT));
    478         break;
     481        WinSetDlgItemText(hwnd, EA_HELP, (CHAR *)GetPString(IDS_EATYPESHELPTEXT));
     482        break;
    479483      case LN_KILLFOCUS:
    480         WinSetDlgItemText(hwnd, EA_HELP, NullStr);
    481         break;
     484        WinSetDlgItemText(hwnd, EA_HELP, NullStr);
     485        break;
    482486      case LN_SELECT:
    483         {
    484           CHAR s[1024];
    485           SHORT sSelect;
    486 
    487           eap->current = NULL;
    488           if (eap->head) {
    489             WinSetDlgItemText(hwnd, EA_TEXT, NullStr);
    490             WinShowWindow(WinWindowFromID(hwnd, EA_ENTRY), FALSE);
    491             WinSetDlgItemText(hwnd, EA_ENTRY, NullStr);
    492             MLEclearall(WinWindowFromID(hwnd, EA_MLE));
    493             WinShowWindow(WinWindowFromID(hwnd, EA_MLE), FALSE);
    494             WinShowWindow(WinWindowFromID(hwnd,EA_CHANGE), FALSE);
    495             WinShowWindow(WinWindowFromID(hwnd, EA_DELETE), FALSE);
    496             WinShowWindow(WinWindowFromID(hwnd, EA_HEXDUMP), FALSE);
    497             WinSendDlgItemMsg(hwnd, EA_HEXDUMP, LM_DELETEALL, MPVOID, MPVOID);
    498             *s = 0;
    499             sSelect = (USHORT) WinSendDlgItemMsg(hwnd, EA_LISTBOX,
    500                                                  LM_QUERYSELECTION,
    501                                                  MPFROMSHORT(LIT_FIRST),
    502                                                  MPVOID);
    503             if (sSelect >= 0) {
    504               WinSendDlgItemMsg(hwnd, EA_LISTBOX, LM_QUERYITEMTEXT,
    505                                 MPFROM2SHORT(sSelect, 1024), MPFROMP(s));
    506               if (*s) {
    507 
    508                 USHORT len, num, type;
    509                 CHAR *data;
    510                 CHAR last = '\n';
    511                 const CHAR *linefeed = "\n";
    512                 BOOL alltext;
    513                 IPT pos = 0;
    514 
    515                 info = eap->head;
    516                 while (info) {
    517                   if (!strcmp(s, info->name)) {
    518                     eap->current = info;
    519                     WinShowWindow(WinWindowFromID(hwnd, EA_DELETE), TRUE);
    520                     switch (*(USHORT *) info->value) {
    521                     case EAT_EA:
    522                     case EAT_ASCII:
    523                       if (!strcmp(info->name, SUBJECT))
    524                         WinSendDlgItemMsg(hwnd, EA_ENTRY,
    525                                           EM_SETTEXTLIMIT,
    526                                           MPFROM2SHORT(1024, 0), MPVOID);
    527                       else
    528                         WinSendDlgItemMsg(hwnd, EA_ENTRY,
    529                                           EM_SETTEXTLIMIT,
    530                                           MPFROM2SHORT(1024, 0), MPVOID);
    531                       WinSetDlgItemText(hwnd, EA_ENTRY,
    532                                         info->value + (sizeof(USHORT) * 2));
    533                       WinShowWindow(WinWindowFromID(hwnd, EA_ENTRY), TRUE);
    534                       WinEnableWindow(WinWindowFromID(hwnd, EA_CHANGE),
    535                                       FALSE);
    536                       WinShowWindow(WinWindowFromID(hwnd, EA_CHANGE), TRUE);
    537                       {
    538                         CHAR str[81];
    539 
    540                         sprintf(str,
    541                                 GetPString(IDS_DATAANDBYTESTEXT),
    542                                 (*(USHORT *) info->value == EAT_ASCII) ?
    543                                 GetPString(IDS_TEXTTEXT) :
    544                                 GetPString(IDS_EAREFTEXT), info->cbValue);
    545                         WinSetDlgItemText(hwnd, EA_TEXT, str);
    546                       }
    547                       break;
    548                     case EAT_MVST:
    549                       MLEclearall(WinWindowFromID(hwnd, EA_MLE));
    550                       num = *(USHORT *) (info->value + (sizeof(USHORT) * 2));
    551                       type = *(USHORT *) (info->value + (sizeof(USHORT) * 3));
    552                       if (type == EAT_ASCII) {
    553                         data = info->value + (sizeof(USHORT) * 4);
    554                         len = *(USHORT *) data;
    555                         data += sizeof(USHORT);
    556                         while ((data - info->value) + len <= info->cbValue) {
    557                           if (last != '\n') {
    558                             WinSendDlgItemMsg(hwnd,
    559                                               EA_MLE,
    560                                               MLM_SETIMPORTEXPORT,
    561                                               MPFROMP(linefeed),
    562                                               MPFROMLONG(1));
    563                             WinSendDlgItemMsg(hwnd,
    564                                               EA_MLE,
    565                                               MLM_IMPORT,
    566                                               MPFROMP(&pos), MPFROMLONG(1));
    567                           }
    568                           WinSendDlgItemMsg(hwnd,
    569                                             EA_MLE,
    570                                             MLM_SETIMPORTEXPORT,
    571                                             MPFROMP(data),
    572                                             MPFROMLONG((ULONG) len));
    573                           WinSendDlgItemMsg(hwnd,
    574                                             EA_MLE,
    575                                             MLM_IMPORT,
    576                                             MPFROMP(&pos),
    577                                             MPFROMLONG((ULONG) len));
    578                           data += len;
    579                           last = *(data - 1);
    580                           if (data - info->value >= info->cbValue)
    581                             break;
    582                           len = *(USHORT *) data;
    583                           data += sizeof(USHORT);
    584                         }
    585                         WinShowWindow(WinWindowFromID(hwnd, EA_MLE), TRUE);
    586                         WinEnableWindow(WinWindowFromID(hwnd, EA_CHANGE),
    587                                         FALSE);
    588                         WinShowWindow(WinWindowFromID(hwnd, EA_CHANGE), TRUE);
    589                       }
    590                       else {
    591                         WinShowWindow(WinWindowFromID(hwnd, EA_MLE), FALSE);
    592                         HexDumpEA(hwnd, info);
    593                         WinShowWindow(WinWindowFromID(hwnd, EA_HEXDUMP),
    594                                       TRUE);
    595                       }
    596                       {
    597                         CHAR str[81];
    598 
    599                         sprintf(str,
    600                                 GetPString(IDS_MVSTTEXT),
    601                                 num,
    602                                 (num == 1) ?
    603                                 GetPString(IDS_YTEXT) :
    604                                 GetPString(IDS_IESTEXT), info->cbValue);
    605                         WinSetDlgItemText(hwnd, EA_TEXT, str);
    606                       }
    607                       break;
    608                     case EAT_MVMT:
    609                       MLEclearall(WinWindowFromID(hwnd, EA_MLE));
    610                       num = *(USHORT *) (info->value + (sizeof(USHORT) * 2));
    611                       data = info->value + (sizeof(USHORT) * 3);
    612                       type = *(USHORT *) data;
    613                       data += sizeof(USHORT);
    614                       len = *(USHORT *) data;
    615                       data += sizeof(USHORT);
    616                       alltext = TRUE;
    617                       while ((data - info->value) - len <= info->cbValue) {
    618                         if (type != EAT_ASCII) {
    619                           alltext = FALSE;
    620                           break;
    621                         }
    622                         data += len;
    623                         if (data - info->value >= info->cbValue)
    624                           break;
    625                         type = *(USHORT *) data;
    626                         data += sizeof(USHORT);
    627                         len = *(USHORT *) data;
    628                         data += sizeof(USHORT);
    629                       }
    630                       if (alltext) {
    631                         data = info->value + (sizeof(USHORT) * 3);
    632                         type = *(USHORT *) data;
    633                         data += sizeof(USHORT);
    634                         len = *(USHORT *) data;
    635                         data += sizeof(USHORT);
    636                         while ((data - info->value) - len <= info->cbValue) {
    637                           if (last != '\n') {
    638                             WinSendDlgItemMsg(hwnd,
    639                                               EA_MLE,
    640                                               MLM_SETIMPORTEXPORT,
    641                                               MPFROMP(linefeed),
    642                                               MPFROMLONG(1));
    643                             WinSendDlgItemMsg(hwnd,
    644                                               EA_MLE,
    645                                               MLM_IMPORT,
    646                                               MPFROMP(&pos), MPFROMLONG(1));
    647                           }
    648                           WinSendDlgItemMsg(hwnd,
    649                                             EA_MLE,
    650                                             MLM_SETIMPORTEXPORT,
    651                                             MPFROMP(data),
    652                                             MPFROMLONG((ULONG) len));
    653                           WinSendDlgItemMsg(hwnd,
    654                                             EA_MLE,
    655                                             MLM_IMPORT,
    656                                             MPFROMP(&pos),
    657                                             MPFROMLONG((ULONG) len));
    658                           data += len;
    659                           last = *(data - 1);
    660                           if (data - info->value >= info->cbValue)
    661                             break;
    662                           type = *(USHORT *) data;
    663                           data += sizeof(USHORT);
    664                           len = *(USHORT *) data;
    665                           data += sizeof(USHORT);
    666                         }
    667                       }
    668                       if (alltext) {
    669                         WinShowWindow(WinWindowFromID(hwnd, EA_MLE), TRUE);
    670                         WinEnableWindow(WinWindowFromID(hwnd,
    671                                                         EA_CHANGE), FALSE);
    672                         WinShowWindow(WinWindowFromID(hwnd, EA_CHANGE), TRUE);
    673                       }
    674                       else {
    675                         WinShowWindow(WinWindowFromID(hwnd, EA_MLE), FALSE);
    676                         HexDumpEA(hwnd, info);
    677                         WinShowWindow(WinWindowFromID(hwnd, EA_HEXDUMP),
    678                                       TRUE);
    679                       }
    680                       {
    681                         CHAR str[81];
    682 
    683                         sprintf(str,
    684                                 GetPString(IDS_MVMTTEXT),
    685                                 num,
    686                                 (num == 1) ?
    687                                 GetPString(IDS_YTEXT) :
    688                                 GetPString(IDS_IESTEXT),
    689                                 info->cbValue,
    690                                 (alltext) ?
    691                                 GetPString(IDS_ALLTEXTTEXT) :
    692                                 GetPString(IDS_MIXEDTYPESTEXT));
    693                         WinSetDlgItemText(hwnd, EA_TEXT, str);
    694                       }
    695                       break;
    696                     default:
    697                       HexDumpEA(hwnd, info);
    698                       WinShowWindow(WinWindowFromID(hwnd, EA_HEXDUMP), TRUE);
    699                       switch (*(USHORT *) info->value) {
    700                       case EAT_BINARY:
    701                         {
    702                           CHAR str[81];
    703 
    704                           sprintf(str,
    705                                   GetPString(IDS_BINARYBYTESTEXT),
    706                                   info->cbValue);
    707                           WinSetDlgItemText(hwnd, EA_TEXT, str);
    708                         }
    709                         break;
    710                       case EAT_BITMAP:
    711                         {
    712                           CHAR str[81];
    713 
    714                           sprintf(str,
    715                                   GetPString(IDS_BITMAPBYTESTEXT),
    716                                   info->cbValue);
    717                           WinSetDlgItemText(hwnd, EA_TEXT, str);
    718                         }
    719                         break;
    720                       case EAT_METAFILE:
    721                         {
    722                           CHAR str[81];
    723 
    724                           sprintf(str,
    725                                   GetPString(IDS_METAFILEBYTESTEXT),
    726                                   info->cbValue);
    727                           WinSetDlgItemText(hwnd, EA_TEXT, str);
    728                         }
    729                         break;
    730                       case EAT_ICON:
    731                         {
    732                           CHAR str[81];
    733 
    734                           sprintf(str,
    735                                   GetPString(IDS_ICONBYTESTEXT),
    736                                   info->cbValue);
    737                           WinSetDlgItemText(hwnd, EA_TEXT, str);
    738                         }
    739                         break;
    740                       case EAT_ASN1:
    741                         {
    742                           CHAR str[81];
    743 
    744                           sprintf(str,
    745                                   GetPString(IDS_ASN1BYTESTEXT),
    746                                   info->cbValue);
    747                           WinSetDlgItemText(hwnd, EA_TEXT, str);
    748                         }
    749                         break;
    750                       default:
    751                         {
    752                           CHAR str[81];
    753 
    754                           sprintf(str,
    755                                   GetPString(IDS_UNKNOWNBYTESTEXT),
    756                                   *(USHORT *) info->value, info->cbValue);
    757                           WinSetDlgItemText(hwnd, EA_TEXT, str);
    758                         }
    759                         break;
    760                       }
    761                       break;
    762                     }
    763                   }
    764                   info = info->next;
    765                 }
    766               }
    767             }
    768           }
    769           if (!isalpha(*eap->filename) ||
    770               (driveflags[toupper(*eap->filename) - 'A'] &
    771                DRIVE_NOTWRITEABLE)) {
    772             WinEnableWindow(WinWindowFromID(hwnd, EA_CHANGE), FALSE);
    773             WinEnableWindow(WinWindowFromID(hwnd, EA_ADD), FALSE);
    774             WinEnableWindow(WinWindowFromID(hwnd, EA_DELETE), FALSE);
    775           }
    776           else {
    777             WinEnableWindow(WinWindowFromID(hwnd, EA_CHANGE), TRUE);
    778             WinEnableWindow(WinWindowFromID(hwnd, EA_ADD), TRUE);
    779             WinEnableWindow(WinWindowFromID(hwnd, EA_DELETE), TRUE);
    780           }
    781         }
    782         break;
     487        {
     488          CHAR s[1024];
     489          SHORT sSelect;
     490
     491          eap->current = NULL;
     492          if (eap->head) {
     493            WinSetDlgItemText(hwnd, EA_TEXT, NullStr);
     494            WinShowWindow(WinWindowFromID(hwnd, EA_ENTRY), FALSE);
     495            WinSetDlgItemText(hwnd, EA_ENTRY, NullStr);
     496            MLEclearall(WinWindowFromID(hwnd, EA_MLE));
     497            WinShowWindow(WinWindowFromID(hwnd, EA_MLE), FALSE);
     498            WinShowWindow(WinWindowFromID(hwnd,EA_CHANGE), FALSE);
     499            WinShowWindow(WinWindowFromID(hwnd, EA_DELETE), FALSE);
     500            WinShowWindow(WinWindowFromID(hwnd, EA_HEXDUMP), FALSE);
     501            WinSendDlgItemMsg(hwnd, EA_HEXDUMP, LM_DELETEALL, MPVOID, MPVOID);
     502            *s = 0;
     503            sSelect = (USHORT)WinSendDlgItemMsg(hwnd,
     504                                                EA_LISTBOX,
     505                                                LM_QUERYSELECTION,
     506                                                MPFROMSHORT(LIT_FIRST),
     507                                                MPVOID);
     508            if (sSelect >= 0) {
     509              WinSendDlgItemMsg(hwnd,
     510                                EA_LISTBOX,
     511                                LM_QUERYITEMTEXT,
     512                                MPFROM2SHORT(sSelect, 1024),
     513                                MPFROMP(s));
     514              if (*s) {
     515
     516                USHORT len, num, type;
     517                CHAR *data;
     518                CHAR last = '\n';
     519                const CHAR *linefeed = "\n";
     520                BOOL alltext;
     521                IPT pos = 0;
     522
     523                // Find selected EA and refresh details display
     524                info = eap->head;
     525                while (info) {
     526                  if (!strcmp(s, info->name)) {
     527                    // Found it
     528                    eap->current = info;
     529                    WinShowWindow(WinWindowFromID(hwnd, EA_DELETE), TRUE);
     530                    switch (*(USHORT *)info->value) {
     531                    case EAT_EA:
     532                    case EAT_ASCII:
     533                      if (!strcmp(info->name, SUBJECT))
     534                        WinSendDlgItemMsg(hwnd, EA_ENTRY,
     535                                          EM_SETTEXTLIMIT,
     536                                          MPFROM2SHORT(1024, 0), MPVOID);
     537                      else
     538                        WinSendDlgItemMsg(hwnd, EA_ENTRY,
     539                                          EM_SETTEXTLIMIT,
     540                                          MPFROM2SHORT(1024, 0), MPVOID);
     541                      WinSetDlgItemText(hwnd, EA_ENTRY,
     542                                        info->value + (sizeof(USHORT) * 2));
     543                      WinShowWindow(WinWindowFromID(hwnd, EA_ENTRY), TRUE);
     544                      WinEnableWindow(WinWindowFromID(hwnd, EA_CHANGE),
     545                                      FALSE);
     546                      WinShowWindow(WinWindowFromID(hwnd, EA_CHANGE), TRUE);    // Allow edits
     547                      sprintf(str,
     548                              GetPString(IDS_DATAANDBYTESTEXT),
     549                              *(USHORT *)info->value == EAT_ASCII ?
     550                                GetPString(IDS_TEXTTEXT) :
     551                                GetPString(IDS_EAREFTEXT),
     552                              info->cbValue);
     553                      WinSetDlgItemText(hwnd, EA_TEXT, str);
     554                      break;
     555                    case EAT_MVST:
     556                      MLEclearall(WinWindowFromID(hwnd, EA_MLE));
     557                      num = *(USHORT *)(info->value + (sizeof(USHORT) * 2));
     558                      type = *(USHORT *)(info->value + (sizeof(USHORT) * 3));
     559                      if (type == EAT_ASCII) {
     560                        data = info->value + (sizeof(USHORT) * 4);
     561                        len = *(USHORT *)data;
     562                        data += sizeof(USHORT);
     563                        while ((data - info->value) + len <= info->cbValue) {
     564                          if (last != '\n') {
     565                            WinSendDlgItemMsg(hwnd,
     566                                              EA_MLE,
     567                                              MLM_SETIMPORTEXPORT,
     568                                              MPFROMP(linefeed),
     569                                              MPFROMLONG(1));
     570                            WinSendDlgItemMsg(hwnd,
     571                                              EA_MLE,
     572                                              MLM_IMPORT,
     573                                              MPFROMP(&pos), MPFROMLONG(1));
     574                          }
     575                          WinSendDlgItemMsg(hwnd,
     576                                            EA_MLE,
     577                                            MLM_SETIMPORTEXPORT,
     578                                            MPFROMP(data),
     579                                            MPFROMLONG((ULONG) len));
     580                          WinSendDlgItemMsg(hwnd,
     581                                            EA_MLE,
     582                                            MLM_IMPORT,
     583                                            MPFROMP(&pos),
     584                                            MPFROMLONG((ULONG) len));
     585                          data += len;
     586                          last = *(data - 1);
     587                          if (data - info->value >= info->cbValue)
     588                            break;
     589                          len = *(USHORT *)data;
     590                          data += sizeof(USHORT);
     591                        }
     592                        WinShowWindow(WinWindowFromID(hwnd, EA_MLE), TRUE);
     593                        // Do not know how to edit
     594                        WinEnableWindow(WinWindowFromID(hwnd, EA_CHANGE),
     595                                        FALSE);
     596                        WinShowWindow(WinWindowFromID(hwnd, EA_CHANGE), TRUE);
     597                      }
     598                      else {
     599                        WinShowWindow(WinWindowFromID(hwnd, EA_MLE), FALSE);
     600                        HexDumpEA(hwnd, info);
     601                        WinShowWindow(WinWindowFromID(hwnd, EA_HEXDUMP),
     602                                      TRUE);
     603                      }
     604                      sprintf(str,
     605                              GetPString(IDS_MVSTTEXT),
     606                              num,
     607                              num == 1 ?
     608                                GetPString(IDS_YTEXT) :
     609                                GetPString(IDS_IESTEXT),
     610                              info->cbValue);
     611                      WinSetDlgItemText(hwnd, EA_TEXT, str);
     612                      break;
     613                    case EAT_MVMT:
     614                      MLEclearall(WinWindowFromID(hwnd, EA_MLE));
     615                      num = *(USHORT *)(info->value + (sizeof(USHORT) * 2));
     616                      data = info->value + (sizeof(USHORT) * 3);
     617                      type = *(USHORT *)data;
     618                      data += sizeof(USHORT);
     619                      len = *(USHORT *)data;
     620                      data += sizeof(USHORT);
     621                      alltext = TRUE;
     622                      while ((data - info->value) - len <= info->cbValue) {
     623                        if (type != EAT_ASCII) {
     624                          alltext = FALSE;
     625                          break;
     626                        }
     627                        data += len;
     628                        if (data - info->value >= info->cbValue)
     629                          break;
     630                        type = *(USHORT *)data;
     631                        data += sizeof(USHORT);
     632                        len = *(USHORT *)data;
     633                        data += sizeof(USHORT);
     634                      }
     635                      if (alltext) {
     636                        data = info->value + (sizeof(USHORT) * 3);
     637                        type = *(USHORT *)data;
     638                        data += sizeof(USHORT);
     639                        len = *(USHORT *)data;
     640                        data += sizeof(USHORT);
     641                        while ((data - info->value) - len <= info->cbValue) {
     642                          if (last != '\n') {
     643                            WinSendDlgItemMsg(hwnd,
     644                                              EA_MLE,
     645                                              MLM_SETIMPORTEXPORT,
     646                                              MPFROMP(linefeed),
     647                                              MPFROMLONG(1));
     648                            WinSendDlgItemMsg(hwnd,
     649                                              EA_MLE,
     650                                              MLM_IMPORT,
     651                                              MPFROMP(&pos), MPFROMLONG(1));
     652                          }
     653                          WinSendDlgItemMsg(hwnd,
     654                                            EA_MLE,
     655                                            MLM_SETIMPORTEXPORT,
     656                                            MPFROMP(data),
     657                                            MPFROMLONG((ULONG) len));
     658                          WinSendDlgItemMsg(hwnd,
     659                                            EA_MLE,
     660                                            MLM_IMPORT,
     661                                            MPFROMP(&pos),
     662                                            MPFROMLONG((ULONG) len));
     663                          data += len;
     664                          last = *(data - 1);
     665                          if (data - info->value >= info->cbValue)
     666                            break;
     667                          type = *(USHORT *)data;
     668                          data += sizeof(USHORT);
     669                          len = *(USHORT *)data;
     670                          data += sizeof(USHORT);
     671                        }
     672                      }
     673                      if (alltext) {
     674                        WinShowWindow(WinWindowFromID(hwnd, EA_MLE), TRUE);
     675                        WinEnableWindow(WinWindowFromID(hwnd,
     676                                                        EA_CHANGE), FALSE);
     677                        WinShowWindow(WinWindowFromID(hwnd, EA_CHANGE), TRUE);
     678                      }
     679                      else {
     680                        WinShowWindow(WinWindowFromID(hwnd, EA_MLE), FALSE);
     681                        HexDumpEA(hwnd, info);
     682                        WinShowWindow(WinWindowFromID(hwnd, EA_HEXDUMP),
     683                                      TRUE);
     684                      }
     685                      sprintf(str,
     686                              GetPString(IDS_MVMTTEXT),
     687                              num,
     688                              num == 1 ?
     689                                GetPString(IDS_YTEXT) :
     690                                GetPString(IDS_IESTEXT),
     691                              info->cbValue,
     692                              alltext ?
     693                                GetPString(IDS_ALLTEXTTEXT) :
     694                                GetPString(IDS_MIXEDTYPESTEXT));
     695                      WinSetDlgItemText(hwnd, EA_TEXT, str);
     696                      break;
     697                    default:
     698                      HexDumpEA(hwnd, info);
     699                      WinShowWindow(WinWindowFromID(hwnd, EA_HEXDUMP), TRUE);
     700                      switch (*(USHORT *)info->value) {
     701                      case EAT_BINARY:
     702                        sprintf(str,
     703                                GetPString(IDS_BINARYBYTESTEXT),
     704                                info->fEA ? GetPString(IDS_CRITICALEA) : "",
     705                                info->cbValue);
     706                        WinSetDlgItemText(hwnd, EA_TEXT, str);
     707                        break;
     708                      case EAT_BITMAP:
     709                        sprintf(str,
     710                                GetPString(IDS_BITMAPBYTESTEXT),
     711                                info->cbValue);
     712                        WinSetDlgItemText(hwnd, EA_TEXT, str);
     713                        break;
     714                      case EAT_METAFILE:
     715                        sprintf(str,
     716                                GetPString(IDS_METAFILEBYTESTEXT),
     717                                info->cbValue);
     718                        WinSetDlgItemText(hwnd, EA_TEXT, str);
     719                        break;
     720                      case EAT_ICON:
     721                        sprintf(str,
     722                                GetPString(IDS_ICONBYTESTEXT),
     723                                info->cbValue);
     724                        WinSetDlgItemText(hwnd, EA_TEXT, str);
     725                        break;
     726                      case EAT_ASN1:
     727                        sprintf(str,
     728                                GetPString(IDS_ASN1BYTESTEXT),
     729                                info->cbValue);
     730                        WinSetDlgItemText(hwnd, EA_TEXT, str);
     731                        break;
     732                      default:
     733                        sprintf(str,
     734                                GetPString(IDS_UNKNOWNBYTESTEXT),
     735                                *(USHORT *)info->value,
     736                                info->cbValue);
     737                        WinSetDlgItemText(hwnd, EA_TEXT, str);
     738                        break;
     739                      }
     740                      break;
     741                    } // switch EAT_...
     742                  } // if matched
     743                  info = info->next;
     744                } // while
     745              } // if have name
     746            } // if have select
     747          } // if have non-empty list
     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;
    783763      }
    784764      break;
    … …  
    787767      switch (SHORT2FROMMP(mp1)) {
    788768      case EN_SETFOCUS:
    789         WinSetDlgItemText(hwnd, EA_HELP, (CHAR *) GetPString(IDS_EADATAHELPTEXT));
    790         break;
     769        WinSetDlgItemText(hwnd, EA_HELP, (CHAR *)GetPString(IDS_EADATAHELPTEXT));
     770        break;
    791771      case EN_KILLFOCUS:
    792         WinSetDlgItemText(hwnd, EA_HELP, NullStr);
    793         break;
     772        WinSetDlgItemText(hwnd, EA_HELP, NullStr);
     773        break;
    794774      case EN_CHANGE:
    795         WinEnableWindow(WinWindowFromID(hwnd, EA_CHANGE), TRUE);
    796         break;
     775        WinEnableWindow(WinWindowFromID(hwnd, EA_CHANGE), TRUE);
     776        break;
    797777      }
    798778      break;
    … …  
    801781      switch (SHORT2FROMMP(mp1)) {
    802782      case LN_SETFOCUS:
    803         WinSetDlgItemText(hwnd, EA_HELP, (CHAR *) GetPString(IDS_EADATAHELPTEXT));
    804         break;
     783        WinSetDlgItemText(hwnd, EA_HELP, (CHAR *)GetPString(IDS_EADATAHELPTEXT));
     784        break;
    805785      case LN_KILLFOCUS:
    806         WinSetDlgItemText(hwnd, EA_HELP, NullStr);
    807         break;
     786        WinSetDlgItemText(hwnd, EA_HELP, NullStr);
     787        break;
    808788      }
    809789      break;
    … …  
    812792      switch (SHORT2FROMMP(mp1)) {
    813793      case MLN_SETFOCUS:
    814         WinSetDlgItemText(hwnd, EA_HELP, (CHAR *) GetPString(IDS_EADATAHELPTEXT));
    815         break;
     794        WinSetDlgItemText(hwnd, EA_HELP, (CHAR *)GetPString(IDS_EADATAHELPTEXT));
     795        break;
    816796      case MLN_KILLFOCUS:
    817         WinSetDlgItemText(hwnd, EA_HELP, NullStr);
    818         break;
     797        WinSetDlgItemText(hwnd, EA_HELP, NullStr);
     798        break;
    819799      case MLN_CHANGE:
    820         WinEnableWindow(WinWindowFromID(hwnd, EA_CHANGE), TRUE);
    821         break;
     800        WinEnableWindow(WinWindowFromID(hwnd, EA_CHANGE), TRUE);
     801        break;
    822802      }
    823803      break;
    … …  
    829809    case EA_OPENFILE:
    830810      {
    831         CHAR filename[CCHMAXPATH];
    832         CHAR *p;
    833         CHAR **list = NULL;
    834 
    835         if (*eap->filename)
    836           strcpy(filename, eap->filename);
    837         WinDismissDlg(hwnd, 1);
    838         ForwardslashToBackslash(filename);
     811        CHAR filename[CCHMAXPATH];
     812        CHAR *p;
     813        CHAR **list = NULL;
     814
     815        if (*eap->filename)
     816          strcpy(filename, eap->filename);
     817        WinDismissDlg(hwnd, 1);
     818        ForwardslashToBackslash(filename);
    839819        p = strrchr(filename, '\\');
    840820        if (p) {
    … …  
    846826        strcat(filename, "*");
    847827        list = xmalloc(sizeof(CHAR *) * 2, pszSrcFile, __LINE__);
    848        
    849         if (list) {
    850           if (insert_filename(HWND_DESKTOP,filename,TRUE,FALSE) &&
    851               *filename && *filename != '*') {
    852             list[0] = filename;
    853             list[1] = NULL;
    854             WinDlgBox(HWND_DESKTOP,
    855                       HWND_DESKTOP,
    856                       DisplayEAsProc,
    857                       FM3ModHandle,
    858                       EA_FRAME,
    859                       (PVOID)list);
    860           }
    861           else
    862             free(list);
    863         }
    864         break;
     828
     829        if (list) {
     830          if (insert_filename(HWND_DESKTOP,filename,TRUE,FALSE) &&
     831              *filename && *filename != '*') {
     832            list[0] = filename;
     833            list[1] = NULL;
     834            WinDlgBox(HWND_DESKTOP,
     835                      HWND_DESKTOP,
     836                      DisplayEAsProc,
     837                      FM3ModHandle,
     838                      EA_FRAME,
     839                      (PVOID)list);
     840          }
     841          else
     842            free(list);
     843        }
     844        break;
    865845      }
    866846    case EA_ADD:
    867847      {
    868         ADDEA add;
    869 
    870         add.filename = eap->filename;
    871         add.head = eap->head;
    872         if (WinDlgBox(HWND_DESKTOP, hwnd, AddEAProc, FM3ModHandle,
    873                       EAC_FRAME, &add)) {
    874           Free_FEAList(eap->head);
    875           eap->head = GetFileEAs(eap->filename, FALSE, FALSE);
    876           WinSendMsg(hwnd, UM_SETUP, MPVOID, MPVOID);
    877         }
     848        ADDEA add;
     849
     850        add.filename = eap->filename;
     851        add.head = eap->head;
     852        if (WinDlgBox(HWND_DESKTOP, hwnd, AddEAProc, FM3ModHandle,
     853                      EAC_FRAME, &add)) {
     854          Free_FEAList(eap->head);
     855          eap->head = GetFileEAs(eap->filename, FALSE, FALSE);
     856          WinSendMsg(hwnd, UM_SETUP, MPVOID, MPVOID);
     857        }
    878858      }
    879859      break;
    880860    case EA_CHANGE:
    881861      if (!eap->current)
    882         WinShowWindow(WinWindowFromID(hwnd, EA_CHANGE), FALSE);
     862        WinShowWindow(WinWindowFromID(hwnd, EA_CHANGE), FALSE);
    883863      else {
    884864
    885         CHAR *s;
    886         USHORT control;
    887 
    888         if (!eap->head || !*eap->filename)
    889           Runtime_Error(pszSrcFile, __LINE__, NULL);
    890         else {
    891           switch (*(USHORT *) eap->current->value) {
    892           case EAT_EA:
    893           case EAT_ASCII:
    894             control = EA_ENTRY;
    895             break;
    896           case EAT_MVMT:
    897             control = EA_MLE;
    898             break;
    899           case EAT_MVST:
    900             control = EA_MLE;
    901             break;
    902           default:
    903             Runtime_Error(pszSrcFile, __LINE__, "unexpected type");
    904             WinShowWindow(WinWindowFromID(hwnd, EA_CHANGE), FALSE);
    905             control = 0;
    906           }
    907           if (control) {
    908             s = xmalloc(32768, pszSrcFile, __LINE__);
    909             if (s) {
    910               *s = 0;
    911               WinQueryDlgItemText(hwnd, control, 32767, (PCH) s);
    912               if (!*s)
    913                 Runtime_Error(pszSrcFile, __LINE__, NULL);
    914               else {
    915                 PFEA2LIST pfealist;
    916 
    917                 pfealist = SaveEA(eap->filename, eap->current, s, FALSE);
    918                 if (!pfealist)
    919                   Runtime_Error(pszSrcFile, __LINE__, "SaveEA");
    920                 else {
    921                   PFEA2 pfea;
    922 
    923                   pfea = xmalloc(pfealist->cbList, pszSrcFile, __LINE__);
    924                   if (pfea) {
    925                     memcpy(pfea, pfealist->list,
    926                            pfealist->cbList - sizeof(ULONG));
    927                     free(eap->current->pfea);
    928                     eap->current->pfea = pfea;
    929                     eap->current->name = eap->current->pfea->szName;
    930                     eap->current->cbName = eap->current->pfea->cbName;
    931                     eap->current->cbValue = eap->current->pfea->cbValue;
    932                     eap->current->value = eap->current->pfea->szName +
    933                       eap->current->pfea->cbName + 1;
    934                     eap->current->value[eap->current->cbValue] = 0;
    935                     PostMsg(hwnd, WM_CONTROL,
    936                             MPFROM2SHORT(EA_LISTBOX, LN_SELECT), MPVOID);
    937                   }
    938                   DosFreeMem(pfealist);
    939                 }
    940               }
    941               free(s);
    942             }
    943           }
    944         }
     865        CHAR *s;
     866        USHORT control;
     867
     868        if (!eap->head || !*eap->filename)
     869          Runtime_Error(pszSrcFile, __LINE__, NULL);
     870        else {
     871          switch (*(USHORT *)eap->current->value) {
     872          case EAT_EA:
     873          case EAT_ASCII:
     874            control = EA_ENTRY;
     875            break;
     876          case EAT_MVMT:
     877            control = EA_MLE;
     878            break;
     879          case EAT_MVST:
     880            control = EA_MLE;
     881            break;
     882          default:
     883            Runtime_Error(pszSrcFile, __LINE__, "unexpected type");
     884            WinShowWindow(WinWindowFromID(hwnd, EA_CHANGE), FALSE);
     885            control = 0;
     886          }
     887          if (control) {
     888            s = xmalloc(32768, pszSrcFile, __LINE__);
     889            if (s) {
     890              *s = 0;
     891              WinQueryDlgItemText(hwnd, control, 32767, (PCH) s);
     892              if (!*s)
     893                Runtime_Error(pszSrcFile, __LINE__, NULL);
     894              else {
     895                PFEA2LIST pfealist;
     896
     897                // FIXME to only rewrite if modified
     898                pfealist = SaveEA(eap->filename, eap->current, s, FALSE);
     899                if (!pfealist)
     900                  Runtime_Error(pszSrcFile, __LINE__, "SaveEA");
     901                else {
     902                  // EA rewritten - update listbox
     903                  PFEA2 pfea = xmalloc(pfealist->cbList, pszSrcFile, __LINE__);
     904                  if (pfea) {
     905                    memcpy(pfea,
     906                           pfealist->list,
     907                           pfealist->cbList - sizeof(ULONG));
     908                    free(eap->current->pfea);   // Stale
     909                    // Refresh current
     910                    eap->current->pfea = pfea;
     911                    eap->current->name = eap->current->pfea->szName;
     912                    eap->current->cbName = eap->current->pfea->cbName;
     913                    eap->current->fEA = eap->current->pfea->fEA;
     914                    eap->current->cbValue = eap->current->pfea->cbValue;
     915                    eap->current->value = eap->current->pfea->szName +
     916                      eap->current->pfea->cbName + 1;
     917                    eap->current->value[eap->current->cbValue] = 0;
     918                    // Refresh display
     919                    PostMsg(hwnd, WM_CONTROL,
     920                            MPFROM2SHORT(EA_LISTBOX, LN_SELECT), MPVOID);
     921                  }
     922                  DosFreeMem(pfealist);
     923                }
     924              }
     925              free(s);
     926            }
     927          }
     928        }
    945929      }
    946930      break;
    … …  
    949933      if (eap->head && eap->current) {
    950934
    951         EAOP2 eaop;
    952         PFEA2LIST pfealist;
    953         GEA2LIST gealist;
    954         APIRET rc;
    955         SHORT sSelect;
    956 
    957         pfealist =
    958           xmallocz(sizeof(FEA2LIST) + eap->current->cbName + 1, pszSrcFile,
    959                    __LINE__);
    960         if (pfealist) {
    961           pfealist->cbList = sizeof(FEA2LIST) + eap->current->cbName + 1;
    962           pfealist->list[0].cbName = eap->current->cbName;
    963           strcpy(pfealist->list[0].szName, eap->current->name);
    964           pfealist->list[0].cbValue = 0;
    965           memset(&gealist, 0, sizeof(GEA2LIST));
    966           gealist.cbList = sizeof(GEA2LIST);
    967           eaop.fpGEA2List = &gealist;
    968           eaop.fpFEA2List = pfealist;
    969           eaop.oError = 0;
    970           rc = xDosSetPathInfo(eap->filename, FIL_QUERYEASIZE,
    971                                &eaop, sizeof(eaop), DSPI_WRTTHRU);
    972           free(pfealist);
    973           if (rc)
    974             Dos_Error(MB_CANCEL, rc, hwnd, pszSrcFile, __LINE__,
    975                       "xDosSetPathInfo");
    976           else {
    977             sSelect = 0;
    978             if (eap->current == eap->head) {
    979               eap->head = eap->head->next;
    980               free(eap->current->pfea);
    981               free(eap->current);
    982               eap->current = NULL;
    983             }
    984             else {
    985               info = eap->head;
    986               while (info) {
    987                 if (info->next == eap->current) {
    988                   sSelect++;
    989                   info->next = eap->current->next;
    990                   free(eap->current->pfea);
    991                   free(eap->current);
    992                   eap->current = NULL;
    993                   break;
    994                 }
    995                 sSelect++;
    996                 info = info->next;
    997               }
    998             }
    999             WinSendDlgItemMsg(hwnd, EA_LISTBOX, LM_DELETEITEM,
    1000                               MPFROM2SHORT(sSelect, 0), MPVOID);
    1001             WinShowWindow(WinWindowFromID(hwnd, EA_ENTRY), FALSE);
    1002             WinShowWindow(WinWindowFromID(hwnd, EA_MLE), FALSE);
    1003             WinShowWindow(WinWindowFromID(hwnd, EA_CHANGE), FALSE);
    1004             WinShowWindow(WinWindowFromID(hwnd, EA_DELETE), FALSE);
    1005             WinShowWindow(WinWindowFromID(hwnd, EA_HEXDUMP), FALSE);
    1006             WinSetDlgItemText(hwnd, EA_ENTRY, NullStr);
    1007             MLEclearall(WinWindowFromID(hwnd, EA_MLE));
    1008             WinSendDlgItemMsg(hwnd, EA_HEXDUMP, LM_DELETEALL, MPVOID, MPVOID);
    1009             if (sSelect && (SHORT) WinSendDlgItemMsg(hwnd, EA_LISTBOX,
    1010                                                      LM_QUERYITEMCOUNT,
    1011                                                      MPVOID, MPVOID) <=
    1012                 sSelect)
    1013               sSelect--;
    1014             WinSendDlgItemMsg(hwnd, EA_LISTBOX, LM_SELECTITEM,
    1015                               MPFROM2SHORT(sSelect, 0),
    1016                               MPFROM2SHORT(TRUE, 0));
    1017           }
    1018         }
     935        EAOP2 eaop;
     936        PFEA2LIST pfealist;
     937        GEA2LIST gealist;
     938        APIRET rc;
     939        SHORT sSelect;
     940
     941        pfealist =
     942          xmallocz(sizeof(FEA2LIST) + eap->current->cbName + 1, pszSrcFile,
     943                   __LINE__);
     944        if (pfealist) {
     945          pfealist->cbList = sizeof(FEA2LIST) + eap->current->cbName + 1;
     946          pfealist->list[0].cbName = eap->current->cbName;
     947          strcpy(pfealist->list[0].szName, eap->current->name);
     948          pfealist->list[0].cbValue = 0;
     949          memset(&gealist, 0, sizeof(GEA2LIST));
     950          gealist.cbList = sizeof(GEA2LIST);
     951          eaop.fpGEA2List = &gealist;
     952          eaop.fpFEA2List = pfealist;
     953          eaop.oError = 0;
     954          rc = xDosSetPathInfo(eap->filename, FIL_QUERYEASIZE,
     955                               &eaop, sizeof(eaop), DSPI_WRTTHRU);
     956          free(pfealist);
     957          if (rc)
     958            Dos_Error(MB_CANCEL, rc, hwnd, pszSrcFile, __LINE__,
     959                      "xDosSetPathInfo");
     960          else {
     961            sSelect = 0;
     962            if (eap->current == eap->head) {
     963              eap->head = eap->head->next;
     964              free(eap->current->pfea);
     965              free(eap->current);
     966              eap->current = NULL;
     967            }
     968            else {
     969              info = eap->head;
     970              while (info) {
     971                if (info->next == eap->current) {
     972                  sSelect++;
     973                  info->next = eap->current->next;
     974                  free(eap->current->pfea);
     975                  free(eap->current);
     976                  eap->current = NULL;
     977                  break;
     978                }
     979                sSelect++;
     980                info = info->next;
     981              }
     982            }
     983            WinSendDlgItemMsg(hwnd, EA_LISTBOX, LM_DELETEITEM,
     984                              MPFROM2SHORT(sSelect, 0), MPVOID);
     985            WinShowWindow(WinWindowFromID(hwnd, EA_ENTRY), FALSE);
     986            WinShowWindow(WinWindowFromID(hwnd, EA_MLE), FALSE);
     987            WinShowWindow(WinWindowFromID(hwnd, EA_CHANGE), FALSE);
     988            WinShowWindow(WinWindowFromID(hwnd, EA_DELETE), FALSE);
     989            WinShowWindow(WinWindowFromID(hwnd, EA_HEXDUMP), FALSE);
     990            WinSetDlgItemText(hwnd, EA_ENTRY, NullStr);
     991            MLEclearall(WinWindowFromID(hwnd, EA_MLE));
     992            WinSendDlgItemMsg(hwnd, EA_HEXDUMP, LM_DELETEALL, MPVOID, MPVOID);
     993            if (sSelect && (SHORT) WinSendDlgItemMsg(hwnd, EA_LISTBOX,
     994                                                     LM_QUERYITEMCOUNT,
     995                                                     MPVOID, MPVOID) <=
     996                sSelect)
     997              sSelect--;
     998            WinSendDlgItemMsg(hwnd, EA_LISTBOX, LM_SELECTITEM,
     999                              MPFROM2SHORT(sSelect, 0),
     1000                              MPFROM2SHORT(TRUE, 0));
     1001          }
     1002        }
    10191003      }
    10201004      if (!eap->head)
    1021         WinSetDlgItemText(hwnd, EA_TEXT, (CHAR *) GetPString(IDS_EANOEAS));
     1005        WinSetDlgItemText(hwnd, EA_TEXT, (CHAR *)GetPString(IDS_EANOEAS));
    10221006      break;
    10231007
    10241008    case IDM_HELP:
    10251009      if (hwndHelp)
    1026         WinSendMsg(hwndHelp, HM_DISPLAY_HELP,
    1027                    MPFROM2SHORT(HELP_EAS, 0), MPFROMSHORT(HM_RESOURCEID));
     1010        WinSendMsg(hwndHelp, HM_DISPLAY_HELP,
     1011                   MPFROM2SHORT(HELP_EAS, 0), MPFROMSHORT(HM_RESOURCEID));
    10281012      break;
    10291013
    … …  
    10441028    if (eap) {
    10451029      if (eap->head)
    1046         Free_FEAList(eap->head);
     1030        Free_FEAList(eap->head);
    10471031      xfree(mp2, pszSrcFile, __LINE__);
    10481032      free(eap);
    10491033      if (hptrIcon)
    1050         WinDestroyPointer(hptrIcon);
     1034        WinDestroyPointer(hptrIcon);
    10511035      hptrIcon = (HPOINTER) 0;
    10521036    }
    … …  
    10561040}
    10571041
    1058 PVOID SaveEA(CHAR * filename, HOLDFEA * current, CHAR * newdata,
    1059              BOOL silentfail)
     1042/**
     1043 * Update one file EA
     1044 * @param filename is file to be updated
     1045 * @param current is discriptor for current EA value
     1046 * @param newdata is text string to be converted to EA value
     1047 * @param silentfail suppresses error message boxes if set
     1048 * @returns point to FEA2LIST for updated EA or NULL if error
     1049 */
     1050
     1051PVOID SaveEA(CHAR *filename,
     1052             HOLDFEA *current,
     1053             CHAR *newdata,
     1054             BOOL silentfail)
    10601055{
    1061   // save an ea to disk
    1062 
    10631056  PFEA2LIST pfealist = NULL;
    10641057  EAOP2 eaop;
    … …  
    10661059  ULONG ealen;
    10671060  USHORT len, *num, *plen;
    1068   CHAR *p, *eaval;
     1061  CHAR *p, *peaval;
     1062
     1063  DbgMsg(pszSrcFile, __LINE__, "SaveEA: entered for %s", filename);
    10691064
    10701065  if (!filename || !current)
    1071     return (PVOID) pfealist;
     1066    return (PVOID)pfealist;             // FIXME to complain
     1067
    10721068  len = strlen(newdata);
    10731069  ealen = sizeof(FEA2LIST) + 24 + (ULONG) current->cbName + 1 +
    1074          (ULONG)len + 4;
    1075   switch (*(USHORT *) current->value) {
     1070         (ULONG)len + 4;
     1071  // Do type specific adjustments to EA length
     1072  switch (*(USHORT *)current->value) {
    10761073  case EAT_EA:
    10771074  case EAT_ASCII:
    … …  
    10841081    while (*p) {
    10851082      if (*p == '\n' && *(p + 1))
    1086         ealen += sizeof(USHORT);
     1083        ealen += sizeof(USHORT);
    10871084      p++;
    10881085    }
    … …  
    10951092    while (*p) {
    10961093      if (*p == '\n' && *(p + 1))
    1097         ealen += (sizeof(USHORT) * 2);
     1094        ealen += (sizeof(USHORT) * 2);
    10981095      p++;
    10991096    }
    11001097    break;
    11011098  default:
     1099    // FIXME to complain
    11021100    return (PVOID) pfealist;
    1103   }
    1104 
    1105   if (!xDosAllocMem((PPVOID) & pfealist, ealen, pszSrcFile, __LINE__)) {
     1101  } // switch EAT_...
     1102
     1103  if (!xDosAllocMem((PPVOID)&pfealist, ealen, pszSrcFile, __LINE__)) {
     1104    // Build FEA2LIST
    11061105    memset(pfealist, 0, ealen);
    11071106    pfealist->list[0].oNextEntryOffset = 0;
    1108     pfealist->list[0].fEA = 0;          //current->fEA;
     1107    // pfealist->list[0].fEA = 0;               //  Always write non-critical EAs
     1108    pfealist->list[0].fEA = current->fEA;       //  Retain critical EA flags 2014-02-10 SHL
    11091109
    11101110    pfealist->list[0].cbName = current->cbName;
    11111111    memcpy(pfealist->list[0].szName, current->name,
    1112            pfealist->list[0].cbName + 1);
    1113     eaval = pfealist->list[0].szName + pfealist->list[0].cbName + 1;
    1114     switch (*(USHORT *) current->value) {
     1112           pfealist->list[0].cbName + 1);
     1113    peaval = pfealist->list[0].szName + pfealist->list[0].cbName + 1;
     1114
     1115    // Build new EA value
     1116    switch (*(USHORT *)current->value) {
    11151117    case EAT_EA:
    11161118    case EAT_ASCII:
    1117       *(USHORT *) eaval = *(USHORT *) current->value;
    1118       eaval += sizeof(USHORT);
    1119       *(USHORT *) eaval = (USHORT) len;
    1120       eaval += sizeof(USHORT);
    1121       memcpy(eaval, newdata, len);
    1122       eaval += len;
     1119      *(USHORT *)peaval = *(USHORT *)current->value;
     1120      peaval += sizeof(USHORT);
     1121      *(USHORT *)peaval = (USHORT)len;
     1122      peaval += sizeof(USHORT);
     1123      memcpy(peaval, newdata, len);
     1124      peaval += len;
    11231125      break;
    11241126    case EAT_MVST:
    1125       *(USHORT *) eaval = (USHORT) EAT_MVST;
    1126       eaval += sizeof(USHORT);
    1127       *(USHORT *) eaval = *(USHORT *) (current->value + sizeof(USHORT));
    1128       eaval += sizeof(USHORT);
    1129       num = (USHORT *) eaval;
     1127      *(USHORT *)peaval = (USHORT)EAT_MVST;
     1128      peaval += sizeof(USHORT);
     1129      *(USHORT *)peaval = *(USHORT *)(current->value + sizeof(USHORT));
     1130      peaval += sizeof(USHORT);
     1131      num = (USHORT *)peaval;
    11301132      *num = 0;
    1131       eaval += sizeof(USHORT);
    1132       *(USHORT *) eaval = (USHORT) EAT_ASCII;
    1133       eaval += sizeof(USHORT);
    1134       plen = (USHORT *) eaval;
     1133      peaval += sizeof(USHORT);
     1134      *(USHORT *)peaval = (USHORT)EAT_ASCII;
     1135      peaval += sizeof(USHORT);
     1136      plen = (USHORT *)peaval;
    11351137      *plen = 0;
    1136       eaval += sizeof(USHORT);
     1138      peaval += sizeof(USHORT);
    11371139      p = newdata;
    11381140      while (*p == '\n')
    1139         p++;
     1141        p++;
    11401142      while (*p) {
    1141         while (*p) {
    1142           if (*p == '\n')
    1143             p++;
    1144           *eaval++ = *p++;
    1145           (*plen)++;
    1146         }
    1147         if (*p || *plen)
    1148           (*num)++;
    1149         if (*p) {
    1150           plen = (USHORT *) eaval;
    1151           *plen = 0;
    1152           eaval += sizeof(USHORT);
    1153         }
    1154       }
    1155       break;
    1156 /**
    1157  * cbList      nextoffset fea cb cbval name.......
    1158  * 000000  3C 00 00 00 00 00 00 00 6F 0B 24 00 2E 4B 45 59  <       o
     1143        while (*p) {
     1144          if (*p == '\n')
     1145            p++;
     1146          *peaval++ = *p++;
     1147          (*plen)++;
     1148        }
     1149        if (*p || *plen)
     1150          (*num)++;
     1151        if (*p) {
     1152          plen = (USHORT *)peaval;
     1153          *plen = 0;
     1154          peaval += sizeof(USHORT);
     1155        }
     1156      }
     1157      break;
     1158
     1159   /**
     1160    * cbList      nextoffset fea cb cbval name.......
     1161    * 000000  3C 00 00 00 00 00 00 00 6F 0B 24 00 2E 4B 45 59  <       o
    11591162$ .KEY
    1160  * ....................    eat   code  num   eat
    1161  * 000010  50 48 52 41 53 45 53 00 DF FF 00 00 02 00 FD FF  PHRASES ßÿ  ýÿ
    1162  * len.. phrase1............................ eat
    1163  * 000020  0C 00 4B 65 79 20 70 68 72 61 73 65 20 31 FD FF 
     1163    * ....................    eat   code  num   eat
     1164    * 000010  50 48 52 41 53 45 53 00 DF FF 00 00 02 00 FD FF  PHRASES ßÿ  ýÿ
     1165    * len.. phrase1............................ eat
     1166    * 000020  0C 00 4B 65 79 20 70 68 72 61 73 65 20 31 FD FF 
    11641167 Key phrase 1ýÿ
    1165  * len.. phrase2......................
    1166  * 000030  0A 00 4B 65 79 20 70 68 72 61 73 65               Key phrase
    1167  */
     1168    * len.. phrase2......................
     1169    * 000030  0A 00 4B 65 79 20 70 68 72 61 73 65               Key phrase
     1170    */
    11681171    case EAT_MVMT:
    1169       *(USHORT *) eaval = (USHORT) EAT_MVMT;
    1170       eaval += sizeof(USHORT);
    1171       *(USHORT *) eaval = *(USHORT *) (current->value + sizeof(USHORT));
    1172       eaval += sizeof(USHORT);
    1173       num = (USHORT *) eaval;
     1172      *(USHORT *)peaval = (USHORT)EAT_MVMT;
     1173      peaval += sizeof(USHORT);
     1174      *(USHORT *)peaval = *(USHORT *)(current->value + sizeof(USHORT));
     1175      peaval += sizeof(USHORT);
     1176      num = (USHORT *)peaval;
    11741177      *num = 0;
    1175       eaval += sizeof(USHORT);
    1176       *(USHORT *) eaval = (USHORT) EAT_ASCII;
    1177       eaval += sizeof(USHORT);
    1178       plen = (USHORT *) eaval;
     1178      peaval += sizeof(USHORT);
     1179      *(USHORT *)peaval = (USHORT)EAT_ASCII;
     1180      peaval += sizeof(USHORT);
     1181      plen = (USHORT *)peaval;
    11791182      *plen = 0;
    1180       eaval += sizeof(USHORT);
     1183      peaval += sizeof(USHORT);
    11811184      p = newdata;
    11821185      while (*p == '\n')
    1183         p++;
     1186        p++;
    11841187      while (*p) {
    1185         while (*p) {
    1186           if (*p == '\n')
    1187             p++;
    1188           *eaval++ = *p++;
    1189           (*plen)++;
    1190         }
    1191         if (*p || *plen)
    1192           (*num)++;
    1193         if (*p) {
    1194           *(USHORT *) eaval = (USHORT) EAT_ASCII;
    1195           eaval += sizeof(USHORT);
    1196           plen = (USHORT *) eaval;
    1197           *plen = 0;
    1198           eaval += sizeof(USHORT);
    1199         }
    1200       }
    1201       break;
    1202     }
    1203     pfealist->list[0].cbValue = eaval - (pfealist->list[0].szName + pfealist->list[0].cbName + 1);
    1204     eaop.fpGEA2List = (PGEA2LIST) 0;
     1188        while (*p) {
     1189          if (*p == '\n')
     1190            p++;
     1191          *peaval++ = *p++;
     1192          (*plen)++;
     1193        }
     1194        if (*p || *plen)
     1195          (*num)++;
     1196        if (*p) {
     1197          *(USHORT *)peaval = (USHORT)EAT_ASCII;
     1198          peaval += sizeof(USHORT);
     1199          plen = (USHORT *)peaval;
     1200          *plen = 0;
     1201          peaval += sizeof(USHORT);
     1202        }
     1203      }
     1204      break;
     1205    } // switch EAT_...
     1206
     1207    pfealist->list[0].cbValue = peaval - (pfealist->list[0].szName + pfealist->list[0].cbName + 1);
     1208    eaop.fpGEA2List = (PGEA2LIST)0;
    12051209    eaop.fpFEA2List = pfealist;
    12061210    eaop.oError = 0;
    12071211    pfealist->cbList = 13 + (ULONG) pfealist->list[0].cbName +
    1208                        (ULONG)pfealist->list[0].cbValue;
    1209 
     1212                       (ULONG)pfealist->list[0].cbValue;
     1213
     1214#if 1
     1215    // Rewrite iff modified
     1216    if (current->pfea->cbValue == pfealist->list[0].cbValue &&
     1217        memcmp(current->pfea->szName + current->pfea->cbName + 1,
     1218               pfealist->list[0].szName + pfealist->list[0].cbName + 1,
     1219               current->pfea->cbValue) == 0)
     1220    {
     1221      DbgMsg(pszSrcFile, __LINE__, "SaveEA: %s unchanged", current->pfea->szName);
     1222      rc = 0;                           // Suppress rewrite
     1223    }
     1224    else {
     1225      rc = xDosSetPathInfo(filename, FIL_QUERYEASIZE,
     1226                           &eaop, sizeof(eaop), DSPI_WRTTHRU);
     1227      DbgMsg(pszSrcFile, __LINE__, "SaveEA: %s updated", current->pfea->szName);
     1228    }
     1229#else
     1230    // Rewrite EA
    12101231    rc = xDosSetPathInfo(filename, FIL_QUERYEASIZE,
    1211                          &eaop, sizeof(eaop), DSPI_WRTTHRU);
     1232                         &eaop, sizeof(eaop), DSPI_WRTTHRU);
     1233#endif
    12121234    if (rc) {
    12131235      DosFreeMem(pfealist);
    … …  
    12161238    if (rc && !silentfail) {
    12171239      if (rc == ERROR_ACCESS_DENIED || rc == ERROR_SHARING_VIOLATION) {
    1218         saymsg(MB_ENTER,
    1219                HWND_DESKTOP,
    1220                GetPString(IDS_OOPSTEXT),
    1221                GetPString(IDS_CANTWRITEEATEXT), current->name, filename);
     1240        saymsg(MB_ENTER,
     1241               HWND_DESKTOP,
     1242               GetPString(IDS_OOPSTEXT),
     1243               GetPString(IDS_CANTWRITEEATEXT), current->name, filename);
    12221244      }
    12231245      else {
    1224         Dos_Error(MB_ENTER,
    1225                   rc,
    1226                   HWND_DESKTOP,
    1227                   pszSrcFile,
    1228                   __LINE__,
    1229                   GetPString(IDS_ERRORWRITEEATEXT),
    1230                   current->name, filename, eaop.oError);
     1246        Dos_Error(MB_ENTER,
     1247                  rc,
     1248                  HWND_DESKTOP,
     1249                  pszSrcFile,
     1250                  __LINE__,
     1251                  GetPString(IDS_ERRORWRITEEATEXT),
     1252                  current->name, filename, eaop.oError);
    12311253      }
    12321254    }
    12331255  }
    1234   return (PVOID) pfealist;
     1256  return (PVOID)pfealist;
    12351257}
    12361258
    … …  
    12481270    return head;
    12491271  if (ishandle || !DosOpen(filename, &handle, &action, 0, 0,
    1250                            OPEN_ACTION_FAIL_IF_NEW |
    1251                            OPEN_ACTION_OPEN_IF_EXISTS,
    1252                            OPEN_FLAGS_NOINHERIT |
    1253                            OPEN_SHARE_DENYREADWRITE |
    1254                            OPEN_ACCESS_READWRITE, (PEAOP2)0)) {
     1272                           OPEN_ACTION_FAIL_IF_NEW |
     1273                           OPEN_ACTION_OPEN_IF_EXISTS,
     1274                           OPEN_FLAGS_NOINHERIT |
     1275                           OPEN_SHARE_DENYREADWRITE |
     1276                           OPEN_ACCESS_READWRITE, (PEAOP2)0)) {
    12551277    if (ishandle)
    12561278      handle = *(HFILE *) filename;
    12571279    if (!DosQueryFileInfo(handle, FIL_QUERYEASIZE, (PVOID)&fsa4,
    1258                           (ULONG) sizeof(fsa4)) &&
    1259         fsa4.cbList > 4)
     1280                          (ULONG) sizeof(fsa4)) &&
     1281        fsa4.cbList > 4)
    12601282    {
    12611283      PDENA2 pdena;
    … …  
    12651287      PGEA2 pgea;
    12661288      ULONG ulEntry = 1;                // Ordinal of EA to return
    1267       ULONG ulCount = 1;                // # of EAs to return
     1289      ULONG ulCount = 1;                // # of EAs to return per call
    12681290
    12691291      pdena = xmalloc(65536 + 1024, pszSrcFile, __LINE__);
    12701292      if (pdena) {
    1271         while (!DosEnumAttribute(ENUMEA_REFTYPE_FHANDLE,
    1272                                  &handle,
    1273                                  ulEntry,
    1274                                  (PVOID)pdena,
    1275                                  (ULONG)65536,
    1276                                  &ulCount,
    1277                                  ENUMEA_LEVEL_NO_VALUE) &&
    1278                ulCount)
    1279         {
    1280           // 64 is for header and spare - fixme to allocate smarter
    1281           pgealist = xmalloc(64 + pdena->cbName, pszSrcFile, __LINE__);
    1282           if (pgealist) {
    1283             pgealist->cbList = 64 + pdena->cbName;
    1284             pgea = pgealist->list;
    1285             pgea->oNextEntryOffset = 0;
    1286             pgea->cbName = pdena->cbName;
    1287             memcpy(pgea->szName, pdena->szName, pdena->cbName + 1);
    1288             pfealist = xmallocz(64 + pdena->cbName + pdena->cbValue,
    1289                                 pszSrcFile, __LINE__);
    1290             if (pfealist) {
    1291               pfealist->cbList = 64 + pdena->cbName + pdena->cbValue;
    1292               eaop.fpGEA2List = pgealist;
    1293               eaop.fpFEA2List = pfealist;
    1294               eaop.oError = 0;
    1295               rc = DosQueryFileInfo(handle, FIL_QUERYEASFROMLIST, (PVOID) & eaop,
    1296                                     (ULONG) sizeof(EAOP2));
    1297               if (rc) {
    1298                 if (!silentfail) {
    1299                   Dos_Error(MB_ENTER,
    1300                             rc,
    1301                             HWND_DESKTOP,
    1302                             pszSrcFile,
    1303                             __LINE__,
    1304                             GetPString(IDS_ERRORREADEATEXT), pdena->szName);
    1305                 }
    1306               }
    1307               else {
    1308                 info = xmalloc(sizeof(HOLDFEA), pszSrcFile, __LINE__);
    1309                 if (info) {
    1310                   // 05 Jul 07 SHL was one short
    1311                   info->pfea = xmalloc(eaop.fpFEA2List->cbList - sizeof(ULONG) + 1,
    1312                                        pszSrcFile, __LINE__);
    1313                   memcpy(info->pfea, eaop.fpFEA2List->list,
    1314                          eaop.fpFEA2List->cbList - sizeof(ULONG));
    1315                   info->name = info->pfea->szName;
    1316                   info->cbName = info->pfea->cbName;
    1317                   info->cbValue = info->pfea->cbValue;
    1318                   info->value = info->pfea->szName + info->pfea->cbName + 1;
    1319                   info->value[info->cbValue] = 0;
    1320                   info->next = NULL;
    1321                   if (!head)
    1322                     head = info;
    1323                   else
    1324                     last->next = info;
    1325                   last = info;
    1326                 }
    1327               }
    1328               free(pfealist);
    1329             }
    1330             free(pgealist);
    1331           }
    1332           ulEntry += ulCount;
    1333         } // while
    1334         free(pdena);
    1335         DosPostEventSem(CompactSem);
    1336       }
     1293        while (!DosEnumAttribute(ENUMEA_REFTYPE_FHANDLE,
     1294                                 &handle,
     1295                                 ulEntry,
     1296                                 (PVOID)pdena,
     1297                                 (ULONG)65536,
     1298                                 &ulCount,
     1299                                 ENUMEA_LEVEL_NO_VALUE) &&
     1300               ulCount)
     1301        {
     1302          // 64 is for header and spare - FIXME to allocate smarter
     1303          pgealist = xmalloc(64 + pdena->cbName, pszSrcFile, __LINE__);
     1304          if (pgealist) {
     1305            pgealist->cbList = 64 + pdena->cbName;
     1306            pgea = pgealist->list;
     1307            pgea->oNextEntryOffset = 0;
     1308            pgea->cbName = pdena->cbName;
     1309            memcpy(pgea->szName, pdena->szName, pdena->cbName + 1);
     1310            pfealist = xmallocz(64 + pdena->cbName + pdena->cbValue,
     1311                                pszSrcFile, __LINE__);
     1312            if (pfealist) {
     1313              pfealist->cbList = 64 + pdena->cbName + pdena->cbValue;
     1314              eaop.fpGEA2List = pgealist;
     1315              eaop.fpFEA2List = pfealist;
     1316              eaop.oError = 0;
     1317              rc = DosQueryFileInfo(handle,
     1318                                    FIL_QUERYEASFROMLIST,
     1319                                    (PVOID)&eaop,
     1320                                    (ULONG)sizeof(EAOP2));
     1321              if (rc) {
     1322                if (!silentfail) {
     1323                  Dos_Error(MB_ENTER,
     1324                            rc,
     1325                            HWND_DESKTOP,
     1326                            pszSrcFile,
     1327                            __LINE__,
     1328                            GetPString(IDS_ERRORREADEATEXT), pdena->szName);
     1329                }
     1330              }
     1331              else {
     1332                info = xmalloc(sizeof(HOLDFEA), pszSrcFile, __LINE__);
     1333                if (info) {
     1334                  // 05 Jul 07 SHL was one short
     1335                  info->pfea = xmalloc(eaop.fpFEA2List->cbList - sizeof(ULONG) + 1,
     1336                                       pszSrcFile, __LINE__);
     1337                  memcpy(info->pfea, eaop.fpFEA2List->list,
     1338                         eaop.fpFEA2List->cbList - sizeof(ULONG));
     1339                  // Copy for hold
     1340                  info->name = info->pfea->szName;
     1341                  info->cbName = info->pfea->cbName;
     1342                  info->fEA = info->pfea->fEA;  // 2014-02-10 SHL
     1343                  info->cbValue = info->pfea->cbValue;
     1344                  info->value = info->pfea->szName + info->pfea->cbName + 1;
     1345                  info->value[info->cbValue] = 0;
     1346                  info->next = NULL;
     1347                  // Add to list
     1348                  if (!head)
     1349                    head = info;
     1350                  else
     1351                    last->next = info;
     1352                  last = info;
     1353                } // if malloc OK
     1354              } // if query from list OK
     1355              free(pfealist);
     1356            } // if malloc OK
     1357            free(pgealist);
     1358          } // if malloc OK
     1359          ulEntry += ulCount;
     1360        } // while have EAs
     1361        free(pdena);
     1362        DosPostEventSem(CompactSem);
     1363      } // if malloc OK
    13371364    }
    13381365    if (!ishandle)
    … …  
    13401367  }
    13411368  else {
    1342     // try it without opening it
    1343     if (!DosQueryPathInfo(filename, FIL_QUERYEASIZE, (PVOID) & fsa4,
    1344                           (ULONG) sizeof(fsa4)) &&
    1345         fsa4.cbList > 4)
     1369    // File probably in use - try to get EAs without opening file
     1370    if (!DosQueryPathInfo(filename,
     1371                          FIL_QUERYEASIZE,
     1372                          (PVOID)&fsa4,
     1373                          (ULONG)sizeof(fsa4)) &&
     1374        fsa4.cbList > 4)
    13461375    {
    13471376      PDENA2 pdena;
    … …  
    13541383      pdena = xmalloc(65536 + 1024, pszSrcFile, __LINE__);
    13551384      if (pdena) {
    1356         while (!DosEnumAttribute
    1357                (ENUMEA_REFTYPE_PATH, filename, ulEntry, (PVOID) pdena,
    1358                 (ULONG) 65536, &ulCount, ENUMEA_LEVEL_NO_VALUE) && ulCount)
    1359         {
    1360           pgealist = xmalloc(64 + pdena->cbName, pszSrcFile, __LINE__);
    1361           if (pgealist) {
    1362             pgealist->cbList = 64 + pdena->cbName;
    1363             pgea = pgealist->list;
    1364             pgea->oNextEntryOffset = 0;
    1365             pgea->cbName = pdena->cbName;
    1366             memcpy(pgea->szName, pdena->szName, pdena->cbName + 1);
    1367             pfealist =
    1368               xmallocz(64 + pdena->cbName + pdena->cbValue, pszSrcFile,
    1369                        __LINE__);
    1370             if (pfealist) {
    1371               pfealist->cbList = 64 + pdena->cbName + pdena->cbValue;
    1372               eaop.fpGEA2List = pgealist;
    1373               eaop.fpFEA2List = pfealist;
    1374               eaop.oError = 0;
    1375               rc = DosQueryPathInfo(filename, FIL_QUERYEASFROMLIST,
    1376                                     (PVOID) & eaop, (ULONG) sizeof(EAOP2));
    1377               if (!rc) {
    1378                 info = xmalloc(sizeof(HOLDFEA), pszSrcFile, __LINE__);
    1379                 if (info) {
    1380                // 29 Nov 07 GKY One short (EA search crash)
    1381                   info->pfea =
    1382                     xmalloc(eaop.fpFEA2List->cbList - sizeof(ULONG) + 1,
    1383                             pszSrcFile, __LINE__);
    1384                   memcpy(info->pfea, eaop.fpFEA2List->list,
    1385                          eaop.fpFEA2List->cbList - sizeof(ULONG));
    1386                   info->name = info->pfea->szName;
    1387                   info->cbName = info->pfea->cbName;
    1388                   info->cbValue = info->pfea->cbValue;
    1389                   info->value = info->pfea->szName + info->pfea->cbName + 1;
    1390                   info->value[info->cbValue] = 0;
    1391                   info->next = NULL;
    1392                   if (!head)
    1393                     head = info;
    1394                   else
    1395                     last->next = info;
    1396                   last = info;
    1397                 }
    1398                 else
    1399                   free(pfealist);
    1400               }
    1401               else {
    1402                 free(pfealist);
    1403                 if (!silentfail) {
    1404                   if (rc == ERROR_ACCESS_DENIED
    1405                       || rc == ERROR_SHARING_VIOLATION) {
    1406                     rc =
    1407                       saymsg(MB_ENTER | MB_CANCEL, HWND_DESKTOP,
    1408                              GetPString(IDS_OOPSTEXT),
    1409                              GetPString(IDS_CANTREADEATEXT), filename,
    1410                              pdena->szName);
    1411                     if (rc == MBID_CANCEL) {
    1412                       free(pgealist);
    1413                       break;
    1414                     }
    1415                   }
    1416                   else {
    1417                     Dos_Error(MB_ENTER,
    1418                               rc,
    1419                               HWND_DESKTOP,
    1420                               pszSrcFile,
    1421                               __LINE__,
    1422                               GetPString(IDS_ERRORREADEATEXT), pdena->szName);
    1423                   }
    1424                 }
    1425               }
    1426             }
    1427             free(pgealist);
    1428           }
    1429           ulEntry += ulCount;
    1430         } // while
    1431         free(pdena);
    1432         DosPostEventSem(CompactSem);
    1433       }
    1434     }
    1435   }
     1385        while (!DosEnumAttribute(ENUMEA_REFTYPE_PATH,
     1386                                 filename,
     1387                                 ulEntry,
     1388                                 (PVOID)pdena,
     1389                                 (ULONG)65536,
     1390                                 &ulCount,
     1391                                 ENUMEA_LEVEL_NO_VALUE) &&
     1392               ulCount)
     1393        {
     1394          // Got some EAs
     1395          pgealist = xmalloc(64 + pdena->cbName, pszSrcFile, __LINE__);
     1396          if (pgealist) {
     1397            pgealist->cbList = 64 + pdena->cbName;
     1398            pgea = pgealist->list;
     1399            pgea->oNextEntryOffset = 0;
     1400            pgea->cbName = pdena->cbName;
     1401            memcpy(pgea->szName, pdena->szName, pdena->cbName + 1);
     1402            pfealist =
     1403              xmallocz(64 + pdena->cbName + pdena->cbValue, pszSrcFile,
     1404                       __LINE__);
     1405            if (pfealist) {
     1406              pfealist->cbList = 64 + pdena->cbName + pdena->cbValue;
     1407              eaop.fpGEA2List = pgealist;
     1408              eaop.fpFEA2List = pfealist;
     1409              eaop.oError = 0;
     1410              rc = DosQueryPathInfo(filename,
     1411                                    FIL_QUERYEASFROMLIST,
     1412                                    (PVOID)&eaop,
     1413                                    (ULONG)sizeof(EAOP2));
     1414              if (!rc) {
     1415                // Got one
     1416                info = xmalloc(sizeof(HOLDFEA), pszSrcFile, __LINE__);
     1417                if (info) {
     1418                  // 29 Nov 07 GKY One short (EA search crash)
     1419                  info->pfea = xmalloc(eaop.fpFEA2List->cbList - sizeof(ULONG) + 1,
     1420                                       pszSrcFile, __LINE__);
     1421                  memcpy(info->pfea, eaop.fpFEA2List->list,
     1422                         eaop.fpFEA2List->cbList - sizeof(ULONG));
     1423                  info->name = info->pfea->szName;
     1424                  info->cbName = info->pfea->cbName;
     1425                  info->fEA = info->pfea->fEA;  // 2014-02-10 SHL
     1426                  info->cbValue = info->pfea->cbValue;
     1427                  info->value = info->pfea->szName + info->pfea->cbName + 1;
     1428                  info->value[info->cbValue] = 0;
     1429                  info->next = NULL;
     1430                  // Add to list
     1431                  if (!head)
     1432                    head = info;
     1433                  else
     1434                    last->next = info;
     1435                  last = info;
     1436                }
     1437                else
     1438                  free(pfealist);
     1439              }
     1440              else {
     1441                free(pfealist);
     1442                if (!silentfail) {
     1443                  if (rc == ERROR_ACCESS_DENIED
     1444                      || rc == ERROR_SHARING_VIOLATION) {
     1445                    rc =
     1446                      saymsg(MB_ENTER | MB_CANCEL, HWND_DESKTOP,
     1447                             GetPString(IDS_OOPSTEXT),
     1448                             GetPString(IDS_CANTREADEATEXT), filename,
     1449                             pdena->szName);
     1450                    if (rc == MBID_CANCEL) {
     1451                      free(pgealist);
     1452                      break;
     1453                    }
     1454                  }
     1455                  else {
     1456                    Dos_Error(MB_ENTER,
     1457                              rc,
     1458                              HWND_DESKTOP,
     1459                              pszSrcFile,
     1460                              __LINE__,
     1461                              GetPString(IDS_ERRORREADEATEXT), pdena->szName);
     1462                  }
     1463                }
     1464              } // if DosQeryPathInfo
     1465            } // if malloc OK
     1466            free(pgealist);
     1467          } // if malloc OK
     1468          ulEntry += ulCount;
     1469        } // while have EAs
     1470        free(pdena);
     1471        DosPostEventSem(CompactSem);
     1472      } // if malloc OK
     1473    } // if DosQueryPathInfo OK
     1474  } // if need DosQueryPathInfo
    14361475  return head;
    14371476}

  • trunk/dll/fm3res.rc

    r1803 r1804  
    31143114    IDS_ALLTEXTTEXT                       ", all text"
    31153115    IDS_MIXEDTYPESTEXT                    ", mixed types"
    3116     IDS_BINARYBYTESTEXT                   "Binary data (%u bytes)"
     3116    IDS_BINARYBYTESTEXT                   "%sBinary data (%u bytes)"
    31173117    IDS_BITMAPBYTESTEXT                   "Bitmap data (%u bytes)"
    31183118    IDS_METAFILEBYTESTEXT                 "Metafile data (%u bytes)"
Note: See TracChangeset for help on using the changeset viewer.