Context Navigation

source: trunk/dll/misc.c@ 1835

Visit:

Last change on this file since 1835 was 1835, checked in by Gregg Young, 10 years ago
Make sure a pci->pszFileName can be made a NullStr by direct edit.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 79.9 KB

Line
1	/***********************************************************************
2
3	$Id: misc.c 1835 2015-07-15 00:44:38Z gyoung $
4
5	Misc GUI support functions
6
7	Copyright (c) 1993-98 M. Kimes
8	Copyright (c) 2003, 2010 Steven H. Levine
9
10	11 Jun 03 SHL Add JFS and FAT32 support
11	01 Aug 04 SHL Rework lstrip/rstrip usage
12	01 Aug 04 SHL LoadLibPath: avoid buffer overflow
13	07 Jun 05 SHL Drop obsoletes
14	24 Jul 05 SHL Beautify
15	24 Jul 05 SHL Correct longname display option
16	17 Jul 06 SHL Use Runtime_Error
17	26 Jul 06 SHL Use chop_at_crnl
18	27 Jul 06 SHL Comments, apply indent
19	29 Jul 06 SHL Use xfgets_bstripcr
20	16 Aug 06 SHL Comments
21	31 Aug 06 SHL disable_menuitem: rework args to match name - sheesh
22	10 Oct 06 GKY Add NDFS32 support
23	18 Feb 07 GKY More drive type and drive icon support
24	10 Jun 07 GKY Add IsFm2Window as part of work around PM drag limit
25	05 Jul 07 GKY Fix menu removals for WORKPLACE_PROCESS=YES
26	23 Jul 07 SHL Sync with CNRITEM updates (ticket#24)
27	31 Jul 07 SHL Clean up and report errors (ticket#24)
28	03 Aug 07 GKY Direct editting fixed (ticket#24)
29	06 Aug 07 SHL Use BldQuotedFileName
30	06 Aug 07 GKY Increase Subject EA to 1024
31	06 Aug 07 GKY Reduce DosSleep times (ticket 148)
32	14 Aug 07 SHL Delete obsoletes
33	14 Aug 07 SHL Move #pragma alloc_text to end for OpenWatcom compat
34	01 Sep 07 GKY Use xDosSetPathInfo to fix case where FS3 buffer crosses 64k boundry
35	05 Nov 07 GKY Use commafmtULL to display file sizes for large file support
36	22 Nov 07 GKY Use CopyPresParams to fix presparam inconsistencies in menus
37	12 Jan 08 SHL Document SetConditionalCascade
38	13 Jan 08 GKY Get Subjectwidth/Subjectleft working in the collector.
39	19 Jan 08 JBS Ticket 150: fix/improve save and restore of dir cnr state at FM/2 close/reopen
40	21 Jan 08 GKY Stop reallocating NullStr by direct editing of empty subject and longname strings.
41	29 Feb 08 GKY Use xfree where appropriate
42	08 Mar 08 JBS Ticket 230: Replace prefixless INI keys for default directory containers with
43	keys using a "DirCnr." prefix
44	19 Jun 08 JBS Ticket 239: Fix LoadDetailsSwitches so INI file is read correctly and details
45	switches are set correctly.
46	11 Jul 08 JBS Ticket 230: Simplified code and eliminated some local variables by incorporating
47	all the details view settings (both the global variables and those in the
48	DIRCNRDATA struct) into a new struct: DETAILS_SETTINGS.
49	17 Jul 08 SHL Add GetTidForWindow for Fortify support
50	20 Jul 08 GKY Add save/append filename to clipboard.
51	Change menu wording to make these easier to find
52	23 Aug 08 GKY Add CheckDriveSpaceAvail To pre check drive space to prevent failures
53	25 Dec 08 GKY Add code to allow write verify to be turned off on a per drive basis
54	28 Dec 08 GKY Check for LVM.EXE and remove Refresh removable media menu item as appropriate
55	07 Feb 09 GKY Allow user to turn off alert and/or error beeps in settings notebook.
56	08 Mar 09 GKY Renamed commafmt.h i18nutil.h
57	08 Mar 09 GKY Additional strings move to PCSZs in init.c
58	08 Mar 09 GKY Add WriteDetailsSwitches and use LoadDetailsSwitches to replace in line code
59	08 Mar 09 GKY Removed variable aurguments from docopyf and unlinkf (not used)
60	28 Mar 09 GKY Add RemoveOldCnrSwitches to remove pre 3.16 style ini keys;
61	add State.version key for check
62	12 Jul 09 GKY Add xDosQueryAppType and xDosAlloc... to allow FM/2 to load in high memory
63	22 Jul 09 GKY Check if drives support EAs add driveflag for this
64	22 Jul 09 GKY Allow .LONGNAME to be displayed for FAT drives.
65	21 Dec 09 GKY Allow command menu reorder without changing the "ID" or hot key for a command.
66	Added load_inicommand to load the IDs from the ini file.
67	17 JAN 10 GKY Changes to get working with Watcom 1.9 Beta (1/16/10). Mostly cast CHAR CONSTANT * as CHAR *.
68	23 Oct 10 GKY Add menu items for opening directory cnrs based on path of selected item
69	including the option to use walk directories to select path
70	26 Aug 11 GKY Add a low mem version of xDosAlloc* wrappers; move error checking into all the
71	xDosAlloc* wrappers.
72	12 Nov 11 GKY Fixed HelpViewer's failure to open help files and subsequent failure with files with spaces.
73	28 Jun 14 GKY Fix errors identified with CPPCheck
74	12 Jul 15 GKY Fix CN_REALLOCPSZ file name editing code to: 1) Eliminate the possibility of
75	updating the container before CN_ENDEDIT is called. 2) Don't call RemoveCnrItems
76	for tree container and collector.
77
78	***********************************************************************/
79
80	#include <stdlib.h>
81	#include <string.h>
82	#include <ctype.h>
83	#include <share.h>
84	#include <malloc.h> // _heapmin
85
86	#define INCL_DOS
87	#define INCL_WIN
88	#define INCL_GPI
89	#define INCL_LONGLONG
90
91	#include "fm3dll.h"
92	#include "fm3dll2.h" // #define's for UM_*, control id's, etc.
93	#include "misc.h"
94	#include "killproc.h" // Data declaration(s)
95	#include "comp.h" // Data declaration(s)
96	#include "treecnr.h" // Data declaration(s)
97	#include "mainwnd.h" // Data declaration(s)
98	#include "init.h" // Data declaration(s)
99	#include "dircnrs.h" // Data declaration(s)
100	#include "newview.h" // Data declarations
101	#include "collect.h" // data declaration(s)
102	#include "notebook.h" // data declaration(s)
103	#include "arccnrs.h"
104	#include "fm3dlg.h"
105	#include "fm3str.h"
106	#include "pathutil.h" // BldQuotedFileName
107	#include "errutil.h" // Dos_Error...
108	#include "strutil.h" // GetPString
109	#include "command.h" // LINKCMDS
110	#include "cmdline.h" // CmdLineDlgProc
111	#include "defview.h" // QuickView
112	#include "copyf.h" // WriteLongName
113	#include "strips.h" // chop_at_crnl
114	#include "valid.h" // CheckDrive
115	#include "presparm.h" // CopyPresParams
116	#include "systemf.h" // ExecOnList
117	#include "viewer.h" // StartMLEEditor
118	#include "subj.h" // Subject
119	#include "wrappers.h" // xDosSetPathInfo
120	#include "i18nutil.h" // CommaFmtULL
121	#include "fortify.h"
122	#include "info.h" // driveflags
123	#if 0
124	#define __PMPRINTF__
125	#include "PMPRINTF.H"
126	#endif
127
128	#define CONTAINER_COLUMNS 13 // Number of columns in details view
129	#define MS_POPUP 0x00000010L
130
131	// Data definitions
132	#pragma data_seg(GLOBAL1)
133	HWND CollectorDirMenu;
134	HWND CollectorFileMenu;
135	HWND DirMenu;
136	HWND FileMenu;
137	HWND TreeMenu;
138	BOOL fDefaultDeletePerm;
139	BOOL fWorkPlace;
140
141	#pragma data_seg(GLOBAL4)
142	ULONG numswitches;
143	HSWITCH switches[499];
144
145	#pragma data_seg(DATA1)
146	static PSZ pszSrcFile = __FILE__;
147
148	#ifndef BEGIN_LIBPATH
149	#define BEGIN_LIBPATH 1
150	#endif
151
152	#ifndef END_LIBPATH
153	#define END_LIBPATH 2
154	#endif
155
156	#ifndef ORD_DOS32QUERYEXTLIBPATH
157	#define ORD_DOS32QUERYEXTLIBPATH 874
158	#endif
159
160	BOOL IsFm2Window(HWND hwnd, BOOL chkTid)
161	{
162	PIB *ppib;
163	TIB *ptib;
164	BOOL yes;
165	APIRET rc = DosGetInfoBlocks(&ptib, &ppib);
166
167	if (rc) {
168	Dos_Error(MB_CANCEL, rc, HWND_DESKTOP, pszSrcFile, __LINE__,
169	PCSZ_DOSGETINFOBLOCKS);
170	yes = FALSE;
171	}
172	else {
173	PID pid;
174	TID tid;
175
176	// Check window owned by FM2 process
177	// Check say same thread too, if requested
178	// OK for window to be dead - just return FALSE
179	yes = WinQueryWindowProcess(hwnd, &pid, &tid) &&
180	pid == ppib->pib_ulpid &&
181	(!chkTid \|\| tid == ptib->tib_ptib2->tib2_ultid);
182	}
183	return yes;
184	}
185
186	#ifdef FORTIFY
187
188	/**
189	* Return thread ordinal for fm/2 window
190	* window must exist and must be created by fm/2
191	* @param hwnd is window handle
192	* @returns thread ordinal or -1 if error
193	*/
194
195	INT GetTidForWindow(HWND hwnd)
196	{
197	PIB *ppib;
198	TIB *ptib;
199	LONG ordinal = -1;
200	APIRET rc = DosGetInfoBlocks(&ptib, &ppib);
201
202	if (rc) {
203	Dos_Error(MB_CANCEL, rc, HWND_DESKTOP, pszSrcFile, __LINE__,
204	PCSZ_DOSGETINFOBLOCKS);
205	}
206	else {
207	PID pid;
208	TID tid;
209	if (!WinQueryWindowProcess(hwnd, &pid, &tid))
210	Win_Error(hwnd, HWND_DESKTOP, pszSrcFile, __LINE__, "WinQueryWindowProcess failed for %X", hwnd);
211	else if (pid != ppib->pib_ulpid)
212	Runtime_Error(pszSrcFile, __LINE__, "hwnd %X not created by fm/2", hwnd);
213	else
214	ordinal = ptib->tib_ptib2->tib2_ultid;
215	}
216	return ordinal;
217	}
218
219	/**
220	* Return thread ordinal for current thread
221	* @returns thread ordinal or -1 if error
222	*/
223
224	INT GetTidForThread(VOID)
225	{
226	PIB *ppib;
227	TIB *ptib;
228	LONG ordinal = -1;
229	APIRET rc = DosGetInfoBlocks(&ptib, &ppib);
230
231	if (rc) {
232	Dos_Error(MB_CANCEL, rc, HWND_DESKTOP, pszSrcFile, __LINE__,
233	PCSZ_DOSGETINFOBLOCKS);
234	}
235	else
236	ordinal = ptib->tib_ptib2->tib2_ultid;
237
238	return ordinal;
239	}
240
241	#endif // FORTIFY
242
243	VOID SetShiftState(VOID)
244	{
245	shiftstate = 0;
246	if (WinGetKeyState(HWND_DESKTOP, VK_CTRL) & 0x8000)
247	shiftstate \|= KC_CTRL;
248	if (WinGetKeyState(HWND_DESKTOP, VK_SHIFT) & 0x8000)
249	shiftstate \|= KC_SHIFT;
250	if (WinGetKeyState(HWND_DESKTOP, VK_ALT) & 0x8000)
251	shiftstate \|= KC_ALT;
252	}
253
254	void EmphasizeButton(HWND hwnd, BOOL on)
255	{
256	HPS hps = DrgGetPS(hwnd);
257
258	// fixme to complain?
259	if (hps) {
260	POINTL ptl;
261	SWP swp;
262
263	WinQueryWindowPos(hwnd, &swp);
264	ptl.x = 1;
265	ptl.y = 1;
266	GpiMove(hps, &ptl);
267	GpiSetColor(hps, on ? CLR_BLACK : CLR_PALEGRAY);
268	ptl.x = swp.cx - 2;
269	ptl.y = swp.cy - 2;
270	GpiBox(hps, DRO_OUTLINE, &ptl, 0, 0);
271	DrgReleasePS(hps);
272	if (remove) //fixme always true
273	WinInvalidateRect(hwnd, NULL, FALSE);
274	}
275	}
276
277	void DrawTargetEmphasis(HWND hwnd, BOOL on)
278	{
279	HPS hps = DrgGetPS(WinQueryWindow(hwnd, QW_PARENT));
280
281	if (hps) {
282	BoxWindow(hwnd, hps, on ? CLR_BLACK : CLR_PALEGRAY);
283	DrgReleasePS(hps);
284	}
285	}
286
287	void BoxWindow(HWND hwnd, HPS hps, LONG color)
288	{
289	POINTL ptl;
290	SWP swp;
291	BOOL releaseme = FALSE;
292
293	if (!hps) {
294	hps = WinGetPS(WinQueryWindow(hwnd, QW_PARENT));
295	releaseme = TRUE;
296	}
297	if (hps && WinQueryWindowPos(hwnd, &swp)) {
298	ptl.x = swp.x - 2;
299	ptl.y = swp.y - 2;
300	GpiMove(hps, &ptl);
301	GpiSetColor(hps, color);
302	ptl.x = swp.x + swp.cx + 1;
303	ptl.y = swp.y + swp.cy + 1;
304	GpiBox(hps, DRO_OUTLINE, &ptl, 0, 0);
305	}
306	if (releaseme && hps)
307	WinReleasePS(hps);
308	}
309
310	void PaintSTextWindow(HWND hwnd, HPS hps)
311	{
312	/**
313	* paint a text window such that the rightmost part of the text is
314	* always visible even if the text length exceeds the length of the
315	* window -- otherwise, paint the window so that it is left-justified
316	* and vertically centered.
317	*/
318
319	char *s = NULL;
320	long len;
321	POINTL aptl[TXTBOX_COUNT], ptl;
322	RECTL rcl;
323	char *p;
324	BOOL releaseme = FALSE;
325
326	if (!hps) {
327	releaseme = TRUE;
328	hps = WinGetPS(hwnd);
329	}
330	if (hps) {
331	WinQueryWindowRect(hwnd, &rcl);
332	WinFillRect(hps, &rcl, CLR_PALEGRAY);
333	len = WinQueryWindowTextLength(hwnd);
334	if (len)
335	s = xmalloc(len + 1, pszSrcFile, __LINE__);
336	if (s) {
337	*s = 0;
338	WinQueryWindowText(hwnd, CCHMAXPATH, s);
339	if (*s) {
340	rcl.xRight -= 3;
341	p = s;
342	GpiQueryTextBox(hps, 3, "...", TXTBOX_COUNT, aptl);
343	len = aptl[TXTBOX_TOPRIGHT].x;
344	do {
345	GpiQueryTextBox(hps, strlen(p), p, TXTBOX_COUNT, aptl);
346	if (aptl[TXTBOX_TOPRIGHT].x > (rcl.xRight - (p != s ? len : 0)))
347	p++;
348	else
349	break;
350	}
351	while (*p);
352	if (*p) {
353	GpiSetMix(hps, FM_OVERPAINT);
354	GpiSetColor(hps, CLR_BLACK);
355	ptl.x = 3;
356	ptl.y = ((rcl.yTop / 2) -
357	((aptl[TXTBOX_TOPRIGHT].y +
358	aptl[TXTBOX_BOTTOMLEFT].y) / 2));
359	GpiMove(hps, &ptl);
360	if (p != s)
361	GpiCharString(hps, 3, "...");
362	GpiCharString(hps, strlen(p), p);
363	}
364	}
365	free(s);
366	}
367	if (releaseme)
368	WinReleasePS(hps);
369	}
370	}
371
372	VOID PaintRecessedWindow(HWND hwnd, HPS hps, BOOL outtie, BOOL dbl)
373	{
374	/**
375	* paint a recessed box around the window
376	* two pixels width required around window for painting...
377	*/
378	BOOL releaseme = FALSE;
379
380	if (!hps) {
381	hps = WinGetPS(WinQueryWindow(hwnd, QW_PARENT));
382	releaseme = TRUE;
383	}
384	if (hps) {
385
386	POINTL ptl;
387	SWP swp;
388
389	WinQueryWindowPos(hwnd, &swp);
390	ptl.x = swp.x - 1;
391	ptl.y = swp.y - 1;
392	GpiMove(hps, &ptl);
393	if (!outtie)
394	GpiSetColor(hps, CLR_WHITE);
395	else
396	GpiSetColor(hps, CLR_DARKGRAY);
397	ptl.x = swp.x + swp.cx;
398	GpiLine(hps, &ptl);
399	ptl.y = swp.y + swp.cy;
400	GpiLine(hps, &ptl);
401	if (dbl) {
402	ptl.x = swp.x - 2;
403	ptl.y = swp.y - 2;
404	GpiMove(hps, &ptl);
405	ptl.x = swp.x + swp.cx + 1;
406	GpiLine(hps, &ptl);
407	ptl.y = swp.y + swp.cy + 1;
408	GpiLine(hps, &ptl);
409	}
410	if (!outtie)
411	GpiSetColor(hps, CLR_DARKGRAY);
412	else
413	GpiSetColor(hps, CLR_WHITE);
414	if (dbl) {
415	ptl.x = swp.x - 2;
416	GpiLine(hps, &ptl);
417	ptl.y = swp.y - 2;
418	GpiLine(hps, &ptl);
419	ptl.x = swp.x + swp.cx;
420	ptl.y = swp.y + swp.cy;
421	GpiMove(hps, &ptl);
422	}
423	ptl.x = swp.x - 1;
424	GpiLine(hps, &ptl);
425	ptl.y = swp.y - 1;
426	GpiLine(hps, &ptl);
427	GpiSetColor(hps, CLR_PALEGRAY);
428	ptl.x = swp.x - (2 + (dbl != FALSE));
429	ptl.y = swp.y - (2 + (dbl != FALSE));
430	GpiMove(hps, &ptl);
431	ptl.x = swp.x + swp.cx + (1 + (dbl != FALSE));
432	GpiLine(hps, &ptl);
433	ptl.y = swp.y + swp.cy + (1 + (dbl != FALSE));
434	GpiLine(hps, &ptl);
435	ptl.x = swp.x - (2 + (dbl != FALSE));
436	GpiLine(hps, &ptl);
437	ptl.y = swp.y - (2 + (dbl != FALSE));
438	GpiLine(hps, &ptl);
439	if (releaseme)
440	WinReleasePS(hps);
441	}
442	}
443
444	BOOL AdjustCnrColVis(HWND hwndCnr, PCSZ title, BOOL visible, BOOL toggle)
445	{
446	PFIELDINFO pfi = (PFIELDINFO) WinSendMsg(hwndCnr,
447	CM_QUERYDETAILFIELDINFO,
448	MPVOID, MPFROMSHORT(CMA_FIRST));
449
450	while (pfi) {
451	if (!strcmp(pfi->pTitleData, title)) {
452	if (toggle) {
453	if (pfi->flData & CFA_INVISIBLE)
454	pfi->flData &= (~CFA_INVISIBLE);
455	else
456	pfi->flData \|= CFA_INVISIBLE;
457	return !(pfi->flData & CFA_INVISIBLE);
458	}
459	else {
460	if (visible)
461	pfi->flData &= (~CFA_INVISIBLE);
462	else
463	pfi->flData \|= CFA_INVISIBLE;
464	}
465	return TRUE;
466	}
467	pfi = pfi->pNextFieldInfo;
468	}
469	return FALSE;
470	}
471
472	BOOL AdjustCnrColRO(HWND hwndCnr, PCSZ title, BOOL readonly, BOOL toggle)
473	{
474	PFIELDINFO pfi = (PFIELDINFO) WinSendMsg(hwndCnr,
475	CM_QUERYDETAILFIELDINFO,
476	MPVOID, MPFROMSHORT(CMA_FIRST));
477
478	while (pfi) {
479	if (!strcmp(pfi->pTitleData, title)) {
480	if (toggle) {
481	if (pfi->flData & CFA_FIREADONLY)
482	pfi->flData &= (~CFA_FIREADONLY);
483	else
484	pfi->flData \|= CFA_FIREADONLY;
485	return (pfi->flData & CFA_FIREADONLY);
486	}
487	else {
488	if (!readonly)
489	pfi->flData &= (~CFA_FIREADONLY);
490	else
491	pfi->flData \|= CFA_FIREADONLY;
492	}
493	return TRUE;
494	}
495	pfi = pfi->pNextFieldInfo;
496	}
497	return FALSE;
498	}
499
500	VOID AdjustCnrColsForFSType(HWND hwndCnr, PCSZ directory, DETAILS_SETTINGS *pds, BOOL compare)
501	{
502	CHAR FileSystem[CCHMAXPATH];
503	INT x;
504	BOOL hasCreateDT;
505	BOOL hasAccessDT;
506	BOOL hasLongNames;
507	BOOL hasSubjects;
508
509	if (!directory \|\| !*directory)
510	return;
511	x = CheckDrive(toupper(*directory), FileSystem, NULL);
512	if (x != -1) {
513	x = toupper(*directory) - 'A';
514	if (!stricmp(FileSystem, HPFS) \|\|
515	!stricmp(FileSystem, JFS) \|\|
516	!stricmp(FileSystem, FAT32) \|\|
517	!stricmp(FileSystem, RAMFS) \|\|
518	!stricmp(FileSystem, NDFS32) \|\|
519	!stricmp(FileSystem, NTFS) \|\|
520	!stricmp(FileSystem, HPFS386)) {
521	hasCreateDT = TRUE;
522	hasAccessDT = TRUE;
523	if (driveflags[x] & DRIVE_NOEASUPPORT) {
524	hasSubjects = FALSE;
525	hasLongNames = FALSE;
526	}
527	else {
528	hasSubjects = TRUE;
529	hasLongNames = TRUE;
530	}
531	}
532	else if (!strcmp(FileSystem, CDFS) \|\| !strcmp(FileSystem, ISOFS)) {
533	hasCreateDT = TRUE;
534	hasAccessDT = FALSE;
535	if (driveflags[x] & DRIVE_NOEASUPPORT) {
536	hasSubjects = FALSE;
537	hasLongNames = FALSE;
538	}
539	else {
540	hasSubjects = TRUE;
541	hasLongNames = TRUE;
542	}
543	}
544	else {
545	// Assume FAT
546	hasCreateDT = FALSE;
547	hasAccessDT = FALSE;
548	if (driveflags[x] & DRIVE_NOEASUPPORT) {
549	hasSubjects = FALSE;
550	hasLongNames = FALSE;
551	}
552	else {
553	hasSubjects = TRUE;
554	hasLongNames = TRUE;
555	}
556	}
557	}
558	else {
559	// Assume FAT
560	x = toupper(*directory) - 'A'; //31 Aug 14 GKY added since x = -1 so "if" was always false
561	hasCreateDT = FALSE;
562	hasAccessDT = FALSE;
563	if (driveflags[x] & DRIVE_NOEASUPPORT) {
564	hasSubjects = FALSE;
565	hasLongNames = FALSE;
566	}
567	else {
568	hasSubjects = TRUE;
569	hasLongNames = TRUE;
570	}
571	}
572	AdjustCnrColVis(hwndCnr,
573	GetPString(IDS_LADATE),
574	pds->detailsladate ? hasAccessDT : FALSE,
575	FALSE);
576	AdjustCnrColVis(hwndCnr,
577	GetPString(IDS_LATIME),
578	pds->detailslatime ? hasAccessDT : FALSE,
579	FALSE);
580	AdjustCnrColVis(hwndCnr,
581	GetPString(IDS_CRDATE),
582	pds->detailscrdate ? hasCreateDT : FALSE,
583	FALSE);
584	AdjustCnrColVis(hwndCnr,
585	GetPString(IDS_CRTIME),
586	pds->detailscrtime ? hasCreateDT : FALSE,
587	FALSE);
588	if (pds->detailslongname && !pds->detailssubject && hasSubjects) {
589	AdjustCnrColVis(hwndCnr,
590	compare ? GetPString(IDS_STATUS) : GetPString(IDS_SUBJ),
591	TRUE,
592	FALSE);
593	AdjustCnrColVis(hwndCnr,
594	GetPString(IDS_LNAME),
595	pds->detailslongname ? hasLongNames : FALSE,
596	FALSE);
597	WinSendMsg(hwndCnr, CM_INVALIDATEDETAILFIELDINFO, MPVOID, MPVOID);
598	}
599	else
600	AdjustCnrColVis(hwndCnr,
601	GetPString(IDS_LNAME),
602	pds->detailslongname ? hasLongNames : FALSE,
603	FALSE);
604	AdjustCnrColVis(hwndCnr,
605	compare ? GetPString(IDS_STATUS) : GetPString(IDS_SUBJ),
606	pds->detailssubject ? hasSubjects : FALSE,
607	FALSE);
608	WinSendMsg(hwndCnr, CM_INVALIDATEDETAILFIELDINFO, MPVOID, MPVOID);
609	}
610
611	VOID AdjustCnrColsForPref(HWND hwndCnr, PCSZ directory, DETAILS_SETTINGS *pds,
612	BOOL compare)
613	{
614	AdjustCnrColVis(hwndCnr, GetPString(IDS_ATTR), pds->detailsattr, FALSE);
615	AdjustCnrColVis(hwndCnr, GetPString(IDS_ICON), pds->detailsicon, FALSE);
616	AdjustCnrColVis(hwndCnr, GetPString(IDS_LWDATE), pds->detailslwdate, FALSE);
617	AdjustCnrColVis(hwndCnr, GetPString(IDS_LWTIME), pds->detailslwtime, FALSE);
618	AdjustCnrColVis(hwndCnr, GetPString(IDS_EA), pds->detailsea, FALSE);
619	AdjustCnrColVis(hwndCnr, GetPString(IDS_SIZE), pds->detailssize, FALSE);
620
621	if (!directory) {
622	AdjustCnrColVis(hwndCnr,
623	compare ? GetPString(IDS_STATUS) : GetPString(IDS_SUBJ),
624	pds->detailssubject,
625	FALSE);
626	AdjustCnrColVis(hwndCnr, GetPString(IDS_LADATE), pds->detailsladate, FALSE);
627	AdjustCnrColVis(hwndCnr, GetPString(IDS_LATIME), pds->detailslatime, FALSE);
628	AdjustCnrColVis(hwndCnr, GetPString(IDS_CRDATE), pds->detailscrdate, FALSE);
629	AdjustCnrColVis(hwndCnr, GetPString(IDS_CRTIME), pds->detailscrtime, FALSE);
630	AdjustCnrColVis(hwndCnr, GetPString(IDS_LNAME), pds->detailslongname, FALSE);
631	WinSendMsg(hwndCnr, CM_INVALIDATEDETAILFIELDINFO, MPVOID, MPVOID);
632	}
633	else {
634	AdjustCnrColsForFSType(hwndCnr, directory, pds, compare);
635	}
636	}
637
638	BOOL SetCnrCols(HWND hwndCnr, BOOL isCompCnr)
639	{
640	BOOL fSuccess = TRUE;
641	PFIELDINFO pfi, pfiLastLeftCol, pfiIconCol;
642
643	// Allocate storage for container column data
644
645	pfi = WinSendMsg(hwndCnr, CM_ALLOCDETAILFIELDINFO,
646	MPFROMLONG(CONTAINER_COLUMNS), NULL);
647
648	if (!pfi) {
649	Win_Error(hwndCnr, HWND_DESKTOP, pszSrcFile, __LINE__, "CM_ALLOCDETAILFIELDINFO");
650	fSuccess = FALSE;
651	}
652	else {
653
654	PFIELDINFO pfiFirst;
655	FIELDINFOINSERT fii;
656
657	// Store original value of pfi so we won't lose it when it changes.
658	// This will be needed on the CM_INSERTDETAILFIELDINFO message.
659
660	pfiFirst = pfi;
661
662	// Fill in column information for the icon column
663
664	pfi->flData = CFA_BITMAPORICON \| CFA_CENTER \| CFA_FIREADONLY;
665	pfi->flTitle = CFA_CENTER \| CFA_FITITLEREADONLY;
666	pfi->pTitleData = (PSZ)GetPString(IDS_ICON);
667	pfi->offStruct = FIELDOFFSET(MINIRECORDCORE, hptrIcon);
668
669	pfiIconCol = pfi;
670
671	// Fill in column information for the file name. Note that we are
672	// using the pszDisplayName variable rather than pszFileName. We do this
673	// because the container does not always display the full path file name.
674
675	pfi = pfi->pNextFieldInfo;
676
677	pfi->flData = CFA_STRING \| CFA_LEFT \| CFA_SEPARATOR;
678	pfi->flTitle = CFA_LEFT;
679	pfi->pTitleData = (PSZ)GetPString(IDS_FILENAME);
680	pfi->offStruct = FIELDOFFSET(CNRITEM, pszDisplayName);
681
682	// Fill in column information for the longname.
683
684	pfi = pfi->pNextFieldInfo;
685	pfi->flData = CFA_STRING \| CFA_LEFT \| CFA_SEPARATOR;
686	pfi->flTitle = CFA_LEFT \| CFA_FITITLEREADONLY;
687	pfi->pTitleData = (PSZ)GetPString(IDS_LNAME);
688	pfi->offStruct = FIELDOFFSET(CNRITEM, pszLongName);
689	pfiLastLeftCol = pfi;
690
691	// Store the current pfi value as that will be used to indicate the
692	// last column in the lefthand container window (we have a splitbar)
693	if (!dsDirCnrDefault.fSubjectInLeftPane)
694	pfiLastLeftCol = pfi;
695	else
696	pfiLastLeftCol = pfi->pNextFieldInfo;
697
698	// Fill in column info for subjects
699	pfi = pfi->pNextFieldInfo;
700	pfi->flData = CFA_STRING \| CFA_LEFT \| CFA_SEPARATOR;
701	if (isCompCnr)
702	pfi->flData \|= CFA_FIREADONLY;
703	pfi->flTitle = CFA_LEFT \| CFA_FITITLEREADONLY;
704	pfi->pTitleData = isCompCnr ? (PSZ)GetPString(IDS_STATUS) :
705	(PSZ)GetPString(IDS_SUBJ);
706	pfi->offStruct = FIELDOFFSET(CNRITEM, pszSubject);
707	pfi->cxWidth = dsDirCnrDefault.SubjectDisplayWidth;
708
709	// Fill in column information for the file size
710
711	pfi = pfi->pNextFieldInfo;
712	pfi->flData = CFA_STRING \| CFA_RIGHT \| CFA_SEPARATOR \| CFA_FIREADONLY;
713	pfi->flTitle = CFA_CENTER;
714	pfi->pTitleData = (PSZ)GetPString(IDS_SIZE);
715	pfi->offStruct = FIELDOFFSET(CNRITEM, pszFmtFileSize);
716
717
718	// Fill in the column information for the file's ea size
719
720	pfi = pfi->pNextFieldInfo;
721	pfi->flData = CFA_ULONG \| CFA_RIGHT \| CFA_SEPARATOR \| CFA_FIREADONLY;
722	pfi->flTitle = CFA_CENTER;
723	pfi->pTitleData = (PSZ)GetPString(IDS_EA);
724	pfi->offStruct = FIELDOFFSET(CNRITEM, easize);
725
726	// Fill in the column information for the file attribute
727
728	pfi = pfi->pNextFieldInfo;
729	pfi->flData = CFA_STRING \| CFA_CENTER \| CFA_SEPARATOR \| CFA_FIREADONLY;
730	pfi->flTitle = CFA_CENTER \| CFA_FITITLEREADONLY;
731	pfi->pTitleData = (PSZ)GetPString(IDS_ATTR);
732	pfi->offStruct = FIELDOFFSET(CNRITEM, pszDispAttr);
733
734	// Fill in column information for last write file date
735
736	pfi = pfi->pNextFieldInfo;
737	pfi->flData = CFA_DATE \| CFA_RIGHT \| CFA_FIREADONLY;
738	pfi->flTitle = CFA_CENTER;
739	pfi->pTitleData = (PSZ)GetPString(IDS_LWDATE);
740	pfi->offStruct = FIELDOFFSET(CNRITEM, date);
741
742	// Fill in column information for the last write file time
743
744	pfi = pfi->pNextFieldInfo;
745	pfi->flData = CFA_TIME \| CFA_RIGHT \| CFA_SEPARATOR \| CFA_FIREADONLY;
746	pfi->flTitle = CFA_CENTER;
747	pfi->pTitleData = (PSZ)GetPString(IDS_LWTIME);
748	pfi->offStruct = FIELDOFFSET(CNRITEM, time);
749
750	// Fill in column information for last access file date
751
752	pfi = pfi->pNextFieldInfo;
753	pfi->flData = CFA_DATE \| CFA_RIGHT \| CFA_FIREADONLY;
754	pfi->flTitle = CFA_CENTER;
755	pfi->pTitleData = (PSZ)GetPString(IDS_LADATE);
756	pfi->offStruct = FIELDOFFSET(CNRITEM, ladate);
757
758	// Fill in column information for the last access file time
759
760	pfi = pfi->pNextFieldInfo;
761	pfi->flData = CFA_TIME \| CFA_RIGHT \| CFA_SEPARATOR \| CFA_FIREADONLY;
762	pfi->flTitle = CFA_CENTER;
763	pfi->pTitleData = (PSZ)GetPString(IDS_LATIME);
764	pfi->offStruct = FIELDOFFSET(CNRITEM, latime);
765
766	// Fill in column information for create file date
767
768	pfi = pfi->pNextFieldInfo;
769	pfi->flData = CFA_DATE \| CFA_RIGHT \| CFA_FIREADONLY;
770	pfi->flTitle = CFA_CENTER;
771	pfi->pTitleData = (PSZ)GetPString(IDS_CRDATE);
772	pfi->offStruct = FIELDOFFSET(CNRITEM, crdate);
773
774	// Fill in column information for the create file time
775
776	pfi = pfi->pNextFieldInfo;
777	pfi->flData = CFA_TIME \| CFA_RIGHT \| CFA_FIREADONLY;
778	pfi->flTitle = CFA_CENTER;
779	pfi->pTitleData = (PSZ)GetPString(IDS_CRTIME);
780	pfi->offStruct = FIELDOFFSET(CNRITEM, crtime);
781
782	// Use the CM_INSERTDETAILFIELDINFO message to tell the container
783	// all the column information it needs to function properly. Place
784	// this column info first in the column list and update the display
785	// after they are inserted (fInvalidateFieldInfo = TRUE)
786
787	(void)memset(&fii, 0, sizeof(FIELDINFOINSERT));
788
789	fii.cb = sizeof(FIELDINFOINSERT);
790	fii.pFieldInfoOrder = (PFIELDINFO) CMA_FIRST;
791	fii.cFieldInfoInsert = (SHORT) CONTAINER_COLUMNS;
792	fii.fInvalidateFieldInfo = TRUE;
793
794	if (!WinSendMsg(hwndCnr, CM_INSERTDETAILFIELDINFO, MPFROMP(pfiFirst),
795	MPFROMP(&fii))) {
796	Win_Error(hwndCnr, HWND_DESKTOP, pszSrcFile, __LINE__, "CM_INSERTDETAILFIELDINFO");
797	fSuccess = FALSE;
798	}
799	}
800
801	if (fSuccess) {
802
803	CNRINFO cnri;
804	ULONG size;
805
806	// Tell the container about the splitbar and where it goes
807
808	cnri.cb = sizeof(CNRINFO);
809	cnri.pFieldInfoLast = pfiLastLeftCol;
810	cnri.xVertSplitbar = DIR_SPLITBAR_OFFSET - 32;
811	cnri.pFieldInfoObject = pfiIconCol;
812	size = sizeof(LONG);
813	PrfQueryProfileData(fmprof,
814	appname, "CnrSplitBar", &cnri.xVertSplitbar, &size);
815	if (cnri.xVertSplitbar <= 0)
816	cnri.xVertSplitbar = DIR_SPLITBAR_OFFSET - 32;
817	if (!WinSendMsg(hwndCnr, CM_SETCNRINFO, MPFROMP(&cnri),
818	MPFROMLONG(CMA_PFIELDINFOLAST \| CMA_PFIELDINFOOBJECT \|
819	CMA_XVERTSPLITBAR))) {
820	Win_Error(hwndCnr, HWND_DESKTOP, pszSrcFile, __LINE__, "CM_SETCNRINFO");
821	fSuccess = FALSE;
822	}
823	}
824
825	return fSuccess;
826	}
827
828	MRESULT CnrDirectEdit(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
829	{
830	static CHAR oldname[CCHMAXPATH];
831	static CHAR newname[CCHMAXPATH];
832	static BOOL fPostName = FALSE;
833
834	switch (SHORT2FROMMP(mp1)) {
835	case CN_BEGINEDIT:
836	if (mp2) {
837	PFIELDINFO pfi = ((PCNREDITDATA) mp2)->pFieldInfo;
838	PCNRITEM pci = (PCNRITEM) ((PCNREDITDATA) mp2)->pRecord;
839
840	if (pci &&
841	(INT) pci != -1 &&
842	!IsRoot(pci->pszFileName) &&
843	!(pci->flags & RECFLAGS_ENV) && !(pci->flags & RECFLAGS_UNDERENV)) {
844	if (!pfi \|\| pfi->offStruct == FIELDOFFSET(CNRITEM, pszDisplayName)) {
845	PostMsg(hwnd, UM_FIXEDITNAME, MPFROMP(pci->pszFileName), MPVOID);
846	}
847	else if (pfi->offStruct == FIELDOFFSET(CNRITEM, pszSubject))
848	PostMsg(hwnd, UM_FIXCNRMLE, MPFROMLONG(1048), MPVOID);
849	else
850	PostMsg(hwnd, UM_FIXCNRMLE, MPFROMLONG(CCHMAXPATH), MPVOID);
851	}
852	else
853	PostMsg(hwnd, CM_CLOSEEDIT, MPVOID, MPVOID);
854	}
855	break;
856
857	case CN_REALLOCPSZ:
858	if (mp2) {
859	PFIELDINFO pfi = ((PCNREDITDATA) mp2)->pFieldInfo;
860	PCNRITEM pci = (PCNRITEM) ((PCNREDITDATA) mp2)->pRecord;
861	CHAR testname[CCHMAXPATH];
862	HWND hwndMLE = WinWindowFromID(hwnd, CID_MLE);
863	BOOL fResetVerify = FALSE;
864	PSZ psz;
865	LONG retlen;
866	APIRET rc;
867
868	if (pci && (INT) pci != -1 && !IsRoot(pci->pszFileName)) {
869	if (pfi && pfi->offStruct == FIELDOFFSET(CNRITEM, pszSubject)) {
870	EAOP2 eaop;
871	PFEA2LIST pfealist = NULL;
872	CHAR szSubject[1048];
873	ULONG ealen;
874	USHORT len;
875	CHAR *eaval;
876
877	retlen = WinQueryWindowText(hwndMLE, sizeof(szSubject), szSubject);
878	szSubject[retlen + 1] = 0;
879	bstrip(szSubject);
880	if (pci->pszSubject != NullStr) {
881	if (retlen == 0) {
882	psz = pci->pszSubject;
883	pci->pszSubject = NullStr;
884	xfree(psz, pszSrcFile, __LINE__);
885	}
886	else {
887	psz = xrealloc(pci->pszSubject, retlen + 1, pszSrcFile, __LINE__);
888	if (psz)
889	pci->pszSubject = psz;
890	else {
891	xfree(pci->pszSubject, pszSrcFile, __LINE__);
892	pci->pszSubject = NullStr;
893	return FALSE; // out of memory
894	}
895	}
896	}
897	else {
898	pci->pszSubject = xmalloc(retlen + 1, pszSrcFile, __LINE__);
899	if (!pci->pszSubject)
900	return FALSE;
901	}
902	len = strlen(szSubject);
903	if (len)
904	ealen = sizeof(FEA2LIST) + 9 + len + 4;
905	else
906	ealen = sizeof(FEALIST) + 9;
907	if (!xDosAllocMem((PPVOID) & pfealist, ealen + 64, pszSrcFile, __LINE__)) {
908	memset(pfealist, 0, ealen + 1);
909	pfealist->cbList = ealen;
910	pfealist->list[0].oNextEntryOffset = 0;
911	pfealist->list[0].fEA = 0;
912	pfealist->list[0].cbName = 8;
913	strcpy(pfealist->list[0].szName, SUBJECT);
914	if (len) {
915	eaval = pfealist->list[0].szName + 9;
916	(USHORT ) eaval = (USHORT) EAT_ASCII;
917	eaval += sizeof(USHORT);
918	(USHORT ) eaval = (USHORT) len;
919	eaval += sizeof(USHORT);
920	memcpy(eaval, szSubject, len);
921	pfealist->list[0].cbValue = len + (sizeof(USHORT) * 2);
922	}
923	else
924	pfealist->list[0].cbValue = 0;
925	eaop.fpGEA2List = (PGEA2LIST) 0;
926	eaop.fpFEA2List = pfealist;
927	eaop.oError = 0;
928	rc = xDosSetPathInfo(pci->pszFileName, FIL_QUERYEASIZE,
929	&eaop, sizeof(eaop), DSPI_WRTTHRU);
930	DosFreeMem(pfealist);
931	if (rc)
932	return FALSE;
933	}
934	return (MRESULT) TRUE;
935	}
936	else if (pfi && pfi->offStruct == FIELDOFFSET(CNRITEM, pszLongName)) {
937	CHAR longname[CCHMAXPATHCOMP];
938
939	*longname = 0;
940	retlen = WinQueryWindowText(hwndMLE, sizeof(longname), longname);
941	longname[retlen + 1] = 0;
942	chop_at_crnl(longname);
943	bstrip(longname);
944	WinSetWindowText(hwndMLE, longname);
945	if (pci->pszLongName != NullStr) {
946	if (retlen == 0) {
947	psz = pci->pszLongName;
948	pci->pszLongName = NullStr;
949	xfree(psz, pszSrcFile, __LINE__);
950	}
951	else {
952	psz = xrealloc(pci->pszLongName, retlen + 1, pszSrcFile, __LINE__);
953	if (psz)
954	pci->pszLongName = psz;
955	else {
956	xfree(pci->pszLongName, pszSrcFile, __LINE__);
957	pci->pszLongName = NullStr;
958	return FALSE; // out of memory
959	}
960	}
961	}
962	else {
963	pci->pszLongName = xmalloc(retlen + 1, pszSrcFile, __LINE__);
964	if (!pci->pszLongName)
965	return FALSE;
966	}
967	return (MRESULT) WriteLongName(pci->pszFileName, longname);
968	}
969	else {
970	WinQueryWindowText(hwndMLE, sizeof(testname), testname);
971	// fixme to check for other illegal chars? GKY 11 Jul 15
972	if (strchr(testname, '?') \|\| strchr(testname, '*'))
973	return (MRESULT) FALSE;
974	// If the text changed, rename the file system object.
975	chop_at_crnl(testname);
976	bstrip(testname);
977	if (!IsFullName(testname))
978	Runtime_Error(pszSrcFile, __LINE__, "bad name");
979	else {
980	if (DosQueryPathInfo(testname, //Why does this return 0 when the file doesn't exist?
981	FIL_QUERYFULLNAME, // No new directory creation?
982	newname, sizeof(newname)))
983	return FALSE;
984	if (DosQueryPathInfo(pci->pszFileName,
985	FIL_QUERYFULLNAME,
986	oldname, sizeof(oldname)))
987	strcpy(oldname, pci->pszFileName);
988	WinSetWindowText(hwndMLE, oldname);
989	if (strcmp(oldname, newname)) {
990	if (stricmp(oldname, newname) && IsFile(newname) != -1) {
991	if (!fAlertBeepOff)
992	DosBeep(50, 100);
993	return (MRESULT) FALSE; // exists; disallow
994	}
995	if (fVerify && (driveflags[toupper(*oldname) - 'A'] & DRIVE_WRITEVERIFYOFF \|\|
996	driveflags[toupper(*newname) - 'A'] & DRIVE_WRITEVERIFYOFF)) {
997	DosSetVerify(FALSE);
998	fResetVerify = TRUE;
999	}
1000	if (docopyf(MOVE, oldname, newname))
1001	Runtime_Error(pszSrcFile, __LINE__, "docopyf");
1002	else {
1003	fPostName = TRUE;
1004	}
1005	if (fResetVerify) {
1006	DosSetVerify(fVerify);
1007	fResetVerify = FALSE;
1008	}
1009	}
1010	}
1011	}
1012	}
1013	}
1014	return FALSE;
1015
1016	case CN_ENDEDIT:
1017	if (mp2) {
1018	PFIELDINFO pfi = ((PCNREDITDATA) mp2)->pFieldInfo;
1019	PCNRITEM pci = (PCNRITEM) ((PCNREDITDATA) mp2)->pRecord;
1020
1021	if (fPostName) {
1022	CHAR *filename;
1023	DIRCNRDATA *dcd;
1024
1025	if (!dcd)
1026	dcd = INSTDATA(hwnd);
1027	filename = xstrdup(oldname, pszSrcFile, __LINE__);
1028	if (filename) {
1029	if (!PostMsg(hwnd,UM_FIXEDITNAME, MPVOID, MPFROMP(filename)))
1030	free(filename);
1031	}
1032	if (strcmp(newname, NullStr)) {
1033	filename = xstrdup(newname, pszSrcFile, __LINE__);
1034	if (filename) {
1035	if (!PostMsg(hwnd, UM_FIXEDITNAME, MPVOID, MPFROMP(filename)))
1036	free(filename);
1037	}
1038	}
1039	fPostName = FALSE;
1040	}
1041	if (pci && (INT) pci != -1 && !IsRoot(pci->pszFileName)) {
1042	WinSendMsg(hwnd,
1043	CM_INVALIDATERECORD,
1044	MPFROMP(&pci),
1045	MPFROM2SHORT(1, CMA_ERASE \| CMA_TEXTCHANGED));
1046	if (pfi && pfi->offStruct == FIELDOFFSET(CNRITEM, pszDisplayName))
1047	PostMsg(hwnd, UM_SORTRECORD, MPVOID, MPVOID);
1048	}
1049	else {
1050	USHORT cmd = 0;
1051
1052	if (!pfi \|\| pfi->offStruct == FIELDOFFSET(CNRITEM, pszDisplayName))
1053	cmd = IDM_SORTSMARTNAME;
1054	else if (pfi->offStruct == FIELDOFFSET(CNRITEM, cbFile))
1055	cmd = IDM_SORTSIZE;
1056	else if (pfi->offStruct == FIELDOFFSET(CNRITEM, easize))
1057	cmd = IDM_SORTEASIZE;
1058	else if (pfi->offStruct == FIELDOFFSET(CNRITEM, date))
1059	cmd = IDM_SORTLWDATE;
1060	else if (pfi->offStruct == FIELDOFFSET(CNRITEM, time))
1061	cmd = IDM_SORTLWDATE;
1062	else if (pfi->offStruct == FIELDOFFSET(CNRITEM, ladate))
1063	cmd = IDM_SORTLADATE;
1064	else if (pfi->offStruct == FIELDOFFSET(CNRITEM, latime))
1065	cmd = IDM_SORTLADATE;
1066	else if (pfi->offStruct == FIELDOFFSET(CNRITEM, crdate))
1067	cmd = IDM_SORTCRDATE;
1068	else if (pfi->offStruct == FIELDOFFSET(CNRITEM, crtime))
1069	cmd = IDM_SORTCRDATE;
1070	if (cmd)
1071	PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(cmd, 0), MPVOID);
1072	}
1073	}
1074	break;
1075	}
1076	return (MRESULT) - 1;
1077	}
1078
1079	BOOL SetMenuCheck(HWND hwndMenu, USHORT id, BOOL * bool, BOOL toggle,
1080	PCSZ savename)
1081	{
1082	if (toggle) {
1083	bool = bool ? FALSE : TRUE;
1084	if (savename && *savename)
1085	PrfWriteProfileData(fmprof, appname, (CHAR *) savename, bool, sizeof(BOOL));
1086	}
1087	WinSendMsg(hwndMenu, MM_SETITEMATTR,
1088	MPFROM2SHORT(id, 1),
1089	MPFROM2SHORT(MIA_CHECKED, (*bool ? MIA_CHECKED : 0)));
1090	return *bool;
1091	}
1092
1093	//== disable_menuitem() disable or enable_menuitem ==
1094
1095	VOID disable_menuitem(HWND hwndMenu, USHORT id, BOOL disable)
1096	{
1097	WinSendMsg(hwndMenu, MM_SETITEMATTR,
1098	MPFROM2SHORT(id, TRUE),
1099	MPFROM2SHORT(MIA_DISABLED, (disable ? MIA_DISABLED : 0)));
1100	}
1101
1102	//== ViewHelp() invoke view.exe, return TRUE if OK ==
1103
1104	BOOL ViewHelp(PCSZ filename)
1105	{
1106	CHAR s[CCHMAXPATH + 81];
1107	CHAR szQuotedFileName[CCHMAXPATH];
1108	FILE *fp;
1109	INT ret = -1;
1110	CHAR *moderb = "rb";
1111
1112	fp = xfsopen(filename, moderb, SH_DENYNO, pszSrcFile, __LINE__, FALSE);
1113	if (fp) {
1114	*s = 0;
1115	fread(s, 1, 3, fp);
1116	if (*s != 'H' \|\| s[1] != 'S' \|\| s[2] != 'P') {
1117	fclose(fp);
1118	return FALSE;
1119	}
1120	fclose(fp);
1121	ret = runemf2(SEPARATE \| WINDOWED, HWND_DESKTOP, pszSrcFile, __LINE__,
1122	NULL, NULL,
1123	"VIEW.EXE %s",
1124	BldQuotedFileName(szQuotedFileName, filename));
1125	}
1126
1127	return (ret != -1);
1128	}
1129
1130	//== ExecFile() run file, return 1 if OK 0 if skipped -1 if can't run ==
1131
1132	INT ExecFile(HWND hwnd, PCSZ filename)
1133	{
1134	EXECARGS ex;
1135	CHAR path[CCHMAXPATH], *p;
1136	PSZ pszCmdLine;
1137	APIRET ret;
1138	static INT lastflags = 0;
1139
1140	strcpy(path, filename);
1141	p = strrchr(path, '\\');
1142	if (!p)
1143	p = strrchr(path, ':');
1144	if (p) {
1145	if (*p == ':') {
1146	p++;
1147	*p = '\\';
1148	p++;
1149	}
1150	*p = 0;
1151	}
1152	else
1153	*path = 0;
1154	pszCmdLine = xmallocz(MaxComLineStrg, pszSrcFile, __LINE__);
1155	if (pszCmdLine) {
1156	BldQuotedFileName(pszCmdLine, filename);
1157	memset(&ex, 0, sizeof(ex));
1158	ex.flags = lastflags;
1159	ex.commandline = pszCmdLine;
1160	*ex.path = 0;
1161	*ex.environment = 0;
1162	ret = WinDlgBox(HWND_DESKTOP, hwnd, CmdLineDlgProc, FM3ModHandle,
1163	EXEC_FRAME, &ex);
1164	if (ret == 1) {
1165	lastflags = ex.flags;
1166	return runemf2(ex.flags, hwnd, pszSrcFile, __LINE__, path,
1167	*ex.environment ? ex.environment : NULL,
1168	"%s", pszCmdLine) != -1;
1169	}
1170	else if (ret != 0)
1171	return -1;
1172	free(pszCmdLine);
1173	}
1174	return 0;
1175	}
1176
1177	VOID SetDetailsSwitches(HWND hwnd, DETAILS_SETTINGS * pds)
1178	{
1179	WinCheckMenuItem(hwnd, IDM_SHOWLNAMES, pds->detailslongname);
1180	WinCheckMenuItem(hwnd, IDM_SHOWSUBJECT, pds->detailssubject);
1181	WinCheckMenuItem(hwnd, IDM_SHOWEAS, pds->detailsea);
1182	WinCheckMenuItem(hwnd, IDM_SHOWSIZE, pds->detailssize);
1183	WinCheckMenuItem(hwnd, IDM_SHOWICON, pds->detailsicon);
1184	WinCheckMenuItem(hwnd, IDM_SHOWLWDATE, pds->detailslwdate);
1185	WinCheckMenuItem(hwnd, IDM_SHOWLWTIME, pds->detailslwtime);
1186	WinCheckMenuItem(hwnd, IDM_SHOWLADATE, pds->detailsladate);
1187	WinCheckMenuItem(hwnd, IDM_SHOWLATIME, pds->detailslatime);
1188	WinCheckMenuItem(hwnd, IDM_SHOWCRDATE, pds->detailscrdate);
1189	WinCheckMenuItem(hwnd, IDM_SHOWCRTIME, pds->detailscrtime);
1190	WinCheckMenuItem(hwnd, IDM_SHOWATTR, pds->detailsattr);
1191	}
1192
1193	VOID AdjustDetailsSwitches(HWND hwnd, HWND hwndMenu, USHORT cmd,
1194	PCSZ directory, PCSZ keyroot,
1195	DETAILS_SETTINGS * pds, BOOL compare)
1196	{
1197	BOOL *bool = NULL;
1198
1199	switch (cmd) {
1200	case IDM_SHOWLNAMES:
1201	bool = &pds->detailslongname;
1202	break;
1203	case IDM_SHOWSUBJECT:
1204	bool = &pds->detailssubject;
1205	break;
1206	case IDM_SHOWEAS:
1207	bool = &pds->detailsea;
1208	break;
1209	case IDM_SHOWSIZE:
1210	bool = &pds->detailssize;
1211	break;
1212	case IDM_SHOWICON:
1213	bool = &pds->detailsicon;
1214	break;
1215	case IDM_SHOWLWDATE:
1216	bool = &pds->detailslwdate;
1217	break;
1218	case IDM_SHOWLWTIME:
1219	bool = &pds->detailslwtime;
1220	break;
1221	case IDM_SHOWLADATE:
1222	bool = &pds->detailsladate;
1223	break;
1224	case IDM_SHOWLATIME:
1225	bool = &pds->detailslatime;
1226	break;
1227	case IDM_SHOWCRDATE:
1228	bool = &pds->detailscrdate;
1229	break;
1230	case IDM_SHOWCRTIME:
1231	bool = &pds->detailscrtime;
1232	break;
1233	case IDM_SHOWATTR:
1234	bool = &pds->detailsattr;
1235	break;
1236	default:
1237	if (hwndMenu)
1238	SetDetailsSwitches(hwndMenu, pds);
1239	return;
1240	}
1241	if (bool)
1242	bool = bool ? FALSE : TRUE;
1243	if (hwnd)
1244	AdjustCnrColsForPref(hwnd, directory, pds, compare);
1245	if (hwndMenu)
1246	SetDetailsSwitches(hwndMenu, pds);
1247	}
1248
1249	/**
1250	* Set default menu item to invoke for top level conditional cascade menu
1251	* @param def is default menu id (i.e. IDM_...)
1252	*/
1253
1254	VOID SetConditionalCascade(HWND hwndMenu, USHORT id, USHORT def)
1255	{
1256	MENUITEM mi;
1257
1258	mi.iPosition = MIT_END;
1259	mi.hItem = 0;
1260	mi.hwndSubMenu = (HWND)0;
1261	mi.afAttribute = 0;
1262	mi.afStyle = MIS_TEXT;
1263	if (WinSendMsg(hwndMenu,
1264	MM_QUERYITEM,
1265	MPFROM2SHORT(id, TRUE),
1266	MPFROMP(&mi)))
1267	{
1268	WinSetWindowBits(mi.hwndSubMenu, QWL_STYLE, MS_CONDITIONALCASCADE,
1269	MS_CONDITIONALCASCADE);
1270	WinSendMsg(mi.hwndSubMenu, MM_SETDEFAULTITEMID, MPFROMSHORT(def), MPVOID);
1271	WinCheckMenuItem(mi.hwndSubMenu, def, TRUE);
1272	}
1273	}
1274
1275	VOID SetSortChecks(HWND hwndMenu, INT sortflags)
1276	{
1277	WinCheckMenuItem(hwndMenu, IDM_SORTNONE, FALSE);
1278	WinCheckMenuItem(hwndMenu, IDM_SORTFIRST, FALSE);
1279	WinCheckMenuItem(hwndMenu, IDM_SORTLAST, FALSE);
1280	WinCheckMenuItem(hwndMenu, IDM_SORTSIZE, FALSE);
1281	WinCheckMenuItem(hwndMenu, IDM_SORTEASIZE, FALSE);
1282	WinCheckMenuItem(hwndMenu, IDM_SORTLWDATE, FALSE);
1283	WinCheckMenuItem(hwndMenu, IDM_SORTLADATE, FALSE);
1284	WinCheckMenuItem(hwndMenu, IDM_SORTCRDATE, FALSE);
1285	WinCheckMenuItem(hwndMenu, IDM_SORTFILENAME, FALSE);
1286	WinCheckMenuItem(hwndMenu, IDM_SORTNAME, FALSE);
1287	WinCheckMenuItem(hwndMenu, IDM_SORTSUBJECT, FALSE);
1288	WinCheckMenuItem(hwndMenu, IDM_SORTDIRSFIRST, FALSE);
1289	WinCheckMenuItem(hwndMenu, IDM_SORTDIRSLAST, FALSE);
1290	WinCheckMenuItem(hwndMenu, IDM_SORTREVERSE, FALSE);
1291	if (sortflags & SORT_FIRSTEXTENSION)
1292	WinCheckMenuItem(hwndMenu, IDM_SORTFIRST, TRUE);
1293	else if (sortflags & SORT_LASTEXTENSION)
1294	WinCheckMenuItem(hwndMenu, IDM_SORTLAST, TRUE);
1295	else if (sortflags & SORT_SIZE)
1296	WinCheckMenuItem(hwndMenu, IDM_SORTSIZE, TRUE);
1297	else if (sortflags & SORT_EASIZE)
1298	WinCheckMenuItem(hwndMenu, IDM_SORTEASIZE, TRUE);
1299	else if (sortflags & SORT_LWDATE)
1300	WinCheckMenuItem(hwndMenu, IDM_SORTLWDATE, TRUE);
1301	else if (sortflags & SORT_LADATE)
1302	WinCheckMenuItem(hwndMenu, IDM_SORTLADATE, TRUE);
1303	else if (sortflags & SORT_CRDATE)
1304	WinCheckMenuItem(hwndMenu, IDM_SORTCRDATE, TRUE);
1305	else if (sortflags & SORT_FILENAME)
1306	WinCheckMenuItem(hwndMenu, IDM_SORTFILENAME, TRUE);
1307	else if (sortflags & SORT_NOSORT)
1308	WinCheckMenuItem(hwndMenu, IDM_SORTNONE, TRUE);
1309	else if (sortflags & SORT_SUBJECT)
1310	WinCheckMenuItem(hwndMenu, IDM_SORTSUBJECT, TRUE);
1311	else
1312	WinCheckMenuItem(hwndMenu, IDM_SORTNAME, TRUE);
1313	if (sortflags & SORT_DIRSFIRST)
1314	WinCheckMenuItem(hwndMenu, IDM_SORTDIRSFIRST, TRUE);
1315	else if (sortflags & SORT_DIRSLAST)
1316	WinCheckMenuItem(hwndMenu, IDM_SORTDIRSLAST, TRUE);
1317	if (sortflags & SORT_REVERSE)
1318	WinCheckMenuItem(hwndMenu, IDM_SORTREVERSE, TRUE);
1319	}
1320
1321	VOID FcloseFile(FILE * fp)
1322	{
1323	// for use by apps that don't use the DLLs runtime library
1324	fclose(fp);
1325	}
1326
1327	VOID SetupCommandMenu(HWND hwndMenu, HWND hwndCnr)
1328	{
1329	MENUITEM mi, mit;
1330	INT x;
1331	SHORT numitems;
1332	LINKCMDS *info;
1333
1334	if (!cmdloaded)
1335	load_commands();
1336	mi.iPosition = MIT_END;
1337	mi.hwndSubMenu = (HWND) 0;
1338	mi.hItem = 0L;
1339	mi.afAttribute = 0;
1340	mi.afStyle = MIS_TEXT;
1341	memset(&mit, 0, sizeof(MENUITEM));
1342	if (WinQueryWindowUShort(hwndMenu, QWS_ID) == IDM_COMMANDSMENU)
1343	mit.hwndSubMenu = hwndMenu;
1344	else
1345	WinSendMsg(hwndMenu, MM_QUERYITEM,
1346	MPFROM2SHORT(IDM_COMMANDSMENU, TRUE), MPFROMP(&mit));
1347	if (mit.hwndSubMenu) {
1348	numitems = (SHORT) WinSendMsg(mit.hwndSubMenu, MM_QUERYITEMCOUNT,
1349	MPVOID, MPVOID);
1350	WinSendMsg(mit.hwndSubMenu, MM_DELETEITEM, MPFROMSHORT(-1), MPVOID);
1351	info = cmdhead;
1352	while (info) {
1353	WinSendMsg(mit.hwndSubMenu, MM_DELETEITEM,
1354	MPFROMSHORT((SHORT) (info->ID)), MPVOID);
1355	x++;
1356	info = info->next;
1357	}
1358	while (numitems != MIT_ERROR) { // Delete items that were deleted from commands since the ID is gone
1359	numitems = (SHORT) WinSendMsg(mit.hwndSubMenu, MM_ITEMIDFROMPOSITION,
1360	MPFROMSHORT((SHORT) 1), MPVOID);
1361	WinSendMsg(mit.hwndSubMenu, MM_DELETEITEM,
1362	MPFROMSHORT(numitems), MPVOID);
1363	}
1364	if (hwndCnr && cmdhead) {
1365	x = 0;
1366	info = cmdhead;
1367	while (info) {
1368
1369	CHAR s[CCHMAXPATH + 24];
1370
1371	sprintf(s,
1372	"%s {%i} %s%s%s",
1373	info->title, info->ID,
1374	info->HotKeyID && info->HotKeyID < IDM_COMMANDNUM20 ? "\tCtrl + " : NullStr,
1375	info->HotKeyID && info->HotKeyID > IDM_COMMANDNUM19 ? "\tAlt + " : NullStr,
1376	info->HotKeyID && ((info->HotKeyID > IDM_COMMANDNUM9 &&
1377	info->HotKeyID < IDM_COMMANDNUM20) \|\|
1378	info->HotKeyID > IDM_COMMANDNUM29) ? "Shift + " : NullStr);
1379	if (info->HotKeyID)
1380	sprintf(&s[strlen(s)], "%d",
1381	(((info->HotKeyID - IDM_COMMANDNUM0) % 10) + 1) == 10 ? 0 :
1382	((info->HotKeyID - IDM_COMMANDNUM0) % 10) + 1);
1383	mi.id = (USHORT) info->ID;
1384	mi.afAttribute = (info->flags & ONCE ? MIA_CHECKED : 0) \|
1385	(info->flags & PROMPT ? MIA_FRAMED : 0);
1386	mi.afStyle = MIS_TEXT;
1387	if (!(x % 20) && x && info->next)
1388	mi.afStyle \|= MIS_BREAK;
1389	WinSendMsg(mit.hwndSubMenu, MM_INSERTITEM, MPFROMP(&mi), MPFROMP(s));
1390	x++;
1391	info = info->next;
1392	}
1393	}
1394	}
1395	}
1396
1397	/**
1398	* Loads all the detail switches from the ini file
1399	* state if TRUE skips global only settings
1400	* keyroot shouldn't pass trailing dot
1401	*/
1402	VOID LoadDetailsSwitches(PCSZ keyroot, DETAILS_SETTINGS *pds, BOOL state)
1403	{
1404	ULONG size;
1405	CHAR s[CCHMAXPATH], *eos = s;
1406
1407	strcpy(s, keyroot);
1408	strcat(s, ".");
1409	eos = &s[strlen(s)];
1410	strcpy(eos, "DetailsLongname");
1411	pds->detailslongname = dsDirCnrDefault.detailslongname;
1412	size = sizeof(BOOL);
1413	PrfQueryProfileData(fmprof, appname, s, (PVOID) &pds->detailslongname, &size);
1414	strcpy(eos, "DetailsSubject");
1415	pds->detailssubject = dsDirCnrDefault.detailssubject;
1416	size = sizeof(BOOL);
1417	PrfQueryProfileData(fmprof, appname, s, (PVOID) &pds->detailssubject, &size);
1418	strcpy(eos, "DetailsEA");
1419	pds->detailsea = dsDirCnrDefault.detailsea;
1420	size = sizeof(BOOL);
1421	PrfQueryProfileData(fmprof, appname, s, (PVOID) &pds->detailsea, &size);
1422	strcpy(eos, "DetailsSize");
1423	pds->detailssize = dsDirCnrDefault.detailssize;
1424	size = sizeof(BOOL);
1425	PrfQueryProfileData(fmprof, appname, s, (PVOID) &pds->detailssize, &size);
1426	strcpy(eos, "DetailsIcon");
1427	pds->detailsicon = dsDirCnrDefault.detailsicon;
1428	size = sizeof(BOOL);
1429	PrfQueryProfileData(fmprof, appname, s, (PVOID) &pds->detailsicon, &size);
1430	strcpy(eos, "DetailsAttr");
1431	pds->detailsattr = dsDirCnrDefault.detailsattr;
1432	size = sizeof(BOOL);
1433	PrfQueryProfileData(fmprof, appname, s, (PVOID) &pds->detailsattr, &size);
1434	strcpy(eos, "DetailsCRDate");
1435	pds->detailscrdate = dsDirCnrDefault.detailscrdate;
1436	size = sizeof(BOOL);
1437	PrfQueryProfileData(fmprof, appname, s, (PVOID) &pds->detailscrdate, &size);
1438	strcpy(eos, "DetailsCRTime");
1439	pds->detailscrtime = dsDirCnrDefault.detailscrtime;
1440	size = sizeof(BOOL);
1441	PrfQueryProfileData(fmprof, appname, s, (PVOID) &pds->detailscrtime, &size);
1442	strcpy(eos, "DetailsLWDate");
1443	pds->detailslwdate = dsDirCnrDefault.detailslwdate;
1444	size = sizeof(BOOL);
1445	PrfQueryProfileData(fmprof, appname, s, (PVOID) &pds->detailslwdate, &size);
1446	strcpy(eos, "DetailsLWTime");
1447	pds->detailslwtime = dsDirCnrDefault.detailslwtime;
1448	size = sizeof(BOOL);
1449	PrfQueryProfileData(fmprof, appname, s, (PVOID) &pds->detailslwtime, &size);
1450	strcpy(eos, "DetailsLADate");
1451	pds->detailsladate = dsDirCnrDefault.detailsladate;
1452	size = sizeof(BOOL);
1453	PrfQueryProfileData(fmprof, appname, s, (PVOID) &pds->detailsladate, &size);
1454	strcpy(eos, "DetailsLATime");
1455	pds->detailslatime = dsDirCnrDefault.detailslatime;
1456	size = sizeof(BOOL);
1457	PrfQueryProfileData(fmprof, appname, s, (PVOID) &pds->detailslatime, &size);
1458	if (!state) {
1459	strcpy(eos, "SubjectInLeftPane");
1460	pds->fSubjectInLeftPane = dsDirCnrDefault.fSubjectInLeftPane;
1461	size = sizeof(BOOL);
1462	PrfQueryProfileData(fmprof, appname, s, (PVOID) &pds->fSubjectInLeftPane, &size);
1463	strcpy(eos, "SubjectLengthMax");
1464	pds->fSubjectLengthMax = dsDirCnrDefault.fSubjectLengthMax;
1465	size = sizeof(BOOL);
1466	PrfQueryProfileData(fmprof, appname, s, (PVOID) &pds->fSubjectLengthMax, &size);
1467	if (pds->fSubjectLengthMax)
1468	pds->SubjectDisplayWidth = 0;
1469	else {
1470	strcpy(eos, "SubjectDisplayWidth");
1471	pds->SubjectDisplayWidth = dsDirCnrDefault.SubjectDisplayWidth;
1472	size = sizeof(ULONG);
1473	PrfQueryProfileData(fmprof, appname, s, (PVOID) &pds->SubjectDisplayWidth, &size);
1474	if (pds->SubjectDisplayWidth < 50)
1475	pds->SubjectDisplayWidth = 0;
1476	else if (pds->SubjectDisplayWidth > 1000)
1477	pds->SubjectDisplayWidth = 1000;
1478	}
1479	}
1480	}
1481
1482	/**
1483	* Writes all the detail switches to the ini file
1484	* state if TRUE skips global only settings
1485	* keyroot shouldn't pass trailing dot
1486	*/
1487	VOID WriteDetailsSwitches(PCSZ keyroot, DETAILS_SETTINGS *pds, BOOL state)
1488	{
1489	CHAR s[CCHMAXPATH], *eos = s;
1490
1491	strcpy(s, keyroot);
1492	strcat(s, ".");
1493	eos = &s[strlen(s)];
1494	strcpy(eos, "DetailsLongname");
1495	PrfWriteProfileData(fmprof, appname, s, &pds->detailslongname, sizeof(BOOL));
1496	strcpy(eos, "DetailsSubject");
1497	PrfWriteProfileData(fmprof, appname, s, &pds->detailssubject, sizeof(BOOL));
1498	strcpy(eos, "DetailsEA");
1499	PrfWriteProfileData(fmprof, appname, s, &pds->detailsea, sizeof(BOOL));
1500	strcpy(eos, "DetailsSize");
1501	PrfWriteProfileData(fmprof, appname, s, &pds->detailssize, sizeof(BOOL));
1502	strcpy(eos, "DetailsIcon");
1503	PrfWriteProfileData(fmprof, appname, s, &pds->detailsicon, sizeof(BOOL));
1504	strcpy(eos, "DetailsAttr");
1505	PrfWriteProfileData(fmprof, appname, s, &pds->detailsattr, sizeof(BOOL));
1506	strcpy(eos, "DetailsCRDate");
1507	PrfWriteProfileData(fmprof, appname, s, &pds->detailscrdate, sizeof(BOOL));
1508	strcpy(eos, "DetailsCRTime");
1509	PrfWriteProfileData(fmprof, appname, s, &pds->detailscrtime, sizeof(BOOL));
1510	strcpy(eos, "DetailsLWDate");
1511	PrfWriteProfileData(fmprof, appname, s, &pds->detailslwdate, sizeof(BOOL));
1512	strcpy(eos, "DetailsLWTime");
1513	PrfWriteProfileData(fmprof, appname, s, &pds->detailslwtime, sizeof(BOOL));
1514	strcpy(eos, "DetailsLADate");
1515	PrfWriteProfileData(fmprof, appname, s, &pds->detailsladate, sizeof(BOOL));
1516	strcpy(eos, "DetailsLATime");
1517	PrfWriteProfileData(fmprof, appname, s, &pds->detailslatime, sizeof(BOOL));
1518	if (!state) {
1519	strcpy(eos, "SubjectInLeftPane");
1520	PrfWriteProfileData(fmprof, appname, s, &pds->fSubjectInLeftPane, sizeof(BOOL));
1521	strcpy(eos, "SubjectLengthMax");
1522	PrfWriteProfileData(fmprof, appname, s, &pds->fSubjectLengthMax, sizeof(BOOL));
1523	strcpy(eos, "SubjectDisplayWidth");
1524	PrfWriteProfileData(fmprof, appname, s, &pds->SubjectDisplayWidth, sizeof(ULONG));
1525	}
1526	}
1527
1528	/**
1529	* Removes the ini entries when a state is deleted
1530	* statename should be NULL for the shutdown state
1531	* (avoids removing global state settings like toolbar)
1532	* keyroot shouldn't pass the trailing dot
1533	*/
1534	VOID RemoveCnrSwitches(PCSZ keyroot, PCSZ statename)
1535	{
1536	CHAR s[CCHMAXPATH], *eos = s;
1537
1538	strcpy(s, keyroot);
1539	strcat(s, ".");
1540	eos = &s[strlen(s)];
1541	DeletePresParams(s);
1542	strcpy(eos, "DetailsLongname");
1543	PrfWriteProfileData(fmprof, appname, s, NULL, 0);
1544	strcpy(eos, "DetailsSubject");
1545	PrfWriteProfileData(fmprof, appname, s, NULL, 0);
1546	strcpy(eos, "DetailsEA");
1547	PrfWriteProfileData(fmprof, appname, s, NULL, 0);
1548	strcpy(eos, "DetailsSize");
1549	PrfWriteProfileData(fmprof, appname, s, NULL, 0);
1550	strcpy(eos, "DetailsIcon");
1551	PrfWriteProfileData(fmprof, appname, s, NULL, 0);
1552	strcpy(eos, "DetailsAttr");
1553	PrfWriteProfileData(fmprof, appname, s, NULL, 0);
1554	strcpy(eos, "DetailsCRDate");
1555	PrfWriteProfileData(fmprof, appname, s, NULL, 0);
1556	strcpy(eos, "DetailsCRTime");
1557	PrfWriteProfileData(fmprof, appname, s, NULL, 0);
1558	strcpy(eos, "DetailsLWDate");
1559	PrfWriteProfileData(fmprof, appname, s, NULL, 0);
1560	strcpy(eos, "DetailsLWTime");
1561	PrfWriteProfileData(fmprof, appname, s, NULL, 0);
1562	strcpy(eos, "DetailsLADate");
1563	PrfWriteProfileData(fmprof, appname, s, NULL, 0);
1564	strcpy(eos, "DetailsLATime");
1565	PrfWriteProfileData(fmprof, appname, s, NULL, 0);
1566
1567	#ifdef NEVER
1568	// activate this code if we ever allow setting of subject location/length per container GKY 3-28-09
1569	strcpy(eos, "SubjectInLeftPane");
1570	PrfWriteProfileData(fmprof, appname, s, NULL, 0);
1571	strcpy(eos, "SubjectLengthMax");
1572	PrfWriteProfileData(fmprof, appname, s, NULL, 0);
1573	strcpy(eos, "SubjectDisplayWidth");
1574	PrfWriteProfileData(fmprof, appname, s, NULL, 0);
1575	#endif
1576
1577	strcpy(eos, "Pos");;
1578	PrfWriteProfileData(fmprof, FM3Str, s, NULL, 0);
1579	strcpy(eos, "Sort");
1580	PrfWriteProfileData(fmprof, FM3Str, s, NULL, 0);
1581	strcpy(eos, "Filter");
1582	PrfWriteProfileData(fmprof, FM3Str, s, NULL, 0);
1583	strcpy(eos, "View");
1584	PrfWriteProfileData(fmprof, FM3Str, s, NULL, 0);
1585	strcpy(eos, "Dir");
1586	PrfWriteProfileString(fmprof, FM3Str, s, NULL);
1587	if (statename && strstr(s, ".0.")) {
1588	strcpy(s, statename);
1589	strcat(s, ".");
1590	eos = &s[strlen(s)];
1591	strcpy(eos, "LastTreePos");
1592	PrfWriteProfileData(fmprof, FM3Str, s, NULL, 0);
1593	strcpy(eos, "MySizeLastTime");
1594	PrfWriteProfileData(fmprof, FM3Str, s, NULL, 0);
1595	strcpy(eos, "Toolbar");
1596	PrfWriteProfileString(fmprof, FM3Str, s, NULL);
1597	strcpy(eos, "TargetDir");
1598	PrfWriteProfileString(fmprof, FM3Str, s, NULL);
1599	}
1600
1601	}
1602
1603	/**
1604	* Removes the pre 3.16 style ini entries when a state is deleted
1605	*/
1606	VOID RemoveOldCnrSwitches(PCSZ szPrefix, ULONG ulTemp)
1607	{
1608	CHAR szKey[STATE_NAME_MAX_BYTES + 80];
1609
1610	sprintf(szKey, "%sDirCnrPos.%lu", szPrefix, ulTemp);
1611	PrfWriteProfileData(fmprof, FM3Str, szKey, NULL, 0);
1612	sprintf(szKey, "%sDirCnrSort.%lu", szPrefix, ulTemp);
1613	PrfWriteProfileData(fmprof, FM3Str, szKey, NULL, 0);
1614	sprintf(szKey, "%sDirCnrFilter.%lu", szPrefix, ulTemp);
1615	PrfWriteProfileData(fmprof, FM3Str, szKey, NULL, 0);
1616	sprintf(szKey, "%sDirCnrView.%lu", szPrefix, ulTemp);
1617	PrfWriteProfileData(fmprof, FM3Str, szKey, NULL, 0);
1618	sprintf(szKey, "%sDirCnrDir.%lu", szPrefix, ulTemp);
1619	PrfWriteProfileString(fmprof, FM3Str, szKey, NULL);
1620	sprintf(szKey, "%sDirCnr.%lu.", szPrefix, ulTemp);
1621	}
1622
1623	HWND FindDirCnr(HWND hwndParent)
1624	{
1625	HWND found, hwndDir = (HWND) 0;
1626	HENUM henum;
1627
1628	henum = WinBeginEnumWindows(hwndParent);
1629	while ((found = WinGetNextWindow(henum)) != NULLHANDLE) {
1630	hwndDir = WinWindowFromID(found, FID_CLIENT);
1631	if (hwndDir) {
1632	hwndDir = WinWindowFromID(hwndDir, DIR_CNR);
1633	if (hwndDir)
1634	break;
1635	hwndDir = (HWND) 0;
1636	}
1637	}
1638	WinEndEnumWindows(henum);
1639
1640	return hwndDir;
1641	}
1642
1643	VOID HeapThread(VOID * dummy)
1644	{
1645	ULONG postcount;
1646	APIRET rc;
1647
1648	rc = DosCreateEventSem(NULL, &CompactSem, 0L, FALSE);
1649	if (rc)
1650	Dos_Error(MB_CANCEL, rc, HWND_DESKTOP, pszSrcFile, __LINE__,
1651	"DosCreateEventSem");
1652	else {
1653	priority_normal();
1654	for (;;) {
1655	if (DosWaitEventSem(CompactSem, SEM_INDEFINITE_WAIT))
1656	break;
1657	_heapmin();
1658	DosResetEventSem(CompactSem, &postcount);
1659	}
1660	}
1661	}
1662
1663	VOID FixSwitchList(HWND hwnd, PCSZ text)
1664	{
1665	HSWITCH hswitch;
1666	SWCNTRL swctl;
1667
1668	hswitch = WinQuerySwitchHandle(hwnd, 0);
1669	if (hswitch) {
1670	if (!WinQuerySwitchEntry(hswitch, &swctl)) {
1671	strcpy(swctl.szSwtitle, "FM/2");
1672	WinChangeSwitchEntry(hswitch, &swctl);
1673	}
1674	}
1675	}
1676
1677	VOID QuickPopup(HWND hwnd, DIRCNRDATA * dcd, HWND hwndMenu, USHORT id)
1678	{
1679	dcd->hwndLastMenu = hwndMenu;
1680	if (dcd->hwndLastMenu && !dcd->cnremphasized) {
1681	WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPVOID,
1682	MPFROM2SHORT(TRUE, CRA_SOURCE));
1683	dcd->cnremphasized = TRUE;
1684	}
1685	if (dcd->flWindowAttr & CV_MINI)
1686	WinCheckMenuItem(dcd->hwndLastMenu, IDM_MINIICONS, TRUE);
1687	if (!WinPopupMenu(hwnd, hwnd, dcd->hwndLastMenu,
1688	8, 8, 0,
1689	PU_HCONSTRAIN \| PU_VCONSTRAIN \|
1690	PU_KEYBOARD \| PU_MOUSEBUTTON1)) {
1691	if (dcd->cnremphasized) {
1692	WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPVOID,
1693	MPFROM2SHORT(FALSE, CRA_SOURCE));
1694	dcd->cnremphasized = FALSE;
1695	}
1696	}
1697	else
1698	WinSendMsg(dcd->hwndLastMenu, MM_SELECTITEM,
1699	MPFROM2SHORT(id, TRUE), MPFROM2SHORT(0, FALSE));
1700	}
1701
1702	PMINIRECORDCORE CurrentRecord(HWND hwndCnr)
1703	{
1704	SHORT attrib = fSelectedAlways ? CRA_SELECTED : CRA_CURSORED;
1705	PMINIRECORDCORE pmi;
1706
1707	for (;;) {
1708	pmi = (PMINIRECORDCORE) WinSendMsg(hwndCnr, CM_QUERYRECORDEMPHASIS,
1709	MPFROMLONG(CMA_FIRST),
1710	MPFROMSHORT(attrib));
1711	if ((!pmi \|\| (INT) pmi == -1) && attrib == CRA_SELECTED) // punt
1712	attrib = CRA_CURSORED;
1713	else
1714	break;
1715	}
1716	return ((INT)pmi == -1) ? NULL : pmi;
1717	}
1718
1719	BOOL PostMsg(HWND h, ULONG msg, MPARAM mp1, MPARAM mp2)
1720	{
1721	BOOL rc = WinPostMsg(h, msg, mp1, mp2);
1722
1723	if (!rc) {
1724
1725	// If window owned by some other process or some other thread?
1726	if (!IsFm2Window(h, 1)) {
1727	QMSG qmsg;
1728	for (;;) {
1729	DosSleep(1);
1730	rc = WinPostMsg(h, msg, mp1, mp2);
1731	if (rc)
1732	break; // OK
1733	if (!WinIsWindow((HAB) 0, h))
1734	break; // Window gone
1735	if (WinPeekMsg((HAB) 0, &qmsg, (HWND) 0, 0, 0, PM_NOREMOVE))
1736	break; // Queue has message(s)
1737	} // for
1738	}
1739	}
1740	return rc;
1741	}
1742
1743	VOID OpenEdit(HWND hwnd)
1744	{
1745	CNREDITDATA ced;
1746	PCNRITEM pci;
1747	PFIELDINFO pfi;
1748
1749	pci = (PCNRITEM) WinSendMsg(hwnd,
1750	CM_QUERYRECORDEMPHASIS,
1751	MPFROMLONG(CMA_FIRST),
1752	MPFROMSHORT(CRA_CURSORED));
1753	if (pci && (INT) pci != -1) {
1754	memset(&ced, 0, sizeof(ced));
1755	ced.cb = sizeof(ced);
1756	ced.hwndCnr = hwnd;
1757	ced.id = WinQueryWindowUShort(hwnd, QWS_ID);
1758	ced.pRecord = (PRECORDCORE) pci;
1759	pfi = (PFIELDINFO) WinSendMsg(hwnd,
1760	CM_QUERYDETAILFIELDINFO,
1761	MPVOID, MPFROMSHORT(CMA_FIRST));
1762	if (!pfi)
1763	WinSendMsg(hwnd, CM_OPENEDIT, MPFROMP(&ced), MPVOID);
1764	else {
1765	while (pfi && (INT) pfi != -1 &&
1766	pfi->offStruct != FIELDOFFSET(CNRITEM, pszFileName))
1767	pfi = (PFIELDINFO) WinSendMsg(hwnd,
1768	CM_QUERYDETAILFIELDINFO,
1769	MPFROMP(pfi), MPFROMSHORT(CMA_NEXT));
1770	if (pfi && (INT) pfi != -1) {
1771	ced.pFieldInfo = pfi;
1772	{
1773	CNRINFO cnri;
1774
1775	memset(&cnri, 0, sizeof(CNRINFO));
1776	cnri.cb = sizeof(CNRINFO);
1777	WinSendMsg(hwnd,
1778	CM_QUERYCNRINFO,
1779	MPFROMP(&cnri), MPFROMLONG(sizeof(CNRINFO)));
1780	if (cnri.flWindowAttr & CV_DETAIL)
1781	ced.id = CID_LEFTDVWND;
1782	}
1783	WinSendMsg(hwnd, CM_OPENEDIT, MPFROMP(&ced), MPVOID);
1784	}
1785	}
1786	}
1787	}
1788
1789	#ifdef NEVER
1790	VOID QuickView(HWND hwnd, PCSZ filename)
1791	{
1792	if (filename && IsFile(filename) == 1) {
1793	if (TestBinary(filename) && *binview) {
1794
1795	CHAR *list[2];
1796
1797	list[0] = filename;
1798	list[1] = NULL;
1799	ExecOnList(hwnd, binview, WINDOWED \| SEPARATE, NULL, NULL, list, NULL,
1800	pszSrcFile, __LINE__);
1801	return;
1802	}
1803	else if (*viewer) {
1804
1805	CHAR *list[2];
1806
1807	list[0] = filename;
1808	list[1] = NULL;
1809	ExecOnList(hwnd, viewer,
1810	WINDOWED \| SEPARATE \| (fViewChild ? CHILD : 0),
1811	NULL, NULL, list, NULL, pszSrcFile, __LINE__);
1812	return;
1813	}
1814	StartMLEEditor(HWND_DESKTOP, 5, filename, (HWND) 0);
1815	}
1816	}
1817
1818	VOID QuickEdit(HWND hwnd, CHAR * filename)
1819	{
1820	if (filename && IsFile(filename) == 1) {
1821	if (TestBinary(filename) && *bined) {
1822
1823	CHAR *list[2];
1824
1825	list[0] = filename;
1826	list[1] = NULL;
1827	ExecOnList(hwnd, bined, WINDOWED \| SEPARATE, NULL, NULL, list, NULL,
1828	pszSrcFile, __LINE__);
1829	return;
1830	}
1831	else if (*editor) {
1832
1833	CHAR *list[2];
1834
1835	list[0] = filename;
1836	list[1] = NULL;
1837	ExecOnList(hwnd, editor, WINDOWED \| SEPARATE, NULL, NULL, list, NULL,
1838	pszSrcFile, __LINE__);
1839	return;
1840	}
1841	StartMLEEditor(HWND_DESKTOP, 4, filename, (HWND) 0);
1842	}
1843	}
1844	#endif
1845
1846	VOID PortholeInit(HWND hwndNew, MPARAM mp1, MPARAM mp2)
1847	{
1848	static HWND DefMenu = (HWND) 0;
1849	HWND hwndMenu = (HWND) mp2;
1850
1851	{
1852	ULONG style;
1853
1854	style = WinQueryWindowULong(hwndMenu, QWL_STYLE);
1855	if (!(style & MS_ACTIONBAR))
1856	return;
1857	}
1858
1859	switch (SHORT1FROMMP(mp1)) {
1860	case 0:
1861	{
1862	HWND hwndNow;
1863	MENUITEM mi;
1864	ULONG ulStyle;
1865
1866	memset(&mi, 0, sizeof(mi));
1867	mi.iPosition = MIT_END;
1868	mi.afStyle = MIS_TEXT;
1869	WinSendMsg(hwndMenu, MM_QUERYITEM,
1870	MPFROM2SHORT(IDM_FILESMENU, TRUE), MPFROMP(&mi));
1871	if (!DefMenu)
1872	DefMenu = WinLoadMenu(HWND_DESKTOP, FM3ModHandle, DEFMENU);
1873	hwndNow = mi.hwndSubMenu;
1874	mi.hwndSubMenu = hwndNew;
1875	if (!mi.hwndSubMenu)
1876	mi.hwndSubMenu = DefMenu;
1877	WinSetParent(hwndNow, WinQueryObjectWindow(HWND_DESKTOP), FALSE);
1878	WinSetOwner(hwndNow, WinQueryObjectWindow(HWND_DESKTOP));
1879	WinSetOwner(mi.hwndSubMenu, hwndMenu);
1880	WinSetParent(mi.hwndSubMenu, hwndMenu, FALSE);
1881	WinSetWindowUShort(mi.hwndSubMenu, QWS_ID, IDM_FILESMENU);
1882	mi.afStyle = MIS_SUBMENU;
1883	ulStyle = WinQueryWindowULong(mi.hwndSubMenu, QWL_STYLE);
1884	ulStyle &= -WS_SAVEBITS;
1885	ulStyle \|= MS_POPUP \| WS_CLIPSIBLINGS \| WS_SAVEBITS;
1886	WinSetWindowULong(mi.hwndSubMenu, QWL_STYLE, ulStyle);
1887	WinSendMsg(hwndMenu, MM_SETITEM, MPFROM2SHORT(0, TRUE), MPFROMP(&mi));
1888	}
1889	break;
1890
1891	case 1:
1892	{
1893	HWND hwndNow;
1894	MENUITEM mi;
1895	ULONG ulStyle;
1896
1897	memset(&mi, 0, sizeof(mi));
1898	mi.iPosition = MIT_END;
1899	mi.afStyle = MIS_TEXT;
1900	WinSendMsg(hwndMenu, MM_QUERYITEM,
1901	MPFROM2SHORT(IDM_VIEWSMENU, TRUE), MPFROMP(&mi));
1902	if (!DefMenu)
1903	DefMenu = WinLoadMenu(HWND_DESKTOP, FM3ModHandle, DEFMENU);
1904	hwndNow = mi.hwndSubMenu;
1905	mi.hwndSubMenu = hwndNew;
1906	if (!mi.hwndSubMenu)
1907	mi.hwndSubMenu = DefMenu;
1908	WinSetParent(hwndNow, WinQueryObjectWindow(HWND_DESKTOP), FALSE);
1909	WinSetOwner(hwndNow, WinQueryObjectWindow(HWND_DESKTOP));
1910	WinSetOwner(mi.hwndSubMenu, hwndMenu);
1911	WinSetParent(mi.hwndSubMenu, hwndMenu, FALSE);
1912	WinSetWindowUShort(mi.hwndSubMenu, QWS_ID, IDM_VIEWSMENU);
1913	mi.afStyle = MIS_SUBMENU;
1914	ulStyle = WinQueryWindowULong(mi.hwndSubMenu, QWL_STYLE);
1915	ulStyle &= -WS_SAVEBITS;
1916	ulStyle \|= MS_POPUP \| WS_CLIPSIBLINGS \| WS_SAVEBITS;
1917	WinSetWindowULong(mi.hwndSubMenu, QWL_STYLE, ulStyle);
1918	WinSendMsg(hwndMenu, MM_SETITEM, MPFROM2SHORT(0, TRUE), MPFROMP(&mi));
1919	}
1920	break;
1921	}
1922	}
1923
1924	HWND CheckMenu(HWND hwnd, HWND * hwndMenu, USHORT id)
1925	{
1926	// load and adjust menus as required
1927	if (!hwndMenu \|\| !WinIsWindow((HAB) 0, hwndMenu)) {
1928	*hwndMenu = WinLoadMenu(HWND_DESKTOP, FM3ModHandle, id);
1929	CopyPresParams(*hwndMenu, hwnd);
1930	if (hwndMenu == &DirMenu) {
1931	WinSetWindowUShort(DirMenu, QWS_ID, IDM_FILESMENU);
1932	SetConditionalCascade(DirMenu, IDM_COMMANDSMENU, IDM_DOITYOURSELF);
1933	SetConditionalCascade(DirMenu, IDM_COPYMENU, IDM_COPY);
1934	SetConditionalCascade(DirMenu, IDM_MOVEMENU, IDM_MOVE);
1935	SetConditionalCascade(DirMenu, IDM_SAVESUBMENU, IDM_SAVETOCLIP);
1936	SetConditionalCascade(DirMenu, IDM_VIEWSUBMENU, IDM_INFO);
1937	SetConditionalCascade(DirMenu, IDM_EDITSUBMENU, IDM_ATTRS);
1938	SetConditionalCascade(DirMenu, IDM_DELETESUBMENU,
1939	fDefaultDeletePerm ? IDM_PERMDELETE : IDM_DELETE);
1940	SetConditionalCascade(DirMenu, IDM_MISCSUBMENU, IDM_SIZES);
1941	SetConditionalCascade(DirMenu, IDM_OPENSUBMENU, IDM_OPENWINDOW);
1942	if (fWorkPlace) {
1943	WinSendMsg(DirMenu, MM_DELETEITEM,
1944	MPFROM2SHORT(IDM_OPENSUBMENU, TRUE), MPVOID);
1945	WinSendMsg(DirMenu, MM_DELETEITEM,
1946	MPFROM2SHORT(IDM_OBJECTSUBMENU, TRUE), MPVOID);
1947	}
1948	}
1949	else if (hwndMenu == &TreeMenu) {
1950	WinSetWindowUShort(TreeMenu, QWS_ID, IDM_FILESMENU);
1951	SetConditionalCascade(TreeMenu, IDM_COMMANDSMENU, IDM_DOITYOURSELF);
1952	SetConditionalCascade(TreeMenu, IDM_SAVESUBMENU, IDM_SAVETOCLIP);
1953	SetConditionalCascade(TreeMenu, IDM_EDITSUBMENU, IDM_ATTRS);
1954	SetConditionalCascade(TreeMenu, IDM_EXPANDSUBMENU, IDM_EXPAND);
1955	SetConditionalCascade(TreeMenu, IDM_MISCSUBMENU, IDM_SIZES);
1956	SetConditionalCascade(TreeMenu, IDM_OPENSUBMENU, IDM_OPENWINDOW);
1957	if (fWorkPlace) {
1958	WinSendMsg(TreeMenu, MM_DELETEITEM,
1959	MPFROM2SHORT(IDM_OPENSUBMENU, TRUE), MPVOID);
1960	WinSendMsg(TreeMenu, MM_DELETEITEM,
1961	MPFROM2SHORT(IDM_OBJECTSUBMENU, TRUE), MPVOID);
1962	}
1963	if (!fLVM)
1964	WinSendMsg(TreeMenu, MM_DELETEITEM,
1965	MPFROM2SHORT(IDM_REFRESHREMOVABLES, TRUE), MPVOID);
1966	}
1967	else if (hwndMenu == &ArcMenu) {
1968	WinSetWindowUShort(ArcMenu, QWS_ID, IDM_FILESMENU);
1969	SetConditionalCascade(ArcMenu, IDM_EXTRACTSUBMENU, IDM_EXTRACT);
1970	SetConditionalCascade(ArcMenu, IDM_EDITSUBMENU, IDM_EDIT);
1971	SetConditionalCascade(ArcMenu, IDM_VIEWSUBMENU, IDM_VIEW);
1972	if (fWorkPlace)
1973	WinSendMsg(ArcMenu, MM_DELETEITEM,
1974	MPFROM2SHORT(IDM_FOLDERAFTEREXTRACT, TRUE), MPVOID);
1975	}
1976	else if (hwndMenu == &FileMenu) {
1977	WinSetWindowUShort(FileMenu, QWS_ID, IDM_FILESMENU);
1978	SetConditionalCascade(FileMenu, IDM_COMMANDSMENU, IDM_DOITYOURSELF);
1979	SetConditionalCascade(FileMenu, IDM_COPYMENU, IDM_COPY);
1980	SetConditionalCascade(FileMenu, IDM_MOVEMENU, IDM_MOVE);
1981	SetConditionalCascade(FileMenu, IDM_SAVESUBMENU, IDM_SAVETOCLIP);
1982	SetConditionalCascade(FileMenu, IDM_VIEWSUBMENU, IDM_VIEW);
1983	SetConditionalCascade(FileMenu, IDM_EDITSUBMENU, IDM_EDIT);
1984	SetConditionalCascade(FileMenu, IDM_COLLECTMENU, IDM_COLLECT);
1985	SetConditionalCascade(FileMenu, IDM_DELETESUBMENU,
1986	fDefaultDeletePerm ? IDM_PERMDELETE : IDM_DELETE);
1987	SetConditionalCascade(FileMenu, IDM_OPENSUBMENU, IDM_OPENDEFAULT);
1988	SetConditionalCascade(FileMenu, IDM_OBJECTSUBMENU, IDM_SHADOW);
1989	if (fWorkPlace) {
1990	WinSendMsg(FileMenu, MM_DELETEITEM,
1991	MPFROM2SHORT(IDM_OPENSUBMENU, TRUE), MPVOID);
1992	WinSendMsg(FileMenu, MM_DELETEITEM,
1993	MPFROM2SHORT(IDM_OBJECTSUBMENU, TRUE), MPVOID);
1994	}
1995	if (!fLVM)
1996	WinSendMsg(FileMenu, MM_DELETEITEM,
1997	MPFROM2SHORT(IDM_REFRESHREMOVABLES, TRUE), MPVOID);
1998	}
1999	else if (hwndMenu == &DirCnrMenu) {
2000	WinSetWindowUShort(DirCnrMenu, QWS_ID, IDM_VIEWSMENU);
2001	SetConditionalCascade(DirCnrMenu, IDM_MISCSUBMENU, IDM_SIZES);
2002	SetConditionalCascade(DirCnrMenu, IDM_OPENSUBMENU, IDM_OPENSETTINGSME);
2003	if (fWorkPlace)
2004	WinSendMsg(DirCnrMenu, MM_DELETEITEM,
2005	MPFROM2SHORT(IDM_OPENSUBMENU, TRUE), MPVOID);
2006	}
2007	else if (hwndMenu == &TreeCnrMenu) {
2008	WinSetWindowUShort(TreeCnrMenu, QWS_ID, IDM_VIEWSMENU);
2009	if (!fLVM)
2010	WinSendMsg(TreeCnrMenu, MM_DELETEITEM,
2011	MPFROM2SHORT(IDM_REFRESHREMOVABLES, TRUE), MPVOID);
2012	}
2013	else if (hwndMenu == &ArcCnrMenu) {
2014	WinSetWindowUShort(ArcCnrMenu, QWS_ID, IDM_VIEWSMENU);
2015	SetConditionalCascade(ArcCnrMenu, IDM_EXTRACTSUBMENU, IDM_ARCEXTRACT);
2016	if (fWorkPlace)
2017	WinSendMsg(ArcCnrMenu, MM_DELETEITEM,
2018	MPFROM2SHORT(IDM_FOLDERAFTEREXTRACT, TRUE), MPVOID);
2019	}
2020	else if (hwndMenu == &CollectorCnrMenu) {
2021	WinSetWindowUShort(CollectorCnrMenu, QWS_ID, IDM_VIEWSMENU);
2022	SetConditionalCascade(CollectorCnrMenu, IDM_COLLECTMENU,
2023	IDM_COLLECTFROMCLIP);
2024	}
2025	else if (hwndMenu == &CollectorFileMenu) {
2026	WinSetWindowUShort(CollectorFileMenu, QWS_ID, IDM_FILESMENU);
2027	SetConditionalCascade(CollectorFileMenu, IDM_COMMANDSMENU,
2028	IDM_DOITYOURSELF);
2029	SetConditionalCascade(CollectorFileMenu, IDM_COPYMENU, IDM_COPY);
2030	SetConditionalCascade(CollectorFileMenu, IDM_MOVEMENU, IDM_MOVE);
2031	SetConditionalCascade(CollectorFileMenu, IDM_SAVESUBMENU,
2032	IDM_SAVETOCLIP);
2033	SetConditionalCascade(CollectorFileMenu, IDM_VIEWSUBMENU, IDM_VIEW);
2034	SetConditionalCascade(CollectorFileMenu, IDM_EDITSUBMENU, IDM_EDIT);
2035	SetConditionalCascade(CollectorFileMenu, IDM_DELETESUBMENU,
2036	fDefaultDeletePerm ? IDM_PERMDELETE : IDM_DELETE);
2037	SetConditionalCascade(CollectorFileMenu, IDM_OPENSUBMENU,
2038	IDM_OPENDEFAULT);
2039	SetConditionalCascade(CollectorFileMenu, IDM_OPENSUBCNRMENU,
2040	IDM_OPENWINDOW);
2041	SetConditionalCascade(CollectorFileMenu, IDM_OBJECTSUBMENU, IDM_SHADOW);
2042	if (fWorkPlace) {
2043	WinSendMsg(CollectorFileMenu, MM_DELETEITEM,
2044	MPFROM2SHORT(IDM_OPENSUBMENU, TRUE), MPVOID);
2045	WinSendMsg(CollectorFileMenu, MM_DELETEITEM,
2046	MPFROM2SHORT(IDM_OBJECTSUBMENU, TRUE), MPVOID);
2047	}
2048	}
2049	else if (hwndMenu == &CollectorDirMenu) {
2050	WinSetWindowUShort(CollectorDirMenu, QWS_ID, IDM_FILESMENU);
2051	SetConditionalCascade(CollectorDirMenu, IDM_COMMANDSMENU,
2052	IDM_DOITYOURSELF);
2053	SetConditionalCascade(CollectorDirMenu, IDM_COPYMENU, IDM_COPY);
2054	SetConditionalCascade(CollectorDirMenu, IDM_MOVEMENU, IDM_MOVE);
2055	SetConditionalCascade(CollectorDirMenu, IDM_SAVESUBMENU,
2056	IDM_SAVETOCLIP);
2057	SetConditionalCascade(CollectorDirMenu, IDM_VIEWSUBMENU, IDM_INFO);
2058	SetConditionalCascade(CollectorDirMenu, IDM_EDITSUBMENU, IDM_ATTRS);
2059	SetConditionalCascade(CollectorDirMenu, IDM_DELETESUBMENU,
2060	fDefaultDeletePerm ? IDM_PERMDELETE : IDM_DELETE);
2061	SetConditionalCascade(CollectorDirMenu, IDM_MISCSUBMENU, IDM_SIZES);
2062	SetConditionalCascade(CollectorDirMenu, IDM_OPENSUBMENU,
2063	IDM_OPENWINDOW);
2064	if (fWorkPlace) {
2065	WinSendMsg(CollectorDirMenu, MM_DELETEITEM,
2066	MPFROM2SHORT(IDM_OPENSUBMENU, TRUE), MPVOID);
2067	WinSendMsg(CollectorDirMenu, MM_DELETEITEM,
2068	MPFROM2SHORT(IDM_OBJECTSUBMENU, TRUE), MPVOID);
2069	}
2070	}
2071	else if (hwndMenu == &MainPopupMenu) {
2072	WinSetWindowUShort(MainPopupMenu, QWS_ID, IDM_MAINPOPUP);
2073	SetConditionalCascade(MainPopupMenu, IDM_TOOLSUBMENU, IDM_TOOLBAR);
2074	SetConditionalCascade(MainPopupMenu, IDM_AUTOVIEWSUBMENU, IDM_AUTOVIEW);
2075	}
2076	}
2077	CopyPresParams(*hwndMenu, hwnd);
2078	return *hwndMenu;
2079	}
2080
2081	SHORT AddToListboxBottom(HWND hwnd, PCSZ str)
2082	{
2083	SHORT ln;
2084
2085	ln = (SHORT) WinSendMsg(hwnd, LM_INSERTITEM, MPFROM2SHORT(LIT_END, 0),
2086	MPFROMP(str));
2087	if (ln)
2088	WinSendMsg(hwnd, LM_SELECTITEM, MPFROM2SHORT(ln, 0), MPVOID);
2089	return ln;
2090	}
2091
2092	VOID SetSysMenu(HWND hwndSysMenu)
2093	{
2094	CHAR s[128], *p;
2095
2096	if (WinSendMsg(hwndSysMenu, MM_QUERYITEMTEXT,
2097	MPFROM2SHORT(SC_RESTORE, 128), MPFROMP(s))) {
2098	p = strchr(s, '\t');
2099	if (p) {
2100	p++;
2101	strcpy(p, "Ctrl+Alt+F5");
2102	WinSetMenuItemText(hwndSysMenu, SC_RESTORE, s);
2103	}
2104	}
2105	if (WinSendMsg(hwndSysMenu, MM_QUERYITEMTEXT,
2106	MPFROM2SHORT(SC_CLOSE, 128), MPFROMP(s))) {
2107	p = strchr(s, '\t');
2108	if (p) {
2109	p++;
2110	strcpy(p, "Ctrl+Alt+F4");
2111	WinSetMenuItemText(hwndSysMenu, SC_CLOSE, s);
2112	}
2113	}
2114	if (WinSendMsg(hwndSysMenu, MM_QUERYITEMTEXT,
2115	MPFROM2SHORT(SC_MOVE, 128), MPFROMP(s))) {
2116	p = strchr(s, '\t');
2117	if (p) {
2118	p++;
2119	strcpy(p, "Ctrl+Alt+F7");
2120	WinSetMenuItemText(hwndSysMenu, SC_MOVE, s);
2121	}
2122	}
2123	if (WinSendMsg(hwndSysMenu, MM_QUERYITEMTEXT,
2124	MPFROM2SHORT(SC_SIZE, 128), MPFROMP(s))) {
2125	p = strchr(s, '\t');
2126	if (p) {
2127	p++;
2128	strcpy(p, "Ctrl+Alt+F8");
2129	WinSetMenuItemText(hwndSysMenu, SC_SIZE, s);
2130	}
2131	}
2132	if (WinSendMsg(hwndSysMenu, MM_QUERYITEMTEXT,
2133	MPFROM2SHORT(SC_MINIMIZE, 128), MPFROMP(s))) {
2134	p = strchr(s, '\t');
2135	if (p) {
2136	p++;
2137	strcpy(p, "Ctrl+Alt+F9");
2138	WinSetMenuItemText(hwndSysMenu, SC_MINIMIZE, s);
2139	}
2140	}
2141	if (WinSendMsg(hwndSysMenu,
2142	MM_QUERYITEMTEXT,
2143	MPFROM2SHORT(SC_MAXIMIZE, 128), MPFROMP(s))) {
2144	p = strchr(s, '\t');
2145	if (p) {
2146	p++;
2147	strcpy(p, "Ctrl+Alt+F10");
2148	WinSetMenuItemText(hwndSysMenu, SC_MAXIMIZE, s);
2149	}
2150	}
2151	if (WinSendMsg(hwndSysMenu,
2152	MM_QUERYITEMTEXT, MPFROM2SHORT(SC_HIDE, 128), MPFROMP(s))) {
2153	p = strchr(s, '\t');
2154	if (p) {
2155	p++;
2156	strcpy(p, "Ctrl+Alt+F11");
2157	WinSetMenuItemText(hwndSysMenu, SC_HIDE, s);
2158	}
2159	}
2160	}
2161
2162	VOID LoadLibPath(PSZ str, LONG len)
2163	{
2164	ULONG ver[2];
2165	CHAR configsys[] = "C:\\CONFIG.SYS";
2166	static CHAR var[8192], beg[16384], end[16384];
2167	BOOL warp = FALSE;
2168	FILE *fp;
2169	PFN DQELIBPATH = NULL;
2170	HMODULE hmod;
2171	CHAR *moder = "r";
2172
2173	if (str && len) {
2174	*str = 0;
2175	if (DosQuerySysInfo(QSV_BOOT_DRIVE,
2176	QSV_BOOT_DRIVE, (PVOID) ver, (ULONG) sizeof(ULONG)))
2177	ver[0] = 3L;
2178	*configsys = (CHAR) ver[0] + '@';
2179	if (!DosQuerySysInfo(QSV_VERSION_MAJOR,
2180	QSV_VERSION_MINOR,
2181	(PVOID) ver, (ULONG) sizeof(ver)) && ver[1] >= 30)
2182	warp = TRUE;
2183	var = beg = *end = 0;
2184	if (warp) {
2185	if (!DosLoadModule(var, sizeof(var), "DOSCALL1.DLL", &hmod)) {
2186	if (!DosQueryProcAddr(hmod,
2187	ORD_DOS32QUERYEXTLIBPATH,
2188	NULL, (PFN *) &DQELIBPATH)) {
2189	DQELIBPATH(beg, BEGIN_LIBPATH);
2190	DQELIBPATH(end, END_LIBPATH);
2191	}
2192	DosFreeModule(hmod);
2193	}
2194	*var = 0;
2195	}
2196	fp = xfopen(configsys, moder, pszSrcFile, __LINE__, FALSE);
2197	if (fp) {
2198	while (!feof(fp)) {
2199	if (!xfgets_bstripcr(var, sizeof(var), fp, pszSrcFile, __LINE__))
2200	break;
2201	if (!strnicmp(var, "LIBPATH=", 8)) {
2202	memmove(var, var + 8, strlen(var + 8) + 1);
2203	lstrip(var);
2204	break;
2205	}
2206	}
2207	fclose(fp);
2208	}
2209	strncpy(str, beg, len);
2210	strncat(str, var, len - strlen(str));
2211	strncat(str, end, len - strlen(str));
2212	str[len - 1] = 0;
2213	}
2214	}
2215
2216	void SetViewMenu(HWND hwndMenu, ULONG flWindowAttr)
2217	{
2218	WinCheckMenuItem(hwndMenu, IDM_MINIICONS, ((flWindowAttr & CV_MINI)));
2219	WinCheckMenuItem(hwndMenu, IDM_TEXT, ((flWindowAttr & CV_TEXT)));
2220	WinCheckMenuItem(hwndMenu, IDM_ICON, ((flWindowAttr & CV_ICON) &&
2221	!(flWindowAttr & CV_TREE)));
2222	WinCheckMenuItem(hwndMenu, IDM_TREEVIEW, ((flWindowAttr & CV_TREE)));
2223	WinCheckMenuItem(hwndMenu, IDM_DETAILS, ((flWindowAttr & CV_DETAIL)));
2224	WinCheckMenuItem(hwndMenu, IDM_NAME, ((flWindowAttr & CV_NAME)));
2225	}
2226
2227	void SaySort(HWND hwnd, INT sortflags, BOOL archive)
2228	{
2229	char *s = NULL;
2230
2231	s = xmalloc(CCHMAXPATH, pszSrcFile, __LINE__);
2232	if (s) {
2233	sprintf(s, "S:%s%s",
2234	sortflags & SORT_REVERSE ? "^" : NullStr,
2235	(sortflags & SORT_FIRSTEXTENSION) ?
2236	GetPString(IDS_FIRSTX) : (sortflags & SORT_LASTEXTENSION) ?
2237	GetPString(IDS_LASTX) : (sortflags & SORT_SIZE) ?
2238	"Size" : (sortflags & SORT_EASIZE) ?
2239	(archive == 0) ?
2240	GetPString(IDS_EASIZE) : GetPString(IDS_CSIZE) :
2241	(sortflags & SORT_LWDATE) ?
2242	(archive == 0) ?
2243	GetPString(IDS_LWDATE) : GetPString(IDS_DATE) :
2244	(sortflags & SORT_LADATE) ?
2245	GetPString(IDS_LADATE) : (sortflags & SORT_CRDATE) ?
2246	GetPString(IDS_CRDATE) :
2247	(sortflags & SORT_PATHNAME) ?
2248	GetPString(IDS_PATH) : (sortflags & SORT_NOSORT) ?
2249	GetPString(IDS_NONE) : (sortflags & SORT_SUBJECT) ?
2250	GetPString(IDS_SUBJ) : GetPString(IDS_NAME));
2251	WinSetWindowText(hwnd, s);
2252	free(s);
2253	}
2254	}
2255
2256	void SayView(HWND hwnd, ULONG flWindowAttr)
2257	{
2258	char *s = NULL;
2259
2260	s = xmalloc(CCHMAXPATH, pszSrcFile, __LINE__);
2261	if (s) {
2262	sprintf(s, "V:%s%s",
2263	(flWindowAttr & CV_TREE) ? GetPString(IDS_TREE) :
2264	(flWindowAttr & CV_NAME) ? GetPString(IDS_NAME) :
2265	(flWindowAttr & CV_DETAIL) ? GetPString(IDS_DETAIL) :
2266	(flWindowAttr & CV_TEXT) ? GetPString(IDS_TEXT) :
2267	GetPString(IDS_ICON),
2268	((flWindowAttr & CV_MINI) &&
2269	!(flWindowAttr & CV_TEXT)) ? GetPString(IDS_MINI) : NullStr);
2270	WinSetWindowText(hwnd, s);
2271	free(s);
2272	}
2273	}
2274
2275	void SayFilter(HWND hwnd, MASK * mask, BOOL archive)
2276	{
2277	char *s = NULL;
2278
2279	s = xmalloc(CCHMAXPATH * 2, pszSrcFile, __LINE__);
2280	if (s) {
2281	sprintf(s, "F:%s%s%s",
2282	mask->szMask,
2283	(!archive && (mask->attrFile != ALLATTRS \|\|
2284	mask->antiattr != 0)) ? " " : NullStr,
2285	(!archive && (mask->attrFile != ALLATTRS \|\|
2286	mask->antiattr !=
2287	0)) ? GetPString(IDS_ATTRTEXT) : NullStr);
2288	if (!s[2])
2289	sprintf(s, "F:%s", GetPString(IDS_ALLTEXT));
2290	WinSetWindowText(hwnd, s);
2291	free(s);
2292	}
2293	}
2294
2295	char *GetCmdSpec(BOOL dos)
2296	{
2297	char *cmspec;
2298
2299	if (!dos) {
2300	cmspec = getenv("OS2_SHELL");
2301	if (!cmspec)
2302	cmspec = getenv("COMSPEC");
2303	if (!cmspec)
2304	cmspec = "CMD.EXE";
2305	}
2306	else {
2307	cmspec = getenv("DOS_SHELL");
2308	if (!cmspec)
2309	cmspec = "COMMAND.COM";
2310	}
2311	return cmspec;
2312	}
2313
2314	void Broadcast(HAB hab, HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
2315	{
2316	if (hwndMain)
2317	WinBroadcastMsg(hwndMain, msg, mp1, mp2, BMSG_SEND \| BMSG_FRAMEONLY);
2318	if (hwnd &&
2319	hwnd != HWND_DESKTOP &&
2320	hwnd != hwndMain &&
2321	hwnd != WinQueryDesktopWindow(hab, NULLHANDLE) &&
2322	WinIsWindow(hab, hwnd) && (!hwndMain \|\| !WinIsChild(hwnd, hwndMain)))
2323	WinSendMsg(hwnd, msg, mp1, mp2);
2324	}
2325
2326	void SetupWinList(HWND hwndMenu, HWND hwndTop, HWND hwndFrame)
2327	{
2328	/**
2329	* add switchlist entries to end of pulldown menu
2330	*/
2331
2332	SHORT sItemCount, x = 0, y = 0;
2333	MENUITEM mi;
2334
2335	sItemCount = (SHORT) WinSendMsg(hwndMenu,
2336	MM_QUERYITEMCOUNT, MPVOID, MPVOID);
2337
2338	// clean out old additions
2339	while ((SHORT) WinSendMsg(hwndMenu,
2340	MM_DELETEITEM,
2341	MPFROM2SHORT(IDM_SWITCHSTART + x++,
2342	TRUE), MPVOID) < sItemCount)
2343	sItemCount--;
2344	x = 0;
2345	while ((SHORT) WinSendMsg(hwndMenu,
2346	MM_DELETEITEM,
2347	MPFROM2SHORT(IDM_WINDOWSTART + x++,
2348	TRUE), MPVOID) < sItemCount)
2349	sItemCount--;
2350
2351	x = 0;
2352	if (hwndTop) {
2353
2354	char wtext[CCHMAXPATH + 8];
2355	HENUM henum;
2356	HWND hwndChild;
2357
2358	// add children of the main FM/2 client
2359	henum = WinBeginEnumWindows(hwndTop);
2360	memset(&mi, 0, sizeof(mi));
2361	while ((hwndChild = WinGetNextWindow(henum)) != NULLHANDLE) {
2362	if (WinQueryWindowUShort(hwndChild, QWS_ID) && hwndChild != hwndFrame) {
2363	*wtext = 0;
2364	WinQueryWindowText(hwndChild, CCHMAXPATH + 8, wtext);
2365	if (*wtext) {
2366	wtext[CCHMAXPATH + 7] = 0;
2367	mi.afStyle = MIS_TEXT;
2368	if (!((x + sItemCount) % 28))
2369	mi.afStyle \|= MIS_BREAK;
2370	mi.id = IDM_WINDOWSTART + x;
2371	mi.iPosition = MIT_END;
2372	if ((SHORT) WinSendMsg(hwndMenu,
2373	MM_INSERTITEM,
2374	MPFROMP(&mi), MPFROMP(wtext)) >= 0)
2375	x++;
2376	}
2377	}
2378	}
2379	WinEndEnumWindows(henum);
2380	}
2381
2382	// add external FM/2 windows
2383	{
2384	PSWBLOCK pswb;
2385	ULONG ulSize, ulcEntries;
2386	HWND hwndTopFrame;
2387	register INT i;
2388
2389	hwndTopFrame = hwndTop ? WinQueryWindow(hwndTop, QW_PARENT) : (HWND)0;
2390	// Get the switch list information
2391	x = 0;
2392	ulcEntries = WinQuerySwitchList(0, NULL, 0);
2393	ulSize = sizeof(SWBLOCK) + sizeof(HSWITCH) + (ulcEntries + 4L) *
2394	(LONG) sizeof(SWENTRY);
2395	// Allocate memory for list
2396	pswb = xmalloc(ulSize, pszSrcFile, __LINE__);
2397	if (pswb) {
2398	// Put the info in the list
2399	ulcEntries = WinQuerySwitchList(0, pswb, ulSize - sizeof(SWENTRY));
2400	// do the dirty deed
2401	memset(&mi, 0, sizeof(mi));
2402	for (i = 0; i < pswb->cswentry; i++) {
2403	if (pswb->aswentry[i].swctl.uchVisibility == SWL_VISIBLE &&
2404	pswb->aswentry[i].swctl.fbJump == SWL_JUMPABLE &&
2405	(pswb->aswentry[i].swctl.idProcess != mypid \|\|
2406	!hwndFrame \|\|
2407	pswb->aswentry[i].swctl.hwnd != hwndFrame) &&
2408	(pswb->aswentry[i].swctl.idProcess != mypid \|\|
2409	!hwndTopFrame \|\|
2410	pswb->aswentry[i].swctl.hwnd != hwndTopFrame \|\|
2411	!WinIsChild(hwndFrame, hwndTop))) {
2412	if (!strnicmp(pswb->aswentry[i].swctl.szSwtitle, "AV/2", 4)
2413	\|\| !stricmp(pswb->aswentry[i].swctl.szSwtitle, "File Manager/2")
2414	\|\| !stricmp(pswb->aswentry[i].swctl.szSwtitle, PCSZ_COLLECTOR)
2415	\|\| !strnicmp(pswb->aswentry[i].swctl.szSwtitle, "VTree", 5)
2416	\|\| !strnicmp(pswb->aswentry[i].swctl.szSwtitle, "VDir", 4)
2417	\|\| !strnicmp(pswb->aswentry[i].swctl.szSwtitle, FM2Str, 4)) {
2418	mi.afStyle = MIS_TEXT;
2419	if (x && !(x % 28))
2420	mi.afStyle \|= MIS_BREAK;
2421	mi.id = IDM_SWITCHSTART + y;
2422	mi.iPosition = MIT_END;
2423	switches[y] = pswb->aswentry[i].hswitch;
2424	if ((SHORT) WinSendMsg(hwndMenu,
2425	MM_INSERTITEM,
2426	MPFROMP(&mi),
2427	MPFROMP(pswb->aswentry[i].
2428	swctl.szSwtitle)) >= 0) {
2429	y++;
2430	x++;
2431	}
2432	}
2433	}
2434	}
2435	numswitches = y;
2436	free(pswb);
2437	DosPostEventSem(CompactSem);
2438	}
2439	}
2440	}
2441
2442	BOOL SwitchCommand(HWND hwndMenu, USHORT cmd)
2443	{
2444	BOOL ret = FALSE;
2445
2446	if (hwndMain && hwndMenu && cmd >= IDM_WINDOWSTART && cmd < IDM_SWITCHSTART) {
2447	// select a child window (of client)
2448
2449	MENUITEM mi;
2450	HWND hwndSubMenu = (HWND) 0, hwndChild;
2451	CHAR s[CCHMAXPATH + 8];
2452
2453	if (WinQueryWindowUShort(hwndMenu, QWS_ID) != IDM_WINDOWSMENU) {
2454	memset(&mi, 0, sizeof(mi));
2455	mi.iPosition = MIT_END;
2456	mi.afStyle = MIS_TEXT;
2457	if (WinSendMsg(hwndMenu,
2458	MM_QUERYITEM,
2459	MPFROM2SHORT(IDM_WINDOWSMENU, TRUE), MPFROMP(&mi)))
2460	hwndSubMenu = mi.hwndSubMenu;
2461	}
2462	else
2463	hwndSubMenu = hwndMenu;
2464	if (hwndSubMenu) {
2465	*s = 0;
2466	if (WinSendMsg(hwndSubMenu,
2467	MM_QUERYITEMTEXT,
2468	MPFROM2SHORT(cmd, CCHMAXPATH + 8), MPFROMP(s)) && *s) {
2469
2470	HENUM henum;
2471	CHAR checkText[CCHMAXPATH + 8];
2472	SWP swp;
2473
2474	s[CCHMAXPATH + 7] = 0;
2475	henum = WinBeginEnumWindows(hwndMain);
2476	while ((hwndChild = WinGetNextWindow(henum)) != NULLHANDLE) {
2477	if (WinQueryWindowUShort(hwndChild, QWS_ID)) {
2478	*checkText = 0;
2479	WinQueryWindowText(hwndChild, CCHMAXPATH + 8, checkText);
2480	checkText[CCHMAXPATH + 7] = 0;
2481	if (!stricmp(checkText, s)) {
2482	if (WinQueryWindowPos(hwndChild, &swp)) {
2483	if (swp.fl & (SWP_MINIMIZE \| SWP_HIDE))
2484	WinSetWindowPos(hwndChild,
2485	HWND_TOP,
2486	0, 0, 0, 0, SWP_RESTORE \| SWP_ZORDER);
2487	}
2488	WinSetActiveWindow(HWND_DESKTOP, hwndChild);
2489	ret = TRUE;
2490	break;
2491	}
2492	}
2493	}
2494	WinEndEnumWindows(henum);
2495	}
2496	}
2497	}
2498	else if (cmd >= IDM_SWITCHSTART && cmd < IDM_SWITCHSTART + 499) {
2499	if (cmd - IDM_SWITCHSTART < numswitches) {
2500	WinSwitchToProgram(switches[cmd - IDM_SWITCHSTART]);
2501	ret = TRUE;
2502	}
2503	}
2504
2505	return ret;
2506	}
2507
2508	/** CheckDriveSpaceAvail
2509	* Take space needed and checks that drive has at least 1000 bits in excess of the required space.
2510	* Returns 0 if sufficient space is available; 1 if the drive is full & 2 on abort of operation
2511	* when the drive would have less than ullFreeSpaceWhenComplete remaining or has insufficient space.
2512	*/
2513
2514	INT CheckDriveSpaceAvail(PCSZ pTargetPath, ULONGLONG ullSpaceNeeded,
2515	ULONGLONG ullFreeSpaceWhenComplete)
2516	{
2517	FSALLOCATE fsa;
2518	ULONGLONG ullFreeQty;
2519	APIRET ret;
2520
2521	DosQueryFSInfo(toupper(*pTargetPath) - 'A' + 1, FSIL_ALLOC, &fsa, sizeof(FSALLOCATE));
2522	ullFreeQty = (ULONGLONG) fsa.cUnitAvail * (fsa.cSectorUnit * fsa.cbSector);
2523	if (ullFreeQty > ullSpaceNeeded + ullFreeSpaceWhenComplete)
2524	return 0;
2525	else if (ullFreeQty < ullSpaceNeeded + 1024) {
2526	CHAR szKB[20];
2527
2528	CommaFmtULL(szKB, sizeof(szKB),
2529	ullFreeQty - ullSpaceNeeded, ' ');
2530	if (ullFreeSpaceWhenComplete == 0) {
2531	saymsg(MB_OK,
2532	HWND_DESKTOP,
2533	NullStr,
2534	GetPString(IDS_DRIVESPACELIMITEDTMPSAVE),
2535	pTargetPath);
2536	return 0;
2537	}
2538	else {
2539	if (ullFreeQty > ullSpaceNeeded) {
2540	ret = saymsg(MB_YESNO,
2541	HWND_DESKTOP,
2542	NullStr,
2543	GetPString(IDS_DRIVESPACELIMITED),
2544	pTargetPath,
2545	szKB);
2546	if (ret == MBID_YES)
2547	return 0;
2548	else
2549	return 2;
2550	}
2551	else {
2552	saymsg(MB_OK,
2553	HWND_DESKTOP,
2554	NullStr,
2555	GetPString(IDS_DRIVESPACEEXCEEDED),
2556	pTargetPath);
2557	return 2;
2558	}
2559	}
2560	}
2561	else
2562	return 1;
2563	}
2564
2565	#pragma alloc_text(MAINWND5,SetSysMenu)
2566	#pragma alloc_text(MISC1,BoxWindow,PaintRecessedWindow,PostMsg,PaintSTextWindow,IsFm2Window)
2567	#pragma alloc_text(MISC1,FixSwitchList,FindDirCnr,CurrentRecord,SetShiftState,AddToListboxBottom)
2568	#pragma alloc_text(MISC1,CheckDriveSpaceAvail)
2569
2570	#ifdef FORTIFY
2571	#pragma alloc_text(MISC1,GetTidForWindow)
2572	#endif // FORTIFY
2573
2574	#pragma alloc_text(CNR_MISC1,AdjustCnrColVis,AdjustCnrColsForFSType)
2575	#pragma alloc_text(CNR_MISC1,AdjustCnrColsForPref,SetCnrCols)
2576	#pragma alloc_text(CNR_MISC2,CnrDirectEdit,OpenEdit)
2577	#pragma alloc_text(MISC2,SetMenuCheck,disable_menuitem,SetSortChecks)
2578	#pragma alloc_text(MISC2,SetDetailsSwitches,SetViewMenu)
2579	#pragma alloc_text(MISC3,SetupCommandMenu,AdjustDetailsSwitches)
2580	#pragma alloc_text(MISC3,ViewHelp,GetCmdSpec)
2581	#pragma alloc_text(MISC3,ExecFile,SetConditionalCascade,LoadDetailsSwitches,WriteDetailsSwitches)
2582	#pragma alloc_text(MISC4,PortholeInit,CheckMenu,Broadcast,SetupWinList,SwitchCommand)
2583	#pragma alloc_text(MISC6,DrawTargetEmphasis,EmphasizeButton)
2584	#pragma alloc_text(MISC_LIBPATH,LoadLibPath)
2585	#pragma alloc_text(MISC_SAY,SayView,SaySort,SayFilter)
2586

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

Download in other formats: