Context Navigation

source: trunk/dll/treecnr.c@ 423

Visit:

Last change on this file since 423 was 386, checked in by root, 19 years ago
Drop extra Runtime_Error
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 78.3 KB

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

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

Download in other formats: