source: trunk/dll/arccnrs.c@ 775

Last change on this file since 775 was 775, checked in by Gregg Young, 18 years ago

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