Context Navigation

source: trunk/dll/arccnrs.c@ 1694

Visit:

Last change on this file since 1694 was 1694, checked in by Gregg Young, 12 years ago
Added comments for CS 1690 & 1692
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 106.7 KB

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

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

Download in other formats: