source: trunk/dll/arccnrs.c@ 1068

Last change on this file since 1068 was 1068, checked in by John Small, 17 years ago

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