source: trunk/dll/arccnrs.c@ 510

Last change on this file since 510 was 460, checked in by root, 19 years ago

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