source: trunk/dll/arccnrs.c@ 1078

Last change on this file since 1078 was 1078, checked in by Steven Levine, 17 years ago

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