source: trunk/dll/arccnrs.c@ 1073

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

Fm2 uses TMP/TEMP directory if set for temporary files and directories. Ticket 20
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 99.2 KB
Line 
1
2/***********************************************************************
3
4 $Id: arccnrs.c 1073 2008-07-18 00:30:20Z gyoung $
5
6 Archive containers
7
8 Copyright (c) 1993-98 M. Kimes
9 Copyright (c) 2001, 2008 Steven H. Levine
10
11 11 Jun 02 SHL Ensure archive name not garbage
12 22 May 03 SHL ArcObjWndProc: fix UM_RESCAN now that we understand it
13 01 Aug 04 SHL Rework lstrip/rstrip usage
14 23 May 05 SHL Use QWL_USER
15 25 May 05 SHL Rename comnam to szCommonName and fix typo
16 25 May 05 SHL Use ULONGLONG and CommaFmtULL
17 05 Jun 05 SHL Drop obsolete, localize
18 05 Jun 05 SHL Correct last sort logic
19 05 Jun 05 SHL Use QWL_USER
20 22 Jun 05 SHL ArcSort: correct typo in last sort fix
21 13 Aug 05 SHL FillArcCnr: optimize
22 08 Dec 05 SHL FillArcCnr: allow list start and end markers to be empty (i.e. tar)
23 08 Dec 05 SHL ArcCnrWndProc: suppress IDM_EXTRACT if no simple extract (i.e. tar)
24 30 Dec 05 SHL ArcCnrWndProc: correct date/time column display setup
25 29 May 06 SHL Comments
26 14 Jul 06 SHL Use Runtime_Error
27 26 Jul 06 SHL Correct SelectAll usage
28 29 Jul 06 SHL Use xfgets_bstripcr
29 31 Jul 06 SHL Lower priority for archives with more than 1000 entries
30 02 Aug 06 SHL Add logic to stop processing large archives
31 23 Aug 06 SHL Integrate John Small's switch list title logic
32 03 Nov 06 SHL Renames
33 14 Mar 07 SHL ArcObjWndProc/UM_ENTER: delay before starting viewer
34 30 Mar 07 GKY Remove GetPString for window class names
35 06 Apr 07 GKY Work around PM DragInfo and DrgFreeISH limit
36 06 Apr 07 GKY Add some error checking in drag/drop
37 20 Apr 07 SHL Sync with NumItemsToUnhilite mods
38 21 Apr 07 GKY Find FM2Utils by path or utils directory
39 12 May 07 SHL Use dcd->ulItemsToUnHilite; sync with UnHilite arg mods
40 10 Jun 07 GKY Add CheckPmDrgLimit including IsFm2Window as part of work around PM drag limit
41 16 Jun 07 SHL Use DosQueryAppType not DosQAppType
42 02 Aug 07 SHL Sync with ARCITEM mods
43 06 Aug 07 SHL Use BldFullPathName and BldQuotedFileName
44 06 Aug 07 SHL Move BldQuotedFileName and BldQuotedFullPathNamehere
45 to be near primary caller
46 06 Aug 07 GKY Reduce DosSleep times (ticket 148)
47 20 Aug 07 GKY Move #pragma alloc_text to end for OpenWatcom compat
48 26 Aug 07 GKY DosSleep(1) in loops changed to (0)
49 22 Nov 07 GKY Use CopyPresParams to fix presparam inconsistencies in menus
50 30 Dec 07 GKY Use TestCDates for sort by date
51 10 Jan 08 SHL Sync with CfgDlgProc mods
52 10 Feb 08 GKY Implement bubble help for bitmap menu items
53 15 Feb 08 SHL Sync with settings menu rework
54 29 Feb 08 GKY Use xfree where appropriate
55 14 Jul 08 JBS Ticket 126: Add support for WPS open default & open settings in arccnrs
56 16 Jul 08 GKY Fix trap on viewing multiple files from an archive (misplaced free)
57 16 JUL 08 GKY Use TMP directory for temp files if present.
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;
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 DM_PRINTOBJECT:
1233 case DM_DISCARDOBJECT:
1234 dcd = INSTDATA(hwnd);
1235 if (dcd) {
1236
1237 LISTINFO *li;
1238 CNRDRAGINFO cni;
1239
1240 cni.pRecord = NULL;
1241 cni.pDragInfo = (PDRAGINFO) mp1;
1242 li = DoFileDrop(dcd->hwndCnr,
1243 dcd->directory, FALSE, MPVOID, MPFROMP(&cni));
1244 CheckPmDrgLimit(cni.pDragInfo);
1245 if (li) {
1246 li->type = (msg == DM_DISCARDOBJECT) ? IDM_DELETE : IDM_PRINT;
1247 if (!li->list ||
1248 !li->list[0] || !PostMsg(hwnd, UM_ACTION, MPFROMP(li), MPVOID))
1249 FreeListInfo(li);
1250 else
1251 return MRFROMLONG(DRR_SOURCE);
1252 }
1253 }
1254 return MRFROMLONG(DRR_TARGET);
1255
1256 case DM_RENDERPREPARE:
1257 return (MRESULT) TRUE;
1258
1259 case DM_RENDER:
1260 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
1261 if (dcd && dcd->info && dcd->info->extract && dcd->arcname) {
1262
1263 PDRAGTRANSFER pdt = (PDRAGTRANSFER) mp1;
1264 CHAR filename[CCHMAXPATH];
1265 ULONG len;
1266
1267 if (pdt->hwndClient && pdt->pditem && pdt->hstrSelectedRMF &&
1268 pdt->hstrRenderToName) {
1269 if (pdt->usOperation == DO_COPY || pdt->usOperation == DO_MOVE) {
1270 *filename = 0;
1271 len = DrgQueryStrName(pdt->hstrSelectedRMF, CCHMAXPATH, filename);
1272 filename[len] = 0;
1273 if (!strnicmp(filename, "OS2FILE,", 8)) {
1274 // saymsg(MB_ENTER,HWND_DESKTOP,DEBUG_STRING,"RMF = \"%s\"",filename);
1275 }
1276 else {
1277 *filename = 0;
1278 len =
1279 DrgQueryStrName(pdt->hstrRenderToName, CCHMAXPATH, filename);
1280 filename[len] = 0;
1281 if (len && *filename) {
1282 psz = xstrdup(filename, pszSrcFile, __LINE__);
1283 if (psz) {
1284 PostMsg(hwnd, UM_RENDER, MPFROMP(pdt), MPFROMP(psz));
1285 return (MRESULT) TRUE;
1286 }
1287 }
1288 else {
1289 // saymsg(MB_ENTER,HWND_DESKTOP,DEBUG_STRING,"No render-to name given.");
1290 }
1291 }
1292 }
1293 pdt->fsReply = DMFL_RENDERRETRY;
1294 }
1295 }
1296 return (MRESULT) FALSE;
1297
1298 case UM_RENDER:
1299 {
1300 PDRAGTRANSFER pdt = (PDRAGTRANSFER) mp1;
1301 USHORT usRes = DMFL_RENDERFAIL;
1302
1303 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
1304 if (dcd && dcd->info && dcd->info->extract && dcd->arcname) {
1305
1306 CHAR *filename = (CHAR *) mp2, *p;
1307 ULONG len;
1308 CHAR membername[CCHMAXPATH], construct[CCHMAXPATH * 2];
1309
1310 *membername = 0;
1311 len = DrgQueryStrName(pdt->pditem->hstrSourceName,
1312 CCHMAXPATH, membername);
1313 membername[len] = 0;
1314 if (*membername && len && filename) {
1315 unlinkf("%s", filename);
1316 strcpy(construct, filename);
1317 p = strrchr(filename, '\\');
1318 if (!p)
1319 *construct = 0;
1320 else {
1321 if (p == filename || *(p - 1) == ':')
1322 p++;
1323 *p = 0;
1324 }
1325 // saymsg(MB_ENTER,HWND_DESKTOP,DEBUG_STRING,"%s %s %s\r[%s]",dcd->info->extract,dcd->arcname,membername,construct);
1326 runemf2(SEPARATE | WINDOWED | WAIT |
1327 (fArcStuffVisible ? 0 : BACKGROUND | MINIMIZED),
1328 dcd->hwndClient, pszSrcFile, __LINE__, construct, NULL,
1329 "%s %s %s",
1330 dcd->info->extract,
1331 BldQuotedFileName(szQuotedArcName, dcd->arcname),
1332 BldQuotedFileName(szQuotedMemberName, membername));
1333 BldFullPathName(construct, construct, membername);
1334 if (IsFile(construct) != -1) {
1335 rename(construct, filename);
1336 unlinkf("%s", construct);
1337 if (IsFile(filename) != -1)
1338 usRes = DMFL_RENDEROK;
1339 }
1340 }
1341 }
1342 xfree((CHAR *)mp2, pszSrcFile, __LINE__);
1343 PostMsg(pdt->hwndClient, DM_RENDERCOMPLETE, MPFROMP(pdt),
1344 MPFROM2SHORT(usRes, 0));
1345 }
1346 return 0;
1347
1348 case UM_SETUP:
1349 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
1350 if (!dcd) {
1351 Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
1352 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
1353 }
1354 else {
1355 /* set unique id */
1356 WinSetWindowUShort(hwnd, QWS_ID, ARCOBJ_FRAME + (ARC_FRAME - dcd->id));
1357 dcd->hwndObject = hwnd; // pass back hwnd
1358 if (ParentIsDesktop(hwnd, dcd->hwndParent))
1359 DosSleep(100); //05 Aug 07 GKY 250 // Avoid race?
1360 }
1361 return 0;
1362
1363 case UM_RESCAN:
1364 /*
1365 * populate container
1366 */
1367 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
1368 if (dcd) {
1369 if (mp1)
1370 strcpy(dcd->arcname, (CHAR *) mp1); // Update name on request
1371 dcd->ullTotalBytes = dcd->totalfiles =
1372 dcd->selectedfiles = dcd->selectedbytes = 0;
1373 WinSetDlgItemText(dcd->hwndClient, DIR_TOTALS, "0");
1374 WinSetDlgItemText(dcd->hwndClient, DIR_SELECTED, "0 / 0k");
1375 dcd->totalfiles = FillArcCnr(dcd->hwndCnr,
1376 dcd->arcname,
1377 &dcd->info,
1378 &dcd->ullTotalBytes, &dcd->stopflag);
1379 if (!dcd->totalfiles)
1380 PostMsg(dcd->hwndCnr, WM_CLOSE, MPVOID, MPVOID);
1381 else {
1382 dcd->arcfilled = TRUE;
1383 if (!PostMsg(dcd->hwndCnr, UM_RESCAN, MPVOID, MPVOID))
1384 WinSendMsg(dcd->hwndCnr, UM_RESCAN, MPVOID, MPVOID);
1385 PostMsg(dcd->hwndCnr, UM_SETUP2, MPVOID, MPVOID);
1386 WinSendMsg(dcd->hwndCnr,
1387 CM_INVALIDATERECORD,
1388 MPVOID, MPFROM2SHORT(0, CMA_ERASE | CMA_REPOSITION));
1389 }
1390 }
1391 return 0;
1392
1393 case UM_SELECT:
1394 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
1395 if (dcd) {
1396 switch (SHORT1FROMMP(mp1)) {
1397 case IDM_SELECTALL:
1398 case IDM_SELECTALLFILES:
1399 SelectAll(dcd->hwndCnr, TRUE, TRUE, NULL, NULL, TRUE);
1400 break;
1401 case IDM_DESELECTALL:
1402 case IDM_DESELECTALLFILES:
1403 DeselectAll(dcd->hwndCnr, TRUE, TRUE, NULL, NULL, TRUE);
1404 break;
1405 case IDM_DESELECTMASK:
1406 case IDM_SELECTMASK:
1407 {
1408 MASK mask;
1409 PARCITEM pci = (PARCITEM) mp2;
1410
1411 memset(&mask, 0, sizeof(MASK));
1412 mask.fNoAttribs = TRUE;
1413 mask.fNoDirs = TRUE;
1414 strcpy(mask.prompt,
1415 GetPString((SHORT1FROMMP(mp1) == IDM_SELECTMASK) ?
1416 IDS_SELECTFILTERTEXT : IDS_DESELECTFILTERTEXT));
1417 if (pci && (INT) pci != -1)
1418 strcpy(mask.szMask, pci->pszFileName);
1419 if (WinDlgBox(HWND_DESKTOP, dcd->hwndCnr, PickMaskDlgProc,
1420 FM3ModHandle, MSK_FRAME, MPFROMP(&mask))) {
1421 if (SHORT1FROMMP(mp1) == IDM_SELECTMASK)
1422 SelectAll(dcd->hwndCnr, TRUE, TRUE, mask.szMask, NULL, FALSE);
1423 else
1424 DeselectAll(dcd->hwndCnr, TRUE, TRUE, mask.szMask, NULL, FALSE);
1425 }
1426 }
1427
1428 case IDM_INVERT:
1429 InvertAll(dcd->hwndCnr);
1430 break;
1431 }
1432 }
1433 return 0;
1434
1435 case UM_ENTER:
1436 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
1437 if (dcd) {
1438
1439 CHAR *s = (CHAR *) mp1, *p, *pp, filename[CCHMAXPATH];
1440
1441 if (s) {
1442 if (!dcd->info->extract) {
1443 Runtime_Error(pszSrcFile, __LINE__, "no extract");
1444 free(s);
1445 return 0;
1446 }
1447 runemf2(SEPARATE | WINDOWED | WAIT |
1448 (fArcStuffVisible ? 0 : BACKGROUND | MINIMIZED),
1449 dcd->hwndClient, pszSrcFile, __LINE__, dcd->workdir, NULL,
1450 "%s %s %s",
1451 dcd->info->exwdirs ? dcd->info->exwdirs :
1452 dcd->info->extract,
1453 BldQuotedFileName(szQuotedArcName, dcd->arcname),
1454 BldQuotedFileName(szQuotedMemberName, s));
1455 if (!dcd->info->exwdirs) {
1456 p = s;
1457 p = strrchr(s, '\\');
1458 pp = strrchr(s, '/');
1459 if (p && pp)
1460 p = max(p, pp);
1461 else if (!p)
1462 p = pp;
1463 if (p)
1464 memmove(s, p + 1, strlen(p + 1));
1465 }
1466 sprintf(filename, "%s\\%s", dcd->workdir, s);
1467 p = filename;
1468 while (*p) {
1469 if (*p == '/')
1470 *p = '\\';
1471 p++;
1472 }
1473 // printf("%s %d UM_ENTER %s %s\n",__FILE__, __LINE__,filename, s); fflush(stdout); // 10 Mar 07 SHL hang
1474 free(s);
1475 if (IsFile(filename) == 1) {
1476#if 0 // 06 Oct 07 SHL fixme to be gone - set to 0 for ticket #58 testing
1477 if (fViewChild && fArcStuffVisible)
1478 DosSleep(100); // Allow unzip session to finish closing 14 Mar 07 SHL
1479#endif
1480 WinSendMsg(dcd->hwndCnr, UM_ENTER, MPFROMP(filename), MPVOID);
1481 }
1482 }
1483 }
1484 return 0;
1485
1486 case UM_COMMAND:
1487 if (mp1) {
1488 if (PostMsg(hwnd, UM_ACTION, mp1, mp2))
1489 return (MRESULT) TRUE;
1490 }
1491 return 0;
1492
1493 case UM_ACTION:
1494 DosError(FERR_DISABLEHARDERR);
1495 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
1496 if (dcd) {
1497
1498 LISTINFO *li = (LISTINFO *) mp1;
1499 register INT x;
1500
1501 if (li && li->list && li->list[0]) {
1502 printf("%x/r", li->type); fflush(stdout);
1503 switch (li->type) {
1504 case IDM_ARCHIVE:
1505 case IDM_ARCHIVEM:
1506 {
1507 DIRCNRDATA ad;
1508 CHAR szBuffer[1025], *p;
1509
1510 if (!li->list[1] && !stricmp(li->list[0], dcd->arcname)) {
1511 Runtime_Error(pszSrcFile, __LINE__, "arc to self");
1512 break;
1513 }
1514 ad = *dcd;
1515 ad.namecanchange = 0;
1516 ad.fmoving = (li->type == IDM_ARCHIVEM);
1517 if (!WinDlgBox(HWND_DESKTOP, dcd->hwndClient, ArchiveDlgProc, FM3ModHandle, ARCH_FRAME, (PVOID) & ad) || !*ad.arcname || !*ad.command) /* we blew it */
1518 break;
1519 /* build the sucker */
1520 strcpy(szBuffer, ad.command);
1521 strcat(szBuffer, " ");
1522
1523 BldQuotedFileName(szBuffer + strlen(szBuffer), ad.arcname);
1524
1525 p = &szBuffer[strlen(szBuffer)]; // Remeber where archiver name ends
1526
1527 if (ad.mask.szMask) {
1528 strcat(szBuffer, " ");
1529
1530 BldQuotedFileName(szBuffer + strlen(szBuffer), ad.mask.szMask);
1531 }
1532 strcat(szBuffer, " ");
1533 x = 0;
1534
1535 // Run commands avoiding command line overflow
1536 while (li->list[x]) {
1537
1538 if (IsFile(li->list[x]))
1539 BldQuotedFileName(szBuffer + strlen(szBuffer), li->list[x]);
1540 else
1541 BldQuotedFullPathName(szBuffer + strlen(szBuffer), li->list[x], "*");
1542
1543 x++;
1544 if (!li->list[x] || strlen(szBuffer) +
1545 strlen(li->list[x]) + 5 > MaxComLineStrg) {
1546 runemf2(SEPARATE | WINDOWED |
1547 (fArcStuffVisible ? 0 : BACKGROUND | MINIMIZED) |
1548 WAIT, hwnd, pszSrcFile, __LINE__,
1549 NULL, NULL, "%s", szBuffer);
1550 *p = 0;
1551 }
1552 strcat(szBuffer, " ");
1553 } // while
1554
1555 PostMsg(dcd->hwndCnr, UM_RESCAN, MPFROMSHORT(1), MPVOID);
1556 Broadcast(WinQueryAnchorBlock(hwnd),
1557 hwndMain, UM_UPDATERECORD, MPFROMP(ad.arcname), MPVOID);
1558 Broadcast(WinQueryAnchorBlock(hwnd),
1559 hwndMain,
1560 UM_UPDATERECORDLIST, MPFROMP(li->list), MPVOID);
1561 }
1562 break;
1563
1564 case IDM_REFRESH:
1565 case IDM_DELETE:
1566 {
1567 CHAR *endofit;
1568 PSZ pszCmdLine;
1569 INT z;
1570 CHECKLIST ck;
1571 CHAR prompt[CCHMAXPATH + 257];
1572
1573 if (!dcd->info->delete)
1574 break;
1575 memset(&ck, 0, sizeof(ck));
1576 ck.size = sizeof(ck);
1577 ck.list = li->list;
1578 ck.cmd = li->type;
1579 ck.prompt = prompt;
1580 sprintf(prompt, GetPString(IDS_ARCCNRDELREFTEXT),
1581 (li->type == IDM_DELETE) ?
1582 GetPString(IDS_DELETELOWERTEXT) :
1583 GetPString(IDS_REFRESHLOWERTEXT),
1584 &"s"[li->list[1] == NULL],
1585 dcd->arcname,
1586 (li->type == IDM_DELETE) ?
1587 GetPString(IDS_DELETELOWERTEXT) :
1588 GetPString(IDS_REFRESHLOWERTEXT));
1589 if (!WinDlgBox(HWND_DESKTOP, hwnd, CheckListProc,
1590 FM3ModHandle, CHECK_FRAME, MPFROMP(&ck)))
1591 break;
1592 li->list = ck.list;
1593 if (!li->list || !li->list[0])
1594 break;
1595 pszCmdLine = xmallocz(MaxComLineStrg, pszSrcFile, __LINE__);
1596 if (!pszCmdLine)
1597 break;
1598 strcpy(pszCmdLine, li->type == IDM_DELETE ?
1599 dcd->info->delete :
1600 dcd->info->create);
1601 strcat(pszCmdLine, " ");
1602 BldQuotedFileName(pszCmdLine + strlen(pszCmdLine), dcd->arcname);
1603 endofit = &pszCmdLine[strlen(pszCmdLine)];
1604 z = 0;
1605 do {
1606 for (x = z; li->list[x] &&
1607 strlen(pszCmdLine) + strlen(li->list[x]) < 999; x++) {
1608 strcat(pszCmdLine, " ");
1609 BldQuotedFileName(pszCmdLine + strlen(pszCmdLine), li->list[x]);
1610 }
1611 z = x;
1612 runemf2(SEPARATE | WINDOWED | WAIT |
1613 (fArcStuffVisible ? 0 : BACKGROUND | MINIMIZED),
1614 hwnd, pszSrcFile, __LINE__, NullStr, NULL, "%s", pszCmdLine);
1615 *endofit = 0;
1616 free(pszCmdLine);
1617 } while (li->list[x]);
1618 PostMsg(dcd->hwndCnr, UM_RESCAN, MPFROMSHORT(1), MPVOID);
1619 Broadcast(WinQueryAnchorBlock(hwnd),
1620 hwndMain,
1621 UM_UPDATERECORD, MPFROMP(dcd->arcname), MPVOID);
1622 }
1623 break;
1624
1625 case IDM_PRINT:
1626 case IDM_VIRUSSCAN:
1627 case IDM_VIEW:
1628 case IDM_MCIPLAY:
1629 case IDM_VIEWARCHIVE:
1630 case IDM_VIEWTEXT:
1631 case IDM_VIEWBINARY:
1632 case IDM_EDIT:
1633 case IDM_EDITTEXT:
1634 case IDM_EDITBINARY:
1635 case IDM_EXEC:
1636 case IDM_EXTRACTWDIRS:
1637 case IDM_EXTRACT:
1638 case IDM_OPENDEFAULT:
1639 case IDM_OPENSETTINGS:
1640 {
1641 CHAR *endofit, *ptr;
1642 PSZ pszCmdLine;
1643 INT z;
1644 if ((li->type == IDM_EXTRACT && !li->info->extract) ||
1645 ((li->type == IDM_VIEW || li->type == IDM_VIEWTEXT ||
1646 li->type == IDM_VIEWBINARY || li->type == IDM_EDIT ||
1647 li->type == IDM_VIEWARCHIVE || li->type == IDM_EDITTEXT ||
1648 li->type == IDM_EDITBINARY || li->type == IDM_MCIPLAY) &&
1649 (!li->info->extract && !li->info->exwdirs)) ||
1650 (li->type != IDM_EXTRACT && li->type != IDM_EDIT &&
1651 li->type != IDM_VIEW && li->type != IDM_VIEWTEXT &&
1652 li->type != IDM_VIEWBINARY &&
1653 li->type != IDM_VIEWARCHIVE &&
1654 li->type != IDM_EDITTEXT &&
1655 li->type != IDM_EDITBINARY &&
1656 li->type != IDM_MCIPLAY && !li->info->exwdirs)) {
1657 Runtime_Error(pszSrcFile, __LINE__, "no cmd for request");
1658 break;
1659 }
1660 if (li->type == IDM_EXTRACT || li->type == IDM_EXTRACTWDIRS) {
1661
1662 CHAR fullname[CCHMAXPATH * 2];
1663 CHAR **exfiles = NULL;
1664 UINT numfiles = 0, numalloc = 0;
1665
1666 for (x = 0; li->list[x]; x++) {
1667 BldFullPathName(fullname, li->targetpath, li->list[x]);
1668 if (IsFile(fullname) != -1) {
1669 AddToList(li->list[x], &exfiles, &numfiles, &numalloc);
1670 li->list = RemoveFromList(li->list, li->list[x]);
1671 if (!li->list)
1672 break;
1673 x--;
1674 }
1675 }
1676 if (exfiles && numfiles) {
1677
1678 CHECKLIST ckl;
1679 CHAR prompt[(CCHMAXPATH * 2) + 256];
1680
1681 memset(&ckl, 0, sizeof(ckl));
1682 ckl.size = sizeof(ckl);
1683 ckl.list = exfiles;
1684 ckl.prompt = prompt;
1685 ckl.cmd = li->type;
1686 sprintf(prompt,
1687 GetPString(IDS_REPLACEWARNTEXT),
1688 &"s"[numfiles == 1],
1689 li->arcname, &"s"[numfiles != 1], li->targetpath);
1690 if (!WinDlgBox(HWND_DESKTOP, hwnd, CheckListProc,
1691 FM3ModHandle, CHECK_FRAME, MPFROMP(&ckl))) {
1692 if (ckl.list)
1693 FreeList(ckl.list);
1694 break;
1695 }
1696 else if (ckl.list)
1697 li->list = CombineLists(li->list, ckl.list);
1698 }
1699 }
1700 if (!li->list || !li->list[0])
1701 break;
1702 pszCmdLine = xmallocz(MaxComLineStrg, pszSrcFile, __LINE__);
1703 if (!pszCmdLine)
1704 break;
1705 strcpy(pszCmdLine,
1706 (li->type == IDM_EXTRACT ||
1707 ((li->type == IDM_VIEW ||
1708 li->type == IDM_VIEWTEXT ||
1709 li->type == IDM_VIEWBINARY ||
1710 li->type == IDM_VIEWARCHIVE ||
1711 li->type == IDM_PRINT ||
1712 li->type == IDM_EDIT ||
1713 li->type == IDM_EDITTEXT ||
1714 li->type == IDM_OPENDEFAULT ||
1715 li->type == IDM_OPENSETTINGS ||
1716 (li->type == IDM_EDITBINARY && // JBS No way for this () to be true??
1717 li->type == IDM_MCIPLAY)) &&
1718 !li->info->exwdirs)) ?
1719 li->info->extract :
1720 li->info->exwdirs);
1721 strcat(pszCmdLine, " ");
1722 BldQuotedFileName(pszCmdLine + strlen(pszCmdLine), li->arcname);
1723 endofit = &pszCmdLine[strlen(pszCmdLine)];
1724 z = 0;
1725 do {
1726 for (x = z; li->list[x] &&
1727 strlen(pszCmdLine) + strlen(li->list[x]) < MaxComLineStrg - 1 ; x++) {
1728 strcat(pszCmdLine, " ");
1729 BldQuotedFileName(pszCmdLine + strlen(pszCmdLine), li->list[x]);
1730 ptr = li->list[x];
1731 while (*ptr) {
1732 if (*ptr == '/')
1733 *ptr = '\\';
1734 ptr++;
1735 }
1736 }
1737 z = x;
1738 runemf2(SEPARATE | WINDOWED |
1739 (fArcStuffVisible ? 0 : BACKGROUND | MINIMIZED) |
1740 WAIT, hwnd, pszSrcFile, __LINE__,
1741 li->targetpath, NULL, "%s", pszCmdLine);
1742 *endofit = 0;
1743 } while (li->list[x]);
1744 if (li->type == IDM_EXTRACT || li->type == IDM_EXTRACTWDIRS) {
1745 /* update windows */
1746 for (x = 0; li->list[x]; x++) {
1747
1748 CHAR *temp, *p;
1749
1750 temp = li->list[x];
1751 p = temp;
1752 while (*p) {
1753 if (*p == '/')
1754 *p = '\\';
1755 p++;
1756 }
1757 p = xmalloc(strlen(temp) + strlen(li->targetpath) + 2,
1758 pszSrcFile, __LINE__);
1759 if (p) {
1760 BldFullPathName(p, li->targetpath, temp);
1761 /*strcpy(p, li->targetpath);
1762 if (p[strlen(p) - 1] != '\\')
1763 strcat(p, "\\");
1764 strcat(p, temp);*/
1765 li->list[x] = p;
1766 free(temp);
1767 }
1768 }
1769 if (fFolderAfterExtract) {
1770
1771 CHAR objectpath[CCHMAXPATH], *p;
1772 APIRET rc;
1773
1774 GetDesktopName(objectpath, sizeof(objectpath));
1775 rc = WinDlgBox(HWND_DESKTOP, dcd->hwndParent, ObjCnrDlgProc,
1776 FM3ModHandle, OBJCNR_FRAME,
1777 MPFROMP(objectpath));
1778 if (rc) {
1779 if (rc > 1)
1780 strcpy(objectpath, "<WP_DESKTOP>");
1781 p = NULL;
1782 if (li->arcname) {
1783 p = strrchr(li->arcname, '\\');
1784 if (p)
1785 p++;
1786 }
1787 MakeShadows(dcd->hwndParent, li->list, 2, objectpath, p);
1788 }
1789 }
1790 Broadcast(WinQueryAnchorBlock(hwnd),
1791 hwndMain,
1792 UM_UPDATERECORDLIST, MPFROMP(li->list), MPVOID);
1793 }
1794 else if (li->type == IDM_EXEC)
1795 ExecOnList(hwnd,
1796 li->runfile,
1797 WINDOWED | SEPARATEKEEP | PROMPT,
1798 li->targetpath,
1799 NULL, GetPString(IDS_EXECARCFILETITLETEXT),
1800 pszSrcFile, __LINE__);
1801 else if (li->type == IDM_VIRUSSCAN)
1802 ExecOnList(hwnd, virus, PROMPT | WINDOWED | SEPARATEKEEP,
1803 li->targetpath, NULL,
1804 GetPString(IDS_VIRUSSCANARCHIVETITLETEXT),
1805 pszSrcFile, __LINE__);
1806 else if (li->type == IDM_VIEW || li->type == IDM_VIEWTEXT ||
1807 li->type == IDM_VIEWBINARY || li->type == IDM_EDIT ||
1808 li->type == IDM_EDITTEXT ||
1809 li->type == IDM_VIEWARCHIVE ||
1810 li->type == IDM_EDITBINARY ||
1811 li->type == IDM_OPENDEFAULT ||
1812 li->type == IDM_OPENSETTINGS ||
1813 li->type == IDM_MCIPLAY || li->type == IDM_PRINT) {
1814
1815 CHAR *temp, *p;
1816 for (x = 0; li->list[x]; x++) {
1817 if (!li->info->exwdirs) {
1818 temp = li->list[x];
1819 p = strrchr(li->list[x], '\\');
1820 if (p) {
1821 p++;
1822 li->list[x] = xstrdup(p, pszSrcFile, __LINE__);
1823 if (!li->list[x])
1824 li->list[x] = temp;
1825 else {
1826 xfree(temp, pszSrcFile, __LINE__);
1827 }
1828 }
1829 }
1830 BldFullPathName(pszCmdLine, li->targetpath, li->list[x]);
1831 temp = li->list[x];
1832 li->list[x] = xstrdup(pszCmdLine, pszSrcFile, __LINE__);
1833 if (!li->list[x])
1834 li->list[x] = temp;
1835 else
1836 xfree(temp, pszSrcFile, __LINE__);
1837 }
1838 free(pszCmdLine);
1839 if (li->type == IDM_VIEW || li->type == IDM_EDIT) {
1840
1841 BOOL isit = TestBinary(li->list[0]);
1842
1843 if (isit) {
1844 if (li->type == IDM_VIEW)
1845 li->type = IDM_VIEWBINARY;
1846 else
1847 li->type = IDM_EDITBINARY;
1848 }
1849 else {
1850 if (li->type == IDM_VIEW)
1851 li->type = IDM_VIEWTEXT;
1852 else
1853 li->type = IDM_EDITTEXT;
1854 }
1855 }
1856 if (li->type == IDM_MCIPLAY) {
1857
1858 FILE *fp;
1859 CHAR szTempFile[CCHMAXPATH];
1860
1861 if (fUseTmp)
1862 BldFullPathName(szTempFile, pTmpDir, "$FM2PLAY.$$$");
1863 else
1864 strcpy(szTempFile, "$FM2PLAY.$$$");
1865
1866 fp = xfopen(szTempFile, "w", pszSrcFile, __LINE__);
1867 if (fp) {
1868 fprintf(fp, "%s", ";AV/2-built FM2Play listfile\n");
1869 for (x = 0; li->list[x]; x++)
1870 fprintf(fp, "%s\n", li->list[x]);
1871 fprintf(fp, ";end\n");
1872 fclose(fp);
1873 strrev(szTempFile);
1874 strcat(szTempFile, "@/");
1875 strrev(szTempFile);
1876 RunFM2Util("FM2PLAY.EXE", szTempFile);
1877 }
1878 }
1879 else if (li->type == IDM_PRINT) {
1880 strcpy(li->targetpath, printer);
1881 if (_beginthread(PrintListThread, NULL, 65536, (PVOID) li) !=
1882 -1) {
1883 Runtime_Error(pszSrcFile, __LINE__,
1884 GetPString(IDS_COULDNTSTARTTHREADTEXT));
1885 li = NULL;
1886 }
1887 }
1888 else if (li->type == IDM_VIEWARCHIVE) {
1889
1890 ARC_TYPE *info;
1891
1892 for (x = 0; li->list[x]; x++) {
1893 if (IsFile(li->list[x]) == 1) {
1894 info = NULL; // Do not hide dups - fixme to know why?
1895 if (WinDlgBox(HWND_DESKTOP, HWND_DESKTOP,
1896 SBoxDlgProc, FM3ModHandle, ASEL_FRAME,
1897 (PVOID) & info) && info) {
1898 StartArcCnr(HWND_DESKTOP,
1899 HWND_DESKTOP, li->list[x], 4, info);
1900 }
1901 }
1902 }
1903 }
1904 else if ((li->type == IDM_VIEWTEXT && *viewer) ||
1905 (li->type == IDM_VIEWBINARY && *binview) ||
1906 (li->type == IDM_EDITTEXT && *editor) ||
1907 (li->type == IDM_EDITBINARY && *bined)) {
1908 DosSleep(32); //05 Aug 07 GKY 100
1909 ExecOnList(hwnd, ((li->type == IDM_VIEWTEXT) ? viewer :
1910 (li->type == IDM_VIEWBINARY) ? binview :
1911 (li->type == IDM_EDITTEXT) ? editor :
1912 bined),
1913 WINDOWED | SEPARATE, li->targetpath, li->list,
1914 NULL, pszSrcFile, __LINE__);
1915 }
1916 else if (li->type == IDM_OPENDEFAULT ||
1917 li->type == IDM_OPENSETTINGS) {
1918 WORKER *wk;
1919# ifdef FORTIFY
1920 Fortify_EnterScope();
1921# endif
1922 wk = xmallocz(sizeof(WORKER), pszSrcFile, __LINE__);
1923 if (!wk)
1924 FreeListInfo(li);
1925 else {
1926 wk->size = sizeof(WORKER);
1927 wk->hwndCnr = dcd->hwndCnr;
1928 wk->hwndParent = dcd->hwndParent;
1929 wk->hwndFrame = dcd->hwndFrame;
1930 wk->hwndClient = dcd->hwndClient;
1931 wk->li = li;
1932 strcpy(wk->directory, dcd->directory);
1933 if (_beginthread(Action, NULL, 122880, (PVOID) wk) == -1) {
1934 Runtime_Error(pszSrcFile, __LINE__,
1935 GetPString(IDS_COULDNTSTARTTHREADTEXT));
1936 free(wk);
1937 FreeListInfo((LISTINFO *) mp1);
1938# ifdef FORTIFY
1939 Fortify_LeaveScope();
1940# endif
1941 }
1942 }
1943
1944 }
1945 else {
1946 if (li->hwnd) {
1947
1948 ULONG viewtype;
1949
1950 for (x = 0; li->list[x]; x++) {
1951 if (x == 0) {
1952 if (li->type == IDM_VIEWBINARY ||
1953 li->type == IDM_EDITBINARY)
1954 viewtype = 16;
1955 else
1956 viewtype = 8;
1957 }
1958 else
1959 viewtype = 0;
1960 temp = xstrdup(li->list[x], pszSrcFile, __LINE__);
1961 if (temp) {
1962 if (!PostMsg(WinQueryWindow(li->hwnd, QW_PARENT),
1963 UM_LOADFILE,
1964 MPFROMLONG(4L +
1965 (li->type == IDM_VIEWTEXT ||
1966 li->type == IDM_VIEWBINARY) +
1967 viewtype), MPFROMP(temp)))
1968 free(temp);
1969 }
1970 }
1971 }
1972 }
1973 }
1974 }
1975 break;
1976
1977 case IDM_FIND:
1978 {
1979 UINT numfiles = 0, numalloced = 0;
1980 CHAR **list2 = NULL, fullname[CCHMAXPATH * 2], *p;
1981
1982 for (x = 0; li->list[x]; x++) {
1983 p = li->list[x];
1984 while (*p) {
1985 if (*p == '/')
1986 *p = '\\';
1987 p++;
1988 }
1989 BldFullPathName(fullname, dcd->directory, li->list[x]);
1990 if (IsFile(fullname) != -1)
1991 if (AddToList(fullname, &list2, &numfiles, &numalloced))
1992 break;
1993 if (strchr(li->list[x], '\\')) {
1994 p = strrchr(li->list[x], '\\');
1995 if (p) {
1996 p++;
1997 if (*p) {
1998 BldFullPathName(fullname, dcd->directory, p);
1999 if (IsFile(fullname) != -1)
2000 if (AddToList(fullname, &list2, &numfiles, &numalloced))
2001 break;
2002 }
2003 }
2004 }
2005 }
2006 if (!numfiles || !list2)
2007 Runtime_Error(pszSrcFile, __LINE__, "no files or list");
2008 else {
2009 WinSendMsg(dcd->hwndCnr, WM_COMMAND,
2010 MPFROM2SHORT(IDM_COLLECTOR, 0), MPVOID);
2011 DosSleep(10); //05 Aug 07 GKY 128
2012 if (Collector) {
2013 if (!PostMsg(Collector, WM_COMMAND,
2014 MPFROM2SHORT(IDM_COLLECTOR, 0), MPFROMP(list2)))
2015 FreeList(list2);
2016 }
2017 else
2018 FreeList(list2);
2019 }
2020 }
2021 break;
2022 }
2023 }
2024 if (li->type != IDM_OPENDEFAULT && li->type != IDM_OPENSETTINGS)
2025 {
2026 FreeListInfo(li);
2027 }
2028 }
2029 return 0;
2030
2031 case WM_CLOSE:
2032 WinDestroyWindow(hwnd);
2033 break;
2034
2035 case WM_DESTROY:
2036 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
2037 if (dcd) {
2038 if (*dcd->workdir) {
2039 DosSleep(16); //05 Aug 07 GKY 33
2040 wipeallf("%s\\*", dcd->workdir);
2041 if (rmdir(dcd->workdir)) {
2042 DosSleep(100); //05 Aug 07 GKY 256
2043 wipeallf("%s\\*", dcd->workdir);
2044 rmdir(dcd->workdir);
2045 }
2046 }
2047 FreeList(dcd->lastselection);
2048 WinSendMsg(dcd->hwndCnr, UM_CLOSE, MPVOID, MPVOID);
2049 free(dcd);
2050# ifdef FORTIFY
2051 //Fortify_LeaveScope();
2052# endif
2053 WinSetWindowPtr(dcd->hwndCnr, QWL_USER, NULL);
2054 }
2055 if (!PostMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID))
2056 WinSendMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID);
2057 break;
2058 } // switch
2059 return WinDefWindowProc(hwnd, msg, mp1, mp2);
2060}
2061
2062static MRESULT EXPENTRY ArcCnrWndProc(HWND hwnd, ULONG msg, MPARAM mp1,
2063 MPARAM mp2)
2064{
2065 DIRCNRDATA *dcd = INSTDATA(hwnd);
2066 CHAR szQuotedArcName[CCHMAXPATH];
2067
2068 switch (msg) {
2069 case DM_PRINTOBJECT:
2070 case DM_DISCARDOBJECT:
2071 if (dcd)
2072 return WinSendMsg(dcd->hwndObject, msg, mp1, mp2);
2073 else
2074 return MRFROMLONG(DRR_TARGET);
2075
2076 case WM_CHAR:
2077 shiftstate = (SHORT1FROMMP(mp1) & (KC_SHIFT | KC_ALT | KC_CTRL));
2078 if (SHORT1FROMMP(mp1) & KC_KEYUP)
2079 return (MRESULT) TRUE;
2080 if (SHORT1FROMMP(mp1) & KC_VIRTUALKEY) {
2081 switch (SHORT2FROMMP(mp2)) {
2082 case VK_DELETE:
2083 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_DELETE, 0), MPVOID);
2084 break;
2085 }
2086 }
2087 if (shiftstate || fNoSearch)
2088 break;
2089 if (SHORT1FROMMP(mp1) & KC_CHAR) {
2090
2091 ULONG thistime, len;
2092 SEARCHSTRING srch;
2093 PCNRITEM pci;
2094
2095 if (!dcd)
2096 break;
2097 switch (SHORT1FROMMP(mp2)) {
2098 case '\x1b':
2099 case '\r':
2100 case '\n':
2101 dcd->lasttime = 0;
2102 *dcd->szCommonName = 0;
2103 break;
2104 default:
2105 thistime = WinQueryMsgTime(WinQueryAnchorBlock(hwnd));
2106 if (thistime > dcd->lasttime + 1250)
2107 *dcd->szCommonName = 0;
2108 dcd->lasttime = thistime;
2109 if (SHORT1FROMMP(mp2) == ' ' && !*dcd->szCommonName)
2110 break;
2111 KbdRetry:
2112 len = strlen(dcd->szCommonName);
2113 if (len >= CCHMAXPATH - 1) {
2114 *dcd->szCommonName = 0;
2115 len = 0;
2116 }
2117 dcd->szCommonName[len] = toupper(SHORT1FROMMP(mp2));
2118 dcd->szCommonName[len + 1] = 0;
2119 memset(&srch, 0, sizeof(SEARCHSTRING));
2120 srch.cb = (ULONG) sizeof(SEARCHSTRING);
2121 srch.pszSearch = dcd->szCommonName;
2122 srch.fsPrefix = TRUE;
2123 srch.fsCaseSensitive = FALSE;
2124 srch.usView = CV_ICON;
2125 pci = WinSendMsg(hwnd,
2126 CM_SEARCHSTRING,
2127 MPFROMP(&srch), MPFROMLONG(CMA_FIRST));
2128 if (pci && (INT) pci != -1) {
2129
2130 USHORT attrib = CRA_CURSORED;
2131
2132 /* make found item current item */
2133 if (!stricmp(pci->pszFileName, dcd->szCommonName))
2134 attrib |= CRA_SELECTED;
2135 WinSendMsg(hwnd,
2136 CM_SETRECORDEMPHASIS,
2137 MPFROMP(pci), MPFROM2SHORT(TRUE, attrib));
2138 /* make sure that record shows in viewport */
2139 ShowCnrRecord(hwnd, (PMINIRECORDCORE) pci);
2140 return (MRESULT) TRUE;
2141 }
2142 else {
2143 if (SHORT1FROMMP(mp2) == ' ') {
2144 dcd->szCommonName[len] = 0;
2145 break;
2146 }
2147 *dcd->szCommonName = 0;
2148 dcd->lasttime = 0;
2149 if (len) // retry as first letter if no match
2150 goto KbdRetry;
2151 }
2152 break;
2153 }
2154 }
2155 break;
2156
2157 case WM_MOUSEMOVE:
2158 case WM_BUTTON1UP:
2159 case WM_BUTTON2UP:
2160 case WM_BUTTON3UP:
2161 case WM_CHORD:
2162 shiftstate = (SHORT2FROMMP(mp2) & (KC_SHIFT | KC_ALT | KC_CTRL));
2163 break;
2164
2165 case WM_BUTTON1MOTIONEND:
2166 {
2167 CNRINFO cnri;
2168
2169 memset(&cnri, 0, sizeof(CNRINFO));
2170 cnri.cb = sizeof(CNRINFO);
2171 if (WinSendMsg(hwnd,
2172 CM_QUERYCNRINFO,
2173 MPFROMP(&cnri), MPFROMLONG(sizeof(CNRINFO)))) {
2174 if (cnri.flWindowAttr & CV_DETAIL)
2175 PrfWriteProfileData(fmprof,
2176 appname,
2177 "ArcCnrSplitBar",
2178 (PVOID) & cnri.xVertSplitbar, sizeof(LONG));
2179 }
2180 }
2181 break;
2182
2183 case WM_PRESPARAMCHANGED:
2184 PresParamChanged(hwnd, "ArcCnr", mp1, mp2);
2185 break;
2186
2187 case UM_UPDATERECORD:
2188 case UM_UPDATERECORDLIST:
2189 if (dcd && !IsArcThere(hwnd, dcd->arcname))
2190 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
2191 return 0;
2192
2193 case WM_SETFOCUS:
2194 /*
2195 * put name of our window (archive name) on status line
2196 */
2197 if (dcd && hwndStatus && mp2)
2198 WinSendMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
2199 break;
2200
2201 case UM_SETUP2:
2202 if (dcd && dcd->info) {
2203 if (dcd->info->fdpos == -1 || !dcd->info->datetype)
2204 dcd->sortFlags &= (~SORT_LWDATE);
2205 if (dcd->info->nsizepos == -1)
2206 dcd->sortFlags &= (~SORT_EASIZE);
2207 if (dcd->info->osizepos == -1)
2208 dcd->sortFlags &= (~SORT_SIZE);
2209 AdjustCnrColVis(hwnd,
2210 GetPString(IDS_OLDSIZECOLTEXT),
2211 dcd->info->osizepos != -1, FALSE);
2212 AdjustCnrColVis(hwnd,
2213 GetPString(IDS_NEWSIZECOLTEXT),
2214 dcd->info->nsizepos != -1, FALSE);
2215 // Display unsullied date/time string if type 0
2216 AdjustCnrColVis(hwnd,
2217 GetPString(IDS_DATETIMECOLTEXT),
2218 dcd->info->fdpos != -1 && !dcd->info->datetype, FALSE);
2219 // Display parsed date/time columns if type specified
2220 AdjustCnrColVis(hwnd,
2221 GetPString(IDS_TIMECOLTEXT),
2222 dcd->info->fdpos != -1 && dcd->info->datetype, FALSE);
2223 AdjustCnrColVis(hwnd,
2224 GetPString(IDS_DATECOLTEXT),
2225 dcd->info->fdpos != -1 && dcd->info->datetype, FALSE);
2226 WinSendMsg(hwnd, CM_INVALIDATEDETAILFIELDINFO, MPVOID, MPVOID);
2227 }
2228 return 0;
2229
2230 case UM_RESCAN:
2231 if (dcd) {
2232 CNRINFO cnri;
2233 CHAR s[CCHMAXPATH * 2], tb[81], tf[81];
2234 PARCITEM pci;
2235
2236 if (mp1) {
2237 PostMsg(dcd->hwndObject, UM_RESCAN, MPVOID, MPVOID);
2238 return 0;
2239 }
2240 memset(&cnri, 0, sizeof(CNRINFO));
2241 cnri.cb = sizeof(CNRINFO);
2242 WinSendMsg(hwnd,
2243 CM_QUERYCNRINFO,
2244 MPFROMP(&cnri), MPFROMLONG(sizeof(CNRINFO)));
2245 dcd->totalfiles = cnri.cRecords;
2246 commafmt(tf, sizeof(tf), dcd->selectedfiles);
2247 if (dcd->ullTotalBytes)
2248 CommaFmtULL(tb, sizeof(tb), dcd->selectedbytes, 'K');
2249 else
2250 *tb = 0;
2251 sprintf(s, "%s%s%s", tf, *tb ? " / " : NullStr, tb);
2252 WinSetDlgItemText(dcd->hwndClient, DIR_SELECTED, s);
2253 commafmt(tf, sizeof(tf), dcd->totalfiles);
2254 if (dcd->ullTotalBytes)
2255 CommaFmtULL(tb, sizeof(tb), dcd->ullTotalBytes, 'K');
2256 else
2257 *tb = 0;
2258 sprintf(s, "%s%s%s", tf, *tb ? " / " : NullStr, tb);
2259 WinSetDlgItemText(dcd->hwndClient, DIR_TOTALS, s);
2260 if (hwndStatus &&
2261 dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent)) {
2262 sprintf(s, " [%s%s%s]%s%s%s %s",
2263 tf,
2264 *tb ? " / " : NullStr,
2265 tb,
2266 *dcd->mask.szMask ? " (" : NullStr,
2267 *dcd->mask.szMask ? dcd->mask.szMask : NullStr,
2268 *dcd->mask.szMask ? ")" : NullStr, dcd->arcname);
2269 WinSetWindowText(hwndStatus, s);
2270 if (!ParentIsDesktop(hwnd, dcd->hwndParent)) {
2271 pci = WinSendMsg(hwnd,
2272 CM_QUERYRECORDEMPHASIS,
2273 MPFROMLONG(CMA_FIRST), MPFROMSHORT(CRA_CURSORED));
2274 if (pci && (INT) pci != -1) {
2275 if (fSplitStatus && hwndStatus2) {
2276 if (dcd->ullTotalBytes)
2277 CommaFmtULL(tb, sizeof(tb), pci->cbFile, ' ');
2278 else
2279 *tb = 0;
2280 sprintf(s, "%s%s%s%s",
2281 *tb ? " " : NullStr,
2282 tb, *tb ? " " : NullStr, pci->pszFileName);
2283 WinSetWindowText(hwndStatus2, s);
2284 }
2285 if (fMoreButtons)
2286 WinSetWindowText(hwndName, pci->pszFileName);
2287 }
2288 else {
2289 WinSetWindowText(hwndStatus2, NullStr);
2290 WinSetWindowText(hwndName, NullStr);
2291 }
2292 WinSetWindowText(hwndDate, NullStr);
2293 WinSetWindowText(hwndAttr, NullStr);
2294 }
2295 }
2296 if ((dcd->arcfilled && !dcd->totalfiles) ||
2297 !IsArcThere(hwnd, dcd->arcname))
2298 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
2299 }
2300 return 0;
2301
2302 case UM_SETUP:
2303 if (!dcd) {
2304 Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
2305 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
2306 return 0;
2307 }
2308 else {
2309 if (!dcd->hwndObject) {
2310 /*
2311 * first time through -- set things up
2312 */
2313 {
2314 CHAR *p, *pp;
2315 ULONG z, was;
2316 APIRET rc;
2317
2318 rc = DosCreateDir(dcd->workdir, 0);
2319 if (rc) {
2320 if (rc == ERROR_ACCESS_DENIED) {
2321 p = strrchr(dcd->workdir, '.');
2322 if (p) {
2323 p++;
2324 pp = p;
2325 was = strtoul(p, &pp, 16);
2326 for (z = 0; z < 99; z++) {
2327 was++;
2328 sprintf(p, "%03x");
2329 rc = DosCreateDir(dcd->workdir, 0);
2330 if (!rc || rc != ERROR_ACCESS_DENIED)
2331 break;
2332 }
2333 }
2334 }
2335 if (rc)
2336 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
2337 return 0;
2338 }
2339 }
2340 RestorePresParams(hwnd, "ArcCnr");
2341 dcd->mask.fNoAttribs = TRUE;
2342 dcd->mask.fNoDirs = TRUE;
2343 *dcd->mask.prompt = 0;
2344 {
2345 PFIELDINFO pfi, pfiLastLeftCol;
2346 ULONG numcols = CON_COLS;
2347 CNRINFO cnri;
2348 ULONG size;
2349
2350 pfi = WinSendMsg(hwnd,
2351 CM_ALLOCDETAILFIELDINFO,
2352 MPFROMLONG(numcols), NULL);
2353 if (pfi) {
2354
2355 PFIELDINFO pfiFirst;
2356 FIELDINFOINSERT fii;
2357
2358 pfiFirst = pfi;
2359 pfi->flData = CFA_STRING | CFA_LEFT | CFA_FIREADONLY;
2360 pfi->flTitle = CFA_CENTER;
2361 pfi->pTitleData = GetPString(IDS_FILENAMECOLTEXT);
2362 pfi->offStruct = FIELDOFFSET(ARCITEM, pszDisplayName);
2363 pfiLastLeftCol = pfi;
2364 pfi = pfi->pNextFieldInfo;
2365 pfi->flData =
2366 CFA_ULONG | CFA_RIGHT | CFA_SEPARATOR | CFA_FIREADONLY;
2367 pfi->flTitle = CFA_CENTER;
2368 pfi->pTitleData = GetPString(IDS_OLDSIZECOLTEXT);
2369 pfi->offStruct = FIELDOFFSET(ARCITEM, cbFile);
2370 pfi = pfi->pNextFieldInfo;
2371 pfi->flData =
2372 CFA_ULONG | CFA_RIGHT | CFA_SEPARATOR | CFA_FIREADONLY;
2373 pfi->flTitle = CFA_CENTER;
2374 pfi->pTitleData = GetPString(IDS_NEWSIZECOLTEXT);
2375 pfi->offStruct = FIELDOFFSET(ARCITEM, cbComp);
2376 pfi = pfi->pNextFieldInfo;
2377 pfi->flData =
2378 CFA_STRING | CFA_CENTER | CFA_SEPARATOR | CFA_FIREADONLY;
2379 pfi->flTitle = CFA_CENTER | CFA_FITITLEREADONLY;
2380 pfi->pTitleData = GetPString(IDS_DATETIMECOLTEXT);
2381 pfi->offStruct = FIELDOFFSET(ARCITEM, pszDate);
2382 pfi = pfi->pNextFieldInfo;
2383 pfi->flData = CFA_DATE | CFA_RIGHT | CFA_FIREADONLY;
2384 pfi->flTitle = CFA_CENTER;
2385 pfi->pTitleData = GetPString(IDS_DATECOLTEXT);
2386 pfi->offStruct = FIELDOFFSET(ARCITEM, date);
2387 pfi = pfi->pNextFieldInfo;
2388 pfi->flData = CFA_TIME | CFA_RIGHT | CFA_FIREADONLY;
2389 pfi->flTitle = CFA_CENTER | CFA_FITITLEREADONLY;
2390 pfi->pTitleData = GetPString(IDS_TIMECOLTEXT);
2391 pfi->offStruct = FIELDOFFSET(ARCITEM, time);
2392 memset(&fii, 0, sizeof(FIELDINFOINSERT));
2393 fii.cb = sizeof(FIELDINFOINSERT);
2394 fii.pFieldInfoOrder = (PFIELDINFO) CMA_FIRST;
2395 fii.cFieldInfoInsert = (SHORT) numcols;
2396 fii.fInvalidateFieldInfo = TRUE;
2397 WinSendMsg(hwnd,
2398 CM_INSERTDETAILFIELDINFO,
2399 MPFROMP(pfiFirst), MPFROMP(&fii));
2400 PostMsg(hwnd, UM_SETUP2, MPVOID, MPVOID);
2401
2402 memset(&cnri, 0, sizeof(cnri));
2403 cnri.cb = sizeof(CNRINFO);
2404 cnri.pFieldInfoLast = pfiLastLeftCol;
2405 cnri.xVertSplitbar = DIR_SPLITBAR_OFFSET + 32;
2406
2407 size = sizeof(LONG);
2408 PrfQueryProfileData(fmprof, appname, "ArcCnrSplitBar",
2409 &cnri.xVertSplitbar, &size);
2410 if (cnri.xVertSplitbar <= 0)
2411 cnri.xVertSplitbar = DIR_SPLITBAR_OFFSET + 32;
2412
2413 cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT | CV_NAME));
2414 cnri.flWindowAttr |= (CV_DETAIL | CA_DETAILSVIEWTITLES | CV_FLOW);
2415 cnri.flWindowAttr &= (~(CA_ORDEREDTARGETEMPH |
2416 CA_MIXEDTARGETEMPH));
2417 cnri.pSortRecord = (PVOID) ArcSort;
2418 WinSendMsg(hwnd,
2419 CM_SETCNRINFO,
2420 MPFROMP(&cnri),
2421 MPFROMLONG(CMA_PFIELDINFOLAST |
2422 CMA_XVERTSPLITBAR |
2423 CMA_PSORTRECORD | CMA_FLWINDOWATTR));
2424 }
2425 }
2426 WinSendMsg(hwnd, CM_SORTRECORD, MPFROMP(ArcSort), MPFROMP(dcd));
2427 if (_beginthread(MakeObjWin, NULL, 245760, (PVOID) dcd) == -1) {
2428 Runtime_Error(pszSrcFile, __LINE__,
2429 GetPString(IDS_COULDNTSTARTTHREADTEXT));
2430 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
2431 return 0;
2432 }
2433 else
2434 DosSleep(1);
2435 SayFilter(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
2436 DIR_FILTER), &dcd->mask, TRUE);
2437 SaySort(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
2438 DIR_SORT), dcd->sortFlags, TRUE);
2439 DefArcSortFlags = dcd->sortFlags; // Remember for new windows
2440 }
2441 }
2442 return 0;
2443
2444 case UM_SETDIR:
2445 if (dcd) {
2446
2447 CHAR s[CCHMAXPATH], *p;
2448 ULONG ret = 0;
2449
2450 WinQueryDlgItemText(dcd->hwndClient, ARC_EXTRACTDIR, CCHMAXPATH, s);
2451 bstrip(s);
2452 MakeFullName(s);
2453 if (*s) {
2454 while ((p = strchr(s, '/')) != NULL)
2455 *p = '\\';
2456 while (strlen(s) > 3 && s[strlen(s) - 1] == '\\')
2457 s[strlen(s) - 1] = 0;
2458 if (stricmp(s, dcd->directory)) {
2459 if (IsFullName(s)) {
2460 if (driveflags[toupper(*s) - 'A'] &
2461 (DRIVE_NOTWRITEABLE | DRIVE_IGNORE | DRIVE_INVALID)) {
2462 Runtime_Error(pszSrcFile, __LINE__, "drive %s bad", s);
2463 WinSetDlgItemText(dcd->hwndClient,
2464 ARC_EXTRACTDIR, dcd->directory);
2465 return 0;
2466 }
2467 }
2468 if (!SetDir(dcd->hwndParent, hwnd, s, 0)) {
2469 if (stricmp(dcd->directory, s)) {
2470 DosEnterCritSec();
2471 strcpy(lastextractpath, s);
2472 DosExitCritSec();
2473 }
2474 strcpy(dcd->directory, s);
2475 if ((!isalpha(*s) || s[1] != ':') && *s != '.')
2476 saymsg(MB_ENTER | MB_ICONASTERISK,
2477 hwnd,
2478 GetPString(IDS_WARNINGTEXT),
2479 GetPString(IDS_SPECIFYDRIVETEXT));
2480 }
2481 else
2482 ret = 1;
2483 }
2484 }
2485 WinSetDlgItemText(dcd->hwndClient, ARC_EXTRACTDIR, dcd->directory);
2486 return (MRESULT) ret;
2487 }
2488 return 0;
2489
2490 case UM_ENTER:
2491 if (WinSendMsg(hwnd, UM_SETDIR, MPVOID, MPVOID))
2492 return 0;
2493 SetShiftState();
2494 if (dcd && (CHAR *) mp1) {
2495
2496 SWP swp;
2497 CHAR *filename = mp1;
2498
2499 if (IsFile(filename) != 1)
2500 return 0;
2501 WinQueryWindowPos(dcd->hwndFrame, &swp);
2502 DefaultViewKeys(hwnd, dcd->hwndFrame, dcd->hwndParent, &swp, filename);
2503 if (fUnHilite)
2504 UnHilite(hwnd, FALSE, &dcd->lastselection, 0);
2505 }
2506 return 0;
2507
2508 case WM_MENUEND:
2509 if (dcd) {
2510
2511 HWND hwndMenu = (HWND) mp2;
2512
2513 if (hwndMenu == ArcCnrMenu || hwndMenu == ArcMenu) {
2514 MarkAll(hwnd, TRUE, FALSE, TRUE);
2515 if (dcd->cnremphasized) {
2516 WinSendMsg(hwnd,
2517 CM_SETRECORDEMPHASIS,
2518 MPVOID, MPFROM2SHORT(FALSE, CRA_SOURCE));
2519 dcd->cnremphasized = FALSE;
2520 }
2521 }
2522 }
2523 break;
2524
2525 case MM_PORTHOLEINIT:
2526 if (dcd) {
2527 switch (SHORT1FROMMP(mp1)) {
2528 case 0:
2529 case 1:
2530 {
2531 ULONG wmsg;
2532
2533 wmsg = SHORT1FROMMP(mp1) == 0 ? UM_FILESMENU : UM_VIEWSMENU;
2534 PortholeInit((HWND) WinSendMsg(dcd->hwndClient,
2535 wmsg, MPVOID, MPVOID), mp1, mp2);
2536 }
2537 break;
2538 }
2539 }
2540 break;
2541
2542 case UM_INITMENU:
2543 case WM_INITMENU:
2544 if (dcd) {
2545 switch (SHORT1FROMMP(mp1)) {
2546 case IDM_FILESMENU:
2547 if (dcd->info) {
2548 WinEnableMenuItem((HWND) mp2,
2549 IDM_DELETE, dcd->info->delete != NULL);
2550 WinEnableMenuItem((HWND) mp2, IDM_TEST, dcd->info->test != NULL);
2551 WinEnableMenuItem((HWND) mp2,
2552 IDM_EXTRACT, dcd->info->extract != NULL);
2553 WinEnableMenuItem((HWND) mp2,
2554 IDM_EXTRACTWDIRS, dcd->info->exwdirs != NULL);
2555 WinEnableMenuItem((HWND) mp2,
2556 IDM_ARCEXTRACTWDIRS, dcd->info->exwdirs != NULL);
2557 WinEnableMenuItem((HWND) mp2,
2558 IDM_ARCEXTRACTWDIRSEXIT,
2559 dcd->info->exwdirs != NULL);
2560 }
2561 break;
2562
2563 case IDM_VIEWSMENU:
2564 WinCheckMenuItem((HWND) mp2,
2565 IDM_MINIICONS, (dcd->flWindowAttr & CV_MINI) != 0);
2566 WinEnableMenuItem((HWND) mp2,
2567 IDM_RESELECT, (dcd->lastselection != NULL));
2568 break;
2569
2570 case IDM_COMMANDSMENU:
2571 SetupCommandMenu((HWND) mp2, hwnd);
2572 break;
2573
2574 case IDM_SORTSUBMENU:
2575 SetSortChecks((HWND) mp2, dcd->sortFlags);
2576 break;
2577
2578 case IDM_WINDOWSMENU:
2579 /*
2580 * add switchlist entries to end of pulldown menu
2581 */
2582 SetupWinList((HWND)mp2,
2583 hwndMain ? hwndMain : (HWND)0, dcd->hwndFrame);
2584 break;
2585 }
2586 dcd->hwndLastMenu = (HWND) mp2;
2587 }
2588 if (msg == WM_INITMENU)
2589 break;
2590 return 0;
2591
2592 case UM_LOADFILE:
2593 if (dcd && mp2) {
2594
2595 HWND hwnd;
2596
2597 if ((INT)mp1 == 5 || (INT)mp1 == 13 || (INT)mp1 == 21)
2598 hwnd = StartViewer(HWND_DESKTOP, (INT)mp1,
2599 (CHAR *)mp2, dcd->hwndFrame);
2600 else
2601 hwnd = StartMLEEditor(dcd->hwndParent,
2602 (INT)mp1, (CHAR *)mp2, dcd->hwndFrame);
2603 free((CHAR *)mp2);
2604 return MRFROMLONG(hwnd);
2605 }
2606 return 0;
2607
2608 case UM_COMMAND:
2609 if (mp1) {
2610 if (dcd) {
2611 if (!PostMsg(dcd->hwndObject, UM_COMMAND, mp1, mp2)) {
2612 Runtime_Error(pszSrcFile, __LINE__, "post");
2613 FreeListInfo((LISTINFO *) mp1);
2614 }
2615 else
2616 return (MRESULT) TRUE;
2617 }
2618 else
2619 FreeListInfo((LISTINFO *) mp1);
2620 }
2621 return 0;
2622
2623 case UM_OPENWINDOWFORME:
2624 if (dcd) {
2625 if (mp1 && !IsFile((CHAR *) mp1)) {
2626 OpenDirCnr((HWND) 0, hwndMain, dcd->hwndFrame, FALSE, (char *)mp1);
2627 }
2628 else if (mp1 && IsFile(mp1) == 1) {
2629 StartArcCnr(HWND_DESKTOP,
2630 dcd->hwndFrame, (CHAR *) mp1, 4, (ARC_TYPE *) mp2);
2631 }
2632 }
2633 return 0;
2634
2635 case WM_COMMAND:
2636 DosError(FERR_DISABLEHARDERR);
2637 if (dcd) {
2638 if (SwitchCommand(dcd->hwndLastMenu, SHORT1FROMMP(mp1)))
2639 return 0;
2640 if (WinSendMsg(hwnd, UM_SETDIR, MPVOID, MPVOID))
2641 return 0;
2642 if (!IsArcThere(hwnd, dcd->arcname)) {
2643 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
2644 return 0;
2645 }
2646 switch (SHORT1FROMMP(mp1)) {
2647 case IDM_TREEVIEW:
2648
2649 break;
2650
2651 case IDM_CONTEXTMENU:
2652 {
2653 PCNRITEM pci;
2654
2655 pci = (PCNRITEM) CurrentRecord(hwnd);
2656 PostMsg(hwnd,
2657 WM_CONTROL,
2658 MPFROM2SHORT(ARC_CNR, CN_CONTEXTMENU), MPFROMP(pci));
2659 }
2660 break;
2661
2662 case IDM_NEXTWINDOW:
2663 case IDM_PREVWINDOW:
2664 {
2665 HWND hwndActive;
2666
2667 hwndActive = WinQueryFocus(HWND_DESKTOP);
2668 WinSetFocus(HWND_DESKTOP,
2669 hwndActive == hwnd ?
2670 WinWindowFromID(dcd->hwndClient, ARC_EXTRACTDIR) :
2671 hwnd);
2672 }
2673 break;
2674
2675 case IDM_FOLDERAFTEREXTRACT:
2676 fFolderAfterExtract = fFolderAfterExtract ? FALSE : TRUE;
2677 PrfWriteProfileData(fmprof, appname, "FolderAfterExtract",
2678 &fFolderAfterExtract, sizeof(BOOL));
2679 break;
2680
2681 case IDM_SHOWSELECT:
2682 QuickPopup(hwnd, dcd, CheckMenu(hwnd, &ArcCnrMenu, ARCCNR_POPUP),
2683 IDM_SELECTSUBMENU);
2684 break;
2685
2686 case IDM_SHOWSORT:
2687 QuickPopup(hwnd, dcd, CheckMenu(hwnd, &ArcCnrMenu, ARCCNR_POPUP),
2688 IDM_SORTSUBMENU);
2689 break;
2690
2691 case IDM_ARCHIVERSETTINGS:
2692 if (!ParentIsDesktop(dcd->hwndParent, dcd->hwndParent))
2693 PostMsg(dcd->hwndParent, msg, MPFROMLONG(IDM_ARCHIVERSETTINGS), mp2);
2694 else {
2695 WinDlgBox(HWND_DESKTOP,
2696 hwnd,
2697 CfgDlgProc,
2698 FM3ModHandle,
2699 CFG_FRAME,
2700 MPFROMLONG(IDM_ARCHIVERSETTINGS));
2701 }
2702 break;
2703
2704 case IDM_RESCAN:
2705 dcd->ullTotalBytes = dcd->totalfiles =
2706 dcd->selectedfiles = dcd->selectedbytes = 0;
2707 WinSetDlgItemText(dcd->hwndClient, DIR_TOTALS, "0");
2708 WinSetDlgItemText(dcd->hwndClient, DIR_SELECTED, "0 / 0k");
2709 dcd->totalfiles = FillArcCnr(dcd->hwndCnr,
2710 dcd->arcname,
2711 &dcd->info,
2712 &dcd->ullTotalBytes, &dcd->stopflag);
2713 PostMsg(dcd->hwndCnr, UM_RESCAN, MPVOID, MPVOID);
2714 PostMsg(dcd->hwndCnr, UM_SETUP2, MPVOID, MPVOID);
2715 WinSendMsg(dcd->hwndCnr,
2716 CM_INVALIDATERECORD,
2717 MPVOID, MPFROM2SHORT(0, CMA_ERASE | CMA_REPOSITION));
2718 break;
2719
2720 case IDM_RESELECT:
2721 SelectList(hwnd, TRUE, FALSE, FALSE, NULL, NULL, dcd->lastselection);
2722 break;
2723
2724 case IDM_HELP:
2725 if (hwndHelp)
2726 WinSendMsg(hwndHelp,
2727 HM_DISPLAY_HELP,
2728 MPFROM2SHORT(HELP_ARCLIST, 0),
2729 MPFROMSHORT(HM_RESOURCEID));
2730 break;
2731
2732 case IDM_WINDOWDLG:
2733 if (!ParentIsDesktop(dcd->hwndParent, dcd->hwndFrame))
2734 PostMsg(dcd->hwndParent,
2735 UM_COMMAND, MPFROM2SHORT(IDM_WINDOWDLG, 0), MPVOID);
2736 break;
2737
2738 case IDM_SELECTALL:
2739 case IDM_SELECTALLFILES:
2740 case IDM_DESELECTALL:
2741 case IDM_DESELECTALLFILES:
2742 case IDM_SELECTMASK:
2743 case IDM_DESELECTMASK:
2744 case IDM_INVERT:
2745 {
2746 PARCITEM pci;
2747
2748 pci = (PARCITEM) WinSendMsg(hwnd,
2749 CM_QUERYRECORDEMPHASIS,
2750 MPFROMLONG(CMA_FIRST),
2751 MPFROMSHORT(CRA_CURSORED));
2752 if ((INT) pci == -1)
2753 pci = NULL;
2754 if (SHORT1FROMMP(mp1) == IDM_HIDEALL) {
2755 if (pci) {
2756 if (!(pci->rc.flRecordAttr & CRA_SELECTED))
2757 pci->rc.flRecordAttr |= CRA_FILTERED;
2758 WinSendMsg(hwnd,
2759 CM_INVALIDATERECORD,
2760 MPFROMP(&pci),
2761 MPFROM2SHORT(1, CMA_ERASE | CMA_REPOSITION));
2762 break;
2763 }
2764 }
2765 PostMsg(dcd->hwndObject, UM_SELECT, mp1, MPFROMP(pci));
2766 }
2767 break;
2768
2769 case IDM_SORTSMARTNAME:
2770 case IDM_SORTNAME:
2771 case IDM_SORTFILENAME:
2772 case IDM_SORTSIZE:
2773 case IDM_SORTEASIZE:
2774 case IDM_SORTFIRST:
2775 case IDM_SORTLAST:
2776 case IDM_SORTLWDATE:
2777 dcd->sortFlags &= SORT_REVERSE;
2778 /* intentional fallthru */
2779 case IDM_SORTREVERSE:
2780 switch (SHORT1FROMMP(mp1)) {
2781 case IDM_SORTSMARTNAME:
2782 case IDM_SORTFILENAME:
2783 dcd->sortFlags |= SORT_FILENAME;
2784 break;
2785 case IDM_SORTSIZE:
2786 dcd->sortFlags |= SORT_SIZE;
2787 break;
2788 case IDM_SORTEASIZE:
2789 dcd->sortFlags |= SORT_EASIZE;
2790 break;
2791 case IDM_SORTFIRST:
2792 dcd->sortFlags |= SORT_FIRSTEXTENSION;
2793 break;
2794 case IDM_SORTLAST:
2795 dcd->sortFlags |= SORT_LASTEXTENSION;
2796 break;
2797 case IDM_SORTLWDATE:
2798 dcd->sortFlags |= SORT_LWDATE;
2799 break;
2800 case IDM_SORTREVERSE:
2801 if (dcd->sortFlags & SORT_REVERSE)
2802 dcd->sortFlags &= (~SORT_REVERSE);
2803 else
2804 dcd->sortFlags |= SORT_REVERSE;
2805 break;
2806 }
2807 WinSendMsg(hwnd, CM_SORTRECORD, MPFROMP(ArcSort), MPFROMP(dcd));
2808 SaySort(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
2809 DIR_SORT), dcd->sortFlags, TRUE);
2810 DefArcSortFlags = dcd->sortFlags; // Remember for new windows
2811 break;
2812
2813 case IDM_COLLECTOR:
2814 if (!Collector) {
2815 HWND hwndC;
2816 SWP swp;
2817
2818 if (ParentIsDesktop(hwnd, dcd->hwndParent) && !fAutoTile &&
2819 (!fExternalCollector && !strcmp(realappname, FM3Str)))
2820 GetNextWindowPos(dcd->hwndParent, &swp, NULL, NULL);
2821 hwndC = StartCollector(fExternalCollector ||
2822 strcmp(realappname, FM3Str) ?
2823 HWND_DESKTOP : dcd->hwndParent, 4);
2824 if (hwndC) {
2825 if (!ParentIsDesktop(hwnd, dcd->hwndParent) && !fAutoTile &&
2826 (!fExternalCollector && !strcmp(realappname, FM3Str)))
2827 WinSetWindowPos(hwndC,
2828 HWND_TOP,
2829 swp.x,
2830 swp.y,
2831 swp.cx,
2832 swp.cy,
2833 SWP_MOVE | SWP_SIZE | SWP_SHOW | SWP_ZORDER);
2834 else if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
2835 fAutoTile && !strcmp(realappname, FM3Str)) {
2836 TileChildren(dcd->hwndParent, TRUE);
2837 }
2838 WinSetWindowPos(hwndC, HWND_TOP, 0, 0, 0, 0, SWP_ACTIVATE);
2839 DosSleep(100); //05 Aug 07 GKY 128
2840 }
2841 }
2842 else
2843 StartCollector(dcd->hwndParent, 4);
2844 break;
2845
2846 case IDM_ARCEXTRACTEXIT:
2847 case IDM_ARCEXTRACT:
2848 if (dcd->info->extract)
2849 runemf2(SEPARATE | WINDOWED |
2850 (fArcStuffVisible ? 0 : BACKGROUND | MINIMIZED),
2851 hwnd, pszSrcFile, __LINE__,
2852 dcd->directory, NULL, "%s %s", dcd->info->extract,
2853 BldQuotedFileName(szQuotedArcName, dcd->arcname));
2854 if (SHORT1FROMMP(mp1) == IDM_ARCEXTRACTEXIT)
2855 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
2856 break;
2857
2858 case IDM_ARCEXTRACTWDIRSEXIT:
2859 case IDM_ARCEXTRACTWDIRS:
2860 if (dcd->info->exwdirs)
2861 runemf2(SEPARATE | WINDOWED |
2862 (fArcStuffVisible ? 0 : BACKGROUND | MINIMIZED),
2863 hwnd, pszSrcFile, __LINE__,
2864 dcd->directory, NULL, "%s %s",
2865 dcd->info->exwdirs,
2866 BldQuotedFileName(szQuotedArcName, dcd->arcname));
2867 if (SHORT1FROMMP(mp1) == IDM_ARCEXTRACTWDIRSEXIT)
2868 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
2869 break;
2870
2871 case IDM_RESORT:
2872 WinSendMsg(hwnd, CM_SORTRECORD, MPFROMP(ArcSort), MPFROMP(dcd));
2873 break;
2874
2875 case IDM_FILTER:
2876 {
2877 BOOL empty = FALSE;
2878 PARCITEM pci;
2879
2880 if (!*dcd->mask.szMask) {
2881 empty = TRUE;
2882 pci = (PARCITEM) CurrentRecord(hwnd);
2883 if (pci && strchr(pci->pszFileName, '.'))
2884 strcpy(dcd->mask.szMask, pci->pszFileName);
2885 }
2886
2887 if (WinDlgBox(HWND_DESKTOP, hwnd, PickMaskDlgProc,
2888 FM3ModHandle, MSK_FRAME, MPFROMP(&dcd->mask))) {
2889 WinSendMsg(hwnd, CM_FILTER, MPFROMP(ArcFilter), MPFROMP(dcd));
2890 PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
2891 }
2892 else if (empty)
2893 *dcd->mask.szMask = 0;
2894 SayFilter(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
2895 DIR_FILTER), &dcd->mask, TRUE);
2896 }
2897 break;
2898
2899 case IDM_SWITCH:
2900 if (mp2) {
2901 if (stricmp(dcd->directory, (CHAR *) mp2)) {
2902 DosEnterCritSec();
2903 strcpy(lastextractpath, (CHAR *) mp2);
2904 MakeValidDir(lastextractpath);
2905 DosExitCritSec();
2906 }
2907 strcpy(dcd->directory, (CHAR *) mp2);
2908 MakeValidDir(dcd->directory);
2909 WinSetWindowText(dcd->hwndExtract, dcd->directory);
2910 }
2911 break;
2912
2913 case IDM_WALKDIR:
2914 {
2915 CHAR newdir[CCHMAXPATH];
2916
2917 strcpy(newdir, dcd->directory);
2918 if (!WinDlgBox(HWND_DESKTOP, dcd->hwndParent, WalkExtractDlgProc,
2919 FM3ModHandle, WALK_FRAME,
2920 MPFROMP(newdir)) || !*newdir)
2921 break;
2922 if (stricmp(newdir, dcd->directory)) {
2923 strcpy(dcd->directory, newdir);
2924 if (stricmp(lastextractpath, newdir))
2925 strcpy(lastextractpath, newdir);
2926 WinSetWindowText(dcd->hwndExtract, dcd->directory);
2927 }
2928 }
2929 break;
2930
2931 case IDM_TEST:
2932 if (dcd->info->test)
2933 runemf2(SEPARATEKEEP | WINDOWED | MAXIMIZED,
2934 hwnd, pszSrcFile, __LINE__, NULL, NULL,
2935 "%s %s",dcd->info->test,
2936 BldQuotedFileName(szQuotedArcName, dcd->arcname));
2937 break;
2938
2939 case IDM_REFRESH:
2940 case IDM_DELETE:
2941 case IDM_PRINT:
2942 case IDM_VIEW:
2943 case IDM_VIEWTEXT:
2944 case IDM_VIEWBINARY:
2945 case IDM_VIEWARCHIVE:
2946 case IDM_EDIT:
2947 case IDM_EDITTEXT:
2948 case IDM_EDITBINARY:
2949 case IDM_EXTRACT:
2950 case IDM_EXTRACTWDIRS:
2951 case IDM_FIND:
2952 case IDM_EXEC:
2953 case IDM_VIRUSSCAN:
2954 case IDM_OPENDEFAULT:
2955 case IDM_OPENSETTINGS:
2956 case IDM_MCIPLAY:
2957 {
2958 LISTINFO *li;
2959# ifdef FORTIFY
2960 Fortify_EnterScope();
2961# endif
2962 li = xmallocz(sizeof(LISTINFO), pszSrcFile, __LINE__);
2963 if (li) {
2964 li->type = SHORT1FROMMP(mp1);
2965 li->hwnd = hwnd;
2966 li->list = BuildArcList(hwnd);
2967 if (li->type == IDM_REFRESH) {
2968
2969 CHAR s[CCHMAXPATH], *p;
2970 INT x, y;
2971
2972 for (x = 0; li->list && li->list[x]; x++) {
2973 BldFullPathName(s, dcd->workdir, li->list[x]);
2974 if (IsFile(s) != 1) {
2975 free(li->list[x]);
2976 li->list[x] = NULL;
2977 for (y = x; li->list[y]; y++)
2978 li->list[y] = li->list[y + 1];
2979 li->list =
2980 xrealloc(li->list, y * sizeof(CHAR *), pszSrcFile,
2981 __LINE__);
2982 x--;
2983 }
2984 else {
2985 p = xstrdup(s, pszSrcFile, __LINE__);
2986 if (p) {
2987 free(li->list[x]);
2988 li->list[x] = p;
2989 }
2990 }
2991 } // for
2992 }
2993 strcpy(li->arcname, dcd->arcname);
2994 li->info = dcd->info;
2995 {
2996 PARCITEM pai;
2997
2998 if (SHORT1FROMMP(mp1) != IDM_EXEC)
2999 pai = (PARCITEM) CurrentRecord(hwnd);
3000 else
3001 pai = (PARCITEM) WinSendMsg(hwnd, CM_QUERYRECORDEMPHASIS,
3002 MPFROMLONG(CMA_FIRST),
3003 MPFROMSHORT(CRA_CURSORED));
3004 if (pai && (INT) pai != -1)
3005 strcpy(li->runfile, pai->pszFileName);
3006 else
3007 strcpy(li->runfile, li->list[0]);
3008 }
3009 switch (SHORT1FROMMP(mp1)) {
3010 case IDM_VIEW:
3011 case IDM_VIEWTEXT:
3012 case IDM_VIEWBINARY:
3013 case IDM_VIEWARCHIVE:
3014 case IDM_EDIT:
3015 case IDM_EDITTEXT:
3016 case IDM_EDITBINARY:
3017 case IDM_EXEC:
3018 case IDM_PRINT:
3019 case IDM_VIRUSSCAN:
3020 case IDM_OPENDEFAULT:
3021 case IDM_OPENSETTINGS:
3022 case IDM_MCIPLAY:
3023 strcpy(li->targetpath, dcd->workdir);
3024 break;
3025 default:
3026 strcpy(li->targetpath, dcd->directory);
3027 break;
3028 }
3029 if (li->list) {
3030 if (!PostMsg(dcd->hwndObject, UM_ACTION, MPFROMP(li), MPVOID)) {
3031 Runtime_Error(pszSrcFile, __LINE__, "post");
3032 FreeListInfo(li);
3033 }
3034 else if (fUnHilite && SHORT1FROMMP(mp1) != IDM_EDIT)
3035 UnHilite(hwnd, TRUE, &dcd->lastselection, 0);
3036 }
3037 else {
3038 free(li);
3039# ifdef FORTIFY
3040 Fortify_LeaveScope();
3041# endif
3042 }
3043 }
3044 }
3045 break;
3046 }
3047 }
3048 return 0;
3049
3050 case WM_CONTROL:
3051 DosError(FERR_DISABLEHARDERR);
3052 if (dcd) {
3053 switch (SHORT2FROMMP(mp1)) {
3054 case CN_BEGINEDIT:
3055 PostMsg(hwnd, CM_CLOSEEDIT, MPVOID, MPVOID);
3056 break;
3057
3058 case CN_ENDEDIT:
3059 if (!((PCNREDITDATA) mp2)->pRecord) {
3060
3061 PFIELDINFO pfi = ((PCNREDITDATA) mp2)->pFieldInfo;
3062 USHORT cmd = 0;
3063
3064 if (!pfi || pfi->offStruct == FIELDOFFSET(ARCITEM, pszDisplayName))
3065 cmd = IDM_SORTSMARTNAME;
3066 else if (pfi->offStruct == FIELDOFFSET(ARCITEM, cbFile))
3067 cmd = IDM_SORTSIZE;
3068 else if (pfi->offStruct == FIELDOFFSET(ARCITEM, cbComp))
3069 cmd = IDM_SORTEASIZE;
3070 else if (pfi->offStruct == FIELDOFFSET(ARCITEM, date))
3071 cmd = IDM_SORTLWDATE;
3072 else if (pfi->offStruct == FIELDOFFSET(ARCITEM, time))
3073 cmd = IDM_SORTLWDATE;
3074 if (cmd)
3075 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(cmd, 0), MPVOID);
3076 }
3077 break;
3078
3079 case CN_DROPHELP:
3080 saymsg(MB_ENTER, hwnd,
3081 GetPString(IDS_DROPHELPHDRTEXT),
3082 GetPString(IDS_ARCCNRDROPHELPTEXT), dcd->arcname);
3083 return 0;
3084
3085 case CN_DRAGLEAVE:
3086 if (mp2) {
3087
3088 PDRAGINFO pDInfo;
3089
3090 pDInfo = ((PCNRDRAGINFO) mp2)->pDragInfo;
3091 DrgAccessDraginfo(pDInfo); /* Access DRAGINFO */
3092 DrgFreeDraginfo(pDInfo); /* Free DRAGINFO */
3093 }
3094 return 0;
3095
3096 case CN_DRAGAFTER:
3097 case CN_DRAGOVER:
3098 if (mp2) {
3099
3100 PDRAGITEM pDItem; /* Pointer to DRAGITEM */
3101 PDRAGINFO pDInfo; /* Pointer to DRAGINFO */
3102 PARCITEM pci;
3103
3104 pci = (PARCITEM) ((PCNRDRAGINFO) mp2)->pRecord;
3105 if (SHORT1FROMMP(mp1) == CN_DRAGAFTER)
3106 pci = NULL;
3107 pDInfo = ((PCNRDRAGINFO) mp2)->pDragInfo;
3108 DrgAccessDraginfo(pDInfo); /* Access DRAGINFO */
3109 if (*dcd->arcname) {
3110 if ((driveflags[toupper(*dcd->arcname) - 'A'] &
3111 DRIVE_NOTWRITEABLE) || !dcd->info || !dcd->info->create) {
3112 DrgFreeDraginfo(pDInfo);
3113 return MRFROM2SHORT(DOR_NEVERDROP, 0);
3114 }
3115 }
3116 if (pci) {
3117 DrgFreeDraginfo(pDInfo);
3118 return MRFROM2SHORT(DOR_NODROP, 0);
3119 }
3120 pDItem = DrgQueryDragitemPtr(pDInfo, /* Access DRAGITEM */
3121 0); /* Index to DRAGITEM */
3122 if (DrgVerifyRMF(pDItem, /* Check valid rendering */
3123 DRM_OS2FILE, /* mechanisms and data */
3124 NULL) && !(pDItem->fsControl & DC_PREPARE)) {
3125 DrgFreeDraginfo(pDInfo); /* Free DRAGINFO */
3126 return MRFROM2SHORT(DOR_DROP, /* Return okay to drop */
3127 fCopyDefault ? DO_COPY : DO_MOVE);
3128 }
3129 DrgFreeDraginfo(pDInfo); /* Free DRAGINFO */
3130 }
3131 return (MRFROM2SHORT(DOR_NEVERDROP, 0)); /* Drop not valid */
3132
3133 case CN_INITDRAG:
3134 if (mp2) {
3135
3136 BOOL wasemphasized = FALSE;
3137 PCNRDRAGINIT pcd = (PCNRDRAGINIT) mp2;
3138 PARCITEM pci;
3139
3140 if (pcd) {
3141 pci = (PARCITEM) pcd->pRecord;
3142 if (pci) {
3143 if (pci->rc.flRecordAttr & CRA_SELECTED)
3144 wasemphasized = TRUE;
3145 if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
3146 fSplitStatus && hwndStatus2)
3147 WinSetWindowText(hwndStatus2, GetPString(IDS_DRAGARCMEMTEXT));
3148 if (DoFileDrag(hwnd,
3149 dcd->hwndObject,
3150 mp2, dcd->arcname, NULL, TRUE)) {
3151 if ((fUnHilite && wasemphasized) || dcd->ulItemsToUnHilite)
3152 UnHilite(hwnd, TRUE, &dcd->lastselection, dcd->ulItemsToUnHilite);
3153 }
3154 if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
3155 fSplitStatus && hwndStatus2) {
3156 PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
3157 }
3158 }
3159 else {
3160 if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
3161 fSplitStatus && hwndStatus2)
3162 WinSetWindowText(hwndStatus2,
3163 GetPString(IDS_DRAGARCFILETEXT));
3164 DragOne(hwnd, dcd->hwndObject, dcd->arcname, FALSE);
3165 if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
3166 fSplitStatus && hwndStatus2)
3167 PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
3168 }
3169 }
3170 }
3171 return 0;
3172
3173 case CN_DROP:
3174 if (mp2) {
3175
3176 LISTINFO *li;
3177
3178 DosBeep(500, 100); // fixme to know why beep?
3179 li = DoFileDrop(hwnd, dcd->arcname, FALSE, mp1, mp2);
3180 DosBeep(50, 100); // fixme to know why beep?
3181 CheckPmDrgLimit(((PCNRDRAGINFO)mp2)->pDragInfo);
3182 if (li) {
3183 li->type = li->type == DO_MOVE ? IDM_ARCHIVEM : IDM_ARCHIVE;
3184 strcpy(li->targetpath, dcd->arcname);
3185 if (!li->list ||
3186 !li->list[0] ||
3187 !PostMsg(dcd->hwndObject, UM_ACTION, MPFROMP(li), MPVOID))
3188 FreeListInfo(li);
3189 }
3190 }
3191 return 0;
3192
3193 case CN_CONTEXTMENU:
3194 {
3195 PARCITEM pci = (PARCITEM) mp2;
3196
3197 if (pci) {
3198 WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPFROMP(pci),
3199 MPFROM2SHORT(TRUE, CRA_CURSORED));
3200 MarkAll(hwnd, FALSE, FALSE, TRUE);
3201 dcd->hwndLastMenu = CheckMenu(hwnd, &ArcMenu, ARC_POPUP);
3202 }
3203 else {
3204 dcd->hwndLastMenu = CheckMenu(hwnd, &ArcCnrMenu, ARCCNR_POPUP);
3205 if (dcd->hwndLastMenu && !dcd->cnremphasized) {
3206 WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPVOID,
3207 MPFROM2SHORT(TRUE, CRA_SOURCE));
3208 dcd->cnremphasized = TRUE;
3209 }
3210 }
3211 if (dcd->hwndLastMenu) {
3212 if (dcd->hwndLastMenu == ArcCnrMenu) {
3213 if (dcd->flWindowAttr & CV_MINI)
3214 WinCheckMenuItem(dcd->hwndLastMenu, IDM_MINIICONS, TRUE);
3215 }
3216 WinCheckMenuItem(dcd->hwndLastMenu, IDM_FOLDERAFTEREXTRACT,
3217 fFolderAfterExtract);
3218 if (!PopupMenu(hwnd, hwnd, dcd->hwndLastMenu)) {
3219 if (dcd->cnremphasized) {
3220 WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPVOID,
3221 MPFROM2SHORT(FALSE, CRA_SOURCE));
3222 dcd->cnremphasized = TRUE;
3223 }
3224 MarkAll(hwnd, TRUE, FALSE, TRUE);
3225 }
3226 }
3227 }
3228 break;
3229
3230 case CN_EMPHASIS:
3231 if (mp2) {
3232
3233 PNOTIFYRECORDEMPHASIS pre = mp2;
3234 PARCITEM pci;
3235 CHAR s[CCHMAXPATHCOMP + 91], tf[81], tb[81];
3236
3237 pci = (PARCITEM)(pre ? pre->pRecord : NULL);
3238 if (!pci) {
3239 if (!ParentIsDesktop(hwnd, dcd->hwndParent)) {
3240 if (hwndStatus2)
3241 WinSetWindowText(hwndStatus2, NullStr);
3242 if (fMoreButtons)
3243 WinSetWindowText(hwndName, NullStr);
3244 }
3245 break;
3246 }
3247 if (pre->fEmphasisMask & CRA_SELECTED) {
3248 if (pci->rc.flRecordAttr & CRA_SELECTED) {
3249 dcd->selectedbytes += pci->cbFile;
3250 dcd->selectedfiles++;
3251 }
3252 else if (dcd->selectedfiles) {
3253 dcd->selectedbytes -= pci->cbFile;
3254 dcd->selectedfiles--;
3255 }
3256 commafmt(tf, sizeof(tf), dcd->selectedfiles);
3257 if (dcd->ullTotalBytes)
3258 CommaFmtULL(tb, sizeof(tb), dcd->selectedbytes, ' ');
3259 else
3260 *tb = 0;
3261 sprintf(s, "%s%s%s", tf, *tb ? " / " : NullStr, tb);
3262 WinSetDlgItemText(dcd->hwndClient, DIR_SELECTED, s);
3263 }
3264 else if (WinQueryActiveWindow(dcd->hwndParent) ==
3265 dcd->hwndFrame &&
3266 !ParentIsDesktop(hwnd, dcd->hwndParent)) {
3267 if (pre->fEmphasisMask & CRA_CURSORED) {
3268 if (pci->rc.flRecordAttr & CRA_CURSORED) {
3269 if (fSplitStatus && hwndStatus2) {
3270 if (dcd->ullTotalBytes)
3271 CommaFmtULL(tb, sizeof(tb), pci->cbFile, ' ');
3272 else
3273 *tb = 0;
3274 sprintf(s, "%s%s%s%s",
3275 *tb ? " " : NullStr,
3276 tb, *tb ? " " : NullStr, pci->pszFileName);
3277 WinSetWindowText(hwndStatus2, s);
3278 }
3279 if (fMoreButtons)
3280 WinSetWindowText(hwndName, pci->pszFileName);
3281 }
3282 }
3283 }
3284 }
3285 break;
3286
3287 case CN_ENTER:
3288 if (mp2) {
3289
3290 PARCITEM pci = (PARCITEM) ((PNOTIFYRECORDENTER) mp2)->pRecord;
3291
3292 if (pci) {
3293
3294 CHAR *s;
3295
3296 if ((pci->rc.flRecordAttr & CRA_INUSE) ||
3297 (pci->flags & (ARCFLAGS_REALDIR | ARCFLAGS_PSEUDODIR)))
3298 break;
3299 s = xstrdup(pci->pszFileName, pszSrcFile, __LINE__);
3300 if (s) {
3301 if (!PostMsg(dcd->hwndObject, UM_ENTER, MPFROMP(s), MPVOID)) {
3302 Runtime_Error(pszSrcFile, __LINE__, "post");
3303 free(s);
3304 }
3305 }
3306 }
3307 }
3308 break;
3309 }
3310 }
3311 return 0;
3312
3313 case UM_FOLDUP:
3314 if (!PostMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID))
3315 DosExit(EXIT_PROCESS, 1);
3316 return 0;
3317
3318 case UM_CLOSE:
3319 WinDestroyWindow(WinQueryWindow(WinQueryWindow(hwnd, QW_PARENT),
3320 QW_PARENT));
3321 return 0;
3322
3323 case WM_SAVEAPPLICATION:
3324 if (dcd && ParentIsDesktop(hwnd, dcd->hwndParent)) {
3325 SWP swp;
3326
3327 WinQueryWindowPos(dcd->hwndFrame, &swp);
3328 if (!(swp.fl & (SWP_HIDE | SWP_MINIMIZE | SWP_MAXIMIZE)))
3329 PrfWriteProfileData(fmprof, appname, "AV2SizePos", &swp, sizeof(swp));
3330 }
3331 break;
3332
3333 case WM_CLOSE:
3334 WinSendMsg(hwnd, WM_SAVEAPPLICATION, MPVOID, MPVOID);
3335 if (dcd)
3336 dcd->stopflag++;
3337 if (dcd && dcd->hwndObject) {
3338 if (!PostMsg(dcd->hwndObject, WM_CLOSE, MPVOID, MPVOID))
3339 WinSendMsg(dcd->hwndObject, WM_CLOSE, MPVOID, MPVOID);
3340 }
3341 // In case object window frees dcd
3342 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
3343 if (!dcd ||
3344 (!dcd->dontclose &&
3345 !dcd->amextracted && ParentIsDesktop(hwnd, dcd->hwndParent))) {
3346 if (!PostMsg(hwnd, UM_FOLDUP, MPVOID, MPVOID))
3347 WinSendMsg(hwnd, UM_FOLDUP, MPVOID, MPVOID);
3348 }
3349 return 0;
3350
3351 case WM_DESTROY:
3352 if (ArcMenu)
3353 WinDestroyWindow(ArcMenu);
3354 if (ArcCnrMenu)
3355 WinDestroyWindow(ArcCnrMenu);
3356 ArcMenu = ArcCnrMenu = (HWND) 0;
3357 EmptyArcCnr(hwnd);
3358 break;
3359 }
3360 if (dcd && dcd->oldproc){
3361 return dcd->oldproc(hwnd, msg, mp1, mp2);
3362 }
3363 else
3364 return PFNWPCnr(hwnd, msg, mp1, mp2);
3365}
3366
3367MRESULT EXPENTRY ArcCnrMenuProc(HWND hwnd, ULONG msg, MPARAM mp1,
3368 MPARAM mp2)
3369{
3370 PFNWP oldMenuProc = WinQueryWindowPtr(hwnd, QWL_USER);
3371 static short sLastMenuitem;
3372
3373 switch (msg) {
3374 case WM_MOUSEMOVE: {
3375 if (fOtherHelp) {
3376 RECTL rectl;
3377 SHORT i, sCurrentMenuitem;
3378 SHORT MenuItems = 10;
3379 SHORT asMenuIDs[10] = {IDM_VIEW,
3380 IDM_DELETE,
3381 IDM_EXEC,
3382 IDM_EXTRACT,
3383 IDM_TEST,
3384 IDM_VIRUSSCAN,
3385 IDM_RESCAN,
3386 IDM_WALKDIR,
3387 IDM_FILTER,
3388 0};
3389 char *szHelpString = NULL;
3390
3391
3392 for (i=0; i<MenuItems; i++) {
3393 sCurrentMenuitem = asMenuIDs[i];
3394 oldMenuProc(hwnd,MM_QUERYITEMRECT,
3395 MPFROM2SHORT(asMenuIDs[i], FALSE),
3396 &rectl);
3397
3398 if (MOUSEMSG(&msg)->x > rectl.xLeft &&
3399 MOUSEMSG(&msg)->x < rectl.xRight &&
3400 MOUSEMSG(&msg)->y > rectl.yBottom &&
3401 MOUSEMSG(&msg)->y < rectl.yTop)
3402 break;
3403 } // for
3404
3405
3406 switch (sCurrentMenuitem) {
3407 case 0:
3408 break;
3409 case IDM_VIEW:
3410 szHelpString = GetPString(IDS_ARCCNRVIEWMENUHELP);
3411 break;
3412 case IDM_DELETE:
3413 szHelpString = GetPString(IDS_ARCCNRDELETEMENUHELP);
3414 break;
3415 case IDM_EXEC:
3416 szHelpString = GetPString(IDS_ARCCNREXECMENUHELP);
3417 break;
3418 case IDM_EXTRACT:
3419 szHelpString = GetPString(IDS_ARCCNREXTRACTMENUHELP);
3420 break;
3421 case IDM_TEST:
3422 szHelpString = GetPString(IDS_ARCCNRTESTMENUHELP);
3423 break;
3424 case IDM_VIRUSSCAN:
3425 szHelpString = GetPString(IDS_ARCCNRVIRUSMENUHELP);
3426 break;
3427 case IDM_RESCAN:
3428 szHelpString = GetPString(IDS_ARCCNRRESCANMENUHELP);
3429 break;
3430 case IDM_WALKDIR:
3431 szHelpString = GetPString(IDS_ARCCNRWALKDIRMENUHELP);
3432 break;
3433 case IDM_FILTER:
3434 szHelpString = GetPString(IDS_ARCCNRFILTERMENUHELP);
3435 break;
3436 default:
3437 break;
3438 }
3439
3440 if (sLastMenuitem != sCurrentMenuitem && szHelpString) {
3441 sLastMenuitem = sCurrentMenuitem;
3442 MakeBubble(hwnd, TRUE, szHelpString);
3443 }
3444 else if (hwndBubble && !sCurrentMenuitem){
3445 sLastMenuitem = sCurrentMenuitem;
3446 WinDestroyWindow(hwndBubble);
3447 }
3448 }
3449 }
3450 }
3451 return oldMenuProc(hwnd, msg, mp1, mp2);
3452}
3453
3454HWND StartArcCnr(HWND hwndParent, HWND hwndCaller, CHAR * arcname, INT flags,
3455 ARC_TYPE * sinfo)
3456{
3457 /*
3458 * bitmapped flags:
3459 * 1 = am extracted from another archive
3460 * 4 = don't kill proc on close
3461 */
3462
3463 HWND hwndFrame = (HWND) 0, hwndClient;
3464 ULONG FrameFlags = FCF_TITLEBAR | FCF_SYSMENU |
3465 FCF_SIZEBORDER | FCF_MINMAX | FCF_ICON | FCF_NOBYTEALIGN | FCF_ACCELTABLE;
3466 USHORT id;
3467 DIRCNRDATA *dcd;
3468 ARC_TYPE *info = sinfo;
3469 CHAR title[MAXNAMEL + 1] = "AV/2 - ";
3470 CHAR fullname[CCHMAXPATH + 8], *p, temp;
3471 static USHORT idinc = 0;
3472
3473 if (!idinc)
3474 idinc = (rand() % 256);
3475 if (ParentIsDesktop(hwndParent, hwndParent))
3476 FrameFlags |= (FCF_TASKLIST | FCF_MENU);
3477 if (arcname) {
3478 DosError(FERR_DISABLEHARDERR);
3479 if (DosQueryPathInfo(arcname,
3480 FIL_QUERYFULLNAME, fullname, sizeof(fullname)))
3481 strcpy(fullname, arcname);
3482 p = fullname;
3483 while (*p) {
3484 if (*p == '/')
3485 *p = '\\';
3486 p++;
3487 }
3488 if (!info)
3489 info = find_type(fullname, arcsighead);
3490 if (!info)
3491 return hwndFrame;
3492 if (strlen(title) + strlen(fullname) > MAXNAMEL) {
3493 p = title + strlen(title);
3494 strncpy(p, fullname, MAXNAMEL / 2 - 5);
3495 strcpy(p + MAXNAMEL / 2 - 5, "...");
3496 strcat(title, fullname + strlen(fullname) - (MAXNAMEL / 2 - 5));
3497 }
3498 else {
3499 strcat(title, fullname);
3500 }
3501 hwndFrame = WinCreateStdWindow(hwndParent,
3502 WS_VISIBLE,
3503 &FrameFlags,
3504 WC_ARCCONTAINER,
3505 title,
3506 WS_VISIBLE | fwsAnimate,
3507 FM3ModHandle, ARC_FRAME, &hwndClient);
3508 if (hwndFrame && hwndClient) {
3509 id = ARC_FRAME + idinc++;
3510 if (idinc > 512)
3511 idinc = 0;
3512 WinSetWindowUShort(hwndFrame, QWS_ID, id);
3513# ifdef FORTIFY
3514 Fortify_EnterScope();
3515# endif
3516 dcd = xmallocz(sizeof(DIRCNRDATA), pszSrcFile, __LINE__);
3517 if (!dcd) {
3518 PostMsg(hwndClient, WM_CLOSE, MPVOID, MPVOID);
3519 hwndFrame = (HWND) 0;
3520 }
3521 else {
3522 dcd->size = sizeof(DIRCNRDATA);
3523 dcd->id = id;
3524 dcd->type = ARC_FRAME;
3525 if (!fUseTmp) {
3526 save_dir2(dcd->workdir);
3527 if (dcd->workdir[strlen(dcd->workdir) - 1] != '\\')
3528 strcat(dcd->workdir, "\\");
3529 sprintf(dcd->workdir + strlen(dcd->workdir), "%s.%03x",
3530 ArcTempRoot, (clock() & 4095));
3531 }
3532 else
3533 sprintf(dcd->workdir, "%s.%03x",
3534 ArcTempRoot, (clock() & 4095));
3535 strcpy(dcd->arcname, fullname);
3536 if (*extractpath) {
3537 if (!strcmp(extractpath, "*")) {
3538 p = strrchr(fullname, '\\');
3539 if (p) {
3540 if (p < fullname + 3)
3541 p++;
3542 temp = *p;
3543 *p = 0;
3544 strcpy(dcd->directory, fullname);
3545 *p = temp;
3546 }
3547 }
3548 else
3549 strcpy(dcd->directory, extractpath);
3550 }
3551 if (!*dcd->directory && *lastextractpath) {
3552 DosEnterCritSec();
3553 strcpy(dcd->directory, lastextractpath);
3554 DosExitCritSec();
3555 }
3556 if (!*dcd->directory) {
3557 if (!ParentIsDesktop(hwndParent, hwndParent))
3558 TopWindowName(hwndParent, hwndCaller, dcd->directory);
3559 if (!*dcd->directory) {
3560 p = strrchr(fullname, '\\');
3561 if (p) {
3562 if (p < fullname + 3)
3563 p++;
3564 *p = 0;
3565 strcpy(dcd->directory, fullname);
3566 }
3567 }
3568 }
3569 if (!*dcd->directory ||
3570 IsFile(dcd->directory) ||
3571 (isalpha(*dcd->directory) &&
3572 (driveflags[toupper(*dcd->directory) - 'A'] &
3573 DRIVE_NOTWRITEABLE)))
3574 save_dir2(dcd->directory);
3575 dcd->hwndParent = hwndParent ? hwndParent : HWND_DESKTOP;
3576 dcd->hwndFrame = hwndFrame;
3577 dcd->hwndClient = hwndClient;
3578 dcd->amextracted = (flags & 1) != 0;
3579 dcd->dontclose = (flags & 4) != 0;
3580 dcd->info = info;
3581 dcd->sortFlags = DefArcSortFlags;
3582 {
3583 PFNWP oldproc;
3584
3585 oldproc = WinSubclassWindow(hwndFrame, (PFNWP) ArcFrameWndProc);
3586 WinSetWindowPtr(hwndFrame, QWL_USER, (PVOID) oldproc);
3587 }
3588 dcd->hwndCnr = WinCreateWindow(hwndClient,
3589 WC_CONTAINER,
3590 NULL,
3591 CCS_AUTOPOSITION | CCS_MINIICONS |
3592 CCS_MINIRECORDCORE | ulCnrType |
3593 WS_VISIBLE,
3594 0,
3595 0,
3596 0,
3597 0,
3598 hwndClient,
3599 HWND_TOP, (ULONG) ARC_CNR, NULL, NULL);
3600 if (!dcd->hwndCnr) {
3601 Win_Error2(hwndClient, hwndClient, pszSrcFile, __LINE__,
3602 IDS_WINCREATEWINDOW);
3603 PostMsg(hwndClient, WM_CLOSE, MPVOID, MPVOID);
3604 free(dcd);
3605# ifdef FORTIFY
3606 Fortify_LeaveScope();
3607# endif
3608 hwndFrame = (HWND) 0;
3609 }
3610 else {
3611 WinSetWindowPtr(dcd->hwndCnr, QWL_USER, (PVOID) dcd);
3612 dcd->oldproc = WinSubclassWindow(dcd->hwndCnr,
3613 (PFNWP) ArcCnrWndProc);
3614 {
3615 USHORT ids[] = { DIR_TOTALS, DIR_SELECTED, DIR_VIEW, DIR_SORT,
3616 DIR_FILTER, DIR_FOLDERICON, 0
3617 };
3618
3619 CommonCreateTextChildren(dcd->hwndClient,
3620 WC_ARCSTATUS, ids);
3621 }
3622 WinEnableWindow(WinWindowFromID(dcd->hwndClient, DIR_VIEW), FALSE);
3623 dcd->hwndExtract = WinCreateWindow(dcd->hwndClient,
3624 WC_ENTRYFIELD,
3625 NULL,
3626 ES_AUTOSCROLL,
3627 0,
3628 0,
3629 0,
3630 0,
3631 dcd->hwndClient,
3632 HWND_TOP,
3633 ARC_EXTRACTDIR, NULL, NULL);
3634 WinSendMsg(dcd->hwndExtract,
3635 EM_SETTEXTLIMIT, MPFROM2SHORT(CCHMAXPATH, 0), MPVOID);
3636 WinSetWindowText(dcd->hwndExtract, dcd->directory);
3637 if (!PostMsg(dcd->hwndCnr, UM_SETUP, MPVOID, MPVOID))
3638 WinSendMsg(dcd->hwndCnr, UM_SETUP, MPVOID, MPVOID);
3639 if (FrameFlags & FCF_MENU) {
3640 PFNWP oldmenuproc;
3641 HWND hwndMenu = WinWindowFromID(hwndFrame, FID_MENU);
3642
3643 oldmenuproc = WinSubclassWindow(hwndMenu, (PFNWP) ArcCnrMenuProc);
3644 WinSetWindowPtr(hwndMenu, QWL_USER, (PVOID) oldmenuproc);
3645 if (!fToolbar) {
3646
3647 if (hwndMenu) {
3648 WinSendMsg(hwndMenu, MM_DELETEITEM,
3649 MPFROM2SHORT(IDM_VIEW, FALSE), MPVOID);
3650 WinSendMsg(hwndMenu, MM_DELETEITEM,
3651 MPFROM2SHORT(IDM_EXEC, FALSE), MPVOID);
3652 WinSendMsg(hwndMenu, MM_DELETEITEM,
3653 MPFROM2SHORT(IDM_RESCAN, FALSE), MPVOID);
3654 WinSendMsg(hwndMenu, MM_DELETEITEM,
3655 MPFROM2SHORT(IDM_DELETE, FALSE), MPVOID);
3656 WinSendMsg(hwndMenu, MM_DELETEITEM,
3657 MPFROM2SHORT(IDM_EXTRACT, FALSE), MPVOID);
3658 WinSendMsg(hwndMenu, MM_DELETEITEM,
3659 MPFROM2SHORT(IDM_TEST, FALSE), MPVOID);
3660 WinSendMsg(hwndMenu, MM_DELETEITEM,
3661 MPFROM2SHORT(IDM_VIRUSSCAN, FALSE), MPVOID);
3662 WinSendMsg(hwndMenu, MM_DELETEITEM,
3663 MPFROM2SHORT(IDM_WALKDIR, FALSE), MPVOID);
3664 WinSendMsg(hwndMenu, MM_DELETEITEM,
3665 MPFROM2SHORT(IDM_FILTER, FALSE), MPVOID);
3666 }
3667 }
3668 }
3669 if (FrameFlags & FCF_TASKLIST) {
3670
3671 SWP swp, swpD;
3672 ULONG size = sizeof(swp);
3673 LONG cxScreen, cyScreen;
3674
3675 WinQueryTaskSizePos(WinQueryAnchorBlock(hwndFrame), 0, &swp);
3676 if (PrfQueryProfileData(fmprof,
3677 appname, "AV2SizePos", &swpD, &size)) {
3678 cxScreen = WinQuerySysValue(HWND_DESKTOP, SV_CXSCREEN);
3679 cyScreen = WinQuerySysValue(HWND_DESKTOP, SV_CYSCREEN);
3680 if (swp.x + swpD.cx > cxScreen)
3681 swp.x = cxScreen - swpD.cx;
3682 if (swp.y + swpD.cy > cyScreen)
3683 swp.y = cyScreen - swpD.cy;
3684 swp.cx = swpD.cx;
3685 swp.cy = swpD.cy;
3686 }
3687 WinSetWindowPos(hwndFrame,
3688 HWND_TOP,
3689 swp.x,
3690 swp.y,
3691 swp.cx,
3692 swp.cy,
3693 SWP_SIZE | SWP_MOVE | SWP_SHOW | SWP_ZORDER |
3694 SWP_ACTIVATE);
3695 }
3696 }
3697 }
3698 }
3699 }
3700 return hwndFrame;
3701}
3702
3703#pragma alloc_text(ARCCNRS,ArcCnrWndProc,ArcObjWndProc,ArcClientWndProc,BldQuotedFullPathName)
3704#pragma alloc_text(ARCCNRS,ArcTextProc,FillArcCnr,ArcFilter,BldQuotedFileName)
3705#pragma alloc_text(ARCCNRS,ArcSort,ArcFrameWndProc,IsArcThere,ArcErrProc)
3706#pragma alloc_text(STARTUP,StartArcCnr)
Note: See TracBrowser for help on using the repository browser.