source: trunk/dll/arccnrs.c@ 613

Last change on this file since 613 was 606, checked in by Gregg Young, 19 years ago

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