source: trunk/dll/arccnrs.c@ 953

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

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