Context Navigation

source: trunk/dll/arccnrs.c@ 212

Visit:

Last change on this file since 212 was 212, checked in by root, 20 years ago
Drop obsolete, localize Correct last sort logic Use QWL_USER
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 126.9 KB

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

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

Download in other formats: