source: trunk/dll/arccnrs.c@ 300

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

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