source: trunk/dll/arccnrs.c@ 906

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

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