Context Navigation

source: trunk/dll/arccnrs.c@ 1545

Visit:

Last change on this file since 1545 was 1545, checked in by Gregg Young, 15 years ago
Added ForwardslashToBackslash function to streamline code.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 105.7 KB

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

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

Download in other formats: