source: trunk/dll/arccnrs.c@ 705

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

Minor code cleanup fix ramdisk on states list & WORPLACE_PROCESS logic
  • 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 705 2007-06-24 19:17:37Z gyoung $
5
6 Archive containers
7
8 Copyright (c) 1993-98 M. Kimes
9 Copyright (c) 2001, 2007 Steven H. Levine
10
11 11 Jun 02 SHL Ensure archive name not garbage
12 22 May 03 SHL ArcObjWndProc: fix UM_RESCAN now that we understand it
13 01 Aug 04 SHL Rework lstrip/rstrip usage
14 23 May 05 SHL Use QWL_USER
15 25 May 05 SHL Rename comnam to szCommonName and fix typo
16 25 May 05 SHL Use ULONGLONG and CommaFmtULL
17 05 Jun 05 SHL Drop obsolete, localize
18 05 Jun 05 SHL Correct last sort logic
19 05 Jun 05 SHL Use QWL_USER
20 22 Jun 05 SHL ArcSort: correct typo in last sort fix
21 13 Aug 05 SHL FillArcCnr: optimize
22 08 Dec 05 SHL FillArcCnr: allow list start and end markers to be empty (i.e. tar)
23 08 Dec 05 SHL ArcCnrWndProc: suppress IDM_EXTRACT if no simple extract (i.e. tar)
24 30 Dec 05 SHL ArcCnrWndProc: correct date/time column display setup
25 29 May 06 SHL Comments
26 14 Jul 06 SHL Use Runtime_Error
27 26 Jul 06 SHL Correct SelectAll usage
28 29 Jul 06 SHL Use xfgets_bstripcr
29 31 Jul 06 SHL Lower priority for archives with more than 1000 entries
30 02 Aug 06 SHL Add logic to stop processing large archives
31 23 Aug 06 SHL Integrate John Small's switch list title logic
32 03 Nov 06 SHL Renames
33 14 Mar 07 SHL ArcObjWndProc/UM_ENTER: delay before starting viewer
34 30 Mar 07 GKY Remove GetPString for window class names
35 06 Apr 07 GKY Work around PM DragInfo and DrgFreeISH limit
36 06 Apr 07 GKY Add some error checking in drag/drop
37 20 Apr 07 SHL Sync with NumItemsToUnhilite mods
38 21 Apr 07 GKY Find FM2Utils by path or utils directory
39 12 May 07 SHL Use dcd->ulItemsToUnHilite; sync with UnHilite arg mods
40 10 Jun 07 GKY Add CheckPmDrgLimit including IsFm2Window as part of work around PM drag limit
41 16 Jun 07 SHL Use DosQueryAppType not DosQAppType
42
43***********************************************************************/
44
45#define INCL_DOS
46#define INCL_DOSERRORS
47#define INCL_WIN
48#define INCL_GPI
49#define INCL_LONGLONG
50#include <os2.h>
51
52#include <stdarg.h>
53#include <stdio.h>
54#include <stdlib.h>
55#include <string.h>
56#include <ctype.h>
57#include <time.h>
58#include <direct.h>
59#include <share.h>
60#include <limits.h>
61#include <process.h> // _beginthread
62
63#include "fm3dll.h"
64#include "fm3dlg.h"
65#include "fm3str.h"
66#include "mle.h"
67
68#pragma data_seg(DATA1)
69
70static INT DefArcSortFlags;
71static PSZ pszSrcFile = __FILE__;
72
73#pragma alloc_text(ARCCNRS,ArcCnrWndProc,ArcObjWndProc,ArcClientWndProc)
74#pragma alloc_text(ARCCNRS,ArcTextProc,FillArcCnr,ArcFilter)
75#pragma alloc_text(ARCCNRS,ArcSort,ArcFrameWndProc,IsArcThere,ArcErrProc)
76#pragma alloc_text(STARTUP,StartArcCnr)
77
78static MRESULT EXPENTRY ArcErrProc(HWND hwnd, ULONG msg, MPARAM mp1,
79 MPARAM mp2)
80{
81 ARCDUMP *ad;
82
83 switch (msg) {
84 case WM_INITDLG:
85 if (!mp2)
86 WinDismissDlg(hwnd, 0);
87 else {
88 ad = (ARCDUMP *) mp2;
89 WinSetWindowPtr(hwnd, QWL_USER, ad);
90 if (ad->errmsg)
91 WinSetDlgItemText(hwnd, ARCERR_TEXT, ad->errmsg);
92 if (!ad->info->test)
93 WinEnableWindow(WinWindowFromID(hwnd, ARCERR_TEST), FALSE);
94 if (ad->listname) {
95 MLEsetlimit(WinWindowFromID(hwnd, ARCERR_MLE), -1L);
96 MLEsetformat(WinWindowFromID(hwnd, ARCERR_MLE), MLFIE_NOTRANS);
97 MLEsetcurpos(WinWindowFromID(hwnd, ARCERR_MLE),
98 MLEgetlen(WinWindowFromID(hwnd, ARCERR_MLE)));
99 MLEinsert(WinWindowFromID(hwnd, ARCERR_MLE),
100 GetPString(IDS_ARCHIVERREPORTTEXT));
101 MLEinsertfile(WinWindowFromID(hwnd, ARCERR_MLE), ad->listname);
102 }
103 }
104 break;
105
106 case WM_COMMAND:
107 switch (SHORT1FROMMP(mp1)) {
108 case DID_CANCEL:
109 WinDismissDlg(hwnd, 0);
110 break;
111
112 case IDM_HELP:
113 if (hwndHelp) {
114 WinSendMsg(hwndHelp, HM_DISPLAY_HELP,
115 MPFROM2SHORT(HELP_ARCERR, 0), MPFROMSHORT(HM_RESOURCEID));
116 }
117 break;
118
119 case DID_OK:
120 ad = WinQueryWindowPtr(hwnd, QWL_USER);
121 WinDlgBox(HWND_DESKTOP, hwnd, ArcReviewDlgProc, FM3ModHandle,
122 AD_FRAME, MPFROMP(ad));
123 WinDismissDlg(hwnd, 0);
124 break;
125
126 case ARCERR_VIEW:
127 ad = WinQueryWindowPtr(hwnd, QWL_USER);
128 {
129 CHAR *list[2];
130
131 list[0] = ad->arcname;
132 list[1] = NULL;
133 if (TestBinary(ad->arcname)) {
134 if (*binview)
135 ExecOnList((HWND) 0, binview, WINDOWED | SEPARATE, NULL, list,
136 NULL);
137 else
138 StartMLEEditor(HWND_DESKTOP, 16 + 4 + 1, ad->arcname, hwnd);
139 }
140 else {
141 if (*viewer) {
142 ExecOnList((HWND) 0, viewer, WINDOWED | SEPARATE |
143 (fViewChild ? CHILD : 0),
144 NULL, list, NULL);
145 }
146 else
147 StartMLEEditor(HWND_DESKTOP, 8 + 4 + 1, ad->arcname, hwnd);
148 }
149 }
150 break;
151
152 case ARCERR_TEST:
153 ad = WinQueryWindowPtr(hwnd, QWL_USER);
154 runemf2(SEPARATEKEEP | WINDOWED | MAXIMIZED,
155 hwnd, NULL, NULL, "%s %s%s%s", ad->info->test,
156 needs_quoting(ad->arcname) ? "\"" : NullStr,
157 ad->arcname,
158 needs_quoting(ad->arcname) ? "\"" : NullStr);
159 break;
160 }
161 return 0;
162 }
163 return WinDefDlgProc(hwnd, msg, mp1, mp2);
164}
165
166static SHORT APIENTRY ArcSort(PMINIRECORDCORE pmrc1, PMINIRECORDCORE pmrc2,
167 PVOID pStorage)
168{
169 PARCITEM pai1 = (PARCITEM) pmrc1;
170 PARCITEM pai2 = (PARCITEM) pmrc2;
171 DIRCNRDATA *pdcd = (DIRCNRDATA *) pStorage;
172 SHORT ret = 0;
173 CHAR *pext, *ppext;
174 INT sortFlags;
175
176 if (!pdcd) {
177 HWND hwndCnr = pai1->hwndCnr;
178
179 pdcd = WinQueryWindowPtr(hwndCnr, QWL_USER);
180 if (!pdcd) {
181 Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
182 return ret;
183 }
184 }
185
186 sortFlags = pdcd->sortFlags; // Optimize
187
188 if (sortFlags) {
189 switch (sortFlags & (~SORT_REVERSE)) {
190 case SORT_FIRSTEXTENSION:
191 pext = strchr(pai1->szFileName, '.');
192 ppext = strchr(pai2->szFileName, '.');
193 if (!pext)
194 pext = NullStr;
195 if (!ppext)
196 ppext = NullStr;
197 ret = stricmp(pext, ppext);
198 break;
199
200 case SORT_LASTEXTENSION:
201 pext = strrchr(pai1->szFileName, '.');
202 ppext = strrchr(pai2->szFileName, '.');
203 if (!pext)
204 pext = NullStr;
205 if (!ppext)
206 ppext = NullStr;
207 ret = stricmp(pext, ppext);
208 break;
209
210 case SORT_LWDATE:
211 ret = (pai1->date.year < pai2->date.year) ? 1 :
212 (pai1->date.year > pai2->date.year) ? -1 :
213 (pai1->date.month < pai2->date.month) ? 1 :
214 (pai1->date.month > pai2->date.month) ? -1 :
215 (pai1->date.day < pai2->date.day) ? 1 :
216 (pai1->date.day > pai2->date.day) ? -1 :
217 (pai1->time.hours < pai2->time.hours) ? 1 :
218 (pai1->time.hours > pai2->time.hours) ? -1 :
219 (pai1->time.minutes < pai2->time.minutes) ? 1 :
220 (pai1->time.minutes > pai2->time.minutes) ? -1 :
221 (pai1->time.seconds < pai2->time.seconds) ? 1 :
222 (pai1->time.seconds > pai2->time.seconds) ? -1 : 0;
223 break;
224
225 case SORT_SIZE:
226 ret =
227 (pai1->cbFile < pai2->cbFile) ? 1 : (pai1->cbFile ==
228 pai2->cbFile) ? 0 : -1;
229 if (!ret)
230 ret =
231 (pai1->cbComp < pai2->cbComp) ? 1 : (pai1->cbComp ==
232 pai2->cbComp) ? 0 : -1;
233 break;
234
235 case SORT_EASIZE:
236 ret =
237 (pai1->cbComp < pai2->cbComp) ? 1 : (pai1->cbComp ==
238 pai2->cbComp) ? 0 : -1;
239 if (!ret)
240 ret =
241 (pai1->cbFile < pai2->cbFile) ? 1 : (pai1->cbFile ==
242 pai2->cbFile) ? 0 : -1;
243 break;
244 }
245 if (!ret)
246 ret = (SHORT) stricmp(pai1->szFileName, pai2->szFileName);
247 if (ret && (sortFlags & SORT_REVERSE))
248 ret = ret > 0 ? -1 : 1;
249 return ret;
250 }
251 return (SHORT) stricmp(pai1->szFileName, pai2->szFileName);
252}
253
254static INT APIENTRY ArcFilter(PMINIRECORDCORE rmini, PVOID arg)
255{
256 DIRCNRDATA *dcd = (DIRCNRDATA *) arg;
257 PARCITEM r;
258 register INT x;
259 INT ret = FALSE;
260
261 if (dcd && *dcd->mask.szMask) {
262 r = (PARCITEM) rmini;
263 if (dcd->mask.pszMasks[1]) {
264 for (x = 0; dcd->mask.pszMasks[x]; x++) {
265 if (*dcd->mask.pszMasks[x]) {
266 if (*dcd->mask.pszMasks[x] != '/') {
267 if (wildcard(r->szFileName, dcd->mask.pszMasks[x], FALSE))
268 ret = TRUE;
269 }
270 else {
271 if (wildcard(r->szFileName, dcd->mask.pszMasks[x] + 1, FALSE)) {
272 ret = FALSE;
273 break;
274 }
275 }
276 }
277 }
278 }
279 else {
280 if (wildcard(r->szFileName, dcd->mask.szMask, FALSE))
281 ret = TRUE;
282 }
283 }
284 else
285 ret = TRUE;
286 return ret;
287}
288
289static MRESULT EXPENTRY ArcFrameWndProc(HWND hwnd, ULONG msg, MPARAM mp1,
290 MPARAM mp2)
291{
292 return CommonFrameWndProc(ARC_CNR, hwnd, msg, mp1, mp2);
293}
294
295static BOOL IsArcThere(HWND hwnd, CHAR * arcname)
296{
297 if (arcname) {
298 if (IsFile(arcname) != 1) {
299 saymsg(MB_CANCEL, hwnd,
300 GetPString(IDS_SAYWHATTEXT),
301 GetPString(IDS_ARCNOTTHERETEXT), arcname);
302 return FALSE;
303 }
304 return TRUE;
305 }
306 return FALSE;
307}
308
309//== FillArcCnr() generate archive content list and fill container window ==
310
311static INT FillArcCnr(HWND hwndCnr, CHAR * arcname, ARC_TYPE ** arcinfo,
312 ULONGLONG * pullTotalBytes, volatile PCHAR pStopFlag)
313{
314 FILE *fp;
315 HFILE oldstdout;
316 HFILE newstdout;
317 CHAR s[CCHMAXPATH * 2], lonename[CCHMAXPATH + 2],
318 *nsize, *osize, *fdate, *fname, *p, *pp, arctemp[33];
319 BOOL gotstart;
320 BOOL gotend;
321 BOOL wasquote;
322 BOOL nomove = FALSE; // fixme to be gone?
323 INT highest = 0, x, counter = 0, numarcfiles = 0;
324 PARCITEM lastpai;
325 ARC_TYPE *info;
326 ARC_TYPE *tinfo;
327 ULONG apptype;
328 APIRET rc;
329
330 if (!arcname || !arcinfo)
331 return 0;
332
333 info = *arcinfo;
334 if (!info)
335 info = find_type(arcname, NULL);
336 for (x = 0; x < 99; x++) {
337 sprintf(arctemp, "%s.%03x", ArcTempRoot, (clock() & 4095L));
338 if (IsFile(arctemp) == 1)
339 DosSleep(rand() % 100);
340 else
341 break;
342 }
343
344ReTry:
345
346#ifdef DEBUG
347 if (info && info->id)
348 WinSetWindowText(WinQueryWindow
349 (WinQueryWindow(hwndCnr, QW_PARENT), QW_PARENT),
350 info->id);
351#endif
352
353 tinfo = NULL;
354 numarcfiles = counter = highest = 0;
355 gotstart = gotend = FALSE;
356 lastpai = NULL;
357 *pullTotalBytes = 0;
358 if (!info || !info->list)
359 Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
360 else {
361 WinSendMsg(hwndCnr,
362 CM_REMOVERECORD,
363 MPVOID,
364 MPFROM2SHORT(0, CMA_FREE | CMA_INVALIDATE | CMA_ERASE));
365 *arcinfo = info;
366 highest = info->osizepos;
367 if (info->nsizepos > highest)
368 highest = info->nsizepos;
369 if (info->fdpos > highest)
370 highest = info->fdpos;
371 if (info->fnpos > highest)
372 highest = info->fnpos;
373 if (highest > 50) {
374 saymsg(MB_ENTER | MB_ICONEXCLAMATION, HWND_DESKTOP,
375 GetPString(IDS_SHAMETEXT), "%s", GetPString(IDS_BUNGEDUPTEXT));
376 }
377 if (info->fnpos == -1)
378 highest = 32767;
379
380 DosError(FERR_DISABLEHARDERR);
381 DosForceDelete(arctemp);
382 DosError(FERR_DISABLEHARDERR);
383
384 strcpy(s, info->list);
385 p = strchr(s, ' ');
386 if (p)
387 *p = 0;
388 DosError(FERR_DISABLEHARDERR);
389 if (!DosQueryAppType(s, &apptype) &&
390 (apptype & FAPPTYP_DOS ||
391 apptype & FAPPTYP_WINDOWSREAL ||
392 apptype & FAPPTYP_WINDOWSPROT ||
393 apptype & FAPPTYP_WINDOWSPROT31)) {
394 p = GetCmdSpec(TRUE);
395 runemf2(SEPARATE | INVISIBLE | MINIMIZED | BACKGROUND | WAIT,
396 hwndCnr,
397 NULL,
398 "DOS_BACKGROUND_EXECUTION=1",
399 "%s /C %s %s%s%s > %s",
400 p,
401 info->list,
402 needs_quoting(arcname) ? "\"" : NullStr,
403 arcname,
404 needs_quoting(arcname) ? "\"" : NullStr,
405 arctemp);
406 }
407 else {
408 fp = xfopen(arctemp, "w", pszSrcFile, __LINE__);
409 if (!fp)
410 return 0;
411 else {
412 newstdout = -1;
413 DosError(FERR_DISABLEHARDERR);
414 rc = DosDupHandle(fileno(stdout), &newstdout);
415 if (rc) {
416 Dos_Error(MB_CANCEL, rc, hwndCnr, pszSrcFile, __LINE__,
417 "DosDupHandle");
418 return 0;
419 }
420 else {
421 oldstdout = fileno(stdout);
422 DosError(FERR_DISABLEHARDERR);
423 rc = DosDupHandle(fileno(fp), &oldstdout);
424 if (rc) {
425 Dos_Error(MB_CANCEL, rc, hwndCnr, pszSrcFile, __LINE__,
426 "DosDupHandle");
427 return 0;
428 }
429 else {
430 runemf2(SEPARATE | INVISIBLE | FULLSCREEN | BACKGROUND | WAIT,
431 hwndCnr, NULL, NULL, "%s %s%s%s", info->list,
432 needs_quoting(arcname) ? "\"" : NullStr,
433 arcname,
434 needs_quoting(arcname) ? "\"" : NullStr);
435 oldstdout = fileno(stdout);
436 DosError(FERR_DISABLEHARDERR);
437 DosDupHandle(newstdout, &oldstdout);
438 DosClose(newstdout);
439 fclose(fp);
440 }
441 }
442 }
443 }
444
445 DosError(FERR_DISABLEHARDERR);
446 fp = _fsopen(arctemp, "r", SH_DENYWR);
447
448 if (fp) {
449 gotstart = !info->startlist || !*info->startlist; // If list has no start marker
450
451 while (!feof(fp) && !gotend && !*pStopFlag) {
452 if (!xfgets_bstripcr(s, sizeof(s), fp, pszSrcFile, __LINE__))
453 break;
454 if (!gotstart) {
455 if (!strcmp(s, info->startlist))
456 gotstart = TRUE;
457 }
458 else if (info->endlist && !strcmp(s, info->endlist))
459 gotend = TRUE;
460 else {
461 /* add to container */
462 fname = NULL;
463 bstrip(s);
464 if (info->nameisfirst) {
465 strncpy(lonename, s, CCHMAXPATH + 2);
466 lonename[CCHMAXPATH + 1] = 0;
467 fname = lonename;
468 if (!xfgets_bstripcr(s, sizeof(s), fp, pszSrcFile, __LINE__))
469 break;
470 if (*fname == '\"') {
471 memmove(fname, fname + 1, strlen(fname) + 1);
472 p = strchr(fname, '\"');
473 if (p)
474 *p = 0;
475 }
476 }
477 nsize = NULL;
478 osize = fdate = NullStr;
479 p = s;
480 for (x = 0; x <= highest; x++) {
481 pp = p;
482 while (*pp && (*pp == ' ' || *pp == '\t')) /* skip leading */
483 pp++;
484 if (!*pp)
485 break;
486 wasquote = FALSE;
487 p = pp;
488 while (*p && (wasquote ||
489 ((x != info->fnpos || !info->nameislast) ?
490 (*p != ' ' && *p != '\t') : TRUE))) {
491 if (*p == '\"') {
492 if (!wasquote) {
493 wasquote = TRUE;
494 memmove(p, p + 1, strlen(p));
495 while (*p == ' ' || *p == '\t')
496 p++;
497 }
498 else {
499 memmove(p, p + 1, strlen(p));
500 break;
501 }
502 }
503 else if (*p)
504 p++;
505 }
506 if (*p) {
507 *p = 0;
508 p++;
509 }
510 if (x == info->nsizepos)
511 nsize = pp;
512 else if (x == info->osizepos)
513 osize = pp;
514 else if (x == info->fdpos) {
515 fdate = pp;
516 if (info->fdflds > 1 && info->fdflds < 24) {
517 INT y;
518
519 if (*p) {
520 p--;
521 *p = ' ';
522 for (y = 0; y < info->fdflds - 1; y++) {
523 while (*p && (*p == ' ' || *p == '\t'))
524 p++;
525 while (*p && (*p != ' ' && *p != '\t'))
526 p++;
527 x++;
528 }
529 if (*p) {
530 *p = 0;
531 p++;
532 }
533 }
534 }
535 }
536 else if (x == info->fnpos) {
537 fname = pp;
538 if (pp && *pp == '*' && !*(pp + 1)) /* workaround for LH.EXE */
539 fname = NULL;
540 if (info->nameislast)
541 break;
542 }
543 else if ((!p || !*p) && info->fnpos == -1) {
544 fname = pp;
545 break;
546 }
547 }
548 if (info->nameisnext) {
549 if (!xfgets_bstripcr
550 (lonename, sizeof(lonename), fp, pszSrcFile, __LINE__))
551 break;
552 fname = lonename;
553 }
554 // fixme to complain?
555 if (fname && *fname) {
556
557 RECORDINSERT ri;
558 PARCITEM pai;
559
560#ifdef DEBUG
561 saymsg(MB_ENTER, hwndCnr, DEBUG_STRING,
562 "fname: %s\r\rpp: %s\r\rp: %s\r\rlonename: %s\r\rhighest: %ld\r\rx: %ld\r\rfdate: %s",
563 fname ? fname : "NULL",
564 pp ? pp : "NULL",
565 p ? p : "NULL",
566 lonename, highest, x, (fdate) ? fdate : "NULL");
567#endif
568
569 pai = WinSendMsg(hwndCnr,
570 CM_ALLOCRECORD,
571 MPFROMLONG(EXTRA_ARCRECORD_BYTES),
572 MPFROMLONG(1L));
573 if (!pai) {
574 Runtime_Error(pszSrcFile, __LINE__, "CM_ALLOCRECORD");
575 break;
576 }
577 else {
578 memset(pai, 0, sizeof(ARCITEM));
579 pai->hwndCnr = hwndCnr;
580 if (*fname == '*') {
581 fname++;
582 pai->flags = ARCFLAGS_REALDIR;
583 }
584 if (fname[strlen(fname) - 1] == '\\' ||
585 fname[strlen(fname) - 1] == '/')
586 pai->flags = ARCFLAGS_REALDIR;
587 strcpy(pai->szFileName, fname);
588 if (fdate)
589 strcpy(pai->szDate, fdate);
590 pai->pszFileName = pai->szFileName;
591 pai->rc.pszIcon = pai->pszFileName;
592 pai->rc.hptrIcon = (pai->flags & ARCFLAGS_REALDIR) != 0 ?
593 hptrDir : hptrFile;
594 pai->pszDate = pai->szDate;
595 if (osize)
596 pai->cbFile = atol(osize);
597 if (nsize)
598 pai->cbComp = atol(nsize);
599 if (info->datetype && fdate && *fdate)
600 ArcDateTime(fdate, info->datetype, &pai->date, &pai->time);
601 memset(&ri, 0, sizeof(RECORDINSERT));
602 ri.cb = sizeof(RECORDINSERT);
603 ri.pRecordOrder = (PRECORDCORE) CMA_END;
604 ri.pRecordParent = (PRECORDCORE) NULL;
605 ri.zOrder = (USHORT) CMA_TOP;
606 ri.cRecordsInsert = 1L;
607 ri.fInvalidateRecord = FALSE;
608 if (WinSendMsg(hwndCnr,
609 CM_INSERTRECORD, MPFROMP(pai), MPFROMP(&ri))) {
610 *pullTotalBytes += pai->cbFile;
611 }
612 numarcfiles++;
613 if (!(++counter % 50)) {
614 if (!lastpai)
615 lastpai = pai;
616 WinSendMsg(hwndCnr,
617 CM_INVALIDATERECORD,
618 lastpai,
619 MPFROM2SHORT(10, CMA_ERASE | CMA_REPOSITION));
620 lastpai = pai;
621 }
622 // Avoid hogging system for large archive
623 if (numarcfiles == 100)
624 priority_idle();
625 }
626 }
627 }
628 } // while !eof
629
630 fclose(fp);
631
632 if (*pStopFlag)
633 numarcfiles = 0; // Request close
634 else if (!numarcfiles || !gotstart
635 || (!gotend && info->endlist && *info->endlist)) {
636 // Oops
637 ARCDUMP ad;
638 CHAR errstr[CCHMAXPATH + 256];
639
640 // Try for alternate archiver
641 tinfo = info;
642 do {
643 tinfo = tinfo->next;
644 if (tinfo)
645 tinfo = find_type(arcname, tinfo);
646 if (tinfo) {
647 DosError(FERR_DISABLEHARDERR);
648 DosForceDelete(arctemp);
649 info = tinfo;
650 goto ReTry;
651 }
652 } while (tinfo);
653 DosBeep(750, 50); // wake up user
654 sprintf(errstr, GetPString(IDS_ARCERRORINFOTEXT),
655 arcname,
656 !gotstart ? GetPString(IDS_NOGOTSTARTTEXT) : NullStr,
657 !numarcfiles ? GetPString(IDS_NOARCFILESFOUNDTEXT) :
658 NullStr,
659 !gotend ? GetPString(IDS_NOENDOFLISTTEXT) : NullStr);
660 memset(&ad, 0, sizeof(ARCDUMP));
661 ad.info = info;
662 strcpy(ad.listname, arctemp);
663 strcpy(ad.arcname, arcname);
664 ad.errmsg = errstr;
665 WinDlgBox(HWND_DESKTOP,
666 hwndCnr,
667 ArcErrProc, FM3ModHandle, ARCERR_FRAME, MPFROMP(&ad));
668 }
669 else if (!nomove && tinfo) {
670 /* if we got a false hit, move working hit to top */
671 tinfo = info->next;
672 info->next = arcsighead;
673 arcsighead->prev = info;
674 if (tinfo)
675 tinfo->next->prev = info->prev;
676 info->prev->next = tinfo;
677 info->prev = NULL;
678 arcsighead = info;
679 rewrite_archiverbb2(NULL); // Rewrite with warning
680 }
681 } // if opened
682
683 DosError(FERR_DISABLEHARDERR);
684 DosForceDelete(arctemp);
685 }
686
687 if (numarcfiles)
688 priority_normal();
689
690 return numarcfiles;
691}
692
693MRESULT EXPENTRY ArcTextProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
694{
695 static BOOL emphasized = FALSE;
696 static HWND hwndButtonPopup = (HWND) 0;
697 static ULONG timestamp = ULONG_MAX;
698 static USHORT lastid = 0;
699
700 switch (msg) {
701 case WM_CREATE:
702 return CommonTextProc(hwnd, msg, mp1, mp2);
703
704 case WM_COMMAND:
705 return WinSendMsg(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
706 ARC_CNR), msg, mp1, mp2);
707
708 case UM_CONTEXTMENU:
709 case WM_CONTEXTMENU:
710 {
711 USHORT id;
712
713 id = WinQueryWindowUShort(hwnd, QWS_ID);
714 switch (id) {
715 case DIR_SELECTED:
716 case DIR_VIEW:
717 case DIR_SORT:
718 {
719 POINTL ptl = { 0, 0 };
720 SWP swp;
721 DIRCNRDATA *dcd;
722
723 if (hwndButtonPopup)
724 WinDestroyWindow(hwndButtonPopup);
725 if (id == DIR_SELECTED)
726 id = DIR_RESTORE;
727 if (id == lastid) {
728
729 ULONG check;
730
731 DosQuerySysInfo(QSV_MS_COUNT, QSV_MS_COUNT, &check,
732 sizeof(check));
733 if (check < timestamp + 500) {
734 lastid = 0;
735 goto MenuAbort;
736 }
737 }
738 hwndButtonPopup = WinLoadMenu(HWND_DESKTOP, FM3ModHandle, id);
739 if (hwndButtonPopup) {
740 WinSetWindowUShort(hwndButtonPopup, QWS_ID, id);
741 dcd = WinQueryWindowPtr(WinWindowFromID(WinQueryWindow(hwnd,
742 QW_PARENT),
743 ARC_CNR), QWL_USER);
744 if (id == DIR_SORT) {
745 if (dcd)
746 SetSortChecks(hwndButtonPopup, dcd->sortFlags);
747 WinSendMsg(hwndButtonPopup,
748 MM_DELETEITEM,
749 MPFROM2SHORT(IDM_SORTNONE, FALSE), MPVOID);
750 WinSendMsg(hwndButtonPopup,
751 MM_DELETEITEM,
752 MPFROM2SHORT(IDM_SORTNAME, FALSE), MPVOID);
753 WinSendMsg(hwndButtonPopup,
754 MM_DELETEITEM,
755 MPFROM2SHORT(IDM_SORTLADATE, FALSE), MPVOID);
756 WinSendMsg(hwndButtonPopup,
757 MM_DELETEITEM,
758 MPFROM2SHORT(IDM_SORTCRDATE, FALSE), MPVOID);
759 WinSendMsg(hwndButtonPopup,
760 MM_DELETEITEM,
761 MPFROM2SHORT(IDM_SORTDIRSFIRST, FALSE), MPVOID);
762 WinSendMsg(hwndButtonPopup,
763 MM_DELETEITEM,
764 MPFROM2SHORT(IDM_SORTDIRSLAST, FALSE), MPVOID);
765 WinSendMsg(hwndButtonPopup,
766 MM_DELETEITEM,
767 MPFROM2SHORT(IDM_SORTSUBJECT, FALSE), MPVOID);
768 WinSendMsg(hwndButtonPopup,
769 MM_SETITEMTEXT,
770 MPFROM2SHORT(IDM_SORTEASIZE, 0),
771 MPFROMP(GetPString(IDS_COMPRESSEDSIZEMENUTEXT)));
772 WinSendMsg(hwndButtonPopup,
773 MM_SETITEMTEXT,
774 MPFROM2SHORT(IDM_SORTLWDATE, 0),
775 MPFROMP(GetPString(IDS_DATEMENUTEXT)));
776 }
777 ptl.x = 0;
778 if (WinPopupMenu(HWND_OBJECT,
779 HWND_OBJECT,
780 hwndButtonPopup, -32767, -32767, 0, 0)) {
781 WinQueryWindowPos(hwndButtonPopup, &swp);
782 ptl.y = -(swp.cy + 2);
783 }
784 else {
785 WinQueryWindowPos(hwnd, &swp);
786 ptl.y = swp.cy + 2;
787 }
788 if (WinPopupMenu(hwnd,
789 hwnd,
790 hwndButtonPopup,
791 ptl.x,
792 ptl.y,
793 0,
794 PU_HCONSTRAIN | PU_VCONSTRAIN |
795 PU_KEYBOARD | PU_MOUSEBUTTON1)) {
796 CenterOverWindow(hwndButtonPopup);
797 PaintRecessedWindow(hwnd, (HPS) 0, FALSE, FALSE);
798 }
799 }
800 }
801 break;
802 default:
803 PostMsg(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
804 ARC_CNR),
805 WM_CONTROL, MPFROM2SHORT(ARC_CNR, CN_CONTEXTMENU), MPVOID);
806 break;
807 }
808 }
809 MenuAbort:
810 if (msg == UM_CONTEXTMENU)
811 return 0;
812 break;
813
814 case WM_MENUEND:
815 if (hwndButtonPopup == (HWND) mp2) {
816 lastid = WinQueryWindowUShort((HWND) mp2, QWS_ID);
817 WinDestroyWindow(hwndButtonPopup);
818 hwndButtonPopup = (HWND) 0;
819 DosQuerySysInfo(QSV_MS_COUNT, QSV_MS_COUNT, &timestamp,
820 sizeof(timestamp));
821 switch (lastid) {
822 case DIR_VIEW:
823 case DIR_SORT:
824 case DIR_RESTORE:
825 case DIR_SELECTED:
826 PaintRecessedWindow(hwnd, (HPS) 0, TRUE, FALSE);
827 break;
828 }
829 }
830 break;
831
832 case WM_MOUSEMOVE:
833 {
834 USHORT id = WinQueryWindowUShort(hwnd, QWS_ID);
835 char *s = NULL;
836
837 if (fOtherHelp) {
838 if ((!hwndBubble ||
839 WinQueryWindowULong(hwndBubble, QWL_USER) != hwnd) &&
840 !WinQueryCapture(HWND_DESKTOP)) {
841 switch (id) {
842 case DIR_TOTALS:
843 s = GetPString(IDS_ARCCNRTOTALSHELPTEXT);
844 break;
845 case DIR_SELECTED:
846 s = GetPString(IDS_ARCCNRSELECTEDHELPTEXT);
847 break;
848 case DIR_VIEW:
849 s = GetPString(IDS_ARCCNRVIEWHELPTEXT);
850 break;
851 case DIR_SORT:
852 s = GetPString(IDS_DIRCNRSORTHELP);
853 break;
854 case DIR_FILTER:
855 s = GetPString(IDS_DIRCNRFILTERHELP);
856 break;
857 case DIR_FOLDERICON:
858 s = GetPString(IDS_ARCCNRFOLDERHELPTEXT);
859 break;
860 default:
861 break;
862 }
863 if (s)
864 MakeBubble(hwnd, TRUE, s);
865 else if (hwndBubble)
866 WinDestroyWindow(hwndBubble);
867 }
868 }
869 switch (id) {
870 case DIR_FILTER:
871 case DIR_SORT:
872 case DIR_VIEW:
873 case DIR_SELECTED:
874 case DIR_FOLDERICON:
875 return CommonTextButton(hwnd, msg, mp1, mp2);
876 }
877 }
878 break;
879
880 case WM_BUTTON3UP:
881 case WM_BUTTON1UP:
882 case WM_BUTTON1DOWN:
883 case WM_BUTTON3DOWN:
884 {
885 USHORT id;
886
887 id = WinQueryWindowUShort(hwnd, QWS_ID);
888 switch (id) {
889 case DIR_FILTER:
890 case DIR_SORT:
891 case DIR_VIEW:
892 case DIR_SELECTED:
893 case DIR_FOLDERICON:
894 return CommonTextButton(hwnd, msg, mp1, mp2);
895 }
896 }
897 break;
898
899 case UM_CLICKED:
900 case UM_CLICKED3:
901 {
902 USHORT id, cmd = 0;
903
904 id = WinQueryWindowUShort(hwnd, QWS_ID);
905 switch (id) {
906 case DIR_FOLDERICON:
907 switch (msg) {
908 case WM_BUTTON3CLICK:
909 case WM_CHORD:
910 cmd = IDM_RESCAN;
911 break;
912 default:
913 if ((SHORT2FROMMP(mp2) & KC_ALT) != 0)
914 cmd = IDM_WINDOWDLG;
915 else
916 cmd = IDM_WALKDIR;
917 break;
918 }
919 break;
920 case DIR_VIEW:
921 case DIR_SORT:
922 case DIR_SELECTED:
923 PostMsg(hwnd, UM_CONTEXTMENU, MPVOID, MPVOID);
924 break;
925 case DIR_FILTER:
926 cmd = IDM_FILTER;
927 break;
928 default:
929 break;
930 }
931 if (cmd)
932 PostMsg(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
933 ARC_CNR),
934 WM_COMMAND, MPFROM2SHORT(cmd, 0), MPVOID);
935 }
936 return 0;
937
938 case WM_BEGINDRAG:
939 case DM_DROP:
940 case DM_DRAGOVER:
941 case DM_DRAGLEAVE:
942 case DM_DROPHELP:
943 if (msg == DM_DRAGOVER) {
944 if (!emphasized) {
945 emphasized = TRUE;
946 DrawTargetEmphasis(hwnd, emphasized);
947 }
948 }
949 else if (msg != WM_BEGINDRAG) {
950 if (emphasized) {
951 emphasized = FALSE;
952 DrawTargetEmphasis(hwnd, emphasized);
953 }
954 }
955 switch (WinQueryWindowUShort(hwnd, QWS_ID)) {
956 case DIR_FOLDERICON:
957 switch (msg) {
958 case DM_DRAGOVER:
959 if (AcceptOneDrop(hwnd, mp1, mp2))
960 return MRFROM2SHORT(DOR_DROP, DO_MOVE);
961 return MRFROM2SHORT(DOR_NODROP, 0); /* Drop not valid */
962 case DM_DROPHELP:
963 DropHelp(mp1, mp2, hwnd, GetPString(IDS_ARCCNRFOLDERDROPHELPTEXT));
964 return 0;
965 case DM_DROP:
966 {
967 char szFrom[CCHMAXPATH + 2];
968
969 if (emphasized) {
970 emphasized = FALSE;
971 DrawTargetEmphasis(hwnd, emphasized);
972 }
973 if (GetOneDrop(hwnd, mp1, mp2, szFrom, sizeof(szFrom)))
974 WinSendMsg(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
975 ARC_CNR),
976 WM_COMMAND,
977 MPFROM2SHORT(IDM_SWITCH, 0), MPFROMP(szFrom));
978 }
979 return 0;
980 default:
981 return PFNWPStatic(hwnd, msg, mp1, mp2);
982 }
983 default:
984 {
985 CNRDRAGINFO cnd;
986 USHORT dcmd;
987
988 switch (msg) {
989 case DM_DROP:
990 dcmd = CN_DROP;
991 break;
992 case DM_DRAGOVER:
993 dcmd = CN_DRAGOVER;
994 break;
995 case DM_DRAGLEAVE:
996 dcmd = CN_DRAGLEAVE;
997 break;
998 case DM_DROPHELP:
999 dcmd = CN_DROPHELP;
1000 break;
1001 case WM_BEGINDRAG:
1002 dcmd = CN_INITDRAG;
1003 break;
1004 }
1005 cnd.pDragInfo = (PDRAGINFO) mp1;
1006 cnd.pRecord = NULL;
1007 return WinSendMsg(WinQueryWindow(hwnd, QW_PARENT),
1008 WM_CONTROL,
1009 MPFROM2SHORT(ARC_CNR, dcmd), MPFROMP(&cnd));
1010 }
1011 }
1012 }
1013 return PFNWPStatic(hwnd, msg, mp1, mp2);
1014}
1015
1016MRESULT EXPENTRY ArcClientWndProc(HWND hwnd, ULONG msg, MPARAM mp1,
1017 MPARAM mp2)
1018{
1019
1020 switch (msg) {
1021 case UM_CONTAINERHWND:
1022 return MRFROMLONG(WinWindowFromID(hwnd, ARC_CNR));
1023
1024 case UM_VIEWSMENU:
1025 // fixme to disble menu items as needed
1026 return MRFROMLONG(CheckMenu(&ArcCnrMenu, ARCCNR_POPUP));
1027
1028 case UM_FILESMENU:
1029 // fixme to disble menu items as needed
1030 return MRFROMLONG(CheckMenu(&ArcMenu, ARC_POPUP));
1031
1032 case MM_PORTHOLEINIT:
1033 case WM_INITMENU:
1034 case UM_INITMENU:
1035 case UM_COMMAND:
1036 case UM_LOADFILE:
1037 case UM_UPDATERECORD:
1038 case UM_UPDATERECORDLIST:
1039 case WM_COMMAND:
1040 case WM_CONTROL:
1041 case WM_CLOSE:
1042 return WinSendMsg(WinWindowFromID(hwnd, ARC_CNR), msg, mp1, mp2);
1043
1044 case WM_PSETFOCUS:
1045 case WM_SETFOCUS:
1046 if (mp2)
1047 PostMsg(hwnd, UM_FOCUSME, MPVOID, MPVOID);
1048 break;
1049
1050 case UM_FOCUSME:
1051 WinSetFocus(HWND_DESKTOP, WinWindowFromID(hwnd, ARC_CNR));
1052 break;
1053
1054 case WM_PAINT:
1055 {
1056 HPS hps;
1057 RECTL rcl;
1058
1059 hps = WinBeginPaint(hwnd, (HPS) 0, NULL);
1060 if (hps) {
1061 WinQueryWindowRect(hwnd, &rcl);
1062 WinFillRect(hps, &rcl, CLR_PALEGRAY);
1063 CommonTextPaint(hwnd, hps);
1064 WinEndPaint(hps);
1065 }
1066 }
1067 break;
1068
1069 case UM_SIZE:
1070 case WM_SIZE:
1071 if (msg == UM_SIZE) {
1072
1073 SWP swp;
1074
1075 WinQueryWindowPos(hwnd, &swp);
1076 mp1 = MPFROM2SHORT(swp.cx, swp.cy);
1077 mp2 = MPFROM2SHORT(swp.cx, swp.cy);
1078 }
1079 {
1080 USHORT cx, cy, bx;
1081
1082 cx = SHORT1FROMMP(mp2);
1083 cy = SHORT2FROMMP(mp2);
1084 WinSetWindowPos(WinWindowFromID(hwnd, ARC_CNR), HWND_TOP,
1085 0,
1086 22, cx, cy - (24 + 22), SWP_SHOW | SWP_MOVE | SWP_SIZE);
1087 WinSetWindowPos(WinWindowFromID(hwnd, ARC_EXTRACTDIR), HWND_TOP,
1088 0, 0, cx, 22, SWP_SHOW | SWP_MOVE | SWP_SIZE);
1089 WinSetWindowPos(WinWindowFromID(hwnd, DIR_FOLDERICON), HWND_TOP,
1090 2, cy - 22, 24, 20, SWP_SHOW | SWP_MOVE | SWP_SIZE);
1091 WinSetWindowPos(WinWindowFromID(hwnd, DIR_TOTALS), HWND_TOP,
1092 29,
1093 cy - 22,
1094 (cx / 3) - 2, 20, SWP_SHOW | SWP_MOVE | SWP_SIZE);
1095 WinSetWindowPos(WinWindowFromID(hwnd, DIR_SELECTED), HWND_TOP,
1096 29 + (cx / 3) + 2,
1097 cy - 22,
1098 (cx / 3) - 2, 20, SWP_SHOW | SWP_MOVE | SWP_SIZE);
1099 bx = (cx - (29 + (((cx / 3) + 2) * 2))) / 3;
1100 WinSetWindowPos(WinWindowFromID(hwnd, DIR_VIEW), HWND_TOP,
1101 29 + (((cx / 3) + 2) * 2),
1102 cy - 22, bx - 4, 20, SWP_SHOW | SWP_MOVE | SWP_SIZE);
1103 WinSetWindowPos(WinWindowFromID(hwnd, DIR_SORT), HWND_TOP,
1104 29 + (((cx / 3) + 2) * 2) + bx,
1105 cy - 22, bx - 4, 20, SWP_SHOW | SWP_MOVE | SWP_SIZE);
1106 WinSetWindowPos(WinWindowFromID(hwnd, DIR_FILTER), HWND_TOP,
1107 29 + (((cx / 3) + 2) * 2) + (bx * 2),
1108 cy - 22, bx - 4, 20, SWP_SHOW | SWP_MOVE | SWP_SIZE);
1109 }
1110 CommonTextPaint(hwnd, (HPS) 0);
1111 if (msg == UM_SIZE) {
1112 WinSetWindowPos(WinQueryWindow(hwnd, QW_PARENT), HWND_TOP, 0, 0, 0, 0,
1113 SWP_SHOW | SWP_ZORDER | SWP_ACTIVATE);
1114 return 0;
1115 }
1116 break;
1117 }
1118 return WinDefWindowProc(hwnd, msg, mp1, mp2);
1119}
1120
1121MRESULT EXPENTRY ArcObjWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
1122{
1123 DIRCNRDATA *dcd;
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
1940 switch (msg) {
1941 case DM_PRINTOBJECT:
1942 case DM_DISCARDOBJECT:
1943 if (dcd)
1944 return WinSendMsg(dcd->hwndObject, msg, mp1, mp2);
1945 else
1946 return MRFROMLONG(DRR_TARGET);
1947
1948 case WM_CHAR:
1949 shiftstate = (SHORT1FROMMP(mp1) & (KC_SHIFT | KC_ALT | KC_CTRL));
1950 if (SHORT1FROMMP(mp1) & KC_KEYUP)
1951 return (MRESULT) TRUE;
1952 if (SHORT1FROMMP(mp1) & KC_VIRTUALKEY) {
1953 switch (SHORT2FROMMP(mp2)) {
1954 case VK_DELETE:
1955 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_DELETE, 0), MPVOID);
1956 break;
1957 }
1958 }
1959 if (shiftstate || fNoSearch)
1960 break;
1961 if (SHORT1FROMMP(mp1) & KC_CHAR) {
1962
1963 ULONG thistime, len;
1964 SEARCHSTRING srch;
1965 PCNRITEM pci;
1966
1967 if (!dcd)
1968 break;
1969 switch (SHORT1FROMMP(mp2)) {
1970 case '\x1b':
1971 case '\r':
1972 case '\n':
1973 dcd->lasttime = 0;
1974 *dcd->szCommonName = 0;
1975 break;
1976 default:
1977 thistime = WinQueryMsgTime(WinQueryAnchorBlock(hwnd));
1978 if (thistime > dcd->lasttime + 1250)
1979 *dcd->szCommonName = 0;
1980 dcd->lasttime = thistime;
1981 if (SHORT1FROMMP(mp2) == ' ' && !*dcd->szCommonName)
1982 break;
1983 KbdRetry:
1984 len = strlen(dcd->szCommonName);
1985 if (len >= CCHMAXPATH - 1) {
1986 *dcd->szCommonName = 0;
1987 len = 0;
1988 }
1989 dcd->szCommonName[len] = toupper(SHORT1FROMMP(mp2));
1990 dcd->szCommonName[len + 1] = 0;
1991 memset(&srch, 0, sizeof(SEARCHSTRING));
1992 srch.cb = (ULONG) sizeof(SEARCHSTRING);
1993 srch.pszSearch = dcd->szCommonName;
1994 srch.fsPrefix = TRUE;
1995 srch.fsCaseSensitive = FALSE;
1996 srch.usView = CV_ICON;
1997 pci = WinSendMsg(hwnd,
1998 CM_SEARCHSTRING,
1999 MPFROMP(&srch), MPFROMLONG(CMA_FIRST));
2000 if (pci && (INT) pci != -1) {
2001
2002 USHORT attrib = CRA_CURSORED;
2003
2004 /* make found item current item */
2005 if (!stricmp(pci->pszFileName, dcd->szCommonName))
2006 attrib |= CRA_SELECTED;
2007 WinSendMsg(hwnd,
2008 CM_SETRECORDEMPHASIS,
2009 MPFROMP(pci), MPFROM2SHORT(TRUE, attrib));
2010 /* make sure that record shows in viewport */
2011 ShowCnrRecord(hwnd, (PMINIRECORDCORE) pci);
2012 return (MRESULT) TRUE;
2013 }
2014 else {
2015 if (SHORT1FROMMP(mp2) == ' ') {
2016 dcd->szCommonName[len] = 0;
2017 break;
2018 }
2019 *dcd->szCommonName = 0;
2020 dcd->lasttime = 0;
2021 if (len) // retry as first letter if no match
2022 goto KbdRetry;
2023 }
2024 break;
2025 }
2026 }
2027 break;
2028
2029 case WM_MOUSEMOVE:
2030 case WM_BUTTON1UP:
2031 case WM_BUTTON2UP:
2032 case WM_BUTTON3UP:
2033 case WM_CHORD:
2034 shiftstate = (SHORT2FROMMP(mp2) & (KC_SHIFT | KC_ALT | KC_CTRL));
2035 break;
2036
2037 case WM_BUTTON1MOTIONEND:
2038 {
2039 CNRINFO cnri;
2040
2041 memset(&cnri, 0, sizeof(CNRINFO));
2042 cnri.cb = sizeof(CNRINFO);
2043 if (WinSendMsg(hwnd,
2044 CM_QUERYCNRINFO,
2045 MPFROMP(&cnri), MPFROMLONG(sizeof(CNRINFO)))) {
2046 if (cnri.flWindowAttr & CV_DETAIL)
2047 PrfWriteProfileData(fmprof,
2048 appname,
2049 "ArcCnrSplitBar",
2050 (PVOID) & cnri.xVertSplitbar, sizeof(LONG));
2051 }
2052 }
2053 break;
2054
2055 case WM_PRESPARAMCHANGED:
2056 PresParamChanged(hwnd, "ArcCnr", mp1, mp2);
2057 break;
2058
2059 case UM_UPDATERECORD:
2060 case UM_UPDATERECORDLIST:
2061 if (dcd && !IsArcThere(hwnd, dcd->arcname))
2062 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
2063 return 0;
2064
2065 case WM_SETFOCUS:
2066 /*
2067 * put name of our window (archive name) on status line
2068 */
2069 if (dcd && hwndStatus && mp2)
2070 WinSendMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
2071 break;
2072
2073 case UM_SETUP2:
2074 if (dcd && dcd->info) {
2075 if (dcd->info->fdpos == -1 || !dcd->info->datetype)
2076 dcd->sortFlags &= (~SORT_LWDATE);
2077 if (dcd->info->nsizepos == -1)
2078 dcd->sortFlags &= (~SORT_EASIZE);
2079 if (dcd->info->osizepos == -1)
2080 dcd->sortFlags &= (~SORT_SIZE);
2081 AdjustCnrColVis(hwnd,
2082 GetPString(IDS_OLDSIZECOLTEXT),
2083 dcd->info->osizepos != -1, FALSE);
2084 AdjustCnrColVis(hwnd,
2085 GetPString(IDS_NEWSIZECOLTEXT),
2086 dcd->info->nsizepos != -1, FALSE);
2087 // Display unsullied date/time string if type 0
2088 AdjustCnrColVis(hwnd,
2089 GetPString(IDS_DATETIMECOLTEXT),
2090 dcd->info->fdpos != -1 && !dcd->info->datetype, FALSE);
2091 // Display parsed date/time columns if type specified
2092 AdjustCnrColVis(hwnd,
2093 GetPString(IDS_TIMECOLTEXT),
2094 dcd->info->fdpos != -1 && dcd->info->datetype, FALSE);
2095 AdjustCnrColVis(hwnd,
2096 GetPString(IDS_DATECOLTEXT),
2097 dcd->info->fdpos != -1 && dcd->info->datetype, FALSE);
2098 WinSendMsg(hwnd, CM_INVALIDATEDETAILFIELDINFO, MPVOID, MPVOID);
2099 }
2100 return 0;
2101
2102 case UM_RESCAN:
2103 if (dcd) {
2104 CNRINFO cnri;
2105 CHAR s[CCHMAXPATH * 2], tb[81], tf[81];
2106 PARCITEM pci;
2107
2108 if (mp1) {
2109 PostMsg(dcd->hwndObject, UM_RESCAN, MPVOID, MPVOID);
2110 return 0;
2111 }
2112 memset(&cnri, 0, sizeof(CNRINFO));
2113 cnri.cb = sizeof(CNRINFO);
2114 WinSendMsg(hwnd,
2115 CM_QUERYCNRINFO,
2116 MPFROMP(&cnri), MPFROMLONG(sizeof(CNRINFO)));
2117 dcd->totalfiles = cnri.cRecords;
2118 commafmt(tf, sizeof(tf), dcd->selectedfiles);
2119 if (dcd->ullTotalBytes)
2120 CommaFmtULL(tb, sizeof(tb), dcd->selectedbytes, 'K');
2121 else
2122 *tb = 0;
2123 sprintf(s, "%s%s%s", tf, *tb ? " / " : NullStr, tb);
2124 WinSetDlgItemText(dcd->hwndClient, DIR_SELECTED, s);
2125 commafmt(tf, sizeof(tf), dcd->totalfiles);
2126 if (dcd->ullTotalBytes)
2127 CommaFmtULL(tb, sizeof(tb), dcd->ullTotalBytes, 'K');
2128 else
2129 *tb = 0;
2130 sprintf(s, "%s%s%s", tf, *tb ? " / " : NullStr, tb);
2131 WinSetDlgItemText(dcd->hwndClient, DIR_TOTALS, s);
2132 if (hwndStatus &&
2133 dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent)) {
2134 sprintf(s, " [%s%s%s]%s%s%s %s",
2135 tf,
2136 *tb ? " / " : NullStr,
2137 tb,
2138 *dcd->mask.szMask ? " (" : NullStr,
2139 *dcd->mask.szMask ? dcd->mask.szMask : NullStr,
2140 *dcd->mask.szMask ? ")" : NullStr, dcd->arcname);
2141 WinSetWindowText(hwndStatus, s);
2142 if (!ParentIsDesktop(hwnd, dcd->hwndParent)) {
2143 pci = WinSendMsg(hwnd,
2144 CM_QUERYRECORDEMPHASIS,
2145 MPFROMLONG(CMA_FIRST), MPFROMSHORT(CRA_CURSORED));
2146 if (pci && (INT) pci != -1) {
2147 if (fSplitStatus && hwndStatus2) {
2148 if (dcd->ullTotalBytes)
2149 CommaFmtULL(tb, sizeof(tb), pci->cbFile, ' ');
2150 else
2151 *tb = 0;
2152 sprintf(s, "%s%s%s%s",
2153 *tb ? " " : NullStr,
2154 tb, *tb ? " " : NullStr, pci->szFileName);
2155 WinSetWindowText(hwndStatus2, s);
2156 }
2157 if (fMoreButtons)
2158 WinSetWindowText(hwndName, pci->szFileName);
2159 }
2160 else {
2161 WinSetWindowText(hwndStatus2, NullStr);
2162 WinSetWindowText(hwndName, NullStr);
2163 }
2164 WinSetWindowText(hwndDate, NullStr);
2165 WinSetWindowText(hwndAttr, NullStr);
2166 }
2167 }
2168 if ((dcd->arcfilled && !dcd->totalfiles) ||
2169 !IsArcThere(hwnd, dcd->arcname))
2170 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
2171 }
2172 return 0;
2173
2174 case UM_SETUP:
2175 if (!dcd) {
2176 Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
2177 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
2178 return 0;
2179 }
2180 else {
2181 if (!dcd->hwndObject) {
2182 /*
2183 * first time through -- set things up
2184 */
2185 {
2186 CHAR *p, *pp;
2187 ULONG z, was;
2188 APIRET rc;
2189
2190 rc = DosCreateDir(dcd->workdir, 0);
2191 if (rc) {
2192 if (rc == ERROR_ACCESS_DENIED) {
2193 p = strrchr(dcd->workdir, '.');
2194 if (p) {
2195 p++;
2196 pp = p;
2197 was = strtoul(p, &pp, 16);
2198 for (z = 0; z < 99; z++) {
2199 was++;
2200 sprintf(p, "%03x");
2201 rc = DosCreateDir(dcd->workdir, 0);
2202 if (!rc || rc != ERROR_ACCESS_DENIED)
2203 break;
2204 }
2205 }
2206 }
2207 if (rc)
2208 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
2209 return 0;
2210 }
2211 }
2212 RestorePresParams(hwnd, "ArcCnr");
2213 dcd->mask.fNoAttribs = TRUE;
2214 dcd->mask.fNoDirs = TRUE;
2215 *dcd->mask.prompt = 0;
2216 {
2217 PFIELDINFO pfi, pfiLastLeftCol;
2218 ULONG numcols = CON_COLS;
2219 CNRINFO cnri;
2220 ULONG size;
2221
2222 pfi = WinSendMsg(hwnd,
2223 CM_ALLOCDETAILFIELDINFO,
2224 MPFROMLONG(numcols), NULL);
2225 if (pfi) {
2226
2227 PFIELDINFO pfiFirst;
2228 FIELDINFOINSERT fii;
2229
2230 pfiFirst = pfi;
2231 pfi->flData = CFA_STRING | CFA_LEFT | CFA_FIREADONLY;
2232 pfi->flTitle = CFA_CENTER;
2233 pfi->pTitleData = GetPString(IDS_FILENAMECOLTEXT);
2234 pfi->offStruct = FIELDOFFSET(ARCITEM, pszFileName);
2235 pfiLastLeftCol = pfi;
2236 pfi = pfi->pNextFieldInfo;
2237 pfi->flData =
2238 CFA_ULONG | CFA_RIGHT | CFA_SEPARATOR | CFA_FIREADONLY;
2239 pfi->flTitle = CFA_CENTER;
2240 pfi->pTitleData = GetPString(IDS_OLDSIZECOLTEXT);
2241 pfi->offStruct = FIELDOFFSET(ARCITEM, cbFile);
2242 pfi = pfi->pNextFieldInfo;
2243 pfi->flData =
2244 CFA_ULONG | CFA_RIGHT | CFA_SEPARATOR | CFA_FIREADONLY;
2245 pfi->flTitle = CFA_CENTER;
2246 pfi->pTitleData = GetPString(IDS_NEWSIZECOLTEXT);
2247 pfi->offStruct = FIELDOFFSET(ARCITEM, cbComp);
2248 pfi = pfi->pNextFieldInfo;
2249 pfi->flData =
2250 CFA_STRING | CFA_CENTER | CFA_SEPARATOR | CFA_FIREADONLY;
2251 pfi->flTitle = CFA_CENTER | CFA_FITITLEREADONLY;
2252 pfi->pTitleData = GetPString(IDS_DATETIMECOLTEXT);
2253 pfi->offStruct = FIELDOFFSET(ARCITEM, pszDate);
2254 pfi = pfi->pNextFieldInfo;
2255 pfi->flData = CFA_DATE | CFA_RIGHT | CFA_FIREADONLY;
2256 pfi->flTitle = CFA_CENTER;
2257 pfi->pTitleData = GetPString(IDS_DATECOLTEXT);
2258 pfi->offStruct = FIELDOFFSET(ARCITEM, date);
2259 pfi = pfi->pNextFieldInfo;
2260 pfi->flData = CFA_TIME | CFA_RIGHT | CFA_FIREADONLY;
2261 pfi->flTitle = CFA_CENTER | CFA_FITITLEREADONLY;
2262 pfi->pTitleData = GetPString(IDS_TIMECOLTEXT);
2263 pfi->offStruct = FIELDOFFSET(ARCITEM, time);
2264 memset(&fii, 0, sizeof(FIELDINFOINSERT));
2265 fii.cb = sizeof(FIELDINFOINSERT);
2266 fii.pFieldInfoOrder = (PFIELDINFO) CMA_FIRST;
2267 fii.cFieldInfoInsert = (SHORT) numcols;
2268 fii.fInvalidateFieldInfo = TRUE;
2269 WinSendMsg(hwnd,
2270 CM_INSERTDETAILFIELDINFO,
2271 MPFROMP(pfiFirst), MPFROMP(&fii));
2272 PostMsg(hwnd, UM_SETUP2, MPVOID, MPVOID);
2273
2274 memset(&cnri, 0, sizeof(cnri));
2275 cnri.cb = sizeof(CNRINFO);
2276 cnri.pFieldInfoLast = pfiLastLeftCol;
2277 cnri.xVertSplitbar = DIR_SPLITBAR_OFFSET + 32;
2278
2279 size = sizeof(LONG);
2280 PrfQueryProfileData(fmprof, appname, "ArcCnrSplitBar",
2281 &cnri.xVertSplitbar, &size);
2282 if (cnri.xVertSplitbar <= 0)
2283 cnri.xVertSplitbar = DIR_SPLITBAR_OFFSET + 32;
2284
2285 cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT | CV_NAME));
2286 cnri.flWindowAttr |= (CV_DETAIL | CA_DETAILSVIEWTITLES | CV_FLOW);
2287 cnri.flWindowAttr &= (~(CA_ORDEREDTARGETEMPH |
2288 CA_MIXEDTARGETEMPH));
2289 cnri.pSortRecord = (PVOID) ArcSort;
2290 WinSendMsg(hwnd,
2291 CM_SETCNRINFO,
2292 MPFROMP(&cnri),
2293 MPFROMLONG(CMA_PFIELDINFOLAST |
2294 CMA_XVERTSPLITBAR |
2295 CMA_PSORTRECORD | CMA_FLWINDOWATTR));
2296 }
2297 }
2298 WinSendMsg(hwnd, CM_SORTRECORD, MPFROMP(ArcSort), MPFROMP(dcd));
2299 if (_beginthread(MakeObjWin, NULL, 245760, (PVOID) dcd) == -1) {
2300 Runtime_Error(pszSrcFile, __LINE__,
2301 GetPString(IDS_COULDNTSTARTTHREADTEXT));
2302 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
2303 return 0;
2304 }
2305 else
2306 DosSleep(1L);
2307 SayFilter(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
2308 DIR_FILTER), &dcd->mask, TRUE);
2309 SaySort(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
2310 DIR_SORT), dcd->sortFlags, TRUE);
2311 DefArcSortFlags = dcd->sortFlags; // Remember for new windows
2312 }
2313 }
2314 return 0;
2315
2316 case UM_SETDIR:
2317 if (dcd) {
2318
2319 CHAR s[CCHMAXPATH], *p;
2320 ULONG ret = 0;
2321
2322 WinQueryDlgItemText(dcd->hwndClient, ARC_EXTRACTDIR, CCHMAXPATH, s);
2323 bstrip(s);
2324 MakeFullName(s);
2325 if (*s) {
2326 while ((p = strchr(s, '/')) != NULL)
2327 *p = '\\';
2328 while (strlen(s) > 3 && s[strlen(s) - 1] == '\\')
2329 s[strlen(s) - 1] = 0;
2330 if (stricmp(s, dcd->directory)) {
2331 if (IsFullName(s)) {
2332 if (driveflags[toupper(*s) - 'A'] &
2333 (DRIVE_NOTWRITEABLE | DRIVE_IGNORE | DRIVE_INVALID)) {
2334 Runtime_Error(pszSrcFile, __LINE__, "drive %s bad", s);
2335 WinSetDlgItemText(dcd->hwndClient,
2336 ARC_EXTRACTDIR, dcd->directory);
2337 return 0;
2338 }
2339 }
2340 if (!SetDir(dcd->hwndParent, hwnd, s, 0)) {
2341 if (stricmp(dcd->directory, s)) {
2342 DosEnterCritSec();
2343 strcpy(lastextractpath, s);
2344 DosExitCritSec();
2345 }
2346 strcpy(dcd->directory, s);
2347 if ((!isalpha(*s) || s[1] != ':') && *s != '.')
2348 saymsg(MB_ENTER | MB_ICONASTERISK,
2349 hwnd,
2350 GetPString(IDS_WARNINGTEXT),
2351 GetPString(IDS_SPECIFYDRIVETEXT));
2352 }
2353 else
2354 ret = 1;
2355 }
2356 }
2357 WinSetDlgItemText(dcd->hwndClient, ARC_EXTRACTDIR, dcd->directory);
2358 return (MRESULT) ret;
2359 }
2360 return 0;
2361
2362 case UM_ENTER:
2363 if (WinSendMsg(hwnd, UM_SETDIR, MPVOID, MPVOID))
2364 return 0;
2365 SetShiftState();
2366 if (dcd && (CHAR *) mp1) {
2367
2368 SWP swp;
2369 CHAR *filename = mp1;
2370
2371 if (IsFile(filename) != 1)
2372 return 0;
2373 WinQueryWindowPos(dcd->hwndFrame, &swp);
2374 DefaultViewKeys(hwnd, dcd->hwndFrame, dcd->hwndParent, &swp, filename);
2375 if (fUnHilite)
2376 UnHilite(hwnd, FALSE, &dcd->lastselection, 0);
2377 }
2378 return 0;
2379
2380 case WM_MENUEND:
2381 if (dcd) {
2382
2383 HWND hwndMenu = (HWND) mp2;
2384
2385 if (hwndMenu == ArcCnrMenu || hwndMenu == ArcMenu) {
2386 MarkAll(hwnd, TRUE, FALSE, TRUE);
2387 if (dcd->cnremphasized) {
2388 WinSendMsg(hwnd,
2389 CM_SETRECORDEMPHASIS,
2390 MPVOID, MPFROM2SHORT(FALSE, CRA_SOURCE));
2391 dcd->cnremphasized = FALSE;
2392 }
2393 }
2394 }
2395 break;
2396
2397 case MM_PORTHOLEINIT:
2398 if (dcd) {
2399 switch (SHORT1FROMMP(mp1)) {
2400 case 0:
2401 case 1:
2402 {
2403 ULONG wmsg;
2404
2405 wmsg = SHORT1FROMMP(mp1) == 0 ? UM_FILESMENU : UM_VIEWSMENU;
2406 PortholeInit((HWND) WinSendMsg(dcd->hwndClient,
2407 wmsg, MPVOID, MPVOID), mp1, mp2);
2408 }
2409 break;
2410 }
2411 }
2412 break;
2413
2414 case UM_INITMENU:
2415 case WM_INITMENU:
2416 if (dcd) {
2417 switch (SHORT1FROMMP(mp1)) {
2418 case IDM_FILESMENU:
2419 if (dcd->info) {
2420 WinEnableMenuItem((HWND) mp2,
2421 IDM_DELETE, dcd->info->delete != NULL);
2422 WinEnableMenuItem((HWND) mp2, IDM_TEST, dcd->info->test != NULL);
2423 WinEnableMenuItem((HWND) mp2,
2424 IDM_EXTRACT, dcd->info->extract != NULL);
2425 WinEnableMenuItem((HWND) mp2,
2426 IDM_EXTRACTWDIRS, dcd->info->exwdirs != NULL);
2427 WinEnableMenuItem((HWND) mp2,
2428 IDM_ARCEXTRACTWDIRS, dcd->info->exwdirs != NULL);
2429 WinEnableMenuItem((HWND) mp2,
2430 IDM_ARCEXTRACTWDIRSEXIT,
2431 dcd->info->exwdirs != NULL);
2432 }
2433 break;
2434
2435 case IDM_VIEWSMENU:
2436 WinCheckMenuItem((HWND) mp2,
2437 IDM_MINIICONS, (dcd->flWindowAttr & CV_MINI) != 0);
2438 WinEnableMenuItem((HWND) mp2,
2439 IDM_RESELECT, (dcd->lastselection != NULL));
2440 break;
2441
2442 case IDM_COMMANDSMENU:
2443 SetupCommandMenu((HWND) mp2, hwnd);
2444 break;
2445
2446 case IDM_SORTSUBMENU:
2447 SetSortChecks((HWND) mp2, dcd->sortFlags);
2448 break;
2449
2450 case IDM_WINDOWSMENU:
2451 /*
2452 * add switchlist entries to end of pulldown menu
2453 */
2454 SetupWinList((HWND)mp2,
2455 hwndMain ? hwndMain : (HWND)0, dcd->hwndFrame);
2456 break;
2457 }
2458 dcd->hwndLastMenu = (HWND) mp2;
2459 }
2460 if (msg == WM_INITMENU)
2461 break;
2462 return 0;
2463
2464 case UM_LOADFILE:
2465 if (dcd && mp2) {
2466
2467 HWND ret;
2468
2469 ret = StartMLEEditor(dcd->hwndParent,
2470 (INT) mp1, (CHAR *) mp2, dcd->hwndFrame);
2471 free((CHAR *) mp2);
2472 return MRFROMLONG(ret);
2473 }
2474 return 0;
2475
2476 case UM_COMMAND:
2477 if (mp1) {
2478 if (dcd) {
2479 if (!PostMsg(dcd->hwndObject, UM_COMMAND, mp1, mp2)) {
2480 Runtime_Error(pszSrcFile, __LINE__, "post");
2481 FreeListInfo((LISTINFO *) mp1);
2482 }
2483 else
2484 return (MRESULT) TRUE;
2485 }
2486 else
2487 FreeListInfo((LISTINFO *) mp1);
2488 }
2489 return 0;
2490
2491 case UM_OPENWINDOWFORME:
2492 if (dcd) {
2493 if (mp1 && !IsFile((CHAR *) mp1)) {
2494 OpenDirCnr((HWND) 0, hwndMain, dcd->hwndFrame, FALSE, (char *)mp1);
2495 }
2496 else if (mp1 && IsFile(mp1) == 1) {
2497 StartArcCnr(HWND_DESKTOP,
2498 dcd->hwndFrame, (CHAR *) mp1, 4, (ARC_TYPE *) mp2);
2499 }
2500 }
2501 return 0;
2502
2503 case WM_COMMAND:
2504 DosError(FERR_DISABLEHARDERR);
2505 if (dcd) {
2506 if (SwitchCommand(dcd->hwndLastMenu, SHORT1FROMMP(mp1)))
2507 return 0;
2508 if (WinSendMsg(hwnd, UM_SETDIR, MPVOID, MPVOID))
2509 return 0;
2510 if (!IsArcThere(hwnd, dcd->arcname)) {
2511 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
2512 return 0;
2513 }
2514 switch (SHORT1FROMMP(mp1)) {
2515 case IDM_TREEVIEW:
2516
2517 break;
2518
2519 case IDM_CONTEXTMENU:
2520 {
2521 PCNRITEM pci;
2522
2523 pci = (PCNRITEM) CurrentRecord(hwnd);
2524 PostMsg(hwnd,
2525 WM_CONTROL,
2526 MPFROM2SHORT(ARC_CNR, CN_CONTEXTMENU), MPFROMP(pci));
2527 }
2528 break;
2529
2530 case IDM_NEXTWINDOW:
2531 case IDM_PREVWINDOW:
2532 {
2533 HWND hwndActive;
2534
2535 hwndActive = WinQueryFocus(HWND_DESKTOP);
2536 WinSetFocus(HWND_DESKTOP,
2537 hwndActive == hwnd ?
2538 WinWindowFromID(dcd->hwndClient, ARC_EXTRACTDIR) :
2539 hwnd);
2540 }
2541 break;
2542
2543 case IDM_FOLDERAFTEREXTRACT:
2544 fFolderAfterExtract = fFolderAfterExtract ? FALSE : TRUE;
2545 PrfWriteProfileData(fmprof, appname, "FolderAfterExtract",
2546 &fFolderAfterExtract, sizeof(BOOL));
2547 break;
2548
2549 case IDM_SHOWSELECT:
2550 QuickPopup(hwnd, dcd, CheckMenu(&ArcCnrMenu, ARCCNR_POPUP),
2551 IDM_SELECTSUBMENU);
2552 break;
2553
2554 case IDM_SHOWSORT:
2555 QuickPopup(hwnd, dcd, CheckMenu(&ArcCnrMenu, ARCCNR_POPUP),
2556 IDM_SORTSUBMENU);
2557 break;
2558
2559 case IDM_NOTEBOOK:
2560 if (!ParentIsDesktop(dcd->hwndParent, dcd->hwndParent))
2561 PostMsg(dcd->hwndParent, msg, mp1, mp2);
2562 else
2563 WinDlgBox(HWND_DESKTOP,
2564 hwnd,
2565 CfgDlgProc, FM3ModHandle, CFG_FRAME, (PVOID) "Archive");
2566 break;
2567
2568 case IDM_RESCAN:
2569 dcd->ullTotalBytes = dcd->totalfiles =
2570 dcd->selectedfiles = dcd->selectedbytes = 0;
2571 WinSetDlgItemText(dcd->hwndClient, DIR_TOTALS, "0");
2572 WinSetDlgItemText(dcd->hwndClient, DIR_SELECTED, "0 / 0k");
2573 dcd->totalfiles = FillArcCnr(dcd->hwndCnr,
2574 dcd->arcname,
2575 &dcd->info,
2576 &dcd->ullTotalBytes, &dcd->stopflag);
2577 PostMsg(dcd->hwndCnr, UM_RESCAN, MPVOID, MPVOID);
2578 PostMsg(dcd->hwndCnr, UM_SETUP2, MPVOID, MPVOID);
2579 WinSendMsg(dcd->hwndCnr,
2580 CM_INVALIDATERECORD,
2581 MPVOID, MPFROM2SHORT(0, CMA_ERASE | CMA_REPOSITION));
2582 break;
2583
2584 case IDM_RESELECT:
2585 SelectList(hwnd, TRUE, FALSE, FALSE, NULL, NULL, dcd->lastselection);
2586 break;
2587
2588 case IDM_HELP:
2589 if (hwndHelp)
2590 WinSendMsg(hwndHelp,
2591 HM_DISPLAY_HELP,
2592 MPFROM2SHORT(HELP_ARCLIST, 0),
2593 MPFROMSHORT(HM_RESOURCEID));
2594 break;
2595
2596 case IDM_WINDOWDLG:
2597 if (!ParentIsDesktop(dcd->hwndParent, dcd->hwndFrame))
2598 PostMsg(dcd->hwndParent,
2599 UM_COMMAND, MPFROM2SHORT(IDM_WINDOWDLG, 0), MPVOID);
2600 break;
2601
2602 case IDM_SELECTALL:
2603 case IDM_SELECTALLFILES:
2604 case IDM_DESELECTALL:
2605 case IDM_DESELECTALLFILES:
2606 case IDM_SELECTMASK:
2607 case IDM_DESELECTMASK:
2608 case IDM_INVERT:
2609 {
2610 PARCITEM pci;
2611
2612 pci = (PARCITEM) WinSendMsg(hwnd,
2613 CM_QUERYRECORDEMPHASIS,
2614 MPFROMLONG(CMA_FIRST),
2615 MPFROMSHORT(CRA_CURSORED));
2616 if ((INT) pci == -1)
2617 pci = NULL;
2618 if (SHORT1FROMMP(mp1) == IDM_HIDEALL) {
2619 if (pci) {
2620 if (!(pci->rc.flRecordAttr & CRA_SELECTED))
2621 pci->rc.flRecordAttr |= CRA_FILTERED;
2622 WinSendMsg(hwnd,
2623 CM_INVALIDATERECORD,
2624 MPFROMP(&pci),
2625 MPFROM2SHORT(1, CMA_ERASE | CMA_REPOSITION));
2626 break;
2627 }
2628 }
2629 PostMsg(dcd->hwndObject, UM_SELECT, mp1, MPFROMP(pci));
2630 }
2631 break;
2632
2633 case IDM_SORTSMARTNAME:
2634 case IDM_SORTNAME:
2635 case IDM_SORTFILENAME:
2636 case IDM_SORTSIZE:
2637 case IDM_SORTEASIZE:
2638 case IDM_SORTFIRST:
2639 case IDM_SORTLAST:
2640 case IDM_SORTLWDATE:
2641 dcd->sortFlags &= SORT_REVERSE;
2642 /* intentional fallthru */
2643 case IDM_SORTREVERSE:
2644 switch (SHORT1FROMMP(mp1)) {
2645 case IDM_SORTSMARTNAME:
2646 case IDM_SORTFILENAME:
2647 dcd->sortFlags |= SORT_FILENAME;
2648 break;
2649 case IDM_SORTSIZE:
2650 dcd->sortFlags |= SORT_SIZE;
2651 break;
2652 case IDM_SORTEASIZE:
2653 dcd->sortFlags |= SORT_EASIZE;
2654 break;
2655 case IDM_SORTFIRST:
2656 dcd->sortFlags |= SORT_FIRSTEXTENSION;
2657 break;
2658 case IDM_SORTLAST:
2659 dcd->sortFlags |= SORT_LASTEXTENSION;
2660 break;
2661 case IDM_SORTLWDATE:
2662 dcd->sortFlags |= SORT_LWDATE;
2663 break;
2664 case IDM_SORTREVERSE:
2665 if (dcd->sortFlags & SORT_REVERSE)
2666 dcd->sortFlags &= (~SORT_REVERSE);
2667 else
2668 dcd->sortFlags |= SORT_REVERSE;
2669 break;
2670 }
2671 WinSendMsg(hwnd, CM_SORTRECORD, MPFROMP(ArcSort), MPFROMP(dcd));
2672 SaySort(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
2673 DIR_SORT), dcd->sortFlags, TRUE);
2674 DefArcSortFlags = dcd->sortFlags; // Remember for new windows
2675 break;
2676
2677 case IDM_COLLECTOR:
2678 if (!Collector) {
2679 HWND hwndC;
2680 SWP swp;
2681
2682 if (ParentIsDesktop(hwnd, dcd->hwndParent) && !fAutoTile &&
2683 (!fExternalCollector && !strcmp(realappname, FM3Str)))
2684 GetNextWindowPos(dcd->hwndParent, &swp, NULL, NULL);
2685 hwndC = StartCollector(fExternalCollector ||
2686 strcmp(realappname, FM3Str) ?
2687 HWND_DESKTOP : dcd->hwndParent, 4);
2688 if (hwndC) {
2689 if (!ParentIsDesktop(hwnd, dcd->hwndParent) && !fAutoTile &&
2690 (!fExternalCollector && !strcmp(realappname, FM3Str)))
2691 WinSetWindowPos(hwndC,
2692 HWND_TOP,
2693 swp.x,
2694 swp.y,
2695 swp.cx,
2696 swp.cy,
2697 SWP_MOVE | SWP_SIZE | SWP_SHOW | SWP_ZORDER);
2698 else if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
2699 fAutoTile && !strcmp(realappname, FM3Str)) {
2700 TileChildren(dcd->hwndParent, TRUE);
2701 }
2702 WinSetWindowPos(hwndC, HWND_TOP, 0, 0, 0, 0, SWP_ACTIVATE);
2703 DosSleep(128L);
2704 }
2705 }
2706 else
2707 StartCollector(dcd->hwndParent, 4);
2708 break;
2709
2710 case IDM_ARCEXTRACTEXIT:
2711 case IDM_ARCEXTRACT:
2712 if (dcd->info->extract)
2713 runemf2(SEPARATE | WINDOWED |
2714 (fArcStuffVisible ? 0 : BACKGROUND | MINIMIZED),
2715 hwnd, dcd->directory, NULL, "%s %s%s%s",
2716 dcd->info->extract,
2717 needs_quoting(dcd->arcname) ? "\"" : NullStr,
2718 dcd->arcname,
2719 needs_quoting(dcd->arcname) ? "\"" : NullStr);
2720 if (SHORT1FROMMP(mp1) == IDM_ARCEXTRACTEXIT)
2721 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
2722 break;
2723
2724 case IDM_ARCEXTRACTWDIRSEXIT:
2725 case IDM_ARCEXTRACTWDIRS:
2726 if (dcd->info->exwdirs)
2727 runemf2(SEPARATE | WINDOWED |
2728 (fArcStuffVisible ? 0 : BACKGROUND | MINIMIZED),
2729 hwnd, dcd->directory, NULL, "%s %s%s%s",
2730 dcd->info->exwdirs,
2731 needs_quoting(dcd->arcname) ? "\"" : NullStr,
2732 dcd->arcname,
2733 needs_quoting(dcd->arcname) ? "\"" : NullStr);
2734 if (SHORT1FROMMP(mp1) == IDM_ARCEXTRACTWDIRSEXIT)
2735 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
2736 break;
2737
2738 case IDM_RESORT:
2739 WinSendMsg(hwnd, CM_SORTRECORD, MPFROMP(ArcSort), MPFROMP(dcd));
2740 break;
2741
2742 case IDM_FILTER:
2743 {
2744 BOOL empty = FALSE;
2745 PARCITEM pci;
2746
2747 if (!*dcd->mask.szMask) {
2748 empty = TRUE;
2749 pci = (PARCITEM) CurrentRecord(hwnd);
2750 if (pci && strchr(pci->szFileName, '.'))
2751 strcpy(dcd->mask.szMask, pci->szFileName);
2752 }
2753
2754 if (WinDlgBox(HWND_DESKTOP, hwnd, PickMaskDlgProc,
2755 FM3ModHandle, MSK_FRAME, MPFROMP(&dcd->mask))) {
2756 WinSendMsg(hwnd, CM_FILTER, MPFROMP(ArcFilter), MPFROMP(dcd));
2757 PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
2758 }
2759 else if (empty)
2760 *dcd->mask.szMask = 0;
2761 SayFilter(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
2762 DIR_FILTER), &dcd->mask, TRUE);
2763 }
2764 break;
2765
2766 case IDM_SWITCH:
2767 if (mp2) {
2768 if (stricmp(dcd->directory, (CHAR *) mp2)) {
2769 DosEnterCritSec();
2770 strcpy(lastextractpath, (CHAR *) mp2);
2771 MakeValidDir(lastextractpath);
2772 DosExitCritSec();
2773 }
2774 strcpy(dcd->directory, (CHAR *) mp2);
2775 MakeValidDir(dcd->directory);
2776 WinSetWindowText(dcd->hwndExtract, dcd->directory);
2777 }
2778 break;
2779
2780 case IDM_WALKDIR:
2781 {
2782 CHAR newdir[CCHMAXPATH];
2783
2784 strcpy(newdir, dcd->directory);
2785 if (!WinDlgBox(HWND_DESKTOP, dcd->hwndParent, WalkExtractDlgProc,
2786 FM3ModHandle, WALK_FRAME,
2787 MPFROMP(newdir)) || !*newdir)
2788 break;
2789 if (stricmp(newdir, dcd->directory)) {
2790 strcpy(dcd->directory, newdir);
2791 if (stricmp(lastextractpath, newdir))
2792 strcpy(lastextractpath, newdir);
2793 WinSetWindowText(dcd->hwndExtract, dcd->directory);
2794 }
2795 }
2796 break;
2797
2798 case IDM_TEST:
2799 if (dcd->info->test)
2800 runemf2(SEPARATEKEEP | WINDOWED | MAXIMIZED,
2801 hwnd, NULL, NULL, "%s %s%s%s", dcd->info->test,
2802 needs_quoting(dcd->arcname) ? "\"" : NullStr,
2803 dcd->arcname,
2804 needs_quoting(dcd->arcname) ? "\"" : NullStr);
2805 break;
2806
2807 case IDM_REFRESH:
2808 case IDM_DELETE:
2809 case IDM_PRINT:
2810 case IDM_VIEW:
2811 case IDM_VIEWTEXT:
2812 case IDM_VIEWBINARY:
2813 case IDM_VIEWARCHIVE:
2814 case IDM_EDIT:
2815 case IDM_EDITTEXT:
2816 case IDM_EDITBINARY:
2817 case IDM_EXTRACT:
2818 case IDM_EXTRACTWDIRS:
2819 case IDM_FIND:
2820 case IDM_EXEC:
2821 case IDM_VIRUSSCAN:
2822 {
2823 LISTINFO *li;
2824
2825 li = xmallocz(sizeof(LISTINFO), pszSrcFile, __LINE__);
2826 if (li) {
2827 li->type = SHORT1FROMMP(mp1);
2828 li->hwnd = hwnd;
2829 li->list = BuildArcList(hwnd);
2830 if (li->type == IDM_REFRESH) {
2831
2832 CHAR s[CCHMAXPATH], *p;
2833 INT x, y;
2834
2835 for (x = 0; li->list && li->list[x]; x++) {
2836 sprintf(s, "%s%s%s", dcd->workdir,
2837 (dcd->workdir[strlen(dcd->workdir) - 1] == '\\') ?
2838 NullStr : "\\", li->list[x]);
2839 if (IsFile(s) != 1) {
2840 free(li->list[x]);
2841 li->list[x] = NULL;
2842 for (y = x; li->list[y]; y++)
2843 li->list[y] = li->list[y + 1];
2844 li->list =
2845 xrealloc(li->list, y * sizeof(CHAR *), pszSrcFile,
2846 __LINE__);
2847 x--;
2848 }
2849 else {
2850 p = xstrdup(s, pszSrcFile, __LINE__);
2851 if (p) {
2852 free(li->list[x]);
2853 li->list[x] = p;
2854 }
2855 }
2856 } // for
2857 }
2858 strcpy(li->arcname, dcd->arcname);
2859 li->info = dcd->info;
2860 {
2861 PARCITEM pai;
2862
2863 if (SHORT1FROMMP(mp1) != IDM_EXEC)
2864 pai = (PARCITEM) CurrentRecord(hwnd);
2865 else
2866 pai = (PARCITEM) WinSendMsg(hwnd, CM_QUERYRECORDEMPHASIS,
2867 MPFROMLONG(CMA_FIRST),
2868 MPFROMSHORT(CRA_CURSORED));
2869 if (pai && (INT) pai != -1)
2870 strcpy(li->runfile, pai->szFileName);
2871 else
2872 strcpy(li->runfile, li->list[0]);
2873 }
2874 switch (SHORT1FROMMP(mp1)) {
2875 case IDM_VIEW:
2876 case IDM_VIEWTEXT:
2877 case IDM_VIEWBINARY:
2878 case IDM_VIEWARCHIVE:
2879 case IDM_EDIT:
2880 case IDM_EDITTEXT:
2881 case IDM_EDITBINARY:
2882 case IDM_EXEC:
2883 case IDM_PRINT:
2884 case IDM_VIRUSSCAN:
2885 strcpy(li->targetpath, dcd->workdir);
2886 break;
2887 default:
2888 strcpy(li->targetpath, dcd->directory);
2889 break;
2890 }
2891 if (li->list) {
2892 if (!PostMsg(dcd->hwndObject, UM_ACTION, MPFROMP(li), MPVOID)) {
2893 Runtime_Error(pszSrcFile, __LINE__, "post");
2894 FreeListInfo(li);
2895 }
2896 else if (fUnHilite && SHORT1FROMMP(mp1) != IDM_EDIT)
2897 UnHilite(hwnd, TRUE, &dcd->lastselection, 0);
2898 }
2899 else
2900 free(li);
2901 }
2902 }
2903 break;
2904 }
2905 }
2906 return 0;
2907
2908 case WM_CONTROL:
2909 DosError(FERR_DISABLEHARDERR);
2910 if (dcd) {
2911 switch (SHORT2FROMMP(mp1)) {
2912 case CN_BEGINEDIT:
2913 PostMsg(hwnd, CM_CLOSEEDIT, MPVOID, MPVOID);
2914 break;
2915
2916 case CN_ENDEDIT:
2917 if (!((PCNREDITDATA) mp2)->pRecord) {
2918
2919 PFIELDINFO pfi = ((PCNREDITDATA) mp2)->pFieldInfo;
2920 USHORT cmd = 0;
2921
2922 if (!pfi || pfi->offStruct == FIELDOFFSET(ARCITEM, pszFileName))
2923 cmd = IDM_SORTSMARTNAME;
2924 else if (pfi->offStruct == FIELDOFFSET(ARCITEM, cbFile))
2925 cmd = IDM_SORTSIZE;
2926 else if (pfi->offStruct == FIELDOFFSET(ARCITEM, cbComp))
2927 cmd = IDM_SORTEASIZE;
2928 else if (pfi->offStruct == FIELDOFFSET(ARCITEM, date))
2929 cmd = IDM_SORTLWDATE;
2930 else if (pfi->offStruct == FIELDOFFSET(ARCITEM, time))
2931 cmd = IDM_SORTLWDATE;
2932 if (cmd)
2933 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(cmd, 0), MPVOID);
2934 }
2935 break;
2936
2937 case CN_DROPHELP:
2938 saymsg(MB_ENTER, hwnd,
2939 GetPString(IDS_DROPHELPHDRTEXT),
2940 GetPString(IDS_ARCCNRDROPHELPTEXT), dcd->arcname);
2941 return 0;
2942
2943 case CN_DRAGLEAVE:
2944 if (mp2) {
2945
2946 PDRAGINFO pDInfo;
2947
2948 pDInfo = ((PCNRDRAGINFO) mp2)->pDragInfo;
2949 DrgAccessDraginfo(pDInfo); /* Access DRAGINFO */
2950 DrgFreeDraginfo(pDInfo); /* Free DRAGINFO */
2951 }
2952 return 0;
2953
2954 case CN_DRAGAFTER:
2955 case CN_DRAGOVER:
2956 if (mp2) {
2957
2958 PDRAGITEM pDItem; /* Pointer to DRAGITEM */
2959 PDRAGINFO pDInfo; /* Pointer to DRAGINFO */
2960 PARCITEM pci;
2961
2962 pci = (PARCITEM) ((PCNRDRAGINFO) mp2)->pRecord;
2963 if (SHORT1FROMMP(mp1) == CN_DRAGAFTER)
2964 pci = NULL;
2965 pDInfo = ((PCNRDRAGINFO) mp2)->pDragInfo;
2966 DrgAccessDraginfo(pDInfo); /* Access DRAGINFO */
2967 if (*dcd->arcname) {
2968 if ((driveflags[toupper(*dcd->arcname) - 'A'] &
2969 DRIVE_NOTWRITEABLE) || !dcd->info || !dcd->info->create) {
2970 DrgFreeDraginfo(pDInfo);
2971 return MRFROM2SHORT(DOR_NEVERDROP, 0);
2972 }
2973 }
2974 if (pci) {
2975 DrgFreeDraginfo(pDInfo);
2976 return MRFROM2SHORT(DOR_NODROP, 0);
2977 }
2978 pDItem = DrgQueryDragitemPtr(pDInfo, /* Access DRAGITEM */
2979 0); /* Index to DRAGITEM */
2980 if (DrgVerifyRMF(pDItem, /* Check valid rendering */
2981 DRM_OS2FILE, /* mechanisms and data */
2982 NULL) && !(pDItem->fsControl & DC_PREPARE)) {
2983 DrgFreeDraginfo(pDInfo); /* Free DRAGINFO */
2984 return MRFROM2SHORT(DOR_DROP, /* Return okay to drop */
2985 fCopyDefault ? DO_COPY : DO_MOVE);
2986 }
2987 DrgFreeDraginfo(pDInfo); /* Free DRAGINFO */
2988 }
2989 return (MRFROM2SHORT(DOR_NEVERDROP, 0)); /* Drop not valid */
2990
2991 case CN_INITDRAG:
2992 if (mp2) {
2993
2994 BOOL wasemphasized = FALSE;
2995 PCNRDRAGINIT pcd = (PCNRDRAGINIT) mp2;
2996 PARCITEM pci;
2997
2998 if (pcd) {
2999 pci = (PARCITEM) pcd->pRecord;
3000 if (pci) {
3001 if (pci->rc.flRecordAttr & CRA_SELECTED)
3002 wasemphasized = TRUE;
3003 if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
3004 fSplitStatus && hwndStatus2)
3005 WinSetWindowText(hwndStatus2, GetPString(IDS_DRAGARCMEMTEXT));
3006 if (DoFileDrag(hwnd,
3007 dcd->hwndObject,
3008 mp2, dcd->arcname, NULL, TRUE)) {
3009 if ((fUnHilite && wasemphasized) || dcd->ulItemsToUnHilite)
3010 UnHilite(hwnd, TRUE, &dcd->lastselection, dcd->ulItemsToUnHilite);
3011 }
3012 if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
3013 fSplitStatus && hwndStatus2) {
3014 PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
3015 }
3016 }
3017 else {
3018 if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
3019 fSplitStatus && hwndStatus2)
3020 WinSetWindowText(hwndStatus2,
3021 GetPString(IDS_DRAGARCFILETEXT));
3022 DragOne(hwnd, dcd->hwndObject, dcd->arcname, FALSE);
3023 if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
3024 fSplitStatus && hwndStatus2)
3025 PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
3026 }
3027 }
3028 }
3029 return 0;
3030
3031 case CN_DROP:
3032 if (mp2) {
3033
3034 LISTINFO *li;
3035
3036 DosBeep(500, 100); // fixme to know why beep?
3037 li = DoFileDrop(hwnd, dcd->arcname, FALSE, mp1, mp2);
3038 DosBeep(50, 100); // fixme to know why beep?
3039 CheckPmDrgLimit(((PCNRDRAGINFO)mp2)->pDragInfo);
3040 if (li) {
3041 li->type = li->type == DO_MOVE ? IDM_ARCHIVEM : IDM_ARCHIVE;
3042 strcpy(li->targetpath, dcd->arcname);
3043 if (!li->list ||
3044 !li->list[0] ||
3045 !PostMsg(dcd->hwndObject, UM_ACTION, MPFROMP(li), MPVOID))
3046 FreeListInfo(li);
3047 }
3048 }
3049 return 0;
3050
3051 case CN_CONTEXTMENU:
3052 {
3053 PARCITEM pci = (PARCITEM) mp2;
3054
3055 if (pci) {
3056 WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPFROMP(pci),
3057 MPFROM2SHORT(TRUE, CRA_CURSORED));
3058 MarkAll(hwnd, FALSE, FALSE, TRUE);
3059 dcd->hwndLastMenu = CheckMenu(&ArcMenu, ARC_POPUP);
3060 }
3061 else {
3062 dcd->hwndLastMenu = CheckMenu(&ArcCnrMenu, ARCCNR_POPUP);
3063 if (dcd->hwndLastMenu && !dcd->cnremphasized) {
3064 WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPVOID,
3065 MPFROM2SHORT(TRUE, CRA_SOURCE));
3066 dcd->cnremphasized = TRUE;
3067 }
3068 }
3069 if (dcd->hwndLastMenu) {
3070 if (dcd->hwndLastMenu == ArcCnrMenu) {
3071 if (dcd->flWindowAttr & CV_MINI)
3072 WinCheckMenuItem(dcd->hwndLastMenu, IDM_MINIICONS, TRUE);
3073 }
3074 WinCheckMenuItem(dcd->hwndLastMenu, IDM_FOLDERAFTEREXTRACT,
3075 fFolderAfterExtract);
3076 if (!PopupMenu(hwnd, hwnd, dcd->hwndLastMenu)) {
3077 if (dcd->cnremphasized) {
3078 WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPVOID,
3079 MPFROM2SHORT(FALSE, CRA_SOURCE));
3080 dcd->cnremphasized = TRUE;
3081 }
3082 MarkAll(hwnd, TRUE, FALSE, TRUE);
3083 }
3084 }
3085 }
3086 break;
3087
3088 case CN_EMPHASIS:
3089 if (mp2) {
3090
3091 PNOTIFYRECORDEMPHASIS pre = mp2;
3092 PARCITEM pci;
3093 CHAR s[CCHMAXPATHCOMP + 91], tf[81], tb[81];
3094
3095 pci = (PARCITEM)(pre ? pre->pRecord : NULL);
3096 if (!pci) {
3097 if (!ParentIsDesktop(hwnd, dcd->hwndParent)) {
3098 if (hwndStatus2)
3099 WinSetWindowText(hwndStatus2, NullStr);
3100 if (fMoreButtons)
3101 WinSetWindowText(hwndName, NullStr);
3102 }
3103 break;
3104 }
3105 if (pre->fEmphasisMask & CRA_SELECTED) {
3106 if (pci->rc.flRecordAttr & CRA_SELECTED) {
3107 dcd->selectedbytes += pci->cbFile;
3108 dcd->selectedfiles++;
3109 }
3110 else if (dcd->selectedfiles) {
3111 dcd->selectedbytes -= pci->cbFile;
3112 dcd->selectedfiles--;
3113 }
3114 commafmt(tf, sizeof(tf), dcd->selectedfiles);
3115 if (dcd->ullTotalBytes)
3116 CommaFmtULL(tb, sizeof(tb), dcd->selectedbytes, ' ');
3117 else
3118 *tb = 0;
3119 sprintf(s, "%s%s%s", tf, *tb ? " / " : NullStr, tb);
3120 WinSetDlgItemText(dcd->hwndClient, DIR_SELECTED, s);
3121 }
3122 else if (WinQueryActiveWindow(dcd->hwndParent) ==
3123 dcd->hwndFrame &&
3124 !ParentIsDesktop(hwnd, dcd->hwndParent)) {
3125 if (pre->fEmphasisMask & CRA_CURSORED) {
3126 if (pci->rc.flRecordAttr & CRA_CURSORED) {
3127 if (fSplitStatus && hwndStatus2) {
3128 if (dcd->ullTotalBytes)
3129 CommaFmtULL(tb, sizeof(tb), pci->cbFile, ' ');
3130 else
3131 *tb = 0;
3132 sprintf(s, "%s%s%s%s",
3133 *tb ? " " : NullStr,
3134 tb, *tb ? " " : NullStr, pci->szFileName);
3135 WinSetWindowText(hwndStatus2, s);
3136 }
3137 if (fMoreButtons)
3138 WinSetWindowText(hwndName, pci->szFileName);
3139 }
3140 }
3141 }
3142 }
3143 break;
3144
3145 case CN_ENTER:
3146 if (mp2) {
3147
3148 PARCITEM pci = (PARCITEM) ((PNOTIFYRECORDENTER) mp2)->pRecord;
3149
3150 if (pci) {
3151
3152 CHAR *s;
3153
3154 if ((pci->rc.flRecordAttr & CRA_INUSE) ||
3155 (pci->flags & (ARCFLAGS_REALDIR | ARCFLAGS_PSEUDODIR)))
3156 break;
3157 s = xstrdup(pci->szFileName, pszSrcFile, __LINE__);
3158 if (s) {
3159 if (!PostMsg(dcd->hwndObject, UM_ENTER, MPFROMP(s), MPVOID)) {
3160 Runtime_Error(pszSrcFile, __LINE__, "post");
3161 free(s);
3162 }
3163 }
3164 }
3165 }
3166 break;
3167 }
3168 }
3169 return 0;
3170
3171 case UM_FOLDUP:
3172 if (!PostMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID))
3173 DosExit(EXIT_PROCESS, 1);
3174 return 0;
3175
3176 case UM_CLOSE:
3177 WinDestroyWindow(WinQueryWindow(WinQueryWindow(hwnd, QW_PARENT),
3178 QW_PARENT));
3179 return 0;
3180
3181 case WM_SAVEAPPLICATION:
3182 if (dcd && ParentIsDesktop(hwnd, dcd->hwndParent)) {
3183 SWP swp;
3184
3185 WinQueryWindowPos(dcd->hwndFrame, &swp);
3186 if (!(swp.fl & (SWP_HIDE | SWP_MINIMIZE | SWP_MAXIMIZE)))
3187 PrfWriteProfileData(fmprof, appname, "AV2SizePos", &swp, sizeof(swp));
3188 }
3189 break;
3190
3191 case WM_CLOSE:
3192 WinSendMsg(hwnd, WM_SAVEAPPLICATION, MPVOID, MPVOID);
3193 if (dcd)
3194 dcd->stopflag++;
3195 if (dcd && dcd->hwndObject) {
3196 if (!PostMsg(dcd->hwndObject, WM_CLOSE, MPVOID, MPVOID))
3197 WinSendMsg(dcd->hwndObject, WM_CLOSE, MPVOID, MPVOID);
3198 }
3199 // In case object window frees dcd
3200 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
3201 if (!dcd ||
3202 (!dcd->dontclose &&
3203 !dcd->amextracted && ParentIsDesktop(hwnd, dcd->hwndParent))) {
3204 if (!PostMsg(hwnd, UM_FOLDUP, MPVOID, MPVOID))
3205 WinSendMsg(hwnd, UM_FOLDUP, MPVOID, MPVOID);
3206 }
3207 return 0;
3208
3209 case WM_DESTROY:
3210 if (ArcMenu)
3211 WinDestroyWindow(ArcMenu);
3212 if (ArcCnrMenu)
3213 WinDestroyWindow(ArcCnrMenu);
3214 ArcMenu = ArcCnrMenu = (HWND) 0;
3215 EmptyCnr(hwnd);
3216 break;
3217 }
3218 if (dcd && dcd->oldproc){
3219 return dcd->oldproc(hwnd, msg, mp1, mp2);
3220 }
3221 else
3222 return PFNWPCnr(hwnd, msg, mp1, mp2);
3223}
3224
3225HWND StartArcCnr(HWND hwndParent, HWND hwndCaller, CHAR * arcname, INT flags,
3226 ARC_TYPE * sinfo)
3227{
3228 /*
3229 * bitmapped flags:
3230 * 1 = am extracted from another archive
3231 * 4 = don't kill proc on close
3232 */
3233
3234 HWND hwndFrame = (HWND) 0, hwndClient;
3235 ULONG FrameFlags = FCF_TITLEBAR | FCF_SYSMENU |
3236 FCF_SIZEBORDER | FCF_MINMAX | FCF_ICON | FCF_NOBYTEALIGN | FCF_ACCELTABLE;
3237 USHORT id;
3238 DIRCNRDATA *dcd;
3239 ARC_TYPE *info = sinfo;
3240 CHAR title[MAXNAMEL + 1] = "AV/2 - ";
3241 CHAR fullname[CCHMAXPATH + 8], *p, temp;
3242 static USHORT idinc = 0;
3243
3244 if (!idinc)
3245 idinc = (rand() % 256);
3246 if (ParentIsDesktop(hwndParent, hwndParent))
3247 FrameFlags |= (FCF_TASKLIST | FCF_MENU);
3248 if (arcname) {
3249 DosError(FERR_DISABLEHARDERR);
3250 if (DosQueryPathInfo(arcname,
3251 FIL_QUERYFULLNAME, fullname, sizeof(fullname)))
3252 strcpy(fullname, arcname);
3253 p = fullname;
3254 while (*p) {
3255 if (*p == '/')
3256 *p = '\\';
3257 p++;
3258 }
3259 if (!info)
3260 info = find_type(fullname, arcsighead);
3261 if (!info)
3262 return hwndFrame;
3263 if (strlen(title) + strlen(fullname) > MAXNAMEL) {
3264 p = title + strlen(title);
3265 strncpy(p, fullname, MAXNAMEL / 2 - 5);
3266 strcpy(p + MAXNAMEL / 2 - 5, "...");
3267 strcat(title, fullname + strlen(fullname) - (MAXNAMEL / 2 - 5));
3268 }
3269 else {
3270 strcat(title, fullname);
3271 }
3272 hwndFrame = WinCreateStdWindow(hwndParent,
3273 WS_VISIBLE,
3274 &FrameFlags,
3275 WC_ARCCONTAINER,
3276 title,
3277 WS_VISIBLE | fwsAnimate,
3278 FM3ModHandle, ARC_FRAME, &hwndClient);
3279 if (hwndFrame && hwndClient) {
3280 id = ARC_FRAME + idinc++;
3281 if (idinc > 512)
3282 idinc = 0;
3283 WinSetWindowUShort(hwndFrame, QWS_ID, id);
3284 dcd = xmallocz(sizeof(DIRCNRDATA), pszSrcFile, __LINE__);
3285 if (!dcd) {
3286 PostMsg(hwndClient, WM_CLOSE, MPVOID, MPVOID);
3287 hwndFrame = (HWND) 0;
3288 }
3289 else {
3290 dcd->size = sizeof(DIRCNRDATA);
3291 dcd->id = id;
3292 dcd->type = ARC_FRAME;
3293 save_dir2(dcd->workdir);
3294 if (dcd->workdir[strlen(dcd->workdir) - 1] != '\\')
3295 strcat(dcd->workdir, "\\");
3296 sprintf(dcd->workdir + strlen(dcd->workdir), "%s.%03x",
3297 ArcTempRoot, (clock() & 4095));
3298 strcpy(dcd->arcname, fullname);
3299 if (*extractpath) {
3300 if (!strcmp(extractpath, "*")) {
3301 p = strrchr(fullname, '\\');
3302 if (p) {
3303 if (p < fullname + 3)
3304 p++;
3305 temp = *p;
3306 *p = 0;
3307 strcpy(dcd->directory, fullname);
3308 *p = temp;
3309 }
3310 }
3311 else
3312 strcpy(dcd->directory, extractpath);
3313 }
3314 if (!*dcd->directory && *lastextractpath) {
3315 DosEnterCritSec();
3316 strcpy(dcd->directory, lastextractpath);
3317 DosExitCritSec();
3318 }
3319 if (!*dcd->directory) {
3320 if (!ParentIsDesktop(hwndParent, hwndParent))
3321 TopWindowName(hwndParent, hwndCaller, dcd->directory);
3322 if (!*dcd->directory) {
3323 p = strrchr(fullname, '\\');
3324 if (p) {
3325 if (p < fullname + 3)
3326 p++;
3327 *p = 0;
3328 strcpy(dcd->directory, fullname);
3329 }
3330 }
3331 }
3332 if (!*dcd->directory ||
3333 IsFile(dcd->directory) ||
3334 (isalpha(*dcd->directory) &&
3335 (driveflags[toupper(*dcd->directory) - 'A'] &
3336 DRIVE_NOTWRITEABLE)))
3337 save_dir2(dcd->directory);
3338 dcd->hwndParent = hwndParent ? hwndParent : HWND_DESKTOP;
3339 dcd->hwndFrame = hwndFrame;
3340 dcd->hwndClient = hwndClient;
3341 dcd->amextracted = (flags & 1) != 0;
3342 dcd->dontclose = (flags & 4) != 0;
3343 dcd->info = info;
3344 dcd->sortFlags = DefArcSortFlags;
3345 {
3346 PFNWP oldproc;
3347
3348 oldproc = WinSubclassWindow(hwndFrame, (PFNWP) ArcFrameWndProc);
3349 WinSetWindowPtr(hwndFrame, QWL_USER, (PVOID) oldproc);
3350 }
3351 dcd->hwndCnr = WinCreateWindow(hwndClient,
3352 WC_CONTAINER,
3353 NULL,
3354 CCS_AUTOPOSITION | CCS_MINIICONS |
3355 CCS_MINIRECORDCORE | ulCnrType |
3356 WS_VISIBLE,
3357 0,
3358 0,
3359 0,
3360 0,
3361 hwndClient,
3362 HWND_TOP, (ULONG) ARC_CNR, NULL, NULL);
3363 if (!dcd->hwndCnr) {
3364 Win_Error2(hwndClient, hwndClient, pszSrcFile, __LINE__,
3365 IDS_WINCREATEWINDOW);
3366 PostMsg(hwndClient, WM_CLOSE, MPVOID, MPVOID);
3367 free(dcd);
3368 hwndFrame = (HWND) 0;
3369 }
3370 else {
3371 WinSetWindowPtr(dcd->hwndCnr, QWL_USER, (PVOID) dcd);
3372 dcd->oldproc = WinSubclassWindow(dcd->hwndCnr,
3373 (PFNWP) ArcCnrWndProc);
3374 {
3375 USHORT ids[] = { DIR_TOTALS, DIR_SELECTED, DIR_VIEW, DIR_SORT,
3376 DIR_FILTER, DIR_FOLDERICON, 0
3377 };
3378
3379 CommonCreateTextChildren(dcd->hwndClient,
3380 WC_ARCSTATUS, ids);
3381 }
3382 WinEnableWindow(WinWindowFromID(dcd->hwndClient, DIR_VIEW), FALSE);
3383 dcd->hwndExtract = WinCreateWindow(dcd->hwndClient,
3384 WC_ENTRYFIELD,
3385 NULL,
3386 ES_AUTOSCROLL,
3387 0,
3388 0,
3389 0,
3390 0,
3391 dcd->hwndClient,
3392 HWND_TOP,
3393 ARC_EXTRACTDIR, NULL, NULL);
3394 WinSendMsg(dcd->hwndExtract,
3395 EM_SETTEXTLIMIT, MPFROM2SHORT(CCHMAXPATH, 0), MPVOID);
3396 WinSetWindowText(dcd->hwndExtract, dcd->directory);
3397 if (!PostMsg(dcd->hwndCnr, UM_SETUP, MPVOID, MPVOID))
3398 WinSendMsg(dcd->hwndCnr, UM_SETUP, MPVOID, MPVOID);
3399 if (FrameFlags & FCF_MENU) {
3400 if (!fToolbar) {
3401 HWND hwndMenu = WinWindowFromID(hwndFrame, FID_MENU);
3402
3403 if (hwndMenu) {
3404 WinSendMsg(hwndMenu, MM_DELETEITEM,
3405 MPFROM2SHORT(IDM_VIEW, FALSE), MPVOID);
3406 WinSendMsg(hwndMenu, MM_DELETEITEM,
3407 MPFROM2SHORT(IDM_EXEC, FALSE), MPVOID);
3408 WinSendMsg(hwndMenu, MM_DELETEITEM,
3409 MPFROM2SHORT(IDM_RESCAN, FALSE), MPVOID);
3410 WinSendMsg(hwndMenu, MM_DELETEITEM,
3411 MPFROM2SHORT(IDM_DELETE, FALSE), MPVOID);
3412 WinSendMsg(hwndMenu, MM_DELETEITEM,
3413 MPFROM2SHORT(IDM_EXTRACT, FALSE), MPVOID);
3414 WinSendMsg(hwndMenu, MM_DELETEITEM,
3415 MPFROM2SHORT(IDM_TEST, FALSE), MPVOID);
3416 WinSendMsg(hwndMenu, MM_DELETEITEM,
3417 MPFROM2SHORT(IDM_VIRUSSCAN, FALSE), MPVOID);
3418 WinSendMsg(hwndMenu, MM_DELETEITEM,
3419 MPFROM2SHORT(IDM_WALKDIR, FALSE), MPVOID);
3420 WinSendMsg(hwndMenu, MM_DELETEITEM,
3421 MPFROM2SHORT(IDM_FILTER, FALSE), MPVOID);
3422 }
3423 }
3424 }
3425 if (FrameFlags & FCF_TASKLIST) {
3426
3427 SWP swp, swpD;
3428 ULONG size = sizeof(swp);
3429 LONG cxScreen, cyScreen;
3430
3431 WinQueryTaskSizePos(WinQueryAnchorBlock(hwndFrame), 0, &swp);
3432 if (PrfQueryProfileData(fmprof,
3433 appname, "AV2SizePos", &swpD, &size)) {
3434 cxScreen = WinQuerySysValue(HWND_DESKTOP, SV_CXSCREEN);
3435 cyScreen = WinQuerySysValue(HWND_DESKTOP, SV_CYSCREEN);
3436 if (swp.x + swpD.cx > cxScreen)
3437 swp.x = cxScreen - swpD.cx;
3438 if (swp.y + swpD.cy > cyScreen)
3439 swp.y = cyScreen - swpD.cy;
3440 swp.cx = swpD.cx;
3441 swp.cy = swpD.cy;
3442 }
3443 WinSetWindowPos(hwndFrame,
3444 HWND_TOP,
3445 swp.x,
3446 swp.y,
3447 swp.cx,
3448 swp.cy,
3449 SWP_SIZE | SWP_MOVE | SWP_SHOW | SWP_ZORDER |
3450 SWP_ACTIVATE);
3451 }
3452 }
3453 }
3454 }
3455 }
3456 return hwndFrame;
3457}
Note: See TracBrowser for help on using the repository browser.