source: trunk/dll/arccnrs.c@ 1011

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

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