source: trunk/dll/arccnrs.c@ 1037

Last change on this file since 1037 was 1037, checked in by Gregg Young, 17 years ago

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