source: trunk/dll/arccnrs.c@ 506

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

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