source: trunk/dll/arccnrs.c@ 1063

Last change on this file since 1063 was 1063, checked in by Gregg Young, 17 years ago

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