source: trunk/dll/treecnr.c@ 469

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

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