Context Navigation

source: trunk/dll/treecnr.c@ 487

Visit:

Last change on this file since 487 was 472, 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.6 KB

Line
1
2	/***********************************************************************
3
4	$Id: treecnr.c 472 2006-09-01 01:06:56Z 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	15 Aug 06 SHL Rework SetMask args
21	31 Aug 06 JS Add more partitioning menu items
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	if(removable == 1)
2063	driveflags[x] \|= DRIVE_REMOVABLE;
2064	if(drvtype & DRIVE_REMOTE)
2065	driveflags[x] \|= DRIVE_REMOTE;
2066	if(!strcmp(FileSystem,CDFS))
2067	driveflags[x] \|= (DRIVE_REMOVABLE \|
2068	DRIVE_NOTWRITEABLE \|
2069	DRIVE_CDROM);
2070	if (strcmp(FileSystem,HPFS) &&
2071	strcmp(FileSystem,JFS) &&
2072	strcmp(FileSystem,CDFS) &&
2073	strcmp(FileSystem,FAT32) &&
2074	strcmp(FileSystem,HPFS386))
2075	{
2076	driveflags[x] \|= DRIVE_NOLONGNAMES;
2077	}
2078	if(!strcmp(FileSystem,CBSIFS)) {
2079	driveflags[x] \|= DRIVE_ZIPSTREAM;
2080	driveflags[x] &= (~DRIVE_REMOTE);
2081	}
2082	if(driveflags[x] & DRIVE_CDROM)
2083	pciP->rc.hptrIcon = hptrCDROM;
2084	else
2085	pciP->rc.hptrIcon = (driveflags[x] & DRIVE_REMOVABLE) ?
2086	hptrRemovable :
2087	(driveflags[x] & DRIVE_REMOTE) ?
2088	hptrRemote : hptrDrive;
2089	WinSendMsg(hwnd,
2090	CM_INVALIDATERECORD,
2091	MPFROMP(&pciP),
2092	MPFROM2SHORT(1,CMA_ERASE \| CMA_REPOSITION));
2093	if(hwndMain)
2094	PostMsg(hwndMain,
2095	UM_BUILDDRIVEBAR,
2096	MPVOID,
2097	MPVOID);
2098	}
2099	}
2100	memset(&volser,0,sizeof(volser));
2101	DosError(FERR_DISABLEHARDERR);
2102	status = DosQueryFSInfo(toupper(*pci->szFileName) - '@',
2103	FSIL_VOLSER,&volser,
2104	(ULONG)sizeof(volser));
2105	if(!status) {
2106	if(!volser.serial \|\|
2107	driveserial[toupper(*pci->szFileName) - 'A'] !=
2108	volser.serial) {
2109	UnFlesh(hwnd,pciP);
2110	Flesh(hwnd,pciP);
2111	driveserial[toupper(*pci->szFileName) - 'A'] =
2112	volser.serial;
2113	}
2114	pciL = WinSendMsg(hwnd,
2115	CM_QUERYRECORD,
2116	MPFROMP(pciP),
2117	MPFROM2SHORT(CMA_FIRSTCHILD,
2118	CMA_ITEMORDER));
2119	if(!pciL)
2120	Flesh(hwnd,pciP);
2121	}
2122	else {
2123	driveserial[toupper(*pci->szFileName) - 'A'] = -1;
2124	UnFlesh(hwnd,
2125	pci);
2126	PostMsg(hwnd,
2127	UM_RESCAN,
2128	MPVOID,
2129	MPVOID);
2130	PostMsg(hwnd,
2131	UM_SETUP2,
2132	MPFROMP(pci),
2133	MPFROMLONG(status));
2134	return 0;
2135	}
2136	}
2137	status = 0;
2138	IsOk = (IsRoot(pci->szFileName) &&
2139	IsValidDrive(toupper(*pci->szFileName)));
2140	if(!IsOk) {
2141	DosError(FERR_DISABLEHARDERR);
2142	status = DosFindFirst(pci->szFileName,&hDir,
2143	FILE_NORMAL \| FILE_DIRECTORY \|
2144	FILE_ARCHIVED \| FILE_READONLY \|
2145	FILE_HIDDEN \| FILE_SYSTEM,
2146	&ffb,sizeof(ffb),&nm,
2147	FIL_STANDARD);
2148	priority_bumped();
2149	}
2150	if(!status) {
2151	if(!IsOk)
2152	DosFindClose(hDir);
2153	if(IsOk \|\|
2154	(ffb.attrFile & FILE_DIRECTORY)) {
2155	if((shiftstate & (KC_CTRL \| KC_ALT)) ==
2156	(KC_CTRL \| KC_ALT)) {
2157	PostMsg(hwnd,
2158	WM_COMMAND,
2159	MPFROM2SHORT(IDM_SHOWALLFILES,0),
2160	MPVOID);
2161	return 0;
2162	}
2163	if((shiftstate & (KC_CTRL \| KC_SHIFT)) ==
2164	(KC_CTRL \| KC_SHIFT)) {
2165	OpenObject(pci->szFileName,
2166	Settings,
2167	dcd->hwndFrame);
2168	return 0;
2169	}
2170	if(!(shiftstate & (KC_CTRL \| KC_SHIFT))) {
2171	if(!ParentIsDesktop(hwnd,dcd->hwndParent)) {
2172	if(FindDirCnrByName(pci->szFileName,
2173	TRUE))
2174	return 0;
2175	}
2176	}
2177	if((shiftstate & KC_CTRL) \|\|
2178	(!(shiftstate & KC_SHIFT) &&
2179	ParentIsDesktop(hwnd,dcd->hwndParent) &&
2180	fVTreeOpensWPS)) {
2181
2182	ULONG size = sizeof(ULONG),flWindowAttr = CV_ICON;
2183	CHAR s[33];
2184
2185	strcpy(s,"ICON");
2186	PrfQueryProfileData(fmprof,
2187	appname,
2188	"DirflWindowAttr",
2189	(PVOID)&flWindowAttr,
2190	&size);
2191	if(flWindowAttr & CV_DETAIL) {
2192	if(IsRoot(pci->szFileName))
2193	strcpy(s,"TREE");
2194	else
2195	strcpy(s,"DETAILS");
2196	}
2197	OpenObject(pci->szFileName,
2198	s,
2199	dcd->hwndFrame);
2200	return 0;
2201	}
2202	if(!ParentIsDesktop(hwnd,dcd->hwndParent) &&
2203	!fDCOpens &&
2204	!LastDir &&
2205	!(shiftstate & KC_SHIFT))
2206	LastDir = FindDirCnr(dcd->hwndParent);
2207	if(LastDir &&
2208	!fDCOpens &&
2209	!(shiftstate & KC_SHIFT)) {
2210	WinSendMsg(LastDir,
2211	UM_SETDIR,
2212	MPFROMP(pci->szFileName),
2213	MPVOID);
2214	WinSetWindowPos(WinQueryWindow(WinQueryWindow(LastDir,
2215	QW_PARENT),
2216	QW_PARENT),
2217	HWND_TOP,
2218	0,
2219	0,
2220	0,
2221	0,
2222	SWP_ZORDER \| fl);
2223	}
2224	else
2225	OpenDirCnr(hwnd,
2226	dcd->hwndParent,
2227	dcd->hwndFrame,
2228	FALSE,
2229	pci->szFileName);
2230	}
2231	else {
2232	if(!(driveflags[toupper(*pci->szFileName) - 'A'] &
2233	DRIVE_INCLUDEFILES))
2234	WinSendMsg(hwnd,
2235	CM_REMOVERECORD,
2236	MPFROMP(&pci),
2237	MPFROM2SHORT(1,CMA_FREE \| CMA_INVALIDATE));
2238	else {
2239
2240	SWP swp;
2241
2242	WinQueryWindowPos(dcd->hwndFrame,&swp);
2243	DefaultViewKeys(hwnd,
2244	dcd->hwndFrame,
2245	dcd->hwndParent,
2246	&swp,
2247	pci->szFileName);
2248	}
2249	}
2250	}
2251	else {
2252	if(!IsRoot(pci->szFileName)) {
2253	NotifyError(pci->szFileName,status);
2254	WinSendMsg(hwnd,
2255	CM_REMOVERECORD,
2256	MPFROMP(&pci),
2257	MPFROM2SHORT(1,CMA_FREE \| CMA_INVALIDATE));
2258	}
2259	}
2260	}
2261	else if(!pci)
2262	PostMsg(hwnd,
2263	WM_COMMAND,
2264	MPFROM2SHORT(IDM_MKDIR,0),
2265	MPVOID);
2266	if(fFollowTree)
2267	WinSetFocus(HWND_DESKTOP,hwnd);
2268	}
2269	return 0;
2270
2271	case WM_MENUEND:
2272	if(dcd) {
2273
2274	HWND hwndMenu = (HWND)mp2;
2275
2276	if(hwndMenu == TreeCnrMenu \|\| hwndMenu == TreeMenu \|\|
2277	hwndMenu == DirMenu) {
2278	MarkAll(hwnd,TRUE,FALSE,TRUE);
2279	if(dcd->cnremphasized) {
2280	WinSendMsg(hwnd,
2281	CM_SETRECORDEMPHASIS,
2282	MPVOID,
2283	MPFROM2SHORT(FALSE,CRA_SOURCE));
2284	dcd->cnremphasized = FALSE;
2285	}
2286	}
2287	}
2288	break;
2289
2290	case UM_OPENWINDOWFORME:
2291	if(dcd) {
2292	if(mp1 &&
2293	!IsFile((CHAR *)mp1))
2294	OpenDirCnr(hwnd,
2295	dcd->hwndParent,
2296	dcd->hwndFrame,
2297	FALSE,
2298	(char *)mp1);
2299	}
2300	return 0;
2301
2302	case MM_PORTHOLEINIT:
2303	if(dcd) {
2304	switch(SHORT1FROMMP(mp1)) {
2305	case 0:
2306	case 1:
2307	{
2308	ULONG wmsg;
2309
2310	wmsg = ((SHORT1FROMMP(mp1) == 0) ?
2311	UM_FILESMENU :
2312	UM_VIEWSMENU);
2313	PortholeInit((HWND)WinSendMsg(dcd->hwndClient,
2314	wmsg,
2315	MPVOID,
2316	MPVOID),
2317	mp1,
2318	mp2);
2319	}
2320	break;
2321	}
2322	}
2323	break;
2324
2325	case UM_INITMENU:
2326	case WM_INITMENU:
2327	if(dcd) {
2328	switch(SHORT1FROMMP(mp1)) {
2329	case IDM_FILESMENU:
2330	{
2331	PCNRITEM pci;
2332
2333	pci = (PCNRITEM)CurrentRecord(hwnd);
2334	if(pci && (INT)pci != -1)
2335	{
2336	BOOL rdy;
2337	BOOL writeable;
2338	BOOL removable;
2339	BOOL underenv;
2340	CHAR chDrvU;
2341	CHAR szDrv[CCHMAXPATH];
2342	strcpy(szDrv, pci->szFileName);
2343	chDrvU = *pci->szFileName;
2344	chDrvU = toupper(chDrvU);
2345	MakeValidDir(szDrv);
2346	rdy = *szDrv == chDrvU; // Drive not ready if MakeValidDir changes drive letter
2347	removable = rdy && (driveflags[chDrvU - 'A'] & DRIVE_REMOVABLE) != 0;
2348	writeable = rdy && !(driveflags[chDrvU - 'A'] & DRIVE_NOTWRITEABLE);
2349	underenv = (pci->flags & RECFLAGS_UNDERENV) != 0;
2350
2351	WinEnableMenuItem((HWND)mp2, IDM_INFO, rdy);
2352
2353	WinEnableMenuItem((HWND)mp2, IDM_ATTRS, writeable);
2354	WinEnableMenuItem((HWND)mp2, IDM_EAS, writeable);
2355	WinEnableMenuItem((HWND)mp2, IDM_SUBJECT, writeable);
2356	WinEnableMenuItem((HWND)mp2, IDM_DRVFLAGS, rdy); // fixme to allow if not ready
2357
2358	WinEnableMenuItem((HWND)mp2, IDM_ARCHIVE, rdy);
2359
2360	WinEnableMenuItem((HWND)mp2, IDM_UPDATE, !underenv);
2361	WinEnableMenuItem((HWND)mp2, IDM_EXPANDSUBMENU, !underenv);
2362	WinEnableMenuItem((HWND)mp2, IDM_EXPAND, !underenv);
2363	WinEnableMenuItem((HWND)mp2, IDM_COLLAPSE, !underenv);
2364
2365	WinEnableMenuItem((HWND)mp2, IDM_SIZES, rdy);
2366	WinEnableMenuItem((HWND)mp2, IDM_MKDIR, writeable);
2367	WinEnableMenuItem((HWND)mp2, IDM_SHOWALLFILES, rdy);
2368	WinEnableMenuItem((HWND)mp2, IDM_UNDELETE, writeable);
2369
2370	WinEnableMenuItem((HWND)mp2, IDM_CHKDSK, writeable);
2371	WinEnableMenuItem((HWND)mp2, IDM_FORMAT, writeable);
2372	WinEnableMenuItem((HWND)mp2, IDM_OPTIMIZE, writeable);
2373
2374	WinEnableMenuItem((HWND)mp2, IDM_DETACH,
2375	rdy && (driveflags[chDrvU - 'A'] & DRIVE_REMOTE) != 0);
2376
2377	WinEnableMenuItem((HWND)mp2, IDM_EJECT, removable);
2378
2379	WinEnableMenuItem((HWND)mp2, IDM_LOCK, removable);
2380	WinEnableMenuItem((HWND)mp2, IDM_UNLOCK, removable);
2381
2382	WinEnableMenuItem((HWND)mp2, IDM_DELETE, !underenv && writeable);
2383	WinEnableMenuItem((HWND)mp2, IDM_PERMDELETE, !underenv && writeable);
2384	WinEnableMenuItem((HWND)mp2, IDM_DELETESUBMENU, !underenv && writeable);
2385	WinEnableMenuItem((HWND)mp2, IDM_MOVEMENU, !underenv && writeable);
2386	WinEnableMenuItem((HWND)mp2, IDM_RENAME, !underenv && writeable);
2387
2388	}
2389	}
2390	break;
2391
2392	case IDM_VIEWSMENU:
2393	WinCheckMenuItem((HWND)mp2,
2394	IDM_MINIICONS,
2395	((dcd->flWindowAttr & CV_MINI) != 0));
2396	WinEnableMenuItem((HWND)mp2,
2397	IDM_RESELECT,
2398	FALSE);
2399	break;
2400
2401	case IDM_COMMANDSMENU:
2402	SetupCommandMenu((HWND)mp2,hwnd);
2403	break;
2404
2405	case IDM_SORTSUBMENU:
2406	SetSortChecks((HWND)mp2,TreesortFlags);
2407	break;
2408
2409	case IDM_WINDOWSMENU:
2410	SetupWinList((HWND)mp2,
2411	(hwndMain) ? hwndMain : (HWND)0,
2412	dcd->hwndFrame);
2413	break;
2414	}
2415	dcd->hwndLastMenu = (HWND)mp2;
2416	}
2417	if(msg == WM_INITMENU)
2418	break;
2419	return 0;
2420
2421	case UM_COMMAND:
2422	if (!mp1)
2423	Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
2424	else {
2425	if (!dcd) {
2426	Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
2427	FreeListInfo((LISTINFO *)mp1);
2428	}
2429	else {
2430	if (!PostMsg(dcd->hwndObject,UM_COMMAND,mp1,mp2)) {
2431	Runtime_Error(pszSrcFile, __LINE__, "PostMsg");
2432	FreeListInfo((LISTINFO *)mp1);
2433	}
2434	else
2435	return (MRESULT)TRUE;
2436	}
2437	}
2438	return 0;
2439
2440	case UM_LOADFILE:
2441	if(dcd && mp2) {
2442
2443	HWND ret;
2444
2445	ret = StartMLEEditor(dcd->hwndParent,(INT)mp1,(CHAR *)mp2,
2446	dcd->hwndFrame);
2447	if(mp2)
2448	free((CHAR *)mp2);
2449	return MRFROMLONG(ret);
2450	}
2451	return 0;
2452
2453	case UM_FIXCNRMLE:
2454	case UM_FIXEDITNAME:
2455	return CommonCnrProc(hwnd,msg,mp1,mp2);
2456
2457	case UM_NOTIFY:
2458	if(mp2)
2459	Notify((CHAR *)mp2);
2460	return 0;
2461
2462	case UM_FILTER:
2463	if(dcd) {
2464
2465	BOOL tempsusp = dcd->suspendview;
2466
2467	if(mp1) {
2468	DosEnterCritSec();
2469	SetMask((CHAR *)mp1,&dcd->mask);
2470	DosExitCritSec();
2471	}
2472	dcd->suspendview = TRUE;
2473	dcd->mask.attrFile \|= FILE_DIRECTORY;
2474	WinSendMsg(hwnd,CM_FILTER,MPFROMP(Filter),MPFROMP(&dcd->mask));
2475	dcd->suspendview = tempsusp;
2476	PostMsg(hwnd,UM_RESCAN,MPVOID,MPVOID);
2477	}
2478	return 0;
2479
2480	case UM_DRIVECMD:
2481	if(mp1)
2482	ShowTreeRec(hwnd,(CHAR *)mp1,FALSE,TRUE);
2483	return 0;
2484
2485	case WM_APPTERMINATENOTIFY:
2486	{
2487	APPNOTIFY *info;
2488	PCNRITEM pci;
2489	CHAR s[] = " :\\";
2490
2491	if(!mp2) {
2492	if(hwndMain)
2493	PostMsg(hwndMain,
2494	UM_BUILDDRIVEBAR,
2495	MPVOID,
2496	MPVOID);
2497	}
2498	info = apphead;
2499	while(info) {
2500	if(info->happ == (HAPP)mp1) {
2501	*s = info->device;
2502	pci = FindCnrRecord(hwnd,
2503	s,
2504	NULL,
2505	FALSE,
2506	FALSE,
2507	TRUE);
2508	if(pci && (INT)pci != -1) {
2509	driveserial[info->device - 'A'] = -1;
2510	DriveFlagsOne(info->device - 'A');
2511	if(driveflags[info->device - 'A'] &
2512	(DRIVE_INVALID \| DRIVE_IGNORE))
2513	WinSendMsg(hwnd,
2514	CM_REMOVERECORD,
2515	MPFROMP(&pci),
2516	MPFROM2SHORT(1,CMA_FREE));
2517	else
2518	Flesh(hwnd,pci);
2519	}
2520	if(info->prev)
2521	info->prev->next = info->next;
2522	if(info->next)
2523	info->next->prev = info->prev;
2524	if(apphead == info)
2525	apphead = info->next;
2526	if(apptail == info)
2527	apptail = info->prev;
2528	free(info);
2529	break;
2530	}
2531	info = info->next;
2532	}
2533	}
2534	break;
2535
2536	case WM_COMMAND:
2537	DosError(FERR_DISABLEHARDERR);
2538	if(dcd) {
2539	if(SwitchCommand(dcd->hwndLastMenu,
2540	SHORT1FROMMP(mp1)))
2541	return 0;
2542	switch(SHORT1FROMMP(mp1)) {
2543	case IDM_SETTARGET:
2544	SetTargetDir(hwnd,FALSE);
2545	break;
2546
2547	case IDM_DETACH:
2548	{
2549	CHAR d[3] = " :";
2550	PCNRITEM pci;
2551	PROGDETAILS pgd;
2552	CHAR params[368],*p;
2553	HAPP happ;
2554
2555
2556	pci = (PCNRITEM)CurrentRecord(hwnd);
2557	if(pci && (INT)pci != -1 && isalpha(*pci->szFileName)) {
2558	d = toupper(pci->szFileName);
2559	p = GetCmdSpec(FALSE);
2560	memset(&pgd,0,sizeof(pgd));
2561	pgd.Length = sizeof(pgd);
2562	pgd.progt.progc = PROG_WINDOWABLEVIO;
2563	pgd.progt.fbVisible = SHE_VISIBLE;
2564	pgd.pszTitle = GetPString(IDS_DETACHREQUESTTEXT);
2565	pgd.pszExecutable = p;
2566	pgd.pszParameters = params;
2567	pgd.pszStartupDir = NULL;
2568	pgd.pszIcon = NULL;
2569	pgd.pszEnvironment = NULL;
2570	pgd.swpInitial.hwndInsertBehind = HWND_TOP;
2571	pgd.swpInitial.hwnd = hwnd;
2572	pgd.swpInitial.fl = SWP_SHOW \| SWP_ACTIVATE;
2573	sprintf(params,"/C NET USE %s /D",d);
2574	happ = WinStartApp(hwnd,&pgd,pgd.pszParameters,
2575	NULL,SAF_MAXIMIZED);
2576	if (!happ) {
2577	saymsg(MB_CANCEL \| MB_ICONEXCLAMATION,hwnd,
2578	GetPString(IDS_ERRORTEXT),
2579	GetPString(IDS_CANTSTARTTEXT),
2580	p,params);
2581	}
2582	else {
2583	APPNOTIFY *info;
2584
2585	info = xmallocz(sizeof(APPNOTIFY), pszSrcFile, __LINE__);
2586	if (info) {
2587	info->happ = happ;
2588	info->device = *d;
2589	if (!apphead)
2590	apphead = info;
2591	else {
2592	apptail->next = info;
2593	info->prev = apptail;
2594	}
2595	apptail = info;
2596	}
2597	}
2598	}
2599	}
2600	break;
2601
2602	case IDM_REMAP:
2603	WinDlgBox(HWND_DESKTOP,hwnd,RemapDlgProc,
2604	FM3ModHandle,MAP_FRAME,NULL);
2605	break;
2606
2607	case IDM_CONTEXTMENU:
2608	{
2609	PCNRITEM pci;
2610
2611	pci = (PCNRITEM)CurrentRecord(hwnd);
2612	PostMsg(hwnd,WM_CONTROL,MPFROM2SHORT(DIR_CNR,CN_CONTEXTMENU),
2613	MPFROMP(pci));
2614	}
2615	break;
2616
2617	case IDM_FINDINTREE:
2618	{
2619	CHAR dir[CCHMAXPATH];
2620	PCNRITEM pci;
2621
2622	pci = (PCNRITEM)CurrentRecord(hwnd);
2623	if(pci && (INT)pci != -1) {
2624	strcpy(dir,pci->szFileName);
2625	MakeValidDir(dir);
2626	}
2627	else
2628	save_dir2(dir);
2629	if(WinDlgBox(HWND_DESKTOP,dcd->hwndParent,
2630	WalkAllDlgProc,
2631	FM3ModHandle,WALK_FRAME,
2632	MPFROMP(dir)) && *dir)
2633	WinSendMsg(hwnd,UM_SHOWME,MPFROMP(dir),MPFROMLONG(1L));
2634	}
2635	break;
2636
2637	case IDM_BEGINEDIT:
2638	OpenEdit(hwnd);
2639	break;
2640
2641	case IDM_ENDEDIT:
2642	WinSendMsg(hwnd,
2643	CM_CLOSEEDIT,
2644	MPVOID,
2645	MPVOID);
2646	break;
2647
2648	case IDM_FILTER:
2649	{
2650	BOOL empty = FALSE;
2651	PCNRITEM pci;
2652
2653	pci = (PCNRITEM)CurrentRecord(hwnd);
2654	if(!*dcd->mask.szMask)
2655	empty = TRUE;
2656	dcd->mask.fIsTree = TRUE;
2657	*dcd->mask.prompt = 0;
2658	if(pci && (INT)pci != -1)
2659	dcd->mask.fFilesIncluded = ((driveflags[toupper(*pci->szFileName) - 'A'] &
2660	DRIVE_INCLUDEFILES) != 0);
2661	else
2662	dcd->mask.fFilesIncluded = FALSE;
2663	if(WinDlgBox(HWND_DESKTOP,hwnd,PickMaskDlgProc,
2664	FM3ModHandle,MSK_FRAME,MPFROMP(&dcd->mask)))
2665	WinSendMsg(hwnd,UM_FILTER,MPVOID,MPVOID);
2666	else if(empty)
2667	*dcd->mask.szMask = 0;
2668	PrfWriteProfileData(fmprof,appname,"TreeFilter",&dcd->mask,
2669	sizeof(MASK));
2670	}
2671	break;
2672
2673	case IDM_SHOWSORT:
2674	QuickPopup(hwnd,dcd,CheckMenu(&TreeCnrMenu,TREECNR_POPUP),
2675	IDM_SORTSUBMENU);
2676	break;
2677
2678	case IDM_SHOWSELECT:
2679	QuickPopup(hwnd,dcd,CheckMenu(&TreeCnrMenu,TREECNR_POPUP),
2680	IDM_SELECTSUBMENU);
2681	break;
2682
2683	case IDM_NOTEBOOK:
2684	if(!ParentIsDesktop(dcd->hwndParent,dcd->hwndParent))
2685	PostMsg(dcd->hwndParent,msg,mp1,mp2);
2686	else
2687	WinDlgBox(HWND_DESKTOP,hwnd,CfgDlgProc,FM3ModHandle,
2688	CFG_FRAME,(PVOID)"Tree");
2689	break;
2690
2691	case IDM_WALKDIR:
2692	case IDM_OPENWALK:
2693	{
2694	CHAR newpath[CCHMAXPATH];
2695	PCNRITEM pci;
2696
2697	pci = (PCNRITEM)CurrentRecord(hwnd);
2698	if(pci && (INT)pci != -1) {
2699	strcpy(newpath,pci->szFileName);
2700	MakeValidDir(newpath);
2701	}
2702	else
2703	save_dir2(newpath);
2704	if(!WinDlgBox(HWND_DESKTOP,dcd->hwndParent,WalkAllDlgProc,
2705	FM3ModHandle,WALK_FRAME,
2706	MPFROMP(newpath)) \|\| !*newpath)
2707	break;
2708	WinSendMsg(hwnd,UM_OPENWINDOWFORME,MPFROMP(newpath),MPVOID);
2709	}
2710	break;
2711
2712	case IDM_HELP:
2713	if(hwndHelp) {
2714	if(!ParentIsDesktop(dcd->hwndFrame,dcd->hwndParent))
2715	PostMsg(dcd->hwndParent,UM_COMMAND,mp1,mp2);
2716	else
2717	WinSendMsg(hwndHelp,HM_HELP_CONTENTS,MPVOID,MPVOID);
2718	}
2719	break;
2720
2721	case IDM_PARTITION:
2722	runemf2(SEPARATE \| WINDOWED,HWND_DESKTOP,NULL,NULL,
2723	"%s","MINILVM.EXE");
2724	break;
2725
2726	case IDM_PARTITIONDF:
2727	runemf2(SEPARATE \| WINDOWED,HWND_DESKTOP,NULL,NULL,
2728	"%s","DFSOS2.EXE");
2729	break;
2730
2731	case IDM_PARTITIONLVMG:
2732	runemf2(SEPARATE \| WINDOWED,HWND_DESKTOP,NULL,NULL,
2733	"%s","LVMGUI.CMD");
2734	break;
2735
2736	case IDM_PARTITIONFD:
2737	runemf2(SEPARATE \| WINDOWED,HWND_DESKTOP,NULL,NULL,
2738	"%s","FDISKPM.EXE");
2739	break;
2740
2741	case IDM_SORTNAME:
2742	case IDM_SORTFILENAME:
2743	case IDM_SORTSIZE:
2744	case IDM_SORTEASIZE:
2745	case IDM_SORTFIRST:
2746	case IDM_SORTLAST:
2747	case IDM_SORTLWDATE:
2748	case IDM_SORTLADATE:
2749	case IDM_SORTCRDATE:
2750	TreesortFlags &= (SORT_REVERSE \| SORT_DIRSFIRST \| SORT_DIRSLAST);
2751	case IDM_SORTDIRSFIRST:
2752	case IDM_SORTDIRSLAST:
2753	case IDM_SORTREVERSE:
2754	switch(SHORT1FROMMP(mp1)) {
2755	case IDM_SORTFILENAME:
2756	TreesortFlags \|= SORT_FILENAME;
2757	break;
2758	case IDM_SORTSIZE:
2759	TreesortFlags \|= SORT_SIZE;
2760	break;
2761	case IDM_SORTEASIZE:
2762	TreesortFlags \|= SORT_EASIZE;
2763	break;
2764	case IDM_SORTFIRST:
2765	TreesortFlags \|= SORT_FIRSTEXTENSION;
2766	break;
2767	case IDM_SORTLAST:
2768	TreesortFlags \|= SORT_LASTEXTENSION;
2769	break;
2770	case IDM_SORTLWDATE:
2771	TreesortFlags \|= SORT_LWDATE;
2772	break;
2773	case IDM_SORTLADATE:
2774	TreesortFlags \|= SORT_LADATE;
2775	break;
2776	case IDM_SORTCRDATE:
2777	TreesortFlags \|= SORT_CRDATE;
2778	break;
2779	case IDM_SORTDIRSFIRST:
2780	if(TreesortFlags & SORT_DIRSFIRST)
2781	TreesortFlags &= (~SORT_DIRSFIRST);
2782	else {
2783	TreesortFlags \|= SORT_DIRSFIRST;
2784	TreesortFlags &= (~SORT_DIRSLAST);
2785	}
2786	break;
2787	case IDM_SORTDIRSLAST:
2788	if(TreesortFlags & SORT_DIRSLAST)
2789	TreesortFlags &= (~SORT_DIRSLAST);
2790	else {
2791	TreesortFlags \|= SORT_DIRSLAST;
2792	TreesortFlags &= (~SORT_DIRSFIRST);
2793	}
2794	break;
2795	case IDM_SORTREVERSE:
2796	if(TreesortFlags & SORT_REVERSE)
2797	TreesortFlags &= (~SORT_REVERSE);
2798	else
2799	TreesortFlags \|= SORT_REVERSE;
2800	break;
2801	}
2802	PrfWriteProfileData(fmprof,appname,"TreeSort",&TreesortFlags,
2803	sizeof(INT));
2804	WinSendMsg(hwnd,CM_SORTRECORD,MPFROMP(SortTreeCnr),MPVOID);
2805	break;
2806
2807	case IDM_COLLECT:
2808	if(!Collector) {
2809
2810	HWND hwndC;
2811	SWP swp;
2812
2813	if(!ParentIsDesktop(hwnd,dcd->hwndParent) &&
2814	!fAutoTile &&
2815	(!fExternalCollector &&
2816	(ULONG )realappname == FM3UL))
2817	GetNextWindowPos(dcd->hwndParent,
2818	&swp,
2819	NULL,
2820	NULL);
2821	hwndC = StartCollector((fExternalCollector \|\|
2822	(ULONG )realappname != FM3UL) ?
2823	HWND_DESKTOP :
2824	dcd->hwndParent,
2825	4);
2826	if(hwndC) {
2827	if(!ParentIsDesktop(hwnd,
2828	dcd->hwndParent) &&
2829	!fAutoTile &&
2830	(!fExternalCollector &&
2831	(ULONG )realappname == FM3UL))
2832	WinSetWindowPos(hwndC,
2833	HWND_TOP,
2834	swp.x,
2835	swp.y,
2836	swp.cx,
2837	swp.cy,
2838	SWP_MOVE \| SWP_SIZE \|
2839	SWP_SHOW \| SWP_ZORDER);
2840	else if(!ParentIsDesktop(hwnd,
2841	dcd->hwndParent) &&
2842	fAutoTile &&
2843	(ULONG )realappname == FM3UL)
2844	TileChildren(dcd->hwndParent,
2845	TRUE);
2846	}
2847	WinSetWindowPos(hwndC,
2848	HWND_TOP,
2849	0,
2850	0,
2851	0,
2852	0,
2853	SWP_ACTIVATE);
2854	DosSleep(250L);
2855	}
2856	else
2857	StartCollector(dcd->hwndParent,
2858	4);
2859	PostMsg(hwnd,
2860	WM_COMMAND,
2861	MPFROM2SHORT(IDM_COLLECTOR,0),
2862	MPVOID);
2863	break;
2864
2865	case IDM_COLLECTOR:
2866	DosSleep(64L);
2867	{
2868	CHAR **list;
2869
2870	list = BuildList(hwnd);
2871	if(list) {
2872	if(Collector) {
2873	if(!PostMsg(Collector,WM_COMMAND,
2874	MPFROM2SHORT(IDM_COLLECTOR,0),
2875	MPFROMP(list)))
2876	FreeList(list);
2877	}
2878	else
2879	FreeList(list);
2880	}
2881	}
2882	break;
2883
2884	case IDM_COLLAPSEALL:
2885	WinSendMsg(hwnd,
2886	CM_COLLAPSETREE,
2887	MPVOID,
2888	MPVOID);
2889	break;
2890
2891	case IDM_COLLAPSE:
2892	case IDM_EXPAND:
2893	{
2894	PCNRITEM pci = NULL;
2895
2896	pci = (PCNRITEM)CurrentRecord(hwnd);
2897	if(pci && (INT)pci != -1) {
2898	if(pci->flags & RECFLAGS_UNDERENV)
2899	break;
2900	PostMsg(dcd->hwndObject,
2901	UM_EXPAND,
2902	mp1,
2903	MPFROMP(pci));
2904	}
2905	}
2906	break;
2907
2908	case IDM_UPDATE:
2909	{
2910	PCNRITEM pci = NULL;
2911
2912	pci = (PCNRITEM)CurrentRecord(hwnd);
2913	if(pci && (INT)pci != -1) {
2914	if(pci->attrFile & FILE_DIRECTORY) {
2915	if(pci->flags & RECFLAGS_UNDERENV)
2916	break;
2917	UnFlesh(hwnd,pci);
2918	if(driveflags[toupper(*pci->szFileName) - 'A'] & (DRIVE_INVALID \|
2919	DRIVE_NOPRESCAN)) {
2920	driveflags[toupper(*pci->szFileName) - 'A'] &= (DRIVE_IGNORE \|
2921	DRIVE_NOPRESCAN \| DRIVE_NOLOADICONS \|
2922	DRIVE_NOLOADSUBJS \| DRIVE_NOLOADLONGS);
2923	DriveFlagsOne(toupper(*pci->szFileName) - 'A');
2924	if(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_INVALID)
2925	pci->rc.hptrIcon = hptrDunno;
2926	else {
2927	if(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_CDROM)
2928	pci->rc.hptrIcon = hptrCDROM;
2929	else
2930	pci->rc.hptrIcon = (driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_REMOVABLE) ?
2931	hptrRemovable :
2932	(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_REMOTE) ?
2933	hptrRemote :
2934	(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_ZIPSTREAM) ?
2935	hptrZipstrm : hptrDrive;
2936	}
2937	WinSendMsg(hwnd,
2938	CM_INVALIDATERECORD,
2939	MPFROMP(&pci),
2940	MPFROM2SHORT(1,CMA_ERASE \| CMA_REPOSITION));
2941	if(hwndMain)
2942	PostMsg(hwndMain,
2943	UM_BUILDDRIVEBAR,
2944	MPVOID,
2945	MPVOID);
2946	}
2947	if(!(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_INVALID))
2948	Flesh(hwnd,pci);
2949	}
2950	else {
2951
2952	}
2953	}
2954	}
2955	break;
2956
2957	case IDM_RESCAN:
2958	PostMsg(dcd->hwndObject,
2959	UM_RESCAN,
2960	MPVOID,
2961	MPVOID);
2962	break;
2963
2964	case IDM_RESORT:
2965	WinSendMsg(hwnd,
2966	CM_SORTRECORD,
2967	MPFROMP(SortTreeCnr),
2968	MPVOID);
2969	break;
2970
2971	case IDM_TEXT:
2972	case IDM_MINIICONS:
2973	{
2974	CNRINFO cnri;
2975
2976	memset(&cnri,0,sizeof(CNRINFO));
2977	cnri.cb = sizeof(CNRINFO);
2978	WinSendMsg(hwnd,
2979	CM_QUERYCNRINFO,
2980	MPFROMP(&cnri),
2981	MPFROMLONG(sizeof(CNRINFO)));
2982	if(SHORT1FROMMP(mp1) == IDM_MINIICONS) {
2983	if(cnri.flWindowAttr & CV_MINI)
2984	cnri.flWindowAttr &= (~CV_MINI);
2985	else
2986	cnri.flWindowAttr \|= CV_MINI;
2987	}
2988	else {
2989	if(cnri.flWindowAttr & CV_TEXT) {
2990	cnri.flWindowAttr &= (~CV_TEXT);
2991	cnri.flWindowAttr \|= CV_ICON;
2992	}
2993	else {
2994	cnri.flWindowAttr &= (~CV_ICON);
2995	cnri.flWindowAttr \|= CV_TEXT;
2996	}
2997	}
2998	dcd->flWindowAttr = cnri.flWindowAttr;
2999	PrfWriteProfileData(fmprof,
3000	appname,
3001	"TreeflWindowAttr",
3002	&cnri.flWindowAttr,
3003	sizeof(ULONG));
3004	WinSendMsg(hwnd,
3005	CM_SETCNRINFO,
3006	MPFROMP(&cnri),
3007	MPFROMLONG(CMA_FLWINDOWATTR \| CMA_TREEICON \|
3008	CMA_SLTREEBITMAPORICON));
3009	}
3010	break;
3011
3012	case IDM_SIZES:
3013	case IDM_DRVFLAGS:
3014	case IDM_SHOWALLFILES:
3015	case IDM_UNDELETE:
3016	case IDM_OPTIMIZE:
3017	case IDM_CHKDSK:
3018	case IDM_FORMAT:
3019	case IDM_MKDIR:
3020	case IDM_LOCK:
3021	case IDM_UNLOCK:
3022	case IDM_EJECT:
3023	case IDM_CLOSETRAY:
3024	{
3025	PCNRITEM pci;
3026
3027	pci = (PCNRITEM)CurrentRecord(hwnd);
3028	if(pci && (INT)pci != -1)
3029	CommonDriveCmd(hwnd,
3030	pci->szFileName,
3031	SHORT1FROMMP(mp1));
3032	}
3033	break;
3034
3035	case IDM_SAVETOLIST:
3036	WinDlgBox(HWND_DESKTOP,
3037	hwnd,
3038	SaveListDlgProc,
3039	FM3ModHandle,
3040	SAV_FRAME,
3041	MPFROMP(&hwnd));
3042	break;
3043
3044	case IDM_DELETE:
3045	case IDM_PERMDELETE:
3046	case IDM_MOVE:
3047	case IDM_WPSMOVE:
3048	case IDM_WILDMOVE:
3049	case IDM_RENAME:
3050	{
3051	PCNRITEM pci;
3052
3053	pci = (PCNRITEM)CurrentRecord(hwnd);
3054	if(pci && (INT)pci != -1) {
3055	if(pci->flags & RECFLAGS_UNDERENV)
3056	break;
3057	}
3058	}
3059	/* else intentional fallthru */
3060	case IDM_ATTRS:
3061	case IDM_INFO:
3062	case IDM_COPY:
3063	case IDM_WPSCOPY:
3064	case IDM_WILDCOPY:
3065	case IDM_DOITYOURSELF:
3066	case IDM_OPENWINDOW:
3067	case IDM_OPENSETTINGS:
3068	case IDM_OPENDEFAULT:
3069	case IDM_OPENICON:
3070	case IDM_OPENDETAILS:
3071	case IDM_OPENTREE:
3072	case IDM_SHADOW:
3073	case IDM_SHADOW2:
3074	case IDM_COMPARE:
3075	case IDM_VIEW:
3076	case IDM_VIEWTEXT:
3077	case IDM_VIEWBINARY:
3078	case IDM_EDIT:
3079	case IDM_EDITTEXT:
3080	case IDM_EDITBINARY:
3081	case IDM_EAS:
3082	case IDM_SUBJECT:
3083	case IDM_APPENDTOCLIP:
3084	case IDM_SAVETOCLIP:
3085	case IDM_ARCHIVE:
3086	case IDM_MCIPLAY:
3087	case IDM_UUDECODE:
3088	{
3089	LISTINFO *li;
3090	ULONG action = UM_ACTION;
3091
3092	li = xmallocz(sizeof(LISTINFO),pszSrcFile,__LINE__);
3093	if (li) {
3094	li->type = SHORT1FROMMP(mp1);
3095	li->hwnd = hwnd;
3096	li->list = BuildList(hwnd);
3097	if(!li->list \|\| !li->list[0]) {
3098	free(li);
3099	break;
3100	}
3101	if(IsRoot(li->list[0])) {
3102	switch(SHORT1FROMMP(mp1)) {
3103	case IDM_MOVE:
3104	case IDM_COPY:
3105	case IDM_WILDCOPY:
3106	case IDM_WILDMOVE:
3107	case IDM_WPSMOVE:
3108	case IDM_WPSCOPY:
3109	case IDM_RENAME:
3110	case IDM_DELETE:
3111	case IDM_PERMDELETE:
3112	mp1 = MPFROM2SHORT(IDM_INFO,SHORT2FROMMP(mp1));
3113	li->type = IDM_INFO;
3114	break;
3115	}
3116	}
3117	switch(SHORT1FROMMP(mp1)) {
3118	case IDM_APPENDTOCLIP:
3119	case IDM_SAVETOCLIP:
3120	case IDM_ARCHIVE:
3121	case IDM_DELETE:
3122	case IDM_PERMDELETE:
3123	case IDM_ATTRS:
3124	case IDM_SHADOW:
3125	case IDM_SHADOW2:
3126	case IDM_DOITYOURSELF:
3127	case IDM_EAS:
3128	case IDM_VIEW:
3129	case IDM_VIEWTEXT:
3130	case IDM_VIEWBINARY:
3131	case IDM_EDIT:
3132	case IDM_EDITTEXT:
3133	case IDM_EDITBINARY:
3134	case IDM_MCIPLAY:
3135	action = UM_MASSACTION;
3136	break;
3137	}
3138	if(SHORT1FROMMP(mp1) == IDM_SHADOW \|\|
3139	SHORT1FROMMP(mp1) == IDM_SHADOW2)
3140	*li->targetpath = 0;
3141	if(!PostMsg(dcd->hwndObject,action,MPFROMP(li),MPVOID)) {
3142	Runtime_Error(pszSrcFile, __LINE__, "PostMsg");
3143	FreeListInfo(li);
3144	}
3145	}
3146	}
3147	break;
3148
3149	default:
3150	if(SHORT1FROMMP(mp1) >= IDM_COMMANDSTART &&
3151	SHORT1FROMMP(mp1) < IDM_QUICKTOOLSTART) {
3152
3153	INT x;
3154
3155	if(!cmdloaded)
3156	load_commands();
3157	x = SHORT1FROMMP(mp1) - IDM_COMMANDSTART;
3158	if(x >= 0) {
3159	x++;
3160	RunCommand(hwnd,x);
3161	if(fUnHilite)
3162	UnHilite(hwnd,TRUE,&dcd->lastselection);
3163	}
3164	}
3165	break;
3166	}
3167	}
3168	return 0;
3169
3170	case WM_SAVEAPPLICATION:
3171	if(dcd && !ParentIsDesktop(hwnd,dcd->hwndParent)) {
3172
3173	SWP swp,swpP;
3174	INT ratio;
3175
3176	WinQueryWindowPos(dcd->hwndFrame,&swp);
3177	if(!(swp.fl & (SWP_MINIMIZE \| SWP_MAXIMIZE \| SWP_HIDE))) {
3178	WinQueryWindowPos(dcd->hwndParent,&swpP);
3179	ratio = (swpP.cx * 100) / swp.cx;
3180	if(ratio > 0)
3181	PrfWriteProfileData(fmprof,appname,"TreeWindowRatio",
3182	&ratio,sizeof(INT));
3183	}
3184	}
3185	else if(dcd && ParentIsDesktop(hwnd,dcd->hwndParent)) {
3186
3187	SWP swp;
3188
3189	WinQueryWindowPos(dcd->hwndFrame,&swp);
3190	if(!(swp.fl & (SWP_HIDE \| SWP_MINIMIZE \| SWP_MAXIMIZE)))
3191	WinStoreWindowPos(FM2Str,"VTreeWindowPos",dcd->hwndFrame);
3192	}
3193	break;
3194
3195	case UM_MINIMIZE:
3196	if(dcd && hwndMain) {
3197	fOkayMinimize = TRUE;
3198	if(dcd->hwndObject && !fDummy) {
3199	DosSleep(100L);
3200	if(!fDummy) {
3201	fOkayMinimize = FALSE;
3202	WinSetWindowPos(((hwndMain) ? WinQueryWindow(hwndMain,QW_PARENT) :
3203	dcd->hwndFrame),HWND_TOP,0,0,0,0,SWP_MINIMIZE \|
3204	SWP_DEACTIVATE);
3205	}
3206	}
3207	}
3208	return 0;
3209
3210	case UM_MAXIMIZE:
3211	if(dcd \|\| hwndMain)
3212	WinSetWindowPos(((hwndMain) ? WinQueryWindow(hwndMain,QW_PARENT) :
3213	dcd->hwndFrame),HWND_TOP,0,0,0,0,SWP_MAXIMIZE \|
3214	SWP_SHOW);
3215	return 0;
3216
3217	case UM_CLOSE:
3218	{
3219	HWND hwndParent = WinQueryWindow(WinQueryWindow(WinQueryWindow(hwnd,
3220	QW_PARENT),QW_PARENT),QW_PARENT);
3221
3222	if(!mp1) {
3223	if(!PostMsg((HWND)0,WM_QUIT,MPVOID,MPVOID))
3224	WinSendMsg((HWND)0,WM_QUIT,MPVOID,MPVOID);
3225	if(hwndParent && !ParentIsDesktop(hwnd,hwndParent))
3226	WinDestroyWindow(hwndParent);
3227	}
3228	else
3229	WinDestroyWindow(WinQueryWindow(WinQueryWindow(hwnd,QW_PARENT),
3230	QW_PARENT));
3231	}
3232	return 0;
3233
3234	case WM_CLOSE:
3235	WinSendMsg(hwnd,WM_SAVEAPPLICATION,MPVOID,MPVOID);
3236	if(dcd)
3237	dcd->stopflag++;
3238	if(dcd && dcd->hwndObject) {
3239	/* kill object window */
3240	if(!PostMsg(dcd->hwndObject,WM_CLOSE,MPVOID,MPVOID))
3241	WinSendMsg(dcd->hwndObject,WM_CLOSE,MPVOID,MPVOID);
3242	}
3243	else
3244	WinSendMsg(hwnd,UM_CLOSE,MPFROMLONG(1L),MPVOID);
3245	return 0;
3246
3247	case WM_DESTROY:
3248	if(TreeCnrMenu)
3249	WinDestroyWindow(TreeCnrMenu);
3250	if(DirMenu)
3251	WinDestroyWindow(DirMenu);
3252	if(FileMenu)
3253	WinDestroyWindow(FileMenu);
3254	TreeCnrMenu = FileMenu = DirMenu = (HWND)0;
3255	EmptyCnr(hwnd);
3256	if(apphead) {
3257
3258	APPNOTIFY info,next;
3259
3260	info = apphead;
3261	while(info) {
3262	next = info->next;
3263	free(info);
3264	info = next;
3265	}
3266	apphead = apptail = NULL;
3267	}
3268	break;
3269	}
3270	return (dcd && dcd->oldproc) ? dcd->oldproc(hwnd,msg,mp1,mp2) :
3271	PFNWPCnr(hwnd,msg,mp1,mp2);
3272	}
3273
3274
3275	HWND StartTreeCnr (HWND hwndParent,ULONG flags)
3276	{
3277	/* bitmapped flags:
3278	* 0x00000001 = don't close app when window closes
3279	* 0x00000002 = no frame controls
3280	*/
3281
3282	HWND hwndFrame = (HWND)0,hwndClient;
3283	ULONG FrameFlags = FCF_TITLEBAR \| FCF_SYSMENU \|
3284	FCF_SIZEBORDER \| FCF_MINMAX \|
3285	FCF_ICON \| FCF_NOBYTEALIGN \|
3286	FCF_ACCELTABLE;
3287	DIRCNRDATA *dcd;
3288
3289	if(!hwndParent)
3290	hwndParent = HWND_DESKTOP;
3291	if(ParentIsDesktop(hwndParent,hwndParent))
3292	FrameFlags \|= (FCF_TASKLIST \| FCF_MENU);
3293	if(flags & 2)
3294	FrameFlags &= (~(FCF_TITLEBAR \| FCF_SYSMENU \| FCF_SIZEBORDER \|
3295	FCF_MINMAX \| FCF_ICON));
3296	hwndFrame = WinCreateStdWindow(hwndParent,
3297	WS_VISIBLE,
3298	&FrameFlags,
3299	GetPString(IDS_WCTREECONTAINER),
3300	NULL,
3301	WS_VISIBLE \| fwsAnimate,
3302	FM3ModHandle,
3303	TREE_FRAME,
3304	&hwndClient);
3305	if(hwndFrame && hwndClient) {
3306	dcd = xmalloc(sizeof(DIRCNRDATA), pszSrcFile, __LINE__);
3307	if (!dcd) {
3308	Runtime_Error(pszSrcFile,__LINE__,GetPString(IDS_OUTOFMEMORY));
3309	PostMsg(hwndClient,WM_CLOSE,MPVOID,MPVOID);
3310	hwndFrame = (HWND)0;
3311	}
3312	else {
3313	SWP swp;
3314	WinQueryWindowPos(hwndFrame,&swp);
3315	if ((ULONG )realappname == FM3UL) {
3316	if (!WinCreateWindow(hwndFrame,
3317	GetPString(IDS_WCTREEOPENBUTTON),
3318	"O",
3319	WS_VISIBLE \| BS_PUSHBUTTON \| BS_NOPOINTERFOCUS,
3320	((swp.cx - WinQuerySysValue(HWND_DESKTOP,SV_CXMINMAXBUTTON)) -
3321	WinQuerySysValue(HWND_DESKTOP,SV_CXMINMAXBUTTON) / 2) -
3322	WinQuerySysValue(HWND_DESKTOP,SV_CXSIZEBORDER),
3323	(swp.cy - WinQuerySysValue(HWND_DESKTOP,SV_CYMINMAXBUTTON)) -
3324	WinQuerySysValue(HWND_DESKTOP,SV_CYSIZEBORDER),
3325	WinQuerySysValue(HWND_DESKTOP,SV_CXMINMAXBUTTON) / 2,
3326	WinQuerySysValue(HWND_DESKTOP,SV_CYMINMAXBUTTON),
3327	hwndFrame,
3328	HWND_TOP,
3329	IDM_OPENWINDOW,
3330	NULL,
3331	NULL))
3332	{
3333	Win_Error2(hwndFrame,hwndParent,pszSrcFile,__LINE__,IDS_WINCREATEWINDOW);
3334	}
3335	}
3336	else {
3337	if (!WinCreateWindow(hwndFrame,
3338	GetPString(IDS_WCTREESTATUS),
3339	GetPString(IDS_YOUAREHERETEXT),
3340	WS_VISIBLE \| SS_TEXT \| DT_LEFT \| DT_VCENTER,
3341	swp.x + 4 + WinQuerySysValue(HWND_DESKTOP,
3342	SV_CXSIZEBORDER),
3343	swp.cy - (22 + WinQuerySysValue(HWND_DESKTOP,
3344	SV_CYSIZEBORDER)),
3345	(swp.cx - 8) - (WinQuerySysValue(HWND_DESKTOP,
3346	SV_CXSIZEBORDER) * 2),
3347	22,
3348	hwndFrame,
3349	HWND_TOP,
3350	MAIN_STATUS,
3351	NULL,
3352	NULL))
3353	{
3354	Win_Error2(hwndFrame,hwndParent,pszSrcFile,__LINE__,IDS_WINCREATEWINDOW);
3355	}
3356	}
3357	memset(dcd,0,sizeof(DIRCNRDATA));
3358	dcd->size = sizeof(DIRCNRDATA);
3359	dcd->type = TREE_FRAME;
3360	dcd->dontclose = ((flags & 1) != 0);
3361	dcd->hwndParent = (hwndParent) ? hwndParent : HWND_DESKTOP;
3362	dcd->hwndClient = hwndClient;
3363	dcd->hwndFrame = hwndFrame;
3364	{
3365	PFNWP oldproc;
3366
3367	oldproc = WinSubclassWindow(hwndFrame,TreeFrameWndProc);
3368	WinSetWindowPtr(hwndFrame,QWL_USER,(PVOID)oldproc);
3369	oldproc = WinSubclassWindow(WinWindowFromID(hwndFrame,FID_TITLEBAR),
3370	(PFNWP)TreeTitleWndProc);
3371	WinSetWindowPtr(WinWindowFromID(hwndFrame,FID_TITLEBAR),
3372	QWL_USER,
3373	(PVOID)oldproc);
3374	}
3375	dcd->hwndCnr = WinCreateWindow(hwndClient,
3376	WC_CONTAINER,
3377	NULL,
3378	CCS_AUTOPOSITION \| CCS_MINIICONS \|
3379	CCS_MINIRECORDCORE \| WS_VISIBLE,
3380	0,
3381	0,
3382	0,
3383	0,
3384	hwndClient,
3385	HWND_TOP,
3386	(ULONG)TREE_CNR,
3387	NULL,
3388	NULL);
3389	if (!dcd->hwndCnr) {
3390	Win_Error2(hwndClient,hwndClient,pszSrcFile,__LINE__,IDS_WINCREATEWINDOW);
3391	PostMsg(hwndClient,WM_CLOSE,MPVOID,MPVOID);
3392	free(dcd);
3393	hwndFrame = (HWND)0;
3394	}
3395	else {
3396	WinSetWindowPtr(dcd->hwndCnr,QWL_USER,(PVOID)dcd);
3397	if(ParentIsDesktop(hwndFrame,hwndParent)) {
3398	WinSetWindowText(WinWindowFromID(hwndFrame,FID_TITLEBAR),"VTree");
3399	FixSwitchList(hwndFrame,"VTree");
3400	}
3401	else {
3402	WinSetWindowText(hwndFrame,GetPString(IDS_TREETEXT));
3403	WinSetWindowText(WinWindowFromID(hwndFrame,FID_TITLEBAR),
3404	GetPString(IDS_TREETEXT));
3405	}
3406	dcd->oldproc = WinSubclassWindow(dcd->hwndCnr,TreeCnrWndProc);
3407	if(!PostMsg(dcd->hwndCnr,UM_SETUP,MPVOID,MPVOID))
3408	WinSendMsg(dcd->hwndCnr,UM_SETUP,MPVOID,MPVOID);
3409	}
3410	}
3411	}
3412	return hwndFrame;
3413	}
3414

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

Download in other formats: