source: trunk/dll/arccnrs.c@ 1301

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

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