source: trunk/dll/treecnr.c@ 532

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

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