source: trunk/dll/collect.c@ 529

Last change on this file since 529 was 471, checked in by root, 19 years ago

Disable Utilities->Seek and scan menu while busy
Correct stop scan context menu enable/disable
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 71.3 KB
RevLine 
[96]1
2/***********************************************************************
3
4 $Id: collect.c 471 2006-09-01 01:05:53Z root $
5
6 Collector
7
8 Copyright (c) 1993-98 M. Kimes
[352]9 Copyright (c) 2003, 2006 Steven H. Levine
[96]10
[130]11 15 Oct 02 MK Baseline
12 10 Jan 04 SHL Avoid -1L byte counts
13 01 Aug 04 SHL Rework lstrip/rstrip usage
14 23 May 05 SHL Use QWL_USER
[145]15 24 May 05 SHL Rework Win_Error usage
[155]16 25 May 05 SHL Use ULONGLONG and CommaFmtULL
17 25 May 05 SHL Rework for FillInRecordFromFFB
[186]18 05 Jun 05 SHL Use QWL_USER
[194]19 06 Jun 05 SHL Indent -i2
[197]20 06 Jun 05 SHL Make savedSortFlags static to avoid referencing garbage
[280]21 24 Oct 05 SHL Sanitize handle references
22 24 Oct 05 SHL CollectorCnrWndProc: avoid excess writes to Status2 window
23 10 Nov 05 SHL CollectorCnrWndProc: correct missing button window updates
[352]24 14 Jul 06 SHL Use Runtime_Error
[403]25 27 Jul 06 SHL Avoid shutdown hang - pre3 typo
26 29 Jul 06 SHL Use xfgets_bstripcr
[444]27 15 Aug 06 SHL Don't write garbage to CollectorFilter INI entry
28 15 Aug 06 SHL Rework SetMask args
29 18 Aug 06 SHL CollectorCnrWndProc: avoid freeing NULL pointer
[471]30 31 Aug 06 SHL Disable Utilities->Seek and scan menu while busy
31 31 Aug 06 SHL Correct stop scan context menu enable/disable
[96]32
33***********************************************************************/
34
[2]35#define INCL_DOS
36#define INCL_WIN
37#define INCL_GPI
38#define INCL_DOSERRORS
[155]39#define INCL_LONGLONG
40#include <os2.h>
[2]41
42#include <stdarg.h>
43#include <stdio.h>
44#include <stdlib.h>
45#include <string.h>
46#include <ctype.h>
47#include <time.h>
48#include <share.h>
49#include <limits.h>
[155]50
[2]51#include "fm3dll.h"
52#include "fm3dlg.h"
53#include "fm3str.h"
54#include "mle.h"
55#include "grep.h"
56
57#pragma data_seg(DATA1)
[352]58
59static PSZ pszSrcFile = __FILE__;
60
[2]61#pragma alloc_text(COLLECTOR,CollectorCnrWndProc,CollectorObjWndProc)
62#pragma alloc_text(COLLECTOR,CollectorClientWndProc,CollectorTextProc)
63#pragma alloc_text(COLLECTOR,CollectorFrameWndProc)
64#pragma alloc_text(STARTUP,StartCollector)
65
[194]66MRESULT EXPENTRY CollectorFrameWndProc(HWND hwnd, ULONG msg, MPARAM mp1,
67 MPARAM mp2)
68{
69 return CommonFrameWndProc(COLLECTOR_CNR, hwnd, msg, mp1, mp2);
[2]70}
71
[194]72MRESULT EXPENTRY CollectorTextProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
[96]73{
[197]74 DIRCNRDATA *dcd;
[155]75
[194]76 static BOOL emphasized = FALSE;
[403]77 static HWND hwndButtonPopup = (HWND)0;
[194]78 static ULONG timestamp = ULONG_MAX;
79 static USHORT lastid = 0;
[2]80
[444]81 switch (msg) {
[194]82 case WM_CREATE:
83 return CommonTextProc(hwnd, msg, mp1, mp2);
[2]84
[194]85 case UM_CONTEXTMENU:
86 case WM_CONTEXTMENU:
87 {
88 USHORT id;
89
90 id = WinQueryWindowUShort(hwnd, QWS_ID);
[444]91 switch (id) {
[194]92 case DIR_SELECTED:
93 case DIR_VIEW:
94 case DIR_SORT:
95 {
96 POINTL ptl = {0, 0};
97 SWP swp;
[2]98
[194]99 if (hwndButtonPopup)
100 WinDestroyWindow(hwndButtonPopup);
[444]101 if (id == lastid) {
[194]102 ULONG check;
[2]103
[194]104 DosQuerySysInfo(QSV_MS_COUNT,
105 QSV_MS_COUNT,
106 &check,
107 sizeof(check));
[444]108 if (check < timestamp + 500) {
[194]109 lastid = 0;
110 goto MenuAbort;
111 }
112 }
[471]113 hwndButtonPopup = WinLoadMenu(HWND_DESKTOP,FM3ModHandle,id);
[444]114 if (hwndButtonPopup) {
[471]115 WinSetWindowUShort(hwndButtonPopup,QWS_ID,id);
[194]116 dcd = WinQueryWindowPtr(WinWindowFromID(WinQueryWindow(hwnd,
[352]117 QW_PARENT),
[194]118 COLLECTOR_CNR),
119 QWL_USER);
[444]120 if (id == DIR_VIEW) {
121 if (dcd) {
[471]122 SetViewMenu(hwndButtonPopup,dcd -> flWindowAttr);
123 SetDetailsSwitches(hwndButtonPopup,dcd);
[194]124 }
[2]125
[194]126 /* don't have tree view in collector */
127 WinSendMsg(hwndButtonPopup,
128 MM_DELETEITEM,
[471]129 MPFROM2SHORT(IDM_TREEVIEW,FALSE),
[194]130 MPVOID);
[2]131
[194]132 }
[444]133 else if (id == DIR_SORT) {
[194]134 if (dcd)
[471]135 SetSortChecks(hwndButtonPopup,dcd -> sortFlags);
[194]136 }
137 ptl.x = 0;
138 if (WinPopupMenu(HWND_OBJECT,
139 HWND_OBJECT,
140 hwndButtonPopup,
141 -32767,
142 -32767,
143 0,
144 0))
145 {
[471]146 WinQueryWindowPos(hwndButtonPopup,&swp);
[194]147 ptl.y = -(swp.cy + 2);
148 }
[444]149 else {
[471]150 WinQueryWindowPos(hwnd,&swp);
[194]151 ptl.y = swp.cy + 2;
152 }
153 if (WinPopupMenu(hwnd,
154 hwnd,
155 hwndButtonPopup,
156 ptl.x,
157 ptl.y,
158 0,
159 PU_HCONSTRAIN | PU_VCONSTRAIN |
160 PU_KEYBOARD | PU_MOUSEBUTTON1))
161 {
162 CenterOverWindow(hwndButtonPopup);
[471]163 PaintRecessedWindow(hwnd,NULLHANDLE,FALSE,FALSE);
[194]164 }
165 }
166 }
167 break;
168 default:
169 PostMsg(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
170 COLLECTOR_CNR),
171 WM_CONTROL,
[471]172 MPFROM2SHORT(COLLECTOR_CNR,CN_CONTEXTMENU),
[194]173 MPVOID);
174 break;
[2]175 }
[194]176 }
177 MenuAbort:
178 if (msg == UM_CONTEXTMENU)
179 return 0;
180 break;
[2]181
[194]182 case WM_MENUEND:
[444]183 if (hwndButtonPopup == (HWND)mp2) {
[403]184 lastid = WinQueryWindowUShort((HWND)mp2, QWS_ID);
[194]185 WinDestroyWindow(hwndButtonPopup);
[403]186 hwndButtonPopup = (HWND)0;
[471]187 DosQuerySysInfo(QSV_MS_COUNT,QSV_MS_COUNT,&timestamp,sizeof(timestamp));
[444]188 switch (lastid) {
[194]189 case DIR_SELECTED:
190 case DIR_VIEW:
191 case DIR_SORT:
[471]192 PaintRecessedWindow(hwnd,NULLHANDLE,TRUE,FALSE);
[194]193 break;
[2]194 }
[194]195 }
196 break;
[2]197
[194]198 case WM_COMMAND:
199 {
200 DIRCNRDATA *dcd;
201 MRESULT mr;
202
203 mr = WinSendMsg(WinWindowFromID(WinQueryWindow(hwnd,
204 QW_PARENT),
205 COLLECTOR_CNR),
206 msg,
207 mp1,
208 mp2);
209 if (hwndButtonPopup &&
210 SHORT1FROMMP(mp1) > IDM_DETAILSTITLES &&
211 SHORT1FROMMP(mp1) < IDM_DETAILSSETUP)
[2]212 {
[194]213 dcd = WinQueryWindowPtr(WinWindowFromID(WinQueryWindow(hwnd,
214 QW_PARENT),
215 COLLECTOR_CNR),
216 QWL_USER);
217 if (dcd)
[471]218 SetDetailsSwitches(hwndButtonPopup,dcd);
[2]219 }
[194]220 return mr;
221 }
[2]222
[194]223 case WM_MOUSEMOVE:
224 {
225 USHORT id = WinQueryWindowUShort(hwnd, QWS_ID);
226 char *s = NULL;
227
[444]228 if (fOtherHelp) {
[194]229 if ((!hwndBubble ||
230 WinQueryWindowULong(hwndBubble, QWL_USER) != hwnd) &&
231 !WinQueryCapture(HWND_DESKTOP))
232 {
[444]233 switch (id) {
[194]234 case DIR_SELECTED:
235 s = GetPString(IDS_COLSELECTEDHELP);
236 break;
237 case DIR_TOTALS:
238 s = GetPString(IDS_COLTOTALSHELP);
239 break;
240 case DIR_VIEW:
241 s = GetPString(IDS_DIRCNRVIEWHELP);
242 break;
243 case DIR_SORT:
244 s = GetPString(IDS_DIRCNRSORTHELP);
245 break;
246 case DIR_FILTER:
247 s = GetPString(IDS_DIRCNRFILTERHELP);
248 break;
249 default:
250 break;
251 }
252 if (s)
253 MakeBubble(hwnd, TRUE, s);
254 else if (hwndBubble)
255 WinDestroyWindow(hwndBubble);
256 }
[2]257 }
[444]258 switch (id) {
[194]259 case DIR_FILTER:
260 case DIR_SORT:
261 case DIR_VIEW:
262 case DIR_SELECTED:
263 return CommonTextButton(hwnd, msg, mp1, mp2);
264 }
265 }
266 break;
[2]267
[194]268 case WM_BUTTON3UP:
269 case WM_BUTTON1UP:
270 case WM_BUTTON3DOWN:
271 case WM_BUTTON1DOWN:
272 {
273 USHORT id;
274
[280]275 id = WinQueryWindowUShort(hwnd, QWS_ID);
[444]276 switch (id) {
[194]277 case DIR_FILTER:
278 case DIR_SORT:
279 case DIR_VIEW:
280 case DIR_SELECTED:
281 return CommonTextButton(hwnd, msg, mp1, mp2);
[2]282 }
[194]283 }
284 break;
[2]285
[194]286 case UM_CLICKED:
287 case UM_CLICKED3:
288 {
289 USHORT id, cmd = 0;
290
[280]291 id = WinQueryWindowUShort(hwnd, QWS_ID);
[444]292 switch (id) {
[194]293 case DIR_VIEW:
294 case DIR_SORT:
295 case DIR_SELECTED:
[471]296 PostMsg(hwnd,UM_CONTEXTMENU,MPVOID,MPVOID);
[194]297 break;
298 case DIR_FILTER:
299 cmd = IDM_FILTER;
300 break;
301 default:
302 break;
[2]303 }
[194]304 if (cmd)
[471]305 PostMsg(WinWindowFromID(WinQueryWindow(hwnd,QW_PARENT),
[194]306 COLLECTOR_CNR),
307 WM_COMMAND,
308 MPFROM2SHORT(cmd, 0),
309 MPVOID);
310 }
311 return 0;
[2]312
[194]313 case DM_DROP:
314 case DM_DRAGOVER:
315 case DM_DRAGLEAVE:
316 case DM_DROPHELP:
[444]317 if (msg == DM_DRAGOVER) {
318 if (!emphasized) {
[194]319 emphasized = TRUE;
320 DrawTargetEmphasis(hwnd, emphasized);
[2]321 }
[194]322 }
[444]323 else {
324 if (emphasized) {
[194]325 emphasized = FALSE;
326 DrawTargetEmphasis(hwnd, emphasized);
[2]327 }
[194]328 }
329 {
330 CNRDRAGINFO cnd;
331 USHORT dcmd;
332
[444]333 switch (msg) {
[194]334 case DM_DROP:
335 dcmd = CN_DROP;
336 break;
337 case DM_DRAGOVER:
338 dcmd = CN_DRAGOVER;
339 break;
340 case DM_DRAGLEAVE:
341 dcmd = CN_DRAGLEAVE;
342 break;
343 case DM_DROPHELP:
344 dcmd = CN_DROPHELP;
345 break;
[2]346 }
[194]347 memset(&cnd, 0, sizeof(cnd));
348 cnd.pDragInfo = (PDRAGINFO) mp1;
349 cnd.pRecord = NULL;
350 return WinSendMsg(WinQueryWindow(hwnd, QW_PARENT), WM_CONTROL,
351 MPFROM2SHORT(COLLECTOR_CNR, dcmd), MPFROMP(&cnd));
352 }
[2]353 }
[194]354 return PFNWPStatic(hwnd, msg, mp1, mp2);
[2]355}
356
[194]357MRESULT EXPENTRY CollectorClientWndProc(HWND hwnd, ULONG msg, MPARAM mp1,
358 MPARAM mp2)
359{
[444]360 switch (msg) {
[194]361 case UM_CONTAINERHWND:
362 return MRFROMLONG(WinWindowFromID(hwnd, COLLECTOR_CNR));
[2]363
[194]364 case UM_VIEWSMENU:
365 return MRFROMLONG(CheckMenu(&CollectorCnrMenu, COLLECTORCNR_POPUP));
[2]366
[194]367 case MM_PORTHOLEINIT:
368 case WM_INITMENU:
369 case UM_INITMENU:
370 case UM_CONTAINER_FILLED:
371 case UM_FILESMENU:
372 case UM_UPDATERECORD:
373 case UM_UPDATERECORDLIST:
374 return WinSendMsg(WinWindowFromID(hwnd, COLLECTOR_CNR), msg, mp1, mp2);
[2]375
[194]376 case WM_PSETFOCUS:
377 case WM_SETFOCUS:
378 if (mp2)
379 PostMsg(hwnd, UM_FOCUSME, MPVOID, MPVOID);
380 break;
[2]381
[194]382 case UM_FOCUSME:
383 WinSetFocus(HWND_DESKTOP, WinWindowFromID(hwnd, COLLECTOR_CNR));
384 break;
[2]385
[194]386 case WM_PAINT:
387 {
388 HPS hps;
389 RECTL rcl;
[2]390
[280]391 hps = WinBeginPaint(hwnd, NULLHANDLE, NULL);
[444]392 if (hps) {
[194]393 WinQueryWindowRect(hwnd, &rcl);
394 WinFillRect(hps, &rcl, CLR_PALEGRAY);
395 CommonTextPaint(hwnd, hps);
396 WinEndPaint(hps);
[2]397 }
[194]398 }
399 break;
[2]400
[194]401 case UM_SIZE:
402 case WM_SIZE:
[444]403 if (msg == UM_SIZE) {
[194]404 SWP swp;
[2]405
[194]406 WinQueryWindowPos(hwnd, &swp);
407 mp1 = MPFROM2SHORT(swp.cx, swp.cy);
408 mp2 = MPFROM2SHORT(swp.cx, swp.cy);
409 }
410 {
411 USHORT cx, cy, bx;
[2]412
[194]413 cx = SHORT1FROMMP(mp2);
414 cy = SHORT2FROMMP(mp2);
415 WinSetWindowPos(WinWindowFromID(hwnd, COLLECTOR_CNR), HWND_TOP,
416 0,
417 0,
418 cx,
419 cy - 24,
420 SWP_SHOW | SWP_MOVE | SWP_SIZE);
421 WinSetWindowPos(WinWindowFromID(hwnd, DIR_TOTALS), HWND_TOP,
422 2,
423 cy - 22,
424 (cx / 3) - 2,
425 20,
426 SWP_SHOW | SWP_MOVE | SWP_SIZE);
427 WinSetWindowPos(WinWindowFromID(hwnd, DIR_SELECTED), HWND_TOP,
428 2 + (cx / 3) + 2,
429 cy - 22,
430 (cx / 3) - 2,
431 20,
432 SWP_SHOW | SWP_MOVE | SWP_SIZE);
433 bx = (cx - (2 + (((cx / 3) + 2) * 2))) / 3;
434 WinSetWindowPos(WinWindowFromID(hwnd, DIR_VIEW), HWND_TOP,
435 2 + (((cx / 3) + 2) * 2),
436 cy - 22,
437 bx - 4,
438 20,
439 SWP_SHOW | SWP_MOVE | SWP_SIZE);
440 WinSetWindowPos(WinWindowFromID(hwnd, DIR_SORT), HWND_TOP,
441 2 + (((cx / 3) + 2) * 2) + bx,
442 cy - 22,
443 bx - 4,
444 20,
445 SWP_SHOW | SWP_MOVE | SWP_SIZE);
446 WinSetWindowPos(WinWindowFromID(hwnd, DIR_FILTER), HWND_TOP,
447 2 + (((cx / 3) + 2) * 2) + (bx * 2),
448 cy - 22,
449 bx - 4,
450 20,
451 SWP_SHOW | SWP_MOVE | SWP_SIZE);
452 }
[280]453 CommonTextPaint(hwnd, NULLHANDLE);
[444]454 if (msg == UM_SIZE) {
[194]455 WinSetWindowPos(WinQueryWindow(hwnd, QW_PARENT), HWND_TOP, 0, 0, 0, 0,
456 SWP_SHOW | SWP_ZORDER | SWP_ACTIVATE);
457 return 0;
458 }
459 break;
[2]460
[194]461 case UM_COMMAND:
462 case WM_COMMAND:
463 case WM_CONTROL:
464 case WM_CLOSE:
465 return WinSendMsg(WinWindowFromID(hwnd, COLLECTOR_CNR), msg, mp1, mp2);
[2]466 }
[194]467 return WinDefWindowProc(hwnd, msg, mp1, mp2);
[2]468}
469
[194]470MRESULT EXPENTRY CollectorObjWndProc(HWND hwnd, ULONG msg, MPARAM mp1,
471 MPARAM mp2)
472{
[197]473 ULONG size;
[2]474 DIRCNRDATA *dcd;
475
[444]476 switch (msg) {
[194]477 case WM_CREATE:
478 break;
[2]479
[194]480 case DM_PRINTOBJECT:
481 return MRFROMLONG(DRR_TARGET);
[2]482
[194]483 case DM_DISCARDOBJECT:
484 dcd = INSTDATA(hwnd);
[444]485 if (fFM2Deletes && dcd) {
[194]486 LISTINFO *li;
487 CNRDRAGINFO cni;
[2]488
[194]489 cni.pRecord = NULL;
490 cni.pDragInfo = (PDRAGINFO) mp1;
491 li = DoFileDrop(dcd -> hwndCnr, NULL, FALSE, MPVOID, MPFROMP(&cni));
[444]492 if (li) {
[194]493 li -> type = (fDefaultDeletePerm) ? IDM_PERMDELETE : IDM_DELETE;
494 if (!PostMsg(hwnd, UM_MASSACTION, MPFROMP(li), MPVOID))
495 FreeListInfo(li);
496 else
497 return MRFROMLONG(DRR_SOURCE);
[2]498 }
[194]499 }
500 return MRFROMLONG(DRR_TARGET);
[2]501
[194]502 case UM_UPDATERECORDLIST:
503 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
[444]504 if (dcd && mp1) {
[194]505 INT numentries = 0;
506 CHAR **list = (CHAR **) mp1;
[2]507
[194]508 while (list[numentries])
509 numentries++;
510 if (numentries)
511 UpdateCnrList(dcd -> hwndCnr, list, numentries, FALSE, dcd);
512 }
513 return 0;
[2]514
[194]515 case UM_SETUP:
516 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
[444]517 if (dcd) {
[194]518 /* set unique id */
519 WinSetWindowUShort(hwnd,
520 QWS_ID,
521 COLLECTOROBJ_FRAME + (COLLECTOR_FRAME - dcd -> id));
522 dcd -> hwndObject = hwnd;
523 if (ParentIsDesktop(hwnd, dcd -> hwndParent))
524 DosSleep(250L);
525 }
526 else
527 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
528 return 0;
[2]529
[194]530 case UM_COMMAND:
[444]531 if (mp1) {
[194]532 LISTINFO *li = (LISTINFO *) mp1;
533
[444]534 switch (li -> type) {
[194]535 case IDM_DOITYOURSELF:
536 case IDM_APPENDTOCLIP:
537 case IDM_SAVETOCLIP:
538 case IDM_ARCHIVE:
539 case IDM_ARCHIVEM:
540 case IDM_VIEW:
541 case IDM_VIEWTEXT:
542 case IDM_VIEWBINARY:
543 case IDM_VIEWARCHIVE:
544 case IDM_EDIT:
545 case IDM_EDITTEXT:
546 case IDM_EDITBINARY:
547 case IDM_OBJECT:
548 case IDM_SHADOW:
549 case IDM_SHADOW2:
550 case IDM_PRINT:
551 case IDM_ATTRS:
552 case IDM_DELETE:
553 case IDM_PERMDELETE:
554 case IDM_FAKEEXTRACT:
555 case IDM_FAKEEXTRACTM:
556 case IDM_MCIPLAY:
557 case IDM_UPDATE:
558 if (PostMsg(hwnd, UM_MASSACTION, mp1, mp2))
559 return (MRESULT) TRUE;
560 break;
561 default:
562 if (PostMsg(hwnd, UM_ACTION, mp1, mp2))
563 return (MRESULT) TRUE;
[2]564 }
[194]565 }
566 return 0;
[2]567
[194]568 case UM_COLLECT:
569 DosError(FERR_DISABLEHARDERR);
570 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
[444]571 if (dcd) {
[194]572 LISTINFO *li = (LISTINFO *) mp1;
573 INT x;
574 FILEFINDBUF4 fb4;
575 HDIR hdir;
576 ULONG nm;
577 PCNRITEM pci, pciFirst, pciT, pciP = NULL;
578 RECORDINSERT ri;
579 ULONG ulMaxFiles;
580 ULONGLONG ullTotalBytes;
581 CHAR fullname[CCHMAXPATH];
[2]582
[471]583 WinSetWindowText(WinWindowFromID(dcd -> hwndClient,DIR_SELECTED),
[194]584 GetPString(IDS_COLLECTINGTEXT));
[352]585 for (ulMaxFiles = 0; li -> list[ulMaxFiles]; ulMaxFiles++)
586 ; // Count
587
588 if (ulMaxFiles) {
[194]589 pci = WinSendMsg(dcd -> hwndCnr, CM_ALLOCRECORD,
590 MPFROMLONG(EXTRA_RECORD_BYTES),
591 MPFROMLONG(ulMaxFiles));
[403]592 if (!pci) {
[352]593 Runtime_Error(pszSrcFile, __LINE__, "CM_ALLOCRECORD %u failed", ulMaxFiles);
594 break;
595 }
596 else {
[194]597 pciFirst = pci;
[444]598 for (x = 0; li -> list[x]; x++) {
[194]599 nm = 1L;
600 hdir = HDIR_CREATE;
601 DosError(FERR_DISABLEHARDERR);
602 if (*li -> list[x] &&
603 !DosQueryPathInfo(li -> list[x], FIL_QUERYFULLNAME,
604 fullname, sizeof(fullname)) &&
605 !IsRoot(fullname) &&
606 !FindCnrRecord(dcd -> hwndCnr,
607 fullname,
608 NULL,
609 FALSE,
610 FALSE,
611 TRUE) &&
612 !DosFindFirst(fullname,
613 &hdir,
614 FILE_NORMAL | FILE_DIRECTORY |
615 FILE_ARCHIVED | FILE_SYSTEM |
616 FILE_HIDDEN | FILE_READONLY,
617 &fb4,
618 sizeof(fb4),
619 &nm,
620 FIL_QUERYEASIZE))
621 {
622 DosFindClose(hdir);
623 priority_normal();
624 *fb4.achName = 0;
625 ullTotalBytes = FillInRecordFromFFB(dcd -> hwndCnr,
626 pci,
627 fullname,
628 &fb4,
629 FALSE,
630 dcd);
631 dcd -> ullTotalBytes += ullTotalBytes;
632 pciP = pci;
633 pci = (PCNRITEM) pci -> rc.preccNextRecord;
634 }
[444]635 else {
[194]636 pciT = pci;
637 pci = (PCNRITEM) pci -> rc.preccNextRecord;
638 if (pciP)
639 pciP -> rc.preccNextRecord = (PMINIRECORDCORE) pci;
640 else
641 pciFirst = pci;
[471]642 WinSendMsg(hwnd, CM_FREERECORD, MPFROMP(&pciT),MPFROM2SHORT(1, 0));
[194]643 ulMaxFiles--;
644 }
645 DosSleep(1L);
646 }
[444]647 if (ulMaxFiles) {
[194]648 memset(&ri, 0, sizeof(RECORDINSERT));
649 ri.cb = sizeof(RECORDINSERT);
650 ri.pRecordOrder = (PRECORDCORE) CMA_END;
651 ri.pRecordParent = (PRECORDCORE) 0;
652 ri.zOrder = (ULONG) CMA_TOP;
653 ri.cRecordsInsert = ulMaxFiles;
654 ri.fInvalidateRecord = TRUE;
655 WinSendMsg(dcd -> hwndCnr,
656 CM_INSERTRECORD,
657 MPFROMP(pciFirst),
658 MPFROMP(&ri));
[471]659 PostMsg(dcd -> hwndCnr,UM_RESCAN,MPVOID,MPVOID);
[194]660 }
661 }
[2]662 }
[194]663 }
664 if (dcd -> flWindowAttr & CV_DETAIL)
665 WinSendDlgItemMsg(hwnd,
666 COLLECTOR_CNR,
667 CM_INVALIDATERECORD,
668 MPVOID,
[471]669 MPFROM2SHORT(0,CMA_ERASE | CMA_REPOSITION));
[194]670 return 0;
[2]671
[194]672 case UM_COLLECTFROMFILE:
673 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
[403]674 if (dcd && mp1) {
[194]675 FILESTATUS4 fs4;
676 PCNRITEM pci;
677 RECORDINSERT ri;
678 CHAR fullname[1024], *p;
679 FILE *fp;
680 ULONG errs = 0L;
[444]681 BOOL first = FALSE;
682 size_t c;
[2]683
[194]684 fp = _fsopen((CHAR *) mp1, "r", SH_DENYNO);
[403]685 if (fp) {
686 while (!feof(fp)) {
[444]687 // Avoid too much noise if collecting from binary file - oops
688 if (!fgets(fullname, sizeof(fullname), fp)) {
689 if (ferror(fp))
690 Runtime_Error(pszSrcFile, __LINE__, "fgets");
[194]691 break;
692 }
[444]693
694 c = strlen(fullname);
695 if (c + 1 >= sizeof(fullname))
696 errs++;
697 else if (!c || (fullname[c-1] != '\n' && fullname[c-1] != '\r'))
698 errs++;
[403]699 else {
[444]700 bstripcr(fullname);
701
702 if (*fullname == '\"') {
703 memmove(fullname, fullname + 1, strlen(fullname) + 1);
704 lstrip(fullname);
705 p = strchr(fullname, '\"');
706 if (p)
707 *p = 0;
708 rstrip(fullname);
709 }
710 else {
711 p = strchr(fullname, ' ');
712 if (p)
713 *p = 0;
714 }
715 /* fullname now contains name of file to collect */
716 DosError(FERR_DISABLEHARDERR);
717 if (IsFullName(fullname) &&
718 !IsRoot(fullname) &&
719 !DosQueryPathInfo(fullname,
720 FIL_QUERYEASIZE,
721 &fs4,
722 sizeof(fs4)) &&
723 !FindCnrRecord(dcd -> hwndCnr,
724 fullname,
725 NULL,
726 FALSE,
727 FALSE,
728 TRUE))
[194]729 {
[444]730 /* collect it */
731 pci = WinSendMsg(dcd -> hwndCnr,
732 CM_ALLOCRECORD,
733 MPFROMLONG(EXTRA_RECORD_BYTES),
734 MPFROMLONG(1L));
735 if (pci) {
736 dcd -> ullTotalBytes += FillInRecordFromFSA(dcd -> hwndCnr, pci,
737 fullname,
738 &fs4, FALSE, dcd);
739 memset(&ri, 0, sizeof(RECORDINSERT));
740 ri.cb = sizeof(RECORDINSERT);
741 ri.pRecordOrder = (PRECORDCORE) CMA_END;
742 ri.pRecordParent = (PRECORDCORE) 0;
743 ri.zOrder = (ULONG) CMA_TOP;
744 ri.cRecordsInsert = 1L;
745 ri.fInvalidateRecord = TRUE;
746 WinSendMsg(dcd -> hwndCnr, CM_INSERTRECORD,
747 MPFROMP(pci), MPFROMP(&ri));
748 }
[194]749 }
[444]750 else
751 errs++;
[194]752 }
[444]753 if (errs > (first ? 0 : 50)) {
754 /* prevent runaway on bad file */
755 APIRET ret = saymsg(MB_YESNO, dcd -> hwndCnr,
756 GetPString(IDS_COLLECTNOLISTHDRTEXT),
757 GetPString(IDS_COLLECTNOLISTTEXT),
758 (CHAR *)mp1);
759 if (ret == MBID_NO)
760 break;
761 if (!first)
762 errs = 0;
763 else
764 first = FALSE;
[194]765 }
[444]766 } // while not eof
[194]767 fclose(fp);
[2]768 }
[194]769 }
[403]770 xfree(mp1);
[194]771 return 0;
[2]772
[194]773 case UM_SELECT:
774 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
[444]775 if (dcd) {
776 switch (SHORT1FROMMP(mp1)) {
[194]777 case IDM_SELECTLIST:
778 {
779 CHAR filename[CCHMAXPATH], *p, *pp;
[2]780
[194]781 strcpy(filename, "*.LST");
782 size = CCHMAXPATH;
[471]783 PrfQueryProfileData(fmprof,appname,"SaveToListName",filename,&size);
[194]784 pp = strrchr(filename, '\\');
785 if (!pp)
786 pp = filename;
787 p = strrchr(pp, '.');
[444]788 if (p && *(p + 1) && p > pp + 1) {
[194]789 if (pp > filename)
790 pp++;
791 *pp = '*';
792 pp++;
793 if (p > pp)
794 memmove(pp, p, strlen(p) + 1);
795 }
796 if (insert_filename(hwnd, filename, FALSE, FALSE))
797 SelectList(dcd -> hwndCnr, TRUE, FALSE, FALSE, NULL, filename, NULL);
798 }
799 break;
800 case IDM_SELECTALL:
801 SelectAll(dcd -> hwndCnr, TRUE, TRUE, NULL, NULL, FALSE);
802 break;
803 case IDM_DESELECTALL:
804 DeselectAll(dcd -> hwndCnr, TRUE, TRUE, NULL, NULL, FALSE);
805 break;
806 case IDM_SELECTALLFILES:
807 SelectAll(dcd -> hwndCnr, TRUE, FALSE, NULL, NULL, FALSE);
808 break;
809 case IDM_DESELECTALLFILES:
810 DeselectAll(dcd -> hwndCnr, TRUE, FALSE, NULL, NULL, FALSE);
811 break;
812 case IDM_SELECTALLDIRS:
813 SelectAll(dcd -> hwndCnr, FALSE, TRUE, NULL, NULL, FALSE);
814 break;
815 case IDM_DESELECTALLDIRS:
816 DeselectAll(dcd -> hwndCnr, FALSE, TRUE, NULL, NULL, FALSE);
817 break;
818 case IDM_DESELECTMASK:
819 case IDM_SELECTMASK:
820 {
821 MASK mask;
822 PCNRITEM pci = (PCNRITEM) mp2;
[2]823
[194]824 memset(&mask, 0, sizeof(MASK));
825 mask.fNoAttribs = TRUE;
826 mask.fNoDirs = TRUE;
827 mask.fText = TRUE;
828 strcpy(mask.prompt,
829 GetPString((SHORT1FROMMP(mp1) == IDM_SELECTMASK) ?
830 IDS_SELECTFILTERTEXT :
831 IDS_DESELECTFILTERTEXT));
832 if (pci && (INT) pci != -1)
833 strcpy(mask.szMask, pci -> szFileName);
834 if (WinDlgBox(HWND_DESKTOP, dcd -> hwndCnr, PickMaskDlgProc,
835 FM3ModHandle, MSK_FRAME, MPFROMP(&mask)))
836 {
837 if (SHORT1FROMMP(mp1) == IDM_SELECTMASK)
838 SelectAll(dcd -> hwndCnr, TRUE, TRUE, mask.szMask, mask.szText,
839 FALSE);
840 else
841 DeselectAll(dcd -> hwndCnr, TRUE, TRUE, mask.szMask, mask.szText,
842 FALSE);
843 }
844 }
[2]845
[194]846 case IDM_DESELECTCLIP:
847 case IDM_SELECTCLIP:
848 {
849 CHAR **list;
[2]850
[194]851 list = ListFromClipboard(hwnd);
[444]852 if (list) {
[194]853 SelectList(dcd -> hwndCnr, TRUE, FALSE,
854 (SHORT1FROMMP(mp1) == IDM_DESELECTCLIP),
855 NULL, NULL, list);
856 FreeList(list);
857 }
858 }
859 break;
[2]860
[194]861 case IDM_INVERT:
862 InvertAll(dcd -> hwndCnr);
863 break;
[2]864 }
[194]865 }
866 return 0;
[2]867
[194]868 case UM_MASSACTION:
[444]869 if (mp1) {
[194]870 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
[444]871 if (dcd) {
[194]872 WORKER *wk;
[2]873
[352]874 wk = xmallocz(sizeof(WORKER),pszSrcFile,__LINE__);
[444]875 if (!wk)
[352]876 FreeListInfo((LISTINFO *) mp1);
877 else {
[194]878 wk -> size = sizeof(WORKER);
879 wk -> hwndCnr = dcd -> hwndCnr;
880 wk -> hwndParent = dcd -> hwndParent;
881 wk -> hwndFrame = dcd -> hwndFrame;
882 wk -> hwndClient = dcd -> hwndClient;
883 wk -> li = (LISTINFO *) mp1;
884 strcpy(wk -> directory, dcd -> directory);
[444]885 if (_beginthread(MassAction, NULL, 122880, (PVOID) wk) == -1) {
886 Runtime_Error(pszSrcFile, __LINE__, GetPString(IDS_COULDNTSTARTTHREADTEXT));
[194]887 free(wk);
888 FreeListInfo((LISTINFO *) mp1);
889 }
890 }
[2]891 }
[194]892 }
893 return 0;
[2]894
[194]895 case UM_ACTION:
[444]896 if (mp1) {
[194]897 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
[444]898 if (dcd) {
[194]899 WORKER *wk;
[2]900
[352]901 wk = xmallocz(sizeof(WORKER),pszSrcFile,__LINE__);
902 if (!wk)
903 FreeListInfo((LISTINFO *) mp1);
904 else {
[194]905 wk -> size = sizeof(WORKER);
906 wk -> hwndCnr = dcd -> hwndCnr;
907 wk -> hwndParent = dcd -> hwndParent;
908 wk -> hwndFrame = dcd -> hwndFrame;
909 wk -> hwndClient = dcd -> hwndClient;
910 wk -> li = (LISTINFO *) mp1;
911 strcpy(wk -> directory, dcd -> directory);
[444]912 if (_beginthread(Action, NULL, 122880, (PVOID) wk) == -1) {
913 Runtime_Error(pszSrcFile, __LINE__, GetPString(IDS_COULDNTSTARTTHREADTEXT));
[194]914 free(wk);
915 FreeListInfo((LISTINFO *) mp1);
916 }
917 }
[2]918 }
[194]919 }
920 return 0;
[2]921
[194]922 case WM_CLOSE:
923 WinDestroyWindow(hwnd);
924 break;
[2]925
[194]926 case WM_DESTROY:
927 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
[444]928 if (dcd) {
929 INT x;
[194]930 dcd -> stopflag = 1;
[280]931 // Allow rescan logic to quiesce
[444]932 for (x = 0; x < 10 && dcd -> amextracted;x++)
[194]933 DosSleep(250L);
934 WinSendMsg(dcd -> hwndCnr, UM_CLOSE, MPVOID, MPVOID);
935 FreeList(dcd -> lastselection);
936 free(dcd);
937 }
938 DosPostEventSem(CompactSem);
[403]939 if (!PostMsg((HWND)0, WM_QUIT, MPVOID, MPVOID))
940 WinSendMsg((HWND)0, WM_QUIT, MPVOID, MPVOID);
[194]941 break;
[2]942 }
[194]943 return WinDefWindowProc(hwnd, msg, mp1, mp2);
[2]944}
945
[194]946MRESULT EXPENTRY CollectorCnrWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
[155]947{
[194]948 DIRCNRDATA *dcd = WinQueryWindowPtr(hwnd, QWL_USER);
[197]949 ULONG size;
[2]950
[197]951 static INT savedSortFlags;
952
[444]953 switch (msg) {
[194]954 case DM_PRINTOBJECT:
955 return MRFROMLONG(DRR_TARGET);
956
957 case DM_DISCARDOBJECT:
958 if (dcd)
959 return WinSendMsg(dcd -> hwndObject, msg, mp1, mp2);
960 else
[2]961 return MRFROMLONG(DRR_TARGET);
962
[194]963 case WM_CHAR:
964 shiftstate = (SHORT1FROMMP(mp1) & (KC_SHIFT | KC_ALT | KC_CTRL));
965 if (SHORT1FROMMP(mp1) & KC_KEYUP)
966 return (MRESULT) TRUE;
[444]967 if (SHORT1FROMMP(mp1) & KC_VIRTUALKEY) {
968 switch (SHORT2FROMMP(mp2)) {
[194]969 case VK_DELETE:
970 if ((shiftstate & KC_CTRL) == KC_CTRL)
971 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_PERMDELETE, 0), MPVOID);
972 else if ((shiftstate & KC_SHIFT) == KC_SHIFT)
973 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_SAVETOCLIP, 0), MPVOID);
974 else
975 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_DELETE, 0), MPVOID);
976 break;
[2]977 }
[194]978 }
979 if (shiftstate || fNoSearch)
980 break;
[444]981 if (SHORT1FROMMP(mp1) & KC_CHAR) {
[194]982 ULONG thistime, len;
983 SEARCHSTRING srch;
984 PCNRITEM pci;
[2]985
[194]986 if (!dcd)
987 break;
[444]988 switch (SHORT1FROMMP(mp2)) {
[194]989 case '\x1b':
990 case '\r':
991 case '\n':
992 dcd -> lasttime = 0;
993 *dcd -> szCommonName = 0;
994 break;
995 default:
996 thistime = WinQueryMsgTime(WinQueryAnchorBlock(hwnd));
997 if (thistime > dcd -> lasttime + 1250)
998 *dcd -> szCommonName = 0;
999 dcd -> lasttime = thistime;
1000 if (SHORT1FROMMP(mp2) == ' ' && !dcd -> szCommonName)
1001 break;
1002 KbdRetry:
1003 len = strlen(dcd -> szCommonName);
[444]1004 if (len >= CCHMAXPATH - 1) {
[194]1005 *dcd -> szCommonName = 0;
1006 len = 0;
1007 }
1008 dcd -> szCommonName[len] = toupper(SHORT1FROMMP(mp2));
1009 dcd -> szCommonName[len + 1] = 0;
1010 memset(&srch, 0, sizeof(SEARCHSTRING));
[197]1011 srch.cb = sizeof(SEARCHSTRING);
1012 srch.pszSearch = dcd -> szCommonName;
[194]1013 srch.fsPrefix = TRUE;
1014 srch.fsCaseSensitive = FALSE;
1015 srch.usView = CV_ICON;
1016 pci = WinSendMsg(hwnd, CM_SEARCHSTRING, MPFROMP(&srch),
1017 MPFROMLONG(CMA_FIRST));
[444]1018 if (pci && (INT) pci != -1) {
[194]1019 USHORT attrib = CRA_CURSORED;
[2]1020
[194]1021 /* make found item current item */
1022 if (!stricmp(pci -> pszFileName, dcd -> szCommonName))
1023 attrib |= CRA_SELECTED;
1024 WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPFROMP(pci),
1025 MPFROM2SHORT(TRUE, attrib));
1026 /* make sure that record shows in viewport */
1027 ShowCnrRecord(hwnd, (PMINIRECORDCORE) pci);
1028 return (MRESULT) TRUE;
1029 }
[444]1030 else {
1031 if (SHORT1FROMMP(mp2) == ' ') {
[194]1032 dcd -> szCommonName[len] = 0;
1033 break;
1034 }
1035 *dcd -> szCommonName = 0;
1036 dcd -> lasttime = 0;
1037 if (len) // retry as first letter if no match
[2]1038
[194]1039 goto KbdRetry;
1040 }
1041 break;
[2]1042 }
[194]1043 }
1044 break;
[2]1045
[194]1046 case WM_MOUSEMOVE:
1047 case WM_BUTTON1UP:
1048 case WM_BUTTON2UP:
1049 case WM_BUTTON3UP:
1050 case WM_CHORD:
1051 shiftstate = (SHORT2FROMMP(mp2) & (KC_SHIFT | KC_ALT | KC_CTRL));
1052 break;
[2]1053
[194]1054 case WM_BUTTON1MOTIONEND:
1055 {
1056 CNRINFO cnri;
1057
1058 memset(&cnri, 0, sizeof(CNRINFO));
1059 cnri.cb = sizeof(CNRINFO);
1060 if (WinSendMsg(hwnd, CM_QUERYCNRINFO, MPFROMP(&cnri),
1061 MPFROMLONG(sizeof(CNRINFO))))
[2]1062 {
[194]1063 if (cnri.flWindowAttr & CV_DETAIL)
1064 PrfWriteProfileData(fmprof, appname, "CollectorCnrSplitBar",
1065 (PVOID) & cnri.xVertSplitbar, sizeof(LONG));
[2]1066 }
[194]1067 }
1068 break;
[2]1069
[194]1070 case WM_PRESPARAMCHANGED:
1071 PresParamChanged(hwnd, "Collector", mp1, mp2);
1072 break;
[2]1073
[194]1074 case UM_COMPARE:
[444]1075 if (dcd && mp1 && mp2) {
[194]1076 COMPARE *cmp;
1077 CHAR *leftdir = (CHAR *) mp1, *rightdir = (CHAR *) mp2;
[2]1078
[444]1079 if (!IsFile(leftdir) && !IsFile(rightdir)) {
[352]1080 cmp = xmallocz(sizeof(COMPARE),pszSrcFile,__LINE__);
[444]1081 if (cmp) {
[194]1082 cmp -> size = sizeof(COMPARE);
1083 strcpy(cmp -> leftdir, leftdir);
1084 strcpy(cmp -> rightdir, rightdir);
1085 cmp -> hwndParent = dcd -> hwndParent;
1086 cmp -> dcd.hwndParent = dcd -> hwndParent;
1087 WinDlgBox(HWND_DESKTOP, HWND_DESKTOP, CompareDlgProc,
1088 FM3ModHandle, COMP_FRAME, MPFROMP(cmp));
1089 }
[2]1090 }
[194]1091 }
1092 return 0;
[2]1093
[194]1094 case UM_UPDATERECORDLIST:
1095 if (dcd && mp1)
1096 WinSendMsg(dcd -> hwndObject, msg, mp1, mp2);
1097 return 0;
[2]1098
[194]1099 case UM_UPDATERECORD:
[444]1100 if (dcd && mp1) {
[194]1101 CHAR *filename;
[2]1102
[194]1103 filename = mp1;
1104 if (filename)
1105 UpdateCnrRecord(hwnd, filename, TRUE, dcd);
1106 }
1107 return 0;
[2]1108
[194]1109 case WM_SETFOCUS:
1110 /*
1111 * put name of our window on status line
1112 */
[444]1113 if (dcd && hwndStatus && mp2) {
[194]1114 PCNRITEM pci = NULL;
[2]1115
[444]1116 if (fAutoView && hwndMain) {
[194]1117 pci = WinSendMsg(hwnd,
1118 CM_QUERYRECORDEMPHASIS,
1119 MPFROMLONG(CMA_FIRST),
1120 MPFROMSHORT(CRA_CURSORED));
1121 if (pci && (INT) pci != -1 &&
1122 (!(driveflags[toupper(*pci -> szFileName) - 'A'] & DRIVE_SLOW)))
[471]1123 WinSendMsg(hwndMain,UM_LOADFILE,MPFROMP(pci -> szFileName),MPVOID);
[194]1124 else
[471]1125 WinSendMsg(hwndMain,UM_LOADFILE,MPVOID,MPVOID);
[2]1126 }
[194]1127 if (dcd -> amextracted)
1128 WinSetWindowText(hwndStatus2,
[280]1129 GetPString(IDS_INSEEKSCANTEXT)); // Say working
[471]1130 WinSendMsg(hwnd,UM_RESCAN,MPVOID,MPVOID);
[194]1131 }
1132 break;
[2]1133
[194]1134 case UM_RESCAN:
[444]1135 if (dcd) {
[194]1136 CNRINFO cnri;
1137 CHAR s[CCHMAXPATH + 69], tb[81], tf[81], *p;
1138 PCNRITEM pci = NULL;
[2]1139
[194]1140 memset(&cnri, 0, sizeof(CNRINFO));
1141 cnri.cb = sizeof(CNRINFO);
1142 WinSendMsg(hwnd, CM_QUERYCNRINFO, MPFROMP(&cnri),
1143 MPFROMLONG(sizeof(CNRINFO)));
1144 dcd -> totalfiles = cnri.cRecords;
1145 commafmt(tf, sizeof(tf), dcd -> totalfiles);
1146 CommaFmtULL(tb, sizeof(tb), dcd -> ullTotalBytes, ' ');
1147 sprintf(s, "%s / %s", tf, tb);
1148 WinSetDlgItemText(dcd -> hwndClient, DIR_TOTALS, s);
[2]1149
[194]1150 commafmt(tf, sizeof(tf), dcd -> selectedfiles);
1151 CommaFmtULL(tb, sizeof(tb), dcd -> selectedbytes, ' ');
1152 sprintf(s, "%s / %s", tf, tb);
1153 WinSetDlgItemText(dcd -> hwndClient, DIR_SELECTED, s);
[155]1154
[194]1155 if (hwndStatus &&
1156 dcd -> hwndFrame == WinQueryActiveWindow(dcd -> hwndParent))
1157 {
[444]1158 if (hwndMain) {
[194]1159 pci = WinSendMsg(hwnd, CM_QUERYRECORDEMPHASIS,
1160 MPFROMLONG(CMA_FIRST),
1161 MPFROMSHORT(CRA_CURSORED));
1162 if (pci && (INT) pci != -1)
1163 PostMsg(hwndMain, UM_LOADFILE, MPFROMP(pci -> szFileName), MPVOID);
1164 else
1165 PostMsg(hwndMain, UM_LOADFILE, MPVOID, MPVOID);
1166 }
1167 if (!fMoreButtons)
1168 sprintf(s, " %s%s%s%s", GetPString(IDS_COLLECTORTEXT),
1169 (*dcd -> mask.szMask || dcd -> mask.antiattr ||
1170 dcd -> mask.attrFile != ALLATTRS) ? " (" : NullStr,
1171 (*dcd -> mask.szMask) ? dcd -> mask.szMask :
1172 (dcd -> mask.antiattr ||
1173 dcd -> mask.attrFile != ALLATTRS) ?
1174 GetPString(IDS_ATTRTEXT) : NullStr,
1175 (*dcd -> mask.szMask || dcd -> mask.antiattr ||
1176 dcd -> mask.attrFile != ALLATTRS) ? ")" : NullStr);
1177 else
1178 strcpy(s, GetPString(IDS_COLLECTORTEXT));
1179 WinSetWindowText(hwndStatus, s);
1180 if (!pci)
1181 pci = WinSendMsg(hwnd, CM_QUERYRECORDEMPHASIS,
1182 MPFROMLONG(CMA_FIRST),
1183 MPFROMSHORT(CRA_CURSORED));
[444]1184 if (pci && (INT) pci != -1) {
[280]1185 BOOL fStatus2Used = FALSE;
[444]1186 if (fSplitStatus && hwndStatus2) {
[194]1187 if (pci -> attrFile & FILE_DIRECTORY)
1188 p = pci -> pszFileName;
[444]1189 else {
[194]1190 p = strrchr(pci -> szFileName, '\\');
[444]1191 if (p) {
[194]1192 if (*(p + 1))
1193 p++;
1194 else
1195 p = pci -> pszFileName;
[155]1196 }
[194]1197 else
1198 p = pci -> pszFileName;
1199 }
1200 CommaFmtULL(tb, sizeof(tb), pci -> cbFile + pci -> easize, ' ');
[444]1201 if (!fMoreButtons) {
[194]1202 sprintf(s, " %s %04u/%02u/%02u %02u:%02u:%02u [%s] %s",
1203 tb, pci -> date.year, pci -> date.month,
1204 pci -> date.day, pci -> time.hours, pci -> time.minutes,
1205 pci -> time.seconds, pci -> pszDispAttr, p);
1206 }
[444]1207 else {
[194]1208 if (pci -> cbFile + pci -> easize > 1024)
1209 CommaFmtULL(tf, sizeof(tf), pci -> cbFile + pci -> easize, 'K');
1210 else
1211 *tf = 0;
1212 sprintf(s, GetPString(IDS_STATUSSIZETEXT),
1213 tb,
1214 *tf ? " (" : NullStr,
1215 tf,
1216 *tf ? ")" : NullStr);
1217 }
1218 WinSetWindowText(hwndStatus2, s);
[280]1219 fStatus2Used = TRUE;
[194]1220 }
[444]1221 if (fMoreButtons) {
[194]1222 WinSetWindowText(hwndName, pci -> pszFileName);
1223 sprintf(s, "%04u/%02u/%02u %02u:%02u:%02u",
1224 pci -> date.year, pci -> date.month,
1225 pci -> date.day, pci -> time.hours, pci -> time.minutes,
1226 pci -> time.seconds);
1227 WinSetWindowText(hwndDate, s);
1228 WinSetWindowText(hwndAttr, pci -> pszDispAttr);
1229 }
[280]1230 if (dcd -> amextracted && hwndStatus2 && !fStatus2Used)
1231 WinSetWindowText(hwndStatus2, GetPString(IDS_INSEEKSCANTEXT)); // Say working
[194]1232 }
[444]1233 else {
[194]1234 if (hwndStatus2)
1235 WinSetWindowText(hwndStatus2, NullStr);
[444]1236 if (fMoreButtons) {
[194]1237 WinSetWindowText(hwndName, NullStr);
1238 WinSetWindowText(hwndDate, NullStr);
1239 WinSetWindowText(hwndAttr, NullStr);
1240 }
1241 }
[2]1242 }
[194]1243 }
1244 return 0;
[2]1245
[194]1246 case UM_CONTAINER_FILLED:
[471]1247 DosBeep(1000, 50); // Wake up user?
[194]1248 WinSendMsg(hwnd,
1249 CM_INVALIDATERECORD,
1250 MPVOID,
1251 MPFROM2SHORT(0, CMA_ERASE | CMA_REPOSITION));
[471]1252 disable_menuitem(WinWindowFromID(WinQueryWindow(hwndMain, QW_PARENT),
1253 FID_MENU),
1254 IDM_GREP,
1255 FALSE);
1256 PostMsg(hwnd,UM_RESCAN,MPVOID,MPVOID);
[444]1257 if (dcd) {
[194]1258 dcd -> stopflag = 0;
[471]1259 dcd -> amextracted = FALSE; // Say not busy
[444]1260 if (dcd -> namecanchange) {
[471]1261 if (!PostMsg(hwnd,WM_CLOSE,MPVOID,MPVOID))
1262 WinSendMsg(hwnd,WM_CLOSE,MPVOID,MPVOID);
[2]1263 }
[194]1264 else
1265 WinSetWindowPos(WinQueryWindow(WinQueryWindow(hwnd, QW_PARENT),
1266 QW_PARENT),
1267 HWND_TOP,
1268 0,
1269 0,
1270 0,
1271 0,
1272 SWP_SHOW | SWP_RESTORE | SWP_ZORDER);
1273 }
1274 return 0;
[2]1275
[194]1276 case UM_SETUP:
[444]1277 if (dcd) {
1278 if (!dcd -> hwndObject) {
[471]1279 /* first time through -- set things up */
[2]1280
[194]1281 CNRINFO cnri;
[2]1282
[194]1283 RestorePresParams(hwnd, "Collector");
1284 LoadDetailsSwitches("Collector", dcd);
[471]1285
1286 dcd -> amextracted = FALSE; // Say not busy
[194]1287 dcd -> stopflag = 0;
1288 memset(&cnri, 0, sizeof(CNRINFO));
1289 cnri.cb = sizeof(CNRINFO);
1290 WinSendMsg(hwnd, CM_QUERYCNRINFO, MPFROMP(&cnri),
1291 MPFROMLONG(sizeof(CNRINFO)));
1292 cnri.cyLineSpacing = 0;
1293 cnri.cxTreeIndent = 12L;
[2]1294
[194]1295 cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT |
1296 CV_DETAIL));
1297 cnri.flWindowAttr |= (CV_NAME | CA_DETAILSVIEWTITLES |
1298 CV_MINI | CV_FLOW);
1299 cnri.pSortRecord = (PVOID) SortCollectorCnr;
[2]1300
[444]1301 size = sizeof(ULONG);
1302 PrfQueryProfileData(fmprof, appname, "CollectorflWindowAttr",
1303 (PVOID) & cnri.flWindowAttr, &size);
1304 size = sizeof(MASK);
1305 if (PrfQueryProfileSize(fmprof, appname, "CollectorFilter", &size) &&
1306 size)
[194]1307 {
[444]1308 PrfQueryProfileData(fmprof, appname, "CollectorFilter", &dcd -> mask,
1309 &size);
1310 SetMask(NULL, &dcd -> mask);
[194]1311 }
[444]1312 else {
1313 dcd -> mask.attrFile = (FILE_NORMAL | FILE_READONLY |
1314 FILE_DIRECTORY | FILE_HIDDEN |
1315 FILE_SYSTEM | FILE_ARCHIVED);
1316 dcd -> mask.antiattr = 0;
1317 }
1318
1319 *(dcd -> mask.prompt) = 0;
1320
[194]1321 cnri.flWindowAttr |= CV_FLOW;
1322 cnri.flWindowAttr &= (~(CA_MIXEDTARGETEMPH | CA_ORDEREDTARGETEMPH));
1323 dcd -> flWindowAttr = cnri.flWindowAttr;
1324 WinSendMsg(hwnd, CM_SETCNRINFO, MPFROMP(&cnri),
1325 MPFROMLONG(CMA_FLWINDOWATTR | CMA_LINESPACING |
1326 CMA_CXTREEINDENT | CMA_PSORTRECORD));
1327 SetCnrCols(hwnd, FALSE);
1328 AdjustCnrColsForPref(hwnd, NULL, dcd, FALSE);
[2]1329
[197]1330 /* fix splitbar for collector container */
1331 cnri.xVertSplitbar = DIR_SPLITBAR_OFFSET - 32;
1332 size = sizeof(LONG);
1333 PrfQueryProfileData(fmprof, appname, "CollectorCnrSplitBar",
1334 &cnri.xVertSplitbar, &size);
1335 if (cnri.xVertSplitbar <= 0)
[194]1336 cnri.xVertSplitbar = DIR_SPLITBAR_OFFSET - 32;
[197]1337 WinSendMsg(hwnd, CM_SETCNRINFO, MPFROMP(&cnri),
1338 MPFROMLONG(CMA_XVERTSPLITBAR));
1339
[444]1340 if (_beginthread(MakeObjWin, NULL, 245760, (PVOID) dcd) == -1) {
1341 Runtime_Error(pszSrcFile, __LINE__, GetPString(IDS_COULDNTSTARTTHREADTEXT));
[194]1342 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
1343 return 0;
1344 }
1345 else
1346 DosSleep(64L);
[2]1347 }
[194]1348 SayFilter(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
1349 DIR_FILTER), &dcd -> mask, FALSE);
1350 SaySort(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
1351 DIR_SORT), CollectorsortFlags, FALSE);
1352 SayView(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
1353 DIR_VIEW), dcd -> flWindowAttr);
1354 }
[444]1355 else {
[194]1356 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
[2]1357 return 0;
[194]1358 }
1359 return 0;
[2]1360
[194]1361 case WM_MENUEND:
[444]1362 if (dcd) {
[403]1363 HWND hwndMenu = (HWND)mp2;
[2]1364
[194]1365 if (hwndMenu == CollectorCnrMenu || hwndMenu == CollectorFileMenu ||
1366 hwndMenu == CollectorDirMenu)
1367 {
1368 MarkAll(hwnd, TRUE, FALSE, TRUE);
[444]1369 if (dcd -> cnremphasized) {
[194]1370 WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPVOID,
1371 MPFROM2SHORT(FALSE, CRA_SOURCE));
1372 dcd -> cnremphasized = FALSE;
1373 }
[2]1374 }
[194]1375 }
1376 break;
[2]1377
[194]1378 case UM_OPENWINDOWFORME:
[444]1379 if (dcd) {
[194]1380 if (mp1 &&
1381 !IsFile((CHAR *) mp1))
[471]1382 OpenDirCnr(HWND_DESKTOP,hwndMain,dcd -> hwndFrame,FALSE,(PSZ)mp1);
1383 else if (mp1 && IsFile(mp1) == 1)
[194]1384 StartArcCnr(HWND_DESKTOP,
1385 dcd -> hwndFrame,
1386 (CHAR *) mp1,
1387 4,
1388 (ARC_TYPE *) mp2);
1389 }
1390 return 0;
[2]1391
[194]1392 case MM_PORTHOLEINIT:
[444]1393 if (dcd) {
1394 switch (SHORT1FROMMP(mp1)) {
[194]1395 case 0:
1396 case 1:
1397 {
1398 ULONG wmsg;
[2]1399
[194]1400 wmsg = (SHORT1FROMMP(mp1) == 0) ? UM_FILESMENU : UM_VIEWSMENU;
[403]1401 PortholeInit((HWND)WinSendMsg(dcd -> hwndClient, wmsg, MPVOID,
[194]1402 MPVOID), mp1, mp2);
1403 }
1404 break;
[2]1405 }
[194]1406 }
1407 break;
[2]1408
[194]1409 case UM_INITMENU:
1410 case WM_INITMENU:
[444]1411 if (dcd) {
1412 switch (SHORT1FROMMP(mp1)) {
[194]1413 case IDM_VIEWSMENU:
[403]1414 SetViewMenu((HWND)mp2, dcd -> flWindowAttr);
1415 WinEnableMenuItem((HWND)mp2, IDM_RESELECT,
[194]1416 (dcd -> lastselection != NULL));
1417 break;
[2]1418
[194]1419 case IDM_DETAILSSETUP:
[403]1420 SetDetailsSwitches((HWND)mp2, dcd);
[194]1421 break;
[2]1422
[194]1423 case IDM_COMMANDSMENU:
[403]1424 SetupCommandMenu((HWND)mp2, hwnd);
[194]1425 break;
[2]1426
[194]1427 case IDM_SORTSUBMENU:
[403]1428 SetSortChecks((HWND)mp2, CollectorsortFlags);
[194]1429 break;
[2]1430 }
[403]1431 dcd -> hwndLastMenu = (HWND)mp2;
[194]1432 }
1433 if (msg == WM_INITMENU)
1434 break;
1435 return 0;
[2]1436
[194]1437 case UM_COLLECTFROMFILE:
[444]1438 if (mp1) {
1439 if (!dcd) {
1440 free(mp1);
1441 Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
1442 }
1443 else {
1444 if (!PostMsg(dcd -> hwndObject, UM_COLLECTFROMFILE, mp1, mp2)) {
1445 Runtime_Error(pszSrcFile, __LINE__, "PostMsg");
[194]1446 free(mp1);
1447 }
[2]1448 }
[194]1449 }
1450 return 0;
[2]1451
[194]1452 case UM_COMMAND:
[444]1453 if (mp1) {
1454 if (dcd) {
1455 if (!PostMsg(dcd -> hwndObject, UM_COMMAND, mp1, mp2)) {
1456 Runtime_Error(pszSrcFile, __LINE__, "PostMsg");
[194]1457 FreeListInfo((LISTINFO *) mp1);
1458 }
1459 else
1460 return (MRESULT) TRUE;
[2]1461 }
[194]1462 else
1463 FreeListInfo((LISTINFO *) mp1);
1464 }
1465 return 0;
[2]1466
[194]1467 case UM_NOTIFY:
1468 if (mp2)
1469 AddNote((CHAR *) mp2);
1470 return 0;
[2]1471
[194]1472 case WM_COMMAND:
1473 DosError(FERR_DISABLEHARDERR);
[444]1474 if (dcd) {
1475 switch (SHORT1FROMMP(mp1)) {
[194]1476 case IDM_SETTARGET:
1477 SetTargetDir(hwnd, FALSE);
1478 break;
[2]1479
[194]1480 case IDM_CONTEXTMENU:
1481 {
1482 PCNRITEM pci;
[2]1483
[194]1484 pci = (PCNRITEM) CurrentRecord(hwnd);
1485 PostMsg(hwnd, WM_CONTROL, MPFROM2SHORT(COLLECTOR_CNR,
1486 CN_CONTEXTMENU), MPFROMP(pci));
1487 }
1488 break;
[2]1489
[194]1490 case IDM_SHOWALLFILES:
1491 {
1492 PCNRITEM pci;
[2]1493
[471]1494 pci = WinSendMsg(hwnd,
1495 CM_QUERYRECORDEMPHASIS,
[194]1496 MPFROMLONG(CMA_FIRST),
1497 MPFROMSHORT(CRA_CURSORED));
[444]1498 if (pci && (INT) pci != -1) {
[194]1499 static CHAR dirname[CCHMAXPATH];
[2]1500
[194]1501 strcpy(dirname, pci -> szFileName);
1502 MakeValidDir(dirname);
1503 StartSeeAll(HWND_DESKTOP, FALSE, dirname);
1504 }
1505 }
1506 break;
[2]1507
[194]1508 case IDM_BEGINEDIT:
1509 OpenEdit(hwnd);
1510 break;
[2]1511
[194]1512 case IDM_ENDEDIT:
1513 WinSendMsg(hwnd, CM_CLOSEEDIT, MPVOID, MPVOID);
1514 break;
[2]1515
[194]1516 case IDM_SHOWSELECT:
1517 QuickPopup(hwnd, dcd, CheckMenu(&CollectorCnrMenu, COLLECTORCNR_POPUP),
1518 IDM_SELECTSUBMENU);
1519 break;
[2]1520
[194]1521 case IDM_SHOWSORT:
1522 QuickPopup(hwnd, dcd, CheckMenu(&CollectorCnrMenu, COLLECTORCNR_POPUP),
1523 IDM_SORTSUBMENU);
1524 break;
[2]1525
[194]1526 case IDM_VIEWORARC:
1527 {
1528 SWP swp;
1529 PCNRITEM pci;
[2]1530
[194]1531 pci = (PCNRITEM) WinSendMsg(hwnd, CM_QUERYRECORDEMPHASIS,
1532 MPFROMLONG(CMA_FIRST),
1533 MPFROMSHORT(CRA_CURSORED));
[444]1534 if (pci && (INT) pci != -1) {
[194]1535 WinQueryWindowPos(dcd -> hwndFrame, &swp);
1536 DefaultViewKeys(hwnd, dcd -> hwndFrame, dcd -> hwndParent, &swp,
1537 pci -> szFileName);
1538 }
1539 }
1540 break;
[2]1541
[194]1542 case IDM_SEEALL:
[471]1543 StartSeeAll(HWND_DESKTOP,FALSE,NULL);
[194]1544 break;
[2]1545
[194]1546 case IDM_COLLECTSELECT:
1547 {
1548 CHAR filename[CCHMAXPATH], *p, *pp;
[2]1549
[194]1550 strcpy(filename, "*.LST");
1551 size = CCHMAXPATH;
1552 PrfQueryProfileData(fmprof, appname, "SaveToListName",
1553 filename, &size);
1554 pp = strrchr(filename, '\\');
1555 if (!pp)
1556 pp = filename;
1557 p = strrchr(pp, '.');
[444]1558 if (p && *(p + 1) && p > pp + 1) {
[194]1559 if (pp > filename)
1560 pp++;
1561 *pp = '*';
1562 pp++;
1563 if (p > pp)
1564 memmove(pp, p, strlen(p) + 1);
1565 }
[444]1566 if (insert_filename(hwnd, filename, FALSE, FALSE)) {
[352]1567 p = xstrdup(filename,pszSrcFile,__LINE__);
[444]1568 if (p) {
[194]1569 if (!PostMsg(hwnd, UM_COLLECTFROMFILE, MPFROMP(p), MPVOID))
1570 free(p);
1571 }
1572 }
1573 }
1574 break;
[2]1575
[194]1576 case IDM_NOTEBOOK:
1577 if (!ParentIsDesktop(dcd -> hwndParent, dcd -> hwndParent))
1578 PostMsg(dcd -> hwndParent, msg, mp1, mp2);
1579 else
1580 WinDlgBox(HWND_DESKTOP, hwnd, CfgDlgProc, FM3ModHandle,
1581 CFG_FRAME, (PVOID) "Collector");
1582 break;
[2]1583
[194]1584 case IDM_RESELECT:
1585 SelectList(hwnd, FALSE, FALSE, FALSE, NULL, NULL, dcd -> lastselection);
1586 break;
[2]1587
[194]1588 case IDM_HELP:
1589 if (hwndHelp)
1590 WinSendMsg(hwndHelp, HM_DISPLAY_HELP,
1591 MPFROM2SHORT(HELP_COLLECT, 0),
1592 MPFROMSHORT(HM_RESOURCEID));
1593 break;
[2]1594
[194]1595 case IDM_SORTNONE:
1596 case IDM_SORTSMARTNAME:
1597 case IDM_SORTNAME:
1598 case IDM_SORTFILENAME:
1599 case IDM_SORTSIZE:
1600 case IDM_SORTEASIZE:
1601 case IDM_SORTFIRST:
1602 case IDM_SORTLAST:
1603 case IDM_SORTLWDATE:
1604 case IDM_SORTLADATE:
1605 case IDM_SORTCRDATE:
1606 case IDM_SORTSUBJECT:
[197]1607 savedSortFlags = CollectorsortFlags;
[194]1608 CollectorsortFlags &= (SORT_REVERSE | SORT_DIRSFIRST | SORT_DIRSLAST);
1609 case IDM_SORTDIRSFIRST:
1610 case IDM_SORTDIRSLAST:
1611 case IDM_SORTREVERSE:
[444]1612 switch (SHORT1FROMMP(mp1)) {
[194]1613 case IDM_SORTSUBJECT:
1614 CollectorsortFlags |= SORT_SUBJECT;
1615 break;
1616 case IDM_SORTNONE:
1617 CollectorsortFlags |= SORT_NOSORT;
1618 break;
1619 case IDM_SORTSMARTNAME:
[197]1620 if (~savedSortFlags & SORT_FILENAME)
[194]1621 CollectorsortFlags |= SORT_FILENAME;
1622 break;
1623 case IDM_SORTFILENAME:
1624 CollectorsortFlags |= SORT_FILENAME;
1625 break;
1626 case IDM_SORTSIZE:
1627 CollectorsortFlags |= SORT_SIZE;
1628 break;
1629 case IDM_SORTEASIZE:
1630 CollectorsortFlags |= SORT_EASIZE;
1631 break;
1632 case IDM_SORTFIRST:
1633 CollectorsortFlags |= SORT_FIRSTEXTENSION;
1634 break;
1635 case IDM_SORTLAST:
1636 CollectorsortFlags |= SORT_LASTEXTENSION;
1637 break;
1638 case IDM_SORTLWDATE:
1639 CollectorsortFlags |= SORT_LWDATE;
1640 break;
1641 case IDM_SORTLADATE:
1642 CollectorsortFlags |= SORT_LADATE;
1643 break;
1644 case IDM_SORTCRDATE:
1645 CollectorsortFlags |= SORT_CRDATE;
1646 break;
1647 case IDM_SORTDIRSFIRST:
1648 if (CollectorsortFlags & SORT_DIRSFIRST)
1649 CollectorsortFlags &= (~SORT_DIRSFIRST);
[444]1650 else {
[194]1651 CollectorsortFlags |= SORT_DIRSFIRST;
1652 CollectorsortFlags &= (~SORT_DIRSLAST);
1653 }
1654 break;
1655 case IDM_SORTDIRSLAST:
1656 if (CollectorsortFlags & SORT_DIRSLAST)
1657 CollectorsortFlags &= (~SORT_DIRSLAST);
[444]1658 else {
[194]1659 CollectorsortFlags |= SORT_DIRSLAST;
1660 CollectorsortFlags &= (~SORT_DIRSFIRST);
1661 }
1662 break;
1663 case IDM_SORTREVERSE:
1664 if (CollectorsortFlags & SORT_REVERSE)
1665 CollectorsortFlags &= (~SORT_REVERSE);
1666 else
1667 CollectorsortFlags |= SORT_REVERSE;
1668 break;
1669 }
1670 PrfWriteProfileData(fmprof, appname, "CollectorSort",
1671 &CollectorsortFlags, sizeof(INT));
1672 WinSendMsg(hwnd, CM_SORTRECORD, MPFROMP(SortCollectorCnr), MPVOID);
1673 SaySort(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
1674 DIR_SORT), CollectorsortFlags, FALSE);
1675 break;
[2]1676
[194]1677 case IDM_COLLECTFROMCLIP:
1678 {
1679 LISTINFO *li;
[2]1680
[352]1681 li = xmallocz(sizeof(LISTINFO),pszSrcFile,__LINE__);
[444]1682 if (li) {
[194]1683 li -> list = ListFromClipboard(hwnd);
1684 if (!li -> list || !li -> list[0])
1685 FreeListInfo(li);
[444]1686 else {
[194]1687 li -> type = IDM_COLLECT;
[471]1688 if (!PostMsg(dcd -> hwndObject, UM_COLLECT, MPFROMP(li),MPVOID))
[194]1689 FreeListInfo(li);
1690 }
1691 }
1692 }
1693 break;
[2]1694
[194]1695 case IDM_REMOVE:
1696 if (fAutoView &&
1697 hwndMain)
[471]1698 PostMsg(hwndMain,UM_LOADFILE,MPVOID,MPVOID);
[194]1699 dcd -> suspendview = 1;
[471]1700 RemoveAll(hwnd,&dcd -> ullTotalBytes,&dcd -> totalfiles);
[194]1701 dcd -> suspendview = 0;
[471]1702 PostMsg(hwnd,UM_RESCAN,MPVOID,MPVOID);
[194]1703 break;
[2]1704
[194]1705 case IDM_CLEARCNR:
1706 {
1707 PCNRITEM pci;
[2]1708
[194]1709 pci = (PCNRITEM) WinSendMsg(hwnd,
1710 CM_QUERYRECORD,
1711 MPVOID,
[471]1712 MPFROM2SHORT(CMA_FIRST,CMA_ITEMORDER));
[444]1713 if (pci && (INT) pci != -1) {
[194]1714 WinSendMsg(hwnd,
1715 CM_REMOVERECORD,
1716 MPVOID,
1717 MPFROM2SHORT(0, CMA_FREE | CMA_INVALIDATE));
1718 dcd -> ullTotalBytes = dcd -> selectedbytes = dcd -> selectedfiles =
1719 dcd -> totalfiles = 0L;
[471]1720 PostMsg(hwnd,UM_RESCAN,MPVOID,MPVOID);
[194]1721 }
1722 }
1723 break;
[2]1724
[194]1725 case DID_CANCEL:
1726 if (dcd -> amextracted)
[280]1727 dcd -> stopflag = 1; // Request cancel
[194]1728 break;
[2]1729
[194]1730 case IDM_COLLECTOR:
[444]1731 if (mp2) {
[194]1732 LISTINFO *li;
[2]1733
[352]1734 li = xmallocz(sizeof(LISTINFO),pszSrcFile,__LINE__);
[444]1735 if (li) {
[194]1736 li -> list = mp2;
1737 if (!li -> list || !li -> list[0])
1738 FreeListInfo(li);
[444]1739 else {
[194]1740 li -> type = IDM_COLLECT;
[471]1741 if (!PostMsg(dcd -> hwndObject, UM_COLLECT, MPFROMP(li),MPVOID))
[194]1742 FreeListInfo(li);
1743 }
1744 }
1745 else
1746 FreeList(mp2);
1747 }
1748 break;
[2]1749
[194]1750 case IDM_UNDELETE:
1751 {
1752 PCNRITEM pci;
1753 CHAR path[CCHMAXPATH];
[2]1754
[194]1755 pci = (PCNRITEM) CurrentRecord(hwnd);
[444]1756 if (pci) {
[194]1757 strcpy(path, pci -> szFileName);
1758 MakeValidDir(path);
1759 WinDlgBox(HWND_DESKTOP, hwnd, UndeleteDlgProc, FM3ModHandle,
1760 UNDEL_FRAME, MPFROMP(path));
1761 }
1762 }
1763 break;
[2]1764
[194]1765 case IDM_GREP:
[471]1766 if (dcd -> amextracted)
[444]1767 Runtime_Error(pszSrcFile, __LINE__, "busy");
1768 else {
[194]1769 if (WinDlgBox(HWND_DESKTOP, hwnd, GrepDlgProc,
1770 FM3ModHandle, GREP_FRAME, (PVOID) & hwnd))
1771 {
[471]1772 dcd -> amextracted = TRUE; // Say busy scanning
1773 disable_menuitem(WinWindowFromID(WinQueryWindow(hwndMain, QW_PARENT),
1774 FID_MENU),
1775 IDM_GREP,
1776 TRUE);
[194]1777 PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
1778 }
1779 }
1780 break;
[2]1781
[194]1782 case IDM_RESORT:
1783 WinSendMsg(hwnd, CM_SORTRECORD, MPFROMP(SortCollectorCnr), MPVOID);
1784 break;
[2]1785
[194]1786 case IDM_FILTER:
1787 {
1788 BOOL empty = FALSE;
1789 PCNRITEM pci;
1790 CHAR *p;
[2]1791
[444]1792 if (!*dcd -> mask.szMask) {
[194]1793 empty = TRUE;
1794 pci = (PCNRITEM) CurrentRecord(hwnd);
[444]1795 if (pci && !(pci -> attrFile & FILE_DIRECTORY)) {
[194]1796 p = strrchr(pci -> szFileName, '\\');
[444]1797 if (p) {
[194]1798 p++;
1799 strcpy(dcd -> mask.szMask, p);
1800 }
1801 }
1802 }
1803 *(dcd -> mask.prompt) = 0;
[2]1804
[194]1805 if (WinDlgBox(HWND_DESKTOP, hwnd, PickMaskDlgProc,
1806 FM3ModHandle, MSK_FRAME, MPFROMP(&dcd -> mask)))
1807 {
[197]1808 size = sizeof(MASK);
1809 PrfWriteProfileData(fmprof, appname, "CollectorFilter",
[444]1810 &dcd -> mask, size);
[194]1811 dcd -> suspendview = 1;
1812 WinSendMsg(hwnd, CM_FILTER, MPFROMP(Filter), MPFROMP(&dcd -> mask));
1813 dcd -> suspendview = 0;
[444]1814 if (fAutoView && hwndMain) {
[194]1815 pci = WinSendMsg(hwnd, CM_QUERYRECORDEMPHASIS,
1816 MPFROMLONG(CMA_FIRST),
1817 MPFROMSHORT(CRA_CURSORED));
1818 if (pci && (INT) pci != -1 &&
1819 (!(driveflags[toupper(*pci -> szFileName) - 'A'] & DRIVE_SLOW)))
1820 WinSendMsg(hwndMain, UM_LOADFILE, MPFROMP(pci -> szFileName),
1821 MPVOID);
1822 else
1823 WinSendMsg(hwndMain, UM_LOADFILE, MPVOID, MPVOID);
1824 }
1825 PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
1826 }
1827 else if (empty)
1828 *dcd -> mask.szMask = 0;
1829 SayFilter(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
1830 DIR_FILTER), &dcd -> mask, FALSE);
1831 }
1832 break;
[2]1833
[194]1834 case IDM_HIDEALL:
1835 if (fAutoView && hwndMain)
1836 PostMsg(hwndMain, UM_LOADFILE, MPVOID, MPVOID);
1837 dcd -> suspendview = 1;
1838 HideAll(hwnd);
1839 dcd -> suspendview = 0;
1840 PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
1841 break;
[2]1842
[194]1843 case IDM_SELECTLIST:
1844 case IDM_SELECTALL:
1845 case IDM_DESELECTALL:
1846 case IDM_SELECTALLFILES:
1847 case IDM_DESELECTALLFILES:
1848 case IDM_SELECTALLDIRS:
1849 case IDM_DESELECTALLDIRS:
1850 case IDM_SELECTMASK:
1851 case IDM_DESELECTMASK:
1852 case IDM_INVERT:
1853 case IDM_SELECTCLIP:
1854 case IDM_DESELECTCLIP:
1855 {
1856 PCNRITEM pci;
[2]1857
[194]1858 pci = (PCNRITEM) CurrentRecord(hwnd);
1859 if ((INT) pci == -1)
1860 pci = NULL;
[444]1861 if (SHORT1FROMMP(mp1) == IDM_HIDEALL) {
1862 if (pci) {
[194]1863 if (!(pci -> rc.flRecordAttr & CRA_SELECTED))
1864 pci -> rc.flRecordAttr |= CRA_FILTERED;
1865 WinSendMsg(hwnd, CM_INVALIDATERECORD, MPFROMP(&pci),
1866 MPFROM2SHORT(1, CMA_ERASE | CMA_REPOSITION));
1867 break;
1868 }
1869 }
1870 PostMsg(dcd -> hwndObject, UM_SELECT, mp1, MPFROMP(pci));
1871 }
1872 break;
[2]1873
[194]1874 case IDM_RESCAN:
1875 PostMsg(dcd -> hwndObject, UM_RESCAN, MPVOID, MPVOID);
1876 break;
[2]1877
[194]1878 case IDM_SHOWLNAMES:
1879 case IDM_SHOWSUBJECT:
1880 case IDM_SHOWEAS:
1881 case IDM_SHOWSIZE:
1882 case IDM_SHOWICON:
1883 case IDM_SHOWLWDATE:
1884 case IDM_SHOWLWTIME:
1885 case IDM_SHOWLADATE:
1886 case IDM_SHOWLATIME:
1887 case IDM_SHOWCRDATE:
1888 case IDM_SHOWCRTIME:
1889 case IDM_SHOWATTR:
1890 AdjustDetailsSwitches(hwnd, dcd -> hwndLastMenu,
1891 SHORT1FROMMP(mp1), NULL,
1892 "Collector", dcd, FALSE);
1893 break;
[2]1894
[194]1895 case IDM_ICON:
1896 case IDM_TEXT:
1897 case IDM_DETAILS:
1898 case IDM_NAME:
1899 case IDM_MINIICONS:
1900 case IDM_DETAILSTITLES:
1901 {
1902 CNRINFO cnri;
[2]1903
[194]1904 memset(&cnri, 0, sizeof(CNRINFO));
1905 cnri.cb = sizeof(CNRINFO);
1906 WinSendMsg(hwnd, CM_QUERYCNRINFO, MPFROMP(&cnri),
1907 MPFROMLONG(sizeof(CNRINFO)));
[444]1908 switch (SHORT1FROMMP(mp1)) {
[194]1909 case IDM_ICON:
1910 cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT |
1911 CV_DETAIL | CV_NAME));
1912 cnri.flWindowAttr |= CV_ICON;
1913 break;
1914 case IDM_NAME:
1915 cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT |
1916 CV_DETAIL | CV_NAME));
1917 cnri.flWindowAttr |= CV_NAME;
1918 break;
1919 case IDM_TEXT:
1920 cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT |
1921 CV_DETAIL | CV_NAME));
1922 cnri.flWindowAttr |= CV_TEXT;
1923 break;
1924 case IDM_DETAILS:
1925 cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT |
1926 CV_DETAIL | CV_NAME));
1927 cnri.flWindowAttr |= CV_DETAIL;
1928 break;
1929 case IDM_MINIICONS:
1930 if (cnri.flWindowAttr & CV_MINI)
1931 cnri.flWindowAttr &= (~CV_MINI);
1932 else
1933 cnri.flWindowAttr |= CV_MINI;
1934 break;
1935 case IDM_DETAILSTITLES:
1936 if (cnri.flWindowAttr & CA_DETAILSVIEWTITLES)
1937 cnri.flWindowAttr &= (~CA_DETAILSVIEWTITLES);
1938 else
1939 cnri.flWindowAttr |= CA_DETAILSVIEWTITLES;
1940 break;
1941 }
1942 cnri.flWindowAttr &= (~(CA_ORDEREDTARGETEMPH |
1943 CA_MIXEDTARGETEMPH));
1944 cnri.flWindowAttr |= CV_FLOW;
1945 dcd -> flWindowAttr = cnri.flWindowAttr;
1946 PrfWriteProfileData(fmprof, appname, "CollectorflWindowAttr",
1947 &cnri.flWindowAttr, sizeof(ULONG));
1948 WinSendMsg(hwnd, CM_SETCNRINFO, MPFROMP(&cnri),
1949 MPFROMLONG(CMA_FLWINDOWATTR));
1950 WinSendMsg(hwnd, CM_INVALIDATERECORD, MPVOID,
1951 MPFROM2SHORT(0, CMA_ERASE | CMA_REPOSITION));
1952 SayView(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
1953 DIR_VIEW), dcd -> flWindowAttr);
1954 }
1955 break;
[2]1956
[194]1957 case IDM_SAVETOLIST:
1958 WinDlgBox(HWND_DESKTOP, hwnd, SaveListDlgProc, FM3ModHandle,
1959 SAV_FRAME, MPFROMP(&hwnd));
1960 break;
[2]1961
[194]1962 case IDM_SIZES:
1963 {
1964 PCNRITEM pci;
[2]1965
[194]1966 pci = (PCNRITEM) CurrentRecord(hwnd);
1967 if (pci && (INT) pci != -1)
1968 WinDlgBox(HWND_DESKTOP, HWND_DESKTOP, DirSizeProc, FM3ModHandle,
1969 DSZ_FRAME, pci -> szFileName);
1970 }
1971 break;
[2]1972
[194]1973 case IDM_MKDIR:
1974 {
1975 PCNRITEM pci;
[2]1976
[194]1977 pci = (PCNRITEM) CurrentRecord(hwnd);
1978 PMMkDir(dcd -> hwndParent, (pci && (INT) pci != -1) ?
1979 pci -> szFileName : NULL, FALSE);
1980 }
1981 break;
[2]1982
[194]1983 case IDM_DOITYOURSELF:
1984 case IDM_UPDATE:
1985 case IDM_COLLECTFROMFILE:
1986 case IDM_OPENWINDOW:
1987 case IDM_OPENSETTINGS:
1988 case IDM_OPENDEFAULT:
1989 case IDM_OPENICON:
1990 case IDM_OPENDETAILS:
1991 case IDM_OPENTREE:
1992 case IDM_OBJECT:
1993 case IDM_SHADOW:
1994 case IDM_SHADOW2:
1995 case IDM_DELETE:
1996 case IDM_PERMDELETE:
1997 case IDM_PRINT:
1998 case IDM_ATTRS:
1999 case IDM_INFO:
2000 case IDM_COPY:
2001 case IDM_MOVE:
2002 case IDM_WPSCOPY:
2003 case IDM_WPSMOVE:
2004 case IDM_COPYPRESERVE:
2005 case IDM_MOVEPRESERVE:
2006 case IDM_WILDCOPY:
2007 case IDM_WILDMOVE:
2008 case IDM_RENAME:
2009 case IDM_COMPARE:
2010 case IDM_EAS:
2011 case IDM_SUBJECT:
2012 case IDM_VIEW:
2013 case IDM_VIEWTEXT:
2014 case IDM_VIEWBINARY:
2015 case IDM_VIEWARCHIVE:
2016 case IDM_EDIT:
2017 case IDM_EDITTEXT:
2018 case IDM_EDITBINARY:
2019 case IDM_SAVETOCLIP:
2020 case IDM_APPENDTOCLIP:
2021 case IDM_ARCHIVE:
2022 case IDM_ARCHIVEM:
2023 case IDM_EXTRACT:
2024 case IDM_MCIPLAY:
2025 case IDM_UUDECODE:
2026 case IDM_MERGE:
2027 {
2028 LISTINFO *li;
2029 ULONG action = UM_ACTION;
[2]2030
[352]2031 li = xmallocz(sizeof(LISTINFO),pszSrcFile,__LINE__);
[444]2032 if (li) {
[194]2033 li -> type = SHORT1FROMMP(mp1);
2034 li -> hwnd = hwnd;
2035 li -> list = BuildList(hwnd);
[444]2036 if (li -> list) {
2037 switch (SHORT1FROMMP(mp1)) {
[194]2038 case IDM_DOITYOURSELF:
2039 case IDM_APPENDTOCLIP:
2040 case IDM_SAVETOCLIP:
2041 case IDM_ARCHIVE:
2042 case IDM_ARCHIVEM:
2043 case IDM_DELETE:
2044 case IDM_PERMDELETE:
2045 case IDM_ATTRS:
2046 case IDM_PRINT:
2047 case IDM_SHADOW:
2048 case IDM_SHADOW2:
2049 case IDM_OBJECT:
2050 case IDM_VIEW:
2051 case IDM_VIEWTEXT:
2052 case IDM_VIEWBINARY:
2053 case IDM_EDIT:
2054 case IDM_EDITTEXT:
2055 case IDM_EDITBINARY:
2056 case IDM_MCIPLAY:
2057 case IDM_UPDATE:
2058 case IDM_INFO:
2059 case IDM_EAS:
2060 action = UM_MASSACTION;
2061 break;
2062 }
2063 if (li -> type == IDM_SHADOW || li -> type == IDM_OBJECT ||
2064 li -> type == IDM_SHADOW2)
2065 *li -> targetpath = 0;
[471]2066 if (!PostMsg(dcd -> hwndObject, action, MPFROMP(li),MPVOID))
[194]2067 {
[444]2068 Runtime_Error(pszSrcFile, __LINE__, "PostMsg");
[194]2069 FreeListInfo(li);
2070 }
2071 else if (fUnHilite)
2072 UnHilite(hwnd, TRUE, &dcd -> lastselection);
2073 }
2074 else
2075 free(li);
2076 }
2077 }
2078 break;
[2]2079
[194]2080 default:
2081 if (!cmdloaded)
2082 load_commands();
2083 if (SHORT1FROMMP(mp1) >= IDM_COMMANDSTART &&
2084 SHORT1FROMMP(mp1) < IDM_QUICKTOOLSTART)
2085 {
2086 INT x;
[2]2087
[194]2088 x = SHORT1FROMMP(mp1) - IDM_COMMANDSTART;
[444]2089 if (x >= 0) {
[194]2090 x++;
2091 RunCommand(hwnd, x);
2092 if (fUnHilite)
2093 UnHilite(hwnd, TRUE, &dcd -> lastselection);
2094 }
2095 }
2096 break;
2097 }
2098 }
2099 return 0;
[2]2100
[194]2101 case UM_FIXCNRMLE:
2102 case UM_FIXEDITNAME:
2103 return CommonCnrProc(hwnd, msg, mp1, mp2);
[2]2104
[194]2105 case UM_FILESMENU:
2106 {
2107 PCNRITEM pci;
[403]2108 HWND menuHwnd = (HWND)0;
[2]2109
[194]2110 pci = (PCNRITEM) CurrentRecord(hwnd);
[444]2111 if (pci && (INT) pci != -1) {
[194]2112 if (pci -> attrFile & FILE_DIRECTORY)
2113 menuHwnd = CheckMenu(&CollectorDirMenu, COLLECTORDIR_POPUP);
2114 else
2115 menuHwnd = CheckMenu(&CollectorFileMenu, COLLECTORFILE_POPUP);
[2]2116 }
[194]2117 return MRFROMLONG(menuHwnd);
2118 }
[2]2119
[194]2120 case WM_CONTROL:
2121 DosError(FERR_DISABLEHARDERR);
[444]2122 if (dcd) {
2123 switch (SHORT2FROMMP(mp1)) {
[194]2124 case CN_CONTEXTMENU:
2125 {
2126 PCNRITEM pci = (PCNRITEM) mp2;
[2]2127
[444]2128 if (pci) {
[194]2129 WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPFROMP(pci),
2130 MPFROM2SHORT(TRUE, CRA_CURSORED));
2131 MarkAll(hwnd, FALSE, FALSE, TRUE);
2132 if (pci -> attrFile & FILE_DIRECTORY)
2133 dcd -> hwndLastMenu = CheckMenu(&CollectorDirMenu,
2134 COLLECTORDIR_POPUP);
2135 else
2136 dcd -> hwndLastMenu = CheckMenu(&CollectorFileMenu,
2137 COLLECTORFILE_POPUP);
2138 }
[444]2139 else {
[194]2140 dcd -> hwndLastMenu = CheckMenu(&CollectorCnrMenu,
2141 COLLECTORCNR_POPUP);
[444]2142 if (dcd -> hwndLastMenu && !dcd -> cnremphasized) {
[194]2143 WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPVOID,
2144 MPFROM2SHORT(TRUE, CRA_SOURCE));
2145 dcd -> cnremphasized = TRUE;
2146 }
2147 }
[444]2148 if (dcd -> hwndLastMenu) {
2149 if (dcd -> hwndLastMenu == CollectorCnrMenu) {
[194]2150 SetViewMenu(dcd -> hwndLastMenu, dcd -> flWindowAttr);
2151 SetDetailsSwitches(dcd -> hwndLastMenu, dcd);
2152 if (dcd -> flWindowAttr & CV_MINI)
2153 WinCheckMenuItem(dcd -> hwndLastMenu, IDM_MINIICONS, TRUE);
[471]2154 disable_menuitem(dcd -> hwndLastMenu,DID_CANCEL,!dcd->amextracted);
2155 disable_menuitem(dcd -> hwndLastMenu,IDM_GREP,dcd->amextracted);
[194]2156 }
[444]2157 if (!PopupMenu(hwnd, hwnd, dcd -> hwndLastMenu)) {
2158 if (dcd -> cnremphasized) {
[194]2159 WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPVOID,
2160 MPFROM2SHORT(FALSE, CRA_SOURCE));
2161 dcd -> cnremphasized = TRUE;
2162 }
2163 MarkAll(hwnd, TRUE, FALSE, TRUE);
2164 }
2165 }
2166 }
2167 break;
[2]2168
[194]2169 case CN_DROPHELP:
[444]2170 if (mp2) {
[194]2171 PDRAGINFO pDInfo;
2172 PCNRITEM pci;
2173 ULONG numitems;
2174 USHORT usOperation;
[2]2175
[194]2176 pci = (PCNRITEM) ((PCNRDRAGINFO) mp2) -> pRecord;
2177 pDInfo = ((PCNRDRAGINFO) mp2) -> pDragInfo;
[444]2178 if (!DrgAccessDraginfo(pDInfo)) {
[352]2179 Win_Error(hwnd, hwnd, pszSrcFile, __LINE__,
[194]2180 "%s",
2181 GetPString(IDS_DROPERRORTEXT));
2182 break;
2183 }
2184 numitems = DrgQueryDragitemCount(pDInfo);
2185 usOperation = pDInfo -> usOperation;
2186 DrgDeleteDraginfoStrHandles(pDInfo);
2187 DrgFreeDraginfo(pDInfo);
2188 saymsg(MB_ENTER | MB_ICONASTERISK,
2189 hwnd,
2190 GetPString(IDS_DROPHELPHDRTEXT),
2191 GetPString(IDS_DROPHELPTEXT),
2192 numitems,
2193 &"s"[numitems == 1L],
2194 (pci) ? NullStr : GetPString(IDS_NOTEXT),
2195 (pci) ? NullStr : " ",
2196 (pci) ? pci -> szFileName : NullStr,
2197 (pci) ? " " : NullStr,
2198 GetPString((usOperation == DO_COPY) ?
2199 IDS_COPYTEXT :
2200 (usOperation == DO_LINK) ?
2201 IDS_LINKTEXT : IDS_MOVETEXT));
2202 }
2203 return 0;
[2]2204
[194]2205 case CN_DRAGLEAVE:
[444]2206 if (mp2) {
[194]2207 PDRAGINFO pDInfo;
[2]2208
[194]2209 pDInfo = ((PCNRDRAGINFO) mp2) -> pDragInfo;
2210 DrgAccessDraginfo(pDInfo); /* Access DRAGINFO */
[444]2211 DrgFreeDraginfo(pDInfo); /* Free DRAGINFO */
[194]2212 }
2213 return 0;
[2]2214
[194]2215 case CN_DRAGAFTER:
2216 case CN_DRAGOVER:
[444]2217 if (mp2) {
[194]2218 PDRAGITEM pDItem; /* Pointer to DRAGITEM */
2219 PDRAGINFO pDInfo; /* Pointer to DRAGINFO */
2220 PCNRITEM pci;
2221 USHORT uso;
[2]2222
[194]2223 pci = (PCNRITEM) ((PCNRDRAGINFO) mp2) -> pRecord;
[444]2224// if(SHORT1FROMMP(mp1) == CN_DRAGAFTER)
2225 // pci = NULL;
[194]2226 pDInfo = ((PCNRDRAGINFO) mp2) -> pDragInfo;
2227 DrgAccessDraginfo(pDInfo); /* Access DRAGINFO */
[444]2228 if (pci) {
2229 if (pci -> rc.flRecordAttr & CRA_SOURCE) {
[194]2230 DrgFreeDraginfo(pDInfo);
2231 return (MRFROM2SHORT(DOR_NODROP, 0));
2232 }
2233 uso = pDInfo -> usOperation;
2234 if (uso == DO_DEFAULT)
2235 uso = (fCopyDefault) ? DO_COPY : DO_MOVE;
[444]2236 if (!(pci -> attrFile & FILE_DIRECTORY)) {
[194]2237 if (uso != DO_LINK && uso != DO_MOVE &&
2238 uso != DO_COPY)
2239 {
2240 DrgFreeDraginfo(pDInfo);
2241 return MRFROM2SHORT(DOR_NODROP, 0);
2242 }
2243 if (uso != DO_LINK &&
2244 !(driveflags[toupper(*pci -> szFileName) - 'A'] &
2245 DRIVE_NOTWRITEABLE))
2246 {
2247 ARC_TYPE *info = NULL;
[2]2248
[194]2249 if (!fQuickArcFind &&
2250 !(driveflags[toupper(*pci -> szFileName) - 'A'] &
2251 DRIVE_SLOW))
2252 info = find_type(pci -> szFileName, NULL);
2253 else
2254 info = quick_find_type(pci -> szFileName, NULL);
2255 if (!info || ((uso == DO_MOVE && !info -> move) ||
2256 (uso == DO_COPY && !info -> create)))
2257 {
2258 DrgFreeDraginfo(pDInfo);
2259 return MRFROM2SHORT(DOR_NODROP, 0);
2260 }
2261 }
2262 }
2263 }
2264 pDItem = DrgQueryDragitemPtr(pDInfo, /* Access DRAGITEM */
2265 0); /* Index to DRAGITEM */
2266 if (DrgVerifyRMF(pDItem, /* Check valid rendering */
2267 DRM_OS2FILE, /* mechanisms and data */
2268 NULL))
2269 {
[444]2270 DrgFreeDraginfo(pDInfo); /* Free DRAGINFO */
2271 if (pci) {
[194]2272 if (driveflags[toupper(*pci -> szFileName) - 'A'] &
2273 DRIVE_NOTWRITEABLE)
2274 return MRFROM2SHORT(DOR_DROP, DO_LINK);
2275 if (toupper(*pci -> szFileName) < 'C')
2276 return MRFROM2SHORT(DOR_DROP, DO_COPY);
2277 return MRFROM2SHORT(DOR_DROP, /* Return okay to drop */
2278 ((fCopyDefault) ?
2279 DO_COPY :
2280 DO_MOVE));
2281 }
2282 else
2283 return MRFROM2SHORT(DOR_DROP, /* Return okay to drop */
2284 DO_COPY);
2285 }
[444]2286 DrgFreeDraginfo(pDInfo); /* Free DRAGINFO */
[194]2287 }
[444]2288 return (MRFROM2SHORT(DOR_NODROP, 0)); /* Drop not valid */
[2]2289
[194]2290 case CN_INITDRAG:
[444]2291 if (mp2) {
[194]2292 BOOL wasemphasized = FALSE;
2293 PCNRDRAGINIT pcd = (PCNRDRAGINIT) mp2;
2294 PCNRITEM pci;
[2]2295
[444]2296 if (pcd) {
[194]2297 pci = (PCNRITEM) pcd -> pRecord;
[444]2298 if (pci) {
[194]2299 if (pci -> rc.flRecordAttr & CRA_SELECTED)
2300 wasemphasized = TRUE;
2301 if (IsRoot(pci -> szFileName))
2302 break;
2303 if (hwndStatus2)
[471]2304 WinSetWindowText(hwndStatus2,GetPString(IDS_DRAGFILEOBJTEXT));
2305 if (DoFileDrag(hwnd,dcd -> hwndObject,mp2,NULL,NULL,TRUE))
[194]2306 {
2307 if (fUnHilite && wasemphasized)
2308 UnHilite(hwnd, TRUE, &dcd -> lastselection);
2309 }
2310 if (hwndStatus2)
2311 PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
2312 }
2313 }
2314 }
2315 return 0;
[2]2316
[194]2317 case CN_DROP:
[444]2318 if (mp2) {
[194]2319 LISTINFO *li;
2320 ULONG action = UM_ACTION;
[2]2321
[194]2322 li = DoFileDrop(hwnd, NULL, TRUE, mp1, mp2);
[444]2323 if (li) {
2324 if (!*li -> targetpath) {
[194]2325 li -> type = IDM_COLLECT;
2326 action = UM_COLLECT;
2327 }
[444]2328 else {
[194]2329 if (li -> list && li -> list[0] && IsRoot(li -> list[0]))
2330 li -> type = DO_LINK;
[444]2331 else if (fDragndropDlg && (!*li -> arcname || !li -> info)) {
[194]2332 CHECKLIST cl;
[2]2333
[194]2334 memset(&cl, 0, sizeof(cl));
2335 cl.size = sizeof(cl);
2336 cl.flags = li -> type;
2337 cl.list = li -> list;
2338 cl.cmd = li -> type;
2339 cl.prompt = li -> targetpath;
2340 li -> type = WinDlgBox(HWND_DESKTOP, dcd -> hwndParent,
2341 DropListProc, FM3ModHandle,
2342 DND_FRAME, MPFROMP(&cl));
[444]2343 if (!li -> type) {
[194]2344 FreeListInfo(li);
2345 return 0;
2346 }
2347 li -> list = cl.list;
[444]2348 if (!li -> list || !li -> list[0]) {
[194]2349 FreeListInfo(li);
2350 return 0;
2351 }
2352 }
[444]2353 switch (li -> type) {
[194]2354 case DND_LAUNCH:
2355 strcat(li -> targetpath, " %a");
2356 ExecOnList(dcd -> hwndParent, li -> targetpath,
2357 PROMPT | WINDOWED, NULL, li -> list, NULL);
2358 FreeList(li -> list);
2359 li -> list = NULL;
2360 break;
2361 case DO_LINK:
[444]2362 if (fLinkSetsIcon) {
[194]2363 li -> type = IDM_SETICON;
2364 action = UM_MASSACTION;
2365 }
2366 else
2367 li -> type = IDM_COMPARE;
2368 break;
2369 case DND_EXTRACT:
2370 if (*li -> targetpath && !IsFile(li -> targetpath))
2371 li -> type = IDM_EXTRACT;
2372 break;
2373 case DND_MOVE:
2374 li -> type = IDM_MOVE;
[444]2375 if (*li -> targetpath && IsFile(li -> targetpath) == 1) {
[194]2376 action = UM_MASSACTION;
2377 li -> type = IDM_ARCHIVEM;
2378 }
2379 break;
2380 case DND_WILDMOVE:
2381 li -> type = IDM_WILDMOVE;
[444]2382 if (*li -> targetpath && IsFile(li -> targetpath) == 1) {
[194]2383 action = UM_MASSACTION;
2384 li -> type = IDM_ARCHIVEM;
2385 }
2386 break;
2387 case DND_OBJECT:
2388 li -> type = IDM_OBJECT;
2389 action = UM_MASSACTION;
2390 break;
2391 case DND_SHADOW:
2392 li -> type = IDM_SHADOW;
2393 action = UM_MASSACTION;
2394 break;
2395 case DND_COMPARE:
2396 li -> type = IDM_COMPARE;
2397 break;
2398 case DND_SETICON:
2399 action = UM_MASSACTION;
2400 li -> type = IDM_SETICON;
2401 break;
2402 case DND_WILDCOPY:
2403 li -> type = IDM_WILDCOPY;
[444]2404 if (*li -> targetpath && IsFile(li -> targetpath) == 1) {
[194]2405 action = UM_MASSACTION;
2406 li -> type = IDM_ARCHIVE;
2407 }
2408 break;
2409 case DND_COPY:
2410 li -> type = IDM_COPY;
[444]2411 if (*li -> targetpath && IsFile(li -> targetpath) == 1) {
[194]2412 action = UM_MASSACTION;
2413 li -> type = IDM_ARCHIVE;
2414 }
2415 break;
2416 default:
[444]2417 if (*li -> arcname && li -> info) {
[194]2418 action = UM_MASSACTION;
2419 li -> type = (li -> type == DO_MOVE) ? IDM_FAKEEXTRACTM : IDM_FAKEEXTRACT;
2420 }
[444]2421 else if (*li -> targetpath && IsFile(li -> targetpath) == 1) {
[194]2422 action = UM_MASSACTION;
2423 li -> type = (li -> type == DO_MOVE) ? IDM_ARCHIVEM : IDM_ARCHIVE;
2424 }
2425 else
2426 li -> type = (li -> type == DO_MOVE) ? IDM_MOVE : IDM_COPY;
2427 break;
2428 }
2429 }
2430 if (!li -> list || !li -> list[0])
2431 FreeListInfo(li);
2432 else if (!PostMsg(dcd -> hwndObject, action, MPFROMP(li), MPVOID))
2433 FreeListInfo(li);
[444]2434 else {
[194]2435 USHORT usop = 0;
[2]2436
[444]2437 switch (li -> type) {
[194]2438 case IDM_COPY:
2439 case IDM_WILDCOPY:
2440 usop = DO_COPY;
2441 break;
2442 case IDM_MOVE:
2443 case IDM_WILDMOVE:
2444 case IDM_ARCHIVEM:
2445 usop = DO_MOVE;
2446 break;
2447 }
2448 if (usop)
2449 return MRFROM2SHORT(DOR_DROP, usop);
2450 }
2451 }
2452 }
2453 return 0;
[2]2454
[194]2455 case CN_BEGINEDIT:
2456 case CN_REALLOCPSZ:
2457 case CN_ENDEDIT:
2458 {
2459 MRESULT mre;
[2]2460
[194]2461 mre = CnrDirectEdit(hwnd, msg, mp1, mp2);
2462 if (mre != (MRESULT) - 1)
2463 return mre;
2464 }
2465 break;
[2]2466
[194]2467 case CN_EMPHASIS:
[444]2468 if (mp2) {
[194]2469 PNOTIFYRECORDEMPHASIS pre = mp2;
2470 PCNRITEM pci;
2471 CHAR s[CCHMAXPATH + 91], tb[81], tf[81], *p;
[2]2472
[194]2473 pci = (PCNRITEM) ((pre) ? pre -> pRecord : NULL);
[444]2474 if (!pci) {
[194]2475 if (hwndStatus2)
2476 WinSetWindowText(hwndStatus2, NullStr);
[444]2477 if (fMoreButtons) {
[194]2478 WinSetWindowText(hwndName, NullStr);
2479 WinSetWindowText(hwndDate, NullStr);
2480 WinSetWindowText(hwndAttr, NullStr);
2481 }
2482 if (hwndMain)
2483 WinSendMsg(hwndMain, UM_LOADFILE, MPVOID, MPVOID);
2484 break;
2485 }
[444]2486 if (pre -> fEmphasisMask & CRA_SELECTED) {
2487 if (pci -> rc.flRecordAttr & CRA_SELECTED) {
[194]2488 dcd -> selectedbytes += (pci -> cbFile + pci -> easize);
2489 dcd -> selectedfiles++;
2490 }
[444]2491 else if (dcd -> selectedfiles) {
[194]2492 dcd -> selectedbytes -= (pci -> cbFile + pci -> easize);
2493 dcd -> selectedfiles--;
2494 }
[444]2495 if (!dcd -> suspendview) {
[194]2496 commafmt(tf, sizeof(tf), dcd -> selectedfiles);
2497 CommaFmtULL(tb, sizeof(tb), dcd -> selectedbytes, ' ');
2498 sprintf(s, "%s / %s", tf, tb);
2499 WinSetDlgItemText(dcd -> hwndClient, DIR_SELECTED, s);
2500 }
2501 }
[280]2502 if (!dcd -> suspendview &&
2503 WinQueryActiveWindow(dcd -> hwndParent) == dcd -> hwndFrame)
[194]2504 {
[444]2505 if (pre -> fEmphasisMask & CRA_CURSORED) {
2506 if (pci -> rc.flRecordAttr & CRA_CURSORED) {
2507 if (fSplitStatus && hwndStatus2) {
[194]2508 if (pci -> attrFile & FILE_DIRECTORY)
2509 p = pci -> pszFileName;
[444]2510 else {
[194]2511 p = strrchr(pci -> szFileName, '\\');
[444]2512 if (p) {
[194]2513 if (*(p + 1))
2514 p++;
2515 else
2516 p = pci -> pszFileName;
2517 }
2518 else
2519 p = pci -> pszFileName;
2520 }
2521 CommaFmtULL(tb, sizeof(tb), pci -> cbFile + pci -> easize, ' ');
2522 if (!fMoreButtons)
2523 sprintf(s, " %s %04u/%02u/%02u %02u:%02u:%02u [%s] %s",
2524 tb, pci -> date.year,
2525 pci -> date.month, pci -> date.day, pci -> time.hours,
2526 pci -> time.minutes, pci -> time.seconds,
2527 pci -> pszDispAttr, p);
[444]2528 else {
[194]2529 if (pci -> cbFile + pci -> easize > 1024)
2530 CommaFmtULL(tf, sizeof(tf), pci -> cbFile + pci -> easize, ' ');
2531 else
2532 *tf = 0;
2533 sprintf(s, GetPString(IDS_STATUSSIZETEXT),
2534 tb,
2535 *tf ? " (" : NullStr,
2536 tf,
2537 *tf ? ")" : NullStr);
2538 }
2539 WinSetWindowText(hwndStatus2, s);
2540 }
[444]2541 if (fMoreButtons) {
[194]2542 WinSetWindowText(hwndName, pci -> pszFileName);
2543 sprintf(s, "%04u/%02u/%02u %02u:%02u:%02u",
2544 pci -> date.year, pci -> date.month,
2545 pci -> date.day, pci -> time.hours, pci -> time.minutes,
2546 pci -> time.seconds);
2547 WinSetWindowText(hwndDate, s);
2548 WinSetWindowText(hwndAttr, pci -> pszDispAttr);
2549 }
2550 }
2551 }
2552 }
2553 if (!dcd -> suspendview && hwndMain &&
2554 (pre -> fEmphasisMask & CRA_CURSORED) &&
2555 (pci -> rc.flRecordAttr & CRA_CURSORED) &&
2556 WinQueryActiveWindow(dcd -> hwndParent) == dcd -> hwndFrame)
2557 WinSendMsg(hwndMain, UM_LOADFILE,
2558 MPFROMP(((fComments || (pci -> attrFile & FILE_DIRECTORY) == 0) ?
2559 pci -> szFileName : NULL)), MPVOID);
2560 }
2561 break;
[2]2562
[194]2563 case CN_ENTER:
[444]2564 if (mp2) {
[194]2565 PCNRITEM pci = (PCNRITEM) ((PNOTIFYRECORDENTER) mp2) -> pRecord;
2566 FILEFINDBUF3 ffb;
2567 HDIR hDir = HDIR_CREATE;
2568 ULONG nm = 1L;
2569 APIRET status = 0;
[2]2570
[194]2571 SetShiftState();
[444]2572 if (pci) {
[194]2573 if (pci -> rc.flRecordAttr & CRA_INUSE)
2574 break;
2575 DosError(FERR_DISABLEHARDERR);
2576 status = DosFindFirst(pci -> szFileName, &hDir,
2577 FILE_NORMAL | FILE_DIRECTORY |
2578 FILE_ARCHIVED | FILE_READONLY |
2579 FILE_HIDDEN | FILE_SYSTEM,
2580 &ffb, sizeof(ffb), &nm,
2581 FIL_STANDARD);
2582 priority_bumped();
[444]2583 if (!status) {
[194]2584 DosFindClose(hDir);
[444]2585 if (ffb.attrFile & FILE_DIRECTORY) {
[194]2586 if ((shiftstate & (KC_CTRL | KC_ALT)) ==
2587 (KC_CTRL | KC_ALT))
2588 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_SHOWALLFILES, 0),
2589 MPVOID);
2590 else if ((shiftstate & (KC_CTRL | KC_SHIFT)) ==
2591 (KC_CTRL | KC_SHIFT))
2592 OpenObject(pci -> szFileName, Settings, dcd -> hwndFrame);
2593 else if (shiftstate & KC_CTRL)
2594 OpenObject(pci -> szFileName, Default, dcd -> hwndFrame);
2595 else
[280]2596 OpenDirCnr(HWND_DESKTOP,
[194]2597 hwndMain,
2598 dcd -> hwndFrame,
2599 FALSE,
2600 pci -> szFileName);
2601 }
[444]2602 else {
[194]2603 SWP swp;
[2]2604
[194]2605 WinSendMsg(hwnd,
2606 CM_SETRECORDEMPHASIS,
2607 MPFROMP(pci),
2608 MPFROM2SHORT(TRUE, CRA_INUSE));
2609 WinQueryWindowPos(dcd -> hwndFrame, &swp);
2610 DefaultViewKeys(hwnd,
2611 dcd -> hwndFrame,
2612 dcd -> hwndParent,
2613 &swp,
2614 pci -> szFileName);
2615 WinSendMsg(hwnd,
2616 CM_SETRECORDEMPHASIS,
2617 MPFROMP(pci),
2618 MPFROM2SHORT(FALSE, CRA_INUSE |
2619 ((fUnHilite) ? CRA_SELECTED : 0)));
2620 }
2621 }
2622 else
2623 WinSendMsg(hwnd,
2624 CM_REMOVERECORD,
2625 MPFROMP(&pci),
2626 MPFROM2SHORT(1,
[471]2627 CMA_FREE | CMA_INVALIDATE | CMA_ERASE));
[194]2628 }
2629 }
2630 break;
[2]2631 }
[194]2632 }
2633 return 0;
[2]2634
[194]2635 case UM_LOADFILE:
[444]2636 if (dcd && mp2) {
[194]2637 HWND ret;
[2]2638
[194]2639 ret = StartMLEEditor(dcd -> hwndParent,
2640 (INT) mp1,
2641 (CHAR *) mp2,
2642 dcd -> hwndFrame);
2643 if (mp2)
2644 free((CHAR *) mp2);
2645 return MRFROMLONG(ret);
2646 }
2647 return 0;
[2]2648
[194]2649 case UM_CLOSE:
2650 WinDestroyWindow(WinQueryWindow(WinQueryWindow(hwnd, QW_PARENT),
2651 QW_PARENT));
2652 return 0;
[2]2653
[194]2654 case UM_FOLDUP:
[403]2655 if (!PostMsg((HWND)0, WM_QUIT, MPVOID, MPVOID))
[194]2656 DosExit(EXIT_PROCESS, 1);
2657 return 0;
[2]2658
[194]2659 case WM_CLOSE:
[444]2660 if (dcd) {
[194]2661 dcd -> namecanchange = TRUE;
2662 dcd -> stopflag = 1;
2663 if (dcd -> amextracted)
[280]2664 return 0; // Can not close yet
[194]2665 }
2666 WinSendMsg(hwnd, WM_SAVEAPPLICATION, MPVOID, MPVOID);
[444]2667 if (dcd) {
[194]2668 if (!dcd -> dontclose && ParentIsDesktop(hwnd, dcd -> hwndParent))
2669 PostMsg(hwnd, UM_FOLDUP, MPVOID, MPVOID);
[444]2670 if (dcd -> hwndObject) {
[194]2671 DosSleep(64L);
2672 if (!PostMsg(dcd -> hwndObject, WM_CLOSE, MPVOID, MPVOID))
2673 WinSendMsg(dcd -> hwndObject, WM_CLOSE, MPVOID, MPVOID);
[2]2674 }
[194]2675 }
2676 else
2677 WinSendMsg(hwnd, UM_CLOSE, MPVOID, MPVOID);
2678 return 0;
[2]2679
[194]2680 case WM_DESTROY:
2681 if (CollectorDirMenu)
2682 WinDestroyWindow(CollectorDirMenu);
2683 if (CollectorFileMenu)
2684 WinDestroyWindow(CollectorFileMenu);
2685 if (CollectorCnrMenu)
2686 WinDestroyWindow(CollectorCnrMenu);
[403]2687 CollectorCnrMenu = CollectorFileMenu = CollectorDirMenu = (HWND)0;
2688 Collector = (HWND)0;
[194]2689 EmptyCnr(hwnd);
2690 break;
[2]2691 }
[194]2692 return (dcd && dcd -> oldproc) ? dcd -> oldproc(hwnd, msg, mp1, mp2) :
2693 PFNWPCnr(hwnd, msg, mp1, mp2);
[2]2694}
2695
[194]2696HWND StartCollector(HWND hwndParent, INT flags)
[155]2697{
[403]2698 HWND hwndFrame = (HWND)0;
[197]2699 HWND hwndClient;
[194]2700 ULONG FrameFlags = FCF_TITLEBAR | FCF_SYSMENU |
[444]2701 FCF_SIZEBORDER | FCF_MINMAX |
2702 FCF_ICON | FCF_NOBYTEALIGN |
2703 FCF_ACCELTABLE;
[194]2704 USHORT id;
2705 DIRCNRDATA *dcd;
[2]2706
[197]2707 static USHORT idinc = 0;
2708
[194]2709 if (ParentIsDesktop(hwndParent, hwndParent))
[2]2710 FrameFlags |= (FCF_TASKLIST | FCF_SHELLPOSITION | FCF_MENU);
[444]2711 if (Collector) {
[2]2712 WinSetWindowPos(WinQueryWindow(WinQueryWindow(Collector,
[194]2713 QW_PARENT),
2714 QW_PARENT),
2715 HWND_TOP,
2716 0,
2717 0,
2718 0,
2719 0,
2720 SWP_SHOW | SWP_RESTORE);
[2]2721 return WinQueryWindow(WinQueryWindow(Collector,
[194]2722 QW_PARENT),
2723 QW_PARENT);
[2]2724 }
2725 hwndFrame = WinCreateStdWindow(hwndParent,
[194]2726 WS_VISIBLE,
2727 &FrameFlags,
2728 GetPString(IDS_WCCOLLECTOR),
2729 NULL,
2730 WS_VISIBLE | fwsAnimate,
2731 FM3ModHandle,
2732 COLLECTOR_FRAME,
2733 &hwndClient);
[444]2734 if (hwndFrame && hwndClient) {
[2]2735 id = COLLECTOR_FRAME + idinc++;
[194]2736 WinSetWindowUShort(hwndFrame, QWS_ID, id);
[352]2737 dcd = xmallocz(sizeof(DIRCNRDATA),pszSrcFile,__LINE__);
[377]2738 if (!dcd) {
2739 Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
2740 PostMsg(hwndClient,WM_CLOSE,MPVOID,MPVOID);
[403]2741 hwndFrame = (HWND)0;
[377]2742 }
2743 else {
[194]2744 dcd -> size = sizeof(DIRCNRDATA);
2745 dcd -> id = id;
2746 dcd -> type = COLLECTOR_FRAME;
2747 dcd -> hwndParent = (hwndParent) ? hwndParent : HWND_DESKTOP;
2748 dcd -> hwndFrame = hwndFrame;
2749 dcd -> hwndClient = hwndClient;
2750 if (flags & 4)
2751 dcd -> dontclose = TRUE;
[2]2752 {
[194]2753 PFNWP oldproc;
[2]2754
[194]2755 oldproc = WinSubclassWindow(hwndFrame,
2756 (PFNWP) CollectorFrameWndProc);
[471]2757 WinSetWindowPtr(hwndFrame,QWL_USER,(PVOID) oldproc);
[2]2758 }
[194]2759 dcd -> hwndCnr = WinCreateWindow(hwndClient,
2760 WC_CONTAINER,
2761 NULL,
2762 CCS_AUTOPOSITION | CCS_MINIICONS |
2763 CCS_MINIRECORDCORE | ulCnrType |
2764 WS_VISIBLE,
2765 0,
2766 0,
2767 0,
2768 0,
2769 hwndClient,
2770 HWND_TOP,
2771 (ULONG) COLLECTOR_CNR,
2772 NULL,
2773 NULL);
[377]2774 if (!dcd -> hwndCnr) {
[444]2775 Win_Error2(hwndClient,hwndClient,pszSrcFile,__LINE__,IDS_WINCREATEWINDOW);
[377]2776 PostMsg(hwndClient,WM_CLOSE,MPVOID,MPVOID);
2777 free(dcd);
[403]2778 hwndFrame = (HWND)0;
[377]2779 }
2780 else {
[194]2781 Collector = dcd -> hwndCnr;
2782 WinSetWindowPtr(dcd -> hwndCnr, QWL_USER, (PVOID) dcd);
[471]2783 WinSetWindowText(hwndFrame,GetPString(IDS_COLLECTORTITLETEXT));
[444]2784 if (FrameFlags & FCF_MENU) {
2785 if (!fToolbar) {
[194]2786 HWND hwndMenu = WinWindowFromID(hwndFrame, FID_MENU);
[2]2787
[444]2788 if (hwndMenu) {
[194]2789 WinSendMsg(hwndMenu,
2790 MM_DELETEITEM,
2791 MPFROM2SHORT(IDM_SEEALL, FALSE),
2792 MPVOID);
2793 WinSendMsg(hwndMenu,
2794 MM_DELETEITEM,
2795 MPFROM2SHORT(IDM_GREP, FALSE),
2796 MPVOID);
2797 WinSendMsg(hwndMenu,
2798 MM_DELETEITEM,
2799 MPFROM2SHORT(IDM_CLEARCNR, FALSE),
2800 MPVOID);
2801 WinSendMsg(hwndMenu,
2802 MM_DELETEITEM,
2803 MPFROM2SHORT(IDM_REMOVE, FALSE),
2804 MPVOID);
2805 }
2806 }
2807 }
2808 dcd -> oldproc = WinSubclassWindow(dcd -> hwndCnr,
2809 (PFNWP) CollectorCnrWndProc);
2810 {
2811 USHORT ids[] =
2812 {DIR_TOTALS, DIR_SELECTED, DIR_VIEW, DIR_SORT,
2813 DIR_FILTER, 0};
[2]2814
[194]2815 CommonCreateTextChildren(dcd -> hwndClient,
2816 GetPString(IDS_WCCOLSTATUS),
2817 ids);
2818 }
2819 if (FrameFlags & FCF_SHELLPOSITION)
[471]2820 PostMsg(hwndClient,UM_SIZE,MPVOID,MPVOID);
2821 if (!PostMsg(dcd -> hwndCnr,UM_SETUP,MPVOID,MPVOID))
2822 WinSendMsg(dcd -> hwndCnr,UM_SETUP,MPVOID,MPVOID);
[2]2823 }
2824 }
2825 }
2826 return hwndFrame;
2827}
Note: See TracBrowser for help on using the repository browser.