source: trunk/dll/treecnr.c@ 156

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

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