source: trunk/dll/dircnrs.c @ 672

Last change on this file since 672 was 672, checked in by Steven Levine, 14 years ago

Use dcd->ulItemsToUnHilite
Sync UnHilite? calls with arg mods

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