source: trunk/dll/arccnrs.c@ 1078

Last change on this file since 1078 was 1078, checked in by Steven Levine, 17 years ago

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