source: trunk/dll/arccnrs.c@ 358

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

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