Context Navigation

source: trunk/dll/arccnrs.c@ 1104

Visit:

Last change on this file since 1104 was 1104, checked in by Gregg Young, 17 years ago
Replace save_dir2(dir) with strcpy(dir, pFM2SaveDirectory)
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 99.3 KB

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

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

Download in other formats: