Context Navigation

source: trunk/dll/arccnrs.c@ 1807

Visit:

Last change on this file since 1807 was 1799, checked in by Gregg Young, 11 years ago
Add fix for trap on close while filtered dir container was still populating to collector, arc container and tree container after collector experienced the same trap. Ticket [535]
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 109.7 KB

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

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

Download in other formats: