source: trunk/dll/arccnrs.c@ 570

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

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