hotkeydlg.cpp

本文件包包含了大量用VC＋＋开发的应用程序界面

// HotKeyDlg.cpp : implementation file
//

#include "stdafx.h"
#include "Controls.h"
#include "HotKeyDlg.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CHotKeyDlg property page

//
//	A couple of macros will reduce our typing. And
//	help us not forget the flags are different.
//
#define ALL_KEYS	HKCOMB_A | HKCOMB_C | HKCOMB_CA | \
					HKCOMB_NONE | HKCOMB_S | HKCOMB_SA | \
					HKCOMB_SC | HKCOMB_SCA

#define	ALL_MODIFIERS	HOTKEYF_SHIFT | HOTKEYF_EXT | HOTKEYF_CONTROL | HOTKEYF_ALT

IMPLEMENT_DYNCREATE(CHotKeyDlg, CPropertyPage)

CHotKeyDlg::CHotKeyDlg() : CPropertyPage(CHotKeyDlg::IDD)
{
	//{{AFX_DATA_INIT(CHotKeyDlg)
	m_bAlt = FALSE;
	m_bCtrl = FALSE;
	m_bShift = FALSE;
	m_nType = 0;
	//}}AFX_DATA_INIT
	m_psp.dwFlags &= ~PSP_HASHELP;
	m_wVirtual = 0;
	m_wModifiers = 0;
}

CHotKeyDlg::~CHotKeyDlg()
{
}

void CHotKeyDlg::DoDataExchange(CDataExchange* pDX)
{
	CPropertyPage::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CHotKeyDlg)
	DDX_Control(pDX, IDC_HOTKEY_EDIT, m_ctlEdit);
	DDX_Control(pDX, IDC_HOTKEY_HOTKEY, m_HotKey);
	DDX_Check(pDX, IDC_HOTKEY_ALT, m_bAlt);
	DDX_Check(pDX, IDC_HOTKEY_CTRL, m_bCtrl);
	DDX_Check(pDX, IDC_HOTKEY_SHIFT, m_bShift);
	DDX_Radio(pDX, IDC_HOTKEY_ASCII, m_nType);
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CHotKeyDlg, CPropertyPage)
	//{{AFX_MSG_MAP(CHotKeyDlg)
	ON_BN_CLICKED(IDC_HOTKEY_GETHOTKEY, OnHotkeyGethotkey)
	ON_BN_CLICKED(IDC_HOTKEY_ALT, OnHotkeyAlt)
	ON_BN_CLICKED(IDC_HOTKEY_CTRL, OnHotkeyCtrl)
	ON_BN_CLICKED(IDC_HOTKEY_SHIFT, OnHotkeyShift)
	ON_BN_CLICKED(IDC_HOTKEY_ASCII, OnHotkeyType)
	ON_BN_CLICKED(IDC_HOTKEY_VIRTUAL, OnHotkeyType)
	ON_BN_CLICKED(IDC_HOTKEY_NEXTTYPED, OnHotkeyNexttyped)
	//}}AFX_MSG_MAP
	ON_MESSAGE(WM_HOTKEY, OnHotKey)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CHotKeyDlg message handlers

//
//	Flag specific to the RegisterHotKey() function.
//
//	MOD_ALT Either alt key must be held down. 
//	MOD_CONTROL Either ctrl key must be held down. 
//	MOD_SHIFT Either shift key must be held down. 
//	MOD_WIN Either WINDOWS key was held down. These keys are labeled with the Microsoft Windows logo. 
//
void CHotKeyDlg::OnHotkeyGethotkey() 
{
	WORD wVirtual, wModifiers;
	m_HotKey.GetHotKey (wVirtual, wModifiers);
	if (!(wVirtual | wModifiers))
		return;
	CWnd *button = GetDlgItem (IDC_HOTKEY_GETHOTKEY);
	if (!(m_wVirtual | m_wModifiers))
	{
		UINT nModifers = 0;
		if (wModifiers & HOTKEYF_ALT)
			nModifers |= MOD_ALT;
		if (wModifiers & HOTKEYF_CONTROL)
			nModifers |= MOD_CONTROL;
		if (wModifiers & HOTKEYF_SHIFT)
			nModifers |= MOD_SHIFT;
		BOOL bResult = RegisterHotKey (this->m_hWnd, 1, nModifers, wVirtual);
		button->SetWindowText (_T("Remove Hot Key"));
		m_wVirtual = wVirtual;
		m_wModifiers = wModifiers;
	}
	else
	{
		UnregisterHotKey (this->m_hWnd, 1);
		m_HotKey.SetHotKey (0, 0);
		button->SetWindowText (_T("Set Hot Key"));
		m_wVirtual = 0;
		m_wModifiers = 0;
	}
}

