Changeset 194 for trunk/dll


Ignore:
Timestamp:
Jun 6, 2005, 10:52:22 PM (20 years ago)
Author:
root
Message:

Indent -i2

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/dll/collect.c

    r186 r194  
    1717  25 May 05 SHL Rework for FillInRecordFromFFB
    1818  05 Jun 05 SHL Use QWL_USER
     19  06 Jun 05 SHL Indent -i2
    1920
    2021***********************************************************************/
    … …  
    4849#pragma alloc_text(STARTUP,StartCollector)
    4950
    50 
    51 MRESULT EXPENTRY CollectorFrameWndProc (HWND hwnd,ULONG msg,MPARAM mp1,
    52                                         MPARAM mp2) {
    53 
    54   return CommonFrameWndProc(COLLECTOR_CNR,hwnd,msg,mp1,mp2);
     51MRESULT EXPENTRY CollectorFrameWndProc(HWND hwnd, ULONG msg, MPARAM mp1,
     52                                       MPARAM mp2)
     53{
     54  return CommonFrameWndProc(COLLECTOR_CNR, hwnd, msg, mp1, mp2);
    5555}
    5656
    57 
    58 MRESULT EXPENTRY CollectorTextProc (HWND hwnd,ULONG msg,MPARAM mp1,MPARAM mp2)
     57MRESULT EXPENTRY CollectorTextProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
    5958{
    6059  LONGLONG ullBytes;
    6160
    62   static BOOL   emphasized      = FALSE;
    63   static HWND   hwndButtonPopup = (HWND)0;
    64   static ULONG  timestamp       = ULONG_MAX;
    65   static USHORT lastid          = 0;
    66 
    67   switch(msg) {
    68     case WM_CREATE:
    69       return CommonTextProc(hwnd,msg,mp1,mp2);
    70 
    71     case UM_CONTEXTMENU:
    72     case WM_CONTEXTMENU:
    73       {
    74         USHORT id;
    75 
    76         id = WinQueryWindowUShort(hwnd,QWS_ID);
    77         switch(id) {
    78           case DIR_SELECTED:
    79           case DIR_VIEW:
    80           case DIR_SORT:
    81             {
    82               POINTL      ptl = {0,0};
    83               SWP         swp;
    84               DIRCNRDATA *dcd;
    85 
    86               if(hwndButtonPopup)
    87                 WinDestroyWindow(hwndButtonPopup);
    88               if(id == lastid) {
    89 
    90                 ULONG check;
    91 
    92                 DosQuerySysInfo(QSV_MS_COUNT,
    93                                 QSV_MS_COUNT,
    94                                 &check,
    95                                 sizeof(check));
    96                 if(check < timestamp + 500) {
    97                   lastid = 0;
    98                   goto MenuAbort;
    99                 }
    100               }
    101               hwndButtonPopup = WinLoadMenu(HWND_DESKTOP,
    102                                             FM3ModHandle,
    103                                             id);
    104               if(hwndButtonPopup) {
    105                 WinSetWindowUShort(hwndButtonPopup,
    106                                    QWS_ID,
    107                                    id);
    108                 dcd = WinQueryWindowPtr(WinWindowFromID(WinQueryWindow(hwnd,
    109                                                         QW_PARENT),
    110                                                         COLLECTOR_CNR),
    111                                         QWL_USER);
    112                 if(id == DIR_VIEW) {
    113                   if(dcd) {
    114                     SetViewMenu(hwndButtonPopup,
    115                                 dcd->flWindowAttr);
    116                     SetDetailsSwitches(hwndButtonPopup,
    117                                        dcd);
    118                   }
    119 
    120                   /* don't have tree view in collector */
    121                   WinSendMsg(hwndButtonPopup,
    122                              MM_DELETEITEM,
    123                              MPFROM2SHORT(IDM_TREEVIEW,
    124                                           FALSE),
    125                              MPVOID);
    126 
    127                 }
    128                 else if(id == DIR_SORT) {
    129                   if(dcd)
    130                     SetSortChecks(hwndButtonPopup,
    131                                   dcd->sortFlags);
    132                 }
    133                 ptl.x = 0;
    134                 if(WinPopupMenu(HWND_OBJECT,
    135                                 HWND_OBJECT,
    136                                 hwndButtonPopup,
    137                                 -32767,
    138                                 -32767,
    139                                 0,
    140                                 0)) {
    141                   WinQueryWindowPos(hwndButtonPopup,
    142                                     &swp);
    143                   ptl.y = -(swp.cy + 2);
    144                 }
    145                 else {
    146                   WinQueryWindowPos(hwnd,
    147                                     &swp);
    148                   ptl.y = swp.cy + 2;
    149                 }
    150                 if(WinPopupMenu(hwnd,
    151                                 hwnd,
    152                                 hwndButtonPopup,
    153                                 ptl.x,
    154                                 ptl.y,
    155                                 0,
    156                                 PU_HCONSTRAIN | PU_VCONSTRAIN |
    157                                 PU_KEYBOARD   | PU_MOUSEBUTTON1)) {
    158                   CenterOverWindow(hwndButtonPopup);
    159                   PaintRecessedWindow(hwnd,
    160                                       (HPS)0,
    161                                       FALSE,
    162                                       FALSE);
    163                 }
    164               }
    165             }
    166             break;
    167           default:
    168             PostMsg(WinWindowFromID(WinQueryWindow(hwnd,QW_PARENT),
    169                                     COLLECTOR_CNR),
    170                     WM_CONTROL,
    171                     MPFROM2SHORT(COLLECTOR_CNR,
    172                                  CN_CONTEXTMENU),
    173                     MPVOID);
    174             break;
    175         }
    176       }
    177 MenuAbort:
    178       if(msg == UM_CONTEXTMENU)
    179         return 0;
     61  static BOOL emphasized = FALSE;
     62  static HWND hwndButtonPopup = (HWND) 0;
     63  static ULONG timestamp = ULONG_MAX;
     64  static USHORT lastid = 0;
     65
     66  switch (msg)
     67  {
     68  case WM_CREATE:
     69    return CommonTextProc(hwnd, msg, mp1, mp2);
     70
     71  case UM_CONTEXTMENU:
     72  case WM_CONTEXTMENU:
     73    {
     74      USHORT id;
     75
     76      id = WinQueryWindowUShort(hwnd, QWS_ID);
     77      switch (id)
     78      {
     79      case DIR_SELECTED:
     80      case DIR_VIEW:
     81      case DIR_SORT:
     82        {
     83          POINTL ptl = {0, 0};
     84          SWP swp;
     85          DIRCNRDATA *dcd;
     86
     87          if (hwndButtonPopup)
     88            WinDestroyWindow(hwndButtonPopup);
     89          if (id == lastid)
     90          {
     91            ULONG check;
     92
     93            DosQuerySysInfo(QSV_MS_COUNT,
     94                            QSV_MS_COUNT,
     95                            &check,
     96                            sizeof(check));
     97            if (check < timestamp + 500)
     98            {
     99              lastid = 0;
     100              goto MenuAbort;
     101            }
     102          }
     103          hwndButtonPopup = WinLoadMenu(HWND_DESKTOP,
     104                                        FM3ModHandle,
     105                                        id);
     106          if (hwndButtonPopup)
     107          {
     108            WinSetWindowUShort(hwndButtonPopup,
     109                               QWS_ID,
     110                               id);
     111            dcd = WinQueryWindowPtr(WinWindowFromID(WinQueryWindow(hwnd,
     112                                                                 QW_PARENT),
     113                                                    COLLECTOR_CNR),
     114                                    QWL_USER);
     115            if (id == DIR_VIEW)
     116            {
     117              if (dcd)
     118              {
     119                SetViewMenu(hwndButtonPopup,
     120                            dcd -> flWindowAttr);
     121                SetDetailsSwitches(hwndButtonPopup,
     122                                   dcd);
     123              }
     124
     125              /* don't have tree view in collector */
     126              WinSendMsg(hwndButtonPopup,
     127                         MM_DELETEITEM,
     128                         MPFROM2SHORT(IDM_TREEVIEW,
     129                                      FALSE),
     130                         MPVOID);
     131
     132            }
     133            else if (id == DIR_SORT)
     134            {
     135              if (dcd)
     136                SetSortChecks(hwndButtonPopup,
     137                              dcd -> sortFlags);
     138            }
     139            ptl.x = 0;
     140            if (WinPopupMenu(HWND_OBJECT,
     141                             HWND_OBJECT,
     142                             hwndButtonPopup,
     143                             -32767,
     144                             -32767,
     145                             0,
     146                             0))
     147            {
     148              WinQueryWindowPos(hwndButtonPopup,
     149                                &swp);
     150              ptl.y = -(swp.cy + 2);
     151            }
     152            else
     153            {
     154              WinQueryWindowPos(hwnd,
     155                                &swp);
     156              ptl.y = swp.cy + 2;
     157            }
     158            if (WinPopupMenu(hwnd,
     159                             hwnd,
     160                             hwndButtonPopup,
     161                             ptl.x,
     162                             ptl.y,
     163                             0,
     164                             PU_HCONSTRAIN | PU_VCONSTRAIN |
     165                             PU_KEYBOARD | PU_MOUSEBUTTON1))
     166            {
     167              CenterOverWindow(hwndButtonPopup);
     168              PaintRecessedWindow(hwnd,
     169                                  (HPS) 0,
     170                                  FALSE,
     171                                  FALSE);
     172            }
     173          }
     174        }
     175        break;
     176      default:
     177        PostMsg(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
     178                                COLLECTOR_CNR),
     179                WM_CONTROL,
     180                MPFROM2SHORT(COLLECTOR_CNR,
     181                             CN_CONTEXTMENU),
     182                MPVOID);
     183        break;
     184      }
     185    }
     186  MenuAbort:
     187    if (msg == UM_CONTEXTMENU)
     188      return 0;
     189    break;
     190
     191  case WM_MENUEND:
     192    if (hwndButtonPopup == (HWND) mp2)
     193    {
     194      lastid = WinQueryWindowUShort((HWND) mp2,
     195                                    QWS_ID);
     196      WinDestroyWindow(hwndButtonPopup);
     197      hwndButtonPopup = (HWND) 0;
     198      DosQuerySysInfo(QSV_MS_COUNT,
     199                      QSV_MS_COUNT,
     200                      &timestamp,
     201                      sizeof(timestamp));
     202      switch (lastid)
     203      {
     204      case DIR_SELECTED:
     205      case DIR_VIEW:
     206      case DIR_SORT:
     207        PaintRecessedWindow(hwnd,
     208                            (HPS) 0,
     209                            TRUE,
     210                            FALSE);
     211        break;
     212      }
     213    }
     214    break;
     215
     216  case WM_COMMAND:
     217    {
     218      DIRCNRDATA *dcd;
     219      MRESULT mr;
     220
     221      mr = WinSendMsg(WinWindowFromID(WinQueryWindow(hwnd,
     222                                                     QW_PARENT),
     223                                      COLLECTOR_CNR),
     224                      msg,
     225                      mp1,
     226                      mp2);
     227      if (hwndButtonPopup &&
     228          SHORT1FROMMP(mp1) > IDM_DETAILSTITLES &&
     229          SHORT1FROMMP(mp1) < IDM_DETAILSSETUP)
     230      {
     231        dcd = WinQueryWindowPtr(WinWindowFromID(WinQueryWindow(hwnd,
     232                                                               QW_PARENT),
     233                                                COLLECTOR_CNR),
     234                                QWL_USER);
     235        if (dcd)
     236          SetDetailsSwitches(hwndButtonPopup,
     237                             dcd);
     238      }
     239      return mr;
     240    }
     241
     242  case WM_MOUSEMOVE:
     243    {
     244      USHORT id = WinQueryWindowUShort(hwnd, QWS_ID);
     245      char *s = NULL;
     246
     247      if (fOtherHelp)
     248      {
     249        if ((!hwndBubble ||
     250             WinQueryWindowULong(hwndBubble, QWL_USER) != hwnd) &&
     251            !WinQueryCapture(HWND_DESKTOP))
     252        {
     253          switch (id)
     254          {
     255          case DIR_SELECTED:
     256            s = GetPString(IDS_COLSELECTEDHELP);
     257            break;
     258          case DIR_TOTALS:
     259            s = GetPString(IDS_COLTOTALSHELP);
     260            break;
     261          case DIR_VIEW:
     262            s = GetPString(IDS_DIRCNRVIEWHELP);
     263            break;
     264          case DIR_SORT:
     265            s = GetPString(IDS_DIRCNRSORTHELP);
     266            break;
     267          case DIR_FILTER:
     268            s = GetPString(IDS_DIRCNRFILTERHELP);
     269            break;
     270          default:
     271            break;
     272          }
     273          if (s)
     274            MakeBubble(hwnd, TRUE, s);
     275          else if (hwndBubble)
     276            WinDestroyWindow(hwndBubble);
     277        }
     278      }
     279      switch (id)
     280      {
     281      case DIR_FILTER:
     282      case DIR_SORT:
     283      case DIR_VIEW:
     284      case DIR_SELECTED:
     285        return CommonTextButton(hwnd, msg, mp1, mp2);
     286      }
     287    }
     288    break;
     289
     290  case WM_BUTTON3UP:
     291  case WM_BUTTON1UP:
     292  case WM_BUTTON3DOWN:
     293  case WM_BUTTON1DOWN:
     294    {
     295      USHORT id;
     296
     297      id = WinQueryWindowUShort(hwnd,
     298                                QWS_ID);
     299      switch (id)
     300      {
     301      case DIR_FILTER:
     302      case DIR_SORT:
     303      case DIR_VIEW:
     304      case DIR_SELECTED:
     305        return CommonTextButton(hwnd, msg, mp1, mp2);
     306      }
     307    }
     308    break;
     309
     310  case UM_CLICKED:
     311  case UM_CLICKED3:
     312    {
     313      USHORT id, cmd = 0;
     314
     315      id = WinQueryWindowUShort(hwnd,
     316                                QWS_ID);
     317      switch (id)
     318      {
     319      case DIR_VIEW:
     320      case DIR_SORT:
     321      case DIR_SELECTED:
     322        PostMsg(hwnd,
     323                UM_CONTEXTMENU,
     324                MPVOID,
     325                MPVOID);
     326        break;
     327      case DIR_FILTER:
     328        cmd = IDM_FILTER;
     329        break;
     330      default:
     331        break;
     332      }
     333      if (cmd)
     334        PostMsg(WinWindowFromID(WinQueryWindow(hwnd,
     335                                               QW_PARENT),
     336                                COLLECTOR_CNR),
     337                WM_COMMAND,
     338                MPFROM2SHORT(cmd, 0),
     339                MPVOID);
     340    }
     341    return 0;
     342
     343  case DM_DROP:
     344  case DM_DRAGOVER:
     345  case DM_DRAGLEAVE:
     346  case DM_DROPHELP:
     347    if (msg == DM_DRAGOVER)
     348    {
     349      if (!emphasized)
     350      {
     351        emphasized = TRUE;
     352        DrawTargetEmphasis(hwnd, emphasized);
     353      }
     354    }
     355    else
     356    {
     357      if (emphasized)
     358      {
     359        emphasized = FALSE;
     360        DrawTargetEmphasis(hwnd, emphasized);
     361      }
     362    }
     363    {
     364      CNRDRAGINFO cnd;
     365      USHORT dcmd;
     366
     367      switch (msg)
     368      {
     369      case DM_DROP:
     370        dcmd = CN_DROP;
     371        break;
     372      case DM_DRAGOVER:
     373        dcmd = CN_DRAGOVER;
     374        break;
     375      case DM_DRAGLEAVE:
     376        dcmd = CN_DRAGLEAVE;
     377        break;
     378      case DM_DROPHELP:
     379        dcmd = CN_DROPHELP;
     380        break;
     381      }
     382      memset(&cnd, 0, sizeof(cnd));
     383      cnd.pDragInfo = (PDRAGINFO) mp1;
     384      cnd.pRecord = NULL;
     385      return WinSendMsg(WinQueryWindow(hwnd, QW_PARENT), WM_CONTROL,
     386                        MPFROM2SHORT(COLLECTOR_CNR, dcmd), MPFROMP(&cnd));
     387    }
     388  }
     389  return PFNWPStatic(hwnd, msg, mp1, mp2);
     390}
     391
     392MRESULT EXPENTRY CollectorClientWndProc(HWND hwnd, ULONG msg, MPARAM mp1,
     393                                        MPARAM mp2)
     394{
     395  switch (msg)
     396  {
     397  case UM_CONTAINERHWND:
     398    return MRFROMLONG(WinWindowFromID(hwnd, COLLECTOR_CNR));
     399
     400  case UM_VIEWSMENU:
     401    return MRFROMLONG(CheckMenu(&CollectorCnrMenu, COLLECTORCNR_POPUP));
     402
     403  case MM_PORTHOLEINIT:
     404  case WM_INITMENU:
     405  case UM_INITMENU:
     406  case UM_CONTAINER_FILLED:
     407  case UM_FILESMENU:
     408  case UM_UPDATERECORD:
     409  case UM_UPDATERECORDLIST:
     410    return WinSendMsg(WinWindowFromID(hwnd, COLLECTOR_CNR), msg, mp1, mp2);
     411
     412  case WM_PSETFOCUS:
     413  case WM_SETFOCUS:
     414    if (mp2)
     415      PostMsg(hwnd, UM_FOCUSME, MPVOID, MPVOID);
     416    break;
     417
     418  case UM_FOCUSME:
     419    WinSetFocus(HWND_DESKTOP, WinWindowFromID(hwnd, COLLECTOR_CNR));
     420    break;
     421
     422  case WM_PAINT:
     423    {
     424      HPS hps;
     425      RECTL rcl;
     426
     427      hps = WinBeginPaint(hwnd, (HPS) 0, NULL);
     428      if (hps)
     429      {
     430        WinQueryWindowRect(hwnd, &rcl);
     431        WinFillRect(hps, &rcl, CLR_PALEGRAY);
     432        CommonTextPaint(hwnd, hps);
     433        WinEndPaint(hps);
     434      }
     435    }
     436    break;
     437
     438  case UM_SIZE:
     439  case WM_SIZE:
     440    if (msg == UM_SIZE)
     441    {
     442      SWP swp;
     443
     444      WinQueryWindowPos(hwnd, &swp);
     445      mp1 = MPFROM2SHORT(swp.cx, swp.cy);
     446      mp2 = MPFROM2SHORT(swp.cx, swp.cy);
     447    }
     448    {
     449      USHORT cx, cy, bx;
     450
     451      cx = SHORT1FROMMP(mp2);
     452      cy = SHORT2FROMMP(mp2);
     453      WinSetWindowPos(WinWindowFromID(hwnd, COLLECTOR_CNR), HWND_TOP,
     454                      0,
     455                      0,
     456                      cx,
     457                      cy - 24,
     458                      SWP_SHOW | SWP_MOVE | SWP_SIZE);
     459      WinSetWindowPos(WinWindowFromID(hwnd, DIR_TOTALS), HWND_TOP,
     460                      2,
     461                      cy - 22,
     462                      (cx / 3) - 2,
     463                      20,
     464                      SWP_SHOW | SWP_MOVE | SWP_SIZE);
     465      WinSetWindowPos(WinWindowFromID(hwnd, DIR_SELECTED), HWND_TOP,
     466                      2 + (cx / 3) + 2,
     467                      cy - 22,
     468                      (cx / 3) - 2,
     469                      20,
     470                      SWP_SHOW | SWP_MOVE | SWP_SIZE);
     471      bx = (cx - (2 + (((cx / 3) + 2) * 2))) / 3;
     472      WinSetWindowPos(WinWindowFromID(hwnd, DIR_VIEW), HWND_TOP,
     473                      2 + (((cx / 3) + 2) * 2),
     474                      cy - 22,
     475                      bx - 4,
     476                      20,
     477                      SWP_SHOW | SWP_MOVE | SWP_SIZE);
     478      WinSetWindowPos(WinWindowFromID(hwnd, DIR_SORT), HWND_TOP,
     479                      2 + (((cx / 3) + 2) * 2) + bx,
     480                      cy - 22,
     481                      bx - 4,
     482                      20,
     483                      SWP_SHOW | SWP_MOVE | SWP_SIZE);
     484      WinSetWindowPos(WinWindowFromID(hwnd, DIR_FILTER), HWND_TOP,
     485                      2 + (((cx / 3) + 2) * 2) + (bx * 2),
     486                      cy - 22,
     487                      bx - 4,
     488                      20,
     489                      SWP_SHOW | SWP_MOVE | SWP_SIZE);
     490    }
     491    CommonTextPaint(hwnd, (HPS) 0);
     492    if (msg == UM_SIZE)
     493    {
     494      WinSetWindowPos(WinQueryWindow(hwnd, QW_PARENT), HWND_TOP, 0, 0, 0, 0,
     495                      SWP_SHOW | SWP_ZORDER | SWP_ACTIVATE);
     496      return 0;
     497    }
     498    break;
     499
     500  case UM_COMMAND:
     501  case WM_COMMAND:
     502  case WM_CONTROL:
     503  case WM_CLOSE:
     504    return WinSendMsg(WinWindowFromID(hwnd, COLLECTOR_CNR), msg, mp1, mp2);
     505  }
     506  return WinDefWindowProc(hwnd, msg, mp1, mp2);
     507}
     508
     509MRESULT EXPENTRY CollectorObjWndProc(HWND hwnd, ULONG msg, MPARAM mp1,
     510                                     MPARAM mp2)
     511{
     512  DIRCNRDATA *dcd;
     513
     514  switch (msg)
     515  {
     516  case WM_CREATE:
     517    break;
     518
     519  case DM_PRINTOBJECT:
     520    return MRFROMLONG(DRR_TARGET);
     521
     522  case DM_DISCARDOBJECT:
     523    dcd = INSTDATA(hwnd);
     524    if (fFM2Deletes && dcd)
     525    {
     526      LISTINFO *li;
     527      CNRDRAGINFO cni;
     528
     529      cni.pRecord = NULL;
     530      cni.pDragInfo = (PDRAGINFO) mp1;
     531      li = DoFileDrop(dcd -> hwndCnr, NULL, FALSE, MPVOID, MPFROMP(&cni));
     532      if (li)
     533      {
     534        li -> type = (fDefaultDeletePerm) ? IDM_PERMDELETE : IDM_DELETE;
     535        if (!PostMsg(hwnd, UM_MASSACTION, MPFROMP(li), MPVOID))
     536          FreeListInfo(li);
     537        else
     538          return MRFROMLONG(DRR_SOURCE);
     539      }
     540    }
     541    return MRFROMLONG(DRR_TARGET);
     542
     543  case UM_UPDATERECORDLIST:
     544    dcd = WinQueryWindowPtr(hwnd, QWL_USER);
     545    if (dcd && mp1)
     546    {
     547      INT numentries = 0;
     548      CHAR **list = (CHAR **) mp1;
     549
     550      while (list[numentries])
     551        numentries++;
     552      if (numentries)
     553        UpdateCnrList(dcd -> hwndCnr, list, numentries, FALSE, dcd);
     554    }
     555    return 0;
     556
     557  case UM_SETUP:
     558    dcd = WinQueryWindowPtr(hwnd, QWL_USER);
     559    if (dcd)
     560    {
     561      /* set unique id */
     562      WinSetWindowUShort(hwnd,
     563                         QWS_ID,
     564                         COLLECTOROBJ_FRAME + (COLLECTOR_FRAME - dcd -> id));
     565      dcd -> hwndObject = hwnd;
     566      if (ParentIsDesktop(hwnd, dcd -> hwndParent))
     567        DosSleep(250L);
     568    }
     569    else
     570      PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
     571    return 0;
     572
     573  case UM_COMMAND:
     574    if (mp1)
     575    {
     576      LISTINFO *li = (LISTINFO *) mp1;
     577
     578      switch (li -> type)
     579      {
     580      case IDM_DOITYOURSELF:
     581      case IDM_APPENDTOCLIP:
     582      case IDM_SAVETOCLIP:
     583      case IDM_ARCHIVE:
     584      case IDM_ARCHIVEM:
     585      case IDM_VIEW:
     586      case IDM_VIEWTEXT:
     587      case IDM_VIEWBINARY:
     588      case IDM_VIEWARCHIVE:
     589      case IDM_EDIT:
     590      case IDM_EDITTEXT:
     591      case IDM_EDITBINARY:
     592      case IDM_OBJECT:
     593      case IDM_SHADOW:
     594      case IDM_SHADOW2:
     595      case IDM_PRINT:
     596      case IDM_ATTRS:
     597      case IDM_DELETE:
     598      case IDM_PERMDELETE:
     599      case IDM_FAKEEXTRACT:
     600      case IDM_FAKEEXTRACTM:
     601      case IDM_MCIPLAY:
     602      case IDM_UPDATE:
     603        if (PostMsg(hwnd, UM_MASSACTION, mp1, mp2))
     604          return (MRESULT) TRUE;
     605        break;
     606      default:
     607        if (PostMsg(hwnd, UM_ACTION, mp1, mp2))
     608          return (MRESULT) TRUE;
     609      }
     610    }
     611    return 0;
     612
     613  case UM_COLLECT:
     614    DosError(FERR_DISABLEHARDERR);
     615    dcd = WinQueryWindowPtr(hwnd, QWL_USER);
     616    if (dcd)
     617    {
     618      LISTINFO *li = (LISTINFO *) mp1;
     619      INT x;
     620      FILEFINDBUF4 fb4;
     621      HDIR hdir;
     622      ULONG nm;
     623      PCNRITEM pci, pciFirst, pciT, pciP = NULL;
     624      RECORDINSERT ri;
     625      ULONG ulMaxFiles;
     626      ULONGLONG ullTotalBytes;
     627      CHAR fullname[CCHMAXPATH];
     628
     629      WinSetWindowText(WinWindowFromID(dcd -> hwndClient,
     630                                       DIR_SELECTED),
     631                       GetPString(IDS_COLLECTINGTEXT));
     632      for (x = 0; li -> list[x]; x++)
     633        ;
     634      ulMaxFiles = x;
     635      if (ulMaxFiles)
     636      {
     637        pci = WinSendMsg(dcd -> hwndCnr, CM_ALLOCRECORD,
     638                         MPFROMLONG(EXTRA_RECORD_BYTES),
     639                         MPFROMLONG(ulMaxFiles));
     640        if (pci)
     641        {
     642          pciFirst = pci;
     643          for (x = 0; li -> list[x]; x++)
     644          {
     645            nm = 1L;
     646            hdir = HDIR_CREATE;
     647            DosError(FERR_DISABLEHARDERR);
     648            if (*li -> list[x] &&
     649                !DosQueryPathInfo(li -> list[x], FIL_QUERYFULLNAME,
     650                                  fullname, sizeof(fullname)) &&
     651                !IsRoot(fullname) &&
     652                !FindCnrRecord(dcd -> hwndCnr,
     653                               fullname,
     654                               NULL,
     655                               FALSE,
     656                               FALSE,
     657                               TRUE) &&
     658                !DosFindFirst(fullname,
     659                              &hdir,
     660                              FILE_NORMAL | FILE_DIRECTORY |
     661                              FILE_ARCHIVED | FILE_SYSTEM |
     662                              FILE_HIDDEN | FILE_READONLY,
     663                              &fb4,
     664                              sizeof(fb4),
     665                              &nm,
     666                              FIL_QUERYEASIZE))
     667            {
     668              DosFindClose(hdir);
     669              priority_normal();
     670              *fb4.achName = 0;
     671              ullTotalBytes = FillInRecordFromFFB(dcd -> hwndCnr,
     672                                                  pci,
     673                                                  fullname,
     674                                                  &fb4,
     675                                                  FALSE,
     676                                                  dcd);
     677              dcd -> ullTotalBytes += ullTotalBytes;
     678              pciP = pci;
     679              pci = (PCNRITEM) pci -> rc.preccNextRecord;
     680            }
     681            else
     682            {
     683              pciT = pci;
     684              pci = (PCNRITEM) pci -> rc.preccNextRecord;
     685              if (pciP)
     686                pciP -> rc.preccNextRecord = (PMINIRECORDCORE) pci;
     687              else
     688                pciFirst = pci;
     689              WinSendMsg(hwnd, CM_FREERECORD, MPFROMP(&pciT),
     690                         MPFROM2SHORT(1, 0));
     691              ulMaxFiles--;
     692            }
     693            DosSleep(1L);
     694          }
     695          if (ulMaxFiles)
     696          {
     697            memset(&ri, 0, sizeof(RECORDINSERT));
     698            ri.cb = sizeof(RECORDINSERT);
     699            ri.pRecordOrder = (PRECORDCORE) CMA_END;
     700            ri.pRecordParent = (PRECORDCORE) 0;
     701            ri.zOrder = (ULONG) CMA_TOP;
     702            ri.cRecordsInsert = ulMaxFiles;
     703            ri.fInvalidateRecord = TRUE;
     704            WinSendMsg(dcd -> hwndCnr,
     705                       CM_INSERTRECORD,
     706                       MPFROMP(pciFirst),
     707                       MPFROMP(&ri));
     708            PostMsg(dcd -> hwndCnr,
     709                    UM_RESCAN,
     710                    MPVOID,
     711                    MPVOID);
     712          }
     713        }
     714      }
     715    }
     716    if (dcd -> flWindowAttr & CV_DETAIL)
     717      WinSendDlgItemMsg(hwnd,
     718                        COLLECTOR_CNR,
     719                        CM_INVALIDATERECORD,
     720                        MPVOID,
     721                        MPFROM2SHORT(0,
     722                                     CMA_ERASE | CMA_REPOSITION));
     723    return 0;
     724
     725  case UM_COLLECTFROMFILE:
     726    dcd = WinQueryWindowPtr(hwnd, QWL_USER);
     727    if (dcd && mp1)
     728    {
     729      FILESTATUS4 fs4;
     730      PCNRITEM pci;
     731      RECORDINSERT ri;
     732      CHAR fullname[1024], *p;
     733      FILE *fp;
     734      ULONG errs = 0L;
     735
     736      fp = _fsopen((CHAR *) mp1, "r", SH_DENYNO);
     737      if (fp)
     738      {
     739        while (!feof(fp))
     740        {
     741          if (!fgets(fullname, 1024, fp))
     742            break;
     743          fullname[1023] = 0;
     744          bstripcr(fullname);
     745          if (*fullname == '\"')
     746          {
     747            memmove(fullname, fullname + 1, strlen(fullname) + 1);
     748            lstrip(fullname);
     749            p = strchr(fullname, '\"');
     750            if (p)
     751              *p = 0;
     752            rstrip(fullname);
     753          }
     754          else
     755          {
     756            p = strchr(fullname, ' ');
     757            if (p)
     758              *p = 0;
     759          }
     760          /* fullname now contains name of file to collect */
     761          DosError(FERR_DISABLEHARDERR);
     762          if (IsFullName(fullname) &&
     763              !IsRoot(fullname) &&
     764              !DosQueryPathInfo(fullname,
     765                                FIL_QUERYEASIZE,
     766                                &fs4,
     767                                sizeof(fs4)) &&
     768              !FindCnrRecord(dcd -> hwndCnr,
     769                             fullname,
     770                             NULL,
     771                             FALSE,
     772                             FALSE,
     773                             TRUE))
     774          {
     775            /* collect it */
     776            pci = WinSendMsg(dcd -> hwndCnr,
     777                             CM_ALLOCRECORD,
     778                             MPFROMLONG(EXTRA_RECORD_BYTES),
     779                             MPFROMLONG(1L));
     780            if (pci)
     781            {
     782              dcd -> ullTotalBytes += FillInRecordFromFSA(dcd -> hwndCnr, pci,
     783                                                          fullname,
     784                                                          &fs4, FALSE, dcd);
     785              memset(&ri, 0, sizeof(RECORDINSERT));
     786              ri.cb = sizeof(RECORDINSERT);
     787              ri.pRecordOrder = (PRECORDCORE) CMA_END;
     788              ri.pRecordParent = (PRECORDCORE) 0;
     789              ri.zOrder = (ULONG) CMA_TOP;
     790              ri.cRecordsInsert = 1L;
     791              ri.fInvalidateRecord = TRUE;
     792              WinSendMsg(dcd -> hwndCnr, CM_INSERTRECORD,
     793                         MPFROMP(pci), MPFROMP(&ri));
     794            }
     795          }
     796          else
     797          {
     798            errs++;
     799            if (errs > 50L)
     800            {                           /* prevent runaway on bad file */
     801
     802              APIRET ret;
     803
     804              ret = saymsg(MB_YESNO, dcd -> hwndCnr,
     805                           GetPString(IDS_COLLECTNOLISTHDRTEXT),
     806                           GetPString(IDS_COLLECTNOLISTTEXT),
     807                           (CHAR *) mp1);
     808              if (ret == MBID_NO)
     809                break;
     810              errs = 0L;
     811            }
     812          }
     813        }
     814        fclose(fp);
     815      }
     816    }
     817    if (mp1)
     818      free(mp1);
     819    return 0;
     820
     821  case UM_SELECT:
     822    dcd = WinQueryWindowPtr(hwnd, QWL_USER);
     823    if (dcd)
     824    {
     825      switch (SHORT1FROMMP(mp1))
     826      {
     827      case IDM_SELECTLIST:
     828        {
     829          CHAR filename[CCHMAXPATH], *p, *pp;
     830          ULONG size;
     831
     832          strcpy(filename, "*.LST");
     833          size = CCHMAXPATH;
     834          PrfQueryProfileData(fmprof,
     835                              appname,
     836                              "SaveToListName",
     837                              filename,
     838                              &size);
     839          pp = strrchr(filename, '\\');
     840          if (!pp)
     841            pp = filename;
     842          p = strrchr(pp, '.');
     843          if (p && *(p + 1) && p > pp + 1)
     844          {
     845            if (pp > filename)
     846              pp++;
     847            *pp = '*';
     848            pp++;
     849            if (p > pp)
     850              memmove(pp, p, strlen(p) + 1);
     851          }
     852          if (insert_filename(hwnd, filename, FALSE, FALSE))
     853            SelectList(dcd -> hwndCnr, TRUE, FALSE, FALSE, NULL, filename, NULL);
     854        }
     855        break;
     856      case IDM_SELECTALL:
     857        SelectAll(dcd -> hwndCnr, TRUE, TRUE, NULL, NULL, FALSE);
     858        break;
     859      case IDM_DESELECTALL:
     860        DeselectAll(dcd -> hwndCnr, TRUE, TRUE, NULL, NULL, FALSE);
     861        break;
     862      case IDM_SELECTALLFILES:
     863        SelectAll(dcd -> hwndCnr, TRUE, FALSE, NULL, NULL, FALSE);
     864        break;
     865      case IDM_DESELECTALLFILES:
     866        DeselectAll(dcd -> hwndCnr, TRUE, FALSE, NULL, NULL, FALSE);
     867        break;
     868      case IDM_SELECTALLDIRS:
     869        SelectAll(dcd -> hwndCnr, FALSE, TRUE, NULL, NULL, FALSE);
     870        break;
     871      case IDM_DESELECTALLDIRS:
     872        DeselectAll(dcd -> hwndCnr, FALSE, TRUE, NULL, NULL, FALSE);
     873        break;
     874      case IDM_DESELECTMASK:
     875      case IDM_SELECTMASK:
     876        {
     877          MASK mask;
     878          PCNRITEM pci = (PCNRITEM) mp2;
     879
     880          memset(&mask, 0, sizeof(MASK));
     881          mask.fNoAttribs = TRUE;
     882          mask.fNoDirs = TRUE;
     883          mask.fText = TRUE;
     884          strcpy(mask.prompt,
     885                 GetPString((SHORT1FROMMP(mp1) == IDM_SELECTMASK) ?
     886                            IDS_SELECTFILTERTEXT :
     887                            IDS_DESELECTFILTERTEXT));
     888          if (pci && (INT) pci != -1)
     889            strcpy(mask.szMask, pci -> szFileName);
     890          if (WinDlgBox(HWND_DESKTOP, dcd -> hwndCnr, PickMaskDlgProc,
     891                        FM3ModHandle, MSK_FRAME, MPFROMP(&mask)))
     892          {
     893            if (SHORT1FROMMP(mp1) == IDM_SELECTMASK)
     894              SelectAll(dcd -> hwndCnr, TRUE, TRUE, mask.szMask, mask.szText,
     895                        FALSE);
     896            else
     897              DeselectAll(dcd -> hwndCnr, TRUE, TRUE, mask.szMask, mask.szText,
     898                          FALSE);
     899          }
     900        }
     901
     902      case IDM_DESELECTCLIP:
     903      case IDM_SELECTCLIP:
     904        {
     905          CHAR **list;
     906
     907          list = ListFromClipboard(hwnd);
     908          if (list)
     909          {
     910            SelectList(dcd -> hwndCnr, TRUE, FALSE,
     911                       (SHORT1FROMMP(mp1) == IDM_DESELECTCLIP),
     912                       NULL, NULL, list);
     913            FreeList(list);
     914          }
     915        }
     916        break;
     917
     918      case IDM_INVERT:
     919        InvertAll(dcd -> hwndCnr);
     920        break;
     921      }
     922    }
     923    return 0;
     924
     925  case UM_MASSACTION:
     926    if (mp1)
     927    {
     928      dcd = WinQueryWindowPtr(hwnd, QWL_USER);
     929      if (dcd)
     930      {
     931        WORKER *wk;
     932
     933        wk = malloc(sizeof(WORKER));
     934        if (wk)
     935        {
     936          memset(wk, 0, sizeof(WORKER));
     937          wk -> size = sizeof(WORKER);
     938          wk -> hwndCnr = dcd -> hwndCnr;
     939          wk -> hwndParent = dcd -> hwndParent;
     940          wk -> hwndFrame = dcd -> hwndFrame;
     941          wk -> hwndClient = dcd -> hwndClient;
     942          wk -> li = (LISTINFO *) mp1;
     943          strcpy(wk -> directory, dcd -> directory);
     944          if (_beginthread(MassAction, NULL, 122880, (PVOID) wk) == -1)
     945          {
     946            free(wk);
     947            FreeListInfo((LISTINFO *) mp1);
     948          }
     949        }
     950        else
     951          FreeListInfo((LISTINFO *) mp1);
     952      }
     953    }
     954    return 0;
     955
     956  case UM_ACTION:
     957    if (mp1)
     958    {
     959      dcd = WinQueryWindowPtr(hwnd, QWL_USER);
     960      if (dcd)
     961      {
     962        WORKER *wk;
     963
     964        wk = malloc(sizeof(WORKER));
     965        if (wk)
     966        {
     967          memset(wk, 0, sizeof(WORKER));
     968          wk -> size = sizeof(WORKER);
     969          wk -> hwndCnr = dcd -> hwndCnr;
     970          wk -> hwndParent = dcd -> hwndParent;
     971          wk -> hwndFrame = dcd -> hwndFrame;
     972          wk -> hwndClient = dcd -> hwndClient;
     973          wk -> li = (LISTINFO *) mp1;
     974          strcpy(wk -> directory, dcd -> directory);
     975          if (_beginthread(Action, NULL, 122880, (PVOID) wk) == -1)
     976          {
     977            free(wk);
     978            FreeListInfo((LISTINFO *) mp1);
     979          }
     980        }
     981        else
     982          FreeListInfo((LISTINFO *) mp1);
     983      }
     984    }
     985    return 0;
     986
     987  case WM_CLOSE:
     988    WinDestroyWindow(hwnd);
     989    break;
     990
     991  case WM_DESTROY:
     992    dcd = WinQueryWindowPtr(hwnd, QWL_USER);
     993    if (dcd)
     994    {
     995      INT x = 0;
     996
     997      dcd -> stopflag = 1;
     998      while (x++ < 10 && dcd -> amextracted)
     999        DosSleep(250L);
     1000      WinSendMsg(dcd -> hwndCnr, UM_CLOSE, MPVOID, MPVOID);
     1001      FreeList(dcd -> lastselection);
     1002      free(dcd);
     1003    }
     1004    DosPostEventSem(CompactSem);
     1005    if (!PostMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID))
     1006      WinSendMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID);
     1007    break;
     1008  }
     1009  return WinDefWindowProc(hwnd, msg, mp1, mp2);
     1010}
     1011
     1012MRESULT EXPENTRY CollectorCnrWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
     1013{
     1014  DIRCNRDATA *dcd = WinQueryWindowPtr(hwnd, QWL_USER);
     1015  INT tempsortFlags;
     1016
     1017  switch (msg)
     1018  {
     1019  case DM_PRINTOBJECT:
     1020    return MRFROMLONG(DRR_TARGET);
     1021
     1022  case DM_DISCARDOBJECT:
     1023    if (dcd)
     1024      return WinSendMsg(dcd -> hwndObject, msg, mp1, mp2);
     1025    else
     1026      return MRFROMLONG(DRR_TARGET);
     1027
     1028  case WM_CHAR:
     1029    shiftstate = (SHORT1FROMMP(mp1) & (KC_SHIFT | KC_ALT | KC_CTRL));
     1030    if (SHORT1FROMMP(mp1) & KC_KEYUP)
     1031      return (MRESULT) TRUE;
     1032    if (SHORT1FROMMP(mp1) & KC_VIRTUALKEY)
     1033    {
     1034      switch (SHORT2FROMMP(mp2))
     1035      {
     1036      case VK_DELETE:
     1037        if ((shiftstate & KC_CTRL) == KC_CTRL)
     1038          PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_PERMDELETE, 0), MPVOID);
     1039        else if ((shiftstate & KC_SHIFT) == KC_SHIFT)
     1040          PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_SAVETOCLIP, 0), MPVOID);
     1041        else
     1042          PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_DELETE, 0), MPVOID);
     1043        break;
     1044      }
     1045    }
     1046    if (shiftstate || fNoSearch)
    1801047      break;
    181 
    182     case WM_MENUEND:
    183       if(hwndButtonPopup == (HWND)mp2) {
    184         lastid = WinQueryWindowUShort((HWND)mp2,
    185                                       QWS_ID);
    186         WinDestroyWindow(hwndButtonPopup);
    187         hwndButtonPopup = (HWND)0;
    188         DosQuerySysInfo(QSV_MS_COUNT,
    189                         QSV_MS_COUNT,
    190                         &timestamp,
    191                         sizeof(timestamp));
    192         switch(lastid) {
    193           case DIR_SELECTED:
    194           case DIR_VIEW:
    195           case DIR_SORT:
    196             PaintRecessedWindow(hwnd,
    197                                 (HPS)0,
    198                                 TRUE,
    199                                 FALSE);
    200             break;
    201         }
    202       }
     1048    if (SHORT1FROMMP(mp1) & KC_CHAR)
     1049    {
     1050      ULONG thistime, len;
     1051      SEARCHSTRING srch;
     1052      PCNRITEM pci;
     1053
     1054      if (!dcd)
     1055        break;
     1056      switch (SHORT1FROMMP(mp2))
     1057      {
     1058      case '\x1b':
     1059      case '\r':
     1060      case '\n':
     1061        dcd -> lasttime = 0;
     1062        *dcd -> szCommonName = 0;
     1063        break;
     1064      default:
     1065        thistime = WinQueryMsgTime(WinQueryAnchorBlock(hwnd));
     1066        if (thistime > dcd -> lasttime + 1250)
     1067          *dcd -> szCommonName = 0;
     1068        dcd -> lasttime = thistime;
     1069        if (SHORT1FROMMP(mp2) == ' ' && !dcd -> szCommonName)
     1070          break;
     1071      KbdRetry:
     1072        len = strlen(dcd -> szCommonName);
     1073        if (len >= CCHMAXPATH - 1)
     1074        {
     1075          *dcd -> szCommonName = 0;
     1076          len = 0;
     1077        }
     1078        dcd -> szCommonName[len] = toupper(SHORT1FROMMP(mp2));
     1079        dcd -> szCommonName[len + 1] = 0;
     1080        memset(&srch, 0, sizeof(SEARCHSTRING));
     1081        srch.cb = (ULONG) sizeof(SEARCHSTRING);
     1082        srch.pszSearch = (PSZ) dcd -> szCommonName;
     1083        srch.fsPrefix = TRUE;
     1084        srch.fsCaseSensitive = FALSE;
     1085        srch.usView = CV_ICON;
     1086        pci = WinSendMsg(hwnd, CM_SEARCHSTRING, MPFROMP(&srch),
     1087                         MPFROMLONG(CMA_FIRST));
     1088        if (pci && (INT) pci != -1)
     1089        {
     1090          USHORT attrib = CRA_CURSORED;
     1091
     1092          /* make found item current item */
     1093          if (!stricmp(pci -> pszFileName, dcd -> szCommonName))
     1094            attrib |= CRA_SELECTED;
     1095          WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPFROMP(pci),
     1096                     MPFROM2SHORT(TRUE, attrib));
     1097          /* make sure that record shows in viewport */
     1098          ShowCnrRecord(hwnd, (PMINIRECORDCORE) pci);
     1099          return (MRESULT) TRUE;
     1100        }
     1101        else
     1102        {
     1103          if (SHORT1FROMMP(mp2) == ' ')
     1104          {
     1105            dcd -> szCommonName[len] = 0;
     1106            break;
     1107          }
     1108          *dcd -> szCommonName = 0;
     1109          dcd -> lasttime = 0;
     1110          if (len)                      // retry as first letter if no match
     1111
     1112            goto KbdRetry;
     1113        }
     1114        break;
     1115      }
     1116    }
     1117    break;
     1118
     1119  case WM_MOUSEMOVE:
     1120  case WM_BUTTON1UP:
     1121  case WM_BUTTON2UP:
     1122  case WM_BUTTON3UP:
     1123  case WM_CHORD:
     1124    shiftstate = (SHORT2FROMMP(mp2) & (KC_SHIFT | KC_ALT | KC_CTRL));
     1125    break;
     1126
     1127  case WM_BUTTON1MOTIONEND:
     1128    {
     1129      CNRINFO cnri;
     1130
     1131      memset(&cnri, 0, sizeof(CNRINFO));
     1132      cnri.cb = sizeof(CNRINFO);
     1133      if (WinSendMsg(hwnd, CM_QUERYCNRINFO, MPFROMP(&cnri),
     1134                     MPFROMLONG(sizeof(CNRINFO))))
     1135      {
     1136        if (cnri.flWindowAttr & CV_DETAIL)
     1137          PrfWriteProfileData(fmprof, appname, "CollectorCnrSplitBar",
     1138                              (PVOID) & cnri.xVertSplitbar, sizeof(LONG));
     1139      }
     1140    }
     1141    break;
     1142
     1143  case WM_PRESPARAMCHANGED:
     1144    PresParamChanged(hwnd, "Collector", mp1, mp2);
     1145    break;
     1146
     1147  case UM_COMPARE:
     1148    if (dcd && mp1 && mp2)
     1149    {
     1150      COMPARE *cmp;
     1151      CHAR *leftdir = (CHAR *) mp1, *rightdir = (CHAR *) mp2;
     1152
     1153      if (!IsFile(leftdir) && !IsFile(rightdir))
     1154      {
     1155        cmp = malloc(sizeof(COMPARE));
     1156        if (cmp)
     1157        {
     1158          memset(cmp, 0, sizeof(COMPARE));
     1159          cmp -> size = sizeof(COMPARE);
     1160          strcpy(cmp -> leftdir, leftdir);
     1161          strcpy(cmp -> rightdir, rightdir);
     1162          cmp -> hwndParent = dcd -> hwndParent;
     1163          cmp -> dcd.hwndParent = dcd -> hwndParent;
     1164          WinDlgBox(HWND_DESKTOP, HWND_DESKTOP, CompareDlgProc,
     1165                    FM3ModHandle, COMP_FRAME, MPFROMP(cmp));
     1166        }
     1167      }
     1168    }
     1169    return 0;
     1170
     1171  case UM_UPDATERECORDLIST:
     1172    if (dcd && mp1)
     1173      WinSendMsg(dcd -> hwndObject, msg, mp1, mp2);
     1174    return 0;
     1175
     1176  case UM_UPDATERECORD:
     1177    if (dcd && mp1)
     1178    {
     1179      CHAR *filename;
     1180
     1181      filename = mp1;
     1182      if (filename)
     1183        UpdateCnrRecord(hwnd, filename, TRUE, dcd);
     1184    }
     1185    return 0;
     1186
     1187  case WM_SETFOCUS:
     1188    /*
     1189     * put name of our window on status line
     1190     */
     1191    if (dcd && hwndStatus && mp2)
     1192    {
     1193      PCNRITEM pci = NULL;
     1194
     1195      if (fAutoView && hwndMain)
     1196      {
     1197        pci = WinSendMsg(hwnd,
     1198                         CM_QUERYRECORDEMPHASIS,
     1199                         MPFROMLONG(CMA_FIRST),
     1200                         MPFROMSHORT(CRA_CURSORED));
     1201        if (pci && (INT) pci != -1 &&
     1202            (!(driveflags[toupper(*pci -> szFileName) - 'A'] & DRIVE_SLOW)))
     1203          WinSendMsg(hwndMain,
     1204                     UM_LOADFILE,
     1205                     MPFROMP(pci -> szFileName),
     1206                     MPVOID);
     1207        else
     1208          WinSendMsg(hwndMain,
     1209                     UM_LOADFILE,
     1210                     MPVOID,
     1211                     MPVOID);
     1212      }
     1213      if (dcd -> amextracted)
     1214        WinSetWindowText(hwndStatus2,
     1215                         GetPString(IDS_INSEEKSCANTEXT));
     1216      WinSendMsg(hwnd,
     1217                 UM_RESCAN,
     1218                 MPVOID,
     1219                 MPVOID);
     1220    }
     1221    break;
     1222
     1223  case UM_RESCAN:
     1224    if (dcd)
     1225    {
     1226      CNRINFO cnri;
     1227      CHAR s[CCHMAXPATH + 69], tb[81], tf[81], *p;
     1228      PCNRITEM pci = NULL;
     1229
     1230      memset(&cnri, 0, sizeof(CNRINFO));
     1231      cnri.cb = sizeof(CNRINFO);
     1232      WinSendMsg(hwnd, CM_QUERYCNRINFO, MPFROMP(&cnri),
     1233                 MPFROMLONG(sizeof(CNRINFO)));
     1234      dcd -> totalfiles = cnri.cRecords;
     1235      commafmt(tf, sizeof(tf), dcd -> totalfiles);
     1236      CommaFmtULL(tb, sizeof(tb), dcd -> ullTotalBytes, ' ');
     1237      sprintf(s, "%s / %s", tf, tb);
     1238      WinSetDlgItemText(dcd -> hwndClient, DIR_TOTALS, s);
     1239
     1240      commafmt(tf, sizeof(tf), dcd -> selectedfiles);
     1241      CommaFmtULL(tb, sizeof(tb), dcd -> selectedbytes, ' ');
     1242      sprintf(s, "%s / %s", tf, tb);
     1243      WinSetDlgItemText(dcd -> hwndClient, DIR_SELECTED, s);
     1244
     1245      if (hwndStatus &&
     1246          dcd -> hwndFrame == WinQueryActiveWindow(dcd -> hwndParent))
     1247      {
     1248        if (hwndMain)
     1249        {
     1250          pci = WinSendMsg(hwnd, CM_QUERYRECORDEMPHASIS,
     1251                           MPFROMLONG(CMA_FIRST),
     1252                           MPFROMSHORT(CRA_CURSORED));
     1253          if (pci && (INT) pci != -1)
     1254            PostMsg(hwndMain, UM_LOADFILE, MPFROMP(pci -> szFileName), MPVOID);
     1255          else
     1256            PostMsg(hwndMain, UM_LOADFILE, MPVOID, MPVOID);
     1257        }
     1258        if (!fMoreButtons)
     1259          sprintf(s, " %s%s%s%s", GetPString(IDS_COLLECTORTEXT),
     1260                  (*dcd -> mask.szMask || dcd -> mask.antiattr ||
     1261                   dcd -> mask.attrFile != ALLATTRS) ? "  (" : NullStr,
     1262                  (*dcd -> mask.szMask) ? dcd -> mask.szMask :
     1263                  (dcd -> mask.antiattr ||
     1264                   dcd -> mask.attrFile != ALLATTRS) ?
     1265                  GetPString(IDS_ATTRTEXT) : NullStr,
     1266                  (*dcd -> mask.szMask || dcd -> mask.antiattr ||
     1267                   dcd -> mask.attrFile != ALLATTRS) ? ")" : NullStr);
     1268        else
     1269          strcpy(s, GetPString(IDS_COLLECTORTEXT));
     1270        WinSetWindowText(hwndStatus, s);
     1271        if (!pci)
     1272          pci = WinSendMsg(hwnd, CM_QUERYRECORDEMPHASIS,
     1273                           MPFROMLONG(CMA_FIRST),
     1274                           MPFROMSHORT(CRA_CURSORED));
     1275        if (pci && (INT) pci != -1)
     1276        {
     1277          if (fSplitStatus && hwndStatus2)
     1278          {
     1279            if (pci -> attrFile & FILE_DIRECTORY)
     1280              p = pci -> pszFileName;
     1281            else
     1282            {
     1283              p = strrchr(pci -> szFileName, '\\');
     1284              if (p)
     1285              {
     1286                if (*(p + 1))
     1287                  p++;
     1288                else
     1289                  p = pci -> pszFileName;
     1290              }
     1291              else
     1292                p = pci -> pszFileName;
     1293            }
     1294            CommaFmtULL(tb, sizeof(tb), pci -> cbFile + pci -> easize, ' ');
     1295            if (!fMoreButtons)
     1296            {
     1297              sprintf(s, " %s  %04u/%02u/%02u %02u:%02u:%02u  [%s]  %s",
     1298                      tb, pci -> date.year, pci -> date.month,
     1299                    pci -> date.day, pci -> time.hours, pci -> time.minutes,
     1300                      pci -> time.seconds, pci -> pszDispAttr, p);
     1301            }
     1302            else
     1303            {
     1304              if (pci -> cbFile + pci -> easize > 1024)
     1305                CommaFmtULL(tf, sizeof(tf), pci -> cbFile + pci -> easize, 'K');
     1306              else
     1307                *tf = 0;
     1308              sprintf(s, GetPString(IDS_STATUSSIZETEXT),
     1309                      tb,
     1310                      *tf ? " (" : NullStr,
     1311                      tf,
     1312                      *tf ? ")" : NullStr);
     1313            }
     1314            WinSetWindowText(hwndStatus2, s);
     1315          }
     1316          if (fMoreButtons)
     1317          {
     1318            WinSetWindowText(hwndName, pci -> pszFileName);
     1319            sprintf(s, "%04u/%02u/%02u %02u:%02u:%02u",
     1320                    pci -> date.year, pci -> date.month,
     1321                    pci -> date.day, pci -> time.hours, pci -> time.minutes,
     1322                    pci -> time.seconds);
     1323            WinSetWindowText(hwndDate, s);
     1324            WinSetWindowText(hwndAttr, pci -> pszDispAttr);
     1325          }
     1326          if (dcd -> amextracted && hwndStatus2)
     1327            WinSetWindowText(hwndStatus2, GetPString(IDS_INSEEKSCANTEXT));
     1328        }
     1329        else
     1330        {
     1331          if (hwndStatus2)
     1332            WinSetWindowText(hwndStatus2, NullStr);
     1333          if (fMoreButtons)
     1334          {
     1335            WinSetWindowText(hwndName, NullStr);
     1336            WinSetWindowText(hwndDate, NullStr);
     1337            WinSetWindowText(hwndAttr, NullStr);
     1338          }
     1339        }
     1340      }
     1341    }
     1342    return 0;
     1343
     1344  case UM_CONTAINER_FILLED:
     1345    DosBeep(1000, 50);
     1346    WinSendMsg(hwnd,
     1347               CM_INVALIDATERECORD,
     1348               MPVOID,
     1349               MPFROM2SHORT(0, CMA_ERASE | CMA_REPOSITION));
     1350    WinSendMsg(CollectorCnrMenu,
     1351               MM_SETITEMATTR,
     1352               MPFROM2SHORT(DID_CANCEL, TRUE),
     1353               MPFROM2SHORT(MIA_DISABLED, MIA_DISABLED));
     1354    WinSendMsg(CollectorCnrMenu,
     1355               MM_SETITEMATTR,
     1356               MPFROM2SHORT(IDM_GREP, TRUE),
     1357               MPFROM2SHORT(MIA_DISABLED, 0));
     1358    PostMsg(hwnd,
     1359            UM_RESCAN,
     1360            MPVOID,
     1361            MPVOID);
     1362    if (dcd)
     1363    {
     1364      dcd -> stopflag = 0;
     1365      dcd -> amextracted = FALSE;
     1366      if (dcd -> namecanchange)
     1367      {
     1368        if (!PostMsg(hwnd,
     1369                     WM_CLOSE,
     1370                     MPVOID,
     1371                     MPVOID))
     1372          WinSendMsg(hwnd,
     1373                     WM_CLOSE,
     1374                     MPVOID,
     1375                     MPVOID);
     1376      }
     1377      else
     1378        WinSetWindowPos(WinQueryWindow(WinQueryWindow(hwnd, QW_PARENT),
     1379                                       QW_PARENT),
     1380                        HWND_TOP,
     1381                        0,
     1382                        0,
     1383                        0,
     1384                        0,
     1385                        SWP_SHOW | SWP_RESTORE | SWP_ZORDER);
     1386    }
     1387    return 0;
     1388
     1389  case UM_SETUP:
     1390    if (dcd)
     1391    {
     1392      if (!dcd -> hwndObject)
     1393      {
     1394        /*
     1395         * first time through -- set things up
     1396         */
     1397
     1398        CNRINFO cnri;
     1399
     1400        RestorePresParams(hwnd, "Collector");
     1401        LoadDetailsSwitches("Collector", dcd);
     1402        WinSendMsg(CollectorCnrMenu, MM_SETITEMATTR,
     1403                   MPFROM2SHORT(DID_CANCEL, TRUE),
     1404                   MPFROM2SHORT(MIA_DISABLED, MIA_DISABLED));
     1405        WinSendMsg(CollectorCnrMenu, MM_SETITEMATTR, MPFROM2SHORT(IDM_GREP, TRUE),
     1406                   MPFROM2SHORT(MIA_DISABLED, 0));
     1407        dcd -> amextracted = FALSE;
     1408        dcd -> stopflag = 0;
     1409        memset(&cnri, 0, sizeof(CNRINFO));
     1410        cnri.cb = sizeof(CNRINFO);
     1411        WinSendMsg(hwnd, CM_QUERYCNRINFO, MPFROMP(&cnri),
     1412                   MPFROMLONG(sizeof(CNRINFO)));
     1413        cnri.cyLineSpacing = 0;
     1414        cnri.cxTreeIndent = 12L;
     1415
     1416        cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT |
     1417                                CV_DETAIL));
     1418        cnri.flWindowAttr |= (CV_NAME | CA_DETAILSVIEWTITLES |
     1419                              CV_MINI | CV_FLOW);
     1420        cnri.pSortRecord = (PVOID) SortCollectorCnr;
     1421
     1422        {
     1423          ULONG size = sizeof(ULONG);
     1424
     1425          PrfQueryProfileData(fmprof, appname, "CollectorflWindowAttr",
     1426                              (PVOID) & cnri.flWindowAttr, &size);
     1427          size = sizeof(MASK);
     1428          if (PrfQueryProfileSize(fmprof, appname, "CollectorFilter", &size) &&
     1429              size)
     1430          {
     1431            PrfQueryProfileData(fmprof, appname, "CollectorFilter", &dcd -> mask,
     1432                                &size);
     1433            SetMask(dcd -> mask.szMask, &dcd -> mask);
     1434          }
     1435          else
     1436          {
     1437            dcd -> mask.attrFile = (FILE_NORMAL | FILE_READONLY |
     1438                                    FILE_DIRECTORY | FILE_HIDDEN |
     1439                                    FILE_SYSTEM | FILE_ARCHIVED);
     1440            dcd -> mask.antiattr = 0;
     1441          }
     1442          *(dcd -> mask.prompt) = 0;
     1443        }
     1444        cnri.flWindowAttr |= CV_FLOW;
     1445        cnri.flWindowAttr &= (~(CA_MIXEDTARGETEMPH | CA_ORDEREDTARGETEMPH));
     1446        dcd -> flWindowAttr = cnri.flWindowAttr;
     1447        WinSendMsg(hwnd, CM_SETCNRINFO, MPFROMP(&cnri),
     1448                   MPFROMLONG(CMA_FLWINDOWATTR | CMA_LINESPACING |
     1449                              CMA_CXTREEINDENT | CMA_PSORTRECORD));
     1450        SetCnrCols(hwnd, FALSE);
     1451        AdjustCnrColsForPref(hwnd, NULL, dcd, FALSE);
     1452        {                               /* fix splitbar for collector container */
     1453          ULONG size;
     1454
     1455          cnri.xVertSplitbar = DIR_SPLITBAR_OFFSET - 32;
     1456          size = sizeof(LONG);
     1457          PrfQueryProfileData(fmprof, appname, "CollectorCnrSplitBar",
     1458                              &cnri.xVertSplitbar, &size);
     1459          if (cnri.xVertSplitbar <= 0)
     1460            cnri.xVertSplitbar = DIR_SPLITBAR_OFFSET - 32;
     1461          WinSendMsg(hwnd, CM_SETCNRINFO, MPFROMP(&cnri),
     1462                     MPFROMLONG(CMA_XVERTSPLITBAR));
     1463        }
     1464        if (_beginthread(MakeObjWin, NULL, 245760, (PVOID) dcd) == -1)
     1465        {
     1466          PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
     1467          return 0;
     1468        }
     1469        else
     1470          DosSleep(64L);
     1471      }
     1472      SayFilter(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
     1473                                DIR_FILTER), &dcd -> mask, FALSE);
     1474      SaySort(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
     1475                              DIR_SORT), CollectorsortFlags, FALSE);
     1476      SayView(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
     1477                              DIR_VIEW), dcd -> flWindowAttr);
     1478    }
     1479    else
     1480    {
     1481      PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
     1482      return 0;
     1483    }
     1484    return 0;
     1485
     1486  case WM_MENUEND:
     1487    if (dcd)
     1488    {
     1489      HWND hwndMenu = (HWND) mp2;
     1490
     1491      if (hwndMenu == CollectorCnrMenu || hwndMenu == CollectorFileMenu ||
     1492          hwndMenu == CollectorDirMenu)
     1493      {
     1494        MarkAll(hwnd, TRUE, FALSE, TRUE);
     1495        if (dcd -> cnremphasized)
     1496        {
     1497          WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPVOID,
     1498                     MPFROM2SHORT(FALSE, CRA_SOURCE));
     1499          dcd -> cnremphasized = FALSE;
     1500        }
     1501      }
     1502    }
     1503    break;
     1504
     1505  case UM_OPENWINDOWFORME:
     1506    if (dcd)
     1507    {
     1508      if (mp1 &&
     1509          !IsFile((CHAR *) mp1))
     1510        OpenDirCnr((HWND) 0,
     1511                   hwndMain,
     1512                   dcd -> hwndFrame,
     1513                   FALSE,
     1514                   (char *) mp1);
     1515      else if (mp1 &&
     1516               IsFile(mp1) == 1)
     1517        StartArcCnr(HWND_DESKTOP,
     1518                    dcd -> hwndFrame,
     1519                    (CHAR *) mp1,
     1520                    4,
     1521                    (ARC_TYPE *) mp2);
     1522    }
     1523    return 0;
     1524
     1525  case MM_PORTHOLEINIT:
     1526    if (dcd)
     1527    {
     1528      switch (SHORT1FROMMP(mp1))
     1529      {
     1530      case 0:
     1531      case 1:
     1532        {
     1533          ULONG wmsg;
     1534
     1535          wmsg = (SHORT1FROMMP(mp1) == 0) ? UM_FILESMENU : UM_VIEWSMENU;
     1536          PortholeInit((HWND) WinSendMsg(dcd -> hwndClient, wmsg, MPVOID,
     1537                                         MPVOID), mp1, mp2);
     1538        }
     1539        break;
     1540      }
     1541    }
     1542    break;
     1543
     1544  case UM_INITMENU:
     1545  case WM_INITMENU:
     1546    if (dcd)
     1547    {
     1548      switch (SHORT1FROMMP(mp1))
     1549      {
     1550      case IDM_VIEWSMENU:
     1551        SetViewMenu((HWND) mp2, dcd -> flWindowAttr);
     1552        WinEnableMenuItem((HWND) mp2, IDM_RESELECT,
     1553                          (dcd -> lastselection != NULL));
     1554        break;
     1555
     1556      case IDM_DETAILSSETUP:
     1557        SetDetailsSwitches((HWND) mp2, dcd);
     1558        break;
     1559
     1560      case IDM_COMMANDSMENU:
     1561        SetupCommandMenu((HWND) mp2, hwnd);
     1562        break;
     1563
     1564      case IDM_SORTSUBMENU:
     1565        SetSortChecks((HWND) mp2, CollectorsortFlags);
     1566        break;
     1567      }
     1568      dcd -> hwndLastMenu = (HWND) mp2;
     1569    }
     1570    if (msg == WM_INITMENU)
    2031571      break;
    204 
    205     case WM_COMMAND:
    206       {
    207         DIRCNRDATA *dcd;
    208         MRESULT     mr;
    209 
    210         mr = WinSendMsg(WinWindowFromID(WinQueryWindow(hwnd,
    211                                                        QW_PARENT),
    212                         COLLECTOR_CNR),
    213                         msg,
    214                         mp1,
    215                         mp2);
    216         if(hwndButtonPopup &&
    217            SHORT1FROMMP(mp1) > IDM_DETAILSTITLES &&
    218            SHORT1FROMMP(mp1) < IDM_DETAILSSETUP) {
    219           dcd = WinQueryWindowPtr(WinWindowFromID(WinQueryWindow(hwnd,
    220                                                   QW_PARENT),
    221                                                   COLLECTOR_CNR),
    222                                   QWL_USER);
    223           if(dcd)
    224             SetDetailsSwitches(hwndButtonPopup,
    225                                dcd);
    226         }
    227         return mr;
    228       }
    229 
    230     case WM_MOUSEMOVE:
    231       {
    232         USHORT id   = WinQueryWindowUShort(hwnd,QWS_ID);
    233         char  *s    = NULL;
    234 
    235         if(fOtherHelp) {
    236           if((!hwndBubble ||
    237               WinQueryWindowULong(hwndBubble,QWL_USER) != hwnd) &&
    238              !WinQueryCapture(HWND_DESKTOP)) {
    239             switch(id) {
    240               case DIR_SELECTED:
    241                 s = GetPString(IDS_COLSELECTEDHELP);
    242                 break;
    243               case DIR_TOTALS:
    244                 s = GetPString(IDS_COLTOTALSHELP);
    245                 break;
    246               case DIR_VIEW:
    247                 s = GetPString(IDS_DIRCNRVIEWHELP);
    248                 break;
    249               case DIR_SORT:
    250                 s = GetPString(IDS_DIRCNRSORTHELP);
    251                 break;
    252               case DIR_FILTER:
    253                 s = GetPString(IDS_DIRCNRFILTERHELP);
    254                 break;
    255               default:
    256                 break;
    257             }
    258             if(s)
    259               MakeBubble(hwnd,TRUE,s);
    260             else if(hwndBubble)
    261               WinDestroyWindow(hwndBubble);
    262           }
    263         }
    264         switch(id) {
    265           case DIR_FILTER:
    266           case DIR_SORT:
    267           case DIR_VIEW:
    268           case DIR_SELECTED:
    269             return CommonTextButton(hwnd,msg,mp1,mp2);
    270         }
    271       }
    272       break;
    273 
    274     case WM_BUTTON3UP:
    275     case WM_BUTTON1UP:
    276     case WM_BUTTON3DOWN:
    277     case WM_BUTTON1DOWN:
    278       {
    279         USHORT id;
    280 
    281         id = WinQueryWindowUShort(hwnd,
    282                                   QWS_ID);
    283         switch(id) {
    284           case DIR_FILTER:
    285           case DIR_SORT:
    286           case DIR_VIEW:
    287           case DIR_SELECTED:
    288             return CommonTextButton(hwnd,msg,mp1,mp2);
    289         }
    290       }
    291       break;
    292 
    293     case UM_CLICKED:
    294     case UM_CLICKED3:
    295       {
    296         USHORT id,cmd = 0;
    297 
    298         id = WinQueryWindowUShort(hwnd,
    299                                   QWS_ID);
    300         switch(id) {
    301           case DIR_VIEW:
    302           case DIR_SORT:
    303           case DIR_SELECTED:
    304             PostMsg(hwnd,
    305                     UM_CONTEXTMENU,
    306                     MPVOID,
    307                     MPVOID);
    308             break;
    309           case DIR_FILTER:
    310             cmd = IDM_FILTER;
    311             break;
    312           default:
    313             break;
    314         }
    315         if(cmd)
    316           PostMsg(WinWindowFromID(WinQueryWindow(hwnd,
    317                                                  QW_PARENT),
    318                                   COLLECTOR_CNR),
    319                   WM_COMMAND,
    320                   MPFROM2SHORT(cmd,0),
    321                   MPVOID);
    322       }
    323       return 0;
    324 
    325     case DM_DROP:
    326     case DM_DRAGOVER:
    327     case DM_DRAGLEAVE:
    328     case DM_DROPHELP:
    329       if(msg == DM_DRAGOVER) {
    330         if(!emphasized) {
    331           emphasized = TRUE;
    332           DrawTargetEmphasis(hwnd,emphasized);
    333         }
    334       }
    335       else {
    336         if(emphasized) {
    337           emphasized = FALSE;
    338           DrawTargetEmphasis(hwnd,emphasized);
    339         }
    340       }
    341       {
    342         CNRDRAGINFO cnd;
    343         USHORT      dcmd;
    344 
    345         switch(msg) {
    346           case DM_DROP:
    347             dcmd = CN_DROP;
    348             break;
    349           case DM_DRAGOVER:
    350             dcmd = CN_DRAGOVER;
    351             break;
    352           case DM_DRAGLEAVE:
    353             dcmd = CN_DRAGLEAVE;
    354             break;
    355           case DM_DROPHELP:
    356             dcmd = CN_DROPHELP;
    357             break;
    358         }
    359         memset(&cnd,0,sizeof(cnd));
    360         cnd.pDragInfo = (PDRAGINFO)mp1;
    361         cnd.pRecord = NULL;
    362         return WinSendMsg(WinQueryWindow(hwnd,QW_PARENT),WM_CONTROL,
    363                           MPFROM2SHORT(COLLECTOR_CNR,dcmd),MPFROMP(&cnd));
    364       }
     1572    return 0;
     1573
     1574  case UM_COLLECTFROMFILE:
     1575    if (mp1)
     1576    {
     1577      if (dcd)
     1578      {
     1579        if (!PostMsg(dcd -> hwndObject, UM_COLLECTFROMFILE, mp1, mp2))
     1580        {
     1581          free(mp1);
     1582          DosBeep(50, 100);
     1583        }
     1584      }
     1585      else
     1586        free(mp1);
     1587    }
     1588    else
     1589      free(mp1);
     1590    return 0;
     1591
     1592  case UM_COMMAND:
     1593    if (mp1)
     1594    {
     1595      if (dcd)
     1596      {
     1597        if (!PostMsg(dcd -> hwndObject, UM_COMMAND, mp1, mp2))
     1598        {
     1599          FreeListInfo((LISTINFO *) mp1);
     1600          DosBeep(50, 100);
     1601        }
     1602        else
     1603          return (MRESULT) TRUE;
     1604      }
     1605      else
     1606        FreeListInfo((LISTINFO *) mp1);
     1607    }
     1608    return 0;
     1609
     1610  case UM_NOTIFY:
     1611    if (mp2)
     1612      AddNote((CHAR *) mp2);
     1613    return 0;
     1614
     1615  case WM_COMMAND:
     1616    DosError(FERR_DISABLEHARDERR);
     1617    if (dcd)
     1618    {
     1619      switch (SHORT1FROMMP(mp1))
     1620      {
     1621      case IDM_SETTARGET:
     1622        SetTargetDir(hwnd, FALSE);
     1623        break;
     1624
     1625      case IDM_CONTEXTMENU:
     1626        {
     1627          PCNRITEM pci;
     1628
     1629          pci = (PCNRITEM) CurrentRecord(hwnd);
     1630          PostMsg(hwnd, WM_CONTROL, MPFROM2SHORT(COLLECTOR_CNR,
     1631                                             CN_CONTEXTMENU), MPFROMP(pci));
     1632        }
     1633        break;
     1634
     1635      case IDM_SHOWALLFILES:
     1636        {
     1637          PCNRITEM pci;
     1638
     1639          pci = WinSendMsg(hwnd, CM_QUERYRECORDEMPHASIS,
     1640                           MPFROMLONG(CMA_FIRST),
     1641                           MPFROMSHORT(CRA_CURSORED));
     1642          if (pci && (INT) pci != -1)
     1643          {
     1644            static CHAR dirname[CCHMAXPATH];
     1645
     1646            strcpy(dirname, pci -> szFileName);
     1647            MakeValidDir(dirname);
     1648            StartSeeAll(HWND_DESKTOP, FALSE, dirname);
     1649          }
     1650        }
     1651        break;
     1652
     1653      case IDM_BEGINEDIT:
     1654        OpenEdit(hwnd);
     1655        break;
     1656
     1657      case IDM_ENDEDIT:
     1658        WinSendMsg(hwnd, CM_CLOSEEDIT, MPVOID, MPVOID);
     1659        break;
     1660
     1661      case IDM_SHOWSELECT:
     1662        QuickPopup(hwnd, dcd, CheckMenu(&CollectorCnrMenu, COLLECTORCNR_POPUP),
     1663                   IDM_SELECTSUBMENU);
     1664        break;
     1665
     1666      case IDM_SHOWSORT:
     1667        QuickPopup(hwnd, dcd, CheckMenu(&CollectorCnrMenu, COLLECTORCNR_POPUP),
     1668                   IDM_SORTSUBMENU);
     1669        break;
     1670
     1671      case IDM_VIEWORARC:
     1672        {
     1673          SWP swp;
     1674          PCNRITEM pci;
     1675
     1676          pci = (PCNRITEM) WinSendMsg(hwnd, CM_QUERYRECORDEMPHASIS,
     1677                                      MPFROMLONG(CMA_FIRST),
     1678                                      MPFROMSHORT(CRA_CURSORED));
     1679          if (pci && (INT) pci != -1)
     1680          {
     1681            WinQueryWindowPos(dcd -> hwndFrame, &swp);
     1682            DefaultViewKeys(hwnd, dcd -> hwndFrame, dcd -> hwndParent, &swp,
     1683                            pci -> szFileName);
     1684          }
     1685        }
     1686        break;
     1687
     1688      case IDM_SEEALL:
     1689        StartSeeAll(HWND_DESKTOP,
     1690                    FALSE,
     1691                    NULL);
     1692        break;
     1693
     1694      case IDM_COLLECTSELECT:
     1695        {
     1696          CHAR filename[CCHMAXPATH], *p, *pp;
     1697          ULONG size;
     1698
     1699          strcpy(filename, "*.LST");
     1700          size = CCHMAXPATH;
     1701          PrfQueryProfileData(fmprof, appname, "SaveToListName",
     1702                              filename, &size);
     1703          pp = strrchr(filename, '\\');
     1704          if (!pp)
     1705            pp = filename;
     1706          p = strrchr(pp, '.');
     1707          if (p && *(p + 1) && p > pp + 1)
     1708          {
     1709            if (pp > filename)
     1710              pp++;
     1711            *pp = '*';
     1712            pp++;
     1713            if (p > pp)
     1714              memmove(pp, p, strlen(p) + 1);
     1715          }
     1716          if (insert_filename(hwnd, filename, FALSE, FALSE))
     1717          {
     1718            p = strdup(filename);
     1719            if (p)
     1720            {
     1721              if (!PostMsg(hwnd, UM_COLLECTFROMFILE, MPFROMP(p), MPVOID))
     1722                free(p);
     1723            }
     1724          }
     1725        }
     1726        break;
     1727
     1728      case IDM_NOTEBOOK:
     1729        if (!ParentIsDesktop(dcd -> hwndParent, dcd -> hwndParent))
     1730          PostMsg(dcd -> hwndParent, msg, mp1, mp2);
     1731        else
     1732          WinDlgBox(HWND_DESKTOP, hwnd, CfgDlgProc, FM3ModHandle,
     1733                    CFG_FRAME, (PVOID) "Collector");
     1734        break;
     1735
     1736      case IDM_RESELECT:
     1737        SelectList(hwnd, FALSE, FALSE, FALSE, NULL, NULL, dcd -> lastselection);
     1738        break;
     1739
     1740      case IDM_HELP:
     1741        if (hwndHelp)
     1742          WinSendMsg(hwndHelp, HM_DISPLAY_HELP,
     1743                     MPFROM2SHORT(HELP_COLLECT, 0),
     1744                     MPFROMSHORT(HM_RESOURCEID));
     1745        break;
     1746
     1747      case IDM_SORTNONE:
     1748      case IDM_SORTSMARTNAME:
     1749      case IDM_SORTNAME:
     1750      case IDM_SORTFILENAME:
     1751      case IDM_SORTSIZE:
     1752      case IDM_SORTEASIZE:
     1753      case IDM_SORTFIRST:
     1754      case IDM_SORTLAST:
     1755      case IDM_SORTLWDATE:
     1756      case IDM_SORTLADATE:
     1757      case IDM_SORTCRDATE:
     1758      case IDM_SORTSUBJECT:
     1759        tempsortFlags = CollectorsortFlags;
     1760        CollectorsortFlags &= (SORT_REVERSE | SORT_DIRSFIRST | SORT_DIRSLAST);
     1761      case IDM_SORTDIRSFIRST:
     1762      case IDM_SORTDIRSLAST:
     1763      case IDM_SORTREVERSE:
     1764        switch (SHORT1FROMMP(mp1))
     1765        {
     1766        case IDM_SORTSUBJECT:
     1767          CollectorsortFlags |= SORT_SUBJECT;
     1768          break;
     1769        case IDM_SORTNONE:
     1770          CollectorsortFlags |= SORT_NOSORT;
     1771          break;
     1772        case IDM_SORTSMARTNAME:
     1773          if (!(tempsortFlags & SORT_FILENAME))
     1774            CollectorsortFlags |= SORT_FILENAME;
     1775          break;
     1776        case IDM_SORTFILENAME:
     1777          CollectorsortFlags |= SORT_FILENAME;
     1778          break;
     1779        case IDM_SORTSIZE:
     1780          CollectorsortFlags |= SORT_SIZE;
     1781          break;
     1782        case IDM_SORTEASIZE:
     1783          CollectorsortFlags |= SORT_EASIZE;
     1784          break;
     1785        case IDM_SORTFIRST:
     1786          CollectorsortFlags |= SORT_FIRSTEXTENSION;
     1787          break;
     1788        case IDM_SORTLAST:
     1789          CollectorsortFlags |= SORT_LASTEXTENSION;
     1790          break;
     1791        case IDM_SORTLWDATE:
     1792          CollectorsortFlags |= SORT_LWDATE;
     1793          break;
     1794        case IDM_SORTLADATE:
     1795          CollectorsortFlags |= SORT_LADATE;
     1796          break;
     1797        case IDM_SORTCRDATE:
     1798          CollectorsortFlags |= SORT_CRDATE;
     1799          break;
     1800        case IDM_SORTDIRSFIRST:
     1801          if (CollectorsortFlags & SORT_DIRSFIRST)
     1802            CollectorsortFlags &= (~SORT_DIRSFIRST);
     1803          else
     1804          {
     1805            CollectorsortFlags |= SORT_DIRSFIRST;
     1806            CollectorsortFlags &= (~SORT_DIRSLAST);
     1807          }
     1808          break;
     1809        case IDM_SORTDIRSLAST:
     1810          if (CollectorsortFlags & SORT_DIRSLAST)
     1811            CollectorsortFlags &= (~SORT_DIRSLAST);
     1812          else
     1813          {
     1814            CollectorsortFlags |= SORT_DIRSLAST;
     1815            CollectorsortFlags &= (~SORT_DIRSFIRST);
     1816          }
     1817          break;
     1818        case IDM_SORTREVERSE:
     1819          if (CollectorsortFlags & SORT_REVERSE)
     1820            CollectorsortFlags &= (~SORT_REVERSE);
     1821          else
     1822            CollectorsortFlags |= SORT_REVERSE;
     1823          break;
     1824        }
     1825        PrfWriteProfileData(fmprof, appname, "CollectorSort",
     1826                            &CollectorsortFlags, sizeof(INT));
     1827        WinSendMsg(hwnd, CM_SORTRECORD, MPFROMP(SortCollectorCnr), MPVOID);
     1828        SaySort(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
     1829                                DIR_SORT), CollectorsortFlags, FALSE);
     1830        break;
     1831
     1832      case IDM_COLLECTFROMCLIP:
     1833        {
     1834          LISTINFO *li;
     1835
     1836          li = malloc(sizeof(LISTINFO));
     1837          if (li)
     1838          {
     1839            memset(li, 0, sizeof(LISTINFO));
     1840            li -> list = ListFromClipboard(hwnd);
     1841            if (!li -> list || !li -> list[0])
     1842              FreeListInfo(li);
     1843            else
     1844            {
     1845              li -> type = IDM_COLLECT;
     1846              if (!PostMsg(dcd -> hwndObject, UM_COLLECT, MPFROMP(li),
     1847                           MPVOID))
     1848                FreeListInfo(li);
     1849            }
     1850          }
     1851        }
     1852        break;
     1853
     1854      case IDM_REMOVE:
     1855        if (fAutoView &&
     1856            hwndMain)
     1857          PostMsg(hwndMain,
     1858                  UM_LOADFILE,
     1859                  MPVOID,
     1860                  MPVOID);
     1861        dcd -> suspendview = 1;
     1862        RemoveAll(hwnd,
     1863                  &dcd -> ullTotalBytes,
     1864                  &dcd -> totalfiles);
     1865        dcd -> suspendview = 0;
     1866        PostMsg(hwnd,
     1867                UM_RESCAN,
     1868                MPVOID,
     1869                MPVOID);
     1870        break;
     1871
     1872      case IDM_CLEARCNR:
     1873        {
     1874          PCNRITEM pci;
     1875
     1876          pci = (PCNRITEM) WinSendMsg(hwnd,
     1877                                      CM_QUERYRECORD,
     1878                                      MPVOID,
     1879                                      MPFROM2SHORT(CMA_FIRST,
     1880                                                   CMA_ITEMORDER));
     1881          if (pci && (INT) pci != -1)
     1882          {
     1883            WinSendMsg(hwnd,
     1884                       CM_REMOVERECORD,
     1885                       MPVOID,
     1886                       MPFROM2SHORT(0, CMA_FREE | CMA_INVALIDATE));
     1887            dcd -> ullTotalBytes = dcd -> selectedbytes = dcd -> selectedfiles =
     1888              dcd -> totalfiles = 0L;
     1889            PostMsg(hwnd,
     1890                    UM_RESCAN,
     1891                    MPVOID,
     1892                    MPVOID);
     1893          }
     1894        }
     1895        break;
     1896
     1897      case DID_CANCEL:
     1898        if (dcd -> amextracted)
     1899          dcd -> stopflag = 1;
     1900        break;
     1901
     1902      case IDM_COLLECTOR:
     1903        if (mp2)
     1904        {
     1905          LISTINFO *li;
     1906
     1907          li = malloc(sizeof(LISTINFO));
     1908          if (li)
     1909          {
     1910            memset(li, 0, sizeof(LISTINFO));
     1911            li -> list = mp2;
     1912            if (!li -> list || !li -> list[0])
     1913              FreeListInfo(li);
     1914            else
     1915            {
     1916              li -> type = IDM_COLLECT;
     1917              if (!PostMsg(dcd -> hwndObject, UM_COLLECT, MPFROMP(li),
     1918                           MPVOID))
     1919                FreeListInfo(li);
     1920            }
     1921          }
     1922          else
     1923            FreeList(mp2);
     1924        }
     1925        break;
     1926
     1927      case IDM_UNDELETE:
     1928        {
     1929          PCNRITEM pci;
     1930          CHAR path[CCHMAXPATH];
     1931
     1932          pci = (PCNRITEM) CurrentRecord(hwnd);
     1933          if (pci)
     1934          {
     1935            strcpy(path, pci -> szFileName);
     1936            MakeValidDir(path);
     1937            WinDlgBox(HWND_DESKTOP, hwnd, UndeleteDlgProc, FM3ModHandle,
     1938                      UNDEL_FRAME, MPFROMP(path));
     1939          }
     1940        }
     1941        break;
     1942
     1943      case IDM_GREP:
     1944        if (!dcd -> amextracted)
     1945        {
     1946          if (WinDlgBox(HWND_DESKTOP, hwnd, GrepDlgProc,
     1947                        FM3ModHandle, GREP_FRAME, (PVOID) & hwnd))
     1948          {
     1949            dcd -> amextracted = TRUE;
     1950            WinSendMsg(CollectorCnrMenu, MM_SETITEMATTR,
     1951                       MPFROM2SHORT(DID_CANCEL, TRUE),
     1952                       MPFROM2SHORT(MIA_DISABLED, 0));
     1953            WinSendMsg(CollectorCnrMenu, MM_SETITEMATTR,
     1954                       MPFROM2SHORT(IDM_GREP, TRUE),
     1955                       MPFROM2SHORT(MIA_DISABLED, MIA_DISABLED));
     1956            PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
     1957          }
     1958        }
     1959        else
     1960          DosBeep(50, 100);
     1961        break;
     1962
     1963      case IDM_RESORT:
     1964        WinSendMsg(hwnd, CM_SORTRECORD, MPFROMP(SortCollectorCnr), MPVOID);
     1965        break;
     1966
     1967      case IDM_FILTER:
     1968        {
     1969          BOOL empty = FALSE;
     1970          PCNRITEM pci;
     1971          CHAR *p;
     1972
     1973          if (!*dcd -> mask.szMask)
     1974          {
     1975            empty = TRUE;
     1976            pci = (PCNRITEM) CurrentRecord(hwnd);
     1977            if (pci && !(pci -> attrFile & FILE_DIRECTORY))
     1978            {
     1979              p = strrchr(pci -> szFileName, '\\');
     1980              if (p)
     1981              {
     1982                p++;
     1983                strcpy(dcd -> mask.szMask, p);
     1984              }
     1985            }
     1986          }
     1987          *(dcd -> mask.prompt) = 0;
     1988
     1989          if (WinDlgBox(HWND_DESKTOP, hwnd, PickMaskDlgProc,
     1990                        FM3ModHandle, MSK_FRAME, MPFROMP(&dcd -> mask)))
     1991          {
     1992            PrfWriteProfileData(fmprof, appname, "CollectorFilter", &dcd -> mask,
     1993                                sizeof(MASK));
     1994            dcd -> suspendview = 1;
     1995            WinSendMsg(hwnd, CM_FILTER, MPFROMP(Filter), MPFROMP(&dcd -> mask));
     1996            dcd -> suspendview = 0;
     1997            if (fAutoView && hwndMain)
     1998            {
     1999              pci = WinSendMsg(hwnd, CM_QUERYRECORDEMPHASIS,
     2000                               MPFROMLONG(CMA_FIRST),
     2001                               MPFROMSHORT(CRA_CURSORED));
     2002              if (pci && (INT) pci != -1 &&
     2003                  (!(driveflags[toupper(*pci -> szFileName) - 'A'] & DRIVE_SLOW)))
     2004                WinSendMsg(hwndMain, UM_LOADFILE, MPFROMP(pci -> szFileName),
     2005                           MPVOID);
     2006              else
     2007                WinSendMsg(hwndMain, UM_LOADFILE, MPVOID, MPVOID);
     2008            }
     2009            PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
     2010          }
     2011          else if (empty)
     2012            *dcd -> mask.szMask = 0;
     2013          SayFilter(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
     2014                                    DIR_FILTER), &dcd -> mask, FALSE);
     2015        }
     2016        break;
     2017
     2018      case IDM_HIDEALL:
     2019        if (fAutoView && hwndMain)
     2020          PostMsg(hwndMain, UM_LOADFILE, MPVOID, MPVOID);
     2021        dcd -> suspendview = 1;
     2022        HideAll(hwnd);
     2023        dcd -> suspendview = 0;
     2024        PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
     2025        break;
     2026
     2027      case IDM_SELECTLIST:
     2028      case IDM_SELECTALL:
     2029      case IDM_DESELECTALL:
     2030      case IDM_SELECTALLFILES:
     2031      case IDM_DESELECTALLFILES:
     2032      case IDM_SELECTALLDIRS:
     2033      case IDM_DESELECTALLDIRS:
     2034      case IDM_SELECTMASK:
     2035      case IDM_DESELECTMASK:
     2036      case IDM_INVERT:
     2037      case IDM_SELECTCLIP:
     2038      case IDM_DESELECTCLIP:
     2039        {
     2040          PCNRITEM pci;
     2041
     2042          pci = (PCNRITEM) CurrentRecord(hwnd);
     2043          if ((INT) pci == -1)
     2044            pci = NULL;
     2045          if (SHORT1FROMMP(mp1) == IDM_HIDEALL)
     2046          {
     2047            if (pci)
     2048            {
     2049              if (!(pci -> rc.flRecordAttr & CRA_SELECTED))
     2050                pci -> rc.flRecordAttr |= CRA_FILTERED;
     2051              WinSendMsg(hwnd, CM_INVALIDATERECORD, MPFROMP(&pci),
     2052                         MPFROM2SHORT(1, CMA_ERASE | CMA_REPOSITION));
     2053              break;
     2054            }
     2055          }
     2056          PostMsg(dcd -> hwndObject, UM_SELECT, mp1, MPFROMP(pci));
     2057        }
     2058        break;
     2059
     2060      case IDM_RESCAN:
     2061        PostMsg(dcd -> hwndObject, UM_RESCAN, MPVOID, MPVOID);
     2062        break;
     2063
     2064      case IDM_SHOWLNAMES:
     2065      case IDM_SHOWSUBJECT:
     2066      case IDM_SHOWEAS:
     2067      case IDM_SHOWSIZE:
     2068      case IDM_SHOWICON:
     2069      case IDM_SHOWLWDATE:
     2070      case IDM_SHOWLWTIME:
     2071      case IDM_SHOWLADATE:
     2072      case IDM_SHOWLATIME:
     2073      case IDM_SHOWCRDATE:
     2074      case IDM_SHOWCRTIME:
     2075      case IDM_SHOWATTR:
     2076        AdjustDetailsSwitches(hwnd, dcd -> hwndLastMenu,
     2077                              SHORT1FROMMP(mp1), NULL,
     2078                              "Collector", dcd, FALSE);
     2079        break;
     2080
     2081      case IDM_ICON:
     2082      case IDM_TEXT:
     2083      case IDM_DETAILS:
     2084      case IDM_NAME:
     2085      case IDM_MINIICONS:
     2086      case IDM_DETAILSTITLES:
     2087        {
     2088          CNRINFO cnri;
     2089
     2090          memset(&cnri, 0, sizeof(CNRINFO));
     2091          cnri.cb = sizeof(CNRINFO);
     2092          WinSendMsg(hwnd, CM_QUERYCNRINFO, MPFROMP(&cnri),
     2093                     MPFROMLONG(sizeof(CNRINFO)));
     2094          switch (SHORT1FROMMP(mp1))
     2095          {
     2096          case IDM_ICON:
     2097            cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT |
     2098                                    CV_DETAIL | CV_NAME));
     2099            cnri.flWindowAttr |= CV_ICON;
     2100            break;
     2101          case IDM_NAME:
     2102            cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT |
     2103                                    CV_DETAIL | CV_NAME));
     2104            cnri.flWindowAttr |= CV_NAME;
     2105            break;
     2106          case IDM_TEXT:
     2107            cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT |
     2108                                    CV_DETAIL | CV_NAME));
     2109            cnri.flWindowAttr |= CV_TEXT;
     2110            break;
     2111          case IDM_DETAILS:
     2112            cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT |
     2113                                    CV_DETAIL | CV_NAME));
     2114            cnri.flWindowAttr |= CV_DETAIL;
     2115            break;
     2116          case IDM_MINIICONS:
     2117            if (cnri.flWindowAttr & CV_MINI)
     2118              cnri.flWindowAttr &= (~CV_MINI);
     2119            else
     2120              cnri.flWindowAttr |= CV_MINI;
     2121            break;
     2122          case IDM_DETAILSTITLES:
     2123            if (cnri.flWindowAttr & CA_DETAILSVIEWTITLES)
     2124              cnri.flWindowAttr &= (~CA_DETAILSVIEWTITLES);
     2125            else
     2126              cnri.flWindowAttr |= CA_DETAILSVIEWTITLES;
     2127            break;
     2128          }
     2129          cnri.flWindowAttr &= (~(CA_ORDEREDTARGETEMPH |
     2130                                  CA_MIXEDTARGETEMPH));
     2131          cnri.flWindowAttr |= CV_FLOW;
     2132          dcd -> flWindowAttr = cnri.flWindowAttr;
     2133          PrfWriteProfileData(fmprof, appname, "CollectorflWindowAttr",
     2134                              &cnri.flWindowAttr, sizeof(ULONG));
     2135          WinSendMsg(hwnd, CM_SETCNRINFO, MPFROMP(&cnri),
     2136                     MPFROMLONG(CMA_FLWINDOWATTR));
     2137          WinSendMsg(hwnd, CM_INVALIDATERECORD, MPVOID,
     2138                     MPFROM2SHORT(0, CMA_ERASE | CMA_REPOSITION));
     2139          SayView(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
     2140                                  DIR_VIEW), dcd -> flWindowAttr);
     2141        }
     2142        break;
     2143
     2144      case IDM_SAVETOLIST:
     2145        WinDlgBox(HWND_DESKTOP, hwnd, SaveListDlgProc, FM3ModHandle,
     2146                  SAV_FRAME, MPFROMP(&hwnd));
     2147        break;
     2148
     2149      case IDM_SIZES:
     2150        {
     2151          PCNRITEM pci;
     2152
     2153          pci = (PCNRITEM) CurrentRecord(hwnd);
     2154          if (pci && (INT) pci != -1)
     2155            WinDlgBox(HWND_DESKTOP, HWND_DESKTOP, DirSizeProc, FM3ModHandle,
     2156                      DSZ_FRAME, pci -> szFileName);
     2157        }
     2158        break;
     2159
     2160      case IDM_MKDIR:
     2161        {
     2162          PCNRITEM pci;
     2163
     2164          pci = (PCNRITEM) CurrentRecord(hwnd);
     2165          PMMkDir(dcd -> hwndParent, (pci && (INT) pci != -1) ?
     2166                  pci -> szFileName : NULL, FALSE);
     2167        }
     2168        break;
     2169
     2170      case IDM_DOITYOURSELF:
     2171      case IDM_UPDATE:
     2172      case IDM_COLLECTFROMFILE:
     2173      case IDM_OPENWINDOW:
     2174      case IDM_OPENSETTINGS:
     2175      case IDM_OPENDEFAULT:
     2176      case IDM_OPENICON:
     2177      case IDM_OPENDETAILS:
     2178      case IDM_OPENTREE:
     2179      case IDM_OBJECT:
     2180      case IDM_SHADOW:
     2181      case IDM_SHADOW2:
     2182      case IDM_DELETE:
     2183      case IDM_PERMDELETE:
     2184      case IDM_PRINT:
     2185      case IDM_ATTRS:
     2186      case IDM_INFO:
     2187      case IDM_COPY:
     2188      case IDM_MOVE:
     2189      case IDM_WPSCOPY:
     2190      case IDM_WPSMOVE:
     2191      case IDM_COPYPRESERVE:
     2192      case IDM_MOVEPRESERVE:
     2193      case IDM_WILDCOPY:
     2194      case IDM_WILDMOVE:
     2195      case IDM_RENAME:
     2196      case IDM_COMPARE:
     2197      case IDM_EAS:
     2198      case IDM_SUBJECT:
     2199      case IDM_VIEW:
     2200      case IDM_VIEWTEXT:
     2201      case IDM_VIEWBINARY:
     2202      case IDM_VIEWARCHIVE:
     2203      case IDM_EDIT:
     2204      case IDM_EDITTEXT:
     2205      case IDM_EDITBINARY:
     2206      case IDM_SAVETOCLIP:
     2207      case IDM_APPENDTOCLIP:
     2208      case IDM_ARCHIVE:
     2209      case IDM_ARCHIVEM:
     2210      case IDM_EXTRACT:
     2211      case IDM_MCIPLAY:
     2212      case IDM_UUDECODE:
     2213      case IDM_MERGE:
     2214        {
     2215          LISTINFO *li;
     2216          ULONG action = UM_ACTION;
     2217
     2218          li = malloc(sizeof(LISTINFO));
     2219          if (li)
     2220          {
     2221            memset(li, 0, sizeof(LISTINFO));
     2222            li -> type = SHORT1FROMMP(mp1);
     2223            li -> hwnd = hwnd;
     2224            li -> list = BuildList(hwnd);
     2225            if (li -> list)
     2226            {
     2227              switch (SHORT1FROMMP(mp1))
     2228              {
     2229              case IDM_DOITYOURSELF:
     2230              case IDM_APPENDTOCLIP:
     2231              case IDM_SAVETOCLIP:
     2232              case IDM_ARCHIVE:
     2233              case IDM_ARCHIVEM:
     2234              case IDM_DELETE:
     2235              case IDM_PERMDELETE:
     2236              case IDM_ATTRS:
     2237              case IDM_PRINT:
     2238              case IDM_SHADOW:
     2239              case IDM_SHADOW2:
     2240              case IDM_OBJECT:
     2241              case IDM_VIEW:
     2242              case IDM_VIEWTEXT:
     2243              case IDM_VIEWBINARY:
     2244              case IDM_EDIT:
     2245              case IDM_EDITTEXT:
     2246              case IDM_EDITBINARY:
     2247              case IDM_MCIPLAY:
     2248              case IDM_UPDATE:
     2249              case IDM_INFO:
     2250              case IDM_EAS:
     2251                action = UM_MASSACTION;
     2252                break;
     2253              }
     2254              if (li -> type == IDM_SHADOW || li -> type == IDM_OBJECT ||
     2255                  li -> type == IDM_SHADOW2)
     2256                *li -> targetpath = 0;
     2257              if (!PostMsg(dcd -> hwndObject, action, MPFROMP(li),
     2258                           MPVOID))
     2259              {
     2260                FreeListInfo(li);
     2261                DosBeep(50, 100);
     2262              }
     2263              else if (fUnHilite)
     2264                UnHilite(hwnd, TRUE, &dcd -> lastselection);
     2265            }
     2266            else
     2267              free(li);
     2268          }
     2269        }
     2270        break;
     2271
     2272      default:
     2273        if (!cmdloaded)
     2274          load_commands();
     2275        if (SHORT1FROMMP(mp1) >= IDM_COMMANDSTART &&
     2276            SHORT1FROMMP(mp1) < IDM_QUICKTOOLSTART)
     2277        {
     2278          INT x;
     2279
     2280          x = SHORT1FROMMP(mp1) - IDM_COMMANDSTART;
     2281          if (x >= 0)
     2282          {
     2283            x++;
     2284            RunCommand(hwnd, x);
     2285            if (fUnHilite)
     2286              UnHilite(hwnd, TRUE, &dcd -> lastselection);
     2287          }
     2288        }
     2289        break;
     2290      }
     2291    }
     2292    return 0;
     2293
     2294  case UM_FIXCNRMLE:
     2295  case UM_FIXEDITNAME:
     2296    return CommonCnrProc(hwnd, msg, mp1, mp2);
     2297
     2298  case UM_FILESMENU:
     2299    {
     2300      PCNRITEM pci;
     2301      HWND menuHwnd = (HWND) 0;
     2302
     2303      pci = (PCNRITEM) CurrentRecord(hwnd);
     2304      if (pci && (INT) pci != -1)
     2305      {
     2306        if (pci -> attrFile & FILE_DIRECTORY)
     2307          menuHwnd = CheckMenu(&CollectorDirMenu, COLLECTORDIR_POPUP);
     2308        else
     2309          menuHwnd = CheckMenu(&CollectorFileMenu, COLLECTORFILE_POPUP);
     2310      }
     2311      return MRFROMLONG(menuHwnd);
     2312    }
     2313
     2314  case WM_CONTROL:
     2315    DosError(FERR_DISABLEHARDERR);
     2316    if (dcd)
     2317    {
     2318      switch (SHORT2FROMMP(mp1))
     2319      {
     2320      case CN_CONTEXTMENU:
     2321        {
     2322          PCNRITEM pci = (PCNRITEM) mp2;
     2323
     2324          if (pci)
     2325          {
     2326            WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPFROMP(pci),
     2327                       MPFROM2SHORT(TRUE, CRA_CURSORED));
     2328            MarkAll(hwnd, FALSE, FALSE, TRUE);
     2329            if (pci -> attrFile & FILE_DIRECTORY)
     2330              dcd -> hwndLastMenu = CheckMenu(&CollectorDirMenu,
     2331                                              COLLECTORDIR_POPUP);
     2332            else
     2333              dcd -> hwndLastMenu = CheckMenu(&CollectorFileMenu,
     2334                                              COLLECTORFILE_POPUP);
     2335          }
     2336          else
     2337          {
     2338            dcd -> hwndLastMenu = CheckMenu(&CollectorCnrMenu,
     2339                                            COLLECTORCNR_POPUP);
     2340            if (dcd -> hwndLastMenu && !dcd -> cnremphasized)
     2341            {
     2342              WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPVOID,
     2343                         MPFROM2SHORT(TRUE, CRA_SOURCE));
     2344              dcd -> cnremphasized = TRUE;
     2345            }
     2346          }
     2347          if (dcd -> hwndLastMenu)
     2348          {
     2349            if (dcd -> hwndLastMenu == CollectorCnrMenu)
     2350            {
     2351              SetViewMenu(dcd -> hwndLastMenu, dcd -> flWindowAttr);
     2352              SetDetailsSwitches(dcd -> hwndLastMenu, dcd);
     2353              if (dcd -> flWindowAttr & CV_MINI)
     2354                WinCheckMenuItem(dcd -> hwndLastMenu, IDM_MINIICONS, TRUE);
     2355            }
     2356            if (!PopupMenu(hwnd, hwnd, dcd -> hwndLastMenu))
     2357            {
     2358              if (dcd -> cnremphasized)
     2359              {
     2360                WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPVOID,
     2361                           MPFROM2SHORT(FALSE, CRA_SOURCE));
     2362                dcd -> cnremphasized = TRUE;
     2363              }
     2364              MarkAll(hwnd, TRUE, FALSE, TRUE);
     2365            }
     2366          }
     2367        }
     2368        break;
     2369
     2370      case CN_DROPHELP:
     2371        if (mp2)
     2372        {
     2373          PDRAGINFO pDInfo;
     2374          PCNRITEM pci;
     2375          ULONG numitems;
     2376          USHORT usOperation;
     2377
     2378          pci = (PCNRITEM) ((PCNRDRAGINFO) mp2) -> pRecord;
     2379          pDInfo = ((PCNRDRAGINFO) mp2) -> pDragInfo;
     2380          if (!DrgAccessDraginfo(pDInfo))
     2381          {
     2382            Win_Error(hwnd, hwnd, __FILE__, __LINE__,
     2383                      "%s",
     2384                      GetPString(IDS_DROPERRORTEXT));
     2385            break;
     2386          }
     2387          numitems = DrgQueryDragitemCount(pDInfo);
     2388          usOperation = pDInfo -> usOperation;
     2389          DrgDeleteDraginfoStrHandles(pDInfo);
     2390          DrgFreeDraginfo(pDInfo);
     2391          saymsg(MB_ENTER | MB_ICONASTERISK,
     2392                 hwnd,
     2393                 GetPString(IDS_DROPHELPHDRTEXT),
     2394                 GetPString(IDS_DROPHELPTEXT),
     2395                 numitems,
     2396                 &"s"[numitems == 1L],
     2397                 (pci) ? NullStr : GetPString(IDS_NOTEXT),
     2398                 (pci) ? NullStr : " ",
     2399                 (pci) ? pci -> szFileName : NullStr,
     2400                 (pci) ? " " : NullStr,
     2401                 GetPString((usOperation == DO_COPY) ?
     2402                            IDS_COPYTEXT :
     2403                            (usOperation == DO_LINK) ?
     2404                            IDS_LINKTEXT : IDS_MOVETEXT));
     2405        }
     2406        return 0;
     2407
     2408      case CN_DRAGLEAVE:
     2409        if (mp2)
     2410        {
     2411          PDRAGINFO pDInfo;
     2412
     2413          pDInfo = ((PCNRDRAGINFO) mp2) -> pDragInfo;
     2414          DrgAccessDraginfo(pDInfo);    /* Access DRAGINFO       */
     2415          DrgFreeDraginfo(pDInfo);      /* Free DRAGINFO         */
     2416        }
     2417        return 0;
     2418
     2419      case CN_DRAGAFTER:
     2420      case CN_DRAGOVER:
     2421        if (mp2)
     2422        {
     2423          PDRAGITEM pDItem;     /* Pointer to DRAGITEM   */
     2424          PDRAGINFO pDInfo;     /* Pointer to DRAGINFO   */
     2425          PCNRITEM pci;
     2426          USHORT uso;
     2427
     2428          pci = (PCNRITEM) ((PCNRDRAGINFO) mp2) -> pRecord;
     2429//              if(SHORT1FROMMP(mp1) == CN_DRAGAFTER)
     2430          //                pci = NULL;
     2431          pDInfo = ((PCNRDRAGINFO) mp2) -> pDragInfo;
     2432          DrgAccessDraginfo(pDInfo);    /* Access DRAGINFO       */
     2433          if (pci)
     2434          {
     2435            if (pci -> rc.flRecordAttr & CRA_SOURCE)
     2436            {
     2437              DrgFreeDraginfo(pDInfo);
     2438              return (MRFROM2SHORT(DOR_NODROP, 0));
     2439            }
     2440            uso = pDInfo -> usOperation;
     2441            if (uso == DO_DEFAULT)
     2442              uso = (fCopyDefault) ? DO_COPY : DO_MOVE;
     2443            if (!(pci -> attrFile & FILE_DIRECTORY))
     2444            {
     2445              if (uso != DO_LINK && uso != DO_MOVE &&
     2446                  uso != DO_COPY)
     2447              {
     2448                DrgFreeDraginfo(pDInfo);
     2449                return MRFROM2SHORT(DOR_NODROP, 0);
     2450              }
     2451              if (uso != DO_LINK &&
     2452                  !(driveflags[toupper(*pci -> szFileName) - 'A'] &
     2453                    DRIVE_NOTWRITEABLE))
     2454              {
     2455                ARC_TYPE *info = NULL;
     2456
     2457                if (!fQuickArcFind &&
     2458                    !(driveflags[toupper(*pci -> szFileName) - 'A'] &
     2459                      DRIVE_SLOW))
     2460                  info = find_type(pci -> szFileName, NULL);
     2461                else
     2462                  info = quick_find_type(pci -> szFileName, NULL);
     2463                if (!info || ((uso == DO_MOVE && !info -> move) ||
     2464                              (uso == DO_COPY && !info -> create)))
     2465                {
     2466                  DrgFreeDraginfo(pDInfo);
     2467                  return MRFROM2SHORT(DOR_NODROP, 0);
     2468                }
     2469              }
     2470            }
     2471          }
     2472          pDItem = DrgQueryDragitemPtr(pDInfo,  /* Access DRAGITEM       */
     2473                                       0);      /* Index to DRAGITEM     */
     2474          if (DrgVerifyRMF(pDItem,      /* Check valid rendering */
     2475                           DRM_OS2FILE, /* mechanisms and data   */
     2476                           NULL))
     2477          {
     2478            DrgFreeDraginfo(pDInfo);    /* Free DRAGINFO         */
     2479            if (pci)
     2480            {
     2481              if (driveflags[toupper(*pci -> szFileName) - 'A'] &
     2482                  DRIVE_NOTWRITEABLE)
     2483                return MRFROM2SHORT(DOR_DROP, DO_LINK);
     2484              if (toupper(*pci -> szFileName) < 'C')
     2485                return MRFROM2SHORT(DOR_DROP, DO_COPY);
     2486              return MRFROM2SHORT(DOR_DROP,     /* Return okay to drop   */
     2487                                  ((fCopyDefault) ?
     2488                                   DO_COPY :
     2489                                   DO_MOVE));
     2490            }
     2491            else
     2492              return MRFROM2SHORT(DOR_DROP,     /* Return okay to drop   */
     2493                                  DO_COPY);
     2494          }
     2495          DrgFreeDraginfo(pDInfo);      /* Free DRAGINFO         */
     2496        }
     2497        return (MRFROM2SHORT(DOR_NODROP, 0));   /* Drop not valid        */
     2498
     2499      case CN_INITDRAG:
     2500        if (mp2)
     2501        {
     2502          BOOL wasemphasized = FALSE;
     2503          PCNRDRAGINIT pcd = (PCNRDRAGINIT) mp2;
     2504          PCNRITEM pci;
     2505
     2506          if (pcd)
     2507          {
     2508            pci = (PCNRITEM) pcd -> pRecord;
     2509            if (pci)
     2510            {
     2511              if (pci -> rc.flRecordAttr & CRA_SELECTED)
     2512                wasemphasized = TRUE;
     2513              if (IsRoot(pci -> szFileName))
     2514                break;
     2515              if (hwndStatus2)
     2516                WinSetWindowText(hwndStatus2,
     2517                                 GetPString(IDS_DRAGFILEOBJTEXT));
     2518              if (DoFileDrag(hwnd,
     2519                             dcd -> hwndObject,
     2520                             mp2,
     2521                             NULL,
     2522                             NULL,
     2523                             TRUE))
     2524              {
     2525                if (fUnHilite && wasemphasized)
     2526                  UnHilite(hwnd, TRUE, &dcd -> lastselection);
     2527              }
     2528              if (hwndStatus2)
     2529                PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
     2530            }
     2531          }
     2532        }
     2533        return 0;
     2534
     2535      case CN_DROP:
     2536        if (mp2)
     2537        {
     2538          LISTINFO *li;
     2539          ULONG action = UM_ACTION;
     2540
     2541          li = DoFileDrop(hwnd, NULL, TRUE, mp1, mp2);
     2542          if (li)
     2543          {
     2544            if (!*li -> targetpath)
     2545            {
     2546              li -> type = IDM_COLLECT;
     2547              action = UM_COLLECT;
     2548            }
     2549            else
     2550            {
     2551              if (li -> list && li -> list[0] && IsRoot(li -> list[0]))
     2552                li -> type = DO_LINK;
     2553              else if (fDragndropDlg && (!*li -> arcname || !li -> info))
     2554              {
     2555                CHECKLIST cl;
     2556
     2557                memset(&cl, 0, sizeof(cl));
     2558                cl.size = sizeof(cl);
     2559                cl.flags = li -> type;
     2560                cl.list = li -> list;
     2561                cl.cmd = li -> type;
     2562                cl.prompt = li -> targetpath;
     2563                li -> type = WinDlgBox(HWND_DESKTOP, dcd -> hwndParent,
     2564                                       DropListProc, FM3ModHandle,
     2565                                       DND_FRAME, MPFROMP(&cl));
     2566                if (!li -> type)
     2567                {
     2568                  FreeListInfo(li);
     2569                  return 0;
     2570                }
     2571                li -> list = cl.list;
     2572                if (!li -> list || !li -> list[0])
     2573                {
     2574                  FreeListInfo(li);
     2575                  return 0;
     2576                }
     2577              }
     2578              switch (li -> type)
     2579              {
     2580              case DND_LAUNCH:
     2581                strcat(li -> targetpath, " %a");
     2582                ExecOnList(dcd -> hwndParent, li -> targetpath,
     2583                           PROMPT | WINDOWED, NULL, li -> list, NULL);
     2584                FreeList(li -> list);
     2585                li -> list = NULL;
     2586                break;
     2587              case DO_LINK:
     2588                if (fLinkSetsIcon)
     2589                {
     2590                  li -> type = IDM_SETICON;
     2591                  action = UM_MASSACTION;
     2592                }
     2593                else
     2594                  li -> type = IDM_COMPARE;
     2595                break;
     2596              case DND_EXTRACT:
     2597                if (*li -> targetpath && !IsFile(li -> targetpath))
     2598                  li -> type = IDM_EXTRACT;
     2599                break;
     2600              case DND_MOVE:
     2601                li -> type = IDM_MOVE;
     2602                if (*li -> targetpath && IsFile(li -> targetpath) == 1)
     2603                {
     2604                  action = UM_MASSACTION;
     2605                  li -> type = IDM_ARCHIVEM;
     2606                }
     2607                break;
     2608              case DND_WILDMOVE:
     2609                li -> type = IDM_WILDMOVE;
     2610                if (*li -> targetpath && IsFile(li -> targetpath) == 1)
     2611                {
     2612                  action = UM_MASSACTION;
     2613                  li -> type = IDM_ARCHIVEM;
     2614                }
     2615                break;
     2616              case DND_OBJECT:
     2617                li -> type = IDM_OBJECT;
     2618                action = UM_MASSACTION;
     2619                break;
     2620              case DND_SHADOW:
     2621                li -> type = IDM_SHADOW;
     2622                action = UM_MASSACTION;
     2623                break;
     2624              case DND_COMPARE:
     2625                li -> type = IDM_COMPARE;
     2626                break;
     2627              case DND_SETICON:
     2628                action = UM_MASSACTION;
     2629                li -> type = IDM_SETICON;
     2630                break;
     2631              case DND_WILDCOPY:
     2632                li -> type = IDM_WILDCOPY;
     2633                if (*li -> targetpath && IsFile(li -> targetpath) == 1)
     2634                {
     2635                  action = UM_MASSACTION;
     2636                  li -> type = IDM_ARCHIVE;
     2637                }
     2638                break;
     2639              case DND_COPY:
     2640                li -> type = IDM_COPY;
     2641                if (*li -> targetpath && IsFile(li -> targetpath) == 1)
     2642                {
     2643                  action = UM_MASSACTION;
     2644                  li -> type = IDM_ARCHIVE;
     2645                }
     2646                break;
     2647              default:
     2648                if (*li -> arcname && li -> info)
     2649                {
     2650                  action = UM_MASSACTION;
     2651                  li -> type = (li -> type == DO_MOVE) ? IDM_FAKEEXTRACTM : IDM_FAKEEXTRACT;
     2652                }
     2653                else if (*li -> targetpath && IsFile(li -> targetpath) == 1)
     2654                {
     2655                  action = UM_MASSACTION;
     2656                  li -> type = (li -> type == DO_MOVE) ? IDM_ARCHIVEM : IDM_ARCHIVE;
     2657                }
     2658                else
     2659                  li -> type = (li -> type == DO_MOVE) ? IDM_MOVE : IDM_COPY;
     2660                break;
     2661              }
     2662            }
     2663            if (!li -> list || !li -> list[0])
     2664              FreeListInfo(li);
     2665            else if (!PostMsg(dcd -> hwndObject, action, MPFROMP(li), MPVOID))
     2666              FreeListInfo(li);
     2667            else
     2668            {
     2669              USHORT usop = 0;
     2670
     2671              switch (li -> type)
     2672              {
     2673              case IDM_COPY:
     2674              case IDM_WILDCOPY:
     2675                usop = DO_COPY;
     2676                break;
     2677              case IDM_MOVE:
     2678              case IDM_WILDMOVE:
     2679              case IDM_ARCHIVEM:
     2680                usop = DO_MOVE;
     2681                break;
     2682              }
     2683              if (usop)
     2684                return MRFROM2SHORT(DOR_DROP, usop);
     2685            }
     2686          }
     2687        }
     2688        return 0;
     2689
     2690      case CN_BEGINEDIT:
     2691      case CN_REALLOCPSZ:
     2692      case CN_ENDEDIT:
     2693        {
     2694          MRESULT mre;
     2695
     2696          mre = CnrDirectEdit(hwnd, msg, mp1, mp2);
     2697          if (mre != (MRESULT) - 1)
     2698            return mre;
     2699        }
     2700        break;
     2701
     2702      case CN_EMPHASIS:
     2703        if (mp2)
     2704        {
     2705          PNOTIFYRECORDEMPHASIS pre = mp2;
     2706          PCNRITEM pci;
     2707          CHAR s[CCHMAXPATH + 91], tb[81], tf[81], *p;
     2708
     2709          pci = (PCNRITEM) ((pre) ? pre -> pRecord : NULL);
     2710          if (!pci)
     2711          {
     2712            if (hwndStatus2)
     2713              WinSetWindowText(hwndStatus2, NullStr);
     2714            if (fMoreButtons)
     2715            {
     2716              WinSetWindowText(hwndName, NullStr);
     2717              WinSetWindowText(hwndDate, NullStr);
     2718              WinSetWindowText(hwndAttr, NullStr);
     2719            }
     2720            if (hwndMain)
     2721              WinSendMsg(hwndMain, UM_LOADFILE, MPVOID, MPVOID);
     2722            break;
     2723          }
     2724          if (pre -> fEmphasisMask & CRA_SELECTED)
     2725          {
     2726            if (pci -> rc.flRecordAttr & CRA_SELECTED)
     2727            {
     2728              dcd -> selectedbytes += (pci -> cbFile + pci -> easize);
     2729              dcd -> selectedfiles++;
     2730            }
     2731            else if (dcd -> selectedfiles)
     2732            {
     2733              dcd -> selectedbytes -= (pci -> cbFile + pci -> easize);
     2734              dcd -> selectedfiles--;
     2735            }
     2736            if (!dcd -> suspendview)
     2737            {
     2738              commafmt(tf, sizeof(tf), dcd -> selectedfiles);
     2739              CommaFmtULL(tb, sizeof(tb), dcd -> selectedbytes, ' ');
     2740              sprintf(s, "%s / %s", tf, tb);
     2741              WinSetDlgItemText(dcd -> hwndClient, DIR_SELECTED, s);
     2742            }
     2743          }
     2744          else if (!dcd -> suspendview &&
     2745                   WinQueryActiveWindow(dcd -> hwndParent) ==
     2746                   dcd -> hwndFrame)
     2747          {
     2748            if (pre -> fEmphasisMask & CRA_CURSORED)
     2749            {
     2750              if (pci -> rc.flRecordAttr & CRA_CURSORED)
     2751              {
     2752                if (fSplitStatus && hwndStatus2)
     2753                {
     2754                  if (pci -> attrFile & FILE_DIRECTORY)
     2755                    p = pci -> pszFileName;
     2756                  else
     2757                  {
     2758                    p = strrchr(pci -> szFileName, '\\');
     2759                    if (p)
     2760                    {
     2761                      if (*(p + 1))
     2762                        p++;
     2763                      else
     2764                        p = pci -> pszFileName;
     2765                    }
     2766                    else
     2767                      p = pci -> pszFileName;
     2768                  }
     2769                  CommaFmtULL(tb, sizeof(tb), pci -> cbFile + pci -> easize, ' ');
     2770                  if (!fMoreButtons)
     2771                    sprintf(s, " %s  %04u/%02u/%02u %02u:%02u:%02u  [%s]  %s",
     2772                            tb, pci -> date.year,
     2773                      pci -> date.month, pci -> date.day, pci -> time.hours,
     2774                            pci -> time.minutes, pci -> time.seconds,
     2775                            pci -> pszDispAttr, p);
     2776                  else
     2777                  {
     2778                    if (pci -> cbFile + pci -> easize > 1024)
     2779                      CommaFmtULL(tf, sizeof(tf), pci -> cbFile + pci -> easize, ' ');
     2780                    else
     2781                      *tf = 0;
     2782                    sprintf(s, GetPString(IDS_STATUSSIZETEXT),
     2783                            tb,
     2784                            *tf ? " (" : NullStr,
     2785                            tf,
     2786                            *tf ? ")" : NullStr);
     2787                  }
     2788                  WinSetWindowText(hwndStatus2, s);
     2789                }
     2790                if (fMoreButtons)
     2791                {
     2792                  WinSetWindowText(hwndName, pci -> pszFileName);
     2793                  sprintf(s, "%04u/%02u/%02u %02u:%02u:%02u",
     2794                          pci -> date.year, pci -> date.month,
     2795                    pci -> date.day, pci -> time.hours, pci -> time.minutes,
     2796                          pci -> time.seconds);
     2797                  WinSetWindowText(hwndDate, s);
     2798                  WinSetWindowText(hwndAttr, pci -> pszDispAttr);
     2799                }
     2800              }
     2801            }
     2802          }
     2803          if (!dcd -> suspendview && hwndMain &&
     2804              (pre -> fEmphasisMask & CRA_CURSORED) &&
     2805              (pci -> rc.flRecordAttr & CRA_CURSORED) &&
     2806              WinQueryActiveWindow(dcd -> hwndParent) == dcd -> hwndFrame)
     2807            WinSendMsg(hwndMain, UM_LOADFILE,
     2808            MPFROMP(((fComments || (pci -> attrFile & FILE_DIRECTORY) == 0) ?
     2809                     pci -> szFileName : NULL)), MPVOID);
     2810        }
     2811        break;
     2812
     2813      case CN_ENTER:
     2814        if (mp2)
     2815        {
     2816          PCNRITEM pci = (PCNRITEM) ((PNOTIFYRECORDENTER) mp2) -> pRecord;
     2817          FILEFINDBUF3 ffb;
     2818          HDIR hDir = HDIR_CREATE;
     2819          ULONG nm = 1L;
     2820          APIRET status = 0;
     2821
     2822          SetShiftState();
     2823          if (pci)
     2824          {
     2825            if (pci -> rc.flRecordAttr & CRA_INUSE)
     2826              break;
     2827            DosError(FERR_DISABLEHARDERR);
     2828            status = DosFindFirst(pci -> szFileName, &hDir,
     2829                                  FILE_NORMAL | FILE_DIRECTORY |
     2830                                  FILE_ARCHIVED | FILE_READONLY |
     2831                                  FILE_HIDDEN | FILE_SYSTEM,
     2832                                  &ffb, sizeof(ffb), &nm,
     2833                                  FIL_STANDARD);
     2834            priority_bumped();
     2835            if (!status)
     2836            {
     2837              DosFindClose(hDir);
     2838              if (ffb.attrFile & FILE_DIRECTORY)
     2839              {
     2840                if ((shiftstate & (KC_CTRL | KC_ALT)) ==
     2841                    (KC_CTRL | KC_ALT))
     2842                  PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_SHOWALLFILES, 0),
     2843                          MPVOID);
     2844                else if ((shiftstate & (KC_CTRL | KC_SHIFT)) ==
     2845                         (KC_CTRL | KC_SHIFT))
     2846                  OpenObject(pci -> szFileName, Settings, dcd -> hwndFrame);
     2847                else if (shiftstate & KC_CTRL)
     2848                  OpenObject(pci -> szFileName, Default, dcd -> hwndFrame);
     2849                else
     2850                  OpenDirCnr((HWND) 0,
     2851                             hwndMain,
     2852                             dcd -> hwndFrame,
     2853                             FALSE,
     2854                             pci -> szFileName);
     2855              }
     2856              else
     2857              {
     2858                SWP swp;
     2859
     2860                WinSendMsg(hwnd,
     2861                           CM_SETRECORDEMPHASIS,
     2862                           MPFROMP(pci),
     2863                           MPFROM2SHORT(TRUE, CRA_INUSE));
     2864                WinQueryWindowPos(dcd -> hwndFrame, &swp);
     2865                DefaultViewKeys(hwnd,
     2866                                dcd -> hwndFrame,
     2867                                dcd -> hwndParent,
     2868                                &swp,
     2869                                pci -> szFileName);
     2870                WinSendMsg(hwnd,
     2871                           CM_SETRECORDEMPHASIS,
     2872                           MPFROMP(pci),
     2873                           MPFROM2SHORT(FALSE, CRA_INUSE |
     2874                                        ((fUnHilite) ? CRA_SELECTED : 0)));
     2875              }
     2876            }
     2877            else
     2878              WinSendMsg(hwnd,
     2879                         CM_REMOVERECORD,
     2880                         MPFROMP(&pci),
     2881                         MPFROM2SHORT(1,
     2882                                    CMA_FREE | CMA_INVALIDATE | CMA_ERASE));
     2883          }
     2884        }
     2885        break;
     2886      }
     2887    }
     2888    return 0;
     2889
     2890  case UM_LOADFILE:
     2891    if (dcd && mp2)
     2892    {
     2893      HWND ret;
     2894
     2895      ret = StartMLEEditor(dcd -> hwndParent,
     2896                           (INT) mp1,
     2897                           (CHAR *) mp2,
     2898                           dcd -> hwndFrame);
     2899      if (mp2)
     2900        free((CHAR *) mp2);
     2901      return MRFROMLONG(ret);
     2902    }
     2903    return 0;
     2904
     2905  case UM_CLOSE:
     2906    WinDestroyWindow(WinQueryWindow(WinQueryWindow(hwnd, QW_PARENT),
     2907                                    QW_PARENT));
     2908    return 0;
     2909
     2910  case UM_FOLDUP:
     2911    if (!PostMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID))
     2912      DosExit(EXIT_PROCESS, 1);
     2913    return 0;
     2914
     2915  case WM_CLOSE:
     2916    if (dcd)
     2917    {
     2918      dcd -> namecanchange = TRUE;
     2919      dcd -> stopflag = 1;
     2920      if (dcd -> amextracted)
     2921        return 0;
     2922    }
     2923    WinSendMsg(hwnd, WM_SAVEAPPLICATION, MPVOID, MPVOID);
     2924    if (dcd)
     2925    {
     2926      if (!dcd -> dontclose && ParentIsDesktop(hwnd, dcd -> hwndParent))
     2927        PostMsg(hwnd, UM_FOLDUP, MPVOID, MPVOID);
     2928      if (dcd -> hwndObject)
     2929      {
     2930        DosSleep(64L);
     2931        if (!PostMsg(dcd -> hwndObject, WM_CLOSE, MPVOID, MPVOID))
     2932          WinSendMsg(dcd -> hwndObject, WM_CLOSE, MPVOID, MPVOID);
     2933      }
     2934    }
     2935    else
     2936      WinSendMsg(hwnd, UM_CLOSE, MPVOID, MPVOID);
     2937    return 0;
     2938
     2939  case WM_DESTROY:
     2940    if (CollectorDirMenu)
     2941      WinDestroyWindow(CollectorDirMenu);
     2942    if (CollectorFileMenu)
     2943      WinDestroyWindow(CollectorFileMenu);
     2944    if (CollectorCnrMenu)
     2945      WinDestroyWindow(CollectorCnrMenu);
     2946    CollectorCnrMenu = CollectorFileMenu = CollectorDirMenu = (HWND) 0;
     2947    Collector = (HWND) 0;
     2948    EmptyCnr(hwnd);
     2949    break;
    3652950  }
    366   return PFNWPStatic(hwnd,msg,mp1,mp2);
     2951  return (dcd && dcd -> oldproc) ? dcd -> oldproc(hwnd, msg, mp1, mp2) :
     2952    PFNWPCnr(hwnd, msg, mp1, mp2);
    3672953}
    3682954
    369 
    370 MRESULT EXPENTRY CollectorClientWndProc (HWND hwnd,ULONG msg,MPARAM mp1,
    371                                          MPARAM mp2) {
    372 
    373   switch(msg) {
    374     case UM_CONTAINERHWND:
    375       return MRFROMLONG(WinWindowFromID(hwnd,COLLECTOR_CNR));
    376 
    377     case UM_VIEWSMENU:
    378       return MRFROMLONG(CheckMenu(&CollectorCnrMenu,COLLECTORCNR_POPUP));
    379 
    380     case MM_PORTHOLEINIT:
    381     case WM_INITMENU:
    382     case UM_INITMENU:
    383     case UM_CONTAINER_FILLED:
    384     case UM_FILESMENU:
    385     case UM_UPDATERECORD:
    386     case UM_UPDATERECORDLIST:
    387       return WinSendMsg(WinWindowFromID(hwnd,COLLECTOR_CNR),msg,mp1,mp2);
    388 
    389     case WM_PSETFOCUS:
    390     case WM_SETFOCUS:
    391       if(mp2)
    392         PostMsg(hwnd,UM_FOCUSME,MPVOID,MPVOID);
    393       break;
    394 
    395     case UM_FOCUSME:
    396       WinSetFocus(HWND_DESKTOP,WinWindowFromID(hwnd,COLLECTOR_CNR));
    397       break;
    398 
    399     case WM_PAINT:
    400       {
    401         HPS    hps;
    402         RECTL  rcl;
    403 
    404         hps = WinBeginPaint(hwnd,(HPS)0,NULL);
    405         if(hps) {
    406           WinQueryWindowRect(hwnd,&rcl);
    407           WinFillRect(hps,&rcl,CLR_PALEGRAY);
    408           CommonTextPaint(hwnd,hps);
    409           WinEndPaint(hps);
    410         }
    411       }
    412       break;
    413 
    414     case UM_SIZE:
    415     case WM_SIZE:
    416       if(msg == UM_SIZE) {
    417 
    418         SWP     swp;
    419 
    420         WinQueryWindowPos(hwnd,&swp);
    421         mp1 = MPFROM2SHORT(swp.cx,swp.cy);
    422         mp2 = MPFROM2SHORT(swp.cx,swp.cy);
    423       }
    424       {
    425         USHORT  cx,cy,bx;
    426 
    427         cx = SHORT1FROMMP(mp2);
    428         cy = SHORT2FROMMP(mp2);
    429         WinSetWindowPos(WinWindowFromID(hwnd,COLLECTOR_CNR),HWND_TOP,
    430                         0,
    431                         0,
    432                         cx,
    433                         cy - 24,
    434                         SWP_SHOW | SWP_MOVE | SWP_SIZE);
    435         WinSetWindowPos(WinWindowFromID(hwnd,DIR_TOTALS),HWND_TOP,
    436                         2,
    437                         cy - 22,
    438                         (cx / 3) - 2,
    439                         20,
    440                         SWP_SHOW | SWP_MOVE | SWP_SIZE);
    441         WinSetWindowPos(WinWindowFromID(hwnd,DIR_SELECTED),HWND_TOP,
    442                         2 + (cx / 3) + 2,
    443                         cy - 22,
    444                         (cx / 3) - 2,
    445                         20,
    446                         SWP_SHOW | SWP_MOVE | SWP_SIZE);
    447         bx = (cx - (2 + (((cx / 3) + 2) * 2))) / 3;
    448         WinSetWindowPos(WinWindowFromID(hwnd,DIR_VIEW),HWND_TOP,
    449                         2 + (((cx / 3) + 2) * 2),
    450                         cy - 22,
    451                         bx - 4,
    452                         20,
    453                         SWP_SHOW | SWP_MOVE | SWP_SIZE);
    454         WinSetWindowPos(WinWindowFromID(hwnd,DIR_SORT),HWND_TOP,
    455                         2 + (((cx / 3) + 2) * 2) + bx,
    456                         cy - 22,
    457                         bx - 4,
    458                         20,
    459                         SWP_SHOW | SWP_MOVE | SWP_SIZE);
    460         WinSetWindowPos(WinWindowFromID(hwnd,DIR_FILTER),HWND_TOP,
    461                         2 + (((cx / 3) + 2) * 2) + (bx * 2),
    462                         cy - 22,
    463                         bx - 4,
    464                         20,
    465                         SWP_SHOW | SWP_MOVE | SWP_SIZE);
    466       }
    467       CommonTextPaint(hwnd,(HPS)0);
    468       if(msg == UM_SIZE) {
    469         WinSetWindowPos(WinQueryWindow(hwnd,QW_PARENT),HWND_TOP,0,0,0,0,
    470                         SWP_SHOW | SWP_ZORDER | SWP_ACTIVATE);
    471         return 0;
    472       }
    473       break;
    474 
    475     case UM_COMMAND:
    476     case WM_COMMAND:
    477     case WM_CONTROL:
    478     case WM_CLOSE:
    479       return WinSendMsg(WinWindowFromID(hwnd,COLLECTOR_CNR),msg,mp1,mp2);
    480   }
    481   return WinDefWindowProc(hwnd,msg,mp1,mp2);
    482 }
    483 
    484 
    485 MRESULT EXPENTRY CollectorObjWndProc (HWND hwnd,ULONG msg,MPARAM mp1,
    486                                       MPARAM mp2) {
    487 
     2955HWND StartCollector(HWND hwndParent, INT flags)
     2956{
     2957  HWND hwndFrame = (HWND) 0, hwndClient;
     2958  ULONG FrameFlags = FCF_TITLEBAR | FCF_SYSMENU |
     2959  FCF_SIZEBORDER | FCF_MINMAX |
     2960  FCF_ICON | FCF_NOBYTEALIGN |
     2961  FCF_ACCELTABLE;
     2962  USHORT id;
     2963  static USHORT idinc = 0;
    4882964  DIRCNRDATA *dcd;
    4892965
    490   switch(msg) {
    491     case WM_CREATE:
    492       break;
    493 
    494     case DM_PRINTOBJECT:
    495       return MRFROMLONG(DRR_TARGET);
    496 
    497     case DM_DISCARDOBJECT:
    498       dcd = INSTDATA(hwnd);
    499       if(fFM2Deletes && dcd) {
    500 
    501         LISTINFO    *li;
    502         CNRDRAGINFO cni;
    503 
    504         cni.pRecord = NULL;
    505         cni.pDragInfo = (PDRAGINFO)mp1;
    506         li = DoFileDrop(dcd->hwndCnr,NULL,FALSE,MPVOID,MPFROMP(&cni));
    507         if(li) {
    508           li->type = (fDefaultDeletePerm) ? IDM_PERMDELETE : IDM_DELETE;
    509           if(!PostMsg(hwnd,UM_MASSACTION,MPFROMP(li),MPVOID))
    510             FreeListInfo(li);
    511           else
    512             return MRFROMLONG(DRR_SOURCE);
    513         }
    514       }
    515       return MRFROMLONG(DRR_TARGET);
    516 
    517     case UM_UPDATERECORDLIST:
    518       dcd = WinQueryWindowPtr(hwnd,QWL_USER);
    519       if(dcd && mp1) {
    520 
    521         INT    numentries = 0;
    522         CHAR **list = (CHAR **)mp1;
    523 
    524         while(list[numentries])
    525           numentries++;
    526         if(numentries)
    527           UpdateCnrList(dcd->hwndCnr,list,numentries,FALSE,dcd);
    528       }
    529       return 0;
    530 
    531     case UM_SETUP:
    532       dcd = WinQueryWindowPtr(hwnd,QWL_USER);
    533       if(dcd) {
    534         /* set unique id */
    535         WinSetWindowUShort(hwnd,
    536                            QWS_ID,
    537                            COLLECTOROBJ_FRAME + (COLLECTOR_FRAME - dcd->id));
    538         dcd->hwndObject = hwnd;
    539         if(ParentIsDesktop(hwnd,dcd->hwndParent))
    540           DosSleep(250L);
    541       }
    542       else
    543         PostMsg(hwnd,WM_CLOSE,MPVOID,MPVOID);
    544       return 0;
    545 
    546     case UM_COMMAND:
    547       if(mp1) {
    548 
    549         LISTINFO *li = (LISTINFO *)mp1;
    550 
    551         switch(li->type) {
    552           case IDM_DOITYOURSELF:
    553           case IDM_APPENDTOCLIP:
    554           case IDM_SAVETOCLIP:
    555           case IDM_ARCHIVE:
    556           case IDM_ARCHIVEM:
    557           case IDM_VIEW:
    558           case IDM_VIEWTEXT:
    559           case IDM_VIEWBINARY:
    560           case IDM_VIEWARCHIVE:
    561           case IDM_EDIT:
    562           case IDM_EDITTEXT:
    563           case IDM_EDITBINARY:
    564           case IDM_OBJECT:
    565           case IDM_SHADOW:
    566           case IDM_SHADOW2:
    567           case IDM_PRINT:
    568           case IDM_ATTRS:
    569           case IDM_DELETE:
    570           case IDM_PERMDELETE:
    571           case IDM_FAKEEXTRACT:
    572           case IDM_FAKEEXTRACTM:
    573           case IDM_MCIPLAY:
    574           case IDM_UPDATE:
    575             if(PostMsg(hwnd,UM_MASSACTION,mp1,mp2))
    576               return (MRESULT)TRUE;
    577             break;
    578           default:
    579             if(PostMsg(hwnd,UM_ACTION,mp1,mp2))
    580               return (MRESULT)TRUE;
    581         }
    582       }
    583       return 0;
    584 
    585     case UM_COLLECT:
    586       DosError(FERR_DISABLEHARDERR);
    587       dcd = WinQueryWindowPtr(hwnd,QWL_USER);
    588       if (dcd)
    589       {
    590         LISTINFO    *li = (LISTINFO *)mp1;
    591         INT          x;
    592         FILEFINDBUF4 fb4;
    593         HDIR         hdir;
    594         ULONG        nm;
    595         PCNRITEM     pci,pciFirst,pciT,pciP = NULL;
    596         RECORDINSERT ri;
    597         ULONG        ulMaxFiles;
    598         ULONGLONG    ullTotalBytes;
    599         CHAR         fullname[CCHMAXPATH];
    600 
    601         WinSetWindowText(WinWindowFromID(dcd->hwndClient,
    602                          DIR_SELECTED),
    603                          GetPString(IDS_COLLECTINGTEXT));
    604         for(x = 0;li->list[x];x++)
    605         ;
    606         ulMaxFiles = x;
    607         if(ulMaxFiles) {
    608           pci = WinSendMsg(dcd->hwndCnr, CM_ALLOCRECORD,
    609                            MPFROMLONG(EXTRA_RECORD_BYTES),
    610                            MPFROMLONG(ulMaxFiles));
    611           if(pci) {
    612             pciFirst = pci;
    613             for(x = 0;li->list[x];x++) {
    614               nm = 1L;
    615               hdir = HDIR_CREATE;
    616               DosError(FERR_DISABLEHARDERR);
    617               if(*li->list[x] &&
    618                  !DosQueryPathInfo(li->list[x],FIL_QUERYFULLNAME,
    619                                    fullname,sizeof(fullname)) &&
    620                  !IsRoot(fullname) &&
    621                  !FindCnrRecord(dcd->hwndCnr,
    622                                 fullname,
    623                                 NULL,
    624                                 FALSE,
    625                                 FALSE,
    626                                 TRUE) &&
    627                  !DosFindFirst(fullname,
    628                                &hdir,
    629                                FILE_NORMAL   | FILE_DIRECTORY |
    630                                FILE_ARCHIVED | FILE_SYSTEM    |
    631                                FILE_HIDDEN   | FILE_READONLY,
    632                                &fb4,
    633                                sizeof(fb4),
    634                                &nm,
    635                                FIL_QUERYEASIZE)) {
    636                 DosFindClose(hdir);
    637                 priority_normal();
    638                 *fb4.achName = 0;
    639                 ullTotalBytes = FillInRecordFromFFB(dcd->hwndCnr,
    640                                                     pci,
    641                                                     fullname,
    642                                                     &fb4,
    643                                                     FALSE,
    644                                                     dcd);
    645                 dcd->ullTotalBytes += ullTotalBytes;
    646                 pciP = pci;
    647                 pci = (PCNRITEM)pci->rc.preccNextRecord;
    648               }
    649               else {
    650                 pciT = pci;
    651                 pci = (PCNRITEM)pci->rc.preccNextRecord;
    652                 if(pciP)
    653                   pciP->rc.preccNextRecord = (PMINIRECORDCORE)pci;
    654                 else
    655                   pciFirst = pci;
    656                 WinSendMsg(hwnd,CM_FREERECORD,MPFROMP(&pciT),
    657                            MPFROM2SHORT(1,0));
    658                 ulMaxFiles--;
    659               }
    660               DosSleep(1L);
    661             }
    662             if(ulMaxFiles) {
    663               memset(&ri, 0, sizeof(RECORDINSERT));
    664               ri.cb                 = sizeof(RECORDINSERT);
    665               ri.pRecordOrder       = (PRECORDCORE) CMA_END;
    666               ri.pRecordParent      = (PRECORDCORE) 0;
    667               ri.zOrder             = (ULONG) CMA_TOP;
    668               ri.cRecordsInsert     = ulMaxFiles;
    669               ri.fInvalidateRecord  = TRUE;
    670               WinSendMsg(dcd->hwndCnr,
    671                          CM_INSERTRECORD,
    672                          MPFROMP(pciFirst),
    673                          MPFROMP(&ri));
    674               PostMsg(dcd->hwndCnr,
    675                       UM_RESCAN,
    676                       MPVOID,
    677                       MPVOID);
    678             }
    679           }
    680         }
    681       }
    682       if(dcd->flWindowAttr & CV_DETAIL)
    683         WinSendDlgItemMsg(hwnd,
    684                           COLLECTOR_CNR,
    685                           CM_INVALIDATERECORD,
    686                           MPVOID,
    687                           MPFROM2SHORT(0,
    688                                        CMA_ERASE | CMA_REPOSITION));
    689       return 0;
    690 
    691     case UM_COLLECTFROMFILE:
    692       dcd = WinQueryWindowPtr(hwnd,QWL_USER);
    693       if(dcd && mp1) {
    694 
    695         FILESTATUS4  fs4;
    696         PCNRITEM     pci;
    697         RECORDINSERT ri;
    698         CHAR         fullname[1024],*p;
    699         FILE        *fp;
    700         ULONG        errs = 0L;
    701 
    702         fp = _fsopen((CHAR *)mp1,"r",SH_DENYNO);
    703         if(fp) {
    704           while(!feof(fp)) {
    705             if(!fgets(fullname,1024,fp))
    706               break;
    707             fullname[1023] = 0;
    708             bstripcr(fullname);
    709             if(*fullname == '\"') {
    710               memmove(fullname,fullname + 1,strlen(fullname) + 1);
    711               lstrip(fullname);
    712               p = strchr(fullname,'\"');
    713               if(p)
    714                 *p = 0;
    715               rstrip(fullname);
    716             }
    717             else {
    718               p = strchr(fullname,' ');
    719               if(p)
    720                 *p = 0;
    721             }
    722             /* fullname now contains name of file to collect */
    723             DosError(FERR_DISABLEHARDERR);
    724             if(IsFullName(fullname) &&
    725                !IsRoot(fullname) &&
    726                !DosQueryPathInfo(fullname,
    727                                  FIL_QUERYEASIZE,
    728                                  &fs4,
    729                                  sizeof(fs4)) &&
    730                !FindCnrRecord(dcd->hwndCnr,
    731                               fullname,
    732                               NULL,
    733                               FALSE,
    734                               FALSE,
    735                               TRUE)) {
    736               /* collect it */
    737               pci = WinSendMsg(dcd->hwndCnr,
    738                                CM_ALLOCRECORD,
    739                                MPFROMLONG(EXTRA_RECORD_BYTES),
    740                                MPFROMLONG(1L));
    741               if (pci)
    742               {
    743                 dcd->ullTotalBytes += FillInRecordFromFSA(dcd->hwndCnr,pci,
    744                                                        fullname,
    745                                                        &fs4,FALSE,dcd);
    746                 memset(&ri, 0, sizeof(RECORDINSERT));
    747                 ri.cb                 = sizeof(RECORDINSERT);
    748                 ri.pRecordOrder       = (PRECORDCORE) CMA_END;
    749                 ri.pRecordParent      = (PRECORDCORE) 0;
    750                 ri.zOrder             = (ULONG) CMA_TOP;
    751                 ri.cRecordsInsert     = 1L;
    752                 ri.fInvalidateRecord  = TRUE;
    753                 WinSendMsg(dcd->hwndCnr, CM_INSERTRECORD,
    754                            MPFROMP(pci),MPFROMP(&ri));
    755               }
    756             }
    757             else {
    758               errs++;
    759               if(errs > 50L) {  /* prevent runaway on bad file */
    760 
    761                 APIRET ret;
    762 
    763                 ret = saymsg(MB_YESNO,dcd->hwndCnr,
    764                              GetPString(IDS_COLLECTNOLISTHDRTEXT),
    765                              GetPString(IDS_COLLECTNOLISTTEXT),
    766                              (CHAR *)mp1);
    767                 if(ret == MBID_NO)
    768                   break;
    769                 errs = 0L;
    770               }
    771             }
    772           }
    773           fclose(fp);
    774         }
    775       }
    776       if(mp1)
    777         free(mp1);
    778       return 0;
    779 
    780     case UM_SELECT:
    781       dcd = WinQueryWindowPtr(hwnd,QWL_USER);
    782       if(dcd) {
    783         switch(SHORT1FROMMP(mp1)) {
    784           case IDM_SELECTLIST:
    785             {
    786               CHAR filename[CCHMAXPATH],*p,*pp;
    787               ULONG size;
    788 
    789               strcpy(filename,"*.LST");
    790               size = CCHMAXPATH;
    791               PrfQueryProfileData(fmprof,
    792                                   appname,
    793                                   "SaveToListName",
    794                                   filename,
    795                                   &size);
    796               pp = strrchr(filename,'\\');
    797               if(!pp)
    798                 pp = filename;
    799               p = strrchr(pp,'.');
    800               if(p && *(p + 1) && p > pp + 1) {
    801                 if(pp > filename)
    802                   pp++;
    803                 *pp = '*';
    804                 pp++;
    805                 if(p > pp)
    806                   memmove(pp,p,strlen(p) + 1);
    807               }
    808               if(insert_filename(hwnd,filename,FALSE,FALSE))
    809                 SelectList(dcd->hwndCnr,TRUE,FALSE,FALSE,NULL,filename,NULL);
    810             }
    811             break;
    812           case IDM_SELECTALL:
    813             SelectAll(dcd->hwndCnr,TRUE,TRUE,NULL,NULL,FALSE);
    814             break;
    815           case IDM_DESELECTALL:
    816             DeselectAll(dcd->hwndCnr,TRUE,TRUE,NULL,NULL,FALSE);
    817             break;
    818           case IDM_SELECTALLFILES:
    819             SelectAll(dcd->hwndCnr,TRUE,FALSE,NULL,NULL,FALSE);
    820             break;
    821           case IDM_DESELECTALLFILES:
    822             DeselectAll(dcd->hwndCnr,TRUE,FALSE,NULL,NULL,FALSE);
    823             break;
    824           case IDM_SELECTALLDIRS:
    825             SelectAll(dcd->hwndCnr,FALSE,TRUE,NULL,NULL,FALSE);
    826             break;
    827           case IDM_DESELECTALLDIRS:
    828             DeselectAll(dcd->hwndCnr,FALSE,TRUE,NULL,NULL,FALSE);
    829             break;
    830           case IDM_DESELECTMASK:
    831           case IDM_SELECTMASK:
    832             {
    833               MASK     mask;
    834               PCNRITEM pci = (PCNRITEM)mp2;
    835 
    836               memset(&mask,0,sizeof(MASK));
    837               mask.fNoAttribs = TRUE;
    838               mask.fNoDirs = TRUE;
    839               mask.fText = TRUE;
    840               strcpy(mask.prompt,
    841                      GetPString((SHORT1FROMMP(mp1) == IDM_SELECTMASK) ?
    842                                 IDS_SELECTFILTERTEXT :
    843                                 IDS_DESELECTFILTERTEXT));
    844               if(pci && (INT)pci != -1)
    845                 strcpy(mask.szMask,pci->szFileName);
    846               if(WinDlgBox(HWND_DESKTOP,dcd->hwndCnr,PickMaskDlgProc,
    847                            FM3ModHandle,MSK_FRAME,MPFROMP(&mask))) {
    848                 if(SHORT1FROMMP(mp1) == IDM_SELECTMASK)
    849                   SelectAll(dcd->hwndCnr,TRUE,TRUE,mask.szMask,mask.szText,
    850                             FALSE);
    851                 else
    852                   DeselectAll(dcd->hwndCnr,TRUE,TRUE,mask.szMask,mask.szText,
    853                               FALSE);
    854               }
    855             }
    856 
    857           case IDM_DESELECTCLIP:
    858           case IDM_SELECTCLIP:
    859             {
    860               CHAR **list;
    861 
    862               list = ListFromClipboard(hwnd);
    863               if(list) {
    864                 SelectList(dcd->hwndCnr,TRUE,FALSE,
    865                            (SHORT1FROMMP(mp1) == IDM_DESELECTCLIP),
    866                            NULL,NULL,list);
    867                 FreeList(list);
    868               }
    869             }
    870             break;
    871 
    872           case IDM_INVERT:
    873             InvertAll(dcd->hwndCnr);
    874             break;
    875         }
    876       }
    877       return 0;
    878 
    879     case UM_MASSACTION:
    880       if(mp1) {
    881 
    882         dcd = WinQueryWindowPtr(hwnd,QWL_USER);
    883         if(dcd) {
    884 
    885           WORKER *wk;
    886 
    887           wk = malloc(sizeof(WORKER));
    888           if(wk) {
    889             memset(wk,0,sizeof(WORKER));
    890             wk->size = sizeof(WORKER);
    891             wk->hwndCnr = dcd->hwndCnr;
    892             wk->hwndParent = dcd->hwndParent;
    893             wk->hwndFrame = dcd->hwndFrame;
    894             wk->hwndClient = dcd->hwndClient;
    895             wk->li = (LISTINFO *)mp1;
    896             strcpy(wk->directory,dcd->directory);
    897             if(_beginthread(MassAction,NULL,122880,(PVOID)wk) == -1) {
    898               free(wk);
    899               FreeListInfo((LISTINFO *)mp1);
    900             }
    901           }
    902           else
    903             FreeListInfo((LISTINFO *)mp1);
    904         }
    905       }
    906       return 0;
    907 
    908     case UM_ACTION:
    909       if(mp1) {
    910 
    911         dcd = WinQueryWindowPtr(hwnd,QWL_USER);
    912         if(dcd) {
    913 
    914           WORKER *wk;
    915 
    916           wk = malloc(sizeof(WORKER));
    917           if(wk) {
    918             memset(wk,0,sizeof(WORKER));
    919             wk->size = sizeof(WORKER);
    920             wk->hwndCnr = dcd->hwndCnr;
    921             wk->hwndParent = dcd->hwndParent;
    922             wk->hwndFrame = dcd->hwndFrame;
    923             wk->hwndClient = dcd->hwndClient;
    924             wk->li = (LISTINFO *)mp1;
    925             strcpy(wk->directory,dcd->directory);
    926             if(_beginthread(Action,NULL,122880,(PVOID)wk) == -1) {
    927               free(wk);
    928               FreeListInfo((LISTINFO *)mp1);
    929             }
    930           }
    931           else
    932             FreeListInfo((LISTINFO *)mp1);
    933         }
    934       }
    935       return 0;
    936 
    937     case WM_CLOSE:
    938       WinDestroyWindow(hwnd);
    939       break;
    940 
    941     case WM_DESTROY:
    942       dcd = WinQueryWindowPtr(hwnd,QWL_USER);
    943       if(dcd) {
    944 
    945         INT x = 0;
    946 
    947         dcd->stopflag = 1;
    948         while(x++ < 10 && dcd->amextracted)
    949           DosSleep(250L);
    950         WinSendMsg(dcd->hwndCnr,UM_CLOSE,MPVOID,MPVOID);
    951         FreeList(dcd->lastselection);
    952         free(dcd);
    953       }
    954       DosPostEventSem(CompactSem);
    955       if(!PostMsg((HWND)0,WM_QUIT,MPVOID,MPVOID))
    956         WinSendMsg((HWND)0,WM_QUIT,MPVOID,MPVOID);
    957       break;
    958   }
    959   return WinDefWindowProc(hwnd,msg,mp1,mp2);
    960 }
    961 
    962 
    963 MRESULT EXPENTRY CollectorCnrWndProc (HWND hwnd,ULONG msg,MPARAM mp1,MPARAM mp2)
    964 {
    965   DIRCNRDATA *dcd = WinQueryWindowPtr(hwnd,QWL_USER);
    966   INT         tempsortFlags;
    967 
    968   switch(msg) {
    969     case DM_PRINTOBJECT:
    970       return MRFROMLONG(DRR_TARGET);
    971 
    972     case DM_DISCARDOBJECT:
    973       if(dcd)
    974         return WinSendMsg(dcd->hwndObject,msg,mp1,mp2);
    975       else
    976         return MRFROMLONG(DRR_TARGET);
    977 
    978     case WM_CHAR:
    979       shiftstate = (SHORT1FROMMP(mp1) & (KC_SHIFT | KC_ALT | KC_CTRL));
    980       if(SHORT1FROMMP(mp1) & KC_KEYUP)
    981         return (MRESULT)TRUE;
    982       if(SHORT1FROMMP(mp1) & KC_VIRTUALKEY) {
    983         switch(SHORT2FROMMP(mp2)) {
    984           case VK_DELETE:
    985             if((shiftstate & KC_CTRL) == KC_CTRL)
    986               PostMsg(hwnd,WM_COMMAND,MPFROM2SHORT(IDM_PERMDELETE,0),MPVOID);
    987             else if((shiftstate & KC_SHIFT) == KC_SHIFT)
    988               PostMsg(hwnd,WM_COMMAND,MPFROM2SHORT(IDM_SAVETOCLIP,0),MPVOID);
    989             else
    990               PostMsg(hwnd,WM_COMMAND,MPFROM2SHORT(IDM_DELETE,0),MPVOID);
    991             break;
    992         }
    993       }
    994       if(shiftstate || fNoSearch)
    995         break;
    996       if(SHORT1FROMMP(mp1) & KC_CHAR) {
    997 
    998         ULONG        thistime,len;
    999         SEARCHSTRING srch;
    1000         PCNRITEM     pci;
    1001 
    1002         if(!dcd)
    1003           break;
    1004         switch(SHORT1FROMMP(mp2)) {
    1005           case '\x1b':
    1006           case '\r':
    1007           case '\n':
    1008             dcd->lasttime = 0;
    1009             *dcd->szCommonName = 0;
    1010             break;
    1011           default:
    1012             thistime = WinQueryMsgTime(WinQueryAnchorBlock(hwnd));
    1013             if(thistime > dcd->lasttime + 1250)
    1014               *dcd->szCommonName = 0;
    1015             dcd->lasttime = thistime;
    1016             if(SHORT1FROMMP(mp2) == ' ' && !dcd->szCommonName)
    1017               break;
    1018 KbdRetry:
    1019             len = strlen(dcd->szCommonName);
    1020             if(len >= CCHMAXPATH - 1) {
    1021               *dcd->szCommonName = 0;
    1022               len = 0;
    1023             }
    1024             dcd->szCommonName[len] = toupper(SHORT1FROMMP(mp2));
    1025             dcd->szCommonName[len + 1] = 0;
    1026             memset(&srch,0,sizeof(SEARCHSTRING));
    1027             srch.cb = (ULONG)sizeof(SEARCHSTRING);
    1028             srch.pszSearch = (PSZ)dcd->szCommonName;
    1029             srch.fsPrefix = TRUE;
    1030             srch.fsCaseSensitive = FALSE;
    1031             srch.usView = CV_ICON;
    1032             pci = WinSendMsg(hwnd,CM_SEARCHSTRING,MPFROMP(&srch),
    1033                              MPFROMLONG(CMA_FIRST));
    1034             if(pci && (INT)pci != -1) {
    1035 
    1036               USHORT          attrib = CRA_CURSORED;
    1037 
    1038               /* make found item current item */
    1039               if(!stricmp(pci->pszFileName,dcd->szCommonName))
    1040                 attrib |= CRA_SELECTED;
    1041               WinSendMsg(hwnd,CM_SETRECORDEMPHASIS,MPFROMP(pci),
    1042                          MPFROM2SHORT(TRUE,attrib));
    1043               /* make sure that record shows in viewport */
    1044               ShowCnrRecord(hwnd,(PMINIRECORDCORE)pci);
    1045               return (MRESULT)TRUE;
    1046             }
    1047             else {
    1048               if(SHORT1FROMMP(mp2) == ' ') {
    1049                 dcd->szCommonName[len] = 0;
    1050                 break;
    1051               }
    1052               *dcd->szCommonName = 0;
    1053               dcd->lasttime = 0;
    1054               if(len)           // retry as first letter if no match
    1055                 goto KbdRetry;
    1056             }
    1057             break;
    1058         }
    1059       }
    1060       break;
    1061 
    1062     case WM_MOUSEMOVE:
    1063     case WM_BUTTON1UP:
    1064     case WM_BUTTON2UP:
    1065     case WM_BUTTON3UP:
    1066     case WM_CHORD:
    1067       shiftstate = (SHORT2FROMMP(mp2) & (KC_SHIFT | KC_ALT | KC_CTRL));
    1068       break;
    1069 
    1070     case WM_BUTTON1MOTIONEND:
    1071       {
    1072         CNRINFO cnri;
    1073 
    1074         memset(&cnri,0,sizeof(CNRINFO));
    1075         cnri.cb = sizeof(CNRINFO);
    1076         if(WinSendMsg(hwnd,CM_QUERYCNRINFO,MPFROMP(&cnri),
    1077                       MPFROMLONG(sizeof(CNRINFO)))) {
    1078           if(cnri.flWindowAttr & CV_DETAIL)
    1079             PrfWriteProfileData(fmprof,appname,"CollectorCnrSplitBar",
    1080                                 (PVOID)&cnri.xVertSplitbar,sizeof(LONG));
    1081         }
    1082       }
    1083       break;
    1084 
    1085     case WM_PRESPARAMCHANGED:
    1086       PresParamChanged(hwnd,"Collector",mp1,mp2);
    1087       break;
    1088 
    1089     case UM_COMPARE:
    1090       if(dcd && mp1 && mp2) {
    1091 
    1092         COMPARE *cmp;
    1093         CHAR    *leftdir = (CHAR *)mp1,*rightdir = (CHAR *)mp2;
    1094 
    1095         if(!IsFile(leftdir) && !IsFile(rightdir)) {
    1096           cmp = malloc(sizeof(COMPARE));
    1097           if(cmp) {
    1098             memset(cmp,0,sizeof(COMPARE));
    1099             cmp->size = sizeof(COMPARE);
    1100             strcpy(cmp->leftdir,leftdir);
    1101             strcpy(cmp->rightdir,rightdir);
    1102             cmp->hwndParent = dcd->hwndParent;
    1103             cmp->dcd.hwndParent = dcd->hwndParent;
    1104             WinDlgBox(HWND_DESKTOP,HWND_DESKTOP,CompareDlgProc,
    1105                       FM3ModHandle,COMP_FRAME,MPFROMP(cmp));
    1106           }
    1107         }
    1108       }
    1109       return 0;
    1110 
    1111     case UM_UPDATERECORDLIST:
    1112       if(dcd && mp1)
    1113         WinSendMsg(dcd->hwndObject,msg,mp1,mp2);
    1114       return 0;
    1115 
    1116     case UM_UPDATERECORD:
    1117       if(dcd && mp1) {
    1118 
    1119         CHAR *filename;
    1120 
    1121         filename = mp1;
    1122         if(filename)
    1123           UpdateCnrRecord(hwnd,filename,TRUE,dcd);
    1124       }
    1125       return 0;
    1126 
    1127     case WM_SETFOCUS:
    1128       /*
    1129        * put name of our window on status line
    1130        */
    1131       if(dcd && hwndStatus && mp2) {
    1132 
    1133         PCNRITEM pci = NULL;
    1134 
    1135         if(fAutoView && hwndMain) {
    1136           pci = WinSendMsg(hwnd,
    1137                            CM_QUERYRECORDEMPHASIS,
    1138                            MPFROMLONG(CMA_FIRST),
    1139                            MPFROMSHORT(CRA_CURSORED));
    1140           if(pci && (INT)pci != -1 &&
    1141              (!(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_SLOW)))
    1142             WinSendMsg(hwndMain,
    1143                        UM_LOADFILE,
    1144                        MPFROMP(pci->szFileName),
    1145                        MPVOID);
    1146           else
    1147             WinSendMsg(hwndMain,
    1148                        UM_LOADFILE,
    1149                        MPVOID,
    1150                        MPVOID);
    1151         }
    1152         if(dcd->amextracted)
    1153           WinSetWindowText(hwndStatus2,
    1154                            GetPString(IDS_INSEEKSCANTEXT));
    1155         WinSendMsg(hwnd,
    1156                    UM_RESCAN,
    1157                    MPVOID,
    1158                    MPVOID);
    1159       }
    1160       break;
    1161 
    1162     case UM_RESCAN:
    1163       if(dcd) {
    1164 
    1165         CNRINFO  cnri;
    1166         CHAR     s[CCHMAXPATH + 69],tb[81],tf[81],*p;
    1167         PCNRITEM pci = NULL;
    1168 
    1169         memset(&cnri,0,sizeof(CNRINFO));
    1170         cnri.cb = sizeof(CNRINFO);
    1171         WinSendMsg(hwnd,CM_QUERYCNRINFO,MPFROMP(&cnri),
    1172                    MPFROMLONG(sizeof(CNRINFO)));
    1173         dcd->totalfiles = cnri.cRecords;
    1174         commafmt(tf,sizeof(tf),dcd->totalfiles);
    1175         CommaFmtULL(tb,sizeof(tb),dcd->ullTotalBytes,' ');
    1176         sprintf(s,"%s / %s",tf,tb);
    1177         WinSetDlgItemText(dcd->hwndClient,DIR_TOTALS,s);
    1178 
    1179         commafmt(tf,sizeof(tf),dcd->selectedfiles);
    1180         CommaFmtULL(tb,sizeof(tb),dcd->selectedbytes,' ');
    1181         sprintf(s,"%s / %s",tf,tb);
    1182         WinSetDlgItemText(dcd->hwndClient,DIR_SELECTED,s);
    1183 
    1184         if(hwndStatus &&
    1185            dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent)) {
    1186           if(hwndMain) {
    1187             pci = WinSendMsg(hwnd,CM_QUERYRECORDEMPHASIS,
    1188                              MPFROMLONG(CMA_FIRST),
    1189                              MPFROMSHORT(CRA_CURSORED));
    1190             if(pci && (INT)pci != -1)
    1191               PostMsg(hwndMain,UM_LOADFILE,MPFROMP(pci->szFileName),MPVOID);
    1192             else
    1193               PostMsg(hwndMain,UM_LOADFILE,MPVOID,MPVOID);
    1194           }
    1195           if(!fMoreButtons)
    1196             sprintf(s," %s%s%s%s",GetPString(IDS_COLLECTORTEXT),
    1197                     (*dcd->mask.szMask || dcd->mask.antiattr ||
    1198                      dcd->mask.attrFile != ALLATTRS) ? "  (" : NullStr,
    1199                     (*dcd->mask.szMask) ? dcd->mask.szMask :
    1200                      (dcd->mask.antiattr ||
    1201                       dcd->mask.attrFile != ALLATTRS) ?
    1202                        GetPString(IDS_ATTRTEXT) : NullStr,
    1203                     (*dcd->mask.szMask || dcd->mask.antiattr ||
    1204                      dcd->mask.attrFile != ALLATTRS) ? ")" : NullStr);
    1205           else
    1206             strcpy(s,GetPString(IDS_COLLECTORTEXT));
    1207           WinSetWindowText(hwndStatus,s);
    1208           if(!pci)
    1209             pci = WinSendMsg(hwnd,CM_QUERYRECORDEMPHASIS,
    1210                              MPFROMLONG(CMA_FIRST),
    1211                              MPFROMSHORT(CRA_CURSORED));
    1212           if(pci && (INT)pci != -1) {
    1213             if(fSplitStatus && hwndStatus2) {
    1214               if(pci->attrFile & FILE_DIRECTORY)
    1215                 p = pci->pszFileName;
    1216               else {
    1217                 p = strrchr(pci->szFileName,'\\');
    1218                 if(p) {
    1219                   if(*(p + 1))
    1220                     p++;
    1221                   else
    1222                     p = pci->pszFileName;
    1223                 }
    1224                 else
    1225                   p = pci->pszFileName;
    1226               }
    1227               CommaFmtULL(tb,sizeof(tb),pci->cbFile + pci->easize,' ');
    1228               if(!fMoreButtons)
    1229               {
    1230                 sprintf(s," %s  %04u/%02u/%02u %02u:%02u:%02u  [%s]  %s",
    1231                         tb,pci->date.year,pci->date.month,
    1232                         pci->date.day,pci->time.hours,pci->time.minutes,
    1233                         pci->time.seconds,pci->pszDispAttr,p);
    1234               }
    1235               else
    1236               {
    1237                 if(pci->cbFile + pci->easize > 1024)
    1238                   CommaFmtULL(tf,sizeof(tf),pci->cbFile + pci->easize, 'K');
    1239                 else
    1240                   *tf = 0;
    1241                 sprintf(s,GetPString(IDS_STATUSSIZETEXT),
    1242                         tb,
    1243                         *tf ? " (" : NullStr,
    1244                         tf,
    1245                         *tf ? ")" : NullStr);
    1246               }
    1247               WinSetWindowText(hwndStatus2,s);
    1248             }
    1249             if(fMoreButtons) {
    1250               WinSetWindowText(hwndName,pci->pszFileName);
    1251               sprintf(s,"%04u/%02u/%02u %02u:%02u:%02u",
    1252                       pci->date.year,pci->date.month,
    1253                       pci->date.day,pci->time.hours,pci->time.minutes,
    1254                       pci->time.seconds);
    1255               WinSetWindowText(hwndDate,s);
    1256               WinSetWindowText(hwndAttr,pci->pszDispAttr);
    1257             }
    1258             if(dcd->amextracted && hwndStatus2)
    1259               WinSetWindowText(hwndStatus2,GetPString(IDS_INSEEKSCANTEXT));
    1260           }
    1261           else {
    1262             if(hwndStatus2)
    1263               WinSetWindowText(hwndStatus2,NullStr);
    1264             if(fMoreButtons) {
    1265               WinSetWindowText(hwndName,NullStr);
    1266               WinSetWindowText(hwndDate,NullStr);
    1267               WinSetWindowText(hwndAttr,NullStr);
    1268             }
    1269           }
    1270         }
    1271       }
    1272       return 0;
    1273 
    1274     case UM_CONTAINER_FILLED:
    1275       DosBeep(1000,50);
    1276       WinSendMsg(hwnd,
    1277                  CM_INVALIDATERECORD,
    1278                  MPVOID,
    1279                  MPFROM2SHORT(0,CMA_ERASE | CMA_REPOSITION));
    1280       WinSendMsg(CollectorCnrMenu,
    1281                  MM_SETITEMATTR,
    1282                  MPFROM2SHORT(DID_CANCEL,TRUE),
    1283                  MPFROM2SHORT(MIA_DISABLED,MIA_DISABLED));
    1284       WinSendMsg(CollectorCnrMenu,
    1285                  MM_SETITEMATTR,
    1286                  MPFROM2SHORT(IDM_GREP,TRUE),
    1287                  MPFROM2SHORT(MIA_DISABLED,0));
    1288       PostMsg(hwnd,
    1289               UM_RESCAN,
    1290               MPVOID,
    1291               MPVOID);
    1292       if(dcd) {
    1293         dcd->stopflag = 0;
    1294         dcd->amextracted = FALSE;
    1295         if(dcd->namecanchange) {
    1296           if(!PostMsg(hwnd,
    1297                       WM_CLOSE,
    1298                       MPVOID,
    1299                       MPVOID))
    1300             WinSendMsg(hwnd,
    1301                        WM_CLOSE,
    1302                        MPVOID,
    1303                        MPVOID);
    1304         }
    1305         else
    1306           WinSetWindowPos(WinQueryWindow(WinQueryWindow(hwnd,QW_PARENT),
    1307                                          QW_PARENT),
    1308                                          HWND_TOP,
    1309                                          0,
    1310                                          0,
    1311                                          0,
    1312                                          0,
    1313                                          SWP_SHOW | SWP_RESTORE | SWP_ZORDER);
    1314       }
    1315       return 0;
    1316 
    1317     case UM_SETUP:
    1318       if(dcd) {
    1319         if(!dcd->hwndObject) {
    1320           /*
    1321            * first time through -- set things up
    1322            */
    1323 
    1324           CNRINFO cnri;
    1325 
    1326           RestorePresParams(hwnd,"Collector");
    1327           LoadDetailsSwitches("Collector",dcd);
    1328           WinSendMsg(CollectorCnrMenu,MM_SETITEMATTR,
    1329                      MPFROM2SHORT(DID_CANCEL,TRUE),
    1330                      MPFROM2SHORT(MIA_DISABLED,MIA_DISABLED));
    1331           WinSendMsg(CollectorCnrMenu,MM_SETITEMATTR,MPFROM2SHORT(IDM_GREP,TRUE),
    1332                      MPFROM2SHORT(MIA_DISABLED,0));
    1333           dcd->amextracted = FALSE;
    1334           dcd->stopflag = 0;
    1335           memset(&cnri,0,sizeof(CNRINFO));
    1336           cnri.cb = sizeof(CNRINFO);
    1337           WinSendMsg(hwnd,CM_QUERYCNRINFO,MPFROMP(&cnri),
    1338                      MPFROMLONG(sizeof(CNRINFO)));
    1339           cnri.cyLineSpacing = 0;
    1340           cnri.cxTreeIndent = 12L;
    1341 
    1342           cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT |
    1343                                   CV_DETAIL));
    1344           cnri.flWindowAttr |= (CV_NAME | CA_DETAILSVIEWTITLES |
    1345                                 CV_MINI | CV_FLOW);
    1346           cnri.pSortRecord = (PVOID)SortCollectorCnr;
    1347 
    1348           {
    1349             ULONG size = sizeof(ULONG);
    1350 
    1351             PrfQueryProfileData(fmprof,appname,"CollectorflWindowAttr",
    1352                                 (PVOID)&cnri.flWindowAttr,&size);
    1353             size = sizeof(MASK);
    1354             if(PrfQueryProfileSize(fmprof,appname,"CollectorFilter",&size) &&
    1355                size) {
    1356               PrfQueryProfileData(fmprof,appname,"CollectorFilter",&dcd->mask,
    1357                                   &size);
    1358               SetMask(dcd->mask.szMask,&dcd->mask);
    1359             }
    1360             else {
    1361               dcd->mask.attrFile = (FILE_NORMAL | FILE_READONLY |
    1362                                     FILE_DIRECTORY | FILE_HIDDEN |
    1363                                     FILE_SYSTEM | FILE_ARCHIVED);
    1364               dcd->mask.antiattr = 0;
    1365             }
    1366             *(dcd->mask.prompt) = 0;
    1367           }
    1368           cnri.flWindowAttr |= CV_FLOW;
    1369           cnri.flWindowAttr &= (~(CA_MIXEDTARGETEMPH | CA_ORDEREDTARGETEMPH));
    1370           dcd->flWindowAttr = cnri.flWindowAttr;
    1371           WinSendMsg(hwnd,CM_SETCNRINFO,MPFROMP(&cnri),
    1372                      MPFROMLONG(CMA_FLWINDOWATTR | CMA_LINESPACING |
    1373                                 CMA_CXTREEINDENT | CMA_PSORTRECORD));
    1374           SetCnrCols(hwnd,FALSE);
    1375           AdjustCnrColsForPref(hwnd,NULL,dcd,FALSE);
    1376           { /* fix splitbar for collector container */
    1377             ULONG    size;
    1378 
    1379             cnri.xVertSplitbar  = DIR_SPLITBAR_OFFSET - 32;
    1380             size = sizeof(LONG);
    1381             PrfQueryProfileData(fmprof,appname,"CollectorCnrSplitBar",
    1382                                 &cnri.xVertSplitbar,&size);
    1383             if(cnri.xVertSplitbar <= 0)
    1384               cnri.xVertSplitbar = DIR_SPLITBAR_OFFSET - 32;
    1385             WinSendMsg(hwnd,CM_SETCNRINFO, MPFROMP(&cnri),
    1386                        MPFROMLONG(CMA_XVERTSPLITBAR));
    1387           }
    1388           if(_beginthread(MakeObjWin,NULL,245760,(PVOID)dcd) == -1) {
    1389             PostMsg(hwnd,WM_CLOSE,MPVOID,MPVOID);
    1390             return 0;
    1391           }
    1392           else
    1393             DosSleep(64L);
    1394         }
    1395         SayFilter(WinWindowFromID(WinQueryWindow(hwnd,QW_PARENT),
    1396                                   DIR_FILTER),&dcd->mask,FALSE);
    1397         SaySort(WinWindowFromID(WinQueryWindow(hwnd,QW_PARENT),
    1398                                 DIR_SORT),CollectorsortFlags,FALSE);
    1399         SayView(WinWindowFromID(WinQueryWindow(hwnd,QW_PARENT),
    1400                                 DIR_VIEW),dcd->flWindowAttr);
    1401       }
    1402       else {
    1403         PostMsg(hwnd,WM_CLOSE,MPVOID,MPVOID);
    1404         return 0;
    1405       }
    1406       return 0;
    1407 
    1408     case WM_MENUEND:
    1409       if(dcd) {
    1410 
    1411         HWND hwndMenu = (HWND)mp2;
    1412 
    1413         if(hwndMenu == CollectorCnrMenu || hwndMenu == CollectorFileMenu ||
    1414            hwndMenu == CollectorDirMenu) {
    1415           MarkAll(hwnd,TRUE,FALSE,TRUE);
    1416           if(dcd->cnremphasized) {
    1417             WinSendMsg(hwnd,CM_SETRECORDEMPHASIS,MPVOID,
    1418                        MPFROM2SHORT(FALSE,CRA_SOURCE));
    1419             dcd->cnremphasized = FALSE;
    1420           }
    1421         }
    1422       }
    1423       break;
    1424 
    1425     case UM_OPENWINDOWFORME:
    1426       if(dcd) {
    1427         if(mp1 &&
    1428            !IsFile((CHAR *)mp1))
    1429           OpenDirCnr((HWND)0,
    1430                      hwndMain,
    1431                      dcd->hwndFrame,
    1432                      FALSE,
    1433                      (char *)mp1);
    1434         else if(mp1 &&
    1435                 IsFile(mp1) == 1)
    1436           StartArcCnr(HWND_DESKTOP,
    1437                       dcd->hwndFrame,
    1438                       (CHAR *)mp1,
    1439                       4,
    1440                       (ARC_TYPE *)mp2);
    1441       }
    1442       return 0;
    1443 
    1444     case MM_PORTHOLEINIT:
    1445       if(dcd) {
    1446         switch(SHORT1FROMMP(mp1)) {
    1447           case 0:
    1448           case 1:
    1449             {
    1450               ULONG wmsg;
    1451 
    1452               wmsg = (SHORT1FROMMP(mp1) == 0) ? UM_FILESMENU : UM_VIEWSMENU;
    1453               PortholeInit((HWND)WinSendMsg(dcd->hwndClient,wmsg,MPVOID,
    1454                                             MPVOID),mp1,mp2);
    1455             }
    1456             break;
    1457         }
    1458       }
    1459       break;
    1460 
    1461     case UM_INITMENU:
    1462     case WM_INITMENU:
    1463       if(dcd) {
    1464         switch(SHORT1FROMMP(mp1)) {
    1465           case IDM_VIEWSMENU:
    1466             SetViewMenu((HWND)mp2,dcd->flWindowAttr);
    1467             WinEnableMenuItem((HWND)mp2,IDM_RESELECT,
    1468                               (dcd->lastselection != NULL));
    1469             break;
    1470 
    1471           case IDM_DETAILSSETUP:
    1472             SetDetailsSwitches((HWND)mp2,dcd);
    1473             break;
    1474 
    1475           case IDM_COMMANDSMENU:
    1476             SetupCommandMenu((HWND)mp2,hwnd);
    1477             break;
    1478 
    1479           case IDM_SORTSUBMENU:
    1480             SetSortChecks((HWND)mp2,CollectorsortFlags);
    1481             break;
    1482         }
    1483         dcd->hwndLastMenu = (HWND)mp2;
    1484       }
    1485       if(msg == WM_INITMENU)
    1486         break;
    1487       return 0;
    1488 
    1489     case UM_COLLECTFROMFILE:
    1490       if(mp1) {
    1491         if(dcd) {
    1492           if(!PostMsg(dcd->hwndObject,UM_COLLECTFROMFILE,mp1,mp2)) {
    1493             free(mp1);
    1494             DosBeep(50,100);
    1495           }
    1496         }
    1497         else
    1498           free(mp1);
    1499       }
    1500       else
    1501         free(mp1);
    1502       return 0;
    1503 
    1504 
    1505     case UM_COMMAND:
    1506       if(mp1) {
    1507         if(dcd) {
    1508           if(!PostMsg(dcd->hwndObject,UM_COMMAND,mp1,mp2)) {
    1509             FreeListInfo((LISTINFO *)mp1);
    1510             DosBeep(50,100);
    1511           }
    1512           else
    1513             return (MRESULT)TRUE;
    1514         }
    1515         else
    1516           FreeListInfo((LISTINFO *)mp1);
    1517       }
    1518       return 0;
    1519 
    1520     case UM_NOTIFY:
    1521       if(mp2)
    1522         AddNote((CHAR *)mp2);
    1523       return 0;
    1524 
    1525     case WM_COMMAND:
    1526       DosError(FERR_DISABLEHARDERR);
    1527       if(dcd) {
    1528         switch(SHORT1FROMMP(mp1)) {
    1529           case IDM_SETTARGET:
    1530             SetTargetDir(hwnd,FALSE);
    1531             break;
    1532 
    1533           case IDM_CONTEXTMENU:
    1534             {
    1535               PCNRITEM pci;
    1536 
    1537               pci = (PCNRITEM)CurrentRecord(hwnd);
    1538               PostMsg(hwnd,WM_CONTROL,MPFROM2SHORT(COLLECTOR_CNR,
    1539                       CN_CONTEXTMENU),MPFROMP(pci));
    1540             }
    1541             break;
    1542 
    1543           case IDM_SHOWALLFILES:
    1544             {
    1545               PCNRITEM pci;
    1546 
    1547               pci = WinSendMsg(hwnd,CM_QUERYRECORDEMPHASIS,
    1548                                MPFROMLONG(CMA_FIRST),
    1549                                MPFROMSHORT(CRA_CURSORED));
    1550               if(pci && (INT)pci != -1) {
    1551 
    1552                 static CHAR dirname[CCHMAXPATH];
    1553 
    1554                 strcpy(dirname,pci->szFileName);
    1555                 MakeValidDir(dirname);
    1556                 StartSeeAll(HWND_DESKTOP,FALSE,dirname);
    1557               }
    1558             }
    1559             break;
    1560 
    1561           case IDM_BEGINEDIT:
    1562             OpenEdit(hwnd);
    1563             break;
    1564 
    1565           case IDM_ENDEDIT:
    1566             WinSendMsg(hwnd,CM_CLOSEEDIT,MPVOID,MPVOID);
    1567             break;
    1568 
    1569           case IDM_SHOWSELECT:
    1570             QuickPopup(hwnd,dcd,CheckMenu(&CollectorCnrMenu,COLLECTORCNR_POPUP),
    1571                        IDM_SELECTSUBMENU);
    1572             break;
    1573 
    1574           case IDM_SHOWSORT:
    1575             QuickPopup(hwnd,dcd,CheckMenu(&CollectorCnrMenu,COLLECTORCNR_POPUP),
    1576                        IDM_SORTSUBMENU);
    1577             break;
    1578 
    1579           case IDM_VIEWORARC:
    1580             {
    1581               SWP       swp;
    1582               PCNRITEM  pci;
    1583 
    1584               pci = (PCNRITEM)WinSendMsg(hwnd,CM_QUERYRECORDEMPHASIS,
    1585                                          MPFROMLONG(CMA_FIRST),
    1586                                          MPFROMSHORT(CRA_CURSORED));
    1587               if(pci && (INT)pci != -1) {
    1588                 WinQueryWindowPos(dcd->hwndFrame,&swp);
    1589                 DefaultViewKeys(hwnd,dcd->hwndFrame,dcd->hwndParent,&swp,
    1590                                 pci->szFileName);
    1591               }
    1592             }
    1593             break;
    1594 
    1595           case IDM_SEEALL:
    1596             StartSeeAll(HWND_DESKTOP,
    1597                         FALSE,
    1598                         NULL);
    1599             break;
    1600 
    1601           case IDM_COLLECTSELECT:
    1602             {
    1603               CHAR filename[CCHMAXPATH],*p,*pp;
    1604               ULONG size;
    1605 
    1606               strcpy(filename,"*.LST");
    1607               size = CCHMAXPATH;
    1608               PrfQueryProfileData(fmprof,appname,"SaveToListName",
    1609                                   filename,&size);
    1610               pp = strrchr(filename,'\\');
    1611               if(!pp)
    1612                 pp = filename;
    1613               p = strrchr(pp,'.');
    1614               if(p && *(p + 1) && p > pp + 1) {
    1615                 if(pp > filename)
    1616                   pp++;
    1617                 *pp = '*';
    1618                 pp++;
    1619                 if(p > pp)
    1620                   memmove(pp,p,strlen(p) + 1);
    1621               }
    1622               if(insert_filename(hwnd,filename,FALSE,FALSE)) {
    1623                 p = strdup(filename);
    1624                 if(p) {
    1625                   if(!PostMsg(hwnd,UM_COLLECTFROMFILE,MPFROMP(p),MPVOID))
    1626                     free(p);
    1627                 }
    1628               }
    1629             }
    1630             break;
    1631 
    1632           case IDM_NOTEBOOK:
    1633             if(!ParentIsDesktop(dcd->hwndParent,dcd->hwndParent))
    1634               PostMsg(dcd->hwndParent,msg,mp1,mp2);
    1635             else
    1636               WinDlgBox(HWND_DESKTOP,hwnd,CfgDlgProc,FM3ModHandle,
    1637                         CFG_FRAME,(PVOID)"Collector");
    1638             break;
    1639 
    1640           case IDM_RESELECT:
    1641             SelectList(hwnd,FALSE,FALSE,FALSE,NULL,NULL,dcd->lastselection);
    1642             break;
    1643 
    1644           case IDM_HELP:
    1645             if(hwndHelp)
    1646               WinSendMsg(hwndHelp,HM_DISPLAY_HELP,
    1647                          MPFROM2SHORT(HELP_COLLECT,0),
    1648                          MPFROMSHORT(HM_RESOURCEID));
    1649             break;
    1650 
    1651           case IDM_SORTNONE:
    1652           case IDM_SORTSMARTNAME:
    1653           case IDM_SORTNAME:
    1654           case IDM_SORTFILENAME:
    1655           case IDM_SORTSIZE:
    1656           case IDM_SORTEASIZE:
    1657           case IDM_SORTFIRST:
    1658           case IDM_SORTLAST:
    1659           case IDM_SORTLWDATE:
    1660           case IDM_SORTLADATE:
    1661           case IDM_SORTCRDATE:
    1662           case IDM_SORTSUBJECT:
    1663             tempsortFlags = CollectorsortFlags;
    1664             CollectorsortFlags &= (SORT_REVERSE | SORT_DIRSFIRST | SORT_DIRSLAST);
    1665           case IDM_SORTDIRSFIRST:
    1666           case IDM_SORTDIRSLAST:
    1667           case IDM_SORTREVERSE:
    1668             switch(SHORT1FROMMP(mp1)) {
    1669               case IDM_SORTSUBJECT:
    1670                 CollectorsortFlags |= SORT_SUBJECT;
    1671                 break;
    1672               case IDM_SORTNONE:
    1673                 CollectorsortFlags |= SORT_NOSORT;
    1674                 break;
    1675               case IDM_SORTSMARTNAME:
    1676                 if(!(tempsortFlags & SORT_FILENAME))
    1677                   CollectorsortFlags |= SORT_FILENAME;
    1678                 break;
    1679               case IDM_SORTFILENAME:
    1680                 CollectorsortFlags |= SORT_FILENAME;
    1681                 break;
    1682               case IDM_SORTSIZE:
    1683                 CollectorsortFlags |= SORT_SIZE;
    1684                 break;
    1685               case IDM_SORTEASIZE:
    1686                 CollectorsortFlags |= SORT_EASIZE;
    1687                 break;
    1688               case IDM_SORTFIRST:
    1689                 CollectorsortFlags |= SORT_FIRSTEXTENSION;
    1690                 break;
    1691               case IDM_SORTLAST:
    1692                 CollectorsortFlags |= SORT_LASTEXTENSION;
    1693                 break;
    1694               case IDM_SORTLWDATE:
    1695                 CollectorsortFlags |= SORT_LWDATE;
    1696                 break;
    1697               case IDM_SORTLADATE:
    1698                 CollectorsortFlags |= SORT_LADATE;
    1699                 break;
    1700               case IDM_SORTCRDATE:
    1701                 CollectorsortFlags |= SORT_CRDATE;
    1702                 break;
    1703               case IDM_SORTDIRSFIRST:
    1704                 if(CollectorsortFlags & SORT_DIRSFIRST)
    1705                   CollectorsortFlags &= (~SORT_DIRSFIRST);
    1706                 else {
    1707                   CollectorsortFlags |= SORT_DIRSFIRST;
    1708                   CollectorsortFlags &= (~SORT_DIRSLAST);
    1709                 }
    1710                 break;
    1711               case IDM_SORTDIRSLAST:
    1712                 if(CollectorsortFlags & SORT_DIRSLAST)
    1713                   CollectorsortFlags &= (~SORT_DIRSLAST);
    1714                 else {
    1715                   CollectorsortFlags |= SORT_DIRSLAST;
    1716                   CollectorsortFlags &= (~SORT_DIRSFIRST);
    1717                 }
    1718                 break;
    1719               case IDM_SORTREVERSE:
    1720                 if(CollectorsortFlags & SORT_REVERSE)
    1721                   CollectorsortFlags &= (~SORT_REVERSE);
    1722                 else
    1723                   CollectorsortFlags |= SORT_REVERSE;
    1724                 break;
    1725             }
    1726             PrfWriteProfileData(fmprof,appname,"CollectorSort",
    1727                                 &CollectorsortFlags,sizeof(INT));
    1728             WinSendMsg(hwnd,CM_SORTRECORD,MPFROMP(SortCollectorCnr),MPVOID);
    1729             SaySort(WinWindowFromID(WinQueryWindow(hwnd,QW_PARENT),
    1730                     DIR_SORT),CollectorsortFlags,FALSE);
    1731             break;
    1732 
    1733           case IDM_COLLECTFROMCLIP:
    1734             {
    1735 
    1736               LISTINFO *li;
    1737 
    1738               li = malloc(sizeof(LISTINFO));
    1739               if(li) {
    1740                 memset(li,0,sizeof(LISTINFO));
    1741                 li->list = ListFromClipboard(hwnd);
    1742                 if(!li->list || !li->list[0])
    1743                   FreeListInfo(li);
    1744                 else {
    1745                   li->type = IDM_COLLECT;
    1746                   if(!PostMsg(dcd->hwndObject,UM_COLLECT,MPFROMP(li),
    1747                                  MPVOID))
    1748                     FreeListInfo(li);
    1749                 }
    1750               }
    1751             }
    1752             break;
    1753 
    1754           case IDM_REMOVE:
    1755             if(fAutoView &&
    1756                hwndMain)
    1757               PostMsg(hwndMain,
    1758                       UM_LOADFILE,
    1759                       MPVOID,
    1760                       MPVOID);
    1761             dcd->suspendview = 1;
    1762             RemoveAll(hwnd,
    1763                       &dcd->ullTotalBytes,
    1764                       &dcd->totalfiles);
    1765             dcd->suspendview = 0;
    1766             PostMsg(hwnd,
    1767                     UM_RESCAN,
    1768                     MPVOID,
    1769                     MPVOID);
    1770             break;
    1771 
    1772           case IDM_CLEARCNR:
    1773             {
    1774               PCNRITEM pci;
    1775 
    1776               pci = (PCNRITEM)WinSendMsg(hwnd,
    1777                                          CM_QUERYRECORD,
    1778                                          MPVOID,
    1779                                          MPFROM2SHORT(CMA_FIRST,
    1780                                                       CMA_ITEMORDER));
    1781               if(pci && (INT)pci != -1) {
    1782                 WinSendMsg(hwnd,
    1783                            CM_REMOVERECORD,
    1784                            MPVOID,
    1785                            MPFROM2SHORT(0,CMA_FREE | CMA_INVALIDATE));
    1786                 dcd->ullTotalBytes = dcd->selectedbytes = dcd->selectedfiles =
    1787                   dcd->totalfiles = 0L;
    1788                 PostMsg(hwnd,
    1789                         UM_RESCAN,
    1790                         MPVOID,
    1791                         MPVOID);
    1792               }
    1793             }
    1794             break;
    1795 
    1796           case DID_CANCEL:
    1797             if(dcd->amextracted)
    1798               dcd->stopflag = 1;
    1799             break;
    1800 
    1801           case IDM_COLLECTOR:
    1802             if(mp2) {
    1803 
    1804               LISTINFO *li;
    1805 
    1806               li = malloc(sizeof(LISTINFO));
    1807               if(li) {
    1808                 memset(li,0,sizeof(LISTINFO));
    1809                 li->list = mp2;
    1810                 if(!li->list || !li->list[0])
    1811                   FreeListInfo(li);
    1812                 else {
    1813                   li->type = IDM_COLLECT;
    1814                   if(!PostMsg(dcd->hwndObject,UM_COLLECT,MPFROMP(li),
    1815                                  MPVOID))
    1816                     FreeListInfo(li);
    1817                 }
    1818               }
    1819               else
    1820                 FreeList(mp2);
    1821             }
    1822             break;
    1823 
    1824           case IDM_UNDELETE:
    1825             {
    1826               PCNRITEM pci;
    1827               CHAR     path[CCHMAXPATH];
    1828 
    1829               pci = (PCNRITEM)CurrentRecord(hwnd);
    1830               if(pci) {
    1831                 strcpy(path,pci->szFileName);
    1832                 MakeValidDir(path);
    1833                 WinDlgBox(HWND_DESKTOP,hwnd,UndeleteDlgProc,FM3ModHandle,
    1834                           UNDEL_FRAME,MPFROMP(path));
    1835               }
    1836             }
    1837             break;
    1838 
    1839           case IDM_GREP:
    1840             if(!dcd->amextracted) {
    1841               if(WinDlgBox(HWND_DESKTOP,hwnd,GrepDlgProc,
    1842                            FM3ModHandle,GREP_FRAME,(PVOID)&hwnd)) {
    1843                 dcd->amextracted = TRUE;
    1844                 WinSendMsg(CollectorCnrMenu,MM_SETITEMATTR,
    1845                            MPFROM2SHORT(DID_CANCEL,TRUE),
    1846                            MPFROM2SHORT(MIA_DISABLED,0));
    1847                 WinSendMsg(CollectorCnrMenu,MM_SETITEMATTR,
    1848                            MPFROM2SHORT(IDM_GREP,TRUE),
    1849                            MPFROM2SHORT(MIA_DISABLED,MIA_DISABLED));
    1850                 PostMsg(hwnd,UM_RESCAN,MPVOID,MPVOID);
    1851               }
    1852             }
    1853             else
    1854               DosBeep(50,100);
    1855             break;
    1856 
    1857           case IDM_RESORT:
    1858             WinSendMsg(hwnd,CM_SORTRECORD,MPFROMP(SortCollectorCnr),MPVOID);
    1859             break;
    1860 
    1861           case IDM_FILTER:
    1862             {
    1863               BOOL     empty = FALSE;
    1864               PCNRITEM pci;
    1865               CHAR    *p;
    1866 
    1867               if(!*dcd->mask.szMask) {
    1868                 empty = TRUE;
    1869                 pci = (PCNRITEM)CurrentRecord(hwnd);
    1870                 if(pci && !(pci->attrFile & FILE_DIRECTORY)) {
    1871                   p = strrchr(pci->szFileName,'\\');
    1872                   if(p) {
    1873                     p++;
    1874                     strcpy(dcd->mask.szMask,p);
    1875                   }
    1876                 }
    1877               }
    1878               *(dcd->mask.prompt) = 0;
    1879 
    1880               if(WinDlgBox(HWND_DESKTOP,hwnd,PickMaskDlgProc,
    1881                            FM3ModHandle,MSK_FRAME,MPFROMP(&dcd->mask))) {
    1882                 PrfWriteProfileData(fmprof,appname,"CollectorFilter",&dcd->mask,
    1883                                     sizeof(MASK));
    1884                 dcd->suspendview = 1;
    1885                 WinSendMsg(hwnd,CM_FILTER,MPFROMP(Filter),MPFROMP(&dcd->mask));
    1886                 dcd->suspendview = 0;
    1887                 if(fAutoView && hwndMain) {
    1888                   pci = WinSendMsg(hwnd,CM_QUERYRECORDEMPHASIS,
    1889                                    MPFROMLONG(CMA_FIRST),
    1890                                    MPFROMSHORT(CRA_CURSORED));
    1891                   if(pci && (INT)pci != -1 &&
    1892                      (!(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_SLOW)))
    1893                     WinSendMsg(hwndMain,UM_LOADFILE,MPFROMP(pci->szFileName),
    1894                                MPVOID);
    1895                   else
    1896                     WinSendMsg(hwndMain,UM_LOADFILE,MPVOID,MPVOID);
    1897                 }
    1898                 PostMsg(hwnd,UM_RESCAN,MPVOID,MPVOID);
    1899               }
    1900               else if(empty)
    1901                 *dcd->mask.szMask = 0;
    1902               SayFilter(WinWindowFromID(WinQueryWindow(hwnd,QW_PARENT),
    1903                         DIR_FILTER),&dcd->mask,FALSE);
    1904             }
    1905             break;
    1906 
    1907           case IDM_HIDEALL:
    1908             if(fAutoView && hwndMain)
    1909               PostMsg(hwndMain,UM_LOADFILE,MPVOID,MPVOID);
    1910             dcd->suspendview = 1;
    1911             HideAll(hwnd);
    1912             dcd->suspendview = 0;
    1913             PostMsg(hwnd,UM_RESCAN,MPVOID,MPVOID);
    1914             break;
    1915 
    1916           case IDM_SELECTLIST:
    1917           case IDM_SELECTALL:
    1918           case IDM_DESELECTALL:
    1919           case IDM_SELECTALLFILES:
    1920           case IDM_DESELECTALLFILES:
    1921           case IDM_SELECTALLDIRS:
    1922           case IDM_DESELECTALLDIRS:
    1923           case IDM_SELECTMASK:
    1924           case IDM_DESELECTMASK:
    1925           case IDM_INVERT:
    1926           case IDM_SELECTCLIP:
    1927           case IDM_DESELECTCLIP:
    1928             {
    1929               PCNRITEM pci;
    1930 
    1931               pci = (PCNRITEM)CurrentRecord(hwnd);
    1932               if((INT)pci == -1)
    1933                 pci = NULL;
    1934               if(SHORT1FROMMP(mp1) == IDM_HIDEALL) {
    1935                 if(pci) {
    1936                   if(!(pci->rc.flRecordAttr & CRA_SELECTED))
    1937                     pci->rc.flRecordAttr |= CRA_FILTERED;
    1938                     WinSendMsg(hwnd,CM_INVALIDATERECORD,MPFROMP(&pci),
    1939                                MPFROM2SHORT(1,CMA_ERASE | CMA_REPOSITION));
    1940                     break;
    1941                 }
    1942               }
    1943               PostMsg(dcd->hwndObject,UM_SELECT,mp1,MPFROMP(pci));
    1944             }
    1945             break;
    1946 
    1947           case IDM_RESCAN:
    1948             PostMsg(dcd->hwndObject,UM_RESCAN,MPVOID,MPVOID);
    1949             break;
    1950 
    1951           case IDM_SHOWLNAMES:
    1952           case IDM_SHOWSUBJECT:
    1953           case IDM_SHOWEAS:
    1954           case IDM_SHOWSIZE:
    1955           case IDM_SHOWICON:
    1956           case IDM_SHOWLWDATE:
    1957           case IDM_SHOWLWTIME:
    1958           case IDM_SHOWLADATE:
    1959           case IDM_SHOWLATIME:
    1960           case IDM_SHOWCRDATE:
    1961           case IDM_SHOWCRTIME:
    1962           case IDM_SHOWATTR:
    1963             AdjustDetailsSwitches(hwnd,dcd->hwndLastMenu,
    1964                                   SHORT1FROMMP(mp1),NULL,
    1965                                   "Collector",dcd,FALSE);
    1966             break;
    1967 
    1968           case IDM_ICON:
    1969           case IDM_TEXT:
    1970           case IDM_DETAILS:
    1971           case IDM_NAME:
    1972           case IDM_MINIICONS:
    1973           case IDM_DETAILSTITLES:
    1974             {
    1975               CNRINFO cnri;
    1976 
    1977               memset(&cnri,0,sizeof(CNRINFO));
    1978               cnri.cb = sizeof(CNRINFO);
    1979               WinSendMsg(hwnd,CM_QUERYCNRINFO,MPFROMP(&cnri),
    1980                          MPFROMLONG(sizeof(CNRINFO)));
    1981               switch(SHORT1FROMMP(mp1)) {
    1982                 case IDM_ICON:
    1983                   cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT |
    1984                                           CV_DETAIL | CV_NAME));
    1985                   cnri.flWindowAttr |= CV_ICON;
    1986                   break;
    1987                 case IDM_NAME:
    1988                   cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT |
    1989                                           CV_DETAIL | CV_NAME));
    1990                   cnri.flWindowAttr |= CV_NAME;
    1991                   break;
    1992                 case IDM_TEXT:
    1993                   cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT |
    1994                                           CV_DETAIL | CV_NAME));
    1995                   cnri.flWindowAttr |= CV_TEXT;
    1996                   break;
    1997                 case IDM_DETAILS:
    1998                   cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT |
    1999                                           CV_DETAIL | CV_NAME));
    2000                   cnri.flWindowAttr |= CV_DETAIL;
    2001                   break;
    2002                 case IDM_MINIICONS:
    2003                   if(cnri.flWindowAttr & CV_MINI)
    2004                     cnri.flWindowAttr &= (~CV_MINI);
    2005                   else
    2006                     cnri.flWindowAttr |= CV_MINI;
    2007                   break;
    2008                 case IDM_DETAILSTITLES:
    2009                   if(cnri.flWindowAttr & CA_DETAILSVIEWTITLES)
    2010                     cnri.flWindowAttr &= (~CA_DETAILSVIEWTITLES);
    2011                   else
    2012                     cnri.flWindowAttr |= CA_DETAILSVIEWTITLES;
    2013                   break;
    2014               }
    2015               cnri.flWindowAttr &= (~(CA_ORDEREDTARGETEMPH |
    2016                                       CA_MIXEDTARGETEMPH));
    2017               cnri.flWindowAttr |= CV_FLOW;
    2018               dcd->flWindowAttr = cnri.flWindowAttr;
    2019               PrfWriteProfileData(fmprof,appname,"CollectorflWindowAttr",
    2020                                   &cnri.flWindowAttr,sizeof(ULONG));
    2021               WinSendMsg(hwnd,CM_SETCNRINFO,MPFROMP(&cnri),
    2022                          MPFROMLONG(CMA_FLWINDOWATTR));
    2023               WinSendMsg(hwnd,CM_INVALIDATERECORD,MPVOID,
    2024                          MPFROM2SHORT(0,CMA_ERASE | CMA_REPOSITION));
    2025               SayView(WinWindowFromID(WinQueryWindow(hwnd,QW_PARENT),
    2026                       DIR_VIEW),dcd->flWindowAttr);
    2027             }
    2028             break;
    2029 
    2030           case IDM_SAVETOLIST:
    2031             WinDlgBox(HWND_DESKTOP,hwnd,SaveListDlgProc,FM3ModHandle,
    2032                       SAV_FRAME,MPFROMP(&hwnd));
    2033             break;
    2034 
    2035           case IDM_SIZES:
    2036             {
    2037               PCNRITEM pci;
    2038 
    2039               pci = (PCNRITEM)CurrentRecord(hwnd);
    2040               if(pci && (INT)pci != -1)
    2041                 WinDlgBox(HWND_DESKTOP,HWND_DESKTOP,DirSizeProc,FM3ModHandle,
    2042                           DSZ_FRAME,pci->szFileName);
    2043             }
    2044             break;
    2045 
    2046           case IDM_MKDIR:
    2047             {
    2048               PCNRITEM pci;
    2049 
    2050               pci = (PCNRITEM)CurrentRecord(hwnd);
    2051               PMMkDir(dcd->hwndParent,(pci && (INT)pci != -1) ?
    2052                       pci->szFileName : NULL,FALSE);
    2053             }
    2054             break;
    2055 
    2056           case IDM_DOITYOURSELF:
    2057           case IDM_UPDATE:
    2058           case IDM_COLLECTFROMFILE:
    2059           case IDM_OPENWINDOW:
    2060           case IDM_OPENSETTINGS:
    2061           case IDM_OPENDEFAULT:
    2062           case IDM_OPENICON:
    2063           case IDM_OPENDETAILS:
    2064           case IDM_OPENTREE:
    2065           case IDM_OBJECT:
    2066           case IDM_SHADOW:
    2067           case IDM_SHADOW2:
    2068           case IDM_DELETE:
    2069           case IDM_PERMDELETE:
    2070           case IDM_PRINT:
    2071           case IDM_ATTRS:
    2072           case IDM_INFO:
    2073           case IDM_COPY:
    2074           case IDM_MOVE:
    2075           case IDM_WPSCOPY:
    2076           case IDM_WPSMOVE:
    2077           case IDM_COPYPRESERVE:
    2078           case IDM_MOVEPRESERVE:
    2079           case IDM_WILDCOPY:
    2080           case IDM_WILDMOVE:
    2081           case IDM_RENAME:
    2082           case IDM_COMPARE:
    2083           case IDM_EAS:
    2084           case IDM_SUBJECT:
    2085           case IDM_VIEW:
    2086           case IDM_VIEWTEXT:
    2087           case IDM_VIEWBINARY:
    2088           case IDM_VIEWARCHIVE:
    2089           case IDM_EDIT:
    2090           case IDM_EDITTEXT:
    2091           case IDM_EDITBINARY:
    2092           case IDM_SAVETOCLIP:
    2093           case IDM_APPENDTOCLIP:
    2094           case IDM_ARCHIVE:
    2095           case IDM_ARCHIVEM:
    2096           case IDM_EXTRACT:
    2097           case IDM_MCIPLAY:
    2098           case IDM_UUDECODE:
    2099           case IDM_MERGE:
    2100             {
    2101               LISTINFO *li;
    2102               ULONG     action = UM_ACTION;
    2103 
    2104               li = malloc(sizeof(LISTINFO));
    2105               if(li) {
    2106                 memset(li,0,sizeof(LISTINFO));
    2107                 li->type = SHORT1FROMMP(mp1);
    2108                 li->hwnd = hwnd;
    2109                 li->list = BuildList(hwnd);
    2110                 if(li->list) {
    2111                   switch(SHORT1FROMMP(mp1)) {
    2112                     case IDM_DOITYOURSELF:
    2113                     case IDM_APPENDTOCLIP:
    2114                     case IDM_SAVETOCLIP:
    2115                     case IDM_ARCHIVE:
    2116                     case IDM_ARCHIVEM:
    2117                     case IDM_DELETE:
    2118                     case IDM_PERMDELETE:
    2119                     case IDM_ATTRS:
    2120                     case IDM_PRINT:
    2121                     case IDM_SHADOW:
    2122                     case IDM_SHADOW2:
    2123                     case IDM_OBJECT:
    2124                     case IDM_VIEW:
    2125                     case IDM_VIEWTEXT:
    2126                     case IDM_VIEWBINARY:
    2127                     case IDM_EDIT:
    2128                     case IDM_EDITTEXT:
    2129                     case IDM_EDITBINARY:
    2130                     case IDM_MCIPLAY:
    2131                     case IDM_UPDATE:
    2132                     case IDM_INFO:
    2133                     case IDM_EAS:
    2134                       action = UM_MASSACTION;
    2135                       break;
    2136                   }
    2137                   if(li->type == IDM_SHADOW || li->type == IDM_OBJECT ||
    2138                      li->type == IDM_SHADOW2)
    2139                     *li->targetpath = 0;
    2140                   if(!PostMsg(dcd->hwndObject,action,MPFROMP(li),
    2141                                  MPVOID)) {
    2142                     FreeListInfo(li);
    2143                     DosBeep(50,100);
    2144                   }
    2145                   else if(fUnHilite)
    2146                     UnHilite(hwnd,TRUE,&dcd->lastselection);
    2147                 }
    2148                 else
    2149                   free(li);
    2150               }
    2151             }
    2152             break;
    2153 
    2154           default:
    2155             if(!cmdloaded)
    2156               load_commands();
    2157             if(SHORT1FROMMP(mp1) >= IDM_COMMANDSTART &&
    2158                   SHORT1FROMMP(mp1) < IDM_QUICKTOOLSTART) {
    2159 
    2160               INT  x;
    2161 
    2162               x = SHORT1FROMMP(mp1) - IDM_COMMANDSTART;
    2163               if(x >= 0) {
    2164                 x++;
    2165                 RunCommand(hwnd,x);
    2166                 if(fUnHilite)
    2167                   UnHilite(hwnd,TRUE,&dcd->lastselection);
    2168               }
    2169             }
    2170             break;
    2171         }
    2172       }
    2173       return 0;
    2174 
    2175     case UM_FIXCNRMLE:
    2176     case UM_FIXEDITNAME:
    2177       return CommonCnrProc(hwnd,msg,mp1,mp2);
    2178 
    2179     case UM_FILESMENU:
    2180       {
    2181         PCNRITEM pci;
    2182         HWND     menuHwnd = (HWND)0;
    2183 
    2184         pci = (PCNRITEM)CurrentRecord(hwnd);
    2185         if(pci && (INT)pci != -1) {
    2186           if(pci->attrFile & FILE_DIRECTORY)
    2187             menuHwnd = CheckMenu(&CollectorDirMenu,COLLECTORDIR_POPUP);
    2188           else
    2189             menuHwnd = CheckMenu(&CollectorFileMenu,COLLECTORFILE_POPUP);
    2190         }
    2191         return MRFROMLONG(menuHwnd);
    2192       }
    2193 
    2194     case WM_CONTROL:
    2195       DosError(FERR_DISABLEHARDERR);
    2196       if(dcd) {
    2197         switch(SHORT2FROMMP(mp1)) {
    2198           case CN_CONTEXTMENU:
    2199             {
    2200               PCNRITEM pci = (PCNRITEM)mp2;
    2201 
    2202               if(pci) {
    2203                 WinSendMsg(hwnd,CM_SETRECORDEMPHASIS,MPFROMP(pci),
    2204                            MPFROM2SHORT(TRUE,CRA_CURSORED));
    2205                 MarkAll(hwnd,FALSE,FALSE,TRUE);
    2206                 if(pci->attrFile & FILE_DIRECTORY)
    2207                   dcd->hwndLastMenu = CheckMenu(&CollectorDirMenu,
    2208                                                 COLLECTORDIR_POPUP);
    2209                 else
    2210                   dcd->hwndLastMenu = CheckMenu(&CollectorFileMenu,
    2211                                                 COLLECTORFILE_POPUP);
    2212               }
    2213               else {
    2214                 dcd->hwndLastMenu = CheckMenu(&CollectorCnrMenu,
    2215                                               COLLECTORCNR_POPUP);
    2216                 if(dcd->hwndLastMenu && !dcd->cnremphasized) {
    2217                   WinSendMsg(hwnd,CM_SETRECORDEMPHASIS,MPVOID,
    2218                              MPFROM2SHORT(TRUE,CRA_SOURCE));
    2219                   dcd->cnremphasized = TRUE;
    2220                 }
    2221               }
    2222               if(dcd->hwndLastMenu) {
    2223                 if(dcd->hwndLastMenu == CollectorCnrMenu) {
    2224                   SetViewMenu(dcd->hwndLastMenu,dcd->flWindowAttr);
    2225                   SetDetailsSwitches(dcd->hwndLastMenu,dcd);
    2226                   if(dcd->flWindowAttr & CV_MINI)
    2227                     WinCheckMenuItem(dcd->hwndLastMenu,IDM_MINIICONS,TRUE);
    2228                 }
    2229                 if(!PopupMenu(hwnd,hwnd,dcd->hwndLastMenu)) {
    2230                   if(dcd->cnremphasized) {
    2231                     WinSendMsg(hwnd,CM_SETRECORDEMPHASIS,MPVOID,
    2232                                MPFROM2SHORT(FALSE,CRA_SOURCE));
    2233                     dcd->cnremphasized = TRUE;
    2234                   }
    2235                   MarkAll(hwnd,TRUE,FALSE,TRUE);
    2236                 }
    2237               }
    2238             }
    2239             break;
    2240 
    2241           case CN_DROPHELP:
    2242             if(mp2) {
    2243 
    2244               PDRAGINFO   pDInfo;
    2245               PCNRITEM    pci;
    2246               ULONG       numitems;
    2247               USHORT      usOperation;
    2248 
    2249               pci = (PCNRITEM)((PCNRDRAGINFO)mp2)->pRecord;
    2250               pDInfo = ((PCNRDRAGINFO)mp2)->pDragInfo;
    2251               if(!DrgAccessDraginfo(pDInfo)) {
    2252                 Win_Error(hwnd,hwnd,__FILE__,__LINE__,
    2253                           "%s",
    2254                           GetPString(IDS_DROPERRORTEXT));
    2255                 break;
    2256               }
    2257               numitems = DrgQueryDragitemCount(pDInfo);
    2258               usOperation = pDInfo->usOperation;
    2259               DrgDeleteDraginfoStrHandles(pDInfo);
    2260               DrgFreeDraginfo(pDInfo);
    2261               saymsg(MB_ENTER | MB_ICONASTERISK,
    2262                      hwnd,
    2263                      GetPString(IDS_DROPHELPHDRTEXT),
    2264                      GetPString(IDS_DROPHELPTEXT),
    2265                      numitems,
    2266                      &"s"[numitems == 1L],
    2267                      (pci) ? NullStr : GetPString(IDS_NOTEXT),
    2268                      (pci) ? NullStr : " ",
    2269                      (pci) ? pci->szFileName : NullStr,
    2270                      (pci) ? " " : NullStr,
    2271                      GetPString((usOperation == DO_COPY) ?
    2272                                 IDS_COPYTEXT :
    2273                                 (usOperation == DO_LINK) ?
    2274                                 IDS_LINKTEXT : IDS_MOVETEXT));
    2275             }
    2276             return 0;
    2277 
    2278           case CN_DRAGLEAVE:
    2279             if(mp2) {
    2280 
    2281               PDRAGINFO pDInfo;
    2282 
    2283               pDInfo = ((PCNRDRAGINFO)mp2)->pDragInfo;
    2284               DrgAccessDraginfo(pDInfo);             /* Access DRAGINFO       */
    2285               DrgFreeDraginfo(pDInfo);               /* Free DRAGINFO         */
    2286             }
    2287             return 0;
    2288 
    2289           case CN_DRAGAFTER:
    2290           case CN_DRAGOVER:
    2291             if(mp2) {
    2292 
    2293               PDRAGITEM pDItem;                      /* Pointer to DRAGITEM   */
    2294               PDRAGINFO pDInfo;                      /* Pointer to DRAGINFO   */
    2295               PCNRITEM  pci;
    2296               USHORT    uso;
    2297 
    2298               pci = (PCNRITEM)((PCNRDRAGINFO)mp2)->pRecord;
    2299 //              if(SHORT1FROMMP(mp1) == CN_DRAGAFTER)
    2300 //                pci = NULL;
    2301               pDInfo = ((PCNRDRAGINFO)mp2)->pDragInfo;
    2302               DrgAccessDraginfo(pDInfo);             /* Access DRAGINFO       */
    2303               if(pci) {
    2304                 if(pci->rc.flRecordAttr & CRA_SOURCE) {
    2305                   DrgFreeDraginfo(pDInfo);
    2306                   return(MRFROM2SHORT(DOR_NODROP,0));
    2307                 }
    2308                 uso = pDInfo->usOperation;
    2309                 if(uso == DO_DEFAULT)
    2310                   uso = (fCopyDefault) ? DO_COPY : DO_MOVE;
    2311                 if(!(pci->attrFile & FILE_DIRECTORY)) {
    2312                   if(uso != DO_LINK && uso != DO_MOVE &&
    2313                      uso != DO_COPY) {
    2314                     DrgFreeDraginfo(pDInfo);
    2315                     return MRFROM2SHORT(DOR_NODROP,0);
    2316                   }
    2317                   if(uso != DO_LINK &&
    2318                      !(driveflags[toupper(*pci->szFileName) - 'A'] &
    2319                        DRIVE_NOTWRITEABLE)) {
    2320 
    2321                     ARC_TYPE *info = NULL;
    2322 
    2323                     if(!fQuickArcFind &&
    2324                        !(driveflags[toupper(*pci->szFileName) - 'A'] &
    2325                          DRIVE_SLOW))
    2326                       info = find_type(pci->szFileName,NULL);
    2327                     else
    2328                       info = quick_find_type(pci->szFileName,NULL);
    2329                     if(!info || ((uso == DO_MOVE && !info->move) ||
    2330                        (uso == DO_COPY && !info->create)))  {
    2331                       DrgFreeDraginfo(pDInfo);
    2332                       return MRFROM2SHORT(DOR_NODROP,0);
    2333                     }
    2334                   }
    2335                 }
    2336               }
    2337               pDItem = DrgQueryDragitemPtr(pDInfo,   /* Access DRAGITEM       */
    2338                                            0);       /* Index to DRAGITEM     */
    2339               if(DrgVerifyRMF(pDItem,                /* Check valid rendering */
    2340                               DRM_OS2FILE,           /* mechanisms and data   */
    2341                               NULL)) {
    2342                 DrgFreeDraginfo(pDInfo);             /* Free DRAGINFO         */
    2343                 if(pci) {
    2344                   if(driveflags[toupper(*pci->szFileName) - 'A'] &
    2345                              DRIVE_NOTWRITEABLE)
    2346                     return MRFROM2SHORT(DOR_DROP,DO_LINK);
    2347                   if(toupper(*pci->szFileName) < 'C')
    2348                     return MRFROM2SHORT(DOR_DROP,DO_COPY);
    2349                   return MRFROM2SHORT(DOR_DROP,        /* Return okay to drop   */
    2350                                       ((fCopyDefault) ?
    2351                                       DO_COPY :
    2352                                       DO_MOVE));
    2353                 }
    2354                 else
    2355                   return MRFROM2SHORT(DOR_DROP,      /* Return okay to drop   */
    2356                                       DO_COPY);
    2357               }
    2358               DrgFreeDraginfo(pDInfo);               /* Free DRAGINFO         */
    2359             }
    2360             return(MRFROM2SHORT(DOR_NODROP,0)); /* Drop not valid        */
    2361 
    2362           case CN_INITDRAG:
    2363             if(mp2) {
    2364 
    2365               BOOL         wasemphasized = FALSE;
    2366               PCNRDRAGINIT pcd = (PCNRDRAGINIT)mp2;
    2367               PCNRITEM     pci;
    2368 
    2369               if(pcd) {
    2370                 pci = (PCNRITEM)pcd->pRecord;
    2371                 if(pci) {
    2372                   if(pci->rc.flRecordAttr & CRA_SELECTED)
    2373                     wasemphasized = TRUE;
    2374                   if(IsRoot(pci->szFileName))
    2375                     break;
    2376                   if(hwndStatus2)
    2377                     WinSetWindowText(hwndStatus2,
    2378                                      GetPString(IDS_DRAGFILEOBJTEXT));
    2379                   if(DoFileDrag(hwnd,
    2380                                 dcd->hwndObject,
    2381                                 mp2,
    2382                                 NULL,
    2383                                 NULL,
    2384                                 TRUE)) {
    2385                     if(fUnHilite && wasemphasized)
    2386                       UnHilite(hwnd,TRUE,&dcd->lastselection);
    2387                   }
    2388                   if(hwndStatus2)
    2389                     PostMsg(hwnd,UM_RESCAN,MPVOID,MPVOID);
    2390                 }
    2391               }
    2392             }
    2393             return 0;
    2394 
    2395           case CN_DROP:
    2396             if(mp2) {
    2397 
    2398               LISTINFO *li;
    2399               ULONG     action = UM_ACTION;
    2400 
    2401               li = DoFileDrop(hwnd,NULL,TRUE,mp1,mp2);
    2402               if(li) {
    2403                 if(!*li->targetpath) {
    2404                   li->type = IDM_COLLECT;
    2405                   action = UM_COLLECT;
    2406                 }
    2407                 else {
    2408                   if(li->list && li->list[0] && IsRoot(li->list[0]))
    2409                     li->type = DO_LINK;
    2410                   else if(fDragndropDlg && (!*li->arcname || !li->info)) {
    2411 
    2412                     CHECKLIST    cl;
    2413 
    2414                     memset(&cl,0,sizeof(cl));
    2415                     cl.size = sizeof(cl);
    2416                     cl.flags = li->type;
    2417                     cl.list = li->list;
    2418                     cl.cmd = li->type;
    2419                     cl.prompt = li->targetpath;
    2420                     li->type = WinDlgBox(HWND_DESKTOP,dcd->hwndParent,
    2421                                          DropListProc,FM3ModHandle,
    2422                                          DND_FRAME,MPFROMP(&cl));
    2423                     if(!li->type) {
    2424                       FreeListInfo(li);
    2425                       return 0;
    2426                     }
    2427                     li->list = cl.list;
    2428                     if(!li->list || !li->list[0]) {
    2429                       FreeListInfo(li);
    2430                       return 0;
    2431                     }
    2432                   }
    2433                   switch(li->type) {
    2434                     case DND_LAUNCH:
    2435                       strcat(li->targetpath," %a");
    2436                       ExecOnList(dcd->hwndParent,li->targetpath,
    2437                                  PROMPT | WINDOWED,NULL,li->list,NULL);
    2438                       FreeList(li->list);
    2439                       li->list = NULL;
    2440                       break;
    2441                     case DO_LINK:
    2442                       if(fLinkSetsIcon) {
    2443                         li->type = IDM_SETICON;
    2444                         action = UM_MASSACTION;
    2445                       }
    2446                       else
    2447                         li->type = IDM_COMPARE;
    2448                       break;
    2449                     case DND_EXTRACT:
    2450                       if(*li->targetpath && !IsFile(li->targetpath))
    2451                         li->type = IDM_EXTRACT;
    2452                       break;
    2453                     case DND_MOVE:
    2454                       li->type = IDM_MOVE;
    2455                       if(*li->targetpath && IsFile(li->targetpath) == 1) {
    2456                         action = UM_MASSACTION;
    2457                         li->type = IDM_ARCHIVEM;
    2458                       }
    2459                       break;
    2460                     case DND_WILDMOVE:
    2461                       li->type = IDM_WILDMOVE;
    2462                       if(*li->targetpath && IsFile(li->targetpath) == 1) {
    2463                         action = UM_MASSACTION;
    2464                         li->type = IDM_ARCHIVEM;
    2465                       }
    2466                       break;
    2467                     case DND_OBJECT:
    2468                       li->type = IDM_OBJECT;
    2469                       action = UM_MASSACTION;
    2470                       break;
    2471                     case DND_SHADOW:
    2472                       li->type = IDM_SHADOW;
    2473                       action = UM_MASSACTION;
    2474                       break;
    2475                     case DND_COMPARE:
    2476                       li->type = IDM_COMPARE;
    2477                       break;
    2478                     case DND_SETICON:
    2479                       action = UM_MASSACTION;
    2480                       li->type = IDM_SETICON;
    2481                       break;
    2482                     case DND_WILDCOPY:
    2483                       li->type = IDM_WILDCOPY;
    2484                       if(*li->targetpath && IsFile(li->targetpath) == 1) {
    2485                         action = UM_MASSACTION;
    2486                         li->type = IDM_ARCHIVE;
    2487                       }
    2488                       break;
    2489                     case DND_COPY:
    2490                       li->type = IDM_COPY;
    2491                       if(*li->targetpath && IsFile(li->targetpath) == 1) {
    2492                         action = UM_MASSACTION;
    2493                         li->type = IDM_ARCHIVE;
    2494                       }
    2495                       break;
    2496                     default:
    2497                       if(*li->arcname && li->info) {
    2498                         action = UM_MASSACTION;
    2499                         li->type = (li->type == DO_MOVE) ? IDM_FAKEEXTRACTM : IDM_FAKEEXTRACT;
    2500                       }
    2501                       else if(*li->targetpath && IsFile(li->targetpath) == 1) {
    2502                         action = UM_MASSACTION;
    2503                         li->type = (li->type == DO_MOVE) ? IDM_ARCHIVEM : IDM_ARCHIVE;
    2504                       }
    2505                       else
    2506                         li->type = (li->type == DO_MOVE) ? IDM_MOVE : IDM_COPY;
    2507                       break;
    2508                   }
    2509                 }
    2510                 if(!li->list || !li->list[0])
    2511                   FreeListInfo(li);
    2512                 else if(!PostMsg(dcd->hwndObject,action,MPFROMP(li),MPVOID))
    2513                   FreeListInfo(li);
    2514                 else {
    2515 
    2516                   USHORT usop = 0;
    2517 
    2518                   switch(li->type) {
    2519                     case IDM_COPY:
    2520                     case IDM_WILDCOPY:
    2521                       usop = DO_COPY;
    2522                       break;
    2523                     case IDM_MOVE:
    2524                     case IDM_WILDMOVE:
    2525                     case IDM_ARCHIVEM:
    2526                       usop = DO_MOVE;
    2527                       break;
    2528                   }
    2529                   if(usop)
    2530                     return MRFROM2SHORT(DOR_DROP,usop);
    2531                 }
    2532               }
    2533             }
    2534             return 0;
    2535 
    2536           case CN_BEGINEDIT:
    2537           case CN_REALLOCPSZ:
    2538           case CN_ENDEDIT:
    2539             {
    2540               MRESULT mre;
    2541 
    2542               mre = CnrDirectEdit(hwnd,msg,mp1,mp2);
    2543               if(mre != (MRESULT)-1)
    2544                 return mre;
    2545             }
    2546             break;
    2547 
    2548           case CN_EMPHASIS:
    2549             if(mp2) {
    2550 
    2551               PNOTIFYRECORDEMPHASIS pre = mp2;
    2552               PCNRITEM              pci;
    2553               CHAR                  s[CCHMAXPATH + 91],tb[81],tf[81],*p;
    2554 
    2555               pci = (PCNRITEM)((pre) ? pre->pRecord : NULL);
    2556               if(!pci) {
    2557                 if(hwndStatus2)
    2558                   WinSetWindowText(hwndStatus2,NullStr);
    2559                 if(fMoreButtons) {
    2560                   WinSetWindowText(hwndName,NullStr);
    2561                   WinSetWindowText(hwndDate,NullStr);
    2562                   WinSetWindowText(hwndAttr,NullStr);
    2563                 }
    2564                 if(hwndMain)
    2565                   WinSendMsg(hwndMain,UM_LOADFILE,MPVOID,MPVOID);
    2566                 break;
    2567               }
    2568               if(pre->fEmphasisMask & CRA_SELECTED) {
    2569                 if(pci->rc.flRecordAttr & CRA_SELECTED) {
    2570                   dcd->selectedbytes += (pci->cbFile + pci->easize);
    2571                   dcd->selectedfiles++;
    2572                 }
    2573                 else if(dcd->selectedfiles) {
    2574                   dcd->selectedbytes -= (pci->cbFile + pci->easize);
    2575                   dcd->selectedfiles--;
    2576                 }
    2577                 if(!dcd->suspendview)
    2578                 {
    2579                   commafmt(tf,sizeof(tf),dcd->selectedfiles);
    2580                   CommaFmtULL(tb,sizeof(tb),dcd->selectedbytes,' ');
    2581                   sprintf(s,"%s / %s",tf,tb);
    2582                   WinSetDlgItemText(dcd->hwndClient,DIR_SELECTED,s);
    2583                 }
    2584               }
    2585               else if(!dcd->suspendview &&
    2586                       WinQueryActiveWindow(dcd->hwndParent) ==
    2587                       dcd->hwndFrame) {
    2588                 if(pre->fEmphasisMask & CRA_CURSORED) {
    2589                   if(pci->rc.flRecordAttr & CRA_CURSORED) {
    2590                     if(fSplitStatus && hwndStatus2) {
    2591                       if(pci->attrFile & FILE_DIRECTORY)
    2592                         p = pci->pszFileName;
    2593                       else {
    2594                         p = strrchr(pci->szFileName,'\\');
    2595                         if(p) {
    2596                           if(*(p + 1))
    2597                             p++;
    2598                           else
    2599                             p = pci->pszFileName;
    2600                         }
    2601                         else
    2602                           p = pci->pszFileName;
    2603                       }
    2604                       CommaFmtULL(tb,sizeof(tb),pci->cbFile + pci->easize,' ');
    2605                       if(!fMoreButtons)
    2606                         sprintf(s," %s  %04u/%02u/%02u %02u:%02u:%02u  [%s]  %s",
    2607                                 tb,pci->date.year,
    2608                                 pci->date.month,pci->date.day,pci->time.hours,
    2609                                 pci->time.minutes,pci->time.seconds,
    2610                                 pci->pszDispAttr,p);
    2611                       else
    2612                       {
    2613                         if (pci->cbFile + pci->easize > 1024)
    2614                           CommaFmtULL(tf,sizeof(tf),pci->cbFile + pci->easize, ' ');
    2615                         else
    2616                           *tf = 0;
    2617                         sprintf(s,GetPString(IDS_STATUSSIZETEXT),
    2618                                 tb,
    2619                                 *tf ? " (" : NullStr,
    2620                                 tf,
    2621                                 *tf ? ")" : NullStr);
    2622                       }
    2623                       WinSetWindowText(hwndStatus2,s);
    2624                     }
    2625                     if(fMoreButtons) {
    2626                       WinSetWindowText(hwndName,pci->pszFileName);
    2627                       sprintf(s,"%04u/%02u/%02u %02u:%02u:%02u",
    2628                               pci->date.year,pci->date.month,
    2629                               pci->date.day,pci->time.hours,pci->time.minutes,
    2630                               pci->time.seconds);
    2631                       WinSetWindowText(hwndDate,s);
    2632                       WinSetWindowText(hwndAttr,pci->pszDispAttr);
    2633                     }
    2634                   }
    2635                 }
    2636               }
    2637               if(!dcd->suspendview && hwndMain &&
    2638                  (pre->fEmphasisMask & CRA_CURSORED) &&
    2639                  (pci->rc.flRecordAttr & CRA_CURSORED) &&
    2640                  WinQueryActiveWindow(dcd->hwndParent) ==dcd->hwndFrame)
    2641                 WinSendMsg(hwndMain,UM_LOADFILE,
    2642                            MPFROMP(((fComments || (pci->attrFile & FILE_DIRECTORY) == 0) ?
    2643                                     pci->szFileName : NULL)),MPVOID);
    2644             }
    2645             break;
    2646 
    2647           case CN_ENTER:
    2648             if(mp2) {
    2649 
    2650               PCNRITEM     pci = (PCNRITEM)((PNOTIFYRECORDENTER)mp2)->pRecord;
    2651               FILEFINDBUF3 ffb;
    2652               HDIR         hDir = HDIR_CREATE;
    2653               ULONG        nm = 1L;
    2654               APIRET       status = 0;
    2655 
    2656               SetShiftState();
    2657               if(pci) {
    2658                 if(pci->rc.flRecordAttr & CRA_INUSE)
    2659                   break;
    2660                 DosError(FERR_DISABLEHARDERR);
    2661                 status = DosFindFirst(pci->szFileName,&hDir,
    2662                                       FILE_NORMAL   | FILE_DIRECTORY |
    2663                                       FILE_ARCHIVED | FILE_READONLY  |
    2664                                       FILE_HIDDEN   | FILE_SYSTEM,
    2665                                       &ffb,sizeof(ffb),&nm,
    2666                                       FIL_STANDARD);
    2667                 priority_bumped();
    2668                 if(!status) {
    2669                   DosFindClose(hDir);
    2670                   if(ffb.attrFile & FILE_DIRECTORY) {
    2671                     if((shiftstate & (KC_CTRL | KC_ALT)) ==
    2672                        (KC_CTRL | KC_ALT))
    2673                       PostMsg(hwnd,WM_COMMAND,MPFROM2SHORT(IDM_SHOWALLFILES,0),
    2674                               MPVOID);
    2675                     else if((shiftstate & (KC_CTRL | KC_SHIFT)) ==
    2676                             (KC_CTRL | KC_SHIFT))
    2677                       OpenObject(pci->szFileName,Settings,dcd->hwndFrame);
    2678                     else if(shiftstate & KC_CTRL)
    2679                       OpenObject(pci->szFileName,Default,dcd->hwndFrame);
    2680                     else
    2681                       OpenDirCnr((HWND)0,
    2682                                  hwndMain,
    2683                                  dcd->hwndFrame,
    2684                                  FALSE,
    2685                                  pci->szFileName);
    2686                   }
    2687                   else {
    2688 
    2689                     SWP swp;
    2690 
    2691                     WinSendMsg(hwnd,
    2692                                CM_SETRECORDEMPHASIS,
    2693                                MPFROMP(pci),
    2694                                MPFROM2SHORT(TRUE,CRA_INUSE));
    2695                     WinQueryWindowPos(dcd->hwndFrame,&swp);
    2696                     DefaultViewKeys(hwnd,
    2697                                     dcd->hwndFrame,
    2698                                     dcd->hwndParent,
    2699                                     &swp,
    2700                                     pci->szFileName);
    2701                     WinSendMsg(hwnd,
    2702                                CM_SETRECORDEMPHASIS,
    2703                                MPFROMP(pci),
    2704                                MPFROM2SHORT(FALSE,CRA_INUSE |
    2705                                               ((fUnHilite) ? CRA_SELECTED : 0)));
    2706                   }
    2707                 }
    2708                 else
    2709                   WinSendMsg(hwnd,
    2710                              CM_REMOVERECORD,
    2711                              MPFROMP(&pci),
    2712                              MPFROM2SHORT(1,
    2713                                CMA_FREE | CMA_INVALIDATE | CMA_ERASE));
    2714               }
    2715             }
    2716             break;
    2717         }
    2718       }
    2719       return 0;
    2720 
    2721     case UM_LOADFILE:
    2722       if(dcd && mp2) {
    2723 
    2724         HWND ret;
    2725 
    2726         ret = StartMLEEditor(dcd->hwndParent,
    2727                              (INT)mp1,
    2728                              (CHAR *)mp2,
    2729                              dcd->hwndFrame);
    2730         if(mp2)
    2731           free((CHAR *)mp2);
    2732         return MRFROMLONG(ret);
    2733       }
    2734       return 0;
    2735 
    2736     case UM_CLOSE:
    2737       WinDestroyWindow(WinQueryWindow(WinQueryWindow(hwnd,QW_PARENT),
    2738                        QW_PARENT));
    2739       return 0;
    2740 
    2741     case UM_FOLDUP:
    2742       if(!PostMsg((HWND)0,WM_QUIT,MPVOID,MPVOID))
    2743         DosExit(EXIT_PROCESS,1);
    2744       return 0;
    2745 
    2746     case WM_CLOSE:
    2747       if(dcd) {
    2748         dcd->namecanchange = TRUE;
    2749         dcd->stopflag = 1;
    2750         if(dcd->amextracted)
    2751           return 0;
    2752       }
    2753       WinSendMsg(hwnd,WM_SAVEAPPLICATION,MPVOID,MPVOID);
    2754       if(dcd) {
    2755         if(!dcd->dontclose && ParentIsDesktop(hwnd,dcd->hwndParent))
    2756           PostMsg(hwnd,UM_FOLDUP,MPVOID,MPVOID);
    2757         if(dcd->hwndObject) {
    2758           DosSleep(64L);
    2759           if(!PostMsg(dcd->hwndObject,WM_CLOSE,MPVOID,MPVOID))
    2760             WinSendMsg(dcd->hwndObject,WM_CLOSE,MPVOID,MPVOID);
    2761         }
    2762       }
    2763       else
    2764         WinSendMsg(hwnd,UM_CLOSE,MPVOID,MPVOID);
    2765       return 0;
    2766 
    2767     case WM_DESTROY:
    2768       if(CollectorDirMenu)
    2769         WinDestroyWindow(CollectorDirMenu);
    2770       if(CollectorFileMenu)
    2771         WinDestroyWindow(CollectorFileMenu);
    2772       if(CollectorCnrMenu)
    2773         WinDestroyWindow(CollectorCnrMenu);
    2774       CollectorCnrMenu = CollectorFileMenu = CollectorDirMenu = (HWND)0;
    2775       Collector = (HWND)0;
    2776       EmptyCnr(hwnd);
    2777       break;
    2778   }
    2779   return (dcd && dcd->oldproc) ? dcd->oldproc(hwnd,msg,mp1,mp2) :
    2780                                  PFNWPCnr(hwnd,msg,mp1,mp2);
    2781 }
    2782 
    2783 
    2784 HWND StartCollector (HWND hwndParent,INT flags)
    2785 {
    2786   HWND          hwndFrame = (HWND)0,hwndClient;
    2787   ULONG         FrameFlags = FCF_TITLEBAR   | FCF_SYSMENU     |
    2788                              FCF_SIZEBORDER | FCF_MINMAX      |
    2789                              FCF_ICON       | FCF_NOBYTEALIGN |
    2790                              FCF_ACCELTABLE;
    2791   USHORT        id;
    2792   static USHORT idinc = 0;
    2793   DIRCNRDATA   *dcd;
    2794 
    2795   if(ParentIsDesktop(hwndParent,hwndParent))
     2966  if (ParentIsDesktop(hwndParent, hwndParent))
    27962967    FrameFlags |= (FCF_TASKLIST | FCF_SHELLPOSITION | FCF_MENU);
    2797   if(Collector) {
     2968  if (Collector)
     2969  {
    27982970    WinSetWindowPos(WinQueryWindow(WinQueryWindow(Collector,
    2799                                                   QW_PARENT),
    2800                                    QW_PARENT),
    2801                     HWND_TOP,
    2802                     0,
    2803                     0,
    2804                     0,
    2805                     0,
    2806                     SWP_SHOW | SWP_RESTORE);
     2971                                                  QW_PARENT),
     2972                                   QW_PARENT),
     2973                    HWND_TOP,
     2974                    0,
     2975                    0,
     2976                    0,
     2977                    0,
     2978                    SWP_SHOW | SWP_RESTORE);
    28072979    return WinQueryWindow(WinQueryWindow(Collector,
    2808                                         QW_PARENT),
    2809                           QW_PARENT);
     2980                                        QW_PARENT),
     2981                          QW_PARENT);
    28102982  }
    28112983  hwndFrame = WinCreateStdWindow(hwndParent,
    2812                                  WS_VISIBLE,
    2813                                  &FrameFlags,
    2814                                  GetPString(IDS_WCCOLLECTOR),
    2815                                  NULL,
    2816                                  WS_VISIBLE | fwsAnimate,
    2817                                  FM3ModHandle,
    2818                                  COLLECTOR_FRAME,
    2819                                  &hwndClient);
    2820   if(hwndFrame && hwndClient) {
     2984                                 WS_VISIBLE,
     2985                                 &FrameFlags,
     2986                                 GetPString(IDS_WCCOLLECTOR),
     2987                                 NULL,
     2988                                 WS_VISIBLE | fwsAnimate,
     2989                                 FM3ModHandle,
     2990                                 COLLECTOR_FRAME,
     2991                                 &hwndClient);
     2992  if (hwndFrame && hwndClient)
     2993  {
    28212994    id = COLLECTOR_FRAME + idinc++;
    2822     WinSetWindowUShort(hwndFrame,QWS_ID,id);
     2995    WinSetWindowUShort(hwndFrame, QWS_ID, id);
    28232996    dcd = malloc(sizeof(DIRCNRDATA));
    2824     if(dcd) {
    2825       memset(dcd,0,sizeof(DIRCNRDATA));
    2826       dcd->size = sizeof(DIRCNRDATA);
    2827       dcd->id = id;
    2828       dcd->type = COLLECTOR_FRAME;
    2829       dcd->hwndParent = (hwndParent) ? hwndParent : HWND_DESKTOP;
    2830       dcd->hwndFrame  = hwndFrame;
    2831       dcd->hwndClient = hwndClient;
    2832       if(flags & 4)
    2833         dcd->dontclose = TRUE;
    2834       {
    2835         PFNWP oldproc;
    2836 
    2837         oldproc = WinSubclassWindow(hwndFrame,
    2838                                     (PFNWP)CollectorFrameWndProc);
    2839         WinSetWindowPtr(hwndFrame,
    2840                         QWL_USER,
    2841                         (PVOID)oldproc);
    2842       }
    2843       dcd->hwndCnr = WinCreateWindow(hwndClient,
    2844                                      WC_CONTAINER,
    2845                                      NULL,
    2846                                      CCS_AUTOPOSITION | CCS_MINIICONS |
    2847                                      CCS_MINIRECORDCORE | ulCnrType |
    2848                                      WS_VISIBLE,
    2849                                      0,
    2850                                      0,
    2851                                      0,
    2852                                      0,
    2853                                      hwndClient,
    2854                                      HWND_TOP,
    2855                                      (ULONG)COLLECTOR_CNR,
    2856                                      NULL,
    2857                                      NULL);
    2858       if(dcd->hwndCnr) {
    2859         Collector = dcd->hwndCnr;
    2860         WinSetWindowPtr(dcd->hwndCnr,QWL_USER,(PVOID)dcd);
    2861         WinSetWindowText(hwndFrame,
    2862                          GetPString(IDS_COLLECTORTITLETEXT));
    2863         if(FrameFlags & FCF_MENU) {
    2864           if(!fToolbar) {
    2865 
    2866             HWND hwndMenu = WinWindowFromID(hwndFrame,FID_MENU);
    2867 
    2868             if(hwndMenu) {
    2869               WinSendMsg(hwndMenu,
    2870                          MM_DELETEITEM,
    2871                          MPFROM2SHORT(IDM_SEEALL,FALSE),
    2872                          MPVOID);
    2873               WinSendMsg(hwndMenu,
    2874                          MM_DELETEITEM,
    2875                          MPFROM2SHORT(IDM_GREP,FALSE),
    2876                          MPVOID);
    2877               WinSendMsg(hwndMenu,
    2878                          MM_DELETEITEM,
    2879                          MPFROM2SHORT(IDM_CLEARCNR,FALSE),
    2880                          MPVOID);
    2881               WinSendMsg(hwndMenu,
    2882                          MM_DELETEITEM,
    2883                          MPFROM2SHORT(IDM_REMOVE,FALSE),
    2884                          MPVOID);
    2885             }
    2886           }
    2887         }
    2888         dcd->oldproc = WinSubclassWindow(dcd->hwndCnr,
    2889                                          (PFNWP)CollectorCnrWndProc);
    2890         {
    2891           USHORT ids[] = {DIR_TOTALS,DIR_SELECTED,DIR_VIEW,DIR_SORT,
    2892                           DIR_FILTER,0};
    2893 
    2894           CommonCreateTextChildren(dcd->hwndClient,
    2895                                    GetPString(IDS_WCCOLSTATUS),
    2896                                    ids);
    2897         }
    2898         if(FrameFlags & FCF_SHELLPOSITION)
    2899           PostMsg(hwndClient,
    2900                   UM_SIZE,
    2901                   MPVOID,
    2902                   MPVOID);
    2903         if(!PostMsg(dcd->hwndCnr,
    2904                     UM_SETUP,
    2905                     MPVOID,
    2906                     MPVOID))
    2907           WinSendMsg(dcd->hwndCnr,
    2908                      UM_SETUP,
    2909                      MPVOID,
    2910                      MPVOID);
    2911       }
    2912       else {
    2913         PostMsg(hwndClient,
    2914                 WM_CLOSE,
    2915                 MPVOID,
    2916                 MPVOID);
    2917         free(dcd);
    2918         hwndFrame = (HWND)0;
    2919       }
    2920     }
    2921     else {
     2997    if (dcd)
     2998    {
     2999      memset(dcd, 0, sizeof(DIRCNRDATA));
     3000      dcd -> size = sizeof(DIRCNRDATA);
     3001      dcd -> id = id;
     3002      dcd -> type = COLLECTOR_FRAME;
     3003      dcd -> hwndParent = (hwndParent) ? hwndParent : HWND_DESKTOP;
     3004      dcd -> hwndFrame = hwndFrame;
     3005      dcd -> hwndClient = hwndClient;
     3006      if (flags & 4)
     3007        dcd -> dontclose = TRUE;
     3008      {
     3009        PFNWP oldproc;
     3010
     3011        oldproc = WinSubclassWindow(hwndFrame,
     3012                                    (PFNWP) CollectorFrameWndProc);
     3013        WinSetWindowPtr(hwndFrame,
     3014                        QWL_USER,
     3015                        (PVOID) oldproc);
     3016      }
     3017      dcd -> hwndCnr = WinCreateWindow(hwndClient,
     3018                                       WC_CONTAINER,
     3019                                       NULL,
     3020                                       CCS_AUTOPOSITION | CCS_MINIICONS |
     3021                                       CCS_MINIRECORDCORE | ulCnrType |
     3022                                       WS_VISIBLE,
     3023                                       0,
     3024                                       0,
     3025                                       0,
     3026                                       0,
     3027                                       hwndClient,
     3028                                       HWND_TOP,
     3029                                       (ULONG) COLLECTOR_CNR,
     3030                                       NULL,
     3031                                       NULL);
     3032      if (dcd -> hwndCnr)
     3033      {
     3034        Collector = dcd -> hwndCnr;
     3035        WinSetWindowPtr(dcd -> hwndCnr, QWL_USER, (PVOID) dcd);
     3036        WinSetWindowText(hwndFrame,
     3037                         GetPString(IDS_COLLECTORTITLETEXT));
     3038        if (FrameFlags & FCF_MENU)
     3039        {
     3040          if (!fToolbar)
     3041          {
     3042            HWND hwndMenu = WinWindowFromID(hwndFrame, FID_MENU);
     3043
     3044            if (hwndMenu)
     3045            {
     3046              WinSendMsg(hwndMenu,
     3047                         MM_DELETEITEM,
     3048                         MPFROM2SHORT(IDM_SEEALL, FALSE),
     3049                         MPVOID);
     3050              WinSendMsg(hwndMenu,
     3051                         MM_DELETEITEM,
     3052                         MPFROM2SHORT(IDM_GREP, FALSE),
     3053                         MPVOID);
     3054              WinSendMsg(hwndMenu,
     3055                         MM_DELETEITEM,
     3056                         MPFROM2SHORT(IDM_CLEARCNR, FALSE),
     3057                         MPVOID);
     3058              WinSendMsg(hwndMenu,
     3059                         MM_DELETEITEM,
     3060                         MPFROM2SHORT(IDM_REMOVE, FALSE),
     3061                         MPVOID);
     3062            }
     3063          }
     3064        }
     3065        dcd -> oldproc = WinSubclassWindow(dcd -> hwndCnr,
     3066                                           (PFNWP) CollectorCnrWndProc);
     3067        {
     3068          USHORT ids[] =
     3069          {DIR_TOTALS, DIR_SELECTED, DIR_VIEW, DIR_SORT,
     3070           DIR_FILTER, 0};
     3071
     3072          CommonCreateTextChildren(dcd -> hwndClient,
     3073                                   GetPString(IDS_WCCOLSTATUS),
     3074                                   ids);
     3075        }
     3076        if (FrameFlags & FCF_SHELLPOSITION)
     3077          PostMsg(hwndClient,
     3078                  UM_SIZE,
     3079                  MPVOID,
     3080                  MPVOID);
     3081        if (!PostMsg(dcd -> hwndCnr,
     3082                     UM_SETUP,
     3083                     MPVOID,
     3084                     MPVOID))
     3085          WinSendMsg(dcd -> hwndCnr,
     3086                     UM_SETUP,
     3087                     MPVOID,
     3088                     MPVOID);
     3089      }
     3090      else
     3091      {
     3092        PostMsg(hwndClient,
     3093                WM_CLOSE,
     3094                MPVOID,
     3095                MPVOID);
     3096        free(dcd);
     3097        hwndFrame = (HWND) 0;
     3098      }
     3099    }
     3100    else
     3101    {
    29223102      PostMsg(hwndClient,
    2923               WM_CLOSE,
    2924               MPVOID,
    2925               MPVOID);
    2926       hwndFrame = (HWND)0;
     3103              WM_CLOSE,
     3104              MPVOID,
     3105              MPVOID);
     3106      hwndFrame = (HWND) 0;
    29273107    }
    29283108  }
    29293109  return hwndFrame;
    29303110}
    2931 
Note: See TracChangeset for help on using the changeset viewer.