source: trunk/dll/arccnrs.c@ 687

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

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