//
//	This is the message handler that does the work
//	when the system sends us the WM_HOTKEY message.
//
//	wParam contains the id.
//	lParam contains the key in the upper word,
//		the modifiers in the lower word.
//
void CHotKeyDlg::OnHotKey(WPARAM wParam, LPARAM lParam)
{
	if (m_ctlEdit.IsWindowVisible ())
		m_ctlEdit.ShowWindow (SW_HIDE);
	else
	{
		m_ctlEdit.ShowWindow (SW_SHOWNORMAL);
	}
	m_ctlEdit.SetFocus ();
}

void CHotKeyDlg::OnHotkeyAlt()
{
	UpdateData (TRUE);
	WORD wBanned, wDefault;
	GetKeyCombs (wBanned, wDefault);
	m_HotKey.SetRules (wBanned, wDefault);
	m_HotKey.SetFocus ();
}

void CHotKeyDlg::OnHotkeyCtrl()
{
	UpdateData (TRUE);
	WORD wBanned, wDefault;
	GetKeyCombs (wBanned, wDefault);
	m_HotKey.SetRules (wBanned, wDefault);
	m_HotKey.SetFocus ();
}

void CHotKeyDlg::OnHotkeyShift() 
{
	UpdateData (TRUE);
	WORD wBanned, wDefault;
	GetKeyCombs (wBanned, wDefault);
	m_HotKey.SetRules (wBanned, wDefault);
	m_HotKey.SetFocus ();
}

//
//	ASCII keys allow any combination. Virtual keys
//	may be used only with or without the Alt key.
//
void CHotKeyDlg::OnHotkeyType() 
{
	static BOOL bOldCtrl = FALSE;
	static BOOL bOldShift = FALSE;
	UpdateData (TRUE);
	WORD wBanned, wDefault;
	switch (m_nType)
	{
		case 0:		//	ASCII
			m_bCtrl = bOldCtrl;
			m_bShift = bOldShift;
			::EnableWindow (GetDlgItem (IDC_HOTKEY_CTRL)->m_hWnd, TRUE);
			::EnableWindow (GetDlgItem (IDC_HOTKEY_SHIFT)->m_hWnd, TRUE);
			UpdateData (FALSE);
			GetKeyCombs (wBanned, wDefault);
			break;
		case 1:		//	Virtual
			bOldCtrl = m_bCtrl;
			bOldShift = m_bShift;
			m_bCtrl = FALSE;
			m_bShift = FALSE;
			::EnableWindow (GetDlgItem (IDC_HOTKEY_CTRL)->m_hWnd, FALSE);
			::EnableWindow (GetDlgItem (IDC_HOTKEY_SHIFT)->m_hWnd, FALSE);
			UpdateData (FALSE);
			GetKeyCombs (wBanned, wDefault);
			break;
		default:
			return;
	}
	m_HotKey.SetRules (wBanned, wDefault);
	m_HotKey.SetFocus ();
}

void CHotKeyDlg::OnHotkeyNexttyped() 
{
//
//	No holds barred. Any combination is possible.
//	Ignore, but don't change, the check and radio
//	box settings.
//
	m_HotKey.SetRules (0, 0);
	m_HotKey.SetHotKey (0, 0);
	m_HotKey.SetFocus ();
}

