static guint
get_numeric_keyval (GthBrowser *browser,
GdkEventKey *event)
{
guint keyval;
gdk_keymap_translate_keyboard_state (gdk_keymap_get_for_display (gtk_widget_get_display (GTK_WIDGET (browser))),
event->hardware_keycode,
event->state & ~GDK_SHIFT_MASK,
event->group,
&keyval,
NULL, NULL, NULL);
/* This fixes the keyboard shortcuts for French keyboards (and
* maybe others as well) where the number keys are shifted. */
if ((keyval < GDK_KEY_1) || (keyval > GDK_KEY_3))
gdk_keymap_translate_keyboard_state (gdk_keymap_get_for_display (gtk_widget_get_display (GTK_WIDGET (browser))),
event->hardware_keycode,
event->state | GDK_SHIFT_MASK,
event->group,
&keyval,
NULL, NULL, NULL);
return keyval;
}
static void
handle_key_event (GdkWindow *window, const MirInputEvent *event)
{
const MirKeyboardEvent *keyboard_event = mir_input_event_get_keyboard_event (event);
GdkMirWindowImpl *impl = GDK_MIR_WINDOW_IMPL (window->impl);
GdkKeymap *keymap;
guint modifier_state;
guint button_state;
if (!keyboard_event)
return;
switch (mir_keyboard_event_action (keyboard_event))
{
case mir_keyboard_action_up:
case mir_keyboard_action_down:
// FIXME: Convert keycode
_gdk_mir_window_impl_get_cursor_state (impl, NULL, NULL, NULL, &button_state);
modifier_state = get_modifier_state (mir_keyboard_event_modifiers (keyboard_event), button_state);
keymap = gdk_keymap_get_for_display (gdk_window_get_display (window));
generate_key_event (window,
mir_keyboard_event_action (keyboard_event) == mir_keyboard_action_down ? GDK_KEY_PRESS : GDK_KEY_RELEASE,
modifier_state,
mir_keyboard_event_key_code (keyboard_event),
mir_keyboard_event_scan_code (keyboard_event),
_gdk_mir_keymap_key_is_modifier (keymap, mir_keyboard_event_key_code (keyboard_event)),
NANO_TO_MILLI (mir_input_event_get_event_time (event)));
break;
default:
//case mir_key_action_multiple:
// FIXME
break;
}
}
gboolean parse_keystr(const gchar* keystr,
GtkWidget* widget,
HotkeyEntry* key)
{
guint keyval;
GdkKeymapKey *keys;
gint n;
GdkDisplay* display;
if (!keystr || strlen(keystr) < 1)
return FALSE;
keyval = gdk_keyval_from_name(keystr);
if (keyval == GDK_VoidSymbol)
return FALSE;
display = widget ? gtk_widget_get_display(widget) : gdk_display_get_default();
if (!display)
return FALSE;
gdk_keymap_get_entries_for_keyval(
gdk_keymap_get_for_display(display),
keyval, &keys, &n);
if (n < 1)
return FALSE;
key->code = keys[0].keycode;
return TRUE;
}
static void
clutter_text_focus_in_cb (ClutterText *text,
ClutterActor *actor)
{
StEntry *entry = ST_ENTRY (actor);
StEntryPrivate *priv = entry->priv;
GdkKeymap *keymap;
/* remove the hint if visible */
if (priv->hint && priv->hint_visible)
{
priv->hint_visible = FALSE;
clutter_text_set_text (text, "");
}
keymap = gdk_keymap_get_for_display (gdk_display_get_default ());
keymap_state_changed (keymap, entry);
g_signal_connect (keymap, "state-changed",
G_CALLBACK (keymap_state_changed), entry);
st_widget_remove_style_pseudo_class (ST_WIDGET (actor), "indeterminate");
st_widget_add_style_pseudo_class (ST_WIDGET (actor), "focus");
clutter_text_set_cursor_visible (text, TRUE);
}
/* Send keyboard accelerators to the parent window, if necessary.
* This code is heavily based on gtk_menu_key_press ()
*/
static gboolean
hildon_app_menu_key_press (GtkWidget *widget,
GdkEventKey *event)
{
GtkWindow *parent_window;
HildonAppMenuPrivate *priv;
g_return_val_if_fail (HILDON_IS_APP_MENU (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
if (GTK_WIDGET_CLASS (hildon_app_menu_parent_class)->key_press_event (widget, event))
return TRUE;
priv = HILDON_APP_MENU_GET_PRIVATE (widget);
parent_window = priv->parent_window;
if (parent_window) {
guint accel_key, accel_mods;
GdkModifierType consumed_modifiers;
GdkDisplay *display;
GSList *accel_groups;
GSList *list;
display = gtk_widget_get_display (widget);
/* Figure out what modifiers went into determining the key symbol */
gdk_keymap_translate_keyboard_state (gdk_keymap_get_for_display (display),
event->hardware_keycode, event->state, event->group,
NULL, NULL, NULL, &consumed_modifiers);
accel_key = gdk_keyval_to_lower (event->keyval);
accel_mods = event->state & gtk_accelerator_get_default_mod_mask () & ~consumed_modifiers;
/* If lowercasing affects the keysym, then we need to include SHIFT in the modifiers,
* We re-upper case when we match against the keyval, but display and save in caseless form.
*/
if (accel_key != event->keyval)
accel_mods |= GDK_SHIFT_MASK;
accel_groups = gtk_accel_groups_from_object (G_OBJECT (parent_window));
for (list = accel_groups; list; list = list->next) {
GtkAccelGroup *accel_group = list->data;
if (gtk_accel_group_query (accel_group, accel_key, accel_mods, NULL)) {
gtk_window_activate_key (parent_window, event);
priv->hide_idle_id = gdk_threads_add_idle (hildon_app_menu_hide_idle, widget);
break;
}
}
}
return TRUE;
}
GdkModifierType
gtk_widget_get_modifier_mask (GtkWidget *widget,
GdkModifierIntent intent)
{
GdkDisplay *display;
g_return_val_if_fail (GTK_IS_WIDGET (widget), 0);
display = gtk_widget_get_display (widget);
return gdk_keymap_get_modifier_mask (gdk_keymap_get_for_display (display),
intent);
}
static void
translate_key_event (GdkDisplay *display,
GdkX11DeviceManagerCore *device_manager,
GdkEvent *event,
XEvent *xevent)
{
GdkKeymap *keymap = gdk_keymap_get_for_display (display);
GdkModifierType consumed, state;
event->key.type = xevent->xany.type == KeyPress ? GDK_KEY_PRESS : GDK_KEY_RELEASE;
event->key.time = xevent->xkey.time;
gdk_event_set_device (event, device_manager->core_keyboard);
event->key.state = (GdkModifierType) xevent->xkey.state;
event->key.group = _gdk_x11_get_group_for_state (display, xevent->xkey.state);
event->key.hardware_keycode = xevent->xkey.keycode;
event->key.keyval = GDK_KEY_VoidSymbol;
gdk_keymap_translate_keyboard_state (keymap,
event->key.hardware_keycode,
event->key.state,
event->key.group,
&event->key.keyval,
NULL, NULL, &consumed);
state = event->key.state & ~consumed;
_gdk_x11_keymap_add_virt_mods (keymap, &state);
event->key.state |= state;
event->key.is_modifier = _gdk_x11_keymap_key_is_modifier (keymap, event->key.hardware_keycode);
_gdk_x11_event_translate_keyboard_string (&event->key);
#ifdef G_ENABLE_DEBUG
if (_gdk_debug_flags & GDK_DEBUG_EVENTS)
{
g_message ("%s:\t\twindow: %ld key: %12s %d",
event->type == GDK_KEY_PRESS ? "key press " : "key release",
xevent->xkey.window,
event->key.keyval ? gdk_keyval_name (event->key.keyval) : "(none)",
event->key.keyval);
if (event->key.length > 0)
g_message ("\t\tlength: %4d string: \"%s\"",
event->key.length, event->key.string);
}
#endif /* G_ENABLE_DEBUG */
return;
}
static GdkEventKey *
key_event_to_gdk (ClutterKeyEvent *event_clutter)
{
GdkDisplay *display = gdk_display_get_default ();
GdkKeymap *keymap = gdk_keymap_get_for_display (display);
GdkEventKey *event_gdk;
event_gdk = (GdkEventKey *)gdk_event_new ((event_clutter->type == CLUTTER_KEY_PRESS) ?
GDK_KEY_PRESS : GDK_KEY_RELEASE);
event_gdk->window = window_for_actor ((ClutterActor *)event_clutter->stage);
event_gdk->send_event = FALSE;
event_gdk->time = event_clutter->time;
/* This depends on ClutterModifierType and GdkModifierType being
* identical, which they are currently. (They both match the X
* modifier state in the low 16-bits and have the same extensions.) */
event_gdk->state = event_clutter->modifier_state;
event_gdk->keyval = event_clutter->keyval;
event_gdk->hardware_keycode = event_clutter->hardware_keycode;
/* For non-proper non-XKB support, we'd need a huge cut-and-paste
* from gdkkeys-x11.c; this is a macro that just shifts a few bits
* out of state, so won't make the situation worse if the server
* doesn't support XKB; we'll just end up with group == 0 */
event_gdk->group = XkbGroupForCoreState (event_gdk->state);
gdk_keymap_translate_keyboard_state (keymap, event_gdk->hardware_keycode,
event_gdk->state, event_gdk->group,
&event_gdk->keyval, NULL, NULL, NULL);
if (event_clutter->unicode_value)
{
/* This is not particularly close to what GDK does - event_gdk->string
* is supposed to be in the locale encoding, and have control keys
* as control characters, etc. See gdkevents-x11.c:translate_key_event().
* Hopefully no input method is using event.string.
*/
char buf[6];
event_gdk->length = g_unichar_to_utf8 (event_clutter->unicode_value, buf);
event_gdk->string = g_strndup (buf, event_gdk->length);
}
event_gdk->is_modifier = key_is_modifier (event_gdk->keyval);
return event_gdk;
}
static void
st_entry_dispose (GObject *object)
{
StEntry *entry = ST_ENTRY (object);
StEntryPrivate *priv = entry->priv;
GdkKeymap *keymap;
if (priv->entry)
{
clutter_actor_destroy (priv->entry);
priv->entry = NULL;
}
keymap = gdk_keymap_get_for_display (gdk_display_get_default ());
g_signal_handlers_disconnect_by_func (keymap, keymap_state_changed, entry);
G_OBJECT_CLASS (st_entry_parent_class)->dispose (object);
}
void
translate_key_event (GdkDisplay *display,
GdkEvent *event,
XEvent *xevent)
{
GdkKeymap *keymap = gdk_keymap_get_for_display (display);
event->key.type = xevent->xany.type == KeyPress ? GDK_KEY_PRESS : GDK_KEY_RELEASE;
event->key.time = xevent->xkey.time;
event->key.state = (GdkModifierType) xevent->xkey.state;
#ifdef HAVE_XKB
event->key.group = XkbGroupForCoreState (xevent->xkey.state);
#else
event->key.group = 0;
#endif
event->key.hardware_keycode = xevent->xkey.keycode;
event->key.keyval = GDK_VoidSymbol;
gdk_keymap_translate_keyboard_state (keymap,
event->key.hardware_keycode,
event->key.state,
event->key.group,
&event->key.keyval,
NULL, NULL, NULL);
event->key.is_modifier = 0;
/* Fill in event->string crudely, since various programs
* depend on it.
*/
event->key.string = NULL;
event->key.length = 0;
return;
}
gchar* keycode_to_string(KeyCode keycode,
GtkWidget* widget)
{
guint *keyvals;
gint n;
gboolean retval;
gchar *keystr = NULL;
GdkDisplay* display;
display = widget ? gtk_widget_get_display(widget) : gdk_display_get_default();
if (!display)
return FALSE;
retval = gdk_keymap_get_entries_for_keycode(
gdk_keymap_get_for_display(display),
keycode, NULL, &keyvals, &n);
if (!retval || !n)
return NULL;
keystr = gdk_keyval_name(keyvals[0]);
g_free(keyvals);
return keystr;
}
static void
clutter_text_focus_out_cb (ClutterText *text,
ClutterActor *actor)
{
StEntry *entry = ST_ENTRY (actor);
StEntryPrivate *priv = entry->priv;
GdkKeymap *keymap;
st_widget_remove_style_pseudo_class (ST_WIDGET (actor), "focus");
/* add a hint if the entry is empty */
if (priv->hint && !strcmp (clutter_text_get_text (text), ""))
{
priv->hint_visible = TRUE;
clutter_text_set_text (text, priv->hint);
st_widget_add_style_pseudo_class (ST_WIDGET (actor), "indeterminate");
}
clutter_text_set_cursor_visible (text, FALSE);
remove_capslock_feedback (entry);
keymap = gdk_keymap_get_for_display (gdk_display_get_default ());
g_signal_handlers_disconnect_by_func (keymap, keymap_state_changed, entry);
}
static gboolean
grab_key_callback (GtkWidget *widget,
GdkEventKey *event,
GtkCellRendererAccel *accel)
{
GdkModifierType accel_mods = 0;
guint accel_key;
gchar *path;
gboolean edited;
gboolean cleared;
GdkModifierType consumed_modifiers;
GdkDisplay *display;
display = gtk_widget_get_display (widget);
if (event->is_modifier)
return TRUE;
edited = FALSE;
cleared = FALSE;
gdk_keymap_translate_keyboard_state (gdk_keymap_get_for_display (display),
event->hardware_keycode,
event->state,
event->group,
NULL, NULL, NULL, &consumed_modifiers);
accel_key = gdk_keyval_to_lower (event->keyval);
if (accel_key == GDK_ISO_Left_Tab)
accel_key = GDK_Tab;
accel_mods = event->state & gtk_accelerator_get_default_mod_mask ();
/* Filter consumed modifiers
*/
if (accel->accel_mode == GTK_CELL_RENDERER_ACCEL_MODE_GTK)
accel_mods &= ~consumed_modifiers;
/* Put shift back if it changed the case of the key, not otherwise.
*/
if (accel_key != event->keyval)
accel_mods |= GDK_SHIFT_MASK;
if (accel_mods == 0)
{
switch (event->keyval)
{
case GDK_Escape:
goto out; /* cancel */
case GDK_BackSpace:
/* clear the accelerator on Backspace */
cleared = TRUE;
goto out;
default:
break;
}
}
if (accel->accel_mode == GTK_CELL_RENDERER_ACCEL_MODE_GTK)
{
if (!gtk_accelerator_valid (accel_key, accel_mods))
{
gtk_widget_error_bell (widget);
return TRUE;
}
}
edited = TRUE;
out:
gdk_display_keyboard_ungrab (display, event->time);
gdk_display_pointer_ungrab (display, event->time);
path = g_strdup (g_object_get_data (G_OBJECT (accel->edit_widget), "gtk-cell-renderer-text"));
gtk_cell_editable_editing_done (GTK_CELL_EDITABLE (accel->edit_widget));
gtk_cell_editable_remove_widget (GTK_CELL_EDITABLE (accel->edit_widget));
accel->edit_widget = NULL;
accel->grab_widget = NULL;
if (edited)
g_signal_emit (accel, signals[ACCEL_EDITED], 0, path,
accel_key, accel_mods, event->hardware_keycode);
else if (cleared)
g_signal_emit (accel, signals[ACCEL_CLEARED], 0, path);
g_free (path);
return TRUE;
}
/**
* gdk_keymap_get_default:
*
* Returns the #GdkKeymap attached to the default display.
*
* Returns: (transfer none): the #GdkKeymap attached to the default display.
*/
GdkKeymap*
gdk_keymap_get_default (void)
{
return gdk_keymap_get_for_display (gdk_display_get_default ());
}
/* 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);
}
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;
}
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);
}
static gboolean grab_key_callback(GtkWidget* widget, GdkEventKey* event, void* data)
{
GdkModifierType accel_mods = 0;
guint accel_keyval;
EggCellRendererKeys *keys;
char *path;
gboolean edited;
gboolean cleared;
GdkModifierType consumed_modifiers;
guint upper;
GdkModifierType ignored_modifiers;
GdkDisplay *display;
GdkSeat *seat;
keys = EGG_CELL_RENDERER_KEYS(data);
if (is_modifier(event->hardware_keycode))
{
return TRUE;
}
edited = FALSE;
cleared = FALSE;
consumed_modifiers = 0;
gdk_keymap_translate_keyboard_state (gdk_keymap_get_for_display (gdk_display_get_default ()),
event->hardware_keycode,
event->state,
event->group,
NULL, NULL, NULL, &consumed_modifiers);
upper = event->keyval;
accel_keyval = gdk_keyval_to_lower(upper);
if (accel_keyval == GDK_KEY_ISO_Left_Tab)
{
accel_keyval = GDK_KEY_Tab;
}
/* Put shift back if it changed the case of the key, not otherwise. */
if (upper != accel_keyval && (consumed_modifiers & GDK_SHIFT_MASK))
{
consumed_modifiers &= ~(GDK_SHIFT_MASK);
}
egg_keymap_resolve_virtual_modifiers (gdk_keymap_get_for_display (gdk_display_get_default ()),
EGG_VIRTUAL_NUM_LOCK_MASK |
EGG_VIRTUAL_SCROLL_LOCK_MASK |
EGG_VIRTUAL_LOCK_MASK,
&ignored_modifiers);
/* http://bugzilla.gnome.org/show_bug.cgi?id=139605
* mouse keys should effect keybindings */
ignored_modifiers |= GDK_BUTTON1_MASK |
GDK_BUTTON2_MASK |
GDK_BUTTON3_MASK |
GDK_BUTTON4_MASK |
GDK_BUTTON5_MASK;
/* filter consumed/ignored modifiers */
if (keys->accel_mode == EGG_CELL_RENDERER_KEYS_MODE_GTK)
{
accel_mods = event->state & GDK_MODIFIER_MASK & ~(consumed_modifiers | ignored_modifiers);
}
else if (keys->accel_mode == EGG_CELL_RENDERER_KEYS_MODE_X)
{
accel_mods = event->state & GDK_MODIFIER_MASK & ~(ignored_modifiers);
}
else
{
g_assert_not_reached();
}
if (accel_mods == 0 && accel_keyval == GDK_KEY_Escape)
{
goto out; /* cancel */
}
/* clear the accelerator on Backspace */
if (accel_mods == 0 && accel_keyval == GDK_KEY_BackSpace)
{
cleared = TRUE;
goto out;
}
if (keys->accel_mode == EGG_CELL_RENDERER_KEYS_MODE_GTK)
{
if (!gtk_accelerator_valid (accel_keyval, accel_mods))
{
accel_keyval = 0;
accel_mods = 0;
}
}
edited = TRUE;
out:
display = gtk_widget_get_display (widget);
seat = gdk_display_get_default_seat (display);
gdk_seat_ungrab (seat);
path = g_strdup(g_object_get_data(G_OBJECT(keys->edit_widget), EGG_CELL_RENDERER_TEXT_PATH));
gtk_cell_editable_editing_done(GTK_CELL_EDITABLE(keys->edit_widget));
gtk_cell_editable_remove_widget(GTK_CELL_EDITABLE(keys->edit_widget));
keys->edit_widget = NULL;
keys->grab_widget = NULL;
if (edited)
{
g_signal_emit_by_name(G_OBJECT(keys), "accel_edited", path, accel_keyval, accel_mods, event->hardware_keycode);
}
else if (cleared)
{
g_signal_emit_by_name(G_OBJECT(keys), "accel_cleared", path);
}
g_free (path);
return TRUE;
}
gboolean keypress_cb( GtkWidget *widget, GdkEventKey *event, gpointer data )
{
gboolean wasConsumed = FALSE; /* default to report event not consumed */
EgeAdjustmentAction* action = EGE_ADJUSTMENT_ACTION(data);
guint key = 0;
gdk_keymap_translate_keyboard_state( gdk_keymap_get_for_display( gdk_display_get_default() ),
event->hardware_keycode, (GdkModifierType)event->state,
0, &key, 0, 0, 0 );
switch ( key ) {
case GDK_Escape:
{
action->private_data->transferFocus = TRUE;
gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), action->private_data->lastVal );
ege_adjustment_action_defocus( action );
wasConsumed = TRUE;
}
break;
case GDK_Return:
case GDK_KP_Enter:
{
action->private_data->transferFocus = TRUE;
ege_adjustment_action_defocus( action );
wasConsumed = TRUE;
}
break;
case GDK_Tab:
{
action->private_data->transferFocus = FALSE;
wasConsumed = process_tab( widget, 1 );
}
break;
case GDK_ISO_Left_Tab:
{
action->private_data->transferFocus = FALSE;
wasConsumed = process_tab( widget, -1 );
}
break;
case GDK_Up:
case GDK_KP_Up:
{
action->private_data->transferFocus = FALSE;
gdouble val = gtk_spin_button_get_value( GTK_SPIN_BUTTON(widget) );
gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), val + action->private_data->step );
wasConsumed = TRUE;
}
break;
case GDK_Down:
case GDK_KP_Down:
{
action->private_data->transferFocus = FALSE;
gdouble val = gtk_spin_button_get_value( GTK_SPIN_BUTTON(widget) );
gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), val - action->private_data->step );
wasConsumed = TRUE;
}
break;
case GDK_Page_Up:
case GDK_KP_Page_Up:
{
action->private_data->transferFocus = FALSE;
gdouble val = gtk_spin_button_get_value( GTK_SPIN_BUTTON(widget) );
gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), val + action->private_data->page );
wasConsumed = TRUE;
}
break;
case GDK_Page_Down:
case GDK_KP_Page_Down:
{
action->private_data->transferFocus = FALSE;
gdouble val = gtk_spin_button_get_value( GTK_SPIN_BUTTON(widget) );
gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), val - action->private_data->page );
wasConsumed = TRUE;
}
break;
case GDK_z:
case GDK_Z:
{
action->private_data->transferFocus = FALSE;
gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), action->private_data->lastVal );
wasConsumed = TRUE;
}
break;
}
return wasConsumed;
}
static VALUE
rg_s_for_display(G_GNUC_UNUSED VALUE self, VALUE display)
{
return GOBJ2RVAL(gdk_keymap_get_for_display(GDK_DISPLAY_OBJECT(RVAL2GOBJ(display))));
}