source: trunk/dll/treecnr.c@ 15

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

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