source: trunk/dll/arccnrs.c@ 197

Last change on this file since 197 was 172, checked in by root, 20 years ago

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