source: trunk/dll/dircnrs.c@ 688

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

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