source: trunk/dll/dircnrs.c@ 1459

Last change on this file since 1459 was 1459, checked in by Steven Levine, 16 years ago

Show rescan progress while filling container, ticket #291
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 104.0 KB
RevLine 
[1335]1
[36]2/***********************************************************************
3
4 $Id: dircnrs.c 1459 2009-09-16 05:58:59Z stevenhl $
5
6 Directory containers
7
8 Copyright (c) 1993-98 M. Kimes
[1394]9 Copyright (c) 2001, 2009 Steven H. Levine
[36]10
[130]11 16 Oct 02 SHL Handle large partitions
12 01 Aug 04 SHL Rework lstrip/rstrip usage
13 23 May 05 SHL Use QWL_USER
[145]14 24 May 05 SHL Rework Win_Error usage
[150]15 25 May 05 SHL Use ULONGLONG and CommaFmtULL
[171]16 26 May 05 SHL More large file formatting updates
[186]17 05 Jun 05 SHL Use QWL_USER
[275]18 10 Nov 05 SHL Comments
[358]19 13 Jul 06 SHL Use Runtime_Error
[369]20 26 Jul 06 SHL Use chop_at_crnl
[449]21 15 Aug 06 SHL Rework warning message text
[552]22 07 Jan 07 GKY Move error strings etc. to string file
[593]23 30 Mar 07 GKY Remove GetPString for window class names
[603]24 06 Apr 07 GKY Work around PM DragInfo and DrgFreeDISH limits
25 06 Apr 07 GKY Add some error checking in drag/drop
[618]26 19 Apr 07 SHL Use FreeDragInfoData. Add more drag/drop error checking.
[672]27 12 May 07 SHL Use dcd->ulItemsToUnHilite; sync with UnHilite arg mods
[688]28 10 Jun 07 GKY Add CheckPmDrgLimit including IsFm2Window as part of work around PM drag limit
[751]29 02 Aug 07 SHL Sync with CNRITEM mods
[775]30 06 Aug 07 GKY Reduce DosSleep times (ticket 148)
[793]31 20 Aug 07 GKY Move #pragma alloc_text to end for OpenWatcom compat
[814]32 26 Aug 07 GKY DosSleep(1) in loops changed to (0)
[872]33 22 Nov 07 GKY Use CopyPresParams to fix presparam inconsistencies in menus
[917]34 10 Jan 08 SHL Sync with CfgDlgProc mods
[972]35 19 Jan 08 JBS Ticket 150: fix/improve save and restore of dir cnr state at FM/2 close/reopen
[953]36 15 Feb 08 SHL Sync with settings menu rework
[972]37 22 Feb 08 JBS Ticket 230: Fix/improve various code related to state or presparam values in the INI file.
[1016]38 11 May 08 GKY Avoid using stale dcd after free
39 11 May 08 SHL Add stale dcd sanity checks
[1028]40 21 Jun 08 GKY Fix columns to honor preferences on new container open.
[1029]41 22 Jun 08 GKY Included free_... functions for fortify checking
[1041]42 06 Jul 08 GKY Update delete/undelete to include move to and open XWP trashcan
[1065]43 11 Jul 08 JBS Ticket 230: Simplified code and eliminated some local variables by incorporating
[1077]44 all the details view settings (both the global variables and those in the
45 DIRCNRDATA struct) into a new struct: DETAILS_SETTINGS.
[1084]46 20 Jul 08 GKY Add save/append filename to clipboard.
[1335]47 Change menu wording to make these easier to find
[1102]48 02 Aug 08 GKY Always pass temp variable point to treecnr UM_SHOWME to avoid
[1335]49 freeing dcd->directory early
[1120]50 25 Aug 08 GKY Check TMP directory space warn if lee than 5 MiB prevent archiver from opening if
[1335]51 less than 10 KiB (It hangs and can't be closed)
[1303]52 29 Nov 08 GKY Remove or replace with a mutex semaphore DosEnterCriSec where appropriate.
[1335]53 10 Dec 08 SHL Integrate exception handler support
[1357]54 26 Dec 08 GKY Fixed DROPHELP to check for copy as default is action is DO_DEFAULT
[1375]55 01 Jan 09 GKY Add Seek and Scan to drives & directory context menus pass drive/dir as search root
[1395]56 07 Feb 09 GKY Eliminate Win_Error2 by moving function names to PCSZs used in Win_Error
57 07 Feb 09 GKY Move repeated strings to PCSZs.
58 07 Feb 09 GKY Allow user to turn off alert and/or error beeps in settings notebook.
59 07 Feb 09 GKY Add *DateFormat functions to format dates based on locale
[1400]60 08 Mar 09 GKY Renamed commafmt.h i18nutil.h
61 08 Mar 09 GKY Additional strings move to PCSZs in init.c
[1412]62 12 Mar 09 SHL Use common SearchContainer
[1402]63 14 Mar 09 GKY Prevent execution of UM_SHOWME while drive scan is occuring
[1412]64 29 Mar 09 SHL Keep more keys away from PM if extended search in progress
65 29 Mar 09 SHL Increase extended search timeout to 3 seconds
[1438]66 28 Jun 09 GKY Added AddBackslashToPath() to remove repeatative code.
[1444]67 22 Jul 09 GKY Code changes to use semaphores to serialize drive scanning
68 22 Jul 09 SHL Cleanup of SETFOCUS code
[1455]69 14 Sep 09 SHL Drop experimental code
[1459]70 15 Sep 09 SHL Show rescan progress while filling container
[36]71
72***********************************************************************/
73
[907]74#include <stdlib.h>
75#include <string.h>
76#include <ctype.h>
77#include <limits.h>
[1335]78// #include <process.h> // _beginthread
[907]79
[2]80#define INCL_DOS
81#define INCL_WIN
82#define INCL_DOSERRORS
[150]83#define INCL_LONGLONG
[1041]84#define INCL_WINWORKPLACE
[2]85
[1177]86#include "fm3dll.h"
[1222]87#include "fm3dll2.h" // #define's for UM_*, control id's, etc.
[1206]88#include "mainwnd2.h" // Data declaration(s)
89#include "grep.h" // Data declaration(s)
90#include "info.h" // Data declaration(s)
91#include "treecnr.h" // Data declaration(s)
92#include "dircnrs.h" // Data declaration(s)
93#include "init.h" // Data declaration(s)
[2]94#include "fm3dlg.h"
95#include "fm3str.h"
96#include "mle.h"
[907]97#include "arccnrs.h" // StartArcCnr
98#include "comp.h" // COMPARE
99#include "filldir.h" // EmptyCnr...
100#include "errutil.h" // Dos_Error...
101#include "strutil.h" // GetPString
[953]102#include "notebook.h" // CfgDlgProc
[1016]103#include "command.h" // RunCommand
[1459]104#include "worker.h" // Action, MassAction
[1156]105#include "misc.h" // GetTidForThread, AdjustCnrColsForFSType, AdjustCnrColsForPref
[1335]106 // AdjustDetailsSwitches, CnrDirectEdit, OpenEdit, QuickPopup
107 // SayFilter, SaySort, SayView, SetCnrCols, SetDetailsSwitches
[1459]108 // SetSortChecks, SetViewMenu, SwitchCommand, CheckMenu
109 // CurrentRecord, DrawTargetEmphasis, IsFm2Window
[1156]110#include "chklist.h" // CenterOverWindow, DropListProc
111#include "common.h" // CommonCnrProc, CommonCreateTextChildren, CommonFrameWndProc
[1459]112 // CommonTextPaint, CommonTextButton, CommonTextProc
[1177]113#include "mainwnd.h" // CountDirCnrs, GetNextWindowPos, MakeBubble, TopWindow
[1156]114#include "select.h" // DeselectAll, HideAll, InvertAll, SelectAll, SelectList
[1459]115 // SpecialSelect2
[1156]116#include "dirsize.h" // DirSizeProc
117#include "flesh.h" // Flesh, Stubby, UnFlesh
118#include "valid.h" // IsValidDir
119#include "objwin.h" // MakeObjWin
120#include "notify.h" // NotifyError
121#include "objcnr.h" // ObjCnrDlgProc
[1177]122#include "draglist.h" // DoFileDrag, FreeDragInfoData, PickUp
[1156]123#include "saveclip.h" // SaveListDlgProc
124#include "findrec.h" // ShowCnrRecord
125#include "sortcnr.h" // SortDirCnr
126#include "seeall.h" // StartSeeAll
127#include "update.h" // UpdateCnrList, UpdateCnrRecord
128#include "walkem.h" // add_udir
129#include "strips.h" // chop_at_crnl
[1177]130#include "droplist.h" // AcceptOneDrop, CheckPmDrgLimit, DropHelp, GetOneDrop
131#include "presparm.h" // CopyPresParams
132#include "defview.h" // DefaultViewKeys
133#include "systemf.h" // ExecOnList
134#include "filter.h" // Filter
135#include "findrec.h" // FindCnrRecord
136#include "input.h" // InputDlgProc
137#include "shadow.h" // OpenObject
138#include "mkdir.h" // PMMkDir
139#include "collect.h" // StartCollector
140#include "viewer.h" // StartMLEEditor
141#include "newview.h" // StartViewer
142#include "undel.h" // UndeleteDlgProc
[1400]143#include "i18nutil.h" // commafmt
[1177]144#include "getnames.h" // insert_filename
145#include "wrappers.h" // xfree
[1012]146#include "fortify.h"
[1335]147#include "excputil.h" // 06 May 08 SHL added
[1455]148#include "pathutil.h" // AddBackslashToPath
[2]149
[1206]150// Data definitions
151#pragma data_seg(GLOBAL1)
152HWND DirCnrMenu;
153HWND hwndAttr;
154HWND hwndDate;
155
156#pragma data_seg(GLOBAL2)
157INT sortFlags;
158
[2]159#pragma data_seg(DATA1)
160
[358]161static PSZ pszSrcFile = __FILE__;
[2]162
[551]163MRESULT EXPENTRY DirFrameWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
[275]164{
[551]165 return CommonFrameWndProc(DIR_CNR, hwnd, msg, mp1, mp2);
[2]166}
167
[551]168MRESULT EXPENTRY DirTextProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
[275]169{
[551]170 static BOOL emphasized = FALSE;
171 static HWND hwndButtonPopup = (HWND) 0;
172 static USHORT lastid = 0;
173 static ULONG timestamp = ULONG_MAX;
[2]174
[551]175 switch (msg) {
176 case WM_CREATE:
177 return CommonTextProc(hwnd, msg, mp1, mp2);
[2]178
[551]179 case WM_COMMAND:
180 {
181 DIRCNRDATA *dcd;
182 MRESULT mr;
[2]183
[551]184 mr = WinSendMsg(WinWindowFromID(WinQueryWindow(hwnd,
185 QW_PARENT),
186 DIR_CNR), msg, mp1, mp2);
187 if (hwndButtonPopup &&
188 SHORT1FROMMP(mp1) > IDM_DETAILSTITLES &&
189 SHORT1FROMMP(mp1) < IDM_DETAILSSETUP) {
190 dcd = WinQueryWindowPtr(WinWindowFromID(WinQueryWindow(hwnd,
191 QW_PARENT),
192 DIR_CNR), QWL_USER);
193 if (dcd)
[1065]194 SetDetailsSwitches(hwndButtonPopup, &dcd->ds);
[2]195 }
[551]196 return mr;
197 }
[2]198
[551]199 case UM_CONTEXTMENU:
200 case WM_CONTEXTMENU:
201 {
202 USHORT id;
[2]203
[551]204 id = WinQueryWindowUShort(hwnd, QWS_ID);
205 switch (id) {
206 case DIR_FOLDERICON:
207 if (fNoFoldMenu) {
208 PostMsg(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
209 DIR_CNR),
210 WM_COMMAND, MPFROM2SHORT(IDM_PREVIOUS, 0), mp2);
211 break;
212 }
213 /* else intentional fallthru */
214 case DIR_SELECTED:
215 case DIR_VIEW:
216 case DIR_SORT:
217 {
218 POINTL ptl = { 0, 0 };
219 SWP swp;
220 DIRCNRDATA *dcd;
[2]221
[551]222 if (hwndButtonPopup)
223 WinDestroyWindow(hwndButtonPopup);
224 if (id == DIR_SELECTED && msg == WM_CONTEXTMENU)
225 id = DIR_MAX;
226 if (id == lastid) {
[2]227
[551]228 ULONG check;
[2]229
[551]230 DosQuerySysInfo(QSV_MS_COUNT,
231 QSV_MS_COUNT, &check, sizeof(check));
232 if (check < timestamp + 500) {
233 lastid = 0;
234 goto MenuAbort;
235 }
236 }
[907]237 hwndButtonPopup = WinLoadMenu(HWND_DESKTOP, FM3ModHandle, id);
238 CopyPresParams(hwndButtonPopup, hwnd);
[551]239 if (hwndButtonPopup) {
240 WinSetWindowUShort(hwndButtonPopup, QWS_ID, id);
241 dcd = WinQueryWindowPtr(WinWindowFromID(WinQueryWindow(hwnd,
242 QW_PARENT),
243 DIR_CNR), QWL_USER);
244 if (id == DIR_SORT) { /* don't have sort pathname in dirs */
245 WinSendMsg(hwndButtonPopup,
246 MM_DELETEITEM,
247 MPFROM2SHORT(IDM_SORTNAME, FALSE), MPVOID);
248 WinSendMsg(hwndButtonPopup,
249 MM_DELETEITEM,
250 MPFROM2SHORT(IDM_SORTNONE, FALSE), MPVOID);
251 if (dcd)
252 SetSortChecks(hwndButtonPopup, dcd->sortFlags);
253 }
254 else if (id == DIR_VIEW) {
255 if (dcd) {
256 SetViewMenu(hwndButtonPopup, dcd->flWindowAttr);
[1065]257 SetDetailsSwitches(hwndButtonPopup, &dcd->ds);
[551]258 }
259 }
260 else if (id == DIR_MAX) {
[2]261
[551]262 int x;
263 BOOL enable;
264 USHORT ids[] = { IDM_SELECTBOTH,
265 IDM_SELECTMORE,
266 IDM_SELECTONE,
267 IDM_SELECTNEWER,
268 IDM_SELECTOLDER,
269 IDM_SELECTBIGGER,
270 IDM_SELECTSMALLER,
271 IDM_DESELECTBOTH,
272 IDM_DESELECTMORE,
273 IDM_DESELECTONE,
274 IDM_DESELECTNEWER,
275 IDM_DESELECTOLDER,
276 IDM_DESELECTBIGGER,
277 IDM_DESELECTSMALLER,
278 0
279 };
[2]280
[551]281 enable = (CountDirCnrs(dcd->hwndParent) > 1);
282 for (x = 0; ids[x]; x++)
283 WinEnableMenuItem(hwndButtonPopup, ids[x], enable);
284 }
285 else if (id == DIR_SELECTED) {
286 if (dcd)
287 WinEnableMenuItem(hwndButtonPopup,
288 IDM_RESELECT, (dcd->lastselection != NULL));
289 }
290 ptl.x = 0;
291 if (WinPopupMenu(HWND_OBJECT,
292 HWND_OBJECT,
293 hwndButtonPopup, -32767, -32767, 0, 0)) {
294 WinQueryWindowPos(hwndButtonPopup, &swp);
295 ptl.y = -(swp.cy + 2);
296 }
297 else {
298 WinQueryWindowPos(hwnd, &swp);
299 ptl.y = swp.cy + 2;
300 }
301 if (WinPopupMenu(hwnd,
302 hwnd,
303 hwndButtonPopup,
304 ptl.x,
305 ptl.y,
306 0,
307 PU_HCONSTRAIN | PU_VCONSTRAIN |
308 PU_KEYBOARD | PU_MOUSEBUTTON1)) {
309 CenterOverWindow(hwndButtonPopup);
310 PaintRecessedWindow(hwnd, (HPS) 0, FALSE, FALSE);
311 }
312 }
313 }
314 break;
315 default:
316 PostMsg(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT), DIR_CNR),
317 WM_CONTROL, MPFROM2SHORT(DIR_CNR, CN_CONTEXTMENU), MPVOID);
318 break;
319 }
320 } // case WM_CONTENT_MENU
[275]321
[551]322 MenuAbort:
[275]323
[551]324 if (msg == UM_CONTEXTMENU)
325 return 0;
326 break;
[2]327
[551]328 case WM_MENUEND:
329 if (hwndButtonPopup == (HWND) mp2) {
330 lastid = WinQueryWindowUShort((HWND) mp2, QWS_ID);
331 WinDestroyWindow(hwndButtonPopup);
332 hwndButtonPopup = (HWND) 0;
333 DosQuerySysInfo(QSV_MS_COUNT,
334 QSV_MS_COUNT, &timestamp, sizeof(timestamp));
335 switch (lastid) {
336 case DIR_VIEW:
337 case DIR_SORT:
338 case DIR_FOLDERICON:
339 case DIR_SELECTED:
340 case DIR_MAX:
341 PaintRecessedWindow(hwnd, (HPS) 0, TRUE, FALSE);
342 break;
[2]343 }
[551]344 }
345 break;
[2]346
[551]347 case WM_BUTTON3DOWN:
348 case WM_BUTTON1DOWN:
349 case WM_BUTTON3UP:
350 case WM_BUTTON1UP:
351 {
352 USHORT id;
[2]353
[551]354 id = WinQueryWindowUShort(hwnd, QWS_ID);
355 switch (id) {
356 case DIR_FILTER:
357 case DIR_VIEW:
358 case DIR_SORT:
359 case DIR_SELECTED:
360 case DIR_FOLDERICON:
361 case DIR_MAX:
362 return CommonTextButton(hwnd, msg, mp1, mp2);
[2]363 }
[551]364 }
365 break;
[2]366
[551]367 case WM_BUTTON1DBLCLK:
368 {
369 NOTIFYRECORDENTER nr;
[2]370
[1451]371 if (WinQueryWindowUShort(hwnd, QWS_ID) != DIR_FOLDERICON) {
[1455]372 memset(&nr, 0, sizeof(NOTIFYRECORDENTER));
373 nr.hwndCnr = WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT), DIR_CNR);
374 WinSendMsg(WinQueryWindow(hwnd, QW_PARENT),
375 WM_CONTROL, MPFROM2SHORT(DIR_CNR, CN_ENTER), MPFROMP(&nr));
[1451]376 }
[551]377 }
378 break;
[2]379
[551]380 case WM_MOUSEMOVE:
381 {
382 USHORT id = WinQueryWindowUShort(hwnd, QWS_ID);
[1394]383 PCSZ s = NULL;
[2]384
[551]385 if (fOtherHelp) {
386 if ((!hwndBubble ||
387 WinQueryWindowULong(hwndBubble, QWL_USER) != hwnd) &&
388 !WinQueryCapture(HWND_DESKTOP)) {
389 switch (id) {
390 case DIR_TOTALS:
391 s = GetPString(IDS_DIRCNRTOTALHELP);
392 break;
393 case DIR_SELECTED:
394 s = GetPString(IDS_DIRCNRSELECTEDHELP);
395 break;
396 case DIR_VIEW:
397 s = GetPString(IDS_DIRCNRVIEWHELP);
398 break;
399 case DIR_SORT:
400 s = GetPString(IDS_DIRCNRSORTHELP);
401 break;
402 case DIR_FILTER:
403 s = GetPString(IDS_DIRCNRFILTERHELP);
404 break;
405 case DIR_MAX:
406 s = GetPString(IDS_DIRCNRMAXHELP);
407 break;
408 case DIR_FOLDERICON:
409 s = GetPString(IDS_DIRCNRFOLDERHELP);
410 break;
411 default:
412 break;
413 }
414 if (s)
415 MakeBubble(hwnd, TRUE, s);
416 else if (hwndBubble)
417 WinDestroyWindow(hwndBubble);
418 }
[2]419 }
[551]420 switch (id) {
421 case DIR_MAX:
422 case DIR_FOLDERICON:
423 case DIR_FILTER:
424 case DIR_SORT:
425 case DIR_VIEW:
426 case DIR_SELECTED:
427 return CommonTextButton(hwnd, msg, mp1, mp2);
428 }
429 }
430 break;
[2]431
[551]432 case WM_CHORD:
433 case WM_BUTTON3CLICK:
434 case WM_BUTTON1CLICK:
435 case UM_CLICKED:
436 case UM_CLICKED3:
437 {
438 USHORT id, cmd = 0;
[2]439
[551]440 id = WinQueryWindowUShort(hwnd, QWS_ID);
441 if (msg == UM_CLICKED || msg == UM_CLICKED3) {
442 switch (id) {
443 case DIR_MAX:
444 cmd = IDM_MAXIMIZE;
445 break;
446 case DIR_VIEW:
447 case DIR_SELECTED:
448 case DIR_SORT:
449 PostMsg(hwnd, UM_CONTEXTMENU, MPVOID, MPVOID);
450 break;
451 case DIR_FILTER:
452 cmd = IDM_FILTER;
453 break;
454 default:
455 break;
456 }
[2]457 }
[551]458 else if (id == DIR_FOLDERICON) {
459 if ((msg == WM_BUTTON1CLICK && (SHORT2FROMMP(mp2) & KC_CTRL)))
460 cmd = IDM_PREVIOUS;
461 else if (msg == WM_BUTTON3CLICK || msg == WM_CHORD)
462 cmd = IDM_RESCAN;
463 else if (msg == WM_BUTTON1CLICK && (SHORT2FROMMP(mp2) & KC_SHIFT))
464 cmd = IDM_WALKDIR;
465 else if (msg == WM_BUTTON1CLICK && (SHORT2FROMMP(mp2) & KC_ALT))
466 cmd = IDM_WINDOWDLG;
467 else
468 cmd = IDM_PARENT;
469 }
470 if (cmd)
471 PostMsg(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
472 DIR_CNR),
473 WM_COMMAND, MPFROM2SHORT(cmd, 0), MPVOID);
474 }
475 if (msg == UM_CLICKED || msg == UM_CLICKED3)
476 return 0;
477 break;
[2]478
[551]479 case DM_DROP:
480 case DM_DRAGOVER:
481 case DM_DRAGLEAVE:
482 case DM_DROPHELP:
483 case WM_BEGINDRAG:
484 if (msg == DM_DRAGOVER) {
485 if (!emphasized) {
486 emphasized = TRUE;
487 DrawTargetEmphasis(hwnd, emphasized);
[2]488 }
[551]489 }
490 else if (msg != WM_BEGINDRAG) {
491 if (emphasized) {
492 emphasized = FALSE;
493 DrawTargetEmphasis(hwnd, emphasized);
[2]494 }
[551]495 }
496 switch (WinQueryWindowUShort(hwnd, QWS_ID)) {
497 case DIR_FOLDERICON:
498 switch (msg) {
499 case DM_DRAGOVER:
[618]500 if (AcceptOneDrop(hwnd, mp1, mp2))
[551]501 return MRFROM2SHORT(DOR_DROP, DO_MOVE);
[618]502 return (MRFROM2SHORT(DOR_NODROP, 0)); /* Drop not valid */
[551]503 case DM_DROPHELP:
504 DropHelp(mp1, mp2, hwnd, GetPString(IDS_DIRCNRFOLDERDROPHELP));
505 return 0;
506 case DM_DROP:
507 {
508 char szFrom[CCHMAXPATH + 2];
[2]509
[551]510 if (emphasized) {
511 emphasized = FALSE;
512 DrawTargetEmphasis(hwnd, emphasized);
513 }
[618]514 if (GetOneDrop(hwnd, mp1, mp2, szFrom, sizeof(szFrom)))
[551]515 WinSendMsg(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
516 DIR_CNR),
517 WM_COMMAND, MPFROM2SHORT(IDM_SWITCH, 0),
518 MPFROMP(szFrom));
519 }
520 return 0;
521 default:
522 return PFNWPStatic(hwnd, msg, mp1, mp2);
523 }
524 case DIR_MAX:
525 if (msg == WM_BEGINDRAG)
526 return PFNWPStatic(hwnd, msg, mp1, mp2);
527 default:
528 {
529 CNRDRAGINFO cnd;
530 USHORT dcmd;
[2]531
[551]532 switch (msg) {
533 case DM_DROP:
534 dcmd = CN_DROP;
535 break;
536 case DM_DRAGOVER:
537 dcmd = CN_DRAGOVER;
538 break;
539 case DM_DRAGLEAVE:
540 dcmd = CN_DRAGLEAVE;
541 break;
542 case DM_DROPHELP:
543 dcmd = CN_DROPHELP;
544 break;
545 case WM_BEGINDRAG:
546 dcmd = CN_INITDRAG;
547 break;
548 }
549 memset(&cnd, 0, sizeof(cnd));
550 cnd.pDragInfo = (PDRAGINFO) mp1;
551 cnd.pRecord = NULL;
552 return WinSendMsg(WinQueryWindow(hwnd, QW_PARENT),
553 WM_CONTROL,
554 MPFROM2SHORT(DIR_CNR, dcmd), MPFROMP(&cnd));
[2]555 }
[551]556 }
[2]557 }
[551]558 return PFNWPStatic(hwnd, msg, mp1, mp2);
[2]559}
560
[551]561MRESULT EXPENTRY DirClientWndProc(HWND hwnd, ULONG msg, MPARAM mp1,
562 MPARAM mp2)
[275]563{
[551]564 switch (msg) {
565 case UM_CONTAINERDIR:
566 if (mp1) {
[2]567
[551]568 DIRCNRDATA *dcd;
[2]569
[1009]570 *(CHAR *)mp1 = 0;
[551]571 dcd = WinQueryWindowPtr(WinWindowFromID(hwnd, DIR_CNR), QWL_USER);
572 if (dcd)
[1009]573 strcpy((CHAR *)mp1, dcd->directory);
[551]574 return MRFROMLONG(TRUE);
575 }
576 return 0;
[2]577
[551]578 case UM_CONTAINERHWND:
579 return MRFROMLONG(WinWindowFromID(hwnd, DIR_CNR));
[2]580
[551]581 case UM_VIEWSMENU:
[877]582 return MRFROMLONG(CheckMenu(hwnd, &DirCnrMenu, DIRCNR_POPUP));
[2]583
[551]584 case UM_DRIVECMD:
585 case WM_INITMENU:
586 case UM_FILTER:
587 case UM_INITMENU:
588 case MM_PORTHOLEINIT:
589 case UM_COMMAND:
590 case UM_FILESMENU:
591 case UM_UPDATERECORD:
592 case UM_UPDATERECORDLIST:
593 return WinSendMsg(WinWindowFromID(hwnd, DIR_CNR), msg, mp1, mp2);
[2]594
[551]595 case WM_PSETFOCUS:
596 case WM_SETFOCUS:
597 if (mp2)
598 PostMsg(hwnd, UM_FOCUSME, MPVOID, MPVOID);
599 break;
[2]600
[551]601 case UM_FOCUSME:
602 WinSetFocus(HWND_DESKTOP, WinWindowFromID(hwnd, DIR_CNR));
603 break;
[2]604
[551]605 case WM_PAINT:
606 {
607 HPS hps;
608 RECTL rcl;
[2]609
[551]610 hps = WinBeginPaint(hwnd, (HPS) 0, NULL);
611 if (hps) {
612 WinQueryWindowRect(hwnd, &rcl);
613 WinFillRect(hps, &rcl, CLR_PALEGRAY);
614 CommonTextPaint(hwnd, hps);
615 WinEndPaint(hps);
[2]616 }
[551]617 }
618 break;
[2]619
[551]620 case UM_SIZE:
621 case WM_SIZE:
622 if (msg == UM_SIZE) {
[2]623
[551]624 SWP swp;
[2]625
[551]626 WinQueryWindowPos(hwnd, &swp);
627 mp1 = MPFROM2SHORT(swp.cx, swp.cy);
628 mp2 = MPFROM2SHORT(swp.cx, swp.cy);
629 }
630 {
631 USHORT cx, cy, bx;
[2]632
[551]633 cx = SHORT1FROMMP(mp2);
634 cy = SHORT2FROMMP(mp2);
635 WinSetWindowPos(WinWindowFromID(hwnd, DIR_CNR), HWND_TOP,
636 0, 0, cx, cy - 24, SWP_SHOW | SWP_MOVE | SWP_SIZE);
637 if (WinWindowFromID(hwnd, DIR_MAX) != (HWND) 0) {
638 WinSetWindowPos(WinWindowFromID(hwnd, DIR_MAX), HWND_TOP,
639 cx - 22,
640 cy - 22, 20, 20, SWP_SHOW | SWP_MOVE | SWP_SIZE);
641 cx -= 24;
[2]642 }
[551]643 WinSetWindowPos(WinWindowFromID(hwnd, DIR_FOLDERICON), HWND_TOP,
644 2, cy - 22, 24, 20, SWP_SHOW | SWP_MOVE | SWP_SIZE);
645 WinSetWindowPos(WinWindowFromID(hwnd, DIR_TOTALS), HWND_TOP,
646 29,
647 cy - 22,
648 (cx / 3) - 2, 20, SWP_SHOW | SWP_MOVE | SWP_SIZE);
649 WinSetWindowPos(WinWindowFromID(hwnd, DIR_SELECTED), HWND_TOP,
650 29 + (cx / 3) + 2,
651 cy - 22,
652 (cx / 3) - 2, 20, SWP_SHOW | SWP_MOVE | SWP_SIZE);
653 bx = (cx - (29 + (((cx / 3) + 2) * 2))) / 3;
654 WinSetWindowPos(WinWindowFromID(hwnd, DIR_VIEW), HWND_TOP,
655 29 + (((cx / 3) + 2) * 2),
656 cy - 22, bx - 4, 20, SWP_SHOW | SWP_MOVE | SWP_SIZE);
657 WinSetWindowPos(WinWindowFromID(hwnd, DIR_SORT), HWND_TOP,
658 29 + (((cx / 3) + 2) * 2) + bx,
659 cy - 22, bx - 4, 20, SWP_SHOW | SWP_MOVE | SWP_SIZE);
660 WinSetWindowPos(WinWindowFromID(hwnd, DIR_FILTER), HWND_TOP,
661 29 + (((cx / 3) + 2) * 2) + (bx * 2),
662 cy - 22, bx - 4, 20, SWP_SHOW | SWP_MOVE | SWP_SIZE);
663 }
664 CommonTextPaint(hwnd, (HPS) 0);
665 if (msg == UM_SIZE) {
666 WinSetWindowPos(WinQueryWindow(hwnd, QW_PARENT), HWND_TOP, 0, 0, 0, 0,
667 SWP_SHOW | SWP_ZORDER | SWP_ACTIVATE);
668 return 0;
669 }
670 break;
[2]671
[551]672 case WM_COMMAND:
673 case WM_CONTROL:
674 case WM_CLOSE:
675 return WinSendMsg(WinWindowFromID(hwnd, DIR_CNR), msg, mp1, mp2);
[2]676 }
[551]677 return WinDefWindowProc(hwnd, msg, mp1, mp2);
[2]678}
679
[551]680MRESULT EXPENTRY DirObjWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
[150]681{
[2]682 DIRCNRDATA *dcd;
[1459]683 CHAR tf[64];
684 CHAR tb[64];
685 CHAR s[CCHMAXPATH * 2];
[2]686
[551]687 switch (msg) {
688 case WM_CREATE:
[1077]689 DbgMsg(pszSrcFile, __LINE__, "WM_CREATE mp1 %p mp2 %p", mp1, mp2); // 18 Jul 08 SHL fixme
[551]690 break;
[2]691
[551]692 case DM_PRINTOBJECT:
693 return MRFROMLONG(DRR_TARGET);
[2]694
[551]695 case DM_DISCARDOBJECT:
696 dcd = INSTDATA(hwnd);
697 if (fFM2Deletes && dcd) {
698 LISTINFO *li;
699 CNRDRAGINFO cni;
700 cni.pRecord = NULL;
701 cni.pDragInfo = (PDRAGINFO) mp1;
702 li =
703 DoFileDrop(dcd->hwndCnr, dcd->directory, FALSE, MPVOID,
[907]704 MPFROMP(&cni));
[687]705 CheckPmDrgLimit(cni.pDragInfo);
[551]706 if (li) {
707 li->type = (fDefaultDeletePerm) ? IDM_PERMDELETE : IDM_DELETE;
708 if (!PostMsg(hwnd, UM_MASSACTION, MPFROMP(li), MPVOID))
709 FreeListInfo(li);
710 else
711 return MRFROMLONG(DRR_SOURCE);
[2]712 }
[551]713 }
714 return MRFROMLONG(DRR_TARGET);
[2]715
[551]716 case UM_UPDATERECORDLIST:
717 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
718 if (dcd && mp1) {
[2]719
[551]720 INT numentries = 0;
721 CHAR **list = (CHAR **) mp1;
[2]722
[551]723 while (list[numentries])
724 numentries++;
725 if (numentries)
[1394]726 UpdateCnrList(dcd->hwndCnr, list, numentries, TRUE, dcd);
[551]727 }
728 return 0;
[2]729
[551]730 case UM_SETUP:
[1077]731# ifdef FORTIFY
[1113]732 //DbgMsg(pszSrcFile, __LINE__, "UM_SETUP hwnd %p TID %u", hwnd, GetTidForThread()); // 18 Jul 08 SHL fixme
[1077]733 Fortify_EnterScope();
734# endif
[551]735 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
736 if (dcd) {
[1077]737# ifdef FORTIFY
[1078]738 Fortify_BecomeOwner(dcd); // We free dcd
[1335]739 if (GetTidForThread() != 1)
740 Fortify_ChangeScope(dcd, -1);
[1077]741# endif
[551]742 /* set unique id */
743 WinSetWindowUShort(hwnd, QWS_ID, DIROBJ_FRAME + (DIR_FRAME - dcd->id));
744 dcd->hwndObject = hwnd;
745 if (ParentIsDesktop(hwnd, dcd->hwndParent))
[771]746 DosSleep(100); //05 Aug 07 GKY 250
[551]747 }
748 else
749 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
[1335]750# ifdef FORTIFY
751 // TID 1 will free data
752 if (GetTidForThread() != 1)
753 Fortify_LeaveScope();
754# endif
[551]755 return 0;
756
757 case UM_RESCAN2:
758 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
759 if (dcd && dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent)) {
760 FSALLOCATE fsa;
761 CHAR szFree[64];
762 DosError(FERR_DISABLEHARDERR);
763 if (!DosQueryFSInfo(toupper(*dcd->directory) - '@',
764 FSIL_ALLOC, &fsa, sizeof(FSALLOCATE))) {
765 CommaFmtULL(tb, sizeof(tb),
766 (ULONGLONG) fsa.cUnitAvail * (fsa.cSectorUnit *
767 fsa.cbSector), 'K');
768 sprintf(szFree, " {%s %s}", tb, GetPString(IDS_FREETEXT));
[2]769 }
770 else
[551]771 *szFree = 0;
772 commafmt(tf, sizeof(tf), dcd->totalfiles);
773 CommaFmtULL(tb, sizeof(tb), dcd->ullTotalBytes, ' ');
774 if (!fMoreButtons) {
775 sprintf(s, " [%s / %s]%s%s%s%s %s",
776 tf, tb, szFree,
777 (*dcd->mask.szMask || dcd->mask.antiattr ||
778 dcd->mask.attrFile != ALLATTRS) ? " (" : NullStr,
779 (*dcd->mask.szMask) ? dcd->mask.szMask :
780 (dcd->mask.antiattr ||
781 dcd->mask.attrFile != ALLATTRS) ?
782 GetPString(IDS_ALLTEXT) : NullStr,
783 (*dcd->mask.szMask || dcd->mask.antiattr ||
784 dcd->mask.attrFile != ALLATTRS) ? ")" : NullStr,
785 dcd->directory);
786 }
787 else {
788 sprintf(s, " [%s / %s]%s %s", tf, tb, szFree, dcd->directory);
789 }
790 if (dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent))
791 WinSetWindowText(hwndStatus, s);
792 }
793 return 0;
[2]794
[551]795 case UM_FLESH:
796 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
797 if (dcd) {
[2]798
[551]799 PCNRITEM pci, pciC;
[2]800
[551]801 pci = WinSendMsg(dcd->hwndCnr,
802 CM_QUERYRECORD,
803 MPVOID, MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
804 while (pci && (INT) pci != -1) {
805 if (pci->attrFile & FILE_DIRECTORY) {
806 pciC = WinSendMsg(dcd->hwndCnr,
807 CM_QUERYRECORD,
808 MPFROMP(pci),
809 MPFROM2SHORT(CMA_FIRSTCHILD, CMA_ITEMORDER));
[1455]810 if (!pciC) {
811 Stubby(dcd->hwndCnr, pci);
[551]812 }
[171]813 }
[551]814 pci = WinSendMsg(dcd->hwndCnr,
815 CM_QUERYRECORD,
[1335]816 MPFROMP(pci), MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
[2]817 }
[551]818 dcd->firsttree = TRUE;
819 }
820 return 0;
[2]821
[551]822 case UM_RESCAN:
823 /*
824 * populate container
825 */
826 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
827 if (dcd) {
[1303]828 //DosEnterCritSec(); //GKY 11-29-08
829 DosRequestMutexSem(hmtxFM2Globals, SEM_INDEFINITE_WAIT);
[551]830 if (dcd->stopflag)
831 dcd->stopflag--;
832 if (dcd->stopflag) {
[1335]833 DosReleaseMutexSem(hmtxFM2Globals);
834 //DosExitCritSec();
[551]835 return 0;
836 }
[1303]837 DosReleaseMutexSem(hmtxFM2Globals);
838 //DosExitCritSec();
[551]839 if (mp1) {
840 strcpy(dcd->previous, dcd->directory);
[1009]841 strcpy(dcd->directory, (CHAR *)mp1);
[551]842 }
843 MakeValidDir(dcd->directory);
844 {
845 sprintf(s,
846 "%s%s%s",
847 (ParentIsDesktop(dcd->hwndFrame, (HWND) 0)) ?
848 "VDir" :
849 NullStr,
850 (ParentIsDesktop(dcd->hwndFrame, (HWND) 0)) ?
851 (!dcd->dontclose) ?
852 " Master: " : ": " : NullStr, dcd->directory);
853 WinSetWindowText(dcd->hwndFrame, s);
854 WinSetWindowText(WinWindowFromID(dcd->hwndFrame, FID_TITLEBAR), s);
[2]855 }
[751]856 RemoveCnrItems(dcd->hwndCnr, NULL, 0, CMA_FREE | CMA_INVALIDATE | CMA_ERASE);
[1444]857 AdjustCnrColsForFSType(dcd->hwndCnr, dcd->directory, &dcd->ds, FALSE);
[551]858 dcd->ullTotalBytes = dcd->totalfiles =
859 dcd->selectedfiles = dcd->selectedbytes = 0;
860 WinSetDlgItemText(dcd->hwndClient, DIR_TOTALS, "0 / 0k");
861 WinSetDlgItemText(dcd->hwndClient, DIR_SELECTED, "0 / 0k");
862 if (hwndStatus &&
863 dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent)) {
[1459]864 WinSetWindowText(hwndStatus, GetPString(IDS_PLEASEWAITSCANNINGTEXT));
[551]865 if (hwndMain)
866 WinSendMsg(hwndMain, UM_LOADFILE, MPVOID, MPVOID);
867 }
868 if (fSwitchTree && hwndTree) {
[1459]869 // Keep drive tree in sync with directory container
[1335]870 PSZ pszTempDir = xstrdup(dcd->directory, pszSrcFile, __LINE__);
871 if (hwndMain) {
[1102]872 if (TopWindow(hwndMain, (HWND) 0) == dcd->hwndFrame && pszTempDir)
[1402]873 if (!PostMsg(hwndTree, UM_SHOWME, MPFROMP(pszTempDir), MPVOID))
[1335]874 free(pszTempDir);
[551]875 }
[1335]876 else {
877 if (pszTempDir)
[1402]878 if (!PostMsg(hwndTree, UM_SHOWME, MPFROMP(pszTempDir), MPVOID))
[1335]879 free(pszTempDir);
880 }
[551]881 }
882 dcd->firsttree = FALSE;
[1459]883 WinStartTimer(WinQueryAnchorBlock(hwnd), dcd->hwndCnr, ID_DIRCNR_TIMER, 500);
[551]884 // fixme to check errors
885 FillDirCnr(dcd->hwndCnr, dcd->directory, dcd, &dcd->ullTotalBytes);
[1459]886 WinStopTimer(WinQueryAnchorBlock(hwnd), dcd->hwndCnr, ID_DIRCNR_TIMER);
[551]887 PostMsg(dcd->hwndCnr, UM_RESCAN, MPVOID, MPVOID);
888 if (mp2 && !fLeaveTree && (dcd->flWindowAttr & CV_TREE)) {
889 ULONG flWindowAttr = dcd->flWindowAttr;
890 CNRINFO cnri;
[1459]891 flWindowAttr &= ~(CV_NAME | CV_TREE | CV_ICON | CV_DETAIL | CV_TEXT);
[551]892 if (dcd->lastattr) {
893 if (dcd->lastattr & CV_TEXT)
894 flWindowAttr |= CV_TEXT;
895 else if (dcd->lastattr & CV_DETAIL)
896 flWindowAttr |= CV_DETAIL;
897 else if (dcd->lastattr & CV_ICON)
898 flWindowAttr |= CV_ICON;
899 else
900 flWindowAttr |= CV_NAME;
901 }
902 else
903 flWindowAttr |= CV_NAME;
904 flWindowAttr |= CV_FLOW;
905 memset(&cnri, 0, sizeof(CNRINFO));
906 cnri.cb = sizeof(CNRINFO);
907 if (WinSendMsg(dcd->hwndCnr, CM_QUERYCNRINFO, MPFROMP(&cnri),
908 MPFROMLONG(sizeof(CNRINFO)))) {
909 dcd->flWindowAttr = cnri.flWindowAttr = flWindowAttr;
910 WinSendMsg(dcd->hwndCnr, CM_SETCNRINFO,
911 MPFROMP(&cnri), MPFROMLONG(CMA_FLWINDOWATTR));
912 SayView(WinWindowFromID(dcd->hwndClient,
913 DIR_VIEW), dcd->flWindowAttr);
914 }
915 }
916 if (dcd->flWindowAttr & CV_TREE)
917 PostMsg(dcd->hwndObject, UM_FLESH, MPVOID, MPVOID);
918 if (*dcd->previous) {
919 if (strlen(dcd->previous) > strlen(dcd->directory) &&
920 !strnicmp(dcd->directory, dcd->previous,
[787]921 strlen(dcd->directory)))
[907]922 {
[787]923 PCNRITEM pci = FindCnrRecord(dcd->hwndCnr,
[907]924 dcd->previous,
[787]925 NULL, TRUE, FALSE, TRUE);
[551]926 if (pci && (INT) pci != -1) {
[787]927 // make found item current (cursored) item
[551]928 WinSendMsg(dcd->hwndCnr, CM_SETRECORDEMPHASIS, MPFROMP(pci),
929 MPFROM2SHORT(TRUE, CRA_CURSORED));
930 /* make sure that record shows in viewport */
931 ShowCnrRecord(dcd->hwndCnr, (PMINIRECORDCORE) pci);
932 }
933 }
[2]934 }
[551]935 }
936 return 0;
[2]937
[551]938 case UM_COMMAND:
939 if (mp1) {
[2]940
[551]941 LISTINFO *li = (LISTINFO *) mp1;
[2]942
[551]943 switch (li->type) {
944 case IDM_DOITYOURSELF:
945 case IDM_APPENDTOCLIP:
[1084]946 case IDM_APPENDTOCLIPFILENAME:
[551]947 case IDM_SAVETOCLIP:
[1084]948 case IDM_SAVETOCLIPFILENAME:
[551]949 case IDM_ARCHIVE:
950 case IDM_ARCHIVEM:
951 case IDM_VIEWTEXT:
952 case IDM_VIEWBINARY:
953 case IDM_VIEWARCHIVE:
954 case IDM_VIEW:
955 case IDM_EDITTEXT:
956 case IDM_EDITBINARY:
957 case IDM_EDIT:
958 case IDM_OBJECT:
959 case IDM_SHADOW:
960 case IDM_SHADOW2:
961 case IDM_PRINT:
962 case IDM_ATTRS:
963 case IDM_DELETE:
964 case IDM_PERMDELETE:
965 case IDM_MCIPLAY:
966 case IDM_UPDATE:
967 if (PostMsg(hwnd, UM_MASSACTION, mp1, mp2))
968 return (MRESULT) TRUE;
969 break;
970 default:
971 if (PostMsg(hwnd, UM_ACTION, mp1, mp2))
972 return (MRESULT) TRUE;
[2]973 }
[551]974 }
975 return 0;
[2]976
[551]977 case UM_SELECT:
978 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
979 if (dcd) {
980 switch (SHORT1FROMMP(mp1)) {
981 case IDM_SELECTBOTH:
982 case IDM_SELECTONE:
983 case IDM_SELECTMORE:
984 case IDM_SELECTNEWER:
985 case IDM_SELECTOLDER:
986 case IDM_SELECTBIGGER:
987 case IDM_SELECTSMALLER:
988 case IDM_DESELECTBOTH:
989 case IDM_DESELECTONE:
990 case IDM_DESELECTMORE:
991 case IDM_DESELECTNEWER:
992 case IDM_DESELECTOLDER:
993 case IDM_DESELECTBIGGER:
994 case IDM_DESELECTSMALLER:
995 SpecialSelect2(dcd->hwndParent, SHORT1FROMMP(mp1));
996 break;
997 case IDM_SELECTLIST:
998 {
999 CHAR filename[CCHMAXPATH], *p, *pp;
1000 ULONG size;
[2]1001
[1395]1002 strcpy(filename, PCSZ_STARDOTLST);
[551]1003 size = CCHMAXPATH;
1004 PrfQueryProfileData(fmprof, appname, "SaveToListName",
1005 filename, &size);
1006 pp = strrchr(filename, '\\');
1007 if (!pp)
1008 pp = filename;
1009 p = strrchr(pp, '.');
1010 if (p && *(p + 1) && p > pp + 1) {
1011 if (pp > filename)
1012 pp++;
1013 *pp = '*';
1014 pp++;
1015 if (p > pp)
1016 memmove(pp, p, strlen(p) + 1);
1017 }
1018 if (insert_filename(hwnd, filename, FALSE, FALSE))
1019 SelectList(dcd->hwndCnr, TRUE, FALSE, FALSE, NULL, filename,
1020 NULL);
1021 }
1022 break;
1023 case IDM_SELECTALL:
1024 SelectAll(dcd->hwndCnr, TRUE, TRUE, NULL, NULL, FALSE);
1025 break;
1026 case IDM_DESELECTALL:
1027 DeselectAll(dcd->hwndCnr, TRUE, TRUE, NULL, NULL, FALSE);
1028 break;
1029 case IDM_SELECTALLFILES:
1030 SelectAll(dcd->hwndCnr, TRUE, FALSE, NULL, NULL, FALSE);
1031 break;
1032 case IDM_DESELECTALLFILES:
1033 DeselectAll(dcd->hwndCnr, TRUE, FALSE, NULL, NULL, FALSE);
1034 break;
1035 case IDM_SELECTALLDIRS:
1036 SelectAll(dcd->hwndCnr, FALSE, TRUE, NULL, NULL, FALSE);
1037 break;
1038 case IDM_DESELECTALLDIRS:
1039 DeselectAll(dcd->hwndCnr, FALSE, TRUE, NULL, NULL, FALSE);
1040 break;
1041 case IDM_DESELECTMASK:
1042 case IDM_SELECTMASK:
1043 {
1044 MASK mask;
1045 PCNRITEM pci = (PCNRITEM) mp2;
[2]1046
[551]1047 memset(&mask, 0, sizeof(MASK));
1048 mask.fNoAttribs = TRUE;
1049 mask.fNoDirs = TRUE;
1050 mask.fText = TRUE;
1051 strcpy(mask.prompt,
1052 GetPString((SHORT1FROMMP(mp1) == IDM_SELECTMASK) ?
1053 IDS_SELECTFILTERTEXT : IDS_DESELECTFILTERTEXT));
1054 if (pci && (INT) pci != -1)
[730]1055 strcpy(mask.szMask, pci->pszFileName);
[551]1056 if (WinDlgBox(HWND_DESKTOP,
1057 dcd->hwndCnr,
1058 PickMaskDlgProc,
1059 FM3ModHandle, MSK_FRAME, MPFROMP(&mask))) {
1060 if (SHORT1FROMMP(mp1) == IDM_SELECTMASK)
1061 SelectAll(dcd->hwndCnr,
1062 TRUE, TRUE, mask.szMask, mask.szText, FALSE);
1063 else
1064 DeselectAll(dcd->hwndCnr,
1065 TRUE, TRUE, mask.szMask, mask.szText, FALSE);
1066 }
1067 }
1068 break;
[2]1069
[551]1070 case IDM_DESELECTCLIP:
1071 case IDM_SELECTCLIP:
1072 {
1073 CHAR **list;
[2]1074
[551]1075 list = ListFromClipboard(hwnd);
1076 if (list) {
1077 SelectList(dcd->hwndCnr, TRUE, FALSE,
1078 (SHORT1FROMMP(mp1) == IDM_DESELECTCLIP),
1079 NULL, NULL, list);
1080 FreeList(list);
1081 }
1082 }
1083 break;
[2]1084
[551]1085 case IDM_INVERT:
1086 InvertAll(dcd->hwndCnr);
1087 break;
[2]1088 }
[551]1089 }
1090 return 0;
[2]1091
[551]1092 case UM_MASSACTION:
1093 if (mp1) {
1094 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
1095 if (dcd) {
1096 WORKER *wk;
[1077]1097# ifdef FORTIFY
1098 Fortify_EnterScope();
1099# endif
[551]1100 wk = xmallocz(sizeof(WORKER), pszSrcFile, __LINE__);
1101 if (!wk)
1102 FreeListInfo((LISTINFO *) mp1);
1103 else {
1104 wk->size = sizeof(WORKER);
1105 wk->hwndCnr = dcd->hwndCnr;
1106 wk->hwndParent = dcd->hwndParent;
1107 wk->hwndFrame = dcd->hwndFrame;
1108 wk->hwndClient = dcd->hwndClient;
1109 wk->li = (LISTINFO *) mp1;
1110 strcpy(wk->directory, dcd->directory);
[1335]1111 if (xbeginthread(MassAction,
1112 122880,
1113 wk,
1114 pszSrcFile,
1115 __LINE__) == -1)
1116 {
[1077]1117 free(wk);
[1335]1118 FreeListInfo((LISTINFO *)mp1);
[551]1119 }
1120 }
[1077]1121# ifdef FORTIFY
1122 DosSleep(1); // Allow MassAction to take ownership
1123 Fortify_LeaveScope();
1124# endif
[2]1125 }
[551]1126 }
1127 return 0;
[2]1128
[551]1129 case UM_ACTION:
1130 if (mp1) {
[2]1131
[551]1132 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
1133 if (dcd) {
[2]1134
[551]1135 WORKER *wk;
[1077]1136# ifdef FORTIFY
1137 Fortify_EnterScope();
1138# endif
[551]1139 wk = xmallocz(sizeof(WORKER), pszSrcFile, __LINE__);
1140 if (!wk)
1141 FreeListInfo((LISTINFO *) mp1);
1142 else {
1143 wk->size = sizeof(WORKER);
1144 wk->hwndCnr = dcd->hwndCnr;
1145 wk->hwndParent = dcd->hwndParent;
1146 wk->hwndFrame = dcd->hwndFrame;
1147 wk->hwndClient = dcd->hwndClient;
1148 wk->li = (LISTINFO *) mp1;
1149 strcpy(wk->directory, dcd->directory);
[1455]1150
[1335]1151 if (xbeginthread(Action,
1152 122880,
1153 wk,
1154 pszSrcFile,
1155 __LINE__) == -1)
1156 {
[551]1157 Runtime_Error(pszSrcFile, __LINE__,
1158 GetPString(IDS_COULDNTSTARTTHREADTEXT));
[1077]1159 free(wk);
[1018]1160 FreeListInfo((LISTINFO *) mp1);
[551]1161 }
1162 }
[1077]1163# ifdef FORTIFY
1164 Fortify_LeaveScope();
1165# endif
[2]1166 }
[551]1167 }
1168 return 0;
[2]1169
[551]1170 case WM_CLOSE:
1171 WinDestroyWindow(hwnd);
1172 break;
[2]1173
[551]1174 case WM_DESTROY:
[1078]1175# ifdef FORTIFY
[1079]1176 DbgMsg(pszSrcFile, __LINE__, "WM_DESTROY hwnd %p TID %u", hwnd, GetTidForThread()); // 18 Jul 08 SHL fixme
[1078]1177# endif
[551]1178 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
[1335]1179 if (!dcd)
[1398]1180 Runtime_Error(pszSrcFile, __LINE__, NULL);
[1335]1181 else {
[551]1182 if (dcd->hwndRestore)
1183 WinSetWindowPos(dcd->hwndRestore,
1184 HWND_TOP,
1185 0,
1186 0,
1187 0,
1188 0,
1189 SWP_RESTORE | SWP_SHOW | SWP_ACTIVATE | SWP_ZORDER);
1190 FreeList(dcd->lastselection);
[1009]1191 xfree(dcd, pszSrcFile, __LINE__);
[1017]1192 WinSetWindowPtr(dcd->hwndCnr, QWL_USER, NULL);
[551]1193 DosPostEventSem(CompactSem);
1194 }
[1335]1195# ifdef FORTIFY
1196 Fortify_LeaveScope();
1197# endif
1198 // 22 Jul 08 SHL fixme to understand
[551]1199 if (!PostMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID))
1200 WinSendMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID);
1201 break;
[2]1202 }
[551]1203 return WinDefWindowProc(hwnd, msg, mp1, mp2);
[2]1204}
1205
[551]1206MRESULT EXPENTRY DirCnrWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
[275]1207{
[672]1208 DIRCNRDATA *dcd = INSTDATA(hwnd);
[1459]1209 CHAR tf[64];
1210 CHAR tb[64];
1211 CHAR s[CCHMAXPATH];
[2]1212
[551]1213 switch (msg) {
[1077]1214 case WM_CREATE:
1215# ifdef FORTIFY
1216 Fortify_EnterScope();
1217# endif
1218 break;
1219
[551]1220 case DM_PRINTOBJECT:
1221 return MRFROMLONG(DRR_TARGET);
1222
1223 case DM_DISCARDOBJECT:
1224 if (dcd)
1225 return WinSendMsg(dcd->hwndObject, msg, mp1, mp2);
1226 else
[2]1227 return MRFROMLONG(DRR_TARGET);
1228
[551]1229 case WM_CHAR:
1230 shiftstate = (SHORT1FROMMP(mp1) & (KC_SHIFT | KC_ALT | KC_CTRL));
1231 if (SHORT1FROMMP(mp1) & KC_KEYUP)
1232 return (MRESULT) TRUE;
1233 if (SHORT1FROMMP(mp1) & KC_VIRTUALKEY) {
1234 switch (SHORT2FROMMP(mp2)) {
1235 case VK_INSERT:
1236 if ((shiftstate & KC_CTRL) == KC_CTRL)
1237 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_MKDIR, 0), MPVOID);
[1411]1238 // Alt-Insert - create file
[551]1239 else if ((shiftstate & KC_ALT) == KC_ALT)
1240 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_CREATE, 0), MPVOID);
1241 break;
1242 case VK_PAGEUP:
1243 if ((shiftstate & KC_CTRL) == KC_CTRL)
1244 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_PARENT, 0), MPVOID);
1245 break;
1246 case VK_PAGEDOWN:
1247 if ((shiftstate & KC_CTRL) == KC_CTRL)
1248 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_PREVIOUS, 0), MPVOID);
1249 break;
1250 case VK_HOME:
1251 if ((shiftstate & KC_CTRL) == KC_CTRL && dcd) {
[1459]1252 PSZ p;
[551]1253 strcpy(s, dcd->directory);
1254 p = strchr(s, '\\');
1255 if (p) {
1256 p++;
1257 *p = 0;
1258 WinSendMsg(hwnd, UM_SETDIR, MPFROMP(s), MPVOID);
1259 }
1260 }
1261 break;
1262 case VK_DELETE:
1263 if ((shiftstate & KC_CTRL) == KC_CTRL)
1264 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_PERMDELETE, 0), MPVOID);
1265 else if ((shiftstate & KC_SHIFT) == KC_SHIFT)
1266 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_SAVETOCLIP, 0), MPVOID);
1267 else
1268 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_DELETE, 0), MPVOID);
1269 break;
[1411]1270 } // switch
[551]1271 }
[2]1272
[1411]1273 if (SearchContainer(hwnd, msg, mp1, mp2))
1274 return (MRESULT)TRUE; // Avoid default handler
1275 break; // Let default handler see key too
[2]1276
[551]1277 case WM_MOUSEMOVE:
1278 case WM_BUTTON1UP:
1279 case WM_BUTTON2UP:
1280 case WM_BUTTON3UP:
1281 case WM_CHORD:
1282 shiftstate = (SHORT2FROMMP(mp2) & (KC_ALT | KC_SHIFT | KC_CTRL));
1283 break;
[2]1284
[551]1285 case WM_BUTTON1MOTIONEND:
1286 {
1287 CNRINFO cnri;
[2]1288
[551]1289 memset(&cnri, 0, sizeof(CNRINFO));
1290 cnri.cb = sizeof(CNRINFO);
1291 if (WinSendMsg(hwnd, CM_QUERYCNRINFO, MPFROMP(&cnri),
1292 MPFROMLONG(sizeof(CNRINFO)))) {
1293 if (cnri.flWindowAttr & CV_DETAIL)
1294 PrfWriteProfileData(fmprof, appname, "CnrSplitBar",
1295 (PVOID) & cnri.xVertSplitbar, sizeof(LONG));
[2]1296 }
[551]1297 }
1298 break;
[2]1299
[551]1300 case UM_COMPARE:
1301 if (dcd && mp1 && mp2) {
[2]1302
[551]1303 COMPARE *cmp;
[1009]1304 CHAR *leftdir = (CHAR *)mp1, *rightdir = (CHAR *)mp2;
[2]1305
[551]1306 if (!IsFile(leftdir) && !IsFile(rightdir)) {
[1077]1307# ifdef FORTIFY
1308 Fortify_EnterScope();
1309# endif
[551]1310 cmp = xmallocz(sizeof(COMPARE), pszSrcFile, __LINE__);
1311 if (cmp) {
1312 cmp->size = sizeof(COMPARE);
1313 strcpy(cmp->leftdir, leftdir);
1314 strcpy(cmp->rightdir, rightdir);
1315 cmp->hwndParent = dcd->hwndParent;
1316 cmp->dcd.hwndParent = dcd->hwndParent;
1317 WinDlgBox(HWND_DESKTOP,
1318 HWND_DESKTOP,
1319 CompareDlgProc, FM3ModHandle, COMP_FRAME, MPFROMP(cmp));
1320 }
[1077]1321# ifdef FORTIFY
1322 Fortify_LeaveScope();
1323# endif
[2]1324 }
[551]1325 }
1326 return 0;
[2]1327
[978]1328 case WM_PRESPARAMCHANGED:
[1400]1329 PresParamChanged(hwnd, PCSZ_DIRCNR, mp1, mp2);
[978]1330 break;
[2]1331
[551]1332 case UM_UPDATERECORDLIST:
1333 if (dcd && mp1)
1334 WinSendMsg(dcd->hwndObject, msg, mp1, mp2);
1335 return 0;
[2]1336
[551]1337 case UM_UPDATERECORD:
1338 if (dcd && mp1) {
[2]1339
[551]1340 CHAR *filename;
[2]1341
[551]1342 filename = mp1;
1343 if (filename)
1344 UpdateCnrRecord(hwnd, filename, TRUE, dcd);
1345 }
1346 return 0;
[2]1347
[551]1348 case WM_SETFOCUS:
[1444]1349 /* put name of our window (directory name) on status line */
1350 if (mp2) {
1351 // Getting focus
1352 if (dcd && hwndStatus) {
1353 /* put name of our window (directory name) on status line */
[1455]1354 PCNRITEM pci = NULL;
1355 if (fAutoView && hwndMain) {
1356 pci = WinSendMsg(hwnd, CM_QUERYRECORDEMPHASIS, MPFROMLONG(CMA_FIRST),
1357 MPFROMSHORT(CRA_CURSORED));
1358 if (pci && (INT) pci != -1 &&
1359 (!(driveflags[toupper(*pci->pszFileName) - 'A'] & DRIVE_SLOW)))
1360 WinSendMsg(hwndMain, UM_LOADFILE, MPFROMP(pci->pszFileName), MPVOID);
1361 else
1362 WinSendMsg(hwndMain, UM_LOADFILE, MPVOID, MPVOID);
1363 }
1364 if (*dcd->directory) {
1365 if (hwndMain)
1366 WinSendMsg(hwndMain,
1367 UM_SETUSERLISTNAME, MPFROMP(dcd->directory), MPVOID);
1368 else
1369 add_udir(FALSE, dcd->directory);
1370 }
1371
[551]1372 if (hwndMain)
1373 PostMsg(hwndMain, UM_ADVISEFOCUS, MPFROMLONG(dcd->hwndFrame), MPVOID);
1374 }
[1444]1375
[551]1376 LastDir = hwnd;
1377 PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
[1444]1378
[1102]1379 if (fSwitchTreeOnFocus && hwndTree && dcd && *dcd->directory) {
[1335]1380 PSZ pszTempDir = xstrdup(dcd->directory, pszSrcFile, __LINE__);
1381 if (pszTempDir) {
[1402]1382 if (!PostMsg(hwndTree, UM_SHOWME, MPFROMP(pszTempDir), MPVOID))
[1444]1383 free(pszTempDir); // Failed
[1335]1384 }
[1102]1385 }
[551]1386 }
1387 break;
[2]1388
[551]1389 case UM_SETDIR:
1390 if (dcd && mp1) {
[2]1391
[551]1392 CHAR fullname[CCHMAXPATH];
[2]1393
[551]1394 DosError(FERR_DISABLEHARDERR);
[1009]1395 if (!DosQueryPathInfo((CHAR *)mp1,
[551]1396 FIL_QUERYFULLNAME, fullname, sizeof(fullname))) {
1397 if (stricmp(dcd->directory, fullname)) {
1398 strcpy(dcd->previous, dcd->directory);
1399 strcpy(dcd->directory, fullname);
[1303]1400 //DosEnterCritSec(); //GKY 11-27-08
[551]1401 dcd->stopflag++;
[1303]1402 //DosExitCritSec();
[551]1403 if (!PostMsg(dcd->hwndObject, UM_RESCAN, MPVOID, MPFROMLONG(1L))) {
1404 strcpy(dcd->directory, dcd->previous);
[1303]1405 //DosEnterCritSec(); //GKY 11-27-08
[551]1406 dcd->stopflag--;
[1303]1407 //DosExitCritSec();
[551]1408 }
1409 else if (*dcd->directory) {
1410 if (hwndMain)
1411 WinSendMsg(hwndMain,
1412 UM_SETUSERLISTNAME, MPFROMP(dcd->directory), MPVOID);
1413 else
1414 add_udir(FALSE, dcd->directory);
1415 }
1416 }
[2]1417 }
[551]1418 }
1419 break;
[2]1420
[1459]1421 case WM_TIMER:
1422 // Started/stopped by DirObjWndPro
1423 // dcd = WinQueryWindowPtr(hwnd, QWL_USER);
1424 if (dcd) {
1425 commafmt(tb, sizeof(tb), dcd->totalfiles);
1426 CommaFmtULL(tf, sizeof(tf), dcd->ullTotalBytes, 'K');
1427 sprintf(s, "%s / %s", tb, tf);
1428 // DbgMsg(pszSrcFile, __LINE__, "WM_TIMER %s", s); // 15 Sep 09 SHL fixme debug
1429 WinSetDlgItemText(dcd->hwndClient, DIR_TOTALS, s);
1430 }
1431 break; // WM_TIMER
1432
[551]1433 case UM_RESCAN:
1434 if (dcd) {
[2]1435
[551]1436 CNRINFO cnri;
[1459]1437 CHAR szDate[DATE_BUF_BYTES];
[551]1438 PCNRITEM pci;
[2]1439
[551]1440 memset(&cnri, 0, sizeof(CNRINFO));
1441 cnri.cb = sizeof(CNRINFO);
1442 WinSendMsg(hwnd,
1443 CM_QUERYCNRINFO,
1444 MPFROMP(&cnri), MPFROMLONG(sizeof(CNRINFO)));
1445 cnri.pszCnrTitle = dcd->directory;
1446 WinSendMsg(hwnd,
1447 CM_SETCNRINFO, MPFROMP(&cnri), MPFROMLONG(CMA_CNRTITLE));
1448 dcd->totalfiles = cnri.cRecords;
1449 commafmt(tb, sizeof(tb), dcd->totalfiles);
1450 CommaFmtULL(tf, sizeof(tf), dcd->ullTotalBytes, 'K');
1451 sprintf(s, "%s / %s", tb, tf);
1452 WinSetDlgItemText(dcd->hwndClient, DIR_TOTALS, s);
1453 commafmt(tb, sizeof(tb), dcd->selectedfiles);
1454 CommaFmtULL(tf, sizeof(tf), dcd->selectedbytes, 'K');
1455 sprintf(s, "%s / %s", tb, tf);
1456 WinSetDlgItemText(dcd->hwndClient, DIR_SELECTED, s);
1457 if (hwndStatus &&
1458 dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent)) {
1459 PostMsg(dcd->hwndObject, UM_RESCAN2, MPVOID, MPVOID);
1460 if ((fSplitStatus && hwndStatus2) || fMoreButtons) {
1461 pci = WinSendMsg(hwnd,
1462 CM_QUERYRECORDEMPHASIS,
1463 MPFROMLONG(CMA_FIRST), MPFROMSHORT(CRA_CURSORED));
[1455]1464 if (pci && (INT) pci != -1) {
[551]1465 if (fSplitStatus && hwndStatus2) {
1466 CommaFmtULL(tb, sizeof(tb), pci->cbFile + pci->easize, ' ');
[1411]1467 if (!fMoreButtons) {
1468 DateFormat(szDate, pci->date);
[1395]1469 sprintf(s, " %s %s %02u%s%02u%s%02u [%s] %s",
[551]1470 tb,
[1395]1471 szDate,
[1411]1472 pci->time.hours,
1473 TimeSeparator,
1474 pci->time.minutes,
1475 TimeSeparator,
[551]1476 pci->time.seconds,
[1411]1477 pci->pszDispAttr, pci->pszFileName);
1478 }
[551]1479 else {
1480 *tf = 0;
1481 if (pci->cbFile + pci->easize > 1024) {
1482 CommaFmtULL(tf, sizeof(tf), pci->cbFile + pci->easize, 'K');
1483 }
1484 sprintf(s,
1485 GetPString(IDS_STATUSSIZETEXT),
1486 tb, *tf ? " (" : NullStr, tf, *tf ? ")" : NullStr);
1487 }
1488 WinSetWindowText(hwndStatus2, s);
1489 }
1490 else
1491 WinSetWindowText(hwndStatus2, NullStr);
1492 if (fMoreButtons) {
[1411]1493 WinSetWindowText(hwndName, pci->pszFileName);
1494 DateFormat(szDate, pci->date);
[1395]1495 sprintf(s, "%s %02u%s%02u%s%02u",
[1411]1496 szDate,
1497 pci->time.hours, TimeSeparator,
1498 pci->time.minutes, TimeSeparator,
1499 pci->time.seconds);
[551]1500 WinSetWindowText(hwndDate, s);
1501 WinSetWindowText(hwndAttr, pci->pszDispAttr);
1502 }
1503 }
1504 else {
1505 WinSetWindowText(hwndStatus2, NullStr);
1506 WinSetWindowText(hwndName, NullStr);
1507 WinSetWindowText(hwndDate, NullStr);
1508 WinSetWindowText(hwndAttr, NullStr);
1509 }
1510 }
[2]1511 }
[551]1512 }
1513 return 0;
[2]1514
[551]1515 case UM_SORTRECORD:
1516 if (dcd) {
[2]1517
[551]1518 CNRINFO cnri;
[2]1519
[551]1520 memset(&cnri, 0, sizeof(CNRINFO));
1521 cnri.cb = sizeof(CNRINFO);
1522 WinSendMsg(hwnd,
1523 CM_QUERYCNRINFO,
1524 MPFROMP(&cnri), MPFROMLONG(sizeof(CNRINFO)));
1525 cnri.pSortRecord = (PVOID) SortDirCnr;
1526 WinSendMsg(hwnd,
1527 CM_SETCNRINFO, MPFROMP(&cnri), MPFROMLONG(CMA_PSORTRECORD));
1528 WinSendMsg(hwnd,
1529 CM_SORTRECORD,
1530 MPFROMP(SortDirCnr), MPFROMLONG(dcd->sortFlags));
1531 }
1532 return 0;
[2]1533
[551]1534 case UM_SETUP:
1535 if (dcd) {
1536 if (!dcd->hwndObject) {
1537 /*
1538 * first time through -- set things up
1539 */
[2]1540
[551]1541 CNRINFO cnri;
[2]1542
[551]1543 memset(&cnri, 0, sizeof(CNRINFO));
1544 cnri.cb = sizeof(CNRINFO);
1545 WinSendMsg(hwnd,
1546 CM_QUERYCNRINFO,
1547 MPFROMP(&cnri), MPFROMLONG(sizeof(CNRINFO)));
1548 cnri.cyLineSpacing = 0;
1549 cnri.cxTreeIndent = 12L;
[2]1550
[551]1551 cnri.flWindowAttr &= (~(CV_TREE | CV_ICON | CV_DETAIL | CV_TEXT));
1552 cnri.flWindowAttr |= (CV_NAME | CA_DETAILSVIEWTITLES | CV_MINI |
1553 CV_FLOW);
1554 cnri.pSortRecord = (PVOID) SortDirCnr;
[2]1555
[551]1556 {
1557 ULONG size = sizeof(ULONG);
[2]1558
[551]1559 PrfQueryProfileData(fmprof,
1560 appname,
1561 "DirflWindowAttr",
1562 (PVOID) & cnri.flWindowAttr, &size);
1563 size = sizeof(MASK);
1564 if (!*dcd->mask.szMask &&
1565 !dcd->mask.attrFile && !dcd->mask.antiattr) {
1566 if (PrfQueryProfileSize(fmprof,
1567 appname, "DirFilter", &size) && size) {
1568 PrfQueryProfileData(fmprof,
1569 appname, "DirFilter", &dcd->mask, &size);
1570 SetMask(dcd->mask.szMask, &dcd->mask);
1571 }
1572 else
1573 dcd->mask.attrFile = (FILE_READONLY | FILE_NORMAL |
1574 FILE_ARCHIVED | FILE_DIRECTORY |
1575 FILE_HIDDEN | FILE_SYSTEM);
1576 }
1577 *(dcd->mask.prompt) = 0;
1578 }
1579 if (dcd->flWindowAttr)
1580 cnri.flWindowAttr = dcd->flWindowAttr;
1581 else
1582 dcd->flWindowAttr = cnri.flWindowAttr;
1583 cnri.flWindowAttr &= (~(CA_MIXEDTARGETEMPH | CA_ORDEREDTARGETEMPH |
1584 CA_TITLEREADONLY | CA_TITLESEPARATOR));
1585 cnri.flWindowAttr |= CV_FLOW;
1586 dcd->flWindowAttr |= CV_FLOW;
1587 if (WinWindowFromID(dcd->hwndFrame, FID_TITLEBAR))
1588 cnri.flWindowAttr &= (~CA_CONTAINERTITLE);
1589 else
1590 cnri.flWindowAttr |= CA_CONTAINERTITLE;
1591 if (!dcd->sortFlags)
1592 dcd->sortFlags = sortFlags;
1593 WinSendMsg(hwnd,
1594 CM_SETCNRINFO,
1595 MPFROMP(&cnri),
1596 MPFROMLONG(CMA_FLWINDOWATTR | CMA_LINESPACING |
1597 CMA_CXTREEINDENT | CMA_PSORTRECORD));
1598 SetCnrCols(hwnd, FALSE);
[1335]1599 if (xbeginthread(MakeObjWin,
1600 245760,
1601 dcd,
1602 pszSrcFile,
1603 __LINE__) == -1)
1604 {
[551]1605 Runtime_Error(pszSrcFile, __LINE__,
1606 GetPString(IDS_COULDNTSTARTTHREADTEXT));
1607 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
1608 return 0;
1609 }
1610 else
[771]1611 DosSleep(32); //05 Aug 07 GKY 64
[551]1612 WinEnableMenuItem(DirCnrMenu, IDM_FINDINTREE, (hwndTree != (HWND) 0));
[2]1613 }
[1444]1614 if (!fInitialDriveScan)
[1455]1615 PostMsg(hwnd, UM_SETUP2, MPVOID, MPVOID);
[551]1616 }
1617 else {
1618 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
[2]1619 return 0;
[551]1620 }
1621 return 0;
[2]1622
[923]1623 case UM_SETUP2:
[992]1624 if (dcd) {
[1065]1625 AdjustCnrColsForPref(hwnd, NULL, &dcd->ds, FALSE);
[992]1626 SayFilter(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
[1016]1627 DIR_FILTER), &dcd->mask, FALSE);
[992]1628 SaySort(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
[1016]1629 DIR_SORT), dcd->sortFlags, FALSE);
[992]1630 SayView(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
[1455]1631 DIR_VIEW), dcd->flWindowAttr);
[992]1632 } else
[923]1633 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
1634 return 0;
1635
[551]1636 case WM_MENUEND:
1637 if (dcd) {
[2]1638
[551]1639 HWND hwndMenu = (HWND) mp2;
[2]1640
[551]1641 if (hwndMenu == DirCnrMenu ||
[1016]1642 hwndMenu == FileMenu ||
1643 hwndMenu == DirMenu) {
[551]1644 MarkAll(hwnd, TRUE, FALSE, TRUE);
1645 if (dcd->cnremphasized) {
1646 WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPVOID,
1647 MPFROM2SHORT(FALSE, CRA_SOURCE));
1648 dcd->cnremphasized = FALSE;
1649 }
[2]1650 }
[551]1651 }
1652 break;
[2]1653
[551]1654 case UM_OPENWINDOWFORME:
1655 if (dcd) {
[1009]1656 if (mp1 && !IsFile((CHAR *)mp1)) {
[551]1657 OpenDirCnr(hwnd, dcd->hwndParent, dcd->hwndFrame, FALSE, (char *)mp1);
[2]1658 }
[1120]1659 else if (mp1 && IsFile(mp1) == 1 &&
[1335]1660 CheckDriveSpaceAvail(ArcTempRoot, ullDATFileSpaceNeeded, ullTmpSpaceNeeded) != 2) {
[551]1661 StartArcCnr(HWND_DESKTOP,
[1009]1662 dcd->hwndFrame, (CHAR *)mp1, 4, (ARC_TYPE *) mp2);
[551]1663 }
1664 }
1665 return 0;
[2]1666
[551]1667 case MM_PORTHOLEINIT:
1668 if (dcd) {
1669 switch (SHORT1FROMMP(mp1)) {
1670 case 0:
1671 case 1:
1672 {
1673 ULONG wmsg;
[2]1674
[551]1675 wmsg = (SHORT1FROMMP(mp1) == 0) ? UM_FILESMENU : UM_VIEWSMENU;
1676 PortholeInit((HWND) WinSendMsg(dcd->hwndClient,
1677 wmsg, MPVOID, MPVOID), mp1, mp2);
1678 }
1679 break;
[2]1680 }
[551]1681 }
1682 break;
[2]1683
[551]1684 case UM_INITMENU:
1685 case WM_INITMENU:
1686 if (dcd) {
1687 switch (SHORT1FROMMP(mp1)) {
1688 case IDM_FILESMENU:
[907]1689 CopyPresParams((HWND) mp2, hwndMainMenu);
1690 if (isalpha(*dcd->directory)) {
[551]1691 if (driveflags[toupper(*dcd->directory) - 'A'] & DRIVE_NOTWRITEABLE) {
1692 WinEnableMenuItem((HWND) mp2, IDM_MOVEMENU, FALSE);
1693 WinEnableMenuItem((HWND) mp2, IDM_RENAME, FALSE);
1694 WinEnableMenuItem((HWND) mp2, IDM_MKDIR, FALSE);
1695 WinEnableMenuItem((HWND) mp2, IDM_UNDELETE, FALSE);
1696 WinEnableMenuItem((HWND) mp2, IDM_DELETESUBMENU, FALSE);
1697 WinEnableMenuItem((HWND) mp2, IDM_DELETE, FALSE);
1698 WinEnableMenuItem((HWND) mp2, IDM_EDIT, FALSE);
1699 WinEnableMenuItem((HWND) mp2, IDM_EDITTEXT, FALSE);
1700 WinEnableMenuItem((HWND) mp2, IDM_EDITBINARY, FALSE);
1701 WinEnableMenuItem((HWND) mp2, IDM_ATTRS, FALSE);
1702 }
1703 else {
1704 WinEnableMenuItem((HWND) mp2, IDM_MOVEMENU, TRUE);
1705 WinEnableMenuItem((HWND) mp2, IDM_RENAME, TRUE);
1706 WinEnableMenuItem((HWND) mp2, IDM_MKDIR, TRUE);
1707 WinEnableMenuItem((HWND) mp2, IDM_UNDELETE, TRUE);
1708 WinEnableMenuItem((HWND) mp2, IDM_DELETESUBMENU, TRUE);
1709 WinEnableMenuItem((HWND) mp2, IDM_DELETE, TRUE);
1710 WinEnableMenuItem((HWND) mp2, IDM_EDIT, TRUE);
1711 WinEnableMenuItem((HWND) mp2, IDM_EDITTEXT, TRUE);
1712 WinEnableMenuItem((HWND) mp2, IDM_EDITBINARY, TRUE);
[907]1713 WinEnableMenuItem((HWND) mp2, IDM_ATTRS, TRUE);
[551]1714 }
1715 }
1716 break;
[2]1717
[551]1718 case IDM_VIEWSMENU:
[907]1719 SetViewMenu((HWND) mp2, dcd->flWindowAttr);
[877]1720 CopyPresParams((HWND) mp2, hwndMainMenu);
[907]1721 WinEnableMenuItem((HWND) mp2, IDM_RESELECT,
1722 (dcd->lastselection != NULL));
1723 if (isalpha(*dcd->directory)) {
[551]1724 if (driveflags[toupper(*dcd->directory) - 'A'] & DRIVE_NOTWRITEABLE)
1725 WinEnableMenuItem((HWND) mp2, IDM_MKDIR, FALSE);
1726 else
1727 WinEnableMenuItem((HWND) mp2, IDM_MKDIR, TRUE);
1728 }
1729 WinEnableMenuItem((HWND) mp2,
1730 IDM_SELECTCOMPAREMENU,
1731 (CountDirCnrs(dcd->hwndParent) > 1));
1732 break;
[2]1733
[551]1734 case IDM_DETAILSSETUP:
[1065]1735 SetDetailsSwitches((HWND) mp2, &dcd->ds);
[551]1736 break;
[2]1737
[551]1738 case IDM_COMMANDSMENU:
1739 SetupCommandMenu((HWND) mp2, hwnd);
1740 break;
[2]1741
[551]1742 case IDM_SORTSUBMENU:
1743 SetSortChecks((HWND) mp2, dcd->sortFlags);
1744 break;
[2]1745
[551]1746 case IDM_WINDOWSMENU:
1747 SetupWinList((HWND) mp2,
1748 (hwndMain) ? hwndMain : (HWND) 0, dcd->hwndFrame);
1749 break;
[2]1750 }
[551]1751 dcd->hwndLastMenu = (HWND) mp2;
1752 }
1753 if (msg == WM_INITMENU)
1754 break;
1755 return 0;
[2]1756
[551]1757 case UM_FILTER:
1758 if (dcd) {
[2]1759
[551]1760 PCNRITEM pci;
[2]1761
[551]1762 if (mp1) {
[1304]1763 //DosEnterCritSec(); // GKY 11-30-08 moved to SetMask
[1009]1764 SetMask((CHAR *)mp1, &dcd->mask);
[1304]1765 //DosExitCritSec();
[2]1766 }
[551]1767 dcd->suspendview = 1;
1768 WinSendMsg(hwnd, CM_FILTER, MPFROMP(Filter), MPFROMP(&dcd->mask));
1769 dcd->suspendview = 0;
1770 if (fAutoView && hwndMain) {
1771 pci = WinSendMsg(hwnd, CM_QUERYRECORDEMPHASIS,
1772 MPFROMLONG(CMA_FIRST), MPFROMSHORT(CRA_CURSORED));
1773 if (pci && (INT) pci != -1 &&
[730]1774 (!(driveflags[toupper(*pci->pszFileName) - 'A'] & DRIVE_SLOW)))
1775 WinSendMsg(hwndMain, UM_LOADFILE, MPFROMP(pci->pszFileName), MPVOID);
[551]1776 else
1777 WinSendMsg(hwndMain, UM_LOADFILE, MPVOID, MPVOID);
1778 }
1779 PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
1780 }
1781 return 0;
[2]1782
[551]1783 case UM_COMMAND:
1784 if (mp1) {
1785 if (dcd) {
1786 if (!PostMsg(dcd->hwndObject, UM_COMMAND, mp1, mp2)) {
[1400]1787 Runtime_Error(pszSrcFile, __LINE__, PCSZ_POSTMSG);
[551]1788 FreeListInfo((LISTINFO *) mp1);
1789 }
1790 else
1791 return (MRESULT) TRUE;
[2]1792 }
[551]1793 else
1794 FreeListInfo((LISTINFO *) mp1);
1795 }
1796 return 0;
[2]1797
[551]1798 case UM_NOTIFY:
1799 if (mp2)
[1009]1800 Notify((CHAR *)mp2);
[551]1801 return 0;
[2]1802
[551]1803 case UM_DRIVECMD:
1804 if (mp1)
1805 WinSendMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_SWITCH, 0), mp1);
1806 return 0;
[2]1807
[551]1808 case WM_COMMAND:
1809 DosError(FERR_DISABLEHARDERR);
1810 if (dcd) {
1811 switch (SHORT1FROMMP(mp1)) {
1812 case IDM_SETTARGET:
1813 SetTargetDir(hwnd, FALSE);
1814 break;
[2]1815
[551]1816 case IDM_CREATE:
1817 {
1818 STRINGINPARMS sip;
1819 CHAR filename[CCHMAXPATHCOMP];
[2]1820
[551]1821 memset(&sip, 0, sizeof(sip));
1822 sip.help = GetPString(IDS_CREATETEXT);
1823 sip.prompt = GetPString(IDS_CREATEPROMPTTEXT);
1824 sip.inputlen = CCHMAXPATHCOMP - (strlen(dcd->directory) - 1);
1825 strcpy(filename, "NEWFILE.TXT");
1826 sip.ret = filename;
1827 sip.title = GetPString(IDS_CREATETITLETEXT);
1828 if (WinDlgBox(HWND_DESKTOP, hwnd, InputDlgProc, FM3ModHandle,
1829 STR_FRAME, &sip)) {
1830 bstrip(sip.ret);
1831 if (*sip.ret) {
1832 CHAR newfile[CCHMAXPATH];
1833 FILE *fp;
1834 INT test;
1835 PCNRITEM pci;
[2]1836
[1455]1837 strcpy(newfile, dcd->directory);
1838 AddBackslashToPath(newfile);
[1438]1839 //if (newfile[strlen(newfile) - 1] != '\\')
1840 // strcat(newfile, "\\");
[551]1841 strcat(newfile, sip.ret);
1842 test = IsFile(newfile);
1843 if (test != 1)
1844 fp = fopen(newfile, "w");
1845 if (test != 1 && !fp) {
1846 saymsg(MB_ENTER,
1847 hwnd,
1848 GetPString(IDS_ERRORTEXT),
1849 GetPString(IDS_CREATEERRORTEXT), newfile);
1850 }
1851 else {
1852 if (fp) {
1853 WinSendMsg(hwnd, UM_UPDATERECORD, MPFROMP(newfile), MPVOID);
1854 fclose(fp);
1855 }
1856 if (*editor) {
[2]1857
[551]1858 CHAR *dummy[2];
[2]1859
[551]1860 dummy[0] = newfile;
1861 dummy[1] = NULL;
1862 ExecOnList(hwnd,
[907]1863 editor, WINDOWED | SEPARATE, NULL, dummy, NULL,
1864 pszSrcFile, __LINE__);
[551]1865 }
1866 else
1867 StartMLEEditor(dcd->hwndParent, 4, newfile, dcd->hwndFrame);
1868 pci = FindCnrRecord(hwnd, newfile, NULL, TRUE, FALSE, TRUE);
1869 if (pci && (INT) pci != -1)
1870 /* make sure that record shows in viewport */
1871 ShowCnrRecord(hwnd, (PMINIRECORDCORE) pci);
1872 }
1873 }
1874 }
1875 }
1876 break;
[2]1877
[551]1878 case IDM_CONTEXTMENU:
1879 {
1880 PCNRITEM pci;
[2]1881
[551]1882 pci = (PCNRITEM) CurrentRecord(hwnd);
1883 PostMsg(hwnd, WM_CONTROL, MPFROM2SHORT(DIR_CNR, CN_CONTEXTMENU),
1884 MPFROMP(pci));
1885 }
1886 break;
[2]1887
[551]1888 case IDM_MAXIMIZE:
1889 PostMsg(hwndMain, UM_MAXIMIZE, MPFROMLONG(dcd->hwndFrame), MPVOID);
1890 break;
[2]1891
[551]1892 case IDM_SHOWALLFILESCNR:
1893 StartSeeAll(HWND_DESKTOP, FALSE, dcd->directory);
1894 break;
[2]1895
[551]1896 case IDM_SHOWALLFILES:
1897 {
1898 PCNRITEM pci;
[2]1899
[551]1900 pci = WinSendMsg(hwnd, CM_QUERYRECORDEMPHASIS,
1901 MPFROMLONG(CMA_FIRST), MPFROMSHORT(CRA_CURSORED));
1902 if (pci && (INT) pci != -1) {
[2]1903
[551]1904 static CHAR dirname[CCHMAXPATH];
[2]1905
[730]1906 strcpy(dirname, pci->pszFileName);
[551]1907 MakeValidDir(dirname);
1908 StartSeeAll(HWND_DESKTOP, FALSE, dirname);
1909 }
1910 }
[1394]1911 break;
[2]1912
[551]1913 case IDM_FINDINTREE:
[1335]1914 if (hwndTree) {
1915 PSZ pszTempDir = xstrdup(dcd->directory, pszSrcFile, __LINE__);
[1102]1916
[1335]1917 if (pszTempDir) {
[1402]1918 if (!PostMsg(hwndTree, UM_SHOWME, MPFROMP(pszTempDir),
[1335]1919 MPFROMLONG(1L)))
1920 free(pszTempDir);
1921 }
1922 }
[551]1923 break;
[2]1924
[551]1925 case IDM_BEGINEDIT:
1926 OpenEdit(hwnd);
1927 break;
[2]1928
[551]1929 case IDM_ENDEDIT:
1930 WinSendMsg(hwnd, CM_CLOSEEDIT, MPVOID, MPVOID);
1931 break;
[2]1932
[551]1933 case IDM_SHOWSELECT:
1934 QuickPopup(hwnd,
1935 dcd,
[877]1936 CheckMenu(hwnd, &DirCnrMenu, DIRCNR_POPUP), IDM_SELECTSUBMENU);
[551]1937 break;
[2]1938
[551]1939 case IDM_SHOWSORT:
[877]1940 QuickPopup(hwnd, dcd, CheckMenu(hwnd, &DirCnrMenu, DIRCNR_POPUP),
[551]1941 IDM_SORTSUBMENU);
1942 break;
[2]1943
[551]1944 case IDM_VIEWORARC:
1945 {
1946 SWP swp;
1947 PCNRITEM pci;
[2]1948
[551]1949 pci = (PCNRITEM) WinSendMsg(hwnd, CM_QUERYRECORDEMPHASIS,
1950 MPFROMLONG(CMA_FIRST),
1951 MPFROMSHORT(CRA_CURSORED));
1952 if (pci && (INT) pci != -1) {
1953 WinQueryWindowPos(dcd->hwndFrame, &swp);
1954 DefaultViewKeys(hwnd,
1955 dcd->hwndFrame,
[730]1956 dcd->hwndParent, &swp, pci->pszFileName);
[551]1957 }
1958 }
1959 break;
[2]1960
[953]1961 case IDM_DIRCNRSETTINGS:
[551]1962 if (!ParentIsDesktop(dcd->hwndParent, dcd->hwndParent))
[917]1963 PostMsg(dcd->hwndParent, msg, MPFROMLONG(IDM_DIRCNRSETTINGS), mp2);
1964 else {
1965 WinDlgBox(HWND_DESKTOP,
1966 hwnd,
1967 CfgDlgProc,
1968 FM3ModHandle,
1969 CFG_FRAME,
1970 MPFROMLONG(IDM_DIRCNRSETTINGS));
1971 }
[551]1972 break;
[2]1973
[551]1974 case IDM_QTREE:
1975 case IDM_TREE:
1976 {
1977 CHAR newpath[CCHMAXPATH];
1978 APIRET rc;
1979 PCNRITEM pci;
[2]1980
[551]1981 if (SHORT1FROMMP(mp1) == IDM_TREE) {
1982 pci = (PCNRITEM) CurrentRecord(hwnd);
1983 if (pci && (INT) pci != -1)
[730]1984 strcpy(newpath, pci->pszFileName);
[551]1985 else
1986 strcpy(newpath, dcd->directory);
1987 }
1988 else
1989 strcpy(newpath, dcd->directory);
1990 MakeValidDir(newpath);
1991 rc = WinDlgBox(HWND_DESKTOP, dcd->hwndClient, ObjCnrDlgProc,
1992 FM3ModHandle, QTREE_FRAME, MPFROMP(newpath));
1993 if (rc)
1994 WinSendMsg(hwnd, UM_SETDIR, MPFROMP(newpath), MPVOID);
1995 }
1996 break;
[2]1997
[551]1998 case IDM_RESELECT:
1999 SelectList(hwnd, TRUE, FALSE, FALSE, NULL, NULL, dcd->lastselection);
2000 break;
[2]2001
[551]2002 case IDM_HELP:
2003 if (hwndHelp) {
2004 if (!ParentIsDesktop(dcd->hwndFrame, dcd->hwndParent))
2005 PostMsg(dcd->hwndParent, UM_COMMAND, mp1, mp2);
2006 else
2007 WinSendMsg(hwndHelp, HM_HELP_CONTENTS, MPVOID, MPVOID);
2008 }
2009 break;
[2]2010
[551]2011 case IDM_WINDOWDLG:
2012 if (!ParentIsDesktop(dcd->hwndFrame, dcd->hwndParent))
2013 PostMsg(dcd->hwndParent, UM_COMMAND,
2014 MPFROM2SHORT(IDM_WINDOWDLG, 0), MPVOID);
2015 break;
[2]2016
[551]2017 case IDM_SORTSMARTNAME:
2018 case IDM_SORTNAME:
2019 case IDM_SORTFILENAME:
2020 case IDM_SORTSIZE:
2021 case IDM_SORTEASIZE:
2022 case IDM_SORTFIRST:
2023 case IDM_SORTLAST:
2024 case IDM_SORTLWDATE:
2025 case IDM_SORTLADATE:
2026 case IDM_SORTCRDATE:
2027 case IDM_SORTSUBJECT:
2028 dcd->sortFlags &= (SORT_REVERSE | SORT_DIRSFIRST | SORT_DIRSLAST);
2029 case IDM_SORTDIRSFIRST:
2030 case IDM_SORTDIRSLAST:
2031 case IDM_SORTREVERSE:
2032 switch (SHORT1FROMMP(mp1)) {
2033 case IDM_SORTSUBJECT:
2034 dcd->sortFlags |= SORT_SUBJECT;
2035 break;
2036 case IDM_SORTSMARTNAME:
2037 case IDM_SORTFILENAME:
2038 dcd->sortFlags |= SORT_FILENAME;
2039 break;
2040 case IDM_SORTSIZE:
2041 dcd->sortFlags |= SORT_SIZE;
2042 break;
2043 case IDM_SORTEASIZE:
2044 dcd->sortFlags |= SORT_EASIZE;
2045 break;
2046 case IDM_SORTFIRST:
2047 dcd->sortFlags |= SORT_FIRSTEXTENSION;
2048 break;
2049 case IDM_SORTLAST:
2050 dcd->sortFlags |= SORT_LASTEXTENSION;
2051 break;
2052 case IDM_SORTLWDATE:
2053 dcd->sortFlags |= SORT_LWDATE;
2054 break;
2055 case IDM_SORTLADATE:
2056 dcd->sortFlags |= SORT_LADATE;
2057 break;
2058 case IDM_SORTCRDATE:
2059 dcd->sortFlags |= SORT_CRDATE;
2060 break;
2061 case IDM_SORTDIRSFIRST:
2062 if (dcd->sortFlags & SORT_DIRSFIRST)
2063 dcd->sortFlags &= (~SORT_DIRSFIRST);
2064 else {
2065 dcd->sortFlags |= SORT_DIRSFIRST;
2066 dcd->sortFlags &= (~SORT_DIRSLAST);
2067 }
2068 break;
2069 case IDM_SORTDIRSLAST:
2070 if (dcd->sortFlags & SORT_DIRSLAST)
2071 dcd->sortFlags &= (~SORT_DIRSLAST);
2072 else {
2073 dcd->sortFlags |= SORT_DIRSLAST;
2074 dcd->sortFlags &= (~SORT_DIRSFIRST);
2075 }
2076 break;
2077 case IDM_SORTREVERSE:
2078 if (dcd->sortFlags & SORT_REVERSE)
2079 dcd->sortFlags &= (~SORT_REVERSE);
2080 else
2081 dcd->sortFlags |= SORT_REVERSE;
2082 break;
2083 }
2084 WinSendMsg(hwnd, CM_SORTRECORD, MPFROMP(SortDirCnr),
2085 MPFROMLONG(dcd->sortFlags));
2086 SaySort(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
2087 DIR_SORT), dcd->sortFlags, FALSE);
2088 break;
[2]2089
[551]2090 case IDM_COLLECT:
[1350]2091 case IDM_GREP:
[551]2092 if (!Collector) {
[2]2093
[551]2094 HWND hwndC;
2095 SWP swp;
[2]2096
[551]2097 if (!ParentIsDesktop(hwnd, dcd->hwndParent) && !fAutoTile &&
2098 (!fExternalCollector && !strcmp(realappname, FM3Str)))
2099 GetNextWindowPos(dcd->hwndParent, &swp, NULL, NULL);
2100 hwndC = StartCollector((fExternalCollector ||
2101 strcmp(realappname, FM3Str)) ?
2102 HWND_DESKTOP : dcd->hwndParent, 4);
2103 if (hwndC) {
2104 if (!ParentIsDesktop(hwnd, dcd->hwndParent) && !fAutoTile &&
2105 (!fExternalCollector && !strcmp(realappname, FM3Str)))
2106 WinSetWindowPos(hwndC, HWND_TOP, swp.x, swp.y,
2107 swp.cx, swp.cy, SWP_MOVE | SWP_SIZE |
2108 SWP_SHOW | SWP_ZORDER);
2109 else if (!ParentIsDesktop(hwnd, dcd->hwndParent) && fAutoTile &&
2110 !strcmp(realappname, FM3Str))
2111 TileChildren(dcd->hwndParent, TRUE);
2112 WinSetWindowPos(hwndC, HWND_TOP, 0, 0, 0, 0, SWP_ACTIVATE);
[771]2113 DosSleep(100); //05 Aug 07 GKY 250
[551]2114 }
2115 }
2116 else
[1394]2117 StartCollector(dcd->hwndParent, 4);
2118 if (SHORT1FROMMP(mp1) == IDM_GREP) {
2119 PCNRITEM pci = NULL;
[1366]2120
[1394]2121 pci = WinSendMsg(hwnd,
2122 CM_QUERYRECORDEMPHASIS,
2123 MPFROMLONG(CMA_FIRST), MPFROMSHORT(CRA_CURSORED));
2124 if (pci && (INT) pci != -1)
2125 PostMsg(Collector, WM_COMMAND,
2126 MPFROM2SHORT(IDM_GREP, 0), MPFROMP(pci->pszFileName));
2127 else
2128 PostMsg(Collector, WM_COMMAND,
2129 MPFROM2SHORT(IDM_GREP, 0), MPVOID);
2130 }
2131 else
[1350]2132 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_COLLECTOR, 0), MPVOID);
[551]2133 break;
[2]2134
[551]2135 case IDM_COLLECTOR:
[771]2136 DosSleep(32); //05 Aug 07 GKY 64
[551]2137 {
2138 CHAR **list;
[2]2139
[551]2140 list = BuildList(hwnd);
2141 if (list) {
2142 if (Collector) {
2143 if (!PostMsg(Collector,
2144 WM_COMMAND,
2145 MPFROM2SHORT(IDM_COLLECTOR, 0), MPFROMP(list)))
2146 FreeList(list);
2147 else if (fUnHilite)
[672]2148 UnHilite(hwnd, TRUE, &dcd->lastselection, 0);
[551]2149 }
2150 else
2151 FreeList(list);
2152 }
2153 }
2154 break;
[2]2155
[551]2156 case IDM_UNDELETE:
2157 {
2158 PCNRITEM pci;
[1077]2159 CHAR path[CCHMAXPATH];
2160 HOBJECT hObject;
2161 HWND hwndDesktop;
[2]2162
[1077]2163 hObject = WinQueryObject("<XWP_TRASHCAN>");
2164 if (hObject != NULLHANDLE && fTrashCan) {
2165 hwndDesktop = WinQueryDesktopWindow((HAB) 0, NULLHANDLE);
[1041]2166 WinSetFocus(HWND_DESKTOP, hwndDesktop);
[1077]2167 WinOpenObject(hObject, 0, TRUE);
[551]2168 }
[1077]2169 else {
2170 pci = (PCNRITEM) CurrentRecord(hwnd);
2171 if (pci && (INT) pci != -1) {
2172 strcpy(path, pci->pszFileName);
2173 MakeValidDir(path);
2174 WinDlgBox(HWND_DESKTOP, hwnd, UndeleteDlgProc, FM3ModHandle,
2175 UNDEL_FRAME, MPFROMP(path));
2176 }
2177 }
[551]2178 }
2179 break;
[2]2180
[551]2181 case IDM_UNDELETESPEC:
[1077]2182 {
2183 HOBJECT hObject;
2184 HWND hwndDesktop;
[2]2185
[1077]2186 hObject = WinQueryObject("<XWP_TRASHCAN>");
2187 if (hObject != NULLHANDLE && fTrashCan) {
2188 hwndDesktop = WinQueryDesktopWindow((HAB) 0, NULLHANDLE);
[1041]2189 WinSetFocus(HWND_DESKTOP, hwndDesktop);
[1077]2190 WinOpenObject(hObject, 0, TRUE);
2191 }
2192 else
[1041]2193 WinDlgBox(HWND_DESKTOP,
2194 hwnd,
2195 UndeleteDlgProc,
[1077]2196 FM3ModHandle, UNDEL_FRAME, MPFROMP(dcd->directory));
2197 }
2198 break;
[1041]2199
[551]2200 case IDM_RESORT:
[930]2201// WinSendMsg(hwnd,
2202// CM_SORTRECORD,
2203// MPFROMP(SortDirCnr),
2204// MPFROMLONG((fSyncUpdates) ? sortFlags : dcd->sortFlags));
[551]2205 WinSendMsg(hwnd,
2206 CM_SORTRECORD,
2207 MPFROMP(SortDirCnr), MPFROMLONG(dcd->sortFlags));
2208 break;
[2]2209
[551]2210 case IDM_FILTER:
2211 {
2212 BOOL empty = FALSE;
2213 PCNRITEM pci;
2214 CHAR *p;
[2]2215
[551]2216 if (!*dcd->mask.szMask) {
2217 empty = TRUE;
2218 pci = (PCNRITEM) CurrentRecord(hwnd);
2219 if (pci && !(pci->attrFile & FILE_DIRECTORY)) {
[730]2220 p = strrchr(pci->pszFileName, '\\');
[551]2221 if (p) {
2222 p++;
2223 strcpy(dcd->mask.szMask, p);
2224 }
2225 }
2226 }
2227 *(dcd->mask.prompt) = 0;
[2]2228
[551]2229 if (WinDlgBox(HWND_DESKTOP, hwnd, PickMaskDlgProc,
2230 FM3ModHandle, MSK_FRAME, MPFROMP(&dcd->mask)))
2231 WinSendMsg(hwnd, UM_FILTER, MPVOID, MPVOID);
2232 else if (empty)
2233 *dcd->mask.szMask = 0;
2234 SayFilter(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
2235 DIR_FILTER), &dcd->mask, FALSE);
2236 }
[1016]2237 break;
[2]2238
[958]2239 case IDM_UNHIDEALL:
[1016]2240 WinSendMsg(hwnd, CM_FILTER, MPFROMP(Filter), MPFROMP(&dcd->mask));
2241 break;
[958]2242
[551]2243 case IDM_HIDEALL:
2244 if (fAutoView && hwndMain)
2245 PostMsg(hwndMain, UM_LOADFILE, MPVOID, MPVOID);
2246 dcd->suspendview = 1;
2247 HideAll(hwnd);
2248 dcd->suspendview = 0;
2249 PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
2250 break;
[2]2251
[551]2252 case IDM_SELECTBOTH:
2253 case IDM_SELECTONE:
2254 case IDM_SELECTMORE:
2255 case IDM_SELECTNEWER:
2256 case IDM_SELECTOLDER:
2257 case IDM_SELECTBIGGER:
2258 case IDM_SELECTSMALLER:
2259 case IDM_DESELECTBOTH:
2260 case IDM_DESELECTONE:
2261 case IDM_DESELECTMORE:
2262 case IDM_DESELECTNEWER:
2263 case IDM_DESELECTOLDER:
2264 case IDM_DESELECTBIGGER:
2265 case IDM_DESELECTSMALLER:
2266 if (ParentIsDesktop(hwnd, dcd->hwndParent)) {
2267 Runtime_Error(pszSrcFile, __LINE__, "ParentIsDesktop unexpected");
2268 break;
2269 }
2270 case IDM_SELECTLIST:
2271 case IDM_SELECTALL:
2272 case IDM_DESELECTALL:
2273 case IDM_SELECTALLFILES:
2274 case IDM_DESELECTALLFILES:
2275 case IDM_SELECTALLDIRS:
2276 case IDM_DESELECTALLDIRS:
2277 case IDM_SELECTMASK:
2278 case IDM_DESELECTMASK:
2279 case IDM_INVERT:
2280 case IDM_SELECTCLIP:
2281 case IDM_DESELECTCLIP:
2282 {
2283 PCNRITEM pci;
[2]2284
[551]2285 pci = (PCNRITEM) CurrentRecord(hwnd);
2286 if ((INT) pci == -1)
2287 pci = NULL;
2288 if (SHORT1FROMMP(mp1) == IDM_HIDEALL) {
2289 if (pci) {
2290 if (!(pci->rc.flRecordAttr & CRA_SELECTED))
2291 pci->rc.flRecordAttr |= CRA_FILTERED;
2292 WinSendMsg(hwnd, CM_INVALIDATERECORD, MPFROMP(&pci),
2293 MPFROM2SHORT(1, CMA_ERASE | CMA_REPOSITION));
2294 break;
2295 }
2296 }
2297 PostMsg(dcd->hwndObject, UM_SELECT, mp1, MPFROMP(pci));
2298 }
2299 break;
[2]2300
[551]2301 case IDM_RESCAN:
[1303]2302 //DosEnterCritSec(); //GKY 11-27-08
[551]2303 dcd->stopflag++;
[1303]2304 //DosExitCritSec();
[551]2305 if (!PostMsg(dcd->hwndObject, UM_RESCAN, MPVOID, MPVOID)) {
[1303]2306 //DosEnterCritSec(); //GKY 11-27-08
[551]2307 dcd->stopflag--;
[1303]2308 //DosExitCritSec();
[551]2309 }
2310 break;
[2]2311
[551]2312 case IDM_SHOWLNAMES:
2313 case IDM_SHOWSUBJECT:
2314 case IDM_SHOWEAS:
2315 case IDM_SHOWSIZE:
2316 case IDM_SHOWICON:
2317 case IDM_SHOWLWDATE:
2318 case IDM_SHOWLWTIME:
2319 case IDM_SHOWLADATE:
2320 case IDM_SHOWLATIME:
2321 case IDM_SHOWCRDATE:
2322 case IDM_SHOWCRTIME:
2323 case IDM_SHOWATTR:
2324 AdjustDetailsSwitches(hwnd,
2325 dcd->hwndLastMenu,
2326 SHORT1FROMMP(mp1),
[1065]2327 dcd->directory, NULL, &dcd->ds, FALSE);
[551]2328 break;
[2]2329
[551]2330 case IDM_TREEVIEW:
2331 case IDM_ICON:
2332 case IDM_TEXT:
2333 case IDM_DETAILS:
2334 case IDM_NAME:
2335 case IDM_MINIICONS:
2336 case IDM_DETAILSTITLES:
2337 {
2338 CNRINFO cnri;
[2]2339
[551]2340 memset(&cnri, 0, sizeof(CNRINFO));
2341 cnri.cb = sizeof(CNRINFO);
2342 WinSendMsg(hwnd, CM_QUERYCNRINFO, MPFROMP(&cnri),
2343 MPFROMLONG(sizeof(CNRINFO)));
2344 switch (SHORT1FROMMP(mp1)) {
2345 case IDM_TREEVIEW:
2346 if (!(cnri.flWindowAttr & CV_TREE))
2347 dcd->lastattr = cnri.flWindowAttr;
2348 cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT |
2349 CV_DETAIL | CV_NAME | CA_TREELINE));
2350 cnri.flWindowAttr |= CA_TREELINE | CV_TREE | CV_ICON;
2351 if (!dcd->firsttree)
2352 PostMsg(dcd->hwndObject, UM_FLESH, MPVOID, MPVOID);
2353 break;
2354 case IDM_ICON:
2355 cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT |
2356 CV_DETAIL | CV_NAME | CA_TREELINE));
2357 cnri.flWindowAttr |= CV_ICON;
2358 break;
2359 case IDM_NAME:
2360 cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT |
2361 CV_DETAIL | CV_NAME | CA_TREELINE));
2362 cnri.flWindowAttr |= CV_NAME;
2363 break;
2364 case IDM_TEXT:
2365 cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT |
2366 CV_DETAIL | CV_NAME | CA_TREELINE));
2367 cnri.flWindowAttr |= CV_TEXT;
2368 break;
2369 case IDM_DETAILS:
2370 cnri.flWindowAttr &= (~(CV_ICON | CV_TREE | CV_TEXT |
2371 CV_DETAIL | CV_NAME | CA_TREELINE));
2372 cnri.flWindowAttr |= CV_DETAIL;
2373 break;
2374 case IDM_MINIICONS:
2375 if (cnri.flWindowAttr & CV_MINI)
2376 cnri.flWindowAttr &= (~CV_MINI);
2377 else
2378 cnri.flWindowAttr |= CV_MINI;
2379 break;
2380 case IDM_DETAILSTITLES:
2381 if (cnri.flWindowAttr & CA_DETAILSVIEWTITLES)
2382 cnri.flWindowAttr &= (~CA_DETAILSVIEWTITLES);
2383 else
2384 cnri.flWindowAttr |= CA_DETAILSVIEWTITLES;
2385 break;
2386 }
2387 cnri.flWindowAttr &= (~(CA_ORDEREDTARGETEMPH | CA_MIXEDTARGETEMPH));
2388 cnri.flWindowAttr |= CV_FLOW;
2389 dcd->flWindowAttr = cnri.flWindowAttr;
2390 WinSendMsg(hwnd, CM_SETCNRINFO, MPFROMP(&cnri),
2391 MPFROMLONG(CMA_FLWINDOWATTR));
2392 WinSendMsg(hwnd, CM_INVALIDATERECORD, MPVOID,
2393 MPFROM2SHORT(0, CMA_ERASE | CMA_REPOSITION));
2394 SayView(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
2395 DIR_VIEW), dcd->flWindowAttr);
2396 }
2397 break;
[2]2398
[551]2399 case IDM_SAVETOLIST:
2400 WinDlgBox(HWND_DESKTOP, hwnd, SaveListDlgProc, FM3ModHandle,
2401 SAV_FRAME, MPFROMP(&hwnd));
2402 break;
[2]2403
[551]2404 case IDM_SIZES:
2405 {
2406 PCNRITEM pci;
2407 CHAR path[CCHMAXPATH];
[2]2408
[551]2409 pci = (PCNRITEM) CurrentRecord(hwnd);
2410 if (pci && (INT) pci != -1)
[730]2411 strcpy(path, pci->pszFileName);
[551]2412 else
2413 strcpy(path, dcd->directory);
2414 MakeValidDir(path);
2415 WinDlgBox(HWND_DESKTOP,
2416 HWND_DESKTOP, DirSizeProc, FM3ModHandle, DSZ_FRAME, path);
2417 }
2418 break;
[2]2419
[551]2420 case IDM_MKDIR:
2421 {
[907]2422 PCNRITEM pci;
2423 BOOL saved;
[2]2424
[907]2425 saved = fSelectedAlways;
2426 fSelectedAlways = FALSE;
2427 pci = (PCNRITEM)CurrentRecord(hwnd);
2428 // 01 Oct 07 SHL Make below selected directory or in current directory
[551]2429 PMMkDir(dcd->hwndParent,
[907]2430 pci && (INT)pci != -1 ? pci->pszFileName : dcd->directory,
2431 FALSE);
2432 fSelectedAlways = saved;
[551]2433 }
2434 break;
[2]2435
[551]2436 case IDM_SWITCH:
[1455]2437 if (mp2) {
[551]2438 strcpy(dcd->previous, dcd->directory);
[1455]2439 strcpy(dcd->directory, (CHAR *)mp2);
[1303]2440 //DosEnterCritSec(); // GKY 11-27-08
[551]2441 dcd->stopflag++;
[1455]2442 //DosExitCritSec();
[551]2443 if (!PostMsg(dcd->hwndObject, UM_RESCAN, MPVOID, MPFROMLONG(1L))) {
2444 strcpy(dcd->directory, dcd->previous);
[1303]2445 //DosEnterCritSec(); // GKY 11-27-08
[551]2446 dcd->stopflag--;
[1303]2447 //DosExitCritSec();
[551]2448 }
2449 else if (*dcd->directory) {
2450 if (hwndMain)
2451 WinSendMsg(hwndMain,
2452 UM_SETUSERLISTNAME, MPFROMP(dcd->directory), MPVOID);
2453 else
2454 add_udir(FALSE, dcd->directory);
2455 }
2456 }
2457 break;
[2]2458
[551]2459 case IDM_PARENT:
2460 {
2461 CHAR tempname1[CCHMAXPATH], tempname2[CCHMAXPATH];
[2]2462
[1455]2463 strcpy(tempname1, dcd->directory);
2464 AddBackslashToPath(tempname1);
[1438]2465 //if (tempname1[strlen(tempname1) - 1] != '\\')
2466 // strcat(tempname1, "\\");
[551]2467 strcat(tempname1, "..");
2468 DosError(FERR_DISABLEHARDERR);
2469 if (!DosQueryPathInfo(tempname1,
2470 FIL_QUERYFULLNAME,
2471 tempname2, sizeof(tempname2))) {
2472 if (stricmp(dcd->directory, tempname2)) {
2473 strcpy(dcd->previous, dcd->directory);
2474 strcpy(dcd->directory, tempname2);
[1303]2475 //DosEnterCritSec(); // GKY 11-27-08
[551]2476 dcd->stopflag++;
[1303]2477 //DosExitCritSec();
[551]2478 if (!PostMsg(dcd->hwndObject,
2479 UM_RESCAN, MPVOID, MPFROMLONG(1L))) {
2480 strcpy(dcd->directory, dcd->previous);
[1303]2481 //DosEnterCritSec();// GKY 11-27-08
[551]2482 dcd->stopflag--;
[1303]2483 //DosExitCritSec();
[551]2484 }
2485 else if (*dcd->directory) {
2486 if (hwndMain)
2487 WinSendMsg(hwndMain,
2488 UM_SETUSERLISTNAME,
2489 MPFROMP(dcd->directory), MPVOID);
2490 else
2491 add_udir(FALSE, dcd->directory);
2492 }
2493 }
2494 }
2495 }
2496 break;
[2]2497
[551]2498 case IDM_PREVIOUS:
2499 if (*dcd->previous && stricmp(dcd->directory, dcd->previous)) {
[2]2500
[551]2501 CHAR tempname[CCHMAXPATH];
[2]2502
[551]2503 if (IsValidDir(dcd->previous)) {
2504 strcpy(tempname, dcd->directory);
2505 strcpy(dcd->directory, dcd->previous);
2506 strcpy(dcd->previous, tempname);
[1303]2507 //DosEnterCritSec(); // GKY 11-27-08
[551]2508 dcd->stopflag++;
[1303]2509 //DosExitCritSec();
[551]2510 if (!PostMsg(dcd->hwndObject, UM_RESCAN, MPVOID, MPFROMLONG(1L))) {
2511 strcpy(dcd->directory, dcd->previous);
[1303]2512 //DosEnterCritSec(); // GKY 11-27-08
[551]2513 dcd->stopflag--;
[1303]2514 //DosExitCritSec();
[551]2515 }
2516 else if (*dcd->directory) {
2517 if (hwndMain)
2518 WinSendMsg(hwndMain,
2519 UM_SETUSERLISTNAME,
2520 MPFROMP(dcd->directory), MPVOID);
2521 else
2522 add_udir(FALSE, dcd->directory);
2523 }
2524 }
2525 else
2526 *dcd->previous = 0;
2527 }
2528 break;
[2]2529
[551]2530 case IDM_WALKDIR:
2531 {
2532 CHAR newdir[CCHMAXPATH];
[2]2533
[551]2534 strcpy(newdir, dcd->directory);
2535 if (!WinDlgBox(HWND_DESKTOP,
2536 dcd->hwndParent,
2537 WalkAllDlgProc,
2538 FM3ModHandle,
2539 WALK_FRAME, MPFROMP(newdir)) || !*newdir)
2540 break;
2541 if (stricmp(newdir, dcd->directory)) {
2542 strcpy(dcd->previous, dcd->directory);
2543 strcpy(dcd->directory, newdir);
[1303]2544 //DosEnterCritSec(); //GKY 11-27-08
[551]2545 dcd->stopflag++;
[1303]2546 //DosExitCritSec();
[551]2547 if (!PostMsg(dcd->hwndObject, UM_RESCAN, MPVOID, MPFROMLONG(1L))) {
2548 strcpy(dcd->directory, dcd->previous);
[1303]2549 //DosEnterCritSec(); // GKY 11-27-08
[551]2550 dcd->stopflag--;
[1303]2551 //DosExitCritSec();
[551]2552 }
2553 else if (*dcd->directory) {
2554 if (hwndMain)
2555 WinSendMsg(hwndMain,
2556 UM_SETUSERLISTNAME,
2557 MPFROMP(dcd->directory), MPVOID);
2558 else
2559 add_udir(FALSE, dcd->directory);
2560 }
2561 }
2562 }
2563 break;
[2]2564
[551]2565 case IDM_OPENICONME:
[1402]2566 OpenObject(dcd->directory, PCSZ_ICON, dcd->hwndFrame);
[551]2567 break;
2568 case IDM_OPENDETAILSME:
[1402]2569 OpenObject(dcd->directory, Details, dcd->hwndFrame);
[551]2570 break;
2571 case IDM_OPENTREEME:
[1402]2572 OpenObject(dcd->directory, PCSZ_TREE, dcd->hwndFrame);
[551]2573 break;
2574 case IDM_OPENSETTINGSME:
2575 OpenObject(dcd->directory, Settings, dcd->hwndFrame);
2576 break;
[2]2577
[551]2578 case IDM_DOITYOURSELF:
2579 case IDM_UPDATE:
2580 case IDM_OPENWINDOW:
2581 case IDM_OPENSETTINGS:
2582 case IDM_OPENDEFAULT:
2583 case IDM_OPENICON:
2584 case IDM_OPENDETAILS:
2585 case IDM_OPENTREE:
2586 case IDM_OBJECT:
2587 case IDM_SHADOW:
2588 case IDM_SHADOW2:
2589 case IDM_DELETE:
2590 case IDM_PERMDELETE:
2591 case IDM_PRINT:
2592 case IDM_ATTRS:
2593 case IDM_INFO:
2594 case IDM_COPY:
2595 case IDM_MOVE:
2596 case IDM_WPSMOVE:
2597 case IDM_WPSCOPY:
2598 case IDM_WILDCOPY:
2599 case IDM_WILDMOVE:
2600 case IDM_RENAME:
2601 case IDM_COMPARE:
2602 case IDM_EAS:
2603 case IDM_SUBJECT:
2604 case IDM_VIEW:
2605 case IDM_VIEWTEXT:
2606 case IDM_VIEWBINARY:
2607 case IDM_VIEWARCHIVE:
2608 case IDM_EDIT:
2609 case IDM_EDITTEXT:
2610 case IDM_EDITBINARY:
2611 case IDM_SAVETOCLIP:
[1084]2612 case IDM_SAVETOCLIPFILENAME:
[551]2613 case IDM_APPENDTOCLIP:
[1084]2614 case IDM_APPENDTOCLIPFILENAME:
[551]2615 case IDM_ARCHIVE:
2616 case IDM_ARCHIVEM:
2617 case IDM_EXTRACT:
2618 case IDM_MCIPLAY:
2619 case IDM_COLLECTFROMFILE:
2620 case IDM_UUDECODE:
2621 case IDM_MERGE:
2622 {
2623 LISTINFO *li;
2624 ULONG action = UM_ACTION;
2625 li = xmallocz(sizeof(LISTINFO), pszSrcFile, __LINE__);
2626 if (li) {
2627 li->type = SHORT1FROMMP(mp1);
2628 li->hwnd = hwnd;
2629 li->list = BuildList(hwnd);
2630 switch (SHORT1FROMMP(mp1)) {
2631 case IDM_WILDMOVE:
2632 case IDM_WILDCOPY:
2633 case IDM_MOVE:
2634 case IDM_COPY:
2635 case IDM_WPSMOVE:
2636 case IDM_WPSCOPY:
2637 break;
2638 default:
2639 strcpy(li->targetpath, dcd->directory);
2640 break;
2641 }
2642 if (li->list) {
2643 if (SHORT1FROMMP(mp1) == IDM_COLLECTFROMFILE) {
2644 if (!Collector) {
[2]2645
[551]2646 HWND hwndC;
2647 SWP swp;
[2]2648
[551]2649 if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
2650 !fAutoTile &&
2651 (!fExternalCollector && !strcmp(realappname, FM3Str)))
2652 GetNextWindowPos(dcd->hwndParent, &swp, NULL, NULL);
2653 hwndC = StartCollector((fExternalCollector ||
2654 strcmp(realappname, FM3Str)) ?
2655 HWND_DESKTOP : dcd->hwndParent, 4);
2656 if (hwndC) {
2657 if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
2658 !fAutoTile && (!fExternalCollector &&
2659 !strcmp(realappname, FM3Str)))
2660 WinSetWindowPos(hwndC, HWND_TOP, swp.x, swp.y,
2661 swp.cx, swp.cy, SWP_MOVE | SWP_SIZE |
2662 SWP_SHOW | SWP_ZORDER);
2663 else if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
2664 fAutoTile && !strcmp(realappname, FM3Str))
2665 TileChildren(dcd->hwndParent, TRUE);
2666 WinSetWindowPos(hwndC, HWND_TOP, 0, 0, 0, 0,
2667 SWP_ACTIVATE);
[771]2668 DosSleep(100); //05 Aug 07 GKY 250
[551]2669 }
2670 }
2671 else
2672 StartCollector(dcd->hwndParent, 4);
2673 }
2674 switch (SHORT1FROMMP(mp1)) {
[1335]2675 case IDM_APPENDTOCLIP:
2676 case IDM_APPENDTOCLIPFILENAME:
2677 case IDM_SAVETOCLIP:
2678 case IDM_SAVETOCLIPFILENAME:
[551]2679 case IDM_ARCHIVE:
2680 case IDM_ARCHIVEM:
2681 case IDM_DELETE:
2682 case IDM_PERMDELETE:
2683 case IDM_ATTRS:
2684 case IDM_PRINT:
2685 case IDM_SHADOW:
2686 case IDM_SHADOW2:
2687 case IDM_OBJECT:
2688 case IDM_VIEW:
2689 case IDM_VIEWTEXT:
2690 case IDM_VIEWBINARY:
2691 case IDM_EDIT:
2692 case IDM_EDITTEXT:
2693 case IDM_EDITBINARY:
2694 case IDM_MCIPLAY:
2695 case IDM_UPDATE:
2696 case IDM_DOITYOURSELF:
2697 case IDM_INFO:
2698 case IDM_EAS:
2699 action = UM_MASSACTION;
2700 break;
2701 }
2702 if (SHORT1FROMMP(mp1) == IDM_OBJECT ||
2703 SHORT1FROMMP(mp1) == IDM_SHADOW ||
2704 SHORT1FROMMP(mp1) == IDM_SHADOW2)
2705 *li->targetpath = 0;
2706 if (!PostMsg(dcd->hwndObject, action, MPFROMP(li), MPVOID)) {
[1400]2707 Runtime_Error(pszSrcFile, __LINE__, PCSZ_POSTMSG);
[551]2708 FreeListInfo(li);
2709 }
2710 else if (fUnHilite)
[672]2711 UnHilite(hwnd, TRUE, &dcd->lastselection, 0);
[551]2712 }
2713 else
[1039]2714 free(li);
[551]2715 }
2716 }
2717 break;
[2]2718
[551]2719 case IDM_DRIVESMENU:
2720 if (!hwndMain)
2721 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_WALKDIR, 0), MPVOID);
2722 break;
[2]2723
[551]2724 default:
2725 if (SwitchCommand(dcd->hwndLastMenu, SHORT1FROMMP(mp1)))
2726 return 0;
2727 else {
2728 if (SHORT1FROMMP(mp1) >= IDM_COMMANDSTART &&
2729 SHORT1FROMMP(mp1) < IDM_QUICKTOOLSTART) {
[2]2730
[551]2731 register INT x;
[2]2732
[551]2733 if (!cmdloaded)
2734 load_commands();
2735 x = SHORT1FROMMP(mp1) - IDM_COMMANDSTART;
2736 if (x >= 0) {
2737 x++;
2738 RunCommand(hwnd, x);
2739 if (fUnHilite)
[672]2740 UnHilite(hwnd, TRUE, &dcd->lastselection, 0);
[551]2741 }
2742 }
2743 }
2744 break;
[2]2745 }
[551]2746 }
2747 return 0;
[2]2748
[551]2749 case UM_FIXCNRMLE:
2750 case UM_FIXEDITNAME:
2751 return CommonCnrProc(hwnd, msg, mp1, mp2);
[2]2752
[551]2753 case UM_FILESMENU:
2754 {
2755 PCNRITEM pci;
2756 HWND menuHwnd = (HWND) 0;
[2]2757
[551]2758 pci = (PCNRITEM) CurrentRecord(hwnd);
2759 if (pci && (INT) pci != -1) {
2760 if (pci->attrFile & FILE_DIRECTORY) {
[875]2761 menuHwnd = CheckMenu(hwndMainMenu, &DirMenu, DIR_POPUP);
[930]2762// WinEnableMenuItem(DirMenu,IDM_TREE,TRUE);
[551]2763 }
2764 else
[875]2765 menuHwnd = CheckMenu(hwndMainMenu, &FileMenu, FILE_POPUP);
[2]2766 }
[551]2767 return MRFROMLONG(menuHwnd);
2768 }
[2]2769
[551]2770 case WM_CONTROL:
2771 DosError(FERR_DISABLEHARDERR);
2772 if (dcd) {
2773 switch (SHORT2FROMMP(mp1)) {
2774 case CN_COLLAPSETREE:
2775 case CN_EXPANDTREE:
2776 {
2777 PCNRITEM pci = (PCNRITEM) mp2;
[2]2778
[551]2779 if (pci && (INT) pci != -1 && !(pci->flags & RECFLAGS_ENV)) {
[730]2780 if (driveflags[toupper(*pci->pszFileName) - 'A'] & DRIVE_REMOVABLE) {
[551]2781 struct
[275]2782 {
[551]2783 ULONG serial;
2784 CHAR volumelength;
2785 CHAR volumelabel[CCHMAXPATH];
2786 }
2787 volser;
2788 APIRET rc;
[2]2789
[551]2790 memset(&volser, 0, sizeof(volser));
2791 DosError(FERR_DISABLEHARDERR);
[907]2792 // fixme?
[730]2793 rc = DosQueryFSInfo(toupper(*pci->pszFileName) - '@',
[551]2794 FSIL_VOLSER, &volser, sizeof(volser));
2795 if (rc) {
2796 Dos_Error(MB_ENTER, rc, HWND_DESKTOP, pszSrcFile, __LINE__,
[552]2797 GetPString(IDS_CANTFINDDIRTEXT),
[1411]2798 pci->pszFileName);
2799 if (!fErrorBeepOff)
[1395]2800 DosBeep(250,100);
[730]2801 driveserial[toupper(*pci->pszFileName) - 'A'] = -1;
[551]2802 UnFlesh(hwnd, pci);
2803 PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
2804 }
2805 else {
2806 if (SHORT2FROMMP(mp1) == CN_COLLAPSETREE &&
2807 !volser.serial ||
[907]2808 driveserial[toupper(*pci->pszFileName) - 'A'] !=
[551]2809 volser.serial)
2810 UnFlesh(hwnd, pci);
2811 if (SHORT2FROMMP(mp1) != CN_COLLAPSETREE ||
2812 (!volser.serial ||
[730]2813 driveserial[toupper(*pci->pszFileName) - 'A'] !=
[551]2814 volser.serial)) {
2815 if (Flesh(hwnd, pci) &&
2816 SHORT2FROMMP(mp1) == CN_EXPANDTREE &&
[1455]2817 !dcd->suspendview && fTopDir) {
2818 PostMsg(hwnd, UM_TOPDIR, MPFROMP(pci), MPVOID);
2819 //DbgMsg(pszSrcFile, __LINE__, "UM_TOPDIR %p pci %p", hwnd, pci);
2820 }
[551]2821 }
[730]2822 driveserial[toupper(*pci->pszFileName) - 'A'] = volser.serial;
[551]2823 }
2824 }
2825 else if (SHORT2FROMMP(mp1) == CN_EXPANDTREE) {
[1455]2826 if (Flesh(hwnd, pci) && !dcd->suspendview && fTopDir) {
[551]2827 PostMsg(hwnd, UM_TOPDIR, MPFROMP(pci), MPVOID);
[1455]2828 //DbgMsg(pszSrcFile, __LINE__, "UM_TOPDIR %p pci %p", hwnd, pci);
2829 }
[551]2830 }
[1455]2831 if (SHORT2FROMMP(mp1) == CN_EXPANDTREE && !dcd->suspendview) {
[551]2832 WinSendMsg(hwnd, UM_FILTER, MPVOID, MPVOID);
[1455]2833 //DbgMsg(pszSrcFile, __LINE__, "UM_TOPDIR %p pci %p", hwnd, pci);
2834 }
[551]2835 }
2836 }
2837 break;
[2]2838
2839/*
[618]2840 case CN_PICKUP:
2841 return PickUp(hwnd,dcd->hwndObject,mp2);
[2]2842*/
2843
[551]2844 case CN_CONTEXTMENU:
2845 {
2846 PCNRITEM pci = (PCNRITEM) mp2;
[2]2847
[551]2848 if (pci) {
2849 WinSendMsg(hwnd,
2850 CM_SETRECORDEMPHASIS,
2851 MPFROMP(pci), MPFROM2SHORT(TRUE, CRA_CURSORED));
[907]2852 MarkAll(hwnd, FALSE, FALSE, TRUE);
2853 if (pci->attrFile & FILE_DIRECTORY)
[875]2854 dcd->hwndLastMenu = CheckMenu(hwndMainMenu, &DirMenu, DIR_POPUP);
[551]2855 else
[875]2856 dcd->hwndLastMenu = CheckMenu(hwndMainMenu, &FileMenu, FILE_POPUP);
[551]2857 }
2858 else {
[877]2859 dcd->hwndLastMenu = CheckMenu(hwnd, &DirCnrMenu, DIRCNR_POPUP);
[551]2860 if (dcd->hwndLastMenu && !dcd->cnremphasized) {
2861 WinSendMsg(hwnd,
2862 CM_SETRECORDEMPHASIS,
2863 MPVOID, MPFROM2SHORT(TRUE, CRA_SOURCE));
2864 dcd->cnremphasized = TRUE;
2865 }
2866 }
2867 if (dcd->hwndLastMenu) {
2868 if (dcd->hwndLastMenu == DirCnrMenu) {
2869 if (dcd->flWindowAttr & CV_MINI)
2870 WinCheckMenuItem(dcd->hwndLastMenu, IDM_MINIICONS, TRUE);
2871 }
2872 if (dcd->hwndLastMenu == DirMenu)
2873 WinEnableMenuItem(DirMenu, IDM_TREE, TRUE);
2874 if (!PopupMenu(hwnd, hwnd, dcd->hwndLastMenu)) {
2875 if (dcd->cnremphasized) {
2876 WinSendMsg(hwnd,
2877 CM_SETRECORDEMPHASIS,
2878 MPVOID, MPFROM2SHORT(FALSE, CRA_SOURCE));
2879 dcd->cnremphasized = TRUE;
2880 }
2881 MarkAll(hwnd, TRUE, FALSE, TRUE);
2882 }
2883 }
2884 }
2885 break;
[2]2886
[551]2887 case CN_DROPHELP:
2888 if (mp2) {
[2]2889
[551]2890 PDRAGINFO pDInfo;
2891 PCNRITEM pci;
2892 ULONG numitems;
2893 USHORT usOperation;
[2]2894
[551]2895 pci = (PCNRITEM) ((PCNRDRAGINFO) mp2)->pRecord;
2896 pDInfo = (PDRAGINFO) ((PCNRDRAGINFO) mp2)->pDragInfo;
2897 if (!DrgAccessDraginfo(pDInfo)) {
2898 Win_Error(hwnd, hwnd, pszSrcFile, __LINE__,
2899 GetPString(IDS_DROPERRORTEXT));
2900 }
[618]2901 else {
2902 numitems = DrgQueryDragitemCount(pDInfo);
[1394]2903 usOperation = pDInfo->usOperation;
2904 if (usOperation == DO_DEFAULT)
2905 usOperation = fCopyDefault ? DO_COPY : DO_MOVE;
[618]2906 FreeDragInfoData(hwnd, pDInfo);
2907 saymsg(MB_ENTER | MB_ICONASTERISK,
2908 hwnd,
2909 GetPString(IDS_DROPHELPHDRTEXT),
2910 GetPString(IDS_DROPHELPTEXT),
2911 numitems,
2912 &"s"[numitems == 1L],
2913 pci ? NullStr : GetPString(IDS_NOTEXT),
2914 pci ? NullStr : " ",
[730]2915 pci ? pci->pszFileName : NullStr,
[618]2916 pci ? " " : NullStr,
[1357]2917 GetPString((usOperation == DO_MOVE) ?
2918 IDS_MOVETEXT :
[618]2919 (usOperation == DO_LINK) ?
[1357]2920 IDS_LINKTEXT : IDS_COPYTEXT));
[618]2921 }
[551]2922 }
2923 return 0;
[2]2924
[551]2925 case CN_DRAGLEAVE:
2926 return 0;
[2]2927
[551]2928 case CN_DRAGAFTER:
2929 case CN_DRAGOVER:
2930 if (mp2) {
[2]2931
[618]2932 PDRAGITEM pDItem; /* Pointer to DRAGITEM */
2933 PDRAGINFO pDInfo; /* Pointer to DRAGINFO */
[551]2934 PCNRITEM pci;
2935 USHORT uso;
[2]2936
[551]2937 pci = (PCNRITEM) ((PCNRDRAGINFO) mp2)->pRecord;
2938 pDInfo = ((PCNRDRAGINFO) mp2)->pDragInfo;
[907]2939 if (!DrgAccessDraginfo(pDInfo)) {
2940 Win_Error(HWND_DESKTOP, HWND_DESKTOP, pszSrcFile, __LINE__,
[1402]2941 PCSZ_DRGACCESSDRAGINFO);
[618]2942 return (MRFROM2SHORT(DOR_NEVERDROP, 0));
[907]2943 }
2944 if (*dcd->directory &&
[687]2945 (driveflags[toupper(*dcd->directory) - 'A'] &
2946 DRIVE_NOTWRITEABLE)) {
[551]2947 DrgFreeDraginfo(pDInfo);
2948 return MRFROM2SHORT(DOR_DROP, /* Return okay to link */
[618]2949 DO_LINK); /* (compare) only */
[551]2950 }
2951 if (pci) {
2952 if (pci->rc.flRecordAttr & CRA_SOURCE) {
2953 DrgFreeDraginfo(pDInfo);
2954 return (MRFROM2SHORT(DOR_NODROP, 0));
2955 }
2956 uso = pDInfo->usOperation;
2957 if (uso == DO_DEFAULT)
[618]2958 uso = fCopyDefault ? DO_COPY : DO_MOVE;
[551]2959 if (!(pci->attrFile & FILE_DIRECTORY)) {
2960 if (uso != DO_LINK && uso != DO_COPY && uso != DO_MOVE) {
2961 DrgFreeDraginfo(pDInfo);
2962 return MRFROM2SHORT(DOR_NODROP, 0);
2963 }
2964 if (uso != DO_LINK &&
[730]2965 !(driveflags[toupper(*pci->pszFileName) - 'A'] &
[551]2966 DRIVE_NOTWRITEABLE)) {
[2]2967
[551]2968 ARC_TYPE *info = NULL;
[2]2969
[551]2970 if (!fQuickArcFind &&
[730]2971 !(driveflags[toupper(*pci->pszFileName) - 'A'] &
[551]2972 DRIVE_SLOW))
[730]2973 info = find_type(pci->pszFileName, NULL);
[551]2974 else
[730]2975 info = quick_find_type(pci->pszFileName, NULL);
[551]2976 if (!info || ((uso == DO_MOVE && !info->move) ||
2977 (uso == DO_COPY && !info->create))) {
2978 DrgFreeDraginfo(pDInfo);
2979 return MRFROM2SHORT(DOR_NODROP, 0);
2980 }
2981 }
2982 }
2983 }
[275]2984
[551]2985 /* Access DRAGITEM index to DRAGITEM
2986 * Check valid rendering mechanisms and data
2987 */
2988 pDItem = DrgQueryDragitemPtr(pDInfo, 0);
2989 if (DrgVerifyRMF(pDItem, DRM_OS2FILE, NULL) ||
2990 ((!pci || (pci->attrFile & FILE_DIRECTORY)) &&
2991 DrgVerifyRMF(pDItem, DRM_FM2ARCMEMBER, DRF_FM2ARCHIVE))) {
2992 DrgFreeDraginfo(pDInfo);
2993 if (driveflags[toupper(*dcd->directory) - 'A'] &
2994 DRIVE_NOTWRITEABLE)
2995 return MRFROM2SHORT(DOR_DROP, DO_LINK);
2996 if (toupper(*dcd->directory) < 'C')
2997 return MRFROM2SHORT(DOR_DROP, DO_COPY);
[618]2998 return MRFROM2SHORT(DOR_DROP, /* Return okay to drop */
[551]2999 ((fCopyDefault) ? DO_COPY : DO_MOVE));
3000 }
[618]3001 DrgFreeDraginfo(pDInfo); /* Free DRAGINFO */
[551]3002 }
[618]3003 return MRFROM2SHORT(DOR_NODROP, 0); /* Drop not valid */
[2]3004
[551]3005 case CN_INITDRAG:
3006 {
3007 BOOL wasemphasized = FALSE;
3008 PCNRDRAGINIT pcd = (PCNRDRAGINIT) mp2;
3009 PCNRITEM pci;
[2]3010
[551]3011 if (pcd) {
3012 pci = (PCNRITEM) pcd->pRecord;
3013 if (pci) {
3014 if ((INT) pci == -1)
3015 pci = NULL;
3016 else if (pci->rc.flRecordAttr & CRA_SELECTED)
3017 wasemphasized = TRUE;
3018 }
3019 else if (!*dcd->directory) {
[1398]3020 Runtime_Error(pszSrcFile, __LINE__, NULL);
[551]3021 break;
3022 }
3023 else if (IsRoot(dcd->directory)) {
[618]3024 saymsg(MB_ENTER, hwnd, GetPString(IDS_ERRORTEXT),
3025 GetPString(IDS_CANTDRAGROOTDIR));
[551]3026 break;
3027 }
3028 if (hwndStatus2) {
3029 if (pci)
3030 WinSetWindowText(hwndStatus2,
3031 GetPString(IDS_DRAGFILEOBJTEXT));
3032 else
3033 WinSetWindowText(hwndStatus2, GetPString(IDS_DRAGDIRTEXT));
3034 }
3035 if (DoFileDrag(hwnd,
3036 dcd->hwndObject,
3037 mp2,
3038 NULL,
[618]3039 pci ? NULL : dcd->directory,
3040 pci ? TRUE : FALSE)) {
[672]3041 if ((pci && fUnHilite && wasemphasized) || dcd->ulItemsToUnHilite) {
3042 UnHilite(hwnd, TRUE, &dcd->lastselection, dcd->ulItemsToUnHilite);
[618]3043 }
[551]3044 }
3045 if (hwndStatus2) {
3046 WinSetFocus(HWND_DESKTOP, hwnd);
3047 PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
3048 }
3049 }
3050 }
3051 return 0;
[2]3052
[551]3053 case CN_DROP:
3054 if (mp2) {
[2]3055
[551]3056 LISTINFO *li;
3057 ULONG action = UM_ACTION;
[2]3058
[907]3059 li = DoFileDrop(hwnd, dcd->directory, TRUE, mp1, mp2);
3060 CheckPmDrgLimit(((PCNRDRAGINFO)mp2)->pDragInfo);
[551]3061 if (li) {
3062 if (li->list && li->list[0] && IsRoot(li->list[0]))
3063 li->type = DO_LINK;
3064 else if (fDragndropDlg && (!*li->arcname || !li->info)) {
[2]3065
[551]3066 CHECKLIST cl;
[2]3067
[551]3068 memset(&cl, 0, sizeof(cl));
3069 cl.size = sizeof(cl);
3070 cl.flags = li->type;
3071 cl.list = li->list;
3072 cl.cmd = li->type;
3073 cl.prompt = li->targetpath;
3074 li->type = WinDlgBox(HWND_DESKTOP, dcd->hwndParent,
3075 DropListProc, FM3ModHandle,
[618]3076 DND_FRAME, MPFROMP(&cl));
3077 if (li->type == DID_ERROR)
3078 Win_Error(DND_FRAME, HWND_DESKTOP, pszSrcFile, __LINE__,
[1402]3079 GetPString(IDS_DRAGDROPDIALOGTEXT));
[618]3080 if (!li->type) {
[551]3081 FreeListInfo(li);
3082 return 0;
3083 }
3084 li->list = cl.list;
[618]3085 if (!li->list || !li->list[0]) {
[551]3086 FreeListInfo(li);
3087 return 0;
3088 }
3089 }
3090 switch (li->type) {
3091 case DND_LAUNCH:
3092 strcat(li->targetpath, " %a");
3093 ExecOnList(dcd->hwndParent, li->targetpath,
[907]3094 PROMPT | WINDOWED, NULL, li->list, NULL,
3095 pszSrcFile, __LINE__);
[551]3096 FreeList(li->list);
3097 li->list = NULL;
3098 break;
3099 case DO_LINK:
3100 if (fLinkSetsIcon) {
3101 li->type = IDM_SETICON;
3102 action = UM_MASSACTION;
3103 }
3104 else
3105 li->type = IDM_COMPARE;
3106 break;
3107 case DND_EXTRACT:
3108 if (*li->targetpath && !IsFile(li->targetpath))
3109 li->type = IDM_EXTRACT;
3110 break;
3111 case DND_MOVE:
3112 li->type = IDM_MOVE;
3113 if (*li->targetpath && IsFile(li->targetpath) == 1) {
3114 action = UM_MASSACTION;
3115 li->type = IDM_ARCHIVEM;
3116 }
3117 break;
3118 case DND_WILDMOVE:
3119 li->type = IDM_WILDMOVE;
3120 if (*li->targetpath && IsFile(li->targetpath) == 1) {
3121 action = UM_MASSACTION;
3122 li->type = IDM_ARCHIVEM;
3123 }
3124 break;
3125 case DND_OBJECT:
3126 li->type = IDM_OBJECT;
3127 action = UM_MASSACTION;
3128 break;
3129 case DND_SHADOW:
3130 li->type = IDM_SHADOW;
3131 action = UM_MASSACTION;
3132 break;
3133 case DND_COMPARE:
3134 li->type = IDM_COMPARE;
3135 break;
3136 case DND_SETICON:
3137 action = UM_MASSACTION;
3138 li->type = IDM_SETICON;
3139 break;
3140 case DND_COPY:
3141 li->type = IDM_COPY;
3142 if (*li->targetpath && IsFile(li->targetpath) == 1) {
3143 action = UM_MASSACTION;
3144 li->type = IDM_ARCHIVE;
3145 }
3146 break;
3147 case DND_WILDCOPY:
3148 li->type = IDM_WILDCOPY;
3149 if (*li->targetpath && IsFile(li->targetpath) == 1) {
3150 action = UM_MASSACTION;
3151 li->type = IDM_ARCHIVE;
3152 }
3153 break;
3154 default:
3155 if (*li->arcname && li->info) {
3156 action = UM_MASSACTION;
3157 li->type =
3158 (li->type == DO_MOVE) ? IDM_FAKEEXTRACTM : IDM_FAKEEXTRACT;
3159 }
3160 else if (*li->targetpath && IsFile(li->targetpath) == 1) {
3161 action = UM_MASSACTION;
3162 li->type = (li->type == DO_MOVE) ? IDM_ARCHIVEM : IDM_ARCHIVE;
3163 }
3164 else
3165 li->type = (li->type == DO_MOVE) ? IDM_MOVE : IDM_COPY;
3166 break;
3167 }
3168 if (!li->list || !li->list[0])
3169 FreeListInfo(li);
3170 else if (!PostMsg(dcd->hwndObject, action, MPFROMP(li), MPVOID))
3171 FreeListInfo(li);
3172 else {
[2]3173
[551]3174 USHORT usop = 0;
[2]3175
[551]3176 switch (li->type) {
3177 case IDM_COPY:
3178 case IDM_WILDCOPY:
3179 usop = DO_COPY;
3180 break;
3181 case IDM_MOVE:
3182 case IDM_WILDMOVE:
3183 case IDM_ARCHIVEM:
3184 usop = DO_MOVE;
3185 break;
3186 }
3187 if (usop)
3188 return MRFROM2SHORT(DOR_DROP, usop);
3189 }
3190 }
3191 }
3192 return 0;
[2]3193
[551]3194 case CN_ENDEDIT:
3195 case CN_BEGINEDIT:
3196 {
3197 PFIELDINFO pfi = ((PCNREDITDATA) mp2)->pFieldInfo;
3198 PCNRITEM pci = (PCNRITEM) ((PCNREDITDATA) mp2)->pRecord;
[2]3199
[551]3200 if (pfi || pci) {
[2]3201
[551]3202 MRESULT mre;
[2]3203
[551]3204 mre = CnrDirectEdit(hwnd, msg, mp1, mp2);
3205 if (mre != (MRESULT) - 1)
3206 return mre;
3207 }
3208 else if (!pfi && !pci)
3209 PostMsg(hwnd, UM_FIXCNRMLE, MPFROMLONG(CCHMAXPATH), MPVOID);
3210 }
3211 return 0;
[2]3212
[551]3213 case CN_REALLOCPSZ:
3214 {
3215 PFIELDINFO pfi = ((PCNREDITDATA) mp2)->pFieldInfo;
3216 PCNRITEM pci = (PCNRITEM) ((PCNREDITDATA) mp2)->pRecord;
3217 HWND hwndMLE;
[689]3218 CHAR testname[CCHMAXPATH];
[2]3219
[551]3220 if (!pci && !pfi) {
3221 hwndMLE = WinWindowFromID(hwnd, CID_MLE);
[1459]3222 WinQueryWindowText(hwndMLE, sizeof(s), s);
3223 chop_at_crnl(s);
3224 bstrip(s);
3225 if (*s) {
3226 if (!DosQueryPathInfo(s,
[551]3227 FIL_QUERYFULLNAME,
3228 testname, sizeof(testname))) {
3229 if (!SetDir(dcd->hwndParent, hwnd, testname, 1)) {
3230 PostMsg(hwnd, UM_SETDIR, MPFROMP(testname), MPVOID);
3231 }
3232 }
3233 }
3234 }
3235 else {
[2]3236
[551]3237 MRESULT mre;
[2]3238
[551]3239 mre = CnrDirectEdit(hwnd, msg, mp1, mp2);
3240 if (mre != (MRESULT) - 1)
3241 return mre;
3242 }
3243 }
3244 return 0;
[2]3245
[551]3246 case CN_EMPHASIS:
3247 if (!mp2)
3248 Runtime_Error(pszSrcFile, __LINE__, "mp2 NULL");
3249 else {
3250 PNOTIFYRECORDEMPHASIS pre = mp2;
3251 PCNRITEM pci;
[1459]3252 CHAR s[CCHMAXPATHCOMP + 91];
[2]3253
[762]3254 pci = (PCNRITEM) (pre ? pre->pRecord : NULL);
[551]3255 if (!pci) {
3256 if (hwndStatus2)
3257 WinSetWindowText(hwndStatus2, NullStr);
3258 if (fMoreButtons) {
3259 WinSetWindowText(hwndName, NullStr);
3260 WinSetWindowText(hwndDate, NullStr);
3261 WinSetWindowText(hwndAttr, NullStr);
3262 }
3263 if (hwndMain)
3264 WinSendMsg(hwndMain, UM_LOADFILE, MPVOID, MPVOID);
3265 break;
3266 }
3267 if (pre->fEmphasisMask & CRA_SELECTED) {
3268 if (pci->rc.flRecordAttr & CRA_SELECTED) {
3269 dcd->selectedbytes += (pci->cbFile + pci->easize);
3270 dcd->selectedfiles++;
3271 }
3272 else if (dcd->selectedfiles) {
3273 dcd->selectedbytes -= (pci->cbFile + pci->easize);
3274 dcd->selectedfiles--;
3275 }
3276 if (!dcd->suspendview) {
3277 commafmt(tf, sizeof(tf), dcd->selectedfiles);
3278 CommaFmtULL(tb, sizeof(tb), dcd->selectedbytes, 'K');
3279 sprintf(s, "%s / %s", tf, tb);
3280 WinSetDlgItemText(dcd->hwndClient, DIR_SELECTED, s);
3281 }
3282 }
3283 if (!dcd->suspendview && hwndMain &&
3284 (pre->fEmphasisMask & CRA_CURSORED) &&
3285 (pci->rc.flRecordAttr & CRA_CURSORED) &&
3286 WinQueryActiveWindow(dcd->hwndParent) == dcd->hwndFrame) {
[730]3287 if (driveflags[toupper(*pci->pszFileName) - 'A'] & DRIVE_SLOW)
[551]3288 WinSendMsg(hwndMain, UM_LOADFILE, MPVOID, MPVOID);
3289 else
3290 WinSendMsg(hwndMain,
[730]3291 UM_LOADFILE, MPFROMP(pci->pszFileName), MPVOID);
[551]3292 }
3293 if (!dcd->suspendview &&
3294 WinQueryActiveWindow(dcd->hwndParent) == dcd->hwndFrame) {
3295 if (pre->fEmphasisMask & CRA_CURSORED) {
3296 if (pci->rc.flRecordAttr & CRA_CURSORED) {
3297 if (fSplitStatus && hwndStatus2) {
3298 CommaFmtULL(tb, sizeof(tb), pci->cbFile + pci->easize, ' ');
[1411]3299 if (!fMoreButtons) {
3300 CHAR date[11];
[1395]3301
[1411]3302 DateFormat(date, pci->date);
[1395]3303 sprintf(s, " %s %s %02u%s%02u%s%02u [%s] %s",
3304 tb, date, pci->time.hours, TimeSeparator,
3305 pci->time.minutes, TimeSeparator, pci->time.seconds,
[551]3306 pci->pszDispAttr, pci->pszFileName);
3307 }
3308 else {
3309 *tf = 0;
3310 if (pci->cbFile + pci->easize > 1024) {
3311 CommaFmtULL(tf, sizeof(tf),
3312 pci->cbFile + pci->easize, 'K');
3313 }
3314 sprintf(s, GetPString(IDS_STATUSSIZETEXT),
3315 tb,
3316 *tf ? " (" : NullStr, tf, *tf ? ")" : NullStr);
3317 }
3318 WinSetWindowText(hwndStatus2, s);
3319 }
[1411]3320 if (fMoreButtons) {
3321 CHAR szDate[DATE_BUF_BYTES];
[1395]3322
[1411]3323 WinSetWindowText(hwndName, pci->pszFileName);
3324 DateFormat(szDate, pci->date);
[1395]3325 sprintf(s, "%s %02u%s%02u%s%02u",
[1411]3326 szDate, pci->time.hours, TimeSeparator, pci->time.minutes,
[1395]3327 TimeSeparator, pci->time.seconds);
[551]3328 WinSetWindowText(hwndDate, s);
3329 WinSetWindowText(hwndAttr, pci->pszDispAttr);
3330 }
3331 }
3332 }
3333 }
3334 }
3335 break;
[2]3336
[551]3337 case CN_ENTER:
3338 if (mp2) {
[2]3339
[551]3340 PCNRITEM pci = (PCNRITEM) ((PNOTIFYRECORDENTER) mp2)->pRecord;
[847]3341 FILEFINDBUF3 ffb;
[551]3342 HDIR hDir = HDIR_CREATE;
[761]3343 ULONG nm = 1;
[551]3344 APIRET status = 0;
[2]3345
[551]3346 SetShiftState();
3347 if (pci) {
3348 if (pci->rc.flRecordAttr & CRA_INUSE)
3349 break;
3350 DosError(FERR_DISABLEHARDERR);
[847]3351 status = DosFindFirst(pci->pszFileName,
[838]3352 &hDir,
3353 FILE_NORMAL | FILE_DIRECTORY |
3354 FILE_ARCHIVED | FILE_READONLY |
3355 FILE_HIDDEN | FILE_SYSTEM,
[847]3356 &ffb, sizeof(ffb), &nm, FIL_STANDARD);
[551]3357 priority_bumped();
3358 if (!status) {
3359 DosFindClose(hDir);
3360 if (ffb.attrFile & FILE_DIRECTORY) {
3361 if ((shiftstate & (KC_CTRL | KC_ALT)) == (KC_CTRL | KC_ALT))
3362 PostMsg(hwnd,
3363 WM_COMMAND,
3364 MPFROM2SHORT(IDM_SHOWALLFILES, 0), MPVOID);
3365 else if ((shiftstate & (KC_CTRL | KC_SHIFT)) ==
3366 (KC_CTRL | KC_SHIFT))
[730]3367 OpenObject(pci->pszFileName, Settings, dcd->hwndFrame);
[551]3368 else if (shiftstate & KC_CTRL)
[730]3369 OpenObject(pci->pszFileName, Default, dcd->hwndFrame);
[551]3370 else if (shiftstate & KC_SHIFT) {
[2]3371
[551]3372 HWND hwndDir;
[2]3373
[551]3374 hwndDir = OpenDirCnr((HWND) 0,
3375 dcd->hwndParent,
3376 dcd->hwndFrame,
[730]3377 FALSE, pci->pszFileName);
[551]3378 if (hwndDir) {
3379 if (fMinOnOpen)
3380 WinSetWindowPos(dcd->hwndFrame,
3381 HWND_BOTTOM,
3382 0, 0, 0, 0, SWP_MINIMIZE | SWP_ZORDER);
3383 if (fAutoTile)
3384 TileChildren(dcd->hwndParent, TRUE);
3385 WinSetWindowPos(hwndDir,
3386 HWND_TOP, 0, 0, 0, 0, SWP_ACTIVATE);
3387 }
3388 }
3389 else {
3390 strcpy(dcd->previous, dcd->directory);
[730]3391 strcpy(dcd->directory, pci->pszFileName);
[1303]3392 //DosEnterCritSec(); // GKY 11-27-08
[551]3393 dcd->stopflag++;
[1303]3394 //DosExitCritSec();
[551]3395 if (!PostMsg(dcd->hwndObject,
[841]3396 UM_RESCAN, MPVOID, MPFROMLONG(1))) {
[1303]3397 //DosEnterCritSec(); // GKY 11-27-08
[551]3398 dcd->stopflag--;
[1303]3399 //DosExitCritSec();
[551]3400 }
3401 else if (*dcd->directory) {
3402 if (hwndMain)
3403 WinSendMsg(hwndMain,
3404 UM_SETUSERLISTNAME,
3405 MPFROMP(dcd->directory), MPVOID);
3406 else
3407 add_udir(FALSE, dcd->directory);
3408 }
3409 }
3410 }
3411 else {
[2]3412
[551]3413 SWP swp;
[2]3414
[551]3415 WinQueryWindowPos(dcd->hwndFrame, &swp);
3416 WinSendMsg(hwnd,
3417 CM_SETRECORDEMPHASIS,
3418 MPFROMP(pci), MPFROM2SHORT(TRUE, CRA_INUSE));
3419 DefaultViewKeys(hwnd,
3420 dcd->hwndFrame,
[730]3421 dcd->hwndParent, &swp, pci->pszFileName);
[551]3422 WinSendMsg(hwnd,
3423 CM_SETRECORDEMPHASIS,
3424 MPFROMP(pci),
3425 MPFROM2SHORT(FALSE,
3426 CRA_INUSE |
3427 ((fUnHilite) ? CRA_SELECTED : 0)));
3428 }
3429 }
3430 else {
3431 if (!*dcd->directory || IsValidDir(dcd->directory)) {
[730]3432 NotifyError(pci->pszFileName, status);
[751]3433 RemoveCnrItems(hwnd, pci, 1, CMA_FREE | CMA_INVALIDATE | CMA_ERASE);
[551]3434 if (hwndStatus)
3435 WinSetWindowText(hwndStatus,
3436 GetPString(IDS_RESCANSUGGESTEDTEXT));
3437 }
3438 else {
[1303]3439 //DosEnterCritSec(); // GKY 11-27-08
[551]3440 dcd->stopflag++;
[1303]3441 //DosExitCritSec();
[551]3442 if (!PostMsg(dcd->hwndObject,
3443 UM_RESCAN, MPVOID, MPFROMLONG(1L))) {
[1303]3444 //DosEnterCritSec(); // GKY 11-27-08
[551]3445 dcd->stopflag--;
[1303]3446 //DosExitCritSec();
[551]3447 }
3448 else if (*dcd->directory) {
3449 if (hwndMain)
3450 WinSendMsg(hwndMain,
3451 UM_SETUSERLISTNAME,
3452 MPFROMP(dcd->directory), MPVOID);
3453 else
3454 add_udir(FALSE, dcd->directory);
3455 }
3456 }
3457 }
3458 }
3459 else if (*dcd->directory)
3460 OpenObject(dcd->directory, Default, hwnd);
[787]3461 } // CN_ENTER
[551]3462 break;
[787]3463 } // switch mp1
[551]3464 break;
[787]3465 } // if dcd
[551]3466 return 0;
[2]3467
[551]3468 case UM_LOADFILE:
3469 if (dcd && mp2) {
[2]3470
[1037]3471 HWND hwnd;
3472
3473 if ((INT)mp1 == 5 || (INT)mp1 == 13 || (INT)mp1 == 21)
[1077]3474 hwnd = StartViewer(HWND_DESKTOP, (INT)mp1,
3475 (CHAR *)mp2, dcd->hwndFrame);
[1037]3476 else
[1077]3477 hwnd = StartMLEEditor(dcd->hwndParent,
3478 (INT)mp1, (CHAR *)mp2, dcd->hwndFrame);
[1009]3479 xfree((CHAR *)mp2, pszSrcFile, __LINE__);
[1037]3480 return MRFROMLONG(hwnd);
[551]3481 }
3482 return 0;
[2]3483
[551]3484 case WM_SAVEAPPLICATION:
3485 if (dcd && ParentIsDesktop(hwnd, dcd->hwndParent)) {
[2]3486
[551]3487 SWP swp;
[2]3488
[551]3489 WinQueryWindowPos(dcd->hwndFrame, &swp);
3490 if (!(swp.fl & (SWP_HIDE | SWP_MINIMIZE | SWP_MAXIMIZE)))
3491 PrfWriteProfileData(fmprof,
3492 appname, "VDirSizePos", &swp, sizeof(swp));
3493 }
3494 break;
[2]3495
[551]3496 case WM_CLOSE:
3497 WinSendMsg(hwnd, WM_SAVEAPPLICATION, MPVOID, MPVOID);
3498 if (LastDir == hwnd)
3499 LastDir = (HWND) 0;
3500 if (dcd) {
3501 dcd->stopflag++;
3502 if (!dcd->dontclose && ParentIsDesktop(dcd->hwndFrame, (HWND) 0))
[1016]3503 PostMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID);
[1012]3504 if (dcd->hwndObject) {
[1016]3505 // Ensure object window destroy does not attempt duplicate clean up
3506 WinSetWindowPtr(dcd->hwndObject, QWL_USER, NULL);
3507 if (!PostMsg(dcd->hwndObject, WM_CLOSE, MPVOID, MPVOID))
3508 Win_Error(dcd->hwndObject, hwnd, pszSrcFile, __LINE__, "hwndObject WinPostMsg failed");
[2]3509 }
[1012]3510 if (dcd->hwndRestore)
[1016]3511 WinSetWindowPos(dcd->hwndRestore,
3512 HWND_TOP,
3513 0,
3514 0,
3515 0,
3516 0,
3517 SWP_RESTORE | SWP_SHOW | SWP_ACTIVATE | SWP_ZORDER);
[1012]3518 FreeList(dcd->lastselection);
[1039]3519 free(dcd);
[1012]3520 WinSetWindowPtr(hwnd, QWL_USER, NULL);
3521 DosPostEventSem(CompactSem);
[551]3522 }
3523 WinDestroyWindow(WinQueryWindow(WinQueryWindow(hwnd, QW_PARENT),
3524 QW_PARENT));
3525 return 0;
[2]3526
[551]3527 case WM_DESTROY:
[1078]3528# ifdef FORTIFY
[1079]3529 DbgMsg(pszSrcFile, __LINE__, "WM_DESTROY hwnd %p TID %u", hwnd, GetTidForThread()); // 18 Jul 08 SHL fixme
[1078]3530# endif
[551]3531 if (DirMenu)
3532 WinDestroyWindow(DirMenu);
3533 if (DirCnrMenu)
3534 WinDestroyWindow(DirCnrMenu);
3535 if (FileMenu)
3536 WinDestroyWindow(FileMenu);
3537 DirMenu = DirCnrMenu = FileMenu = (HWND) 0;
3538 EmptyCnr(hwnd);
[1077]3539# ifdef FORTIFY
3540 Fortify_LeaveScope();
3541# endif
[551]3542 break;
[1016]3543 } // switch
3544
3545 if (dcd && dcd->oldproc) {
3546 // 11 May 08 SHL fixme debug fortify
3547 if ((ULONG)dcd->oldproc == 0xa9a9a9a9)
3548 DbgMsg(pszSrcFile, __LINE__, "calling oldproc after dcd free msg %x mp1 %x mp2 %x", msg, mp1, mp2);
[705]3549 return dcd->oldproc(hwnd, msg, mp1, mp2);
3550 }
3551 else
3552 return PFNWPCnr(hwnd, msg, mp1, mp2);
[2]3553}
3554
[1411]3555/**
3556 * Search container for matching text
3557 * @return TRUE if key completely handled here
3558 */
3559
3560MRESULT EXPENTRY SearchContainer(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
3561{
3562 DIRCNRDATA *dcd = INSTDATA(hwnd);
3563 ULONG thistime;
3564 UINT len;
3565 SEARCHSTRING srch;
3566 PCNRITEM pci;
3567 USHORT key;
3568
3569 if (!dcd)
3570 return FALSE;
3571
3572 // Just to be safe, caller has probably already checked
3573 if (SHORT1FROMMP(mp1) & KC_KEYUP)
[1412]3574 return FALSE; // Let PM process key
[1411]3575
3576 // Just to be safe, caller has probably already cached
3577 shiftstate = (SHORT1FROMMP(mp1) & (KC_SHIFT | KC_ALT | KC_CTRL));
3578
3579 // If not plain character or suppressed
3580 // Shift toggles configured setting
3581 if (shiftstate & (KC_ALT | KC_CTRL) || (shiftstate & KC_SHIFT ? !fNoSearch : fNoSearch))
[1412]3582 return FALSE; // Let PM process key
[1411]3583
3584 if (SHORT1FROMMP(mp1) & KC_VIRTUALKEY) {
3585 key = SHORT2FROMMP(mp2);
3586 if (key == VK_BACKSPACE)
3587 key = '\x8';
3588 else if (key == VK_ESC)
3589 key = '\x1b';
3590 else
[1412]3591 return FALSE; // Let PM process key
[1411]3592 }
3593 else if (SHORT1FROMMP(mp1) & KC_CHAR)
3594 key = SHORT1FROMMP(mp2);
3595 else
3596 return FALSE;
3597
3598 thistime = WinQueryMsgTime(WinQueryAnchorBlock(hwnd));
[1412]3599 if (thistime > dcd->lasttime + 3000)
3600 *dcd->szCommonName = 0; // 3 seconds since last character
[1411]3601 dcd->lasttime = thistime;
3602
3603 switch (key) {
3604 case '\x1b': // Esc
3605 *dcd->szCommonName = 0;
3606 break;
3607 default:
3608 if (key == ' ' && !*dcd->szCommonName)
[1412]3609 break; // Let PM process space to allow select toggle
[1411]3610 len = strlen(dcd->szCommonName);
3611 if (key == '\x8') {
3612 // Backspace
3613 if (len) {
3614 len--;
3615 dcd->szCommonName[len] = 0; // Chop
3616 }
3617 }
3618 else {
3619 if (len >= CCHMAXPATH - 1) {
3620 if (!fErrorBeepOff)
3621 DosBeep(250,100);
3622 // WinAlarm(hwnd,WA_WARNING);
3623 }
3624 else {
3625 dcd->szCommonName[len] = toupper(key);
3626 dcd->szCommonName[len + 1] = 0;
3627 }
3628 }
3629 // Case insensitive search
3630 memset(&srch, 0, sizeof(SEARCHSTRING));
3631 srch.cb = (ULONG) sizeof(SEARCHSTRING);
3632 srch.pszSearch = (PSZ) dcd->szCommonName;
3633 srch.fsPrefix = TRUE;
3634 srch.fsCaseSensitive = FALSE;
3635 srch.usView = CV_ICON;
3636 pci = WinSendMsg(hwnd, CM_SEARCHSTRING, MPFROMP(&srch),
3637 MPFROMLONG(CMA_FIRST));
3638 if (pci && (INT) pci != -1) {
3639 /* Got match make found item current item */
3640 USHORT attrib = CRA_CURSORED;
[1444]3641 // 29 Mar 09 SHL fixme to clear other object select if not extended select
[1411]3642 if (!stricmp(pci->pszDisplayName, dcd->szCommonName))
3643 attrib |= CRA_SELECTED;
3644 WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPFROMP(pci),
3645 MPFROM2SHORT(TRUE, attrib));
3646 /* make sure that record shows in viewport */
3647 ShowCnrRecord(hwnd, (PMINIRECORDCORE) pci);
3648 return (MRESULT)TRUE;
3649 }
3650 else {
3651 if (key == ' ')
[1412]3652 return FALSE; // Let PM process space to toggle select
[1411]3653 // No match
3654 // Erase non-matching last character, len is not yet incremented
3655 dcd->szCommonName[len] = 0;
3656 if (len == 0 && key != '\\') {
3657 // Let's see if user forgot leading backslash
3658 // key = SHORT1FROMMP(mp2);
3659 if (SearchContainer(hwnd, msg, mp1, MPFROM2SHORT('\\', 0))) {
3660 if (SearchContainer(hwnd, msg, mp1, mp2))
[1412]3661 return (MRESULT)TRUE; // Grab key from PM
[1411]3662 }
3663 }
[1412]3664 if (*dcd->szCommonName)
3665 return (MRESULT)TRUE; // Have partial match, grab key from PM
[1411]3666#if 0 // 15 Mar 09 SHL fixme to not hang
3667 if (!fErrorBeepOff)
3668 DosBeep(250,100);
3669 // WinAlarm(hwnd,WA_WARNING);
3670#endif
3671 }
3672 } // switch
3673
[1412]3674 return FALSE; // Let PM process key
[1411]3675}
3676
[551]3677HWND StartDirCnr(HWND hwndParent, CHAR * directory, HWND hwndRestore,
3678 ULONG flags)
[275]3679{
[2]3680 /* bitmapped flags:
3681 * 0x00000001 = don't close app when window closes
3682 * 0x00000002 = no frame controls
3683 */
3684
[551]3685 HWND hwndFrame = (HWND) 0, hwndClient;
3686 ULONG FrameFlags = FCF_TITLEBAR | FCF_SYSMENU |
3687 FCF_SIZEBORDER | FCF_MINMAX | FCF_ICON | FCF_NOBYTEALIGN | FCF_ACCELTABLE;
3688 USHORT id;
[2]3689 static USHORT idinc = 0;
[551]3690 DIRCNRDATA *dcd;
3691 static BOOL first = FALSE;
[2]3692
[551]3693 if (flags & 2)
[2]3694 FrameFlags &= (~(FCF_TITLEBAR | FCF_SYSMENU | FCF_SIZEBORDER |
[551]3695 FCF_MINMAX | FCF_ICON));
3696 if (!idinc)
[2]3697 idinc = (rand() % 100);
[551]3698 if (!hwndParent)
[2]3699 hwndParent = HWND_DESKTOP;
[551]3700 if (ParentIsDesktop(hwndParent, hwndParent))
[2]3701 FrameFlags |= (FCF_TASKLIST | FCF_MENU);
[551]3702 if (!hwndMain && !first) {
3703 if (DirCnrMenu) {
[2]3704 MENUITEM mi;
[551]3705 memset(&mi, 0, sizeof(mi));
[2]3706 WinSendMsg(DirCnrMenu,
[551]3707 MM_DELETEITEM, MPFROM2SHORT(IDM_DRIVESMENU, FALSE), MPVOID);
[2]3708 mi.iPosition = MIT_END;
3709 mi.afStyle = MIS_TEXT;
3710 mi.id = IDM_DRIVESMENU;
3711 WinSendMsg(DirCnrMenu,
[551]3712 MM_INSERTITEM,
3713 MPFROMP(&mi), MPFROMP(GetPString(IDS_DRIVESMENUTEXT)));
[2]3714 }
3715 first = TRUE;
3716 }
[551]3717 if (directory) {
[2]3718 hwndFrame = WinCreateStdWindow(hwndParent,
[551]3719 WS_VISIBLE,
3720 &FrameFlags,
[593]3721 WC_DIRCONTAINER,
[551]3722 NULL,
[1394]3723 WS_VISIBLE | fwsAnimate,
[551]3724 FM3ModHandle, DIR_FRAME, &hwndClient);
3725 if (hwndFrame && hwndClient) {
[2]3726 id = DIR_FRAME + idinc++;
[551]3727 if (idinc > 99)
3728 idinc = 0;
3729 WinSetWindowUShort(hwndFrame, QWS_ID, id);
[1063]3730# ifdef FORTIFY
3731 Fortify_EnterScope();
[1077]3732# endif
[551]3733 dcd = xmallocz(sizeof(DIRCNRDATA), pszSrcFile, __LINE__);
[358]3734 if (!dcd) {
[1016]3735 PostMsg(hwndClient, WM_CLOSE, MPVOID, MPVOID);
[551]3736 hwndFrame = (HWND) 0;
[358]3737 }
3738 else {
[551]3739 dcd->size = sizeof(DIRCNRDATA);
3740 dcd->id = id;
3741 dcd->type = DIR_FRAME;
3742 dcd->hwndParent = (hwndParent) ? hwndParent : HWND_DESKTOP;
3743 dcd->hwndFrame = hwndFrame;
3744 dcd->hwndClient = hwndClient;
3745 dcd->hwndRestore = hwndRestore;
3746 dcd->dontclose = ((flags & 1) != 0);
[1065]3747 dcd->ds.detailslongname = dsDirCnrDefault.detailslongname;
3748 dcd->ds.detailssubject = dsDirCnrDefault.detailssubject;
3749 dcd->ds.detailsea = dsDirCnrDefault.detailsea;
3750 dcd->ds.detailssize = dsDirCnrDefault.detailssize;
3751 dcd->ds.detailsicon = dsDirCnrDefault.detailsicon;
3752 dcd->ds.detailsattr = dsDirCnrDefault.detailsattr;
3753 dcd->ds.detailscrdate = dsDirCnrDefault.detailscrdate;
3754 dcd->ds.detailscrtime = dsDirCnrDefault.detailscrtime;
3755 dcd->ds.detailslwdate = dsDirCnrDefault.detailslwdate;
3756 dcd->ds.detailslwtime = dsDirCnrDefault.detailslwtime;
3757 dcd->ds.detailsladate = dsDirCnrDefault.detailsladate;
3758 dcd->ds.detailslatime = dsDirCnrDefault.detailslatime;
[551]3759 strcpy(dcd->directory, directory);
3760 add_udir(FALSE, directory);
3761 {
3762 PFNWP oldproc;
[2]3763
[551]3764 oldproc = WinSubclassWindow(hwndFrame, (PFNWP) DirFrameWndProc);
3765 WinSetWindowPtr(hwndFrame, QWL_USER, (PVOID) oldproc);
[377]3766 }
[551]3767 dcd->hwndCnr = WinCreateWindow(hwndClient,
3768 WC_CONTAINER,
3769 NULL,
3770 CCS_AUTOPOSITION | CCS_MINIICONS |
[1350]3771 CCS_MINIRECORDCORE | ulCnrType, // |
3772 //WS_VISIBLE,
[551]3773 0,
3774 0,
3775 0,
3776 0,
3777 hwndClient,
3778 HWND_TOP, (ULONG) DIR_CNR, NULL, NULL);
3779 if (!dcd->hwndCnr) {
[1395]3780 Win_Error(hwndClient, hwndClient, pszSrcFile, __LINE__,
3781 PCSZ_WINCREATEWINDOW);
[551]3782 PostMsg(hwndClient, WM_CLOSE, MPVOID, MPVOID);
[1077]3783 free(dcd);
[551]3784 hwndFrame = (HWND) 0;
3785 }
[377]3786 else {
[1078]3787# ifdef FORTIFY
3788 Fortify_ChangeScope(dcd, -1);
3789# endif
[1400]3790 RestorePresParams(dcd->hwndCnr, PCSZ_DIRCNR);
[551]3791 WinSetWindowPtr(dcd->hwndCnr, QWL_USER, (PVOID) dcd);
3792 dcd->oldproc = WinSubclassWindow(dcd->hwndCnr,
[1016]3793 (PFNWP) DirCnrWndProc);
[551]3794 {
3795 USHORT ids[] = { DIR_TOTALS, DIR_SELECTED, DIR_VIEW, DIR_SORT,
3796 DIR_FILTER, DIR_FOLDERICON, DIR_MAX, 0
3797 };
[2]3798
[551]3799 if (!(flags & 2))
3800 ids[6] = 0;
3801 CommonCreateTextChildren(dcd->hwndClient,
[593]3802 WC_DIRSTATUS, ids);
[1335]3803 }
[551]3804 if (!PostMsg(dcd->hwndCnr, UM_SETUP, MPVOID, MPVOID))
3805 WinSendMsg(dcd->hwndCnr, UM_SETUP, MPVOID, MPVOID);
3806 if (FrameFlags & FCF_TASKLIST) {
[2]3807
[551]3808 SWP swp, swpD;
3809 ULONG size = sizeof(swp);
3810 LONG cxScreen, cyScreen;
[2]3811
[551]3812 WinQueryTaskSizePos(WinQueryAnchorBlock(hwndFrame), 0, &swp);
3813 if (PrfQueryProfileData(fmprof,
3814 appname, "VDirSizePos", &swpD, &size)) {
3815 cxScreen = WinQuerySysValue(HWND_DESKTOP, SV_CXSCREEN);
3816 cyScreen = WinQuerySysValue(HWND_DESKTOP, SV_CYSCREEN);
3817 if (swp.x + swpD.cx > cxScreen)
3818 swp.x = cxScreen - swpD.cx;
3819 if (swp.y + swpD.cy > cyScreen)
3820 swp.y = cyScreen - swpD.cy;
3821 swp.cx = swpD.cx;
3822 swp.cy = swpD.cy;
3823 }
3824 WinSetWindowPos(hwndFrame,
3825 HWND_TOP,
3826 swp.x,
3827 swp.y,
3828 swp.cx,
3829 swp.cy,
3830 SWP_SIZE | SWP_MOVE | SWP_SHOW | SWP_ZORDER |
3831 SWP_ACTIVATE);
[1394]3832 }
3833 WinShowWindow(dcd->hwndCnr, TRUE);
[551]3834 }
[2]3835 }
[1077]3836# ifdef FORTIFY
3837 Fortify_LeaveScope();
3838# endif
[2]3839 }
3840 }
3841 return hwndFrame;
3842}
[793]3843
3844#pragma alloc_text(DIRCNRS,DirCnrWndProc,DirObjWndProc,DirClientWndProc)
3845#pragma alloc_text(DIRCNRS,DirTextProc,DirFrameWndProc)
3846#pragma alloc_text(STARTUP,StartDirCnr)
Note: See TracBrowser for help on using the repository browser.