source: trunk/dll/arccnrs.c@ 300

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

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