Not
Åtkomst till den här sidan kräver auktorisering. Du kan prova att logga in eller ändra kataloger.
Åtkomst till den här sidan kräver auktorisering. Du kan prova att ändra kataloger.
Ett fönster tar emot tangentbordsindata i form av tangenttryckningsmeddelanden och teckenmeddelanden. Meddelandeloopen som är kopplad till fönstret måste innehålla kod för att översätta tangenttryckningsmeddelanden till motsvarande teckenmeddelanden. Om fönstret visar tangentbordsindata i klientområdet bör det skapa och visa en caret för att ange positionen där nästa tecken ska anges. I följande avsnitt beskrivs koden som används för att ta emot, bearbeta och visa tangentbordsindata:
- Att bearbeta tangenttryckningsmeddelanden
- översättning av teckenmeddelanden
- bearbeta teckenmeddelanden
- Använda Caret-
- visa tangentbordsindata
Bearbeta tangenttryckningsmeddelanden
Fönsterproceduren i fönstret som har tangentbordsfokus tar emot tangenttryckningsmeddelanden när användaren skriver på tangentbordet. Tangenttryckningsmeddelandena är WM_KEYDOWN, WM_KEYUP, WM_SYSKEYDOWNoch WM_SYSKEYUP. En typisk fönsterprocedur ignorerar alla tangenttryckningsmeddelanden förutom WM_KEYDOWN. Systemet publicerar WM_KEYDOWN meddelande när användaren trycker på en nyckel.
När fönsterproceduren tar emot WM_KEYDOWN-meddelandet bör den undersöka den virtuella nyckelkod som medföljer meddelandet för att avgöra hur tangenttryckningen ska bearbetas. Den virtuella nyckelkoden finns i meddelandets wParam parameter. Vanligtvis bearbetar ett program endast tangenttryckningar som genereras av icke-teckennycklar, inklusive funktionsnycklarna, markörflyttnycklarna och specialnycklarna som INS, DEL, HOME och END.
I följande exempel visas det ramverk för fönsterprocedurer som ett typiskt program använder för att ta emot och bearbeta tangenttryckningsmeddelanden.
case WM_KEYDOWN:
switch (wParam)
{
case VK_LEFT:
// Process the LEFT ARROW key.
break;
case VK_RIGHT:
// Process the RIGHT ARROW key.
break;
case VK_UP:
// Process the UP ARROW key.
break;
case VK_DOWN:
// Process the DOWN ARROW key.
break;
case VK_HOME:
// Process the HOME key.
break;
case VK_END:
// Process the END key.
break;
case VK_INSERT:
// Process the INS key.
break;
case VK_DELETE:
// Process the DEL key.
break;
case VK_F2:
// Process the F2 key.
break;
default:
// Process other non-character keystrokes.
break;
}
Översätta teckenmeddelanden
Alla trådar som tar emot teckenindata från användaren måste innehålla funktionen TranslateMessage i meddelandeloopen. Den här funktionen undersöker koden för en virtuell nyckel för ett tangenttryckningsmeddelande och placerar ett teckenmeddelande i meddelandekön om koden motsvarar ett tecken. Teckenmeddelandet tas bort och skickas vid nästa iteration av meddelandeloopen. parametern wParam i meddelandet innehåller teckenkoden.
I allmänhet bör en tråds meddelandeloop använda funktionen TranslateMessage för att översätta varje meddelande, inte bara virtuella nyckelmeddelanden. Även om TranslateMessage inte har någon effekt på andra typer av meddelanden, garanterar det att tangentbordsindata översätts korrekt. I följande exempel visas hur du inkluderar funktionen TranslateMessage i en vanlig trådmeddelandeslinga.
MSG msg;
BOOL bRet;
while ((bRet = GetMessage(&msg, (HWND) NULL, 0, 0)) != 0)
{
if (bRet == -1);
{
// handle the error and possibly exit
}
else
{
if (TranslateAccelerator(hwndMain, haccl, &msg) == 0)
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
}
Bearbeta teckenmeddelanden
En fönsterprocedur tar emot ett teckenmeddelande när funktionen TranslateMessage översätter en virtuell nyckelkod som motsvarar en teckennyckel. Teckenmeddelandena är WM_CHAR, WM_DEADCHAR, WM_SYSCHARoch WM_SYSDEADCHAR. En typisk fönsterprocedur ignorerar alla teckenmeddelanden förutom WM_CHAR. Funktionen TranslateMessage genererar ett WM_CHAR meddelande när användaren trycker på någon av följande nycklar:
- Valfri teckennyckel
- BACKSTEGSTANGENT
- RETUR (vagnretur)
- ESC
- SKIFT+RETUR (radmatning)
- FLIK
När en fönsterprocedur tar emot WM_CHAR meddelande bör den undersöka teckenkoden som medföljer meddelandet för att avgöra hur tecknet ska bearbetas. Teckenkoden finns i meddelandets wParam parameter.
I följande exempel visas det ramverk för fönsterprocedurer som ett typiskt program använder för att ta emot och bearbeta teckenmeddelanden.
case WM_CHAR:
switch (wParam)
{
case 0x08: // or '\b'
// Process a backspace.
break;
case 0x09: // or '\t'
// Process a tab.
break;
case 0x0A: // or '\n'
// Process a linefeed.
break;
case 0x0D:
// Process a carriage return.
break;
case 0x1B:
// Process an escape.
break;
default:
// Process displayable characters.
break;
}
Använda Caret
Ett fönster som tar emot tangentbordsindata visar vanligtvis tecknen som användaren skriver i fönstrets klientområde. Ett fönster bör använda en caret för att ange positionen i klientområdet där nästa tecken visas. Fönstret bör också skapa och visa markören när det tar emot tangentbordsfokus, och dölja och förstöra markören när det förlorar fokus. Ett fönster kan utföra dessa åtgärder i bearbetningen av WM_SETFOCUS och WM_KILLFOCUS meddelanden. Mer information om carets finns i Carets.
Visa tangentbordsindata
Exemplet i det här avsnittet visar hur ett program kan ta emot tecken från tangentbordet, visa dem i klientområdet i ett fönster och uppdatera positionen för caret med varje tecken skrivet. Den visar också hur du flyttar markören som svar på tangenttryckningarna VÄNSTERPIL, HÖGERPIL, HEM och SLUT och visar hur du markerar text som svar på tangentkombinationen SHIFT+HÖGERPIL.
Under bearbetningen av WM_CREATE meddelande allokerar fönsterproceduren som visas i exemplet en buffert på 64 000 för lagring av tangentbordsindata. Den hämtar också måtten för det teckensnitt som för närvarande är inläst, vilket sparar höjden och den genomsnittliga bredden på tecken i teckensnittet. Höjden och bredden används vid bearbetning av WM_SIZE meddelande för att beräkna radlängden och det maximala antalet rader, baserat på storleken på klientområdet.
Fönsterproceduren skapar och visar textmarkören när WM_SETFOCUS-meddelandet bearbetas. Den döljer och tar bort markören när WM_KILLFOCUS-meddelandet bearbetas.
När fönsterproceduren bearbetar WM_CHAR meddelandet, visas tecken, lagras i inmatningsbufferten och uppdaterar markörens position. Fönsterproceduren konverterar också tabbtecken till fyra mellanslag i följd. Backspace-, linefeed- och escape-tecken genererar ett pip, men bearbetas inte på annat sätt.
Fönsterproceduren utför rörelserna vänster, höger, slut och hem när WM_KEYDOWN-meddelandet bearbetas. När du bearbetar åtgärden för högerpiltangenten kontrollerar fönsterproceduren skifttangentens tillstånd och, om den är nedtryckt, väljer tecknet till höger om insättningspunkten i takt med att insättningspunkten flyttas.
Observera att följande kod skrivs så att den kan kompileras antingen som Unicode eller som ANSI. Om källkoden definierar UNICODE hanteras strängar som Unicode-tecken. annars hanteras de som ANSI-tecken.
#define BUFSIZE 65535
#define SHIFTED 0x8000
LONG APIENTRY MainWndProc(HWND hwndMain, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
HDC hdc; // handle to device context
TEXTMETRIC tm; // structure for text metrics
static DWORD dwCharX; // average width of characters
static DWORD dwCharY; // height of characters
static DWORD dwClientX; // width of client area
static DWORD dwClientY; // height of client area
static DWORD dwLineLen; // line length
static DWORD dwLines; // text lines in client area
static int nCaretPosX = 0; // horizontal position of caret
static int nCaretPosY = 0; // vertical position of caret
static int nCharWidth = 0; // width of a character
static int cch = 0; // characters in buffer
static int nCurChar = 0; // index of current character
static PTCHAR pchInputBuf; // input buffer
int i, j; // loop counters
int cCR = 0; // count of carriage returns
int nCRIndex = 0; // index of last carriage return
int nVirtKey; // virtual-key code
TCHAR szBuf[128]; // temporary buffer
TCHAR ch; // current character
PAINTSTRUCT ps; // required by BeginPaint
RECT rc; // output rectangle for DrawText
SIZE sz; // string dimensions
COLORREF crPrevText; // previous text color
COLORREF crPrevBk; // previous background color
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;
dwCharY = tm.tmHeight;
// Allocate a buffer to store keyboard input.
pchInputBuf = (LPTSTR) GlobalAlloc(GPTR,
BUFSIZE * sizeof(TCHAR));
return 0;
case WM_SIZE:
// Save the new width and height of the client area.
dwClientX = LOWORD(lParam);
dwClientY = HIWORD(lParam);
// Calculate the maximum width of a line and the
// maximum number of lines in the client area.
dwLineLen = dwClientX - dwCharX;
dwLines = dwClientY / dwCharY;
break;
case WM_SETFOCUS:
// Create, position, and display the caret when the
// window receives the keyboard focus.
CreateCaret(hwndMain, (HBITMAP) 1, 0, dwCharY);
SetCaretPos(nCaretPosX, nCaretPosY * dwCharY);
ShowCaret(hwndMain);
break;
case WM_KILLFOCUS:
// Hide and destroy the caret when the window loses the
// keyboard focus.
HideCaret(hwndMain);
DestroyCaret();
break;
case WM_CHAR:
// check if current location is close enough to the
// end of the buffer that a buffer overflow may
// occur. If so, add null and display contents.
if (cch > BUFSIZE-5)
{
pchInputBuf[cch] = 0x00;
SendMessage(hwndMain, WM_PAINT, 0, 0);
}
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;
nCaretPosY += 1;
break;
default: // displayable character
ch = (TCHAR) wParam;
HideCaret(hwndMain);
// Retrieve the character's width and output
// the character.
hdc = GetDC(hwndMain);
GetCharWidth32(hdc, (UINT) wParam, (UINT) wParam,
&nCharWidth);
TextOut(hdc, nCaretPosX, nCaretPosY * dwCharY,
&ch, 1);
ReleaseDC(hwndMain, hdc);
// Store the character in the buffer.
pchInputBuf[cch++] = ch;
// Calculate the new horizontal position of the
// caret. If the position exceeds the maximum,
// insert a carriage return and move the caret
// to the beginning of the next line.
nCaretPosX += nCharWidth;
if ((DWORD) nCaretPosX > dwLineLen)
{
nCaretPosX = 0;
pchInputBuf[cch++] = 0x0D;
++nCaretPosY;
}
nCurChar = cch;
ShowCaret(hwndMain);
break;
}
SetCaretPos(nCaretPosX, nCaretPosY * dwCharY);
break;
case WM_KEYDOWN:
switch (wParam)
{
case VK_LEFT: // LEFT ARROW
// The caret can move only to the beginning of
// the current line.
if (nCaretPosX > 0)
{
HideCaret(hwndMain);
// Retrieve the character to the left of
// the caret, calculate the character's
// width, then subtract the width from the
// current horizontal position of the caret
// to obtain the new position.
ch = pchInputBuf[--nCurChar];
hdc = GetDC(hwndMain);
GetCharWidth32(hdc, ch, ch, &nCharWidth);
ReleaseDC(hwndMain, hdc);
nCaretPosX = max(nCaretPosX - nCharWidth,
0);
ShowCaret(hwndMain);
}
break;
case VK_RIGHT: // RIGHT ARROW
// Caret moves to the right or, when a carriage
// return is encountered, to the beginning of
// the next line.
if (nCurChar < cch)
{
HideCaret(hwndMain);
// Retrieve the character to the right of
// the caret. If it's a carriage return,
// position the caret at the beginning of
// the next line.
ch = pchInputBuf[nCurChar];
if (ch == 0x0D)
{
nCaretPosX = 0;
nCaretPosY++;
}
// If the character isn't a carriage
// return, check to see whether the SHIFT
// key is down. If it is, invert the text
// colors and output the character.
else
{
hdc = GetDC(hwndMain);
nVirtKey = GetKeyState(VK_SHIFT);
if (nVirtKey & SHIFTED)
{
crPrevText = SetTextColor(hdc,
RGB(255, 255, 255));
crPrevBk = SetBkColor(hdc,
RGB(0,0,0));
TextOut(hdc, nCaretPosX,
nCaretPosY * dwCharY,
&ch, 1);
SetTextColor(hdc, crPrevText);
SetBkColor(hdc, crPrevBk);
}
// Get the width of the character and
// calculate the new horizontal
// position of the caret.
GetCharWidth32(hdc, ch, ch, &nCharWidth);
ReleaseDC(hwndMain, hdc);
nCaretPosX = nCaretPosX + nCharWidth;
}
nCurChar++;
ShowCaret(hwndMain);
break;
}
break;
case VK_UP: // UP ARROW
case VK_DOWN: // DOWN ARROW
MessageBeep((UINT) -1);
return 0;
case VK_HOME: // HOME
// Set the caret's position to the upper left
// corner of the client area.
nCaretPosX = nCaretPosY = 0;
nCurChar = 0;
break;
case VK_END: // END
// Move the caret to the end of the text.
for (i=0; i < cch; i++)
{
// Count the carriage returns and save the
// index of the last one.
if (pchInputBuf[i] == 0x0D)
{
cCR++;
nCRIndex = i + 1;
}
}
nCaretPosY = cCR;
// Copy all text between the last carriage
// return and the end of the keyboard input
// buffer to a temporary buffer.
for (i = nCRIndex, j = 0; i < cch; i++, j++)
szBuf[j] = pchInputBuf[i];
szBuf[j] = TEXT('\0');
// Retrieve the text extent and use it
// to set the horizontal position of the
// caret.
hdc = GetDC(hwndMain);
hResult = StringCchLength(szBuf, 128, pcch);
if (FAILED(hResult))
{
// TODO: write error handler
}
GetTextExtentPoint32(hdc, szBuf, *pcch,
&sz);
nCaretPosX = sz.cx;
ReleaseDC(hwndMain, hdc);
nCurChar = cch;
break;
default:
break;
}
SetCaretPos(nCaretPosX, nCaretPosY * dwCharY);
break;
case WM_PAINT:
if (cch == 0) // nothing in input buffer
break;
hdc = BeginPaint(hwndMain, &ps);
HideCaret(hwndMain);
// Set the clipping rectangle, and then draw the text
// into it.
SetRect(&rc, 0, 0, dwLineLen, dwClientY);
DrawText(hdc, pchInputBuf, -1, &rc, DT_LEFT);
ShowCaret(hwndMain);
EndPaint(hwndMain, &ps);
break;
// Process other messages.
case WM_DESTROY:
PostQuitMessage(0);
// Free the input buffer.
GlobalFree((HGLOBAL) pchInputBuf);
UnregisterHotKey(hwndMain, 0xAAAA);
break;
default:
return DefWindowProc(hwndMain, uMsg, wParam, lParam);
}
return NULL;
}