source: trunk/dll/treecnr.c@ 549

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

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