mirror of https://github.com/lianthony/NT4.0
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
488 lines
14 KiB
488 lines
14 KiB
// UNUSED.TXT
|
|
//
|
|
// Stuff that is not used anymore but could be useful for
|
|
// cut & paste.
|
|
//
|
|
|
|
/*
|
|
switch (uMsg)
|
|
{
|
|
|
|
case WM_SETCURSOR:
|
|
if (MouseTargetter.m_dwTargetMode == CMouseTargetter::tgTargetTreeView)
|
|
{
|
|
HTREEITEM hti;
|
|
MOUSETARGETINFO mti = { hwnd };
|
|
|
|
Assert(TreeView.m_hWnd == hwnd);
|
|
// Fill out structure with mouse position
|
|
GetCursorPos(&tvHitTest.pt);
|
|
if (hti == s_htiOld)
|
|
{
|
|
if (hcursorOld)
|
|
{
|
|
SetCursor(hcursorOld);
|
|
return TRUE;
|
|
}
|
|
}
|
|
if (s_htiOld != NULL)
|
|
InvalidateRect(hwnd, &rcOld, TRUE);
|
|
|
|
if (hti)
|
|
{
|
|
(void)MouseTracker.HwndGrabCapture(hwnd);
|
|
TreeView_GetItemRect(hwnd, hti, &rcOld, TRUE);
|
|
rcOld.right++;
|
|
HDC hdc = GetDC(hwnd);
|
|
FrameRect(hdc, &rcOld, hbrWindowText);
|
|
ReleaseDC(hwnd, hdc);
|
|
|
|
tvItem.mask = TVIF_PARAM;
|
|
tvItem.hItem = hti;
|
|
SideAssert(TreeView_GetItem(hwnd, OUT &tvItem));
|
|
Assert((ITreeItem *)tvItem.lParam != NULL);
|
|
mti.hcursorTarget = hcursorFinger;
|
|
mti.tv.hti = hti;
|
|
mti.tv.pTreeItem = (ITreeItem *)tvItem.lParam;
|
|
s_htiOld = hti;
|
|
}
|
|
else
|
|
{
|
|
s_htiOld = NULL;
|
|
}
|
|
(void)MouseTargetter.OnNotify(INOUT &mti);
|
|
hcursorOld = mti.hcursorTarget;
|
|
if (mti.hcursorTarget)
|
|
{
|
|
SetCursor(mti.hcursorTarget);
|
|
return TRUE;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case UN_MOUSETIMERCAPTURE:
|
|
if (lParam == NULL && s_htiOld != NULL)
|
|
{
|
|
s_htiOld = NULL;
|
|
hcursorOld = NULL;
|
|
InvalidateRect(TreeView.m_hWnd, &rcOld, TRUE);
|
|
}
|
|
return 0;
|
|
} // switch
|
|
*/
|
|
case WM_SETCURSOR:
|
|
if (MouseTargetter.m_dwTargetMode != CMouseTargetter::tgTargetNone)
|
|
{
|
|
if ((HWND)wParam == hwndMain)
|
|
{
|
|
SetCursor(MouseTargetter.m_dwTargetMode == CMouseTargetter::tgTargetStandBy ?
|
|
hcursorArrow : hcursorNo);
|
|
return TRUE;
|
|
}
|
|
}
|
|
goto DoDefault;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
VOID CALLBACK MouseTrackerTimerProc(HWND, UINT, UINT, DWORD);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// class CMouseTracker
|
|
//
|
|
// CMouseTracker require a timer in order to determine if the mouse
|
|
// has gone out of a window client's rectangle. A window receives
|
|
// WM_MOUSEMOVE only when the mouse is inside its client area, but
|
|
// never receives any notification when the mouse is about to move
|
|
// to another window.
|
|
// A simple way would to capture the mouse on the first mouse move
|
|
// message and keep the capture as long as the mouse is inside the
|
|
// client area. Capturing the mouse has a bad side effect: It
|
|
// is impossible for the user to activate the menu via the Alt key.
|
|
//
|
|
// Therefore, we need to check manually if the cursor is on top of
|
|
// our window on every timer event. If the cursor is outside the
|
|
// window client's rectangle, it sends a UN_MOUSETIMERCAPTURE message
|
|
// with lParam==NULL, otherwise lParam==&ptMouse and wParam is the
|
|
// number of milliseconds that have elapsed since you grap the capture.
|
|
// ptMouse specifies the coordinates relative to the upper left
|
|
// corner of the client area.
|
|
//
|
|
// Once you grab the capture, you get UN_MOUSETIMERCAPTURE messages
|
|
// every dtTimerTick (currently 200 milliseconds) until you loose
|
|
// the capture.
|
|
//
|
|
class CMouseTracker
|
|
{
|
|
public:
|
|
enum { dtTimerTick = 200 };
|
|
|
|
protected:
|
|
UINT m_uTimerId;
|
|
HWND m_hwndCapture;
|
|
DWORD m_dwTimeCapture;
|
|
|
|
public:
|
|
CMouseTracker();
|
|
~CMouseTracker();
|
|
HWND HwndGrabCapture(HWND hwndCaptureNew);
|
|
HWND HwndReleaseCapture(HWND hwnd);
|
|
void OnWmTimer(DWORD dwCurrentTime);
|
|
inline HWND HwndGetCapture() const { return m_hwndCapture; }
|
|
DebugCode( UINT GetTimerId() const { return m_uTimerId; } )
|
|
|
|
}; // CMouseTracker
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// UN_MOUSETARGETCHANGED
|
|
//
|
|
// Notification message indicating the mouse has moved and the
|
|
// target has changed.
|
|
//
|
|
// wParam = 0;
|
|
// pMTI = (MOUSETARGETINFO *)lParam;
|
|
//
|
|
#define UN_MOUSETARGETCHANGED (WM_FIRST+30)
|
|
|
|
class ITreeItem;
|
|
struct MOUSETARGETINFO // mti
|
|
{
|
|
HWND hwndFrom; // IN: Window sending the message
|
|
DWORD dwFlags; // IN: Extra Flags
|
|
HCURSOR hcursorTarget; // OPTIONAL: Change the shape of the cursor
|
|
union
|
|
{
|
|
struct TREEVIEW_INFO
|
|
{
|
|
HTREEITEM hti;
|
|
ITreeItem * pTreeItem;
|
|
} tv;
|
|
};
|
|
};
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
class CMouseTargetter
|
|
{
|
|
public:
|
|
enum
|
|
{
|
|
tgTargetNone,
|
|
tgTargetStandBy,
|
|
tgTargetTreeView
|
|
};
|
|
|
|
public:
|
|
DWORD m_dwTargetMode; // What kind of target we want
|
|
HWND m_hwndNotify; // Window receiving UN_MOUSETARGETCHANGED
|
|
|
|
public:
|
|
void SetTargetMode(DWORD dwTargetMode, HWND hwndNotify = NULL);
|
|
LRESULT OnNotify(INOUT MOUSETARGETINFO * pMTI);
|
|
|
|
}; // CMouseTargetter
|
|
|
|
extern CMouseTargetter MouseTargetter;
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// UN_MOUSETIMERCAPTURE
|
|
//
|
|
// Notification message indicating the window has lost the mouse capture and/or
|
|
// the mouse cursor is no longer in its client area.
|
|
//
|
|
// dwTimeElapsed = (DWORD)wParam;
|
|
// fLostCapture = (BOOL)(lParam == NULL);
|
|
// pptMouse = (POINT *)lParam;
|
|
//
|
|
// dwTimeElapsed: Time elapsed (in milliseconds) since the capture
|
|
// fLostCapture: The mouse is no longer in your client area
|
|
// pptMouse: Mouse coordinates in client coordinates
|
|
//
|
|
#define UN_MOUSETIMERCAPTURE (WM_FIRST+31)
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CMouseTracker()
|
|
//
|
|
// Initialize the mouse tracker timer.
|
|
//
|
|
CMouseTracker::CMouseTracker()
|
|
{
|
|
DebugCode( static int cRefCount = 0; )
|
|
Assert(cRefCount++ == 0);
|
|
m_hwndCapture = NULL;
|
|
m_uTimerId = SetTimer(NULL, 0, dtTimerTick, (TIMERPROC)MouseTrackerTimerProc);
|
|
ReportFSz(m_uTimerId != 0, "CMouseTracker: Unable to set a timer.");
|
|
} // CMouseTracker
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// ~CMouseTracker()
|
|
//
|
|
// Kill the mouse tracker timer.
|
|
//
|
|
CMouseTracker::~CMouseTracker()
|
|
{
|
|
SideReport(KillTimer(NULL, m_uTimerId));
|
|
} // ~CMouseTracker
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// HwndGrabCapture()
|
|
//
|
|
// Set the mouse capture to the window hwndCaptureNew. If the capture
|
|
// was already set set to hwndCaptureNew, the function simply does
|
|
// nothing. If you want to release the capture, set hwndCaptureNew to
|
|
// NULL. This will send you a message UN_MOUSETIMERCAPTURE with
|
|
// lParam==NULL indicating you have lost the capture.
|
|
//
|
|
// Return Value:
|
|
// The function always returns the handle of the previous window having
|
|
// the capture. If no window had the capture, the function will return
|
|
// NULL. To find if you just captured the mouse, you may do the following:
|
|
//
|
|
// // Find if you just got the mouse capture
|
|
// if (MouseTracker.HwndGrabCapture(hwnd) != hwnd)
|
|
// {
|
|
// // Initialization code for the capture
|
|
// }
|
|
//
|
|
HWND CMouseTracker::HwndGrabCapture(HWND hwndCaptureNew)
|
|
{
|
|
HWND hwndCaptureOld;
|
|
DWORD dwCurrentTime;
|
|
|
|
Assert(IsWindow(hwndCaptureNew));
|
|
if (hwndCaptureNew == m_hwndCapture)
|
|
return m_hwndCapture;
|
|
// A new window is about to receive the mouse capture
|
|
hwndCaptureOld = m_hwndCapture;
|
|
m_hwndCapture = hwndCaptureNew;
|
|
// Get the current time
|
|
dwCurrentTime = GetTickCount();
|
|
// If the previous window having the capture still exists
|
|
if (IsWindow(hwndCaptureOld))
|
|
{
|
|
// Send a notification message that the window has lost the capture
|
|
SendMessage(hwndCaptureOld, UN_MOUSETIMERCAPTURE,
|
|
dwCurrentTime - m_dwTimeCapture, NULL);
|
|
}
|
|
m_dwTimeCapture = dwCurrentTime;
|
|
return hwndCaptureOld;
|
|
} // HwndGrabCapture
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// HwndReleaseCapture()
|
|
//
|
|
// Release the capture previously set by HwndGrabCapture. hwnd is the
|
|
// handle of the window releasing the capture (ie, the same handle
|
|
// as for HwndGrabCapture.
|
|
// If your window had the capture, the function will send a
|
|
// UN_MOUSETIMERCAPTURE message to your window to indicate you has
|
|
// lost the capture.
|
|
// The function will return the handle of the window having the capture.
|
|
// Typically the return value is NULL because the capture has been
|
|
// released, however there is always the possibility of another
|
|
// window having the capture. In this case, no UN_MOUSETIMERCAPTURE will
|
|
// be send to your window and the function will return a non-NULL handle.
|
|
// NOTE: A window should not worry about releasing the capture because
|
|
// as soon as someone else grab the capture, HwndGrabCapture will
|
|
// automatically release the capture of the previous window. This
|
|
// function should be used only if you want explicitly release the capture
|
|
// while you have the focus and/or receiving WM_MOUSEMOVE messages.
|
|
//
|
|
HWND CMouseTracker::HwndReleaseCapture(HWND hwnd)
|
|
{
|
|
Assert(IsWindow(hwnd));
|
|
if (hwnd == m_hwndCapture)
|
|
{
|
|
// Send a notification message to our the window to
|
|
// notify we have released/lost the capture
|
|
SendMessage(hwnd, UN_MOUSETIMERCAPTURE, 0, NULL);
|
|
m_hwndCapture = NULL;
|
|
}
|
|
return(m_hwndCapture);
|
|
} // HwndReleaseCapture
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// HwndGetCapture()
|
|
//
|
|
// Retrieves the handle of the window (if any) that has grabbed the
|
|
// capture. This may be useful if you want to do something special
|
|
// on your WM_PAINT message if you have the mouse capture.
|
|
//
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// OnWmTimer()
|
|
//
|
|
// Process the WM_TIMER message and forward a UN_MOUSETIMERCAPTURE to
|
|
// the window having the capture.
|
|
//
|
|
void CMouseTracker::OnWmTimer(DWORD dwCurrentTime)
|
|
{
|
|
HWND hwnd;
|
|
POINT ptMouse;
|
|
|
|
if (m_hwndCapture == NULL)
|
|
return;
|
|
if (!IsWindow(m_hwndCapture))
|
|
{
|
|
m_hwndCapture = NULL;
|
|
return;
|
|
}
|
|
hwnd = GetCapture();
|
|
if (hwnd == m_hwndCapture)
|
|
return;
|
|
if (hwnd)
|
|
{
|
|
// Someone else got the capture
|
|
// Send a notification message that the window has lost the capture
|
|
SendMessage(m_hwndCapture, UN_MOUSETIMERCAPTURE,
|
|
dwCurrentTime - m_dwTimeCapture, NULL);
|
|
m_hwndCapture = NULL;
|
|
return;
|
|
}
|
|
GetCursorPos(&ptMouse);
|
|
hwnd = WindowFromPoint(ptMouse);
|
|
if (hwnd != m_hwndCapture)
|
|
{
|
|
// Mouse is no longer on top of our window
|
|
// Send a notification message that the window has lost the capture
|
|
SendMessage(m_hwndCapture, UN_MOUSETIMERCAPTURE,
|
|
dwCurrentTime - m_dwTimeCapture, NULL);
|
|
m_hwndCapture = NULL;
|
|
}
|
|
else
|
|
{
|
|
ScreenToClient(m_hwndCapture, &ptMouse);
|
|
SendMessage(m_hwndCapture, UN_MOUSETIMERCAPTURE,
|
|
dwCurrentTime - m_dwTimeCapture, (LPARAM)&ptMouse);
|
|
}
|
|
} // OnWmTimer
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CMouseTargetter::SetTargetMode(DWORD dwTargetMode, HWND hwndNotify)
|
|
{
|
|
switch (dwTargetMode)
|
|
{
|
|
case tgTargetNone:
|
|
EnableWindow(hwndMain, TRUE);
|
|
HelperMgr.EnableWindow(TRUE);
|
|
break;
|
|
case tgTargetStandBy:
|
|
EnableWindow(hwndMain, FALSE);
|
|
break;
|
|
case tgTargetTreeView:
|
|
Assert(IsWindow(hwndNotify));
|
|
EnableWindow(hwndMain, TRUE);
|
|
HelperMgr.EnableWindow(FALSE);
|
|
break;
|
|
default:
|
|
Assert(FALSE);
|
|
} // switch
|
|
m_dwTargetMode = dwTargetMode;
|
|
m_hwndNotify = hwndNotify;
|
|
} // SetTargetMode
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
LRESULT CMouseTargetter::OnNotify(INOUT MOUSETARGETINFO * pMTI)
|
|
{
|
|
Assert(IsWindow(m_hwndNotify));
|
|
Assert(pMTI);
|
|
return SendMessage(m_hwndNotify, UN_MOUSETARGETCHANGED, 0, (LPARAM)pMTI);
|
|
} // OnNotify
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
VOID CALLBACK MouseTrackerTimerProc(
|
|
HWND hwnd, // Handle of window for timer messages
|
|
UINT uMsg, // WM_TIMER message
|
|
UINT idTimer, // Timer identifier
|
|
DWORD dwTime) // Current system time
|
|
{
|
|
Assert(hwnd == NULL);
|
|
Assert(uMsg == WM_TIMER);
|
|
Assert(idTimer == MouseTracker.GetTimerId());
|
|
MouseTracker.OnWmTimer(dwTime);
|
|
} // MouseTrackerTimerProc
|
|
|
|
// To store an array of pointers
|
|
// Behavior of a list
|
|
class CDynArray
|
|
{
|
|
private:
|
|
enum { nDataGranularity = 64 }; // Allocate storage for 64 elements
|
|
|
|
private:
|
|
PVOID m_rgpvData[100];
|
|
int m_cData; // Number of elements in array
|
|
int m_cDataAlloc; // Number of elements allocated
|
|
|
|
public:
|
|
CDynArray()
|
|
{
|
|
// Initialize the array to zeroes
|
|
ZeroInit(m_rgpvData, sizeof(m_rgpvData));
|
|
m_cData = 0;
|
|
}
|
|
|
|
// Insert an element at position iIndex
|
|
// - iIndex is a zero based index
|
|
// - If iIndex==-1, append at end of array
|
|
// - The array grows automatically if necessary
|
|
//
|
|
void Add(PVOID pvData)
|
|
{
|
|
// if (iIndex == -1)
|
|
// iIndex = m_cData; // Points to the end of array
|
|
|
|
// Assert(iIndex >= 0 && iIndex < 10); // REVIEW: Temporary
|
|
Assert(m_cData < 10);
|
|
m_rgpvData[m_cData++] = pvData;
|
|
}
|
|
|
|
PVOID GetAt(int iIndex)
|
|
{
|
|
Assert(iIndex >= 0 && iIndex < 10); // REVIEW: Temporary
|
|
return (m_rgpvData[iIndex]);
|
|
}
|
|
|
|
int GetSize()
|
|
{
|
|
return m_cData;
|
|
}
|
|
}; // CDynArray
|
|
#endif // NOT_USED
|
|
|
|
|
|
#ifdef OBSOLETE
|
|
Trace3(mskTraceUnused3, "\nTreeView::OnNotify() [code=0x%X (%d), action=0x%X] ",
|
|
pNmTreeView->hdr.code, pNmTreeView->hdr.code,
|
|
pNmTreeView->action);
|
|
switch (pNmTreeView->hdr.code)
|
|
{
|
|
case TVN_SETDISPINFO:
|
|
case TVN_GETDISPINFO:
|
|
Trace0(mskTraceUnused3, "TVN_GETDISPINFO/TVN_SETDISPINFO");
|
|
break;
|
|
case TVN_SELCHANGING:
|
|
Trace0(mskTraceUnused3, "TVN_SELCHANGING");
|
|
break;
|
|
case TVN_SELCHANGED:
|
|
Trace0(mskTraceUnused3, "TVN_SELCHANGED");
|
|
break;
|
|
case TVN_ITEMEXPANDING:
|
|
Trace0(mskTraceUnused3, "TVN_ITEMEXPANDING");
|
|
break;
|
|
case NM_RCLICK:
|
|
Trace0(mskTraceUnused3, "NM_RCLICK");
|
|
break;
|
|
case NM_CLICK:
|
|
Trace0(mskTraceUnused3, "NM_CLICK");
|
|
break;
|
|
case NM_DBLCLK:
|
|
Trace0(mskTraceUnused3, "NM_DBLCLK");
|
|
break;
|
|
case NM_RETURN:
|
|
break;
|
|
case NM_SETFOCUS:
|
|
Trace0(mskTraceUnused3, "NM_SETFOCUS");
|
|
} // switch
|
|
#endif // OBSOLETE
|