source: trunk/dll/dircnrs.c@ 1069

Last change on this file since 1069 was 1065, checked in by John Small, 17 years ago

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