+ #ifndef _

+ #define _(x) dgettext (GETTEXT_PACKAGE, x)

+ #define N_(x) x

+ #endif

+ #define _(x) x

+ #define N_(x) x

+static GtkCellRendererTextClass* parent_class = NULL;

+GType egg_cell_renderer_keys_get_type(void)

+ static GType cell_keys_type = 0;

+ if (!cell_keys_type)

+ {

+ static const GTypeInfo cell_keys_info = {

+ sizeof (EggCellRendererKeysClass),

+ NULL, /* base_init */

+ NULL, /* base_finalize */

+ (GClassInitFunc)egg_cell_renderer_keys_class_init,

+ NULL, /* class_finalize */

+ NULL, /* class_data */

+ sizeof (EggCellRendererKeys),

+ 0, /* n_preallocs */

+ (GInstanceInitFunc) egg_cell_renderer_keys_init

+ };

+

+ cell_keys_type = g_type_register_static (GTK_TYPE_CELL_RENDERER_TEXT, "EggCellRendererKeys", &cell_keys_info, 0);

+ }

+ return cell_keys_type;

+static void egg_cell_renderer_keys_init(EggCellRendererKeys* cell_keys)

+ MATEDEBUG();

+ cell_keys->accel_mode = EGG_CELL_RENDERER_KEYS_MODE_GTK;

+static void marshal_VOID__STRING_UINT_FLAGS_UINT(GClosure* closure, GValue* return_value, guint n_param_values, const GValue* param_values, gpointer invocation_hint, gpointer marshal_data)

+ /* typedef inside a function? wow */

+ typedef void (*GMarshalFunc_VOID__STRING_UINT_FLAGS_UINT) (

+ gpointer data1,

+ const char* arg_1,

+ guint arg_2,

+ int arg_3,

+ guint arg_4,

+ gpointer data2);

+

+ register GMarshalFunc_VOID__STRING_UINT_FLAGS_UINT callback;

+ register GCClosure* cc = (GCClosure*) closure;

+ register gpointer data1, data2;

+

+ g_return_if_fail (n_param_values == 5);

+

+ if (G_CCLOSURE_SWAP_DATA(closure))

+ {

+ data1 = closure->data;

+ data2 = g_value_peek_pointer(param_values + 0);

+ }

+ else

+ {

+ data1 = g_value_peek_pointer(param_values + 0);

+ data2 = closure->data;

+ }

+ callback = (GMarshalFunc_VOID__STRING_UINT_FLAGS_UINT) (marshal_data ? marshal_data : cc->callback);

+ callback(data1,

+ g_value_get_string(param_values + 1),

+ g_value_get_uint(param_values + 2),

+ g_value_get_flags(param_values + 3),

+ g_value_get_uint(param_values + 4),

+ data2);

+static gchar* convert_keysym_state_to_string(guint keysym, guint keycode, EggVirtualModifierType mask)

+ if (keysym == 0 && keycode == 0)

+ {

+ return g_strdup (_("Disabled"));

+ }

+ else

+ {

+ return egg_virtual_accelerator_label(keysym, keycode, mask);

+ }

+static gboolean is_modifier(guint keycode)

+ gint i;

+ gint map_size;

+ XModifierKeymap* mod_keymap;

+ gboolean retval = FALSE;

+ mod_keymap = XGetModifierMapping(gdk_display);

+ map_size = 8 * mod_keymap->max_keypermod;

+ i = 0;

+ while (i < map_size)

+ {

+ if (keycode == mod_keymap->modifiermap[i])

+ {

+ retval = TRUE;

+ break;

+ }

+

+ ++i;

+ }

+ XFreeModifiermap(mod_keymap);

+

+ return retval;

+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;

+

+ 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_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_ISO_Left_Tab)

+ {

+ accel_keyval = GDK_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_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_Escape)

+ {

+ goto out; /* cancel */

+ }

+ /* clear the accelerator on Backspace */

