source: trunk/dll/arccnrs.c@ 917

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

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