source: trunk/dll/arccnrs.c@ 1117

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

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