Context Navigation

source: trunk/dll/treecnr.c@ 452

Visit:

Last change on this file since 452 was 443, checked in by root, 19 years ago
Rework SetMask args
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 78.3 KB

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

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

Download in other formats: