source: trunk/dll/arccnrs.c@ 1311

Last change on this file since 1311 was 1311, checked in by John Small, 17 years ago

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