onscreenkeyboarddlg.cpp

制作屏幕软键盘

				((rc.left + rc.right)/2) - (tsize.cx/2), 
				((rc.top + rc.bottom)/2) - (tsize.cy/2), 
				label);
		}
	}
	else
	{
		if((key->cShifted >= 'A') && (key->cShifted <= 'Z'))
		{
			CSize tsize;
			tsize = dc->GetTextExtent(key->cShifted);
			dc->TextOut(
				((rc.left + rc.right)/2) - (tsize.cx/2), 
				((rc.top + rc.bottom)/2) - (tsize.cy/2), 
				key->cShifted);
		}
		else
		{
			CSize tsize;
			tsize = dc->GetTextExtent('M');
			dc->TextOut(rc.left, rc.top, key->cShifted);
			dc->TextOut(
				rc.right - tsize.cx, 
				rc.bottom - tsize.cy,
				key->cNormal);
		}
	}
}


// If you add a minimize button to your dialog, you will need the code below
//  to draw the icon.  For MFC applications using the document/view model,
//  this is automatically done for you by the framework.

void COnscreenKeyboardDlg::OnPaint() 
{
	if (IsIconic())
	{
		CPaintDC dc(this); // device context for painting

		SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);

		// Center icon in client rectangle
		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;

		// Draw the icon
		dc.DrawIcon(x, y, m_hIcon);
	}
	else
	{
		CDialog::OnPaint();
		DrawKeyboard();
	}
}

// The system calls this to obtain the cursor to display while the user drags
//  the minimized window.
HCURSOR COnscreenKeyboardDlg::OnQueryDragIcon()
{
	return (HCURSOR) m_hIcon;
}


void COnscreenKeyboardDlg::SendKey(KEYDEF * keydef)
{
	if(keydef->cNormal == 0x00)
	{
		int vk;
		BOOL uptoo = TRUE;
		if(keydef->cShifted > 0x6F) //is a function key
		{
			vk = keydef->cShifted;
		}
		else
		{
			switch(keydef->cShifted)
			{
			case TAB:    // 0x02
				vk = VkKeyScan(0x09) & 0xFF;
				break;
			case CAPSLOCK:    // 0x03
				vk = VK_CAPITAL;
				break;
			case SHIFT:    // 0x04
				vk = VK_SHIFT;
				if(GetKeyState(vk) & 0xF000) return;
				uptoo = FALSE;
				break;
			case CTRL:    // 0x05
				vk = VK_CONTROL;
				if(GetKeyState(vk) & 0xF000) return;
				uptoo = FALSE;
				break;
			case BSPACE:    // 0x06
				vk = VK_BACK;
				break;
			case ENTER:    // 0x07
				vk = VkKeyScan(0x0D) & 0xFF;
				break;
			case ALT:    // 0x08
				vk = VK_MENU;
				break;
			case WINDOW:    // 0x9
				vk = VK_LWIN;
				break;
			case LEFT:    // 0x0A
				vk = VK_LEFT;
				break;
			case RIGHT:    // 0x0B
				vk = VK_RIGHT;
				break;
			case UP:    // 0x0C
				vk = VK_UP;
				break;
			case DOWN:    // 0x0D
				vk = VK_DOWN;
				break;
			case PUP: //0x0F
				vk = VK_PRIOR;
				break;
			case PDN: //0x10
				vk = VK_NEXT;
				break;
			case HOME: //0x11
				vk = VK_HOME;
				break;
			case END: //0x12
				vk = VK_END;
				break;
			case INS: //0x13
				vk = VK_INSERT;
				break;
			case DEL: //0x14
				vk = VK_DELETE;
				break;
			case WWW:
				KEYDEF key;
				key.cNormal = key.cShifted = 'H';
				SendKey(&key);
				key.cNormal = key.cShifted = 'T';
				SendKey(&key);
				SendKey(&key);
				key.cNormal = key.cShifted = 'P';
				SendKey(&key);
				key.cNormal = key.cShifted = ':';
				SendKey(&key);
				key.cNormal = key.cShifted = '/';
				SendKey(&key);
				SendKey(&key);
				key.cNormal = key.cShifted = 'W';
				SendKey(&key);
				SendKey(&key);
				SendKey(&key);
				vk = VkKeyScan('.') & 0xFF;
				break;
			default:
				ASSERT(FALSE);
				break;
			}
		}
		keybd_event(vk,0,0,0);
		if(uptoo)
		{
			keybd_event(vk,0,KEYEVENTF_KEYUP,0);
		}
	}
	else
	{
		char pChar = keydef->cNormal;
		SHORT ks = VkKeyScan(pChar);
		BYTE key = ks & 0xFF;

		keybd_event(key,0,0,0);
		keybd_event(key,0,KEYEVENTF_KEYUP,0);

		//turn off the control and shift if they were down
		unsigned char vk = VK_SHIFT;
		if(GetKeyState(vk) & 0xF000)
		{
			keybd_event(vk,0,KEYEVENTF_KEYUP,0);
		}
		vk = VK_CONTROL;
		if(GetKeyState(vk) & 0xF000) //allow toggle
		{
			keybd_event(vk,0,KEYEVENTF_KEYUP,0);
		}
	}
}

void COnscreenKeyboardDlg::OnLButtonDown(UINT nFlags, CPoint point) 
{
	ReleaseFocus();

	CRect client;
	GetClientRect(client);
	int x = 0;
	int y = -pKeyHeight;
	KEYDEF * key;
	POSITION pos = cKeys.GetHeadPosition();
	while(pos)
	{
		key = cKeys.GetNext(pos);
		if((key->cNormal == 0x00) && (key->cShifted == 0x00))
		{
			x = 0;
			y += pKeyHeight;
		}
		else
		{
			int width = ((abs(key->cWidth) * pKeyWidth) / 10);
			CRect rc(x,y,x + width, y + pKeyHeight);
			if(key->cWidth < 0)
			{
				rc.right = client.right;
			}
			x += width;
			if(rc.PtInRect(point))
			{
				SendKey(key);
			}
		}
	}
}

void COnscreenKeyboardDlg::OnLButtonDblClk(UINT nFlags, CPoint point) 
{
	OnLButtonDown(nFlags, point);
}

BOOL COnscreenKeyboardDlg::PreTranslateMessage(MSG* pMsg) 
{
	HWND wnd = ::GetForegroundWindow();
	if(IsWindow(wnd))
	{
		if(wnd != this->m_hWnd)
		{
			if(gFocus != wnd)
			{
				if(IsWindow(gFocus))
				{
					AttachThreadInput(
						GetWindowThreadProcessId(m_hWnd,NULL),
						GetWindowThreadProcessId(gFocus,NULL),
						FALSE);
				}

				gFocus = wnd;
				AttachThreadInput(
					GetWindowThreadProcessId(m_hWnd,NULL),
					GetWindowThreadProcessId(gFocus,NULL),
					TRUE);
			}
		}
	}
	return CDialog::PreTranslateMessage(pMsg);
}

void COnscreenKeyboardDlg::OnRButtonDblClk(UINT nFlags, CPoint point) 
{
	OnLButtonDown(nFlags, point);
}

void COnscreenKeyboardDlg::OnRButtonDown(UINT nFlags, CPoint point) 
{
	OnLButtonDown(nFlags, point);
}

void COnscreenKeyboardDlg::OnRButtonUp(UINT nFlags, CPoint point) 
{
	ReleaseFocus();
}

BOOL COnscreenKeyboardDlg::OnMouseWheel(UINT nFlags, short zDelta, CPoint pt) 
{
	ReleaseFocus();
	return TRUE;
}

void COnscreenKeyboardDlg::OnLButtonUp(UINT nFlags, CPoint point) 
{
	ReleaseFocus();
}

void COnscreenKeyboardDlg::ReleaseFocus() 
{
	if(IsWindow(gFocus))
	{
		HWND wnd = ::GetForegroundWindow();
		if(IsWindow(wnd))
		{
			if(wnd == gFocus)
			{
				return;
			}
		}
		::SetForegroundWindow(gFocus);
		::SetFocus(gFocus);
	}
}

void COnscreenKeyboardDlg::OnSize(UINT nType, int cx, int cy) 
{
	CDialog::OnSize(nType, cx, cy);
	if(IsWindow(m_hWnd))
	{
		if(cKeys.GetCount())
		{
			CalcWidthHeight();
			Invalidate();
		}
	}
}

void COnscreenKeyboardDlg::OnOK() 
{
	ShowWindow(SW_HIDE);
}

void COnscreenKeyboardDlg::OnCancel() 
{
	ShowWindow(SW_HIDE);
}

void COnscreenKeyboardDlg::OnShowKeyboard() 
{
	ShowWindow(SW_SHOW);
}

void COnscreenKeyboardDlg::OnUpdateShowKeyboard(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(!IsWindowVisible());
}

void COnscreenKeyboardDlg::OnHideKeyboard() 
{
	ShowWindow(SW_HIDE);
}

void COnscreenKeyboardDlg::OnUpdateHideKeyboard(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(IsWindowVisible());
}

void COnscreenKeyboardDlg::OnExit() 
{
	POSITION pos = cKeys.GetHeadPosition();
	while(pos)
	{
		delete cKeys.GetNext(pos);
	}

	int state = DescribeKeyState();
	if(state & 0x01) keybd_event(VK_CAPITAL,0,KEYEVENTF_KEYUP,0);
	if(state & 0x02) keybd_event(VK_SHIFT,0,KEYEVENTF_KEYUP,0);
	if(state & 0x04) keybd_event(VK_CONTROL,0,KEYEVENTF_KEYUP,0);

	CDialog::OnOK();
}

void COnscreenKeyboardDlg::OnShowWindow(BOOL bShow, UINT nStatus) 
{
	CDialog::OnShowWindow(bShow, nStatus);
	if(bShow)
	{
		cSystray.SetMenuDefaultItem(IDM_HIDE_KEYBOARD, FALSE);
	}
	else
	{
		cSystray.SetMenuDefaultItem(IDM_SHOW_KEYBOARD, FALSE);
	}
}

int COnscreenKeyboardDlg::DescribeKeyState() 
{
	int state = 0;
	short ks;
	ks = GetKeyState(VK_CAPITAL);
	if(ks & 0x000F) state += 0x01;
	ks = GetKeyState(VK_SHIFT);
	if(ks & 0xF000) state += 0x02;
	ks = GetKeyState(VK_CONTROL);
	if(ks & 0xF000) state += 0x04;
	return state;
}

void COnscreenKeyboardDlg::DrawKeyboard()
{
	CClientDC dc(this);
	CRect client;
	GetClientRect(client);
	CRgn clipRgn;
	clipRgn.CreateRectRgnIndirect(&client);
	dc.SelectClipRgn(&clipRgn);
	dc.SelectObject(GetStockObject(DEFAULT_GUI_FONT));
	dc.SetBkMode(TRANSPARENT);
	int x = 0;
	int y = -pKeyHeight;
	KEYDEF * key;
	POSITION pos = cKeys.GetHeadPosition();
	cCurrentKeyState = DescribeKeyState();
	int state = cCurrentKeyState;
	while(pos)
	{
		key = cKeys.GetNext(pos);
		if((key->cNormal == 0x00) && (key->cShifted == 0x00))
		{
			x = 0;
			y += pKeyHeight;
		}
		else
		{
			int width = ((abs(key->cWidth) * pKeyWidth) / 10);
			CRect rc(x,y,x + width, y + pKeyHeight);
			x += width;
			if(key->cWidth < 0)
			{
				rc.right = client.right; 
			}
			BOOL hilight = FALSE;
			if(key->cNormal == 0x00)
			{
				switch(key->cShifted)
				{
				case CAPSLOCK:
					if(state & 0x01)
					{
						hilight = TRUE;
					}
					break;
				case SHIFT:
					if(state & 0x02)
					{
						hilight = TRUE;
					}
					break;
				case CTRL:
					if(state & 0x04)
					{
						hilight = TRUE;
					}
					break;
				default:
					break;
				}
			}
			DrawKey(&dc, rc, key, hilight);
		}
	}
}

long x = 0;
void COnscreenKeyboardDlg::OnTimer(UINT nIDEvent) 
{
	if(nIDEvent == TIMER_ID)
	{
		int state = DescribeKeyState();
		if(state != cCurrentKeyState)
		{
			DrawKeyboard();
		}
	}
}