source: trunk/dll/arccnrs.c@ 1032

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

Fortify updates including a leave scope wrapper which frees and in some cases reloads commands, archivers, association, etc.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 96.7 KB
Line 
1
2/***********************************************************************
3
4 $Id: arccnrs.c 1032 2008-06-30 02:55:36Z 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();
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 ret;
2550
2551 ret = StartMLEEditor(dcd->hwndParent,
2552 (INT) mp1, (CHAR *) mp2, dcd->hwndFrame);
2553 xfree((CHAR *) mp2, pszSrcFile, __LINE__);
2554 return MRFROMLONG(ret);
2555 }
2556 return 0;
2557
2558 case UM_COMMAND:
2559 if (mp1) {
2560 if (dcd) {
2561 if (!PostMsg(dcd->hwndObject, UM_COMMAND, mp1, mp2)) {
2562 Runtime_Error(pszSrcFile, __LINE__, "post");
2563 FreeListInfo((LISTINFO *) mp1);
2564 }
2565 else
2566 return (MRESULT) TRUE;
2567 }
2568 else
2569 FreeListInfo((LISTINFO *) mp1);
2570 }
2571 return 0;
2572
2573 case UM_OPENWINDOWFORME:
2574 if (dcd) {
2575 if (mp1 && !IsFile((CHAR *) mp1)) {
2576 OpenDirCnr((HWND) 0, hwndMain, dcd->hwndFrame, FALSE, (char *)mp1);
2577 }
2578 else if (mp1 && IsFile(mp1) == 1) {
2579 StartArcCnr(HWND_DESKTOP,
2580 dcd->hwndFrame, (CHAR *) mp1, 4, (ARC_TYPE *) mp2);
2581 }
2582 }
2583 return 0;
2584
2585 case WM_COMMAND:
2586 DosError(FERR_DISABLEHARDERR);
2587 if (dcd) {
2588 if (SwitchCommand(dcd->hwndLastMenu, SHORT1FROMMP(mp1)))
2589 return 0;
2590 if (WinSendMsg(hwnd, UM_SETDIR, MPVOID, MPVOID))
2591 return 0;
2592 if (!IsArcThere(hwnd, dcd->arcname)) {
2593 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
2594 return 0;
2595 }
2596 switch (SHORT1FROMMP(mp1)) {
2597 case IDM_TREEVIEW:
2598
2599 break;
2600
2601 case IDM_CONTEXTMENU:
2602 {
2603 PCNRITEM pci;
2604
2605 pci = (PCNRITEM) CurrentRecord(hwnd);
2606 PostMsg(hwnd,
2607 WM_CONTROL,
2608 MPFROM2SHORT(ARC_CNR, CN_CONTEXTMENU), MPFROMP(pci));
2609 }
2610 break;
2611
2612 case IDM_NEXTWINDOW:
2613 case IDM_PREVWINDOW:
2614 {
2615 HWND hwndActive;
2616
2617 hwndActive = WinQueryFocus(HWND_DESKTOP);
2618 WinSetFocus(HWND_DESKTOP,
2619 hwndActive == hwnd ?
2620 WinWindowFromID(dcd->hwndClient, ARC_EXTRACTDIR) :
2621 hwnd);
2622 }
2623 break;
2624
2625 case IDM_FOLDERAFTEREXTRACT:
2626 fFolderAfterExtract = fFolderAfterExtract ? FALSE : TRUE;
2627 PrfWriteProfileData(fmprof, appname, "FolderAfterExtract",
2628 &fFolderAfterExtract, sizeof(BOOL));
2629 break;
2630
2631 case IDM_SHOWSELECT:
2632 QuickPopup(hwnd, dcd, CheckMenu(hwnd, &ArcCnrMenu, ARCCNR_POPUP),
2633 IDM_SELECTSUBMENU);
2634 break;
2635
2636 case IDM_SHOWSORT:
2637 QuickPopup(hwnd, dcd, CheckMenu(hwnd, &ArcCnrMenu, ARCCNR_POPUP),
2638 IDM_SORTSUBMENU);
2639 break;
2640
2641 case IDM_ARCHIVERSETTINGS:
2642 if (!ParentIsDesktop(dcd->hwndParent, dcd->hwndParent))
2643 PostMsg(dcd->hwndParent, msg, MPFROMLONG(IDM_ARCHIVERSETTINGS), mp2);
2644 else {
2645 WinDlgBox(HWND_DESKTOP,
2646 hwnd,
2647 CfgDlgProc,
2648 FM3ModHandle,
2649 CFG_FRAME,
2650 MPFROMLONG(IDM_ARCHIVERSETTINGS));
2651 }
2652 break;
2653
2654 case IDM_RESCAN:
2655 dcd->ullTotalBytes = dcd->totalfiles =
2656 dcd->selectedfiles = dcd->selectedbytes = 0;
2657 WinSetDlgItemText(dcd->hwndClient, DIR_TOTALS, "0");
2658 WinSetDlgItemText(dcd->hwndClient, DIR_SELECTED, "0 / 0k");
2659 dcd->totalfiles = FillArcCnr(dcd->hwndCnr,
2660 dcd->arcname,
2661 &dcd->info,
2662 &dcd->ullTotalBytes, &dcd->stopflag);
2663 PostMsg(dcd->hwndCnr, UM_RESCAN, MPVOID, MPVOID);
2664 PostMsg(dcd->hwndCnr, UM_SETUP2, MPVOID, MPVOID);
2665 WinSendMsg(dcd->hwndCnr,
2666 CM_INVALIDATERECORD,
2667 MPVOID, MPFROM2SHORT(0, CMA_ERASE | CMA_REPOSITION));
2668 break;
2669
2670 case IDM_RESELECT:
2671 SelectList(hwnd, TRUE, FALSE, FALSE, NULL, NULL, dcd->lastselection);
2672 break;
2673
2674 case IDM_HELP:
2675 if (hwndHelp)
2676 WinSendMsg(hwndHelp,
2677 HM_DISPLAY_HELP,
2678 MPFROM2SHORT(HELP_ARCLIST, 0),
2679 MPFROMSHORT(HM_RESOURCEID));
2680 break;
2681
2682 case IDM_WINDOWDLG:
2683 if (!ParentIsDesktop(dcd->hwndParent, dcd->hwndFrame))
2684 PostMsg(dcd->hwndParent,
2685 UM_COMMAND, MPFROM2SHORT(IDM_WINDOWDLG, 0), MPVOID);
2686 break;
2687
2688 case IDM_SELECTALL:
2689 case IDM_SELECTALLFILES:
2690 case IDM_DESELECTALL:
2691 case IDM_DESELECTALLFILES:
2692 case IDM_SELECTMASK:
2693 case IDM_DESELECTMASK:
2694 case IDM_INVERT:
2695 {
2696 PARCITEM pci;
2697
2698 pci = (PARCITEM) WinSendMsg(hwnd,
2699 CM_QUERYRECORDEMPHASIS,
2700 MPFROMLONG(CMA_FIRST),
2701 MPFROMSHORT(CRA_CURSORED));
2702 if ((INT) pci == -1)
2703 pci = NULL;
2704 if (SHORT1FROMMP(mp1) == IDM_HIDEALL) {
2705 if (pci) {
2706 if (!(pci->rc.flRecordAttr & CRA_SELECTED))
2707 pci->rc.flRecordAttr |= CRA_FILTERED;
2708 WinSendMsg(hwnd,
2709 CM_INVALIDATERECORD,
2710 MPFROMP(&pci),
2711 MPFROM2SHORT(1, CMA_ERASE | CMA_REPOSITION));
2712 break;
2713 }
2714 }
2715 PostMsg(dcd->hwndObject, UM_SELECT, mp1, MPFROMP(pci));
2716 }
2717 break;
2718
2719 case IDM_SORTSMARTNAME:
2720 case IDM_SORTNAME:
2721 case IDM_SORTFILENAME:
2722 case IDM_SORTSIZE:
2723 case IDM_SORTEASIZE:
2724 case IDM_SORTFIRST:
2725 case IDM_SORTLAST:
2726 case IDM_SORTLWDATE:
2727 dcd->sortFlags &= SORT_REVERSE;
2728 /* intentional fallthru */
2729 case IDM_SORTREVERSE:
2730 switch (SHORT1FROMMP(mp1)) {
2731 case IDM_SORTSMARTNAME:
2732 case IDM_SORTFILENAME:
2733 dcd->sortFlags |= SORT_FILENAME;
2734 break;
2735 case IDM_SORTSIZE:
2736 dcd->sortFlags |= SORT_SIZE;
2737 break;
2738 case IDM_SORTEASIZE:
2739 dcd->sortFlags |= SORT_EASIZE;
2740 break;
2741 case IDM_SORTFIRST:
2742 dcd->sortFlags |= SORT_FIRSTEXTENSION;
2743 break;
2744 case IDM_SORTLAST:
2745 dcd->sortFlags |= SORT_LASTEXTENSION;
2746 break;
2747 case IDM_SORTLWDATE:
2748 dcd->sortFlags |= SORT_LWDATE;
2749 break;
2750 case IDM_SORTREVERSE:
2751 if (dcd->sortFlags & SORT_REVERSE)
2752 dcd->sortFlags &= (~SORT_REVERSE);
2753 else
2754 dcd->sortFlags |= SORT_REVERSE;
2755 break;
2756 }
2757 WinSendMsg(hwnd, CM_SORTRECORD, MPFROMP(ArcSort), MPFROMP(dcd));
2758 SaySort(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
2759 DIR_SORT), dcd->sortFlags, TRUE);
2760 DefArcSortFlags = dcd->sortFlags; // Remember for new windows
2761 break;
2762
2763 case IDM_COLLECTOR:
2764 if (!Collector) {
2765 HWND hwndC;
2766 SWP swp;
2767
2768 if (ParentIsDesktop(hwnd, dcd->hwndParent) && !fAutoTile &&
2769 (!fExternalCollector && !strcmp(realappname, FM3Str)))
2770 GetNextWindowPos(dcd->hwndParent, &swp, NULL, NULL);
2771 hwndC = StartCollector(fExternalCollector ||
2772 strcmp(realappname, FM3Str) ?
2773 HWND_DESKTOP : dcd->hwndParent, 4);
2774 if (hwndC) {
2775 if (!ParentIsDesktop(hwnd, dcd->hwndParent) && !fAutoTile &&
2776 (!fExternalCollector && !strcmp(realappname, FM3Str)))
2777 WinSetWindowPos(hwndC,
2778 HWND_TOP,
2779 swp.x,
2780 swp.y,
2781 swp.cx,
2782 swp.cy,
2783 SWP_MOVE | SWP_SIZE | SWP_SHOW | SWP_ZORDER);
2784 else if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
2785 fAutoTile && !strcmp(realappname, FM3Str)) {
2786 TileChildren(dcd->hwndParent, TRUE);
2787 }
2788 WinSetWindowPos(hwndC, HWND_TOP, 0, 0, 0, 0, SWP_ACTIVATE);
2789 DosSleep(100); //05 Aug 07 GKY 128
2790 }
2791 }
2792 else
2793 StartCollector(dcd->hwndParent, 4);
2794 break;
2795
2796 case IDM_ARCEXTRACTEXIT:
2797 case IDM_ARCEXTRACT:
2798 if (dcd->info->extract)
2799 runemf2(SEPARATE | WINDOWED |
2800 (fArcStuffVisible ? 0 : BACKGROUND | MINIMIZED),
2801 hwnd, pszSrcFile, __LINE__,
2802 dcd->directory, NULL, "%s %s", dcd->info->extract,
2803 BldQuotedFileName(szQuotedArcName, dcd->arcname));
2804 if (SHORT1FROMMP(mp1) == IDM_ARCEXTRACTEXIT)
2805 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
2806 break;
2807
2808 case IDM_ARCEXTRACTWDIRSEXIT:
2809 case IDM_ARCEXTRACTWDIRS:
2810 if (dcd->info->exwdirs)
2811 runemf2(SEPARATE | WINDOWED |
2812 (fArcStuffVisible ? 0 : BACKGROUND | MINIMIZED),
2813 hwnd, pszSrcFile, __LINE__,
2814 dcd->directory, NULL, "%s %s",
2815 dcd->info->exwdirs,
2816 BldQuotedFileName(szQuotedArcName, dcd->arcname));
2817 if (SHORT1FROMMP(mp1) == IDM_ARCEXTRACTWDIRSEXIT)
2818 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
2819 break;
2820
2821 case IDM_RESORT:
2822 WinSendMsg(hwnd, CM_SORTRECORD, MPFROMP(ArcSort), MPFROMP(dcd));
2823 break;
2824
2825 case IDM_FILTER:
2826 {
2827 BOOL empty = FALSE;
2828 PARCITEM pci;
2829
2830 if (!*dcd->mask.szMask) {
2831 empty = TRUE;
2832 pci = (PARCITEM) CurrentRecord(hwnd);
2833 if (pci && strchr(pci->pszFileName, '.'))
2834 strcpy(dcd->mask.szMask, pci->pszFileName);
2835 }
2836
2837 if (WinDlgBox(HWND_DESKTOP, hwnd, PickMaskDlgProc,
2838 FM3ModHandle, MSK_FRAME, MPFROMP(&dcd->mask))) {
2839 WinSendMsg(hwnd, CM_FILTER, MPFROMP(ArcFilter), MPFROMP(dcd));
2840 PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
2841 }
2842 else if (empty)
2843 *dcd->mask.szMask = 0;
2844 SayFilter(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
2845 DIR_FILTER), &dcd->mask, TRUE);
2846 }
2847 break;
2848
2849 case IDM_SWITCH:
2850 if (mp2) {
2851 if (stricmp(dcd->directory, (CHAR *) mp2)) {
2852 DosEnterCritSec();
2853 strcpy(lastextractpath, (CHAR *) mp2);
2854 MakeValidDir(lastextractpath);
2855 DosExitCritSec();
2856 }
2857 strcpy(dcd->directory, (CHAR *) mp2);
2858 MakeValidDir(dcd->directory);
2859 WinSetWindowText(dcd->hwndExtract, dcd->directory);
2860 }
2861 break;
2862
2863 case IDM_WALKDIR:
2864 {
2865 CHAR newdir[CCHMAXPATH];
2866
2867 strcpy(newdir, dcd->directory);
2868 if (!WinDlgBox(HWND_DESKTOP, dcd->hwndParent, WalkExtractDlgProc,
2869 FM3ModHandle, WALK_FRAME,
2870 MPFROMP(newdir)) || !*newdir)
2871 break;
2872 if (stricmp(newdir, dcd->directory)) {
2873 strcpy(dcd->directory, newdir);
2874 if (stricmp(lastextractpath, newdir))
2875 strcpy(lastextractpath, newdir);
2876 WinSetWindowText(dcd->hwndExtract, dcd->directory);
2877 }
2878 }
2879 break;
2880
2881 case IDM_TEST:
2882 if (dcd->info->test)
2883 runemf2(SEPARATEKEEP | WINDOWED | MAXIMIZED,
2884 hwnd, pszSrcFile, __LINE__, NULL, NULL,
2885 "%s %s",dcd->info->test,
2886 BldQuotedFileName(szQuotedArcName, dcd->arcname));
2887 break;
2888
2889 case IDM_REFRESH:
2890 case IDM_DELETE:
2891 case IDM_PRINT:
2892 case IDM_VIEW:
2893 case IDM_VIEWTEXT:
2894 case IDM_VIEWBINARY:
2895 case IDM_VIEWARCHIVE:
2896 case IDM_EDIT:
2897 case IDM_EDITTEXT:
2898 case IDM_EDITBINARY:
2899 case IDM_EXTRACT:
2900 case IDM_EXTRACTWDIRS:
2901 case IDM_FIND:
2902 case IDM_EXEC:
2903 case IDM_VIRUSSCAN:
2904 {
2905 LISTINFO *li;
2906# ifdef FORTIFY
2907 Fortify_EnterScope();
2908# endif
2909 li = xmallocz(sizeof(LISTINFO), pszSrcFile, __LINE__);
2910 if (li) {
2911 li->type = SHORT1FROMMP(mp1);
2912 li->hwnd = hwnd;
2913 li->list = BuildArcList(hwnd);
2914 if (li->type == IDM_REFRESH) {
2915
2916 CHAR s[CCHMAXPATH], *p;
2917 INT x, y;
2918
2919 for (x = 0; li->list && li->list[x]; x++) {
2920 BldFullPathName(s, dcd->workdir, li->list[x]);
2921 if (IsFile(s) != 1) {
2922 xfree(li->list[x], pszSrcFile, __LINE__);
2923 li->list[x] = NULL;
2924 for (y = x; li->list[y]; y++)
2925 li->list[y] = li->list[y + 1];
2926 li->list =
2927 xrealloc(li->list, y * sizeof(CHAR *), pszSrcFile,
2928 __LINE__);
2929 x--;
2930 }
2931 else {
2932 p = xstrdup(s, pszSrcFile, __LINE__);
2933 if (p) {
2934 xfree(li->list[x], pszSrcFile, __LINE__);
2935 li->list[x] = p;
2936 }
2937 }
2938 } // for
2939 }
2940 strcpy(li->arcname, dcd->arcname);
2941 li->info = dcd->info;
2942 {
2943 PARCITEM pai;
2944
2945 if (SHORT1FROMMP(mp1) != IDM_EXEC)
2946 pai = (PARCITEM) CurrentRecord(hwnd);
2947 else
2948 pai = (PARCITEM) WinSendMsg(hwnd, CM_QUERYRECORDEMPHASIS,
2949 MPFROMLONG(CMA_FIRST),
2950 MPFROMSHORT(CRA_CURSORED));
2951 if (pai && (INT) pai != -1)
2952 strcpy(li->runfile, pai->pszFileName);
2953 else
2954 strcpy(li->runfile, li->list[0]);
2955 }
2956 switch (SHORT1FROMMP(mp1)) {
2957 case IDM_VIEW:
2958 case IDM_VIEWTEXT:
2959 case IDM_VIEWBINARY:
2960 case IDM_VIEWARCHIVE:
2961 case IDM_EDIT:
2962 case IDM_EDITTEXT:
2963 case IDM_EDITBINARY:
2964 case IDM_EXEC:
2965 case IDM_PRINT:
2966 case IDM_VIRUSSCAN:
2967 strcpy(li->targetpath, dcd->workdir);
2968 break;
2969 default:
2970 strcpy(li->targetpath, dcd->directory);
2971 break;
2972 }
2973 if (li->list) {
2974 if (!PostMsg(dcd->hwndObject, UM_ACTION, MPFROMP(li), MPVOID)) {
2975 Runtime_Error(pszSrcFile, __LINE__, "post");
2976 FreeListInfo(li);
2977 }
2978 else if (fUnHilite && SHORT1FROMMP(mp1) != IDM_EDIT)
2979 UnHilite(hwnd, TRUE, &dcd->lastselection, 0);
2980 }
2981 else
2982 xfree(li, pszSrcFile, __LINE__);
2983# ifdef FORTIFY
2984 Fortify_LeaveScope();
2985# endif
2986 }
2987 }
2988 break;
2989 }
2990 }
2991 return 0;
2992
2993 case WM_CONTROL:
2994 DosError(FERR_DISABLEHARDERR);
2995 if (dcd) {
2996 switch (SHORT2FROMMP(mp1)) {
2997 case CN_BEGINEDIT:
2998 PostMsg(hwnd, CM_CLOSEEDIT, MPVOID, MPVOID);
2999 break;
3000
3001 case CN_ENDEDIT:
3002 if (!((PCNREDITDATA) mp2)->pRecord) {
3003
3004 PFIELDINFO pfi = ((PCNREDITDATA) mp2)->pFieldInfo;
3005 USHORT cmd = 0;
3006
3007 if (!pfi || pfi->offStruct == FIELDOFFSET(ARCITEM, pszDisplayName))
3008 cmd = IDM_SORTSMARTNAME;
3009 else if (pfi->offStruct == FIELDOFFSET(ARCITEM, cbFile))
3010 cmd = IDM_SORTSIZE;
3011 else if (pfi->offStruct == FIELDOFFSET(ARCITEM, cbComp))
3012 cmd = IDM_SORTEASIZE;
3013 else if (pfi->offStruct == FIELDOFFSET(ARCITEM, date))
3014 cmd = IDM_SORTLWDATE;
3015 else if (pfi->offStruct == FIELDOFFSET(ARCITEM, time))
3016 cmd = IDM_SORTLWDATE;
3017 if (cmd)
3018 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(cmd, 0), MPVOID);
3019 }
3020 break;
3021
3022 case CN_DROPHELP:
3023 saymsg(MB_ENTER, hwnd,
3024 GetPString(IDS_DROPHELPHDRTEXT),
3025 GetPString(IDS_ARCCNRDROPHELPTEXT), dcd->arcname);
3026 return 0;
3027
3028 case CN_DRAGLEAVE:
3029 if (mp2) {
3030
3031 PDRAGINFO pDInfo;
3032
3033 pDInfo = ((PCNRDRAGINFO) mp2)->pDragInfo;
3034 DrgAccessDraginfo(pDInfo); /* Access DRAGINFO */
3035 DrgFreeDraginfo(pDInfo); /* Free DRAGINFO */
3036 }
3037 return 0;
3038
3039 case CN_DRAGAFTER:
3040 case CN_DRAGOVER:
3041 if (mp2) {
3042
3043 PDRAGITEM pDItem; /* Pointer to DRAGITEM */
3044 PDRAGINFO pDInfo; /* Pointer to DRAGINFO */
3045 PARCITEM pci;
3046
3047 pci = (PARCITEM) ((PCNRDRAGINFO) mp2)->pRecord;
3048 if (SHORT1FROMMP(mp1) == CN_DRAGAFTER)
3049 pci = NULL;
3050 pDInfo = ((PCNRDRAGINFO) mp2)->pDragInfo;
3051 DrgAccessDraginfo(pDInfo); /* Access DRAGINFO */
3052 if (*dcd->arcname) {
3053 if ((driveflags[toupper(*dcd->arcname) - 'A'] &
3054 DRIVE_NOTWRITEABLE) || !dcd->info || !dcd->info->create) {
3055 DrgFreeDraginfo(pDInfo);
3056 return MRFROM2SHORT(DOR_NEVERDROP, 0);
3057 }
3058 }
3059 if (pci) {
3060 DrgFreeDraginfo(pDInfo);
3061 return MRFROM2SHORT(DOR_NODROP, 0);
3062 }
3063 pDItem = DrgQueryDragitemPtr(pDInfo, /* Access DRAGITEM */
3064 0); /* Index to DRAGITEM */
3065 if (DrgVerifyRMF(pDItem, /* Check valid rendering */
3066 DRM_OS2FILE, /* mechanisms and data */
3067 NULL) && !(pDItem->fsControl & DC_PREPARE)) {
3068 DrgFreeDraginfo(pDInfo); /* Free DRAGINFO */
3069 return MRFROM2SHORT(DOR_DROP, /* Return okay to drop */
3070 fCopyDefault ? DO_COPY : DO_MOVE);
3071 }
3072 DrgFreeDraginfo(pDInfo); /* Free DRAGINFO */
3073 }
3074 return (MRFROM2SHORT(DOR_NEVERDROP, 0)); /* Drop not valid */
3075
3076 case CN_INITDRAG:
3077 if (mp2) {
3078
3079 BOOL wasemphasized = FALSE;
3080 PCNRDRAGINIT pcd = (PCNRDRAGINIT) mp2;
3081 PARCITEM pci;
3082
3083 if (pcd) {
3084 pci = (PARCITEM) pcd->pRecord;
3085 if (pci) {
3086 if (pci->rc.flRecordAttr & CRA_SELECTED)
3087 wasemphasized = TRUE;
3088 if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
3089 fSplitStatus && hwndStatus2)
3090 WinSetWindowText(hwndStatus2, GetPString(IDS_DRAGARCMEMTEXT));
3091 if (DoFileDrag(hwnd,
3092 dcd->hwndObject,
3093 mp2, dcd->arcname, NULL, TRUE)) {
3094 if ((fUnHilite && wasemphasized) || dcd->ulItemsToUnHilite)
3095 UnHilite(hwnd, TRUE, &dcd->lastselection, dcd->ulItemsToUnHilite);
3096 }
3097 if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
3098 fSplitStatus && hwndStatus2) {
3099 PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
3100 }
3101 }
3102 else {
3103 if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
3104 fSplitStatus && hwndStatus2)
3105 WinSetWindowText(hwndStatus2,
3106 GetPString(IDS_DRAGARCFILETEXT));
3107 DragOne(hwnd, dcd->hwndObject, dcd->arcname, FALSE);
3108 if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
3109 fSplitStatus && hwndStatus2)
3110 PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
3111 }
3112 }
3113 }
3114 return 0;
3115
3116 case CN_DROP:
3117 if (mp2) {
3118
3119 LISTINFO *li;
3120
3121 DosBeep(500, 100); // fixme to know why beep?
3122 li = DoFileDrop(hwnd, dcd->arcname, FALSE, mp1, mp2);
3123 DosBeep(50, 100); // fixme to know why beep?
3124 CheckPmDrgLimit(((PCNRDRAGINFO)mp2)->pDragInfo);
3125 if (li) {
3126 li->type = li->type == DO_MOVE ? IDM_ARCHIVEM : IDM_ARCHIVE;
3127 strcpy(li->targetpath, dcd->arcname);
3128 if (!li->list ||
3129 !li->list[0] ||
3130 !PostMsg(dcd->hwndObject, UM_ACTION, MPFROMP(li), MPVOID))
3131 FreeListInfo(li);
3132 }
3133 }
3134 return 0;
3135
3136 case CN_CONTEXTMENU:
3137 {
3138 PARCITEM pci = (PARCITEM) mp2;
3139
3140 if (pci) {
3141 WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPFROMP(pci),
3142 MPFROM2SHORT(TRUE, CRA_CURSORED));
3143 MarkAll(hwnd, FALSE, FALSE, TRUE);
3144 dcd->hwndLastMenu = CheckMenu(hwnd, &ArcMenu, ARC_POPUP);
3145 }
3146 else {
3147 dcd->hwndLastMenu = CheckMenu(hwnd, &ArcCnrMenu, ARCCNR_POPUP);
3148 if (dcd->hwndLastMenu && !dcd->cnremphasized) {
3149 WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPVOID,
3150 MPFROM2SHORT(TRUE, CRA_SOURCE));
3151 dcd->cnremphasized = TRUE;
3152 }
3153 }
3154 if (dcd->hwndLastMenu) {
3155 if (dcd->hwndLastMenu == ArcCnrMenu) {
3156 if (dcd->flWindowAttr & CV_MINI)
3157 WinCheckMenuItem(dcd->hwndLastMenu, IDM_MINIICONS, TRUE);
3158 }
3159 WinCheckMenuItem(dcd->hwndLastMenu, IDM_FOLDERAFTEREXTRACT,
3160 fFolderAfterExtract);
3161 if (!PopupMenu(hwnd, hwnd, dcd->hwndLastMenu)) {
3162 if (dcd->cnremphasized) {
3163 WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPVOID,
3164 MPFROM2SHORT(FALSE, CRA_SOURCE));
3165 dcd->cnremphasized = TRUE;
3166 }
3167 MarkAll(hwnd, TRUE, FALSE, TRUE);
3168 }
3169 }
3170 }
3171 break;
3172
3173 case CN_EMPHASIS:
3174 if (mp2) {
3175
3176 PNOTIFYRECORDEMPHASIS pre = mp2;
3177 PARCITEM pci;
3178 CHAR s[CCHMAXPATHCOMP + 91], tf[81], tb[81];
3179
3180 pci = (PARCITEM)(pre ? pre->pRecord : NULL);
3181 if (!pci) {
3182 if (!ParentIsDesktop(hwnd, dcd->hwndParent)) {
3183 if (hwndStatus2)
3184 WinSetWindowText(hwndStatus2, NullStr);
3185 if (fMoreButtons)
3186 WinSetWindowText(hwndName, NullStr);
3187 }
3188 break;
3189 }
3190 if (pre->fEmphasisMask & CRA_SELECTED) {
3191 if (pci->rc.flRecordAttr & CRA_SELECTED) {
3192 dcd->selectedbytes += pci->cbFile;
3193 dcd->selectedfiles++;
3194 }
3195 else if (dcd->selectedfiles) {
3196 dcd->selectedbytes -= pci->cbFile;
3197 dcd->selectedfiles--;
3198 }
3199 commafmt(tf, sizeof(tf), dcd->selectedfiles);
3200 if (dcd->ullTotalBytes)
3201 CommaFmtULL(tb, sizeof(tb), dcd->selectedbytes, ' ');
3202 else
3203 *tb = 0;
3204 sprintf(s, "%s%s%s", tf, *tb ? " / " : NullStr, tb);
3205 WinSetDlgItemText(dcd->hwndClient, DIR_SELECTED, s);
3206 }
3207 else if (WinQueryActiveWindow(dcd->hwndParent) ==
3208 dcd->hwndFrame &&
3209 !ParentIsDesktop(hwnd, dcd->hwndParent)) {
3210 if (pre->fEmphasisMask & CRA_CURSORED) {
3211 if (pci->rc.flRecordAttr & CRA_CURSORED) {
3212 if (fSplitStatus && hwndStatus2) {
3213 if (dcd->ullTotalBytes)
3214 CommaFmtULL(tb, sizeof(tb), pci->cbFile, ' ');
3215 else
3216 *tb = 0;
3217 sprintf(s, "%s%s%s%s",
3218 *tb ? " " : NullStr,
3219 tb, *tb ? " " : NullStr, pci->pszFileName);
3220 WinSetWindowText(hwndStatus2, s);
3221 }
3222 if (fMoreButtons)
3223 WinSetWindowText(hwndName, pci->pszFileName);
3224 }
3225 }
3226 }
3227 }
3228 break;
3229
3230 case CN_ENTER:
3231 if (mp2) {
3232
3233 PARCITEM pci = (PARCITEM) ((PNOTIFYRECORDENTER) mp2)->pRecord;
3234
3235 if (pci) {
3236
3237 CHAR *s;
3238
3239 if ((pci->rc.flRecordAttr & CRA_INUSE) ||
3240 (pci->flags & (ARCFLAGS_REALDIR | ARCFLAGS_PSEUDODIR)))
3241 break;
3242 s = xstrdup(pci->pszFileName, pszSrcFile, __LINE__);
3243 if (s) {
3244 if (!PostMsg(dcd->hwndObject, UM_ENTER, MPFROMP(s), MPVOID)) {
3245 Runtime_Error(pszSrcFile, __LINE__, "post");
3246 xfree(s, pszSrcFile, __LINE__);
3247 }
3248 }
3249 }
3250 }
3251 break;
3252 }
3253 }
3254 return 0;
3255
3256 case UM_FOLDUP:
3257 if (!PostMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID))
3258 DosExit(EXIT_PROCESS, 1);
3259 return 0;
3260
3261 case UM_CLOSE:
3262 WinDestroyWindow(WinQueryWindow(WinQueryWindow(hwnd, QW_PARENT),
3263 QW_PARENT));
3264 return 0;
3265
3266 case WM_SAVEAPPLICATION:
3267 if (dcd && ParentIsDesktop(hwnd, dcd->hwndParent)) {
3268 SWP swp;
3269
3270 WinQueryWindowPos(dcd->hwndFrame, &swp);
3271 if (!(swp.fl & (SWP_HIDE | SWP_MINIMIZE | SWP_MAXIMIZE)))
3272 PrfWriteProfileData(fmprof, appname, "AV2SizePos", &swp, sizeof(swp));
3273 }
3274 break;
3275
3276 case WM_CLOSE:
3277 WinSendMsg(hwnd, WM_SAVEAPPLICATION, MPVOID, MPVOID);
3278 if (dcd)
3279 dcd->stopflag++;
3280 if (dcd && dcd->hwndObject) {
3281 if (!PostMsg(dcd->hwndObject, WM_CLOSE, MPVOID, MPVOID))
3282 WinSendMsg(dcd->hwndObject, WM_CLOSE, MPVOID, MPVOID);
3283 }
3284 // In case object window frees dcd
3285 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
3286 if (!dcd ||
3287 (!dcd->dontclose &&
3288 !dcd->amextracted && ParentIsDesktop(hwnd, dcd->hwndParent))) {
3289 if (!PostMsg(hwnd, UM_FOLDUP, MPVOID, MPVOID))
3290 WinSendMsg(hwnd, UM_FOLDUP, MPVOID, MPVOID);
3291 }
3292 return 0;
3293
3294 case WM_DESTROY:
3295 if (ArcMenu)
3296 WinDestroyWindow(ArcMenu);
3297 if (ArcCnrMenu)
3298 WinDestroyWindow(ArcCnrMenu);
3299 ArcMenu = ArcCnrMenu = (HWND) 0;
3300 EmptyArcCnr(hwnd);
3301 break;
3302 }
3303 if (dcd && dcd->oldproc){
3304 return dcd->oldproc(hwnd, msg, mp1, mp2);
3305 }
3306 else
3307 return PFNWPCnr(hwnd, msg, mp1, mp2);
3308}
3309
3310MRESULT EXPENTRY ArcCnrMenuProc(HWND hwnd, ULONG msg, MPARAM mp1,
3311 MPARAM mp2)
3312{
3313 PFNWP oldMenuProc = WinQueryWindowPtr(hwnd, QWL_USER);
3314 static short sLastMenuitem;
3315
3316 switch (msg) {
3317 case WM_MOUSEMOVE: {
3318 if (fOtherHelp) {
3319 RECTL rectl;
3320 SHORT i, sCurrentMenuitem;
3321 SHORT MenuItems = 10;
3322 SHORT asMenuIDs[10] = {IDM_VIEW,
3323 IDM_DELETE,
3324 IDM_EXEC,
3325 IDM_EXTRACT,
3326 IDM_TEST,
3327 IDM_VIRUSSCAN,
3328 IDM_RESCAN,
3329 IDM_WALKDIR,
3330 IDM_FILTER,
3331 0};
3332 char *szHelpString = NULL;
3333
3334
3335 for (i=0; i<MenuItems; i++) {
3336 sCurrentMenuitem = asMenuIDs[i];
3337 oldMenuProc(hwnd,MM_QUERYITEMRECT,
3338 MPFROM2SHORT(asMenuIDs[i], FALSE),
3339 &rectl);
3340
3341 if (MOUSEMSG(&msg)->x > rectl.xLeft &&
3342 MOUSEMSG(&msg)->x < rectl.xRight &&
3343 MOUSEMSG(&msg)->y > rectl.yBottom &&
3344 MOUSEMSG(&msg)->y < rectl.yTop)
3345 break;
3346 } // for
3347
3348
3349 switch (sCurrentMenuitem) {
3350 case 0:
3351 break;
3352 case IDM_VIEW:
3353 szHelpString = GetPString(IDS_ARCCNRVIEWMENUHELP);
3354 break;
3355 case IDM_DELETE:
3356 szHelpString = GetPString(IDS_ARCCNRDELETEMENUHELP);
3357 break;
3358 case IDM_EXEC:
3359 szHelpString = GetPString(IDS_ARCCNREXECMENUHELP);
3360 break;
3361 case IDM_EXTRACT:
3362 szHelpString = GetPString(IDS_ARCCNREXTRACTMENUHELP);
3363 break;
3364 case IDM_TEST:
3365 szHelpString = GetPString(IDS_ARCCNRTESTMENUHELP);
3366 break;
3367 case IDM_VIRUSSCAN:
3368 szHelpString = GetPString(IDS_ARCCNRVIRUSMENUHELP);
3369 break;
3370 case IDM_RESCAN:
3371 szHelpString = GetPString(IDS_ARCCNRRESCANMENUHELP);
3372 break;
3373 case IDM_WALKDIR:
3374 szHelpString = GetPString(IDS_ARCCNRWALKDIRMENUHELP);
3375 break;
3376 case IDM_FILTER:
3377 szHelpString = GetPString(IDS_ARCCNRFILTERMENUHELP);
3378 break;
3379 default:
3380 break;
3381 }
3382
3383 if (sLastMenuitem != sCurrentMenuitem && szHelpString) {
3384 sLastMenuitem = sCurrentMenuitem;
3385 MakeBubble(hwnd, TRUE, szHelpString);
3386 }
3387 else if (hwndBubble && !sCurrentMenuitem){
3388 sLastMenuitem = sCurrentMenuitem;
3389 WinDestroyWindow(hwndBubble);
3390 }
3391 }
3392 }
3393 }
3394 return oldMenuProc(hwnd, msg, mp1, mp2);
3395}
3396
3397HWND StartArcCnr(HWND hwndParent, HWND hwndCaller, CHAR * arcname, INT flags,
3398 ARC_TYPE * sinfo)
3399{
3400 /*
3401 * bitmapped flags:
3402 * 1 = am extracted from another archive
3403 * 4 = don't kill proc on close
3404 */
3405
3406 HWND hwndFrame = (HWND) 0, hwndClient;
3407 ULONG FrameFlags = FCF_TITLEBAR | FCF_SYSMENU |
3408 FCF_SIZEBORDER | FCF_MINMAX | FCF_ICON | FCF_NOBYTEALIGN | FCF_ACCELTABLE;
3409 USHORT id;
3410 DIRCNRDATA *dcd;
3411 ARC_TYPE *info = sinfo;
3412 CHAR title[MAXNAMEL + 1] = "AV/2 - ";
3413 CHAR fullname[CCHMAXPATH + 8], *p, temp;
3414 static USHORT idinc = 0;
3415
3416 if (!idinc)
3417 idinc = (rand() % 256);
3418 if (ParentIsDesktop(hwndParent, hwndParent))
3419 FrameFlags |= (FCF_TASKLIST | FCF_MENU);
3420 if (arcname) {
3421 DosError(FERR_DISABLEHARDERR);
3422 if (DosQueryPathInfo(arcname,
3423 FIL_QUERYFULLNAME, fullname, sizeof(fullname)))
3424 strcpy(fullname, arcname);
3425 p = fullname;
3426 while (*p) {
3427 if (*p == '/')
3428 *p = '\\';
3429 p++;
3430 }
3431 if (!info)
3432 info = find_type(fullname, arcsighead);
3433 if (!info)
3434 return hwndFrame;
3435 if (strlen(title) + strlen(fullname) > MAXNAMEL) {
3436 p = title + strlen(title);
3437 strncpy(p, fullname, MAXNAMEL / 2 - 5);
3438 strcpy(p + MAXNAMEL / 2 - 5, "...");
3439 strcat(title, fullname + strlen(fullname) - (MAXNAMEL / 2 - 5));
3440 }
3441 else {
3442 strcat(title, fullname);
3443 }
3444 hwndFrame = WinCreateStdWindow(hwndParent,
3445 WS_VISIBLE,
3446 &FrameFlags,
3447 WC_ARCCONTAINER,
3448 title,
3449 WS_VISIBLE | fwsAnimate,
3450 FM3ModHandle, ARC_FRAME, &hwndClient);
3451 if (hwndFrame && hwndClient) {
3452 id = ARC_FRAME + idinc++;
3453 if (idinc > 512)
3454 idinc = 0;
3455 WinSetWindowUShort(hwndFrame, QWS_ID, id);
3456# ifdef FORTIFY
3457 Fortify_EnterScope();
3458# endif
3459 dcd = xmallocz(sizeof(DIRCNRDATA), pszSrcFile, __LINE__);
3460 if (!dcd) {
3461 PostMsg(hwndClient, WM_CLOSE, MPVOID, MPVOID);
3462 hwndFrame = (HWND) 0;
3463 }
3464 else {
3465 dcd->size = sizeof(DIRCNRDATA);
3466 dcd->id = id;
3467 dcd->type = ARC_FRAME;
3468 save_dir2(dcd->workdir);
3469 if (dcd->workdir[strlen(dcd->workdir) - 1] != '\\')
3470 strcat(dcd->workdir, "\\");
3471 sprintf(dcd->workdir + strlen(dcd->workdir), "%s.%03x",
3472 ArcTempRoot, (clock() & 4095));
3473 strcpy(dcd->arcname, fullname);
3474 if (*extractpath) {
3475 if (!strcmp(extractpath, "*")) {
3476 p = strrchr(fullname, '\\');
3477 if (p) {
3478 if (p < fullname + 3)
3479 p++;
3480 temp = *p;
3481 *p = 0;
3482 strcpy(dcd->directory, fullname);
3483 *p = temp;
3484 }
3485 }
3486 else
3487 strcpy(dcd->directory, extractpath);
3488 }
3489 if (!*dcd->directory && *lastextractpath) {
3490 DosEnterCritSec();
3491 strcpy(dcd->directory, lastextractpath);
3492 DosExitCritSec();
3493 }
3494 if (!*dcd->directory) {
3495 if (!ParentIsDesktop(hwndParent, hwndParent))
3496 TopWindowName(hwndParent, hwndCaller, dcd->directory);
3497 if (!*dcd->directory) {
3498 p = strrchr(fullname, '\\');
3499 if (p) {
3500 if (p < fullname + 3)
3501 p++;
3502 *p = 0;
3503 strcpy(dcd->directory, fullname);
3504 }
3505 }
3506 }
3507 if (!*dcd->directory ||
3508 IsFile(dcd->directory) ||
3509 (isalpha(*dcd->directory) &&
3510 (driveflags[toupper(*dcd->directory) - 'A'] &
3511 DRIVE_NOTWRITEABLE)))
3512 save_dir2(dcd->directory);
3513 dcd->hwndParent = hwndParent ? hwndParent : HWND_DESKTOP;
3514 dcd->hwndFrame = hwndFrame;
3515 dcd->hwndClient = hwndClient;
3516 dcd->amextracted = (flags & 1) != 0;
3517 dcd->dontclose = (flags & 4) != 0;
3518 dcd->info = info;
3519 dcd->sortFlags = DefArcSortFlags;
3520 {
3521 PFNWP oldproc;
3522
3523 oldproc = WinSubclassWindow(hwndFrame, (PFNWP) ArcFrameWndProc);
3524 WinSetWindowPtr(hwndFrame, QWL_USER, (PVOID) oldproc);
3525 }
3526 dcd->hwndCnr = WinCreateWindow(hwndClient,
3527 WC_CONTAINER,
3528 NULL,
3529 CCS_AUTOPOSITION | CCS_MINIICONS |
3530 CCS_MINIRECORDCORE | ulCnrType |
3531 WS_VISIBLE,
3532 0,
3533 0,
3534 0,
3535 0,
3536 hwndClient,
3537 HWND_TOP, (ULONG) ARC_CNR, NULL, NULL);
3538 if (!dcd->hwndCnr) {
3539 Win_Error2(hwndClient, hwndClient, pszSrcFile, __LINE__,
3540 IDS_WINCREATEWINDOW);
3541 PostMsg(hwndClient, WM_CLOSE, MPVOID, MPVOID);
3542 xfree(dcd, pszSrcFile, __LINE__);
3543# ifdef FORTIFY
3544 Fortify_LeaveScope();
3545# endif
3546 hwndFrame = (HWND) 0;
3547 }
3548 else {
3549 WinSetWindowPtr(dcd->hwndCnr, QWL_USER, (PVOID) dcd);
3550 dcd->oldproc = WinSubclassWindow(dcd->hwndCnr,
3551 (PFNWP) ArcCnrWndProc);
3552 {
3553 USHORT ids[] = { DIR_TOTALS, DIR_SELECTED, DIR_VIEW, DIR_SORT,
3554 DIR_FILTER, DIR_FOLDERICON, 0
3555 };
3556
3557 CommonCreateTextChildren(dcd->hwndClient,
3558 WC_ARCSTATUS, ids);
3559 }
3560 WinEnableWindow(WinWindowFromID(dcd->hwndClient, DIR_VIEW), FALSE);
3561 dcd->hwndExtract = WinCreateWindow(dcd->hwndClient,
3562 WC_ENTRYFIELD,
3563 NULL,
3564 ES_AUTOSCROLL,
3565 0,
3566 0,
3567 0,
3568 0,
3569 dcd->hwndClient,
3570 HWND_TOP,
3571 ARC_EXTRACTDIR, NULL, NULL);
3572 WinSendMsg(dcd->hwndExtract,
3573 EM_SETTEXTLIMIT, MPFROM2SHORT(CCHMAXPATH, 0), MPVOID);
3574 WinSetWindowText(dcd->hwndExtract, dcd->directory);
3575 if (!PostMsg(dcd->hwndCnr, UM_SETUP, MPVOID, MPVOID))
3576 WinSendMsg(dcd->hwndCnr, UM_SETUP, MPVOID, MPVOID);
3577 if (FrameFlags & FCF_MENU) {
3578 PFNWP oldmenuproc;
3579 HWND hwndMenu = WinWindowFromID(hwndFrame, FID_MENU);
3580
3581 oldmenuproc = WinSubclassWindow(hwndMenu, (PFNWP) ArcCnrMenuProc);
3582 WinSetWindowPtr(hwndMenu, QWL_USER, (PVOID) oldmenuproc);
3583 if (!fToolbar) {
3584
3585 if (hwndMenu) {
3586 WinSendMsg(hwndMenu, MM_DELETEITEM,
3587 MPFROM2SHORT(IDM_VIEW, FALSE), MPVOID);
3588 WinSendMsg(hwndMenu, MM_DELETEITEM,
3589 MPFROM2SHORT(IDM_EXEC, FALSE), MPVOID);
3590 WinSendMsg(hwndMenu, MM_DELETEITEM,
3591 MPFROM2SHORT(IDM_RESCAN, FALSE), MPVOID);
3592 WinSendMsg(hwndMenu, MM_DELETEITEM,
3593 MPFROM2SHORT(IDM_DELETE, FALSE), MPVOID);
3594 WinSendMsg(hwndMenu, MM_DELETEITEM,
3595 MPFROM2SHORT(IDM_EXTRACT, FALSE), MPVOID);
3596 WinSendMsg(hwndMenu, MM_DELETEITEM,
3597 MPFROM2SHORT(IDM_TEST, FALSE), MPVOID);
3598 WinSendMsg(hwndMenu, MM_DELETEITEM,
3599 MPFROM2SHORT(IDM_VIRUSSCAN, FALSE), MPVOID);
3600 WinSendMsg(hwndMenu, MM_DELETEITEM,
3601 MPFROM2SHORT(IDM_WALKDIR, FALSE), MPVOID);
3602 WinSendMsg(hwndMenu, MM_DELETEITEM,
3603 MPFROM2SHORT(IDM_FILTER, FALSE), MPVOID);
3604 }
3605 }
3606 }
3607 if (FrameFlags & FCF_TASKLIST) {
3608
3609 SWP swp, swpD;
3610 ULONG size = sizeof(swp);
3611 LONG cxScreen, cyScreen;
3612
3613 WinQueryTaskSizePos(WinQueryAnchorBlock(hwndFrame), 0, &swp);
3614 if (PrfQueryProfileData(fmprof,
3615 appname, "AV2SizePos", &swpD, &size)) {
3616 cxScreen = WinQuerySysValue(HWND_DESKTOP, SV_CXSCREEN);
3617 cyScreen = WinQuerySysValue(HWND_DESKTOP, SV_CYSCREEN);
3618 if (swp.x + swpD.cx > cxScreen)
3619 swp.x = cxScreen - swpD.cx;
3620 if (swp.y + swpD.cy > cyScreen)
3621 swp.y = cyScreen - swpD.cy;
3622 swp.cx = swpD.cx;
3623 swp.cy = swpD.cy;
3624 }
3625 WinSetWindowPos(hwndFrame,
3626 HWND_TOP,
3627 swp.x,
3628 swp.y,
3629 swp.cx,
3630 swp.cy,
3631 SWP_SIZE | SWP_MOVE | SWP_SHOW | SWP_ZORDER |
3632 SWP_ACTIVATE);
3633 }
3634 }
3635 }
3636 }
3637 }
3638 return hwndFrame;
3639}
3640
3641#pragma alloc_text(ARCCNRS,ArcCnrWndProc,ArcObjWndProc,ArcClientWndProc,BldQuotedFullPathName)
3642#pragma alloc_text(ARCCNRS,ArcTextProc,FillArcCnr,ArcFilter,BldQuotedFileName)
3643#pragma alloc_text(ARCCNRS,ArcSort,ArcFrameWndProc,IsArcThere,ArcErrProc)
3644#pragma alloc_text(STARTUP,StartArcCnr)
Note: See TracBrowser for help on using the repository browser.