source: trunk/dll/arccnrs.c@ 377

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

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