Changeset 551 for trunk/dll/arccnrs.c


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

Indentation cleanup

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/dll/arccnrs.c

    r531 r551  
    6666#pragma alloc_text(STARTUP,StartArcCnr)
    6767
    68 static MRESULT EXPENTRY ArcErrProc (HWND hwnd,ULONG msg,MPARAM mp1,MPARAM mp2)
     68static MRESULT EXPENTRY ArcErrProc(HWND hwnd, ULONG msg, MPARAM mp1,
     69                                   MPARAM mp2)
    6970{
    7071  ARCDUMP *ad;
    7172
    72   switch (msg)
    73   {
    74     case WM_INITDLG:
    75       if (!mp2)
    76         WinDismissDlg(hwnd,0);
    77       else {
    78         ad = (ARCDUMP *)mp2;
    79         WinSetWindowPtr(hwnd,QWL_USER,ad);
    80         if (ad->errmsg)
    81           WinSetDlgItemText(hwnd,ARCERR_TEXT,ad->errmsg);
    82         if (!ad->info->test)
    83           WinEnableWindow(WinWindowFromID(hwnd,ARCERR_TEST),FALSE);
    84         if (ad->listname) {
    85           MLEsetlimit(WinWindowFromID(hwnd,ARCERR_MLE),-1L);
    86           MLEsetformat(WinWindowFromID(hwnd,ARCERR_MLE),MLFIE_NOTRANS);
    87           MLEsetcurpos(WinWindowFromID(hwnd,ARCERR_MLE),
    88                        MLEgetlen(WinWindowFromID(hwnd,ARCERR_MLE)));
    89           MLEinsert(WinWindowFromID(hwnd,ARCERR_MLE),
    90                     GetPString(IDS_ARCHIVERREPORTTEXT));
    91           MLEinsertfile(WinWindowFromID(hwnd,ARCERR_MLE),ad->listname);
    92         }
    93       }
     73  switch (msg) {
     74  case WM_INITDLG:
     75    if (!mp2)
     76      WinDismissDlg(hwnd, 0);
     77    else {
     78      ad = (ARCDUMP *) mp2;
     79      WinSetWindowPtr(hwnd, QWL_USER, ad);
     80      if (ad->errmsg)
     81        WinSetDlgItemText(hwnd, ARCERR_TEXT, ad->errmsg);
     82      if (!ad->info->test)
     83        WinEnableWindow(WinWindowFromID(hwnd, ARCERR_TEST), FALSE);
     84      if (ad->listname) {
     85        MLEsetlimit(WinWindowFromID(hwnd, ARCERR_MLE), -1L);
     86        MLEsetformat(WinWindowFromID(hwnd, ARCERR_MLE), MLFIE_NOTRANS);
     87        MLEsetcurpos(WinWindowFromID(hwnd, ARCERR_MLE),
     88                     MLEgetlen(WinWindowFromID(hwnd, ARCERR_MLE)));
     89        MLEinsert(WinWindowFromID(hwnd, ARCERR_MLE),
     90                  GetPString(IDS_ARCHIVERREPORTTEXT));
     91        MLEinsertfile(WinWindowFromID(hwnd, ARCERR_MLE), ad->listname);
     92      }
     93    }
     94    break;
     95
     96  case WM_COMMAND:
     97    switch (SHORT1FROMMP(mp1)) {
     98    case DID_CANCEL:
     99      WinDismissDlg(hwnd, 0);
    94100      break;
    95101
    96     case WM_COMMAND:
    97       switch(SHORT1FROMMP(mp1)) {
    98         case DID_CANCEL:
    99           WinDismissDlg(hwnd,0);
    100           break;
    101 
    102         case IDM_HELP:
    103           if (hwndHelp) {
    104             WinSendMsg(hwndHelp,HM_DISPLAY_HELP,
    105                        MPFROM2SHORT(HELP_ARCERR,0),
    106                        MPFROMSHORT(HM_RESOURCEID));
    107           }
    108           break;
    109 
    110         case DID_OK:
    111           ad = WinQueryWindowPtr(hwnd,QWL_USER);
    112           WinDlgBox(HWND_DESKTOP,hwnd,ArcReviewDlgProc,FM3ModHandle,
    113                     AD_FRAME,MPFROMP(ad));
    114           WinDismissDlg(hwnd,0);
    115           break;
    116 
    117         case ARCERR_VIEW:
    118           ad = WinQueryWindowPtr(hwnd,QWL_USER);
    119           {
    120             CHAR *list[2];
    121 
    122             list[0] = ad->arcname;
    123             list[1] = NULL;
    124             if (TestBinary(ad->arcname)) {
    125               if (*binview)
    126                 ExecOnList((HWND)0,binview,WINDOWED | SEPARATE,NULL,list,NULL);
    127               else
    128                 StartMLEEditor(HWND_DESKTOP,16 + 4 + 1,ad->arcname,hwnd);
    129             }
    130             else {
    131               if (*viewer) {
    132                 ExecOnList((HWND)0,viewer,WINDOWED | SEPARATE |
    133                            ((fViewChild) ? CHILD : 0),
    134                            NULL,list,NULL);
    135               }
    136               else
    137                 StartMLEEditor(HWND_DESKTOP,8 + 4 + 1,ad->arcname,hwnd);
    138             }
    139           }
    140           break;
    141 
    142         case ARCERR_TEST:
    143           ad = WinQueryWindowPtr(hwnd,QWL_USER);
    144           runemf2(SEPARATEKEEP | WINDOWED | MAXIMIZED,
    145                   hwnd,NULL,NULL,"%s %s%s%s",ad->info->test,
    146                   ((needs_quoting(ad->arcname)) ? "\"" : NullStr),
    147                   ad->arcname,
    148                   ((needs_quoting(ad->arcname)) ? "\"" : NullStr));
    149           break;
    150       }
    151       return 0;
     102    case IDM_HELP:
     103      if (hwndHelp) {
     104        WinSendMsg(hwndHelp, HM_DISPLAY_HELP,
     105                   MPFROM2SHORT(HELP_ARCERR, 0), MPFROMSHORT(HM_RESOURCEID));
     106      }
     107      break;
     108
     109    case DID_OK:
     110      ad = WinQueryWindowPtr(hwnd, QWL_USER);
     111      WinDlgBox(HWND_DESKTOP, hwnd, ArcReviewDlgProc, FM3ModHandle,
     112                AD_FRAME, MPFROMP(ad));
     113      WinDismissDlg(hwnd, 0);
     114      break;
     115
     116    case ARCERR_VIEW:
     117      ad = WinQueryWindowPtr(hwnd, QWL_USER);
     118      {
     119        CHAR *list[2];
     120
     121        list[0] = ad->arcname;
     122        list[1] = NULL;
     123        if (TestBinary(ad->arcname)) {
     124          if (*binview)
     125            ExecOnList((HWND) 0, binview, WINDOWED | SEPARATE, NULL, list,
     126                       NULL);
     127          else
     128            StartMLEEditor(HWND_DESKTOP, 16 + 4 + 1, ad->arcname, hwnd);
     129        }
     130        else {
     131          if (*viewer) {
     132            ExecOnList((HWND) 0, viewer, WINDOWED | SEPARATE |
     133                       ((fViewChild) ? CHILD : 0), NULL, list, NULL);
     134          }
     135          else
     136            StartMLEEditor(HWND_DESKTOP, 8 + 4 + 1, ad->arcname, hwnd);
     137        }
     138      }
     139      break;
     140
     141    case ARCERR_TEST:
     142      ad = WinQueryWindowPtr(hwnd, QWL_USER);
     143      runemf2(SEPARATEKEEP | WINDOWED | MAXIMIZED,
     144              hwnd, NULL, NULL, "%s %s%s%s", ad->info->test,
     145              ((needs_quoting(ad->arcname)) ? "\"" : NullStr),
     146              ad->arcname, ((needs_quoting(ad->arcname)) ? "\"" : NullStr));
     147      break;
     148    }
     149    return 0;
    152150  }
    153   return WinDefDlgProc(hwnd,msg,mp1,mp2);
     151  return WinDefDlgProc(hwnd, msg, mp1, mp2);
    154152}
    155153
    156 
    157 static SHORT APIENTRY ArcSort (PMINIRECORDCORE pmrc1,PMINIRECORDCORE pmrc2,PVOID pStorage)
     154static SHORT APIENTRY ArcSort(PMINIRECORDCORE pmrc1, PMINIRECORDCORE pmrc2,
     155                              PVOID pStorage)
    158156{
    159   PARCITEM    pai1 = (PARCITEM)pmrc1;
    160   PARCITEM    pai2 = (PARCITEM)pmrc2;
    161   DIRCNRDATA *pdcd = (DIRCNRDATA *)pStorage;
    162   SHORT       ret = 0;
    163   CHAR       *pext,*ppext;
    164   INT        sortFlags;
     157  PARCITEM pai1 = (PARCITEM) pmrc1;
     158  PARCITEM pai2 = (PARCITEM) pmrc2;
     159  DIRCNRDATA *pdcd = (DIRCNRDATA *) pStorage;
     160  SHORT ret = 0;
     161  CHAR *pext, *ppext;
     162  INT sortFlags;
    165163
    166164  if (!pdcd) {
    167165    HWND hwndCnr = pai1->hwndCnr;
    168     pdcd = WinQueryWindowPtr(hwndCnr,QWL_USER);
     166
     167    pdcd = WinQueryWindowPtr(hwndCnr, QWL_USER);
    169168    if (!pdcd) {
    170169      Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
    … …  
    176175
    177176  if (sortFlags) {
    178     switch(sortFlags & (~SORT_REVERSE)) {
    179       case SORT_FIRSTEXTENSION:
    180         pext = strchr(pai1->szFileName,'.');
    181         ppext = strchr(pai2->szFileName,'.');
    182         if (!pext)
    183           pext = NullStr;
    184         if (!ppext)
    185           ppext = NullStr;
    186         ret = stricmp(pext,ppext);
    187         break;
    188 
    189       case SORT_LASTEXTENSION:
    190         pext = strrchr(pai1->szFileName,'.');
    191         ppext = strrchr(pai2->szFileName,'.');
    192         if (!pext)
    193           pext = NullStr;
    194         if (!ppext)
    195           ppext = NullStr;
    196         ret = stricmp(pext,ppext);
    197         break;
    198 
    199       case SORT_LWDATE:
    200         ret = (pai1->date.year < pai2->date.year) ? 1 :
    201               (pai1->date.year > pai2->date.year) ? -1 :
    202               (pai1->date.month < pai2->date.month) ? 1 :
    203               (pai1->date.month > pai2->date.month) ? -1 :
    204               (pai1->date.day < pai2->date.day) ? 1 :
    205               (pai1->date.day > pai2->date.day) ? -1 :
    206               (pai1->time.hours < pai2->time.hours) ? 1 :
    207               (pai1->time.hours > pai2->time.hours) ? -1 :
    208               (pai1->time.minutes < pai2->time.minutes) ? 1 :
    209               (pai1->time.minutes > pai2->time.minutes) ? -1 :
    210               (pai1->time.seconds < pai2->time.seconds) ? 1 :
    211               (pai1->time.seconds > pai2->time.seconds) ? -1 : 0;
    212         break;
    213 
    214       case SORT_SIZE:
    215         ret = (pai1->cbFile < pai2->cbFile) ? 1 : (pai1->cbFile == pai2->cbFile) ?
    216               0 : -1;
    217         if (!ret)
    218           ret = (pai1->cbComp < pai2->cbComp) ? 1 : (pai1->cbComp == pai2->cbComp) ?
    219                 0 : -1;
    220         break;
    221 
    222       case SORT_EASIZE:
    223         ret = (pai1->cbComp < pai2->cbComp) ? 1 : (pai1->cbComp == pai2->cbComp) ?
    224               0 : -1;
    225         if (!ret)
    226           ret = (pai1->cbFile < pai2->cbFile) ? 1 : (pai1->cbFile == pai2->cbFile) ?
    227                 0 : -1;
    228         break;
     177    switch (sortFlags & (~SORT_REVERSE)) {
     178    case SORT_FIRSTEXTENSION:
     179      pext = strchr(pai1->szFileName, '.');
     180      ppext = strchr(pai2->szFileName, '.');
     181      if (!pext)
     182        pext = NullStr;
     183      if (!ppext)
     184        ppext = NullStr;
     185      ret = stricmp(pext, ppext);
     186      break;
     187
     188    case SORT_LASTEXTENSION:
     189      pext = strrchr(pai1->szFileName, '.');
     190      ppext = strrchr(pai2->szFileName, '.');
     191      if (!pext)
     192        pext = NullStr;
     193      if (!ppext)
     194        ppext = NullStr;
     195      ret = stricmp(pext, ppext);
     196      break;
     197
     198    case SORT_LWDATE:
     199      ret = (pai1->date.year < pai2->date.year) ? 1 :
     200        (pai1->date.year > pai2->date.year) ? -1 :
     201        (pai1->date.month < pai2->date.month) ? 1 :
     202        (pai1->date.month > pai2->date.month) ? -1 :
     203        (pai1->date.day < pai2->date.day) ? 1 :
     204        (pai1->date.day > pai2->date.day) ? -1 :
     205        (pai1->time.hours < pai2->time.hours) ? 1 :
     206        (pai1->time.hours > pai2->time.hours) ? -1 :
     207        (pai1->time.minutes < pai2->time.minutes) ? 1 :
     208        (pai1->time.minutes > pai2->time.minutes) ? -1 :
     209        (pai1->time.seconds < pai2->time.seconds) ? 1 :
     210        (pai1->time.seconds > pai2->time.seconds) ? -1 : 0;
     211      break;
     212
     213    case SORT_SIZE:
     214      ret =
     215        (pai1->cbFile < pai2->cbFile) ? 1 : (pai1->cbFile ==
     216                                             pai2->cbFile) ? 0 : -1;
     217      if (!ret)
     218        ret =
     219          (pai1->cbComp < pai2->cbComp) ? 1 : (pai1->cbComp ==
     220                                               pai2->cbComp) ? 0 : -1;
     221      break;
     222
     223    case SORT_EASIZE:
     224      ret =
     225        (pai1->cbComp < pai2->cbComp) ? 1 : (pai1->cbComp ==
     226                                             pai2->cbComp) ? 0 : -1;
     227      if (!ret)
     228        ret =
     229          (pai1->cbFile < pai2->cbFile) ? 1 : (pai1->cbFile ==
     230                                               pai2->cbFile) ? 0 : -1;
     231      break;
    229232    }
    230233    if (!ret)
    231       ret = (SHORT)stricmp(pai1->szFileName,pai2->szFileName);
     234      ret = (SHORT) stricmp(pai1->szFileName, pai2->szFileName);
    232235    if (ret && (sortFlags & SORT_REVERSE))
    233236      ret = (ret > 0) ? -1 : 1;
    234237    return ret;
    235238  }
    236   return (SHORT)stricmp(pai1->szFileName,pai2->szFileName);
     239  return (SHORT) stricmp(pai1->szFileName, pai2->szFileName);
    237240}
    238241
    239 
    240 static INT APIENTRY ArcFilter (PMINIRECORDCORE rmini,PVOID arg)
     242static INT APIENTRY ArcFilter(PMINIRECORDCORE rmini, PVOID arg)
    241243{
    242   DIRCNRDATA   *dcd = (DIRCNRDATA *)arg;
    243   PARCITEM      r;
    244   register INT  x;
    245   INT           ret = FALSE;
     244  DIRCNRDATA *dcd = (DIRCNRDATA *) arg;
     245  PARCITEM r;
     246  register INT x;
     247  INT ret = FALSE;
    246248
    247249  if (dcd && *dcd->mask.szMask) {
    248     r = (PARCITEM)rmini;
     250    r = (PARCITEM) rmini;
    249251    if (dcd->mask.pszMasks[1]) {
    250       for(x = 0;dcd->mask.pszMasks[x];x++) {
    251         if (*dcd->mask.pszMasks[x]) {
    252           if (*dcd->mask.pszMasks[x] != '/') {
    253             if (wildcard(r->szFileName,dcd->mask.pszMasks[x],FALSE))
    254               ret = TRUE;
    255           }
    256           else {
    257             if (wildcard(r->szFileName,dcd->mask.pszMasks[x] + 1,FALSE)) {
    258               ret = FALSE;
    259               break;
    260             }
    261           }
    262         }
     252      for (x = 0; dcd->mask.pszMasks[x]; x++) {
     253        if (*dcd->mask.pszMasks[x]) {
     254          if (*dcd->mask.pszMasks[x] != '/') {
     255            if (wildcard(r->szFileName, dcd->mask.pszMasks[x], FALSE))
     256              ret = TRUE;
     257          }
     258          else {
     259            if (wildcard(r->szFileName, dcd->mask.pszMasks[x] + 1, FALSE)) {
     260              ret = FALSE;
     261              break;
     262            }
     263          }
     264        }
    263265      }
    264266    }
    265267    else {
    266       if (wildcard(r->szFileName,dcd->mask.szMask,FALSE))
    267         ret = TRUE;
     268      if (wildcard(r->szFileName, dcd->mask.szMask, FALSE))
     269        ret = TRUE;
    268270    }
    269271  }
    … …  
    273275}
    274276
    275 
    276 static MRESULT EXPENTRY ArcFrameWndProc (HWND hwnd,ULONG msg,MPARAM mp1,MPARAM mp2)
     277static MRESULT EXPENTRY ArcFrameWndProc(HWND hwnd, ULONG msg, MPARAM mp1,
     278                                        MPARAM mp2)
    277279{
    278   return CommonFrameWndProc(ARC_CNR,hwnd,msg,mp1,mp2);
     280  return CommonFrameWndProc(ARC_CNR, hwnd, msg, mp1, mp2);
    279281}
    280282
    281 
    282 static BOOL IsArcThere (HWND hwnd, CHAR *arcname)
     283static BOOL IsArcThere(HWND hwnd, CHAR * arcname)
    283284{
    284285  if (arcname) {
    285286    if (IsFile(arcname) != 1) {
    286       saymsg(MB_CANCEL,hwnd,
    287              GetPString(IDS_SAYWHATTEXT),
    288              GetPString(IDS_ARCNOTTHERETEXT),
    289              arcname);
     287      saymsg(MB_CANCEL, hwnd,
     288             GetPString(IDS_SAYWHATTEXT),
     289             GetPString(IDS_ARCNOTTHERETEXT), arcname);
    290290      return FALSE;
    291291    }
    … …  
    295295}
    296296
    297 
    298297//== FillArcCnr() generate archive content list and fill container window ==
    299298
    300 static INT FillArcCnr(HWND hwndCnr,CHAR *arcname,ARC_TYPE **arcinfo,
    301                       ULONGLONG *pullTotalBytes, volatile PCHAR pStopFlag)
     299static INT FillArcCnr(HWND hwndCnr, CHAR * arcname, ARC_TYPE ** arcinfo,
     300                      ULONGLONG * pullTotalBytes, volatile PCHAR pStopFlag)
    302301{
    303   FILE         *fp;
    304   HFILE         oldstdout;
    305   HFILE         newstdout;
    306   CHAR          s[CCHMAXPATH * 2],lonename[CCHMAXPATH + 2],
    307                *nsize,*osize,*fdate,*fname,*p,*pp,arctemp[33];
    308   BOOL          gotstart;
    309   BOOL          gotend;
    310   BOOL          wasquote;
    311   BOOL          nomove = FALSE;         // fixme to be gone?
    312   INT           highest = 0,x,counter = 0,numarcfiles = 0;
    313   PARCITEM      lastpai;
    314   ARC_TYPE     *info;
    315   ARC_TYPE     *tinfo;
    316   ULONG         apptype;
    317   APIRET        rc;
     302  FILE *fp;
     303  HFILE oldstdout;
     304  HFILE newstdout;
     305  CHAR s[CCHMAXPATH * 2], lonename[CCHMAXPATH + 2],
     306    *nsize, *osize, *fdate, *fname, *p, *pp, arctemp[33];
     307  BOOL gotstart;
     308  BOOL gotend;
     309  BOOL wasquote;
     310  BOOL nomove = FALSE;          // fixme to be gone?
     311  INT highest = 0, x, counter = 0, numarcfiles = 0;
     312  PARCITEM lastpai;
     313  ARC_TYPE *info;
     314  ARC_TYPE *tinfo;
     315  ULONG apptype;
     316  APIRET rc;
    318317
    319318  if (!arcname || !arcinfo)
    … …  
    322321  info = *arcinfo;
    323322  if (!info)
    324     info = find_type(arcname,NULL);
    325   for(x = 0;x < 99;x++) {
    326     sprintf(arctemp,"%s.%03x",ArcTempRoot,(clock() & 4095L));
     323    info = find_type(arcname, NULL);
     324  for (x = 0; x < 99; x++) {
     325    sprintf(arctemp, "%s.%03x", ArcTempRoot, (clock() & 4095L));
    327326    if (IsFile(arctemp) == 1)
    328327      DosSleep(rand() % 100);
    … …  
    335334#ifdef DEBUG
    336335  if (info && info->id)
    337     WinSetWindowText(WinQueryWindow(WinQueryWindow(hwndCnr,QW_PARENT),QW_PARENT),info->id);
     336    WinSetWindowText(WinQueryWindow
     337                     (WinQueryWindow(hwndCnr, QW_PARENT), QW_PARENT),
     338                     info->id);
    338339#endif
    339340
    … …  
    347348  else {
    348349    WinSendMsg(hwndCnr,
    349                CM_REMOVERECORD,
    350                MPVOID,
    351                MPFROM2SHORT(0,CMA_FREE | CMA_INVALIDATE | CMA_ERASE));
     350               CM_REMOVERECORD,
     351               MPVOID,
     352               MPFROM2SHORT(0, CMA_FREE | CMA_INVALIDATE | CMA_ERASE));
    352353    *arcinfo = info;
    353354    highest = info->osizepos;
    … …  
    359360      highest = info->fnpos;
    360361    if (highest > 50) {
    361       saymsg(MB_ENTER | MB_ICONEXCLAMATION,HWND_DESKTOP,
    362              GetPString(IDS_SHAMETEXT),
    363              "%s",
    364              GetPString(IDS_BUNGEDUPTEXT));
     362      saymsg(MB_ENTER | MB_ICONEXCLAMATION, HWND_DESKTOP,
     363             GetPString(IDS_SHAMETEXT), "%s", GetPString(IDS_BUNGEDUPTEXT));
    365364    }
    366365    if (info->fnpos == -1)
    … …  
    371370    DosError(FERR_DISABLEHARDERR);
    372371
    373     strcpy(s,info->list);
    374     p = strchr(s,' ');
     372    strcpy(s, info->list);
     373    p = strchr(s, ' ');
    375374    if (p)
    376375      *p = 0;
    377376    DosError(FERR_DISABLEHARDERR);
    378     if (!DosQAppType(s,&apptype) &&
    379         ((apptype & FAPPTYP_DOS) ||
    380          (apptype & FAPPTYP_WINDOWSREAL) ||
    381          (apptype & FAPPTYP_WINDOWSPROT) ||
    382          (apptype & 0x1000))) {
     377    if (!DosQAppType(s, &apptype) &&
     378        ((apptype & FAPPTYP_DOS) ||
     379         (apptype & FAPPTYP_WINDOWSREAL) ||
     380         (apptype & FAPPTYP_WINDOWSPROT) || (apptype & 0x1000))) {
    383381      p = GetCmdSpec(TRUE);
    384382      runemf2(SEPARATE | INVISIBLE | MINIMIZED | BACKGROUND | WAIT,
    385               hwndCnr,
    386               NULL,
    387               "DOS_BACKGROUND_EXECUTION=1",
    388               "%s /C %s %s%s%s > %s",
    389               p,
    390               info->list,
    391               (needs_quoting(arcname)) ? "\"" : NullStr,
    392               arcname,
    393               (needs_quoting(arcname)) ? "\"" : NullStr,
    394               arctemp);
     383              hwndCnr,
     384              NULL,
     385              "DOS_BACKGROUND_EXECUTION=1",
     386              "%s /C %s %s%s%s > %s",
     387              p,
     388              info->list,
     389              (needs_quoting(arcname)) ? "\"" : NullStr,
     390              arcname, (needs_quoting(arcname)) ? "\"" : NullStr, arctemp);
    395391    }
    396392    else {
    397       fp = xfopen(arctemp,"w",pszSrcFile,__LINE__);
     393      fp = xfopen(arctemp, "w", pszSrcFile, __LINE__);
    398394      if (!fp)
    399         return 0;
     395        return 0;
    400396      else {
    401         newstdout = -1;
    402         DosError(FERR_DISABLEHARDERR);
    403         rc = DosDupHandle(fileno(stdout),&newstdout);
    404         if (rc) {
    405           Dos_Error(MB_CANCEL,rc,hwndCnr,pszSrcFile,__LINE__,"DosDupHandle");
    406           return 0;
     397        newstdout = -1;
     398        DosError(FERR_DISABLEHARDERR);
     399        rc = DosDupHandle(fileno(stdout), &newstdout);
     400        if (rc) {
     401          Dos_Error(MB_CANCEL, rc, hwndCnr, pszSrcFile, __LINE__,
     402                    "DosDupHandle");
     403          return 0;
    407404        }
    408405        else {
    409           oldstdout = fileno(stdout);
    410           DosError(FERR_DISABLEHARDERR);
    411           rc = DosDupHandle(fileno(fp),&oldstdout);
    412           if (rc)
    413           {
    414             Dos_Error(MB_CANCEL,rc,hwndCnr,pszSrcFile,__LINE__,"DosDupHandle");
    415             return 0;
     406          oldstdout = fileno(stdout);
     407          DosError(FERR_DISABLEHARDERR);
     408          rc = DosDupHandle(fileno(fp), &oldstdout);
     409          if (rc) {
     410            Dos_Error(MB_CANCEL, rc, hwndCnr, pszSrcFile, __LINE__,
     411                      "DosDupHandle");
     412            return 0;
    416413          }
    417414          else {
    418             runemf2(SEPARATE | INVISIBLE | FULLSCREEN | BACKGROUND | WAIT,
    419                     hwndCnr,NULL,NULL,"%s %s%s%s",info->list,
    420                     (needs_quoting(arcname)) ? "\"" : NullStr,arcname,
    421                     (needs_quoting(arcname)) ? "\"" : NullStr);
    422             oldstdout = fileno(stdout);
    423             DosError(FERR_DISABLEHARDERR);
    424             DosDupHandle(newstdout,&oldstdout);
    425             DosClose(newstdout);
    426             fclose(fp);
    427           }
    428         }
     415            runemf2(SEPARATE | INVISIBLE | FULLSCREEN | BACKGROUND | WAIT,
     416                    hwndCnr, NULL, NULL, "%s %s%s%s", info->list,
     417                    (needs_quoting(arcname)) ? "\"" : NullStr, arcname,
     418                    (needs_quoting(arcname)) ? "\"" : NullStr);
     419            oldstdout = fileno(stdout);
     420            DosError(FERR_DISABLEHARDERR);
     421            DosDupHandle(newstdout, &oldstdout);
     422            DosClose(newstdout);
     423            fclose(fp);
     424          }
     425        }
    429426      }
    430427    }
    431428
    432429    DosError(FERR_DISABLEHARDERR);
    433     fp = _fsopen(arctemp,"r",SH_DENYWR);
     430    fp = _fsopen(arctemp, "r", SH_DENYWR);
    434431
    435432    if (fp) {
    436433      gotstart = !info->startlist || !*info->startlist; // If list has no start marker
    437434
    438       while(!feof(fp) && !gotend && !*pStopFlag) {
    439         if (!xfgets_bstripcr(s,sizeof(s),fp,pszSrcFile,__LINE__))
    440           break;
    441         if (!gotstart) {
    442           if (!strcmp(s,info->startlist))
    443             gotstart = TRUE;
    444         }
    445         else if (info->endlist &&
    446                  !strcmp(s,info->endlist))
    447           gotend = TRUE;
    448         else {
     435      while (!feof(fp) && !gotend && !*pStopFlag) {
     436        if (!xfgets_bstripcr(s, sizeof(s), fp, pszSrcFile, __LINE__))
     437          break;
     438        if (!gotstart) {
     439          if (!strcmp(s, info->startlist))
     440            gotstart = TRUE;
     441        }
     442        else if (info->endlist && !strcmp(s, info->endlist))
     443          gotend = TRUE;
     444        else {
    449445          /* add to container */
    450           fname = NULL;
    451           bstrip(s);
    452           if (info->nameisfirst) {
    453             strncpy(lonename,s,CCHMAXPATH + 2);
    454             lonename[CCHMAXPATH + 1] = 0;
    455             fname = lonename;
    456             if (!xfgets_bstripcr(s,sizeof(s),fp,pszSrcFile,__LINE__))
    457               break;
    458             if (*fname == '\"') {
    459               memmove(fname,fname + 1,strlen(fname) + 1);
    460               p = strchr(fname,'\"');
    461               if (p)
    462                 *p = 0;
    463             }
    464           }
    465           nsize = NULL;
    466           osize = fdate = NullStr;
    467           p = s;
    468           for(x = 0;x <= highest;x++) {
    469             pp = p;
    470             while(*pp && (*pp == ' ' || *pp == '\t')) /* skip leading */
    471               pp++;
    472             if (!*pp)
    473               break;
    474             wasquote = FALSE;
    475             p = pp;
    476             while(*p && (wasquote ||
    477                          ((x != info->fnpos || !info->nameislast) ?
    478                           (*p != ' ' && *p != '\t') : TRUE))) {
    479               if (*p == '\"') {
    480                 if (!wasquote) {
    481                   wasquote = TRUE;
    482                   memmove(p,p + 1,strlen(p));
    483                   while(*p == ' ' || *p == '\t')
    484                    p++;
    485                 }
    486                 else {
    487                   memmove(p,p + 1,strlen(p));
    488                   break;
    489                 }
    490               }
    491               else if (*p)
    492                 p++;
    493             }
    494             if (*p) {
    495               *p = 0;
    496               p++;
    497             }
    498             if (x == info->nsizepos)
    499               nsize = pp;
    500             else if (x == info->osizepos)
    501               osize = pp;
    502             else if (x == info->fdpos) {
    503               fdate = pp;
    504               if (info->fdflds > 1 &&
    505                   info->fdflds < 24) {
    506                 INT y;
    507 
    508                 if (*p) {
    509                   p--;
    510                   *p = ' ';
    511                   for(y = 0;y < info->fdflds - 1;y++) {
    512                     while(*p && (*p == ' ' || *p == '\t'))
    513                       p++;
    514                     while(*p && (*p != ' ' && *p != '\t'))
    515                       p++;
    516                     x++;
    517                   }
    518                   if (*p) {
    519                     *p = 0;
    520                     p++;
    521                   }
    522                 }
    523               }
    524             }
    525             else if (x == info->fnpos) {
    526               fname = pp;
    527               if (pp && *pp == '*' && !*(pp + 1))  /* workaround for LH.EXE */
    528                 fname = NULL;
    529               if (info->nameislast)
    530                 break;
    531             }
    532             else if ((!p || !*p) && info->fnpos == -1) {
    533               fname = pp;
    534               break;
    535             }
    536           }
    537           if (info->nameisnext) {
    538             if (!xfgets_bstripcr(lonename,sizeof(lonename),fp,pszSrcFile,__LINE__))
    539               break;
    540             fname = lonename;
    541           }
     446          fname = NULL;
     447          bstrip(s);
     448          if (info->nameisfirst) {
     449            strncpy(lonename, s, CCHMAXPATH + 2);
     450            lonename[CCHMAXPATH + 1] = 0;
     451            fname = lonename;
     452            if (!xfgets_bstripcr(s, sizeof(s), fp, pszSrcFile, __LINE__))
     453              break;
     454            if (*fname == '\"') {
     455              memmove(fname, fname + 1, strlen(fname) + 1);
     456              p = strchr(fname, '\"');
     457              if (p)
     458                *p = 0;
     459            }
     460          }
     461          nsize = NULL;
     462          osize = fdate = NullStr;
     463          p = s;
     464          for (x = 0; x <= highest; x++) {
     465            pp = p;
     466            while (*pp && (*pp == ' ' || *pp == '\t'))  /* skip leading */
     467              pp++;
     468            if (!*pp)
     469              break;
     470            wasquote = FALSE;
     471            p = pp;
     472            while (*p && (wasquote ||
     473                          ((x != info->fnpos || !info->nameislast) ?
     474                           (*p != ' ' && *p != '\t') : TRUE))) {
     475              if (*p == '\"') {
     476                if (!wasquote) {
     477                  wasquote = TRUE;
     478                  memmove(p, p + 1, strlen(p));
     479                  while (*p == ' ' || *p == '\t')
     480                    p++;
     481                }
     482                else {
     483                  memmove(p, p + 1, strlen(p));
     484                  break;
     485                }
     486              }
     487              else if (*p)
     488                p++;
     489            }
     490            if (*p) {
     491              *p = 0;
     492              p++;
     493            }
     494            if (x == info->nsizepos)
     495              nsize = pp;
     496            else if (x == info->osizepos)
     497              osize = pp;
     498            else if (x == info->fdpos) {
     499              fdate = pp;
     500              if (info->fdflds > 1 && info->fdflds < 24) {
     501                INT y;
     502
     503                if (*p) {
     504                  p--;
     505                  *p = ' ';
     506                  for (y = 0; y < info->fdflds - 1; y++) {
     507                    while (*p && (*p == ' ' || *p == '\t'))
     508                      p++;
     509                    while (*p && (*p != ' ' && *p != '\t'))
     510                      p++;
     511                    x++;
     512                  }
     513                  if (*p) {
     514                    *p = 0;
     515                    p++;
     516                  }
     517                }
     518              }
     519            }
     520            else if (x == info->fnpos) {
     521              fname = pp;
     522              if (pp && *pp == '*' && !*(pp + 1))       /* workaround for LH.EXE */
     523                fname = NULL;
     524              if (info->nameislast)
     525                break;
     526            }
     527            else if ((!p || !*p) && info->fnpos == -1) {
     528              fname = pp;
     529              break;
     530            }
     531          }
     532          if (info->nameisnext) {
     533            if (!xfgets_bstripcr
     534                (lonename, sizeof(lonename), fp, pszSrcFile, __LINE__))
     535              break;
     536            fname = lonename;
     537          }
    542538          // fixme to complain?
    543           if (fname && *fname) {
    544 
    545             RECORDINSERT ri;
    546             PARCITEM    pai;
     539          if (fname && *fname) {
     540
     541            RECORDINSERT ri;
     542            PARCITEM pai;
    547543
    548544#ifdef DEBUG
    549             saymsg(MB_ENTER,hwndCnr,DEBUG_STRING,
    550                    "fname: %s\r\rpp: %s\r\rp: %s\r\rlonename: %s\r\rhighest: %ld\r\rx: %ld\r\rfdate: %s",
    551                    (fname) ? fname : "NULL",
    552                    (pp) ? pp : "NULL",
    553                    (p) ? p : "NULL",
    554                    lonename,
    555                    highest,
    556                    x,
    557                    (fdate) ? fdate : "NULL");
     545            saymsg(MB_ENTER, hwndCnr, DEBUG_STRING,
     546                   "fname: %s\r\rpp: %s\r\rp: %s\r\rlonename: %s\r\rhighest: %ld\r\rx: %ld\r\rfdate: %s",
     547                   (fname) ? fname : "NULL",
     548                   (pp) ? pp : "NULL",
     549                   (p) ? p : "NULL",
     550                   lonename, highest, x, (fdate) ? fdate : "NULL");
    558551#endif
    559552
    560             pai = WinSendMsg(hwndCnr,
    561                              CM_ALLOCRECORD,
    562                              MPFROMLONG(EXTRA_ARCRECORD_BYTES),
    563                              MPFROMLONG(1L));
    564             if (!pai) {
     553            pai = WinSendMsg(hwndCnr,
     554                             CM_ALLOCRECORD,
     555                             MPFROMLONG(EXTRA_ARCRECORD_BYTES),
     556                             MPFROMLONG(1L));
     557            if (!pai) {
    565558              Runtime_Error(pszSrcFile, __LINE__, "CM_ALLOCRECORD");
    566559              break;
    567560            }
    568561            else {
    569               memset(pai,0,sizeof(ARCITEM));
    570               pai->hwndCnr = hwndCnr;
    571               if (*fname == '*') {
    572                 fname++;
    573                 pai->flags = ARCFLAGS_REALDIR;
    574               }
    575               if (fname[strlen(fname) - 1] == '\\' ||
    576                  fname[strlen(fname) - 1] == '/')
    577                 pai->flags = ARCFLAGS_REALDIR;
    578               strcpy(pai->szFileName,fname);
    579               if (fdate)
    580                 strcpy(pai->szDate,fdate);
    581               pai->pszFileName = pai->szFileName;
    582               pai->rc.pszIcon = pai->pszFileName;
    583               pai->rc.hptrIcon = ((pai->flags & ARCFLAGS_REALDIR) != 0) ?
    584                                   hptrDir :
    585                                   hptrFile;
    586               pai->pszDate = pai->szDate;
    587               if (osize)
    588                 pai->cbFile = atol(osize);
    589               if (nsize)
    590                 pai->cbComp = atol(nsize);
    591               if (info->datetype && fdate && *fdate)
    592                 ArcDateTime(fdate,
    593                             info->datetype,
    594                             &pai->date,
    595                             &pai->time);
    596               memset(&ri,0,sizeof(RECORDINSERT));
    597               ri.cb                 = sizeof(RECORDINSERT);
    598               ri.pRecordOrder       = (PRECORDCORE) CMA_END;
    599               ri.pRecordParent      = (PRECORDCORE)NULL;
    600               ri.zOrder             = (USHORT)CMA_TOP;
    601               ri.cRecordsInsert     = 1L;
    602               ri.fInvalidateRecord  = FALSE;
    603               if (WinSendMsg(hwndCnr,
    604                             CM_INSERTRECORD,
    605                             MPFROMP(pai),
    606                             MPFROMP(&ri)))
    607               {
    608                 *pullTotalBytes += pai->cbFile;
     562              memset(pai, 0, sizeof(ARCITEM));
     563              pai->hwndCnr = hwndCnr;
     564              if (*fname == '*') {
     565                fname++;
     566                pai->flags = ARCFLAGS_REALDIR;
    609567              }
    610               numarcfiles++;
    611               if  (!(++counter % 50)) {
    612                 if (!lastpai)
    613                   lastpai = pai;
    614                 WinSendMsg(hwndCnr,
    615                            CM_INVALIDATERECORD,
    616                            lastpai,
    617                            MPFROM2SHORT(10,CMA_ERASE | CMA_REPOSITION));
    618                 lastpai = pai;
    619               }
     568              if (fname[strlen(fname) - 1] == '\\' ||
     569                  fname[strlen(fname) - 1] == '/')
     570                pai->flags = ARCFLAGS_REALDIR;
     571              strcpy(pai->szFileName, fname);
     572              if (fdate)
     573                strcpy(pai->szDate, fdate);
     574              pai->pszFileName = pai->szFileName;
     575              pai->rc.pszIcon = pai->pszFileName;
     576              pai->rc.hptrIcon = ((pai->flags & ARCFLAGS_REALDIR) != 0) ?
     577                hptrDir : hptrFile;
     578              pai->pszDate = pai->szDate;
     579              if (osize)
     580                pai->cbFile = atol(osize);
     581              if (nsize)
     582                pai->cbComp = atol(nsize);
     583              if (info->datetype && fdate && *fdate)
     584                ArcDateTime(fdate, info->datetype, &pai->date, &pai->time);
     585              memset(&ri, 0, sizeof(RECORDINSERT));
     586              ri.cb = sizeof(RECORDINSERT);
     587              ri.pRecordOrder = (PRECORDCORE) CMA_END;
     588              ri.pRecordParent = (PRECORDCORE) NULL;
     589              ri.zOrder = (USHORT) CMA_TOP;
     590              ri.cRecordsInsert = 1L;
     591              ri.fInvalidateRecord = FALSE;
     592              if (WinSendMsg(hwndCnr,
     593                             CM_INSERTRECORD, MPFROMP(pai), MPFROMP(&ri))) {
     594                *pullTotalBytes += pai->cbFile;
     595              }
     596              numarcfiles++;
     597              if (!(++counter % 50)) {
     598                if (!lastpai)
     599                  lastpai = pai;
     600                WinSendMsg(hwndCnr,
     601                           CM_INVALIDATERECORD,
     602                           lastpai,
     603                           MPFROM2SHORT(10, CMA_ERASE | CMA_REPOSITION));
     604                lastpai = pai;
     605              }
    620606              // Avoid hogging system for large archive
    621607              if (numarcfiles == 100)
    622                 priority_idle();
    623             }
    624           }
    625         }
    626       } // while !eof
     608                priority_idle();
     609            }
     610          }
     611        }
     612      }                                 // while !eof
    627613
    628614      fclose(fp);
    629615
    630616      if (*pStopFlag)
    631         numarcfiles = 0;                // Request close
    632       else if (!numarcfiles || !gotstart || (!gotend && info->endlist && *info->endlist))
    633       {
     617        numarcfiles = 0;                // Request close
     618      else if (!numarcfiles || !gotstart
     619               || (!gotend && info->endlist && *info->endlist)) {
    634620        // Oops
    635         ARCDUMP ad;
    636         CHAR errstr[CCHMAXPATH + 256];
     621        ARCDUMP ad;
     622        CHAR errstr[CCHMAXPATH + 256];
    637623
    638624        // Try for alternate archiver
    639         tinfo = info;
    640         do {
    641           tinfo = tinfo->next;
    642           if (tinfo)
    643             tinfo = find_type(arcname,tinfo);
    644           if (tinfo) {
    645             DosError(FERR_DISABLEHARDERR);
    646             DosForceDelete(arctemp);
    647             info = tinfo;
    648             goto ReTry;
    649           }
    650         } while(tinfo);
    651         DosBeep(750,50);                // wake up user
    652         sprintf(errstr,GetPString(IDS_ARCERRORINFOTEXT),
    653                 arcname,
    654                 (!gotstart) ? GetPString(IDS_NOGOTSTARTTEXT) : NullStr,
    655                 (!numarcfiles) ? GetPString(IDS_NOARCFILESFOUNDTEXT) : NullStr,
    656                 (!gotend) ? GetPString(IDS_NOENDOFLISTTEXT) : NullStr);
    657         memset(&ad,0,sizeof(ARCDUMP));
    658         ad.info = info;
    659         strcpy(ad.listname,arctemp);
    660         strcpy(ad.arcname,arcname);
    661         ad.errmsg = errstr;
    662         WinDlgBox(HWND_DESKTOP,
    663                   hwndCnr,
    664                   ArcErrProc,
    665                   FM3ModHandle,
    666                   ARCERR_FRAME,
    667                   MPFROMP(&ad));
     625        tinfo = info;
     626        do {
     627          tinfo = tinfo->next;
     628          if (tinfo)
     629            tinfo = find_type(arcname, tinfo);
     630          if (tinfo) {
     631            DosError(FERR_DISABLEHARDERR);
     632            DosForceDelete(arctemp);
     633            info = tinfo;
     634            goto ReTry;
     635          }
     636        } while (tinfo);
     637        DosBeep(750, 50);               // wake up user
     638        sprintf(errstr, GetPString(IDS_ARCERRORINFOTEXT),
     639                arcname,
     640                (!gotstart) ? GetPString(IDS_NOGOTSTARTTEXT) : NullStr,
     641                (!numarcfiles) ? GetPString(IDS_NOARCFILESFOUNDTEXT) :
     642                NullStr,
     643                (!gotend) ? GetPString(IDS_NOENDOFLISTTEXT) : NullStr);
     644        memset(&ad, 0, sizeof(ARCDUMP));
     645        ad.info = info;
     646        strcpy(ad.listname, arctemp);
     647        strcpy(ad.arcname, arcname);
     648        ad.errmsg = errstr;
     649        WinDlgBox(HWND_DESKTOP,
     650                  hwndCnr,
     651                  ArcErrProc, FM3ModHandle, ARCERR_FRAME, MPFROMP(&ad));
    668652      }
    669653      else if (!nomove && tinfo) {
    670654        /* if we got a false hit, move working hit to top */
    671         tinfo = info->next;
    672         info->next = arcsighead;
    673         arcsighead->prev = info;
    674         if (tinfo)
    675           tinfo->next->prev = info->prev;
    676         info->prev->next = tinfo;
    677         info->prev = NULL;
    678         arcsighead = info;
    679         rewrite_archiverbb2(NULL);      // Rewrite with warning
    680       }
    681     } // if opened
     655        tinfo = info->next;
     656        info->next = arcsighead;
     657        arcsighead->prev = info;
     658        if (tinfo)
     659          tinfo->next->prev = info->prev;
     660        info->prev->next = tinfo;
     661        info->prev = NULL;
     662        arcsighead = info;
     663        rewrite_archiverbb2(NULL);      // Rewrite with warning
     664      }
     665    }                                   // if opened
    682666
    683667    DosError(FERR_DISABLEHARDERR);
    … …  
    691675}
    692676
    693 
    694 MRESULT EXPENTRY ArcTextProc (HWND hwnd,ULONG msg,MPARAM mp1,MPARAM mp2)
     677MRESULT EXPENTRY ArcTextProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
    695678{
    696   static BOOL   emphasized      = FALSE;
    697   static HWND   hwndButtonPopup = (HWND)0;
    698   static ULONG  timestamp       = ULONG_MAX;
    699   static USHORT lastid          = 0;
    700 
    701   switch(msg) {
    702     case WM_CREATE:
    703       return CommonTextProc(hwnd,msg,mp1,mp2);
    704 
    705     case WM_COMMAND:
    706       return WinSendMsg(WinWindowFromID(WinQueryWindow(hwnd,QW_PARENT),
    707                                         ARC_CNR),
    708                         msg,
    709                         mp1,
    710                         mp2);
    711 
    712     case UM_CONTEXTMENU:
    713     case WM_CONTEXTMENU:
     679  static BOOL emphasized = FALSE;
     680  static HWND hwndButtonPopup = (HWND) 0;
     681  static ULONG timestamp = ULONG_MAX;
     682  static USHORT lastid = 0;
     683
     684  switch (msg) {
     685  case WM_CREATE:
     686    return CommonTextProc(hwnd, msg, mp1, mp2);
     687
     688  case WM_COMMAND:
     689    return WinSendMsg(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
     690                                      ARC_CNR), msg, mp1, mp2);
     691
     692  case UM_CONTEXTMENU:
     693  case WM_CONTEXTMENU:
     694    {
     695      USHORT id;
     696
     697      id = WinQueryWindowUShort(hwnd, QWS_ID);
     698      switch (id) {
     699      case DIR_SELECTED:
     700      case DIR_VIEW:
     701      case DIR_SORT:
     702        {
     703          POINTL ptl = { 0, 0 };
     704          SWP swp;
     705          DIRCNRDATA *dcd;
     706
     707          if (hwndButtonPopup)
     708            WinDestroyWindow(hwndButtonPopup);
     709          if (id == DIR_SELECTED)
     710            id = DIR_RESTORE;
     711          if (id == lastid) {
     712
     713            ULONG check;
     714
     715            DosQuerySysInfo(QSV_MS_COUNT, QSV_MS_COUNT, &check,
     716                            sizeof(check));
     717            if (check < timestamp + 500) {
     718              lastid = 0;
     719              goto MenuAbort;
     720            }
     721          }
     722          hwndButtonPopup = WinLoadMenu(HWND_DESKTOP, FM3ModHandle, id);
     723          if (hwndButtonPopup) {
     724            WinSetWindowUShort(hwndButtonPopup, QWS_ID, id);
     725            dcd = WinQueryWindowPtr(WinWindowFromID(WinQueryWindow(hwnd,
     726                                                                   QW_PARENT),
     727                                                    ARC_CNR), QWL_USER);
     728            if (id == DIR_SORT) {
     729              if (dcd)
     730                SetSortChecks(hwndButtonPopup, dcd->sortFlags);
     731              WinSendMsg(hwndButtonPopup,
     732                         MM_DELETEITEM,
     733                         MPFROM2SHORT(IDM_SORTNONE, FALSE), MPVOID);
     734              WinSendMsg(hwndButtonPopup,
     735                         MM_DELETEITEM,
     736                         MPFROM2SHORT(IDM_SORTNAME, FALSE), MPVOID);
     737              WinSendMsg(hwndButtonPopup,
     738                         MM_DELETEITEM,
     739                         MPFROM2SHORT(IDM_SORTLADATE, FALSE), MPVOID);
     740              WinSendMsg(hwndButtonPopup,
     741                         MM_DELETEITEM,
     742                         MPFROM2SHORT(IDM_SORTCRDATE, FALSE), MPVOID);
     743              WinSendMsg(hwndButtonPopup,
     744                         MM_DELETEITEM,
     745                         MPFROM2SHORT(IDM_SORTDIRSFIRST, FALSE), MPVOID);
     746              WinSendMsg(hwndButtonPopup,
     747                         MM_DELETEITEM,
     748                         MPFROM2SHORT(IDM_SORTDIRSLAST, FALSE), MPVOID);
     749              WinSendMsg(hwndButtonPopup,
     750                         MM_DELETEITEM,
     751                         MPFROM2SHORT(IDM_SORTSUBJECT, FALSE), MPVOID);
     752              WinSendMsg(hwndButtonPopup,
     753                         MM_SETITEMTEXT,
     754                         MPFROM2SHORT(IDM_SORTEASIZE, 0),
     755                         MPFROMP(GetPString(IDS_COMPRESSEDSIZEMENUTEXT)));
     756              WinSendMsg(hwndButtonPopup,
     757                         MM_SETITEMTEXT,
     758                         MPFROM2SHORT(IDM_SORTLWDATE, 0),
     759                         MPFROMP(GetPString(IDS_DATEMENUTEXT)));
     760            }
     761            ptl.x = 0;
     762            if (WinPopupMenu(HWND_OBJECT,
     763                             HWND_OBJECT,
     764                             hwndButtonPopup, -32767, -32767, 0, 0)) {
     765              WinQueryWindowPos(hwndButtonPopup, &swp);
     766              ptl.y = -(swp.cy + 2);
     767            }
     768            else {
     769              WinQueryWindowPos(hwnd, &swp);
     770              ptl.y = swp.cy + 2;
     771            }
     772            if (WinPopupMenu(hwnd,
     773                             hwnd,
     774                             hwndButtonPopup,
     775                             ptl.x,
     776                             ptl.y,
     777                             0,
     778                             PU_HCONSTRAIN | PU_VCONSTRAIN |
     779                             PU_KEYBOARD | PU_MOUSEBUTTON1)) {
     780              CenterOverWindow(hwndButtonPopup);
     781              PaintRecessedWindow(hwnd, (HPS) 0, FALSE, FALSE);
     782            }
     783          }
     784        }
     785        break;
     786      default:
     787        PostMsg(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
     788                                ARC_CNR),
     789                WM_CONTROL, MPFROM2SHORT(ARC_CNR, CN_CONTEXTMENU), MPVOID);
     790        break;
     791      }
     792    }
     793  MenuAbort:
     794    if (msg == UM_CONTEXTMENU)
     795      return 0;
     796    break;
     797
     798  case WM_MENUEND:
     799    if (hwndButtonPopup == (HWND) mp2) {
     800      lastid = WinQueryWindowUShort((HWND) mp2, QWS_ID);
     801      WinDestroyWindow(hwndButtonPopup);
     802      hwndButtonPopup = (HWND) 0;
     803      DosQuerySysInfo(QSV_MS_COUNT, QSV_MS_COUNT, &timestamp,
     804                      sizeof(timestamp));
     805      switch (lastid) {
     806      case DIR_VIEW:
     807      case DIR_SORT:
     808      case DIR_RESTORE:
     809      case DIR_SELECTED:
     810        PaintRecessedWindow(hwnd, (HPS) 0, TRUE, FALSE);
     811        break;
     812      }
     813    }
     814    break;
     815
     816  case WM_MOUSEMOVE:
     817    {
     818      USHORT id = WinQueryWindowUShort(hwnd, QWS_ID);
     819      char *s = NULL;
     820
     821      if (fOtherHelp) {
     822        if ((!hwndBubble ||
     823             WinQueryWindowULong(hwndBubble, QWL_USER) != hwnd) &&
     824            !WinQueryCapture(HWND_DESKTOP)) {
     825          switch (id) {
     826          case DIR_TOTALS:
     827            s = GetPString(IDS_ARCCNRTOTALSHELPTEXT);
     828            break;
     829          case DIR_SELECTED:
     830            s = GetPString(IDS_ARCCNRSELECTEDHELPTEXT);
     831            break;
     832          case DIR_VIEW:
     833            s = GetPString(IDS_ARCCNRVIEWHELPTEXT);
     834            break;
     835          case DIR_SORT:
     836            s = GetPString(IDS_DIRCNRSORTHELP);
     837            break;
     838          case DIR_FILTER:
     839            s = GetPString(IDS_DIRCNRFILTERHELP);
     840            break;
     841          case DIR_FOLDERICON:
     842            s = GetPString(IDS_ARCCNRFOLDERHELPTEXT);
     843            break;
     844          default:
     845            break;
     846          }
     847          if (s)
     848            MakeBubble(hwnd, TRUE, s);
     849          else if (hwndBubble)
     850            WinDestroyWindow(hwndBubble);
     851        }
     852      }
     853      switch (id) {
     854      case DIR_FILTER:
     855      case DIR_SORT:
     856      case DIR_VIEW:
     857      case DIR_SELECTED:
     858      case DIR_FOLDERICON:
     859        return CommonTextButton(hwnd, msg, mp1, mp2);
     860      }
     861    }
     862    break;
     863
     864  case WM_BUTTON3UP:
     865  case WM_BUTTON1UP:
     866  case WM_BUTTON1DOWN:
     867  case WM_BUTTON3DOWN:
     868    {
     869      USHORT id;
     870
     871      id = WinQueryWindowUShort(hwnd, QWS_ID);
     872      switch (id) {
     873      case DIR_FILTER:
     874      case DIR_SORT:
     875      case DIR_VIEW:
     876      case DIR_SELECTED:
     877      case DIR_FOLDERICON:
     878        return CommonTextButton(hwnd, msg, mp1, mp2);
     879      }
     880    }
     881    break;
     882
     883  case UM_CLICKED:
     884  case UM_CLICKED3:
     885    {
     886      USHORT id, cmd = 0;
     887
     888      id = WinQueryWindowUShort(hwnd, QWS_ID);
     889      switch (id) {
     890      case DIR_FOLDERICON:
     891        switch (msg) {
     892        case WM_BUTTON3CLICK:
     893        case WM_CHORD:
     894          cmd = IDM_RESCAN;
     895          break;
     896        default:
     897          if ((SHORT2FROMMP(mp2) & KC_ALT) != 0)
     898            cmd = IDM_WINDOWDLG;
     899          else
     900            cmd = IDM_WALKDIR;
     901          break;
     902        }
     903        break;
     904      case DIR_VIEW:
     905      case DIR_SORT:
     906      case DIR_SELECTED:
     907        PostMsg(hwnd, UM_CONTEXTMENU, MPVOID, MPVOID);
     908        break;
     909      case DIR_FILTER:
     910        cmd = IDM_FILTER;
     911        break;
     912      default:
     913        break;
     914      }
     915      if (cmd)
     916        PostMsg(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
     917                                ARC_CNR),
     918                WM_COMMAND, MPFROM2SHORT(cmd, 0), MPVOID);
     919    }
     920    return 0;
     921
     922  case WM_BEGINDRAG:
     923  case DM_DROP:
     924  case DM_DRAGOVER:
     925  case DM_DRAGLEAVE:
     926  case DM_DROPHELP:
     927    if (msg == DM_DRAGOVER) {
     928      if (!emphasized) {
     929        emphasized = TRUE;
     930        DrawTargetEmphasis(hwnd, emphasized);
     931      }
     932    }
     933    else if (msg != WM_BEGINDRAG) {
     934      if (emphasized) {
     935        emphasized = FALSE;
     936        DrawTargetEmphasis(hwnd, emphasized);
     937      }
     938    }
     939    switch (WinQueryWindowUShort(hwnd, QWS_ID)) {
     940    case DIR_FOLDERICON:
     941      switch (msg) {
     942      case DM_DRAGOVER:
     943        if (AcceptOneDrop(mp1, mp2))
     944          return MRFROM2SHORT(DOR_DROP, DO_MOVE);
     945        return MRFROM2SHORT(DOR_NODROP, 0);     /* Drop not valid        */
     946      case DM_DROPHELP:
     947        DropHelp(mp1, mp2, hwnd, GetPString(IDS_ARCCNRFOLDERDROPHELPTEXT));
     948        return 0;
     949      case DM_DROP:
     950        {
     951          char szFrom[CCHMAXPATH + 2];
     952
     953          if (emphasized) {
     954            emphasized = FALSE;
     955            DrawTargetEmphasis(hwnd, emphasized);
     956          }
     957          if (GetOneDrop(mp1, mp2, szFrom, sizeof(szFrom)))
     958            WinSendMsg(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
     959                                       ARC_CNR),
     960                       WM_COMMAND,
     961                       MPFROM2SHORT(IDM_SWITCH, 0), MPFROMP(szFrom));
     962        }
     963        return 0;
     964      default:
     965        return PFNWPStatic(hwnd, msg, mp1, mp2);
     966      }
     967    default:
    714968      {
    715         USHORT id;
    716 
    717         id = WinQueryWindowUShort(hwnd,QWS_ID);
    718         switch(id) {
    719           case DIR_SELECTED:
    720           case DIR_VIEW:
    721           case DIR_SORT:
    722             {
    723               POINTL      ptl = {0,0};
    724               SWP         swp;
    725               DIRCNRDATA *dcd;
    726 
    727               if (hwndButtonPopup)
    728                 WinDestroyWindow(hwndButtonPopup);
    729               if (id == DIR_SELECTED)
    730                 id = DIR_RESTORE;
    731               if (id == lastid) {
    732 
    733                 ULONG check;
    734 
    735                 DosQuerySysInfo(QSV_MS_COUNT,QSV_MS_COUNT,&check,sizeof(check));
    736                 if (check < timestamp + 500) {
    737                   lastid = 0;
    738                   goto MenuAbort;
    739                 }
    740               }
    741               hwndButtonPopup = WinLoadMenu(HWND_DESKTOP,
    742                                             FM3ModHandle,
    743                                             id);
    744               if (hwndButtonPopup) {
    745                 WinSetWindowUShort(hwndButtonPopup,
    746                                    QWS_ID,
    747                                    id);
    748                 dcd = WinQueryWindowPtr(WinWindowFromID(WinQueryWindow(hwnd,
    749                                                         QW_PARENT),
    750                                                         ARC_CNR),
    751                                         QWL_USER);
    752                 if (id == DIR_SORT) {
    753                   if (dcd)
    754                     SetSortChecks(hwndButtonPopup,
    755                                   dcd->sortFlags);
    756                   WinSendMsg(hwndButtonPopup,
    757                              MM_DELETEITEM,
    758                              MPFROM2SHORT(IDM_SORTNONE,FALSE),
    759                              MPVOID);
    760                   WinSendMsg(hwndButtonPopup,
    761                              MM_DELETEITEM,
    762                              MPFROM2SHORT(IDM_SORTNAME,FALSE),
    763                              MPVOID);
    764                   WinSendMsg(hwndButtonPopup,
    765                              MM_DELETEITEM,
    766                              MPFROM2SHORT(IDM_SORTLADATE,FALSE),
    767                              MPVOID);
    768                   WinSendMsg(hwndButtonPopup,
    769                              MM_DELETEITEM,
    770                              MPFROM2SHORT(IDM_SORTCRDATE,FALSE),
    771                              MPVOID);
    772                   WinSendMsg(hwndButtonPopup,
    773                              MM_DELETEITEM,
    774                              MPFROM2SHORT(IDM_SORTDIRSFIRST,FALSE),
    775                              MPVOID);
    776                   WinSendMsg(hwndButtonPopup,
    777                              MM_DELETEITEM,
    778                              MPFROM2SHORT(IDM_SORTDIRSLAST,FALSE),
    779                              MPVOID);
    780                   WinSendMsg(hwndButtonPopup,
    781                              MM_DELETEITEM,
    782                              MPFROM2SHORT(IDM_SORTSUBJECT,FALSE),
    783                              MPVOID);
    784                   WinSendMsg(hwndButtonPopup,
    785                              MM_SETITEMTEXT,
    786                              MPFROM2SHORT(IDM_SORTEASIZE,0),
    787                              MPFROMP(GetPString(IDS_COMPRESSEDSIZEMENUTEXT)));
    788                   WinSendMsg(hwndButtonPopup,
    789                              MM_SETITEMTEXT,
    790                              MPFROM2SHORT(IDM_SORTLWDATE,0),
    791                              MPFROMP(GetPString(IDS_DATEMENUTEXT)));
    792                 }
    793                 ptl.x = 0;
    794                 if (WinPopupMenu(HWND_OBJECT,
    795                                 HWND_OBJECT,
    796                                 hwndButtonPopup,
    797                                 -32767,
    798                                 -32767,
    799                                 0,
    800                                 0)) {
    801                   WinQueryWindowPos(hwndButtonPopup,
    802                                     &swp);
    803                   ptl.y = -(swp.cy + 2);
    804                 }
    805                 else {
    806                   WinQueryWindowPos(hwnd,
    807                                     &swp);
    808                   ptl.y = swp.cy + 2;
    809                 }
    810                 if (WinPopupMenu(hwnd,
    811                                 hwnd,
    812                                 hwndButtonPopup,
    813                                 ptl.x,
    814                                 ptl.y,
    815                                 0,
    816                                 PU_HCONSTRAIN | PU_VCONSTRAIN |
    817                                 PU_KEYBOARD   | PU_MOUSEBUTTON1)) {
    818                   CenterOverWindow(hwndButtonPopup);
    819                   PaintRecessedWindow(hwnd,
    820                                       (HPS)0,
    821                                       FALSE,
    822                                       FALSE);
    823                 }
    824               }
    825             }
    826             break;
    827           default:
    828             PostMsg(WinWindowFromID(WinQueryWindow(hwnd,QW_PARENT),
    829                                     ARC_CNR),
    830                     WM_CONTROL,
    831                     MPFROM2SHORT(ARC_CNR,CN_CONTEXTMENU),
    832                     MPVOID);
    833             break;
    834         }
    835       }
    836 MenuAbort:
    837       if (msg == UM_CONTEXTMENU)
    838         return 0;
    839       break;
    840 
    841     case WM_MENUEND:
    842       if (hwndButtonPopup == (HWND)mp2) {
    843         lastid = WinQueryWindowUShort((HWND)mp2,QWS_ID);
    844         WinDestroyWindow(hwndButtonPopup);
    845         hwndButtonPopup = (HWND)0;
    846         DosQuerySysInfo(QSV_MS_COUNT,QSV_MS_COUNT,&timestamp,sizeof(timestamp));
    847         switch(lastid) {
    848           case DIR_VIEW:
    849           case DIR_SORT:
    850           case DIR_RESTORE:
    851           case DIR_SELECTED:
    852             PaintRecessedWindow(hwnd,(HPS)0,TRUE,FALSE);
    853             break;
    854         }
    855       }
    856       break;
    857 
    858     case WM_MOUSEMOVE:
    859       {
    860         USHORT id   = WinQueryWindowUShort(hwnd,QWS_ID);
    861         char  *s    = NULL;
    862 
    863         if (fOtherHelp) {
    864           if ((!hwndBubble ||
    865               WinQueryWindowULong(hwndBubble,QWL_USER) != hwnd) &&
    866              !WinQueryCapture(HWND_DESKTOP)) {
    867             switch(id) {
    868               case DIR_TOTALS:
    869                 s = GetPString(IDS_ARCCNRTOTALSHELPTEXT);
    870                 break;
    871               case DIR_SELECTED:
    872                 s = GetPString(IDS_ARCCNRSELECTEDHELPTEXT);
    873                 break;
    874               case DIR_VIEW:
    875                 s = GetPString(IDS_ARCCNRVIEWHELPTEXT);
    876                 break;
    877               case DIR_SORT:
    878                 s = GetPString(IDS_DIRCNRSORTHELP);
    879                 break;
    880               case DIR_FILTER:
    881                 s = GetPString(IDS_DIRCNRFILTERHELP);
    882                 break;
    883               case DIR_FOLDERICON:
    884                 s = GetPString(IDS_ARCCNRFOLDERHELPTEXT);
    885                 break;
    886               default:
    887                 break;
    888             }
    889             if (s)
    890               MakeBubble(hwnd,TRUE,s);
    891             else if (hwndBubble)
    892               WinDestroyWindow(hwndBubble);
    893           }
    894         }
    895         switch(id) {
    896           case DIR_FILTER:
    897           case DIR_SORT:
    898           case DIR_VIEW:
    899           case DIR_SELECTED:
    900           case DIR_FOLDERICON:
    901             return CommonTextButton(hwnd,msg,mp1,mp2);
    902         }
    903       }
    904       break;
    905 
    906     case WM_BUTTON3UP:
    907     case WM_BUTTON1UP:
    908     case WM_BUTTON1DOWN:
    909     case WM_BUTTON3DOWN:
    910       {
    911         USHORT id;
    912 
    913         id = WinQueryWindowUShort(hwnd,QWS_ID);
    914         switch(id) {
    915           case DIR_FILTER:
    916           case DIR_SORT:
    917           case DIR_VIEW:
    918           case DIR_SELECTED:
    919           case DIR_FOLDERICON:
    920             return CommonTextButton(hwnd,msg,mp1,mp2);
    921         }
    922       }
    923       break;
    924 
    925     case UM_CLICKED:
    926     case UM_CLICKED3:
    927       {
    928         USHORT id,cmd = 0;
    929 
    930         id = WinQueryWindowUShort(hwnd,QWS_ID);
    931         switch(id) {
    932           case DIR_FOLDERICON:
    933             switch(msg) {
    934               case WM_BUTTON3CLICK:
    935               case WM_CHORD:
    936                 cmd = IDM_RESCAN;
    937                 break;
    938               default:
    939                 if ((SHORT2FROMMP(mp2) & KC_ALT) != 0)
    940                   cmd = IDM_WINDOWDLG;
    941                 else
    942                   cmd = IDM_WALKDIR;
    943                 break;
    944             }
    945             break;
    946           case DIR_VIEW:
    947           case DIR_SORT:
    948           case DIR_SELECTED:
    949             PostMsg(hwnd,UM_CONTEXTMENU,MPVOID,MPVOID);
    950             break;
    951           case DIR_FILTER:
    952             cmd = IDM_FILTER;
    953             break;
    954           default:
    955             break;
    956         }
    957         if (cmd)
    958           PostMsg(WinWindowFromID(WinQueryWindow(hwnd,QW_PARENT),
    959                                   ARC_CNR),
    960                   WM_COMMAND,
    961                   MPFROM2SHORT(cmd,0),
    962                   MPVOID);
    963       }
     969        CNRDRAGINFO cnd;
     970        USHORT dcmd;
     971
     972        switch (msg) {
     973        case DM_DROP:
     974          dcmd = CN_DROP;
     975          break;
     976        case DM_DRAGOVER:
     977          dcmd = CN_DRAGOVER;
     978          break;
     979        case DM_DRAGLEAVE:
     980          dcmd = CN_DRAGLEAVE;
     981          break;
     982        case DM_DROPHELP:
     983          dcmd = CN_DROPHELP;
     984          break;
     985        case WM_BEGINDRAG:
     986          dcmd = CN_INITDRAG;
     987          break;
     988        }
     989        cnd.pDragInfo = (PDRAGINFO) mp1;
     990        cnd.pRecord = NULL;
     991        return WinSendMsg(WinQueryWindow(hwnd, QW_PARENT),
     992                          WM_CONTROL,
     993                          MPFROM2SHORT(ARC_CNR, dcmd), MPFROMP(&cnd));
     994      }
     995    }
     996  }
     997  return PFNWPStatic(hwnd, msg, mp1, mp2);
     998}
     999
     1000MRESULT EXPENTRY ArcClientWndProc(HWND hwnd, ULONG msg, MPARAM mp1,
     1001                                  MPARAM mp2)
     1002{
     1003
     1004  switch (msg) {
     1005  case UM_CONTAINERHWND:
     1006    return MRFROMLONG(WinWindowFromID(hwnd, ARC_CNR));
     1007
     1008  case UM_VIEWSMENU:
     1009    // fixme to disble menu items as needed
     1010    return MRFROMLONG(CheckMenu(&ArcCnrMenu, ARCCNR_POPUP));
     1011
     1012  case UM_FILESMENU:
     1013    // fixme to disble menu items as needed
     1014    return MRFROMLONG(CheckMenu(&ArcMenu, ARC_POPUP));
     1015
     1016  case MM_PORTHOLEINIT:
     1017  case WM_INITMENU:
     1018  case UM_INITMENU:
     1019  case UM_COMMAND:
     1020  case UM_LOADFILE:
     1021  case UM_UPDATERECORD:
     1022  case UM_UPDATERECORDLIST:
     1023  case WM_COMMAND:
     1024  case WM_CONTROL:
     1025  case WM_CLOSE:
     1026    return WinSendMsg(WinWindowFromID(hwnd, ARC_CNR), msg, mp1, mp2);
     1027
     1028  case WM_PSETFOCUS:
     1029  case WM_SETFOCUS:
     1030    if (mp2)
     1031      PostMsg(hwnd, UM_FOCUSME, MPVOID, MPVOID);
     1032    break;
     1033
     1034  case UM_FOCUSME:
     1035    WinSetFocus(HWND_DESKTOP, WinWindowFromID(hwnd, ARC_CNR));
     1036    break;
     1037
     1038  case WM_PAINT:
     1039    {
     1040      HPS hps;
     1041      RECTL rcl;
     1042
     1043      hps = WinBeginPaint(hwnd, (HPS) 0, NULL);
     1044      if (hps) {
     1045        WinQueryWindowRect(hwnd, &rcl);
     1046        WinFillRect(hps, &rcl, CLR_PALEGRAY);
     1047        CommonTextPaint(hwnd, hps);
     1048        WinEndPaint(hps);
     1049      }
     1050    }
     1051    break;
     1052
     1053  case UM_SIZE:
     1054  case WM_SIZE:
     1055    if (msg == UM_SIZE) {
     1056
     1057      SWP swp;
     1058
     1059      WinQueryWindowPos(hwnd, &swp);
     1060      mp1 = MPFROM2SHORT(swp.cx, swp.cy);
     1061      mp2 = MPFROM2SHORT(swp.cx, swp.cy);
     1062    }
     1063    {
     1064      USHORT cx, cy, bx;
     1065
     1066      cx = SHORT1FROMMP(mp2);
     1067      cy = SHORT2FROMMP(mp2);
     1068      WinSetWindowPos(WinWindowFromID(hwnd, ARC_CNR), HWND_TOP,
     1069                      0,
     1070                      22, cx, cy - (24 + 22), SWP_SHOW | SWP_MOVE | SWP_SIZE);
     1071      WinSetWindowPos(WinWindowFromID(hwnd, ARC_EXTRACTDIR), HWND_TOP,
     1072                      0, 0, cx, 22, SWP_SHOW | SWP_MOVE | SWP_SIZE);
     1073      WinSetWindowPos(WinWindowFromID(hwnd, DIR_FOLDERICON), HWND_TOP,
     1074                      2, cy - 22, 24, 20, SWP_SHOW | SWP_MOVE | SWP_SIZE);
     1075      WinSetWindowPos(WinWindowFromID(hwnd, DIR_TOTALS), HWND_TOP,
     1076                      29,
     1077                      cy - 22,
     1078                      (cx / 3) - 2, 20, SWP_SHOW | SWP_MOVE | SWP_SIZE);
     1079      WinSetWindowPos(WinWindowFromID(hwnd, DIR_SELECTED), HWND_TOP,
     1080                      29 + (cx / 3) + 2,
     1081                      cy - 22,
     1082                      (cx / 3) - 2, 20, SWP_SHOW | SWP_MOVE | SWP_SIZE);
     1083      bx = (cx - (29 + (((cx / 3) + 2) * 2))) / 3;
     1084      WinSetWindowPos(WinWindowFromID(hwnd, DIR_VIEW), HWND_TOP,
     1085                      29 + (((cx / 3) + 2) * 2),
     1086                      cy - 22, bx - 4, 20, SWP_SHOW | SWP_MOVE | SWP_SIZE);
     1087      WinSetWindowPos(WinWindowFromID(hwnd, DIR_SORT), HWND_TOP,
     1088                      29 + (((cx / 3) + 2) * 2) + bx,
     1089                      cy - 22, bx - 4, 20, SWP_SHOW | SWP_MOVE | SWP_SIZE);
     1090      WinSetWindowPos(WinWindowFromID(hwnd, DIR_FILTER), HWND_TOP,
     1091                      29 + (((cx / 3) + 2) * 2) + (bx * 2),
     1092                      cy - 22, bx - 4, 20, SWP_SHOW | SWP_MOVE | SWP_SIZE);
     1093    }
     1094    CommonTextPaint(hwnd, (HPS) 0);
     1095    if (msg == UM_SIZE) {
     1096      WinSetWindowPos(WinQueryWindow(hwnd, QW_PARENT), HWND_TOP, 0, 0, 0, 0,
     1097                      SWP_SHOW | SWP_ZORDER | SWP_ACTIVATE);
    9641098      return 0;
    965 
    966     case WM_BEGINDRAG:
    967     case DM_DROP:
    968     case DM_DRAGOVER:
    969     case DM_DRAGLEAVE:
    970     case DM_DROPHELP:
    971       if (msg == DM_DRAGOVER) {
    972         if (!emphasized) {
    973           emphasized = TRUE;
    974           DrawTargetEmphasis(hwnd,emphasized);
    975         }
    976       }
    977       else if (msg != WM_BEGINDRAG) {
    978         if (emphasized) {
    979           emphasized = FALSE;
    980           DrawTargetEmphasis(hwnd,emphasized);
    981         }
    982       }
    983       switch(WinQueryWindowUShort(hwnd,QWS_ID)) {
    984         case DIR_FOLDERICON:
    985           switch(msg) {
    986             case DM_DRAGOVER:
    987               if (AcceptOneDrop(mp1,mp2))
    988                 return MRFROM2SHORT(DOR_DROP,
    989                                     DO_MOVE);
    990               return MRFROM2SHORT(DOR_NODROP,0);         /* Drop not valid        */
    991             case DM_DROPHELP:
    992               DropHelp(mp1,
    993                        mp2,
    994                        hwnd,
    995                        GetPString(IDS_ARCCNRFOLDERDROPHELPTEXT));
    996               return 0;
    997             case DM_DROP:
    998               {
    999                 char szFrom[CCHMAXPATH + 2];
    1000 
    1001                 if (emphasized) {
    1002                   emphasized = FALSE;
    1003                   DrawTargetEmphasis(hwnd,emphasized);
    1004                 }
    1005                 if (GetOneDrop(mp1,mp2,szFrom,sizeof(szFrom)))
    1006                   WinSendMsg(WinWindowFromID(WinQueryWindow(hwnd,QW_PARENT),
    1007                                              ARC_CNR),
    1008                              WM_COMMAND,
    1009                              MPFROM2SHORT(IDM_SWITCH,0),
    1010                              MPFROMP(szFrom));
    1011               }
    1012               return 0;
    1013             default:
    1014               return PFNWPStatic(hwnd,msg,mp1,mp2);
    1015           }
    1016         default:
    1017           {
    1018             CNRDRAGINFO cnd;
    1019             USHORT      dcmd;
    1020 
    1021             switch(msg) {
    1022               case DM_DROP:
    1023                 dcmd = CN_DROP;
    1024                 break;
    1025               case DM_DRAGOVER:
    1026                 dcmd = CN_DRAGOVER;
    1027                 break;
    1028               case DM_DRAGLEAVE:
    1029                 dcmd = CN_DRAGLEAVE;
    1030                 break;
    1031               case DM_DROPHELP:
    1032                 dcmd = CN_DROPHELP;
    1033                 break;
    1034               case WM_BEGINDRAG:
    1035                 dcmd = CN_INITDRAG;
    1036                 break;
    1037             }
    1038             cnd.pDragInfo = (PDRAGINFO)mp1;
    1039             cnd.pRecord = NULL;
    1040             return WinSendMsg(WinQueryWindow(hwnd,QW_PARENT),
    1041                               WM_CONTROL,
    1042                               MPFROM2SHORT(ARC_CNR,dcmd),
    1043                               MPFROMP(&cnd));
    1044           }
    1045       }
     1099    }
     1100    break;
    10461101  }
    1047   return PFNWPStatic(hwnd,msg,mp1,mp2);
     1102  return WinDefWindowProc(hwnd, msg, mp1, mp2);
    10481103}
    10491104
    1050 
    1051 MRESULT EXPENTRY ArcClientWndProc (HWND hwnd,ULONG msg,MPARAM mp1,
    1052                                    MPARAM mp2) {
    1053 
    1054   switch(msg) {
    1055     case UM_CONTAINERHWND:
    1056       return MRFROMLONG(WinWindowFromID(hwnd,ARC_CNR));
    1057 
    1058     case UM_VIEWSMENU:
    1059       // fixme to disble menu items as needed
    1060       return MRFROMLONG(CheckMenu(&ArcCnrMenu,ARCCNR_POPUP));
    1061 
    1062     case UM_FILESMENU:
    1063       // fixme to disble menu items as needed
    1064       return MRFROMLONG(CheckMenu(&ArcMenu,ARC_POPUP));
    1065 
    1066     case MM_PORTHOLEINIT:
    1067     case WM_INITMENU:
    1068     case UM_INITMENU:
    1069     case UM_COMMAND:
    1070     case UM_LOADFILE:
    1071     case UM_UPDATERECORD:
    1072     case UM_UPDATERECORDLIST:
    1073     case WM_COMMAND:
    1074     case WM_CONTROL:
    1075     case WM_CLOSE:
    1076       return WinSendMsg(WinWindowFromID(hwnd,ARC_CNR),msg,mp1,mp2);
    1077 
    1078     case WM_PSETFOCUS:
    1079     case WM_SETFOCUS:
    1080       if (mp2)
    1081         PostMsg(hwnd,UM_FOCUSME,MPVOID,MPVOID);
    1082       break;
    1083 
    1084     case UM_FOCUSME:
    1085       WinSetFocus(HWND_DESKTOP,WinWindowFromID(hwnd,ARC_CNR));
    1086       break;
    1087 
    1088     case WM_PAINT:
    1089       {
    1090         HPS    hps;
    1091         RECTL  rcl;
    1092 
    1093         hps = WinBeginPaint(hwnd,(HPS)0,NULL);
    1094         if (hps) {
    1095           WinQueryWindowRect(hwnd,&rcl);
    1096           WinFillRect(hps,&rcl,CLR_PALEGRAY);
    1097           CommonTextPaint(hwnd,hps);
    1098           WinEndPaint(hps);
    1099         }
    1100       }
    1101       break;
    1102 
    1103     case UM_SIZE:
    1104     case WM_SIZE:
    1105       if (msg == UM_SIZE) {
    1106 
    1107         SWP     swp;
    1108 
    1109         WinQueryWindowPos(hwnd,&swp);
    1110         mp1 = MPFROM2SHORT(swp.cx,swp.cy);
    1111         mp2 = MPFROM2SHORT(swp.cx,swp.cy);
    1112       }
    1113       {
    1114         USHORT  cx,cy,bx;
    1115 
    1116         cx = SHORT1FROMMP(mp2);
    1117         cy = SHORT2FROMMP(mp2);
    1118         WinSetWindowPos(WinWindowFromID(hwnd,ARC_CNR),HWND_TOP,
    1119                         0,
    1120                         22,
    1121                         cx,
    1122                         cy - (24 + 22),
    1123                         SWP_SHOW | SWP_MOVE | SWP_SIZE);
    1124         WinSetWindowPos(WinWindowFromID(hwnd,ARC_EXTRACTDIR),HWND_TOP,
    1125                         0,
    1126                         0,
    1127                         cx,
    1128                         22,
    1129                         SWP_SHOW | SWP_MOVE | SWP_SIZE);
    1130         WinSetWindowPos(WinWindowFromID(hwnd,DIR_FOLDERICON),HWND_TOP,
    1131                         2,
    1132                         cy - 22,
    1133                         24,
    1134                         20,
    1135                         SWP_SHOW | SWP_MOVE | SWP_SIZE);
    1136         WinSetWindowPos(WinWindowFromID(hwnd,DIR_TOTALS),HWND_TOP,
    1137                         29,
    1138                         cy - 22,
    1139                         (cx / 3) - 2,
    1140                         20,
    1141                         SWP_SHOW | SWP_MOVE | SWP_SIZE);
    1142         WinSetWindowPos(WinWindowFromID(hwnd,DIR_SELECTED),HWND_TOP,
    1143                         29 + (cx / 3) + 2,
    1144                         cy - 22,
    1145                         (cx / 3) - 2,
    1146                         20,
    1147                         SWP_SHOW | SWP_MOVE | SWP_SIZE);
    1148         bx = (cx - (29 + (((cx / 3) + 2) * 2))) / 3;
    1149         WinSetWindowPos(WinWindowFromID(hwnd,DIR_VIEW),HWND_TOP,
    1150                         29 + (((cx / 3) + 2) * 2),
    1151                         cy - 22,
    1152                         bx - 4,
    1153                         20,
    1154                         SWP_SHOW | SWP_MOVE | SWP_SIZE);
    1155         WinSetWindowPos(WinWindowFromID(hwnd,DIR_SORT),HWND_TOP,
    1156                         29 + (((cx / 3) + 2) * 2) + bx,
    1157                         cy - 22,
    1158                         bx - 4,
    1159                         20,
    1160                         SWP_SHOW | SWP_MOVE | SWP_SIZE);
    1161         WinSetWindowPos(WinWindowFromID(hwnd,DIR_FILTER),HWND_TOP,
    1162                         29 + (((cx / 3) + 2) * 2) + (bx * 2),
    1163                         cy - 22,
    1164                         bx - 4,
    1165                         20,
    1166                         SWP_SHOW | SWP_MOVE | SWP_SIZE);
    1167       }
    1168       CommonTextPaint(hwnd,(HPS)0);
    1169       if (msg == UM_SIZE) {
    1170         WinSetWindowPos(WinQueryWindow(hwnd,QW_PARENT),HWND_TOP,0,0,0,0,
    1171                         SWP_SHOW | SWP_ZORDER | SWP_ACTIVATE);
    1172         return 0;
    1173       }
    1174       break;
    1175   }
    1176   return WinDefWindowProc(hwnd,msg,mp1,mp2);
    1177 }
    1178 
    1179 
    1180 MRESULT EXPENTRY ArcObjWndProc (HWND hwnd,ULONG msg,MPARAM mp1,MPARAM mp2)
     1105MRESULT EXPENTRY ArcObjWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
    11811106{
    11821107  DIRCNRDATA *dcd;
    11831108  PSZ psz;
    11841109
    1185   switch(msg) {
    1186     case DM_PRINTOBJECT:
    1187     case DM_DISCARDOBJECT:
    1188       dcd = INSTDATA(hwnd);
     1110  switch (msg) {
     1111  case DM_PRINTOBJECT:
     1112  case DM_DISCARDOBJECT:
     1113    dcd = INSTDATA(hwnd);
     1114    if (dcd) {
     1115
     1116      LISTINFO *li;
     1117      CNRDRAGINFO cni;
     1118
     1119      cni.pRecord = NULL;
     1120      cni.pDragInfo = (PDRAGINFO) mp1;
     1121      li = DoFileDrop(dcd->hwndCnr,
     1122                      dcd->directory, FALSE, MPVOID, MPFROMP(&cni));
     1123      if (li) {
     1124        li->type = (msg == DM_DISCARDOBJECT) ? IDM_DELETE : IDM_PRINT;
     1125        if (!li->list ||
     1126            !li->list[0] || !PostMsg(hwnd, UM_ACTION, MPFROMP(li), MPVOID))
     1127          FreeListInfo(li);
     1128        else
     1129          return MRFROMLONG(DRR_SOURCE);
     1130      }
     1131    }
     1132    return MRFROMLONG(DRR_TARGET);
     1133
     1134  case DM_RENDERPREPARE:
     1135    return (MRESULT) TRUE;
     1136
     1137  case DM_RENDER:
     1138    dcd = WinQueryWindowPtr(hwnd, QWL_USER);
     1139    if (dcd && dcd->info && dcd->info->extract && dcd->arcname) {
     1140
     1141      PDRAGTRANSFER pdt = (PDRAGTRANSFER) mp1;
     1142      CHAR filename[CCHMAXPATH];
     1143      ULONG len;
     1144
     1145      if (pdt->hwndClient && pdt->pditem && pdt->hstrSelectedRMF &&
     1146          pdt->hstrRenderToName) {
     1147        if (pdt->usOperation == DO_COPY || pdt->usOperation == DO_MOVE) {
     1148          *filename = 0;
     1149          len = DrgQueryStrName(pdt->hstrSelectedRMF, CCHMAXPATH, filename);
     1150          filename[len] = 0;
     1151          if (!strnicmp(filename, "OS2FILE,", 8)) {
     1152            // saymsg(MB_ENTER,HWND_DESKTOP,DEBUG_STRING,"RMF = \"%s\"",filename);
     1153          }
     1154          else {
     1155            *filename = 0;
     1156            len =
     1157              DrgQueryStrName(pdt->hstrRenderToName, CCHMAXPATH, filename);
     1158            filename[len] = 0;
     1159            if (len && *filename) {
     1160              psz = xstrdup(filename, pszSrcFile, __LINE__);
     1161              if (psz) {
     1162                PostMsg(hwnd, UM_RENDER, MPFROMP(pdt), MPFROMP(psz));
     1163                return (MRESULT) TRUE;
     1164              }
     1165            }
     1166            else {
     1167              // saymsg(MB_ENTER,HWND_DESKTOP,DEBUG_STRING,"No render-to name given.");
     1168            }
     1169          }
     1170        }
     1171        pdt->fsReply = DMFL_RENDERRETRY;
     1172      }
     1173    }
     1174    return (MRESULT) FALSE;
     1175
     1176  case UM_RENDER:
     1177    {
     1178      PDRAGTRANSFER pdt = (PDRAGTRANSFER) mp1;
     1179      USHORT usRes = DMFL_RENDERFAIL;
     1180
     1181      dcd = WinQueryWindowPtr(hwnd, QWL_USER);
     1182      if (dcd && dcd->info && dcd->info->extract && dcd->arcname) {
     1183
     1184        CHAR *filename = (CHAR *) mp2, *p;
     1185        ULONG len;
     1186        CHAR membername[CCHMAXPATH], construct[CCHMAXPATH * 2];
     1187
     1188        *membername = 0;
     1189        len = DrgQueryStrName(pdt->pditem->hstrSourceName,
     1190                              CCHMAXPATH, membername);
     1191        membername[len] = 0;
     1192        if (*membername && len && filename) {
     1193          unlinkf("%s", filename);
     1194          strcpy(construct, filename);
     1195          p = strrchr(filename, '\\');
     1196          if (!p)
     1197            *construct = 0;
     1198          else {
     1199            if (p == filename || *(p - 1) == ':')
     1200              p++;
     1201            *p = 0;
     1202          }
     1203          // saymsg(MB_ENTER,HWND_DESKTOP,DEBUG_STRING,"%s %s %s\r[%s]",dcd->info->extract,dcd->arcname,membername,construct);
     1204          runemf2(SEPARATE | WINDOWED | WAIT |
     1205                  ((fArcStuffVisible) ? 0 : (BACKGROUND | MINIMIZED)) |
     1206                  WAIT, dcd->hwndClient, construct, NULL, "%s %s%s%s %s%s%s",
     1207                  dcd->info->extract,
     1208                  (needs_quoting(dcd->arcname)) ? "\"" : NullStr,
     1209                  dcd->arcname,
     1210                  (needs_quoting(dcd->arcname)) ? "\"" : NullStr,
     1211                  (needs_quoting(membername)) ? "\"" : NullStr,
     1212                  membername, (needs_quoting(membername)) ? "\"" : NullStr);
     1213          if (*construct && construct[strlen(construct) - 1] != '\\')
     1214            strcat(construct, "\\");
     1215          strcat(construct, membername);
     1216          if (IsFile(construct) != -1) {
     1217            rename(construct, filename);
     1218            unlinkf("%s", construct);
     1219            if (IsFile(filename) != -1)
     1220              usRes = DMFL_RENDEROK;
     1221          }
     1222        }
     1223      }
     1224      if (mp2)
     1225        free((CHAR *) mp2);
     1226      PostMsg(pdt->hwndClient, DM_RENDERCOMPLETE, MPFROMP(pdt),
     1227              MPFROM2SHORT(usRes, 0));
     1228    }
     1229    return 0;
     1230
     1231  case UM_SETUP:
     1232    dcd = WinQueryWindowPtr(hwnd, QWL_USER);
     1233    if (!dcd) {
     1234      Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
     1235      PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
     1236    }
     1237    else {
     1238      /* set unique id */
     1239      WinSetWindowUShort(hwnd, QWS_ID, ARCOBJ_FRAME + (ARC_FRAME - dcd->id));
     1240      dcd->hwndObject = hwnd;           // pass back hwnd
     1241      if (ParentIsDesktop(hwnd, dcd->hwndParent))
     1242        DosSleep(250);                  // Avoid race?
     1243    }
     1244    return 0;
     1245
     1246  case UM_RESCAN:
     1247    /*
     1248     * populate container
     1249     */
     1250    dcd = WinQueryWindowPtr(hwnd, QWL_USER);
     1251    if (dcd) {
     1252      if (mp1)
     1253        strcpy(dcd->arcname, (CHAR *) mp1);     // Update name on request
     1254      dcd->ullTotalBytes = dcd->totalfiles =
     1255        dcd->selectedfiles = dcd->selectedbytes = 0;
     1256      WinSetDlgItemText(dcd->hwndClient, DIR_TOTALS, "0");
     1257      WinSetDlgItemText(dcd->hwndClient, DIR_SELECTED, "0 / 0k");
     1258      dcd->totalfiles = FillArcCnr(dcd->hwndCnr,
     1259                                   dcd->arcname,
     1260                                   &dcd->info,
     1261                                   &dcd->ullTotalBytes, &dcd->stopflag);
     1262      if (!dcd->totalfiles)
     1263        PostMsg(dcd->hwndCnr, WM_CLOSE, MPVOID, MPVOID);
     1264      else {
     1265        dcd->arcfilled = TRUE;
     1266        if (!PostMsg(dcd->hwndCnr, UM_RESCAN, MPVOID, MPVOID))
     1267          WinSendMsg(dcd->hwndCnr, UM_RESCAN, MPVOID, MPVOID);
     1268        PostMsg(dcd->hwndCnr, UM_SETUP2, MPVOID, MPVOID);
     1269        WinSendMsg(dcd->hwndCnr,
     1270                   CM_INVALIDATERECORD,
     1271                   MPVOID, MPFROM2SHORT(0, CMA_ERASE | CMA_REPOSITION));
     1272      }
     1273    }
     1274    return 0;
     1275
     1276  case UM_SELECT:
     1277    dcd = WinQueryWindowPtr(hwnd, QWL_USER);
     1278    if (dcd) {
     1279      switch (SHORT1FROMMP(mp1)) {
     1280      case IDM_SELECTALL:
     1281      case IDM_SELECTALLFILES:
     1282        SelectAll(dcd->hwndCnr, TRUE, TRUE, NULL, NULL, TRUE);
     1283        break;
     1284      case IDM_DESELECTALL:
     1285      case IDM_DESELECTALLFILES:
     1286        DeselectAll(dcd->hwndCnr, TRUE, TRUE, NULL, NULL, TRUE);
     1287        break;
     1288      case IDM_DESELECTMASK:
     1289      case IDM_SELECTMASK:
     1290        {
     1291          MASK mask;
     1292          PARCITEM pci = (PARCITEM) mp2;
     1293
     1294          memset(&mask, 0, sizeof(MASK));
     1295          mask.fNoAttribs = TRUE;
     1296          mask.fNoDirs = TRUE;
     1297          strcpy(mask.prompt,
     1298                 GetPString((SHORT1FROMMP(mp1) == IDM_SELECTMASK) ?
     1299                            IDS_SELECTFILTERTEXT : IDS_DESELECTFILTERTEXT));
     1300          if (pci && (INT) pci != -1)
     1301            strcpy(mask.szMask, pci->szFileName);
     1302          if (WinDlgBox(HWND_DESKTOP, dcd->hwndCnr, PickMaskDlgProc,
     1303                        FM3ModHandle, MSK_FRAME, MPFROMP(&mask))) {
     1304            if (SHORT1FROMMP(mp1) == IDM_SELECTMASK)
     1305              SelectAll(dcd->hwndCnr, TRUE, TRUE, mask.szMask, NULL, FALSE);
     1306            else
     1307              DeselectAll(dcd->hwndCnr, TRUE, TRUE, mask.szMask, NULL, FALSE);
     1308          }
     1309        }
     1310
     1311      case IDM_INVERT:
     1312        InvertAll(dcd->hwndCnr);
     1313        break;
     1314      }
     1315    }
     1316    return 0;
     1317
     1318  case UM_ENTER:
     1319    dcd = WinQueryWindowPtr(hwnd, QWL_USER);
     1320    if (dcd) {
     1321
     1322      CHAR *s = (CHAR *) mp1, *p, *pp, filename[CCHMAXPATH];
     1323
     1324      if (s) {
     1325        if (!dcd->info->extract) {
     1326          Runtime_Error(pszSrcFile, __LINE__, "no extract");
     1327          free(s);
     1328          return 0;
     1329        }
     1330        runemf2(SEPARATE | WINDOWED |
     1331                ((fArcStuffVisible) ? 0 : (BACKGROUND | MINIMIZED)) |
     1332                WAIT, dcd->hwndClient, dcd->workdir, NULL, "%s %s%s%s %s%s%s",
     1333                ((dcd->info->exwdirs) ? dcd->info->exwdirs :
     1334                 dcd->info->extract),
     1335                (needs_quoting(dcd->arcname)) ? "\"" : NullStr,
     1336                dcd->arcname,
     1337                (needs_quoting(dcd->arcname)) ? "\"" : NullStr,
     1338                (needs_quoting(s)) ? "\"" : NullStr,
     1339                s, (needs_quoting(s)) ? "\"" : NullStr);
     1340
     1341        if (!dcd->info->exwdirs) {
     1342          p = s;
     1343          p = strrchr(s, '\\');
     1344          pp = strrchr(s, '/');
     1345          if (p && pp)
     1346            p = max(p, pp);
     1347          else if (!p)
     1348            p = pp;
     1349          if (p)
     1350            memmove(s, p + 1, strlen(p + 1));
     1351        }
     1352        sprintf(filename, "%s\\%s", dcd->workdir, s);
     1353        p = filename;
     1354        while (*p) {
     1355          if (*p == '/')
     1356            *p = '\\';
     1357          p++;
     1358        }
     1359        free(s);
     1360        if (IsFile(filename) == 1)
     1361          WinSendMsg(dcd->hwndCnr, UM_ENTER, MPFROMP(filename), MPVOID);
     1362      }
     1363    }
     1364    return 0;
     1365
     1366  case UM_COMMAND:
     1367    if (mp1) {
     1368      if (PostMsg(hwnd, UM_ACTION, mp1, mp2))
     1369        return (MRESULT) TRUE;
     1370    }
     1371    return 0;
     1372
     1373  case UM_ACTION:
     1374    DosError(FERR_DISABLEHARDERR);
     1375    dcd = WinQueryWindowPtr(hwnd, QWL_USER);
     1376    if (dcd) {
     1377
     1378      LISTINFO *li = (LISTINFO *) mp1;
     1379      register INT x;
     1380
     1381      if (li && li->list && li->list[0]) {
     1382        switch (li->type) {
     1383        case IDM_ARCHIVE:
     1384        case IDM_ARCHIVEM:
     1385          {
     1386            DIRCNRDATA ad;
     1387            CHAR szBuffer[1025], *p;
     1388
     1389            if (!li->list[1] && !stricmp(li->list[0], dcd->arcname)) {
     1390              Runtime_Error(pszSrcFile, __LINE__, "arc to self");
     1391              break;
     1392            }
     1393            ad = *dcd;
     1394            ad.namecanchange = 0;
     1395            ad.fmoving = (li->type == IDM_ARCHIVEM);
     1396            if (!WinDlgBox(HWND_DESKTOP, dcd->hwndClient, ArchiveDlgProc, FM3ModHandle, ARCH_FRAME, (PVOID) & ad) || !*ad.arcname || !*ad.command)      /* we blew it */
     1397              break;
     1398            /* build the sucker */
     1399            strcpy(szBuffer, ad.command);
     1400            strcat(szBuffer, " ");
     1401            if (needs_quoting(ad.arcname))
     1402              strcat(szBuffer, "\"");
     1403            strcat(szBuffer, ad.arcname);
     1404            if (needs_quoting(ad.arcname))
     1405              strcat(szBuffer, "\"");
     1406            p = &szBuffer[strlen(szBuffer)];
     1407            if (ad.mask.szMask) {
     1408              strcat(szBuffer, " ");
     1409              if (needs_quoting(ad.mask.szMask))
     1410                strcat(szBuffer, "\"");
     1411              strcat(szBuffer, ad.mask.szMask);
     1412              if (needs_quoting(ad.mask.szMask))
     1413                strcat(szBuffer, "\"");
     1414            }
     1415            strcat(szBuffer, " ");
     1416            x = 0;
     1417            while (li->list[x]) {
     1418              if (needs_quoting(li->list[x]))
     1419                strcat(szBuffer, "\"");
     1420              strcat(szBuffer, li->list[x]);
     1421              if (!IsFile(li->list[x])) {
     1422                if (szBuffer[strlen(szBuffer) - 1] != '\\')
     1423                  strcat(szBuffer, "\\");
     1424                strcat(szBuffer, "*");
     1425              }
     1426              if (needs_quoting(li->list[x]))
     1427                strcat(szBuffer, "\"");
     1428              x++;
     1429              if (!li->list[x] || strlen(szBuffer) +
     1430                  strlen(li->list[x]) + 5 > 1024) {
     1431                runemf2(SEPARATE | WINDOWED |
     1432                        ((fArcStuffVisible) ? 0 :
     1433                         (BACKGROUND | MINIMIZED)) |
     1434                        WAIT, hwnd, NULL, NULL, "%s", szBuffer);
     1435                *p = 0;
     1436              }
     1437              strcat(szBuffer, " ");
     1438            }
     1439            PostMsg(dcd->hwndCnr, UM_RESCAN, MPFROMSHORT(1), MPVOID);
     1440            Broadcast(WinQueryAnchorBlock(hwnd),
     1441                      hwndMain, UM_UPDATERECORD, MPFROMP(ad.arcname), MPVOID);
     1442            Broadcast(WinQueryAnchorBlock(hwnd),
     1443                      hwndMain,
     1444                      UM_UPDATERECORDLIST, MPFROMP(li->list), MPVOID);
     1445          }
     1446          break;
     1447
     1448        case IDM_REFRESH:
     1449        case IDM_DELETE:
     1450          {
     1451            CHAR cl[1001], *endofit;
     1452            INT z;
     1453            CHECKLIST ck;
     1454            CHAR prompt[CCHMAXPATH + 257];
     1455
     1456            if (!dcd->info->delete)
     1457              break;
     1458            memset(&ck, 0, sizeof(ck));
     1459            ck.size = sizeof(ck);
     1460            ck.list = li->list;
     1461            ck.cmd = li->type;
     1462            ck.prompt = prompt;
     1463            sprintf(prompt, GetPString(IDS_ARCCNRDELREFTEXT),
     1464                    (li->type == IDM_DELETE) ?
     1465                    GetPString(IDS_DELETELOWERTEXT) :
     1466                    GetPString(IDS_REFRESHLOWERTEXT),
     1467                    &"s"[li->list[1] == NULL],
     1468                    dcd->arcname,
     1469                    (li->type == IDM_DELETE) ?
     1470                    GetPString(IDS_DELETELOWERTEXT) :
     1471                    GetPString(IDS_REFRESHLOWERTEXT));
     1472            if (!WinDlgBox(HWND_DESKTOP, hwnd, CheckListProc,
     1473                           FM3ModHandle, CHECK_FRAME, MPFROMP(&ck)))
     1474              break;
     1475            li->list = ck.list;
     1476            if (!li->list || !li->list[0])
     1477              break;
     1478            if (li->type == IDM_DELETE)
     1479              sprintf(cl, "%s %s%s%s", dcd->info->delete,
     1480                      (needs_quoting(dcd->arcname)) ? "\"" : NullStr,
     1481                      dcd->arcname,
     1482                      (needs_quoting(dcd->arcname)) ? "\"" : NullStr);
     1483            else
     1484              sprintf(cl, "%s %s%s%s", dcd->info->create,
     1485                      (needs_quoting(dcd->arcname)) ? "\"" : NullStr,
     1486                      dcd->arcname,
     1487                      (needs_quoting(dcd->arcname)) ? "\"" : NullStr);
     1488            endofit = &cl[strlen(cl)];
     1489            z = 0;
     1490            do {
     1491              for (x = z; li->list[x] &&
     1492                   strlen(cl) + strlen(li->list[x]) < 999; x++) {
     1493                strcat(cl, " ");
     1494                if (needs_quoting(li->list[x]))
     1495                  strcat(cl, "\"");
     1496                strcat(cl, li->list[x]);
     1497                if (needs_quoting(li->list[x]))
     1498                  strcat(cl, "\"");
     1499              }
     1500              z = x;
     1501              runemf2(SEPARATE | WINDOWED |
     1502                      ((fArcStuffVisible) ? 0 : (BACKGROUND | MINIMIZED)) |
     1503                      WAIT, hwnd, NullStr, NULL, "%s", cl);
     1504              *endofit = 0;
     1505            } while (li->list[x]);
     1506            PostMsg(dcd->hwndCnr, UM_RESCAN, MPFROMSHORT(1), MPVOID);
     1507            Broadcast(WinQueryAnchorBlock(hwnd),
     1508                      hwndMain,
     1509                      UM_UPDATERECORD, MPFROMP(dcd->arcname), MPVOID);
     1510          }
     1511          break;
     1512
     1513        case IDM_PRINT:
     1514        case IDM_VIRUSSCAN:
     1515        case IDM_VIEW:
     1516        case IDM_MCIPLAY:
     1517        case IDM_VIEWARCHIVE:
     1518        case IDM_VIEWTEXT:
     1519        case IDM_VIEWBINARY:
     1520        case IDM_EDIT:
     1521        case IDM_EDITTEXT:
     1522        case IDM_EDITBINARY:
     1523        case IDM_EXEC:
     1524        case IDM_EXTRACTWDIRS:
     1525        case IDM_EXTRACT:
     1526          {
     1527            CHAR cl[1001], *endofit, *ptr;
     1528            INT z;
     1529
     1530            if ((li->type == IDM_EXTRACT && !li->info->extract) ||
     1531                ((li->type == IDM_VIEW || li->type == IDM_VIEWTEXT ||
     1532                  li->type == IDM_VIEWBINARY || li->type == IDM_EDIT ||
     1533                  li->type == IDM_VIEWARCHIVE || li->type == IDM_EDITTEXT ||
     1534                  li->type == IDM_EDITBINARY || li->type == IDM_MCIPLAY) &&
     1535                 (!li->info->extract && !li->info->exwdirs)) ||
     1536                (li->type != IDM_EXTRACT && li->type != IDM_EDIT &&
     1537                 li->type != IDM_VIEW && li->type != IDM_VIEWTEXT &&
     1538                 li->type != IDM_VIEWBINARY &&
     1539                 li->type != IDM_VIEWARCHIVE &&
     1540                 li->type != IDM_EDITTEXT &&
     1541                 li->type != IDM_EDITBINARY &&
     1542                 li->type != IDM_MCIPLAY && !li->info->exwdirs)) {
     1543              Runtime_Error(pszSrcFile, __LINE__, "no cmd for request");
     1544              break;
     1545            }
     1546            if (li->type == IDM_EXTRACT || li->type == IDM_EXTRACTWDIRS) {
     1547
     1548              CHAR fullname[CCHMAXPATH * 2];
     1549              CHAR **exfiles = NULL;
     1550              INT numfiles = 0, numalloc = 0;
     1551
     1552              for (x = 0; li->list[x]; x++) {
     1553                sprintf(fullname, "%s%s%s",
     1554                        li->targetpath,
     1555                        (li->targetpath[strlen(li->targetpath) - 1] == '\\') ?
     1556                        NullStr : "\\", li->list[x]);
     1557                if (IsFile(fullname) != -1) {
     1558                  AddToList(li->list[x], &exfiles, &numfiles, &numalloc);
     1559                  li->list = RemoveFromList(li->list, li->list[x]);
     1560                  if (!li->list)
     1561                    break;
     1562                  x--;
     1563                }
     1564              }
     1565              if (exfiles && numfiles) {
     1566
     1567                CHECKLIST ckl;
     1568                CHAR prompt[(CCHMAXPATH * 2) + 256];
     1569
     1570                memset(&ckl, 0, sizeof(ckl));
     1571                ckl.size = sizeof(ckl);
     1572                ckl.list = exfiles;
     1573                ckl.prompt = prompt;
     1574                ckl.cmd = li->type;
     1575                sprintf(prompt,
     1576                        GetPString(IDS_REPLACEWARNTEXT),
     1577                        &"s"[numfiles == 1],
     1578                        li->arcname, &"s"[numfiles != 1], li->targetpath);
     1579                if (!WinDlgBox(HWND_DESKTOP, hwnd, CheckListProc,
     1580                               FM3ModHandle, CHECK_FRAME, MPFROMP(&ckl))) {
     1581                  if (ckl.list)
     1582                    FreeList(ckl.list);
     1583                  break;
     1584                }
     1585                else if (ckl.list)
     1586                  li->list = CombineLists(li->list, ckl.list);
     1587              }
     1588            }
     1589            if (!li->list || !li->list[0])
     1590              break;
     1591            sprintf(cl, "%s %s%s%s", (li->type == IDM_EXTRACT ||
     1592                                      ((li->type == IDM_VIEW
     1593                                        || li->type == IDM_VIEWTEXT
     1594                                        || li->type == IDM_VIEWBINARY
     1595                                        || li->type == IDM_VIEWARCHIVE
     1596                                        || li->type == IDM_PRINT
     1597                                        || li->type == IDM_EDIT
     1598                                        || li->type == IDM_EDITTEXT
     1599                                        || li->type == IDM_EDITBINARY
     1600                                        && li->type == IDM_MCIPLAY)
     1601                                       && !li->info->exwdirs)) ? li->info->
     1602                    extract : li->info->exwdirs,
     1603                    (needs_quoting(li->arcname)) ? "\"" : NullStr,
     1604                    li->arcname,
     1605                    (needs_quoting(li->arcname)) ? "\"" : NullStr);
     1606            endofit = &cl[strlen(cl)];
     1607            z = 0;
     1608            do {
     1609              for (x = z; li->list[x] &&
     1610                   strlen(cl) + strlen(li->list[x]) < 999; x++) {
     1611                strcat(cl, " ");
     1612                if (needs_quoting(li->list[x]))
     1613                  strcat(cl, "\"");
     1614                strcat(cl, li->list[x]);
     1615                if (needs_quoting(li->list[x]))
     1616                  strcat(cl, "\"");
     1617                ptr = li->list[x];
     1618                while (*ptr) {
     1619                  if (*ptr == '/')
     1620                    *ptr = '\\';
     1621                  ptr++;
     1622                }
     1623              }
     1624              z = x;
     1625              runemf2(SEPARATE | WINDOWED |
     1626                      (fArcStuffVisible ? 0 : (BACKGROUND | MINIMIZED)) |
     1627                      WAIT, hwnd, li->targetpath, NULL, "%s", cl);
     1628              *endofit = 0;
     1629            } while (li->list[x]);
     1630            if (li->type == IDM_EXTRACT || li->type == IDM_EXTRACTWDIRS) {
     1631              /* update windows */
     1632              for (x = 0; li->list[x]; x++) {
     1633
     1634                CHAR *temp, *p;
     1635
     1636                temp = li->list[x];
     1637                p = temp;
     1638                while (*p) {
     1639                  if (*p == '/')
     1640                    *p = '\\';
     1641                  p++;
     1642                }
     1643                p =
     1644                  xmalloc(strlen(temp) + strlen(li->targetpath) + 2,
     1645                          pszSrcFile, __LINE__);
     1646                if (p) {
     1647                  strcpy(p, li->targetpath);
     1648                  if (p[strlen(p) - 1] != '\\')
     1649                    strcat(p, "\\");
     1650                  strcat(p, temp);
     1651                  li->list[x] = p;
     1652                  free(temp);
     1653                }
     1654              }
     1655              if (fFolderAfterExtract) {
     1656
     1657                CHAR objectpath[CCHMAXPATH], *p;
     1658                APIRET rc;
     1659
     1660                GetDesktopName(objectpath, sizeof(objectpath));
     1661                rc = WinDlgBox(HWND_DESKTOP, dcd->hwndParent, ObjCnrDlgProc,
     1662                               FM3ModHandle, OBJCNR_FRAME,
     1663                               MPFROMP(objectpath));
     1664                if (rc) {
     1665                  if (rc > 1)
     1666                    strcpy(objectpath, "<WP_DESKTOP>");
     1667                  p = NULL;
     1668                  if (li->arcname) {
     1669                    p = strrchr(li->arcname, '\\');
     1670                    if (p)
     1671                      p++;
     1672                  }
     1673                  MakeShadows(dcd->hwndParent, li->list, 2, objectpath, p);
     1674                }
     1675              }
     1676              Broadcast(WinQueryAnchorBlock(hwnd),
     1677                        hwndMain,
     1678                        UM_UPDATERECORDLIST, MPFROMP(li->list), MPVOID);
     1679            }
     1680            else if (li->type == IDM_EXEC)
     1681              ExecOnList(hwnd,
     1682                         li->runfile,
     1683                         WINDOWED | SEPARATEKEEP | PROMPT,
     1684                         li->targetpath,
     1685                         NULL, GetPString(IDS_EXECARCFILETITLETEXT));
     1686            else if (li->type == IDM_VIRUSSCAN)
     1687              ExecOnList(hwnd, virus, PROMPT | WINDOWED | SEPARATEKEEP,
     1688                         li->targetpath, NULL,
     1689                         GetPString(IDS_VIRUSSCANARCHIVETITLETEXT));
     1690            else if (li->type == IDM_VIEW || li->type == IDM_VIEWTEXT ||
     1691                     li->type == IDM_VIEWBINARY || li->type == IDM_EDIT ||
     1692                     li->type == IDM_EDITTEXT ||
     1693                     li->type == IDM_VIEWARCHIVE ||
     1694                     li->type == IDM_EDITBINARY ||
     1695                     li->type == IDM_MCIPLAY || li->type == IDM_PRINT) {
     1696
     1697              CHAR *temp, *p;
     1698
     1699              for (x = 0; li->list[x]; x++) {
     1700                if (!li->info->exwdirs) {
     1701                  temp = li->list[x];
     1702                  p = strrchr(li->list[x], '\\');
     1703                  if (p) {
     1704                    p++;
     1705                    li->list[x] = xstrdup(p, pszSrcFile, __LINE__);
     1706                    if (!li->list[x])
     1707                      li->list[x] = temp;
     1708                    else {
     1709                      free(temp);
     1710                    }
     1711                  }
     1712                }
     1713                sprintf(cl, "%s%s%s", li->targetpath,
     1714                        (li->targetpath[strlen(li->targetpath) - 1] == '\\') ?
     1715                        NullStr : "\\", li->list[x]);
     1716                temp = li->list[x];
     1717                li->list[x] = xstrdup(cl, pszSrcFile, __LINE__);
     1718                if (!li->list[x])
     1719                  li->list[x] = temp;
     1720                else
     1721                  free(temp);
     1722              }
     1723              if (li->type == IDM_VIEW || li->type == IDM_EDIT) {
     1724
     1725                BOOL isit = TestBinary(li->list[0]);
     1726
     1727                if (isit) {
     1728                  if (li->type == IDM_VIEW)
     1729                    li->type = IDM_VIEWBINARY;
     1730                  else
     1731                    li->type = IDM_EDITBINARY;
     1732                }
     1733                else {
     1734                  if (li->type == IDM_VIEW)
     1735                    li->type = IDM_VIEWTEXT;
     1736                  else
     1737                    li->type = IDM_EDITTEXT;
     1738                }
     1739              }
     1740              if (li->type == IDM_MCIPLAY) {
     1741
     1742                FILE *fp;
     1743
     1744                fp = xfopen("$FM2PLAY.$$$", "w", pszSrcFile, __LINE__);
     1745                if (fp) {
     1746                  fprintf(fp, "%s", ";AV/2-built FM2Play listfile\n");
     1747                  for (x = 0; li->list[x]; x++)
     1748                    fprintf(fp, "%s\n", li->list[x]);
     1749                  fprintf(fp, ";end\n");
     1750                  fclose(fp);
     1751                  runemf2(SEPARATE | WINDOWED, HWND_DESKTOP, NULL,
     1752                          NULL, "%sFM2PLAY.EXE /@$FM2PLAY.$$$",
     1753                          (fAddUtils) ? "UTILS\\" : NullStr);
     1754                }
     1755              }
     1756              else if (li->type == IDM_PRINT) {
     1757                strcpy(li->targetpath, printer);
     1758                if (_beginthread(PrintListThread, NULL, 65536, (PVOID) li) !=
     1759                    -1) {
     1760                  Runtime_Error(pszSrcFile, __LINE__,
     1761                                GetPString(IDS_COULDNTSTARTTHREADTEXT));
     1762                  li = NULL;
     1763                }
     1764              }
     1765              else if (li->type == IDM_VIEWARCHIVE) {
     1766
     1767                ARC_TYPE *info;
     1768
     1769                for (x = 0; li->list[x]; x++) {
     1770                  if (IsFile(li->list[x]) == 1) {
     1771                    info = NULL;        // Do not hide dups - fixme to know why?
     1772                    if (WinDlgBox(HWND_DESKTOP, HWND_DESKTOP,
     1773                                  SBoxDlgProc, FM3ModHandle, ASEL_FRAME,
     1774                                  (PVOID) & info) && info) {
     1775                      StartArcCnr(HWND_DESKTOP,
     1776                                  HWND_DESKTOP, li->list[x], 4, info);
     1777                    }
     1778                  }
     1779                }
     1780              }
     1781              else if ((li->type == IDM_VIEWTEXT && *viewer) ||
     1782                       (li->type == IDM_VIEWBINARY && *binview) ||
     1783                       (li->type == IDM_EDITTEXT && *editor) ||
     1784                       (li->type == IDM_EDITBINARY && *bined)) {
     1785                DosSleep(100);
     1786                ExecOnList(hwnd, ((li->type == IDM_VIEWTEXT) ? viewer :
     1787                                  (li->type == IDM_VIEWBINARY) ? binview :
     1788                                  (li->type == IDM_EDITTEXT) ? editor :
     1789                                  bined),
     1790                           WINDOWED | SEPARATE, li->targetpath, li->list,
     1791                           NULL);
     1792              }
     1793              else {
     1794                if (li->hwnd) {
     1795
     1796                  ULONG viewtype;
     1797
     1798                  for (x = 0; li->list[x]; x++) {
     1799                    if (x == 0) {
     1800                      if (li->type == IDM_VIEWBINARY ||
     1801                          li->type == IDM_EDITBINARY)
     1802                        viewtype = 16;
     1803                      else
     1804                        viewtype = 8;
     1805                    }
     1806                    else
     1807                      viewtype = 0;
     1808                    temp = xstrdup(li->list[x], pszSrcFile, __LINE__);
     1809                    if (temp) {
     1810                      if (!PostMsg(WinQueryWindow(li->hwnd, QW_PARENT),
     1811                                   UM_LOADFILE,
     1812                                   MPFROMLONG(4L +
     1813                                              (li->type == IDM_VIEWTEXT ||
     1814                                               li->type == IDM_VIEWBINARY) +
     1815                                              viewtype), MPFROMP(temp)))
     1816                        free(temp);
     1817                    }
     1818                  }
     1819                }
     1820              }
     1821            }
     1822          }
     1823          break;
     1824
     1825        case IDM_FIND:
     1826          {
     1827            INT numfiles = 0, numalloced = 0;
     1828            CHAR **list2 = NULL, fullname[CCHMAXPATH * 2], *p;
     1829
     1830            for (x = 0; li->list[x]; x++) {
     1831              p = li->list[x];
     1832              while (*p) {
     1833                if (*p == '/')
     1834                  *p = '\\';
     1835                p++;
     1836              }
     1837              sprintf(fullname, "%s%s%s", dcd->directory,
     1838                      (dcd->directory[strlen(dcd->directory) - 1] == '\\') ?
     1839                      NullStr : "\\", li->list[x]);
     1840              if (IsFile(fullname) != -1)
     1841                if (AddToList(fullname, &list2, &numfiles, &numalloced))
     1842                  break;
     1843              if (strchr(li->list[x], '\\')) {
     1844                p = strrchr(li->list[x], '\\');
     1845                if (p) {
     1846                  p++;
     1847                  if (*p) {
     1848                    sprintf(fullname, "%s%s%s", dcd->directory,
     1849                            (dcd->directory[strlen(dcd->directory) - 1] ==
     1850                             '\\') ? NullStr : "\\", p);
     1851                    if (IsFile(fullname) != -1)
     1852                      if (AddToList(fullname, &list2, &numfiles, &numalloced))
     1853                        break;
     1854                  }
     1855                }
     1856              }
     1857            }
     1858            if (!numfiles || !list2)
     1859              Runtime_Error(pszSrcFile, __LINE__, "no files or list");
     1860            else {
     1861              WinSendMsg(dcd->hwndCnr, WM_COMMAND,
     1862                         MPFROM2SHORT(IDM_COLLECTOR, 0), MPVOID);
     1863              DosSleep(128L);
     1864              if (Collector) {
     1865                if (!PostMsg(Collector, WM_COMMAND,
     1866                             MPFROM2SHORT(IDM_COLLECTOR, 0), MPFROMP(list2)))
     1867                  FreeList(list2);
     1868              }
     1869              else
     1870                FreeList(list2);
     1871            }
     1872          }
     1873          break;
     1874        }
     1875      }
     1876      FreeListInfo(li);
     1877    }
     1878    return 0;
     1879
     1880  case WM_CLOSE:
     1881    WinDestroyWindow(hwnd);
     1882    break;
     1883
     1884  case WM_DESTROY:
     1885    dcd = WinQueryWindowPtr(hwnd, QWL_USER);
     1886    if (dcd) {
     1887      if (*dcd->workdir) {
     1888        DosSleep(33L);
     1889        wipeallf("%s\\*", dcd->workdir);
     1890        if (rmdir(dcd->workdir)) {
     1891          DosSleep(256L);
     1892          wipeallf("%s\\*", dcd->workdir);
     1893          rmdir(dcd->workdir);
     1894        }
     1895      }
     1896      FreeList(dcd->lastselection);
     1897      WinSendMsg(dcd->hwndCnr, UM_CLOSE, MPVOID, MPVOID);
     1898      free(dcd);
     1899      WinSetWindowPtr(dcd->hwndCnr, QWL_USER, NULL);
     1900    }
     1901    if (!PostMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID))
     1902      WinSendMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID);
     1903    break;
     1904  }                                     // switch
     1905  return WinDefWindowProc(hwnd, msg, mp1, mp2);
     1906}
     1907
     1908static MRESULT EXPENTRY ArcCnrWndProc(HWND hwnd, ULONG msg, MPARAM mp1,
     1909                                      MPARAM mp2)
     1910{
     1911  DIRCNRDATA *dcd = WinQueryWindowPtr(hwnd, QWL_USER);
     1912
     1913  switch (msg) {
     1914  case DM_PRINTOBJECT:
     1915  case DM_DISCARDOBJECT:
     1916    if (dcd)
     1917      return WinSendMsg(dcd->hwndObject, msg, mp1, mp2);
     1918    else
     1919      return MRFROMLONG(DRR_TARGET);
     1920
     1921  case WM_CHAR:
     1922    shiftstate = (SHORT1FROMMP(mp1) & (KC_SHIFT | KC_ALT | KC_CTRL));
     1923    if (SHORT1FROMMP(mp1) & KC_KEYUP)
     1924      return (MRESULT) TRUE;
     1925    if (SHORT1FROMMP(mp1) & KC_VIRTUALKEY) {
     1926      switch (SHORT2FROMMP(mp2)) {
     1927      case VK_DELETE:
     1928        PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_DELETE, 0), MPVOID);
     1929        break;
     1930      }
     1931    }
     1932    if (shiftstate || fNoSearch)
     1933      break;
     1934    if (SHORT1FROMMP(mp1) & KC_CHAR) {
     1935
     1936      ULONG thistime, len;
     1937      SEARCHSTRING srch;
     1938      PCNRITEM pci;
     1939
     1940      if (!dcd)
     1941        break;
     1942      switch (SHORT1FROMMP(mp2)) {
     1943      case '\x1b':
     1944      case '\r':
     1945      case '\n':
     1946        dcd->lasttime = 0;
     1947        *dcd->szCommonName = 0;
     1948        break;
     1949      default:
     1950        thistime = WinQueryMsgTime(WinQueryAnchorBlock(hwnd));
     1951        if (thistime > dcd->lasttime + 1250)
     1952          *dcd->szCommonName = 0;
     1953        dcd->lasttime = thistime;
     1954        if (SHORT1FROMMP(mp2) == ' ' && !*dcd->szCommonName)
     1955          break;
     1956      KbdRetry:
     1957        len = strlen(dcd->szCommonName);
     1958        if (len >= CCHMAXPATH - 1) {
     1959          *dcd->szCommonName = 0;
     1960          len = 0;
     1961        }
     1962        dcd->szCommonName[len] = toupper(SHORT1FROMMP(mp2));
     1963        dcd->szCommonName[len + 1] = 0;
     1964        memset(&srch, 0, sizeof(SEARCHSTRING));
     1965        srch.cb = (ULONG) sizeof(SEARCHSTRING);
     1966        srch.pszSearch = dcd->szCommonName;
     1967        srch.fsPrefix = TRUE;
     1968        srch.fsCaseSensitive = FALSE;
     1969        srch.usView = CV_ICON;
     1970        pci = WinSendMsg(hwnd,
     1971                         CM_SEARCHSTRING,
     1972                         MPFROMP(&srch), MPFROMLONG(CMA_FIRST));
     1973        if (pci && (INT) pci != -1) {
     1974
     1975          USHORT attrib = CRA_CURSORED;
     1976
     1977          /* make found item current item */
     1978          if (!stricmp(pci->pszFileName, dcd->szCommonName))
     1979            attrib |= CRA_SELECTED;
     1980          WinSendMsg(hwnd,
     1981                     CM_SETRECORDEMPHASIS,
     1982                     MPFROMP(pci), MPFROM2SHORT(TRUE, attrib));
     1983          /* make sure that record shows in viewport */
     1984          ShowCnrRecord(hwnd, (PMINIRECORDCORE) pci);
     1985          return (MRESULT) TRUE;
     1986        }
     1987        else {
     1988          if (SHORT1FROMMP(mp2) == ' ') {
     1989            dcd->szCommonName[len] = 0;
     1990            break;
     1991          }
     1992          *dcd->szCommonName = 0;
     1993          dcd->lasttime = 0;
     1994          if (len)                      // retry as first letter if no match
     1995            goto KbdRetry;
     1996        }
     1997        break;
     1998      }
     1999    }
     2000    break;
     2001
     2002  case WM_MOUSEMOVE:
     2003  case WM_BUTTON1UP:
     2004  case WM_BUTTON2UP:
     2005  case WM_BUTTON3UP:
     2006  case WM_CHORD:
     2007    shiftstate = (SHORT2FROMMP(mp2) & (KC_SHIFT | KC_ALT | KC_CTRL));
     2008    break;
     2009
     2010  case WM_BUTTON1MOTIONEND:
     2011    {
     2012      CNRINFO cnri;
     2013
     2014      memset(&cnri, 0, sizeof(CNRINFO));
     2015      cnri.cb = sizeof(CNRINFO);
     2016      if (WinSendMsg(hwnd,
     2017                     CM_QUERYCNRINFO,
     2018                     MPFROMP(&cnri), MPFROMLONG(sizeof(CNRINFO)))) {
     2019        if (cnri.flWindowAttr & CV_DETAIL)
     2020          PrfWriteProfileData(fmprof,
     2021                              appname,
     2022                              "ArcCnrSplitBar",
     2023                              (PVOID) & cnri.xVertSplitbar, sizeof(LONG));
     2024      }
     2025    }
     2026    break;
     2027
     2028  case WM_PRESPARAMCHANGED:
     2029    PresParamChanged(hwnd, "ArcCnr", mp1, mp2);
     2030    break;
     2031
     2032  case UM_UPDATERECORD:
     2033  case UM_UPDATERECORDLIST:
     2034    if (dcd && !IsArcThere(hwnd, dcd->arcname))
     2035      PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
     2036    return 0;
     2037
     2038  case WM_SETFOCUS:
     2039    /*
     2040     * put name of our window (archive name) on status line
     2041     */
     2042    if (dcd && hwndStatus && mp2)
     2043      WinSendMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
     2044    break;
     2045
     2046  case UM_SETUP2:
     2047    if (dcd && dcd->info) {
     2048      if (dcd->info->fdpos == -1 || !dcd->info->datetype)
     2049        dcd->sortFlags &= (~SORT_LWDATE);
     2050      if (dcd->info->nsizepos == -1)
     2051        dcd->sortFlags &= (~SORT_EASIZE);
     2052      if (dcd->info->osizepos == -1)
     2053        dcd->sortFlags &= (~SORT_SIZE);
     2054      AdjustCnrColVis(hwnd,
     2055                      GetPString(IDS_OLDSIZECOLTEXT),
     2056                      dcd->info->osizepos != -1, FALSE);
     2057      AdjustCnrColVis(hwnd,
     2058                      GetPString(IDS_NEWSIZECOLTEXT),
     2059                      dcd->info->nsizepos != -1, FALSE);
     2060      // Display unsullied date/time string if type 0
     2061      AdjustCnrColVis(hwnd,
     2062                      GetPString(IDS_DATETIMECOLTEXT),
     2063                      dcd->info->fdpos != -1 && !dcd->info->datetype, FALSE);
     2064      // Display parsed date/time columns if type specified
     2065      AdjustCnrColVis(hwnd,
     2066                      GetPString(IDS_TIMECOLTEXT),
     2067                      dcd->info->fdpos != -1 && dcd->info->datetype, FALSE);
     2068      AdjustCnrColVis(hwnd,
     2069                      GetPString(IDS_DATECOLTEXT),
     2070                      dcd->info->fdpos != -1 && dcd->info->datetype, FALSE);
     2071      WinSendMsg(hwnd, CM_INVALIDATEDETAILFIELDINFO, MPVOID, MPVOID);
     2072    }
     2073    return 0;
     2074
     2075  case UM_RESCAN:
     2076    if (dcd) {
     2077      CNRINFO cnri;
     2078      CHAR s[CCHMAXPATH * 2], tb[81], tf[81];
     2079      PARCITEM pci;
     2080
     2081      if (mp1) {
     2082        PostMsg(dcd->hwndObject, UM_RESCAN, MPVOID, MPVOID);
     2083        return 0;
     2084      }
     2085      memset(&cnri, 0, sizeof(CNRINFO));
     2086      cnri.cb = sizeof(CNRINFO);
     2087      WinSendMsg(hwnd,
     2088                 CM_QUERYCNRINFO,
     2089                 MPFROMP(&cnri), MPFROMLONG(sizeof(CNRINFO)));
     2090      dcd->totalfiles = cnri.cRecords;
     2091      commafmt(tf, sizeof(tf), dcd->selectedfiles);
     2092      if (dcd->ullTotalBytes)
     2093        CommaFmtULL(tb, sizeof(tb), dcd->selectedbytes, 'K');
     2094      else
     2095        *tb = 0;
     2096      sprintf(s, "%s%s%s", tf, *tb ? " / " : NullStr, tb);
     2097      WinSetDlgItemText(dcd->hwndClient, DIR_SELECTED, s);
     2098      commafmt(tf, sizeof(tf), dcd->totalfiles);
     2099      if (dcd->ullTotalBytes)
     2100        CommaFmtULL(tb, sizeof(tb), dcd->ullTotalBytes, 'K');
     2101      else
     2102        *tb = 0;
     2103      sprintf(s, "%s%s%s", tf, *tb ? " / " : NullStr, tb);
     2104      WinSetDlgItemText(dcd->hwndClient, DIR_TOTALS, s);
     2105      if (hwndStatus &&
     2106          dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent)) {
     2107        sprintf(s, " [%s%s%s]%s%s%s  %s",
     2108                tf,
     2109                *tb ? " / " : NullStr,
     2110                tb,
     2111                (*dcd->mask.szMask) ? " (" : NullStr,
     2112                (*dcd->mask.szMask) ? dcd->mask.szMask : NullStr,
     2113                (*dcd->mask.szMask) ? ")" : NullStr, dcd->arcname);
     2114        WinSetWindowText(hwndStatus, s);
     2115        if (!ParentIsDesktop(hwnd, dcd->hwndParent)) {
     2116          pci = WinSendMsg(hwnd,
     2117                           CM_QUERYRECORDEMPHASIS,
     2118                           MPFROMLONG(CMA_FIRST), MPFROMSHORT(CRA_CURSORED));
     2119          if (pci && (INT) pci != -1) {
     2120            if (fSplitStatus && hwndStatus2) {
     2121              if (dcd->ullTotalBytes)
     2122                CommaFmtULL(tb, sizeof(tb), pci->cbFile, ' ');
     2123              else
     2124                *tb = 0;
     2125              sprintf(s, "%s%s%s%s",
     2126                      *tb ? " " : NullStr,
     2127                      tb, *tb ? "  " : NullStr, pci->szFileName);
     2128              WinSetWindowText(hwndStatus2, s);
     2129            }
     2130            if (fMoreButtons)
     2131              WinSetWindowText(hwndName, pci->szFileName);
     2132          }
     2133          else {
     2134            WinSetWindowText(hwndStatus2, NullStr);
     2135            WinSetWindowText(hwndName, NullStr);
     2136          }
     2137          WinSetWindowText(hwndDate, NullStr);
     2138          WinSetWindowText(hwndAttr, NullStr);
     2139        }
     2140      }
     2141      if ((dcd->arcfilled &&
     2142           !dcd->totalfiles) || !IsArcThere(hwnd, dcd->arcname))
     2143        PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
     2144    }
     2145    return 0;
     2146
     2147  case UM_SETUP:
     2148    if (!dcd) {
     2149      Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
     2150      PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
     2151      return 0;
     2152    }
     2153    else {
     2154      if (!dcd->hwndObject) {
     2155        /*
     2156         * first time through -- set things up
     2157         */
     2158        {
     2159          CHAR *p, *pp;
     2160          ULONG z, was;
     2161          APIRET rc;
     2162
     2163          rc = DosCreateDir(dcd->workdir, 0);
     2164          if (rc) {
     2165            if (rc == ERROR_ACCESS_DENIED) {
     2166              p = strrchr(dcd->workdir, '.');
     2167              if (p) {
     2168                p++;
     2169                pp = p;
     2170                was = strtoul(p, &pp, 16);
     2171                for (z = 0; z < 99; z++) {
     2172                  was++;
     2173                  sprintf(p, "%03x");
     2174                  rc = DosCreateDir(dcd->workdir, 0);
     2175                  if (!rc || rc != ERROR_ACCESS_DENIED)
     2176                    break;
     2177                }
     2178              }
     2179            }
     2180            if (rc)
     2181              PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
     2182            return 0;
     2183          }
     2184        }
     2185        RestorePresParams(hwnd, "ArcCnr");
     2186        dcd->mask.fNoAttribs = TRUE;
     2187        dcd->mask.fNoDirs = TRUE;
     2188        *dcd->mask.prompt = 0;
     2189        {
     2190          PFIELDINFO pfi, pfiLastLeftCol;
     2191          ULONG numcols = CON_COLS;
     2192          CNRINFO cnri;
     2193          ULONG size;
     2194
     2195          pfi = WinSendMsg(hwnd,
     2196                           CM_ALLOCDETAILFIELDINFO,
     2197                           MPFROMLONG(numcols), NULL);
     2198          if (pfi) {
     2199
     2200            PFIELDINFO pfiFirst;
     2201            FIELDINFOINSERT fii;
     2202
     2203            pfiFirst = pfi;
     2204            pfi->flData = CFA_STRING | CFA_LEFT | CFA_FIREADONLY;
     2205            pfi->flTitle = CFA_CENTER;
     2206            pfi->pTitleData = GetPString(IDS_FILENAMECOLTEXT);
     2207            pfi->offStruct = FIELDOFFSET(ARCITEM, pszFileName);
     2208            pfiLastLeftCol = pfi;
     2209            pfi = pfi->pNextFieldInfo;
     2210            pfi->flData =
     2211              CFA_ULONG | CFA_RIGHT | CFA_SEPARATOR | CFA_FIREADONLY;
     2212            pfi->flTitle = CFA_CENTER;
     2213            pfi->pTitleData = GetPString(IDS_OLDSIZECOLTEXT);
     2214            pfi->offStruct = FIELDOFFSET(ARCITEM, cbFile);
     2215            pfi = pfi->pNextFieldInfo;
     2216            pfi->flData =
     2217              CFA_ULONG | CFA_RIGHT | CFA_SEPARATOR | CFA_FIREADONLY;
     2218            pfi->flTitle = CFA_CENTER;
     2219            pfi->pTitleData = GetPString(IDS_NEWSIZECOLTEXT);
     2220            pfi->offStruct = FIELDOFFSET(ARCITEM, cbComp);
     2221            pfi = pfi->pNextFieldInfo;
     2222            pfi->flData =
     2223              CFA_STRING | CFA_CENTER | CFA_SEPARATOR | CFA_FIREADONLY;
     2224            pfi->flTitle = CFA_CENTER | CFA_FITITLEREADONLY;
     2225            pfi->pTitleData = GetPString(IDS_DATETIMECOLTEXT);
     2226            pfi->offStruct = FIELDOFFSET(ARCITEM, pszDate);
     2227            pfi = pfi->pNextFieldInfo;
     2228            pfi->flData = CFA_DATE | CFA_RIGHT | CFA_FIREADONLY;
     2229            pfi->flTitle = CFA_CENTER;
     2230            pfi->pTitleData = GetPString(IDS_DATECOLTEXT);
     2231            pfi->offStruct = FIELDOFFSET(ARCITEM, date);
     2232            pfi = pfi->pNextFieldInfo;
     2233            pfi->flData = CFA_TIME | CFA_RIGHT | CFA_FIREADONLY;
     2234            pfi->flTitle = CFA_CENTER | CFA_FITITLEREADONLY;
     2235            pfi->pTitleData = GetPString(IDS_TIMECOLTEXT);
     2236            pfi->offStruct = FIELDOFFSET(ARCITEM, time);
     2237            memset(&fii, 0, sizeof(FIELDINFOINSERT));
     2238            fii.cb = sizeof(FIELDINFOINSERT);
     2239            fii.pFieldInfoOrder = (PFIELDINFO) CMA_FIRST;
     2240            fii.cFieldInfoInsert = (SHORT) numcols;
     2241            fii.fInvalidateFieldInfo = TRUE;
     2242            WinSendMsg(hwnd,
     2243                       CM_INSERTDETAILFIELDINFO,
     2244                       MPFROMP(pfiFirst), MPFROMP(&fii));
     2245            PostMsg(hwnd, UM_SETUP2, MPVOID, MPVOID);
     2246
     2247            memset(&cnri, 0, sizeof(cnri));
     2248            cnri.cb = sizeof(CNRINFO);
     2249            cnri.pFieldInfoLast = pfiLastLeftCol;
     2250            cnri.xVertSplitbar = DIR_SPLITBAR_OFFSET + 32;
     2251
     2252            size = sizeof(LONG);
     2253            PrfQueryProfileData(fmprof, appname, "ArcCnrSplitBar",
     2254                                &cnri.xVertSplitbar, &size);
     2255            if (cnri.xVertSplitbar <= 0)
     2256              cnri.xVertSplitbar = DIR_SPLITBAR_OFFSET + 32;
     2257
     2258            cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT | CV_NAME));
     2259            cnri.flWindowAttr |= (CV_DETAIL | CA_DETAILSVIEWTITLES | CV_FLOW);
     2260            cnri.flWindowAttr &= (~(CA_ORDEREDTARGETEMPH |
     2261                                    CA_MIXEDTARGETEMPH));
     2262            cnri.pSortRecord = (PVOID) ArcSort;
     2263            WinSendMsg(hwnd,
     2264                       CM_SETCNRINFO,
     2265                       MPFROMP(&cnri),
     2266                       MPFROMLONG(CMA_PFIELDINFOLAST |
     2267                                  CMA_XVERTSPLITBAR |
     2268                                  CMA_PSORTRECORD | CMA_FLWINDOWATTR));
     2269          }
     2270        }
     2271        WinSendMsg(hwnd, CM_SORTRECORD, MPFROMP(ArcSort), MPFROMP(dcd));
     2272        if (_beginthread(MakeObjWin, NULL, 245760, (PVOID) dcd) == -1) {
     2273          Runtime_Error(pszSrcFile, __LINE__,
     2274                        GetPString(IDS_COULDNTSTARTTHREADTEXT));
     2275          PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
     2276          return 0;
     2277        }
     2278        else
     2279          DosSleep(1L);
     2280        SayFilter(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
     2281                                  DIR_FILTER), &dcd->mask, TRUE);
     2282        SaySort(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
     2283                                DIR_SORT), dcd->sortFlags, TRUE);
     2284        DefArcSortFlags = dcd->sortFlags;       // Remember for new windows
     2285      }
     2286    }
     2287    return 0;
     2288
     2289  case UM_SETDIR:
     2290    if (dcd) {
     2291
     2292      CHAR s[CCHMAXPATH], *p;
     2293      ULONG ret = 0;
     2294
     2295      WinQueryDlgItemText(dcd->hwndClient, ARC_EXTRACTDIR, CCHMAXPATH, s);
     2296      bstrip(s);
     2297      MakeFullName(s);
     2298      if (*s) {
     2299        while ((p = strchr(s, '/')) != NULL)
     2300          *p = '\\';
     2301        while (strlen(s) > 3 && s[strlen(s) - 1] == '\\')
     2302          s[strlen(s) - 1] = 0;
     2303        if (stricmp(s, dcd->directory)) {
     2304          if (IsFullName(s)) {
     2305            if (driveflags[toupper(*s) - 'A'] &
     2306                (DRIVE_NOTWRITEABLE | DRIVE_IGNORE | DRIVE_INVALID)) {
     2307              Runtime_Error(pszSrcFile, __LINE__, "drive %s bad", s);
     2308              WinSetDlgItemText(dcd->hwndClient,
     2309                                ARC_EXTRACTDIR, dcd->directory);
     2310              return 0;
     2311            }
     2312          }
     2313          if (!SetDir(dcd->hwndParent, hwnd, s, 0)) {
     2314            if (stricmp(dcd->directory, s)) {
     2315              DosEnterCritSec();
     2316              strcpy(lastextractpath, s);
     2317              DosExitCritSec();
     2318            }
     2319            strcpy(dcd->directory, s);
     2320            if ((!isalpha(*s) || s[1] != ':') && *s != '.')
     2321              saymsg(MB_ENTER | MB_ICONASTERISK,
     2322                     hwnd,
     2323                     GetPString(IDS_WARNINGTEXT),
     2324                     GetPString(IDS_SPECIFYDRIVETEXT));
     2325          }
     2326          else
     2327            ret = 1;
     2328        }
     2329      }
     2330      WinSetDlgItemText(dcd->hwndClient, ARC_EXTRACTDIR, dcd->directory);
     2331      return (MRESULT) ret;
     2332    }
     2333    return 0;
     2334
     2335  case UM_ENTER:
     2336    if (WinSendMsg(hwnd, UM_SETDIR, MPVOID, MPVOID))
     2337      return 0;
     2338    SetShiftState();
     2339    if (dcd && (CHAR *) mp1) {
     2340
     2341      SWP swp;
     2342      CHAR *filename = mp1;
     2343
     2344      if (IsFile(filename) != 1)
     2345        return 0;
     2346      WinQueryWindowPos(dcd->hwndFrame, &swp);
     2347      DefaultViewKeys(hwnd, dcd->hwndFrame, dcd->hwndParent, &swp, filename);
     2348      if (fUnHilite)
     2349        UnHilite(hwnd, FALSE, &dcd->lastselection);
     2350    }
     2351    return 0;
     2352
     2353  case WM_MENUEND:
     2354    if (dcd) {
     2355
     2356      HWND hwndMenu = (HWND) mp2;
     2357
     2358      if (hwndMenu == ArcCnrMenu || hwndMenu == ArcMenu) {
     2359        MarkAll(hwnd, TRUE, FALSE, TRUE);
     2360        if (dcd->cnremphasized) {
     2361          WinSendMsg(hwnd,
     2362                     CM_SETRECORDEMPHASIS,
     2363                     MPVOID, MPFROM2SHORT(FALSE, CRA_SOURCE));
     2364          dcd->cnremphasized = FALSE;
     2365        }
     2366      }
     2367    }
     2368    break;
     2369
     2370  case MM_PORTHOLEINIT:
     2371    if (dcd) {
     2372      switch (SHORT1FROMMP(mp1)) {
     2373      case 0:
     2374      case 1:
     2375        {
     2376          ULONG wmsg;
     2377
     2378          wmsg = (SHORT1FROMMP(mp1) == 0) ? UM_FILESMENU : UM_VIEWSMENU;
     2379          PortholeInit((HWND) WinSendMsg(dcd->hwndClient,
     2380                                         wmsg, MPVOID, MPVOID), mp1, mp2);
     2381        }
     2382        break;
     2383      }
     2384    }
     2385    break;
     2386
     2387  case UM_INITMENU:
     2388  case WM_INITMENU:
     2389    if (dcd) {
     2390      switch (SHORT1FROMMP(mp1)) {
     2391      case IDM_FILESMENU:
     2392        if (dcd->info) {
     2393          WinEnableMenuItem((HWND) mp2,
     2394                            IDM_DELETE, dcd->info->delete != NULL);
     2395          WinEnableMenuItem((HWND) mp2, IDM_TEST, dcd->info->test != NULL);
     2396          WinEnableMenuItem((HWND) mp2,
     2397                            IDM_EXTRACT, dcd->info->extract != NULL);
     2398          WinEnableMenuItem((HWND) mp2,
     2399                            IDM_EXTRACTWDIRS, dcd->info->exwdirs != NULL);
     2400          WinEnableMenuItem((HWND) mp2,
     2401                            IDM_ARCEXTRACTWDIRS, dcd->info->exwdirs != NULL);
     2402          WinEnableMenuItem((HWND) mp2,
     2403                            IDM_ARCEXTRACTWDIRSEXIT,
     2404                            dcd->info->exwdirs != NULL);
     2405        }
     2406        break;
     2407
     2408      case IDM_VIEWSMENU:
     2409        WinCheckMenuItem((HWND) mp2,
     2410                         IDM_MINIICONS, ((dcd->flWindowAttr & CV_MINI) != 0));
     2411        WinEnableMenuItem((HWND) mp2,
     2412                          IDM_RESELECT, (dcd->lastselection != NULL));
     2413        break;
     2414
     2415      case IDM_COMMANDSMENU:
     2416        SetupCommandMenu((HWND) mp2, hwnd);
     2417        break;
     2418
     2419      case IDM_SORTSUBMENU:
     2420        SetSortChecks((HWND) mp2, dcd->sortFlags);
     2421        break;
     2422
     2423      case IDM_WINDOWSMENU:
     2424        /*
     2425         * add switchlist entries to end of pulldown menu
     2426         */
     2427        SetupWinList((HWND) mp2,
     2428                     (hwndMain) ? hwndMain : (HWND) 0, dcd->hwndFrame);
     2429        break;
     2430      }
     2431      dcd->hwndLastMenu = (HWND) mp2;
     2432    }
     2433    if (msg == WM_INITMENU)
     2434      break;
     2435    return 0;
     2436
     2437  case UM_LOADFILE:
     2438    if (dcd && mp2) {
     2439
     2440      HWND ret;
     2441
     2442      ret = StartMLEEditor(dcd->hwndParent,
     2443                           (INT) mp1, (CHAR *) mp2, dcd->hwndFrame);
     2444      free((CHAR *) mp2);
     2445      return MRFROMLONG(ret);
     2446    }
     2447    return 0;
     2448
     2449  case UM_COMMAND:
     2450    if (mp1) {
    11892451      if (dcd) {
    1190 
    1191         LISTINFO    *li;
    1192         CNRDRAGINFO cni;
    1193 
    1194         cni.pRecord = NULL;
    1195         cni.pDragInfo = (PDRAGINFO)mp1;
    1196         li = DoFileDrop(dcd->hwndCnr,
    1197                         dcd->directory,
    1198                         FALSE,
    1199                         MPVOID,
    1200                         MPFROMP(&cni));
    1201         if (li) {
    1202           li->type = (msg == DM_DISCARDOBJECT) ?
    1203                       IDM_DELETE :
    1204                       IDM_PRINT;
    1205           if (!li->list ||
    1206              !li->list[0] ||
    1207              !PostMsg(hwnd,UM_ACTION,MPFROMP(li),MPVOID))
    1208             FreeListInfo(li);
    1209           else
    1210             return MRFROMLONG(DRR_SOURCE);
    1211         }
    1212       }
    1213       return MRFROMLONG(DRR_TARGET);
    1214 
    1215     case DM_RENDERPREPARE:
    1216       return (MRESULT)TRUE;
    1217 
    1218     case DM_RENDER:
    1219       dcd = WinQueryWindowPtr(hwnd,QWL_USER);
    1220       if (dcd && dcd->info && dcd->info->extract && dcd->arcname) {
    1221 
    1222         PDRAGTRANSFER  pdt = (PDRAGTRANSFER)mp1;
    1223         CHAR           filename[CCHMAXPATH];
    1224         ULONG          len;
    1225 
    1226         if (pdt->hwndClient && pdt->pditem && pdt->hstrSelectedRMF &&
    1227            pdt->hstrRenderToName)
    1228         {
    1229           if (pdt->usOperation == DO_COPY || pdt->usOperation == DO_MOVE) {
    1230             *filename = 0;
    1231             len = DrgQueryStrName(pdt->hstrSelectedRMF,CCHMAXPATH,filename);
    1232             filename[len] = 0;
    1233             if (!strnicmp(filename,"OS2FILE,",8)) {
    1234               // saymsg(MB_ENTER,HWND_DESKTOP,DEBUG_STRING,"RMF = \"%s\"",filename);
    1235             }
     2452        if (!PostMsg(dcd->hwndObject, UM_COMMAND, mp1, mp2)) {
     2453          Runtime_Error(pszSrcFile, __LINE__, "post");
     2454          FreeListInfo((LISTINFO *) mp1);
     2455        }
     2456        else
     2457          return (MRESULT) TRUE;
     2458      }
     2459      else
     2460        FreeListInfo((LISTINFO *) mp1);
     2461    }
     2462    return 0;
     2463
     2464  case UM_OPENWINDOWFORME:
     2465    if (dcd) {
     2466      if (mp1 && !IsFile((CHAR *) mp1)) {
     2467        OpenDirCnr((HWND) 0, hwndMain, dcd->hwndFrame, FALSE, (char *)mp1);
     2468      }
     2469      else if (mp1 && IsFile(mp1) == 1) {
     2470        StartArcCnr(HWND_DESKTOP,
     2471                    dcd->hwndFrame, (CHAR *) mp1, 4, (ARC_TYPE *) mp2);
     2472      }
     2473    }
     2474    return 0;
     2475
     2476  case WM_COMMAND:
     2477    DosError(FERR_DISABLEHARDERR);
     2478    if (dcd) {
     2479      if (SwitchCommand(dcd->hwndLastMenu, SHORT1FROMMP(mp1)))
     2480        return 0;
     2481      if (WinSendMsg(hwnd, UM_SETDIR, MPVOID, MPVOID))
     2482        return 0;
     2483      if (!IsArcThere(hwnd, dcd->arcname)) {
     2484        PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
     2485        return 0;
     2486      }
     2487      switch (SHORT1FROMMP(mp1)) {
     2488      case IDM_TREEVIEW:
     2489
     2490        break;
     2491
     2492      case IDM_CONTEXTMENU:
     2493        {
     2494          PCNRITEM pci;
     2495
     2496          pci = (PCNRITEM) CurrentRecord(hwnd);
     2497          PostMsg(hwnd,
     2498                  WM_CONTROL,
     2499                  MPFROM2SHORT(ARC_CNR, CN_CONTEXTMENU), MPFROMP(pci));
     2500        }
     2501        break;
     2502
     2503      case IDM_NEXTWINDOW:
     2504      case IDM_PREVWINDOW:
     2505        {
     2506          HWND hwndActive;
     2507
     2508          hwndActive = WinQueryFocus(HWND_DESKTOP);
     2509          WinSetFocus(HWND_DESKTOP,
     2510                      ((hwndActive == hwnd) ?
     2511                       WinWindowFromID(dcd->hwndClient, ARC_EXTRACTDIR) :
     2512                       hwnd));
     2513        }
     2514        break;
     2515
     2516      case IDM_FOLDERAFTEREXTRACT:
     2517        fFolderAfterExtract = (fFolderAfterExtract) ? FALSE : TRUE;
     2518        PrfWriteProfileData(fmprof, appname, "FolderAfterExtract",
     2519                            &fFolderAfterExtract, sizeof(BOOL));
     2520        break;
     2521
     2522      case IDM_SHOWSELECT:
     2523        QuickPopup(hwnd, dcd, CheckMenu(&ArcCnrMenu, ARCCNR_POPUP),
     2524                   IDM_SELECTSUBMENU);
     2525        break;
     2526
     2527      case IDM_SHOWSORT:
     2528        QuickPopup(hwnd, dcd, CheckMenu(&ArcCnrMenu, ARCCNR_POPUP),
     2529                   IDM_SORTSUBMENU);
     2530        break;
     2531
     2532      case IDM_NOTEBOOK:
     2533        if (!ParentIsDesktop(dcd->hwndParent, dcd->hwndParent))
     2534          PostMsg(dcd->hwndParent, msg, mp1, mp2);
     2535        else
     2536          WinDlgBox(HWND_DESKTOP,
     2537                    hwnd,
     2538                    CfgDlgProc, FM3ModHandle, CFG_FRAME, (PVOID) "Archive");
     2539        break;
     2540
     2541      case IDM_RESCAN:
     2542        dcd->ullTotalBytes = dcd->totalfiles =
     2543          dcd->selectedfiles = dcd->selectedbytes = 0;
     2544        WinSetDlgItemText(dcd->hwndClient, DIR_TOTALS, "0");
     2545        WinSetDlgItemText(dcd->hwndClient, DIR_SELECTED, "0 / 0k");
     2546        dcd->totalfiles = FillArcCnr(dcd->hwndCnr,
     2547                                     dcd->arcname,
     2548                                     &dcd->info,
     2549                                     &dcd->ullTotalBytes, &dcd->stopflag);
     2550        PostMsg(dcd->hwndCnr, UM_RESCAN, MPVOID, MPVOID);
     2551        PostMsg(dcd->hwndCnr, UM_SETUP2, MPVOID, MPVOID);
     2552        WinSendMsg(dcd->hwndCnr,
     2553                   CM_INVALIDATERECORD,
     2554                   MPVOID, MPFROM2SHORT(0, CMA_ERASE | CMA_REPOSITION));
     2555        break;
     2556
     2557      case IDM_RESELECT:
     2558        SelectList(hwnd, TRUE, FALSE, FALSE, NULL, NULL, dcd->lastselection);
     2559        break;
     2560
     2561      case IDM_HELP:
     2562        if (hwndHelp)
     2563          WinSendMsg(hwndHelp,
     2564                     HM_DISPLAY_HELP,
     2565                     MPFROM2SHORT(HELP_ARCLIST, 0),
     2566                     MPFROMSHORT(HM_RESOURCEID));
     2567        break;
     2568
     2569      case IDM_WINDOWDLG:
     2570        if (!ParentIsDesktop(dcd->hwndParent, dcd->hwndFrame))
     2571          PostMsg(dcd->hwndParent,
     2572                  UM_COMMAND, MPFROM2SHORT(IDM_WINDOWDLG, 0), MPVOID);
     2573        break;
     2574
     2575      case IDM_SELECTALL:
     2576      case IDM_SELECTALLFILES:
     2577      case IDM_DESELECTALL:
     2578      case IDM_DESELECTALLFILES:
     2579      case IDM_SELECTMASK:
     2580      case IDM_DESELECTMASK:
     2581      case IDM_INVERT:
     2582        {
     2583          PARCITEM pci;
     2584
     2585          pci = (PARCITEM) WinSendMsg(hwnd,
     2586                                      CM_QUERYRECORDEMPHASIS,
     2587                                      MPFROMLONG(CMA_FIRST),
     2588                                      MPFROMSHORT(CRA_CURSORED));
     2589          if ((INT) pci == -1)
     2590            pci = NULL;
     2591          if (SHORT1FROMMP(mp1) == IDM_HIDEALL) {
     2592            if (pci) {
     2593              if (!(pci->rc.flRecordAttr & CRA_SELECTED))
     2594                pci->rc.flRecordAttr |= CRA_FILTERED;
     2595              WinSendMsg(hwnd,
     2596                         CM_INVALIDATERECORD,
     2597                         MPFROMP(&pci),
     2598                         MPFROM2SHORT(1, CMA_ERASE | CMA_REPOSITION));
     2599              break;
     2600            }
     2601          }
     2602          PostMsg(dcd->hwndObject, UM_SELECT, mp1, MPFROMP(pci));
     2603        }
     2604        break;
     2605
     2606      case IDM_SORTSMARTNAME:
     2607      case IDM_SORTNAME:
     2608      case IDM_SORTFILENAME:
     2609      case IDM_SORTSIZE:
     2610      case IDM_SORTEASIZE:
     2611      case IDM_SORTFIRST:
     2612      case IDM_SORTLAST:
     2613      case IDM_SORTLWDATE:
     2614        dcd->sortFlags &= SORT_REVERSE;
     2615        /* intentional fallthru */
     2616      case IDM_SORTREVERSE:
     2617        switch (SHORT1FROMMP(mp1)) {
     2618        case IDM_SORTSMARTNAME:
     2619        case IDM_SORTFILENAME:
     2620          dcd->sortFlags |= SORT_FILENAME;
     2621          break;
     2622        case IDM_SORTSIZE:
     2623          dcd->sortFlags |= SORT_SIZE;
     2624          break;
     2625        case IDM_SORTEASIZE:
     2626          dcd->sortFlags |= SORT_EASIZE;
     2627          break;
     2628        case IDM_SORTFIRST:
     2629          dcd->sortFlags |= SORT_FIRSTEXTENSION;
     2630          break;
     2631        case IDM_SORTLAST:
     2632          dcd->sortFlags |= SORT_LASTEXTENSION;
     2633          break;
     2634        case IDM_SORTLWDATE:
     2635          dcd->sortFlags |= SORT_LWDATE;
     2636          break;
     2637        case IDM_SORTREVERSE:
     2638          if (dcd->sortFlags & SORT_REVERSE)
     2639            dcd->sortFlags &= (~SORT_REVERSE);
     2640          else
     2641            dcd->sortFlags |= SORT_REVERSE;
     2642          break;
     2643        }
     2644        WinSendMsg(hwnd, CM_SORTRECORD, MPFROMP(ArcSort), MPFROMP(dcd));
     2645        SaySort(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
     2646                                DIR_SORT), dcd->sortFlags, TRUE);
     2647        DefArcSortFlags = dcd->sortFlags;       // Remember for new windows
     2648        break;
     2649
     2650      case IDM_COLLECTOR:
     2651        if (!Collector) {
     2652          HWND hwndC;
     2653          SWP swp;
     2654
     2655          if (ParentIsDesktop(hwnd, dcd->hwndParent) && !fAutoTile &&
     2656              (!fExternalCollector && !strcmp(realappname, FM3Str)))
     2657            GetNextWindowPos(dcd->hwndParent, &swp, NULL, NULL);
     2658          hwndC = StartCollector((fExternalCollector ||
     2659                                  strcmp(realappname, FM3Str)) ?
     2660                                 HWND_DESKTOP : dcd->hwndParent, 4);
     2661          if (hwndC) {
     2662            if (!ParentIsDesktop(hwnd, dcd->hwndParent) && !fAutoTile &&
     2663                (!fExternalCollector && !strcmp(realappname, FM3Str)))
     2664              WinSetWindowPos(hwndC,
     2665                              HWND_TOP,
     2666                              swp.x,
     2667                              swp.y,
     2668                              swp.cx,
     2669                              swp.cy,
     2670                              SWP_MOVE | SWP_SIZE | SWP_SHOW | SWP_ZORDER);
     2671            else if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
     2672                     fAutoTile && !strcmp(realappname, FM3Str)) {
     2673              TileChildren(dcd->hwndParent, TRUE);
     2674            }
     2675            WinSetWindowPos(hwndC, HWND_TOP, 0, 0, 0, 0, SWP_ACTIVATE);
     2676            DosSleep(128L);
     2677          }
     2678        }
     2679        else
     2680          StartCollector(dcd->hwndParent, 4);
     2681        break;
     2682
     2683      case IDM_ARCEXTRACTEXIT:
     2684      case IDM_ARCEXTRACT:
     2685        if (dcd->info->extract)
     2686          runemf2(SEPARATE | WINDOWED |
     2687                  ((fArcStuffVisible) ? 0 : (BACKGROUND | MINIMIZED)),
     2688                  hwnd, dcd->directory, NULL, "%s %s%s%s",
     2689                  dcd->info->extract,
     2690                  (needs_quoting(dcd->arcname)) ? "\"" : NullStr,
     2691                  dcd->arcname,
     2692                  (needs_quoting(dcd->arcname)) ? "\"" : NullStr);
     2693        if (SHORT1FROMMP(mp1) == IDM_ARCEXTRACTEXIT)
     2694          PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
     2695        break;
     2696
     2697      case IDM_ARCEXTRACTWDIRSEXIT:
     2698      case IDM_ARCEXTRACTWDIRS:
     2699        if (dcd->info->exwdirs)
     2700          runemf2(SEPARATE | WINDOWED |
     2701                  ((fArcStuffVisible) ? 0 : (BACKGROUND | MINIMIZED)),
     2702                  hwnd, dcd->directory, NULL, "%s %s%s%s",
     2703                  dcd->info->exwdirs,
     2704                  (needs_quoting(dcd->arcname)) ? "\"" : NullStr,
     2705                  dcd->arcname,
     2706                  (needs_quoting(dcd->arcname)) ? "\"" : NullStr);
     2707        if (SHORT1FROMMP(mp1) == IDM_ARCEXTRACTWDIRSEXIT)
     2708          PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
     2709        break;
     2710
     2711      case IDM_RESORT:
     2712        WinSendMsg(hwnd, CM_SORTRECORD, MPFROMP(ArcSort), MPFROMP(dcd));
     2713        break;
     2714
     2715      case IDM_FILTER:
     2716        {
     2717          BOOL empty = FALSE;
     2718          PARCITEM pci;
     2719
     2720          if (!*dcd->mask.szMask) {
     2721            empty = TRUE;
     2722            pci = (PARCITEM) CurrentRecord(hwnd);
     2723            if (pci && strchr(pci->szFileName, '.'))
     2724              strcpy(dcd->mask.szMask, pci->szFileName);
     2725          }
     2726
     2727          if (WinDlgBox(HWND_DESKTOP, hwnd, PickMaskDlgProc,
     2728                        FM3ModHandle, MSK_FRAME, MPFROMP(&dcd->mask))) {
     2729            WinSendMsg(hwnd, CM_FILTER, MPFROMP(ArcFilter), MPFROMP(dcd));
     2730            PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
     2731          }
     2732          else if (empty)
     2733            *dcd->mask.szMask = 0;
     2734          SayFilter(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
     2735                                    DIR_FILTER), &dcd->mask, TRUE);
     2736        }
     2737        break;
     2738
     2739      case IDM_SWITCH:
     2740        if (mp2) {
     2741          if (stricmp(dcd->directory, (CHAR *) mp2)) {
     2742            DosEnterCritSec();
     2743            strcpy(lastextractpath, (CHAR *) mp2);
     2744            MakeValidDir(lastextractpath);
     2745            DosExitCritSec();
     2746          }
     2747          strcpy(dcd->directory, (CHAR *) mp2);
     2748          MakeValidDir(dcd->directory);
     2749          WinSetWindowText(dcd->hwndExtract, dcd->directory);
     2750        }
     2751        break;
     2752
     2753      case IDM_WALKDIR:
     2754        {
     2755          CHAR newdir[CCHMAXPATH];
     2756
     2757          strcpy(newdir, dcd->directory);
     2758          if (!WinDlgBox(HWND_DESKTOP, dcd->hwndParent, WalkExtractDlgProc,
     2759                         FM3ModHandle, WALK_FRAME,
     2760                         MPFROMP(newdir)) || !*newdir)
     2761            break;
     2762          if (stricmp(newdir, dcd->directory)) {
     2763            strcpy(dcd->directory, newdir);
     2764            if (stricmp(lastextractpath, newdir))
     2765              strcpy(lastextractpath, newdir);
     2766            WinSetWindowText(dcd->hwndExtract, dcd->directory);
     2767          }
     2768        }
     2769        break;
     2770
     2771      case IDM_TEST:
     2772        if (dcd->info->test)
     2773          runemf2(SEPARATEKEEP | WINDOWED | MAXIMIZED,
     2774                  hwnd, NULL, NULL, "%s %s%s%s", dcd->info->test,
     2775                  (needs_quoting(dcd->arcname)) ? "\"" : NullStr,
     2776                  dcd->arcname,
     2777                  (needs_quoting(dcd->arcname)) ? "\"" : NullStr);
     2778        break;
     2779
     2780      case IDM_REFRESH:
     2781      case IDM_DELETE:
     2782      case IDM_PRINT:
     2783      case IDM_VIEW:
     2784      case IDM_VIEWTEXT:
     2785      case IDM_VIEWBINARY:
     2786      case IDM_VIEWARCHIVE:
     2787      case IDM_EDIT:
     2788      case IDM_EDITTEXT:
     2789      case IDM_EDITBINARY:
     2790      case IDM_EXTRACT:
     2791      case IDM_EXTRACTWDIRS:
     2792      case IDM_FIND:
     2793      case IDM_EXEC:
     2794      case IDM_VIRUSSCAN:
     2795        {
     2796          LISTINFO *li;
     2797
     2798          li = xmallocz(sizeof(LISTINFO), pszSrcFile, __LINE__);
     2799          if (li) {
     2800            li->type = SHORT1FROMMP(mp1);
     2801            li->hwnd = hwnd;
     2802            li->list = BuildArcList(hwnd);
     2803            if (li->type == IDM_REFRESH) {
     2804
     2805              CHAR s[CCHMAXPATH], *p;
     2806              INT x, y;
     2807
     2808              for (x = 0; li->list && li->list[x]; x++) {
     2809                sprintf(s, "%s%s%s", dcd->workdir,
     2810                        (dcd->workdir[strlen(dcd->workdir) - 1] == '\\') ?
     2811                        NullStr : "\\", li->list[x]);
     2812                if (IsFile(s) != 1) {
     2813                  free(li->list[x]);
     2814                  li->list[x] = NULL;
     2815                  for (y = x; li->list[y]; y++)
     2816                    li->list[y] = li->list[y + 1];
     2817                  li->list =
     2818                    xrealloc(li->list, y * sizeof(CHAR *), pszSrcFile,
     2819                             __LINE__);
     2820                  x--;
     2821                }
     2822                else {
     2823                  p = xstrdup(s, pszSrcFile, __LINE__);
     2824                  if (p) {
     2825                    free(li->list[x]);
     2826                    li->list[x] = p;
     2827                  }
     2828                }
     2829              }                         // for
     2830            }
     2831            strcpy(li->arcname, dcd->arcname);
     2832            li->info = dcd->info;
     2833            {
     2834              PARCITEM pai;
     2835
     2836              if (SHORT1FROMMP(mp1) != IDM_EXEC)
     2837                pai = (PARCITEM) CurrentRecord(hwnd);
     2838              else
     2839                pai = (PARCITEM) WinSendMsg(hwnd, CM_QUERYRECORDEMPHASIS,
     2840                                            MPFROMLONG(CMA_FIRST),
     2841                                            MPFROMSHORT(CRA_CURSORED));
     2842              if (pai && (INT) pai != -1)
     2843                strcpy(li->runfile, pai->szFileName);
     2844              else
     2845                strcpy(li->runfile, li->list[0]);
     2846            }
     2847            switch (SHORT1FROMMP(mp1)) {
     2848            case IDM_VIEW:
     2849            case IDM_VIEWTEXT:
     2850            case IDM_VIEWBINARY:
     2851            case IDM_VIEWARCHIVE:
     2852            case IDM_EDIT:
     2853            case IDM_EDITTEXT:
     2854            case IDM_EDITBINARY:
     2855            case IDM_EXEC:
     2856            case IDM_PRINT:
     2857            case IDM_VIRUSSCAN:
     2858              strcpy(li->targetpath, dcd->workdir);
     2859              break;
     2860            default:
     2861              strcpy(li->targetpath, dcd->directory);
     2862              break;
     2863            }
     2864            if (li->list) {
     2865              if (!PostMsg(dcd->hwndObject, UM_ACTION, MPFROMP(li), MPVOID)) {
     2866                Runtime_Error(pszSrcFile, __LINE__, "post");
     2867                FreeListInfo(li);
     2868              }
     2869              else if (fUnHilite && SHORT1FROMMP(mp1) != IDM_EDIT)
     2870                UnHilite(hwnd, TRUE, &dcd->lastselection);
     2871            }
     2872            else
     2873              free(li);
     2874          }
     2875        }
     2876        break;
     2877      }
     2878    }
     2879    return 0;
     2880
     2881  case WM_CONTROL:
     2882    DosError(FERR_DISABLEHARDERR);
     2883    if (dcd) {
     2884      switch (SHORT2FROMMP(mp1)) {
     2885      case CN_BEGINEDIT:
     2886        PostMsg(hwnd, CM_CLOSEEDIT, MPVOID, MPVOID);
     2887        break;
     2888
     2889      case CN_ENDEDIT:
     2890        if (!((PCNREDITDATA) mp2)->pRecord) {
     2891
     2892          PFIELDINFO pfi = ((PCNREDITDATA) mp2)->pFieldInfo;
     2893          USHORT cmd = 0;
     2894
     2895          if (!pfi || pfi->offStruct == FIELDOFFSET(ARCITEM, pszFileName))
     2896            cmd = IDM_SORTSMARTNAME;
     2897          else if (pfi->offStruct == FIELDOFFSET(ARCITEM, cbFile))
     2898            cmd = IDM_SORTSIZE;
     2899          else if (pfi->offStruct == FIELDOFFSET(ARCITEM, cbComp))
     2900            cmd = IDM_SORTEASIZE;
     2901          else if (pfi->offStruct == FIELDOFFSET(ARCITEM, date))
     2902            cmd = IDM_SORTLWDATE;
     2903          else if (pfi->offStruct == FIELDOFFSET(ARCITEM, time))
     2904            cmd = IDM_SORTLWDATE;
     2905          if (cmd)
     2906            PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(cmd, 0), MPVOID);
     2907        }
     2908        break;
     2909
     2910      case CN_DROPHELP:
     2911        saymsg(MB_ENTER, hwnd,
     2912               GetPString(IDS_DROPHELPHDRTEXT),
     2913               GetPString(IDS_ARCCNRDROPHELPTEXT), dcd->arcname);
     2914        return 0;
     2915
     2916      case CN_DRAGLEAVE:
     2917        if (mp2) {
     2918
     2919          PDRAGINFO pDInfo;
     2920
     2921          pDInfo = ((PCNRDRAGINFO) mp2)->pDragInfo;
     2922          DrgAccessDraginfo(pDInfo);    /* Access DRAGINFO       */
     2923          DrgFreeDraginfo(pDInfo);      /* Free DRAGINFO         */
     2924        }
     2925        return 0;
     2926
     2927      case CN_DRAGAFTER:
     2928      case CN_DRAGOVER:
     2929        if (mp2) {
     2930
     2931          PDRAGITEM pDItem;     /* Pointer to DRAGITEM   */
     2932          PDRAGINFO pDInfo;     /* Pointer to DRAGINFO   */
     2933          PARCITEM pci;
     2934
     2935          pci = (PARCITEM) ((PCNRDRAGINFO) mp2)->pRecord;
     2936          if (SHORT1FROMMP(mp1) == CN_DRAGAFTER)
     2937            pci = NULL;
     2938          pDInfo = ((PCNRDRAGINFO) mp2)->pDragInfo;
     2939          DrgAccessDraginfo(pDInfo);    /* Access DRAGINFO       */
     2940          if (*dcd->arcname) {
     2941            if ((driveflags[toupper(*dcd->arcname) - 'A'] &
     2942                 DRIVE_NOTWRITEABLE) || !dcd->info || !dcd->info->create) {
     2943              DrgFreeDraginfo(pDInfo);
     2944              return MRFROM2SHORT(DOR_NEVERDROP, 0);
     2945            }
     2946          }
     2947          if (pci) {
     2948            DrgFreeDraginfo(pDInfo);
     2949            return MRFROM2SHORT(DOR_NODROP, 0);
     2950          }
     2951          pDItem = DrgQueryDragitemPtr(pDInfo,  /* Access DRAGITEM       */
     2952                                       0);      /* Index to DRAGITEM     */
     2953          if (DrgVerifyRMF(pDItem,      /* Check valid rendering */
     2954                           DRM_OS2FILE, /* mechanisms and data   */
     2955                           NULL) && !(pDItem->fsControl & DC_PREPARE)) {
     2956            DrgFreeDraginfo(pDInfo);    /* Free DRAGINFO         */
     2957            return (MRFROM2SHORT(DOR_DROP,      /* Return okay to drop   */
     2958                                 ((fCopyDefault) ? DO_COPY : DO_MOVE)));
     2959          }
     2960          DrgFreeDraginfo(pDInfo);      /* Free DRAGINFO         */
     2961        }
     2962        return (MRFROM2SHORT(DOR_NEVERDROP, 0));        /* Drop not valid        */
     2963
     2964      case CN_INITDRAG:
     2965        if (mp2) {
     2966
     2967          BOOL wasemphasized = FALSE;
     2968          PCNRDRAGINIT pcd = (PCNRDRAGINIT) mp2;
     2969          PARCITEM pci;
     2970
     2971          if (pcd) {
     2972            pci = (PARCITEM) pcd->pRecord;
     2973            if (pci) {
     2974              if (pci->rc.flRecordAttr & CRA_SELECTED)
     2975                wasemphasized = TRUE;
     2976              if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
     2977                  fSplitStatus && hwndStatus2)
     2978                WinSetWindowText(hwndStatus2, GetPString(IDS_DRAGARCMEMTEXT));
     2979              if (DoFileDrag(hwnd,
     2980                             dcd->hwndObject,
     2981                             mp2, dcd->arcname, NULL, TRUE)) {
     2982                if (fUnHilite && wasemphasized)
     2983                  UnHilite(hwnd, TRUE, &dcd->lastselection);
     2984              }
     2985              if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
     2986                  fSplitStatus && hwndStatus2) {
     2987                PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
     2988              }
     2989            }
    12362990            else {
    1237               *filename = 0;
    1238               len = DrgQueryStrName(pdt->hstrRenderToName,CCHMAXPATH,filename);
    1239               filename[len] = 0;
    1240               if (len && *filename) {
    1241                 psz = xstrdup(filename,pszSrcFile,__LINE__);
    1242                 if (psz) {
    1243                   PostMsg(hwnd,UM_RENDER,MPFROMP(pdt),MPFROMP(psz));
    1244                   return (MRESULT)TRUE;
    1245                 }
    1246               }
    1247               else {
    1248                 // saymsg(MB_ENTER,HWND_DESKTOP,DEBUG_STRING,"No render-to name given.");
    1249               }
    1250             }
    1251           }
    1252           pdt->fsReply = DMFL_RENDERRETRY;
    1253         }
    1254       }
    1255       return(MRESULT)FALSE;
    1256 
    1257     case UM_RENDER:
    1258       {
    1259         PDRAGTRANSFER  pdt = (PDRAGTRANSFER)mp1;
    1260         USHORT         usRes = DMFL_RENDERFAIL;
    1261 
    1262         dcd = WinQueryWindowPtr(hwnd,QWL_USER);
    1263         if (dcd && dcd->info && dcd->info->extract && dcd->arcname) {
    1264 
    1265           CHAR          *filename = (CHAR *)mp2,*p;
    1266           ULONG          len;
    1267           CHAR           membername[CCHMAXPATH],construct[CCHMAXPATH * 2];
    1268 
    1269           *membername = 0;
    1270           len = DrgQueryStrName(pdt->pditem->hstrSourceName,
    1271                                 CCHMAXPATH,membername);
    1272           membername[len] = 0;
    1273           if (*membername && len && filename) {
    1274             unlinkf("%s",filename);
    1275             strcpy(construct,filename);
    1276             p = strrchr(filename,'\\');
    1277             if (!p)
    1278               *construct = 0;
    1279             else {
    1280               if (p == filename || *(p - 1) == ':')
    1281                 p++;
    1282               *p = 0;
    1283             }
    1284             // saymsg(MB_ENTER,HWND_DESKTOP,DEBUG_STRING,"%s %s %s\r[%s]",dcd->info->extract,dcd->arcname,membername,construct);
    1285             runemf2(SEPARATE | WINDOWED | WAIT |
    1286                     ((fArcStuffVisible) ? 0 : (BACKGROUND | MINIMIZED)) |
    1287                     WAIT,dcd->hwndClient,construct,NULL,"%s %s%s%s %s%s%s",
    1288                     dcd->info->extract,
    1289                     (needs_quoting(dcd->arcname)) ? "\"" : NullStr,
    1290                     dcd->arcname,
    1291                     (needs_quoting(dcd->arcname)) ? "\"" : NullStr,
    1292                     (needs_quoting(membername)) ? "\"" : NullStr,
    1293                     membername,
    1294                     (needs_quoting(membername)) ? "\"" : NullStr);
    1295             if (*construct && construct[strlen(construct) - 1] != '\\')
    1296               strcat(construct,"\\");
    1297             strcat(construct,membername);
    1298             if (IsFile(construct) != -1) {
    1299               rename(construct,filename);
    1300               unlinkf("%s",construct);
    1301               if (IsFile(filename) != -1)
    1302                 usRes = DMFL_RENDEROK;
    1303             }
    1304           }
    1305         }
    1306         if (mp2)
    1307           free((CHAR *)mp2);
    1308         PostMsg(pdt->hwndClient,DM_RENDERCOMPLETE,MPFROMP(pdt),
    1309                 MPFROM2SHORT(usRes,0));
    1310       }
    1311       return 0;
    1312 
    1313     case UM_SETUP:
    1314       dcd = WinQueryWindowPtr(hwnd,QWL_USER);
    1315       if (!dcd) {
    1316         Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
    1317         PostMsg(hwnd,WM_CLOSE,MPVOID,MPVOID);
    1318       }
    1319       else {
    1320         /* set unique id */
    1321         WinSetWindowUShort(hwnd,QWS_ID,ARCOBJ_FRAME + (ARC_FRAME - dcd->id));
    1322         dcd->hwndObject = hwnd;         // pass back hwnd
    1323         if (ParentIsDesktop(hwnd,dcd->hwndParent))
    1324           DosSleep(250);                // Avoid race?
    1325       }
    1326       return 0;
    1327 
    1328     case UM_RESCAN:
    1329       /*
    1330        * populate container
    1331        */
    1332       dcd = WinQueryWindowPtr(hwnd,QWL_USER);
    1333       if (dcd) {
    1334         if (mp1)
    1335           strcpy(dcd->arcname,(CHAR *)mp1);     // Update name on request
    1336         dcd->ullTotalBytes = dcd->totalfiles =
    1337           dcd->selectedfiles = dcd->selectedbytes = 0;
    1338         WinSetDlgItemText(dcd->hwndClient,DIR_TOTALS,"0");
    1339         WinSetDlgItemText(dcd->hwndClient,DIR_SELECTED,"0 / 0k");
    1340         dcd->totalfiles = FillArcCnr(dcd->hwndCnr,
    1341                                      dcd->arcname,
    1342                                      &dcd->info,
    1343                                      &dcd->ullTotalBytes,
    1344                                      &dcd->stopflag);
    1345         if (!dcd->totalfiles)
    1346           PostMsg(dcd->hwndCnr,WM_CLOSE,MPVOID,MPVOID);
    1347         else {
    1348           dcd->arcfilled = TRUE;
    1349           if (!PostMsg(dcd->hwndCnr,UM_RESCAN,MPVOID,MPVOID))
    1350             WinSendMsg(dcd->hwndCnr,UM_RESCAN,MPVOID,MPVOID);
    1351           PostMsg(dcd->hwndCnr,UM_SETUP2,MPVOID,MPVOID);
    1352           WinSendMsg(dcd->hwndCnr,
    1353                      CM_INVALIDATERECORD,
    1354                      MPVOID,
    1355                      MPFROM2SHORT(0,CMA_ERASE | CMA_REPOSITION));
    1356         }
    1357       }
    1358       return 0;
    1359 
    1360     case UM_SELECT:
    1361       dcd = WinQueryWindowPtr(hwnd,QWL_USER);
    1362       if (dcd) {
    1363         switch(SHORT1FROMMP(mp1)) {
    1364           case IDM_SELECTALL:
    1365           case IDM_SELECTALLFILES:
    1366             SelectAll(dcd->hwndCnr,TRUE,TRUE,NULL,NULL,TRUE);
    1367             break;
    1368           case IDM_DESELECTALL:
    1369           case IDM_DESELECTALLFILES:
    1370             DeselectAll(dcd->hwndCnr,TRUE,TRUE,NULL,NULL,TRUE);
    1371             break;
    1372           case IDM_DESELECTMASK:
    1373           case IDM_SELECTMASK:
    1374             {
    1375               MASK     mask;
    1376               PARCITEM pci = (PARCITEM)mp2;
    1377 
    1378               memset(&mask,0,sizeof(MASK));
    1379               mask.fNoAttribs = TRUE;
    1380               mask.fNoDirs = TRUE;
    1381               strcpy(mask.prompt,
    1382                      GetPString((SHORT1FROMMP(mp1) == IDM_SELECTMASK) ?
    1383                                 IDS_SELECTFILTERTEXT :
    1384                                 IDS_DESELECTFILTERTEXT));
    1385               if (pci && (INT)pci != -1)
    1386                 strcpy(mask.szMask,pci->szFileName);
    1387               if (WinDlgBox(HWND_DESKTOP,dcd->hwndCnr,PickMaskDlgProc,
    1388                            FM3ModHandle,MSK_FRAME,MPFROMP(&mask))) {
    1389                 if (SHORT1FROMMP(mp1) == IDM_SELECTMASK)
    1390                   SelectAll(dcd->hwndCnr,TRUE,TRUE,mask.szMask,NULL,FALSE);
    1391                 else
    1392                   DeselectAll(dcd->hwndCnr,TRUE,TRUE,mask.szMask,NULL,FALSE);
    1393               }
    1394             }
    1395 
    1396           case IDM_INVERT:
    1397             InvertAll(dcd->hwndCnr);
    1398             break;
    1399         }
    1400       }
    1401       return 0;
    1402 
    1403     case UM_ENTER:
    1404       dcd = WinQueryWindowPtr(hwnd,QWL_USER);
    1405       if (dcd) {
    1406 
    1407         CHAR   *s = (CHAR *)mp1,*p,*pp,filename[CCHMAXPATH];
    1408 
    1409         if (s) {
    1410           if (!dcd->info->extract) {
    1411             Runtime_Error(pszSrcFile, __LINE__, "no extract");
    1412             free(s);
    1413             return 0;
    1414           }
    1415           runemf2(SEPARATE | WINDOWED |
    1416                   ((fArcStuffVisible) ? 0 : (BACKGROUND | MINIMIZED)) |
    1417                   WAIT,dcd->hwndClient,dcd->workdir,NULL,"%s %s%s%s %s%s%s",
    1418                   ((dcd->info->exwdirs) ? dcd->info->exwdirs :
    1419                     dcd->info->extract),
    1420                     (needs_quoting(dcd->arcname)) ? "\"" : NullStr,
    1421                     dcd->arcname,
    1422                     (needs_quoting(dcd->arcname)) ? "\"" : NullStr,
    1423                     (needs_quoting(s)) ? "\"" : NullStr,
    1424                     s,
    1425                     (needs_quoting(s)) ? "\"" : NullStr);
    1426 
    1427           if (!dcd->info->exwdirs) {
    1428             p = s;
    1429             p = strrchr(s,'\\');
    1430             pp = strrchr(s,'/');
    1431             if (p && pp)
    1432               p = max(p,pp);
    1433             else if (!p)
    1434               p = pp;
    1435             if (p)
    1436               memmove(s,p + 1,strlen(p + 1));
    1437           }
    1438           sprintf(filename,"%s\\%s",dcd->workdir,s);
    1439           p = filename;
    1440           while(*p) {
    1441             if (*p == '/')
    1442               *p = '\\';
    1443             p++;
    1444           }
    1445           free(s);
    1446           if (IsFile(filename) == 1)
    1447             WinSendMsg(dcd->hwndCnr,UM_ENTER,MPFROMP(filename),MPVOID);
    1448         }
    1449       }
    1450       return 0;
    1451 
    1452     case UM_COMMAND:
    1453       if (mp1) {
    1454         if (PostMsg(hwnd,UM_ACTION,mp1,mp2))
    1455           return (MRESULT)TRUE;
    1456       }
    1457       return 0;
    1458 
    1459     case UM_ACTION:
    1460       DosError(FERR_DISABLEHARDERR);
    1461       dcd = WinQueryWindowPtr(hwnd,QWL_USER);
    1462       if (dcd) {
    1463 
    1464         LISTINFO    *li = (LISTINFO *)mp1;
    1465         register INT x;
    1466 
    1467         if (li && li->list && li->list[0]) {
    1468           switch(li->type) {
    1469             case IDM_ARCHIVE:
    1470             case IDM_ARCHIVEM:
    1471               {
    1472                 DIRCNRDATA  ad;
    1473                 CHAR        szBuffer[1025],*p;
    1474 
    1475                 if (!li->list[1] && !stricmp(li->list[0],dcd->arcname)) {
    1476                   Runtime_Error(pszSrcFile, __LINE__, "arc to self");
    1477                   break;
    1478                 }
    1479                 ad = *dcd;
    1480                 ad.namecanchange = 0;
    1481                 ad.fmoving = (li->type == IDM_ARCHIVEM);
    1482                 if (!WinDlgBox(HWND_DESKTOP,dcd->hwndClient,
    1483                               ArchiveDlgProc,FM3ModHandle,
    1484                               ARCH_FRAME,(PVOID)&ad) ||
    1485                               !*ad.arcname ||
    1486                               !*ad.command) /* we blew it */
    1487                   break;
    1488                 /* build the sucker */
    1489                 strcpy(szBuffer,ad.command);
    1490                 strcat(szBuffer," ");
    1491                 if (needs_quoting(ad.arcname))
    1492                   strcat(szBuffer,"\"");
    1493                 strcat(szBuffer,ad.arcname);
    1494                 if (needs_quoting(ad.arcname))
    1495                   strcat(szBuffer,"\"");
    1496                 p = &szBuffer[strlen(szBuffer)];
    1497                 if (ad.mask.szMask) {
    1498                   strcat(szBuffer," ");
    1499                   if (needs_quoting(ad.mask.szMask))
    1500                     strcat(szBuffer,"\"");
    1501                   strcat(szBuffer,ad.mask.szMask);
    1502                   if (needs_quoting(ad.mask.szMask))
    1503                     strcat(szBuffer,"\"");
    1504                 }
    1505                 strcat(szBuffer," ");
    1506                 x = 0;
    1507                 while(li->list[x]) {
    1508                   if (needs_quoting(li->list[x]))
    1509                     strcat(szBuffer,"\"");
    1510                   strcat(szBuffer,li->list[x]);
    1511                   if (!IsFile(li->list[x])) {
    1512                     if (szBuffer[strlen(szBuffer) - 1] != '\\')
    1513                       strcat(szBuffer,"\\");
    1514                     strcat(szBuffer,"*");
    1515                   }
    1516                   if (needs_quoting(li->list[x]))
    1517                     strcat(szBuffer,"\"");
    1518                   x++;
    1519                   if (!li->list[x] || strlen(szBuffer) +
    1520                      strlen(li->list[x]) + 5 > 1024) {
    1521                     runemf2(SEPARATE | WINDOWED |
    1522                             ((fArcStuffVisible) ? 0 :
    1523                               (BACKGROUND | MINIMIZED)) |
    1524                             WAIT,hwnd,NULL,NULL,"%s",szBuffer);
    1525                     *p = 0;
    1526                   }
    1527                   strcat(szBuffer," ");
    1528                 }
    1529                 PostMsg(dcd->hwndCnr,UM_RESCAN,MPFROMSHORT(1),MPVOID);
    1530                 Broadcast(WinQueryAnchorBlock(hwnd),
    1531                           hwndMain,
    1532                           UM_UPDATERECORD,
    1533                           MPFROMP(ad.arcname),
    1534                           MPVOID);
    1535                 Broadcast(WinQueryAnchorBlock(hwnd),
    1536                           hwndMain,
    1537                           UM_UPDATERECORDLIST,
    1538                           MPFROMP(li->list),
    1539                           MPVOID);
    1540               }
    1541               break;
    1542 
    1543             case IDM_REFRESH:
    1544             case IDM_DELETE:
    1545               {
    1546                 CHAR      cl[1001],*endofit;
    1547                 INT       z;
    1548                 CHECKLIST ck;
    1549                 CHAR      prompt[CCHMAXPATH + 257];
    1550 
    1551                 if (!dcd->info->delete)
    1552                   break;
    1553                 memset(&ck,0,sizeof(ck));
    1554                 ck.size = sizeof(ck);
    1555                 ck.list = li->list;
    1556                 ck.cmd  = li->type;
    1557                 ck.prompt = prompt;
    1558                 sprintf(prompt,GetPString(IDS_ARCCNRDELREFTEXT),
    1559                         (li->type == IDM_DELETE) ?
    1560                          GetPString(IDS_DELETELOWERTEXT) :
    1561                          GetPString(IDS_REFRESHLOWERTEXT),
    1562                         &"s"[li->list[1] == NULL],
    1563                         dcd->arcname,
    1564                         (li->type == IDM_DELETE) ?
    1565                          GetPString(IDS_DELETELOWERTEXT) :
    1566                          GetPString(IDS_REFRESHLOWERTEXT));
    1567                 if (!WinDlgBox(HWND_DESKTOP,hwnd,CheckListProc,
    1568                               FM3ModHandle,
    1569                               CHECK_FRAME,MPFROMP(&ck)))
    1570                   break;
    1571                 li->list = ck.list;
    1572                 if (!li->list || !li->list[0])
    1573                   break;
    1574                 if (li->type == IDM_DELETE)
    1575                   sprintf(cl,"%s %s%s%s",dcd->info->delete,
    1576                           (needs_quoting(dcd->arcname)) ? "\"" : NullStr,
    1577                           dcd->arcname,
    1578                           (needs_quoting(dcd->arcname)) ? "\"" : NullStr);
    1579                 else
    1580                   sprintf(cl,"%s %s%s%s",dcd->info->create,
    1581                           (needs_quoting(dcd->arcname)) ? "\"" : NullStr,
    1582                           dcd->arcname,
    1583                           (needs_quoting(dcd->arcname)) ? "\"" : NullStr);
    1584                 endofit = &cl[strlen(cl)];
    1585                 z = 0;
    1586                 do {
    1587                   for(x = z;li->list[x] &&
    1588                        strlen(cl) + strlen(li->list[x]) < 999;x++) {
    1589                     strcat(cl," ");
    1590                     if (needs_quoting(li->list[x]))
    1591                       strcat(cl,"\"");
    1592                     strcat(cl,li->list[x]);
    1593                     if (needs_quoting(li->list[x]))
    1594                       strcat(cl,"\"");
    1595                   }
    1596                   z = x;
    1597                   runemf2(SEPARATE | WINDOWED |
    1598                           ((fArcStuffVisible) ? 0 : (BACKGROUND | MINIMIZED)) |
    1599                           WAIT,hwnd,NullStr,NULL,"%s",cl);
    1600                   *endofit = 0;
    1601                 } while(li->list[x]);
    1602                 PostMsg(dcd->hwndCnr,UM_RESCAN,MPFROMSHORT(1),MPVOID);
    1603                 Broadcast(WinQueryAnchorBlock(hwnd),
    1604                           hwndMain,
    1605                           UM_UPDATERECORD,
    1606                           MPFROMP(dcd->arcname),
    1607                           MPVOID);
    1608               }
    1609               break;
    1610 
    1611             case IDM_PRINT:
    1612             case IDM_VIRUSSCAN:
    1613             case IDM_VIEW:
    1614             case IDM_MCIPLAY:
    1615             case IDM_VIEWARCHIVE:
    1616             case IDM_VIEWTEXT:
    1617             case IDM_VIEWBINARY:
    1618             case IDM_EDIT:
    1619             case IDM_EDITTEXT:
    1620             case IDM_EDITBINARY:
    1621             case IDM_EXEC:
    1622             case IDM_EXTRACTWDIRS:
    1623             case IDM_EXTRACT:
    1624               {
    1625                 CHAR cl[1001],*endofit,*ptr;
    1626                 INT  z;
    1627 
    1628                 if ((li->type == IDM_EXTRACT && !li->info->extract) ||
    1629                    ((li->type == IDM_VIEW || li->type == IDM_VIEWTEXT ||
    1630                     li->type == IDM_VIEWBINARY || li->type == IDM_EDIT ||
    1631                     li->type == IDM_VIEWARCHIVE || li->type == IDM_EDITTEXT ||
    1632                     li->type == IDM_EDITBINARY || li->type == IDM_MCIPLAY) &&
    1633                    (!li->info->extract && !li->info->exwdirs)) ||
    1634                    (li->type != IDM_EXTRACT && li->type != IDM_EDIT &&
    1635                     li->type != IDM_VIEW && li->type != IDM_VIEWTEXT &&
    1636                     li->type != IDM_VIEWBINARY &&
    1637                     li->type != IDM_VIEWARCHIVE &&
    1638                     li->type != IDM_EDITTEXT &&
    1639                     li->type != IDM_EDITBINARY &&
    1640                     li->type != IDM_MCIPLAY &&
    1641                     !li->info->exwdirs)) {
    1642                   Runtime_Error(pszSrcFile, __LINE__, "no cmd for request");
    1643                   break;
    1644                 }
    1645                 if (li->type == IDM_EXTRACT || li->type == IDM_EXTRACTWDIRS) {
    1646 
    1647                   CHAR        fullname[CCHMAXPATH * 2];
    1648                   CHAR        **exfiles = NULL;
    1649                   INT         numfiles = 0,numalloc = 0;
    1650 
    1651                   for(x = 0;li->list[x];x++) {
    1652                     sprintf(fullname,"%s%s%s",
    1653                             li->targetpath,
    1654                             (li->targetpath[strlen(li->targetpath) - 1] == '\\') ?
    1655                             NullStr : "\\",
    1656                             li->list[x]);
    1657                     if (IsFile(fullname) != -1) {
    1658                       AddToList(li->list[x],&exfiles,&numfiles,
    1659                                 &numalloc);
    1660                       li->list = RemoveFromList(li->list,li->list[x]);
    1661                       if (!li->list)
    1662                         break;
    1663                       x--;
    1664                     }
    1665                   }
    1666                   if (exfiles && numfiles) {
    1667 
    1668                     CHECKLIST ckl;
    1669                     CHAR      prompt[(CCHMAXPATH * 2) + 256];
    1670 
    1671                     memset(&ckl,0,sizeof(ckl));
    1672                     ckl.size = sizeof(ckl);
    1673                     ckl.list = exfiles;
    1674                     ckl.prompt = prompt;
    1675                     ckl.cmd = li->type;
    1676                     sprintf(prompt,
    1677                             GetPString(IDS_REPLACEWARNTEXT),
    1678                             &"s"[numfiles == 1],
    1679                             li->arcname,
    1680                             &"s"[numfiles != 1],
    1681                             li->targetpath);
    1682                     if (!WinDlgBox(HWND_DESKTOP,hwnd,CheckListProc,
    1683                                   FM3ModHandle,
    1684                                   CHECK_FRAME,MPFROMP(&ckl))) {
    1685                       if (ckl.list)
    1686                         FreeList(ckl.list);
    1687                       break;
    1688                     }
    1689                     else if (ckl.list)
    1690                       li->list = CombineLists(li->list,ckl.list);
    1691                   }
    1692                 }
    1693                 if (!li->list || !li->list[0])
    1694                   break;
    1695                 sprintf(cl,"%s %s%s%s",(li->type == IDM_EXTRACT ||
    1696                         ((li->type == IDM_VIEW || li->type == IDM_VIEWTEXT ||
    1697                           li->type == IDM_VIEWBINARY ||
    1698                           li->type == IDM_VIEWARCHIVE ||
    1699                           li->type == IDM_PRINT || li->type == IDM_EDIT ||
    1700                           li->type == IDM_EDITTEXT ||
    1701                           li->type == IDM_EDITBINARY &&
    1702                           li->type == IDM_MCIPLAY) &&
    1703                           !li->info->exwdirs)) ?
    1704                         li->info->extract : li->info->exwdirs,
    1705                         (needs_quoting(li->arcname)) ? "\"" : NullStr,
    1706                         li->arcname,
    1707                         (needs_quoting(li->arcname)) ? "\"" : NullStr);
    1708                 endofit = &cl[strlen(cl)];
    1709                 z = 0;
    1710                 do {
    1711                   for(x = z;li->list[x] &&
    1712                        strlen(cl) + strlen(li->list[x]) < 999;x++) {
    1713                     strcat(cl," ");
    1714                     if (needs_quoting(li->list[x]))
    1715                       strcat(cl,"\"");
    1716                     strcat(cl,li->list[x]);
    1717                     if (needs_quoting(li->list[x]))
    1718                       strcat(cl,"\"");
    1719                     ptr = li->list[x];
    1720                     while(*ptr) {
    1721                       if (*ptr == '/')
    1722                         *ptr = '\\';
    1723                       ptr++;
    1724                     }
    1725                   }
    1726                   z = x;
    1727                   runemf2(SEPARATE | WINDOWED |
    1728                           (fArcStuffVisible ? 0 : (BACKGROUND | MINIMIZED)) |
    1729                           WAIT,hwnd,li->targetpath,NULL,"%s",cl);
    1730                   *endofit = 0;
    1731                 } while(li->list[x]);
    1732                 if (li->type == IDM_EXTRACT || li->type == IDM_EXTRACTWDIRS) {
    1733                   /* update windows */
    1734                   for(x = 0;li->list[x];x++) {
    1735 
    1736                     CHAR *temp,*p;
    1737 
    1738                     temp = li->list[x];
    1739                     p = temp;
    1740                     while(*p) {
    1741                       if (*p == '/')
    1742                         *p = '\\';
    1743                       p++;
    1744                     }
    1745                     p = xmalloc(strlen(temp) + strlen(li->targetpath) + 2,pszSrcFile,__LINE__);
    1746                     if (p) {
    1747                       strcpy(p,li->targetpath);
    1748                       if (p[strlen(p) - 1] != '\\')
    1749                         strcat(p,"\\");
    1750                       strcat(p,temp);
    1751                       li->list[x] = p;
    1752                       free(temp);
    1753                     }
    1754                   }
    1755                   if (fFolderAfterExtract) {
    1756 
    1757                     CHAR   objectpath[CCHMAXPATH],*p;
    1758                     APIRET rc;
    1759 
    1760                     GetDesktopName(objectpath,sizeof(objectpath));
    1761                     rc = WinDlgBox(HWND_DESKTOP,dcd->hwndParent,ObjCnrDlgProc,
    1762                                    FM3ModHandle,OBJCNR_FRAME,
    1763                                    MPFROMP(objectpath));
    1764                     if (rc) {
    1765                       if (rc > 1)
    1766                         strcpy(objectpath,"<WP_DESKTOP>");
    1767                       p = NULL;
    1768                       if (li->arcname) {
    1769                         p = strrchr(li->arcname,'\\');
    1770                         if (p)
    1771                           p++;
    1772                       }
    1773                       MakeShadows(dcd->hwndParent,li->list,2,objectpath,p);
    1774                     }
    1775                   }
    1776                   Broadcast(WinQueryAnchorBlock(hwnd),
    1777                             hwndMain,
    1778                             UM_UPDATERECORDLIST,
    1779                             MPFROMP(li->list),
    1780                             MPVOID);
    1781                 }
    1782                 else if (li->type == IDM_EXEC)
    1783                   ExecOnList(hwnd,
    1784                              li->runfile,
    1785                              WINDOWED | SEPARATEKEEP | PROMPT,
    1786                              li->targetpath,
    1787                              NULL,
    1788                              GetPString(IDS_EXECARCFILETITLETEXT));
    1789                 else if (li->type == IDM_VIRUSSCAN)
    1790                   ExecOnList(hwnd,virus,PROMPT | WINDOWED | SEPARATEKEEP,
    1791                              li->targetpath,NULL,
    1792                              GetPString(IDS_VIRUSSCANARCHIVETITLETEXT));
    1793                 else if (li->type == IDM_VIEW || li->type == IDM_VIEWTEXT ||
    1794                         li->type == IDM_VIEWBINARY || li->type == IDM_EDIT ||
    1795                         li->type == IDM_EDITTEXT ||
    1796                         li->type == IDM_VIEWARCHIVE ||
    1797                         li->type == IDM_EDITBINARY ||
    1798                         li->type == IDM_MCIPLAY ||
    1799                         li->type == IDM_PRINT) {
    1800 
    1801                   CHAR *temp,*p;
    1802 
    1803                   for(x = 0;li->list[x];x++) {
    1804                     if (!li->info->exwdirs) {
    1805                       temp = li->list[x];
    1806                       p = strrchr(li->list[x],'\\');
    1807                       if (p) {
    1808                         p++;
    1809                         li->list[x] = xstrdup(p,pszSrcFile,__LINE__);
    1810                         if (!li->list[x])
    1811                           li->list[x] = temp;
    1812                         else {
    1813                           free(temp);
    1814                         }
    1815                       }
    1816                     }
    1817                     sprintf(cl,"%s%s%s",li->targetpath,
    1818                             (li->targetpath[strlen(li->targetpath) - 1] == '\\') ?
    1819                             NullStr : "\\",li->list[x]);
    1820                     temp = li->list[x];
    1821                     li->list[x] = xstrdup(cl,pszSrcFile,__LINE__);
    1822                     if (!li->list[x])
    1823                       li->list[x] = temp;
    1824                     else
    1825                       free(temp);
    1826                   }
    1827                   if (li->type == IDM_VIEW || li->type == IDM_EDIT) {
    1828 
    1829                     BOOL isit = TestBinary(li->list[0]);
    1830 
    1831                     if (isit) {
    1832                       if (li->type == IDM_VIEW)
    1833                         li->type = IDM_VIEWBINARY;
    1834                       else
    1835                         li->type = IDM_EDITBINARY;
    1836                     }
    1837                     else {
    1838                       if (li->type == IDM_VIEW)
    1839                         li->type = IDM_VIEWTEXT;
    1840                       else
    1841                         li->type = IDM_EDITTEXT;
    1842                     }
    1843                   }
    1844                   if (li->type == IDM_MCIPLAY) {
    1845 
    1846                     FILE *fp;
    1847 
    1848                     fp = xfopen("$FM2PLAY.$$$","w",pszSrcFile,__LINE__);
    1849                     if (fp) {
    1850                       fprintf(fp,"%s",";AV/2-built FM2Play listfile\n");
    1851                       for(x = 0;li->list[x];x++)
    1852                         fprintf(fp,"%s\n",li->list[x]);
    1853                       fprintf(fp,";end\n");
    1854                       fclose(fp);
    1855                       runemf2(SEPARATE | WINDOWED,HWND_DESKTOP,NULL,
    1856                               NULL,"%sFM2PLAY.EXE /@$FM2PLAY.$$$",
    1857                               (fAddUtils) ? "UTILS\\" : NullStr);
    1858                     }
    1859                   }
    1860                   else if (li->type == IDM_PRINT) {
    1861                     strcpy(li->targetpath,printer);
    1862                     if (_beginthread(PrintListThread,NULL,65536,(PVOID)li) != -1) {
    1863                       Runtime_Error(pszSrcFile, __LINE__, GetPString(IDS_COULDNTSTARTTHREADTEXT));
    1864                       li = NULL;
    1865                     }
    1866                   }
    1867                   else if (li->type == IDM_VIEWARCHIVE) {
    1868 
    1869                     ARC_TYPE *info;
    1870 
    1871                     for(x = 0;li->list[x];x++) {
    1872                       if (IsFile(li->list[x]) == 1) {
    1873                         info = NULL;    // Do not hide dups - fixme to know why?
    1874                         if (WinDlgBox(HWND_DESKTOP,HWND_DESKTOP,
    1875                                       SBoxDlgProc,FM3ModHandle,ASEL_FRAME,
    1876                                       (PVOID)&info) &&
    1877                             info)
    1878                         {
    1879                           StartArcCnr(HWND_DESKTOP,
    1880                                       HWND_DESKTOP,
    1881                                       li->list[x],
    1882                                       4,
    1883                                       info);
    1884                         }
    1885                       }
    1886                     }
    1887                   }
    1888                   else if ((li->type == IDM_VIEWTEXT && *viewer) ||
    1889                           (li->type == IDM_VIEWBINARY && *binview) ||
    1890                           (li->type == IDM_EDITTEXT && *editor) ||
    1891                           (li->type == IDM_EDITBINARY && *bined)) {
    1892                     DosSleep(100);
    1893                     ExecOnList(hwnd,((li->type == IDM_VIEWTEXT) ? viewer :
    1894                                      (li->type == IDM_VIEWBINARY) ? binview :
    1895                                      (li->type == IDM_EDITTEXT) ? editor :
    1896                                      bined),
    1897                                WINDOWED | SEPARATE,li->targetpath,li->list,
    1898                                NULL);
    1899                   }
    1900                   else {
    1901                     if (li->hwnd) {
    1902 
    1903                       ULONG viewtype;
    1904 
    1905                       for(x = 0;li->list[x];x++) {
    1906                         if (x == 0) {
    1907                           if (li->type == IDM_VIEWBINARY ||
    1908                              li->type == IDM_EDITBINARY)
    1909                             viewtype = 16;
    1910                           else
    1911                             viewtype = 8;
    1912                         }
    1913                         else
    1914                           viewtype = 0;
    1915                         temp = xstrdup(li->list[x],pszSrcFile,__LINE__);
    1916                         if (temp) {
    1917                           if (!PostMsg(WinQueryWindow(li->hwnd,QW_PARENT),
    1918                                        UM_LOADFILE,
    1919                                        MPFROMLONG(4L +
    1920                                          (li->type == IDM_VIEWTEXT ||
    1921                                           li->type == IDM_VIEWBINARY) +
    1922                                           viewtype),
    1923                                        MPFROMP(temp)))
    1924                             free(temp);
    1925                         }
    1926                       }
    1927                     }
    1928                   }
    1929                 }
    1930               }
    1931               break;
    1932 
    1933             case IDM_FIND:
    1934               {
    1935                 INT         numfiles = 0,numalloced = 0;
    1936                 CHAR      **list2 = NULL,fullname[CCHMAXPATH * 2],*p;
    1937 
    1938                 for(x = 0;li->list[x];x++) {
    1939                   p = li->list[x];
    1940                   while(*p) {
    1941                     if (*p == '/')
    1942                       *p = '\\';
    1943                     p++;
    1944                   }
    1945                   sprintf(fullname,"%s%s%s",dcd->directory,
    1946                           (dcd->directory[strlen(dcd->directory) - 1] == '\\') ?
    1947                           NullStr : "\\",li->list[x]);
    1948                   if (IsFile(fullname) != -1)
    1949                     if (AddToList(fullname,&list2,&numfiles,&numalloced))
    1950                       break;
    1951                   if (strchr(li->list[x],'\\')) {
    1952                     p = strrchr(li->list[x],'\\');
    1953                     if (p) {
    1954                       p++;
    1955                       if (*p) {
    1956                         sprintf(fullname,"%s%s%s",dcd->directory,
    1957                                 (dcd->directory[strlen(dcd->directory) - 1] == '\\') ?
    1958                                 NullStr : "\\",p);
    1959                         if (IsFile(fullname) != -1)
    1960                           if (AddToList(fullname,&list2,&numfiles,&numalloced))
    1961                             break;
    1962                       }
    1963                     }
    1964                   }
    1965                 }
    1966                 if (!numfiles || !list2)
    1967                   Runtime_Error(pszSrcFile, __LINE__, "no files or list");
    1968                 else {
    1969                   WinSendMsg(dcd->hwndCnr,WM_COMMAND,
    1970                              MPFROM2SHORT(IDM_COLLECTOR,0),MPVOID);
    1971                   DosSleep(128L);
    1972                   if (Collector) {
    1973                     if (!PostMsg(Collector,WM_COMMAND,
    1974                                    MPFROM2SHORT(IDM_COLLECTOR,0),
    1975                                    MPFROMP(list2)))
    1976                       FreeList(list2);
    1977                   }
    1978                   else
    1979                     FreeList(list2);
    1980                 }
    1981               }
    1982               break;
    1983           }
    1984         }
    1985         FreeListInfo(li);
    1986       }
    1987       return 0;
    1988 
    1989     case WM_CLOSE:
    1990       WinDestroyWindow(hwnd);
    1991       break;
    1992 
    1993     case WM_DESTROY:
    1994       dcd = WinQueryWindowPtr(hwnd,QWL_USER);
    1995       if (dcd) {
    1996         if (*dcd->workdir) {
    1997           DosSleep(33L);
    1998           wipeallf("%s\\*",dcd->workdir);
    1999           if (rmdir(dcd->workdir)) {
    2000             DosSleep(256L);
    2001             wipeallf("%s\\*",dcd->workdir);
    2002             rmdir(dcd->workdir);
    2003           }
    2004         }
    2005         FreeList(dcd->lastselection);
    2006         WinSendMsg(dcd->hwndCnr,UM_CLOSE,MPVOID,MPVOID);
    2007         free(dcd);
    2008         WinSetWindowPtr(dcd->hwndCnr,QWL_USER,NULL);
    2009       }
    2010       if (!PostMsg((HWND)0,WM_QUIT,MPVOID,MPVOID))
    2011         WinSendMsg((HWND)0,WM_QUIT,MPVOID,MPVOID);
    2012       break;
    2013   } // switch
    2014   return WinDefWindowProc(hwnd,msg,mp1,mp2);
     2991              if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
     2992                  fSplitStatus && hwndStatus2)
     2993                WinSetWindowText(hwndStatus2,
     2994                                 GetPString(IDS_DRAGARCFILETEXT));
     2995              DragOne(hwnd, dcd->hwndObject, dcd->arcname, FALSE);
     2996              if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
     2997                  fSplitStatus && hwndStatus2)
     2998                PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
     2999            }
     3000          }
     3001        }
     3002        return 0;
     3003
     3004      case CN_DROP:
     3005        if (mp2) {
     3006
     3007          LISTINFO *li;
     3008
     3009          DosBeep(500, 100);            // fixme to know why beep?
     3010          li = DoFileDrop(hwnd, dcd->arcname, FALSE, mp1, mp2);
     3011          DosBeep(50, 100);             // fixme to know why beep?
     3012          if (li) {
     3013            li->type = (li->type == DO_MOVE) ? IDM_ARCHIVEM : IDM_ARCHIVE;
     3014            strcpy(li->targetpath, dcd->arcname);
     3015            if (!li->list ||
     3016                !li->list[0] ||
     3017                !PostMsg(dcd->hwndObject, UM_ACTION, MPFROMP(li), MPVOID))
     3018              FreeListInfo(li);
     3019          }
     3020        }
     3021        return 0;
     3022
     3023      case CN_CONTEXTMENU:
     3024        {
     3025          PARCITEM pci = (PARCITEM) mp2;
     3026
     3027          if (pci) {
     3028            WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPFROMP(pci),
     3029                       MPFROM2SHORT(TRUE, CRA_CURSORED));
     3030            MarkAll(hwnd, FALSE, FALSE, TRUE);
     3031            dcd->hwndLastMenu = CheckMenu(&ArcMenu, ARC_POPUP);
     3032          }
     3033          else {
     3034            dcd->hwndLastMenu = CheckMenu(&ArcCnrMenu, ARCCNR_POPUP);
     3035            if (dcd->hwndLastMenu && !dcd->cnremphasized) {
     3036              WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPVOID,
     3037                         MPFROM2SHORT(TRUE, CRA_SOURCE));
     3038              dcd->cnremphasized = TRUE;
     3039            }
     3040          }
     3041          if (dcd->hwndLastMenu) {
     3042            if (dcd->hwndLastMenu == ArcCnrMenu) {
     3043              if (dcd->flWindowAttr & CV_MINI)
     3044                WinCheckMenuItem(dcd->hwndLastMenu, IDM_MINIICONS, TRUE);
     3045            }
     3046            WinCheckMenuItem(dcd->hwndLastMenu, IDM_FOLDERAFTEREXTRACT,
     3047                             fFolderAfterExtract);
     3048            if (!PopupMenu(hwnd, hwnd, dcd->hwndLastMenu)) {
     3049              if (dcd->cnremphasized) {
     3050                WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPVOID,
     3051                           MPFROM2SHORT(FALSE, CRA_SOURCE));
     3052                dcd->cnremphasized = TRUE;
     3053              }
     3054              MarkAll(hwnd, TRUE, FALSE, TRUE);
     3055            }
     3056          }
     3057        }
     3058        break;
     3059
     3060      case CN_EMPHASIS:
     3061        if (mp2) {
     3062
     3063          PNOTIFYRECORDEMPHASIS pre = mp2;
     3064          PARCITEM pci;
     3065          CHAR s[CCHMAXPATHCOMP + 91], tf[81], tb[81];
     3066
     3067          pci = (PARCITEM) ((pre) ? pre->pRecord : NULL);
     3068          if (!pci) {
     3069            if (!ParentIsDesktop(hwnd, dcd->hwndParent)) {
     3070              if (hwndStatus2)
     3071                WinSetWindowText(hwndStatus2, NullStr);
     3072              if (fMoreButtons)
     3073                WinSetWindowText(hwndName, NullStr);
     3074            }
     3075            break;
     3076          }
     3077          if (pre->fEmphasisMask & CRA_SELECTED) {
     3078            if (pci->rc.flRecordAttr & CRA_SELECTED) {
     3079              dcd->selectedbytes += pci->cbFile;
     3080              dcd->selectedfiles++;
     3081            }
     3082            else if (dcd->selectedfiles) {
     3083              dcd->selectedbytes -= pci->cbFile;
     3084              dcd->selectedfiles--;
     3085            }
     3086            commafmt(tf, sizeof(tf), dcd->selectedfiles);
     3087            if (dcd->ullTotalBytes)
     3088              CommaFmtULL(tb, sizeof(tb), dcd->selectedbytes, ' ');
     3089            else
     3090              *tb = 0;
     3091            sprintf(s, "%s%s%s", tf, *tb ? " / " : NullStr, tb);
     3092            WinSetDlgItemText(dcd->hwndClient, DIR_SELECTED, s);
     3093          }
     3094          else if (WinQueryActiveWindow(dcd->hwndParent) ==
     3095                   dcd->hwndFrame &&
     3096                   !ParentIsDesktop(hwnd, dcd->hwndParent)) {
     3097            if (pre->fEmphasisMask & CRA_CURSORED) {
     3098              if (pci->rc.flRecordAttr & CRA_CURSORED) {
     3099                if (fSplitStatus && hwndStatus2) {
     3100                  if (dcd->ullTotalBytes)
     3101                    CommaFmtULL(tb, sizeof(tb), pci->cbFile, ' ');
     3102                  else
     3103                    *tb = 0;
     3104                  sprintf(s, "%s%s%s%s",
     3105                          *tb ? " " : NullStr,
     3106                          tb, *tb ? "  " : NullStr, pci->szFileName);
     3107                  WinSetWindowText(hwndStatus2, s);
     3108                }
     3109                if (fMoreButtons)
     3110                  WinSetWindowText(hwndName, pci->szFileName);
     3111              }
     3112            }
     3113          }
     3114        }
     3115        break;
     3116
     3117      case CN_ENTER:
     3118        if (mp2) {
     3119
     3120          PARCITEM pci = (PARCITEM) ((PNOTIFYRECORDENTER) mp2)->pRecord;
     3121
     3122          if (pci) {
     3123
     3124            CHAR *s;
     3125
     3126            if ((pci->rc.flRecordAttr & CRA_INUSE) ||
     3127                (pci->flags & (ARCFLAGS_REALDIR | ARCFLAGS_PSEUDODIR)))
     3128              break;
     3129            s = xstrdup(pci->szFileName, pszSrcFile, __LINE__);
     3130            if (s) {
     3131              if (!PostMsg(dcd->hwndObject, UM_ENTER, MPFROMP(s), MPVOID)) {
     3132                Runtime_Error(pszSrcFile, __LINE__, "post");
     3133                free(s);
     3134              }
     3135            }
     3136          }
     3137        }
     3138        break;
     3139      }
     3140    }
     3141    return 0;
     3142
     3143  case UM_FOLDUP:
     3144    if (!PostMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID))
     3145      DosExit(EXIT_PROCESS, 1);
     3146    return 0;
     3147
     3148  case UM_CLOSE:
     3149    WinDestroyWindow(WinQueryWindow(WinQueryWindow(hwnd, QW_PARENT),
     3150                                    QW_PARENT));
     3151    return 0;
     3152
     3153  case WM_SAVEAPPLICATION:
     3154    if (dcd && ParentIsDesktop(hwnd, dcd->hwndParent)) {
     3155      SWP swp;
     3156
     3157      WinQueryWindowPos(dcd->hwndFrame, &swp);
     3158      if (!(swp.fl & (SWP_HIDE | SWP_MINIMIZE | SWP_MAXIMIZE)))
     3159        PrfWriteProfileData(fmprof, appname, "AV2SizePos", &swp, sizeof(swp));
     3160    }
     3161    break;
     3162
     3163  case WM_CLOSE:
     3164    WinSendMsg(hwnd, WM_SAVEAPPLICATION, MPVOID, MPVOID);
     3165    if (dcd)
     3166      dcd->stopflag++;
     3167    if (dcd && dcd->hwndObject) {
     3168      if (!PostMsg(dcd->hwndObject, WM_CLOSE, MPVOID, MPVOID))
     3169        WinSendMsg(dcd->hwndObject, WM_CLOSE, MPVOID, MPVOID);
     3170    }
     3171    // In case object window frees dcd
     3172    dcd = WinQueryWindowPtr(hwnd, QWL_USER);
     3173    if (!dcd ||
     3174        (!dcd->dontclose &&
     3175         !dcd->amextracted && ParentIsDesktop(hwnd, dcd->hwndParent))) {
     3176      if (!PostMsg(hwnd, UM_FOLDUP, MPVOID, MPVOID))
     3177        WinSendMsg(hwnd, UM_FOLDUP, MPVOID, MPVOID);
     3178    }
     3179    return 0;
     3180
     3181  case WM_DESTROY:
     3182    if (ArcMenu)
     3183      WinDestroyWindow(ArcMenu);
     3184    if (ArcCnrMenu)
     3185      WinDestroyWindow(ArcCnrMenu);
     3186    ArcMenu = ArcCnrMenu = (HWND) 0;
     3187    EmptyCnr(hwnd);
     3188    break;
     3189  }
     3190  return (dcd && dcd->oldproc) ? dcd->oldproc(hwnd, msg, mp1, mp2) :
     3191    PFNWPCnr(hwnd, msg, mp1, mp2);
    20153192}
    20163193
    2017 
    2018 static MRESULT EXPENTRY ArcCnrWndProc (HWND hwnd,ULONG msg,MPARAM mp1,MPARAM mp2)
    2019 {
    2020   DIRCNRDATA *dcd = WinQueryWindowPtr(hwnd,QWL_USER);
    2021 
    2022   switch(msg) {
    2023     case DM_PRINTOBJECT:
    2024     case DM_DISCARDOBJECT:
    2025       if (dcd)
    2026         return WinSendMsg(dcd->hwndObject,msg,mp1,mp2);
    2027       else
    2028         return MRFROMLONG(DRR_TARGET);
    2029 
    2030     case WM_CHAR:
    2031       shiftstate = (SHORT1FROMMP(mp1) & (KC_SHIFT | KC_ALT | KC_CTRL));
    2032       if (SHORT1FROMMP(mp1) & KC_KEYUP)
    2033         return (MRESULT)TRUE;
    2034       if (SHORT1FROMMP(mp1) & KC_VIRTUALKEY) {
    2035         switch(SHORT2FROMMP(mp2)) {
    2036           case VK_DELETE:
    2037             PostMsg(hwnd,WM_COMMAND,MPFROM2SHORT(IDM_DELETE,0),MPVOID);
    2038             break;
    2039         }
    2040       }
    2041       if (shiftstate || fNoSearch)
    2042         break;
    2043       if (SHORT1FROMMP(mp1) & KC_CHAR) {
    2044 
    2045         ULONG        thistime,len;
    2046         SEARCHSTRING srch;
    2047         PCNRITEM     pci;
    2048 
    2049         if (!dcd)
    2050           break;
    2051         switch(SHORT1FROMMP(mp2)) {
    2052           case '\x1b':
    2053           case '\r':
    2054           case '\n':
    2055             dcd->lasttime = 0;
    2056             *dcd->szCommonName = 0;
    2057             break;
    2058           default:
    2059             thistime = WinQueryMsgTime(WinQueryAnchorBlock(hwnd));
    2060             if (thistime > dcd->lasttime + 1250)
    2061               *dcd->szCommonName = 0;
    2062             dcd->lasttime = thistime;
    2063             if (SHORT1FROMMP(mp2) == ' ' && !*dcd->szCommonName)
    2064               break;
    2065 KbdRetry:
    2066             len = strlen(dcd->szCommonName);
    2067             if (len >= CCHMAXPATH - 1) {
    2068               *dcd->szCommonName = 0;
    2069               len = 0;
    2070             }
    2071             dcd->szCommonName[len] = toupper(SHORT1FROMMP(mp2));
    2072             dcd->szCommonName[len + 1] = 0;
    2073             memset(&srch,0,sizeof(SEARCHSTRING));
    2074             srch.cb = (ULONG)sizeof(SEARCHSTRING);
    2075             srch.pszSearch = dcd->szCommonName;
    2076             srch.fsPrefix = TRUE;
    2077             srch.fsCaseSensitive = FALSE;
    2078             srch.usView = CV_ICON;
    2079             pci = WinSendMsg(hwnd,
    2080                              CM_SEARCHSTRING,
    2081                              MPFROMP(&srch),
    2082                              MPFROMLONG(CMA_FIRST));
    2083             if (pci && (INT)pci != -1) {
    2084 
    2085               USHORT  attrib = CRA_CURSORED;
    2086 
    2087               /* make found item current item */
    2088               if (!stricmp(pci->pszFileName,dcd->szCommonName))
    2089                 attrib |= CRA_SELECTED;
    2090               WinSendMsg(hwnd,
    2091                          CM_SETRECORDEMPHASIS,
    2092                          MPFROMP(pci),
    2093                          MPFROM2SHORT(TRUE,attrib));
    2094               /* make sure that record shows in viewport */
    2095               ShowCnrRecord(hwnd,(PMINIRECORDCORE)pci);
    2096               return (MRESULT)TRUE;
    2097             }
    2098             else {
    2099               if (SHORT1FROMMP(mp2) == ' ') {
    2100                 dcd->szCommonName[len] = 0;
    2101                 break;
    2102               }
    2103               *dcd->szCommonName = 0;
    2104               dcd->lasttime = 0;
    2105               if (len)           // retry as first letter if no match
    2106                 goto KbdRetry;
    2107             }
    2108             break;
    2109         }
    2110       }
    2111       break;
    2112 
    2113     case WM_MOUSEMOVE:
    2114     case WM_BUTTON1UP:
    2115     case WM_BUTTON2UP:
    2116     case WM_BUTTON3UP:
    2117     case WM_CHORD:
    2118       shiftstate = (SHORT2FROMMP(mp2) & (KC_SHIFT | KC_ALT | KC_CTRL));
    2119       break;
    2120 
    2121     case WM_BUTTON1MOTIONEND:
    2122       {
    2123         CNRINFO cnri;
    2124 
    2125         memset(&cnri,0,sizeof(CNRINFO));
    2126         cnri.cb = sizeof(CNRINFO);
    2127         if (WinSendMsg(hwnd,
    2128                       CM_QUERYCNRINFO,
    2129                       MPFROMP(&cnri),
    2130                       MPFROMLONG(sizeof(CNRINFO)))) {
    2131           if (cnri.flWindowAttr & CV_DETAIL)
    2132             PrfWriteProfileData(fmprof,
    2133                                 appname,
    2134                                 "ArcCnrSplitBar",
    2135                                 (PVOID)&cnri.xVertSplitbar,
    2136                                 sizeof(LONG));
    2137         }
    2138       }
    2139       break;
    2140 
    2141     case WM_PRESPARAMCHANGED:
    2142       PresParamChanged(hwnd,"ArcCnr",mp1,mp2);
    2143       break;
    2144 
    2145     case UM_UPDATERECORD:
    2146     case UM_UPDATERECORDLIST:
    2147       if (dcd && !IsArcThere(hwnd,dcd->arcname))
    2148         PostMsg(hwnd,WM_CLOSE,MPVOID,MPVOID);
    2149       return 0;
    2150 
    2151     case WM_SETFOCUS:
    2152       /*
    2153        * put name of our window (archive name) on status line
    2154        */
    2155       if (dcd && hwndStatus && mp2)
    2156         WinSendMsg(hwnd,UM_RESCAN,MPVOID,MPVOID);
    2157       break;
    2158 
    2159     case UM_SETUP2:
    2160       if (dcd &&
    2161          dcd->info) {
    2162         if (dcd->info->fdpos == -1 || !dcd->info->datetype)
    2163           dcd->sortFlags &= (~SORT_LWDATE);
    2164         if (dcd->info->nsizepos == -1)
    2165           dcd->sortFlags &= (~SORT_EASIZE);
    2166         if (dcd->info->osizepos == -1)
    2167           dcd->sortFlags &= (~SORT_SIZE);
    2168         AdjustCnrColVis(hwnd,
    2169                         GetPString(IDS_OLDSIZECOLTEXT),
    2170                         dcd->info->osizepos != -1,
    2171                         FALSE);
    2172         AdjustCnrColVis(hwnd,
    2173                         GetPString(IDS_NEWSIZECOLTEXT),
    2174                         dcd->info->nsizepos != -1,
    2175                         FALSE);
    2176         // Display unsullied date/time string if type 0
    2177         AdjustCnrColVis(hwnd,
    2178                         GetPString(IDS_DATETIMECOLTEXT),
    2179                         dcd->info->fdpos != -1 && !dcd->info->datetype,
    2180                         FALSE);
    2181         // Display parsed date/time columns if type specified
    2182         AdjustCnrColVis(hwnd,
    2183                         GetPString(IDS_TIMECOLTEXT),
    2184                         dcd->info->fdpos != -1 && dcd->info->datetype,
    2185                         FALSE);
    2186         AdjustCnrColVis(hwnd,
    2187                         GetPString(IDS_DATECOLTEXT),
    2188                         dcd->info->fdpos != -1 && dcd->info->datetype,
    2189                         FALSE);
    2190         WinSendMsg(hwnd,CM_INVALIDATEDETAILFIELDINFO,MPVOID,MPVOID);
    2191       }
    2192       return 0;
    2193 
    2194     case UM_RESCAN:
    2195       if (dcd) {
    2196         CNRINFO  cnri;
    2197         CHAR     s[CCHMAXPATH * 2],tb[81],tf[81];
    2198         PARCITEM pci;
    2199 
    2200         if (mp1) {
    2201           PostMsg(dcd->hwndObject,UM_RESCAN,MPVOID,MPVOID);
    2202           return 0;
    2203         }
    2204         memset(&cnri,0,sizeof(CNRINFO));
    2205         cnri.cb = sizeof(CNRINFO);
    2206         WinSendMsg(hwnd,
    2207                    CM_QUERYCNRINFO,
    2208                    MPFROMP(&cnri),
    2209                    MPFROMLONG(sizeof(CNRINFO)));
    2210         dcd->totalfiles = cnri.cRecords;
    2211         commafmt(tf,sizeof(tf),dcd->selectedfiles);
    2212         if (dcd->ullTotalBytes)
    2213           CommaFmtULL(tb,sizeof(tb),dcd->selectedbytes,'K');
    2214         else
    2215           *tb = 0;
    2216         sprintf(s,"%s%s%s",
    2217                 tf,
    2218                 *tb ? " / " : NullStr,
    2219                 tb);
    2220         WinSetDlgItemText(dcd->hwndClient,DIR_SELECTED,s);
    2221         commafmt(tf,sizeof(tf),dcd->totalfiles);
    2222         if (dcd->ullTotalBytes)
    2223           CommaFmtULL(tb,sizeof(tb),dcd->ullTotalBytes,'K');
    2224         else
    2225           *tb = 0;
    2226         sprintf(s,"%s%s%s",
    2227                 tf,
    2228                 *tb ? " / " : NullStr,
    2229                 tb);
    2230         WinSetDlgItemText(dcd->hwndClient,DIR_TOTALS,s);
    2231         if (hwndStatus &&
    2232            dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent))
    2233         {
    2234           sprintf(s," [%s%s%s]%s%s%s  %s",
    2235                   tf,
    2236                   *tb ? " / " : NullStr,
    2237                   tb,
    2238                   (*dcd->mask.szMask) ? " (" : NullStr,
    2239                   (*dcd->mask.szMask) ? dcd->mask.szMask : NullStr,
    2240                   (*dcd->mask.szMask) ? ")" : NullStr,dcd->arcname);
    2241           WinSetWindowText(hwndStatus,s);
    2242           if (!ParentIsDesktop(hwnd,dcd->hwndParent)) {
    2243             pci = WinSendMsg(hwnd,
    2244                              CM_QUERYRECORDEMPHASIS,
    2245                              MPFROMLONG(CMA_FIRST),
    2246                              MPFROMSHORT(CRA_CURSORED));
    2247             if (pci && (INT)pci != -1) {
    2248               if (fSplitStatus && hwndStatus2) {
    2249                 if (dcd->ullTotalBytes)
    2250                   CommaFmtULL(tb,sizeof(tb),pci->cbFile,' ');
    2251                 else
    2252                   *tb = 0;
    2253                 sprintf(s,"%s%s%s%s",
    2254                         *tb ? " " : NullStr,
    2255                         tb,
    2256                         *tb ? "  " : NullStr,
    2257                         pci->szFileName);
    2258                 WinSetWindowText(hwndStatus2,s);
    2259               }
    2260               if (fMoreButtons)
    2261                 WinSetWindowText(hwndName,
    2262                                  pci->szFileName);
    2263             }
    2264             else {
    2265               WinSetWindowText(hwndStatus2,NullStr);
    2266               WinSetWindowText(hwndName,NullStr);
    2267             }
    2268             WinSetWindowText(hwndDate,NullStr);
    2269             WinSetWindowText(hwndAttr,NullStr);
    2270           }
    2271         }
    2272         if ((dcd->arcfilled &&
    2273             !dcd->totalfiles) ||
    2274            !IsArcThere(hwnd,dcd->arcname))
    2275           PostMsg(hwnd,WM_CLOSE,MPVOID,MPVOID);
    2276       }
    2277       return 0;
    2278 
    2279     case UM_SETUP:
    2280       if (!dcd) {
    2281         Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
    2282         PostMsg(hwnd,WM_CLOSE,MPVOID,MPVOID);
    2283         return 0;
    2284       }
    2285       else {
    2286         if (!dcd->hwndObject) {
    2287           /*
    2288            * first time through -- set things up
    2289            */
    2290           {
    2291             CHAR  *p,*pp;
    2292             ULONG  z,was;
    2293             APIRET rc;
    2294 
    2295             rc = DosCreateDir(dcd->workdir,0);
    2296             if (rc) {
    2297               if (rc == ERROR_ACCESS_DENIED) {
    2298                 p = strrchr(dcd->workdir,'.');
    2299                 if (p) {
    2300                   p++;
    2301                   pp = p;
    2302                   was = strtoul(p,&pp,16);
    2303                   for(z = 0;z < 99;z++) {
    2304                     was++;
    2305                     sprintf(p,"%03x");
    2306                     rc = DosCreateDir(dcd->workdir,0);
    2307                     if (!rc || rc != ERROR_ACCESS_DENIED)
    2308                       break;
    2309                   }
    2310                 }
    2311               }
    2312               if (rc)
    2313                 PostMsg(hwnd,WM_CLOSE,MPVOID,MPVOID);
    2314               return 0;
    2315             }
    2316           }
    2317           RestorePresParams(hwnd,"ArcCnr");
    2318           dcd->mask.fNoAttribs = TRUE;
    2319           dcd->mask.fNoDirs = TRUE;
    2320           *dcd->mask.prompt = 0;
    2321           {
    2322             PFIELDINFO  pfi, pfiLastLeftCol;
    2323             ULONG       numcols = CON_COLS;
    2324             CNRINFO cnri;
    2325             ULONG size;
    2326 
    2327             pfi = WinSendMsg(hwnd,
    2328                              CM_ALLOCDETAILFIELDINFO,
    2329                              MPFROMLONG(numcols),
    2330                              NULL);
    2331             if (pfi) {
    2332 
    2333               PFIELDINFO      pfiFirst;
    2334               FIELDINFOINSERT fii;
    2335 
    2336               pfiFirst = pfi;
    2337               pfi->flData     = CFA_STRING | CFA_LEFT | CFA_FIREADONLY;
    2338               pfi->flTitle    = CFA_CENTER;
    2339               pfi->pTitleData = GetPString(IDS_FILENAMECOLTEXT);
    2340               pfi->offStruct  = FIELDOFFSET(ARCITEM, pszFileName);
    2341               pfiLastLeftCol = pfi;
    2342               pfi             = pfi->pNextFieldInfo;
    2343               pfi->flData     = CFA_ULONG | CFA_RIGHT | CFA_SEPARATOR | CFA_FIREADONLY;
    2344               pfi->flTitle    = CFA_CENTER;
    2345               pfi->pTitleData = GetPString(IDS_OLDSIZECOLTEXT);
    2346               pfi->offStruct  = FIELDOFFSET(ARCITEM, cbFile);
    2347               pfi             = pfi->pNextFieldInfo;
    2348               pfi->flData     = CFA_ULONG | CFA_RIGHT | CFA_SEPARATOR | CFA_FIREADONLY;
    2349               pfi->flTitle    = CFA_CENTER;
    2350               pfi->pTitleData = GetPString(IDS_NEWSIZECOLTEXT);
    2351               pfi->offStruct  = FIELDOFFSET( ARCITEM, cbComp );
    2352               pfi             = pfi->pNextFieldInfo;
    2353               pfi->flData     = CFA_STRING | CFA_CENTER | CFA_SEPARATOR | CFA_FIREADONLY;
    2354               pfi->flTitle    = CFA_CENTER | CFA_FITITLEREADONLY;
    2355               pfi->pTitleData = GetPString(IDS_DATETIMECOLTEXT);
    2356               pfi->offStruct  = FIELDOFFSET(ARCITEM, pszDate);
    2357               pfi             = pfi->pNextFieldInfo;
    2358               pfi->flData     = CFA_DATE | CFA_RIGHT | CFA_FIREADONLY;
    2359               pfi->flTitle    = CFA_CENTER;
    2360               pfi->pTitleData = GetPString(IDS_DATECOLTEXT);
    2361               pfi->offStruct  = FIELDOFFSET(ARCITEM, date);
    2362               pfi             = pfi->pNextFieldInfo;
    2363               pfi->flData     = CFA_TIME | CFA_RIGHT | CFA_FIREADONLY;
    2364               pfi->flTitle    = CFA_CENTER | CFA_FITITLEREADONLY;
    2365               pfi->pTitleData = GetPString(IDS_TIMECOLTEXT);
    2366               pfi->offStruct  = FIELDOFFSET( ARCITEM, time );
    2367               memset( &fii, 0, sizeof( FIELDINFOINSERT ) );
    2368               fii.cb                   = sizeof( FIELDINFOINSERT );
    2369               fii.pFieldInfoOrder      = (PFIELDINFO) CMA_FIRST;
    2370               fii.cFieldInfoInsert     = (SHORT) numcols;
    2371               fii.fInvalidateFieldInfo = TRUE;
    2372               WinSendMsg(hwnd,
    2373                          CM_INSERTDETAILFIELDINFO,
    2374                          MPFROMP(pfiFirst),
    2375                          MPFROMP(&fii));
    2376               PostMsg(hwnd,UM_SETUP2,MPVOID,MPVOID);
    2377 
    2378               memset(&cnri,0,sizeof(cnri));
    2379               cnri.cb             = sizeof( CNRINFO );
    2380               cnri.pFieldInfoLast = pfiLastLeftCol;
    2381               cnri.xVertSplitbar  = DIR_SPLITBAR_OFFSET + 32;
    2382 
    2383               size = sizeof(LONG);
    2384               PrfQueryProfileData(fmprof,appname,"ArcCnrSplitBar",
    2385                                   &cnri.xVertSplitbar,&size);
    2386               if (cnri.xVertSplitbar <= 0)
    2387                 cnri.xVertSplitbar = DIR_SPLITBAR_OFFSET + 32;
    2388 
    2389               cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT |
    2390                                     CV_NAME));
    2391               cnri.flWindowAttr |= (CV_DETAIL | CA_DETAILSVIEWTITLES |
    2392                                     CV_FLOW);
    2393               cnri.flWindowAttr &= (~(CA_ORDEREDTARGETEMPH |
    2394                                       CA_MIXEDTARGETEMPH));
    2395               cnri.pSortRecord = (PVOID)ArcSort;
    2396               WinSendMsg(hwnd,
    2397                          CM_SETCNRINFO,
    2398                          MPFROMP(&cnri),
    2399                          MPFROMLONG(CMA_PFIELDINFOLAST |
    2400                                     CMA_XVERTSPLITBAR  |
    2401                                     CMA_PSORTRECORD    |
    2402                                     CMA_FLWINDOWATTR));
    2403             }
    2404           }
    2405           WinSendMsg(hwnd,CM_SORTRECORD,MPFROMP(ArcSort),MPFROMP(dcd));
    2406           if (_beginthread(MakeObjWin,NULL,245760,(PVOID)dcd) == -1) {
    2407             Runtime_Error(pszSrcFile, __LINE__, GetPString(IDS_COULDNTSTARTTHREADTEXT));
    2408             PostMsg(hwnd,WM_CLOSE,MPVOID,MPVOID);
    2409             return 0;
    2410           }
    2411           else
    2412             DosSleep(1L);
    2413           SayFilter(WinWindowFromID(WinQueryWindow(hwnd,QW_PARENT),
    2414                     DIR_FILTER),
    2415                     &dcd->mask,
    2416                     TRUE);
    2417           SaySort(WinWindowFromID(WinQueryWindow(hwnd,QW_PARENT),
    2418                   DIR_SORT),
    2419                   dcd->sortFlags,
    2420                   TRUE);
    2421           DefArcSortFlags = dcd->sortFlags;     // Remember for new windows
    2422         }
    2423       }
    2424       return 0;
    2425 
    2426     case UM_SETDIR:
    2427       if (dcd) {
    2428 
    2429         CHAR        s[CCHMAXPATH],*p;
    2430         ULONG       ret = 0;
    2431 
    2432         WinQueryDlgItemText(dcd->hwndClient,
    2433                             ARC_EXTRACTDIR,
    2434                             CCHMAXPATH,
    2435                             s);
    2436         bstrip(s);
    2437         MakeFullName(s);
    2438         if (*s) {
    2439           while ((p = strchr(s,'/')) != NULL)
    2440             *p = '\\';
    2441           while (strlen(s) > 3 && s[strlen(s) - 1] == '\\')
    2442             s[strlen(s) - 1] = 0;
    2443           if (stricmp(s,dcd->directory)) {
    2444             if (IsFullName(s)) {
    2445               if (driveflags[toupper(*s) - 'A'] &
    2446                   (DRIVE_NOTWRITEABLE | DRIVE_IGNORE | DRIVE_INVALID)) {
    2447                 Runtime_Error(pszSrcFile, __LINE__, "drive %s bad", s);
    2448                 WinSetDlgItemText(dcd->hwndClient,
    2449                                   ARC_EXTRACTDIR,
    2450                                   dcd->directory);
    2451                 return 0;
    2452               }
    2453             }
    2454             if (!SetDir(dcd->hwndParent,hwnd,s,0)) {
    2455               if (stricmp(dcd->directory,s)) {
    2456                 DosEnterCritSec();
    2457                  strcpy(lastextractpath,s);
    2458                 DosExitCritSec();
    2459               }
    2460               strcpy(dcd->directory,s);
    2461               if ((!isalpha(*s) || s[1] != ':') && *s != '.')
    2462                 saymsg(MB_ENTER | MB_ICONASTERISK,
    2463                        hwnd,
    2464                        GetPString(IDS_WARNINGTEXT),
    2465                        GetPString(IDS_SPECIFYDRIVETEXT));
    2466             }
    2467             else
    2468               ret = 1;
    2469           }
    2470         }
    2471         WinSetDlgItemText(dcd->hwndClient,
    2472                           ARC_EXTRACTDIR,
    2473                           dcd->directory);
    2474         return (MRESULT)ret;
    2475       }
    2476       return 0;
    2477 
    2478     case UM_ENTER:
    2479       if (WinSendMsg(hwnd,UM_SETDIR,MPVOID,MPVOID))
    2480         return 0;
    2481       SetShiftState();
    2482       if (dcd && (CHAR *)mp1) {
    2483 
    2484         SWP   swp;
    2485         CHAR *filename = mp1;
    2486 
    2487         if (IsFile(filename) != 1)
    2488           return 0;
    2489         WinQueryWindowPos(dcd->hwndFrame,&swp);
    2490         DefaultViewKeys(hwnd,
    2491                         dcd->hwndFrame,
    2492                         dcd->hwndParent,
    2493                         &swp,
    2494                         filename);
    2495         if (fUnHilite)
    2496           UnHilite(hwnd,
    2497                    FALSE,
    2498                    &dcd->lastselection);
    2499       }
    2500       return 0;
    2501 
    2502     case WM_MENUEND:
    2503       if (dcd) {
    2504 
    2505         HWND hwndMenu = (HWND)mp2;
    2506 
    2507         if (hwndMenu == ArcCnrMenu || hwndMenu == ArcMenu) {
    2508           MarkAll(hwnd,TRUE,FALSE,TRUE);
    2509           if (dcd->cnremphasized) {
    2510             WinSendMsg(hwnd,
    2511                        CM_SETRECORDEMPHASIS,
    2512                        MPVOID,
    2513                        MPFROM2SHORT(FALSE,CRA_SOURCE));
    2514             dcd->cnremphasized = FALSE;
    2515           }
    2516         }
    2517       }
    2518       break;
    2519 
    2520     case MM_PORTHOLEINIT:
    2521       if (dcd) {
    2522         switch(SHORT1FROMMP(mp1)) {
    2523           case 0:
    2524           case 1:
    2525             {
    2526               ULONG wmsg;
    2527 
    2528               wmsg = (SHORT1FROMMP(mp1) == 0) ? UM_FILESMENU : UM_VIEWSMENU;
    2529               PortholeInit((HWND)WinSendMsg(dcd->hwndClient,
    2530                                             wmsg,
    2531                                             MPVOID,
    2532                                             MPVOID),
    2533                             mp1,
    2534                             mp2);
    2535             }
    2536             break;
    2537         }
    2538       }
    2539       break;
    2540 
    2541     case UM_INITMENU:
    2542     case WM_INITMENU:
    2543       if (dcd) {
    2544         switch(SHORT1FROMMP(mp1)) {
    2545           case IDM_FILESMENU:
    2546             if (dcd->info) {
    2547               WinEnableMenuItem((HWND)mp2,
    2548                                 IDM_DELETE,
    2549                                 dcd->info->delete != NULL);
    2550               WinEnableMenuItem((HWND)mp2,
    2551                                 IDM_TEST,
    2552                                 dcd->info->test != NULL);
    2553               WinEnableMenuItem((HWND)mp2,
    2554                                 IDM_EXTRACT,
    2555                                 dcd->info->extract != NULL);
    2556               WinEnableMenuItem((HWND)mp2,
    2557                                 IDM_EXTRACTWDIRS,
    2558                                 dcd->info->exwdirs != NULL);
    2559               WinEnableMenuItem((HWND)mp2,
    2560                                 IDM_ARCEXTRACTWDIRS,
    2561                                 dcd->info->exwdirs != NULL);
    2562               WinEnableMenuItem((HWND)mp2,
    2563                                 IDM_ARCEXTRACTWDIRSEXIT,
    2564                                 dcd->info->exwdirs != NULL);
    2565             }
    2566             break;
    2567 
    2568           case IDM_VIEWSMENU:
    2569             WinCheckMenuItem((HWND)mp2,
    2570                              IDM_MINIICONS,
    2571                              ((dcd->flWindowAttr & CV_MINI) != 0));
    2572             WinEnableMenuItem((HWND)mp2,
    2573                               IDM_RESELECT,
    2574                               (dcd->lastselection != NULL));
    2575             break;
    2576 
    2577           case IDM_COMMANDSMENU:
    2578             SetupCommandMenu((HWND)mp2,hwnd);
    2579             break;
    2580 
    2581           case IDM_SORTSUBMENU:
    2582             SetSortChecks((HWND)mp2,dcd->sortFlags);
    2583             break;
    2584 
    2585           case IDM_WINDOWSMENU:
    2586             /*
    2587              * add switchlist entries to end of pulldown menu
    2588              */
    2589             SetupWinList((HWND)mp2,
    2590                          (hwndMain) ? hwndMain : (HWND)0,
    2591                          dcd->hwndFrame);
    2592             break;
    2593         }
    2594         dcd->hwndLastMenu = (HWND)mp2;
    2595       }
    2596       if (msg == WM_INITMENU)
    2597         break;
    2598       return 0;
    2599 
    2600     case UM_LOADFILE:
    2601       if (dcd && mp2) {
    2602 
    2603         HWND ret;
    2604 
    2605         ret = StartMLEEditor(dcd->hwndParent,
    2606                              (INT)mp1,
    2607                              (CHAR *)mp2,
    2608                              dcd->hwndFrame);
    2609         free((CHAR *)mp2);
    2610         return MRFROMLONG(ret);
    2611       }
    2612       return 0;
    2613 
    2614     case UM_COMMAND:
    2615       if (mp1) {
    2616         if (dcd) {
    2617           if (!PostMsg(dcd->hwndObject,UM_COMMAND,mp1,mp2)) {
    2618             Runtime_Error(pszSrcFile, __LINE__, "post");
    2619             FreeListInfo((LISTINFO *)mp1);
    2620           }
    2621           else
    2622             return (MRESULT)TRUE;
    2623         }
    2624         else
    2625           FreeListInfo((LISTINFO *)mp1);
    2626       }
    2627       return 0;
    2628 
    2629     case UM_OPENWINDOWFORME:
    2630       if (dcd) {
    2631         if (mp1 && !IsFile((CHAR *)mp1)) {
    2632           OpenDirCnr((HWND)0,
    2633                      hwndMain,
    2634                      dcd->hwndFrame,
    2635                      FALSE,
    2636                      (char *)mp1);
    2637         }
    2638         else if (mp1 && IsFile(mp1) == 1) {
    2639           StartArcCnr(HWND_DESKTOP,
    2640                       dcd->hwndFrame,
    2641                       (CHAR *)mp1,
    2642                       4,
    2643                       (ARC_TYPE *)mp2);
    2644         }
    2645       }
    2646       return 0;
    2647 
    2648     case WM_COMMAND:
    2649       DosError(FERR_DISABLEHARDERR);
    2650       if (dcd) {
    2651         if (SwitchCommand(dcd->hwndLastMenu,
    2652                          SHORT1FROMMP(mp1)))
    2653           return 0;
    2654         if (WinSendMsg(hwnd,UM_SETDIR,MPVOID,MPVOID))
    2655           return 0;
    2656         if (!IsArcThere(hwnd,dcd->arcname)) {
    2657           PostMsg(hwnd,WM_CLOSE,MPVOID,MPVOID);
    2658           return 0;
    2659         }
    2660         switch(SHORT1FROMMP(mp1)) {
    2661           case IDM_TREEVIEW:
    2662 
    2663             break;
    2664 
    2665           case IDM_CONTEXTMENU:
    2666             {
    2667               PCNRITEM pci;
    2668 
    2669               pci = (PCNRITEM)CurrentRecord(hwnd);
    2670               PostMsg(hwnd,
    2671                       WM_CONTROL,
    2672                       MPFROM2SHORT(ARC_CNR,CN_CONTEXTMENU),
    2673                       MPFROMP(pci));
    2674             }
    2675             break;
    2676 
    2677           case IDM_NEXTWINDOW:
    2678           case IDM_PREVWINDOW:
    2679             {
    2680               HWND hwndActive;
    2681 
    2682               hwndActive = WinQueryFocus(HWND_DESKTOP);
    2683               WinSetFocus(HWND_DESKTOP,
    2684                           ((hwndActive == hwnd) ?
    2685                            WinWindowFromID(dcd->hwndClient,ARC_EXTRACTDIR) :
    2686                            hwnd));
    2687             }
    2688             break;
    2689 
    2690           case IDM_FOLDERAFTEREXTRACT:
    2691             fFolderAfterExtract = (fFolderAfterExtract) ? FALSE : TRUE;
    2692             PrfWriteProfileData(fmprof,appname,"FolderAfterExtract",
    2693                                 &fFolderAfterExtract,sizeof(BOOL));
    2694             break;
    2695 
    2696           case IDM_SHOWSELECT:
    2697             QuickPopup(hwnd,dcd,CheckMenu(&ArcCnrMenu,ARCCNR_POPUP),
    2698                        IDM_SELECTSUBMENU);
    2699             break;
    2700 
    2701           case IDM_SHOWSORT:
    2702             QuickPopup(hwnd,dcd,CheckMenu(&ArcCnrMenu,ARCCNR_POPUP),
    2703                        IDM_SORTSUBMENU);
    2704             break;
    2705 
    2706           case IDM_NOTEBOOK:
    2707             if (!ParentIsDesktop(dcd->hwndParent,dcd->hwndParent))
    2708               PostMsg(dcd->hwndParent,msg,mp1,mp2);
    2709             else
    2710               WinDlgBox(HWND_DESKTOP,
    2711                         hwnd,
    2712                         CfgDlgProc,
    2713                         FM3ModHandle,
    2714                         CFG_FRAME,
    2715                         (PVOID)"Archive");
    2716             break;
    2717 
    2718           case IDM_RESCAN:
    2719             dcd->ullTotalBytes = dcd->totalfiles =
    2720               dcd->selectedfiles = dcd->selectedbytes = 0;
    2721             WinSetDlgItemText(dcd->hwndClient,DIR_TOTALS,"0");
    2722             WinSetDlgItemText(dcd->hwndClient,DIR_SELECTED,"0 / 0k");
    2723             dcd->totalfiles = FillArcCnr(dcd->hwndCnr,
    2724                                          dcd->arcname,
    2725                                          &dcd->info,
    2726                                          &dcd->ullTotalBytes,
    2727                                          &dcd->stopflag);
    2728             PostMsg(dcd->hwndCnr,UM_RESCAN,MPVOID,MPVOID);
    2729             PostMsg(dcd->hwndCnr,UM_SETUP2,MPVOID,MPVOID);
    2730             WinSendMsg(dcd->hwndCnr,
    2731                        CM_INVALIDATERECORD,
    2732                        MPVOID,
    2733                        MPFROM2SHORT(0,CMA_ERASE | CMA_REPOSITION));
    2734             break;
    2735 
    2736           case IDM_RESELECT:
    2737             SelectList(hwnd,
    2738                        TRUE,
    2739                        FALSE,
    2740                        FALSE,
    2741                        NULL,
    2742                        NULL,
    2743                        dcd->lastselection);
    2744             break;
    2745 
    2746           case IDM_HELP:
    2747             if (hwndHelp)
    2748               WinSendMsg(hwndHelp,
    2749                          HM_DISPLAY_HELP,
    2750                          MPFROM2SHORT(HELP_ARCLIST,0),
    2751                          MPFROMSHORT(HM_RESOURCEID));
    2752             break;
    2753 
    2754           case IDM_WINDOWDLG:
    2755             if (!ParentIsDesktop(dcd->hwndParent,dcd->hwndFrame))
    2756               PostMsg(dcd->hwndParent,
    2757                       UM_COMMAND,
    2758                       MPFROM2SHORT(IDM_WINDOWDLG,0),
    2759                       MPVOID);
    2760             break;
    2761 
    2762           case IDM_SELECTALL:
    2763           case IDM_SELECTALLFILES:
    2764           case IDM_DESELECTALL:
    2765           case IDM_DESELECTALLFILES:
    2766           case IDM_SELECTMASK:
    2767           case IDM_DESELECTMASK:
    2768           case IDM_INVERT:
    2769             {
    2770               PARCITEM pci;
    2771 
    2772               pci = (PARCITEM)WinSendMsg(hwnd,
    2773                                          CM_QUERYRECORDEMPHASIS,
    2774                                          MPFROMLONG(CMA_FIRST),
    2775                                          MPFROMSHORT(CRA_CURSORED));
    2776               if ((INT)pci == -1)
    2777                 pci = NULL;
    2778               if (SHORT1FROMMP(mp1) == IDM_HIDEALL) {
    2779                 if (pci) {
    2780                   if (!(pci->rc.flRecordAttr & CRA_SELECTED))
    2781                     pci->rc.flRecordAttr |= CRA_FILTERED;
    2782                     WinSendMsg(hwnd,
    2783                                CM_INVALIDATERECORD,
    2784                                MPFROMP(&pci),
    2785                                MPFROM2SHORT(1,CMA_ERASE | CMA_REPOSITION));
    2786                     break;
    2787                 }
    2788               }
    2789               PostMsg(dcd->hwndObject,UM_SELECT,mp1,MPFROMP(pci));
    2790             }
    2791             break;
    2792 
    2793           case IDM_SORTSMARTNAME:
    2794           case IDM_SORTNAME:
    2795           case IDM_SORTFILENAME:
    2796           case IDM_SORTSIZE:
    2797           case IDM_SORTEASIZE:
    2798           case IDM_SORTFIRST:
    2799           case IDM_SORTLAST:
    2800           case IDM_SORTLWDATE:
    2801             dcd->sortFlags &= SORT_REVERSE;
    2802             /* intentional fallthru */
    2803           case IDM_SORTREVERSE:
    2804             switch(SHORT1FROMMP(mp1)) {
    2805               case IDM_SORTSMARTNAME:
    2806               case IDM_SORTFILENAME:
    2807                 dcd->sortFlags |= SORT_FILENAME;
    2808                 break;
    2809               case IDM_SORTSIZE:
    2810                 dcd->sortFlags |= SORT_SIZE;
    2811                 break;
    2812               case IDM_SORTEASIZE:
    2813                 dcd->sortFlags |= SORT_EASIZE;
    2814                 break;
    2815               case IDM_SORTFIRST:
    2816                 dcd->sortFlags |= SORT_FIRSTEXTENSION;
    2817                 break;
    2818               case IDM_SORTLAST:
    2819                 dcd->sortFlags |= SORT_LASTEXTENSION;
    2820                 break;
    2821               case IDM_SORTLWDATE:
    2822                 dcd->sortFlags |= SORT_LWDATE;
    2823                 break;
    2824               case IDM_SORTREVERSE:
    2825                 if (dcd->sortFlags & SORT_REVERSE)
    2826                   dcd->sortFlags &= (~SORT_REVERSE);
    2827                 else
    2828                   dcd->sortFlags |= SORT_REVERSE;
    2829                 break;
    2830             }
    2831             WinSendMsg(hwnd,CM_SORTRECORD,MPFROMP(ArcSort),MPFROMP(dcd));
    2832             SaySort(WinWindowFromID(WinQueryWindow(hwnd,QW_PARENT),
    2833                                     DIR_SORT),
    2834                     dcd->sortFlags,
    2835                     TRUE);
    2836             DefArcSortFlags = dcd->sortFlags;   // Remember for new windows
    2837             break;
    2838 
    2839           case IDM_COLLECTOR:
    2840             if (!Collector) {
    2841               HWND hwndC;
    2842               SWP  swp;
    2843 
    2844               if (ParentIsDesktop(hwnd,dcd->hwndParent) && !fAutoTile &&
    2845                   (!fExternalCollector && !strcmp(realappname,FM3Str)))
    2846                 GetNextWindowPos(dcd->hwndParent,&swp,NULL,NULL);
    2847               hwndC = StartCollector((fExternalCollector ||
    2848                                       strcmp(realappname,FM3Str)) ?
    2849                                      HWND_DESKTOP : dcd->hwndParent,4);
    2850               if (hwndC) {
    2851                 if (!ParentIsDesktop(hwnd,dcd->hwndParent) && !fAutoTile &&
    2852                     (!fExternalCollector && !strcmp(realappname,FM3Str)))
    2853                   WinSetWindowPos(hwndC,
    2854                                   HWND_TOP,
    2855                                   swp.x,
    2856                                   swp.y,
    2857                                   swp.cx,
    2858                                   swp.cy,
    2859                                   SWP_MOVE | SWP_SIZE |
    2860                                   SWP_SHOW | SWP_ZORDER);
    2861                 else if (!ParentIsDesktop(hwnd,dcd->hwndParent) &&
    2862                          fAutoTile &&
    2863                          !strcmp(realappname,FM3Str)) {
    2864                   TileChildren(dcd->hwndParent,TRUE);
    2865                 }
    2866                 WinSetWindowPos(hwndC,
    2867                                 HWND_TOP,
    2868                                 0,
    2869                                 0,
    2870                                 0,
    2871                                 0,
    2872                                 SWP_ACTIVATE);
    2873                 DosSleep(128L);
    2874               }
    2875             }
    2876             else
    2877               StartCollector(dcd->hwndParent,4);
    2878             break;
    2879 
    2880           case IDM_ARCEXTRACTEXIT:
    2881           case IDM_ARCEXTRACT:
    2882             if (dcd->info->extract)
    2883               runemf2(SEPARATE | WINDOWED |
    2884                       ((fArcStuffVisible) ? 0 : (BACKGROUND | MINIMIZED)),
    2885                       hwnd,dcd->directory,NULL,"%s %s%s%s",
    2886                       dcd->info->extract,
    2887                       (needs_quoting(dcd->arcname)) ? "\"" : NullStr,
    2888                       dcd->arcname,
    2889                       (needs_quoting(dcd->arcname)) ? "\"" : NullStr);
    2890             if (SHORT1FROMMP(mp1) == IDM_ARCEXTRACTEXIT)
    2891               PostMsg(hwnd,WM_CLOSE,MPVOID,MPVOID);
    2892             break;
    2893 
    2894           case IDM_ARCEXTRACTWDIRSEXIT:
    2895           case IDM_ARCEXTRACTWDIRS:
    2896             if (dcd->info->exwdirs)
    2897               runemf2(SEPARATE | WINDOWED |
    2898                       ((fArcStuffVisible) ? 0 : (BACKGROUND | MINIMIZED)) ,
    2899                       hwnd,dcd->directory,NULL,"%s %s%s%s",
    2900                       dcd->info->exwdirs,
    2901                       (needs_quoting(dcd->arcname)) ? "\"" : NullStr,
    2902                       dcd->arcname,
    2903                       (needs_quoting(dcd->arcname)) ? "\"" : NullStr);
    2904             if (SHORT1FROMMP(mp1) == IDM_ARCEXTRACTWDIRSEXIT)
    2905               PostMsg(hwnd,WM_CLOSE,MPVOID,MPVOID);
    2906             break;
    2907 
    2908           case IDM_RESORT:
    2909             WinSendMsg(hwnd,CM_SORTRECORD,MPFROMP(ArcSort),MPFROMP(dcd));
    2910             break;
    2911 
    2912           case IDM_FILTER:
    2913             {
    2914               BOOL     empty = FALSE;
    2915               PARCITEM pci;
    2916 
    2917               if (!*dcd->mask.szMask) {
    2918                 empty = TRUE;
    2919                 pci = (PARCITEM)CurrentRecord(hwnd);
    2920                 if (pci && strchr(pci->szFileName,'.'))
    2921                   strcpy(dcd->mask.szMask,pci->szFileName);
    2922               }
    2923 
    2924               if (WinDlgBox(HWND_DESKTOP,hwnd,PickMaskDlgProc,
    2925                             FM3ModHandle,MSK_FRAME,MPFROMP(&dcd->mask))) {
    2926                 WinSendMsg(hwnd,CM_FILTER,MPFROMP(ArcFilter),MPFROMP(dcd));
    2927                 PostMsg(hwnd,UM_RESCAN,MPVOID,MPVOID);
    2928               }
    2929               else if (empty)
    2930                 *dcd->mask.szMask = 0;
    2931               SayFilter(WinWindowFromID(WinQueryWindow(hwnd,QW_PARENT),
    2932                         DIR_FILTER),&dcd->mask,TRUE);
    2933             }
    2934             break;
    2935 
    2936           case IDM_SWITCH:
    2937             if (mp2) {
    2938               if (stricmp(dcd->directory,(CHAR *)mp2)) {
    2939                 DosEnterCritSec();
    2940                  strcpy(lastextractpath,(CHAR *)mp2);
    2941                  MakeValidDir(lastextractpath);
    2942                 DosExitCritSec();
    2943               }
    2944               strcpy(dcd->directory,(CHAR *)mp2);
    2945               MakeValidDir(dcd->directory);
    2946               WinSetWindowText(dcd->hwndExtract,dcd->directory);
    2947             }
    2948             break;
    2949 
    2950           case IDM_WALKDIR:
    2951             {
    2952               CHAR newdir[CCHMAXPATH];
    2953 
    2954               strcpy(newdir,dcd->directory);
    2955               if (!WinDlgBox(HWND_DESKTOP,dcd->hwndParent,WalkExtractDlgProc,
    2956                              FM3ModHandle,WALK_FRAME,
    2957                              MPFROMP(newdir)) || !*newdir)
    2958                 break;
    2959               if (stricmp(newdir,dcd->directory)) {
    2960                 strcpy(dcd->directory,newdir);
    2961                 if (stricmp(lastextractpath,newdir))
    2962                   strcpy(lastextractpath,newdir);
    2963                 WinSetWindowText(dcd->hwndExtract,dcd->directory);
    2964               }
    2965             }
    2966             break;
    2967 
    2968           case IDM_TEST:
    2969             if (dcd->info->test)
    2970               runemf2(SEPARATEKEEP | WINDOWED | MAXIMIZED,
    2971                       hwnd,NULL,NULL,"%s %s%s%s",dcd->info->test,
    2972                       (needs_quoting(dcd->arcname)) ? "\"" : NullStr,
    2973                       dcd->arcname,
    2974                       (needs_quoting(dcd->arcname)) ? "\"" : NullStr);
    2975             break;
    2976 
    2977           case IDM_REFRESH:
    2978           case IDM_DELETE:
    2979           case IDM_PRINT:
    2980           case IDM_VIEW:
    2981           case IDM_VIEWTEXT:
    2982           case IDM_VIEWBINARY:
    2983           case IDM_VIEWARCHIVE:
    2984           case IDM_EDIT:
    2985           case IDM_EDITTEXT:
    2986           case IDM_EDITBINARY:
    2987           case IDM_EXTRACT:
    2988           case IDM_EXTRACTWDIRS:
    2989           case IDM_FIND:
    2990           case IDM_EXEC:
    2991           case IDM_VIRUSSCAN:
    2992             {
    2993               LISTINFO *li;
    2994 
    2995               li = xmallocz(sizeof(LISTINFO),pszSrcFile,__LINE__);
    2996               if (li) {
    2997                 li->type = SHORT1FROMMP(mp1);
    2998                 li->hwnd = hwnd;
    2999                 li->list = BuildArcList(hwnd);
    3000                 if (li->type == IDM_REFRESH) {
    3001 
    3002                   CHAR s[CCHMAXPATH],*p;
    3003                   INT  x,y;
    3004 
    3005                   for (x = 0;li->list && li->list[x];x++) {
    3006                     sprintf(s,"%s%s%s",dcd->workdir,
    3007                             (dcd->workdir[strlen(dcd->workdir) - 1] == '\\') ?
    3008                             NullStr : "\\",li->list[x]);
    3009                     if (IsFile(s) != 1) {
    3010                       free(li->list[x]);
    3011                       li->list[x] = NULL;
    3012                       for (y = x;li->list[y];y++)
    3013                         li->list[y] = li->list[y + 1];
    3014                       li->list = xrealloc(li->list,y * sizeof(CHAR *),pszSrcFile,__LINE__);
    3015                       x--;
    3016                     }
    3017                     else {
    3018                       p = xstrdup(s,pszSrcFile,__LINE__);
    3019                       if (p) {
    3020                         free(li->list[x]);
    3021                         li->list[x] = p;
    3022                       }
    3023                     }
    3024                   } // for
    3025                 }
    3026                 strcpy(li->arcname,dcd->arcname);
    3027                 li->info = dcd->info;
    3028                 {
    3029                   PARCITEM pai;
    3030 
    3031                   if (SHORT1FROMMP(mp1) != IDM_EXEC)
    3032                     pai = (PARCITEM)CurrentRecord(hwnd);
    3033                   else
    3034                     pai = (PARCITEM)WinSendMsg(hwnd,CM_QUERYRECORDEMPHASIS,
    3035                                                MPFROMLONG(CMA_FIRST),
    3036                                                MPFROMSHORT(CRA_CURSORED));
    3037                   if (pai && (INT)pai != -1)
    3038                     strcpy(li->runfile,pai->szFileName);
    3039                   else
    3040                     strcpy(li->runfile,li->list[0]);
    3041                 }
    3042                 switch(SHORT1FROMMP(mp1)) {
    3043                   case IDM_VIEW:
    3044                   case IDM_VIEWTEXT:
    3045                   case IDM_VIEWBINARY:
    3046                   case IDM_VIEWARCHIVE:
    3047                   case IDM_EDIT:
    3048                   case IDM_EDITTEXT:
    3049                   case IDM_EDITBINARY:
    3050                   case IDM_EXEC:
    3051                   case IDM_PRINT:
    3052                   case IDM_VIRUSSCAN:
    3053                     strcpy(li->targetpath,dcd->workdir);
    3054                     break;
    3055                   default:
    3056                     strcpy(li->targetpath,dcd->directory);
    3057                     break;
    3058                 }
    3059                 if (li->list) {
    3060                   if (!PostMsg(dcd->hwndObject,UM_ACTION,MPFROMP(li),MPVOID)) {
    3061                     Runtime_Error(pszSrcFile, __LINE__, "post");
    3062                     FreeListInfo(li);
    3063                   }
    3064                   else if (fUnHilite && SHORT1FROMMP(mp1) != IDM_EDIT)
    3065                     UnHilite(hwnd,TRUE,&dcd->lastselection);
    3066                 }
    3067                 else
    3068                   free(li);
    3069               }
    3070             }
    3071             break;
    3072         }
    3073       }
    3074       return 0;
    3075 
    3076     case WM_CONTROL:
    3077       DosError(FERR_DISABLEHARDERR);
    3078       if (dcd) {
    3079         switch(SHORT2FROMMP(mp1)) {
    3080           case CN_BEGINEDIT:
    3081             PostMsg(hwnd,CM_CLOSEEDIT,MPVOID,MPVOID);
    3082             break;
    3083 
    3084           case CN_ENDEDIT:
    3085             if (!((PCNREDITDATA)mp2)->pRecord) {
    3086 
    3087               PFIELDINFO pfi = ((PCNREDITDATA)mp2)->pFieldInfo;
    3088               USHORT     cmd = 0;
    3089 
    3090               if (!pfi || pfi->offStruct == FIELDOFFSET(ARCITEM,pszFileName))
    3091                 cmd = IDM_SORTSMARTNAME;
    3092               else if (pfi->offStruct == FIELDOFFSET(ARCITEM,cbFile))
    3093                 cmd = IDM_SORTSIZE;
    3094               else if (pfi->offStruct == FIELDOFFSET(ARCITEM,cbComp))
    3095                 cmd = IDM_SORTEASIZE;
    3096               else if (pfi->offStruct == FIELDOFFSET(ARCITEM,date))
    3097                 cmd = IDM_SORTLWDATE;
    3098               else if (pfi->offStruct == FIELDOFFSET(ARCITEM,time))
    3099                 cmd = IDM_SORTLWDATE;
    3100               if (cmd)
    3101                 PostMsg(hwnd,WM_COMMAND,MPFROM2SHORT(cmd,0),MPVOID);
    3102             }
    3103             break;
    3104 
    3105           case CN_DROPHELP:
    3106             saymsg(MB_ENTER,hwnd,
    3107                    GetPString(IDS_DROPHELPHDRTEXT),
    3108                    GetPString(IDS_ARCCNRDROPHELPTEXT),
    3109                    dcd->arcname);
    3110             return 0;
    3111 
    3112           case CN_DRAGLEAVE:
    3113             if (mp2) {
    3114 
    3115               PDRAGINFO pDInfo;
    3116 
    3117               pDInfo = ((PCNRDRAGINFO)mp2)->pDragInfo;
    3118               DrgAccessDraginfo(pDInfo);             /* Access DRAGINFO       */
    3119               DrgFreeDraginfo(pDInfo);               /* Free DRAGINFO         */
    3120             }
    3121             return 0;
    3122 
    3123           case CN_DRAGAFTER:
    3124           case CN_DRAGOVER:
    3125             if (mp2) {
    3126 
    3127               PDRAGITEM pDItem;                      /* Pointer to DRAGITEM   */
    3128               PDRAGINFO pDInfo;                      /* Pointer to DRAGINFO   */
    3129               PARCITEM  pci;
    3130 
    3131               pci = (PARCITEM)((PCNRDRAGINFO)mp2)->pRecord;
    3132               if (SHORT1FROMMP(mp1) == CN_DRAGAFTER)
    3133                 pci = NULL;
    3134               pDInfo = ((PCNRDRAGINFO)mp2)->pDragInfo;
    3135               DrgAccessDraginfo(pDInfo);             /* Access DRAGINFO       */
    3136               if (*dcd->arcname) {
    3137                 if ((driveflags[toupper(*dcd->arcname) - 'A'] & DRIVE_NOTWRITEABLE) ||
    3138                     !dcd->info ||
    3139                     !dcd->info->create) {
    3140                   DrgFreeDraginfo(pDInfo);
    3141                   return MRFROM2SHORT(DOR_NEVERDROP,0);
    3142                 }
    3143               }
    3144               if (pci) {
    3145                 DrgFreeDraginfo(pDInfo);
    3146                 return MRFROM2SHORT(DOR_NODROP,0);
    3147               }
    3148               pDItem = DrgQueryDragitemPtr(pDInfo,      /* Access DRAGITEM       */
    3149                                            0);          /* Index to DRAGITEM     */
    3150               if (DrgVerifyRMF(pDItem,                  /* Check valid rendering */
    3151                                DRM_OS2FILE,             /* mechanisms and data   */
    3152                                NULL) &&
    3153                   !(pDItem->fsControl & DC_PREPARE)) {
    3154                 DrgFreeDraginfo(pDInfo);             /* Free DRAGINFO         */
    3155                 return(MRFROM2SHORT(DOR_DROP,        /* Return okay to drop   */
    3156                                     ((fCopyDefault) ?
    3157                                      DO_COPY : DO_MOVE)));
    3158               }
    3159               DrgFreeDraginfo(pDInfo);               /* Free DRAGINFO         */
    3160             }
    3161             return(MRFROM2SHORT(DOR_NEVERDROP,0)); /* Drop not valid        */
    3162 
    3163           case CN_INITDRAG:
    3164             if (mp2) {
    3165 
    3166               BOOL         wasemphasized = FALSE;
    3167               PCNRDRAGINIT pcd = (PCNRDRAGINIT)mp2;
    3168               PARCITEM  pci;
    3169 
    3170               if (pcd) {
    3171                 pci = (PARCITEM)pcd->pRecord;
    3172                 if (pci) {
    3173                   if (pci->rc.flRecordAttr & CRA_SELECTED)
    3174                     wasemphasized = TRUE;
    3175                   if (!ParentIsDesktop(hwnd,dcd->hwndParent) &&
    3176                       fSplitStatus && hwndStatus2)
    3177                     WinSetWindowText(hwndStatus2,
    3178                                      GetPString(IDS_DRAGARCMEMTEXT));
    3179                   if (DoFileDrag(hwnd,
    3180                                  dcd->hwndObject,
    3181                                  mp2,
    3182                                  dcd->arcname,
    3183                                  NULL,
    3184                                  TRUE)) {
    3185                     if (fUnHilite && wasemphasized)
    3186                       UnHilite(hwnd,TRUE,&dcd->lastselection);
    3187                   }
    3188                   if (!ParentIsDesktop(hwnd,dcd->hwndParent) &&
    3189                       fSplitStatus && hwndStatus2) {
    3190                     PostMsg(hwnd,UM_RESCAN,MPVOID,MPVOID);
    3191                   }
    3192                 }
    3193                 else {
    3194                   if (!ParentIsDesktop(hwnd,dcd->hwndParent) &&
    3195                       fSplitStatus && hwndStatus2)
    3196                     WinSetWindowText(hwndStatus2,
    3197                                      GetPString(IDS_DRAGARCFILETEXT));
    3198                   DragOne(hwnd,
    3199                           dcd->hwndObject,
    3200                           dcd->arcname,
    3201                           FALSE);
    3202                   if (!ParentIsDesktop(hwnd,dcd->hwndParent) &&
    3203                       fSplitStatus && hwndStatus2)
    3204                     PostMsg(hwnd,UM_RESCAN,MPVOID,MPVOID);
    3205                 }
    3206               }
    3207             }
    3208             return 0;
    3209 
    3210           case CN_DROP:
    3211             if (mp2) {
    3212 
    3213               LISTINFO *li;
    3214 
    3215               DosBeep(500,100);                 // fixme to know why beep?
    3216               li = DoFileDrop(hwnd,
    3217                               dcd->arcname,
    3218                               FALSE,
    3219                               mp1,
    3220                               mp2);
    3221               DosBeep(50,100);                  // fixme to know why beep?
    3222               if (li) {
    3223                 li->type = (li->type == DO_MOVE) ?
    3224                             IDM_ARCHIVEM :
    3225                             IDM_ARCHIVE;
    3226                 strcpy(li->targetpath,dcd->arcname);
    3227                 if (!li->list ||
    3228                     !li->list[0] ||
    3229                     !PostMsg(dcd->hwndObject,UM_ACTION,MPFROMP(li),MPVOID))
    3230                   FreeListInfo(li);
    3231               }
    3232             }
    3233             return 0;
    3234 
    3235           case CN_CONTEXTMENU:
    3236             {
    3237               PARCITEM pci = (PARCITEM)mp2;
    3238 
    3239               if (pci) {
    3240                 WinSendMsg(hwnd,CM_SETRECORDEMPHASIS,MPFROMP(pci),
    3241                            MPFROM2SHORT(TRUE,CRA_CURSORED));
    3242                 MarkAll(hwnd,FALSE,FALSE,TRUE);
    3243                 dcd->hwndLastMenu = CheckMenu(&ArcMenu,ARC_POPUP);
    3244               }
    3245               else {
    3246                 dcd->hwndLastMenu = CheckMenu(&ArcCnrMenu,ARCCNR_POPUP);
    3247                 if (dcd->hwndLastMenu && !dcd->cnremphasized) {
    3248                   WinSendMsg(hwnd,CM_SETRECORDEMPHASIS,MPVOID,
    3249                              MPFROM2SHORT(TRUE,CRA_SOURCE));
    3250                   dcd->cnremphasized = TRUE;
    3251                 }
    3252               }
    3253               if (dcd->hwndLastMenu) {
    3254                 if (dcd->hwndLastMenu == ArcCnrMenu) {
    3255                   if (dcd->flWindowAttr & CV_MINI)
    3256                     WinCheckMenuItem(dcd->hwndLastMenu,IDM_MINIICONS,TRUE);
    3257                 }
    3258                 WinCheckMenuItem(dcd->hwndLastMenu,IDM_FOLDERAFTEREXTRACT,
    3259                                  fFolderAfterExtract);
    3260                 if (!PopupMenu(hwnd,hwnd,dcd->hwndLastMenu)) {
    3261                   if (dcd->cnremphasized) {
    3262                     WinSendMsg(hwnd,CM_SETRECORDEMPHASIS,MPVOID,
    3263                                MPFROM2SHORT(FALSE,CRA_SOURCE));
    3264                     dcd->cnremphasized = TRUE;
    3265                   }
    3266                   MarkAll(hwnd,TRUE,FALSE,TRUE);
    3267                 }
    3268               }
    3269             }
    3270             break;
    3271 
    3272           case CN_EMPHASIS:
    3273             if (mp2) {
    3274 
    3275               PNOTIFYRECORDEMPHASIS pre = mp2;
    3276               PARCITEM              pci;
    3277               CHAR                  s[CCHMAXPATHCOMP + 91],tf[81],tb[81];
    3278 
    3279               pci = (PARCITEM)((pre) ? pre->pRecord : NULL);
    3280               if (!pci) {
    3281                 if (!ParentIsDesktop(hwnd,dcd->hwndParent)) {
    3282                   if (hwndStatus2)
    3283                     WinSetWindowText(hwndStatus2,NullStr);
    3284                   if (fMoreButtons)
    3285                     WinSetWindowText(hwndName,NullStr);
    3286                 }
    3287                 break;
    3288               }
    3289               if (pre->fEmphasisMask & CRA_SELECTED) {
    3290                 if (pci->rc.flRecordAttr & CRA_SELECTED) {
    3291                   dcd->selectedbytes += pci->cbFile;
    3292                   dcd->selectedfiles++;
    3293                 }
    3294                 else if (dcd->selectedfiles) {
    3295                   dcd->selectedbytes -= pci->cbFile;
    3296                   dcd->selectedfiles--;
    3297                 }
    3298                 commafmt(tf,sizeof(tf),dcd->selectedfiles);
    3299                 if (dcd->ullTotalBytes)
    3300                   CommaFmtULL(tb,sizeof(tb),dcd->selectedbytes,' ');
    3301                 else
    3302                   *tb = 0;
    3303                 sprintf(s,"%s%s%s",
    3304                         tf,
    3305                         *tb ? " / " : NullStr,
    3306                         tb);
    3307                 WinSetDlgItemText(dcd->hwndClient,DIR_SELECTED,s);
    3308               }
    3309               else if (WinQueryActiveWindow(dcd->hwndParent) ==
    3310                        dcd->hwndFrame &&
    3311                        !ParentIsDesktop(hwnd,dcd->hwndParent)) {
    3312                 if (pre->fEmphasisMask & CRA_CURSORED) {
    3313                   if (pci->rc.flRecordAttr & CRA_CURSORED) {
    3314                     if (fSplitStatus && hwndStatus2) {
    3315                       if (dcd->ullTotalBytes)
    3316                         CommaFmtULL(tb,sizeof(tb),pci->cbFile,' ');
    3317                       else
    3318                         *tb = 0;
    3319                       sprintf(s,"%s%s%s%s",
    3320                               *tb ? " " : NullStr,
    3321                               tb,
    3322                               *tb ? "  " : NullStr,
    3323                               pci->szFileName);
    3324                       WinSetWindowText(hwndStatus2,s);
    3325                     }
    3326                     if (fMoreButtons)
    3327                       WinSetWindowText(hwndName,pci->szFileName);
    3328                   }
    3329                 }
    3330               }
    3331             }
    3332             break;
    3333 
    3334           case CN_ENTER:
    3335             if (mp2) {
    3336 
    3337               PARCITEM pci = (PARCITEM)((PNOTIFYRECORDENTER)mp2)->pRecord;
    3338 
    3339               if (pci) {
    3340 
    3341                 CHAR *s;
    3342 
    3343                 if ((pci->rc.flRecordAttr & CRA_INUSE) ||
    3344                     (pci->flags & (ARCFLAGS_REALDIR | ARCFLAGS_PSEUDODIR)))
    3345                   break;
    3346                 s = xstrdup(pci->szFileName,pszSrcFile,__LINE__);
    3347                 if (s) {
    3348                   if (!PostMsg(dcd->hwndObject,UM_ENTER,MPFROMP(s),MPVOID)) {
    3349                     Runtime_Error(pszSrcFile, __LINE__, "post");
    3350                     free(s);
    3351                   }
    3352                 }
    3353               }
    3354             }
    3355             break;
    3356         }
    3357       }
    3358       return 0;
    3359 
    3360     case UM_FOLDUP:
    3361       if (!PostMsg((HWND)0,WM_QUIT,MPVOID,MPVOID))
    3362         DosExit(EXIT_PROCESS,1);
    3363       return 0;
    3364 
    3365     case UM_CLOSE:
    3366       WinDestroyWindow(WinQueryWindow(WinQueryWindow(hwnd,QW_PARENT),
    3367                        QW_PARENT));
    3368       return 0;
    3369 
    3370     case WM_SAVEAPPLICATION:
    3371       if (dcd &&
    3372           ParentIsDesktop(hwnd,dcd->hwndParent)) {
    3373         SWP swp;
    3374         WinQueryWindowPos(dcd->hwndFrame,&swp);
    3375         if (!(swp.fl & (SWP_HIDE | SWP_MINIMIZE | SWP_MAXIMIZE)))
    3376           PrfWriteProfileData(fmprof,
    3377                               appname,
    3378                               "AV2SizePos",
    3379                               &swp,
    3380                               sizeof(swp));
    3381       }
    3382       break;
    3383 
    3384     case WM_CLOSE:
    3385       WinSendMsg(hwnd,WM_SAVEAPPLICATION,MPVOID,MPVOID);
    3386       if (dcd)
    3387         dcd->stopflag++;
    3388       if (dcd && dcd->hwndObject) {
    3389         if (!PostMsg(dcd->hwndObject,WM_CLOSE,MPVOID,MPVOID))
    3390           WinSendMsg(dcd->hwndObject,WM_CLOSE,MPVOID,MPVOID);
    3391       }
    3392       // In case object window frees dcd
    3393       dcd = WinQueryWindowPtr(hwnd,QWL_USER);
    3394       if (!dcd ||
    3395           (!dcd->dontclose &&
    3396            !dcd->amextracted &&
    3397            ParentIsDesktop(hwnd,dcd->hwndParent))) {
    3398         if (!PostMsg(hwnd,UM_FOLDUP,MPVOID,MPVOID))
    3399           WinSendMsg(hwnd,UM_FOLDUP,MPVOID,MPVOID);
    3400       }
    3401       return 0;
    3402 
    3403     case WM_DESTROY:
    3404       if (ArcMenu)
    3405         WinDestroyWindow(ArcMenu);
    3406       if (ArcCnrMenu)
    3407         WinDestroyWindow(ArcCnrMenu);
    3408       ArcMenu = ArcCnrMenu = (HWND)0;
    3409       EmptyCnr(hwnd);
    3410       break;
    3411   }
    3412   return (dcd && dcd->oldproc) ? dcd->oldproc(hwnd,msg,mp1,mp2) :
    3413                                  PFNWPCnr(hwnd,msg,mp1,mp2);
    3414 }
    3415 
    3416 
    3417 HWND StartArcCnr (HWND hwndParent,HWND hwndCaller,CHAR *arcname,INT flags,
    3418                   ARC_TYPE *sinfo)
     3194HWND StartArcCnr(HWND hwndParent, HWND hwndCaller, CHAR * arcname, INT flags,
     3195                 ARC_TYPE * sinfo)
    34193196{
    34203197  /*
    … …  
    34243201   */
    34253202
    3426   HWND          hwndFrame = (HWND)0,hwndClient;
    3427   ULONG         FrameFlags = FCF_TITLEBAR   | FCF_SYSMENU     |
    3428                              FCF_SIZEBORDER | FCF_MINMAX      |
    3429                              FCF_ICON       | FCF_NOBYTEALIGN |
    3430                              FCF_ACCELTABLE;
    3431   USHORT        id;
    3432   DIRCNRDATA   *dcd;
    3433   ARC_TYPE     *info = sinfo;
    3434   CHAR          title[MAXNAMEL + 1] = "AV/2 - ";
    3435   CHAR          fullname[CCHMAXPATH + 8], *p, temp;
     3203  HWND hwndFrame = (HWND) 0, hwndClient;
     3204  ULONG FrameFlags = FCF_TITLEBAR | FCF_SYSMENU |
     3205    FCF_SIZEBORDER | FCF_MINMAX | FCF_ICON | FCF_NOBYTEALIGN | FCF_ACCELTABLE;
     3206  USHORT id;
     3207  DIRCNRDATA *dcd;
     3208  ARC_TYPE *info = sinfo;
     3209  CHAR title[MAXNAMEL + 1] = "AV/2 - ";
     3210  CHAR fullname[CCHMAXPATH + 8], *p, temp;
    34363211  static USHORT idinc = 0;
    34373212
    34383213  if (!idinc)
    34393214    idinc = (rand() % 256);
    3440   if (ParentIsDesktop(hwndParent,hwndParent))
     3215  if (ParentIsDesktop(hwndParent, hwndParent))
    34413216    FrameFlags |= (FCF_TASKLIST | FCF_MENU);
    34423217  if (arcname) {
    34433218    DosError(FERR_DISABLEHARDERR);
    34443219    if (DosQueryPathInfo(arcname,
    3445                          FIL_QUERYFULLNAME,
    3446                          fullname,
    3447                          sizeof(fullname)))
    3448       strcpy(fullname,arcname);
     3220                         FIL_QUERYFULLNAME, fullname, sizeof(fullname)))
     3221      strcpy(fullname, arcname);
    34493222    p = fullname;
    3450     while(*p) {
     3223    while (*p) {
    34513224      if (*p == '/')
    3452         *p = '\\';
     3225        *p = '\\';
    34533226      p++;
    34543227    }
    34553228    if (!info)
    3456       info = find_type(fullname,
    3457                        arcsighead);
     3229      info = find_type(fullname, arcsighead);
    34583230    if (!info)
    34593231      return hwndFrame;
    3460     if (strlen(title) + strlen(fullname) > MAXNAMEL)
    3461     {
    3462         p = title + strlen(title);
    3463         strncpy(p, fullname, MAXNAMEL/2 - 5);
    3464         strcpy(p + MAXNAMEL/2 - 5, "...");
    3465         strcat(title, fullname + strlen(fullname) - (MAXNAMEL/2 - 5));
    3466     }
    3467     else
    3468     {
    3469         strcat(title, fullname);
     3232    if (strlen(title) + strlen(fullname) > MAXNAMEL) {
     3233      p = title + strlen(title);
     3234      strncpy(p, fullname, MAXNAMEL / 2 - 5);
     3235      strcpy(p + MAXNAMEL / 2 - 5, "...");
     3236      strcat(title, fullname + strlen(fullname) - (MAXNAMEL / 2 - 5));
     3237    }
     3238    else {
     3239      strcat(title, fullname);
    34703240    }
    34713241    hwndFrame = WinCreateStdWindow(hwndParent,
    3472                                    WS_VISIBLE,
    3473                                    &FrameFlags,
    3474                                    GetPString(IDS_WCARCCONTAINER),
    3475                                    title,
    3476                                    WS_VISIBLE | fwsAnimate,
    3477                                    FM3ModHandle,
    3478                                    ARC_FRAME,
    3479                                    &hwndClient);
     3242                                   WS_VISIBLE,
     3243                                   &FrameFlags,
     3244                                   GetPString(IDS_WCARCCONTAINER),
     3245                                   title,
     3246                                   WS_VISIBLE | fwsAnimate,
     3247                                   FM3ModHandle, ARC_FRAME, &hwndClient);
    34803248    if (hwndFrame && hwndClient) {
    34813249      id = ARC_FRAME + idinc++;
    34823250      if (idinc > 512)
    3483         idinc = 0;
    3484       WinSetWindowUShort(hwndFrame,QWS_ID,id);
    3485       dcd = xmallocz(sizeof(DIRCNRDATA),pszSrcFile,__LINE__);
     3251        idinc = 0;
     3252      WinSetWindowUShort(hwndFrame, QWS_ID, id);
     3253      dcd = xmallocz(sizeof(DIRCNRDATA), pszSrcFile, __LINE__);
    34863254      if (!dcd) {
    3487         PostMsg(hwndClient,WM_CLOSE,MPVOID,MPVOID);
    3488         hwndFrame = (HWND)0;
     3255        PostMsg(hwndClient, WM_CLOSE, MPVOID, MPVOID);
     3256        hwndFrame = (HWND) 0;
    34893257      }
    34903258      else {
    3491         dcd->size = sizeof(DIRCNRDATA);
    3492         dcd->id = id;
    3493         dcd->type = ARC_FRAME;
    3494         save_dir2(dcd->workdir);
    3495         if (dcd->workdir[strlen(dcd->workdir) - 1] != '\\')
    3496           strcat(dcd->workdir,"\\");
    3497         sprintf(dcd->workdir + strlen(dcd->workdir),"%s.%03x",
    3498                 ArcTempRoot,(clock() & 4095));
    3499         strcpy(dcd->arcname,fullname);
    3500         if (*extractpath) {
    3501           if (!strcmp(extractpath,"*")) {
    3502             p = strrchr(fullname,'\\');
    3503             if (p) {
    3504               if (p < fullname + 3)
    3505                 p++;
    3506               temp = *p;
    3507               *p = 0;
    3508               strcpy(dcd->directory,fullname);
    3509               *p = temp;
    3510             }
    3511           }
    3512           else
    3513             strcpy(dcd->directory,extractpath);
    3514         }
    3515         if (!*dcd->directory && *lastextractpath) {
    3516           DosEnterCritSec();
    3517           strcpy(dcd->directory,lastextractpath);
    3518           DosExitCritSec();
    3519         }
    3520         if (!*dcd->directory) {
    3521           if (!ParentIsDesktop(hwndParent,hwndParent))
    3522             TopWindowName(hwndParent,
    3523                           hwndCaller,
    3524                           dcd->directory);
    3525           if (!*dcd->directory) {
    3526             p = strrchr(fullname,'\\');
    3527             if (p) {
    3528               if (p < fullname + 3)
    3529                 p++;
    3530               *p = 0;
    3531               strcpy(dcd->directory,fullname);
    3532             }
    3533           }
    3534         }
    3535         if (!*dcd->directory ||
    3536             IsFile(dcd->directory) ||
    3537             (isalpha(*dcd->directory) &&
    3538              (driveflags[toupper(*dcd->directory) - 'A'] & DRIVE_NOTWRITEABLE)))
    3539           save_dir2(dcd->directory);
    3540         dcd->hwndParent = (hwndParent) ? hwndParent :
    3541                                          HWND_DESKTOP;
    3542         dcd->hwndFrame  = hwndFrame;
    3543         dcd->hwndClient = hwndClient;
    3544         dcd->amextracted = ((flags & 1) != 0);
    3545         dcd->dontclose = ((flags & 4) != 0);
    3546         dcd->info = info;
    3547         dcd->sortFlags = DefArcSortFlags;
    3548         {
    3549           PFNWP oldproc;
    3550 
    3551           oldproc = WinSubclassWindow(hwndFrame,
    3552                                       (PFNWP)ArcFrameWndProc);
    3553           WinSetWindowPtr(hwndFrame,
    3554                           QWL_USER,
    3555                           (PVOID)oldproc);
    3556         }
    3557         dcd->hwndCnr = WinCreateWindow(hwndClient,
    3558                                        WC_CONTAINER,
    3559                                        NULL,
    3560                                        CCS_AUTOPOSITION | CCS_MINIICONS |
    3561                                        CCS_MINIRECORDCORE | ulCnrType |
    3562                                        WS_VISIBLE,
    3563                                        0,
    3564                                        0,
    3565                                        0,
    3566                                        0,
    3567                                        hwndClient,
    3568                                        HWND_TOP,
    3569                                        (ULONG)ARC_CNR,
    3570                                        NULL,
    3571                                        NULL);
    3572         if (!dcd->hwndCnr) {
    3573           Win_Error2(hwndClient,hwndClient,pszSrcFile,__LINE__,IDS_WINCREATEWINDOW);
    3574           PostMsg(hwndClient,WM_CLOSE,MPVOID,MPVOID);
    3575           free(dcd);
    3576           hwndFrame = (HWND)0;
     3259        dcd->size = sizeof(DIRCNRDATA);
     3260        dcd->id = id;
     3261        dcd->type = ARC_FRAME;
     3262        save_dir2(dcd->workdir);
     3263        if (dcd->workdir[strlen(dcd->workdir) - 1] != '\\')
     3264          strcat(dcd->workdir, "\\");
     3265        sprintf(dcd->workdir + strlen(dcd->workdir), "%s.%03x",
     3266                ArcTempRoot, (clock() & 4095));
     3267        strcpy(dcd->arcname, fullname);
     3268        if (*extractpath) {
     3269          if (!strcmp(extractpath, "*")) {
     3270            p = strrchr(fullname, '\\');
     3271            if (p) {
     3272              if (p < fullname + 3)
     3273                p++;
     3274              temp = *p;
     3275              *p = 0;
     3276              strcpy(dcd->directory, fullname);
     3277              *p = temp;
     3278            }
     3279          }
     3280          else
     3281            strcpy(dcd->directory, extractpath);
     3282        }
     3283        if (!*dcd->directory && *lastextractpath) {
     3284          DosEnterCritSec();
     3285          strcpy(dcd->directory, lastextractpath);
     3286          DosExitCritSec();
     3287        }
     3288        if (!*dcd->directory) {
     3289          if (!ParentIsDesktop(hwndParent, hwndParent))
     3290            TopWindowName(hwndParent, hwndCaller, dcd->directory);
     3291          if (!*dcd->directory) {
     3292            p = strrchr(fullname, '\\');
     3293            if (p) {
     3294              if (p < fullname + 3)
     3295                p++;
     3296              *p = 0;
     3297              strcpy(dcd->directory, fullname);
     3298            }
     3299          }
     3300        }
     3301        if (!*dcd->directory ||
     3302            IsFile(dcd->directory) ||
     3303            (isalpha(*dcd->directory) &&
     3304             (driveflags[toupper(*dcd->directory) - 'A'] &
     3305              DRIVE_NOTWRITEABLE)))
     3306          save_dir2(dcd->directory);
     3307        dcd->hwndParent = (hwndParent) ? hwndParent : HWND_DESKTOP;
     3308        dcd->hwndFrame = hwndFrame;
     3309        dcd->hwndClient = hwndClient;
     3310        dcd->amextracted = ((flags & 1) != 0);
     3311        dcd->dontclose = ((flags & 4) != 0);
     3312        dcd->info = info;
     3313        dcd->sortFlags = DefArcSortFlags;
     3314        {
     3315          PFNWP oldproc;
     3316
     3317          oldproc = WinSubclassWindow(hwndFrame, (PFNWP) ArcFrameWndProc);
     3318          WinSetWindowPtr(hwndFrame, QWL_USER, (PVOID) oldproc);
     3319        }
     3320        dcd->hwndCnr = WinCreateWindow(hwndClient,
     3321                                       WC_CONTAINER,
     3322                                       NULL,
     3323                                       CCS_AUTOPOSITION | CCS_MINIICONS |
     3324                                       CCS_MINIRECORDCORE | ulCnrType |
     3325                                       WS_VISIBLE,
     3326                                       0,
     3327                                       0,
     3328                                       0,
     3329                                       0,
     3330                                       hwndClient,
     3331                                       HWND_TOP, (ULONG) ARC_CNR, NULL, NULL);
     3332        if (!dcd->hwndCnr) {
     3333          Win_Error2(hwndClient, hwndClient, pszSrcFile, __LINE__,
     3334                     IDS_WINCREATEWINDOW);
     3335          PostMsg(hwndClient, WM_CLOSE, MPVOID, MPVOID);
     3336          free(dcd);
     3337          hwndFrame = (HWND) 0;
    35773338        }
    35783339        else {
    3579           WinSetWindowPtr(dcd->hwndCnr,
    3580                           QWL_USER,
    3581                           (PVOID)dcd);
    3582           dcd->oldproc = WinSubclassWindow(dcd->hwndCnr,
    3583                                            (PFNWP)ArcCnrWndProc);
    3584           {
    3585             USHORT ids[] = {DIR_TOTALS,DIR_SELECTED,DIR_VIEW,DIR_SORT,
    3586                             DIR_FILTER,DIR_FOLDERICON,0};
    3587 
    3588             CommonCreateTextChildren(dcd->hwndClient,
    3589                                      GetPString(IDS_WCARCSTATUS),
    3590                                      ids);
    3591           }
    3592           WinEnableWindow(WinWindowFromID(dcd->hwndClient,DIR_VIEW),
    3593                           FALSE);
    3594           dcd->hwndExtract = WinCreateWindow(dcd->hwndClient,
    3595                                              WC_ENTRYFIELD,
    3596                                              NULL,
    3597                                              ES_AUTOSCROLL,
    3598                                              0,
    3599                                              0,
    3600                                              0,
    3601                                              0,
    3602                                              dcd->hwndClient,
    3603                                              HWND_TOP,
    3604                                              ARC_EXTRACTDIR,
    3605                                              NULL,
    3606                                              NULL);
    3607           WinSendMsg(dcd->hwndExtract,
    3608                      EM_SETTEXTLIMIT,
    3609                      MPFROM2SHORT(CCHMAXPATH,0),
    3610                      MPVOID);
    3611           WinSetWindowText(dcd->hwndExtract,dcd->directory);
    3612           if (!PostMsg(dcd->hwndCnr,UM_SETUP,MPVOID,MPVOID))
    3613             WinSendMsg(dcd->hwndCnr,UM_SETUP,MPVOID,MPVOID);
    3614           if (FrameFlags & FCF_MENU) {
    3615             if (!fToolbar) {
    3616               HWND hwndMenu = WinWindowFromID(hwndFrame,FID_MENU);
    3617 
    3618               if (hwndMenu) {
    3619                 WinSendMsg(hwndMenu,MM_DELETEITEM,
    3620                            MPFROM2SHORT(IDM_VIEW,FALSE),
    3621                            MPVOID);
    3622                 WinSendMsg(hwndMenu,MM_DELETEITEM,
    3623                            MPFROM2SHORT(IDM_EXEC,FALSE),
    3624                            MPVOID);
    3625                 WinSendMsg(hwndMenu,MM_DELETEITEM,
    3626                            MPFROM2SHORT(IDM_RESCAN,FALSE),
    3627                            MPVOID);
    3628                 WinSendMsg(hwndMenu,MM_DELETEITEM,
    3629                            MPFROM2SHORT(IDM_DELETE,FALSE),
    3630                            MPVOID);
    3631                 WinSendMsg(hwndMenu,MM_DELETEITEM,
    3632                            MPFROM2SHORT(IDM_EXTRACT,FALSE),
    3633                            MPVOID);
    3634                 WinSendMsg(hwndMenu,MM_DELETEITEM,
    3635                            MPFROM2SHORT(IDM_TEST,FALSE),
    3636                            MPVOID);
    3637                 WinSendMsg(hwndMenu,MM_DELETEITEM,
    3638                            MPFROM2SHORT(IDM_VIRUSSCAN,FALSE),
    3639                            MPVOID);
    3640                 WinSendMsg(hwndMenu,MM_DELETEITEM,
    3641                            MPFROM2SHORT(IDM_WALKDIR,FALSE),
    3642                            MPVOID);
    3643                 WinSendMsg(hwndMenu,MM_DELETEITEM,
    3644                            MPFROM2SHORT(IDM_FILTER,FALSE),
    3645                            MPVOID);
    3646               }
    3647             }
    3648           }
    3649           if (FrameFlags & FCF_TASKLIST) {
    3650 
    3651             SWP   swp,swpD;
    3652             ULONG size = sizeof(swp);
    3653             LONG  cxScreen,cyScreen;
    3654 
    3655             WinQueryTaskSizePos(WinQueryAnchorBlock(hwndFrame),0,&swp);
    3656             if (PrfQueryProfileData(fmprof,
    3657                                    appname,
    3658                                    "AV2SizePos",
    3659                                    &swpD,
    3660                                    &size)) {
    3661               cxScreen = WinQuerySysValue(HWND_DESKTOP,SV_CXSCREEN);
    3662               cyScreen = WinQuerySysValue(HWND_DESKTOP,SV_CYSCREEN);
    3663               if (swp.x + swpD.cx > cxScreen)
    3664                 swp.x = cxScreen - swpD.cx;
    3665               if (swp.y + swpD.cy > cyScreen)
    3666                 swp.y = cyScreen - swpD.cy;
    3667               swp.cx = swpD.cx;
    3668               swp.cy = swpD.cy;
    3669             }
    3670             WinSetWindowPos(hwndFrame,
    3671                             HWND_TOP,
    3672                             swp.x,
    3673                             swp.y,
    3674                             swp.cx,
    3675                             swp.cy,
    3676                             SWP_SIZE | SWP_MOVE | SWP_SHOW | SWP_ZORDER |
    3677                             SWP_ACTIVATE);
    3678           }
    3679         }
     3340          WinSetWindowPtr(dcd->hwndCnr, QWL_USER, (PVOID) dcd);
     3341          dcd->oldproc = WinSubclassWindow(dcd->hwndCnr,
     3342                                           (PFNWP) ArcCnrWndProc);
     3343          {
     3344            USHORT ids[] = { DIR_TOTALS, DIR_SELECTED, DIR_VIEW, DIR_SORT,
     3345              DIR_FILTER, DIR_FOLDERICON, 0
     3346            };
     3347
     3348            CommonCreateTextChildren(dcd->hwndClient,
     3349                                     GetPString(IDS_WCARCSTATUS), ids);
     3350          }
     3351          WinEnableWindow(WinWindowFromID(dcd->hwndClient, DIR_VIEW), FALSE);
     3352          dcd->hwndExtract = WinCreateWindow(dcd->hwndClient,
     3353                                             WC_ENTRYFIELD,
     3354                                             NULL,
     3355                                             ES_AUTOSCROLL,
     3356                                             0,
     3357                                             0,
     3358                                             0,
     3359                                             0,
     3360                                             dcd->hwndClient,
     3361                                             HWND_TOP,
     3362                                             ARC_EXTRACTDIR, NULL, NULL);
     3363          WinSendMsg(dcd->hwndExtract,
     3364                     EM_SETTEXTLIMIT, MPFROM2SHORT(CCHMAXPATH, 0), MPVOID);
     3365          WinSetWindowText(dcd->hwndExtract, dcd->directory);
     3366          if (!PostMsg(dcd->hwndCnr, UM_SETUP, MPVOID, MPVOID))
     3367            WinSendMsg(dcd->hwndCnr, UM_SETUP, MPVOID, MPVOID);
     3368          if (FrameFlags & FCF_MENU) {
     3369            if (!fToolbar) {
     3370              HWND hwndMenu = WinWindowFromID(hwndFrame, FID_MENU);
     3371
     3372              if (hwndMenu) {
     3373                WinSendMsg(hwndMenu, MM_DELETEITEM,
     3374                           MPFROM2SHORT(IDM_VIEW, FALSE), MPVOID);
     3375                WinSendMsg(hwndMenu, MM_DELETEITEM,
     3376                           MPFROM2SHORT(IDM_EXEC, FALSE), MPVOID);
     3377                WinSendMsg(hwndMenu, MM_DELETEITEM,
     3378                           MPFROM2SHORT(IDM_RESCAN, FALSE), MPVOID);
     3379                WinSendMsg(hwndMenu, MM_DELETEITEM,
     3380                           MPFROM2SHORT(IDM_DELETE, FALSE), MPVOID);
     3381                WinSendMsg(hwndMenu, MM_DELETEITEM,
     3382                           MPFROM2SHORT(IDM_EXTRACT, FALSE), MPVOID);
     3383                WinSendMsg(hwndMenu, MM_DELETEITEM,
     3384                           MPFROM2SHORT(IDM_TEST, FALSE), MPVOID);
     3385                WinSendMsg(hwndMenu, MM_DELETEITEM,
     3386                           MPFROM2SHORT(IDM_VIRUSSCAN, FALSE), MPVOID);
     3387                WinSendMsg(hwndMenu, MM_DELETEITEM,
     3388                           MPFROM2SHORT(IDM_WALKDIR, FALSE), MPVOID);
     3389                WinSendMsg(hwndMenu, MM_DELETEITEM,
     3390                           MPFROM2SHORT(IDM_FILTER, FALSE), MPVOID);
     3391              }
     3392            }
     3393          }
     3394          if (FrameFlags & FCF_TASKLIST) {
     3395
     3396            SWP swp, swpD;
     3397            ULONG size = sizeof(swp);
     3398            LONG cxScreen, cyScreen;
     3399
     3400            WinQueryTaskSizePos(WinQueryAnchorBlock(hwndFrame), 0, &swp);
     3401            if (PrfQueryProfileData(fmprof,
     3402                                    appname, "AV2SizePos", &swpD, &size)) {
     3403              cxScreen = WinQuerySysValue(HWND_DESKTOP, SV_CXSCREEN);
     3404              cyScreen = WinQuerySysValue(HWND_DESKTOP, SV_CYSCREEN);
     3405              if (swp.x + swpD.cx > cxScreen)
     3406                swp.x = cxScreen - swpD.cx;
     3407              if (swp.y + swpD.cy > cyScreen)
     3408                swp.y = cyScreen - swpD.cy;
     3409              swp.cx = swpD.cx;
     3410              swp.cy = swpD.cy;
     3411            }
     3412            WinSetWindowPos(hwndFrame,
     3413                            HWND_TOP,
     3414                            swp.x,
     3415                            swp.y,
     3416                            swp.cx,
     3417                            swp.cy,
     3418                            SWP_SIZE | SWP_MOVE | SWP_SHOW | SWP_ZORDER |
     3419                            SWP_ACTIVATE);
     3420          }
     3421        }
    36803422      }
    36813423    }
Note: See TracChangeset for help on using the changeset viewer.