Changeset 176 for trunk/dll/treecnr.c


Ignore:
Timestamp:
May 28, 2005, 7:41:08 PM (20 years ago)
Author:
root
Message:

More large file formatting updates

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/dll/treecnr.c

    r156 r176  
    1313  25 May 05 SHL Rename comnam to szCommonName and fix typo
    1414  25 May 05 SHL Use ULONGLONG and CommaFmtULL
     15  26 May 05 SHL More large file formatting updates
    1516
    1617***********************************************************************/
    … …  
    5758    case WM_CREATE:
    5859      {
    59         MRESULT rc;
    60 
    61         rc = PFNWPButton(hwnd,msg,mp1,mp2);
    62         WinSetPresParam(hwnd,PP_FONTNAMESIZE,
    63                         strlen(GetPString(IDS_8TIMESNEWROMANTEXT)) + 1,
    64                         (PVOID)GetPString(IDS_8TIMESNEWROMANTEXT));
    65         return rc;
     60        MRESULT rc;
     61
     62        rc = PFNWPButton(hwnd,msg,mp1,mp2);
     63        WinSetPresParam(hwnd,PP_FONTNAMESIZE,
     64                        strlen(GetPString(IDS_8TIMESNEWROMANTEXT)) + 1,
     65                        (PVOID)GetPString(IDS_8TIMESNEWROMANTEXT));
     66        return rc;
    6667      }
    6768
    6869    case WM_MOUSEMOVE:
    6970      BubbleHelp(hwnd,
    70                 TRUE,
    71                 FALSE,
    72                 TRUE,
    73                 GetPString(IDS_OPENBUTTONHELP));
     71                TRUE,
     72                FALSE,
     73                TRUE,
     74                GetPString(IDS_OPENBUTTONHELP));
    7475      break;
    7576
    7677    case WM_CONTEXTMENU:
    7778      PostMsg(WinQueryWindow(hwnd,QW_PARENT),
    78               WM_COMMAND,
    79               MPFROM2SHORT(IDM_OPENWALK,0),
    80               MPVOID);
     79              WM_COMMAND,
     80              MPFROM2SHORT(IDM_OPENWALK,0),
     81              MPVOID);
    8182      return 0;
    8283
    8384    case DM_DRAGOVER:
    8485      if(!emphasized) {
    85         emphasized = TRUE;
    86         EmphasizeButton(hwnd,emphasized);
     86        emphasized = TRUE;
     87        EmphasizeButton(hwnd,emphasized);
    8788      }
    8889      if(AcceptOneDrop(mp1,mp2))
    89         return MRFROM2SHORT(DOR_DROP,
    90                             DO_MOVE);
     90        return MRFROM2SHORT(DOR_DROP,
     91                            DO_MOVE);
    9192      return MRFROM2SHORT(DOR_NEVERDROP,0);
    9293
    9394    case DM_DRAGLEAVE:
    9495      if(emphasized) {
    95         emphasized = FALSE;
    96         EmphasizeButton(hwnd,emphasized);
     96        emphasized = FALSE;
     97        EmphasizeButton(hwnd,emphasized);
    9798      }
    9899      break;
    … …  
    104105    case DM_DROP:
    105106      {
    106         char szFrom[CCHMAXPATH + 2];
    107 
    108         if(emphasized) {
    109           emphasized = FALSE;
    110           EmphasizeButton(hwnd,emphasized);
    111         }
    112         if(GetOneDrop(mp1,mp2,szFrom,sizeof(szFrom))) {
    113           MakeValidDir(szFrom);
    114           WinSendMsg(WinQueryWindow(hwnd,QW_PARENT),
    115                      UM_OPENWINDOWFORME,
    116                      MPFROMP(szFrom),
    117                      MPVOID);
    118         }
     107        char szFrom[CCHMAXPATH + 2];
     108
     109        if(emphasized) {
     110          emphasized = FALSE;
     111          EmphasizeButton(hwnd,emphasized);
     112        }
     113        if(GetOneDrop(mp1,mp2,szFrom,sizeof(szFrom))) {
     114          MakeValidDir(szFrom);
     115          WinSendMsg(WinQueryWindow(hwnd,QW_PARENT),
     116                     UM_OPENWINDOWFORME,
     117                     MPFROMP(szFrom),
     118                     MPVOID);
     119        }
    119120      }
    120121      return 0;
    … …  
    136137  /* is it already the current record? */
    137138  pci = WinSendMsg(hwndCnr,
    138                    CM_QUERYRECORDEMPHASIS,
    139                    MPFROMLONG(CMA_FIRST),
    140                    MPFROMSHORT(CRA_CURSORED));
     139                   CM_QUERYRECORDEMPHASIS,
     140                   MPFROMLONG(CMA_FIRST),
     141                   MPFROMSHORT(CRA_CURSORED));
    141142  if(pci &&
    142143     (INT)pci != -1 &&
    … …  
    147148  WinEnableWindowUpdate(hwndCnr,FALSE);
    148149  pci = FindCnrRecord(hwndCnr,
    149                       dirname,
    150                       NULL,
    151                       TRUE,
    152                       FALSE,
    153                       TRUE);
     150                      dirname,
     151                      NULL,
     152                      TRUE,
     153                      FALSE,
     154                      TRUE);
    154155  if(!pci || (INT)pci == -1) {
    155156    *szDir   = *dirname;
    … …  
    160161    for(;;) {
    161162      pciP = FindCnrRecord(hwndCnr,
    162                            szDir,
    163                            NULL,
    164                            TRUE,
    165                            FALSE,
    166                            TRUE);
     163                           szDir,
     164                           NULL,
     165                           TRUE,
     166                           FALSE,
     167                           TRUE);
    167168      if(pciP &&
    168         (INT)pciP != -1) {
    169         if(!stricmp(dirname,pciP->szFileName))
    170           break;
    171         if(!(pciP->rc.flRecordAttr & CRA_EXPANDED))
    172           WinSendMsg(hwndCnr,
    173                      CM_EXPANDTREE,
    174                      MPFROMP(pciP),
    175                      MPVOID);
    176         strcpy(szDir,dirname);
    177         if(p - szDir >= strlen(szDir))
    178           break;
    179         p = strchr(p,'\\');
    180         if(p) {
    181           *p = 0;
    182           p++;
    183         }
    184         else
    185           break;
     169        (INT)pciP != -1) {
     170        if(!stricmp(dirname,pciP->szFileName))
     171          break;
     172        if(!(pciP->rc.flRecordAttr & CRA_EXPANDED))
     173          WinSendMsg(hwndCnr,
     174                     CM_EXPANDTREE,
     175                     MPFROMP(pciP),
     176                     MPVOID);
     177        strcpy(szDir,dirname);
     178        if(p - szDir >= strlen(szDir))
     179          break;
     180        p = strchr(p,'\\');
     181        if(p) {
     182          *p = 0;
     183          p++;
     184        }
     185        else
     186          break;
    186187      }
    187188      else
    188         break;
     189        break;
    189190      DosSleep(0L);
    190191    }
    191192    pci = FindCnrRecord(hwndCnr,
    192                         dirname,
    193                         NULL,
    194                         TRUE,
    195                         FALSE,
    196                         TRUE);
     193                        dirname,
     194                        NULL,
     195                        TRUE,
     196                        FALSE,
     197                        TRUE);
    197198  }
    198199  if(pci &&
    … …  
    200201    if(!(pci->rc.flRecordAttr & CRA_CURSORED)) {
    201202      if(collapsefirst) {
    202         /* collapse top level of all branches */
    203         pciP = WinSendMsg(hwndCnr,
    204                           CM_QUERYRECORD,
    205                           MPVOID,
    206                           MPFROM2SHORT(CMA_FIRST,CMA_ITEMORDER));
    207         while(pciP && (INT)pciP != -1) {
    208           if(toupper(*pciP->szFileName) == toupper(*dirname))
    209             /* collapse all levels if branch is our drive */
    210             ExpandAll(hwndCnr,
    211                       FALSE,
    212                       pciP);
    213           else if(pciP->rc.flRecordAttr & CRA_EXPANDED)
    214             WinSendMsg(hwndCnr,
    215                        CM_COLLAPSETREE,
    216                        MPFROMP(pciP),
    217                        MPVOID);
    218           pciP = WinSendMsg(hwndCnr,
    219                             CM_QUERYRECORD,
    220                             MPFROMP(pciP),
    221                             MPFROM2SHORT(CMA_NEXT,CMA_ITEMORDER));
    222         }
     203        /* collapse top level of all branches */
     204        pciP = WinSendMsg(hwndCnr,
     205                          CM_QUERYRECORD,
     206                          MPVOID,
     207                          MPFROM2SHORT(CMA_FIRST,CMA_ITEMORDER));
     208        while(pciP && (INT)pciP != -1) {
     209          if(toupper(*pciP->szFileName) == toupper(*dirname))
     210            /* collapse all levels if branch is our drive */
     211            ExpandAll(hwndCnr,
     212                      FALSE,
     213                      pciP);
     214          else if(pciP->rc.flRecordAttr & CRA_EXPANDED)
     215            WinSendMsg(hwndCnr,
     216                       CM_COLLAPSETREE,
     217                       MPFROMP(pciP),
     218                       MPVOID);
     219          pciP = WinSendMsg(hwndCnr,
     220                            CM_QUERYRECORD,
     221                            MPFROMP(pciP),
     222                            MPFROM2SHORT(CMA_NEXT,CMA_ITEMORDER));
     223        }
    223224      }
    224225      /* expand all parent branches */
    225226      pciToSelect = pci;
    226227      for(;;) {
    227         pciP = WinSendMsg(hwndCnr,
    228                           CM_QUERYRECORD,
    229                           MPFROMP(pciToSelect),
    230                           MPFROM2SHORT(CMA_PARENT,CMA_ITEMORDER));
    231         if(pciP && (INT)pciP != -1) {
    232           if(!(pciP->rc.flRecordAttr & CRA_EXPANDED))
    233             WinSendMsg(hwndCnr,
    234                        CM_EXPANDTREE,
    235                        MPFROMP(pciP),
    236                        MPVOID);
    237           pciToSelect = pciP;
    238         }
    239         else
    240           break;
    241         DosSleep(0L);
     228        pciP = WinSendMsg(hwndCnr,
     229                          CM_QUERYRECORD,
     230                          MPFROMP(pciToSelect),
     231                          MPFROM2SHORT(CMA_PARENT,CMA_ITEMORDER));
     232        if(pciP && (INT)pciP != -1) {
     233          if(!(pciP->rc.flRecordAttr & CRA_EXPANDED))
     234            WinSendMsg(hwndCnr,
     235                       CM_EXPANDTREE,
     236                       MPFROMP(pciP),
     237                       MPVOID);
     238          pciToSelect = pciP;
     239        }
     240        else
     241          break;
     242        DosSleep(0L);
    242243      }
    243244    }
    … …  
    247248    if(pciToSelect && (INT)pciToSelect != -1) {
    248249      if(fTopDir || maketop)
    249         ShowCnrRecord(hwndCnr,
    250                       (PMINIRECORDCORE)pciToSelect);
     250        ShowCnrRecord(hwndCnr,
     251                      (PMINIRECORDCORE)pciToSelect);
    251252      if(fSwitchTreeExpand &&
    252         !(pciToSelect->rc.flRecordAttr & CRA_EXPANDED))
    253         WinSendMsg(hwndCnr,
    254                    CM_EXPANDTREE,
    255                    MPFROMP(pciToSelect),
    256                    MPVOID);
     253        !(pciToSelect->rc.flRecordAttr & CRA_EXPANDED))
     254        WinSendMsg(hwndCnr,
     255                   CM_EXPANDTREE,
     256                   MPFROMP(pciToSelect),
     257                   MPVOID);
    257258      if(quickbail) {
    258         WinEnableWindowUpdate(hwndCnr,TRUE);
    259         return;
     259        WinEnableWindowUpdate(hwndCnr,TRUE);
     260        return;
    260261      }
    261262      WinSendMsg(hwndCnr,
    262                 CM_SETRECORDEMPHASIS,
    263                 MPFROMP(pciToSelect),
    264                 MPFROM2SHORT(TRUE,CRA_SELECTED | CRA_CURSORED));
     263                CM_SETRECORDEMPHASIS,
     264                MPFROMP(pciToSelect),
     265                MPFROM2SHORT(TRUE,CRA_SELECTED | CRA_CURSORED));
    265266    }
    266267  }
    … …  
    276277    case WM_CONTEXTMENU:
    277278      return WinSendMsg(WinQueryWindow(hwnd,QW_PARENT),
    278                         UM_CONTEXTMENU,
    279                         mp1,
    280                         mp2);
     279                        UM_CONTEXTMENU,
     280                        mp1,
     281                        mp2);
    281282  }
    282283  return oldproc(hwnd,msg,mp1,mp2);
    … …  
    296297    case WM_PAINT:
    297298      {
    298         MRESULT mr = PFNWPStatic(hwnd,msg,mp1,mp2);
    299 
    300         PaintRecessedWindow(hwnd,(HPS)0,FALSE,FALSE);
    301         return mr;
     299        MRESULT mr = PFNWPStatic(hwnd,msg,mp1,mp2);
     300
     301        PaintRecessedWindow(hwnd,(HPS)0,FALSE,FALSE);
     302        return mr;
    302303      }
    303304
    304305    case WM_SETFOCUS:
    305306      if(mp2)
    306         PostMsg(hwnd,UM_FOCUSME,MPVOID,MPVOID);
     307        PostMsg(hwnd,UM_FOCUSME,MPVOID,MPVOID);
    307308      break;
    308309
    … …  
    324325    case WM_ADJUSTWINDOWPOS:
    325326      {
    326         SWP *pswp;
    327 
    328         pswp = (SWP *)mp1;
    329         if(ParentIsDesktop(hwnd,(HWND)0)) {
    330           if(pswp->fl & (SWP_HIDE | SWP_MINIMIZE))
    331             HideNote();
    332         }
     327        SWP *pswp;
     328
     329        pswp = (SWP *)mp1;
     330        if(ParentIsDesktop(hwnd,(HWND)0)) {
     331          if(pswp->fl & (SWP_HIDE | SWP_MINIMIZE))
     332            HideNote();
     333        }
    333334      }
    334335      break;
    … …  
    336337    case WM_TRACKFRAME:
    337338      if(!fFreeTree && !ParentIsDesktop(hwnd,(HWND)0)) {
    338         switch(SHORT1FROMMP(mp1) & TF_MOVE) {
    339           case TF_MOVE:
    340           case TF_LEFT:
    341           case TF_TOP:
    342           case (TF_LEFT | TF_BOTTOM):
    343           case (TF_LEFT | TF_TOP):
    344             {
    345               SWP swp;
    346 
    347               WinQueryWindowPos(hwnd,&swp);
    348               if(!(swp.fl & SWP_ACTIVATE))
    349                 WinSetWindowPos(hwnd,HWND_TOP,0,0,0,0,
    350                                 SWP_ZORDER | SWP_ACTIVATE);
    351             }
    352             return 0;
    353         }
     339        switch(SHORT1FROMMP(mp1) & TF_MOVE) {
     340          case TF_MOVE:
     341          case TF_LEFT:
     342          case TF_TOP:
     343          case (TF_LEFT | TF_BOTTOM):
     344          case (TF_LEFT | TF_TOP):
     345            {
     346              SWP swp;
     347
     348              WinQueryWindowPos(hwnd,&swp);
     349              if(!(swp.fl & SWP_ACTIVATE))
     350                WinSetWindowPos(hwnd,HWND_TOP,0,0,0,0,
     351                                SWP_ZORDER | SWP_ACTIVATE);
     352            }
     353            return 0;
     354        }
    354355      }
    355356      break;
    … …  
    358359      if(*(ULONG *)realappname != FM3UL) {
    359360
    360         MRESULT mr;
    361         PRECTL  prectl;
    362 
    363         mr = CommonFrameWndProc(TREE_CNR,hwnd,msg,mp1,mp2);
    364 
    365         /*
    366         * Calculate the position of the client rectangle.
    367         * Otherwise,  we'll see a lot of redraw when we move the
    368         * client during WM_FORMATFRAME.
    369         */
    370 
    371         if(mr && mp2) {
    372           prectl = (PRECTL)mp1;
    373           prectl->yTop -= 22;
    374         }
    375         return mr;
     361        MRESULT mr;
     362        PRECTL  prectl;
     363
     364        mr = CommonFrameWndProc(TREE_CNR,hwnd,msg,mp1,mp2);
     365
     366        /*
     367        * Calculate the position of the client rectangle.
     368        * Otherwise,  we'll see a lot of redraw when we move the
     369        * client during WM_FORMATFRAME.
     370        */
     371
     372        if(mr && mp2) {
     373          prectl = (PRECTL)mp1;
     374          prectl->yTop -= 22;
     375        }
     376        return mr;
    376377      }
    377378      break;
    … …  
    379380    case WM_FORMATFRAME:
    380381      {
    381         SHORT sCount;
    382         PSWP  pswp,pswpClient,pswpNew;
    383 
    384         sCount = (SHORT)CommonFrameWndProc(TREE_CNR,hwnd,msg,mp1,mp2);
    385 
    386         /*
    387         * Reformat the frame to "squeeze" the client
    388         */
    389 
    390         pswp = (PSWP)mp1;
    391         {
    392           SHORT x;
    393 
    394           for(x = 0;x < sCount;x++) {
    395             if(WinQueryWindowUShort(pswp->hwnd,QWS_ID) == FID_CLIENT) {
    396               pswpClient = pswp;
    397               break;
    398             }
    399             pswp++;
    400           }
    401         }
    402         pswpNew = (PSWP)mp1 + sCount;
    403         *pswpNew = *pswpClient;
    404         pswpNew->hwnd = WinWindowFromID(hwnd,MAIN_STATUS);
    405         if(*(ULONG *)realappname == FM3UL) {
    406 
    407           PSWP  pswpTitlebar = (PSWP)0,pswpMinbutton = (PSWP)0;
    408           SHORT x;
    409 
    410           pswpNew->hwnd = WinWindowFromID(hwnd,IDM_OPENWINDOW);
    411           pswp = (PSWP)mp1;
    412           for(x = 0;x < sCount;x++) {
    413             if(WinQueryWindowUShort(pswp->hwnd,QWS_ID) == FID_TITLEBAR)
    414               pswpTitlebar = pswp;
    415             else if(WinQueryWindowUShort(pswp->hwnd,QWS_ID) == FID_MINMAX)
    416               pswpMinbutton = pswp;
    417             if(pswpTitlebar && pswpMinbutton)
    418               break;
    419             pswp++;
    420           }
    421           pswpNew->cy = pswpMinbutton->cy + 3;
    422           pswpNew->cx = min(pswpNew->cy,(pswpMinbutton->cx / 2) + 3);
    423           pswpTitlebar->cx -= (pswpNew->cx + 1);
    424           pswpNew->x = pswpTitlebar->x + pswpTitlebar->cx;
    425           pswpNew->y = pswpMinbutton->y - 1;
    426         }
    427         else {
    428           pswpNew->x = pswpClient->x + 3;
    429           pswpNew->y = (pswpClient->y + pswpClient->cy) - 20;
    430           pswpNew->cx = pswpClient->cx - 6;
    431           pswpNew->cy = 18;
    432           pswpClient->cy -= 22;
    433         }
    434         sCount++;
    435         return MRFROMSHORT(sCount);
     382        SHORT sCount;
     383        PSWP  pswp,pswpClient,pswpNew;
     384
     385        sCount = (SHORT)CommonFrameWndProc(TREE_CNR,hwnd,msg,mp1,mp2);
     386
     387        /*
     388        * Reformat the frame to "squeeze" the client
     389        */
     390
     391        pswp = (PSWP)mp1;
     392        {
     393          SHORT x;
     394
     395          for(x = 0;x < sCount;x++) {
     396            if(WinQueryWindowUShort(pswp->hwnd,QWS_ID) == FID_CLIENT) {
     397              pswpClient = pswp;
     398              break;
     399            }
     400            pswp++;
     401          }
     402        }
     403        pswpNew = (PSWP)mp1 + sCount;
     404        *pswpNew = *pswpClient;
     405        pswpNew->hwnd = WinWindowFromID(hwnd,MAIN_STATUS);
     406        if(*(ULONG *)realappname == FM3UL) {
     407
     408          PSWP  pswpTitlebar = (PSWP)0,pswpMinbutton = (PSWP)0;
     409          SHORT x;
     410
     411          pswpNew->hwnd = WinWindowFromID(hwnd,IDM_OPENWINDOW);
     412          pswp = (PSWP)mp1;
     413          for(x = 0;x < sCount;x++) {
     414            if(WinQueryWindowUShort(pswp->hwnd,QWS_ID) == FID_TITLEBAR)
     415              pswpTitlebar = pswp;
     416            else if(WinQueryWindowUShort(pswp->hwnd,QWS_ID) == FID_MINMAX)
     417              pswpMinbutton = pswp;
     418            if(pswpTitlebar && pswpMinbutton)
     419              break;
     420            pswp++;
     421          }
     422          pswpNew->cy = pswpMinbutton->cy + 3;
     423          pswpNew->cx = min(pswpNew->cy,(pswpMinbutton->cx / 2) + 3);
     424          pswpTitlebar->cx -= (pswpNew->cx + 1);
     425          pswpNew->x = pswpTitlebar->x + pswpTitlebar->cx;
     426          pswpNew->y = pswpMinbutton->y - 1;
     427        }
     428        else {
     429          pswpNew->x = pswpClient->x + 3;
     430          pswpNew->y = (pswpClient->y + pswpClient->cy) - 20;
     431          pswpNew->cx = pswpClient->cx - 6;
     432          pswpNew->cy = 18;
     433          pswpClient->cy -= 22;
     434        }
     435        sCount++;
     436        return MRFROMSHORT(sCount);
    436437      }
    437438
    438439    case WM_QUERYFRAMECTLCOUNT:
    439440      {
    440         SHORT sCount;
    441 
    442         sCount = (SHORT)CommonFrameWndProc(TREE_CNR,hwnd,msg,mp1,mp2);
    443         sCount++;
    444         return MRFROMSHORT(sCount);
     441        SHORT sCount;
     442
     443        sCount = (SHORT)CommonFrameWndProc(TREE_CNR,hwnd,msg,mp1,mp2);
     444        sCount++;
     445        return MRFROMSHORT(sCount);
    445446      }
    446447  }
    … …  
    450451
    451452MRESULT EXPENTRY TreeClientWndProc (HWND hwnd,ULONG msg,MPARAM mp1,
    452                                     MPARAM mp2) {
     453                                    MPARAM mp2) {
    453454
    454455  switch(msg) {
    455456    case UM_CONTAINERHWND:
    456457      return MRFROMLONG(WinWindowFromID(hwnd,
    457                                         TREE_CNR));
     458                                        TREE_CNR));
    458459
    459460    case UM_VIEWSMENU:
    460461      return MRFROMLONG(CheckMenu(&TreeCnrMenu,
    461                                   TREECNR_POPUP));
     462                                  TREECNR_POPUP));
    462463
    463464    case UM_TIMER:
    … …  
    480481    case WM_COMMAND:
    481482      return WinSendMsg(WinWindowFromID(hwnd,TREE_CNR),
    482                         msg,
    483                         mp1,
    484                         mp2);
     483                        msg,
     484                        mp1,
     485                        mp2);
    485486
    486487    case WM_PSETFOCUS:
    487488    case WM_SETFOCUS:
    488489      if(mp2)
    489         PostMsg(hwnd,
    490                 UM_FOCUSME,
    491                 MPVOID,
    492                 MPVOID);
     490        PostMsg(hwnd,
     491                UM_FOCUSME,
     492                MPVOID,
     493                MPVOID);
    493494      break;
    494495
    495496    case UM_FOCUSME:
    496497      WinSetFocus(HWND_DESKTOP,
    497                   WinWindowFromID(hwnd,TREE_CNR));
     498                  WinWindowFromID(hwnd,TREE_CNR));
    498499      break;
    499500
    500501    case WM_ERASEBACKGROUND:
    501502      WinFillRect((HPS)mp1,
    502                   (PRECTL)mp2,
    503                   0x00d0d0d0);
     503                  (PRECTL)mp2,
     504                  0x00d0d0d0);
    504505      return 0;
    505506
    506507    case WM_PAINT:
    507508      {
    508         HPS    hps;
    509         RECTL  rcl;
    510 
    511         hps = WinBeginPaint(hwnd,
    512                             (HPS)0,
    513                             NULL);
    514         if(hps) {
    515           WinQueryWindowRect(hwnd,
    516                              &rcl);
    517           WinFillRect(hps,
    518                       &rcl,
    519                       CLR_PALEGRAY);
    520           PaintRecessedWindow(WinWindowFromID(WinQueryWindow(hwnd,QW_PARENT),
    521                                               MAIN_STATUS),
    522                               hps,
    523                               FALSE,
    524                               FALSE);
    525           WinEndPaint(hps);
    526         }
     509        HPS    hps;
     510        RECTL  rcl;
     511
     512        hps = WinBeginPaint(hwnd,
     513                            (HPS)0,
     514                            NULL);
     515        if(hps) {
     516          WinQueryWindowRect(hwnd,
     517                             &rcl);
     518          WinFillRect(hps,
     519                      &rcl,
     520                      CLR_PALEGRAY);
     521          PaintRecessedWindow(WinWindowFromID(WinQueryWindow(hwnd,QW_PARENT),
     522                                              MAIN_STATUS),
     523                              hps,
     524                              FALSE,
     525                              FALSE);
     526          WinEndPaint(hps);
     527        }
    527528      }
    528529      break;
    … …  
    530531    case WM_SIZE:
    531532      WinSetWindowPos(WinWindowFromID(hwnd,TREE_CNR),
    532                       HWND_TOP,
    533                       0,
    534                       0,
    535                       SHORT1FROMMP(mp2),
    536                       SHORT2FROMMP(mp2),
    537                       SWP_SHOW | SWP_MOVE | SWP_SIZE);
     533                      HWND_TOP,
     534                      0,
     535                      0,
     536                      SHORT1FROMMP(mp2),
     537                      SHORT2FROMMP(mp2),
     538                      SWP_SHOW | SWP_MOVE | SWP_SIZE);
    538539      if(hwndMain)
    539         PostMsg(hwndMain,
    540                 UM_SIZE,
    541                 MPVOID,
    542                 MPVOID);
     540        PostMsg(hwndMain,
     541                UM_SIZE,
     542                MPVOID,
     543                MPVOID);
    543544      break;
    544545
    … …  
    546547    case UM_CONTEXTMENU:
    547548      PostMsg(WinWindowFromID(hwnd,TREE_CNR),
    548               WM_CONTROL,
    549               MPFROM2SHORT(TREE_CNR,CN_CONTEXTMENU),
    550               MPVOID);
     549              WM_CONTROL,
     550              MPFROM2SHORT(TREE_CNR,CN_CONTEXTMENU),
     551              MPVOID);
    551552      return 0;
    552553  }
    … …  
    559560  DIRCNRDATA *dcd;
    560561
    561   switch(msg) {
     562  switch(msg)
     563  {
    562564    case WM_CREATE:
    563565      break;
    564566
    565567    case UM_SHOWME:
    566       if(mp1) {
    567         dcd = INSTDATA(hwnd);
    568         if(dcd) {
    569 
    570           BOOL tempsusp,tempfollow,temptop;
    571 
    572           tempsusp = dcd->suspendview;
    573           dcd->suspendview = TRUE;
    574           tempfollow = fFollowTree;
    575           fFollowTree = FALSE;
    576           if(mp2) {
    577             temptop = fTopDir;
    578             fTopDir = TRUE;
    579           }
    580           ShowTreeRec(dcd->hwndCnr,
    581                       (CHAR *)mp1,
    582                       fCollapseFirst,
    583                       TRUE);
    584           dcd->suspendview = tempsusp;
    585           fFollowTree = tempfollow;
    586           if(mp2)
    587             fTopDir = temptop;
    588         }
    589         free((CHAR *)mp1);
     568      if(mp1)
     569      {
     570        dcd = INSTDATA(hwnd);
     571        if(dcd)
     572        {
     573          BOOL tempsusp,tempfollow,temptop;
     574
     575          tempsusp = dcd->suspendview;
     576          dcd->suspendview = TRUE;
     577          tempfollow = fFollowTree;
     578          fFollowTree = FALSE;
     579          if(mp2) {
     580            temptop = fTopDir;
     581            fTopDir = TRUE;
     582          }
     583          ShowTreeRec(dcd->hwndCnr,
     584                      (CHAR *)mp1,
     585                      fCollapseFirst,
     586                      TRUE);
     587          dcd->suspendview = tempsusp;
     588          fFollowTree = tempfollow;
     589          if(mp2)
     590            fTopDir = temptop;
     591        }
     592        free((CHAR *)mp1);
    590593      }
    591594      return 0;
    … …  
    598601      if(fFM2Deletes && dcd) {
    599602
    600         LISTINFO    *li;
    601         CNRDRAGINFO cni;
    602 
    603         cni.pRecord = NULL;
    604         cni.pDragInfo = (PDRAGINFO)mp1;
    605         li = DoFileDrop(dcd->hwndCnr,
    606                         dcd->directory,
    607                         FALSE,
    608                         MPVOID,
    609                         MPFROMP(&cni));
    610         if(li) {
    611           li->type = ((fDefaultDeletePerm) ?
    612                        IDM_PERMDELETE :
    613                        IDM_DELETE);
    614           if(!PostMsg(hwnd,
    615                       UM_MASSACTION,
    616                       MPFROMP(li),
    617                       MPVOID))
    618             FreeListInfo(li);
    619           else
    620             return MRFROMLONG(DRR_SOURCE);
    621         }
     603        LISTINFO    *li;
     604        CNRDRAGINFO cni;
     605
     606        cni.pRecord = NULL;
     607        cni.pDragInfo = (PDRAGINFO)mp1;
     608        li = DoFileDrop(dcd->hwndCnr,
     609                        dcd->directory,
     610                        FALSE,
     611                        MPVOID,
     612                        MPFROMP(&cni));
     613        if(li) {
     614          li->type = ((fDefaultDeletePerm) ?
     615                       IDM_PERMDELETE :
     616                       IDM_DELETE);
     617          if(!PostMsg(hwnd,
     618                      UM_MASSACTION,
     619                      MPFROMP(li),
     620                      MPVOID))
     621            FreeListInfo(li);
     622          else
     623            return MRFROMLONG(DRR_SOURCE);
     624        }
    622625      }
    623626      return MRFROMLONG(DRR_TARGET);
    … …  
    627630      if(dcd) {
    628631
    629         BOOL tempsusp = dcd->suspendview;
    630 
    631         dcd->suspendview = TRUE;
    632         ExpandAll(dcd->hwndCnr,
    633                   (SHORT1FROMMP(mp1) == IDM_EXPAND),
    634                   (PCNRITEM)mp2);
    635         dcd->suspendview = tempsusp;
    636         PostMsg(dcd->hwndCnr,
    637                 UM_FILTER,
    638                 MPVOID,
    639                 MPVOID);
     632        BOOL tempsusp = dcd->suspendview;
     633
     634        dcd->suspendview = TRUE;
     635        ExpandAll(dcd->hwndCnr,
     636                  (SHORT1FROMMP(mp1) == IDM_EXPAND),
     637                  (PCNRITEM)mp2);
     638        dcd->suspendview = tempsusp;
     639        PostMsg(dcd->hwndCnr,
     640                UM_FILTER,
     641                MPVOID,
     642                MPVOID);
    640643      }
    641644      return 0;
    … …  
    645648      if(dcd && mp1) {
    646649
    647         INT    numentries = 0;
    648         CHAR **list = (CHAR **)mp1;
    649 
    650         while(list[numentries])
    651           numentries++;
    652         if(numentries)
    653           UpdateCnrList(dcd->hwndCnr,
    654                         list,
    655                         numentries,
    656                         TRUE,
    657                         dcd);
     650        INT    numentries = 0;
     651        CHAR **list = (CHAR **)mp1;
     652
     653        while(list[numentries])
     654          numentries++;
     655        if(numentries)
     656          UpdateCnrList(dcd->hwndCnr,
     657                        list,
     658                        numentries,
     659                        TRUE,
     660                        dcd);
    658661      }
    659662      return 0;
    … …  
    662665      dcd = WinQueryWindowPtr(hwnd,0);
    663666      if(dcd) {
    664         dcd->hwndObject = hwnd;
    665         if(ParentIsDesktop(hwnd,dcd->hwndParent))
    666           DosSleep(250L);
     667        dcd->hwndObject = hwnd;
     668        if(ParentIsDesktop(hwnd,dcd->hwndParent))
     669          DosSleep(250L);
    667670      }
    668671      return 0;
    … …  
    671674      dcd = WinQueryWindowPtr(hwnd,0);
    672675      if(dcd &&
    673          hwndStatus &&
    674          dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent)) {
    675 
    676         CHAR      s[CCHMAXPATH * 2];
    677         PCNRITEM   pci = (PCNRITEM)mp1;
    678         FSALLOCATE fsa;
    679         struct {
    680           ULONG serial;
    681           CHAR  volumelength;
    682           CHAR  volumelabel[CCHMAXPATH];
    683         }          volser;
    684         CHAR       szBuf[81];
    685         CNRINFO    cnri;
    686 
    687         strcpy(s,GetPString(IDS_TREETEXT));
    688         memset(&cnri,0,sizeof(CNRINFO));
    689         cnri.cb = sizeof(CNRINFO);
    690         WinSendMsg(dcd->hwndCnr,
    691                    CM_QUERYCNRINFO,
    692                    MPFROMP(&cnri),
    693                    MPFROMLONG(sizeof(CNRINFO)));
    694         if(cnri.cRecords) {
    695 
    696           sprintf(s,
    697                   GetPString(IDS_NUMDRIVESTEXT),
    698                   cnri.cRecords);
    699           if(pci) {
    700             if(!(driveflags[toupper(*pci->szFileName) - 'A'] &
    701                  DRIVE_REMOVABLE) ||
    702                driveserial[toupper(*pci->szFileName) - 'A'] != -1) {
    703              memset(&volser,0,sizeof(volser));
    704               DosError(FERR_DISABLEHARDERR);
    705               if(!DosQueryFSInfo(toupper(*pci->szFileName) - '@',
    706                                  FSIL_VOLSER,
    707                                  &volser,
    708                                  (ULONG)sizeof(volser)) &&
    709                  dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent)) {
    710                 DosError(FERR_DISABLEHARDERR);
    711                 if(!DosQueryFSInfo(toupper(*pci->szFileName) - '@',
    712                                    FSIL_ALLOC,
    713                                    &fsa,
    714                                    sizeof(FSALLOCATE))) {
    715                   strcpy(szBuf,"  ");
    716                   CommaFmtULL(szBuf + 2,sizeof(szBuf) - 4,
    717                               (ULONGLONG)fsa.cUnitAvail * (fsa.cSectorUnit * fsa.cbSector),
    718                               'K');
    719                   strcat(szBuf,
    720                          GetPString(IDS_KFREETEXT));
    721                 }
    722                 else
    723                   *szBuf = 0;
    724                 driveserial[toupper(*pci->szFileName) - 'A'] = volser.serial;
    725                 sprintf(&s[strlen(s)],
    726                         GetPString(IDS_TREESTATUSSTARTTEXT),
    727                         toupper(*pci->szFileName),
    728                         volser.volumelabel,
    729                         volser.serial,szBuf);
    730                 if(!fMoreButtons) {
    731                   if(*dcd->mask.szMask ||
    732                      (dcd->mask.attrFile != ALLATTRS ||
    733                       ((fFilesInTree ||
    734                         (driveflags[toupper(*pci->szFileName)] &
    735                          DRIVE_INCLUDEFILES)) ?
    736                        dcd->mask.antiattr :
    737                        (dcd->mask.antiattr &&
    738                         dcd->mask.antiattr != FILE_DIRECTORY))))
    739                     sprintf(&s[strlen(s)],
    740                             " (%s)",
    741                             (*dcd->mask.szMask) ?
    742                              dcd->mask.szMask :
    743                              GetPString(IDS_ATTRTEXT));
    744                 }
    745               }
    746             }
    747             else {  /* find root record and strip it */
    748               pci = FindParentRecord(dcd->hwndCnr,pci);
    749               driveserial[toupper(*pci->szFileName) - 'A'] = -1;
    750               UnFlesh(dcd->hwndCnr,pci);
    751             }
    752           }
    753         }
    754         if(dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent))
    755           WinSetWindowText(hwndStatus,s);
     676         hwndStatus &&
     677         dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent)) {
     678
     679        CHAR      s[CCHMAXPATH * 2];
     680        PCNRITEM   pci = (PCNRITEM)mp1;
     681        FSALLOCATE fsa;
     682        struct
     683        {
     684          ULONG serial;
     685          CHAR  volumelength;
     686          CHAR  volumelabel[CCHMAXPATH];
     687        }          volser;
     688        CHAR       tb[64];
     689        CHAR       szFree[64];
     690        CNRINFO    cnri;
     691
     692        strcpy(s,GetPString(IDS_TREETEXT));
     693        memset(&cnri,0,sizeof(CNRINFO));
     694        cnri.cb = sizeof(CNRINFO);
     695        WinSendMsg(dcd->hwndCnr,
     696                   CM_QUERYCNRINFO,
     697                   MPFROMP(&cnri),
     698                   MPFROMLONG(sizeof(CNRINFO)));
     699        if (cnri.cRecords)
     700        {
     701          sprintf(s,
     702                  GetPString(IDS_NUMDRIVESTEXT),
     703                  cnri.cRecords);
     704          if (pci)
     705          {
     706            if (!(driveflags[toupper(*pci->szFileName) - 'A'] &
     707                  DRIVE_REMOVABLE) ||
     708               driveserial[toupper(*pci->szFileName) - 'A'] != -1)
     709            {
     710              memset(&volser,0,sizeof(volser));
     711              DosError(FERR_DISABLEHARDERR);
     712              if (!DosQueryFSInfo(toupper(*pci->szFileName) - '@',
     713                                  FSIL_VOLSER,
     714                                  &volser,
     715                                  (ULONG)sizeof(volser)) &&
     716                 dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent))
     717              {
     718                DosError(FERR_DISABLEHARDERR);
     719                if (!DosQueryFSInfo(toupper(*pci->szFileName) - '@',
     720                                    FSIL_ALLOC,
     721                                    &fsa,
     722                                    sizeof(FSALLOCATE)))
     723                {
     724                  CommaFmtULL(tb,sizeof(tb),
     725                              (ULONGLONG)fsa.cUnitAvail * (fsa.cSectorUnit * fsa.cbSector),
     726                              'M');
     727                  sprintf(szFree, "  %s %s",
     728                         tb,GetPString(IDS_FREETEXT));
     729                }
     730                else
     731                  *szFree = 0;
     732                driveserial[toupper(*pci->szFileName) - 'A'] = volser.serial;
     733                sprintf(&s[strlen(s)],
     734                        GetPString(IDS_TREESTATUSSTARTTEXT),
     735                        toupper(*pci->szFileName),
     736                        volser.volumelabel,
     737                        volser.serial,szFree);
     738                if (!fMoreButtons)
     739                {
     740                  if (*dcd->mask.szMask ||
     741                      (dcd->mask.attrFile != ALLATTRS ||
     742                       ((fFilesInTree ||
     743                         (driveflags[toupper(*pci->szFileName)] &
     744                          DRIVE_INCLUDEFILES)) ?
     745                            dcd->mask.antiattr :
     746                           (dcd->mask.antiattr &&
     747                            dcd->mask.antiattr != FILE_DIRECTORY))))
     748                  {
     749                    sprintf (&s[strlen(s)],
     750                             " (%s)",
     751                             (*dcd->mask.szMask) ?
     752                              dcd->mask.szMask :
     753                              GetPString(IDS_ATTRTEXT));
     754                  }
     755                }
     756              }
     757            }
     758            else
     759            {
     760              /* find root record and strip it */
     761              pci = FindParentRecord(dcd->hwndCnr,pci);
     762              driveserial[toupper(*pci->szFileName) - 'A'] = -1;
     763              UnFlesh(dcd->hwndCnr,pci);
     764            }
     765          }
     766        }
     767        if (dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent))
     768          WinSetWindowText(hwndStatus,s);
    756769      }
    757770      return 0;
    … …  
    763776      dcd = WinQueryWindowPtr(hwnd,0);
    764777      if(dcd) {
    765         WinSendMsg(dcd->hwndCnr,
    766                    CM_REMOVERECORD,
    767                    MPVOID,
    768                    MPFROM2SHORT(0,CMA_FREE | CMA_INVALIDATE | CMA_ERASE));
    769         WinSendMsg(dcd->hwndCnr,
    770                    CM_SCROLLWINDOW,
    771                    MPFROMSHORT(CMA_VERTICAL),
    772                    MPFROMLONG(-1));
    773         WinSendMsg(dcd->hwndCnr,
    774                    CM_SCROLLWINDOW,
    775                    MPFROMSHORT(CMA_HORIZONTAL),
    776                    MPFROMLONG(-1));
    777         FillTreeCnr(dcd->hwndCnr,
    778                     dcd->hwndParent);
    779         if(fOkayMinimize) {
    780           PostMsg(dcd->hwndCnr,
    781                   UM_MINIMIZE,
    782                   MPVOID,
    783                   MPVOID);
    784           fOkayMinimize = FALSE;
    785         }
    786         WinSendMsg(dcd->hwndCnr,
    787                    CM_INVALIDATERECORD,
    788                    MPVOID,
    789                    MPFROM2SHORT(0,CMA_ERASE | CMA_REPOSITION));
    790         PostMsg(dcd->hwndCnr,
    791                 UM_RESCAN,
    792                 MPVOID,
    793                 MPVOID);
     778        WinSendMsg(dcd->hwndCnr,
     779                   CM_REMOVERECORD,
     780                   MPVOID,
     781                   MPFROM2SHORT(0,CMA_FREE | CMA_INVALIDATE | CMA_ERASE));
     782        WinSendMsg(dcd->hwndCnr,
     783                   CM_SCROLLWINDOW,
     784                   MPFROMSHORT(CMA_VERTICAL),
     785                   MPFROMLONG(-1));
     786        WinSendMsg(dcd->hwndCnr,
     787                   CM_SCROLLWINDOW,
     788                   MPFROMSHORT(CMA_HORIZONTAL),
     789                   MPFROMLONG(-1));
     790        FillTreeCnr(dcd->hwndCnr,
     791                    dcd->hwndParent);
     792        if(fOkayMinimize) {
     793          PostMsg(dcd->hwndCnr,
     794                  UM_MINIMIZE,
     795                  MPVOID,
     796                  MPVOID);
     797          fOkayMinimize = FALSE;
     798        }
     799        WinSendMsg(dcd->hwndCnr,
     800                   CM_INVALIDATERECORD,
     801                   MPVOID,
     802                   MPFROM2SHORT(0,CMA_ERASE | CMA_REPOSITION));
     803        PostMsg(dcd->hwndCnr,
     804                UM_RESCAN,
     805                MPVOID,
     806                MPVOID);
    794807      }
    795808      return 0;
    … …  
    798811      if(mp1) {
    799812
    800         LISTINFO *li = (LISTINFO *)mp1;
    801 
    802         switch(li->type) {
    803           case IDM_DOITYOURSELF:
    804           case IDM_APPENDTOCLIP:
    805           case IDM_SAVETOCLIP:
    806           case IDM_ARCHIVE:
    807           case IDM_VIEW:
    808           case IDM_EDIT:
    809           case IDM_OBJECT:
    810           case IDM_SHADOW:
    811           case IDM_SHADOW2:
    812           case IDM_PRINT:
    813           case IDM_ATTRS:
    814           case IDM_DELETE:
    815           case IDM_PERMDELETE:
    816             if(PostMsg(hwnd,
    817                        UM_MASSACTION,
    818                        mp1,
    819                        mp2))
    820               return (MRESULT)TRUE;
    821           default:
    822             if(PostMsg(hwnd,
    823                        UM_ACTION,
    824                        mp1,
    825                        mp2))
    826               return (MRESULT)TRUE;
    827         }
     813        LISTINFO *li = (LISTINFO *)mp1;
     814
     815        switch(li->type) {
     816          case IDM_DOITYOURSELF:
     817          case IDM_APPENDTOCLIP:
     818          case IDM_SAVETOCLIP:
     819          case IDM_ARCHIVE:
     820          case IDM_VIEW:
     821          case IDM_EDIT:
     822          case IDM_OBJECT:
     823          case IDM_SHADOW:
     824          case IDM_SHADOW2:
     825          case IDM_PRINT:
     826          case IDM_ATTRS:
     827          case IDM_DELETE:
     828          case IDM_PERMDELETE:
     829            if(PostMsg(hwnd,
     830                       UM_MASSACTION,
     831                       mp1,
     832                       mp2))
     833              return (MRESULT)TRUE;
     834          default:
     835            if(PostMsg(hwnd,
     836                       UM_ACTION,
     837                       mp1,
     838                       mp2))
     839              return (MRESULT)TRUE;
     840        }
    828841      }
    829842      return 0;
    … …  
    832845      if(mp1) {
    833846
    834         dcd = WinQueryWindowPtr(hwnd,0);
    835         if(dcd) {
    836 
    837           WORKER *wk;
    838 
    839           wk = malloc(sizeof(WORKER));
    840           if(wk) {
    841             memset(wk,0,sizeof(WORKER));
    842             wk->size = sizeof(WORKER);
    843             wk->hwndCnr = dcd->hwndCnr;
    844             wk->hwndParent = dcd->hwndParent;
    845             wk->hwndFrame = dcd->hwndFrame;
    846             wk->hwndClient = dcd->hwndClient;
    847             wk->li = (LISTINFO *)mp1;
    848             strcpy(wk->directory,dcd->directory);
    849             if(_beginthread(MassAction,
    850                             NULL,
    851                             122880,
    852                             (PVOID)wk) ==
    853                -1) {
    854               free(wk);
    855               FreeListInfo((LISTINFO *)mp1);
    856             }
    857           }
    858           else
    859             FreeListInfo((LISTINFO *)mp1);
    860         }
     847        dcd = WinQueryWindowPtr(hwnd,0);
     848        if(dcd) {
     849
     850          WORKER *wk;
     851
     852          wk = malloc(sizeof(WORKER));
     853          if(wk) {
     854            memset(wk,0,sizeof(WORKER));
     855            wk->size = sizeof(WORKER);
     856            wk->hwndCnr = dcd->hwndCnr;
     857            wk->hwndParent = dcd->hwndParent;
     858            wk->hwndFrame = dcd->hwndFrame;
     859            wk->hwndClient = dcd->hwndClient;
     860            wk->li = (LISTINFO *)mp1;
     861            strcpy(wk->directory,dcd->directory);
     862            if(_beginthread(MassAction,
     863                            NULL,
     864                            122880,
     865                            (PVOID)wk) ==
     866               -1) {
     867              free(wk);
     868              FreeListInfo((LISTINFO *)mp1);
     869            }
     870          }
     871          else
     872            FreeListInfo((LISTINFO *)mp1);
     873        }
    861874      }
    862875      return 0;
    … …  
    865878      if(mp1) {
    866879
    867         dcd = WinQueryWindowPtr(hwnd,0);
    868         if(dcd) {
    869 
    870           WORKER *wk;
    871 
    872           wk = malloc(sizeof(WORKER));
    873           if(wk) {
    874             memset(wk,0,sizeof(WORKER));
    875             wk->size = sizeof(WORKER);
    876             wk->hwndCnr = dcd->hwndCnr;
    877             wk->hwndParent = dcd->hwndParent;
    878             wk->hwndFrame = dcd->hwndFrame;
    879             wk->hwndClient = dcd->hwndClient;
    880             wk->li = (LISTINFO *)mp1;
    881             strcpy(wk->directory,dcd->directory);
    882             if(_beginthread(Action,
    883                             NULL,
    884                             122880,
    885                             (PVOID)wk) ==
    886                -1) {
    887               free(wk);
    888               FreeListInfo((LISTINFO *)mp1);
    889             }
    890           }
    891           else
    892             FreeListInfo((LISTINFO *)mp1);
    893         }
     880        dcd = WinQueryWindowPtr(hwnd,0);
     881        if(dcd) {
     882
     883          WORKER *wk;
     884
     885          wk = malloc(sizeof(WORKER));
     886          if(wk) {
     887            memset(wk,0,sizeof(WORKER));
     888            wk->size = sizeof(WORKER);
     889            wk->hwndCnr = dcd->hwndCnr;
     890            wk->hwndParent = dcd->hwndParent;
     891            wk->hwndFrame = dcd->hwndFrame;
     892            wk->hwndClient = dcd->hwndClient;
     893            wk->li = (LISTINFO *)mp1;
     894            strcpy(wk->directory,dcd->directory);
     895            if(_beginthread(Action,
     896                            NULL,
     897                            122880,
     898                            (PVOID)wk) ==
     899               -1) {
     900              free(wk);
     901              FreeListInfo((LISTINFO *)mp1);
     902            }
     903          }
     904          else
     905            FreeListInfo((LISTINFO *)mp1);
     906        }
    894907      }
    895908      return 0;
    … …  
    903916      dcd = WinQueryWindowPtr(hwnd,0);
    904917      if(dcd) {
    905         WinSendMsg(dcd->hwndCnr,
    906                    UM_CLOSE,
    907                    MPFROMLONG(dcd->dontclose != FALSE),
    908                    MPVOID);
    909         free(dcd);
     918        WinSendMsg(dcd->hwndCnr,
     919                   UM_CLOSE,
     920                   MPFROMLONG(dcd->dontclose != FALSE),
     921                   MPVOID);
     922        free(dcd);
    910923      }
    911924      DosPostEventSem(CompactSem);
    912925      if(!PostMsg((HWND)0,
    913                   WM_QUIT,
    914                   MPVOID,
    915                   MPVOID))
    916         WinSendMsg((HWND)0,
    917                    WM_QUIT,
    918                    MPVOID,
    919                    MPVOID);
     926                  WM_QUIT,
     927                  MPVOID,
     928                  MPVOID))
     929        WinSendMsg((HWND)0,
     930                   WM_QUIT,
     931                   MPVOID,
     932                   MPVOID);
    920933      break;
    921934  }
    … …  
    935948    case DM_DISCARDOBJECT:
    936949      if(dcd)
    937         return WinSendMsg(dcd->hwndObject,
    938                           msg,
    939                           mp1,
    940                           mp2);
     950        return WinSendMsg(dcd->hwndObject,
     951                          msg,
     952                          mp1,
     953                          mp2);
    941954      else
    942         return MRFROMLONG(DRR_TARGET);
     955        return MRFROMLONG(DRR_TARGET);
    943956
    944957    case WM_CHAR:
    945958      shiftstate = (SHORT1FROMMP(mp1) & (KC_SHIFT | KC_ALT | KC_CTRL));
    946959      if(SHORT1FROMMP(mp1) & KC_KEYUP)
    947         return (MRESULT)TRUE;
     960        return (MRESULT)TRUE;
    948961      if(SHORT1FROMMP(mp1) & KC_VIRTUALKEY) {
    949         switch(SHORT2FROMMP(mp2)) {
    950           case VK_INSERT:
    951             if((shiftstate & KC_CTRL) == KC_CTRL)
    952               PostMsg(hwnd,
    953                       WM_COMMAND,
    954                       MPFROM2SHORT(IDM_MKDIR,0),
    955                       MPVOID);
    956             break;
    957           case VK_DELETE:
    958             if((shiftstate & KC_CTRL) == KC_CTRL)
    959               PostMsg(hwnd,
    960                       WM_COMMAND,
    961                       MPFROM2SHORT(IDM_PERMDELETE,0),
    962                       MPVOID);
    963             else if((shiftstate & KC_SHIFT) == KC_SHIFT)
    964               PostMsg(hwnd,
    965                       WM_COMMAND,
    966                       MPFROM2SHORT(IDM_SAVETOCLIP,0),
    967                       MPVOID);
    968             else
    969               PostMsg(hwnd,
    970                       WM_COMMAND,
    971                       MPFROM2SHORT(IDM_DELETE,0),
    972                       MPVOID);
    973             break;
    974         }
     962        switch(SHORT2FROMMP(mp2)) {
     963          case VK_INSERT:
     964            if((shiftstate & KC_CTRL) == KC_CTRL)
     965              PostMsg(hwnd,
     966                      WM_COMMAND,
     967                      MPFROM2SHORT(IDM_MKDIR,0),
     968                      MPVOID);
     969            break;
     970          case VK_DELETE:
     971            if((shiftstate & KC_CTRL) == KC_CTRL)
     972              PostMsg(hwnd,
     973                      WM_COMMAND,
     974                      MPFROM2SHORT(IDM_PERMDELETE,0),
     975                      MPVOID);
     976            else if((shiftstate & KC_SHIFT) == KC_SHIFT)
     977              PostMsg(hwnd,
     978                      WM_COMMAND,
     979                      MPFROM2SHORT(IDM_SAVETOCLIP,0),
     980                      MPVOID);
     981            else
     982              PostMsg(hwnd,
     983                      WM_COMMAND,
     984                      MPFROM2SHORT(IDM_DELETE,0),
     985                      MPVOID);
     986            break;
     987        }
    975988      }
    976989      if(shiftstate || fNoSearch)
    977         break;
     990        break;
    978991      if(SHORT1FROMMP(mp1) & KC_CHAR) {
    979992
    980         ULONG        thistime,len;
    981         SEARCHSTRING srch;
    982         PCNRITEM     pci;
    983 
    984         if(!dcd)
    985           break;
    986         switch(SHORT1FROMMP(mp2)) {
    987           case '\x1b':
    988           case '\r':
    989           case '\n':
    990             dcd->lasttime = 0;
    991             *dcd->szCommonName = 0;
    992             break;
    993           default:
    994             thistime = WinQueryMsgTime(WinQueryAnchorBlock(hwnd));
    995             if(thistime > dcd->lasttime + 1250)
    996               *dcd->szCommonName = 0;
    997             dcd->lasttime = thistime;
    998             if(SHORT1FROMMP(mp2) == ' ' && !*dcd->szCommonName)
    999               break;
     993        ULONG        thistime,len;
     994        SEARCHSTRING srch;
     995        PCNRITEM     pci;
     996
     997        if(!dcd)
     998          break;
     999        switch(SHORT1FROMMP(mp2)) {
     1000          case '\x1b':
     1001          case '\r':
     1002          case '\n':
     1003            dcd->lasttime = 0;
     1004            *dcd->szCommonName = 0;
     1005            break;
     1006          default:
     1007            thistime = WinQueryMsgTime(WinQueryAnchorBlock(hwnd));
     1008            if(thistime > dcd->lasttime + 1250)
     1009              *dcd->szCommonName = 0;
     1010            dcd->lasttime = thistime;
     1011            if(SHORT1FROMMP(mp2) == ' ' && !*dcd->szCommonName)
     1012              break;
    10001013KbdRetry:
    1001             len = strlen(dcd->szCommonName);
    1002             if(len >= CCHMAXPATH - 1) {
    1003               *dcd->szCommonName = 0;
    1004               len = 0;
    1005             }
    1006             dcd->szCommonName[len] = toupper(SHORT1FROMMP(mp2));
    1007             dcd->szCommonName[len + 1] = 0;
    1008             memset(&srch,0,sizeof(SEARCHSTRING));
    1009             srch.cb = (ULONG)sizeof(SEARCHSTRING);
    1010             srch.pszSearch = (PSZ)dcd->szCommonName;
    1011             srch.fsPrefix = TRUE;
    1012             srch.fsCaseSensitive = FALSE;
    1013             srch.usView = CV_ICON;
    1014             pci = WinSendMsg(hwnd,
    1015                              CM_SEARCHSTRING,
    1016                              MPFROMP(&srch),
    1017                              MPFROMLONG(CMA_FIRST));
    1018             if(pci && (INT)pci != -1) {
    1019               /* make found item current item */
    1020               WinSendMsg(hwnd,
    1021                         CM_SETRECORDEMPHASIS,
    1022                         MPFROMP(pci),
    1023                         MPFROM2SHORT(TRUE,CRA_CURSORED));
    1024               /* make sure that record shows in viewport */
    1025               ShowCnrRecord(hwnd,
    1026                             (PMINIRECORDCORE)pci);
    1027               return (MRESULT)TRUE;
    1028             }
    1029             else {
    1030               if(SHORT1FROMMP(mp2) == ' ') {
    1031                 dcd->szCommonName[len] = 0;
    1032                 break;
    1033               }
    1034               *dcd->szCommonName = 0;
    1035               dcd->lasttime = 0;
    1036               if(len)           // retry as first letter if no match
    1037                 goto KbdRetry;
    1038             }
    1039             break;
    1040         }
     1014            len = strlen(dcd->szCommonName);
     1015            if(len >= CCHMAXPATH - 1) {
     1016              *dcd->szCommonName = 0;
     1017              len = 0;
     1018            }
     1019            dcd->szCommonName[len] = toupper(SHORT1FROMMP(mp2));
     1020            dcd->szCommonName[len + 1] = 0;
     1021            memset(&srch,0,sizeof(SEARCHSTRING));
     1022            srch.cb = (ULONG)sizeof(SEARCHSTRING);
     1023            srch.pszSearch = (PSZ)dcd->szCommonName;
     1024            srch.fsPrefix = TRUE;
     1025            srch.fsCaseSensitive = FALSE;
     1026            srch.usView = CV_ICON;
     1027            pci = WinSendMsg(hwnd,
     1028                             CM_SEARCHSTRING,
     1029                             MPFROMP(&srch),
     1030                             MPFROMLONG(CMA_FIRST));
     1031            if(pci && (INT)pci != -1) {
     1032              /* make found item current item */
     1033              WinSendMsg(hwnd,
     1034                        CM_SETRECORDEMPHASIS,
     1035                        MPFROMP(pci),
     1036                        MPFROM2SHORT(TRUE,CRA_CURSORED));
     1037              /* make sure that record shows in viewport */
     1038              ShowCnrRecord(hwnd,
     1039                            (PMINIRECORDCORE)pci);
     1040              return (MRESULT)TRUE;
     1041            }
     1042            else {
     1043              if(SHORT1FROMMP(mp2) == ' ') {
     1044                dcd->szCommonName[len] = 0;
     1045                break;
     1046              }
     1047              *dcd->szCommonName = 0;
     1048              dcd->lasttime = 0;
     1049              if(len)           // retry as first letter if no match
     1050                goto KbdRetry;
     1051            }
     1052            break;
     1053        }
    10411054      }
    10421055      break;
    … …  
    10511064    case UM_TIMER:
    10521065      if(dcd && dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent) &&
    1053          hwndStatus2) {
    1054 
    1055         FILEFINDBUF3 ffb;
    1056         ULONG        nm = 1L;
    1057         HDIR         hdir =  HDIR_CREATE;
    1058 
    1059         if(*SwapperDat) {
    1060           if(!DosFindFirst(SwapperDat,
    1061                            &hdir,
    1062                            FILE_NORMAL | FILE_HIDDEN |
    1063                            FILE_SYSTEM | FILE_ARCHIVED | FILE_READONLY,
    1064                            &ffb,
    1065                            sizeof(ffb),
    1066                            &nm,
    1067                            FIL_STANDARD)) {
    1068 
    1069             CHAR  tb[39],tm[39],tpm[39],s[163];
    1070             ULONG amem = 0;
    1071 
    1072             priority_bumped();
    1073             DosFindClose(hdir);
    1074             *tm = *tpm = 0;
    1075             if(!DosQuerySysInfo(QSV_TOTAVAILMEM,
    1076                                 QSV_TOTAVAILMEM,
    1077                                 (PVOID)&amem,
    1078                                 (ULONG)sizeof(amem))) {
    1079               CommaFmtULL(tpm,sizeof(tpm),amem,'K');
    1080             }
    1081             if(!Dos16MemAvail(&amem))
    1082               CommaFmtULL(tm,sizeof(tm),amem,'K');
    1083             CommaFmtULL(tb,sizeof(tb),ffb.cbFile,'K');
    1084             sprintf(s," %s %sk%s%s%s%s",
    1085                     GetPString(IDS_SWAPFILETEXT),
    1086                     tb,
    1087                     (*tm) ? GetPString(IDS_TREEMEMTEXT) : NullStr,
    1088                     tm,
    1089                     (*tpm) ? "/" : NullStr,
    1090                     tpm);
    1091             WinSetWindowText(hwndStatus2,s);
    1092           }
    1093           else
    1094             WinSetWindowText(hwndStatus2,NullStr);
    1095         }
    1096         else
    1097           WinSetWindowText(hwndStatus2,NullStr);
     1066         hwndStatus2)
     1067      {
     1068        FILEFINDBUF3 ffb;
     1069        ULONG        nm = 1L;
     1070        HDIR         hdir =  HDIR_CREATE;
     1071
     1072        if(*SwapperDat)
     1073        {
     1074          if (!DosFindFirst(SwapperDat,
     1075                            &hdir,
     1076                            FILE_NORMAL | FILE_HIDDEN |
     1077                            FILE_SYSTEM | FILE_ARCHIVED | FILE_READONLY,
     1078                            &ffb,
     1079                            sizeof(ffb),
     1080                            &nm,
     1081                            FIL_STANDARD))
     1082          {
     1083            CHAR  tb[39],tm[39],tpm[39],s[163];
     1084            ULONG amem;
     1085
     1086            priority_bumped();
     1087            DosFindClose(hdir);
     1088            if (!DosQuerySysInfo(QSV_TOTAVAILMEM,
     1089                                 QSV_TOTAVAILMEM,
     1090                                 (PVOID)&amem,
     1091                                 sizeof(amem)))
     1092            {
     1093              CommaFmtULL(tpm,sizeof(tpm),amem,'M');
     1094            }
     1095            else
     1096              *tpm = 0;
     1097            if (!Dos16MemAvail(&amem))
     1098              CommaFmtULL(tm,sizeof(tm),amem,'M');
     1099            else
     1100              *tm = 0;
     1101            CommaFmtULL(tb,sizeof(tb),ffb.cbFile,'M');
     1102            sprintf(s," %s %s%s%s%s%s",
     1103                    GetPString(IDS_SWAPFILETEXT),
     1104                    tb,
     1105                    *tm ? GetPString(IDS_TREEMEMTEXT) : NullStr,
     1106                    tm,
     1107                    *tpm ? "/" : NullStr,
     1108                    tpm);
     1109            WinSetWindowText(hwndStatus2,s);
     1110          }
     1111          else
     1112            WinSetWindowText(hwndStatus2,NullStr);
     1113        }
     1114        else
     1115          WinSetWindowText(hwndStatus2,NullStr);
    10981116      }
    10991117      if(msg == UM_TIMER)
    1100         return 0;
     1118        return 0;
    11011119      break;
    11021120
    11031121    case WM_PRESPARAMCHANGED:
    11041122      PresParamChanged(hwnd,
    1105                        "TreeCnr",
    1106                        mp1,
    1107                        mp2);
     1123                       "TreeCnr",
     1124                       mp1,
     1125                       mp2);
    11081126      break;
    11091127
    11101128    case UM_FILESMENU:
    11111129      {
    1112         PCNRITEM pci;
    1113         HWND     menuHwnd = (HWND)0;
    1114 
    1115         pci = (PCNRITEM)CurrentRecord(hwnd);
    1116         if(pci && (INT)pci != -1) {
    1117           if(IsRoot(pci->szFileName))
    1118             menuHwnd = CheckMenu(&TreeMenu,
    1119                                 TREE_POPUP);
    1120           else {
    1121             menuHwnd = CheckMenu(&DirMenu,
    1122                                 DIR_POPUP);
     1130        PCNRITEM pci;
     1131        HWND     menuHwnd = (HWND)0;
     1132
     1133        pci = (PCNRITEM)CurrentRecord(hwnd);
     1134        if(pci && (INT)pci != -1) {
     1135          if(IsRoot(pci->szFileName))
     1136            menuHwnd = CheckMenu(&TreeMenu,
     1137                                TREE_POPUP);
     1138          else {
     1139            menuHwnd = CheckMenu(&DirMenu,
     1140                                DIR_POPUP);
    11231141//            WinEnableMenuItem(DirMenu,
    11241142//                              IDM_TREE,
    11251143//                              FALSE);
    1126           }
    1127           if(!(pci->attrFile & FILE_DIRECTORY))
    1128             menuHwnd = CheckMenu(&FileMenu,
    1129                                 FILE_POPUP);
    1130         }
    1131         return MRFROMLONG(menuHwnd);
     1144          }
     1145          if(!(pci->attrFile & FILE_DIRECTORY))
     1146            menuHwnd = CheckMenu(&FileMenu,
     1147                                FILE_POPUP);
     1148        }
     1149        return MRFROMLONG(menuHwnd);
    11321150      }
    11331151
    … …  
    11351153      if(dcd && mp1 && mp2) {
    11361154
    1137         COMPARE *cmp;
    1138         CHAR    *leftdir = (CHAR *)mp1,*rightdir = (CHAR *)mp2;
    1139 
    1140         if(!IsFile(leftdir) &&
    1141            !IsFile(rightdir)) {
    1142           cmp = malloc(sizeof(COMPARE));
    1143           if(cmp) {
    1144             memset(cmp,0,sizeof(COMPARE));
    1145             cmp->size = sizeof(COMPARE);
    1146             strcpy(cmp->leftdir,leftdir);
    1147             strcpy(cmp->rightdir,rightdir);
    1148             cmp->hwndParent = dcd->hwndParent;
    1149             cmp->dcd.hwndParent = dcd->hwndParent;
    1150             WinDlgBox(HWND_DESKTOP,
    1151                       HWND_DESKTOP,
    1152                       CompareDlgProc,
    1153                       FM3ModHandle,
    1154                       COMP_FRAME,
    1155                       MPFROMP(cmp));
    1156           }
    1157         }
     1155        COMPARE *cmp;
     1156        CHAR    *leftdir = (CHAR *)mp1,*rightdir = (CHAR *)mp2;
     1157
     1158        if(!IsFile(leftdir) &&
     1159           !IsFile(rightdir)) {
     1160          cmp = malloc(sizeof(COMPARE));
     1161          if(cmp) {
     1162            memset(cmp,0,sizeof(COMPARE));
     1163            cmp->size = sizeof(COMPARE);
     1164            strcpy(cmp->leftdir,leftdir);
     1165            strcpy(cmp->rightdir,rightdir);
     1166            cmp->hwndParent = dcd->hwndParent;
     1167            cmp->dcd.hwndParent = dcd->hwndParent;
     1168            WinDlgBox(HWND_DESKTOP,
     1169                      HWND_DESKTOP,
     1170                      CompareDlgProc,
     1171                      FM3ModHandle,
     1172                      COMP_FRAME,
     1173                      MPFROMP(cmp));
     1174          }
     1175        }
    11581176      }
    11591177      return 0;
    … …  
    11611179    case UM_UPDATERECORDLIST:
    11621180      if(dcd && mp1)
    1163         WinSendMsg(dcd->hwndObject,
    1164                    msg,
    1165                    mp1,
    1166                    mp2);
     1181        WinSendMsg(dcd->hwndObject,
     1182                   msg,
     1183                   mp1,
     1184                   mp2);
    11671185      return 0;
    11681186
    … …  
    11701188      if(dcd && mp1) {
    11711189
    1172         CHAR *filename;
    1173 
    1174         filename = mp1;
    1175         if(filename)
    1176           UpdateCnrRecord(hwnd,
    1177                           filename,
    1178                           TRUE,
    1179                           dcd);
     1190        CHAR *filename;
     1191
     1192        filename = mp1;
     1193        if(filename)
     1194          UpdateCnrRecord(hwnd,
     1195                          filename,
     1196                          TRUE,
     1197                          dcd);
    11801198      }
    11811199      return 0;
    … …  
    11831201    case WM_SETFOCUS:
    11841202      if(dcd && hwndStatus && mp2) {
    1185         WinSendMsg(hwnd,
    1186                    UM_RESCAN,
    1187                    MPVOID,
    1188                    MPVOID);
    1189         if(hwndMain)
    1190           PostMsg(hwndMain,
    1191                   UM_ADVISEFOCUS,
    1192                   MPFROMLONG(dcd->hwndFrame),
    1193                   MPVOID);
     1203        WinSendMsg(hwnd,
     1204                   UM_RESCAN,
     1205                   MPVOID,
     1206                   MPVOID);
     1207        if(hwndMain)
     1208          PostMsg(hwndMain,
     1209                  UM_ADVISEFOCUS,
     1210                  MPFROMLONG(dcd->hwndFrame),
     1211                  MPVOID);
    11941212      }
    11951213      break;
    … …  
    11971215    case UM_RESCAN:
    11981216      if(dcd && dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent)) {
    1199         /*
    1200         * put name of our window on status line
    1201         */
    1202 
    1203         PCNRITEM  pci = NULL;
    1204         CHAR      str[CCHMAXPATH + 6];
    1205 
    1206         if(fAutoView && hwndMain) {
    1207           pci = WinSendMsg(hwnd,
    1208                            CM_QUERYRECORDEMPHASIS,
    1209                            MPFROMLONG(CMA_FIRST),
    1210                            MPFROMSHORT(CRA_CURSORED));
    1211           if(pci && (INT)pci != -1 && fComments &&
    1212              !(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_SLOW))
    1213             WinSendMsg(hwndMain,
    1214                        UM_LOADFILE,
    1215                        MPFROMP(pci->szFileName),
    1216                        MPVOID);
    1217           else
    1218             WinSendMsg(hwndMain,
    1219                        UM_LOADFILE,
    1220                        MPVOID,
    1221                        MPVOID);
    1222         }
    1223         if(!fAutoView ||
    1224            !hwndMain)
    1225           pci = (PCNRITEM)WinSendMsg(hwnd,
    1226                                      CM_QUERYRECORDEMPHASIS,
    1227                                      MPFROMLONG(CMA_FIRST),
    1228                                      MPFROMSHORT(CRA_CURSORED));
    1229         if((INT)pci == -1)
    1230           pci = NULL;
    1231         if(pci) {
    1232           if(*(ULONG *)realappname == FM3UL) {
    1233             sprintf(str,
    1234                     "%s %s",
    1235                     GetPString(IDS_DTTEXT),
    1236                     pci->szFileName);
    1237             WinSetWindowText(dcd->hwndFrame,
    1238                              str);
    1239             WinSetWindowText(WinWindowFromID(dcd->hwndFrame,FID_TITLEBAR),
    1240                              str);
    1241           }
    1242           else
    1243             WinSetWindowText(WinWindowFromID(dcd->hwndFrame,
    1244                                              MAIN_STATUS),
    1245                              pci->szFileName);
    1246           if(fMoreButtons && hwndName) {
    1247             WinSetWindowText(hwndName,
    1248                              pci->szFileName);
    1249             sprintf(str,
    1250                     "%04u/%02u/%02u %02u:%02u:%02u",
    1251                     pci->date.year,
    1252                     pci->date.month,
    1253                     pci->date.day,
    1254                     pci->time.hours,
    1255                     pci->time.minutes,
    1256                     pci->time.seconds);
    1257             WinSetWindowText(hwndDate,
    1258                              str);
    1259             WinSetWindowText(hwndAttr,
    1260                              pci->pszDispAttr);
    1261           }
    1262         }
    1263         PostMsg(dcd->hwndObject,
    1264                 UM_RESCAN2,
    1265                 MPFROMP(pci),
    1266                 MPVOID);
    1267         if(hwndStatus2)
    1268           PostMsg(hwnd,
    1269                   UM_TIMER,
    1270                   MPVOID,
    1271                   MPVOID);
     1217        /*
     1218        * put name of our window on status line
     1219        */
     1220
     1221        PCNRITEM  pci = NULL;
     1222        CHAR      str[CCHMAXPATH + 6];
     1223
     1224        if(fAutoView && hwndMain) {
     1225          pci = WinSendMsg(hwnd,
     1226                           CM_QUERYRECORDEMPHASIS,
     1227                           MPFROMLONG(CMA_FIRST),
     1228                           MPFROMSHORT(CRA_CURSORED));
     1229          if(pci && (INT)pci != -1 && fComments &&
     1230             !(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_SLOW))
     1231            WinSendMsg(hwndMain,
     1232                       UM_LOADFILE,
     1233                       MPFROMP(pci->szFileName),
     1234                       MPVOID);
     1235          else
     1236            WinSendMsg(hwndMain,
     1237                       UM_LOADFILE,
     1238                       MPVOID,
     1239                       MPVOID);
     1240        }
     1241        if(!fAutoView ||
     1242           !hwndMain)
     1243          pci = (PCNRITEM)WinSendMsg(hwnd,
     1244                                     CM_QUERYRECORDEMPHASIS,
     1245                                     MPFROMLONG(CMA_FIRST),
     1246                                     MPFROMSHORT(CRA_CURSORED));
     1247        if((INT)pci == -1)
     1248          pci = NULL;
     1249        if(pci) {
     1250          if(*(ULONG *)realappname == FM3UL) {
     1251            sprintf(str,
     1252                    "%s %s",
     1253                    GetPString(IDS_DTTEXT),
     1254                    pci->szFileName);
     1255            WinSetWindowText(dcd->hwndFrame,
     1256                             str);
     1257            WinSetWindowText(WinWindowFromID(dcd->hwndFrame,FID_TITLEBAR),
     1258                             str);
     1259          }
     1260          else
     1261            WinSetWindowText(WinWindowFromID(dcd->hwndFrame,
     1262                                             MAIN_STATUS),
     1263                             pci->szFileName);
     1264          if(fMoreButtons && hwndName) {
     1265            WinSetWindowText(hwndName,
     1266                             pci->szFileName);
     1267            sprintf(str,
     1268                    "%04u/%02u/%02u %02u:%02u:%02u",
     1269                    pci->date.year,
     1270                    pci->date.month,
     1271                    pci->date.day,
     1272                    pci->time.hours,
     1273                    pci->time.minutes,
     1274                    pci->time.seconds);
     1275            WinSetWindowText(hwndDate,
     1276                             str);
     1277            WinSetWindowText(hwndAttr,
     1278                             pci->pszDispAttr);
     1279          }
     1280        }
     1281        PostMsg(dcd->hwndObject,
     1282                UM_RESCAN2,
     1283                MPFROMP(pci),
     1284                MPVOID);
     1285        if(hwndStatus2)
     1286          PostMsg(hwnd,
     1287                  UM_TIMER,
     1288                  MPVOID,
     1289                  MPVOID);
    12721290      }
    12731291      return 0;
    … …  
    12751293    case UM_SETUP2:
    12761294      {
    1277         PCNRITEM pci = (PCNRITEM)mp1;
    1278 
    1279         if(pci)
    1280           NotifyError(pci->szFileName,
    1281                       (ULONG)mp2);
     1295        PCNRITEM pci = (PCNRITEM)mp1;
     1296
     1297        if(pci)
     1298          NotifyError(pci->szFileName,
     1299                      (ULONG)mp2);
    12821300      }
    12831301      return 0;
    … …  
    12851303    case UM_SETUP:
    12861304      if(dcd) {
    1287         if(!dcd->hwndObject) {
    1288           /*
    1289            * first time through -- set things up
    1290            */
    1291 
    1292           CNRINFO cnri;
    1293 
    1294           RestorePresParams(hwnd,"TreeCnr");
    1295           memset(&cnri,0,sizeof(CNRINFO));
    1296           cnri.cb = sizeof(CNRINFO);
    1297           WinSendMsg(hwnd,
    1298                      CM_QUERYCNRINFO,
    1299                      MPFROMP(&cnri),
    1300                      MPFROMLONG(sizeof(CNRINFO)));
    1301           cnri.cyLineSpacing = 0;
    1302           cnri.cxTreeIndent = 12L;
    1303           cnri.pSortRecord = (PVOID)SortTreeCnr;
    1304           cnri.flWindowAttr &= (~(CV_NAME | CV_DETAIL | CV_TEXT));
    1305           cnri.flWindowAttr |= (CV_TREE | CA_TREELINE | CV_ICON | CV_MINI);
    1306           {
    1307             ULONG size = sizeof(ULONG);
    1308 
    1309             PrfQueryProfileData(fmprof,
    1310                                 appname,
    1311                                 "TreeflWindowAttr",
    1312                                 (PVOID)&cnri.flWindowAttr,
    1313                                 &size);
    1314             size = sizeof(MASK);
    1315             *dcd->mask.prompt = 0;
    1316             if(!*dcd->mask.szMask && !dcd->mask.attrFile) {
    1317               if(PrfQueryProfileSize(fmprof,
    1318                                      appname,
    1319                                      "TreeFilter",
    1320                                      &size) &&
    1321                 size) {
    1322                 PrfQueryProfileData(fmprof,
    1323                                     appname,
    1324                                     "TreeFilter",
    1325                                     &dcd->mask,
    1326                                     &size);
    1327                 SetMask(dcd->mask.szMask,
    1328                         &dcd->mask);
    1329               }
    1330               else
    1331                 dcd->mask.attrFile = (FILE_READONLY | FILE_NORMAL |
    1332                                       FILE_ARCHIVED | FILE_DIRECTORY |
    1333                                       FILE_HIDDEN   | FILE_SYSTEM);
    1334             }
    1335             dcd->mask.attrFile |= FILE_DIRECTORY;
    1336           }
    1337           cnri.flWindowAttr &= (~(CA_MIXEDTARGETEMPH | CA_ORDEREDTARGETEMPH));
    1338           cnri.flWindowAttr |= CV_FLOW;
    1339           dcd->flWindowAttr = cnri.flWindowAttr;
    1340           WinSendMsg(hwnd,
    1341                      CM_SETCNRINFO,
    1342                      MPFROMP(&cnri),
    1343                      MPFROMLONG(CMA_FLWINDOWATTR | CMA_LINESPACING |
    1344                                 CMA_CXTREEINDENT | CMA_PSORTRECORD));
     1305        if(!dcd->hwndObject) {
     1306          /*
     1307           * first time through -- set things up
     1308           */
     1309
     1310          CNRINFO cnri;
     1311
     1312          RestorePresParams(hwnd,"TreeCnr");
     1313          memset(&cnri,0,sizeof(CNRINFO));
     1314          cnri.cb = sizeof(CNRINFO);
     1315          WinSendMsg(hwnd,
     1316                     CM_QUERYCNRINFO,
     1317                     MPFROMP(&cnri),
     1318                     MPFROMLONG(sizeof(CNRINFO)));
     1319          cnri.cyLineSpacing = 0;
     1320          cnri.cxTreeIndent = 12L;
     1321          cnri.pSortRecord = (PVOID)SortTreeCnr;
     1322          cnri.flWindowAttr &= (~(CV_NAME | CV_DETAIL | CV_TEXT));
     1323          cnri.flWindowAttr |= (CV_TREE | CA_TREELINE | CV_ICON | CV_MINI);
     1324          {
     1325            ULONG size = sizeof(ULONG);
     1326
     1327            PrfQueryProfileData(fmprof,
     1328                                appname,
     1329                                "TreeflWindowAttr",
     1330                                (PVOID)&cnri.flWindowAttr,
     1331                                &size);
     1332            size = sizeof(MASK);
     1333            *dcd->mask.prompt = 0;
     1334            if(!*dcd->mask.szMask && !dcd->mask.attrFile) {
     1335              if(PrfQueryProfileSize(fmprof,
     1336                                     appname,
     1337                                     "TreeFilter",
     1338                                     &size) &&
     1339                size) {
     1340                PrfQueryProfileData(fmprof,
     1341                                    appname,
     1342                                    "TreeFilter",
     1343                                    &dcd->mask,
     1344                                    &size);
     1345                SetMask(dcd->mask.szMask,
     1346                        &dcd->mask);
     1347              }
     1348              else
     1349                dcd->mask.attrFile = (FILE_READONLY | FILE_NORMAL |
     1350                                      FILE_ARCHIVED | FILE_DIRECTORY |
     1351                                      FILE_HIDDEN   | FILE_SYSTEM);
     1352            }
     1353            dcd->mask.attrFile |= FILE_DIRECTORY;
     1354          }
     1355          cnri.flWindowAttr &= (~(CA_MIXEDTARGETEMPH | CA_ORDEREDTARGETEMPH));
     1356          cnri.flWindowAttr |= CV_FLOW;
     1357          dcd->flWindowAttr = cnri.flWindowAttr;
     1358          WinSendMsg(hwnd,
     1359                     CM_SETCNRINFO,
     1360                     MPFROMP(&cnri),
     1361                     MPFROMLONG(CMA_FLWINDOWATTR | CMA_LINESPACING |
     1362                                CMA_CXTREEINDENT | CMA_PSORTRECORD));
    13451363//                                CMA_TREEICON));
    1346           if(_beginthread(MakeObjWin,
    1347                           NULL,
    1348                           327680,
    1349                           (PVOID)dcd) ==
    1350              -1) {
    1351             PostMsg(hwnd,
    1352                     WM_CLOSE,
    1353                     MPVOID,
    1354                     MPVOID);
    1355             return 0;
    1356           }
    1357           else
    1358             DosSleep(1L);
    1359         }
     1364          if(_beginthread(MakeObjWin,
     1365                          NULL,
     1366                          327680,
     1367                          (PVOID)dcd) ==
     1368             -1) {
     1369            PostMsg(hwnd,
     1370                    WM_CLOSE,
     1371                    MPVOID,
     1372                    MPVOID);
     1373            return 0;
     1374          }
     1375          else
     1376            DosSleep(1L);
     1377        }
    13601378      }
    13611379      else {
    1362         PostMsg(hwnd,
    1363                 WM_CLOSE,
    1364                 MPVOID,
    1365                 MPVOID);
    1366         return 0;
     1380        PostMsg(hwnd,
     1381                WM_CLOSE,
     1382                MPVOID,
     1383                MPVOID);
     1384        return 0;
    13671385      }
    13681386      return 0;
    … …  
    13711389    case WM_CHORD:
    13721390      {
    1373         PCNRITEM          pci = NULL;
    1374         QUERYRECFROMRECT  pqr;
    1375         NOTIFYRECORDENTER nr;
    1376         BOOL              tbool = fDCOpens;
    1377         RECTL             rectl;
    1378         POINTL            ptl;
    1379 
    1380         shiftstate = (SHORT2FROMMP(mp2) & (KC_SHIFT | KC_ALT | KC_CTRL));
    1381         if(msg == WM_CHORD) {
    1382           if(!WinQueryPointerPos(HWND_DESKTOP,
    1383                                 &ptl))
    1384             break;
    1385           WinMapWindowPoints(HWND_DESKTOP,
    1386                              hwnd,
    1387                              &ptl,
    1388                              1L);
    1389         }
    1390         else {
    1391           ptl.x = SHORT1FROMMP(mp1);
    1392           ptl.y = SHORT2FROMMP(mp1);
    1393         }
    1394         memset(&rectl,0,sizeof(rectl));
    1395         memset(&pqr,0,sizeof(pqr));
    1396         pqr.cb = sizeof(pqr);
    1397         pqr.rect.xLeft = ptl.x - 1;
    1398         pqr.rect.xRight = ptl.x + 1;
    1399         pqr.rect.yTop = ptl.y + 1;
    1400         pqr.rect.yBottom = ptl.y - 1;
    1401         pqr.fsSearch = CMA_PARTIAL;
    1402         pci = (PCNRITEM)WinSendMsg(hwnd,
    1403                                    CM_QUERYRECORDFROMRECT,
    1404                                    MPFROMLONG(CMA_FIRST),
    1405                                    MPFROMP(&pqr));
    1406         if(pci && (INT)pci != -1) {
    1407           memset(&nr,0,sizeof(nr));
    1408           nr.hwndCnr = hwnd;
    1409           nr.pRecord = (PRECORDCORE)pci;
    1410           fDCOpens = TRUE;
    1411           WinSendMsg(hwnd,
    1412                      WM_CONTROL,
    1413                      MPFROM2SHORT(WinQueryWindowUShort(hwnd,
    1414                                                        QWS_ID),
    1415                                   CN_ENTER),
    1416                      MPFROMP(&nr));
    1417           PostMsg(hwnd,
    1418                   UM_RESTOREDC,
    1419                   MPFROMLONG(tbool),
    1420                   MPVOID);
    1421         }
    1422         else
    1423           DosBeep(50,100);
     1391        PCNRITEM          pci = NULL;
     1392        QUERYRECFROMRECT  pqr;
     1393        NOTIFYRECORDENTER nr;
     1394        BOOL              tbool = fDCOpens;
     1395        RECTL             rectl;
     1396        POINTL            ptl;
     1397
     1398        shiftstate = (SHORT2FROMMP(mp2) & (KC_SHIFT | KC_ALT | KC_CTRL));
     1399        if(msg == WM_CHORD) {
     1400          if(!WinQueryPointerPos(HWND_DESKTOP,
     1401                                &ptl))
     1402            break;
     1403          WinMapWindowPoints(HWND_DESKTOP,
     1404                             hwnd,
     1405                             &ptl,
     1406                             1L);
     1407        }
     1408        else {
     1409          ptl.x = SHORT1FROMMP(mp1);
     1410          ptl.y = SHORT2FROMMP(mp1);
     1411        }
     1412        memset(&rectl,0,sizeof(rectl));
     1413        memset(&pqr,0,sizeof(pqr));
     1414        pqr.cb = sizeof(pqr);
     1415        pqr.rect.xLeft = ptl.x - 1;
     1416        pqr.rect.xRight = ptl.x + 1;
     1417        pqr.rect.yTop = ptl.y + 1;
     1418        pqr.rect.yBottom = ptl.y - 1;
     1419        pqr.fsSearch = CMA_PARTIAL;
     1420        pci = (PCNRITEM)WinSendMsg(hwnd,
     1421                                   CM_QUERYRECORDFROMRECT,
     1422                                   MPFROMLONG(CMA_FIRST),
     1423                                   MPFROMP(&pqr));
     1424        if(pci && (INT)pci != -1) {
     1425          memset(&nr,0,sizeof(nr));
     1426          nr.hwndCnr = hwnd;
     1427          nr.pRecord = (PRECORDCORE)pci;
     1428          fDCOpens = TRUE;
     1429          WinSendMsg(hwnd,
     1430                     WM_CONTROL,
     1431                     MPFROM2SHORT(WinQueryWindowUShort(hwnd,
     1432                                                       QWS_ID),
     1433                                  CN_ENTER),
     1434                     MPFROMP(&nr));
     1435          PostMsg(hwnd,
     1436                  UM_RESTOREDC,
     1437                  MPFROMLONG(tbool),
     1438                  MPVOID);
     1439        }
     1440        else
     1441          DosBeep(50,100);
    14241442      }
    14251443      break;
    … …  
    14321450      DosError(FERR_DISABLEHARDERR);
    14331451      if(dcd) {
    1434         switch(SHORT2FROMMP(mp1)) {
    1435           case CN_BEGINEDIT:
    1436           case CN_REALLOCPSZ:
    1437           case CN_ENDEDIT:
    1438             {
    1439               MRESULT mre;
    1440 
    1441               mre = CnrDirectEdit(hwnd,
    1442                                   msg,
    1443                                   mp1,
    1444                                   mp2);
    1445               if(mre != (MRESULT)-1)
    1446                 return mre;
    1447             }
    1448             break;
    1449 
    1450           case CN_DRAGLEAVE:
    1451             if(mp2) {
    1452 
    1453               PDRAGINFO pDInfo;
    1454 
    1455               pDInfo = ((PCNRDRAGINFO)mp2)->pDragInfo;
    1456               DrgAccessDraginfo(pDInfo);
    1457               DrgFreeDraginfo(pDInfo);
    1458             }
    1459             return 0;
    1460 
    1461           case CN_DRAGAFTER:
    1462           case CN_DRAGOVER:
    1463             if(mp2) {
    1464 
    1465               PDRAGITEM pDItem;
    1466               PDRAGINFO pDInfo;
    1467               PCNRITEM  pci;
    1468               USHORT    uso;
    1469 
    1470               pDInfo = ((PCNRDRAGINFO)mp2)->pDragInfo;
    1471               DrgAccessDraginfo(pDInfo);
    1472               pci = (PCNRITEM)((PCNRDRAGINFO)mp2)->pRecord;
    1473               if((INT)pci == -1)
    1474                 pci = NULL;
    1475               if(pci &&
    1476                  (pci->flags & (RECFLAGS_ENV | RECFLAGS_NODROP))) {
    1477                 DrgFreeDraginfo(pDInfo);
    1478                 return MRFROM2SHORT(DOR_NODROP,0);
    1479               }
    1480               if(!pDInfo) {
    1481                 DrgFreeDraginfo(pDInfo);
    1482                 return MRFROM2SHORT(DOR_NODROP,0);
    1483               }
    1484               if(!WinIsWindowEnabled(dcd->hwndFrame)) {
    1485                 DrgFreeDraginfo(pDInfo);
    1486                 return MRFROM2SHORT(DOR_NODROP,0);
    1487               }
    1488               if(pci) {
    1489                 uso = pDInfo->usOperation;
    1490                 if(uso == DO_DEFAULT)
    1491                   uso = (fCopyDefault) ? DO_COPY : DO_MOVE;
    1492                 if(!(pci->attrFile & FILE_DIRECTORY)) {
    1493                   if(uso != DO_LINK &&
    1494                      uso != DO_COPY &&
    1495                      uso != DO_MOVE) {
    1496                     DrgFreeDraginfo(pDInfo);
    1497                     return(MRFROM2SHORT(DOR_NODROP,0));
    1498                   }
    1499                   if(uso != DO_LINK &&
    1500                      !(driveflags[toupper(*pci->szFileName) - 'A'] &
    1501                        DRIVE_NOTWRITEABLE)) {
    1502 
    1503                     ARC_TYPE *info;
    1504 
    1505                     if(!fQuickArcFind &&
    1506                        !(driveflags[toupper(*pci->szFileName) - 'A'] &
    1507                          DRIVE_SLOW))
    1508                       info = find_type(pci->szFileName,NULL);
    1509                     else
    1510                       info = quick_find_type(pci->szFileName,NULL);
    1511                     if(!info || ((uso == DO_MOVE && !info->move) ||
    1512                        (uso == DO_COPY && !info->create)))  {
    1513                       DrgFreeDraginfo(pDInfo);
    1514                       return(MRFROM2SHORT(DOR_NODROP,0));
    1515                     }
    1516                   }
    1517                 }
    1518               }
    1519               pDItem = DrgQueryDragitemPtr(pDInfo,   /* Access DRAGITEM       */
    1520                                            0);       /* Index to DRAGITEM     */
    1521               if(DrgVerifyRMF(pDItem,                /* Check valid rendering */
    1522                               DRM_OS2FILE,           /* mechanisms and data   */
    1523                               NULL) ||
    1524                   DrgVerifyRMF(pDItem,DRM_FM2ARCMEMBER,
    1525                                DRF_FM2ARCHIVE)) {    /* formats               */
    1526                 DrgFreeDraginfo(pDInfo);             /* Free DRAGINFO         */
    1527                 if(!pci || (INT)pci == -1)
    1528                   return MRFROM2SHORT(DOR_DROP,DO_MOVE);
    1529                 if(driveflags[toupper(*pci->szFileName) - 'A'] &
    1530                    DRIVE_NOTWRITEABLE)
    1531                   return MRFROM2SHORT(DOR_DROP,DO_LINK);
    1532                 if(toupper(*pci->szFileName) < 'C')
    1533                   return MRFROM2SHORT(DOR_DROP,DO_COPY);
    1534                 return MRFROM2SHORT(DOR_DROP,     /* Return okay to drop   */
    1535                                     ((fCopyDefault) ?
    1536                                     DO_COPY :
    1537                                     DO_MOVE));
    1538               }
    1539               DrgFreeDraginfo(pDInfo);            /* Free DRAGINFO         */
    1540             }
    1541             return MRFROM2SHORT(DOR_NODROP,0);    /* Drop not valid        */
    1542 
    1543           case CN_INITDRAG:
    1544             {
    1545               PCNRDRAGINIT pcd = (PCNRDRAGINIT)mp2;
    1546               PCNRITEM     pci;
    1547 
    1548               if(pcd) {
    1549                 pci = (PCNRITEM)pcd->pRecord;
    1550                 if(!pci || (INT)pci == -1 ||
    1551                    (pci->flags & (RECFLAGS_ENV | RECFLAGS_NODRAG))) {
    1552                   DosBeep(50,100);
    1553                   break;
    1554                 }
    1555                 if(hwndStatus2)
    1556                   WinSetWindowText(hwndStatus2,(IsRoot(pci->szFileName)) ?
    1557                                    GetPString(IDS_DRAGROOTTEXT) :
    1558                                    (pci->attrFile & FILE_DIRECTORY) ?
    1559                                    GetPString(IDS_DRAGDIRTEXT) :
    1560                                    GetPString(IDS_DRAGFILETEXT));
    1561                 DoFileDrag(hwnd,
    1562                            dcd->hwndObject,
    1563                            mp2,
    1564                            NULL,
    1565                            NULL,
    1566                            TRUE);
    1567                 if(hwndStatus2)
    1568                   PostMsg(hwnd,
    1569                           UM_RESCAN,
    1570                           MPVOID,
    1571                           MPVOID);
    1572               }
    1573             }
    1574             return 0;
    1575 
    1576           case CN_DROP:
    1577             {
    1578               LISTINFO *li;
    1579               ULONG     action = UM_ACTION;
    1580 
    1581               li = DoFileDrop(hwnd,
    1582                               NULL,
    1583                               TRUE,
    1584                               mp1,
    1585                               mp2);
    1586               if(li) {
    1587                 if(!*li->targetpath) {
    1588                   if(li->list[0])
    1589                     PMMkDir(dcd->hwndParent,
    1590                             li->list[0],
    1591                             FALSE);
    1592                   FreeListInfo(li);
    1593                   return 0;
    1594                 }
    1595                 if(li->list &&
    1596                    li->list[0] &&
    1597                    IsRoot(li->list[0]))
    1598                   li->type = DO_LINK;
    1599                 else if(fDragndropDlg &&
    1600                         (!*li->arcname || !li->info)) {
    1601 
    1602                   CHECKLIST    cl;
    1603 
    1604                   memset(&cl,0,sizeof(cl));
    1605                   cl.size = sizeof(cl);
    1606                   cl.flags = li->type;
    1607                   cl.list = li->list;
    1608                   cl.cmd = li->type;
    1609                   cl.prompt = li->targetpath;
    1610                   li->type = WinDlgBox(HWND_DESKTOP,
    1611                                        dcd->hwndParent,
    1612                                        DropListProc,
    1613                                        FM3ModHandle,
    1614                                        DND_FRAME,
    1615                                        MPFROMP(&cl));
    1616                   if(!li->type) {
    1617                     FreeListInfo(li);
    1618                     return 0;
    1619                   }
    1620                   li->list = cl.list;
    1621                   if(!li->list || !li->list[0]) {
    1622                     FreeListInfo(li);
    1623                     return 0;
    1624                   }
    1625                 }
    1626                 switch(li->type) {
    1627                   case DO_LINK:
    1628                     if(fLinkSetsIcon) {
    1629                       li->type = IDM_SETICON;
    1630                       action = UM_MASSACTION;
    1631                     }
    1632                     else
    1633                       li->type = IDM_COMPARE;
    1634                     break;
    1635                   case DND_EXTRACT:
    1636                     if(*li->targetpath &&
    1637                        !IsFile(li->targetpath))
    1638                       li->type = IDM_EXTRACT;
    1639                     break;
    1640                   case DND_MOVE:
    1641                     li->type = IDM_MOVE;
    1642                     if(*li->targetpath &&
    1643                        IsFile(li->targetpath) == 1) {
    1644                       action = UM_MASSACTION;
    1645                       li->type = IDM_ARCHIVEM;
    1646                     }
    1647                     break;
    1648                   case DND_WILDMOVE:
    1649                     li->type = IDM_WILDMOVE;
    1650                     if(*li->targetpath &&
    1651                        IsFile(li->targetpath) == 1) {
    1652                       action = UM_MASSACTION;
    1653                       li->type = IDM_ARCHIVEM;
    1654                     }
    1655                     break;
    1656                   case DND_OBJECT:
    1657                     li->type = IDM_OBJECT;
    1658                     action = UM_MASSACTION;
    1659                     break;
    1660                   case DND_SHADOW:
    1661                     li->type = IDM_SHADOW;
    1662                     action = UM_MASSACTION;
    1663                     break;
    1664                   case DND_COMPARE:
    1665                     li->type = IDM_COMPARE;
    1666                     break;
    1667                   case DND_SETICON:
    1668                     action = UM_MASSACTION;
    1669                     li->type = IDM_SETICON;
    1670                     break;
    1671                   case DND_COPY:
    1672                     li->type = IDM_COPY;
    1673                     if(*li->targetpath &&
    1674                        IsFile(li->targetpath) == 1) {
    1675                       action = UM_MASSACTION;
    1676                       li->type = IDM_ARCHIVE;
    1677                     }
    1678                     break;
    1679                   case DND_WILDCOPY:
    1680                     li->type = IDM_WILDCOPY;
    1681                     if(*li->targetpath &&
    1682                        IsFile(li->targetpath) == 1) {
    1683                       action = UM_MASSACTION;
    1684                       li->type = IDM_ARCHIVE;
    1685                     }
    1686                     break;
    1687                   default:
    1688                     if(*li->arcname && li->info) {
    1689                       action = UM_MASSACTION;
    1690                       li->type = (li->type == DO_MOVE) ?
    1691                                   IDM_FAKEEXTRACTM :
    1692                                   IDM_FAKEEXTRACT;
    1693                     }
    1694                     else if(*li->targetpath &&
    1695                             IsFile(li->targetpath) == 1) {
    1696                       action = UM_MASSACTION;
    1697                       li->type = (li->type == DO_MOVE) ?
    1698                                   IDM_ARCHIVEM :
    1699                                   IDM_ARCHIVE;
    1700                     }
    1701                     else
    1702                       li->type = (li->type == DO_MOVE) ?
    1703                                   IDM_MOVE :
    1704                                   IDM_COPY;
    1705                     break;
    1706                 }
    1707                 if(!li->list || !li->list[0])
    1708                   FreeListInfo(li);
    1709                 else if(!PostMsg(dcd->hwndObject,
    1710                                  action,
    1711                                  MPFROMP(li),
    1712                                  MPVOID))
    1713                   FreeListInfo(li);
    1714                 else {
    1715 
    1716                   USHORT usop = 0;
    1717 
    1718                   switch(li->type) {
    1719                     case IDM_COPY:
    1720                     case IDM_WILDCOPY:
    1721                       usop = DO_COPY;
    1722                       break;
    1723                     case IDM_MOVE:
    1724                     case IDM_WILDMOVE:
    1725                     case IDM_ARCHIVEM:
    1726                       usop = DO_MOVE;
    1727                       break;
    1728                   }
    1729                   if(usop)
    1730                     return MRFROM2SHORT(DOR_DROP,usop);
    1731                 }
    1732               }
    1733             }
    1734             return 0;
    1735 
    1736           case CN_EMPHASIS:
    1737             if(!fDummy) {
    1738 
    1739               PNOTIFYRECORDEMPHASIS pre = mp2;
    1740 
    1741               if(pre->fEmphasisMask & CRA_SELECTED) {
    1742                 if(pre->pRecord->flRecordAttr & CRA_SELECTED) {
    1743                   if(((PCNRITEM)(pre->pRecord))->attrFile & FILE_DIRECTORY) {
    1744                     PostMsg(hwnd,
    1745                             UM_RESCAN,
    1746                             MPVOID,
    1747                             MPVOID);
    1748                     if(fFollowTree &&
    1749                        !(driveflags[toupper(*((PCNRITEM)pre->pRecord)->szFileName) - 'A'] &
    1750                          DRIVE_INVALID)) {
    1751                       if(!LastDir &&
    1752                          !ParentIsDesktop(hwnd,dcd->hwndParent))
    1753                         LastDir = FindDirCnr(dcd->hwndParent);
    1754                       if(LastDir) {
    1755 
    1756                         NOTIFYRECORDENTER pri;
    1757                         BOOL              tbool = fDCOpens;
    1758 
    1759                         fDCOpens = FALSE;
    1760                         memset(&pri,0,sizeof(pri));
    1761                         pri.hwndCnr = hwnd;
    1762                         pri.fKey = FALSE;
    1763                         pri.pRecord = pre->pRecord;
    1764                         WinSendMsg(hwnd,
    1765                                    WM_CONTROL,
    1766                                    MPFROM2SHORT(SHORT1FROMMP(mp1),
    1767                                                 CN_ENTER),
    1768                                    MPFROMP(&pri));
    1769                         fDCOpens = tbool;
    1770                       }
    1771                     }
    1772                     if(*(ULONG *)realappname != FM3UL)
    1773                       WinSetWindowText(WinWindowFromID(dcd->hwndFrame,
    1774                                                        MAIN_STATUS),
    1775                                        ((PCNRITEM)(pre->pRecord))->szFileName);
    1776                   }
    1777                 }
    1778               }
    1779             }
    1780             break;
    1781 
    1782           case CN_CONTEXTMENU:
    1783             {
    1784               PCNRITEM pci = (PCNRITEM)mp2;
    1785               BOOL     wasFollowing;
    1786 
    1787               DosEnterCritSec();
    1788                wasFollowing = fFollowTree;
    1789                fFollowTree = FALSE;
    1790               DosExitCritSec();
    1791               if(pci && (INT)pci != -1 && !(pci->flags & RECFLAGS_ENV)) {
    1792                 WinSendMsg(hwnd,
    1793                            CM_SETRECORDEMPHASIS,
    1794                            MPFROMP(pci),
    1795                            MPFROM2SHORT(TRUE,CRA_CURSORED));
    1796                 MarkAll(hwnd,
    1797                         FALSE,
    1798                         FALSE,
    1799                         TRUE);
    1800                 if(!(pci->attrFile & FILE_DIRECTORY))
    1801                   dcd->hwndLastMenu = CheckMenu(&FileMenu,FILE_POPUP);
    1802                 else if(!IsRoot(pci->szFileName))
    1803                   dcd->hwndLastMenu = CheckMenu(&DirMenu,DIR_POPUP);
    1804                 else
    1805                   dcd->hwndLastMenu = CheckMenu(&TreeMenu,TREE_POPUP);
    1806               }
    1807               else {
    1808                 dcd->hwndLastMenu = CheckMenu(&TreeCnrMenu,TREECNR_POPUP);
    1809                 if(dcd->hwndLastMenu && !dcd->cnremphasized) {
    1810                   WinSendMsg(hwnd,CM_SETRECORDEMPHASIS,MPVOID,
    1811                              MPFROM2SHORT(TRUE,CRA_SOURCE));
    1812                   dcd->cnremphasized = TRUE;
    1813                 }
    1814               }
    1815               if(dcd->hwndLastMenu) {
    1816                 if(dcd->hwndLastMenu == DirMenu)
    1817                   WinEnableMenuItem(DirMenu,IDM_TREE,FALSE);
    1818                 if(dcd->hwndLastMenu == TreeCnrMenu) {
    1819                   if(dcd->flWindowAttr & CV_MINI)
    1820                     WinCheckMenuItem(dcd->hwndLastMenu,IDM_MINIICONS,TRUE);
    1821                 }
    1822                 if(!PopupMenu(hwnd,hwnd,dcd->hwndLastMenu)) {
    1823                   if(dcd->cnremphasized) {
    1824                     WinSendMsg(hwnd,CM_SETRECORDEMPHASIS,MPVOID,
    1825                                MPFROM2SHORT(FALSE,CRA_SOURCE));
    1826                     dcd->cnremphasized = FALSE;
    1827                   }
    1828                   if(dcd->hwndLastMenu != TreeCnrMenu)
    1829                     MarkAll(hwnd,TRUE,FALSE,TRUE);
    1830                 }
    1831               }
    1832               DosEnterCritSec();
    1833                fFollowTree = wasFollowing;
    1834               DosExitCritSec();
    1835             }
    1836             break;
    1837 
    1838           case CN_ENTER:
    1839             if(mp2)
     1452        switch(SHORT2FROMMP(mp1)) {
     1453          case CN_BEGINEDIT:
     1454          case CN_REALLOCPSZ:
     1455          case CN_ENDEDIT:
    18401456            {
    1841               PCNRITEM pci = (PCNRITEM)((PNOTIFYRECORDENTER)mp2)->pRecord;
    1842 
    1843               PostMsg(hwnd,UM_ENTER,MPFROMP(pci),MPVOID);
    1844             }
    1845             break;
    1846 
    1847           case CN_COLLAPSETREE:
    1848           case CN_EXPANDTREE:
    1849             {
    1850               PCNRITEM pci = (PCNRITEM)mp2;
    1851 
    1852               if(pci && (INT)pci != -1 && !(pci->flags & RECFLAGS_ENV)) {
    1853                 if(driveflags[toupper(*pci->szFileName) - 'A'] &
    1854                    DRIVE_REMOVABLE) {
    1855 
    1856                   struct {
    1857                     ULONG serial;
    1858                     CHAR  volumelength;
    1859                     CHAR  volumelabel[CCHMAXPATH];
    1860                   }         volser;
    1861 
    1862                   memset(&volser,0,sizeof(volser));
    1863                   DosError(FERR_DISABLEHARDERR);
    1864                   if(!DosQueryFSInfo(toupper(*pci->szFileName) - '@',
    1865                                      FSIL_VOLSER,&volser,
    1866                                      (ULONG)sizeof(volser))) {
    1867                     if(SHORT2FROMMP(mp1) == CN_COLLAPSETREE &&
    1868                        !volser.serial ||
    1869                        driveserial[toupper(*pci->szFileName) - 'A'] !=
    1870                          volser.serial)
    1871                       UnFlesh(hwnd,pci);
    1872                     if(SHORT2FROMMP(mp1) != CN_COLLAPSETREE ||
    1873                        (!volser.serial ||
    1874                         driveserial[toupper(*pci->szFileName) - 'A'] !=
    1875                           volser.serial)) {
    1876                       if(Flesh(hwnd,pci) &&
    1877                          SHORT2FROMMP(mp1) == CN_EXPANDTREE &&
    1878                          !dcd->suspendview && fTopDir)
    1879                         PostMsg(hwnd,UM_TOPDIR,MPFROMP(pci),MPVOID);
    1880                     }
    1881                     driveserial[toupper(*pci->szFileName) - 'A'] =
    1882                       volser.serial;
    1883                   }
    1884                   else {
    1885                     driveserial[toupper(*pci->szFileName) - 'A'] = -1;
    1886                     UnFlesh(hwnd,pci);
    1887                     PostMsg(hwnd,UM_RESCAN,MPVOID,MPVOID);
    1888                     DosBeep(250,100);
    1889                   }
    1890                 }
    1891                 else if(SHORT2FROMMP(mp1) == CN_EXPANDTREE) {
    1892                   if(Flesh(hwnd,pci) && !dcd->suspendview && fTopDir)
    1893                     PostMsg(hwnd,UM_TOPDIR,MPFROMP(pci),MPVOID);
    1894                 }
    1895                 if(SHORT2FROMMP(mp1) == CN_EXPANDTREE && !dcd->suspendview)
    1896                   WinSendMsg(hwnd,UM_FILTER,MPVOID,MPVOID);
    1897               }
    1898             }
    1899             break;
    1900         }
     1457              MRESULT mre;
     1458
     1459              mre = CnrDirectEdit(hwnd,
     1460                                  msg,
     1461                                  mp1,
     1462                                  mp2);
     1463              if(mre != (MRESULT)-1)
     1464                return mre;
     1465            }
     1466            break;
     1467
     1468          case CN_DRAGLEAVE:
     1469            if(mp2) {
     1470
     1471              PDRAGINFO pDInfo;
     1472
     1473              pDInfo = ((PCNRDRAGINFO)mp2)->pDragInfo;
     1474              DrgAccessDraginfo(pDInfo);
     1475              DrgFreeDraginfo(pDInfo);
     1476            }
     1477            return 0;
     1478
     1479          case CN_DRAGAFTER:
     1480          case CN_DRAGOVER:
     1481            if(mp2) {
     1482
     1483              PDRAGITEM pDItem;
     1484              PDRAGINFO pDInfo;
     1485              PCNRITEM  pci;
     1486              USHORT    uso;
     1487
     1488              pDInfo = ((PCNRDRAGINFO)mp2)->pDragInfo;
     1489              DrgAccessDraginfo(pDInfo);
     1490              pci = (PCNRITEM)((PCNRDRAGINFO)mp2)->pRecord;
     1491              if((INT)pci == -1)
     1492                pci = NULL;
     1493              if(pci &&
     1494                 (pci->flags & (RECFLAGS_ENV | RECFLAGS_NODROP))) {
     1495                DrgFreeDraginfo(pDInfo);
     1496                return MRFROM2SHORT(DOR_NODROP,0);
     1497              }
     1498              if(!pDInfo) {
     1499                DrgFreeDraginfo(pDInfo);
     1500                return MRFROM2SHORT(DOR_NODROP,0);
     1501              }
     1502              if(!WinIsWindowEnabled(dcd->hwndFrame)) {
     1503                DrgFreeDraginfo(pDInfo);
     1504                return MRFROM2SHORT(DOR_NODROP,0);
     1505              }
     1506              if(pci) {
     1507                uso = pDInfo->usOperation;
     1508                if(uso == DO_DEFAULT)
     1509                  uso = (fCopyDefault) ? DO_COPY : DO_MOVE;
     1510                if(!(pci->attrFile & FILE_DIRECTORY)) {
     1511                  if(uso != DO_LINK &&
     1512                     uso != DO_COPY &&
     1513                     uso != DO_MOVE) {
     1514                    DrgFreeDraginfo(pDInfo);
     1515                    return(MRFROM2SHORT(DOR_NODROP,0));
     1516                  }
     1517                  if(uso != DO_LINK &&
     1518                     !(driveflags[toupper(*pci->szFileName) - 'A'] &
     1519                       DRIVE_NOTWRITEABLE)) {
     1520
     1521                    ARC_TYPE *info;
     1522
     1523                    if(!fQuickArcFind &&
     1524                       !(driveflags[toupper(*pci->szFileName) - 'A'] &
     1525                         DRIVE_SLOW))
     1526                      info = find_type(pci->szFileName,NULL);
     1527                    else
     1528                      info = quick_find_type(pci->szFileName,NULL);
     1529                    if(!info || ((uso == DO_MOVE && !info->move) ||
     1530                       (uso == DO_COPY && !info->create)))  {
     1531                      DrgFreeDraginfo(pDInfo);
     1532                      return(MRFROM2SHORT(DOR_NODROP,0));
     1533                    }
     1534                  }
     1535                }
     1536              }
     1537              pDItem = DrgQueryDragitemPtr(pDInfo,   /* Access DRAGITEM       */
     1538                                           0);       /* Index to DRAGITEM     */
     1539              if(DrgVerifyRMF(pDItem,                /* Check valid rendering */
     1540                              DRM_OS2FILE,           /* mechanisms and data   */
     1541                              NULL) ||
     1542                  DrgVerifyRMF(pDItem,DRM_FM2ARCMEMBER,
     1543                               DRF_FM2ARCHIVE)) {    /* formats               */
     1544                DrgFreeDraginfo(pDInfo);             /* Free DRAGINFO         */
     1545                if(!pci || (INT)pci == -1)
     1546                  return MRFROM2SHORT(DOR_DROP,DO_MOVE);
     1547                if(driveflags[toupper(*pci->szFileName) - 'A'] &
     1548                   DRIVE_NOTWRITEABLE)
     1549                  return MRFROM2SHORT(DOR_DROP,DO_LINK);
     1550                if(toupper(*pci->szFileName) < 'C')
     1551                  return MRFROM2SHORT(DOR_DROP,DO_COPY);
     1552                return MRFROM2SHORT(DOR_DROP,     /* Return okay to drop   */
     1553                                    ((fCopyDefault) ?
     1554                                    DO_COPY :
     1555                                    DO_MOVE));
     1556              }
     1557              DrgFreeDraginfo(pDInfo);            /* Free DRAGINFO         */
     1558            }
     1559            return MRFROM2SHORT(DOR_NODROP,0);    /* Drop not valid        */
     1560
     1561          case CN_INITDRAG:
     1562            {
     1563              PCNRDRAGINIT pcd = (PCNRDRAGINIT)mp2;
     1564              PCNRITEM     pci;
     1565
     1566              if(pcd) {
     1567                pci = (PCNRITEM)pcd->pRecord;
     1568                if(!pci || (INT)pci == -1 ||
     1569                   (pci->flags & (RECFLAGS_ENV | RECFLAGS_NODRAG))) {
     1570                  DosBeep(50,100);
     1571                  break;
     1572                }
     1573                if(hwndStatus2)
     1574                  WinSetWindowText(hwndStatus2,(IsRoot(pci->szFileName)) ?
     1575                                   GetPString(IDS_DRAGROOTTEXT) :
     1576                                   (pci->attrFile & FILE_DIRECTORY) ?
     1577                                   GetPString(IDS_DRAGDIRTEXT) :
     1578                                   GetPString(IDS_DRAGFILETEXT));
     1579                DoFileDrag(hwnd,
     1580                           dcd->hwndObject,
     1581                           mp2,
     1582                           NULL,
     1583                           NULL,
     1584                           TRUE);
     1585                if(hwndStatus2)
     1586                  PostMsg(hwnd,
     1587                          UM_RESCAN,
     1588                          MPVOID,
     1589                          MPVOID);
     1590              }
     1591            }
     1592            return 0;
     1593
     1594          case CN_DROP:
     1595            {
     1596              LISTINFO *li;
     1597              ULONG     action = UM_ACTION;
     1598
     1599              li = DoFileDrop(hwnd,
     1600                              NULL,
     1601                              TRUE,
     1602                              mp1,
     1603                              mp2);
     1604              if(li) {
     1605                if(!*li->targetpath) {
     1606                  if(li->list[0])
     1607                    PMMkDir(dcd->hwndParent,
     1608                            li->list[0],
     1609                            FALSE);
     1610                  FreeListInfo(li);
     1611                  return 0;
     1612                }
     1613                if(li->list &&
     1614                   li->list[0] &&
     1615                   IsRoot(li->list[0]))
     1616                  li->type = DO_LINK;
     1617                else if(fDragndropDlg &&
     1618                        (!*li->arcname || !li->info)) {
     1619
     1620                  CHECKLIST    cl;
     1621
     1622                  memset(&cl,0,sizeof(cl));
     1623                  cl.size = sizeof(cl);
     1624                  cl.flags = li->type;
     1625                  cl.list = li->list;
     1626                  cl.cmd = li->type;
     1627                  cl.prompt = li->targetpath;
     1628                  li->type = WinDlgBox(HWND_DESKTOP,
     1629                                       dcd->hwndParent,
     1630                                       DropListProc,
     1631                                       FM3ModHandle,
     1632                                       DND_FRAME,
     1633                                       MPFROMP(&cl));
     1634                  if(!li->type) {
     1635                    FreeListInfo(li);
     1636                    return 0;
     1637                  }
     1638                  li->list = cl.list;
     1639                  if(!li->list || !li->list[0]) {
     1640                    FreeListInfo(li);
     1641                    return 0;
     1642                  }
     1643                }
     1644                switch(li->type) {
     1645                  case DO_LINK:
     1646                    if(fLinkSetsIcon) {
     1647                      li->type = IDM_SETICON;
     1648                      action = UM_MASSACTION;
     1649                    }
     1650                    else
     1651                      li->type = IDM_COMPARE;
     1652                    break;
     1653                  case DND_EXTRACT:
     1654                    if(*li->targetpath &&
     1655                       !IsFile(li->targetpath))
     1656                      li->type = IDM_EXTRACT;
     1657                    break;
     1658                  case DND_MOVE:
     1659                    li->type = IDM_MOVE;
     1660                    if(*li->targetpath &&
     1661                       IsFile(li->targetpath) == 1) {
     1662                      action = UM_MASSACTION;
     1663                      li->type = IDM_ARCHIVEM;
     1664                    }
     1665                    break;
     1666                  case DND_WILDMOVE:
     1667                    li->type = IDM_WILDMOVE;
     1668                    if(*li->targetpath &&
     1669                       IsFile(li->targetpath) == 1) {
     1670                      action = UM_MASSACTION;
     1671                      li->type = IDM_ARCHIVEM;
     1672                    }
     1673                    break;
     1674                  case DND_OBJECT:
     1675                    li->type = IDM_OBJECT;
     1676                    action = UM_MASSACTION;
     1677                    break;
     1678                  case DND_SHADOW:
     1679                    li->type = IDM_SHADOW;
     1680                    action = UM_MASSACTION;
     1681                    break;
     1682                  case DND_COMPARE:
     1683                    li->type = IDM_COMPARE;
     1684                    break;
     1685                  case DND_SETICON:
     1686                    action = UM_MASSACTION;
     1687                    li->type = IDM_SETICON;
     1688                    break;
     1689                  case DND_COPY:
     1690                    li->type = IDM_COPY;
     1691                    if(*li->targetpath &&
     1692                       IsFile(li->targetpath) == 1) {
     1693                      action = UM_MASSACTION;
     1694                      li->type = IDM_ARCHIVE;
     1695                    }
     1696                    break;
     1697                  case DND_WILDCOPY:
     1698                    li->type = IDM_WILDCOPY;
     1699                    if(*li->targetpath &&
     1700                       IsFile(li->targetpath) == 1) {
     1701                      action = UM_MASSACTION;
     1702                      li->type = IDM_ARCHIVE;
     1703                    }
     1704                    break;
     1705                  default:
     1706                    if(*li->arcname && li->info) {
     1707                      action = UM_MASSACTION;
     1708                      li->type = (li->type == DO_MOVE) ?
     1709                                  IDM_FAKEEXTRACTM :
     1710                                  IDM_FAKEEXTRACT;
     1711                    }
     1712                    else if(*li->targetpath &&
     1713                            IsFile(li->targetpath) == 1) {
     1714                      action = UM_MASSACTION;
     1715                      li->type = (li->type == DO_MOVE) ?
     1716                                  IDM_ARCHIVEM :
     1717                                  IDM_ARCHIVE;
     1718                    }
     1719                    else
     1720                      li->type = (li->type == DO_MOVE) ?
     1721                                  IDM_MOVE :
     1722                                  IDM_COPY;
     1723                    break;
     1724                }
     1725                if(!li->list || !li->list[0])
     1726                  FreeListInfo(li);
     1727                else if(!PostMsg(dcd->hwndObject,
     1728                                 action,
     1729                                 MPFROMP(li),
     1730                                 MPVOID))
     1731                  FreeListInfo(li);
     1732                else {
     1733
     1734                  USHORT usop = 0;
     1735
     1736                  switch(li->type) {
     1737                    case IDM_COPY:
     1738                    case IDM_WILDCOPY:
     1739                      usop = DO_COPY;
     1740                      break;
     1741                    case IDM_MOVE:
     1742                    case IDM_WILDMOVE:
     1743                    case IDM_ARCHIVEM:
     1744                      usop = DO_MOVE;
     1745                      break;
     1746                  }
     1747                  if(usop)
     1748                    return MRFROM2SHORT(DOR_DROP,usop);
     1749                }
     1750              }
     1751            }
     1752            return 0;
     1753
     1754          case CN_EMPHASIS:
     1755            if(!fDummy) {
     1756
     1757              PNOTIFYRECORDEMPHASIS pre = mp2;
     1758
     1759              if(pre->fEmphasisMask & CRA_SELECTED) {
     1760                if(pre->pRecord->flRecordAttr & CRA_SELECTED) {
     1761                  if(((PCNRITEM)(pre->pRecord))->attrFile & FILE_DIRECTORY) {
     1762                    PostMsg(hwnd,
     1763                            UM_RESCAN,
     1764                            MPVOID,
     1765                            MPVOID);
     1766                    if(fFollowTree &&
     1767                       !(driveflags[toupper(*((PCNRITEM)pre->pRecord)->szFileName) - 'A'] &
     1768                         DRIVE_INVALID)) {
     1769                      if(!LastDir &&
     1770                         !ParentIsDesktop(hwnd,dcd->hwndParent))
     1771                        LastDir = FindDirCnr(dcd->hwndParent);
     1772                      if(LastDir) {
     1773
     1774                        NOTIFYRECORDENTER pri;
     1775                        BOOL              tbool = fDCOpens;
     1776
     1777                        fDCOpens = FALSE;
     1778                        memset(&pri,0,sizeof(pri));
     1779                        pri.hwndCnr = hwnd;
     1780                        pri.fKey = FALSE;
     1781                        pri.pRecord = pre->pRecord;
     1782                        WinSendMsg(hwnd,
     1783                                   WM_CONTROL,
     1784                                   MPFROM2SHORT(SHORT1FROMMP(mp1),
     1785                                                CN_ENTER),
     1786                                   MPFROMP(&pri));
     1787                        fDCOpens = tbool;
     1788                      }
     1789                    }
     1790                    if(*(ULONG *)realappname != FM3UL)
     1791                      WinSetWindowText(WinWindowFromID(dcd->hwndFrame,
     1792                                                       MAIN_STATUS),
     1793                                       ((PCNRITEM)(pre->pRecord))->szFileName);
     1794                  }
     1795                }
     1796              }
     1797            }
     1798            break;
     1799
     1800          case CN_CONTEXTMENU:
     1801            {
     1802              PCNRITEM pci = (PCNRITEM)mp2;
     1803              BOOL     wasFollowing;
     1804
     1805              DosEnterCritSec();
     1806               wasFollowing = fFollowTree;
     1807               fFollowTree = FALSE;
     1808              DosExitCritSec();
     1809              if(pci && (INT)pci != -1 && !(pci->flags & RECFLAGS_ENV)) {
     1810                WinSendMsg(hwnd,
     1811                           CM_SETRECORDEMPHASIS,
     1812                           MPFROMP(pci),
     1813                           MPFROM2SHORT(TRUE,CRA_CURSORED));
     1814                MarkAll(hwnd,
     1815                        FALSE,
     1816                        FALSE,
     1817                        TRUE);
     1818                if(!(pci->attrFile & FILE_DIRECTORY))
     1819                  dcd->hwndLastMenu = CheckMenu(&FileMenu,FILE_POPUP);
     1820                else if(!IsRoot(pci->szFileName))
     1821                  dcd->hwndLastMenu = CheckMenu(&DirMenu,DIR_POPUP);
     1822                else
     1823                  dcd->hwndLastMenu = CheckMenu(&TreeMenu,TREE_POPUP);
     1824              }
     1825              else {
     1826                dcd->hwndLastMenu = CheckMenu(&TreeCnrMenu,TREECNR_POPUP);
     1827                if(dcd->hwndLastMenu && !dcd->cnremphasized) {
     1828                  WinSendMsg(hwnd,CM_SETRECORDEMPHASIS,MPVOID,
     1829                             MPFROM2SHORT(TRUE,CRA_SOURCE));
     1830                  dcd->cnremphasized = TRUE;
     1831                }
     1832              }
     1833              if(dcd->hwndLastMenu) {
     1834                if(dcd->hwndLastMenu == DirMenu)
     1835                  WinEnableMenuItem(DirMenu,IDM_TREE,FALSE);
     1836                if(dcd->hwndLastMenu == TreeCnrMenu) {
     1837                  if(dcd->flWindowAttr & CV_MINI)
     1838                    WinCheckMenuItem(dcd->hwndLastMenu,IDM_MINIICONS,TRUE);
     1839                }
     1840                if(!PopupMenu(hwnd,hwnd,dcd->hwndLastMenu)) {
     1841                  if(dcd->cnremphasized) {
     1842                    WinSendMsg(hwnd,CM_SETRECORDEMPHASIS,MPVOID,
     1843                               MPFROM2SHORT(FALSE,CRA_SOURCE));
     1844                    dcd->cnremphasized = FALSE;
     1845                  }
     1846                  if(dcd->hwndLastMenu != TreeCnrMenu)
     1847                    MarkAll(hwnd,TRUE,FALSE,TRUE);
     1848                }
     1849              }
     1850              DosEnterCritSec();
     1851               fFollowTree = wasFollowing;
     1852              DosExitCritSec();
     1853            }
     1854            break;
     1855
     1856          case CN_ENTER:
     1857            if(mp2)
     1858            {
     1859              PCNRITEM pci = (PCNRITEM)((PNOTIFYRECORDENTER)mp2)->pRecord;
     1860
     1861              PostMsg(hwnd,UM_ENTER,MPFROMP(pci),MPVOID);
     1862            }
     1863            break;
     1864
     1865          case CN_COLLAPSETREE:
     1866          case CN_EXPANDTREE:
     1867            {
     1868              PCNRITEM pci = (PCNRITEM)mp2;
     1869
     1870              if(pci && (INT)pci != -1 && !(pci->flags & RECFLAGS_ENV)) {
     1871                if(driveflags[toupper(*pci->szFileName) - 'A'] &
     1872                   DRIVE_REMOVABLE) {
     1873
     1874                  struct {
     1875                    ULONG serial;
     1876                    CHAR  volumelength;
     1877                    CHAR  volumelabel[CCHMAXPATH];
     1878                  }         volser;
     1879
     1880                  memset(&volser,0,sizeof(volser));
     1881                  DosError(FERR_DISABLEHARDERR);
     1882                  if(!DosQueryFSInfo(toupper(*pci->szFileName) - '@',
     1883                                     FSIL_VOLSER,&volser,
     1884                                     (ULONG)sizeof(volser))) {
     1885                    if(SHORT2FROMMP(mp1) == CN_COLLAPSETREE &&
     1886                       !volser.serial ||
     1887                       driveserial[toupper(*pci->szFileName) - 'A'] !=
     1888                         volser.serial)
     1889                      UnFlesh(hwnd,pci);
     1890                    if(SHORT2FROMMP(mp1) != CN_COLLAPSETREE ||
     1891                       (!volser.serial ||
     1892                        driveserial[toupper(*pci->szFileName) - 'A'] !=
     1893                          volser.serial)) {
     1894                      if(Flesh(hwnd,pci) &&
     1895                         SHORT2FROMMP(mp1) == CN_EXPANDTREE &&
     1896                         !dcd->suspendview && fTopDir)
     1897                        PostMsg(hwnd,UM_TOPDIR,MPFROMP(pci),MPVOID);
     1898                    }
     1899                    driveserial[toupper(*pci->szFileName) - 'A'] =
     1900                      volser.serial;
     1901                  }
     1902                  else {
     1903                    driveserial[toupper(*pci->szFileName) - 'A'] = -1;
     1904                    UnFlesh(hwnd,pci);
     1905                    PostMsg(hwnd,UM_RESCAN,MPVOID,MPVOID);
     1906                    DosBeep(250,100);
     1907                  }
     1908                }
     1909                else if(SHORT2FROMMP(mp1) == CN_EXPANDTREE) {
     1910                  if(Flesh(hwnd,pci) && !dcd->suspendview && fTopDir)
     1911                    PostMsg(hwnd,UM_TOPDIR,MPFROMP(pci),MPVOID);
     1912                }
     1913                if(SHORT2FROMMP(mp1) == CN_EXPANDTREE && !dcd->suspendview)
     1914                  WinSendMsg(hwnd,UM_FILTER,MPVOID,MPVOID);
     1915              }
     1916            }
     1917            break;
     1918        }
    19011919      }
    19021920      return 0;
    … …  
    19051923      if(mp1) {
    19061924
    1907         LISTINFO *li = mp1;
    1908         ULONG     action = (ULONG)mp2;
    1909 
    1910         if(!li->list || !li->list[0] ||
    1911            !PostMsg(dcd->hwndObject,
    1912                     action,
    1913                     MPFROMP(li),
    1914                     MPVOID))
    1915           FreeListInfo(li);
     1925        LISTINFO *li = mp1;
     1926        ULONG     action = (ULONG)mp2;
     1927
     1928        if(!li->list || !li->list[0] ||
     1929           !PostMsg(dcd->hwndObject,
     1930                    action,
     1931                    MPFROMP(li),
     1932                    MPVOID))
     1933          FreeListInfo(li);
    19161934      }
    19171935      return 0;
    … …  
    19201938      if(mp1 && dcd) {
    19211939
    1922         CHAR *dir;
    1923 
    1924         dir = strdup((CHAR *)mp1);
    1925         if(dir) {
    1926           if(!PostMsg(dcd->hwndObject,
    1927                       UM_SHOWME,
    1928                       MPFROMP(dir),
    1929                       MPVOID))
    1930             free(dir);
    1931         }
     1940        CHAR *dir;
     1941
     1942        dir = strdup((CHAR *)mp1);
     1943        if(dir) {
     1944          if(!PostMsg(dcd->hwndObject,
     1945                      UM_SHOWME,
     1946                      MPFROMP(dir),
     1947                      MPVOID))
     1948            free(dir);
     1949        }
    19321950      }
    19331951      return 0;
    … …  
    19361954      if(mp1) {
    19371955
    1938         PCNRITEM pci = (PCNRITEM)mp1;
    1939 
    1940         ShowCnrRecord(hwnd,
    1941                       (PMINIRECORDCORE)pci);
     1956        PCNRITEM pci = (PCNRITEM)mp1;
     1957
     1958        ShowCnrRecord(hwnd,
     1959                      (PMINIRECORDCORE)pci);
    19421960      }
    19431961      return 0;
    … …  
    19451963    case UM_ENTER:
    19461964      {
    1947         FILEFINDBUF3 ffb;
    1948         HDIR         hDir = HDIR_CREATE;
    1949         ULONG        nm = 1L;
    1950         APIRET       status;
    1951         BOOL         IsOk = FALSE;
    1952         ULONG        ulDriveNum,ulDriveMap;
    1953         PCNRITEM     pciP,pciL,pci;
    1954         ULONG        fl = SWP_ACTIVATE;
    1955 
    1956         if(fFollowTree)
    1957           fl = 0;
    1958         SetShiftState();
    1959         pci = (PCNRITEM)mp1;
    1960         if(pci &&
    1961            (INT)pci != -1 &&
    1962            !(pci->rc.flRecordAttr & CRA_INUSE) &&
    1963            !(pci->flags & RECFLAGS_ENV) &&
    1964            IsFullName(pci->szFileName)) {
    1965           if(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_INVALID) {
    1966             DosBeep(50,100);
    1967             if(hwndStatus)
    1968               WinSetWindowText(hwndStatus,
    1969                                GetPString(IDS_RESCANSUGTEXT));
    1970             return 0;
    1971           }
    1972           DosError(FERR_DISABLEHARDERR);
    1973           if(!DosQCurDisk(&ulDriveNum,&ulDriveMap)) {
    1974             if(!(ulDriveMap & 1L << (toupper(*pci->szFileName) - 'A'))) {
    1975               pciL = pciP = pci;
    1976               for(;;) {
    1977                 pciP = WinSendMsg(hwnd,
    1978                                   CM_QUERYRECORD,
    1979                                   MPFROMP(pciL),
    1980                                   MPFROM2SHORT(CMA_PARENT,CMA_ITEMORDER));
    1981                 if(pciP && (INT)pciP != -1)
    1982                   pciL = pciP;
    1983                 else {
    1984                   pciP = pciL;
    1985                   break;
    1986                 }
    1987               }
    1988               WinSendMsg(hwnd,
    1989                         CM_REMOVERECORD,
    1990                         MPFROMP(&pciP),
    1991                         MPFROM2SHORT(1,CMA_FREE | CMA_INVALIDATE));
    1992               return 0;
    1993             }
    1994           }
    1995           if(driveflags[toupper(*pci->szFileName) - 'A'] &
    1996              (DRIVE_REMOVABLE | DRIVE_NOPRESCAN)) {
    1997 
    1998             struct {
    1999               ULONG serial;
    2000               CHAR  volumelength;
    2001               CHAR  volumelabel[CCHMAXPATH];
    2002             } volser;
    2003 
    2004             pciL = pciP = pci;
    2005             for(;;) {
    2006               pciP = WinSendMsg(hwnd,
    2007                                 CM_QUERYRECORD,
    2008                                 MPFROMP(pciL),
    2009                                 MPFROM2SHORT(CMA_PARENT,CMA_ITEMORDER));
    2010               if(pciP && (INT)pciP != -1)
    2011                 pciL = pciP;
    2012               else {
    2013                 pciP = pciL;
    2014                 break;
    2015               }
    2016             }
    2017             if((driveflags[toupper(*pci->szFileName) - 'A'] &
    2018                DRIVE_NOPRESCAN) ||
    2019                (toupper(*pci->szFileName) > 'B' &&
    2020                 !(driveflags[toupper(*pci->szFileName) - 'A'] &
    2021                   DRIVE_CDROM))) {
    2022 
    2023               INT      removable,
    2024                        x = (INT)(toupper(*pci->szFileName) - 'A');
    2025               ULONG    drvtype;
    2026               CHAR     FileSystem[CCHMAXPATH];
    2027 
    2028               DosError(FERR_DISABLEHARDERR);
    2029               removable = CheckDrive(toupper(*pciP->szFileName),
    2030                                      FileSystem,
    2031                                      &drvtype);
    2032               if(removable != -1) {
    2033                 driveflags[x] &= (DRIVE_IGNORE      | DRIVE_NOPRESCAN |
    2034                                   DRIVE_NOLOADICONS | DRIVE_NOLOADSUBJS |
    2035                                   DRIVE_NOLOADLONGS | DRIVE_INCLUDEFILES |
    2036                                   DRIVE_SLOW);
    2037                 if(removable == 1)
    2038                   driveflags[x] |= DRIVE_REMOVABLE;
    2039                 if(drvtype & DRIVE_REMOTE)
    2040                   driveflags[x] |= DRIVE_REMOTE;
    2041                 if(!strcmp(FileSystem,CDFS))
    2042                   driveflags[x] |= (DRIVE_REMOVABLE |
    2043                                     DRIVE_NOTWRITEABLE |
    2044                                     DRIVE_CDROM);
    2045                 if (strcmp(FileSystem,HPFS) &&
     1965        FILEFINDBUF3 ffb;
     1966        HDIR         hDir = HDIR_CREATE;
     1967        ULONG        nm = 1L;
     1968        APIRET       status;
     1969        BOOL         IsOk = FALSE;
     1970        ULONG        ulDriveNum,ulDriveMap;
     1971        PCNRITEM     pciP,pciL,pci;
     1972        ULONG        fl = SWP_ACTIVATE;
     1973
     1974        if(fFollowTree)
     1975          fl = 0;
     1976        SetShiftState();
     1977        pci = (PCNRITEM)mp1;
     1978        if(pci &&
     1979           (INT)pci != -1 &&
     1980           !(pci->rc.flRecordAttr & CRA_INUSE) &&
     1981           !(pci->flags & RECFLAGS_ENV) &&
     1982           IsFullName(pci->szFileName)) {
     1983          if(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_INVALID) {
     1984            DosBeep(50,100);
     1985            if(hwndStatus)
     1986              WinSetWindowText(hwndStatus,
     1987                               GetPString(IDS_RESCANSUGTEXT));
     1988            return 0;
     1989          }
     1990          DosError(FERR_DISABLEHARDERR);
     1991          if(!DosQCurDisk(&ulDriveNum,&ulDriveMap)) {
     1992            if(!(ulDriveMap & 1L << (toupper(*pci->szFileName) - 'A'))) {
     1993              pciL = pciP = pci;
     1994              for(;;) {
     1995                pciP = WinSendMsg(hwnd,
     1996                                  CM_QUERYRECORD,
     1997                                  MPFROMP(pciL),
     1998                                  MPFROM2SHORT(CMA_PARENT,CMA_ITEMORDER));
     1999                if(pciP && (INT)pciP != -1)
     2000                  pciL = pciP;
     2001                else {
     2002                  pciP = pciL;
     2003                  break;
     2004                }
     2005              }
     2006              WinSendMsg(hwnd,
     2007                        CM_REMOVERECORD,
     2008                        MPFROMP(&pciP),
     2009                        MPFROM2SHORT(1,CMA_FREE | CMA_INVALIDATE));
     2010              return 0;
     2011            }
     2012          }
     2013          if(driveflags[toupper(*pci->szFileName) - 'A'] &
     2014             (DRIVE_REMOVABLE | DRIVE_NOPRESCAN)) {
     2015
     2016            struct {
     2017              ULONG serial;
     2018              CHAR  volumelength;
     2019              CHAR  volumelabel[CCHMAXPATH];
     2020            } volser;
     2021
     2022            pciL = pciP = pci;
     2023            for(;;) {
     2024              pciP = WinSendMsg(hwnd,
     2025                                CM_QUERYRECORD,
     2026                                MPFROMP(pciL),
     2027                                MPFROM2SHORT(CMA_PARENT,CMA_ITEMORDER));
     2028              if(pciP && (INT)pciP != -1)
     2029                pciL = pciP;
     2030              else {
     2031                pciP = pciL;
     2032                break;
     2033              }
     2034            }
     2035            if((driveflags[toupper(*pci->szFileName) - 'A'] &
     2036               DRIVE_NOPRESCAN) ||
     2037               (toupper(*pci->szFileName) > 'B' &&
     2038                !(driveflags[toupper(*pci->szFileName) - 'A'] &
     2039                  DRIVE_CDROM))) {
     2040
     2041              INT      removable,
     2042                       x = (INT)(toupper(*pci->szFileName) - 'A');
     2043              ULONG    drvtype;
     2044              CHAR     FileSystem[CCHMAXPATH];
     2045
     2046              DosError(FERR_DISABLEHARDERR);
     2047              removable = CheckDrive(toupper(*pciP->szFileName),
     2048                                     FileSystem,
     2049                                     &drvtype);
     2050              if(removable != -1) {
     2051                driveflags[x] &= (DRIVE_IGNORE      | DRIVE_NOPRESCAN |
     2052                                  DRIVE_NOLOADICONS | DRIVE_NOLOADSUBJS |
     2053                                  DRIVE_NOLOADLONGS | DRIVE_INCLUDEFILES |
     2054                                  DRIVE_SLOW);
     2055                if(removable == 1)
     2056                  driveflags[x] |= DRIVE_REMOVABLE;
     2057                if(drvtype & DRIVE_REMOTE)
     2058                  driveflags[x] |= DRIVE_REMOTE;
     2059                if(!strcmp(FileSystem,CDFS))
     2060                  driveflags[x] |= (DRIVE_REMOVABLE |
     2061                                    DRIVE_NOTWRITEABLE |
     2062                                    DRIVE_CDROM);
     2063                if (strcmp(FileSystem,HPFS) &&
    20462064                    strcmp(FileSystem,JFS) &&
    20472065                    strcmp(FileSystem,CDFS) &&
    20482066                    strcmp(FileSystem,FAT32) &&
    2049                     strcmp(FileSystem,HPFS386))
     2067                    strcmp(FileSystem,HPFS386))
    20502068                {
    2051                   driveflags[x] |= DRIVE_NOLONGNAMES;
     2069                  driveflags[x] |= DRIVE_NOLONGNAMES;
    20522070                }
    2053                 if(!strcmp(FileSystem,CBSIFS)) {
    2054                   driveflags[x] |= DRIVE_ZIPSTREAM;
    2055                   driveflags[x] &= (~DRIVE_REMOTE);
    2056                 }
    2057                 if(driveflags[x] & DRIVE_CDROM)
    2058                   pciP->rc.hptrIcon = hptrCDROM;
    2059                 else
    2060                   pciP->rc.hptrIcon = (driveflags[x] & DRIVE_REMOVABLE) ?
    2061                                        hptrRemovable :
    2062                                        (driveflags[x] & DRIVE_REMOTE) ?
    2063                                        hptrRemote : hptrDrive;
    2064                 WinSendMsg(hwnd,
    2065                            CM_INVALIDATERECORD,
    2066                            MPFROMP(&pciP),
    2067                            MPFROM2SHORT(1,CMA_ERASE | CMA_REPOSITION));
    2068                 if(hwndMain)
    2069                   PostMsg(hwndMain,
    2070                           UM_BUILDDRIVES,
    2071                           MPVOID,
    2072                           MPVOID);
    2073               }
    2074             }
    2075             memset(&volser,0,sizeof(volser));
    2076             DosError(FERR_DISABLEHARDERR);
    2077             status = DosQueryFSInfo(toupper(*pci->szFileName) - '@',
    2078                                     FSIL_VOLSER,&volser,
    2079                                     (ULONG)sizeof(volser));
    2080             if(!status) {
    2081               if(!volser.serial ||
    2082                 driveserial[toupper(*pci->szFileName) - 'A'] !=
    2083                    volser.serial) {
    2084                 UnFlesh(hwnd,pciP);
    2085                 Flesh(hwnd,pciP);
    2086                 driveserial[toupper(*pci->szFileName) - 'A'] =
    2087                   volser.serial;
    2088               }
    2089               pciL = WinSendMsg(hwnd,
    2090                                 CM_QUERYRECORD,
    2091                                 MPFROMP(pciP),
    2092                                 MPFROM2SHORT(CMA_FIRSTCHILD,
    2093                                              CMA_ITEMORDER));
    2094               if(!pciL)
    2095                 Flesh(hwnd,pciP);
    2096             }
    2097             else {
    2098               driveserial[toupper(*pci->szFileName) - 'A'] = -1;
    2099               UnFlesh(hwnd,
    2100                       pci);
    2101               PostMsg(hwnd,
    2102                       UM_RESCAN,
    2103                       MPVOID,
    2104                       MPVOID);
    2105               PostMsg(hwnd,
    2106                       UM_SETUP2,
    2107                       MPFROMP(pci),
    2108                       MPFROMLONG(status));
    2109               return 0;
    2110             }
    2111           }
    2112           status = 0;
    2113           IsOk = (IsRoot(pci->szFileName) &&
    2114                   IsValidDrive(toupper(*pci->szFileName)));
    2115           if(!IsOk) {
    2116             DosError(FERR_DISABLEHARDERR);
    2117             status = DosFindFirst(pci->szFileName,&hDir,
    2118                                   FILE_NORMAL   | FILE_DIRECTORY |
    2119                                   FILE_ARCHIVED | FILE_READONLY  |
    2120                                   FILE_HIDDEN   | FILE_SYSTEM,
    2121                                   &ffb,sizeof(ffb),&nm,
    2122                                   FIL_STANDARD);
    2123             priority_bumped();
    2124           }
    2125           if(!status) {
    2126             if(!IsOk)
    2127               DosFindClose(hDir);
    2128             if(IsOk ||
    2129                (ffb.attrFile & FILE_DIRECTORY)) {
    2130               if((shiftstate & (KC_CTRL | KC_ALT)) ==
    2131                 (KC_CTRL | KC_ALT)) {
    2132                 PostMsg(hwnd,
    2133                         WM_COMMAND,
    2134                         MPFROM2SHORT(IDM_SHOWALLFILES,0),
    2135                         MPVOID);
    2136                 return 0;
    2137               }
    2138               if((shiftstate & (KC_CTRL | KC_SHIFT)) ==
    2139                 (KC_CTRL | KC_SHIFT)) {
    2140                 OpenObject(pci->szFileName,
    2141                            Settings,
    2142                            dcd->hwndFrame);
    2143                 return 0;
    2144               }
    2145               if(!(shiftstate & (KC_CTRL | KC_SHIFT))) {
    2146                 if(!ParentIsDesktop(hwnd,dcd->hwndParent)) {
    2147                   if(FindDirCnrByName(pci->szFileName,
    2148                                       TRUE))
    2149                     return 0;
    2150                 }
    2151               }
    2152               if((shiftstate & KC_CTRL) ||
    2153                 (!(shiftstate & KC_SHIFT) &&
    2154                   ParentIsDesktop(hwnd,dcd->hwndParent) &&
    2155                   fVTreeOpensWPS)) {
    2156 
    2157                 ULONG size = sizeof(ULONG),flWindowAttr = CV_ICON;
    2158                 CHAR  s[33];
    2159 
    2160                 strcpy(s,"ICON");
    2161                 PrfQueryProfileData(fmprof,
    2162                                     appname,
    2163                                     "DirflWindowAttr",
    2164                                     (PVOID)&flWindowAttr,
    2165                                     &size);
    2166                 if(flWindowAttr & CV_DETAIL) {
    2167                   if(IsRoot(pci->szFileName))
    2168                     strcpy(s,"TREE");
    2169                   else
    2170                     strcpy(s,"DETAILS");
    2171                 }
    2172                 OpenObject(pci->szFileName,
    2173                            s,
    2174                            dcd->hwndFrame);
    2175                 return 0;
    2176               }
    2177               if(!ParentIsDesktop(hwnd,dcd->hwndParent) &&
    2178                 !fDCOpens &&
    2179                 !LastDir &&
    2180                 !(shiftstate & KC_SHIFT))
    2181                 LastDir = FindDirCnr(dcd->hwndParent);
    2182               if(LastDir &&
    2183                 !fDCOpens &&
    2184                 !(shiftstate & KC_SHIFT)) {
    2185                 WinSendMsg(LastDir,
    2186                            UM_SETDIR,
    2187                            MPFROMP(pci->szFileName),
    2188                            MPVOID);
    2189                 WinSetWindowPos(WinQueryWindow(WinQueryWindow(LastDir,
    2190                                                               QW_PARENT),
    2191                                                QW_PARENT),
    2192                                 HWND_TOP,
    2193                                 0,
    2194                                 0,
    2195                                 0,
    2196                                 0,
    2197                                 SWP_ZORDER | fl);
    2198               }
    2199               else
    2200                 OpenDirCnr(hwnd,
    2201                            dcd->hwndParent,
    2202                            dcd->hwndFrame,
    2203                            FALSE,
    2204                            pci->szFileName);
    2205             }
    2206             else {
    2207               if(!(driveflags[toupper(*pci->szFileName) - 'A'] &
    2208                    DRIVE_INCLUDEFILES))
    2209                 WinSendMsg(hwnd,
    2210                            CM_REMOVERECORD,
    2211                            MPFROMP(&pci),
    2212                            MPFROM2SHORT(1,CMA_FREE | CMA_INVALIDATE));
    2213               else {
    2214 
    2215                 SWP swp;
    2216 
    2217                 WinQueryWindowPos(dcd->hwndFrame,&swp);
    2218                 DefaultViewKeys(hwnd,
    2219                                 dcd->hwndFrame,
    2220                                 dcd->hwndParent,
    2221                                 &swp,
    2222                                 pci->szFileName);
    2223               }
    2224             }
    2225           }
    2226           else {
    2227             if(!IsRoot(pci->szFileName)) {
    2228               NotifyError(pci->szFileName,status);
    2229               WinSendMsg(hwnd,
    2230                         CM_REMOVERECORD,
    2231                         MPFROMP(&pci),
    2232                         MPFROM2SHORT(1,CMA_FREE | CMA_INVALIDATE));
    2233             }
    2234           }
    2235         }
    2236         else if(!pci)
    2237           PostMsg(hwnd,
    2238                   WM_COMMAND,
    2239                   MPFROM2SHORT(IDM_MKDIR,0),
    2240                   MPVOID);
    2241         if(fFollowTree)
    2242           WinSetFocus(HWND_DESKTOP,hwnd);
     2071                if(!strcmp(FileSystem,CBSIFS)) {
     2072                  driveflags[x] |= DRIVE_ZIPSTREAM;
     2073                  driveflags[x] &= (~DRIVE_REMOTE);
     2074                }
     2075                if(driveflags[x] & DRIVE_CDROM)
     2076                  pciP->rc.hptrIcon = hptrCDROM;
     2077                else
     2078                  pciP->rc.hptrIcon = (driveflags[x] & DRIVE_REMOVABLE) ?
     2079                                       hptrRemovable :
     2080                                       (driveflags[x] & DRIVE_REMOTE) ?
     2081                                       hptrRemote : hptrDrive;
     2082                WinSendMsg(hwnd,
     2083                           CM_INVALIDATERECORD,
     2084                           MPFROMP(&pciP),
     2085                           MPFROM2SHORT(1,CMA_ERASE | CMA_REPOSITION));
     2086                if(hwndMain)
     2087                  PostMsg(hwndMain,
     2088                          UM_BUILDDRIVES,
     2089                          MPVOID,
     2090                          MPVOID);
     2091              }
     2092            }
     2093            memset(&volser,0,sizeof(volser));
     2094            DosError(FERR_DISABLEHARDERR);
     2095            status = DosQueryFSInfo(toupper(*pci->szFileName) - '@',
     2096                                    FSIL_VOLSER,&volser,
     2097                                    (ULONG)sizeof(volser));
     2098            if(!status) {
     2099              if(!volser.serial ||
     2100                driveserial[toupper(*pci->szFileName) - 'A'] !=
     2101                   volser.serial) {
     2102                UnFlesh(hwnd,pciP);
     2103                Flesh(hwnd,pciP);
     2104                driveserial[toupper(*pci->szFileName) - 'A'] =
     2105                  volser.serial;
     2106              }
     2107              pciL = WinSendMsg(hwnd,
     2108                                CM_QUERYRECORD,
     2109                                MPFROMP(pciP),
     2110                                MPFROM2SHORT(CMA_FIRSTCHILD,
     2111                                             CMA_ITEMORDER));
     2112              if(!pciL)
     2113                Flesh(hwnd,pciP);
     2114            }
     2115            else {
     2116              driveserial[toupper(*pci->szFileName) - 'A'] = -1;
     2117              UnFlesh(hwnd,
     2118                      pci);
     2119              PostMsg(hwnd,
     2120                      UM_RESCAN,
     2121                      MPVOID,
     2122                      MPVOID);
     2123              PostMsg(hwnd,
     2124                      UM_SETUP2,
     2125                      MPFROMP(pci),
     2126                      MPFROMLONG(status));
     2127              return 0;
     2128            }
     2129          }
     2130          status = 0;
     2131          IsOk = (IsRoot(pci->szFileName) &&
     2132                  IsValidDrive(toupper(*pci->szFileName)));
     2133          if(!IsOk) {
     2134            DosError(FERR_DISABLEHARDERR);
     2135            status = DosFindFirst(pci->szFileName,&hDir,
     2136                                  FILE_NORMAL   | FILE_DIRECTORY |
     2137                                  FILE_ARCHIVED | FILE_READONLY  |
     2138                                  FILE_HIDDEN   | FILE_SYSTEM,
     2139                                  &ffb,sizeof(ffb),&nm,
     2140                                  FIL_STANDARD);
     2141            priority_bumped();
     2142          }
     2143          if(!status) {
     2144            if(!IsOk)
     2145              DosFindClose(hDir);
     2146            if(IsOk ||
     2147               (ffb.attrFile & FILE_DIRECTORY)) {
     2148              if((shiftstate & (KC_CTRL | KC_ALT)) ==
     2149                (KC_CTRL | KC_ALT)) {
     2150                PostMsg(hwnd,
     2151                        WM_COMMAND,
     2152                        MPFROM2SHORT(IDM_SHOWALLFILES,0),
     2153                        MPVOID);
     2154                return 0;
     2155              }
     2156              if((shiftstate & (KC_CTRL | KC_SHIFT)) ==
     2157                (KC_CTRL | KC_SHIFT)) {
     2158                OpenObject(pci->szFileName,
     2159                           Settings,
     2160                           dcd->hwndFrame);
     2161                return 0;
     2162              }
     2163              if(!(shiftstate & (KC_CTRL | KC_SHIFT))) {
     2164                if(!ParentIsDesktop(hwnd,dcd->hwndParent)) {
     2165                  if(FindDirCnrByName(pci->szFileName,
     2166                                      TRUE))
     2167                    return 0;
     2168                }
     2169              }
     2170              if((shiftstate & KC_CTRL) ||
     2171                (!(shiftstate & KC_SHIFT) &&
     2172                  ParentIsDesktop(hwnd,dcd->hwndParent) &&
     2173                  fVTreeOpensWPS)) {
     2174
     2175                ULONG size = sizeof(ULONG),flWindowAttr = CV_ICON;
     2176                CHAR  s[33];
     2177
     2178                strcpy(s,"ICON");
     2179                PrfQueryProfileData(fmprof,
     2180                                    appname,
     2181                                    "DirflWindowAttr",
     2182                                    (PVOID)&flWindowAttr,
     2183                                    &size);
     2184                if(flWindowAttr & CV_DETAIL) {
     2185                  if(IsRoot(pci->szFileName))
     2186                    strcpy(s,"TREE");
     2187                  else
     2188                    strcpy(s,"DETAILS");
     2189                }
     2190                OpenObject(pci->szFileName,
     2191                           s,
     2192                           dcd->hwndFrame);
     2193                return 0;
     2194              }
     2195              if(!ParentIsDesktop(hwnd,dcd->hwndParent) &&
     2196                !fDCOpens &&
     2197                !LastDir &&
     2198                !(shiftstate & KC_SHIFT))
     2199                LastDir = FindDirCnr(dcd->hwndParent);
     2200              if(LastDir &&
     2201                !fDCOpens &&
     2202                !(shiftstate & KC_SHIFT)) {
     2203                WinSendMsg(LastDir,
     2204                           UM_SETDIR,
     2205                           MPFROMP(pci->szFileName),
     2206                           MPVOID);
     2207                WinSetWindowPos(WinQueryWindow(WinQueryWindow(LastDir,
     2208                                                              QW_PARENT),
     2209                                               QW_PARENT),
     2210                                HWND_TOP,
     2211                                0,
     2212                                0,
     2213                                0,
     2214                                0,
     2215                                SWP_ZORDER | fl);
     2216              }
     2217              else
     2218                OpenDirCnr(hwnd,
     2219                           dcd->hwndParent,
     2220                           dcd->hwndFrame,
     2221                           FALSE,
     2222                           pci->szFileName);
     2223            }
     2224            else {
     2225              if(!(driveflags[toupper(*pci->szFileName) - 'A'] &
     2226                   DRIVE_INCLUDEFILES))
     2227                WinSendMsg(hwnd,
     2228                           CM_REMOVERECORD,
     2229                           MPFROMP(&pci),
     2230                           MPFROM2SHORT(1,CMA_FREE | CMA_INVALIDATE));
     2231              else {
     2232
     2233                SWP swp;
     2234
     2235                WinQueryWindowPos(dcd->hwndFrame,&swp);
     2236                DefaultViewKeys(hwnd,
     2237                                dcd->hwndFrame,
     2238                                dcd->hwndParent,
     2239                                &swp,
     2240                                pci->szFileName);
     2241              }
     2242            }
     2243          }
     2244          else {
     2245            if(!IsRoot(pci->szFileName)) {
     2246              NotifyError(pci->szFileName,status);
     2247              WinSendMsg(hwnd,
     2248                        CM_REMOVERECORD,
     2249                        MPFROMP(&pci),
     2250                        MPFROM2SHORT(1,CMA_FREE | CMA_INVALIDATE));
     2251            }
     2252          }
     2253        }
     2254        else if(!pci)
     2255          PostMsg(hwnd,
     2256                  WM_COMMAND,
     2257                  MPFROM2SHORT(IDM_MKDIR,0),
     2258                  MPVOID);
     2259        if(fFollowTree)
     2260          WinSetFocus(HWND_DESKTOP,hwnd);
    22432261      }
    22442262      return 0;
    … …  
    22472265      if(dcd) {
    22482266
    2249         HWND hwndMenu = (HWND)mp2;
    2250 
    2251         if(hwndMenu == TreeCnrMenu || hwndMenu == TreeMenu ||
    2252            hwndMenu == DirMenu) {
    2253           MarkAll(hwnd,TRUE,FALSE,TRUE);
    2254           if(dcd->cnremphasized) {
    2255             WinSendMsg(hwnd,
    2256                        CM_SETRECORDEMPHASIS,
    2257                        MPVOID,
    2258                        MPFROM2SHORT(FALSE,CRA_SOURCE));
    2259             dcd->cnremphasized = FALSE;
    2260           }
    2261         }
     2267        HWND hwndMenu = (HWND)mp2;
     2268
     2269        if(hwndMenu == TreeCnrMenu || hwndMenu == TreeMenu ||
     2270           hwndMenu == DirMenu) {
     2271          MarkAll(hwnd,TRUE,FALSE,TRUE);
     2272          if(dcd->cnremphasized) {
     2273            WinSendMsg(hwnd,
     2274                       CM_SETRECORDEMPHASIS,
     2275                       MPVOID,
     2276                       MPFROM2SHORT(FALSE,CRA_SOURCE));
     2277            dcd->cnremphasized = FALSE;
     2278          }
     2279        }
    22622280      }
    22632281      break;
    … …  
    22652283    case UM_OPENWINDOWFORME:
    22662284      if(dcd) {
    2267         if(mp1 &&
    2268            !IsFile((CHAR *)mp1))
    2269           OpenDirCnr(hwnd,
    2270                      dcd->hwndParent,
    2271                      dcd->hwndFrame,
    2272                      FALSE,
    2273                      (char *)mp1);
     2285        if(mp1 &&
     2286           !IsFile((CHAR *)mp1))
     2287          OpenDirCnr(hwnd,
     2288                     dcd->hwndParent,
     2289                     dcd->hwndFrame,
     2290                     FALSE,
     2291                     (char *)mp1);
    22742292      }
    22752293      return 0;
    … …  
    22772295    case MM_PORTHOLEINIT:
    22782296      if(dcd) {
    2279         switch(SHORT1FROMMP(mp1)) {
    2280           case 0:
    2281           case 1:
    2282             {
    2283               ULONG wmsg;
    2284 
    2285               wmsg = ((SHORT1FROMMP(mp1) == 0) ?
    2286                        UM_FILESMENU :
    2287                        UM_VIEWSMENU);
    2288               PortholeInit((HWND)WinSendMsg(dcd->hwndClient,
    2289                                             wmsg,
    2290                                             MPVOID,
    2291                                             MPVOID),
    2292                            mp1,
    2293                            mp2);
    2294             }
    2295             break;
    2296         }
     2297        switch(SHORT1FROMMP(mp1)) {
     2298          case 0:
     2299          case 1:
     2300            {
     2301              ULONG wmsg;
     2302
     2303              wmsg = ((SHORT1FROMMP(mp1) == 0) ?
     2304                       UM_FILESMENU :
     2305                       UM_VIEWSMENU);
     2306              PortholeInit((HWND)WinSendMsg(dcd->hwndClient,
     2307                                            wmsg,
     2308                                            MPVOID,
     2309                                            MPVOID),
     2310                           mp1,
     2311                           mp2);
     2312            }
     2313            break;
     2314        }
    22972315      }
    22982316      break;
    … …  
    23012319    case WM_INITMENU:
    23022320      if(dcd) {
    2303         switch(SHORT1FROMMP(mp1)) {
    2304           case IDM_FILESMENU:
    2305             {
    2306               PCNRITEM pci;
    2307 
    2308               pci = (PCNRITEM)CurrentRecord(hwnd);
    2309               if(pci && (INT)pci != -1) {
    2310                 WinEnableMenuItem((HWND)mp2,
    2311                                   IDM_UPDATE,
    2312                                   (pci->flags & RECFLAGS_UNDERENV) == 0);
    2313                 WinEnableMenuItem((HWND)mp2,
    2314                                   IDM_EXPANDSUBMENU,
    2315                                   (pci->flags & RECFLAGS_UNDERENV) == 0);
    2316                 WinEnableMenuItem((HWND)mp2,
    2317                                   IDM_EXPAND,
    2318                                   (pci->flags & RECFLAGS_UNDERENV) == 0);
    2319                 WinEnableMenuItem((HWND)mp2,
    2320                                   IDM_COLLAPSE,
    2321                                   (pci->flags & RECFLAGS_UNDERENV) == 0);
    2322                 WinEnableMenuItem((HWND)mp2,
    2323                                   IDM_DELETE,
    2324                                   ((pci->flags & RECFLAGS_UNDERENV) == 0) &&
    2325                                   (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOTWRITEABLE) == 0);
    2326                 WinEnableMenuItem((HWND)mp2,
    2327                                   IDM_PERMDELETE,
    2328                                   ((pci->flags & RECFLAGS_UNDERENV) == 0) &&
    2329                                   (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOTWRITEABLE) == 0);
    2330                 WinEnableMenuItem((HWND)mp2,
    2331                                   IDM_DELETESUBMENU,
    2332                                   ((pci->flags & RECFLAGS_UNDERENV) == 0) &&
    2333                                   (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOTWRITEABLE) == 0);
    2334                 WinEnableMenuItem((HWND)mp2,
    2335                                   IDM_MOVEMENU,
    2336                                   ((pci->flags & RECFLAGS_UNDERENV) == 0) &&
    2337                                   (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOTWRITEABLE) == 0);
    2338                 WinEnableMenuItem((HWND)mp2,
    2339                                   IDM_RENAME,
    2340                                   ((pci->flags & RECFLAGS_UNDERENV) == 0) &&
    2341                                   (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOTWRITEABLE) == 0);
    2342                 WinEnableMenuItem((HWND)mp2,
    2343                                   IDM_DETACH,
    2344                                   (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_REMOTE) != 0);
    2345                 WinEnableMenuItem((HWND)mp2,
    2346                                   IDM_EJECT,
    2347                                   (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_REMOVABLE) != 0);
     2321        switch(SHORT1FROMMP(mp1)) {
     2322          case IDM_FILESMENU:
     2323            {
     2324              PCNRITEM pci;
     2325
     2326              pci = (PCNRITEM)CurrentRecord(hwnd);
     2327              if(pci && (INT)pci != -1) {
     2328                WinEnableMenuItem((HWND)mp2,
     2329                                  IDM_UPDATE,
     2330                                  (pci->flags & RECFLAGS_UNDERENV) == 0);
     2331                WinEnableMenuItem((HWND)mp2,
     2332                                  IDM_EXPANDSUBMENU,
     2333                                  (pci->flags & RECFLAGS_UNDERENV) == 0);
     2334                WinEnableMenuItem((HWND)mp2,
     2335                                  IDM_EXPAND,
     2336                                  (pci->flags & RECFLAGS_UNDERENV) == 0);
     2337                WinEnableMenuItem((HWND)mp2,
     2338                                  IDM_COLLAPSE,
     2339                                  (pci->flags & RECFLAGS_UNDERENV) == 0);
     2340                WinEnableMenuItem((HWND)mp2,
     2341                                  IDM_DELETE,
     2342                                  ((pci->flags & RECFLAGS_UNDERENV) == 0) &&
     2343                                  (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOTWRITEABLE) == 0);
     2344                WinEnableMenuItem((HWND)mp2,
     2345                                  IDM_PERMDELETE,
     2346                                  ((pci->flags & RECFLAGS_UNDERENV) == 0) &&
     2347                                  (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOTWRITEABLE) == 0);
     2348                WinEnableMenuItem((HWND)mp2,
     2349                                  IDM_DELETESUBMENU,
     2350                                  ((pci->flags & RECFLAGS_UNDERENV) == 0) &&
     2351                                  (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOTWRITEABLE) == 0);
     2352                WinEnableMenuItem((HWND)mp2,
     2353                                  IDM_MOVEMENU,
     2354                                  ((pci->flags & RECFLAGS_UNDERENV) == 0) &&
     2355                                  (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOTWRITEABLE) == 0);
     2356                WinEnableMenuItem((HWND)mp2,
     2357                                  IDM_RENAME,
     2358                                  ((pci->flags & RECFLAGS_UNDERENV) == 0) &&
     2359                                  (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOTWRITEABLE) == 0);
     2360                WinEnableMenuItem((HWND)mp2,
     2361                                  IDM_DETACH,
     2362                                  (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_REMOTE) != 0);
     2363                WinEnableMenuItem((HWND)mp2,
     2364                                  IDM_EJECT,
     2365                                  (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_REMOVABLE) != 0);
    23482366/*
    2349                 WinEnableMenuItem((HWND)mp2,
    2350                                   IDM_CLOSETRAY,
    2351                                   (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_CDROM) != 0);
     2367                WinEnableMenuItem((HWND)mp2,
     2368                                  IDM_CLOSETRAY,
     2369                                  (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_CDROM) != 0);
    23522370*/
    2353                 WinEnableMenuItem((HWND)mp2,
    2354                                   IDM_LOCK,
    2355                                   (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_REMOVABLE) != 0);
    2356                 WinEnableMenuItem((HWND)mp2,
    2357                                   IDM_UNLOCK,
    2358                                   (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_REMOVABLE) != 0);
    2359                 WinEnableMenuItem((HWND)mp2,
    2360                                   IDM_OPTIMIZE,
    2361                                   (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOTWRITEABLE) == 0);
    2362                 WinEnableMenuItem((HWND)mp2,
    2363                                   IDM_FORMAT,
    2364                                   (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOTWRITEABLE) == 0);
    2365                 WinEnableMenuItem((HWND)mp2,
    2366                                   IDM_CHKDSK,
    2367                                   (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOTWRITEABLE) == 0);
    2368                 WinEnableMenuItem((HWND)mp2,
    2369                                   IDM_MKDIR,
    2370                                   (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOTWRITEABLE) == 0);
    2371                 WinEnableMenuItem((HWND)mp2,
    2372                                   IDM_UNDELETE,
    2373                                   (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOTWRITEABLE) == 0);
    2374                 WinEnableMenuItem((HWND)mp2,
    2375                                   IDM_ATTRS,
    2376                                   (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOTWRITEABLE) == 0);
    2377               }
    2378             }
    2379             break;
    2380 
    2381           case IDM_VIEWSMENU:
    2382             WinCheckMenuItem((HWND)mp2,
    2383                              IDM_MINIICONS,
    2384                              ((dcd->flWindowAttr & CV_MINI) != 0));
    2385             WinEnableMenuItem((HWND)mp2,
    2386                               IDM_RESELECT,
    2387                               FALSE);
    2388             break;
    2389 
    2390           case IDM_COMMANDSMENU:
    2391             SetupCommandMenu((HWND)mp2,hwnd);
    2392             break;
    2393 
    2394           case IDM_SORTSUBMENU:
    2395             SetSortChecks((HWND)mp2,TreesortFlags);
    2396             break;
    2397 
    2398           case IDM_WINDOWSMENU:
    2399             SetupWinList((HWND)mp2,
    2400                         (hwndMain) ? hwndMain : (HWND)0,
    2401                         dcd->hwndFrame);
    2402             break;
    2403         }
    2404         dcd->hwndLastMenu = (HWND)mp2;
     2371                WinEnableMenuItem((HWND)mp2,
     2372                                  IDM_LOCK,
     2373                                  (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_REMOVABLE) != 0);
     2374                WinEnableMenuItem((HWND)mp2,
     2375                                  IDM_UNLOCK,
     2376                                  (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_REMOVABLE) != 0);
     2377                WinEnableMenuItem((HWND)mp2,
     2378                                  IDM_OPTIMIZE,
     2379                                  (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOTWRITEABLE) == 0);
     2380                WinEnableMenuItem((HWND)mp2,
     2381                                  IDM_FORMAT,
     2382                                  (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOTWRITEABLE) == 0);
     2383                WinEnableMenuItem((HWND)mp2,
     2384                                  IDM_CHKDSK,
     2385                                  (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOTWRITEABLE) == 0);
     2386                WinEnableMenuItem((HWND)mp2,
     2387                                  IDM_MKDIR,
     2388                                  (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOTWRITEABLE) == 0);
     2389                WinEnableMenuItem((HWND)mp2,
     2390                                  IDM_UNDELETE,
     2391                                  (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOTWRITEABLE) == 0);
     2392                WinEnableMenuItem((HWND)mp2,
     2393                                  IDM_ATTRS,
     2394                                  (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOTWRITEABLE) == 0);
     2395              }
     2396            }
     2397            break;
     2398
     2399          case IDM_VIEWSMENU:
     2400            WinCheckMenuItem((HWND)mp2,
     2401                             IDM_MINIICONS,
     2402                             ((dcd->flWindowAttr & CV_MINI) != 0));
     2403            WinEnableMenuItem((HWND)mp2,
     2404                              IDM_RESELECT,
     2405                              FALSE);
     2406            break;
     2407
     2408          case IDM_COMMANDSMENU:
     2409            SetupCommandMenu((HWND)mp2,hwnd);
     2410            break;
     2411
     2412          case IDM_SORTSUBMENU:
     2413            SetSortChecks((HWND)mp2,TreesortFlags);
     2414            break;
     2415
     2416          case IDM_WINDOWSMENU:
     2417            SetupWinList((HWND)mp2,
     2418                        (hwndMain) ? hwndMain : (HWND)0,
     2419                        dcd->hwndFrame);
     2420            break;
     2421        }
     2422        dcd->hwndLastMenu = (HWND)mp2;
    24052423      }
    24062424      if(msg == WM_INITMENU)
    2407         break;
     2425        break;
    24082426      return 0;
    24092427
    24102428    case UM_COMMAND:
    24112429      if(mp1) {
    2412         if(dcd) {
    2413           if(!PostMsg(dcd->hwndObject,UM_COMMAND,mp1,mp2)) {
    2414             FreeListInfo((LISTINFO *)mp1);
    2415             DosBeep(50,100);
    2416           }
    2417           else
    2418             return (MRESULT)TRUE;
    2419         }
    2420         else
    2421           FreeListInfo((LISTINFO *)mp1);
     2430        if(dcd) {
     2431          if(!PostMsg(dcd->hwndObject,UM_COMMAND,mp1,mp2)) {
     2432            FreeListInfo((LISTINFO *)mp1);
     2433            DosBeep(50,100);
     2434          }
     2435          else
     2436            return (MRESULT)TRUE;
     2437        }
     2438        else
     2439          FreeListInfo((LISTINFO *)mp1);
    24222440      }
    24232441      return 0;
    … …  
    24262444      if(dcd && mp2) {
    24272445
    2428         HWND ret;
    2429 
    2430         ret = StartMLEEditor(dcd->hwndParent,(INT)mp1,(CHAR *)mp2,
    2431                              dcd->hwndFrame);
    2432         if(mp2)
    2433           free((CHAR *)mp2);
    2434         return MRFROMLONG(ret);
     2446        HWND ret;
     2447
     2448        ret = StartMLEEditor(dcd->hwndParent,(INT)mp1,(CHAR *)mp2,
     2449                             dcd->hwndFrame);
     2450        if(mp2)
     2451          free((CHAR *)mp2);
     2452        return MRFROMLONG(ret);
    24352453      }
    24362454      return 0;
    … …  
    24422460    case UM_NOTIFY:
    24432461      if(mp2)
    2444         Notify((CHAR *)mp2);
     2462        Notify((CHAR *)mp2);
    24452463      return 0;
    24462464
    … …  
    24482466      if(dcd) {
    24492467
    2450         BOOL tempsusp = dcd->suspendview;
    2451 
    2452         if(mp1) {
    2453           DosEnterCritSec();
    2454            SetMask((CHAR *)mp1,&dcd->mask);
    2455           DosExitCritSec();
    2456         }
    2457         dcd->suspendview = TRUE;
    2458         dcd->mask.attrFile |= FILE_DIRECTORY;
    2459         WinSendMsg(hwnd,CM_FILTER,MPFROMP(Filter),MPFROMP(&dcd->mask));
    2460         dcd->suspendview = tempsusp;
    2461         PostMsg(hwnd,UM_RESCAN,MPVOID,MPVOID);
     2468        BOOL tempsusp = dcd->suspendview;
     2469
     2470        if(mp1) {
     2471          DosEnterCritSec();
     2472           SetMask((CHAR *)mp1,&dcd->mask);
     2473          DosExitCritSec();
     2474        }
     2475        dcd->suspendview = TRUE;
     2476        dcd->mask.attrFile |= FILE_DIRECTORY;
     2477        WinSendMsg(hwnd,CM_FILTER,MPFROMP(Filter),MPFROMP(&dcd->mask));
     2478        dcd->suspendview = tempsusp;
     2479        PostMsg(hwnd,UM_RESCAN,MPVOID,MPVOID);
    24622480      }
    24632481      return 0;
    … …  
    24652483    case UM_DRIVECMD:
    24662484      if(mp1)
    2467         ShowTreeRec(hwnd,(CHAR *)mp1,FALSE,TRUE);
     2485        ShowTreeRec(hwnd,(CHAR *)mp1,FALSE,TRUE);
    24682486      return 0;
    24692487
    24702488    case WM_APPTERMINATENOTIFY:
    24712489      {
    2472         APPNOTIFY *info;
    2473         PCNRITEM   pci;
    2474         CHAR       s[] = " :\\";
    2475 
    2476         if(!mp2) {
    2477           if(hwndMain)
    2478             PostMsg(hwndMain,
    2479                     UM_BUILDDRIVES,
    2480                     MPVOID,
    2481                     MPVOID);
    2482         }
    2483         info = apphead;
    2484         while(info) {
    2485           if(info->happ == (HAPP)mp1) {
    2486             *s = info->device;
    2487             pci = FindCnrRecord(hwnd,
    2488                                 s,
    2489                                 NULL,
    2490                                 FALSE,
    2491                                 FALSE,
    2492                                 TRUE);
    2493             if(pci && (INT)pci != -1) {
    2494               driveserial[info->device - 'A'] = -1;
    2495               DriveFlagsOne(info->device - 'A');
    2496               if(driveflags[info->device - 'A'] &
    2497                 (DRIVE_INVALID | DRIVE_IGNORE))
    2498                 WinSendMsg(hwnd,
    2499                            CM_REMOVERECORD,
    2500                            MPFROMP(&pci),
    2501                            MPFROM2SHORT(1,CMA_FREE));
    2502               else
    2503                 Flesh(hwnd,pci);
    2504             }
    2505             if(info->prev)
    2506               info->prev->next = info->next;
    2507             if(info->next)
    2508               info->next->prev = info->prev;
    2509             if(apphead == info)
    2510               apphead = info->next;
    2511             if(apptail == info)
    2512               apptail = info->prev;
    2513             free(info);
    2514             break;
    2515           }
    2516           info = info->next;
    2517         }
     2490        APPNOTIFY *info;
     2491        PCNRITEM   pci;
     2492        CHAR       s[] = " :\\";
     2493
     2494        if(!mp2) {
     2495          if(hwndMain)
     2496            PostMsg(hwndMain,
     2497                    UM_BUILDDRIVES,
     2498                    MPVOID,
     2499                    MPVOID);
     2500        }
     2501        info = apphead;
     2502        while(info) {
     2503          if(info->happ == (HAPP)mp1) {
     2504            *s = info->device;
     2505            pci = FindCnrRecord(hwnd,
     2506                                s,
     2507                                NULL,
     2508                                FALSE,
     2509                                FALSE,
     2510                                TRUE);
     2511            if(pci && (INT)pci != -1) {
     2512              driveserial[info->device - 'A'] = -1;
     2513              DriveFlagsOne(info->device - 'A');
     2514              if(driveflags[info->device - 'A'] &
     2515                (DRIVE_INVALID | DRIVE_IGNORE))
     2516                WinSendMsg(hwnd,
     2517                           CM_REMOVERECORD,
     2518                           MPFROMP(&pci),
     2519                           MPFROM2SHORT(1,CMA_FREE));
     2520              else
     2521                Flesh(hwnd,pci);
     2522            }
     2523            if(info->prev)
     2524              info->prev->next = info->next;
     2525            if(info->next)
     2526              info->next->prev = info->prev;
     2527            if(apphead == info)
     2528              apphead = info->next;
     2529            if(apptail == info)
     2530              apptail = info->prev;
     2531            free(info);
     2532            break;
     2533          }
     2534          info = info->next;
     2535        }
    25182536      }
    25192537      break;
    … …  
    25222540      DosError(FERR_DISABLEHARDERR);
    25232541      if(dcd) {
    2524         if(SwitchCommand(dcd->hwndLastMenu,
    2525                    SHORT1FROMMP(mp1)))
    2526           return 0;
    2527         switch(SHORT1FROMMP(mp1)) {
    2528           case IDM_SETTARGET:
    2529             SetTargetDir(hwnd,FALSE);
    2530             break;
    2531 
    2532           case IDM_DETACH:
    2533             {
    2534               CHAR        d[3] = " :";
    2535               PCNRITEM    pci;
    2536               PROGDETAILS pgd;
    2537               CHAR        params[368],*p;
    2538               HAPP        happ;
    2539 
    2540 
    2541               pci = (PCNRITEM)CurrentRecord(hwnd);
    2542               if(pci && (INT)pci != -1 && isalpha(*pci->szFileName)) {
    2543                 *d = toupper(*pci->szFileName);
    2544                 p = GetCmdSpec(FALSE);
    2545                 memset(&pgd,0,sizeof(pgd));
    2546                 pgd.Length = sizeof(pgd);
    2547                 pgd.progt.progc = PROG_WINDOWABLEVIO;
    2548                 pgd.progt.fbVisible = SHE_VISIBLE;
    2549                 pgd.pszTitle = GetPString(IDS_DETACHREQUESTTEXT);
    2550                 pgd.pszExecutable = p;
    2551                 pgd.pszParameters = params;
    2552                 pgd.pszStartupDir = NULL;
    2553                 pgd.pszIcon = NULL;
    2554                 pgd.pszEnvironment = NULL;
    2555                 pgd.swpInitial.hwndInsertBehind = HWND_TOP;
    2556                 pgd.swpInitial.hwnd = hwnd;
    2557                 pgd.swpInitial.fl = SWP_SHOW | SWP_ACTIVATE;
    2558                 sprintf(params,"/C NET USE %s /D",d);
    2559                 happ = WinStartApp(hwnd,&pgd,pgd.pszParameters,
    2560                                    NULL,SAF_MAXIMIZED);
    2561                 if(happ) {
    2562 
    2563                   APPNOTIFY *info;
    2564 
    2565                   info = malloc(sizeof(APPNOTIFY));
    2566                   if(info) {
    2567                     memset(info,0,sizeof(APPNOTIFY));
    2568                     info->happ = happ;
    2569                     info->device = *d;
    2570                     if(!apphead)
    2571                       apphead = info;
    2572                     else {
    2573                       apptail->next = info;
    2574                       info->prev = apptail;
    2575                     }
    2576                     apptail = info;
    2577                   }
    2578                 }
    2579                 else
    2580                   saymsg(MB_CANCEL | MB_ICONEXCLAMATION,hwnd,
    2581                         GetPString(IDS_ERRORTEXT),
    2582                         GetPString(IDS_CANTSTARTTEXT),
    2583                         p,params);
    2584               }
    2585             }
    2586             break;
    2587 
    2588           case IDM_REMAP:
    2589             WinDlgBox(HWND_DESKTOP,hwnd,RemapDlgProc,
    2590                       FM3ModHandle,MAP_FRAME,NULL);
    2591             break;
    2592 
    2593           case IDM_CONTEXTMENU:
    2594             {
    2595               PCNRITEM pci;
    2596 
    2597               pci = (PCNRITEM)CurrentRecord(hwnd);
    2598               PostMsg(hwnd,WM_CONTROL,MPFROM2SHORT(DIR_CNR,CN_CONTEXTMENU),
    2599                       MPFROMP(pci));
    2600             }
    2601             break;
    2602 
    2603           case IDM_FINDINTREE:
    2604             {
    2605               CHAR     dir[CCHMAXPATH];
    2606               PCNRITEM pci;
    2607 
    2608               pci = (PCNRITEM)CurrentRecord(hwnd);
    2609               if(pci && (INT)pci != -1) {
    2610                 strcpy(dir,pci->szFileName);
    2611                 MakeValidDir(dir);
    2612               }
    2613               else
    2614                 save_dir2(dir);
    2615               if(WinDlgBox(HWND_DESKTOP,dcd->hwndParent,
    2616                            WalkAllDlgProc,
    2617                            FM3ModHandle,WALK_FRAME,
    2618                            MPFROMP(dir)) && *dir)
    2619                 WinSendMsg(hwnd,UM_SHOWME,MPFROMP(dir),MPFROMLONG(1L));
    2620             }
    2621             break;
    2622 
    2623           case IDM_BEGINEDIT:
    2624             OpenEdit(hwnd);
    2625             break;
    2626 
    2627           case IDM_ENDEDIT:
    2628             WinSendMsg(hwnd,
    2629                        CM_CLOSEEDIT,
    2630                        MPVOID,
    2631                        MPVOID);
    2632             break;
    2633 
    2634           case IDM_FILTER:
    2635             {
    2636               BOOL     empty = FALSE;
    2637               PCNRITEM pci;
    2638 
    2639               pci = (PCNRITEM)CurrentRecord(hwnd);
    2640               if(!*dcd->mask.szMask)
    2641                 empty = TRUE;
    2642               dcd->mask.fIsTree = TRUE;
    2643               *dcd->mask.prompt = 0;
    2644               if(pci && (INT)pci != -1)
    2645                 dcd->mask.fFilesIncluded = ((driveflags[toupper(*pci->szFileName) - 'A'] &
    2646                                              DRIVE_INCLUDEFILES) != 0);
    2647               else
    2648                 dcd->mask.fFilesIncluded = FALSE;
    2649               if(WinDlgBox(HWND_DESKTOP,hwnd,PickMaskDlgProc,
    2650                            FM3ModHandle,MSK_FRAME,MPFROMP(&dcd->mask)))
    2651                 WinSendMsg(hwnd,UM_FILTER,MPVOID,MPVOID);
    2652               else if(empty)
    2653                 *dcd->mask.szMask = 0;
    2654               PrfWriteProfileData(fmprof,appname,"TreeFilter",&dcd->mask,
    2655                                   sizeof(MASK));
    2656             }
    2657             break;
    2658 
    2659           case IDM_SHOWSORT:
    2660             QuickPopup(hwnd,dcd,CheckMenu(&TreeCnrMenu,TREECNR_POPUP),
    2661                        IDM_SORTSUBMENU);
    2662             break;
    2663 
    2664           case IDM_SHOWSELECT:
    2665             QuickPopup(hwnd,dcd,CheckMenu(&TreeCnrMenu,TREECNR_POPUP),
    2666                        IDM_SELECTSUBMENU);
    2667             break;
    2668 
    2669           case IDM_NOTEBOOK:
    2670             if(!ParentIsDesktop(dcd->hwndParent,dcd->hwndParent))
    2671               PostMsg(dcd->hwndParent,msg,mp1,mp2);
    2672             else
    2673               WinDlgBox(HWND_DESKTOP,hwnd,CfgDlgProc,FM3ModHandle,
    2674                         CFG_FRAME,(PVOID)"Tree");
    2675             break;
    2676 
    2677           case IDM_WALKDIR:
    2678           case IDM_OPENWALK:
    2679             {
    2680               CHAR     newpath[CCHMAXPATH];
    2681               PCNRITEM pci;
    2682 
    2683               pci = (PCNRITEM)CurrentRecord(hwnd);
    2684               if(pci && (INT)pci != -1) {
    2685                 strcpy(newpath,pci->szFileName);
    2686                 MakeValidDir(newpath);
    2687               }
    2688               else
    2689                 save_dir2(newpath);
    2690               if(!WinDlgBox(HWND_DESKTOP,dcd->hwndParent,WalkAllDlgProc,
    2691                             FM3ModHandle,WALK_FRAME,
    2692                             MPFROMP(newpath)) || !*newpath)
    2693                 break;
    2694               WinSendMsg(hwnd,UM_OPENWINDOWFORME,MPFROMP(newpath),MPVOID);
    2695             }
    2696             break;
    2697 
    2698           case IDM_HELP:
    2699             if(hwndHelp) {
    2700               if(!ParentIsDesktop(dcd->hwndFrame,dcd->hwndParent))
    2701                 PostMsg(dcd->hwndParent,UM_COMMAND,mp1,mp2);
    2702               else
    2703                 WinSendMsg(hwndHelp,HM_HELP_CONTENTS,MPVOID,MPVOID);
    2704             }
    2705             break;
    2706 
    2707           case IDM_PARTITION:
    2708             runemf2(SEPARATE | WINDOWED,HWND_DESKTOP,NULL,NULL,
    2709                     "%s","FDISKPM.EXE");
    2710             break;
    2711 
    2712           case IDM_SORTNAME:
    2713           case IDM_SORTFILENAME:
    2714           case IDM_SORTSIZE:
    2715           case IDM_SORTEASIZE:
    2716           case IDM_SORTFIRST:
    2717           case IDM_SORTLAST:
    2718           case IDM_SORTLWDATE:
    2719           case IDM_SORTLADATE:
    2720           case IDM_SORTCRDATE:
    2721             TreesortFlags &= (SORT_REVERSE | SORT_DIRSFIRST | SORT_DIRSLAST);
    2722           case IDM_SORTDIRSFIRST:
    2723           case IDM_SORTDIRSLAST:
    2724           case IDM_SORTREVERSE:
    2725             switch(SHORT1FROMMP(mp1)) {
    2726               case IDM_SORTFILENAME:
    2727                 TreesortFlags |= SORT_FILENAME;
    2728                 break;
    2729               case IDM_SORTSIZE:
    2730                 TreesortFlags |= SORT_SIZE;
    2731                 break;
    2732               case IDM_SORTEASIZE:
    2733                 TreesortFlags |= SORT_EASIZE;
    2734                 break;
    2735               case IDM_SORTFIRST:
    2736                 TreesortFlags |= SORT_FIRSTEXTENSION;
    2737                 break;
    2738               case IDM_SORTLAST:
    2739                 TreesortFlags |= SORT_LASTEXTENSION;
    2740                 break;
    2741               case IDM_SORTLWDATE:
    2742                 TreesortFlags |= SORT_LWDATE;
    2743                 break;
    2744               case IDM_SORTLADATE:
    2745                 TreesortFlags |= SORT_LADATE;
    2746                 break;
    2747               case IDM_SORTCRDATE:
    2748                 TreesortFlags |= SORT_CRDATE;
    2749                 break;
    2750               case IDM_SORTDIRSFIRST:
    2751                 if(TreesortFlags & SORT_DIRSFIRST)
    2752                   TreesortFlags &= (~SORT_DIRSFIRST);
    2753                 else {
    2754                   TreesortFlags |= SORT_DIRSFIRST;
    2755                   TreesortFlags &= (~SORT_DIRSLAST);
    2756                 }
    2757                 break;
    2758               case IDM_SORTDIRSLAST:
    2759                 if(TreesortFlags & SORT_DIRSLAST)
    2760                   TreesortFlags &= (~SORT_DIRSLAST);
    2761                 else {
    2762                   TreesortFlags |= SORT_DIRSLAST;
    2763                   TreesortFlags &= (~SORT_DIRSFIRST);
    2764                 }
    2765                 break;
    2766               case IDM_SORTREVERSE:
    2767                 if(TreesortFlags & SORT_REVERSE)
    2768                   TreesortFlags &= (~SORT_REVERSE);
    2769                 else
    2770                   TreesortFlags |= SORT_REVERSE;
    2771                 break;
    2772             }
    2773             PrfWriteProfileData(fmprof,appname,"TreeSort",&TreesortFlags,
    2774                                 sizeof(INT));
    2775             WinSendMsg(hwnd,CM_SORTRECORD,MPFROMP(SortTreeCnr),MPVOID);
    2776             break;
    2777 
    2778           case IDM_COLLECT:
    2779             if(!Collector) {
    2780 
    2781               HWND hwndC;
    2782               SWP  swp;
    2783 
    2784               if(!ParentIsDesktop(hwnd,dcd->hwndParent) &&
    2785                 !fAutoTile &&
    2786                 (!fExternalCollector &&
    2787                   *(ULONG *)realappname == FM3UL))
    2788                 GetNextWindowPos(dcd->hwndParent,
    2789                                 &swp,
    2790                                 NULL,
    2791                                 NULL);
    2792               hwndC = StartCollector((fExternalCollector ||
    2793                                       *(ULONG *)realappname != FM3UL) ?
    2794                                      HWND_DESKTOP :
    2795                                      dcd->hwndParent,
    2796                                      4);
    2797               if(hwndC) {
    2798                 if(!ParentIsDesktop(hwnd,
    2799                                     dcd->hwndParent) &&
    2800                    !fAutoTile &&
    2801                    (!fExternalCollector &&
    2802                     *(ULONG *)realappname == FM3UL))
    2803                   WinSetWindowPos(hwndC,
    2804                                   HWND_TOP,
    2805                                   swp.x,
    2806                                   swp.y,
    2807                                   swp.cx,
    2808                                   swp.cy,
    2809                                   SWP_MOVE | SWP_SIZE |
    2810                                   SWP_SHOW | SWP_ZORDER);
    2811                 else if(!ParentIsDesktop(hwnd,
    2812                                         dcd->hwndParent) &&
    2813                         fAutoTile &&
    2814                         *(ULONG *)realappname == FM3UL)
    2815                   TileChildren(dcd->hwndParent,
    2816                                TRUE);
    2817               }
    2818               WinSetWindowPos(hwndC,
    2819                               HWND_TOP,
    2820                               0,
    2821                               0,
    2822                               0,
    2823                               0,
    2824                               SWP_ACTIVATE);
    2825               DosSleep(250L);
    2826             }
    2827             else
    2828               StartCollector(dcd->hwndParent,
    2829                              4);
    2830             PostMsg(hwnd,
    2831                     WM_COMMAND,
    2832                     MPFROM2SHORT(IDM_COLLECTOR,0),
    2833                     MPVOID);
    2834             break;
    2835 
    2836           case IDM_COLLECTOR:
    2837             DosSleep(64L);
    2838             {
    2839               CHAR **list;
    2840 
    2841               list = BuildList(hwnd);
    2842               if(list) {
    2843                 if(Collector) {
    2844                   if(!PostMsg(Collector,WM_COMMAND,
    2845                                 MPFROM2SHORT(IDM_COLLECTOR,0),
    2846                                 MPFROMP(list)))
    2847                     FreeList(list);
    2848                 }
    2849                 else
    2850                   FreeList(list);
    2851               }
    2852             }
    2853             break;
    2854 
    2855           case IDM_COLLAPSEALL:
    2856             WinSendMsg(hwnd,
    2857                        CM_COLLAPSETREE,
    2858                        MPVOID,
    2859                        MPVOID);
    2860             break;
    2861 
    2862           case IDM_COLLAPSE:
    2863           case IDM_EXPAND:
    2864             {
    2865               PCNRITEM pci = NULL;
    2866 
    2867               pci = (PCNRITEM)CurrentRecord(hwnd);
    2868               if(pci && (INT)pci != -1) {
    2869                 if(pci->flags & RECFLAGS_UNDERENV)
    2870                   break;
    2871                 PostMsg(dcd->hwndObject,
    2872                         UM_EXPAND,
    2873                         mp1,
    2874                         MPFROMP(pci));
    2875               }
    2876             }
    2877             break;
    2878 
    2879           case IDM_UPDATE:
    2880             {
    2881               PCNRITEM pci = NULL;
    2882 
    2883               pci = (PCNRITEM)CurrentRecord(hwnd);
    2884               if(pci && (INT)pci != -1) {
    2885                 if(pci->attrFile & FILE_DIRECTORY) {
    2886                   if(pci->flags & RECFLAGS_UNDERENV)
    2887                     break;
    2888                   UnFlesh(hwnd,pci);
    2889                   if(driveflags[toupper(*pci->szFileName) - 'A'] & (DRIVE_INVALID |
    2890                                       DRIVE_NOPRESCAN)) {
    2891                     driveflags[toupper(*pci->szFileName) - 'A'] &= (DRIVE_IGNORE |
    2892                                       DRIVE_NOPRESCAN | DRIVE_NOLOADICONS |
    2893                                       DRIVE_NOLOADSUBJS | DRIVE_NOLOADLONGS);
    2894                     DriveFlagsOne(toupper(*pci->szFileName) - 'A');
    2895                     if(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_INVALID)
    2896                       pci->rc.hptrIcon = hptrDunno;
    2897                     else {
    2898                       if(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_CDROM)
    2899                         pci->rc.hptrIcon = hptrCDROM;
    2900                       else
    2901                         pci->rc.hptrIcon = (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_REMOVABLE) ?
    2902                                             hptrRemovable :
    2903                                             (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_REMOTE) ?
    2904                                             hptrRemote :
    2905                                             (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_ZIPSTREAM) ?
    2906                                             hptrZipstrm : hptrDrive;
    2907                     }
    2908                     WinSendMsg(hwnd,
    2909                                CM_INVALIDATERECORD,
    2910                                MPFROMP(&pci),
    2911                                MPFROM2SHORT(1,CMA_ERASE | CMA_REPOSITION));
    2912                     if(hwndMain)
    2913                       PostMsg(hwndMain,
    2914                               UM_BUILDDRIVES,
    2915                               MPVOID,
    2916                               MPVOID);
    2917                   }
    2918                   if(!(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_INVALID))
    2919                     Flesh(hwnd,pci);
    2920                 }
    2921                 else {
    2922 
    2923                 }
    2924               }
    2925             }
    2926             break;
    2927 
    2928           case IDM_RESCAN:
    2929             PostMsg(dcd->hwndObject,
    2930                     UM_RESCAN,
    2931                     MPVOID,
    2932                     MPVOID);
    2933             break;
    2934 
    2935           case IDM_RESORT:
    2936             WinSendMsg(hwnd,
    2937                        CM_SORTRECORD,
    2938                        MPFROMP(SortTreeCnr),
    2939                        MPVOID);
    2940             break;
    2941 
    2942           case IDM_TEXT:
    2943           case IDM_MINIICONS:
    2944             {
    2945               CNRINFO cnri;
    2946 
    2947               memset(&cnri,0,sizeof(CNRINFO));
    2948               cnri.cb = sizeof(CNRINFO);
    2949               WinSendMsg(hwnd,
    2950                         CM_QUERYCNRINFO,
    2951                         MPFROMP(&cnri),
    2952                         MPFROMLONG(sizeof(CNRINFO)));
    2953               if(SHORT1FROMMP(mp1) == IDM_MINIICONS) {
    2954                 if(cnri.flWindowAttr & CV_MINI)
    2955                   cnri.flWindowAttr &= (~CV_MINI);
    2956                 else
    2957                   cnri.flWindowAttr |= CV_MINI;
    2958               }
    2959               else {
    2960                 if(cnri.flWindowAttr & CV_TEXT) {
    2961                   cnri.flWindowAttr &= (~CV_TEXT);
    2962                   cnri.flWindowAttr |= CV_ICON;
    2963                 }
    2964                 else {
    2965                   cnri.flWindowAttr &= (~CV_ICON);
    2966                   cnri.flWindowAttr |= CV_TEXT;
    2967                 }
    2968               }
    2969               dcd->flWindowAttr = cnri.flWindowAttr;
    2970               PrfWriteProfileData(fmprof,
    2971                                   appname,
    2972                                   "TreeflWindowAttr",
    2973                                   &cnri.flWindowAttr,
    2974                                   sizeof(ULONG));
    2975               WinSendMsg(hwnd,
    2976                         CM_SETCNRINFO,
    2977                         MPFROMP(&cnri),
    2978                         MPFROMLONG(CMA_FLWINDOWATTR | CMA_TREEICON |
    2979                                     CMA_SLTREEBITMAPORICON));
    2980             }
    2981             break;
    2982 
    2983           case IDM_SIZES:
    2984           case IDM_DRVFLAGS:
    2985           case IDM_SHOWALLFILES:
    2986           case IDM_UNDELETE:
    2987           case IDM_OPTIMIZE:
    2988           case IDM_CHKDSK:
    2989           case IDM_FORMAT:
    2990           case IDM_MKDIR:
    2991           case IDM_LOCK:
    2992           case IDM_UNLOCK:
    2993           case IDM_EJECT:
    2994           case IDM_CLOSETRAY:
    2995             {
    2996               PCNRITEM pci;
    2997 
    2998               pci = (PCNRITEM)CurrentRecord(hwnd);
    2999               if(pci && (INT)pci != -1)
    3000                 CommonDriveCmd(hwnd,
    3001                                pci->szFileName,
    3002                                SHORT1FROMMP(mp1));
    3003             }
    3004             break;
    3005 
    3006           case IDM_SAVETOLIST:
    3007             WinDlgBox(HWND_DESKTOP,
    3008                       hwnd,
    3009                       SaveListDlgProc,
    3010                       FM3ModHandle,
    3011                       SAV_FRAME,
    3012                       MPFROMP(&hwnd));
    3013             break;
    3014 
    3015           case IDM_DELETE:
    3016           case IDM_PERMDELETE:
    3017           case IDM_MOVE:
    3018           case IDM_WPSMOVE:
    3019           case IDM_WILDMOVE:
    3020           case IDM_RENAME:
    3021             {
    3022               PCNRITEM pci;
    3023 
    3024               pci = (PCNRITEM)CurrentRecord(hwnd);
    3025               if(pci && (INT)pci != -1) {
    3026                 if(pci->flags & RECFLAGS_UNDERENV)
    3027                   break;
    3028               }
    3029             }
    3030             /* else intentional fallthru */
    3031           case IDM_ATTRS:
    3032           case IDM_INFO:
    3033           case IDM_COPY:
    3034           case IDM_WPSCOPY:
    3035           case IDM_WILDCOPY:
    3036           case IDM_DOITYOURSELF:
    3037           case IDM_OPENWINDOW:
    3038           case IDM_OPENSETTINGS:
    3039           case IDM_OPENDEFAULT:
    3040           case IDM_OPENICON:
    3041           case IDM_OPENDETAILS:
    3042           case IDM_OPENTREE:
    3043           case IDM_SHADOW:
    3044           case IDM_SHADOW2:
    3045           case IDM_COMPARE:
    3046           case IDM_VIEW:
    3047           case IDM_VIEWTEXT:
    3048           case IDM_VIEWBINARY:
    3049           case IDM_EDIT:
    3050           case IDM_EDITTEXT:
    3051           case IDM_EDITBINARY:
    3052           case IDM_EAS:
    3053           case IDM_SUBJECT:
    3054           case IDM_APPENDTOCLIP:
    3055           case IDM_SAVETOCLIP:
    3056           case IDM_ARCHIVE:
    3057           case IDM_MCIPLAY:
    3058           case IDM_UUDECODE:
    3059             {
    3060               LISTINFO *li;
    3061               ULONG     action = UM_ACTION;
    3062 
    3063               li = malloc(sizeof(LISTINFO));
    3064               if(li) {
    3065                 memset(li,0,sizeof(LISTINFO));
    3066                 li->type = SHORT1FROMMP(mp1);
    3067                 li->hwnd = hwnd;
    3068                 li->list = BuildList(hwnd);
    3069                 if(!li->list || !li->list[0]) {
    3070                   free(li);
    3071                   break;
    3072                 }
    3073                 if(IsRoot(li->list[0])) {
    3074                   switch(SHORT1FROMMP(mp1)) {
    3075                     case IDM_MOVE:
    3076                     case IDM_COPY:
    3077                     case IDM_WILDCOPY:
    3078                     case IDM_WILDMOVE:
    3079                     case IDM_WPSMOVE:
    3080                     case IDM_WPSCOPY:
    3081                     case IDM_RENAME:
    3082                     case IDM_DELETE:
    3083                     case IDM_PERMDELETE:
    3084                       mp1 = MPFROM2SHORT(IDM_INFO,SHORT2FROMMP(mp1));
    3085                       li->type = IDM_INFO;
    3086                       break;
    3087                   }
    3088                 }
    3089                 switch(SHORT1FROMMP(mp1)) {
    3090                   case IDM_APPENDTOCLIP:
    3091                   case IDM_SAVETOCLIP:
    3092                   case IDM_ARCHIVE:
    3093                   case IDM_DELETE:
    3094                   case IDM_PERMDELETE:
    3095                   case IDM_ATTRS:
    3096                   case IDM_SHADOW:
    3097                   case IDM_SHADOW2:
    3098                   case IDM_DOITYOURSELF:
    3099                   case IDM_EAS:
    3100                   case IDM_VIEW:
    3101                   case IDM_VIEWTEXT:
    3102                   case IDM_VIEWBINARY:
    3103                   case IDM_EDIT:
    3104                   case IDM_EDITTEXT:
    3105                   case IDM_EDITBINARY:
    3106                   case IDM_MCIPLAY:
    3107                     action = UM_MASSACTION;
    3108                     break;
    3109                 }
    3110                 if(SHORT1FROMMP(mp1) == IDM_SHADOW ||
    3111                    SHORT1FROMMP(mp1) == IDM_SHADOW2)
    3112                   *li->targetpath = 0;
    3113                 if(!PostMsg(dcd->hwndObject,action,MPFROMP(li),MPVOID)) {
    3114                   FreeListInfo(li);
    3115                   DosBeep(50,100);
    3116                 }
    3117               }
    3118             }
    3119             break;
    3120 
    3121           default:
    3122             if(SHORT1FROMMP(mp1) >= IDM_COMMANDSTART &&
    3123                SHORT1FROMMP(mp1) < IDM_QUICKTOOLSTART) {
    3124 
    3125               INT  x;
    3126 
    3127               if(!cmdloaded)
    3128                 load_commands();
    3129               x = SHORT1FROMMP(mp1) - IDM_COMMANDSTART;
    3130               if(x >= 0) {
    3131                 x++;
    3132                 RunCommand(hwnd,x);
    3133                 if(fUnHilite)
    3134                   UnHilite(hwnd,TRUE,&dcd->lastselection);
    3135               }
    3136             }
    3137             break;
    3138         }
     2542        if(SwitchCommand(dcd->hwndLastMenu,
     2543                   SHORT1FROMMP(mp1)))
     2544          return 0;
     2545        switch(SHORT1FROMMP(mp1)) {
     2546          case IDM_SETTARGET:
     2547            SetTargetDir(hwnd,FALSE);
     2548            break;
     2549
     2550          case IDM_DETACH:
     2551            {
     2552              CHAR        d[3] = " :";
     2553              PCNRITEM    pci;
     2554              PROGDETAILS pgd;
     2555              CHAR        params[368],*p;
     2556              HAPP        happ;
     2557
     2558
     2559              pci = (PCNRITEM)CurrentRecord(hwnd);
     2560              if(pci && (INT)pci != -1 && isalpha(*pci->szFileName)) {
     2561                *d = toupper(*pci->szFileName);
     2562                p = GetCmdSpec(FALSE);
     2563                memset(&pgd,0,sizeof(pgd));
     2564                pgd.Length = sizeof(pgd);
     2565                pgd.progt.progc = PROG_WINDOWABLEVIO;
     2566                pgd.progt.fbVisible = SHE_VISIBLE;
     2567                pgd.pszTitle = GetPString(IDS_DETACHREQUESTTEXT);
     2568                pgd.pszExecutable = p;
     2569                pgd.pszParameters = params;
     2570                pgd.pszStartupDir = NULL;
     2571                pgd.pszIcon = NULL;
     2572                pgd.pszEnvironment = NULL;
     2573                pgd.swpInitial.hwndInsertBehind = HWND_TOP;
     2574                pgd.swpInitial.hwnd = hwnd;
     2575                pgd.swpInitial.fl = SWP_SHOW | SWP_ACTIVATE;
     2576                sprintf(params,"/C NET USE %s /D",d);
     2577                happ = WinStartApp(hwnd,&pgd,pgd.pszParameters,
     2578                                   NULL,SAF_MAXIMIZED);
     2579                if(happ) {
     2580
     2581                  APPNOTIFY *info;
     2582
     2583                  info = malloc(sizeof(APPNOTIFY));
     2584                  if(info) {
     2585                    memset(info,0,sizeof(APPNOTIFY));
     2586                    info->happ = happ;
     2587                    info->device = *d;
     2588                    if(!apphead)
     2589                      apphead = info;
     2590                    else {
     2591                      apptail->next = info;
     2592                      info->prev = apptail;
     2593                    }
     2594                    apptail = info;
     2595                  }
     2596                }
     2597                else
     2598                  saymsg(MB_CANCEL | MB_ICONEXCLAMATION,hwnd,
     2599                        GetPString(IDS_ERRORTEXT),
     2600                        GetPString(IDS_CANTSTARTTEXT),
     2601                        p,params);
     2602              }
     2603            }
     2604            break;
     2605
     2606          case IDM_REMAP:
     2607            WinDlgBox(HWND_DESKTOP,hwnd,RemapDlgProc,
     2608                      FM3ModHandle,MAP_FRAME,NULL);
     2609            break;
     2610
     2611          case IDM_CONTEXTMENU:
     2612            {
     2613              PCNRITEM pci;
     2614
     2615              pci = (PCNRITEM)CurrentRecord(hwnd);
     2616              PostMsg(hwnd,WM_CONTROL,MPFROM2SHORT(DIR_CNR,CN_CONTEXTMENU),
     2617                      MPFROMP(pci));
     2618            }
     2619            break;
     2620
     2621          case IDM_FINDINTREE:
     2622            {
     2623              CHAR     dir[CCHMAXPATH];
     2624              PCNRITEM pci;
     2625
     2626              pci = (PCNRITEM)CurrentRecord(hwnd);
     2627              if(pci && (INT)pci != -1) {
     2628                strcpy(dir,pci->szFileName);
     2629                MakeValidDir(dir);
     2630              }
     2631              else
     2632                save_dir2(dir);
     2633              if(WinDlgBox(HWND_DESKTOP,dcd->hwndParent,
     2634                           WalkAllDlgProc,
     2635                           FM3ModHandle,WALK_FRAME,
     2636                           MPFROMP(dir)) && *dir)
     2637                WinSendMsg(hwnd,UM_SHOWME,MPFROMP(dir),MPFROMLONG(1L));
     2638            }
     2639            break;
     2640
     2641          case IDM_BEGINEDIT:
     2642            OpenEdit(hwnd);
     2643            break;
     2644
     2645          case IDM_ENDEDIT:
     2646            WinSendMsg(hwnd,
     2647                       CM_CLOSEEDIT,
     2648                       MPVOID,
     2649                       MPVOID);
     2650            break;
     2651
     2652          case IDM_FILTER:
     2653            {
     2654              BOOL     empty = FALSE;
     2655              PCNRITEM pci;
     2656
     2657              pci = (PCNRITEM)CurrentRecord(hwnd);
     2658              if(!*dcd->mask.szMask)
     2659                empty = TRUE;
     2660              dcd->mask.fIsTree = TRUE;
     2661              *dcd->mask.prompt = 0;
     2662              if(pci && (INT)pci != -1)
     2663                dcd->mask.fFilesIncluded = ((driveflags[toupper(*pci->szFileName) - 'A'] &
     2664                                             DRIVE_INCLUDEFILES) != 0);
     2665              else
     2666                dcd->mask.fFilesIncluded = FALSE;
     2667              if(WinDlgBox(HWND_DESKTOP,hwnd,PickMaskDlgProc,
     2668                           FM3ModHandle,MSK_FRAME,MPFROMP(&dcd->mask)))
     2669                WinSendMsg(hwnd,UM_FILTER,MPVOID,MPVOID);
     2670              else if(empty)
     2671                *dcd->mask.szMask = 0;
     2672              PrfWriteProfileData(fmprof,appname,"TreeFilter",&dcd->mask,
     2673                                  sizeof(MASK));
     2674            }
     2675            break;
     2676
     2677          case IDM_SHOWSORT:
     2678            QuickPopup(hwnd,dcd,CheckMenu(&TreeCnrMenu,TREECNR_POPUP),
     2679                       IDM_SORTSUBMENU);
     2680            break;
     2681
     2682          case IDM_SHOWSELECT:
     2683            QuickPopup(hwnd,dcd,CheckMenu(&TreeCnrMenu,TREECNR_POPUP),
     2684                       IDM_SELECTSUBMENU);
     2685            break;
     2686
     2687          case IDM_NOTEBOOK:
     2688            if(!ParentIsDesktop(dcd->hwndParent,dcd->hwndParent))
     2689              PostMsg(dcd->hwndParent,msg,mp1,mp2);
     2690            else
     2691              WinDlgBox(HWND_DESKTOP,hwnd,CfgDlgProc,FM3ModHandle,
     2692                        CFG_FRAME,(PVOID)"Tree");
     2693            break;
     2694
     2695          case IDM_WALKDIR:
     2696          case IDM_OPENWALK:
     2697            {
     2698              CHAR     newpath[CCHMAXPATH];
     2699              PCNRITEM pci;
     2700
     2701              pci = (PCNRITEM)CurrentRecord(hwnd);
     2702              if(pci && (INT)pci != -1) {
     2703                strcpy(newpath,pci->szFileName);
     2704                MakeValidDir(newpath);
     2705              }
     2706              else
     2707                save_dir2(newpath);
     2708              if(!WinDlgBox(HWND_DESKTOP,dcd->hwndParent,WalkAllDlgProc,
     2709                            FM3ModHandle,WALK_FRAME,
     2710                            MPFROMP(newpath)) || !*newpath)
     2711                break;
     2712              WinSendMsg(hwnd,UM_OPENWINDOWFORME,MPFROMP(newpath),MPVOID);
     2713            }
     2714            break;
     2715
     2716          case IDM_HELP:
     2717            if(hwndHelp) {
     2718              if(!ParentIsDesktop(dcd->hwndFrame,dcd->hwndParent))
     2719                PostMsg(dcd->hwndParent,UM_COMMAND,mp1,mp2);
     2720              else
     2721                WinSendMsg(hwndHelp,HM_HELP_CONTENTS,MPVOID,MPVOID);
     2722            }
     2723            break;
     2724
     2725          case IDM_PARTITION:
     2726            runemf2(SEPARATE | WINDOWED,HWND_DESKTOP,NULL,NULL,
     2727                    "%s","FDISKPM.EXE");
     2728            break;
     2729
     2730          case IDM_SORTNAME:
     2731          case IDM_SORTFILENAME:
     2732          case IDM_SORTSIZE:
     2733          case IDM_SORTEASIZE:
     2734          case IDM_SORTFIRST:
     2735          case IDM_SORTLAST:
     2736          case IDM_SORTLWDATE:
     2737          case IDM_SORTLADATE:
     2738          case IDM_SORTCRDATE:
     2739            TreesortFlags &= (SORT_REVERSE | SORT_DIRSFIRST | SORT_DIRSLAST);
     2740          case IDM_SORTDIRSFIRST:
     2741          case IDM_SORTDIRSLAST:
     2742          case IDM_SORTREVERSE:
     2743            switch(SHORT1FROMMP(mp1)) {
     2744              case IDM_SORTFILENAME:
     2745                TreesortFlags |= SORT_FILENAME;
     2746                break;
     2747              case IDM_SORTSIZE:
     2748                TreesortFlags |= SORT_SIZE;
     2749                break;
     2750              case IDM_SORTEASIZE:
     2751                TreesortFlags |= SORT_EASIZE;
     2752                break;
     2753              case IDM_SORTFIRST:
     2754                TreesortFlags |= SORT_FIRSTEXTENSION;
     2755                break;
     2756              case IDM_SORTLAST:
     2757                TreesortFlags |= SORT_LASTEXTENSION;
     2758                break;
     2759              case IDM_SORTLWDATE:
     2760                TreesortFlags |= SORT_LWDATE;
     2761                break;
     2762              case IDM_SORTLADATE:
     2763                TreesortFlags |= SORT_LADATE;
     2764                break;
     2765              case IDM_SORTCRDATE:
     2766                TreesortFlags |= SORT_CRDATE;
     2767                break;
     2768              case IDM_SORTDIRSFIRST:
     2769                if(TreesortFlags & SORT_DIRSFIRST)
     2770                  TreesortFlags &= (~SORT_DIRSFIRST);
     2771                else {
     2772                  TreesortFlags |= SORT_DIRSFIRST;
     2773                  TreesortFlags &= (~SORT_DIRSLAST);
     2774                }
     2775                break;
     2776              case IDM_SORTDIRSLAST:
     2777                if(TreesortFlags & SORT_DIRSLAST)
     2778                  TreesortFlags &= (~SORT_DIRSLAST);
     2779                else {
     2780                  TreesortFlags |= SORT_DIRSLAST;
     2781                  TreesortFlags &= (~SORT_DIRSFIRST);
     2782                }
     2783                break;
     2784              case IDM_SORTREVERSE:
     2785                if(TreesortFlags & SORT_REVERSE)
     2786                  TreesortFlags &= (~SORT_REVERSE);
     2787                else
     2788                  TreesortFlags |= SORT_REVERSE;
     2789                break;
     2790            }
     2791            PrfWriteProfileData(fmprof,appname,"TreeSort",&TreesortFlags,
     2792                                sizeof(INT));
     2793            WinSendMsg(hwnd,CM_SORTRECORD,MPFROMP(SortTreeCnr),MPVOID);
     2794            break;
     2795
     2796          case IDM_COLLECT:
     2797            if(!Collector) {
     2798
     2799              HWND hwndC;
     2800              SWP  swp;
     2801
     2802              if(!ParentIsDesktop(hwnd,dcd->hwndParent) &&
     2803                !fAutoTile &&
     2804                (!fExternalCollector &&
     2805                  *(ULONG *)realappname == FM3UL))
     2806                GetNextWindowPos(dcd->hwndParent,
     2807                                &swp,
     2808                                NULL,
     2809                                NULL);
     2810              hwndC = StartCollector((fExternalCollector ||
     2811                                      *(ULONG *)realappname != FM3UL) ?
     2812                                     HWND_DESKTOP :
     2813                                     dcd->hwndParent,
     2814                                     4);
     2815              if(hwndC) {
     2816                if(!ParentIsDesktop(hwnd,
     2817                                    dcd->hwndParent) &&
     2818                   !fAutoTile &&
     2819                   (!fExternalCollector &&
     2820                    *(ULONG *)realappname == FM3UL))
     2821                  WinSetWindowPos(hwndC,
     2822                                  HWND_TOP,
     2823                                  swp.x,
     2824                                  swp.y,
     2825                                  swp.cx,
     2826                                  swp.cy,
     2827                                  SWP_MOVE | SWP_SIZE |
     2828                                  SWP_SHOW | SWP_ZORDER);
     2829                else if(!ParentIsDesktop(hwnd,
     2830                                        dcd->hwndParent) &&
     2831                        fAutoTile &&
     2832                        *(ULONG *)realappname == FM3UL)
     2833                  TileChildren(dcd->hwndParent,
     2834                               TRUE);
     2835              }
     2836              WinSetWindowPos(hwndC,
     2837                              HWND_TOP,
     2838                              0,
     2839                              0,
     2840                              0,
     2841                              0,
     2842                              SWP_ACTIVATE);
     2843              DosSleep(250L);
     2844            }
     2845            else
     2846              StartCollector(dcd->hwndParent,
     2847                             4);
     2848            PostMsg(hwnd,
     2849                    WM_COMMAND,
     2850                    MPFROM2SHORT(IDM_COLLECTOR,0),
     2851                    MPVOID);
     2852            break;
     2853
     2854          case IDM_COLLECTOR:
     2855            DosSleep(64L);
     2856            {
     2857              CHAR **list;
     2858
     2859              list = BuildList(hwnd);
     2860              if(list) {
     2861                if(Collector) {
     2862                  if(!PostMsg(Collector,WM_COMMAND,
     2863                                MPFROM2SHORT(IDM_COLLECTOR,0),
     2864                                MPFROMP(list)))
     2865                    FreeList(list);
     2866                }
     2867                else
     2868                  FreeList(list);
     2869              }
     2870            }
     2871            break;
     2872
     2873          case IDM_COLLAPSEALL:
     2874            WinSendMsg(hwnd,
     2875                       CM_COLLAPSETREE,
     2876                       MPVOID,
     2877                       MPVOID);
     2878            break;
     2879
     2880          case IDM_COLLAPSE:
     2881          case IDM_EXPAND:
     2882            {
     2883              PCNRITEM pci = NULL;
     2884
     2885              pci = (PCNRITEM)CurrentRecord(hwnd);
     2886              if(pci && (INT)pci != -1) {
     2887                if(pci->flags & RECFLAGS_UNDERENV)
     2888                  break;
     2889                PostMsg(dcd->hwndObject,
     2890                        UM_EXPAND,
     2891                        mp1,
     2892                        MPFROMP(pci));
     2893              }
     2894            }
     2895            break;
     2896
     2897          case IDM_UPDATE:
     2898            {
     2899              PCNRITEM pci = NULL;
     2900
     2901              pci = (PCNRITEM)CurrentRecord(hwnd);
     2902              if(pci && (INT)pci != -1) {
     2903                if(pci->attrFile & FILE_DIRECTORY) {
     2904                  if(pci->flags & RECFLAGS_UNDERENV)
     2905                    break;
     2906                  UnFlesh(hwnd,pci);
     2907                  if(driveflags[toupper(*pci->szFileName) - 'A'] & (DRIVE_INVALID |
     2908                                      DRIVE_NOPRESCAN)) {
     2909                    driveflags[toupper(*pci->szFileName) - 'A'] &= (DRIVE_IGNORE |
     2910                                      DRIVE_NOPRESCAN | DRIVE_NOLOADICONS |
     2911                                      DRIVE_NOLOADSUBJS | DRIVE_NOLOADLONGS);
     2912                    DriveFlagsOne(toupper(*pci->szFileName) - 'A');
     2913                    if(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_INVALID)
     2914                      pci->rc.hptrIcon = hptrDunno;
     2915                    else {
     2916                      if(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_CDROM)
     2917                        pci->rc.hptrIcon = hptrCDROM;
     2918                      else
     2919                        pci->rc.hptrIcon = (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_REMOVABLE) ?
     2920                                            hptrRemovable :
     2921                                            (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_REMOTE) ?
     2922                                            hptrRemote :
     2923                                            (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_ZIPSTREAM) ?
     2924                                            hptrZipstrm : hptrDrive;
     2925                    }
     2926                    WinSendMsg(hwnd,
     2927                               CM_INVALIDATERECORD,
     2928                               MPFROMP(&pci),
     2929                               MPFROM2SHORT(1,CMA_ERASE | CMA_REPOSITION));
     2930                    if(hwndMain)
     2931                      PostMsg(hwndMain,
     2932                              UM_BUILDDRIVES,
     2933                              MPVOID,
     2934                              MPVOID);
     2935                  }
     2936                  if(!(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_INVALID))
     2937                    Flesh(hwnd,pci);
     2938                }
     2939                else {
     2940
     2941                }
     2942              }
     2943            }
     2944            break;
     2945
     2946          case IDM_RESCAN:
     2947            PostMsg(dcd->hwndObject,
     2948                    UM_RESCAN,
     2949                    MPVOID,
     2950                    MPVOID);
     2951            break;
     2952
     2953          case IDM_RESORT:
     2954            WinSendMsg(hwnd,
     2955                       CM_SORTRECORD,
     2956                       MPFROMP(SortTreeCnr),
     2957                       MPVOID);
     2958            break;
     2959
     2960          case IDM_TEXT:
     2961          case IDM_MINIICONS:
     2962            {
     2963              CNRINFO cnri;
     2964
     2965              memset(&cnri,0,sizeof(CNRINFO));
     2966              cnri.cb = sizeof(CNRINFO);
     2967              WinSendMsg(hwnd,
     2968                        CM_QUERYCNRINFO,
     2969                        MPFROMP(&cnri),
     2970                        MPFROMLONG(sizeof(CNRINFO)));
     2971              if(SHORT1FROMMP(mp1) == IDM_MINIICONS) {
     2972                if(cnri.flWindowAttr & CV_MINI)
     2973                  cnri.flWindowAttr &= (~CV_MINI);
     2974                else
     2975                  cnri.flWindowAttr |= CV_MINI;
     2976              }
     2977              else {
     2978                if(cnri.flWindowAttr & CV_TEXT) {
     2979                  cnri.flWindowAttr &= (~CV_TEXT);
     2980                  cnri.flWindowAttr |= CV_ICON;
     2981                }
     2982                else {
     2983                  cnri.flWindowAttr &= (~CV_ICON);
     2984                  cnri.flWindowAttr |= CV_TEXT;
     2985                }
     2986              }
     2987              dcd->flWindowAttr = cnri.flWindowAttr;
     2988              PrfWriteProfileData(fmprof,
     2989                                  appname,
     2990                                  "TreeflWindowAttr",
     2991                                  &cnri.flWindowAttr,
     2992                                  sizeof(ULONG));
     2993              WinSendMsg(hwnd,
     2994                        CM_SETCNRINFO,
     2995                        MPFROMP(&cnri),
     2996                        MPFROMLONG(CMA_FLWINDOWATTR | CMA_TREEICON |
     2997                                    CMA_SLTREEBITMAPORICON));
     2998            }
     2999            break;
     3000
     3001          case IDM_SIZES:
     3002          case IDM_DRVFLAGS:
     3003          case IDM_SHOWALLFILES:
     3004          case IDM_UNDELETE:
     3005          case IDM_OPTIMIZE:
     3006          case IDM_CHKDSK:
     3007          case IDM_FORMAT:
     3008          case IDM_MKDIR:
     3009          case IDM_LOCK:
     3010          case IDM_UNLOCK:
     3011          case IDM_EJECT:
     3012          case IDM_CLOSETRAY:
     3013            {
     3014              PCNRITEM pci;
     3015
     3016              pci = (PCNRITEM)CurrentRecord(hwnd);
     3017              if(pci && (INT)pci != -1)
     3018                CommonDriveCmd(hwnd,
     3019                               pci->szFileName,
     3020                               SHORT1FROMMP(mp1));
     3021            }
     3022            break;
     3023
     3024          case IDM_SAVETOLIST:
     3025            WinDlgBox(HWND_DESKTOP,
     3026                      hwnd,
     3027                      SaveListDlgProc,
     3028                      FM3ModHandle,
     3029                      SAV_FRAME,
     3030                      MPFROMP(&hwnd));
     3031            break;
     3032
     3033          case IDM_DELETE:
     3034          case IDM_PERMDELETE:
     3035          case IDM_MOVE:
     3036          case IDM_WPSMOVE:
     3037          case IDM_WILDMOVE:
     3038          case IDM_RENAME:
     3039            {
     3040              PCNRITEM pci;
     3041
     3042              pci = (PCNRITEM)CurrentRecord(hwnd);
     3043              if(pci && (INT)pci != -1) {
     3044                if(pci->flags & RECFLAGS_UNDERENV)
     3045                  break;
     3046              }
     3047            }
     3048            /* else intentional fallthru */
     3049          case IDM_ATTRS:
     3050          case IDM_INFO:
     3051          case IDM_COPY:
     3052          case IDM_WPSCOPY:
     3053          case IDM_WILDCOPY:
     3054          case IDM_DOITYOURSELF:
     3055          case IDM_OPENWINDOW:
     3056          case IDM_OPENSETTINGS:
     3057          case IDM_OPENDEFAULT:
     3058          case IDM_OPENICON:
     3059          case IDM_OPENDETAILS:
     3060          case IDM_OPENTREE:
     3061          case IDM_SHADOW:
     3062          case IDM_SHADOW2:
     3063          case IDM_COMPARE:
     3064          case IDM_VIEW:
     3065          case IDM_VIEWTEXT:
     3066          case IDM_VIEWBINARY:
     3067          case IDM_EDIT:
     3068          case IDM_EDITTEXT:
     3069          case IDM_EDITBINARY:
     3070          case IDM_EAS:
     3071          case IDM_SUBJECT:
     3072          case IDM_APPENDTOCLIP:
     3073          case IDM_SAVETOCLIP:
     3074          case IDM_ARCHIVE:
     3075          case IDM_MCIPLAY:
     3076          case IDM_UUDECODE:
     3077            {
     3078              LISTINFO *li;
     3079              ULONG     action = UM_ACTION;
     3080
     3081              li = malloc(sizeof(LISTINFO));
     3082              if(li) {
     3083                memset(li,0,sizeof(LISTINFO));
     3084                li->type = SHORT1FROMMP(mp1);
     3085                li->hwnd = hwnd;
     3086                li->list = BuildList(hwnd);
     3087                if(!li->list || !li->list[0]) {
     3088                  free(li);
     3089                  break;
     3090                }
     3091                if(IsRoot(li->list[0])) {
     3092                  switch(SHORT1FROMMP(mp1)) {
     3093                    case IDM_MOVE:
     3094                    case IDM_COPY:
     3095                    case IDM_WILDCOPY:
     3096                    case IDM_WILDMOVE:
     3097                    case IDM_WPSMOVE:
     3098                    case IDM_WPSCOPY:
     3099                    case IDM_RENAME:
     3100                    case IDM_DELETE:
     3101                    case IDM_PERMDELETE:
     3102                      mp1 = MPFROM2SHORT(IDM_INFO,SHORT2FROMMP(mp1));
     3103                      li->type = IDM_INFO;
     3104                      break;
     3105                  }
     3106                }
     3107                switch(SHORT1FROMMP(mp1)) {
     3108                  case IDM_APPENDTOCLIP:
     3109                  case IDM_SAVETOCLIP:
     3110                  case IDM_ARCHIVE:
     3111                  case IDM_DELETE:
     3112                  case IDM_PERMDELETE:
     3113                  case IDM_ATTRS:
     3114                  case IDM_SHADOW:
     3115                  case IDM_SHADOW2:
     3116                  case IDM_DOITYOURSELF:
     3117                  case IDM_EAS:
     3118                  case IDM_VIEW:
     3119                  case IDM_VIEWTEXT:
     3120                  case IDM_VIEWBINARY:
     3121                  case IDM_EDIT:
     3122                  case IDM_EDITTEXT:
     3123                  case IDM_EDITBINARY:
     3124                  case IDM_MCIPLAY:
     3125                    action = UM_MASSACTION;
     3126                    break;
     3127                }
     3128                if(SHORT1FROMMP(mp1) == IDM_SHADOW ||
     3129                   SHORT1FROMMP(mp1) == IDM_SHADOW2)
     3130                  *li->targetpath = 0;
     3131                if(!PostMsg(dcd->hwndObject,action,MPFROMP(li),MPVOID)) {
     3132                  FreeListInfo(li);
     3133                  DosBeep(50,100);
     3134                }
     3135              }
     3136            }
     3137            break;
     3138
     3139          default:
     3140            if(SHORT1FROMMP(mp1) >= IDM_COMMANDSTART &&
     3141               SHORT1FROMMP(mp1) < IDM_QUICKTOOLSTART) {
     3142
     3143              INT  x;
     3144
     3145              if(!cmdloaded)
     3146                load_commands();
     3147              x = SHORT1FROMMP(mp1) - IDM_COMMANDSTART;
     3148              if(x >= 0) {
     3149                x++;
     3150                RunCommand(hwnd,x);
     3151                if(fUnHilite)
     3152                  UnHilite(hwnd,TRUE,&dcd->lastselection);
     3153              }
     3154            }
     3155            break;
     3156        }
    31393157      }
    31403158      return 0;
    … …  
    31433161      if(dcd && !ParentIsDesktop(hwnd,dcd->hwndParent)) {
    31443162
    3145         SWP swp,swpP;
    3146         INT ratio;
    3147 
    3148         WinQueryWindowPos(dcd->hwndFrame,&swp);
    3149         if(!(swp.fl & (SWP_MINIMIZE | SWP_MAXIMIZE | SWP_HIDE))) {
    3150           WinQueryWindowPos(dcd->hwndParent,&swpP);
    3151           ratio = (swpP.cx * 100) / swp.cx;
    3152           if(ratio > 0)
    3153             PrfWriteProfileData(fmprof,appname,"TreeWindowRatio",
    3154                                 &ratio,sizeof(INT));
    3155         }
     3163        SWP swp,swpP;
     3164        INT ratio;
     3165
     3166        WinQueryWindowPos(dcd->hwndFrame,&swp);
     3167        if(!(swp.fl & (SWP_MINIMIZE | SWP_MAXIMIZE | SWP_HIDE))) {
     3168          WinQueryWindowPos(dcd->hwndParent,&swpP);
     3169          ratio = (swpP.cx * 100) / swp.cx;
     3170          if(ratio > 0)
     3171            PrfWriteProfileData(fmprof,appname,"TreeWindowRatio",
     3172                                &ratio,sizeof(INT));
     3173        }
    31563174      }
    31573175      else if(dcd && ParentIsDesktop(hwnd,dcd->hwndParent)) {
    31583176
    3159         SWP swp;
    3160 
    3161         WinQueryWindowPos(dcd->hwndFrame,&swp);
    3162         if(!(swp.fl & (SWP_HIDE | SWP_MINIMIZE | SWP_MAXIMIZE)))
    3163           WinStoreWindowPos(FM2Str,"VTreeWindowPos",dcd->hwndFrame);
     3177        SWP swp;
     3178
     3179        WinQueryWindowPos(dcd->hwndFrame,&swp);
     3180        if(!(swp.fl & (SWP_HIDE | SWP_MINIMIZE | SWP_MAXIMIZE)))
     3181          WinStoreWindowPos(FM2Str,"VTreeWindowPos",dcd->hwndFrame);
    31643182      }
    31653183      break;
    … …  
    31673185    case UM_MINIMIZE:
    31683186      if(dcd && hwndMain) {
    3169         fOkayMinimize = TRUE;
    3170         if(dcd->hwndObject && !fDummy) {
    3171           DosSleep(100L);
    3172           if(!fDummy) {
    3173             fOkayMinimize = FALSE;
    3174             WinSetWindowPos(((hwndMain) ? WinQueryWindow(hwndMain,QW_PARENT) :
    3175                              dcd->hwndFrame),HWND_TOP,0,0,0,0,SWP_MINIMIZE |
    3176                              SWP_DEACTIVATE);
    3177           }
    3178         }
     3187        fOkayMinimize = TRUE;
     3188        if(dcd->hwndObject && !fDummy) {
     3189          DosSleep(100L);
     3190          if(!fDummy) {
     3191            fOkayMinimize = FALSE;
     3192            WinSetWindowPos(((hwndMain) ? WinQueryWindow(hwndMain,QW_PARENT) :
     3193                             dcd->hwndFrame),HWND_TOP,0,0,0,0,SWP_MINIMIZE |
     3194                             SWP_DEACTIVATE);
     3195          }
     3196        }
    31793197      }
    31803198      return 0;
    … …  
    31823200    case UM_MAXIMIZE:
    31833201      if(dcd || hwndMain)
    3184         WinSetWindowPos(((hwndMain) ? WinQueryWindow(hwndMain,QW_PARENT) :
    3185                         dcd->hwndFrame),HWND_TOP,0,0,0,0,SWP_MAXIMIZE |
    3186                         SWP_SHOW);
     3202        WinSetWindowPos(((hwndMain) ? WinQueryWindow(hwndMain,QW_PARENT) :
     3203                        dcd->hwndFrame),HWND_TOP,0,0,0,0,SWP_MAXIMIZE |
     3204                        SWP_SHOW);
    31873205      return 0;
    31883206
    31893207    case UM_CLOSE:
    31903208      {
    3191         HWND hwndParent = WinQueryWindow(WinQueryWindow(WinQueryWindow(hwnd,
    3192                                         QW_PARENT),QW_PARENT),QW_PARENT);
    3193 
    3194         if(!mp1) {
    3195           if(!PostMsg((HWND)0,WM_QUIT,MPVOID,MPVOID))
    3196             WinSendMsg((HWND)0,WM_QUIT,MPVOID,MPVOID);
    3197           if(hwndParent && !ParentIsDesktop(hwnd,hwndParent))
    3198             WinDestroyWindow(hwndParent);
    3199         }
    3200         else
    3201           WinDestroyWindow(WinQueryWindow(WinQueryWindow(hwnd,QW_PARENT),
    3202                            QW_PARENT));
     3209        HWND hwndParent = WinQueryWindow(WinQueryWindow(WinQueryWindow(hwnd,
     3210                                        QW_PARENT),QW_PARENT),QW_PARENT);
     3211
     3212        if(!mp1) {
     3213          if(!PostMsg((HWND)0,WM_QUIT,MPVOID,MPVOID))
     3214            WinSendMsg((HWND)0,WM_QUIT,MPVOID,MPVOID);
     3215          if(hwndParent && !ParentIsDesktop(hwnd,hwndParent))
     3216            WinDestroyWindow(hwndParent);
     3217        }
     3218        else
     3219          WinDestroyWindow(WinQueryWindow(WinQueryWindow(hwnd,QW_PARENT),
     3220                           QW_PARENT));
    32033221      }
    32043222      return 0;
    … …  
    32073225      WinSendMsg(hwnd,WM_SAVEAPPLICATION,MPVOID,MPVOID);
    32083226      if(dcd)
    3209         dcd->stopflag++;
     3227        dcd->stopflag++;
    32103228      if(dcd && dcd->hwndObject) {
    3211         /* kill object window */
    3212         if(!PostMsg(dcd->hwndObject,WM_CLOSE,MPVOID,MPVOID))
    3213           WinSendMsg(dcd->hwndObject,WM_CLOSE,MPVOID,MPVOID);
     3229        /* kill object window */
     3230        if(!PostMsg(dcd->hwndObject,WM_CLOSE,MPVOID,MPVOID))
     3231          WinSendMsg(dcd->hwndObject,WM_CLOSE,MPVOID,MPVOID);
    32143232      }
    32153233      else
    3216         WinSendMsg(hwnd,UM_CLOSE,MPFROMLONG(1L),MPVOID);
     3234        WinSendMsg(hwnd,UM_CLOSE,MPFROMLONG(1L),MPVOID);
    32173235      return 0;
    32183236
    32193237    case WM_DESTROY:
    32203238      if(TreeCnrMenu)
    3221         WinDestroyWindow(TreeCnrMenu);
     3239        WinDestroyWindow(TreeCnrMenu);
    32223240      if(DirMenu)
    3223         WinDestroyWindow(DirMenu);
     3241        WinDestroyWindow(DirMenu);
    32243242      if(FileMenu)
    3225         WinDestroyWindow(FileMenu);
     3243        WinDestroyWindow(FileMenu);
    32263244      TreeCnrMenu = FileMenu = DirMenu = (HWND)0;
    32273245      EmptyCnr(hwnd);
    32283246      if(apphead) {
    32293247
    3230         APPNOTIFY *info,*next;
    3231 
    3232         info = apphead;
    3233         while(info) {
    3234           next = info->next;
    3235           free(info);
    3236           info = next;
    3237         }
    3238         apphead = apptail = NULL;
     3248        APPNOTIFY *info,*next;
     3249
     3250        info = apphead;
     3251        while(info) {
     3252          next = info->next;
     3253          free(info);
     3254          info = next;
     3255        }
     3256        apphead = apptail = NULL;
    32393257      }
    32403258      break;
    32413259  }
    32423260  return (dcd && dcd->oldproc) ? dcd->oldproc(hwnd,msg,mp1,mp2) :
    3243                                 PFNWPCnr(hwnd,msg,mp1,mp2);
     3261                                PFNWPCnr(hwnd,msg,mp1,mp2);
    32443262}
    32453263
    … …  
    32543272  HWND          hwndFrame = (HWND)0,hwndClient;
    32553273  ULONG         FrameFlags = FCF_TITLEBAR   | FCF_SYSMENU     |
    3256                              FCF_SIZEBORDER | FCF_MINMAX      |
    3257                              FCF_ICON       | FCF_NOBYTEALIGN |
    3258                              FCF_ACCELTABLE;
     3274                             FCF_SIZEBORDER | FCF_MINMAX      |
     3275                             FCF_ICON       | FCF_NOBYTEALIGN |
     3276                             FCF_ACCELTABLE;
    32593277  DIRCNRDATA   *dcd;
    32603278
    … …  
    32653283  if(flags & 2)
    32663284    FrameFlags &= (~(FCF_TITLEBAR | FCF_SYSMENU | FCF_SIZEBORDER |
    3267                      FCF_MINMAX   | FCF_ICON));
     3285                     FCF_MINMAX   | FCF_ICON));
    32683286  hwndFrame = WinCreateStdWindow(hwndParent,
    3269                                 WS_VISIBLE,
    3270                                 &FrameFlags,
    3271                                 GetPString(IDS_WCTREECONTAINER),
    3272                                 NULL,
    3273                                 WS_VISIBLE | fwsAnimate,
    3274                                 FM3ModHandle,
    3275                                 TREE_FRAME,
    3276                                 &hwndClient);
     3287                                WS_VISIBLE,
     3288                                &FrameFlags,
     3289                                GetPString(IDS_WCTREECONTAINER),
     3290                                NULL,
     3291                                WS_VISIBLE | fwsAnimate,
     3292                                FM3ModHandle,
     3293                                TREE_FRAME,
     3294                                &hwndClient);
    32773295  if(hwndFrame && hwndClient) {
    32783296    dcd = malloc(sizeof(DIRCNRDATA));
    … …  
    32833301      WinQueryWindowPos(hwndFrame,&swp);
    32843302      if(*(ULONG *)realappname == FM3UL)
    3285         WinCreateWindow(hwndFrame,
    3286                         GetPString(IDS_WCTREEOPENBUTTON),
    3287                         "O",
    3288                         WS_VISIBLE | BS_PUSHBUTTON | BS_NOPOINTERFOCUS,
    3289                         ((swp.cx - WinQuerySysValue(HWND_DESKTOP,SV_CXMINMAXBUTTON)) -
    3290                         WinQuerySysValue(HWND_DESKTOP,SV_CXMINMAXBUTTON) / 2) -
    3291                         WinQuerySysValue(HWND_DESKTOP,SV_CXSIZEBORDER),
    3292                         (swp.cy - WinQuerySysValue(HWND_DESKTOP,SV_CYMINMAXBUTTON)) -
    3293                         WinQuerySysValue(HWND_DESKTOP,SV_CYSIZEBORDER),
    3294                         WinQuerySysValue(HWND_DESKTOP,SV_CXMINMAXBUTTON) / 2,
    3295                         WinQuerySysValue(HWND_DESKTOP,SV_CYMINMAXBUTTON),
    3296                         hwndFrame,
    3297                         HWND_TOP,
    3298                         IDM_OPENWINDOW,
    3299                         NULL,
    3300                         NULL);
     3303        WinCreateWindow(hwndFrame,
     3304                        GetPString(IDS_WCTREEOPENBUTTON),
     3305                        "O",
     3306                        WS_VISIBLE | BS_PUSHBUTTON | BS_NOPOINTERFOCUS,
     3307                        ((swp.cx - WinQuerySysValue(HWND_DESKTOP,SV_CXMINMAXBUTTON)) -
     3308                        WinQuerySysValue(HWND_DESKTOP,SV_CXMINMAXBUTTON) / 2) -
     3309                        WinQuerySysValue(HWND_DESKTOP,SV_CXSIZEBORDER),
     3310                        (swp.cy - WinQuerySysValue(HWND_DESKTOP,SV_CYMINMAXBUTTON)) -
     3311                        WinQuerySysValue(HWND_DESKTOP,SV_CYSIZEBORDER),
     3312                        WinQuerySysValue(HWND_DESKTOP,SV_CXMINMAXBUTTON) / 2,
     3313                        WinQuerySysValue(HWND_DESKTOP,SV_CYMINMAXBUTTON),
     3314                        hwndFrame,
     3315                        HWND_TOP,
     3316                        IDM_OPENWINDOW,
     3317                        NULL,
     3318                        NULL);
    33013319      else
    3302         WinCreateWindow(hwndFrame,
    3303                         GetPString(IDS_WCTREESTATUS),
    3304                         GetPString(IDS_YOUAREHERETEXT),
    3305                         WS_VISIBLE | SS_TEXT | DT_LEFT | DT_VCENTER,
    3306                         swp.x + 4 + WinQuerySysValue(HWND_DESKTOP,
    3307                                                      SV_CXSIZEBORDER),
    3308                         swp.cy - (22 + WinQuerySysValue(HWND_DESKTOP,
    3309                                                         SV_CYSIZEBORDER)),
    3310                         (swp.cx  - 8) - (WinQuerySysValue(HWND_DESKTOP,
    3311                                               SV_CXSIZEBORDER) * 2),
    3312                         22,
    3313                         hwndFrame,
    3314                         HWND_TOP,
    3315                         MAIN_STATUS,
    3316                         NULL,
    3317                         NULL);
     3320        WinCreateWindow(hwndFrame,
     3321                        GetPString(IDS_WCTREESTATUS),
     3322                        GetPString(IDS_YOUAREHERETEXT),
     3323                        WS_VISIBLE | SS_TEXT | DT_LEFT | DT_VCENTER,
     3324                        swp.x + 4 + WinQuerySysValue(HWND_DESKTOP,
     3325                                                     SV_CXSIZEBORDER),
     3326                        swp.cy - (22 + WinQuerySysValue(HWND_DESKTOP,
     3327                                                        SV_CYSIZEBORDER)),
     3328                        (swp.cx  - 8) - (WinQuerySysValue(HWND_DESKTOP,
     3329                                              SV_CXSIZEBORDER) * 2),
     3330                        22,
     3331                        hwndFrame,
     3332                        HWND_TOP,
     3333                        MAIN_STATUS,
     3334                        NULL,
     3335                        NULL);
    33183336      memset(dcd,0,sizeof(DIRCNRDATA));
    33193337      dcd->size = sizeof(DIRCNRDATA);
    … …  
    33243342      dcd->hwndFrame  = hwndFrame;
    33253343      {
    3326         PFNWP oldproc;
    3327 
    3328         oldproc = WinSubclassWindow(hwndFrame,(PFNWP)TreeFrameWndProc);
    3329         WinSetWindowPtr(hwndFrame,0,(PVOID)oldproc);
    3330         oldproc = WinSubclassWindow(WinWindowFromID(hwndFrame,FID_TITLEBAR),
    3331                                     (PFNWP)TreeTitleWndProc);
    3332         WinSetWindowPtr(WinWindowFromID(hwndFrame,FID_TITLEBAR),0,
    3333                         (PVOID)oldproc);
     3344        PFNWP oldproc;
     3345
     3346        oldproc = WinSubclassWindow(hwndFrame,(PFNWP)TreeFrameWndProc);
     3347        WinSetWindowPtr(hwndFrame,0,(PVOID)oldproc);
     3348        oldproc = WinSubclassWindow(WinWindowFromID(hwndFrame,FID_TITLEBAR),
     3349                                    (PFNWP)TreeTitleWndProc);
     3350        WinSetWindowPtr(WinWindowFromID(hwndFrame,FID_TITLEBAR),0,
     3351                        (PVOID)oldproc);
    33343352      }
    33353353      dcd->hwndCnr = WinCreateWindow(hwndClient,
    3336                                      WC_CONTAINER,
    3337                                      NULL,
    3338                                      CCS_AUTOPOSITION | CCS_MINIICONS |
    3339                                      CCS_MINIRECORDCORE | WS_VISIBLE,
    3340                                      0,
    3341                                      0,
    3342                                      0,
    3343                                      0,
    3344                                      hwndClient,
    3345                                      HWND_TOP,
    3346                                      (ULONG)TREE_CNR,
    3347                                      NULL,
    3348                                      NULL);
     3354                                     WC_CONTAINER,
     3355                                     NULL,
     3356                                     CCS_AUTOPOSITION | CCS_MINIICONS |
     3357                                     CCS_MINIRECORDCORE | WS_VISIBLE,
     3358                                     0,
     3359                                     0,
     3360                                     0,
     3361                                     0,
     3362                                     hwndClient,
     3363                                     HWND_TOP,
     3364                                     (ULONG)TREE_CNR,
     3365                                     NULL,
     3366                                     NULL);
    33493367      if(dcd->hwndCnr) {
    3350         WinSetWindowPtr(dcd->hwndCnr,0,(PVOID)dcd);
    3351         if(ParentIsDesktop(hwndFrame,hwndParent)) {
    3352           WinSetWindowText(WinWindowFromID(hwndFrame,FID_TITLEBAR),"VTree");
    3353           FixSwitchList(hwndFrame,"VTree");
    3354         }
    3355         else {
    3356           WinSetWindowText(hwndFrame,GetPString(IDS_TREETEXT));
    3357           WinSetWindowText(WinWindowFromID(hwndFrame,FID_TITLEBAR),
    3358                            GetPString(IDS_TREETEXT));
    3359         }
    3360         dcd->oldproc = WinSubclassWindow(dcd->hwndCnr,(PFNWP)TreeCnrWndProc);
    3361         if(!PostMsg(dcd->hwndCnr,UM_SETUP,MPVOID,MPVOID))
    3362           WinSendMsg(dcd->hwndCnr,UM_SETUP,MPVOID,MPVOID);
     3368        WinSetWindowPtr(dcd->hwndCnr,0,(PVOID)dcd);
     3369        if(ParentIsDesktop(hwndFrame,hwndParent)) {
     3370          WinSetWindowText(WinWindowFromID(hwndFrame,FID_TITLEBAR),"VTree");
     3371          FixSwitchList(hwndFrame,"VTree");
     3372        }
     3373        else {
     3374          WinSetWindowText(hwndFrame,GetPString(IDS_TREETEXT));
     3375          WinSetWindowText(WinWindowFromID(hwndFrame,FID_TITLEBAR),
     3376                           GetPString(IDS_TREETEXT));
     3377        }
     3378        dcd->oldproc = WinSubclassWindow(dcd->hwndCnr,(PFNWP)TreeCnrWndProc);
     3379        if(!PostMsg(dcd->hwndCnr,UM_SETUP,MPVOID,MPVOID))
     3380          WinSendMsg(dcd->hwndCnr,UM_SETUP,MPVOID,MPVOID);
    33633381      }
    33643382      else {
    3365         PostMsg(hwndClient,WM_CLOSE,MPVOID,MPVOID);
    3366         free(dcd);
    3367         hwndFrame = (HWND)0;
     3383        PostMsg(hwndClient,WM_CLOSE,MPVOID,MPVOID);
     3384        free(dcd);
     3385        hwndFrame = (HWND)0;
    33683386      }
    33693387    }
    33703388    else {
    33713389      saymsg(MB_ENTER,hwndParent,DEBUG_STRING,
    3372              GetPString(IDS_OUTOFMEMORY));
     3390             GetPString(IDS_OUTOFMEMORY));
    33733391      PostMsg(hwndClient,WM_CLOSE,MPVOID,MPVOID);
    33743392      hwndFrame = (HWND)0;
Note: See TracChangeset for help on using the changeset viewer.