source: trunk/dll/arccnrs.c@ 30

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

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