source: trunk/dll/treecnr.c@ 352

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

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