source: trunk/dll/arccnrs.c@ 15

Last change on this file since 15 was 2, checked in by root, 23 years ago

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