source: trunk/dll/arccnrs.c@ 406

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

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