source: trunk/dll/arccnrs.c@ 229

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

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