source: trunk/dll/arccnrs.c@ 123

Last change on this file since 123 was 123, checked in by root, 21 years ago

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