Context Navigation

source: trunk/dll/arccnrs.c@ 1242

Visit:

Last change on this file since 1242 was 1242, checked in by John Small, 17 years ago
Ticket 288: Ensure DEBUG is passed to compiler and cleanup obsolete #ifdef DEBUG code
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 101.7 KB

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

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

Download in other formats: