source: trunk/dll/arccnrs.c@ 240

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

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