source: trunk/dll/arccnrs.c@ 171

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

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