source: trunk/dll/treecnr.c@ 36

Last change on this file since 36 was 36, checked in by root, 23 years ago

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