source: trunk/dll/arccnrs.c@ 1038

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

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