source: trunk/dll/arccnrs.c@ 985

Last change on this file since 985 was 985, checked in by Gregg Young, 17 years ago

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