void CHotKeyDlg::GetKeyCombs (WORD &wBanned, WORD &wDefault)
{
//
//	At first, all key combinations are banned and
//	no combinations are allowed.
//
	WORD wNoNo = ALL_KEYS;
	WORD wOkay = 0;
	if (m_bShift)
		wOkay |= HOTKEYF_SHIFT;
	if (m_bCtrl)
		wOkay |= HOTKEYF_CONTROL;
	if (m_bAlt)
		wOkay |= HOTKEYF_ALT;
	switch (wOkay)
	{
		case 0:				//	Any key allowed
			break;
		case HOTKEYF_SHIFT:	//	Shifted keys only
			wNoNo &= ~(HKCOMB_S);
			wNoNo |= (HKCOMB_SCA);
			wNoNo |= (HKCOMB_A);
			wNoNo |= (HKCOMB_C);
			wNoNo |= (HKCOMB_SC);
			wNoNo |= (HKCOMB_SA);
			wNoNo |= (HKCOMB_CA);
			break;
		case HOTKEYF_CONTROL:	//	Control keys only
			wNoNo &= ~(HKCOMB_C);
			wNoNo |= (HKCOMB_S);
			wNoNo |= (HKCOMB_A);
			wNoNo |= (HKCOMB_SCA);
			wNoNo |= (HKCOMB_SC);
			wNoNo |= (HKCOMB_SA);
			wNoNo |= (HKCOMB_CA);
			break;
		case HOTKEYF_ALT:		//	Alt keys only
			wNoNo &= ~(HKCOMB_A);
			wNoNo |= (HKCOMB_S);
			wNoNo |= (HKCOMB_SCA);
			wNoNo |= (HKCOMB_C);
			wNoNo |= (HKCOMB_SC);
			wNoNo |= (HKCOMB_SA);
			wNoNo |= (HKCOMB_CA);
			break;
								//	Shift + Ctrl combinations
		case HOTKEYF_SHIFT | HOTKEYF_CONTROL:
			wNoNo &= ~(HKCOMB_SC);
			wNoNo |= (HKCOMB_S);
			wNoNo |= (HKCOMB_A);
			wNoNo |= (HKCOMB_C);
			wNoNo |= (HKCOMB_SCA);
			wNoNo |= (HKCOMB_SA);
			wNoNo |= (HKCOMB_CA);
			break;
								//	Shift + Alt combinations
		case HOTKEYF_SHIFT | HOTKEYF_ALT:
			wNoNo &= ~(HKCOMB_SA);
			wNoNo |= (HKCOMB_S);
			wNoNo |= (HKCOMB_A);
			wNoNo |= (HKCOMB_C);
			wNoNo |= (HKCOMB_SC);
			wNoNo |= (HKCOMB_SCA);
			wNoNo |= (HKCOMB_CA);
			break;
								//	Alt + Ctrl combinations
		case HOTKEYF_CONTROL | HOTKEYF_ALT:
			wNoNo &= ~(HKCOMB_CA);
			wNoNo |= (HKCOMB_S);
			wNoNo |= (HKCOMB_S);
			wNoNo |= (HKCOMB_C);
			wNoNo |= (HKCOMB_SC);
			wNoNo |= (HKCOMB_SA);
			wNoNo |= (HKCOMB_SCA);
			break;
								//	Alt + Ctrl + Shift
		case HOTKEYF_SHIFT | HOTKEYF_CONTROL | HOTKEYF_ALT:
			wNoNo &= ~(HKCOMB_SCA);
			wNoNo |= (HKCOMB_S);
			wNoNo |= (HKCOMB_A);
			wNoNo |= (HKCOMB_C);
			wNoNo |= (HKCOMB_SC);
			wNoNo |= (HKCOMB_SA);
			wNoNo |= (HKCOMB_CA);
			break;
	}
	wBanned = wNoNo;
	wDefault = wOkay;
}