Context Navigation

source: trunk/dll/arccnrs.c@ 1068

Visit:

Last change on this file since 1068 was 1068, checked in by John Small, 17 years ago
Ticket 126: Add support for WPS open default & open settings in arccnrs
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 98.6 KB

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

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

Download in other formats: