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