source: trunk/dll/arccnrs.c@ 773

Last change on this file since 773 was 773, checked in by Steven Levine, 18 years ago

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