Context Navigation

source: trunk/dll/arccnrs.c@ 1836

Visit:

Last change on this file since 1836 was 1826, checked in by Gregg Young, 10 years ago
Remove misplaced comment
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 109.4 KB

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

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

Download in other formats: