Context Navigation

source: trunk/dll/arccnrs.c@ 1117

Visit:

Last change on this file since 1117 was 1117, checked in by Gregg Young, 17 years ago
Check disk free space before writing data files to prevent traps from being on a full disk (ticket 154)
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 99.1 KB

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

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

Download in other formats: