Context Navigation

source: trunk/dll/treecnr.c@ 536

Visit:

Last change on this file since 536 was 527, checked in by root, 19 years ago
31 Aug 06 JS Add more partitioning menu items
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 78.7 KB

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

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

Download in other formats: