source: trunk/dll/arccnrs.c@ 562

Last change on this file since 562 was 562, checked in by Gregg Young, 18 years ago

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