source: trunk/dll/treecnr.c@ 70

Last change on this file since 70 was 70, checked in by root, 22 years ago

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