// returns untranslated keycode, i.e. for EVT_CHAR, where characters are left in
// the form they were entered (lowercase, diacritics etc.)
static long GetUntraslatedKeyCode(DFBInputDeviceKeyIdentifier key_id,
DFBInputDeviceKeySymbol key_symbol)
{
switch ( DFB_KEY_TYPE(key_symbol) )
{
case DIKT_UNICODE:
#if wxUSE_UNICODE
return key_symbol;
#else
if ( key_symbol < 128 )
return key_symbol;
else
{
wchar_t chr = key_symbol;
wxCharBuffer buf(wxConvUI->cWC2MB(&chr, 1, NULL));
if ( buf )
return *buf; // may be 0 if failed
else
return 0;
}
#endif
default:
return GetTranslatedKeyCode(key_id);
}
}
/*
* Translates key and button events.
*/
static int
key_event( struct input_event *levt,
DFBInputEvent *devt )
{
if (levt->code >= BTN_MOUSE && levt->code <= BTN_STYLUS2) {
devt->type = levt->value ? DIET_BUTTONPRESS : DIET_BUTTONRELEASE;
/* don't set DIEF_BUTTONS, it will be set by the input core */
devt->button = DIBI_FIRST + levt->code - BTN_MOUSE;
}
else {
int key = translate_key( levt->code );
if (key == DIKI_UNKNOWN)
return 0;
devt->type = levt->value ? DIET_KEYPRESS : DIET_KEYRELEASE;
if (DFB_KEY_TYPE(key) == DIKT_IDENTIFIER) {
devt->key_id = key;
devt->flags |= DIEF_KEYID;
}
else {
devt->key_symbol = key;
devt->flags |= DIEF_KEYSYMBOL;
}
}
return 1;
}
static SDL_keysym *
DirectFB_TranslateKeyInputEvent(_THIS, int index, DFBInputEvent * evt,
SDL_keysym * keysym)
{
SDL_DFB_DEVICEDATA(_this);
if (evt->key_code >= 0 &&
evt->key_code < SDL_arraysize(linux_scancode_table))
keysym->scancode = linux_scancode_table[evt->key_code];
else
keysym->scancode = SDL_SCANCODE_UNKNOWN;
if (keysym->scancode == SDL_SCANCODE_UNKNOWN ||
devdata->keyboard[index].is_generic) {
if (evt->key_id - DIKI_UNKNOWN < SDL_arraysize(oskeymap))
keysym->scancode = oskeymap[evt->key_id - DIKI_UNKNOWN];
else
keysym->scancode = SDL_SCANCODE_UNKNOWN;
}
keysym->unicode =
(DFB_KEY_TYPE(evt->key_symbol) == DIKT_UNICODE) ? evt->key_symbol : 0;
if (keysym->unicode == 0 &&
(evt->key_symbol > 0 && evt->key_symbol < 255))
keysym->unicode = evt->key_symbol;
return keysym;
}
static SDL_keysym *DirectFB_TranslateKey (DFBInputEvent *ev, SDL_keysym *keysym)
{
keysym->scancode = ev->key_id;
keysym->mod = KMOD_NONE;
keysym->unicode = (DFB_KEY_TYPE (ev->key_symbol) == DIKT_UNICODE) ? ev->key_symbol : 0;
if (ev->key_symbol > 0 && ev->key_symbol < 128)
keysym->sym = ev->key_symbol;
else
keysym->sym = keymap[ev->key_id - DIKI_UNKNOWN];
return keysym;
}
void QDirectFbInput::handleKeyEvents(const DFBEvent &event)
{
QEvent::Type type = QDirectFbConvenience::eventType(event.window.type);
Qt::Key key = QDirectFbConvenience::keyMap()->value(event.window.key_symbol);
Qt::KeyboardModifiers modifiers = QDirectFbConvenience::keyboardModifiers(event.window.modifiers);
long timestamp = (event.window.timestamp.tv_sec*1000) + (event.window.timestamp.tv_usec/1000);
QChar character;
if (DFB_KEY_TYPE(event.window.key_symbol) == DIKT_UNICODE)
character = QChar(event.window.key_symbol);
QWidget *tlw = m_tlwMap.value(event.window.window_id);
QWindowSystemInterface::handleKeyEvent(tlw, timestamp, type, key, modifiers, character);
}
/*
* Translates key and button events.
*/
static bool
key_event( const struct input_event *levt,
DFBInputEvent *devt )
{
int code = levt->code;
/* map touchscreen and smartpad events to button mouse */
if (code == BTN_TOUCH || code == BTN_TOOL_FINGER)
code = BTN_MOUSE;
if ((code >= BTN_MOUSE && code < BTN_JOYSTICK) || code == BTN_TOUCH) {
/* ignore repeat events for buttons */
if (levt->value == 2)
return false;
devt->type = levt->value ? DIET_BUTTONPRESS : DIET_BUTTONRELEASE;
/* don't set DIEF_BUTTONS, it will be set by the input core */
devt->button = DIBI_FIRST + code - BTN_MOUSE;
}
else {
int key = translate_key( code );
if (key == DIKI_UNKNOWN)
return false;
devt->type = levt->value ? DIET_KEYPRESS : DIET_KEYRELEASE;
if (DFB_KEY_TYPE(key) == DIKT_IDENTIFIER) {
devt->key_id = key;
devt->flags |= DIEF_KEYID;
}
else {
devt->key_symbol = key;
devt->flags |= DIEF_KEYSYMBOL;
}
devt->flags |= DIEF_KEYCODE;
devt->key_code = code;
}
if (levt->value == 2)
devt->flags |= DIEF_REPEAT;
return true;
}
static void
show_key_event( DFBInputEvent *evt )
{
static DFBInputDeviceKeyIdentifier last_id = DIKI_UNKNOWN;
static int count = 0;
char buf[16];
struct DFBKeySymbolName *symbol_name;
struct DFBKeyIdentifierName *id_name;
if (DFB_KEY_TYPE( evt->key_symbol ) == DIKT_UNICODE) {
primary->SetFont( primary, font_large );
primary->SetColor( primary, 0x70, 0x80, 0xE0, 0xFF );
primary->DrawGlyph( primary, evt->key_symbol,
screen_width/2, screen_height/2,
DSTF_CENTER );
}
symbol_name = bsearch( &evt->key_symbol, keynames,
sizeof(keynames) / sizeof(keynames[0]) - 1,
sizeof(keynames[0]), compare_symbol );
primary->SetFont( primary, font_normal );
if (symbol_name) {
primary->SetColor( primary, 0xF0, 0xC0, 0x30, 0xFF );
primary->DrawString( primary, symbol_name->name, -1,
40, screen_height/3, DSTF_LEFT );
}
primary->SetColor( primary, 0x60, 0x60, 0x60, 0xFF );
snprintf (buf, sizeof(buf), "0x%X", evt->key_symbol);
primary->DrawString( primary, buf, -1,
screen_width - 40, screen_height/3,
DSTF_RIGHT );
primary->SetFont( primary, font_small );
primary->SetColor( primary, 0x80, 0x80, 0x80, 0xFF );
snprintf (buf, sizeof(buf), "%d", evt->key_code);
primary->DrawString( primary, buf, -1,
screen_width - 40, screen_height/4,
DSTF_RIGHT );
primary->SetFont( primary, font_normal );
id_name = bsearch( &evt->key_id, idnames,
sizeof(idnames) / sizeof(idnames[0]) - 1,
sizeof(idnames[0]), compare_id );
if (id_name) {
primary->SetColor( primary, 0x60, 0x60, 0x60, 0xFF );
primary->DrawString( primary, id_name->name, -1,
40, 2 * screen_height/3, DSTF_LEFT );
}
show_key_modifier_state( evt );
show_key_lock_state( evt );
if (evt->type == DIET_KEYPRESS) {
if (evt->key_id != DIKI_UNKNOWN && evt->key_id == last_id)
count++;
else
count = 0;
last_id = evt->key_id;
} else {
count = 0;
last_id = DIKI_UNKNOWN;
}
primary->SetColor( primary, 0x60, 0x60, 0x60, 0xFF );
if (count > 0) {
snprintf (buf, sizeof(buf), "%dx PRESS", count + 1);
primary->DrawString( primary, buf, -1,
screen_width - 40, 2 * screen_height/3,
DSTF_RIGHT );
}
else
primary->DrawString( primary, (evt->type == DIET_KEYPRESS) ?
"PRESS" : "RELEASE", -1,
screen_width - 40, 2 * screen_height/3,
DSTF_RIGHT );
if (evt->key_symbol == DIKS_ESCAPE || evt->key_symbol == DIKS_EXIT) {
primary->SetFont( primary, font_small );
primary->SetColor( primary, 0xF0, 0xC0, 0x30, 0xFF );
primary->DrawString( primary, "Press ESC/EXIT again to quit", -1,
screen_width/2, screen_height/6,
DSTF_CENTER );
}
}
static KeySym
DirectFBTranslateSymbol (DFBInputDeviceKeymapEntry *entry, int index)
{
DFBInputDeviceKeySymbol symbol = entry->symbols[diksi[index]];
DFBInputDeviceKeyIdentifier id = entry->identifier;
if (id >= DIKI_KP_DIV && id <= DIKI_KP_9) {
if (symbol >= DIKS_0 && symbol <= DIKS_9)
return XK_KP_0 + symbol - DIKS_0;
switch (symbol) {
case DIKS_HOME:
return XK_KP_Home;
case DIKS_CURSOR_LEFT:
return XK_KP_Left;
case DIKS_CURSOR_UP:
return XK_KP_Up;
case DIKS_CURSOR_RIGHT:
return XK_KP_Right;
case DIKS_CURSOR_DOWN:
return XK_KP_Down;
case DIKS_PAGE_UP:
return XK_KP_Page_Up;
case DIKS_PAGE_DOWN:
return XK_KP_Page_Down;
case DIKS_END:
return XK_KP_End;
case DIKS_BEGIN:
return XK_KP_Begin;
case DIKS_INSERT:
return XK_KP_Insert;
case DIKS_DELETE:
return XK_KP_Delete;
default:
;
}
switch (id) {
case DIKI_KP_DIV:
return XK_KP_Divide;
case DIKI_KP_MULT:
return XK_KP_Multiply;
case DIKI_KP_MINUS:
return XK_KP_Subtract;
case DIKI_KP_PLUS:
return XK_KP_Add;
case DIKI_KP_ENTER:
return XK_KP_Enter;
case DIKI_KP_SPACE:
return XK_KP_Space;
case DIKI_KP_TAB:
return XK_KP_Tab;
case DIKI_KP_F1:
return XK_KP_F1;
case DIKI_KP_F2:
return XK_KP_F2;
case DIKI_KP_F3:
return XK_KP_F3;
case DIKI_KP_F4:
return XK_KP_F4;
case DIKI_KP_EQUAL:
return XK_KP_Equal;
case DIKI_KP_DECIMAL:
return XK_KP_Decimal;
case DIKI_KP_SEPARATOR:
return XK_KP_Separator;
default:
;
}
}
if (symbol == DIKS_TAB && (index & 1))
return XK_ISO_Left_Tab;
if (symbol > 0 && symbol < 256)
return latin1_to_x[symbol];
if (DFB_KEY_TYPE (symbol) == DIKT_FUNCTION && symbol < DFB_FUNCTION_KEY(36))
return XK_F1 + symbol - DIKS_F1;
switch (id) {
case DIKI_SHIFT_L:
return XK_Shift_L;
case DIKI_SHIFT_R:
return XK_Shift_R;
case DIKI_CONTROL_L:
return XK_Control_L;
case DIKI_CONTROL_R:
return XK_Control_R;
default:
;
}
switch (symbol) {
case DIKS_CURSOR_LEFT:
return XK_Left;
case DIKS_CURSOR_RIGHT:
return XK_Right;
case DIKS_CURSOR_UP:
return XK_Up;
case DIKS_CURSOR_DOWN:
return XK_Down;
case DIKS_INSERT:
return XK_Insert;
case DIKS_HOME:
return XK_Home;
case DIKS_END:
return XK_End;
case DIKS_PAGE_UP:
return XK_Page_Up;
case DIKS_PAGE_DOWN:
return XK_Page_Down;
case DIKS_PRINT:
return XK_Print;
case DIKS_PAUSE:
return XK_Pause;
case DIKS_OK:
return XK_Return;
case DIKS_SELECT:
return XK_Select;
case DIKS_CLEAR:
return XK_Clear;
case DIKS_MENU:
return XK_Menu;
case DIKS_HELP:
return XK_Help;
case DIKS_ALT:
return XK_Alt_L;
case DIKS_ALTGR:
return XK_Mode_switch;
case DIKS_META:
return XK_Meta_L;
case DIKS_SUPER:
return XK_Super_L;
case DIKS_HYPER:
return XK_Hyper_L;
case DIKS_CAPS_LOCK:
return XK_Caps_Lock;
case DIKS_NUM_LOCK:
return XK_Num_Lock;
case DIKS_SCROLL_LOCK:
return XK_Scroll_Lock;
case DIKS_DEAD_GRAVE:
return XK_dead_grave;
case DIKS_DEAD_ACUTE:
return XK_dead_acute;
case DIKS_DEAD_CIRCUMFLEX:
return XK_dead_circumflex;
case DIKS_DEAD_TILDE:
return XK_dead_tilde;
case DIKS_DEAD_DIAERESIS:
return XK_dead_diaeresis;
case DIKS_DEAD_CEDILLA:
return XK_dead_cedilla;
default:
;
}
return 0;
}
