source: trunk/dll/arccnrs.c@ 119

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

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