Context Navigation

source: trunk/dll/arccnrs.c@ 1689

Visit:

Last change on this file since 1689 was 1689, checked in by Gregg Young, 12 years ago
Changes to get 7z archives to work with AV. Includes an ugly hack to compensate for the fact that the compressed size is missing from some files in some archives. This results in the filename being put in the nsize variable which then must be passed to fname. Fortunately it displays compressed size as 0 since it can't deal with the non numeric text string. A file name that is all numeric will show odd results. Ticket 492
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 105.9 KB

Line
1
2	/***********************************************************************
3
4	$Id: arccnrs.c 1689 2013-07-30 23:22:48Z gyoung $
5
6	Archive containers
7
8	Copyright (c) 1993-98 M. Kimes
9	Copyright (c) 2001, 2013 Steven H. Levine
10
11	11 Jun 02 SHL Ensure archive name not garbage
12	22 May 03 SHL ArcObjWndProc: fix UM_RESCAN now that we understand it
13	01 Aug 04 SHL Rework lstrip/rstrip usage
14	23 May 05 SHL Use QWL_USER
15	25 May 05 SHL Rename comnam to szCommonName and fix typo
16	25 May 05 SHL Use ULONGLONG and CommaFmtULL
17	05 Jun 05 SHL Drop obsolete, localize
18	05 Jun 05 SHL Correct last sort logic
19	05 Jun 05 SHL Use QWL_USER
20	22 Jun 05 SHL ArcSort: correct typo in last sort fix
21	13 Aug 05 SHL FillArcCnr: optimize
22	08 Dec 05 SHL FillArcCnr: allow list start and end markers to be empty (i.e. tar)
23	08 Dec 05 SHL ArcCnrWndProc: suppress IDM_EXTRACT if no simple extract (i.e. tar)
24	30 Dec 05 SHL ArcCnrWndProc: correct date/time column display setup
25	29 May 06 SHL Comments
26	14 Jul 06 SHL Use Runtime_Error
27	26 Jul 06 SHL Correct SelectAll usage
28	29 Jul 06 SHL Use xfgets_bstripcr
29	31 Jul 06 SHL Lower priority for archives with more than 1000 entries
30	02 Aug 06 SHL Add logic to stop processing large archives
31	23 Aug 06 SHL Integrate John Small's switch list title logic
32	03 Nov 06 SHL Renames
33	14 Mar 07 SHL ArcObjWndProc/UM_ENTER: delay before starting viewer
34	30 Mar 07 GKY Remove GetPString for window class names
35	06 Apr 07 GKY Work around PM DragInfo and DrgFreeISH limit
36	06 Apr 07 GKY Add some error checking in drag/drop
37	20 Apr 07 SHL Sync with NumItemsToUnhilite mods
38	21 Apr 07 GKY Find FM2Utils by path or utils directory
39	12 May 07 SHL Use dcd->ulItemsToUnHilite; sync with UnHilite arg mods
40	10 Jun 07 GKY Add CheckPmDrgLimit including IsFm2Window as part of work around PM drag limit
41	16 Jun 07 SHL Use DosQueryAppType not DosQAppType
42	02 Aug 07 SHL Sync with ARCITEM mods
43	06 Aug 07 SHL Use BldFullPathName and BldQuotedFileName
44	06 Aug 07 SHL Move BldQuotedFileName and BldQuotedFullPathNamehere
45	to be near primary caller
46	06 Aug 07 GKY Reduce DosSleep times (ticket 148)
47	20 Aug 07 GKY Move #pragma alloc_text to end for OpenWatcom compat
48	26 Aug 07 GKY DosSleep(1) in loops changed to (0)
49	22 Nov 07 GKY Use CopyPresParams to fix presparam inconsistencies in menus
50	30 Dec 07 GKY Use TestCDates for sort by date
51	10 Jan 08 SHL Sync with CfgDlgProc mods
52	10 Feb 08 GKY Implement bubble help for bitmap menu items
53	15 Feb 08 SHL Sync with settings menu rework
54	29 Feb 08 GKY Use xfree where appropriate
55	14 Jul 08 JBS Ticket 126: Add support for WPS open default & open settings in arccnrs
56	16 Jul 08 GKY Fix trap on viewing multiple files from an archive (misplaced free)
57	16 Jul 08 GKY Use TMP directory for temp files if present. Use MakeTempName
58	19 Jul 08 GKY Replace save_dir2(dir) with pFM2SaveDirectory
59	25 Aug 08 GKY Check TMP directory space warn if lee than 5 MiB prevent archiver from opening if
60	less than 10 KiB (It hangs and can't be closed)
61	08 Nov 08 GKY Add WaitChildThread to fix hang caused by viewer trying to open a file before
62	the archiver process closes. (Ticket 58)
63	23 Nov 08 JBS Ticket 284: Support archivers with no Start or End of list strings
64	29 Nov 08 GKY Add flag to tell CheckListProc file is in an archive so it won't try to open it.
65	29 Nov 08 GKY Remove or replace with a mutex semaphore DosEnterCriSec where appropriate.
66	30 Nov 08 GKY Add the option of creating a subdirectory from the arcname
67	for the extract path to arc container.
68	02 Dec 08 JBS Ticket 284: Changed string indicating no Start/End of list strings.
69	03 Dec 08 GKY Subdirectory from the arcname for the extract path only created if an "extract"
70	menu option is selected.
71	10 Dec 08 SHL Integrate exception handler support
72	07 Feb 09 GKY Eliminate Win_Error2 by moving function names to PCSZs used in Win_Error
73	07 Feb 09 GKY Allow user to turn off alert and/or error beeps in settings notebook.
74	08 Mar 09 GKY Renamed commafmt.h i18nutil.h
75	08 Mar 09 GKY Additional strings move to PCSZs in init.c
76	08 Mar 09 GKY Removed variable aurguments from docopyf and unlinkf (not used)
77	12 Mar 09 SHL Use common SearchContainer
78	13 Dec 09 GKY Fixed separate paramenters. Please note that appname should be used in
79	profile calls for user settings that work and are setable in more than one
80	miniapp; FM3Str should be used for setting only relavent to FM/2 or that
81	aren't user settable; realappname should be used for setting applicable to
82	one or more miniapp but not to FM/2
83	17 Jan 10 GKY Changes to get working with Watcom 1.9 Beta (1/16/10). Mostly cast CHAR CONSTANT * as CHAR *.
84	15 Apr 10 JBS Ticket 422: Stop hang when open archive gets deleted or moved
85	23 Oct 10 GKY Add ForwardslashToBackslash function to streamline code
86	20 Nov 10 GKY Check that pTmpDir IsValid and recreate if not found; Fixes hangs caused
87	by temp file creation failures.
88	13 Aug 11 GKY Change to Doxygen comment format
89	30 Jul 13 GKY Changes to allow 7z archiver to work with AV.
90
91	***********************************************************************/
92
93	#include <stdlib.h> // free..
94	#include <string.h>
95	#include <ctype.h>
96	#include <direct.h> // rmdir
97	#include <share.h> // SH_DENYWR
98	#include <limits.h> // ULONG_MAX
99
100	#if 0
101	#include <malloc.h> // _heapchk
102	#endif
103
104	#define INCL_DOS
105	#define INCL_DOSERRORS
106	#define INCL_WIN
107	#define INCL_LONGLONG
108
109	#include "fm3dll.h"
110	#include "fm3dll2.h" // #define's for UM_*, control id's, etc.
111	#include "arccnrs.h"
112	#include "makelist.h" // Typedef
113	#include "colors.h" // Typedef
114	#include "mainwnd2.h" // Data declaration(s)
115	#include "grep.h" // Data declaration(s)
116	#include "dircnrs.h" // Data declaration(s)
117	#include "info.h" // Data declaration(s)
118	#include "init.h" // Data declaration(s)
119	#include "fm3dlg.h"
120	#include "fm3str.h"
121	#include "mle.h"
122	#include "pathutil.h" // BldFullPathName
123	#include "filldir.h" // EmptyCnr...
124	#include "errutil.h" // Dos_Error...
125	#include "strutil.h" // GetPString
126	#include "notebook.h" // CfgDlgProc
127	#include "worker.h" // Action, MassAction
128	#include "avv.h" // ArcReviewDlgProc, rewrite_archiverbb2
129	#include "chklist.h" // CenterOverWindow, CheckListProc
130	#include "common.h" // CommonCreateTextChildren, CommonFrameWndProc, CommonTextPaint
131	// CommonTextButton
132	#include "draglist.h" // DoFileDrag, DragOne
133	#include "valid.h" // GetDesktopName, TestCDates
134	#include "mainwnd.h" // GetNextWindowPos, MakeBubble, TopWindowName
135	#include "objwin.h" // MakeObjWin
136	#include "shadow.h" // MakeShadows
137	#include "objcnr.h" // ObjCnrDlgProc
138	#include "printer.h" // PrintListThread
139	#include "srchpath.h" // RunFM2Util
140	#include "misc.h" // Broadcast, CheckMenu, CurrentRecord, SayFilter, SaySort
141	// DrawTargetEmphasis, IsFm2Window
142	#include "select.h" // SelectAll, SelectList
143	#include "findrec.h" // ShowCnrRecord
144	#include "walkem.h" // WalkExtractDlgProc
145	#include "droplist.h" // AcceptOneDrop, CheckPmDrgLimit, DropHelp, GetOneDrop
146	#include "archive.h" // ArchiveDlgProc
147	#include "common.h" // CommonTextProc
148	#include "presparm.h" // CopyPresParams
149	#include "defview.h" // DefaultViewKeys
150	#include "systemf.h" // ExecOnList
151	#include "filter.h" // PickMaskDlgProc
152	#include "avl.h" // SBoxDlgProc
153	#include "mkdir.h" // SetDir
154	#include "collect.h" // StartCollector
155	#include "viewer.h" // StartMLEEditor
156	#include "newview.h" // StartViewer
157	#include "i18nutil.h" // commafmt
158	#include "copyf.h" // unlinkf
159	#include "literal.h" // wildcard
160	#include "wrappers.h" // xrealloc
161	#include "misc.h" // AdjustCnrColVis, QuickPopup, SetSortChecks, SwitchCommand
162	#include "select.h" // DeselectAll, InvertAll
163	#include "strips.h" // bstrip
164	#include "dirs.h" // save_dir2
165	#include "fortify.h"
166	#include "excputil.h" // 06 May 08 SHL added
167
168	#define ARCFLAGS_REALDIR 0x00000001
169	#define ARCFLAGS_PSEUDODIR 0x00000002
170	#define CON_COLS 6
171	#define EXTRA_ARCRECORD_BYTES (sizeof(ARCITEM) - sizeof(MINIRECORDCORE))
172	#define NO_START_OF_ARCHIVER_LIST_STRING "None"
173	#define NO_END_OF_ARCHIVER_LIST_STRING NO_START_OF_ARCHIVER_LIST_STRING
174
175	#pragma data_seg(DATA1)
176	static INT DefArcSortFlags;
177
178	// Data definitions
179	static PSZ pszSrcFile = __FILE__;
180	#pragma data_seg(GLOBAL1)
181	HWND ArcCnrMenu;
182	HWND ArcMenu;
183	CHAR ArcTempRoot[CCHMAXPATH];
184	BOOL fArcStuffVisible;
185	BOOL fFileNameCnrPath;
186
187	#pragma data_seg(GLOBAL2)
188	CHAR lastextractpath[CCHMAXPATH];
189	ULONGLONG ullDATFileSpaceNeeded = 10000;
190
191	typedef struct {
192
193	HWND hwndCnr; //hwnd you want the message posted to
194	HWND hwndClient; //hwnd calling this thread; NULL will work
195	ULONG RunFlags; //runemf2 flags see systemf.h
196	ULONG msg; //Message to post
197	UINT uiLineNumber;
198	PCSZ pszSrcFile;
199	CHAR filename[CCHMAXPATH]; //file passed as MP1 message parameter (file selected)
200	CHAR *pszDirectory; //Execution directory
201	CHAR *pszEnvironment; //Enviroment -- NULL passes current
202	CHAR *pszCmdLine; //Use sprintf to format multipart command line into single string
203	CHAR formatstring[40]; //Usally "%s"
204	}
205	WAITCHILD;
206
207	/** Creates a thread to wait for a child process to complete then posts a message and closes
208	* This function should only be used for runemf2 calls that include the WAIT flag
209	*/
210	VOID WaitChildThread(VOID * arg)
211	{
212	WAITCHILD *WaitChild;
213	HAB thab;
214	CHAR *filename;
215	INT ret;
216
217	DosError(FERR_DISABLEHARDERR);
218
219	# ifdef FORTIFY
220	Fortify_EnterScope();
221	# endif
222
223	WaitChild = (WAITCHILD *) arg;
224	if (WaitChild) {
225	filename = xstrdup(WaitChild->filename, pszSrcFile, __LINE__);
226	thab = WinInitialize(0);
227	if (thab) {
228	IncrThreadUsage();
229	priority_normal();
230	ret = runemf2(WaitChild->RunFlags, WaitChild->hwndClient,
231	WaitChild->pszSrcFile, WaitChild->uiLineNumber,
232	WaitChild->pszDirectory, WaitChild->pszEnvironment,
233	WaitChild->formatstring, WaitChild->pszCmdLine);
234	if (ret != -1) {
235	if (IsFile(WaitChild->filename) == 1)
236	PostMsg(WaitChild->hwndCnr, WaitChild->msg, MPFROMP(filename), MPVOID);
237	}
238	DecrThreadUsage();
239	WinTerminate(thab);
240	}
241	xfree(WaitChild->pszDirectory, pszSrcFile, __LINE__);
242	xfree(WaitChild->pszEnvironment, pszSrcFile, __LINE__);
243	xfree(WaitChild->pszCmdLine, pszSrcFile, __LINE__);
244	free(WaitChild);
245	} // if WaitChild
246	# ifdef FORTIFY
247	Fortify_LeaveScope();
248	# endif
249	}
250
251	static MRESULT EXPENTRY ArcErrProc(HWND hwnd, ULONG msg, MPARAM mp1,
252	MPARAM mp2)
253	{
254	ARCDUMP *ad;
255	CHAR szQuotedArcName[CCHMAXPATH];
256
257	switch (msg) {
258	case WM_INITDLG:
259	if (!mp2)
260	WinDismissDlg(hwnd, 0);
261	else {
262	ad = (ARCDUMP *) mp2;
263	WinSetWindowPtr(hwnd, QWL_USER, ad);
264	if (ad->errmsg)
265	WinSetDlgItemText(hwnd, ARCERR_TEXT, ad->errmsg);
266	if (!ad->info->test)
267	WinEnableWindow(WinWindowFromID(hwnd, ARCERR_TEST), FALSE);
268	if (ad->listname) {
269	MLEsetlimit(WinWindowFromID(hwnd, ARCERR_MLE), -1L);
270	MLEsetformat(WinWindowFromID(hwnd, ARCERR_MLE), MLFIE_NOTRANS);
271	MLEsetcurpos(WinWindowFromID(hwnd, ARCERR_MLE),
272	MLEgetlen(WinWindowFromID(hwnd, ARCERR_MLE)));
273	MLEinsert(WinWindowFromID(hwnd, ARCERR_MLE),
274	GetPString(IDS_ARCHIVERREPORTTEXT));
275	MLEinsertfile(WinWindowFromID(hwnd, ARCERR_MLE), ad->listname);
276	}
277	}
278	break;
279
280	case WM_COMMAND:
281	switch (SHORT1FROMMP(mp1)) {
282	case DID_CANCEL:
283	WinDismissDlg(hwnd, 0);
284	break;
285
286	case IDM_HELP:
287	if (hwndHelp) {
288	WinSendMsg(hwndHelp, HM_DISPLAY_HELP,
289	MPFROM2SHORT(HELP_ARCERR, 0), MPFROMSHORT(HM_RESOURCEID));
290	}
291	break;
292
293	case DID_OK:
294	ad = WinQueryWindowPtr(hwnd, QWL_USER);
295	WinDlgBox(HWND_DESKTOP, hwnd, ArcReviewDlgProc, FM3ModHandle,
296	AD_FRAME, MPFROMP(ad));
297	WinDismissDlg(hwnd, 0);
298	break;
299
300	case ARCERR_VIEW:
301	ad = WinQueryWindowPtr(hwnd, QWL_USER);
302	{
303	CHAR *list[2];
304
305	list[0] = ad->arcname;
306	list[1] = NULL;
307	if (TestBinary(ad->arcname)) {
308	if (*binview)
309	ExecOnList((HWND) 0, binview, WINDOWED \| SEPARATE, NULL, NULL, list,
310	NULL, pszSrcFile, __LINE__);
311	else
312	StartMLEEditor(HWND_DESKTOP, 16 + 4 + 1, ad->arcname, hwnd);
313	}
314	else {
315	if (*viewer) {
316	ExecOnList((HWND) 0, viewer, WINDOWED \| SEPARATE \|
317	(fViewChild ? CHILD : 0), NULL,
318	NULL, list, NULL, pszSrcFile, __LINE__);
319	}
320	else
321	StartMLEEditor(HWND_DESKTOP, 8 + 4 + 1, ad->arcname, hwnd);
322	}
323	}
324	break;
325
326	case ARCERR_TEST:
327	ad = WinQueryWindowPtr(hwnd, QWL_USER);
328	runemf2(SEPARATEKEEP \| WINDOWED \| MAXIMIZED,
329	hwnd, pszSrcFile, __LINE__, NULL, NULL,
330	"%s %s",
331	ad->info->test,
332	BldQuotedFileName(szQuotedArcName, ad->arcname));
333	break;
334	}
335	return 0;
336	}
337	return WinDefDlgProc(hwnd, msg, mp1, mp2);
338	}
339
340	static SHORT APIENTRY ArcSort(PMINIRECORDCORE pmrc1, PMINIRECORDCORE pmrc2,
341	PVOID pStorage)
342	{
343	PARCITEM pai1 = (PARCITEM) pmrc1;
344	PARCITEM pai2 = (PARCITEM) pmrc2;
345	DIRCNRDATA pdcd = (DIRCNRDATA ) pStorage;
346	SHORT ret = 0;
347	CHAR pext, ppext;
348	INT sortFlags;
349
350	if (!pdcd) {
351	HWND hwndCnr = pai1->hwndCnr;
352
353	pdcd = WinQueryWindowPtr(hwndCnr, QWL_USER);
354	if (!pdcd) {
355	Runtime_Error(pszSrcFile, __LINE__, NULL);
356	return ret;
357	}
358	}
359
360	sortFlags = pdcd->sortFlags; // Optimize
361
362	if (sortFlags) {
363	switch (sortFlags & (~SORT_REVERSE)) {
364	case SORT_FIRSTEXTENSION:
365	pext = strchr(pai1->pszFileName, '.');
366	ppext = strchr(pai2->pszFileName, '.');
367	if (!pext)
368	pext = NullStr;
369	if (!ppext)
370	ppext = NullStr;
371	ret = stricmp(pext, ppext);
372	break;
373
374	case SORT_LASTEXTENSION:
375	pext = strrchr(pai1->pszFileName, '.');
376	ppext = strrchr(pai2->pszFileName, '.');
377	if (!pext)
378	pext = NullStr;
379	if (!ppext)
380	ppext = NullStr;
381	ret = stricmp(pext, ppext);
382	break;
383
384	case SORT_LWDATE:
385	ret = TestCDates(&pai1->date, &pai1->time,
386	&pai2->date, &pai2->time);
387	break;
388
389	case SORT_SIZE:
390	ret =
391	(pai1->cbFile < pai2->cbFile) ? 1 : (pai1->cbFile ==
392	pai2->cbFile) ? 0 : -1;
393	if (!ret)
394	ret =
395	(pai1->cbComp < pai2->cbComp) ? 1 : (pai1->cbComp ==
396	pai2->cbComp) ? 0 : -1;
397	break;
398
399	case SORT_EASIZE:
400	ret =
401	(pai1->cbComp < pai2->cbComp) ? 1 : (pai1->cbComp ==
402	pai2->cbComp) ? 0 : -1;
403	if (!ret)
404	ret =
405	(pai1->cbFile < pai2->cbFile) ? 1 : (pai1->cbFile ==
406	pai2->cbFile) ? 0 : -1;
407	break;
408	}
409	if (!ret)
410	ret = (SHORT) stricmp(pai1->pszFileName, pai2->pszFileName);
411	if (ret && (sortFlags & SORT_REVERSE))
412	ret = ret > 0 ? -1 : 1;
413	return ret;
414	}
415	return (SHORT) stricmp(pai1->pszFileName, pai2->pszFileName);
416	}
417
418	static INT APIENTRY ArcFilter(PMINIRECORDCORE rmini, PVOID arg)
419	{
420	DIRCNRDATA dcd = (DIRCNRDATA ) arg;
421	PARCITEM r;
422	register INT x;
423	INT ret = FALSE;
424
425	if (dcd && *dcd->mask.szMask) {
426	r = (PARCITEM) rmini;
427	if (dcd->mask.pszMasks[1]) {
428	for (x = 0; dcd->mask.pszMasks[x]; x++) {
429	if (*dcd->mask.pszMasks[x]) {
430	if (*dcd->mask.pszMasks[x] != '/') {
431	if (wildcard(r->pszFileName, dcd->mask.pszMasks[x], TRUE))
432	ret = TRUE;
433	}
434	else {
435	if (wildcard(r->pszFileName, dcd->mask.pszMasks[x] + 1, TRUE)) {
436	ret = FALSE;
437	break;
438	}
439	}
440	}
441	}
442	}
443	else {
444	if (wildcard(r->pszFileName, dcd->mask.szMask, TRUE))
445	ret = TRUE;
446	}
447	}
448	else
449	ret = TRUE;
450	return ret;
451	}
452
453	static MRESULT EXPENTRY ArcFrameWndProc(HWND hwnd, ULONG msg, MPARAM mp1,
454	MPARAM mp2)
455	{
456	return CommonFrameWndProc(ARC_CNR, hwnd, msg, mp1, mp2);
457	}
458
459	static BOOL IsArcThere(HWND hwnd, CHAR * arcname)
460	{
461	if (arcname) {
462	if (IsFile(arcname) != 1) {
463	saymsg(MB_CANCEL, hwnd,
464	GetPString(IDS_SAYWHATTEXT),
465	GetPString(IDS_ARCNOTTHERETEXT), arcname);
466	return FALSE;
467	}
468	return TRUE;
469	}
470	return FALSE;
471	}
472
473	/**
474	* Free storage associated with archive container item
475	* Caller is responsible for correcting pointers
476	*/
477
478	static VOID FreeArcItemData(PARCITEM pai)
479	{
480	// DbgMsg(pszSrcFile, __LINE__, "FreeArcItemData %p", pai);
481	PSZ psz;
482
483	if (pai->pszFileName && pai->pszFileName != NullStr) {
484	psz = pai->pszFileName;
485	pai->pszFileName = NULL; // 08 Jul 08 SHL was NulStr
486	free(psz);
487	}
488	}
489
490	/**
491	* Remove item(s) from archive container and free associated storage if requested
492	* @param paiFirst points to first item to remove or NULL to remove all
493	* @param usCnt is remove count or 0 to remove all
494	*/
495
496	static VOID RemoveArcItems(HWND hwnd, PARCITEM paiFirst, USHORT usCnt, USHORT usFlags)
497	{
498	INT remaining = usCnt;
499	PARCITEM pai;
500
501	if ((usCnt && !paiFirst) \|\| (!usCnt && paiFirst))
502	Runtime_Error(pszSrcFile, __LINE__, "paiFirst %p usCnt %u mismatch", paiFirst, usCnt);
503	else {
504	// Free our buffers if free requested
505	if (usFlags & CMA_FREE) {
506	if (paiFirst)
507	pai = paiFirst;
508	else {
509	pai = (PARCITEM)WinSendMsg(hwnd, CM_QUERYRECORD, MPVOID,
510	MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
511	if ((INT)pai == -1) {
512	Win_Error(hwnd, HWND_DESKTOP, pszSrcFile, __LINE__,"CM_QUERYRECORD");
513	remaining = -1;
514	pai = NULL;
515	}
516	}
517	while (pai) {
518	FreeArcItemData(pai);
519	pai = (PARCITEM)pai->rc.preccNextRecord;
520	if (remaining && --remaining == 0)
521	break;
522	}
523	}
524	}
525
526	// DbgMsg(pszSrcFile, __LINE__, "RemoveArcItems %p %u %s", pai, usCnt, pai->pszFileName);
527
528	if (remaining != - 1) {
529	remaining = (INT)WinSendMsg(hwnd, CM_REMOVERECORD, MPFROMP(&paiFirst), MPFROM2SHORT(usCnt, usFlags));
530	if (remaining == -1) {
531	Win_Error(hwnd, HWND_DESKTOP, pszSrcFile, __LINE__,"CM_REMOVERECORD hwnd %x pai %p cnt %u",
532	hwnd, paiFirst, usCnt);
533	}
534	}
535	}
536
537	/**
538	* Empty all records from an archive container and
539	* free associated storage and free up field infos
540	*/
541
542	static VOID EmptyArcCnr(HWND hwnd)
543	{
544	#if 0 // fixme to be gone or to be configurable
545	{
546	int state = _heapchk();
547	if (state != _HEAPOK)
548	Runtime_Error(pszSrcFile, __LINE__, "heap corrupted %d", state);
549	else
550	DbgMsg(pszSrcFile, __LINE__, "_memavl %u", _memavl());
551	}
552	#endif
553
554	// Remove all ARCITEM records
555	RemoveArcItems(hwnd, NULL, 0, CMA_FREE);
556
557	// Use common code to remove rest
558	EmptyCnr(hwnd);
559	}
560
561	//== FillArcCnr() generate archive content list and fill container window ==
562
563	static INT FillArcCnr(HWND hwndCnr, CHAR * arcname, ARC_TYPE ** arcinfo,
564	ULONGLONG * pullTotalBytes, volatile PCHAR pStopFlag)
565	{
566	FILE *fp;
567	HFILE oldstdout;
568	HFILE newstdout;
569	CHAR s[CCHMAXPATH * 2], lonename[CCHMAXPATH + 2],
570	nsize, osize, fdate, fname, p, pp, *arctemp;
571	BOOL gotstart;
572	BOOL gotend;
573	BOOL wasquote;
574	BOOL nomove = FALSE; // fixme to be gone?
575	INT highest = 0, fieldnum, counter = 0, numarcfiles = 0;
576	PARCITEM lastpai;
577	ARC_TYPE *info;
578	ARC_TYPE *tinfo;
579	ULONG apptype;
580	APIRET rc;
581	CHAR *mode;
582
583	if (!arcname \|\| !arcinfo)
584	return 0;
585
586	info = *arcinfo;
587	if (!info)
588	info = find_type(arcname, NULL);
589	arctemp = xmallocz(CCHMAXPATH, pszSrcFile, __LINE__);
590	if (CheckDriveSpaceAvail(ArcTempRoot, ullDATFileSpaceNeeded, ullTmpSpaceNeeded) == 1)
591	saymsg(MB_OK,
592	HWND_DESKTOP,
593	NullStr,
594	GetPString(IDS_ARCTMPDRIVESPACELIMITED),
595	ArcTempRoot);
596	MakeTempName(arctemp, ArcTempRoot, 2);
597
598
599	ReTry:
600
601	tinfo = NULL;
602	numarcfiles = counter = highest = 0;
603	gotstart = gotend = FALSE;
604	lastpai = NULL;
605	*pullTotalBytes = 0;
606	if (!info \|\| !info->list)
607	Runtime_Error(pszSrcFile, __LINE__, NULL);
608	else {
609	RemoveArcItems(hwndCnr, NULL, 0, CMA_FREE \| CMA_INVALIDATE \| CMA_ERASE);
610	*arcinfo = info;
611	highest = info->osizepos;
612	if (info->nsizepos > highest)
613	highest = info->nsizepos;
614	if (info->fdpos > highest)
615	highest = info->fdpos;
616	if (info->fnpos > highest)
617	highest = info->fnpos;
618	if (highest > 50) {
619	saymsg(MB_ENTER \| MB_ICONEXCLAMATION, HWND_DESKTOP,
620	GetPString(IDS_SHAMETEXT), GetPString(IDS_BUNGEDUPTEXT));
621	}
622	if (info->fnpos == -1)
623	highest = 32767;
624
625	DosError(FERR_DISABLEHARDERR);
626	DosForceDelete(arctemp);
627	DosError(FERR_DISABLEHARDERR);
628
629	strcpy(s, info->list);
630	p = strchr(s, ' ');
631	if (p)
632	*p = 0;
633	DosError(FERR_DISABLEHARDERR);
634	if (!DosQueryAppType(s, &apptype) &&
635	(apptype & FAPPTYP_DOS \|\|
636	apptype & FAPPTYP_WINDOWSREAL \|\|
637	apptype & FAPPTYP_WINDOWSPROT \|\|
638	apptype & FAPPTYP_WINDOWSPROT31)) {
639	p = GetCmdSpec(TRUE);
640	runemf2(SEPARATE \| INVISIBLE \| MINIMIZED \| BACKGROUND \| WAIT,
641	hwndCnr, pszSrcFile, __LINE__, NULL, "DOS_BACKGROUND_EXECUTION=1",
642	"%s /C %s %s >%s",
643	p, // shell
644	info->list, // list command
645	BldQuotedFileName(s, arcname),
646	arctemp);
647	}
648	else {
649	mode = "w";
650	fp = xfopen(arctemp, mode, pszSrcFile, __LINE__, FALSE);
651	if (!fp) {
652	xfree(arctemp, pszSrcFile, __LINE__);
653	return 0;
654	}
655	else {
656	newstdout = -1;
657	DosError(FERR_DISABLEHARDERR);
658	rc = DosDupHandle(fileno(stdout), &newstdout);
659	if (rc) {
660	Dos_Error(MB_CANCEL, rc, hwndCnr, pszSrcFile, __LINE__,
661	PCSZ_DOSDUPHANDLE);
662	xfree(arctemp, pszSrcFile, __LINE__);
663	return 0;
664	}
665	else {
666	oldstdout = fileno(stdout);
667	DosError(FERR_DISABLEHARDERR);
668	rc = DosDupHandle(fileno(fp), &oldstdout);
669	if (rc) {
670	Dos_Error(MB_CANCEL, rc, hwndCnr, pszSrcFile, __LINE__,
671	PCSZ_DOSDUPHANDLE);
672	xfree(arctemp, pszSrcFile, __LINE__);
673	return 0;
674	}
675	else {
676	runemf2(SEPARATE \| INVISIBLE \| MINIMIZED \| BACKGROUND \| WAIT,
677	hwndCnr, pszSrcFile, __LINE__, NULL, NULL,
678	"%s %s",
679	info->list,
680	BldQuotedFileName(s, arcname));
681	oldstdout = fileno(stdout);
682	DosError(FERR_DISABLEHARDERR);
683	DosDupHandle(newstdout, &oldstdout);
684	DosClose(newstdout);
685	fclose(fp);
686	}
687	}
688	}
689	}
690
691	DosError(FERR_DISABLEHARDERR);
692	mode = "r";
693	fp = xfsopen(arctemp, mode, SH_DENYWR, pszSrcFile, __LINE__, TRUE);
694
695	if (fp) {
696	gotstart = !info->startlist \|\| // If list has no start marker
697	!*info->startlist \|\|
698	(stricmp(info->startlist, NO_START_OF_ARCHIVER_LIST_STRING) == 0);
699
700	while (!feof(fp) && !gotend && !*pStopFlag) {
701	if (!xfgets_bstripcr(s, sizeof(s), fp, pszSrcFile, __LINE__))
702	break;
703	if (!gotstart) {
704	if (!strcmp(s, info->startlist))
705	gotstart = TRUE;
706	}
707	else if (info->endlist && !strcmp(s, info->endlist))
708	gotend = TRUE;
709	else {
710	// add to container
711	fname = NULL;
712	bstrip(s);
713	if (info->nameisfirst) {
714	strncpy(lonename, s, CCHMAXPATH + 2);
715	lonename[CCHMAXPATH + 1] = 0;
716	fname = lonename;
717	if (!xfgets_bstripcr(s, sizeof(s), fp, pszSrcFile, __LINE__))
718	break;
719	if (*fname == '\"') {
720	memmove(fname, fname + 1, strlen(fname) + 1);
721	p = strchr(fname, '\"');
722	if (p)
723	*p = 0;
724	}
725	}
726	nsize = NULL;
727	osize = fdate = NullStr;
728	p = s;
729	for (fieldnum = 0; fieldnum <= highest; fieldnum++) {
730	pp = p;
731	while (pp && (pp == ' ' \|\| *pp == '\t')) // skip leading
732	pp++;
733	if (!*pp) {
734	if (fieldnum == info->fnpos && (!strcmp(strupr(info->ext), "7Z") \|\|
735	!strcmp(strupr(info->signature), "7Z")))
736	fname = nsize;// GKY 7-30-13 Work around for missing nsize field for some members of archive
737	break;
738	}
739	wasquote = FALSE;
740	p = pp;
741	while (*p && (wasquote \|\|
742	((fieldnum != info->fnpos \|\| !info->nameislast) ?
743	(p != ' ' && p != '\t') : TRUE))) {
744	if (*p == '\"') {
745	if (!wasquote) {
746	wasquote = TRUE;
747	memmove(p, p + 1, strlen(p));
748	while (p == ' ' \|\| p == '\t')
749	p++;
750	}
751	else {
752	memmove(p, p + 1, strlen(p));
753	break;
754	}
755	}
756	else if (*p)
757	p++;
758	}
759	if (*p) {
760	*p = 0;
761	p++;
762	}
763	if (fieldnum == info->nsizepos)
764	nsize = pp;
765	else if (fieldnum == info->osizepos)
766	osize = pp;
767	else if (fieldnum == info->fdpos) {
768	fdate = pp;
769	if (info->fdflds > 1 && info->fdflds < 24) {
770	INT y;
771
772	if (*p) {
773	p--;
774	*p = ' ';
775	for (y = 0; y < info->fdflds - 1; y++) {
776	while (p && (p == ' ' \|\| *p == '\t'))
777	p++;
778	while (p && (p != ' ' && *p != '\t'))
779	p++;
780	fieldnum++;
781	}
782	if (*p) {
783	*p = 0;
784	p++;
785	}
786	}
787	}
788	}
789	else if (fieldnum == info->fnpos) {
790	fname = pp;
791	if (pp && pp == '' && !*(pp + 1)) // workaround for LH.EXE
792	fname = NULL;
793	if (info->nameislast)
794	break;
795	}
796	else if ((!p \|\| !*p) && info->fnpos == -1) {
797	fname = pp;
798	break;
799	}
800	} // for fldnum
801	if (info->nameisnext) {
802	if (!xfgets_bstripcr
803	(lonename, sizeof(lonename), fp, pszSrcFile, __LINE__))
804	break;
805	fname = lonename;
806	}
807	// fixme to complain?
808	if (fname && *fname) {
809
810	RECORDINSERT ri;
811	PARCITEM pai;
812
813	pai = WinSendMsg(hwndCnr,
814	CM_ALLOCRECORD,
815	MPFROMLONG(EXTRA_ARCRECORD_BYTES),
816	MPFROMLONG(1L));
817	if (!pai) {
818	Runtime_Error(pszSrcFile, __LINE__, PCSZ_CM_ALLOCRECORD);
819	break;
820	}
821	else {
822	memset(pai, 0, sizeof(ARCITEM));
823	pai->hwndCnr = hwndCnr;
824	if (fname == '') {
825	fname++;
826	pai->flags = ARCFLAGS_REALDIR;
827	}
828	if (fname[strlen(fname) - 1] == '\\' \|\|
829	fname[strlen(fname) - 1] == '/')
830	pai->flags = ARCFLAGS_REALDIR;
831	pai->pszFileName = xstrdup(fname,pszSrcFile, __LINE__);
832	# ifdef FORTIFY
833	// Will be freed by WM_DESTROY
834	Fortify_SetOwner(pai->pszFileName, 1);
835	// Fortify_ChangeScope(pai->pszFileName, -1);
836	# endif
837
838	pai->pszDisplayName = pai->pszFileName;
839	pai->rc.pszIcon = pai->pszDisplayName;
840	if (fdate)
841	strcpy(pai->szDate, fdate);
842	// pai->pszFileName = pai->pszFileName;
843	pai->rc.pszIcon = pai->pszFileName;
844	pai->rc.hptrIcon = (pai->flags & ARCFLAGS_REALDIR) != 0 ?
845	hptrDir : hptrFile;
846	pai->pszDate = pai->szDate;
847	if (osize)
848	pai->cbFile = atol(osize);
849	if (nsize)
850	pai->cbComp = atol(nsize);
851	if (info->datetype && fdate && *fdate)
852	ArcDateTime(fdate, info->datetype, &pai->date, &pai->time);
853	memset(&ri, 0, sizeof(RECORDINSERT));
854	ri.cb = sizeof(RECORDINSERT);
855	ri.pRecordOrder = (PRECORDCORE) CMA_END;
856	ri.pRecordParent = (PRECORDCORE) NULL;
857	ri.zOrder = (USHORT) CMA_TOP;
858	ri.cRecordsInsert = 1L;
859	ri.fInvalidateRecord = FALSE;
860	if (WinSendMsg(hwndCnr,
861	CM_INSERTRECORD, MPFROMP(pai), MPFROMP(&ri))) {
862	*pullTotalBytes += pai->cbFile;
863	}
864	numarcfiles++;
865	if (!(++counter % 50)) {
866	if (!lastpai)
867	lastpai = pai;
868	WinSendMsg(hwndCnr,
869	CM_INVALIDATERECORD,
870	lastpai,
871	MPFROM2SHORT(10, CMA_ERASE \| CMA_REPOSITION));
872	lastpai = pai;
873	}
874	// Avoid hogging system for large archive
875	if (numarcfiles == 100)
876	priority_idle();
877	}
878	}
879	}
880	} // while !eof
881
882	fclose(fp);
883
884	if (*pStopFlag)
885	numarcfiles = 0; // Request close
886	else if (!numarcfiles \|\| !gotstart
887	\|\| (!gotend && info->endlist && *info->endlist && (stricmp(info->endlist, NO_END_OF_ARCHIVER_LIST_STRING)))) {
888	// Oops
889	ARCDUMP ad;
890	CHAR errstr[CCHMAXPATH + 256];
891
892	// Try for alternate archiver
893	tinfo = info;
894	do {
895	tinfo = tinfo->next;
896	if (tinfo)
897	tinfo = find_type(arcname, tinfo);
898	if (tinfo) {
899	DosError(FERR_DISABLEHARDERR);
900	DosForceDelete(arctemp);
901	info = tinfo;
902	goto ReTry;
903	}
904	} while (tinfo);
905	if (!fAlertBeepOff)
906	DosBeep(750, 50); // wake up user
907	sprintf(errstr, GetPString(IDS_ARCERRORINFOTEXT),
908	arcname,
909	!gotstart ? GetPString(IDS_NOGOTSTARTTEXT) : NullStr,
910	!numarcfiles ? GetPString(IDS_NOARCFILESFOUNDTEXT) :
911	NullStr,
912	!gotend ? GetPString(IDS_NOENDOFLISTTEXT) : NullStr);
913	memset(&ad, 0, sizeof(ARCDUMP));
914	ad.info = info;
915	strcpy(ad.listname, arctemp);
916	strcpy(ad.arcname, arcname);
917	ad.errmsg = errstr;
918	WinDlgBox(HWND_DESKTOP,
919	hwndCnr,
920	ArcErrProc, FM3ModHandle, ARCERR_FRAME, MPFROMP(&ad));
921	}
922	else if (!nomove && tinfo) {
923	// if we got a false hit, move working hit to top
924	tinfo = info->next;
925	info->next = arcsighead;
926	arcsighead->prev = info;
927	if (tinfo)
928	tinfo->next->prev = info->prev;
929	info->prev->next = tinfo;
930	info->prev = NULL;
931	arcsighead = info;
932	rewrite_archiverbb2(NULL); // Rewrite with warning
933	}
934	} // if opened
935
936	DosError(FERR_DISABLEHARDERR);
937	DosForceDelete(arctemp);
938	xfree(arctemp, pszSrcFile, __LINE__);
939	}
940
941	if (numarcfiles)
942	priority_normal();
943
944	return numarcfiles;
945	}
946
947	MRESULT EXPENTRY ArcTextProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
948	{
949	static BOOL emphasized = FALSE;
950	static HWND hwndButtonPopup = (HWND) 0;
951	static ULONG timestamp = ULONG_MAX;
952	static USHORT lastid = 0;
953
954	switch (msg) {
955	case WM_CREATE:
956	return CommonTextProc(hwnd, msg, mp1, mp2);
957
958	case WM_COMMAND:
959	return WinSendMsg(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
960	ARC_CNR), msg, mp1, mp2);
961
962	case UM_CONTEXTMENU:
963	case WM_CONTEXTMENU:
964	{
965	USHORT id;
966
967	id = WinQueryWindowUShort(hwnd, QWS_ID);
968	switch (id) {
969	case DIR_SELECTED:
970	case DIR_VIEW:
971	case DIR_SORT:
972	{
973	POINTL ptl = { 0, 0 };
974	SWP swp;
975	DIRCNRDATA *dcd;
976
977	if (hwndButtonPopup)
978	WinDestroyWindow(hwndButtonPopup);
979	if (id == DIR_SELECTED)
980	id = DIR_RESTORE;
981	if (id == lastid) {
982
983	ULONG check;
984
985	DosQuerySysInfo(QSV_MS_COUNT, QSV_MS_COUNT, &check,
986	sizeof(check));
987	if (check < timestamp + 500) {
988	lastid = 0;
989	goto MenuAbort;
990	}
991	}
992	hwndButtonPopup = WinLoadMenu(HWND_DESKTOP, FM3ModHandle, id);
993	if (hwndButtonPopup) {
994	WinSetWindowUShort(hwndButtonPopup, QWS_ID, id);
995	dcd = WinQueryWindowPtr(WinWindowFromID(WinQueryWindow(hwnd,
996	QW_PARENT),
997	ARC_CNR), QWL_USER);
998	if (id == DIR_SORT) {
999	if (dcd)
1000	SetSortChecks(hwndButtonPopup, dcd->sortFlags);
1001	WinSendMsg(hwndButtonPopup,
1002	MM_DELETEITEM,
1003	MPFROM2SHORT(IDM_SORTNONE, FALSE), MPVOID);
1004	WinSendMsg(hwndButtonPopup,
1005	MM_DELETEITEM,
1006	MPFROM2SHORT(IDM_SORTNAME, FALSE), MPVOID);
1007	WinSendMsg(hwndButtonPopup,
1008	MM_DELETEITEM,
1009	MPFROM2SHORT(IDM_SORTLADATE, FALSE), MPVOID);
1010	WinSendMsg(hwndButtonPopup,
1011	MM_DELETEITEM,
1012	MPFROM2SHORT(IDM_SORTCRDATE, FALSE), MPVOID);
1013	WinSendMsg(hwndButtonPopup,
1014	MM_DELETEITEM,
1015	MPFROM2SHORT(IDM_SORTDIRSFIRST, FALSE), MPVOID);
1016	WinSendMsg(hwndButtonPopup,
1017	MM_DELETEITEM,
1018	MPFROM2SHORT(IDM_SORTDIRSLAST, FALSE), MPVOID);
1019	WinSendMsg(hwndButtonPopup,
1020	MM_DELETEITEM,
1021	MPFROM2SHORT(IDM_SORTSUBJECT, FALSE), MPVOID);
1022	WinSendMsg(hwndButtonPopup,
1023	MM_SETITEMTEXT,
1024	MPFROM2SHORT(IDM_SORTEASIZE, 0),
1025	MPFROMP(GetPString(IDS_COMPRESSEDSIZEMENUTEXT)));
1026	WinSendMsg(hwndButtonPopup,
1027	MM_SETITEMTEXT,
1028	MPFROM2SHORT(IDM_SORTLWDATE, 0),
1029	MPFROMP(GetPString(IDS_DATEMENUTEXT)));
1030	}
1031	ptl.x = 0;
1032	if (WinPopupMenu(HWND_OBJECT,
1033	HWND_OBJECT,
1034	hwndButtonPopup, -32767, -32767, 0, 0)) {
1035	WinQueryWindowPos(hwndButtonPopup, &swp);
1036	ptl.y = -(swp.cy + 2);
1037	}
1038	else {
1039	WinQueryWindowPos(hwnd, &swp);
1040	ptl.y = swp.cy + 2;
1041	}
1042	if (WinPopupMenu(hwnd,
1043	hwnd,
1044	hwndButtonPopup,
1045	ptl.x,
1046	ptl.y,
1047	0,
1048	PU_HCONSTRAIN \| PU_VCONSTRAIN \|
1049	PU_KEYBOARD \| PU_MOUSEBUTTON1)) {
1050	CenterOverWindow(hwndButtonPopup);
1051	PaintRecessedWindow(hwnd, (HPS) 0, FALSE, FALSE);
1052	}
1053	}
1054	}
1055	break;
1056	default:
1057	PostMsg(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
1058	ARC_CNR),
1059	WM_CONTROL, MPFROM2SHORT(ARC_CNR, CN_CONTEXTMENU), MPVOID);
1060	break;
1061	}
1062	}
1063	MenuAbort:
1064	if (msg == UM_CONTEXTMENU)
1065	return 0;
1066	break;
1067
1068	case WM_MENUEND:
1069	if (hwndButtonPopup == (HWND) mp2) {
1070	lastid = WinQueryWindowUShort((HWND) mp2, QWS_ID);
1071	WinDestroyWindow(hwndButtonPopup);
1072	hwndButtonPopup = (HWND) 0;
1073	DosQuerySysInfo(QSV_MS_COUNT, QSV_MS_COUNT, &timestamp,
1074	sizeof(timestamp));
1075	switch (lastid) {
1076	case DIR_VIEW:
1077	case DIR_SORT:
1078	case DIR_RESTORE:
1079	case DIR_SELECTED:
1080	PaintRecessedWindow(hwnd, (HPS) 0, TRUE, FALSE);
1081	break;
1082	}
1083	}
1084	break;
1085
1086	case WM_MOUSEMOVE:
1087	{
1088	USHORT id = WinQueryWindowUShort(hwnd, QWS_ID);
1089	PCSZ s = NULL;
1090
1091	if (fOtherHelp) {
1092	if ((!hwndBubble \|\|
1093	WinQueryWindowULong(hwndBubble, QWL_USER) != hwnd) &&
1094	!WinQueryCapture(HWND_DESKTOP)) {
1095	switch (id) {
1096	case DIR_TOTALS:
1097	s = GetPString(IDS_ARCCNRTOTALSHELPTEXT);
1098	break;
1099	case DIR_SELECTED:
1100	s = GetPString(IDS_ARCCNRSELECTEDHELPTEXT);
1101	break;
1102	case DIR_VIEW:
1103	s = GetPString(IDS_ARCCNRVIEWHELPTEXT);
1104	break;
1105	case DIR_SORT:
1106	s = GetPString(IDS_DIRCNRSORTHELP);
1107	break;
1108	case DIR_FILTER:
1109	s = GetPString(IDS_DIRCNRFILTERHELP);
1110	break;
1111	case DIR_FOLDERICON:
1112	s = GetPString(IDS_ARCCNRFOLDERHELPTEXT);
1113	break;
1114	default:
1115	break;
1116	}
1117	if (s)
1118	MakeBubble(hwnd, TRUE, s);
1119	else if (hwndBubble)
1120	WinDestroyWindow(hwndBubble);
1121	}
1122	}
1123	switch (id) {
1124	case DIR_FILTER:
1125	case DIR_SORT:
1126	case DIR_VIEW:
1127	case DIR_SELECTED:
1128	case DIR_FOLDERICON:
1129	return CommonTextButton(hwnd, msg, mp1, mp2);
1130	}
1131	}
1132	break;
1133
1134	case WM_BUTTON3UP:
1135	case WM_BUTTON1UP:
1136	case WM_BUTTON1DOWN:
1137	case WM_BUTTON3DOWN:
1138	{
1139	USHORT id;
1140
1141	id = WinQueryWindowUShort(hwnd, QWS_ID);
1142	switch (id) {
1143	case DIR_FILTER:
1144	case DIR_SORT:
1145	case DIR_VIEW:
1146	case DIR_SELECTED:
1147	case DIR_FOLDERICON:
1148	return CommonTextButton(hwnd, msg, mp1, mp2);
1149	}
1150	}
1151	break;
1152
1153	case UM_CLICKED:
1154	case UM_CLICKED3:
1155	{
1156	USHORT id, cmd = 0;
1157
1158	id = WinQueryWindowUShort(hwnd, QWS_ID);
1159	switch (id) {
1160	case DIR_FOLDERICON:
1161	switch (msg) {
1162	case WM_BUTTON3CLICK:
1163	case WM_CHORD:
1164	cmd = IDM_RESCAN;
1165	break;
1166	default:
1167	if ((SHORT2FROMMP(mp2) & KC_ALT) != 0)
1168	cmd = IDM_WINDOWDLG;
1169	else
1170	cmd = IDM_WALKDIR;
1171	break;
1172	}
1173	break;
1174	case DIR_VIEW:
1175	case DIR_SORT:
1176	case DIR_SELECTED:
1177	PostMsg(hwnd, UM_CONTEXTMENU, MPVOID, MPVOID);
1178	break;
1179	case DIR_FILTER:
1180	cmd = IDM_FILTER;
1181	break;
1182	default:
1183	break;
1184	}
1185	if (cmd)
1186	PostMsg(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
1187	ARC_CNR),
1188	WM_COMMAND, MPFROM2SHORT(cmd, 0), MPVOID);
1189	}
1190	return 0;
1191
1192	case WM_BEGINDRAG:
1193	case DM_DROP:
1194	case DM_DRAGOVER:
1195	case DM_DRAGLEAVE:
1196	case DM_DROPHELP:
1197	if (msg == DM_DRAGOVER) {
1198	if (!emphasized) {
1199	emphasized = TRUE;
1200	DrawTargetEmphasis(hwnd, emphasized);
1201	}
1202	}
1203	else if (msg != WM_BEGINDRAG) {
1204	if (emphasized) {
1205	emphasized = FALSE;
1206	DrawTargetEmphasis(hwnd, emphasized);
1207	}
1208	}
1209	switch (WinQueryWindowUShort(hwnd, QWS_ID)) {
1210	case DIR_FOLDERICON:
1211	switch (msg) {
1212	case DM_DRAGOVER:
1213	if (AcceptOneDrop(hwnd, mp1, mp2))
1214	return MRFROM2SHORT(DOR_DROP, DO_MOVE);
1215	return MRFROM2SHORT(DOR_NODROP, 0); // Drop not valid
1216	case DM_DROPHELP:
1217	DropHelp(mp1, mp2, hwnd, GetPString(IDS_ARCCNRFOLDERDROPHELPTEXT));
1218	return 0;
1219	case DM_DROP:
1220	{
1221	char szFrom[CCHMAXPATH + 2];
1222
1223	if (emphasized) {
1224	emphasized = FALSE;
1225	DrawTargetEmphasis(hwnd, emphasized);
1226	}
1227	if (GetOneDrop(hwnd, mp1, mp2, szFrom, sizeof(szFrom)))
1228	WinSendMsg(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
1229	ARC_CNR),
1230	WM_COMMAND,
1231	MPFROM2SHORT(IDM_SWITCH, 0), MPFROMP(szFrom));
1232	}
1233	return 0;
1234	default:
1235	return PFNWPStatic(hwnd, msg, mp1, mp2);
1236	}
1237	default:
1238	{
1239	CNRDRAGINFO cnd;
1240	USHORT dcmd;
1241
1242	switch (msg) {
1243	case DM_DROP:
1244	dcmd = CN_DROP;
1245	break;
1246	case DM_DRAGOVER:
1247	dcmd = CN_DRAGOVER;
1248	break;
1249	case DM_DRAGLEAVE:
1250	dcmd = CN_DRAGLEAVE;
1251	break;
1252	case DM_DROPHELP:
1253	dcmd = CN_DROPHELP;
1254	break;
1255	case WM_BEGINDRAG:
1256	dcmd = CN_INITDRAG;
1257	break;
1258	}
1259	cnd.pDragInfo = (PDRAGINFO) mp1;
1260	cnd.pRecord = NULL;
1261	return WinSendMsg(WinQueryWindow(hwnd, QW_PARENT),
1262	WM_CONTROL,
1263	MPFROM2SHORT(ARC_CNR, dcmd), MPFROMP(&cnd));
1264	}
1265	}
1266	}
1267	return PFNWPStatic(hwnd, msg, mp1, mp2);
1268	}
1269
1270	MRESULT EXPENTRY ArcClientWndProc(HWND hwnd, ULONG msg, MPARAM mp1,
1271	MPARAM mp2)
1272	{
1273
1274	switch (msg) {
1275	case UM_CONTAINERHWND:
1276	return MRFROMLONG(WinWindowFromID(hwnd, ARC_CNR));
1277
1278	case UM_VIEWSMENU:
1279	// fixme to disble menu items as needed
1280	return MRFROMLONG(CheckMenu(hwnd, &ArcCnrMenu, ARCCNR_POPUP));
1281
1282	case UM_FILESMENU:
1283	// fixme to disble menu items as needed
1284	return MRFROMLONG(CheckMenu(hwnd, &ArcMenu, ARC_POPUP));
1285
1286	case MM_PORTHOLEINIT:
1287	case WM_INITMENU:
1288	case UM_INITMENU:
1289	case UM_COMMAND:
1290	case UM_LOADFILE:
1291	case UM_UPDATERECORD:
1292	case UM_UPDATERECORDLIST:
1293	case WM_COMMAND:
1294	case WM_CONTROL:
1295	case WM_CLOSE:
1296	return WinSendMsg(WinWindowFromID(hwnd, ARC_CNR), msg, mp1, mp2);
1297
1298	case WM_PSETFOCUS:
1299	case WM_SETFOCUS:
1300	if (mp2)
1301	PostMsg(hwnd, UM_FOCUSME, MPVOID, MPVOID);
1302	break;
1303
1304	case UM_FOCUSME:
1305	WinSetFocus(HWND_DESKTOP, WinWindowFromID(hwnd, ARC_CNR));
1306	break;
1307
1308	case WM_PAINT:
1309	{
1310	HPS hps;
1311	RECTL rcl;
1312
1313	hps = WinBeginPaint(hwnd, (HPS) 0, NULL);
1314	if (hps) {
1315	WinQueryWindowRect(hwnd, &rcl);
1316	WinFillRect(hps, &rcl, CLR_PALEGRAY);
1317	CommonTextPaint(hwnd, hps);
1318	WinEndPaint(hps);
1319	}
1320	}
1321	break;
1322
1323	case UM_SIZE:
1324	case WM_SIZE:
1325	if (msg == UM_SIZE) {
1326
1327	SWP swp;
1328
1329	WinQueryWindowPos(hwnd, &swp);
1330	mp1 = MPFROM2SHORT(swp.cx, swp.cy);
1331	mp2 = MPFROM2SHORT(swp.cx, swp.cy);
1332	}
1333	{
1334	USHORT cx, cy, bx;
1335
1336	cx = SHORT1FROMMP(mp2);
1337	cy = SHORT2FROMMP(mp2);
1338	WinSetWindowPos(WinWindowFromID(hwnd, ARC_CNR), HWND_TOP,
1339	0,
1340	22, cx, cy - (24 + 22), SWP_SHOW \| SWP_MOVE \| SWP_SIZE);
1341	WinSetWindowPos(WinWindowFromID(hwnd, ARC_EXTRACTDIR), HWND_TOP,
1342	0, 0, cx, 22, SWP_SHOW \| SWP_MOVE \| SWP_SIZE);
1343	WinSetWindowPos(WinWindowFromID(hwnd, DIR_FOLDERICON), HWND_TOP,
1344	2, cy - 22, 24, 20, SWP_SHOW \| SWP_MOVE \| SWP_SIZE);
1345	WinSetWindowPos(WinWindowFromID(hwnd, DIR_TOTALS), HWND_TOP,
1346	29,
1347	cy - 22,
1348	(cx / 3) - 2, 20, SWP_SHOW \| SWP_MOVE \| SWP_SIZE);
1349	WinSetWindowPos(WinWindowFromID(hwnd, DIR_SELECTED), HWND_TOP,
1350	29 + (cx / 3) + 2,
1351	cy - 22,
1352	(cx / 3) - 2, 20, SWP_SHOW \| SWP_MOVE \| SWP_SIZE);
1353	bx = (cx - (29 + (((cx / 3) + 2) * 2))) / 3;
1354	WinSetWindowPos(WinWindowFromID(hwnd, DIR_VIEW), HWND_TOP,
1355	29 + (((cx / 3) + 2) * 2),
1356	cy - 22, bx - 4, 20, SWP_SHOW \| SWP_MOVE \| SWP_SIZE);
1357	WinSetWindowPos(WinWindowFromID(hwnd, DIR_SORT), HWND_TOP,
1358	29 + (((cx / 3) + 2) * 2) + bx,
1359	cy - 22, bx - 4, 20, SWP_SHOW \| SWP_MOVE \| SWP_SIZE);
1360	WinSetWindowPos(WinWindowFromID(hwnd, DIR_FILTER), HWND_TOP,
1361	29 + (((cx / 3) + 2) * 2) + (bx * 2),
1362	cy - 22, bx - 4, 20, SWP_SHOW \| SWP_MOVE \| SWP_SIZE);
1363	}
1364	CommonTextPaint(hwnd, (HPS) 0);
1365	if (msg == UM_SIZE) {
1366	WinSetWindowPos(WinQueryWindow(hwnd, QW_PARENT), HWND_TOP, 0, 0, 0, 0,
1367	SWP_SHOW \| SWP_ZORDER \| SWP_ACTIVATE);
1368	return 0;
1369	}
1370	break;
1371	}
1372	return WinDefWindowProc(hwnd, msg, mp1, mp2);
1373	}
1374
1375	MRESULT EXPENTRY ArcObjWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
1376	{
1377	DIRCNRDATA *dcd;
1378	PSZ psz;
1379	CHAR szQuotedArcName[CCHMAXPATH];
1380	CHAR szQuotedMemberName[CCHMAXPATH];
1381
1382	switch (msg) {
1383	case WM_CREATE:
1384	DbgMsg(pszSrcFile, __LINE__, "WM_CREATE mp1 %p mp2 %p", mp1, mp2); // 18 Jul 08 SHL fixme
1385	break;
1386
1387	case DM_PRINTOBJECT:
1388	case DM_DISCARDOBJECT:
1389	dcd = INSTDATA(hwnd);
1390	if (dcd) {
1391
1392	LISTINFO *li;
1393	CNRDRAGINFO cni;
1394
1395	cni.pRecord = NULL;
1396	cni.pDragInfo = (PDRAGINFO) mp1;
1397	li = DoFileDrop(dcd->hwndCnr,
1398	dcd->directory, FALSE, MPVOID, MPFROMP(&cni));
1399	CheckPmDrgLimit(cni.pDragInfo);
1400	if (li) {
1401	li->type = (msg == DM_DISCARDOBJECT) ? IDM_DELETE : IDM_PRINT;
1402	if (!li->list \|\|
1403	!li->list[0] \|\| !PostMsg(hwnd, UM_ACTION, MPFROMP(li), MPVOID))
1404	FreeListInfo(li);
1405	else
1406	return MRFROMLONG(DRR_SOURCE);
1407	}
1408	}
1409	return MRFROMLONG(DRR_TARGET);
1410
1411	case DM_RENDERPREPARE:
1412	return (MRESULT) TRUE;
1413
1414	case DM_RENDER:
1415	dcd = WinQueryWindowPtr(hwnd, QWL_USER);
1416	if (dcd && dcd->info && dcd->info->extract && dcd->arcname) {
1417
1418	PDRAGTRANSFER pdt = (PDRAGTRANSFER) mp1;
1419	CHAR filename[CCHMAXPATH];
1420	ULONG len;
1421
1422	if (pdt->hwndClient && pdt->pditem && pdt->hstrSelectedRMF &&
1423	pdt->hstrRenderToName) {
1424	if (pdt->usOperation == DO_COPY \|\| pdt->usOperation == DO_MOVE) {
1425	*filename = 0;
1426	len = DrgQueryStrName(pdt->hstrSelectedRMF, CCHMAXPATH, filename);
1427	filename[len] = 0;
1428	if (strnicmp(filename, "OS2FILE,", 8)) {
1429	*filename = 0;
1430	len = DrgQueryStrName(pdt->hstrRenderToName, CCHMAXPATH, filename);
1431	filename[len] = 0;
1432	if (len && *filename) {
1433	psz = xstrdup(filename, pszSrcFile, __LINE__);
1434	if (psz) {
1435	PostMsg(hwnd, UM_RENDER, MPFROMP(pdt), MPFROMP(psz));
1436	return (MRESULT) TRUE;
1437	}
1438	}
1439	}
1440	}
1441	pdt->fsReply = DMFL_RENDERRETRY;
1442	}
1443	}
1444	return (MRESULT) FALSE;
1445
1446	case UM_RENDER:
1447	{
1448	PDRAGTRANSFER pdt = (PDRAGTRANSFER) mp1;
1449	USHORT usRes = DMFL_RENDERFAIL;
1450
1451	dcd = WinQueryWindowPtr(hwnd, QWL_USER);
1452	if (dcd && dcd->info && dcd->info->extract && dcd->arcname) {
1453
1454	CHAR filename = (CHAR ) mp2, *p;
1455	ULONG len;
1456	CHAR membername[CCHMAXPATH], construct[CCHMAXPATH * 2];
1457
1458	*membername = 0;
1459	len = DrgQueryStrName(pdt->pditem->hstrSourceName,
1460	CCHMAXPATH, membername);
1461	membername[len] = 0;
1462	if (*membername && len && filename) {
1463	unlinkf(filename);
1464	strcpy(construct, filename);
1465	p = strrchr(filename, '\\');
1466	if (!p)
1467	*construct = 0;
1468	else {
1469	if (p == filename \|\| *(p - 1) == ':')
1470	p++;
1471	*p = 0;
1472	}
1473	runemf2(SEPARATE \| WINDOWED \| ASYNCHRONOUS \| WAIT \|
1474	(fArcStuffVisible ? 0 : BACKGROUND \| MINIMIZED),
1475	dcd->hwndClient, pszSrcFile, __LINE__, construct, NULL,
1476	"%s %s %s",
1477	dcd->info->extract,
1478	BldQuotedFileName(szQuotedArcName, dcd->arcname),
1479	BldQuotedFileName(szQuotedMemberName, membername));
1480	BldFullPathName(construct, construct, membername);
1481	if (IsFile(construct) != -1) {
1482	rename(construct, filename);
1483	unlinkf(construct);
1484	if (IsFile(filename) != -1)
1485	usRes = DMFL_RENDEROK;
1486	}
1487	}
1488	}
1489	xfree((CHAR *)mp2, pszSrcFile, __LINE__);
1490	PostMsg(pdt->hwndClient, DM_RENDERCOMPLETE, MPFROMP(pdt),
1491	MPFROM2SHORT(usRes, 0));
1492	}
1493	return 0;
1494
1495	case UM_SETUP:
1496	# ifdef FORTIFY
1497	Fortify_EnterScope();
1498	# endif
1499	dcd = WinQueryWindowPtr(hwnd, QWL_USER);
1500	if (!dcd) {
1501	Runtime_Error(pszSrcFile, __LINE__, NULL);
1502	PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
1503	}
1504	else {
1505	# ifdef FORTIFY
1506	Fortify_BecomeOwner(dcd);
1507	# endif
1508	// set unique id
1509	WinSetWindowUShort(hwnd, QWS_ID, ARCOBJ_FRAME + (ARC_FRAME - dcd->id));
1510	dcd->hwndObject = hwnd; // pass back hwnd
1511	if (ParentIsDesktop(hwnd, dcd->hwndParent))
1512	DosSleep(100); //05 Aug 07 GKY 250 // Avoid race?
1513	}
1514	return 0;
1515
1516	case UM_RESCAN:
1517	/**
1518	* populate container
1519	*/
1520	dcd = WinQueryWindowPtr(hwnd, QWL_USER);
1521	if (dcd) {
1522	if (mp1)
1523	strcpy(dcd->arcname, (CHAR *) mp1); // Update name on request
1524	dcd->ullTotalBytes = dcd->totalfiles =
1525	dcd->selectedfiles = dcd->selectedbytes = 0;
1526	WinSetDlgItemText(dcd->hwndClient, DIR_TOTALS, "0");
1527	WinSetDlgItemText(dcd->hwndClient, DIR_SELECTED, "0 / 0k");
1528	dcd->totalfiles = FillArcCnr(dcd->hwndCnr,
1529	dcd->arcname,
1530	&dcd->info,
1531	&dcd->ullTotalBytes, &dcd->stopflag);
1532	if (!dcd->totalfiles)
1533	PostMsg(dcd->hwndCnr, WM_CLOSE, MPVOID, MPVOID);
1534	else {
1535	dcd->arcfilled = TRUE;
1536	if (!PostMsg(dcd->hwndCnr, UM_RESCAN, MPVOID, MPVOID))
1537	WinSendMsg(dcd->hwndCnr, UM_RESCAN, MPVOID, MPVOID);
1538	PostMsg(dcd->hwndCnr, UM_SETUP2, MPVOID, MPVOID);
1539	WinSendMsg(dcd->hwndCnr,
1540	CM_INVALIDATERECORD,
1541	MPVOID, MPFROM2SHORT(0, CMA_ERASE \| CMA_REPOSITION));
1542	}
1543	}
1544	return 0;
1545
1546	case UM_SELECT:
1547	dcd = WinQueryWindowPtr(hwnd, QWL_USER);
1548	if (dcd) {
1549	switch (SHORT1FROMMP(mp1)) {
1550	case IDM_SELECTALL:
1551	case IDM_SELECTALLFILES:
1552	SelectAll(dcd->hwndCnr, TRUE, TRUE, NULL, NULL, TRUE);
1553	break;
1554	case IDM_DESELECTALL:
1555	case IDM_DESELECTALLFILES:
1556	DeselectAll(dcd->hwndCnr, TRUE, TRUE, NULL, NULL, TRUE);
1557	break;
1558	case IDM_DESELECTMASK:
1559	case IDM_SELECTMASK:
1560	{
1561	MASK mask;
1562	PARCITEM pci = (PARCITEM) mp2;
1563
1564	memset(&mask, 0, sizeof(MASK));
1565	mask.fNoAttribs = TRUE;
1566	mask.fNoDirs = TRUE;
1567	mask.fText = TRUE;
1568	strcpy(mask.prompt,
1569	GetPString((SHORT1FROMMP(mp1) == IDM_SELECTMASK) ?
1570	IDS_SELECTFILTERTEXT : IDS_DESELECTFILTERTEXT));
1571	if (pci && (INT) pci != -1)
1572	strcpy(mask.szMask, pci->pszFileName);
1573	if (WinDlgBox(HWND_DESKTOP, dcd->hwndCnr, PickMaskDlgProc,
1574	FM3ModHandle, MSK_FRAME, MPFROMP(&mask))) {
1575	if (SHORT1FROMMP(mp1) == IDM_SELECTMASK)
1576	SelectAll(dcd->hwndCnr, TRUE, TRUE, mask.szMask, NULL, FALSE);
1577	else
1578	DeselectAll(dcd->hwndCnr, TRUE, TRUE, mask.szMask, NULL, FALSE);
1579	}
1580	}
1581	break;
1582
1583	case IDM_INVERT:
1584	InvertAll(dcd->hwndCnr);
1585	break;
1586	}
1587	}
1588	return 0;
1589
1590	case UM_ENTER:
1591	dcd = WinQueryWindowPtr(hwnd, QWL_USER);
1592	if (dcd) {
1593
1594	CHAR s = (CHAR ) mp1, p, pp; // filename[CCHMAXPATH];
1595	WAITCHILD *WaitChild;
1596
1597	WaitChild = xmallocz(sizeof(WAITCHILD), pszSrcFile, __LINE__);
1598	WaitChild->pszCmdLine = xmallocz(MaxComLineStrg, pszSrcFile, __LINE__);
1599	if (!WaitChild)
1600	return 0;
1601	if (s) {
1602	if (!dcd->info->extract) {
1603	Runtime_Error(pszSrcFile, __LINE__, "no extract");
1604	free(s);
1605	return 0;
1606	}
1607	sprintf(WaitChild->pszCmdLine, "%s %s %s",
1608	dcd->info->exwdirs ? dcd->info->exwdirs :
1609	dcd->info->extract,
1610	BldQuotedFileName(szQuotedArcName, dcd->arcname),
1611	BldQuotedFileName(szQuotedMemberName, s));
1612	if (!dcd->info->exwdirs) {
1613	p = s;
1614	p = strrchr(s, '\\');
1615	pp = strrchr(s, '/');
1616	if (p && pp)
1617	p = max(p, pp);
1618	else if (!p)
1619	p = pp;
1620	if (p)
1621	memmove(s, p + 1, strlen(p + 1));
1622	}
1623	sprintf(WaitChild->filename, "%s\\%s", dcd->workdir, s);
1624	ForwardslashToBackslash(WaitChild->filename);
1625	free(s);
1626	WaitChild->RunFlags = SEPARATE \| ASYNCHRONOUS \| WAIT \|
1627	(fArcStuffVisible ? 0 : BACKGROUND);
1628	WaitChild->hwndClient = dcd->hwndClient;
1629	WaitChild->msg = UM_ENTER;
1630	WaitChild->uiLineNumber = __LINE__;
1631	WaitChild->pszSrcFile = pszSrcFile;
1632	WaitChild->pszDirectory = xstrdup(dcd->workdir, pszSrcFile, __LINE__);
1633	WaitChild->pszEnvironment = NULL;
1634	strcpy(WaitChild->formatstring, "%s");
1635	WaitChild->hwndCnr = dcd->hwndCnr;
1636	xbeginthread(WaitChildThread,
1637	65536,
1638	WaitChild,
1639	pszSrcFile,
1640	__LINE__);
1641	}
1642	}
1643	return 0;
1644
1645	case UM_COMMAND:
1646	if (mp1) {
1647	if (PostMsg(hwnd, UM_ACTION, mp1, mp2))
1648	return (MRESULT) TRUE;
1649	}
1650	return 0;
1651
1652	case UM_ACTION:
1653	DosError(FERR_DISABLEHARDERR);
1654	dcd = WinQueryWindowPtr(hwnd, QWL_USER);
1655	if (dcd) {
1656
1657	LISTINFO li = (LISTINFO ) mp1;
1658	register INT x;
1659
1660	if (li && li->list && li->list[0]) {
1661	// printf("%x/r", li->type); fflush(stdout); // 24 Sep 08 SHL
1662	switch (li->type) {
1663	case IDM_ARCHIVE:
1664	case IDM_ARCHIVEM:
1665	{
1666	DIRCNRDATA ad;
1667	CHAR szBuffer[1025], *p;
1668
1669	if (!li->list[1] && !stricmp(li->list[0], dcd->arcname)) {
1670	Runtime_Error(pszSrcFile, __LINE__, "arc to self");
1671	break;
1672	}
1673	ad = *dcd;
1674	ad.namecanchange = 0;
1675	ad.fmoving = (li->type == IDM_ARCHIVEM);
1676	if (!WinDlgBox(HWND_DESKTOP, dcd->hwndClient, ArchiveDlgProc,
1677	FM3ModHandle, ARCH_FRAME, (PVOID) & ad) \|\| !*ad.arcname \|\|
1678	!*ad.command) // we blew it
1679	break;
1680	// build the sucker
1681	strcpy(szBuffer, ad.command);
1682	strcat(szBuffer, " ");
1683
1684	BldQuotedFileName(szBuffer + strlen(szBuffer), ad.arcname);
1685
1686	p = &szBuffer[strlen(szBuffer)]; // Remeber where archiver name ends
1687
1688	if (ad.mask.szMask) {
1689	strcat(szBuffer, " ");
1690
1691	BldQuotedFileName(szBuffer + strlen(szBuffer), ad.mask.szMask);
1692	}
1693	strcat(szBuffer, " ");
1694	x = 0;
1695
1696	// Run commands avoiding command line overflow
1697	while (li->list[x]) {
1698
1699	if (IsFile(li->list[x]))
1700	BldQuotedFileName(szBuffer + strlen(szBuffer), li->list[x]);
1701	else
1702	BldQuotedFullPathName(szBuffer + strlen(szBuffer), li->list[x], "*");
1703
1704	x++;
1705	if (!li->list[x] \|\| strlen(szBuffer) +
1706	strlen(li->list[x]) + 5 > MaxComLineStrg) {
1707	runemf2(SEPARATE \| WINDOWED \| ASYNCHRONOUS \|
1708	(fArcStuffVisible ? 0 : BACKGROUND \| MINIMIZED),
1709	hwnd, pszSrcFile, __LINE__,
1710	NULL, NULL, "%s", szBuffer);
1711	*p = 0;
1712	}
1713	strcat(szBuffer, " ");
1714	} // while
1715
1716	PostMsg(dcd->hwndCnr, UM_RESCAN, MPFROMSHORT(1), MPVOID);
1717	Broadcast(WinQueryAnchorBlock(hwnd),
1718	hwndMain, UM_UPDATERECORD, MPFROMP(ad.arcname), MPVOID);
1719	Broadcast(WinQueryAnchorBlock(hwnd),
1720	hwndMain,
1721	UM_UPDATERECORDLIST, MPFROMP(li->list), MPVOID);
1722	}
1723	break;
1724
1725	case IDM_REFRESH:
1726	case IDM_DELETE:
1727	{
1728	CHAR *endofit;
1729	PSZ pszCmdLine;
1730	INT z;
1731	CHECKLIST ck;
1732	CHAR prompt[CCHMAXPATH + 257];
1733
1734	if (!dcd->info->delete)
1735	break;
1736	memset(&ck, 0, sizeof(ck));
1737	ck.size = sizeof(ck);
1738	ck.list = li->list;
1739	ck.cmd = li->type;
1740	ck.prompt = prompt;
1741	ck.flags = CHECK_ARCHIVE;
1742	sprintf(prompt, GetPString(IDS_ARCCNRDELREFTEXT),
1743	(li->type == IDM_DELETE) ?
1744	GetPString(IDS_DELETELOWERTEXT) :
1745	GetPString(IDS_REFRESHLOWERTEXT),
1746	&"s"[li->list[1] == NULL],
1747	dcd->arcname,
1748	(li->type == IDM_DELETE) ?
1749	GetPString(IDS_DELETELOWERTEXT) :
1750	GetPString(IDS_REFRESHLOWERTEXT));
1751	if (!WinDlgBox(HWND_DESKTOP, hwnd, CheckListProc,
1752	FM3ModHandle, CHECK_FRAME, MPFROMP(&ck)))
1753	break;
1754	li->list = ck.list;
1755	if (!li->list \|\| !li->list[0])
1756	break;
1757	pszCmdLine = xmallocz(MaxComLineStrg, pszSrcFile, __LINE__);
1758	if (!pszCmdLine)
1759	break;
1760	strcpy(pszCmdLine, li->type == IDM_DELETE ?
1761	dcd->info->delete :
1762	dcd->info->create);
1763	strcat(pszCmdLine, " ");
1764	BldQuotedFileName(pszCmdLine + strlen(pszCmdLine), dcd->arcname);
1765	endofit = &pszCmdLine[strlen(pszCmdLine)];
1766	z = 0;
1767	do {
1768	for (x = z; li->list[x] &&
1769	strlen(pszCmdLine) + strlen(li->list[x]) < 999; x++) {
1770	strcat(pszCmdLine, " ");
1771	BldQuotedFileName(pszCmdLine + strlen(pszCmdLine), li->list[x]);
1772	}
1773	z = x;
1774	runemf2(SEPARATE \| WINDOWED \| ASYNCHRONOUS \| WAIT \|
1775	(fArcStuffVisible ? 0 : BACKGROUND \| MINIMIZED),
1776	hwnd, pszSrcFile, __LINE__, NullStr, NULL, "%s", pszCmdLine);
1777	*endofit = 0;
1778	free(pszCmdLine);
1779	} while (li->list[x]);
1780	PostMsg(dcd->hwndCnr, UM_RESCAN, MPFROMSHORT(1), MPVOID);
1781	Broadcast(WinQueryAnchorBlock(hwnd),
1782	hwndMain,
1783	UM_UPDATERECORD, MPFROMP(dcd->arcname), MPVOID);
1784	}
1785	break;
1786
1787	case IDM_PRINT:
1788	case IDM_VIRUSSCAN:
1789	case IDM_VIEW:
1790	case IDM_MCIPLAY:
1791	case IDM_VIEWARCHIVE:
1792	case IDM_VIEWTEXT:
1793	case IDM_VIEWBINARY:
1794	case IDM_EDIT:
1795	case IDM_EDITTEXT:
1796	case IDM_EDITBINARY:
1797	case IDM_EXEC:
1798	case IDM_EXTRACTWDIRS:
1799	case IDM_EXTRACT:
1800	case IDM_OPENDEFAULT:
1801	case IDM_OPENSETTINGS:
1802	{
1803	CHAR endofit, ptr;
1804	PSZ pszCmdLine;
1805	INT z;
1806	if ((li->type == IDM_EXTRACT && !li->info->extract) \|\|
1807	((li->type == IDM_VIEW \|\| li->type == IDM_VIEWTEXT \|\|
1808	li->type == IDM_VIEWBINARY \|\| li->type == IDM_EDIT \|\|
1809	li->type == IDM_VIEWARCHIVE \|\| li->type == IDM_EDITTEXT \|\|
1810	li->type == IDM_EDITBINARY \|\| li->type == IDM_MCIPLAY) &&
1811	(!li->info->extract && !li->info->exwdirs)) \|\|
1812	(li->type != IDM_EXTRACT && li->type != IDM_EDIT &&
1813	li->type != IDM_VIEW && li->type != IDM_VIEWTEXT &&
1814	li->type != IDM_VIEWBINARY &&
1815	li->type != IDM_VIEWARCHIVE &&
1816	li->type != IDM_EDITTEXT &&
1817	li->type != IDM_EDITBINARY &&
1818	li->type != IDM_MCIPLAY && !li->info->exwdirs)) {
1819	Runtime_Error(pszSrcFile, __LINE__, "no cmd for request");
1820	break;
1821	}
1822	if (li->type == IDM_EXTRACT \|\| li->type == IDM_EXTRACTWDIRS) {
1823
1824	CHAR fullname[CCHMAXPATH * 2];
1825	CHAR **exfiles = NULL;
1826	UINT numfiles = 0, numalloc = 0;
1827
1828	if (li->targetpath && fFileNameCnrPath &&
1829	stricmp(lastextractpath, li->targetpath)) {
1830	strcpy(lastextractpath, li->targetpath);
1831	SetDir(dcd->hwndParent, hwnd, li->targetpath, 1);
1832	}
1833	for (x = 0; li->list[x]; x++) {
1834	BldFullPathName(fullname, li->targetpath, li->list[x]);
1835	//Check if file already exists on disk warn if it does.
1836	if (IsFile(fullname) != -1) {
1837	AddToList(li->list[x], &exfiles, &numfiles, &numalloc);
1838	li->list = RemoveFromList(li->list, li->list[x]);
1839	if (!li->list)
1840	break;
1841	x--;
1842	}
1843	}
1844	if (exfiles && numfiles) {
1845
1846	CHECKLIST ckl;
1847	CHAR prompt[(CCHMAXPATH * 2) + 256];
1848
1849	memset(&ckl, 0, sizeof(ckl));
1850	ckl.size = sizeof(ckl);
1851	ckl.list = exfiles;
1852	ckl.prompt = prompt;
1853	ckl.cmd = li->type;
1854	ckl.flags = CHECK_ARCHIVE;
1855	sprintf(prompt,
1856	GetPString(IDS_REPLACEWARNTEXT),
1857	&"s"[numfiles == 1],
1858	li->arcname, &"s"[numfiles != 1], li->targetpath);
1859	if (!WinDlgBox(HWND_DESKTOP, hwnd, CheckListProc,
1860	FM3ModHandle, CHECK_FRAME, MPFROMP(&ckl))) {
1861	if (ckl.list)
1862	FreeList(ckl.list);
1863	break;
1864	}
1865	else if (ckl.list)
1866	li->list = CombineLists(li->list, ckl.list);
1867	} // end check and warn
1868	}
1869	if (!li->list \|\| !li->list[0])
1870	break;
1871	pszCmdLine = xmallocz(MaxComLineStrg, pszSrcFile, __LINE__);
1872	if (!pszCmdLine)
1873	break;
1874	strcpy(pszCmdLine,
1875	(li->type == IDM_EXTRACT \|\|
1876	((li->type == IDM_VIEW \|\|
1877	li->type == IDM_VIEWTEXT \|\|
1878	li->type == IDM_VIEWBINARY \|\|
1879	li->type == IDM_VIEWARCHIVE \|\|
1880	li->type == IDM_PRINT \|\|
1881	li->type == IDM_EDIT \|\|
1882	li->type == IDM_EDITTEXT \|\|
1883	li->type == IDM_OPENDEFAULT \|\|
1884	li->type == IDM_OPENSETTINGS \|\|
1885	(li->type == IDM_EDITBINARY && // JBS No way for this () to be true??
1886	li->type == IDM_MCIPLAY)) &&
1887	!li->info->exwdirs)) ?
1888	li->info->extract :
1889	li->info->exwdirs);
1890	strcat(pszCmdLine, " ");
1891	BldQuotedFileName(pszCmdLine + strlen(pszCmdLine), li->arcname);
1892	endofit = &pszCmdLine[strlen(pszCmdLine)];
1893	z = 0;
1894	do {
1895	for (x = z; li->list[x] &&
1896	strlen(pszCmdLine) + strlen(li->list[x]) < MaxComLineStrg - 1 ; x++) {
1897	strcat(pszCmdLine, " ");
1898	BldQuotedFileName(pszCmdLine + strlen(pszCmdLine), li->list[x]);
1899	ptr = li->list[x];
1900	while (*ptr) {
1901	if (*ptr == '/')
1902	*ptr = '\\';
1903	ptr++;
1904	}
1905	}
1906	z = x;
1907	runemf2(SEPARATE \| WINDOWED \| WAIT \|
1908	(fArcStuffVisible ? 0 : BACKGROUND \| MINIMIZED),
1909	hwnd, pszSrcFile, __LINE__,
1910	li->targetpath, NULL, "%s", pszCmdLine);
1911	*endofit = 0;
1912	} while (li->list[x]);
1913	if (li->type == IDM_EXTRACT \|\| li->type == IDM_EXTRACTWDIRS) {
1914	// update windows
1915	for (x = 0; li->list[x]; x++) {
1916
1917	CHAR temp, p;
1918
1919	temp = li->list[x];
1920	ForwardslashToBackslash(temp);
1921	p = xmalloc(strlen(temp) + strlen(li->targetpath) + 2,
1922	pszSrcFile, __LINE__);
1923	if (p) {
1924	BldFullPathName(p, li->targetpath, temp);
1925	li->list[x] = p;
1926	free(temp);
1927	}
1928	}
1929	if (fFolderAfterExtract) {
1930
1931	CHAR objectpath[CCHMAXPATH], *p;
1932	APIRET rc;
1933
1934	GetDesktopName(objectpath, sizeof(objectpath));
1935	rc = WinDlgBox(HWND_DESKTOP, dcd->hwndParent, ObjCnrDlgProc,
1936	FM3ModHandle, OBJCNR_FRAME,
1937	MPFROMP(objectpath));
1938	if (rc) {
1939	if (rc > 1)
1940	strcpy(objectpath, "<WP_DESKTOP>");
1941	p = NULL;
1942	if (li->arcname) {
1943	p = strrchr(li->arcname, '\\');
1944	if (p)
1945	p++;
1946	}
1947	MakeShadows(dcd->hwndParent, li->list, 2, objectpath, p);
1948	}
1949	}
1950	Broadcast(WinQueryAnchorBlock(hwnd),
1951	hwndMain,
1952	UM_UPDATERECORDLIST, MPFROMP(li->list), MPVOID);
1953	}
1954	else if (li->type == IDM_EXEC)
1955	ExecOnList(hwnd,
1956	li->runfile,
1957	WINDOWED \| SEPARATEKEEP \| PROMPT,
1958	li->targetpath, NULL, NULL, GetPString(IDS_EXECARCFILETITLETEXT),
1959	pszSrcFile, __LINE__);
1960	else if (li->type == IDM_VIRUSSCAN)
1961	ExecOnList(hwnd, virus, PROMPT \| WINDOWED \| SEPARATEKEEP,
1962	li->targetpath, NULL, NULL,
1963	GetPString(IDS_VIRUSSCANARCHIVETITLETEXT),
1964	pszSrcFile, __LINE__);
1965	else if (li->type == IDM_VIEW \|\| li->type == IDM_VIEWTEXT \|\|
1966	li->type == IDM_VIEWBINARY \|\| li->type == IDM_EDIT \|\|
1967	li->type == IDM_EDITTEXT \|\|
1968	li->type == IDM_VIEWARCHIVE \|\|
1969	li->type == IDM_EDITBINARY \|\|
1970	li->type == IDM_OPENDEFAULT \|\|
1971	li->type == IDM_OPENSETTINGS \|\|
1972	li->type == IDM_MCIPLAY \|\| li->type == IDM_PRINT) {
1973
1974	CHAR temp, p;
1975	for (x = 0; li->list[x]; x++) {
1976	if (!li->info->exwdirs) {
1977	temp = li->list[x];
1978	p = strrchr(li->list[x], '\\');
1979	if (p) {
1980	p++;
1981	li->list[x] = xstrdup(p, pszSrcFile, __LINE__);
1982	if (!li->list[x])
1983	li->list[x] = temp;
1984	else {
1985	xfree(temp, pszSrcFile, __LINE__);
1986	}
1987	}
1988	}
1989	BldFullPathName(pszCmdLine, li->targetpath, li->list[x]);
1990	temp = li->list[x];
1991	li->list[x] = xstrdup(pszCmdLine, pszSrcFile, __LINE__);
1992	if (!li->list[x])
1993	li->list[x] = temp;
1994	else
1995	xfree(temp, pszSrcFile, __LINE__);
1996	}
1997	free(pszCmdLine);
1998	if (li->type == IDM_VIEW \|\| li->type == IDM_EDIT) {
1999
2000	BOOL isit = TestBinary(li->list[0]);
2001
2002	if (isit) {
2003	if (li->type == IDM_VIEW)
2004	li->type = IDM_VIEWBINARY;
2005	else
2006	li->type = IDM_EDITBINARY;
2007	}
2008	else {
2009	if (li->type == IDM_VIEW)
2010	li->type = IDM_VIEWTEXT;
2011	else
2012	li->type = IDM_EDITTEXT;
2013	}
2014	}
2015	if (li->type == IDM_MCIPLAY) {
2016
2017	FILE *fp;
2018	CHAR szTempFile[CCHMAXPATH];
2019	CHAR *modew = "w";
2020
2021	if (pTmpDir && !IsValidDir(pTmpDir))
2022	DosCreateDir(pTmpDir, 0);
2023	BldFullPathName(szTempFile, pTmpDir, PCSZ_FM2PLAYTEMP);
2024	fp = xfopen(szTempFile, modew, pszSrcFile, __LINE__, FALSE);
2025	if (fp) {
2026	fprintf(fp, "%s", ";AV/2-built FM2Play listfile\n");
2027	for (x = 0; li->list[x]; x++)
2028	fprintf(fp, "%s\n", li->list[x]);
2029	fprintf(fp, ";end\n");
2030	fclose(fp);
2031	strrev(szTempFile);
2032	strcat(szTempFile, "@/");
2033	strrev(szTempFile);
2034	RunFM2Util(PCSZ_FM2PLAYEXE, szTempFile);
2035	}
2036	}
2037	else if (li->type == IDM_PRINT) {
2038	strcpy(li->targetpath, printer);
2039	// 10 Dec 08 SHL correct error handling - looked backward
2040	if (xbeginthread(PrintListThread,
2041	65536,
2042	li,
2043	pszSrcFile,
2044	__LINE__) != -1)
2045	{
2046	li = NULL; // Ensure not freed here
2047	}
2048
2049	}
2050	else if (li->type == IDM_VIEWARCHIVE) {
2051
2052	ARC_TYPE *info;
2053
2054	for (x = 0; li->list[x]; x++) {
2055	if (IsFile(li->list[x]) == 1) {
2056	info = NULL; // Do not hide dups - fixme to know why?
2057	if (WinDlgBox(HWND_DESKTOP, HWND_DESKTOP,
2058	SBoxDlgProc, FM3ModHandle, ASEL_FRAME,
2059	(PVOID) & info) && info) {
2060	StartArcCnr(HWND_DESKTOP,
2061	HWND_DESKTOP, li->list[x], 4, info);
2062	}
2063	}
2064	}
2065	}
2066	else if ((li->type == IDM_VIEWTEXT && *viewer) \|\|
2067	(li->type == IDM_VIEWBINARY && *binview) \|\|
2068	(li->type == IDM_EDITTEXT && *editor) \|\|
2069	(li->type == IDM_EDITBINARY && *bined)) {
2070	//DosSleep(32); // Added WAIT to runemf2 12-12-08 GKY
2071	ExecOnList(hwnd, ((li->type == IDM_VIEWTEXT) ? viewer :
2072	(li->type == IDM_VIEWBINARY) ? binview :
2073	(li->type == IDM_EDITTEXT) ? editor :
2074	bined),
2075	WINDOWED \| SEPARATE, NULL, NULL, // li->targetpath,
2076	li->list,
2077	NULL, pszSrcFile, __LINE__);
2078	}
2079	else if (li->type == IDM_OPENDEFAULT \|\|
2080	li->type == IDM_OPENSETTINGS) {
2081	WORKER *wk;
2082	# ifdef FORTIFY
2083	Fortify_EnterScope();
2084	# endif
2085	wk = xmallocz(sizeof(WORKER), pszSrcFile, __LINE__);
2086	if (!wk)
2087	FreeListInfo(li);
2088	else {
2089	wk->size = sizeof(WORKER);
2090	wk->hwndCnr = dcd->hwndCnr;
2091	wk->hwndParent = dcd->hwndParent;
2092	wk->hwndFrame = dcd->hwndFrame;
2093	wk->hwndClient = dcd->hwndClient;
2094	wk->li = li;
2095	strcpy(wk->directory, dcd->directory);
2096	if (xbeginthread(Action,
2097	122880,
2098	wk,
2099	pszSrcFile,
2100	__LINE__) == -1)
2101	{
2102	free(wk);
2103	FreeListInfo((LISTINFO *) mp1);
2104	}
2105	}
2106	# ifdef FORTIFY
2107	Fortify_LeaveScope();
2108	# endif
2109	}
2110	else {
2111	if (li->hwnd) {
2112
2113	ULONG viewtype;
2114
2115	for (x = 0; li->list[x]; x++) {
2116	if (x == 0) {
2117	if (li->type == IDM_VIEWBINARY \|\|
2118	li->type == IDM_EDITBINARY)
2119	viewtype = 16;
2120	else
2121	viewtype = 8;
2122	}
2123	else
2124	viewtype = 0;
2125	# ifdef FORTIFY
2126	Fortify_EnterScope();
2127	# endif
2128	temp = xstrdup(li->list[x], pszSrcFile, __LINE__);
2129	if (temp) {
2130	if (!PostMsg(WinQueryWindow(li->hwnd, QW_PARENT),
2131	UM_LOADFILE,
2132	MPFROMLONG(4L +
2133	(li->type == IDM_VIEWTEXT \|\|
2134	li->type == IDM_VIEWBINARY) +
2135	viewtype), MPFROMP(temp)))
2136	free(temp);
2137	}
2138	# ifdef FORTIFY
2139	DosSleep(1); // Allow MassAction to take ownership
2140	Fortify_LeaveScope();
2141	# endif
2142	}
2143	}
2144	}
2145	}
2146	}
2147	break;
2148
2149	case IDM_FIND:
2150	{
2151	UINT numfiles = 0, numalloced = 0;
2152	CHAR *list2 = NULL, fullname[CCHMAXPATH 2], *p;
2153
2154	for (x = 0; li->list[x]; x++) {
2155	ForwardslashToBackslash(li->list[x]);
2156	BldFullPathName(fullname, dcd->directory, li->list[x]);
2157	if (IsFile(fullname) != -1)
2158	if (AddToList(fullname, &list2, &numfiles, &numalloced))
2159	break;
2160	if (strchr(li->list[x], '\\')) {
2161	p = strrchr(li->list[x], '\\');
2162	if (p) {
2163	p++;
2164	if (*p) {
2165	BldFullPathName(fullname, dcd->directory, p);
2166	if (IsFile(fullname) != -1)
2167	if (AddToList(fullname, &list2, &numfiles, &numalloced))
2168	break;
2169	}
2170	}
2171	}
2172	}
2173	if (!numfiles \|\| !list2)
2174	Runtime_Error(pszSrcFile, __LINE__, "no files or list");
2175	else {
2176	WinSendMsg(dcd->hwndCnr, WM_COMMAND,
2177	MPFROM2SHORT(IDM_COLLECTOR, 0), MPVOID);
2178	DosSleep(10); //05 Aug 07 GKY 128
2179	if (Collector) {
2180	if (!PostMsg(Collector, WM_COMMAND,
2181	MPFROM2SHORT(IDM_COLLECTOR, 0), MPFROMP(list2)))
2182	FreeList(list2);
2183	}
2184	else
2185	FreeList(list2);
2186	}
2187	}
2188	break;
2189	} // switch
2190	}
2191	if (li->type != IDM_OPENDEFAULT && li->type != IDM_OPENSETTINGS)
2192	{
2193	FreeListInfo(li);
2194	}
2195	}
2196	return 0;
2197
2198	case WM_CLOSE:
2199	WinDestroyWindow(hwnd);
2200	break;
2201
2202	case WM_DESTROY:
2203	dcd = WinQueryWindowPtr(hwnd, QWL_USER);
2204	if (dcd) {
2205	if (*dcd->workdir) {
2206	DosSleep(16); //05 Aug 07 GKY 33
2207	wipeallf("%s\\*", dcd->workdir);
2208	if (rmdir(dcd->workdir)) {
2209	DosSleep(100); //05 Aug 07 GKY 256
2210	wipeallf("%s\\*", dcd->workdir);
2211	rmdir(dcd->workdir);
2212	}
2213	}
2214	FreeList(dcd->lastselection);
2215	WinSendMsg(dcd->hwndCnr, UM_CLOSE, MPVOID, MPVOID);
2216	WinSetWindowPtr(dcd->hwndCnr, QWL_USER, NULL); // 13 Apr 10 SHL Set NULL before freeing dcd
2217	free(dcd);
2218	# ifdef FORTIFY
2219	Fortify_LeaveScope();
2220	# endif
2221	}
2222	if (!PostMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID))
2223	WinSendMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID);
2224	break;
2225	} // switch
2226	return WinDefWindowProc(hwnd, msg, mp1, mp2);
2227	}
2228
2229	static MRESULT EXPENTRY ArcCnrWndProc(HWND hwnd, ULONG msg, MPARAM mp1,
2230	MPARAM mp2)
2231	{
2232	DIRCNRDATA *dcd = INSTDATA(hwnd);
2233	CHAR szQuotedArcName[CCHMAXPATH];
2234
2235	switch (msg) {
2236	case DM_PRINTOBJECT:
2237	case DM_DISCARDOBJECT:
2238	if (dcd)
2239	return WinSendMsg(dcd->hwndObject, msg, mp1, mp2);
2240	else
2241	return MRFROMLONG(DRR_TARGET);
2242
2243	case WM_CHAR:
2244	shiftstate = (SHORT1FROMMP(mp1) & (KC_SHIFT \| KC_ALT \| KC_CTRL));
2245	if (SHORT1FROMMP(mp1) & KC_KEYUP)
2246	return (MRESULT)TRUE;
2247	if (SHORT1FROMMP(mp1) & KC_VIRTUALKEY) {
2248	switch (SHORT2FROMMP(mp2)) {
2249	case VK_DELETE:
2250	PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_DELETE, 0), MPVOID);
2251	break;
2252	}
2253	}
2254
2255	if (SearchContainer(hwnd, msg, mp1, mp2))
2256	return (MRESULT)TRUE; // Avoid default handler
2257	break; // Let default handler see key too
2258
2259	case WM_MOUSEMOVE:
2260	case WM_BUTTON1UP:
2261	case WM_BUTTON2UP:
2262	case WM_BUTTON3UP:
2263	case WM_CHORD:
2264	shiftstate = (SHORT2FROMMP(mp2) & (KC_SHIFT \| KC_ALT \| KC_CTRL));
2265	break;
2266
2267	case WM_BUTTON1MOTIONEND:
2268	{
2269	CNRINFO cnri;
2270
2271	memset(&cnri, 0, sizeof(CNRINFO));
2272	cnri.cb = sizeof(CNRINFO);
2273	if (WinSendMsg(hwnd,
2274	CM_QUERYCNRINFO,
2275	MPFROMP(&cnri), MPFROMLONG(sizeof(CNRINFO)))) {
2276	if (cnri.flWindowAttr & CV_DETAIL)
2277	PrfWriteProfileData(fmprof,
2278	appname,
2279	"ArcCnrSplitBar",
2280	(PVOID) & cnri.xVertSplitbar, sizeof(LONG));
2281	}
2282	}
2283	break;
2284
2285	case WM_PRESPARAMCHANGED:
2286	PresParamChanged(hwnd, PCSZ_ARCCNR, mp1, mp2);
2287	break;
2288
2289	case UM_UPDATERECORD:
2290	case UM_UPDATERECORDLIST:
2291	if (dcd && !IsArcThere(hwnd, dcd->arcname))
2292	PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
2293	return 0;
2294
2295	case WM_SETFOCUS:
2296	/**
2297	* put name of our window (archive name) on status line
2298	*/
2299	if (dcd && hwndStatus && mp2)
2300	PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
2301	break;
2302
2303	case UM_SETUP2:
2304	if (dcd && dcd->info) {
2305	if (dcd->info->fdpos == -1 \|\| !dcd->info->datetype)
2306	dcd->sortFlags &= (~SORT_LWDATE);
2307	if (dcd->info->nsizepos == -1)
2308	dcd->sortFlags &= (~SORT_EASIZE);
2309	if (dcd->info->osizepos == -1)
2310	dcd->sortFlags &= (~SORT_SIZE);
2311	AdjustCnrColVis(hwnd,
2312	GetPString(IDS_OLDSIZECOLTEXT),
2313	dcd->info->osizepos != -1, FALSE);
2314	AdjustCnrColVis(hwnd,
2315	GetPString(IDS_NEWSIZECOLTEXT),
2316	dcd->info->nsizepos != -1, FALSE);
2317	// Display unsullied date/time string if type 0
2318	AdjustCnrColVis(hwnd,
2319	GetPString(IDS_DATETIMECOLTEXT),
2320	dcd->info->fdpos != -1 && !dcd->info->datetype, FALSE);
2321	// Display parsed date/time columns if type specified
2322	AdjustCnrColVis(hwnd,
2323	GetPString(IDS_TIMECOLTEXT),
2324	dcd->info->fdpos != -1 && dcd->info->datetype, FALSE);
2325	AdjustCnrColVis(hwnd,
2326	GetPString(IDS_DATECOLTEXT),
2327	dcd->info->fdpos != -1 && dcd->info->datetype, FALSE);
2328	WinSendMsg(hwnd, CM_INVALIDATEDETAILFIELDINFO, MPVOID, MPVOID);
2329	}
2330	return 0;
2331
2332	case UM_RESCAN:
2333	if (dcd) {
2334	CNRINFO cnri;
2335	CHAR s[CCHMAXPATH * 2], tb[81], tf[81];
2336	PARCITEM pci;
2337
2338	if (mp1) {
2339	PostMsg(dcd->hwndObject, UM_RESCAN, MPVOID, MPVOID);
2340	return 0;
2341	}
2342	memset(&cnri, 0, sizeof(CNRINFO));
2343	cnri.cb = sizeof(CNRINFO);
2344	WinSendMsg(hwnd,
2345	CM_QUERYCNRINFO,
2346	MPFROMP(&cnri), MPFROMLONG(sizeof(CNRINFO)));
2347	dcd->totalfiles = cnri.cRecords;
2348	commafmt(tf, sizeof(tf), dcd->selectedfiles);
2349	if (dcd->ullTotalBytes)
2350	CommaFmtULL(tb, sizeof(tb), dcd->selectedbytes, 'K');
2351	else
2352	*tb = 0;
2353	sprintf(s, "%s%s%s", tf, *tb ? " / " : NullStr, tb);
2354	WinSetDlgItemText(dcd->hwndClient, DIR_SELECTED, s);
2355	commafmt(tf, sizeof(tf), dcd->totalfiles);
2356	if (dcd->ullTotalBytes)
2357	CommaFmtULL(tb, sizeof(tb), dcd->ullTotalBytes, 'K');
2358	else
2359	*tb = 0;
2360	sprintf(s, "%s%s%s", tf, *tb ? " / " : NullStr, tb);
2361	WinSetDlgItemText(dcd->hwndClient, DIR_TOTALS, s);
2362	if (hwndStatus &&
2363	dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent)) {
2364	sprintf(s, " [%s%s%s]%s%s%s %s",
2365	tf,
2366	*tb ? " / " : NullStr,
2367	tb,
2368	*dcd->mask.szMask ? " (" : NullStr,
2369	*dcd->mask.szMask ? dcd->mask.szMask : NullStr,
2370	*dcd->mask.szMask ? ")" : NullStr, dcd->arcname);
2371	WinSetWindowText(hwndStatus, s);
2372	if (!ParentIsDesktop(hwnd, dcd->hwndParent)) {
2373	pci = WinSendMsg(hwnd,
2374	CM_QUERYRECORDEMPHASIS,
2375	MPFROMLONG(CMA_FIRST), MPFROMSHORT(CRA_CURSORED));
2376	if (pci && (INT) pci != -1) {
2377	if (fSplitStatus && hwndStatus2) {
2378	if (dcd->ullTotalBytes)
2379	CommaFmtULL(tb, sizeof(tb), pci->cbFile, ' ');
2380	else
2381	*tb = 0;
2382	sprintf(s, "%s%s%s%s",
2383	*tb ? " " : NullStr,
2384	tb, *tb ? " " : NullStr, pci->pszFileName);
2385	WinSetWindowText(hwndStatus2, s);
2386	}
2387	if (fMoreButtons)
2388	WinSetWindowText(hwndName, pci->pszFileName);
2389	}
2390	else {
2391	WinSetWindowText(hwndStatus2, NullStr);
2392	WinSetWindowText(hwndName, NullStr);
2393	}
2394	WinSetWindowText(hwndDate, NullStr);
2395	WinSetWindowText(hwndAttr, NullStr);
2396	}
2397	}
2398	if ((dcd->arcfilled && !dcd->totalfiles) \|\|
2399	!IsArcThere(hwnd, dcd->arcname))
2400	PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
2401	}
2402	return 0;
2403
2404	case UM_SETUP:
2405	if (!dcd) {
2406	Runtime_Error(pszSrcFile, __LINE__, NULL);
2407	PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
2408	return 0;
2409	}
2410	else {
2411	if (!dcd->hwndObject) {
2412	/**
2413	* first time through -- set things up
2414	*/
2415	{
2416	CHAR p, pp;
2417	ULONG z, was;
2418	APIRET rc;
2419
2420	rc = DosCreateDir(dcd->workdir, 0);
2421	if (rc) {
2422	if (rc == ERROR_ACCESS_DENIED) {
2423	p = strrchr(dcd->workdir, '.');
2424	if (p) {
2425	p++;
2426	pp = p;
2427	was = strtoul(p, &pp, 16);
2428	for (z = 0; z < 99; z++) {
2429	was++;
2430	sprintf(p, "%03x");
2431	rc = DosCreateDir(dcd->workdir, 0);
2432	if (!rc \|\| rc != ERROR_ACCESS_DENIED)
2433	break;
2434	}
2435	}
2436	}
2437	if (rc)
2438	PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
2439	return 0;
2440	}
2441	}
2442	RestorePresParams(hwnd, PCSZ_ARCCNR);
2443	dcd->mask.fNoAttribs = TRUE;
2444	dcd->mask.fNoDirs = TRUE;
2445	*dcd->mask.prompt = 0;
2446	{
2447	PFIELDINFO pfi, pfiLastLeftCol;
2448	ULONG numcols = CON_COLS;
2449	CNRINFO cnri;
2450	ULONG size;
2451
2452	pfi = WinSendMsg(hwnd,
2453	CM_ALLOCDETAILFIELDINFO,
2454	MPFROMLONG(numcols), NULL);
2455	if (pfi) {
2456
2457	PFIELDINFO pfiFirst;
2458	FIELDINFOINSERT fii;
2459
2460	pfiFirst = pfi;
2461	pfi->flData = CFA_STRING \| CFA_LEFT \| CFA_FIREADONLY;
2462	pfi->flTitle = CFA_CENTER;
2463	pfi->pTitleData = (PSZ)GetPString(IDS_FILENAMECOLTEXT);
2464	pfi->offStruct = FIELDOFFSET(ARCITEM, pszDisplayName);
2465	pfiLastLeftCol = pfi;
2466	pfi = pfi->pNextFieldInfo;
2467	pfi->flData =
2468	CFA_ULONG \| CFA_RIGHT \| CFA_SEPARATOR \| CFA_FIREADONLY;
2469	pfi->flTitle = CFA_CENTER;
2470	pfi->pTitleData = (PSZ)GetPString(IDS_OLDSIZECOLTEXT);
2471	pfi->offStruct = FIELDOFFSET(ARCITEM, cbFile);
2472	pfi = pfi->pNextFieldInfo;
2473	pfi->flData =
2474	CFA_ULONG \| CFA_RIGHT \| CFA_SEPARATOR \| CFA_FIREADONLY;
2475	pfi->flTitle = CFA_CENTER;
2476	pfi->pTitleData = (PSZ)GetPString(IDS_NEWSIZECOLTEXT);
2477	pfi->offStruct = FIELDOFFSET(ARCITEM, cbComp);
2478	pfi = pfi->pNextFieldInfo;
2479	pfi->flData =
2480	CFA_STRING \| CFA_CENTER \| CFA_SEPARATOR \| CFA_FIREADONLY;
2481	pfi->flTitle = CFA_CENTER \| CFA_FITITLEREADONLY;
2482	pfi->pTitleData = (PSZ)GetPString(IDS_DATETIMECOLTEXT);
2483	pfi->offStruct = FIELDOFFSET(ARCITEM, pszDate);
2484	pfi = pfi->pNextFieldInfo;
2485	pfi->flData = CFA_DATE \| CFA_RIGHT \| CFA_FIREADONLY;
2486	pfi->flTitle = CFA_CENTER;
2487	pfi->pTitleData = (PSZ)GetPString(IDS_DATECOLTEXT);
2488	pfi->offStruct = FIELDOFFSET(ARCITEM, date);
2489	pfi = pfi->pNextFieldInfo;
2490	pfi->flData = CFA_TIME \| CFA_RIGHT \| CFA_FIREADONLY;
2491	pfi->flTitle = CFA_CENTER \| CFA_FITITLEREADONLY;
2492	pfi->pTitleData = (PSZ)GetPString(IDS_TIMECOLTEXT);
2493	pfi->offStruct = FIELDOFFSET(ARCITEM, time);
2494	memset(&fii, 0, sizeof(FIELDINFOINSERT));
2495	fii.cb = sizeof(FIELDINFOINSERT);
2496	fii.pFieldInfoOrder = (PFIELDINFO) CMA_FIRST;
2497	fii.cFieldInfoInsert = (SHORT) numcols;
2498	fii.fInvalidateFieldInfo = TRUE;
2499	WinSendMsg(hwnd,
2500	CM_INSERTDETAILFIELDINFO,
2501	MPFROMP(pfiFirst), MPFROMP(&fii));
2502	PostMsg(hwnd, UM_SETUP2, MPVOID, MPVOID);
2503
2504	memset(&cnri, 0, sizeof(cnri));
2505	cnri.cb = sizeof(CNRINFO);
2506	cnri.pFieldInfoLast = pfiLastLeftCol;
2507	cnri.xVertSplitbar = DIR_SPLITBAR_OFFSET + 32;
2508
2509	size = sizeof(LONG);
2510	PrfQueryProfileData(fmprof, appname, "ArcCnrSplitBar",
2511	&cnri.xVertSplitbar, &size);
2512	if (cnri.xVertSplitbar <= 0)
2513	cnri.xVertSplitbar = DIR_SPLITBAR_OFFSET + 32;
2514
2515	cnri.flWindowAttr &= (~(CV_ICON \| CV_TREE \| CV_TEXT \| CV_NAME));
2516	cnri.flWindowAttr \|= (CV_DETAIL \| CA_DETAILSVIEWTITLES \| CV_FLOW);
2517	cnri.flWindowAttr &= (~(CA_ORDEREDTARGETEMPH \|
2518	CA_MIXEDTARGETEMPH));
2519	cnri.pSortRecord = (PVOID) ArcSort;
2520	WinSendMsg(hwnd,
2521	CM_SETCNRINFO,
2522	MPFROMP(&cnri),
2523	MPFROMLONG(CMA_PFIELDINFOLAST \|
2524	CMA_XVERTSPLITBAR \|
2525	CMA_PSORTRECORD \| CMA_FLWINDOWATTR));
2526	}
2527	}
2528	WinSendMsg(hwnd, CM_SORTRECORD, MPFROMP(ArcSort), MPFROMP(dcd));
2529	if (xbeginthread(MakeObjWin,
2530	245760,
2531	dcd,
2532	pszSrcFile,
2533	__LINE__) == -1)
2534	{
2535	PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
2536	return 0;
2537	}
2538	else
2539	DosSleep(1);
2540	SayFilter(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
2541	DIR_FILTER), &dcd->mask, TRUE);
2542	SaySort(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
2543	DIR_SORT), dcd->sortFlags, TRUE);
2544	DefArcSortFlags = dcd->sortFlags; // Remember for new windows
2545	}
2546	}
2547	return 0;
2548
2549	case UM_SETDIR:
2550	if (dcd) {
2551
2552	CHAR s[CCHMAXPATH], *p;
2553	ULONG ret = 0;
2554
2555	WinQueryDlgItemText(dcd->hwndClient, ARC_EXTRACTDIR, CCHMAXPATH, s);
2556	bstrip(s);
2557	MakeFullName(s);
2558	if (*s) {
2559	while ((p = strchr(s, '/')) != NULL)
2560	*p = '\\';
2561	while (strlen(s) > 3 && s[strlen(s) - 1] == '\\')
2562	s[strlen(s) - 1] = 0;
2563	if (stricmp(s, dcd->directory)) {
2564	if (IsFullName(s)) {
2565	if (driveflags[toupper(*s) - 'A'] &
2566	(DRIVE_NOTWRITEABLE \| DRIVE_IGNORE \| DRIVE_INVALID)) {
2567	Runtime_Error(pszSrcFile, __LINE__, "drive %s bad", s);
2568	WinSetDlgItemText(dcd->hwndClient,
2569	ARC_EXTRACTDIR, dcd->directory);
2570	return 0;
2571	}
2572	}
2573	if (!SetDir(dcd->hwndParent, hwnd, s, 0)) {
2574	if (stricmp(dcd->directory, s)) {
2575	//DosEnterCritSec(); //GKY 11-29-08
2576	DosRequestMutexSem(hmtxFM2Globals, SEM_INDEFINITE_WAIT);
2577	strcpy(lastextractpath, s);
2578	DosReleaseMutexSem(hmtxFM2Globals);
2579	//DosExitCritSec();
2580	}
2581	strcpy(dcd->directory, s);
2582	if ((!isalpha(s) \|\| s[1] != ':') && s != '.')
2583	saymsg(MB_ENTER \| MB_ICONASTERISK,
2584	hwnd,
2585	GetPString(IDS_WARNINGTEXT),
2586	GetPString(IDS_SPECIFYDRIVETEXT));
2587	}
2588	else
2589	ret = 1;
2590	}
2591	}
2592	WinSetDlgItemText(dcd->hwndClient, ARC_EXTRACTDIR, dcd->directory);
2593	return (MRESULT) ret;
2594	}
2595	return 0;
2596
2597	case UM_ENTER:
2598	if (WinSendMsg(hwnd, UM_SETDIR, MPVOID, MPVOID)) {
2599	free(mp1);
2600	return 0;
2601	}
2602	SetShiftState();
2603	if (dcd && (CHAR *) mp1) {
2604
2605	SWP swp;
2606	CHAR *filename = mp1;
2607	//printf("%s %d UM_ENTER %s\n",__FILE__, __LINE__, filename); fflush(stdout);
2608	if (IsFile(filename) != 1) {
2609	free(mp1);
2610	return 0;
2611	}
2612	WinQueryWindowPos(dcd->hwndFrame, &swp);
2613	DefaultViewKeys(hwnd, dcd->hwndFrame, dcd->hwndParent, &swp, filename);
2614	if (fUnHilite)
2615	UnHilite(hwnd, FALSE, &dcd->lastselection, 0);
2616	}
2617	free(mp1);
2618	return 0;
2619
2620	case WM_MENUEND:
2621	if (dcd) {
2622
2623	HWND hwndMenu = (HWND) mp2;
2624
2625	if (hwndMenu == ArcCnrMenu \|\| hwndMenu == ArcMenu) {
2626	MarkAll(hwnd, TRUE, FALSE, TRUE);
2627	if (dcd->cnremphasized) {
2628	WinSendMsg(hwnd,
2629	CM_SETRECORDEMPHASIS,
2630	MPVOID, MPFROM2SHORT(FALSE, CRA_SOURCE));
2631	dcd->cnremphasized = FALSE;
2632	}
2633	}
2634	}
2635	break;
2636
2637	case MM_PORTHOLEINIT:
2638	if (dcd) {
2639	switch (SHORT1FROMMP(mp1)) {
2640	case 0:
2641	case 1:
2642	{
2643	ULONG wmsg;
2644
2645	wmsg = SHORT1FROMMP(mp1) == 0 ? UM_FILESMENU : UM_VIEWSMENU;
2646	PortholeInit((HWND) WinSendMsg(dcd->hwndClient,
2647	wmsg, MPVOID, MPVOID), mp1, mp2);
2648	}
2649	break;
2650	}
2651	}
2652	break;
2653
2654	case UM_INITMENU:
2655	case WM_INITMENU:
2656	if (dcd) {
2657	switch (SHORT1FROMMP(mp1)) {
2658	case IDM_FILESMENU:
2659	if (dcd->info) {
2660	WinEnableMenuItem((HWND) mp2,
2661	IDM_DELETE, dcd->info->delete != NULL);
2662	WinEnableMenuItem((HWND) mp2, IDM_TEST, dcd->info->test != NULL);
2663	WinEnableMenuItem((HWND) mp2,
2664	IDM_EXTRACT, dcd->info->extract != NULL);
2665	WinEnableMenuItem((HWND) mp2,
2666	IDM_EXTRACTWDIRS, dcd->info->exwdirs != NULL);
2667	WinEnableMenuItem((HWND) mp2,
2668	IDM_ARCEXTRACTWDIRS, dcd->info->exwdirs != NULL);
2669	WinEnableMenuItem((HWND) mp2,
2670	IDM_ARCEXTRACTWDIRSEXIT,
2671	dcd->info->exwdirs != NULL);
2672	}
2673	break;
2674
2675	case IDM_VIEWSMENU:
2676	WinCheckMenuItem((HWND) mp2,
2677	IDM_MINIICONS, (dcd->flWindowAttr & CV_MINI) != 0);
2678	WinEnableMenuItem((HWND) mp2,
2679	IDM_RESELECT, (dcd->lastselection != NULL));
2680	break;
2681
2682	case IDM_COMMANDSMENU:
2683	SetupCommandMenu((HWND) mp2, hwnd);
2684	break;
2685
2686	case IDM_SORTSUBMENU:
2687	SetSortChecks((HWND) mp2, dcd->sortFlags);
2688	break;
2689
2690	case IDM_WINDOWSMENU:
2691	/**
2692	* add switchlist entries to end of pulldown menu
2693	*/
2694	SetupWinList((HWND)mp2,
2695	hwndMain ? hwndMain : (HWND)0, dcd->hwndFrame);
2696	break;
2697	}
2698	dcd->hwndLastMenu = (HWND) mp2;
2699	}
2700	if (msg == WM_INITMENU)
2701	break;
2702	return 0;
2703
2704	case UM_LOADFILE:
2705	if (dcd && mp2) {
2706
2707	HWND hwnd;
2708
2709	if ((INT)mp1 == 5 \|\| (INT)mp1 == 13 \|\| (INT)mp1 == 21)
2710	hwnd = StartViewer(HWND_DESKTOP, (INT)mp1,
2711	(CHAR *)mp2, dcd->hwndFrame);
2712	else
2713	hwnd = StartMLEEditor(dcd->hwndParent,
2714	(INT)mp1, (CHAR *)mp2, dcd->hwndFrame);
2715	free((CHAR *)mp2);
2716	return MRFROMLONG(hwnd);
2717	}
2718	return 0;
2719
2720	case UM_COMMAND:
2721	if (mp1) {
2722	if (dcd) {
2723	if (!PostMsg(dcd->hwndObject, UM_COMMAND, mp1, mp2)) {
2724	Runtime_Error(pszSrcFile, __LINE__, "post");
2725	FreeListInfo((LISTINFO *) mp1);
2726	}
2727	else
2728	return (MRESULT) TRUE;
2729	}
2730	else
2731	FreeListInfo((LISTINFO *) mp1);
2732	}
2733	return 0;
2734
2735	case UM_OPENWINDOWFORME:
2736	if (dcd) {
2737	if (mp1 && !IsFile((CHAR *) mp1)) {
2738	OpenDirCnr((HWND) 0, hwndMain, dcd->hwndFrame, FALSE, (char *)mp1);
2739	}
2740	else if (mp1 && IsFile(mp1) == 1 &&
2741	CheckDriveSpaceAvail(ArcTempRoot, ullDATFileSpaceNeeded, ullTmpSpaceNeeded) != 2) {
2742	StartArcCnr(HWND_DESKTOP,
2743	dcd->hwndFrame, (CHAR ) mp1, 4, (ARC_TYPE ) mp2);
2744	}
2745	}
2746	return 0;
2747
2748	case WM_COMMAND:
2749	DosError(FERR_DISABLEHARDERR);
2750	if (dcd) {
2751	if (SwitchCommand(dcd->hwndLastMenu, SHORT1FROMMP(mp1)))
2752	return 0;
2753	if (WinSendMsg(hwnd, UM_SETDIR, MPVOID, MPVOID))
2754	return 0;
2755	if (!IsArcThere(hwnd, dcd->arcname)) {
2756	PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
2757	return 0;
2758	}
2759	switch (SHORT1FROMMP(mp1)) {
2760	case IDM_TREEVIEW:
2761
2762	break;
2763
2764	case IDM_CONTEXTMENU:
2765	{
2766	PCNRITEM pci;
2767
2768	pci = (PCNRITEM) CurrentRecord(hwnd);
2769	PostMsg(hwnd,
2770	WM_CONTROL,
2771	MPFROM2SHORT(ARC_CNR, CN_CONTEXTMENU), MPFROMP(pci));
2772	}
2773	break;
2774
2775	case IDM_NEXTWINDOW:
2776	case IDM_PREVWINDOW:
2777	{
2778	HWND hwndActive;
2779
2780	hwndActive = WinQueryFocus(HWND_DESKTOP);
2781	WinSetFocus(HWND_DESKTOP,
2782	hwndActive == hwnd ?
2783	WinWindowFromID(dcd->hwndClient, ARC_EXTRACTDIR) :
2784	hwnd);
2785	}
2786	break;
2787
2788	case IDM_FOLDERAFTEREXTRACT:
2789	fFolderAfterExtract = fFolderAfterExtract ? FALSE : TRUE;
2790	PrfWriteProfileData(fmprof, appname, "FolderAfterExtract",
2791	&fFolderAfterExtract, sizeof(BOOL));
2792	break;
2793
2794	case IDM_SHOWSELECT:
2795	QuickPopup(hwnd, dcd, CheckMenu(hwnd, &ArcCnrMenu, ARCCNR_POPUP),
2796	IDM_SELECTSUBMENU);
2797	break;
2798
2799	case IDM_SHOWSORT:
2800	QuickPopup(hwnd, dcd, CheckMenu(hwnd, &ArcCnrMenu, ARCCNR_POPUP),
2801	IDM_SORTSUBMENU);
2802	break;
2803
2804	case IDM_ARCHIVERSETTINGS:
2805	if (!ParentIsDesktop(dcd->hwndParent, dcd->hwndParent))
2806	PostMsg(dcd->hwndParent, msg, MPFROMLONG(IDM_ARCHIVERSETTINGS), mp2);
2807	else {
2808	WinDlgBox(HWND_DESKTOP,
2809	hwnd,
2810	CfgDlgProc,
2811	FM3ModHandle,
2812	CFG_FRAME,
2813	MPFROMLONG(IDM_ARCHIVERSETTINGS));
2814	}
2815	break;
2816
2817	case IDM_RESCAN:
2818	dcd->ullTotalBytes = dcd->totalfiles =
2819	dcd->selectedfiles = dcd->selectedbytes = 0;
2820	WinSetDlgItemText(dcd->hwndClient, DIR_TOTALS, "0");
2821	WinSetDlgItemText(dcd->hwndClient, DIR_SELECTED, "0 / 0k");
2822	dcd->totalfiles = FillArcCnr(dcd->hwndCnr,
2823	dcd->arcname,
2824	&dcd->info,
2825	&dcd->ullTotalBytes, &dcd->stopflag);
2826	PostMsg(dcd->hwndCnr, UM_RESCAN, MPVOID, MPVOID);
2827	PostMsg(dcd->hwndCnr, UM_SETUP2, MPVOID, MPVOID);
2828	WinSendMsg(dcd->hwndCnr,
2829	CM_INVALIDATERECORD,
2830	MPVOID, MPFROM2SHORT(0, CMA_ERASE \| CMA_REPOSITION));
2831	break;
2832
2833	case IDM_RESELECT:
2834	SelectList(hwnd, TRUE, FALSE, FALSE, NULL, NULL, dcd->lastselection);
2835	break;
2836
2837	case IDM_HELP:
2838	if (hwndHelp)
2839	WinSendMsg(hwndHelp,
2840	HM_DISPLAY_HELP,
2841	MPFROM2SHORT(HELP_ARCLIST, 0),
2842	MPFROMSHORT(HM_RESOURCEID));
2843	break;
2844
2845	case IDM_WINDOWDLG:
2846	if (!ParentIsDesktop(dcd->hwndParent, dcd->hwndFrame))
2847	PostMsg(dcd->hwndParent,
2848	UM_COMMAND, MPFROM2SHORT(IDM_WINDOWDLG, 0), MPVOID);
2849	break;
2850
2851	case IDM_SELECTALL:
2852	case IDM_SELECTALLFILES:
2853	case IDM_DESELECTALL:
2854	case IDM_DESELECTALLFILES:
2855	case IDM_SELECTMASK:
2856	case IDM_DESELECTMASK:
2857	case IDM_INVERT:
2858	{
2859	PARCITEM pci;
2860
2861	pci = (PARCITEM) WinSendMsg(hwnd,
2862	CM_QUERYRECORDEMPHASIS,
2863	MPFROMLONG(CMA_FIRST),
2864	MPFROMSHORT(CRA_CURSORED));
2865	if ((INT) pci == -1)
2866	pci = NULL;
2867	if (SHORT1FROMMP(mp1) == IDM_HIDEALL) {
2868	if (pci) {
2869	if (!(pci->rc.flRecordAttr & CRA_SELECTED))
2870	pci->rc.flRecordAttr \|= CRA_FILTERED;
2871	WinSendMsg(hwnd,
2872	CM_INVALIDATERECORD,
2873	MPFROMP(&pci),
2874	MPFROM2SHORT(1, CMA_ERASE \| CMA_REPOSITION));
2875	break;
2876	}
2877	}
2878	PostMsg(dcd->hwndObject, UM_SELECT, mp1, MPFROMP(pci));
2879	}
2880	break;
2881
2882	case IDM_SORTSMARTNAME:
2883	case IDM_SORTNAME:
2884	case IDM_SORTFILENAME:
2885	case IDM_SORTSIZE:
2886	case IDM_SORTEASIZE:
2887	case IDM_SORTFIRST:
2888	case IDM_SORTLAST:
2889	case IDM_SORTLWDATE:
2890	dcd->sortFlags &= SORT_REVERSE;
2891	// intentional fallthru
2892	case IDM_SORTREVERSE:
2893	switch (SHORT1FROMMP(mp1)) {
2894	case IDM_SORTSMARTNAME:
2895	case IDM_SORTFILENAME:
2896	dcd->sortFlags \|= SORT_FILENAME;
2897	break;
2898	case IDM_SORTSIZE:
2899	dcd->sortFlags \|= SORT_SIZE;
2900	break;
2901	case IDM_SORTEASIZE:
2902	dcd->sortFlags \|= SORT_EASIZE;
2903	break;
2904	case IDM_SORTFIRST:
2905	dcd->sortFlags \|= SORT_FIRSTEXTENSION;
2906	break;
2907	case IDM_SORTLAST:
2908	dcd->sortFlags \|= SORT_LASTEXTENSION;
2909	break;
2910	case IDM_SORTLWDATE:
2911	dcd->sortFlags \|= SORT_LWDATE;
2912	break;
2913	case IDM_SORTREVERSE:
2914	if (dcd->sortFlags & SORT_REVERSE)
2915	dcd->sortFlags &= (~SORT_REVERSE);
2916	else
2917	dcd->sortFlags \|= SORT_REVERSE;
2918	break;
2919	}
2920	WinSendMsg(hwnd, CM_SORTRECORD, MPFROMP(ArcSort), MPFROMP(dcd));
2921	SaySort(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
2922	DIR_SORT), dcd->sortFlags, TRUE);
2923	DefArcSortFlags = dcd->sortFlags; // Remember for new windows
2924	break;
2925
2926	case IDM_COLLECTOR:
2927	if (!Collector) {
2928	HWND hwndC;
2929	SWP swp;
2930
2931	if (ParentIsDesktop(hwnd, dcd->hwndParent) && !fAutoTile &&
2932	(!fExternalCollector && !strcmp(realappname, FM3Str)))
2933	GetNextWindowPos(dcd->hwndParent, &swp, NULL, NULL);
2934	hwndC = StartCollector(fExternalCollector \|\|
2935	strcmp(realappname, FM3Str) ?
2936	HWND_DESKTOP : dcd->hwndParent, 4);
2937	if (hwndC) {
2938	if (!ParentIsDesktop(hwnd, dcd->hwndParent) && !fAutoTile &&
2939	(!fExternalCollector && !strcmp(realappname, FM3Str)))
2940	WinSetWindowPos(hwndC,
2941	HWND_TOP,
2942	swp.x,
2943	swp.y,
2944	swp.cx,
2945	swp.cy,
2946	SWP_MOVE \| SWP_SIZE \| SWP_SHOW \| SWP_ZORDER);
2947	else if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
2948	fAutoTile && !strcmp(realappname, FM3Str)) {
2949	TileChildren(dcd->hwndParent, TRUE);
2950	}
2951	WinSetWindowPos(hwndC, HWND_TOP, 0, 0, 0, 0, SWP_ACTIVATE);
2952	DosSleep(100); //05 Aug 07 GKY 128
2953	}
2954	}
2955	else
2956	StartCollector(dcd->hwndParent, 4);
2957	break;
2958
2959	case IDM_ARCEXTRACTEXIT:
2960	case IDM_ARCEXTRACT:
2961	if (dcd->directory && fFileNameCnrPath &&
2962	stricmp(lastextractpath, dcd->directory)) {
2963	strcpy(lastextractpath, dcd->directory);
2964	SetDir(dcd->hwndParent, hwnd, dcd->directory, 1);
2965	}
2966	if (dcd->info->extract)
2967	runemf2(SEPARATE \| WINDOWED \| ASYNCHRONOUS \|
2968	(fArcStuffVisible ? 0 : BACKGROUND \| MINIMIZED),
2969	hwnd, pszSrcFile, __LINE__,
2970	dcd->directory, NULL, "%s %s", dcd->info->extract,
2971	BldQuotedFileName(szQuotedArcName, dcd->arcname));
2972	if (SHORT1FROMMP(mp1) == IDM_ARCEXTRACTEXIT)
2973	PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
2974	break;
2975
2976	case IDM_ARCEXTRACTWDIRSEXIT:
2977	case IDM_ARCEXTRACTWDIRS:
2978	if (dcd->directory && fFileNameCnrPath &&
2979	stricmp(lastextractpath, dcd->directory)) {
2980	strcpy(lastextractpath, dcd->directory);
2981	SetDir(dcd->hwndParent, hwnd, dcd->directory, 1);
2982	}
2983	if (dcd->info->exwdirs)
2984	runemf2(SEPARATE \| WINDOWED \| ASYNCHRONOUS \|
2985	(fArcStuffVisible ? 0 : BACKGROUND \| MINIMIZED),
2986	hwnd, pszSrcFile, __LINE__,
2987	dcd->directory, NULL, "%s %s",
2988	dcd->info->exwdirs,
2989	BldQuotedFileName(szQuotedArcName, dcd->arcname));
2990	if (SHORT1FROMMP(mp1) == IDM_ARCEXTRACTWDIRSEXIT)
2991	PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
2992	break;
2993
2994	case IDM_RESORT:
2995	WinSendMsg(hwnd, CM_SORTRECORD, MPFROMP(ArcSort), MPFROMP(dcd));
2996	break;
2997
2998	case IDM_FILTER:
2999	{
3000	BOOL empty = FALSE;
3001	PARCITEM pci;
3002
3003	if (!*dcd->mask.szMask) {
3004	empty = TRUE;
3005	pci = (PARCITEM) CurrentRecord(hwnd);
3006	if (pci && strchr(pci->pszFileName, '.'))
3007	strcpy(dcd->mask.szMask, pci->pszFileName);
3008	}
3009
3010	if (WinDlgBox(HWND_DESKTOP, hwnd, PickMaskDlgProc,
3011	FM3ModHandle, MSK_FRAME, MPFROMP(&dcd->mask))) {
3012	WinSendMsg(hwnd, CM_FILTER, MPFROMP(ArcFilter), MPFROMP(dcd));
3013	PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
3014	}
3015	else if (empty)
3016	*dcd->mask.szMask = 0;
3017	SayFilter(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
3018	DIR_FILTER), &dcd->mask, TRUE);
3019	}
3020	break;
3021
3022	case IDM_SWITCH:
3023	if (mp2) {
3024	if (stricmp(dcd->directory, (CHAR *) mp2)) {
3025	//DosEnterCritSec(); //GKY 11-29-08
3026	DosRequestMutexSem(hmtxFM2Globals, SEM_INDEFINITE_WAIT);
3027	strcpy(lastextractpath, (CHAR *) mp2);
3028	MakeValidDir(lastextractpath);
3029	DosReleaseMutexSem(hmtxFM2Globals);
3030	//DosExitCritSec();
3031	}
3032	strcpy(dcd->directory, (CHAR *) mp2);
3033	MakeValidDir(dcd->directory);
3034	WinSetWindowText(dcd->hwndExtract, dcd->directory);
3035	}
3036	break;
3037
3038	case IDM_WALKDIR:
3039	{
3040	CHAR newdir[CCHMAXPATH];
3041
3042	strcpy(newdir, dcd->directory);
3043	if (!WinDlgBox(HWND_DESKTOP, dcd->hwndParent, WalkExtractDlgProc,
3044	FM3ModHandle, WALK_FRAME,
3045	MPFROMP(newdir)) \|\| !*newdir)
3046	break;
3047	if (stricmp(newdir, dcd->directory)) {
3048	strcpy(dcd->directory, newdir);
3049	if (stricmp(lastextractpath, newdir))
3050	strcpy(lastextractpath, newdir);
3051	WinSetWindowText(dcd->hwndExtract, dcd->directory);
3052	}
3053	}
3054	break;
3055
3056	case IDM_TEST:
3057	if (dcd->info->test)
3058	runemf2(SEPARATEKEEP \| WINDOWED \| MAXIMIZED,
3059	hwnd, pszSrcFile, __LINE__, NULL, NULL,
3060	"%s %s",dcd->info->test,
3061	BldQuotedFileName(szQuotedArcName, dcd->arcname));
3062	break;
3063
3064	case IDM_REFRESH:
3065	case IDM_DELETE:
3066	case IDM_PRINT:
3067	case IDM_VIEW:
3068	case IDM_VIEWTEXT:
3069	case IDM_VIEWBINARY:
3070	case IDM_VIEWARCHIVE:
3071	case IDM_EDIT:
3072	case IDM_EDITTEXT:
3073	case IDM_EDITBINARY:
3074	case IDM_EXTRACT:
3075	case IDM_EXTRACTWDIRS:
3076	case IDM_FIND:
3077	case IDM_EXEC:
3078	case IDM_VIRUSSCAN:
3079	case IDM_OPENDEFAULT:
3080	case IDM_OPENSETTINGS:
3081	case IDM_MCIPLAY:
3082	{
3083	LISTINFO *li;
3084	# ifdef FORTIFY
3085	Fortify_EnterScope();
3086	# endif
3087	li = xmallocz(sizeof(LISTINFO), pszSrcFile, __LINE__);
3088	if (li) {
3089	li->type = SHORT1FROMMP(mp1);
3090	li->hwnd = hwnd;
3091	li->list = BuildArcList(hwnd);
3092	if (li->type == IDM_REFRESH) {
3093
3094	CHAR s[CCHMAXPATH], *p;
3095	INT x, y;
3096
3097	for (x = 0; li->list && li->list[x]; x++) {
3098	BldFullPathName(s, dcd->workdir, li->list[x]);
3099	if (IsFile(s) != 1) {
3100	free(li->list[x]);
3101	li->list[x] = NULL;
3102	for (y = x; li->list[y]; y++)
3103	li->list[y] = li->list[y + 1];
3104	li->list =
3105	xrealloc(li->list, y * sizeof(CHAR *), pszSrcFile,
3106	__LINE__);
3107	x--;
3108	}
3109	else {
3110	p = xstrdup(s, pszSrcFile, __LINE__);
3111	if (p) {
3112	free(li->list[x]);
3113	li->list[x] = p;
3114	}
3115	}
3116	} // for
3117	}
3118	strcpy(li->arcname, dcd->arcname);
3119	li->info = dcd->info;
3120	{
3121	PARCITEM pai;
3122
3123	if (SHORT1FROMMP(mp1) != IDM_EXEC)
3124	pai = (PARCITEM) CurrentRecord(hwnd);
3125	else
3126	pai = (PARCITEM) WinSendMsg(hwnd, CM_QUERYRECORDEMPHASIS,
3127	MPFROMLONG(CMA_FIRST),
3128	MPFROMSHORT(CRA_CURSORED));
3129	if (pai && (INT) pai != -1)
3130	strcpy(li->runfile, pai->pszFileName);
3131	else
3132	strcpy(li->runfile, li->list[0]);
3133	}
3134	switch (SHORT1FROMMP(mp1)) {
3135	case IDM_VIEW:
3136	case IDM_VIEWTEXT:
3137	case IDM_VIEWBINARY:
3138	case IDM_VIEWARCHIVE:
3139	case IDM_EDIT:
3140	case IDM_EDITTEXT:
3141	case IDM_EDITBINARY:
3142	case IDM_EXEC:
3143	case IDM_PRINT:
3144	case IDM_VIRUSSCAN:
3145	case IDM_OPENDEFAULT:
3146	case IDM_OPENSETTINGS:
3147	case IDM_MCIPLAY:
3148	strcpy(li->targetpath, dcd->workdir);
3149	break;
3150	default:
3151	strcpy(li->targetpath, dcd->directory);
3152	break;
3153	}
3154	if (li->list) {
3155	if (!PostMsg(dcd->hwndObject, UM_ACTION, MPFROMP(li), MPVOID)) {
3156	Runtime_Error(pszSrcFile, __LINE__, "post");
3157	FreeListInfo(li);
3158	}
3159	else if (fUnHilite && SHORT1FROMMP(mp1) != IDM_EDIT)
3160	UnHilite(hwnd, TRUE, &dcd->lastselection, 0);
3161	}
3162	else {
3163	free(li);
3164	}
3165	}
3166	# ifdef FORTIFY
3167	Fortify_LeaveScope();
3168	# endif
3169	}
3170	break;
3171	}
3172	}
3173	return 0;
3174
3175	case WM_CONTROL:
3176	DosError(FERR_DISABLEHARDERR);
3177	if (dcd) {
3178	switch (SHORT2FROMMP(mp1)) {
3179	case CN_BEGINEDIT:
3180	PostMsg(hwnd, CM_CLOSEEDIT, MPVOID, MPVOID);
3181	break;
3182
3183	case CN_ENDEDIT:
3184	if (!((PCNREDITDATA) mp2)->pRecord) {
3185
3186	PFIELDINFO pfi = ((PCNREDITDATA) mp2)->pFieldInfo;
3187	USHORT cmd = 0;
3188
3189	if (!pfi \|\| pfi->offStruct == FIELDOFFSET(ARCITEM, pszDisplayName))
3190	cmd = IDM_SORTSMARTNAME;
3191	else if (pfi->offStruct == FIELDOFFSET(ARCITEM, cbFile))
3192	cmd = IDM_SORTSIZE;
3193	else if (pfi->offStruct == FIELDOFFSET(ARCITEM, cbComp))
3194	cmd = IDM_SORTEASIZE;
3195	else if (pfi->offStruct == FIELDOFFSET(ARCITEM, date))
3196	cmd = IDM_SORTLWDATE;
3197	else if (pfi->offStruct == FIELDOFFSET(ARCITEM, time))
3198	cmd = IDM_SORTLWDATE;
3199	if (cmd)
3200	PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(cmd, 0), MPVOID);
3201	}
3202	break;
3203
3204	case CN_DROPHELP:
3205	saymsg(MB_ENTER, hwnd,
3206	GetPString(IDS_DROPHELPHDRTEXT),
3207	GetPString(IDS_ARCCNRDROPHELPTEXT), dcd->arcname);
3208	return 0;
3209
3210	case CN_DRAGLEAVE:
3211	if (mp2) {
3212
3213	PDRAGINFO pDInfo;
3214
3215	pDInfo = ((PCNRDRAGINFO) mp2)->pDragInfo;
3216	DrgAccessDraginfo(pDInfo); // Access DRAGINFO
3217	DrgFreeDraginfo(pDInfo); // Free DRAGINFO
3218	}
3219	return 0;
3220
3221	case CN_DRAGAFTER:
3222	case CN_DRAGOVER:
3223	if (mp2) {
3224
3225	PDRAGITEM pDItem; // Pointer to DRAGITEM
3226	PDRAGINFO pDInfo; // Pointer to DRAGINFO
3227	PARCITEM pci;
3228
3229	pci = (PARCITEM) ((PCNRDRAGINFO) mp2)->pRecord;
3230	if (SHORT1FROMMP(mp1) == CN_DRAGAFTER)
3231	pci = NULL;
3232	pDInfo = ((PCNRDRAGINFO) mp2)->pDragInfo;
3233	DrgAccessDraginfo(pDInfo); // Access DRAGINFO
3234	if (*dcd->arcname) {
3235	if ((driveflags[toupper(*dcd->arcname) - 'A'] &
3236	DRIVE_NOTWRITEABLE) \|\| !dcd->info \|\| !dcd->info->create) {
3237	DrgFreeDraginfo(pDInfo);
3238	return MRFROM2SHORT(DOR_NEVERDROP, 0);
3239	}
3240	}
3241	if (pci) {
3242	DrgFreeDraginfo(pDInfo);
3243	return MRFROM2SHORT(DOR_NODROP, 0);
3244	}
3245	pDItem = DrgQueryDragitemPtr(pDInfo, // Access DRAGITEM
3246	0); // Index to DRAGITEM
3247	if (DrgVerifyRMF(pDItem, // Check valid rendering
3248	(CHAR *) DRM_OS2FILE, // mechanisms and data
3249	NULL) && !(pDItem->fsControl & DC_PREPARE)) {
3250	DrgFreeDraginfo(pDInfo); // Free DRAGINFO
3251	return MRFROM2SHORT(DOR_DROP, // Return okay to drop
3252	fCopyDefault ? DO_COPY : DO_MOVE);
3253	}
3254	DrgFreeDraginfo(pDInfo); // Free DRAGINFO
3255	}
3256	return (MRFROM2SHORT(DOR_NEVERDROP, 0)); // Drop not valid
3257
3258	case CN_INITDRAG:
3259	if (mp2) {
3260
3261	BOOL wasemphasized = FALSE;
3262	PCNRDRAGINIT pcd = (PCNRDRAGINIT) mp2;
3263	PARCITEM pci;
3264
3265	if (pcd) {
3266	pci = (PARCITEM) pcd->pRecord;
3267	if (pci) {
3268	if (pci->rc.flRecordAttr & CRA_SELECTED)
3269	wasemphasized = TRUE;
3270	if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
3271	fSplitStatus && hwndStatus2)
3272	WinSetWindowText(hwndStatus2, (CHAR *) GetPString(IDS_DRAGARCMEMTEXT));
3273	if (DoFileDrag(hwnd,
3274	dcd->hwndObject,
3275	mp2, dcd->arcname, NULL, TRUE)) {
3276	if ((fUnHilite && wasemphasized) \|\| dcd->ulItemsToUnHilite)
3277	UnHilite(hwnd, TRUE, &dcd->lastselection, dcd->ulItemsToUnHilite);
3278	}
3279	if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
3280	fSplitStatus && hwndStatus2) {
3281	PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
3282	}
3283	}
3284	else {
3285	if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
3286	fSplitStatus && hwndStatus2)
3287	WinSetWindowText(hwndStatus2,
3288	(CHAR *) GetPString(IDS_DRAGARCFILETEXT));
3289	DragOne(hwnd, dcd->hwndObject, dcd->arcname, FALSE);
3290	if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
3291	fSplitStatus && hwndStatus2)
3292	PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
3293	}
3294	}
3295	}
3296	return 0;
3297
3298	case CN_DROP:
3299	if (mp2) {
3300
3301	LISTINFO *li;
3302
3303	//DosBeep(500, 100); // fixme to know why beep?
3304	li = DoFileDrop(hwnd, dcd->arcname, FALSE, mp1, mp2);
3305	//DosBeep(50, 100); // fixme to know why beep?
3306	CheckPmDrgLimit(((PCNRDRAGINFO)mp2)->pDragInfo);
3307	if (li) {
3308	li->type = li->type == DO_MOVE ? IDM_ARCHIVEM : IDM_ARCHIVE;
3309	strcpy(li->targetpath, dcd->arcname);
3310	if (!li->list \|\|
3311	!li->list[0] \|\|
3312	!PostMsg(dcd->hwndObject, UM_ACTION, MPFROMP(li), MPVOID))
3313	FreeListInfo(li);
3314	}
3315	}
3316	return 0;
3317
3318	case CN_CONTEXTMENU:
3319	{
3320	PARCITEM pci = (PARCITEM) mp2;
3321
3322	if (pci) {
3323	WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPFROMP(pci),
3324	MPFROM2SHORT(TRUE, CRA_CURSORED));
3325	MarkAll(hwnd, FALSE, FALSE, TRUE);
3326	dcd->hwndLastMenu = CheckMenu(hwnd, &ArcMenu, ARC_POPUP);
3327	}
3328	else {
3329	dcd->hwndLastMenu = CheckMenu(hwnd, &ArcCnrMenu, ARCCNR_POPUP);
3330	if (dcd->hwndLastMenu && !dcd->cnremphasized) {
3331	WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPVOID,
3332	MPFROM2SHORT(TRUE, CRA_SOURCE));
3333	dcd->cnremphasized = TRUE;
3334	}
3335	}
3336	if (dcd->hwndLastMenu) {
3337	if (dcd->hwndLastMenu == ArcCnrMenu) {
3338	if (dcd->flWindowAttr & CV_MINI)
3339	WinCheckMenuItem(dcd->hwndLastMenu, IDM_MINIICONS, TRUE);
3340	}
3341	WinCheckMenuItem(dcd->hwndLastMenu, IDM_FOLDERAFTEREXTRACT,
3342	fFolderAfterExtract);
3343	if (!PopupMenu(hwnd, hwnd, dcd->hwndLastMenu)) {
3344	if (dcd->cnremphasized) {
3345	WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPVOID,
3346	MPFROM2SHORT(FALSE, CRA_SOURCE));
3347	dcd->cnremphasized = TRUE;
3348	}
3349	MarkAll(hwnd, TRUE, FALSE, TRUE);
3350	}
3351	}
3352	}
3353	break;
3354
3355	case CN_EMPHASIS:
3356	if (mp2) {
3357
3358	PNOTIFYRECORDEMPHASIS pre = mp2;
3359	PARCITEM pci;
3360	CHAR s[CCHMAXPATHCOMP + 91], tf[81], tb[81];
3361
3362	pci = (PARCITEM)(pre ? pre->pRecord : NULL);
3363	if (!pci) {
3364	if (!ParentIsDesktop(hwnd, dcd->hwndParent)) {
3365	if (hwndStatus2)
3366	WinSetWindowText(hwndStatus2, NullStr);
3367	if (fMoreButtons)
3368	WinSetWindowText(hwndName, NullStr);
3369	}
3370	break;
3371	}
3372	if (pre->fEmphasisMask & CRA_SELECTED) {
3373	if (pci->rc.flRecordAttr & CRA_SELECTED) {
3374	dcd->selectedbytes += pci->cbFile;
3375	dcd->selectedfiles++;
3376	}
3377	else if (dcd->selectedfiles) {
3378	dcd->selectedbytes -= pci->cbFile;
3379	dcd->selectedfiles--;
3380	}
3381	commafmt(tf, sizeof(tf), dcd->selectedfiles);
3382	if (dcd->ullTotalBytes)
3383	CommaFmtULL(tb, sizeof(tb), dcd->selectedbytes, ' ');
3384	else
3385	*tb = 0;
3386	sprintf(s, "%s%s%s", tf, *tb ? " / " : NullStr, tb);
3387	WinSetDlgItemText(dcd->hwndClient, DIR_SELECTED, s);
3388	}
3389	else if (WinQueryActiveWindow(dcd->hwndParent) ==
3390	dcd->hwndFrame &&
3391	!ParentIsDesktop(hwnd, dcd->hwndParent)) {
3392	if (pre->fEmphasisMask & CRA_CURSORED) {
3393	if (pci->rc.flRecordAttr & CRA_CURSORED) {
3394	if (fSplitStatus && hwndStatus2) {
3395	if (dcd->ullTotalBytes)
3396	CommaFmtULL(tb, sizeof(tb), pci->cbFile, ' ');
3397	else
3398	*tb = 0;
3399	sprintf(s, "%s%s%s%s",
3400	*tb ? " " : NullStr,
3401	tb, *tb ? " " : NullStr, pci->pszFileName);
3402	WinSetWindowText(hwndStatus2, s);
3403	}
3404	if (fMoreButtons)
3405	WinSetWindowText(hwndName, pci->pszFileName);
3406	}
3407	}
3408	}
3409	}
3410	break;
3411
3412	case CN_ENTER:
3413	if (mp2) {
3414
3415	PARCITEM pci = (PARCITEM) ((PNOTIFYRECORDENTER) mp2)->pRecord;
3416
3417	if (pci) {
3418
3419	CHAR *s;
3420
3421	if ((pci->rc.flRecordAttr & CRA_INUSE) \|\|
3422	(pci->flags & (ARCFLAGS_REALDIR \| ARCFLAGS_PSEUDODIR)))
3423	break;
3424	s = xstrdup(pci->pszFileName, pszSrcFile, __LINE__);
3425	if (s) {
3426	if (!PostMsg(dcd->hwndObject, UM_ENTER, MPFROMP(s), MPVOID)) {
3427	Runtime_Error(pszSrcFile, __LINE__, "post");
3428	free(s);
3429	}
3430	}
3431	}
3432	}
3433	break;
3434	}
3435	}
3436	return 0;
3437
3438	case UM_FOLDUP:
3439	if (!PostMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID))
3440	DosExit(EXIT_PROCESS, 1);
3441	return 0;
3442
3443	case UM_CLOSE:
3444	WinDestroyWindow(WinQueryWindow(WinQueryWindow(hwnd, QW_PARENT),
3445	QW_PARENT));
3446	return 0;
3447
3448	case WM_SAVEAPPLICATION:
3449	if (dcd && ParentIsDesktop(hwnd, dcd->hwndParent)) {
3450	SWP swp;
3451
3452	WinQueryWindowPos(dcd->hwndFrame, &swp);
3453	if (!(swp.fl & (SWP_HIDE \| SWP_MINIMIZE \| SWP_MAXIMIZE)))
3454	PrfWriteProfileData(fmprof, appname, "AV2SizePos", &swp, sizeof(swp));
3455	}
3456	break;
3457
3458	case WM_CLOSE:
3459	WinSendMsg(hwnd, WM_SAVEAPPLICATION, MPVOID, MPVOID);
3460	if (dcd)
3461	dcd->stopflag++;
3462	if (dcd && dcd->hwndObject) {
3463	if (!PostMsg(dcd->hwndObject, WM_CLOSE, MPVOID, MPVOID))
3464	WinSendMsg(dcd->hwndObject, WM_CLOSE, MPVOID, MPVOID);
3465	}
3466	// In case object window frees dcd
3467	dcd = WinQueryWindowPtr(hwnd, QWL_USER);
3468	if (!dcd \|\|
3469	(!dcd->dontclose &&
3470	!dcd->amextracted && ParentIsDesktop(hwnd, dcd->hwndParent))) {
3471	if (!PostMsg(hwnd, UM_FOLDUP, MPVOID, MPVOID))
3472	WinSendMsg(hwnd, UM_FOLDUP, MPVOID, MPVOID);
3473	}
3474	return 0;
3475
3476	case WM_DESTROY:
3477	if (ArcMenu)
3478	WinDestroyWindow(ArcMenu);
3479	if (ArcCnrMenu)
3480	WinDestroyWindow(ArcCnrMenu);
3481	ArcMenu = ArcCnrMenu = (HWND) 0;
3482	EmptyArcCnr(hwnd);
3483	# ifdef FORTIFY
3484	Fortify_LeaveScope();
3485	# endif
3486	break;
3487	}
3488	if (dcd && dcd->oldproc){
3489	return dcd->oldproc(hwnd, msg, mp1, mp2);
3490	}
3491	else
3492	return PFNWPCnr(hwnd, msg, mp1, mp2);
3493	}
3494
3495	MRESULT EXPENTRY ArcCnrMenuProc(HWND hwnd, ULONG msg, MPARAM mp1,
3496	MPARAM mp2)
3497	{
3498	PFNWP oldMenuProc = WinQueryWindowPtr(hwnd, QWL_USER);
3499	static short sLastMenuitem;
3500
3501	switch (msg) {
3502	case WM_MOUSEMOVE: {
3503	if (fOtherHelp) {
3504	RECTL rectl;
3505	SHORT i, sCurrentMenuitem;
3506	SHORT MenuItems = 10;
3507	SHORT asMenuIDs[10] = {IDM_VIEW,
3508	IDM_DELETE,
3509	IDM_EXEC,
3510	IDM_EXTRACT,
3511	IDM_TEST,
3512	IDM_VIRUSSCAN,
3513	IDM_RESCAN,
3514	IDM_WALKDIR,
3515	IDM_FILTER,
3516	0};
3517	PCSZ szHelpString = NULL;
3518
3519
3520	for (i=0; i<MenuItems; i++) {
3521	sCurrentMenuitem = asMenuIDs[i];
3522	oldMenuProc(hwnd,MM_QUERYITEMRECT,
3523	MPFROM2SHORT(asMenuIDs[i], FALSE),
3524	&rectl);
3525
3526	if (MOUSEMSG(&msg)->x > rectl.xLeft &&
3527	MOUSEMSG(&msg)->x < rectl.xRight &&
3528	MOUSEMSG(&msg)->y > rectl.yBottom &&
3529	MOUSEMSG(&msg)->y < rectl.yTop)
3530	break;
3531	} // for
3532
3533
3534	switch (sCurrentMenuitem) {
3535	case 0:
3536	break;
3537	case IDM_VIEW:
3538	szHelpString = GetPString(IDS_ARCCNRVIEWMENUHELP);
3539	break;
3540	case IDM_DELETE:
3541	szHelpString = GetPString(IDS_ARCCNRDELETEMENUHELP);
3542	break;
3543	case IDM_EXEC:
3544	szHelpString = GetPString(IDS_ARCCNREXECMENUHELP);
3545	break;
3546	case IDM_EXTRACT:
3547	szHelpString = GetPString(IDS_ARCCNREXTRACTMENUHELP);
3548	break;
3549	case IDM_TEST:
3550	szHelpString = GetPString(IDS_ARCCNRTESTMENUHELP);
3551	break;
3552	case IDM_VIRUSSCAN:
3553	szHelpString = GetPString(IDS_ARCCNRVIRUSMENUHELP);
3554	break;
3555	case IDM_RESCAN:
3556	szHelpString = GetPString(IDS_ARCCNRRESCANMENUHELP);
3557	break;
3558	case IDM_WALKDIR:
3559	szHelpString = GetPString(IDS_ARCCNRWALKDIRMENUHELP);
3560	break;
3561	case IDM_FILTER:
3562	szHelpString = GetPString(IDS_ARCCNRFILTERMENUHELP);
3563	break;
3564	default:
3565	break;
3566	}
3567
3568	if (sLastMenuitem != sCurrentMenuitem && szHelpString) {
3569	sLastMenuitem = sCurrentMenuitem;
3570	MakeBubble(hwnd, TRUE, szHelpString);
3571	}
3572	else if (hwndBubble && !sCurrentMenuitem){
3573	sLastMenuitem = sCurrentMenuitem;
3574	WinDestroyWindow(hwndBubble);
3575	}
3576	}
3577	}
3578	}
3579	return oldMenuProc(hwnd, msg, mp1, mp2);
3580	}
3581
3582	HWND StartArcCnr(HWND hwndParent, HWND hwndCaller, CHAR * arcname, INT flags,
3583	ARC_TYPE * sinfo)
3584	{
3585	/**
3586	* bitmapped flags:
3587	* 1 = am extracted from another archive
3588	* 4 = don't kill proc on close
3589	*/
3590
3591	HWND hwndFrame = (HWND) 0, hwndClient;
3592	ULONG FrameFlags = FCF_TITLEBAR \| FCF_SYSMENU \|
3593	FCF_SIZEBORDER \| FCF_MINMAX \| FCF_ICON \| FCF_NOBYTEALIGN \| FCF_ACCELTABLE;
3594	USHORT id;
3595	DIRCNRDATA *dcd;
3596	ARC_TYPE *info = sinfo;
3597	CHAR title[MAXNAMEL + 1] = "AV/2 - ";
3598	CHAR fullname[CCHMAXPATH + 8], *p, temp;
3599	static USHORT idinc = 0;
3600
3601	if (!idinc)
3602	idinc = (rand() % 256);
3603	if (ParentIsDesktop(hwndParent, hwndParent))
3604	FrameFlags \|= (FCF_TASKLIST \| FCF_MENU);
3605	if (arcname) {
3606	DosError(FERR_DISABLEHARDERR);
3607	if (DosQueryPathInfo(arcname,
3608	FIL_QUERYFULLNAME, fullname, sizeof(fullname)))
3609	strcpy(fullname, arcname);
3610	ForwardslashToBackslash(fullname);
3611	if (!info)
3612	info = find_type(fullname, arcsighead);
3613	if (!info)
3614	return hwndFrame;
3615	if (strlen(title) + strlen(fullname) > MAXNAMEL) {
3616	p = title + strlen(title);
3617	strncpy(p, fullname, MAXNAMEL / 2 - 5);
3618	strcpy(p + MAXNAMEL / 2 - 5, "...");
3619	strcat(title, fullname + strlen(fullname) - (MAXNAMEL / 2 - 5));
3620	}
3621	else {
3622	strcat(title, fullname);
3623	}
3624	hwndFrame = WinCreateStdWindow(hwndParent,
3625	WS_VISIBLE,
3626	&FrameFlags,
3627	(CHAR *) WC_ARCCONTAINER,
3628	title,
3629	WS_VISIBLE \| fwsAnimate,
3630	FM3ModHandle, ARC_FRAME, &hwndClient);
3631	if (hwndFrame && hwndClient) {
3632	id = ARC_FRAME + idinc++;
3633	if (idinc > 512)
3634	idinc = 0;
3635	WinSetWindowUShort(hwndFrame, QWS_ID, id);
3636	# ifdef FORTIFY
3637	Fortify_EnterScope();
3638	# endif
3639	dcd = xmallocz(sizeof(DIRCNRDATA), pszSrcFile, __LINE__);
3640	if (!dcd) {
3641	PostMsg(hwndClient, WM_CLOSE, MPVOID, MPVOID);
3642	hwndFrame = (HWND) 0;
3643	}
3644	else {
3645	# ifdef FORTIFY
3646	// Will be freed by WM_DESTROY
3647	Fortify_ChangeScope(dcd, -1);
3648	# endif
3649	dcd->size = sizeof(DIRCNRDATA);
3650	dcd->id = id;
3651	dcd->type = ARC_FRAME;
3652	if (pTmpDir && !IsValidDir(pTmpDir))
3653	DosCreateDir(pTmpDir, 0);
3654	MakeTempName(dcd->workdir, ArcTempRoot, 2);
3655	strcpy(dcd->arcname, fullname);
3656	if (*extractpath) {
3657	if (!strcmp(extractpath, "*")) {
3658	p = strrchr(fullname, '\\');
3659	if (p) {
3660	if (p < fullname + 3)
3661	p++;
3662	temp = *p;
3663	*p = 0;
3664	strcpy(dcd->directory, fullname);
3665	*p = temp;
3666	}
3667	}
3668	else
3669	strcpy(dcd->directory, extractpath);
3670	}
3671	if (!*dcd->directory && fFileNameCnrPath && dcd->arcname) {
3672	strcpy(fullname, dcd->arcname);
3673	p = strrchr(fullname, '.');
3674	if (p)
3675	*p = 0;
3676	else {
3677	p = fullname + strlen(fullname);
3678	p--;
3679	*p = 0;
3680	}
3681	strcpy(dcd->directory, fullname);
3682	}
3683	if (!dcd->directory && lastextractpath) {
3684	//DosEnterCritSec(); //GKY 11-29-08
3685	DosRequestMutexSem(hmtxFM2Globals, SEM_INDEFINITE_WAIT);
3686	strcpy(dcd->directory, lastextractpath);
3687	DosReleaseMutexSem(hmtxFM2Globals);
3688	//DosExitCritSec();
3689	}
3690	if (!*dcd->directory) {
3691	if (!ParentIsDesktop(hwndParent, hwndParent))
3692	TopWindowName(hwndParent, hwndCaller, dcd->directory);
3693	if (!*dcd->directory) {
3694	p = strrchr(fullname, '\\');
3695	if (p) {
3696	if (p < fullname + 3)
3697	p++;
3698	*p = 0;
3699	strcpy(dcd->directory, fullname);
3700	}
3701	}
3702	}
3703	if (!*dcd->directory \|\|
3704	(IsFile(dcd->directory) == 1) \|\|
3705	(isalpha(*dcd->directory) &&
3706	(driveflags[toupper(*dcd->directory) - 'A'] &
3707	DRIVE_NOTWRITEABLE)))
3708	strcpy(dcd->directory, pFM2SaveDirectory);
3709	dcd->hwndParent = hwndParent ? hwndParent : HWND_DESKTOP;
3710	dcd->hwndFrame = hwndFrame;
3711	dcd->hwndClient = hwndClient;
3712	dcd->amextracted = (flags & 1) != 0;
3713	dcd->dontclose = (flags & 4) != 0;
3714	dcd->info = info;
3715	dcd->sortFlags = DefArcSortFlags;
3716	{
3717	PFNWP oldproc;
3718
3719	oldproc = WinSubclassWindow(hwndFrame, (PFNWP) ArcFrameWndProc);
3720	WinSetWindowPtr(hwndFrame, QWL_USER, (PVOID) oldproc);
3721	}
3722	dcd->hwndCnr = WinCreateWindow(hwndClient,
3723	WC_CONTAINER,
3724	NULL,
3725	CCS_AUTOPOSITION \| CCS_MINIICONS \|
3726	CCS_MINIRECORDCORE \| ulCnrType \|
3727	WS_VISIBLE,
3728	0,
3729	0,
3730	0,
3731	0,
3732	hwndClient,
3733	HWND_TOP, (ULONG) ARC_CNR, NULL, NULL);
3734	if (!dcd->hwndCnr) {
3735	Win_Error(hwndClient, hwndClient, pszSrcFile, __LINE__,
3736	PCSZ_WINCREATEWINDOW);
3737	PostMsg(hwndClient, WM_CLOSE, MPVOID, MPVOID);
3738	free(dcd);
3739	hwndFrame = (HWND) 0;
3740	}
3741	else {
3742	WinSetWindowPtr(dcd->hwndCnr, QWL_USER, (PVOID) dcd);
3743	dcd->oldproc = WinSubclassWindow(dcd->hwndCnr,
3744	(PFNWP) ArcCnrWndProc);
3745	{
3746	USHORT ids[] = { DIR_TOTALS, DIR_SELECTED, DIR_VIEW, DIR_SORT,
3747	DIR_FILTER, DIR_FOLDERICON, 0
3748	};
3749
3750	CommonCreateTextChildren(dcd->hwndClient,
3751	WC_ARCSTATUS, ids);
3752	}
3753	WinEnableWindow(WinWindowFromID(dcd->hwndClient, DIR_VIEW), FALSE);
3754	dcd->hwndExtract = WinCreateWindow(dcd->hwndClient,
3755	WC_ENTRYFIELD,
3756	NULL,
3757	ES_AUTOSCROLL,
3758	0,
3759	0,
3760	0,
3761	0,
3762	dcd->hwndClient,
3763	HWND_TOP,
3764	ARC_EXTRACTDIR, NULL, NULL);
3765	WinSendMsg(dcd->hwndExtract,
3766	EM_SETTEXTLIMIT, MPFROM2SHORT(CCHMAXPATH, 0), MPVOID);
3767	WinSetWindowText(dcd->hwndExtract, dcd->directory);
3768	if (!PostMsg(dcd->hwndCnr, UM_SETUP, MPVOID, MPVOID))
3769	WinSendMsg(dcd->hwndCnr, UM_SETUP, MPVOID, MPVOID);
3770	if (FrameFlags & FCF_MENU) {
3771	PFNWP oldmenuproc;
3772	HWND hwndMenu = WinWindowFromID(hwndFrame, FID_MENU);
3773
3774	oldmenuproc = WinSubclassWindow(hwndMenu, (PFNWP) ArcCnrMenuProc);
3775	WinSetWindowPtr(hwndMenu, QWL_USER, (PVOID) oldmenuproc);
3776	if (!fToolbar) {
3777
3778	if (hwndMenu) {
3779	WinSendMsg(hwndMenu, MM_DELETEITEM,
3780	MPFROM2SHORT(IDM_VIEW, FALSE), MPVOID);
3781	WinSendMsg(hwndMenu, MM_DELETEITEM,
3782	MPFROM2SHORT(IDM_EXEC, FALSE), MPVOID);
3783	WinSendMsg(hwndMenu, MM_DELETEITEM,
3784	MPFROM2SHORT(IDM_RESCAN, FALSE), MPVOID);
3785	WinSendMsg(hwndMenu, MM_DELETEITEM,
3786	MPFROM2SHORT(IDM_DELETE, FALSE), MPVOID);
3787	WinSendMsg(hwndMenu, MM_DELETEITEM,
3788	MPFROM2SHORT(IDM_EXTRACT, FALSE), MPVOID);
3789	WinSendMsg(hwndMenu, MM_DELETEITEM,
3790	MPFROM2SHORT(IDM_TEST, FALSE), MPVOID);
3791	WinSendMsg(hwndMenu, MM_DELETEITEM,
3792	MPFROM2SHORT(IDM_VIRUSSCAN, FALSE), MPVOID);
3793	WinSendMsg(hwndMenu, MM_DELETEITEM,
3794	MPFROM2SHORT(IDM_WALKDIR, FALSE), MPVOID);
3795	WinSendMsg(hwndMenu, MM_DELETEITEM,
3796	MPFROM2SHORT(IDM_FILTER, FALSE), MPVOID);
3797	}
3798	}
3799	}
3800	if (FrameFlags & FCF_TASKLIST) {
3801
3802	SWP swp, swpD;
3803	ULONG size = sizeof(swp);
3804	LONG cxScreen, cyScreen;
3805
3806	WinQueryTaskSizePos(WinQueryAnchorBlock(hwndFrame), 0, &swp);
3807	if (PrfQueryProfileData(fmprof, appname, "AV2SizePos", &swpD, &size)) {
3808	cxScreen = WinQuerySysValue(HWND_DESKTOP, SV_CXSCREEN);
3809	cyScreen = WinQuerySysValue(HWND_DESKTOP, SV_CYSCREEN);
3810	if (swp.x + swpD.cx > cxScreen)
3811	swp.x = cxScreen - swpD.cx;
3812	if (swp.y + swpD.cy > cyScreen)
3813	swp.y = cyScreen - swpD.cy;
3814	swp.cx = swpD.cx;
3815	swp.cy = swpD.cy;
3816	}
3817	WinSetWindowPos(hwndFrame,
3818	HWND_TOP,
3819	swp.x,
3820	swp.y,
3821	swp.cx,
3822	swp.cy,
3823	SWP_SIZE \| SWP_MOVE \| SWP_SHOW \| SWP_ZORDER \|
3824	SWP_ACTIVATE);
3825	}
3826	}
3827	}
3828	# ifdef FORTIFY
3829	Fortify_LeaveScope();
3830	# endif
3831	}
3832	}
3833	return hwndFrame;
3834	}
3835
3836	#pragma alloc_text(ARCCNRS,ArcCnrWndProc,ArcObjWndProc,ArcClientWndProc,BldQuotedFullPathName)
3837	#pragma alloc_text(ARCCNRS,ArcTextProc,FillArcCnr,ArcFilter,BldQuotedFileName)
3838	#pragma alloc_text(ARCCNRS,ArcSort,ArcFrameWndProc,IsArcThere,ArcErrProc)
3839	#pragma alloc_text(STARTUP,StartArcCnr)

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

Download in other formats: