source: trunk/dll/treecnr.c@ 197

Last change on this file since 197 was 186, checked in by root, 20 years ago

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