source: trunk/dll/arccnrs.c@ 284

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

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