source: trunk/dll/arccnrs.c@ 426

Last change on this file since 426 was 426, checked in by root, 19 years ago

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