/****************************************************************************/
/* */
/* WFTREE.C - */
/* */
/* Windows File System Tree Window Proc Routines */
/* */
/****************************************************************************/
#include "winfile.h"
#include "lfn.h"
#include "wfcopy.h"
#include <commctrl.h>
#ifdef PROGMAN
#include "wficon.h"
#endif
HICON
GetTreeIcon(HWND hWnd);
HICON
GetTreeIcon(HWND hWnd)
{
HWND hwndTree, hwndDir;
hwndTree = HasTreeWindow(hWnd);
hwndDir = HasDirWindow(hWnd);
if (hwndTree && hwndDir)
return hicoTreeDir;
else if (hwndTree)
return hicoTree;
else
return hicoDir;
}
VOID
GetTreeWindows( HWND hwnd,
PHWND phwndTree,
PHWND phwndDir)
{
if (phwndTree) {
*phwndTree = GetDlgItem(hwnd, IDCW_TREECONTROL);
}
if (phwndDir) {
*phwndDir = GetDlgItem(hwnd, IDCW_DIR);
}
}
// returns hwndTree, hwndDir or hwndDrives depending on the focus tracking
// for the window. if none is found we return NULL
HWND
GetTreeFocus(HWND hwndTree)
{
HWND hwnd, hwndLast = NULL;
if (bDriveBar && GetFocus() == hwndDriveBar)
return hwndDriveBar;
hwndLast = hwnd = (HWND)GetWindowLong(hwndTree, GWL_LASTFOCUS);
while (hwnd && hwnd != hwndTree) {
hwndLast = hwnd;
hwnd = GetParent(hwnd);
}
return hwndLast;
}
/*--------------------------------------------------------------------------*/
/* */
/* CompactPath() - */
/* */
/*--------------------------------------------------------------------------*/
BOOL
CompactPath(HDC hDC, LPTSTR lpszPath, DWORD dx)
{
register INT len;
SIZE sizeF, sizeT;
LPTSTR lpEnd; /* end of the unfixed string */
LPTSTR lpFixed; /* start of text that we always display */
BOOL bEllipsesIn;
TCHAR szTemp[MAXPATHLEN];
DWORD dxEllipses;
//
// Does it already fit?
//
GetTextExtentPoint32(hDC, lpszPath, lstrlen(lpszPath), &sizeF);
if (sizeF.cx <= (INT)dx)
return(TRUE);
//
// Search backwards for the '\', and man, it better be there!
//
lpFixed = lpszPath + lstrlen(lpszPath) - 1;
while (*lpFixed != CHAR_BACKSLASH)
lpFixed--;
// Save this guy to prevent overlap.
lstrcpy(szTemp, lpFixed);
lpEnd = lpFixed;
bEllipsesIn = FALSE;
GetTextExtentPoint32(hDC, szEllipses, 3, &sizeF);
dxEllipses = sizeF.cx;
GetTextExtentPoint32(hDC, lpFixed, lstrlen(lpFixed), &sizeF);
while (TRUE) {
GetTextExtentPoint32(hDC, lpszPath, lpEnd - lpszPath, &sizeT);
len = sizeF.cx + sizeT.cx;
if (bEllipsesIn)
len += dxEllipses;
if (len <= (INT)dx)
break;
bEllipsesIn = TRUE;
if (lpEnd <= lpszPath) {
// Things didn't fit.
lstrcpy(lpszPath, szEllipses);
lstrcat(lpszPath, szTemp);
return(FALSE);
}
// Step back a character.
--lpEnd;
}
if (bEllipsesIn) {
lstrcpy(lpEnd, szEllipses);
lstrcat(lpEnd, szTemp);
}
return(TRUE);
}
/////////////////////////////////////////////////////////////////////
//
// Name: ResizeSplit
//
// Synopsis: Creates/resizes kids of MDI child for give path or
// resizes (perhaps creating/destroying) kids based on dxSplit
//
// IN hwnd Window to change
// IN dxSplit
//
//
// Return: TRUE = success
// FALSE = fail (out of mem, can't create win, unresizable tree)
//
//
// Assumes:
//
// Effects:
//
//
// Notes:
//
/////////////////////////////////////////////////////////////////////
BOOL
ResizeSplit(HWND hwnd, INT dxSplit)
{
RECT rc;
HWND hwndTree, hwndDir, hwndLB;
DWORD dwTemp;
GetTreeWindows(hwnd, &hwndTree, &hwndDir);
if (hwndTree && GetWindowLong(hwndTree, GWL_READLEVEL))
return FALSE;
GetClientRect(hwnd, &rc);
if (dxSplit > dxDriveBitmap * 2) {
if (!hwndTree) { // make new tree window
hwndTree = CreateWindowEx(0L,
szTreeControlClass,
NULL,
WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN,
0, 0, 0, 0,
hwnd,
(HMENU)IDCW_TREECONTROL,
hAppInstance, NULL);
if (!hwndTree)
return FALSE;
//
// only reset this if the dir window already
// exists, that is we are creating the tree
// by splitting open a dir window
//
if (hwndDir)
SendMessage(hwndTree, TC_SETDRIVE, MAKEWORD(FALSE, 0), 0L);
}
} else {
//
// In this conditional, always set dxSplit=0.
//
if (hwndTree) { // we are closing the tree window
//
// If the directory window is empty, then set the focus to the
// drives window.
//
if (hwndDir) {
hwndLB = GetDlgItem (hwndDir,IDCW_LISTBOX);
if (hwndLB) {
SendMessage (hwndLB,LB_GETTEXT,0,(LPARAM)(LPTSTR) &dwTemp);
if (!dwTemp)
SetFocus(hwndDriveBar);
}
}
DestroyWindow(hwndTree);
}
dxSplit = 0;
}
if ((rc.right - dxSplit) > dxDriveBitmap * 2) {
if (!hwndDir) {
hwndDir = CreateWindowEx(0L,
szDirClass,
NULL,
WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN,
0, 0, 0, 0,
hwnd,
(HMENU)IDCW_DIR,
hAppInstance,
NULL);
if (!hwndDir)
return FALSE;
} else {
//
// Must invalidate: if viewing extreme left, paint residue left.
//
InvalidateRect(hwndDir, NULL, TRUE);
}
} else {
//
// Again, always set dxSplit
//
if (hwndDir) {
DestroyWindow(hwndDir);
}
dxSplit = rc.right;
}
SetWindowLong(hwnd, GWL_SPLIT, dxSplit);
UpdateStatus(hwnd);
EnableCheckTBButtons(hwnd);
return TRUE;
}
VOID
SwitchDriveSelection(HWND hwndChild, BOOL bSelectToolbarDrive)
{
DRIVE drive;
DRIVEIND i, driveIndOld, driveIndOldFocus;
RECT rc;
drive = GetWindowLong(hwndChild, GWL_TYPE);
if (TYPE_SEARCH == drive) {
drive = (DRIVE)SendMessage(hwndSearch, FS_GETDRIVE, 0, 0L) - CHAR_A;
}
driveIndOld = GetWindowLong(hwndDriveBar, GWL_CURDRIVEIND);
driveIndOldFocus = GetWindowLong(hwndDriveBar, GWL_CURDRIVEFOCUS);
for (i=0; i < cDrives; i++) {
if (rgiDrive[i] == drive) {
SetWindowLong(hwndDriveBar, GWL_CURDRIVEIND, i);
SetWindowLong(hwndDriveBar, GWL_CURDRIVEFOCUS, i);
break;
}
}
if (i == cDrives)
return; // didn't find drive; it must have been invalidated
// other code (such as tree walk) will handle
if (bDriveBar) {
//
// Optimization: don't invalidate whole drive bar, just the
// two drives that change.
//
// was: InvalidateRect(hwndDriveBar, NULL, TRUE);
//
GetDriveRect(i, &rc);
InvalidateRect(hwndDriveBar, &rc, TRUE);
GetDriveRect(driveIndOld, &rc);
InvalidateRect(hwndDriveBar, &rc, TRUE);
GetDriveRect(driveIndOldFocus, &rc);
InvalidateRect(hwndDriveBar, &rc, TRUE);
UpdateWindow(hwndDriveBar);
}
// made optional to prevent extra refreshing.
if (bSelectToolbarDrive)
SelectToolbarDrive(i);
}
//--------------------------------------------------------------------------*/
// */
// TreeWndProc() - */
// */
//--------------------------------------------------------------------------*/
// WndProc for the MDI child window containing the drives, volume, and
// directory tree child windows.
LONG
TreeWndProc(
register HWND hwnd,
UINT uMsg,
register WPARAM wParam,
LPARAM lParam)
{
HWND hwndTree, hwndDir, hwndFocus;
TCHAR szDir[2*MAXPATHLEN];
RECT rc;
HDC hdc;
switch (uMsg) {
case WM_MENUSELECT:
if (GET_WM_MENUSELECT_HMENU(wParam, lParam)) {
//
// Save the menu the user selected
//
uMenuID = GET_WM_MENUSELECT_CMD(wParam, lParam);
uMenuFlags = GET_WM_MENUSELECT_FLAGS(wParam, lParam);
hMenu = GET_WM_MENUSELECT_HMENU(wParam, lParam);
bMDIFrameSysMenu = FALSE;
}
MenuHelp((WORD)uMsg, wParam, lParam, GetMenu(hwndFrame),
hAppInstance, hwndStatus, (LPDWORD)dwMenuIDs);
break;
case WM_FSC:
if (hwndDir = HasDirWindow(hwnd))
SendMessage(hwndDir, uMsg, wParam, lParam);
break;
case FS_NOTIFYRESUME:
if (hwndDir = HasDirWindow(hwnd)) {
SendMessage(hwnd, FS_GETDIRECTORY, COUNTOF(szDir), (LPARAM)szDir);
ModifyWatchList(hwnd, szDir, FILE_NOTIFY_CHANGE_FLAGS);
}
break;
case FS_CHANGEDRIVES:
{
GetMDIWindowText(hwnd, szDir, COUNTOF(szDir));
SetMDIWindowText(hwnd, szDir); /* refresh label in title */
RedoDriveWindows((HWND)SendMessage(hwndMDIClient, WM_MDIGETACTIVE, 0, 0L));
break;
}
case FS_GETSELECTION:
{
#define pfDir (BOOL *)lParam
LPTSTR p;
GetTreeWindows(hwnd, &hwndTree, &hwndDir);
hwndFocus = GetTreeFocus(hwnd);
if (hwndFocus == hwndDir || !hwndTree) {
return SendMessage(hwndDir, FS_GETSELECTION, wParam, lParam);
} else {
//
// +2 for checkesc safety
//
p = (LPTSTR)LocalAlloc(LPTR, ByteCountOf(MAXPATHLEN + 2));
if (p) {
SendMessage(hwnd, FS_GETDIRECTORY, MAXPATHLEN, (DWORD)(LPTSTR)p);
StripBackslash(p);
if (!(wParam & 16)) CheckEsc(p);
if (wParam == 2) { // BUG ??? wParam should be fMostRecentOnly
if (pfDir) {
*pfDir = IsLFN(p);
}
LocalFree((HANDLE)p);
return (LONG)p;
}
}
if (pfDir) {
*pfDir = TRUE;
}
return (LONG)p;
}
#undef pfDir
}
case FS_GETDIRECTORY:
// wParam is the length of the string pointed to by lParam
// returns in lParam ANSI directory string with
// a trailing backslash. if you want to do a SetCurrentDirecotor()
// you must first StripBackslash() the thing!
GetMDIWindowText(hwnd, (LPTSTR)lParam, (INT)wParam); // get the string
StripFilespec((LPTSTR)lParam); // Remove the trailing extention
AddBackslash((LPTSTR)lParam); // terminate with a backslash
break;
case FS_GETFILESPEC:
// WARNING: Requires ((LPTSTR)lparam)[MAXPATHLEN] space!
// (TreeControlWndProc WM_COMMAND LBN_SELCHANGE broke this!)
// returns the current filespec (from View.Include...). this is
// an uppercase ANSI string
GetMDIWindowText(hwnd, (LPTSTR)lParam, (INT)wParam);
StripPath((LPTSTR)lParam);
break;
// redirect these messages to the drive icons to get the same
// result as dropping on the active drive.
// this is especially useful when we are minimized
case WM_DRAGSELECT:
case WM_QUERYDROPOBJECT:
case WM_DROPOBJECT:
// This code is really messed up since there is only one drive bar.
// Fix the case for Iconic windows but the uniconic state is weird
#define lpds ((LPDROPSTRUCT)lParam)
if (IsIconic(hwnd) || hwnd != (HWND)SendMessage(hwndMDIClient, WM_MDIGETACTIVE, 0, 0L)) {
if (hwndDir = HasDirWindow(hwnd)) {
lpds->dwControlData = (DWORD) -1;
return SendMessage(hwndDir, uMsg, wParam, lParam);
} else {
break;
}
}
#undef lpds
if (hwndDriveBar) {
LONG lRet;
hwndDropChild = hwnd;
lRet = SendMessage(hwndDriveBar, uMsg, wParam, lParam);
hwndDropChild = NULL;
return lRet;
}
if (hwndDir = HasDirWindow(hwnd)) {
return SendMessage(hwndDir, uMsg, wParam, lParam);
}
break;
case FS_GETDRIVE:
GetTreeWindows(hwnd, &hwndTree, &hwndDir);
if (hwndTree)
return SendMessage(hwndTree, uMsg, wParam, lParam);
else
return SendMessage(hwndDir, uMsg, wParam, lParam);
break;
case WM_CREATE:
{
#define lpcs ((LPCREATESTRUCT)lParam)
#define lpmdics ((LPMDICREATESTRUCT)(lpcs->lpCreateParams))
INT dxSplit;
DRIVE drive;
WCHAR szPath[2 * MAXFILENAMELEN];
//
// lpcs->lpszName is the path we are opening the
// window for (has extension stuff "*.*")
//
drive = DRIVEID(lpcs->lpszName);
SetWindowLong(hwnd, GWL_TYPE, drive);
//
// if dxSplit is negative we split in the middle
//
dxSplit = (INT)lpmdics->lParam;
//
// if dxSplit is negative we split in the middle
//
if (dxSplit < 0)
dxSplit = lpcs->cx / 2;
SetWindowLong(hwnd, GWL_NOTIFYPAUSE, 0L);
SetWindowLong(hwnd, GWL_SPLIT, dxSplit);
SetWindowLong(hwnd, GWL_LASTFOCUS, 0L);
SetWindowLong(hwnd, GWL_FSCFLAG, FALSE);
SetWindowLong(hwnd, GWL_VOLNAME, 0L);
SetWindowLong(hwnd, GWL_PATHLEN, 0L);
#ifdef PROGMAN
SetWindowLong(hwnd, GWL_PICONBLOCK, 0L);
#endif
if (!ResizeSplit(hwnd, dxSplit))
return -1;
GetTreeWindows(hwnd, &hwndTree, &hwndDir);
SetWindowLong(hwnd, GWL_LASTFOCUS, (LONG)(hwndTree ? hwndTree : hwndDir));
iNumWindows++;
GetMDIWindowText(hwnd, szPath, COUNTOF(szPath));
SetMDIWindowText(hwnd, szPath);
break;
#undef lpcs
#undef lpmdics
}
case WM_CLOSE:
if (hwndTree = HasTreeWindow(hwnd)) {
//
// don't close if we are reading the tree
//
if (GetWindowLong(hwndTree, GWL_READLEVEL))
break;
}
//
// don't allow the last MDI child to be closed!
//
if (!IsLastWindow()) {
iNumWindows--;
//
// don't leave current dir on floppies
//
GetSystemDirectory(szDir, COUNTOF(szDir));
SheSetCurDrive(DRIVEID(szDir));
goto DEF_MDI_PROC; // this will close this window
}
break;
case WM_DESTROY:
{
LPWSTR lpszVolName;
//
// Free GWL_VOLNAME
//
lpszVolName = (LPTSTR)GetWindowLong(hwnd, GWL_VOLNAME);
if (lpszVolName)
LocalFree(lpszVolName);
break;
}
case WM_MDIACTIVATE:
//
// Invalidate the cache since we are switching windows
//
ExtSelItemsInvalidate();
//
// we are receiving the activation
//
if (GET_WM_MDIACTIVATE_FACTIVATE(hwnd, wParam, lParam)) {
#ifdef PROGMAN
IconMDIActivate();
#endif
EnableCheckTBButtons(hwnd);
SPC_SET_INVALID(qFreeSpace);
UpdateStatus(hwnd);
hwndFocus = (HWND)GetWindowLong(hwnd, GWL_LASTFOCUS);
SetFocus(hwndFocus);
SwitchDriveSelection(hwnd, TRUE);
}
else if (hwndDriveBar)
SendMessage(hwndDriveBar, uMsg, wParam, lParam);
break;
case WM_SETFOCUS:
hwndFocus = (HWND)GetWindowLong(hwnd, GWL_LASTFOCUS);
SetFocus(hwndFocus);
break;
case WM_INITMENUPOPUP:
if (HIWORD(lParam)) {
EnableMenuItem((HMENU)wParam, SC_CLOSE,
IsLastWindow() ? MF_BYCOMMAND | MF_DISABLED | MF_GRAYED :
MF_ENABLED);
}
break;
case WM_SYSCOMMAND:
if (wParam != SC_SPLIT)
goto DEF_MDI_PROC;
GetClientRect(hwnd, &rc);
lParam = MAKELONG(rc.right / 2, 0);
// fall through
case WM_LBUTTONDOWN:
{
MSG msg;
INT x, y, dx, dy;
if (IsIconic(hwnd))
break;
y = 0;
x = LOWORD(lParam);
GetClientRect(hwnd, &rc);
dx = 4;
dy = rc.bottom - y; // the height of the client less the drives window
hdc = GetDC(hwnd);
// split bar loop
PatBlt(hdc, x - dx / 2, y, dx, dy, PATINVERT);
SetCapture(hwnd);
while (GetMessage(&msg, NULL, 0, 0)) {
if (msg.message == WM_KEYDOWN || msg.message == WM_SYSKEYDOWN ||
(msg.message >= WM_MOUSEFIRST && msg.message <= WM_MOUSELAST)) {
if (msg.message == WM_LBUTTONUP || msg.message == WM_LBUTTONDOWN)
break;
if (msg.message == WM_KEYDOWN) {
if (msg.wParam == VK_LEFT) {
msg.message = WM_MOUSEMOVE;
msg.pt.x -= 2;
} else if (msg.wParam == VK_RIGHT) {
msg.message = WM_MOUSEMOVE;
msg.pt.x += 2;
} else if (msg.wParam == VK_RETURN ||
msg.wParam == VK_ESCAPE) {
break;
}
SetCursorPos(msg.pt.x, msg.pt.y);
}
if (msg.message == WM_MOUSEMOVE) {
// erase old
PatBlt(hdc, x - dx / 2, y, dx, dy, PATINVERT);
ScreenToClient(hwnd, &msg.pt);
x = msg.pt.x;
// put down new
PatBlt(hdc, x - dx / 2, y, dx, dy, PATINVERT);
}
} else {
DispatchMessage(&msg);
}
}
ReleaseCapture();
// erase old
PatBlt(hdc, x - dx / 2, y, dx, dy, PATINVERT);
ReleaseDC(hwnd, hdc);
if (msg.wParam != VK_ESCAPE) {
if (ResizeSplit(hwnd, x))
SendMessage(hwnd, WM_SIZE, SIZENOMDICRAP, MAKELONG(rc.right, rc.bottom));
}
break;
}
case WM_QUERYDRAGICON:
return (LONG)GetTreeIcon(hwnd);
break;
case WM_ERASEBKGND:
if (IsIconic(hwnd)) {
// this paints the background of the icon properly, doing
// brush allignment and other nasty stuff
DefWindowProc(hwnd, WM_ICONERASEBKGND, wParam, 0L);
} else {
//
// Don't bother since we will be redrawing everything
// over it anyway.
//
}
break;
case WM_PAINT:
{
PAINTSTRUCT ps;
HBRUSH hbr;
hdc = BeginPaint(hwnd, &ps);
if (IsIconic(hwnd)) {
DrawIcon(hdc, 0, 0, GetTreeIcon(hwnd));
} else {
GetClientRect(hwnd, &rc);
rc.left = GetSplit(hwnd);
if (rc.left >= rc.right)
rc.left = 0;
rc.right = rc.left + dxFrame;
// draw the black pane handle
rc.top = rc.bottom - GetSystemMetrics(SM_CYHSCROLL);
FillRect(hdc, &rc, GetStockObject(BLACK_BRUSH));
if (hbr = CreateSolidBrush(GetSysColor(COLOR_WINDOW))) {
rc.bottom = rc.top;
rc.top = 0;
FillRect(hdc, &rc, hbr);
DeleteObject(hbr);
}
}
EndPaint(hwnd, &ps);
break;
}
case WM_SIZE:
if (wParam != SIZEICONIC) {
//
// Must invalidate rect to clear up the hwndDir display
// when the view is single column (partial/full details)
// and it's scrolled to the extreme left. (Either resizing
// larger or maximizing)
//
// To avoid nasty double flicker, we turn off the redraw
// flag for the list box (hwndDir is set to IDCW_LISTBOX).
// Then we redraw then repaint.
//
if (hwndDir = HasDirWindow(hwnd)) {
hwndDir = GetDlgItem(hwndDir, IDCW_LISTBOX);
SendMessage(hwndDir, WM_SETREDRAW, FALSE, 0L);
}
ResizeWindows(hwnd,LOWORD(lParam),HIWORD(lParam));
//
// When hwndDir is non-NULL, it holds the IDCW_LISTBOX set
// above. Now set redraw true and repaint.
//
if (hwndDir) {
SendMessage(hwndDir, WM_SETREDRAW, TRUE, 0L);
InvalidateRect(hwndDir, NULL, TRUE);
UpdateWindow(hwndDir);
}
} else if (IsLastWindow()) {
//
// A bug in MDI sometimes causes us to get the input focus
// even though we're minimized. Prevent that...
//
SetFocus(GetParent(hwnd));
}
//
// if wParam is SIZENOMDICRAP this WM_SIZE was generated by us.
// don't let this through to the DefMDIChildProc().
// that might change the min/max state, (show parameter)
//
if (wParam == SIZENOMDICRAP)
break;
//
// FALL THRU
//
default:
DEF_MDI_PROC:
return DefMDIChildProc(hwnd, uMsg, wParam, lParam);
}
return 0L;
}
VOID
ResizeWindows(HWND hwndParent,INT dxWindow, INT dyWindow)
{
INT y, dy, split;
HWND hwndTree, hwndDir;
RECT rc;
GetTreeWindows(hwndParent, &hwndTree, &hwndDir);
y = -dyBorder;
split = GetSplit(hwndParent);
//
// user has been fixed to do this right
//
dy = dyWindow - y + dyBorder;
if (hwndTree) {
if (!hwndDir)
MoveWindow(hwndTree, dxFrame, y, dxWindow - dxFrame + dyBorder, dy, TRUE);
else
MoveWindow(hwndTree, -dyBorder, y, split + dyBorder, dy, TRUE);
}
if (hwndDir) {
if (!hwndTree)
MoveWindow(hwndDir, dxFrame, y, dxWindow - dxFrame + dyBorder, dy, TRUE);
else
MoveWindow(hwndDir, split + dxFrame, y,
dxWindow - split - dxFrame + dyBorder, dy, TRUE);
}
//
// since this window is not CS_HREDRAW | CS_VREDRAW we need to force
// the repaint of the split
//
rc.top = y;
rc.bottom = y + dy;
//
// yutakas
// When split moved, Tree Window couldn't redraw.
//
if ((hwndTree) && (!(rc.left = GetScrollPos(GetDlgItem(hwndTree,
IDCW_TREELISTBOX),
SB_HORZ) ?
0 :
split))) {
rc.right = split;
InvalidateRect(hwndParent, &rc, FALSE);
}
rc.left = split;
rc.right = split + dxFrame;
InvalidateRect(hwndParent, &rc, TRUE);
UpdateWindow(hwndParent);
}