source: trunk/dll/arccnrs.c@ 1069

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

Fixes trap on viewing multiple files from an archive Ticket 248. Also includes initial code for using TMP directory for Temp files.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 99.5 KB
RevLine 
[27]1
2/***********************************************************************
3
4 $Id: arccnrs.c 1069 2008-07-16 23:53:38Z gyoung $
5
[123]6 Archive containers
7
[28]8 Copyright (c) 1993-98 M. Kimes
[907]9 Copyright (c) 2001, 2008 Steven H. Levine
[27]10
[130]11 11 Jun 02 SHL Ensure archive name not garbage
12 22 May 03 SHL ArcObjWndProc: fix UM_RESCAN now that we understand it
13 01 Aug 04 SHL Rework lstrip/rstrip usage
14 23 May 05 SHL Use QWL_USER
[156]15 25 May 05 SHL Rename comnam to szCommonName and fix typo
16 25 May 05 SHL Use ULONGLONG and CommaFmtULL
[212]17 05 Jun 05 SHL Drop obsolete, localize
18 05 Jun 05 SHL Correct last sort logic
19 05 Jun 05 SHL Use QWL_USER
[229]20 22 Jun 05 SHL ArcSort: correct typo in last sort fix
[249]21 13 Aug 05 SHL FillArcCnr: optimize
[300]22 08 Dec 05 SHL FillArcCnr: allow list start and end markers to be empty (i.e. tar)
23 08 Dec 05 SHL ArcCnrWndProc: suppress IDM_EXTRACT if no simple extract (i.e. tar)
24 30 Dec 05 SHL ArcCnrWndProc: correct date/time column display setup
25 29 May 06 SHL Comments
[358]26 14 Jul 06 SHL Use Runtime_Error
[367]27 26 Jul 06 SHL Correct SelectAll usage
[406]28 29 Jul 06 SHL Use xfgets_bstripcr
[423]29 31 Jul 06 SHL Lower priority for archives with more than 1000 entries
[426]30 02 Aug 06 SHL Add logic to stop processing large archives
[460]31 23 Aug 06 SHL Integrate John Small's switch list title logic
[531]32 03 Nov 06 SHL Renames
[562]33 14 Mar 07 SHL ArcObjWndProc/UM_ENTER: delay before starting viewer
[593]34 30 Mar 07 GKY Remove GetPString for window class names
[618]35 06 Apr 07 GKY Work around PM DragInfo and DrgFreeISH limit
[606]36 06 Apr 07 GKY Add some error checking in drag/drop
[618]37 20 Apr 07 SHL Sync with NumItemsToUnhilite mods
[627]38 21 Apr 07 GKY Find FM2Utils by path or utils directory
[672]39 12 May 07 SHL Use dcd->ulItemsToUnHilite; sync with UnHilite arg mods
[688]40 10 Jun 07 GKY Add CheckPmDrgLimit including IsFm2Window as part of work around PM drag limit
[696]41 16 Jun 07 SHL Use DosQueryAppType not DosQAppType
[751]42 02 Aug 07 SHL Sync with ARCITEM mods
[773]43 06 Aug 07 SHL Use BldFullPathName and BldQuotedFileName
44 06 Aug 07 SHL Move BldQuotedFileName and BldQuotedFullPathNamehere
45 to be near primary caller
[775]46 06 Aug 07 GKY Reduce DosSleep times (ticket 148)
[793]47 20 Aug 07 GKY Move #pragma alloc_text to end for OpenWatcom compat
[814]48 26 Aug 07 GKY DosSleep(1) in loops changed to (0)
[872]49 22 Nov 07 GKY Use CopyPresParams to fix presparam inconsistencies in menus
[897]50 30 Dec 07 GKY Use TestCDates for sort by date
[917]51 10 Jan 08 SHL Sync with CfgDlgProc mods
[946]52 10 Feb 08 GKY Implement bubble help for bitmap menu items
[953]53 15 Feb 08 SHL Sync with settings menu rework
[985]54 29 Feb 08 GKY Use xfree where appropriate
[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;
341 pai->pszFileName = NullStr;
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) {
1232 case DM_PRINTOBJECT:
1233 case DM_DISCARDOBJECT:
1234 dcd = INSTDATA(hwnd);
1235 if (dcd) {
[2]1236
[551]1237 LISTINFO *li;
1238 CNRDRAGINFO cni;
[2]1239
[551]1240 cni.pRecord = NULL;
1241 cni.pDragInfo = (PDRAGINFO) mp1;
1242 li = DoFileDrop(dcd->hwndCnr,
[762]1243 dcd->directory, FALSE, MPVOID, MPFROMP(&cni));
[687]1244 CheckPmDrgLimit(cni.pDragInfo);
[551]1245 if (li) {
1246 li->type = (msg == DM_DISCARDOBJECT) ? IDM_DELETE : IDM_PRINT;
1247 if (!li->list ||
1248 !li->list[0] || !PostMsg(hwnd, UM_ACTION, MPFROMP(li), MPVOID))
1249 FreeListInfo(li);
1250 else
1251 return MRFROMLONG(DRR_SOURCE);
[2]1252 }
[551]1253 }
1254 return MRFROMLONG(DRR_TARGET);
[2]1255
[551]1256 case DM_RENDERPREPARE:
1257 return (MRESULT) TRUE;
[2]1258
[551]1259 case DM_RENDER:
1260 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
1261 if (dcd && dcd->info && dcd->info->extract && dcd->arcname) {
[2]1262
[551]1263 PDRAGTRANSFER pdt = (PDRAGTRANSFER) mp1;
1264 CHAR filename[CCHMAXPATH];
1265 ULONG len;
[2]1266
[551]1267 if (pdt->hwndClient && pdt->pditem && pdt->hstrSelectedRMF &&
1268 pdt->hstrRenderToName) {
1269 if (pdt->usOperation == DO_COPY || pdt->usOperation == DO_MOVE) {
1270 *filename = 0;
1271 len = DrgQueryStrName(pdt->hstrSelectedRMF, CCHMAXPATH, filename);
1272 filename[len] = 0;
1273 if (!strnicmp(filename, "OS2FILE,", 8)) {
1274 // saymsg(MB_ENTER,HWND_DESKTOP,DEBUG_STRING,"RMF = \"%s\"",filename);
1275 }
1276 else {
1277 *filename = 0;
1278 len =
1279 DrgQueryStrName(pdt->hstrRenderToName, CCHMAXPATH, filename);
1280 filename[len] = 0;
1281 if (len && *filename) {
1282 psz = xstrdup(filename, pszSrcFile, __LINE__);
1283 if (psz) {
1284 PostMsg(hwnd, UM_RENDER, MPFROMP(pdt), MPFROMP(psz));
1285 return (MRESULT) TRUE;
1286 }
1287 }
[358]1288 else {
[551]1289 // saymsg(MB_ENTER,HWND_DESKTOP,DEBUG_STRING,"No render-to name given.");
[358]1290 }
1291 }
[551]1292 }
1293 pdt->fsReply = DMFL_RENDERRETRY;
[2]1294 }
[551]1295 }
1296 return (MRESULT) FALSE;
[2]1297
[551]1298 case UM_RENDER:
1299 {
1300 PDRAGTRANSFER pdt = (PDRAGTRANSFER) mp1;
1301 USHORT usRes = DMFL_RENDERFAIL;
[2]1302
[551]1303 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
1304 if (dcd && dcd->info && dcd->info->extract && dcd->arcname) {
[2]1305
[551]1306 CHAR *filename = (CHAR *) mp2, *p;
1307 ULONG len;
1308 CHAR membername[CCHMAXPATH], construct[CCHMAXPATH * 2];
[2]1309
[551]1310 *membername = 0;
1311 len = DrgQueryStrName(pdt->pditem->hstrSourceName,
1312 CCHMAXPATH, membername);
1313 membername[len] = 0;
1314 if (*membername && len && filename) {
1315 unlinkf("%s", filename);
1316 strcpy(construct, filename);
1317 p = strrchr(filename, '\\');
1318 if (!p)
1319 *construct = 0;
1320 else {
1321 if (p == filename || *(p - 1) == ':')
1322 p++;
1323 *p = 0;
1324 }
1325 // saymsg(MB_ENTER,HWND_DESKTOP,DEBUG_STRING,"%s %s %s\r[%s]",dcd->info->extract,dcd->arcname,membername,construct);
1326 runemf2(SEPARATE | WINDOWED | WAIT |
[888]1327 (fArcStuffVisible ? 0 : BACKGROUND | MINIMIZED),
1328 dcd->hwndClient, pszSrcFile, __LINE__, construct, NULL,
[773]1329 "%s %s %s",
[551]1330 dcd->info->extract,
[773]1331 BldQuotedFileName(szQuotedArcName, dcd->arcname),
1332 BldQuotedFileName(szQuotedMemberName, membername));
1333 BldFullPathName(construct, construct, membername);
[551]1334 if (IsFile(construct) != -1) {
1335 rename(construct, filename);
1336 unlinkf("%s", construct);
1337 if (IsFile(filename) != -1)
1338 usRes = DMFL_RENDEROK;
1339 }
1340 }
[2]1341 }
[1009]1342 xfree((CHAR *)mp2, pszSrcFile, __LINE__);
[551]1343 PostMsg(pdt->hwndClient, DM_RENDERCOMPLETE, MPFROMP(pdt),
1344 MPFROM2SHORT(usRes, 0));
1345 }
1346 return 0;
[2]1347
[551]1348 case UM_SETUP:
1349 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
1350 if (!dcd) {
1351 Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
1352 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
1353 }
1354 else {
1355 /* set unique id */
1356 WinSetWindowUShort(hwnd, QWS_ID, ARCOBJ_FRAME + (ARC_FRAME - dcd->id));
1357 dcd->hwndObject = hwnd; // pass back hwnd
1358 if (ParentIsDesktop(hwnd, dcd->hwndParent))
[771]1359 DosSleep(100); //05 Aug 07 GKY 250 // Avoid race?
[551]1360 }
1361 return 0;
1362
1363 case UM_RESCAN:
1364 /*
1365 * populate container
1366 */
1367 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
1368 if (dcd) {
1369 if (mp1)
1370 strcpy(dcd->arcname, (CHAR *) mp1); // Update name on request
1371 dcd->ullTotalBytes = dcd->totalfiles =
1372 dcd->selectedfiles = dcd->selectedbytes = 0;
1373 WinSetDlgItemText(dcd->hwndClient, DIR_TOTALS, "0");
1374 WinSetDlgItemText(dcd->hwndClient, DIR_SELECTED, "0 / 0k");
1375 dcd->totalfiles = FillArcCnr(dcd->hwndCnr,
1376 dcd->arcname,
1377 &dcd->info,
1378 &dcd->ullTotalBytes, &dcd->stopflag);
1379 if (!dcd->totalfiles)
1380 PostMsg(dcd->hwndCnr, WM_CLOSE, MPVOID, MPVOID);
[423]1381 else {
[551]1382 dcd->arcfilled = TRUE;
1383 if (!PostMsg(dcd->hwndCnr, UM_RESCAN, MPVOID, MPVOID))
1384 WinSendMsg(dcd->hwndCnr, UM_RESCAN, MPVOID, MPVOID);
1385 PostMsg(dcd->hwndCnr, UM_SETUP2, MPVOID, MPVOID);
1386 WinSendMsg(dcd->hwndCnr,
1387 CM_INVALIDATERECORD,
1388 MPVOID, MPFROM2SHORT(0, CMA_ERASE | CMA_REPOSITION));
[2]1389 }
[551]1390 }
1391 return 0;
[2]1392
[551]1393 case UM_SELECT:
1394 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
1395 if (dcd) {
1396 switch (SHORT1FROMMP(mp1)) {
1397 case IDM_SELECTALL:
1398 case IDM_SELECTALLFILES:
1399 SelectAll(dcd->hwndCnr, TRUE, TRUE, NULL, NULL, TRUE);
1400 break;
1401 case IDM_DESELECTALL:
1402 case IDM_DESELECTALLFILES:
1403 DeselectAll(dcd->hwndCnr, TRUE, TRUE, NULL, NULL, TRUE);
1404 break;
1405 case IDM_DESELECTMASK:
1406 case IDM_SELECTMASK:
1407 {
1408 MASK mask;
1409 PARCITEM pci = (PARCITEM) mp2;
[2]1410
[551]1411 memset(&mask, 0, sizeof(MASK));
1412 mask.fNoAttribs = TRUE;
1413 mask.fNoDirs = TRUE;
1414 strcpy(mask.prompt,
1415 GetPString((SHORT1FROMMP(mp1) == IDM_SELECTMASK) ?
1416 IDS_SELECTFILTERTEXT : IDS_DESELECTFILTERTEXT));
1417 if (pci && (INT) pci != -1)
[730]1418 strcpy(mask.szMask, pci->pszFileName);
[551]1419 if (WinDlgBox(HWND_DESKTOP, dcd->hwndCnr, PickMaskDlgProc,
1420 FM3ModHandle, MSK_FRAME, MPFROMP(&mask))) {
1421 if (SHORT1FROMMP(mp1) == IDM_SELECTMASK)
1422 SelectAll(dcd->hwndCnr, TRUE, TRUE, mask.szMask, NULL, FALSE);
1423 else
1424 DeselectAll(dcd->hwndCnr, TRUE, TRUE, mask.szMask, NULL, FALSE);
1425 }
1426 }
[2]1427
[551]1428 case IDM_INVERT:
1429 InvertAll(dcd->hwndCnr);
1430 break;
[2]1431 }
[551]1432 }
1433 return 0;
[2]1434
[551]1435 case UM_ENTER:
1436 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
1437 if (dcd) {
[2]1438
[551]1439 CHAR *s = (CHAR *) mp1, *p, *pp, filename[CCHMAXPATH];
[2]1440
[551]1441 if (s) {
1442 if (!dcd->info->extract) {
1443 Runtime_Error(pszSrcFile, __LINE__, "no extract");
[1039]1444 free(s);
[551]1445 return 0;
1446 }
[773]1447 runemf2(SEPARATE | WINDOWED | WAIT |
[888]1448 (fArcStuffVisible ? 0 : BACKGROUND | MINIMIZED),
1449 dcd->hwndClient, pszSrcFile, __LINE__, dcd->workdir, NULL,
[773]1450 "%s %s %s",
[562]1451 dcd->info->exwdirs ? dcd->info->exwdirs :
1452 dcd->info->extract,
[773]1453 BldQuotedFileName(szQuotedArcName, dcd->arcname),
1454 BldQuotedFileName(szQuotedMemberName, s));
[551]1455 if (!dcd->info->exwdirs) {
1456 p = s;
1457 p = strrchr(s, '\\');
1458 pp = strrchr(s, '/');
1459 if (p && pp)
1460 p = max(p, pp);
1461 else if (!p)
1462 p = pp;
1463 if (p)
1464 memmove(s, p + 1, strlen(p + 1));
1465 }
1466 sprintf(filename, "%s\\%s", dcd->workdir, s);
1467 p = filename;
1468 while (*p) {
1469 if (*p == '/')
1470 *p = '\\';
1471 p++;
1472 }
[562]1473 // printf("%s %d UM_ENTER %s %s\n",__FILE__, __LINE__,filename, s); fflush(stdout); // 10 Mar 07 SHL hang
[1039]1474 free(s);
[562]1475 if (IsFile(filename) == 1) {
[917]1476#if 1 // 06 Oct 07 SHL fixme to be gone - set to 0 for ticket #58 testing
[570]1477 if (fViewChild && fArcStuffVisible)
[835]1478 DosSleep(100); // Allow unzip session to finish closing 14 Mar 07 SHL
[907]1479#endif
[551]1480 WinSendMsg(dcd->hwndCnr, UM_ENTER, MPFROMP(filename), MPVOID);
[562]1481 }
[2]1482 }
[551]1483 }
1484 return 0;
[2]1485
[551]1486 case UM_COMMAND:
1487 if (mp1) {
1488 if (PostMsg(hwnd, UM_ACTION, mp1, mp2))
1489 return (MRESULT) TRUE;
1490 }
1491 return 0;
[2]1492
[551]1493 case UM_ACTION:
1494 DosError(FERR_DISABLEHARDERR);
1495 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
1496 if (dcd) {
[2]1497
[551]1498 LISTINFO *li = (LISTINFO *) mp1;
1499 register INT x;
[2]1500
[551]1501 if (li && li->list && li->list[0]) {
[1069]1502 printf("%x/r", li->type); fflush(stdout);
[551]1503 switch (li->type) {
1504 case IDM_ARCHIVE:
1505 case IDM_ARCHIVEM:
1506 {
1507 DIRCNRDATA ad;
1508 CHAR szBuffer[1025], *p;
[2]1509
[551]1510 if (!li->list[1] && !stricmp(li->list[0], dcd->arcname)) {
1511 Runtime_Error(pszSrcFile, __LINE__, "arc to self");
1512 break;
1513 }
1514 ad = *dcd;
1515 ad.namecanchange = 0;
1516 ad.fmoving = (li->type == IDM_ARCHIVEM);
1517 if (!WinDlgBox(HWND_DESKTOP, dcd->hwndClient, ArchiveDlgProc, FM3ModHandle, ARCH_FRAME, (PVOID) & ad) || !*ad.arcname || !*ad.command) /* we blew it */
1518 break;
1519 /* build the sucker */
1520 strcpy(szBuffer, ad.command);
1521 strcat(szBuffer, " ");
[773]1522
1523 BldQuotedFileName(szBuffer + strlen(szBuffer), ad.arcname);
1524
1525 p = &szBuffer[strlen(szBuffer)]; // Remeber where archiver name ends
1526
[551]1527 if (ad.mask.szMask) {
1528 strcat(szBuffer, " ");
[773]1529
1530 BldQuotedFileName(szBuffer + strlen(szBuffer), ad.mask.szMask);
[551]1531 }
1532 strcat(szBuffer, " ");
1533 x = 0;
[773]1534
1535 // Run commands avoiding command line overflow
[551]1536 while (li->list[x]) {
[773]1537
1538 if (IsFile(li->list[x]))
[907]1539 BldQuotedFileName(szBuffer + strlen(szBuffer), li->list[x]);
[773]1540 else
[907]1541 BldQuotedFullPathName(szBuffer + strlen(szBuffer), li->list[x], "*");
[773]1542
[551]1543 x++;
1544 if (!li->list[x] || strlen(szBuffer) +
[1004]1545 strlen(li->list[x]) + 5 > MaxComLineStrg) {
[551]1546 runemf2(SEPARATE | WINDOWED |
[907]1547 (fArcStuffVisible ? 0 : BACKGROUND | MINIMIZED) |
1548 WAIT, hwnd, pszSrcFile, __LINE__,
1549 NULL, NULL, "%s", szBuffer);
[551]1550 *p = 0;
1551 }
1552 strcat(szBuffer, " ");
[773]1553 } // while
1554
[551]1555 PostMsg(dcd->hwndCnr, UM_RESCAN, MPFROMSHORT(1), MPVOID);
1556 Broadcast(WinQueryAnchorBlock(hwnd),
1557 hwndMain, UM_UPDATERECORD, MPFROMP(ad.arcname), MPVOID);
1558 Broadcast(WinQueryAnchorBlock(hwnd),
1559 hwndMain,
1560 UM_UPDATERECORDLIST, MPFROMP(li->list), MPVOID);
1561 }
1562 break;
[2]1563
[551]1564 case IDM_REFRESH:
1565 case IDM_DELETE:
1566 {
[1040]1567 CHAR *endofit;
1568 PSZ pszCmdLine;
[551]1569 INT z;
1570 CHECKLIST ck;
1571 CHAR prompt[CCHMAXPATH + 257];
[2]1572
[551]1573 if (!dcd->info->delete)
1574 break;
1575 memset(&ck, 0, sizeof(ck));
1576 ck.size = sizeof(ck);
1577 ck.list = li->list;
1578 ck.cmd = li->type;
1579 ck.prompt = prompt;
1580 sprintf(prompt, GetPString(IDS_ARCCNRDELREFTEXT),
1581 (li->type == IDM_DELETE) ?
1582 GetPString(IDS_DELETELOWERTEXT) :
1583 GetPString(IDS_REFRESHLOWERTEXT),
1584 &"s"[li->list[1] == NULL],
1585 dcd->arcname,
1586 (li->type == IDM_DELETE) ?
1587 GetPString(IDS_DELETELOWERTEXT) :
1588 GetPString(IDS_REFRESHLOWERTEXT));
1589 if (!WinDlgBox(HWND_DESKTOP, hwnd, CheckListProc,
1590 FM3ModHandle, CHECK_FRAME, MPFROMP(&ck)))
1591 break;
1592 li->list = ck.list;
1593 if (!li->list || !li->list[0])
[1040]1594 break;
1595 pszCmdLine = xmallocz(MaxComLineStrg, pszSrcFile, __LINE__);
1596 if (!pszCmdLine)
1597 break;
1598 strcpy(pszCmdLine, li->type == IDM_DELETE ?
[773]1599 dcd->info->delete :
1600 dcd->info->create);
[1040]1601 strcat(pszCmdLine, " ");
1602 BldQuotedFileName(pszCmdLine + strlen(pszCmdLine), dcd->arcname);
1603 endofit = &pszCmdLine[strlen(pszCmdLine)];
[551]1604 z = 0;
1605 do {
1606 for (x = z; li->list[x] &&
[1040]1607 strlen(pszCmdLine) + strlen(li->list[x]) < 999; x++) {
1608 strcat(pszCmdLine, " ");
1609 BldQuotedFileName(pszCmdLine + strlen(pszCmdLine), li->list[x]);
[551]1610 }
1611 z = x;
[773]1612 runemf2(SEPARATE | WINDOWED | WAIT |
[888]1613 (fArcStuffVisible ? 0 : BACKGROUND | MINIMIZED),
[1040]1614 hwnd, pszSrcFile, __LINE__, NullStr, NULL, "%s", pszCmdLine);
1615 *endofit = 0;
1616 free(pszCmdLine);
[551]1617 } while (li->list[x]);
1618 PostMsg(dcd->hwndCnr, UM_RESCAN, MPFROMSHORT(1), MPVOID);
1619 Broadcast(WinQueryAnchorBlock(hwnd),
1620 hwndMain,
1621 UM_UPDATERECORD, MPFROMP(dcd->arcname), MPVOID);
1622 }
1623 break;
[2]1624
[551]1625 case IDM_PRINT:
1626 case IDM_VIRUSSCAN:
1627 case IDM_VIEW:
1628 case IDM_MCIPLAY:
1629 case IDM_VIEWARCHIVE:
1630 case IDM_VIEWTEXT:
1631 case IDM_VIEWBINARY:
1632 case IDM_EDIT:
1633 case IDM_EDITTEXT:
1634 case IDM_EDITBINARY:
1635 case IDM_EXEC:
1636 case IDM_EXTRACTWDIRS:
1637 case IDM_EXTRACT:
[1068]1638 case IDM_OPENDEFAULT:
1639 case IDM_OPENSETTINGS:
[551]1640 {
[1040]1641 CHAR *endofit, *ptr;
1642 PSZ pszCmdLine;
[551]1643 INT z;
1644 if ((li->type == IDM_EXTRACT && !li->info->extract) ||
1645 ((li->type == IDM_VIEW || li->type == IDM_VIEWTEXT ||
1646 li->type == IDM_VIEWBINARY || li->type == IDM_EDIT ||
1647 li->type == IDM_VIEWARCHIVE || li->type == IDM_EDITTEXT ||
1648 li->type == IDM_EDITBINARY || li->type == IDM_MCIPLAY) &&
1649 (!li->info->extract && !li->info->exwdirs)) ||
1650 (li->type != IDM_EXTRACT && li->type != IDM_EDIT &&
1651 li->type != IDM_VIEW && li->type != IDM_VIEWTEXT &&
1652 li->type != IDM_VIEWBINARY &&
1653 li->type != IDM_VIEWARCHIVE &&
1654 li->type != IDM_EDITTEXT &&
1655 li->type != IDM_EDITBINARY &&
1656 li->type != IDM_MCIPLAY && !li->info->exwdirs)) {
1657 Runtime_Error(pszSrcFile, __LINE__, "no cmd for request");
1658 break;
1659 }
1660 if (li->type == IDM_EXTRACT || li->type == IDM_EXTRACTWDIRS) {
[2]1661
[551]1662 CHAR fullname[CCHMAXPATH * 2];
1663 CHAR **exfiles = NULL;
[907]1664 UINT numfiles = 0, numalloc = 0;
[2]1665
[551]1666 for (x = 0; li->list[x]; x++) {
[773]1667 BldFullPathName(fullname, li->targetpath, li->list[x]);
[551]1668 if (IsFile(fullname) != -1) {
1669 AddToList(li->list[x], &exfiles, &numfiles, &numalloc);
1670 li->list = RemoveFromList(li->list, li->list[x]);
1671 if (!li->list)
1672 break;
1673 x--;
1674 }
1675 }
1676 if (exfiles && numfiles) {
[2]1677
[551]1678 CHECKLIST ckl;
1679 CHAR prompt[(CCHMAXPATH * 2) + 256];
[2]1680
[551]1681 memset(&ckl, 0, sizeof(ckl));
1682 ckl.size = sizeof(ckl);
1683 ckl.list = exfiles;
1684 ckl.prompt = prompt;
1685 ckl.cmd = li->type;
1686 sprintf(prompt,
1687 GetPString(IDS_REPLACEWARNTEXT),
1688 &"s"[numfiles == 1],
1689 li->arcname, &"s"[numfiles != 1], li->targetpath);
1690 if (!WinDlgBox(HWND_DESKTOP, hwnd, CheckListProc,
1691 FM3ModHandle, CHECK_FRAME, MPFROMP(&ckl))) {
1692 if (ckl.list)
1693 FreeList(ckl.list);
1694 break;
1695 }
1696 else if (ckl.list)
1697 li->list = CombineLists(li->list, ckl.list);
1698 }
1699 }
1700 if (!li->list || !li->list[0])
[1040]1701 break;
1702 pszCmdLine = xmallocz(MaxComLineStrg, pszSrcFile, __LINE__);
1703 if (!pszCmdLine)
1704 break;
1705 strcpy(pszCmdLine,
[773]1706 (li->type == IDM_EXTRACT ||
1707 ((li->type == IDM_VIEW ||
1708 li->type == IDM_VIEWTEXT ||
1709 li->type == IDM_VIEWBINARY ||
1710 li->type == IDM_VIEWARCHIVE ||
1711 li->type == IDM_PRINT ||
1712 li->type == IDM_EDIT ||
1713 li->type == IDM_EDITTEXT ||
[1068]1714 li->type == IDM_OPENDEFAULT ||
1715 li->type == IDM_OPENSETTINGS ||
1716 (li->type == IDM_EDITBINARY && // JBS No way for this () to be true??
[773]1717 li->type == IDM_MCIPLAY)) &&
1718 !li->info->exwdirs)) ?
1719 li->info->extract :
1720 li->info->exwdirs);
[1040]1721 strcat(pszCmdLine, " ");
1722 BldQuotedFileName(pszCmdLine + strlen(pszCmdLine), li->arcname);
1723 endofit = &pszCmdLine[strlen(pszCmdLine)];
[888]1724 z = 0;
1725 do {
1726 for (x = z; li->list[x] &&
[1069]1727 strlen(pszCmdLine) + strlen(li->list[x]) < MaxComLineStrg - 1 ; x++) {
[1040]1728 strcat(pszCmdLine, " ");
1729 BldQuotedFileName(pszCmdLine + strlen(pszCmdLine), li->list[x]);
[551]1730 ptr = li->list[x];
1731 while (*ptr) {
1732 if (*ptr == '/')
1733 *ptr = '\\';
1734 ptr++;
1735 }
1736 }
1737 z = x;
1738 runemf2(SEPARATE | WINDOWED |
[888]1739 (fArcStuffVisible ? 0 : BACKGROUND | MINIMIZED) |
[907]1740 WAIT, hwnd, pszSrcFile, __LINE__,
[1069]1741 li->targetpath, NULL, "%s", pszCmdLine);
[551]1742 *endofit = 0;
1743 } while (li->list[x]);
1744 if (li->type == IDM_EXTRACT || li->type == IDM_EXTRACTWDIRS) {
1745 /* update windows */
1746 for (x = 0; li->list[x]; x++) {
[2]1747
[551]1748 CHAR *temp, *p;
[2]1749
[551]1750 temp = li->list[x];
1751 p = temp;
1752 while (*p) {
1753 if (*p == '/')
1754 *p = '\\';
1755 p++;
1756 }
[1017]1757 p = xmalloc(strlen(temp) + strlen(li->targetpath) + 2,
1758 pszSrcFile, __LINE__);
[1069]1759 if (p) {
1760 BldFullPathName(p, li->targetpath, temp);
1761 /*strcpy(p, li->targetpath);
[551]1762 if (p[strlen(p) - 1] != '\\')
1763 strcat(p, "\\");
[1069]1764 strcat(p, temp);*/
[551]1765 li->list[x] = p;
[1039]1766 free(temp);
[551]1767 }
1768 }
1769 if (fFolderAfterExtract) {
[2]1770
[551]1771 CHAR objectpath[CCHMAXPATH], *p;
1772 APIRET rc;
[2]1773
[551]1774 GetDesktopName(objectpath, sizeof(objectpath));
1775 rc = WinDlgBox(HWND_DESKTOP, dcd->hwndParent, ObjCnrDlgProc,
1776 FM3ModHandle, OBJCNR_FRAME,
1777 MPFROMP(objectpath));
1778 if (rc) {
1779 if (rc > 1)
1780 strcpy(objectpath, "<WP_DESKTOP>");
1781 p = NULL;
1782 if (li->arcname) {
1783 p = strrchr(li->arcname, '\\');
1784 if (p)
1785 p++;
1786 }
1787 MakeShadows(dcd->hwndParent, li->list, 2, objectpath, p);
1788 }
1789 }
1790 Broadcast(WinQueryAnchorBlock(hwnd),
1791 hwndMain,
1792 UM_UPDATERECORDLIST, MPFROMP(li->list), MPVOID);
1793 }
1794 else if (li->type == IDM_EXEC)
1795 ExecOnList(hwnd,
1796 li->runfile,
1797 WINDOWED | SEPARATEKEEP | PROMPT,
1798 li->targetpath,
[907]1799 NULL, GetPString(IDS_EXECARCFILETITLETEXT),
1800 pszSrcFile, __LINE__);
[551]1801 else if (li->type == IDM_VIRUSSCAN)
1802 ExecOnList(hwnd, virus, PROMPT | WINDOWED | SEPARATEKEEP,
1803 li->targetpath, NULL,
[907]1804 GetPString(IDS_VIRUSSCANARCHIVETITLETEXT),
1805 pszSrcFile, __LINE__);
[551]1806 else if (li->type == IDM_VIEW || li->type == IDM_VIEWTEXT ||
1807 li->type == IDM_VIEWBINARY || li->type == IDM_EDIT ||
1808 li->type == IDM_EDITTEXT ||
1809 li->type == IDM_VIEWARCHIVE ||
1810 li->type == IDM_EDITBINARY ||
[1068]1811 li->type == IDM_OPENDEFAULT ||
1812 li->type == IDM_OPENSETTINGS ||
[551]1813 li->type == IDM_MCIPLAY || li->type == IDM_PRINT) {
[2]1814
[551]1815 CHAR *temp, *p;
1816 for (x = 0; li->list[x]; x++) {
1817 if (!li->info->exwdirs) {
1818 temp = li->list[x];
1819 p = strrchr(li->list[x], '\\');
1820 if (p) {
1821 p++;
1822 li->list[x] = xstrdup(p, pszSrcFile, __LINE__);
1823 if (!li->list[x])
1824 li->list[x] = temp;
1825 else {
[1032]1826 xfree(temp, pszSrcFile, __LINE__);
[551]1827 }
1828 }
[1069]1829 }
[1040]1830 BldFullPathName(pszCmdLine, li->targetpath, li->list[x]);
[551]1831 temp = li->list[x];
[1040]1832 li->list[x] = xstrdup(pszCmdLine, pszSrcFile, __LINE__);
[551]1833 if (!li->list[x])
1834 li->list[x] = temp;
1835 else
[1032]1836 xfree(temp, pszSrcFile, __LINE__);
[1069]1837 }
1838 free(pszCmdLine);
[551]1839 if (li->type == IDM_VIEW || li->type == IDM_EDIT) {
[2]1840
[551]1841 BOOL isit = TestBinary(li->list[0]);
[2]1842
[551]1843 if (isit) {
1844 if (li->type == IDM_VIEW)
1845 li->type = IDM_VIEWBINARY;
1846 else
1847 li->type = IDM_EDITBINARY;
1848 }
1849 else {
1850 if (li->type == IDM_VIEW)
1851 li->type = IDM_VIEWTEXT;
1852 else
1853 li->type = IDM_EDITTEXT;
1854 }
1855 }
1856 if (li->type == IDM_MCIPLAY) {
[2]1857
[1069]1858 FILE *fp;
1859 CHAR TempFile[CCHMAXPATH];
[2]1860
[1069]1861 if (fUseTmp)
1862 BldFullPathName(TempFile, pTmpDir, "$FM2PLAY.$$$");
1863 else
1864 strcpy(TempFile, "$FM2PLAY.$$$");
1865
1866 fp = xfopen(TempFile, "w", pszSrcFile, __LINE__);
[551]1867 if (fp) {
1868 fprintf(fp, "%s", ";AV/2-built FM2Play listfile\n");
1869 for (x = 0; li->list[x]; x++)
1870 fprintf(fp, "%s\n", li->list[x]);
1871 fprintf(fp, ";end\n");
[1069]1872 fclose(fp);
1873 strrev(TempFile);
1874 strcat(TempFile, "@/");
1875 strrev(TempFile);
1876 RunFM2Util("FM2PLAY.EXE", TempFile);
[762]1877 }
[551]1878 }
1879 else if (li->type == IDM_PRINT) {
1880 strcpy(li->targetpath, printer);
1881 if (_beginthread(PrintListThread, NULL, 65536, (PVOID) li) !=
1882 -1) {
1883 Runtime_Error(pszSrcFile, __LINE__,
1884 GetPString(IDS_COULDNTSTARTTHREADTEXT));
1885 li = NULL;
1886 }
1887 }
1888 else if (li->type == IDM_VIEWARCHIVE) {
[2]1889
[551]1890 ARC_TYPE *info;
[2]1891
[551]1892 for (x = 0; li->list[x]; x++) {
1893 if (IsFile(li->list[x]) == 1) {
1894 info = NULL; // Do not hide dups - fixme to know why?
1895 if (WinDlgBox(HWND_DESKTOP, HWND_DESKTOP,
1896 SBoxDlgProc, FM3ModHandle, ASEL_FRAME,
1897 (PVOID) & info) && info) {
1898 StartArcCnr(HWND_DESKTOP,
1899 HWND_DESKTOP, li->list[x], 4, info);
1900 }
1901 }
1902 }
1903 }
1904 else if ((li->type == IDM_VIEWTEXT && *viewer) ||
1905 (li->type == IDM_VIEWBINARY && *binview) ||
1906 (li->type == IDM_EDITTEXT && *editor) ||
1907 (li->type == IDM_EDITBINARY && *bined)) {
[814]1908 DosSleep(32); //05 Aug 07 GKY 100
[551]1909 ExecOnList(hwnd, ((li->type == IDM_VIEWTEXT) ? viewer :
1910 (li->type == IDM_VIEWBINARY) ? binview :
1911 (li->type == IDM_EDITTEXT) ? editor :
1912 bined),
1913 WINDOWED | SEPARATE, li->targetpath, li->list,
[888]1914 NULL, pszSrcFile, __LINE__);
[551]1915 }
[1068]1916 else if (li->type == IDM_OPENDEFAULT ||
1917 li->type == IDM_OPENSETTINGS) {
1918 WORKER *wk;
1919# ifdef FORTIFY
1920 Fortify_EnterScope();
1921# endif
1922 wk = xmallocz(sizeof(WORKER), pszSrcFile, __LINE__);
1923 if (!wk)
1924 FreeListInfo(li);
1925 else {
1926 wk->size = sizeof(WORKER);
1927 wk->hwndCnr = dcd->hwndCnr;
1928 wk->hwndParent = dcd->hwndParent;
1929 wk->hwndFrame = dcd->hwndFrame;
1930 wk->hwndClient = dcd->hwndClient;
1931 wk->li = li;
1932 strcpy(wk->directory, dcd->directory);
1933 if (_beginthread(Action, NULL, 122880, (PVOID) wk) == -1) {
1934 Runtime_Error(pszSrcFile, __LINE__,
1935 GetPString(IDS_COULDNTSTARTTHREADTEXT));
1936 free(wk);
1937 FreeListInfo((LISTINFO *) mp1);
1938# ifdef FORTIFY
1939 Fortify_LeaveScope();
1940# endif
1941 }
1942 }
[1069]1943
[1068]1944 }
[551]1945 else {
1946 if (li->hwnd) {
[2]1947
[551]1948 ULONG viewtype;
[2]1949
[551]1950 for (x = 0; li->list[x]; x++) {
1951 if (x == 0) {
1952 if (li->type == IDM_VIEWBINARY ||
1953 li->type == IDM_EDITBINARY)
1954 viewtype = 16;
1955 else
1956 viewtype = 8;
1957 }
1958 else
1959 viewtype = 0;
1960 temp = xstrdup(li->list[x], pszSrcFile, __LINE__);
1961 if (temp) {
1962 if (!PostMsg(WinQueryWindow(li->hwnd, QW_PARENT),
1963 UM_LOADFILE,
1964 MPFROMLONG(4L +
1965 (li->type == IDM_VIEWTEXT ||
1966 li->type == IDM_VIEWBINARY) +
1967 viewtype), MPFROMP(temp)))
1968 free(temp);
1969 }
1970 }
1971 }
1972 }
1973 }
1974 }
1975 break;
[2]1976
[551]1977 case IDM_FIND:
1978 {
[907]1979 UINT numfiles = 0, numalloced = 0;
[551]1980 CHAR **list2 = NULL, fullname[CCHMAXPATH * 2], *p;
[2]1981
[551]1982 for (x = 0; li->list[x]; x++) {
1983 p = li->list[x];
1984 while (*p) {
1985 if (*p == '/')
1986 *p = '\\';
1987 p++;
1988 }
[773]1989 BldFullPathName(fullname, dcd->directory, li->list[x]);
1990 // sprintf(fullname, "%s%s%s", dcd->directory,
1991 // (dcd->directory[strlen(dcd->directory) - 1] == '\\') ?
1992 // NullStr : "\\", li->list[x]);
[551]1993 if (IsFile(fullname) != -1)
1994 if (AddToList(fullname, &list2, &numfiles, &numalloced))
1995 break;
1996 if (strchr(li->list[x], '\\')) {
1997 p = strrchr(li->list[x], '\\');
1998 if (p) {
1999 p++;
2000 if (*p) {
[773]2001 BldFullPathName(fullname, dcd->directory, p);
2002 // sprintf(fullname, "%s%s%s", dcd->directory,
2003 // (dcd->directory[strlen(dcd->directory) - 1] ==
2004 // '\\') ? NullStr : "\\",
2005 // p);
[551]2006 if (IsFile(fullname) != -1)
2007 if (AddToList(fullname, &list2, &numfiles, &numalloced))
2008 break;
2009 }
2010 }
2011 }
2012 }
2013 if (!numfiles || !list2)
2014 Runtime_Error(pszSrcFile, __LINE__, "no files or list");
2015 else {
2016 WinSendMsg(dcd->hwndCnr, WM_COMMAND,
2017 MPFROM2SHORT(IDM_COLLECTOR, 0), MPVOID);
[814]2018 DosSleep(10); //05 Aug 07 GKY 128
[551]2019 if (Collector) {
2020 if (!PostMsg(Collector, WM_COMMAND,
2021 MPFROM2SHORT(IDM_COLLECTOR, 0), MPFROMP(list2)))
2022 FreeList(list2);
2023 }
2024 else
2025 FreeList(list2);
2026 }
2027 }
2028 break;
2029 }
[2]2030 }
[1068]2031 if (li->type != IDM_OPENDEFAULT && li->type != IDM_OPENSETTINGS)
2032 {
2033 FreeListInfo(li);
2034 }
[551]2035 }
2036 return 0;
[2]2037
[551]2038 case WM_CLOSE:
2039 WinDestroyWindow(hwnd);
2040 break;
[2]2041
[551]2042 case WM_DESTROY:
2043 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
2044 if (dcd) {
2045 if (*dcd->workdir) {
[771]2046 DosSleep(16); //05 Aug 07 GKY 33
[551]2047 wipeallf("%s\\*", dcd->workdir);
2048 if (rmdir(dcd->workdir)) {
[771]2049 DosSleep(100); //05 Aug 07 GKY 256
[551]2050 wipeallf("%s\\*", dcd->workdir);
2051 rmdir(dcd->workdir);
2052 }
[2]2053 }
[551]2054 FreeList(dcd->lastselection);
2055 WinSendMsg(dcd->hwndCnr, UM_CLOSE, MPVOID, MPVOID);
[1039]2056 free(dcd);
[1063]2057# ifdef FORTIFY
2058 Fortify_LeaveScope();
2059# endif
[551]2060 WinSetWindowPtr(dcd->hwndCnr, QWL_USER, NULL);
2061 }
2062 if (!PostMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID))
2063 WinSendMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID);
2064 break;
2065 } // switch
2066 return WinDefWindowProc(hwnd, msg, mp1, mp2);
[2]2067}
2068
[551]2069static MRESULT EXPENTRY ArcCnrWndProc(HWND hwnd, ULONG msg, MPARAM mp1,
2070 MPARAM mp2)
[172]2071{
[672]2072 DIRCNRDATA *dcd = INSTDATA(hwnd);
[773]2073 CHAR szQuotedArcName[CCHMAXPATH];
[2]2074
[551]2075 switch (msg) {
2076 case DM_PRINTOBJECT:
2077 case DM_DISCARDOBJECT:
2078 if (dcd)
2079 return WinSendMsg(dcd->hwndObject, msg, mp1, mp2);
2080 else
2081 return MRFROMLONG(DRR_TARGET);
[2]2082
[551]2083 case WM_CHAR:
2084 shiftstate = (SHORT1FROMMP(mp1) & (KC_SHIFT | KC_ALT | KC_CTRL));
2085 if (SHORT1FROMMP(mp1) & KC_KEYUP)
2086 return (MRESULT) TRUE;
2087 if (SHORT1FROMMP(mp1) & KC_VIRTUALKEY) {
2088 switch (SHORT2FROMMP(mp2)) {
2089 case VK_DELETE:
2090 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_DELETE, 0), MPVOID);
2091 break;
[2]2092 }
[551]2093 }
2094 if (shiftstate || fNoSearch)
2095 break;
2096 if (SHORT1FROMMP(mp1) & KC_CHAR) {
[2]2097
[551]2098 ULONG thistime, len;
2099 SEARCHSTRING srch;
2100 PCNRITEM pci;
[2]2101
[551]2102 if (!dcd)
2103 break;
2104 switch (SHORT1FROMMP(mp2)) {
2105 case '\x1b':
2106 case '\r':
2107 case '\n':
2108 dcd->lasttime = 0;
2109 *dcd->szCommonName = 0;
2110 break;
2111 default:
2112 thistime = WinQueryMsgTime(WinQueryAnchorBlock(hwnd));
2113 if (thistime > dcd->lasttime + 1250)
2114 *dcd->szCommonName = 0;
2115 dcd->lasttime = thistime;
2116 if (SHORT1FROMMP(mp2) == ' ' && !*dcd->szCommonName)
2117 break;
2118 KbdRetry:
2119 len = strlen(dcd->szCommonName);
2120 if (len >= CCHMAXPATH - 1) {
2121 *dcd->szCommonName = 0;
2122 len = 0;
2123 }
2124 dcd->szCommonName[len] = toupper(SHORT1FROMMP(mp2));
2125 dcd->szCommonName[len + 1] = 0;
2126 memset(&srch, 0, sizeof(SEARCHSTRING));
2127 srch.cb = (ULONG) sizeof(SEARCHSTRING);
2128 srch.pszSearch = dcd->szCommonName;
2129 srch.fsPrefix = TRUE;
2130 srch.fsCaseSensitive = FALSE;
2131 srch.usView = CV_ICON;
2132 pci = WinSendMsg(hwnd,
2133 CM_SEARCHSTRING,
2134 MPFROMP(&srch), MPFROMLONG(CMA_FIRST));
2135 if (pci && (INT) pci != -1) {
[2]2136
[551]2137 USHORT attrib = CRA_CURSORED;
[2]2138
[551]2139 /* make found item current item */
2140 if (!stricmp(pci->pszFileName, dcd->szCommonName))
2141 attrib |= CRA_SELECTED;
2142 WinSendMsg(hwnd,
2143 CM_SETRECORDEMPHASIS,
2144 MPFROMP(pci), MPFROM2SHORT(TRUE, attrib));
2145 /* make sure that record shows in viewport */
2146 ShowCnrRecord(hwnd, (PMINIRECORDCORE) pci);
2147 return (MRESULT) TRUE;
2148 }
2149 else {
2150 if (SHORT1FROMMP(mp2) == ' ') {
2151 dcd->szCommonName[len] = 0;
2152 break;
2153 }
2154 *dcd->szCommonName = 0;
2155 dcd->lasttime = 0;
2156 if (len) // retry as first letter if no match
2157 goto KbdRetry;
2158 }
2159 break;
[2]2160 }
[551]2161 }
2162 break;
[2]2163
[551]2164 case WM_MOUSEMOVE:
2165 case WM_BUTTON1UP:
2166 case WM_BUTTON2UP:
2167 case WM_BUTTON3UP:
2168 case WM_CHORD:
2169 shiftstate = (SHORT2FROMMP(mp2) & (KC_SHIFT | KC_ALT | KC_CTRL));
2170 break;
[2]2171
[551]2172 case WM_BUTTON1MOTIONEND:
2173 {
2174 CNRINFO cnri;
[2]2175
[551]2176 memset(&cnri, 0, sizeof(CNRINFO));
2177 cnri.cb = sizeof(CNRINFO);
2178 if (WinSendMsg(hwnd,
2179 CM_QUERYCNRINFO,
2180 MPFROMP(&cnri), MPFROMLONG(sizeof(CNRINFO)))) {
2181 if (cnri.flWindowAttr & CV_DETAIL)
2182 PrfWriteProfileData(fmprof,
2183 appname,
2184 "ArcCnrSplitBar",
2185 (PVOID) & cnri.xVertSplitbar, sizeof(LONG));
[2]2186 }
[551]2187 }
2188 break;
[2]2189
[551]2190 case WM_PRESPARAMCHANGED:
2191 PresParamChanged(hwnd, "ArcCnr", mp1, mp2);
2192 break;
[2]2193
[551]2194 case UM_UPDATERECORD:
2195 case UM_UPDATERECORDLIST:
2196 if (dcd && !IsArcThere(hwnd, dcd->arcname))
2197 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
2198 return 0;
[2]2199
[551]2200 case WM_SETFOCUS:
2201 /*
2202 * put name of our window (archive name) on status line
2203 */
2204 if (dcd && hwndStatus && mp2)
2205 WinSendMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
2206 break;
[2]2207
[551]2208 case UM_SETUP2:
2209 if (dcd && dcd->info) {
2210 if (dcd->info->fdpos == -1 || !dcd->info->datetype)
2211 dcd->sortFlags &= (~SORT_LWDATE);
2212 if (dcd->info->nsizepos == -1)
2213 dcd->sortFlags &= (~SORT_EASIZE);
2214 if (dcd->info->osizepos == -1)
2215 dcd->sortFlags &= (~SORT_SIZE);
2216 AdjustCnrColVis(hwnd,
2217 GetPString(IDS_OLDSIZECOLTEXT),
2218 dcd->info->osizepos != -1, FALSE);
2219 AdjustCnrColVis(hwnd,
2220 GetPString(IDS_NEWSIZECOLTEXT),
2221 dcd->info->nsizepos != -1, FALSE);
2222 // Display unsullied date/time string if type 0
2223 AdjustCnrColVis(hwnd,
2224 GetPString(IDS_DATETIMECOLTEXT),
2225 dcd->info->fdpos != -1 && !dcd->info->datetype, FALSE);
2226 // Display parsed date/time columns if type specified
2227 AdjustCnrColVis(hwnd,
2228 GetPString(IDS_TIMECOLTEXT),
2229 dcd->info->fdpos != -1 && dcd->info->datetype, FALSE);
2230 AdjustCnrColVis(hwnd,
2231 GetPString(IDS_DATECOLTEXT),
2232 dcd->info->fdpos != -1 && dcd->info->datetype, FALSE);
2233 WinSendMsg(hwnd, CM_INVALIDATEDETAILFIELDINFO, MPVOID, MPVOID);
2234 }
2235 return 0;
[2]2236
[551]2237 case UM_RESCAN:
2238 if (dcd) {
2239 CNRINFO cnri;
2240 CHAR s[CCHMAXPATH * 2], tb[81], tf[81];
2241 PARCITEM pci;
[2]2242
[551]2243 if (mp1) {
2244 PostMsg(dcd->hwndObject, UM_RESCAN, MPVOID, MPVOID);
2245 return 0;
2246 }
2247 memset(&cnri, 0, sizeof(CNRINFO));
2248 cnri.cb = sizeof(CNRINFO);
2249 WinSendMsg(hwnd,
2250 CM_QUERYCNRINFO,
2251 MPFROMP(&cnri), MPFROMLONG(sizeof(CNRINFO)));
2252 dcd->totalfiles = cnri.cRecords;
2253 commafmt(tf, sizeof(tf), dcd->selectedfiles);
2254 if (dcd->ullTotalBytes)
2255 CommaFmtULL(tb, sizeof(tb), dcd->selectedbytes, 'K');
2256 else
2257 *tb = 0;
2258 sprintf(s, "%s%s%s", tf, *tb ? " / " : NullStr, tb);
2259 WinSetDlgItemText(dcd->hwndClient, DIR_SELECTED, s);
2260 commafmt(tf, sizeof(tf), dcd->totalfiles);
2261 if (dcd->ullTotalBytes)
2262 CommaFmtULL(tb, sizeof(tb), dcd->ullTotalBytes, 'K');
2263 else
2264 *tb = 0;
2265 sprintf(s, "%s%s%s", tf, *tb ? " / " : NullStr, tb);
2266 WinSetDlgItemText(dcd->hwndClient, DIR_TOTALS, s);
2267 if (hwndStatus &&
2268 dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent)) {
2269 sprintf(s, " [%s%s%s]%s%s%s %s",
2270 tf,
[156]2271 *tb ? " / " : NullStr,
[551]2272 tb,
[562]2273 *dcd->mask.szMask ? " (" : NullStr,
2274 *dcd->mask.szMask ? dcd->mask.szMask : NullStr,
2275 *dcd->mask.szMask ? ")" : NullStr, dcd->arcname);
[551]2276 WinSetWindowText(hwndStatus, s);
2277 if (!ParentIsDesktop(hwnd, dcd->hwndParent)) {
2278 pci = WinSendMsg(hwnd,
2279 CM_QUERYRECORDEMPHASIS,
2280 MPFROMLONG(CMA_FIRST), MPFROMSHORT(CRA_CURSORED));
2281 if (pci && (INT) pci != -1) {
2282 if (fSplitStatus && hwndStatus2) {
2283 if (dcd->ullTotalBytes)
2284 CommaFmtULL(tb, sizeof(tb), pci->cbFile, ' ');
2285 else
2286 *tb = 0;
2287 sprintf(s, "%s%s%s%s",
2288 *tb ? " " : NullStr,
[730]2289 tb, *tb ? " " : NullStr, pci->pszFileName);
[551]2290 WinSetWindowText(hwndStatus2, s);
2291 }
2292 if (fMoreButtons)
[730]2293 WinSetWindowText(hwndName, pci->pszFileName);
[551]2294 }
2295 else {
2296 WinSetWindowText(hwndStatus2, NullStr);
2297 WinSetWindowText(hwndName, NullStr);
2298 }
2299 WinSetWindowText(hwndDate, NullStr);
2300 WinSetWindowText(hwndAttr, NullStr);
2301 }
[2]2302 }
[563]2303 if ((dcd->arcfilled && !dcd->totalfiles) ||
[762]2304 !IsArcThere(hwnd, dcd->arcname))
[551]2305 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
2306 }
2307 return 0;
2308
2309 case UM_SETUP:
2310 if (!dcd) {
2311 Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
2312 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
[2]2313 return 0;
[551]2314 }
2315 else {
2316 if (!dcd->hwndObject) {
2317 /*
2318 * first time through -- set things up
2319 */
2320 {
2321 CHAR *p, *pp;
2322 ULONG z, was;
2323 APIRET rc;
[2]2324
[551]2325 rc = DosCreateDir(dcd->workdir, 0);
2326 if (rc) {
2327 if (rc == ERROR_ACCESS_DENIED) {
2328 p = strrchr(dcd->workdir, '.');
2329 if (p) {
2330 p++;
2331 pp = p;
2332 was = strtoul(p, &pp, 16);
2333 for (z = 0; z < 99; z++) {
2334 was++;
2335 sprintf(p, "%03x");
2336 rc = DosCreateDir(dcd->workdir, 0);
2337 if (!rc || rc != ERROR_ACCESS_DENIED)
2338 break;
2339 }
2340 }
2341 }
2342 if (rc)
2343 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
2344 return 0;
2345 }
2346 }
2347 RestorePresParams(hwnd, "ArcCnr");
2348 dcd->mask.fNoAttribs = TRUE;
2349 dcd->mask.fNoDirs = TRUE;
2350 *dcd->mask.prompt = 0;
2351 {
2352 PFIELDINFO pfi, pfiLastLeftCol;
2353 ULONG numcols = CON_COLS;
2354 CNRINFO cnri;
2355 ULONG size;
[2]2356
[551]2357 pfi = WinSendMsg(hwnd,
2358 CM_ALLOCDETAILFIELDINFO,
2359 MPFROMLONG(numcols), NULL);
2360 if (pfi) {
[2]2361
[551]2362 PFIELDINFO pfiFirst;
2363 FIELDINFOINSERT fii;
[2]2364
[551]2365 pfiFirst = pfi;
2366 pfi->flData = CFA_STRING | CFA_LEFT | CFA_FIREADONLY;
2367 pfi->flTitle = CFA_CENTER;
2368 pfi->pTitleData = GetPString(IDS_FILENAMECOLTEXT);
[739]2369 pfi->offStruct = FIELDOFFSET(ARCITEM, pszDisplayName);
[551]2370 pfiLastLeftCol = pfi;
2371 pfi = pfi->pNextFieldInfo;
2372 pfi->flData =
2373 CFA_ULONG | CFA_RIGHT | CFA_SEPARATOR | CFA_FIREADONLY;
2374 pfi->flTitle = CFA_CENTER;
2375 pfi->pTitleData = GetPString(IDS_OLDSIZECOLTEXT);
2376 pfi->offStruct = FIELDOFFSET(ARCITEM, cbFile);
2377 pfi = pfi->pNextFieldInfo;
2378 pfi->flData =
2379 CFA_ULONG | CFA_RIGHT | CFA_SEPARATOR | CFA_FIREADONLY;
2380 pfi->flTitle = CFA_CENTER;
2381 pfi->pTitleData = GetPString(IDS_NEWSIZECOLTEXT);
2382 pfi->offStruct = FIELDOFFSET(ARCITEM, cbComp);
2383 pfi = pfi->pNextFieldInfo;
2384 pfi->flData =
2385 CFA_STRING | CFA_CENTER | CFA_SEPARATOR | CFA_FIREADONLY;
2386 pfi->flTitle = CFA_CENTER | CFA_FITITLEREADONLY;
2387 pfi->pTitleData = GetPString(IDS_DATETIMECOLTEXT);
2388 pfi->offStruct = FIELDOFFSET(ARCITEM, pszDate);
2389 pfi = pfi->pNextFieldInfo;
2390 pfi->flData = CFA_DATE | CFA_RIGHT | CFA_FIREADONLY;
2391 pfi->flTitle = CFA_CENTER;
2392 pfi->pTitleData = GetPString(IDS_DATECOLTEXT);
2393 pfi->offStruct = FIELDOFFSET(ARCITEM, date);
2394 pfi = pfi->pNextFieldInfo;
2395 pfi->flData = CFA_TIME | CFA_RIGHT | CFA_FIREADONLY;
2396 pfi->flTitle = CFA_CENTER | CFA_FITITLEREADONLY;
2397 pfi->pTitleData = GetPString(IDS_TIMECOLTEXT);
2398 pfi->offStruct = FIELDOFFSET(ARCITEM, time);
2399 memset(&fii, 0, sizeof(FIELDINFOINSERT));
2400 fii.cb = sizeof(FIELDINFOINSERT);
2401 fii.pFieldInfoOrder = (PFIELDINFO) CMA_FIRST;
2402 fii.cFieldInfoInsert = (SHORT) numcols;
2403 fii.fInvalidateFieldInfo = TRUE;
2404 WinSendMsg(hwnd,
2405 CM_INSERTDETAILFIELDINFO,
2406 MPFROMP(pfiFirst), MPFROMP(&fii));
2407 PostMsg(hwnd, UM_SETUP2, MPVOID, MPVOID);
[2]2408
[551]2409 memset(&cnri, 0, sizeof(cnri));
2410 cnri.cb = sizeof(CNRINFO);
2411 cnri.pFieldInfoLast = pfiLastLeftCol;
2412 cnri.xVertSplitbar = DIR_SPLITBAR_OFFSET + 32;
[2]2413
[551]2414 size = sizeof(LONG);
2415 PrfQueryProfileData(fmprof, appname, "ArcCnrSplitBar",
2416 &cnri.xVertSplitbar, &size);
2417 if (cnri.xVertSplitbar <= 0)
2418 cnri.xVertSplitbar = DIR_SPLITBAR_OFFSET + 32;
[2]2419
[551]2420 cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT | CV_NAME));
2421 cnri.flWindowAttr |= (CV_DETAIL | CA_DETAILSVIEWTITLES | CV_FLOW);
2422 cnri.flWindowAttr &= (~(CA_ORDEREDTARGETEMPH |
2423 CA_MIXEDTARGETEMPH));
2424 cnri.pSortRecord = (PVOID) ArcSort;
2425 WinSendMsg(hwnd,
2426 CM_SETCNRINFO,
2427 MPFROMP(&cnri),
2428 MPFROMLONG(CMA_PFIELDINFOLAST |
2429 CMA_XVERTSPLITBAR |
2430 CMA_PSORTRECORD | CMA_FLWINDOWATTR));
2431 }
2432 }
2433 WinSendMsg(hwnd, CM_SORTRECORD, MPFROMP(ArcSort), MPFROMP(dcd));
2434 if (_beginthread(MakeObjWin, NULL, 245760, (PVOID) dcd) == -1) {
2435 Runtime_Error(pszSrcFile, __LINE__,
2436 GetPString(IDS_COULDNTSTARTTHREADTEXT));
2437 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
2438 return 0;
2439 }
2440 else
[766]2441 DosSleep(1);
[551]2442 SayFilter(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
2443 DIR_FILTER), &dcd->mask, TRUE);
2444 SaySort(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
2445 DIR_SORT), dcd->sortFlags, TRUE);
2446 DefArcSortFlags = dcd->sortFlags; // Remember for new windows
[2]2447 }
[551]2448 }
2449 return 0;
[2]2450
[551]2451 case UM_SETDIR:
2452 if (dcd) {
[2]2453
[551]2454 CHAR s[CCHMAXPATH], *p;
2455 ULONG ret = 0;
[2]2456
[551]2457 WinQueryDlgItemText(dcd->hwndClient, ARC_EXTRACTDIR, CCHMAXPATH, s);
2458 bstrip(s);
2459 MakeFullName(s);
2460 if (*s) {
2461 while ((p = strchr(s, '/')) != NULL)
2462 *p = '\\';
2463 while (strlen(s) > 3 && s[strlen(s) - 1] == '\\')
2464 s[strlen(s) - 1] = 0;
2465 if (stricmp(s, dcd->directory)) {
2466 if (IsFullName(s)) {
2467 if (driveflags[toupper(*s) - 'A'] &
2468 (DRIVE_NOTWRITEABLE | DRIVE_IGNORE | DRIVE_INVALID)) {
2469 Runtime_Error(pszSrcFile, __LINE__, "drive %s bad", s);
2470 WinSetDlgItemText(dcd->hwndClient,
2471 ARC_EXTRACTDIR, dcd->directory);
2472 return 0;
2473 }
2474 }
2475 if (!SetDir(dcd->hwndParent, hwnd, s, 0)) {
2476 if (stricmp(dcd->directory, s)) {
2477 DosEnterCritSec();
2478 strcpy(lastextractpath, s);
2479 DosExitCritSec();
2480 }
2481 strcpy(dcd->directory, s);
2482 if ((!isalpha(*s) || s[1] != ':') && *s != '.')
2483 saymsg(MB_ENTER | MB_ICONASTERISK,
2484 hwnd,
2485 GetPString(IDS_WARNINGTEXT),
2486 GetPString(IDS_SPECIFYDRIVETEXT));
2487 }
2488 else
2489 ret = 1;
2490 }
[2]2491 }
[551]2492 WinSetDlgItemText(dcd->hwndClient, ARC_EXTRACTDIR, dcd->directory);
2493 return (MRESULT) ret;
2494 }
2495 return 0;
2496
2497 case UM_ENTER:
2498 if (WinSendMsg(hwnd, UM_SETDIR, MPVOID, MPVOID))
[2]2499 return 0;
[551]2500 SetShiftState();
2501 if (dcd && (CHAR *) mp1) {
[2]2502
[551]2503 SWP swp;
2504 CHAR *filename = mp1;
[2]2505
[551]2506 if (IsFile(filename) != 1)
2507 return 0;
2508 WinQueryWindowPos(dcd->hwndFrame, &swp);
2509 DefaultViewKeys(hwnd, dcd->hwndFrame, dcd->hwndParent, &swp, filename);
2510 if (fUnHilite)
[672]2511 UnHilite(hwnd, FALSE, &dcd->lastselection, 0);
[551]2512 }
2513 return 0;
[2]2514
[551]2515 case WM_MENUEND:
2516 if (dcd) {
[2]2517
[551]2518 HWND hwndMenu = (HWND) mp2;
[2]2519
[551]2520 if (hwndMenu == ArcCnrMenu || hwndMenu == ArcMenu) {
2521 MarkAll(hwnd, TRUE, FALSE, TRUE);
2522 if (dcd->cnremphasized) {
2523 WinSendMsg(hwnd,
2524 CM_SETRECORDEMPHASIS,
2525 MPVOID, MPFROM2SHORT(FALSE, CRA_SOURCE));
2526 dcd->cnremphasized = FALSE;
2527 }
[2]2528 }
[551]2529 }
2530 break;
[2]2531
[551]2532 case MM_PORTHOLEINIT:
2533 if (dcd) {
2534 switch (SHORT1FROMMP(mp1)) {
2535 case 0:
2536 case 1:
2537 {
2538 ULONG wmsg;
[2]2539
[562]2540 wmsg = SHORT1FROMMP(mp1) == 0 ? UM_FILESMENU : UM_VIEWSMENU;
[551]2541 PortholeInit((HWND) WinSendMsg(dcd->hwndClient,
2542 wmsg, MPVOID, MPVOID), mp1, mp2);
2543 }
2544 break;
[2]2545 }
[551]2546 }
2547 break;
[2]2548
[551]2549 case UM_INITMENU:
2550 case WM_INITMENU:
2551 if (dcd) {
2552 switch (SHORT1FROMMP(mp1)) {
2553 case IDM_FILESMENU:
2554 if (dcd->info) {
2555 WinEnableMenuItem((HWND) mp2,
2556 IDM_DELETE, dcd->info->delete != NULL);
2557 WinEnableMenuItem((HWND) mp2, IDM_TEST, dcd->info->test != NULL);
2558 WinEnableMenuItem((HWND) mp2,
2559 IDM_EXTRACT, dcd->info->extract != NULL);
2560 WinEnableMenuItem((HWND) mp2,
2561 IDM_EXTRACTWDIRS, dcd->info->exwdirs != NULL);
2562 WinEnableMenuItem((HWND) mp2,
2563 IDM_ARCEXTRACTWDIRS, dcd->info->exwdirs != NULL);
2564 WinEnableMenuItem((HWND) mp2,
2565 IDM_ARCEXTRACTWDIRSEXIT,
2566 dcd->info->exwdirs != NULL);
2567 }
2568 break;
[2]2569
[551]2570 case IDM_VIEWSMENU:
2571 WinCheckMenuItem((HWND) mp2,
[562]2572 IDM_MINIICONS, (dcd->flWindowAttr & CV_MINI) != 0);
[551]2573 WinEnableMenuItem((HWND) mp2,
2574 IDM_RESELECT, (dcd->lastselection != NULL));
2575 break;
[2]2576
[551]2577 case IDM_COMMANDSMENU:
2578 SetupCommandMenu((HWND) mp2, hwnd);
2579 break;
[2]2580
[551]2581 case IDM_SORTSUBMENU:
2582 SetSortChecks((HWND) mp2, dcd->sortFlags);
2583 break;
[2]2584
[551]2585 case IDM_WINDOWSMENU:
2586 /*
2587 * add switchlist entries to end of pulldown menu
2588 */
[562]2589 SetupWinList((HWND)mp2,
2590 hwndMain ? hwndMain : (HWND)0, dcd->hwndFrame);
[551]2591 break;
[2]2592 }
[551]2593 dcd->hwndLastMenu = (HWND) mp2;
2594 }
2595 if (msg == WM_INITMENU)
2596 break;
2597 return 0;
[2]2598
[551]2599 case UM_LOADFILE:
2600 if (dcd && mp2) {
[2]2601
[1037]2602 HWND hwnd;
[2]2603
[1037]2604 if ((INT)mp1 == 5 || (INT)mp1 == 13 || (INT)mp1 == 21)
2605 hwnd = StartViewer(HWND_DESKTOP, (INT)mp1,
2606 (CHAR *)mp2, dcd->hwndFrame);
2607 else
2608 hwnd = StartMLEEditor(dcd->hwndParent,
2609 (INT)mp1, (CHAR *)mp2, dcd->hwndFrame);
[1039]2610 free((CHAR *)mp2);
[1037]2611 return MRFROMLONG(hwnd);
[551]2612 }
2613 return 0;
2614
2615 case UM_COMMAND:
2616 if (mp1) {
2617 if (dcd) {
2618 if (!PostMsg(dcd->hwndObject, UM_COMMAND, mp1, mp2)) {
2619 Runtime_Error(pszSrcFile, __LINE__, "post");
2620 FreeListInfo((LISTINFO *) mp1);
2621 }
2622 else
2623 return (MRESULT) TRUE;
[2]2624 }
[551]2625 else
2626 FreeListInfo((LISTINFO *) mp1);
2627 }
2628 return 0;
[2]2629
[551]2630 case UM_OPENWINDOWFORME:
2631 if (dcd) {
2632 if (mp1 && !IsFile((CHAR *) mp1)) {
2633 OpenDirCnr((HWND) 0, hwndMain, dcd->hwndFrame, FALSE, (char *)mp1);
[2]2634 }
[551]2635 else if (mp1 && IsFile(mp1) == 1) {
2636 StartArcCnr(HWND_DESKTOP,
2637 dcd->hwndFrame, (CHAR *) mp1, 4, (ARC_TYPE *) mp2);
2638 }
2639 }
2640 return 0;
[2]2641
[551]2642 case WM_COMMAND:
2643 DosError(FERR_DISABLEHARDERR);
2644 if (dcd) {
2645 if (SwitchCommand(dcd->hwndLastMenu, SHORT1FROMMP(mp1)))
2646 return 0;
2647 if (WinSendMsg(hwnd, UM_SETDIR, MPVOID, MPVOID))
2648 return 0;
2649 if (!IsArcThere(hwnd, dcd->arcname)) {
2650 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
2651 return 0;
[2]2652 }
[551]2653 switch (SHORT1FROMMP(mp1)) {
2654 case IDM_TREEVIEW:
[2]2655
[551]2656 break;
[2]2657
[551]2658 case IDM_CONTEXTMENU:
2659 {
2660 PCNRITEM pci;
[2]2661
[551]2662 pci = (PCNRITEM) CurrentRecord(hwnd);
2663 PostMsg(hwnd,
2664 WM_CONTROL,
2665 MPFROM2SHORT(ARC_CNR, CN_CONTEXTMENU), MPFROMP(pci));
2666 }
2667 break;
[2]2668
[551]2669 case IDM_NEXTWINDOW:
2670 case IDM_PREVWINDOW:
2671 {
2672 HWND hwndActive;
[2]2673
[551]2674 hwndActive = WinQueryFocus(HWND_DESKTOP);
2675 WinSetFocus(HWND_DESKTOP,
[563]2676 hwndActive == hwnd ?
[762]2677 WinWindowFromID(dcd->hwndClient, ARC_EXTRACTDIR) :
2678 hwnd);
[551]2679 }
2680 break;
[2]2681
[551]2682 case IDM_FOLDERAFTEREXTRACT:
[562]2683 fFolderAfterExtract = fFolderAfterExtract ? FALSE : TRUE;
[551]2684 PrfWriteProfileData(fmprof, appname, "FolderAfterExtract",
2685 &fFolderAfterExtract, sizeof(BOOL));
2686 break;
[2]2687
[551]2688 case IDM_SHOWSELECT:
[872]2689 QuickPopup(hwnd, dcd, CheckMenu(hwnd, &ArcCnrMenu, ARCCNR_POPUP),
[551]2690 IDM_SELECTSUBMENU);
2691 break;
[2]2692
[551]2693 case IDM_SHOWSORT:
[872]2694 QuickPopup(hwnd, dcd, CheckMenu(hwnd, &ArcCnrMenu, ARCCNR_POPUP),
[551]2695 IDM_SORTSUBMENU);
2696 break;
[2]2697
[953]2698 case IDM_ARCHIVERSETTINGS:
[551]2699 if (!ParentIsDesktop(dcd->hwndParent, dcd->hwndParent))
[917]2700 PostMsg(dcd->hwndParent, msg, MPFROMLONG(IDM_ARCHIVERSETTINGS), mp2);
2701 else {
[551]2702 WinDlgBox(HWND_DESKTOP,
2703 hwnd,
[917]2704 CfgDlgProc,
2705 FM3ModHandle,
2706 CFG_FRAME,
2707 MPFROMLONG(IDM_ARCHIVERSETTINGS));
2708 }
[551]2709 break;
[2]2710
[551]2711 case IDM_RESCAN:
2712 dcd->ullTotalBytes = dcd->totalfiles =
2713 dcd->selectedfiles = dcd->selectedbytes = 0;
2714 WinSetDlgItemText(dcd->hwndClient, DIR_TOTALS, "0");
2715 WinSetDlgItemText(dcd->hwndClient, DIR_SELECTED, "0 / 0k");
2716 dcd->totalfiles = FillArcCnr(dcd->hwndCnr,
2717 dcd->arcname,
2718 &dcd->info,
2719 &dcd->ullTotalBytes, &dcd->stopflag);
2720 PostMsg(dcd->hwndCnr, UM_RESCAN, MPVOID, MPVOID);
2721 PostMsg(dcd->hwndCnr, UM_SETUP2, MPVOID, MPVOID);
2722 WinSendMsg(dcd->hwndCnr,
2723 CM_INVALIDATERECORD,
2724 MPVOID, MPFROM2SHORT(0, CMA_ERASE | CMA_REPOSITION));
2725 break;
[2]2726
[551]2727 case IDM_RESELECT:
2728 SelectList(hwnd, TRUE, FALSE, FALSE, NULL, NULL, dcd->lastselection);
2729 break;
[2]2730
[551]2731 case IDM_HELP:
2732 if (hwndHelp)
2733 WinSendMsg(hwndHelp,
2734 HM_DISPLAY_HELP,
2735 MPFROM2SHORT(HELP_ARCLIST, 0),
2736 MPFROMSHORT(HM_RESOURCEID));
2737 break;
[2]2738
[551]2739 case IDM_WINDOWDLG:
2740 if (!ParentIsDesktop(dcd->hwndParent, dcd->hwndFrame))
2741 PostMsg(dcd->hwndParent,
2742 UM_COMMAND, MPFROM2SHORT(IDM_WINDOWDLG, 0), MPVOID);
2743 break;
[2]2744
[551]2745 case IDM_SELECTALL:
2746 case IDM_SELECTALLFILES:
2747 case IDM_DESELECTALL:
2748 case IDM_DESELECTALLFILES:
2749 case IDM_SELECTMASK:
2750 case IDM_DESELECTMASK:
2751 case IDM_INVERT:
2752 {
2753 PARCITEM pci;
[2]2754
[551]2755 pci = (PARCITEM) WinSendMsg(hwnd,
2756 CM_QUERYRECORDEMPHASIS,
2757 MPFROMLONG(CMA_FIRST),
2758 MPFROMSHORT(CRA_CURSORED));
2759 if ((INT) pci == -1)
2760 pci = NULL;
2761 if (SHORT1FROMMP(mp1) == IDM_HIDEALL) {
2762 if (pci) {
2763 if (!(pci->rc.flRecordAttr & CRA_SELECTED))
2764 pci->rc.flRecordAttr |= CRA_FILTERED;
2765 WinSendMsg(hwnd,
2766 CM_INVALIDATERECORD,
2767 MPFROMP(&pci),
2768 MPFROM2SHORT(1, CMA_ERASE | CMA_REPOSITION));
2769 break;
2770 }
2771 }
2772 PostMsg(dcd->hwndObject, UM_SELECT, mp1, MPFROMP(pci));
2773 }
2774 break;
[2]2775
[551]2776 case IDM_SORTSMARTNAME:
2777 case IDM_SORTNAME:
2778 case IDM_SORTFILENAME:
2779 case IDM_SORTSIZE:
2780 case IDM_SORTEASIZE:
2781 case IDM_SORTFIRST:
2782 case IDM_SORTLAST:
2783 case IDM_SORTLWDATE:
2784 dcd->sortFlags &= SORT_REVERSE;
2785 /* intentional fallthru */
2786 case IDM_SORTREVERSE:
2787 switch (SHORT1FROMMP(mp1)) {
2788 case IDM_SORTSMARTNAME:
2789 case IDM_SORTFILENAME:
2790 dcd->sortFlags |= SORT_FILENAME;
2791 break;
2792 case IDM_SORTSIZE:
2793 dcd->sortFlags |= SORT_SIZE;
2794 break;
2795 case IDM_SORTEASIZE:
2796 dcd->sortFlags |= SORT_EASIZE;
2797 break;
2798 case IDM_SORTFIRST:
2799 dcd->sortFlags |= SORT_FIRSTEXTENSION;
2800 break;
2801 case IDM_SORTLAST:
2802 dcd->sortFlags |= SORT_LASTEXTENSION;
2803 break;
2804 case IDM_SORTLWDATE:
2805 dcd->sortFlags |= SORT_LWDATE;
2806 break;
2807 case IDM_SORTREVERSE:
2808 if (dcd->sortFlags & SORT_REVERSE)
2809 dcd->sortFlags &= (~SORT_REVERSE);
2810 else
2811 dcd->sortFlags |= SORT_REVERSE;
2812 break;
2813 }
2814 WinSendMsg(hwnd, CM_SORTRECORD, MPFROMP(ArcSort), MPFROMP(dcd));
2815 SaySort(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
2816 DIR_SORT), dcd->sortFlags, TRUE);
2817 DefArcSortFlags = dcd->sortFlags; // Remember for new windows
2818 break;
[2]2819
[551]2820 case IDM_COLLECTOR:
2821 if (!Collector) {
2822 HWND hwndC;
2823 SWP swp;
[2]2824
[551]2825 if (ParentIsDesktop(hwnd, dcd->hwndParent) && !fAutoTile &&
2826 (!fExternalCollector && !strcmp(realappname, FM3Str)))
2827 GetNextWindowPos(dcd->hwndParent, &swp, NULL, NULL);
[563]2828 hwndC = StartCollector(fExternalCollector ||
2829 strcmp(realappname, FM3Str) ?
2830 HWND_DESKTOP : dcd->hwndParent, 4);
[551]2831 if (hwndC) {
2832 if (!ParentIsDesktop(hwnd, dcd->hwndParent) && !fAutoTile &&
2833 (!fExternalCollector && !strcmp(realappname, FM3Str)))
2834 WinSetWindowPos(hwndC,
2835 HWND_TOP,
2836 swp.x,
2837 swp.y,
2838 swp.cx,
2839 swp.cy,
2840 SWP_MOVE | SWP_SIZE | SWP_SHOW | SWP_ZORDER);
2841 else if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
2842 fAutoTile && !strcmp(realappname, FM3Str)) {
2843 TileChildren(dcd->hwndParent, TRUE);
2844 }
2845 WinSetWindowPos(hwndC, HWND_TOP, 0, 0, 0, 0, SWP_ACTIVATE);
[771]2846 DosSleep(100); //05 Aug 07 GKY 128
[551]2847 }
2848 }
2849 else
2850 StartCollector(dcd->hwndParent, 4);
2851 break;
[2]2852
[551]2853 case IDM_ARCEXTRACTEXIT:
2854 case IDM_ARCEXTRACT:
2855 if (dcd->info->extract)
2856 runemf2(SEPARATE | WINDOWED |
[888]2857 (fArcStuffVisible ? 0 : BACKGROUND | MINIMIZED),
[907]2858 hwnd, pszSrcFile, __LINE__,
2859 dcd->directory, NULL, "%s %s", dcd->info->extract,
[773]2860 BldQuotedFileName(szQuotedArcName, dcd->arcname));
[551]2861 if (SHORT1FROMMP(mp1) == IDM_ARCEXTRACTEXIT)
2862 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
2863 break;
[2]2864
[551]2865 case IDM_ARCEXTRACTWDIRSEXIT:
2866 case IDM_ARCEXTRACTWDIRS:
2867 if (dcd->info->exwdirs)
2868 runemf2(SEPARATE | WINDOWED |
[888]2869 (fArcStuffVisible ? 0 : BACKGROUND | MINIMIZED),
[907]2870 hwnd, pszSrcFile, __LINE__,
2871 dcd->directory, NULL, "%s %s",
[551]2872 dcd->info->exwdirs,
[773]2873 BldQuotedFileName(szQuotedArcName, dcd->arcname));
[551]2874 if (SHORT1FROMMP(mp1) == IDM_ARCEXTRACTWDIRSEXIT)
2875 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
2876 break;
[2]2877
[551]2878 case IDM_RESORT:
2879 WinSendMsg(hwnd, CM_SORTRECORD, MPFROMP(ArcSort), MPFROMP(dcd));
2880 break;
[2]2881
[551]2882 case IDM_FILTER:
2883 {
2884 BOOL empty = FALSE;
2885 PARCITEM pci;
[2]2886
[551]2887 if (!*dcd->mask.szMask) {
2888 empty = TRUE;
2889 pci = (PARCITEM) CurrentRecord(hwnd);
[730]2890 if (pci && strchr(pci->pszFileName, '.'))
2891 strcpy(dcd->mask.szMask, pci->pszFileName);
[551]2892 }
[2]2893
[551]2894 if (WinDlgBox(HWND_DESKTOP, hwnd, PickMaskDlgProc,
2895 FM3ModHandle, MSK_FRAME, MPFROMP(&dcd->mask))) {
2896 WinSendMsg(hwnd, CM_FILTER, MPFROMP(ArcFilter), MPFROMP(dcd));
2897 PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
2898 }
2899 else if (empty)
2900 *dcd->mask.szMask = 0;
2901 SayFilter(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
2902 DIR_FILTER), &dcd->mask, TRUE);
2903 }
2904 break;
[2]2905
[551]2906 case IDM_SWITCH:
2907 if (mp2) {
2908 if (stricmp(dcd->directory, (CHAR *) mp2)) {
2909 DosEnterCritSec();
2910 strcpy(lastextractpath, (CHAR *) mp2);
2911 MakeValidDir(lastextractpath);
2912 DosExitCritSec();
2913 }
2914 strcpy(dcd->directory, (CHAR *) mp2);
2915 MakeValidDir(dcd->directory);
2916 WinSetWindowText(dcd->hwndExtract, dcd->directory);
2917 }
2918 break;
[2]2919
[551]2920 case IDM_WALKDIR:
2921 {
2922 CHAR newdir[CCHMAXPATH];
[2]2923
[551]2924 strcpy(newdir, dcd->directory);
2925 if (!WinDlgBox(HWND_DESKTOP, dcd->hwndParent, WalkExtractDlgProc,
2926 FM3ModHandle, WALK_FRAME,
2927 MPFROMP(newdir)) || !*newdir)
2928 break;
2929 if (stricmp(newdir, dcd->directory)) {
2930 strcpy(dcd->directory, newdir);
2931 if (stricmp(lastextractpath, newdir))
2932 strcpy(lastextractpath, newdir);
2933 WinSetWindowText(dcd->hwndExtract, dcd->directory);
2934 }
2935 }
2936 break;
[2]2937
[551]2938 case IDM_TEST:
2939 if (dcd->info->test)
2940 runemf2(SEPARATEKEEP | WINDOWED | MAXIMIZED,
[888]2941 hwnd, pszSrcFile, __LINE__, NULL, NULL,
[773]2942 "%s %s",dcd->info->test,
2943 BldQuotedFileName(szQuotedArcName, dcd->arcname));
[551]2944 break;
[2]2945
[551]2946 case IDM_REFRESH:
2947 case IDM_DELETE:
2948 case IDM_PRINT:
2949 case IDM_VIEW:
2950 case IDM_VIEWTEXT:
2951 case IDM_VIEWBINARY:
2952 case IDM_VIEWARCHIVE:
2953 case IDM_EDIT:
2954 case IDM_EDITTEXT:
2955 case IDM_EDITBINARY:
2956 case IDM_EXTRACT:
2957 case IDM_EXTRACTWDIRS:
2958 case IDM_FIND:
2959 case IDM_EXEC:
2960 case IDM_VIRUSSCAN:
[1068]2961 case IDM_OPENDEFAULT:
2962 case IDM_OPENSETTINGS:
[1069]2963 case IDM_MCIPLAY:
[551]2964 {
2965 LISTINFO *li;
[1063]2966# ifdef FORTIFY
2967 Fortify_EnterScope();
2968# endif
[551]2969 li = xmallocz(sizeof(LISTINFO), pszSrcFile, __LINE__);
2970 if (li) {
2971 li->type = SHORT1FROMMP(mp1);
2972 li->hwnd = hwnd;
2973 li->list = BuildArcList(hwnd);
2974 if (li->type == IDM_REFRESH) {
[2]2975
[551]2976 CHAR s[CCHMAXPATH], *p;
2977 INT x, y;
[2]2978
[551]2979 for (x = 0; li->list && li->list[x]; x++) {
[773]2980 BldFullPathName(s, dcd->workdir, li->list[x]);
[551]2981 if (IsFile(s) != 1) {
[1039]2982 free(li->list[x]);
[551]2983 li->list[x] = NULL;
2984 for (y = x; li->list[y]; y++)
2985 li->list[y] = li->list[y + 1];
2986 li->list =
2987 xrealloc(li->list, y * sizeof(CHAR *), pszSrcFile,
2988 __LINE__);
2989 x--;
2990 }
2991 else {
2992 p = xstrdup(s, pszSrcFile, __LINE__);
2993 if (p) {
[1039]2994 free(li->list[x]);
[551]2995 li->list[x] = p;
2996 }
2997 }
2998 } // for
2999 }
3000 strcpy(li->arcname, dcd->arcname);
3001 li->info = dcd->info;
3002 {
3003 PARCITEM pai;
[2]3004
[551]3005 if (SHORT1FROMMP(mp1) != IDM_EXEC)
3006 pai = (PARCITEM) CurrentRecord(hwnd);
3007 else
3008 pai = (PARCITEM) WinSendMsg(hwnd, CM_QUERYRECORDEMPHASIS,
3009 MPFROMLONG(CMA_FIRST),
3010 MPFROMSHORT(CRA_CURSORED));
3011 if (pai && (INT) pai != -1)
[730]3012 strcpy(li->runfile, pai->pszFileName);
[551]3013 else
3014 strcpy(li->runfile, li->list[0]);
3015 }
3016 switch (SHORT1FROMMP(mp1)) {
3017 case IDM_VIEW:
3018 case IDM_VIEWTEXT:
3019 case IDM_VIEWBINARY:
3020 case IDM_VIEWARCHIVE:
3021 case IDM_EDIT:
3022 case IDM_EDITTEXT:
3023 case IDM_EDITBINARY:
3024 case IDM_EXEC:
3025 case IDM_PRINT:
3026 case IDM_VIRUSSCAN:
[1068]3027 case IDM_OPENDEFAULT:
[1069]3028 case IDM_OPENSETTINGS:
3029 case IDM_MCIPLAY:
[551]3030 strcpy(li->targetpath, dcd->workdir);
3031 break;
3032 default:
3033 strcpy(li->targetpath, dcd->directory);
3034 break;
3035 }
3036 if (li->list) {
3037 if (!PostMsg(dcd->hwndObject, UM_ACTION, MPFROMP(li), MPVOID)) {
3038 Runtime_Error(pszSrcFile, __LINE__, "post");
3039 FreeListInfo(li);
3040 }
3041 else if (fUnHilite && SHORT1FROMMP(mp1) != IDM_EDIT)
[672]3042 UnHilite(hwnd, TRUE, &dcd->lastselection, 0);
[551]3043 }
[1018]3044 else
[1039]3045 free(li);
[1068]3046# ifdef FORTIFY
3047 Fortify_LeaveScope();
3048# endif
[551]3049 }
3050 }
3051 break;
[2]3052 }
[551]3053 }
3054 return 0;
[2]3055
[551]3056 case WM_CONTROL:
3057 DosError(FERR_DISABLEHARDERR);
3058 if (dcd) {
3059 switch (SHORT2FROMMP(mp1)) {
3060 case CN_BEGINEDIT:
3061 PostMsg(hwnd, CM_CLOSEEDIT, MPVOID, MPVOID);
3062 break;
[2]3063
[551]3064 case CN_ENDEDIT:
3065 if (!((PCNREDITDATA) mp2)->pRecord) {
[2]3066
[551]3067 PFIELDINFO pfi = ((PCNREDITDATA) mp2)->pFieldInfo;
3068 USHORT cmd = 0;
[2]3069
[739]3070 if (!pfi || pfi->offStruct == FIELDOFFSET(ARCITEM, pszDisplayName))
[551]3071 cmd = IDM_SORTSMARTNAME;
3072 else if (pfi->offStruct == FIELDOFFSET(ARCITEM, cbFile))
3073 cmd = IDM_SORTSIZE;
3074 else if (pfi->offStruct == FIELDOFFSET(ARCITEM, cbComp))
3075 cmd = IDM_SORTEASIZE;
3076 else if (pfi->offStruct == FIELDOFFSET(ARCITEM, date))
3077 cmd = IDM_SORTLWDATE;
3078 else if (pfi->offStruct == FIELDOFFSET(ARCITEM, time))
3079 cmd = IDM_SORTLWDATE;
3080 if (cmd)
3081 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(cmd, 0), MPVOID);
3082 }
3083 break;
[2]3084
[551]3085 case CN_DROPHELP:
3086 saymsg(MB_ENTER, hwnd,
3087 GetPString(IDS_DROPHELPHDRTEXT),
3088 GetPString(IDS_ARCCNRDROPHELPTEXT), dcd->arcname);
3089 return 0;
[2]3090
[551]3091 case CN_DRAGLEAVE:
3092 if (mp2) {
[2]3093
[551]3094 PDRAGINFO pDInfo;
[2]3095
[551]3096 pDInfo = ((PCNRDRAGINFO) mp2)->pDragInfo;
[562]3097 DrgAccessDraginfo(pDInfo); /* Access DRAGINFO */
3098 DrgFreeDraginfo(pDInfo); /* Free DRAGINFO */
[551]3099 }
3100 return 0;
[2]3101
[551]3102 case CN_DRAGAFTER:
3103 case CN_DRAGOVER:
3104 if (mp2) {
[2]3105
[773]3106 PDRAGITEM pDItem; /* Pointer to DRAGITEM */
3107 PDRAGINFO pDInfo; /* Pointer to DRAGINFO */
[551]3108 PARCITEM pci;
[2]3109
[551]3110 pci = (PARCITEM) ((PCNRDRAGINFO) mp2)->pRecord;
3111 if (SHORT1FROMMP(mp1) == CN_DRAGAFTER)
3112 pci = NULL;
3113 pDInfo = ((PCNRDRAGINFO) mp2)->pDragInfo;
[562]3114 DrgAccessDraginfo(pDInfo); /* Access DRAGINFO */
[551]3115 if (*dcd->arcname) {
3116 if ((driveflags[toupper(*dcd->arcname) - 'A'] &
3117 DRIVE_NOTWRITEABLE) || !dcd->info || !dcd->info->create) {
3118 DrgFreeDraginfo(pDInfo);
3119 return MRFROM2SHORT(DOR_NEVERDROP, 0);
3120 }
3121 }
3122 if (pci) {
3123 DrgFreeDraginfo(pDInfo);
3124 return MRFROM2SHORT(DOR_NODROP, 0);
3125 }
[562]3126 pDItem = DrgQueryDragitemPtr(pDInfo, /* Access DRAGITEM */
3127 0); /* Index to DRAGITEM */
[551]3128 if (DrgVerifyRMF(pDItem, /* Check valid rendering */
[562]3129 DRM_OS2FILE, /* mechanisms and data */
[551]3130 NULL) && !(pDItem->fsControl & DC_PREPARE)) {
[773]3131 DrgFreeDraginfo(pDInfo); /* Free DRAGINFO */
[562]3132 return MRFROM2SHORT(DOR_DROP, /* Return okay to drop */
3133 fCopyDefault ? DO_COPY : DO_MOVE);
[551]3134 }
[562]3135 DrgFreeDraginfo(pDInfo); /* Free DRAGINFO */
[551]3136 }
[562]3137 return (MRFROM2SHORT(DOR_NEVERDROP, 0)); /* Drop not valid */
[2]3138
[551]3139 case CN_INITDRAG:
3140 if (mp2) {
[2]3141
[551]3142 BOOL wasemphasized = FALSE;
3143 PCNRDRAGINIT pcd = (PCNRDRAGINIT) mp2;
3144 PARCITEM pci;
[2]3145
[551]3146 if (pcd) {
3147 pci = (PARCITEM) pcd->pRecord;
3148 if (pci) {
3149 if (pci->rc.flRecordAttr & CRA_SELECTED)
3150 wasemphasized = TRUE;
3151 if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
3152 fSplitStatus && hwndStatus2)
3153 WinSetWindowText(hwndStatus2, GetPString(IDS_DRAGARCMEMTEXT));
3154 if (DoFileDrag(hwnd,
3155 dcd->hwndObject,
3156 mp2, dcd->arcname, NULL, TRUE)) {
[672]3157 if ((fUnHilite && wasemphasized) || dcd->ulItemsToUnHilite)
3158 UnHilite(hwnd, TRUE, &dcd->lastselection, dcd->ulItemsToUnHilite);
[551]3159 }
3160 if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
3161 fSplitStatus && hwndStatus2) {
3162 PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
3163 }
3164 }
3165 else {
3166 if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
3167 fSplitStatus && hwndStatus2)
3168 WinSetWindowText(hwndStatus2,
3169 GetPString(IDS_DRAGARCFILETEXT));
3170 DragOne(hwnd, dcd->hwndObject, dcd->arcname, FALSE);
3171 if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
3172 fSplitStatus && hwndStatus2)
3173 PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
3174 }
3175 }
3176 }
3177 return 0;
[2]3178
[551]3179 case CN_DROP:
3180 if (mp2) {
[2]3181
[551]3182 LISTINFO *li;
[2]3183
[551]3184 DosBeep(500, 100); // fixme to know why beep?
3185 li = DoFileDrop(hwnd, dcd->arcname, FALSE, mp1, mp2);
[762]3186 DosBeep(50, 100); // fixme to know why beep?
3187 CheckPmDrgLimit(((PCNRDRAGINFO)mp2)->pDragInfo);
[551]3188 if (li) {
[562]3189 li->type = li->type == DO_MOVE ? IDM_ARCHIVEM : IDM_ARCHIVE;
[551]3190 strcpy(li->targetpath, dcd->arcname);
3191 if (!li->list ||
3192 !li->list[0] ||
3193 !PostMsg(dcd->hwndObject, UM_ACTION, MPFROMP(li), MPVOID))
3194 FreeListInfo(li);
3195 }
3196 }
3197 return 0;
[2]3198
[551]3199 case CN_CONTEXTMENU:
3200 {
3201 PARCITEM pci = (PARCITEM) mp2;
[2]3202
[551]3203 if (pci) {
3204 WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPFROMP(pci),
3205 MPFROM2SHORT(TRUE, CRA_CURSORED));
3206 MarkAll(hwnd, FALSE, FALSE, TRUE);
[872]3207 dcd->hwndLastMenu = CheckMenu(hwnd, &ArcMenu, ARC_POPUP);
[551]3208 }
3209 else {
[872]3210 dcd->hwndLastMenu = CheckMenu(hwnd, &ArcCnrMenu, ARCCNR_POPUP);
[551]3211 if (dcd->hwndLastMenu && !dcd->cnremphasized) {
3212 WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPVOID,
3213 MPFROM2SHORT(TRUE, CRA_SOURCE));
3214 dcd->cnremphasized = TRUE;
3215 }
3216 }
3217 if (dcd->hwndLastMenu) {
3218 if (dcd->hwndLastMenu == ArcCnrMenu) {
3219 if (dcd->flWindowAttr & CV_MINI)
3220 WinCheckMenuItem(dcd->hwndLastMenu, IDM_MINIICONS, TRUE);
3221 }
3222 WinCheckMenuItem(dcd->hwndLastMenu, IDM_FOLDERAFTEREXTRACT,
3223 fFolderAfterExtract);
3224 if (!PopupMenu(hwnd, hwnd, dcd->hwndLastMenu)) {
3225 if (dcd->cnremphasized) {
3226 WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPVOID,
3227 MPFROM2SHORT(FALSE, CRA_SOURCE));
3228 dcd->cnremphasized = TRUE;
3229 }
3230 MarkAll(hwnd, TRUE, FALSE, TRUE);
3231 }
3232 }
3233 }
3234 break;
[2]3235
[551]3236 case CN_EMPHASIS:
3237 if (mp2) {
[2]3238
[551]3239 PNOTIFYRECORDEMPHASIS pre = mp2;
3240 PARCITEM pci;
3241 CHAR s[CCHMAXPATHCOMP + 91], tf[81], tb[81];
[2]3242
[562]3243 pci = (PARCITEM)(pre ? pre->pRecord : NULL);
[551]3244 if (!pci) {
3245 if (!ParentIsDesktop(hwnd, dcd->hwndParent)) {
3246 if (hwndStatus2)
3247 WinSetWindowText(hwndStatus2, NullStr);
3248 if (fMoreButtons)
3249 WinSetWindowText(hwndName, NullStr);
3250 }
3251 break;
3252 }
3253 if (pre->fEmphasisMask & CRA_SELECTED) {
3254 if (pci->rc.flRecordAttr & CRA_SELECTED) {
3255 dcd->selectedbytes += pci->cbFile;
3256 dcd->selectedfiles++;
3257 }
3258 else if (dcd->selectedfiles) {
3259 dcd->selectedbytes -= pci->cbFile;
3260 dcd->selectedfiles--;
3261 }
3262 commafmt(tf, sizeof(tf), dcd->selectedfiles);
3263 if (dcd->ullTotalBytes)
3264 CommaFmtULL(tb, sizeof(tb), dcd->selectedbytes, ' ');
3265 else
3266 *tb = 0;
3267 sprintf(s, "%s%s%s", tf, *tb ? " / " : NullStr, tb);
3268 WinSetDlgItemText(dcd->hwndClient, DIR_SELECTED, s);
3269 }
3270 else if (WinQueryActiveWindow(dcd->hwndParent) ==
3271 dcd->hwndFrame &&
3272 !ParentIsDesktop(hwnd, dcd->hwndParent)) {
3273 if (pre->fEmphasisMask & CRA_CURSORED) {
3274 if (pci->rc.flRecordAttr & CRA_CURSORED) {
3275 if (fSplitStatus && hwndStatus2) {
3276 if (dcd->ullTotalBytes)
3277 CommaFmtULL(tb, sizeof(tb), pci->cbFile, ' ');
3278 else
3279 *tb = 0;
3280 sprintf(s, "%s%s%s%s",
3281 *tb ? " " : NullStr,
[730]3282 tb, *tb ? " " : NullStr, pci->pszFileName);
[551]3283 WinSetWindowText(hwndStatus2, s);
3284 }
3285 if (fMoreButtons)
[730]3286 WinSetWindowText(hwndName, pci->pszFileName);
[551]3287 }
3288 }
3289 }
3290 }
3291 break;
[2]3292
[551]3293 case CN_ENTER:
3294 if (mp2) {
[2]3295
[551]3296 PARCITEM pci = (PARCITEM) ((PNOTIFYRECORDENTER) mp2)->pRecord;
[2]3297
[551]3298 if (pci) {
[2]3299
[551]3300 CHAR *s;
[2]3301
[551]3302 if ((pci->rc.flRecordAttr & CRA_INUSE) ||
3303 (pci->flags & (ARCFLAGS_REALDIR | ARCFLAGS_PSEUDODIR)))
3304 break;
[730]3305 s = xstrdup(pci->pszFileName, pszSrcFile, __LINE__);
[551]3306 if (s) {
3307 if (!PostMsg(dcd->hwndObject, UM_ENTER, MPFROMP(s), MPVOID)) {
3308 Runtime_Error(pszSrcFile, __LINE__, "post");
[1039]3309 free(s);
[551]3310 }
3311 }
3312 }
3313 }
3314 break;
[2]3315 }
[551]3316 }
3317 return 0;
[2]3318
[551]3319 case UM_FOLDUP:
3320 if (!PostMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID))
3321 DosExit(EXIT_PROCESS, 1);
3322 return 0;
[2]3323
[551]3324 case UM_CLOSE:
3325 WinDestroyWindow(WinQueryWindow(WinQueryWindow(hwnd, QW_PARENT),
3326 QW_PARENT));
3327 return 0;
[2]3328
[551]3329 case WM_SAVEAPPLICATION:
3330 if (dcd && ParentIsDesktop(hwnd, dcd->hwndParent)) {
3331 SWP swp;
[2]3332
[551]3333 WinQueryWindowPos(dcd->hwndFrame, &swp);
3334 if (!(swp.fl & (SWP_HIDE | SWP_MINIMIZE | SWP_MAXIMIZE)))
3335 PrfWriteProfileData(fmprof, appname, "AV2SizePos", &swp, sizeof(swp));
3336 }
3337 break;
[2]3338
[551]3339 case WM_CLOSE:
3340 WinSendMsg(hwnd, WM_SAVEAPPLICATION, MPVOID, MPVOID);
3341 if (dcd)
3342 dcd->stopflag++;
3343 if (dcd && dcd->hwndObject) {
3344 if (!PostMsg(dcd->hwndObject, WM_CLOSE, MPVOID, MPVOID))
3345 WinSendMsg(dcd->hwndObject, WM_CLOSE, MPVOID, MPVOID);
3346 }
3347 // In case object window frees dcd
3348 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
3349 if (!dcd ||
3350 (!dcd->dontclose &&
3351 !dcd->amextracted && ParentIsDesktop(hwnd, dcd->hwndParent))) {
3352 if (!PostMsg(hwnd, UM_FOLDUP, MPVOID, MPVOID))
3353 WinSendMsg(hwnd, UM_FOLDUP, MPVOID, MPVOID);
3354 }
3355 return 0;
3356
3357 case WM_DESTROY:
3358 if (ArcMenu)
3359 WinDestroyWindow(ArcMenu);
3360 if (ArcCnrMenu)
3361 WinDestroyWindow(ArcCnrMenu);
3362 ArcMenu = ArcCnrMenu = (HWND) 0;
[751]3363 EmptyArcCnr(hwnd);
[551]3364 break;
[2]3365 }
[705]3366 if (dcd && dcd->oldproc){
3367 return dcd->oldproc(hwnd, msg, mp1, mp2);
3368 }
3369 else
3370 return PFNWPCnr(hwnd, msg, mp1, mp2);
[2]3371}
3372
[942]3373MRESULT EXPENTRY ArcCnrMenuProc(HWND hwnd, ULONG msg, MPARAM mp1,
3374 MPARAM mp2)
3375{
3376 PFNWP oldMenuProc = WinQueryWindowPtr(hwnd, QWL_USER);
3377 static short sLastMenuitem;
3378
3379 switch (msg) {
3380 case WM_MOUSEMOVE: {
3381 if (fOtherHelp) {
[953]3382 RECTL rectl;
3383 SHORT i, sCurrentMenuitem;
3384 SHORT MenuItems = 10;
3385 SHORT asMenuIDs[10] = {IDM_VIEW,
3386 IDM_DELETE,
3387 IDM_EXEC,
3388 IDM_EXTRACT,
3389 IDM_TEST,
3390 IDM_VIRUSSCAN,
3391 IDM_RESCAN,
3392 IDM_WALKDIR,
3393 IDM_FILTER,
3394 0};
3395 char *szHelpString = NULL;
[942]3396
3397
[953]3398 for (i=0; i<MenuItems; i++) {
3399 sCurrentMenuitem = asMenuIDs[i];
3400 oldMenuProc(hwnd,MM_QUERYITEMRECT,
3401 MPFROM2SHORT(asMenuIDs[i], FALSE),
3402 &rectl);
[942]3403
[953]3404 if (MOUSEMSG(&msg)->x > rectl.xLeft &&
3405 MOUSEMSG(&msg)->x < rectl.xRight &&
3406 MOUSEMSG(&msg)->y > rectl.yBottom &&
3407 MOUSEMSG(&msg)->y < rectl.yTop)
3408 break;
3409 } // for
[942]3410
3411
[953]3412 switch (sCurrentMenuitem) {
3413 case 0:
3414 break;
3415 case IDM_VIEW:
3416 szHelpString = GetPString(IDS_ARCCNRVIEWMENUHELP);
3417 break;
3418 case IDM_DELETE:
3419 szHelpString = GetPString(IDS_ARCCNRDELETEMENUHELP);
3420 break;
3421 case IDM_EXEC:
3422 szHelpString = GetPString(IDS_ARCCNREXECMENUHELP);
3423 break;
3424 case IDM_EXTRACT:
3425 szHelpString = GetPString(IDS_ARCCNREXTRACTMENUHELP);
3426 break;
3427 case IDM_TEST:
3428 szHelpString = GetPString(IDS_ARCCNRTESTMENUHELP);
3429 break;
3430 case IDM_VIRUSSCAN:
3431 szHelpString = GetPString(IDS_ARCCNRVIRUSMENUHELP);
3432 break;
3433 case IDM_RESCAN:
3434 szHelpString = GetPString(IDS_ARCCNRRESCANMENUHELP);
3435 break;
3436 case IDM_WALKDIR:
3437 szHelpString = GetPString(IDS_ARCCNRWALKDIRMENUHELP);
3438 break;
3439 case IDM_FILTER:
3440 szHelpString = GetPString(IDS_ARCCNRFILTERMENUHELP);
3441 break;
3442 default:
3443 break;
3444 }
[942]3445
[953]3446 if (sLastMenuitem != sCurrentMenuitem && szHelpString) {
3447 sLastMenuitem = sCurrentMenuitem;
3448 MakeBubble(hwnd, TRUE, szHelpString);
3449 }
3450 else if (hwndBubble && !sCurrentMenuitem){
3451 sLastMenuitem = sCurrentMenuitem;
3452 WinDestroyWindow(hwndBubble);
3453 }
[942]3454 }
3455 }
3456 }
3457 return oldMenuProc(hwnd, msg, mp1, mp2);
3458}
3459
[551]3460HWND StartArcCnr(HWND hwndParent, HWND hwndCaller, CHAR * arcname, INT flags,
3461 ARC_TYPE * sinfo)
[212]3462{
[2]3463 /*
3464 * bitmapped flags:
3465 * 1 = am extracted from another archive
3466 * 4 = don't kill proc on close
3467 */
3468
[551]3469 HWND hwndFrame = (HWND) 0, hwndClient;
3470 ULONG FrameFlags = FCF_TITLEBAR | FCF_SYSMENU |
3471 FCF_SIZEBORDER | FCF_MINMAX | FCF_ICON | FCF_NOBYTEALIGN | FCF_ACCELTABLE;
3472 USHORT id;
3473 DIRCNRDATA *dcd;
3474 ARC_TYPE *info = sinfo;
3475 CHAR title[MAXNAMEL + 1] = "AV/2 - ";
3476 CHAR fullname[CCHMAXPATH + 8], *p, temp;
[2]3477 static USHORT idinc = 0;
3478
[423]3479 if (!idinc)
[2]3480 idinc = (rand() % 256);
[551]3481 if (ParentIsDesktop(hwndParent, hwndParent))
[2]3482 FrameFlags |= (FCF_TASKLIST | FCF_MENU);
[423]3483 if (arcname) {
[2]3484 DosError(FERR_DISABLEHARDERR);
[423]3485 if (DosQueryPathInfo(arcname,
[551]3486 FIL_QUERYFULLNAME, fullname, sizeof(fullname)))
3487 strcpy(fullname, arcname);
[2]3488 p = fullname;
[551]3489 while (*p) {
[423]3490 if (*p == '/')
[551]3491 *p = '\\';
[2]3492 p++;
3493 }
[423]3494 if (!info)
[551]3495 info = find_type(fullname, arcsighead);
[423]3496 if (!info)
[2]3497 return hwndFrame;
[551]3498 if (strlen(title) + strlen(fullname) > MAXNAMEL) {
3499 p = title + strlen(title);
3500 strncpy(p, fullname, MAXNAMEL / 2 - 5);
3501 strcpy(p + MAXNAMEL / 2 - 5, "...");
3502 strcat(title, fullname + strlen(fullname) - (MAXNAMEL / 2 - 5));
[460]3503 }
[551]3504 else {
3505 strcat(title, fullname);
[460]3506 }
[2]3507 hwndFrame = WinCreateStdWindow(hwndParent,
[551]3508 WS_VISIBLE,
3509 &FrameFlags,
[593]3510 WC_ARCCONTAINER,
[551]3511 title,
3512 WS_VISIBLE | fwsAnimate,
3513 FM3ModHandle, ARC_FRAME, &hwndClient);
[423]3514 if (hwndFrame && hwndClient) {
[2]3515 id = ARC_FRAME + idinc++;
[423]3516 if (idinc > 512)
[551]3517 idinc = 0;
3518 WinSetWindowUShort(hwndFrame, QWS_ID, id);
[1063]3519# ifdef FORTIFY
3520 Fortify_EnterScope();
3521# endif
[551]3522 dcd = xmallocz(sizeof(DIRCNRDATA), pszSrcFile, __LINE__);
[358]3523 if (!dcd) {
[551]3524 PostMsg(hwndClient, WM_CLOSE, MPVOID, MPVOID);
3525 hwndFrame = (HWND) 0;
[358]3526 }
3527 else {
[551]3528 dcd->size = sizeof(DIRCNRDATA);
3529 dcd->id = id;
3530 dcd->type = ARC_FRAME;
[1069]3531 if (!fUseTmp) {
3532 save_dir2(dcd->workdir);
3533 if (dcd->workdir[strlen(dcd->workdir) - 1] != '\\')
3534 strcat(dcd->workdir, "\\");
3535 sprintf(dcd->workdir + strlen(dcd->workdir), "%s.%03x",
3536 ArcTempRoot, (clock() & 4095));
3537 }
3538 else
3539 sprintf(dcd->workdir, "%s.%03x",
3540 ArcTempRoot, (clock() & 4095));
[551]3541 strcpy(dcd->arcname, fullname);
3542 if (*extractpath) {
3543 if (!strcmp(extractpath, "*")) {
3544 p = strrchr(fullname, '\\');
3545 if (p) {
3546 if (p < fullname + 3)
3547 p++;
3548 temp = *p;
3549 *p = 0;
3550 strcpy(dcd->directory, fullname);
3551 *p = temp;
3552 }
3553 }
3554 else
3555 strcpy(dcd->directory, extractpath);
3556 }
3557 if (!*dcd->directory && *lastextractpath) {
3558 DosEnterCritSec();
3559 strcpy(dcd->directory, lastextractpath);
3560 DosExitCritSec();
3561 }
3562 if (!*dcd->directory) {
3563 if (!ParentIsDesktop(hwndParent, hwndParent))
3564 TopWindowName(hwndParent, hwndCaller, dcd->directory);
3565 if (!*dcd->directory) {
3566 p = strrchr(fullname, '\\');
3567 if (p) {
3568 if (p < fullname + 3)
3569 p++;
3570 *p = 0;
3571 strcpy(dcd->directory, fullname);
3572 }
3573 }
3574 }
3575 if (!*dcd->directory ||
3576 IsFile(dcd->directory) ||
3577 (isalpha(*dcd->directory) &&
3578 (driveflags[toupper(*dcd->directory) - 'A'] &
3579 DRIVE_NOTWRITEABLE)))
3580 save_dir2(dcd->directory);
[562]3581 dcd->hwndParent = hwndParent ? hwndParent : HWND_DESKTOP;
[551]3582 dcd->hwndFrame = hwndFrame;
3583 dcd->hwndClient = hwndClient;
[562]3584 dcd->amextracted = (flags & 1) != 0;
3585 dcd->dontclose = (flags & 4) != 0;
[551]3586 dcd->info = info;
3587 dcd->sortFlags = DefArcSortFlags;
3588 {
3589 PFNWP oldproc;
[2]3590
[551]3591 oldproc = WinSubclassWindow(hwndFrame, (PFNWP) ArcFrameWndProc);
3592 WinSetWindowPtr(hwndFrame, QWL_USER, (PVOID) oldproc);
[358]3593 }
[551]3594 dcd->hwndCnr = WinCreateWindow(hwndClient,
3595 WC_CONTAINER,
3596 NULL,
3597 CCS_AUTOPOSITION | CCS_MINIICONS |
3598 CCS_MINIRECORDCORE | ulCnrType |
3599 WS_VISIBLE,
3600 0,
3601 0,
3602 0,
3603 0,
3604 hwndClient,
3605 HWND_TOP, (ULONG) ARC_CNR, NULL, NULL);
3606 if (!dcd->hwndCnr) {
3607 Win_Error2(hwndClient, hwndClient, pszSrcFile, __LINE__,
3608 IDS_WINCREATEWINDOW);
3609 PostMsg(hwndClient, WM_CLOSE, MPVOID, MPVOID);
[1039]3610 free(dcd);
[1063]3611# ifdef FORTIFY
3612 Fortify_LeaveScope();
3613# endif
[551]3614 hwndFrame = (HWND) 0;
3615 }
[358]3616 else {
[551]3617 WinSetWindowPtr(dcd->hwndCnr, QWL_USER, (PVOID) dcd);
3618 dcd->oldproc = WinSubclassWindow(dcd->hwndCnr,
3619 (PFNWP) ArcCnrWndProc);
3620 {
3621 USHORT ids[] = { DIR_TOTALS, DIR_SELECTED, DIR_VIEW, DIR_SORT,
3622 DIR_FILTER, DIR_FOLDERICON, 0
3623 };
[2]3624
[551]3625 CommonCreateTextChildren(dcd->hwndClient,
[593]3626 WC_ARCSTATUS, ids);
[551]3627 }
3628 WinEnableWindow(WinWindowFromID(dcd->hwndClient, DIR_VIEW), FALSE);
3629 dcd->hwndExtract = WinCreateWindow(dcd->hwndClient,
3630 WC_ENTRYFIELD,
3631 NULL,
3632 ES_AUTOSCROLL,
3633 0,
3634 0,
3635 0,
3636 0,
3637 dcd->hwndClient,
3638 HWND_TOP,
3639 ARC_EXTRACTDIR, NULL, NULL);
3640 WinSendMsg(dcd->hwndExtract,
3641 EM_SETTEXTLIMIT, MPFROM2SHORT(CCHMAXPATH, 0), MPVOID);
3642 WinSetWindowText(dcd->hwndExtract, dcd->directory);
3643 if (!PostMsg(dcd->hwndCnr, UM_SETUP, MPVOID, MPVOID))
3644 WinSendMsg(dcd->hwndCnr, UM_SETUP, MPVOID, MPVOID);
[953]3645 if (FrameFlags & FCF_MENU) {
3646 PFNWP oldmenuproc;
3647 HWND hwndMenu = WinWindowFromID(hwndFrame, FID_MENU);
[942]3648
3649 oldmenuproc = WinSubclassWindow(hwndMenu, (PFNWP) ArcCnrMenuProc);
3650 WinSetWindowPtr(hwndMenu, QWL_USER, (PVOID) oldmenuproc);
[551]3651 if (!fToolbar) {
[2]3652
[551]3653 if (hwndMenu) {
3654 WinSendMsg(hwndMenu, MM_DELETEITEM,
3655 MPFROM2SHORT(IDM_VIEW, FALSE), MPVOID);
3656 WinSendMsg(hwndMenu, MM_DELETEITEM,
3657 MPFROM2SHORT(IDM_EXEC, FALSE), MPVOID);
3658 WinSendMsg(hwndMenu, MM_DELETEITEM,
3659 MPFROM2SHORT(IDM_RESCAN, FALSE), MPVOID);
3660 WinSendMsg(hwndMenu, MM_DELETEITEM,
3661 MPFROM2SHORT(IDM_DELETE, FALSE), MPVOID);
3662 WinSendMsg(hwndMenu, MM_DELETEITEM,
3663 MPFROM2SHORT(IDM_EXTRACT, FALSE), MPVOID);
3664 WinSendMsg(hwndMenu, MM_DELETEITEM,
3665 MPFROM2SHORT(IDM_TEST, FALSE), MPVOID);
3666 WinSendMsg(hwndMenu, MM_DELETEITEM,
3667 MPFROM2SHORT(IDM_VIRUSSCAN, FALSE), MPVOID);
3668 WinSendMsg(hwndMenu, MM_DELETEITEM,
3669 MPFROM2SHORT(IDM_WALKDIR, FALSE), MPVOID);
3670 WinSendMsg(hwndMenu, MM_DELETEITEM,
3671 MPFROM2SHORT(IDM_FILTER, FALSE), MPVOID);
3672 }
3673 }
3674 }
3675 if (FrameFlags & FCF_TASKLIST) {
[2]3676
[551]3677 SWP swp, swpD;
3678 ULONG size = sizeof(swp);
3679 LONG cxScreen, cyScreen;
[2]3680
[551]3681 WinQueryTaskSizePos(WinQueryAnchorBlock(hwndFrame), 0, &swp);
3682 if (PrfQueryProfileData(fmprof,
3683 appname, "AV2SizePos", &swpD, &size)) {
3684 cxScreen = WinQuerySysValue(HWND_DESKTOP, SV_CXSCREEN);
3685 cyScreen = WinQuerySysValue(HWND_DESKTOP, SV_CYSCREEN);
3686 if (swp.x + swpD.cx > cxScreen)
3687 swp.x = cxScreen - swpD.cx;
3688 if (swp.y + swpD.cy > cyScreen)
3689 swp.y = cyScreen - swpD.cy;
3690 swp.cx = swpD.cx;
3691 swp.cy = swpD.cy;
3692 }
3693 WinSetWindowPos(hwndFrame,
3694 HWND_TOP,
3695 swp.x,
3696 swp.y,
3697 swp.cx,
3698 swp.cy,
3699 SWP_SIZE | SWP_MOVE | SWP_SHOW | SWP_ZORDER |
3700 SWP_ACTIVATE);
3701 }
3702 }
[2]3703 }
3704 }
3705 }
3706 return hwndFrame;
3707}
[793]3708
3709#pragma alloc_text(ARCCNRS,ArcCnrWndProc,ArcObjWndProc,ArcClientWndProc,BldQuotedFullPathName)
3710#pragma alloc_text(ARCCNRS,ArcTextProc,FillArcCnr,ArcFilter,BldQuotedFileName)
3711#pragma alloc_text(ARCCNRS,ArcSort,ArcFrameWndProc,IsArcThere,ArcErrProc)
3712#pragma alloc_text(STARTUP,StartArcCnr)
Note: See TracBrowser for help on using the repository browser.