source: trunk/dll/arccnrs.c@ 689

Last change on this file since 689 was 689, checked in by Steven Levine, 18 years ago

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