마우스 입력 사용
이 섹션에서는 마우스 입력과 관련된 작업을 다룹니다.
마우스 커서 추적
애플리케이션에서 마우스 커서의 위치를 추적하는 것과 관련된 작업을 수행하는 경우가 많습니다. 예를 들어 대부분의 그리기 애플리케이션은 그리기 작업 중에 마우스 커서의 위치를 추적하여 사용자가 마우스를 끌어 창의 클라이언트 영역에 그릴 수 있도록 합니다. 또한 워드 프로세싱 애플리케이션은 커서를 추적하여 사용자가 마우스를 클릭하고 끌어 단어 또는 텍스트 블록을 선택할 수 있도록 합니다.
커서 추적에는 일반적으로 WM_LBUTTONDOWN, WM_MOUSEMOVE 및 WM_LBUTTONUP 메시지 처리가 포함됩니다. 창에서는 WM_LBUTTONDOWN 메시지의 lParam 매개 변수에 제공된 커서 위치를 확인하여 커서 추적을 시작할 시기를 결정합니다. 예를 들어 워드 프로세싱 애플리케이션은 커서가 텍스트 줄에 있는 동안 WM_LBUTTONDOWN 메시지가 발생한 경우에만 커서 추적을 시작하지만 문서 끝을 지난 경우에는 추적하지 않습니다.
창에서는 마우스가 움직일 때 창에 게시된 WM_MOUSEMOVE 메시지 스트림을 처리하여 커서의 위치를 추적합니다. WM_MOUSEMOVE 메시지 처리에는 일반적으로 클라이언트 영역에서 반복적인 페인팅 또는 그리기 작업이 포함됩니다. 예를 들어 그리기 애플리케이션은 마우스가 움직일 때 선을 반복적으로 다시 그릴 수 있습니다. 창에서는 WM_LBUTTONUP 메시지를 신호로 사용하여 커서 추적을 중지합니다.
또한 애플리케이션은 TrackMouseEvent 함수를 호출하여 시스템에서 커서를 추적하는 데 유용한 다른 메시지를 보내도록 할 수 있습니다. 커서가 특정 기간 동안 클라이언트 영역 위를 가리키면 시스템에서 WM_MOUSEHOVER 메시지를 게시합니다. 커서가 클라이언트 영역을 벗어나면 WM_MOUSELEAVE 메시지를 게시합니다. WM_NCMOUSEHOVER 및 WM_NCMOUSELEAVE 메시지는 비클라이언트 영역에 해당하는 메시지입니다.
마우스를 사용하여 선 그리기
이 섹션의 예제에서는 마우스 커서를 추적하는 방법을 보여 줍니다. 여기에는 사용자가 마우스를 끌어 창의 클라이언트 영역에 선을 그릴 수 있는 창 프로시저의 일부가 포함되어 있습니다.
창 프로시저는 WM_LBUTTONDOWN 메시지를 받으면 마우스를 캡처하고 좌표를 줄의 시작점으로 사용하여 커서의 좌표를 저장합니다. 또한 ClipCursor 함수를 사용하여 선 그리기 작업 중에 커서를 클라이언트 영역으로 제한합니다.
첫 번째 WM_MOUSEMOVE 메시지 중에 창 프로시저는 시작점에서 커서의 현재 위치까지 선을 그립니다. 이후 WM_MOUSEMOVE 메시지 중에 창 프로시저는 반전된 펜 색상으로 그 위에 그려서 이전 줄을 지웁니다. 그런 다음, 시작점에서 커서의 새 위치로 새로운 선을 그립니다.
WM_LBUTTONUP 메시지는 그리기 작업의 끝을 신호로 보냅니다. 창 프로시저는 마우스 캡처를 해제하고 클라이언트 영역에서 마우스를 해제합니다.
LRESULT APIENTRY MainWndProc(HWND hwndMain, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
HDC hdc; // handle to device context
RECT rcClient; // client area rectangle
POINT ptClientUL; // client upper left corner
POINT ptClientLR; // client lower right corner
static POINTS ptsBegin; // beginning point
static POINTS ptsEnd; // new endpoint
static POINTS ptsPrevEnd; // previous endpoint
static BOOL fPrevLine = FALSE; // previous line flag
switch (uMsg)
{
case WM_LBUTTONDOWN:
// Capture mouse input.
SetCapture(hwndMain);
// Retrieve the screen coordinates of the client area,
// and convert them into client coordinates.
GetClientRect(hwndMain, &rcClient);
ptClientUL.x = rcClient.left;
ptClientUL.y = rcClient.top;
// Add one to the right and bottom sides, because the
// coordinates retrieved by GetClientRect do not
// include the far left and lowermost pixels.
ptClientLR.x = rcClient.right + 1;
ptClientLR.y = rcClient.bottom + 1;
ClientToScreen(hwndMain, &ptClientUL);
ClientToScreen(hwndMain, &ptClientLR);
// Copy the client coordinates of the client area
// to the rcClient structure. Confine the mouse cursor
// to the client area by passing the rcClient structure
// to the ClipCursor function.
SetRect(&rcClient, ptClientUL.x, ptClientUL.y,
ptClientLR.x, ptClientLR.y);
ClipCursor(&rcClient);
// Convert the cursor coordinates into a POINTS
// structure, which defines the beginning point of the
// line drawn during a WM_MOUSEMOVE message.
ptsBegin = MAKEPOINTS(lParam);
return 0;
case WM_MOUSEMOVE:
// When moving the mouse, the user must hold down
// the left mouse button to draw lines.
if (wParam & MK_LBUTTON)
{
// Retrieve a device context (DC) for the client area.
hdc = GetDC(hwndMain);
// The following function ensures that pixels of
// the previously drawn line are set to white and
// those of the new line are set to black.
SetROP2(hdc, R2_NOTXORPEN);
// If a line was drawn during an earlier WM_MOUSEMOVE
// message, draw over it. This erases the line by
// setting the color of its pixels to white.
if (fPrevLine)
{
MoveToEx(hdc, ptsBegin.x, ptsBegin.y,
(LPPOINT) NULL);
LineTo(hdc, ptsPrevEnd.x, ptsPrevEnd.y);
}
// Convert the current cursor coordinates to a
// POINTS structure, and then draw a new line.
ptsEnd = MAKEPOINTS(lParam);
MoveToEx(hdc, ptsBegin.x, ptsBegin.y, (LPPOINT) NULL);
LineTo(hdc, ptsEnd.x, ptsEnd.y);
// Set the previous line flag, save the ending
// point of the new line, and then release the DC.
fPrevLine = TRUE;
ptsPrevEnd = ptsEnd;
ReleaseDC(hwndMain, hdc);
}
break;
case WM_LBUTTONUP:
// The user has finished drawing the line. Reset the
// previous line flag, release the mouse cursor, and
// release the mouse capture.
fPrevLine = FALSE;
ClipCursor(NULL);
ReleaseCapture();
return 0;
case WM_DESTROY:
PostQuitMessage(0);
break;
// Process other messages.
}
}
두 번 클릭 메시지 처리
두 번 클릭 메시지를 받으려면 창이 CS_DBLCLKS 클래스 스타일을 포함하는 창 클래스에 속해야 합니다. 다음 예제와 같이 창 클래스를 등록할 때 이 스타일을 설정합니다.
BOOL InitApplication(HINSTANCE hInstance)
{
WNDCLASS wc;
wc.style = CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW;
wc.lpfnWndProc = (WNDPROC) MainWndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = hInstance;
wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
wc.hCursor = LoadCursor(NULL, IDC_IBEAM);
wc.hbrBackground = GetStockObject(WHITE_BRUSH);
wc.lpszMenuName = "MainMenu";
wc.lpszClassName = "MainWClass";
return RegisterClass(&wc);
}
두 번 클릭 메시지 앞에는 항상 단추 누름 메시지가 표시됩니다. 이러한 이유로 애플리케이션은 일반적으로 두 번 클릭 메시지를 사용하여 단추 누름 메시지 중에 시작된 작업을 확장합니다.
텍스트 줄 선택
이 섹션의 예제는 간단한 워드 프로세싱 애플리케이션에서 가져온 것입니다. 여기에는 사용자가 텍스트 줄의 아무 곳이나 클릭하여 캐럿의 위치를 설정하고 줄의 아무 곳이나 두 번 클릭하여 텍스트 줄을 선택(강조 표시)할 수 있는 코드가 포함되어 있습니다.
LRESULT APIENTRY MainWndProc(HWND hwndMain, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
HDC hdc; // handle to device context
TEXTMETRIC tm; // font size data
int i, j; // loop counters
int cCR = 0; // count of carriage returns
char ch; // character from input buffer
static int nBegLine; // beginning of selected line
static int nCurrentLine = 0; // currently selected line
static int nLastLine = 0; // last text line
static int nCaretPosX = 0; // x-coordinate of caret
static int cch = 0; // number of characters entered
static int nCharWidth = 0; // exact width of a character
static char szHilite[128]; // text string to highlight
static DWORD dwCharX; // average width of characters
static DWORD dwLineHeight; // line height
static POINTS ptsCursor; // coordinates of mouse cursor
static COLORREF crPrevText; // previous text color
static COLORREF crPrevBk; // previous background color
static PTCHAR pchInputBuf; // pointer to input buffer
static BOOL fTextSelected = FALSE; // text-selection flag
size_t * pcch;
HRESULT hResult;
switch (uMsg)
{
case WM_CREATE:
// Get the metrics of the current font.
hdc = GetDC(hwndMain);
GetTextMetrics(hdc, &tm);
ReleaseDC(hwndMain, hdc);
// Save the average character width and height.
dwCharX = tm.tmAveCharWidth;
dwLineHeight = tm.tmHeight;
// Allocate a buffer to store keyboard input.
pchInputBuf = (LPSTR) GlobalAlloc(GPTR,
BUFSIZE * sizeof(TCHAR));
return 0;
case WM_CHAR:
switch (wParam)
{
case 0x08: // backspace
case 0x0A: // linefeed
case 0x1B: // escape
MessageBeep( (UINT) -1);
return 0;
case 0x09: // tab
// Convert tabs to four consecutive spaces.
for (i = 0; i < 4; i++)
SendMessage(hwndMain, WM_CHAR, 0x20, 0);
return 0;
case 0x0D: // carriage return
// Record the carriage return, and position the
// caret at the beginning of the new line.
pchInputBuf[cch++] = 0x0D;
nCaretPosX = 0;
nCurrentLine += 1;
break;
default: / displayable character
ch = (char) wParam;
HideCaret(hwndMain);
// Retrieve the character's width, and display the
// character.
hdc = GetDC(hwndMain);
GetCharWidth32(hdc, (UINT) wParam, (UINT) wParam,
&nCharWidth);
TextOut(hdc, nCaretPosX,
nCurrentLine * dwLineHeight, &ch, 1);
ReleaseDC(hwndMain, hdc);
// Store the character in the buffer.
pchInputBuf[cch++] = ch;
// Calculate the new horizontal position of the
// caret. If the new position exceeds the maximum,
// insert a carriage return and reposition the
// caret at the beginning of the next line.
nCaretPosX += nCharWidth;
if ((DWORD) nCaretPosX > dwMaxCharX)
{
nCaretPosX = 0;
pchInputBuf[cch++] = 0x0D;
++nCurrentLine;
}
ShowCaret(hwndMain);
break;
}
SetCaretPos(nCaretPosX, nCurrentLine * dwLineHeight);
nLastLine = max(nLastLine, nCurrentLine);
break;
// Process other messages.
case WM_LBUTTONDOWN:
// If a line of text is currently highlighted, redraw
// the text to remove the highlighting.
if (fTextSelected)
{
hdc = GetDC(hwndMain);
SetTextColor(hdc, crPrevText);
SetBkColor(hdc, crPrevBk);
hResult = StringCchLength(szHilite, 128/sizeof(TCHAR), pcch);
if (FAILED(hResult))
{
// TODO: write error handler
}
TextOut(hdc, 0, nCurrentLine * dwLineHeight,
szHilite, *pcch);
ReleaseDC(hwndMain, hdc);
ShowCaret(hwndMain);
fTextSelected = FALSE;
}
// Save the current mouse-cursor coordinates.
ptsCursor = MAKEPOINTS(lParam);
// Determine which line the cursor is on, and save
// the line number. Do not allow line numbers greater
// than the number of the last line of text. The
// line number is later multiplied by the average height
// of the current font. The result is used to set the
// y-coordinate of the caret.
nCurrentLine = min((int)(ptsCursor.y / dwLineHeight),
nLastLine);
// Parse the text input buffer to find the first
// character in the selected line of text. Each
// line ends with a carriage return, so it is possible
// to count the carriage returns to find the selected
// line.
cCR = 0;
nBegLine = 0;
if (nCurrentLine != 0)
{
for (i = 0; (i < cch) &&
(cCR < nCurrentLine); i++)
{
if (pchInputBuf[i] == 0x0D)
++cCR;
}
nBegLine = i;
}
// Starting at the beginning of the selected line,
// measure the width of each character, summing the
// width with each character measured. Stop when the
// sum is greater than the x-coordinate of the cursor.
// The sum is used to set the x-coordinate of the caret.
hdc = GetDC(hwndMain);
nCaretPosX = 0;
for (i = nBegLine;
(pchInputBuf[i] != 0x0D) && (i < cch); i++)
{
ch = pchInputBuf[i];
GetCharWidth32(hdc, (int) ch, (int) ch, &nCharWidth);
if ((nCaretPosX + nCharWidth) > ptsCursor.x) break;
else nCaretPosX += nCharWidth;
}
ReleaseDC(hwndMain, hdc);
// Set the caret to the user-selected position.
SetCaretPos(nCaretPosX, nCurrentLine * dwLineHeight);
break;
case WM_LBUTTONDBLCLK:
// Copy the selected line of text to a buffer.
for (i = nBegLine, j = 0; (pchInputBuf[i] != 0x0D) &&
(i < cch); i++)
{
szHilite[j++] = pchInputBuf[i];
}
szHilite[j] = '\0';
// Hide the caret, invert the background and foreground
// colors, and then redraw the selected line.
HideCaret(hwndMain);
hdc = GetDC(hwndMain);
crPrevText = SetTextColor(hdc, RGB(255, 255, 255));
crPrevBk = SetBkColor(hdc, RGB(0, 0, 0));
hResult = StringCchLength(szHilite, 128/sizeof(TCHAR), pcch);
if (FAILED(hResult))
{
// TODO: write error handler
}
TextOut(hdc, 0, nCurrentLine * dwLineHeight, szHilite, *pcch);
SetTextColor(hdc, crPrevText);
SetBkColor(hdc, crPrevBk);
ReleaseDC(hwndMain, hdc);
fTextSelected = TRUE;
break;
// Process other messages.
default:
return DefWindowProc(hwndMain, uMsg, wParam, lParam);
}
return NULL;
}
포함된 개체가 있는 문서에서 마우스 휠 사용
이 예제에서는 다양한 포함된 개체가 있는 Microsoft Word 문서를 가정합니다.
- Microsoft Excel 스프레드시트
- 휠에 반응하여 스크롤되는 포함된 목록 상자 컨트롤
- 휠에 대한 응답으로 스크롤되는 포함된 목록 상자 컨트롤
MSH_MOUSEWHEEL 메시지는 항상 Microsoft Word의 주 창으로 전송됩니다. 포함된 스프레드시트가 활성 상태인 경우에도 그렇습니다. 다음 표에서는 포커스에 따라 MSH_MOUSEWHEEL 메시지가 처리되는 방식을 설명합니다.
| 포커스가 있는 경우 | 처리되는 방식 |
|---|---|
| Word.문서 | Word에서 문서 창을 스크롤합니다. |
| 포함된 Excel 스프레드시트 | Word에서 Excel에 메시지를 게시합니다. 포함된 애플리케이션이 메시지에 응답해야 하는지 여부를 결정해야 합니다. |
| 포함된 컨트롤 | 애플리케이션은 포커스가 있는 포함된 컨트롤에 메시지를 보내고 반환 코드를 확인하여 컨트롤이 처리했는지 확인해야 합니다. 컨트롤이 이를 처리하지 않은 경우 애플리케이션은 문서 창을 스크롤해야 합니다. 예를 들어 사용자가 목록 상자를 클릭한 다음, 휠을 움직이면 해당 컨트롤은 휠 회전에 반응하여 스크롤됩니다. 사용자가 텍스트 상자를 클릭한, 다음 휠을 회전하면 전체 문서가 스크롤됩니다. |
다음 예제에서는 애플리케이션이 두 개의 휠 메시지를 처리하는 방법을 보여 줍니다.
/************************************************
* this code deals with MSH_MOUSEWHEEL
*************************************************/
#include "zmouse.h"
//
// Mouse Wheel rotation stuff, only define if we are
// on a version of the OS that does not support
// WM_MOUSEWHEEL messages.
//
#ifndef WM_MOUSEWHEEL
#define WM_MOUSEWHEEL WM_MOUSELAST+1
// Message ID for IntelliMouse wheel
#endif
UINT uMSH_MOUSEWHEEL = 0; // Value returned from
// RegisterWindowMessage()
/**************************************************
INT WINAPI WinMain(
HINSTANCE hInst,
HINSTANCE hPrevInst,
LPSTR lpCmdLine,
INT nCmdShow)
{
MSG msg;
BOOL bRet;
if (!InitInstance(hInst, nCmdShow))
return FALSE;
//
// The new IntelliMouse uses a Registered message to transmit
// wheel rotation info. So register for it!
uMSH_MOUSEWHEEL =
RegisterWindowMessage(MSH_MOUSEWHEEL);
if ( !uMSH_MOUSEWHEEL )
{
MessageBox(NULL,"
RegisterWindowMessag Failed!",
"Error",MB_OK);
return msg.wParam;
}
while (( bRet = GetMessage(&msg, NULL, 0, 0)) != 0)
{
if (bRet == -1)
{
// handle the error and possibly exit
}
else
{
if (!TranslateAccelerator(ghwndApp,
ghaccelTable,
&msg))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
}
return msg.wParam;
}
/************************************************
* this code deals with WM_MOUSEWHEEL
*************************************************/
LONG APIENTRY MainWndProc(
HWND hwnd,
UINT msg,
WPARAM wParam,
LPARAM lParam)
{
static int nZoom = 0;
switch (msg)
{
//
// Handle Mouse Wheel messages generated
// by the operating systems that have built-in
// support for the WM_MOUSEWHEEL message.
//
case WM_MOUSEWHEEL:
((short) HIWORD(wParam)< 0) ? nZoom-- : nZoom++;
//
// Do other wheel stuff...
//
break;
default:
//
// uMSH_MOUSEWHEEL is a message registered by
// the mswheel dll on versions of Windows that
// do not support the new message in the OS.
if( msg == uMSH_MOUSEWHEEL )
{
((int)wParam < 0) ? nZoom-- : nZoom++;
//
// Do other wheel stuff...
//
break;
}
return DefWindowProc(hwnd,
msg,
wParam,
lParam);
}
return 0L;
}
마우스 휠 스크롤 줄 수 검색
다음 코드를 사용하면 애플리케이션이 SystemParametersInfo 함수를 사용하여 스크롤 줄 수를 검색할 수 있습니다.
#ifndef SPI_GETWHEELSCROLLLINES
#define SPI_GETWHEELSCROLLLINES 104
#endif
#include "zmouse.h"
/*********************************************************
* FUNCTION: GetNumScrollLines
* Purpose : An OS independent method to retrieve the
* number of wheel scroll lines
* Params : none
* Returns : UINT: Number of scroll lines where WHEEL_PAGESCROLL
* indicates to scroll a page at a time.
*********************************************************/
UINT GetNumScrollLines(void)
{
HWND hdlMsWheel;
UINT ucNumLines=3; // 3 is the default
OSVERSIONINFO osversion;
UINT uiMsh_MsgScrollLines;
memset(&osversion, 0, sizeof(osversion));
osversion.dwOSVersionInfoSize =sizeof(osversion);
GetVersionEx(&osversion);
if ((osversion.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) ||
( (osversion.dwPlatformId == VER_PLATFORM_WIN32_NT) &&
(osversion.dwMajorVersion < 4) ) )
{
hdlMsWheel = FindWindow(MSH_WHEELMODULE_CLASS,
MSH_WHEELMODULE_TITLE);
if (hdlMsWheel)
{
uiMsh_MsgScrollLines = RegisterWindowMessage
(MSH_SCROLL_LINES);
if (uiMsh_MsgScrollLines)
ucNumLines = (int)SendMessage(hdlMsWheel,
uiMsh_MsgScrollLines,
0,
0);
}
}
else if ( (osversion.dwPlatformId ==
VER_PLATFORM_WIN32_NT) &&
(osversion.dwMajorVersion >= 4) )
{
SystemParametersInfo(SPI_GETWHEELSCROLLLINES,
0,
&ucNumLines, 0);
}
return(ucNumLines);
}