Context Navigation

source: trunk/dll/arccnrs.c@ 1482

Visit:

Last change on this file since 1482 was 1482, checked in by Gregg Young, 16 years ago
Fixed separate parameters; added the ability to set it either globally or for just one app; some files only contain white space changes.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 105.2 KB

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

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

Download in other formats: