Windows/UltimateToolbox
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
UltimateToolbox/UltimateToolbox93_src/Ultimate Toolbox/source/OXIntelliMouse.cpp
Raten fb064541d6 new
2025-11-27 16:46:48 +09:00

1344 lines
33 KiB
C++
Raw Permalink Blame History

// ==========================================================================
// Class Implementation :
// COXIntelliMouse
// ==========================================================================
// Version: 9.3
// This software along with its related components, documentation and files ("The Libraries")
// is © 1994-2007 The Code Project (1612916 Ontario Limited) and use of The Libraries is
// governed by a software license agreement ("Agreement"). Copies of the Agreement are
// available at The Code Project (www.codeproject.com), as part of the package you downloaded
// to obtain this file, or directly from our office. For a copy of the license governing
// this software, you may contact us at legalaffairs@codeproject.com, or by calling 416-849-8900.
// //////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "OXIntelliMouse.h"
#include "UTB64Bit.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
IMPLEMENT_DYNAMIC(COXIntelliMouse, COXHookWnd);
// Constructor
COXIntelliMouse::COXIntelliMouse()
{
// initialize variables
Reset();
m_nStartEventID=0;
m_dwKeyState=0;
// load splash window bitmap
//
m_splashWnd.LoadBitmap(IDB_OX_INTELLITARGET);
// create cursors
//
HCURSOR hCursor;
hCursor = AfxGetApp()->LoadCursor(MAKEINTRESOURCE(IDC_OX_SCRL_LEFT));
ASSERT(hCursor!=NULL);
m_arrScrollCursor.SetAt(SCRL_LEFT,hCursor);
hCursor = AfxGetApp()->LoadCursor(MAKEINTRESOURCE(IDC_OX_SCRL_TOPLEFT));
ASSERT(hCursor!=NULL);
m_arrScrollCursor.SetAt(SCRL_TOPLEFT,hCursor);
hCursor = AfxGetApp()->LoadCursor(MAKEINTRESOURCE(IDC_OX_SCRL_TOP));
ASSERT(hCursor!=NULL);
m_arrScrollCursor.SetAt(SCRL_TOP,hCursor);
hCursor = AfxGetApp()->LoadCursor(MAKEINTRESOURCE(IDC_OX_SCRL_TOPRIGHT));
ASSERT(hCursor!=NULL);
m_arrScrollCursor.SetAt(SCRL_TOPRIGHT,hCursor);
hCursor = AfxGetApp()->LoadCursor(MAKEINTRESOURCE(IDC_OX_SCRL_RIGHT));
ASSERT(hCursor!=NULL);
m_arrScrollCursor.SetAt(SCRL_RIGHT,hCursor);
hCursor = AfxGetApp()->LoadCursor(MAKEINTRESOURCE(IDC_OX_SCRL_BOTTOMRIGHT));
ASSERT(hCursor!=NULL);
m_arrScrollCursor.SetAt(SCRL_BOTTOMRIGHT,hCursor);
hCursor = AfxGetApp()->LoadCursor(MAKEINTRESOURCE(IDC_OX_SCRL_BOTTOM));
ASSERT(hCursor!=NULL);
m_arrScrollCursor.SetAt(SCRL_BOTTOM,hCursor);
hCursor = AfxGetApp()->LoadCursor(MAKEINTRESOURCE(IDC_OX_SCRL_BOTTOMLEFT));
ASSERT(hCursor!=NULL);
m_arrScrollCursor.SetAt(SCRL_BOTTOMLEFT,hCursor);
hCursor = AfxGetApp()->LoadCursor(MAKEINTRESOURCE(IDC_OX_SCRL_LEFTRIGHT));
ASSERT(hCursor!=NULL);
m_arrScrollCursor.SetAt(SCRL_LEFTRIGHT,hCursor);
hCursor = AfxGetApp()->LoadCursor(MAKEINTRESOURCE(IDC_OX_SCRL_TOPBOTTOM));
ASSERT(hCursor!=NULL);
m_arrScrollCursor.SetAt(SCRL_TOPBOTTOM,hCursor);
hCursor = AfxGetApp()->LoadCursor(MAKEINTRESOURCE(IDC_OX_SCRL_ALL));
ASSERT(hCursor!=NULL);
m_arrScrollCursor.SetAt(SCRL_ALL,hCursor);
ASSERT(m_arrScrollCursor.GetCount()==ID_ICONCOUNT);
// create helper window
//
// make it transparent
if(!m_helperWnd.CreateEx(WS_EX_TRANSPARENT|WS_EX_TOOLWINDOW,
AfxRegisterWndClass(CS_DBLCLKS),_T(""),WS_POPUP,0,0,0,0,NULL,NULL))
{
TRACE(_T("COXIntelliMouse::COXIntelliMouse: unable to create helper window!\n"));
AfxThrowResourceException();
}
ASSERT(::IsWindow(m_helperWnd.m_hWnd));
m_pOldForegroundWnd=NULL;
}
// Destructor
COXIntelliMouse::~COXIntelliMouse()
{
m_arrScrollCursor.RemoveAll();
m_arrScrollRect.RemoveAll();
if(::IsWindow(m_helperWnd.m_hWnd))
{
m_helperWnd.DestroyWindow();
}
}
void COXIntelliMouse::Reset()
{
m_bIsHandling=FALSE;
m_dwScrollFlag=SCRL_NONE;
m_nScrollTimerID=0;
m_scrollDirection=SCRL_NONE;
m_szScrollSize=CSize(0,0);
m_ptStart=CPoint(-1,-1);
}
BOOL COXIntelliMouse::Attach(CWnd* pWnd,
const UINT nStartEventID/*=WM_MBUTTONDOWN*/,
const DWORD dwKeyState/*=0*/)
{
ASSERT(::IsWindow(pWnd->m_hWnd));
HookWindow(pWnd);
m_nStartEventID=nStartEventID;
m_dwKeyState=dwKeyState;
return TRUE;
}
void COXIntelliMouse::Detach()
{
UnhookWindow();
CancelIntelliMouseSupport();
}
////////////////////////////////////////////////////////////////////////////
//
LRESULT COXIntelliMouse::WindowProc(UINT msg, WPARAM wp, LPARAM lp)
{
#ifdef _WINDLL
#ifndef _AFXEXT
AFX_MANAGE_STATE(AfxGetStaticModuleState());
#endif
#endif
ASSERT(::IsWindow(m_hWndHooked));
if(msg==m_nStartEventID && !m_bIsHandling)
{
BOOL bKeyState=TRUE;
if(bKeyState && (m_dwKeyState&KEYPRESSED_CONTROL)!=0)
bKeyState=(GetKeyState(VK_CONTROL)<0);
if(bKeyState && (m_dwKeyState&KEYPRESSED_SHIFT)!=0)
bKeyState=(GetKeyState(VK_SHIFT)<0);
if(bKeyState && (m_dwKeyState&KEYPRESSED_ALT)!=0)
bKeyState=(GetKeyState(VK_MENU)<0);
if(bKeyState)
if(LaunchIntelliMouseSupport())
return (LRESULT)0;
}
if(m_bIsHandling && ::GetCapture()!=m_hWndHooked)
CancelIntelliMouseSupport();
if(m_bIsHandling)
{
switch(msg)
{
case WM_NCMOUSEMOVE:
case WM_MOUSEMOVE:
{
// define scroll direction
//
CPoint ptTest;
::GetCursorPos(&ptTest);
m_scrollDirection=FindScrollDirectionFromPoint(ptTest);
ASSERT(m_scrollDirection!=SCRL_NONE);
ShowScrollCursor(m_scrollDirection);
// update scroll speed
//
CRect rect;
VERIFY(m_arrScrollRect.Lookup(m_scrollDirection,rect));
switch(m_scrollDirection)
{
case SCRL_LEFT:
{
m_szScrollSize=CSize((ptTest.x-rect.right)/ID_SCROLLCOEF,0);
break;
}
case SCRL_TOPLEFT:
{
m_szScrollSize=CSize((ptTest.x-rect.right)/ID_SCROLLCOEF,
(ptTest.y-rect.bottom)/10);
break;
}
case SCRL_TOP:
{
m_szScrollSize=CSize(0,(ptTest.y-rect.bottom)/10);
break;
}
case SCRL_TOPRIGHT:
{
m_szScrollSize=CSize((ptTest.x-rect.left)/ID_SCROLLCOEF,
(ptTest.y-rect.bottom)/10);
break;
}
case SCRL_RIGHT:
{
m_szScrollSize=CSize((ptTest.x-rect.left)/ID_SCROLLCOEF,0);
break;
}
case SCRL_BOTTOMRIGHT:
{
m_szScrollSize=CSize((ptTest.x-rect.left)/ID_SCROLLCOEF,
(ptTest.y-rect.top)/10);
break;
}
case SCRL_BOTTOM:
{
m_szScrollSize=CSize(0,(ptTest.y-rect.top)/10);
break;
}
case SCRL_BOTTOMLEFT:
{
m_szScrollSize=CSize((ptTest.x-rect.right)/ID_SCROLLCOEF,
(ptTest.y-rect.top)/10);
break;
}
case SCRL_TOPBOTTOM:
case SCRL_LEFTRIGHT:
case SCRL_ALL:
{
m_szScrollSize=CSize(0,0);
break;
}
default:
ASSERT(FALSE);
}
break;
}
case WM_SETCURSOR:
{
return TRUE;
}
case WM_TIMER:
{
if(wp==m_nScrollTimerID)
{
int nScrollCode;
BOOL bScrollViewDerived=
GetHookedWnd()->IsKindOf(RUNTIME_CLASS(CScrollView));
if(m_szScrollSize.cx!=0)
{
nScrollCode=m_szScrollSize.cx>0 ? SB_LINERIGHT : SB_LINELEFT;
for(int nIndex=0; nIndex<abs(m_szScrollSize.cx); nIndex++)
{
if(bScrollViewDerived)
{
((CScrollView*)GetHookedWnd())->
OnScroll(MAKEWORD((BYTE)nScrollCode,-1),0);
}
else
{
GetHookedWnd()->SendMessage(WM_HSCROLL,
MAKEWPARAM(nScrollCode,0),(LPARAM)NULL);
}
}
}
if(m_szScrollSize.cy!=0)
{
nScrollCode=m_szScrollSize.cy>0 ? SB_LINEDOWN : SB_LINEUP;
for(int nIndex=0; nIndex<abs(m_szScrollSize.cy); nIndex++)
{
if(bScrollViewDerived)
{
((CScrollView*)GetHookedWnd())->
OnScroll(MAKEWORD(-1,(BYTE)nScrollCode),0);
}
else
{
GetHookedWnd()->SendMessage(WM_VSCROLL,
MAKEWPARAM(nScrollCode,0),(LPARAM)NULL);
}
}
}
// update scroll info
GetHookedScrollInfo();
return (LRESULT)0;
}
else
break;
}
case WM_LBUTTONDOWN:
case WM_RBUTTONDOWN:
case WM_MBUTTONDOWN:
case WM_LBUTTONDBLCLK:
case WM_RBUTTONDBLCLK:
case WM_MBUTTONDBLCLK:
case WM_NCLBUTTONDOWN:
case WM_NCRBUTTONDOWN:
case WM_NCMBUTTONDOWN:
case WM_NCLBUTTONDBLCLK:
case WM_NCRBUTTONDBLCLK:
case WM_NCMBUTTONDBLCLK:
{
CancelIntelliMouseSupport();
CPoint point;
::GetCursorPos(&point);
CWnd* pWnd=CWnd::WindowFromPoint(point);
ASSERT(pWnd);
UINT nHitTest=(int)pWnd->SendMessage(WM_NCHITTEST,0,
MAKELONG(point.x,point.y));
if(nHitTest==HTCLIENT)
{
switch(msg)
{
case WM_NCLBUTTONDOWN:
{
msg=WM_LBUTTONDOWN;
break;
}
case WM_NCRBUTTONDOWN:
{
msg=WM_RBUTTONDOWN;
break;
}
case WM_NCMBUTTONDOWN:
{
msg=WM_MBUTTONDOWN;
break;
}
case WM_NCLBUTTONDBLCLK:
{
msg=WM_LBUTTONDBLCLK;
break;
}
case WM_NCRBUTTONDBLCLK:
{
msg=WM_RBUTTONDBLCLK;
break;
}
case WM_NCMBUTTONDBLCLK:
{
msg=WM_MBUTTONDBLCLK;
break;
}
}
pWnd->ScreenToClient(&point);
}
else
{
switch(msg)
{
case WM_LBUTTONDOWN:
{
msg=WM_NCLBUTTONDOWN;
break;
}
case WM_RBUTTONDOWN:
{
msg=WM_NCRBUTTONDOWN;
break;
}
case WM_MBUTTONDOWN:
{
msg=WM_NCMBUTTONDOWN;
break;
}
case WM_LBUTTONDBLCLK:
{
msg=WM_NCLBUTTONDBLCLK;
break;
}
case WM_RBUTTONDBLCLK:
{
msg=WM_NCRBUTTONDBLCLK;
break;
}
case WM_MBUTTONDBLCLK:
{
msg=WM_NCMBUTTONDBLCLK;
break;
}
}
}
wp=nHitTest;
lp=MAKELONG(point.x,point.y);
if(pWnd->m_hWnd!=m_hWndHooked)
{
// pWnd->PostMessage(msg,wp,lp);
return (LRESULT)0;
}
else
break;
}
case WM_KEYDOWN:
case WM_SYSKEYDOWN:
{
CancelIntelliMouseSupport();
return TRUE;
}
}
}
// I don't handle it: pass along
return COXHookWnd::WindowProc(msg,wp,lp);
}
BOOL COXIntelliMouse::GetHookedScrollInfo()
{
ASSERT(m_hWndHooked!=NULL);
ASSERT(::IsWindow(m_hWndHooked));
CRect rect;
::GetClientRect(m_hWndHooked,rect);
::ZeroMemory((void*)&m_scrollHorzInfo,sizeof(m_scrollHorzInfo));
m_scrollHorzInfo.cbSize=sizeof(m_scrollHorzInfo);
m_scrollHorzInfo.fMask=SIF_ALL;
if(!GetHookedWnd()->GetScrollInfo(SB_HORZ,&m_scrollHorzInfo) ||
(m_scrollHorzInfo.nMax==0 || m_scrollHorzInfo.nPage==0 ||
m_scrollHorzInfo.nMax<(int)m_scrollHorzInfo.nPage))
{
m_dwScrollFlag&=~(SCRL_LEFT|SCRL_RIGHT);
}
else
{
if(m_scrollHorzInfo.nPos>0)
m_dwScrollFlag|=SCRL_LEFT;
else
m_dwScrollFlag&=~SCRL_LEFT;
if(m_scrollHorzInfo.nPos+(int)m_scrollHorzInfo.nPage<=m_scrollHorzInfo.nMax)
m_dwScrollFlag|=SCRL_RIGHT;
else
m_dwScrollFlag&=~SCRL_RIGHT;
}
::ZeroMemory((void*)&m_scrollVertInfo,sizeof(m_scrollVertInfo));
m_scrollVertInfo.cbSize=sizeof(m_scrollVertInfo);
m_scrollVertInfo.fMask=SIF_ALL;
if(!GetHookedWnd()->GetScrollInfo(SB_VERT,&m_scrollVertInfo) ||
m_scrollVertInfo.nMax==0 || m_scrollVertInfo.nPage==0 ||
m_scrollVertInfo.nMax<(int)m_scrollVertInfo.nPage)
{
m_dwScrollFlag&=~(SCRL_TOP|SCRL_BOTTOM);
}
else
{
if(m_scrollVertInfo.nPos>0)
m_dwScrollFlag|=SCRL_TOP;
else
m_dwScrollFlag&=~SCRL_TOP;
if(m_scrollVertInfo.nPos+(int)m_scrollVertInfo.nPage<=m_scrollVertInfo.nMax)
m_dwScrollFlag|=SCRL_BOTTOM;
else
m_dwScrollFlag&=~SCRL_BOTTOM;
}
if((m_dwScrollFlag&SCRL_LEFT)==0 && m_szScrollSize.cx<0)
m_szScrollSize.cx=0;
if((m_dwScrollFlag&SCRL_RIGHT)==0 && m_szScrollSize.cx>0)
m_szScrollSize.cx=0;
if((m_dwScrollFlag&SCRL_TOP)==0 && m_szScrollSize.cy<0)
m_szScrollSize.cy=0;
if((m_dwScrollFlag&SCRL_BOTTOM)==0 && m_szScrollSize.cy>0)
m_szScrollSize.cy=0;
return TRUE;
}
void COXIntelliMouse::CalculateScrollRects(const CSize& szSplashWindowBitmap,
const CPoint& ptStart,
SCROLLDIRECTION scrollDirection)
{
CRect rect(-1,-1,-1,-1);
m_arrScrollRect.SetAt(SCRL_NONE,rect);
m_arrScrollRect.SetAt(SCRL_LEFT,rect);
m_arrScrollRect.SetAt(SCRL_TOPLEFT,rect);
m_arrScrollRect.SetAt(SCRL_TOP,rect);
m_arrScrollRect.SetAt(SCRL_TOPRIGHT,rect);
m_arrScrollRect.SetAt(SCRL_RIGHT,rect);
m_arrScrollRect.SetAt(SCRL_BOTTOMRIGHT,rect);
m_arrScrollRect.SetAt(SCRL_BOTTOM,rect);
m_arrScrollRect.SetAt(SCRL_BOTTOMLEFT,rect);
m_arrScrollRect.SetAt(SCRL_ALL,rect);
m_arrScrollRect.SetAt(SCRL_LEFTRIGHT,rect);
m_arrScrollRect.SetAt(SCRL_TOPBOTTOM,rect);
// screen's dimension (big enough :-))
int nWidthScreen=::GetSystemMetrics(SM_CXSCREEN);
int nHeightScreen=::GetSystemMetrics(SM_CYSCREEN);
if((m_dwScrollFlag&SCRL_LEFT)!=0 || (m_dwScrollFlag&SCRL_RIGHT)!=0)
{
// rectangle for left scrolling area
rect.left=0;
rect.right=ptStart.x-szSplashWindowBitmap.cx/2;
if((m_dwScrollFlag&SCRL_TOP)!=0 || (m_dwScrollFlag&SCRL_BOTTOM)!=0)
{
rect.top=ptStart.y-szSplashWindowBitmap.cy/2;
rect.bottom=rect.top+szSplashWindowBitmap.cy;
}
else
{
rect.top=0;
rect.bottom=nHeightScreen;
}
m_arrScrollRect.SetAt(SCRL_LEFT,rect);
// rectangle for right scrolling area
rect.right=nWidthScreen;
rect.left=ptStart.x+szSplashWindowBitmap.cx/2+szSplashWindowBitmap.cx%2;
if((m_dwScrollFlag&SCRL_TOP)!=0 || (m_dwScrollFlag&SCRL_BOTTOM)!=0)
{
rect.top=ptStart.y-szSplashWindowBitmap.cy/2;
rect.bottom=rect.top+szSplashWindowBitmap.cy;
}
else
{
rect.top=0;
rect.bottom=nHeightScreen;
}
m_arrScrollRect.SetAt(SCRL_RIGHT,rect);
}
if((m_dwScrollFlag&SCRL_TOP)!=0 || (m_dwScrollFlag&SCRL_BOTTOM)!=0)
{
// rectangle for top scrolling area
rect.top=0;
rect.bottom=ptStart.y-szSplashWindowBitmap.cy/2;
if((m_dwScrollFlag&SCRL_LEFT)!=0 || (m_dwScrollFlag&SCRL_RIGHT)!=0)
{
rect.left=ptStart.x-szSplashWindowBitmap.cx/2;
rect.right=rect.left+szSplashWindowBitmap.cx;
}
else
{
rect.left=0;
rect.right=nWidthScreen;
}
m_arrScrollRect.SetAt(SCRL_TOP,rect);
// rectangle for bottom scrolling area
rect.bottom=nHeightScreen;
rect.top=ptStart.y+szSplashWindowBitmap.cy/2+szSplashWindowBitmap.cy%2;
if((m_dwScrollFlag&SCRL_LEFT)!=0 || (m_dwScrollFlag&SCRL_RIGHT)!=0)
{
rect.left=ptStart.x-szSplashWindowBitmap.cx/2;
rect.right=rect.left+szSplashWindowBitmap.cx;
}
else
{
rect.left=0;
rect.right=nWidthScreen;
}
m_arrScrollRect.SetAt(SCRL_BOTTOM,rect);
}
if(((m_dwScrollFlag&SCRL_TOP)!=0 || (m_dwScrollFlag&SCRL_BOTTOM)!=0) &&
((m_dwScrollFlag&SCRL_LEFT)!=0 || (m_dwScrollFlag&SCRL_RIGHT)!=0))
{
// rectangle for topleft scrolling area
rect.top=0;
rect.bottom=ptStart.y-szSplashWindowBitmap.cy/2;
rect.left=0;
rect.right=ptStart.x-szSplashWindowBitmap.cx/2;
m_arrScrollRect.SetAt(SCRL_TOPLEFT,rect);
// rectangle for topright scrolling area
rect.left=ptStart.x+szSplashWindowBitmap.cx/2+szSplashWindowBitmap.cx%2;
rect.right=nWidthScreen;
m_arrScrollRect.SetAt(SCRL_TOPRIGHT,rect);
// rectangle for bottomleft scrolling area
rect.top=ptStart.y+szSplashWindowBitmap.cy/2+szSplashWindowBitmap.cy%2;
rect.bottom=nHeightScreen;
rect.left=0;
rect.right=ptStart.x-szSplashWindowBitmap.cx/2;
m_arrScrollRect.SetAt(SCRL_BOTTOMLEFT,rect);
// rectangle for bottomright scrolling area
rect.left=ptStart.x+szSplashWindowBitmap.cx/2+szSplashWindowBitmap.cx%2;
rect.right=nWidthScreen;
m_arrScrollRect.SetAt(SCRL_BOTTOMRIGHT,rect);
// rectangle for non-scrolling area which equals to the size
// of splash window
rect.left=ptStart.x-szSplashWindowBitmap.cx/2;
rect.top=ptStart.y-szSplashWindowBitmap.cy/2;
rect.right=rect.left+szSplashWindowBitmap.cx;
rect.bottom=rect.top+szSplashWindowBitmap.cy;
m_arrScrollRect.SetAt(scrollDirection,rect);
}
else
{
// rectangle for non-scrolling
if((m_dwScrollFlag&SCRL_LEFT)!=0 || (m_dwScrollFlag&SCRL_RIGHT)!=0)
{
rect.left=ptStart.x-szSplashWindowBitmap.cx/2;
rect.top=0;
rect.right=rect.left+szSplashWindowBitmap.cx;
rect.bottom=nHeightScreen;
m_arrScrollRect.SetAt(scrollDirection,rect);
}
else if((m_dwScrollFlag&SCRL_TOP)!=0 || (m_dwScrollFlag&SCRL_BOTTOM)!=0)
{
rect.left=0;
rect.top=ptStart.y-szSplashWindowBitmap.cy/2;
rect.right=nWidthScreen;
rect.bottom=rect.top+szSplashWindowBitmap.cy;
m_arrScrollRect.SetAt(scrollDirection,rect);
}
else
ASSERT(FALSE);
}
}
void COXIntelliMouse::ShowScrollCursor(SCROLLDIRECTION scrollDirection) const
{
ASSERT(scrollDirection!=SCRL_NONE);
HANDLE hCursor=NULL;
VERIFY(m_arrScrollCursor.Lookup(scrollDirection,hCursor));
ASSERT(hCursor!=NULL);
::SetCursor((HCURSOR)hCursor);
}
SCROLLDIRECTION COXIntelliMouse::
FindScrollDirectionFromPoint(const CPoint& ptTest) const
{
CRect rect;
SCROLLDIRECTION scrollDirection=SCRL_NONE;
BOOL bSuccess=FALSE;
POSITION pos=m_arrScrollRect.GetStartPosition();
while(pos!=NULL)
{
m_arrScrollRect.GetNextAssoc(pos,scrollDirection,rect);
if(rect.PtInRect(ptTest))
{
bSuccess=TRUE;
break;
}
}
if(!bSuccess)
scrollDirection=SCRL_NONE;
return scrollDirection;
}
void COXIntelliMouse::CancelIntelliMouseSupport()
{
if(m_bIsHandling)
{
m_bIsHandling=FALSE;
// hide splash window
m_splashWnd.Hide();
// hide helper window
m_helperWnd.SetWindowPos(&CWnd::wndBottom,0,0,0,0,
SWP_HIDEWINDOW|SWP_NOREDRAW);
ASSERT(::IsWindow(m_pOldForegroundWnd->m_hWnd));
m_pOldForegroundWnd->SetForegroundWindow();
// release capture
::ReleaseCapture();
// kill scrolling timer
if(m_nScrollTimerID!=0)
{
::KillTimer(m_hWndHooked,m_nScrollTimerID);
}
}
// reset all internal variables
Reset();
}
BOOL COXIntelliMouse::LaunchIntelliMouseSupport()
{
if(GetHookedScrollInfo() && m_dwScrollFlag!=SCRL_NONE)
{
ASSERT(m_nScrollTimerID==0);
// setup timer
m_nScrollTimerID=::SetTimer(m_hWndHooked,
ID_INTELLIMOUSESCROLLTIMER,ID_INTELLIMOUSESCROLLDELAY,NULL);
if(m_nScrollTimerID!=0)
{
// start point
::GetCursorPos(&m_ptStart);
// get size of splash window bitmap
//
m_splashWnd.SetUserCancel(FALSE);
COXSplashWndDIB* pDIB=m_splashWnd.GetDIB();
ASSERT(pDIB!=NULL);
ASSERT(pDIB->GetBitmap()!=NULL);
BITMAP bm;
pDIB->GetBitmapInfo(bm);
// use helper window
//
m_pOldForegroundWnd=CWnd::GetForegroundWindow();
if(m_pOldForegroundWnd==NULL)
m_pOldForegroundWnd=CWnd::GetDesktopWindow();
m_helperWnd.SetWindowPos(&CWnd::wndTopMost,0,0,
::GetSystemMetrics(SM_CXSCREEN),
::GetSystemMetrics(SM_CYSCREEN),
SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOREDRAW);
// show splash window
//
CPoint ptDisplayAt(m_ptStart.x-bm.bmWidth/2,
m_ptStart.y-bm.bmHeight/2);
if(!m_splashWnd.Show(SPLASH_NOTIMER,NULL,&ptDisplayAt))
{
// kill scrolling timer
::KillTimer(m_hWndHooked,m_nScrollTimerID);
m_nScrollTimerID=0;
// hide helper window
m_helperWnd.SetWindowPos(&CWnd::wndBottom,0,0,0,0,
SWP_HIDEWINDOW|SWP_NOREDRAW);
ASSERT(::IsWindow(m_pOldForegroundWnd->m_hWnd));
m_pOldForegroundWnd->SetForegroundWindow();
}
else
{
// current scroll direction
if(((m_dwScrollFlag&SCRL_TOP)!=0 ||
(m_dwScrollFlag&SCRL_BOTTOM)!=0) &&
((m_dwScrollFlag&SCRL_LEFT)!=0 ||
(m_dwScrollFlag&SCRL_RIGHT)!=0))
m_scrollDirection=SCRL_ALL;
else if((m_dwScrollFlag&SCRL_TOP)!=0 ||
(m_dwScrollFlag&SCRL_BOTTOM)!=0)
m_scrollDirection=SCRL_TOPBOTTOM;
else if((m_dwScrollFlag&SCRL_LEFT)!=0 ||
(m_dwScrollFlag&SCRL_RIGHT)!=0)
m_scrollDirection=SCRL_LEFTRIGHT;
else
ASSERT(FALSE);
// calculate rectangles
//
CalculateScrollRects(CSize(bm.bmWidth,bm.bmHeight),m_ptStart,
m_scrollDirection);
// scroll sizes
m_szScrollSize=CSize(0,0);
// set mouse cursor
ShowScrollCursor(m_scrollDirection);
// capture all mouse messages
::SetCapture(m_hWndHooked);
// we are in the scrolling mode
m_bIsHandling=TRUE;
return TRUE;
}
}
}
return FALSE;
}
///////////////////////////////////////////////////////////
// static variables
CMap<DWORD,DWORD,COXIntelliMouseOrganizer*,COXIntelliMouseOrganizer*>
COXIntelliMouseOrganizer::m_arrThreadOrganizers;
HHOOK COXIntelliMouseOrganizer::m_pfnOriginalCBTHookProc=NULL;
HHOOK COXIntelliMouseOrganizer::m_pfnOriginalGetMessageHookProc=NULL;
/////////////////
// Constructor
COXIntelliMouseOrganizer::COXIntelliMouseOrganizer() :
m_pfnOldCBTHookProc(NULL),
m_dwThreadID(NULL),
m_pfnOldGetMessageHookProc(NULL),
m_nThreadOrigStartEventID(NULL),
m_dwThreadOrigKeyState(NULL)
{
}
// Destructor
COXIntelliMouseOrganizer::~COXIntelliMouseOrganizer()
{
if(IsAttachedAllInThread())
VERIFY(DetachAllInThread());
else
VERIFY(Detach(NULL));
int nCount=PtrToInt(m_arrUsedObjects.GetSize());
for(int nIndex=0; nIndex<nCount; nIndex++)
{
COXIntelliMouse* pIntelliMouseObject=m_arrUsedObjects[nIndex];
ASSERT(pIntelliMouseObject!=NULL);
ASSERT(!pIntelliMouseObject->IsHooked());
delete pIntelliMouseObject;
}
m_arrUsedObjects.RemoveAll();
ASSERT(m_pfnOriginalCBTHookProc==NULL);
ASSERT(m_pfnOldCBTHookProc==NULL);
ASSERT(m_pfnOriginalGetMessageHookProc==NULL);
}
COXIntelliMouse* COXIntelliMouseOrganizer::Attach(CWnd* pWnd,
UINT nStartEventID/*=WM_MBUTTONDOWN*/,
DWORD dwKeyState/*=0*/)
{
ASSERT(pWnd!=NULL);
ASSERT(::IsWindow(pWnd->m_hWnd));
HWND hWndAttached=pWnd->GetSafeHwnd();
ASSERT(::IsWindow(hWndAttached));
COXIntelliMouse* pIntelliMouseObject=NULL;
if(m_arrAttachedWnd.Lookup(hWndAttached,pIntelliMouseObject))
{
ASSERT(pIntelliMouseObject!=NULL);
ASSERT(pIntelliMouseObject->IsHooked());
ASSERT(pIntelliMouseObject->GetHookedWnd()->GetSafeHwnd()==hWndAttached);
TRACE(_T("COXIntelliMouseOrganizer::Attach: specified window already attached to an intelli mouse object\n"));
return pIntelliMouseObject;
}
if(IsRejected(hWndAttached))
{
return FALSE;
}
if(IsAttachedAllInThread())
{
CString sWndClass;
::GetClassName(pWnd->GetSafeHwnd(),sWndClass.GetBuffer(512),512);
if(!IsQualified(pWnd->GetSafeHwnd(),sWndClass))
{
m_mapRejectedControls.SetAt(pWnd->GetSafeHwnd(),1);
return NULL;
}
}
if(m_arrUsedObjects.GetSize()>0)
{
pIntelliMouseObject=m_arrUsedObjects[0];
ASSERT(pIntelliMouseObject!=NULL);
ASSERT(!pIntelliMouseObject->IsHooked());
m_arrUsedObjects.RemoveAt(0);
}
else
{
pIntelliMouseObject=new COXIntelliMouse;
}
if(pIntelliMouseObject->Attach(pWnd,nStartEventID,dwKeyState))
{
m_arrAttachedWnd.SetAt(hWndAttached,pIntelliMouseObject);
return pIntelliMouseObject;
}
else
{
// save the object in the array of COXIntelliMouse objects
// that can be used later
m_arrUsedObjects.Add(pIntelliMouseObject);
return NULL;
}
}
BOOL COXIntelliMouseOrganizer::Detach(CWnd* pWnd/*=NULL*/)
{
if(pWnd==NULL)
{
POSITION pos=m_arrAttachedWnd.GetStartPosition();
HWND hAttachedWnd=NULL;
COXIntelliMouse* pIntelliMouseObject=NULL;
while(pos!=NULL)
{
m_arrAttachedWnd.GetNextAssoc(pos,hAttachedWnd,pIntelliMouseObject);
if(pIntelliMouseObject!=NULL && pIntelliMouseObject->IsHooked() &&
pIntelliMouseObject->GetHookedWnd()->GetSafeHwnd()!=hAttachedWnd)
{
COXIntelliMouse* pTheSameIntelliMouseObject=NULL;
if(m_arrAttachedWnd.
Lookup(pIntelliMouseObject->GetHookedWnd()->GetSafeHwnd(),
pTheSameIntelliMouseObject))
{
ASSERT(pIntelliMouseObject==pTheSameIntelliMouseObject);
}
else
{
if(pIntelliMouseObject->IsHooked())
pIntelliMouseObject->Detach();
// save the object in the array of COXIntelliMouse objects
// that can be used later
m_arrUsedObjects.Add(pIntelliMouseObject);
}
}
else
{
ASSERT(pIntelliMouseObject!=NULL);
ASSERT(::IsWindow(hAttachedWnd) || pIntelliMouseObject==NULL ||
(pIntelliMouseObject!=NULL && !pIntelliMouseObject->IsHooked()));
if(pIntelliMouseObject!=NULL)
{
if(pIntelliMouseObject->IsHooked())
pIntelliMouseObject->Detach();
// save the object in the array of COXIntelliMouse objects
// that can be used later
m_arrUsedObjects.Add(pIntelliMouseObject);
}
}
}
m_arrAttachedWnd.RemoveAll();
}
else
{
COXIntelliMouse* pIntelliMouseObject=NULL;
CWnd* pAttachedWnd=(CWnd*)pWnd;
if(!m_arrAttachedWnd.Lookup(pAttachedWnd->GetSafeHwnd(),pIntelliMouseObject))
return FALSE;
ASSERT(pIntelliMouseObject!=NULL);
m_arrAttachedWnd.RemoveKey(pAttachedWnd->GetSafeHwnd());
if(pIntelliMouseObject!=NULL)
{
if(pIntelliMouseObject->IsHooked())
pIntelliMouseObject->Detach();
// save the object in the array of COXIntelliMouse objects
// that can be used later
m_arrUsedObjects.Add(pIntelliMouseObject);
}
}
return TRUE;
}
UINT COXIntelliMouseOrganizer::GetStartEventID(CWnd* pWnd) const
{
ASSERT(pWnd!=NULL);
ASSERT(IsAttached(pWnd));
return GetIntelliMouseObject(pWnd)->GetStartEventID();
}
UINT COXIntelliMouseOrganizer::GetKeyPressedState(CWnd* pWnd) const
{
ASSERT(pWnd!=NULL);
ASSERT(IsAttached(pWnd));
return GetIntelliMouseObject(pWnd)->GetKeyPressedState();
}
BOOL COXIntelliMouseOrganizer::SetStartEventID(CWnd* pWnd,
UINT nStartEventID,
DWORD dwKeyState/*=0*/)
{
if(pWnd==NULL)
{
if(IsAttachedAllInThread())
{
m_nThreadOrigStartEventID=nStartEventID;
m_dwThreadOrigKeyState=dwKeyState;
}
POSITION pos=m_arrAttachedWnd.GetStartPosition();
HWND hAttachedWnd=NULL;
COXIntelliMouse* pIntelliMouseObject=NULL;
while(pos!=NULL)
{
m_arrAttachedWnd.GetNextAssoc(pos,hAttachedWnd,pIntelliMouseObject);
ASSERT(::IsWindow(hAttachedWnd));
ASSERT(pIntelliMouseObject!=NULL);
pIntelliMouseObject->SetStartEventID(nStartEventID,dwKeyState);
}
}
else
{
COXIntelliMouse* pIntelliMouseObject=GetIntelliMouseObject(pWnd);
if(pIntelliMouseObject==NULL)
return FALSE;
pIntelliMouseObject->SetStartEventID(nStartEventID,dwKeyState);
}
return TRUE;
}
COXIntelliMouse* COXIntelliMouseOrganizer::
GetIntelliMouseObject(const CWnd* pWnd) const
{
ASSERT(pWnd!=NULL);
COXIntelliMouse* pIntelliMouseObject=NULL;
CWnd* pAttachedWnd=(CWnd*)pWnd;
if(!m_arrAttachedWnd.Lookup(pAttachedWnd->GetSafeHwnd(),pIntelliMouseObject))
{
pIntelliMouseObject=NULL;
}
else
{
ASSERT(pIntelliMouseObject->IsHooked());
ASSERT(pIntelliMouseObject->GetHookedWnd()==pAttachedWnd);
}
return pIntelliMouseObject;
}
BOOL COXIntelliMouseOrganizer::IsAttached(const CWnd* pWnd) const
{
ASSERT(pWnd!=NULL);
if(pWnd==NULL)
return FALSE;
COXIntelliMouse* pIntelliMouseObject=NULL;
CWnd* pAttachedWnd=(CWnd*)pWnd;
if(m_arrAttachedWnd.Lookup(pAttachedWnd->GetSafeHwnd(),pIntelliMouseObject))
{
ASSERT(pIntelliMouseObject!=NULL);
ASSERT(pIntelliMouseObject->IsHooked());
ASSERT(pIntelliMouseObject->GetHookedWnd()==pAttachedWnd);
if(pIntelliMouseObject!=NULL)
return TRUE;
}
return FALSE;
}
BOOL COXIntelliMouseOrganizer::IsRejected(HWND hWnd) const
{
DWORD dwReason=0;
BOOL bResult=m_mapRejectedControls.Lookup(hWnd,dwReason);
ASSERT(!bResult || dwReason!=0);
return bResult;
}
BOOL COXIntelliMouseOrganizer::
AttachAllInThread(DWORD dwThreadID/*=::GetCurrentThreadId()*/,
UINT nStartEventID/*=WM_MBUTTONDOWN*/,
DWORD dwKeyState/*=0*/)
{
if(IsAttachedAllInThread())
{
TRACE(_T("COXIntelliMouseOrganizer::AttachAllInThread: this object already attached to a thread\n"));
return FALSE;
}
COXIntelliMouseOrganizer* pOrganizer=NULL;
if(m_arrThreadOrganizers.Lookup(dwThreadID,pOrganizer))
{
ASSERT(pOrganizer!=NULL);
TRACE(_T("COXIntelliMouseOrganizer::AttachAllInThread: specified thread already attached to a COXIntelliMouseOrganizer object\n"));
return FALSE;
}
m_arrThreadOrganizers.SetAt(dwThreadID,this);
m_dwThreadID=dwThreadID;
m_nThreadOrigStartEventID=nStartEventID;
m_dwThreadOrigKeyState=dwKeyState;
// go through all windows and attach them
::EnumWindows(&EnumThreadWindows,(LPARAM)this);
// setup hooks for Computer Based Training
if(m_pfnOriginalCBTHookProc==NULL)
{
m_pfnOriginalCBTHookProc=
::SetWindowsHookEx(WH_CBT,IntelliMouseCBTHookProc,NULL,dwThreadID);
m_pfnOldCBTHookProc=m_pfnOriginalCBTHookProc;
}
else
{
m_pfnOldCBTHookProc=
::SetWindowsHookEx(WH_CBT,IntelliMouseCBTHookProc,NULL,dwThreadID);
}
// setup hooks for GetMessage
if(m_pfnOriginalGetMessageHookProc==NULL)
{
m_pfnOriginalGetMessageHookProc=::SetWindowsHookEx(WH_GETMESSAGE,
IntelliMouseGetMessageHookProc,NULL,dwThreadID);
m_pfnOldGetMessageHookProc=m_pfnOriginalGetMessageHookProc;
}
else
{
m_pfnOldGetMessageHookProc=::SetWindowsHookEx(WH_GETMESSAGE,
IntelliMouseGetMessageHookProc,NULL,dwThreadID);
}
SetStartEventID(NULL,nStartEventID,dwKeyState);
return TRUE;
}
void COXIntelliMouseOrganizer::AttachAllWindows(HWND hWndStartFrom)
{
ASSERT(hWndStartFrom!=NULL);
HWND hWnd=hWndStartFrom;
while(hWnd!=NULL)
{
DWORD dwThreadID=::GetWindowThreadProcessId(hWnd,NULL);
if(dwThreadID!=GetAttachedThread())
break;
CWnd* pWnd=CWnd::FromHandlePermanent(hWnd);
if(pWnd!=NULL && !IsAttached(pWnd) && !IsRejected(hWnd))
{
Attach(pWnd);
}
// loop through children
HWND hWndChild=::GetWindow(hWnd,GW_CHILD);
if(hWndChild!=NULL && !IsRejected(hWnd) && !IsAttached(pWnd))
AttachAllWindows(hWndChild);
// loop through windows
hWnd=::GetWindow(hWnd,GW_HWNDNEXT);
}
}
LRESULT CALLBACK COXIntelliMouseOrganizer::
IntelliMouseCBTHookProc(int nCode, WPARAM wParam, LPARAM lParam)
{
#if defined (_WINDLL)
#if defined (_AFXDLL)
AFX_MANAGE_STATE(AfxGetAppModuleState());
#else
AFX_MANAGE_STATE(AfxGetStaticModuleState());
#endif
#endif
if(nCode>=0 && ::IsWindow((HWND)wParam))
{
DWORD dwThreadID=::GetWindowThreadProcessId((HWND)wParam,NULL);
COXIntelliMouseOrganizer* pOrganizer=NULL;
if(COXIntelliMouseOrganizer::m_arrThreadOrganizers.
Lookup(dwThreadID,pOrganizer))
{
ASSERT(pOrganizer!=NULL);
ASSERT(pOrganizer->IsAttachedAllInThread());
if(nCode==HCBT_DESTROYWND)
{
// check if the window that is about to be destroyed
// had been added to intelli mouse organizer list
CWnd* pWnd=CWnd::FromHandle((HWND)wParam);
if(pWnd!=NULL && pOrganizer->IsAttached(pWnd))
VERIFY(pOrganizer->Detach(pWnd));
}
else
{
// check if new window is created and attach it.
CWnd* pWnd=CWnd::FromHandlePermanent((HWND)wParam);
if(pWnd!=NULL && !pOrganizer->IsAttached(pWnd))
{
POSITION pos=NULL;
COXIntelliMouse* pIntelliMouseObject=
pOrganizer->GetFirstIntelliMouseObject(pos);
if(pIntelliMouseObject!=NULL)
{
pOrganizer->
Attach(pWnd,pIntelliMouseObject->GetStartEventID(),
pIntelliMouseObject->GetKeyPressedState());
}
else
{
pOrganizer->
Attach(pWnd,pOrganizer->m_nThreadOrigStartEventID,
pOrganizer->m_dwThreadOrigKeyState);
}
}
}
return ::CallNextHookEx(pOrganizer->GetSavedCBTHookProc(),
nCode,wParam,lParam);
}
}
return ::CallNextHookEx(COXIntelliMouseOrganizer::GetOriginalCBTHookProc(),
nCode,wParam,lParam);
}
LRESULT CALLBACK COXIntelliMouseOrganizer::
IntelliMouseGetMessageHookProc(int nCode, WPARAM wParam, LPARAM lParam)
{
#if defined (_WINDLL)
#if defined (_AFXDLL)
AFX_MANAGE_STATE(AfxGetAppModuleState());
#else
AFX_MANAGE_STATE(AfxGetStaticModuleState());
#endif
#endif
if(nCode>=0 && ::IsWindow(((MSG*)lParam)->hwnd))
{
DWORD dwThreadID=::GetWindowThreadProcessId(((MSG*)lParam)->hwnd,NULL);
COXIntelliMouseOrganizer* pOrganizer=NULL;
if(COXIntelliMouseOrganizer::
m_arrThreadOrganizers.Lookup(dwThreadID,pOrganizer))
{
ASSERT(pOrganizer!=NULL);
ASSERT(pOrganizer->IsAttachedAllInThread());
// check if new window is created and attach it.
CWnd* pWnd=CWnd::FromHandlePermanent(((MSG*)lParam)->hwnd);
if(pWnd!=NULL && !pOrganizer->IsAttached(pWnd))
{
POSITION pos=NULL;
COXIntelliMouse* pIntelliMouseObject=
pOrganizer->GetFirstIntelliMouseObject(pos);
if(pIntelliMouseObject!=NULL)
{
pOrganizer->
Attach(pWnd,pIntelliMouseObject->GetStartEventID(),
pIntelliMouseObject->GetKeyPressedState());
}
else
{
pOrganizer->
Attach(pWnd,pOrganizer->m_nThreadOrigStartEventID,
pOrganizer->m_dwThreadOrigKeyState);
}
}
return ::CallNextHookEx(pOrganizer->GetSavedGetMessageHookProc(),
nCode,wParam,lParam);
}
}
return ::CallNextHookEx(COXIntelliMouseOrganizer::GetOriginalGetMessageHookProc(),
nCode,wParam,lParam);
}
BOOL CALLBACK COXIntelliMouseOrganizer::EnumThreadWindows(HWND hWnd, LPARAM lParam)
{
#if defined (_WINDLL)
#if defined (_AFXDLL)
AFX_MANAGE_STATE(AfxGetAppModuleState());
#else
AFX_MANAGE_STATE(AfxGetStaticModuleState());
#endif
#endif
ASSERT(lParam!=NULL);
ASSERT(::IsWindow(hWnd));
COXIntelliMouseOrganizer* pOrganizer=(COXIntelliMouseOrganizer*)lParam;
ASSERT(pOrganizer->IsAttachedAllInThread());
DWORD dwThreadID=::GetWindowThreadProcessId(hWnd,NULL);
if(dwThreadID==pOrganizer->GetAttachedThread())
{
pOrganizer->AttachAllWindows(hWnd);
return FALSE;
}
return TRUE;
}
BOOL COXIntelliMouseOrganizer::DetachAllInThread()
{
if(!IsAttachedAllInThread())
return FALSE;
ASSERT(m_dwThreadID!=NULL);
ASSERT(m_pfnOldCBTHookProc!=NULL);
ASSERT(m_pfnOriginalCBTHookProc!=NULL);
ASSERT(m_pfnOldGetMessageHookProc!=NULL);
ASSERT(m_pfnOriginalGetMessageHookProc!=NULL);
// unhook CBT
if(m_pfnOldCBTHookProc!=NULL)
{
VERIFY(::UnhookWindowsHookEx(m_pfnOldCBTHookProc));
m_pfnOldCBTHookProc=NULL;
m_pfnOriginalCBTHookProc=NULL;
}
// unhook GetMessage
if(m_pfnOldGetMessageHookProc!=NULL)
{
VERIFY(::UnhookWindowsHookEx(m_pfnOldGetMessageHookProc));
m_pfnOldGetMessageHookProc=NULL;
m_pfnOriginalGetMessageHookProc=NULL;
}
// clear map of rejected windows
m_mapRejectedControls.RemoveAll();
m_arrThreadOrganizers.RemoveKey(m_dwThreadID);
m_dwThreadID=NULL;
return Detach(NULL);
}
Reference in New Issue View Git Blame Copy Permalink