source: trunk/dll/dircnrs.c@ 672

Last change on this file since 672 was 672, checked in by Steven Levine, 18 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.