source: trunk/dll/treecnr.c@ 284

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

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