source: trunk/dll/arccnrs.c@ 1004

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

Change default command line length to 1024; remove additional hard coded command line lengths
  • 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 1004 2008-04-20 17:59:34Z gyoung $
5
6 Archive containers
7
8 Copyright (c) 1993-98 M. Kimes
9 Copyright (c) 2001, 2008 Steven H. Levine
10
11 11 Jun 02 SHL Ensure archive name not garbage
12 22 May 03 SHL ArcObjWndProc: fix UM_RESCAN now that we understand it
13 01 Aug 04 SHL Rework lstrip/rstrip usage
14 23 May 05 SHL Use QWL_USER
15 25 May 05 SHL Rename comnam to szCommonName and fix typo
16 25 May 05 SHL Use ULONGLONG and CommaFmtULL
17 05 Jun 05 SHL Drop obsolete, localize
18 05 Jun 05 SHL Correct last sort logic
19 05 Jun 05 SHL Use QWL_USER
20 22 Jun 05 SHL ArcSort: correct typo in last sort fix
21 13 Aug 05 SHL FillArcCnr: optimize
22 08 Dec 05 SHL FillArcCnr: allow list start and end markers to be empty (i.e. tar)
23 08 Dec 05 SHL ArcCnrWndProc: suppress IDM_EXTRACT if no simple extract (i.e. tar)
24 30 Dec 05 SHL ArcCnrWndProc: correct date/time column display setup
25 29 May 06 SHL Comments
26 14 Jul 06 SHL Use Runtime_Error
27 26 Jul 06 SHL Correct SelectAll usage
28 29 Jul 06 SHL Use xfgets_bstripcr
29 31 Jul 06 SHL Lower priority for archives with more than 1000 entries
30 02 Aug 06 SHL Add logic to stop processing large archives
31 23 Aug 06 SHL Integrate John Small's switch list title logic
32 03 Nov 06 SHL Renames
33 14 Mar 07 SHL ArcObjWndProc/UM_ENTER: delay before starting viewer
34 30 Mar 07 GKY Remove GetPString for window class names
35 06 Apr 07 GKY Work around PM DragInfo and DrgFreeISH limit
36 06 Apr 07 GKY Add some error checking in drag/drop
37 20 Apr 07 SHL Sync with NumItemsToUnhilite mods
38 21 Apr 07 GKY Find FM2Utils by path or utils directory
39 12 May 07 SHL Use dcd->ulItemsToUnHilite; sync with UnHilite arg mods
40 10 Jun 07 GKY Add CheckPmDrgLimit including IsFm2Window as part of work around PM drag limit
41 16 Jun 07 SHL Use DosQueryAppType not DosQAppType
42 02 Aug 07 SHL Sync with ARCITEM mods
43 06 Aug 07 SHL Use BldFullPathName and BldQuotedFileName
44 06 Aug 07 SHL Move BldQuotedFileName and BldQuotedFullPathNamehere
45 to be near primary caller
46 06 Aug 07 GKY Reduce DosSleep times (ticket 148)
47 20 Aug 07 GKY Move #pragma alloc_text to end for OpenWatcom compat
48 26 Aug 07 GKY DosSleep(1) in loops changed to (0)
49 22 Nov 07 GKY Use CopyPresParams to fix presparam inconsistencies in menus
50 30 Dec 07 GKY Use TestCDates for sort by date
51 10 Jan 08 SHL Sync with CfgDlgProc mods
52 10 Feb 08 GKY Implement bubble help for bitmap menu items
53 15 Feb 08 SHL Sync with settings menu rework
54 29 Feb 08 GKY Use xfree where appropriate
55
56***********************************************************************/
57
58#include <stdlib.h> // free..
59#include <string.h>
60#include <ctype.h>
61#include <direct.h> // rmdir
62#include <share.h> // SH_DENYWR
63#include <limits.h> // ULONG_MAX
64#include <process.h> // _beginthread
65
66#if 0
67#include <malloc.h> // _heapchk
68#endif
69
70#define INCL_DOS
71#define INCL_DOSERRORS
72#define INCL_WIN
73#define INCL_LONGLONG
74
75#include "arccnrs.h" // StartArcCnr
76#include "fm3dlg.h"
77#include "fm3str.h"
78#include "mle.h"
79#include "pathutil.h" // BldFullPathName
80#include "filldir.h" // EmptyCnr...
81#include "errutil.h" // Dos_Error...
82#include "strutil.h" // GetPString
83#include "notebook.h" // CfgDlgProc
84#include "fm3dll.h"
85
86#pragma data_seg(DATA1)
87
88static INT DefArcSortFlags;
89static PSZ pszSrcFile = __FILE__;
90
91static MRESULT EXPENTRY ArcErrProc(HWND hwnd, ULONG msg, MPARAM mp1,
92 MPARAM mp2)
93{
94 ARCDUMP *ad;
95 CHAR szQuotedArcName[CCHMAXPATH];
96
97 switch (msg) {
98 case WM_INITDLG:
99 if (!mp2)
100 WinDismissDlg(hwnd, 0);
101 else {
102 ad = (ARCDUMP *) mp2;
103 WinSetWindowPtr(hwnd, QWL_USER, ad);
104 if (ad->errmsg)
105 WinSetDlgItemText(hwnd, ARCERR_TEXT, ad->errmsg);
106 if (!ad->info->test)
107 WinEnableWindow(WinWindowFromID(hwnd, ARCERR_TEST), FALSE);
108 if (ad->listname) {
109 MLEsetlimit(WinWindowFromID(hwnd, ARCERR_MLE), -1L);
110 MLEsetformat(WinWindowFromID(hwnd, ARCERR_MLE), MLFIE_NOTRANS);
111 MLEsetcurpos(WinWindowFromID(hwnd, ARCERR_MLE),
112 MLEgetlen(WinWindowFromID(hwnd, ARCERR_MLE)));
113 MLEinsert(WinWindowFromID(hwnd, ARCERR_MLE),
114 GetPString(IDS_ARCHIVERREPORTTEXT));
115 MLEinsertfile(WinWindowFromID(hwnd, ARCERR_MLE), ad->listname);
116 }
117 }
118 break;
119
120 case WM_COMMAND:
121 switch (SHORT1FROMMP(mp1)) {
122 case DID_CANCEL:
123 WinDismissDlg(hwnd, 0);
124 break;
125
126 case IDM_HELP:
127 if (hwndHelp) {
128 WinSendMsg(hwndHelp, HM_DISPLAY_HELP,
129 MPFROM2SHORT(HELP_ARCERR, 0), MPFROMSHORT(HM_RESOURCEID));
130 }
131 break;
132
133 case DID_OK:
134 ad = WinQueryWindowPtr(hwnd, QWL_USER);
135 WinDlgBox(HWND_DESKTOP, hwnd, ArcReviewDlgProc, FM3ModHandle,
136 AD_FRAME, MPFROMP(ad));
137 WinDismissDlg(hwnd, 0);
138 break;
139
140 case ARCERR_VIEW:
141 ad = WinQueryWindowPtr(hwnd, QWL_USER);
142 {
143 CHAR *list[2];
144
145 list[0] = ad->arcname;
146 list[1] = NULL;
147 if (TestBinary(ad->arcname)) {
148 if (*binview)
149 ExecOnList((HWND) 0, binview, WINDOWED | SEPARATE, NULL, list,
150 NULL, pszSrcFile, __LINE__);
151 else
152 StartMLEEditor(HWND_DESKTOP, 16 + 4 + 1, ad->arcname, hwnd);
153 }
154 else {
155 if (*viewer) {
156 ExecOnList((HWND) 0, viewer, WINDOWED | SEPARATE |
157 (fViewChild ? CHILD : 0),
158 NULL, list, NULL, pszSrcFile, __LINE__);
159 }
160 else
161 StartMLEEditor(HWND_DESKTOP, 8 + 4 + 1, ad->arcname, hwnd);
162 }
163 }
164 break;
165
166 case ARCERR_TEST:
167 ad = WinQueryWindowPtr(hwnd, QWL_USER);
168 runemf2(SEPARATEKEEP | WINDOWED | MAXIMIZED,
169 hwnd, pszSrcFile, __LINE__, NULL, NULL,
170 "%s %s",
171 ad->info->test,
172 BldQuotedFileName(szQuotedArcName, ad->arcname));
173 break;
174 }
175 return 0;
176 }
177 return WinDefDlgProc(hwnd, msg, mp1, mp2);
178}
179
180static SHORT APIENTRY ArcSort(PMINIRECORDCORE pmrc1, PMINIRECORDCORE pmrc2,
181 PVOID pStorage)
182{
183 PARCITEM pai1 = (PARCITEM) pmrc1;
184 PARCITEM pai2 = (PARCITEM) pmrc2;
185 DIRCNRDATA *pdcd = (DIRCNRDATA *) pStorage;
186 SHORT ret = 0;
187 CHAR *pext, *ppext;
188 INT sortFlags;
189
190 if (!pdcd) {
191 HWND hwndCnr = pai1->hwndCnr;
192
193 pdcd = WinQueryWindowPtr(hwndCnr, QWL_USER);
194 if (!pdcd) {
195 Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
196 return ret;
197 }
198 }
199
200 sortFlags = pdcd->sortFlags; // Optimize
201
202 if (sortFlags) {
203 switch (sortFlags & (~SORT_REVERSE)) {
204 case SORT_FIRSTEXTENSION:
205 pext = strchr(pai1->pszFileName, '.');
206 ppext = strchr(pai2->pszFileName, '.');
207 if (!pext)
208 pext = NullStr;
209 if (!ppext)
210 ppext = NullStr;
211 ret = stricmp(pext, ppext);
212 break;
213
214 case SORT_LASTEXTENSION:
215 pext = strrchr(pai1->pszFileName, '.');
216 ppext = strrchr(pai2->pszFileName, '.');
217 if (!pext)
218 pext = NullStr;
219 if (!ppext)
220 ppext = NullStr;
221 ret = stricmp(pext, ppext);
222 break;
223
224 case SORT_LWDATE:
225 ret = TestCDates(&pai1->date, &pai1->time,
226 &pai2->date, &pai2->time);
227 /*(pai1->date.year < pai2->date.year) ? 1 :
228 (pai1->date.year > pai2->date.year) ? -1 :
229 (pai1->date.month < pai2->date.month) ? 1 :
230 (pai1->date.month > pai2->date.month) ? -1 :
231 (pai1->date.day < pai2->date.day) ? 1 :
232 (pai1->date.day > pai2->date.day) ? -1 :
233 (pai1->time.hours < pai2->time.hours) ? 1 :
234 (pai1->time.hours > pai2->time.hours) ? -1 :
235 (pai1->time.minutes < pai2->time.minutes) ? 1 :
236 (pai1->time.minutes > pai2->time.minutes) ? -1 :
237 (pai1->time.seconds < pai2->time.seconds) ? 1 :
238 (pai1->time.seconds > pai2->time.seconds) ? -1 : 0;*/
239 break;
240
241 case SORT_SIZE:
242 ret =
243 (pai1->cbFile < pai2->cbFile) ? 1 : (pai1->cbFile ==
244 pai2->cbFile) ? 0 : -1;
245 if (!ret)
246 ret =
247 (pai1->cbComp < pai2->cbComp) ? 1 : (pai1->cbComp ==
248 pai2->cbComp) ? 0 : -1;
249 break;
250
251 case SORT_EASIZE:
252 ret =
253 (pai1->cbComp < pai2->cbComp) ? 1 : (pai1->cbComp ==
254 pai2->cbComp) ? 0 : -1;
255 if (!ret)
256 ret =
257 (pai1->cbFile < pai2->cbFile) ? 1 : (pai1->cbFile ==
258 pai2->cbFile) ? 0 : -1;
259 break;
260 }
261 if (!ret)
262 ret = (SHORT) stricmp(pai1->pszFileName, pai2->pszFileName);
263 if (ret && (sortFlags & SORT_REVERSE))
264 ret = ret > 0 ? -1 : 1;
265 return ret;
266 }
267 return (SHORT) stricmp(pai1->pszFileName, pai2->pszFileName);
268}
269
270static INT APIENTRY ArcFilter(PMINIRECORDCORE rmini, PVOID arg)
271{
272 DIRCNRDATA *dcd = (DIRCNRDATA *) arg;
273 PARCITEM r;
274 register INT x;
275 INT ret = FALSE;
276
277 if (dcd && *dcd->mask.szMask) {
278 r = (PARCITEM) rmini;
279 if (dcd->mask.pszMasks[1]) {
280 for (x = 0; dcd->mask.pszMasks[x]; x++) {
281 if (*dcd->mask.pszMasks[x]) {
282 if (*dcd->mask.pszMasks[x] != '/') {
283 if (wildcard(r->pszFileName, dcd->mask.pszMasks[x], FALSE))
284 ret = TRUE;
285 }
286 else {
287 if (wildcard(r->pszFileName, dcd->mask.pszMasks[x] + 1, FALSE)) {
288 ret = FALSE;
289 break;
290 }
291 }
292 }
293 }
294 }
295 else {
296 if (wildcard(r->pszFileName, dcd->mask.szMask, FALSE))
297 ret = TRUE;
298 }
299 }
300 else
301 ret = TRUE;
302 return ret;
303}
304
305static MRESULT EXPENTRY ArcFrameWndProc(HWND hwnd, ULONG msg, MPARAM mp1,
306 MPARAM mp2)
307{
308 return CommonFrameWndProc(ARC_CNR, hwnd, msg, mp1, mp2);
309}
310
311static BOOL IsArcThere(HWND hwnd, CHAR * arcname)
312{
313 if (arcname) {
314 if (IsFile(arcname) != 1) {
315 saymsg(MB_CANCEL, hwnd,
316 GetPString(IDS_SAYWHATTEXT),
317 GetPString(IDS_ARCNOTTHERETEXT), arcname);
318 return FALSE;
319 }
320 return TRUE;
321 }
322 return FALSE;
323}
324
325/**
326 * Free storage associated with archive container item
327 * Caller is responsible for correcting pointers
328 */
329
330static VOID FreeArcItemData(PARCITEM pai)
331{
332 // DbgMsg(pszSrcFile, __LINE__, "FreeArcItemData %p", pai);
333 PSZ psz;
334
335 if (pai->pszFileName && pai->pszFileName != NullStr) {
336 psz = pai->pszFileName;
337 pai->pszFileName = NullStr;
338 free(psz);
339 }
340}
341
342/**
343 * Remove item(s) from archive container and free associated storage if requested
344 * @param paiFirst points to first item to remove or NULL to remove all
345 * @param usCnt is remove count or 0 to remove all
346 */
347
348static VOID RemoveArcItems(HWND hwnd, PARCITEM paiFirst, USHORT usCnt, USHORT usFlags)
349{
350 INT remaining = usCnt;
351 PARCITEM pai;
352
353 if ((usCnt && !paiFirst) || (!usCnt && paiFirst))
354 Runtime_Error(pszSrcFile, __LINE__, "paiFirst %p usCnt %u mismatch", paiFirst, usCnt);
355 else {
356 // Free our buffers if free requested
357 if (usFlags & CMA_FREE) {
358 if (paiFirst)
359 pai = paiFirst;
360 else {
361 pai = (PARCITEM)WinSendMsg(hwnd, CM_QUERYRECORD, MPVOID,
362 MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
363 if ((INT)pai == -1) {
364 Win_Error(hwnd, HWND_DESKTOP, pszSrcFile, __LINE__,"CM_QUERYRECORD");
365 remaining = -1;
366 pai = NULL;
367 }
368 }
369 while (pai) {
370 FreeArcItemData(pai);
371 pai = (PARCITEM)pai->rc.preccNextRecord;
372 if (remaining && --remaining == 0)
373 break;
374 }
375 }
376 }
377
378 // DbgMsg(pszSrcFile, __LINE__, "RemoveArcItems %p %u %s", pai, usCnt, pai->pszFileName);
379
380 if (remaining != - 1) {
381 remaining = (INT)WinSendMsg(hwnd, CM_REMOVERECORD, MPFROMP(&paiFirst), MPFROM2SHORT(usCnt, usFlags));
382 if (remaining == -1) {
383 // Win_Error2(hwnd, HWND_DESKTOP, pszSrcFile, __LINE__,IDS_CMREMOVEERRTEXT);
384 Win_Error(hwnd, HWND_DESKTOP, pszSrcFile, __LINE__,"CM_REMOVERECORD hwnd %x pai %p cnt %u", hwnd, paiFirst, usCnt);
385 }
386 }
387}
388
389/**
390 * Empty all records from an archive container and
391 * free associated storage and free up field infos
392 */
393
394static VOID EmptyArcCnr(HWND hwnd)
395{
396#if 0 // fixme to be gone or to be configurable
397 {
398 int state = _heapchk();
399 if (state != _HEAPOK)
400 Runtime_Error(pszSrcFile, __LINE__, "heap corrupted %d", state);
401 else
402 DbgMsg(pszSrcFile, __LINE__, "_memavl %u", _memavl());
403 }
404#endif
405
406 // Remove all ARCITEM records
407 RemoveArcItems(hwnd, NULL, 0, CMA_FREE);
408
409 // Use common code to remove rest
410 EmptyCnr(hwnd);
411}
412
413//== FillArcCnr() generate archive content list and fill container window ==
414
415static INT FillArcCnr(HWND hwndCnr, CHAR * arcname, ARC_TYPE ** arcinfo,
416 ULONGLONG * pullTotalBytes, volatile PCHAR pStopFlag)
417{
418 FILE *fp;
419 HFILE oldstdout;
420 HFILE newstdout;
421 CHAR s[CCHMAXPATH * 2], lonename[CCHMAXPATH + 2],
422 *nsize, *osize, *fdate, *fname, *p, *pp, arctemp[33];
423 BOOL gotstart;
424 BOOL gotend;
425 BOOL wasquote;
426 BOOL nomove = FALSE; // fixme to be gone?
427 INT highest = 0, x, counter = 0, numarcfiles = 0;
428 PARCITEM lastpai;
429 ARC_TYPE *info;
430 ARC_TYPE *tinfo;
431 ULONG apptype;
432 APIRET rc;
433
434 if (!arcname || !arcinfo)
435 return 0;
436
437 info = *arcinfo;
438 if (!info)
439 info = find_type(arcname, NULL);
440 for (x = 0; x < 99; x++) {
441 sprintf(arctemp, "%s.%03x", ArcTempRoot, (clock() & 4095L));
442 if (IsFile(arctemp) == 1)
443 DosSleep(rand() % 100);
444 else
445 break;
446 }
447
448ReTry:
449
450#ifdef DEBUG
451 if (info && info->id)
452 WinSetWindowText(WinQueryWindow
453 (WinQueryWindow(hwndCnr, QW_PARENT), QW_PARENT),
454 info->id);
455#endif
456
457 tinfo = NULL;
458 numarcfiles = counter = highest = 0;
459 gotstart = gotend = FALSE;
460 lastpai = NULL;
461 *pullTotalBytes = 0;
462 if (!info || !info->list)
463 Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
464 else {
465 RemoveArcItems(hwndCnr, NULL, 0, CMA_FREE | CMA_INVALIDATE | CMA_ERASE);
466 *arcinfo = info;
467 highest = info->osizepos;
468 if (info->nsizepos > highest)
469 highest = info->nsizepos;
470 if (info->fdpos > highest)
471 highest = info->fdpos;
472 if (info->fnpos > highest)
473 highest = info->fnpos;
474 if (highest > 50) {
475 saymsg(MB_ENTER | MB_ICONEXCLAMATION, HWND_DESKTOP,
476 GetPString(IDS_SHAMETEXT), "%s", GetPString(IDS_BUNGEDUPTEXT));
477 }
478 if (info->fnpos == -1)
479 highest = 32767;
480
481 DosError(FERR_DISABLEHARDERR);
482 DosForceDelete(arctemp);
483 DosError(FERR_DISABLEHARDERR);
484
485 strcpy(s, info->list);
486 p = strchr(s, ' ');
487 if (p)
488 *p = 0;
489 DosError(FERR_DISABLEHARDERR);
490 if (!DosQueryAppType(s, &apptype) &&
491 (apptype & FAPPTYP_DOS ||
492 apptype & FAPPTYP_WINDOWSREAL ||
493 apptype & FAPPTYP_WINDOWSPROT ||
494 apptype & FAPPTYP_WINDOWSPROT31)) {
495 p = GetCmdSpec(TRUE);
496 runemf2(SEPARATE | INVISIBLE | MINIMIZED | BACKGROUND | WAIT,
497 hwndCnr, pszSrcFile, __LINE__, NULL, "DOS_BACKGROUND_EXECUTION=1",
498 "%s /C %s %s >%s",
499 p, // shell
500 info->list, // list command
501 BldQuotedFileName(s, arcname),
502 arctemp);
503 }
504 else {
505 fp = xfopen(arctemp, "w", pszSrcFile, __LINE__);
506 if (!fp)
507 return 0;
508 else {
509 newstdout = -1;
510 DosError(FERR_DISABLEHARDERR);
511 rc = DosDupHandle(fileno(stdout), &newstdout);
512 if (rc) {
513 Dos_Error(MB_CANCEL, rc, hwndCnr, pszSrcFile, __LINE__,
514 "DosDupHandle");
515 return 0;
516 }
517 else {
518 oldstdout = fileno(stdout);
519 DosError(FERR_DISABLEHARDERR);
520 rc = DosDupHandle(fileno(fp), &oldstdout);
521 if (rc) {
522 Dos_Error(MB_CANCEL, rc, hwndCnr, pszSrcFile, __LINE__,
523 "DosDupHandle");
524 return 0;
525 }
526 else {
527 runemf2(SEPARATE | INVISIBLE | FULLSCREEN | BACKGROUND | WAIT,
528 hwndCnr, pszSrcFile, __LINE__, NULL, NULL,
529 "%s %s",
530 info->list,
531 BldQuotedFileName(s, arcname));
532 oldstdout = fileno(stdout);
533 DosError(FERR_DISABLEHARDERR);
534 DosDupHandle(newstdout, &oldstdout);
535 DosClose(newstdout);
536 fclose(fp);
537 }
538 }
539 }
540 }
541
542 DosError(FERR_DISABLEHARDERR);
543 fp = _fsopen(arctemp, "r", SH_DENYWR);
544
545 if (fp) {
546 gotstart = !info->startlist || !*info->startlist; // If list has no start marker
547
548 while (!feof(fp) && !gotend && !*pStopFlag) {
549 if (!xfgets_bstripcr(s, sizeof(s), fp, pszSrcFile, __LINE__))
550 break;
551 if (!gotstart) {
552 if (!strcmp(s, info->startlist))
553 gotstart = TRUE;
554 }
555 else if (info->endlist && !strcmp(s, info->endlist))
556 gotend = TRUE;
557 else {
558 /* add to container */
559 fname = NULL;
560 bstrip(s);
561 if (info->nameisfirst) {
562 strncpy(lonename, s, CCHMAXPATH + 2);
563 lonename[CCHMAXPATH + 1] = 0;
564 fname = lonename;
565 if (!xfgets_bstripcr(s, sizeof(s), fp, pszSrcFile, __LINE__))
566 break;
567 if (*fname == '\"') {
568 memmove(fname, fname + 1, strlen(fname) + 1);
569 p = strchr(fname, '\"');
570 if (p)
571 *p = 0;
572 }
573 }
574 nsize = NULL;
575 osize = fdate = NullStr;
576 p = s;
577 for (x = 0; x <= highest; x++) {
578 pp = p;
579 while (*pp && (*pp == ' ' || *pp == '\t')) /* skip leading */
580 pp++;
581 if (!*pp)
582 break;
583 wasquote = FALSE;
584 p = pp;
585 while (*p && (wasquote ||
586 ((x != info->fnpos || !info->nameislast) ?
587 (*p != ' ' && *p != '\t') : TRUE))) {
588 if (*p == '\"') {
589 if (!wasquote) {
590 wasquote = TRUE;
591 memmove(p, p + 1, strlen(p));
592 while (*p == ' ' || *p == '\t')
593 p++;
594 }
595 else {
596 memmove(p, p + 1, strlen(p));
597 break;
598 }
599 }
600 else if (*p)
601 p++;
602 }
603 if (*p) {
604 *p = 0;
605 p++;
606 }
607 if (x == info->nsizepos)
608 nsize = pp;
609 else if (x == info->osizepos)
610 osize = pp;
611 else if (x == info->fdpos) {
612 fdate = pp;
613 if (info->fdflds > 1 && info->fdflds < 24) {
614 INT y;
615
616 if (*p) {
617 p--;
618 *p = ' ';
619 for (y = 0; y < info->fdflds - 1; y++) {
620 while (*p && (*p == ' ' || *p == '\t'))
621 p++;
622 while (*p && (*p != ' ' && *p != '\t'))
623 p++;
624 x++;
625 }
626 if (*p) {
627 *p = 0;
628 p++;
629 }
630 }
631 }
632 }
633 else if (x == info->fnpos) {
634 fname = pp;
635 if (pp && *pp == '*' && !*(pp + 1)) /* workaround for LH.EXE */
636 fname = NULL;
637 if (info->nameislast)
638 break;
639 }
640 else if ((!p || !*p) && info->fnpos == -1) {
641 fname = pp;
642 break;
643 }
644 }
645 if (info->nameisnext) {
646 if (!xfgets_bstripcr
647 (lonename, sizeof(lonename), fp, pszSrcFile, __LINE__))
648 break;
649 fname = lonename;
650 }
651 // fixme to complain?
652 if (fname && *fname) {
653
654 RECORDINSERT ri;
655 PARCITEM pai;
656
657#ifdef DEBUG
658 saymsg(MB_ENTER, hwndCnr, DEBUG_STRING,
659 "fname: %s\r\rpp: %s\r\rp: %s\r\rlonename: %s\r\rhighest: %ld\r\rx: %ld\r\rfdate: %s",
660 fname ? fname : "NULL",
661 pp ? pp : "NULL",
662 p ? p : "NULL",
663 lonename, highest, x, (fdate) ? fdate : "NULL");
664#endif
665
666 pai = WinSendMsg(hwndCnr,
667 CM_ALLOCRECORD,
668 MPFROMLONG(EXTRA_ARCRECORD_BYTES),
669 MPFROMLONG(1L));
670 if (!pai) {
671 Runtime_Error(pszSrcFile, __LINE__, "CM_ALLOCRECORD");
672 break;
673 }
674 else {
675 memset(pai, 0, sizeof(ARCITEM));
676 pai->hwndCnr = hwndCnr;
677 if (*fname == '*') {
678 fname++;
679 pai->flags = ARCFLAGS_REALDIR;
680 }
681 if (fname[strlen(fname) - 1] == '\\' ||
682 fname[strlen(fname) - 1] == '/')
683 pai->flags = ARCFLAGS_REALDIR;
684 pai->pszFileName = xstrdup(fname,pszSrcFile, __LINE__);
685 pai->pszDisplayName = pai->pszFileName;
686 pai->rc.pszIcon = pai->pszDisplayName;
687 if (fdate)
688 strcpy(pai->szDate, fdate);
689 // pai->pszFileName = pai->pszFileName;
690 pai->rc.pszIcon = pai->pszFileName;
691 pai->rc.hptrIcon = (pai->flags & ARCFLAGS_REALDIR) != 0 ?
692 hptrDir : hptrFile;
693 pai->pszDate = pai->szDate;
694 if (osize)
695 pai->cbFile = atol(osize);
696 if (nsize)
697 pai->cbComp = atol(nsize);
698 if (info->datetype && fdate && *fdate)
699 ArcDateTime(fdate, info->datetype, &pai->date, &pai->time);
700 memset(&ri, 0, sizeof(RECORDINSERT));
701 ri.cb = sizeof(RECORDINSERT);
702 ri.pRecordOrder = (PRECORDCORE) CMA_END;
703 ri.pRecordParent = (PRECORDCORE) NULL;
704 ri.zOrder = (USHORT) CMA_TOP;
705 ri.cRecordsInsert = 1L;
706 ri.fInvalidateRecord = FALSE;
707 if (WinSendMsg(hwndCnr,
708 CM_INSERTRECORD, MPFROMP(pai), MPFROMP(&ri))) {
709 *pullTotalBytes += pai->cbFile;
710 }
711 numarcfiles++;
712 if (!(++counter % 50)) {
713 if (!lastpai)
714 lastpai = pai;
715 WinSendMsg(hwndCnr,
716 CM_INVALIDATERECORD,
717 lastpai,
718 MPFROM2SHORT(10, CMA_ERASE | CMA_REPOSITION));
719 lastpai = pai;
720 }
721 // Avoid hogging system for large archive
722 if (numarcfiles == 100)
723 priority_idle();
724 }
725 }
726 }
727 } // while !eof
728
729 fclose(fp);
730
731 if (*pStopFlag)
732 numarcfiles = 0; // Request close
733 else if (!numarcfiles || !gotstart
734 || (!gotend && info->endlist && *info->endlist)) {
735 // Oops
736 ARCDUMP ad;
737 CHAR errstr[CCHMAXPATH + 256];
738
739 // Try for alternate archiver
740 tinfo = info;
741 do {
742 tinfo = tinfo->next;
743 if (tinfo)
744 tinfo = find_type(arcname, tinfo);
745 if (tinfo) {
746 DosError(FERR_DISABLEHARDERR);
747 DosForceDelete(arctemp);
748 info = tinfo;
749 goto ReTry;
750 }
751 } while (tinfo);
752 DosBeep(750, 50); // wake up user
753 sprintf(errstr, GetPString(IDS_ARCERRORINFOTEXT),
754 arcname,
755 !gotstart ? GetPString(IDS_NOGOTSTARTTEXT) : NullStr,
756 !numarcfiles ? GetPString(IDS_NOARCFILESFOUNDTEXT) :
757 NullStr,
758 !gotend ? GetPString(IDS_NOENDOFLISTTEXT) : NullStr);
759 memset(&ad, 0, sizeof(ARCDUMP));
760 ad.info = info;
761 strcpy(ad.listname, arctemp);
762 strcpy(ad.arcname, arcname);
763 ad.errmsg = errstr;
764 WinDlgBox(HWND_DESKTOP,
765 hwndCnr,
766 ArcErrProc, FM3ModHandle, ARCERR_FRAME, MPFROMP(&ad));
767 }
768 else if (!nomove && tinfo) {
769 /* if we got a false hit, move working hit to top */
770 tinfo = info->next;
771 info->next = arcsighead;
772 arcsighead->prev = info;
773 if (tinfo)
774 tinfo->next->prev = info->prev;
775 info->prev->next = tinfo;
776 info->prev = NULL;
777 arcsighead = info;
778 rewrite_archiverbb2(NULL); // Rewrite with warning
779 }
780 } // if opened
781
782 DosError(FERR_DISABLEHARDERR);
783 DosForceDelete(arctemp);
784 }
785
786 if (numarcfiles)
787 priority_normal();
788
789 return numarcfiles;
790}
791
792MRESULT EXPENTRY ArcTextProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
793{
794 static BOOL emphasized = FALSE;
795 static HWND hwndButtonPopup = (HWND) 0;
796 static ULONG timestamp = ULONG_MAX;
797 static USHORT lastid = 0;
798
799 switch (msg) {
800 case WM_CREATE:
801 return CommonTextProc(hwnd, msg, mp1, mp2);
802
803 case WM_COMMAND:
804 return WinSendMsg(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
805 ARC_CNR), msg, mp1, mp2);
806
807 case UM_CONTEXTMENU:
808 case WM_CONTEXTMENU:
809 {
810 USHORT id;
811
812 id = WinQueryWindowUShort(hwnd, QWS_ID);
813 switch (id) {
814 case DIR_SELECTED:
815 case DIR_VIEW:
816 case DIR_SORT:
817 {
818 POINTL ptl = { 0, 0 };
819 SWP swp;
820 DIRCNRDATA *dcd;
821
822 if (hwndButtonPopup)
823 WinDestroyWindow(hwndButtonPopup);
824 if (id == DIR_SELECTED)
825 id = DIR_RESTORE;
826 if (id == lastid) {
827
828 ULONG check;
829
830 DosQuerySysInfo(QSV_MS_COUNT, QSV_MS_COUNT, &check,
831 sizeof(check));
832 if (check < timestamp + 500) {
833 lastid = 0;
834 goto MenuAbort;
835 }
836 }
837 hwndButtonPopup = WinLoadMenu(HWND_DESKTOP, FM3ModHandle, id);
838 if (hwndButtonPopup) {
839 WinSetWindowUShort(hwndButtonPopup, QWS_ID, id);
840 dcd = WinQueryWindowPtr(WinWindowFromID(WinQueryWindow(hwnd,
841 QW_PARENT),
842 ARC_CNR), QWL_USER);
843 if (id == DIR_SORT) {
844 if (dcd)
845 SetSortChecks(hwndButtonPopup, dcd->sortFlags);
846 WinSendMsg(hwndButtonPopup,
847 MM_DELETEITEM,
848 MPFROM2SHORT(IDM_SORTNONE, FALSE), MPVOID);
849 WinSendMsg(hwndButtonPopup,
850 MM_DELETEITEM,
851 MPFROM2SHORT(IDM_SORTNAME, FALSE), MPVOID);
852 WinSendMsg(hwndButtonPopup,
853 MM_DELETEITEM,
854 MPFROM2SHORT(IDM_SORTLADATE, FALSE), MPVOID);
855 WinSendMsg(hwndButtonPopup,
856 MM_DELETEITEM,
857 MPFROM2SHORT(IDM_SORTCRDATE, FALSE), MPVOID);
858 WinSendMsg(hwndButtonPopup,
859 MM_DELETEITEM,
860 MPFROM2SHORT(IDM_SORTDIRSFIRST, FALSE), MPVOID);
861 WinSendMsg(hwndButtonPopup,
862 MM_DELETEITEM,
863 MPFROM2SHORT(IDM_SORTDIRSLAST, FALSE), MPVOID);
864 WinSendMsg(hwndButtonPopup,
865 MM_DELETEITEM,
866 MPFROM2SHORT(IDM_SORTSUBJECT, FALSE), MPVOID);
867 WinSendMsg(hwndButtonPopup,
868 MM_SETITEMTEXT,
869 MPFROM2SHORT(IDM_SORTEASIZE, 0),
870 MPFROMP(GetPString(IDS_COMPRESSEDSIZEMENUTEXT)));
871 WinSendMsg(hwndButtonPopup,
872 MM_SETITEMTEXT,
873 MPFROM2SHORT(IDM_SORTLWDATE, 0),
874 MPFROMP(GetPString(IDS_DATEMENUTEXT)));
875 }
876 ptl.x = 0;
877 if (WinPopupMenu(HWND_OBJECT,
878 HWND_OBJECT,
879 hwndButtonPopup, -32767, -32767, 0, 0)) {
880 WinQueryWindowPos(hwndButtonPopup, &swp);
881 ptl.y = -(swp.cy + 2);
882 }
883 else {
884 WinQueryWindowPos(hwnd, &swp);
885 ptl.y = swp.cy + 2;
886 }
887 if (WinPopupMenu(hwnd,
888 hwnd,
889 hwndButtonPopup,
890 ptl.x,
891 ptl.y,
892 0,
893 PU_HCONSTRAIN | PU_VCONSTRAIN |
894 PU_KEYBOARD | PU_MOUSEBUTTON1)) {
895 CenterOverWindow(hwndButtonPopup);
896 PaintRecessedWindow(hwnd, (HPS) 0, FALSE, FALSE);
897 }
898 }
899 }
900 break;
901 default:
902 PostMsg(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
903 ARC_CNR),
904 WM_CONTROL, MPFROM2SHORT(ARC_CNR, CN_CONTEXTMENU), MPVOID);
905 break;
906 }
907 }
908 MenuAbort:
909 if (msg == UM_CONTEXTMENU)
910 return 0;
911 break;
912
913 case WM_MENUEND:
914 if (hwndButtonPopup == (HWND) mp2) {
915 lastid = WinQueryWindowUShort((HWND) mp2, QWS_ID);
916 WinDestroyWindow(hwndButtonPopup);
917 hwndButtonPopup = (HWND) 0;
918 DosQuerySysInfo(QSV_MS_COUNT, QSV_MS_COUNT, &timestamp,
919 sizeof(timestamp));
920 switch (lastid) {
921 case DIR_VIEW:
922 case DIR_SORT:
923 case DIR_RESTORE:
924 case DIR_SELECTED:
925 PaintRecessedWindow(hwnd, (HPS) 0, TRUE, FALSE);
926 break;
927 }
928 }
929 break;
930
931 case WM_MOUSEMOVE:
932 {
933 USHORT id = WinQueryWindowUShort(hwnd, QWS_ID);
934 char *s = NULL;
935
936 if (fOtherHelp) {
937 if ((!hwndBubble ||
938 WinQueryWindowULong(hwndBubble, QWL_USER) != hwnd) &&
939 !WinQueryCapture(HWND_DESKTOP)) {
940 switch (id) {
941 case DIR_TOTALS:
942 s = GetPString(IDS_ARCCNRTOTALSHELPTEXT);
943 break;
944 case DIR_SELECTED:
945 s = GetPString(IDS_ARCCNRSELECTEDHELPTEXT);
946 break;
947 case DIR_VIEW:
948 s = GetPString(IDS_ARCCNRVIEWHELPTEXT);
949 break;
950 case DIR_SORT:
951 s = GetPString(IDS_DIRCNRSORTHELP);
952 break;
953 case DIR_FILTER:
954 s = GetPString(IDS_DIRCNRFILTERHELP);
955 break;
956 case DIR_FOLDERICON:
957 s = GetPString(IDS_ARCCNRFOLDERHELPTEXT);
958 break;
959 default:
960 break;
961 }
962 if (s)
963 MakeBubble(hwnd, TRUE, s);
964 else if (hwndBubble)
965 WinDestroyWindow(hwndBubble);
966 }
967 }
968 switch (id) {
969 case DIR_FILTER:
970 case DIR_SORT:
971 case DIR_VIEW:
972 case DIR_SELECTED:
973 case DIR_FOLDERICON:
974 return CommonTextButton(hwnd, msg, mp1, mp2);
975 }
976 }
977 break;
978
979 case WM_BUTTON3UP:
980 case WM_BUTTON1UP:
981 case WM_BUTTON1DOWN:
982 case WM_BUTTON3DOWN:
983 {
984 USHORT id;
985
986 id = WinQueryWindowUShort(hwnd, QWS_ID);
987 switch (id) {
988 case DIR_FILTER:
989 case DIR_SORT:
990 case DIR_VIEW:
991 case DIR_SELECTED:
992 case DIR_FOLDERICON:
993 return CommonTextButton(hwnd, msg, mp1, mp2);
994 }
995 }
996 break;
997
998 case UM_CLICKED:
999 case UM_CLICKED3:
1000 {
1001 USHORT id, cmd = 0;
1002
1003 id = WinQueryWindowUShort(hwnd, QWS_ID);
1004 switch (id) {
1005 case DIR_FOLDERICON:
1006 switch (msg) {
1007 case WM_BUTTON3CLICK:
1008 case WM_CHORD:
1009 cmd = IDM_RESCAN;
1010 break;
1011 default:
1012 if ((SHORT2FROMMP(mp2) & KC_ALT) != 0)
1013 cmd = IDM_WINDOWDLG;
1014 else
1015 cmd = IDM_WALKDIR;
1016 break;
1017 }
1018 break;
1019 case DIR_VIEW:
1020 case DIR_SORT:
1021 case DIR_SELECTED:
1022 PostMsg(hwnd, UM_CONTEXTMENU, MPVOID, MPVOID);
1023 break;
1024 case DIR_FILTER:
1025 cmd = IDM_FILTER;
1026 break;
1027 default:
1028 break;
1029 }
1030 if (cmd)
1031 PostMsg(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
1032 ARC_CNR),
1033 WM_COMMAND, MPFROM2SHORT(cmd, 0), MPVOID);
1034 }
1035 return 0;
1036
1037 case WM_BEGINDRAG:
1038 case DM_DROP:
1039 case DM_DRAGOVER:
1040 case DM_DRAGLEAVE:
1041 case DM_DROPHELP:
1042 if (msg == DM_DRAGOVER) {
1043 if (!emphasized) {
1044 emphasized = TRUE;
1045 DrawTargetEmphasis(hwnd, emphasized);
1046 }
1047 }
1048 else if (msg != WM_BEGINDRAG) {
1049 if (emphasized) {
1050 emphasized = FALSE;
1051 DrawTargetEmphasis(hwnd, emphasized);
1052 }
1053 }
1054 switch (WinQueryWindowUShort(hwnd, QWS_ID)) {
1055 case DIR_FOLDERICON:
1056 switch (msg) {
1057 case DM_DRAGOVER:
1058 if (AcceptOneDrop(hwnd, mp1, mp2))
1059 return MRFROM2SHORT(DOR_DROP, DO_MOVE);
1060 return MRFROM2SHORT(DOR_NODROP, 0); /* Drop not valid */
1061 case DM_DROPHELP:
1062 DropHelp(mp1, mp2, hwnd, GetPString(IDS_ARCCNRFOLDERDROPHELPTEXT));
1063 return 0;
1064 case DM_DROP:
1065 {
1066 char szFrom[CCHMAXPATH + 2];
1067
1068 if (emphasized) {
1069 emphasized = FALSE;
1070 DrawTargetEmphasis(hwnd, emphasized);
1071 }
1072 if (GetOneDrop(hwnd, mp1, mp2, szFrom, sizeof(szFrom)))
1073 WinSendMsg(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
1074 ARC_CNR),
1075 WM_COMMAND,
1076 MPFROM2SHORT(IDM_SWITCH, 0), MPFROMP(szFrom));
1077 }
1078 return 0;
1079 default:
1080 return PFNWPStatic(hwnd, msg, mp1, mp2);
1081 }
1082 default:
1083 {
1084 CNRDRAGINFO cnd;
1085 USHORT dcmd;
1086
1087 switch (msg) {
1088 case DM_DROP:
1089 dcmd = CN_DROP;
1090 break;
1091 case DM_DRAGOVER:
1092 dcmd = CN_DRAGOVER;
1093 break;
1094 case DM_DRAGLEAVE:
1095 dcmd = CN_DRAGLEAVE;
1096 break;
1097 case DM_DROPHELP:
1098 dcmd = CN_DROPHELP;
1099 break;
1100 case WM_BEGINDRAG:
1101 dcmd = CN_INITDRAG;
1102 break;
1103 }
1104 cnd.pDragInfo = (PDRAGINFO) mp1;
1105 cnd.pRecord = NULL;
1106 return WinSendMsg(WinQueryWindow(hwnd, QW_PARENT),
1107 WM_CONTROL,
1108 MPFROM2SHORT(ARC_CNR, dcmd), MPFROMP(&cnd));
1109 }
1110 }
1111 }
1112 return PFNWPStatic(hwnd, msg, mp1, mp2);
1113}
1114
1115MRESULT EXPENTRY ArcClientWndProc(HWND hwnd, ULONG msg, MPARAM mp1,
1116 MPARAM mp2)
1117{
1118
1119 switch (msg) {
1120 case UM_CONTAINERHWND:
1121 return MRFROMLONG(WinWindowFromID(hwnd, ARC_CNR));
1122
1123 case UM_VIEWSMENU:
1124 // fixme to disble menu items as needed
1125 return MRFROMLONG(CheckMenu(hwnd, &ArcCnrMenu, ARCCNR_POPUP));
1126
1127 case UM_FILESMENU:
1128 // fixme to disble menu items as needed
1129 return MRFROMLONG(CheckMenu(hwnd, &ArcMenu, ARC_POPUP));
1130
1131 case MM_PORTHOLEINIT:
1132 case WM_INITMENU:
1133 case UM_INITMENU:
1134 case UM_COMMAND:
1135 case UM_LOADFILE:
1136 case UM_UPDATERECORD:
1137 case UM_UPDATERECORDLIST:
1138 case WM_COMMAND:
1139 case WM_CONTROL:
1140 case WM_CLOSE:
1141 return WinSendMsg(WinWindowFromID(hwnd, ARC_CNR), msg, mp1, mp2);
1142
1143 case WM_PSETFOCUS:
1144 case WM_SETFOCUS:
1145 if (mp2)
1146 PostMsg(hwnd, UM_FOCUSME, MPVOID, MPVOID);
1147 break;
1148
1149 case UM_FOCUSME:
1150 WinSetFocus(HWND_DESKTOP, WinWindowFromID(hwnd, ARC_CNR));
1151 break;
1152
1153 case WM_PAINT:
1154 {
1155 HPS hps;
1156 RECTL rcl;
1157
1158 hps = WinBeginPaint(hwnd, (HPS) 0, NULL);
1159 if (hps) {
1160 WinQueryWindowRect(hwnd, &rcl);
1161 WinFillRect(hps, &rcl, CLR_PALEGRAY);
1162 CommonTextPaint(hwnd, hps);
1163 WinEndPaint(hps);
1164 }
1165 }
1166 break;
1167
1168 case UM_SIZE:
1169 case WM_SIZE:
1170 if (msg == UM_SIZE) {
1171
1172 SWP swp;
1173
1174 WinQueryWindowPos(hwnd, &swp);
1175 mp1 = MPFROM2SHORT(swp.cx, swp.cy);
1176 mp2 = MPFROM2SHORT(swp.cx, swp.cy);
1177 }
1178 {
1179 USHORT cx, cy, bx;
1180
1181 cx = SHORT1FROMMP(mp2);
1182 cy = SHORT2FROMMP(mp2);
1183 WinSetWindowPos(WinWindowFromID(hwnd, ARC_CNR), HWND_TOP,
1184 0,
1185 22, cx, cy - (24 + 22), SWP_SHOW | SWP_MOVE | SWP_SIZE);
1186 WinSetWindowPos(WinWindowFromID(hwnd, ARC_EXTRACTDIR), HWND_TOP,
1187 0, 0, cx, 22, SWP_SHOW | SWP_MOVE | SWP_SIZE);
1188 WinSetWindowPos(WinWindowFromID(hwnd, DIR_FOLDERICON), HWND_TOP,
1189 2, cy - 22, 24, 20, SWP_SHOW | SWP_MOVE | SWP_SIZE);
1190 WinSetWindowPos(WinWindowFromID(hwnd, DIR_TOTALS), HWND_TOP,
1191 29,
1192 cy - 22,
1193 (cx / 3) - 2, 20, SWP_SHOW | SWP_MOVE | SWP_SIZE);
1194 WinSetWindowPos(WinWindowFromID(hwnd, DIR_SELECTED), HWND_TOP,
1195 29 + (cx / 3) + 2,
1196 cy - 22,
1197 (cx / 3) - 2, 20, SWP_SHOW | SWP_MOVE | SWP_SIZE);
1198 bx = (cx - (29 + (((cx / 3) + 2) * 2))) / 3;
1199 WinSetWindowPos(WinWindowFromID(hwnd, DIR_VIEW), HWND_TOP,
1200 29 + (((cx / 3) + 2) * 2),
1201 cy - 22, bx - 4, 20, SWP_SHOW | SWP_MOVE | SWP_SIZE);
1202 WinSetWindowPos(WinWindowFromID(hwnd, DIR_SORT), HWND_TOP,
1203 29 + (((cx / 3) + 2) * 2) + bx,
1204 cy - 22, bx - 4, 20, SWP_SHOW | SWP_MOVE | SWP_SIZE);
1205 WinSetWindowPos(WinWindowFromID(hwnd, DIR_FILTER), HWND_TOP,
1206 29 + (((cx / 3) + 2) * 2) + (bx * 2),
1207 cy - 22, bx - 4, 20, SWP_SHOW | SWP_MOVE | SWP_SIZE);
1208 }
1209 CommonTextPaint(hwnd, (HPS) 0);
1210 if (msg == UM_SIZE) {
1211 WinSetWindowPos(WinQueryWindow(hwnd, QW_PARENT), HWND_TOP, 0, 0, 0, 0,
1212 SWP_SHOW | SWP_ZORDER | SWP_ACTIVATE);
1213 return 0;
1214 }
1215 break;
1216 }
1217 return WinDefWindowProc(hwnd, msg, mp1, mp2);
1218}
1219
1220MRESULT EXPENTRY ArcObjWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
1221{
1222 DIRCNRDATA *dcd;
1223 PSZ psz;
1224 CHAR szQuotedArcName[CCHMAXPATH];
1225 CHAR szQuotedMemberName[CCHMAXPATH];
1226
1227 switch (msg) {
1228 case DM_PRINTOBJECT:
1229 case DM_DISCARDOBJECT:
1230 dcd = INSTDATA(hwnd);
1231 if (dcd) {
1232
1233 LISTINFO *li;
1234 CNRDRAGINFO cni;
1235
1236 cni.pRecord = NULL;
1237 cni.pDragInfo = (PDRAGINFO) mp1;
1238 li = DoFileDrop(dcd->hwndCnr,
1239 dcd->directory, FALSE, MPVOID, MPFROMP(&cni));
1240 CheckPmDrgLimit(cni.pDragInfo);
1241 if (li) {
1242 li->type = (msg == DM_DISCARDOBJECT) ? IDM_DELETE : IDM_PRINT;
1243 if (!li->list ||
1244 !li->list[0] || !PostMsg(hwnd, UM_ACTION, MPFROMP(li), MPVOID))
1245 FreeListInfo(li);
1246 else
1247 return MRFROMLONG(DRR_SOURCE);
1248 }
1249 }
1250 return MRFROMLONG(DRR_TARGET);
1251
1252 case DM_RENDERPREPARE:
1253 return (MRESULT) TRUE;
1254
1255 case DM_RENDER:
1256 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
1257 if (dcd && dcd->info && dcd->info->extract && dcd->arcname) {
1258
1259 PDRAGTRANSFER pdt = (PDRAGTRANSFER) mp1;
1260 CHAR filename[CCHMAXPATH];
1261 ULONG len;
1262
1263 if (pdt->hwndClient && pdt->pditem && pdt->hstrSelectedRMF &&
1264 pdt->hstrRenderToName) {
1265 if (pdt->usOperation == DO_COPY || pdt->usOperation == DO_MOVE) {
1266 *filename = 0;
1267 len = DrgQueryStrName(pdt->hstrSelectedRMF, CCHMAXPATH, filename);
1268 filename[len] = 0;
1269 if (!strnicmp(filename, "OS2FILE,", 8)) {
1270 // saymsg(MB_ENTER,HWND_DESKTOP,DEBUG_STRING,"RMF = \"%s\"",filename);
1271 }
1272 else {
1273 *filename = 0;
1274 len =
1275 DrgQueryStrName(pdt->hstrRenderToName, CCHMAXPATH, filename);
1276 filename[len] = 0;
1277 if (len && *filename) {
1278 psz = xstrdup(filename, pszSrcFile, __LINE__);
1279 if (psz) {
1280 PostMsg(hwnd, UM_RENDER, MPFROMP(pdt), MPFROMP(psz));
1281 return (MRESULT) TRUE;
1282 }
1283 }
1284 else {
1285 // saymsg(MB_ENTER,HWND_DESKTOP,DEBUG_STRING,"No render-to name given.");
1286 }
1287 }
1288 }
1289 pdt->fsReply = DMFL_RENDERRETRY;
1290 }
1291 }
1292 return (MRESULT) FALSE;
1293
1294 case UM_RENDER:
1295 {
1296 PDRAGTRANSFER pdt = (PDRAGTRANSFER) mp1;
1297 USHORT usRes = DMFL_RENDERFAIL;
1298
1299 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
1300 if (dcd && dcd->info && dcd->info->extract && dcd->arcname) {
1301
1302 CHAR *filename = (CHAR *) mp2, *p;
1303 ULONG len;
1304 CHAR membername[CCHMAXPATH], construct[CCHMAXPATH * 2];
1305
1306 *membername = 0;
1307 len = DrgQueryStrName(pdt->pditem->hstrSourceName,
1308 CCHMAXPATH, membername);
1309 membername[len] = 0;
1310 if (*membername && len && filename) {
1311 unlinkf("%s", filename);
1312 strcpy(construct, filename);
1313 p = strrchr(filename, '\\');
1314 if (!p)
1315 *construct = 0;
1316 else {
1317 if (p == filename || *(p - 1) == ':')
1318 p++;
1319 *p = 0;
1320 }
1321 // saymsg(MB_ENTER,HWND_DESKTOP,DEBUG_STRING,"%s %s %s\r[%s]",dcd->info->extract,dcd->arcname,membername,construct);
1322 runemf2(SEPARATE | WINDOWED | WAIT |
1323 (fArcStuffVisible ? 0 : BACKGROUND | MINIMIZED),
1324 dcd->hwndClient, pszSrcFile, __LINE__, construct, NULL,
1325 "%s %s %s",
1326 dcd->info->extract,
1327 BldQuotedFileName(szQuotedArcName, dcd->arcname),
1328 BldQuotedFileName(szQuotedMemberName, membername));
1329 BldFullPathName(construct, construct, membername);
1330 if (IsFile(construct) != -1) {
1331 rename(construct, filename);
1332 unlinkf("%s", construct);
1333 if (IsFile(filename) != -1)
1334 usRes = DMFL_RENDEROK;
1335 }
1336 }
1337 }
1338 xfree((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 xfree(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 xfree(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 > MaxComLineStrg) {
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 xfree(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 xfree(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 xfree((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 xfree(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 xfree(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 xfree(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 xfree(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 xfree(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.