source: trunk/dll/arccnrs.c@ 627

Last change on this file since 627 was 627, checked in by Gregg Young, 19 years ago

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