Context Navigation

source: trunk/dll/dircnrs.c@ 880

Visit:

Last change on this file since 880 was 877, checked in by Gregg Young, 18 years ago
Cleaned up actual fix for drop down menu fonts and colors not matching.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 90.4 KB

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

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

Download in other formats: