source: trunk/dll/arccnrs.c@ 27

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

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