gint
KeymapWrapper::GetFirstLatinGroup()
{
GdkKeymapKey *keys;
gint count;
gint minGroup = -1;
if (gdk_keymap_get_entries_for_keyval(mGdkKeymap, GDK_a, &keys, &count)) {
// find the minimum number group for latin inputtable layout
for (gint i = 0; i < count && minGroup != 0; ++i) {
if (keys[i].level != 0 && keys[i].level != 1) {
continue;
}
if (minGroup >= 0 && keys[i].group > minGroup) {
continue;
}
minGroup = keys[i].group;
}
g_free(keys);
}
return minGroup;
}
void EventSenderProxy::keyDown(WKStringRef keyRef, WKEventModifiers wkModifiers, unsigned location)
{
guint modifiers = webkitModifiersToGDKModifiers(wkModifiers);
int gdkKeySym = getGDKKeySymForKeyRef(keyRef, location, &modifiers);
GdkEvent* pressEvent = gdk_event_new(GDK_KEY_PRESS);
pressEvent->key.keyval = gdkKeySym;
pressEvent->key.state = modifiers;
pressEvent->key.window = gtk_widget_get_window(GTK_WIDGET(m_testController->mainWebView()->platformWindow()));
g_object_ref(pressEvent->key.window);
gdk_event_set_device(pressEvent, gdk_device_manager_get_client_pointer(gdk_display_get_device_manager(gdk_window_get_display(pressEvent->key.window))));
GOwnPtr<GdkKeymapKey> keys;
gint nKeys;
if (gdk_keymap_get_entries_for_keyval(gdk_keymap_get_default(), gdkKeySym, &keys.outPtr(), &nKeys))
pressEvent->key.hardware_keycode = keys.get()[0].keycode;
GdkEvent* releaseEvent = gdk_event_copy(pressEvent);
dispatchEvent(pressEvent);
releaseEvent->key.type = GDK_KEY_RELEASE;
dispatchEvent(releaseEvent);
}
/* Return true if keyval is defined in keyboard group
*/
static gboolean
keyval_in_group (GdkKeymap *keymap,
guint keyval,
gint group)
{
GtkKeyHashEntry entry;
gint i;
gdk_keymap_get_entries_for_keyval (keymap,
keyval,
&entry.keys, &entry.n_keys);
for (i = 0; i < entry.n_keys; i++)
{
if (entry.keys[i].group == group)
{
g_free (entry.keys);
return TRUE;
}
}
g_free (entry.keys);
return FALSE;
}
static VALUE
rg_get_entries_for_keyval(VALUE self, VALUE keyval)
{
GdkKeymapKey* keys;
gint n_keys;
gboolean ret;
ret = gdk_keymap_get_entries_for_keyval(_SELF(self),
NUM2UINT(keyval), &keys, &n_keys);
if (ret){
VALUE key;
VALUE ary = rb_ary_new();
gint i;
for (i = 0; i < n_keys; i++){
key = rb_ary_new3(3, UINT2NUM(keys[i].keycode), INT2NUM(keys[i].group),
INT2NUM(keys[i].level));
rb_ary_push(ary, key);
}
g_free(keys);
return ary;
} else {
return Qnil;
}
}
static JSValueRef keyDownCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
{
if (argumentCount < 1)
return JSValueMakeUndefined(context);
static const JSStringRef lengthProperty = JSStringCreateWithUTF8CString("length");
webkit_web_frame_layout(mainFrame);
// handle modifier keys.
int state = 0;
if (argumentCount > 1) {
JSObjectRef modifiersArray = JSValueToObject(context, arguments[1], exception);
if (modifiersArray) {
for (int i = 0; i < JSValueToNumber(context, JSObjectGetProperty(context, modifiersArray, lengthProperty, 0), 0); ++i) {
JSValueRef value = JSObjectGetPropertyAtIndex(context, modifiersArray, i, 0);
JSStringRef string = JSValueToStringCopy(context, value, 0);
if (JSStringIsEqualToUTF8CString(string, "ctrlKey"))
state |= GDK_CONTROL_MASK;
else if (JSStringIsEqualToUTF8CString(string, "shiftKey"))
state |= GDK_SHIFT_MASK;
else if (JSStringIsEqualToUTF8CString(string, "altKey"))
state |= GDK_MOD1_MASK;
JSStringRelease(string);
}
}
}
// handle location argument.
int location = DOM_KEY_LOCATION_STANDARD;
if (argumentCount > 2)
location = (int)JSValueToNumber(context, arguments[2], exception);
JSStringRef character = JSValueToStringCopy(context, arguments[0], exception);
g_return_val_if_fail((!exception || !*exception), JSValueMakeUndefined(context));
int gdkKeySym = GDK_VoidSymbol;
if (location == DOM_KEY_LOCATION_NUMPAD) {
if (JSStringIsEqualToUTF8CString(character, "leftArrow"))
gdkKeySym = GDK_KP_Left;
else if (JSStringIsEqualToUTF8CString(character, "rightArrow"))
gdkKeySym = GDK_KP_Right;
else if (JSStringIsEqualToUTF8CString(character, "upArrow"))
gdkKeySym = GDK_KP_Up;
else if (JSStringIsEqualToUTF8CString(character, "downArrow"))
gdkKeySym = GDK_KP_Down;
else if (JSStringIsEqualToUTF8CString(character, "pageUp"))
gdkKeySym = GDK_KP_Page_Up;
else if (JSStringIsEqualToUTF8CString(character, "pageDown"))
gdkKeySym = GDK_KP_Page_Down;
else if (JSStringIsEqualToUTF8CString(character, "home"))
gdkKeySym = GDK_KP_Home;
else if (JSStringIsEqualToUTF8CString(character, "end"))
gdkKeySym = GDK_KP_End;
else
// Assume we only get arrow/pgUp/pgDn/home/end keys with
// location=NUMPAD for now.
g_assert_not_reached();
} else {
if (JSStringIsEqualToUTF8CString(character, "leftArrow"))
gdkKeySym = GDK_Left;
else if (JSStringIsEqualToUTF8CString(character, "rightArrow"))
gdkKeySym = GDK_Right;
else if (JSStringIsEqualToUTF8CString(character, "upArrow"))
gdkKeySym = GDK_Up;
else if (JSStringIsEqualToUTF8CString(character, "downArrow"))
gdkKeySym = GDK_Down;
else if (JSStringIsEqualToUTF8CString(character, "pageUp"))
gdkKeySym = GDK_Page_Up;
else if (JSStringIsEqualToUTF8CString(character, "pageDown"))
gdkKeySym = GDK_Page_Down;
else if (JSStringIsEqualToUTF8CString(character, "home"))
gdkKeySym = GDK_Home;
else if (JSStringIsEqualToUTF8CString(character, "end"))
gdkKeySym = GDK_End;
else if (JSStringIsEqualToUTF8CString(character, "delete"))
gdkKeySym = GDK_BackSpace;
else if (JSStringIsEqualToUTF8CString(character, "F1"))
gdkKeySym = GDK_F1;
else if (JSStringIsEqualToUTF8CString(character, "F2"))
gdkKeySym = GDK_F2;
else if (JSStringIsEqualToUTF8CString(character, "F3"))
gdkKeySym = GDK_F3;
else if (JSStringIsEqualToUTF8CString(character, "F4"))
gdkKeySym = GDK_F4;
else if (JSStringIsEqualToUTF8CString(character, "F5"))
gdkKeySym = GDK_F5;
else if (JSStringIsEqualToUTF8CString(character, "F6"))
gdkKeySym = GDK_F6;
else if (JSStringIsEqualToUTF8CString(character, "F7"))
gdkKeySym = GDK_F7;
else if (JSStringIsEqualToUTF8CString(character, "F8"))
gdkKeySym = GDK_F8;
else if (JSStringIsEqualToUTF8CString(character, "F9"))
gdkKeySym = GDK_F9;
else if (JSStringIsEqualToUTF8CString(character, "F10"))
gdkKeySym = GDK_F10;
else if (JSStringIsEqualToUTF8CString(character, "F11"))
gdkKeySym = GDK_F11;
else if (JSStringIsEqualToUTF8CString(character, "F12"))
gdkKeySym = GDK_F12;
else {
int charCode = JSStringGetCharactersPtr(character)[0];
if (charCode == '\n' || charCode == '\r')
gdkKeySym = GDK_Return;
else if (charCode == '\t')
gdkKeySym = GDK_Tab;
else if (charCode == '\x8')
gdkKeySym = GDK_BackSpace;
else {
gdkKeySym = gdk_unicode_to_keyval(charCode);
if (WTF::isASCIIUpper(charCode))
state |= GDK_SHIFT_MASK;
}
}
}
JSStringRelease(character);
WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame);
if (!view)
return JSValueMakeUndefined(context);
// create and send the event
GdkEvent event;
memset(&event, 0, sizeof(event));
event.key.keyval = gdkKeySym;
event.key.state = state;
event.key.window = GTK_WIDGET(view)->window;
// When synthesizing an event, an invalid hardware_keycode value
// can cause it to be badly processed by Gtk+.
GdkKeymapKey* keys;
gint n_keys;
if (gdk_keymap_get_entries_for_keyval(gdk_keymap_get_default(), gdkKeySym, &keys, &n_keys)) {
event.key.hardware_keycode = keys[0].keycode;
g_free(keys);
}
gboolean return_val;
event.key.type = GDK_KEY_PRESS;
g_signal_emit_by_name(view, "key-press-event", &event.key, &return_val);
event.key.type = GDK_KEY_RELEASE;
g_signal_emit_by_name(view, "key-release-event", &event.key, &return_val);
return JSValueMakeUndefined(context);
}
static GdkNativeWindow
select_window_x11 (GdkScreen *screen)
{
Display *x_dpy = GDK_SCREEN_XDISPLAY (screen);
gint x_scr = GDK_SCREEN_XNUMBER (screen);
Window x_root = RootWindow (x_dpy, x_scr);
Window x_win = None;
GC x_gc = None;
Cursor x_cursor = XCreateFontCursor (x_dpy, GDK_CROSSHAIR);
GdkKeymapKey *keys = NULL;
gint status;
gint i, num_keys;
gint buttons = 0;
gint mask = ButtonPressMask | ButtonReleaseMask;
gboolean cancel = FALSE;
if (shootvals.shoot_type == SHOOT_REGION)
mask |= PointerMotionMask;
status = XGrabPointer (x_dpy, x_root, False,
mask, GrabModeSync, GrabModeAsync,
x_root, x_cursor, CurrentTime);
if (status != GrabSuccess)
{
gint x, y;
guint xmask;
/* if we can't grab the pointer, return the window under the pointer */
XQueryPointer (x_dpy, x_root, &x_root, &x_win, &x, &y, &x, &y, &xmask);
if (x_win == None || x_win == x_root)
g_message (_("Error selecting the window"));
}
if (shootvals.shoot_type == SHOOT_REGION)
{
XGCValues gc_values;
gc_values.function = GXxor;
gc_values.plane_mask = AllPlanes;
gc_values.foreground = WhitePixel (x_dpy, x_scr);
gc_values.background = BlackPixel (x_dpy, x_scr);
gc_values.line_width = 0;
gc_values.line_style = LineSolid;
gc_values.fill_style = FillSolid;
gc_values.cap_style = CapButt;
gc_values.join_style = JoinMiter;
gc_values.graphics_exposures = FALSE;
gc_values.clip_x_origin = 0;
gc_values.clip_y_origin = 0;
gc_values.clip_mask = None;
gc_values.subwindow_mode = IncludeInferiors;
x_gc = XCreateGC (x_dpy, x_root,
GCFunction | GCPlaneMask | GCForeground | GCLineWidth |
GCLineStyle | GCCapStyle | GCJoinStyle |
GCGraphicsExposures | GCBackground | GCFillStyle |
GCClipXOrigin | GCClipYOrigin | GCClipMask |
GCSubwindowMode,
&gc_values);
}
if (gdk_keymap_get_entries_for_keyval (NULL, GDK_Escape, &keys, &num_keys))
{
gdk_error_trap_push ();
#define X_GRAB_KEY(index, modifiers) \
XGrabKey (x_dpy, keys[index].keycode, modifiers, x_root, False, \
GrabModeAsync, GrabModeAsync)
for (i = 0; i < num_keys; i++)
{
X_GRAB_KEY (i, 0);
X_GRAB_KEY (i, LockMask); /* CapsLock */
X_GRAB_KEY (i, Mod2Mask); /* NumLock */
X_GRAB_KEY (i, Mod5Mask); /* ScrollLock */
X_GRAB_KEY (i, LockMask | Mod2Mask); /* CapsLock + NumLock */
X_GRAB_KEY (i, LockMask | Mod5Mask); /* CapsLock + ScrollLock */
X_GRAB_KEY (i, Mod2Mask | Mod5Mask); /* NumLock + ScrollLock */
X_GRAB_KEY (i, LockMask | Mod2Mask | Mod5Mask); /* all */
}
#undef X_GRAB_KEY
gdk_flush ();
gdk_error_trap_pop ();
}
while (! cancel && ((x_win == None) || (buttons != 0)))
{
XEvent x_event;
gint x, y, w, h;
XAllowEvents (x_dpy, SyncPointer, CurrentTime);
XWindowEvent (x_dpy, x_root, mask | KeyPressMask, &x_event);
switch (x_event.type)
{
case ButtonPress:
if (x_win == None)
{
x_win = x_event.xbutton.subwindow;
if (x_win == None)
x_win = x_root;
#ifdef HAVE_X11_XMU_WINUTIL_H
else if (! shootvals.decorate)
x_win = XmuClientWindow (x_dpy, x_win);
#endif
shootvals.x2 = shootvals.x1 = x_event.xbutton.x_root;
shootvals.y2 = shootvals.y1 = x_event.xbutton.y_root;
}
buttons++;
break;
case ButtonRelease:
if (buttons > 0)
buttons--;
if (! buttons && shootvals.shoot_type == SHOOT_REGION)
{
x = MIN (shootvals.x1, shootvals.x2);
y = MIN (shootvals.y1, shootvals.y2);
w = ABS (shootvals.x2 - shootvals.x1);
h = ABS (shootvals.y2 - shootvals.y1);
if (w > 0 && h > 0)
XDrawRectangle (x_dpy, x_root, x_gc, x, y, w, h);
shootvals.x2 = x_event.xbutton.x_root;
shootvals.y2 = x_event.xbutton.y_root;
}
break;
case MotionNotify:
if (buttons > 0)
{
x = MIN (shootvals.x1, shootvals.x2);
y = MIN (shootvals.y1, shootvals.y2);
w = ABS (shootvals.x2 - shootvals.x1);
h = ABS (shootvals.y2 - shootvals.y1);
if (w > 0 && h > 0)
XDrawRectangle (x_dpy, x_root, x_gc, x, y, w, h);
shootvals.x2 = x_event.xmotion.x_root;
shootvals.y2 = x_event.xmotion.y_root;
x = MIN (shootvals.x1, shootvals.x2);
y = MIN (shootvals.y1, shootvals.y2);
w = ABS (shootvals.x2 - shootvals.x1);
h = ABS (shootvals.y2 - shootvals.y1);
if (w > 0 && h > 0)
XDrawRectangle (x_dpy, x_root, x_gc, x, y, w, h);
}
break;
case KeyPress:
{
guint *keyvals;
gint n;
if (gdk_keymap_get_entries_for_keycode (NULL, x_event.xkey.keycode,
NULL, &keyvals, &n))
{
gint i;
for (i = 0; i < n && ! cancel; i++)
if (keyvals[i] == GDK_Escape)
cancel = TRUE;
g_free (keyvals);
}
}
break;
default:
break;
}
}
if (keys)
{
#define X_UNGRAB_KEY(index, modifiers) \
XUngrabKey (x_dpy, keys[index].keycode, modifiers, x_root)
for (i = 0; i < num_keys; i++)
{
X_UNGRAB_KEY (i, 0);
X_UNGRAB_KEY (i, LockMask); /* CapsLock */
X_UNGRAB_KEY (i, Mod2Mask); /* NumLock */
X_UNGRAB_KEY (i, Mod5Mask); /* ScrollLock */
X_UNGRAB_KEY (i, LockMask | Mod2Mask); /* CapsLock + NumLock */
X_UNGRAB_KEY (i, LockMask | Mod5Mask); /* CapsLock + ScrollLock */
X_UNGRAB_KEY (i, Mod2Mask | Mod5Mask); /* NumLock + ScrollLock */
X_UNGRAB_KEY (i, LockMask | Mod2Mask | Mod5Mask); /* all */
}
#undef X_UNGRAB_KEY
g_free (keys);
}
if (status == GrabSuccess)
XUngrabPointer (x_dpy, CurrentTime);
XFreeCursor (x_dpy, x_cursor);
if (x_gc != None)
XFreeGC (x_dpy, x_gc);
return x_win;
}
GdkEventKey *
ide_gdk_synthesize_event_key (GdkWindow *window,
gunichar ch)
{
GdkDisplay *display;
GdkDeviceManager *device_manager;
GdkDevice *client_pointer;
GdkEvent *ev;
GdkKeymapKey *keys = NULL;
gint n_keys = 0;
gchar str[8] = { 0 };
g_assert (window != NULL);
g_assert (GDK_IS_WINDOW (window));
g_unichar_to_utf8 (ch, str);
ev = gdk_event_new (GDK_KEY_PRESS);
ev->key.window = g_object_ref (window);
ev->key.send_event = TRUE;
ev->key.time = gtk_get_current_event_time ();
ev->key.state = 0;
ev->key.hardware_keycode = 0;
ev->key.group = 0;
ev->key.is_modifier = 0;
switch (ch)
{
case '\n':
ev->key.keyval = GDK_KEY_Return;
ev->key.string = g_strdup ("\n");
ev->key.length = 1;
break;
case '\e':
ev->key.keyval = GDK_KEY_Escape;
ev->key.string = g_strdup ("");
ev->key.length = 0;
break;
default:
ev->key.keyval = gdk_unicode_to_keyval (ch);
ev->key.length = strlen (str);
ev->key.string = g_strdup (str);
break;
}
gdk_keymap_get_entries_for_keyval (gdk_keymap_get_default (),
ev->key.keyval,
&keys,
&n_keys);
if (n_keys > 0)
{
ev->key.hardware_keycode = keys [0].keycode;
ev->key.group = keys [0].group;
if (keys [0].level == 1)
ev->key.state |= GDK_SHIFT_MASK;
g_free (keys);
}
display = gdk_window_get_display (ev->any.window);
device_manager = gdk_display_get_device_manager (display);
client_pointer = gdk_device_manager_get_client_pointer (device_manager);
gdk_event_set_device (ev, gdk_device_get_associated_device (client_pointer));
return &ev->key;
}
/*
* Translate a Java KeyEvent object into a GdkEventKey event, then
* pass it to the GTK main loop for processing.
*/
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_GtkComponentPeer_gtkWidgetDispatchKeyEvent
(JNIEnv *env, jobject obj, jint id, jlong when, jint mods,
jint keyCode, jint keyLocation)
{
void *ptr;
GdkEvent *event = NULL;
GdkKeymapKey *keymap_keys = NULL;
gint n_keys = 0;
guint lookup_keyval = 0;
gdk_threads_enter ();
ptr = gtkpeer_get_widget (env, obj);
if (id == AWT_KEY_PRESSED)
event = gdk_event_new (GDK_KEY_PRESS);
else if (id == AWT_KEY_RELEASED)
event = gdk_event_new (GDK_KEY_RELEASE);
else
{
gdk_threads_leave ();
/* Don't send AWT KEY_TYPED events to GTK. */
return;
}
if (GTK_IS_BUTTON (ptr))
event->key.window = GTK_BUTTON (get_widget(GTK_WIDGET (ptr)))->event_window;
else if (GTK_IS_SCROLLED_WINDOW (get_widget(GTK_WIDGET (ptr))))
event->key.window = GTK_WIDGET (GTK_SCROLLED_WINDOW (get_widget(GTK_WIDGET (ptr)))->container.child)->window;
else
event->key.window = get_widget(GTK_WIDGET (ptr))->window;
event->key.send_event = 0;
event->key.time = (guint32) when;
if (mods & AWT_SHIFT_DOWN_MASK)
event->key.state |= GDK_SHIFT_MASK;
if (mods & AWT_CTRL_DOWN_MASK)
event->key.state |= GDK_CONTROL_MASK;
if (mods & AWT_ALT_DOWN_MASK)
event->key.state |= GDK_MOD1_MASK;
/* This hack is needed because the AWT has no notion of num lock.
It infers numlock state from the only Java virtual keys that are
affected by it. */
if (keyCode == VK_NUMPAD9
|| keyCode == VK_NUMPAD8
|| keyCode == VK_NUMPAD7
|| keyCode == VK_NUMPAD6
|| keyCode == VK_NUMPAD5
|| keyCode == VK_NUMPAD4
|| keyCode == VK_NUMPAD3
|| keyCode == VK_NUMPAD2
|| keyCode == VK_NUMPAD1
|| keyCode == VK_NUMPAD0
|| keyCode == VK_DECIMAL)
event->key.state |= GDK_MOD2_MASK;
/* These values don't need to be filled in since GTK doesn't use
them. */
event->key.length = 0;
event->key.string = NULL;
lookup_keyval = cp_gtk_awt_keycode_to_keysym (keyCode, keyLocation);
if (!gdk_keymap_get_entries_for_keyval (gdk_keymap_get_default (),
lookup_keyval,
&keymap_keys,
&n_keys))
{
/* No matching keymap entry was found. */
g_printerr ("No matching keymap entries were found\n");
gdk_threads_leave ();
return;
}
/* Note: if n_keys > 1 then there are multiple hardware keycodes
that translate to lookup_keyval. We arbitrarily choose the first
hardware keycode from the list returned by
gdk_keymap_get_entries_for_keyval. */
event->key.hardware_keycode = keymap_keys[0].keycode;
event->key.group = keymap_keys[0].group;
g_free (keymap_keys);
if (!gdk_keymap_translate_keyboard_state (gdk_keymap_get_default (),
event->key.hardware_keycode,
event->key.state,
event->key.group,
&event->key.keyval,
NULL, NULL, NULL))
{
/* No matching keyval was found. */
g_printerr ("No matching keyval was found\n");
gdk_threads_leave ();
return;
}
/* keyevent = (GdkEventKey *) event; */
/* g_printerr ("generated event: sent: %d time: %d state: %d keyval: %d length: %d string: %s hardware_keycode: %d group: %d\n", keyevent->send_event, keyevent->time, keyevent->state, keyevent->keyval, keyevent->length, keyevent->string, keyevent->hardware_keycode, keyevent->group); */
/* We already received the original key event on the window itself,
so we don't want to resend it. */
if (!GTK_IS_WINDOW (ptr))
{
if (GTK_IS_SCROLLED_WINDOW (get_widget(GTK_WIDGET (ptr))))
gtk_widget_event (GTK_WIDGET (GTK_SCROLLED_WINDOW (get_widget(GTK_WIDGET (ptr)))->container.child), event);
else
gtk_widget_event (get_widget(GTK_WIDGET (ptr)), event);
}
gdk_threads_leave ();
}
static void
carbon_menu_item_update_accelerator (CarbonMenuItem *carbon_item,
GtkWidget *widget)
{
GtkWidget *label;
get_menu_label_text (widget, &label);
if (GTK_IS_ACCEL_LABEL (label))
{
GClosure *closure;
g_object_get (label, "accel-closure", &closure, NULL);
if (closure)
{
GtkAccelGroup *group;
GtkAccelKey *key;
group = gtk_accel_group_from_accel_closure (closure);
key = gtk_accel_group_find (group, accel_find_func, closure);
g_closure_unref (closure);
if (key &&
key->accel_key &&
key->accel_flags & GTK_ACCEL_VISIBLE)
{
GdkDisplay *display = gtk_widget_get_display (widget);
GdkKeymap *keymap = gdk_keymap_get_for_display (display);
GdkKeymapKey *keys;
gint n_keys;
if (gdk_keymap_get_entries_for_keyval (keymap, key->accel_key,
&keys, &n_keys))
{
UInt8 modifiers = 0;
SetMenuItemCommandKey (carbon_item->menu, carbon_item->index,
true, keys[0].keycode);
g_free (keys);
if (key->accel_mods)
{
if (key->accel_mods & GDK_SHIFT_MASK)
modifiers |= kMenuShiftModifier;
if (key->accel_mods & GDK_MOD1_MASK)
modifiers |= kMenuOptionModifier;
}
if (!(key->accel_mods & GDK_META_MASK))
{
modifiers |= kMenuNoCommandModifier;
}
SetMenuItemModifiers (carbon_item->menu, carbon_item->index,
modifiers);
return;
}
}
}
}
/* otherwise, clear the menu shortcut */
SetMenuItemModifiers (carbon_item->menu, carbon_item->index,
kMenuNoModifiers | kMenuNoCommandModifier);
ChangeMenuItemAttributes (carbon_item->menu, carbon_item->index,
0, kMenuItemAttrUseVirtualKey);
SetMenuItemCommandKey (carbon_item->menu, carbon_item->index,
false, 0);
}
void keyPress(char * key, int type)
{
printf("%s %s\n", __func__, key);
gboolean rtv;
/*
GdkEventType type;
GdkWindow *window;
gint8 send_event;
guint32 time;
guint state;
guint keyval;
gint length;
gchar *string;
guint16 hardware_keycode;
guint8 group;
guint is_modifier : 1;
*/
//GdkEventKey * event = (GdkEventKey*)malloc(sizeof(GdkEventKey));
GdkEvent* event = gdk_event_new(GDK_KEY_PRESS);
if(type == KEY_TYPE_PRESS)
((GdkEventKey*)event)->type = GDK_KEY_PRESS;
else if(type == KEY_TYPE_RELEASE)
((GdkEventKey*)event)->type = GDK_KEY_RELEASE;
else
return;
((GdkEventKey*)event)->window = g_window->window;
((GdkEventKey*)event)->send_event = 1;
((GdkEventKey*)event)->time = GDK_CURRENT_TIME;
((GdkEventKey*)event)->state = 0;
((GdkEventKey*)event)->keyval = 0;
//((GdkEventKey*)event)->length = 1;
if (!strcmp(key, "red"))
((GdkEventKey*)event)->keyval = GDK_F5; //'t';
else if(!strcmp(key, "green"))
((GdkEventKey*)event)->keyval = GDK_F6; //'u';
else if(!strcmp(key, "yellow"))
((GdkEventKey*)event)->keyval = GDK_F7; //'v';
else if(!strcmp(key, "blue"))
((GdkEventKey*)event)->keyval = GDK_F8; //'w';
else if(!strcmp(key, "up"))
((GdkEventKey*)event)->keyval = GDK_Up;
else if(!strcmp(key, "down"))
((GdkEventKey*)event)->keyval = GDK_Down;
else if(!strcmp(key, "left"))
((GdkEventKey*)event)->keyval = GDK_Left;
else if(!strcmp(key, "right"))
((GdkEventKey*)event)->keyval = GDK_Right;
else if(!strcmp(key, "ok"))
((GdkEventKey*)event)->keyval = GDK_Return;
else if(!strcmp(key, "play"))
((GdkEventKey*)event)->keyval = 'P';
else if(!strcmp(key, "pause"))
((GdkEventKey*)event)->keyval = 'P'; // PAUSE IS Q but it seems that P is Toggle PlayPause
else if(!strcmp(key, "stop"))
((GdkEventKey*)event)->keyval = 'S';
else if(!strcmp(key, "rewind"))
((GdkEventKey*)event)->keyval = 'R';
else if(!strcmp(key, "fastforward"))
((GdkEventKey*)event)->keyval = 'F';
else {
GdkKeymapKey* keys;
gint n_keys;
gdk_keymap_get_entries_for_keyval(gdk_keymap_get_default(), ((GdkEventKey*)event)->keyval, &keys, &n_keys);
((GdkEventKey*)event)->hardware_keycode = keys[0].keycode;
}
((GdkEventKey*)event)->group = 0;
((GdkEventKey*)event)->is_modifier = 0;
if(((GdkEventKey*)event)->keyval != 0) {
//if(type == KEY_TYPE_PRESS) {
//gtk_signal_emit_by_name(GTK_OBJECT (g_window), "key-press-event", event, &rtv);
gdk_event_put(event);
//}
//else if(type == KEY_TYPE_RELEASE)
// gtk_signal_emit_by_name(GTK_OBJECT (g_window), "key-release-event", event, &rtv);
return;
}
//event->state |= GDK_MOD1_MASK;
return;
}
static JSValueRef keyDownCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
{
if (argumentCount < 1)
return JSValueMakeUndefined(context);
static const JSStringRef lengthProperty = JSStringCreateWithUTF8CString("length");
webkit_web_frame_layout(mainFrame);
// handle modifier keys.
int state = 0;
if (argumentCount > 1) {
JSObjectRef modifiersArray = JSValueToObject(context, arguments[1], exception);
if (modifiersArray) {
for (int i = 0; i < JSValueToNumber(context, JSObjectGetProperty(context, modifiersArray, lengthProperty, 0), 0); ++i) {
JSValueRef value = JSObjectGetPropertyAtIndex(context, modifiersArray, i, 0);
JSStringRef string = JSValueToStringCopy(context, value, 0);
if (JSStringIsEqualToUTF8CString(string, "ctrlKey"))
state |= GDK_CONTROL_MASK;
else if (JSStringIsEqualToUTF8CString(string, "shiftKey"))
state |= GDK_SHIFT_MASK;
else if (JSStringIsEqualToUTF8CString(string, "altKey"))
state |= GDK_MOD1_MASK;
JSStringRelease(string);
}
}
}
// handle location argument.
int location = DOM_KEY_LOCATION_STANDARD;
if (argumentCount > 2)
location = (int)JSValueToNumber(context, arguments[2], exception);
JSStringRef character = JSValueToStringCopy(context, arguments[0], exception);
g_return_val_if_fail((!exception || !*exception), JSValueMakeUndefined(context));
int gdkKeySym = GDK_VoidSymbol;
if (location == DOM_KEY_LOCATION_NUMPAD) {
if (JSStringIsEqualToUTF8CString(character, "leftArrow"))
gdkKeySym = GDK_KP_Left;
else if (JSStringIsEqualToUTF8CString(character, "rightArrow"))
gdkKeySym = GDK_KP_Right;
else if (JSStringIsEqualToUTF8CString(character, "upArrow"))
gdkKeySym = GDK_KP_Up;
else if (JSStringIsEqualToUTF8CString(character, "downArrow"))
gdkKeySym = GDK_KP_Down;
else if (JSStringIsEqualToUTF8CString(character, "pageUp"))
gdkKeySym = GDK_KP_Page_Up;
else if (JSStringIsEqualToUTF8CString(character, "pageDown"))
gdkKeySym = GDK_KP_Page_Down;
else if (JSStringIsEqualToUTF8CString(character, "home"))
gdkKeySym = GDK_KP_Home;
else if (JSStringIsEqualToUTF8CString(character, "end"))
gdkKeySym = GDK_KP_End;
else if (JSStringIsEqualToUTF8CString(character, "insert"))
gdkKeySym = GDK_KP_Insert;
else if (JSStringIsEqualToUTF8CString(character, "delete"))
gdkKeySym = GDK_KP_Delete;
else
// If we get some other key specified with the numpad location,
// crash here, so we add it sooner rather than later.
g_assert_not_reached();
} else {
if (JSStringIsEqualToUTF8CString(character, "leftArrow"))
gdkKeySym = GDK_Left;
else if (JSStringIsEqualToUTF8CString(character, "rightArrow"))
gdkKeySym = GDK_Right;
else if (JSStringIsEqualToUTF8CString(character, "upArrow"))
gdkKeySym = GDK_Up;
else if (JSStringIsEqualToUTF8CString(character, "downArrow"))
gdkKeySym = GDK_Down;
else if (JSStringIsEqualToUTF8CString(character, "pageUp"))
gdkKeySym = GDK_Page_Up;
else if (JSStringIsEqualToUTF8CString(character, "pageDown"))
gdkKeySym = GDK_Page_Down;
else if (JSStringIsEqualToUTF8CString(character, "home"))
gdkKeySym = GDK_Home;
else if (JSStringIsEqualToUTF8CString(character, "end"))
gdkKeySym = GDK_End;
else if (JSStringIsEqualToUTF8CString(character, "insert"))
gdkKeySym = GDK_Insert;
else if (JSStringIsEqualToUTF8CString(character, "delete"))
gdkKeySym = GDK_Delete;
else if (JSStringIsEqualToUTF8CString(character, "printScreen"))
gdkKeySym = GDK_Print;
else if (JSStringIsEqualToUTF8CString(character, "F1"))
gdkKeySym = GDK_F1;
else if (JSStringIsEqualToUTF8CString(character, "F2"))
gdkKeySym = GDK_F2;
else if (JSStringIsEqualToUTF8CString(character, "F3"))
gdkKeySym = GDK_F3;
else if (JSStringIsEqualToUTF8CString(character, "F4"))
gdkKeySym = GDK_F4;
else if (JSStringIsEqualToUTF8CString(character, "F5"))
gdkKeySym = GDK_F5;
else if (JSStringIsEqualToUTF8CString(character, "F6"))
gdkKeySym = GDK_F6;
else if (JSStringIsEqualToUTF8CString(character, "F7"))
gdkKeySym = GDK_F7;
else if (JSStringIsEqualToUTF8CString(character, "F8"))
gdkKeySym = GDK_F8;
else if (JSStringIsEqualToUTF8CString(character, "F9"))
gdkKeySym = GDK_F9;
else if (JSStringIsEqualToUTF8CString(character, "F10"))
gdkKeySym = GDK_F10;
else if (JSStringIsEqualToUTF8CString(character, "F11"))
gdkKeySym = GDK_F11;
else if (JSStringIsEqualToUTF8CString(character, "F12"))
gdkKeySym = GDK_F12;
else {
int charCode = JSStringGetCharactersPtr(character)[0];
if (charCode == '\n' || charCode == '\r')
gdkKeySym = GDK_Return;
else if (charCode == '\t')
gdkKeySym = GDK_Tab;
else if (charCode == '\x8')
gdkKeySym = GDK_BackSpace;
else {
gdkKeySym = gdk_unicode_to_keyval(charCode);
if (WTF::isASCIIUpper(charCode))
state |= GDK_SHIFT_MASK;
}
}
}
JSStringRelease(character);
WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame);
if (!view)
return JSValueMakeUndefined(context);
// create and send the event
GdkEvent* pressEvent = gdk_event_new(GDK_KEY_PRESS);
pressEvent->key.keyval = gdkKeySym;
pressEvent->key.state = state;
pressEvent->key.window = gtk_widget_get_window(GTK_WIDGET(view));
g_object_ref(pressEvent->key.window);
#ifndef GTK_API_VERSION_2
gdk_event_set_device(pressEvent, getDefaultGDKPointerDevice(pressEvent->key.window));
#endif
// When synthesizing an event, an invalid hardware_keycode value
// can cause it to be badly processed by Gtk+.
GdkKeymapKey* keys;
gint n_keys;
if (gdk_keymap_get_entries_for_keyval(gdk_keymap_get_default(), gdkKeySym, &keys, &n_keys)) {
pressEvent->key.hardware_keycode = keys[0].keycode;
g_free(keys);
}
GdkEvent* releaseEvent = gdk_event_copy(pressEvent);
dispatchEvent(pressEvent);
releaseEvent->key.type = GDK_KEY_RELEASE;
dispatchEvent(releaseEvent);
return JSValueMakeUndefined(context);
}
/* Grab or ungrab then keyval and modifiers combination, grabbing all key
* combinations yielding the same key values.
* Includes ignorable modifiers using grab_ungrab_with_ignorable_modifiers.
*/
static gboolean
grab_ungrab (GdkWindow *rootwin,
uint keyval,
uint modifiers,
gboolean grab)
{
int k;
GdkKeymap *map;
GdkKeymapKey *keys;
gint n_keys;
GdkModifierType add_modifiers;
XkbDescPtr xmap;
gboolean success = FALSE;
xmap = XkbGetMap(GDK_WINDOW_XDISPLAY(rootwin),
XkbAllClientInfoMask,
XkbUseCoreKbd);
map = gdk_keymap_get_default();
gdk_keymap_get_entries_for_keyval(map, keyval, &keys, &n_keys);
if (n_keys == 0)
return FALSE;
for (k = 0; k < n_keys; k++) {
/* NOTE: We only bind for the first group,
* so regardless of current keyboard layout, it will
* grab the key from the default Layout.
*/
if (keys[k].group != WE_ONLY_USE_ONE_GROUP) {
continue;
}
add_modifiers = FinallyGetModifiersForKeycode(xmap,
keys[k].keycode,
keys[k].group,
keys[k].level);
if (add_modifiers == MODIFIERS_ERROR) {
continue;
}
TRACE (g_print("grab/ungrab keycode: %d, lev: %d, grp: %d, ",
keys[k].keycode, keys[k].level, keys[k].group));
TRACE (g_print("modifiers: 0x%x (consumed: 0x%x)\n",
add_modifiers | modifiers, add_modifiers));
if (grab_ungrab_with_ignorable_modifiers(rootwin,
keys[k].keycode,
add_modifiers | modifiers,
grab)) {
success = TRUE;
} else {
/* When grabbing, break on error */
if (grab && !success) {
break;
}
}
}
g_free(keys);
XkbFreeClientMap(xmap, 0, TRUE);
return success;
}
void
compzillaWindow::SendKeyEvent (int eventType, nsIDOMKeyEvent *keyEv)
{
DOMTimeStamp timestamp;
PRBool ctrl, shift, alt, meta;
int state = 0;
keyEv->GetTimeStamp (×tamp);
if (!timestamp) {
timestamp = gtk_get_current_event_time (); // CurrentTime;
}
keyEv->GetAltKey (&alt);
keyEv->GetCtrlKey (&ctrl);
keyEv->GetShiftKey (&shift);
keyEv->GetMetaKey (&meta);
if (ctrl) {
state |= ControlMask;
}
if (shift) {
state |= ShiftMask;
}
if (alt) {
state |= Mod1Mask;
}
if (meta) {
state |= Mod2Mask;
}
PRUint32 keycode;
keyEv->GetKeyCode (&keycode);
unsigned int xkeysym = DOMKeyCodeToKeySym (keycode);
#ifdef USE_GDK_KEYMAP
// FIXME: There's probably some annoying reason, like XKB, we need to use
// the GDK version. But for now I'm in denial.
GdkKeymapKey *keys = NULL;
int n_keys = 0;
if (!gdk_keymap_get_entries_for_keyval (gdk_keymap_get_for_display (gdk_display_get_default ()),
xkeysym,
&keys,
&n_keys)) {
ERROR ("Unknown keyval '%d' ignored.\n", xkeysym);
return;
}
unsigned int xkeycode = 0;
for (int i = 0; i < n_keys; i++) {
if (keys [i].keycode) {
xkeycode = keys [i].keycode;
break;
}
}
g_free (keys);
SPEW_EVENT ("SendKeyEvent: gdk_keymap_get_entries_for_keyval keysym=%p, "
"keycode=%p\n", xkeysym, xkeycode);
#else
unsigned int xkeycode = XKeysymToKeycode (mDisplay, xkeysym);
#endif
// Build up the XEvent we will send
XEvent xev = { 0 };
xev.xkey.type = eventType;
xev.xkey.serial = 0;
xev.xkey.display = mDisplay;
xev.xkey.window = mWindow;
xev.xkey.root = mAttr.root;
xev.xkey.time = timestamp;
xev.xkey.state = state;
xev.xkey.keycode = xkeycode;
xev.xkey.same_screen = True;
// Figure out who to send to
long xevMask;
switch (eventType) {
case _KeyPress:
xevMask = KeyPressMask;
break;
case KeyRelease:
xevMask = KeyReleaseMask;
break;
default:
NS_NOTREACHED ("Unknown eventType");
return;
}
SPEW_EVENT ("SendKeyEvent: %s%s win=%p, child=%p, state=%p, keycode=%u, "
"timestamp=%d\n",
eventType == _KeyPress ? "PRESS" : "",
eventType == KeyRelease ? "RELEASE" : "",
mWindow, mWindow, state, xkeycode, timestamp);
XSendEvent (mDisplay, mWindow, True, xevMask, &xev);
keyEv->StopPropagation ();
keyEv->PreventDefault ();
}
gboolean
_gdk_x11_window_simulate_key (GdkWindow *window,
gint x,
gint y,
guint keyval,
GdkModifierType modifiers,
GdkEventType key_pressrelease)
{
GdkScreen *screen;
GdkKeymapKey *keys = NULL;
gboolean success;
gint n_keys = 0;
XKeyEvent xev = {
0, /* type */
0, /* serial */
1, /* send_event */
};
g_return_val_if_fail (key_pressrelease == GDK_KEY_PRESS || key_pressrelease == GDK_KEY_RELEASE, FALSE);
g_return_val_if_fail (window != NULL, FALSE);
if (!GDK_WINDOW_IS_MAPPED (window))
return FALSE;
screen = gdk_window_get_screen (window);
if (x < 0 && y < 0)
{
x = window->width / 2;
y = window->height / 2;
}
/* Convert to impl coordinates */
x = x + window->abs_x;
y = y + window->abs_y;
xev.type = key_pressrelease == GDK_KEY_PRESS ? KeyPress : KeyRelease;
xev.display = GDK_WINDOW_XDISPLAY (window);
xev.window = GDK_WINDOW_XID (window);
xev.root = RootWindow (xev.display, GDK_X11_SCREEN (screen)->screen_num);
xev.subwindow = 0;
xev.time = 0;
xev.x = MAX (x, 0);
xev.y = MAX (y, 0);
xev.x_root = 0;
xev.y_root = 0;
xev.state = modifiers;
xev.keycode = 0;
success = gdk_keymap_get_entries_for_keyval (gdk_keymap_get_for_display (gdk_window_get_display (window)), keyval, &keys, &n_keys);
success &= n_keys > 0;
if (success)
{
gint i;
for (i = 0; i < n_keys; i++)
if (keys[i].group == 0 && (keys[i].level == 0 || keys[i].level == 1))
{
xev.keycode = keys[i].keycode;
if (keys[i].level == 1)
{
/* Assume shift takes us to level 1 */
xev.state |= GDK_SHIFT_MASK;
}
break;
}
if (i >= n_keys) /* no match for group==0 and level==0 or 1 */
xev.keycode = keys[0].keycode;
}
g_free (keys);
if (!success)
return FALSE;
gdk_x11_display_error_trap_push (GDK_WINDOW_DISPLAY (window));
xev.same_screen = XTranslateCoordinates (xev.display, xev.window, xev.root,
xev.x, xev.y, &xev.x_root, &xev.y_root,
&xev.subwindow);
if (!xev.subwindow)
xev.subwindow = xev.window;
success &= xev.same_screen;
if (x >= 0 && y >= 0)
success &= 0 != XWarpPointer (xev.display, None, xev.window, 0, 0, 0, 0, xev.x, xev.y);
success &= 0 != XSendEvent (xev.display, xev.window, True, key_pressrelease == GDK_KEY_PRESS ? KeyPressMask : KeyReleaseMask, (XEvent*) &xev);
XSync (xev.display, False);
success &= 0 == gdk_x11_display_error_trap_pop (GDK_WINDOW_DISPLAY (window));
return success;
}
/* Copy from gdk */
static GdkEventKey *
_create_gdk_event(FcitxIMContext *fcitxcontext,
guint keyval,
guint state,
FcitxKeyEventType type
)
{
gunichar c = 0;
gchar buf[8];
GdkEventKey *event = (GdkEventKey *)gdk_event_new((type == FCITX_RELEASE_KEY) ? GDK_KEY_RELEASE : GDK_KEY_PRESS);
if (fcitxcontext && fcitxcontext->client_window)
event->window = g_object_ref(fcitxcontext->client_window);
/* The time is copied the latest value from the previous
* GdkKeyEvent in filter_keypress().
*
* We understand the best way would be to pass the all time value
* to Fcitx functions process_key_event() and Fcitx DBus functions
* ProcessKeyEvent() in IM clients and IM engines so that the
* _create_gdk_event() could get the correct time values.
* However it would causes to change many functions and the time value
* would not provide the useful meanings for each Fcitx engines but just
* pass the original value to ForwardKeyEvent().
* We use the saved value at the moment.
*
* Another idea might be to have the time implementation in X servers
* but some Xorg uses clock_gettime() and others use gettimeofday()
* and the values would be different in each implementation and
* locale/remote X server. So probably that idea would not work. */
if (fcitxcontext) {
event->time = fcitxcontext->time;
} else {
event->time = GDK_CURRENT_TIME;
}
event->send_event = FALSE;
event->state = state;
event->keyval = keyval;
event->string = NULL;
event->length = 0;
event->hardware_keycode = 0;
if (event->window) {
#ifndef NEW_GDK_WINDOW_GET_DISPLAY
GdkDisplay *display = gdk_display_get_default();
#else
GdkDisplay *display = gdk_window_get_display(event->window);
#endif
GdkKeymap *keymap = gdk_keymap_get_for_display(display);
GdkKeymapKey *keys;
gint n_keys = 0;
if (gdk_keymap_get_entries_for_keyval(keymap, keyval, &keys, &n_keys)) {
if (n_keys)
event->hardware_keycode = keys[0].keycode;
g_free(keys);
}
}
event->group = 0;
event->is_modifier = _key_is_modifier(keyval);
#ifdef DEPRECATED_GDK_KEYSYMS
if (keyval != GDK_VoidSymbol)
#else
if (keyval != GDK_KEY_VoidSymbol)
#endif
c = gdk_keyval_to_unicode(keyval);
if (c) {
gsize bytes_written;
gint len;
/* Apply the control key - Taken from Xlib
*/
if (event->state & GDK_CONTROL_MASK) {
if ((c >= '@' && c < '\177') || c == ' ') c &= 0x1F;
else if (c == '2') {
event->string = g_memdup("\0\0", 2);
event->length = 1;
buf[0] = '\0';
goto out;
} else if (c >= '3' && c <= '7') c -= ('3' - '\033');
else if (c == '8') c = '\177';
else if (c == '/') c = '_' & 0x1F;
}
len = g_unichar_to_utf8(c, buf);
buf[len] = '\0';
event->string = g_locale_from_utf8(buf, len,
NULL, &bytes_written,
NULL);
if (event->string)
event->length = bytes_written;
#ifdef DEPRECATED_GDK_KEYSYMS
} else if (keyval == GDK_Escape) {
#else
} else if (keyval == GDK_KEY_Escape) {
#endif
event->length = 1;
event->string = g_strdup("\033");
}
#ifdef DEPRECATED_GDK_KEYSYMS
else if (keyval == GDK_Return ||
keyval == GDK_KP_Enter) {
#else
else if (keyval == GDK_KEY_Return ||
keyval == GDK_KEY_KP_Enter) {
#endif
event->length = 1;
event->string = g_strdup("\r");
}
if (!event->string) {
event->length = 0;
event->string = g_strdup("");
}
out:
return event;
}
static gboolean
_key_is_modifier(guint keyval)
{
/* See gdkkeys-x11.c:_gdk_keymap_key_is_modifier() for how this
* really should be implemented */
switch (keyval) {
#ifdef DEPRECATED_GDK_KEYSYMS
case GDK_Shift_L:
case GDK_Shift_R:
case GDK_Control_L:
case GDK_Control_R:
case GDK_Caps_Lock:
case GDK_Shift_Lock:
case GDK_Meta_L:
case GDK_Meta_R:
case GDK_Alt_L:
case GDK_Alt_R:
case GDK_Super_L:
case GDK_Super_R:
case GDK_Hyper_L:
case GDK_Hyper_R:
case GDK_ISO_Lock:
case GDK_ISO_Level2_Latch:
case GDK_ISO_Level3_Shift:
case GDK_ISO_Level3_Latch:
case GDK_ISO_Level3_Lock:
case GDK_ISO_Group_Shift:
case GDK_ISO_Group_Latch:
case GDK_ISO_Group_Lock:
return TRUE;
#else
case GDK_KEY_Shift_L:
case GDK_KEY_Shift_R:
case GDK_KEY_Control_L:
case GDK_KEY_Control_R:
case GDK_KEY_Caps_Lock:
case GDK_KEY_Shift_Lock:
case GDK_KEY_Meta_L:
case GDK_KEY_Meta_R:
case GDK_KEY_Alt_L:
case GDK_KEY_Alt_R:
case GDK_KEY_Super_L:
case GDK_KEY_Super_R:
case GDK_KEY_Hyper_L:
case GDK_KEY_Hyper_R:
case GDK_KEY_ISO_Lock:
case GDK_KEY_ISO_Level2_Latch:
case GDK_KEY_ISO_Level3_Shift:
case GDK_KEY_ISO_Level3_Latch:
case GDK_KEY_ISO_Level3_Lock:
case GDK_KEY_ISO_Level5_Shift:
case GDK_KEY_ISO_Level5_Latch:
case GDK_KEY_ISO_Level5_Lock:
case GDK_KEY_ISO_Group_Shift:
case GDK_KEY_ISO_Group_Latch:
case GDK_KEY_ISO_Group_Lock:
return TRUE;
#endif
default:
return FALSE;
}
}
void _fcitx_im_context_connect_cb(FcitxClient* im, void* user_data)
{
FcitxIMContext* context = FCITX_IM_CONTEXT(user_data);
_fcitx_im_context_set_capacity(context, TRUE);
/* set_cursor_location_internal() will get origin from X server,
* it blocks UI. So delay it to idle callback. */
g_idle_add_full(G_PRIORITY_DEFAULT_IDLE,
(GSourceFunc) _set_cursor_location_internal,
g_object_ref(context),
(GDestroyNotify) g_object_unref);
}
