source: trunk/dll/arccnrs.c@ 1054

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

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