Context Navigation

source: trunk/dll/arccnrs.c@ 1183

Visit:

Last change on this file since 1183 was 1183, checked in by John Small, 17 years ago
Ticket 187: Draft 2: Move remaining function declarations
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 101.4 KB

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

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

Download in other formats: