Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

source: trunk/dll/treecnr.c@ 17

Visit:

Last change on this file since 17 was 2, checked in by root, 23 years ago
Initial revision
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 108.0 KB

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

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

Download in other formats: