Context Navigation

source: trunk/dll/treecnr.c@ 80

Visit:

Last change on this file since 80 was 70, checked in by root, 22 years ago
Add JFS and FAT32 support
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 108.4 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: