source: trunk/dll/treecnr.c@ 305

Last change on this file since 305 was 305, checked in by root, 19 years ago

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