source: trunk/dll/arccnrs.c@ 1877

Last change on this file since 1877 was 1877, checked in by Gregg Young, 10 years ago

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