static GtkWidget *
glade_eprop_accel_view (GladeEditorProperty * eprop)
{
GladeEPropAccel *eprop_accel = GLADE_EPROP_ACCEL (eprop);
GtkWidget *view_widget;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
eprop_accel->model = (GtkTreeModel *)
gtk_tree_store_new (ACCEL_NUM_COLUMNS, G_TYPE_STRING, /* The GSignal name formatted for display */
G_TYPE_STRING, /* The GSignal name */
G_TYPE_STRING, /* The text to show in the accelerator cell */
G_TYPE_INT, /* PangoWeight attribute for bold headers */
G_TYPE_INT, /* PangoStyle attribute for italic grey unset items */
G_TYPE_STRING, /* Foreground colour for italic grey unset items */
G_TYPE_BOOLEAN, /* Visible attribute to hide items for header entries */
G_TYPE_BOOLEAN, /* Whether the key has been entered for this row */
G_TYPE_UINT, /* Hardware keycode */
G_TYPE_INT); /* GdkModifierType */
view_widget = gtk_tree_view_new_with_model (eprop_accel->model);
gtk_tree_view_set_show_expanders (GTK_TREE_VIEW (view_widget), FALSE);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (view_widget), FALSE);
/********************* signal name column *********************/
renderer = gtk_cell_renderer_text_new ();
g_object_set (G_OBJECT (renderer), "editable", FALSE, NULL);
column = gtk_tree_view_column_new_with_attributes
(_("Signal"), renderer,
"text", ACCEL_COLUMN_SIGNAL, "weight", ACCEL_COLUMN_WEIGHT, NULL);
gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN (column), TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (view_widget), column);
/********************* accel editor column *********************/
renderer = gtk_cell_renderer_accel_new ();
g_object_set (G_OBJECT (renderer), "editable", TRUE, NULL);
g_signal_connect (renderer, "accel-edited", G_CALLBACK (accel_edited), eprop);
g_signal_connect (renderer, "accel-cleared",
G_CALLBACK (accel_cleared), eprop);
column = gtk_tree_view_column_new_with_attributes
(_("Accelerator Key"), renderer,
"text", ACCEL_COLUMN_TEXT,
"foreground", ACCEL_COLUMN_FOREGROUND,
"style", ACCEL_COLUMN_STYLE, "visible", ACCEL_COLUMN_VISIBLE, NULL);
gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN (column), TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (view_widget), column);
return view_widget;
}
static GtkWidget *
key_test (void)
{
GtkWidget *window, *sw, *tv;
GtkListStore *store;
GtkTreeViewColumn *column;
GtkCellRenderer *rend;
gint i;
/* create window */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (window), sw);
store = gtk_list_store_new (3, G_TYPE_INT, G_TYPE_UINT, G_TYPE_UINT);
tv = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
gtk_container_add (GTK_CONTAINER (sw), tv);
column = gtk_tree_view_column_new ();
rend = gtk_cell_renderer_accel_new ();
g_object_set (G_OBJECT (rend),
"accel-mode", GTK_CELL_RENDERER_ACCEL_MODE_GTK,
"editable", TRUE,
NULL);
g_signal_connect (G_OBJECT (rend),
"accel-edited",
G_CALLBACK (accel_edited_callback),
store);
gtk_tree_view_column_pack_start (column, rend,
TRUE);
gtk_tree_view_column_set_attributes (column, rend,
"accel-mods", 0,
"accel-key", 1,
"keycode", 2,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tv), column);
for (i = 0; i < 10; i++) {
GtkTreeIter iter;
gtk_list_store_append (store, &iter);
}
/* done */
return window;
}
GtkWidget* create_hotkey_editor(void)
{
GtkWidget *hotkey_tree_view = NULL;
GtkCellRenderer *renderer = NULL;
GtkListStore *model = NULL;
GtkTreeViewColumn *column = NULL;
GtkTreeIter iter = {0};
/* create a tree view */
hotkey_tree_view = gtk_tree_view_new();
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(hotkey_tree_view), FALSE);
g_signal_connect (hotkey_tree_view, "button-press-event", G_CALLBACK (start_editing_cb), NULL);
g_signal_connect (hotkey_tree_view, "row-activated", G_CALLBACK (start_editing_keybd_cb), NULL);
g_object_set(hotkey_tree_view, "visible", TRUE, NULL);
/* create the Egg Cell Renderer and connect to signals */
renderer = (GtkCellRenderer*) gtk_cell_renderer_accel_new ();
g_object_set(renderer, "editable", TRUE, NULL);
g_signal_connect (renderer, "accel-edited", G_CALLBACK (accel_edited_callback), hotkey_tree_view);
g_signal_connect (renderer, "accel-cleared", G_CALLBACK (accel_cleared_callback), hotkey_tree_view);
/* create a column and set the created renderer - append the same to the tree view */
column = gtk_tree_view_column_new_with_attributes ("Shortcut", renderer, NULL);
/* since it's a custom renderer, setting the data to the cell needs to be custom as well */
gtk_tree_view_column_set_cell_data_func (column, renderer, accel_set_func, NULL, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW(hotkey_tree_view), column);
/* create the list store for the tree */
model = gtk_list_store_new (1, G_TYPE_POINTER);
gtk_tree_view_set_model (GTK_TREE_VIEW (hotkey_tree_view), GTK_TREE_MODEL(model));
gtk_list_store_append (model, &iter);
gtk_list_store_set (model, &iter, HOTKEY_COLUMN, &app_hotkey, -1);
/* The tree view has acquired its own reference to the
* model, so we can drop ours. That way the model will
* be freed automatically when the tree view is destroyed */
g_object_unref (model);
g_object_set(hotkey_tree_view, "visible", TRUE, NULL);
return hotkey_tree_view;
}
JNIEXPORT jlong JNICALL
Java_org_gnome_gtk_GtkCellRendererAccel_gtk_1cell_1renderer_1accel_1new
(
JNIEnv* env,
jclass cls
)
{
GtkCellRenderer* result;
jlong _result;
// call function
result = gtk_cell_renderer_accel_new();
// translate return value to JNI type
_result = (jlong) result;
// cleanup return value
if (result != NULL) {
bindings_java_memory_cleanup((GObject*)result, TRUE);
}
// and finally
return _result;
}
GtkWidget *
gimp_action_view_new (GimpUIManager *manager,
const gchar *select_action,
gboolean show_shortcuts)
{
GtkTreeView *view;
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
GtkTreeStore *store;
GtkTreeModel *filter;
GtkAccelGroup *accel_group;
GList *list;
GtkTreePath *select_path = NULL;
g_return_val_if_fail (GIMP_IS_UI_MANAGER (manager), NULL);
store = gtk_tree_store_new (GIMP_ACTION_VIEW_N_COLUMNS,
G_TYPE_BOOLEAN, /* COLUMN_VISIBLE */
GTK_TYPE_ACTION, /* COLUMN_ACTION */
G_TYPE_STRING, /* COLUMN_STOCK_ID */
G_TYPE_STRING, /* COLUMN_LABEL */
G_TYPE_STRING, /* COLUMN_LABEL_CASEFOLD */
G_TYPE_STRING, /* COLUMN_NAME */
G_TYPE_UINT, /* COLUMN_ACCEL_KEY */
GDK_TYPE_MODIFIER_TYPE, /* COLUMN_ACCEL_MASK */
G_TYPE_CLOSURE); /* COLUMN_ACCEL_CLOSURE */
accel_group = gtk_ui_manager_get_accel_group (GTK_UI_MANAGER (manager));
for (list = gtk_ui_manager_get_action_groups (GTK_UI_MANAGER (manager));
list;
list = g_list_next (list))
{
GimpActionGroup *group = list->data;
GList *actions;
GList *list2;
GtkTreeIter group_iter;
gtk_tree_store_append (store, &group_iter, NULL);
gtk_tree_store_set (store, &group_iter,
GIMP_ACTION_VIEW_COLUMN_STOCK_ID, group->stock_id,
GIMP_ACTION_VIEW_COLUMN_LABEL, group->label,
-1);
actions = gtk_action_group_list_actions (GTK_ACTION_GROUP (group));
actions = g_list_sort (actions, (GCompareFunc) gimp_action_name_compare);
for (list2 = actions; list2; list2 = g_list_next (list2))
{
GtkAction *action = list2->data;
const gchar *name = gtk_action_get_name (action);
const gchar *stock_id = gtk_action_get_stock_id (action);
gchar *label;
gchar *label_casefold;
guint accel_key = 0;
GdkModifierType accel_mask = 0;
GClosure *accel_closure = NULL;
GtkTreeIter action_iter;
if (strstr (name, "-menu") ||
strstr (name, "-popup") ||
name[0] == '<')
continue;
label = gimp_strip_uline (gtk_action_get_label (action));
if (! (label && strlen (label)))
{
g_free (label);
label = g_strdup (name);
}
label_casefold = g_utf8_casefold (label, -1);
if (show_shortcuts)
{
accel_closure = gtk_action_get_accel_closure (action);
if (accel_closure)
{
GtkAccelKey *key;
key = gtk_accel_group_find (accel_group,
gimp_action_view_accel_find_func,
accel_closure);
if (key &&
key->accel_key &&
key->accel_flags & GTK_ACCEL_VISIBLE)
{
accel_key = key->accel_key;
accel_mask = key->accel_mods;
}
}
}
gtk_tree_store_append (store, &action_iter, &group_iter);
gtk_tree_store_set (store, &action_iter,
GIMP_ACTION_VIEW_COLUMN_VISIBLE, TRUE,
GIMP_ACTION_VIEW_COLUMN_ACTION, action,
GIMP_ACTION_VIEW_COLUMN_STOCK_ID, stock_id,
GIMP_ACTION_VIEW_COLUMN_LABEL, label,
GIMP_ACTION_VIEW_COLUMN_LABEL_CASEFOLD, label_casefold,
GIMP_ACTION_VIEW_COLUMN_NAME, name,
GIMP_ACTION_VIEW_COLUMN_ACCEL_KEY, accel_key,
GIMP_ACTION_VIEW_COLUMN_ACCEL_MASK, accel_mask,
GIMP_ACTION_VIEW_COLUMN_ACCEL_CLOSURE, accel_closure,
-1);
g_free (label);
g_free (label_casefold);
if (select_action && ! strcmp (select_action, name))
{
select_path = gtk_tree_model_get_path (GTK_TREE_MODEL (store),
&action_iter);
}
}
g_list_free (actions);
}
filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (store), NULL);
g_object_unref (store);
view = g_object_new (GIMP_TYPE_ACTION_VIEW,
"model", filter,
"rules-hint", TRUE,
NULL);
g_object_unref (filter);
gtk_tree_model_filter_set_visible_column (GTK_TREE_MODEL_FILTER (filter),
GIMP_ACTION_VIEW_COLUMN_VISIBLE);
GIMP_ACTION_VIEW (view)->manager = g_object_ref (manager);
GIMP_ACTION_VIEW (view)->show_shortcuts = show_shortcuts;
gtk_tree_view_set_search_column (GTK_TREE_VIEW (view),
GIMP_ACTION_VIEW_COLUMN_LABEL);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Action"));
cell = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, cell, FALSE);
gtk_tree_view_column_set_attributes (column, cell,
"stock-id",
GIMP_ACTION_VIEW_COLUMN_STOCK_ID,
NULL);
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, cell, TRUE);
gtk_tree_view_column_set_attributes (column, cell,
"text",
GIMP_ACTION_VIEW_COLUMN_LABEL,
NULL);
gtk_tree_view_append_column (view, column);
if (show_shortcuts)
{
g_signal_connect (view, "button-press-event",
G_CALLBACK (gimp_action_view_button_press),
NULL);
g_signal_connect (accel_group, "accel-changed",
G_CALLBACK (gimp_action_view_accel_changed),
view);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Shortcut"));
cell = gtk_cell_renderer_accel_new ();
g_object_set (cell,
"mode", GTK_CELL_RENDERER_MODE_EDITABLE,
"editable", TRUE,
NULL);
gtk_tree_view_column_pack_start (column, cell, TRUE);
gtk_tree_view_column_set_attributes (column, cell,
"accel-key",
GIMP_ACTION_VIEW_COLUMN_ACCEL_KEY,
"accel-mods",
GIMP_ACTION_VIEW_COLUMN_ACCEL_MASK,
NULL);
g_signal_connect (cell, "accel-edited",
G_CALLBACK (gimp_action_view_accel_edited),
view);
g_signal_connect (cell, "accel-cleared",
G_CALLBACK (gimp_action_view_accel_cleared),
view);
gtk_tree_view_append_column (view, column);
}
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Name"));
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, cell, TRUE);
gtk_tree_view_column_set_attributes (column, cell,
"text",
GIMP_ACTION_VIEW_COLUMN_NAME,
NULL);
gtk_tree_view_append_column (view, column);
if (select_path)
{
gimp_action_view_select_path (GIMP_ACTION_VIEW (view), select_path);
gtk_tree_path_free (select_path);
}
return GTK_WIDGET (view);
}
static GtkWidget*
shortcuts_get_preferences_dialog (MidoriExtension* extension)
{
MidoriApp* app;
GtkWidget* browser;
const gchar* dialog_title;
GtkWidget* dialog;
gint width, height;
GtkWidget* xfce_heading;
GtkWidget* hbox;
GtkListStore* liststore;
GtkTreeModel* model;
GtkWidget* treeview;
GtkTreeViewColumn* column;
GtkCellRenderer* renderer;
GtkWidget* scrolled;
GtkActionGroup* action_group;
GList* actions;
guint i;
GtkAction* action;
#if HAVE_OSX
GtkWidget* icon;
#endif
app = midori_extension_get_app (extension);
browser = katze_object_get_object (app, "browser");
dialog_title = _("Customize Keyboard shortcuts");
dialog = gtk_dialog_new_with_buttons (dialog_title, GTK_WINDOW (browser),
GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_NO_SEPARATOR,
#if !HAVE_OSX
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
#endif
NULL);
g_signal_connect (dialog, "destroy",
G_CALLBACK (gtk_widget_destroyed), &dialog);
gtk_window_set_icon_name (GTK_WINDOW (dialog), GTK_STOCK_PROPERTIES);
sokoke_widget_get_text_size (dialog, "M", &width, &height);
gtk_window_set_default_size (GTK_WINDOW (dialog), width * 52, height * 24);
g_signal_connect (dialog, "response",
G_CALLBACK (shortcuts_preferences_response_cb), NULL);
if ((xfce_heading = sokoke_xfce_header_new (
gtk_window_get_icon_name (GTK_WINDOW (dialog)), dialog_title)))
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox),
xfce_heading, FALSE, FALSE, 0);
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox,
TRUE, TRUE, 12);
liststore = gtk_list_store_new (7,
G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT, G_TYPE_BOOLEAN,
G_TYPE_STRING, GTK_TYPE_ACTION);
model = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (liststore));
treeview = gtk_tree_view_new_with_model (model);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE);
column = gtk_tree_view_column_new ();
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), renderer, "text", 0);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
column = gtk_tree_view_column_new ();
renderer = gtk_cell_renderer_accel_new ();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), renderer, "accel-key", 1);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), renderer, "accel-mods", 2);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), renderer, "accel-mode", 3);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), renderer, "sensitive", 4);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (column), renderer, "editable", 4);
g_signal_connect (renderer, "accel-edited",
G_CALLBACK (shortcuts_accel_edited_cb), model);
g_signal_connect (renderer, "accel-cleared",
G_CALLBACK (shortcuts_accel_cleared_cb), model);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (scrolled), treeview);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled),
GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (hbox), scrolled, TRUE, TRUE, 5);
action_group = midori_browser_get_action_group (MIDORI_BROWSER (browser));
actions = gtk_action_group_list_actions (action_group);
i = 0;
/* FIXME: Catch added and removed actions */
while ((action = g_list_nth_data (actions, i++)))
{
gchar* label = shortcuts_label_for_action (action);
GtkAccelKey key;
gboolean has_hotkey = shortcuts_hotkey_for_action (action, &key);
gtk_list_store_insert_with_values (GTK_LIST_STORE (liststore),
NULL, G_MAXINT, 0, label, 1, key.accel_key, 2, key.accel_mods,
3, GTK_CELL_RENDERER_ACCEL_MODE_OTHER,
4, has_hotkey, 6, action, -1);
g_free (label);
}
g_list_free (actions);
g_object_unref (liststore);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model),
0, GTK_SORT_ASCENDING);
g_object_unref (model);
gtk_widget_show_all (GTK_DIALOG (dialog)->vbox);
g_object_unref (browser);
return dialog;
}
static GtkWidget *
key_dialog_treeview_new (GtkWidget *box)
{
GtkWidget *scroll;
GtkListStore *store, *combostore;
GtkTreeViewColumn *col;
GtkWidget *view;
GtkCellRenderer *render;
int i;
scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scroll), GTK_SHADOW_IN);
store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING);
g_return_val_if_fail (store != NULL, NULL);
view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
gtk_tree_view_set_fixed_height_mode (GTK_TREE_VIEW (view), TRUE);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (view), FALSE);
gtk_tree_view_set_reorderable (GTK_TREE_VIEW (view), TRUE);
g_signal_connect (G_OBJECT (view), "key-press-event",
G_CALLBACK (key_dialog_keypress), NULL);
g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW(view))),
"changed", G_CALLBACK (key_dialog_selection_changed), NULL);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (view), TRUE);
render = gtk_cell_renderer_accel_new ();
g_object_set (render, "editable", TRUE,
#ifndef WIN32
"accel-mode", GTK_CELL_RENDERER_ACCEL_MODE_OTHER,
#endif
NULL);
g_signal_connect (G_OBJECT (render), "accel-edited",
G_CALLBACK (key_dialog_set_key), NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), KEY_COLUMN,
"Key", render,
"text", KEY_COLUMN,
NULL);
render = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes (
GTK_TREE_VIEW (view), ACCEL_COLUMN,
"Accel", render,
"text", ACCEL_COLUMN,
NULL);
combostore = gtk_list_store_new (1, G_TYPE_STRING);
for (i = 0; i <= KEY_MAX_ACTIONS; i++)
{
GtkTreeIter iter;
if (key_actions[i].name[0])
{
gtk_list_store_append (combostore, &iter);
gtk_list_store_set (combostore, &iter, 0, key_actions[i].name, -1);
}
}
render = gtk_cell_renderer_combo_new ();
g_object_set (G_OBJECT (render), "model", combostore,
"has-entry", FALSE,
"editable", TRUE,
"text-column", 0,
NULL);
g_signal_connect (G_OBJECT (render), "edited",
G_CALLBACK (key_dialog_entry_edited), GINT_TO_POINTER (ACTION_COLUMN));
g_signal_connect (G_OBJECT (render), "changed",
G_CALLBACK (key_dialog_combo_changed), combostore);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), ACTION_COLUMN,
"Action", render,
"text", ACTION_COLUMN,
NULL);
render = gtk_cell_renderer_text_new ();
g_object_set (render, "editable", TRUE, NULL);
g_signal_connect (G_OBJECT (render), "edited",
G_CALLBACK (key_dialog_entry_edited), GINT_TO_POINTER (D1_COLUMN));
gtk_tree_view_insert_column_with_attributes (
GTK_TREE_VIEW (view), D1_COLUMN,
"Data1", render,
"text", D1_COLUMN,
NULL);
render = gtk_cell_renderer_text_new ();
g_object_set (render, "editable", TRUE, NULL);
g_signal_connect (G_OBJECT (render), "edited",
G_CALLBACK (key_dialog_entry_edited), GINT_TO_POINTER (D2_COLUMN));
gtk_tree_view_insert_column_with_attributes (
GTK_TREE_VIEW (view), D2_COLUMN,
"Data2", render,
"text", D2_COLUMN,
NULL);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), KEY_COLUMN);
gtk_tree_view_column_set_fixed_width (col, 200);
gtk_tree_view_column_set_resizable (col, TRUE);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), ACCEL_COLUMN);
gtk_tree_view_column_set_visible (col, FALSE);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), ACTION_COLUMN);
gtk_tree_view_column_set_fixed_width (col, 160);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), D1_COLUMN);
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_min_width (col, 80);
gtk_tree_view_column_set_resizable (col, TRUE);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), D2_COLUMN);
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_min_width (col, 80);
gtk_tree_view_column_set_resizable (col, TRUE);
gtk_container_add (GTK_CONTAINER (scroll), view);
gtk_container_add (GTK_CONTAINER (box), scroll);
return view;
}
static GObject *
games_controls_list_constructor (GType type,
guint n_construct_properties,
GObjectConstructParam *construct_params)
{
GObject *object;
GamesControlsList *list;
GtkScrolledWindow *scrolled_window;
GtkTreeViewColumn *column;
GtkCellRenderer *label_renderer, *key_renderer;
GtkListStore *store;
object = G_OBJECT_CLASS (games_controls_list_parent_class)->constructor
(type, n_construct_properties, construct_params);
list = GAMES_CONTROLS_LIST (object);
scrolled_window = GTK_SCROLLED_WINDOW (object);
store = gtk_list_store_new (N_COLUMNS,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_UINT,
G_TYPE_UINT,
G_TYPE_UINT,
G_TYPE_UINT);
list->priv->store = store;
list->priv->model = GTK_TREE_MODEL (store);
list->priv->view = gtk_tree_view_new_with_model (list->priv->model);
g_object_unref (store);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (list->priv->view), FALSE);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (list->priv->view), FALSE);
/* label column */
label_renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Control",
label_renderer,
"text", LABEL_COLUMN,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (list->priv->view), column);
/* key column */
key_renderer = gtk_cell_renderer_accel_new ();
g_object_set (key_renderer,
"editable", TRUE,
"accel-mode", GTK_CELL_RENDERER_ACCEL_MODE_OTHER,
NULL);
g_signal_connect (key_renderer, "accel-edited",
G_CALLBACK (accel_edited_cb), list);
g_signal_connect (key_renderer, "accel-cleared",
G_CALLBACK (accel_cleared_cb), list);
column = gtk_tree_view_column_new_with_attributes ("Key",
key_renderer,
"accel-key", KEYCODE_COLUMN,
"accel-mods", KEYMODS_COLUMN,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (list->priv->view), column);
gtk_container_add (GTK_CONTAINER (scrolled_window), list->priv->view);
return object;
}
/*#
@class GtkCellRendererAccel
@brief Renders a keyboard accelerator in a cell
GtkCellRendererAccel displays a keyboard accelerator (i.e. a key combination
like <Control>-a). If the cell renderer is editable, the accelerator can be
changed by simply typing the new combination.
*/
FALCON_FUNC CellRendererAccel::init( VMARG )
{
NO_ARGS
MYSELF;
self->setObject( (GObject*) gtk_cell_renderer_accel_new() );
}
void
terminal_edit_keys_dialog_show (GtkWindow *transient_parent)
{
TerminalApp *app;
GtkWidget *dialog, *tree_view, *disable_mnemonics_button, *disable_menu_accel_button;
GtkTreeViewColumn *column;
GtkCellRenderer *cell_renderer;
GtkTreeStore *tree;
guint i;
if (edit_keys_dialog != NULL)
goto done;
if (!terminal_util_load_builder_file ("keybinding-editor.ui",
"keybindings-dialog", &dialog,
"disable-mnemonics-checkbutton", &disable_mnemonics_button,
"disable-menu-accel-checkbutton", &disable_menu_accel_button,
"accelerators-treeview", &tree_view,
NULL))
return;
app = terminal_app_get ();
terminal_util_bind_object_property_to_widget (G_OBJECT (app), TERMINAL_APP_ENABLE_MNEMONICS,
disable_mnemonics_button, 0);
terminal_util_bind_object_property_to_widget (G_OBJECT (app), TERMINAL_APP_ENABLE_MENU_BAR_ACCEL,
disable_menu_accel_button, 0);
/* Column 1 */
cell_renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("_Action"),
cell_renderer,
"text", ACTION_COLUMN,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
gtk_tree_view_column_set_sort_column_id (column, ACTION_COLUMN);
/* Column 2 */
cell_renderer = gtk_cell_renderer_accel_new ();
g_object_set (cell_renderer,
"editable", TRUE,
"accel-mode", GTK_CELL_RENDERER_ACCEL_MODE_GTK,
NULL);
g_signal_connect (cell_renderer, "accel-edited",
G_CALLBACK (accel_edited_callback), tree_view);
g_signal_connect (cell_renderer, "accel-cleared",
G_CALLBACK (accel_cleared_callback), tree_view);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Shortcut _Key"));
gtk_tree_view_column_pack_start (column, cell_renderer, TRUE);
gtk_tree_view_column_set_cell_data_func (column, cell_renderer, accel_set_func, NULL, NULL);
gtk_tree_view_column_set_sort_column_id (column, KEYVAL_COLUMN);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
/* Add the data */
tree = edit_keys_store = gtk_tree_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_POINTER);
#ifdef MATE_ENABLE_DEBUG
_TERMINAL_DEBUG_IF (TERMINAL_DEBUG_ACCELS)
g_signal_connect (tree, "row-changed", G_CALLBACK (row_changed), NULL);
#endif
for (i = 0; i < G_N_ELEMENTS (all_entries); ++i)
{
GtkTreeIter parent_iter;
guint j;
gtk_tree_store_append (tree, &parent_iter, NULL);
gtk_tree_store_set (tree, &parent_iter,
ACTION_COLUMN, _(all_entries[i].user_visible_name),
-1);
for (j = 0; j < all_entries[i].n_elements; ++j)
{
KeyEntry *key_entry = &(all_entries[i].key_entry[j]);
GtkTreeIter iter;
gtk_tree_store_insert_with_values (tree, &iter, &parent_iter, -1,
ACTION_COLUMN, _(key_entry->user_visible_name),
KEYVAL_COLUMN, key_entry,
-1);
}
}
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (tree),
KEYVAL_COLUMN, accel_compare_func,
NULL, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (tree), ACTION_COLUMN,
GTK_SORT_ASCENDING);
gtk_tree_view_set_model (GTK_TREE_VIEW (tree_view), GTK_TREE_MODEL (tree));
g_object_unref (tree);
gtk_tree_view_expand_all (GTK_TREE_VIEW (tree_view));
g_signal_connect (notification_group, "accel-changed",
G_CALLBACK (treeview_accel_changed_cb), tree);
edit_keys_dialog = dialog;
g_signal_connect (dialog, "destroy",
G_CALLBACK (edit_keys_dialog_destroy_cb), tree);
g_signal_connect (dialog, "response",
G_CALLBACK (edit_keys_dialog_response_cb),
NULL);
gtk_window_set_default_size (GTK_WINDOW (dialog), -1, 350);
done:
gtk_window_set_transient_for (GTK_WINDOW (edit_keys_dialog), transient_parent);
gtk_window_present (GTK_WINDOW (edit_keys_dialog));
}