Context Navigation

source: trunk/dll/treecnr.c@ 176

Visit:

Last change on this file since 176 was 176, checked in by root, 20 years ago
More large file formatting updates
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 77.0 KB

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

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

Download in other formats: