Context Navigation

source: trunk/dll/arccnrs.c@ 1752

Visit:

Last change on this file since 1752 was 1752, checked in by Gregg Young, 11 years ago
Fixed error checking in FillArcCnr only to report missing archivers after all entries have been tried. Added a check b/gzip exes for TAR.B/GZ archives. Use the test archive string from the first working archive description. Enhance the error message. Ticket 502 Fix a trap caused by selecting "print" from the arccontainer menu. Ticket 525 Fix the problem with copying text from the test archive window by launching it in a command shell (i.e. comspec /k archiver -t archive) Ticket 503
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 111.0 KB

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

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

Download in other formats: