source: trunk/dll/arccnrs.c@ 890

Last change on this file since 890 was 888, checked in by Gregg Young, 18 years ago

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