int main(int argc, char *argv[])
{
gtk_init(&argc, &argv);
GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_signal_connect(window, "destroy", G_CALLBACK(destroy), NULL);
GtkListStore *liststore = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING);
GtkTreeIter treeiter;
gtk_list_store_append(liststore, &treeiter);
gtk_list_store_set(liststore, &treeiter, 0, "Television", 1, "", -1);
gtk_list_store_append(liststore, &treeiter);
gtk_list_store_set(liststore, &treeiter, 0, "Mobile Phone", 1, "", -1);
gtk_list_store_append(liststore, &treeiter);
gtk_list_store_set(liststore, &treeiter, 0, "DVD Player", 1, "", -1);
GtkListStore *liststoreManufacturer = gtk_list_store_new(1, G_TYPE_STRING);
GtkTreeIter treeiter2;
gtk_list_store_append(liststoreManufacturer, &treeiter2);
gtk_list_store_set(liststoreManufacturer, &treeiter2, 0, "Sony", -1);
gtk_list_store_append(liststoreManufacturer, &treeiter2);
gtk_list_store_set(liststoreManufacturer, &treeiter2, 0, "Samsung", -1);
gtk_list_store_append(liststoreManufacturer, &treeiter2);
gtk_list_store_set(liststoreManufacturer, &treeiter2, 0, "LG", -1);
GtkWidget *treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(liststore));
gtk_container_add(GTK_CONTAINER(window), treeview);
GtkTreeViewColumn *treeviewcolumn;
GtkCellRenderer *cellrenderertext;
GtkCellRenderer *cellrenderercombo;
cellrenderertext = gtk_cell_renderer_text_new();
treeviewcolumn = gtk_tree_view_column_new_with_attributes("Device",
cellrenderertext,
"text", 0, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), treeviewcolumn);
cellrenderercombo = gtk_cell_renderer_combo_new();
gtk_widget_set_property(GTK_WIDGET(cellrenderercombo), "model", liststoreManufacturer);
treeviewcolumn = gtk_tree_view_column_new_with_attributes("Manufacturer",
cellrenderercombo,
"editable", TRUE,
"model", liststoreManufacturer,
"text-column", 0, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), treeviewcolumn);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
static void
add_columns (GtkTreeView *treeview,
GtkTreeModel *items_model,
GtkTreeModel *numbers_model)
{
GtkCellRenderer *renderer;
/* number column */
renderer = gtk_cell_renderer_combo_new ();
g_object_set (renderer,
"model", numbers_model,
"text-column", COLUMN_NUMBER_TEXT,
"has-entry", FALSE,
"editable", TRUE,
NULL);
g_signal_connect (renderer, "edited",
G_CALLBACK (cell_edited), items_model);
g_signal_connect (renderer, "editing-started",
G_CALLBACK (editing_started), NULL);
g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (COLUMN_ITEM_NUMBER));
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
-1, "Number", renderer,
"text", COLUMN_ITEM_NUMBER,
NULL);
/* product column */
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer,
"editable", TRUE,
NULL);
g_signal_connect (renderer, "edited",
G_CALLBACK (cell_edited), items_model);
g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (COLUMN_ITEM_PRODUCT));
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
-1, "Product", renderer,
"text", COLUMN_ITEM_PRODUCT,
NULL);
/* yummy column */
renderer = gtk_cell_renderer_progress_new ();
g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (COLUMN_ITEM_YUMMY));
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
-1, "Yummy", renderer,
"value", COLUMN_ITEM_YUMMY,
NULL);
}
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);
}
GtkWidget *create_treeview(IMAGE *ima){
int i, i_max = sizeof(key_types)/sizeof(char*);;
GtkTreeIter iter;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
if(combo_)
gtk_list_store_clear(combo_);
combo_ = gtk_list_store_new(1, G_TYPE_STRING);
for(i = 0; i < i_max; i++){
gtk_list_store_append(combo_, &iter);
gtk_list_store_set(combo_, &iter, 0, key_types[i], -1);
}
// create list (treeview) according model store
Tree = (GtkTreeView*)gtk_tree_view_new_with_model(GTK_TREE_MODEL(ima->store));
// Create columns in list
for(i = 0; i < VISIBLE_COLS; i++){
if(i == 0){
renderer = gtk_cell_renderer_combo_new();
g_object_set(renderer, "text-column", 0,
"editable", TRUE, "has-entry", FALSE, "model",
GTK_TREE_MODEL(combo_), NULL);
}
else{
renderer = gtk_cell_renderer_text_new ();
g_object_set(renderer, "editable", TRUE, NULL);
}
g_object_set_data(G_OBJECT(renderer), "column_num", GINT_TO_POINTER(i));
column = gtk_tree_view_column_new_with_attributes(_(colnames[i]),
renderer, "text", i, NULL);
gtk_tree_view_append_column(Tree, column); // insert column
gtk_tree_view_column_set_sort_column_id(column, i);// it may be sorted
g_signal_connect(renderer, "edited", G_CALLBACK(edit_cell), ima);
// g_signal_connect(renderer, "editing-canceled", G_CALLBACK(cancel_edit), NULL);
}
/*
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("hidden",renderer, NULL);
g_object_set(column, "visible", FALSE, NULL);
gtk_tree_view_append_column(Tree, column);
*/
return GTK_WIDGET(Tree);
}
JNIEXPORT jlong JNICALL
Java_org_gnome_gtk_GtkCellRendererCombo_gtk_1cell_1renderer_1combo_1new
(
JNIEnv* env,
jclass cls
)
{
GtkCellRenderer* result;
jlong _result;
// call function
result = gtk_cell_renderer_combo_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;
}
Compose * compose_new(Config * config)
{
Compose * compose;
GtkAccelGroup * group;
GtkWidget * vbox;
GtkWidget * toolbar;
GtkToolItem * toolitem;
GtkSizeGroup * sizegroup;
GtkWidget * vpaned;
GtkWidget * vbox2;
GtkWidget * widget;
GtkCellRenderer * renderer;
GtkTreeViewColumn * column;
GtkTreeIter iter;
char const * headers[] = {
"To:", "Cc:", "Bcc:", "Reply-To:", "Newsgroup:",
"Followup-To:" };
size_t i;
if((compose = malloc(sizeof(*compose))) == NULL)
{
compose_error(NULL, strerror(errno), 0);
return NULL;
}
compose->mime = mime_new(NULL);
/* check errors */
if(compose->mime == NULL)
{
free(compose);
return NULL;
}
compose->config = config;
compose->standalone = FALSE;
/* window */
group = gtk_accel_group_new();
compose->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_add_accel_group(GTK_WINDOW(compose->window), group);
#ifndef EMBEDDED
gtk_window_set_default_size(GTK_WINDOW(compose->window), 512, 384);
#else
gtk_window_set_default_size(GTK_WINDOW(compose->window), 200, 300);
#endif
gtk_window_set_title(GTK_WINDOW(compose->window), _("Compose"));
#if GTK_CHECK_VERSION(2, 6, 0)
gtk_window_set_icon_name(GTK_WINDOW(compose->window), "mailer");
#endif
g_signal_connect_swapped(G_OBJECT(compose->window), "delete-event",
G_CALLBACK(_compose_on_closex), compose);
vbox = gtk_vbox_new(FALSE, 0);
/* menubar */
#ifndef EMBEDDED
widget = desktop_menubar_create(_compose_menubar, compose, group);
gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, FALSE, 0);
#endif
/* toolbar */
toolbar = desktop_toolbar_create(_compose_toolbar, compose, group);
gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, TRUE, 0);
/* from */
sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
toolbar = gtk_toolbar_new();
widget = gtk_label_new(_("From: "));
gtk_misc_set_alignment(GTK_MISC(widget), 0.1, 0.5);
gtk_widget_set_size_request(widget, 80, -1);
gtk_size_group_add_widget(sizegroup, widget);
toolitem = gtk_tool_item_new();
gtk_container_add(GTK_CONTAINER(toolitem), widget);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
#if GTK_CHECK_VERSION(2, 24, 0)
compose->from = gtk_combo_box_text_new_with_entry();
#else
compose->from = gtk_combo_box_entry_new_text();
#endif
toolitem = gtk_tool_item_new();
gtk_tool_item_set_expand(toolitem, TRUE);
gtk_container_add(GTK_CONTAINER(toolitem), compose->from);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0);
/* paned */
vpaned = gtk_vpaned_new();
/* headers */
widget = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
compose->h_store = gtk_list_store_new(CHC_COUNT, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_BOOLEAN);
compose->h_store_filter = gtk_tree_model_filter_new(GTK_TREE_MODEL(
compose->h_store), NULL);
gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(
compose->h_store_filter),
_compose_on_headers_filter, compose, NULL);
compose->h_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(
compose->h_store_filter));
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(compose->h_view),
FALSE);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(compose->h_view), TRUE);
compose->h_headers = gtk_list_store_new(2, G_TYPE_STRING,
G_TYPE_STRING);
for(i = 0; i < sizeof(headers) / sizeof(*headers); i++)
{
gtk_list_store_append(compose->h_headers, &iter);
gtk_list_store_set(compose->h_headers, &iter, 0, headers[i], 1,
headers[i], -1);
}
renderer = gtk_cell_renderer_combo_new();
g_object_set(renderer, "editable", TRUE, "model", compose->h_headers,
"text-column", 1, NULL);
g_signal_connect(G_OBJECT(renderer), "edited", G_CALLBACK(
_on_header_field_edited), compose);
column = gtk_tree_view_column_new_with_attributes("", renderer, "text",
CHC_HEADER, NULL);
gtk_tree_view_column_set_min_width(column, 80);
gtk_tree_view_append_column(GTK_TREE_VIEW(compose->h_view), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "editable", TRUE, NULL);
g_signal_connect(G_OBJECT(renderer), "edited", G_CALLBACK(
_on_header_edited), compose);
column = gtk_tree_view_column_new_with_attributes("", renderer, "text",
CHC_VALUE, NULL);
#if GTK_CHECK_VERSION(2, 4, 0)
gtk_tree_view_column_set_expand(column, TRUE);
#endif
gtk_tree_view_append_column(GTK_TREE_VIEW(compose->h_view), column);
/* default to 8-bits transfers with UTF-8 encoding */
compose_set_header(compose, "Content-Transfer-Encoding:", "8bit",
FALSE);
compose_set_header(compose, "Content-Type:",
"text/plain; charset=UTF-8", FALSE);
compose_add_field(compose, "To:", NULL);
gtk_container_add(GTK_CONTAINER(widget), compose->h_view);
gtk_paned_add1(GTK_PANED(vpaned), widget);
/* paned */
vbox2 = gtk_vbox_new(FALSE, 0);
/* subject */
toolbar = gtk_toolbar_new();
widget = gtk_label_new(_("Subject: "));
gtk_misc_set_alignment(GTK_MISC(widget), 0.1, 0.5);
gtk_size_group_add_widget(sizegroup, widget);
toolitem = gtk_tool_item_new();
gtk_container_add(GTK_CONTAINER(toolitem), widget);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
compose->subject = gtk_entry_new();
toolitem = gtk_tool_item_new();
gtk_tool_item_set_expand(toolitem, TRUE);
gtk_container_add(GTK_CONTAINER(toolitem), compose->subject);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
gtk_box_pack_start(GTK_BOX(vbox2), toolbar, FALSE, TRUE, 0);
/* view */
widget = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
compose->view = _new_text_view(compose);
compose_set_font(compose, _compose_get_font(compose));
gtk_container_add(GTK_CONTAINER(widget), compose->view);
gtk_box_pack_start(GTK_BOX(vbox2), widget, TRUE, TRUE, 0);
gtk_paned_add2(GTK_PANED(vpaned), vbox2);
gtk_box_pack_start(GTK_BOX(vbox), vpaned, TRUE, TRUE, 0);
/* attachments */
compose->a_window = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(compose->a_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER);
compose->a_store = gtk_list_store_new(CAC_COUNT, G_TYPE_STRING,
G_TYPE_STRING, GDK_TYPE_PIXBUF);
compose->a_view = gtk_icon_view_new_with_model(GTK_TREE_MODEL(
compose->a_store));
gtk_icon_view_set_pixbuf_column(GTK_ICON_VIEW(compose->a_view),
CAC_ICON);
gtk_icon_view_set_selection_mode(GTK_ICON_VIEW(compose->a_view),
GTK_SELECTION_MULTIPLE);
gtk_icon_view_set_text_column(GTK_ICON_VIEW(compose->a_view),
CAC_BASENAME);
gtk_container_add(GTK_CONTAINER(compose->a_window), compose->a_view);
gtk_widget_show_all(compose->a_view);
gtk_widget_set_no_show_all(compose->a_window, TRUE);
gtk_box_pack_start(GTK_BOX(vbox), compose->a_window, FALSE, TRUE, 0);
/* statusbar */
compose->statusbar = gtk_statusbar_new();
compose->statusbar_id = 0;
gtk_box_pack_start(GTK_BOX(vbox), compose->statusbar, FALSE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(compose->window), vbox);
/* about dialog */
compose->ab_window = NULL;
/* signature */
compose_append_signature(compose);
compose_set_modified(compose, FALSE);
compose_scroll_to_offset(compose, 0);
/* display */
gtk_widget_grab_focus(compose->view);
gtk_widget_show_all(vbox);
gtk_widget_show(compose->window);
return compose;
}
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;
}
EXPORT gboolean lookuptables_configurator(GtkWidget *widget, gpointer data)
{
static gboolean ltc_created = FALSE;
static GtkWidget * lookuptables_config_window = NULL;
extern Firmware_Details *firmware;
GtkListStore *store = NULL;
GtkTreeStore *combostore = NULL;
GtkTreeIter iter;
GtkTreeIter per_iter;
GtkTreeIter sys_iter;
GtkCellRenderer *renderer = NULL;
GtkTreeViewColumn *column = NULL;
GtkWidget * vbox = NULL;
GtkWidget * tree = NULL;
GtkWidget * frame = NULL;
ListElement *element = NULL;
ConfigFile *cfgfile = NULL;
GArray *classes = NULL;
GList *p_list = NULL;
GList *s_list = NULL;
guint i = 0;
gchar * tmpbuf = NULL;
gchar ** vector = NULL;
gchar ** tmpvector = NULL;
if ((ltc_created) && (ltc_visible))
return TRUE;
if ((ltc_created) && (!ltc_visible))
{
gtk_widget_show_all(lookuptables_config_window);
return TRUE;
}
else /* i.e. NOT created, build it */
{
lookuptables_config_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(lookuptables_config_window),_("MegaTunix LookupTables"));
gtk_window_set_default_size(GTK_WINDOW(lookuptables_config_window),300,200);
vbox = gtk_vbox_new(FALSE,0);
gtk_container_add(GTK_CONTAINER(lookuptables_config_window),vbox);
gtk_container_set_border_width(GTK_CONTAINER(vbox),5);
g_signal_connect(G_OBJECT(lookuptables_config_window),"delete_event", G_CALLBACK(lookuptables_configurator_hide),NULL);
ltc_created = TRUE;
ltc_visible = TRUE;
frame = gtk_frame_new("MegaTunix LookupTables");
gtk_box_pack_start (GTK_BOX(vbox),frame,FALSE,TRUE,5);
vbox = gtk_vbox_new(FALSE,0);
gtk_container_add(GTK_CONTAINER(frame),vbox);
store = gtk_list_store_new(N_COLS, /* total cols */
G_TYPE_STRING, /* int name */
G_TYPE_STRING, /* filename combo*/
G_TYPE_BOOLEAN,/* View/Edit */
G_TYPE_BOOLEAN); /* change */
combostore = gtk_tree_store_new(1,G_TYPE_STRING);/* lookuptable filename */
gtk_tree_store_append(combostore,&per_iter,NULL);
gtk_tree_store_append(combostore,&sys_iter,NULL);
gtk_tree_store_set(combostore,&per_iter,
0,"Personal", -1);
gtk_tree_store_set(combostore,&sys_iter,
0,"System", -1);
vector = get_files(g_strdup(LOOKUPTABLES_DATA_DIR),g_strdup("inc"),&classes);
for (i=0;i<g_strv_length(vector);i++)
{
tmpvector = g_strsplit(vector[i],PSEP,-1);
if (g_array_index(classes,FileClass,i) == PERSONAL)
{
element = g_new0(ListElement, 1);
element->name = g_strdup(tmpvector[g_strv_length(tmpvector)-1]);
p_list = g_list_append(p_list,element);
}
if (g_array_index(classes,FileClass,i) == SYSTEM)
{
element = g_new0(ListElement, 1);
element->name = g_strdup(tmpvector[g_strv_length(tmpvector)-1]);
s_list = g_list_append(s_list,element);
}
g_strfreev(tmpvector);
}
g_strfreev(vector);
g_array_free(classes,TRUE);
p_list = g_list_sort(p_list,list_sort);
s_list = g_list_sort(s_list,list_sort);
for (i=0;i<g_list_length(p_list);i++)
{
gtk_tree_store_append(combostore,&iter,&per_iter);
element = g_list_nth_data(p_list,i);
gtk_tree_store_set(combostore,&iter,
0,element->name,
-1);
}
for (i=0;i<g_list_length(s_list);i++)
{
gtk_tree_store_append(combostore,&iter,&sys_iter);
element = g_list_nth_data(s_list,i);
gtk_tree_store_set(combostore,&iter,
0,element->name,
-1);
}
g_list_foreach(p_list,free_element,NULL);
g_list_foreach(s_list,free_element,NULL);
g_list_free(p_list);
g_list_free(s_list);
cfgfile = cfg_open_file(firmware->profile_filename);
if (!cfgfile)
return FALSE;
cfg_read_string(cfgfile,"lookuptables","tables",&tmpbuf);
vector = g_strsplit(tmpbuf,",",-1);
g_free(tmpbuf);
for (i=0;i<g_strv_length(vector);i++)
{
cfg_read_string(cfgfile,"lookuptables",vector[i],&tmpbuf);
gtk_list_store_append(store,&iter);
gtk_list_store_set(store,&iter,
INTERNAL_NAME_COL,vector[i],
FILENAME_COL,tmpbuf,
VIEW_EDIT_COL,FALSE,
-1);
g_free(tmpbuf);
}
g_strfreev(vector);
tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree),TRUE);
gtk_box_pack_start(GTK_BOX(vbox),tree,TRUE,TRUE,0);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Internal Name",renderer,"text",INTERNAL_NAME_COL,NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree),column);
renderer = gtk_cell_renderer_combo_new();
g_object_set(G_OBJECT(renderer),"editable",TRUE,"model",combostore,"text-column",0,"style",PANGO_STYLE_ITALIC,NULL);
g_signal_connect(G_OBJECT(renderer),"edited", G_CALLBACK(lookuptable_change),store);
column = gtk_tree_view_column_new_with_attributes("Table Filename",renderer,"text",FILENAME_COL,NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree),column);
/* renderer = gtk_cell_renderer_toggle_new();
column = gtk_tree_view_column_new_with_attributes("View/Edit",renderer,"active",VIEW_EDIT_COL,NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree),column);
*/
gtk_widget_show_all (lookuptables_config_window);
gtk_tree_view_columns_autosize( GTK_TREE_VIEW(tree));
return TRUE;
}
}
GtkWidget* FilterEditor::createCriteriaPanel() {
// Create an hbox for the treeview and the action buttons
GtkWidget* hbox = gtk_hbox_new(FALSE, 6);
// Create a new treeview
_ruleView = GTK_TREE_VIEW(gtk_tree_view_new_with_model(GTK_TREE_MODEL(_ruleStore)));
gtkutil::TextColumn indexCol(_("Index"), COL_INDEX);
gtkutil::TextColumn regexCol(_("Match"), COL_REGEX);
// Create the cell renderer for the action choice
GtkCellRenderer* actionComboRenderer = gtk_cell_renderer_combo_new();
g_object_set(G_OBJECT(actionComboRenderer), "has-entry", FALSE, NULL);
g_object_set(G_OBJECT(actionComboRenderer), "text-column", 1, NULL);
g_object_set(G_OBJECT(actionComboRenderer), "editable", TRUE, NULL);
// Create the store
GtkListStore* actionStore = createActionStore();
g_object_set(G_OBJECT(actionComboRenderer), "model", GTK_TREE_MODEL(actionStore), NULL);
// Construct the column itself
GtkTreeViewColumn* actionCol = gtk_tree_view_column_new_with_attributes(
_("Action"),
actionComboRenderer,
"markup", COL_ACTION,
NULL
);
g_signal_connect(G_OBJECT(actionComboRenderer), "edited", G_CALLBACK(onActionEdited), this);
// Regex editing
GtkCellRendererText* rend = regexCol.getCellRenderer();
g_object_set(G_OBJECT(rend), "editable", TRUE, NULL);
g_signal_connect(G_OBJECT(rend), "edited", G_CALLBACK(onRegexEdited), this);
// Create the cell renderer for the type choice
GtkCellRenderer* typeComboRenderer = gtk_cell_renderer_combo_new();
g_object_set(G_OBJECT(typeComboRenderer), "has-entry", FALSE, NULL);
g_object_set(G_OBJECT(typeComboRenderer), "text-column", 1, NULL);
g_object_set(G_OBJECT(typeComboRenderer), "editable", TRUE, NULL);
// Create the typestore
GtkListStore* typeStore = createTypeStore();
g_object_set(G_OBJECT(typeComboRenderer), "model", GTK_TREE_MODEL(typeStore), NULL);
// Construct the column itself
GtkTreeViewColumn* typeCol = gtk_tree_view_column_new_with_attributes(
_("Type"),
typeComboRenderer,
"markup", COL_TYPE_STR,
NULL
);
g_signal_connect(G_OBJECT(typeComboRenderer), "edited", G_CALLBACK(onTypeEdited), this);
gtk_tree_view_append_column(GTK_TREE_VIEW(_ruleView), indexCol);
gtk_tree_view_append_column(GTK_TREE_VIEW(_ruleView), typeCol);
gtk_tree_view_append_column(GTK_TREE_VIEW(_ruleView), regexCol);
gtk_tree_view_append_column(GTK_TREE_VIEW(_ruleView), actionCol);
GtkTreeSelection* sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(_ruleView));
g_signal_connect(G_OBJECT(sel), "changed", G_CALLBACK(onRuleSelectionChanged), this);
// Action buttons
_widgets[WIDGET_ADD_RULE_BUTTON] = gtk_button_new_from_stock(GTK_STOCK_ADD);
_widgets[WIDGET_MOVE_RULE_UP_BUTTON] = gtk_button_new_from_stock(GTK_STOCK_GO_UP);
_widgets[WIDGET_MOVE_RULE_DOWN_BUTTON] = gtk_button_new_from_stock(GTK_STOCK_GO_DOWN);
_widgets[WIDGET_DELETE_RULE_BUTTON] = gtk_button_new_from_stock(GTK_STOCK_DELETE);
g_signal_connect(G_OBJECT(_widgets[WIDGET_ADD_RULE_BUTTON]), "clicked", G_CALLBACK(onAddRule), this);
g_signal_connect(G_OBJECT(_widgets[WIDGET_MOVE_RULE_UP_BUTTON]), "clicked", G_CALLBACK(onMoveRuleUp), this);
g_signal_connect(G_OBJECT(_widgets[WIDGET_MOVE_RULE_DOWN_BUTTON]), "clicked", G_CALLBACK(onMoveRuleDown), this);
g_signal_connect(G_OBJECT(_widgets[WIDGET_DELETE_RULE_BUTTON]), "clicked", G_CALLBACK(onDeleteRule), this);
GtkWidget* actionVBox = gtk_vbox_new(FALSE, 6);
gtk_box_pack_start(GTK_BOX(actionVBox), _widgets[WIDGET_ADD_RULE_BUTTON], FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(actionVBox), _widgets[WIDGET_MOVE_RULE_UP_BUTTON], FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(actionVBox), _widgets[WIDGET_MOVE_RULE_DOWN_BUTTON], FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(actionVBox), _widgets[WIDGET_DELETE_RULE_BUTTON], FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), gtkutil::ScrolledFrame(GTK_WIDGET(_ruleView)), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), actionVBox, FALSE, FALSE, 0);
return gtkutil::LeftAlignment(hbox, 18, 1);
}
GncSxSinceLastRunDialog*
gnc_ui_sx_since_last_run_dialog(GncSxInstanceModel *sx_instances, GList *auto_created_txn_guids)
{
GncSxSinceLastRunDialog *dialog;
GtkBuilder *builder;
dialog = g_new0(GncSxSinceLastRunDialog, 1);
builder = gtk_builder_new();
gnc_builder_add_from_file (builder, "dialog-sx.glade", "since-last-run-dialog");
dialog->dialog = GTK_WIDGET(gtk_builder_get_object (builder, "since-last-run-dialog"));
dialog->editing_model = gnc_sx_slr_tree_model_adapter_new(sx_instances);
dialog->review_created_txns_toggle = GTK_TOGGLE_BUTTON(gtk_builder_get_object (builder, "review_txn_toggle"));
dialog->created_txns = auto_created_txn_guids;
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *col;
dialog->instance_view = GTK_TREE_VIEW(gtk_builder_get_object (builder, "instance_view"));
gtk_tree_view_set_model(dialog->instance_view, GTK_TREE_MODEL(dialog->editing_model));
renderer = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new_with_attributes(_("Transaction"), renderer,
"text", SLR_MODEL_COL_NAME,
NULL);
gtk_tree_view_append_column(dialog->instance_view, col);
renderer = gtk_cell_renderer_combo_new();
g_object_set(G_OBJECT(renderer),
"model", gnc_sx_get_slr_state_model(),
"text-column", 0,
"has-entry", FALSE,
"editable", TRUE,
NULL);
g_signal_connect(G_OBJECT(renderer),
"edited",
G_CALLBACK(instance_state_changed_cb),
dialog);
col = gtk_tree_view_column_new_with_attributes(_("Status"), renderer,
"text", SLR_MODEL_COL_INSTANCE_STATE,
"visible", SLR_MODEL_COL_INSTANCE_VISIBILITY,
// you might think only "sensitive" is required to
// control the ability of the combo box to select
// a new state, but you'd be wrong.
"editable", SLR_MODEL_COL_INSTANCE_STATE_SENSITIVITY,
"sensitive", SLR_MODEL_COL_INSTANCE_STATE_SENSITIVITY,
NULL);
gtk_tree_view_append_column(dialog->instance_view, col);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer),
"editable", TRUE,
NULL);
g_signal_connect(G_OBJECT(renderer),
"edited",
G_CALLBACK(variable_value_changed_cb),
dialog);
col = gtk_tree_view_column_new_with_attributes(_("Value"), renderer,
"text", SLR_MODEL_COL_VARAIBLE_VALUE,
"visible", SLR_MODEL_COL_VARIABLE_VISIBILITY,
NULL);
gtk_tree_view_append_column(dialog->instance_view, col);
gtk_tree_view_expand_all(dialog->instance_view);
}
g_signal_connect(G_OBJECT(dialog->dialog), "response", G_CALLBACK(dialog_response_cb), dialog);
g_signal_connect(G_OBJECT(dialog->dialog), "destroy", G_CALLBACK(dialog_destroy_cb), dialog);
gnc_restore_window_size(GNC_PREFS_GROUP_STARTUP, GTK_WINDOW(dialog->dialog));
dialog->component_id = gnc_register_gui_component
(DIALOG_SX_SINCE_LAST_RUN_CM_CLASS, NULL, close_handler, dialog);
gnc_gui_component_set_session(dialog->component_id,
gnc_get_current_session());
gtk_widget_show_all(dialog->dialog);
gtk_builder_connect_signals_full (builder, gnc_builder_connect_full_func, dialog);
g_object_unref(G_OBJECT(builder));
return dialog;
}
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 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;
}
/* Object initialization
* Create private structure and set up default values
*/
static void nojs_preferences_init(NoJSPreferences *self)
{
NoJSPreferencesPrivate *priv;
GtkTreeSortable *sortableList;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkWidget *widget;
gchar *dialogTitle;
GtkWidget *scrolled;
GtkWidget *vbox;
GtkWidget *hbox;
gint width, height;
GtkListStore *list;
GtkTreeIter listIter;
priv=self->priv=NOJS_PREFERENCES_GET_PRIVATE(self);
/* Set up default values */
priv->manager=NULL;
/* Get content area to add gui controls to */
priv->contentArea=gtk_dialog_get_content_area(GTK_DIALOG(self));
#if GTK_CHECK_VERSION (3, 0, 0)
vbox=gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_box_set_homogeneous(GTK_BOX(vbox), FALSE);
#else
vbox=gtk_vbox_new(FALSE, 0);
#endif
/* Set up dialog */
dialogTitle=_("Configure NoJS");
gtk_window_set_title(GTK_WINDOW(self), dialogTitle);
gtk_window_set_icon_name(GTK_WINDOW(self), GTK_STOCK_PROPERTIES);
sokoke_widget_get_text_size(GTK_WIDGET(self), "M", &width, &height);
gtk_window_set_default_size(GTK_WINDOW(self), width*52, -1);
widget=sokoke_xfce_header_new(gtk_window_get_icon_name(GTK_WINDOW(self)), dialogTitle);
if(widget) gtk_box_pack_start(GTK_BOX(priv->contentArea), widget, FALSE, FALSE, 0);
gtk_dialog_add_button(GTK_DIALOG(self), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE);
/* Set up description */
widget=gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(widget),
_("Below is a list of all web sites and the policy set for them. "
"You can delete policies by marking the entries and clicking on <i>Delete</i>."));
gtk_label_set_line_wrap(GTK_LABEL(widget), TRUE);
gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, FALSE, 4);
/* Set up domain list */
priv->listStore=gtk_list_store_new(N_COLUMN,
G_TYPE_STRING, /* DOMAIN_COLUMN */
G_TYPE_STRING /* POLICY_COLUMN */);
sortableList=GTK_TREE_SORTABLE(priv->listStore);
gtk_tree_sortable_set_sort_func(sortableList,
DOMAIN_COLUMN,
(GtkTreeIterCompareFunc)_nojs_preferences_sort_string_callback,
GINT_TO_POINTER(DOMAIN_COLUMN),
NULL);
gtk_tree_sortable_set_sort_func(sortableList,
POLICY_COLUMN,
(GtkTreeIterCompareFunc)_nojs_preferences_sort_string_callback,
GINT_TO_POINTER(POLICY_COLUMN),
NULL);
gtk_tree_sortable_set_sort_column_id(sortableList, DOMAIN_COLUMN, GTK_SORT_ASCENDING);
/* Set up domain addition widgets */
#ifdef HAVE_GTK3
hbox=gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_set_homogeneous(GTK_BOX(hbox), FALSE);
#else
hbox=gtk_hbox_new(FALSE, 0);
#endif
priv->addDomainEntry=gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(priv->addDomainEntry), 64);
gtk_container_add(GTK_CONTAINER(hbox), priv->addDomainEntry);
g_signal_connect_swapped(priv->addDomainEntry, "changed", G_CALLBACK(_nojs_preferences_on_add_domain_entry_changed), self);
list=gtk_list_store_new(2, G_TYPE_INT, G_TYPE_STRING);
gtk_list_store_append(list, &listIter);
gtk_list_store_set(list, &listIter, 0, NOJS_POLICY_ACCEPT, 1, _("Accept"), -1);
gtk_list_store_append(list, &listIter);
gtk_list_store_set(list, &listIter, 0, NOJS_POLICY_ACCEPT_TEMPORARILY, 1, _("Accept for session"), -1);
gtk_list_store_append(list, &listIter);
gtk_list_store_set(list, &listIter, 0, NOJS_POLICY_BLOCK, 1, _("Block"), -1);
priv->addDomainPolicyCombo=gtk_combo_box_new_with_model(GTK_TREE_MODEL(list));
gtk_combo_box_set_active(GTK_COMBO_BOX(priv->addDomainPolicyCombo), 0);
gtk_container_add(GTK_CONTAINER(hbox), priv->addDomainPolicyCombo);
renderer=gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(priv->addDomainPolicyCombo), renderer, TRUE);
gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(priv->addDomainPolicyCombo), renderer, "text", 1);
priv->addDomainButton=gtk_button_new_from_stock(GTK_STOCK_ADD);
gtk_widget_set_sensitive(priv->addDomainButton, FALSE);
gtk_container_add(GTK_CONTAINER(hbox), priv->addDomainButton);
g_signal_connect_swapped(priv->addDomainButton, "clicked", G_CALLBACK(_nojs_preferences_on_add_domain_clicked), self);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 5);
/* Set up domain list view */
priv->list=gtk_tree_view_new_with_model(GTK_TREE_MODEL(priv->listStore));
#if !GTK_CHECK_VERSION (3, 0, 0)
gtk_widget_set_size_request(priv->list, -1, 300);
#endif
priv->listSelection=gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->list));
gtk_tree_selection_set_mode(priv->listSelection, GTK_SELECTION_MULTIPLE);
g_signal_connect_swapped(priv->listSelection, "changed", G_CALLBACK(_nojs_preferences_changed_selection), self);
renderer=gtk_cell_renderer_text_new();
column=gtk_tree_view_column_new_with_attributes(_("Domain"),
renderer,
"text", DOMAIN_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, DOMAIN_COLUMN);
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->list), column);
renderer=gtk_cell_renderer_combo_new();
g_object_set(G_OBJECT(renderer), "model", list, "text-column", 1, "has-entry", false, "editable", true, NULL);
g_signal_connect_swapped(renderer, "editing-started", G_CALLBACK(_nojs_preferences_on_policy_editing_started), self);
g_signal_connect_swapped(renderer, "editing-canceled", G_CALLBACK(_nojs_preferences_on_policy_editing_canceled), self);
g_signal_connect_swapped(renderer, "edited", G_CALLBACK(_nojs_preferences_on_policy_edited), self);
column=gtk_tree_view_column_new_with_attributes(_("Policy"),
renderer,
"text", POLICY_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, POLICY_COLUMN);
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->list), column);
scrolled=gtk_scrolled_window_new(NULL, NULL);
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(scrolled), height*10);
#endif
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(scrolled), priv->list);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(vbox), scrolled, TRUE, TRUE, 5);
/* Set up JavaScript domain list management buttons */
#if GTK_CHECK_VERSION (3, 0, 0)
hbox=gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_set_homogeneous(GTK_BOX(hbox), FALSE);
#else
hbox=gtk_hbox_new(FALSE, 0);
#endif
priv->deleteButton=gtk_button_new_from_stock(GTK_STOCK_DELETE);
gtk_widget_set_sensitive(priv->deleteButton, FALSE);
gtk_container_add(GTK_CONTAINER(hbox), priv->deleteButton);
g_signal_connect_swapped(priv->deleteButton, "clicked", G_CALLBACK(_nojs_preferences_on_delete_selection), self);
priv->deleteAllButton=gtk_button_new_with_mnemonic(_("Delete _all"));
gtk_button_set_image(GTK_BUTTON(priv->deleteAllButton), gtk_image_new_from_stock(GTK_STOCK_DELETE, GTK_ICON_SIZE_BUTTON));
gtk_widget_set_sensitive(priv->deleteAllButton, FALSE);
gtk_container_add(GTK_CONTAINER(hbox), priv->deleteAllButton);
g_signal_connect_swapped(priv->deleteAllButton, "clicked", G_CALLBACK(_nojs_preferences_on_delete_all), self);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 5);
/* Add "allow-all-sites" checkbox */
priv->allowAllSitesCheckbox=gtk_check_button_new_with_mnemonic(_("A_llow scripts at all sites"));
priv->signalAllowAllSitesToggledID=g_signal_connect_swapped(priv->allowAllSitesCheckbox,
"toggled",
G_CALLBACK(_nojs_preferences_on_allow_all_sites_changed),
self);
gtk_box_pack_start(GTK_BOX(vbox), priv->allowAllSitesCheckbox, FALSE, TRUE, 5);
/* Add "block-unknown-domains" checkbox */
priv->blockUnknownDomainsCheckbox=gtk_check_button_new_with_mnemonic(_("Bloc_k scripts at unknown domains by default"));
priv->signalBlockUnknownDomainsToggledID=g_signal_connect_swapped(priv->blockUnknownDomainsCheckbox,
"toggled",
G_CALLBACK(_nojs_preferences_on_block_unknown_domains_changed),
self);
gtk_box_pack_start(GTK_BOX(vbox), priv->blockUnknownDomainsCheckbox, FALSE, TRUE, 5);
/* Add "check-second-level-only" checkbox */
priv->checkSecondLevelOnlyCheckbox=gtk_check_button_new_with_mnemonic(_("S_et permissions on second-level domain"));
priv->signalCheckSecondLevelOnlyToggledID=g_signal_connect_swapped(priv->checkSecondLevelOnlyCheckbox,
"toggled",
G_CALLBACK(_nojs_preferences_on_check_second_level_only_changed),
self);
gtk_box_pack_start(GTK_BOX(vbox), priv->checkSecondLevelOnlyCheckbox, FALSE, TRUE, 5);
/* Finalize setup of content area */
gtk_box_pack_start(GTK_BOX(priv->contentArea), vbox, TRUE, TRUE, 0);
}
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;
}
void users_add_columns(Users *us) {
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
/* Column for user id */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Id", renderer,
"text", UID_COL,
NULL);
gtk_tree_view_column_set_sort_column_id (column, UID_COL);
gtk_tree_view_append_column (GTK_TREE_VIEW(us->tv), column);
/*Column for user name (login name) */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Login", renderer,
"text", UNAME_COL,
NULL);
g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (UNAME_COL));
g_object_set(renderer, "editable", TRUE, NULL);
g_signal_connect (renderer, "edited", G_CALLBACK (u_cell_edited), us->model);
gtk_tree_view_column_set_sort_column_id (column,UNAME_COL);
gtk_tree_view_append_column (GTK_TREE_VIEW(us->tv), column);
/* Column for Full Name */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Name", renderer,
"text", UFULLNAME_COL,
NULL);
g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (UFULLNAME_COL));
g_object_set(renderer, "editable", TRUE, NULL);
g_signal_connect (renderer, "edited", G_CALLBACK (u_cell_edited), us->model);
gtk_tree_view_column_set_sort_column_id (column,UFULLNAME_COL);
gtk_tree_view_append_column (GTK_TREE_VIEW(us->tv), column);
/*Column for shell */
renderer = gtk_cell_renderer_combo_new();
g_object_set (renderer, "model", us->shells_model,
"text-column", SHELL_PATH_COL,
"has-entry", FALSE,
"editable", TRUE,
NULL);
column = gtk_tree_view_column_new_with_attributes ("Shell", renderer,
"text", USHELL_COL,
NULL);
g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (USHELL_COL));
g_signal_connect (renderer, "edited", G_CALLBACK (u_cell_edited), us->model);
g_signal_connect (renderer, "editing-started", G_CALLBACK (u_editing_started), NULL);
gtk_tree_view_column_set_sort_column_id (column,USHELL_COL);
gtk_tree_view_append_column (GTK_TREE_VIEW(us->tv), column);
/*Home path column*/
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Home", renderer,
"text", UHOMEPATH_COL,
NULL);
gtk_tree_view_column_set_sort_column_id (column,UHOMEPATH_COL);
gtk_tree_view_append_column (GTK_TREE_VIEW(us->tv), column);
g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (UHOMEPATH_COL));
g_object_set(renderer, "editable", TRUE, NULL);
g_signal_connect (renderer, "edited", G_CALLBACK (u_cell_edited), us->model);
/*Is new users column */
renderer = gtk_cell_renderer_toggle_new ();
/*g_signal_connect (renderer, "toggled", G_CALLBACK (fixed_toggled), model);*/
column = gtk_tree_view_column_new_with_attributes ("New", renderer,
"active", UISNEW_COL,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW(us->tv), column);
}
static void
setup_mapping_treeview (CcWacomPage *page)
{
CcWacomPagePrivate *priv;
GtkTreeView *treeview;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkListStore *model;
GtkTreeIter iter;
GList *list, *l;
gint i;
priv = page->priv;
treeview = GTK_TREE_VIEW(MWID ("shortcut_treeview"));
g_signal_connect (treeview, "button_press_event",
G_CALLBACK (start_editing_cb), page);
g_signal_connect (treeview, "row-activated",
G_CALLBACK (start_editing_kb_cb), page);
renderer = gtk_cell_renderer_text_new ();
g_object_set (G_OBJECT (renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
column = gtk_tree_view_column_new_with_attributes (_("Button"),
renderer,
"text", MAPPING_DESCRIPTION_COLUMN,
NULL);
gtk_tree_view_column_set_resizable (column, FALSE);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_append_column (treeview, column);
gtk_tree_view_column_set_sort_column_id (column, MAPPING_DESCRIPTION_COLUMN);
priv->action_store = gtk_list_store_new (ACTION_N_COLUMNS, G_TYPE_STRING, G_TYPE_INT);
for (i = 0; i < G_N_ELEMENTS (action_table); i++) {
/* Screen tablets cannot switch monitors (as the monitor is the tablet) */
if (action_table[i].action_type == CSD_WACOM_ACTION_TYPE_SWITCH_MONITOR &&
csd_wacom_device_is_screen_tablet (priv->stylus))
continue;
/* Do not list on-screen help if libwacom do no provide a layout */
if (action_table[i].action_type == CSD_WACOM_ACTION_TYPE_HELP &&
csd_wacom_device_get_layout_path (priv->stylus) == NULL)
continue;
gtk_list_store_append (priv->action_store, &iter);
gtk_list_store_set (priv->action_store, &iter,
ACTION_NAME_COLUMN, WACOM_C(action_table[i].action_name),
ACTION_TYPE_COLUMN, action_table[i].action_type, -1);
}
renderer = gtk_cell_renderer_combo_new ();
g_object_set (renderer,
"text-column", ACTION_NAME_COLUMN,
"has-entry", FALSE,
"model", priv->action_store,
"editable", TRUE,
NULL);
g_signal_connect (renderer, "changed",
G_CALLBACK (combo_action_cell_changed), page);
column = gtk_tree_view_column_new_with_attributes (_("Type"),
renderer,
"text", MAPPING_TYPE_COLUMN,
NULL);
gtk_tree_view_column_set_cell_data_func (column, renderer, action_set_func, NULL, NULL);
gtk_tree_view_column_set_resizable (column, FALSE);
gtk_tree_view_column_set_expand (column, FALSE);
gtk_tree_view_append_column (treeview, column);
renderer = (GtkCellRenderer *) g_object_new (GTK_TYPE_CELL_RENDERER_ACCEL,
"accel-mode", GTK_CELL_RENDERER_ACCEL_MODE_OTHER,
NULL);
g_signal_connect (renderer, "accel_edited",
G_CALLBACK (accel_edited_callback),
page);
g_signal_connect (renderer, "accel_cleared",
G_CALLBACK (accel_cleared_callback),
page);
column = gtk_tree_view_column_new_with_attributes (_("Action"), renderer, NULL);
gtk_tree_view_column_set_cell_data_func (column, renderer, accel_set_func, NULL, NULL);
gtk_tree_view_column_set_resizable (column, FALSE);
gtk_tree_view_column_set_expand (column, FALSE);
gtk_tree_view_append_column (treeview, column);
model = gtk_list_store_new (MAPPING_N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_INT);
gtk_tree_view_set_model (treeview, GTK_TREE_MODEL (model));
/* Fill it up! */
list = csd_wacom_device_get_buttons (priv->pad);
for (l = list; l != NULL; l = l->next) {
CsdWacomTabletButton *button = l->data;
CsdWacomActionType type = CSD_WACOM_ACTION_TYPE_NONE;
if (button->settings)
type = g_settings_get_enum (button->settings, ACTION_TYPE_KEY);
if (button->type == WACOM_TABLET_BUTTON_TYPE_STRIP ||
button->type == WACOM_TABLET_BUTTON_TYPE_RING) {
add_button_to_store (model, button, GTK_DIR_UP, CSD_WACOM_ACTION_TYPE_CUSTOM);
add_button_to_store (model, button, GTK_DIR_DOWN, CSD_WACOM_ACTION_TYPE_CUSTOM);
} else {
add_button_to_store (model, button, 0, type);
}
}
g_list_free (list);
g_object_unref (model);
}
static GtkWidget *
create_action_treeview (GActionGroup *group)
{
GtkWidget *tv;
GtkListStore *store;
GtkListStore *values;
GtkTreeIter iter;
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
gchar **actions;
gint i;
store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
actions = g_action_group_list_actions (group);
for (i = 0; actions[i]; i++)
{
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, 0, actions[i], -1);
}
g_strfreev (actions);
g_object_set_data (G_OBJECT (store), "group", group);
tv = gtk_tree_view_new ();
g_signal_connect_swapped (group, "action-enabled-changed",
G_CALLBACK (gtk_widget_queue_draw), tv);
g_signal_connect_swapped (group, "action-state-changed",
G_CALLBACK (gtk_widget_queue_draw), tv);
gtk_tree_view_set_model (GTK_TREE_VIEW (tv), GTK_TREE_MODEL (store));
cell = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Action", cell,
"text", 0,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tv), column);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, "Enabled");
cell = gtk_cell_renderer_toggle_new ();
gtk_tree_view_column_pack_start (column, cell, FALSE);
gtk_tree_view_column_set_cell_data_func (column, cell, enabled_cell_func, group, NULL);
g_signal_connect (cell, "toggled", G_CALLBACK (enabled_cell_toggled), store);
gtk_tree_view_append_column (GTK_TREE_VIEW (tv), column);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, "State");
cell = gtk_cell_renderer_toggle_new ();
gtk_tree_view_column_pack_start (column, cell, FALSE);
gtk_tree_view_column_set_cell_data_func (column, cell, state_cell_func, group, NULL);
g_signal_connect (cell, "toggled", G_CALLBACK (state_cell_toggled), store);
cell = gtk_cell_renderer_combo_new ();
values = gtk_list_store_new (1, G_TYPE_STRING);
gtk_list_store_append (values, &iter);
gtk_list_store_set (values, &iter, 0, "latin", -1);
gtk_list_store_append (values, &iter);
gtk_list_store_set (values, &iter, 0, "greek", -1);
gtk_list_store_append (values, &iter);
gtk_list_store_set (values, &iter, 0, "urdu", -1);
gtk_list_store_append (values, &iter);
gtk_list_store_set (values, &iter, 0, "sumerian", -1);
g_object_set (cell,
"has-entry", FALSE,
"model", values,
"text-column", 0,
"editable", TRUE,
NULL);
gtk_tree_view_column_pack_start (column, cell, FALSE);
gtk_tree_view_column_set_cell_data_func (column, cell, state_cell_func, group, NULL);
g_signal_connect (cell, "edited", G_CALLBACK (state_cell_edited), store);
gtk_tree_view_append_column (GTK_TREE_VIEW (tv), column);
return tv;
}
static GtkTreeView *
build_view (GladeEditorProperty * eprop)
{
GladeEPropIconSources *eprop_sources = GLADE_EPROP_ICON_SOURCES (eprop);
static GtkListStore *direction_store = NULL, *size_store =
NULL, *state_store = NULL;
GtkTreeView *view = (GtkTreeView *) gtk_tree_view_new ();
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
if (!direction_store)
{
direction_store =
glade_utils_liststore_from_enum_type (GTK_TYPE_TEXT_DIRECTION, FALSE);
size_store =
glade_utils_liststore_from_enum_type (GTK_TYPE_ICON_SIZE, FALSE);
state_store =
glade_utils_liststore_from_enum_type (GTK_TYPE_STATE_TYPE, FALSE);
}
/* Filename / icon name column/renderer */
renderer = gtk_cell_renderer_text_new ();
g_object_set (G_OBJECT (renderer), "editable", FALSE, NULL);
g_signal_connect (G_OBJECT (renderer), "edited",
G_CALLBACK (value_filename_edited), eprop);
eprop_sources->filename_column =
gtk_tree_view_column_new_with_attributes (_("File Name"), renderer,
"text", COLUMN_TEXT,
"weight", COLUMN_TEXT_WEIGHT,
"editable",
COLUMN_TEXT_EDITABLE, NULL);
gtk_tree_view_column_set_expand (eprop_sources->filename_column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (view),
eprop_sources->filename_column);
g_object_set_data (G_OBJECT (eprop_sources->filename_column), "column-id",
GINT_TO_POINTER (COLUMN_TEXT));
/********************* Size *********************/
/* Attribute active portion */
renderer = gtk_cell_renderer_toggle_new ();
g_object_set (G_OBJECT (renderer), "activatable", TRUE, NULL);
g_object_set_data (G_OBJECT (renderer), "attribute-column",
GINT_TO_POINTER (COLUMN_SIZE_ACTIVE));
g_signal_connect (G_OBJECT (renderer), "toggled",
G_CALLBACK (value_attribute_toggled), eprop);
column = gtk_tree_view_column_new_with_attributes
("dummy", renderer,
"visible", COLUMN_TEXT_EDITABLE, "active", COLUMN_SIZE_ACTIVE, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
g_object_set_data (G_OBJECT (column), "column-id",
GINT_TO_POINTER (COLUMN_SIZE_ACTIVE));
/* Attribute portion */
renderer = gtk_cell_renderer_combo_new ();
g_object_set (G_OBJECT (renderer), "editable", TRUE, "has-entry", FALSE,
"text-column", 0, "model", size_store, NULL);
g_object_set_data (G_OBJECT (renderer), "attribute-column",
GINT_TO_POINTER (COLUMN_SIZE));
g_signal_connect (G_OBJECT (renderer), "edited",
G_CALLBACK (value_attribute_edited), eprop);
column = gtk_tree_view_column_new_with_attributes
("dummy", renderer,
"visible", COLUMN_TEXT_EDITABLE,
"editable", COLUMN_SIZE_ACTIVE, "text", COLUMN_SIZE, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
g_object_set_data (G_OBJECT (column), "column-id",
GINT_TO_POINTER (COLUMN_SIZE));
/********************* State *********************/
/* Attribute active portion */
renderer = gtk_cell_renderer_toggle_new ();
g_object_set (G_OBJECT (renderer), "activatable", TRUE, NULL);
g_object_set_data (G_OBJECT (renderer), "attribute-column",
GINT_TO_POINTER (COLUMN_STATE_ACTIVE));
g_signal_connect (G_OBJECT (renderer), "toggled",
G_CALLBACK (value_attribute_toggled), eprop);
column = gtk_tree_view_column_new_with_attributes
("dummy", renderer,
"visible", COLUMN_TEXT_EDITABLE, "active", COLUMN_STATE_ACTIVE, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
g_object_set_data (G_OBJECT (column), "column-id",
GINT_TO_POINTER (COLUMN_STATE_ACTIVE));
/* Attribute portion */
renderer = gtk_cell_renderer_combo_new ();
g_object_set (G_OBJECT (renderer), "editable", TRUE, "has-entry", FALSE,
"text-column", 0, "model", state_store, NULL);
g_object_set_data (G_OBJECT (renderer), "attribute-column",
GINT_TO_POINTER (COLUMN_STATE));
g_signal_connect (G_OBJECT (renderer), "edited",
G_CALLBACK (value_attribute_edited), eprop);
column = gtk_tree_view_column_new_with_attributes
("dummy", renderer,
"visible", COLUMN_TEXT_EDITABLE,
"editable", COLUMN_STATE_ACTIVE, "text", COLUMN_STATE, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
g_object_set_data (G_OBJECT (column), "column-id",
GINT_TO_POINTER (COLUMN_STATE));
/********************* Direction *********************/
/* Attribute active portion */
renderer = gtk_cell_renderer_toggle_new ();
g_object_set (G_OBJECT (renderer), "activatable", TRUE, NULL);
g_object_set_data (G_OBJECT (renderer), "attribute-column",
GINT_TO_POINTER (COLUMN_DIRECTION_ACTIVE));
g_signal_connect (G_OBJECT (renderer), "toggled",
G_CALLBACK (value_attribute_toggled), eprop);
column = gtk_tree_view_column_new_with_attributes
("dummy", renderer,
"visible", COLUMN_TEXT_EDITABLE,
"active", COLUMN_DIRECTION_ACTIVE, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
g_object_set_data (G_OBJECT (column), "column-id",
GINT_TO_POINTER (COLUMN_DIRECTION_ACTIVE));
/* Attribute portion */
renderer = gtk_cell_renderer_combo_new ();
g_object_set (G_OBJECT (renderer), "editable", TRUE, "has-entry", FALSE,
"text-column", 0, "model", direction_store, NULL);
g_object_set_data (G_OBJECT (renderer), "attribute-column",
GINT_TO_POINTER (COLUMN_DIRECTION));
g_signal_connect (G_OBJECT (renderer), "edited",
G_CALLBACK (value_attribute_edited), eprop);
column = gtk_tree_view_column_new_with_attributes
("dummy", renderer,
"visible", COLUMN_TEXT_EDITABLE,
"editable", COLUMN_DIRECTION_ACTIVE, "text", COLUMN_DIRECTION, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
g_object_set_data (G_OBJECT (column), "column-id",
GINT_TO_POINTER (COLUMN_DIRECTION));
/* Connect ::query-tooltip here for fancy tooltips... */
g_object_set (G_OBJECT (view), "has-tooltip", TRUE, NULL);
g_signal_connect (G_OBJECT (view), "query-tooltip",
G_CALLBACK (icon_sources_query_tooltip), eprop);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (view), FALSE);
gtk_tree_view_set_show_expanders (GTK_TREE_VIEW (view), FALSE);
return view;
}
