bool
NativeKeyBindings::Execute(const WidgetKeyboardEvent& aEvent,
DoCommandCallback aCallback,
void* aCallbackData)
{
// If the native key event is set, it must be synthesized for tests.
// We just ignore such events because this behavior depends on system
// settings.
if (!aEvent.mNativeKeyEvent) {
// It must be synthesized event or dispatched DOM event from chrome.
return false;
}
guint keyval;
if (aEvent.mCharCode) {
keyval = gdk_unicode_to_keyval(aEvent.mCharCode);
} else {
keyval =
static_cast<GdkEventKey*>(aEvent.mNativeKeyEvent)->keyval;
}
if (ExecuteInternal(aEvent, aCallback, aCallbackData, keyval)) {
return true;
}
for (uint32_t i = 0; i < aEvent.mAlternativeCharCodes.Length(); ++i) {
uint32_t ch = aEvent.IsShift() ?
aEvent.mAlternativeCharCodes[i].mShiftedCharCode :
aEvent.mAlternativeCharCodes[i].mUnshiftedCharCode;
if (ch && ch != aEvent.mCharCode) {
keyval = gdk_unicode_to_keyval(ch);
if (ExecuteInternal(aEvent, aCallback, aCallbackData, keyval)) {
return true;
}
}
}
/*
gtk_bindings_activate_event is preferable, but it has unresolved bug:
http://bugzilla.gnome.org/show_bug.cgi?id=162726
The bug was already marked as FIXED. However, somebody reports that the
bug still exists.
Also gtk_bindings_activate may work with some non-shortcuts operations
(todo: check it). See bug 411005 and bug 406407.
Code, which should be used after fixing GNOME bug 162726:
gtk_bindings_activate_event(GTK_OBJECT(mNativeTarget),
static_cast<GdkEventKey*>(aEvent.mNativeKeyEvent));
*/
return false;
}
static void load_status_cb(WebKitWebView* webView, GParamSpec* spec, gpointer data)
{
KeyEventFixture* fixture = (KeyEventFixture*)data;
WebKitLoadStatus status = webkit_web_view_get_load_status(webView);
if (status == WEBKIT_LOAD_FINISHED) {
gtk_test_widget_send_key(GTK_WIDGET(fixture->webView),
gdk_unicode_to_keyval('a'), 0);
}
}
static void test_blocking_load_status_cb(WebKitWebView* webView, GParamSpec* spec, gpointer data)
{
KeyEventFixture* fixture = (KeyEventFixture*)data;
WebKitLoadStatus status = webkit_web_view_get_load_status(webView);
if (status != WEBKIT_LOAD_FINISHED)
return;
// The first keypress event should not modify the field.
fixture->info->text = g_strdup("bc");
if (!gtk_test_widget_send_key(GTK_WIDGET(fixture->webView),
gdk_unicode_to_keyval('a'), 0))
g_assert_not_reached();
if (!gtk_test_widget_send_key(GTK_WIDGET(fixture->webView),
gdk_unicode_to_keyval('b'), 0))
g_assert_not_reached();
if (!gtk_test_widget_send_key(GTK_WIDGET(fixture->webView),
gdk_unicode_to_keyval('c'), 0))
g_assert_not_reached();
g_idle_add(verify_contents, fixture);
}
static void test_keypress_events_load_status_cb(WebKitWebView* webView, GParamSpec* spec, gpointer data)
{
KeyEventFixture* fixture = (KeyEventFixture*)data;
WebKitLoadStatus status = webkit_web_view_get_load_status(webView);
if (status == WEBKIT_LOAD_FINISHED) {
g_signal_connect(fixture->webView, "key-press-event",
G_CALLBACK(key_press_event_cb), fixture);
g_signal_connect(fixture->webView, "key-release-event",
G_CALLBACK(key_release_event_cb), fixture);
if (!gtk_test_widget_send_key(GTK_WIDGET(fixture->webView),
gdk_unicode_to_keyval('a'), 0))
g_assert_not_reached();
}
}
/* A key was pressed in locationbar */
static gboolean _interface_tweaks_on_key_press_event(GSignalInvocationHint *inHint,
guint inNumberParams,
const GValue *inParams,
gpointer inUserData)
{
g_return_val_if_fail(GTK_IS_ENTRY(inUserData), FALSE);
GtkEntry *entry=GTK_ENTRY(inUserData);
GtkWidget *target;
GdkEventKey *event;
guint changedSignalID;
GSList *handlers;
/* Get target of this event and check if it is for locationbar entry */
target=GTK_WIDGET(g_value_get_object(inParams));
if(target==GTK_WIDGET(entry))
{
/* Get key-event data */
inParams++;
event=(GdkEventKey*)g_value_get_boxed(inParams);
/* Check if key-event would _not_ add any characters */
if(!(gdk_keyval_is_upper(event->keyval)==gdk_keyval_is_lower(event->keyval) &&
gdk_unicode_to_keyval(gdk_keyval_to_unicode(event->keyval))!=event->keyval))
{
/* Get "changed" signal ID */
changedSignalID=g_signal_lookup("changed", GTK_TYPE_ENTRY);
/* Block all unblocked signal handlers for "changed" signal, remove selected
* text region from entry text and unblock these signal handlers again.
* This way we keep Midori's auto-completion working. Otherwise it fetches the
* complete entry text with the text portion in selected text region and adds
* the pressed key to it which results in a completely wrong text for auto-completion.
*/
handlers=_interface_tweaks_block_all_handlers(G_OBJECT(entry), changedSignalID);
gtk_editable_delete_selection(GTK_EDITABLE(entry));
_interface_tweaks_unblock_handlers(G_OBJECT(entry), handlers);
g_slist_free(handlers);
}
}
return(TRUE);
}
void gtksendkey(sPlayerInterface* player_interf,int keycode)
{
TRACEINFO;
GdkEvent *KeyEvent;
fprintf(stderr, "\x1b[%i;3%imKeyCode\x1b[0m: %d\n",1, 4,keycode);
KeyEvent = gdk_event_new (GDK_KEY_PRESS);
/* Key Value */
KeyEvent->key.keyval = gdk_unicode_to_keyval(keycode);
/* GDK_BUTTON1_MASK refers to left mouse button */
KeyEvent->key.state = GDK_BUTTON1_MASK;
/* Send the key event to Web Window */
KeyEvent->key.window = player_interf->ui->pWebWindow->window;
gtk_main_do_event (KeyEvent);
//gdk_event_free(KeyEvent);
}
static JSValueRef runPasteTestCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
{
gtk_widget_grab_focus(GTK_WIDGET(currentFixture->webView));
// Simulate a paste keyboard sequence.
GdkEvent* event = gdk_event_new(GDK_KEY_PRESS);
event->key.keyval = gdk_unicode_to_keyval('v');
event->key.state = GDK_CONTROL_MASK;
event->key.window = gtk_widget_get_window(GTK_WIDGET(currentFixture->webView));
g_object_ref(event->key.window);
#ifndef GTK_API_VERSION_2
GdkDeviceManager* manager = gdk_display_get_device_manager(gdk_window_get_display(event->key.window));
gdk_event_set_device(event, gdk_device_manager_get_client_pointer(manager));
#endif
GdkKeymapKey* keys;
gint n_keys;
if (gdk_keymap_get_entries_for_keyval(gdk_keymap_get_default(), event->key.keyval, &keys, &n_keys)) {
event->key.hardware_keycode = keys[0].keycode;
g_free(keys);
}
gtk_main_do_event(event);
event->key.type = GDK_KEY_RELEASE;
gtk_main_do_event(event);
gdk_event_free(event);
JSStringRef scriptString = JSStringCreateWithUTF8CString("document.body.innerHTML;");
JSValueRef value = JSEvaluateScript(context, scriptString, 0, 0, 0, 0);
JSStringRelease(scriptString);
g_assert(JSValueIsString(context, value));
JSStringRef actual = JSValueToStringCopy(context, value, exception);
g_assert(!exception || !*exception);
g_assert(currentFixture->info->expectedContent);
JSStringRef expected = JSStringCreateWithUTF8CString(currentFixture->info->expectedContent);
g_assert(JSStringIsEqual(expected, actual));
JSStringRelease(expected);
JSStringRelease(actual);
g_main_loop_quit(currentFixture->loop);
return JSValueMakeUndefined(context);
}
bool tmKey::uniToWxk(wxChar uniCode, int& wxk, int& mod) // static
{
#ifdef __WXMSW__
// Convert key to scan code
const SHORT scancode = ::VkKeyScan(uniCode);
const unsigned char vk = LOBYTE(scancode); // Low eight bits = virtual-key code
const int state = HIBYTE(scancode); // The next eight bits = shift state
if (state & 1) mod |= wxMOD_SHIFT;
if (state & 2) mod |= wxMOD_CONTROL;
if (state & 4) mod |= wxMOD_ALT;
wxk = wxCharCodeMSWToWX(vk, 0);
if (wxk == 0) {
// Normal ascii char
// Note that this is set to the virtual keycode (which does not necessarily
// correspond to the ascii value). This is needed because keydown events
// report it in this format.
wxk = vk;
}
return true;
#elif defined(__WXGTK__)
guint keyval = gdk_unicode_to_keyval(uniCode);
if (keyval & 0x01000000)
return false;
if (gdk_keyval_is_upper(keyval))
{
mod |= wxMOD_SHIFT;
keyval = gdk_keyval_to_lower(keyval);
#ifdef __WXDEBUG__
wxLogDebug(wxT("uniToWxk(%x - %c) downshifting keycode is %x"), uniCode, uniCode, keyval);
#endif //__WXDEBUG__
}
// FIXME not too correct - this is wxChar not wxKeyCode
wxk = gdk_keyval_to_unicode(keyval);
#ifdef __WXDEBUG__
wxLogDebug(wxT("uniToWxk(%x - %c) to %x - %c"), uniCode, uniCode, wxk, wxk);
#endif //__WXDEBUG__
return true;
#else
#error Unknown platform
#endif
}
bool tmKey::wxkToUni(int wxk, bool shifted, wxChar& uniCode) // static
{
if (!wxIsprint(wxk))
return false;
#ifdef __WXMSW__
// Convert key to scan code
const SHORT scancode = ::VkKeyScan(wxk);
const unsigned char vk = LOBYTE(scancode); // Low eight bits = virtual-key code
// Get the char on the key for this keycode
unsigned char key_state[256];
memset (key_state, 0, sizeof (key_state));
const int BUFFER_SIZE = 10;
if (shifted)
key_state[VK_SHIFT] = 0x80;
TCHAR buf[BUFFER_SIZE] = { 0 };
if (::ToUnicode(vk, 0, key_state, buf, BUFFER_SIZE, 0) != 1)
return false;
uniCode = buf[0];
return true;
#elif defined(__WXGTK__)
// FIXME not too correct - this is wxKeyCode not wxChar
guint keyval = gdk_unicode_to_keyval(wxk);
if (keyval & 0x01000000)
return false;
keyval = shifted ? gdk_keyval_to_upper(keyval) : gdk_keyval_to_lower(keyval);
uniCode = gdk_keyval_to_unicode(keyval);
#ifdef __WXDEBUG__
wxLogDebug(wxT("wxkToUni(%x- %c,%d) to %x - %c"), wxk, wxk, shifted, uniCode, uniCode);
#endif //__WXDEBUG__
return true;
#else
#error Unknown platform
#endif
}
static void test_xim_load_status_cb(WebKitWebView* webView, GParamSpec* spec, gpointer data)
{
KeyEventFixture* fixture = (KeyEventFixture*)data;
WebKitLoadStatus status = webkit_web_view_get_load_status(webView);
if (status != WEBKIT_LOAD_FINISHED)
return;
GtkIMContext* imContext = 0;
g_object_get(webView, "im-context", &imContext, NULL);
g_assert(imContext);
gchar* originalId = g_strdup(gtk_im_multicontext_get_context_id(GTK_IM_MULTICONTEXT(imContext)));
gtk_im_multicontext_set_context_id(GTK_IM_MULTICONTEXT(imContext), "xim");
// Test that commits that happen outside of key events
// change the text field immediately. This closely replicates
// the behavior of SCIM.
fixture->info->text = g_strdup("debian");
if (!gtk_test_widget_send_key(GTK_WIDGET(fixture->webView),
gdk_unicode_to_keyval('d'), 0))
g_assert_not_reached();
if (!gtk_test_widget_send_key(GTK_WIDGET(fixture->webView),
gdk_unicode_to_keyval('e'), 0))
g_assert_not_reached();
if (!gtk_test_widget_send_key(GTK_WIDGET(fixture->webView),
gdk_unicode_to_keyval('b'), 0))
g_assert_not_reached();
if (!gtk_test_widget_send_key(GTK_WIDGET(fixture->webView),
gdk_unicode_to_keyval('i'), 0))
g_assert_not_reached();
if (!gtk_test_widget_send_key(GTK_WIDGET(fixture->webView),
gdk_unicode_to_keyval('a'), 0))
g_assert_not_reached();
if (!gtk_test_widget_send_key(GTK_WIDGET(fixture->webView),
gdk_unicode_to_keyval('n'), 0))
g_assert_not_reached();
gtk_im_multicontext_set_context_id(GTK_IM_MULTICONTEXT(imContext), originalId);
g_free(originalId);
g_object_unref(imContext);
g_idle_add(verify_contents, fixture);
}
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);
}
/**
* gdk_keyval_convert_case:
* @symbol: a keyval
* @lower: (out): return location for lowercase version of @symbol
* @upper: (out): return location for uppercase version of @symbol
*
* Obtains the upper- and lower-case versions of the keyval @symbol.
* Examples of keyvals are #GDK_KEY_a, #GDK_KEY_Enter, #GDK_KEY_F1, etc.
*/
void
gdk_keyval_convert_case (guint symbol,
guint *lower,
guint *upper)
{
guint xlower, xupper;
xlower = symbol;
xupper = symbol;
/* Check for directly encoded 24-bit UCS characters: */
if ((symbol & 0xff000000) == 0x01000000)
{
if (lower)
*lower = gdk_unicode_to_keyval (g_unichar_tolower (symbol & 0x00ffffff));
if (upper)
*upper = gdk_unicode_to_keyval (g_unichar_toupper (symbol & 0x00ffffff));
return;
}
switch (symbol >> 8)
{
case 0: /* Latin 1 */
if ((symbol >= GDK_KEY_A) && (symbol <= GDK_KEY_Z))
xlower += (GDK_KEY_a - GDK_KEY_A);
else if ((symbol >= GDK_KEY_a) && (symbol <= GDK_KEY_z))
xupper -= (GDK_KEY_a - GDK_KEY_A);
else if ((symbol >= GDK_KEY_Agrave) && (symbol <= GDK_KEY_Odiaeresis))
xlower += (GDK_KEY_agrave - GDK_KEY_Agrave);
else if ((symbol >= GDK_KEY_agrave) && (symbol <= GDK_KEY_odiaeresis))
xupper -= (GDK_KEY_agrave - GDK_KEY_Agrave);
else if ((symbol >= GDK_KEY_Ooblique) && (symbol <= GDK_KEY_Thorn))
xlower += (GDK_KEY_oslash - GDK_KEY_Ooblique);
else if ((symbol >= GDK_KEY_oslash) && (symbol <= GDK_KEY_thorn))
xupper -= (GDK_KEY_oslash - GDK_KEY_Ooblique);
break;
case 1: /* Latin 2 */
/* Assume the KeySym is a legal value (ignore discontinuities) */
if (symbol == GDK_KEY_Aogonek)
xlower = GDK_KEY_aogonek;
else if (symbol >= GDK_KEY_Lstroke && symbol <= GDK_KEY_Sacute)
xlower += (GDK_KEY_lstroke - GDK_KEY_Lstroke);
else if (symbol >= GDK_KEY_Scaron && symbol <= GDK_KEY_Zacute)
xlower += (GDK_KEY_scaron - GDK_KEY_Scaron);
else if (symbol >= GDK_KEY_Zcaron && symbol <= GDK_KEY_Zabovedot)
xlower += (GDK_KEY_zcaron - GDK_KEY_Zcaron);
else if (symbol == GDK_KEY_aogonek)
xupper = GDK_KEY_Aogonek;
else if (symbol >= GDK_KEY_lstroke && symbol <= GDK_KEY_sacute)
xupper -= (GDK_KEY_lstroke - GDK_KEY_Lstroke);
else if (symbol >= GDK_KEY_scaron && symbol <= GDK_KEY_zacute)
xupper -= (GDK_KEY_scaron - GDK_KEY_Scaron);
else if (symbol >= GDK_KEY_zcaron && symbol <= GDK_KEY_zabovedot)
xupper -= (GDK_KEY_zcaron - GDK_KEY_Zcaron);
else if (symbol >= GDK_KEY_Racute && symbol <= GDK_KEY_Tcedilla)
xlower += (GDK_KEY_racute - GDK_KEY_Racute);
else if (symbol >= GDK_KEY_racute && symbol <= GDK_KEY_tcedilla)
xupper -= (GDK_KEY_racute - GDK_KEY_Racute);
break;
case 2: /* Latin 3 */
/* Assume the KeySym is a legal value (ignore discontinuities) */
if (symbol >= GDK_KEY_Hstroke && symbol <= GDK_KEY_Hcircumflex)
xlower += (GDK_KEY_hstroke - GDK_KEY_Hstroke);
else if (symbol >= GDK_KEY_Gbreve && symbol <= GDK_KEY_Jcircumflex)
xlower += (GDK_KEY_gbreve - GDK_KEY_Gbreve);
else if (symbol >= GDK_KEY_hstroke && symbol <= GDK_KEY_hcircumflex)
xupper -= (GDK_KEY_hstroke - GDK_KEY_Hstroke);
else if (symbol >= GDK_KEY_gbreve && symbol <= GDK_KEY_jcircumflex)
xupper -= (GDK_KEY_gbreve - GDK_KEY_Gbreve);
else if (symbol >= GDK_KEY_Cabovedot && symbol <= GDK_KEY_Scircumflex)
xlower += (GDK_KEY_cabovedot - GDK_KEY_Cabovedot);
else if (symbol >= GDK_KEY_cabovedot && symbol <= GDK_KEY_scircumflex)
xupper -= (GDK_KEY_cabovedot - GDK_KEY_Cabovedot);
break;
case 3: /* Latin 4 */
/* Assume the KeySym is a legal value (ignore discontinuities) */
if (symbol >= GDK_KEY_Rcedilla && symbol <= GDK_KEY_Tslash)
xlower += (GDK_KEY_rcedilla - GDK_KEY_Rcedilla);
else if (symbol >= GDK_KEY_rcedilla && symbol <= GDK_KEY_tslash)
xupper -= (GDK_KEY_rcedilla - GDK_KEY_Rcedilla);
else if (symbol == GDK_KEY_ENG)
xlower = GDK_KEY_eng;
else if (symbol == GDK_KEY_eng)
xupper = GDK_KEY_ENG;
else if (symbol >= GDK_KEY_Amacron && symbol <= GDK_KEY_Umacron)
xlower += (GDK_KEY_amacron - GDK_KEY_Amacron);
else if (symbol >= GDK_KEY_amacron && symbol <= GDK_KEY_umacron)
xupper -= (GDK_KEY_amacron - GDK_KEY_Amacron);
break;
case 6: /* Cyrillic */
/* Assume the KeySym is a legal value (ignore discontinuities) */
if (symbol >= GDK_KEY_Serbian_DJE && symbol <= GDK_KEY_Serbian_DZE)
xlower -= (GDK_KEY_Serbian_DJE - GDK_KEY_Serbian_dje);
else if (symbol >= GDK_KEY_Serbian_dje && symbol <= GDK_KEY_Serbian_dze)
xupper += (GDK_KEY_Serbian_DJE - GDK_KEY_Serbian_dje);
else if (symbol >= GDK_KEY_Cyrillic_YU && symbol <= GDK_KEY_Cyrillic_HARDSIGN)
xlower -= (GDK_KEY_Cyrillic_YU - GDK_KEY_Cyrillic_yu);
else if (symbol >= GDK_KEY_Cyrillic_yu && symbol <= GDK_KEY_Cyrillic_hardsign)
xupper += (GDK_KEY_Cyrillic_YU - GDK_KEY_Cyrillic_yu);
break;
case 7: /* Greek */
/* Assume the KeySym is a legal value (ignore discontinuities) */
if (symbol >= GDK_KEY_Greek_ALPHAaccent && symbol <= GDK_KEY_Greek_OMEGAaccent)
xlower += (GDK_KEY_Greek_alphaaccent - GDK_KEY_Greek_ALPHAaccent);
else if (symbol >= GDK_KEY_Greek_alphaaccent && symbol <= GDK_KEY_Greek_omegaaccent &&
symbol != GDK_KEY_Greek_iotaaccentdieresis &&
symbol != GDK_KEY_Greek_upsilonaccentdieresis)
xupper -= (GDK_KEY_Greek_alphaaccent - GDK_KEY_Greek_ALPHAaccent);
else if (symbol >= GDK_KEY_Greek_ALPHA && symbol <= GDK_KEY_Greek_OMEGA)
xlower += (GDK_KEY_Greek_alpha - GDK_KEY_Greek_ALPHA);
else if (symbol >= GDK_KEY_Greek_alpha && symbol <= GDK_KEY_Greek_omega &&
symbol != GDK_KEY_Greek_finalsmallsigma)
xupper -= (GDK_KEY_Greek_alpha - GDK_KEY_Greek_ALPHA);
break;
default:
break;
}
if (lower)
*lower = xlower;
if (upper)
*upper = xupper;
}
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;
}
int getGDKKeySymForKeyRef(WKStringRef keyRef, unsigned location, guint* modifiers)
{
if (location == DOMKeyLocationNumpad) {
if (WKStringIsEqualToUTF8CString(keyRef, "leftArrow"))
return GDK_KEY_KP_Left;
if (WKStringIsEqualToUTF8CString(keyRef, "rightArror"))
return GDK_KEY_KP_Right;
if (WKStringIsEqualToUTF8CString(keyRef, "upArrow"))
return GDK_KEY_KP_Up;
if (WKStringIsEqualToUTF8CString(keyRef, "downArrow"))
return GDK_KEY_KP_Down;
if (WKStringIsEqualToUTF8CString(keyRef, "pageUp"))
return GDK_KEY_KP_Page_Up;
if (WKStringIsEqualToUTF8CString(keyRef, "pageDown"))
return GDK_KEY_KP_Page_Down;
if (WKStringIsEqualToUTF8CString(keyRef, "home"))
return GDK_KEY_KP_Home;
if (WKStringIsEqualToUTF8CString(keyRef, "end"))
return GDK_KEY_KP_End;
if (WKStringIsEqualToUTF8CString(keyRef, "insert"))
return GDK_KEY_KP_Insert;
if (WKStringIsEqualToUTF8CString(keyRef, "delete"))
return GDK_KEY_KP_Delete;
return GDK_KEY_VoidSymbol;
}
if (WKStringIsEqualToUTF8CString(keyRef, "leftArrow"))
return GDK_KEY_Left;
if (WKStringIsEqualToUTF8CString(keyRef, "rightArrow"))
return GDK_KEY_Right;
if (WKStringIsEqualToUTF8CString(keyRef, "upArrow"))
return GDK_KEY_Up;
if (WKStringIsEqualToUTF8CString(keyRef, "downArrow"))
return GDK_KEY_Down;
if (WKStringIsEqualToUTF8CString(keyRef, "pageUp"))
return GDK_KEY_Page_Up;
if (WKStringIsEqualToUTF8CString(keyRef, "pageDown"))
return GDK_KEY_Page_Down;
if (WKStringIsEqualToUTF8CString(keyRef, "home"))
return GDK_KEY_Home;
if (WKStringIsEqualToUTF8CString(keyRef, "end"))
return GDK_KEY_End;
if (WKStringIsEqualToUTF8CString(keyRef, "insert"))
return GDK_KEY_Insert;
if (WKStringIsEqualToUTF8CString(keyRef, "delete"))
return GDK_KEY_Delete;
if (WKStringIsEqualToUTF8CString(keyRef, "printScreen"))
return GDK_KEY_Print;
if (WKStringIsEqualToUTF8CString(keyRef, "menu"))
return GDK_KEY_Menu;
if (WKStringIsEqualToUTF8CString(keyRef, "F1"))
return GDK_KEY_F1;
if (WKStringIsEqualToUTF8CString(keyRef, "F2"))
return GDK_KEY_F2;
if (WKStringIsEqualToUTF8CString(keyRef, "F3"))
return GDK_KEY_F3;
if (WKStringIsEqualToUTF8CString(keyRef, "F4"))
return GDK_KEY_F4;
if (WKStringIsEqualToUTF8CString(keyRef, "F5"))
return GDK_KEY_F5;
if (WKStringIsEqualToUTF8CString(keyRef, "F6"))
return GDK_KEY_F6;
if (WKStringIsEqualToUTF8CString(keyRef, "F7"))
return GDK_KEY_F7;
if (WKStringIsEqualToUTF8CString(keyRef, "F8"))
return GDK_KEY_F8;
if (WKStringIsEqualToUTF8CString(keyRef, "F9"))
return GDK_KEY_F9;
if (WKStringIsEqualToUTF8CString(keyRef, "F10"))
return GDK_KEY_F10;
if (WKStringIsEqualToUTF8CString(keyRef, "F11"))
return GDK_KEY_F11;
if (WKStringIsEqualToUTF8CString(keyRef, "F12"))
return GDK_KEY_F12;
size_t bufferSize = WKStringGetMaximumUTF8CStringSize(keyRef);
OwnArrayPtr<char> buffer = adoptArrayPtr(new char[bufferSize]);
WKStringGetUTF8CString(keyRef, buffer.get(), bufferSize);
char charCode = buffer.get()[0];
if (charCode == '\n' || charCode == '\r')
return GDK_KEY_Return;
if (charCode == '\t')
return GDK_KEY_Tab;
if (charCode == '\x8')
return GDK_KEY_BackSpace;
if (WTF::isASCIIUpper(charCode))
*modifiers |= GDK_SHIFT_MASK;
return gdk_unicode_to_keyval(static_cast<guint32>(buffer.get()[0]));
}
gboolean
gom_keyboard_evt_key_identifier_to_keyval (const char *key_identifier,
GomKeyLocationCode key_location,
guint *keyval)
{
static GOnce in_a_lifetime = G_ONCE_INIT;
KeyIdentifierCodes *codes;
GHashTable *ht;
if (key_location < GOM_DOM_KEY_LOCATION_STANDARD || key_location > GOM_DOM_KEY_LOCATION_NUMPAD) {
return FALSE;
}
ht = g_once (&in_a_lifetime, key_identifier_to_keyval_once, NULL);
codes = g_hash_table_lookup (ht, key_identifier);
if (codes) {
switch (key_location) {
case GOM_DOM_KEY_LOCATION_STANDARD:
*keyval = codes->standard;
break;
case GOM_DOM_KEY_LOCATION_LEFT:
*keyval = codes->left;
break;
case GOM_DOM_KEY_LOCATION_RIGHT:
*keyval = codes->right;
break;
case GOM_DOM_KEY_LOCATION_NUMPAD:
*keyval = codes->numpad;
break;
}
if (*keyval) {
return TRUE;
}
}
if (key_identifier[0] != 'U' || key_identifier[1] != '+') {
return FALSE;
}
*keyval = strtol (&key_identifier[2], NULL, 16);
if (!*keyval) {
return FALSE;
}
*keyval = gdk_unicode_to_keyval (*keyval);
codes = g_new0 (KeyIdentifierCodes, 1);
codes->id = g_strdup (key_identifier);
switch (key_location) {
case GOM_DOM_KEY_LOCATION_STANDARD:
codes->standard = *keyval;
break;
case GOM_DOM_KEY_LOCATION_LEFT:
codes->left = *keyval;
break;
case GOM_DOM_KEY_LOCATION_RIGHT:
codes->right = *keyval;
break;
case GOM_DOM_KEY_LOCATION_NUMPAD:
codes->numpad = *keyval;
break;
}
g_hash_table_insert (ht, (gpointer)codes->id, codes);
return TRUE;
}
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);
}
void
uGlobalMenuItem::SyncAccelFromContent()
{
if (!mKeyContent) {
dbusmenu_menuitem_property_remove(mDbusMenuItem,
DBUSMENU_MENUITEM_PROP_SHORTCUT);
return;
}
nsAutoString modStr;
mKeyContent->GetAttr(kNameSpaceID_None, uWidgetAtoms::modifiers, modStr);
PRUint32 modifier = 0;
if (!modStr.IsEmpty()) {
char* str = ToNewUTF8String(modStr);
char *token = strtok(str, ", \t");
while(token) {
if (strcmp(token, "shift") == 0) {
modifier |= GDK_SHIFT_MASK;
} else if (strcmp(token, "alt") == 0) {
modifier |= GDK_MOD1_MASK;
} else if (strcmp(token, "meta") == 0) {
modifier |= GDK_META_MASK;
} else if (strcmp(token, "control") == 0) {
modifier |= GDK_CONTROL_MASK;
} else if (strcmp(token, "accel") == 0) {
nsIPrefBranch *prefs = uGlobalMenuService::GetPrefService();
PRInt32 accel;
prefs->GetIntPref("ui.key.accelKey", &accel);
if (accel == nsIDOMKeyEvent::DOM_VK_META) {
modifier |= GDK_META_MASK;
} else if (accel == nsIDOMKeyEvent::DOM_VK_ALT) {
modifier |= GDK_MOD1_MASK;
} else {
modifier |= GDK_CONTROL_MASK;
}
}
token = strtok(nullptr, ", \t");
}
nsMemory::Free(str);
}
nsAutoString keyStr;
guint key = 0;
mKeyContent->GetAttr(kNameSpaceID_None, uWidgetAtoms::key, keyStr);
nsAutoCString cKeyStr;
CopyUTF16toUTF8(keyStr, cKeyStr);
if (!cKeyStr.IsEmpty()) {
key = gdk_keyval_from_name(cKeyStr.get());
}
if (key == 0 && !keyStr.IsEmpty()) {
key = gdk_unicode_to_keyval(*keyStr.BeginReading());
}
if (key == 0) {
mKeyContent->GetAttr(kNameSpaceID_None, uWidgetAtoms::keycode, keyStr);
if (!keyStr.IsEmpty())
key = MozKeyCodeToGdkKeyCode(GetKeyCode(keyStr));
}
if (key == 0) {
key = GDK_VoidSymbol;
}
if (key != GDK_VoidSymbol) {
dbusmenu_menuitem_property_set_shortcut(mDbusMenuItem, key,
static_cast<GdkModifierType>(modifier));
} else {
dbusmenu_menuitem_property_remove(mDbusMenuItem,
DBUSMENU_MENUITEM_PROP_SHORTCUT);
}
}
static void
update_keymap (void)
{
static guint current_serial = 0;
guchar key_state[256];
guint scancode;
guint vk;
gboolean capslock_tested = FALSE;
if (keysym_tab != NULL && current_serial == _gdk_keymap_serial)
return;
current_serial = _gdk_keymap_serial;
if (keysym_tab == NULL)
keysym_tab = g_new (guint, 4*256);
memset (key_state, 0, sizeof (key_state));
_gdk_keyboard_has_altgr = FALSE;
gdk_shift_modifiers = GDK_SHIFT_MASK;
for (vk = 0; vk < 256; vk++)
{
if ((scancode = MapVirtualKey (vk, 0)) == 0 &&
vk != VK_DIVIDE)
keysym_tab[vk*4+0] =
keysym_tab[vk*4+1] =
keysym_tab[vk*4+2] =
keysym_tab[vk*4+3] = GDK_VoidSymbol;
else
{
gint shift;
if (vk == VK_RSHIFT)
_scancode_rshift = scancode;
key_state[vk] = 0x80;
for (shift = 0; shift < 4; shift++)
{
guint *ksymp = keysym_tab + vk*4 + shift;
set_shift_vks (key_state, shift);
*ksymp = 0;
/* First, handle those virtual keys that we always want
* as special GDK_* keysyms, even if ToAsciiEx might
* turn some them into a ASCII character (like TAB and
* ESC).
*/
handle_special (vk, ksymp, shift);
if (*ksymp == 0)
{
wchar_t wcs[10];
gint k;
wcs[0] = wcs[1] = 0;
k = ToUnicodeEx (vk, scancode, key_state,
wcs, G_N_ELEMENTS (wcs),
0, _gdk_input_locale);
#if 0
g_print ("ToUnicodeEx(%#02x, %d: %d): %d, %04x %04x\n",
vk, scancode, shift, k,
wcs[0], wcs[1]);
#endif
if (k == 1)
*ksymp = gdk_unicode_to_keyval (wcs[0]);
else if (k == -1)
{
guint keysym = gdk_unicode_to_keyval (wcs[0]);
/* It is a dead key, and it's has been stored in
* the keyboard layout's state by
* ToAsciiEx()/ToUnicodeEx(). Yes, this is an
* incredibly silly API! Make the keyboard
* layout forget it by calling
* ToAsciiEx()/ToUnicodeEx() once more, with the
* virtual key code and scancode for the
* spacebar, without shift or AltGr. Otherwise
* the next call to ToAsciiEx() with a different
* key would try to combine with the dead key.
*/
reset_after_dead (key_state);
/* Use dead keysyms instead of "undead" ones */
handle_dead (keysym, ksymp);
}
else if (k == 0)
{
/* Seems to be necessary to "reset" the keyboard layout
* in this case, too. Otherwise problems on NT4.
*/
reset_after_dead (key_state);
}
else
{
#if 0
GDK_NOTE (EVENTS,
g_print ("ToUnicodeEx returns %d "
"for vk:%02x, sc:%02x%s%s\n",
k, vk, scancode,
(shift&0x1 ? " shift" : ""),
(shift&0x2 ? " altgr" : "")));
#endif
}
}
if (*ksymp == 0)
*ksymp = GDK_VoidSymbol;
}
key_state[vk] = 0;
/* Check if keyboard has an AltGr key by checking if
* the mapping with Control+Alt is different.
*/
if (!_gdk_keyboard_has_altgr)
if ((keysym_tab[vk*4 + 2] != GDK_VoidSymbol &&
keysym_tab[vk*4] != keysym_tab[vk*4 + 2]) ||
(keysym_tab[vk*4 + 3] != GDK_VoidSymbol &&
keysym_tab[vk*4 + 1] != keysym_tab[vk*4 + 3]))
_gdk_keyboard_has_altgr = TRUE;
if (!capslock_tested)
{
/* Can we use this virtual key to determine the CapsLock
* key behaviour: CapsLock or ShiftLock? If it generates
* keysyms for printable characters and has a shifted
* keysym that isn't just the upperacase of the
* unshifted keysym, check the behaviour of VK_CAPITAL.
*/
if (g_unichar_isgraph (gdk_keyval_to_unicode (keysym_tab[vk*4 + 0])) &&
keysym_tab[vk*4 + 1] != keysym_tab[vk*4 + 0] &&
g_unichar_isgraph (gdk_keyval_to_unicode (keysym_tab[vk*4 + 1])) &&
keysym_tab[vk*4 + 1] != gdk_keyval_to_upper (keysym_tab[vk*4 + 0]))
{
guchar chars[2];
capslock_tested = TRUE;
key_state[VK_SHIFT] = 0;
key_state[VK_CONTROL] = key_state[VK_MENU] = 0;
key_state[VK_CAPITAL] = 1;
if (ToAsciiEx (vk, scancode, key_state,
(LPWORD) chars, 0, _gdk_input_locale) == 1)
{
if (chars[0] >= GDK_space &&
chars[0] <= GDK_asciitilde &&
chars[0] == keysym_tab[vk*4 + 1])
{
/* CapsLock acts as ShiftLock */
gdk_shift_modifiers |= GDK_LOCK_MASK;
}
}
key_state[VK_CAPITAL] = 0;
}
}
}
}
GDK_NOTE (EVENTS, print_keysym_tab ());
}