static gboolean inputs(GtkWidget *widget, GdkEventKey *event,
gpointer data)
{
t_env *rt;
rt = (t_env *)data;
if (!ft_strcmp(gdk_keyval_name(event->keyval), "Return"))
save_file(widget, rt);
else if (!ft_strcmp(gdk_keyval_name(event->keyval), "Escape"))
exit(0);
return (0);
}
/* static */ void
KeymapWrapper::InitKeyEvent(nsKeyEvent& aKeyEvent,
GdkEventKey* aGdkKeyEvent)
{
KeymapWrapper* keymapWrapper = GetInstance();
aKeyEvent.keyCode = ComputeDOMKeyCode(aGdkKeyEvent);
// NOTE: The state of given key event indicates adjacent state of
// modifier keys. E.g., even if the event is Shift key press event,
// the bit for Shift is still false. By the same token, even if the
// event is Shift key release event, the bit for Shift is still true.
// Unfortunately, gdk_keyboard_get_modifiers() returns current modifier
// state. It means if there're some pending modifier key press or
// key release events, the result isn't what we want.
// Temporarily, we should compute the state only when the key event
// is GDK_KEY_PRESS.
// XXX If we could know the modifier keys state at the key release event,
// we should cut out changingMask from modifierState.
guint modifierState = aGdkKeyEvent->state;
if (aGdkKeyEvent->is_modifier && aGdkKeyEvent->type == GDK_KEY_PRESS) {
ModifierKey* modifierKey =
keymapWrapper->GetModifierKey(aGdkKeyEvent->hardware_keycode);
if (modifierKey) {
// If new modifier key is pressed, add the pressed mod mask.
modifierState |= modifierKey->mMask;
}
}
InitInputEvent(aKeyEvent, modifierState);
PR_LOG(gKeymapWrapperLog, PR_LOG_ALWAYS,
("KeymapWrapper(%p): InitKeyEvent, modifierState=0x%08X "
"aGdkKeyEvent={ type=%s, keyval=%s(0x%X), state=0x%08X, "
"hardware_keycode=0x%08X, is_modifier=%s } "
"aKeyEvent={ message=%s, isShift=%s, isControl=%s, "
"isAlt=%s, isMeta=%s }",
keymapWrapper, modifierState,
((aGdkKeyEvent->type == GDK_KEY_PRESS) ?
"GDK_KEY_PRESS" : "GDK_KEY_RELEASE"),
gdk_keyval_name(aGdkKeyEvent->keyval),
aGdkKeyEvent->keyval, aGdkKeyEvent->state,
aGdkKeyEvent->hardware_keycode,
GetBoolName(aGdkKeyEvent->is_modifier),
((aKeyEvent.message == NS_KEY_DOWN) ? "NS_KEY_DOWN" :
(aKeyEvent.message == NS_KEY_PRESS) ? "NS_KEY_PRESS" :
"NS_KEY_UP"),
GetBoolName(aKeyEvent.isShift), GetBoolName(aKeyEvent.isControl),
GetBoolName(aKeyEvent.isAlt), GetBoolName(aKeyEvent.isMeta)));
if (aKeyEvent.message == NS_KEY_PRESS) {
keymapWrapper->InitKeypressEvent(aKeyEvent, aGdkKeyEvent);
}
// The transformations above and in gdk for the keyval are not invertible
// so link to the GdkEvent (which will vanish soon after return from the
// event callback) to give plugins access to hardware_keycode and state.
// (An XEvent would be nice but the GdkEvent is good enough.)
aKeyEvent.pluginEvent = (void *)aGdkKeyEvent;
aKeyEvent.time = aGdkKeyEvent->time;
}
static gboolean key(GtkWidget *widget, GdkEventKey *event, gpointer data) {
M6502 *mpu = (M6502 *) data;
Strudel* mb = (Strudel *) mpu->ext;
guint32 u = 0;
gchar *s = NULL;
s = gdk_keyval_name(event->keyval);
u = gdk_keyval_to_unicode(event->keyval);
g_print("Key press event: %s (%d)\n", s, u);
if (u == 0) {
if (strcmp(s, "BackSpace") == 0)
u = 0x8;
else if (strcmp(s, "Return") == 0)
u = '\r';
} else if (event->state & GDK_CONTROL_MASK) {
u %= 32;
}
if (u > 0 && u < 128) {
if (u == 3) {
g_print("Interrupt\n");
M6502_do(mpu, M6502_IRQ);
} else if (mb->keyr - mb->keyw != 1) {
mb->key[mb->keyw++] = u % 128;
}
}
return TRUE;
}
void visit(const char* name, Accelerator& accelerator)
{
m_file << name << "=";
const char* key = global_keys_find(accelerator.key);
if(!string_empty(key))
{
m_file << key;
}
else if(accelerator.key != 0)
{
m_file << gdk_keyval_name(accelerator.key);
}
if(accelerator.modifiers & GDK_MOD1_MASK)
{
m_file << "+Alt";
}
if(accelerator.modifiers & GDK_CONTROL_MASK)
{
m_file << "+Ctrl";
}
if(accelerator.modifiers & GDK_SHIFT_MASK)
{
m_file << "+Shift";
}
m_file << "\n";
}
void cell_renderer_key_set_scancode (CellRendererKey *key, gint scancode)
{
gboolean changed;
g_return_if_fail (IS_CELL_RENDERER_KEY(key));
g_object_freeze_notify(G_OBJECT(key));
changed = FALSE;
if (scancode != key->scancode) {
key->scancode = scancode;
g_object_notify(G_OBJECT(key), "scancode");
changed = TRUE;
}
g_object_thaw_notify(G_OBJECT(key));
if (changed) {
const gchar *text;
/* sync string to the key values */
if (scancode <= 0) {
text = "None";
} else {
guint keyval = 0;
gdk_keymap_translate_keyboard_state(gdk_keymap_get_default(),
scancode, 0, 0, &keyval, NULL, NULL, NULL);
text = gdk_keyval_name(keyval);
}
g_object_set(key, "text", text, NULL);
}
}
GladeXmlNode *
glade_accel_write (GladeAccelInfo * accel,
GladeXmlContext * context, gboolean write_signal)
{
GladeXmlNode *accel_node;
gchar *modifiers;
g_return_val_if_fail (accel != NULL, NULL);
g_return_val_if_fail (context != NULL, NULL);
accel_node = glade_xml_node_new (context, GLADE_TAG_ACCEL);
modifiers = glade_gtk_modifier_string_from_bits (accel->modifiers);
glade_xml_node_set_property_string (accel_node, GLADE_TAG_ACCEL_KEY,
gdk_keyval_name (accel->key));
if (write_signal)
glade_xml_node_set_property_string (accel_node, GLADE_TAG_ACCEL_SIGNAL,
accel->signal);
glade_xml_node_set_property_string (accel_node, GLADE_TAG_ACCEL_MODIFIERS,
modifiers);
g_free (modifiers);
return accel_node;
}
/**
* dbusmenu_menuitem_property_set_shortcut:
* @menuitem: The #DbusmenuMenuitem to set the shortcut on
* @key: The keycode of the key to send
* @modifier: A bitmask of modifiers used to activate the item
*
* Takes the modifer described by @key and @modifier and places that into
* the format sending across Dbus for shortcuts.
*
* Return value: Whether it was successful at setting the property.
*/
gboolean
dbusmenu_menuitem_property_set_shortcut (DbusmenuMenuitem * menuitem, guint key, GdkModifierType modifier)
{
g_return_val_if_fail(DBUSMENU_IS_MENUITEM(menuitem), FALSE);
g_return_val_if_fail(gtk_accelerator_valid(key, modifier), FALSE);
const gchar * keyname = gdk_keyval_name(key);
g_return_val_if_fail(keyname != NULL, FALSE);
GVariantBuilder builder;
g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
if (modifier & GDK_CONTROL_MASK) {
g_variant_builder_add(&builder, "s", DBUSMENU_MENUITEM_SHORTCUT_CONTROL);
}
if (modifier & GDK_MOD1_MASK) {
g_variant_builder_add(&builder, "s", DBUSMENU_MENUITEM_SHORTCUT_ALT);
}
if (modifier & GDK_SHIFT_MASK) {
g_variant_builder_add(&builder, "s", DBUSMENU_MENUITEM_SHORTCUT_SHIFT);
}
if (modifier & GDK_SUPER_MASK) {
g_variant_builder_add(&builder, "s", DBUSMENU_MENUITEM_SHORTCUT_SUPER);
}
g_variant_builder_add(&builder, "s", keyname);
GVariant * inside = g_variant_builder_end(&builder);
g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
g_variant_builder_add_value(&builder, inside);
GVariant * outsidevariant = g_variant_builder_end(&builder);
return dbusmenu_menuitem_property_set_variant(menuitem, DBUSMENU_MENUITEM_PROP_SHORTCUT, outsidevariant);
}
gboolean browser_key_event(GtkWidget *widget, GdkEventKey *event)
{
char key = gdk_keyval_name(event->keyval)[0];
int index = 0;
for (int a = 0; a < tex_names.size(); a++)
{
if (tex_names[a] == selected_tex)
index = a;
}
if (event->keyval == GDK_Return)
gtk_dialog_response(GTK_DIALOG(browser_dialog), GTK_RESPONSE_ACCEPT);
if (event->keyval == GDK_Up && index - browser_columns >= 0)
index -= browser_columns;
if (event->keyval == GDK_Left && index > 0)
index--;
if (event->keyval == GDK_Right && index < tex_names.size() - 1)
index++;
if (event->keyval == GDK_Down && index < tex_names.size() - browser_columns)
index += browser_columns;
selected_tex = tex_names[index];
scroll_to_selected_texture(widget);
gdk_window_invalidate_rect(widget->window, &widget->allocation, false);
return true;
}
void
on_next_button_clicked (GtkWidget *next_button, GdkEventKey *event, AD data)
// 按下『F3』找下一個符合字串
// ＊因為無法把searchWord正確傳遞，所以無法正常使用此函式。
{
const gchar *text;
GtkTextBuffer *buffer;
GtkTextMark *last_pos;
GtkTextIter iter;
if( !strcmp( gdk_keyval_name( event->keyval ), "F3" ) ) {
text = "e" ; // 預設搜尋e
//text = data->searchWord;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (data->textview));
last_pos = gtk_text_buffer_get_mark (buffer, "last_pos");
if (last_pos == NULL)
gtk_text_buffer_get_start_iter (buffer, &iter); // 若無，就從頭搜尋
else
gtk_text_buffer_get_iter_at_mark (buffer, &iter, last_pos);
//find (GTK_TEXT_VIEW (data->textview), text, &iter);
find (GTK_TEXT_VIEW (data->textview), text, &iter);
}
}
gboolean
on_dialog_key_press_event (GtkWidget *widget, GdkEventKey *event, gpointer user_data) {
GtkLabel *label = (GtkLabel *) G_OBJECT (user_data);
if (!pressed) {
pressed = TRUE;
gtk_label_set_text (label, "");
}
switch (event->keyval)
{
case GDK_Control_L:
case GDK_Control_R:
gtk_label_set_text (label, g_strconcat (gtk_label_get_text (label), "<control>", NULL));
break;
case GDK_Shift_L:
case GDK_Shift_R:
gtk_label_set_text (label, g_strconcat (gtk_label_get_text (label), "<shift>", NULL));
break;
case GDK_Alt_L:
case GDK_Alt_R:
gtk_label_set_text (label, g_strconcat (gtk_label_get_text (label), "<alt>", NULL));
break;
case GDK_Super_L:
case GDK_Super_R:
gtk_label_set_text (label, g_strconcat (gtk_label_get_text (label), "<super>", NULL));
break;
default:
gtk_label_set_text (label, g_strconcat (gtk_label_get_text (label), gdk_keyval_name (event->keyval), NULL));
}
return FALSE;
}
/* Converts a key value into a symbolic name. The names are the same as those
in the <clip-gdk.ch> header file but without the leading "GDK_". */
int
clip_GDK_KEYVALNAME(ClipMachine * ClipMachineMemory)
{
guint keyval = INT_OPTION(ClipMachineMemory, 1, 0);
_clip_retc(ClipMachineMemory, gdk_keyval_name(keyval));
return 0;
}
bool AnnotationPropertiesDialog::on_key_press_event(GdkEventKey* event)
{
string key = gdk_keyval_name (event->keyval);
if ( key == "Return" || key == "KP_Enter" ) {
onButtonClicked(Gtk::RESPONSE_OK);
return true;
}
return Gtk::Dialog::on_key_press_event(event);
}
static void cb_key_fire2(GtkWidget *widget, GdkEventKey *event, gpointer data) {
if(!dialog)
return;
gtk_entry_set_text(GTK_ENTRY(widget), gdk_keyval_name(event->keyval));
newflags->fire2_key = event->keyval;
set_flags_changed(TRUE);
}
void
conf_set_control_key (gint i, guint keyval)
{
char buffer[64];
gchar *keyval_name;
g_snprintf (buffer, sizeof (buffer), KEY_CONTROL_KEY, i);
keyval_name = gdk_keyval_name (keyval);
g_settings_set_string (settings, buffer, keyval_name);
}
static void
gdkrecord_event_key (GdkEventKey *event,
gdouble begin,
gdouble end)
{
const gchar *name;
name = gdk_keyval_name (event->keyval);
gdkrecord_event_log (event, begin, end, name);
}
std::string
keyval_name (unsigned int key)
{
std::string result;
gchar * kname = gdk_keyval_name(key);
if (not_nullptr(kname))
result = std::string((char *) kname);
return result;
}
// we use the string versions of the keys for now..
static gint keypress( GtkWidget* widget, GdkEventKey* event, gpointer data ){
gint ret;
IWindowListener *pListen = static_cast<IWindowListener *>( data );
ret = pListen->OnKeyPressed( gdk_keyval_name( event->keyval ) );
if ( ret ) {
gtk_signal_emit_stop_by_name( GTK_OBJECT( widget ), "key_press_event" );
}
return ret;
}
static gint
keyboard_event_handler(GtkWidget *mk, GdkEventKey *event, gpointer ignored)
{
int note;
char *key;
guint keyval;
GdkKeymapKey kk;
PianoKeyboard *pk = PIANO_KEYBOARD(mk);
(void) ignored;
/* We're not using event->keyval, because we need keyval with level set to 0.
E.g. if user holds Shift and presses '7', we want to get a '7', not '&'. */
kk.keycode = event->hardware_keycode;
kk.level = 0;
kk.group = 0;
keyval = gdk_keymap_lookup_key(NULL, &kk);
key = gdk_keyval_name(gdk_keyval_to_lower(keyval));
if (key == NULL) {
g_message("gtk_keyval_name() returned NULL; please report this.");
return FALSE;
}
note = key_binding(pk, key);
if (note < 0) {
/* Key was not bound. Maybe it's one of the keys handled in jack-keyboard.c. */
return FALSE;
}
if (note == 128) {
if (event->type == GDK_KEY_RELEASE) {
rest (pk);
}
return TRUE;
}
note += pk->octave * 12;
assert(note >= 0);
assert(note < NNOTES);
if (event->type == GDK_KEY_PRESS) {
press_key(pk, note);
} else if (event->type == GDK_KEY_RELEASE) {
release_key(pk, note);
}
return TRUE;
}
void kbd_test_cb(GtkWidget *widget, GdkEventKey *event, gpointer user_data)
{
int fn_ser = 75; // Fn key position
DeBug(printf("key name: %s\n", gdk_keyval_name(event->keyval)))
DeBug(printf("hw_keycode: %d\n", event->hardware_keycode))
DeBug(printf("keycode[%d]: %d\n", idx, keycode[idx]))
gdk_color_parse("#CD9B1D", &btn_pressed_color);
if (idx < SUM_KEY) {
if (event->hardware_keycode == keycode[idx]) {
if (event->type == GDK_KEY_PRESS) {
gtk_widget_modify_bg (button[idx], GTK_STATE_NORMAL, &btn_pressed_color);
gtk_widget_modify_bg (button[idx], GTK_STATE_SELECTED, &btn_pressed_color);
gtk_widget_modify_bg (button[idx], GTK_STATE_PRELIGHT, &btn_pressed_color);
} else if (event->type == GDK_KEY_RELEASE) {
gtk_widget_modify_bg (button[idx], GTK_STATE_NORMAL, &btn_passed_color);
gtk_widget_modify_bg (button[idx], GTK_STATE_SELECTED, &btn_passed_color);
gtk_widget_modify_bg (button[idx], GTK_STATE_PRELIGHT, &btn_passed_color);
if (idx == fn_ser) {
gtk_widget_modify_bg (button[idx + 2], GTK_STATE_NORMAL, &btn_guide_color);
gtk_widget_modify_bg (button[idx + 2], GTK_STATE_SELECTED, &btn_guide_color);
gtk_widget_modify_bg (button[idx + 2], GTK_STATE_PRELIGHT, &btn_guide_color);
idx += 2;
} else {
if (idx != SUM_KEY - 1) {
gtk_widget_modify_bg (button[idx + 1], GTK_STATE_NORMAL, &btn_guide_color);
gtk_widget_modify_bg (button[idx + 1], GTK_STATE_SELECTED, &btn_guide_color);
gtk_widget_modify_bg (button[idx + 1], GTK_STATE_PRELIGHT, &btn_guide_color);
}
idx += 1;
}
} else {
;
}
// } else {
// printf("else\n");
}
} else {
kbd_result = 0;
g_usleep(1000000);
gtk_widget_destroy(widget);
gtk_main_quit();
return;
}
printf("\n");
if (idx >= SUM_KEY) {
gtk_label_set_text(GTK_LABEL(label), "键盘测试完毕，请按任意键退出。");
}
return;
}
const char* global_keys_find( unsigned int key ){
const char *s;
if ( key == 0 ) {
return "";
}
s = gdk_keyval_name( key );
if ( !s ) {
return "";
}
return s;
}
// key_release_event: When a keyboard key is released
// ----------------------------------------------- >>
gboolean key_release_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
{
guint keyval = get_keyval(event);
string key = gdk_keyval_name(keyval);
//printf("\"%s\"\n", key.c_str());
binds.unset(key, (GdkModifierType)event->state, &released_keys);
keys_edit();
released_keys.clear();
return false;
}
void set( unsigned int val )
{
char buf[256] = "";
char* special = gdk_keyval_name( val );
char* p_buf = &buf[strlen(buf)];
if (special)
snprintf( p_buf, sizeof buf - (p_buf - buf), "%s", special );
else
snprintf( p_buf, sizeof buf - (p_buf - buf), "'%c'", (char)val );
set_text( buf );
int width = strlen(buf);
set_width_chars( 1 <= width ? width : 1 );
}
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;
}
/**
* spice_grab_sequence_as_string:
* @sequence:
*
* Returns: (transfer full): a newly allocated string representing the key sequence
**/
gchar *spice_grab_sequence_as_string(SpiceGrabSequence *sequence)
{
GString *str = g_string_new("");
int i;
for (i = 0 ; i < sequence->nkeysyms ; i++) {
if (i > 0)
g_string_append_c(str, '+');
g_string_append(str, gdk_keyval_name(sequence->keysyms[i]));
}
return g_string_free(str, FALSE);
}
// key_press_event: When a keyboard key is pressed
// -------------------------------------------- >>
gboolean key_press_event(GtkWidget *widget, GdkEventKey *event, gpointer data)
{
//printf("keyval: %d (%s)\nhardware: %d\n", event->keyval, gdk_keyval_name(event->keyval), event->hardware_keycode);
down_pos.set(mouse);
guint keyval = get_keyval(event);
string key = gdk_keyval_name(keyval);
//printf("\"%s\"\n", key.c_str());
binds.set(key, (GdkModifierType)event->state, &pressed_keys);
keys_edit();
pressed_keys.clear();
return false;
}
bool PreferencesWindow::on_key_press_event(GdkEventKey* event,
Gtk::Button *button,
Glib::ustring key)
{
Glib::RefPtr<Gnome::Conf::Client> &client
= MainWindow::instance().gconf_client;
Glib::ustring dir = MainWindow::instance().gconf_dir;
grab_connection.disconnect();
button->remove_modal_grab();
Glib::ustring name = gdk_keyval_name(event->keyval);
button->set_label(name);
client->set(dir + key, name);
return true;
}
static gchar *get_full_keystr(guint keyval, guint state)
{
/* strlen("Ctrl+Alt+Shift+Meta+")+1 == 21 */
const gsize max_modstr_len = 21;
gchar modstr[max_modstr_len];
gboolean found = FALSE;
const gchar *keystr = gdk_keyval_name(keyval);
const gchar *keystrmap[] = KEYSTRING_MAP;
modstr[0] = '\0';
if((state&GDK_SHIFT_MASK) != 0)
{
g_strlcat(modstr, "Shift+", max_modstr_len);
}
if((state&GDK_CONTROL_MASK) != 0)
{
g_strlcat(modstr, "Ctrl+", max_modstr_len);
}
if((state&GDK_MOD1_MASK) != 0)
{
g_strlcat(modstr, "Alt+", max_modstr_len);
}
if((state&GDK_META_MASK) != 0 || (state&GDK_SUPER_MASK) != 0)
{
g_strlcat(modstr, "Meta+", max_modstr_len);
}
/* Translate GDK key name to mpv key name */
for(gint i = 0; !found && keystrmap[i]; i += 2)
{
gint rc = g_ascii_strncasecmp( keystr,
keystrmap[i+1],
KEYSTRING_MAX_LEN );
if(rc == 0)
{
keystr = keystrmap[i];
found = TRUE;
}
}
return (strlen(keystr) > 0)?g_strconcat(modstr, keystr, NULL):NULL;
}
void
luaH_keystr_push(lua_State *L, guint keyval)
{
gchar ucs[7];
guint ulen;
guint32 ukval = gdk_keyval_to_unicode(keyval);
/* check for printable unicode character */
if (g_unichar_isgraph(ukval)) {
ulen = g_unichar_to_utf8(ukval, ucs);
ucs[ulen] = 0;
lua_pushstring(L, ucs);
}
/* sent keysym for non-printable characters */
else
lua_pushstring(L, gdk_keyval_name(keyval));
}
std::string EventManager::getGDKEventStr(GdkEventKey* event) {
std::string returnValue("");
// Don't react on modifiers only (no actual key like A, 2, U, etc.)
if (isModifier(event)) {
return returnValue;
}
// Convert the GDKEvent state into modifier flags
const unsigned int modifierFlags = _modifiers.getKeyboardFlags(event->state);
// Construct the complete string
returnValue += _modifiers.getModifierStr(modifierFlags, true);
returnValue += (returnValue != "") ? "-" : "";
returnValue += gdk_keyval_name(gdk_keyval_to_upper(event->keyval));
return returnValue;
}
std::string EventManager::getAcceleratorStr(const IEventPtr& event, bool forMenu) {
std::string returnValue = "";
IAccelerator& accelerator = findAccelerator(event);
unsigned int keyVal = accelerator.getKey();
const std::string keyStr = (keyVal != 0) ? gdk_keyval_name(keyVal) : "";
if (keyStr != "") {
// Return a modifier string for a menu
const std::string modifierStr = getModifierStr(accelerator.getModifiers(), forMenu);
const std::string connector = (forMenu) ? "-" : "+";
returnValue = modifierStr;
returnValue += (modifierStr != "") ? connector : "";
returnValue += keyStr;
}
return returnValue;
}
