source: trunk/dll/arccnrs.c@ 212

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

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