Context Navigation

source: trunk/dll/arccnrs.c@ 130

Visit:

Last change on this file since 130 was 130, checked in by root, 20 years ago
Use QWL_USER
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 126.6 KB

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

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

Download in other formats: