source: trunk/dll/arccnrs.c@ 377

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

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