source: trunk/dll/arccnrs.c@ 1038

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

More fortify cleanup
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 96.8 KB
Line 
1
2/***********************************************************************
3
4 $Id: arccnrs.c 1038 2008-07-04 20:33:59Z 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 free(psz);
340# ifdef FORTIFY
341 Fortify_LeaveScope();
342# endif
343 }
344}
345
346/**
347 * Remove item(s) from archive container and free associated storage if requested
348 * @param paiFirst points to first item to remove or NULL to remove all
349 * @param usCnt is remove count or 0 to remove all
350 */
351
352static VOID RemoveArcItems(HWND hwnd, PARCITEM paiFirst, USHORT usCnt, USHORT usFlags)
353{
354 INT remaining = usCnt;
355 PARCITEM pai;
356
357 if ((usCnt && !paiFirst) || (!usCnt && paiFirst))
358 Runtime_Error(pszSrcFile, __LINE__, "paiFirst %p usCnt %u mismatch", paiFirst, usCnt);
359 else {
360 // Free our buffers if free requested
361 if (usFlags & CMA_FREE) {
362 if (paiFirst)
363 pai = paiFirst;
364 else {
365 pai = (PARCITEM)WinSendMsg(hwnd, CM_QUERYRECORD, MPVOID,
366 MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
367 if ((INT)pai == -1) {
368 Win_Error(hwnd, HWND_DESKTOP, pszSrcFile, __LINE__,"CM_QUERYRECORD");
369 remaining = -1;
370 pai = NULL;
371 }
372 }
373 while (pai) {
374 FreeArcItemData(pai);
375 pai = (PARCITEM)pai->rc.preccNextRecord;
376 if (remaining && --remaining == 0)
377 break;
378 }
379 }
380 }
381
382 // DbgMsg(pszSrcFile, __LINE__, "RemoveArcItems %p %u %s", pai, usCnt, pai->pszFileName);
383
384 if (remaining != - 1) {
385 remaining = (INT)WinSendMsg(hwnd, CM_REMOVERECORD, MPFROMP(&paiFirst), MPFROM2SHORT(usCnt, usFlags));
386 if (remaining == -1) {
387 // Win_Error2(hwnd, HWND_DESKTOP, pszSrcFile, __LINE__,IDS_CMREMOVEERRTEXT);
388 Win_Error(hwnd, HWND_DESKTOP, pszSrcFile, __LINE__,"CM_REMOVERECORD hwnd %x pai %p cnt %u", hwnd, paiFirst, usCnt);
389 }
390 }
391}
392
393/**
394 * Empty all records from an archive container and
395 * free associated storage and free up field infos
396 */
397
398static VOID EmptyArcCnr(HWND hwnd)
399{
400#if 0 // fixme to be gone or to be configurable
401 {
402 int state = _heapchk();
403 if (state != _HEAPOK)
404 Runtime_Error(pszSrcFile, __LINE__, "heap corrupted %d", state);
405 else
406 DbgMsg(pszSrcFile, __LINE__, "_memavl %u", _memavl());
407 }
408#endif
409
410 // Remove all ARCITEM records
411 RemoveArcItems(hwnd, NULL, 0, CMA_FREE);
412
413 // Use common code to remove rest
414 EmptyCnr(hwnd);
415}
416
417//== FillArcCnr() generate archive content list and fill container window ==
418
419static INT FillArcCnr(HWND hwndCnr, CHAR * arcname, ARC_TYPE ** arcinfo,
420 ULONGLONG * pullTotalBytes, volatile PCHAR pStopFlag)
421{
422 FILE *fp;
423 HFILE oldstdout;
424 HFILE newstdout;
425 CHAR s[CCHMAXPATH * 2], lonename[CCHMAXPATH + 2],
426 *nsize, *osize, *fdate, *fname, *p, *pp, arctemp[33];
427 BOOL gotstart;
428 BOOL gotend;
429 BOOL wasquote;
430 BOOL nomove = FALSE; // fixme to be gone?
431 INT highest = 0, x, counter = 0, numarcfiles = 0;
432 PARCITEM lastpai;
433 ARC_TYPE *info;
434 ARC_TYPE *tinfo;
435 ULONG apptype;
436 APIRET rc;
437
438 if (!arcname || !arcinfo)
439 return 0;
440
441 info = *arcinfo;
442 if (!info)
443 info = find_type(arcname, NULL);
444 for (x = 0; x < 99; x++) {
445 sprintf(arctemp, "%s.%03x", ArcTempRoot, (clock() & 4095L));
446 if (IsFile(arctemp) == 1)
447 DosSleep(rand() % 100);
448 else
449 break;
450 }
451
452ReTry:
453
454#ifdef DEBUG
455 if (info && info->id)
456 WinSetWindowText(WinQueryWindow
457 (WinQueryWindow(hwndCnr, QW_PARENT), QW_PARENT),
458 info->id);
459#endif
460
461 tinfo = NULL;
462 numarcfiles = counter = highest = 0;
463 gotstart = gotend = FALSE;
464 lastpai = NULL;
465 *pullTotalBytes = 0;
466 if (!info || !info->list)
467 Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
468 else {
469 RemoveArcItems(hwndCnr, NULL, 0, CMA_FREE | CMA_INVALIDATE | CMA_ERASE);
470 *arcinfo = info;
471 highest = info->osizepos;
472 if (info->nsizepos > highest)
473 highest = info->nsizepos;
474 if (info->fdpos > highest)
475 highest = info->fdpos;
476 if (info->fnpos > highest)
477 highest = info->fnpos;
478 if (highest > 50) {
479 saymsg(MB_ENTER | MB_ICONEXCLAMATION, HWND_DESKTOP,
480 GetPString(IDS_SHAMETEXT), "%s", GetPString(IDS_BUNGEDUPTEXT));
481 }
482 if (info->fnpos == -1)
483 highest = 32767;
484
485 DosError(FERR_DISABLEHARDERR);
486 DosForceDelete(arctemp);
487 DosError(FERR_DISABLEHARDERR);
488
489 strcpy(s, info->list);
490 p = strchr(s, ' ');
491 if (p)
492 *p = 0;
493 DosError(FERR_DISABLEHARDERR);
494 if (!DosQueryAppType(s, &apptype) &&
495 (apptype & FAPPTYP_DOS ||
496 apptype & FAPPTYP_WINDOWSREAL ||
497 apptype & FAPPTYP_WINDOWSPROT ||
498 apptype & FAPPTYP_WINDOWSPROT31)) {
499 p = GetCmdSpec(TRUE);
500 runemf2(SEPARATE | INVISIBLE | MINIMIZED | BACKGROUND | WAIT,
501 hwndCnr, pszSrcFile, __LINE__, NULL, "DOS_BACKGROUND_EXECUTION=1",
502 "%s /C %s %s >%s",
503 p, // shell
504 info->list, // list command
505 BldQuotedFileName(s, arcname),
506 arctemp);
507 }
508 else {
509 fp = xfopen(arctemp, "w", pszSrcFile, __LINE__);
510 if (!fp)
511 return 0;
512 else {
513 newstdout = -1;
514 DosError(FERR_DISABLEHARDERR);
515 rc = DosDupHandle(fileno(stdout), &newstdout);
516 if (rc) {
517 Dos_Error(MB_CANCEL, rc, hwndCnr, pszSrcFile, __LINE__,
518 "DosDupHandle");
519 return 0;
520 }
521 else {
522 oldstdout = fileno(stdout);
523 DosError(FERR_DISABLEHARDERR);
524 rc = DosDupHandle(fileno(fp), &oldstdout);
525 if (rc) {
526 Dos_Error(MB_CANCEL, rc, hwndCnr, pszSrcFile, __LINE__,
527 "DosDupHandle");
528 return 0;
529 }
530 else {
531 runemf2(SEPARATE | INVISIBLE | FULLSCREEN | BACKGROUND | WAIT,
532 hwndCnr, pszSrcFile, __LINE__, NULL, NULL,
533 "%s %s",
534 info->list,
535 BldQuotedFileName(s, arcname));
536 oldstdout = fileno(stdout);
537 DosError(FERR_DISABLEHARDERR);
538 DosDupHandle(newstdout, &oldstdout);
539 DosClose(newstdout);
540 fclose(fp);
541 }
542 }
543 }
544 }
545
546 DosError(FERR_DISABLEHARDERR);
547 fp = _fsopen(arctemp, "r", SH_DENYWR);
548
549 if (fp) {
550 gotstart = !info->startlist || !*info->startlist; // If list has no start marker
551
552 while (!feof(fp) && !gotend && !*pStopFlag) {
553 if (!xfgets_bstripcr(s, sizeof(s), fp, pszSrcFile, __LINE__))
554 break;
555 if (!gotstart) {
556 if (!strcmp(s, info->startlist))
557 gotstart = TRUE;
558 }
559 else if (info->endlist && !strcmp(s, info->endlist))
560 gotend = TRUE;
561 else {
562 /* add to container */
563 fname = NULL;
564 bstrip(s);
565 if (info->nameisfirst) {
566 strncpy(lonename, s, CCHMAXPATH + 2);
567 lonename[CCHMAXPATH + 1] = 0;
568 fname = lonename;
569 if (!xfgets_bstripcr(s, sizeof(s), fp, pszSrcFile, __LINE__))
570 break;
571 if (*fname == '\"') {
572 memmove(fname, fname + 1, strlen(fname) + 1);
573 p = strchr(fname, '\"');
574 if (p)
575 *p = 0;
576 }
577 }
578 nsize = NULL;
579 osize = fdate = NullStr;
580 p = s;
581 for (x = 0; x <= highest; x++) {
582 pp = p;
583 while (*pp && (*pp == ' ' || *pp == '\t')) /* skip leading */
584 pp++;
585 if (!*pp)
586 break;
587 wasquote = FALSE;
588 p = pp;
589 while (*p && (wasquote ||
590 ((x != info->fnpos || !info->nameislast) ?
591 (*p != ' ' && *p != '\t') : TRUE))) {
592 if (*p == '\"') {
593 if (!wasquote) {
594 wasquote = TRUE;
595 memmove(p, p + 1, strlen(p));
596 while (*p == ' ' || *p == '\t')
597 p++;
598 }
599 else {
600 memmove(p, p + 1, strlen(p));
601 break;
602 }
603 }
604 else if (*p)
605 p++;
606 }
607 if (*p) {
608 *p = 0;
609 p++;
610 }
611 if (x == info->nsizepos)
612 nsize = pp;
613 else if (x == info->osizepos)
614 osize = pp;
615 else if (x == info->fdpos) {
616 fdate = pp;
617 if (info->fdflds > 1 && info->fdflds < 24) {
618 INT y;
619
620 if (*p) {
621 p--;
622 *p = ' ';
623 for (y = 0; y < info->fdflds - 1; y++) {
624 while (*p && (*p == ' ' || *p == '\t'))
625 p++;
626 while (*p && (*p != ' ' && *p != '\t'))
627 p++;
628 x++;
629 }
630 if (*p) {
631 *p = 0;
632 p++;
633 }
634 }
635 }
636 }
637 else if (x == info->fnpos) {
638 fname = pp;
639 if (pp && *pp == '*' && !*(pp + 1)) /* workaround for LH.EXE */
640 fname = NULL;
641 if (info->nameislast)
642 break;
643 }
644 else if ((!p || !*p) && info->fnpos == -1) {
645 fname = pp;
646 break;
647 }
648 }
649 if (info->nameisnext) {
650 if (!xfgets_bstripcr
651 (lonename, sizeof(lonename), fp, pszSrcFile, __LINE__))
652 break;
653 fname = lonename;
654 }
655 // fixme to complain?
656 if (fname && *fname) {
657
658 RECORDINSERT ri;
659 PARCITEM pai;
660
661#ifdef DEBUG
662 saymsg(MB_ENTER, hwndCnr, DEBUG_STRING,
663 "fname: %s\r\rpp: %s\r\rp: %s\r\rlonename: %s\r\rhighest: %ld\r\rx: %ld\r\rfdate: %s",
664 fname ? fname : "NULL",
665 pp ? pp : "NULL",
666 p ? p : "NULL",
667 lonename, highest, x, (fdate) ? fdate : "NULL");
668#endif
669
670 pai = WinSendMsg(hwndCnr,
671 CM_ALLOCRECORD,
672 MPFROMLONG(EXTRA_ARCRECORD_BYTES),
673 MPFROMLONG(1L));
674 if (!pai) {
675 Runtime_Error(pszSrcFile, __LINE__, "CM_ALLOCRECORD");
676 break;
677 }
678 else {
679 memset(pai, 0, sizeof(ARCITEM));
680 pai->hwndCnr = hwndCnr;
681 if (*fname == '*') {
682 fname++;
683 pai->flags = ARCFLAGS_REALDIR;
684 }
685 if (fname[strlen(fname) - 1] == '\\' ||
686 fname[strlen(fname) - 1] == '/')
687 pai->flags = ARCFLAGS_REALDIR;
688 pai->pszFileName = xstrdup(fname,pszSrcFile, __LINE__);
689 pai->pszDisplayName = pai->pszFileName;
690 pai->rc.pszIcon = pai->pszDisplayName;
691 if (fdate)
692 strcpy(pai->szDate, fdate);
693 // pai->pszFileName = pai->pszFileName;
694 pai->rc.pszIcon = pai->pszFileName;
695 pai->rc.hptrIcon = (pai->flags & ARCFLAGS_REALDIR) != 0 ?
696 hptrDir : hptrFile;
697 pai->pszDate = pai->szDate;
698 if (osize)
699 pai->cbFile = atol(osize);
700 if (nsize)
701 pai->cbComp = atol(nsize);
702 if (info->datetype && fdate && *fdate)
703 ArcDateTime(fdate, info->datetype, &pai->date, &pai->time);
704 memset(&ri, 0, sizeof(RECORDINSERT));
705 ri.cb = sizeof(RECORDINSERT);
706 ri.pRecordOrder = (PRECORDCORE) CMA_END;
707 ri.pRecordParent = (PRECORDCORE) NULL;
708 ri.zOrder = (USHORT) CMA_TOP;
709 ri.cRecordsInsert = 1L;
710 ri.fInvalidateRecord = FALSE;
711 if (WinSendMsg(hwndCnr,
712 CM_INSERTRECORD, MPFROMP(pai), MPFROMP(&ri))) {
713 *pullTotalBytes += pai->cbFile;
714 }
715 numarcfiles++;
716 if (!(++counter % 50)) {
717 if (!lastpai)
718 lastpai = pai;
719 WinSendMsg(hwndCnr,
720 CM_INVALIDATERECORD,
721 lastpai,
722 MPFROM2SHORT(10, CMA_ERASE | CMA_REPOSITION));
723 lastpai = pai;
724 }
725 // Avoid hogging system for large archive
726 if (numarcfiles == 100)
727 priority_idle();
728 }
729 }
730 }
731 } // while !eof
732
733 fclose(fp);
734
735 if (*pStopFlag)
736 numarcfiles = 0; // Request close
737 else if (!numarcfiles || !gotstart
738 || (!gotend && info->endlist && *info->endlist)) {
739 // Oops
740 ARCDUMP ad;
741 CHAR errstr[CCHMAXPATH + 256];
742
743 // Try for alternate archiver
744 tinfo = info;
745 do {
746 tinfo = tinfo->next;
747 if (tinfo)
748 tinfo = find_type(arcname, tinfo);
749 if (tinfo) {
750 DosError(FERR_DISABLEHARDERR);
751 DosForceDelete(arctemp);
752 info = tinfo;
753 goto ReTry;
754 }
755 } while (tinfo);
756 DosBeep(750, 50); // wake up user
757 sprintf(errstr, GetPString(IDS_ARCERRORINFOTEXT),
758 arcname,
759 !gotstart ? GetPString(IDS_NOGOTSTARTTEXT) : NullStr,
760 !numarcfiles ? GetPString(IDS_NOARCFILESFOUNDTEXT) :
761 NullStr,
762 !gotend ? GetPString(IDS_NOENDOFLISTTEXT) : NullStr);
763 memset(&ad, 0, sizeof(ARCDUMP));
764 ad.info = info;
765 strcpy(ad.listname, arctemp);
766 strcpy(ad.arcname, arcname);
767 ad.errmsg = errstr;
768 WinDlgBox(HWND_DESKTOP,
769 hwndCnr,
770 ArcErrProc, FM3ModHandle, ARCERR_FRAME, MPFROMP(&ad));
771 }
772 else if (!nomove && tinfo) {
773 /* if we got a false hit, move working hit to top */
774 tinfo = info->next;
775 info->next = arcsighead;
776 arcsighead->prev = info;
777 if (tinfo)
778 tinfo->next->prev = info->prev;
779 info->prev->next = tinfo;
780 info->prev = NULL;
781 arcsighead = info;
782 rewrite_archiverbb2(NULL); // Rewrite with warning
783 }
784 } // if opened
785
786 DosError(FERR_DISABLEHARDERR);
787 DosForceDelete(arctemp);
788 }
789
790 if (numarcfiles)
791 priority_normal();
792
793 return numarcfiles;
794}
795
796MRESULT EXPENTRY ArcTextProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
797{
798 static BOOL emphasized = FALSE;
799 static HWND hwndButtonPopup = (HWND) 0;
800 static ULONG timestamp = ULONG_MAX;
801 static USHORT lastid = 0;
802
803 switch (msg) {
804 case WM_CREATE:
805 return CommonTextProc(hwnd, msg, mp1, mp2);
806
807 case WM_COMMAND:
808 return WinSendMsg(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
809 ARC_CNR), msg, mp1, mp2);
810
811 case UM_CONTEXTMENU:
812 case WM_CONTEXTMENU:
813 {
814 USHORT id;
815
816 id = WinQueryWindowUShort(hwnd, QWS_ID);
817 switch (id) {
818 case DIR_SELECTED:
819 case DIR_VIEW:
820 case DIR_SORT:
821 {
822 POINTL ptl = { 0, 0 };
823 SWP swp;
824 DIRCNRDATA *dcd;
825
826 if (hwndButtonPopup)
827 WinDestroyWindow(hwndButtonPopup);
828 if (id == DIR_SELECTED)
829 id = DIR_RESTORE;
830 if (id == lastid) {
831
832 ULONG check;
833
834 DosQuerySysInfo(QSV_MS_COUNT, QSV_MS_COUNT, &check,
835 sizeof(check));
836 if (check < timestamp + 500) {
837 lastid = 0;
838 goto MenuAbort;
839 }
840 }
841 hwndButtonPopup = WinLoadMenu(HWND_DESKTOP, FM3ModHandle, id);
842 if (hwndButtonPopup) {
843 WinSetWindowUShort(hwndButtonPopup, QWS_ID, id);
844 dcd = WinQueryWindowPtr(WinWindowFromID(WinQueryWindow(hwnd,
845 QW_PARENT),
846 ARC_CNR), QWL_USER);
847 if (id == DIR_SORT) {
848 if (dcd)
849 SetSortChecks(hwndButtonPopup, dcd->sortFlags);
850 WinSendMsg(hwndButtonPopup,
851 MM_DELETEITEM,
852 MPFROM2SHORT(IDM_SORTNONE, FALSE), MPVOID);
853 WinSendMsg(hwndButtonPopup,
854 MM_DELETEITEM,
855 MPFROM2SHORT(IDM_SORTNAME, FALSE), MPVOID);
856 WinSendMsg(hwndButtonPopup,
857 MM_DELETEITEM,
858 MPFROM2SHORT(IDM_SORTLADATE, FALSE), MPVOID);
859 WinSendMsg(hwndButtonPopup,
860 MM_DELETEITEM,
861 MPFROM2SHORT(IDM_SORTCRDATE, FALSE), MPVOID);
862 WinSendMsg(hwndButtonPopup,
863 MM_DELETEITEM,
864 MPFROM2SHORT(IDM_SORTDIRSFIRST, FALSE), MPVOID);
865 WinSendMsg(hwndButtonPopup,
866 MM_DELETEITEM,
867 MPFROM2SHORT(IDM_SORTDIRSLAST, FALSE), MPVOID);
868 WinSendMsg(hwndButtonPopup,
869 MM_DELETEITEM,
870 MPFROM2SHORT(IDM_SORTSUBJECT, FALSE), MPVOID);
871 WinSendMsg(hwndButtonPopup,
872 MM_SETITEMTEXT,
873 MPFROM2SHORT(IDM_SORTEASIZE, 0),
874 MPFROMP(GetPString(IDS_COMPRESSEDSIZEMENUTEXT)));
875 WinSendMsg(hwndButtonPopup,
876 MM_SETITEMTEXT,
877 MPFROM2SHORT(IDM_SORTLWDATE, 0),
878 MPFROMP(GetPString(IDS_DATEMENUTEXT)));
879 }
880 ptl.x = 0;
881 if (WinPopupMenu(HWND_OBJECT,
882 HWND_OBJECT,
883 hwndButtonPopup, -32767, -32767, 0, 0)) {
884 WinQueryWindowPos(hwndButtonPopup, &swp);
885 ptl.y = -(swp.cy + 2);
886 }
887 else {
888 WinQueryWindowPos(hwnd, &swp);
889 ptl.y = swp.cy + 2;
890 }
891 if (WinPopupMenu(hwnd,
892 hwnd,
893 hwndButtonPopup,
894 ptl.x,
895 ptl.y,
896 0,
897 PU_HCONSTRAIN | PU_VCONSTRAIN |
898 PU_KEYBOARD | PU_MOUSEBUTTON1)) {
899 CenterOverWindow(hwndButtonPopup);
900 PaintRecessedWindow(hwnd, (HPS) 0, FALSE, FALSE);
901 }
902 }
903 }
904 break;
905 default:
906 PostMsg(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
907 ARC_CNR),
908 WM_CONTROL, MPFROM2SHORT(ARC_CNR, CN_CONTEXTMENU), MPVOID);
909 break;
910 }
911 }
912 MenuAbort:
913 if (msg == UM_CONTEXTMENU)
914 return 0;
915 break;
916
917 case WM_MENUEND:
918 if (hwndButtonPopup == (HWND) mp2) {
919 lastid = WinQueryWindowUShort((HWND) mp2, QWS_ID);
920 WinDestroyWindow(hwndButtonPopup);
921 hwndButtonPopup = (HWND) 0;
922 DosQuerySysInfo(QSV_MS_COUNT, QSV_MS_COUNT, &timestamp,
923 sizeof(timestamp));
924 switch (lastid) {
925 case DIR_VIEW:
926 case DIR_SORT:
927 case DIR_RESTORE:
928 case DIR_SELECTED:
929 PaintRecessedWindow(hwnd, (HPS) 0, TRUE, FALSE);
930 break;
931 }
932 }
933 break;
934
935 case WM_MOUSEMOVE:
936 {
937 USHORT id = WinQueryWindowUShort(hwnd, QWS_ID);
938 char *s = NULL;
939
940 if (fOtherHelp) {
941 if ((!hwndBubble ||
942 WinQueryWindowULong(hwndBubble, QWL_USER) != hwnd) &&
943 !WinQueryCapture(HWND_DESKTOP)) {
944 switch (id) {
945 case DIR_TOTALS:
946 s = GetPString(IDS_ARCCNRTOTALSHELPTEXT);
947 break;
948 case DIR_SELECTED:
949 s = GetPString(IDS_ARCCNRSELECTEDHELPTEXT);
950 break;
951 case DIR_VIEW:
952 s = GetPString(IDS_ARCCNRVIEWHELPTEXT);
953 break;
954 case DIR_SORT:
955 s = GetPString(IDS_DIRCNRSORTHELP);
956 break;
957 case DIR_FILTER:
958 s = GetPString(IDS_DIRCNRFILTERHELP);
959 break;
960 case DIR_FOLDERICON:
961 s = GetPString(IDS_ARCCNRFOLDERHELPTEXT);
962 break;
963 default:
964 break;
965 }
966 if (s)
967 MakeBubble(hwnd, TRUE, s);
968 else if (hwndBubble)
969 WinDestroyWindow(hwndBubble);
970 }
971 }
972 switch (id) {
973 case DIR_FILTER:
974 case DIR_SORT:
975 case DIR_VIEW:
976 case DIR_SELECTED:
977 case DIR_FOLDERICON:
978 return CommonTextButton(hwnd, msg, mp1, mp2);
979 }
980 }
981 break;
982
983 case WM_BUTTON3UP:
984 case WM_BUTTON1UP:
985 case WM_BUTTON1DOWN:
986 case WM_BUTTON3DOWN:
987 {
988 USHORT id;
989
990 id = WinQueryWindowUShort(hwnd, QWS_ID);
991 switch (id) {
992 case DIR_FILTER:
993 case DIR_SORT:
994 case DIR_VIEW:
995 case DIR_SELECTED:
996 case DIR_FOLDERICON:
997 return CommonTextButton(hwnd, msg, mp1, mp2);
998 }
999 }
1000 break;
1001
1002 case UM_CLICKED:
1003 case UM_CLICKED3:
1004 {
1005 USHORT id, cmd = 0;
1006
1007 id = WinQueryWindowUShort(hwnd, QWS_ID);
1008 switch (id) {
1009 case DIR_FOLDERICON:
1010 switch (msg) {
1011 case WM_BUTTON3CLICK:
1012 case WM_CHORD:
1013 cmd = IDM_RESCAN;
1014 break;
1015 default:
1016 if ((SHORT2FROMMP(mp2) & KC_ALT) != 0)
1017 cmd = IDM_WINDOWDLG;
1018 else
1019 cmd = IDM_WALKDIR;
1020 break;
1021 }
1022 break;
1023 case DIR_VIEW:
1024 case DIR_SORT:
1025 case DIR_SELECTED:
1026 PostMsg(hwnd, UM_CONTEXTMENU, MPVOID, MPVOID);
1027 break;
1028 case DIR_FILTER:
1029 cmd = IDM_FILTER;
1030 break;
1031 default:
1032 break;
1033 }
1034 if (cmd)
1035 PostMsg(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
1036 ARC_CNR),
1037 WM_COMMAND, MPFROM2SHORT(cmd, 0), MPVOID);
1038 }
1039 return 0;
1040
1041 case WM_BEGINDRAG:
1042 case DM_DROP:
1043 case DM_DRAGOVER:
1044 case DM_DRAGLEAVE:
1045 case DM_DROPHELP:
1046 if (msg == DM_DRAGOVER) {
1047 if (!emphasized) {
1048 emphasized = TRUE;
1049 DrawTargetEmphasis(hwnd, emphasized);
1050 }
1051 }
1052 else if (msg != WM_BEGINDRAG) {
1053 if (emphasized) {
1054 emphasized = FALSE;
1055 DrawTargetEmphasis(hwnd, emphasized);
1056 }
1057 }
1058 switch (WinQueryWindowUShort(hwnd, QWS_ID)) {
1059 case DIR_FOLDERICON:
1060 switch (msg) {
1061 case DM_DRAGOVER:
1062 if (AcceptOneDrop(hwnd, mp1, mp2))
1063 return MRFROM2SHORT(DOR_DROP, DO_MOVE);
1064 return MRFROM2SHORT(DOR_NODROP, 0); /* Drop not valid */
1065 case DM_DROPHELP:
1066 DropHelp(mp1, mp2, hwnd, GetPString(IDS_ARCCNRFOLDERDROPHELPTEXT));
1067 return 0;
1068 case DM_DROP:
1069 {
1070 char szFrom[CCHMAXPATH + 2];
1071
1072 if (emphasized) {
1073 emphasized = FALSE;
1074 DrawTargetEmphasis(hwnd, emphasized);
1075 }
1076 if (GetOneDrop(hwnd, mp1, mp2, szFrom, sizeof(szFrom)))
1077 WinSendMsg(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
1078 ARC_CNR),
1079 WM_COMMAND,
1080 MPFROM2SHORT(IDM_SWITCH, 0), MPFROMP(szFrom));
1081 }
1082 return 0;
1083 default:
1084 return PFNWPStatic(hwnd, msg, mp1, mp2);
1085 }
1086 default:
1087 {
1088 CNRDRAGINFO cnd;
1089 USHORT dcmd;
1090
1091 switch (msg) {
1092 case DM_DROP:
1093 dcmd = CN_DROP;
1094 break;
1095 case DM_DRAGOVER:
1096 dcmd = CN_DRAGOVER;
1097 break;
1098 case DM_DRAGLEAVE:
1099 dcmd = CN_DRAGLEAVE;
1100 break;
1101 case DM_DROPHELP:
1102 dcmd = CN_DROPHELP;
1103 break;
1104 case WM_BEGINDRAG:
1105 dcmd = CN_INITDRAG;
1106 break;
1107 }
1108 cnd.pDragInfo = (PDRAGINFO) mp1;
1109 cnd.pRecord = NULL;
1110 return WinSendMsg(WinQueryWindow(hwnd, QW_PARENT),
1111 WM_CONTROL,
1112 MPFROM2SHORT(ARC_CNR, dcmd), MPFROMP(&cnd));
1113 }
1114 }
1115 }
1116 return PFNWPStatic(hwnd, msg, mp1, mp2);
1117}
1118
1119MRESULT EXPENTRY ArcClientWndProc(HWND hwnd, ULONG msg, MPARAM mp1,
1120 MPARAM mp2)
1121{
1122
1123 switch (msg) {
1124 case UM_CONTAINERHWND:
1125 return MRFROMLONG(WinWindowFromID(hwnd, ARC_CNR));
1126
1127 case UM_VIEWSMENU:
1128 // fixme to disble menu items as needed
1129 return MRFROMLONG(CheckMenu(hwnd, &ArcCnrMenu, ARCCNR_POPUP));
1130
1131 case UM_FILESMENU:
1132 // fixme to disble menu items as needed
1133 return MRFROMLONG(CheckMenu(hwnd, &ArcMenu, ARC_POPUP));
1134
1135 case MM_PORTHOLEINIT:
1136 case WM_INITMENU:
1137 case UM_INITMENU:
1138 case UM_COMMAND:
1139 case UM_LOADFILE:
1140 case UM_UPDATERECORD:
1141 case UM_UPDATERECORDLIST:
1142 case WM_COMMAND:
1143 case WM_CONTROL:
1144 case WM_CLOSE:
1145 return WinSendMsg(WinWindowFromID(hwnd, ARC_CNR), msg, mp1, mp2);
1146
1147 case WM_PSETFOCUS:
1148 case WM_SETFOCUS:
1149 if (mp2)
1150 PostMsg(hwnd, UM_FOCUSME, MPVOID, MPVOID);
1151 break;
1152
1153 case UM_FOCUSME:
1154 WinSetFocus(HWND_DESKTOP, WinWindowFromID(hwnd, ARC_CNR));
1155 break;
1156
1157 case WM_PAINT:
1158 {
1159 HPS hps;
1160 RECTL rcl;
1161
1162 hps = WinBeginPaint(hwnd, (HPS) 0, NULL);
1163 if (hps) {
1164 WinQueryWindowRect(hwnd, &rcl);
1165 WinFillRect(hps, &rcl, CLR_PALEGRAY);
1166 CommonTextPaint(hwnd, hps);
1167 WinEndPaint(hps);
1168 }
1169 }
1170 break;
1171
1172 case UM_SIZE:
1173 case WM_SIZE:
1174 if (msg == UM_SIZE) {
1175
1176 SWP swp;
1177
1178 WinQueryWindowPos(hwnd, &swp);
1179 mp1 = MPFROM2SHORT(swp.cx, swp.cy);
1180 mp2 = MPFROM2SHORT(swp.cx, swp.cy);
1181 }
1182 {
1183 USHORT cx, cy, bx;
1184
1185 cx = SHORT1FROMMP(mp2);
1186 cy = SHORT2FROMMP(mp2);
1187 WinSetWindowPos(WinWindowFromID(hwnd, ARC_CNR), HWND_TOP,
1188 0,
1189 22, cx, cy - (24 + 22), SWP_SHOW | SWP_MOVE | SWP_SIZE);
1190 WinSetWindowPos(WinWindowFromID(hwnd, ARC_EXTRACTDIR), HWND_TOP,
1191 0, 0, cx, 22, SWP_SHOW | SWP_MOVE | SWP_SIZE);
1192 WinSetWindowPos(WinWindowFromID(hwnd, DIR_FOLDERICON), HWND_TOP,
1193 2, cy - 22, 24, 20, SWP_SHOW | SWP_MOVE | SWP_SIZE);
1194 WinSetWindowPos(WinWindowFromID(hwnd, DIR_TOTALS), HWND_TOP,
1195 29,
1196 cy - 22,
1197 (cx / 3) - 2, 20, SWP_SHOW | SWP_MOVE | SWP_SIZE);
1198 WinSetWindowPos(WinWindowFromID(hwnd, DIR_SELECTED), HWND_TOP,
1199 29 + (cx / 3) + 2,
1200 cy - 22,
1201 (cx / 3) - 2, 20, SWP_SHOW | SWP_MOVE | SWP_SIZE);
1202 bx = (cx - (29 + (((cx / 3) + 2) * 2))) / 3;
1203 WinSetWindowPos(WinWindowFromID(hwnd, DIR_VIEW), HWND_TOP,
1204 29 + (((cx / 3) + 2) * 2),
1205 cy - 22, bx - 4, 20, SWP_SHOW | SWP_MOVE | SWP_SIZE);
1206 WinSetWindowPos(WinWindowFromID(hwnd, DIR_SORT), HWND_TOP,
1207 29 + (((cx / 3) + 2) * 2) + bx,
1208 cy - 22, bx - 4, 20, SWP_SHOW | SWP_MOVE | SWP_SIZE);
1209 WinSetWindowPos(WinWindowFromID(hwnd, DIR_FILTER), HWND_TOP,
1210 29 + (((cx / 3) + 2) * 2) + (bx * 2),
1211 cy - 22, bx - 4, 20, SWP_SHOW | SWP_MOVE | SWP_SIZE);
1212 }
1213 CommonTextPaint(hwnd, (HPS) 0);
1214 if (msg == UM_SIZE) {
1215 WinSetWindowPos(WinQueryWindow(hwnd, QW_PARENT), HWND_TOP, 0, 0, 0, 0,
1216 SWP_SHOW | SWP_ZORDER | SWP_ACTIVATE);
1217 return 0;
1218 }
1219 break;
1220 }
1221 return WinDefWindowProc(hwnd, msg, mp1, mp2);
1222}
1223
1224MRESULT EXPENTRY ArcObjWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
1225{
1226 DIRCNRDATA *dcd;
1227 PSZ psz;
1228 CHAR szQuotedArcName[CCHMAXPATH];
1229 CHAR szQuotedMemberName[CCHMAXPATH];
1230
1231 switch (msg) {
1232 case DM_PRINTOBJECT:
1233 case DM_DISCARDOBJECT:
1234 dcd = INSTDATA(hwnd);
1235 if (dcd) {
1236
1237 LISTINFO *li;
1238 CNRDRAGINFO cni;
1239
1240 cni.pRecord = NULL;
1241 cni.pDragInfo = (PDRAGINFO) mp1;
1242 li = DoFileDrop(dcd->hwndCnr,
1243 dcd->directory, FALSE, MPVOID, MPFROMP(&cni));
1244 CheckPmDrgLimit(cni.pDragInfo);
1245 if (li) {
1246 li->type = (msg == DM_DISCARDOBJECT) ? IDM_DELETE : IDM_PRINT;
1247 if (!li->list ||
1248 !li->list[0] || !PostMsg(hwnd, UM_ACTION, MPFROMP(li), MPVOID))
1249 FreeListInfo(li);
1250 else
1251 return MRFROMLONG(DRR_SOURCE);
1252 }
1253 }
1254 return MRFROMLONG(DRR_TARGET);
1255
1256 case DM_RENDERPREPARE:
1257 return (MRESULT) TRUE;
1258
1259 case DM_RENDER:
1260 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
1261 if (dcd && dcd->info && dcd->info->extract && dcd->arcname) {
1262
1263 PDRAGTRANSFER pdt = (PDRAGTRANSFER) mp1;
1264 CHAR filename[CCHMAXPATH];
1265 ULONG len;
1266
1267 if (pdt->hwndClient && pdt->pditem && pdt->hstrSelectedRMF &&
1268 pdt->hstrRenderToName) {
1269 if (pdt->usOperation == DO_COPY || pdt->usOperation == DO_MOVE) {
1270 *filename = 0;
1271 len = DrgQueryStrName(pdt->hstrSelectedRMF, CCHMAXPATH, filename);
1272 filename[len] = 0;
1273 if (!strnicmp(filename, "OS2FILE,", 8)) {
1274 // saymsg(MB_ENTER,HWND_DESKTOP,DEBUG_STRING,"RMF = \"%s\"",filename);
1275 }
1276 else {
1277 *filename = 0;
1278 len =
1279 DrgQueryStrName(pdt->hstrRenderToName, CCHMAXPATH, filename);
1280 filename[len] = 0;
1281 if (len && *filename) {
1282 psz = xstrdup(filename, pszSrcFile, __LINE__);
1283 if (psz) {
1284 PostMsg(hwnd, UM_RENDER, MPFROMP(pdt), MPFROMP(psz));
1285 return (MRESULT) TRUE;
1286 }
1287 }
1288 else {
1289 // saymsg(MB_ENTER,HWND_DESKTOP,DEBUG_STRING,"No render-to name given.");
1290 }
1291 }
1292 }
1293 pdt->fsReply = DMFL_RENDERRETRY;
1294 }
1295 }
1296 return (MRESULT) FALSE;
1297
1298 case UM_RENDER:
1299 {
1300 PDRAGTRANSFER pdt = (PDRAGTRANSFER) mp1;
1301 USHORT usRes = DMFL_RENDERFAIL;
1302
1303 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
1304 if (dcd && dcd->info && dcd->info->extract && dcd->arcname) {
1305
1306 CHAR *filename = (CHAR *) mp2, *p;
1307 ULONG len;
1308 CHAR membername[CCHMAXPATH], construct[CCHMAXPATH * 2];
1309
1310 *membername = 0;
1311 len = DrgQueryStrName(pdt->pditem->hstrSourceName,
1312 CCHMAXPATH, membername);
1313 membername[len] = 0;
1314 if (*membername && len && filename) {
1315 unlinkf("%s", filename);
1316 strcpy(construct, filename);
1317 p = strrchr(filename, '\\');
1318 if (!p)
1319 *construct = 0;
1320 else {
1321 if (p == filename || *(p - 1) == ':')
1322 p++;
1323 *p = 0;
1324 }
1325 // saymsg(MB_ENTER,HWND_DESKTOP,DEBUG_STRING,"%s %s %s\r[%s]",dcd->info->extract,dcd->arcname,membername,construct);
1326 runemf2(SEPARATE | WINDOWED | WAIT |
1327 (fArcStuffVisible ? 0 : BACKGROUND | MINIMIZED),
1328 dcd->hwndClient, pszSrcFile, __LINE__, construct, NULL,
1329 "%s %s %s",
1330 dcd->info->extract,
1331 BldQuotedFileName(szQuotedArcName, dcd->arcname),
1332 BldQuotedFileName(szQuotedMemberName, membername));
1333 BldFullPathName(construct, construct, membername);
1334 if (IsFile(construct) != -1) {
1335 rename(construct, filename);
1336 unlinkf("%s", construct);
1337 if (IsFile(filename) != -1)
1338 usRes = DMFL_RENDEROK;
1339 }
1340 }
1341 }
1342 xfree((CHAR *)mp2, pszSrcFile, __LINE__);
1343 PostMsg(pdt->hwndClient, DM_RENDERCOMPLETE, MPFROMP(pdt),
1344 MPFROM2SHORT(usRes, 0));
1345 }
1346 return 0;
1347
1348 case UM_SETUP:
1349 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
1350 if (!dcd) {
1351 Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
1352 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
1353 }
1354 else {
1355 /* set unique id */
1356 WinSetWindowUShort(hwnd, QWS_ID, ARCOBJ_FRAME + (ARC_FRAME - dcd->id));
1357 dcd->hwndObject = hwnd; // pass back hwnd
1358 if (ParentIsDesktop(hwnd, dcd->hwndParent))
1359 DosSleep(100); //05 Aug 07 GKY 250 // Avoid race?
1360 }
1361 return 0;
1362
1363 case UM_RESCAN:
1364 /*
1365 * populate container
1366 */
1367 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
1368 if (dcd) {
1369 if (mp1)
1370 strcpy(dcd->arcname, (CHAR *) mp1); // Update name on request
1371 dcd->ullTotalBytes = dcd->totalfiles =
1372 dcd->selectedfiles = dcd->selectedbytes = 0;
1373 WinSetDlgItemText(dcd->hwndClient, DIR_TOTALS, "0");
1374 WinSetDlgItemText(dcd->hwndClient, DIR_SELECTED, "0 / 0k");
1375 dcd->totalfiles = FillArcCnr(dcd->hwndCnr,
1376 dcd->arcname,
1377 &dcd->info,
1378 &dcd->ullTotalBytes, &dcd->stopflag);
1379 if (!dcd->totalfiles)
1380 PostMsg(dcd->hwndCnr, WM_CLOSE, MPVOID, MPVOID);
1381 else {
1382 dcd->arcfilled = TRUE;
1383 if (!PostMsg(dcd->hwndCnr, UM_RESCAN, MPVOID, MPVOID))
1384 WinSendMsg(dcd->hwndCnr, UM_RESCAN, MPVOID, MPVOID);
1385 PostMsg(dcd->hwndCnr, UM_SETUP2, MPVOID, MPVOID);
1386 WinSendMsg(dcd->hwndCnr,
1387 CM_INVALIDATERECORD,
1388 MPVOID, MPFROM2SHORT(0, CMA_ERASE | CMA_REPOSITION));
1389 }
1390 }
1391 return 0;
1392
1393 case UM_SELECT:
1394 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
1395 if (dcd) {
1396 switch (SHORT1FROMMP(mp1)) {
1397 case IDM_SELECTALL:
1398 case IDM_SELECTALLFILES:
1399 SelectAll(dcd->hwndCnr, TRUE, TRUE, NULL, NULL, TRUE);
1400 break;
1401 case IDM_DESELECTALL:
1402 case IDM_DESELECTALLFILES:
1403 DeselectAll(dcd->hwndCnr, TRUE, TRUE, NULL, NULL, TRUE);
1404 break;
1405 case IDM_DESELECTMASK:
1406 case IDM_SELECTMASK:
1407 {
1408 MASK mask;
1409 PARCITEM pci = (PARCITEM) mp2;
1410
1411 memset(&mask, 0, sizeof(MASK));
1412 mask.fNoAttribs = TRUE;
1413 mask.fNoDirs = TRUE;
1414 strcpy(mask.prompt,
1415 GetPString((SHORT1FROMMP(mp1) == IDM_SELECTMASK) ?
1416 IDS_SELECTFILTERTEXT : IDS_DESELECTFILTERTEXT));
1417 if (pci && (INT) pci != -1)
1418 strcpy(mask.szMask, pci->pszFileName);
1419 if (WinDlgBox(HWND_DESKTOP, dcd->hwndCnr, PickMaskDlgProc,
1420 FM3ModHandle, MSK_FRAME, MPFROMP(&mask))) {
1421 if (SHORT1FROMMP(mp1) == IDM_SELECTMASK)
1422 SelectAll(dcd->hwndCnr, TRUE, TRUE, mask.szMask, NULL, FALSE);
1423 else
1424 DeselectAll(dcd->hwndCnr, TRUE, TRUE, mask.szMask, NULL, FALSE);
1425 }
1426 }
1427
1428 case IDM_INVERT:
1429 InvertAll(dcd->hwndCnr);
1430 break;
1431 }
1432 }
1433 return 0;
1434
1435 case UM_ENTER:
1436 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
1437 if (dcd) {
1438
1439 CHAR *s = (CHAR *) mp1, *p, *pp, filename[CCHMAXPATH];
1440
1441 if (s) {
1442 if (!dcd->info->extract) {
1443 Runtime_Error(pszSrcFile, __LINE__, "no extract");
1444 xfree(s, pszSrcFile, __LINE__);
1445 return 0;
1446 }
1447 runemf2(SEPARATE | WINDOWED | WAIT |
1448 (fArcStuffVisible ? 0 : BACKGROUND | MINIMIZED),
1449 dcd->hwndClient, pszSrcFile, __LINE__, dcd->workdir, NULL,
1450 "%s %s %s",
1451 dcd->info->exwdirs ? dcd->info->exwdirs :
1452 dcd->info->extract,
1453 BldQuotedFileName(szQuotedArcName, dcd->arcname),
1454 BldQuotedFileName(szQuotedMemberName, s));
1455 if (!dcd->info->exwdirs) {
1456 p = s;
1457 p = strrchr(s, '\\');
1458 pp = strrchr(s, '/');
1459 if (p && pp)
1460 p = max(p, pp);
1461 else if (!p)
1462 p = pp;
1463 if (p)
1464 memmove(s, p + 1, strlen(p + 1));
1465 }
1466 sprintf(filename, "%s\\%s", dcd->workdir, s);
1467 p = filename;
1468 while (*p) {
1469 if (*p == '/')
1470 *p = '\\';
1471 p++;
1472 }
1473 // printf("%s %d UM_ENTER %s %s\n",__FILE__, __LINE__,filename, s); fflush(stdout); // 10 Mar 07 SHL hang
1474 xfree(s, pszSrcFile, __LINE__);
1475 if (IsFile(filename) == 1) {
1476#if 1 // 06 Oct 07 SHL fixme to be gone - set to 0 for ticket #58 testing
1477 if (fViewChild && fArcStuffVisible)
1478 DosSleep(100); // Allow unzip session to finish closing 14 Mar 07 SHL
1479#endif
1480 WinSendMsg(dcd->hwndCnr, UM_ENTER, MPFROMP(filename), MPVOID);
1481 }
1482 }
1483 }
1484 return 0;
1485
1486 case UM_COMMAND:
1487 if (mp1) {
1488 if (PostMsg(hwnd, UM_ACTION, mp1, mp2))
1489 return (MRESULT) TRUE;
1490 }
1491 return 0;
1492
1493 case UM_ACTION:
1494 DosError(FERR_DISABLEHARDERR);
1495 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
1496 if (dcd) {
1497
1498 LISTINFO *li = (LISTINFO *) mp1;
1499 register INT x;
1500
1501 if (li && li->list && li->list[0]) {
1502 switch (li->type) {
1503 case IDM_ARCHIVE:
1504 case IDM_ARCHIVEM:
1505 {
1506 DIRCNRDATA ad;
1507 CHAR szBuffer[1025], *p;
1508
1509 if (!li->list[1] && !stricmp(li->list[0], dcd->arcname)) {
1510 Runtime_Error(pszSrcFile, __LINE__, "arc to self");
1511 break;
1512 }
1513 ad = *dcd;
1514 ad.namecanchange = 0;
1515 ad.fmoving = (li->type == IDM_ARCHIVEM);
1516 if (!WinDlgBox(HWND_DESKTOP, dcd->hwndClient, ArchiveDlgProc, FM3ModHandle, ARCH_FRAME, (PVOID) & ad) || !*ad.arcname || !*ad.command) /* we blew it */
1517 break;
1518 /* build the sucker */
1519 strcpy(szBuffer, ad.command);
1520 strcat(szBuffer, " ");
1521
1522 BldQuotedFileName(szBuffer + strlen(szBuffer), ad.arcname);
1523
1524 p = &szBuffer[strlen(szBuffer)]; // Remeber where archiver name ends
1525
1526 if (ad.mask.szMask) {
1527 strcat(szBuffer, " ");
1528
1529 BldQuotedFileName(szBuffer + strlen(szBuffer), ad.mask.szMask);
1530 }
1531 strcat(szBuffer, " ");
1532 x = 0;
1533
1534 // Run commands avoiding command line overflow
1535 while (li->list[x]) {
1536
1537 if (IsFile(li->list[x]))
1538 BldQuotedFileName(szBuffer + strlen(szBuffer), li->list[x]);
1539 else
1540 BldQuotedFullPathName(szBuffer + strlen(szBuffer), li->list[x], "*");
1541
1542 x++;
1543 if (!li->list[x] || strlen(szBuffer) +
1544 strlen(li->list[x]) + 5 > MaxComLineStrg) {
1545 runemf2(SEPARATE | WINDOWED |
1546 (fArcStuffVisible ? 0 : BACKGROUND | MINIMIZED) |
1547 WAIT, hwnd, pszSrcFile, __LINE__,
1548 NULL, NULL, "%s", szBuffer);
1549 *p = 0;
1550 }
1551 strcat(szBuffer, " ");
1552 } // while
1553
1554 PostMsg(dcd->hwndCnr, UM_RESCAN, MPFROMSHORT(1), MPVOID);
1555 Broadcast(WinQueryAnchorBlock(hwnd),
1556 hwndMain, UM_UPDATERECORD, MPFROMP(ad.arcname), MPVOID);
1557 Broadcast(WinQueryAnchorBlock(hwnd),
1558 hwndMain,
1559 UM_UPDATERECORDLIST, MPFROMP(li->list), MPVOID);
1560 }
1561 break;
1562
1563 case IDM_REFRESH:
1564 case IDM_DELETE:
1565 {
1566 CHAR cl[1001], *endofit;
1567 INT z;
1568 CHECKLIST ck;
1569 CHAR prompt[CCHMAXPATH + 257];
1570
1571 if (!dcd->info->delete)
1572 break;
1573 memset(&ck, 0, sizeof(ck));
1574 ck.size = sizeof(ck);
1575 ck.list = li->list;
1576 ck.cmd = li->type;
1577 ck.prompt = prompt;
1578 sprintf(prompt, GetPString(IDS_ARCCNRDELREFTEXT),
1579 (li->type == IDM_DELETE) ?
1580 GetPString(IDS_DELETELOWERTEXT) :
1581 GetPString(IDS_REFRESHLOWERTEXT),
1582 &"s"[li->list[1] == NULL],
1583 dcd->arcname,
1584 (li->type == IDM_DELETE) ?
1585 GetPString(IDS_DELETELOWERTEXT) :
1586 GetPString(IDS_REFRESHLOWERTEXT));
1587 if (!WinDlgBox(HWND_DESKTOP, hwnd, CheckListProc,
1588 FM3ModHandle, CHECK_FRAME, MPFROMP(&ck)))
1589 break;
1590 li->list = ck.list;
1591 if (!li->list || !li->list[0])
1592 break;
1593 strcpy(cl, li->type == IDM_DELETE ?
1594 dcd->info->delete :
1595 dcd->info->create);
1596 strcat(cl, " ");
1597 BldQuotedFileName(cl + strlen(cl), dcd->arcname);
1598 endofit = &cl[strlen(cl)];
1599 z = 0;
1600 do {
1601 for (x = z; li->list[x] &&
1602 strlen(cl) + strlen(li->list[x]) < 999; x++) {
1603 strcat(cl, " ");
1604 BldQuotedFileName(cl + strlen(cl), li->list[x]);
1605 }
1606 z = x;
1607 runemf2(SEPARATE | WINDOWED | WAIT |
1608 (fArcStuffVisible ? 0 : BACKGROUND | MINIMIZED),
1609 hwnd, pszSrcFile, __LINE__, NullStr, NULL, "%s", cl);
1610 *endofit = 0;
1611 } while (li->list[x]);
1612 PostMsg(dcd->hwndCnr, UM_RESCAN, MPFROMSHORT(1), MPVOID);
1613 Broadcast(WinQueryAnchorBlock(hwnd),
1614 hwndMain,
1615 UM_UPDATERECORD, MPFROMP(dcd->arcname), MPVOID);
1616 }
1617 break;
1618
1619 case IDM_PRINT:
1620 case IDM_VIRUSSCAN:
1621 case IDM_VIEW:
1622 case IDM_MCIPLAY:
1623 case IDM_VIEWARCHIVE:
1624 case IDM_VIEWTEXT:
1625 case IDM_VIEWBINARY:
1626 case IDM_EDIT:
1627 case IDM_EDITTEXT:
1628 case IDM_EDITBINARY:
1629 case IDM_EXEC:
1630 case IDM_EXTRACTWDIRS:
1631 case IDM_EXTRACT:
1632 {
1633 CHAR cl[1001], *endofit, *ptr;
1634 INT z;
1635
1636 if ((li->type == IDM_EXTRACT && !li->info->extract) ||
1637 ((li->type == IDM_VIEW || li->type == IDM_VIEWTEXT ||
1638 li->type == IDM_VIEWBINARY || li->type == IDM_EDIT ||
1639 li->type == IDM_VIEWARCHIVE || li->type == IDM_EDITTEXT ||
1640 li->type == IDM_EDITBINARY || li->type == IDM_MCIPLAY) &&
1641 (!li->info->extract && !li->info->exwdirs)) ||
1642 (li->type != IDM_EXTRACT && li->type != IDM_EDIT &&
1643 li->type != IDM_VIEW && li->type != IDM_VIEWTEXT &&
1644 li->type != IDM_VIEWBINARY &&
1645 li->type != IDM_VIEWARCHIVE &&
1646 li->type != IDM_EDITTEXT &&
1647 li->type != IDM_EDITBINARY &&
1648 li->type != IDM_MCIPLAY && !li->info->exwdirs)) {
1649 Runtime_Error(pszSrcFile, __LINE__, "no cmd for request");
1650 break;
1651 }
1652 if (li->type == IDM_EXTRACT || li->type == IDM_EXTRACTWDIRS) {
1653
1654 CHAR fullname[CCHMAXPATH * 2];
1655 CHAR **exfiles = NULL;
1656 UINT numfiles = 0, numalloc = 0;
1657
1658 for (x = 0; li->list[x]; x++) {
1659 BldFullPathName(fullname, li->targetpath, li->list[x]);
1660 if (IsFile(fullname) != -1) {
1661 AddToList(li->list[x], &exfiles, &numfiles, &numalloc);
1662 li->list = RemoveFromList(li->list, li->list[x]);
1663 if (!li->list)
1664 break;
1665 x--;
1666 }
1667 }
1668 if (exfiles && numfiles) {
1669
1670 CHECKLIST ckl;
1671 CHAR prompt[(CCHMAXPATH * 2) + 256];
1672
1673 memset(&ckl, 0, sizeof(ckl));
1674 ckl.size = sizeof(ckl);
1675 ckl.list = exfiles;
1676 ckl.prompt = prompt;
1677 ckl.cmd = li->type;
1678 sprintf(prompt,
1679 GetPString(IDS_REPLACEWARNTEXT),
1680 &"s"[numfiles == 1],
1681 li->arcname, &"s"[numfiles != 1], li->targetpath);
1682 if (!WinDlgBox(HWND_DESKTOP, hwnd, CheckListProc,
1683 FM3ModHandle, CHECK_FRAME, MPFROMP(&ckl))) {
1684 if (ckl.list)
1685 FreeList(ckl.list);
1686 break;
1687 }
1688 else if (ckl.list)
1689 li->list = CombineLists(li->list, ckl.list);
1690 }
1691 }
1692 if (!li->list || !li->list[0])
1693 break;
1694 strcpy(cl,
1695 (li->type == IDM_EXTRACT ||
1696 ((li->type == IDM_VIEW ||
1697 li->type == IDM_VIEWTEXT ||
1698 li->type == IDM_VIEWBINARY ||
1699 li->type == IDM_VIEWARCHIVE ||
1700 li->type == IDM_PRINT ||
1701 li->type == IDM_EDIT ||
1702 li->type == IDM_EDITTEXT ||
1703 (li->type == IDM_EDITBINARY &&
1704 li->type == IDM_MCIPLAY)) &&
1705 !li->info->exwdirs)) ?
1706 li->info->extract :
1707 li->info->exwdirs);
1708 strcat(cl, " ");
1709 BldQuotedFileName(cl + strlen(cl), li->arcname);
1710 endofit = &cl[strlen(cl)];
1711 z = 0;
1712 do {
1713 for (x = z; li->list[x] &&
1714 strlen(cl) + strlen(li->list[x]) < 999; x++) {
1715 strcat(cl, " ");
1716 BldQuotedFileName(cl + strlen(cl), li->list[x]);
1717 ptr = li->list[x];
1718 while (*ptr) {
1719 if (*ptr == '/')
1720 *ptr = '\\';
1721 ptr++;
1722 }
1723 }
1724 z = x;
1725 runemf2(SEPARATE | WINDOWED |
1726 (fArcStuffVisible ? 0 : BACKGROUND | MINIMIZED) |
1727 WAIT, hwnd, pszSrcFile, __LINE__,
1728 li->targetpath, NULL, "%s", cl);
1729 *endofit = 0;
1730 } while (li->list[x]);
1731 if (li->type == IDM_EXTRACT || li->type == IDM_EXTRACTWDIRS) {
1732 /* update windows */
1733 for (x = 0; li->list[x]; x++) {
1734
1735 CHAR *temp, *p;
1736
1737 temp = li->list[x];
1738 p = temp;
1739 while (*p) {
1740 if (*p == '/')
1741 *p = '\\';
1742 p++;
1743 }
1744 p = xmalloc(strlen(temp) + strlen(li->targetpath) + 2,
1745 pszSrcFile, __LINE__);
1746 if (p) {
1747 strcpy(p, li->targetpath);
1748 if (p[strlen(p) - 1] != '\\')
1749 strcat(p, "\\");
1750 strcat(p, temp);
1751 li->list[x] = p;
1752 xfree(temp, pszSrcFile, __LINE__);
1753 }
1754 }
1755 if (fFolderAfterExtract) {
1756
1757 CHAR objectpath[CCHMAXPATH], *p;
1758 APIRET rc;
1759
1760 GetDesktopName(objectpath, sizeof(objectpath));
1761 rc = WinDlgBox(HWND_DESKTOP, dcd->hwndParent, ObjCnrDlgProc,
1762 FM3ModHandle, OBJCNR_FRAME,
1763 MPFROMP(objectpath));
1764 if (rc) {
1765 if (rc > 1)
1766 strcpy(objectpath, "<WP_DESKTOP>");
1767 p = NULL;
1768 if (li->arcname) {
1769 p = strrchr(li->arcname, '\\');
1770 if (p)
1771 p++;
1772 }
1773 MakeShadows(dcd->hwndParent, li->list, 2, objectpath, p);
1774 }
1775 }
1776 Broadcast(WinQueryAnchorBlock(hwnd),
1777 hwndMain,
1778 UM_UPDATERECORDLIST, MPFROMP(li->list), MPVOID);
1779 }
1780 else if (li->type == IDM_EXEC)
1781 ExecOnList(hwnd,
1782 li->runfile,
1783 WINDOWED | SEPARATEKEEP | PROMPT,
1784 li->targetpath,
1785 NULL, GetPString(IDS_EXECARCFILETITLETEXT),
1786 pszSrcFile, __LINE__);
1787 else if (li->type == IDM_VIRUSSCAN)
1788 ExecOnList(hwnd, virus, PROMPT | WINDOWED | SEPARATEKEEP,
1789 li->targetpath, NULL,
1790 GetPString(IDS_VIRUSSCANARCHIVETITLETEXT),
1791 pszSrcFile, __LINE__);
1792 else if (li->type == IDM_VIEW || li->type == IDM_VIEWTEXT ||
1793 li->type == IDM_VIEWBINARY || li->type == IDM_EDIT ||
1794 li->type == IDM_EDITTEXT ||
1795 li->type == IDM_VIEWARCHIVE ||
1796 li->type == IDM_EDITBINARY ||
1797 li->type == IDM_MCIPLAY || li->type == IDM_PRINT) {
1798
1799 CHAR *temp, *p;
1800
1801 for (x = 0; li->list[x]; x++) {
1802 if (!li->info->exwdirs) {
1803 temp = li->list[x];
1804 p = strrchr(li->list[x], '\\');
1805 if (p) {
1806 p++;
1807 li->list[x] = xstrdup(p, pszSrcFile, __LINE__);
1808 if (!li->list[x])
1809 li->list[x] = temp;
1810 else {
1811 xfree(temp, pszSrcFile, __LINE__);
1812 }
1813 }
1814 }
1815 BldFullPathName(cl, li->targetpath, li->list[x]);
1816 temp = li->list[x];
1817 li->list[x] = xstrdup(cl, pszSrcFile, __LINE__);
1818 if (!li->list[x])
1819 li->list[x] = temp;
1820 else
1821 xfree(temp, pszSrcFile, __LINE__);
1822 }
1823 if (li->type == IDM_VIEW || li->type == IDM_EDIT) {
1824
1825 BOOL isit = TestBinary(li->list[0]);
1826
1827 if (isit) {
1828 if (li->type == IDM_VIEW)
1829 li->type = IDM_VIEWBINARY;
1830 else
1831 li->type = IDM_EDITBINARY;
1832 }
1833 else {
1834 if (li->type == IDM_VIEW)
1835 li->type = IDM_VIEWTEXT;
1836 else
1837 li->type = IDM_EDITTEXT;
1838 }
1839 }
1840 if (li->type == IDM_MCIPLAY) {
1841
1842 FILE *fp;
1843
1844 fp = xfopen("$FM2PLAY.$$$", "w", pszSrcFile, __LINE__);
1845 if (fp) {
1846 fprintf(fp, "%s", ";AV/2-built FM2Play listfile\n");
1847 for (x = 0; li->list[x]; x++)
1848 fprintf(fp, "%s\n", li->list[x]);
1849 fprintf(fp, ";end\n");
1850 fclose(fp);
1851 RunFM2Util("FM2PLAY.EXE", "/@$FM2PLAY.$$$");
1852 }
1853 }
1854 else if (li->type == IDM_PRINT) {
1855 strcpy(li->targetpath, printer);
1856 if (_beginthread(PrintListThread, NULL, 65536, (PVOID) li) !=
1857 -1) {
1858 Runtime_Error(pszSrcFile, __LINE__,
1859 GetPString(IDS_COULDNTSTARTTHREADTEXT));
1860 li = NULL;
1861 }
1862 }
1863 else if (li->type == IDM_VIEWARCHIVE) {
1864
1865 ARC_TYPE *info;
1866
1867 for (x = 0; li->list[x]; x++) {
1868 if (IsFile(li->list[x]) == 1) {
1869 info = NULL; // Do not hide dups - fixme to know why?
1870 if (WinDlgBox(HWND_DESKTOP, HWND_DESKTOP,
1871 SBoxDlgProc, FM3ModHandle, ASEL_FRAME,
1872 (PVOID) & info) && info) {
1873 StartArcCnr(HWND_DESKTOP,
1874 HWND_DESKTOP, li->list[x], 4, info);
1875 }
1876 }
1877 }
1878 }
1879 else if ((li->type == IDM_VIEWTEXT && *viewer) ||
1880 (li->type == IDM_VIEWBINARY && *binview) ||
1881 (li->type == IDM_EDITTEXT && *editor) ||
1882 (li->type == IDM_EDITBINARY && *bined)) {
1883 DosSleep(32); //05 Aug 07 GKY 100
1884 ExecOnList(hwnd, ((li->type == IDM_VIEWTEXT) ? viewer :
1885 (li->type == IDM_VIEWBINARY) ? binview :
1886 (li->type == IDM_EDITTEXT) ? editor :
1887 bined),
1888 WINDOWED | SEPARATE, li->targetpath, li->list,
1889 NULL, pszSrcFile, __LINE__);
1890 }
1891 else {
1892 if (li->hwnd) {
1893
1894 ULONG viewtype;
1895
1896 for (x = 0; li->list[x]; x++) {
1897 if (x == 0) {
1898 if (li->type == IDM_VIEWBINARY ||
1899 li->type == IDM_EDITBINARY)
1900 viewtype = 16;
1901 else
1902 viewtype = 8;
1903 }
1904 else
1905 viewtype = 0;
1906 temp = xstrdup(li->list[x], pszSrcFile, __LINE__);
1907 if (temp) {
1908 if (!PostMsg(WinQueryWindow(li->hwnd, QW_PARENT),
1909 UM_LOADFILE,
1910 MPFROMLONG(4L +
1911 (li->type == IDM_VIEWTEXT ||
1912 li->type == IDM_VIEWBINARY) +
1913 viewtype), MPFROMP(temp)))
1914 free(temp);
1915 }
1916 }
1917 }
1918 }
1919 }
1920 }
1921 break;
1922
1923 case IDM_FIND:
1924 {
1925 UINT numfiles = 0, numalloced = 0;
1926 CHAR **list2 = NULL, fullname[CCHMAXPATH * 2], *p;
1927
1928 for (x = 0; li->list[x]; x++) {
1929 p = li->list[x];
1930 while (*p) {
1931 if (*p == '/')
1932 *p = '\\';
1933 p++;
1934 }
1935 BldFullPathName(fullname, dcd->directory, li->list[x]);
1936 // sprintf(fullname, "%s%s%s", dcd->directory,
1937 // (dcd->directory[strlen(dcd->directory) - 1] == '\\') ?
1938 // NullStr : "\\", li->list[x]);
1939 if (IsFile(fullname) != -1)
1940 if (AddToList(fullname, &list2, &numfiles, &numalloced))
1941 break;
1942 if (strchr(li->list[x], '\\')) {
1943 p = strrchr(li->list[x], '\\');
1944 if (p) {
1945 p++;
1946 if (*p) {
1947 BldFullPathName(fullname, dcd->directory, p);
1948 // sprintf(fullname, "%s%s%s", dcd->directory,
1949 // (dcd->directory[strlen(dcd->directory) - 1] ==
1950 // '\\') ? NullStr : "\\",
1951 // p);
1952 if (IsFile(fullname) != -1)
1953 if (AddToList(fullname, &list2, &numfiles, &numalloced))
1954 break;
1955 }
1956 }
1957 }
1958 }
1959 if (!numfiles || !list2)
1960 Runtime_Error(pszSrcFile, __LINE__, "no files or list");
1961 else {
1962 WinSendMsg(dcd->hwndCnr, WM_COMMAND,
1963 MPFROM2SHORT(IDM_COLLECTOR, 0), MPVOID);
1964 DosSleep(10); //05 Aug 07 GKY 128
1965 if (Collector) {
1966 if (!PostMsg(Collector, WM_COMMAND,
1967 MPFROM2SHORT(IDM_COLLECTOR, 0), MPFROMP(list2)))
1968 FreeList(list2);
1969 }
1970 else
1971 FreeList(list2);
1972 }
1973 }
1974 break;
1975 }
1976 }
1977 FreeListInfo(li);
1978 }
1979 return 0;
1980
1981 case WM_CLOSE:
1982 WinDestroyWindow(hwnd);
1983 break;
1984
1985 case WM_DESTROY:
1986 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
1987 if (dcd) {
1988 if (*dcd->workdir) {
1989 DosSleep(16); //05 Aug 07 GKY 33
1990 wipeallf("%s\\*", dcd->workdir);
1991 if (rmdir(dcd->workdir)) {
1992 DosSleep(100); //05 Aug 07 GKY 256
1993 wipeallf("%s\\*", dcd->workdir);
1994 rmdir(dcd->workdir);
1995 }
1996 }
1997 FreeList(dcd->lastselection);
1998 WinSendMsg(dcd->hwndCnr, UM_CLOSE, MPVOID, MPVOID);
1999 xfree(dcd, pszSrcFile, __LINE__);
2000# ifdef FORTIFY
2001 Fortify_LeaveScope();
2002# endif
2003 WinSetWindowPtr(dcd->hwndCnr, QWL_USER, NULL);
2004 }
2005 if (!PostMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID))
2006 WinSendMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID);
2007 break;
2008 } // switch
2009 return WinDefWindowProc(hwnd, msg, mp1, mp2);
2010}
2011
2012static MRESULT EXPENTRY ArcCnrWndProc(HWND hwnd, ULONG msg, MPARAM mp1,
2013 MPARAM mp2)
2014{
2015 DIRCNRDATA *dcd = INSTDATA(hwnd);
2016 CHAR szQuotedArcName[CCHMAXPATH];
2017
2018 switch (msg) {
2019 case DM_PRINTOBJECT:
2020 case DM_DISCARDOBJECT:
2021 if (dcd)
2022 return WinSendMsg(dcd->hwndObject, msg, mp1, mp2);
2023 else
2024 return MRFROMLONG(DRR_TARGET);
2025
2026 case WM_CHAR:
2027 shiftstate = (SHORT1FROMMP(mp1) & (KC_SHIFT | KC_ALT | KC_CTRL));
2028 if (SHORT1FROMMP(mp1) & KC_KEYUP)
2029 return (MRESULT) TRUE;
2030 if (SHORT1FROMMP(mp1) & KC_VIRTUALKEY) {
2031 switch (SHORT2FROMMP(mp2)) {
2032 case VK_DELETE:
2033 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_DELETE, 0), MPVOID);
2034 break;
2035 }
2036 }
2037 if (shiftstate || fNoSearch)
2038 break;
2039 if (SHORT1FROMMP(mp1) & KC_CHAR) {
2040
2041 ULONG thistime, len;
2042 SEARCHSTRING srch;
2043 PCNRITEM pci;
2044
2045 if (!dcd)
2046 break;
2047 switch (SHORT1FROMMP(mp2)) {
2048 case '\x1b':
2049 case '\r':
2050 case '\n':
2051 dcd->lasttime = 0;
2052 *dcd->szCommonName = 0;
2053 break;
2054 default:
2055 thistime = WinQueryMsgTime(WinQueryAnchorBlock(hwnd));
2056 if (thistime > dcd->lasttime + 1250)
2057 *dcd->szCommonName = 0;
2058 dcd->lasttime = thistime;
2059 if (SHORT1FROMMP(mp2) == ' ' && !*dcd->szCommonName)
2060 break;
2061 KbdRetry:
2062 len = strlen(dcd->szCommonName);
2063 if (len >= CCHMAXPATH - 1) {
2064 *dcd->szCommonName = 0;
2065 len = 0;
2066 }
2067 dcd->szCommonName[len] = toupper(SHORT1FROMMP(mp2));
2068 dcd->szCommonName[len + 1] = 0;
2069 memset(&srch, 0, sizeof(SEARCHSTRING));
2070 srch.cb = (ULONG) sizeof(SEARCHSTRING);
2071 srch.pszSearch = dcd->szCommonName;
2072 srch.fsPrefix = TRUE;
2073 srch.fsCaseSensitive = FALSE;
2074 srch.usView = CV_ICON;
2075 pci = WinSendMsg(hwnd,
2076 CM_SEARCHSTRING,
2077 MPFROMP(&srch), MPFROMLONG(CMA_FIRST));
2078 if (pci && (INT) pci != -1) {
2079
2080 USHORT attrib = CRA_CURSORED;
2081
2082 /* make found item current item */
2083 if (!stricmp(pci->pszFileName, dcd->szCommonName))
2084 attrib |= CRA_SELECTED;
2085 WinSendMsg(hwnd,
2086 CM_SETRECORDEMPHASIS,
2087 MPFROMP(pci), MPFROM2SHORT(TRUE, attrib));
2088 /* make sure that record shows in viewport */
2089 ShowCnrRecord(hwnd, (PMINIRECORDCORE) pci);
2090 return (MRESULT) TRUE;
2091 }
2092 else {
2093 if (SHORT1FROMMP(mp2) == ' ') {
2094 dcd->szCommonName[len] = 0;
2095 break;
2096 }
2097 *dcd->szCommonName = 0;
2098 dcd->lasttime = 0;
2099 if (len) // retry as first letter if no match
2100 goto KbdRetry;
2101 }
2102 break;
2103 }
2104 }
2105 break;
2106
2107 case WM_MOUSEMOVE:
2108 case WM_BUTTON1UP:
2109 case WM_BUTTON2UP:
2110 case WM_BUTTON3UP:
2111 case WM_CHORD:
2112 shiftstate = (SHORT2FROMMP(mp2) & (KC_SHIFT | KC_ALT | KC_CTRL));
2113 break;
2114
2115 case WM_BUTTON1MOTIONEND:
2116 {
2117 CNRINFO cnri;
2118
2119 memset(&cnri, 0, sizeof(CNRINFO));
2120 cnri.cb = sizeof(CNRINFO);
2121 if (WinSendMsg(hwnd,
2122 CM_QUERYCNRINFO,
2123 MPFROMP(&cnri), MPFROMLONG(sizeof(CNRINFO)))) {
2124 if (cnri.flWindowAttr & CV_DETAIL)
2125 PrfWriteProfileData(fmprof,
2126 appname,
2127 "ArcCnrSplitBar",
2128 (PVOID) & cnri.xVertSplitbar, sizeof(LONG));
2129 }
2130 }
2131 break;
2132
2133 case WM_PRESPARAMCHANGED:
2134 PresParamChanged(hwnd, "ArcCnr", mp1, mp2);
2135 break;
2136
2137 case UM_UPDATERECORD:
2138 case UM_UPDATERECORDLIST:
2139 if (dcd && !IsArcThere(hwnd, dcd->arcname))
2140 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
2141 return 0;
2142
2143 case WM_SETFOCUS:
2144 /*
2145 * put name of our window (archive name) on status line
2146 */
2147 if (dcd && hwndStatus && mp2)
2148 WinSendMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
2149 break;
2150
2151 case UM_SETUP2:
2152 if (dcd && dcd->info) {
2153 if (dcd->info->fdpos == -1 || !dcd->info->datetype)
2154 dcd->sortFlags &= (~SORT_LWDATE);
2155 if (dcd->info->nsizepos == -1)
2156 dcd->sortFlags &= (~SORT_EASIZE);
2157 if (dcd->info->osizepos == -1)
2158 dcd->sortFlags &= (~SORT_SIZE);
2159 AdjustCnrColVis(hwnd,
2160 GetPString(IDS_OLDSIZECOLTEXT),
2161 dcd->info->osizepos != -1, FALSE);
2162 AdjustCnrColVis(hwnd,
2163 GetPString(IDS_NEWSIZECOLTEXT),
2164 dcd->info->nsizepos != -1, FALSE);
2165 // Display unsullied date/time string if type 0
2166 AdjustCnrColVis(hwnd,
2167 GetPString(IDS_DATETIMECOLTEXT),
2168 dcd->info->fdpos != -1 && !dcd->info->datetype, FALSE);
2169 // Display parsed date/time columns if type specified
2170 AdjustCnrColVis(hwnd,
2171 GetPString(IDS_TIMECOLTEXT),
2172 dcd->info->fdpos != -1 && dcd->info->datetype, FALSE);
2173 AdjustCnrColVis(hwnd,
2174 GetPString(IDS_DATECOLTEXT),
2175 dcd->info->fdpos != -1 && dcd->info->datetype, FALSE);
2176 WinSendMsg(hwnd, CM_INVALIDATEDETAILFIELDINFO, MPVOID, MPVOID);
2177 }
2178 return 0;
2179
2180 case UM_RESCAN:
2181 if (dcd) {
2182 CNRINFO cnri;
2183 CHAR s[CCHMAXPATH * 2], tb[81], tf[81];
2184 PARCITEM pci;
2185
2186 if (mp1) {
2187 PostMsg(dcd->hwndObject, UM_RESCAN, MPVOID, MPVOID);
2188 return 0;
2189 }
2190 memset(&cnri, 0, sizeof(CNRINFO));
2191 cnri.cb = sizeof(CNRINFO);
2192 WinSendMsg(hwnd,
2193 CM_QUERYCNRINFO,
2194 MPFROMP(&cnri), MPFROMLONG(sizeof(CNRINFO)));
2195 dcd->totalfiles = cnri.cRecords;
2196 commafmt(tf, sizeof(tf), dcd->selectedfiles);
2197 if (dcd->ullTotalBytes)
2198 CommaFmtULL(tb, sizeof(tb), dcd->selectedbytes, 'K');
2199 else
2200 *tb = 0;
2201 sprintf(s, "%s%s%s", tf, *tb ? " / " : NullStr, tb);
2202 WinSetDlgItemText(dcd->hwndClient, DIR_SELECTED, s);
2203 commafmt(tf, sizeof(tf), dcd->totalfiles);
2204 if (dcd->ullTotalBytes)
2205 CommaFmtULL(tb, sizeof(tb), dcd->ullTotalBytes, 'K');
2206 else
2207 *tb = 0;
2208 sprintf(s, "%s%s%s", tf, *tb ? " / " : NullStr, tb);
2209 WinSetDlgItemText(dcd->hwndClient, DIR_TOTALS, s);
2210 if (hwndStatus &&
2211 dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent)) {
2212 sprintf(s, " [%s%s%s]%s%s%s %s",
2213 tf,
2214 *tb ? " / " : NullStr,
2215 tb,
2216 *dcd->mask.szMask ? " (" : NullStr,
2217 *dcd->mask.szMask ? dcd->mask.szMask : NullStr,
2218 *dcd->mask.szMask ? ")" : NullStr, dcd->arcname);
2219 WinSetWindowText(hwndStatus, s);
2220 if (!ParentIsDesktop(hwnd, dcd->hwndParent)) {
2221 pci = WinSendMsg(hwnd,
2222 CM_QUERYRECORDEMPHASIS,
2223 MPFROMLONG(CMA_FIRST), MPFROMSHORT(CRA_CURSORED));
2224 if (pci && (INT) pci != -1) {
2225 if (fSplitStatus && hwndStatus2) {
2226 if (dcd->ullTotalBytes)
2227 CommaFmtULL(tb, sizeof(tb), pci->cbFile, ' ');
2228 else
2229 *tb = 0;
2230 sprintf(s, "%s%s%s%s",
2231 *tb ? " " : NullStr,
2232 tb, *tb ? " " : NullStr, pci->pszFileName);
2233 WinSetWindowText(hwndStatus2, s);
2234 }
2235 if (fMoreButtons)
2236 WinSetWindowText(hwndName, pci->pszFileName);
2237 }
2238 else {
2239 WinSetWindowText(hwndStatus2, NullStr);
2240 WinSetWindowText(hwndName, NullStr);
2241 }
2242 WinSetWindowText(hwndDate, NullStr);
2243 WinSetWindowText(hwndAttr, NullStr);
2244 }
2245 }
2246 if ((dcd->arcfilled && !dcd->totalfiles) ||
2247 !IsArcThere(hwnd, dcd->arcname))
2248 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
2249 }
2250 return 0;
2251
2252 case UM_SETUP:
2253 if (!dcd) {
2254 Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
2255 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
2256 return 0;
2257 }
2258 else {
2259 if (!dcd->hwndObject) {
2260 /*
2261 * first time through -- set things up
2262 */
2263 {
2264 CHAR *p, *pp;
2265 ULONG z, was;
2266 APIRET rc;
2267
2268 rc = DosCreateDir(dcd->workdir, 0);
2269 if (rc) {
2270 if (rc == ERROR_ACCESS_DENIED) {
2271 p = strrchr(dcd->workdir, '.');
2272 if (p) {
2273 p++;
2274 pp = p;
2275 was = strtoul(p, &pp, 16);
2276 for (z = 0; z < 99; z++) {
2277 was++;
2278 sprintf(p, "%03x");
2279 rc = DosCreateDir(dcd->workdir, 0);
2280 if (!rc || rc != ERROR_ACCESS_DENIED)
2281 break;
2282 }
2283 }
2284 }
2285 if (rc)
2286 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
2287 return 0;
2288 }
2289 }
2290 RestorePresParams(hwnd, "ArcCnr");
2291 dcd->mask.fNoAttribs = TRUE;
2292 dcd->mask.fNoDirs = TRUE;
2293 *dcd->mask.prompt = 0;
2294 {
2295 PFIELDINFO pfi, pfiLastLeftCol;
2296 ULONG numcols = CON_COLS;
2297 CNRINFO cnri;
2298 ULONG size;
2299
2300 pfi = WinSendMsg(hwnd,
2301 CM_ALLOCDETAILFIELDINFO,
2302 MPFROMLONG(numcols), NULL);
2303 if (pfi) {
2304
2305 PFIELDINFO pfiFirst;
2306 FIELDINFOINSERT fii;
2307
2308 pfiFirst = pfi;
2309 pfi->flData = CFA_STRING | CFA_LEFT | CFA_FIREADONLY;
2310 pfi->flTitle = CFA_CENTER;
2311 pfi->pTitleData = GetPString(IDS_FILENAMECOLTEXT);
2312 pfi->offStruct = FIELDOFFSET(ARCITEM, pszDisplayName);
2313 pfiLastLeftCol = pfi;
2314 pfi = pfi->pNextFieldInfo;
2315 pfi->flData =
2316 CFA_ULONG | CFA_RIGHT | CFA_SEPARATOR | CFA_FIREADONLY;
2317 pfi->flTitle = CFA_CENTER;
2318 pfi->pTitleData = GetPString(IDS_OLDSIZECOLTEXT);
2319 pfi->offStruct = FIELDOFFSET(ARCITEM, cbFile);
2320 pfi = pfi->pNextFieldInfo;
2321 pfi->flData =
2322 CFA_ULONG | CFA_RIGHT | CFA_SEPARATOR | CFA_FIREADONLY;
2323 pfi->flTitle = CFA_CENTER;
2324 pfi->pTitleData = GetPString(IDS_NEWSIZECOLTEXT);
2325 pfi->offStruct = FIELDOFFSET(ARCITEM, cbComp);
2326 pfi = pfi->pNextFieldInfo;
2327 pfi->flData =
2328 CFA_STRING | CFA_CENTER | CFA_SEPARATOR | CFA_FIREADONLY;
2329 pfi->flTitle = CFA_CENTER | CFA_FITITLEREADONLY;
2330 pfi->pTitleData = GetPString(IDS_DATETIMECOLTEXT);
2331 pfi->offStruct = FIELDOFFSET(ARCITEM, pszDate);
2332 pfi = pfi->pNextFieldInfo;
2333 pfi->flData = CFA_DATE | CFA_RIGHT | CFA_FIREADONLY;
2334 pfi->flTitle = CFA_CENTER;
2335 pfi->pTitleData = GetPString(IDS_DATECOLTEXT);
2336 pfi->offStruct = FIELDOFFSET(ARCITEM, date);
2337 pfi = pfi->pNextFieldInfo;
2338 pfi->flData = CFA_TIME | CFA_RIGHT | CFA_FIREADONLY;
2339 pfi->flTitle = CFA_CENTER | CFA_FITITLEREADONLY;
2340 pfi->pTitleData = GetPString(IDS_TIMECOLTEXT);
2341 pfi->offStruct = FIELDOFFSET(ARCITEM, time);
2342 memset(&fii, 0, sizeof(FIELDINFOINSERT));
2343 fii.cb = sizeof(FIELDINFOINSERT);
2344 fii.pFieldInfoOrder = (PFIELDINFO) CMA_FIRST;
2345 fii.cFieldInfoInsert = (SHORT) numcols;
2346 fii.fInvalidateFieldInfo = TRUE;
2347 WinSendMsg(hwnd,
2348 CM_INSERTDETAILFIELDINFO,
2349 MPFROMP(pfiFirst), MPFROMP(&fii));
2350 PostMsg(hwnd, UM_SETUP2, MPVOID, MPVOID);
2351
2352 memset(&cnri, 0, sizeof(cnri));
2353 cnri.cb = sizeof(CNRINFO);
2354 cnri.pFieldInfoLast = pfiLastLeftCol;
2355 cnri.xVertSplitbar = DIR_SPLITBAR_OFFSET + 32;
2356
2357 size = sizeof(LONG);
2358 PrfQueryProfileData(fmprof, appname, "ArcCnrSplitBar",
2359 &cnri.xVertSplitbar, &size);
2360 if (cnri.xVertSplitbar <= 0)
2361 cnri.xVertSplitbar = DIR_SPLITBAR_OFFSET + 32;
2362
2363 cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT | CV_NAME));
2364 cnri.flWindowAttr |= (CV_DETAIL | CA_DETAILSVIEWTITLES | CV_FLOW);
2365 cnri.flWindowAttr &= (~(CA_ORDEREDTARGETEMPH |
2366 CA_MIXEDTARGETEMPH));
2367 cnri.pSortRecord = (PVOID) ArcSort;
2368 WinSendMsg(hwnd,
2369 CM_SETCNRINFO,
2370 MPFROMP(&cnri),
2371 MPFROMLONG(CMA_PFIELDINFOLAST |
2372 CMA_XVERTSPLITBAR |
2373 CMA_PSORTRECORD | CMA_FLWINDOWATTR));
2374 }
2375 }
2376 WinSendMsg(hwnd, CM_SORTRECORD, MPFROMP(ArcSort), MPFROMP(dcd));
2377 if (_beginthread(MakeObjWin, NULL, 245760, (PVOID) dcd) == -1) {
2378 Runtime_Error(pszSrcFile, __LINE__,
2379 GetPString(IDS_COULDNTSTARTTHREADTEXT));
2380 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
2381 return 0;
2382 }
2383 else
2384 DosSleep(1);
2385 SayFilter(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
2386 DIR_FILTER), &dcd->mask, TRUE);
2387 SaySort(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
2388 DIR_SORT), dcd->sortFlags, TRUE);
2389 DefArcSortFlags = dcd->sortFlags; // Remember for new windows
2390 }
2391 }
2392 return 0;
2393
2394 case UM_SETDIR:
2395 if (dcd) {
2396
2397 CHAR s[CCHMAXPATH], *p;
2398 ULONG ret = 0;
2399
2400 WinQueryDlgItemText(dcd->hwndClient, ARC_EXTRACTDIR, CCHMAXPATH, s);
2401 bstrip(s);
2402 MakeFullName(s);
2403 if (*s) {
2404 while ((p = strchr(s, '/')) != NULL)
2405 *p = '\\';
2406 while (strlen(s) > 3 && s[strlen(s) - 1] == '\\')
2407 s[strlen(s) - 1] = 0;
2408 if (stricmp(s, dcd->directory)) {
2409 if (IsFullName(s)) {
2410 if (driveflags[toupper(*s) - 'A'] &
2411 (DRIVE_NOTWRITEABLE | DRIVE_IGNORE | DRIVE_INVALID)) {
2412 Runtime_Error(pszSrcFile, __LINE__, "drive %s bad", s);
2413 WinSetDlgItemText(dcd->hwndClient,
2414 ARC_EXTRACTDIR, dcd->directory);
2415 return 0;
2416 }
2417 }
2418 if (!SetDir(dcd->hwndParent, hwnd, s, 0)) {
2419 if (stricmp(dcd->directory, s)) {
2420 DosEnterCritSec();
2421 strcpy(lastextractpath, s);
2422 DosExitCritSec();
2423 }
2424 strcpy(dcd->directory, s);
2425 if ((!isalpha(*s) || s[1] != ':') && *s != '.')
2426 saymsg(MB_ENTER | MB_ICONASTERISK,
2427 hwnd,
2428 GetPString(IDS_WARNINGTEXT),
2429 GetPString(IDS_SPECIFYDRIVETEXT));
2430 }
2431 else
2432 ret = 1;
2433 }
2434 }
2435 WinSetDlgItemText(dcd->hwndClient, ARC_EXTRACTDIR, dcd->directory);
2436 return (MRESULT) ret;
2437 }
2438 return 0;
2439
2440 case UM_ENTER:
2441 if (WinSendMsg(hwnd, UM_SETDIR, MPVOID, MPVOID))
2442 return 0;
2443 SetShiftState();
2444 if (dcd && (CHAR *) mp1) {
2445
2446 SWP swp;
2447 CHAR *filename = mp1;
2448
2449 if (IsFile(filename) != 1)
2450 return 0;
2451 WinQueryWindowPos(dcd->hwndFrame, &swp);
2452 DefaultViewKeys(hwnd, dcd->hwndFrame, dcd->hwndParent, &swp, filename);
2453 if (fUnHilite)
2454 UnHilite(hwnd, FALSE, &dcd->lastselection, 0);
2455 }
2456 return 0;
2457
2458 case WM_MENUEND:
2459 if (dcd) {
2460
2461 HWND hwndMenu = (HWND) mp2;
2462
2463 if (hwndMenu == ArcCnrMenu || hwndMenu == ArcMenu) {
2464 MarkAll(hwnd, TRUE, FALSE, TRUE);
2465 if (dcd->cnremphasized) {
2466 WinSendMsg(hwnd,
2467 CM_SETRECORDEMPHASIS,
2468 MPVOID, MPFROM2SHORT(FALSE, CRA_SOURCE));
2469 dcd->cnremphasized = FALSE;
2470 }
2471 }
2472 }
2473 break;
2474
2475 case MM_PORTHOLEINIT:
2476 if (dcd) {
2477 switch (SHORT1FROMMP(mp1)) {
2478 case 0:
2479 case 1:
2480 {
2481 ULONG wmsg;
2482
2483 wmsg = SHORT1FROMMP(mp1) == 0 ? UM_FILESMENU : UM_VIEWSMENU;
2484 PortholeInit((HWND) WinSendMsg(dcd->hwndClient,
2485 wmsg, MPVOID, MPVOID), mp1, mp2);
2486 }
2487 break;
2488 }
2489 }
2490 break;
2491
2492 case UM_INITMENU:
2493 case WM_INITMENU:
2494 if (dcd) {
2495 switch (SHORT1FROMMP(mp1)) {
2496 case IDM_FILESMENU:
2497 if (dcd->info) {
2498 WinEnableMenuItem((HWND) mp2,
2499 IDM_DELETE, dcd->info->delete != NULL);
2500 WinEnableMenuItem((HWND) mp2, IDM_TEST, dcd->info->test != NULL);
2501 WinEnableMenuItem((HWND) mp2,
2502 IDM_EXTRACT, dcd->info->extract != NULL);
2503 WinEnableMenuItem((HWND) mp2,
2504 IDM_EXTRACTWDIRS, dcd->info->exwdirs != NULL);
2505 WinEnableMenuItem((HWND) mp2,
2506 IDM_ARCEXTRACTWDIRS, dcd->info->exwdirs != NULL);
2507 WinEnableMenuItem((HWND) mp2,
2508 IDM_ARCEXTRACTWDIRSEXIT,
2509 dcd->info->exwdirs != NULL);
2510 }
2511 break;
2512
2513 case IDM_VIEWSMENU:
2514 WinCheckMenuItem((HWND) mp2,
2515 IDM_MINIICONS, (dcd->flWindowAttr & CV_MINI) != 0);
2516 WinEnableMenuItem((HWND) mp2,
2517 IDM_RESELECT, (dcd->lastselection != NULL));
2518 break;
2519
2520 case IDM_COMMANDSMENU:
2521 SetupCommandMenu((HWND) mp2, hwnd);
2522 break;
2523
2524 case IDM_SORTSUBMENU:
2525 SetSortChecks((HWND) mp2, dcd->sortFlags);
2526 break;
2527
2528 case IDM_WINDOWSMENU:
2529 /*
2530 * add switchlist entries to end of pulldown menu
2531 */
2532 SetupWinList((HWND)mp2,
2533 hwndMain ? hwndMain : (HWND)0, dcd->hwndFrame);
2534 break;
2535 }
2536 dcd->hwndLastMenu = (HWND) mp2;
2537 }
2538 if (msg == WM_INITMENU)
2539 break;
2540 return 0;
2541
2542 case UM_LOADFILE:
2543 if (dcd && mp2) {
2544
2545 HWND hwnd;
2546
2547 if ((INT)mp1 == 5 || (INT)mp1 == 13 || (INT)mp1 == 21)
2548 hwnd = StartViewer(HWND_DESKTOP, (INT)mp1,
2549 (CHAR *)mp2, dcd->hwndFrame);
2550 else
2551 hwnd = StartMLEEditor(dcd->hwndParent,
2552 (INT)mp1, (CHAR *)mp2, dcd->hwndFrame);
2553 xfree((CHAR *)mp2, pszSrcFile, __LINE__);
2554 return MRFROMLONG(hwnd);
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.