static void
egg_property_cell_renderer_init (EggPropertyCellRenderer *renderer)
{
EggPropertyCellRendererPrivate *priv;
renderer->priv = priv = EGG_PROPERTY_CELL_RENDERER_GET_PRIVATE (renderer);
priv->text_renderer = gtk_cell_renderer_text_new ();
priv->spin_renderer = gtk_cell_renderer_spin_new ();
priv->toggle_renderer = gtk_cell_renderer_toggle_new ();
priv->combo_renderer = gtk_cell_renderer_combo_new ();
priv->renderer = priv->text_renderer;
priv->combo_models = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref);
g_object_set (priv->text_renderer,
"editable", TRUE,
NULL);
g_object_set (priv->spin_renderer,
"editable", TRUE,
NULL);
g_object_set (priv->toggle_renderer,
"xalign", 0.0f,
"activatable", TRUE,
"mode", GTK_CELL_RENDERER_MODE_ACTIVATABLE,
NULL);
g_object_set (priv->combo_renderer,
"has-entry", FALSE,
NULL);
g_signal_connect (priv->spin_renderer, "edited",
G_CALLBACK (egg_property_cell_renderer_spin_edited_cb), priv);
g_signal_connect (priv->text_renderer, "edited",
G_CALLBACK (egg_property_cell_renderer_text_edited_cb), NULL);
g_signal_connect (priv->toggle_renderer, "toggled",
G_CALLBACK (egg_property_cell_renderer_toggle_cb), priv);
g_signal_connect (priv->combo_renderer, "changed",
G_CALLBACK (egg_property_cell_renderer_changed_cb), priv);
}
JNIEXPORT jlong JNICALL
Java_org_gnome_gtk_GtkCellRendererSpin_gtk_1cell_1renderer_1spin_1new
(
JNIEnv* env,
jclass cls
)
{
GtkCellRenderer* result;
jlong _result;
// call function
result = gtk_cell_renderer_spin_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;
}
/*
* init breaks tree view and return it if succesfull
* arguments:
* cb - callback to call on treeview double click
*/
gboolean bptree_init(move_to_line_cb cb)
{
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
/* save double click callback */
on_break_clicked = cb;
/* crete hash table for file nodes */
files = g_hash_table_new_full(
g_str_hash,
g_str_equal,
(GDestroyNotify)g_free,
(GDestroyNotify)gtk_tree_row_reference_free
);
/* create tree view */
store = gtk_tree_store_new (
N_COLUMNS,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_INT,
G_TYPE_INT,
G_TYPE_BOOLEAN,
G_TYPE_STRING);
model = GTK_TREE_MODEL(store);
tree = gtk_tree_view_new_with_model (model);
g_object_unref(store);
/* set tree view properties */
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), 1);
gtk_widget_set_has_tooltip(GTK_WIDGET(tree), TRUE);
/* multiple selection */
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
/* connect signals */
g_signal_connect(G_OBJECT(tree), "key-press-event", G_CALLBACK (on_key_pressed), NULL);
g_signal_connect(G_OBJECT(tree), "row-activated", G_CALLBACK (on_row_double_click), NULL);
g_signal_connect(G_OBJECT(tree), "query-tooltip", G_CALLBACK (on_query_tooltip), NULL);
/* creating columns */
/* icon, file */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new();
gtk_tree_view_column_pack_end(column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, on_render_filename, NULL, NULL);
/* enable for file */
renderer = cell_renderer_toggle_new ();
g_signal_connect (G_OBJECT(renderer), "toggled", G_CALLBACK(on_enable_for_file), NULL);
gtk_tree_view_column_pack_end(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer, "active", ENABLED, NULL);
gtk_tree_view_column_set_cell_data_func(column, renderer, on_render_enable_for_file, NULL, NULL);
/* enable breakpoint */
renderer = cell_renderer_break_icon_new ();
g_signal_connect (G_OBJECT(renderer), "clicked", G_CALLBACK(on_enable_break), NULL);
g_object_set(renderer, "pixbuf_enabled", (gpointer)break_pixbuf, NULL);
g_object_set(renderer, "pixbuf_disabled", (gpointer)break_disabled_pixbuf, NULL);
g_object_set(renderer, "pixbuf_conditional", (gpointer)break_condition_pixbuf, NULL);
g_object_set(renderer, "pixbuf_file", (gpointer)break_pixbuf, NULL);
gtk_tree_view_column_pack_end(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer, "enabled", ENABLED, "condition", CONDITION, "hitscount", HITSCOUNT, NULL);
gtk_tree_view_column_set_cell_data_func(column, renderer, on_render_enable_break, NULL, NULL);
gtk_tree_view_column_set_title(column, _("Location"));
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* condition */
condition_renderer = gtk_cell_renderer_text_new ();
g_object_set (condition_renderer, "editable", TRUE, NULL);
g_object_set (condition_renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
g_signal_connect (G_OBJECT (condition_renderer), "edited", G_CALLBACK (on_condition_changed), NULL);
column = gtk_tree_view_column_new_with_attributes (_("Condition"), condition_renderer, "text", CONDITION, NULL);
gtk_tree_view_column_set_cell_data_func(column, condition_renderer, on_render, NULL, NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* hits count */
hcount_renderer = gtk_cell_renderer_spin_new ();
g_object_set (hcount_renderer,
"adjustment", gtk_adjustment_new (0.0, 0.0, 100000.0, 1.0, 2.0, 2.0),
"digits", 0, NULL);
g_signal_connect (G_OBJECT (hcount_renderer), "edited", G_CALLBACK (on_hitscount_changed), NULL);
column = gtk_tree_view_column_new_with_attributes (_("Hit count"), hcount_renderer, "text", HITSCOUNT, NULL);
gtk_tree_view_column_set_cell_data_func(column, hcount_renderer, on_render, (gpointer)TRUE, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* line */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Line"), renderer, "text", LINE, NULL);
gtk_tree_view_column_set_visible(column, FALSE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* Last invisible column */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("", renderer, "text", LAST_VISIBLE, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
tab_breaks = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (tab_breaks);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (tab_breaks), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (tab_breaks), GTK_SHADOW_NONE);
gtk_container_add (GTK_CONTAINER (tab_breaks), tree);
return TRUE;
}
bool change_restrictions(int vars)
{
/* Clear model */
clear_liststore(restrictions_view);
/* Create the dynamic types array */
int size = vars + 2;
GType* types = (GType*) malloc(3 * size * sizeof(GType));
if(types == NULL) {
return false;
}
/* Set type in the dynamic types array */
for(int i = 0; i < size; i++) {
types[i] = G_TYPE_INT; /* Coeffs */
types[size + i] = G_TYPE_STRING; /* Text */
types[2 * size + i] = G_TYPE_STRING; /* Signs */
}
/* Create the new model */
GtkListStore* restrictions = gtk_list_store_newv(3 * size, types);
/* Clear the previous columns */
for(int i = gtk_tree_view_get_n_columns(restrictions_view) - 1; i >= 0; i--) {
gtk_tree_view_remove_column(
restrictions_view,
gtk_tree_view_get_column(restrictions_view, i)
);
}
/* Create the new columns */
for(int i = 0; i < size; i++) {
/* Especial column for type */
if(i == (size - 2)) {
GtkCellRenderer* type = gtk_cell_renderer_text_new();
GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes(
"", type, /* Title, renderer */
"markup", size + i,
NULL);
gtk_tree_view_append_column(restrictions_view, column);
continue;
}
/* Create sign column */
if((i != 0) && (i != size - 1)) {
GtkCellRenderer* sign = gtk_cell_renderer_text_new();
GtkTreeViewColumn* sign_c =
gtk_tree_view_column_new_with_attributes(
"", sign, /* Title, renderer */
"markup", 2 * size + i,
NULL);
gtk_tree_view_append_column(restrictions_view, sign_c);
}
/* Create text column */
/* Create and configure cell */
GtkCellRenderer* cell = gtk_cell_renderer_spin_new();
gtk_cell_renderer_set_alignment(cell, 1.0, 0.5);
g_object_set(cell, "editable", true, NULL);
/* Configure callbacks */
g_signal_connect(G_OBJECT(cell),
"editing-started", G_CALLBACK(restrictions_edit_started_cb),
GINT_TO_POINTER(i));
restrictions_edit_started_cb(cell, NULL, NULL, GINT_TO_POINTER(i));
if(i < size - 2) {
g_signal_connect(G_OBJECT(cell),
"edited", G_CALLBACK(restrictions_edited_cb),
GINT_TO_POINTER(i));
} else {
g_signal_connect(G_OBJECT(cell),
"edited", G_CALLBACK(num_edited_cb),
GINT_TO_POINTER(i));
}
/* Configure column */
GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes(
"", cell, /* Title, renderer */
"markup", size + i,
NULL);
gtk_tree_view_column_set_min_width(column, 100);
gtk_tree_view_append_column(restrictions_view, column);
}
gtk_tree_view_append_column(restrictions_view, gtk_tree_view_column_new());
/* Set the new model */
gtk_tree_view_set_model(restrictions_view, GTK_TREE_MODEL(restrictions));
/* Free resources */
g_object_unref(G_OBJECT(restrictions));
free(types);
return true;
}
bool change_function(int vars)
{
/* Clear model */
clear_liststore(function_view);
/* Create the dynamic types array */
GType* types = (GType*) malloc(3 * vars * sizeof(GType));
if(types == NULL) {
return false;
}
/* Set type in the dynamic types array */
for(int i = 0; i < vars; i++) {
types[i] = G_TYPE_INT; /* Coeffs */
types[vars + i] = G_TYPE_STRING; /* Text */
types[2 * vars + i] = G_TYPE_STRING; /* Signs */
}
/* Create and fill the new model */
GtkListStore* function = gtk_list_store_newv(3 * vars, types);
GtkTreeIter iter;
GValue initi = G_VALUE_INIT;
g_value_init(&initi, G_TYPE_INT);
GValue inits = G_VALUE_INIT;
g_value_init(&inits, G_TYPE_STRING);
gtk_list_store_append(function, &iter);
for(int i = 0; i < vars; i++) {
g_value_set_int(&initi, 1);
gtk_list_store_set_value(function, &iter, i, &initi);
char* text = var_name(1, i, false);
g_value_set_string(&inits, text);
gtk_list_store_set_value(function, &iter, vars + i, &inits);
free(text);
g_value_set_string(&inits, PLUS);
gtk_list_store_set_value(function, &iter, 2 * vars + i, &inits);
}
/* Clear the previous columns */
for(int i = gtk_tree_view_get_n_columns(function_view) - 1; i >= 0; i--) {
gtk_tree_view_remove_column(
function_view,
gtk_tree_view_get_column(function_view, i)
);
}
/* Create the new columns */
for(int i = 0; i < vars; i++) {
/* Create sign column */
if(i > 0) {
GtkCellRenderer* sign = gtk_cell_renderer_text_new();
GtkTreeViewColumn* sign_c =
gtk_tree_view_column_new_with_attributes(
"", sign, /* Title, renderer */
"markup", 2 * vars + i,
NULL);
gtk_tree_view_append_column(function_view, sign_c);
}
/* Create text column */
/* Create and configure cell */
GtkCellRenderer* cell = gtk_cell_renderer_spin_new();
gtk_cell_renderer_set_alignment(cell, 1.0, 0.5);
g_object_set(cell, "editable", true, NULL);
/* Configure callbacks */
g_signal_connect(G_OBJECT(cell),
"editing-started", G_CALLBACK(function_edit_started_cb),
GINT_TO_POINTER(i));
function_edit_started_cb(cell, NULL, NULL, GINT_TO_POINTER(i));
g_signal_connect(G_OBJECT(cell),
"edited", G_CALLBACK(function_edited_cb),
GINT_TO_POINTER(i));
/* Configure column */
GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes(
"", cell, /* Title, renderer */
"markup", vars + i,
NULL);
gtk_tree_view_column_set_min_width(column, 100);
gtk_tree_view_append_column(function_view, column);
}
gtk_tree_view_append_column(function_view, gtk_tree_view_column_new());
/* Set the new model */
gtk_tree_view_set_model(function_view, GTK_TREE_MODEL(function));
/* Free resources */
g_object_unref(G_OBJECT(function));
free(types);
return true;
}
static void
dialog_kaplan_meier_tool_setup_treeview (KaplanMeierToolState *state)
{
guint i;
GtkCellRenderer *renderer;
GtkWidget *scrolled = glade_xml_get_widget (state->base.gui, "groups-scrolled");
GtkTreeSelection *selection;
state->groups_treeview = GTK_TREE_VIEW (glade_xml_get_widget
(state->base.gui,
"groups-tree"));
state->groups_list = gtk_list_store_new (GROUP_COLUMNS,
G_TYPE_STRING, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_OBJECT, G_TYPE_OBJECT);
state->groups_treeview = GTK_TREE_VIEW (gtk_tree_view_new_with_model
(GTK_TREE_MODEL (state->groups_list)));
selection = gtk_tree_view_get_selection (state->groups_treeview);
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
for (i = 0; i<2; i++)
dialog_kaplan_meier_tool_treeview_add_item (state, i);
g_signal_connect (selection,
"changed",
G_CALLBACK (cb_selection_changed), state);
renderer = gtk_cell_renderer_text_new ();
g_object_set (G_OBJECT (renderer),
"editable", TRUE,
NULL);
gtk_tree_view_insert_column_with_attributes (state->groups_treeview,
-1, _("Group"),
renderer,
"text", GROUP_NAME,
NULL);
g_signal_connect (G_OBJECT (renderer), "edited",
G_CALLBACK (cb_group_name_edited), state);
renderer = gtk_cell_renderer_spin_new ();
g_object_set (G_OBJECT (renderer), "editable", TRUE, "xalign", 1.0,
"digits", 0, NULL);
g_signal_connect (G_OBJECT (renderer), "edited",
G_CALLBACK (cb_change_from), state);
gtk_tree_view_insert_column_with_attributes (state->groups_treeview,
-1, _("From"),
renderer,
"text", GROUP_FROM,
"adjustment", GROUP_ADJUSTMENT_FROM,
NULL);
renderer = gtk_cell_renderer_spin_new ();
g_object_set (G_OBJECT (renderer), "editable", TRUE, "xalign", 1.0,
"digits", 0, NULL);
g_signal_connect (G_OBJECT (renderer), "edited",
G_CALLBACK (cb_change_to), state);
gtk_tree_view_insert_column_with_attributes (state->groups_treeview,
-1, _("To"),
renderer,
"text", GROUP_TO,
"adjustment", GROUP_ADJUSTMENT_TO,
NULL);
gtk_container_add (GTK_CONTAINER (scrolled), GTK_WIDGET (state->groups_treeview));
cb_selection_changed (selection, state);
}
static GtkTreeViewColumn *
eprop_model_generate_column (GladeEditorProperty * eprop,
gint colnum, GladeModelData * data)
{
GtkTreeViewColumn *column = gtk_tree_view_column_new ();
GtkCellRenderer *renderer = NULL;
GtkAdjustment *adjustment;
GtkListStore *store;
GType type = G_TYPE_INVALID;
gtk_tree_view_column_set_title (column, data->name);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_expand (column, TRUE);
type = G_VALUE_TYPE (&data->value);
/* Support enum and flag types, and a hardcoded list of fundamental types */
if (type == G_TYPE_CHAR ||
type == G_TYPE_UCHAR || type == G_TYPE_STRING || type == GDK_TYPE_PIXBUF)
{
/* Text renderer */
renderer = gtk_cell_renderer_text_new ();
g_object_set (G_OBJECT (renderer),
"editable", TRUE,
"ellipsize", PANGO_ELLIPSIZE_END, "width", 90, NULL);
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"text", NUM_COLUMNS + colnum, NULL);
if (type == G_TYPE_CHAR || type == G_TYPE_UCHAR)
{
/* XXX restrict to 1 char !! */
}
g_signal_connect (G_OBJECT (renderer), "edited",
G_CALLBACK (value_text_edited), eprop);
/* Trigger i18n dialog from here */
if (type == G_TYPE_STRING)
{
GtkCellRenderer *icon_renderer = glade_cell_renderer_icon_new ();
g_object_set (G_OBJECT (icon_renderer),
"activatable", TRUE,
"icon-name", "gtk-edit",
NULL);
gtk_tree_view_column_pack_start (column, icon_renderer, FALSE);
g_object_set_data (G_OBJECT (icon_renderer), "column-number",
GINT_TO_POINTER (colnum));
g_signal_connect (G_OBJECT (icon_renderer), "activate",
G_CALLBACK (value_i18n_activate), eprop);
}
}
else if (type == G_TYPE_BOOLEAN)
{
/* Toggle renderer */
renderer = gtk_cell_renderer_toggle_new ();
g_object_set (G_OBJECT (renderer), "activatable", TRUE, NULL);
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"active", NUM_COLUMNS + colnum,
NULL);
g_signal_connect (G_OBJECT (renderer), "toggled",
G_CALLBACK (value_toggled), eprop);
}
/* Check renderer */
else if (type == G_TYPE_INT ||
type == G_TYPE_UINT ||
type == G_TYPE_LONG ||
type == G_TYPE_ULONG ||
type == G_TYPE_INT64 ||
type == G_TYPE_UINT64 ||
type == G_TYPE_FLOAT || type == G_TYPE_DOUBLE)
{
/* Spin renderer */
renderer = gtk_cell_renderer_spin_new ();
adjustment =
(GtkAdjustment *) gtk_adjustment_new (0, -G_MAXDOUBLE, G_MAXDOUBLE,
100, 100, 0);
g_object_set (G_OBJECT (renderer), "editable", TRUE, "adjustment",
adjustment, NULL);
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer,
"text", NUM_COLUMNS + colnum, NULL);
if (type == G_TYPE_FLOAT || type == G_TYPE_DOUBLE)
g_object_set (G_OBJECT (renderer), "digits", 2, NULL);
g_signal_connect (G_OBJECT (renderer), "edited",
G_CALLBACK (value_text_edited), eprop);
}
else if (G_TYPE_IS_ENUM (type))
{
/* Combo renderer */
renderer = gtk_cell_renderer_combo_new ();
store = glade_utils_liststore_from_enum_type (type, FALSE);
g_object_set (G_OBJECT (renderer),
"editable", TRUE,
"text-column", 0, "has-entry", FALSE, "model", store, NULL);
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer,
"text", NUM_COLUMNS + colnum, NULL);
gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (column),
renderer,
(GtkCellLayoutDataFunc)
enum_flags_format_cell_data, NULL,
NULL);
g_signal_connect (G_OBJECT (renderer), "edited",
G_CALLBACK (value_text_edited), eprop);
}
else if (G_TYPE_IS_FLAGS (type))
{
/* Export a flags dialog from glade-editor-property... */
renderer = gtk_cell_renderer_text_new ();
g_object_set (G_OBJECT (renderer), "editable", FALSE, NULL);
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"text", NUM_COLUMNS + colnum, NULL);
}
else /* All uneditable types at this point (currently we dont do object data here, TODO) */
{
/* text renderer and object dialog (or raw text for pixbuf) */
renderer = gtk_cell_renderer_text_new ();
g_object_set (G_OBJECT (renderer), "editable", FALSE, NULL);
gtk_tree_view_column_pack_start (column, renderer, FALSE);
}
g_signal_connect (G_OBJECT (renderer), "editing-started",
G_CALLBACK (data_editing_started), eprop);
g_signal_connect (G_OBJECT (renderer), "editing-canceled",
G_CALLBACK (data_editing_canceled), eprop);
g_object_set_data (G_OBJECT (renderer), "column-number",
GINT_TO_POINTER (colnum));
g_object_set_data_full (G_OBJECT (column), "column-type",
g_memdup (&type, sizeof (GType)), g_free);
return column;
}
static void
set_columns_type (GtkTreeView *tree_view, ColumnsType type)
{
GtkTreeViewColumn *col;
GtkCellRenderer *rend;
GdkPixbuf *pixbuf;
GtkWidget *image;
GtkAdjustment *adjustment;
current_column_type = type;
col = gtk_tree_view_get_column (tree_view, 0);
while (col)
{
gtk_tree_view_remove_column (tree_view, col);
col = gtk_tree_view_get_column (tree_view, 0);
}
gtk_tree_view_set_rules_hint (tree_view, FALSE);
switch (type)
{
case COLUMNS_NONE:
break;
case COLUMNS_LOTS:
/* with lots of columns we need to turn on rules */
gtk_tree_view_set_rules_hint (tree_view, TRUE);
rend = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes ("Column 1",
rend,
"text", 1,
NULL);
setup_column (col);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title (col, "Column 2");
rend = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (col, rend, FALSE);
gtk_tree_view_column_add_attribute (col, rend, "pixbuf", 2);
rend = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (col, rend, TRUE);
gtk_tree_view_column_add_attribute (col, rend, "text", 0);
setup_column (col);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
gtk_tree_view_set_expander_column (tree_view, col);
rend = gtk_cell_renderer_toggle_new ();
g_signal_connect (rend, "toggled",
G_CALLBACK (toggled_callback), tree_view);
col = gtk_tree_view_column_new_with_attributes ("Column 3",
rend,
"active", BOOL_COLUMN,
NULL);
setup_column (col);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **)book_closed_xpm);
image = gtk_image_new_from_pixbuf (pixbuf);
g_object_unref (pixbuf);
gtk_widget_show (image);
gtk_tree_view_column_set_widget (col, image);
rend = gtk_cell_renderer_toggle_new ();
/* you could also set this per-row by tying it to a column
* in the model of course.
*/
g_object_set (rend, "radio", TRUE, NULL);
g_signal_connect (rend, "toggled",
G_CALLBACK (toggled_callback), tree_view);
col = gtk_tree_view_column_new_with_attributes ("Column 4",
rend,
"active", BOOL_COLUMN,
NULL);
setup_column (col);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
rend = gtk_cell_renderer_spin_new ();
adjustment = gtk_adjustment_new (0, 0, 10000, 100, 100, 100);
g_object_set (rend, "editable", TRUE, NULL);
g_object_set (rend, "adjustment", adjustment, NULL);
g_signal_connect (rend, "edited",
G_CALLBACK (edited_callback), tree_view);
col = gtk_tree_view_column_new_with_attributes ("Column 5",
rend,
"text", 4,
NULL);
setup_column (col);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
#if 0
rend = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes ("Column 6",
rend,
"text", 4,
NULL);
setup_column (col);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
rend = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes ("Column 7",
rend,
"text", 5,
NULL);
setup_column (col);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
rend = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes ("Column 8",
rend,
"text", 6,
NULL);
setup_column (col);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
rend = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes ("Column 9",
rend,
"text", 7,
NULL);
setup_column (col);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
rend = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes ("Column 10",
rend,
"text", 8,
NULL);
setup_column (col);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
#endif
/* FALL THRU */
case COLUMNS_ONE:
rend = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes ("Column 0",
rend,
"text", 0,
NULL);
setup_column (col);
gtk_tree_view_insert_column (GTK_TREE_VIEW (tree_view), col, 0);
default:
break;
}
}
static GtkWidget *
glade_eprop_attrs_view (GladeEditorProperty *eprop)
{
GladeEPropAttrs *eprop_attrs = GLADE_EPROP_ATTRS (eprop);
GtkWidget *view_widget;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkAdjustment *adjustment;
eprop_attrs->model = (GtkTreeModel *)
gtk_list_store_new (NUM_COLUMNS,
/* Main Data */
G_TYPE_STRING, // COLUMN_NAME
G_TYPE_INT, // COLUMN_NAME_WEIGHT
G_TYPE_INT, // COLUMN_TYPE
G_TYPE_INT, // COLUMN_EDIT_TYPE
G_TYPE_POINTER, // COLUMN_VALUE
G_TYPE_UINT, // COLUMN_START
G_TYPE_UINT, // COLUMN_END
/* Editor renderer related */
G_TYPE_BOOLEAN, // COLUMN_TOGGLE_ACTIVE
G_TYPE_BOOLEAN, // COLUMN_TOGGLE_DOWN
G_TYPE_BOOLEAN, // COLUMN_BUTTON_ACTIVE
G_TYPE_STRING, // COLUMN_TEXT
G_TYPE_INT, // COLUMN_TEXT_STYLE
G_TYPE_STRING, // COLUMN_TEXT_FG
G_TYPE_BOOLEAN, // COLUMN_COMBO_ACTIVE
GTK_TYPE_LIST_STORE, // COLUMN_COMBO_MODEL
G_TYPE_BOOLEAN, // COLUMN_SPIN_ACTIVE
G_TYPE_UINT); // COLUMN_SPIN_DIGITS
view_widget = gtk_tree_view_new_with_model (eprop_attrs->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);
/********************* attribute 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
(_("Attribute"), renderer,
"text", COLUMN_NAME, "weight", COLUMN_NAME_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);
/********************* attribute value column *********************/
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Value"));
/* Toggle renderer */
renderer = gtk_cell_renderer_toggle_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"activatable", COLUMN_TOGGLE_ACTIVE,
"visible", COLUMN_TOGGLE_ACTIVE,
"active", COLUMN_TOGGLE_DOWN, NULL);
g_signal_connect (G_OBJECT (renderer), "toggled",
G_CALLBACK (value_toggled), eprop);
/* Text renderer */
renderer = gtk_cell_renderer_text_new ();
g_object_set (G_OBJECT (renderer), "editable", FALSE, NULL);
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"editable", COLUMN_BUTTON_ACTIVE,
"visible", COLUMN_BUTTON_ACTIVE,
"text", COLUMN_TEXT,
"style", COLUMN_TEXT_STYLE,
"foreground", COLUMN_TEXT_FG, NULL);
/* Icon renderer */
renderer = glade_cell_renderer_icon_new ();
g_object_set (G_OBJECT (renderer), "icon-name", GTK_STOCK_EDIT, NULL);
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"activatable", COLUMN_BUTTON_ACTIVE,
"visible", COLUMN_BUTTON_ACTIVE, NULL);
g_signal_connect (G_OBJECT (renderer), "activate",
G_CALLBACK (value_icon_activate), eprop);
/* Combo renderer */
renderer = gtk_cell_renderer_combo_new ();
g_object_set (G_OBJECT (renderer), "text-column", 0, "has-entry", FALSE,
NULL);
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer,
"editable", COLUMN_COMBO_ACTIVE,
"visible", COLUMN_COMBO_ACTIVE,
"model", COLUMN_COMBO_MODEL,
"text", COLUMN_TEXT,
"style", COLUMN_TEXT_STYLE,
"foreground", COLUMN_TEXT_FG, NULL);
g_signal_connect (G_OBJECT (renderer), "edited",
G_CALLBACK (value_combo_spin_edited), eprop);
/* Spin renderer */
renderer = gtk_cell_renderer_spin_new ();
adjustment =
(GtkAdjustment *) gtk_adjustment_new (0, -G_MAXDOUBLE, G_MAXDOUBLE, 100,
100, 100);
g_object_set (G_OBJECT (renderer), "adjustment", adjustment, NULL);
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer,
"visible", COLUMN_SPIN_ACTIVE,
"editable", COLUMN_SPIN_ACTIVE,
"text", COLUMN_TEXT,
"style", COLUMN_TEXT_STYLE,
"foreground", COLUMN_TEXT_FG,
"digits", COLUMN_SPIN_DIGITS, NULL);
g_signal_connect (G_OBJECT (renderer), "edited",
G_CALLBACK (value_combo_spin_edited), eprop);
g_signal_connect (G_OBJECT (renderer), "editing-started",
G_CALLBACK (value_combo_spin_editing_started), 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 GtkTreeViewColumn *
create_column(n_list_store *list, int i)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *col;
GtkTreeModel *model;
switch (list[i].type) {
case G_TYPE_BOOLEAN:
renderer = gtk_cell_renderer_toggle_new();
col = gtk_tree_view_column_new_with_attributes(_(list[i].title), renderer,
"active", i, NULL);
if (list[i].editable) {
g_object_set(renderer, "mode", GTK_CELL_RENDERER_MODE_ACTIVATABLE, NULL);
g_object_set_data(G_OBJECT(renderer), "user-data", &list[i]);
}
break;
case G_TYPE_INT:
case G_TYPE_UINT:
case G_TYPE_LONG:
case G_TYPE_ULONG:
case G_TYPE_INT64:
case G_TYPE_UINT64:
case G_TYPE_FLOAT:
case G_TYPE_DOUBLE:
#if GTK_CHECK_VERSION(3, 8, 0) || ! GTK_CHECK_VERSION(3, 0, 0)
renderer = gtk_cell_renderer_spin_new();
#else
renderer = gtk_cell_renderer_text_new();
#endif
col = gtk_tree_view_column_new_with_attributes(_(list[i].title), renderer,
"text", i, NULL);
gtk_tree_view_column_set_resizable(col, TRUE);
g_object_set((GObject *) renderer, "xalign", (gfloat) 1.0, NULL);
if (list[i].editable) {
if (list[i].type == G_TYPE_DOUBLE || list[i].type == G_TYPE_FLOAT) {
g_object_set((GObject *) renderer,
"editable", list[i].editable,
#if GTK_CHECK_VERSION(3, 8, 0) || ! GTK_CHECK_VERSION(3, 0, 0)
"adjustment", gtk_adjustment_new(0,
list[i].min / 100.0,
list[i].max / 100.0,
list[i].inc / 100.0,
list[i].page / 100.0,
0),
"digits", 2,
#endif
NULL);
g_object_set_data(G_OBJECT(renderer), "user-data", &list[i]);
} else {
g_object_set((GObject *) renderer,
"editable", list[i].editable,
#if GTK_CHECK_VERSION(3, 8, 0) || ! GTK_CHECK_VERSION(3, 0, 0)
"adjustment", gtk_adjustment_new(0,
list[i].min,
list[i].max,
list[i].inc,
list[i].page,
0),
"digits", 0,
#endif
NULL);
g_object_set_data(G_OBJECT(renderer), "user-data", &list[i]);
}
}
if (list[i].editable) {
gtk_tree_view_column_set_expand(col, TRUE);
}
break;
case G_TYPE_OBJECT:
renderer = gtk_cell_renderer_pixbuf_new();
g_object_set((GObject *) renderer,
"mode", (list[i].editable) ?
GTK_CELL_RENDERER_MODE_EDITABLE :
GTK_CELL_RENDERER_MODE_INERT,
"sensitive", list[i].editable,
NULL);
g_object_set_data(G_OBJECT(renderer), "user-data", &list[i]);
GTK_CELL_RENDERER_GET_CLASS(renderer)->start_editing = start_editing_obj;
col = gtk_tree_view_column_new_with_attributes(_(list[i].title), renderer,
"pixbuf", i, NULL);
break;
case G_TYPE_PARAM:
renderer = gtk_cell_renderer_combo_new();
model = create_object_tree_model();
g_object_set((GObject *) renderer,
"has-entry", FALSE,
"model", model,
"text-column", OBJECT_COLUMN_TYPE_STRING,
"editable", list[i].editable,
NULL);
g_object_set_data(G_OBJECT(renderer), "user-data", &list[i]);
col = gtk_tree_view_column_new_with_attributes(_(list[i].title), renderer,
"text", i, NULL);
break;
case G_TYPE_ENUM:
renderer = gtk_cell_renderer_combo_new();
model = GTK_TREE_MODEL(gtk_list_store_new(1, G_TYPE_STRING));
g_object_set((GObject *) renderer,
"has-entry", FALSE,
"model", model,
"text-column", 0,
"editable", list[i].editable,
NULL);
g_object_set_data(G_OBJECT(renderer), "user-data", &list[i]);
col = gtk_tree_view_column_new_with_attributes(_(list[i].title), renderer,
"text", i, NULL);
break;
case G_TYPE_STRING:
default:
renderer = gtk_cell_renderer_text_new();
g_object_set((GObject *) renderer,
"editable", list[i].editable,
"ellipsize", list[i].ellipsize,
NULL);
g_object_set_data(G_OBJECT(renderer), "user-data", &list[i]);
col = gtk_tree_view_column_new_with_attributes(_(list[i].title), renderer,
"text", i, NULL);
gtk_tree_view_column_set_resizable(col, TRUE);
if (list[i].ellipsize != PANGO_ELLIPSIZE_NONE || list[i].editable) {
gtk_tree_view_column_set_expand(col, TRUE);
}
}
return col;
}
/**
* empathy_irc_network_dialog_show:
* @network: the #EmpathyIrcNetwork to configure
* @parent: the parent of this dialog
*
* Display a dialog to configure a given #EmpathyIrcNetwork.
* This function is a singleton so if a configuration dialog already
* exists we use this one to edit the network.
*
* Returns: The displayed #GtkDialog
*/
GtkWidget *
empathy_irc_network_dialog_show (EmpathyIrcNetwork *network,
GtkWidget *parent)
{
static EmpathyIrcNetworkDialog *dialog = NULL;
GladeXML *glade;
GtkListStore *store;
GtkCellRenderer *renderer;
GtkAdjustment *adjustment;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
gchar *filename;
g_return_val_if_fail (network != NULL, NULL);
if (dialog != NULL)
{
change_network (dialog, network);
gtk_window_present (GTK_WINDOW (dialog->dialog));
return dialog->dialog;
}
dialog = g_slice_new0 (EmpathyIrcNetworkDialog);
dialog->network = network;
g_object_ref (dialog->network);
filename = empathy_file_lookup ("empathy-account-widget-irc.glade",
"libempathy-gtk");
glade = empathy_glade_get_file (filename,
"irc_network_dialog",
NULL,
"irc_network_dialog", &dialog->dialog,
"button_close", &dialog->button_close,
"entry_network", &dialog->entry_network,
"combobox_charset", &dialog->combobox_charset,
"treeview_servers", &dialog->treeview_servers,
"button_add", &dialog->button_add,
"button_remove", &dialog->button_remove,
"button_up", &dialog->button_up,
"button_down", &dialog->button_down,
NULL);
g_free (filename);
store = gtk_list_store_new (4, G_TYPE_OBJECT, G_TYPE_STRING,
G_TYPE_UINT, G_TYPE_BOOLEAN);
gtk_tree_view_set_model (GTK_TREE_VIEW (dialog->treeview_servers),
GTK_TREE_MODEL (store));
g_object_unref (store);
/* address */
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "editable", TRUE, NULL);
g_signal_connect (renderer, "edited",
G_CALLBACK (irc_network_dialog_address_edited_cb), dialog);
gtk_tree_view_insert_column_with_attributes (
GTK_TREE_VIEW (dialog->treeview_servers),
-1, _("Server"), renderer, "text", COL_ADR,
NULL);
/* port */
adjustment = (GtkAdjustment *) gtk_adjustment_new (6667, 1, G_MAXUINT16,
1, 10, 0);
renderer = gtk_cell_renderer_spin_new ();
g_object_set (renderer,
"editable", TRUE,
"adjustment", adjustment,
NULL);
g_signal_connect (renderer, "edited",
G_CALLBACK (irc_network_dialog_port_edited_cb), dialog);
gtk_tree_view_insert_column_with_attributes (
GTK_TREE_VIEW (dialog->treeview_servers),
-1, _("Port"), renderer, "text", COL_PORT,
NULL);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (dialog->treeview_servers),
1);
gtk_tree_view_column_set_expand (column, TRUE);
/* SSL */
renderer = gtk_cell_renderer_toggle_new ();
g_object_set (renderer, "activatable", TRUE, NULL);
g_signal_connect (renderer, "toggled",
G_CALLBACK (irc_network_dialog_ssl_toggled_cb), dialog);
gtk_tree_view_insert_column_with_attributes (
GTK_TREE_VIEW (dialog->treeview_servers),
-1, _("SSL"), renderer, "active", COL_SSL,
NULL);
selection = gtk_tree_view_get_selection (
GTK_TREE_VIEW (dialog->treeview_servers));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
/* charset */
totem_subtitle_encoding_init (GTK_COMBO_BOX (dialog->combobox_charset));
irc_network_dialog_setup (dialog);
empathy_glade_connect (glade, dialog,
"irc_network_dialog", "destroy", irc_network_dialog_destroy_cb,
"button_close", "clicked", irc_network_dialog_close_clicked_cb,
"entry_network", "focus-out-event", irc_network_dialog_network_focus_cb,
"button_add", "clicked", irc_network_dialog_button_add_clicked_cb,
"button_remove", "clicked", irc_network_dialog_button_remove_clicked_cb,
"button_up", "clicked", irc_network_dialog_button_up_clicked_cb,
"button_down", "clicked", irc_network_dialog_button_down_clicked_cb,
"combobox_charset", "changed", irc_network_dialog_combobox_charset_changed_cb,
NULL);
g_object_unref (glade);
g_object_add_weak_pointer (G_OBJECT (dialog->dialog),
(gpointer) &dialog);
g_signal_connect (selection, "changed",
G_CALLBACK (irc_network_dialog_selection_changed_cb),
dialog);
gtk_window_set_transient_for (GTK_WINDOW (dialog->dialog),
GTK_WINDOW (parent));
gtk_window_set_modal (GTK_WINDOW (dialog->dialog), TRUE);
irc_network_dialog_network_update_buttons (dialog);
return dialog->dialog;
}
static VALUE
crspin_initialize(VALUE self)
{
RBGTK_INITIALIZE(self, gtk_cell_renderer_spin_new());
return Qnil;
}