+ if (accel_mods == 0 && accel_keyval == GDK_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:

+ gdk_keyboard_ungrab(event->time);

+ gdk_pointer_ungrab(event->time);

+ 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;

+static void ungrab_stuff(GtkWidget* widget, gpointer data)

+ EggCellRendererKeys* keys = EGG_CELL_RENDERER_KEYS(data);

+ gdk_keyboard_ungrab(GDK_CURRENT_TIME);

+ gdk_pointer_ungrab(GDK_CURRENT_TIME);

+ g_signal_handlers_disconnect_by_func(G_OBJECT(keys->grab_widget), G_CALLBACK(grab_key_callback), data);

+static void pointless_eventbox_start_editing(GtkCellEditable* cell_editable, GdkEvent* event)

+ /* do nothing, because we are pointless */

+static void pointless_eventbox_cell_editable_init(GtkCellEditableIface* iface)

+ iface->start_editing = pointless_eventbox_start_editing;

+void egg_cell_renderer_keys_set_accelerator(EggCellRendererKeys* keys, guint keyval, guint keycode, EggVirtualModifierType mask)

+ char *text;

+ gboolean changed;

+ g_return_if_fail (EGG_IS_CELL_RENDERER_KEYS (keys));

+ g_object_freeze_notify (G_OBJECT (keys));

+ changed = FALSE;

+ if (keyval != keys->accel_key)

+ {

+ keys->accel_key = keyval;

+ g_object_notify (G_OBJECT (keys), "accel_key");

+ changed = TRUE;

+ }

+ if (mask != keys->accel_mask)

+ {

+ keys->accel_mask = mask;

+ g_object_notify (G_OBJECT (keys), "accel_mask");

+ changed = TRUE;

+ }

+ if (keycode != keys->keycode)

+ {

+ keys->keycode = keycode;

+ g_object_notify (G_OBJECT (keys), "keycode");

+ changed = TRUE;

+ }

+ g_object_thaw_notify (G_OBJECT (keys));

+

+ if (changed)

+ {

+ /* sync string to the key values */

+ text = convert_keysym_state_to_string (keys->accel_key, keys->keycode, keys->accel_mask);

+ g_object_set (keys, "text", text, NULL);

+ g_free (text);

+ }

+void egg_cell_renderer_keys_get_accelerator(EggCellRendererKeys* keys, guint* keyval, EggVirtualModifierType* mask)

+ g_return_if_fail(EGG_IS_CELL_RENDERER_KEYS(keys));

+ if (keyval)

+ {

+ *keyval = keys->accel_key;

+ }

+ if (mask)

+ {

+ *mask = keys->accel_mask;

+ }

+void egg_cell_renderer_keys_set_accel_mode (EggCellRendererKeys* keys, EggCellRendererKeysMode accel_mode)

+ g_return_if_fail(EGG_IS_CELL_RENDERER_KEYS(keys));

+ keys->accel_mode = accel_mode;

+ g_object_notify(G_OBJECT(keys), "accel_mode");

+static GtkWidget* _gtk_builder_get_widget(GtkBuilder* builder, const gchar* name)

+ return GTK_WIDGET (gtk_builder_get_object (builder, name));

+static gboolean key_match(GtkTreeModel* model, GtkTreePath* path, GtkTreeIter* iter, gpointer data)

+ KeyMatchData* match_data = data;

+ KeyEntry* element;

+ gtk_tree_model_get(model, iter,

+ KEYENTRY_COLUMN, &element,

+ -1);

+ if (element && g_strcmp0(element->mateconf_key, match_data->key) == 0)

+ {

+ match_data->found = TRUE;

+ return TRUE;

+ }

+ return FALSE;

+static gboolean key_is_already_shown(GtkTreeModel* model, const KeyListEntry* entry)

+ KeyMatchData data;

+ data.key = entry->name;

+ data.found = FALSE;

+ gtk_tree_model_foreach(model, key_match, &data);

+ return data.found;

+static gboolean should_show_key(const KeyListEntry* entry)

+ int value;

+ MateConfClient *client;

+ if (entry->comparison == COMPARISON_NONE)

+ {

+ return TRUE;

+ }

+ g_return_val_if_fail(entry->key != NULL, FALSE);

+ client = mateconf_client_get_default();

+ value = mateconf_client_get_int (client, entry->key, NULL);

+ g_object_unref (client);

+ switch (entry->comparison)

+ {

+ case COMPARISON_NONE:

+ /* For compiler warnings */

+ g_assert_not_reached ();

+ return FALSE;

+ case COMPARISON_GT:

+ if (value > entry->value)

+ {

+ return TRUE;

+ }

+ break;

+ case COMPARISON_LT:

+ if (value < entry->value)

+ {

+ return TRUE;

+ }

+ break;

+ case COMPARISON_EQ:

+ if (value == entry->value)

+ {

+ return TRUE;

+ }

+ break;

+ }

+ return FALSE;

+static gboolean cb_check_for_uniqueness(GtkTreeModel* model, GtkTreePath* path, GtkTreeIter* iter, KeyEntry* new_key)

+ KeyEntry* element;

+ gtk_tree_model_get (new_key->model, iter,

+ KEYENTRY_COLUMN, &element,

+ -1);

+ /* no conflict for : blanks, different modifiers, or ourselves */

+ if (element == NULL || new_key->mask != element->mask ||

+ !strcmp (new_key->mateconf_key, element->mateconf_key))

+ {

+ return FALSE;

+ }

+ if (new_key->keyval != 0)

+ {

+ if (new_key->keyval != element->keyval)

+ {

+ return FALSE;

+ }

+ }

+ else if (element->keyval != 0 || new_key->keycode != element->keycode)

+ {

+ return FALSE;

+ }

+ new_key->editable = FALSE;

+ new_key->mateconf_key = element->mateconf_key;

+ new_key->description = element->description;

+ new_key->desc_mateconf_key = element->desc_mateconf_key;

+ new_key->desc_editable = element->desc_editable;

+

+ return TRUE;

+ /* Navigation keys */

+ GDK_Home,

+ GDK_Left,

+ GDK_Up,

+ GDK_Right,

+ GDK_Down,

+ GDK_Page_Up,

+ GDK_Page_Down,

+ GDK_End,

+ GDK_Tab,

+

+ /* Return */

+ GDK_KP_Enter,

+ GDK_Return,

+

+ GDK_space,

+ GDK_Mode_switch

+static gboolean keyval_is_forbidden(guint keyval)

+ guint i;

+ for (i = 0; i < G_N_ELEMENTS(forbidden_keyvals); i++)

+ {

+ if (keyval == forbidden_keyvals[i])

+ {

+ return TRUE;

+ }

+ }

+ return FALSE;

+static void show_error(GtkWindow* parent, GError* err)

+static void accel_edited_callback(GtkCellRendererText* cell, const char* path_string, guint keyval, EggVirtualModifierType mask, guint keycode, gpointer data)

+ MateConfClient* client;

+ GtkTreeView* view = (GtkTreeView*) data;

+ GtkTreeModel* model;

+ GtkTreePath* path = gtk_tree_path_new_from_string (path_string);

+ GtkTreeIter iter;

+ KeyEntry* key_entry, tmp_key;

+ GError* err = NULL;

+ char* str;

+ block_accels = FALSE;

+ /* sanity check */

+ if (key_entry == NULL)

+ {

+ return;

+ }

+ /* CapsLock isn't supported as a keybinding modifier, so keep it from confusing us */

+ mask &= ~EGG_VIRTUAL_LOCK_MASK;

+ tmp_key.model = model;

+ tmp_key.keyval = keyval;

+ tmp_key.keycode = keycode;

+ tmp_key.mask = mask;

+ tmp_key.mateconf_key = key_entry->mateconf_key;

+ tmp_key.description = NULL;

+ tmp_key.editable = TRUE; /* kludge to stuff in a return flag */

+ if (keyval != 0 || keycode != 0) /* any number of keys can be disabled */

+ {

+ gtk_tree_model_foreach(model, (GtkTreeModelForeachFunc) cb_check_for_uniqueness, &tmp_key);

+ }

+ /* Check for unmodified keys */

+ if (tmp_key.mask == 0 && tmp_key.keycode != 0)

+ if ((tmp_key.keyval >= GDK_a && tmp_key.keyval <= GDK_z)

+ || (tmp_key.keyval >= GDK_A && tmp_key.keyval <= GDK_Z)

+ || (tmp_key.keyval >= GDK_0 && tmp_key.keyval <= GDK_9)

+ || (tmp_key.keyval >= GDK_kana_fullstop && tmp_key.keyval <= GDK_semivoicedsound)

+ || (tmp_key.keyval >= GDK_Arabic_comma && tmp_key.keyval <= GDK_Arabic_sukun)

+ || (tmp_key.keyval >= GDK_Serbian_dje && tmp_key.keyval <= GDK_Cyrillic_HARDSIGN)

+ || (tmp_key.keyval >= GDK_Greek_ALPHAaccent && tmp_key.keyval <= GDK_Greek_omega)

+ || (tmp_key.keyval >= GDK_hebrew_doublelowline && tmp_key.keyval <= GDK_hebrew_taf)

+ || (tmp_key.keyval >= GDK_Thai_kokai && tmp_key.keyval <= GDK_Thai_lekkao)

+ || (tmp_key.keyval >= GDK_Hangul && tmp_key.keyval <= GDK_Hangul_Special)

+ || (tmp_key.keyval >= GDK_Hangul_Kiyeog && tmp_key.keyval <= GDK_Hangul_J_YeorinHieuh)

+ || keyval_is_forbidden (tmp_key.keyval))

+ {

+

+ GtkWidget *dialog;

+ char *name;

+

+ name = binding_name (keyval, keycode, mask, TRUE);

+

+ dialog = gtk_message_dialog_new (

+ GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (view))),

+ _("The shortcut \"%s\" cannot be used because it will become impossible to type using this key.\n"

+ "Please try with a key such as Control, Alt or Shift at the same time."),

+ name);

+

+ g_free (name);

+ gtk_dialog_run (GTK_DIALOG (dialog));

+ gtk_widget_destroy (dialog);

+

+ /* set it back to its previous value. */

+ egg_cell_renderer_keys_set_accelerator(

+ EGG_CELL_RENDERER_KEYS(cell),

+ key_entry->keyval,

+ key_entry->keycode,

+ key_entry->mask);

+ return;

+ }

+ }

+ /* flag to see if the new accelerator was in use by something */

+ if (!tmp_key.editable)

+ GtkWidget* dialog;

+ char* name;

+ int response;

+

+ name = binding_name(keyval, keycode, mask, TRUE);

+

+ dialog = gtk_message_dialog_new(

+ GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(view))),

+ GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_MODAL,

+ GTK_MESSAGE_WARNING,

+ GTK_BUTTONS_CANCEL,

+ _("The shortcut \"%s\" is already used for\n\"%s\""),

+ name,

+ tmp_key.description ? tmp_key.description : tmp_key.mateconf_key);

+ g_free (name);

+

+ gtk_message_dialog_format_secondary_text (

+ GTK_MESSAGE_DIALOG (dialog),

+ _("If you reassign the shortcut to \"%s\", the \"%s\" shortcut "

+ "will be disabled."),

+ key_entry->description ? key_entry->description : key_entry->mateconf_key,

+ tmp_key.description ? tmp_key.description : tmp_key.mateconf_key);

