diff options
Diffstat (limited to 'meego/qt-translate.cpp')
| -rw-r--r-- | meego/qt-translate.cpp | 195 |
1 files changed, 195 insertions, 0 deletions
diff --git a/meego/qt-translate.cpp b/meego/qt-translate.cpp new file mode 100644 index 0000000..866610c --- /dev/null +++ b/meego/qt-translate.cpp @@ -0,0 +1,195 @@ +/* + * Copyright (C) 2010, Intel Corporation. + * + * Author: Raymond Liu <raymond.liu@intel.com> + * + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * version 2.1 as published by the Free Software Foundation. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA + */ + +#include "debug.h" + +#include <QEvent> +#include <QKeyEvent> + +#include "qt-keysym-map.h" + +#include "qt-translate.h" + +enum { + ShiftModifier = 1 << 0, + ControlModifier = 1 << 2, + AltModifier = 1 << 3 +}; +#define SHIFT_MASK 1 << 0) + +void meego_im_key_event_decode(MeegoImKeyEvent *e, int type, int key, int modifiers, char *text) +{ + g_warn_if_fail(type == QEvent::KeyPress || type == QEvent::KeyRelease); + e->release = type == QEvent::KeyRelease; + + e->state = 0; + if (modifiers & Qt::ShiftModifier) + e->state |= ShiftModifier; + if (modifiers & Qt::ControlModifier) + e->state |= ControlModifier; + if (modifiers & Qt::AltModifier) + e->state |= AltModifier; + + e->keysym = QtKeyToXKeySym(key); + + if (text && strlen(text) > 0) { + e->text = text; + } +} + +void meego_im_key_event_encode(const MeegoImKeyEvent *e, int *type, int *key, int *modifiers, char **text) +{ + *type = e->release ? QEvent::KeyRelease : QEvent::KeyPress; + *key = XKeySymToQTKey(e->keysym); + *modifiers = Qt::NoModifier; + if (e->state & ShiftModifier) + *modifiers |= Qt::ShiftModifier; + if (e->state & ControlModifier) + *modifiers |= Qt::ControlModifier; + if (e->state & AltModifier) + *modifiers |= Qt::AltModifier; + *text = e->text && strlen(e->text) > 0 ? e->text : NULL; +} + +#if 0 +GdkEventKey * +compose_gdk_keyevent(GdkEventType type, guint keyval, guint state, GdkWindow *window) +{ + GdkEventKey *event = NULL; +#if GTK_CHECK_VERSION (3, 0, 0) + GdkDisplay *display; + GdkDeviceManager *device_manager; + GdkDevice *client_pointer; +#endif + if ((type != GDK_KEY_PRESS) && (type != GDK_KEY_RELEASE)) + return NULL; + + event = (GdkEventKey *)(gdk_event_new(type)); + event->length = 0; + event->string = 0; + event->is_modifier = 0; + event->time = GDK_CURRENT_TIME; + event->state = state; + +#if GTK_CHECK_VERSION (3, 0, 0) + display = gdk_window_get_display (window); + device_manager = gdk_display_get_device_manager (display); + client_pointer = gdk_device_manager_get_client_pointer (device_manager); + + gdk_event_set_device ((GdkEvent *)event, + gdk_device_get_associated_device (client_pointer)); +#endif + + if (type == GDK_KEY_RELEASE) + event->state |= GDK_RELEASE_MASK; + event->keyval = keyval; + event->window = window; + + if (event->window) { + GdkKeymap *key_map = gdk_keymap_get_default(); + GdkKeymapKey *keys; + gint n; + + g_object_ref(event->window); // seems when event is freed, the event->window will be unref + + if (gdk_keymap_get_entries_for_keyval(key_map, event->keyval, &keys, &n)) { + event->hardware_keycode = keys[0].keycode; + event->group = keys[0].group; + } else { + event->hardware_keycode = 0; + event->group = 0; + } + } + + DBG("event type=0x%x, state=0x%x, keyval=0x%x, keycode=0x%x, group=%d", + event->type, event->state, event->keyval, event->hardware_keycode, event->group); + + return event; +} + + + +GdkEventKey * +qt_key_event_to_gdk(int type, int key, int modifiers, char *text, GdkWindow *window) +{ + Q_UNUSED(text); + guint state = 0; + guint keyval; + + STEP(); + if ((type != QEvent::KeyPress) && (type != QEvent::KeyRelease)) + return NULL; + + if (modifiers & Qt::ShiftModifier) + state |= GDK_SHIFT_MASK; + if (modifiers & Qt::ControlModifier) + state |= GDK_CONTROL_MASK; + if (modifiers & Qt::AltModifier) + state |= GDK_MOD1_MASK; + + keyval = QtKeyToXKeySym(key); + + if (type == QEvent::KeyPress) { + return compose_gdk_keyevent(GDK_KEY_PRESS, keyval, state, window); + } else { + return compose_gdk_keyevent(GDK_KEY_RELEASE, keyval, state, window); + } + +} + + +gboolean +gdk_key_event_to_qt(GdkEventKey *event, int *type, int *key, int *modifier) +{ + + switch (event->type) { + case GDK_KEY_PRESS: + *type = QEvent::KeyPress; + break; + case GDK_KEY_RELEASE: + *type = QEvent::KeyRelease; + break; + default: + return FALSE; + } + + *key = XKeySymToQTKey(event->keyval); + if (*key == Qt::Key_unknown) { + qWarning("Unkonwn key"); + return FALSE; + } + + *modifier = Qt::NoModifier; + if (event->state & GDK_SHIFT_MASK) + *modifier |= Qt::ShiftModifier; + if (event->state & GDK_CONTROL_MASK) + *modifier |= Qt::ControlModifier; + if (event->state & GDK_MOD1_MASK) + *modifier |= Qt::AltModifier; + if (event->state & GDK_META_MASK) + *modifier |= Qt::MetaModifier; + + DBG("qtkey type =%d, qtkey=0x%x, modifier=0x%x", *type, *key, *modifier); + + return TRUE; +} + +#endif |