source: trunk/dll/arccnrs.c@ 918

Last change on this file since 918 was 917, checked in by Steven Levine, 18 years ago

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