source: trunk/dll/dircnrs.c@ 593

Last change on this file since 593 was 593, checked in by Gregg Young, 18 years ago

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