Changeset 551 for trunk/dll/dircnrs.c


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

Indentation cleanup

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/dll/dircnrs.c

    r449 r551  
    4848static PSZ pszSrcFile = __FILE__;
    4949
    50 MRESULT EXPENTRY DirFrameWndProc (HWND hwnd,ULONG msg,MPARAM mp1,MPARAM mp2)
     50MRESULT EXPENTRY DirFrameWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
    5151{
    52   return CommonFrameWndProc(DIR_CNR,hwnd,msg,mp1,mp2);
     52  return CommonFrameWndProc(DIR_CNR, hwnd, msg, mp1, mp2);
    5353}
    5454
    55 
    56 MRESULT EXPENTRY DirTextProc (HWND hwnd,ULONG msg,MPARAM mp1,MPARAM mp2)
     55MRESULT EXPENTRY DirTextProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
    5756{
    58   static BOOL   emphasized      = FALSE;
    59   static HWND   hwndButtonPopup = (HWND)0;
    60   static USHORT lastid          = 0;
    61   static ULONG  timestamp       = ULONG_MAX;
    62 
    63   switch(msg) {
    64     case WM_CREATE:
    65       return CommonTextProc(hwnd,msg,mp1,mp2);
    66 
    67     case WM_COMMAND:
     57  static BOOL emphasized = FALSE;
     58  static HWND hwndButtonPopup = (HWND) 0;
     59  static USHORT lastid = 0;
     60  static ULONG timestamp = ULONG_MAX;
     61
     62  switch (msg) {
     63  case WM_CREATE:
     64    return CommonTextProc(hwnd, msg, mp1, mp2);
     65
     66  case WM_COMMAND:
     67    {
     68      DIRCNRDATA *dcd;
     69      MRESULT mr;
     70
     71      mr = WinSendMsg(WinWindowFromID(WinQueryWindow(hwnd,
     72                                                     QW_PARENT),
     73                                      DIR_CNR), msg, mp1, mp2);
     74      if (hwndButtonPopup &&
     75          SHORT1FROMMP(mp1) > IDM_DETAILSTITLES &&
     76          SHORT1FROMMP(mp1) < IDM_DETAILSSETUP) {
     77        dcd = WinQueryWindowPtr(WinWindowFromID(WinQueryWindow(hwnd,
     78                                                               QW_PARENT),
     79                                                DIR_CNR), QWL_USER);
     80        if (dcd)
     81          SetDetailsSwitches(hwndButtonPopup, dcd);
     82      }
     83      return mr;
     84    }
     85
     86  case UM_CONTEXTMENU:
     87  case WM_CONTEXTMENU:
     88    {
     89      USHORT id;
     90
     91      id = WinQueryWindowUShort(hwnd, QWS_ID);
     92      switch (id) {
     93      case DIR_FOLDERICON:
     94        if (fNoFoldMenu) {
     95          PostMsg(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
     96                                  DIR_CNR),
     97                  WM_COMMAND, MPFROM2SHORT(IDM_PREVIOUS, 0), mp2);
     98          break;
     99        }
     100        /* else intentional fallthru */
     101      case DIR_SELECTED:
     102      case DIR_VIEW:
     103      case DIR_SORT:
     104        {
     105          POINTL ptl = { 0, 0 };
     106          SWP swp;
     107          DIRCNRDATA *dcd;
     108
     109          if (hwndButtonPopup)
     110            WinDestroyWindow(hwndButtonPopup);
     111          if (id == DIR_SELECTED && msg == WM_CONTEXTMENU)
     112            id = DIR_MAX;
     113          if (id == lastid) {
     114
     115            ULONG check;
     116
     117            DosQuerySysInfo(QSV_MS_COUNT,
     118                            QSV_MS_COUNT, &check, sizeof(check));
     119            if (check < timestamp + 500) {
     120              lastid = 0;
     121              goto MenuAbort;
     122            }
     123          }
     124          hwndButtonPopup = WinLoadMenu(HWND_DESKTOP, FM3ModHandle, id);
     125          if (hwndButtonPopup) {
     126            WinSetWindowUShort(hwndButtonPopup, QWS_ID, id);
     127            dcd = WinQueryWindowPtr(WinWindowFromID(WinQueryWindow(hwnd,
     128                                                                   QW_PARENT),
     129                                                    DIR_CNR), QWL_USER);
     130            if (id == DIR_SORT) {       /* don't have sort pathname in dirs */
     131              WinSendMsg(hwndButtonPopup,
     132                         MM_DELETEITEM,
     133                         MPFROM2SHORT(IDM_SORTNAME, FALSE), MPVOID);
     134              WinSendMsg(hwndButtonPopup,
     135                         MM_DELETEITEM,
     136                         MPFROM2SHORT(IDM_SORTNONE, FALSE), MPVOID);
     137              if (dcd)
     138                SetSortChecks(hwndButtonPopup, dcd->sortFlags);
     139            }
     140            else if (id == DIR_VIEW) {
     141              if (dcd) {
     142                SetViewMenu(hwndButtonPopup, dcd->flWindowAttr);
     143                SetDetailsSwitches(hwndButtonPopup, dcd);
     144              }
     145            }
     146            else if (id == DIR_MAX) {
     147
     148              int x;
     149              BOOL enable;
     150              USHORT ids[] = { IDM_SELECTBOTH,
     151                IDM_SELECTMORE,
     152                IDM_SELECTONE,
     153                IDM_SELECTNEWER,
     154                IDM_SELECTOLDER,
     155                IDM_SELECTBIGGER,
     156                IDM_SELECTSMALLER,
     157                IDM_DESELECTBOTH,
     158                IDM_DESELECTMORE,
     159                IDM_DESELECTONE,
     160                IDM_DESELECTNEWER,
     161                IDM_DESELECTOLDER,
     162                IDM_DESELECTBIGGER,
     163                IDM_DESELECTSMALLER,
     164                0
     165              };
     166
     167              enable = (CountDirCnrs(dcd->hwndParent) > 1);
     168              for (x = 0; ids[x]; x++)
     169                WinEnableMenuItem(hwndButtonPopup, ids[x], enable);
     170            }
     171            else if (id == DIR_SELECTED) {
     172              if (dcd)
     173                WinEnableMenuItem(hwndButtonPopup,
     174                                  IDM_RESELECT, (dcd->lastselection != NULL));
     175            }
     176            ptl.x = 0;
     177            if (WinPopupMenu(HWND_OBJECT,
     178                             HWND_OBJECT,
     179                             hwndButtonPopup, -32767, -32767, 0, 0)) {
     180              WinQueryWindowPos(hwndButtonPopup, &swp);
     181              ptl.y = -(swp.cy + 2);
     182            }
     183            else {
     184              WinQueryWindowPos(hwnd, &swp);
     185              ptl.y = swp.cy + 2;
     186            }
     187            if (WinPopupMenu(hwnd,
     188                             hwnd,
     189                             hwndButtonPopup,
     190                             ptl.x,
     191                             ptl.y,
     192                             0,
     193                             PU_HCONSTRAIN | PU_VCONSTRAIN |
     194                             PU_KEYBOARD | PU_MOUSEBUTTON1)) {
     195              CenterOverWindow(hwndButtonPopup);
     196              PaintRecessedWindow(hwnd, (HPS) 0, FALSE, FALSE);
     197            }
     198          }
     199        }
     200        break;
     201      default:
     202        PostMsg(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT), DIR_CNR),
     203                WM_CONTROL, MPFROM2SHORT(DIR_CNR, CN_CONTEXTMENU), MPVOID);
     204        break;
     205      }
     206    }                                   // case WM_CONTENT_MENU
     207
     208  MenuAbort:
     209
     210    if (msg == UM_CONTEXTMENU)
     211      return 0;
     212    break;
     213
     214  case WM_MENUEND:
     215    if (hwndButtonPopup == (HWND) mp2) {
     216      lastid = WinQueryWindowUShort((HWND) mp2, QWS_ID);
     217      WinDestroyWindow(hwndButtonPopup);
     218      hwndButtonPopup = (HWND) 0;
     219      DosQuerySysInfo(QSV_MS_COUNT,
     220                      QSV_MS_COUNT, &timestamp, sizeof(timestamp));
     221      switch (lastid) {
     222      case DIR_VIEW:
     223      case DIR_SORT:
     224      case DIR_FOLDERICON:
     225      case DIR_SELECTED:
     226      case DIR_MAX:
     227        PaintRecessedWindow(hwnd, (HPS) 0, TRUE, FALSE);
     228        break;
     229      }
     230    }
     231    break;
     232
     233  case WM_BUTTON3DOWN:
     234  case WM_BUTTON1DOWN:
     235  case WM_BUTTON3UP:
     236  case WM_BUTTON1UP:
     237    {
     238      USHORT id;
     239
     240      id = WinQueryWindowUShort(hwnd, QWS_ID);
     241      switch (id) {
     242      case DIR_FILTER:
     243      case DIR_VIEW:
     244      case DIR_SORT:
     245      case DIR_SELECTED:
     246      case DIR_FOLDERICON:
     247      case DIR_MAX:
     248        return CommonTextButton(hwnd, msg, mp1, mp2);
     249      }
     250    }
     251    break;
     252
     253  case WM_BUTTON1DBLCLK:
     254    {
     255      NOTIFYRECORDENTER nr;
     256
     257      memset(&nr, 0, sizeof(NOTIFYRECORDENTER));
     258      nr.hwndCnr = WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT), DIR_CNR);
     259      WinSendMsg(WinQueryWindow(hwnd, QW_PARENT),
     260                 WM_CONTROL, MPFROM2SHORT(DIR_CNR, CN_ENTER), MPFROMP(&nr));
     261    }
     262    break;
     263
     264  case WM_MOUSEMOVE:
     265    {
     266      USHORT id = WinQueryWindowUShort(hwnd, QWS_ID);
     267      char *s = NULL;
     268
     269      if (fOtherHelp) {
     270        if ((!hwndBubble ||
     271             WinQueryWindowULong(hwndBubble, QWL_USER) != hwnd) &&
     272            !WinQueryCapture(HWND_DESKTOP)) {
     273          switch (id) {
     274          case DIR_TOTALS:
     275            s = GetPString(IDS_DIRCNRTOTALHELP);
     276            break;
     277          case DIR_SELECTED:
     278            s = GetPString(IDS_DIRCNRSELECTEDHELP);
     279            break;
     280          case DIR_VIEW:
     281            s = GetPString(IDS_DIRCNRVIEWHELP);
     282            break;
     283          case DIR_SORT:
     284            s = GetPString(IDS_DIRCNRSORTHELP);
     285            break;
     286          case DIR_FILTER:
     287            s = GetPString(IDS_DIRCNRFILTERHELP);
     288            break;
     289          case DIR_MAX:
     290            s = GetPString(IDS_DIRCNRMAXHELP);
     291            break;
     292          case DIR_FOLDERICON:
     293            s = GetPString(IDS_DIRCNRFOLDERHELP);
     294            break;
     295          default:
     296            break;
     297          }
     298          if (s)
     299            MakeBubble(hwnd, TRUE, s);
     300          else if (hwndBubble)
     301            WinDestroyWindow(hwndBubble);
     302        }
     303      }
     304      switch (id) {
     305      case DIR_MAX:
     306      case DIR_FOLDERICON:
     307      case DIR_FILTER:
     308      case DIR_SORT:
     309      case DIR_VIEW:
     310      case DIR_SELECTED:
     311        return CommonTextButton(hwnd, msg, mp1, mp2);
     312      }
     313    }
     314    break;
     315
     316  case WM_CHORD:
     317  case WM_BUTTON3CLICK:
     318  case WM_BUTTON1CLICK:
     319  case UM_CLICKED:
     320  case UM_CLICKED3:
     321    {
     322      USHORT id, cmd = 0;
     323
     324      id = WinQueryWindowUShort(hwnd, QWS_ID);
     325      if (msg == UM_CLICKED || msg == UM_CLICKED3) {
     326        switch (id) {
     327        case DIR_MAX:
     328          cmd = IDM_MAXIMIZE;
     329          break;
     330        case DIR_VIEW:
     331        case DIR_SELECTED:
     332        case DIR_SORT:
     333          PostMsg(hwnd, UM_CONTEXTMENU, MPVOID, MPVOID);
     334          break;
     335        case DIR_FILTER:
     336          cmd = IDM_FILTER;
     337          break;
     338        default:
     339          break;
     340        }
     341      }
     342      else if (id == DIR_FOLDERICON) {
     343        if ((msg == WM_BUTTON1CLICK && (SHORT2FROMMP(mp2) & KC_CTRL)))
     344          cmd = IDM_PREVIOUS;
     345        else if (msg == WM_BUTTON3CLICK || msg == WM_CHORD)
     346          cmd = IDM_RESCAN;
     347        else if (msg == WM_BUTTON1CLICK && (SHORT2FROMMP(mp2) & KC_SHIFT))
     348          cmd = IDM_WALKDIR;
     349        else if (msg == WM_BUTTON1CLICK && (SHORT2FROMMP(mp2) & KC_ALT))
     350          cmd = IDM_WINDOWDLG;
     351        else
     352          cmd = IDM_PARENT;
     353      }
     354      if (cmd)
     355        PostMsg(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
     356                                DIR_CNR),
     357                WM_COMMAND, MPFROM2SHORT(cmd, 0), MPVOID);
     358    }
     359    if (msg == UM_CLICKED || msg == UM_CLICKED3)
     360      return 0;
     361    break;
     362
     363  case DM_DROP:
     364  case DM_DRAGOVER:
     365  case DM_DRAGLEAVE:
     366  case DM_DROPHELP:
     367  case WM_BEGINDRAG:
     368    if (msg == DM_DRAGOVER) {
     369      if (!emphasized) {
     370        emphasized = TRUE;
     371        DrawTargetEmphasis(hwnd, emphasized);
     372      }
     373    }
     374    else if (msg != WM_BEGINDRAG) {
     375      if (emphasized) {
     376        emphasized = FALSE;
     377        DrawTargetEmphasis(hwnd, emphasized);
     378      }
     379    }
     380    switch (WinQueryWindowUShort(hwnd, QWS_ID)) {
     381    case DIR_FOLDERICON:
     382      switch (msg) {
     383      case DM_DRAGOVER:
     384        if (AcceptOneDrop(mp1, mp2))
     385          return MRFROM2SHORT(DOR_DROP, DO_MOVE);
     386        return (MRFROM2SHORT(DOR_NODROP, 0));   /* Drop not valid        */
     387      case DM_DROPHELP:
     388        DropHelp(mp1, mp2, hwnd, GetPString(IDS_DIRCNRFOLDERDROPHELP));
     389        return 0;
     390      case DM_DROP:
     391        {
     392          char szFrom[CCHMAXPATH + 2];
     393
     394          if (emphasized) {
     395            emphasized = FALSE;
     396            DrawTargetEmphasis(hwnd, emphasized);
     397          }
     398          if (GetOneDrop(mp1, mp2, szFrom, sizeof(szFrom)))
     399            WinSendMsg(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
     400                                       DIR_CNR),
     401                       WM_COMMAND, MPFROM2SHORT(IDM_SWITCH, 0),
     402                       MPFROMP(szFrom));
     403        }
     404        return 0;
     405      default:
     406        return PFNWPStatic(hwnd, msg, mp1, mp2);
     407      }
     408    case DIR_MAX:
     409      if (msg == WM_BEGINDRAG)
     410        return PFNWPStatic(hwnd, msg, mp1, mp2);
     411    default:
    68412      {
    69         DIRCNRDATA *dcd;
    70         MRESULT     mr;
    71 
    72         mr = WinSendMsg(WinWindowFromID(WinQueryWindow(hwnd,
    73                                                        QW_PARENT),
    74                         DIR_CNR),
    75                         msg,
    76                         mp1,
    77                         mp2);
    78         if(hwndButtonPopup &&
    79            SHORT1FROMMP(mp1) > IDM_DETAILSTITLES &&
    80            SHORT1FROMMP(mp1) < IDM_DETAILSSETUP) {
    81           dcd = WinQueryWindowPtr(WinWindowFromID(WinQueryWindow(hwnd,
    82                                                   QW_PARENT),
    83                                                   DIR_CNR),
    84                                   QWL_USER);
    85           if(dcd)
    86             SetDetailsSwitches(hwndButtonPopup,
    87                                dcd);
    88         }
    89         return mr;
    90       }
    91 
    92     case UM_CONTEXTMENU:
    93     case WM_CONTEXTMENU:
    94       {
    95         USHORT id;
    96 
    97         id = WinQueryWindowUShort(hwnd,QWS_ID);
    98         switch(id) {
    99           case DIR_FOLDERICON:
    100             if(fNoFoldMenu) {
    101               PostMsg(WinWindowFromID(WinQueryWindow(hwnd,QW_PARENT),
    102                                       DIR_CNR),
    103                       WM_COMMAND,
    104                       MPFROM2SHORT(IDM_PREVIOUS,0),
    105                       mp2);
    106               break;
    107             }
    108             /* else intentional fallthru */
    109           case DIR_SELECTED:
    110           case DIR_VIEW:
    111           case DIR_SORT:
    112             {
    113               POINTL      ptl = {0,0};
    114               SWP         swp;
    115               DIRCNRDATA *dcd;
    116 
    117               if(hwndButtonPopup)
    118                 WinDestroyWindow(hwndButtonPopup);
    119               if(id == DIR_SELECTED && msg == WM_CONTEXTMENU)
    120                 id = DIR_MAX;
    121               if(id == lastid) {
    122 
    123                 ULONG check;
    124 
    125                 DosQuerySysInfo(QSV_MS_COUNT,
    126                                 QSV_MS_COUNT,
    127                                 &check,
    128                                 sizeof(check));
    129                 if(check < timestamp + 500) {
    130                   lastid = 0;
    131                   goto MenuAbort;
    132                 }
    133               }
    134               hwndButtonPopup = WinLoadMenu(HWND_DESKTOP,
    135                                             FM3ModHandle,
    136                                             id);
    137               if(hwndButtonPopup) {
    138                 WinSetWindowUShort(hwndButtonPopup,
    139                                    QWS_ID,
    140                                    id);
    141                 dcd = WinQueryWindowPtr(WinWindowFromID(WinQueryWindow(hwnd,
    142                                                         QW_PARENT),
    143                                                         DIR_CNR),
    144                                         QWL_USER);
    145                 if(id == DIR_SORT) { /* don't have sort pathname in dirs */
    146                   WinSendMsg(hwndButtonPopup,
    147                              MM_DELETEITEM,
    148                              MPFROM2SHORT(IDM_SORTNAME,
    149                                           FALSE),
    150                              MPVOID);
    151                   WinSendMsg(hwndButtonPopup,
    152                              MM_DELETEITEM,
    153                              MPFROM2SHORT(IDM_SORTNONE,
    154                                           FALSE),
    155                              MPVOID);
    156                   if(dcd)
    157                     SetSortChecks(hwndButtonPopup,
    158                                   dcd->sortFlags);
    159                 }
    160                 else if(id == DIR_VIEW) {
    161                   if(dcd) {
    162                     SetViewMenu(hwndButtonPopup,
    163                                 dcd->flWindowAttr);
    164                     SetDetailsSwitches(hwndButtonPopup,
    165                                        dcd);
    166                   }
    167                 }
    168                 else if(id == DIR_MAX) {
    169 
    170                   int    x;
    171                   BOOL   enable;
    172                   USHORT ids[] = {IDM_SELECTBOTH,
    173                                   IDM_SELECTMORE,
    174                                   IDM_SELECTONE,
    175                                   IDM_SELECTNEWER,
    176                                   IDM_SELECTOLDER,
    177                                   IDM_SELECTBIGGER,
    178                                   IDM_SELECTSMALLER,
    179                                   IDM_DESELECTBOTH,
    180                                   IDM_DESELECTMORE,
    181                                   IDM_DESELECTONE,
    182                                   IDM_DESELECTNEWER,
    183                                   IDM_DESELECTOLDER,
    184                                   IDM_DESELECTBIGGER,
    185                                   IDM_DESELECTSMALLER,
    186                                   0};
    187 
    188                   enable = (CountDirCnrs(dcd->hwndParent) > 1);
    189                   for(x = 0;ids[x];x++)
    190                     WinEnableMenuItem(hwndButtonPopup,
    191                                       ids[x],
    192                                       enable);
    193                 }
    194                 else if(id == DIR_SELECTED) {
    195                   if(dcd)
    196                     WinEnableMenuItem(hwndButtonPopup,
    197                                       IDM_RESELECT,
    198                                       (dcd->lastselection != NULL));
    199                 }
    200                 ptl.x = 0;
    201                 if(WinPopupMenu(HWND_OBJECT,
    202                                 HWND_OBJECT,
    203                                 hwndButtonPopup,
    204                                 -32767,
    205                                 -32767,
    206                                 0,
    207                                 0)) {
    208                   WinQueryWindowPos(hwndButtonPopup,
    209                                     &swp);
    210                   ptl.y = -(swp.cy + 2);
    211                 }
    212                 else {
    213                   WinQueryWindowPos(hwnd,
    214                                     &swp);
    215                   ptl.y = swp.cy + 2;
    216                 }
    217                 if(WinPopupMenu(hwnd,
    218                                 hwnd,
    219                                 hwndButtonPopup,
    220                                 ptl.x,
    221                                 ptl.y,
    222                                 0,
    223                                 PU_HCONSTRAIN | PU_VCONSTRAIN |
    224                                 PU_KEYBOARD   | PU_MOUSEBUTTON1)) {
    225                   CenterOverWindow(hwndButtonPopup);
    226                   PaintRecessedWindow(hwnd,
    227                                       (HPS)0,
    228                                       FALSE,
    229                                       FALSE);
    230                 }
    231               }
    232             }
    233             break;
    234           default:
    235             PostMsg(WinWindowFromID(WinQueryWindow(hwnd,QW_PARENT),DIR_CNR),
    236                     WM_CONTROL,
    237                     MPFROM2SHORT(DIR_CNR,CN_CONTEXTMENU),
    238                     MPVOID);
    239             break;
    240         }
    241       } // case WM_CONTENT_MENU
    242 
    243 MenuAbort:
    244 
    245       if(msg == UM_CONTEXTMENU)
    246         return 0;
    247       break;
    248 
    249     case WM_MENUEND:
    250       if(hwndButtonPopup == (HWND)mp2) {
    251         lastid = WinQueryWindowUShort((HWND)mp2,QWS_ID);
    252         WinDestroyWindow(hwndButtonPopup);
    253         hwndButtonPopup = (HWND)0;
    254         DosQuerySysInfo(QSV_MS_COUNT,
    255                         QSV_MS_COUNT,
    256                         &timestamp,
    257                         sizeof(timestamp));
    258         switch(lastid) {
    259           case DIR_VIEW:
    260           case DIR_SORT:
    261           case DIR_FOLDERICON:
    262           case DIR_SELECTED:
    263           case DIR_MAX:
    264             PaintRecessedWindow(hwnd,(HPS)0,TRUE,FALSE);
    265             break;
    266         }
    267       }
    268       break;
    269 
    270     case WM_BUTTON3DOWN:
    271     case WM_BUTTON1DOWN:
    272     case WM_BUTTON3UP:
    273     case WM_BUTTON1UP:
    274       {
    275         USHORT id;
    276 
    277         id = WinQueryWindowUShort(hwnd,QWS_ID);
    278         switch(id) {
    279           case DIR_FILTER:
    280           case DIR_VIEW:
    281           case DIR_SORT:
    282           case DIR_SELECTED:
    283           case DIR_FOLDERICON:
    284           case DIR_MAX:
    285             return CommonTextButton(hwnd,msg,mp1,mp2);
    286         }
    287       }
    288       break;
    289 
    290     case WM_BUTTON1DBLCLK:
    291       {
    292         NOTIFYRECORDENTER nr;
    293 
    294         memset(&nr,0,sizeof(NOTIFYRECORDENTER));
    295         nr.hwndCnr = WinWindowFromID(WinQueryWindow(hwnd,QW_PARENT),DIR_CNR);
    296         WinSendMsg(WinQueryWindow(hwnd,QW_PARENT),
    297                    WM_CONTROL,
    298                    MPFROM2SHORT(DIR_CNR,CN_ENTER),
    299                    MPFROMP(&nr));
    300       }
    301       break;
    302 
    303     case WM_MOUSEMOVE:
    304       {
    305         USHORT id   = WinQueryWindowUShort(hwnd,QWS_ID);
    306         char  *s    = NULL;
    307 
    308         if(fOtherHelp) {
    309           if((!hwndBubble ||
    310               WinQueryWindowULong(hwndBubble,QWL_USER) != hwnd) &&
    311              !WinQueryCapture(HWND_DESKTOP)) {
    312             switch(id) {
    313               case DIR_TOTALS:
    314                 s = GetPString(IDS_DIRCNRTOTALHELP);
    315                 break;
    316               case DIR_SELECTED:
    317                 s = GetPString(IDS_DIRCNRSELECTEDHELP);
    318                 break;
    319               case DIR_VIEW:
    320                 s = GetPString(IDS_DIRCNRVIEWHELP);
    321                 break;
    322               case DIR_SORT:
    323                 s = GetPString(IDS_DIRCNRSORTHELP);
    324                 break;
    325               case DIR_FILTER:
    326                 s = GetPString(IDS_DIRCNRFILTERHELP);
    327                 break;
    328               case DIR_MAX:
    329                 s = GetPString(IDS_DIRCNRMAXHELP);
    330                 break;
    331               case DIR_FOLDERICON:
    332                 s = GetPString(IDS_DIRCNRFOLDERHELP);
    333                 break;
    334               default:
    335                 break;
    336             }
    337             if(s)
    338               MakeBubble(hwnd,TRUE,s);
    339             else if(hwndBubble)
    340               WinDestroyWindow(hwndBubble);
    341           }
    342         }
    343         switch(id) {
    344           case DIR_MAX:
    345           case DIR_FOLDERICON:
    346           case DIR_FILTER:
    347           case DIR_SORT:
    348           case DIR_VIEW:
    349           case DIR_SELECTED:
    350             return CommonTextButton(hwnd,msg,mp1,mp2);
    351         }
    352       }
    353       break;
    354 
    355     case WM_CHORD:
    356     case WM_BUTTON3CLICK:
    357     case WM_BUTTON1CLICK:
    358     case UM_CLICKED:
    359     case UM_CLICKED3:
    360       {
    361         USHORT id,cmd = 0;
    362 
    363         id = WinQueryWindowUShort(hwnd,QWS_ID);
    364         if(msg == UM_CLICKED || msg == UM_CLICKED3) {
    365           switch(id) {
    366             case DIR_MAX:
    367               cmd = IDM_MAXIMIZE;
    368               break;
    369             case DIR_VIEW:
    370             case DIR_SELECTED:
    371             case DIR_SORT:
    372               PostMsg(hwnd,
    373                       UM_CONTEXTMENU,
    374                       MPVOID,
    375                       MPVOID);
    376               break;
    377             case DIR_FILTER:
    378               cmd = IDM_FILTER;
    379               break;
    380             default:
    381               break;
    382           }
    383         }
    384         else if(id == DIR_FOLDERICON) {
    385           if((msg == WM_BUTTON1CLICK && (SHORT2FROMMP(mp2) & KC_CTRL)))
    386             cmd = IDM_PREVIOUS;
    387           else if(msg == WM_BUTTON3CLICK || msg == WM_CHORD)
    388             cmd = IDM_RESCAN;
    389           else if(msg == WM_BUTTON1CLICK && (SHORT2FROMMP(mp2) & KC_SHIFT))
    390             cmd = IDM_WALKDIR;
    391           else if(msg == WM_BUTTON1CLICK && (SHORT2FROMMP(mp2) & KC_ALT))
    392             cmd = IDM_WINDOWDLG;
    393           else
    394             cmd = IDM_PARENT;
    395         }
    396         if(cmd)
    397           PostMsg(WinWindowFromID(WinQueryWindow(hwnd,QW_PARENT),
    398                                   DIR_CNR),
    399                   WM_COMMAND,
    400                   MPFROM2SHORT(cmd,0),
    401                   MPVOID);
    402       }
    403       if(msg == UM_CLICKED || msg == UM_CLICKED3)
    404         return 0;
    405       break;
    406 
    407     case DM_DROP:
    408     case DM_DRAGOVER:
    409     case DM_DRAGLEAVE:
    410     case DM_DROPHELP:
    411     case WM_BEGINDRAG:
    412       if(msg == DM_DRAGOVER) {
    413         if(!emphasized) {
    414           emphasized = TRUE;
    415           DrawTargetEmphasis(hwnd,emphasized);
    416         }
    417       }
    418       else if(msg != WM_BEGINDRAG){
    419         if(emphasized) {
    420           emphasized = FALSE;
    421           DrawTargetEmphasis(hwnd,emphasized);
    422         }
    423       }
    424       switch(WinQueryWindowUShort(hwnd,QWS_ID)) {
    425         case DIR_FOLDERICON:
    426           switch(msg) {
    427             case DM_DRAGOVER:
    428               if(AcceptOneDrop(mp1,mp2))
    429                 return MRFROM2SHORT(DOR_DROP,
    430                                     DO_MOVE);
    431               return(MRFROM2SHORT(DOR_NODROP,0));        /* Drop not valid        */
    432             case DM_DROPHELP:
    433               DropHelp(mp1,mp2,hwnd,
    434                        GetPString(IDS_DIRCNRFOLDERDROPHELP));
    435               return 0;
    436             case DM_DROP:
    437               {
    438                 char szFrom[CCHMAXPATH + 2];
    439 
    440                 if(emphasized) {
    441                   emphasized = FALSE;
    442                   DrawTargetEmphasis(hwnd,emphasized);
    443                 }
    444                 if(GetOneDrop(mp1,mp2,szFrom,sizeof(szFrom)))
    445                   WinSendMsg(WinWindowFromID(WinQueryWindow(hwnd,QW_PARENT),
    446                              DIR_CNR),
    447                              WM_COMMAND,MPFROM2SHORT(IDM_SWITCH,0),
    448                              MPFROMP(szFrom));
    449               }
    450               return 0;
    451             default:
    452               return PFNWPStatic(hwnd,msg,mp1,mp2);
    453           }
    454         case DIR_MAX:
    455           if(msg == WM_BEGINDRAG)
    456             return PFNWPStatic(hwnd,msg,mp1,mp2);
    457         default:
    458           {
    459             CNRDRAGINFO cnd;
    460             USHORT      dcmd;
    461 
    462             switch(msg) {
    463               case DM_DROP:
    464                 dcmd = CN_DROP;
    465                 break;
    466               case DM_DRAGOVER:
    467                 dcmd = CN_DRAGOVER;
    468                 break;
    469               case DM_DRAGLEAVE:
    470                 dcmd = CN_DRAGLEAVE;
    471                 break;
    472               case DM_DROPHELP:
    473                 dcmd = CN_DROPHELP;
    474                 break;
    475               case WM_BEGINDRAG:
    476                 dcmd = CN_INITDRAG;
    477                 break;
    478             }
    479             memset(&cnd,0,sizeof(cnd));
    480             cnd.pDragInfo = (PDRAGINFO)mp1;
    481             cnd.pRecord = NULL;
    482             return WinSendMsg(WinQueryWindow(hwnd,QW_PARENT),
    483                               WM_CONTROL,
    484                               MPFROM2SHORT(DIR_CNR,dcmd),
    485                               MPFROMP(&cnd));
    486           }
    487       }
     413        CNRDRAGINFO cnd;
     414        USHORT dcmd;
     415
     416        switch (msg) {
     417        case DM_DROP:
     418          dcmd = CN_DROP;
     419          break;
     420        case DM_DRAGOVER:
     421          dcmd = CN_DRAGOVER;
     422          break;
     423        case DM_DRAGLEAVE:
     424          dcmd = CN_DRAGLEAVE;
     425          break;
     426        case DM_DROPHELP:
     427          dcmd = CN_DROPHELP;
     428          break;
     429        case WM_BEGINDRAG:
     430          dcmd = CN_INITDRAG;
     431          break;
     432        }
     433        memset(&cnd, 0, sizeof(cnd));
     434        cnd.pDragInfo = (PDRAGINFO) mp1;
     435        cnd.pRecord = NULL;
     436        return WinSendMsg(WinQueryWindow(hwnd, QW_PARENT),
     437                          WM_CONTROL,
     438                          MPFROM2SHORT(DIR_CNR, dcmd), MPFROMP(&cnd));
     439      }
     440    }
    488441  }
    489   return PFNWPStatic(hwnd,msg,mp1,mp2);
     442  return PFNWPStatic(hwnd, msg, mp1, mp2);
    490443}
    491444
    492 
    493 MRESULT EXPENTRY DirClientWndProc (HWND hwnd,ULONG msg,MPARAM mp1,MPARAM mp2)
     445MRESULT EXPENTRY DirClientWndProc(HWND hwnd, ULONG msg, MPARAM mp1,
     446                                  MPARAM mp2)
    494447{
    495   switch(msg) {
    496     case UM_CONTAINERDIR:
    497       if(mp1) {
    498 
    499         DIRCNRDATA *dcd;
    500 
    501         *(CHAR *)mp1 = 0;
    502         dcd = WinQueryWindowPtr(WinWindowFromID(hwnd,DIR_CNR),QWL_USER);
    503         if(dcd)
    504           strcpy((CHAR *)mp1,dcd->directory);
    505         return MRFROMLONG(TRUE);
    506       }
     448  switch (msg) {
     449  case UM_CONTAINERDIR:
     450    if (mp1) {
     451
     452      DIRCNRDATA *dcd;
     453
     454      *(CHAR *) mp1 = 0;
     455      dcd = WinQueryWindowPtr(WinWindowFromID(hwnd, DIR_CNR), QWL_USER);
     456      if (dcd)
     457        strcpy((CHAR *) mp1, dcd->directory);
     458      return MRFROMLONG(TRUE);
     459    }
     460    return 0;
     461
     462  case UM_CONTAINERHWND:
     463    return MRFROMLONG(WinWindowFromID(hwnd, DIR_CNR));
     464
     465  case UM_VIEWSMENU:
     466    return MRFROMLONG(CheckMenu(&DirCnrMenu, DIRCNR_POPUP));
     467
     468  case UM_DRIVECMD:
     469  case WM_INITMENU:
     470  case UM_FILTER:
     471  case UM_INITMENU:
     472  case MM_PORTHOLEINIT:
     473  case UM_COMMAND:
     474  case UM_FILESMENU:
     475  case UM_UPDATERECORD:
     476  case UM_UPDATERECORDLIST:
     477    return WinSendMsg(WinWindowFromID(hwnd, DIR_CNR), msg, mp1, mp2);
     478
     479  case WM_PSETFOCUS:
     480  case WM_SETFOCUS:
     481    if (mp2)
     482      PostMsg(hwnd, UM_FOCUSME, MPVOID, MPVOID);
     483    break;
     484
     485  case UM_FOCUSME:
     486    WinSetFocus(HWND_DESKTOP, WinWindowFromID(hwnd, DIR_CNR));
     487    break;
     488
     489  case WM_PAINT:
     490    {
     491      HPS hps;
     492      RECTL rcl;
     493
     494      hps = WinBeginPaint(hwnd, (HPS) 0, NULL);
     495      if (hps) {
     496        WinQueryWindowRect(hwnd, &rcl);
     497        WinFillRect(hps, &rcl, CLR_PALEGRAY);
     498        CommonTextPaint(hwnd, hps);
     499        WinEndPaint(hps);
     500      }
     501    }
     502    break;
     503
     504  case UM_SIZE:
     505  case WM_SIZE:
     506    if (msg == UM_SIZE) {
     507
     508      SWP swp;
     509
     510      WinQueryWindowPos(hwnd, &swp);
     511      mp1 = MPFROM2SHORT(swp.cx, swp.cy);
     512      mp2 = MPFROM2SHORT(swp.cx, swp.cy);
     513    }
     514    {
     515      USHORT cx, cy, bx;
     516
     517      cx = SHORT1FROMMP(mp2);
     518      cy = SHORT2FROMMP(mp2);
     519      WinSetWindowPos(WinWindowFromID(hwnd, DIR_CNR), HWND_TOP,
     520                      0, 0, cx, cy - 24, SWP_SHOW | SWP_MOVE | SWP_SIZE);
     521      if (WinWindowFromID(hwnd, DIR_MAX) != (HWND) 0) {
     522        WinSetWindowPos(WinWindowFromID(hwnd, DIR_MAX), HWND_TOP,
     523                        cx - 22,
     524                        cy - 22, 20, 20, SWP_SHOW | SWP_MOVE | SWP_SIZE);
     525        cx -= 24;
     526      }
     527      WinSetWindowPos(WinWindowFromID(hwnd, DIR_FOLDERICON), HWND_TOP,
     528                      2, cy - 22, 24, 20, SWP_SHOW | SWP_MOVE | SWP_SIZE);
     529      WinSetWindowPos(WinWindowFromID(hwnd, DIR_TOTALS), HWND_TOP,
     530                      29,
     531                      cy - 22,
     532                      (cx / 3) - 2, 20, SWP_SHOW | SWP_MOVE | SWP_SIZE);
     533      WinSetWindowPos(WinWindowFromID(hwnd, DIR_SELECTED), HWND_TOP,
     534                      29 + (cx / 3) + 2,
     535                      cy - 22,
     536                      (cx / 3) - 2, 20, SWP_SHOW | SWP_MOVE | SWP_SIZE);
     537      bx = (cx - (29 + (((cx / 3) + 2) * 2))) / 3;
     538      WinSetWindowPos(WinWindowFromID(hwnd, DIR_VIEW), HWND_TOP,
     539                      29 + (((cx / 3) + 2) * 2),
     540                      cy - 22, bx - 4, 20, SWP_SHOW | SWP_MOVE | SWP_SIZE);
     541      WinSetWindowPos(WinWindowFromID(hwnd, DIR_SORT), HWND_TOP,
     542                      29 + (((cx / 3) + 2) * 2) + bx,
     543                      cy - 22, bx - 4, 20, SWP_SHOW | SWP_MOVE | SWP_SIZE);
     544      WinSetWindowPos(WinWindowFromID(hwnd, DIR_FILTER), HWND_TOP,
     545                      29 + (((cx / 3) + 2) * 2) + (bx * 2),
     546                      cy - 22, bx - 4, 20, SWP_SHOW | SWP_MOVE | SWP_SIZE);
     547    }
     548    CommonTextPaint(hwnd, (HPS) 0);
     549    if (msg == UM_SIZE) {
     550      WinSetWindowPos(WinQueryWindow(hwnd, QW_PARENT), HWND_TOP, 0, 0, 0, 0,
     551                      SWP_SHOW | SWP_ZORDER | SWP_ACTIVATE);
    507552      return 0;
    508 
    509     case UM_CONTAINERHWND:
    510       return MRFROMLONG(WinWindowFromID(hwnd,DIR_CNR));
    511 
    512     case UM_VIEWSMENU:
    513       return MRFROMLONG(CheckMenu(&DirCnrMenu,DIRCNR_POPUP));
    514 
    515     case UM_DRIVECMD:
    516     case WM_INITMENU:
    517     case UM_FILTER:
    518     case UM_INITMENU:
    519     case MM_PORTHOLEINIT:
    520     case UM_COMMAND:
    521     case UM_FILESMENU:
    522     case UM_UPDATERECORD:
    523     case UM_UPDATERECORDLIST:
    524       return WinSendMsg(WinWindowFromID(hwnd,DIR_CNR),msg,mp1,mp2);
    525 
    526 
    527     case WM_PSETFOCUS:
    528     case WM_SETFOCUS:
    529       if(mp2)
    530         PostMsg(hwnd,UM_FOCUSME,MPVOID,MPVOID);
    531       break;
    532 
    533     case UM_FOCUSME:
    534       WinSetFocus(HWND_DESKTOP,WinWindowFromID(hwnd,DIR_CNR));
    535       break;
    536 
    537     case WM_PAINT:
    538       {
    539         HPS    hps;
    540         RECTL  rcl;
    541 
    542         hps = WinBeginPaint(hwnd,(HPS)0,NULL);
    543         if(hps) {
    544           WinQueryWindowRect(hwnd,&rcl);
    545           WinFillRect(hps,&rcl,CLR_PALEGRAY);
    546           CommonTextPaint(hwnd,hps);
    547           WinEndPaint(hps);
    548         }
    549       }
    550       break;
    551 
    552     case UM_SIZE:
    553     case WM_SIZE:
    554       if(msg == UM_SIZE) {
    555 
    556         SWP     swp;
    557 
    558         WinQueryWindowPos(hwnd,&swp);
    559         mp1 = MPFROM2SHORT(swp.cx,swp.cy);
    560         mp2 = MPFROM2SHORT(swp.cx,swp.cy);
    561       }
    562       {
    563         USHORT  cx,cy,bx;
    564 
    565         cx = SHORT1FROMMP(mp2);
    566         cy = SHORT2FROMMP(mp2);
    567         WinSetWindowPos(WinWindowFromID(hwnd,DIR_CNR),HWND_TOP,
    568                         0,
    569                         0,
    570                         cx,
    571                         cy - 24,
    572                         SWP_SHOW | SWP_MOVE | SWP_SIZE);
    573         if(WinWindowFromID(hwnd,DIR_MAX) != (HWND)0) {
    574           WinSetWindowPos(WinWindowFromID(hwnd,DIR_MAX),HWND_TOP,
    575                           cx - 22,
    576                           cy - 22,
    577                           20,20,SWP_SHOW | SWP_MOVE | SWP_SIZE);
    578           cx -= 24;
    579         }
    580         WinSetWindowPos(WinWindowFromID(hwnd,DIR_FOLDERICON),HWND_TOP,
    581                         2,
    582                         cy - 22,
    583                         24,
    584                         20,
    585                         SWP_SHOW | SWP_MOVE | SWP_SIZE);
    586         WinSetWindowPos(WinWindowFromID(hwnd,DIR_TOTALS),HWND_TOP,
    587                         29,
    588                         cy - 22,
    589                         (cx / 3) - 2,
    590                         20,
    591                         SWP_SHOW | SWP_MOVE | SWP_SIZE);
    592         WinSetWindowPos(WinWindowFromID(hwnd,DIR_SELECTED),HWND_TOP,
    593                         29 + (cx / 3) + 2,
    594                         cy - 22,
    595                         (cx / 3) - 2,
    596                         20,
    597                         SWP_SHOW | SWP_MOVE | SWP_SIZE);
    598         bx = (cx - (29 + (((cx / 3) + 2) * 2))) / 3;
    599         WinSetWindowPos(WinWindowFromID(hwnd,DIR_VIEW),HWND_TOP,
    600                         29 + (((cx / 3) + 2) * 2),
    601                         cy - 22,
    602                         bx - 4,
    603                         20,
    604                         SWP_SHOW | SWP_MOVE | SWP_SIZE);
    605         WinSetWindowPos(WinWindowFromID(hwnd,DIR_SORT),HWND_TOP,
    606                         29 + (((cx / 3) + 2) * 2) + bx,
    607                         cy - 22,
    608                         bx - 4,
    609                         20,
    610                         SWP_SHOW | SWP_MOVE | SWP_SIZE);
    611         WinSetWindowPos(WinWindowFromID(hwnd,DIR_FILTER),HWND_TOP,
    612                         29 + (((cx / 3) + 2) * 2) + (bx * 2),
    613                         cy - 22,
    614                         bx - 4,
    615                         20,
    616                         SWP_SHOW | SWP_MOVE | SWP_SIZE);
    617       }
    618       CommonTextPaint(hwnd,(HPS)0);
    619       if(msg == UM_SIZE) {
    620         WinSetWindowPos(WinQueryWindow(hwnd,QW_PARENT),HWND_TOP,0,0,0,0,
    621                         SWP_SHOW | SWP_ZORDER | SWP_ACTIVATE);
    622         return 0;
    623       }
    624       break;
    625 
    626     case WM_COMMAND:
    627     case WM_CONTROL:
    628     case WM_CLOSE:
    629       return WinSendMsg(WinWindowFromID(hwnd,DIR_CNR),
    630                         msg,
    631                         mp1,
    632                         mp2);
     553    }
     554    break;
     555
     556  case WM_COMMAND:
     557  case WM_CONTROL:
     558  case WM_CLOSE:
     559    return WinSendMsg(WinWindowFromID(hwnd, DIR_CNR), msg, mp1, mp2);
    633560  }
    634   return WinDefWindowProc(hwnd,msg,mp1,mp2);
     561  return WinDefWindowProc(hwnd, msg, mp1, mp2);
    635562}
    636563
    637 
    638 MRESULT EXPENTRY DirObjWndProc (HWND hwnd,ULONG msg,MPARAM mp1,MPARAM mp2)
     564MRESULT EXPENTRY DirObjWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
    639565{
    640566  DIRCNRDATA *dcd;
    641567
    642   switch(msg) {
    643     case WM_CREATE:
     568  switch (msg) {
     569  case WM_CREATE:
     570    break;
     571
     572  case DM_PRINTOBJECT:
     573    return MRFROMLONG(DRR_TARGET);
     574
     575  case DM_DISCARDOBJECT:
     576    dcd = INSTDATA(hwnd);
     577    if (fFM2Deletes && dcd) {
     578
     579      LISTINFO *li;
     580      CNRDRAGINFO cni;
     581
     582      cni.pRecord = NULL;
     583      cni.pDragInfo = (PDRAGINFO) mp1;
     584      li =
     585        DoFileDrop(dcd->hwndCnr, dcd->directory, FALSE, MPVOID,
     586                   MPFROMP(&cni));
     587      if (li) {
     588        li->type = (fDefaultDeletePerm) ? IDM_PERMDELETE : IDM_DELETE;
     589        if (!PostMsg(hwnd, UM_MASSACTION, MPFROMP(li), MPVOID))
     590          FreeListInfo(li);
     591        else
     592          return MRFROMLONG(DRR_SOURCE);
     593      }
     594    }
     595    return MRFROMLONG(DRR_TARGET);
     596
     597  case UM_UPDATERECORDLIST:
     598    dcd = WinQueryWindowPtr(hwnd, QWL_USER);
     599    if (dcd && mp1) {
     600
     601      INT numentries = 0;
     602      CHAR **list = (CHAR **) mp1;
     603
     604      while (list[numentries])
     605        numentries++;
     606      if (numentries)
     607        UpdateCnrList(dcd->hwndCnr, list, numentries, TRUE, dcd);
     608    }
     609    return 0;
     610
     611  case UM_SETUP:
     612    dcd = WinQueryWindowPtr(hwnd, QWL_USER);
     613    if (dcd) {
     614      /* set unique id */
     615      WinSetWindowUShort(hwnd, QWS_ID, DIROBJ_FRAME + (DIR_FRAME - dcd->id));
     616      dcd->hwndObject = hwnd;
     617      if (ParentIsDesktop(hwnd, dcd->hwndParent))
     618        DosSleep(250L);
     619    }
     620    else
     621      PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
     622    return 0;
     623
     624  case UM_RESCAN2:
     625    dcd = WinQueryWindowPtr(hwnd, QWL_USER);
     626    if (dcd && dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent)) {
     627
     628      FSALLOCATE fsa;
     629      CHAR s[CCHMAXPATH * 2];
     630      CHAR tf[64];
     631      CHAR tb[64];
     632      CHAR szFree[64];
     633
     634      DosError(FERR_DISABLEHARDERR);
     635      if (!DosQueryFSInfo(toupper(*dcd->directory) - '@',
     636                          FSIL_ALLOC, &fsa, sizeof(FSALLOCATE))) {
     637        CommaFmtULL(tb, sizeof(tb),
     638                    (ULONGLONG) fsa.cUnitAvail * (fsa.cSectorUnit *
     639                                                  fsa.cbSector), 'K');
     640        sprintf(szFree, "  {%s %s}", tb, GetPString(IDS_FREETEXT));
     641      }
     642      else
     643        *szFree = 0;
     644      commafmt(tf, sizeof(tf), dcd->totalfiles);
     645      CommaFmtULL(tb, sizeof(tb), dcd->ullTotalBytes, ' ');
     646      if (!fMoreButtons) {
     647        sprintf(s, " [%s / %s]%s%s%s%s %s",
     648                tf, tb, szFree,
     649                (*dcd->mask.szMask || dcd->mask.antiattr ||
     650                 dcd->mask.attrFile != ALLATTRS) ? "  (" : NullStr,
     651                (*dcd->mask.szMask) ? dcd->mask.szMask :
     652                (dcd->mask.antiattr ||
     653                 dcd->mask.attrFile != ALLATTRS) ?
     654                GetPString(IDS_ALLTEXT) : NullStr,
     655                (*dcd->mask.szMask || dcd->mask.antiattr ||
     656                 dcd->mask.attrFile != ALLATTRS) ? ")" : NullStr,
     657                dcd->directory);
     658      }
     659      else {
     660        sprintf(s, " [%s / %s]%s %s", tf, tb, szFree, dcd->directory);
     661      }
     662      if (dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent))
     663        WinSetWindowText(hwndStatus, s);
     664    }
     665    return 0;
     666
     667  case UM_FLESH:
     668    dcd = WinQueryWindowPtr(hwnd, QWL_USER);
     669    if (dcd) {
     670
     671      PCNRITEM pci, pciC;
     672
     673      pci = WinSendMsg(dcd->hwndCnr,
     674                       CM_QUERYRECORD,
     675                       MPVOID, MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
     676      while (pci && (INT) pci != -1) {
     677        if (pci->attrFile & FILE_DIRECTORY) {
     678          pciC = WinSendMsg(dcd->hwndCnr,
     679                            CM_QUERYRECORD,
     680                            MPFROMP(pci),
     681                            MPFROM2SHORT(CMA_FIRSTCHILD, CMA_ITEMORDER));
     682          if (!pciC) {
     683            Stubby(dcd->hwndCnr, pci);
     684            DosSleep(0L);
     685          }
     686        }
     687        pci = WinSendMsg(dcd->hwndCnr,
     688                         CM_QUERYRECORD,
     689                         MPFROMP(pci), MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
     690      }
     691      dcd->firsttree = TRUE;
     692    }
     693    return 0;
     694
     695  case UM_RESCAN:
     696    /*
     697     * populate container
     698     */
     699    dcd = WinQueryWindowPtr(hwnd, QWL_USER);
     700    if (dcd) {
     701      DosEnterCritSec();
     702      if (dcd->stopflag)
     703        dcd->stopflag--;
     704      if (dcd->stopflag) {
     705        DosExitCritSec();
     706        return 0;
     707      }
     708      DosExitCritSec();
     709      if (mp1) {
     710        strcpy(dcd->previous, dcd->directory);
     711        strcpy(dcd->directory, (CHAR *) mp1);
     712      }
     713      MakeValidDir(dcd->directory);
     714      {
     715        CHAR s[CCHMAXPATH + 8];
     716
     717        sprintf(s,
     718                "%s%s%s",
     719                (ParentIsDesktop(dcd->hwndFrame, (HWND) 0)) ?
     720                "VDir" :
     721                NullStr,
     722                (ParentIsDesktop(dcd->hwndFrame, (HWND) 0)) ?
     723                (!dcd->dontclose) ?
     724                " Master: " : ": " : NullStr, dcd->directory);
     725        WinSetWindowText(dcd->hwndFrame, s);
     726        WinSetWindowText(WinWindowFromID(dcd->hwndFrame, FID_TITLEBAR), s);
     727      }
     728      WinSendMsg(dcd->hwndCnr,
     729                 CM_REMOVERECORD,
     730                 MPVOID,
     731                 MPFROM2SHORT(0, CMA_FREE | CMA_INVALIDATE | CMA_ERASE));
     732      AdjustCnrColsForFSType(dcd->hwndCnr, dcd->directory, dcd);
     733      dcd->ullTotalBytes = dcd->totalfiles =
     734        dcd->selectedfiles = dcd->selectedbytes = 0;
     735      WinSetDlgItemText(dcd->hwndClient, DIR_TOTALS, "0 / 0k");
     736      WinSetDlgItemText(dcd->hwndClient, DIR_SELECTED, "0 / 0k");
     737      if (hwndStatus &&
     738          dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent)) {
     739        WinSetWindowText(hwndStatus, GetPString(IDS_SCANNINGTEXT));
     740        if (hwndMain)
     741          WinSendMsg(hwndMain, UM_LOADFILE, MPVOID, MPVOID);
     742      }
     743      if (fSwitchTree && hwndTree) {
     744        if (hwndMain) {
     745          if (TopWindow(hwndMain, (HWND) 0) == dcd->hwndFrame)
     746            WinSendMsg(hwndTree, UM_SHOWME, MPFROMP(dcd->directory), MPVOID);
     747        }
     748        else
     749          WinSendMsg(hwndTree, UM_SHOWME, MPFROMP(dcd->directory), MPVOID);
     750      }
     751      dcd->firsttree = FALSE;
     752      // fixme to check errors
     753      FillDirCnr(dcd->hwndCnr, dcd->directory, dcd, &dcd->ullTotalBytes);
     754      PostMsg(dcd->hwndCnr, UM_RESCAN, MPVOID, MPVOID);
     755      if (mp2 && !fLeaveTree && (dcd->flWindowAttr & CV_TREE)) {
     756
     757        ULONG flWindowAttr = dcd->flWindowAttr;
     758        CNRINFO cnri;
     759
     760        flWindowAttr &=
     761          (~(CV_NAME | CV_TREE | CV_ICON | CV_DETAIL | CV_TEXT));
     762        if (dcd->lastattr) {
     763          if (dcd->lastattr & CV_TEXT)
     764            flWindowAttr |= CV_TEXT;
     765          else if (dcd->lastattr & CV_DETAIL)
     766            flWindowAttr |= CV_DETAIL;
     767          else if (dcd->lastattr & CV_ICON)
     768            flWindowAttr |= CV_ICON;
     769          else
     770            flWindowAttr |= CV_NAME;
     771        }
     772        else
     773          flWindowAttr |= CV_NAME;
     774        flWindowAttr |= CV_FLOW;
     775        memset(&cnri, 0, sizeof(CNRINFO));
     776        cnri.cb = sizeof(CNRINFO);
     777        if (WinSendMsg(dcd->hwndCnr, CM_QUERYCNRINFO, MPFROMP(&cnri),
     778                       MPFROMLONG(sizeof(CNRINFO)))) {
     779          dcd->flWindowAttr = cnri.flWindowAttr = flWindowAttr;
     780          WinSendMsg(dcd->hwndCnr, CM_SETCNRINFO,
     781                     MPFROMP(&cnri), MPFROMLONG(CMA_FLWINDOWATTR));
     782          SayView(WinWindowFromID(dcd->hwndClient,
     783                                  DIR_VIEW), dcd->flWindowAttr);
     784        }
     785      }
     786      if (dcd->flWindowAttr & CV_TREE)
     787        PostMsg(dcd->hwndObject, UM_FLESH, MPVOID, MPVOID);
     788      if (*dcd->previous) {
     789        if (strlen(dcd->previous) > strlen(dcd->directory) &&
     790            !strnicmp(dcd->directory, dcd->previous,
     791                      strlen(dcd->directory))) {
     792
     793          PCNRITEM pci;
     794
     795          pci = FindCnrRecord(dcd->hwndCnr,
     796                              dcd->previous, NULL, TRUE, FALSE, TRUE);
     797          if (pci && (INT) pci != -1) {
     798            /* make found item current (cursored) item */
     799            WinSendMsg(dcd->hwndCnr, CM_SETRECORDEMPHASIS, MPFROMP(pci),
     800                       MPFROM2SHORT(TRUE, CRA_CURSORED));
     801            /* make sure that record shows in viewport */
     802            ShowCnrRecord(dcd->hwndCnr, (PMINIRECORDCORE) pci);
     803          }
     804        }
     805      }
     806    }
     807    return 0;
     808
     809  case UM_COMMAND:
     810    if (mp1) {
     811
     812      LISTINFO *li = (LISTINFO *) mp1;
     813
     814      switch (li->type) {
     815      case IDM_DOITYOURSELF:
     816      case IDM_APPENDTOCLIP:
     817      case IDM_SAVETOCLIP:
     818      case IDM_ARCHIVE:
     819      case IDM_ARCHIVEM:
     820      case IDM_VIEWTEXT:
     821      case IDM_VIEWBINARY:
     822      case IDM_VIEWARCHIVE:
     823      case IDM_VIEW:
     824      case IDM_EDITTEXT:
     825      case IDM_EDITBINARY:
     826      case IDM_EDIT:
     827      case IDM_OBJECT:
     828      case IDM_SHADOW:
     829      case IDM_SHADOW2:
     830      case IDM_PRINT:
     831      case IDM_ATTRS:
     832      case IDM_DELETE:
     833      case IDM_PERMDELETE:
     834      case IDM_MCIPLAY:
     835      case IDM_UPDATE:
     836        if (PostMsg(hwnd, UM_MASSACTION, mp1, mp2))
     837          return (MRESULT) TRUE;
     838        break;
     839      default:
     840        if (PostMsg(hwnd, UM_ACTION, mp1, mp2))
     841          return (MRESULT) TRUE;
     842      }
     843    }
     844    return 0;
     845
     846  case UM_SELECT:
     847    dcd = WinQueryWindowPtr(hwnd, QWL_USER);
     848    if (dcd) {
     849      switch (SHORT1FROMMP(mp1)) {
     850      case IDM_SELECTBOTH:
     851      case IDM_SELECTONE:
     852      case IDM_SELECTMORE:
     853      case IDM_SELECTNEWER:
     854      case IDM_SELECTOLDER:
     855      case IDM_SELECTBIGGER:
     856      case IDM_SELECTSMALLER:
     857      case IDM_DESELECTBOTH:
     858      case IDM_DESELECTONE:
     859      case IDM_DESELECTMORE:
     860      case IDM_DESELECTNEWER:
     861      case IDM_DESELECTOLDER:
     862      case IDM_DESELECTBIGGER:
     863      case IDM_DESELECTSMALLER:
     864        SpecialSelect2(dcd->hwndParent, SHORT1FROMMP(mp1));
     865        break;
     866      case IDM_SELECTLIST:
     867        {
     868          CHAR filename[CCHMAXPATH], *p, *pp;
     869          ULONG size;
     870
     871          strcpy(filename, "*.LST");
     872          size = CCHMAXPATH;
     873          PrfQueryProfileData(fmprof, appname, "SaveToListName",
     874                              filename, &size);
     875          pp = strrchr(filename, '\\');
     876          if (!pp)
     877            pp = filename;
     878          p = strrchr(pp, '.');
     879          if (p && *(p + 1) && p > pp + 1) {
     880            if (pp > filename)
     881              pp++;
     882            *pp = '*';
     883            pp++;
     884            if (p > pp)
     885              memmove(pp, p, strlen(p) + 1);
     886          }
     887          if (insert_filename(hwnd, filename, FALSE, FALSE))
     888            SelectList(dcd->hwndCnr, TRUE, FALSE, FALSE, NULL, filename,
     889                       NULL);
     890        }
     891        break;
     892      case IDM_SELECTALL:
     893        SelectAll(dcd->hwndCnr, TRUE, TRUE, NULL, NULL, FALSE);
     894        break;
     895      case IDM_DESELECTALL:
     896        DeselectAll(dcd->hwndCnr, TRUE, TRUE, NULL, NULL, FALSE);
     897        break;
     898      case IDM_SELECTALLFILES:
     899        SelectAll(dcd->hwndCnr, TRUE, FALSE, NULL, NULL, FALSE);
     900        break;
     901      case IDM_DESELECTALLFILES:
     902        DeselectAll(dcd->hwndCnr, TRUE, FALSE, NULL, NULL, FALSE);
     903        break;
     904      case IDM_SELECTALLDIRS:
     905        SelectAll(dcd->hwndCnr, FALSE, TRUE, NULL, NULL, FALSE);
     906        break;
     907      case IDM_DESELECTALLDIRS:
     908        DeselectAll(dcd->hwndCnr, FALSE, TRUE, NULL, NULL, FALSE);
     909        break;
     910      case IDM_DESELECTMASK:
     911      case IDM_SELECTMASK:
     912        {
     913          MASK mask;
     914          PCNRITEM pci = (PCNRITEM) mp2;
     915
     916          memset(&mask, 0, sizeof(MASK));
     917          mask.fNoAttribs = TRUE;
     918          mask.fNoDirs = TRUE;
     919          mask.fText = TRUE;
     920          strcpy(mask.prompt,
     921                 GetPString((SHORT1FROMMP(mp1) == IDM_SELECTMASK) ?
     922                            IDS_SELECTFILTERTEXT : IDS_DESELECTFILTERTEXT));
     923          if (pci && (INT) pci != -1)
     924            strcpy(mask.szMask, pci->szFileName);
     925          if (WinDlgBox(HWND_DESKTOP,
     926                        dcd->hwndCnr,
     927                        PickMaskDlgProc,
     928                        FM3ModHandle, MSK_FRAME, MPFROMP(&mask))) {
     929            if (SHORT1FROMMP(mp1) == IDM_SELECTMASK)
     930              SelectAll(dcd->hwndCnr,
     931                        TRUE, TRUE, mask.szMask, mask.szText, FALSE);
     932            else
     933              DeselectAll(dcd->hwndCnr,
     934                          TRUE, TRUE, mask.szMask, mask.szText, FALSE);
     935          }
     936        }
     937        break;
     938
     939      case IDM_DESELECTCLIP:
     940      case IDM_SELECTCLIP:
     941        {
     942          CHAR **list;
     943
     944          list = ListFromClipboard(hwnd);
     945          if (list) {
     946            SelectList(dcd->hwndCnr, TRUE, FALSE,
     947                       (SHORT1FROMMP(mp1) == IDM_DESELECTCLIP),
     948                       NULL, NULL, list);
     949            FreeList(list);
     950          }
     951        }
     952        break;
     953
     954      case IDM_INVERT:
     955        InvertAll(dcd->hwndCnr);
     956        break;
     957      }
     958    }
     959    return 0;
     960
     961  case UM_MASSACTION:
     962    if (mp1) {
     963
     964      dcd = WinQueryWindowPtr(hwnd, QWL_USER);
     965      if (dcd) {
     966
     967        WORKER *wk;
     968
     969        wk = xmallocz(sizeof(WORKER), pszSrcFile, __LINE__);
     970        if (!wk)
     971          FreeListInfo((LISTINFO *) mp1);
     972        else {
     973          wk->size = sizeof(WORKER);
     974          wk->hwndCnr = dcd->hwndCnr;
     975          wk->hwndParent = dcd->hwndParent;
     976          wk->hwndFrame = dcd->hwndFrame;
     977          wk->hwndClient = dcd->hwndClient;
     978          wk->li = (LISTINFO *) mp1;
     979          strcpy(wk->directory, dcd->directory);
     980          if (_beginthread(MassAction, NULL, 122880, (PVOID) wk) == -1) {
     981            Runtime_Error(pszSrcFile, __LINE__,
     982                          GetPString(IDS_COULDNTSTARTTHREADTEXT));
     983            free(wk);
     984            FreeListInfo((LISTINFO *) mp1);
     985          }
     986        }
     987      }
     988    }
     989    return 0;
     990
     991  case UM_ACTION:
     992    if (mp1) {
     993
     994      dcd = WinQueryWindowPtr(hwnd, QWL_USER);
     995      if (dcd) {
     996
     997        WORKER *wk;
     998
     999        wk = xmallocz(sizeof(WORKER), pszSrcFile, __LINE__);
     1000        if (!wk)
     1001          FreeListInfo((LISTINFO *) mp1);
     1002        else {
     1003          wk->size = sizeof(WORKER);
     1004          wk->hwndCnr = dcd->hwndCnr;
     1005          wk->hwndParent = dcd->hwndParent;
     1006          wk->hwndFrame = dcd->hwndFrame;
     1007          wk->hwndClient = dcd->hwndClient;
     1008          wk->li = (LISTINFO *) mp1;
     1009          strcpy(wk->directory, dcd->directory);
     1010          if (_beginthread(Action, NULL, 122880, (PVOID) wk) == -1) {
     1011            Runtime_Error(pszSrcFile, __LINE__,
     1012                          GetPString(IDS_COULDNTSTARTTHREADTEXT));
     1013            free(wk);
     1014            FreeListInfo((LISTINFO *) mp1);
     1015          }
     1016        }
     1017      }
     1018    }
     1019    return 0;
     1020
     1021  case WM_CLOSE:
     1022    WinDestroyWindow(hwnd);
     1023    break;
     1024
     1025  case WM_DESTROY:
     1026    dcd = WinQueryWindowPtr(hwnd, QWL_USER);
     1027    if (dcd) {
     1028      if (dcd->hwndRestore)
     1029        WinSetWindowPos(dcd->hwndRestore,
     1030                        HWND_TOP,
     1031                        0,
     1032                        0,
     1033                        0,
     1034                        0,
     1035                        SWP_RESTORE | SWP_SHOW | SWP_ACTIVATE | SWP_ZORDER);
     1036      FreeList(dcd->lastselection);
     1037      free(dcd);
     1038      DosPostEventSem(CompactSem);
     1039    }
     1040    if (!PostMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID))
     1041      WinSendMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID);
     1042    break;
     1043  }
     1044  return WinDefWindowProc(hwnd, msg, mp1, mp2);
     1045}
     1046
     1047MRESULT EXPENTRY DirCnrWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
     1048{
     1049  DIRCNRDATA *dcd = WinQueryWindowPtr(hwnd, QWL_USER);
     1050
     1051  switch (msg) {
     1052  case DM_PRINTOBJECT:
     1053    return MRFROMLONG(DRR_TARGET);
     1054
     1055  case DM_DISCARDOBJECT:
     1056    if (dcd)
     1057      return WinSendMsg(dcd->hwndObject, msg, mp1, mp2);
     1058    else
     1059      return MRFROMLONG(DRR_TARGET);
     1060
     1061  case WM_CHAR:
     1062    shiftstate = (SHORT1FROMMP(mp1) & (KC_SHIFT | KC_ALT | KC_CTRL));
     1063    if (SHORT1FROMMP(mp1) & KC_KEYUP)
     1064      return (MRESULT) TRUE;
     1065    if (SHORT1FROMMP(mp1) & KC_VIRTUALKEY) {
     1066      switch (SHORT2FROMMP(mp2)) {
     1067      case VK_INSERT:
     1068        if ((shiftstate & KC_CTRL) == KC_CTRL)
     1069          PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_MKDIR, 0), MPVOID);
     1070        else if ((shiftstate & KC_ALT) == KC_ALT)
     1071          PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_CREATE, 0), MPVOID);
     1072        break;
     1073      case VK_PAGEUP:
     1074        if ((shiftstate & KC_CTRL) == KC_CTRL)
     1075          PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_PARENT, 0), MPVOID);
     1076        break;
     1077      case VK_PAGEDOWN:
     1078        if ((shiftstate & KC_CTRL) == KC_CTRL)
     1079          PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_PREVIOUS, 0), MPVOID);
     1080        break;
     1081      case VK_HOME:
     1082        if ((shiftstate & KC_CTRL) == KC_CTRL && dcd) {
     1083
     1084          CHAR s[CCHMAXPATH], *p;
     1085
     1086          strcpy(s, dcd->directory);
     1087          p = strchr(s, '\\');
     1088          if (p) {
     1089            p++;
     1090            *p = 0;
     1091            WinSendMsg(hwnd, UM_SETDIR, MPFROMP(s), MPVOID);
     1092          }
     1093        }
     1094        break;
     1095      case VK_DELETE:
     1096        if ((shiftstate & KC_CTRL) == KC_CTRL)
     1097          PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_PERMDELETE, 0), MPVOID);
     1098        else if ((shiftstate & KC_SHIFT) == KC_SHIFT)
     1099          PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_SAVETOCLIP, 0), MPVOID);
     1100        else
     1101          PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_DELETE, 0), MPVOID);
     1102        break;
     1103      }
     1104    }
     1105    if (shiftstate || fNoSearch)
    6441106      break;
    645 
    646     case DM_PRINTOBJECT:
    647       return MRFROMLONG(DRR_TARGET);
    648 
    649     case DM_DISCARDOBJECT:
    650       dcd = INSTDATA(hwnd);
    651       if(fFM2Deletes && dcd) {
    652 
    653         LISTINFO    *li;
    654         CNRDRAGINFO cni;
    655 
    656         cni.pRecord = NULL;
    657         cni.pDragInfo = (PDRAGINFO)mp1;
    658         li = DoFileDrop(dcd->hwndCnr,dcd->directory,FALSE,MPVOID,MPFROMP(&cni));
    659         if(li) {
    660           li->type = (fDefaultDeletePerm) ? IDM_PERMDELETE : IDM_DELETE;
    661           if(!PostMsg(hwnd,UM_MASSACTION,MPFROMP(li),MPVOID))
    662             FreeListInfo(li);
    663           else
    664             return MRFROMLONG(DRR_SOURCE);
    665         }
    666       }
    667       return MRFROMLONG(DRR_TARGET);
    668 
    669     case UM_UPDATERECORDLIST:
    670       dcd = WinQueryWindowPtr(hwnd,QWL_USER);
    671       if(dcd && mp1) {
    672 
    673         INT    numentries = 0;
    674         CHAR **list = (CHAR **)mp1;
    675 
    676         while(list[numentries])
    677           numentries++;
    678         if(numentries)
    679           UpdateCnrList(dcd->hwndCnr,
    680                         list,
    681                         numentries,
    682                         TRUE,
    683                         dcd);
    684       }
     1107    if (SHORT1FROMMP(mp1) & KC_CHAR) {
     1108
     1109      ULONG thistime, len;
     1110      SEARCHSTRING srch;
     1111      PCNRITEM pci;
     1112
     1113      if (!dcd)
     1114        break;
     1115      switch (SHORT1FROMMP(mp2)) {
     1116      case '\x1b':
     1117      case '\r':
     1118      case '\n':
     1119        dcd->lasttime = 0;
     1120        *dcd->szCommonName = 0;
     1121        break;
     1122      default:
     1123        thistime = WinQueryMsgTime(WinQueryAnchorBlock(hwnd));
     1124        if (thistime > dcd->lasttime + 1250)
     1125          *dcd->szCommonName = 0;
     1126        dcd->lasttime = thistime;
     1127        if (SHORT1FROMMP(mp2) == ' ' && !dcd->szCommonName)
     1128          break;
     1129      KbdRetry:
     1130        len = strlen(dcd->szCommonName);
     1131        if (len >= CCHMAXPATH - 1) {
     1132          *dcd->szCommonName = 0;
     1133          len = 0;
     1134        }
     1135        dcd->szCommonName[len] = toupper(SHORT1FROMMP(mp2));
     1136        dcd->szCommonName[len + 1] = 0;
     1137        memset(&srch, 0, sizeof(SEARCHSTRING));
     1138        srch.cb = (ULONG) sizeof(SEARCHSTRING);
     1139        srch.pszSearch = (PSZ) dcd->szCommonName;
     1140        srch.fsPrefix = TRUE;
     1141        srch.fsCaseSensitive = FALSE;
     1142        srch.usView = CV_ICON;
     1143        pci = WinSendMsg(hwnd, CM_SEARCHSTRING, MPFROMP(&srch),
     1144                         MPFROMLONG(CMA_FIRST));
     1145        if (pci && (INT) pci != -1) {
     1146
     1147          USHORT attrib = CRA_CURSORED;
     1148
     1149          /* make found item current item */
     1150          if (!stricmp(pci->pszFileName, dcd->szCommonName))
     1151            attrib |= CRA_SELECTED;
     1152          WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPFROMP(pci),
     1153                     MPFROM2SHORT(TRUE, attrib));
     1154          /* make sure that record shows in viewport */
     1155          ShowCnrRecord(hwnd, (PMINIRECORDCORE) pci);
     1156          return (MRESULT) TRUE;
     1157        }
     1158        else {
     1159          if (SHORT1FROMMP(mp2) == ' ') {
     1160            dcd->szCommonName[len] = 0;
     1161            break;
     1162          }
     1163          *dcd->szCommonName = 0;
     1164          dcd->lasttime = 0;
     1165          if (len)                      // retry as first letter if no match
     1166            goto KbdRetry;
     1167        }
     1168        break;
     1169      }
     1170    }
     1171    break;
     1172
     1173  case WM_MOUSEMOVE:
     1174  case WM_BUTTON1UP:
     1175  case WM_BUTTON2UP:
     1176  case WM_BUTTON3UP:
     1177  case WM_CHORD:
     1178    shiftstate = (SHORT2FROMMP(mp2) & (KC_ALT | KC_SHIFT | KC_CTRL));
     1179    break;
     1180
     1181  case WM_BUTTON1MOTIONEND:
     1182    {
     1183      CNRINFO cnri;
     1184
     1185      memset(&cnri, 0, sizeof(CNRINFO));
     1186      cnri.cb = sizeof(CNRINFO);
     1187      if (WinSendMsg(hwnd, CM_QUERYCNRINFO, MPFROMP(&cnri),
     1188                     MPFROMLONG(sizeof(CNRINFO)))) {
     1189        if (cnri.flWindowAttr & CV_DETAIL)
     1190          PrfWriteProfileData(fmprof, appname, "CnrSplitBar",
     1191                              (PVOID) & cnri.xVertSplitbar, sizeof(LONG));
     1192      }
     1193    }
     1194    break;
     1195
     1196  case UM_COMPARE:
     1197    if (dcd && mp1 && mp2) {
     1198
     1199      COMPARE *cmp;
     1200      CHAR *leftdir = (CHAR *) mp1, *rightdir = (CHAR *) mp2;
     1201
     1202      if (!IsFile(leftdir) && !IsFile(rightdir)) {
     1203        cmp = xmallocz(sizeof(COMPARE), pszSrcFile, __LINE__);
     1204        if (cmp) {
     1205          cmp->size = sizeof(COMPARE);
     1206          strcpy(cmp->leftdir, leftdir);
     1207          strcpy(cmp->rightdir, rightdir);
     1208          cmp->hwndParent = dcd->hwndParent;
     1209          cmp->dcd.hwndParent = dcd->hwndParent;
     1210          WinDlgBox(HWND_DESKTOP,
     1211                    HWND_DESKTOP,
     1212                    CompareDlgProc, FM3ModHandle, COMP_FRAME, MPFROMP(cmp));
     1213        }
     1214      }
     1215    }
     1216    return 0;
     1217
     1218  case WM_PRESPARAMCHANGED:
     1219    PresParamChanged(hwnd, "DirCnr", mp1, mp2);
     1220    break;
     1221
     1222  case UM_UPDATERECORDLIST:
     1223    if (dcd && mp1)
     1224      WinSendMsg(dcd->hwndObject, msg, mp1, mp2);
     1225    return 0;
     1226
     1227  case UM_UPDATERECORD:
     1228    if (dcd && mp1) {
     1229
     1230      CHAR *filename;
     1231
     1232      filename = mp1;
     1233      if (filename)
     1234        UpdateCnrRecord(hwnd, filename, TRUE, dcd);
     1235    }
     1236    return 0;
     1237
     1238  case WM_SETFOCUS:
     1239    /*
     1240     * put name of our window (directory name) on status line
     1241     */
     1242    if (dcd && hwndStatus && mp2) {
     1243
     1244      PCNRITEM pci = NULL;
     1245
     1246      if (fAutoView && hwndMain) {
     1247        pci = WinSendMsg(hwnd, CM_QUERYRECORDEMPHASIS, MPFROMLONG(CMA_FIRST),
     1248                         MPFROMSHORT(CRA_CURSORED));
     1249        if (pci && (INT) pci != -1 &&
     1250            (!(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_SLOW)))
     1251          WinSendMsg(hwndMain, UM_LOADFILE, MPFROMP(pci->szFileName), MPVOID);
     1252        else
     1253          WinSendMsg(hwndMain, UM_LOADFILE, MPVOID, MPVOID);
     1254      }
     1255      if (*dcd->directory) {
     1256        if (hwndMain)
     1257          WinSendMsg(hwndMain,
     1258                     UM_SETUSERLISTNAME, MPFROMP(dcd->directory), MPVOID);
     1259        else
     1260          add_udir(FALSE, dcd->directory);
     1261      }
     1262      if (hwndMain)
     1263        PostMsg(hwndMain, UM_ADVISEFOCUS, MPFROMLONG(dcd->hwndFrame), MPVOID);
     1264    }
     1265    if (mp2) {
     1266      LastDir = hwnd;
     1267      PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
     1268      if (fSwitchTreeOnFocus && hwndTree && dcd && *dcd->directory)
     1269        WinSendMsg(hwndTree, UM_SHOWME, MPFROMP(dcd->directory), MPVOID);
     1270    }
     1271    break;
     1272
     1273  case UM_SETDIR:
     1274    if (dcd && mp1) {
     1275
     1276      CHAR fullname[CCHMAXPATH];
     1277
     1278      DosError(FERR_DISABLEHARDERR);
     1279      if (!DosQueryPathInfo((CHAR *) mp1,
     1280                            FIL_QUERYFULLNAME, fullname, sizeof(fullname))) {
     1281        if (stricmp(dcd->directory, fullname)) {
     1282          strcpy(dcd->previous, dcd->directory);
     1283          strcpy(dcd->directory, fullname);
     1284          DosEnterCritSec();
     1285          dcd->stopflag++;
     1286          DosExitCritSec();
     1287          if (!PostMsg(dcd->hwndObject, UM_RESCAN, MPVOID, MPFROMLONG(1L))) {
     1288            strcpy(dcd->directory, dcd->previous);
     1289            DosEnterCritSec();
     1290            dcd->stopflag--;
     1291            DosExitCritSec();
     1292          }
     1293          else if (*dcd->directory) {
     1294            if (hwndMain)
     1295              WinSendMsg(hwndMain,
     1296                         UM_SETUSERLISTNAME, MPFROMP(dcd->directory), MPVOID);
     1297            else
     1298              add_udir(FALSE, dcd->directory);
     1299          }
     1300        }
     1301      }
     1302    }
     1303    break;
     1304
     1305  case UM_RESCAN:
     1306    if (dcd) {
     1307
     1308      CNRINFO cnri;
     1309      CHAR s[CCHMAXPATH * 2], tf[81], tb[81];
     1310      PCNRITEM pci;
     1311
     1312      memset(&cnri, 0, sizeof(CNRINFO));
     1313      cnri.cb = sizeof(CNRINFO);
     1314      WinSendMsg(hwnd,
     1315                 CM_QUERYCNRINFO,
     1316                 MPFROMP(&cnri), MPFROMLONG(sizeof(CNRINFO)));
     1317      cnri.pszCnrTitle = dcd->directory;
     1318      WinSendMsg(hwnd,
     1319                 CM_SETCNRINFO, MPFROMP(&cnri), MPFROMLONG(CMA_CNRTITLE));
     1320      dcd->totalfiles = cnri.cRecords;
     1321      commafmt(tb, sizeof(tb), dcd->totalfiles);
     1322      CommaFmtULL(tf, sizeof(tf), dcd->ullTotalBytes, 'K');
     1323      sprintf(s, "%s / %s", tb, tf);
     1324      WinSetDlgItemText(dcd->hwndClient, DIR_TOTALS, s);
     1325      commafmt(tb, sizeof(tb), dcd->selectedfiles);
     1326      CommaFmtULL(tf, sizeof(tf), dcd->selectedbytes, 'K');
     1327      sprintf(s, "%s / %s", tb, tf);
     1328      WinSetDlgItemText(dcd->hwndClient, DIR_SELECTED, s);
     1329      if (hwndStatus &&
     1330          dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent)) {
     1331        PostMsg(dcd->hwndObject, UM_RESCAN2, MPVOID, MPVOID);
     1332        if ((fSplitStatus && hwndStatus2) || fMoreButtons) {
     1333          pci = WinSendMsg(hwnd,
     1334                           CM_QUERYRECORDEMPHASIS,
     1335                           MPFROMLONG(CMA_FIRST), MPFROMSHORT(CRA_CURSORED));
     1336          if (pci && (INT) pci != -1) {
     1337            if (fSplitStatus && hwndStatus2) {
     1338              CommaFmtULL(tb, sizeof(tb), pci->cbFile + pci->easize, ' ');
     1339              if (!fMoreButtons)
     1340                sprintf(s,
     1341                        " %s  %04u/%02u/%02u %02u:%02u:%02u  [%s]  %s",
     1342                        tb,
     1343                        pci->date.year,
     1344                        pci->date.month,
     1345                        pci->date.day,
     1346                        pci->time.hours,
     1347                        pci->time.minutes,
     1348                        pci->time.seconds,
     1349                        pci->pszDispAttr, pci->pszFileName);
     1350              else {
     1351                *tf = 0;
     1352                if (pci->cbFile + pci->easize > 1024) {
     1353                  CommaFmtULL(tf, sizeof(tf), pci->cbFile + pci->easize, 'K');
     1354                }
     1355                sprintf(s,
     1356                        GetPString(IDS_STATUSSIZETEXT),
     1357                        tb, *tf ? " (" : NullStr, tf, *tf ? ")" : NullStr);
     1358              }
     1359              WinSetWindowText(hwndStatus2, s);
     1360            }
     1361            else
     1362              WinSetWindowText(hwndStatus2, NullStr);
     1363            if (fMoreButtons) {
     1364              WinSetWindowText(hwndName, pci->pszFileName);
     1365              sprintf(s,
     1366                      "%04u/%02u/%02u %02u:%02u:%02u",
     1367                      pci->date.year,
     1368                      pci->date.month,
     1369                      pci->date.day,
     1370                      pci->time.hours, pci->time.minutes, pci->time.seconds);
     1371              WinSetWindowText(hwndDate, s);
     1372              WinSetWindowText(hwndAttr, pci->pszDispAttr);
     1373            }
     1374          }
     1375          else {
     1376            WinSetWindowText(hwndStatus2, NullStr);
     1377            WinSetWindowText(hwndName, NullStr);
     1378            WinSetWindowText(hwndDate, NullStr);
     1379            WinSetWindowText(hwndAttr, NullStr);
     1380          }
     1381        }
     1382      }
     1383    }
     1384    return 0;
     1385
     1386  case UM_SORTRECORD:
     1387    if (dcd) {
     1388
     1389      CNRINFO cnri;
     1390
     1391      memset(&cnri, 0, sizeof(CNRINFO));
     1392      cnri.cb = sizeof(CNRINFO);
     1393      WinSendMsg(hwnd,
     1394                 CM_QUERYCNRINFO,
     1395                 MPFROMP(&cnri), MPFROMLONG(sizeof(CNRINFO)));
     1396      cnri.pSortRecord = (PVOID) SortDirCnr;
     1397      WinSendMsg(hwnd,
     1398                 CM_SETCNRINFO, MPFROMP(&cnri), MPFROMLONG(CMA_PSORTRECORD));
     1399      WinSendMsg(hwnd,
     1400                 CM_SORTRECORD,
     1401                 MPFROMP(SortDirCnr), MPFROMLONG(dcd->sortFlags));
     1402    }
     1403    return 0;
     1404
     1405  case UM_SETUP:
     1406    if (dcd) {
     1407      if (!dcd->hwndObject) {
     1408        /*
     1409         * first time through -- set things up
     1410         */
     1411
     1412        CNRINFO cnri;
     1413
     1414        RestorePresParams(hwnd, "DirCnr");
     1415        LoadDetailsSwitches("DirCnr", dcd);
     1416        memset(&cnri, 0, sizeof(CNRINFO));
     1417        cnri.cb = sizeof(CNRINFO);
     1418        WinSendMsg(hwnd,
     1419                   CM_QUERYCNRINFO,
     1420                   MPFROMP(&cnri), MPFROMLONG(sizeof(CNRINFO)));
     1421        cnri.cyLineSpacing = 0;
     1422        cnri.cxTreeIndent = 12L;
     1423
     1424        cnri.flWindowAttr &= (~(CV_TREE | CV_ICON | CV_DETAIL | CV_TEXT));
     1425        cnri.flWindowAttr |= (CV_NAME | CA_DETAILSVIEWTITLES | CV_MINI |
     1426                              CV_FLOW);
     1427        cnri.pSortRecord = (PVOID) SortDirCnr;
     1428
     1429        {
     1430          ULONG size = sizeof(ULONG);
     1431
     1432          PrfQueryProfileData(fmprof,
     1433                              appname,
     1434                              "DirflWindowAttr",
     1435                              (PVOID) & cnri.flWindowAttr, &size);
     1436          size = sizeof(MASK);
     1437          if (!*dcd->mask.szMask &&
     1438              !dcd->mask.attrFile && !dcd->mask.antiattr) {
     1439            if (PrfQueryProfileSize(fmprof,
     1440                                    appname, "DirFilter", &size) && size) {
     1441              PrfQueryProfileData(fmprof,
     1442                                  appname, "DirFilter", &dcd->mask, &size);
     1443              SetMask(dcd->mask.szMask, &dcd->mask);
     1444            }
     1445            else
     1446              dcd->mask.attrFile = (FILE_READONLY | FILE_NORMAL |
     1447                                    FILE_ARCHIVED | FILE_DIRECTORY |
     1448                                    FILE_HIDDEN | FILE_SYSTEM);
     1449          }
     1450          *(dcd->mask.prompt) = 0;
     1451        }
     1452        if (dcd->flWindowAttr)
     1453          cnri.flWindowAttr = dcd->flWindowAttr;
     1454        else
     1455          dcd->flWindowAttr = cnri.flWindowAttr;
     1456        cnri.flWindowAttr &= (~(CA_MIXEDTARGETEMPH | CA_ORDEREDTARGETEMPH |
     1457                                CA_TITLEREADONLY | CA_TITLESEPARATOR));
     1458        cnri.flWindowAttr |= CV_FLOW;
     1459        dcd->flWindowAttr |= CV_FLOW;
     1460        if (WinWindowFromID(dcd->hwndFrame, FID_TITLEBAR))
     1461          cnri.flWindowAttr &= (~CA_CONTAINERTITLE);
     1462        else
     1463          cnri.flWindowAttr |= CA_CONTAINERTITLE;
     1464        if (!dcd->sortFlags)
     1465          dcd->sortFlags = sortFlags;
     1466        WinSendMsg(hwnd,
     1467                   CM_SETCNRINFO,
     1468                   MPFROMP(&cnri),
     1469                   MPFROMLONG(CMA_FLWINDOWATTR | CMA_LINESPACING |
     1470                              CMA_CXTREEINDENT | CMA_PSORTRECORD));
     1471        SetCnrCols(hwnd, FALSE);
     1472        AdjustCnrColsForPref(hwnd, NULL, dcd, FALSE);
     1473        if (_beginthread(MakeObjWin, NULL, 245760, (PVOID) dcd) == -1) {
     1474          Runtime_Error(pszSrcFile, __LINE__,
     1475                        GetPString(IDS_COULDNTSTARTTHREADTEXT));
     1476          PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
     1477          return 0;
     1478        }
     1479        else
     1480          DosSleep(64L);
     1481        WinEnableMenuItem(DirCnrMenu, IDM_FINDINTREE, (hwndTree != (HWND) 0));
     1482      }
     1483      SayFilter(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
     1484                                DIR_FILTER), &dcd->mask, FALSE);
     1485      SaySort(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
     1486                              DIR_SORT), dcd->sortFlags, FALSE);
     1487      SayView(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
     1488                              DIR_VIEW), dcd->flWindowAttr);
     1489    }
     1490    else {
     1491      PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
    6851492      return 0;
    686 
    687     case UM_SETUP:
    688       dcd = WinQueryWindowPtr(hwnd,QWL_USER);
    689       if(dcd) {
    690         /* set unique id */
    691         WinSetWindowUShort(hwnd,
    692                            QWS_ID,
    693                            DIROBJ_FRAME + (DIR_FRAME - dcd->id));
    694         dcd->hwndObject = hwnd;
    695         if(ParentIsDesktop(hwnd,dcd->hwndParent))
    696           DosSleep(250L);
     1493    }
     1494    return 0;
     1495
     1496  case WM_MENUEND:
     1497    if (dcd) {
     1498
     1499      HWND hwndMenu = (HWND) mp2;
     1500
     1501      if (hwndMenu == DirCnrMenu ||
     1502          hwndMenu == FileMenu || hwndMenu == DirMenu) {
     1503        MarkAll(hwnd, TRUE, FALSE, TRUE);
     1504        if (dcd->cnremphasized) {
     1505          WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPVOID,
     1506                     MPFROM2SHORT(FALSE, CRA_SOURCE));
     1507          dcd->cnremphasized = FALSE;
     1508        }
     1509      }
     1510    }
     1511    break;
     1512
     1513  case UM_OPENWINDOWFORME:
     1514    if (dcd) {
     1515      if (mp1 && !IsFile((CHAR *) mp1)) {
     1516        OpenDirCnr(hwnd, dcd->hwndParent, dcd->hwndFrame, FALSE, (char *)mp1);
     1517      }
     1518      else if (mp1 && IsFile(mp1) == 1) {
     1519        StartArcCnr(HWND_DESKTOP,
     1520                    dcd->hwndFrame, (CHAR *) mp1, 4, (ARC_TYPE *) mp2);
     1521      }
     1522    }
     1523    return 0;
     1524
     1525  case MM_PORTHOLEINIT:
     1526    if (dcd) {
     1527      switch (SHORT1FROMMP(mp1)) {
     1528      case 0:
     1529      case 1:
     1530        {
     1531          ULONG wmsg;
     1532
     1533          wmsg = (SHORT1FROMMP(mp1) == 0) ? UM_FILESMENU : UM_VIEWSMENU;
     1534          PortholeInit((HWND) WinSendMsg(dcd->hwndClient,
     1535                                         wmsg, MPVOID, MPVOID), mp1, mp2);
     1536        }
     1537        break;
     1538      }
     1539    }
     1540    break;
     1541
     1542  case UM_INITMENU:
     1543  case WM_INITMENU:
     1544    if (dcd) {
     1545      switch (SHORT1FROMMP(mp1)) {
     1546      case IDM_FILESMENU:
     1547        if (isalpha(*dcd->directory)) {
     1548          if (driveflags[toupper(*dcd->directory) - 'A'] & DRIVE_NOTWRITEABLE) {
     1549            WinEnableMenuItem((HWND) mp2, IDM_MOVEMENU, FALSE);
     1550            WinEnableMenuItem((HWND) mp2, IDM_RENAME, FALSE);
     1551            WinEnableMenuItem((HWND) mp2, IDM_MKDIR, FALSE);
     1552            WinEnableMenuItem((HWND) mp2, IDM_UNDELETE, FALSE);
     1553            WinEnableMenuItem((HWND) mp2, IDM_DELETESUBMENU, FALSE);
     1554            WinEnableMenuItem((HWND) mp2, IDM_DELETE, FALSE);
     1555            WinEnableMenuItem((HWND) mp2, IDM_EDIT, FALSE);
     1556            WinEnableMenuItem((HWND) mp2, IDM_EDITTEXT, FALSE);
     1557            WinEnableMenuItem((HWND) mp2, IDM_EDITBINARY, FALSE);
     1558            WinEnableMenuItem((HWND) mp2, IDM_ATTRS, FALSE);
     1559          }
     1560          else {
     1561            WinEnableMenuItem((HWND) mp2, IDM_MOVEMENU, TRUE);
     1562            WinEnableMenuItem((HWND) mp2, IDM_RENAME, TRUE);
     1563            WinEnableMenuItem((HWND) mp2, IDM_MKDIR, TRUE);
     1564            WinEnableMenuItem((HWND) mp2, IDM_UNDELETE, TRUE);
     1565            WinEnableMenuItem((HWND) mp2, IDM_DELETESUBMENU, TRUE);
     1566            WinEnableMenuItem((HWND) mp2, IDM_DELETE, TRUE);
     1567            WinEnableMenuItem((HWND) mp2, IDM_EDIT, TRUE);
     1568            WinEnableMenuItem((HWND) mp2, IDM_EDITTEXT, TRUE);
     1569            WinEnableMenuItem((HWND) mp2, IDM_EDITBINARY, TRUE);
     1570            WinEnableMenuItem((HWND) mp2, IDM_ATTRS, TRUE);
     1571          }
     1572        }
     1573        break;
     1574
     1575      case IDM_VIEWSMENU:
     1576        SetViewMenu((HWND) mp2, dcd->flWindowAttr);
     1577        WinEnableMenuItem((HWND) mp2, IDM_RESELECT,
     1578                          (dcd->lastselection != NULL));
     1579        if (isalpha(*dcd->directory)) {
     1580          if (driveflags[toupper(*dcd->directory) - 'A'] & DRIVE_NOTWRITEABLE)
     1581            WinEnableMenuItem((HWND) mp2, IDM_MKDIR, FALSE);
     1582          else
     1583            WinEnableMenuItem((HWND) mp2, IDM_MKDIR, TRUE);
     1584        }
     1585        WinEnableMenuItem((HWND) mp2,
     1586                          IDM_SELECTCOMPAREMENU,
     1587                          (CountDirCnrs(dcd->hwndParent) > 1));
     1588        break;
     1589
     1590      case IDM_DETAILSSETUP:
     1591        SetDetailsSwitches((HWND) mp2, dcd);
     1592        break;
     1593
     1594      case IDM_COMMANDSMENU:
     1595        SetupCommandMenu((HWND) mp2, hwnd);
     1596        break;
     1597
     1598      case IDM_SORTSUBMENU:
     1599        SetSortChecks((HWND) mp2, dcd->sortFlags);
     1600        break;
     1601
     1602      case IDM_WINDOWSMENU:
     1603        SetupWinList((HWND) mp2,
     1604                     (hwndMain) ? hwndMain : (HWND) 0, dcd->hwndFrame);
     1605        break;
     1606      }
     1607      dcd->hwndLastMenu = (HWND) mp2;
     1608    }
     1609    if (msg == WM_INITMENU)
     1610      break;
     1611    return 0;
     1612
     1613  case UM_FILTER:
     1614    if (dcd) {
     1615
     1616      PCNRITEM pci;
     1617
     1618      if (mp1) {
     1619        DosEnterCritSec();
     1620        SetMask((CHAR *) mp1, &dcd->mask);
     1621        DosExitCritSec();
     1622      }
     1623      dcd->suspendview = 1;
     1624      WinSendMsg(hwnd, CM_FILTER, MPFROMP(Filter), MPFROMP(&dcd->mask));
     1625      dcd->suspendview = 0;
     1626      if (fAutoView && hwndMain) {
     1627        pci = WinSendMsg(hwnd, CM_QUERYRECORDEMPHASIS,
     1628                         MPFROMLONG(CMA_FIRST), MPFROMSHORT(CRA_CURSORED));
     1629        if (pci && (INT) pci != -1 &&
     1630            (!(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_SLOW)))
     1631          WinSendMsg(hwndMain, UM_LOADFILE, MPFROMP(pci->szFileName), MPVOID);
     1632        else
     1633          WinSendMsg(hwndMain, UM_LOADFILE, MPVOID, MPVOID);
     1634      }
     1635      PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
     1636    }
     1637    return 0;
     1638
     1639  case UM_COMMAND:
     1640    if (mp1) {
     1641      if (dcd) {
     1642        if (!PostMsg(dcd->hwndObject, UM_COMMAND, mp1, mp2)) {
     1643          Runtime_Error(pszSrcFile, __LINE__, "PostMsg");
     1644          FreeListInfo((LISTINFO *) mp1);
     1645        }
     1646        else
     1647          return (MRESULT) TRUE;
    6971648      }
    6981649      else
    699         PostMsg(hwnd,WM_CLOSE,MPVOID,MPVOID);
    700       return 0;
    701 
    702     case UM_RESCAN2:
    703       dcd = WinQueryWindowPtr(hwnd,QWL_USER);
    704       if(dcd && dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent)) {
    705 
    706         FSALLOCATE fsa;
    707         CHAR s[CCHMAXPATH * 2];
    708         CHAR tf[64];
    709         CHAR tb[64];
    710         CHAR szFree[64];
    711 
    712         DosError(FERR_DISABLEHARDERR);
    713         if(!DosQueryFSInfo(toupper(*dcd->directory) - '@',
    714            FSIL_ALLOC,&fsa,sizeof(FSALLOCATE)))
     1650        FreeListInfo((LISTINFO *) mp1);
     1651    }
     1652    return 0;
     1653
     1654  case UM_NOTIFY:
     1655    if (mp2)
     1656      Notify((CHAR *) mp2);
     1657    return 0;
     1658
     1659  case UM_DRIVECMD:
     1660    if (mp1)
     1661      WinSendMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_SWITCH, 0), mp1);
     1662    return 0;
     1663
     1664  case WM_COMMAND:
     1665    DosError(FERR_DISABLEHARDERR);
     1666    if (dcd) {
     1667      switch (SHORT1FROMMP(mp1)) {
     1668      case IDM_SETTARGET:
     1669        SetTargetDir(hwnd, FALSE);
     1670        break;
     1671
     1672      case IDM_CREATE:
    7151673        {
    716           CommaFmtULL(tb,sizeof(tb),
    717                       (ULONGLONG)fsa.cUnitAvail * (fsa.cSectorUnit * fsa.cbSector),
    718                       'K');
    719           sprintf(szFree,"  {%s %s}",
    720                   tb,GetPString(IDS_FREETEXT));
    721         }
    722         else
    723           *szFree = 0;
    724         commafmt(tf,sizeof(tf),dcd->totalfiles);
    725         CommaFmtULL(tb,sizeof(tb),dcd->ullTotalBytes,' ');
    726         if (!fMoreButtons)
     1674          STRINGINPARMS sip;
     1675          CHAR filename[CCHMAXPATHCOMP];
     1676
     1677          memset(&sip, 0, sizeof(sip));
     1678          sip.help = GetPString(IDS_CREATETEXT);
     1679          sip.prompt = GetPString(IDS_CREATEPROMPTTEXT);
     1680          sip.inputlen = CCHMAXPATHCOMP - (strlen(dcd->directory) - 1);
     1681          strcpy(filename, "NEWFILE.TXT");
     1682          sip.ret = filename;
     1683          sip.title = GetPString(IDS_CREATETITLETEXT);
     1684          if (WinDlgBox(HWND_DESKTOP, hwnd, InputDlgProc, FM3ModHandle,
     1685                        STR_FRAME, &sip)) {
     1686            bstrip(sip.ret);
     1687            if (*sip.ret) {
     1688              CHAR newfile[CCHMAXPATH];
     1689              FILE *fp;
     1690              INT test;
     1691              PCNRITEM pci;
     1692
     1693              strcpy(newfile, dcd->directory);
     1694              if (newfile[strlen(newfile) - 1] != '\\')
     1695                strcat(newfile, "\\");
     1696              strcat(newfile, sip.ret);
     1697              test = IsFile(newfile);
     1698              if (test != 1)
     1699                fp = fopen(newfile, "w");
     1700              if (test != 1 && !fp) {
     1701                saymsg(MB_ENTER,
     1702                       hwnd,
     1703                       GetPString(IDS_ERRORTEXT),
     1704                       GetPString(IDS_CREATEERRORTEXT), newfile);
     1705              }
     1706              else {
     1707                if (fp) {
     1708                  WinSendMsg(hwnd, UM_UPDATERECORD, MPFROMP(newfile), MPVOID);
     1709                  fclose(fp);
     1710                }
     1711                if (*editor) {
     1712
     1713                  CHAR *dummy[2];
     1714
     1715                  dummy[0] = newfile;
     1716                  dummy[1] = NULL;
     1717                  ExecOnList(hwnd,
     1718                             editor, WINDOWED | SEPARATE, NULL, dummy, NULL);
     1719                }
     1720                else
     1721                  StartMLEEditor(dcd->hwndParent, 4, newfile, dcd->hwndFrame);
     1722                pci = FindCnrRecord(hwnd, newfile, NULL, TRUE, FALSE, TRUE);
     1723                if (pci && (INT) pci != -1)
     1724                  /* make sure that record shows in viewport */
     1725                  ShowCnrRecord(hwnd, (PMINIRECORDCORE) pci);
     1726              }
     1727            }
     1728          }
     1729        }
     1730        break;
     1731
     1732      case IDM_CONTEXTMENU:
    7271733        {
    728           sprintf(s," [%s / %s]%s%s%s%s %s",
    729                   tf,tb,szFree,
    730                   (*dcd->mask.szMask || dcd->mask.antiattr ||
    731                    dcd->mask.attrFile != ALLATTRS) ? "  (" : NullStr,
    732                   (*dcd->mask.szMask) ? dcd->mask.szMask :
    733                    (dcd->mask.antiattr ||
    734                     dcd->mask.attrFile != ALLATTRS) ?
    735                     GetPString(IDS_ALLTEXT) : NullStr,
    736                   (*dcd->mask.szMask || dcd->mask.antiattr ||
    737                    dcd->mask.attrFile != ALLATTRS) ? ")" : NullStr,
    738                   dcd->directory);
    739         }
    740         else
     1734          PCNRITEM pci;
     1735
     1736          pci = (PCNRITEM) CurrentRecord(hwnd);
     1737          PostMsg(hwnd, WM_CONTROL, MPFROM2SHORT(DIR_CNR, CN_CONTEXTMENU),
     1738                  MPFROMP(pci));
     1739        }
     1740        break;
     1741
     1742      case IDM_MAXIMIZE:
     1743        PostMsg(hwndMain, UM_MAXIMIZE, MPFROMLONG(dcd->hwndFrame), MPVOID);
     1744        break;
     1745
     1746      case IDM_SHOWALLFILESCNR:
     1747        StartSeeAll(HWND_DESKTOP, FALSE, dcd->directory);
     1748        break;
     1749
     1750      case IDM_SHOWALLFILES:
    7411751        {
    742           sprintf(s," [%s / %s]%s %s",
    743                   tf,tb,szFree,dcd->directory);
    744         }
    745         if (dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent))
    746           WinSetWindowText(hwndStatus,s);
    747       }
    748       return 0;
    749 
    750     case UM_FLESH:
    751       dcd = WinQueryWindowPtr(hwnd,QWL_USER);
    752       if(dcd) {
    753 
    754         PCNRITEM pci,pciC;
    755 
    756         pci = WinSendMsg(dcd->hwndCnr,
    757                          CM_QUERYRECORD,
    758                          MPVOID,
    759                          MPFROM2SHORT(CMA_FIRST,CMA_ITEMORDER));
    760         while(pci && (INT)pci != -1) {
    761           if(pci->attrFile & FILE_DIRECTORY) {
    762             pciC = WinSendMsg(dcd->hwndCnr,
    763                               CM_QUERYRECORD,
    764                               MPFROMP(pci),
    765                               MPFROM2SHORT(CMA_FIRSTCHILD,CMA_ITEMORDER));
    766             if(!pciC) {
    767               Stubby(dcd->hwndCnr,pci);
    768               DosSleep(0L);
    769             }
    770           }
    771           pci = WinSendMsg(dcd->hwndCnr,
    772                            CM_QUERYRECORD,
    773                            MPFROMP(pci),
    774                            MPFROM2SHORT(CMA_NEXT,CMA_ITEMORDER));
    775         }
    776         dcd->firsttree = TRUE;
    777       }
    778       return 0;
    779 
    780     case UM_RESCAN:
    781       /*
    782        * populate container
    783        */
    784       dcd = WinQueryWindowPtr(hwnd,QWL_USER);
    785       if (dcd) {
    786         DosEnterCritSec();
    787          if (dcd->stopflag)
    788            dcd->stopflag--;
    789          if (dcd->stopflag) {
    790            DosExitCritSec();
    791            return 0;
    792          }
    793         DosExitCritSec();
    794         if(mp1) {
    795           strcpy(dcd->previous,dcd->directory);
    796           strcpy(dcd->directory,(CHAR *)mp1);
    797         }
    798         MakeValidDir(dcd->directory);
    799         {
    800           CHAR s[CCHMAXPATH + 8];
    801 
    802           sprintf(s,
    803                   "%s%s%s",
    804                   (ParentIsDesktop(dcd->hwndFrame,(HWND)0)) ?
    805                    "VDir" :
    806                    NullStr,
    807                   (ParentIsDesktop(dcd->hwndFrame,(HWND)0)) ?
    808                    (!dcd->dontclose) ?
    809                     " Master: " :
    810                     ": " :
    811                    NullStr,
    812                   dcd->directory);
    813           WinSetWindowText(dcd->hwndFrame,
    814                            s);
    815           WinSetWindowText(WinWindowFromID(dcd->hwndFrame,FID_TITLEBAR),
    816                            s);
    817         }
    818         WinSendMsg(dcd->hwndCnr,
    819                    CM_REMOVERECORD,
    820                    MPVOID,
    821                    MPFROM2SHORT(0,CMA_FREE | CMA_INVALIDATE | CMA_ERASE));
    822         AdjustCnrColsForFSType(dcd->hwndCnr,
    823                                dcd->directory,
    824                                dcd);
    825         dcd->ullTotalBytes = dcd->totalfiles =
    826           dcd->selectedfiles = dcd->selectedbytes = 0;
    827         WinSetDlgItemText(dcd->hwndClient,
    828                           DIR_TOTALS,
    829                           "0 / 0k");
    830         WinSetDlgItemText(dcd->hwndClient,
    831                           DIR_SELECTED,
    832                           "0 / 0k");
    833         if(hwndStatus &&
    834            dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent)) {
    835           WinSetWindowText(hwndStatus,
    836                            GetPString(IDS_SCANNINGTEXT));
    837           if(hwndMain)
    838             WinSendMsg(hwndMain,
    839                        UM_LOADFILE,
    840                        MPVOID,
    841                        MPVOID);
    842         }
    843         if(fSwitchTree && hwndTree) {
    844           if(hwndMain) {
    845             if(TopWindow(hwndMain,
    846                          (HWND)0) == dcd->hwndFrame)
    847               WinSendMsg(hwndTree,
    848                          UM_SHOWME,
    849                          MPFROMP(dcd->directory),
    850                          MPVOID);
    851           }
    852           else
    853             WinSendMsg(hwndTree,
    854                        UM_SHOWME,
    855                        MPFROMP(dcd->directory),
    856                        MPVOID);
    857         }
    858         dcd->firsttree = FALSE;
    859         // fixme to check errors
    860         FillDirCnr(dcd->hwndCnr,
    861                    dcd->directory,
    862                    dcd,
    863                    &dcd->ullTotalBytes);
    864         PostMsg(dcd->hwndCnr,
    865                 UM_RESCAN,
    866                 MPVOID,
    867                 MPVOID);
    868         if(mp2 &&
    869            !fLeaveTree &&
    870            (dcd->flWindowAttr & CV_TREE)) {
    871 
    872           ULONG   flWindowAttr = dcd->flWindowAttr;
    873           CNRINFO cnri;
    874 
    875           flWindowAttr &= (~(CV_NAME | CV_TREE | CV_ICON | CV_DETAIL | CV_TEXT));
    876           if(dcd->lastattr) {
    877             if(dcd->lastattr & CV_TEXT)
    878               flWindowAttr |= CV_TEXT;
    879             else if(dcd->lastattr & CV_DETAIL)
    880               flWindowAttr |= CV_DETAIL;
    881             else if(dcd->lastattr & CV_ICON)
    882               flWindowAttr |= CV_ICON;
    883             else
    884               flWindowAttr |= CV_NAME;
    885           }
    886           else
    887             flWindowAttr |= CV_NAME;
    888           flWindowAttr |= CV_FLOW;
    889           memset(&cnri,0,sizeof(CNRINFO));
    890           cnri.cb = sizeof(CNRINFO);
    891           if(WinSendMsg(dcd->hwndCnr,CM_QUERYCNRINFO,MPFROMP(&cnri),
    892                         MPFROMLONG(sizeof(CNRINFO)))) {
    893             dcd->flWindowAttr = cnri.flWindowAttr = flWindowAttr;
    894             WinSendMsg(dcd->hwndCnr,CM_SETCNRINFO,
    895                        MPFROMP(&cnri),
    896                        MPFROMLONG(CMA_FLWINDOWATTR));
    897             SayView(WinWindowFromID(dcd->hwndClient,
    898                                     DIR_VIEW),dcd->flWindowAttr);
    899           }
    900         }
    901         if(dcd->flWindowAttr & CV_TREE)
    902           PostMsg(dcd->hwndObject,UM_FLESH,MPVOID,MPVOID);
    903         if(*dcd->previous) {
    904           if(strlen(dcd->previous) > strlen(dcd->directory) &&
    905              !strnicmp(dcd->directory,dcd->previous,strlen(dcd->directory))) {
    906 
    907             PCNRITEM     pci;
    908 
    909             pci = FindCnrRecord(dcd->hwndCnr,
    910                                 dcd->previous,
    911                                 NULL,
    912                                 TRUE,
    913                                 FALSE,
    914                                 TRUE);
    915             if(pci && (INT)pci != -1) {
    916               /* make found item current (cursored) item */
    917               WinSendMsg(dcd->hwndCnr,CM_SETRECORDEMPHASIS,MPFROMP(pci),
    918                          MPFROM2SHORT(TRUE,CRA_CURSORED));
    919               /* make sure that record shows in viewport */
    920               ShowCnrRecord(dcd->hwndCnr,(PMINIRECORDCORE)pci);
    921             }
    922           }
    923         }
    924       }
    925       return 0;
    926 
    927     case UM_COMMAND:
    928       if(mp1) {
    929 
    930         LISTINFO *li = (LISTINFO *)mp1;
    931 
    932         switch(li->type) {
    933           case IDM_DOITYOURSELF:
    934           case IDM_APPENDTOCLIP:
    935           case IDM_SAVETOCLIP:
    936           case IDM_ARCHIVE:
    937           case IDM_ARCHIVEM:
    938           case IDM_VIEWTEXT:
    939           case IDM_VIEWBINARY:
    940           case IDM_VIEWARCHIVE:
    941           case IDM_VIEW:
    942           case IDM_EDITTEXT:
    943           case IDM_EDITBINARY:
    944           case IDM_EDIT:
    945           case IDM_OBJECT:
    946           case IDM_SHADOW:
    947           case IDM_SHADOW2:
    948           case IDM_PRINT:
    949           case IDM_ATTRS:
    950           case IDM_DELETE:
    951           case IDM_PERMDELETE:
    952           case IDM_MCIPLAY:
    953           case IDM_UPDATE:
    954             if(PostMsg(hwnd,UM_MASSACTION,mp1,mp2))
    955               return (MRESULT)TRUE;
    956             break;
    957           default:
    958             if(PostMsg(hwnd,UM_ACTION,mp1,mp2))
    959               return (MRESULT)TRUE;
    960         }
    961       }
    962       return 0;
    963 
    964     case UM_SELECT:
    965       dcd = WinQueryWindowPtr(hwnd,QWL_USER);
    966       if(dcd) {
    967         switch(SHORT1FROMMP(mp1)) {
    968           case IDM_SELECTBOTH:
    969           case IDM_SELECTONE:
    970           case IDM_SELECTMORE:
    971           case IDM_SELECTNEWER:
    972           case IDM_SELECTOLDER:
    973           case IDM_SELECTBIGGER:
    974           case IDM_SELECTSMALLER:
    975           case IDM_DESELECTBOTH:
    976           case IDM_DESELECTONE:
    977           case IDM_DESELECTMORE:
    978           case IDM_DESELECTNEWER:
    979           case IDM_DESELECTOLDER:
    980           case IDM_DESELECTBIGGER:
    981           case IDM_DESELECTSMALLER:
    982             SpecialSelect2(dcd->hwndParent,SHORT1FROMMP(mp1));
    983             break;
    984           case IDM_SELECTLIST:
    985             {
    986               CHAR filename[CCHMAXPATH],*p,*pp;
    987               ULONG size;
    988 
    989               strcpy(filename,"*.LST");
    990               size = CCHMAXPATH;
    991               PrfQueryProfileData(fmprof,appname,"SaveToListName",
    992                                   filename,&size);
    993               pp = strrchr(filename,'\\');
    994               if(!pp)
    995                 pp = filename;
    996               p = strrchr(pp,'.');
    997               if(p && *(p + 1) && p > pp + 1) {
    998                 if(pp > filename)
    999                   pp++;
    1000                 *pp = '*';
    1001                 pp++;
    1002                 if(p > pp)
    1003                   memmove(pp,p,strlen(p) + 1);
    1004               }
    1005               if(insert_filename(hwnd,filename,FALSE,FALSE))
    1006                 SelectList(dcd->hwndCnr,TRUE,FALSE,FALSE,NULL,filename,NULL);
    1007             }
    1008             break;
    1009           case IDM_SELECTALL:
    1010             SelectAll(dcd->hwndCnr,TRUE,TRUE,NULL,NULL,FALSE);
    1011             break;
    1012           case IDM_DESELECTALL:
    1013             DeselectAll(dcd->hwndCnr,TRUE,TRUE,NULL,NULL,FALSE);
    1014             break;
    1015           case IDM_SELECTALLFILES:
    1016             SelectAll(dcd->hwndCnr,TRUE,FALSE,NULL,NULL,FALSE);
    1017             break;
    1018           case IDM_DESELECTALLFILES:
    1019             DeselectAll(dcd->hwndCnr,TRUE,FALSE,NULL,NULL,FALSE);
    1020             break;
    1021           case IDM_SELECTALLDIRS:
    1022             SelectAll(dcd->hwndCnr,FALSE,TRUE,NULL,NULL,FALSE);
    1023             break;
    1024           case IDM_DESELECTALLDIRS:
    1025             DeselectAll(dcd->hwndCnr,FALSE,TRUE,NULL,NULL,FALSE);
    1026             break;
    1027           case IDM_DESELECTMASK:
    1028           case IDM_SELECTMASK:
    1029             {
    1030               MASK     mask;
    1031               PCNRITEM pci = (PCNRITEM)mp2;
    1032 
    1033               memset(&mask,0,sizeof(MASK));
    1034               mask.fNoAttribs = TRUE;
    1035               mask.fNoDirs = TRUE;
    1036               mask.fText = TRUE;
    1037               strcpy(mask.prompt,
    1038                      GetPString((SHORT1FROMMP(mp1) == IDM_SELECTMASK) ?
    1039                                 IDS_SELECTFILTERTEXT :
    1040                                 IDS_DESELECTFILTERTEXT));
    1041               if(pci && (INT)pci != -1)
    1042                 strcpy(mask.szMask,pci->szFileName);
    1043               if(WinDlgBox(HWND_DESKTOP,
    1044                            dcd->hwndCnr,
    1045                            PickMaskDlgProc,
    1046                            FM3ModHandle,
    1047                            MSK_FRAME,
    1048                            MPFROMP(&mask))) {
    1049                 if(SHORT1FROMMP(mp1) == IDM_SELECTMASK)
    1050                   SelectAll(dcd->hwndCnr,
    1051                             TRUE,
    1052                             TRUE,
    1053                             mask.szMask,
    1054                             mask.szText,
    1055                             FALSE);
    1056                 else
    1057                   DeselectAll(dcd->hwndCnr,
    1058                               TRUE,
    1059                               TRUE,
    1060                               mask.szMask,
    1061                               mask.szText,
    1062                               FALSE);
    1063               }
    1064             }
    1065             break;
    1066 
    1067           case IDM_DESELECTCLIP:
    1068           case IDM_SELECTCLIP:
    1069             {
    1070               CHAR **list;
    1071 
    1072               list = ListFromClipboard(hwnd);
    1073               if(list) {
    1074                 SelectList(dcd->hwndCnr,TRUE,FALSE,
    1075                            (SHORT1FROMMP(mp1) == IDM_DESELECTCLIP),
    1076                            NULL,NULL,list);
    1077                 FreeList(list);
    1078               }
    1079             }
    1080             break;
    1081 
    1082           case IDM_INVERT:
    1083             InvertAll(dcd->hwndCnr);
    1084             break;
    1085         }
    1086       }
    1087       return 0;
    1088 
    1089     case UM_MASSACTION:
    1090       if(mp1) {
    1091 
    1092         dcd = WinQueryWindowPtr(hwnd,QWL_USER);
    1093         if(dcd) {
    1094 
    1095           WORKER *wk;
    1096 
    1097           wk = xmallocz(sizeof(WORKER),pszSrcFile,__LINE__);
    1098           if (!wk)
    1099             FreeListInfo((LISTINFO *)mp1);
     1752          PCNRITEM pci;
     1753
     1754          pci = WinSendMsg(hwnd, CM_QUERYRECORDEMPHASIS,
     1755                           MPFROMLONG(CMA_FIRST), MPFROMSHORT(CRA_CURSORED));
     1756          if (pci && (INT) pci != -1) {
     1757
     1758            static CHAR dirname[CCHMAXPATH];
     1759
     1760            strcpy(dirname, pci->szFileName);
     1761            MakeValidDir(dirname);
     1762            StartSeeAll(HWND_DESKTOP, FALSE, dirname);
     1763          }
     1764        }
     1765        break;
     1766
     1767      case IDM_FINDINTREE:
     1768        if (hwndTree)
     1769          WinSendMsg(hwndTree, UM_SHOWME, MPFROMP(dcd->directory),
     1770                     MPFROMLONG(1L));
     1771        break;
     1772
     1773      case IDM_BEGINEDIT:
     1774        OpenEdit(hwnd);
     1775        break;
     1776
     1777      case IDM_ENDEDIT:
     1778        WinSendMsg(hwnd, CM_CLOSEEDIT, MPVOID, MPVOID);
     1779        break;
     1780
     1781      case IDM_SHOWSELECT:
     1782        QuickPopup(hwnd,
     1783                   dcd,
     1784                   CheckMenu(&DirCnrMenu, DIRCNR_POPUP), IDM_SELECTSUBMENU);
     1785        break;
     1786
     1787      case IDM_SHOWSORT:
     1788        QuickPopup(hwnd, dcd, CheckMenu(&DirCnrMenu, DIRCNR_POPUP),
     1789                   IDM_SORTSUBMENU);
     1790        break;
     1791
     1792      case IDM_VIEWORARC:
     1793        {
     1794          SWP swp;
     1795          PCNRITEM pci;
     1796
     1797          pci = (PCNRITEM) WinSendMsg(hwnd, CM_QUERYRECORDEMPHASIS,
     1798                                      MPFROMLONG(CMA_FIRST),
     1799                                      MPFROMSHORT(CRA_CURSORED));
     1800          if (pci && (INT) pci != -1) {
     1801            WinQueryWindowPos(dcd->hwndFrame, &swp);
     1802            DefaultViewKeys(hwnd,
     1803                            dcd->hwndFrame,
     1804                            dcd->hwndParent, &swp, pci->szFileName);
     1805          }
     1806        }
     1807        break;
     1808
     1809      case IDM_NOTEBOOK:
     1810        if (!ParentIsDesktop(dcd->hwndParent, dcd->hwndParent))
     1811          PostMsg(dcd->hwndParent, msg, mp1, mp2);
     1812        else
     1813          WinDlgBox(HWND_DESKTOP, hwnd, CfgDlgProc, FM3ModHandle,
     1814                    CFG_FRAME, (PVOID) "Directory");
     1815        break;
     1816
     1817      case IDM_QTREE:
     1818      case IDM_TREE:
     1819        {
     1820          CHAR newpath[CCHMAXPATH];
     1821          APIRET rc;
     1822          PCNRITEM pci;
     1823
     1824          if (SHORT1FROMMP(mp1) == IDM_TREE) {
     1825            pci = (PCNRITEM) CurrentRecord(hwnd);
     1826            if (pci && (INT) pci != -1)
     1827              strcpy(newpath, pci->szFileName);
     1828            else
     1829              strcpy(newpath, dcd->directory);
     1830          }
     1831          else
     1832            strcpy(newpath, dcd->directory);
     1833          MakeValidDir(newpath);
     1834          rc = WinDlgBox(HWND_DESKTOP, dcd->hwndClient, ObjCnrDlgProc,
     1835                         FM3ModHandle, QTREE_FRAME, MPFROMP(newpath));
     1836          if (rc)
     1837            WinSendMsg(hwnd, UM_SETDIR, MPFROMP(newpath), MPVOID);
     1838        }
     1839        break;
     1840
     1841      case IDM_RESELECT:
     1842        SelectList(hwnd, TRUE, FALSE, FALSE, NULL, NULL, dcd->lastselection);
     1843        break;
     1844
     1845      case IDM_HELP:
     1846        if (hwndHelp) {
     1847          if (!ParentIsDesktop(dcd->hwndFrame, dcd->hwndParent))
     1848            PostMsg(dcd->hwndParent, UM_COMMAND, mp1, mp2);
     1849          else
     1850            WinSendMsg(hwndHelp, HM_HELP_CONTENTS, MPVOID, MPVOID);
     1851        }
     1852        break;
     1853
     1854      case IDM_WINDOWDLG:
     1855        if (!ParentIsDesktop(dcd->hwndFrame, dcd->hwndParent))
     1856          PostMsg(dcd->hwndParent, UM_COMMAND,
     1857                  MPFROM2SHORT(IDM_WINDOWDLG, 0), MPVOID);
     1858        break;
     1859
     1860      case IDM_SORTSMARTNAME:
     1861      case IDM_SORTNAME:
     1862      case IDM_SORTFILENAME:
     1863      case IDM_SORTSIZE:
     1864      case IDM_SORTEASIZE:
     1865      case IDM_SORTFIRST:
     1866      case IDM_SORTLAST:
     1867      case IDM_SORTLWDATE:
     1868      case IDM_SORTLADATE:
     1869      case IDM_SORTCRDATE:
     1870      case IDM_SORTSUBJECT:
     1871        dcd->sortFlags &= (SORT_REVERSE | SORT_DIRSFIRST | SORT_DIRSLAST);
     1872      case IDM_SORTDIRSFIRST:
     1873      case IDM_SORTDIRSLAST:
     1874      case IDM_SORTREVERSE:
     1875        switch (SHORT1FROMMP(mp1)) {
     1876        case IDM_SORTSUBJECT:
     1877          dcd->sortFlags |= SORT_SUBJECT;
     1878          break;
     1879        case IDM_SORTSMARTNAME:
     1880        case IDM_SORTFILENAME:
     1881          dcd->sortFlags |= SORT_FILENAME;
     1882          break;
     1883        case IDM_SORTSIZE:
     1884          dcd->sortFlags |= SORT_SIZE;
     1885          break;
     1886        case IDM_SORTEASIZE:
     1887          dcd->sortFlags |= SORT_EASIZE;
     1888          break;
     1889        case IDM_SORTFIRST:
     1890          dcd->sortFlags |= SORT_FIRSTEXTENSION;
     1891          break;
     1892        case IDM_SORTLAST:
     1893          dcd->sortFlags |= SORT_LASTEXTENSION;
     1894          break;
     1895        case IDM_SORTLWDATE:
     1896          dcd->sortFlags |= SORT_LWDATE;
     1897          break;
     1898        case IDM_SORTLADATE:
     1899          dcd->sortFlags |= SORT_LADATE;
     1900          break;
     1901        case IDM_SORTCRDATE:
     1902          dcd->sortFlags |= SORT_CRDATE;
     1903          break;
     1904        case IDM_SORTDIRSFIRST:
     1905          if (dcd->sortFlags & SORT_DIRSFIRST)
     1906            dcd->sortFlags &= (~SORT_DIRSFIRST);
    11001907          else {
    1101             wk->size = sizeof(WORKER);
    1102             wk->hwndCnr = dcd->hwndCnr;
    1103             wk->hwndParent = dcd->hwndParent;
    1104             wk->hwndFrame = dcd->hwndFrame;
    1105             wk->hwndClient = dcd->hwndClient;
    1106             wk->li = (LISTINFO *)mp1;
    1107             strcpy(wk->directory,dcd->directory);
    1108             if(_beginthread(MassAction,NULL,122880,(PVOID)wk) == -1) {
    1109               Runtime_Error(pszSrcFile, __LINE__, GetPString(IDS_COULDNTSTARTTHREADTEXT));
    1110               free(wk);
    1111               FreeListInfo((LISTINFO *)mp1);
    1112             }
    1113           }
    1114         }
    1115       }
    1116       return 0;
    1117 
    1118     case UM_ACTION:
    1119       if(mp1) {
    1120 
    1121         dcd = WinQueryWindowPtr(hwnd,QWL_USER);
    1122         if(dcd) {
    1123 
    1124           WORKER *wk;
    1125 
    1126           wk = xmallocz(sizeof(WORKER),pszSrcFile,__LINE__);
    1127           if (!wk)
    1128             FreeListInfo((LISTINFO *)mp1);
     1908            dcd->sortFlags |= SORT_DIRSFIRST;
     1909            dcd->sortFlags &= (~SORT_DIRSLAST);
     1910          }
     1911          break;
     1912        case IDM_SORTDIRSLAST:
     1913          if (dcd->sortFlags & SORT_DIRSLAST)
     1914            dcd->sortFlags &= (~SORT_DIRSLAST);
    11291915          else {
    1130             wk->size = sizeof(WORKER);
    1131             wk->hwndCnr = dcd->hwndCnr;
    1132             wk->hwndParent = dcd->hwndParent;
    1133             wk->hwndFrame = dcd->hwndFrame;
    1134             wk->hwndClient = dcd->hwndClient;
    1135             wk->li = (LISTINFO *)mp1;
    1136             strcpy(wk->directory,dcd->directory);
    1137             if(_beginthread(Action,NULL,122880,(PVOID)wk) == -1) {
    1138               Runtime_Error(pszSrcFile, __LINE__, GetPString(IDS_COULDNTSTARTTHREADTEXT));
    1139               free(wk);
    1140               FreeListInfo((LISTINFO *)mp1);
    1141             }
    1142           }
    1143         }
    1144       }
    1145       return 0;
    1146 
    1147     case WM_CLOSE:
    1148       WinDestroyWindow(hwnd);
    1149       break;
    1150 
    1151     case WM_DESTROY:
    1152       dcd = WinQueryWindowPtr(hwnd,QWL_USER);
    1153       if(dcd) {
    1154         if(dcd->hwndRestore)
    1155           WinSetWindowPos(dcd->hwndRestore,
    1156                           HWND_TOP,
    1157                           0,
    1158                           0,
    1159                           0,
    1160                           0,
    1161                           SWP_RESTORE | SWP_SHOW | SWP_ACTIVATE | SWP_ZORDER);
    1162         FreeList(dcd->lastselection);
    1163         free(dcd);
    1164         DosPostEventSem(CompactSem);
    1165       }
    1166       if(!PostMsg((HWND)0,
    1167                   WM_QUIT,
    1168                   MPVOID,
    1169                   MPVOID))
    1170         WinSendMsg((HWND)0,
    1171                    WM_QUIT,
    1172                    MPVOID,
    1173                    MPVOID);
    1174       break;
    1175   }
    1176   return WinDefWindowProc(hwnd,msg,mp1,mp2);
    1177 }
    1178 
    1179 
    1180 MRESULT EXPENTRY DirCnrWndProc (HWND hwnd,ULONG msg,MPARAM mp1,MPARAM mp2)
    1181 {
    1182   DIRCNRDATA *dcd = WinQueryWindowPtr(hwnd,QWL_USER);
    1183 
    1184   switch(msg) {
    1185     case DM_PRINTOBJECT:
    1186       return MRFROMLONG(DRR_TARGET);
    1187 
    1188     case DM_DISCARDOBJECT:
    1189       if (dcd)
    1190         return WinSendMsg(dcd->hwndObject,msg,mp1,mp2);
    1191       else
    1192         return MRFROMLONG(DRR_TARGET);
    1193 
    1194     case WM_CHAR:
    1195       shiftstate = (SHORT1FROMMP(mp1) & (KC_SHIFT | KC_ALT | KC_CTRL));
    1196       if (SHORT1FROMMP(mp1) & KC_KEYUP)
    1197         return (MRESULT)TRUE;
    1198       if (SHORT1FROMMP(mp1) & KC_VIRTUALKEY) {
    1199         switch(SHORT2FROMMP(mp2)) {
    1200           case VK_INSERT:
    1201             if ((shiftstate & KC_CTRL) == KC_CTRL)
    1202               PostMsg(hwnd,
    1203                       WM_COMMAND,
    1204                       MPFROM2SHORT(IDM_MKDIR,0),
    1205                       MPVOID);
    1206             else if ((shiftstate & KC_ALT) == KC_ALT)
    1207               PostMsg(hwnd,
    1208                       WM_COMMAND,
    1209                       MPFROM2SHORT(IDM_CREATE,0),
    1210                       MPVOID);
    1211             break;
    1212           case VK_PAGEUP:
    1213             if ((shiftstate & KC_CTRL) == KC_CTRL)
    1214               PostMsg(hwnd,
    1215                       WM_COMMAND,
    1216                       MPFROM2SHORT(IDM_PARENT,0),
    1217                       MPVOID);
    1218             break;
    1219           case VK_PAGEDOWN:
    1220             if ((shiftstate & KC_CTRL) == KC_CTRL)
    1221               PostMsg(hwnd,
    1222                       WM_COMMAND,
    1223                       MPFROM2SHORT(IDM_PREVIOUS,0),
    1224                       MPVOID);
    1225             break;
    1226           case VK_HOME:
    1227             if ((shiftstate & KC_CTRL) == KC_CTRL && dcd) {
    1228 
    1229               CHAR s[CCHMAXPATH],*p;
    1230 
    1231               strcpy(s,dcd->directory);
    1232               p = strchr(s,'\\');
    1233               if (p) {
    1234                 p++;
    1235                 *p = 0;
    1236                 WinSendMsg(hwnd,
    1237                            UM_SETDIR,
    1238                            MPFROMP(s),
    1239                            MPVOID);
    1240               }
    1241             }
    1242             break;
    1243           case VK_DELETE:
    1244             if ((shiftstate & KC_CTRL) == KC_CTRL)
    1245               PostMsg(hwnd,WM_COMMAND,MPFROM2SHORT(IDM_PERMDELETE,0),MPVOID);
    1246             else if ((shiftstate & KC_SHIFT) == KC_SHIFT)
    1247               PostMsg(hwnd,WM_COMMAND,MPFROM2SHORT(IDM_SAVETOCLIP,0),MPVOID);
    1248             else
    1249               PostMsg(hwnd,WM_COMMAND,MPFROM2SHORT(IDM_DELETE,0),MPVOID);
    1250             break;
    1251         }
    1252       }
    1253       if (shiftstate || fNoSearch)
    1254         break;
    1255       if (SHORT1FROMMP(mp1) & KC_CHAR) {
    1256 
    1257         ULONG        thistime,len;
    1258         SEARCHSTRING srch;
    1259         PCNRITEM     pci;
    1260 
    1261         if (!dcd)
    1262           break;
    1263         switch(SHORT1FROMMP(mp2)) {
    1264           case '\x1b':
    1265           case '\r':
    1266           case '\n':
    1267             dcd->lasttime = 0;
    1268             *dcd->szCommonName = 0;
    1269             break;
    1270           default:
    1271             thistime = WinQueryMsgTime(WinQueryAnchorBlock(hwnd));
    1272             if (thistime > dcd->lasttime + 1250)
    1273               *dcd->szCommonName = 0;
    1274             dcd->lasttime = thistime;
    1275             if (SHORT1FROMMP(mp2) == ' ' && !dcd->szCommonName)
    1276               break;
    1277 KbdRetry:
    1278             len = strlen(dcd->szCommonName);
    1279             if (len >= CCHMAXPATH - 1) {
    1280               *dcd->szCommonName = 0;
    1281               len = 0;
    1282             }
    1283             dcd->szCommonName[len] = toupper(SHORT1FROMMP(mp2));
    1284             dcd->szCommonName[len + 1] = 0;
    1285             memset(&srch,0,sizeof(SEARCHSTRING));
    1286             srch.cb = (ULONG)sizeof(SEARCHSTRING);
    1287             srch.pszSearch = (PSZ)dcd->szCommonName;
    1288             srch.fsPrefix = TRUE;
    1289             srch.fsCaseSensitive = FALSE;
    1290             srch.usView = CV_ICON;
    1291             pci = WinSendMsg(hwnd,CM_SEARCHSTRING,MPFROMP(&srch),
    1292                              MPFROMLONG(CMA_FIRST));
    1293             if (pci && (INT)pci != -1) {
    1294 
    1295               USHORT          attrib = CRA_CURSORED;
    1296 
    1297               /* make found item current item */
    1298               if (!stricmp(pci->pszFileName,dcd->szCommonName))
    1299                 attrib |= CRA_SELECTED;
    1300               WinSendMsg(hwnd,CM_SETRECORDEMPHASIS,MPFROMP(pci),
    1301                          MPFROM2SHORT(TRUE,attrib));
    1302               /* make sure that record shows in viewport */
    1303               ShowCnrRecord(hwnd,(PMINIRECORDCORE)pci);
    1304               return (MRESULT)TRUE;
    1305             }
    1306             else {
    1307               if (SHORT1FROMMP(mp2) == ' ') {
    1308                 dcd->szCommonName[len] = 0;
    1309                 break;
    1310               }
    1311               *dcd->szCommonName = 0;
    1312               dcd->lasttime = 0;
    1313               if (len)           // retry as first letter if no match
    1314                 goto KbdRetry;
    1315             }
    1316             break;
    1317         }
    1318       }
    1319       break;
    1320 
    1321     case WM_MOUSEMOVE:
    1322     case WM_BUTTON1UP:
    1323     case WM_BUTTON2UP:
    1324     case WM_BUTTON3UP:
    1325     case WM_CHORD:
    1326       shiftstate = (SHORT2FROMMP(mp2) & (KC_ALT | KC_SHIFT | KC_CTRL));
    1327       break;
    1328 
    1329     case WM_BUTTON1MOTIONEND:
    1330       {
    1331         CNRINFO cnri;
    1332 
    1333         memset(&cnri,0,sizeof(CNRINFO));
    1334         cnri.cb = sizeof(CNRINFO);
    1335         if (WinSendMsg(hwnd,CM_QUERYCNRINFO,MPFROMP(&cnri),
    1336                       MPFROMLONG(sizeof(CNRINFO)))) {
    1337           if (cnri.flWindowAttr & CV_DETAIL)
    1338             PrfWriteProfileData(fmprof,appname,"CnrSplitBar",
    1339                                 (PVOID)&cnri.xVertSplitbar,sizeof(LONG));
    1340         }
    1341       }
    1342       break;
    1343 
    1344     case UM_COMPARE:
    1345       if (dcd && mp1 && mp2) {
    1346 
    1347         COMPARE *cmp;
    1348         CHAR    *leftdir = (CHAR *)mp1,*rightdir = (CHAR *)mp2;
    1349 
    1350         if (!IsFile(leftdir) &&
    1351            !IsFile(rightdir)) {
    1352           cmp = xmallocz(sizeof(COMPARE),pszSrcFile,__LINE__);
    1353           if (cmp) {
    1354             cmp->size = sizeof(COMPARE);
    1355             strcpy(cmp->leftdir,leftdir);
    1356             strcpy(cmp->rightdir,rightdir);
    1357             cmp->hwndParent = dcd->hwndParent;
    1358             cmp->dcd.hwndParent = dcd->hwndParent;
    1359             WinDlgBox(HWND_DESKTOP,
    1360                       HWND_DESKTOP,
    1361                       CompareDlgProc,
    1362                       FM3ModHandle,
    1363                       COMP_FRAME,
    1364                       MPFROMP(cmp));
    1365           }
    1366         }
    1367       }
    1368       return 0;
    1369 
    1370     case WM_PRESPARAMCHANGED:
    1371       PresParamChanged(hwnd,
    1372                        "DirCnr",
    1373                        mp1,
    1374                        mp2);
    1375       break;
    1376 
    1377     case UM_UPDATERECORDLIST:
    1378       if (dcd && mp1)
    1379         WinSendMsg(dcd->hwndObject,
    1380                    msg,
    1381                    mp1,
    1382                    mp2);
    1383       return 0;
    1384 
    1385     case UM_UPDATERECORD:
    1386       if (dcd && mp1) {
    1387 
    1388         CHAR    *filename;
    1389 
    1390         filename = mp1;
    1391         if (filename)
    1392           UpdateCnrRecord(hwnd,
    1393                           filename,
    1394                           TRUE,
    1395                           dcd);
    1396       }
    1397       return 0;
    1398 
    1399     case WM_SETFOCUS:
    1400       /*
    1401        * put name of our window (directory name) on status line
    1402        */
    1403       if (dcd && hwndStatus && mp2) {
    1404 
    1405         PCNRITEM   pci = NULL;
    1406 
    1407         if (fAutoView && hwndMain) {
    1408           pci = WinSendMsg(hwnd,CM_QUERYRECORDEMPHASIS,MPFROMLONG(CMA_FIRST),
    1409                            MPFROMSHORT(CRA_CURSORED));
    1410           if (pci && (INT)pci != -1 &&
    1411              (!(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_SLOW)))
    1412             WinSendMsg(hwndMain,
    1413                        UM_LOADFILE,
    1414                        MPFROMP(pci->szFileName),
    1415                        MPVOID);
    1416           else
    1417             WinSendMsg(hwndMain,
    1418                        UM_LOADFILE,
    1419                        MPVOID,
    1420                        MPVOID);
    1421         }
    1422         if (*dcd->directory) {
    1423           if (hwndMain)
    1424             WinSendMsg(hwndMain,
    1425                        UM_SETUSERLISTNAME,
    1426                        MPFROMP(dcd->directory),
    1427                        MPVOID);
    1428           else
    1429             add_udir(FALSE,dcd->directory);
    1430         }
    1431         if (hwndMain)
    1432           PostMsg(hwndMain,
    1433                   UM_ADVISEFOCUS,
    1434                   MPFROMLONG(dcd->hwndFrame),
    1435                   MPVOID);
    1436       }
    1437       if (mp2) {
    1438         LastDir = hwnd;
    1439         PostMsg(hwnd,
    1440                 UM_RESCAN,
    1441                 MPVOID,
    1442                 MPVOID);
    1443         if (fSwitchTreeOnFocus &&
    1444             hwndTree &&
    1445             dcd &&
    1446             *dcd->directory)
    1447           WinSendMsg(hwndTree,
    1448                      UM_SHOWME,
    1449                      MPFROMP(dcd->directory),
    1450                      MPVOID);
    1451       }
    1452       break;
    1453 
    1454     case UM_SETDIR:
    1455       if (dcd && mp1) {
    1456 
    1457         CHAR fullname[CCHMAXPATH];
    1458 
    1459         DosError(FERR_DISABLEHARDERR);
    1460         if (!DosQueryPathInfo((CHAR *)mp1,
    1461                              FIL_QUERYFULLNAME,
    1462                              fullname,
    1463                              sizeof(fullname))) {
    1464           if (stricmp(dcd->directory,fullname)) {
    1465             strcpy(dcd->previous,dcd->directory);
    1466             strcpy(dcd->directory,fullname);
    1467             DosEnterCritSec();
    1468              dcd->stopflag++;
    1469             DosExitCritSec();
    1470             if (!PostMsg(dcd->hwndObject,
    1471                          UM_RESCAN,
    1472                          MPVOID,
    1473                          MPFROMLONG(1L))) {
    1474               strcpy(dcd->directory,dcd->previous);
    1475               DosEnterCritSec();
    1476                dcd->stopflag--;
    1477               DosExitCritSec();
    1478             }
    1479             else if (*dcd->directory) {
    1480               if (hwndMain)
    1481                 WinSendMsg(hwndMain,
    1482                            UM_SETUSERLISTNAME,
    1483                            MPFROMP(dcd->directory),
    1484                            MPVOID);
    1485               else
    1486                 add_udir(FALSE,
    1487                          dcd->directory);
    1488             }
    1489           }
    1490         }
    1491       }
    1492       break;
    1493 
    1494     case UM_RESCAN:
    1495       if (dcd) {
    1496 
    1497         CNRINFO   cnri;
    1498         CHAR      s[CCHMAXPATH * 2],tf[81],tb[81];
    1499         PCNRITEM  pci;
    1500 
    1501         memset(&cnri,0,sizeof(CNRINFO));
    1502         cnri.cb = sizeof(CNRINFO);
    1503         WinSendMsg(hwnd,
    1504                    CM_QUERYCNRINFO,
    1505                    MPFROMP(&cnri),
    1506                    MPFROMLONG(sizeof(CNRINFO)));
    1507         cnri.pszCnrTitle = dcd->directory;
    1508         WinSendMsg(hwnd,
    1509                    CM_SETCNRINFO,
    1510                    MPFROMP(&cnri),
    1511                    MPFROMLONG(CMA_CNRTITLE));
    1512         dcd->totalfiles = cnri.cRecords;
    1513         commafmt(tb,sizeof(tb),dcd->totalfiles);
    1514         CommaFmtULL(tf,sizeof(tf),dcd->ullTotalBytes,'K');
    1515         sprintf(s,"%s / %s",tb,tf);
    1516         WinSetDlgItemText(dcd->hwndClient,DIR_TOTALS,s);
    1517         commafmt(tb,sizeof(tb),dcd->selectedfiles);
    1518         CommaFmtULL(tf,sizeof(tf),dcd->selectedbytes,'K');
    1519         sprintf(s,"%s / %s",tb,tf);
    1520         WinSetDlgItemText(dcd->hwndClient,DIR_SELECTED,s);
    1521         if (hwndStatus &&
    1522             dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent)) {
    1523           PostMsg(dcd->hwndObject,
    1524                   UM_RESCAN2,
    1525                   MPVOID,
    1526                   MPVOID);
    1527           if ((fSplitStatus && hwndStatus2) ||
    1528               fMoreButtons) {
    1529             pci = WinSendMsg(hwnd,
    1530                              CM_QUERYRECORDEMPHASIS,
    1531                              MPFROMLONG(CMA_FIRST),
    1532                              MPFROMSHORT(CRA_CURSORED));
    1533             if (pci && (INT)pci != -1)
    1534             {
    1535               if (fSplitStatus && hwndStatus2)
    1536               {
    1537                 CommaFmtULL(tb,sizeof(tb),pci->cbFile + pci->easize,' ');
    1538                 if (!fMoreButtons)
    1539                   sprintf(s,
    1540                           " %s  %04u/%02u/%02u %02u:%02u:%02u  [%s]  %s",
    1541                           tb,
    1542                           pci->date.year,
    1543                           pci->date.month,
    1544                           pci->date.day,
    1545                           pci->time.hours,
    1546                           pci->time.minutes,
    1547                           pci->time.seconds,
    1548                           pci->pszDispAttr,
    1549                           pci->pszFileName);
    1550                 else {
    1551                   *tf = 0;
    1552                   if (pci->cbFile + pci->easize > 1024)
    1553                   {
    1554                     CommaFmtULL(tf,sizeof(tf),
    1555                                 pci->cbFile + pci->easize,'K');
    1556                   }
    1557                   sprintf(s,
    1558                           GetPString(IDS_STATUSSIZETEXT),
    1559                           tb,
    1560                           *tf ? " (" : NullStr,
    1561                           tf,
    1562                           *tf ? ")" : NullStr);
    1563                 }
    1564                 WinSetWindowText(hwndStatus2,s);
    1565               }
    1566               else
    1567                 WinSetWindowText(hwndStatus2,NullStr);
    1568               if (fMoreButtons) {
    1569                 WinSetWindowText(hwndName,pci->pszFileName);
    1570                 sprintf(s,
    1571                         "%04u/%02u/%02u %02u:%02u:%02u",
    1572                         pci->date.year,
    1573                         pci->date.month,
    1574                         pci->date.day,
    1575                         pci->time.hours,
    1576                         pci->time.minutes,
    1577                         pci->time.seconds);
    1578                 WinSetWindowText(hwndDate,s);
    1579                 WinSetWindowText(hwndAttr,pci->pszDispAttr);
    1580               }
    1581             }
    1582             else {
    1583               WinSetWindowText(hwndStatus2,NullStr);
    1584               WinSetWindowText(hwndName,NullStr);
    1585               WinSetWindowText(hwndDate,NullStr);
    1586               WinSetWindowText(hwndAttr,NullStr);
    1587             }
    1588           }
    1589         }
    1590       }
    1591       return 0;
    1592 
    1593     case UM_SORTRECORD:
    1594       if (dcd) {
    1595 
    1596         CNRINFO cnri;
    1597 
    1598         memset(&cnri,0,sizeof(CNRINFO));
    1599         cnri.cb = sizeof(CNRINFO);
    1600         WinSendMsg(hwnd,
    1601                    CM_QUERYCNRINFO,
    1602                    MPFROMP(&cnri),
    1603                    MPFROMLONG(sizeof(CNRINFO)));
    1604         cnri.pSortRecord = (PVOID)SortDirCnr;
    1605         WinSendMsg(hwnd,
    1606                    CM_SETCNRINFO,
    1607                    MPFROMP(&cnri),
    1608                    MPFROMLONG(CMA_PSORTRECORD));
    1609         WinSendMsg(hwnd,
    1610                    CM_SORTRECORD,
    1611                    MPFROMP(SortDirCnr),
    1612                    MPFROMLONG(dcd->sortFlags));
    1613       }
    1614       return 0;
    1615 
    1616     case UM_SETUP:
    1617       if (dcd) {
    1618         if (!dcd->hwndObject) {
    1619           /*
    1620            * first time through -- set things up
    1621            */
    1622 
    1623           CNRINFO cnri;
    1624 
    1625           RestorePresParams(hwnd,"DirCnr");
    1626           LoadDetailsSwitches("DirCnr",dcd);
    1627           memset(&cnri,0,sizeof(CNRINFO));
    1628           cnri.cb = sizeof(CNRINFO);
    1629           WinSendMsg(hwnd,
    1630                      CM_QUERYCNRINFO,
    1631                      MPFROMP(&cnri),
    1632                      MPFROMLONG(sizeof(CNRINFO)));
    1633           cnri.cyLineSpacing = 0;
    1634           cnri.cxTreeIndent = 12L;
    1635 
    1636           cnri.flWindowAttr &= (~(CV_TREE | CV_ICON | CV_DETAIL | CV_TEXT));
    1637           cnri.flWindowAttr |= (CV_NAME | CA_DETAILSVIEWTITLES | CV_MINI |
    1638                                 CV_FLOW);
    1639           cnri.pSortRecord = (PVOID)SortDirCnr;
    1640 
    1641           {
    1642             ULONG size = sizeof(ULONG);
    1643 
    1644             PrfQueryProfileData(fmprof,
    1645                                 appname,
    1646                                 "DirflWindowAttr",
    1647                                 (PVOID)&cnri.flWindowAttr,
    1648                                 &size);
    1649             size = sizeof(MASK);
    1650             if (!*dcd->mask.szMask &&
    1651                 !dcd->mask.attrFile &&
    1652                 !dcd->mask.antiattr)
    1653             {
    1654               if (PrfQueryProfileSize(fmprof,
    1655                                       appname,
    1656                                       "DirFilter",
    1657                                       &size) &&
    1658                   size)
    1659               {
    1660                 PrfQueryProfileData(fmprof,
    1661                                     appname,
    1662                                     "DirFilter",
    1663                                     &dcd->mask,
    1664                                     &size);
    1665                 SetMask(dcd->mask.szMask,&dcd->mask);
    1666               }
    1667               else
    1668                 dcd->mask.attrFile = (FILE_READONLY | FILE_NORMAL |
    1669                                       FILE_ARCHIVED | FILE_DIRECTORY |
    1670                                       FILE_HIDDEN   | FILE_SYSTEM);
    1671             }
    1672             *(dcd->mask.prompt) = 0;
    1673           }
    1674           if (dcd->flWindowAttr)
    1675             cnri.flWindowAttr = dcd->flWindowAttr;
    1676           else
    1677             dcd->flWindowAttr = cnri.flWindowAttr;
    1678           cnri.flWindowAttr &= (~(CA_MIXEDTARGETEMPH | CA_ORDEREDTARGETEMPH |
    1679                                   CA_TITLEREADONLY | CA_TITLESEPARATOR));
    1680           cnri.flWindowAttr |= CV_FLOW;
    1681           dcd->flWindowAttr |= CV_FLOW;
    1682           if (WinWindowFromID(dcd->hwndFrame,FID_TITLEBAR))
    1683             cnri.flWindowAttr &= (~CA_CONTAINERTITLE);
    1684           else
    1685             cnri.flWindowAttr |= CA_CONTAINERTITLE;
    1686           if (!dcd->sortFlags)
    1687             dcd->sortFlags = sortFlags;
    1688           WinSendMsg(hwnd,
    1689                      CM_SETCNRINFO,
    1690                      MPFROMP(&cnri),
    1691                      MPFROMLONG(CMA_FLWINDOWATTR | CMA_LINESPACING |
    1692                                 CMA_CXTREEINDENT | CMA_PSORTRECORD));
    1693           SetCnrCols(hwnd,FALSE);
    1694           AdjustCnrColsForPref(hwnd,
    1695                                NULL,
    1696                                dcd,
    1697                                FALSE);
    1698           if (_beginthread(MakeObjWin,NULL,245760,(PVOID)dcd) == -1) {
    1699             Runtime_Error(pszSrcFile, __LINE__, GetPString(IDS_COULDNTSTARTTHREADTEXT));
    1700             PostMsg(hwnd,WM_CLOSE,MPVOID,MPVOID);
    1701             return 0;
    1702           }
    1703           else
    1704             DosSleep(64L);
    1705           WinEnableMenuItem(DirCnrMenu,IDM_FINDINTREE,
    1706                             (hwndTree != (HWND)0));
    1707         }
    1708         SayFilter(WinWindowFromID(WinQueryWindow(hwnd,QW_PARENT),
    1709                                   DIR_FILTER),&dcd->mask,FALSE);
    1710         SaySort(WinWindowFromID(WinQueryWindow(hwnd,QW_PARENT),
    1711                                 DIR_SORT),dcd->sortFlags,FALSE);
    1712         SayView(WinWindowFromID(WinQueryWindow(hwnd,QW_PARENT),
    1713                                 DIR_VIEW),dcd->flWindowAttr);
    1714       }
    1715       else {
    1716         PostMsg(hwnd,
    1717                 WM_CLOSE,
    1718                 MPVOID,
    1719                 MPVOID);
    1720         return 0;
    1721       }
    1722       return 0;
    1723 
    1724     case WM_MENUEND:
    1725       if (dcd) {
    1726 
    1727         HWND hwndMenu = (HWND)mp2;
    1728 
    1729         if (hwndMenu == DirCnrMenu ||
    1730             hwndMenu == FileMenu ||
    1731             hwndMenu == DirMenu)
     1916            dcd->sortFlags |= SORT_DIRSLAST;
     1917            dcd->sortFlags &= (~SORT_DIRSFIRST);
     1918          }
     1919          break;
     1920        case IDM_SORTREVERSE:
     1921          if (dcd->sortFlags & SORT_REVERSE)
     1922            dcd->sortFlags &= (~SORT_REVERSE);
     1923          else
     1924            dcd->sortFlags |= SORT_REVERSE;
     1925          break;
     1926        }
     1927        WinSendMsg(hwnd, CM_SORTRECORD, MPFROMP(SortDirCnr),
     1928                   MPFROMLONG(dcd->sortFlags));
     1929        SaySort(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
     1930                                DIR_SORT), dcd->sortFlags, FALSE);
     1931        break;
     1932
     1933      case IDM_COLLECT:
     1934        if (!Collector) {
     1935
     1936          HWND hwndC;
     1937          SWP swp;
     1938
     1939          if (!ParentIsDesktop(hwnd, dcd->hwndParent) && !fAutoTile &&
     1940              (!fExternalCollector && !strcmp(realappname, FM3Str)))
     1941            GetNextWindowPos(dcd->hwndParent, &swp, NULL, NULL);
     1942          hwndC = StartCollector((fExternalCollector ||
     1943                                  strcmp(realappname, FM3Str)) ?
     1944                                 HWND_DESKTOP : dcd->hwndParent, 4);
     1945          if (hwndC) {
     1946            if (!ParentIsDesktop(hwnd, dcd->hwndParent) && !fAutoTile &&
     1947                (!fExternalCollector && !strcmp(realappname, FM3Str)))
     1948              WinSetWindowPos(hwndC, HWND_TOP, swp.x, swp.y,
     1949                              swp.cx, swp.cy, SWP_MOVE | SWP_SIZE |
     1950                              SWP_SHOW | SWP_ZORDER);
     1951            else if (!ParentIsDesktop(hwnd, dcd->hwndParent) && fAutoTile &&
     1952                     !strcmp(realappname, FM3Str))
     1953              TileChildren(dcd->hwndParent, TRUE);
     1954            WinSetWindowPos(hwndC, HWND_TOP, 0, 0, 0, 0, SWP_ACTIVATE);
     1955            DosSleep(250L);
     1956          }
     1957        }
     1958        else
     1959          StartCollector(dcd->hwndParent, 4);
     1960        PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_COLLECTOR, 0), MPVOID);
     1961        break;
     1962
     1963      case IDM_COLLECTOR:
     1964        DosSleep(64L);
    17321965        {
    1733           MarkAll(hwnd,TRUE,FALSE,TRUE);
    1734           if (dcd->cnremphasized) {
    1735             WinSendMsg(hwnd,CM_SETRECORDEMPHASIS,MPVOID,
    1736                        MPFROM2SHORT(FALSE,CRA_SOURCE));
    1737             dcd->cnremphasized = FALSE;
    1738           }
    1739         }
    1740       }
    1741       break;
    1742 
    1743     case UM_OPENWINDOWFORME:
    1744       if (dcd) {
    1745         if (mp1 && !IsFile((CHAR *)mp1)) {
    1746           OpenDirCnr(hwnd,
    1747                      dcd->hwndParent,
    1748                      dcd->hwndFrame,
    1749                      FALSE,
    1750                      (char *)mp1);
    1751         }
    1752         else if (mp1 && IsFile(mp1) == 1) {
    1753           StartArcCnr(HWND_DESKTOP,
    1754                       dcd->hwndFrame,
    1755                       (CHAR *)mp1,
    1756                       4,
    1757                       (ARC_TYPE *)mp2);
    1758         }
    1759       }
    1760       return 0;
    1761 
    1762     case MM_PORTHOLEINIT:
    1763       if (dcd) {
    1764         switch(SHORT1FROMMP(mp1)) {
    1765           case 0:
    1766           case 1:
    1767             {
    1768               ULONG wmsg;
    1769 
    1770               wmsg = (SHORT1FROMMP(mp1) == 0) ? UM_FILESMENU : UM_VIEWSMENU;
    1771               PortholeInit((HWND)WinSendMsg(dcd->hwndClient,
    1772                                             wmsg,
    1773                                             MPVOID,
    1774                                             MPVOID),
    1775                             mp1,
    1776                             mp2);
    1777             }
    1778             break;
    1779         }
    1780       }
    1781       break;
    1782 
    1783     case UM_INITMENU:
    1784     case WM_INITMENU:
    1785       if (dcd) {
    1786         switch(SHORT1FROMMP(mp1)) {
    1787           case IDM_FILESMENU:
    1788             if (isalpha(*dcd->directory)) {
    1789               if (driveflags[toupper(*dcd->directory) - 'A'] & DRIVE_NOTWRITEABLE) {
    1790                 WinEnableMenuItem((HWND)mp2,IDM_MOVEMENU,FALSE);
    1791                 WinEnableMenuItem((HWND)mp2,IDM_RENAME,FALSE);
    1792                 WinEnableMenuItem((HWND)mp2,IDM_MKDIR,FALSE);
    1793                 WinEnableMenuItem((HWND)mp2,IDM_UNDELETE,FALSE);
    1794                 WinEnableMenuItem((HWND)mp2,IDM_DELETESUBMENU,FALSE);
    1795                 WinEnableMenuItem((HWND)mp2,IDM_DELETE,FALSE);
    1796                 WinEnableMenuItem((HWND)mp2,IDM_EDIT,FALSE);
    1797                 WinEnableMenuItem((HWND)mp2,IDM_EDITTEXT,FALSE);
    1798                 WinEnableMenuItem((HWND)mp2,IDM_EDITBINARY,FALSE);
    1799                 WinEnableMenuItem((HWND)mp2,IDM_ATTRS,FALSE);
    1800               }
    1801               else {
    1802                 WinEnableMenuItem((HWND)mp2,IDM_MOVEMENU,TRUE);
    1803                 WinEnableMenuItem((HWND)mp2,IDM_RENAME,TRUE);
    1804                 WinEnableMenuItem((HWND)mp2,IDM_MKDIR,TRUE);
    1805                 WinEnableMenuItem((HWND)mp2,IDM_UNDELETE,TRUE);
    1806                 WinEnableMenuItem((HWND)mp2,IDM_DELETESUBMENU,TRUE);
    1807                 WinEnableMenuItem((HWND)mp2,IDM_DELETE,TRUE);
    1808                 WinEnableMenuItem((HWND)mp2,IDM_EDIT,TRUE);
    1809                 WinEnableMenuItem((HWND)mp2,IDM_EDITTEXT,TRUE);
    1810                 WinEnableMenuItem((HWND)mp2,IDM_EDITBINARY,TRUE);
    1811                 WinEnableMenuItem((HWND)mp2,IDM_ATTRS,TRUE);
    1812               }
    1813             }
    1814             break;
    1815 
    1816           case IDM_VIEWSMENU:
    1817             SetViewMenu((HWND)mp2,dcd->flWindowAttr);
    1818             WinEnableMenuItem((HWND)mp2,IDM_RESELECT,
    1819                               (dcd->lastselection != NULL));
    1820             if (isalpha(*dcd->directory)) {
    1821               if (driveflags[toupper(*dcd->directory) - 'A'] &
    1822                  DRIVE_NOTWRITEABLE)
    1823                 WinEnableMenuItem((HWND)mp2,
    1824                                   IDM_MKDIR,
    1825                                   FALSE);
    1826               else
    1827                 WinEnableMenuItem((HWND)mp2,
    1828                                   IDM_MKDIR,
    1829                                   TRUE);
    1830             }
    1831             WinEnableMenuItem((HWND)mp2,
    1832                               IDM_SELECTCOMPAREMENU,
    1833                               (CountDirCnrs(dcd->hwndParent) > 1));
    1834             break;
    1835 
    1836           case IDM_DETAILSSETUP:
    1837             SetDetailsSwitches((HWND)mp2,dcd);
    1838             break;
    1839 
    1840           case IDM_COMMANDSMENU:
    1841             SetupCommandMenu((HWND)mp2,hwnd);
    1842             break;
    1843 
    1844           case IDM_SORTSUBMENU:
    1845             SetSortChecks((HWND)mp2,dcd->sortFlags);
    1846             break;
    1847 
    1848           case IDM_WINDOWSMENU:
    1849             SetupWinList((HWND)mp2,
    1850                          (hwndMain) ? hwndMain : (HWND)0,
    1851                          dcd->hwndFrame);
    1852             break;
    1853         }
    1854         dcd->hwndLastMenu = (HWND)mp2;
    1855       }
    1856       if (msg == WM_INITMENU)
    1857         break;
    1858       return 0;
    1859 
    1860     case UM_FILTER:
    1861       if (dcd) {
    1862 
    1863         PCNRITEM pci;
    1864 
    1865         if (mp1) {
    1866           DosEnterCritSec();
    1867            SetMask((CHAR *)mp1,&dcd->mask);
    1868           DosExitCritSec();
    1869         }
    1870         dcd->suspendview = 1;
    1871         WinSendMsg(hwnd,CM_FILTER,MPFROMP(Filter),MPFROMP(&dcd->mask));
    1872         dcd->suspendview = 0;
    1873         if (fAutoView && hwndMain) {
    1874           pci = WinSendMsg(hwnd,CM_QUERYRECORDEMPHASIS,
    1875                            MPFROMLONG(CMA_FIRST),
    1876                            MPFROMSHORT(CRA_CURSORED));
    1877           if (pci && (INT)pci != -1 &&
    1878              (!(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_SLOW)))
    1879             WinSendMsg(hwndMain,
    1880                        UM_LOADFILE,
    1881                        MPFROMP(pci->szFileName),
    1882                        MPVOID);
    1883           else
    1884             WinSendMsg(hwndMain,
    1885                        UM_LOADFILE,
    1886                        MPVOID,
    1887                        MPVOID);
    1888         }
    1889         PostMsg(hwnd,
    1890                 UM_RESCAN,
    1891                 MPVOID,
    1892                 MPVOID);
    1893       }
    1894       return 0;
    1895 
    1896     case UM_COMMAND:
    1897       if (mp1) {
    1898         if (dcd) {
    1899           if (!PostMsg(dcd->hwndObject,
    1900                        UM_COMMAND,
    1901                        mp1,
    1902                        mp2))
    1903           {
    1904             Runtime_Error(pszSrcFile, __LINE__, "PostMsg");
    1905             FreeListInfo((LISTINFO *)mp1);
    1906           }
    1907           else
    1908             return (MRESULT)TRUE;
    1909         }
    1910         else
    1911           FreeListInfo((LISTINFO *)mp1);
    1912       }
    1913       return 0;
    1914 
    1915     case UM_NOTIFY:
    1916       if (mp2)
    1917         Notify((CHAR *)mp2);
    1918       return 0;
    1919 
    1920     case UM_DRIVECMD:
    1921       if (mp1)
    1922         WinSendMsg(hwnd,
    1923                    WM_COMMAND,
    1924                    MPFROM2SHORT(IDM_SWITCH,0),
    1925                    mp1);
    1926       return 0;
    1927 
    1928     case WM_COMMAND:
    1929       DosError(FERR_DISABLEHARDERR);
    1930       if (dcd) {
    1931         switch(SHORT1FROMMP(mp1)) {
    1932           case IDM_SETTARGET:
    1933             SetTargetDir(hwnd,FALSE);
    1934             break;
    1935 
    1936           case IDM_CREATE:
    1937             {
    1938               STRINGINPARMS sip;
    1939               CHAR          filename[CCHMAXPATHCOMP];
    1940 
    1941               memset(&sip,0,sizeof(sip));
    1942               sip.help = GetPString(IDS_CREATETEXT);
    1943               sip.prompt = GetPString(IDS_CREATEPROMPTTEXT);
    1944               sip.inputlen = CCHMAXPATHCOMP - (strlen(dcd->directory) - 1);
    1945               strcpy(filename,"NEWFILE.TXT");
    1946               sip.ret = filename;
    1947               sip.title = GetPString(IDS_CREATETITLETEXT);
    1948               if (WinDlgBox(HWND_DESKTOP,hwnd,InputDlgProc,FM3ModHandle,
    1949                             STR_FRAME,&sip))
    1950              {
    1951                 bstrip(sip.ret);
    1952                 if (*sip.ret)
    1953                 {
    1954                   CHAR      newfile[CCHMAXPATH];
    1955                   FILE     *fp;
    1956                   INT       test;
    1957                   PCNRITEM  pci;
    1958 
    1959                   strcpy(newfile,dcd->directory);
    1960                   if (newfile[strlen(newfile) - 1] != '\\')
    1961                     strcat(newfile,"\\");
    1962                   strcat(newfile,sip.ret);
    1963                   test = IsFile(newfile);
    1964                   if (test != 1)
    1965                     fp = fopen(newfile,"w");
    1966                   if (test != 1 && !fp) {
    1967                     saymsg(MB_ENTER,
    1968                            hwnd,
    1969                            GetPString(IDS_ERRORTEXT),
    1970                            GetPString(IDS_CREATEERRORTEXT),
    1971                            newfile);
    1972                   }
    1973                   else {
    1974                     if (fp) {
    1975                       WinSendMsg(hwnd,
    1976                                  UM_UPDATERECORD,
    1977                                  MPFROMP(newfile),
    1978                                  MPVOID);
    1979                       fclose(fp);
    1980                     }
    1981                     if (*editor) {
    1982 
    1983                       CHAR *dummy[2];
    1984 
    1985                       dummy[0] = newfile;
    1986                       dummy[1] = NULL;
    1987                       ExecOnList(hwnd,
    1988                                  editor,
    1989                                  WINDOWED | SEPARATE,
    1990                                  NULL,
    1991                                  dummy,
    1992                                  NULL);
    1993                     }
    1994                     else
    1995                       StartMLEEditor(dcd->hwndParent,
    1996                                      4,
    1997                                      newfile,
    1998                                      dcd->hwndFrame);
    1999                     pci = FindCnrRecord(hwnd,
    2000                                         newfile,
    2001                                         NULL,
    2002                                         TRUE,
    2003                                         FALSE,
    2004                                         TRUE);
    2005                     if (pci && (INT)pci != -1)
    2006                       /* make sure that record shows in viewport */
    2007                       ShowCnrRecord(hwnd,(PMINIRECORDCORE)pci);
    2008                   }
    2009                 }
    2010               }
    2011             }
    2012             break;
    2013 
    2014           case IDM_CONTEXTMENU:
    2015             {
    2016               PCNRITEM pci;
    2017 
    2018               pci = (PCNRITEM)CurrentRecord(hwnd);
    2019               PostMsg(hwnd,WM_CONTROL,MPFROM2SHORT(DIR_CNR,CN_CONTEXTMENU),
    2020                       MPFROMP(pci));
    2021             }
    2022             break;
    2023 
    2024           case IDM_MAXIMIZE:
    2025             PostMsg(hwndMain,
    2026                     UM_MAXIMIZE,
    2027                     MPFROMLONG(dcd->hwndFrame),
    2028                     MPVOID);
    2029             break;
    2030 
    2031           case IDM_SHOWALLFILESCNR:
    2032             StartSeeAll(HWND_DESKTOP,FALSE,dcd->directory);
    2033             break;
    2034 
    2035           case IDM_SHOWALLFILES:
    2036             {
    2037               PCNRITEM pci;
    2038 
    2039               pci = WinSendMsg(hwnd,CM_QUERYRECORDEMPHASIS,
    2040                                MPFROMLONG(CMA_FIRST),
    2041                                MPFROMSHORT(CRA_CURSORED));
    2042               if (pci && (INT)pci != -1) {
    2043 
    2044                 static CHAR dirname[CCHMAXPATH];
    2045 
    2046                 strcpy(dirname,pci->szFileName);
    2047                 MakeValidDir(dirname);
    2048                 StartSeeAll(HWND_DESKTOP,FALSE,dirname);
    2049               }
    2050             }
    2051             break;
    2052 
    2053           case IDM_FINDINTREE:
    2054             if (hwndTree)
    2055               WinSendMsg(hwndTree,UM_SHOWME,MPFROMP(dcd->directory),
    2056                          MPFROMLONG(1L));
    2057             break;
    2058 
    2059           case IDM_BEGINEDIT:
    2060             OpenEdit(hwnd);
    2061             break;
    2062 
    2063           case IDM_ENDEDIT:
    2064             WinSendMsg(hwnd,
    2065                        CM_CLOSEEDIT,
    2066                        MPVOID,
    2067                        MPVOID);
    2068             break;
    2069 
    2070           case IDM_SHOWSELECT:
    2071             QuickPopup(hwnd,
    2072                        dcd,
    2073                        CheckMenu(&DirCnrMenu,DIRCNR_POPUP),
    2074                        IDM_SELECTSUBMENU);
    2075             break;
    2076 
    2077           case IDM_SHOWSORT:
    2078             QuickPopup(hwnd,dcd,CheckMenu(&DirCnrMenu,DIRCNR_POPUP),
    2079                        IDM_SORTSUBMENU);
    2080             break;
    2081 
    2082           case IDM_VIEWORARC:
    2083             {
    2084               SWP       swp;
    2085               PCNRITEM  pci;
    2086 
    2087               pci = (PCNRITEM)WinSendMsg(hwnd,CM_QUERYRECORDEMPHASIS,
    2088                                          MPFROMLONG(CMA_FIRST),
    2089                                          MPFROMSHORT(CRA_CURSORED));
    2090               if (pci && (INT)pci != -1) {
    2091                 WinQueryWindowPos(dcd->hwndFrame,&swp);
    2092                 DefaultViewKeys(hwnd,
    2093                                 dcd->hwndFrame,
    2094                                 dcd->hwndParent,
    2095                                 &swp,
    2096                                 pci->szFileName);
    2097               }
    2098             }
    2099             break;
    2100 
    2101           case IDM_NOTEBOOK:
    2102             if (!ParentIsDesktop(dcd->hwndParent,dcd->hwndParent))
    2103               PostMsg(dcd->hwndParent,msg,mp1,mp2);
    2104             else
    2105               WinDlgBox(HWND_DESKTOP,hwnd,CfgDlgProc,FM3ModHandle,
    2106                         CFG_FRAME,(PVOID)"Directory");
    2107             break;
    2108 
    2109           case IDM_QTREE:
    2110           case IDM_TREE:
    2111             {
    2112               CHAR   newpath[CCHMAXPATH];
    2113               APIRET rc;
    2114               PCNRITEM pci;
    2115 
    2116               if (SHORT1FROMMP(mp1) == IDM_TREE) {
    2117                 pci = (PCNRITEM)CurrentRecord(hwnd);
    2118                 if (pci && (INT)pci != -1)
    2119                   strcpy(newpath,pci->szFileName);
    2120                 else
    2121                   strcpy(newpath,dcd->directory);
    2122               }
    2123               else
    2124                 strcpy(newpath,dcd->directory);
    2125               MakeValidDir(newpath);
    2126               rc = WinDlgBox(HWND_DESKTOP,dcd->hwndClient,ObjCnrDlgProc,
    2127                              FM3ModHandle,QTREE_FRAME,MPFROMP(newpath));
    2128               if (rc)
    2129                 WinSendMsg(hwnd,UM_SETDIR,MPFROMP(newpath),MPVOID);
    2130             }
    2131             break;
    2132 
    2133           case IDM_RESELECT:
    2134             SelectList(hwnd,TRUE,FALSE,FALSE,NULL,NULL,
    2135                        dcd->lastselection);
    2136             break;
    2137 
    2138           case IDM_HELP:
    2139             if (hwndHelp) {
    2140               if (!ParentIsDesktop(dcd->hwndFrame,dcd->hwndParent))
    2141                 PostMsg(dcd->hwndParent,UM_COMMAND,mp1,mp2);
    2142               else
    2143                 WinSendMsg(hwndHelp,HM_HELP_CONTENTS,MPVOID,MPVOID);
    2144             }
    2145             break;
    2146 
    2147           case IDM_WINDOWDLG:
    2148             if (!ParentIsDesktop(dcd->hwndFrame,dcd->hwndParent))
    2149               PostMsg(dcd->hwndParent,UM_COMMAND,
    2150                          MPFROM2SHORT(IDM_WINDOWDLG,0),MPVOID);
    2151             break;
    2152 
    2153           case IDM_SORTSMARTNAME:
    2154           case IDM_SORTNAME:
    2155           case IDM_SORTFILENAME:
    2156           case IDM_SORTSIZE:
    2157           case IDM_SORTEASIZE:
    2158           case IDM_SORTFIRST:
    2159           case IDM_SORTLAST:
    2160           case IDM_SORTLWDATE:
    2161           case IDM_SORTLADATE:
    2162           case IDM_SORTCRDATE:
    2163           case IDM_SORTSUBJECT:
    2164             dcd->sortFlags &= (SORT_REVERSE | SORT_DIRSFIRST | SORT_DIRSLAST);
    2165           case IDM_SORTDIRSFIRST:
    2166           case IDM_SORTDIRSLAST:
    2167           case IDM_SORTREVERSE:
    2168             switch(SHORT1FROMMP(mp1)) {
    2169               case IDM_SORTSUBJECT:
    2170                 dcd->sortFlags |= SORT_SUBJECT;
    2171                 break;
    2172               case IDM_SORTSMARTNAME:
    2173               case IDM_SORTFILENAME:
    2174                 dcd->sortFlags |= SORT_FILENAME;
    2175                 break;
    2176               case IDM_SORTSIZE:
    2177                 dcd->sortFlags |= SORT_SIZE;
    2178                 break;
    2179               case IDM_SORTEASIZE:
    2180                 dcd->sortFlags |= SORT_EASIZE;
    2181                 break;
    2182               case IDM_SORTFIRST:
    2183                 dcd->sortFlags |= SORT_FIRSTEXTENSION;
    2184                 break;
    2185               case IDM_SORTLAST:
    2186                 dcd->sortFlags |= SORT_LASTEXTENSION;
    2187                 break;
    2188               case IDM_SORTLWDATE:
    2189                 dcd->sortFlags |= SORT_LWDATE;
    2190                 break;
    2191               case IDM_SORTLADATE:
    2192                 dcd->sortFlags |= SORT_LADATE;
    2193                 break;
    2194               case IDM_SORTCRDATE:
    2195                 dcd->sortFlags |= SORT_CRDATE;
    2196                 break;
    2197               case IDM_SORTDIRSFIRST:
    2198                 if (dcd->sortFlags & SORT_DIRSFIRST)
    2199                   dcd->sortFlags &= (~SORT_DIRSFIRST);
    2200                 else {
    2201                   dcd->sortFlags |= SORT_DIRSFIRST;
    2202                   dcd->sortFlags &= (~SORT_DIRSLAST);
    2203                 }
    2204                 break;
    2205               case IDM_SORTDIRSLAST:
    2206                 if (dcd->sortFlags & SORT_DIRSLAST)
    2207                   dcd->sortFlags &= (~SORT_DIRSLAST);
    2208                 else {
    2209                   dcd->sortFlags |= SORT_DIRSLAST;
    2210                   dcd->sortFlags &= (~SORT_DIRSFIRST);
    2211                 }
    2212                 break;
    2213               case IDM_SORTREVERSE:
    2214                 if (dcd->sortFlags & SORT_REVERSE)
    2215                   dcd->sortFlags &= (~SORT_REVERSE);
    2216                 else
    2217                   dcd->sortFlags |= SORT_REVERSE;
    2218                 break;
    2219             }
    2220             WinSendMsg(hwnd,CM_SORTRECORD,MPFROMP(SortDirCnr),
    2221                        MPFROMLONG(dcd->sortFlags));
    2222             SaySort(WinWindowFromID(WinQueryWindow(hwnd,QW_PARENT),
    2223                     DIR_SORT),dcd->sortFlags,FALSE);
    2224             break;
    2225 
    2226           case IDM_COLLECT:
    2227             if (!Collector) {
    2228 
    2229               HWND hwndC;
    2230               SWP  swp;
    2231 
    2232               if (!ParentIsDesktop(hwnd,dcd->hwndParent) && !fAutoTile &&
    2233                  (!fExternalCollector && !strcmp(realappname,FM3Str)))
    2234                 GetNextWindowPos(dcd->hwndParent,&swp,NULL,NULL);
    2235               hwndC = StartCollector((fExternalCollector ||
    2236                                       strcmp(realappname,FM3Str)) ?
    2237                                      HWND_DESKTOP :
    2238                                      dcd->hwndParent,4);
    2239               if (hwndC) {
    2240                 if (!ParentIsDesktop(hwnd,dcd->hwndParent) && !fAutoTile &&
    2241                    (!fExternalCollector && !strcmp(realappname,FM3Str)))
    2242                   WinSetWindowPos(hwndC,HWND_TOP,swp.x,swp.y,
    2243                                   swp.cx,swp.cy,SWP_MOVE | SWP_SIZE |
    2244                                   SWP_SHOW | SWP_ZORDER);
    2245                 else if (!ParentIsDesktop(hwnd,dcd->hwndParent) && fAutoTile &&
    2246                         !strcmp(realappname,FM3Str))
    2247                   TileChildren(dcd->hwndParent,TRUE);
    2248                 WinSetWindowPos(hwndC,HWND_TOP,0,0,0,0,SWP_ACTIVATE);
    2249                 DosSleep(250L);
    2250               }
    2251             }
    2252             else
    2253               StartCollector(dcd->hwndParent,4);
    2254             PostMsg(hwnd,WM_COMMAND,MPFROM2SHORT(IDM_COLLECTOR,0),MPVOID);
    2255             break;
    2256 
    2257           case IDM_COLLECTOR:
    2258             DosSleep(64L);
    2259             {
    2260               CHAR **list;
    2261 
    2262               list = BuildList(hwnd);
    2263               if (list) {
    2264                 if (Collector) {
    2265                   if (!PostMsg(Collector,
    2266                                WM_COMMAND,
    2267                                MPFROM2SHORT(IDM_COLLECTOR,0),
    2268                                MPFROMP(list)))
    2269                     FreeList(list);
    2270                   else if (fUnHilite)
    2271                     UnHilite(hwnd,TRUE,&dcd->lastselection);
    2272                 }
    2273                 else
    2274                   FreeList(list);
    2275               }
    2276             }
    2277             break;
    2278 
    2279           case IDM_UNDELETE:
    2280             {
    2281               PCNRITEM pci;
    2282               CHAR     path[CCHMAXPATH];
    2283 
    2284               pci = (PCNRITEM)CurrentRecord(hwnd);
    2285               if (pci && (INT)pci != -1) {
    2286                 strcpy(path,pci->szFileName);
    2287                 MakeValidDir(path);
    2288                 WinDlgBox(HWND_DESKTOP,hwnd,UndeleteDlgProc,FM3ModHandle,
    2289                           UNDEL_FRAME,MPFROMP(path));
    2290               }
    2291             }
    2292             break;
    2293 
    2294           case IDM_UNDELETESPEC:
    2295             WinDlgBox(HWND_DESKTOP,
    2296                       hwnd,
    2297                       UndeleteDlgProc,
    2298                       FM3ModHandle,
    2299                       UNDEL_FRAME,
    2300                       MPFROMP(dcd->directory));
    2301             break;
    2302 
    2303           case IDM_RESORT:
     1966          CHAR **list;
     1967
     1968          list = BuildList(hwnd);
     1969          if (list) {
     1970            if (Collector) {
     1971              if (!PostMsg(Collector,
     1972                           WM_COMMAND,
     1973                           MPFROM2SHORT(IDM_COLLECTOR, 0), MPFROMP(list)))
     1974                FreeList(list);
     1975              else if (fUnHilite)
     1976                UnHilite(hwnd, TRUE, &dcd->lastselection);
     1977            }
     1978            else
     1979              FreeList(list);
     1980          }
     1981        }
     1982        break;
     1983
     1984      case IDM_UNDELETE:
     1985        {
     1986          PCNRITEM pci;
     1987          CHAR path[CCHMAXPATH];
     1988
     1989          pci = (PCNRITEM) CurrentRecord(hwnd);
     1990          if (pci && (INT) pci != -1) {
     1991            strcpy(path, pci->szFileName);
     1992            MakeValidDir(path);
     1993            WinDlgBox(HWND_DESKTOP, hwnd, UndeleteDlgProc, FM3ModHandle,
     1994                      UNDEL_FRAME, MPFROMP(path));
     1995          }
     1996        }
     1997        break;
     1998
     1999      case IDM_UNDELETESPEC:
     2000        WinDlgBox(HWND_DESKTOP,
     2001                  hwnd,
     2002                  UndeleteDlgProc,
     2003                  FM3ModHandle, UNDEL_FRAME, MPFROMP(dcd->directory));
     2004        break;
     2005
     2006      case IDM_RESORT:
    23042007//            WinSendMsg(hwnd,
    23052008//                       CM_SORTRECORD,
    23062009//                       MPFROMP(SortDirCnr),
    23072010//                       MPFROMLONG((fSyncUpdates) ? sortFlags : dcd->sortFlags));
    2308             WinSendMsg(hwnd,
    2309                        CM_SORTRECORD,
    2310                        MPFROMP(SortDirCnr),
    2311                        MPFROMLONG(dcd->sortFlags));
    2312             break;
    2313 
    2314           case IDM_FILTER:
    2315             {
    2316               BOOL     empty = FALSE;
    2317               PCNRITEM pci;
    2318               CHAR    *p;
    2319 
    2320               if (!*dcd->mask.szMask) {
    2321                 empty = TRUE;
    2322                 pci = (PCNRITEM)CurrentRecord(hwnd);
    2323                 if (pci && !(pci->attrFile & FILE_DIRECTORY)) {
    2324                   p = strrchr(pci->szFileName,'\\');
    2325                   if (p) {
    2326                     p++;
    2327                     strcpy(dcd->mask.szMask,p);
    2328                   }
    2329                 }
    2330               }
    2331               *(dcd->mask.prompt) = 0;
    2332 
    2333               if (WinDlgBox(HWND_DESKTOP,hwnd,PickMaskDlgProc,
    2334                             FM3ModHandle,MSK_FRAME,MPFROMP(&dcd->mask)))
    2335                 WinSendMsg(hwnd,UM_FILTER,MPVOID,MPVOID);
    2336               else if (empty)
    2337                 *dcd->mask.szMask = 0;
    2338               SayFilter(WinWindowFromID(WinQueryWindow(hwnd,QW_PARENT),
    2339                         DIR_FILTER),&dcd->mask,FALSE);
    2340             }
    2341             break;
    2342 
    2343           case IDM_HIDEALL:
    2344             if (fAutoView && hwndMain)
    2345               PostMsg(hwndMain,
    2346                       UM_LOADFILE,
    2347                       MPVOID,
    2348                       MPVOID);
    2349             dcd->suspendview = 1;
    2350             HideAll(hwnd);
    2351             dcd->suspendview = 0;
    2352             PostMsg(hwnd,
    2353                     UM_RESCAN,
    2354                     MPVOID,
    2355                     MPVOID);
    2356             break;
    2357 
    2358           case IDM_SELECTBOTH:
    2359           case IDM_SELECTONE:
    2360           case IDM_SELECTMORE:
    2361           case IDM_SELECTNEWER:
    2362           case IDM_SELECTOLDER:
    2363           case IDM_SELECTBIGGER:
    2364           case IDM_SELECTSMALLER:
    2365           case IDM_DESELECTBOTH:
    2366           case IDM_DESELECTONE:
    2367           case IDM_DESELECTMORE:
    2368           case IDM_DESELECTNEWER:
    2369           case IDM_DESELECTOLDER:
    2370           case IDM_DESELECTBIGGER:
    2371           case IDM_DESELECTSMALLER:
    2372             if (ParentIsDesktop(hwnd,dcd->hwndParent)) {
    2373               Runtime_Error(pszSrcFile, __LINE__, "ParentIsDesktop unexpected");
    2374               break;
    2375             }
    2376           case IDM_SELECTLIST:
    2377           case IDM_SELECTALL:
    2378           case IDM_DESELECTALL:
    2379           case IDM_SELECTALLFILES:
    2380           case IDM_DESELECTALLFILES:
    2381           case IDM_SELECTALLDIRS:
    2382           case IDM_DESELECTALLDIRS:
    2383           case IDM_SELECTMASK:
    2384           case IDM_DESELECTMASK:
    2385           case IDM_INVERT:
    2386           case IDM_SELECTCLIP:
    2387           case IDM_DESELECTCLIP:
    2388             {
    2389               PCNRITEM pci;
    2390 
    2391               pci = (PCNRITEM)CurrentRecord(hwnd);
    2392               if ((INT)pci == -1)
    2393                 pci = NULL;
    2394               if (SHORT1FROMMP(mp1) == IDM_HIDEALL) {
    2395                 if (pci) {
    2396                   if (!(pci->rc.flRecordAttr & CRA_SELECTED))
    2397                     pci->rc.flRecordAttr |= CRA_FILTERED;
    2398                     WinSendMsg(hwnd,CM_INVALIDATERECORD,MPFROMP(&pci),
    2399                                MPFROM2SHORT(1,CMA_ERASE | CMA_REPOSITION));
    2400                     break;
    2401                 }
    2402               }
    2403               PostMsg(dcd->hwndObject,
    2404                       UM_SELECT,
    2405                       mp1,
    2406                       MPFROMP(pci));
    2407             }
    2408             break;
    2409 
    2410           case IDM_RESCAN:
    2411             DosEnterCritSec();
    2412             dcd->stopflag++;
    2413             DosExitCritSec();
    2414             if (!PostMsg(dcd->hwndObject,
    2415                          UM_RESCAN,
    2416                          MPVOID,
    2417                          MPVOID))
    2418             {
    2419               DosEnterCritSec();
    2420               dcd->stopflag--;
    2421               DosExitCritSec();
    2422             }
    2423             break;
    2424 
    2425           case IDM_SHOWLNAMES:
    2426           case IDM_SHOWSUBJECT:
    2427           case IDM_SHOWEAS:
    2428           case IDM_SHOWSIZE:
    2429           case IDM_SHOWICON:
    2430           case IDM_SHOWLWDATE:
    2431           case IDM_SHOWLWTIME:
    2432           case IDM_SHOWLADATE:
    2433           case IDM_SHOWLATIME:
    2434           case IDM_SHOWCRDATE:
    2435           case IDM_SHOWCRTIME:
    2436           case IDM_SHOWATTR:
    2437             AdjustDetailsSwitches(hwnd,
    2438                                   dcd->hwndLastMenu,
    2439                                   SHORT1FROMMP(mp1),
    2440                                   dcd->directory,
    2441                                   "DirCnr",
    2442                                   dcd,
    2443                                   FALSE);
    2444             break;
    2445 
    2446           case IDM_TREEVIEW:
    2447           case IDM_ICON:
    2448           case IDM_TEXT:
    2449           case IDM_DETAILS:
    2450           case IDM_NAME:
    2451           case IDM_MINIICONS:
    2452           case IDM_DETAILSTITLES:
    2453             {
    2454               CNRINFO cnri;
    2455 
    2456               memset(&cnri,0,sizeof(CNRINFO));
    2457               cnri.cb = sizeof(CNRINFO);
    2458               WinSendMsg(hwnd,CM_QUERYCNRINFO,MPFROMP(&cnri),
    2459                          MPFROMLONG(sizeof(CNRINFO)));
    2460               switch(SHORT1FROMMP(mp1)) {
    2461                 case IDM_TREEVIEW:
    2462                   if (!(cnri.flWindowAttr & CV_TREE))
    2463                     dcd->lastattr = cnri.flWindowAttr;
    2464                   cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT |
    2465                                           CV_DETAIL | CV_NAME | CA_TREELINE));
    2466                   cnri.flWindowAttr |= CA_TREELINE | CV_TREE | CV_ICON;
    2467                   if (!dcd->firsttree)
    2468                     PostMsg(dcd->hwndObject,UM_FLESH,MPVOID,MPVOID);
    2469                   break;
    2470                 case IDM_ICON:
    2471                   cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT |
    2472                                           CV_DETAIL | CV_NAME | CA_TREELINE));
    2473                   cnri.flWindowAttr |= CV_ICON;
    2474                   break;
    2475                 case IDM_NAME:
    2476                   cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT |
    2477                                           CV_DETAIL | CV_NAME | CA_TREELINE));
    2478                   cnri.flWindowAttr |= CV_NAME;
    2479                   break;
    2480                 case IDM_TEXT:
    2481                   cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT |
    2482                                           CV_DETAIL | CV_NAME | CA_TREELINE));
    2483                   cnri.flWindowAttr |= CV_TEXT;
    2484                   break;
    2485                 case IDM_DETAILS:
    2486                   cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT |
    2487                                           CV_DETAIL | CV_NAME | CA_TREELINE));
    2488                   cnri.flWindowAttr |= CV_DETAIL;
    2489                   break;
    2490                 case IDM_MINIICONS:
    2491                   if (cnri.flWindowAttr & CV_MINI)
    2492                     cnri.flWindowAttr &= (~CV_MINI);
    2493                   else
    2494                     cnri.flWindowAttr |= CV_MINI;
    2495                   break;
    2496                 case IDM_DETAILSTITLES:
    2497                   if (cnri.flWindowAttr & CA_DETAILSVIEWTITLES)
    2498                     cnri.flWindowAttr &= (~CA_DETAILSVIEWTITLES);
    2499                   else
    2500                     cnri.flWindowAttr |= CA_DETAILSVIEWTITLES;
    2501                   break;
    2502               }
    2503               cnri.flWindowAttr &= (~(CA_ORDEREDTARGETEMPH |
    2504                                       CA_MIXEDTARGETEMPH));
    2505               cnri.flWindowAttr |= CV_FLOW;
    2506               dcd->flWindowAttr = cnri.flWindowAttr;
    2507               WinSendMsg(hwnd,CM_SETCNRINFO,MPFROMP(&cnri),
    2508                          MPFROMLONG(CMA_FLWINDOWATTR));
    2509               WinSendMsg(hwnd,CM_INVALIDATERECORD,MPVOID,
    2510                          MPFROM2SHORT(0,CMA_ERASE | CMA_REPOSITION));
    2511               SayView(WinWindowFromID(WinQueryWindow(hwnd,QW_PARENT),
    2512                       DIR_VIEW),dcd->flWindowAttr);
    2513             }
    2514             break;
    2515 
    2516           case IDM_SAVETOLIST:
    2517             WinDlgBox(HWND_DESKTOP,hwnd,SaveListDlgProc,FM3ModHandle,
    2518                       SAV_FRAME,MPFROMP(&hwnd));
    2519             break;
    2520 
    2521           case IDM_SIZES:
    2522             {
    2523               PCNRITEM pci;
    2524               CHAR     path[CCHMAXPATH];
    2525 
    2526               pci = (PCNRITEM)CurrentRecord(hwnd);
    2527               if (pci && (INT)pci != -1)
    2528                 strcpy(path,pci->szFileName);
    2529               else
    2530                 strcpy(path,dcd->directory);
    2531               MakeValidDir(path);
    2532               WinDlgBox(HWND_DESKTOP,
    2533                         HWND_DESKTOP,
    2534                         DirSizeProc,
    2535                         FM3ModHandle,
    2536                         DSZ_FRAME,
    2537                         path);
    2538             }
    2539             break;
    2540 
    2541           case IDM_MKDIR:
    2542             {
    2543               PCNRITEM pci;
    2544 
    2545               pci = (PCNRITEM)CurrentRecord(hwnd);
    2546               PMMkDir(dcd->hwndParent,
    2547                       ((pci && (INT)pci != -1) ?
    2548                        pci->szFileName :
    2549                        dcd->directory),
    2550                       FALSE);
    2551             }
    2552             break;
    2553 
    2554           case IDM_SWITCH:
    2555             if (mp2) {
    2556               strcpy(dcd->previous,dcd->directory);
    2557               strcpy(dcd->directory,(CHAR *)mp2);
    2558               DosEnterCritSec();
    2559                dcd->stopflag++;
    2560               DosExitCritSec();
    2561               if (!PostMsg(dcd->hwndObject,
    2562                            UM_RESCAN,
    2563                            MPVOID,
    2564                            MPFROMLONG(1L)))
     2011        WinSendMsg(hwnd,
     2012                   CM_SORTRECORD,
     2013                   MPFROMP(SortDirCnr), MPFROMLONG(dcd->sortFlags));
     2014        break;
     2015
     2016      case IDM_FILTER:
     2017        {
     2018          BOOL empty = FALSE;
     2019          PCNRITEM pci;
     2020          CHAR *p;
     2021
     2022          if (!*dcd->mask.szMask) {
     2023            empty = TRUE;
     2024            pci = (PCNRITEM) CurrentRecord(hwnd);
     2025            if (pci && !(pci->attrFile & FILE_DIRECTORY)) {
     2026              p = strrchr(pci->szFileName, '\\');
     2027              if (p) {
     2028                p++;
     2029                strcpy(dcd->mask.szMask, p);
     2030              }
     2031            }
     2032          }
     2033          *(dcd->mask.prompt) = 0;
     2034
     2035          if (WinDlgBox(HWND_DESKTOP, hwnd, PickMaskDlgProc,
     2036                        FM3ModHandle, MSK_FRAME, MPFROMP(&dcd->mask)))
     2037            WinSendMsg(hwnd, UM_FILTER, MPVOID, MPVOID);
     2038          else if (empty)
     2039            *dcd->mask.szMask = 0;
     2040          SayFilter(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
     2041                                    DIR_FILTER), &dcd->mask, FALSE);
     2042        }
     2043        break;
     2044
     2045      case IDM_HIDEALL:
     2046        if (fAutoView && hwndMain)
     2047          PostMsg(hwndMain, UM_LOADFILE, MPVOID, MPVOID);
     2048        dcd->suspendview = 1;
     2049        HideAll(hwnd);
     2050        dcd->suspendview = 0;
     2051        PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
     2052        break;
     2053
     2054      case IDM_SELECTBOTH:
     2055      case IDM_SELECTONE:
     2056      case IDM_SELECTMORE:
     2057      case IDM_SELECTNEWER:
     2058      case IDM_SELECTOLDER:
     2059      case IDM_SELECTBIGGER:
     2060      case IDM_SELECTSMALLER:
     2061      case IDM_DESELECTBOTH:
     2062      case IDM_DESELECTONE:
     2063      case IDM_DESELECTMORE:
     2064      case IDM_DESELECTNEWER:
     2065      case IDM_DESELECTOLDER:
     2066      case IDM_DESELECTBIGGER:
     2067      case IDM_DESELECTSMALLER:
     2068        if (ParentIsDesktop(hwnd, dcd->hwndParent)) {
     2069          Runtime_Error(pszSrcFile, __LINE__, "ParentIsDesktop unexpected");
     2070          break;
     2071        }
     2072      case IDM_SELECTLIST:
     2073      case IDM_SELECTALL:
     2074      case IDM_DESELECTALL:
     2075      case IDM_SELECTALLFILES:
     2076      case IDM_DESELECTALLFILES:
     2077      case IDM_SELECTALLDIRS:
     2078      case IDM_DESELECTALLDIRS:
     2079      case IDM_SELECTMASK:
     2080      case IDM_DESELECTMASK:
     2081      case IDM_INVERT:
     2082      case IDM_SELECTCLIP:
     2083      case IDM_DESELECTCLIP:
     2084        {
     2085          PCNRITEM pci;
     2086
     2087          pci = (PCNRITEM) CurrentRecord(hwnd);
     2088          if ((INT) pci == -1)
     2089            pci = NULL;
     2090          if (SHORT1FROMMP(mp1) == IDM_HIDEALL) {
     2091            if (pci) {
     2092              if (!(pci->rc.flRecordAttr & CRA_SELECTED))
     2093                pci->rc.flRecordAttr |= CRA_FILTERED;
     2094              WinSendMsg(hwnd, CM_INVALIDATERECORD, MPFROMP(&pci),
     2095                         MPFROM2SHORT(1, CMA_ERASE | CMA_REPOSITION));
     2096              break;
     2097            }
     2098          }
     2099          PostMsg(dcd->hwndObject, UM_SELECT, mp1, MPFROMP(pci));
     2100        }
     2101        break;
     2102
     2103      case IDM_RESCAN:
     2104        DosEnterCritSec();
     2105        dcd->stopflag++;
     2106        DosExitCritSec();
     2107        if (!PostMsg(dcd->hwndObject, UM_RESCAN, MPVOID, MPVOID)) {
     2108          DosEnterCritSec();
     2109          dcd->stopflag--;
     2110          DosExitCritSec();
     2111        }
     2112        break;
     2113
     2114      case IDM_SHOWLNAMES:
     2115      case IDM_SHOWSUBJECT:
     2116      case IDM_SHOWEAS:
     2117      case IDM_SHOWSIZE:
     2118      case IDM_SHOWICON:
     2119      case IDM_SHOWLWDATE:
     2120      case IDM_SHOWLWTIME:
     2121      case IDM_SHOWLADATE:
     2122      case IDM_SHOWLATIME:
     2123      case IDM_SHOWCRDATE:
     2124      case IDM_SHOWCRTIME:
     2125      case IDM_SHOWATTR:
     2126        AdjustDetailsSwitches(hwnd,
     2127                              dcd->hwndLastMenu,
     2128                              SHORT1FROMMP(mp1),
     2129                              dcd->directory, "DirCnr", dcd, FALSE);
     2130        break;
     2131
     2132      case IDM_TREEVIEW:
     2133      case IDM_ICON:
     2134      case IDM_TEXT:
     2135      case IDM_DETAILS:
     2136      case IDM_NAME:
     2137      case IDM_MINIICONS:
     2138      case IDM_DETAILSTITLES:
     2139        {
     2140          CNRINFO cnri;
     2141
     2142          memset(&cnri, 0, sizeof(CNRINFO));
     2143          cnri.cb = sizeof(CNRINFO);
     2144          WinSendMsg(hwnd, CM_QUERYCNRINFO, MPFROMP(&cnri),
     2145                     MPFROMLONG(sizeof(CNRINFO)));
     2146          switch (SHORT1FROMMP(mp1)) {
     2147          case IDM_TREEVIEW:
     2148            if (!(cnri.flWindowAttr & CV_TREE))
     2149              dcd->lastattr = cnri.flWindowAttr;
     2150            cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT |
     2151                                    CV_DETAIL | CV_NAME | CA_TREELINE));
     2152            cnri.flWindowAttr |= CA_TREELINE | CV_TREE | CV_ICON;
     2153            if (!dcd->firsttree)
     2154              PostMsg(dcd->hwndObject, UM_FLESH, MPVOID, MPVOID);
     2155            break;
     2156          case IDM_ICON:
     2157            cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT |
     2158                                    CV_DETAIL | CV_NAME | CA_TREELINE));
     2159            cnri.flWindowAttr |= CV_ICON;
     2160            break;
     2161          case IDM_NAME:
     2162            cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT |
     2163                                    CV_DETAIL | CV_NAME | CA_TREELINE));
     2164            cnri.flWindowAttr |= CV_NAME;
     2165            break;
     2166          case IDM_TEXT:
     2167            cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT |
     2168                                    CV_DETAIL | CV_NAME | CA_TREELINE));
     2169            cnri.flWindowAttr |= CV_TEXT;
     2170            break;
     2171          case IDM_DETAILS:
     2172            cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT |
     2173                                    CV_DETAIL | CV_NAME | CA_TREELINE));
     2174            cnri.flWindowAttr |= CV_DETAIL;
     2175            break;
     2176          case IDM_MINIICONS:
     2177            if (cnri.flWindowAttr & CV_MINI)
     2178              cnri.flWindowAttr &= (~CV_MINI);
     2179            else
     2180              cnri.flWindowAttr |= CV_MINI;
     2181            break;
     2182          case IDM_DETAILSTITLES:
     2183            if (cnri.flWindowAttr & CA_DETAILSVIEWTITLES)
     2184              cnri.flWindowAttr &= (~CA_DETAILSVIEWTITLES);
     2185            else
     2186              cnri.flWindowAttr |= CA_DETAILSVIEWTITLES;
     2187            break;
     2188          }
     2189          cnri.flWindowAttr &= (~(CA_ORDEREDTARGETEMPH | CA_MIXEDTARGETEMPH));
     2190          cnri.flWindowAttr |= CV_FLOW;
     2191          dcd->flWindowAttr = cnri.flWindowAttr;
     2192          WinSendMsg(hwnd, CM_SETCNRINFO, MPFROMP(&cnri),
     2193                     MPFROMLONG(CMA_FLWINDOWATTR));
     2194          WinSendMsg(hwnd, CM_INVALIDATERECORD, MPVOID,
     2195                     MPFROM2SHORT(0, CMA_ERASE | CMA_REPOSITION));
     2196          SayView(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
     2197                                  DIR_VIEW), dcd->flWindowAttr);
     2198        }
     2199        break;
     2200
     2201      case IDM_SAVETOLIST:
     2202        WinDlgBox(HWND_DESKTOP, hwnd, SaveListDlgProc, FM3ModHandle,
     2203                  SAV_FRAME, MPFROMP(&hwnd));
     2204        break;
     2205
     2206      case IDM_SIZES:
     2207        {
     2208          PCNRITEM pci;
     2209          CHAR path[CCHMAXPATH];
     2210
     2211          pci = (PCNRITEM) CurrentRecord(hwnd);
     2212          if (pci && (INT) pci != -1)
     2213            strcpy(path, pci->szFileName);
     2214          else
     2215            strcpy(path, dcd->directory);
     2216          MakeValidDir(path);
     2217          WinDlgBox(HWND_DESKTOP,
     2218                    HWND_DESKTOP, DirSizeProc, FM3ModHandle, DSZ_FRAME, path);
     2219        }
     2220        break;
     2221
     2222      case IDM_MKDIR:
     2223        {
     2224          PCNRITEM pci;
     2225
     2226          pci = (PCNRITEM) CurrentRecord(hwnd);
     2227          PMMkDir(dcd->hwndParent,
     2228                  ((pci && (INT) pci != -1) ?
     2229                   pci->szFileName : dcd->directory), FALSE);
     2230        }
     2231        break;
     2232
     2233      case IDM_SWITCH:
     2234        if (mp2) {
     2235          strcpy(dcd->previous, dcd->directory);
     2236          strcpy(dcd->directory, (CHAR *) mp2);
     2237          DosEnterCritSec();
     2238          dcd->stopflag++;
     2239          DosExitCritSec();
     2240          if (!PostMsg(dcd->hwndObject, UM_RESCAN, MPVOID, MPFROMLONG(1L))) {
     2241            strcpy(dcd->directory, dcd->previous);
     2242            DosEnterCritSec();
     2243            dcd->stopflag--;
     2244            DosExitCritSec();
     2245          }
     2246          else if (*dcd->directory) {
     2247            if (hwndMain)
     2248              WinSendMsg(hwndMain,
     2249                         UM_SETUSERLISTNAME, MPFROMP(dcd->directory), MPVOID);
     2250            else
     2251              add_udir(FALSE, dcd->directory);
     2252          }
     2253        }
     2254        break;
     2255
     2256      case IDM_PARENT:
     2257        {
     2258          CHAR tempname1[CCHMAXPATH], tempname2[CCHMAXPATH];
     2259
     2260          strcpy(tempname1, dcd->directory);
     2261          if (tempname1[strlen(tempname1) - 1] != '\\')
     2262            strcat(tempname1, "\\");
     2263          strcat(tempname1, "..");
     2264          DosError(FERR_DISABLEHARDERR);
     2265          if (!DosQueryPathInfo(tempname1,
     2266                                FIL_QUERYFULLNAME,
     2267                                tempname2, sizeof(tempname2))) {
     2268            if (stricmp(dcd->directory, tempname2)) {
     2269              strcpy(dcd->previous, dcd->directory);
     2270              strcpy(dcd->directory, tempname2);
     2271              DosEnterCritSec();
     2272              dcd->stopflag++;
     2273              DosExitCritSec();
     2274              if (!PostMsg(dcd->hwndObject,
     2275                           UM_RESCAN, MPVOID, MPFROMLONG(1L))) {
     2276                strcpy(dcd->directory, dcd->previous);
     2277                DosEnterCritSec();
     2278                dcd->stopflag--;
     2279                DosExitCritSec();
     2280              }
     2281              else if (*dcd->directory) {
     2282                if (hwndMain)
     2283                  WinSendMsg(hwndMain,
     2284                             UM_SETUSERLISTNAME,
     2285                             MPFROMP(dcd->directory), MPVOID);
     2286                else
     2287                  add_udir(FALSE, dcd->directory);
     2288              }
     2289            }
     2290          }
     2291        }
     2292        break;
     2293
     2294      case IDM_PREVIOUS:
     2295        if (*dcd->previous && stricmp(dcd->directory, dcd->previous)) {
     2296
     2297          CHAR tempname[CCHMAXPATH];
     2298
     2299          if (IsValidDir(dcd->previous)) {
     2300            strcpy(tempname, dcd->directory);
     2301            strcpy(dcd->directory, dcd->previous);
     2302            strcpy(dcd->previous, tempname);
     2303            DosEnterCritSec();
     2304            dcd->stopflag++;
     2305            DosExitCritSec();
     2306            if (!PostMsg(dcd->hwndObject, UM_RESCAN, MPVOID, MPFROMLONG(1L))) {
     2307              strcpy(dcd->directory, dcd->previous);
     2308              DosEnterCritSec();
     2309              dcd->stopflag--;
     2310              DosExitCritSec();
     2311            }
     2312            else if (*dcd->directory) {
     2313              if (hwndMain)
     2314                WinSendMsg(hwndMain,
     2315                           UM_SETUSERLISTNAME,
     2316                           MPFROMP(dcd->directory), MPVOID);
     2317              else
     2318                add_udir(FALSE, dcd->directory);
     2319            }
     2320          }
     2321          else
     2322            *dcd->previous = 0;
     2323        }
     2324        break;
     2325
     2326      case IDM_WALKDIR:
     2327        {
     2328          CHAR newdir[CCHMAXPATH];
     2329
     2330          strcpy(newdir, dcd->directory);
     2331          if (!WinDlgBox(HWND_DESKTOP,
     2332                         dcd->hwndParent,
     2333                         WalkAllDlgProc,
     2334                         FM3ModHandle,
     2335                         WALK_FRAME, MPFROMP(newdir)) || !*newdir)
     2336            break;
     2337          if (stricmp(newdir, dcd->directory)) {
     2338            strcpy(dcd->previous, dcd->directory);
     2339            strcpy(dcd->directory, newdir);
     2340            DosEnterCritSec();
     2341            dcd->stopflag++;
     2342            DosExitCritSec();
     2343            if (!PostMsg(dcd->hwndObject, UM_RESCAN, MPVOID, MPFROMLONG(1L))) {
     2344              strcpy(dcd->directory, dcd->previous);
     2345              DosEnterCritSec();
     2346              dcd->stopflag--;
     2347              DosExitCritSec();
     2348            }
     2349            else if (*dcd->directory) {
     2350              if (hwndMain)
     2351                WinSendMsg(hwndMain,
     2352                           UM_SETUSERLISTNAME,
     2353                           MPFROMP(dcd->directory), MPVOID);
     2354              else
     2355                add_udir(FALSE, dcd->directory);
     2356            }
     2357          }
     2358        }
     2359        break;
     2360
     2361      case IDM_OPENICONME:
     2362        OpenObject(dcd->directory, "ICON", dcd->hwndFrame);
     2363        break;
     2364      case IDM_OPENDETAILSME:
     2365        OpenObject(dcd->directory, "DETAILS", dcd->hwndFrame);
     2366        break;
     2367      case IDM_OPENTREEME:
     2368        OpenObject(dcd->directory, "TREE", dcd->hwndFrame);
     2369        break;
     2370      case IDM_OPENSETTINGSME:
     2371        OpenObject(dcd->directory, Settings, dcd->hwndFrame);
     2372        break;
     2373
     2374      case IDM_DOITYOURSELF:
     2375      case IDM_UPDATE:
     2376      case IDM_OPENWINDOW:
     2377      case IDM_OPENSETTINGS:
     2378      case IDM_OPENDEFAULT:
     2379      case IDM_OPENICON:
     2380      case IDM_OPENDETAILS:
     2381      case IDM_OPENTREE:
     2382      case IDM_OBJECT:
     2383      case IDM_SHADOW:
     2384      case IDM_SHADOW2:
     2385      case IDM_DELETE:
     2386      case IDM_PERMDELETE:
     2387      case IDM_PRINT:
     2388      case IDM_ATTRS:
     2389      case IDM_INFO:
     2390      case IDM_COPY:
     2391      case IDM_MOVE:
     2392      case IDM_WPSMOVE:
     2393      case IDM_WPSCOPY:
     2394      case IDM_WILDCOPY:
     2395      case IDM_WILDMOVE:
     2396      case IDM_RENAME:
     2397      case IDM_COMPARE:
     2398      case IDM_EAS:
     2399      case IDM_SUBJECT:
     2400      case IDM_VIEW:
     2401      case IDM_VIEWTEXT:
     2402      case IDM_VIEWBINARY:
     2403      case IDM_VIEWARCHIVE:
     2404      case IDM_EDIT:
     2405      case IDM_EDITTEXT:
     2406      case IDM_EDITBINARY:
     2407      case IDM_SAVETOCLIP:
     2408      case IDM_APPENDTOCLIP:
     2409      case IDM_ARCHIVE:
     2410      case IDM_ARCHIVEM:
     2411      case IDM_EXTRACT:
     2412      case IDM_MCIPLAY:
     2413      case IDM_COLLECTFROMFILE:
     2414      case IDM_UUDECODE:
     2415      case IDM_MERGE:
     2416        {
     2417          LISTINFO *li;
     2418          ULONG action = UM_ACTION;
     2419
     2420          li = xmallocz(sizeof(LISTINFO), pszSrcFile, __LINE__);
     2421          if (li) {
     2422            li->type = SHORT1FROMMP(mp1);
     2423            li->hwnd = hwnd;
     2424            li->list = BuildList(hwnd);
     2425            switch (SHORT1FROMMP(mp1)) {
     2426            case IDM_WILDMOVE:
     2427            case IDM_WILDCOPY:
     2428            case IDM_MOVE:
     2429            case IDM_COPY:
     2430            case IDM_WPSMOVE:
     2431            case IDM_WPSCOPY:
     2432              break;
     2433            default:
     2434              strcpy(li->targetpath, dcd->directory);
     2435              break;
     2436            }
     2437            if (li->list) {
     2438              if (SHORT1FROMMP(mp1) == IDM_COLLECTFROMFILE) {
     2439                if (!Collector) {
     2440
     2441                  HWND hwndC;
     2442                  SWP swp;
     2443
     2444                  if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
     2445                      !fAutoTile &&
     2446                      (!fExternalCollector && !strcmp(realappname, FM3Str)))
     2447                    GetNextWindowPos(dcd->hwndParent, &swp, NULL, NULL);
     2448                  hwndC = StartCollector((fExternalCollector ||
     2449                                          strcmp(realappname, FM3Str)) ?
     2450                                         HWND_DESKTOP : dcd->hwndParent, 4);
     2451                  if (hwndC) {
     2452                    if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
     2453                        !fAutoTile && (!fExternalCollector &&
     2454                                       !strcmp(realappname, FM3Str)))
     2455                      WinSetWindowPos(hwndC, HWND_TOP, swp.x, swp.y,
     2456                                      swp.cx, swp.cy, SWP_MOVE | SWP_SIZE |
     2457                                      SWP_SHOW | SWP_ZORDER);
     2458                    else if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
     2459                             fAutoTile && !strcmp(realappname, FM3Str))
     2460                      TileChildren(dcd->hwndParent, TRUE);
     2461                    WinSetWindowPos(hwndC, HWND_TOP, 0, 0, 0, 0,
     2462                                    SWP_ACTIVATE);
     2463                    DosSleep(250L);
     2464                  }
     2465                }
     2466                else
     2467                  StartCollector(dcd->hwndParent, 4);
     2468              }
     2469              switch (SHORT1FROMMP(mp1)) {
     2470              case IDM_APPENDTOCLIP:
     2471              case IDM_SAVETOCLIP:
     2472              case IDM_ARCHIVE:
     2473              case IDM_ARCHIVEM:
     2474              case IDM_DELETE:
     2475              case IDM_PERMDELETE:
     2476              case IDM_ATTRS:
     2477              case IDM_PRINT:
     2478              case IDM_SHADOW:
     2479              case IDM_SHADOW2:
     2480              case IDM_OBJECT:
     2481              case IDM_VIEW:
     2482              case IDM_VIEWTEXT:
     2483              case IDM_VIEWBINARY:
     2484              case IDM_EDIT:
     2485              case IDM_EDITTEXT:
     2486              case IDM_EDITBINARY:
     2487              case IDM_MCIPLAY:
     2488              case IDM_UPDATE:
     2489              case IDM_DOITYOURSELF:
     2490              case IDM_INFO:
     2491              case IDM_EAS:
     2492                action = UM_MASSACTION;
     2493                break;
     2494              }
     2495              if (SHORT1FROMMP(mp1) == IDM_OBJECT ||
     2496                  SHORT1FROMMP(mp1) == IDM_SHADOW ||
     2497                  SHORT1FROMMP(mp1) == IDM_SHADOW2)
     2498                *li->targetpath = 0;
     2499              if (!PostMsg(dcd->hwndObject, action, MPFROMP(li), MPVOID)) {
     2500                Runtime_Error(pszSrcFile, __LINE__, "PostMsg");
     2501                FreeListInfo(li);
     2502              }
     2503              else if (fUnHilite)
     2504                UnHilite(hwnd, TRUE, &dcd->lastselection);
     2505            }
     2506            else
     2507              free(li);
     2508          }
     2509        }
     2510        break;
     2511
     2512      case IDM_DRIVESMENU:
     2513        if (!hwndMain)
     2514          PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_WALKDIR, 0), MPVOID);
     2515        break;
     2516
     2517      default:
     2518        if (SwitchCommand(dcd->hwndLastMenu, SHORT1FROMMP(mp1)))
     2519          return 0;
     2520        else {
     2521          if (SHORT1FROMMP(mp1) >= IDM_COMMANDSTART &&
     2522              SHORT1FROMMP(mp1) < IDM_QUICKTOOLSTART) {
     2523
     2524            register INT x;
     2525
     2526            if (!cmdloaded)
     2527              load_commands();
     2528            x = SHORT1FROMMP(mp1) - IDM_COMMANDSTART;
     2529            if (x >= 0) {
     2530              x++;
     2531              RunCommand(hwnd, x);
     2532              if (fUnHilite)
     2533                UnHilite(hwnd, TRUE, &dcd->lastselection);
     2534            }
     2535          }
     2536        }
     2537        break;
     2538      }
     2539    }
     2540    return 0;
     2541
     2542  case UM_FIXCNRMLE:
     2543  case UM_FIXEDITNAME:
     2544    return CommonCnrProc(hwnd, msg, mp1, mp2);
     2545
     2546  case UM_FILESMENU:
     2547    {
     2548      PCNRITEM pci;
     2549      HWND menuHwnd = (HWND) 0;
     2550
     2551      pci = (PCNRITEM) CurrentRecord(hwnd);
     2552      if (pci && (INT) pci != -1) {
     2553        if (pci->attrFile & FILE_DIRECTORY) {
     2554          menuHwnd = CheckMenu(&DirMenu, DIR_POPUP);
     2555//            WinEnableMenuItem(DirMenu,IDM_TREE,TRUE);
     2556        }
     2557        else
     2558          menuHwnd = CheckMenu(&FileMenu, FILE_POPUP);
     2559      }
     2560      return MRFROMLONG(menuHwnd);
     2561    }
     2562
     2563  case WM_CONTROL:
     2564    DosError(FERR_DISABLEHARDERR);
     2565    if (dcd) {
     2566      switch (SHORT2FROMMP(mp1)) {
     2567      case CN_COLLAPSETREE:
     2568      case CN_EXPANDTREE:
     2569        {
     2570          PCNRITEM pci = (PCNRITEM) mp2;
     2571
     2572          if (pci && (INT) pci != -1 && !(pci->flags & RECFLAGS_ENV)) {
     2573            if (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_REMOVABLE) {
     2574              struct
    25652575              {
    2566                 strcpy(dcd->directory,
    2567                        dcd->previous);
    2568                 DosEnterCritSec();
    2569                  dcd->stopflag--;
    2570                 DosExitCritSec();
    2571               }
    2572               else if (*dcd->directory) {
    2573                 if (hwndMain)
    2574                   WinSendMsg(hwndMain,
    2575                              UM_SETUSERLISTNAME,
    2576                              MPFROMP(dcd->directory),
    2577                              MPVOID);
    2578                 else
    2579                   add_udir(FALSE,dcd->directory);
    2580               }
    2581             }
    2582             break;
    2583 
    2584           case IDM_PARENT:
    2585             {
    2586               CHAR tempname1[CCHMAXPATH],
    2587                    tempname2[CCHMAXPATH];
    2588 
    2589               strcpy(tempname1,dcd->directory);
    2590               if (tempname1[strlen(tempname1) - 1] != '\\')
    2591                 strcat(tempname1,"\\");
    2592               strcat(tempname1,"..");
    2593               DosError(FERR_DISABLEHARDERR);
    2594               if (!DosQueryPathInfo(tempname1,
    2595                                     FIL_QUERYFULLNAME,
    2596                                     tempname2,
    2597                                     sizeof(tempname2))) {
    2598                 if (stricmp(dcd->directory,tempname2)) {
    2599                   strcpy(dcd->previous,dcd->directory);
    2600                   strcpy(dcd->directory,tempname2);
    2601                   DosEnterCritSec();
    2602                    dcd->stopflag++;
    2603                   DosExitCritSec();
    2604                   if (!PostMsg(dcd->hwndObject,
    2605                                UM_RESCAN,
    2606                                MPVOID,
    2607                                MPFROMLONG(1L))) {
    2608                     strcpy(dcd->directory,dcd->previous);
    2609                     DosEnterCritSec();
    2610                      dcd->stopflag--;
    2611                     DosExitCritSec();
    2612                   }
    2613                   else if (*dcd->directory) {
    2614                     if (hwndMain)
    2615                       WinSendMsg(hwndMain,
    2616                                  UM_SETUSERLISTNAME,
    2617                                  MPFROMP(dcd->directory),
    2618                                  MPVOID);
    2619                     else
    2620                       add_udir(FALSE,
    2621                                dcd->directory);
    2622                   }
    2623                 }
    2624               }
    2625             }
    2626             break;
    2627 
    2628           case IDM_PREVIOUS:
    2629             if (*dcd->previous &&
    2630                 stricmp(dcd->directory,dcd->previous)) {
    2631 
    2632               CHAR tempname[CCHMAXPATH];
    2633 
    2634               if (IsValidDir(dcd->previous)) {
    2635                 strcpy(tempname,dcd->directory);
    2636                 strcpy(dcd->directory,dcd->previous);
    2637                 strcpy(dcd->previous,tempname);
    2638                 DosEnterCritSec();
    2639                  dcd->stopflag++;
    2640                 DosExitCritSec();
    2641                 if (!PostMsg(dcd->hwndObject,
    2642                              UM_RESCAN,
    2643                              MPVOID,
    2644                              MPFROMLONG(1L))) {
    2645                   strcpy(dcd->directory,dcd->previous);
    2646                   DosEnterCritSec();
    2647                    dcd->stopflag--;
    2648                   DosExitCritSec();
    2649                 }
    2650                 else if (*dcd->directory) {
    2651                   if (hwndMain)
    2652                     WinSendMsg(hwndMain,
    2653                                UM_SETUSERLISTNAME,
    2654                                MPFROMP(dcd->directory),
    2655                                MPVOID);
    2656                   else
    2657                     add_udir(FALSE,
    2658                              dcd->directory);
    2659                 }
    2660               }
    2661               else
    2662                 *dcd->previous = 0;
    2663             }
    2664             break;
    2665 
    2666           case IDM_WALKDIR:
    2667             {
    2668               CHAR newdir[CCHMAXPATH];
    2669 
    2670               strcpy(newdir,dcd->directory);
    2671               if (!WinDlgBox(HWND_DESKTOP,
    2672                              dcd->hwndParent,
    2673                              WalkAllDlgProc,
    2674                              FM3ModHandle,
    2675                              WALK_FRAME,
    2676                              MPFROMP(newdir)) ||
    2677                   !*newdir)
    2678                 break;
    2679               if (stricmp(newdir,dcd->directory)) {
    2680                 strcpy(dcd->previous,dcd->directory);
    2681                 strcpy(dcd->directory,newdir);
    2682                 DosEnterCritSec();
    2683                  dcd->stopflag++;
    2684                 DosExitCritSec();
    2685                 if (!PostMsg(dcd->hwndObject,
    2686                              UM_RESCAN,
    2687                              MPVOID,
    2688                              MPFROMLONG(1L))) {
    2689                   strcpy(dcd->directory,dcd->previous);
    2690                   DosEnterCritSec();
    2691                    dcd->stopflag--;
    2692                   DosExitCritSec();
    2693                 }
    2694                 else if (*dcd->directory) {
    2695                   if (hwndMain)
    2696                     WinSendMsg(hwndMain,
    2697                                UM_SETUSERLISTNAME,
    2698                                MPFROMP(dcd->directory),
    2699                                MPVOID);
    2700                   else
    2701                     add_udir(FALSE,
    2702                              dcd->directory);
    2703                 }
    2704               }
    2705             }
    2706             break;
    2707 
    2708           case IDM_OPENICONME:
    2709             OpenObject(dcd->directory,
    2710                        "ICON",
    2711                        dcd->hwndFrame);
    2712             break;
    2713           case IDM_OPENDETAILSME:
    2714             OpenObject(dcd->directory,
    2715                        "DETAILS",
    2716                        dcd->hwndFrame);
    2717             break;
    2718           case IDM_OPENTREEME:
    2719             OpenObject(dcd->directory,
    2720                        "TREE",
    2721                        dcd->hwndFrame);
    2722             break;
    2723           case IDM_OPENSETTINGSME:
    2724             OpenObject(dcd->directory,
    2725                        Settings,
    2726                        dcd->hwndFrame);
    2727             break;
    2728 
    2729           case IDM_DOITYOURSELF:
    2730           case IDM_UPDATE:
    2731           case IDM_OPENWINDOW:
    2732           case IDM_OPENSETTINGS:
    2733           case IDM_OPENDEFAULT:
    2734           case IDM_OPENICON:
    2735           case IDM_OPENDETAILS:
    2736           case IDM_OPENTREE:
    2737           case IDM_OBJECT:
    2738           case IDM_SHADOW:
    2739           case IDM_SHADOW2:
    2740           case IDM_DELETE:
    2741           case IDM_PERMDELETE:
    2742           case IDM_PRINT:
    2743           case IDM_ATTRS:
    2744           case IDM_INFO:
    2745           case IDM_COPY:
    2746           case IDM_MOVE:
    2747           case IDM_WPSMOVE:
    2748           case IDM_WPSCOPY:
    2749           case IDM_WILDCOPY:
    2750           case IDM_WILDMOVE:
    2751           case IDM_RENAME:
    2752           case IDM_COMPARE:
    2753           case IDM_EAS:
    2754           case IDM_SUBJECT:
    2755           case IDM_VIEW:
    2756           case IDM_VIEWTEXT:
    2757           case IDM_VIEWBINARY:
    2758           case IDM_VIEWARCHIVE:
    2759           case IDM_EDIT:
    2760           case IDM_EDITTEXT:
    2761           case IDM_EDITBINARY:
    2762           case IDM_SAVETOCLIP:
    2763           case IDM_APPENDTOCLIP:
    2764           case IDM_ARCHIVE:
    2765           case IDM_ARCHIVEM:
    2766           case IDM_EXTRACT:
    2767           case IDM_MCIPLAY:
    2768           case IDM_COLLECTFROMFILE:
    2769           case IDM_UUDECODE:
    2770           case IDM_MERGE:
    2771             {
    2772               LISTINFO *li;
    2773               ULONG     action = UM_ACTION;
    2774 
    2775               li = xmallocz(sizeof(LISTINFO),pszSrcFile,__LINE__);
    2776               if (li) {
    2777                 li->type = SHORT1FROMMP(mp1);
    2778                 li->hwnd = hwnd;
    2779                 li->list = BuildList(hwnd);
    2780                 switch(SHORT1FROMMP(mp1)) {
    2781                   case IDM_WILDMOVE:
    2782                   case IDM_WILDCOPY:
    2783                   case IDM_MOVE:
    2784                   case IDM_COPY:
    2785                   case IDM_WPSMOVE:
    2786                   case IDM_WPSCOPY:
    2787                     break;
    2788                   default:
    2789                     strcpy(li->targetpath,dcd->directory);
    2790                     break;
    2791                 }
    2792                 if (li->list) {
    2793                   if (SHORT1FROMMP(mp1) == IDM_COLLECTFROMFILE) {
    2794                     if (!Collector) {
    2795 
    2796                       HWND hwndC;
    2797                       SWP  swp;
    2798 
    2799                       if (!ParentIsDesktop(hwnd,dcd->hwndParent) &&
    2800                          !fAutoTile &&
    2801                          (!fExternalCollector && !strcmp(realappname,FM3Str)))
    2802                         GetNextWindowPos(dcd->hwndParent,&swp,NULL,NULL);
    2803                       hwndC = StartCollector((fExternalCollector ||
    2804                                               strcmp(realappname,FM3Str)) ?
    2805                                              HWND_DESKTOP :
    2806                                              dcd->hwndParent,4);
    2807                       if (hwndC) {
    2808                         if (!ParentIsDesktop(hwnd,dcd->hwndParent) &&
    2809                            !fAutoTile && (!fExternalCollector &&
    2810                            !strcmp(realappname,FM3Str)))
    2811                           WinSetWindowPos(hwndC,HWND_TOP,swp.x,swp.y,
    2812                                           swp.cx,swp.cy,SWP_MOVE | SWP_SIZE |
    2813                                           SWP_SHOW | SWP_ZORDER);
    2814                         else if (!ParentIsDesktop(hwnd,dcd->hwndParent) &&
    2815                                 fAutoTile && !strcmp(realappname,FM3Str))
    2816                           TileChildren(dcd->hwndParent,TRUE);
    2817                         WinSetWindowPos(hwndC,HWND_TOP,0,0,0,0,SWP_ACTIVATE);
    2818                         DosSleep(250L);
    2819                       }
    2820                     }
    2821                     else
    2822                       StartCollector(dcd->hwndParent,4);
    2823                   }
    2824                   switch(SHORT1FROMMP(mp1)) {
    2825                     case IDM_APPENDTOCLIP:
    2826                     case IDM_SAVETOCLIP:
    2827                     case IDM_ARCHIVE:
    2828                     case IDM_ARCHIVEM:
    2829                     case IDM_DELETE:
    2830                     case IDM_PERMDELETE:
    2831                     case IDM_ATTRS:
    2832                     case IDM_PRINT:
    2833                     case IDM_SHADOW:
    2834                     case IDM_SHADOW2:
    2835                     case IDM_OBJECT:
    2836                     case IDM_VIEW:
    2837                     case IDM_VIEWTEXT:
    2838                     case IDM_VIEWBINARY:
    2839                     case IDM_EDIT:
    2840                     case IDM_EDITTEXT:
    2841                     case IDM_EDITBINARY:
    2842                     case IDM_MCIPLAY:
    2843                     case IDM_UPDATE:
    2844                     case IDM_DOITYOURSELF:
    2845                     case IDM_INFO:
    2846                     case IDM_EAS:
    2847                       action = UM_MASSACTION;
    2848                       break;
    2849                   }
    2850                   if (SHORT1FROMMP(mp1) == IDM_OBJECT ||
    2851                      SHORT1FROMMP(mp1) == IDM_SHADOW ||
    2852                      SHORT1FROMMP(mp1) == IDM_SHADOW2)
    2853                     *li->targetpath = 0;
    2854                   if (!PostMsg(dcd->hwndObject,
    2855                                action,
    2856                                MPFROMP(li),
    2857                                MPVOID)) {
    2858                     Runtime_Error(pszSrcFile, __LINE__, "PostMsg");
    2859                     FreeListInfo(li);
    2860                   }
    2861                   else if (fUnHilite)
    2862                     UnHilite(hwnd,
    2863                              TRUE,
    2864                              &dcd->lastselection);
    2865                 }
    2866                 else
    2867                   free(li);
    2868               }
    2869             }
    2870             break;
    2871 
    2872           case IDM_DRIVESMENU:
    2873             if (!hwndMain)
    2874               PostMsg(hwnd,
    2875                       WM_COMMAND,
    2876                       MPFROM2SHORT(IDM_WALKDIR,0),
    2877                       MPVOID);
    2878             break;
    2879 
    2880           default:
    2881             if (SwitchCommand(dcd->hwndLastMenu,
    2882                               SHORT1FROMMP(mp1)))
    2883               return 0;
    2884             else {
    2885               if (SHORT1FROMMP(mp1) >= IDM_COMMANDSTART &&
    2886                  SHORT1FROMMP(mp1) < IDM_QUICKTOOLSTART) {
    2887 
    2888                 register INT x;
    2889 
    2890                 if (!cmdloaded)
    2891                   load_commands();
    2892                 x = SHORT1FROMMP(mp1) - IDM_COMMANDSTART;
    2893                 if (x >= 0) {
    2894                   x++;
    2895                   RunCommand(hwnd,x);
    2896                   if (fUnHilite)
    2897                     UnHilite(hwnd,
    2898                              TRUE,
    2899                              &dcd->lastselection);
    2900                 }
    2901               }
    2902             }
    2903             break;
    2904         }
    2905       }
    2906       return 0;
    2907 
    2908     case UM_FIXCNRMLE:
    2909     case UM_FIXEDITNAME:
    2910       return CommonCnrProc(hwnd,msg,mp1,mp2);
    2911 
    2912     case UM_FILESMENU:
    2913       {
    2914         PCNRITEM pci;
    2915         HWND     menuHwnd = (HWND)0;
    2916 
    2917         pci = (PCNRITEM)CurrentRecord(hwnd);
    2918         if (pci && (INT)pci != -1) {
    2919           if (pci->attrFile & FILE_DIRECTORY) {
    2920             menuHwnd = CheckMenu(&DirMenu,
    2921                                  DIR_POPUP);
    2922 //            WinEnableMenuItem(DirMenu,IDM_TREE,TRUE);
    2923           }
    2924           else
    2925             menuHwnd = CheckMenu(&FileMenu,
    2926                                  FILE_POPUP);
    2927         }
    2928         return MRFROMLONG(menuHwnd);
    2929       }
    2930 
    2931     case WM_CONTROL:
    2932       DosError(FERR_DISABLEHARDERR);
    2933       if (dcd) {
    2934         switch(SHORT2FROMMP(mp1)) {
    2935           case CN_COLLAPSETREE:
    2936           case CN_EXPANDTREE:
    2937             {
    2938               PCNRITEM pci = (PCNRITEM)mp2;
    2939 
    2940               if (pci &&
    2941                   (INT)pci != -1 &&
    2942                   !(pci->flags & RECFLAGS_ENV))
    2943               {
    2944                 if (driveflags[toupper(*pci->szFileName) - 'A'] &
    2945                     DRIVE_REMOVABLE)
    2946                 {
    2947                   struct {
    2948                     ULONG serial;
    2949                     CHAR  volumelength;
    2950                     CHAR  volumelabel[CCHMAXPATH];
    2951                   } volser;
    2952                   APIRET rc;
    2953 
    2954                   memset(&volser,0,sizeof(volser));
    2955                   DosError(FERR_DISABLEHARDERR);
    2956                   // fixme
    2957                   rc = DosQueryFSInfo(toupper(*pci->szFileName) - '@',
    2958                                       FSIL_VOLSER,
    2959                                       &volser,
    2960                                       sizeof(volser));
    2961                   if (rc) {
    2962                     Dos_Error(MB_ENTER,
    2963                               rc,
    2964                               HWND_DESKTOP,
    2965                               pszSrcFile,
    2966                               __LINE__,
    2967                               // fixme GetPString(IDS_CANTFINDDIRTEXT),
    2968                               "Can't find drive %s",
    2969                               pci->szFileName);
    2970                     // fixme DosBeep(250,100);
    2971                     driveserial[toupper(*pci->szFileName) - 'A'] = -1;
    2972                     UnFlesh(hwnd,pci);
    2973                     PostMsg(hwnd,
    2974                             UM_RESCAN,
    2975                             MPVOID,
    2976                             MPVOID);
    2977                   }
    2978                   else {
    2979                     if (SHORT2FROMMP(mp1) == CN_COLLAPSETREE &&
    2980                        !volser.serial ||
    2981                        driveserial[toupper(*pci->szFileName) - 'A'] !=
    2982                          volser.serial)
    2983                       UnFlesh(hwnd,pci);
    2984                     if (SHORT2FROMMP(mp1) != CN_COLLAPSETREE ||
    2985                        (!volser.serial ||
    2986                         driveserial[toupper(*pci->szFileName) - 'A'] !=
    2987                           volser.serial)) {
    2988                       if (Flesh(hwnd,pci) &&
    2989                          SHORT2FROMMP(mp1) == CN_EXPANDTREE &&
    2990                          !dcd->suspendview && fTopDir)
    2991                         PostMsg(hwnd,UM_TOPDIR,MPFROMP(pci),MPVOID);
    2992                     }
    2993                     driveserial[toupper(*pci->szFileName) - 'A'] =
    2994                       volser.serial;
    2995                   }
    2996                 }
    2997                 else if (SHORT2FROMMP(mp1) == CN_EXPANDTREE) {
    2998                   if (Flesh(hwnd,pci) &&
    2999                      !dcd->suspendview && fTopDir)
    3000                     PostMsg(hwnd,
    3001                             UM_TOPDIR,
    3002                             MPFROMP(pci),
    3003                             MPVOID);
    3004                 }
    3005                 if (SHORT2FROMMP(mp1) == CN_EXPANDTREE &&
    3006                    !dcd->suspendview)
    3007                   WinSendMsg(hwnd,
    3008                              UM_FILTER,
    3009                              MPVOID,
    3010                              MPVOID);
    3011               }
    3012             }
    3013             break;
     2576                ULONG serial;
     2577                CHAR volumelength;
     2578                CHAR volumelabel[CCHMAXPATH];
     2579              }
     2580              volser;
     2581              APIRET rc;
     2582
     2583              memset(&volser, 0, sizeof(volser));
     2584              DosError(FERR_DISABLEHARDERR);
     2585              // fixme
     2586              rc = DosQueryFSInfo(toupper(*pci->szFileName) - '@',
     2587                                  FSIL_VOLSER, &volser, sizeof(volser));
     2588              if (rc) {
     2589                Dos_Error(MB_ENTER, rc, HWND_DESKTOP, pszSrcFile, __LINE__,
     2590                          // fixme GetPString(IDS_CANTFINDDIRTEXT),
     2591                          "Can't find drive %s", pci->szFileName);
     2592                // fixme DosBeep(250,100);
     2593                driveserial[toupper(*pci->szFileName) - 'A'] = -1;
     2594                UnFlesh(hwnd, pci);
     2595                PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
     2596              }
     2597              else {
     2598                if (SHORT2FROMMP(mp1) == CN_COLLAPSETREE &&
     2599                    !volser.serial ||
     2600                    driveserial[toupper(*pci->szFileName) - 'A'] !=
     2601                    volser.serial)
     2602                  UnFlesh(hwnd, pci);
     2603                if (SHORT2FROMMP(mp1) != CN_COLLAPSETREE ||
     2604                    (!volser.serial ||
     2605                     driveserial[toupper(*pci->szFileName) - 'A'] !=
     2606                     volser.serial)) {
     2607                  if (Flesh(hwnd, pci) &&
     2608                      SHORT2FROMMP(mp1) == CN_EXPANDTREE &&
     2609                      !dcd->suspendview && fTopDir)
     2610                    PostMsg(hwnd, UM_TOPDIR, MPFROMP(pci), MPVOID);
     2611                }
     2612                driveserial[toupper(*pci->szFileName) - 'A'] = volser.serial;
     2613              }
     2614            }
     2615            else if (SHORT2FROMMP(mp1) == CN_EXPANDTREE) {
     2616              if (Flesh(hwnd, pci) && !dcd->suspendview && fTopDir)
     2617                PostMsg(hwnd, UM_TOPDIR, MPFROMP(pci), MPVOID);
     2618            }
     2619            if (SHORT2FROMMP(mp1) == CN_EXPANDTREE && !dcd->suspendview)
     2620              WinSendMsg(hwnd, UM_FILTER, MPVOID, MPVOID);
     2621          }
     2622        }
     2623        break;
    30142624
    30152625/*
    … …  
    30182628*/
    30192629
    3020           case CN_CONTEXTMENU:
    3021             {
    3022               PCNRITEM pci = (PCNRITEM)mp2;
    3023 
    3024               if (pci) {
    3025                 WinSendMsg(hwnd,
    3026                            CM_SETRECORDEMPHASIS,
    3027                            MPFROMP(pci),
    3028                            MPFROM2SHORT(TRUE,CRA_CURSORED));
    3029                 MarkAll(hwnd,
    3030                         FALSE,
    3031                         FALSE,
    3032                         TRUE);
    3033                 if (pci->attrFile & FILE_DIRECTORY)
    3034                   dcd->hwndLastMenu = CheckMenu(&DirMenu,DIR_POPUP);
    3035                 else
    3036                   dcd->hwndLastMenu = CheckMenu(&FileMenu,FILE_POPUP);
    3037               }
    3038               else {
    3039                 dcd->hwndLastMenu = CheckMenu(&DirCnrMenu,DIRCNR_POPUP);
    3040                 if (dcd->hwndLastMenu && !dcd->cnremphasized) {
    3041                   WinSendMsg(hwnd,
    3042                              CM_SETRECORDEMPHASIS,
    3043                              MPVOID,
    3044                              MPFROM2SHORT(TRUE,CRA_SOURCE));
    3045                   dcd->cnremphasized = TRUE;
    3046                 }
    3047               }
    3048               if (dcd->hwndLastMenu) {
    3049                 if (dcd->hwndLastMenu == DirCnrMenu) {
    3050                   if (dcd->flWindowAttr & CV_MINI)
    3051                     WinCheckMenuItem(dcd->hwndLastMenu,
    3052                                      IDM_MINIICONS,
    3053                                      TRUE);
    3054                 }
    3055                 if (dcd->hwndLastMenu == DirMenu)
    3056                   WinEnableMenuItem(DirMenu,
    3057                                     IDM_TREE,
    3058                                     TRUE);
    3059                 if (!PopupMenu(hwnd,hwnd,dcd->hwndLastMenu)) {
    3060                   if (dcd->cnremphasized) {
    3061                     WinSendMsg(hwnd,
    3062                                CM_SETRECORDEMPHASIS,
    3063                                MPVOID,
    3064                                MPFROM2SHORT(FALSE,CRA_SOURCE));
    3065                     dcd->cnremphasized = TRUE;
    3066                   }
    3067                   MarkAll(hwnd,TRUE,FALSE,TRUE);
    3068                 }
    3069               }
    3070             }
    3071             break;
    3072 
    3073           case CN_DROPHELP:
    3074             if (mp2) {
    3075 
    3076               PDRAGINFO   pDInfo;
    3077               PCNRITEM    pci;
    3078               ULONG       numitems;
    3079               USHORT      usOperation;
    3080 
    3081               pci = (PCNRITEM)((PCNRDRAGINFO)mp2)->pRecord;
    3082               pDInfo = (PDRAGINFO)((PCNRDRAGINFO)mp2)->pDragInfo;
    3083               if (!DrgAccessDraginfo(pDInfo)) {
    3084                   Win_Error(hwnd,hwnd,pszSrcFile,__LINE__,
    3085                             GetPString(IDS_DROPERRORTEXT));
    3086                 break;
    3087               }
    3088               numitems = DrgQueryDragitemCount(pDInfo);
    3089               usOperation = pDInfo->usOperation;
    3090               DrgDeleteDraginfoStrHandles(pDInfo);
    3091               DrgFreeDraginfo(pDInfo);
    3092               saymsg(MB_ENTER | MB_ICONASTERISK,
    3093                      hwnd,
    3094                      GetPString(IDS_DROPHELPHDRTEXT),
    3095                      GetPString(IDS_DROPHELPTEXT),
    3096                      numitems,
    3097                      &"s"[numitems == 1L],
    3098                      (pci) ? NullStr : GetPString(IDS_NOTEXT),
    3099                      (pci) ? NullStr : " ",
    3100                      (pci) ? pci->szFileName : NullStr,
    3101                      (pci) ? " " : NullStr,
    3102                      GetPString((usOperation == DO_COPY) ?
    3103                                 IDS_COPYTEXT :
    3104                                 (usOperation == DO_LINK) ?
    3105                                 IDS_LINKTEXT : IDS_MOVETEXT));
    3106             }
    3107             return 0;
    3108 
    3109           case CN_DRAGLEAVE:
     2630      case CN_CONTEXTMENU:
     2631        {
     2632          PCNRITEM pci = (PCNRITEM) mp2;
     2633
     2634          if (pci) {
     2635            WinSendMsg(hwnd,
     2636                       CM_SETRECORDEMPHASIS,
     2637                       MPFROMP(pci), MPFROM2SHORT(TRUE, CRA_CURSORED));
     2638            MarkAll(hwnd, FALSE, FALSE, TRUE);
     2639            if (pci->attrFile & FILE_DIRECTORY)
     2640              dcd->hwndLastMenu = CheckMenu(&DirMenu, DIR_POPUP);
     2641            else
     2642              dcd->hwndLastMenu = CheckMenu(&FileMenu, FILE_POPUP);
     2643          }
     2644          else {
     2645            dcd->hwndLastMenu = CheckMenu(&DirCnrMenu, DIRCNR_POPUP);
     2646            if (dcd->hwndLastMenu && !dcd->cnremphasized) {
     2647              WinSendMsg(hwnd,
     2648                         CM_SETRECORDEMPHASIS,
     2649                         MPVOID, MPFROM2SHORT(TRUE, CRA_SOURCE));
     2650              dcd->cnremphasized = TRUE;
     2651            }
     2652          }
     2653          if (dcd->hwndLastMenu) {
     2654            if (dcd->hwndLastMenu == DirCnrMenu) {
     2655              if (dcd->flWindowAttr & CV_MINI)
     2656                WinCheckMenuItem(dcd->hwndLastMenu, IDM_MINIICONS, TRUE);
     2657            }
     2658            if (dcd->hwndLastMenu == DirMenu)
     2659              WinEnableMenuItem(DirMenu, IDM_TREE, TRUE);
     2660            if (!PopupMenu(hwnd, hwnd, dcd->hwndLastMenu)) {
     2661              if (dcd->cnremphasized) {
     2662                WinSendMsg(hwnd,
     2663                           CM_SETRECORDEMPHASIS,
     2664                           MPVOID, MPFROM2SHORT(FALSE, CRA_SOURCE));
     2665                dcd->cnremphasized = TRUE;
     2666              }
     2667              MarkAll(hwnd, TRUE, FALSE, TRUE);
     2668            }
     2669          }
     2670        }
     2671        break;
     2672
     2673      case CN_DROPHELP:
     2674        if (mp2) {
     2675
     2676          PDRAGINFO pDInfo;
     2677          PCNRITEM pci;
     2678          ULONG numitems;
     2679          USHORT usOperation;
     2680
     2681          pci = (PCNRITEM) ((PCNRDRAGINFO) mp2)->pRecord;
     2682          pDInfo = (PDRAGINFO) ((PCNRDRAGINFO) mp2)->pDragInfo;
     2683          if (!DrgAccessDraginfo(pDInfo)) {
     2684            Win_Error(hwnd, hwnd, pszSrcFile, __LINE__,
     2685                      GetPString(IDS_DROPERRORTEXT));
     2686            break;
     2687          }
     2688          numitems = DrgQueryDragitemCount(pDInfo);
     2689          usOperation = pDInfo->usOperation;
     2690          DrgDeleteDraginfoStrHandles(pDInfo);
     2691          DrgFreeDraginfo(pDInfo);
     2692          saymsg(MB_ENTER | MB_ICONASTERISK,
     2693                 hwnd,
     2694                 GetPString(IDS_DROPHELPHDRTEXT),
     2695                 GetPString(IDS_DROPHELPTEXT),
     2696                 numitems,
     2697                 &"s"[numitems == 1L],
     2698                 (pci) ? NullStr : GetPString(IDS_NOTEXT),
     2699                 (pci) ? NullStr : " ",
     2700                 (pci) ? pci->szFileName : NullStr,
     2701                 (pci) ? " " : NullStr,
     2702                 GetPString((usOperation == DO_COPY) ?
     2703                            IDS_COPYTEXT :
     2704                            (usOperation == DO_LINK) ?
     2705                            IDS_LINKTEXT : IDS_MOVETEXT));
     2706        }
     2707        return 0;
     2708
     2709      case CN_DRAGLEAVE:
    31102710#ifdef NEVER
    3111             if (mp2) {
    3112 
    3113               PDRAGINFO pDInfo;
    3114 
    3115               pDInfo = ((PCNRDRAGINFO)mp2)->pDragInfo;
    3116               DrgAccessDraginfo(pDInfo);             /* Access DRAGINFO       */
    3117               DrgFreeDraginfo(pDInfo);               /* Free DRAGINFO         */
    3118             }
     2711        if (mp2) {
     2712
     2713          PDRAGINFO pDInfo;
     2714
     2715          pDInfo = ((PCNRDRAGINFO) mp2)->pDragInfo;
     2716          DrgAccessDraginfo(pDInfo);    /* Access DRAGINFO       */
     2717          DrgFreeDraginfo(pDInfo);      /* Free DRAGINFO         */
     2718        }
    31192719#endif
    3120             return 0;
    3121 
    3122           case CN_DRAGAFTER:
    3123           case CN_DRAGOVER:
    3124             if (mp2) {
    3125 
    3126               PDRAGITEM pDItem;                      /* Pointer to DRAGITEM   */
    3127               PDRAGINFO pDInfo;                      /* Pointer to DRAGINFO   */
    3128               PCNRITEM  pci;
    3129               USHORT    uso;
    3130 
    3131               pci = (PCNRITEM)((PCNRDRAGINFO)mp2)->pRecord;
    3132               pDInfo = ((PCNRDRAGINFO)mp2)->pDragInfo;
    3133               DrgAccessDraginfo(pDInfo);             /* Access DRAGINFO */
    3134               if (*dcd->directory &&
    3135                   (driveflags[toupper(*dcd->directory) - 'A'] &
    3136                      DRIVE_NOTWRITEABLE))
    3137               {
    3138                 DrgFreeDraginfo(pDInfo);
    3139                 return MRFROM2SHORT(DOR_DROP,  /* Return okay to link */
    3140                                     DO_LINK);  /* (compare) only      */
    3141               }
    3142               if (pci) {
    3143                 if (pci->rc.flRecordAttr & CRA_SOURCE) {
    3144                   DrgFreeDraginfo(pDInfo);
    3145                   return(MRFROM2SHORT(DOR_NODROP,0));
    3146                 }
    3147                 uso = pDInfo->usOperation;
    3148                 if (uso == DO_DEFAULT)
    3149                   uso = (fCopyDefault) ? DO_COPY : DO_MOVE;
    3150                 if (!(pci->attrFile & FILE_DIRECTORY)) {
    3151                   if (uso != DO_LINK && uso != DO_COPY && uso != DO_MOVE) {
    3152                     DrgFreeDraginfo(pDInfo);
    3153                     return MRFROM2SHORT(DOR_NODROP,0);
    3154                   }
    3155                   if (uso != DO_LINK &&
    3156                       !(driveflags[toupper(*pci->szFileName) - 'A'] &
    3157                         DRIVE_NOTWRITEABLE)) {
    3158 
    3159                     ARC_TYPE *info = NULL;
    3160 
    3161                     if (!fQuickArcFind &&
    3162                         !(driveflags[toupper(*pci->szFileName) - 'A'] &
    3163                           DRIVE_SLOW))
    3164                       info = find_type(pci->szFileName,NULL);
    3165                     else
    3166                       info = quick_find_type(pci->szFileName,NULL);
    3167                     if (!info || ((uso == DO_MOVE && !info->move) ||
    3168                        (uso == DO_COPY && !info->create)))  {
    3169                       DrgFreeDraginfo(pDInfo);
    3170                       return MRFROM2SHORT(DOR_NODROP,0);
    3171                     }
    3172                   }
    3173                 }
    3174               }
    3175 
    3176               /* Access DRAGITEM index to DRAGITEM
    3177                * Check valid rendering mechanisms and data
    3178                */
    3179               pDItem = DrgQueryDragitemPtr(pDInfo,0);
    3180               if (DrgVerifyRMF(pDItem, DRM_OS2FILE, NULL) ||
    3181                   ((!pci || (pci->attrFile & FILE_DIRECTORY)) &&
    3182                    DrgVerifyRMF(pDItem, DRM_FM2ARCMEMBER, DRF_FM2ARCHIVE)))
    3183               {
    3184                 /* Free DRAGINFO */
    3185                 DrgFreeDraginfo(pDInfo);
    3186                 if (driveflags[toupper(*dcd->directory) - 'A'] &
    3187                    DRIVE_NOTWRITEABLE)
    3188                   return MRFROM2SHORT(DOR_DROP,DO_LINK);
    3189                 if (toupper(*dcd->directory) < 'C')
    3190                   return MRFROM2SHORT(DOR_DROP,DO_COPY);
    3191                 return MRFROM2SHORT(DOR_DROP,         /* Return okay to drop  */
    3192                                     ((fCopyDefault) ?
    3193                                     DO_COPY :
    3194                                     DO_MOVE));
    3195               }
    3196               DrgFreeDraginfo(pDInfo);               /* Free DRAGINFO         */
    3197             }
    3198             return MRFROM2SHORT(DOR_NODROP,0); /* Drop not valid        */
    3199 
    3200           case CN_INITDRAG:
    3201             {
    3202               BOOL         wasemphasized = FALSE;
    3203               PCNRDRAGINIT pcd = (PCNRDRAGINIT)mp2;
    3204               PCNRITEM     pci;
    3205 
    3206               if (pcd) {
    3207                 pci = (PCNRITEM)pcd->pRecord;
    3208                 if (pci) {
    3209                   if ((INT)pci == -1)
    3210                     pci = NULL;
    3211                   else if (pci->rc.flRecordAttr & CRA_SELECTED)
    3212                     wasemphasized = TRUE;
    3213                 }
    3214                 else if (!*dcd->directory) {
    3215                   Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
    3216                   break;
    3217                 }
    3218                 else if (IsRoot(dcd->directory)) {
    3219                   saymsg(MB_ENTER,
    3220                          hwnd,
    3221                          GetPString(IDS_ERRORTEXT),
    3222                          "Can not drag root directory");        // fixme to be GetPString
    3223                   break;
    3224                 }
    3225                 if (hwndStatus2) {
    3226                   if (pci)
    3227                     WinSetWindowText(hwndStatus2,
    3228                                      GetPString(IDS_DRAGFILEOBJTEXT));
    3229                   else
    3230                     WinSetWindowText(hwndStatus2,
    3231                                      GetPString(IDS_DRAGDIRTEXT));
    3232                 }
    3233                 if (DoFileDrag(hwnd,
    3234                                dcd->hwndObject,
    3235                                mp2,
    3236                                NULL,
    3237                                (pci) ? NULL : dcd->directory,
    3238                                (pci) ? TRUE : FALSE))
    3239                 {
    3240                   if (pci && fUnHilite && wasemphasized)
    3241                     UnHilite(hwnd,
    3242                              TRUE,
    3243                              &dcd->lastselection);
    3244                 }
    3245                 if (hwndStatus2) {
    3246                   WinSetFocus(HWND_DESKTOP,hwnd);
    3247                   PostMsg(hwnd,
    3248                           UM_RESCAN,
    3249                           MPVOID,
    3250                           MPVOID);
    3251                 }
    3252               }
    3253             }
    3254             return 0;
    3255 
    3256           case CN_DROP:
    3257             if (mp2) {
    3258 
    3259               LISTINFO *li;
    3260               ULONG     action = UM_ACTION;
    3261 
    3262               li = DoFileDrop(hwnd,dcd->directory,TRUE,mp1,mp2);
    3263               if (li) {
    3264                 if (li->list && li->list[0] && IsRoot(li->list[0]))
    3265                   li->type = DO_LINK;
    3266                 else if (fDragndropDlg && (!*li->arcname || !li->info)) {
    3267 
    3268                   CHECKLIST    cl;
    3269 
    3270                   memset(&cl,0,sizeof(cl));
    3271                   cl.size = sizeof(cl);
    3272                   cl.flags = li->type;
    3273                   cl.list = li->list;
    3274                   cl.cmd = li->type;
    3275                   cl.prompt = li->targetpath;
    3276                   li->type = WinDlgBox(HWND_DESKTOP,dcd->hwndParent,
    3277                                        DropListProc,FM3ModHandle,
    3278                                        DND_FRAME,MPFROMP(&cl));
    3279                   if (!li->type) {
    3280                     FreeListInfo(li);
    3281                     return 0;
    3282                   }
    3283                   li->list = cl.list;
    3284                   if (!li->list || !li->list[0]) {
    3285                     FreeListInfo(li);
    3286                     return 0;
    3287                   }
    3288                 }
    3289                 switch(li->type) {
    3290                   case DND_LAUNCH:
    3291                     strcat(li->targetpath," %a");
    3292                     ExecOnList(dcd->hwndParent,li->targetpath,
    3293                                PROMPT | WINDOWED,NULL,li->list,NULL);
    3294                     FreeList(li->list);
    3295                     li->list = NULL;
    3296                     break;
    3297                   case DO_LINK:
    3298                     if (fLinkSetsIcon) {
    3299                       li->type = IDM_SETICON;
    3300                       action = UM_MASSACTION;
    3301                     }
    3302                     else
    3303                       li->type = IDM_COMPARE;
    3304                     break;
    3305                   case DND_EXTRACT:
    3306                     if (*li->targetpath && !IsFile(li->targetpath))
    3307                       li->type = IDM_EXTRACT;
    3308                     break;
    3309                   case DND_MOVE:
    3310                     li->type = IDM_MOVE;
    3311                     if (*li->targetpath && IsFile(li->targetpath) == 1) {
    3312                       action = UM_MASSACTION;
    3313                       li->type = IDM_ARCHIVEM;
    3314                     }
    3315                     break;
    3316                   case DND_WILDMOVE:
    3317                     li->type = IDM_WILDMOVE;
    3318                     if (*li->targetpath && IsFile(li->targetpath) == 1) {
    3319                       action = UM_MASSACTION;
    3320                       li->type = IDM_ARCHIVEM;
    3321                     }
    3322                     break;
    3323                   case DND_OBJECT:
    3324                     li->type = IDM_OBJECT;
    3325                     action = UM_MASSACTION;
    3326                     break;
    3327                   case DND_SHADOW:
    3328                     li->type = IDM_SHADOW;
    3329                     action = UM_MASSACTION;
    3330                     break;
    3331                   case DND_COMPARE:
    3332                     li->type = IDM_COMPARE;
    3333                     break;
    3334                   case DND_SETICON:
    3335                     action = UM_MASSACTION;
    3336                     li->type = IDM_SETICON;
    3337                     break;
    3338                   case DND_COPY:
    3339                     li->type = IDM_COPY;
    3340                     if (*li->targetpath && IsFile(li->targetpath) == 1) {
    3341                       action = UM_MASSACTION;
    3342                       li->type = IDM_ARCHIVE;
    3343                     }
    3344                     break;
    3345                   case DND_WILDCOPY:
    3346                     li->type = IDM_WILDCOPY;
    3347                     if (*li->targetpath && IsFile(li->targetpath) == 1) {
    3348                       action = UM_MASSACTION;
    3349                       li->type = IDM_ARCHIVE;
    3350                     }
    3351                     break;
    3352                   default:
    3353                     if (*li->arcname && li->info) {
    3354                       action = UM_MASSACTION;
    3355                       li->type = (li->type == DO_MOVE) ? IDM_FAKEEXTRACTM : IDM_FAKEEXTRACT;
    3356                     }
    3357                     else if (*li->targetpath && IsFile(li->targetpath) == 1) {
    3358                       action = UM_MASSACTION;
    3359                       li->type = (li->type == DO_MOVE) ? IDM_ARCHIVEM : IDM_ARCHIVE;
    3360                     }
    3361                     else
    3362                       li->type = (li->type == DO_MOVE) ? IDM_MOVE : IDM_COPY;
    3363                     break;
    3364                 }
    3365                 if (!li->list || !li->list[0])
    3366                   FreeListInfo(li);
    3367                 else if (!PostMsg(dcd->hwndObject,action,MPFROMP(li),MPVOID))
    3368                   FreeListInfo(li);
    3369                 else {
    3370 
    3371                   USHORT usop = 0;
    3372 
    3373                   switch(li->type) {
    3374                     case IDM_COPY:
    3375                     case IDM_WILDCOPY:
    3376                       usop = DO_COPY;
    3377                       break;
    3378                     case IDM_MOVE:
    3379                     case IDM_WILDMOVE:
    3380                     case IDM_ARCHIVEM:
    3381                       usop = DO_MOVE;
    3382                       break;
    3383                   }
    3384                   if (usop)
    3385                     return MRFROM2SHORT(DOR_DROP,usop);
    3386                 }
    3387               }
    3388             }
    3389             return 0;
    3390 
    3391           case CN_ENDEDIT:
    3392           case CN_BEGINEDIT:
    3393             {
    3394               PFIELDINFO pfi = ((PCNREDITDATA)mp2)->pFieldInfo;
    3395               PCNRITEM   pci = (PCNRITEM)((PCNREDITDATA)mp2)->pRecord;
    3396 
    3397               if (pfi || pci) {
    3398 
    3399                 MRESULT mre;
    3400 
    3401                 mre = CnrDirectEdit(hwnd,msg,mp1,mp2);
    3402                 if (mre != (MRESULT)-1)
    3403                   return mre;
    3404               }
    3405               else if (!pfi && !pci)
    3406                 PostMsg(hwnd,
    3407                         UM_FIXCNRMLE,
    3408                         MPFROMLONG(CCHMAXPATH),
    3409                         MPVOID);
    3410             }
    3411             return 0;
    3412 
    3413           case CN_REALLOCPSZ:
    3414             {
    3415               PFIELDINFO  pfi = ((PCNREDITDATA)mp2)->pFieldInfo;
    3416               PCNRITEM    pci = (PCNRITEM)((PCNREDITDATA)mp2)->pRecord;
    3417               HWND        hwndMLE;
    3418               static CHAR szData[CCHMAXPATH];
    3419               CHAR        testname[CCHMAXPATH],*p;
    3420 
    3421               if (!pci && !pfi) {
    3422                 hwndMLE = WinWindowFromID(hwnd,CID_MLE);
    3423                 WinQueryWindowText(hwndMLE,
    3424                                    sizeof(szData),
    3425                                    szData);
    3426                 chop_at_crnl(szData);
    3427                 bstrip(szData);
    3428                 if (*szData) {
    3429                   if (!DosQueryPathInfo(szData,
    3430                                         FIL_QUERYFULLNAME,
    3431                                         testname,
    3432                                         sizeof(testname)))
    3433                   {
    3434                     if (!SetDir(dcd->hwndParent,
    3435                                hwnd,
    3436                                testname,
    3437                                1))
    3438                     {
    3439                       PostMsg(hwnd,
    3440                               UM_SETDIR,
    3441                               MPFROMP(testname),
    3442                               MPVOID);
     2720        return 0;
     2721
     2722      case CN_DRAGAFTER:
     2723      case CN_DRAGOVER:
     2724        if (mp2) {
     2725
     2726          PDRAGITEM pDItem;     /* Pointer to DRAGITEM   */
     2727          PDRAGINFO pDInfo;     /* Pointer to DRAGINFO   */
     2728          PCNRITEM pci;
     2729          USHORT uso;
     2730
     2731          pci = (PCNRITEM) ((PCNRDRAGINFO) mp2)->pRecord;
     2732          pDInfo = ((PCNRDRAGINFO) mp2)->pDragInfo;
     2733          DrgAccessDraginfo(pDInfo);    /* Access DRAGINFO */
     2734          if (*dcd->directory &&
     2735              (driveflags[toupper(*dcd->directory) - 'A'] &
     2736               DRIVE_NOTWRITEABLE)) {
     2737            DrgFreeDraginfo(pDInfo);
     2738            return MRFROM2SHORT(DOR_DROP,       /* Return okay to link */
     2739                                DO_LINK);       /* (compare) only      */
     2740          }
     2741          if (pci) {
     2742            if (pci->rc.flRecordAttr & CRA_SOURCE) {
     2743              DrgFreeDraginfo(pDInfo);
     2744              return (MRFROM2SHORT(DOR_NODROP, 0));
     2745            }
     2746            uso = pDInfo->usOperation;
     2747            if (uso == DO_DEFAULT)
     2748              uso = (fCopyDefault) ? DO_COPY : DO_MOVE;
     2749            if (!(pci->attrFile & FILE_DIRECTORY)) {
     2750              if (uso != DO_LINK && uso != DO_COPY && uso != DO_MOVE) {
     2751                DrgFreeDraginfo(pDInfo);
     2752                return MRFROM2SHORT(DOR_NODROP, 0);
     2753              }
     2754              if (uso != DO_LINK &&
     2755                  !(driveflags[toupper(*pci->szFileName) - 'A'] &
     2756                    DRIVE_NOTWRITEABLE)) {
     2757
     2758                ARC_TYPE *info = NULL;
     2759
     2760                if (!fQuickArcFind &&
     2761                    !(driveflags[toupper(*pci->szFileName) - 'A'] &
     2762                      DRIVE_SLOW))
     2763                  info = find_type(pci->szFileName, NULL);
     2764                else
     2765                  info = quick_find_type(pci->szFileName, NULL);
     2766                if (!info || ((uso == DO_MOVE && !info->move) ||
     2767                              (uso == DO_COPY && !info->create))) {
     2768                  DrgFreeDraginfo(pDInfo);
     2769                  return MRFROM2SHORT(DOR_NODROP, 0);
     2770                }
     2771              }
     2772            }
     2773          }
     2774
     2775          /* Access DRAGITEM index to DRAGITEM
     2776           * Check valid rendering mechanisms and data
     2777           */
     2778          pDItem = DrgQueryDragitemPtr(pDInfo, 0);
     2779          if (DrgVerifyRMF(pDItem, DRM_OS2FILE, NULL) ||
     2780              ((!pci || (pci->attrFile & FILE_DIRECTORY)) &&
     2781               DrgVerifyRMF(pDItem, DRM_FM2ARCMEMBER, DRF_FM2ARCHIVE))) {
     2782            /* Free DRAGINFO */
     2783            DrgFreeDraginfo(pDInfo);
     2784            if (driveflags[toupper(*dcd->directory) - 'A'] &
     2785                DRIVE_NOTWRITEABLE)
     2786              return MRFROM2SHORT(DOR_DROP, DO_LINK);
     2787            if (toupper(*dcd->directory) < 'C')
     2788              return MRFROM2SHORT(DOR_DROP, DO_COPY);
     2789            return MRFROM2SHORT(DOR_DROP,       /* Return okay to drop  */
     2790                                ((fCopyDefault) ? DO_COPY : DO_MOVE));
     2791          }
     2792          DrgFreeDraginfo(pDInfo);      /* Free DRAGINFO         */
     2793        }
     2794        return MRFROM2SHORT(DOR_NODROP, 0);     /* Drop not valid        */
     2795
     2796      case CN_INITDRAG:
     2797        {
     2798          BOOL wasemphasized = FALSE;
     2799          PCNRDRAGINIT pcd = (PCNRDRAGINIT) mp2;
     2800          PCNRITEM pci;
     2801
     2802          if (pcd) {
     2803            pci = (PCNRITEM) pcd->pRecord;
     2804            if (pci) {
     2805              if ((INT) pci == -1)
     2806                pci = NULL;
     2807              else if (pci->rc.flRecordAttr & CRA_SELECTED)
     2808                wasemphasized = TRUE;
     2809            }
     2810            else if (!*dcd->directory) {
     2811              Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
     2812              break;
     2813            }
     2814            else if (IsRoot(dcd->directory)) {
     2815              saymsg(MB_ENTER, hwnd, GetPString(IDS_ERRORTEXT), "Can not drag root directory"); // fixme to be GetPString
     2816              break;
     2817            }
     2818            if (hwndStatus2) {
     2819              if (pci)
     2820                WinSetWindowText(hwndStatus2,
     2821                                 GetPString(IDS_DRAGFILEOBJTEXT));
     2822              else
     2823                WinSetWindowText(hwndStatus2, GetPString(IDS_DRAGDIRTEXT));
     2824            }
     2825            if (DoFileDrag(hwnd,
     2826                           dcd->hwndObject,
     2827                           mp2,
     2828                           NULL,
     2829                           (pci) ? NULL : dcd->directory,
     2830                           (pci) ? TRUE : FALSE)) {
     2831              if (pci && fUnHilite && wasemphasized)
     2832                UnHilite(hwnd, TRUE, &dcd->lastselection);
     2833            }
     2834            if (hwndStatus2) {
     2835              WinSetFocus(HWND_DESKTOP, hwnd);
     2836              PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
     2837            }
     2838          }
     2839        }
     2840        return 0;
     2841
     2842      case CN_DROP:
     2843        if (mp2) {
     2844
     2845          LISTINFO *li;
     2846          ULONG action = UM_ACTION;
     2847
     2848          li = DoFileDrop(hwnd, dcd->directory, TRUE, mp1, mp2);
     2849          if (li) {
     2850            if (li->list && li->list[0] && IsRoot(li->list[0]))
     2851              li->type = DO_LINK;
     2852            else if (fDragndropDlg && (!*li->arcname || !li->info)) {
     2853
     2854              CHECKLIST cl;
     2855
     2856              memset(&cl, 0, sizeof(cl));
     2857              cl.size = sizeof(cl);
     2858              cl.flags = li->type;
     2859              cl.list = li->list;
     2860              cl.cmd = li->type;
     2861              cl.prompt = li->targetpath;
     2862              li->type = WinDlgBox(HWND_DESKTOP, dcd->hwndParent,
     2863                                   DropListProc, FM3ModHandle,
     2864                                   DND_FRAME, MPFROMP(&cl));
     2865              if (!li->type) {
     2866                FreeListInfo(li);
     2867                return 0;
     2868              }
     2869              li->list = cl.list;
     2870              if (!li->list || !li->list[0]) {
     2871                FreeListInfo(li);
     2872                return 0;
     2873              }
     2874            }
     2875            switch (li->type) {
     2876            case DND_LAUNCH:
     2877              strcat(li->targetpath, " %a");
     2878              ExecOnList(dcd->hwndParent, li->targetpath,
     2879                         PROMPT | WINDOWED, NULL, li->list, NULL);
     2880              FreeList(li->list);
     2881              li->list = NULL;
     2882              break;
     2883            case DO_LINK:
     2884              if (fLinkSetsIcon) {
     2885                li->type = IDM_SETICON;
     2886                action = UM_MASSACTION;
     2887              }
     2888              else
     2889                li->type = IDM_COMPARE;
     2890              break;
     2891            case DND_EXTRACT:
     2892              if (*li->targetpath && !IsFile(li->targetpath))
     2893                li->type = IDM_EXTRACT;
     2894              break;
     2895            case DND_MOVE:
     2896              li->type = IDM_MOVE;
     2897              if (*li->targetpath && IsFile(li->targetpath) == 1) {
     2898                action = UM_MASSACTION;
     2899                li->type = IDM_ARCHIVEM;
     2900              }
     2901              break;
     2902            case DND_WILDMOVE:
     2903              li->type = IDM_WILDMOVE;
     2904              if (*li->targetpath && IsFile(li->targetpath) == 1) {
     2905                action = UM_MASSACTION;
     2906                li->type = IDM_ARCHIVEM;
     2907              }
     2908              break;
     2909            case DND_OBJECT:
     2910              li->type = IDM_OBJECT;
     2911              action = UM_MASSACTION;
     2912              break;
     2913            case DND_SHADOW:
     2914              li->type = IDM_SHADOW;
     2915              action = UM_MASSACTION;
     2916              break;
     2917            case DND_COMPARE:
     2918              li->type = IDM_COMPARE;
     2919              break;
     2920            case DND_SETICON:
     2921              action = UM_MASSACTION;
     2922              li->type = IDM_SETICON;
     2923              break;
     2924            case DND_COPY:
     2925              li->type = IDM_COPY;
     2926              if (*li->targetpath && IsFile(li->targetpath) == 1) {
     2927                action = UM_MASSACTION;
     2928                li->type = IDM_ARCHIVE;
     2929              }
     2930              break;
     2931            case DND_WILDCOPY:
     2932              li->type = IDM_WILDCOPY;
     2933              if (*li->targetpath && IsFile(li->targetpath) == 1) {
     2934                action = UM_MASSACTION;
     2935                li->type = IDM_ARCHIVE;
     2936              }
     2937              break;
     2938            default:
     2939              if (*li->arcname && li->info) {
     2940                action = UM_MASSACTION;
     2941                li->type =
     2942                  (li->type == DO_MOVE) ? IDM_FAKEEXTRACTM : IDM_FAKEEXTRACT;
     2943              }
     2944              else if (*li->targetpath && IsFile(li->targetpath) == 1) {
     2945                action = UM_MASSACTION;
     2946                li->type = (li->type == DO_MOVE) ? IDM_ARCHIVEM : IDM_ARCHIVE;
     2947              }
     2948              else
     2949                li->type = (li->type == DO_MOVE) ? IDM_MOVE : IDM_COPY;
     2950              break;
     2951            }
     2952            if (!li->list || !li->list[0])
     2953              FreeListInfo(li);
     2954            else if (!PostMsg(dcd->hwndObject, action, MPFROMP(li), MPVOID))
     2955              FreeListInfo(li);
     2956            else {
     2957
     2958              USHORT usop = 0;
     2959
     2960              switch (li->type) {
     2961              case IDM_COPY:
     2962              case IDM_WILDCOPY:
     2963                usop = DO_COPY;
     2964                break;
     2965              case IDM_MOVE:
     2966              case IDM_WILDMOVE:
     2967              case IDM_ARCHIVEM:
     2968                usop = DO_MOVE;
     2969                break;
     2970              }
     2971              if (usop)
     2972                return MRFROM2SHORT(DOR_DROP, usop);
     2973            }
     2974          }
     2975        }
     2976        return 0;
     2977
     2978      case CN_ENDEDIT:
     2979      case CN_BEGINEDIT:
     2980        {
     2981          PFIELDINFO pfi = ((PCNREDITDATA) mp2)->pFieldInfo;
     2982          PCNRITEM pci = (PCNRITEM) ((PCNREDITDATA) mp2)->pRecord;
     2983
     2984          if (pfi || pci) {
     2985
     2986            MRESULT mre;
     2987
     2988            mre = CnrDirectEdit(hwnd, msg, mp1, mp2);
     2989            if (mre != (MRESULT) - 1)
     2990              return mre;
     2991          }
     2992          else if (!pfi && !pci)
     2993            PostMsg(hwnd, UM_FIXCNRMLE, MPFROMLONG(CCHMAXPATH), MPVOID);
     2994        }
     2995        return 0;
     2996
     2997      case CN_REALLOCPSZ:
     2998        {
     2999          PFIELDINFO pfi = ((PCNREDITDATA) mp2)->pFieldInfo;
     3000          PCNRITEM pci = (PCNRITEM) ((PCNREDITDATA) mp2)->pRecord;
     3001          HWND hwndMLE;
     3002          static CHAR szData[CCHMAXPATH];
     3003          CHAR testname[CCHMAXPATH], *p;
     3004
     3005          if (!pci && !pfi) {
     3006            hwndMLE = WinWindowFromID(hwnd, CID_MLE);
     3007            WinQueryWindowText(hwndMLE, sizeof(szData), szData);
     3008            chop_at_crnl(szData);
     3009            bstrip(szData);
     3010            if (*szData) {
     3011              if (!DosQueryPathInfo(szData,
     3012                                    FIL_QUERYFULLNAME,
     3013                                    testname, sizeof(testname))) {
     3014                if (!SetDir(dcd->hwndParent, hwnd, testname, 1)) {
     3015                  PostMsg(hwnd, UM_SETDIR, MPFROMP(testname), MPVOID);
     3016                }
     3017              }
     3018            }
     3019          }
     3020          else {
     3021
     3022            MRESULT mre;
     3023
     3024            mre = CnrDirectEdit(hwnd, msg, mp1, mp2);
     3025            if (mre != (MRESULT) - 1)
     3026              return mre;
     3027          }
     3028        }
     3029        return 0;
     3030
     3031      case CN_EMPHASIS:
     3032        if (!mp2)
     3033          Runtime_Error(pszSrcFile, __LINE__, "mp2 NULL");
     3034        else {
     3035          PNOTIFYRECORDEMPHASIS pre = mp2;
     3036          PCNRITEM pci;
     3037          CHAR s[CCHMAXPATHCOMP + 91], tb[81], tf[81];
     3038
     3039          pci = (PCNRITEM) ((pre) ? pre->pRecord : NULL);
     3040          if (!pci) {
     3041            if (hwndStatus2)
     3042              WinSetWindowText(hwndStatus2, NullStr);
     3043            if (fMoreButtons) {
     3044              WinSetWindowText(hwndName, NullStr);
     3045              WinSetWindowText(hwndDate, NullStr);
     3046              WinSetWindowText(hwndAttr, NullStr);
     3047            }
     3048            if (hwndMain)
     3049              WinSendMsg(hwndMain, UM_LOADFILE, MPVOID, MPVOID);
     3050            break;
     3051          }
     3052          if (pre->fEmphasisMask & CRA_SELECTED) {
     3053            if (pci->rc.flRecordAttr & CRA_SELECTED) {
     3054              dcd->selectedbytes += (pci->cbFile + pci->easize);
     3055              dcd->selectedfiles++;
     3056            }
     3057            else if (dcd->selectedfiles) {
     3058              dcd->selectedbytes -= (pci->cbFile + pci->easize);
     3059              dcd->selectedfiles--;
     3060            }
     3061            if (!dcd->suspendview) {
     3062              commafmt(tf, sizeof(tf), dcd->selectedfiles);
     3063              CommaFmtULL(tb, sizeof(tb), dcd->selectedbytes, 'K');
     3064              sprintf(s, "%s / %s", tf, tb);
     3065              WinSetDlgItemText(dcd->hwndClient, DIR_SELECTED, s);
     3066            }
     3067          }
     3068          if (!dcd->suspendview && hwndMain &&
     3069              (pre->fEmphasisMask & CRA_CURSORED) &&
     3070              (pci->rc.flRecordAttr & CRA_CURSORED) &&
     3071              WinQueryActiveWindow(dcd->hwndParent) == dcd->hwndFrame) {
     3072            if (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_SLOW)
     3073              WinSendMsg(hwndMain, UM_LOADFILE, MPVOID, MPVOID);
     3074            else
     3075              WinSendMsg(hwndMain,
     3076                         UM_LOADFILE, MPFROMP(pci->szFileName), MPVOID);
     3077          }
     3078          if (!dcd->suspendview &&
     3079              WinQueryActiveWindow(dcd->hwndParent) == dcd->hwndFrame) {
     3080            if (pre->fEmphasisMask & CRA_CURSORED) {
     3081              if (pci->rc.flRecordAttr & CRA_CURSORED) {
     3082                if (fSplitStatus && hwndStatus2) {
     3083                  CommaFmtULL(tb, sizeof(tb), pci->cbFile + pci->easize, ' ');
     3084                  if (!fMoreButtons) {
     3085                    sprintf(s, " %s  %04u/%02u/%02u %02u:%02u:%02u  [%s]  %s",
     3086                            tb, pci->date.year,
     3087                            pci->date.month, pci->date.day, pci->time.hours,
     3088                            pci->time.minutes, pci->time.seconds,
     3089                            pci->pszDispAttr, pci->pszFileName);
     3090                  }
     3091                  else {
     3092                    *tf = 0;
     3093                    if (pci->cbFile + pci->easize > 1024) {
     3094                      CommaFmtULL(tf, sizeof(tf),
     3095                                  pci->cbFile + pci->easize, 'K');
    34433096                    }
    3444                   }
    3445                 }
    3446               }
    3447               else {
    3448 
    3449                 MRESULT mre;
    3450 
    3451                 mre = CnrDirectEdit(hwnd,msg,mp1,mp2);
    3452                 if (mre != (MRESULT)-1)
    3453                   return mre;
    3454               }
    3455             }
    3456             return 0;
    3457 
    3458           case CN_EMPHASIS:
    3459             if (!mp2)
    3460               Runtime_Error(pszSrcFile, __LINE__, "mp2 NULL");
     3097                    sprintf(s, GetPString(IDS_STATUSSIZETEXT),
     3098                            tb,
     3099                            *tf ? " (" : NullStr, tf, *tf ? ")" : NullStr);
     3100                  }
     3101                  WinSetWindowText(hwndStatus2, s);
     3102                }
     3103                if (fMoreButtons) {
     3104                  WinSetWindowText(hwndName, pci->pszFileName);
     3105                  sprintf(s, "%04u/%02u/%02u %02u:%02u:%02u",
     3106                          pci->date.year, pci->date.month,
     3107                          pci->date.day, pci->time.hours, pci->time.minutes,
     3108                          pci->time.seconds);
     3109                  WinSetWindowText(hwndDate, s);
     3110                  WinSetWindowText(hwndAttr, pci->pszDispAttr);
     3111                }
     3112              }
     3113            }
     3114          }
     3115        }
     3116        break;
     3117
     3118      case CN_ENTER:
     3119        if (mp2) {
     3120
     3121          PCNRITEM pci = (PCNRITEM) ((PNOTIFYRECORDENTER) mp2)->pRecord;
     3122          FILEFINDBUF3 ffb;
     3123          HDIR hDir = HDIR_CREATE;
     3124          ULONG nm = 1L;
     3125          APIRET status = 0;
     3126
     3127          SetShiftState();
     3128          if (pci) {
     3129            if (pci->rc.flRecordAttr & CRA_INUSE)
     3130              break;
     3131            DosError(FERR_DISABLEHARDERR);
     3132            status = DosFindFirst(pci->szFileName,
     3133                                  &hDir,
     3134                                  FILE_NORMAL | FILE_DIRECTORY |
     3135                                  FILE_ARCHIVED | FILE_READONLY |
     3136                                  FILE_HIDDEN | FILE_SYSTEM,
     3137                                  &ffb, sizeof(ffb), &nm, FIL_STANDARD);
     3138            priority_bumped();
     3139            if (!status) {
     3140              DosFindClose(hDir);
     3141              if (ffb.attrFile & FILE_DIRECTORY) {
     3142                if ((shiftstate & (KC_CTRL | KC_ALT)) == (KC_CTRL | KC_ALT))
     3143                  PostMsg(hwnd,
     3144                          WM_COMMAND,
     3145                          MPFROM2SHORT(IDM_SHOWALLFILES, 0), MPVOID);
     3146                else if ((shiftstate & (KC_CTRL | KC_SHIFT)) ==
     3147                         (KC_CTRL | KC_SHIFT))
     3148                  OpenObject(pci->szFileName, Settings, dcd->hwndFrame);
     3149                else if (shiftstate & KC_CTRL)
     3150                  OpenObject(pci->szFileName, Default, dcd->hwndFrame);
     3151                else if (shiftstate & KC_SHIFT) {
     3152
     3153                  HWND hwndDir;
     3154
     3155                  hwndDir = OpenDirCnr((HWND) 0,
     3156                                       dcd->hwndParent,
     3157                                       dcd->hwndFrame,
     3158                                       FALSE, pci->szFileName);
     3159                  if (hwndDir) {
     3160                    if (fMinOnOpen)
     3161                      WinSetWindowPos(dcd->hwndFrame,
     3162                                      HWND_BOTTOM,
     3163                                      0, 0, 0, 0, SWP_MINIMIZE | SWP_ZORDER);
     3164                    if (fAutoTile)
     3165                      TileChildren(dcd->hwndParent, TRUE);
     3166                    WinSetWindowPos(hwndDir,
     3167                                    HWND_TOP, 0, 0, 0, 0, SWP_ACTIVATE);
     3168                  }
     3169                }
     3170                else {
     3171                  strcpy(dcd->previous, dcd->directory);
     3172                  strcpy(dcd->directory, pci->szFileName);
     3173                  DosEnterCritSec();
     3174                  dcd->stopflag++;
     3175                  DosExitCritSec();
     3176                  if (!PostMsg(dcd->hwndObject,
     3177                               UM_RESCAN, MPVOID, MPFROMLONG(1L))) {
     3178                    DosEnterCritSec();
     3179                    dcd->stopflag--;
     3180                    DosExitCritSec();
     3181                  }
     3182                  else if (*dcd->directory) {
     3183                    if (hwndMain)
     3184                      WinSendMsg(hwndMain,
     3185                                 UM_SETUSERLISTNAME,
     3186                                 MPFROMP(dcd->directory), MPVOID);
     3187                    else
     3188                      add_udir(FALSE, dcd->directory);
     3189                  }
     3190                }
     3191              }
     3192              else {
     3193
     3194                SWP swp;
     3195
     3196                WinQueryWindowPos(dcd->hwndFrame, &swp);
     3197                WinSendMsg(hwnd,
     3198                           CM_SETRECORDEMPHASIS,
     3199                           MPFROMP(pci), MPFROM2SHORT(TRUE, CRA_INUSE));
     3200                DefaultViewKeys(hwnd,
     3201                                dcd->hwndFrame,
     3202                                dcd->hwndParent, &swp, pci->szFileName);
     3203                WinSendMsg(hwnd,
     3204                           CM_SETRECORDEMPHASIS,
     3205                           MPFROMP(pci),
     3206                           MPFROM2SHORT(FALSE,
     3207                                        CRA_INUSE |
     3208                                        ((fUnHilite) ? CRA_SELECTED : 0)));
     3209              }
     3210            }
    34613211            else {
    3462               PNOTIFYRECORDEMPHASIS pre = mp2;
    3463               PCNRITEM              pci;
    3464               CHAR                  s[CCHMAXPATHCOMP + 91],tb[81],tf[81];
    3465 
    3466               pci = (PCNRITEM)((pre) ? pre->pRecord : NULL);
    3467               if (!pci) {
    3468                 if (hwndStatus2)
    3469                   WinSetWindowText(hwndStatus2,NullStr);
    3470                 if (fMoreButtons) {
    3471                   WinSetWindowText(hwndName,NullStr);
    3472                   WinSetWindowText(hwndDate,NullStr);
    3473                   WinSetWindowText(hwndAttr,NullStr);
    3474                 }
    3475                 if (hwndMain)
    3476                   WinSendMsg(hwndMain,
    3477                              UM_LOADFILE,
    3478                              MPVOID,
    3479                              MPVOID);
    3480                 break;
    3481               }
    3482               if (pre->fEmphasisMask & CRA_SELECTED) {
    3483                 if (pci->rc.flRecordAttr & CRA_SELECTED) {
    3484                   dcd->selectedbytes += (pci->cbFile + pci->easize);
    3485                   dcd->selectedfiles++;
    3486                 }
    3487                 else if (dcd->selectedfiles) {
    3488                   dcd->selectedbytes -= (pci->cbFile + pci->easize);
    3489                   dcd->selectedfiles--;
    3490                 }
    3491                 if (!dcd->suspendview)
    3492                 {
    3493                   commafmt(tf,sizeof(tf),dcd->selectedfiles);
    3494                   CommaFmtULL(tb,sizeof(tb),dcd->selectedbytes,'K');
    3495                   sprintf(s,"%s / %s",tf,tb);
    3496                   WinSetDlgItemText(dcd->hwndClient,DIR_SELECTED,s);
    3497                 }
    3498               }
    3499               if (!dcd->suspendview && hwndMain &&
    3500                   (pre->fEmphasisMask & CRA_CURSORED) &&
    3501                   (pci->rc.flRecordAttr & CRA_CURSORED) &&
    3502                   WinQueryActiveWindow(dcd->hwndParent) == dcd->hwndFrame)
    3503               {
    3504                 if (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_SLOW)
    3505                   WinSendMsg(hwndMain,
    3506                              UM_LOADFILE,
    3507                              MPVOID,
    3508                              MPVOID);
    3509                 else
    3510                   WinSendMsg(hwndMain,
    3511                              UM_LOADFILE,
    3512                              MPFROMP(pci->szFileName),
    3513                              MPVOID);
    3514               }
    3515               if (!dcd->suspendview &&
    3516                   WinQueryActiveWindow(dcd->hwndParent) == dcd->hwndFrame) {
    3517                 if (pre->fEmphasisMask & CRA_CURSORED) {
    3518                   if (pci->rc.flRecordAttr & CRA_CURSORED) {
    3519                     if (fSplitStatus && hwndStatus2)
    3520                     {
    3521                       CommaFmtULL(tb,sizeof(tb),pci->cbFile + pci->easize,' ');
    3522                       if (!fMoreButtons)
    3523                       {
    3524                         sprintf(s," %s  %04u/%02u/%02u %02u:%02u:%02u  [%s]  %s",
    3525                                 tb,pci->date.year,
    3526                                 pci->date.month,pci->date.day,pci->time.hours,
    3527                                 pci->time.minutes,pci->time.seconds,
    3528                                 pci->pszDispAttr,pci->pszFileName);
    3529                       }
    3530                       else {
    3531                         *tf = 0;
    3532                         if (pci->cbFile + pci->easize > 1024)
    3533                         {
    3534                           CommaFmtULL(tf,sizeof(tf),
    3535                                       pci->cbFile + pci->easize,'K');
    3536                         }
    3537                         sprintf(s,GetPString(IDS_STATUSSIZETEXT),
    3538                                 tb,
    3539                                 *tf ? " (" : NullStr,
    3540                                 tf,
    3541                                 *tf ? ")" : NullStr);
    3542                       }
    3543                       WinSetWindowText(hwndStatus2,s);
    3544                     }
    3545                     if (fMoreButtons) {
    3546                       WinSetWindowText(hwndName,pci->pszFileName);
    3547                       sprintf(s,"%04u/%02u/%02u %02u:%02u:%02u",
    3548                               pci->date.year,pci->date.month,
    3549                               pci->date.day,pci->time.hours,pci->time.minutes,
    3550                               pci->time.seconds);
    3551                       WinSetWindowText(hwndDate,s);
    3552                       WinSetWindowText(hwndAttr,pci->pszDispAttr);
    3553                     }
    3554                   }
    3555                 }
    3556               }
    3557             }
    3558             break;
    3559 
    3560           case CN_ENTER:
    3561             if (mp2) {
    3562 
    3563               PCNRITEM     pci = (PCNRITEM)((PNOTIFYRECORDENTER)mp2)->pRecord;
    3564               FILEFINDBUF3 ffb;
    3565               HDIR         hDir = HDIR_CREATE;
    3566               ULONG        nm = 1L;
    3567               APIRET       status = 0;
    3568 
    3569               SetShiftState();
    3570               if (pci) {
    3571                 if (pci->rc.flRecordAttr & CRA_INUSE)
    3572                   break;
    3573                 DosError(FERR_DISABLEHARDERR);
    3574                 status = DosFindFirst(pci->szFileName,
    3575                                       &hDir,
    3576                                       FILE_NORMAL   | FILE_DIRECTORY |
    3577                                       FILE_ARCHIVED | FILE_READONLY  |
    3578                                       FILE_HIDDEN   | FILE_SYSTEM,
    3579                                       &ffb,
    3580                                       sizeof(ffb),
    3581                                       &nm,
    3582                                       FIL_STANDARD);
    3583                 priority_bumped();
    3584                 if (!status) {
    3585                   DosFindClose(hDir);
    3586                   if (ffb.attrFile & FILE_DIRECTORY) {
    3587                     if ((shiftstate & (KC_CTRL | KC_ALT)) ==
    3588                        (KC_CTRL | KC_ALT))
    3589                       PostMsg(hwnd,
    3590                               WM_COMMAND,
    3591                               MPFROM2SHORT(IDM_SHOWALLFILES,0),
    3592                               MPVOID);
    3593                     else if ((shiftstate & (KC_CTRL | KC_SHIFT)) ==
    3594                             (KC_CTRL | KC_SHIFT))
    3595                       OpenObject(pci->szFileName,
    3596                                  Settings,
    3597                                  dcd->hwndFrame);
    3598                     else if (shiftstate & KC_CTRL)
    3599                       OpenObject(pci->szFileName,
    3600                                  Default,
    3601                                  dcd->hwndFrame);
    3602                     else if (shiftstate & KC_SHIFT) {
    3603 
    3604                       HWND hwndDir;
    3605 
    3606                       hwndDir = OpenDirCnr((HWND)0,
    3607                                            dcd->hwndParent,
    3608                                            dcd->hwndFrame,
    3609                                            FALSE,
    3610                                            pci->szFileName);
    3611                       if (hwndDir) {
    3612                         if (fMinOnOpen)
    3613                           WinSetWindowPos(dcd->hwndFrame,
    3614                                           HWND_BOTTOM,
    3615                                           0,
    3616                                           0,
    3617                                           0,
    3618                                           0,
    3619                                           SWP_MINIMIZE | SWP_ZORDER);
    3620                           if (fAutoTile)
    3621                             TileChildren(dcd->hwndParent,
    3622                                          TRUE);
    3623                         WinSetWindowPos(hwndDir,
    3624                                         HWND_TOP,
    3625                                         0,
    3626                                         0,
    3627                                         0,
    3628                                         0,
    3629                                         SWP_ACTIVATE);
    3630                       }
    3631                     }
    3632                     else {
    3633                       strcpy(dcd->previous,dcd->directory);
    3634                       strcpy(dcd->directory,pci->szFileName);
    3635                       DosEnterCritSec();
    3636                        dcd->stopflag++;
    3637                       DosExitCritSec();
    3638                       if (!PostMsg(dcd->hwndObject,
    3639                                    UM_RESCAN,
    3640                                    MPVOID,
    3641                                    MPFROMLONG(1L)))
    3642                       {
    3643                         DosEnterCritSec();
    3644                          dcd->stopflag--;
    3645                         DosExitCritSec();
    3646                       }
    3647                       else if (*dcd->directory) {
    3648                         if (hwndMain)
    3649                           WinSendMsg(hwndMain,
    3650                                      UM_SETUSERLISTNAME,
    3651                                      MPFROMP(dcd->directory),
    3652                                      MPVOID);
    3653                         else
    3654                           add_udir(FALSE,
    3655                                    dcd->directory);
    3656                       }
    3657                     }
    3658                   }
    3659                   else {
    3660 
    3661                     SWP swp;
    3662 
    3663                     WinQueryWindowPos(dcd->hwndFrame,&swp);
    3664                     WinSendMsg(hwnd,
    3665                                CM_SETRECORDEMPHASIS,
    3666                                MPFROMP(pci),
    3667                                MPFROM2SHORT(TRUE,CRA_INUSE));
    3668                     DefaultViewKeys(hwnd,
    3669                                     dcd->hwndFrame,
    3670                                     dcd->hwndParent,
    3671                                     &swp,
    3672                                     pci->szFileName);
    3673                     WinSendMsg(hwnd,
    3674                                CM_SETRECORDEMPHASIS,
    3675                                MPFROMP(pci),
    3676                                MPFROM2SHORT(FALSE,
    3677                                             CRA_INUSE |
    3678                                              ((fUnHilite) ?
    3679                                               CRA_SELECTED :
    3680                                               0)));
    3681                   }
    3682                 }
    3683                 else {
    3684                   if (!*dcd->directory || IsValidDir(dcd->directory)) {
    3685                     NotifyError(pci->szFileName,
    3686                                 status);
    3687                     WinSendMsg(hwnd,
    3688                                CM_REMOVERECORD,
    3689                                MPFROMP(&pci),
    3690                                MPFROM2SHORT(1,
    3691                                             CMA_FREE | CMA_INVALIDATE |
    3692                                             CMA_ERASE));
    3693                     if (hwndStatus)
    3694                       WinSetWindowText(hwndStatus,
    3695                                        GetPString(IDS_RESCANSUGGESTEDTEXT));
    3696                   }
    3697                   else {
    3698                     DosEnterCritSec();
    3699                     dcd->stopflag++;
    3700                     DosExitCritSec();
    3701                     if (!PostMsg(dcd->hwndObject,
    3702                                  UM_RESCAN,
    3703                                  MPVOID,
    3704                                  MPFROMLONG(1L)))
    3705                     {
    3706                       DosEnterCritSec();
    3707                       dcd->stopflag--;
    3708                       DosExitCritSec();
    3709                     }
    3710                     else if (*dcd->directory) {
    3711                       if (hwndMain)
    3712                         WinSendMsg(hwndMain,
    3713                                    UM_SETUSERLISTNAME,
    3714                                    MPFROMP(dcd->directory),
    3715                                    MPVOID);
    3716                       else
    3717                         add_udir(FALSE,
    3718                                  dcd->directory);
    3719                     }
    3720                   }
    3721                 }
    3722               }
    3723               else if (*dcd->directory)
    3724                 OpenObject(dcd->directory,
    3725                            Default,
    3726                            hwnd);
    3727             }
    3728             break;
    3729         }
    3730         break;
    3731       }
    3732       return 0;
    3733 
    3734     case UM_LOADFILE:
    3735       if (dcd && mp2) {
    3736 
    3737         HWND ret;
    3738 
    3739         ret = StartMLEEditor(dcd->hwndParent,
    3740                              (INT)mp1,
    3741                              (CHAR *)mp2,
    3742                              dcd->hwndFrame);
    3743         if (mp2)
    3744           free((CHAR *)mp2);
    3745         return MRFROMLONG(ret);
    3746       }
    3747       return 0;
    3748 
    3749     case WM_SAVEAPPLICATION:
    3750       if (dcd && ParentIsDesktop(hwnd,dcd->hwndParent)) {
    3751 
    3752         SWP swp;
    3753 
    3754         WinQueryWindowPos(dcd->hwndFrame,&swp);
    3755         if (!(swp.fl & (SWP_HIDE | SWP_MINIMIZE | SWP_MAXIMIZE)))
    3756           PrfWriteProfileData(fmprof,
    3757                               appname,
    3758                               "VDirSizePos",
    3759                               &swp,
    3760                               sizeof(swp));
     3212              if (!*dcd->directory || IsValidDir(dcd->directory)) {
     3213                NotifyError(pci->szFileName, status);
     3214                WinSendMsg(hwnd,
     3215                           CM_REMOVERECORD,
     3216                           MPFROMP(&pci),
     3217                           MPFROM2SHORT(1,
     3218                                        CMA_FREE | CMA_INVALIDATE |
     3219                                        CMA_ERASE));
     3220                if (hwndStatus)
     3221                  WinSetWindowText(hwndStatus,
     3222                                   GetPString(IDS_RESCANSUGGESTEDTEXT));
     3223              }
     3224              else {
     3225                DosEnterCritSec();
     3226                dcd->stopflag++;
     3227                DosExitCritSec();
     3228                if (!PostMsg(dcd->hwndObject,
     3229                             UM_RESCAN, MPVOID, MPFROMLONG(1L))) {
     3230                  DosEnterCritSec();
     3231                  dcd->stopflag--;
     3232                  DosExitCritSec();
     3233                }
     3234                else if (*dcd->directory) {
     3235                  if (hwndMain)
     3236                    WinSendMsg(hwndMain,
     3237                               UM_SETUSERLISTNAME,
     3238                               MPFROMP(dcd->directory), MPVOID);
     3239                  else
     3240                    add_udir(FALSE, dcd->directory);
     3241                }
     3242              }
     3243            }
     3244          }
     3245          else if (*dcd->directory)
     3246            OpenObject(dcd->directory, Default, hwnd);
     3247        }
     3248        break;
    37613249      }
    37623250      break;
    3763 
    3764     case WM_CLOSE:
    3765       WinSendMsg(hwnd,
    3766                  WM_SAVEAPPLICATION,
    3767                  MPVOID,
    3768                  MPVOID);
    3769       if (LastDir == hwnd)
    3770         LastDir = (HWND)0;
    3771       if (dcd) {
    3772         dcd->stopflag++;
    3773         if (!dcd->dontclose && ParentIsDesktop(dcd->hwndFrame,(HWND)0))
    3774           PostMsg((HWND)0,
    3775                   WM_QUIT,
    3776                   MPVOID,
    3777                   MPVOID);
    3778         if (!dcd->hwndObject ||
    3779             !PostMsg(dcd->hwndObject, WM_CLOSE, MPVOID, MPVOID))
    3780         {
    3781           if (dcd->hwndObject)
    3782             WinSetWindowPtr(dcd->hwndObject,
    3783                             QWL_USER,
    3784                             NULL);
    3785           WinSetWindowPtr(hwnd,
    3786                           QWL_USER,
    3787                           NULL);
    3788           if (dcd->hwndRestore)
    3789             WinSetWindowPos(dcd->hwndRestore,
    3790                             HWND_TOP,
    3791                             0,
    3792                             0,
    3793                             0,
    3794                             0,
    3795                             SWP_RESTORE | SWP_SHOW | SWP_ACTIVATE |
    3796                             SWP_ZORDER);
    3797           FreeList(dcd->lastselection);
    3798           free(dcd);
    3799           DosPostEventSem(CompactSem);
    3800         }
    3801       }
    3802       WinDestroyWindow(WinQueryWindow(WinQueryWindow(hwnd,QW_PARENT),
    3803                                       QW_PARENT));
    3804       return 0;
    3805 
    3806     case WM_DESTROY:
    3807       if (DirMenu)
    3808         WinDestroyWindow(DirMenu);
    3809       if (DirCnrMenu)
    3810         WinDestroyWindow(DirCnrMenu);
    3811       if (FileMenu)
    3812         WinDestroyWindow(FileMenu);
    3813       DirMenu = DirCnrMenu = FileMenu = (HWND)0;
    3814       EmptyCnr(hwnd);
    3815       break;
     3251    }
     3252    return 0;
     3253
     3254  case UM_LOADFILE:
     3255    if (dcd && mp2) {
     3256
     3257      HWND ret;
     3258
     3259      ret = StartMLEEditor(dcd->hwndParent,
     3260                           (INT) mp1, (CHAR *) mp2, dcd->hwndFrame);
     3261      if (mp2)
     3262        free((CHAR *) mp2);
     3263      return MRFROMLONG(ret);
     3264    }
     3265    return 0;
     3266
     3267  case WM_SAVEAPPLICATION:
     3268    if (dcd && ParentIsDesktop(hwnd, dcd->hwndParent)) {
     3269
     3270      SWP swp;
     3271
     3272      WinQueryWindowPos(dcd->hwndFrame, &swp);
     3273      if (!(swp.fl & (SWP_HIDE | SWP_MINIMIZE | SWP_MAXIMIZE)))
     3274        PrfWriteProfileData(fmprof,
     3275                            appname, "VDirSizePos", &swp, sizeof(swp));
     3276    }
     3277    break;
     3278
     3279  case WM_CLOSE:
     3280    WinSendMsg(hwnd, WM_SAVEAPPLICATION, MPVOID, MPVOID);
     3281    if (LastDir == hwnd)
     3282      LastDir = (HWND) 0;
     3283    if (dcd) {
     3284      dcd->stopflag++;
     3285      if (!dcd->dontclose && ParentIsDesktop(dcd->hwndFrame, (HWND) 0))
     3286        PostMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID);
     3287      if (!dcd->hwndObject ||
     3288          !PostMsg(dcd->hwndObject, WM_CLOSE, MPVOID, MPVOID)) {
     3289        if (dcd->hwndObject)
     3290          WinSetWindowPtr(dcd->hwndObject, QWL_USER, NULL);
     3291        WinSetWindowPtr(hwnd, QWL_USER, NULL);
     3292        if (dcd->hwndRestore)
     3293          WinSetWindowPos(dcd->hwndRestore,
     3294                          HWND_TOP,
     3295                          0,
     3296                          0,
     3297                          0,
     3298                          0,
     3299                          SWP_RESTORE | SWP_SHOW | SWP_ACTIVATE | SWP_ZORDER);
     3300        FreeList(dcd->lastselection);
     3301        free(dcd);
     3302        DosPostEventSem(CompactSem);
     3303      }
     3304    }
     3305    WinDestroyWindow(WinQueryWindow(WinQueryWindow(hwnd, QW_PARENT),
     3306                                    QW_PARENT));
     3307    return 0;
     3308
     3309  case WM_DESTROY:
     3310    if (DirMenu)
     3311      WinDestroyWindow(DirMenu);
     3312    if (DirCnrMenu)
     3313      WinDestroyWindow(DirCnrMenu);
     3314    if (FileMenu)
     3315      WinDestroyWindow(FileMenu);
     3316    DirMenu = DirCnrMenu = FileMenu = (HWND) 0;
     3317    EmptyCnr(hwnd);
     3318    break;
    38163319  }
    3817   return (dcd && dcd->oldproc) ? dcd->oldproc(hwnd,msg,mp1,mp2) :
    3818                                  PFNWPCnr(hwnd,msg,mp1,mp2);
     3320  return (dcd && dcd->oldproc) ? dcd->oldproc(hwnd, msg, mp1, mp2) :
     3321    PFNWPCnr(hwnd, msg, mp1, mp2);
    38193322}
    38203323
    3821 
    3822 HWND StartDirCnr (HWND hwndParent,CHAR *directory,HWND hwndRestore,ULONG flags)
     3324HWND StartDirCnr(HWND hwndParent, CHAR * directory, HWND hwndRestore,
     3325                 ULONG flags)
    38233326{
    38243327  /* bitmapped flags:
    … …  
    38273330   */
    38283331
    3829   HWND          hwndFrame = (HWND)0,hwndClient;
    3830   ULONG         FrameFlags = FCF_TITLEBAR   | FCF_SYSMENU     |
    3831                              FCF_SIZEBORDER | FCF_MINMAX      |
    3832                              FCF_ICON       | FCF_NOBYTEALIGN |
    3833                              FCF_ACCELTABLE;
    3834   USHORT        id;
     3332  HWND hwndFrame = (HWND) 0, hwndClient;
     3333  ULONG FrameFlags = FCF_TITLEBAR | FCF_SYSMENU |
     3334    FCF_SIZEBORDER | FCF_MINMAX | FCF_ICON | FCF_NOBYTEALIGN | FCF_ACCELTABLE;
     3335  USHORT id;
    38353336  static USHORT idinc = 0;
    3836   DIRCNRDATA   *dcd;
    3837   static BOOL   first = FALSE;
    3838 
    3839   if(flags & 2)
     3337  DIRCNRDATA *dcd;
     3338  static BOOL first = FALSE;
     3339
     3340  if (flags & 2)
    38403341    FrameFlags &= (~(FCF_TITLEBAR | FCF_SYSMENU | FCF_SIZEBORDER |
    3841                      FCF_MINMAX  | FCF_ICON));
    3842   if(!idinc)
     3342                     FCF_MINMAX | FCF_ICON));
     3343  if (!idinc)
    38433344    idinc = (rand() % 100);
    3844   if(!hwndParent)
     3345  if (!hwndParent)
    38453346    hwndParent = HWND_DESKTOP;
    3846   if(ParentIsDesktop(hwndParent,hwndParent))
     3347  if (ParentIsDesktop(hwndParent, hwndParent))
    38473348    FrameFlags |= (FCF_TASKLIST | FCF_MENU);
    3848   if(!hwndMain && !first) {
    3849     if(DirCnrMenu) {
     3349  if (!hwndMain && !first) {
     3350    if (DirCnrMenu) {
    38503351
    38513352      MENUITEM mi;
    38523353
    3853       memset(&mi,0,sizeof(mi));
     3354      memset(&mi, 0, sizeof(mi));
    38543355      WinSendMsg(DirCnrMenu,
    3855                  MM_DELETEITEM,
    3856                  MPFROM2SHORT(IDM_DRIVESMENU,FALSE),
    3857                  MPVOID);
     3356                 MM_DELETEITEM, MPFROM2SHORT(IDM_DRIVESMENU, FALSE), MPVOID);
    38583357      mi.iPosition = MIT_END;
    38593358      mi.afStyle = MIS_TEXT;
    38603359      mi.id = IDM_DRIVESMENU;
    38613360      WinSendMsg(DirCnrMenu,
    3862                  MM_INSERTITEM,
    3863                  MPFROMP(&mi),
    3864                  MPFROMP(GetPString(IDS_DRIVESMENUTEXT)));
     3361                 MM_INSERTITEM,
     3362                 MPFROMP(&mi), MPFROMP(GetPString(IDS_DRIVESMENUTEXT)));
    38653363    }
    38663364    first = TRUE;
    38673365  }
    3868   if(directory) {
     3366  if (directory) {
    38693367    hwndFrame = WinCreateStdWindow(hwndParent,
    3870                                    WS_VISIBLE,
    3871                                    &FrameFlags,
    3872                                    GetPString(IDS_WCDIRCONTAINER),
    3873                                    NULL,
    3874                                    WS_VISIBLE | fwsAnimate,
    3875                                    FM3ModHandle,
    3876                                    DIR_FRAME,
    3877                                    &hwndClient);
    3878     if(hwndFrame && hwndClient) {
     3368                                   WS_VISIBLE,
     3369                                   &FrameFlags,
     3370                                   GetPString(IDS_WCDIRCONTAINER),
     3371                                   NULL,
     3372                                   WS_VISIBLE | fwsAnimate,
     3373                                   FM3ModHandle, DIR_FRAME, &hwndClient);
     3374    if (hwndFrame && hwndClient) {
    38793375      id = DIR_FRAME + idinc++;
    3880       if(idinc > 99)
    3881         idinc = 0;
    3882       WinSetWindowUShort(hwndFrame,QWS_ID,id);
    3883       dcd = xmallocz(sizeof(DIRCNRDATA),pszSrcFile,__LINE__);
     3376      if (idinc > 99)
     3377        idinc = 0;
     3378      WinSetWindowUShort(hwndFrame, QWS_ID, id);
     3379      dcd = xmallocz(sizeof(DIRCNRDATA), pszSrcFile, __LINE__);
    38843380      if (!dcd) {
    3885         PostMsg(hwndClient,WM_CLOSE,MPVOID,MPVOID);
    3886         hwndFrame = (HWND)0;
     3381        PostMsg(hwndClient, WM_CLOSE, MPVOID, MPVOID);
     3382        hwndFrame = (HWND) 0;
    38873383      }
    38883384      else {
    3889         dcd->size = sizeof(DIRCNRDATA);
    3890         dcd->id = id;
    3891         dcd->type = DIR_FRAME;
    3892         dcd->hwndParent = (hwndParent) ? hwndParent : HWND_DESKTOP;
    3893         dcd->hwndFrame  = hwndFrame;
    3894         dcd->hwndClient = hwndClient;
    3895         dcd->hwndRestore = hwndRestore;
    3896         dcd->dontclose = ((flags & 1) != 0);
    3897         strcpy(dcd->directory,directory);
    3898         add_udir(FALSE,directory);
    3899         {
    3900           PFNWP oldproc;
    3901 
    3902           oldproc = WinSubclassWindow(hwndFrame,
    3903                                       (PFNWP)DirFrameWndProc);
    3904           WinSetWindowPtr(hwndFrame,
    3905                           QWL_USER,
    3906                           (PVOID)oldproc);
    3907         }
    3908         dcd->hwndCnr = WinCreateWindow(hwndClient,
    3909                                        WC_CONTAINER,
    3910                                        NULL,
    3911                                        CCS_AUTOPOSITION | CCS_MINIICONS |
    3912                                        CCS_MINIRECORDCORE | ulCnrType |
    3913                                        WS_VISIBLE,
    3914                                        0,
    3915                                        0,
    3916                                        0,
    3917                                        0,
    3918                                        hwndClient,
    3919                                        HWND_TOP,
    3920                                        (ULONG)DIR_CNR,
    3921                                        NULL,
    3922                                        NULL);
    3923         if (!dcd->hwndCnr) {
    3924           Win_Error2(hwndClient,hwndClient,pszSrcFile,__LINE__,IDS_WINCREATEWINDOW);
    3925           PostMsg(hwndClient,WM_CLOSE,MPVOID,MPVOID);
    3926           free(dcd);
    3927           hwndFrame = (HWND)0;
     3385        dcd->size = sizeof(DIRCNRDATA);
     3386        dcd->id = id;
     3387        dcd->type = DIR_FRAME;
     3388        dcd->hwndParent = (hwndParent) ? hwndParent : HWND_DESKTOP;
     3389        dcd->hwndFrame = hwndFrame;
     3390        dcd->hwndClient = hwndClient;
     3391        dcd->hwndRestore = hwndRestore;
     3392        dcd->dontclose = ((flags & 1) != 0);
     3393        strcpy(dcd->directory, directory);
     3394        add_udir(FALSE, directory);
     3395        {
     3396          PFNWP oldproc;
     3397
     3398          oldproc = WinSubclassWindow(hwndFrame, (PFNWP) DirFrameWndProc);
     3399          WinSetWindowPtr(hwndFrame, QWL_USER, (PVOID) oldproc);
     3400        }
     3401        dcd->hwndCnr = WinCreateWindow(hwndClient,
     3402                                       WC_CONTAINER,
     3403                                       NULL,
     3404                                       CCS_AUTOPOSITION | CCS_MINIICONS |
     3405                                       CCS_MINIRECORDCORE | ulCnrType |
     3406                                       WS_VISIBLE,
     3407                                       0,
     3408                                       0,
     3409                                       0,
     3410                                       0,
     3411                                       hwndClient,
     3412                                       HWND_TOP, (ULONG) DIR_CNR, NULL, NULL);
     3413        if (!dcd->hwndCnr) {
     3414          Win_Error2(hwndClient, hwndClient, pszSrcFile, __LINE__,
     3415                     IDS_WINCREATEWINDOW);
     3416          PostMsg(hwndClient, WM_CLOSE, MPVOID, MPVOID);
     3417          free(dcd);
     3418          hwndFrame = (HWND) 0;
    39283419        }
    39293420        else {
    3930           WinSetWindowPtr(dcd->hwndCnr,QWL_USER,(PVOID)dcd);
    3931           dcd->oldproc = WinSubclassWindow(dcd->hwndCnr,
    3932                                            (PFNWP)DirCnrWndProc);
    3933           {
    3934             USHORT ids[] = {DIR_TOTALS,DIR_SELECTED,DIR_VIEW,DIR_SORT,
    3935                             DIR_FILTER,DIR_FOLDERICON,DIR_MAX,0};
    3936 
    3937             if(!(flags & 2))
    3938               ids[6] = 0;
    3939             CommonCreateTextChildren(dcd->hwndClient,
    3940                                      GetPString(IDS_WCDIRSTATUS),
    3941                                      ids);
    3942           }
    3943           if(!PostMsg(dcd->hwndCnr,
    3944                       UM_SETUP,
    3945                       MPVOID,
    3946                       MPVOID))
    3947             WinSendMsg(dcd->hwndCnr,
    3948                        UM_SETUP,
    3949                        MPVOID,
    3950                        MPVOID);
    3951           if(FrameFlags & FCF_TASKLIST) {
    3952 
    3953             SWP   swp,swpD;
    3954             ULONG size = sizeof(swp);
    3955             LONG  cxScreen,cyScreen;
    3956 
    3957             WinQueryTaskSizePos(WinQueryAnchorBlock(hwndFrame),0,&swp);
    3958             if(PrfQueryProfileData(fmprof,
    3959                                    appname,
    3960                                    "VDirSizePos",
    3961                                    &swpD,
    3962                                    &size)) {
    3963               cxScreen = WinQuerySysValue(HWND_DESKTOP,SV_CXSCREEN);
    3964               cyScreen = WinQuerySysValue(HWND_DESKTOP,SV_CYSCREEN);
    3965               if(swp.x + swpD.cx > cxScreen)
    3966                 swp.x = cxScreen - swpD.cx;
    3967               if(swp.y + swpD.cy > cyScreen)
    3968                 swp.y = cyScreen - swpD.cy;
    3969               swp.cx = swpD.cx;
    3970               swp.cy = swpD.cy;
    3971             }
    3972             WinSetWindowPos(hwndFrame,
    3973                             HWND_TOP,
    3974                             swp.x,
    3975                             swp.y,
    3976                             swp.cx,
    3977                             swp.cy,
    3978                             SWP_SIZE | SWP_MOVE | SWP_SHOW | SWP_ZORDER |
    3979                             SWP_ACTIVATE);
    3980           }
    3981         }
     3421          WinSetWindowPtr(dcd->hwndCnr, QWL_USER, (PVOID) dcd);
     3422          dcd->oldproc = WinSubclassWindow(dcd->hwndCnr,
     3423                                           (PFNWP) DirCnrWndProc);
     3424          {
     3425            USHORT ids[] = { DIR_TOTALS, DIR_SELECTED, DIR_VIEW, DIR_SORT,
     3426              DIR_FILTER, DIR_FOLDERICON, DIR_MAX, 0
     3427            };
     3428
     3429            if (!(flags & 2))
     3430              ids[6] = 0;
     3431            CommonCreateTextChildren(dcd->hwndClient,
     3432                                     GetPString(IDS_WCDIRSTATUS), ids);
     3433          }
     3434          if (!PostMsg(dcd->hwndCnr, UM_SETUP, MPVOID, MPVOID))
     3435            WinSendMsg(dcd->hwndCnr, UM_SETUP, MPVOID, MPVOID);
     3436          if (FrameFlags & FCF_TASKLIST) {
     3437
     3438            SWP swp, swpD;
     3439            ULONG size = sizeof(swp);
     3440            LONG cxScreen, cyScreen;
     3441
     3442            WinQueryTaskSizePos(WinQueryAnchorBlock(hwndFrame), 0, &swp);
     3443            if (PrfQueryProfileData(fmprof,
     3444                                    appname, "VDirSizePos", &swpD, &size)) {
     3445              cxScreen = WinQuerySysValue(HWND_DESKTOP, SV_CXSCREEN);
     3446              cyScreen = WinQuerySysValue(HWND_DESKTOP, SV_CYSCREEN);
     3447              if (swp.x + swpD.cx > cxScreen)
     3448                swp.x = cxScreen - swpD.cx;
     3449              if (swp.y + swpD.cy > cyScreen)
     3450                swp.y = cyScreen - swpD.cy;
     3451              swp.cx = swpD.cx;
     3452              swp.cy = swpD.cy;
     3453            }
     3454            WinSetWindowPos(hwndFrame,
     3455                            HWND_TOP,
     3456                            swp.x,
     3457                            swp.y,
     3458                            swp.cx,
     3459                            swp.cy,
     3460                            SWP_SIZE | SWP_MOVE | SWP_SHOW | SWP_ZORDER |
     3461                            SWP_ACTIVATE);
     3462          }
     3463        }
    39823464      }
    39833465    }
    … …  
    39853467  return hwndFrame;
    39863468}
    3987 
Note: See TracChangeset for help on using the changeset viewer.