Changeset 551 for trunk/dll/treecnr.c


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

Indentation cleanup

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/dll/treecnr.c

    r549 r551  
    5252#pragma alloc_text(STARTUP,StartTreeCnr)
    5353
    54 APIRET16 APIENTRY16 Dos16MemAvail (PULONG pulAvailMem);
    55 
    56 typedef struct APPNOTIFY {
    57   HAPP              happ;
    58   CHAR              device;
     54APIRET16 APIENTRY16 Dos16MemAvail(PULONG pulAvailMem);
     55
     56typedef struct APPNOTIFY
     57{
     58  HAPP happ;
     59  CHAR device;
    5960  struct APPNOTIFY *next;
    6061  struct APPNOTIFY *prev;
    61 } APPNOTIFY;
    62 
    63 
    64 MRESULT EXPENTRY OpenButtonProc (HWND hwnd,ULONG msg,MPARAM mp1,MPARAM mp2)
     62}
     63APPNOTIFY;
     64
     65MRESULT EXPENTRY OpenButtonProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
    6566{
    6667  static BOOL emphasized = FALSE;
    6768
    68   switch(msg) {
    69     case WM_CREATE:
    70       {
    71         MRESULT rc;
    72 
    73         rc = PFNWPButton(hwnd,msg,mp1,mp2);
    74         WinSetPresParam(hwnd,PP_FONTNAMESIZE,
    75                         strlen(GetPString(IDS_8TIMESNEWROMANTEXT)) + 1,
    76                         (PVOID)GetPString(IDS_8TIMESNEWROMANTEXT));
    77         return rc;
    78       }
    79 
    80     case WM_MOUSEMOVE:
    81       BubbleHelp(hwnd,
    82                  TRUE,
    83                  FALSE,
    84                  TRUE,
    85                  GetPString(IDS_OPENBUTTONHELP));
    86       break;
    87 
    88     case WM_CONTEXTMENU:
    89       PostMsg(WinQueryWindow(hwnd,QW_PARENT),
    90               WM_COMMAND,
    91               MPFROM2SHORT(IDM_OPENWALK,0),
    92               MPVOID);
    93       return 0;
    94 
    95     case DM_DRAGOVER:
    96       if(!emphasized) {
    97         emphasized = TRUE;
    98         EmphasizeButton(hwnd,emphasized);
    99       }
    100       if(AcceptOneDrop(mp1,mp2))
    101         return MRFROM2SHORT(DOR_DROP,
    102                             DO_MOVE);
    103       return MRFROM2SHORT(DOR_NEVERDROP,0);
    104 
    105     case DM_DRAGLEAVE:
    106       if(emphasized) {
     69  switch (msg) {
     70  case WM_CREATE:
     71    {
     72      MRESULT rc;
     73
     74      rc = PFNWPButton(hwnd, msg, mp1, mp2);
     75      WinSetPresParam(hwnd, PP_FONTNAMESIZE,
     76                      strlen(GetPString(IDS_8TIMESNEWROMANTEXT)) + 1,
     77                      (PVOID) GetPString(IDS_8TIMESNEWROMANTEXT));
     78      return rc;
     79    }
     80
     81  case WM_MOUSEMOVE:
     82    BubbleHelp(hwnd, TRUE, FALSE, TRUE, GetPString(IDS_OPENBUTTONHELP));
     83    break;
     84
     85  case WM_CONTEXTMENU:
     86    PostMsg(WinQueryWindow(hwnd, QW_PARENT),
     87            WM_COMMAND, MPFROM2SHORT(IDM_OPENWALK, 0), MPVOID);
     88    return 0;
     89
     90  case DM_DRAGOVER:
     91    if (!emphasized) {
     92      emphasized = TRUE;
     93      EmphasizeButton(hwnd, emphasized);
     94    }
     95    if (AcceptOneDrop(mp1, mp2))
     96      return MRFROM2SHORT(DOR_DROP, DO_MOVE);
     97    return MRFROM2SHORT(DOR_NEVERDROP, 0);
     98
     99  case DM_DRAGLEAVE:
     100    if (emphasized) {
     101      emphasized = FALSE;
     102      EmphasizeButton(hwnd, emphasized);
     103    }
     104    break;
     105
     106  case DM_DROPHELP:
     107    DropHelp(mp1, mp2, hwnd, GetPString(IDS_OPENDROPHELP));
     108    return 0;
     109
     110  case DM_DROP:
     111    {
     112      char szFrom[CCHMAXPATH + 2];
     113
     114      if (emphasized) {
    107115        emphasized = FALSE;
    108         EmphasizeButton(hwnd,emphasized);
    109       }
    110       break;
    111 
    112     case DM_DROPHELP:
    113       DropHelp(mp1,mp2,hwnd,GetPString(IDS_OPENDROPHELP));
    114       return 0;
    115 
    116     case DM_DROP:
    117       {
    118         char szFrom[CCHMAXPATH + 2];
    119 
    120         if(emphasized) {
    121           emphasized = FALSE;
    122           EmphasizeButton(hwnd,emphasized);
    123         }
    124         if(GetOneDrop(mp1,mp2,szFrom,sizeof(szFrom))) {
    125           MakeValidDir(szFrom);
    126           WinSendMsg(WinQueryWindow(hwnd,QW_PARENT),
    127                      UM_OPENWINDOWFORME,
    128                      MPFROMP(szFrom),
    129                      MPVOID);
    130         }
    131       }
    132       return 0;
     116        EmphasizeButton(hwnd, emphasized);
     117      }
     118      if (GetOneDrop(mp1, mp2, szFrom, sizeof(szFrom))) {
     119        MakeValidDir(szFrom);
     120        WinSendMsg(WinQueryWindow(hwnd, QW_PARENT),
     121                   UM_OPENWINDOWFORME, MPFROMP(szFrom), MPVOID);
     122      }
     123    }
     124    return 0;
    133125
    134126  }
    135   return PFNWPButton(hwnd,msg,mp1,mp2);
     127  return PFNWPButton(hwnd, msg, mp1, mp2);
    136128}
    137129
    138 
    139 VOID ShowTreeRec (HWND hwndCnr,CHAR *dirname,BOOL collapsefirst,BOOL maketop)
     130VOID ShowTreeRec(HWND hwndCnr, CHAR * dirname, BOOL collapsefirst,
     131                 BOOL maketop)
    140132{
    141133  /* Find a record in tree view, move it so it shows in container and
    142134     make it the current record */
    143135
    144   PCNRITEM        pci,pciToSelect,pciP;
    145   BOOL            quickbail = FALSE;
    146   CHAR            szDir[CCHMAXPATH],*p;
     136  PCNRITEM pci, pciToSelect, pciP;
     137  BOOL quickbail = FALSE;
     138  CHAR szDir[CCHMAXPATH], *p;
    147139
    148140  /* is it already the current record? */
    149141  pci = WinSendMsg(hwndCnr,
    150142                   CM_QUERYRECORDEMPHASIS,
    151                    MPFROMLONG(CMA_FIRST),
    152                    MPFROMSHORT(CRA_CURSORED));
    153   if(pci &&
    154      (INT)pci != -1 &&
    155      !stricmp(pci->szFileName,dirname)) {
     143                   MPFROMLONG(CMA_FIRST), MPFROMSHORT(CRA_CURSORED));
     144  if (pci && (INT) pci != -1 && !stricmp(pci->szFileName, dirname)) {
    156145    quickbail = TRUE;
    157     goto MakeTop; /* skip lookup bullsh*t */
     146    goto MakeTop;                       /* skip lookup bullsh*t */
    158147  }
    159   WinEnableWindowUpdate(hwndCnr,FALSE);
    160   pci = FindCnrRecord(hwndCnr,
    161                       dirname,
    162                       NULL,
    163                       TRUE,
    164                       FALSE,
    165                       TRUE);
    166   if(!pci || (INT)pci == -1) {
    167     *szDir   = *dirname;
     148  WinEnableWindowUpdate(hwndCnr, FALSE);
     149  pci = FindCnrRecord(hwndCnr, dirname, NULL, TRUE, FALSE, TRUE);
     150  if (!pci || (INT) pci == -1) {
     151    *szDir = *dirname;
    168152    szDir[1] = ':';
    169153    szDir[2] = '\\';
    170154    szDir[3] = 0;
    171155    p = szDir + 3;
    172     for(;;) {
    173       pciP = FindCnrRecord(hwndCnr,
    174                            szDir,
    175                            NULL,
    176                            TRUE,
    177                            FALSE,
    178                            TRUE);
    179       if(pciP &&
    180          (INT)pciP != -1) {
    181         if(!stricmp(dirname,pciP->szFileName))
     156    for (;;) {
     157      pciP = FindCnrRecord(hwndCnr, szDir, NULL, TRUE, FALSE, TRUE);
     158      if (pciP && (INT) pciP != -1) {
     159        if (!stricmp(dirname, pciP->szFileName))
    182160          break;
    183         if(!(pciP->rc.flRecordAttr & CRA_EXPANDED))
    184           WinSendMsg(hwndCnr,
    185                      CM_EXPANDTREE,
    186                      MPFROMP(pciP),
    187                      MPVOID);
    188         strcpy(szDir,dirname);
    189         if(p - szDir >= strlen(szDir))
     161        if (!(pciP->rc.flRecordAttr & CRA_EXPANDED))
     162          WinSendMsg(hwndCnr, CM_EXPANDTREE, MPFROMP(pciP), MPVOID);
     163        strcpy(szDir, dirname);
     164        if (p - szDir >= strlen(szDir))
    190165          break;
    191         p = strchr(p,'\\');
    192         if(p) {
     166        p = strchr(p, '\\');
     167        if (p) {
    193168          *p = 0;
    194169          p++;
    … …  
    201176      DosSleep(0L);
    202177    }
    203     pci = FindCnrRecord(hwndCnr,
    204                         dirname,
    205                         NULL,
    206                         TRUE,
    207                         FALSE,
    208                         TRUE);
     178    pci = FindCnrRecord(hwndCnr, dirname, NULL, TRUE, FALSE, TRUE);
    209179  }
    210   if(pci &&
    211      (INT)pci != -1) {
    212     if(!(pci->rc.flRecordAttr & CRA_CURSORED)) {
    213       if(collapsefirst) {
     180  if (pci && (INT) pci != -1) {
     181    if (!(pci->rc.flRecordAttr & CRA_CURSORED)) {
     182      if (collapsefirst) {
    214183        /* collapse top level of all branches */
    215184        pciP = WinSendMsg(hwndCnr,
    216185                          CM_QUERYRECORD,
    217                           MPVOID,
    218                           MPFROM2SHORT(CMA_FIRST,CMA_ITEMORDER));
    219         while(pciP && (INT)pciP != -1) {
    220           if(toupper(*pciP->szFileName) == toupper(*dirname))
     186                          MPVOID, MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
     187        while (pciP && (INT) pciP != -1) {
     188          if (toupper(*pciP->szFileName) == toupper(*dirname))
    221189            /* collapse all levels if branch is our drive */
    222             ExpandAll(hwndCnr,
    223                       FALSE,
    224                       pciP);
    225           else if(pciP->rc.flRecordAttr & CRA_EXPANDED)
    226             WinSendMsg(hwndCnr,
    227                        CM_COLLAPSETREE,
    228                        MPFROMP(pciP),
    229                        MPVOID);
     190            ExpandAll(hwndCnr, FALSE, pciP);
     191          else if (pciP->rc.flRecordAttr & CRA_EXPANDED)
     192            WinSendMsg(hwndCnr, CM_COLLAPSETREE, MPFROMP(pciP), MPVOID);
    230193          pciP = WinSendMsg(hwndCnr,
    231194                            CM_QUERYRECORD,
    232195                            MPFROMP(pciP),
    233                             MPFROM2SHORT(CMA_NEXT,CMA_ITEMORDER));
     196                            MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
    234197        }
    235198      }
    236199      /* expand all parent branches */
    237200      pciToSelect = pci;
    238       for(;;) {
     201      for (;;) {
    239202        pciP = WinSendMsg(hwndCnr,
    240203                          CM_QUERYRECORD,
    241204                          MPFROMP(pciToSelect),
    242                           MPFROM2SHORT(CMA_PARENT,CMA_ITEMORDER));
    243         if(pciP && (INT)pciP != -1) {
    244           if(!(pciP->rc.flRecordAttr & CRA_EXPANDED))
    245             WinSendMsg(hwndCnr,
    246                        CM_EXPANDTREE,
    247                        MPFROMP(pciP),
    248                        MPVOID);
     205                          MPFROM2SHORT(CMA_PARENT, CMA_ITEMORDER));
     206        if (pciP && (INT) pciP != -1) {
     207          if (!(pciP->rc.flRecordAttr & CRA_EXPANDED))
     208            WinSendMsg(hwndCnr, CM_EXPANDTREE, MPFROMP(pciP), MPVOID);
    249209          pciToSelect = pciP;
    250210        }
    … …  
    255215    }
    256216    /* make record visible */
    257 MakeTop:
     217  MakeTop:
    258218    pciToSelect = pci;
    259     if(pciToSelect && (INT)pciToSelect != -1) {
    260       if(fTopDir || maketop)
    261         ShowCnrRecord(hwndCnr,
    262                       (PMINIRECORDCORE)pciToSelect);
    263       if(fSwitchTreeExpand &&
    264          !(pciToSelect->rc.flRecordAttr & CRA_EXPANDED))
    265         WinSendMsg(hwndCnr,
    266                    CM_EXPANDTREE,
    267                    MPFROMP(pciToSelect),
    268                    MPVOID);
    269       if(quickbail) {
    270         WinEnableWindowUpdate(hwndCnr,TRUE);
     219    if (pciToSelect && (INT) pciToSelect != -1) {
     220      if (fTopDir || maketop)
     221        ShowCnrRecord(hwndCnr, (PMINIRECORDCORE) pciToSelect);
     222      if (fSwitchTreeExpand && !(pciToSelect->rc.flRecordAttr & CRA_EXPANDED))
     223        WinSendMsg(hwndCnr, CM_EXPANDTREE, MPFROMP(pciToSelect), MPVOID);
     224      if (quickbail) {
     225        WinEnableWindowUpdate(hwndCnr, TRUE);
    271226        return;
    272227      }
    … …  
    274229                 CM_SETRECORDEMPHASIS,
    275230                 MPFROMP(pciToSelect),
    276                  MPFROM2SHORT(TRUE,CRA_SELECTED | CRA_CURSORED));
     231                 MPFROM2SHORT(TRUE, CRA_SELECTED | CRA_CURSORED));
    277232    }
    278233  }
    279   WinEnableWindowUpdate(hwndCnr,TRUE);
     234  WinEnableWindowUpdate(hwndCnr, TRUE);
    280235}
    281236
    282 
    283 MRESULT EXPENTRY TreeTitleWndProc (HWND hwnd,ULONG msg,MPARAM mp1,MPARAM mp2)
     237MRESULT EXPENTRY TreeTitleWndProc(HWND hwnd, ULONG msg, MPARAM mp1,
     238                                  MPARAM mp2)
    284239{
    285   PFNWP oldproc = (PFNWP)WinQueryWindowPtr(hwnd,QWL_USER);
    286 
    287   switch(msg) {
    288     case WM_CONTEXTMENU:
    289       return WinSendMsg(WinQueryWindow(hwnd,QW_PARENT),
    290                         UM_CONTEXTMENU,
    291                         mp1,
    292                         mp2);
     240  PFNWP oldproc = (PFNWP) WinQueryWindowPtr(hwnd, QWL_USER);
     241
     242  switch (msg) {
     243  case WM_CONTEXTMENU:
     244    return WinSendMsg(WinQueryWindow(hwnd, QW_PARENT),
     245                      UM_CONTEXTMENU, mp1, mp2);
    293246  }
    294   return oldproc(hwnd,msg,mp1,mp2);
     247  return oldproc(hwnd, msg, mp1, mp2);
    295248}
    296249
    297 
    298 MRESULT EXPENTRY TreeStatProc (HWND hwnd,ULONG msg,MPARAM mp1,MPARAM mp2)
     250MRESULT EXPENTRY TreeStatProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
    299251{
    300   switch(msg) {
    301     case WM_CREATE:
    302       return CommonTextProc(hwnd,msg,mp1,mp2);
    303 
    304     case WM_CONTEXTMENU:
    305       PostMsg(WinQueryWindow(hwnd,QW_PARENT),msg,mp1,mp2);
    306       return 0;
    307 
    308     case WM_PAINT:
     252  switch (msg) {
     253  case WM_CREATE:
     254    return CommonTextProc(hwnd, msg, mp1, mp2);
     255
     256  case WM_CONTEXTMENU:
     257    PostMsg(WinQueryWindow(hwnd, QW_PARENT), msg, mp1, mp2);
     258    return 0;
     259
     260  case WM_PAINT:
     261    {
     262      MRESULT mr = PFNWPStatic(hwnd, msg, mp1, mp2);
     263
     264      PaintRecessedWindow(hwnd, (HPS) 0, FALSE, FALSE);
     265      return mr;
     266    }
     267
     268  case WM_SETFOCUS:
     269    if (mp2)
     270      PostMsg(hwnd, UM_FOCUSME, MPVOID, MPVOID);
     271    break;
     272
     273  case UM_FOCUSME:
     274    WinSetFocus(HWND_DESKTOP, WinQueryWindow(hwnd, QW_PARENT));
     275    return 0;
     276  }
     277  return PFNWPStatic(hwnd, msg, mp1, mp2);
     278}
     279
     280MRESULT EXPENTRY TreeFrameWndProc(HWND hwnd, ULONG msg, MPARAM mp1,
     281                                  MPARAM mp2)
     282{
     283  switch (msg) {
     284  case UM_RESCAN:
     285    PostMsg(WinQueryWindow(hwnd, QW_PARENT), msg, mp1, mp2);
     286    return 0;
     287
     288  case WM_ADJUSTWINDOWPOS:
     289    {
     290      SWP *pswp;
     291
     292      pswp = (SWP *) mp1;
     293      if (ParentIsDesktop(hwnd, (HWND) 0)) {
     294        if (pswp->fl & (SWP_HIDE | SWP_MINIMIZE))
     295          HideNote();
     296      }
     297    }
     298    break;
     299
     300  case WM_TRACKFRAME:
     301    if (!fFreeTree && !ParentIsDesktop(hwnd, (HWND) 0)) {
     302      switch (SHORT1FROMMP(mp1) & TF_MOVE) {
     303      case TF_MOVE:
     304      case TF_LEFT:
     305      case TF_TOP:
     306      case (TF_LEFT | TF_BOTTOM):
     307      case (TF_LEFT | TF_TOP):
     308        {
     309          SWP swp;
     310
     311          WinQueryWindowPos(hwnd, &swp);
     312          if (!(swp.fl & SWP_ACTIVATE))
     313            WinSetWindowPos(hwnd, HWND_TOP, 0, 0, 0, 0,
     314                            SWP_ZORDER | SWP_ACTIVATE);
     315        }
     316        return 0;
     317      }
     318    }
     319    break;
     320
     321  case WM_CALCFRAMERECT:
     322    if (*(ULONG *) realappname != FM3UL) {
     323
     324      MRESULT mr;
     325      PRECTL prectl;
     326
     327      mr = CommonFrameWndProc(TREE_CNR, hwnd, msg, mp1, mp2);
     328
     329      /*
     330       * Calculate the position of the client rectangle.
     331       * Otherwise,  we'll see a lot of redraw when we move the
     332       * client during WM_FORMATFRAME.
     333       */
     334
     335      if (mr && mp2) {
     336        prectl = (PRECTL) mp1;
     337        prectl->yTop -= 22;
     338      }
     339      return mr;
     340    }
     341    break;
     342
     343  case WM_FORMATFRAME:
     344    {
     345      SHORT sCount;
     346      PSWP pswp, pswpClient, pswpNew;
     347
     348      sCount = (SHORT) CommonFrameWndProc(TREE_CNR, hwnd, msg, mp1, mp2);
     349
     350      /*
     351       * Reformat the frame to "squeeze" the client
     352       */
     353
     354      pswp = (PSWP) mp1;
    309355      {
    310         MRESULT mr = PFNWPStatic(hwnd,msg,mp1,mp2);
    311 
    312         PaintRecessedWindow(hwnd,(HPS)0,FALSE,FALSE);
    313         return mr;
    314       }
    315 
    316     case WM_SETFOCUS:
    317       if(mp2)
    318         PostMsg(hwnd,UM_FOCUSME,MPVOID,MPVOID);
    319       break;
    320 
    321     case UM_FOCUSME:
    322       WinSetFocus(HWND_DESKTOP,WinQueryWindow(hwnd,QW_PARENT));
    323       return 0;
     356        SHORT x;
     357
     358        for (x = 0; x < sCount; x++) {
     359          if (WinQueryWindowUShort(pswp->hwnd, QWS_ID) == FID_CLIENT) {
     360            pswpClient = pswp;
     361            break;
     362          }
     363          pswp++;
     364        }
     365      }
     366      pswpNew = (PSWP) mp1 + sCount;
     367      *pswpNew = *pswpClient;
     368      pswpNew->hwnd = WinWindowFromID(hwnd, MAIN_STATUS);
     369      if (*(ULONG *) realappname == FM3UL) {
     370
     371        PSWP pswpTitlebar = (PSWP) 0, pswpMinbutton = (PSWP) 0;
     372        SHORT x;
     373
     374        pswpNew->hwnd = WinWindowFromID(hwnd, IDM_OPENWINDOW);
     375        pswp = (PSWP) mp1;
     376        for (x = 0; x < sCount; x++) {
     377          if (WinQueryWindowUShort(pswp->hwnd, QWS_ID) == FID_TITLEBAR)
     378            pswpTitlebar = pswp;
     379          else if (WinQueryWindowUShort(pswp->hwnd, QWS_ID) == FID_MINMAX)
     380            pswpMinbutton = pswp;
     381          if (pswpTitlebar && pswpMinbutton)
     382            break;
     383          pswp++;
     384        }
     385        pswpNew->cy = pswpMinbutton->cy + 3;
     386        pswpNew->cx = min(pswpNew->cy, (pswpMinbutton->cx / 2) + 3);
     387        pswpTitlebar->cx -= (pswpNew->cx + 1);
     388        pswpNew->x = pswpTitlebar->x + pswpTitlebar->cx;
     389        pswpNew->y = pswpMinbutton->y - 1;
     390      }
     391      else {
     392        pswpNew->x = pswpClient->x + 3;
     393        pswpNew->y = (pswpClient->y + pswpClient->cy) - 20;
     394        pswpNew->cx = pswpClient->cx - 6;
     395        pswpNew->cy = 18;
     396        pswpClient->cy -= 22;
     397      }
     398      sCount++;
     399      return MRFROMSHORT(sCount);
     400    }
     401
     402  case WM_QUERYFRAMECTLCOUNT:
     403    {
     404      SHORT sCount;
     405
     406      sCount = (SHORT) CommonFrameWndProc(TREE_CNR, hwnd, msg, mp1, mp2);
     407      sCount++;
     408      return MRFROMSHORT(sCount);
     409    }
    324410  }
    325   return PFNWPStatic(hwnd,msg,mp1,mp2);
     411  return CommonFrameWndProc(TREE_CNR, hwnd, msg, mp1, mp2);
    326412}
    327413
    328 
    329 MRESULT EXPENTRY TreeFrameWndProc (HWND hwnd,ULONG msg,MPARAM mp1,MPARAM mp2)
     414MRESULT EXPENTRY TreeClientWndProc(HWND hwnd, ULONG msg, MPARAM mp1,
     415                                   MPARAM mp2)
    330416{
    331   switch(msg) {
    332     case UM_RESCAN:
    333       PostMsg(WinQueryWindow(hwnd,QW_PARENT),msg,mp1,mp2);
    334       return 0;
    335 
    336     case WM_ADJUSTWINDOWPOS:
    337       {
    338         SWP *pswp;
    339 
    340         pswp = (SWP *)mp1;
    341         if(ParentIsDesktop(hwnd,(HWND)0)) {
    342           if(pswp->fl & (SWP_HIDE | SWP_MINIMIZE))
    343             HideNote();
    344         }
    345       }
    346       break;
    347 
    348     case WM_TRACKFRAME:
    349       if(!fFreeTree && !ParentIsDesktop(hwnd,(HWND)0)) {
    350         switch(SHORT1FROMMP(mp1) & TF_MOVE) {
    351           case TF_MOVE:
    352           case TF_LEFT:
    353           case TF_TOP:
    354           case (TF_LEFT | TF_BOTTOM):
    355           case (TF_LEFT | TF_TOP):
    356             {
    357               SWP swp;
    358 
    359               WinQueryWindowPos(hwnd,&swp);
    360               if(!(swp.fl & SWP_ACTIVATE))
    361                 WinSetWindowPos(hwnd,HWND_TOP,0,0,0,0,
    362                                 SWP_ZORDER | SWP_ACTIVATE);
    363             }
    364             return 0;
    365         }
    366       }
    367       break;
    368 
    369     case WM_CALCFRAMERECT:
    370       if(*(ULONG *)realappname != FM3UL) {
    371 
    372         MRESULT mr;
    373         PRECTL  prectl;
    374 
    375         mr = CommonFrameWndProc(TREE_CNR,hwnd,msg,mp1,mp2);
    376 
    377         /*
    378          * Calculate the position of the client rectangle.
    379          * Otherwise,  we'll see a lot of redraw when we move the
    380          * client during WM_FORMATFRAME.
    381          */
    382 
    383         if(mr && mp2) {
    384           prectl = (PRECTL)mp1;
    385           prectl->yTop -= 22;
    386         }
    387         return mr;
    388       }
    389       break;
    390 
    391     case WM_FORMATFRAME:
    392       {
    393         SHORT sCount;
    394         PSWP  pswp,pswpClient,pswpNew;
    395 
    396         sCount = (SHORT)CommonFrameWndProc(TREE_CNR,hwnd,msg,mp1,mp2);
    397 
    398         /*
    399          * Reformat the frame to "squeeze" the client
    400          */
    401 
    402         pswp = (PSWP)mp1;
    403         {
    404           SHORT x;
    405 
    406           for(x = 0;x < sCount;x++) {
    407             if(WinQueryWindowUShort(pswp->hwnd,QWS_ID) == FID_CLIENT) {
    408               pswpClient = pswp;
    409               break;
    410             }
    411             pswp++;
    412           }
    413         }
    414         pswpNew = (PSWP)mp1 + sCount;
    415         *pswpNew = *pswpClient;
    416         pswpNew->hwnd = WinWindowFromID(hwnd,MAIN_STATUS);
    417         if(*(ULONG *)realappname == FM3UL) {
    418 
    419           PSWP  pswpTitlebar = (PSWP)0,pswpMinbutton = (PSWP)0;
    420           SHORT x;
    421 
    422           pswpNew->hwnd = WinWindowFromID(hwnd,IDM_OPENWINDOW);
    423           pswp = (PSWP)mp1;
    424           for(x = 0;x < sCount;x++) {
    425             if(WinQueryWindowUShort(pswp->hwnd,QWS_ID) == FID_TITLEBAR)
    426               pswpTitlebar = pswp;
    427             else if(WinQueryWindowUShort(pswp->hwnd,QWS_ID) == FID_MINMAX)
    428               pswpMinbutton = pswp;
    429             if(pswpTitlebar && pswpMinbutton)
    430               break;
    431             pswp++;
    432           }
    433           pswpNew->cy = pswpMinbutton->cy + 3;
    434           pswpNew->cx = min(pswpNew->cy,(pswpMinbutton->cx / 2) + 3);
    435           pswpTitlebar->cx -= (pswpNew->cx + 1);
    436           pswpNew->x = pswpTitlebar->x + pswpTitlebar->cx;
    437           pswpNew->y = pswpMinbutton->y - 1;
    438         }
    439         else {
    440           pswpNew->x = pswpClient->x + 3;
    441           pswpNew->y = (pswpClient->y + pswpClient->cy) - 20;
    442           pswpNew->cx = pswpClient->cx - 6;
    443           pswpNew->cy = 18;
    444           pswpClient->cy -= 22;
    445         }
    446         sCount++;
    447         return MRFROMSHORT(sCount);
    448       }
    449 
    450     case WM_QUERYFRAMECTLCOUNT:
    451       {
    452         SHORT sCount;
    453 
    454         sCount = (SHORT)CommonFrameWndProc(TREE_CNR,hwnd,msg,mp1,mp2);
    455         sCount++;
    456         return MRFROMSHORT(sCount);
    457       }
     417
     418  switch (msg) {
     419  case UM_CONTAINERHWND:
     420    return MRFROMLONG(WinWindowFromID(hwnd, TREE_CNR));
     421
     422  case UM_VIEWSMENU:
     423    return MRFROMLONG(CheckMenu(&TreeCnrMenu, TREECNR_POPUP));
     424
     425  case UM_TIMER:
     426  case UM_ACTION:
     427  case UM_SHOWME:
     428  case UM_OPENWINDOWFORME:
     429  case UM_MINIMIZE:
     430  case UM_MAXIMIZE:
     431  case WM_INITMENU:
     432  case UM_INITMENU:
     433  case UM_FILTER:
     434  case UM_FILESMENU:
     435  case UM_UPDATERECORD:
     436  case UM_UPDATERECORDLIST:
     437  case MM_PORTHOLEINIT:
     438  case UM_DRIVECMD:
     439  case WM_CLOSE:
     440  case WM_CONTROL:
     441  case UM_COMMAND:
     442  case WM_COMMAND:
     443    return WinSendMsg(WinWindowFromID(hwnd, TREE_CNR), msg, mp1, mp2);
     444
     445  case WM_PSETFOCUS:
     446  case WM_SETFOCUS:
     447    if (mp2)
     448      PostMsg(hwnd, UM_FOCUSME, MPVOID, MPVOID);
     449    break;
     450
     451  case UM_FOCUSME:
     452    WinSetFocus(HWND_DESKTOP, WinWindowFromID(hwnd, TREE_CNR));
     453    break;
     454
     455  case WM_ERASEBACKGROUND:
     456    WinFillRect((HPS) mp1, (PRECTL) mp2, 0x00d0d0d0);
     457    return 0;
     458
     459  case WM_PAINT:
     460    {
     461      HPS hps;
     462      RECTL rcl;
     463
     464      hps = WinBeginPaint(hwnd, (HPS) 0, NULL);
     465      if (hps) {
     466        WinQueryWindowRect(hwnd, &rcl);
     467        WinFillRect(hps, &rcl, CLR_PALEGRAY);
     468        PaintRecessedWindow(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
     469                                            MAIN_STATUS), hps, FALSE, FALSE);
     470        WinEndPaint(hps);
     471      }
     472    }
     473    break;
     474
     475  case WM_SIZE:
     476    WinSetWindowPos(WinWindowFromID(hwnd, TREE_CNR),
     477                    HWND_TOP,
     478                    0,
     479                    0,
     480                    SHORT1FROMMP(mp2),
     481                    SHORT2FROMMP(mp2), SWP_SHOW | SWP_MOVE | SWP_SIZE);
     482    if (hwndMain)
     483      PostMsg(hwndMain, UM_SIZE, MPVOID, MPVOID);
     484    break;
     485
     486  case WM_CONTEXTMENU:
     487  case UM_CONTEXTMENU:
     488    PostMsg(WinWindowFromID(hwnd, TREE_CNR),
     489            WM_CONTROL, MPFROM2SHORT(TREE_CNR, CN_CONTEXTMENU), MPVOID);
     490    return 0;
    458491  }
    459   return CommonFrameWndProc(TREE_CNR,hwnd,msg,mp1,mp2);
     492  return WinDefWindowProc(hwnd, msg, mp1, mp2);
    460493}
    461494
    462 
    463 MRESULT EXPENTRY TreeClientWndProc (HWND hwnd,ULONG msg,MPARAM mp1,
    464                                     MPARAM mp2) {
    465 
    466   switch(msg) {
    467     case UM_CONTAINERHWND:
    468       return MRFROMLONG(WinWindowFromID(hwnd,
    469                                         TREE_CNR));
    470 
    471     case UM_VIEWSMENU:
    472       return MRFROMLONG(CheckMenu(&TreeCnrMenu,
    473                                   TREECNR_POPUP));
    474 
    475     case UM_TIMER:
    476     case UM_ACTION:
    477     case UM_SHOWME:
    478     case UM_OPENWINDOWFORME:
    479     case UM_MINIMIZE:
    480     case UM_MAXIMIZE:
    481     case WM_INITMENU:
    482     case UM_INITMENU:
    483     case UM_FILTER:
    484     case UM_FILESMENU:
    485     case UM_UPDATERECORD:
    486     case UM_UPDATERECORDLIST:
    487     case MM_PORTHOLEINIT:
    488     case UM_DRIVECMD:
    489     case WM_CLOSE:
    490     case WM_CONTROL:
    491     case UM_COMMAND:
    492     case WM_COMMAND:
    493       return WinSendMsg(WinWindowFromID(hwnd,TREE_CNR),
    494                         msg,
    495                         mp1,
    496                         mp2);
    497 
    498     case WM_PSETFOCUS:
    499     case WM_SETFOCUS:
    500       if(mp2)
    501         PostMsg(hwnd,
    502                 UM_FOCUSME,
    503                 MPVOID,
    504                 MPVOID);
    505       break;
    506 
    507     case UM_FOCUSME:
    508       WinSetFocus(HWND_DESKTOP,
    509                   WinWindowFromID(hwnd,TREE_CNR));
    510       break;
    511 
    512     case WM_ERASEBACKGROUND:
    513       WinFillRect((HPS)mp1,
    514                   (PRECTL)mp2,
    515                   0x00d0d0d0);
    516       return 0;
    517 
    518     case WM_PAINT:
    519       {
    520         HPS    hps;
    521         RECTL  rcl;
    522 
    523         hps = WinBeginPaint(hwnd,
    524                             (HPS)0,
    525                             NULL);
    526         if(hps) {
    527           WinQueryWindowRect(hwnd,
    528                              &rcl);
    529           WinFillRect(hps,
    530                       &rcl,
    531                       CLR_PALEGRAY);
    532           PaintRecessedWindow(WinWindowFromID(WinQueryWindow(hwnd,QW_PARENT),
    533                                               MAIN_STATUS),
    534                               hps,
    535                               FALSE,
    536                               FALSE);
    537           WinEndPaint(hps);
    538         }
    539       }
    540       break;
    541 
    542     case WM_SIZE:
    543       WinSetWindowPos(WinWindowFromID(hwnd,TREE_CNR),
    544                       HWND_TOP,
    545                       0,
    546                       0,
    547                       SHORT1FROMMP(mp2),
    548                       SHORT2FROMMP(mp2),
    549                       SWP_SHOW | SWP_MOVE | SWP_SIZE);
    550       if(hwndMain)
    551         PostMsg(hwndMain,
    552                 UM_SIZE,
    553                 MPVOID,
    554                 MPVOID);
    555       break;
    556 
    557     case WM_CONTEXTMENU:
    558     case UM_CONTEXTMENU:
    559       PostMsg(WinWindowFromID(hwnd,TREE_CNR),
    560               WM_CONTROL,
    561               MPFROM2SHORT(TREE_CNR,CN_CONTEXTMENU),
    562               MPVOID);
    563       return 0;
    564   }
    565   return WinDefWindowProc(hwnd,msg,mp1,mp2);
    566 }
    567 
    568 
    569 MRESULT EXPENTRY TreeObjWndProc (HWND hwnd,ULONG msg,MPARAM mp1,MPARAM mp2)
     495MRESULT EXPENTRY TreeObjWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
    570496{
    571497  DIRCNRDATA *dcd;
    572498
    573   switch(msg)
    574   {
    575     case WM_CREATE:
    576       break;
    577 
    578     case UM_SHOWME:
    579       if(mp1)
     499  switch (msg) {
     500  case WM_CREATE:
     501    break;
     502
     503  case UM_SHOWME:
     504    if (mp1) {
     505      dcd = INSTDATA(hwnd);
     506      if (dcd) {
     507        BOOL tempsusp, tempfollow, temptop;
     508
     509        tempsusp = dcd->suspendview;
     510        dcd->suspendview = TRUE;
     511        tempfollow = fFollowTree;
     512        fFollowTree = FALSE;
     513        if (mp2) {
     514          temptop = fTopDir;
     515          fTopDir = TRUE;
     516        }
     517        ShowTreeRec(dcd->hwndCnr, (CHAR *) mp1, fCollapseFirst, TRUE);
     518        dcd->suspendview = tempsusp;
     519        fFollowTree = tempfollow;
     520        if (mp2)
     521          fTopDir = temptop;
     522      }
     523      free((CHAR *) mp1);
     524    }
     525    return 0;
     526
     527  case DM_PRINTOBJECT:
     528    return MRFROMLONG(DRR_TARGET);
     529
     530  case DM_DISCARDOBJECT:
     531    dcd = INSTDATA(hwnd);
     532    if (fFM2Deletes && dcd) {
     533
     534      LISTINFO *li;
     535      CNRDRAGINFO cni;
     536
     537      cni.pRecord = NULL;
     538      cni.pDragInfo = (PDRAGINFO) mp1;
     539      li = DoFileDrop(dcd->hwndCnr,
     540                      dcd->directory, FALSE, MPVOID, MPFROMP(&cni));
     541      if (li) {
     542        li->type = ((fDefaultDeletePerm) ? IDM_PERMDELETE : IDM_DELETE);
     543        if (!PostMsg(hwnd, UM_MASSACTION, MPFROMP(li), MPVOID))
     544          FreeListInfo(li);
     545        else
     546          return MRFROMLONG(DRR_SOURCE);
     547      }
     548    }
     549    return MRFROMLONG(DRR_TARGET);
     550
     551  case UM_EXPAND:
     552    dcd = WinQueryWindowPtr(hwnd, QWL_USER);
     553    if (!dcd)
     554      Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
     555    else {
     556      BOOL tempsusp = dcd->suspendview;
     557
     558      dcd->suspendview = TRUE;
     559      ExpandAll(dcd->hwndCnr,
     560                (SHORT1FROMMP(mp1) == IDM_EXPAND), (PCNRITEM) mp2);
     561      dcd->suspendview = tempsusp;
     562      PostMsg(dcd->hwndCnr, UM_FILTER, MPVOID, MPVOID);
     563    }
     564    return 0;
     565
     566  case UM_UPDATERECORDLIST:
     567    dcd = WinQueryWindowPtr(hwnd, QWL_USER);
     568    if (!dcd || !mp1)
     569      Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
     570    else {
     571      INT numentries = 0;
     572      CHAR **list = (CHAR **) mp1;
     573
     574      while (list[numentries])
     575        numentries++;
     576      if (numentries)
     577        UpdateCnrList(dcd->hwndCnr, list, numentries, TRUE, dcd);
     578    }
     579    return 0;
     580
     581  case UM_SETUP:
     582    dcd = WinQueryWindowPtr(hwnd, QWL_USER);
     583    if (!dcd)
     584      Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
     585    else {
     586      dcd->hwndObject = hwnd;
     587      if (ParentIsDesktop(hwnd, dcd->hwndParent))
     588        DosSleep(250L);
     589    }
     590    return 0;
     591
     592  case UM_RESCAN2:
     593    dcd = WinQueryWindowPtr(hwnd, QWL_USER);
     594    if (!dcd)
     595      Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
     596    // Bypass if not running integrated (i.e if vtree)
     597    else if (hwndStatus &&
     598             dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent)) {
     599      CHAR s[CCHMAXPATH * 2];
     600      PCNRITEM pci = (PCNRITEM) mp1;
     601      FSALLOCATE fsa;
     602      struct
    580603      {
    581         dcd = INSTDATA(hwnd);
    582         if(dcd)
    583         {
    584           BOOL tempsusp,tempfollow,temptop;
    585 
    586           tempsusp = dcd->suspendview;
    587           dcd->suspendview = TRUE;
    588           tempfollow = fFollowTree;
    589           fFollowTree = FALSE;
    590           if(mp2) {
    591             temptop = fTopDir;
    592             fTopDir = TRUE;
    593           }
    594           ShowTreeRec(dcd->hwndCnr,
    595                       (CHAR *)mp1,
    596                       fCollapseFirst,
    597                       TRUE);
    598           dcd->suspendview = tempsusp;
    599           fFollowTree = tempfollow;
    600           if(mp2)
    601             fTopDir = temptop;
    602         }
    603         free((CHAR *)mp1);
    604       }
    605       return 0;
    606 
    607     case DM_PRINTOBJECT:
    608       return MRFROMLONG(DRR_TARGET);
    609 
    610     case DM_DISCARDOBJECT:
    611       dcd = INSTDATA(hwnd);
    612       if(fFM2Deletes && dcd) {
    613 
    614         LISTINFO    *li;
    615         CNRDRAGINFO cni;
    616 
    617         cni.pRecord = NULL;
    618         cni.pDragInfo = (PDRAGINFO)mp1;
    619         li = DoFileDrop(dcd->hwndCnr,
    620                         dcd->directory,
    621                         FALSE,
    622                         MPVOID,
    623                         MPFROMP(&cni));
    624         if(li) {
    625           li->type = ((fDefaultDeletePerm) ?
    626                        IDM_PERMDELETE :
    627                        IDM_DELETE);
    628           if(!PostMsg(hwnd,
    629                       UM_MASSACTION,
    630                       MPFROMP(li),
    631                       MPVOID))
    632             FreeListInfo(li);
    633           else
    634             return MRFROMLONG(DRR_SOURCE);
    635         }
    636       }
    637       return MRFROMLONG(DRR_TARGET);
    638 
    639     case UM_EXPAND:
    640       dcd = WinQueryWindowPtr(hwnd,QWL_USER);
    641       if (!dcd)
    642         Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
    643       else {
    644         BOOL tempsusp = dcd->suspendview;
    645 
    646         dcd->suspendview = TRUE;
    647         ExpandAll(dcd->hwndCnr,
    648                   (SHORT1FROMMP(mp1) == IDM_EXPAND),
    649                   (PCNRITEM)mp2);
    650         dcd->suspendview = tempsusp;
    651         PostMsg(dcd->hwndCnr,
    652                 UM_FILTER,
    653                 MPVOID,
    654                 MPVOID);
    655       }
    656       return 0;
    657 
    658     case UM_UPDATERECORDLIST:
    659       dcd = WinQueryWindowPtr(hwnd,QWL_USER);
    660       if (!dcd || !mp1)
    661         Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
    662       else {
    663         INT    numentries = 0;
    664         CHAR **list = (CHAR **)mp1;
    665 
    666         while(list[numentries])
    667           numentries++;
    668         if(numentries)
    669           UpdateCnrList(dcd->hwndCnr,
    670                         list,
    671                         numentries,
    672                         TRUE,
    673                         dcd);
    674       }
    675       return 0;
    676 
    677     case UM_SETUP:
    678       dcd = WinQueryWindowPtr(hwnd,QWL_USER);
    679       if (!dcd)
    680         Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
    681       else {
    682         dcd->hwndObject = hwnd;
    683         if(ParentIsDesktop(hwnd,dcd->hwndParent))
    684           DosSleep(250L);
    685       }
    686       return 0;
    687 
    688     case UM_RESCAN2:
    689       dcd = WinQueryWindowPtr(hwnd,QWL_USER);
    690       if (!dcd)
    691         Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
    692       // Bypass if not running integrated (i.e if vtree)
    693       else if (hwndStatus &&
    694                dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent)) {
    695         CHAR      s[CCHMAXPATH * 2];
    696         PCNRITEM   pci = (PCNRITEM)mp1;
    697         FSALLOCATE fsa;
    698         struct
    699         {
    700           ULONG serial;
    701           CHAR  volumelength;
    702           CHAR  volumelabel[CCHMAXPATH];
    703         }          volser;
    704         CHAR       tb[64];
    705         CHAR       szFree[64];
    706         CNRINFO    cnri;
    707 
    708         strcpy(s,GetPString(IDS_TREETEXT));
    709         memset(&cnri,0,sizeof(CNRINFO));
    710         cnri.cb = sizeof(CNRINFO);
    711         WinSendMsg(dcd->hwndCnr,
    712                    CM_QUERYCNRINFO,
    713                    MPFROMP(&cnri),
    714                    MPFROMLONG(sizeof(CNRINFO)));
    715         if (cnri.cRecords)
    716         {
    717           sprintf(s,
    718                   GetPString(IDS_NUMDRIVESTEXT),
    719                   cnri.cRecords);
    720           if (pci)
    721           {
    722             if (!(driveflags[toupper(*pci->szFileName) - 'A'] &
    723                   DRIVE_REMOVABLE) ||
    724                driveserial[toupper(*pci->szFileName) - 'A'] != -1)
    725             {
    726               memset(&volser,0,sizeof(volser));
     604        ULONG serial;
     605        CHAR volumelength;
     606        CHAR volumelabel[CCHMAXPATH];
     607      }
     608      volser;
     609      CHAR tb[64];
     610      CHAR szFree[64];
     611      CNRINFO cnri;
     612
     613      strcpy(s, GetPString(IDS_TREETEXT));
     614      memset(&cnri, 0, sizeof(CNRINFO));
     615      cnri.cb = sizeof(CNRINFO);
     616      WinSendMsg(dcd->hwndCnr,
     617                 CM_QUERYCNRINFO,
     618                 MPFROMP(&cnri), MPFROMLONG(sizeof(CNRINFO)));
     619      if (cnri.cRecords) {
     620        sprintf(s, GetPString(IDS_NUMDRIVESTEXT), cnri.cRecords);
     621        if (pci) {
     622          if (!(driveflags[toupper(*pci->szFileName) - 'A'] &
     623                DRIVE_REMOVABLE) ||
     624              driveserial[toupper(*pci->szFileName) - 'A'] != -1) {
     625            memset(&volser, 0, sizeof(volser));
     626            DosError(FERR_DISABLEHARDERR);
     627            if (!DosQueryFSInfo(toupper(*pci->szFileName) - '@',
     628                                FSIL_VOLSER,
     629                                &volser,
     630                                (ULONG) sizeof(volser)) &&
     631                dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent)) {
    727632              DosError(FERR_DISABLEHARDERR);
    728633              if (!DosQueryFSInfo(toupper(*pci->szFileName) - '@',
    729                                   FSIL_VOLSER,
    730                                   &volser,
    731                                   (ULONG)sizeof(volser)) &&
    732                  dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent))
    733               {
    734                 DosError(FERR_DISABLEHARDERR);
    735                 if (!DosQueryFSInfo(toupper(*pci->szFileName) - '@',
    736                                     FSIL_ALLOC,
    737                                     &fsa,
    738                                     sizeof(FSALLOCATE)))
    739                 {
    740                   CommaFmtULL(tb,sizeof(tb),
    741                               (ULONGLONG)fsa.cUnitAvail * (fsa.cSectorUnit * fsa.cbSector),
    742                               'M');
    743                   sprintf(szFree, "  %s %s",
    744                          tb,GetPString(IDS_FREETEXT));
    745                 }
    746                 else
    747                   *szFree = 0;
    748                 driveserial[toupper(*pci->szFileName) - 'A'] = volser.serial;
    749                 sprintf(&s[strlen(s)],
    750                         GetPString(IDS_TREESTATUSSTARTTEXT),
    751                         toupper(*pci->szFileName),
    752                         volser.volumelabel,
    753                         volser.serial,szFree);
    754                 if (!fMoreButtons)
    755                 {
    756                   if (*dcd->mask.szMask ||
    757                       (dcd->mask.attrFile != ALLATTRS ||
    758                        ((fFilesInTree ||
    759                          (driveflags[toupper(*pci->szFileName)] &
    760                           DRIVE_INCLUDEFILES)) ?
    761                             dcd->mask.antiattr :
    762                            (dcd->mask.antiattr &&
    763                             dcd->mask.antiattr != FILE_DIRECTORY))))
    764                   {
    765                     sprintf (&s[strlen(s)],
    766                              " (%s)",
    767                              (*dcd->mask.szMask) ?
    768                               dcd->mask.szMask :
    769                               GetPString(IDS_ATTRTEXT));
    770                   }
     634                                  FSIL_ALLOC, &fsa, sizeof(FSALLOCATE))) {
     635                CommaFmtULL(tb, sizeof(tb),
     636                            (ULONGLONG) fsa.cUnitAvail * (fsa.cSectorUnit *
     637                                                          fsa.cbSector), 'M');
     638                sprintf(szFree, "  %s %s", tb, GetPString(IDS_FREETEXT));
     639              }
     640              else
     641                *szFree = 0;
     642              driveserial[toupper(*pci->szFileName) - 'A'] = volser.serial;
     643              sprintf(&s[strlen(s)],
     644                      GetPString(IDS_TREESTATUSSTARTTEXT),
     645                      toupper(*pci->szFileName),
     646                      volser.volumelabel, volser.serial, szFree);
     647              if (!fMoreButtons) {
     648                if (*dcd->mask.szMask ||
     649                    (dcd->mask.attrFile != ALLATTRS ||
     650                     ((fFilesInTree ||
     651                       (driveflags[toupper(*pci->szFileName)] &
     652                        DRIVE_INCLUDEFILES)) ?
     653                      dcd->mask.antiattr :
     654                      (dcd->mask.antiattr &&
     655                       dcd->mask.antiattr != FILE_DIRECTORY)))) {
     656                  sprintf(&s[strlen(s)],
     657                          " (%s)",
     658                          (*dcd->mask.szMask) ?
     659                          dcd->mask.szMask : GetPString(IDS_ATTRTEXT));
    771660                }
    772661              }
    773662            }
    774             else
    775             {
    776               /* find root record and strip it */
    777               pci = FindParentRecord(dcd->hwndCnr,pci);
    778               driveserial[toupper(*pci->szFileName) - 'A'] = -1;
    779               UnFlesh(dcd->hwndCnr,pci);
    780             }
    781           }
    782         }
    783         if (dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent))
    784           WinSetWindowText(hwndStatus,s);
    785       }
     663          }
     664          else {
     665            /* find root record and strip it */
     666            pci = FindParentRecord(dcd->hwndCnr, pci);
     667            driveserial[toupper(*pci->szFileName) - 'A'] = -1;
     668            UnFlesh(dcd->hwndCnr, pci);
     669          }
     670        }
     671      }
     672      if (dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent))
     673        WinSetWindowText(hwndStatus, s);
     674    }
     675    return 0;
     676
     677  case UM_RESCAN:
     678    /*
     679     * populate container
     680     */
     681    dcd = WinQueryWindowPtr(hwnd, QWL_USER);
     682    if (!dcd)
     683      Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
     684    else {
     685      WinSendMsg(dcd->hwndCnr,
     686                 CM_REMOVERECORD,
     687                 MPVOID,
     688                 MPFROM2SHORT(0, CMA_FREE | CMA_INVALIDATE | CMA_ERASE));
     689      WinSendMsg(dcd->hwndCnr,
     690                 CM_SCROLLWINDOW, MPFROMSHORT(CMA_VERTICAL), MPFROMLONG(-1));
     691      WinSendMsg(dcd->hwndCnr,
     692                 CM_SCROLLWINDOW,
     693                 MPFROMSHORT(CMA_HORIZONTAL), MPFROMLONG(-1));
     694      FillTreeCnr(dcd->hwndCnr, dcd->hwndParent);
     695      if (fOkayMinimize) {
     696        PostMsg(dcd->hwndCnr, UM_MINIMIZE, MPVOID, MPVOID);
     697        fOkayMinimize = FALSE;
     698      }
     699      WinSendMsg(dcd->hwndCnr,
     700                 CM_INVALIDATERECORD,
     701                 MPVOID, MPFROM2SHORT(0, CMA_ERASE | CMA_REPOSITION));
     702      PostMsg(dcd->hwndCnr, UM_RESCAN, MPVOID, MPVOID);
     703    }
     704    return 0;
     705
     706  case UM_COMMAND:
     707    if (mp1) {
     708
     709      LISTINFO *li = (LISTINFO *) mp1;
     710
     711      switch (li->type) {
     712      case IDM_DOITYOURSELF:
     713      case IDM_APPENDTOCLIP:
     714      case IDM_SAVETOCLIP:
     715      case IDM_ARCHIVE:
     716      case IDM_VIEW:
     717      case IDM_EDIT:
     718      case IDM_OBJECT:
     719      case IDM_SHADOW:
     720      case IDM_SHADOW2:
     721      case IDM_PRINT:
     722      case IDM_ATTRS:
     723      case IDM_DELETE:
     724      case IDM_PERMDELETE:
     725        if (PostMsg(hwnd, UM_MASSACTION, mp1, mp2))
     726          return (MRESULT) TRUE;
     727      default:
     728        if (PostMsg(hwnd, UM_ACTION, mp1, mp2))
     729          return (MRESULT) TRUE;
     730      }
     731    }
     732    return 0;
     733
     734  case UM_MASSACTION:
     735    if (mp1) {
     736
     737      dcd = WinQueryWindowPtr(hwnd, QWL_USER);
     738      if (!dcd)
     739        Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
     740      else {
     741        WORKER *wk;
     742
     743        wk = xmallocz(sizeof(WORKER), pszSrcFile, __LINE__);
     744        if (!wk)
     745          FreeListInfo((LISTINFO *) mp1);
     746        else {
     747          wk->size = sizeof(WORKER);
     748          wk->hwndCnr = dcd->hwndCnr;
     749          wk->hwndParent = dcd->hwndParent;
     750          wk->hwndFrame = dcd->hwndFrame;
     751          wk->hwndClient = dcd->hwndClient;
     752          wk->li = (LISTINFO *) mp1;
     753          strcpy(wk->directory, dcd->directory);
     754          if (_beginthread(MassAction, NULL, 122880, (PVOID) wk) == -1) {
     755            Runtime_Error(pszSrcFile, __LINE__,
     756                          GetPString(IDS_COULDNTSTARTTHREADTEXT));
     757            free(wk);
     758            FreeListInfo((LISTINFO *) mp1);
     759          }
     760        }
     761      }
     762    }
     763    return 0;
     764
     765  case UM_ACTION:
     766    if (mp1) {
     767
     768      dcd = WinQueryWindowPtr(hwnd, QWL_USER);
     769      if (!dcd)
     770        Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
     771      else {
     772        WORKER *wk;
     773
     774        wk = xmallocz(sizeof(WORKER), pszSrcFile, __LINE__);
     775        if (!wk)
     776          FreeListInfo((LISTINFO *) mp1);
     777        else {
     778          wk->size = sizeof(WORKER);
     779          wk->hwndCnr = dcd->hwndCnr;
     780          wk->hwndParent = dcd->hwndParent;
     781          wk->hwndFrame = dcd->hwndFrame;
     782          wk->hwndClient = dcd->hwndClient;
     783          wk->li = (LISTINFO *) mp1;
     784          strcpy(wk->directory, dcd->directory);
     785          if (_beginthread(Action, NULL, 122880, (PVOID) wk) == -1) {
     786            Runtime_Error(pszSrcFile, __LINE__,
     787                          GetPString(IDS_COULDNTSTARTTHREADTEXT));
     788            free(wk);
     789            FreeListInfo((LISTINFO *) mp1);
     790          }
     791        }
     792      }
     793    }
     794    return 0;
     795
     796  case WM_CLOSE:
     797    WinDestroyWindow(hwnd);
     798    break;
     799
     800  case WM_DESTROY:
     801    hwndTree = (HWND) 0;
     802    dcd = WinQueryWindowPtr(hwnd, QWL_USER);
     803    if (dcd) {
     804      WinSendMsg(dcd->hwndCnr,
     805                 UM_CLOSE, MPFROMLONG(dcd->dontclose != FALSE), MPVOID);
     806      free(dcd);
     807    }
     808    DosPostEventSem(CompactSem);
     809    if (!PostMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID))
     810      WinSendMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID);
     811    break;
     812  }
     813  return WinDefWindowProc(hwnd, msg, mp1, mp2);
     814}
     815
     816MRESULT EXPENTRY TreeCnrWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
     817{
     818  static APPNOTIFY *apphead = NULL, *apptail = NULL;
     819  DIRCNRDATA *dcd = WinQueryWindowPtr(hwnd, QWL_USER);
     820
     821  switch (msg) {
     822  case DM_PRINTOBJECT:
     823    return MRFROMLONG(DRR_TARGET);
     824
     825  case DM_DISCARDOBJECT:
     826    if (dcd)
     827      return WinSendMsg(dcd->hwndObject, msg, mp1, mp2);
     828    else
     829      return MRFROMLONG(DRR_TARGET);
     830
     831  case WM_CHAR:
     832    shiftstate = (SHORT1FROMMP(mp1) & (KC_SHIFT | KC_ALT | KC_CTRL));
     833    if (SHORT1FROMMP(mp1) & KC_KEYUP)
     834      return (MRESULT) TRUE;
     835    if (SHORT1FROMMP(mp1) & KC_VIRTUALKEY) {
     836      switch (SHORT2FROMMP(mp2)) {
     837      case VK_INSERT:
     838        if ((shiftstate & KC_CTRL) == KC_CTRL)
     839          PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_MKDIR, 0), MPVOID);
     840        break;
     841      case VK_DELETE:
     842        if ((shiftstate & KC_CTRL) == KC_CTRL)
     843          PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_PERMDELETE, 0), MPVOID);
     844        else if ((shiftstate & KC_SHIFT) == KC_SHIFT)
     845          PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_SAVETOCLIP, 0), MPVOID);
     846        else
     847          PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_DELETE, 0), MPVOID);
     848        break;
     849      }
     850    }
     851    if (shiftstate || fNoSearch)
     852      break;
     853    if (SHORT1FROMMP(mp1) & KC_CHAR) {
     854
     855      ULONG thistime, len;
     856      SEARCHSTRING srch;
     857      PCNRITEM pci;
     858
     859      if (!dcd)
     860        break;
     861      switch (SHORT1FROMMP(mp2)) {
     862      case '\x1b':
     863      case '\r':
     864      case '\n':
     865        dcd->lasttime = 0;
     866        *dcd->szCommonName = 0;
     867        break;
     868      default:
     869        thistime = WinQueryMsgTime(WinQueryAnchorBlock(hwnd));
     870        if (thistime > dcd->lasttime + 1250)
     871          *dcd->szCommonName = 0;
     872        dcd->lasttime = thistime;
     873        if (SHORT1FROMMP(mp2) == ' ' && !*dcd->szCommonName)
     874          break;
     875      KbdRetry:
     876        len = strlen(dcd->szCommonName);
     877        if (len >= CCHMAXPATH - 1) {
     878          *dcd->szCommonName = 0;
     879          len = 0;
     880        }
     881        dcd->szCommonName[len] = toupper(SHORT1FROMMP(mp2));
     882        dcd->szCommonName[len + 1] = 0;
     883        memset(&srch, 0, sizeof(SEARCHSTRING));
     884        srch.cb = (ULONG) sizeof(SEARCHSTRING);
     885        srch.pszSearch = (PSZ) dcd->szCommonName;
     886        srch.fsPrefix = TRUE;
     887        srch.fsCaseSensitive = FALSE;
     888        srch.usView = CV_ICON;
     889        pci = WinSendMsg(hwnd,
     890                         CM_SEARCHSTRING,
     891                         MPFROMP(&srch), MPFROMLONG(CMA_FIRST));
     892        if (pci && (INT) pci != -1) {
     893          /* make found item current item */
     894          WinSendMsg(hwnd,
     895                     CM_SETRECORDEMPHASIS,
     896                     MPFROMP(pci), MPFROM2SHORT(TRUE, CRA_CURSORED));
     897          /* make sure that record shows in viewport */
     898          ShowCnrRecord(hwnd, (PMINIRECORDCORE) pci);
     899          return (MRESULT) TRUE;
     900        }
     901        else {
     902          if (SHORT1FROMMP(mp2) == ' ') {
     903            dcd->szCommonName[len] = 0;
     904            break;
     905          }
     906          *dcd->szCommonName = 0;
     907          dcd->lasttime = 0;
     908          if (len)                      // retry as first letter if no match
     909            goto KbdRetry;
     910        }
     911        break;
     912      }
     913    }
     914    break;
     915
     916  case WM_MOUSEMOVE:
     917  case WM_BUTTON1UP:
     918  case WM_BUTTON2UP:
     919  case WM_BUTTON3UP:
     920    shiftstate = (SHORT2FROMMP(mp2) & (KC_SHIFT | KC_ALT | KC_CTRL));
     921    break;
     922
     923  case UM_TIMER:
     924    if (dcd && dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent) &&
     925        hwndStatus2) {
     926      FILEFINDBUF3 ffb;
     927      ULONG nm = 1L;
     928      HDIR hdir = HDIR_CREATE;
     929
     930      if (*SwapperDat) {
     931        if (!DosFindFirst(SwapperDat,
     932                          &hdir,
     933                          FILE_NORMAL | FILE_HIDDEN |
     934                          FILE_SYSTEM | FILE_ARCHIVED | FILE_READONLY,
     935                          &ffb, sizeof(ffb), &nm, FIL_STANDARD)) {
     936          CHAR tb[39], tm[39], tpm[39], s[163];
     937          ULONG amem;
     938
     939          priority_bumped();
     940          DosFindClose(hdir);
     941          if (!DosQuerySysInfo(QSV_TOTAVAILMEM,
     942                               QSV_TOTAVAILMEM,
     943                               (PVOID) & amem, sizeof(amem))) {
     944            CommaFmtULL(tpm, sizeof(tpm), amem, 'M');
     945          }
     946          else
     947            *tpm = 0;
     948          if (!Dos16MemAvail(&amem))
     949            CommaFmtULL(tm, sizeof(tm), amem, 'M');
     950          else
     951            *tm = 0;
     952          CommaFmtULL(tb, sizeof(tb), ffb.cbFile, 'M');
     953          sprintf(s, " %s %s%s%s%s%s",
     954                  GetPString(IDS_SWAPFILETEXT),
     955                  tb,
     956                  *tm ? GetPString(IDS_TREEMEMTEXT) : NullStr,
     957                  tm, *tpm ? "/" : NullStr, tpm);
     958          WinSetWindowText(hwndStatus2, s);
     959        }
     960        else
     961          WinSetWindowText(hwndStatus2, NullStr);
     962      }
     963      else
     964        WinSetWindowText(hwndStatus2, NullStr);
     965    }
     966    if (msg == UM_TIMER)
    786967      return 0;
    787 
    788     case UM_RESCAN:
    789       /*
    790        * populate container
    791        */
    792       dcd = WinQueryWindowPtr(hwnd,QWL_USER);
    793       if (!dcd)
    794         Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
    795       else {
    796         WinSendMsg(dcd->hwndCnr,
    797                    CM_REMOVERECORD,
    798                    MPVOID,
    799                    MPFROM2SHORT(0,CMA_FREE | CMA_INVALIDATE | CMA_ERASE));
    800         WinSendMsg(dcd->hwndCnr,
    801                    CM_SCROLLWINDOW,
    802                    MPFROMSHORT(CMA_VERTICAL),
    803                    MPFROMLONG(-1));
    804         WinSendMsg(dcd->hwndCnr,
    805                    CM_SCROLLWINDOW,
    806                    MPFROMSHORT(CMA_HORIZONTAL),
    807                    MPFROMLONG(-1));
    808         FillTreeCnr(dcd->hwndCnr,
    809                     dcd->hwndParent);
    810         if(fOkayMinimize) {
    811           PostMsg(dcd->hwndCnr,
    812                   UM_MINIMIZE,
    813                   MPVOID,
    814                   MPVOID);
    815           fOkayMinimize = FALSE;
    816         }
    817         WinSendMsg(dcd->hwndCnr,
    818                    CM_INVALIDATERECORD,
    819                    MPVOID,
    820                    MPFROM2SHORT(0,CMA_ERASE | CMA_REPOSITION));
    821         PostMsg(dcd->hwndCnr,
    822                 UM_RESCAN,
    823                 MPVOID,
    824                 MPVOID);
    825       }
    826       return 0;
    827 
    828     case UM_COMMAND:
    829       if(mp1) {
    830 
    831         LISTINFO *li = (LISTINFO *)mp1;
    832 
    833         switch(li->type) {
    834           case IDM_DOITYOURSELF:
    835           case IDM_APPENDTOCLIP:
    836           case IDM_SAVETOCLIP:
    837           case IDM_ARCHIVE:
    838           case IDM_VIEW:
    839           case IDM_EDIT:
    840           case IDM_OBJECT:
    841           case IDM_SHADOW:
    842           case IDM_SHADOW2:
    843           case IDM_PRINT:
    844           case IDM_ATTRS:
    845           case IDM_DELETE:
    846           case IDM_PERMDELETE:
    847             if(PostMsg(hwnd,
    848                        UM_MASSACTION,
    849                        mp1,
    850                        mp2))
    851               return (MRESULT)TRUE;
    852           default:
    853             if(PostMsg(hwnd,
    854                        UM_ACTION,
    855                        mp1,
    856                        mp2))
    857               return (MRESULT)TRUE;
    858         }
    859       }
    860       return 0;
    861 
    862     case UM_MASSACTION:
    863       if(mp1) {
    864 
    865         dcd = WinQueryWindowPtr(hwnd,QWL_USER);
    866         if (!dcd)
    867           Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
     968    break;
     969
     970  case WM_PRESPARAMCHANGED:
     971    PresParamChanged(hwnd, "TreeCnr", mp1, mp2);
     972    break;
     973
     974  case UM_FILESMENU:
     975    {
     976      PCNRITEM pci;
     977      HWND menuHwnd = (HWND) 0;
     978
     979      pci = (PCNRITEM) CurrentRecord(hwnd);
     980      if (pci && (INT) pci != -1) {
     981        if (IsRoot(pci->szFileName))
     982          menuHwnd = CheckMenu(&TreeMenu, TREE_POPUP);
    868983        else {
    869           WORKER *wk;
    870 
    871           wk = xmallocz(sizeof(WORKER), pszSrcFile, __LINE__);
    872           if (!wk)
    873             FreeListInfo((LISTINFO *)mp1);
    874           else {
    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(MassAction,NULL,122880,(PVOID)wk) == -1) {
    883               Runtime_Error(pszSrcFile, __LINE__, GetPString(IDS_COULDNTSTARTTHREADTEXT));
    884               free(wk);
    885               FreeListInfo((LISTINFO *)mp1);
    886             }
    887           }
    888         }
    889       }
    890       return 0;
    891 
    892     case UM_ACTION:
    893       if(mp1) {
    894 
    895         dcd = WinQueryWindowPtr(hwnd,QWL_USER);
    896         if (!dcd)
    897           Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
    898         else {
    899           WORKER *wk;
    900 
    901           wk = xmallocz(sizeof(WORKER), pszSrcFile,__LINE__);
    902           if (!wk)
    903             FreeListInfo((LISTINFO *)mp1);
    904           else {
    905             wk->size = sizeof(WORKER);
    906             wk->hwndCnr = dcd->hwndCnr;
    907             wk->hwndParent = dcd->hwndParent;
    908             wk->hwndFrame = dcd->hwndFrame;
    909             wk->hwndClient = dcd->hwndClient;
    910             wk->li = (LISTINFO *)mp1;
    911             strcpy(wk->directory,dcd->directory);
    912             if (_beginthread(Action,NULL,122880,(PVOID)wk) == -1) {
    913               Runtime_Error(pszSrcFile, __LINE__, GetPString(IDS_COULDNTSTARTTHREADTEXT));
    914               free(wk);
    915               FreeListInfo((LISTINFO *)mp1);
    916             }
    917           }
    918         }
    919       }
    920       return 0;
    921 
    922     case WM_CLOSE:
    923       WinDestroyWindow(hwnd);
    924       break;
    925 
    926     case WM_DESTROY:
    927       hwndTree = (HWND)0;
    928       dcd = WinQueryWindowPtr(hwnd,QWL_USER);
    929       if (dcd) {
    930         WinSendMsg(dcd->hwndCnr,
    931                    UM_CLOSE,
    932                    MPFROMLONG(dcd->dontclose != FALSE),
    933                    MPVOID);
    934         free(dcd);
    935       }
    936       DosPostEventSem(CompactSem);
    937       if(!PostMsg((HWND)0,
    938                   WM_QUIT,
    939                   MPVOID,
    940                   MPVOID))
    941         WinSendMsg((HWND)0,
    942                    WM_QUIT,
    943                    MPVOID,
    944                    MPVOID);
    945       break;
    946   }
    947   return WinDefWindowProc(hwnd,msg,mp1,mp2);
    948 }
    949 
    950 
    951 MRESULT EXPENTRY TreeCnrWndProc (HWND hwnd,ULONG msg,MPARAM mp1,MPARAM mp2)
    952 {
    953   static APPNOTIFY *apphead = NULL,*apptail = NULL;
    954   DIRCNRDATA       *dcd = WinQueryWindowPtr(hwnd,QWL_USER);
    955 
    956   switch(msg) {
    957     case DM_PRINTOBJECT:
    958       return MRFROMLONG(DRR_TARGET);
    959 
    960     case DM_DISCARDOBJECT:
    961       if(dcd)
    962         return WinSendMsg(dcd->hwndObject,
    963                           msg,
    964                           mp1,
    965                           mp2);
    966       else
    967         return MRFROMLONG(DRR_TARGET);
    968 
    969     case WM_CHAR:
    970       shiftstate = (SHORT1FROMMP(mp1) & (KC_SHIFT | KC_ALT | KC_CTRL));
    971       if(SHORT1FROMMP(mp1) & KC_KEYUP)
    972         return (MRESULT)TRUE;
    973       if(SHORT1FROMMP(mp1) & KC_VIRTUALKEY) {
    974         switch(SHORT2FROMMP(mp2)) {
    975           case VK_INSERT:
    976             if((shiftstate & KC_CTRL) == KC_CTRL)
    977               PostMsg(hwnd,
    978                       WM_COMMAND,
    979                       MPFROM2SHORT(IDM_MKDIR,0),
    980                       MPVOID);
    981             break;
    982           case VK_DELETE:
    983             if((shiftstate & KC_CTRL) == KC_CTRL)
    984               PostMsg(hwnd,
    985                       WM_COMMAND,
    986                       MPFROM2SHORT(IDM_PERMDELETE,0),
    987                       MPVOID);
    988             else if((shiftstate & KC_SHIFT) == KC_SHIFT)
    989               PostMsg(hwnd,
    990                       WM_COMMAND,
    991                       MPFROM2SHORT(IDM_SAVETOCLIP,0),
    992                       MPVOID);
    993             else
    994               PostMsg(hwnd,
    995                       WM_COMMAND,
    996                       MPFROM2SHORT(IDM_DELETE,0),
    997                       MPVOID);
    998             break;
    999         }
    1000       }
    1001       if(shiftstate || fNoSearch)
    1002         break;
    1003       if(SHORT1FROMMP(mp1) & KC_CHAR) {
    1004 
    1005         ULONG        thistime,len;
    1006         SEARCHSTRING srch;
    1007         PCNRITEM     pci;
    1008 
    1009         if(!dcd)
    1010           break;
    1011         switch(SHORT1FROMMP(mp2)) {
    1012           case '\x1b':
    1013           case '\r':
    1014           case '\n':
    1015             dcd->lasttime = 0;
    1016             *dcd->szCommonName = 0;
    1017             break;
    1018           default:
    1019             thistime = WinQueryMsgTime(WinQueryAnchorBlock(hwnd));
    1020             if(thistime > dcd->lasttime + 1250)
    1021               *dcd->szCommonName = 0;
    1022             dcd->lasttime = thistime;
    1023             if(SHORT1FROMMP(mp2) == ' ' && !*dcd->szCommonName)
    1024               break;
    1025 KbdRetry:
    1026             len = strlen(dcd->szCommonName);
    1027             if(len >= CCHMAXPATH - 1) {
    1028               *dcd->szCommonName = 0;
    1029               len = 0;
    1030             }
    1031             dcd->szCommonName[len] = toupper(SHORT1FROMMP(mp2));
    1032             dcd->szCommonName[len + 1] = 0;
    1033             memset(&srch,0,sizeof(SEARCHSTRING));
    1034             srch.cb = (ULONG)sizeof(SEARCHSTRING);
    1035             srch.pszSearch = (PSZ)dcd->szCommonName;
    1036             srch.fsPrefix = TRUE;
    1037             srch.fsCaseSensitive = FALSE;
    1038             srch.usView = CV_ICON;
    1039             pci = WinSendMsg(hwnd,
    1040                              CM_SEARCHSTRING,
    1041                              MPFROMP(&srch),
    1042                              MPFROMLONG(CMA_FIRST));
    1043             if(pci && (INT)pci != -1) {
    1044               /* make found item current item */
    1045               WinSendMsg(hwnd,
    1046                          CM_SETRECORDEMPHASIS,
    1047                          MPFROMP(pci),
    1048                          MPFROM2SHORT(TRUE,CRA_CURSORED));
    1049               /* make sure that record shows in viewport */
    1050               ShowCnrRecord(hwnd,
    1051                             (PMINIRECORDCORE)pci);
    1052               return (MRESULT)TRUE;
    1053             }
    1054             else {
    1055               if(SHORT1FROMMP(mp2) == ' ') {
    1056                 dcd->szCommonName[len] = 0;
    1057                 break;
    1058               }
    1059               *dcd->szCommonName = 0;
    1060               dcd->lasttime = 0;
    1061               if(len)           // retry as first letter if no match
    1062                 goto KbdRetry;
    1063             }
    1064             break;
    1065         }
    1066       }
    1067       break;
    1068 
    1069     case WM_MOUSEMOVE:
    1070     case WM_BUTTON1UP:
    1071     case WM_BUTTON2UP:
    1072     case WM_BUTTON3UP:
    1073       shiftstate = (SHORT2FROMMP(mp2) & (KC_SHIFT | KC_ALT | KC_CTRL));
    1074       break;
    1075 
    1076     case UM_TIMER:
    1077       if(dcd && dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent) &&
    1078          hwndStatus2)
    1079       {
    1080         FILEFINDBUF3 ffb;
    1081         ULONG        nm = 1L;
    1082         HDIR         hdir =  HDIR_CREATE;
    1083 
    1084         if(*SwapperDat)
    1085         {
    1086           if (!DosFindFirst(SwapperDat,
    1087                             &hdir,
    1088                             FILE_NORMAL | FILE_HIDDEN |
    1089                             FILE_SYSTEM | FILE_ARCHIVED | FILE_READONLY,
    1090                             &ffb,
    1091                             sizeof(ffb),
    1092                             &nm,
    1093                             FIL_STANDARD))
    1094           {
    1095             CHAR  tb[39],tm[39],tpm[39],s[163];
    1096             ULONG amem;
    1097 
    1098             priority_bumped();
    1099             DosFindClose(hdir);
    1100             if (!DosQuerySysInfo(QSV_TOTAVAILMEM,
    1101                                  QSV_TOTAVAILMEM,
    1102                                  (PVOID)&amem,
    1103                                  sizeof(amem)))
    1104             {
    1105               CommaFmtULL(tpm,sizeof(tpm),amem,'M');
    1106             }
    1107             else
    1108               *tpm = 0;
    1109             if (!Dos16MemAvail(&amem))
    1110               CommaFmtULL(tm,sizeof(tm),amem,'M');
    1111             else
    1112               *tm = 0;
    1113             CommaFmtULL(tb,sizeof(tb),ffb.cbFile,'M');
    1114             sprintf(s," %s %s%s%s%s%s",
    1115                     GetPString(IDS_SWAPFILETEXT),
    1116                     tb,
    1117                     *tm ? GetPString(IDS_TREEMEMTEXT) : NullStr,
    1118                     tm,
    1119                     *tpm ? "/" : NullStr,
    1120                     tpm);
    1121             WinSetWindowText(hwndStatus2,s);
    1122           }
    1123           else
    1124             WinSetWindowText(hwndStatus2,NullStr);
    1125         }
    1126         else
    1127           WinSetWindowText(hwndStatus2,NullStr);
    1128       }
    1129       if(msg == UM_TIMER)
    1130         return 0;
    1131       break;
    1132 
    1133     case WM_PRESPARAMCHANGED:
    1134       PresParamChanged(hwnd,
    1135                        "TreeCnr",
    1136                        mp1,
    1137                        mp2);
    1138       break;
    1139 
    1140     case UM_FILESMENU:
    1141       {
    1142         PCNRITEM pci;
    1143         HWND     menuHwnd = (HWND)0;
    1144 
    1145         pci = (PCNRITEM)CurrentRecord(hwnd);
    1146         if(pci && (INT)pci != -1) {
    1147           if(IsRoot(pci->szFileName))
    1148             menuHwnd = CheckMenu(&TreeMenu,
    1149                                  TREE_POPUP);
    1150           else {
    1151             menuHwnd = CheckMenu(&DirMenu,
    1152                                  DIR_POPUP);
     984          menuHwnd = CheckMenu(&DirMenu, DIR_POPUP);
    1153985//            WinEnableMenuItem(DirMenu,
    1154986//                              IDM_TREE,
    1155987//                              FALSE);
    1156           }
    1157           if(!(pci->attrFile & FILE_DIRECTORY))
    1158             menuHwnd = CheckMenu(&FileMenu,
    1159                                  FILE_POPUP);
    1160         }
    1161         return MRFROMLONG(menuHwnd);
    1162       }
    1163 
    1164     case UM_COMPARE:
    1165       if(dcd && mp1 && mp2) {
    1166 
    1167         COMPARE *cmp;
    1168         CHAR    *leftdir = (CHAR *)mp1,*rightdir = (CHAR *)mp2;
    1169 
    1170         if (!IsFile(leftdir) && !IsFile(rightdir)) {
    1171           cmp = xmallocz(sizeof(COMPARE),pszSrcFile,__LINE__);
    1172           if(cmp) {
    1173             cmp->size = sizeof(COMPARE);
    1174             strcpy(cmp->leftdir,leftdir);
    1175             strcpy(cmp->rightdir,rightdir);
    1176             cmp->hwndParent = dcd->hwndParent;
    1177             cmp->dcd.hwndParent = dcd->hwndParent;
    1178             WinDlgBox(HWND_DESKTOP,
    1179                       HWND_DESKTOP,
    1180                       CompareDlgProc,
    1181                       FM3ModHandle,
    1182                       COMP_FRAME,
    1183                       MPFROMP(cmp));
    1184           }
    1185         }
    1186       }
     988        }
     989        if (!(pci->attrFile & FILE_DIRECTORY))
     990          menuHwnd = CheckMenu(&FileMenu, FILE_POPUP);
     991      }
     992      return MRFROMLONG(menuHwnd);
     993    }
     994
     995  case UM_COMPARE:
     996    if (dcd && mp1 && mp2) {
     997
     998      COMPARE *cmp;
     999      CHAR *leftdir = (CHAR *) mp1, *rightdir = (CHAR *) mp2;
     1000
     1001      if (!IsFile(leftdir) && !IsFile(rightdir)) {
     1002        cmp = xmallocz(sizeof(COMPARE), pszSrcFile, __LINE__);
     1003        if (cmp) {
     1004          cmp->size = sizeof(COMPARE);
     1005          strcpy(cmp->leftdir, leftdir);
     1006          strcpy(cmp->rightdir, rightdir);
     1007          cmp->hwndParent = dcd->hwndParent;
     1008          cmp->dcd.hwndParent = dcd->hwndParent;
     1009          WinDlgBox(HWND_DESKTOP,
     1010                    HWND_DESKTOP,
     1011                    CompareDlgProc, FM3ModHandle, COMP_FRAME, MPFROMP(cmp));
     1012        }
     1013      }
     1014    }
     1015    return 0;
     1016
     1017  case UM_UPDATERECORDLIST:
     1018    if (dcd && mp1)
     1019      WinSendMsg(dcd->hwndObject, msg, mp1, mp2);
     1020    return 0;
     1021
     1022  case UM_UPDATERECORD:
     1023    if (dcd && mp1) {
     1024
     1025      CHAR *filename;
     1026
     1027      filename = mp1;
     1028      if (filename)
     1029        UpdateCnrRecord(hwnd, filename, TRUE, dcd);
     1030    }
     1031    return 0;
     1032
     1033  case WM_SETFOCUS:
     1034    if (dcd && hwndStatus && mp2) {
     1035      WinSendMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
     1036      if (hwndMain)
     1037        PostMsg(hwndMain, UM_ADVISEFOCUS, MPFROMLONG(dcd->hwndFrame), MPVOID);
     1038    }
     1039    break;
     1040
     1041  case UM_RESCAN:
     1042    if (dcd && dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent)) {
     1043      /*
     1044       * put name of our window on status line
     1045       */
     1046
     1047      PCNRITEM pci = NULL;
     1048      CHAR str[CCHMAXPATH + 6];
     1049
     1050      if (fAutoView && hwndMain) {
     1051        pci = WinSendMsg(hwnd,
     1052                         CM_QUERYRECORDEMPHASIS,
     1053                         MPFROMLONG(CMA_FIRST), MPFROMSHORT(CRA_CURSORED));
     1054        if (pci && (INT) pci != -1 && fComments &&
     1055            !(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_SLOW))
     1056          WinSendMsg(hwndMain, UM_LOADFILE, MPFROMP(pci->szFileName), MPVOID);
     1057        else
     1058          WinSendMsg(hwndMain, UM_LOADFILE, MPVOID, MPVOID);
     1059      }
     1060      if (!fAutoView || !hwndMain)
     1061        pci = (PCNRITEM) WinSendMsg(hwnd,
     1062                                    CM_QUERYRECORDEMPHASIS,
     1063                                    MPFROMLONG(CMA_FIRST),
     1064                                    MPFROMSHORT(CRA_CURSORED));
     1065      if ((INT) pci == -1)
     1066        pci = NULL;
     1067      if (pci) {
     1068        if (*(ULONG *) realappname == FM3UL) {
     1069          sprintf(str, "%s %s", GetPString(IDS_DTTEXT), pci->szFileName);
     1070          WinSetWindowText(dcd->hwndFrame, str);
     1071          WinSetWindowText(WinWindowFromID(dcd->hwndFrame, FID_TITLEBAR),
     1072                           str);
     1073        }
     1074        else
     1075          WinSetWindowText(WinWindowFromID(dcd->hwndFrame,
     1076                                           MAIN_STATUS), pci->szFileName);
     1077        if (fMoreButtons && hwndName) {
     1078          WinSetWindowText(hwndName, pci->szFileName);
     1079          sprintf(str,
     1080                  "%04u/%02u/%02u %02u:%02u:%02u",
     1081                  pci->date.year,
     1082                  pci->date.month,
     1083                  pci->date.day,
     1084                  pci->time.hours, pci->time.minutes, pci->time.seconds);
     1085          WinSetWindowText(hwndDate, str);
     1086          WinSetWindowText(hwndAttr, pci->pszDispAttr);
     1087        }
     1088      }
     1089      PostMsg(dcd->hwndObject, UM_RESCAN2, MPFROMP(pci), MPVOID);
     1090      if (hwndStatus2)
     1091        PostMsg(hwnd, UM_TIMER, MPVOID, MPVOID);
     1092    }
     1093    return 0;
     1094
     1095  case UM_SETUP2:
     1096    {
     1097      PCNRITEM pci = (PCNRITEM) mp1;
     1098
     1099      if (pci)
     1100        NotifyError(pci->szFileName, (ULONG) mp2);
     1101    }
     1102    return 0;
     1103
     1104  case UM_SETUP:
     1105    if (!dcd) {
     1106      Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
     1107      PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
    11871108      return 0;
    1188 
    1189     case UM_UPDATERECORDLIST:
    1190       if(dcd && mp1)
    1191         WinSendMsg(dcd->hwndObject,
    1192                    msg,
    1193                    mp1,
    1194                    mp2);
    1195       return 0;
    1196 
    1197     case UM_UPDATERECORD:
    1198       if(dcd && mp1) {
    1199 
    1200         CHAR *filename;
    1201 
    1202         filename = mp1;
    1203         if(filename)
    1204           UpdateCnrRecord(hwnd,
    1205                           filename,
    1206                           TRUE,
    1207                           dcd);
    1208       }
    1209       return 0;
    1210 
    1211     case WM_SETFOCUS:
    1212       if(dcd && hwndStatus && mp2) {
     1109    }
     1110    else {
     1111      if (!dcd->hwndObject) {
     1112        /*
     1113         * first time through -- set things up
     1114         */
     1115
     1116        CNRINFO cnri;
     1117
     1118        RestorePresParams(hwnd, "TreeCnr");
     1119        memset(&cnri, 0, sizeof(CNRINFO));
     1120        cnri.cb = sizeof(CNRINFO);
    12131121        WinSendMsg(hwnd,
    1214                    UM_RESCAN,
    1215                    MPVOID,
    1216                    MPVOID);
    1217         if(hwndMain)
    1218           PostMsg(hwndMain,
    1219                   UM_ADVISEFOCUS,
    1220                   MPFROMLONG(dcd->hwndFrame),
    1221                   MPVOID);
    1222       }
    1223       break;
    1224 
    1225     case UM_RESCAN:
    1226       if(dcd && dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent)) {
    1227         /*
    1228          * put name of our window on status line
    1229          */
    1230 
    1231         PCNRITEM  pci = NULL;
    1232         CHAR      str[CCHMAXPATH + 6];
    1233 
    1234         if(fAutoView && hwndMain) {
    1235           pci = WinSendMsg(hwnd,
    1236                            CM_QUERYRECORDEMPHASIS,
    1237                            MPFROMLONG(CMA_FIRST),
    1238                            MPFROMSHORT(CRA_CURSORED));
    1239           if(pci && (INT)pci != -1 && fComments &&
    1240              !(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_SLOW))
    1241             WinSendMsg(hwndMain,
    1242                        UM_LOADFILE,
    1243                        MPFROMP(pci->szFileName),
    1244                        MPVOID);
    1245           else
    1246             WinSendMsg(hwndMain,
    1247                        UM_LOADFILE,
    1248                        MPVOID,
    1249                        MPVOID);
    1250         }
    1251         if(!fAutoView ||
    1252            !hwndMain)
    1253           pci = (PCNRITEM)WinSendMsg(hwnd,
    1254                                      CM_QUERYRECORDEMPHASIS,
    1255                                      MPFROMLONG(CMA_FIRST),
    1256                                      MPFROMSHORT(CRA_CURSORED));
    1257         if((INT)pci == -1)
    1258           pci = NULL;
    1259         if(pci) {
    1260           if(*(ULONG *)realappname == FM3UL) {
    1261             sprintf(str,
    1262                     "%s %s",
    1263                     GetPString(IDS_DTTEXT),
    1264                     pci->szFileName);
    1265             WinSetWindowText(dcd->hwndFrame,
    1266                              str);
    1267             WinSetWindowText(WinWindowFromID(dcd->hwndFrame,FID_TITLEBAR),
    1268                              str);
    1269           }
    1270           else
    1271             WinSetWindowText(WinWindowFromID(dcd->hwndFrame,
    1272                                              MAIN_STATUS),
    1273                              pci->szFileName);
    1274           if(fMoreButtons && hwndName) {
    1275             WinSetWindowText(hwndName,
    1276                              pci->szFileName);
    1277             sprintf(str,
    1278                     "%04u/%02u/%02u %02u:%02u:%02u",
    1279                     pci->date.year,
    1280                     pci->date.month,
    1281                     pci->date.day,
    1282                     pci->time.hours,
    1283                     pci->time.minutes,
    1284                     pci->time.seconds);
    1285             WinSetWindowText(hwndDate,
    1286                              str);
    1287             WinSetWindowText(hwndAttr,
    1288                              pci->pszDispAttr);
    1289           }
    1290         }
    1291         PostMsg(dcd->hwndObject,
    1292                 UM_RESCAN2,
    1293                 MPFROMP(pci),
    1294                 MPVOID);
    1295         if(hwndStatus2)
    1296           PostMsg(hwnd,
    1297                   UM_TIMER,
    1298                   MPVOID,
    1299                   MPVOID);
    1300       }
    1301       return 0;
    1302 
    1303     case UM_SETUP2:
    1304       {
    1305         PCNRITEM pci = (PCNRITEM)mp1;
    1306 
    1307         if(pci)
    1308           NotifyError(pci->szFileName,
    1309                       (ULONG)mp2);
    1310       }
    1311       return 0;
    1312 
    1313     case UM_SETUP:
    1314       if (!dcd) {
    1315         Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
    1316         PostMsg(hwnd,WM_CLOSE,MPVOID,MPVOID);
     1122                   CM_QUERYCNRINFO,
     1123                   MPFROMP(&cnri), MPFROMLONG(sizeof(CNRINFO)));
     1124        cnri.cyLineSpacing = 0;
     1125        cnri.cxTreeIndent = 12L;
     1126        cnri.pSortRecord = (PVOID) SortTreeCnr;
     1127        cnri.flWindowAttr &= (~(CV_NAME | CV_DETAIL | CV_TEXT));
     1128        cnri.flWindowAttr |= (CV_TREE | CA_TREELINE | CV_ICON | CV_MINI);
     1129        {
     1130          ULONG size = sizeof(ULONG);
     1131
     1132          PrfQueryProfileData(fmprof,
     1133                              appname,
     1134                              "TreeflWindowAttr",
     1135                              (PVOID) & cnri.flWindowAttr, &size);
     1136          size = sizeof(MASK);
     1137          *dcd->mask.prompt = 0;
     1138          if (!*dcd->mask.szMask && !dcd->mask.attrFile) {
     1139            if (PrfQueryProfileSize(fmprof,
     1140                                    appname, "TreeFilter", &size) && size) {
     1141              PrfQueryProfileData(fmprof,
     1142                                  appname, "TreeFilter", &dcd->mask, &size);
     1143              SetMask(NULL, &dcd->mask);
     1144            }
     1145            else
     1146              dcd->mask.attrFile = (FILE_READONLY | FILE_NORMAL |
     1147                                    FILE_ARCHIVED | FILE_DIRECTORY |
     1148                                    FILE_HIDDEN | FILE_SYSTEM);
     1149          }
     1150          dcd->mask.attrFile |= FILE_DIRECTORY;
     1151        }
     1152        cnri.flWindowAttr &= (~(CA_MIXEDTARGETEMPH | CA_ORDEREDTARGETEMPH));
     1153        cnri.flWindowAttr |= CV_FLOW;
     1154        dcd->flWindowAttr = cnri.flWindowAttr;
     1155        WinSendMsg(hwnd,
     1156                   CM_SETCNRINFO,
     1157                   MPFROMP(&cnri),
     1158                   MPFROMLONG(CMA_FLWINDOWATTR | CMA_LINESPACING |
     1159                              CMA_CXTREEINDENT | CMA_PSORTRECORD));
     1160        if (_beginthread(MakeObjWin, NULL, 327680, (PVOID) dcd) == -1) {
     1161          Runtime_Error(pszSrcFile, __LINE__,
     1162                        GetPString(IDS_COULDNTSTARTTHREADTEXT));
     1163          PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
     1164          return 0;
     1165        }
     1166        else
     1167          DosSleep(1L);
     1168      }
     1169    }
     1170    return 0;
     1171
     1172  case WM_BUTTON3CLICK:
     1173  case WM_CHORD:
     1174    {
     1175      PCNRITEM pci = NULL;
     1176      QUERYRECFROMRECT pqr;
     1177      NOTIFYRECORDENTER nr;
     1178      BOOL tbool = fDCOpens;
     1179      RECTL rectl;
     1180      POINTL ptl;
     1181
     1182      shiftstate = (SHORT2FROMMP(mp2) & (KC_SHIFT | KC_ALT | KC_CTRL));
     1183      if (msg == WM_CHORD) {
     1184        if (!WinQueryPointerPos(HWND_DESKTOP, &ptl))
     1185          break;
     1186        WinMapWindowPoints(HWND_DESKTOP, hwnd, &ptl, 1L);
     1187      }
     1188      else {
     1189        ptl.x = SHORT1FROMMP(mp1);
     1190        ptl.y = SHORT2FROMMP(mp1);
     1191      }
     1192      memset(&rectl, 0, sizeof(rectl));
     1193      memset(&pqr, 0, sizeof(pqr));
     1194      pqr.cb = sizeof(pqr);
     1195      pqr.rect.xLeft = ptl.x - 1;
     1196      pqr.rect.xRight = ptl.x + 1;
     1197      pqr.rect.yTop = ptl.y + 1;
     1198      pqr.rect.yBottom = ptl.y - 1;
     1199      pqr.fsSearch = CMA_PARTIAL;
     1200      pci = (PCNRITEM) WinSendMsg(hwnd,
     1201                                  CM_QUERYRECORDFROMRECT,
     1202                                  MPFROMLONG(CMA_FIRST), MPFROMP(&pqr));
     1203      if (!pci || (INT) pci == -1)
     1204        Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
     1205      else {
     1206        memset(&nr, 0, sizeof(nr));
     1207        nr.hwndCnr = hwnd;
     1208        nr.pRecord = (PRECORDCORE) pci;
     1209        fDCOpens = TRUE;
     1210        WinSendMsg(hwnd,
     1211                   WM_CONTROL,
     1212                   MPFROM2SHORT(WinQueryWindowUShort(hwnd,
     1213                                                     QWS_ID),
     1214                                CN_ENTER), MPFROMP(&nr));
     1215        PostMsg(hwnd, UM_RESTOREDC, MPFROMLONG(tbool), MPVOID);
     1216      }
     1217    }
     1218    break;
     1219
     1220  case UM_RESTOREDC:
     1221    fDCOpens = (BOOL) mp1;
     1222    return 0;
     1223
     1224  case WM_CONTROL:
     1225    DosError(FERR_DISABLEHARDERR);
     1226    if (dcd) {
     1227      switch (SHORT2FROMMP(mp1)) {
     1228      case CN_BEGINEDIT:
     1229      case CN_REALLOCPSZ:
     1230      case CN_ENDEDIT:
     1231        {
     1232          MRESULT mre;
     1233
     1234          mre = CnrDirectEdit(hwnd, msg, mp1, mp2);
     1235          if (mre != (MRESULT) - 1)
     1236            return mre;
     1237        }
     1238        break;
     1239
     1240      case CN_DRAGLEAVE:
     1241        if (mp2) {
     1242
     1243          PDRAGINFO pDInfo;
     1244
     1245          pDInfo = ((PCNRDRAGINFO) mp2)->pDragInfo;
     1246          DrgAccessDraginfo(pDInfo);
     1247          DrgFreeDraginfo(pDInfo);
     1248        }
    13171249        return 0;
    1318       }
    1319       else {
    1320         if(!dcd->hwndObject) {
    1321           /*
    1322            * first time through -- set things up
    1323            */
    1324 
    1325           CNRINFO cnri;
    1326 
    1327           RestorePresParams(hwnd,"TreeCnr");
    1328           memset(&cnri,0,sizeof(CNRINFO));
    1329           cnri.cb = sizeof(CNRINFO);
    1330           WinSendMsg(hwnd,
    1331                      CM_QUERYCNRINFO,
    1332                      MPFROMP(&cnri),
    1333                      MPFROMLONG(sizeof(CNRINFO)));
    1334           cnri.cyLineSpacing = 0;
    1335           cnri.cxTreeIndent = 12L;
    1336           cnri.pSortRecord = (PVOID)SortTreeCnr;
    1337           cnri.flWindowAttr &= (~(CV_NAME | CV_DETAIL | CV_TEXT));
    1338           cnri.flWindowAttr |= (CV_TREE | CA_TREELINE | CV_ICON | CV_MINI);
    1339           {
    1340             ULONG size = sizeof(ULONG);
    1341 
    1342             PrfQueryProfileData(fmprof,
    1343                                 appname,
    1344                                 "TreeflWindowAttr",
    1345                                 (PVOID)&cnri.flWindowAttr,
    1346                                 &size);
    1347             size = sizeof(MASK);
    1348             *dcd->mask.prompt = 0;
    1349             if(!*dcd->mask.szMask && !dcd->mask.attrFile) {
    1350               if(PrfQueryProfileSize(fmprof,
    1351                                      appname,
    1352                                      "TreeFilter",
    1353                                      &size) &&
    1354                 size) {
    1355                 PrfQueryProfileData(fmprof,
    1356                                     appname,
    1357                                     "TreeFilter",
    1358                                     &dcd->mask,
    1359                                     &size);
    1360                 SetMask(NULL,&dcd->mask);
     1250
     1251      case CN_DRAGAFTER:
     1252      case CN_DRAGOVER:
     1253        if (mp2) {
     1254
     1255          PDRAGITEM pDItem;
     1256          PDRAGINFO pDInfo;
     1257          PCNRITEM pci;
     1258          USHORT uso;
     1259
     1260          pDInfo = ((PCNRDRAGINFO) mp2)->pDragInfo;
     1261          DrgAccessDraginfo(pDInfo);
     1262          pci = (PCNRITEM) ((PCNRDRAGINFO) mp2)->pRecord;
     1263          if ((INT) pci == -1)
     1264            pci = NULL;
     1265          if (pci && (pci->flags & (RECFLAGS_ENV | RECFLAGS_NODROP))) {
     1266            DrgFreeDraginfo(pDInfo);
     1267            return MRFROM2SHORT(DOR_NODROP, 0);
     1268          }
     1269          if (!pDInfo) {
     1270            DrgFreeDraginfo(pDInfo);
     1271            return MRFROM2SHORT(DOR_NODROP, 0);
     1272          }
     1273          if (!WinIsWindowEnabled(dcd->hwndFrame)) {
     1274            DrgFreeDraginfo(pDInfo);
     1275            return MRFROM2SHORT(DOR_NODROP, 0);
     1276          }
     1277          if (pci) {
     1278            uso = pDInfo->usOperation;
     1279            if (uso == DO_DEFAULT)
     1280              uso = (fCopyDefault) ? DO_COPY : DO_MOVE;
     1281            if (!(pci->attrFile & FILE_DIRECTORY)) {
     1282              if (uso != DO_LINK && uso != DO_COPY && uso != DO_MOVE) {
     1283                DrgFreeDraginfo(pDInfo);
     1284                return (MRFROM2SHORT(DOR_NODROP, 0));
     1285              }
     1286              if (uso != DO_LINK &&
     1287                  !(driveflags[toupper(*pci->szFileName) - 'A'] &
     1288                    DRIVE_NOTWRITEABLE)) {
     1289
     1290                ARC_TYPE *info;
     1291
     1292                if (!fQuickArcFind &&
     1293                    !(driveflags[toupper(*pci->szFileName) - 'A'] &
     1294                      DRIVE_SLOW))
     1295                  info = find_type(pci->szFileName, NULL);
     1296                else
     1297                  info = quick_find_type(pci->szFileName, NULL);
     1298                if (!info || ((uso == DO_MOVE && !info->move) ||
     1299                              (uso == DO_COPY && !info->create))) {
     1300                  DrgFreeDraginfo(pDInfo);
     1301                  return (MRFROM2SHORT(DOR_NODROP, 0));
     1302                }
     1303              }
     1304            }
     1305          }
     1306          pDItem = DrgQueryDragitemPtr(pDInfo,  /* Access DRAGITEM       */
     1307                                       0);      /* Index to DRAGITEM     */
     1308          if (DrgVerifyRMF(pDItem,      /* Check valid rendering */
     1309                           DRM_OS2FILE, /* mechanisms and data   */
     1310                           NULL) || DrgVerifyRMF(pDItem, DRM_FM2ARCMEMBER, DRF_FM2ARCHIVE)) {   /* formats               */
     1311            DrgFreeDraginfo(pDInfo);    /* Free DRAGINFO         */
     1312            if (!pci || (INT) pci == -1)
     1313              return MRFROM2SHORT(DOR_DROP, DO_MOVE);
     1314            if (driveflags[toupper(*pci->szFileName) - 'A'] &
     1315                DRIVE_NOTWRITEABLE)
     1316              return MRFROM2SHORT(DOR_DROP, DO_LINK);
     1317            if (toupper(*pci->szFileName) < 'C')
     1318              return MRFROM2SHORT(DOR_DROP, DO_COPY);
     1319            return MRFROM2SHORT(DOR_DROP,       /* Return okay to drop   */
     1320                                ((fCopyDefault) ? DO_COPY : DO_MOVE));
     1321          }
     1322          DrgFreeDraginfo(pDInfo);      /* Free DRAGINFO         */
     1323        }
     1324        return MRFROM2SHORT(DOR_NODROP, 0);     /* Drop not valid        */
     1325
     1326      case CN_INITDRAG:
     1327        {
     1328          PCNRDRAGINIT pcd = (PCNRDRAGINIT) mp2;
     1329          PCNRITEM pci;
     1330
     1331          if (!pcd) {
     1332            Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
     1333            break;
     1334          }
     1335          else {
     1336            pci = (PCNRITEM) pcd->pRecord;
     1337            if (!pci || (INT) pci == -1) {
     1338              Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
     1339              break;
     1340            }
     1341            if (pci->flags & (RECFLAGS_ENV | RECFLAGS_NODRAG)) {
     1342              Runtime_Error(pszSrcFile, __LINE__, "drag not allowed");
     1343              break;
     1344            }
     1345            if (hwndStatus2) {
     1346              WinSetWindowText(hwndStatus2, (IsRoot(pci->szFileName)) ?
     1347                               GetPString(IDS_DRAGROOTTEXT) :
     1348                               (pci->attrFile & FILE_DIRECTORY) ?
     1349                               GetPString(IDS_DRAGDIRTEXT) :
     1350                               GetPString(IDS_DRAGFILETEXT));
     1351            }
     1352            DoFileDrag(hwnd, dcd->hwndObject, mp2, NULL, NULL, TRUE);
     1353            if (hwndStatus2) {
     1354              PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
     1355            }
     1356          }
     1357        }
     1358        return 0;
     1359
     1360      case CN_DROP:
     1361        {
     1362          LISTINFO *li;
     1363          ULONG action = UM_ACTION;
     1364
     1365          li = DoFileDrop(hwnd, NULL, TRUE, mp1, mp2);
     1366          if (li) {
     1367            if (!*li->targetpath) {
     1368              if (li->list[0])
     1369                PMMkDir(dcd->hwndParent, li->list[0], FALSE);
     1370              FreeListInfo(li);
     1371              return 0;
     1372            }
     1373            if (li->list && li->list[0] && IsRoot(li->list[0]))
     1374              li->type = DO_LINK;
     1375            else if (fDragndropDlg && (!*li->arcname || !li->info)) {
     1376
     1377              CHECKLIST cl;
     1378
     1379              memset(&cl, 0, sizeof(cl));
     1380              cl.size = sizeof(cl);
     1381              cl.flags = li->type;
     1382              cl.list = li->list;
     1383              cl.cmd = li->type;
     1384              cl.prompt = li->targetpath;
     1385              li->type = WinDlgBox(HWND_DESKTOP,
     1386                                   dcd->hwndParent,
     1387                                   DropListProc,
     1388                                   FM3ModHandle, DND_FRAME, MPFROMP(&cl));
     1389              if (!li->type) {
     1390                FreeListInfo(li);
     1391                return 0;
     1392              }
     1393              li->list = cl.list;
     1394              if (!li->list || !li->list[0]) {
     1395                FreeListInfo(li);
     1396                return 0;
     1397              }
     1398            }
     1399            switch (li->type) {
     1400            case DO_LINK:
     1401              if (fLinkSetsIcon) {
     1402                li->type = IDM_SETICON;
     1403                action = UM_MASSACTION;
    13611404              }
    13621405              else
    1363                 dcd->mask.attrFile = (FILE_READONLY | FILE_NORMAL |
    1364                                       FILE_ARCHIVED | FILE_DIRECTORY |
    1365                                       FILE_HIDDEN   | FILE_SYSTEM);
    1366             }
    1367             dcd->mask.attrFile |= FILE_DIRECTORY;
    1368           }
    1369           cnri.flWindowAttr &= (~(CA_MIXEDTARGETEMPH | CA_ORDEREDTARGETEMPH));
    1370           cnri.flWindowAttr |= CV_FLOW;
    1371           dcd->flWindowAttr = cnri.flWindowAttr;
    1372           WinSendMsg(hwnd,
    1373                      CM_SETCNRINFO,
    1374                      MPFROMP(&cnri),
    1375                      MPFROMLONG(CMA_FLWINDOWATTR | CMA_LINESPACING |
    1376                                 CMA_CXTREEINDENT | CMA_PSORTRECORD));
    1377           if (_beginthread(MakeObjWin,NULL,327680,(PVOID)dcd) == -1) {
    1378             Runtime_Error(pszSrcFile, __LINE__, GetPString(IDS_COULDNTSTARTTHREADTEXT));
    1379             PostMsg(hwnd,
    1380                     WM_CLOSE,
    1381                     MPVOID,
    1382                     MPVOID);
    1383             return 0;
    1384           }
    1385           else
    1386             DosSleep(1L);
    1387         }
    1388       }
    1389       return 0;
    1390 
    1391     case WM_BUTTON3CLICK:
    1392     case WM_CHORD:
    1393       {
    1394         PCNRITEM          pci = NULL;
    1395         QUERYRECFROMRECT  pqr;
    1396         NOTIFYRECORDENTER nr;
    1397         BOOL              tbool = fDCOpens;
    1398         RECTL             rectl;
    1399         POINTL            ptl;
    1400 
    1401         shiftstate = (SHORT2FROMMP(mp2) & (KC_SHIFT | KC_ALT | KC_CTRL));
    1402         if(msg == WM_CHORD) {
    1403           if(!WinQueryPointerPos(HWND_DESKTOP,
    1404                                  &ptl))
    1405             break;
    1406           WinMapWindowPoints(HWND_DESKTOP,
    1407                              hwnd,
    1408                              &ptl,
    1409                              1L);
    1410         }
    1411         else {
    1412           ptl.x = SHORT1FROMMP(mp1);
    1413           ptl.y = SHORT2FROMMP(mp1);
    1414         }
    1415         memset(&rectl,0,sizeof(rectl));
    1416         memset(&pqr,0,sizeof(pqr));
    1417         pqr.cb = sizeof(pqr);
    1418         pqr.rect.xLeft = ptl.x - 1;
    1419         pqr.rect.xRight = ptl.x + 1;
    1420         pqr.rect.yTop = ptl.y + 1;
    1421         pqr.rect.yBottom = ptl.y - 1;
    1422         pqr.fsSearch = CMA_PARTIAL;
    1423         pci = (PCNRITEM)WinSendMsg(hwnd,
    1424                                    CM_QUERYRECORDFROMRECT,
    1425                                    MPFROMLONG(CMA_FIRST),
    1426                                    MPFROMP(&pqr));
    1427         if(!pci || (INT)pci == -1)
    1428           Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
    1429         else {
    1430           memset(&nr,0,sizeof(nr));
    1431           nr.hwndCnr = hwnd;
    1432           nr.pRecord = (PRECORDCORE)pci;
    1433           fDCOpens = TRUE;
    1434           WinSendMsg(hwnd,
    1435                      WM_CONTROL,
    1436                      MPFROM2SHORT(WinQueryWindowUShort(hwnd,
    1437                                                        QWS_ID),
    1438                                   CN_ENTER),
    1439                      MPFROMP(&nr));
    1440           PostMsg(hwnd,
    1441                   UM_RESTOREDC,
    1442                   MPFROMLONG(tbool),
    1443                   MPVOID);
    1444         }
    1445       }
    1446       break;
    1447 
    1448     case UM_RESTOREDC:
    1449       fDCOpens = (BOOL)mp1;
    1450       return 0;
    1451 
    1452     case WM_CONTROL:
    1453       DosError(FERR_DISABLEHARDERR);
    1454       if(dcd) {
    1455         switch(SHORT2FROMMP(mp1)) {
    1456           case CN_BEGINEDIT:
    1457           case CN_REALLOCPSZ:
    1458           case CN_ENDEDIT:
    1459             {
    1460               MRESULT mre;
    1461 
    1462               mre = CnrDirectEdit(hwnd,
    1463                                   msg,
    1464                                   mp1,
    1465                                   mp2);
    1466               if(mre != (MRESULT)-1)
    1467                 return mre;
    1468             }
    1469             break;
    1470 
    1471           case CN_DRAGLEAVE:
    1472             if(mp2) {
    1473 
    1474               PDRAGINFO pDInfo;
    1475 
    1476               pDInfo = ((PCNRDRAGINFO)mp2)->pDragInfo;
    1477               DrgAccessDraginfo(pDInfo);
    1478               DrgFreeDraginfo(pDInfo);
    1479             }
    1480             return 0;
    1481 
    1482           case CN_DRAGAFTER:
    1483           case CN_DRAGOVER:
    1484             if(mp2) {
    1485 
    1486               PDRAGITEM pDItem;
    1487               PDRAGINFO pDInfo;
    1488               PCNRITEM  pci;
    1489               USHORT    uso;
    1490 
    1491               pDInfo = ((PCNRDRAGINFO)mp2)->pDragInfo;
    1492               DrgAccessDraginfo(pDInfo);
    1493               pci = (PCNRITEM)((PCNRDRAGINFO)mp2)->pRecord;
    1494               if((INT)pci == -1)
    1495                 pci = NULL;
    1496               if(pci &&
    1497                  (pci->flags & (RECFLAGS_ENV | RECFLAGS_NODROP))) {
    1498                 DrgFreeDraginfo(pDInfo);
    1499                 return MRFROM2SHORT(DOR_NODROP,0);
     1406                li->type = IDM_COMPARE;
     1407              break;
     1408            case DND_EXTRACT:
     1409              if (*li->targetpath && !IsFile(li->targetpath))
     1410                li->type = IDM_EXTRACT;
     1411              break;
     1412            case DND_MOVE:
     1413              li->type = IDM_MOVE;
     1414              if (*li->targetpath && IsFile(li->targetpath) == 1) {
     1415                action = UM_MASSACTION;
     1416                li->type = IDM_ARCHIVEM;
    15001417              }
    1501               if(!pDInfo) {
    1502                 DrgFreeDraginfo(pDInfo);
    1503                 return MRFROM2SHORT(DOR_NODROP,0);
     1418              break;
     1419            case DND_WILDMOVE:
     1420              li->type = IDM_WILDMOVE;
     1421              if (*li->targetpath && IsFile(li->targetpath) == 1) {
     1422                action = UM_MASSACTION;
     1423                li->type = IDM_ARCHIVEM;
    15041424              }
    1505               if(!WinIsWindowEnabled(dcd->hwndFrame)) {
    1506                 DrgFreeDraginfo(pDInfo);
    1507                 return MRFROM2SHORT(DOR_NODROP,0);
     1425              break;
     1426            case DND_OBJECT:
     1427              li->type = IDM_OBJECT;
     1428              action = UM_MASSACTION;
     1429              break;
     1430            case DND_SHADOW:
     1431              li->type = IDM_SHADOW;
     1432              action = UM_MASSACTION;
     1433              break;
     1434            case DND_COMPARE:
     1435              li->type = IDM_COMPARE;
     1436              break;
     1437            case DND_SETICON:
     1438              action = UM_MASSACTION;
     1439              li->type = IDM_SETICON;
     1440              break;
     1441            case DND_COPY:
     1442              li->type = IDM_COPY;
     1443              if (*li->targetpath && IsFile(li->targetpath) == 1) {
     1444                action = UM_MASSACTION;
     1445                li->type = IDM_ARCHIVE;
    15081446              }
    1509               if(pci) {
    1510                 uso = pDInfo->usOperation;
    1511                 if(uso == DO_DEFAULT)
    1512                   uso = (fCopyDefault) ? DO_COPY : DO_MOVE;
    1513                 if(!(pci->attrFile & FILE_DIRECTORY)) {
    1514                   if(uso != DO_LINK &&
    1515                      uso != DO_COPY &&
    1516                      uso != DO_MOVE) {
    1517                     DrgFreeDraginfo(pDInfo);
    1518                     return(MRFROM2SHORT(DOR_NODROP,0));
    1519                   }
    1520                   if(uso != DO_LINK &&
    1521                      !(driveflags[toupper(*pci->szFileName) - 'A'] &
    1522                        DRIVE_NOTWRITEABLE)) {
    1523 
    1524                     ARC_TYPE *info;
    1525 
    1526                     if(!fQuickArcFind &&
    1527                        !(driveflags[toupper(*pci->szFileName) - 'A'] &
    1528                          DRIVE_SLOW))
    1529                       info = find_type(pci->szFileName,NULL);
    1530                     else
    1531                       info = quick_find_type(pci->szFileName,NULL);
    1532                     if(!info || ((uso == DO_MOVE && !info->move) ||
    1533                        (uso == DO_COPY && !info->create)))  {
    1534                       DrgFreeDraginfo(pDInfo);
    1535                       return(MRFROM2SHORT(DOR_NODROP,0));
    1536                     }
     1447              break;
     1448            case DND_WILDCOPY:
     1449              li->type = IDM_WILDCOPY;
     1450              if (*li->targetpath && IsFile(li->targetpath) == 1) {
     1451                action = UM_MASSACTION;
     1452                li->type = IDM_ARCHIVE;
     1453              }
     1454              break;
     1455            default:
     1456              if (*li->arcname && li->info) {
     1457                action = UM_MASSACTION;
     1458                li->type = (li->type == DO_MOVE) ?
     1459                  IDM_FAKEEXTRACTM : IDM_FAKEEXTRACT;
     1460              }
     1461              else if (*li->targetpath && IsFile(li->targetpath) == 1) {
     1462                action = UM_MASSACTION;
     1463                li->type = (li->type == DO_MOVE) ? IDM_ARCHIVEM : IDM_ARCHIVE;
     1464              }
     1465              else
     1466                li->type = (li->type == DO_MOVE) ? IDM_MOVE : IDM_COPY;
     1467              break;
     1468            }
     1469            if (!li->list || !li->list[0])
     1470              FreeListInfo(li);
     1471            else if (!PostMsg(dcd->hwndObject, action, MPFROMP(li), MPVOID))
     1472              FreeListInfo(li);
     1473            else {
     1474
     1475              USHORT usop = 0;
     1476
     1477              switch (li->type) {
     1478              case IDM_COPY:
     1479              case IDM_WILDCOPY:
     1480                usop = DO_COPY;
     1481                break;
     1482              case IDM_MOVE:
     1483              case IDM_WILDMOVE:
     1484              case IDM_ARCHIVEM:
     1485                usop = DO_MOVE;
     1486                break;
     1487              }
     1488              if (usop)
     1489                return MRFROM2SHORT(DOR_DROP, usop);
     1490            }
     1491          }
     1492        }
     1493        return 0;
     1494
     1495      case CN_EMPHASIS:
     1496        if (!fDummy) {
     1497
     1498          PNOTIFYRECORDEMPHASIS pre = mp2;
     1499
     1500          if (pre->fEmphasisMask & CRA_SELECTED) {
     1501            if (pre->pRecord->flRecordAttr & CRA_SELECTED) {
     1502              if (((PCNRITEM) (pre->pRecord))->attrFile & FILE_DIRECTORY) {
     1503                PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
     1504                if (fFollowTree &&
     1505                    !(driveflags
     1506                      [toupper(*((PCNRITEM) pre->pRecord)->szFileName) -
     1507                       'A'] & DRIVE_INVALID)) {
     1508                  if (!LastDir && !ParentIsDesktop(hwnd, dcd->hwndParent))
     1509                    LastDir = FindDirCnr(dcd->hwndParent);
     1510                  if (LastDir) {
     1511
     1512                    NOTIFYRECORDENTER pri;
     1513                    BOOL tbool = fDCOpens;
     1514
     1515                    fDCOpens = FALSE;
     1516                    memset(&pri, 0, sizeof(pri));
     1517                    pri.hwndCnr = hwnd;
     1518                    pri.fKey = FALSE;
     1519                    pri.pRecord = pre->pRecord;
     1520                    WinSendMsg(hwnd,
     1521                               WM_CONTROL,
     1522                               MPFROM2SHORT(SHORT1FROMMP(mp1),
     1523                                            CN_ENTER), MPFROMP(&pri));
     1524                    fDCOpens = tbool;
    15371525                  }
    15381526                }
     1527                if (*(ULONG *) realappname != FM3UL)
     1528                  WinSetWindowText(WinWindowFromID(dcd->hwndFrame,
     1529                                                   MAIN_STATUS),
     1530                                   ((PCNRITEM) (pre->pRecord))->szFileName);
    15391531              }
    1540               pDItem = DrgQueryDragitemPtr(pDInfo,   /* Access DRAGITEM       */
    1541                                            0);       /* Index to DRAGITEM     */
    1542               if(DrgVerifyRMF(pDItem,                /* Check valid rendering */
    1543                               DRM_OS2FILE,           /* mechanisms and data   */
    1544                               NULL) ||
    1545                   DrgVerifyRMF(pDItem,DRM_FM2ARCMEMBER,
    1546                                DRF_FM2ARCHIVE)) {    /* formats               */
    1547                 DrgFreeDraginfo(pDInfo);             /* Free DRAGINFO         */
    1548                 if(!pci || (INT)pci == -1)
    1549                   return MRFROM2SHORT(DOR_DROP,DO_MOVE);
    1550                 if(driveflags[toupper(*pci->szFileName) - 'A'] &
    1551                    DRIVE_NOTWRITEABLE)
    1552                   return MRFROM2SHORT(DOR_DROP,DO_LINK);
    1553                 if(toupper(*pci->szFileName) < 'C')
    1554                   return MRFROM2SHORT(DOR_DROP,DO_COPY);
    1555                 return MRFROM2SHORT(DOR_DROP,     /* Return okay to drop   */
    1556                                     ((fCopyDefault) ?
    1557                                     DO_COPY :
    1558                                     DO_MOVE));
     1532            }
     1533          }
     1534        }
     1535        break;
     1536
     1537      case CN_CONTEXTMENU:
     1538        {
     1539          PCNRITEM pci = (PCNRITEM) mp2;
     1540          BOOL wasFollowing;
     1541
     1542          DosEnterCritSec();
     1543          wasFollowing = fFollowTree;
     1544          fFollowTree = FALSE;
     1545          DosExitCritSec();
     1546          if (pci && (INT) pci != -1 && !(pci->flags & RECFLAGS_ENV)) {
     1547            WinSendMsg(hwnd,
     1548                       CM_SETRECORDEMPHASIS,
     1549                       MPFROMP(pci), MPFROM2SHORT(TRUE, CRA_CURSORED));
     1550            MarkAll(hwnd, FALSE, FALSE, TRUE);
     1551            if (!(pci->attrFile & FILE_DIRECTORY))
     1552              dcd->hwndLastMenu = CheckMenu(&FileMenu, FILE_POPUP);
     1553            else if (!IsRoot(pci->szFileName))
     1554              dcd->hwndLastMenu = CheckMenu(&DirMenu, DIR_POPUP);
     1555            else
     1556              dcd->hwndLastMenu = CheckMenu(&TreeMenu, TREE_POPUP);
     1557          }
     1558          else {
     1559            dcd->hwndLastMenu = CheckMenu(&TreeCnrMenu, TREECNR_POPUP);
     1560            if (dcd->hwndLastMenu && !dcd->cnremphasized) {
     1561              WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPVOID,
     1562                         MPFROM2SHORT(TRUE, CRA_SOURCE));
     1563              dcd->cnremphasized = TRUE;
     1564            }
     1565          }
     1566          if (dcd->hwndLastMenu) {
     1567            if (dcd->hwndLastMenu == DirMenu)
     1568              WinEnableMenuItem(DirMenu, IDM_TREE, FALSE);
     1569            if (dcd->hwndLastMenu == TreeCnrMenu) {
     1570              if (dcd->flWindowAttr & CV_MINI)
     1571                WinCheckMenuItem(dcd->hwndLastMenu, IDM_MINIICONS, TRUE);
     1572            }
     1573            if (!PopupMenu(hwnd, hwnd, dcd->hwndLastMenu)) {
     1574              if (dcd->cnremphasized) {
     1575                WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPVOID,
     1576                           MPFROM2SHORT(FALSE, CRA_SOURCE));
     1577                dcd->cnremphasized = FALSE;
    15591578              }
    1560               DrgFreeDraginfo(pDInfo);            /* Free DRAGINFO         */
    1561             }
    1562             return MRFROM2SHORT(DOR_NODROP,0);    /* Drop not valid        */
    1563 
    1564           case CN_INITDRAG:
    1565             {
    1566               PCNRDRAGINIT pcd = (PCNRDRAGINIT)mp2;
    1567               PCNRITEM     pci;
    1568 
    1569               if (!pcd) {
    1570                 Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
    1571                 break;
     1579              if (dcd->hwndLastMenu != TreeCnrMenu)
     1580                MarkAll(hwnd, TRUE, FALSE, TRUE);
     1581            }
     1582          }
     1583          DosEnterCritSec();
     1584          fFollowTree = wasFollowing;
     1585          DosExitCritSec();
     1586        }
     1587        break;
     1588
     1589      case CN_ENTER:
     1590        if (mp2) {
     1591          PCNRITEM pci = (PCNRITEM) ((PNOTIFYRECORDENTER) mp2)->pRecord;
     1592
     1593          PostMsg(hwnd, UM_ENTER, MPFROMP(pci), MPVOID);
     1594        }
     1595        break;
     1596
     1597      case CN_COLLAPSETREE:
     1598      case CN_EXPANDTREE:
     1599        {
     1600          PCNRITEM pci = (PCNRITEM) mp2;
     1601
     1602          if (pci && (INT) pci != -1 && !(pci->flags & RECFLAGS_ENV)) {
     1603            if (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_REMOVABLE) {
     1604
     1605              struct
     1606              {
     1607                ULONG serial;
     1608                CHAR volumelength;
     1609                CHAR volumelabel[CCHMAXPATH];
     1610              }
     1611              volser;
     1612
     1613              memset(&volser, 0, sizeof(volser));
     1614              DosError(FERR_DISABLEHARDERR);
     1615              if (!DosQueryFSInfo(toupper(*pci->szFileName) - '@',
     1616                                  FSIL_VOLSER, &volser,
     1617                                  (ULONG) sizeof(volser))) {
     1618                if (SHORT2FROMMP(mp1) == CN_COLLAPSETREE &&
     1619                    !volser.serial ||
     1620                    driveserial[toupper(*pci->szFileName) - 'A'] !=
     1621                    volser.serial)
     1622                  UnFlesh(hwnd, pci);
     1623                if (SHORT2FROMMP(mp1) != CN_COLLAPSETREE ||
     1624                    (!volser.serial ||
     1625                     driveserial[toupper(*pci->szFileName) - 'A'] !=
     1626                     volser.serial)) {
     1627                  if (Flesh(hwnd, pci) &&
     1628                      SHORT2FROMMP(mp1) == CN_EXPANDTREE &&
     1629                      !dcd->suspendview && fTopDir)
     1630                    PostMsg(hwnd, UM_TOPDIR, MPFROMP(pci), MPVOID);
     1631                }
     1632                driveserial[toupper(*pci->szFileName) - 'A'] = volser.serial;
    15721633              }
    15731634              else {
    1574                 pci = (PCNRITEM)pcd->pRecord;
    1575                 if (!pci || (INT)pci == -1) {
    1576                   Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
    1577                   break;
    1578                 }
    1579                 if (pci->flags & (RECFLAGS_ENV | RECFLAGS_NODRAG)) {
    1580                   Runtime_Error(pszSrcFile, __LINE__, "drag not allowed");
    1581                   break;
    1582                 }
    1583                 if(hwndStatus2) {
    1584                   WinSetWindowText(hwndStatus2,(IsRoot(pci->szFileName)) ?
    1585                                    GetPString(IDS_DRAGROOTTEXT) :
    1586                                    (pci->attrFile & FILE_DIRECTORY) ?
    1587                                    GetPString(IDS_DRAGDIRTEXT) :
    1588                                    GetPString(IDS_DRAGFILETEXT));
    1589                 }
    1590                 DoFileDrag(hwnd,
    1591                            dcd->hwndObject,
    1592                            mp2,
    1593                            NULL,
    1594                            NULL,
    1595                            TRUE);
    1596                 if(hwndStatus2) {
    1597                   PostMsg(hwnd,
    1598                           UM_RESCAN,
    1599                           MPVOID,
    1600                           MPVOID);
    1601                 }
     1635                driveserial[toupper(*pci->szFileName) - 'A'] = -1;
     1636                UnFlesh(hwnd, pci);
     1637                PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
     1638                DosBeep(250, 100);
    16021639              }
    16031640            }
    1604             return 0;
    1605 
    1606           case CN_DROP:
    1607             {
    1608               LISTINFO *li;
    1609               ULONG     action = UM_ACTION;
    1610 
    1611               li = DoFileDrop(hwnd,
    1612                               NULL,
    1613                               TRUE,
    1614                               mp1,
    1615                               mp2);
    1616               if(li) {
    1617                 if(!*li->targetpath) {
    1618                   if(li->list[0])
    1619                     PMMkDir(dcd->hwndParent,
    1620                             li->list[0],
    1621                             FALSE);
    1622                   FreeListInfo(li);
    1623                   return 0;
    1624                 }
    1625                 if(li->list &&
    1626                    li->list[0] &&
    1627                    IsRoot(li->list[0]))
    1628                   li->type = DO_LINK;
    1629                 else if(fDragndropDlg &&
    1630                         (!*li->arcname || !li->info)) {
    1631 
    1632                   CHECKLIST    cl;
    1633 
    1634                   memset(&cl,0,sizeof(cl));
    1635                   cl.size = sizeof(cl);
    1636                   cl.flags = li->type;
    1637                   cl.list = li->list;
    1638                   cl.cmd = li->type;
    1639                   cl.prompt = li->targetpath;
    1640                   li->type = WinDlgBox(HWND_DESKTOP,
    1641                                        dcd->hwndParent,
    1642                                        DropListProc,
    1643                                        FM3ModHandle,
    1644                                        DND_FRAME,
    1645                                        MPFROMP(&cl));
    1646                   if(!li->type) {
    1647                     FreeListInfo(li);
    1648                     return 0;
    1649                   }
    1650                   li->list = cl.list;
    1651                   if(!li->list || !li->list[0]) {
    1652                     FreeListInfo(li);
    1653                     return 0;
    1654                   }
    1655                 }
    1656                 switch(li->type) {
    1657                   case DO_LINK:
    1658                     if(fLinkSetsIcon) {
    1659                       li->type = IDM_SETICON;
    1660                       action = UM_MASSACTION;
    1661                     }
    1662                     else
    1663                       li->type = IDM_COMPARE;
    1664                     break;
    1665                   case DND_EXTRACT:
    1666                     if(*li->targetpath &&
    1667                        !IsFile(li->targetpath))
    1668                       li->type = IDM_EXTRACT;
    1669                     break;
    1670                   case DND_MOVE:
    1671                     li->type = IDM_MOVE;
    1672                     if(*li->targetpath &&
    1673                        IsFile(li->targetpath) == 1) {
    1674                       action = UM_MASSACTION;
    1675                       li->type = IDM_ARCHIVEM;
    1676                     }
    1677                     break;
    1678                   case DND_WILDMOVE:
    1679                     li->type = IDM_WILDMOVE;
    1680                     if(*li->targetpath &&
    1681                        IsFile(li->targetpath) == 1) {
    1682                       action = UM_MASSACTION;
    1683                       li->type = IDM_ARCHIVEM;
    1684                     }
    1685                     break;
    1686                   case DND_OBJECT:
    1687                     li->type = IDM_OBJECT;
    1688                     action = UM_MASSACTION;
    1689                     break;
    1690                   case DND_SHADOW:
    1691                     li->type = IDM_SHADOW;
    1692                     action = UM_MASSACTION;
    1693                     break;
    1694                   case DND_COMPARE:
    1695                     li->type = IDM_COMPARE;
    1696                     break;
    1697                   case DND_SETICON:
    1698                     action = UM_MASSACTION;
    1699                     li->type = IDM_SETICON;
    1700                     break;
    1701                   case DND_COPY:
    1702                     li->type = IDM_COPY;
    1703                     if(*li->targetpath &&
    1704                        IsFile(li->targetpath) == 1) {
    1705                       action = UM_MASSACTION;
    1706                       li->type = IDM_ARCHIVE;
    1707                     }
    1708                     break;
    1709                   case DND_WILDCOPY:
    1710                     li->type = IDM_WILDCOPY;
    1711                     if(*li->targetpath &&
    1712                        IsFile(li->targetpath) == 1) {
    1713                       action = UM_MASSACTION;
    1714                       li->type = IDM_ARCHIVE;
    1715                     }
    1716                     break;
    1717                   default:
    1718                     if(*li->arcname && li->info) {
    1719                       action = UM_MASSACTION;
    1720                       li->type = (li->type == DO_MOVE) ?
    1721                                   IDM_FAKEEXTRACTM :
    1722                                   IDM_FAKEEXTRACT;
    1723                     }
    1724                     else if(*li->targetpath &&
    1725                             IsFile(li->targetpath) == 1) {
    1726                       action = UM_MASSACTION;
    1727                       li->type = (li->type == DO_MOVE) ?
    1728                                   IDM_ARCHIVEM :
    1729                                   IDM_ARCHIVE;
    1730                     }
    1731                     else
    1732                       li->type = (li->type == DO_MOVE) ?
    1733                                   IDM_MOVE :
    1734                                   IDM_COPY;
    1735                     break;
    1736                 }
    1737                 if(!li->list || !li->list[0])
    1738                   FreeListInfo(li);
    1739                 else if(!PostMsg(dcd->hwndObject,
    1740                                  action,
    1741                                  MPFROMP(li),
    1742                                  MPVOID))
    1743                   FreeListInfo(li);
    1744                 else {
    1745 
    1746                   USHORT usop = 0;
    1747 
    1748                   switch(li->type) {
    1749                     case IDM_COPY:
    1750                     case IDM_WILDCOPY:
    1751                       usop = DO_COPY;
    1752                       break;
    1753                     case IDM_MOVE:
    1754                     case IDM_WILDMOVE:
    1755                     case IDM_ARCHIVEM:
    1756                       usop = DO_MOVE;
    1757                       break;
    1758                   }
    1759                   if(usop)
    1760                     return MRFROM2SHORT(DOR_DROP,usop);
    1761                 }
    1762               }
    1763             }
    1764             return 0;
    1765 
    1766           case CN_EMPHASIS:
    1767             if(!fDummy) {
    1768 
    1769               PNOTIFYRECORDEMPHASIS pre = mp2;
    1770 
    1771               if(pre->fEmphasisMask & CRA_SELECTED) {
    1772                 if(pre->pRecord->flRecordAttr & CRA_SELECTED) {
    1773                   if(((PCNRITEM)(pre->pRecord))->attrFile & FILE_DIRECTORY) {
    1774                     PostMsg(hwnd,
    1775                             UM_RESCAN,
    1776                             MPVOID,
    1777                             MPVOID);
    1778                     if(fFollowTree &&
    1779                        !(driveflags[toupper(*((PCNRITEM)pre->pRecord)->szFileName) - 'A'] &
    1780                          DRIVE_INVALID)) {
    1781                       if(!LastDir &&
    1782                          !ParentIsDesktop(hwnd,dcd->hwndParent))
    1783                         LastDir = FindDirCnr(dcd->hwndParent);
    1784                       if(LastDir) {
    1785 
    1786                         NOTIFYRECORDENTER pri;
    1787                         BOOL              tbool = fDCOpens;
    1788 
    1789                         fDCOpens = FALSE;
    1790                         memset(&pri,0,sizeof(pri));
    1791                         pri.hwndCnr = hwnd;
    1792                         pri.fKey = FALSE;
    1793                         pri.pRecord = pre->pRecord;
    1794                         WinSendMsg(hwnd,
    1795                                    WM_CONTROL,
    1796                                    MPFROM2SHORT(SHORT1FROMMP(mp1),
    1797                                                 CN_ENTER),
    1798                                    MPFROMP(&pri));
    1799                         fDCOpens = tbool;
    1800                       }
    1801                     }
    1802                     if(*(ULONG *)realappname != FM3UL)
    1803                       WinSetWindowText(WinWindowFromID(dcd->hwndFrame,
    1804                                                        MAIN_STATUS),
    1805                                        ((PCNRITEM)(pre->pRecord))->szFileName);
    1806                   }
    1807                 }
    1808               }
    1809             }
    1810             break;
    1811 
    1812           case CN_CONTEXTMENU:
    1813             {
    1814               PCNRITEM pci = (PCNRITEM)mp2;
    1815               BOOL     wasFollowing;
    1816 
    1817               DosEnterCritSec();
    1818                wasFollowing = fFollowTree;
    1819                fFollowTree = FALSE;
    1820               DosExitCritSec();
    1821               if(pci && (INT)pci != -1 && !(pci->flags & RECFLAGS_ENV)) {
    1822                 WinSendMsg(hwnd,
    1823                            CM_SETRECORDEMPHASIS,
    1824                            MPFROMP(pci),
    1825                            MPFROM2SHORT(TRUE,CRA_CURSORED));
    1826                 MarkAll(hwnd,
    1827                         FALSE,
    1828                         FALSE,
    1829                         TRUE);
    1830                 if(!(pci->attrFile & FILE_DIRECTORY))
    1831                   dcd->hwndLastMenu = CheckMenu(&FileMenu,FILE_POPUP);
    1832                 else if(!IsRoot(pci->szFileName))
    1833                   dcd->hwndLastMenu = CheckMenu(&DirMenu,DIR_POPUP);
    1834                 else
    1835                   dcd->hwndLastMenu = CheckMenu(&TreeMenu,TREE_POPUP);
    1836               }
    1837               else {
    1838                 dcd->hwndLastMenu = CheckMenu(&TreeCnrMenu,TREECNR_POPUP);
    1839                 if(dcd->hwndLastMenu && !dcd->cnremphasized) {
    1840                   WinSendMsg(hwnd,CM_SETRECORDEMPHASIS,MPVOID,
    1841                              MPFROM2SHORT(TRUE,CRA_SOURCE));
    1842                   dcd->cnremphasized = TRUE;
    1843                 }
    1844               }
    1845               if(dcd->hwndLastMenu) {
    1846                 if(dcd->hwndLastMenu == DirMenu)
    1847                   WinEnableMenuItem(DirMenu,IDM_TREE,FALSE);
    1848                 if(dcd->hwndLastMenu == TreeCnrMenu) {
    1849                   if(dcd->flWindowAttr & CV_MINI)
    1850                     WinCheckMenuItem(dcd->hwndLastMenu,IDM_MINIICONS,TRUE);
    1851                 }
    1852                 if(!PopupMenu(hwnd,hwnd,dcd->hwndLastMenu)) {
    1853                   if(dcd->cnremphasized) {
    1854                     WinSendMsg(hwnd,CM_SETRECORDEMPHASIS,MPVOID,
    1855                                MPFROM2SHORT(FALSE,CRA_SOURCE));
    1856                     dcd->cnremphasized = FALSE;
    1857                   }
    1858                   if(dcd->hwndLastMenu != TreeCnrMenu)
    1859                     MarkAll(hwnd,TRUE,FALSE,TRUE);
    1860                 }
    1861               }
    1862               DosEnterCritSec();
    1863                fFollowTree = wasFollowing;
    1864               DosExitCritSec();
    1865             }
    1866             break;
    1867 
    1868           case CN_ENTER:
    1869             if(mp2)
    1870             {
    1871               PCNRITEM pci = (PCNRITEM)((PNOTIFYRECORDENTER)mp2)->pRecord;
    1872 
    1873               PostMsg(hwnd,UM_ENTER,MPFROMP(pci),MPVOID);
    1874             }
    1875             break;
    1876 
    1877           case CN_COLLAPSETREE:
    1878           case CN_EXPANDTREE:
    1879             {
    1880               PCNRITEM pci = (PCNRITEM)mp2;
    1881 
    1882               if(pci && (INT)pci != -1 && !(pci->flags & RECFLAGS_ENV)) {
    1883                 if(driveflags[toupper(*pci->szFileName) - 'A'] &
    1884                    DRIVE_REMOVABLE) {
    1885 
    1886                   struct {
    1887                     ULONG serial;
    1888                     CHAR  volumelength;
    1889                     CHAR  volumelabel[CCHMAXPATH];
    1890                   }         volser;
    1891 
    1892                   memset(&volser,0,sizeof(volser));
    1893                   DosError(FERR_DISABLEHARDERR);
    1894                   if(!DosQueryFSInfo(toupper(*pci->szFileName) - '@',
    1895                                      FSIL_VOLSER,&volser,
    1896                                      (ULONG)sizeof(volser))) {
    1897                     if(SHORT2FROMMP(mp1) == CN_COLLAPSETREE &&
    1898                        !volser.serial ||
    1899                        driveserial[toupper(*pci->szFileName) - 'A'] !=
    1900                          volser.serial)
    1901                       UnFlesh(hwnd,pci);
    1902                     if(SHORT2FROMMP(mp1) != CN_COLLAPSETREE ||
    1903                        (!volser.serial ||
    1904                         driveserial[toupper(*pci->szFileName) - 'A'] !=
    1905                           volser.serial)) {
    1906                       if(Flesh(hwnd,pci) &&
    1907                          SHORT2FROMMP(mp1) == CN_EXPANDTREE &&
    1908                          !dcd->suspendview && fTopDir)
    1909                         PostMsg(hwnd,UM_TOPDIR,MPFROMP(pci),MPVOID);
    1910                     }
    1911                     driveserial[toupper(*pci->szFileName) - 'A'] =
    1912                       volser.serial;
    1913                   }
    1914                   else {
    1915                     driveserial[toupper(*pci->szFileName) - 'A'] = -1;
    1916                     UnFlesh(hwnd,pci);
    1917                     PostMsg(hwnd,UM_RESCAN,MPVOID,MPVOID);
    1918                     DosBeep(250,100);
    1919                   }
    1920                 }
    1921                 else if(SHORT2FROMMP(mp1) == CN_EXPANDTREE) {
    1922                   if(Flesh(hwnd,pci) && !dcd->suspendview && fTopDir)
    1923                     PostMsg(hwnd,UM_TOPDIR,MPFROMP(pci),MPVOID);
    1924                 }
    1925                 if(SHORT2FROMMP(mp1) == CN_EXPANDTREE && !dcd->suspendview)
    1926                   WinSendMsg(hwnd,UM_FILTER,MPVOID,MPVOID);
    1927               }
    1928             }
    1929             break;
    1930         } // switch WM_CONTROL
    1931       }
    1932       return 0;
    1933 
    1934     case UM_ACTION:
    1935       if(mp1) {
    1936 
    1937         LISTINFO *li = mp1;
    1938         ULONG     action = (ULONG)mp2;
    1939 
    1940         if(!li->list || !li->list[0] ||
    1941            !PostMsg(dcd->hwndObject,
    1942                     action,
    1943                     MPFROMP(li),
    1944                     MPVOID))
    1945           FreeListInfo(li);
    1946       }
    1947       return 0;
    1948 
    1949     case UM_SHOWME:
    1950       if(mp1 && dcd) {
    1951         CHAR *dir = xstrdup((CHAR *)mp1, pszSrcFile, __LINE__);
    1952         if (dir) {
    1953           if(!PostMsg(dcd->hwndObject,
    1954                       UM_SHOWME,
    1955                       MPFROMP(dir),
    1956                       MPVOID))
    1957             free(dir);
    1958         }
    1959       }
    1960       return 0;
    1961 
    1962     case UM_TOPDIR:
    1963       if(mp1) {
    1964 
    1965         PCNRITEM pci = (PCNRITEM)mp1;
    1966 
    1967         ShowCnrRecord(hwnd,
    1968                       (PMINIRECORDCORE)pci);
    1969       }
    1970       return 0;
    1971 
    1972     case UM_ENTER:
    1973       {
    1974         FILEFINDBUF3 ffb;
    1975         HDIR         hDir = HDIR_CREATE;
    1976         ULONG        nm = 1L;
    1977         APIRET       status;
    1978         BOOL         IsOk = FALSE;
    1979         ULONG        ulDriveNum,ulDriveMap;
    1980         PCNRITEM     pciP,pciL,pci;
    1981         ULONG        fl = SWP_ACTIVATE;
    1982 
    1983         if(fFollowTree)
    1984           fl = 0;
    1985         SetShiftState();
    1986         pci = (PCNRITEM)mp1;
    1987         if(pci &&
    1988            (INT)pci != -1 &&
    1989            !(pci->rc.flRecordAttr & CRA_INUSE) &&
    1990            !(pci->flags & RECFLAGS_ENV) &&
    1991            IsFullName(pci->szFileName)) {
    1992           if(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_INVALID) {
    1993             DosBeep(50,100);
    1994             if(hwndStatus)
    1995               WinSetWindowText(hwndStatus,
    1996                                GetPString(IDS_RESCANSUGTEXT));
    1997             return 0;
    1998           }
    1999           DosError(FERR_DISABLEHARDERR);
    2000           if (!DosQCurDisk(&ulDriveNum,&ulDriveMap)) {
    2001             if (!(ulDriveMap & 1L << (toupper(*pci->szFileName) - 'A'))) {
    2002               pciL = pciP = pci;
    2003               for (;;) {
    2004                 pciP = WinSendMsg(hwnd,
    2005                                   CM_QUERYRECORD,
    2006                                   MPFROMP(pciL),
    2007                                   MPFROM2SHORT(CMA_PARENT,CMA_ITEMORDER));
    2008                 if(pciP && (INT)pciP != -1)
    2009                   pciL = pciP;
    2010                 else {
    2011                   pciP = pciL;
    2012                   break;
    2013                 }
    2014               } // for
    2015               WinSendMsg(hwnd,
    2016                          CM_REMOVERECORD,
    2017                          MPFROMP(&pciP),
    2018                          MPFROM2SHORT(1,CMA_FREE | CMA_INVALIDATE));
    2019               return 0;
    2020             }
    2021           }
    2022           if(driveflags[toupper(*pci->szFileName) - 'A'] &
    2023              (DRIVE_REMOVABLE | DRIVE_NOPRESCAN)) {
    2024 
    2025             struct {
    2026               ULONG serial;
    2027               CHAR  volumelength;
    2028               CHAR  volumelabel[CCHMAXPATH];
    2029             } volser;
    2030 
     1641            else if (SHORT2FROMMP(mp1) == CN_EXPANDTREE) {
     1642              if (Flesh(hwnd, pci) && !dcd->suspendview && fTopDir)
     1643                PostMsg(hwnd, UM_TOPDIR, MPFROMP(pci), MPVOID);
     1644            }
     1645            if (SHORT2FROMMP(mp1) == CN_EXPANDTREE && !dcd->suspendview)
     1646              WinSendMsg(hwnd, UM_FILTER, MPVOID, MPVOID);
     1647          }
     1648        }
     1649        break;
     1650      }                                 // switch WM_CONTROL
     1651    }
     1652    return 0;
     1653
     1654  case UM_ACTION:
     1655    if (mp1) {
     1656
     1657      LISTINFO *li = mp1;
     1658      ULONG action = (ULONG) mp2;
     1659
     1660      if (!li->list || !li->list[0] ||
     1661          !PostMsg(dcd->hwndObject, action, MPFROMP(li), MPVOID))
     1662        FreeListInfo(li);
     1663    }
     1664    return 0;
     1665
     1666  case UM_SHOWME:
     1667    if (mp1 && dcd) {
     1668      CHAR *dir = xstrdup((CHAR *) mp1, pszSrcFile, __LINE__);
     1669
     1670      if (dir) {
     1671        if (!PostMsg(dcd->hwndObject, UM_SHOWME, MPFROMP(dir), MPVOID))
     1672          free(dir);
     1673      }
     1674    }
     1675    return 0;
     1676
     1677  case UM_TOPDIR:
     1678    if (mp1) {
     1679
     1680      PCNRITEM pci = (PCNRITEM) mp1;
     1681
     1682      ShowCnrRecord(hwnd, (PMINIRECORDCORE) pci);
     1683    }
     1684    return 0;
     1685
     1686  case UM_ENTER:
     1687    {
     1688      FILEFINDBUF3 ffb;
     1689      HDIR hDir = HDIR_CREATE;
     1690      ULONG nm = 1L;
     1691      APIRET status;
     1692      BOOL IsOk = FALSE;
     1693      ULONG ulDriveNum, ulDriveMap;
     1694      PCNRITEM pciP, pciL, pci;
     1695      ULONG fl = SWP_ACTIVATE;
     1696
     1697      if (fFollowTree)
     1698        fl = 0;
     1699      SetShiftState();
     1700      pci = (PCNRITEM) mp1;
     1701      if (pci &&
     1702          (INT) pci != -1 &&
     1703          !(pci->rc.flRecordAttr & CRA_INUSE) &&
     1704          !(pci->flags & RECFLAGS_ENV) && IsFullName(pci->szFileName)) {
     1705        if (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_INVALID) {
     1706          DosBeep(50, 100);
     1707          if (hwndStatus)
     1708            WinSetWindowText(hwndStatus, GetPString(IDS_RESCANSUGTEXT));
     1709          return 0;
     1710        }
     1711        DosError(FERR_DISABLEHARDERR);
     1712        if (!DosQCurDisk(&ulDriveNum, &ulDriveMap)) {
     1713          if (!(ulDriveMap & 1L << (toupper(*pci->szFileName) - 'A'))) {
    20311714            pciL = pciP = pci;
    2032             for(;;) {
     1715            for (;;) {
    20331716              pciP = WinSendMsg(hwnd,
    20341717                                CM_QUERYRECORD,
    20351718                                MPFROMP(pciL),
    2036                                 MPFROM2SHORT(CMA_PARENT,CMA_ITEMORDER));
    2037               if(pciP && (INT)pciP != -1)
     1719                                MPFROM2SHORT(CMA_PARENT, CMA_ITEMORDER));
     1720              if (pciP && (INT) pciP != -1)
    20381721                pciL = pciP;
    20391722              else {
    … …  
    20411724                break;
    20421725              }
    2043             }
    2044             if((driveflags[toupper(*pci->szFileName) - 'A'] &
     1726            }                           // for
     1727            WinSendMsg(hwnd,
     1728                       CM_REMOVERECORD,
     1729                       MPFROMP(&pciP),
     1730                       MPFROM2SHORT(1, CMA_FREE | CMA_INVALIDATE));
     1731            return 0;
     1732          }
     1733        }
     1734        if (driveflags[toupper(*pci->szFileName) - 'A'] &
     1735            (DRIVE_REMOVABLE | DRIVE_NOPRESCAN)) {
     1736
     1737          struct
     1738          {
     1739            ULONG serial;
     1740            CHAR volumelength;
     1741            CHAR volumelabel[CCHMAXPATH];
     1742          }
     1743          volser;
     1744
     1745          pciL = pciP = pci;
     1746          for (;;) {
     1747            pciP = WinSendMsg(hwnd,
     1748                              CM_QUERYRECORD,
     1749                              MPFROMP(pciL),
     1750                              MPFROM2SHORT(CMA_PARENT, CMA_ITEMORDER));
     1751            if (pciP && (INT) pciP != -1)
     1752              pciL = pciP;
     1753            else {
     1754              pciP = pciL;
     1755              break;
     1756            }
     1757          }
     1758          if ((driveflags[toupper(*pci->szFileName) - 'A'] &
    20451759               DRIVE_NOPRESCAN) ||
    2046                (toupper(*pci->szFileName) > 'B' &&
    2047                 !(driveflags[toupper(*pci->szFileName) - 'A'] &
    2048                   DRIVE_CDROM))) {
    2049 
    2050               INT      removable,
    2051                        x = (INT)(toupper(*pci->szFileName) - 'A');
    2052               ULONG    drvtype;
    2053               CHAR     FileSystem[CCHMAXPATH];
    2054 
    2055               DosError(FERR_DISABLEHARDERR);
    2056               removable = CheckDrive(toupper(*pciP->szFileName),
    2057                                      FileSystem,
    2058                                      &drvtype);
    2059               if(removable != -1) {
    2060                 driveflags[x] &= (DRIVE_IGNORE      | DRIVE_NOPRESCAN |
    2061                                   DRIVE_NOLOADICONS | DRIVE_NOLOADSUBJS |
    2062                                   DRIVE_NOLOADLONGS | DRIVE_INCLUDEFILES |
    2063                                   DRIVE_SLOW);
    2064 
    2065                 if(removable == 1)
    2066                   driveflags[x] |= DRIVE_REMOVABLE;
    2067                 if(drvtype & DRIVE_REMOTE)
    2068                   driveflags[x] |= DRIVE_REMOTE;
    2069                 if(!strcmp(FileSystem,CDFS))
    2070                   driveflags[x] |= (DRIVE_REMOVABLE |
    2071                                     DRIVE_NOTWRITEABLE |
    2072                                     DRIVE_CDROM);
    2073                 if (strcmp(FileSystem,HPFS) &&
    2074                     strcmp(FileSystem,JFS) &&
    2075                     strcmp(FileSystem,CDFS) &&
    2076                     strcmp(FileSystem,FAT32) &&
    2077                     strcmp(FileSystem,NDFS32) &&
    2078                     strcmp(FileSystem,HPFS386))
    2079                 {
    2080                   driveflags[x] |= DRIVE_NOLONGNAMES;
    2081                 }
    2082                 if(!strcmp(FileSystem,CBSIFS)) {
    2083                   driveflags[x] |= DRIVE_ZIPSTREAM;
    2084                   driveflags[x] &= (~DRIVE_REMOTE);
    2085                 }
    2086                 if(driveflags[x] & DRIVE_CDROM)
    2087                   pciP->rc.hptrIcon = hptrCDROM;
    2088 
     1760              (toupper(*pci->szFileName) > 'B' &&
     1761               !(driveflags[toupper(*pci->szFileName) - 'A'] &
     1762                 DRIVE_CDROM))) {
     1763
     1764            INT removable, x = (INT) (toupper(*pci->szFileName) - 'A');
     1765            ULONG drvtype;
     1766            CHAR FileSystem[CCHMAXPATH];
     1767
     1768            DosError(FERR_DISABLEHARDERR);
     1769            removable = CheckDrive(toupper(*pciP->szFileName),
     1770                                   FileSystem, &drvtype);
     1771            if (removable != -1) {
     1772              driveflags[x] &= (DRIVE_IGNORE | DRIVE_NOPRESCAN |
     1773                                DRIVE_NOLOADICONS | DRIVE_NOLOADSUBJS |
     1774                                DRIVE_NOLOADLONGS | DRIVE_INCLUDEFILES |
     1775                                DRIVE_SLOW);
     1776
     1777              if (removable == 1)
     1778                driveflags[x] |= DRIVE_REMOVABLE;
     1779              if (drvtype & DRIVE_REMOTE)
     1780                driveflags[x] |= DRIVE_REMOTE;
     1781              if (!strcmp(FileSystem, CDFS))
     1782                driveflags[x] |= (DRIVE_REMOVABLE |
     1783                                  DRIVE_NOTWRITEABLE | DRIVE_CDROM);
     1784              if (strcmp(FileSystem, HPFS) &&
     1785                  strcmp(FileSystem, JFS) &&
     1786                  strcmp(FileSystem, CDFS) &&
     1787                  strcmp(FileSystem, FAT32) &&
     1788                  strcmp(FileSystem, NDFS32) && strcmp(FileSystem, HPFS386)) {
     1789                driveflags[x] |= DRIVE_NOLONGNAMES;
     1790              }
     1791              if (!strcmp(FileSystem, CBSIFS)) {
     1792                driveflags[x] |= DRIVE_ZIPSTREAM;
     1793                driveflags[x] &= (~DRIVE_REMOTE);
     1794              }
     1795              if (driveflags[x] & DRIVE_CDROM)
     1796                pciP->rc.hptrIcon = hptrCDROM;
     1797
     1798              else
     1799                pciP->rc.hptrIcon = (driveflags[x] & DRIVE_REMOVABLE) ?
     1800                  hptrRemovable :
     1801                  (driveflags[x] & DRIVE_REMOTE) ? hptrRemote : hptrDrive;
     1802              WinSendMsg(hwnd,
     1803                         CM_INVALIDATERECORD,
     1804                         MPFROMP(&pciP),
     1805                         MPFROM2SHORT(1, CMA_ERASE | CMA_REPOSITION));
     1806              if (hwndMain)
     1807                PostMsg(hwndMain, UM_BUILDDRIVEBAR, MPVOID, MPVOID);
     1808            }
     1809          }
     1810          memset(&volser, 0, sizeof(volser));
     1811          DosError(FERR_DISABLEHARDERR);
     1812          status = DosQueryFSInfo(toupper(*pci->szFileName) - '@',
     1813                                  FSIL_VOLSER, &volser,
     1814                                  (ULONG) sizeof(volser));
     1815          if (!status) {
     1816            if (!volser.serial ||
     1817                driveserial[toupper(*pci->szFileName) - 'A'] !=
     1818                volser.serial) {
     1819              UnFlesh(hwnd, pciP);
     1820              Flesh(hwnd, pciP);
     1821              driveserial[toupper(*pci->szFileName) - 'A'] = volser.serial;
     1822            }
     1823            pciL = WinSendMsg(hwnd,
     1824                              CM_QUERYRECORD,
     1825                              MPFROMP(pciP),
     1826                              MPFROM2SHORT(CMA_FIRSTCHILD, CMA_ITEMORDER));
     1827            if (!pciL)
     1828              Flesh(hwnd, pciP);
     1829          }
     1830          else {
     1831            driveserial[toupper(*pci->szFileName) - 'A'] = -1;
     1832            UnFlesh(hwnd, pci);
     1833            PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
     1834            PostMsg(hwnd, UM_SETUP2, MPFROMP(pci), MPFROMLONG(status));
     1835            return 0;
     1836          }
     1837        }
     1838        status = 0;
     1839        IsOk = (IsRoot(pci->szFileName) &&
     1840                IsValidDrive(toupper(*pci->szFileName)));
     1841        if (!IsOk) {
     1842          DosError(FERR_DISABLEHARDERR);
     1843          status = DosFindFirst(pci->szFileName, &hDir,
     1844                                FILE_NORMAL | FILE_DIRECTORY |
     1845                                FILE_ARCHIVED | FILE_READONLY |
     1846                                FILE_HIDDEN | FILE_SYSTEM,
     1847                                &ffb, sizeof(ffb), &nm, FIL_STANDARD);
     1848          priority_bumped();
     1849        }
     1850        if (!status) {
     1851          if (!IsOk)
     1852            DosFindClose(hDir);
     1853          if (IsOk || (ffb.attrFile & FILE_DIRECTORY)) {
     1854            if ((shiftstate & (KC_CTRL | KC_ALT)) == (KC_CTRL | KC_ALT)) {
     1855              PostMsg(hwnd,
     1856                      WM_COMMAND, MPFROM2SHORT(IDM_SHOWALLFILES, 0), MPVOID);
     1857              return 0;
     1858            }
     1859            if ((shiftstate & (KC_CTRL | KC_SHIFT)) == (KC_CTRL | KC_SHIFT)) {
     1860              OpenObject(pci->szFileName, Settings, dcd->hwndFrame);
     1861              return 0;
     1862            }
     1863            if (!(shiftstate & (KC_CTRL | KC_SHIFT))) {
     1864              if (!ParentIsDesktop(hwnd, dcd->hwndParent)) {
     1865                if (FindDirCnrByName(pci->szFileName, TRUE))
     1866                  return 0;
     1867              }
     1868            }
     1869            if ((shiftstate & KC_CTRL) ||
     1870                (!(shiftstate & KC_SHIFT) &&
     1871                 ParentIsDesktop(hwnd, dcd->hwndParent) && fVTreeOpensWPS)) {
     1872
     1873              ULONG size = sizeof(ULONG), flWindowAttr = CV_ICON;
     1874              CHAR s[33];
     1875
     1876              strcpy(s, "ICON");
     1877              PrfQueryProfileData(fmprof,
     1878                                  appname,
     1879                                  "DirflWindowAttr",
     1880                                  (PVOID) & flWindowAttr, &size);
     1881              if (flWindowAttr & CV_DETAIL) {
     1882                if (IsRoot(pci->szFileName))
     1883                  strcpy(s, "TREE");
    20891884                else
    2090                   pciP->rc.hptrIcon = (driveflags[x] & DRIVE_REMOVABLE) ?
    2091                                        hptrRemovable :
    2092                                        (driveflags[x] & DRIVE_REMOTE) ?
    2093                                        hptrRemote : hptrDrive;
    2094                 WinSendMsg(hwnd,
    2095                            CM_INVALIDATERECORD,
    2096                            MPFROMP(&pciP),
    2097                            MPFROM2SHORT(1,CMA_ERASE | CMA_REPOSITION));
    2098                 if(hwndMain)
    2099                   PostMsg(hwndMain,
    2100                           UM_BUILDDRIVEBAR,
    2101                           MPVOID,
    2102                           MPVOID);
     1885                  strcpy(s, "DETAILS");
    21031886              }
    2104             }
    2105             memset(&volser,0,sizeof(volser));
    2106             DosError(FERR_DISABLEHARDERR);
    2107             status = DosQueryFSInfo(toupper(*pci->szFileName) - '@',
    2108                                     FSIL_VOLSER,&volser,
    2109                                     (ULONG)sizeof(volser));
    2110             if(!status) {
    2111               if(!volser.serial ||
    2112                  driveserial[toupper(*pci->szFileName) - 'A'] !=
    2113                    volser.serial) {
    2114                 UnFlesh(hwnd,pciP);
    2115                 Flesh(hwnd,pciP);
    2116                 driveserial[toupper(*pci->szFileName) - 'A'] =
    2117                   volser.serial;
    2118               }
    2119               pciL = WinSendMsg(hwnd,
    2120                                 CM_QUERYRECORD,
    2121                                 MPFROMP(pciP),
    2122                                 MPFROM2SHORT(CMA_FIRSTCHILD,
    2123                                              CMA_ITEMORDER));
    2124               if(!pciL)
    2125                 Flesh(hwnd,pciP);
    2126             }
    2127             else {
    2128               driveserial[toupper(*pci->szFileName) - 'A'] = -1;
    2129               UnFlesh(hwnd,
    2130                       pci);
    2131               PostMsg(hwnd,
    2132                       UM_RESCAN,
    2133                       MPVOID,
    2134                       MPVOID);
    2135               PostMsg(hwnd,
    2136                       UM_SETUP2,
    2137                       MPFROMP(pci),
    2138                       MPFROMLONG(status));
     1887              OpenObject(pci->szFileName, s, dcd->hwndFrame);
    21391888              return 0;
    21401889            }
    2141           }
    2142           status = 0;
    2143           IsOk = (IsRoot(pci->szFileName) &&
    2144                   IsValidDrive(toupper(*pci->szFileName)));
    2145           if(!IsOk) {
    2146             DosError(FERR_DISABLEHARDERR);
    2147             status = DosFindFirst(pci->szFileName,&hDir,
    2148                                   FILE_NORMAL   | FILE_DIRECTORY |
    2149                                   FILE_ARCHIVED | FILE_READONLY  |
    2150                                   FILE_HIDDEN   | FILE_SYSTEM,
    2151                                   &ffb,sizeof(ffb),&nm,
    2152                                   FIL_STANDARD);
    2153             priority_bumped();
    2154           }
    2155           if(!status) {
    2156             if(!IsOk)
    2157               DosFindClose(hDir);
    2158             if(IsOk ||
    2159                (ffb.attrFile & FILE_DIRECTORY)) {
    2160               if((shiftstate & (KC_CTRL | KC_ALT)) ==
    2161                  (KC_CTRL | KC_ALT)) {
    2162                 PostMsg(hwnd,
    2163                         WM_COMMAND,
    2164                         MPFROM2SHORT(IDM_SHOWALLFILES,0),
    2165                         MPVOID);
    2166                 return 0;
    2167               }
    2168               if((shiftstate & (KC_CTRL | KC_SHIFT)) ==
    2169                  (KC_CTRL | KC_SHIFT)) {
    2170                 OpenObject(pci->szFileName,
    2171                            Settings,
    2172                            dcd->hwndFrame);
    2173                 return 0;
    2174               }
    2175               if(!(shiftstate & (KC_CTRL | KC_SHIFT))) {
    2176                 if(!ParentIsDesktop(hwnd,dcd->hwndParent)) {
    2177                   if(FindDirCnrByName(pci->szFileName,
    2178                                       TRUE))
    2179                     return 0;
    2180                 }
    2181               }
    2182               if((shiftstate & KC_CTRL) ||
    2183                  (!(shiftstate & KC_SHIFT) &&
    2184                   ParentIsDesktop(hwnd,dcd->hwndParent) &&
    2185                   fVTreeOpensWPS)) {
    2186 
    2187                 ULONG size = sizeof(ULONG),flWindowAttr = CV_ICON;
    2188                 CHAR  s[33];
    2189 
    2190                 strcpy(s,"ICON");
    2191                 PrfQueryProfileData(fmprof,
    2192                                     appname,
    2193                                     "DirflWindowAttr",
    2194                                     (PVOID)&flWindowAttr,
    2195                                     &size);
    2196                 if(flWindowAttr & CV_DETAIL) {
    2197                   if(IsRoot(pci->szFileName))
    2198                     strcpy(s,"TREE");
    2199                   else
    2200                     strcpy(s,"DETAILS");
    2201                 }
    2202                 OpenObject(pci->szFileName,
    2203                            s,
    2204                            dcd->hwndFrame);
    2205                 return 0;
    2206               }
    2207               if(!ParentIsDesktop(hwnd,dcd->hwndParent) &&
    2208                  !fDCOpens &&
    2209                  !LastDir &&
    2210                  !(shiftstate & KC_SHIFT))
    2211                 LastDir = FindDirCnr(dcd->hwndParent);
    2212               if(LastDir &&
    2213                  !fDCOpens &&
    2214                  !(shiftstate & KC_SHIFT)) {
    2215                 WinSendMsg(LastDir,
    2216                            UM_SETDIR,
    2217                            MPFROMP(pci->szFileName),
    2218                            MPVOID);
    2219                 WinSetWindowPos(WinQueryWindow(WinQueryWindow(LastDir,
    2220                                                               QW_PARENT),
    2221                                                QW_PARENT),
    2222                                 HWND_TOP,
    2223                                 0,
    2224                                 0,
    2225                                 0,
    2226                                 0,
    2227                                 SWP_ZORDER | fl);
    2228               }
    2229               else
    2230                 OpenDirCnr(hwnd,
    2231                            dcd->hwndParent,
    2232                            dcd->hwndFrame,
    2233                            FALSE,
    2234                            pci->szFileName);
    2235             }
    2236             else {
    2237               if(!(driveflags[toupper(*pci->szFileName) - 'A'] &
    2238                    DRIVE_INCLUDEFILES))
    2239                 WinSendMsg(hwnd,
    2240                            CM_REMOVERECORD,
    2241                            MPFROMP(&pci),
    2242                            MPFROM2SHORT(1,CMA_FREE | CMA_INVALIDATE));
    2243               else {
    2244 
    2245                 SWP swp;
    2246 
    2247                 WinQueryWindowPos(dcd->hwndFrame,&swp);
    2248                 DefaultViewKeys(hwnd,
    2249                                 dcd->hwndFrame,
    2250                                 dcd->hwndParent,
    2251                                 &swp,
    2252                                 pci->szFileName);
    2253               }
    2254             }
     1890            if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
     1891                !fDCOpens && !LastDir && !(shiftstate & KC_SHIFT))
     1892              LastDir = FindDirCnr(dcd->hwndParent);
     1893            if (LastDir && !fDCOpens && !(shiftstate & KC_SHIFT)) {
     1894              WinSendMsg(LastDir,
     1895                         UM_SETDIR, MPFROMP(pci->szFileName), MPVOID);
     1896              WinSetWindowPos(WinQueryWindow(WinQueryWindow(LastDir,
     1897                                                            QW_PARENT),
     1898                                             QW_PARENT),
     1899                              HWND_TOP, 0, 0, 0, 0, SWP_ZORDER | fl);
     1900            }
     1901            else
     1902              OpenDirCnr(hwnd,
     1903                         dcd->hwndParent,
     1904                         dcd->hwndFrame, FALSE, pci->szFileName);
    22551905          }
    22561906          else {
    2257             if(!IsRoot(pci->szFileName)) {
    2258               NotifyError(pci->szFileName,status);
     1907            if (!(driveflags[toupper(*pci->szFileName) - 'A'] &
     1908                  DRIVE_INCLUDEFILES))
    22591909              WinSendMsg(hwnd,
    22601910                         CM_REMOVERECORD,
    22611911                         MPFROMP(&pci),
    2262                          MPFROM2SHORT(1,CMA_FREE | CMA_INVALIDATE));
    2263             }
    2264           }
    2265         }
    2266         else if(!pci)
    2267           PostMsg(hwnd,
    2268                   WM_COMMAND,
    2269                   MPFROM2SHORT(IDM_MKDIR,0),
    2270                   MPVOID);
    2271         if(fFollowTree)
    2272           WinSetFocus(HWND_DESKTOP,hwnd);
    2273       }
    2274       return 0;
    2275 
    2276     case WM_MENUEND:
    2277       if(dcd) {
    2278 
    2279         HWND hwndMenu = (HWND)mp2;
    2280 
    2281         if(hwndMenu == TreeCnrMenu || hwndMenu == TreeMenu ||
    2282            hwndMenu == DirMenu) {
    2283           MarkAll(hwnd,TRUE,FALSE,TRUE);
    2284           if(dcd->cnremphasized) {
     1912                         MPFROM2SHORT(1, CMA_FREE | CMA_INVALIDATE));
     1913            else {
     1914
     1915              SWP swp;
     1916
     1917              WinQueryWindowPos(dcd->hwndFrame, &swp);
     1918              DefaultViewKeys(hwnd,
     1919                              dcd->hwndFrame,
     1920                              dcd->hwndParent, &swp, pci->szFileName);
     1921            }
     1922          }
     1923        }
     1924        else {
     1925          if (!IsRoot(pci->szFileName)) {
     1926            NotifyError(pci->szFileName, status);
    22851927            WinSendMsg(hwnd,
    2286                        CM_SETRECORDEMPHASIS,
    2287                        MPVOID,
    2288                        MPFROM2SHORT(FALSE,CRA_SOURCE));
    2289             dcd->cnremphasized = FALSE;
    2290           }
    2291         }
    2292       }
     1928                       CM_REMOVERECORD,
     1929                       MPFROMP(&pci),
     1930                       MPFROM2SHORT(1, CMA_FREE | CMA_INVALIDATE));
     1931          }
     1932        }
     1933      }
     1934      else if (!pci)
     1935        PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_MKDIR, 0), MPVOID);
     1936      if (fFollowTree)
     1937        WinSetFocus(HWND_DESKTOP, hwnd);
     1938    }
     1939    return 0;
     1940
     1941  case WM_MENUEND:
     1942    if (dcd) {
     1943
     1944      HWND hwndMenu = (HWND) mp2;
     1945
     1946      if (hwndMenu == TreeCnrMenu || hwndMenu == TreeMenu ||
     1947          hwndMenu == DirMenu) {
     1948        MarkAll(hwnd, TRUE, FALSE, TRUE);
     1949        if (dcd->cnremphasized) {
     1950          WinSendMsg(hwnd,
     1951                     CM_SETRECORDEMPHASIS,
     1952                     MPVOID, MPFROM2SHORT(FALSE, CRA_SOURCE));
     1953          dcd->cnremphasized = FALSE;
     1954        }
     1955      }
     1956    }
     1957    break;
     1958
     1959  case UM_OPENWINDOWFORME:
     1960    if (dcd) {
     1961      if (mp1 && !IsFile((CHAR *) mp1))
     1962        OpenDirCnr(hwnd, dcd->hwndParent, dcd->hwndFrame, FALSE, (char *)mp1);
     1963    }
     1964    return 0;
     1965
     1966  case MM_PORTHOLEINIT:
     1967    if (dcd) {
     1968      switch (SHORT1FROMMP(mp1)) {
     1969      case 0:
     1970      case 1:
     1971        {
     1972          ULONG wmsg;
     1973
     1974          wmsg = ((SHORT1FROMMP(mp1) == 0) ? UM_FILESMENU : UM_VIEWSMENU);
     1975          PortholeInit((HWND) WinSendMsg(dcd->hwndClient,
     1976                                         wmsg, MPVOID, MPVOID), mp1, mp2);
     1977        }
     1978        break;
     1979      }
     1980    }
     1981    break;
     1982
     1983  case UM_INITMENU:
     1984  case WM_INITMENU:
     1985    if (dcd) {
     1986      switch (SHORT1FROMMP(mp1)) {
     1987      case IDM_FILESMENU:
     1988        {
     1989          PCNRITEM pci;
     1990
     1991          pci = (PCNRITEM) CurrentRecord(hwnd);
     1992          if (pci && (INT) pci != -1) {
     1993            BOOL rdy;
     1994            BOOL writeable;
     1995            BOOL removable;
     1996            BOOL remote;
     1997            BOOL underenv;
     1998            CHAR chDrvU;
     1999            CHAR szDrv[CCHMAXPATH];
     2000
     2001            strcpy(szDrv, pci->szFileName);
     2002            chDrvU = *pci->szFileName;
     2003            chDrvU = toupper(chDrvU);
     2004            MakeValidDir(szDrv);
     2005            rdy = *szDrv == chDrvU;     // Drive not ready if MakeValidDir changes drive letter
     2006            removable = rdy
     2007              && (driveflags[chDrvU - 'A'] & DRIVE_REMOVABLE) != 0;
     2008            writeable = rdy
     2009              && !(driveflags[chDrvU - 'A'] & DRIVE_NOTWRITEABLE);
     2010            remote = rdy && (driveflags[chDrvU - 'A'] & DRIVE_REMOTE) != 0;
     2011            underenv = (pci->flags & RECFLAGS_UNDERENV) != 0;
     2012
     2013            WinEnableMenuItem((HWND) mp2, IDM_INFO, rdy);
     2014
     2015            WinEnableMenuItem((HWND) mp2, IDM_ATTRS, writeable);
     2016            WinEnableMenuItem((HWND) mp2, IDM_EAS, writeable);
     2017            WinEnableMenuItem((HWND) mp2, IDM_SUBJECT, writeable);
     2018            WinEnableMenuItem((HWND) mp2, IDM_DRVFLAGS, 1);     // fixme to allow if not ready
     2019
     2020            WinEnableMenuItem((HWND) mp2, IDM_ARCHIVE, rdy);
     2021
     2022            WinEnableMenuItem((HWND) mp2, IDM_UPDATE, !underenv);
     2023            WinEnableMenuItem((HWND) mp2, IDM_EXPANDSUBMENU, !underenv);
     2024            WinEnableMenuItem((HWND) mp2, IDM_EXPAND, !underenv);
     2025            WinEnableMenuItem((HWND) mp2, IDM_COLLAPSE, !underenv);
     2026
     2027            WinEnableMenuItem((HWND) mp2, IDM_SIZES, rdy);
     2028            WinEnableMenuItem((HWND) mp2, IDM_MKDIR, writeable);
     2029            WinEnableMenuItem((HWND) mp2, IDM_SHOWALLFILES, rdy);
     2030            WinEnableMenuItem((HWND) mp2, IDM_UNDELETE, writeable);
     2031
     2032            WinEnableMenuItem((HWND) mp2, IDM_CHKDSK, writeable && !remote);
     2033            WinEnableMenuItem((HWND) mp2, IDM_FORMAT, writeable && !remote);
     2034            WinEnableMenuItem((HWND) mp2, IDM_OPTIMIZE, writeable && !remote);
     2035            WinEnableMenuItem((HWND) mp2, IDM_PARTITIONSMENU, !remote);
     2036
     2037            WinEnableMenuItem((HWND) mp2, IDM_DETACH, remote);
     2038
     2039            WinEnableMenuItem((HWND) mp2, IDM_EJECT, removable);
     2040
     2041            WinEnableMenuItem((HWND) mp2, IDM_LOCK, removable);
     2042            WinEnableMenuItem((HWND) mp2, IDM_UNLOCK, removable);
     2043
     2044            WinEnableMenuItem((HWND) mp2, IDM_DELETE, !underenv && writeable);
     2045            WinEnableMenuItem((HWND) mp2, IDM_PERMDELETE, !underenv
     2046                              && writeable);
     2047            WinEnableMenuItem((HWND) mp2, IDM_DELETESUBMENU, !underenv
     2048                              && writeable);
     2049            WinEnableMenuItem((HWND) mp2, IDM_MOVEMENU, !underenv
     2050                              && writeable);
     2051            WinEnableMenuItem((HWND) mp2, IDM_RENAME, !underenv && writeable);
     2052
     2053          }
     2054        }
     2055        break;
     2056
     2057      case IDM_VIEWSMENU:
     2058        WinCheckMenuItem((HWND) mp2,
     2059                         IDM_MINIICONS, ((dcd->flWindowAttr & CV_MINI) != 0));
     2060        WinEnableMenuItem((HWND) mp2, IDM_RESELECT, FALSE);
     2061        break;
     2062
     2063      case IDM_COMMANDSMENU:
     2064        SetupCommandMenu((HWND) mp2, hwnd);
     2065        break;
     2066
     2067      case IDM_SORTSUBMENU:
     2068        SetSortChecks((HWND) mp2, TreesortFlags);
     2069        break;
     2070
     2071      case IDM_WINDOWSMENU:
     2072        SetupWinList((HWND) mp2,
     2073                     (hwndMain) ? hwndMain : (HWND) 0, dcd->hwndFrame);
     2074        break;
     2075      }
     2076      dcd->hwndLastMenu = (HWND) mp2;
     2077    }
     2078    if (msg == WM_INITMENU)
    22932079      break;
    2294 
    2295     case UM_OPENWINDOWFORME:
    2296       if(dcd) {
    2297         if(mp1 &&
    2298            !IsFile((CHAR *)mp1))
    2299           OpenDirCnr(hwnd,
    2300                      dcd->hwndParent,
    2301                      dcd->hwndFrame,
    2302                      FALSE,
    2303                      (char *)mp1);
    2304       }
    2305       return 0;
    2306 
    2307     case MM_PORTHOLEINIT:
    2308       if(dcd) {
    2309         switch(SHORT1FROMMP(mp1)) {
    2310           case 0:
    2311           case 1:
    2312             {
    2313               ULONG wmsg;
    2314 
    2315               wmsg = ((SHORT1FROMMP(mp1) == 0) ?
    2316                        UM_FILESMENU :
    2317                        UM_VIEWSMENU);
    2318               PortholeInit((HWND)WinSendMsg(dcd->hwndClient,
    2319                                             wmsg,
    2320                                             MPVOID,
    2321                                             MPVOID),
    2322                            mp1,
    2323                            mp2);
    2324             }
     2080    return 0;
     2081
     2082  case UM_COMMAND:
     2083    if (!mp1)
     2084      Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
     2085    else {
     2086      if (!dcd) {
     2087        Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
     2088        FreeListInfo((LISTINFO *) mp1);
     2089      }
     2090      else {
     2091        if (!PostMsg(dcd->hwndObject, UM_COMMAND, mp1, mp2)) {
     2092          Runtime_Error(pszSrcFile, __LINE__, "PostMsg");
     2093          FreeListInfo((LISTINFO *) mp1);
     2094        }
     2095        else
     2096          return (MRESULT) TRUE;
     2097      }
     2098    }
     2099    return 0;
     2100
     2101  case UM_LOADFILE:
     2102    if (dcd && mp2) {
     2103
     2104      HWND ret;
     2105
     2106      ret = StartMLEEditor(dcd->hwndParent, (INT) mp1, (CHAR *) mp2,
     2107                           dcd->hwndFrame);
     2108      if (mp2)
     2109        free((CHAR *) mp2);
     2110      return MRFROMLONG(ret);
     2111    }
     2112    return 0;
     2113
     2114  case UM_FIXCNRMLE:
     2115  case UM_FIXEDITNAME:
     2116    return CommonCnrProc(hwnd, msg, mp1, mp2);
     2117
     2118  case UM_NOTIFY:
     2119    if (mp2)
     2120      Notify((CHAR *) mp2);
     2121    return 0;
     2122
     2123  case UM_FILTER:
     2124    if (dcd) {
     2125
     2126      BOOL tempsusp = dcd->suspendview;
     2127
     2128      if (mp1) {
     2129        DosEnterCritSec();
     2130        SetMask((CHAR *) mp1, &dcd->mask);
     2131        DosExitCritSec();
     2132      }
     2133      dcd->suspendview = TRUE;
     2134      dcd->mask.attrFile |= FILE_DIRECTORY;
     2135      WinSendMsg(hwnd, CM_FILTER, MPFROMP(Filter), MPFROMP(&dcd->mask));
     2136      dcd->suspendview = tempsusp;
     2137      PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
     2138    }
     2139    return 0;
     2140
     2141  case UM_DRIVECMD:
     2142    if (mp1)
     2143      ShowTreeRec(hwnd, (CHAR *) mp1, FALSE, TRUE);
     2144    return 0;
     2145
     2146  case WM_APPTERMINATENOTIFY:
     2147    {
     2148      APPNOTIFY *info;
     2149      PCNRITEM pci;
     2150      CHAR s[] = " :\\";
     2151
     2152      if (!mp2) {
     2153        if (hwndMain)
     2154          PostMsg(hwndMain, UM_BUILDDRIVEBAR, MPVOID, MPVOID);
     2155      }
     2156      info = apphead;
     2157      while (info) {
     2158        if (info->happ == (HAPP) mp1) {
     2159          *s = info->device;
     2160          pci = FindCnrRecord(hwnd, s, NULL, FALSE, FALSE, TRUE);
     2161          if (pci && (INT) pci != -1) {
     2162            driveserial[info->device - 'A'] = -1;
     2163            DriveFlagsOne(info->device - 'A');
     2164            if (driveflags[info->device - 'A'] &
     2165                (DRIVE_INVALID | DRIVE_IGNORE))
     2166              WinSendMsg(hwnd,
     2167                         CM_REMOVERECORD,
     2168                         MPFROMP(&pci), MPFROM2SHORT(1, CMA_FREE));
     2169            else
     2170              Flesh(hwnd, pci);
     2171          }
     2172          if (info->prev)
     2173            info->prev->next = info->next;
     2174          if (info->next)
     2175            info->next->prev = info->prev;
     2176          if (apphead == info)
     2177            apphead = info->next;
     2178          if (apptail == info)
     2179            apptail = info->prev;
     2180          free(info);
     2181          break;
     2182        }
     2183        info = info->next;
     2184      }
     2185    }
     2186    break;
     2187
     2188  case WM_COMMAND:
     2189    DosError(FERR_DISABLEHARDERR);
     2190    if (dcd) {
     2191      if (SwitchCommand(dcd->hwndLastMenu, SHORT1FROMMP(mp1)))
     2192        return 0;
     2193      switch (SHORT1FROMMP(mp1)) {
     2194      case IDM_SETTARGET:
     2195        SetTargetDir(hwnd, FALSE);
     2196        break;
     2197
     2198      case IDM_DETACH:
     2199        {
     2200          CHAR d[3] = " :";
     2201          PCNRITEM pci;
     2202          PROGDETAILS pgd;
     2203          CHAR params[368], *p;
     2204          HAPP happ;
     2205
     2206          pci = (PCNRITEM) CurrentRecord(hwnd);
     2207          if (pci && (INT) pci != -1 && isalpha(*pci->szFileName)) {
     2208            *d = toupper(*pci->szFileName);
     2209            p = GetCmdSpec(FALSE);
     2210            memset(&pgd, 0, sizeof(pgd));
     2211            pgd.Length = sizeof(pgd);
     2212            pgd.progt.progc = PROG_WINDOWABLEVIO;
     2213            pgd.progt.fbVisible = SHE_VISIBLE;
     2214            pgd.pszTitle = GetPString(IDS_DETACHREQUESTTEXT);
     2215            pgd.pszExecutable = p;
     2216            pgd.pszParameters = params;
     2217            pgd.pszStartupDir = NULL;
     2218            pgd.pszIcon = NULL;
     2219            pgd.pszEnvironment = NULL;
     2220            pgd.swpInitial.hwndInsertBehind = HWND_TOP;
     2221            pgd.swpInitial.hwnd = hwnd;
     2222            pgd.swpInitial.fl = SWP_SHOW | SWP_ACTIVATE;
     2223            sprintf(params, "/C NET USE %s /D", d);
     2224            happ = WinStartApp(hwnd, &pgd, pgd.pszParameters,
     2225                               NULL, SAF_MAXIMIZED);
     2226            if (!happ) {
     2227              saymsg(MB_CANCEL | MB_ICONEXCLAMATION, hwnd,
     2228                     GetPString(IDS_ERRORTEXT),
     2229                     GetPString(IDS_CANTSTARTTEXT), p, params);
     2230            }
     2231            else {
     2232              APPNOTIFY *info;
     2233
     2234              info = xmallocz(sizeof(APPNOTIFY), pszSrcFile, __LINE__);
     2235              if (info) {
     2236                info->happ = happ;
     2237                info->device = *d;
     2238                if (!apphead)
     2239                  apphead = info;
     2240                else {
     2241                  apptail->next = info;
     2242                  info->prev = apptail;
     2243                }
     2244                apptail = info;
     2245              }
     2246            }
     2247          }
     2248        }
     2249        break;
     2250
     2251      case IDM_REMAP:
     2252        WinDlgBox(HWND_DESKTOP, hwnd, RemapDlgProc,
     2253                  FM3ModHandle, MAP_FRAME, NULL);
     2254        break;
     2255
     2256      case IDM_CONTEXTMENU:
     2257        {
     2258          PCNRITEM pci;
     2259
     2260          pci = (PCNRITEM) CurrentRecord(hwnd);
     2261          PostMsg(hwnd, WM_CONTROL, MPFROM2SHORT(DIR_CNR, CN_CONTEXTMENU),
     2262                  MPFROMP(pci));
     2263        }
     2264        break;
     2265
     2266      case IDM_FINDINTREE:
     2267        {
     2268          CHAR dir[CCHMAXPATH];
     2269          PCNRITEM pci;
     2270
     2271          pci = (PCNRITEM) CurrentRecord(hwnd);
     2272          if (pci && (INT) pci != -1) {
     2273            strcpy(dir, pci->szFileName);
     2274            MakeValidDir(dir);
     2275          }
     2276          else
     2277            save_dir2(dir);
     2278          if (WinDlgBox(HWND_DESKTOP, dcd->hwndParent,
     2279                        WalkAllDlgProc,
     2280                        FM3ModHandle, WALK_FRAME, MPFROMP(dir)) && *dir)
     2281            WinSendMsg(hwnd, UM_SHOWME, MPFROMP(dir), MPFROMLONG(1L));
     2282        }
     2283        break;
     2284
     2285      case IDM_BEGINEDIT:
     2286        OpenEdit(hwnd);
     2287        break;
     2288
     2289      case IDM_ENDEDIT:
     2290        WinSendMsg(hwnd, CM_CLOSEEDIT, MPVOID, MPVOID);
     2291        break;
     2292
     2293      case IDM_FILTER:
     2294        {
     2295          BOOL empty = FALSE;
     2296          PCNRITEM pci;
     2297
     2298          pci = (PCNRITEM) CurrentRecord(hwnd);
     2299          if (!*dcd->mask.szMask)
     2300            empty = TRUE;
     2301          dcd->mask.fIsTree = TRUE;
     2302          *dcd->mask.prompt = 0;
     2303          if (pci && (INT) pci != -1)
     2304            dcd->mask.fFilesIncluded =
     2305              ((driveflags[toupper(*pci->szFileName) - 'A'] &
     2306                DRIVE_INCLUDEFILES) != 0);
     2307          else
     2308            dcd->mask.fFilesIncluded = FALSE;
     2309          if (WinDlgBox(HWND_DESKTOP, hwnd, PickMaskDlgProc,
     2310                        FM3ModHandle, MSK_FRAME, MPFROMP(&dcd->mask)))
     2311            WinSendMsg(hwnd, UM_FILTER, MPVOID, MPVOID);
     2312          else if (empty)
     2313            *dcd->mask.szMask = 0;
     2314          PrfWriteProfileData(fmprof, appname, "TreeFilter", &dcd->mask,
     2315                              sizeof(MASK));
     2316        }
     2317        break;
     2318
     2319      case IDM_SHOWSORT:
     2320        QuickPopup(hwnd, dcd, CheckMenu(&TreeCnrMenu, TREECNR_POPUP),
     2321                   IDM_SORTSUBMENU);
     2322        break;
     2323
     2324      case IDM_SHOWSELECT:
     2325        QuickPopup(hwnd, dcd, CheckMenu(&TreeCnrMenu, TREECNR_POPUP),
     2326                   IDM_SELECTSUBMENU);
     2327        break;
     2328
     2329      case IDM_NOTEBOOK:
     2330        if (!ParentIsDesktop(dcd->hwndParent, dcd->hwndParent))
     2331          PostMsg(dcd->hwndParent, msg, mp1, mp2);
     2332        else
     2333          WinDlgBox(HWND_DESKTOP, hwnd, CfgDlgProc, FM3ModHandle,
     2334                    CFG_FRAME, (PVOID) "Tree");
     2335        break;
     2336
     2337      case IDM_WALKDIR:
     2338      case IDM_OPENWALK:
     2339        {
     2340          CHAR newpath[CCHMAXPATH];
     2341          PCNRITEM pci;
     2342
     2343          pci = (PCNRITEM) CurrentRecord(hwnd);
     2344          if (pci && (INT) pci != -1) {
     2345            strcpy(newpath, pci->szFileName);
     2346            MakeValidDir(newpath);
     2347          }
     2348          else
     2349            save_dir2(newpath);
     2350          if (!WinDlgBox(HWND_DESKTOP, dcd->hwndParent, WalkAllDlgProc,
     2351                         FM3ModHandle, WALK_FRAME,
     2352                         MPFROMP(newpath)) || !*newpath)
    23252353            break;
    2326         }
    2327       }
    2328       break;
    2329 
    2330     case UM_INITMENU:
    2331     case WM_INITMENU:
    2332       if(dcd) {
    2333         switch(SHORT1FROMMP(mp1)) {
    2334           case IDM_FILESMENU:
    2335             {
    2336               PCNRITEM pci;
    2337 
    2338               pci = (PCNRITEM)CurrentRecord(hwnd);
    2339               if(pci && (INT)pci != -1)
    2340               {
    2341                 BOOL rdy;
    2342                 BOOL writeable;
    2343                 BOOL removable;
    2344                 BOOL remote;
    2345                 BOOL underenv;
    2346                 CHAR chDrvU;
    2347                 CHAR szDrv[CCHMAXPATH];
    2348                 strcpy(szDrv, pci->szFileName);
    2349                 chDrvU = *pci->szFileName;
    2350                 chDrvU = toupper(chDrvU);
    2351                 MakeValidDir(szDrv);
    2352                 rdy = *szDrv == chDrvU;         // Drive not ready if MakeValidDir changes drive letter
    2353                 removable = rdy && (driveflags[chDrvU - 'A'] & DRIVE_REMOVABLE) != 0;
    2354                 writeable = rdy && !(driveflags[chDrvU - 'A'] & DRIVE_NOTWRITEABLE);
    2355                 remote    = rdy && (driveflags[chDrvU - 'A'] & DRIVE_REMOTE) != 0;
    2356                 underenv = (pci->flags & RECFLAGS_UNDERENV) != 0;
    2357 
    2358                 WinEnableMenuItem((HWND)mp2, IDM_INFO, rdy);
    2359 
    2360                 WinEnableMenuItem((HWND)mp2, IDM_ATTRS, writeable);
    2361                 WinEnableMenuItem((HWND)mp2, IDM_EAS, writeable);
    2362                 WinEnableMenuItem((HWND)mp2, IDM_SUBJECT, writeable);
    2363                 WinEnableMenuItem((HWND)mp2, IDM_DRVFLAGS, 1);  // fixme to allow if not ready
    2364 
    2365                 WinEnableMenuItem((HWND)mp2, IDM_ARCHIVE, rdy);
    2366 
    2367                 WinEnableMenuItem((HWND)mp2, IDM_UPDATE, !underenv);
    2368                 WinEnableMenuItem((HWND)mp2, IDM_EXPANDSUBMENU, !underenv);
    2369                 WinEnableMenuItem((HWND)mp2, IDM_EXPAND, !underenv);
    2370                 WinEnableMenuItem((HWND)mp2, IDM_COLLAPSE, !underenv);
    2371 
    2372                 WinEnableMenuItem((HWND)mp2, IDM_SIZES, rdy);
    2373                 WinEnableMenuItem((HWND)mp2, IDM_MKDIR, writeable);
    2374                 WinEnableMenuItem((HWND)mp2, IDM_SHOWALLFILES, rdy);
    2375                 WinEnableMenuItem((HWND)mp2, IDM_UNDELETE, writeable);
    2376 
    2377                 WinEnableMenuItem((HWND)mp2, IDM_CHKDSK, writeable && !remote);
    2378                 WinEnableMenuItem((HWND)mp2, IDM_FORMAT, writeable && !remote);
    2379                 WinEnableMenuItem((HWND)mp2, IDM_OPTIMIZE, writeable && !remote);
    2380                 WinEnableMenuItem((HWND)mp2, IDM_PARTITIONSMENU, !remote);
    2381 
    2382                 WinEnableMenuItem((HWND)mp2, IDM_DETACH, remote);
    2383 
    2384                 WinEnableMenuItem((HWND)mp2, IDM_EJECT, removable);
    2385 
    2386                 WinEnableMenuItem((HWND)mp2, IDM_LOCK, removable);
    2387                 WinEnableMenuItem((HWND)mp2, IDM_UNLOCK, removable);
    2388 
    2389                 WinEnableMenuItem((HWND)mp2, IDM_DELETE, !underenv && writeable);
    2390                 WinEnableMenuItem((HWND)mp2, IDM_PERMDELETE, !underenv && writeable);
    2391                 WinEnableMenuItem((HWND)mp2, IDM_DELETESUBMENU, !underenv && writeable);
    2392                 WinEnableMenuItem((HWND)mp2, IDM_MOVEMENU, !underenv && writeable);
    2393                 WinEnableMenuItem((HWND)mp2, IDM_RENAME, !underenv && writeable);
    2394 
    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;
    2423       }
    2424       if(msg == WM_INITMENU)
    2425         break;
    2426       return 0;
    2427 
    2428     case UM_COMMAND:
    2429       if (!mp1)
    2430         Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
    2431       else {
    2432         if (!dcd) {
    2433           Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
    2434           FreeListInfo((LISTINFO *)mp1);
    2435         }
    2436         else {
    2437           if (!PostMsg(dcd->hwndObject,UM_COMMAND,mp1,mp2)) {
    2438             Runtime_Error(pszSrcFile, __LINE__, "PostMsg");
    2439             FreeListInfo((LISTINFO *)mp1);
    2440           }
     2354          WinSendMsg(hwnd, UM_OPENWINDOWFORME, MPFROMP(newpath), MPVOID);
     2355        }
     2356        break;
     2357
     2358      case IDM_HELP:
     2359        if (hwndHelp) {
     2360          if (!ParentIsDesktop(dcd->hwndFrame, dcd->hwndParent))
     2361            PostMsg(dcd->hwndParent, UM_COMMAND, mp1, mp2);
    24412362          else
    2442             return (MRESULT)TRUE;
    2443         }
    2444       }
    2445       return 0;
    2446 
    2447     case UM_LOADFILE:
    2448       if(dcd && mp2) {
    2449 
    2450         HWND ret;
    2451 
    2452         ret = StartMLEEditor(dcd->hwndParent,(INT)mp1,(CHAR *)mp2,
    2453                              dcd->hwndFrame);
    2454         if(mp2)
    2455           free((CHAR *)mp2);
    2456         return MRFROMLONG(ret);
    2457       }
    2458       return 0;
    2459 
    2460     case UM_FIXCNRMLE:
    2461     case UM_FIXEDITNAME:
    2462       return CommonCnrProc(hwnd,msg,mp1,mp2);
    2463 
    2464     case UM_NOTIFY:
    2465       if(mp2)
    2466         Notify((CHAR *)mp2);
    2467       return 0;
    2468 
    2469     case UM_FILTER:
    2470       if(dcd) {
    2471 
    2472         BOOL tempsusp = dcd->suspendview;
    2473 
    2474         if(mp1) {
    2475           DosEnterCritSec();
    2476            SetMask((CHAR *)mp1,&dcd->mask);
    2477           DosExitCritSec();
    2478         }
    2479         dcd->suspendview = TRUE;
    2480         dcd->mask.attrFile |= FILE_DIRECTORY;
    2481         WinSendMsg(hwnd,CM_FILTER,MPFROMP(Filter),MPFROMP(&dcd->mask));
    2482         dcd->suspendview = tempsusp;
    2483         PostMsg(hwnd,UM_RESCAN,MPVOID,MPVOID);
    2484       }
    2485       return 0;
    2486 
    2487     case UM_DRIVECMD:
    2488       if(mp1)
    2489         ShowTreeRec(hwnd,(CHAR *)mp1,FALSE,TRUE);
    2490       return 0;
    2491 
    2492     case WM_APPTERMINATENOTIFY:
    2493       {
    2494         APPNOTIFY *info;
    2495         PCNRITEM   pci;
    2496         CHAR       s[] = " :\\";
    2497 
    2498         if(!mp2) {
    2499           if(hwndMain)
    2500             PostMsg(hwndMain,
    2501                     UM_BUILDDRIVEBAR,
    2502                     MPVOID,
    2503                     MPVOID);
    2504         }
    2505         info = apphead;
    2506         while(info) {
    2507           if(info->happ == (HAPP)mp1) {
    2508             *s = info->device;
    2509             pci = FindCnrRecord(hwnd,
    2510                                 s,
    2511                                 NULL,
    2512                                 FALSE,
    2513                                 FALSE,
    2514                                 TRUE);
    2515             if(pci && (INT)pci != -1) {
    2516               driveserial[info->device - 'A'] = -1;
    2517               DriveFlagsOne(info->device - 'A');
    2518               if(driveflags[info->device - 'A'] &
    2519                  (DRIVE_INVALID | DRIVE_IGNORE))
    2520                 WinSendMsg(hwnd,
    2521                            CM_REMOVERECORD,
    2522                            MPFROMP(&pci),
    2523                            MPFROM2SHORT(1,CMA_FREE));
    2524               else
    2525                 Flesh(hwnd,pci);
    2526             }
    2527             if(info->prev)
    2528               info->prev->next = info->next;
    2529             if(info->next)
    2530               info->next->prev = info->prev;
    2531             if(apphead == info)
    2532               apphead = info->next;
    2533             if(apptail == info)
    2534               apptail = info->prev;
    2535             free(info);
    2536             break;
    2537           }
    2538           info = info->next;
    2539         }
    2540       }
    2541       break;
    2542 
    2543     case WM_COMMAND:
    2544       DosError(FERR_DISABLEHARDERR);
    2545       if(dcd) {
    2546         if(SwitchCommand(dcd->hwndLastMenu,
    2547                    SHORT1FROMMP(mp1)))
    2548           return 0;
    2549         switch(SHORT1FROMMP(mp1)) {
    2550           case IDM_SETTARGET:
    2551             SetTargetDir(hwnd,FALSE);
    2552             break;
    2553 
    2554           case IDM_DETACH:
    2555             {
    2556               CHAR        d[3] = " :";
    2557               PCNRITEM    pci;
    2558               PROGDETAILS pgd;
    2559               CHAR        params[368],*p;
    2560               HAPP        happ;
    2561 
    2562 
    2563               pci = (PCNRITEM)CurrentRecord(hwnd);
    2564               if(pci && (INT)pci != -1 && isalpha(*pci->szFileName)) {
    2565                 *d = toupper(*pci->szFileName);
    2566                 p = GetCmdSpec(FALSE);
    2567                 memset(&pgd,0,sizeof(pgd));
    2568                 pgd.Length = sizeof(pgd);
    2569                 pgd.progt.progc = PROG_WINDOWABLEVIO;
    2570                 pgd.progt.fbVisible = SHE_VISIBLE;
    2571                 pgd.pszTitle = GetPString(IDS_DETACHREQUESTTEXT);
    2572                 pgd.pszExecutable = p;
    2573                 pgd.pszParameters = params;
    2574                 pgd.pszStartupDir = NULL;
    2575                 pgd.pszIcon = NULL;
    2576                 pgd.pszEnvironment = NULL;
    2577                 pgd.swpInitial.hwndInsertBehind = HWND_TOP;
    2578                 pgd.swpInitial.hwnd = hwnd;
    2579                 pgd.swpInitial.fl = SWP_SHOW | SWP_ACTIVATE;
    2580                 sprintf(params,"/C NET USE %s /D",d);
    2581                 happ = WinStartApp(hwnd,&pgd,pgd.pszParameters,
    2582                                    NULL,SAF_MAXIMIZED);
    2583                 if (!happ) {
    2584                   saymsg(MB_CANCEL | MB_ICONEXCLAMATION,hwnd,
    2585                          GetPString(IDS_ERRORTEXT),
    2586                          GetPString(IDS_CANTSTARTTEXT),
    2587                          p,params);
    2588                 }
    2589                 else {
    2590                   APPNOTIFY *info;
    2591 
    2592                   info = xmallocz(sizeof(APPNOTIFY), pszSrcFile, __LINE__);
    2593                   if (info) {
    2594                     info->happ = happ;
    2595                     info->device = *d;
    2596                     if (!apphead)
    2597                       apphead = info;
    2598                     else {
    2599                       apptail->next = info;
    2600                       info->prev = apptail;
    2601                     }
    2602                     apptail = info;
    2603                   }
    2604                 }
    2605               }
    2606             }
    2607             break;
    2608 
    2609           case IDM_REMAP:
    2610             WinDlgBox(HWND_DESKTOP,hwnd,RemapDlgProc,
    2611                       FM3ModHandle,MAP_FRAME,NULL);
    2612             break;
    2613 
    2614           case IDM_CONTEXTMENU:
    2615             {
    2616               PCNRITEM pci;
    2617 
    2618               pci = (PCNRITEM)CurrentRecord(hwnd);
    2619               PostMsg(hwnd,WM_CONTROL,MPFROM2SHORT(DIR_CNR,CN_CONTEXTMENU),
    2620                       MPFROMP(pci));
    2621             }
    2622             break;
    2623 
    2624           case IDM_FINDINTREE:
    2625             {
    2626               CHAR     dir[CCHMAXPATH];
    2627               PCNRITEM pci;
    2628 
    2629               pci = (PCNRITEM)CurrentRecord(hwnd);
    2630               if(pci && (INT)pci != -1) {
    2631                 strcpy(dir,pci->szFileName);
    2632                 MakeValidDir(dir);
    2633               }
    2634               else
    2635                 save_dir2(dir);
    2636               if(WinDlgBox(HWND_DESKTOP,dcd->hwndParent,
    2637                            WalkAllDlgProc,
    2638                            FM3ModHandle,WALK_FRAME,
    2639                            MPFROMP(dir)) && *dir)
    2640                 WinSendMsg(hwnd,UM_SHOWME,MPFROMP(dir),MPFROMLONG(1L));
    2641             }
    2642             break;
    2643 
    2644           case IDM_BEGINEDIT:
    2645             OpenEdit(hwnd);
    2646             break;
    2647 
    2648           case IDM_ENDEDIT:
    2649             WinSendMsg(hwnd,
    2650                        CM_CLOSEEDIT,
    2651                        MPVOID,
    2652                        MPVOID);
    2653             break;
    2654 
    2655           case IDM_FILTER:
    2656             {
    2657               BOOL     empty = FALSE;
    2658               PCNRITEM pci;
    2659 
    2660               pci = (PCNRITEM)CurrentRecord(hwnd);
    2661               if(!*dcd->mask.szMask)
    2662                 empty = TRUE;
    2663               dcd->mask.fIsTree = TRUE;
    2664               *dcd->mask.prompt = 0;
    2665               if(pci && (INT)pci != -1)
    2666                 dcd->mask.fFilesIncluded = ((driveflags[toupper(*pci->szFileName) - 'A'] &
    2667                                              DRIVE_INCLUDEFILES) != 0);
    2668               else
    2669                 dcd->mask.fFilesIncluded = FALSE;
    2670               if(WinDlgBox(HWND_DESKTOP,hwnd,PickMaskDlgProc,
    2671                            FM3ModHandle,MSK_FRAME,MPFROMP(&dcd->mask)))
    2672                 WinSendMsg(hwnd,UM_FILTER,MPVOID,MPVOID);
    2673               else if(empty)
    2674                 *dcd->mask.szMask = 0;
    2675               PrfWriteProfileData(fmprof,appname,"TreeFilter",&dcd->mask,
    2676                                   sizeof(MASK));
    2677             }
    2678             break;
    2679 
    2680           case IDM_SHOWSORT:
    2681             QuickPopup(hwnd,dcd,CheckMenu(&TreeCnrMenu,TREECNR_POPUP),
    2682                        IDM_SORTSUBMENU);
    2683             break;
    2684 
    2685           case IDM_SHOWSELECT:
    2686             QuickPopup(hwnd,dcd,CheckMenu(&TreeCnrMenu,TREECNR_POPUP),
    2687                        IDM_SELECTSUBMENU);
    2688             break;
    2689 
    2690           case IDM_NOTEBOOK:
    2691             if(!ParentIsDesktop(dcd->hwndParent,dcd->hwndParent))
    2692               PostMsg(dcd->hwndParent,msg,mp1,mp2);
    2693             else
    2694               WinDlgBox(HWND_DESKTOP,hwnd,CfgDlgProc,FM3ModHandle,
    2695                         CFG_FRAME,(PVOID)"Tree");
    2696             break;
    2697 
    2698           case IDM_WALKDIR:
    2699           case IDM_OPENWALK:
    2700             {
    2701               CHAR     newpath[CCHMAXPATH];
    2702               PCNRITEM pci;
    2703 
    2704               pci = (PCNRITEM)CurrentRecord(hwnd);
    2705               if(pci && (INT)pci != -1) {
    2706                 strcpy(newpath,pci->szFileName);
    2707                 MakeValidDir(newpath);
    2708               }
    2709               else
    2710                 save_dir2(newpath);
    2711               if(!WinDlgBox(HWND_DESKTOP,dcd->hwndParent,WalkAllDlgProc,
    2712                             FM3ModHandle,WALK_FRAME,
    2713                             MPFROMP(newpath)) || !*newpath)
    2714                 break;
    2715               WinSendMsg(hwnd,UM_OPENWINDOWFORME,MPFROMP(newpath),MPVOID);
    2716             }
    2717             break;
    2718 
    2719           case IDM_HELP:
    2720             if(hwndHelp) {
    2721               if(!ParentIsDesktop(dcd->hwndFrame,dcd->hwndParent))
    2722                 PostMsg(dcd->hwndParent,UM_COMMAND,mp1,mp2);
    2723               else
    2724                 WinSendMsg(hwndHelp,HM_HELP_CONTENTS,MPVOID,MPVOID);
    2725             }
    2726             break;
    2727 
    2728           case IDM_PARTITION:
    2729             runemf2(SEPARATE | WINDOWED,HWND_DESKTOP,NULL,NULL,
    2730                     "%s","MINILVM.EXE");
    2731             break;
    2732 
    2733 case IDM_PARTITIONDF:
    2734   runemf2(SEPARATE | WINDOWED,HWND_DESKTOP,NULL,NULL,
    2735    "%s","DFSOS2.EXE");
    2736   break;
    2737 
    2738 case IDM_PARTITIONLVMG:
    2739   runemf2(SEPARATE | WINDOWED,HWND_DESKTOP,NULL,NULL,
    2740    "%s","LVMGUI.CMD");
    2741   break;
    2742 
    2743 case IDM_PARTITIONFD:
    2744   runemf2(SEPARATE | WINDOWED,HWND_DESKTOP,NULL,NULL,
    2745    "%s","FDISKPM.EXE");
    2746   break;
    2747 
    2748           case IDM_SORTNAME:
    2749           case IDM_SORTFILENAME:
    2750           case IDM_SORTSIZE:
    2751           case IDM_SORTEASIZE:
    2752           case IDM_SORTFIRST:
    2753           case IDM_SORTLAST:
    2754           case IDM_SORTLWDATE:
    2755           case IDM_SORTLADATE:
    2756           case IDM_SORTCRDATE:
    2757             TreesortFlags &= (SORT_REVERSE | SORT_DIRSFIRST | SORT_DIRSLAST);
    2758           case IDM_SORTDIRSFIRST:
    2759           case IDM_SORTDIRSLAST:
    2760           case IDM_SORTREVERSE:
    2761             switch(SHORT1FROMMP(mp1)) {
    2762               case IDM_SORTFILENAME:
    2763                 TreesortFlags |= SORT_FILENAME;
    2764                 break;
    2765               case IDM_SORTSIZE:
    2766                 TreesortFlags |= SORT_SIZE;
    2767                 break;
    2768               case IDM_SORTEASIZE:
    2769                 TreesortFlags |= SORT_EASIZE;
    2770                 break;
    2771               case IDM_SORTFIRST:
    2772                 TreesortFlags |= SORT_FIRSTEXTENSION;
    2773                 break;
    2774               case IDM_SORTLAST:
    2775                 TreesortFlags |= SORT_LASTEXTENSION;
    2776                 break;
    2777               case IDM_SORTLWDATE:
    2778                 TreesortFlags |= SORT_LWDATE;
    2779                 break;
    2780               case IDM_SORTLADATE:
    2781                 TreesortFlags |= SORT_LADATE;
    2782                 break;
    2783               case IDM_SORTCRDATE:
    2784                 TreesortFlags |= SORT_CRDATE;
    2785                 break;
    2786               case IDM_SORTDIRSFIRST:
    2787                 if(TreesortFlags & SORT_DIRSFIRST)
    2788                   TreesortFlags &= (~SORT_DIRSFIRST);
    2789                 else {
    2790                   TreesortFlags |= SORT_DIRSFIRST;
    2791                   TreesortFlags &= (~SORT_DIRSLAST);
    2792                 }
    2793                 break;
    2794               case IDM_SORTDIRSLAST:
    2795                 if(TreesortFlags & SORT_DIRSLAST)
    2796                   TreesortFlags &= (~SORT_DIRSLAST);
    2797                 else {
    2798                   TreesortFlags |= SORT_DIRSLAST;
    2799                   TreesortFlags &= (~SORT_DIRSFIRST);
    2800                 }
    2801                 break;
    2802               case IDM_SORTREVERSE:
    2803                 if(TreesortFlags & SORT_REVERSE)
    2804                   TreesortFlags &= (~SORT_REVERSE);
    2805                 else
    2806                   TreesortFlags |= SORT_REVERSE;
    2807                 break;
    2808             }
    2809             PrfWriteProfileData(fmprof,appname,"TreeSort",&TreesortFlags,
    2810                                 sizeof(INT));
    2811             WinSendMsg(hwnd,CM_SORTRECORD,MPFROMP(SortTreeCnr),MPVOID);
    2812             break;
    2813 
    2814           case IDM_COLLECT:
    2815             if(!Collector) {
    2816 
    2817               HWND hwndC;
    2818               SWP  swp;
    2819 
    2820               if(!ParentIsDesktop(hwnd,dcd->hwndParent) &&
    2821                  !fAutoTile &&
    2822                  (!fExternalCollector &&
    2823                   *(ULONG *)realappname == FM3UL))
    2824                 GetNextWindowPos(dcd->hwndParent,
    2825                                  &swp,
    2826                                  NULL,
    2827                                  NULL);
    2828               hwndC = StartCollector((fExternalCollector ||
    2829                                       *(ULONG *)realappname != FM3UL) ?
    2830                                      HWND_DESKTOP :
    2831                                      dcd->hwndParent,
    2832                                      4);
    2833               if(hwndC) {
    2834                 if(!ParentIsDesktop(hwnd,
    2835                                     dcd->hwndParent) &&
    2836                    !fAutoTile &&
    2837                    (!fExternalCollector &&
    2838                     *(ULONG *)realappname == FM3UL))
    2839                   WinSetWindowPos(hwndC,
    2840                                   HWND_TOP,
    2841                                   swp.x,
    2842                                   swp.y,
    2843                                   swp.cx,
    2844                                   swp.cy,
    2845                                   SWP_MOVE | SWP_SIZE |
    2846                                   SWP_SHOW | SWP_ZORDER);
    2847                 else if(!ParentIsDesktop(hwnd,
    2848                                          dcd->hwndParent) &&
    2849                         fAutoTile &&
    2850                         *(ULONG *)realappname == FM3UL)
    2851                   TileChildren(dcd->hwndParent,
    2852                                TRUE);
    2853               }
     2363            WinSendMsg(hwndHelp, HM_HELP_CONTENTS, MPVOID, MPVOID);
     2364        }
     2365        break;
     2366
     2367      case IDM_PARTITION:
     2368        runemf2(SEPARATE | WINDOWED, HWND_DESKTOP, NULL, NULL,
     2369                "%s", "MINILVM.EXE");
     2370        break;
     2371
     2372      case IDM_PARTITIONDF:
     2373        runemf2(SEPARATE | WINDOWED, HWND_DESKTOP, NULL, NULL,
     2374                "%s", "DFSOS2.EXE");
     2375        break;
     2376
     2377      case IDM_PARTITIONLVMG:
     2378        runemf2(SEPARATE | WINDOWED, HWND_DESKTOP, NULL, NULL,
     2379                "%s", "LVMGUI.CMD");
     2380        break;
     2381
     2382      case IDM_PARTITIONFD:
     2383        runemf2(SEPARATE | WINDOWED, HWND_DESKTOP, NULL, NULL,
     2384                "%s", "FDISKPM.EXE");
     2385        break;
     2386
     2387      case IDM_SORTNAME:
     2388      case IDM_SORTFILENAME:
     2389      case IDM_SORTSIZE:
     2390      case IDM_SORTEASIZE:
     2391      case IDM_SORTFIRST:
     2392      case IDM_SORTLAST:
     2393      case IDM_SORTLWDATE:
     2394      case IDM_SORTLADATE:
     2395      case IDM_SORTCRDATE:
     2396        TreesortFlags &= (SORT_REVERSE | SORT_DIRSFIRST | SORT_DIRSLAST);
     2397      case IDM_SORTDIRSFIRST:
     2398      case IDM_SORTDIRSLAST:
     2399      case IDM_SORTREVERSE:
     2400        switch (SHORT1FROMMP(mp1)) {
     2401        case IDM_SORTFILENAME:
     2402          TreesortFlags |= SORT_FILENAME;
     2403          break;
     2404        case IDM_SORTSIZE:
     2405          TreesortFlags |= SORT_SIZE;
     2406          break;
     2407        case IDM_SORTEASIZE:
     2408          TreesortFlags |= SORT_EASIZE;
     2409          break;
     2410        case IDM_SORTFIRST:
     2411          TreesortFlags |= SORT_FIRSTEXTENSION;
     2412          break;
     2413        case IDM_SORTLAST:
     2414          TreesortFlags |= SORT_LASTEXTENSION;
     2415          break;
     2416        case IDM_SORTLWDATE:
     2417          TreesortFlags |= SORT_LWDATE;
     2418          break;
     2419        case IDM_SORTLADATE:
     2420          TreesortFlags |= SORT_LADATE;
     2421          break;
     2422        case IDM_SORTCRDATE:
     2423          TreesortFlags |= SORT_CRDATE;
     2424          break;
     2425        case IDM_SORTDIRSFIRST:
     2426          if (TreesortFlags & SORT_DIRSFIRST)
     2427            TreesortFlags &= (~SORT_DIRSFIRST);
     2428          else {
     2429            TreesortFlags |= SORT_DIRSFIRST;
     2430            TreesortFlags &= (~SORT_DIRSLAST);
     2431          }
     2432          break;
     2433        case IDM_SORTDIRSLAST:
     2434          if (TreesortFlags & SORT_DIRSLAST)
     2435            TreesortFlags &= (~SORT_DIRSLAST);
     2436          else {
     2437            TreesortFlags |= SORT_DIRSLAST;
     2438            TreesortFlags &= (~SORT_DIRSFIRST);
     2439          }
     2440          break;
     2441        case IDM_SORTREVERSE:
     2442          if (TreesortFlags & SORT_REVERSE)
     2443            TreesortFlags &= (~SORT_REVERSE);
     2444          else
     2445            TreesortFlags |= SORT_REVERSE;
     2446          break;
     2447        }
     2448        PrfWriteProfileData(fmprof, appname, "TreeSort", &TreesortFlags,
     2449                            sizeof(INT));
     2450        WinSendMsg(hwnd, CM_SORTRECORD, MPFROMP(SortTreeCnr), MPVOID);
     2451        break;
     2452
     2453      case IDM_COLLECT:
     2454        if (!Collector) {
     2455
     2456          HWND hwndC;
     2457          SWP swp;
     2458
     2459          if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
     2460              !fAutoTile &&
     2461              (!fExternalCollector && *(ULONG *) realappname == FM3UL))
     2462            GetNextWindowPos(dcd->hwndParent, &swp, NULL, NULL);
     2463          hwndC = StartCollector((fExternalCollector ||
     2464                                  *(ULONG *) realappname != FM3UL) ?
     2465                                 HWND_DESKTOP : dcd->hwndParent, 4);
     2466          if (hwndC) {
     2467            if (!ParentIsDesktop(hwnd,
     2468                                 dcd->hwndParent) &&
     2469                !fAutoTile &&
     2470                (!fExternalCollector && *(ULONG *) realappname == FM3UL))
    28542471              WinSetWindowPos(hwndC,
    28552472                              HWND_TOP,
    2856                               0,
    2857                               0,
    2858                               0,
    2859                               0,
    2860                               SWP_ACTIVATE);
    2861               DosSleep(250L);
     2473                              swp.x,
     2474                              swp.y,
     2475                              swp.cx,
     2476                              swp.cy,
     2477                              SWP_MOVE | SWP_SIZE | SWP_SHOW | SWP_ZORDER);
     2478            else if (!ParentIsDesktop(hwnd,
     2479                                      dcd->hwndParent) &&
     2480                     fAutoTile && *(ULONG *) realappname == FM3UL)
     2481              TileChildren(dcd->hwndParent, TRUE);
     2482          }
     2483          WinSetWindowPos(hwndC, HWND_TOP, 0, 0, 0, 0, SWP_ACTIVATE);
     2484          DosSleep(250L);
     2485        }
     2486        else
     2487          StartCollector(dcd->hwndParent, 4);
     2488        PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_COLLECTOR, 0), MPVOID);
     2489        break;
     2490
     2491      case IDM_COLLECTOR:
     2492        DosSleep(64L);
     2493        {
     2494          CHAR **list;
     2495
     2496          list = BuildList(hwnd);
     2497          if (list) {
     2498            if (Collector) {
     2499              if (!PostMsg(Collector, WM_COMMAND,
     2500                           MPFROM2SHORT(IDM_COLLECTOR, 0), MPFROMP(list)))
     2501                FreeList(list);
    28622502            }
    28632503            else
    2864               StartCollector(dcd->hwndParent,
    2865                              4);
    2866             PostMsg(hwnd,
    2867                     WM_COMMAND,
    2868                     MPFROM2SHORT(IDM_COLLECTOR,0),
    2869                     MPVOID);
    2870             break;
    2871 
    2872           case IDM_COLLECTOR:
    2873             DosSleep(64L);
    2874             {
    2875               CHAR **list;
    2876 
    2877               list = BuildList(hwnd);
    2878               if(list) {
    2879                 if(Collector) {
    2880                   if(!PostMsg(Collector,WM_COMMAND,
    2881                                  MPFROM2SHORT(IDM_COLLECTOR,0),
    2882                                  MPFROMP(list)))
    2883                     FreeList(list);
     2504              FreeList(list);
     2505          }
     2506        }
     2507        break;
     2508
     2509      case IDM_COLLAPSEALL:
     2510        WinSendMsg(hwnd, CM_COLLAPSETREE, MPVOID, MPVOID);
     2511        break;
     2512
     2513      case IDM_COLLAPSE:
     2514      case IDM_EXPAND:
     2515        {
     2516          PCNRITEM pci = NULL;
     2517
     2518          pci = (PCNRITEM) CurrentRecord(hwnd);
     2519          if (pci && (INT) pci != -1) {
     2520            if (pci->flags & RECFLAGS_UNDERENV)
     2521              break;
     2522            PostMsg(dcd->hwndObject, UM_EXPAND, mp1, MPFROMP(pci));
     2523          }
     2524        }
     2525        break;
     2526
     2527      case IDM_UPDATE:
     2528        {
     2529          PCNRITEM pci = NULL;
     2530
     2531          pci = (PCNRITEM) CurrentRecord(hwnd);
     2532          if (pci && (INT) pci != -1) {
     2533            if (pci->attrFile & FILE_DIRECTORY) {
     2534              if (pci->flags & RECFLAGS_UNDERENV)
     2535                break;
     2536              UnFlesh(hwnd, pci);
     2537              if (driveflags[toupper(*pci->szFileName) - 'A'] &
     2538                  (DRIVE_INVALID | DRIVE_NOPRESCAN)) {
     2539                driveflags[toupper(*pci->szFileName) - 'A'] &=
     2540                  (DRIVE_IGNORE | DRIVE_NOPRESCAN | DRIVE_NOLOADICONS |
     2541                   DRIVE_NOLOADSUBJS | DRIVE_NOLOADLONGS);
     2542                DriveFlagsOne(toupper(*pci->szFileName) - 'A');
     2543                if (driveflags[toupper(*pci->szFileName) - 'A'] &
     2544                    DRIVE_INVALID)
     2545                  pci->rc.hptrIcon = hptrDunno;
     2546                else {
     2547                  if (driveflags[toupper(*pci->szFileName) - 'A'] &
     2548                      DRIVE_CDROM)
     2549                    pci->rc.hptrIcon = hptrCDROM;
     2550                  else
     2551                    pci->rc.hptrIcon =
     2552                      (driveflags[toupper(*pci->szFileName) - 'A'] &
     2553                       DRIVE_REMOVABLE) ? hptrRemovable
     2554                      : (driveflags[toupper(*pci->szFileName) - 'A'] &
     2555                         DRIVE_REMOTE) ? hptrRemote
     2556                      : (driveflags[toupper(*pci->szFileName) - 'A'] &
     2557                         DRIVE_ZIPSTREAM) ? hptrZipstrm : hptrDrive;
    28842558                }
    2885                 else
    2886                   FreeList(list);
     2559                WinSendMsg(hwnd,
     2560                           CM_INVALIDATERECORD,
     2561                           MPFROMP(&pci),
     2562                           MPFROM2SHORT(1, CMA_ERASE | CMA_REPOSITION));
     2563                if (hwndMain)
     2564                  PostMsg(hwndMain, UM_BUILDDRIVEBAR, MPVOID, MPVOID);
    28872565              }
    2888             }
    2889             break;
    2890 
    2891           case IDM_COLLAPSEALL:
    2892             WinSendMsg(hwnd,
    2893                        CM_COLLAPSETREE,
    2894                        MPVOID,
    2895                        MPVOID);
    2896             break;
    2897 
    2898           case IDM_COLLAPSE:
    2899           case IDM_EXPAND:
    2900             {
    2901               PCNRITEM pci = NULL;
    2902 
    2903               pci = (PCNRITEM)CurrentRecord(hwnd);
    2904               if(pci && (INT)pci != -1) {
    2905                 if(pci->flags & RECFLAGS_UNDERENV)
    2906                   break;
    2907                 PostMsg(dcd->hwndObject,
    2908                         UM_EXPAND,
    2909                         mp1,
    2910                         MPFROMP(pci));
     2566              if (!
     2567                  (driveflags[toupper(*pci->szFileName) - 'A'] &
     2568                   DRIVE_INVALID))
     2569                Flesh(hwnd, pci);
     2570            }
     2571            else {
     2572
     2573            }
     2574          }
     2575        }
     2576        break;
     2577
     2578      case IDM_RESCAN:
     2579        PostMsg(dcd->hwndObject, UM_RESCAN, MPVOID, MPVOID);
     2580        break;
     2581
     2582      case IDM_RESORT:
     2583        WinSendMsg(hwnd, CM_SORTRECORD, MPFROMP(SortTreeCnr), MPVOID);
     2584        break;
     2585
     2586      case IDM_TEXT:
     2587      case IDM_MINIICONS:
     2588        {
     2589          CNRINFO cnri;
     2590
     2591          memset(&cnri, 0, sizeof(CNRINFO));
     2592          cnri.cb = sizeof(CNRINFO);
     2593          WinSendMsg(hwnd,
     2594                     CM_QUERYCNRINFO,
     2595                     MPFROMP(&cnri), MPFROMLONG(sizeof(CNRINFO)));
     2596          if (SHORT1FROMMP(mp1) == IDM_MINIICONS) {
     2597            if (cnri.flWindowAttr & CV_MINI)
     2598              cnri.flWindowAttr &= (~CV_MINI);
     2599            else
     2600              cnri.flWindowAttr |= CV_MINI;
     2601          }
     2602          else {
     2603            if (cnri.flWindowAttr & CV_TEXT) {
     2604              cnri.flWindowAttr &= (~CV_TEXT);
     2605              cnri.flWindowAttr |= CV_ICON;
     2606            }
     2607            else {
     2608              cnri.flWindowAttr &= (~CV_ICON);
     2609              cnri.flWindowAttr |= CV_TEXT;
     2610            }
     2611          }
     2612          dcd->flWindowAttr = cnri.flWindowAttr;
     2613          PrfWriteProfileData(fmprof,
     2614                              appname,
     2615                              "TreeflWindowAttr",
     2616                              &cnri.flWindowAttr, sizeof(ULONG));
     2617          WinSendMsg(hwnd,
     2618                     CM_SETCNRINFO,
     2619                     MPFROMP(&cnri),
     2620                     MPFROMLONG(CMA_FLWINDOWATTR | CMA_TREEICON |
     2621                                CMA_SLTREEBITMAPORICON));
     2622        }
     2623        break;
     2624
     2625      case IDM_SIZES:
     2626      case IDM_DRVFLAGS:
     2627      case IDM_SHOWALLFILES:
     2628      case IDM_UNDELETE:
     2629      case IDM_OPTIMIZE:
     2630      case IDM_CHKDSK:
     2631      case IDM_FORMAT:
     2632      case IDM_MKDIR:
     2633      case IDM_LOCK:
     2634      case IDM_UNLOCK:
     2635      case IDM_EJECT:
     2636      case IDM_CLOSETRAY:
     2637        {
     2638          PCNRITEM pci;
     2639
     2640          pci = (PCNRITEM) CurrentRecord(hwnd);
     2641          if (pci && (INT) pci != -1)
     2642            CommonDriveCmd(hwnd, pci->szFileName, SHORT1FROMMP(mp1));
     2643        }
     2644        break;
     2645
     2646      case IDM_SAVETOLIST:
     2647        WinDlgBox(HWND_DESKTOP,
     2648                  hwnd,
     2649                  SaveListDlgProc, FM3ModHandle, SAV_FRAME, MPFROMP(&hwnd));
     2650        break;
     2651
     2652      case IDM_DELETE:
     2653      case IDM_PERMDELETE:
     2654      case IDM_MOVE:
     2655      case IDM_WPSMOVE:
     2656      case IDM_WILDMOVE:
     2657      case IDM_RENAME:
     2658        {
     2659          PCNRITEM pci;
     2660
     2661          pci = (PCNRITEM) CurrentRecord(hwnd);
     2662          if (pci && (INT) pci != -1) {
     2663            if (pci->flags & RECFLAGS_UNDERENV)
     2664              break;
     2665          }
     2666        }
     2667        /* else intentional fallthru */
     2668      case IDM_ATTRS:
     2669      case IDM_INFO:
     2670      case IDM_COPY:
     2671      case IDM_WPSCOPY:
     2672      case IDM_WILDCOPY:
     2673      case IDM_DOITYOURSELF:
     2674      case IDM_OPENWINDOW:
     2675      case IDM_OPENSETTINGS:
     2676      case IDM_OPENDEFAULT:
     2677      case IDM_OPENICON:
     2678      case IDM_OPENDETAILS:
     2679      case IDM_OPENTREE:
     2680      case IDM_SHADOW:
     2681      case IDM_SHADOW2:
     2682      case IDM_COMPARE:
     2683      case IDM_VIEW:
     2684      case IDM_VIEWTEXT:
     2685      case IDM_VIEWBINARY:
     2686      case IDM_EDIT:
     2687      case IDM_EDITTEXT:
     2688      case IDM_EDITBINARY:
     2689      case IDM_EAS:
     2690      case IDM_SUBJECT:
     2691      case IDM_APPENDTOCLIP:
     2692      case IDM_SAVETOCLIP:
     2693      case IDM_ARCHIVE:
     2694      case IDM_MCIPLAY:
     2695      case IDM_UUDECODE:
     2696        {
     2697          LISTINFO *li;
     2698          ULONG action = UM_ACTION;
     2699
     2700          li = xmallocz(sizeof(LISTINFO), pszSrcFile, __LINE__);
     2701          if (li) {
     2702            li->type = SHORT1FROMMP(mp1);
     2703            li->hwnd = hwnd;
     2704            li->list = BuildList(hwnd);
     2705            if (!li->list || !li->list[0]) {
     2706              free(li);
     2707              break;
     2708            }
     2709            if (IsRoot(li->list[0])) {
     2710              switch (SHORT1FROMMP(mp1)) {
     2711              case IDM_MOVE:
     2712              case IDM_COPY:
     2713              case IDM_WILDCOPY:
     2714              case IDM_WILDMOVE:
     2715              case IDM_WPSMOVE:
     2716              case IDM_WPSCOPY:
     2717              case IDM_RENAME:
     2718              case IDM_DELETE:
     2719              case IDM_PERMDELETE:
     2720                mp1 = MPFROM2SHORT(IDM_INFO, SHORT2FROMMP(mp1));
     2721                li->type = IDM_INFO;
     2722                break;
    29112723              }
    29122724            }
    2913             break;
    2914 
    2915           case IDM_UPDATE:
    2916             {
    2917               PCNRITEM pci = NULL;
    2918 
    2919               pci = (PCNRITEM)CurrentRecord(hwnd);
    2920               if(pci && (INT)pci != -1) {
    2921                 if(pci->attrFile & FILE_DIRECTORY) {
    2922                   if(pci->flags & RECFLAGS_UNDERENV)
    2923                     break;
    2924                   UnFlesh(hwnd,pci);
    2925                   if(driveflags[toupper(*pci->szFileName) - 'A'] & (DRIVE_INVALID |
    2926                                       DRIVE_NOPRESCAN)) {
    2927                     driveflags[toupper(*pci->szFileName) - 'A'] &= (DRIVE_IGNORE |
    2928                                       DRIVE_NOPRESCAN | DRIVE_NOLOADICONS |
    2929                                       DRIVE_NOLOADSUBJS | DRIVE_NOLOADLONGS);
    2930                     DriveFlagsOne(toupper(*pci->szFileName) - 'A');
    2931                     if(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_INVALID)
    2932                       pci->rc.hptrIcon = hptrDunno;
    2933                     else {
    2934                       if(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_CDROM)
    2935                         pci->rc.hptrIcon = hptrCDROM;
    2936                       else
    2937                         pci->rc.hptrIcon = (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_REMOVABLE) ?
    2938                                             hptrRemovable :
    2939                                             (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_REMOTE) ?
    2940                                             hptrRemote :
    2941                                             (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_ZIPSTREAM) ?
    2942                                             hptrZipstrm : hptrDrive;
    2943                     }
    2944                     WinSendMsg(hwnd,
    2945                                CM_INVALIDATERECORD,
    2946                                MPFROMP(&pci),
    2947                                MPFROM2SHORT(1,CMA_ERASE | CMA_REPOSITION));
    2948                     if(hwndMain)
    2949                       PostMsg(hwndMain,
    2950                               UM_BUILDDRIVEBAR,
    2951                               MPVOID,
    2952                               MPVOID);
    2953                   }
    2954                   if(!(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_INVALID))
    2955                     Flesh(hwnd,pci);
    2956                 }
    2957                 else {
    2958 
    2959                 }
    2960               }
    2961             }
    2962             break;
    2963 
    2964           case IDM_RESCAN:
    2965             PostMsg(dcd->hwndObject,
    2966                     UM_RESCAN,
    2967                     MPVOID,
    2968                     MPVOID);
    2969             break;
    2970 
    2971           case IDM_RESORT:
    2972             WinSendMsg(hwnd,
    2973                        CM_SORTRECORD,
    2974                        MPFROMP(SortTreeCnr),
    2975                        MPVOID);
    2976             break;
    2977 
    2978           case IDM_TEXT:
    2979           case IDM_MINIICONS:
    2980             {
    2981               CNRINFO cnri;
    2982 
    2983               memset(&cnri,0,sizeof(CNRINFO));
    2984               cnri.cb = sizeof(CNRINFO);
    2985               WinSendMsg(hwnd,
    2986                          CM_QUERYCNRINFO,
    2987                          MPFROMP(&cnri),
    2988                          MPFROMLONG(sizeof(CNRINFO)));
    2989               if(SHORT1FROMMP(mp1) == IDM_MINIICONS) {
    2990                 if(cnri.flWindowAttr & CV_MINI)
    2991                   cnri.flWindowAttr &= (~CV_MINI);
    2992                 else
    2993                   cnri.flWindowAttr |= CV_MINI;
    2994               }
    2995               else {
    2996                 if(cnri.flWindowAttr & CV_TEXT) {
    2997                   cnri.flWindowAttr &= (~CV_TEXT);
    2998                   cnri.flWindowAttr |= CV_ICON;
    2999                 }
    3000                 else {
    3001                   cnri.flWindowAttr &= (~CV_ICON);
    3002                   cnri.flWindowAttr |= CV_TEXT;
    3003                 }
    3004               }
    3005               dcd->flWindowAttr = cnri.flWindowAttr;
    3006               PrfWriteProfileData(fmprof,
    3007                                   appname,
    3008                                   "TreeflWindowAttr",
    3009                                   &cnri.flWindowAttr,
    3010                                   sizeof(ULONG));
    3011               WinSendMsg(hwnd,
    3012                          CM_SETCNRINFO,
    3013                          MPFROMP(&cnri),
    3014                          MPFROMLONG(CMA_FLWINDOWATTR | CMA_TREEICON |
    3015                                     CMA_SLTREEBITMAPORICON));
    3016             }
    3017             break;
    3018 
    3019           case IDM_SIZES:
    3020           case IDM_DRVFLAGS:
    3021           case IDM_SHOWALLFILES:
    3022           case IDM_UNDELETE:
    3023           case IDM_OPTIMIZE:
    3024           case IDM_CHKDSK:
    3025           case IDM_FORMAT:
    3026           case IDM_MKDIR:
    3027           case IDM_LOCK:
    3028           case IDM_UNLOCK:
    3029           case IDM_EJECT:
    3030           case IDM_CLOSETRAY:
    3031             {
    3032               PCNRITEM pci;
    3033 
    3034               pci = (PCNRITEM)CurrentRecord(hwnd);
    3035               if(pci && (INT)pci != -1)
    3036                 CommonDriveCmd(hwnd,
    3037                                pci->szFileName,
    3038                                SHORT1FROMMP(mp1));
    3039             }
    3040             break;
    3041 
    3042           case IDM_SAVETOLIST:
    3043             WinDlgBox(HWND_DESKTOP,
    3044                       hwnd,
    3045                       SaveListDlgProc,
    3046                       FM3ModHandle,
    3047                       SAV_FRAME,
    3048                       MPFROMP(&hwnd));
    3049             break;
    3050 
    3051           case IDM_DELETE:
    3052           case IDM_PERMDELETE:
    3053           case IDM_MOVE:
    3054           case IDM_WPSMOVE:
    3055           case IDM_WILDMOVE:
    3056           case IDM_RENAME:
    3057             {
    3058               PCNRITEM pci;
    3059 
    3060               pci = (PCNRITEM)CurrentRecord(hwnd);
    3061               if(pci && (INT)pci != -1) {
    3062                 if(pci->flags & RECFLAGS_UNDERENV)
    3063                   break;
    3064               }
    3065             }
    3066             /* else intentional fallthru */
    3067           case IDM_ATTRS:
    3068           case IDM_INFO:
    3069           case IDM_COPY:
    3070           case IDM_WPSCOPY:
    3071           case IDM_WILDCOPY:
    3072           case IDM_DOITYOURSELF:
    3073           case IDM_OPENWINDOW:
    3074           case IDM_OPENSETTINGS:
    3075           case IDM_OPENDEFAULT:
    3076           case IDM_OPENICON:
    3077           case IDM_OPENDETAILS:
    3078           case IDM_OPENTREE:
    3079           case IDM_SHADOW:
    3080           case IDM_SHADOW2:
    3081           case IDM_COMPARE:
    3082           case IDM_VIEW:
    3083           case IDM_VIEWTEXT:
    3084           case IDM_VIEWBINARY:
    3085           case IDM_EDIT:
    3086           case IDM_EDITTEXT:
    3087           case IDM_EDITBINARY:
    3088           case IDM_EAS:
    3089           case IDM_SUBJECT:
    3090           case IDM_APPENDTOCLIP:
    3091           case IDM_SAVETOCLIP:
    3092           case IDM_ARCHIVE:
    3093           case IDM_MCIPLAY:
    3094           case IDM_UUDECODE:
    3095             {
    3096               LISTINFO *li;
    3097               ULONG     action = UM_ACTION;
    3098 
    3099               li = xmallocz(sizeof(LISTINFO),pszSrcFile,__LINE__);
    3100               if (li) {
    3101                 li->type = SHORT1FROMMP(mp1);
    3102                 li->hwnd = hwnd;
    3103                 li->list = BuildList(hwnd);
    3104                 if(!li->list || !li->list[0]) {
    3105                   free(li);
    3106                   break;
    3107                 }
    3108                 if(IsRoot(li->list[0])) {
    3109                   switch(SHORT1FROMMP(mp1)) {
    3110                     case IDM_MOVE:
    3111                     case IDM_COPY:
    3112                     case IDM_WILDCOPY:
    3113                     case IDM_WILDMOVE:
    3114                     case IDM_WPSMOVE:
    3115                     case IDM_WPSCOPY:
    3116                     case IDM_RENAME:
    3117                     case IDM_DELETE:
    3118                     case IDM_PERMDELETE:
    3119                       mp1 = MPFROM2SHORT(IDM_INFO,SHORT2FROMMP(mp1));
    3120                       li->type = IDM_INFO;
    3121                       break;
    3122                   }
    3123                 }
    3124                 switch(SHORT1FROMMP(mp1)) {
    3125                   case IDM_APPENDTOCLIP:
    3126                   case IDM_SAVETOCLIP:
    3127                   case IDM_ARCHIVE:
    3128                   case IDM_DELETE:
    3129                   case IDM_PERMDELETE:
    3130                   case IDM_ATTRS:
    3131                   case IDM_SHADOW:
    3132                   case IDM_SHADOW2:
    3133                   case IDM_DOITYOURSELF:
    3134                   case IDM_EAS:
    3135                   case IDM_VIEW:
    3136                   case IDM_VIEWTEXT:
    3137                   case IDM_VIEWBINARY:
    3138                   case IDM_EDIT:
    3139                   case IDM_EDITTEXT:
    3140                   case IDM_EDITBINARY:
    3141                   case IDM_MCIPLAY:
    3142                     action = UM_MASSACTION;
    3143                     break;
    3144                 }
    3145                 if(SHORT1FROMMP(mp1) == IDM_SHADOW ||
    3146                    SHORT1FROMMP(mp1) == IDM_SHADOW2)
    3147                   *li->targetpath = 0;
    3148                 if(!PostMsg(dcd->hwndObject,action,MPFROMP(li),MPVOID)) {
    3149                   Runtime_Error(pszSrcFile, __LINE__, "PostMsg");
    3150                   FreeListInfo(li);
    3151                 }
    3152               }
    3153             }
    3154             break;
    3155 
    3156           default:
    3157             if(SHORT1FROMMP(mp1) >= IDM_COMMANDSTART &&
    3158                SHORT1FROMMP(mp1) < IDM_QUICKTOOLSTART) {
    3159 
    3160               INT  x;
    3161 
    3162               if(!cmdloaded)
    3163                 load_commands();
    3164               x = SHORT1FROMMP(mp1) - IDM_COMMANDSTART;
    3165               if(x >= 0) {
    3166                 x++;
    3167                 RunCommand(hwnd,x);
    3168                 if(fUnHilite)
    3169                   UnHilite(hwnd,TRUE,&dcd->lastselection);
    3170               }
    3171             }
    3172             break;
    3173         }
    3174       }
    3175       return 0;
    3176 
    3177     case WM_SAVEAPPLICATION:
    3178       if(dcd && !ParentIsDesktop(hwnd,dcd->hwndParent)) {
    3179 
    3180         SWP swp,swpP;
    3181         INT ratio;
    3182 
    3183         WinQueryWindowPos(dcd->hwndFrame,&swp);
    3184         if(!(swp.fl & (SWP_MINIMIZE | SWP_MAXIMIZE | SWP_HIDE))) {
    3185           WinQueryWindowPos(dcd->hwndParent,&swpP);
    3186           ratio = (swpP.cx * 100) / swp.cx;
    3187           if(ratio > 0)
    3188             PrfWriteProfileData(fmprof,appname,"TreeWindowRatio",
    3189                                 &ratio,sizeof(INT));
    3190         }
    3191       }
    3192       else if(dcd && ParentIsDesktop(hwnd,dcd->hwndParent)) {
    3193 
    3194         SWP swp;
    3195 
    3196         WinQueryWindowPos(dcd->hwndFrame,&swp);
    3197         if(!(swp.fl & (SWP_HIDE | SWP_MINIMIZE | SWP_MAXIMIZE)))
    3198           WinStoreWindowPos(FM2Str,"VTreeWindowPos",dcd->hwndFrame);
    3199       }
    3200       break;
    3201 
    3202     case UM_MINIMIZE:
    3203       if(dcd && hwndMain) {
    3204         fOkayMinimize = TRUE;
    3205         if(dcd->hwndObject && !fDummy) {
    3206           DosSleep(100L);
    3207           if(!fDummy) {
    3208             fOkayMinimize = FALSE;
    3209             WinSetWindowPos(((hwndMain) ? WinQueryWindow(hwndMain,QW_PARENT) :
    3210                              dcd->hwndFrame),HWND_TOP,0,0,0,0,SWP_MINIMIZE |
    3211                              SWP_DEACTIVATE);
    3212           }
    3213         }
    3214       }
    3215       return 0;
    3216 
    3217     case UM_MAXIMIZE:
    3218       if(dcd || hwndMain)
    3219         WinSetWindowPos(((hwndMain) ? WinQueryWindow(hwndMain,QW_PARENT) :
    3220                          dcd->hwndFrame),HWND_TOP,0,0,0,0,SWP_MAXIMIZE |
    3221                          SWP_SHOW);
    3222       return 0;
    3223 
    3224     case UM_CLOSE:
    3225       {
    3226         HWND hwndParent = WinQueryWindow(WinQueryWindow(WinQueryWindow(hwnd,
    3227                                          QW_PARENT),QW_PARENT),QW_PARENT);
    3228 
    3229         if(!mp1) {
    3230           if(!PostMsg((HWND)0,WM_QUIT,MPVOID,MPVOID))
    3231             WinSendMsg((HWND)0,WM_QUIT,MPVOID,MPVOID);
    3232           if(hwndParent && !ParentIsDesktop(hwnd,hwndParent))
    3233             WinDestroyWindow(hwndParent);
    3234         }
    3235         else
    3236           WinDestroyWindow(WinQueryWindow(WinQueryWindow(hwnd,QW_PARENT),
    3237                            QW_PARENT));
    3238       }
    3239       return 0;
    3240 
    3241     case WM_CLOSE:
    3242       WinSendMsg(hwnd,WM_SAVEAPPLICATION,MPVOID,MPVOID);
    3243       if(dcd)
    3244         dcd->stopflag++;
    3245       if(dcd && dcd->hwndObject) {
    3246         /* kill object window */
    3247         if(!PostMsg(dcd->hwndObject,WM_CLOSE,MPVOID,MPVOID))
    3248           WinSendMsg(dcd->hwndObject,WM_CLOSE,MPVOID,MPVOID);
     2725            switch (SHORT1FROMMP(mp1)) {
     2726            case IDM_APPENDTOCLIP:
     2727            case IDM_SAVETOCLIP:
     2728            case IDM_ARCHIVE:
     2729            case IDM_DELETE:
     2730            case IDM_PERMDELETE:
     2731            case IDM_ATTRS:
     2732            case IDM_SHADOW:
     2733            case IDM_SHADOW2:
     2734            case IDM_DOITYOURSELF:
     2735            case IDM_EAS:
     2736            case IDM_VIEW:
     2737            case IDM_VIEWTEXT:
     2738            case IDM_VIEWBINARY:
     2739            case IDM_EDIT:
     2740            case IDM_EDITTEXT:
     2741            case IDM_EDITBINARY:
     2742            case IDM_MCIPLAY:
     2743              action = UM_MASSACTION;
     2744              break;
     2745            }
     2746            if (SHORT1FROMMP(mp1) == IDM_SHADOW ||
     2747                SHORT1FROMMP(mp1) == IDM_SHADOW2)
     2748              *li->targetpath = 0;
     2749            if (!PostMsg(dcd->hwndObject, action, MPFROMP(li), MPVOID)) {
     2750              Runtime_Error(pszSrcFile, __LINE__, "PostMsg");
     2751              FreeListInfo(li);
     2752            }
     2753          }
     2754        }
     2755        break;
     2756
     2757      default:
     2758        if (SHORT1FROMMP(mp1) >= IDM_COMMANDSTART &&
     2759            SHORT1FROMMP(mp1) < IDM_QUICKTOOLSTART) {
     2760
     2761          INT x;
     2762
     2763          if (!cmdloaded)
     2764            load_commands();
     2765          x = SHORT1FROMMP(mp1) - IDM_COMMANDSTART;
     2766          if (x >= 0) {
     2767            x++;
     2768            RunCommand(hwnd, x);
     2769            if (fUnHilite)
     2770              UnHilite(hwnd, TRUE, &dcd->lastselection);
     2771          }
     2772        }
     2773        break;
     2774      }
     2775    }
     2776    return 0;
     2777
     2778  case WM_SAVEAPPLICATION:
     2779    if (dcd && !ParentIsDesktop(hwnd, dcd->hwndParent)) {
     2780
     2781      SWP swp, swpP;
     2782      INT ratio;
     2783
     2784      WinQueryWindowPos(dcd->hwndFrame, &swp);
     2785      if (!(swp.fl & (SWP_MINIMIZE | SWP_MAXIMIZE | SWP_HIDE))) {
     2786        WinQueryWindowPos(dcd->hwndParent, &swpP);
     2787        ratio = (swpP.cx * 100) / swp.cx;
     2788        if (ratio > 0)
     2789          PrfWriteProfileData(fmprof, appname, "TreeWindowRatio",
     2790                              &ratio, sizeof(INT));
     2791      }
     2792    }
     2793    else if (dcd && ParentIsDesktop(hwnd, dcd->hwndParent)) {
     2794
     2795      SWP swp;
     2796
     2797      WinQueryWindowPos(dcd->hwndFrame, &swp);
     2798      if (!(swp.fl & (SWP_HIDE | SWP_MINIMIZE | SWP_MAXIMIZE)))
     2799        WinStoreWindowPos(FM2Str, "VTreeWindowPos", dcd->hwndFrame);
     2800    }
     2801    break;
     2802
     2803  case UM_MINIMIZE:
     2804    if (dcd && hwndMain) {
     2805      fOkayMinimize = TRUE;
     2806      if (dcd->hwndObject && !fDummy) {
     2807        DosSleep(100L);
     2808        if (!fDummy) {
     2809          fOkayMinimize = FALSE;
     2810          WinSetWindowPos(((hwndMain) ? WinQueryWindow(hwndMain, QW_PARENT) :
     2811                           dcd->hwndFrame), HWND_TOP, 0, 0, 0, 0,
     2812                          SWP_MINIMIZE | SWP_DEACTIVATE);
     2813        }
     2814      }
     2815    }
     2816    return 0;
     2817
     2818  case UM_MAXIMIZE:
     2819    if (dcd || hwndMain)
     2820      WinSetWindowPos(((hwndMain) ? WinQueryWindow(hwndMain, QW_PARENT) :
     2821                       dcd->hwndFrame), HWND_TOP, 0, 0, 0, 0, SWP_MAXIMIZE |
     2822                      SWP_SHOW);
     2823    return 0;
     2824
     2825  case UM_CLOSE:
     2826    {
     2827      HWND hwndParent = WinQueryWindow(WinQueryWindow(WinQueryWindow(hwnd,
     2828                                                                     QW_PARENT),
     2829                                                      QW_PARENT), QW_PARENT);
     2830
     2831      if (!mp1) {
     2832        if (!PostMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID))
     2833          WinSendMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID);
     2834        if (hwndParent && !ParentIsDesktop(hwnd, hwndParent))
     2835          WinDestroyWindow(hwndParent);
    32492836      }
    32502837      else
    3251         WinSendMsg(hwnd,UM_CLOSE,MPFROMLONG(1L),MPVOID);
    3252       return 0;
    3253 
    3254     case WM_DESTROY:
    3255       if(TreeCnrMenu)
    3256         WinDestroyWindow(TreeCnrMenu);
    3257       if(DirMenu)
    3258         WinDestroyWindow(DirMenu);
    3259       if(FileMenu)
    3260         WinDestroyWindow(FileMenu);
    3261       TreeCnrMenu = FileMenu = DirMenu = (HWND)0;
    3262       EmptyCnr(hwnd);
    3263       if(apphead) {
    3264 
    3265         APPNOTIFY *info,*next;
    3266 
    3267         info = apphead;
    3268         while(info) {
    3269           next = info->next;
    3270           free(info);
    3271           info = next;
    3272         }
    3273         apphead = apptail = NULL;
    3274       }
    3275       break;
     2838        WinDestroyWindow(WinQueryWindow(WinQueryWindow(hwnd, QW_PARENT),
     2839                                        QW_PARENT));
     2840    }
     2841    return 0;
     2842
     2843  case WM_CLOSE:
     2844    WinSendMsg(hwnd, WM_SAVEAPPLICATION, MPVOID, MPVOID);
     2845    if (dcd)
     2846      dcd->stopflag++;
     2847    if (dcd && dcd->hwndObject) {
     2848      /* kill object window */
     2849      if (!PostMsg(dcd->hwndObject, WM_CLOSE, MPVOID, MPVOID))
     2850        WinSendMsg(dcd->hwndObject, WM_CLOSE, MPVOID, MPVOID);
     2851    }
     2852    else
     2853      WinSendMsg(hwnd, UM_CLOSE, MPFROMLONG(1L), MPVOID);
     2854    return 0;
     2855
     2856  case WM_DESTROY:
     2857    if (TreeCnrMenu)
     2858      WinDestroyWindow(TreeCnrMenu);
     2859    if (DirMenu)
     2860      WinDestroyWindow(DirMenu);
     2861    if (FileMenu)
     2862      WinDestroyWindow(FileMenu);
     2863    TreeCnrMenu = FileMenu = DirMenu = (HWND) 0;
     2864    EmptyCnr(hwnd);
     2865    if (apphead) {
     2866
     2867      APPNOTIFY *info, *next;
     2868
     2869      info = apphead;
     2870      while (info) {
     2871        next = info->next;
     2872        free(info);
     2873        info = next;
     2874      }
     2875      apphead = apptail = NULL;
     2876    }
     2877    break;
    32762878  }
    3277   return (dcd && dcd->oldproc) ? dcd->oldproc(hwnd,msg,mp1,mp2) :
    3278                                  PFNWPCnr(hwnd,msg,mp1,mp2);
     2879  return (dcd && dcd->oldproc) ? dcd->oldproc(hwnd, msg, mp1, mp2) :
     2880    PFNWPCnr(hwnd, msg, mp1, mp2);
    32792881}
    32802882
    3281 
    3282 HWND StartTreeCnr (HWND hwndParent,ULONG flags)
     2883HWND StartTreeCnr(HWND hwndParent, ULONG flags)
    32832884{
    32842885  /* bitmapped flags:
    … …  
    32872888   */
    32882889
    3289   HWND          hwndFrame = (HWND)0,hwndClient;
    3290   ULONG         FrameFlags = FCF_TITLEBAR   | FCF_SYSMENU     |
    3291                              FCF_SIZEBORDER | FCF_MINMAX      |
    3292                              FCF_ICON       | FCF_NOBYTEALIGN |
    3293                              FCF_ACCELTABLE;
    3294   DIRCNRDATA   *dcd;
    3295 
    3296   if(!hwndParent)
     2890  HWND hwndFrame = (HWND) 0, hwndClient;
     2891  ULONG FrameFlags = FCF_TITLEBAR | FCF_SYSMENU |
     2892    FCF_SIZEBORDER | FCF_MINMAX | FCF_ICON | FCF_NOBYTEALIGN | FCF_ACCELTABLE;
     2893  DIRCNRDATA *dcd;
     2894
     2895  if (!hwndParent)
    32972896    hwndParent = HWND_DESKTOP;
    3298   if(ParentIsDesktop(hwndParent,hwndParent))
     2897  if (ParentIsDesktop(hwndParent, hwndParent))
    32992898    FrameFlags |= (FCF_TASKLIST | FCF_MENU);
    3300   if(flags & 2)
     2899  if (flags & 2)
    33012900    FrameFlags &= (~(FCF_TITLEBAR | FCF_SYSMENU | FCF_SIZEBORDER |
    3302                      FCF_MINMAX   | FCF_ICON));
     2901                     FCF_MINMAX | FCF_ICON));
    33032902  hwndFrame = WinCreateStdWindow(hwndParent,
    33042903                                 WS_VISIBLE,
    … …  
    33072906                                 NULL,
    33082907                                 WS_VISIBLE | fwsAnimate,
    3309                                  FM3ModHandle,
    3310                                  TREE_FRAME,
    3311                                  &hwndClient);
    3312   if(hwndFrame && hwndClient) {
     2908                                 FM3ModHandle, TREE_FRAME, &hwndClient);
     2909  if (hwndFrame && hwndClient) {
    33132910    dcd = xmalloc(sizeof(DIRCNRDATA), pszSrcFile, __LINE__);
    33142911    if (!dcd) {
    3315       Runtime_Error(pszSrcFile,__LINE__,GetPString(IDS_OUTOFMEMORY));
    3316       PostMsg(hwndClient,WM_CLOSE,MPVOID,MPVOID);
    3317       hwndFrame = (HWND)0;
     2912      Runtime_Error(pszSrcFile, __LINE__, GetPString(IDS_OUTOFMEMORY));
     2913      PostMsg(hwndClient, WM_CLOSE, MPVOID, MPVOID);
     2914      hwndFrame = (HWND) 0;
    33182915    }
    33192916    else {
    33202917      SWP swp;
    3321       WinQueryWindowPos(hwndFrame,&swp);
    3322       if (*(ULONG *)realappname == FM3UL) {
     2918
     2919      WinQueryWindowPos(hwndFrame, &swp);
     2920      if (*(ULONG *) realappname == FM3UL) {
    33232921        if (!WinCreateWindow(hwndFrame,
    3324                         GetPString(IDS_WCTREEOPENBUTTON),
    3325                         "O",
    3326                         WS_VISIBLE | BS_PUSHBUTTON | BS_NOPOINTERFOCUS,
    3327                         ((swp.cx - WinQuerySysValue(HWND_DESKTOP,SV_CXMINMAXBUTTON)) -
    3328                          WinQuerySysValue(HWND_DESKTOP,SV_CXMINMAXBUTTON) / 2) -
    3329                          WinQuerySysValue(HWND_DESKTOP,SV_CXSIZEBORDER),
    3330                         (swp.cy - WinQuerySysValue(HWND_DESKTOP,SV_CYMINMAXBUTTON)) -
    3331                          WinQuerySysValue(HWND_DESKTOP,SV_CYSIZEBORDER),
    3332                         WinQuerySysValue(HWND_DESKTOP,SV_CXMINMAXBUTTON) / 2,
    3333                         WinQuerySysValue(HWND_DESKTOP,SV_CYMINMAXBUTTON),
    3334                         hwndFrame,
    3335                         HWND_TOP,
    3336                         IDM_OPENWINDOW,
    3337                         NULL,
    3338                         NULL))
    3339         {
    3340           Win_Error2(hwndFrame,hwndParent,pszSrcFile,__LINE__,IDS_WINCREATEWINDOW);
     2922                             GetPString(IDS_WCTREEOPENBUTTON),
     2923                             "O",
     2924                             WS_VISIBLE | BS_PUSHBUTTON | BS_NOPOINTERFOCUS,
     2925                             ((swp.cx -
     2926                               WinQuerySysValue(HWND_DESKTOP,
     2927                                                SV_CXMINMAXBUTTON)) -
     2928                              WinQuerySysValue(HWND_DESKTOP,
     2929                                               SV_CXMINMAXBUTTON) / 2) -
     2930                             WinQuerySysValue(HWND_DESKTOP, SV_CXSIZEBORDER),
     2931                             (swp.cy -
     2932                              WinQuerySysValue(HWND_DESKTOP,
     2933                                               SV_CYMINMAXBUTTON)) -
     2934                             WinQuerySysValue(HWND_DESKTOP, SV_CYSIZEBORDER),
     2935                             WinQuerySysValue(HWND_DESKTOP,
     2936                                              SV_CXMINMAXBUTTON) / 2,
     2937                             WinQuerySysValue(HWND_DESKTOP,
     2938                                              SV_CYMINMAXBUTTON), hwndFrame,
     2939                             HWND_TOP, IDM_OPENWINDOW, NULL, NULL)) {
     2940          Win_Error2(hwndFrame, hwndParent, pszSrcFile, __LINE__,
     2941                     IDS_WINCREATEWINDOW);
    33412942        }
    33422943      }
    33432944      else {
    33442945        if (!WinCreateWindow(hwndFrame,
    3345                         GetPString(IDS_WCTREESTATUS),
    3346                         GetPString(IDS_YOUAREHERETEXT),
    3347                         WS_VISIBLE | SS_TEXT | DT_LEFT | DT_VCENTER,
    3348                         swp.x + 4 + WinQuerySysValue(HWND_DESKTOP,
    3349                                                      SV_CXSIZEBORDER),
    3350                         swp.cy - (22 + WinQuerySysValue(HWND_DESKTOP,
    3351                                                         SV_CYSIZEBORDER)),
    3352                         (swp.cx  - 8) - (WinQuerySysValue(HWND_DESKTOP,
    3353                                               SV_CXSIZEBORDER) * 2),
    3354                         22,
    3355                         hwndFrame,
    3356                         HWND_TOP,
    3357                         MAIN_STATUS,
    3358                         NULL,
    3359                         NULL))
    3360         {
    3361           Win_Error2(hwndFrame,hwndParent,pszSrcFile,__LINE__,IDS_WINCREATEWINDOW);
    3362         }
    3363       }
    3364       memset(dcd,0,sizeof(DIRCNRDATA));
     2946                             GetPString(IDS_WCTREESTATUS),
     2947                             GetPString(IDS_YOUAREHERETEXT),
     2948                             WS_VISIBLE | SS_TEXT | DT_LEFT | DT_VCENTER,
     2949                             swp.x + 4 + WinQuerySysValue(HWND_DESKTOP,
     2950                                                          SV_CXSIZEBORDER),
     2951                             swp.cy - (22 + WinQuerySysValue(HWND_DESKTOP,
     2952                                                             SV_CYSIZEBORDER)),
     2953                             (swp.cx - 8) - (WinQuerySysValue(HWND_DESKTOP,
     2954                                                              SV_CXSIZEBORDER)
     2955                                             * 2), 22, hwndFrame, HWND_TOP,
     2956                             MAIN_STATUS, NULL, NULL)) {
     2957          Win_Error2(hwndFrame, hwndParent, pszSrcFile, __LINE__,
     2958                     IDS_WINCREATEWINDOW);
     2959        }
     2960      }
     2961      memset(dcd, 0, sizeof(DIRCNRDATA));
    33652962      dcd->size = sizeof(DIRCNRDATA);
    33662963      dcd->type = TREE_FRAME;
    … …  
    33682965      dcd->hwndParent = (hwndParent) ? hwndParent : HWND_DESKTOP;
    33692966      dcd->hwndClient = hwndClient;
    3370       dcd->hwndFrame  = hwndFrame;
     2967      dcd->hwndFrame = hwndFrame;
    33712968      {
    33722969        PFNWP oldproc;
    33732970
    3374         oldproc = WinSubclassWindow(hwndFrame,TreeFrameWndProc);
    3375         WinSetWindowPtr(hwndFrame,QWL_USER,(PVOID)oldproc);
    3376         oldproc = WinSubclassWindow(WinWindowFromID(hwndFrame,FID_TITLEBAR),
    3377                                     (PFNWP)TreeTitleWndProc);
    3378         WinSetWindowPtr(WinWindowFromID(hwndFrame,FID_TITLEBAR),
    3379                         QWL_USER,
    3380                         (PVOID)oldproc);
     2971        oldproc = WinSubclassWindow(hwndFrame, TreeFrameWndProc);
     2972        WinSetWindowPtr(hwndFrame, QWL_USER, (PVOID) oldproc);
     2973        oldproc = WinSubclassWindow(WinWindowFromID(hwndFrame, FID_TITLEBAR),
     2974                                    (PFNWP) TreeTitleWndProc);
     2975        WinSetWindowPtr(WinWindowFromID(hwndFrame, FID_TITLEBAR),
     2976                        QWL_USER, (PVOID) oldproc);
    33812977      }
    33822978      dcd->hwndCnr = WinCreateWindow(hwndClient,
    … …  
    33902986                                     0,
    33912987                                     hwndClient,
    3392                                      HWND_TOP,
    3393                                      (ULONG)TREE_CNR,
    3394                                      NULL,
    3395                                      NULL);
     2988                                     HWND_TOP, (ULONG) TREE_CNR, NULL, NULL);
    33962989      if (!dcd->hwndCnr) {
    3397         Win_Error2(hwndClient,hwndClient,pszSrcFile,__LINE__,IDS_WINCREATEWINDOW);
    3398         PostMsg(hwndClient,WM_CLOSE,MPVOID,MPVOID);
     2990        Win_Error2(hwndClient, hwndClient, pszSrcFile, __LINE__,
     2991                   IDS_WINCREATEWINDOW);
     2992        PostMsg(hwndClient, WM_CLOSE, MPVOID, MPVOID);
    33992993        free(dcd);
    3400         hwndFrame = (HWND)0;
     2994        hwndFrame = (HWND) 0;
    34012995      }
    34022996      else {
    3403         WinSetWindowPtr(dcd->hwndCnr,QWL_USER,(PVOID)dcd);
    3404         if(ParentIsDesktop(hwndFrame,hwndParent)) {
    3405           WinSetWindowText(WinWindowFromID(hwndFrame,FID_TITLEBAR),"VTree");
    3406           FixSwitchList(hwndFrame,"VTree");
     2997        WinSetWindowPtr(dcd->hwndCnr, QWL_USER, (PVOID) dcd);
     2998        if (ParentIsDesktop(hwndFrame, hwndParent)) {
     2999          WinSetWindowText(WinWindowFromID(hwndFrame, FID_TITLEBAR), "VTree");
     3000          FixSwitchList(hwndFrame, "VTree");
    34073001        }
    34083002        else {
    3409           WinSetWindowText(hwndFrame,GetPString(IDS_TREETEXT));
    3410           WinSetWindowText(WinWindowFromID(hwndFrame,FID_TITLEBAR),
     3003          WinSetWindowText(hwndFrame, GetPString(IDS_TREETEXT));
     3004          WinSetWindowText(WinWindowFromID(hwndFrame, FID_TITLEBAR),
    34113005                           GetPString(IDS_TREETEXT));
    34123006        }
    3413         dcd->oldproc = WinSubclassWindow(dcd->hwndCnr,TreeCnrWndProc);
    3414         if(!PostMsg(dcd->hwndCnr,UM_SETUP,MPVOID,MPVOID))
    3415           WinSendMsg(dcd->hwndCnr,UM_SETUP,MPVOID,MPVOID);
     3007        dcd->oldproc = WinSubclassWindow(dcd->hwndCnr, TreeCnrWndProc);
     3008        if (!PostMsg(dcd->hwndCnr, UM_SETUP, MPVOID, MPVOID))
     3009          WinSendMsg(dcd->hwndCnr, UM_SETUP, MPVOID, MPVOID);
    34163010      }
    34173011    }
    … …  
    34193013  return hwndFrame;
    34203014}
    3421 
Note: See TracChangeset for help on using the changeset viewer.