+

+ gtk_dialog_add_button(GTK_DIALOG (dialog), _("_Reassign"), GTK_RESPONSE_ACCEPT);

+

+ gtk_dialog_set_default_response(GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT);

+

+ response = gtk_dialog_run (GTK_DIALOG (dialog));

+ gtk_widget_destroy (dialog);

+

+ if (response == GTK_RESPONSE_ACCEPT)

+ {

+ MateConfClient* client;

+

+ client = mateconf_client_get_default ();

+

+ mateconf_client_set_string(

+ client,

+ tmp_key.mateconf_key,

+ "",

+ &err);

+

+ if (err != NULL)

+ {

+ show_error(GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (view))), err);

+ g_error_free (err);

+ g_object_unref (client);

+ return;

+ }

+

+ str = binding_name (keyval, keycode, mask, FALSE);

+ mateconf_client_set_string (client, key_entry->mateconf_key, str, &err);

+

+ if (err != NULL)

+ {

+ show_error (GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (view))), err);

+ g_error_free (err);

+

+ /* reset the previous shortcut */

+ mateconf_client_set_string (client, tmp_key.mateconf_key, str, NULL);

+ }

+

+ g_free (str);

+ g_object_unref (client);

+ }

+ else

+ {

+ /* set it back to its previous value. */

+ egg_cell_renderer_keys_set_accelerator(

+ EGG_CELL_RENDERER_KEYS(cell),

+ key_entry->keyval,

+ key_entry->keycode,

+ key_entry->mask);

+ }

+

+ return;

+ }

+ str = binding_name (keyval, keycode, mask, FALSE);

+ client = mateconf_client_get_default ();

+ mateconf_client_set_string(

+ client,

+ key_entry->mateconf_key,

+ str,

+ &err);

+ g_free (str);

+ g_object_unref (client);

+ if (err != NULL)

+ show_error (GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (view))), err);

+ g_error_free (err);

+ key_entry->editable = FALSE;

+static gboolean maybe_block_accels(GtkWidget* widget, GdkEventKey* event, gpointer user_data)

+ if (block_accels)

+ {

+ return gtk_window_propagate_key_event(GTK_WINDOW(widget), event);

+ }

+

+ return FALSE;