Context Navigation

source: trunk/dll/arccnrs.c@ 783

Visit:

Last change on this file since 783 was 775, checked in by Gregg Young, 18 years ago
Minor clean up add comments re recent changes
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 99.0 KB

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

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

Download in other formats: