source: trunk/dll/treecnr.c@ 1336

Last change on this file since 1336 was 1335, checked in by Steven Levine, 17 years ago

Ticket 26: Add exception handlers to all threads using xbeginthread
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 85.8 KB
Line 
1
2/***********************************************************************
3
4 $Id: treecnr.c 1335 2008-12-12 23:49:02Z stevenhl $
5
6 Tree containers
7
8 Copyright (c) 1993-98 M. Kimes
9 Copyright (c) 2001, 2008 Steven H. Levine
10
11 16 Oct 02 SHL Handle large partitions
12 11 Jun 03 SHL Add JFS and FAT32 support
13 25 May 05 SHL Rename comnam to szCommonName and fix typo
14 25 May 05 SHL Use ULONGLONG and CommaFmtULL
15 26 May 05 SHL More large file formatting updates
16 05 Jun 05 SHL Use QWL_USER
17 06 Aug 05 SHL Renames
18 08 Dec 05 SHL TreeCnrWndProc: disable menu items if drive not ready
19 17 Jul 06 SHL Use Runtime_Error
20 15 Aug 06 SHL Rework SetMask args
21 31 Aug 06 JS Add more partitioning menu items
22 22 Oct 06 GKY Add NDFS32 support
23 29 Dec 06 GKY Fixed menu gray out for remote drives (added variable "remote")
24 29 Dec 06 GKY Enabled edit of drive flags on "not ready" drives
25 18 Feb 07 GKY More drive type and icon support
26 08 Mar 07 SHL Ensure drive icon updates after drive flags change
27 09 Mar 07 GKY Use SelectDriveIcon
28 30 Mar 07 GKY Remove GetPString for window class names
29 06 Apr 07 GKY Work around PM DragInfo and DrgFreeDISH limits
30 06 Apr 07 GKY Add some error checking in drag/drop
31 19 Apr 07 SHL Sync with AcceptOneDrop GetOneDrop mods
32 19 Apr 07 SHL Add more drag/drop error checking
33 12 May 07 SHL Use dcd->ulItemsToUnHilite; sync with UnHilite arg mods
34 10 Jun 07 GKY Add CheckPmDrgLimit including IsFm2Window as part of work around PM drag limit
35 10 Jun 07 GKY Mouse button 3 white space click to fail silently
36 05 Jul 07 SHL Disable leftover debug code
37 02 Aug 07 SHL Sync with CNRITEM mods
38 06 Aug 07 GKY Reduce DosSleep times (ticket 148)
39 14 Aug 07 SHL Revert ShowTreeRec DosSleep to 0
40 14 Aug 07 SHL Optimze ShowTreeRec collapse - was really slow
41 20 Aug 07 GKY Move #pragma alloc_text to end for OpenWatcom compat
42 22 Aug 07 SHL Disable DbgMsgs shipped with 3.0.8beta1
43 26 Aug 07 SHL Revert to DosSleep(0)
44 22 Nov 07 GKY Use CopyPresParams to fix presparam inconsistencies in menus
45 10 Jan 08 SHL Sync with CfgDlgProc mods
46 15 Feb 08 SHL Sync with settings menu rework
47 15 Feb 08 SHL Avoid death if tree container 0 width
48 19 Jul 08 GKY Replace save_dir2(dir) with pFM2SaveDirectory
49 02 Aug 08 GKY Always pass temp variable point to UM_SHOWME to avoid freeing pci->pszFileName early
50 19 Oct 08 GKY Fixed logic for greying menu items (Format etc) on remote and virtual drives (it was reversed)
51 19 Oct 08 GKY Fixed context menu to be "drives" menu on unformatted drives
52 28 Nov 08 GKY Remove unneeded DosEnterCriSec calls
53 10 Dec 08 SHL Integrate exception handler support
54
55***********************************************************************/
56
57#include <stdlib.h>
58#include <string.h>
59#include <ctype.h>
60// #include <process.h> // _beginthread
61
62#define INCL_DOS
63#define INCL_WIN
64#define INCL_LONGLONG
65#define INCL_DOSERRORS
66
67#include "fm3dll.h"
68#include "fm3dll2.h" // #define's for UM_*, control id's, etc.
69#include "treecnr.h"
70#include "mainwnd2.h" // Data declaration(s)
71#include "grep.h" // Data declaration(s)
72#include "dircnrs.h" // Data declaration(s)
73#include "info.h" // Data declaration(s)
74#include "fm3dlg.h"
75#include "fm3str.h"
76#include "mle.h"
77#include "comp.h" // COMPARE
78#include "filldir.h" // RemoveCnrItems...
79#include "errutil.h" // Dos_Error...
80#include "strutil.h" // GetPString
81#include "notebook.h" // CfgDlgProc
82#include "command.h" // RunCommand
83#include "worker.h" // Action, MassAction
84#include "mainwnd.h" // BubbleHelp, FindDirCnrByName, GetNextWindowPos
85#include "misc.h" // CnrDirectEdit, EmphasizeButton, FindDirCnr
86 // FindDirCnr, FixSwitchList, OpenEdit, QuickPopup
87 // SetSortChecks, SwitchCommand, CheckMenu
88 // CurrentRecord, IsFm2Window
89#include "common.h" // CommonCnrProc, CommonDriveCmd, CommonFrameWndProc
90 // CommonTextProc
91#include "valid.h" // CheckDrive, DriveFlagsOne, IsValidDrive
92#include "chklist.h" // DropListProc
93#include "select.h" // ExpandAll
94#include "findrec.h" // FindCnrRecord, FindParentRecord, ShowCnrRecord
95#include "flesh.h" // Flesh, UnFlesh
96#include "notify.h" // HideNote
97#include "objwin.h" // MakeObjWin
98#include "notify.h" // NotifyError
99#include "remap.h" // RemapDlgProc
100#include "saveclip.h" // SaveListDlgProc
101#include "update.h" // SelectDriveIcon, UpdateCnrList, UpdateCnrRecord
102#include "sortcnr.h" // SortTreeCnr
103#include "droplist.h" // AcceptOneDrop, CheckPmDrgLimit, DropHelp, GetOneDrop
104#include "presparm.h" // CopyPresParams
105#include "defview.h" // DefaultViewKeys
106#include "draglist.h" // DoFileDrag
107#include "filter.h" // Filter
108#include "shadow.h" // OpenObject
109#include "mkdir.h" // PMMkDir
110#include "collect.h" // StartCollector
111#include "viewer.h" // StartMLEEditor
112#include "newview.h" // StartViewer
113#include "walkem.h" // WalkAllDlgProc
114#include "commafmt.h" // CommaFmtULL
115#include "wrappers.h" // xDosFindFirst
116#include "systemf.h" // runemf2
117#include "dirs.h" // save_dir2
118#include "fortify.h"
119#include "init.h" // GetTidForWindow
120#include "excputil.h" // xbeginthread
121
122// Data definitions
123
124#pragma data_seg(GLOBAL1)
125HWND LastDir;
126HWND TreeCnrMenu;
127INT driveserial[26];
128BOOL fDCOpens;
129BOOL fDummy;
130BOOL fFollowTree;
131BOOL fTopDir;
132HPOINTER hptrDunno;
133HWND hwndMainMenu;
134
135#pragma data_seg(GLOBAL2)
136ULONG FM3UL;
137INT TreesortFlags;
138
139#pragma data_seg(DATA1)
140
141static PSZ pszSrcFile = __FILE__;
142static BOOL fOkayMinimize;
143
144APIRET16 APIENTRY16 Dos16MemAvail(PULONG pulAvailMem);
145
146typedef struct APPNOTIFY
147{
148 HAPP happ;
149 CHAR device;
150 struct APPNOTIFY *next;
151 struct APPNOTIFY *prev;
152}
153APPNOTIFY;
154
155MRESULT EXPENTRY OpenButtonProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
156{
157 static BOOL emphasized = FALSE;
158
159 switch (msg) {
160 case WM_CREATE:
161 {
162 MRESULT rc;
163
164 rc = PFNWPButton(hwnd, msg, mp1, mp2);
165 WinSetPresParam(hwnd, PP_FONTNAMESIZE,
166 strlen(GetPString(IDS_8TIMESNEWROMANTEXT)) + 1,
167 (PVOID) GetPString(IDS_8TIMESNEWROMANTEXT));
168 return rc;
169 }
170
171 case WM_MOUSEMOVE:
172 BubbleHelp(hwnd, TRUE, FALSE, TRUE, GetPString(IDS_OPENBUTTONHELP));
173 break;
174
175 case WM_CONTEXTMENU:
176 PostMsg(WinQueryWindow(hwnd, QW_PARENT),
177 WM_COMMAND, MPFROM2SHORT(IDM_OPENWALK, 0), MPVOID);
178 return 0;
179
180 case DM_DRAGOVER:
181 if (!emphasized) {
182 emphasized = TRUE;
183 EmphasizeButton(hwnd, emphasized);
184 }
185 if (AcceptOneDrop(hwnd, mp1, mp2))
186 return MRFROM2SHORT(DOR_DROP, DO_MOVE);
187 return MRFROM2SHORT(DOR_NEVERDROP, 0);
188
189 case DM_DRAGLEAVE:
190 if (emphasized) {
191 emphasized = FALSE;
192 EmphasizeButton(hwnd, emphasized);
193 }
194 break;
195
196 case DM_DROPHELP:
197 DropHelp(mp1, mp2, hwnd, GetPString(IDS_OPENDROPHELP));
198 return 0;
199
200 case DM_DROP:
201 {
202 char szFrom[CCHMAXPATH + 2];
203
204 if (emphasized) {
205 emphasized = FALSE;
206 EmphasizeButton(hwnd, emphasized);
207 }
208 if (GetOneDrop(hwnd, mp1, mp2, szFrom, sizeof(szFrom))) {
209 MakeValidDir(szFrom);
210 WinSendMsg(WinQueryWindow(hwnd, QW_PARENT),
211 UM_OPENWINDOWFORME, MPFROMP(szFrom), MPVOID);
212 }
213 }
214 return 0;
215
216 }
217 return PFNWPButton(hwnd, msg, mp1, mp2);
218}
219
220VOID ShowTreeRec(HWND hwndCnr,
221 CHAR *dirname,
222 BOOL collapsefirst,
223 BOOL maketop)
224{
225 /* Find a record in tree view, move it so it shows in container and
226 make it the current record */
227
228 PCNRITEM pci, pciToSelect, pciP;
229 BOOL quickbail = FALSE;
230 CHAR szDir[CCHMAXPATH], *p;
231
232 // already positioned to requested record?
233 pci = WinSendMsg(hwndCnr,
234 CM_QUERYRECORDEMPHASIS,
235 MPFROMLONG(CMA_FIRST), MPFROMSHORT(CRA_CURSORED));
236 if (pci && (INT) pci != -1 && !stricmp(pci->pszFileName, dirname)) {
237 // DbgMsg(pszSrcFile, __LINE__, "already at %s collapse %u maketop %u", dirname, collapsefirst, maketop); // 14 Aug 07 SHL fixme
238 quickbail = TRUE; // Bypass repositioning
239 goto MakeTop;
240 }
241 WinEnableWindowUpdate(hwndCnr, FALSE);
242 // DbgMsg(pszSrcFile, __LINE__, "finding %s collapse %u maketop %u", dirname, collapsefirst, maketop); // 14 Aug 07 SHL fixme
243 pci = FindCnrRecord(hwndCnr, dirname, NULL, TRUE, FALSE, TRUE);
244 if (!pci || (INT) pci == -1) {
245 *szDir = *dirname;
246 szDir[1] = ':';
247 szDir[2] = '\\';
248 szDir[3] = 0;
249 p = szDir + 3; // Point after root backslash
250 for (;;) {
251 pciP = FindCnrRecord(hwndCnr, szDir, NULL, TRUE, FALSE, TRUE);
252 if (pciP && (INT) pciP != -1) {
253 if (!stricmp(dirname, pciP->pszFileName))
254 break; // Found it
255 if (~pciP->rc.flRecordAttr & CRA_EXPANDED)
256 WinSendMsg(hwndCnr, CM_EXPANDTREE, MPFROMP(pciP), MPVOID);
257 strcpy(szDir, dirname);
258 if (p - szDir >= strlen(szDir))
259 break; // Not root dir
260 p = strchr(p, '\\');
261 if (p) {
262 *p = 0; // fixme?
263 p++;
264 }
265 else
266 break;
267 }
268 else
269 break;
270 DosSleep(0);
271 } // for
272 pci = FindCnrRecord(hwndCnr, dirname, NULL, TRUE, FALSE, TRUE);
273 }
274 // DbgMsg(pszSrcFile, __LINE__, "found"); // 14 Aug 07 SHL fixme
275 if (pci && (INT) pci != -1) {
276 if (~pci->rc.flRecordAttr & CRA_CURSORED) {
277 if (collapsefirst) {
278 // DbgMsg(pszSrcFile, __LINE__, "collapsing"); // 14 Aug 07 SHL fixme
279 pciP = WinSendMsg(hwndCnr,
280 CM_QUERYRECORD,
281 MPVOID, MPFROM2SHORT(CMA_FIRST, CMA_ITEMORDER));
282 while (pciP && (INT) pciP != -1) {
283#if 1 // // 05 Jan 08 SHL fixme to be sure this is correct code
284 if (pciP->rc.flRecordAttr & CRA_EXPANDED) {
285 // collapse top level of all branches
286 WinSendMsg(hwndCnr, CM_COLLAPSETREE, MPFROMP(pciP), MPVOID);
287 }
288#else // fixme to be gone
289 if (toupper(*pciP->pszFileName) == toupper(*dirname)) {
290 // collapse all levels if branch is our drive
291 if (pciP->rc.flRecordAttr & CRA_EXPANDED)
292 ExpandAll(hwndCnr, FALSE, pciP);
293 }
294 else if (pciP->rc.flRecordAttr & CRA_EXPANDED) {
295 // collapse top level of all branches
296 WinSendMsg(hwndCnr, CM_COLLAPSETREE, MPFROMP(pciP), MPVOID);
297 }
298#endif
299 pciP = WinSendMsg(hwndCnr,
300 CM_QUERYRECORD,
301 MPFROMP(pciP),
302 MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
303 } // while
304 }
305 /* expand all parent branches */
306 // DbgMsg(pszSrcFile, __LINE__, "expanding parents"); // 14 Aug 07 SHL fixme
307 pciToSelect = pci;
308 for (;;) {
309 pciP = WinSendMsg(hwndCnr,
310 CM_QUERYRECORD,
311 MPFROMP(pciToSelect),
312 MPFROM2SHORT(CMA_PARENT, CMA_ITEMORDER));
313 if (pciP && (INT) pciP != -1) {
314 if (!(pciP->rc.flRecordAttr & CRA_EXPANDED))
315 WinSendMsg(hwndCnr, CM_EXPANDTREE, MPFROMP(pciP), MPVOID);
316 pciToSelect = pciP;
317 }
318 else
319 break;
320 DosSleep(0); // Let GUI update
321 } // for
322 }
323 /* make record visible */
324 MakeTop:
325 // DbgMsg(pszSrcFile, __LINE__, "moving into view"); // 14 Aug 07 SHL fixme
326 pciToSelect = pci;
327 if (pciToSelect && (INT) pciToSelect != -1) {
328 if (fTopDir || maketop) {
329 ShowCnrRecord(hwndCnr, (PMINIRECORDCORE) pciToSelect);
330 }
331 if (fSwitchTreeExpand && ~pciToSelect->rc.flRecordAttr & CRA_EXPANDED) {
332 // DbgMsg(pszSrcFile, __LINE__, "expanding current"); // 14 Aug 07 SHL fixme
333 WinSendMsg(hwndCnr, CM_EXPANDTREE, MPFROMP(pciToSelect), MPVOID);
334 // DbgMsg(pszSrcFile, __LINE__, "expanded"); // 14 Aug 07 SHL fixme
335 }
336 if (!quickbail) {
337 WinSendMsg(hwndCnr,
338 CM_SETRECORDEMPHASIS,
339 MPFROMP(pciToSelect),
340 MPFROM2SHORT(TRUE, CRA_SELECTED | CRA_CURSORED));
341 }
342 }
343 }
344 // DbgMsg(pszSrcFile, __LINE__, "done"); // 14 Aug 07 SHL fixme
345 WinEnableWindowUpdate(hwndCnr, TRUE);
346 // DosSleep(1); // Let GUI update
347}
348
349MRESULT EXPENTRY TreeTitleWndProc(HWND hwnd, ULONG msg, MPARAM mp1,
350 MPARAM mp2)
351{
352 PFNWP oldproc = (PFNWP) WinQueryWindowPtr(hwnd, QWL_USER);
353
354 switch (msg) {
355 case WM_CONTEXTMENU:
356 return WinSendMsg(WinQueryWindow(hwnd, QW_PARENT),
357 UM_CONTEXTMENU, mp1, mp2);
358 }
359 return oldproc(hwnd, msg, mp1, mp2);
360}
361
362MRESULT EXPENTRY TreeStatProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
363{
364 switch (msg) {
365 case WM_CREATE:
366 return CommonTextProc(hwnd, msg, mp1, mp2);
367
368 case WM_CONTEXTMENU:
369 PostMsg(WinQueryWindow(hwnd, QW_PARENT), msg, mp1, mp2);
370 return 0;
371
372 case WM_PAINT:
373 {
374 MRESULT mr = PFNWPStatic(hwnd, msg, mp1, mp2);
375
376 PaintRecessedWindow(hwnd, (HPS) 0, FALSE, FALSE);
377 return mr;
378 }
379
380 case WM_SETFOCUS:
381 if (mp2)
382 PostMsg(hwnd, UM_FOCUSME, MPVOID, MPVOID);
383 break;
384
385 case UM_FOCUSME:
386 WinSetFocus(HWND_DESKTOP, WinQueryWindow(hwnd, QW_PARENT));
387 return 0;
388 }
389 return PFNWPStatic(hwnd, msg, mp1, mp2);
390}
391
392MRESULT EXPENTRY TreeFrameWndProc(HWND hwnd, ULONG msg, MPARAM mp1,
393 MPARAM mp2)
394{
395 switch (msg) {
396 case UM_RESCAN:
397 PostMsg(WinQueryWindow(hwnd, QW_PARENT), msg, mp1, mp2);
398 return 0;
399
400 case WM_ADJUSTWINDOWPOS:
401 {
402 SWP *pswp;
403
404 pswp = (SWP *) mp1;
405 if (ParentIsDesktop(hwnd, (HWND) 0)) {
406 if (pswp->fl & (SWP_HIDE | SWP_MINIMIZE))
407 HideNote();
408 }
409 }
410 break;
411
412 case WM_TRACKFRAME:
413 if (!fFreeTree && !ParentIsDesktop(hwnd, (HWND) 0)) {
414 switch (SHORT1FROMMP(mp1) & TF_MOVE) {
415 case TF_MOVE:
416 case TF_LEFT:
417 case TF_TOP:
418 case (TF_LEFT | TF_BOTTOM):
419 case (TF_LEFT | TF_TOP):
420 {
421 SWP swp;
422
423 WinQueryWindowPos(hwnd, &swp);
424 if (!(swp.fl & SWP_ACTIVATE))
425 WinSetWindowPos(hwnd, HWND_TOP, 0, 0, 0, 0,
426 SWP_ZORDER | SWP_ACTIVATE);
427 }
428 return 0;
429 }
430 }
431 break;
432
433 case WM_CALCFRAMERECT:
434 if (*(ULONG *) realappname != FM3UL) {
435
436 MRESULT mr;
437 PRECTL prectl;
438
439 mr = CommonFrameWndProc(TREE_CNR, hwnd, msg, mp1, mp2);
440
441 /*
442 * Calculate the position of the client rectangle.
443 * Otherwise, we'll see a lot of redraw when we move the
444 * client during WM_FORMATFRAME.
445 */
446
447 if (mr && mp2) {
448 prectl = (PRECTL) mp1;
449 prectl->yTop -= 22;
450 }
451 return mr;
452 }
453 break;
454
455 case WM_FORMATFRAME:
456 {
457 SHORT sCount;
458 PSWP pswp, pswpClient, pswpNew;
459
460 sCount = (SHORT) CommonFrameWndProc(TREE_CNR, hwnd, msg, mp1, mp2);
461
462 /*
463 * Reformat the frame to "squeeze" the client
464 */
465
466 pswp = (PSWP) mp1;
467 {
468 SHORT x;
469
470 for (x = 0; x < sCount; x++) {
471 if (WinQueryWindowUShort(pswp->hwnd, QWS_ID) == FID_CLIENT) {
472 pswpClient = pswp;
473 break;
474 }
475 pswp++;
476 }
477 }
478 pswpNew = (PSWP) mp1 + sCount;
479 *pswpNew = *pswpClient;
480 pswpNew->hwnd = WinWindowFromID(hwnd, MAIN_STATUS);
481 if (*(ULONG *) realappname == FM3UL) {
482
483 PSWP pswpTitlebar = (PSWP) 0, pswpMinbutton = (PSWP) 0;
484 SHORT x;
485
486 pswpNew->hwnd = WinWindowFromID(hwnd, IDM_OPENWINDOW);
487 pswp = (PSWP) mp1;
488 for (x = 0; x < sCount; x++) {
489 if (WinQueryWindowUShort(pswp->hwnd, QWS_ID) == FID_TITLEBAR)
490 pswpTitlebar = pswp;
491 else if (WinQueryWindowUShort(pswp->hwnd, QWS_ID) == FID_MINMAX)
492 pswpMinbutton = pswp;
493 if (pswpTitlebar && pswpMinbutton)
494 break;
495 pswp++;
496 }
497 pswpNew->cy = pswpMinbutton->cy + 3;
498 pswpNew->cx = min(pswpNew->cy, (pswpMinbutton->cx / 2) + 3);
499 pswpTitlebar->cx -= (pswpNew->cx + 1);
500 pswpNew->x = pswpTitlebar->x + pswpTitlebar->cx;
501 pswpNew->y = pswpMinbutton->y - 1;
502 }
503 else {
504 pswpNew->x = pswpClient->x + 3;
505 pswpNew->y = (pswpClient->y + pswpClient->cy) - 20;
506 pswpNew->cx = pswpClient->cx - 6;
507 pswpNew->cy = 18;
508 pswpClient->cy -= 22;
509 }
510 sCount++;
511 return MRFROMSHORT(sCount);
512 }
513
514 case WM_QUERYFRAMECTLCOUNT:
515 {
516 SHORT sCount;
517
518 sCount = (SHORT) CommonFrameWndProc(TREE_CNR, hwnd, msg, mp1, mp2);
519 sCount++;
520 return MRFROMSHORT(sCount);
521 }
522 }
523 return CommonFrameWndProc(TREE_CNR, hwnd, msg, mp1, mp2);
524}
525
526MRESULT EXPENTRY TreeClientWndProc(HWND hwnd, ULONG msg, MPARAM mp1,
527 MPARAM mp2)
528{
529
530 switch (msg) {
531 case UM_CONTAINERHWND:
532 return MRFROMLONG(WinWindowFromID(hwnd, TREE_CNR));
533
534 case UM_VIEWSMENU:
535 return MRFROMLONG(CheckMenu(hwndMainMenu, &TreeCnrMenu, TREECNR_POPUP));
536
537 case UM_TIMER:
538 case UM_ACTION:
539 case UM_SHOWME:
540 case UM_OPENWINDOWFORME:
541 case UM_MINIMIZE:
542 case UM_MAXIMIZE:
543 case WM_INITMENU:
544 case UM_INITMENU:
545 case UM_FILTER:
546 case UM_FILESMENU:
547 case UM_UPDATERECORD:
548 case UM_UPDATERECORDLIST:
549 case MM_PORTHOLEINIT:
550 case UM_DRIVECMD:
551 case WM_CLOSE:
552 case WM_CONTROL:
553 case UM_COMMAND:
554 case WM_COMMAND:
555 return WinSendMsg(WinWindowFromID(hwnd, TREE_CNR), msg, mp1, mp2);
556
557 case WM_PSETFOCUS:
558 case WM_SETFOCUS:
559 if (mp2)
560 PostMsg(hwnd, UM_FOCUSME, MPVOID, MPVOID);
561 break;
562
563 case UM_FOCUSME:
564 WinSetFocus(HWND_DESKTOP, WinWindowFromID(hwnd, TREE_CNR));
565 break;
566
567 case WM_ERASEBACKGROUND:
568 WinFillRect((HPS) mp1, (PRECTL) mp2, 0x00d0d0d0);
569 return 0;
570
571 case WM_PAINT:
572 {
573 HPS hps;
574 RECTL rcl;
575
576 hps = WinBeginPaint(hwnd, (HPS) 0, NULL);
577 if (hps) {
578 WinQueryWindowRect(hwnd, &rcl);
579 WinFillRect(hps, &rcl, CLR_PALEGRAY);
580 PaintRecessedWindow(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
581 MAIN_STATUS), hps, FALSE, FALSE);
582 WinEndPaint(hps);
583 }
584 }
585 break;
586
587 case WM_SIZE:
588 WinSetWindowPos(WinWindowFromID(hwnd, TREE_CNR),
589 HWND_TOP,
590 0,
591 0,
592 SHORT1FROMMP(mp2),
593 SHORT2FROMMP(mp2), SWP_SHOW | SWP_MOVE | SWP_SIZE);
594 if (hwndMain)
595 PostMsg(hwndMain, UM_SIZE, MPVOID, MPVOID);
596 break;
597
598 case WM_CONTEXTMENU:
599 case UM_CONTEXTMENU:
600 PostMsg(WinWindowFromID(hwnd, TREE_CNR),
601 WM_CONTROL, MPFROM2SHORT(TREE_CNR, CN_CONTEXTMENU), MPVOID);
602 return 0;
603 }
604 return WinDefWindowProc(hwnd, msg, mp1, mp2);
605}
606
607MRESULT EXPENTRY TreeObjWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
608{
609 DIRCNRDATA *dcd;
610
611 switch (msg) {
612 case WM_CREATE:
613 DbgMsg(pszSrcFile, __LINE__, "WM_CREATE mp1 %p mp2 %p", mp1, mp2); // 18 Jul 08 SHL fixme
614 break;
615
616 case UM_SHOWME:
617 // DbgMsg(pszSrcFile, __LINE__, "UM_SHOWME mp1 %p mp2 %p", mp1, mp2); // 14 Aug 07 SHL fixme
618 if (mp1) {
619# ifdef FORTIFY
620 Fortify_BecomeOwner(mp1);
621# endif
622 dcd = INSTDATA(hwnd);
623 // DbgMsg(pszSrcFile, __LINE__, "UM_SHOWME dcd %p", dcd); // 14 Aug 07 SHL fixme
624 if (dcd) {
625 BOOL tempsusp, tempfollow, temptop;
626
627 tempsusp = dcd->suspendview;
628 dcd->suspendview = TRUE;
629 tempfollow = fFollowTree;
630 fFollowTree = FALSE;
631 if (mp2) {
632 temptop = fTopDir;
633 fTopDir = TRUE;
634 }
635 ShowTreeRec(dcd->hwndCnr, (CHAR *)mp1, fCollapseFirst, TRUE);
636 dcd->suspendview = tempsusp;
637 fFollowTree = tempfollow;
638 if (mp2)
639 fTopDir = temptop;
640 }
641 free((CHAR *)mp1);
642 }
643 return 0;
644
645 case DM_PRINTOBJECT:
646 return MRFROMLONG(DRR_TARGET);
647
648 case DM_DISCARDOBJECT:
649 dcd = INSTDATA(hwnd);
650 if (fFM2Deletes && dcd) {
651
652 LISTINFO *li;
653 CNRDRAGINFO cni;
654
655 cni.pRecord = NULL;
656 cni.pDragInfo = (PDRAGINFO) mp1;
657 li = DoFileDrop(dcd->hwndCnr,
658 dcd->directory, FALSE, MPVOID, MPFROMP(&cni));
659 CheckPmDrgLimit(cni.pDragInfo);
660 if (li) {
661 li->type = ((fDefaultDeletePerm) ? IDM_PERMDELETE : IDM_DELETE);
662 if (!PostMsg(hwnd, UM_MASSACTION, MPFROMP(li), MPVOID))
663 FreeListInfo(li);
664 else
665 return MRFROMLONG(DRR_SOURCE);
666 }
667 }
668 return MRFROMLONG(DRR_TARGET);
669
670 case UM_EXPAND:
671 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
672 if (!dcd)
673 Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
674 else {
675 BOOL tempsusp = dcd->suspendview;
676
677 dcd->suspendview = TRUE;
678 ExpandAll(dcd->hwndCnr,
679 (SHORT1FROMMP(mp1) == IDM_EXPAND), (PCNRITEM) mp2);
680 dcd->suspendview = tempsusp;
681 PostMsg(dcd->hwndCnr, UM_FILTER, MPVOID, MPVOID);
682 }
683 return 0;
684
685 case UM_UPDATERECORDLIST:
686 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
687 if (!dcd || !mp1)
688 Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
689 else {
690 INT numentries = 0;
691 CHAR **list = (CHAR **) mp1;
692
693 while (list[numentries])
694 numentries++;
695 if (numentries)
696 UpdateCnrList(dcd->hwndCnr, list, numentries, TRUE, dcd);
697 }
698 return 0;
699
700 case UM_SETUP:
701# ifdef FORTIFY
702 Fortify_EnterScope();
703# endif
704 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
705 if (!dcd)
706 Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
707 else {
708# ifdef FORTIFY
709 Fortify_BecomeOwner(dcd);
710# endif
711 dcd->hwndObject = hwnd;
712 if (ParentIsDesktop(hwnd, dcd->hwndParent))
713 DosSleep(100); //05 Aug 07 GKY 250
714 }
715 return 0;
716
717 case UM_RESCAN2:
718 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
719 if (!dcd)
720 Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
721 // Bypass if not running integrated (i.e if vtree)
722 else if (hwndStatus &&
723 dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent)) {
724 CHAR s[CCHMAXPATH * 2];
725 PCNRITEM pci = (PCNRITEM) mp1;
726 FSALLOCATE fsa;
727 struct
728 {
729 ULONG serial;
730 CHAR volumelength;
731 CHAR volumelabel[CCHMAXPATH];
732 }
733 volser;
734 CHAR tb[64];
735 CHAR szFree[64];
736 CNRINFO cnri;
737
738 strcpy(s, GetPString(IDS_TREETEXT));
739 memset(&cnri, 0, sizeof(CNRINFO));
740 cnri.cb = sizeof(CNRINFO);
741 WinSendMsg(dcd->hwndCnr,
742 CM_QUERYCNRINFO,
743 MPFROMP(&cnri), MPFROMLONG(sizeof(CNRINFO)));
744 if (cnri.cRecords) {
745 sprintf(s, GetPString(IDS_NUMDRIVESTEXT), cnri.cRecords);
746 if (pci && pci->pszFileName) {
747 if (!(driveflags[toupper(*pci->pszFileName) - 'A'] &
748 DRIVE_REMOVABLE) ||
749 driveserial[toupper(*pci->pszFileName) - 'A'] != -1) {
750 memset(&volser, 0, sizeof(volser));
751 DosError(FERR_DISABLEHARDERR);
752 if (!DosQueryFSInfo(toupper(*pci->pszFileName) - '@',
753 FSIL_VOLSER,
754 &volser,
755 (ULONG) sizeof(volser)) &&
756 dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent)) {
757 DosError(FERR_DISABLEHARDERR);
758 if (!DosQueryFSInfo(toupper(*pci->pszFileName) - '@',
759 FSIL_ALLOC, &fsa, sizeof(FSALLOCATE))) {
760 CommaFmtULL(tb, sizeof(tb),
761 (ULONGLONG) fsa.cUnitAvail * (fsa.cSectorUnit *
762 fsa.cbSector), 'M');
763 sprintf(szFree, " %s %s", tb, GetPString(IDS_FREETEXT));
764 }
765 else
766 *szFree = 0;
767 driveserial[toupper(*pci->pszFileName) - 'A'] = volser.serial;
768 sprintf(&s[strlen(s)],
769 GetPString(IDS_TREESTATUSSTARTTEXT),
770 toupper(*pci->pszFileName),
771 volser.volumelabel, volser.serial, szFree);
772 if (!fMoreButtons) {
773 if (*dcd->mask.szMask ||
774 (dcd->mask.attrFile != ALLATTRS ||
775 ((fFilesInTree ||
776 (driveflags[toupper(*pci->pszFileName)] &
777 DRIVE_INCLUDEFILES)) ?
778 dcd->mask.antiattr :
779 (dcd->mask.antiattr &&
780 dcd->mask.antiattr != FILE_DIRECTORY)))) {
781 sprintf(&s[strlen(s)],
782 " (%s)",
783 (*dcd->mask.szMask) ?
784 dcd->mask.szMask : GetPString(IDS_ATTRTEXT));
785 }
786 }
787 }
788 }
789 else {
790 /* find root record and strip it */
791 pci = FindParentRecord(dcd->hwndCnr, pci);
792 driveserial[toupper(*pci->pszFileName) - 'A'] = -1;
793 UnFlesh(dcd->hwndCnr, pci);
794 }
795 }
796 }
797 if (dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent))
798 WinSetWindowText(hwndStatus, s);
799 }
800 return 0;
801
802 case UM_RESCAN:
803 /*
804 * populate container
805 */
806 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
807 if (!dcd)
808 Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
809 else {
810 //PULONG pulPostCt;
811
812 RemoveCnrItems(dcd->hwndCnr, NULL, 0, CMA_FREE | CMA_INVALIDATE | CMA_ERASE);
813 WinSendMsg(dcd->hwndCnr,
814 CM_SCROLLWINDOW, MPFROMSHORT(CMA_VERTICAL), MPFROMLONG(-1));
815 WinSendMsg(dcd->hwndCnr,
816 CM_SCROLLWINDOW,
817 MPFROMSHORT(CMA_HORIZONTAL), MPFROMLONG(-1));
818 //if (!fInitialDriveScan) {
819 //DosWaitEventSem(DriveScanStart, 20000);
820 while (StubbyScanCount != 0)
821 DosSleep(50);
822 /*pulPostCt = xmallocz(sizeof(ULONG), pszSrcFile, __LINE__);
823 if (pulPostCt) {
824 DosResetEventSem(DriveScanStart, pulPostCt);
825 free(pulPostCt);
826 } */
827 //}
828 //else
829 // fInitialDriveScan = FALSE;
830 FillTreeCnr(dcd->hwndCnr, dcd->hwndParent);
831 if (fOkayMinimize) {
832 PostMsg(dcd->hwndCnr, UM_MINIMIZE, MPVOID, MPVOID);
833 fOkayMinimize = FALSE;
834 }
835 WinSendMsg(dcd->hwndCnr,
836 CM_INVALIDATERECORD,
837 MPVOID, MPFROM2SHORT(0, CMA_ERASE | CMA_REPOSITION));
838 PostMsg(dcd->hwndCnr, UM_RESCAN, MPVOID, MPVOID);
839 }
840 return 0;
841
842 case UM_COMMAND:
843 if (mp1) {
844
845 LISTINFO *li = (LISTINFO *) mp1;
846
847 switch (li->type) {
848 case IDM_DOITYOURSELF:
849 case IDM_APPENDTOCLIP:
850 case IDM_SAVETOCLIP:
851 case IDM_ARCHIVE:
852 case IDM_VIEW:
853 case IDM_EDIT:
854 case IDM_OBJECT:
855 case IDM_SHADOW:
856 case IDM_SHADOW2:
857 case IDM_PRINT:
858 case IDM_ATTRS:
859 case IDM_DELETE:
860 case IDM_PERMDELETE:
861 if (PostMsg(hwnd, UM_MASSACTION, mp1, mp2))
862 return (MRESULT) TRUE;
863 default:
864 if (PostMsg(hwnd, UM_ACTION, mp1, mp2))
865 return (MRESULT) TRUE;
866 }
867 }
868 return 0;
869
870 case UM_MASSACTION:
871 if (mp1) {
872
873 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
874 if (!dcd)
875 Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
876 else {
877 WORKER *wk;
878# ifdef FORTIFY
879 Fortify_EnterScope();
880# endif
881 wk = xmallocz(sizeof(WORKER), pszSrcFile, __LINE__);
882 if (!wk)
883 FreeListInfo((LISTINFO *) mp1);
884 else {
885 wk->size = sizeof(WORKER);
886 wk->hwndCnr = dcd->hwndCnr;
887 wk->hwndParent = dcd->hwndParent;
888 wk->hwndFrame = dcd->hwndFrame;
889 wk->hwndClient = dcd->hwndClient;
890 wk->li = (LISTINFO *) mp1;
891 strcpy(wk->directory, dcd->directory);
892 if (xbeginthread(MassAction,
893 122880,
894 wk,
895 pszSrcFile,
896 __LINE__) == -1)
897 {
898 free(wk);
899 FreeListInfo((LISTINFO *) mp1);
900 }
901 }
902# ifdef FORTIFY
903 Fortify_LeaveScope();
904# endif
905 }
906 }
907 return 0;
908
909 case UM_ACTION:
910# ifdef FORTIFY
911 Fortify_EnterScope();
912# endif
913 if (mp1) {
914# ifdef FORTIFY
915 Fortify_BecomeOwner(mp1);
916# endif
917 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
918 if (!dcd)
919 Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
920 else {
921 WORKER *wk;
922 wk = xmallocz(sizeof(WORKER), pszSrcFile, __LINE__);
923 if (!wk)
924 FreeListInfo((LISTINFO *) mp1);
925 else {
926 wk->size = sizeof(WORKER);
927 wk->hwndCnr = dcd->hwndCnr;
928 wk->hwndParent = dcd->hwndParent;
929 wk->hwndFrame = dcd->hwndFrame;
930 wk->hwndClient = dcd->hwndClient;
931 wk->li = (LISTINFO *) mp1;
932 strcpy(wk->directory, dcd->directory);
933 if (xbeginthread(Action,
934 122880,
935 wk,
936 pszSrcFile,
937 __LINE__) == -1)
938 {
939 free(wk);
940 FreeListInfo((LISTINFO *) mp1);
941 }
942 }
943 }
944 }
945# ifdef FORTIFY
946 Fortify_LeaveScope();
947# endif
948 return 0;
949
950 case WM_CLOSE:
951 WinDestroyWindow(hwnd);
952 break;
953
954 case WM_DESTROY:
955 hwndTree = (HWND) 0;
956 dcd = WinQueryWindowPtr(hwnd, QWL_USER);
957 if (dcd) {
958 WinSendMsg(dcd->hwndCnr,
959 UM_CLOSE, MPFROMLONG(dcd->dontclose != FALSE), MPVOID);
960 free(dcd);
961# ifdef FORTIFY
962 Fortify_LeaveScope();
963# endif
964 WinSetWindowPtr(dcd->hwndCnr, QWL_USER, NULL);
965 }
966 DosPostEventSem(CompactSem);
967 if (!PostMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID))
968 WinSendMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID);
969 break;
970 }
971 return WinDefWindowProc(hwnd, msg, mp1, mp2);
972}
973
974MRESULT EXPENTRY TreeCnrWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
975{
976 static APPNOTIFY *apphead = NULL, *apptail = NULL;
977 DIRCNRDATA *dcd = INSTDATA(hwnd);
978
979 switch (msg) {
980 case WM_CREATE:
981 DbgMsg(pszSrcFile, __LINE__, "WM_CREATE mp1 %p mp2 %p", mp1, mp2); // 18 Jul 08 SHL fixme
982 break;
983
984 case DM_PRINTOBJECT:
985 return MRFROMLONG(DRR_TARGET);
986
987 case DM_DISCARDOBJECT:
988 if (dcd)
989 return WinSendMsg(dcd->hwndObject, msg, mp1, mp2);
990 else
991 return MRFROMLONG(DRR_TARGET);
992
993 case WM_CHAR:
994 shiftstate = (SHORT1FROMMP(mp1) & (KC_SHIFT | KC_ALT | KC_CTRL));
995 if (SHORT1FROMMP(mp1) & KC_KEYUP)
996 return (MRESULT) TRUE;
997 if (SHORT1FROMMP(mp1) & KC_VIRTUALKEY) {
998 switch (SHORT2FROMMP(mp2)) {
999 case VK_INSERT:
1000 if ((shiftstate & KC_CTRL) == KC_CTRL)
1001 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_MKDIR, 0), MPVOID);
1002 break;
1003 case VK_DELETE:
1004 if ((shiftstate & KC_CTRL) == KC_CTRL)
1005 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_PERMDELETE, 0), MPVOID);
1006 else if ((shiftstate & KC_SHIFT) == KC_SHIFT)
1007 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_SAVETOCLIP, 0), MPVOID);
1008 else
1009 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_DELETE, 0), MPVOID);
1010 break;
1011 }
1012 }
1013 if (shiftstate || fNoSearch)
1014 break;
1015 if (SHORT1FROMMP(mp1) & KC_CHAR) {
1016
1017 ULONG thistime, len;
1018 SEARCHSTRING srch;
1019 PCNRITEM pci;
1020
1021 if (!dcd)
1022 break;
1023 switch (SHORT1FROMMP(mp2)) {
1024 case '\x1b':
1025 case '\r':
1026 case '\n':
1027 dcd->lasttime = 0;
1028 *dcd->szCommonName = 0;
1029 break;
1030 default:
1031 thistime = WinQueryMsgTime(WinQueryAnchorBlock(hwnd));
1032 if (thistime > dcd->lasttime + 1250)
1033 *dcd->szCommonName = 0;
1034 dcd->lasttime = thistime;
1035 if (SHORT1FROMMP(mp2) == ' ' && !*dcd->szCommonName)
1036 break;
1037 KbdRetry:
1038 len = strlen(dcd->szCommonName);
1039 if (len >= CCHMAXPATH - 1) {
1040 *dcd->szCommonName = 0;
1041 len = 0;
1042 }
1043 dcd->szCommonName[len] = toupper(SHORT1FROMMP(mp2));
1044 dcd->szCommonName[len + 1] = 0;
1045 memset(&srch, 0, sizeof(SEARCHSTRING));
1046 srch.cb = (ULONG) sizeof(SEARCHSTRING);
1047 srch.pszSearch = (PSZ) dcd->szCommonName;
1048 srch.fsPrefix = TRUE;
1049 srch.fsCaseSensitive = FALSE;
1050 srch.usView = CV_ICON;
1051 pci = WinSendMsg(hwnd,
1052 CM_SEARCHSTRING,
1053 MPFROMP(&srch), MPFROMLONG(CMA_FIRST));
1054 if (pci && (INT) pci != -1) {
1055 /* make found item current item */
1056 WinSendMsg(hwnd,
1057 CM_SETRECORDEMPHASIS,
1058 MPFROMP(pci), MPFROM2SHORT(TRUE, CRA_CURSORED));
1059 /* make sure that record shows in viewport */
1060 ShowCnrRecord(hwnd, (PMINIRECORDCORE) pci);
1061 return (MRESULT) TRUE;
1062 }
1063 else {
1064 if (SHORT1FROMMP(mp2) == ' ') {
1065 dcd->szCommonName[len] = 0;
1066 break;
1067 }
1068 *dcd->szCommonName = 0;
1069 dcd->lasttime = 0;
1070 if (len) // retry as first letter if no match
1071 goto KbdRetry;
1072 }
1073 break;
1074 }
1075 }
1076 break;
1077
1078 case WM_MOUSEMOVE:
1079 case WM_BUTTON1UP:
1080 case WM_BUTTON2UP:
1081 case WM_BUTTON3UP:
1082 shiftstate = (SHORT2FROMMP(mp2) & (KC_SHIFT | KC_ALT | KC_CTRL));
1083 break;
1084
1085 case UM_TIMER:
1086 if (dcd && dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent) &&
1087 hwndStatus2) {
1088 FILEFINDBUF3L ffb;
1089 ULONG nm = 1;
1090 HDIR hdir = HDIR_CREATE;
1091
1092 if (*SwapperDat) {
1093 if (!xDosFindFirst(SwapperDat,
1094 &hdir,
1095 FILE_NORMAL | FILE_HIDDEN |
1096 FILE_SYSTEM | FILE_ARCHIVED | FILE_READONLY,
1097 &ffb, sizeof(ffb), &nm, FIL_STANDARDL)) {
1098 CHAR tb[39], tm[39], tpm[39], s[163];
1099 ULONG amem;
1100
1101 priority_bumped();
1102 DosFindClose(hdir);
1103 if (!DosQuerySysInfo(QSV_TOTAVAILMEM,
1104 QSV_TOTAVAILMEM,
1105 (PVOID) & amem, sizeof(amem))) {
1106 CommaFmtULL(tpm, sizeof(tpm), amem, 'M');
1107 }
1108 else
1109 *tpm = 0;
1110 if (!Dos16MemAvail(&amem))
1111 CommaFmtULL(tm, sizeof(tm), amem, 'M');
1112 else
1113 *tm = 0;
1114 CommaFmtULL(tb, sizeof(tb), ffb.cbFile, 'M');
1115 sprintf(s, " %s %s%s%s%s%s",
1116 GetPString(IDS_SWAPFILETEXT),
1117 tb,
1118 *tm ? GetPString(IDS_TREEMEMTEXT) : NullStr,
1119 tm, *tpm ? "/" : NullStr, tpm);
1120 WinSetWindowText(hwndStatus2, s);
1121 }
1122 else
1123 WinSetWindowText(hwndStatus2, NullStr);
1124 }
1125 else
1126 WinSetWindowText(hwndStatus2, NullStr);
1127 }
1128 if (msg == UM_TIMER)
1129 return 0;
1130 break;
1131
1132 case WM_PRESPARAMCHANGED:
1133 PresParamChanged(hwnd, "TreeCnr", mp1, mp2);
1134 break;
1135
1136 case UM_FILESMENU:
1137 {
1138 PCNRITEM pci;
1139 HWND menuHwnd = (HWND) 0;
1140 FSALLOCATE fsa;
1141
1142 pci = (PCNRITEM) CurrentRecord(hwnd);
1143 if (pci && (INT) pci != -1) {
1144 if (IsRoot(pci->pszFileName) || !DosQueryFSInfo(toupper(*pci->pszFileName) - '@',
1145 FSIL_ALLOC, &fsa,
1146 sizeof(FSALLOCATE)))
1147 menuHwnd = CheckMenu(hwndMainMenu, &TreeMenu, TREE_POPUP);
1148 else {
1149 menuHwnd = CheckMenu(hwndMainMenu, &DirMenu, DIR_POPUP);
1150// WinEnableMenuItem(DirMenu,
1151// IDM_TREE,
1152// FALSE);
1153 }
1154 if (!(pci->attrFile & FILE_DIRECTORY))
1155 menuHwnd = CheckMenu(hwndMainMenu, &FileMenu, FILE_POPUP);
1156 }
1157 return MRFROMLONG(menuHwnd);
1158 }
1159
1160 case UM_COMPARE:
1161 if (dcd && mp1 && mp2) {
1162
1163 COMPARE *cmp;
1164 CHAR *leftdir = (CHAR *)mp1, *rightdir = (CHAR *)mp2;
1165
1166 if (!IsFile(leftdir) && !IsFile(rightdir)) {
1167 cmp = xmallocz(sizeof(COMPARE), pszSrcFile, __LINE__);
1168 if (cmp) {
1169 cmp->size = sizeof(COMPARE);
1170 strcpy(cmp->leftdir, leftdir);
1171 strcpy(cmp->rightdir, rightdir);
1172 cmp->hwndParent = dcd->hwndParent;
1173 cmp->dcd.hwndParent = dcd->hwndParent;
1174 WinDlgBox(HWND_DESKTOP,
1175 HWND_DESKTOP,
1176 CompareDlgProc, FM3ModHandle, COMP_FRAME, MPFROMP(cmp));
1177 }
1178 }
1179 }
1180 return 0;
1181
1182 case UM_UPDATERECORDLIST:
1183 if (dcd && mp1)
1184 WinSendMsg(dcd->hwndObject, msg, mp1, mp2);
1185 return 0;
1186
1187 case UM_UPDATERECORD:
1188 if (dcd && mp1) {
1189
1190 CHAR *filename;
1191
1192 filename = mp1;
1193 if (filename)
1194 UpdateCnrRecord(hwnd, filename, TRUE, dcd);
1195 }
1196 return 0;
1197
1198 case WM_SETFOCUS:
1199 if (dcd && hwndStatus && mp2) {
1200 WinSendMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
1201 if (hwndMain)
1202 PostMsg(hwndMain, UM_ADVISEFOCUS, MPFROMLONG(dcd->hwndFrame), MPVOID);
1203 }
1204 break;
1205
1206 case UM_RESCAN:
1207 if (dcd && dcd->hwndFrame == WinQueryActiveWindow(dcd->hwndParent)) {
1208 /*
1209 * put name of our window on status line
1210 */
1211
1212 PCNRITEM pci = NULL;
1213 CHAR str[CCHMAXPATH + 6];
1214
1215 if (fAutoView && hwndMain) {
1216 pci = WinSendMsg(hwnd,
1217 CM_QUERYRECORDEMPHASIS,
1218 MPFROMLONG(CMA_FIRST), MPFROMSHORT(CRA_CURSORED));
1219 if (pci && (INT) pci != -1 && fComments &&
1220 !(driveflags[toupper(*pci->pszFileName) - 'A'] & DRIVE_SLOW))
1221 WinSendMsg(hwndMain, UM_LOADFILE, MPFROMP(pci->pszFileName), MPVOID);
1222 else
1223 WinSendMsg(hwndMain, UM_LOADFILE, MPVOID, MPVOID);
1224 }
1225 if (!fAutoView || !hwndMain)
1226 pci = (PCNRITEM) WinSendMsg(hwnd,
1227 CM_QUERYRECORDEMPHASIS,
1228 MPFROMLONG(CMA_FIRST),
1229 MPFROMSHORT(CRA_CURSORED));
1230 if ((INT) pci == -1)
1231 pci = NULL;
1232 if (pci) {
1233 if (*(ULONG *) realappname == FM3UL) {
1234 sprintf(str, "%s %s", GetPString(IDS_DTTEXT), pci->pszFileName);
1235 WinSetWindowText(dcd->hwndFrame, str);
1236 WinSetWindowText(WinWindowFromID(dcd->hwndFrame, FID_TITLEBAR),
1237 str);
1238 }
1239 else
1240 WinSetWindowText(WinWindowFromID(dcd->hwndFrame,
1241 MAIN_STATUS), pci->pszFileName);
1242 if (fMoreButtons && hwndName) {
1243 WinSetWindowText(hwndName, pci->pszFileName);
1244 sprintf(str,
1245 "%04u/%02u/%02u %02u:%02u:%02u",
1246 pci->date.year,
1247 pci->date.month,
1248 pci->date.day,
1249 pci->time.hours, pci->time.minutes, pci->time.seconds);
1250 WinSetWindowText(hwndDate, str);
1251 WinSetWindowText(hwndAttr, pci->pszDispAttr);
1252 }
1253 }
1254 PostMsg(dcd->hwndObject, UM_RESCAN2, MPFROMP(pci), MPVOID);
1255 if (hwndStatus2)
1256 PostMsg(hwnd, UM_TIMER, MPVOID, MPVOID);
1257 }
1258 return 0;
1259
1260 case UM_SETUP2:
1261 {
1262 PCNRITEM pci = (PCNRITEM) mp1;
1263
1264 if (pci)
1265 NotifyError(pci->pszFileName, (ULONG) mp2);
1266 }
1267 return 0;
1268
1269 case UM_SETUP:
1270# ifdef FORTIFY
1271 // Balance WM_DESTROY
1272 Fortify_EnterScope();
1273# endif
1274
1275 if (!dcd) {
1276 Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
1277 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
1278 return 0;
1279 }
1280 else {
1281 if (!dcd->hwndObject) {
1282 /*
1283 * first time through -- set things up
1284 */
1285 CNRINFO cnri;
1286
1287# ifdef FORTIFY
1288 Fortify_EnterScope();
1289# endif
1290
1291 RestorePresParams(hwnd, "TreeCnr");
1292 memset(&cnri, 0, sizeof(CNRINFO));
1293 cnri.cb = sizeof(CNRINFO);
1294 WinSendMsg(hwnd,
1295 CM_QUERYCNRINFO,
1296 MPFROMP(&cnri), MPFROMLONG(sizeof(CNRINFO)));
1297 cnri.cyLineSpacing = 0;
1298 cnri.cxTreeIndent = 12;
1299 cnri.pSortRecord = (PVOID) SortTreeCnr;
1300 cnri.flWindowAttr &= (~(CV_NAME | CV_DETAIL | CV_TEXT));
1301 cnri.flWindowAttr |= (CV_TREE | CA_TREELINE | CV_ICON | CV_MINI);
1302 {
1303 ULONG size = sizeof(ULONG);
1304
1305 PrfQueryProfileData(fmprof,
1306 appname,
1307 "TreeflWindowAttr",
1308 (PVOID) & cnri.flWindowAttr, &size);
1309 size = sizeof(MASK);
1310 *dcd->mask.prompt = 0;
1311 if (!*dcd->mask.szMask && !dcd->mask.attrFile) {
1312 if (PrfQueryProfileSize(fmprof,
1313 appname, "TreeFilter", &size) && size) {
1314 PrfQueryProfileData(fmprof,
1315 appname, "TreeFilter", &dcd->mask, &size);
1316 SetMask(NULL, &dcd->mask);
1317 }
1318 else
1319 dcd->mask.attrFile = (FILE_READONLY | FILE_NORMAL |
1320 FILE_ARCHIVED | FILE_DIRECTORY |
1321 FILE_HIDDEN | FILE_SYSTEM);
1322 }
1323 dcd->mask.attrFile |= FILE_DIRECTORY;
1324 }
1325 cnri.flWindowAttr &= (~(CA_MIXEDTARGETEMPH | CA_ORDEREDTARGETEMPH));
1326 cnri.flWindowAttr |= CV_FLOW;
1327 dcd->flWindowAttr = cnri.flWindowAttr;
1328 WinSendMsg(hwnd,
1329 CM_SETCNRINFO,
1330 MPFROMP(&cnri),
1331 MPFROMLONG(CMA_FLWINDOWATTR | CMA_LINESPACING |
1332 CMA_CXTREEINDENT | CMA_PSORTRECORD));
1333 if (xbeginthread(MakeObjWin,
1334 327680,
1335 dcd,
1336 pszSrcFile,
1337 __LINE__) == -1)
1338 {
1339 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
1340 }
1341 else
1342 DosSleep(1);
1343# ifdef FORTIFY
1344 Fortify_LeaveScope();
1345# endif
1346 }
1347 }
1348 return 0;
1349
1350 case WM_BUTTON3CLICK:
1351 case WM_CHORD:
1352 {
1353 PCNRITEM pci = NULL;
1354 QUERYRECFROMRECT pqr;
1355 NOTIFYRECORDENTER nr;
1356 BOOL tbool = fDCOpens;
1357 RECTL rectl;
1358 POINTL ptl;
1359
1360 shiftstate = (SHORT2FROMMP(mp2) & (KC_SHIFT | KC_ALT | KC_CTRL));
1361 if (msg == WM_CHORD) {
1362 if (!WinQueryPointerPos(HWND_DESKTOP, &ptl))
1363 break;
1364 WinMapWindowPoints(HWND_DESKTOP, hwnd, &ptl, 1);
1365 }
1366 else {
1367 ptl.x = SHORT1FROMMP(mp1);
1368 ptl.y = SHORT2FROMMP(mp1);
1369 }
1370 memset(&rectl, 0, sizeof(rectl));
1371 memset(&pqr, 0, sizeof(pqr));
1372 pqr.cb = sizeof(pqr);
1373 pqr.rect.xLeft = ptl.x - 1;
1374 pqr.rect.xRight = ptl.x + 1;
1375 pqr.rect.yTop = ptl.y + 1;
1376 pqr.rect.yBottom = ptl.y - 1;
1377 pqr.fsSearch = CMA_PARTIAL;
1378 pci = (PCNRITEM) WinSendMsg(hwnd,
1379 CM_QUERYRECORDFROMRECT,
1380 MPFROMLONG(CMA_FIRST), MPFROMP(&pqr));
1381 if (!pci || (INT) pci == -1)
1382 break; //Probable B3 click on white space Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
1383 else {
1384 memset(&nr, 0, sizeof(nr));
1385 nr.hwndCnr = hwnd;
1386 nr.pRecord = (PRECORDCORE) pci;
1387 fDCOpens = TRUE;
1388 WinSendMsg(hwnd,
1389 WM_CONTROL,
1390 MPFROM2SHORT(WinQueryWindowUShort(hwnd,
1391 QWS_ID),
1392 CN_ENTER), MPFROMP(&nr));
1393 PostMsg(hwnd, UM_RESTOREDC, MPFROMLONG(tbool), MPVOID);
1394 }
1395 }
1396 break;
1397
1398 case UM_RESTOREDC:
1399 fDCOpens = (BOOL) mp1;
1400 return 0;
1401
1402 case WM_CONTROL:
1403 DosError(FERR_DISABLEHARDERR);
1404 if (dcd) {
1405 switch (SHORT2FROMMP(mp1)) {
1406 case CN_BEGINEDIT:
1407 case CN_REALLOCPSZ:
1408 case CN_ENDEDIT:
1409 {
1410 MRESULT mre;
1411
1412 mre = CnrDirectEdit(hwnd, msg, mp1, mp2);
1413 if (mre != (MRESULT) - 1)
1414 return mre;
1415 }
1416 break;
1417
1418 case CN_DRAGLEAVE:
1419 if (mp2) {
1420
1421 PDRAGINFO pDInfo;
1422
1423 // fixme to know why - seems superfluous
1424 pDInfo = ((PCNRDRAGINFO) mp2)->pDragInfo;
1425 DrgAccessDraginfo(pDInfo);
1426 DrgFreeDraginfo(pDInfo);
1427 }
1428 return 0;
1429
1430 case CN_DRAGAFTER:
1431 case CN_DRAGOVER:
1432 if (mp2) {
1433
1434 PDRAGITEM pDItem;
1435 PDRAGINFO pDInfo;
1436 PCNRITEM pci;
1437 USHORT uso;
1438
1439 pDInfo = ((PCNRDRAGINFO) mp2)->pDragInfo;
1440 if (!DrgAccessDraginfo(pDInfo)) {
1441 Win_Error(hwnd, hwnd, pszSrcFile, __LINE__,
1442 "DrgAccessDraginfo");
1443 return (MRFROM2SHORT(DOR_NODROP, 0)); /* Drop not valid */
1444 }
1445 pci = (PCNRITEM) ((PCNRDRAGINFO) mp2)->pRecord;
1446 if ((INT) pci == -1)
1447 pci = NULL;
1448 if (pci && (pci->flags & (RECFLAGS_ENV | RECFLAGS_NODROP))) {
1449 DrgFreeDraginfo(pDInfo);
1450 return MRFROM2SHORT(DOR_NODROP, 0);
1451 }
1452 if (!WinIsWindowEnabled(dcd->hwndFrame)) {
1453 DrgFreeDraginfo(pDInfo);
1454 return MRFROM2SHORT(DOR_NODROP, 0);
1455 }
1456 if (pci) {
1457 uso = pDInfo->usOperation;
1458 if (uso == DO_DEFAULT)
1459 uso = (fCopyDefault) ? DO_COPY : DO_MOVE;
1460 if (!(pci->attrFile & FILE_DIRECTORY)) {
1461 if (uso != DO_LINK && uso != DO_COPY && uso != DO_MOVE) {
1462 DrgFreeDraginfo(pDInfo);
1463 return (MRFROM2SHORT(DOR_NODROP, 0));
1464 }
1465 if (uso != DO_LINK &&
1466 !(driveflags[toupper(*pci->pszFileName) - 'A'] &
1467 DRIVE_NOTWRITEABLE)) {
1468
1469 ARC_TYPE *info;
1470
1471 if (!fQuickArcFind &&
1472 !(driveflags[toupper(*pci->pszFileName) - 'A'] &
1473 DRIVE_SLOW))
1474 info = find_type(pci->pszFileName, NULL);
1475 else
1476 info = quick_find_type(pci->pszFileName, NULL);
1477 if (!info || ((uso == DO_MOVE && !info->move) ||
1478 (uso == DO_COPY && !info->create))) {
1479 DrgFreeDraginfo(pDInfo);
1480 return (MRFROM2SHORT(DOR_NODROP, 0));
1481 }
1482 }
1483 }
1484 }
1485 pDItem = DrgQueryDragitemPtr(pDInfo, /* Access DRAGITEM */
1486 0); /* Index to DRAGITEM */
1487 if (DrgVerifyRMF(pDItem, /* Check valid rendering */
1488 DRM_OS2FILE, /* mechanisms and data */
1489 NULL) || DrgVerifyRMF(pDItem, DRM_FM2ARCMEMBER, DRF_FM2ARCHIVE)) { /* formats */
1490 DrgFreeDraginfo(pDInfo); /* Free DRAGINFO */
1491 if (!pci || (INT) pci == -1)
1492 return MRFROM2SHORT(DOR_DROP, DO_MOVE);
1493 if (driveflags[toupper(*pci->pszFileName) - 'A'] &
1494 DRIVE_NOTWRITEABLE)
1495 return MRFROM2SHORT(DOR_DROP, DO_LINK);
1496 if (toupper(*pci->pszFileName) < 'C')
1497 return MRFROM2SHORT(DOR_DROP, DO_COPY);
1498 return MRFROM2SHORT(DOR_DROP, /* Return okay to drop */
1499 ((fCopyDefault) ? DO_COPY : DO_MOVE));
1500 }
1501 DrgFreeDraginfo(pDInfo); /* Free DRAGINFO */
1502 }
1503 return MRFROM2SHORT(DOR_NODROP, 0); /* Drop not valid */
1504
1505 case CN_INITDRAG:
1506 {
1507 PCNRDRAGINIT pcd = (PCNRDRAGINIT) mp2;
1508 PCNRITEM pci;
1509
1510 if (!pcd) {
1511 Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
1512 break;
1513 }
1514 else {
1515 pci = (PCNRITEM) pcd->pRecord;
1516 if (!pci || (INT) pci == -1) {
1517 Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
1518 break;
1519 }
1520 if (pci->flags & (RECFLAGS_ENV | RECFLAGS_NODRAG)) {
1521 Runtime_Error(pszSrcFile, __LINE__, "drag not allowed");
1522 break;
1523 }
1524 if (hwndStatus2) {
1525 WinSetWindowText(hwndStatus2, (IsRoot(pci->pszFileName)) ?
1526 GetPString(IDS_DRAGROOTTEXT) :
1527 (pci->attrFile & FILE_DIRECTORY) ?
1528 GetPString(IDS_DRAGDIRTEXT) :
1529 GetPString(IDS_DRAGFILETEXT));
1530 }
1531 DoFileDrag(hwnd, dcd->hwndObject, mp2, NULL, NULL, TRUE);
1532 if (hwndStatus2) {
1533 PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
1534 }
1535 }
1536 }
1537 return 0;
1538
1539 case CN_DROP:
1540 {
1541 LISTINFO *li;
1542 ULONG action = UM_ACTION;
1543
1544 li = DoFileDrop(hwnd, NULL, TRUE, mp1, mp2);
1545 CheckPmDrgLimit(((PCNRDRAGINFO)mp2)->pDragInfo);
1546 if (li) {
1547 if (!*li->targetpath) {
1548 if (li->list[0])
1549 PMMkDir(dcd->hwndParent, li->list[0], FALSE);
1550 FreeListInfo(li);
1551 return 0;
1552 }
1553 if (li->list && li->list[0] && IsRoot(li->list[0]))
1554 li->type = DO_LINK;
1555 else if (fDragndropDlg && (!*li->arcname || !li->info)) {
1556
1557 CHECKLIST cl;
1558
1559 memset(&cl, 0, sizeof(cl));
1560 cl.size = sizeof(cl);
1561 cl.flags = li->type;
1562 cl.list = li->list;
1563 cl.cmd = li->type;
1564 cl.prompt = li->targetpath;
1565 li->type = WinDlgBox(HWND_DESKTOP,
1566 dcd->hwndParent,
1567 DropListProc,
1568 FM3ModHandle, DND_FRAME, MPFROMP(&cl));
1569 if (li->type == DID_ERROR)
1570 Win_Error(hwnd, HWND_DESKTOP, pszSrcFile, __LINE__,
1571 "Drag & Drop Dialog");
1572 if (!li->type) {
1573 FreeListInfo(li);
1574 return 0;
1575 }
1576 li->list = cl.list;
1577 if (!li->list || !li->list[0]) {
1578 FreeListInfo(li);
1579 return 0;
1580 }
1581 }
1582 switch (li->type) {
1583 case DO_LINK:
1584 if (fLinkSetsIcon) {
1585 li->type = IDM_SETICON;
1586 action = UM_MASSACTION;
1587 }
1588 else
1589 li->type = IDM_COMPARE;
1590 break;
1591 case DND_EXTRACT:
1592 if (*li->targetpath && !IsFile(li->targetpath))
1593 li->type = IDM_EXTRACT;
1594 break;
1595 case DND_MOVE:
1596 li->type = IDM_MOVE;
1597 if (*li->targetpath && IsFile(li->targetpath) == 1) {
1598 action = UM_MASSACTION;
1599 li->type = IDM_ARCHIVEM;
1600 }
1601 break;
1602 case DND_WILDMOVE:
1603 li->type = IDM_WILDMOVE;
1604 if (*li->targetpath && IsFile(li->targetpath) == 1) {
1605 action = UM_MASSACTION;
1606 li->type = IDM_ARCHIVEM;
1607 }
1608 break;
1609 case DND_OBJECT:
1610 li->type = IDM_OBJECT;
1611 action = UM_MASSACTION;
1612 break;
1613 case DND_SHADOW:
1614 li->type = IDM_SHADOW;
1615 action = UM_MASSACTION;
1616 break;
1617 case DND_COMPARE:
1618 li->type = IDM_COMPARE;
1619 break;
1620 case DND_SETICON:
1621 action = UM_MASSACTION;
1622 li->type = IDM_SETICON;
1623 break;
1624 case DND_COPY:
1625 li->type = IDM_COPY;
1626 if (*li->targetpath && IsFile(li->targetpath) == 1) {
1627 action = UM_MASSACTION;
1628 li->type = IDM_ARCHIVE;
1629 }
1630 break;
1631 case DND_WILDCOPY:
1632 li->type = IDM_WILDCOPY;
1633 if (*li->targetpath && IsFile(li->targetpath) == 1) {
1634 action = UM_MASSACTION;
1635 li->type = IDM_ARCHIVE;
1636 }
1637 break;
1638 default:
1639 if (*li->arcname && li->info) {
1640 action = UM_MASSACTION;
1641 li->type = (li->type == DO_MOVE) ?
1642 IDM_FAKEEXTRACTM : IDM_FAKEEXTRACT;
1643 }
1644 else if (*li->targetpath && IsFile(li->targetpath) == 1) {
1645 action = UM_MASSACTION;
1646 li->type = (li->type == DO_MOVE) ? IDM_ARCHIVEM : IDM_ARCHIVE;
1647 }
1648 else
1649 li->type = (li->type == DO_MOVE) ? IDM_MOVE : IDM_COPY;
1650 break;
1651 }
1652 if (!li->list || !li->list[0])
1653 FreeListInfo(li);
1654 else if (!PostMsg(dcd->hwndObject, action, MPFROMP(li), MPVOID))
1655 FreeListInfo(li);
1656 else {
1657
1658 USHORT usop = 0;
1659
1660 switch (li->type) {
1661 case IDM_COPY:
1662 case IDM_WILDCOPY:
1663 usop = DO_COPY;
1664 break;
1665 case IDM_MOVE:
1666 case IDM_WILDMOVE:
1667 case IDM_ARCHIVEM:
1668 usop = DO_MOVE;
1669 break;
1670 }
1671 if (usop)
1672 return MRFROM2SHORT(DOR_DROP, usop);
1673 }
1674 }
1675 }
1676 return 0;
1677
1678 case CN_EMPHASIS:
1679 if (!fDummy) {
1680
1681 PNOTIFYRECORDEMPHASIS pre = mp2;
1682
1683 if (pre->fEmphasisMask & CRA_SELECTED) {
1684 if (pre->pRecord->flRecordAttr & CRA_SELECTED) {
1685 if (((PCNRITEM) (pre->pRecord))->attrFile & FILE_DIRECTORY) {
1686 PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
1687 if (fFollowTree &&
1688 !(driveflags
1689 [toupper(*((PCNRITEM) pre->pRecord)->pszFileName) -
1690 'A'] & DRIVE_INVALID)) {
1691 if (!LastDir && !ParentIsDesktop(hwnd, dcd->hwndParent))
1692 LastDir = FindDirCnr(dcd->hwndParent);
1693 if (LastDir) {
1694
1695 NOTIFYRECORDENTER pri;
1696 BOOL tbool = fDCOpens;
1697
1698 fDCOpens = FALSE;
1699 memset(&pri, 0, sizeof(pri));
1700 pri.hwndCnr = hwnd;
1701 pri.fKey = FALSE;
1702 pri.pRecord = pre->pRecord;
1703 WinSendMsg(hwnd,
1704 WM_CONTROL,
1705 MPFROM2SHORT(SHORT1FROMMP(mp1),
1706 CN_ENTER), MPFROMP(&pri));
1707 fDCOpens = tbool;
1708 }
1709 }
1710 if (*(ULONG *) realappname != FM3UL)
1711 WinSetWindowText(WinWindowFromID(dcd->hwndFrame,
1712 MAIN_STATUS),
1713 ((PCNRITEM) (pre->pRecord))->pszFileName);
1714 }
1715 }
1716 }
1717 }
1718 break;
1719
1720 case CN_CONTEXTMENU:
1721 {
1722 PCNRITEM pci = (PCNRITEM) mp2;
1723 BOOL wasFollowing;
1724
1725 //DosEnterCritSec(); //GKY 11-28-08
1726 wasFollowing = fFollowTree;
1727 fFollowTree = FALSE;
1728 //DosExitCritSec();
1729 if (pci && (INT) pci != -1 && !(pci->flags & RECFLAGS_ENV)) {
1730 WinSendMsg(hwnd,
1731 CM_SETRECORDEMPHASIS,
1732 MPFROMP(pci), MPFROM2SHORT(TRUE, CRA_CURSORED));
1733 MarkAll(hwnd, FALSE, FALSE, TRUE);
1734 if (!(pci->attrFile & FILE_DIRECTORY))
1735 dcd->hwndLastMenu = CheckMenu(hwndMainMenu, &FileMenu, FILE_POPUP);
1736 else if (!IsRoot(pci->pszFileName))
1737 dcd->hwndLastMenu = CheckMenu(hwndMainMenu, &DirMenu, DIR_POPUP);
1738 else
1739 dcd->hwndLastMenu = CheckMenu(hwndMainMenu, &TreeMenu, TREE_POPUP);
1740 }
1741 else {
1742 dcd->hwndLastMenu = CheckMenu(hwndMainMenu, &TreeCnrMenu, TREECNR_POPUP);
1743 if (dcd->hwndLastMenu && !dcd->cnremphasized) {
1744 WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPVOID,
1745 MPFROM2SHORT(TRUE, CRA_SOURCE));
1746 dcd->cnremphasized = TRUE;
1747 }
1748 }
1749 if (dcd->hwndLastMenu) {
1750 if (dcd->hwndLastMenu == DirMenu)
1751 WinEnableMenuItem(DirMenu, IDM_TREE, FALSE);
1752 if (dcd->hwndLastMenu == TreeCnrMenu) {
1753 if (dcd->flWindowAttr & CV_MINI)
1754 WinCheckMenuItem(dcd->hwndLastMenu, IDM_MINIICONS, TRUE);
1755 }
1756 if (!PopupMenu(hwnd, hwnd, dcd->hwndLastMenu)) {
1757 if (dcd->cnremphasized) {
1758 WinSendMsg(hwnd, CM_SETRECORDEMPHASIS, MPVOID,
1759 MPFROM2SHORT(FALSE, CRA_SOURCE));
1760 dcd->cnremphasized = FALSE;
1761 }
1762 if (dcd->hwndLastMenu != TreeCnrMenu)
1763 MarkAll(hwnd, TRUE, FALSE, TRUE);
1764 }
1765 }
1766 //DosEnterCritSec(); //GKY 11-28-08
1767 fFollowTree = wasFollowing;
1768 //DosExitCritSec();
1769 }
1770 break;
1771
1772 case CN_ENTER:
1773 if (mp2) {
1774 PCNRITEM pci = (PCNRITEM) ((PNOTIFYRECORDENTER) mp2)->pRecord;
1775
1776 PostMsg(hwnd, UM_ENTER, MPFROMP(pci), MPVOID);
1777 }
1778 break;
1779
1780 case CN_COLLAPSETREE:
1781 case CN_EXPANDTREE:
1782 {
1783 PCNRITEM pci = (PCNRITEM) mp2;
1784
1785 if (pci && (INT) pci != -1 && !(pci->flags & RECFLAGS_ENV)) {
1786 if (driveflags[toupper(*pci->pszFileName) - 'A'] & DRIVE_REMOVABLE) {
1787
1788 struct
1789 {
1790 ULONG serial;
1791 CHAR volumelength;
1792 CHAR volumelabel[CCHMAXPATH];
1793 }
1794 volser;
1795
1796 memset(&volser, 0, sizeof(volser));
1797 DosError(FERR_DISABLEHARDERR);
1798 if (!DosQueryFSInfo(toupper(*pci->pszFileName) - '@',
1799 FSIL_VOLSER, &volser,
1800 (ULONG) sizeof(volser))) {
1801 if (SHORT2FROMMP(mp1) == CN_COLLAPSETREE &&
1802 !volser.serial ||
1803 driveserial[toupper(*pci->pszFileName) - 'A'] !=
1804 volser.serial)
1805 UnFlesh(hwnd, pci);
1806 if (SHORT2FROMMP(mp1) != CN_COLLAPSETREE ||
1807 (!volser.serial ||
1808 driveserial[toupper(*pci->pszFileName) - 'A'] !=
1809 volser.serial)) {
1810 if (Flesh(hwnd, pci) &&
1811 SHORT2FROMMP(mp1) == CN_EXPANDTREE &&
1812 !dcd->suspendview && fTopDir)
1813 PostMsg(hwnd, UM_TOPDIR, MPFROMP(pci), MPVOID);
1814 }
1815 driveserial[toupper(*pci->pszFileName) - 'A'] = volser.serial;
1816 }
1817 else {
1818 driveserial[toupper(*pci->pszFileName) - 'A'] = -1;
1819 UnFlesh(hwnd, pci);
1820 PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
1821 DosBeep(250, 100);
1822 }
1823 }
1824 else if (SHORT2FROMMP(mp1) == CN_EXPANDTREE) {
1825 if (Flesh(hwnd, pci) && !dcd->suspendview && fTopDir)
1826 PostMsg(hwnd, UM_TOPDIR, MPFROMP(pci), MPVOID);
1827 }
1828 if (SHORT2FROMMP(mp1) == CN_EXPANDTREE && !dcd->suspendview)
1829 WinSendMsg(hwnd, UM_FILTER, MPVOID, MPVOID);
1830 }
1831 }
1832 break;
1833 } // switch WM_CONTROL
1834 }
1835 return 0;
1836
1837 case UM_ACTION:
1838 if (mp1) {
1839
1840 LISTINFO *li = mp1;
1841 ULONG action = (ULONG) mp2;
1842
1843 if (!li->list || !li->list[0] ||
1844 !PostMsg(dcd->hwndObject, action, MPFROMP(li), MPVOID))
1845 FreeListInfo(li);
1846 }
1847 return 0;
1848
1849 case UM_SHOWME:
1850 if (mp1 && dcd) {
1851 CHAR *dir = xstrdup((CHAR *)mp1, pszSrcFile, __LINE__);
1852
1853 if (dir) {
1854 if (!PostMsg(dcd->hwndObject, UM_SHOWME, MPFROMP(dir), MPVOID))
1855 free(dir);
1856 }
1857 }
1858 return 0;
1859
1860 case UM_TOPDIR:
1861 if (mp1) {
1862
1863 PCNRITEM pci = (PCNRITEM) mp1;
1864
1865 ShowCnrRecord(hwnd, (PMINIRECORDCORE) pci);
1866 }
1867 return 0;
1868
1869 case UM_ENTER:
1870 {
1871 FILEFINDBUF3 ffb;
1872 HDIR hDir = HDIR_CREATE;
1873 ULONG nm = 1;
1874 APIRET status;
1875 BOOL IsOk = FALSE;
1876 ULONG ulDriveNum, ulDriveMap;
1877 PCNRITEM pciP, pciL, pci;
1878 ULONG fl = SWP_ACTIVATE;
1879
1880 if (fFollowTree)
1881 fl = 0;
1882 SetShiftState();
1883 pci = (PCNRITEM) mp1;
1884 if (pci &&
1885 (INT) pci != -1 &&
1886 !(pci->rc.flRecordAttr & CRA_INUSE) &&
1887 !(pci->flags & RECFLAGS_ENV) && IsFullName(pci->pszFileName)) {
1888 if (driveflags[toupper(*pci->pszFileName) - 'A'] & DRIVE_INVALID) {
1889 DosBeep(50, 100);
1890 if (hwndStatus)
1891 WinSetWindowText(hwndStatus, GetPString(IDS_RESCANSUGTEXT));
1892 return 0;
1893 }
1894 DosError(FERR_DISABLEHARDERR);
1895 if (!DosQCurDisk(&ulDriveNum, &ulDriveMap)) {
1896 if (!(ulDriveMap & 1 << (toupper(*pci->pszFileName) - 'A'))) {
1897 pciL = pciP = pci;
1898 for (;;) {
1899 pciP = WinSendMsg(hwnd,
1900 CM_QUERYRECORD,
1901 MPFROMP(pciL),
1902 MPFROM2SHORT(CMA_PARENT, CMA_ITEMORDER));
1903 if (pciP && (INT) pciP != -1)
1904 pciL = pciP;
1905 else {
1906 pciP = pciL;
1907 break;
1908 }
1909 } // for
1910 RemoveCnrItems(hwnd, pciP, 1, CMA_FREE | CMA_INVALIDATE);
1911 return 0;
1912 }
1913 }
1914 if (driveflags[toupper(*pci->pszFileName) - 'A'] &
1915 (DRIVE_REMOVABLE | DRIVE_NOPRESCAN)) {
1916
1917 struct
1918 {
1919 ULONG serial;
1920 CHAR volumelength;
1921 CHAR volumelabel[CCHMAXPATH];
1922 }
1923 volser;
1924
1925 pciL = pciP = pci;
1926 for (;;) {
1927 pciP = WinSendMsg(hwnd,
1928 CM_QUERYRECORD,
1929 MPFROMP(pciL),
1930 MPFROM2SHORT(CMA_PARENT, CMA_ITEMORDER));
1931 if (pciP && (INT) pciP != -1)
1932 pciL = pciP;
1933 else {
1934 pciP = pciL;
1935 break;
1936 }
1937 }
1938 if ((driveflags[toupper(*pci->pszFileName) - 'A'] &
1939 DRIVE_NOPRESCAN) ||
1940 (toupper(*pci->pszFileName) > 'B' &&
1941 !(driveflags[toupper(*pci->pszFileName) - 'A'] &
1942 DRIVE_CDROM))) {
1943
1944 INT removable, x = (INT) (toupper(*pci->pszFileName) - 'A');
1945 ULONG drvtype;
1946 CHAR FileSystem[CCHMAXPATH];
1947
1948 DosError(FERR_DISABLEHARDERR);
1949 removable = CheckDrive(toupper(*pciP->pszFileName),
1950 FileSystem, &drvtype);
1951 if (removable != -1) {
1952 driveflags[x] &= (DRIVE_IGNORE | DRIVE_NOPRESCAN |
1953 DRIVE_NOLOADICONS | DRIVE_NOLOADSUBJS |
1954 DRIVE_NOLOADLONGS | DRIVE_INCLUDEFILES |
1955 DRIVE_SLOW | DRIVE_NOSTATS);
1956
1957 if (removable == 1)
1958 driveflags[x] |= DRIVE_REMOVABLE;
1959 if (drvtype & DRIVE_REMOTE)
1960 driveflags[x] |= DRIVE_REMOTE;
1961 if (!strcmp(FileSystem, CBSIFS)) {
1962 driveflags[x] |= DRIVE_ZIPSTREAM;
1963 driveflags[x] &= (~DRIVE_REMOTE);
1964 }
1965 if(!strcmp(FileSystem,NDFS32)) {
1966 driveflags[x] |= DRIVE_VIRTUAL;
1967 driveflags[x] &= (~DRIVE_REMOTE);
1968 }
1969 if(!strcmp(FileSystem,RAMFS)) {
1970 driveflags[x] |= DRIVE_RAMDISK;
1971 driveflags[x] &= (~DRIVE_REMOTE);
1972 }
1973 if (!strcmp(FileSystem, CDFS) || !strcmp(FileSystem, ISOFS))
1974 driveflags[x] |= (DRIVE_REMOVABLE |
1975 DRIVE_NOTWRITEABLE | DRIVE_CDROM);
1976 if(!strcmp(FileSystem,NTFS))
1977 driveflags[x] |= DRIVE_NOTWRITEABLE;
1978 if (strcmp(FileSystem, HPFS) &&
1979 strcmp(FileSystem, JFS) &&
1980 strcmp(FileSystem, CDFS) &&
1981 strcmp(FileSystem, ISOFS) &&
1982 strcmp(FileSystem, RAMFS) &&
1983 strcmp(FileSystem, FAT32) &&
1984 strcmp(FileSystem, NDFS32) &&
1985 strcmp(FileSystem, NTFS) &&
1986 strcmp(FileSystem, HPFS386)) {
1987 driveflags[x] |= DRIVE_NOLONGNAMES;
1988 }
1989 SelectDriveIcon(pciP);
1990 WinSendMsg(hwnd,
1991 CM_INVALIDATERECORD,
1992 MPFROMP(&pciP),
1993 MPFROM2SHORT(1, CMA_ERASE | CMA_REPOSITION));
1994 if (hwndMain)
1995 PostMsg(hwndMain, UM_BUILDDRIVEBAR, MPVOID, MPVOID);
1996 }
1997 }
1998 memset(&volser, 0, sizeof(volser));
1999 DosError(FERR_DISABLEHARDERR);
2000 status = DosQueryFSInfo(toupper(*pci->pszFileName) - '@',
2001 FSIL_VOLSER, &volser,
2002 (ULONG) sizeof(volser));
2003 if (!status) {
2004 if (!volser.serial ||
2005 driveserial[toupper(*pci->pszFileName) - 'A'] !=
2006 volser.serial) {
2007 UnFlesh(hwnd, pciP);
2008 Flesh(hwnd, pciP);
2009 driveserial[toupper(*pci->pszFileName) - 'A'] = volser.serial;
2010 }
2011 pciL = WinSendMsg(hwnd,
2012 CM_QUERYRECORD,
2013 MPFROMP(pciP),
2014 MPFROM2SHORT(CMA_FIRSTCHILD, CMA_ITEMORDER));
2015 if (!pciL)
2016 Flesh(hwnd, pciP);
2017 }
2018 else {
2019 driveserial[toupper(*pci->pszFileName) - 'A'] = -1;
2020 UnFlesh(hwnd, pci);
2021 PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
2022 PostMsg(hwnd, UM_SETUP2, MPFROMP(pci), MPFROMLONG(status));
2023 return 0;
2024 }
2025 }
2026 status = 0;
2027 IsOk = (IsRoot(pci->pszFileName) &&
2028 IsValidDrive(toupper(*pci->pszFileName)));
2029 if (!IsOk) {
2030 DosError(FERR_DISABLEHARDERR);
2031 status = DosFindFirst(pci->pszFileName, &hDir,
2032 FILE_NORMAL | FILE_DIRECTORY |
2033 FILE_ARCHIVED | FILE_READONLY |
2034 FILE_HIDDEN | FILE_SYSTEM,
2035 &ffb, sizeof(ffb), &nm, FIL_STANDARD);
2036 priority_bumped();
2037 }
2038 if (!status) {
2039 if (!IsOk)
2040 DosFindClose(hDir);
2041 if (IsOk || (ffb.attrFile & FILE_DIRECTORY)) {
2042 if ((shiftstate & (KC_CTRL | KC_ALT)) == (KC_CTRL | KC_ALT)) {
2043 PostMsg(hwnd,
2044 WM_COMMAND, MPFROM2SHORT(IDM_SHOWALLFILES, 0), MPVOID);
2045 return 0;
2046 }
2047 if ((shiftstate & (KC_CTRL | KC_SHIFT)) == (KC_CTRL | KC_SHIFT)) {
2048 OpenObject(pci->pszFileName, Settings, dcd->hwndFrame);
2049 return 0;
2050 }
2051 if (!(shiftstate & (KC_CTRL | KC_SHIFT))) {
2052 if (!ParentIsDesktop(hwnd, dcd->hwndParent)) {
2053 if (FindDirCnrByName(pci->pszFileName, TRUE))
2054 return 0;
2055 }
2056 }
2057 if ((shiftstate & KC_CTRL) ||
2058 (!(shiftstate & KC_SHIFT) &&
2059 ParentIsDesktop(hwnd, dcd->hwndParent) && fVTreeOpensWPS)) {
2060
2061 ULONG size = sizeof(ULONG), flWindowAttr = CV_ICON;
2062 CHAR s[33];
2063
2064 strcpy(s, "ICON");
2065 PrfQueryProfileData(fmprof,
2066 appname,
2067 "DirflWindowAttr",
2068 (PVOID) & flWindowAttr, &size);
2069 if (flWindowAttr & CV_DETAIL) {
2070 if (IsRoot(pci->pszFileName))
2071 strcpy(s, "TREE");
2072 else
2073 strcpy(s, "DETAILS");
2074 }
2075 OpenObject(pci->pszFileName, s, dcd->hwndFrame);
2076 return 0;
2077 }
2078 if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
2079 !fDCOpens && !LastDir && !(shiftstate & KC_SHIFT))
2080 LastDir = FindDirCnr(dcd->hwndParent);
2081 if (LastDir && !fDCOpens && !(shiftstate & KC_SHIFT)) {
2082 WinSendMsg(LastDir,
2083 UM_SETDIR, MPFROMP(pci->pszFileName), MPVOID);
2084 WinSetWindowPos(WinQueryWindow(WinQueryWindow(LastDir,
2085 QW_PARENT),
2086 QW_PARENT),
2087 HWND_TOP, 0, 0, 0, 0, SWP_ZORDER | fl);
2088 }
2089 else
2090 OpenDirCnr(hwnd,
2091 dcd->hwndParent,
2092 dcd->hwndFrame, FALSE, pci->pszFileName);
2093 }
2094 else {
2095 if (!(driveflags[toupper(*pci->pszFileName) - 'A'] &
2096 DRIVE_INCLUDEFILES))
2097 RemoveCnrItems(hwnd, pci, 1, CMA_FREE | CMA_INVALIDATE);
2098 else {
2099
2100 SWP swp;
2101
2102 WinQueryWindowPos(dcd->hwndFrame, &swp);
2103 DefaultViewKeys(hwnd,
2104 dcd->hwndFrame,
2105 dcd->hwndParent, &swp, pci->pszFileName);
2106 }
2107 }
2108 }
2109 else {
2110 if (!IsRoot(pci->pszFileName)) {
2111 NotifyError(pci->pszFileName, status);
2112 RemoveCnrItems(hwnd, pci, 1, CMA_FREE | CMA_INVALIDATE);
2113 }
2114 }
2115 }
2116 else if (!pci)
2117 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_MKDIR, 0), MPVOID);
2118 if (fFollowTree)
2119 WinSetFocus(HWND_DESKTOP, hwnd);
2120 }
2121 return 0;
2122
2123 case WM_MENUEND:
2124 if (dcd) {
2125
2126 HWND hwndMenu = (HWND) mp2;
2127
2128 if (hwndMenu == TreeCnrMenu || hwndMenu == TreeMenu ||
2129 hwndMenu == DirMenu) {
2130 MarkAll(hwnd, TRUE, FALSE, TRUE);
2131 if (dcd->cnremphasized) {
2132 WinSendMsg(hwnd,
2133 CM_SETRECORDEMPHASIS,
2134 MPVOID, MPFROM2SHORT(FALSE, CRA_SOURCE));
2135 dcd->cnremphasized = FALSE;
2136 }
2137 }
2138 }
2139 break;
2140
2141 case UM_OPENWINDOWFORME:
2142 if (dcd) {
2143 if (mp1 && !IsFile((CHAR *)mp1))
2144 OpenDirCnr(hwnd, dcd->hwndParent, dcd->hwndFrame, FALSE, (char *)mp1);
2145 }
2146 return 0;
2147
2148 case MM_PORTHOLEINIT:
2149 if (dcd) {
2150 switch (SHORT1FROMMP(mp1)) {
2151 case 0:
2152 case 1:
2153 {
2154 ULONG wmsg;
2155
2156 wmsg = ((SHORT1FROMMP(mp1) == 0) ? UM_FILESMENU : UM_VIEWSMENU);
2157 PortholeInit((HWND) WinSendMsg(dcd->hwndClient,
2158 wmsg, MPVOID, MPVOID), mp1, mp2);
2159 }
2160 break;
2161 }
2162 }
2163 break;
2164
2165 case UM_INITMENU:
2166 case WM_INITMENU:
2167 if (dcd) {
2168 switch (SHORT1FROMMP(mp1)) {
2169 case IDM_FILESMENU:
2170 {
2171 PCNRITEM pci;
2172
2173 pci = (PCNRITEM) CurrentRecord(hwnd);
2174 if (pci && (INT) pci != -1) {
2175 BOOL rdy;
2176 BOOL writeable;
2177 BOOL removable;
2178 BOOL remote;
2179 BOOL underenv;
2180 CHAR chDrvU;
2181 CHAR szDrv[CCHMAXPATH];
2182
2183 strcpy(szDrv, pci->pszFileName);
2184 chDrvU = *pci->pszFileName;
2185 chDrvU = toupper(chDrvU);
2186 MakeValidDir(szDrv);
2187 rdy = *szDrv == chDrvU; // Drive not ready if MakeValidDir changes drive letter
2188 removable = rdy
2189 && (driveflags[chDrvU - 'A'] & DRIVE_REMOVABLE) != 0;
2190 writeable = rdy
2191 && !(driveflags[chDrvU - 'A'] & DRIVE_NOTWRITEABLE);
2192 remote = rdy && (driveflags[chDrvU - 'A'] & (DRIVE_REMOTE || DRIVE_VIRTUAL)) == 0;
2193 underenv = (pci->flags & RECFLAGS_UNDERENV) != 0;
2194
2195 CopyPresParams((HWND) mp2, hwndMainMenu);
2196 WinEnableMenuItem((HWND) mp2, IDM_INFO, rdy);
2197
2198 WinEnableMenuItem((HWND) mp2, IDM_ATTRS, writeable);
2199 WinEnableMenuItem((HWND) mp2, IDM_EAS, writeable);
2200 WinEnableMenuItem((HWND) mp2, IDM_SUBJECT, writeable);
2201 WinEnableMenuItem((HWND) mp2, IDM_DRVFLAGS, 1); // fixme to allow if not ready
2202
2203 WinEnableMenuItem((HWND) mp2, IDM_ARCHIVE, rdy);
2204
2205 WinEnableMenuItem((HWND) mp2, IDM_UPDATE, !underenv);
2206 WinEnableMenuItem((HWND) mp2, IDM_EXPANDSUBMENU, !underenv);
2207 WinEnableMenuItem((HWND) mp2, IDM_EXPAND, !underenv);
2208 WinEnableMenuItem((HWND) mp2, IDM_COLLAPSE, !underenv);
2209
2210 WinEnableMenuItem((HWND) mp2, IDM_SIZES, rdy);
2211 WinEnableMenuItem((HWND) mp2, IDM_MKDIR, writeable);
2212 WinEnableMenuItem((HWND) mp2, IDM_SHOWALLFILES, rdy);
2213 WinEnableMenuItem((HWND) mp2, IDM_UNDELETE, writeable);
2214
2215 WinEnableMenuItem((HWND) mp2, IDM_CHKDSK, writeable && !remote);
2216 WinEnableMenuItem((HWND) mp2, IDM_FORMAT, writeable && !remote);
2217 WinEnableMenuItem((HWND) mp2, IDM_OPTIMIZE, writeable && !remote);
2218 WinEnableMenuItem((HWND) mp2, IDM_PARTITIONSMENU, !remote);
2219
2220 WinEnableMenuItem((HWND) mp2, IDM_DETACH, remote);
2221
2222 WinEnableMenuItem((HWND) mp2, IDM_EJECT, removable);
2223
2224 WinEnableMenuItem((HWND) mp2, IDM_LOCK, removable);
2225 WinEnableMenuItem((HWND) mp2, IDM_UNLOCK, removable);
2226
2227 WinEnableMenuItem((HWND) mp2, IDM_DELETE, !underenv && writeable);
2228 WinEnableMenuItem((HWND) mp2, IDM_PERMDELETE, !underenv
2229 && writeable);
2230 WinEnableMenuItem((HWND) mp2, IDM_DELETESUBMENU, !underenv
2231 && writeable);
2232 WinEnableMenuItem((HWND) mp2, IDM_MOVEMENU, !underenv
2233 && writeable);
2234 WinEnableMenuItem((HWND) mp2, IDM_RENAME, !underenv && writeable);
2235
2236 }
2237 }
2238 break;
2239
2240 case IDM_VIEWSMENU:
2241 WinCheckMenuItem((HWND) mp2,
2242 IDM_MINIICONS, ((dcd->flWindowAttr & CV_MINI) != 0));
2243 CopyPresParams((HWND) mp2, hwndMainMenu);
2244 WinEnableMenuItem((HWND) mp2, IDM_RESELECT, FALSE);
2245 break;
2246
2247 case IDM_COMMANDSMENU:
2248 SetupCommandMenu((HWND) mp2, hwnd);
2249 CopyPresParams((HWND) mp2, hwndMainMenu);
2250 break;
2251
2252 case IDM_SORTSUBMENU:
2253 SetSortChecks((HWND) mp2, TreesortFlags);
2254 CopyPresParams((HWND) mp2, hwndMainMenu);
2255 break;
2256
2257 case IDM_WINDOWSMENU:
2258 SetupWinList((HWND) mp2,
2259 (hwndMain) ? hwndMain : (HWND) 0, dcd->hwndFrame);
2260 CopyPresParams((HWND) mp2, hwndMainMenu);
2261 break;
2262 }
2263 dcd->hwndLastMenu = (HWND) mp2;
2264 }
2265 if (msg == WM_INITMENU)
2266 break;
2267 return 0;
2268
2269 case UM_COMMAND:
2270 if (!mp1)
2271 Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
2272 else {
2273 if (!dcd) {
2274 Runtime_Error2(pszSrcFile, __LINE__, IDS_NODATATEXT);
2275 FreeListInfo((LISTINFO *) mp1);
2276 }
2277 else {
2278 if (!PostMsg(dcd->hwndObject, UM_COMMAND, mp1, mp2)) {
2279 Runtime_Error(pszSrcFile, __LINE__, "PostMsg");
2280 FreeListInfo((LISTINFO *) mp1);
2281 }
2282 else
2283 return (MRESULT) TRUE;
2284 }
2285 }
2286 return 0;
2287
2288 case UM_LOADFILE:
2289 if (dcd && mp2) {
2290
2291 HWND hwnd;
2292
2293 if ((INT)mp1 == 5 || (INT)mp1 == 13 || (INT)mp1 == 21)
2294 hwnd = StartViewer(HWND_DESKTOP, (INT)mp1,
2295 (CHAR *)mp2, dcd->hwndFrame);
2296 else
2297 hwnd = StartMLEEditor(dcd->hwndParent,
2298 (INT)mp1, (CHAR *)mp2, dcd->hwndFrame);
2299 free((CHAR *)mp2);
2300 return MRFROMLONG(hwnd);
2301 }
2302 return 0;
2303
2304 case UM_FIXCNRMLE:
2305 case UM_FIXEDITNAME:
2306 return CommonCnrProc(hwnd, msg, mp1, mp2);
2307
2308 case UM_NOTIFY:
2309 if (mp2)
2310 Notify((CHAR *)mp2);
2311 return 0;
2312
2313 case UM_FILTER:
2314 if (dcd) {
2315
2316 BOOL tempsusp = dcd->suspendview;
2317
2318 if (mp1) {
2319 //DosEnterCritSec(); // GKY 11-30-08 moved to SetMask
2320 SetMask((CHAR *)mp1, &dcd->mask);
2321 //DosExitCritSec();
2322 }
2323 dcd->suspendview = TRUE;
2324 dcd->mask.attrFile |= FILE_DIRECTORY;
2325 WinSendMsg(hwnd, CM_FILTER, MPFROMP(Filter), MPFROMP(&dcd->mask));
2326 dcd->suspendview = tempsusp;
2327 PostMsg(hwnd, UM_RESCAN, MPVOID, MPVOID);
2328 }
2329 return 0;
2330
2331 case UM_DRIVECMD:
2332 if (mp1)
2333 ShowTreeRec(hwnd, (CHAR *)mp1, FALSE, TRUE);
2334 return 0;
2335
2336 case WM_APPTERMINATENOTIFY:
2337 {
2338 APPNOTIFY *info;
2339 PCNRITEM pci;
2340 CHAR s[] = " :\\";
2341
2342 if (!mp2) {
2343 if (hwndMain)
2344 PostMsg(hwndMain, UM_BUILDDRIVEBAR, MPVOID, MPVOID);
2345 }
2346 info = apphead;
2347 while (info) {
2348 if (info->happ == (HAPP) mp1) {
2349 *s = info->device;
2350 pci = FindCnrRecord(hwnd, s, NULL, FALSE, FALSE, TRUE);
2351 if (pci && (INT) pci != -1) {
2352 driveserial[info->device - 'A'] = -1;
2353 DriveFlagsOne(info->device - 'A');
2354 if (driveflags[info->device - 'A'] &
2355 (DRIVE_INVALID | DRIVE_IGNORE))
2356 RemoveCnrItems(hwnd, pci, 1, CMA_FREE);
2357 else
2358 Flesh(hwnd, pci);
2359 }
2360 if (info->prev)
2361 info->prev->next = info->next;
2362 if (info->next)
2363 info->next->prev = info->prev;
2364 if (apphead == info)
2365 apphead = info->next;
2366 if (apptail == info)
2367 apptail = info->prev;
2368 free(info);
2369 break;
2370 }
2371 info = info->next;
2372 }
2373 }
2374 break;
2375
2376 case WM_COMMAND:
2377 DosError(FERR_DISABLEHARDERR);
2378 if (dcd) {
2379 if (SwitchCommand(dcd->hwndLastMenu, SHORT1FROMMP(mp1)))
2380 return 0;
2381 switch (SHORT1FROMMP(mp1)) {
2382 case IDM_SETTARGET:
2383 SetTargetDir(hwnd, FALSE);
2384 break;
2385
2386 case IDM_DETACH:
2387 {
2388 CHAR d[3] = " :";
2389 PCNRITEM pci;
2390 PROGDETAILS pgd;
2391 CHAR params[368], *p;
2392 HAPP happ;
2393
2394 pci = (PCNRITEM) CurrentRecord(hwnd);
2395 if (pci && (INT) pci != -1 && isalpha(*pci->pszFileName)) {
2396 *d = toupper(*pci->pszFileName);
2397 p = GetCmdSpec(FALSE);
2398 memset(&pgd, 0, sizeof(pgd));
2399 pgd.Length = sizeof(pgd);
2400 pgd.progt.progc = PROG_WINDOWABLEVIO;
2401 pgd.progt.fbVisible = SHE_VISIBLE;
2402 pgd.pszTitle = GetPString(IDS_DETACHREQUESTTEXT);
2403 pgd.pszExecutable = p;
2404 pgd.pszParameters = params;
2405 pgd.pszStartupDir = NULL;
2406 pgd.pszIcon = NULL;
2407 pgd.pszEnvironment = NULL;
2408 pgd.swpInitial.hwndInsertBehind = HWND_TOP;
2409 pgd.swpInitial.hwnd = hwnd;
2410 pgd.swpInitial.fl = SWP_SHOW | SWP_ACTIVATE;
2411 sprintf(params, "/C NET USE %s /D", d);
2412 happ = WinStartApp(hwnd, &pgd, pgd.pszParameters,
2413 NULL, SAF_MAXIMIZED);
2414 if (!happ) {
2415 saymsg(MB_CANCEL | MB_ICONEXCLAMATION, hwnd,
2416 GetPString(IDS_ERRORTEXT),
2417 GetPString(IDS_CANTSTARTTEXT), p, params);
2418 }
2419 else {
2420 APPNOTIFY *info;
2421
2422 info = xmallocz(sizeof(APPNOTIFY), pszSrcFile, __LINE__);
2423 if (info) {
2424 info->happ = happ;
2425 info->device = *d;
2426 if (!apphead)
2427 apphead = info;
2428 else {
2429 apptail->next = info;
2430 info->prev = apptail;
2431 }
2432 apptail = info;
2433 }
2434 }
2435 }
2436 }
2437 break;
2438
2439 case IDM_REMAP:
2440 WinDlgBox(HWND_DESKTOP, hwnd, RemapDlgProc,
2441 FM3ModHandle, MAP_FRAME, NULL);
2442 break;
2443
2444 case IDM_CONTEXTMENU:
2445 {
2446 PCNRITEM pci;
2447
2448 pci = (PCNRITEM) CurrentRecord(hwnd);
2449 PostMsg(hwnd, WM_CONTROL, MPFROM2SHORT(DIR_CNR, CN_CONTEXTMENU),
2450 MPFROMP(pci));
2451 }
2452 break;
2453
2454 case IDM_FINDINTREE:
2455 {
2456 PSZ pszTempDir;
2457 PCNRITEM pci;
2458
2459 pci = (PCNRITEM) CurrentRecord(hwnd);
2460 if (pci && (INT) pci != -1) {
2461 pszTempDir = xstrdup(pci->pszFileName, pszSrcFile, __LINE__);
2462 if (pszTempDir)
2463 MakeValidDir(pszTempDir);
2464 }
2465 else
2466 pszTempDir = xstrdup(pFM2SaveDirectory, pszSrcFile, __LINE__);
2467 if (pszTempDir) {
2468 if (WinDlgBox(HWND_DESKTOP, dcd->hwndParent,
2469 WalkAllDlgProc,
2470 FM3ModHandle, WALK_FRAME, MPFROMP(pszTempDir))) {
2471 if (!WinSendMsg(hwnd, UM_SHOWME, MPFROMP(pszTempDir), MPFROMLONG(1)))
2472 free(pszTempDir);
2473 }
2474 else
2475 free(pszTempDir);
2476 }
2477 }
2478 break;
2479
2480 case IDM_BEGINEDIT:
2481 OpenEdit(hwnd);
2482 break;
2483
2484 case IDM_ENDEDIT:
2485 WinSendMsg(hwnd, CM_CLOSEEDIT, MPVOID, MPVOID);
2486 break;
2487
2488 case IDM_FILTER:
2489 {
2490 BOOL empty = FALSE;
2491 PCNRITEM pci;
2492
2493 pci = (PCNRITEM) CurrentRecord(hwnd);
2494 if (!*dcd->mask.szMask)
2495 empty = TRUE;
2496 dcd->mask.fIsTree = TRUE;
2497 *dcd->mask.prompt = 0;
2498 if (pci && (INT) pci != -1)
2499 dcd->mask.fFilesIncluded =
2500 ((driveflags[toupper(*pci->pszFileName) - 'A'] &
2501 DRIVE_INCLUDEFILES) != 0);
2502 else
2503 dcd->mask.fFilesIncluded = FALSE;
2504 if (WinDlgBox(HWND_DESKTOP, hwnd, PickMaskDlgProc,
2505 FM3ModHandle, MSK_FRAME, MPFROMP(&dcd->mask)))
2506 WinSendMsg(hwnd, UM_FILTER, MPVOID, MPVOID);
2507 else if (empty)
2508 *dcd->mask.szMask = 0;
2509 PrfWriteProfileData(fmprof, appname, "TreeFilter", &dcd->mask,
2510 sizeof(MASK));
2511 }
2512 break;
2513
2514 case IDM_SHOWSORT:
2515 QuickPopup(hwnd, dcd, CheckMenu(hwndMainMenu, &TreeCnrMenu, TREECNR_POPUP),
2516 IDM_SORTSUBMENU);
2517 break;
2518
2519 case IDM_SHOWSELECT:
2520 QuickPopup(hwnd, dcd, CheckMenu(hwndMainMenu, &TreeCnrMenu, TREECNR_POPUP),
2521 IDM_SELECTSUBMENU);
2522 break;
2523
2524 case IDM_TREECNRVIEWSETTINGS:
2525 if (!ParentIsDesktop(dcd->hwndParent, dcd->hwndParent))
2526 PostMsg(dcd->hwndParent, msg, MPFROMLONG(IDM_TREECNRVIEWSETTINGS), mp2);
2527 else {
2528 WinDlgBox(HWND_DESKTOP,
2529 hwnd,
2530 CfgDlgProc,
2531 FM3ModHandle,
2532 CFG_FRAME,
2533 MPFROMLONG(IDM_TREECNRVIEWSETTINGS));
2534 }
2535 break;
2536
2537 case IDM_WALKDIR:
2538 case IDM_OPENWALK:
2539 {
2540 CHAR newpath[CCHMAXPATH];
2541 PCNRITEM pci;
2542
2543 pci = (PCNRITEM) CurrentRecord(hwnd);
2544 if (pci && (INT) pci != -1) {
2545 strcpy(newpath, pci->pszFileName);
2546 MakeValidDir(newpath);
2547 }
2548 else
2549 strcpy(newpath, pFM2SaveDirectory);
2550 if (!WinDlgBox(HWND_DESKTOP, dcd->hwndParent, WalkAllDlgProc,
2551 FM3ModHandle, WALK_FRAME,
2552 MPFROMP(newpath)) || !*newpath)
2553 break;
2554 WinSendMsg(hwnd, UM_OPENWINDOWFORME, MPFROMP(newpath), MPVOID);
2555 }
2556 break;
2557
2558 case IDM_HELP:
2559 if (hwndHelp) {
2560 if (!ParentIsDesktop(dcd->hwndFrame, dcd->hwndParent))
2561 PostMsg(dcd->hwndParent, UM_COMMAND, mp1, mp2);
2562 else
2563 WinSendMsg(hwndHelp, HM_HELP_CONTENTS, MPVOID, MPVOID);
2564 }
2565 break;
2566
2567 case IDM_PARTITION:
2568 runemf2(SEPARATE | WINDOWED, HWND_DESKTOP, pszSrcFile, __LINE__,
2569 NULL, NULL,
2570 "%s", "MINILVM.EXE");
2571 break;
2572
2573 case IDM_PARTITIONDF:
2574 runemf2(SEPARATE | WINDOWED, HWND_DESKTOP, pszSrcFile, __LINE__,
2575 NULL, NULL,
2576 "%s", "DFSOS2.EXE");
2577 break;
2578
2579 case IDM_PARTITIONLVMG:
2580 runemf2(SEPARATE | WINDOWED, HWND_DESKTOP, pszSrcFile, __LINE__,
2581 NULL, NULL,
2582 "%s", "LVMGUI.CMD");
2583 break;
2584
2585 case IDM_PARTITIONFD:
2586 runemf2(SEPARATE | WINDOWED, HWND_DESKTOP, pszSrcFile, __LINE__,
2587 NULL, NULL,
2588 "%s", "FDISKPM.EXE");
2589 break;
2590
2591 case IDM_SORTNAME:
2592 case IDM_SORTFILENAME:
2593 case IDM_SORTSIZE:
2594 case IDM_SORTEASIZE:
2595 case IDM_SORTFIRST:
2596 case IDM_SORTLAST:
2597 case IDM_SORTLWDATE:
2598 case IDM_SORTLADATE:
2599 case IDM_SORTCRDATE:
2600 TreesortFlags &= (SORT_REVERSE | SORT_DIRSFIRST | SORT_DIRSLAST);
2601 case IDM_SORTDIRSFIRST:
2602 case IDM_SORTDIRSLAST:
2603 case IDM_SORTREVERSE:
2604 switch (SHORT1FROMMP(mp1)) {
2605 case IDM_SORTFILENAME:
2606 TreesortFlags |= SORT_FILENAME;
2607 break;
2608 case IDM_SORTSIZE:
2609 TreesortFlags |= SORT_SIZE;
2610 break;
2611 case IDM_SORTEASIZE:
2612 TreesortFlags |= SORT_EASIZE;
2613 break;
2614 case IDM_SORTFIRST:
2615 TreesortFlags |= SORT_FIRSTEXTENSION;
2616 break;
2617 case IDM_SORTLAST:
2618 TreesortFlags |= SORT_LASTEXTENSION;
2619 break;
2620 case IDM_SORTLWDATE:
2621 TreesortFlags |= SORT_LWDATE;
2622 break;
2623 case IDM_SORTLADATE:
2624 TreesortFlags |= SORT_LADATE;
2625 break;
2626 case IDM_SORTCRDATE:
2627 TreesortFlags |= SORT_CRDATE;
2628 break;
2629 case IDM_SORTDIRSFIRST:
2630 if (TreesortFlags & SORT_DIRSFIRST)
2631 TreesortFlags &= (~SORT_DIRSFIRST);
2632 else {
2633 TreesortFlags |= SORT_DIRSFIRST;
2634 TreesortFlags &= (~SORT_DIRSLAST);
2635 }
2636 break;
2637 case IDM_SORTDIRSLAST:
2638 if (TreesortFlags & SORT_DIRSLAST)
2639 TreesortFlags &= (~SORT_DIRSLAST);
2640 else {
2641 TreesortFlags |= SORT_DIRSLAST;
2642 TreesortFlags &= (~SORT_DIRSFIRST);
2643 }
2644 break;
2645 case IDM_SORTREVERSE:
2646 if (TreesortFlags & SORT_REVERSE)
2647 TreesortFlags &= (~SORT_REVERSE);
2648 else
2649 TreesortFlags |= SORT_REVERSE;
2650 break;
2651 }
2652 PrfWriteProfileData(fmprof, appname, "TreeSort", &TreesortFlags,
2653 sizeof(INT));
2654 WinSendMsg(hwnd, CM_SORTRECORD, MPFROMP(SortTreeCnr), MPVOID);
2655 break;
2656
2657 case IDM_COLLECT:
2658 if (!Collector) {
2659
2660 HWND hwndC;
2661 SWP swp;
2662
2663 if (!ParentIsDesktop(hwnd, dcd->hwndParent) &&
2664 !fAutoTile &&
2665 (!fExternalCollector && *(ULONG *) realappname == FM3UL))
2666 GetNextWindowPos(dcd->hwndParent, &swp, NULL, NULL);
2667 hwndC = StartCollector((fExternalCollector ||
2668 *(ULONG *) realappname != FM3UL) ?
2669 HWND_DESKTOP : dcd->hwndParent, 4);
2670 if (hwndC) {
2671 if (!ParentIsDesktop(hwnd,
2672 dcd->hwndParent) &&
2673 !fAutoTile &&
2674 (!fExternalCollector && *(ULONG *) realappname == FM3UL))
2675 WinSetWindowPos(hwndC,
2676 HWND_TOP,
2677 swp.x,
2678 swp.y,
2679 swp.cx,
2680 swp.cy,
2681 SWP_MOVE | SWP_SIZE | SWP_SHOW | SWP_ZORDER);
2682 else if (!ParentIsDesktop(hwnd,
2683 dcd->hwndParent) &&
2684 fAutoTile && *(ULONG *) realappname == FM3UL)
2685 TileChildren(dcd->hwndParent, TRUE);
2686 }
2687 WinSetWindowPos(hwndC, HWND_TOP, 0, 0, 0, 0, SWP_ACTIVATE);
2688 DosSleep(100);//05 Aug 07 GKY 250
2689 }
2690 else
2691 StartCollector(dcd->hwndParent, 4);
2692 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_COLLECTOR, 0), MPVOID);
2693 break;
2694
2695 case IDM_COLLECTOR:
2696 DosSleep(32);//05 Aug 07 GKY 64
2697 {
2698 CHAR **list;
2699
2700 list = BuildList(hwnd);
2701 if (list) {
2702 if (Collector) {
2703 if (!PostMsg(Collector, WM_COMMAND,
2704 MPFROM2SHORT(IDM_COLLECTOR, 0), MPFROMP(list)))
2705 FreeList(list);
2706 }
2707 else
2708 FreeList(list);
2709 }
2710 }
2711 break;
2712
2713 case IDM_COLLAPSEALL:
2714 WinSendMsg(hwnd, CM_COLLAPSETREE, MPVOID, MPVOID);
2715 break;
2716
2717 case IDM_COLLAPSE:
2718 case IDM_EXPAND:
2719 {
2720 PCNRITEM pci = NULL;
2721
2722 pci = (PCNRITEM) CurrentRecord(hwnd);
2723 if (pci && (INT) pci != -1) {
2724 if (pci->flags & RECFLAGS_UNDERENV)
2725 break;
2726 PostMsg(dcd->hwndObject, UM_EXPAND, mp1, MPFROMP(pci));
2727 }
2728 }
2729 break;
2730
2731 case IDM_UPDATE:
2732 {
2733 PCNRITEM pci = (PCNRITEM)CurrentRecord(hwnd);
2734 if (pci && (INT)pci != -1) {
2735 UINT driveflag = driveflags[toupper(*pci->pszFileName) - 'A'];
2736 if (pci->attrFile & FILE_DIRECTORY) {
2737 if (pci->flags & RECFLAGS_UNDERENV)
2738 break;
2739 UnFlesh(hwnd, pci);
2740 // Check if drive type might need update
2741 if ((driveflag & (DRIVE_INVALID | DRIVE_NOPRESCAN)) ||
2742 (~driveflag & DRIVE_NOPRESCAN && pci->rc.hptrIcon == hptrDunno))
2743 {
2744 driveflags[toupper(*pci->pszFileName) - 'A'] &=
2745 (DRIVE_IGNORE | DRIVE_NOPRESCAN | DRIVE_NOLOADICONS |
2746 DRIVE_NOLOADSUBJS | DRIVE_NOLOADLONGS | DRIVE_NOSTATS);
2747 DriveFlagsOne(toupper(*pci->pszFileName) - 'A');
2748 driveflag = driveflags[toupper(*pci->pszFileName) - 'A'];
2749 if (driveflag & DRIVE_INVALID)
2750 pci->rc.hptrIcon = hptrDunno;
2751 else {
2752 SelectDriveIcon(pci);
2753 }
2754 WinSendMsg(hwnd,
2755 CM_INVALIDATERECORD,
2756 MPFROMP(&pci),
2757 MPFROM2SHORT(1, CMA_ERASE | CMA_REPOSITION));
2758 if (hwndMain)
2759 PostMsg(hwndMain, UM_BUILDDRIVEBAR, MPVOID, MPVOID);
2760 }
2761 if (~driveflag & DRIVE_INVALID)
2762 Flesh(hwnd, pci);
2763 }
2764 }
2765 }
2766 break;
2767
2768 case IDM_RESCAN:
2769 PostMsg(dcd->hwndObject, UM_RESCAN, MPVOID, MPVOID);
2770 break;
2771
2772 case IDM_RESORT:
2773 WinSendMsg(hwnd, CM_SORTRECORD, MPFROMP(SortTreeCnr), MPVOID);
2774 break;
2775
2776 case IDM_TEXT:
2777 case IDM_MINIICONS:
2778 {
2779 CNRINFO cnri;
2780
2781 memset(&cnri, 0, sizeof(CNRINFO));
2782 cnri.cb = sizeof(CNRINFO);
2783 WinSendMsg(hwnd,
2784 CM_QUERYCNRINFO,
2785 MPFROMP(&cnri), MPFROMLONG(sizeof(CNRINFO)));
2786 if (SHORT1FROMMP(mp1) == IDM_MINIICONS) {
2787 if (cnri.flWindowAttr & CV_MINI)
2788 cnri.flWindowAttr &= (~CV_MINI);
2789 else
2790 cnri.flWindowAttr |= CV_MINI;
2791 }
2792 else {
2793 if (cnri.flWindowAttr & CV_TEXT) {
2794 cnri.flWindowAttr &= (~CV_TEXT);
2795 cnri.flWindowAttr |= CV_ICON;
2796 }
2797 else {
2798 cnri.flWindowAttr &= (~CV_ICON);
2799 cnri.flWindowAttr |= CV_TEXT;
2800 }
2801 }
2802 dcd->flWindowAttr = cnri.flWindowAttr;
2803 PrfWriteProfileData(fmprof,
2804 appname,
2805 "TreeflWindowAttr",
2806 &cnri.flWindowAttr, sizeof(ULONG));
2807 WinSendMsg(hwnd,
2808 CM_SETCNRINFO,
2809 MPFROMP(&cnri),
2810 MPFROMLONG(CMA_FLWINDOWATTR | CMA_TREEICON |
2811 CMA_SLTREEBITMAPORICON));
2812 }
2813 break;
2814
2815 case IDM_SIZES:
2816 case IDM_DRVFLAGS:
2817 case IDM_SHOWALLFILES:
2818 case IDM_UNDELETE:
2819 case IDM_OPTIMIZE:
2820 case IDM_CHKDSK:
2821 case IDM_FORMAT:
2822 case IDM_MKDIR:
2823 case IDM_LOCK:
2824 case IDM_UNLOCK:
2825 case IDM_EJECT:
2826 case IDM_CLOSETRAY:
2827 {
2828 PCNRITEM pci;
2829
2830 pci = (PCNRITEM) CurrentRecord(hwnd);
2831 if (pci && (INT) pci != -1)
2832 CommonDriveCmd(hwnd, pci->pszFileName, SHORT1FROMMP(mp1));
2833 }
2834 break;
2835
2836 case IDM_SAVETOLIST:
2837 WinDlgBox(HWND_DESKTOP,
2838 hwnd,
2839 SaveListDlgProc, FM3ModHandle, SAV_FRAME, MPFROMP(&hwnd));
2840 break;
2841
2842 case IDM_DELETE:
2843 case IDM_PERMDELETE:
2844 case IDM_MOVE:
2845 case IDM_WPSMOVE:
2846 case IDM_WILDMOVE:
2847 case IDM_RENAME:
2848 {
2849 PCNRITEM pci;
2850
2851 pci = (PCNRITEM) CurrentRecord(hwnd);
2852 if (pci && (INT) pci != -1) {
2853 if (pci->flags & RECFLAGS_UNDERENV)
2854 break;
2855 }
2856 }
2857 /* else intentional fallthru */
2858 case IDM_ATTRS:
2859 case IDM_INFO:
2860 case IDM_COPY:
2861 case IDM_WPSCOPY:
2862 case IDM_WILDCOPY:
2863 case IDM_DOITYOURSELF:
2864 case IDM_OPENWINDOW:
2865 case IDM_OPENSETTINGS:
2866 case IDM_OPENDEFAULT:
2867 case IDM_OPENICON:
2868 case IDM_OPENDETAILS:
2869 case IDM_OPENTREE:
2870 case IDM_SHADOW:
2871 case IDM_SHADOW2:
2872 case IDM_COMPARE:
2873 case IDM_VIEW:
2874 case IDM_VIEWTEXT:
2875 case IDM_VIEWBINARY:
2876 case IDM_EDIT:
2877 case IDM_EDITTEXT:
2878 case IDM_EDITBINARY:
2879 case IDM_EAS:
2880 case IDM_SUBJECT:
2881 case IDM_APPENDTOCLIP:
2882 case IDM_SAVETOCLIP:
2883 case IDM_ARCHIVE:
2884 case IDM_MCIPLAY:
2885 case IDM_UUDECODE:
2886 {
2887 LISTINFO *li;
2888 ULONG action = UM_ACTION;
2889# ifdef FORTIFY
2890 Fortify_EnterScope();
2891# endif
2892 li = xmallocz(sizeof(LISTINFO), pszSrcFile, __LINE__);
2893 if (li) {
2894 li->type = SHORT1FROMMP(mp1);
2895 li->hwnd = hwnd;
2896 li->list = BuildList(hwnd);
2897 if (!li->list || !li->list[0]) {
2898 free(li);
2899 break;
2900 }
2901 if (IsRoot(li->list[0])) {
2902 switch (SHORT1FROMMP(mp1)) {
2903 case IDM_MOVE:
2904 case IDM_COPY:
2905 case IDM_WILDCOPY:
2906 case IDM_WILDMOVE:
2907 case IDM_WPSMOVE:
2908 case IDM_WPSCOPY:
2909 case IDM_RENAME:
2910 case IDM_DELETE:
2911 case IDM_PERMDELETE:
2912 mp1 = MPFROM2SHORT(IDM_INFO, SHORT2FROMMP(mp1));
2913 li->type = IDM_INFO;
2914 }
2915 }
2916 switch (SHORT1FROMMP(mp1)) {
2917 case IDM_APPENDTOCLIP:
2918 case IDM_SAVETOCLIP:
2919 case IDM_ARCHIVE:
2920 case IDM_DELETE:
2921 case IDM_PERMDELETE:
2922 case IDM_ATTRS:
2923 case IDM_SHADOW:
2924 case IDM_SHADOW2:
2925 case IDM_DOITYOURSELF:
2926 case IDM_EAS:
2927 case IDM_VIEW:
2928 case IDM_VIEWTEXT:
2929 case IDM_VIEWBINARY:
2930 case IDM_EDIT:
2931 case IDM_EDITTEXT:
2932 case IDM_EDITBINARY:
2933 case IDM_MCIPLAY:
2934 action = UM_MASSACTION;
2935 }
2936 if (SHORT1FROMMP(mp1) == IDM_SHADOW ||
2937 SHORT1FROMMP(mp1) == IDM_SHADOW2)
2938 *li->targetpath = 0;
2939 if (!PostMsg(dcd->hwndObject, action, MPFROMP(li), MPVOID)) {
2940 Runtime_Error(pszSrcFile, __LINE__, "PostMsg");
2941 FreeListInfo(li);
2942 }
2943 }
2944# ifdef FORTIFY
2945 Fortify_LeaveScope();
2946# endif
2947 }
2948 break;
2949
2950 default:
2951 if (SHORT1FROMMP(mp1) >= IDM_COMMANDSTART &&
2952 SHORT1FROMMP(mp1) < IDM_QUICKTOOLSTART) {
2953
2954 INT x;
2955
2956 if (!cmdloaded)
2957 load_commands();
2958 x = SHORT1FROMMP(mp1) - IDM_COMMANDSTART;
2959 if (x >= 0) {
2960 x++;
2961 RunCommand(hwnd, x);
2962 if (fUnHilite)
2963 UnHilite(hwnd, TRUE, &dcd->lastselection, 0);
2964 }
2965 }
2966 break;
2967 }
2968 }
2969 return 0;
2970
2971 case WM_SAVEAPPLICATION:
2972 if (dcd && !ParentIsDesktop(hwnd, dcd->hwndParent)) {
2973
2974 SWP swp, swpP;
2975 INT ratio;
2976
2977 WinQueryWindowPos(dcd->hwndFrame, &swp);
2978 if (!(swp.fl & (SWP_MINIMIZE | SWP_MAXIMIZE | SWP_HIDE))) {
2979 WinQueryWindowPos(dcd->hwndParent, &swpP);
2980 if (swp.cx) {
2981 ratio = (swpP.cx * 100) / swp.cx;
2982 if (ratio > 0)
2983 PrfWriteProfileData(fmprof, appname, "TreeWindowRatio",
2984 &ratio, sizeof(INT));
2985 }
2986 }
2987 }
2988 else if (dcd && ParentIsDesktop(hwnd, dcd->hwndParent)) {
2989
2990 SWP swp;
2991
2992 WinQueryWindowPos(dcd->hwndFrame, &swp);
2993 if (!(swp.fl & (SWP_HIDE | SWP_MINIMIZE | SWP_MAXIMIZE)))
2994 WinStoreWindowPos(FM2Str, "VTreeWindowPos", dcd->hwndFrame);
2995 }
2996 break;
2997
2998 case UM_MINIMIZE:
2999 if (dcd && hwndMain) {
3000 fOkayMinimize = TRUE;
3001 if (dcd->hwndObject && !fDummy) {
3002 DosSleep(50);//05 Aug 07 GKY 100
3003 if (!fDummy) {
3004 fOkayMinimize = FALSE;
3005 WinSetWindowPos(((hwndMain) ? WinQueryWindow(hwndMain, QW_PARENT) :
3006 dcd->hwndFrame), HWND_TOP, 0, 0, 0, 0,
3007 SWP_MINIMIZE | SWP_DEACTIVATE);
3008 }
3009 }
3010 }
3011 return 0;
3012
3013 case UM_MAXIMIZE:
3014 if (dcd || hwndMain)
3015 WinSetWindowPos(((hwndMain) ? WinQueryWindow(hwndMain, QW_PARENT) :
3016 dcd->hwndFrame), HWND_TOP, 0, 0, 0, 0, SWP_MAXIMIZE |
3017 SWP_SHOW);
3018 return 0;
3019
3020 case UM_CLOSE:
3021 {
3022 HWND hwndParent = WinQueryWindow(WinQueryWindow(WinQueryWindow(hwnd,
3023 QW_PARENT),
3024 QW_PARENT), QW_PARENT);
3025
3026 if (!mp1) {
3027 if (!PostMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID))
3028 WinSendMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID);
3029 if (hwndParent && !ParentIsDesktop(hwnd, hwndParent))
3030 WinDestroyWindow(hwndParent);
3031 }
3032 else
3033 WinDestroyWindow(WinQueryWindow(WinQueryWindow(hwnd, QW_PARENT),
3034 QW_PARENT));
3035 }
3036 return 0;
3037
3038 case WM_CLOSE:
3039 WinSendMsg(hwnd, WM_SAVEAPPLICATION, MPVOID, MPVOID);
3040 if (dcd)
3041 dcd->stopflag++;
3042 if (dcd && dcd->hwndObject) {
3043 /* kill object window */
3044 if (!PostMsg(dcd->hwndObject, WM_CLOSE, MPVOID, MPVOID))
3045 WinSendMsg(dcd->hwndObject, WM_CLOSE, MPVOID, MPVOID);
3046 }
3047 else
3048 WinSendMsg(hwnd, UM_CLOSE, MPFROMLONG(1), MPVOID);
3049 return 0;
3050
3051 case WM_DESTROY:
3052# ifdef FORTIFY
3053 DbgMsg(pszSrcFile, __LINE__, "WM_DESTROY hwnd %p TID %u", hwnd, GetTidForThread()); // 18 Jul 08 SHL fixme
3054# endif
3055 if (TreeCnrMenu)
3056 WinDestroyWindow(TreeCnrMenu);
3057 if (DirMenu)
3058 WinDestroyWindow(DirMenu);
3059 if (FileMenu)
3060 WinDestroyWindow(FileMenu);
3061 TreeCnrMenu = FileMenu = DirMenu = (HWND) 0;
3062 EmptyCnr(hwnd);
3063 if (apphead) {
3064 APPNOTIFY *info, *next;
3065 info = apphead;
3066 while (info) {
3067 next = info->next;
3068 free(info);
3069 info = next;
3070 }
3071 apphead = apptail = NULL;
3072 }
3073# ifdef FORTIFY
3074 Fortify_LeaveScope();
3075# endif
3076 break; // WM_DESTROY
3077 } // switch
3078 if (dcd && dcd->oldproc){
3079 return dcd->oldproc(hwnd, msg, mp1, mp2);
3080 }
3081 else
3082 return PFNWPCnr(hwnd, msg, mp1, mp2);
3083}
3084
3085HWND StartTreeCnr(HWND hwndParent, ULONG flags)
3086{
3087 /* bitmapped flags:
3088 * 0x00000001 = don't close app when window closes
3089 * 0x00000002 = no frame controls
3090 * 0x00000004 = no close or move button
3091 */
3092
3093 HWND hwndFrame = NULLHANDLE;
3094 HWND hwndSysMenu = NULLHANDLE;
3095 HWND hwndClient;
3096 ULONG FrameFlags = FCF_TITLEBAR | FCF_SYSMENU |
3097 FCF_SIZEBORDER | FCF_MINMAX | FCF_ICON | FCF_NOBYTEALIGN | FCF_ACCELTABLE;
3098 DIRCNRDATA *dcd;
3099
3100 if (!hwndParent)
3101 hwndParent = HWND_DESKTOP;
3102 if (ParentIsDesktop(hwndParent, hwndParent))
3103 FrameFlags |= (FCF_TASKLIST | FCF_MENU);
3104 if (flags & 2)
3105 FrameFlags &= (~(FCF_TITLEBAR | FCF_SYSMENU | FCF_SIZEBORDER |
3106 FCF_MINMAX | FCF_ICON));
3107 hwndFrame = WinCreateStdWindow(hwndParent,
3108 WS_VISIBLE,
3109 &FrameFlags,
3110 WC_TREECONTAINER,
3111 NULL,
3112 WS_VISIBLE | fwsAnimate,
3113 FM3ModHandle, TREE_FRAME, &hwndClient);
3114 if (hwndParent != HWND_DESKTOP) {
3115 hwndSysMenu = WinWindowFromID(hwndFrame, FID_SYSMENU);
3116 if (hwndSysMenu != NULLHANDLE)
3117 WinSendMsg(hwndSysMenu, MM_SETITEMATTR,
3118 MPFROM2SHORT(SC_CLOSE, TRUE),
3119 MPFROM2SHORT(MIA_DISABLED, MIA_DISABLED));
3120 if (!fFreeTree)
3121 WinSendMsg(hwndSysMenu, MM_SETITEMATTR,
3122 MPFROM2SHORT(SC_MOVE, TRUE),
3123 MPFROM2SHORT(MIA_DISABLED, MIA_DISABLED));
3124 }
3125 if (hwndFrame && hwndClient) {
3126# ifdef FORTIFY
3127 Fortify_EnterScope();
3128# endif
3129 dcd = xmallocz(sizeof(DIRCNRDATA), pszSrcFile, __LINE__);
3130 if (!dcd) {
3131 Runtime_Error(pszSrcFile, __LINE__, GetPString(IDS_OUTOFMEMORY));
3132 PostMsg(hwndClient, WM_CLOSE, MPVOID, MPVOID);
3133 hwndFrame = (HWND) 0;
3134 }
3135 else {
3136 SWP swp;
3137 WinQueryWindowPos(hwndFrame, &swp);
3138 if (*(ULONG *) realappname == FM3UL) {
3139 if (!WinCreateWindow(hwndFrame,
3140 WC_TREEOPENBUTTON,
3141 "#303",
3142 WS_VISIBLE | BS_PUSHBUTTON | BS_NOPOINTERFOCUS | BS_BITMAP,
3143 ((swp.cx -
3144 WinQuerySysValue(HWND_DESKTOP,
3145 SV_CXMINMAXBUTTON)) -
3146 WinQuerySysValue(HWND_DESKTOP,
3147 SV_CXMINMAXBUTTON) / 2) -
3148 WinQuerySysValue(HWND_DESKTOP, SV_CXSIZEBORDER),
3149 (swp.cy -
3150 WinQuerySysValue(HWND_DESKTOP,
3151 SV_CYMINMAXBUTTON)) -
3152 WinQuerySysValue(HWND_DESKTOP, SV_CYSIZEBORDER),
3153 WinQuerySysValue(HWND_DESKTOP,
3154 SV_CXMINMAXBUTTON) / 2,
3155 WinQuerySysValue(HWND_DESKTOP,
3156 SV_CYMINMAXBUTTON), hwndFrame,
3157 HWND_TOP, IDM_OPENWINDOW, NULL, NULL)) {
3158 Win_Error2(hwndFrame, hwndParent, pszSrcFile, __LINE__,
3159 IDS_WINCREATEWINDOW);
3160 }
3161 }
3162 else {
3163 if (!WinCreateWindow(hwndFrame,
3164 WC_TREESTATUS,
3165 GetPString(IDS_YOUAREHERETEXT),
3166 WS_VISIBLE | SS_TEXT | DT_LEFT | DT_VCENTER,
3167 swp.x + 4 + WinQuerySysValue(HWND_DESKTOP,
3168 SV_CXSIZEBORDER),
3169 swp.cy - (22 + WinQuerySysValue(HWND_DESKTOP,
3170 SV_CYSIZEBORDER)),
3171 (swp.cx - 8) - (WinQuerySysValue(HWND_DESKTOP,
3172 SV_CXSIZEBORDER)
3173 * 2), 22, hwndFrame, HWND_TOP,
3174 MAIN_STATUS, NULL, NULL)) {
3175 Win_Error2(hwndFrame, hwndParent, pszSrcFile, __LINE__,
3176 IDS_WINCREATEWINDOW);
3177 }
3178 }
3179 memset(dcd, 0, sizeof(DIRCNRDATA));
3180 dcd->size = sizeof(DIRCNRDATA);
3181 dcd->type = TREE_FRAME;
3182 dcd->dontclose = ((flags & 1) != 0);
3183 dcd->hwndParent = (hwndParent) ? hwndParent : HWND_DESKTOP;
3184 dcd->hwndClient = hwndClient;
3185 dcd->hwndFrame = hwndFrame;
3186 {
3187 PFNWP oldproc;
3188
3189 oldproc = WinSubclassWindow(hwndFrame, TreeFrameWndProc);
3190 WinSetWindowPtr(hwndFrame, QWL_USER, (PVOID) oldproc);
3191 oldproc = WinSubclassWindow(WinWindowFromID(hwndFrame, FID_TITLEBAR),
3192 (PFNWP) TreeTitleWndProc);
3193 WinSetWindowPtr(WinWindowFromID(hwndFrame, FID_TITLEBAR),
3194 QWL_USER, (PVOID) oldproc);
3195 }
3196 dcd->hwndCnr = WinCreateWindow(hwndClient,
3197 WC_CONTAINER,
3198 NULL,
3199 CCS_AUTOPOSITION | CCS_MINIICONS |
3200 CCS_MINIRECORDCORE | WS_VISIBLE,
3201 0,
3202 0,
3203 0,
3204 0,
3205 hwndClient,
3206 HWND_TOP, (ULONG) TREE_CNR, NULL, NULL);
3207 if (!dcd->hwndCnr) {
3208 Win_Error2(hwndClient, hwndClient, pszSrcFile, __LINE__,
3209 IDS_WINCREATEWINDOW);
3210 PostMsg(hwndClient, WM_CLOSE, MPVOID, MPVOID);
3211 free(dcd);
3212 dcd = 0;
3213 hwndFrame = (HWND) 0;
3214 }
3215 else {
3216 WinSetWindowPtr(dcd->hwndCnr, QWL_USER, (PVOID) dcd);
3217 if (ParentIsDesktop(hwndFrame, hwndParent)) {
3218 WinSetWindowText(WinWindowFromID(hwndFrame, FID_TITLEBAR), "VTree");
3219 FixSwitchList(hwndFrame, "VTree");
3220 }
3221 else {
3222 WinSetWindowText(hwndFrame, GetPString(IDS_TREETEXT));
3223 WinSetWindowText(WinWindowFromID(hwndFrame, FID_TITLEBAR),
3224 GetPString(IDS_TREETEXT));
3225 }
3226 dcd->oldproc = WinSubclassWindow(dcd->hwndCnr, TreeCnrWndProc);
3227 // DbgMsg(pszSrcFile, __LINE__, "oldproc subclass %X", dcd->oldproc); // 05 Jul 07 SHL
3228 // fixme to document 01 test?
3229 if (dcd->oldproc == 0)
3230 Win_Error(HWND_DESKTOP, HWND_DESKTOP, pszSrcFile, __LINE__,
3231 "WinSubclassWindow");
3232 if (!PostMsg(dcd->hwndCnr, UM_SETUP, MPVOID, MPVOID))
3233 WinSendMsg(dcd->hwndCnr, UM_SETUP, MPVOID, MPVOID);
3234 }
3235 }
3236# ifdef FORTIFY
3237 if (dcd)
3238 Fortify_ChangeScope(dcd, -1);
3239 Fortify_LeaveScope();
3240 if (dcd)
3241 Fortify_ChangeScope(dcd, +1);
3242# endif
3243 }
3244 return hwndFrame;
3245}
3246
3247#pragma alloc_text(TREECNR,TreeCnrWndProc,TreeObjWndProc,TreeClientWndProc)
3248#pragma alloc_text(TREECNR,TreeFrameWndProc,TreeTitleWndProc,ShowTreeRec)
3249#pragma alloc_text(TREECNR,TreeStatProc,OpenButtonProc)
3250#pragma alloc_text(STARTUP,StartTreeCnr)
Note: See TracBrowser for help on using the repository browser.