source: trunk/dll/arccnrs.c@ 627

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

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