source: trunk/dll/arccnrs.c@ 1075

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

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