source: trunk/dll/arccnrs.c@ 249

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

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