void WzMainWindow::inputMethodEvent(QInputMethodEvent *event)
{
// Foward all "committed" characters. Should be more advanced than that, but better than nothing.
for (int i = 0; i < event->commitString().size(); ++i)
{
inputAddBuffer(' ', event->commitString()[i].unicode());
}
QWidget::inputMethodEvent(event);
}
/*!
* Handle text events (if we were to use SDL2)
*/
void inputhandleText(SDL_TextInputEvent *Tevent)
{
size_t *newtextsize = NULL;
int size = SDL_strlen(Tevent->text);
if (size)
{
if (utf8Buf)
{
// clean up memory from last use.
free(utf8Buf);
utf8Buf = NULL;
}
utf8Buf = UTF8toUTF32(Tevent->text, newtextsize);
debug(LOG_INPUT, "Keyboard: text input \"%s\"", Tevent->text);
inputAddBuffer(CurrentKey, *utf8Buf);
if (SDL_strlen(text) + SDL_strlen(Tevent->text) < sizeof(text))
{
SDL_strlcat(text, Tevent->text, sizeof(text));
}
debug(LOG_INPUT, "adding text inputed: %s, to string [%s]", Tevent->text, text);
}
}
void WzMainWindow::realHandleKeyEvent(QKeyEvent *event, bool pressed)
{
unsigned int lastKey;
bool isKeypad = event->modifiers() & Qt::KeypadModifier;
switch (event->text().size())
{
case 0:
debug(LOG_INPUT, "Key%s 0x%04X, isKeypad=%d", pressed ? "Down" : "Up ", event->key(), isKeypad);
case 1:
debug(LOG_INPUT, "Key%s 0x%04X, isKeypad=%d, 0x%04X", pressed ? "Down" : "Up ", event->key(), isKeypad, event->text().unicode()[0].unicode());
break;
case 2:
debug(LOG_INPUT, "Key%s 0x%04X, isKeypad=%d, 0x%04X, 0x%04X", pressed ? "Down" : "Up ", event->key(), isKeypad, event->text().unicode()[0].unicode(), event->text().unicode()[1].unicode());
break;
case 3:
debug(LOG_INPUT, "Key%s 0x%04X, isKeypad=%d, 0x%04X, 0x%04X, ...", pressed ? "Down" : "Up ", event->key(), isKeypad, event->text().unicode()[0].unicode(), event->text().unicode()[1].unicode());
break;
}
if (!isKeypad)
{
switch (event->key())
{
case Qt::Key_Shift : lastKey = setKey(KEY_LSHIFT, pressed); break;
case Qt::Key_Control : lastKey = setKey(KEY_LCTRL, pressed); break;
case Qt::Key_Alt : lastKey = setKey(KEY_LALT, pressed); break;
case Qt::Key_AltGr : lastKey = setKey(KEY_RALT, pressed); break;
case Qt::Key_Meta : lastKey = setKey(KEY_LMETA, pressed); break;
case Qt::Key_Escape : lastKey = setKey(KEY_ESC, pressed); break;
case Qt::Key_Backspace : lastKey = setKey(KEY_BACKSPACE, pressed); break;
case Qt::Key_QuoteLeft : lastKey = setKey(KEY_BACKQUOTE, pressed); break;
case Qt::Key_1 : lastKey = setKey(KEY_1, pressed); break;
case Qt::Key_2 : lastKey = setKey(KEY_2, pressed); break;
case Qt::Key_3 : lastKey = setKey(KEY_3, pressed); break;
case Qt::Key_4 : lastKey = setKey(KEY_4, pressed); break;
case Qt::Key_5 : lastKey = setKey(KEY_5, pressed); break;
case Qt::Key_6 : lastKey = setKey(KEY_6, pressed); break;
case Qt::Key_7 : lastKey = setKey(KEY_7, pressed); break;
case Qt::Key_8 : lastKey = setKey(KEY_8, pressed); break;
case Qt::Key_9 : lastKey = setKey(KEY_9, pressed); break;
case Qt::Key_0 : lastKey = setKey(KEY_0, pressed); break;
case Qt::Key_Minus : lastKey = setKey(KEY_MINUS, pressed); break;
case Qt::Key_Equal : lastKey = setKey(KEY_EQUALS, pressed); break;
case Qt::Key_Backtab:
case Qt::Key_Tab : lastKey = setKey(KEY_TAB, pressed); break;
case Qt::Key_Q : lastKey = setKey(KEY_Q, pressed); break;
case Qt::Key_W : lastKey = setKey(KEY_W, pressed); break;
case Qt::Key_E : lastKey = setKey(KEY_E, pressed); break;
case Qt::Key_R : lastKey = setKey(KEY_R, pressed); break;
case Qt::Key_T : lastKey = setKey(KEY_T, pressed); break;
case Qt::Key_Y : lastKey = setKey(KEY_Y, pressed); break;
case Qt::Key_U : lastKey = setKey(KEY_U, pressed); break;
case Qt::Key_I : lastKey = setKey(KEY_I, pressed); break;
case Qt::Key_O : lastKey = setKey(KEY_O, pressed); break;
case Qt::Key_P : lastKey = setKey(KEY_P, pressed); break;
case Qt::Key_BracketLeft : lastKey = setKey(KEY_LBRACE, pressed); break;
case Qt::Key_BracketRight : lastKey = setKey(KEY_RBRACE, pressed); break;
case Qt::Key_Enter : lastKey = setKey(KEY_RETURN, pressed); break;
case Qt::Key_Return : lastKey = setKey(KEY_RETURN, pressed); break;
case Qt::Key_A : lastKey = setKey(KEY_A, pressed); break;
case Qt::Key_S : lastKey = setKey(KEY_S, pressed); break;
case Qt::Key_D : lastKey = setKey(KEY_D, pressed); break;
case Qt::Key_F : lastKey = setKey(KEY_F, pressed); break;
case Qt::Key_G : lastKey = setKey(KEY_G, pressed); break;
case Qt::Key_H : lastKey = setKey(KEY_H, pressed); break;
case Qt::Key_J : lastKey = setKey(KEY_J, pressed); break;
case Qt::Key_K : lastKey = setKey(KEY_K, pressed); break;
case Qt::Key_L : lastKey = setKey(KEY_L, pressed); break;
case Qt::Key_Semicolon : lastKey = setKey(KEY_SEMICOLON, pressed); break;
case Qt::Key_QuoteDbl : lastKey = setKey(KEY_QUOTE, pressed); break; // ?
case Qt::Key_Apostrophe : lastKey = setKey(KEY_BACKQUOTE, pressed); break; // ?
case Qt::Key_Backslash : lastKey = setKey(KEY_BACKSLASH, pressed); break;
case Qt::Key_Z : lastKey = setKey(KEY_Z, pressed); break;
case Qt::Key_X : lastKey = setKey(KEY_X, pressed); break;
case Qt::Key_C : lastKey = setKey(KEY_C, pressed); break;
case Qt::Key_V : lastKey = setKey(KEY_V, pressed); break;
case Qt::Key_B : lastKey = setKey(KEY_B, pressed); break;
case Qt::Key_N : lastKey = setKey(KEY_N, pressed); break;
case Qt::Key_M : lastKey = setKey(KEY_M, pressed); break;
case Qt::Key_Comma : lastKey = setKey(KEY_COMMA, pressed); break;
case Qt::Key_Period : lastKey = setKey(KEY_FULLSTOP, pressed); break;
case Qt::Key_Slash : lastKey = setKey(KEY_FORWARDSLASH, pressed); break;
case Qt::Key_Space : lastKey = setKey(KEY_SPACE, pressed); break;
case Qt::Key_CapsLock : lastKey = setKey(KEY_CAPSLOCK, pressed); break;
case Qt::Key_F1 : lastKey = setKey(KEY_F1, pressed); break;
case Qt::Key_F2 : lastKey = setKey(KEY_F2, pressed); break;
case Qt::Key_F3 : lastKey = setKey(KEY_F3, pressed); break;
case Qt::Key_F4 : lastKey = setKey(KEY_F4, pressed); break;
case Qt::Key_F5 : lastKey = setKey(KEY_F5, pressed); break;
case Qt::Key_F6 : lastKey = setKey(KEY_F6, pressed); break;
case Qt::Key_F7 : lastKey = setKey(KEY_F7, pressed); break;
case Qt::Key_F8 : lastKey = setKey(KEY_F8, pressed); break;
case Qt::Key_F9 : lastKey = setKey(KEY_F9, pressed); break;
case Qt::Key_F10 : lastKey = setKey(KEY_F10, pressed); break;
case Qt::Key_NumLock : lastKey = setKey(KEY_NUMLOCK, pressed); break;
case Qt::Key_ScrollLock : lastKey = setKey(KEY_SCROLLLOCK, pressed); break;
case Qt::Key_F11 : lastKey = setKey(KEY_F11, pressed); break;
case Qt::Key_F12 : lastKey = setKey(KEY_F12, pressed); break;
case Qt::Key_Home : lastKey = setKey(KEY_HOME, pressed); break;
case Qt::Key_Up : lastKey = setKey(KEY_UPARROW, pressed); break;
case Qt::Key_PageUp : lastKey = setKey(KEY_PAGEUP, pressed); break;
case Qt::Key_Left : lastKey = setKey(KEY_LEFTARROW, pressed); break;
case Qt::Key_Right : lastKey = setKey(KEY_RIGHTARROW, pressed); break;
case Qt::Key_End : lastKey = setKey(KEY_END, pressed); break;
case Qt::Key_Down : lastKey = setKey(KEY_DOWNARROW, pressed); break;
case Qt::Key_PageDown : lastKey = setKey(KEY_PAGEDOWN, pressed); break;
case Qt::Key_Insert : lastKey = setKey(KEY_INSERT, pressed); break;
case Qt::Key_Delete : lastKey = setKey(KEY_DELETE, pressed); break;
default:
debug(LOG_WARNING, "Ignoring normal key %d.\n", event->key());
lastKey = 0;
event->ignore();
break;
}
}
else // Is keypad.
{
switch (event->key())
{
case Qt::Key_Asterisk : lastKey = setKey(KEY_KP_STAR, pressed); break;
case Qt::Key_0 : lastKey = setKey(KEY_KP_0, pressed); break;
case Qt::Key_1 : lastKey = setKey(KEY_KP_1, pressed); break;
case Qt::Key_2 : lastKey = setKey(KEY_KP_2, pressed); break;
case Qt::Key_3 : lastKey = setKey(KEY_KP_3, pressed); break;
case Qt::Key_4 : lastKey = setKey(KEY_KP_4, pressed); break;
case Qt::Key_5 : lastKey = setKey(KEY_KP_5, pressed); break;
case Qt::Key_6 : lastKey = setKey(KEY_KP_6, pressed); break;
case Qt::Key_7 : lastKey = setKey(KEY_KP_7, pressed); break;
case Qt::Key_8 : lastKey = setKey(KEY_KP_8, pressed); break;
case Qt::Key_9 : lastKey = setKey(KEY_KP_9, pressed); break;
#ifndef WZ_OS_MAC // Anything except mac
case Qt::Key_Home : lastKey = setKey(KEY_KP_7, pressed); break;
case Qt::Key_Up : lastKey = setKey(KEY_KP_8, pressed); break;
case Qt::Key_PageUp : lastKey = setKey(KEY_KP_9, pressed); break;
case Qt::Key_Left : lastKey = setKey(KEY_KP_4, pressed); break;
case Qt::Key_Clear : lastKey = setKey(KEY_KP_5, pressed); break;
case Qt::Key_Right : lastKey = setKey(KEY_KP_6, pressed); break;
case Qt::Key_End : lastKey = setKey(KEY_KP_1, pressed); break;
case Qt::Key_Down : lastKey = setKey(KEY_KP_2, pressed); break;
case Qt::Key_PageDown : lastKey = setKey(KEY_KP_3, pressed); break;
case Qt::Key_Insert : lastKey = setKey(KEY_KP_0, pressed); break;
#else // Mac-specific, arrow keys are numpad on the mac.
case Qt::Key_Home : lastKey = setKey(KEY_HOME, pressed); break;
case Qt::Key_Up : lastKey = setKey(KEY_UPARROW, pressed); break;
case Qt::Key_PageUp : lastKey = setKey(KEY_PAGEUP, pressed); break;
case Qt::Key_Left : lastKey = setKey(KEY_LEFTARROW, pressed); break;
case Qt::Key_Clear : lastKey = setKey(KEY_DELETE, pressed); break;
case Qt::Key_Right : lastKey = setKey(KEY_RIGHTARROW, pressed); break;
case Qt::Key_End : lastKey = setKey(KEY_END, pressed); break;
case Qt::Key_Down : lastKey = setKey(KEY_DOWNARROW, pressed); break;
case Qt::Key_PageDown : lastKey = setKey(KEY_PAGEDOWN, pressed); break;
case Qt::Key_Insert : lastKey = setKey(KEY_INSERT, pressed); break;
#endif
case Qt::Key_Delete : lastKey = setKey(KEY_KP_FULLSTOP, pressed); break;
case Qt::Key_Plus : lastKey = setKey(KEY_KP_PLUS, pressed); break;
case Qt::Key_Minus : lastKey = setKey(KEY_KP_MINUS, pressed); break;
case Qt::Key_Period : lastKey = setKey(KEY_KP_FULLSTOP, pressed); break;
case Qt::Key_Slash : lastKey = setKey(KEY_KP_BACKSLASH, pressed); break; // HACK Shouldn't there be a KEY_KP_SLASH? Most keypads only have a forwardslash key.
case Qt::Key_Enter : lastKey = setKey(KEY_KPENTER, pressed); break;
case Qt::Key_Return : lastKey = setKey(KEY_KPENTER, pressed); break;
default:
debug(LOG_WARNING, "Ignoring keypad key %d.\n", event->key());
lastKey = 0;
event->ignore();
break;
}
}
if (pressed)
{
inputAddBuffer(lastKey, event->text().unicode()->unicode());
}
event->accept();
}
/*!
* Handle keyboard events
*/
static void inputHandleKeyEvent(SDL_KeyboardEvent *keyEvent)
{
UDWORD code = 0, vk = 0;
switch (keyEvent->type)
{
case SDL_KEYDOWN:
switch (keyEvent->keysym.sym)
{
// our "editing" keys for text
case SDLK_LEFT:
vk = INPBUF_LEFT;
break;
case SDLK_RIGHT:
vk = INPBUF_RIGHT;
break;
case SDLK_UP:
vk = INPBUF_UP;
break;
case SDLK_DOWN:
vk = INPBUF_DOWN;
break;
case SDLK_HOME:
vk = INPBUF_HOME;
break;
case SDLK_END:
vk = INPBUF_END;
break;
case SDLK_INSERT:
vk = INPBUF_INS;
break;
case SDLK_DELETE:
vk = INPBUF_DEL;
break;
case SDLK_PAGEUP:
vk = INPBUF_PGUP;
break;
case SDLK_PAGEDOWN:
vk = INPBUF_PGDN;
break;
case KEY_BACKSPACE:
vk = INPBUF_BKSPACE;
break;
case KEY_TAB:
vk = INPBUF_TAB;
break;
case KEY_RETURN:
vk = INPBUF_CR;
break;
case KEY_ESC:
vk = INPBUF_ESC;
break;
default:
break;
}
// Keycodes without character representations are determined by their scancode bitwise OR-ed with 1<<30 (0x40000000).
CurrentKey = keyEvent->keysym.sym;
if (vk)
{
// Take care of 'editing' keys that were pressed
inputAddBuffer(vk, 0);
debug(LOG_INPUT, "Editing key: 0x%x, %d SDLkey=[%s] pressed", vk, vk, SDL_GetKeyName(CurrentKey));
}
else
{
// add everything else
inputAddBuffer(CurrentKey, 0);
}
debug(LOG_INPUT, "Key Code (pressed): 0x%x, %d, [%c] SDLkey=[%s]", CurrentKey, CurrentKey, (CurrentKey < 128) && (CurrentKey > 31) ? (char)CurrentKey : '?', SDL_GetKeyName(CurrentKey));
code = sdlKeyToKeyCode(CurrentKey);
if (code >= KEY_MAXSCAN)
{
break;
}
if (aKeyState[code].state == KEY_UP ||
aKeyState[code].state == KEY_RELEASED ||
aKeyState[code].state == KEY_PRESSRELEASE)
{
// whether double key press or not
aKeyState[code].state = KEY_PRESSED;
aKeyState[code].lastdown = 0;
}
break;
case SDL_KEYUP:
code = keyEvent->keysym.sym;
debug(LOG_INPUT, "Key Code (*Depressed*): 0x%x, %d, [%c] SDLkey=[%s]", code, code, (code < 128) && (code > 31) ? (char)code : '?', SDL_GetKeyName(code));
code = sdlKeyToKeyCode(keyEvent->keysym.sym);
if (code >= KEY_MAXSCAN)
{
break;
}
if (aKeyState[code].state == KEY_PRESSED)
{
aKeyState[code].state = KEY_PRESSRELEASE;
}
else if (aKeyState[code].state == KEY_DOWN)
{
aKeyState[code].state = KEY_RELEASED;
}
break;
default:
break;
}
}
/*!
* Handle keyboard events
*/
void inputHandleKeyEvent(SDL_KeyboardEvent * keyEvent)
{
UDWORD code, vk;
utf_32_char unicode = keyEvent->keysym.unicode;
switch (keyEvent->type)
{
case SDL_KEYDOWN:
switch (keyEvent->keysym.sym)
{
case SDLK_LEFT:
vk = INPBUF_LEFT;
break;
case SDLK_RIGHT:
vk = INPBUF_RIGHT;
break;
case SDLK_UP:
vk = INPBUF_UP;
break;
case SDLK_DOWN:
vk = INPBUF_DOWN;
break;
case SDLK_HOME:
vk = INPBUF_HOME;
break;
case SDLK_END:
vk = INPBUF_END;
break;
case SDLK_INSERT:
vk = INPBUF_INS;
break;
case SDLK_DELETE:
vk = INPBUF_DEL;
break;
case SDLK_PAGEUP:
vk = INPBUF_PGUP;
break;
case SDLK_PAGEDOWN:
vk = INPBUF_PGDN;
break;
default:
vk = keyEvent->keysym.sym;
break;
}
debug( LOG_INPUT, "Key Code (pressed): 0x%x, %d, [%c] SDLkey=[%s]", vk, vk, (vk < 128) && (vk > 31) ? (char) vk : '?' , SDL_GetKeyName(keyCodeToSDLKey((KEY_CODE)keyEvent->keysym.sym)));
if (unicode < 32)
{
unicode = 0;
}
inputAddBuffer(vk, unicode);
code = sdlKeyToKeyCode(keyEvent->keysym.sym);
if ( aKeyState[code].state == KEY_UP ||
aKeyState[code].state == KEY_RELEASED ||
aKeyState[code].state == KEY_PRESSRELEASE )
{
//whether double key press or not
aKeyState[code].state = KEY_PRESSED;
aKeyState[code].lastdown = 0;
}
break;
case SDL_KEYUP:
code = sdlKeyToKeyCode(keyEvent->keysym.sym);
if (aKeyState[code].state == KEY_PRESSED)
{
aKeyState[code].state = KEY_PRESSRELEASE;
}
else if (aKeyState[code].state == KEY_DOWN )
{
aKeyState[code].state = KEY_RELEASED;
}
break;
default:
break;
}
}
