source: trunk/dll/arccnrs.c@ 1616

Last change on this file since 1616 was 1616, checked in by Gregg Young, 14 years ago

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