source: trunk/dll/arccnrs.c@ 1689

Last change on this file since 1689 was 1689, checked in by Gregg Young, 12 years ago

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