source: trunk/dll/arccnrs.c@ 1104

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

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