static void attachment_icon_view_constructed (GObject *object) { GtkCellLayout *cell_layout; GtkCellRenderer *renderer; cell_layout = GTK_CELL_LAYOUT (object); /* This needs to happen after constructor properties are set * so that GtkCellLayout.get_area() returns something valid. */ renderer = gtk_cell_renderer_pixbuf_new (); g_object_set (renderer, "stock-size", icon_size, NULL); gtk_cell_layout_pack_start (cell_layout, renderer, FALSE); gtk_cell_layout_add_attribute ( cell_layout, renderer, "gicon", E_ATTACHMENT_STORE_COLUMN_ICON); renderer = gtk_cell_renderer_text_new (); g_object_set ( renderer, "alignment", PANGO_ALIGN_CENTER, "wrap-mode", PANGO_WRAP_WORD, "wrap-width", 150, "yalign", 0.0, NULL); gtk_cell_layout_pack_start (cell_layout, renderer, FALSE); gtk_cell_layout_add_attribute ( cell_layout, renderer, "text", E_ATTACHMENT_STORE_COLUMN_CAPTION); renderer = gtk_cell_renderer_progress_new (); g_object_set (renderer, "text", _("Loading"), NULL); gtk_cell_layout_pack_start (cell_layout, renderer, TRUE); gtk_cell_layout_add_attribute ( cell_layout, renderer, "value", E_ATTACHMENT_STORE_COLUMN_PERCENT); gtk_cell_layout_add_attribute ( cell_layout, renderer, "visible", E_ATTACHMENT_STORE_COLUMN_LOADING); renderer = gtk_cell_renderer_progress_new (); g_object_set (renderer, "text", _("Saving"), NULL); gtk_cell_layout_pack_start (cell_layout, renderer, TRUE); gtk_cell_layout_add_attribute ( cell_layout, renderer, "value", E_ATTACHMENT_STORE_COLUMN_PERCENT); gtk_cell_layout_add_attribute ( cell_layout, renderer, "visible", E_ATTACHMENT_STORE_COLUMN_SAVING); e_extensible_load_extensions (E_EXTENSIBLE (object)); }
void cgraphics_listview_widget_create_columns( widget_t *widget ) { listview_widget_t *lvw = (listview_widget_t *)widget; GtkCellRenderer *renderer; GType *types; GtkTreeModel *model; int a; types = (GType *)malloc( sizeof(GType) * (lvw->widget.columns+1) ); for ( a = 0; a < lvw->widget.columns; a++ ) { if ( lvw->widget.coltypes[a] == CLIST_TYPE_STRING ) types[a] = G_TYPE_STRING; else if ( lvw->widget.coltypes[a] == CLIST_TYPE_UINT ) types[a] = G_TYPE_UINT; else if ( lvw->widget.coltypes[a] == CLIST_TYPE_DOUBLE ) types[a] = G_TYPE_DOUBLE; else { printf( "Bad error: invalid type found (%d)\n", lvw->widget.coltypes[a] ); exit( 0 ); } } types[a] = G_TYPE_UINT; model = (GtkTreeModel *)gtk_list_store_newv( lvw->widget.columns + 1, types ); free( types ); gtk_tree_view_set_model( GTK_TREE_VIEW(widget->container), model ); g_object_unref( model ); for ( a = 0; a < lvw->widget.columns; a++ ) { if ( lvw->widget.coltypes[a] == CLIST_TYPE_STRING ) { renderer = gtk_cell_renderer_text_new( ); gtk_tree_view_insert_column_with_attributes( GTK_TREE_VIEW(widget->container), -1, lvw->titles[a], renderer, "text", a, NULL ); } else if ( lvw->widget.coltypes[a] == CLIST_TYPE_UINT ) { cgcelldata *cgcd = (cgcelldata *)malloc( sizeof(cgcelldata) ); /* FIXME: free me somewhere. */ renderer = gtk_cell_renderer_toggle_new( ); gtk_tree_view_insert_column_with_attributes( GTK_TREE_VIEW(widget->container), -1, lvw->titles[a], renderer, "active", a, NULL ); cgcd->widget = widget; cgcd->column = a; g_signal_connect( G_OBJECT(renderer), "toggled", G_CALLBACK(cgraphics_listview_toggled_handler), cgcd ); } else if ( lvw->widget.coltypes[a] == CLIST_TYPE_DOUBLE ) { renderer = gtk_cell_renderer_progress_new( ); gtk_tree_view_insert_column_with_attributes( GTK_TREE_VIEW(widget->container), -1, lvw->titles[a], renderer, "value", a, NULL ); } } }
static void treeview_download_files_init(void) { GtkTreeView *tv; unsigned i; STATIC_ASSERT(FILEINFO_VISIBLE_COLUMNS == c_fi_num); tv = GTK_TREE_VIEW(gtk_tree_view_new()); treeview_download_files = tv; for (i = 0; i < c_fi_num; i++) { add_column(tv, i, fi_gui_files_column_title(i), fi_gui_files_column_justify_right(i) ? 1.0 : 0.0, c_fi_progress == i ? gtk_cell_renderer_progress_new() : NULL, render_files); } gtk_tree_selection_set_mode(gtk_tree_view_get_selection(tv), GTK_SELECTION_MULTIPLE); gtk_tree_view_set_headers_visible(tv, TRUE); gtk_tree_view_set_headers_clickable(tv, TRUE); gtk_tree_view_set_enable_search(tv, FALSE); gtk_tree_view_set_rules_hint(tv, TRUE); tree_view_set_fixed_height_mode(tv, TRUE); gtk_tree_view_set_model(tv, GTK_TREE_MODEL(store_files)); tree_view_restore_visibility(tv, PROP_FILE_INFO_COL_VISIBLE); tree_view_restore_widths(tv, PROP_FILE_INFO_COL_WIDTHS); gui_signal_connect(tv, "cursor-changed", on_treeview_download_files_cursor_changed, NULL); }
static void brasero_medium_selection_set_show_used_space (BraseroMediumSelection *selector) { GtkCellRenderer *renderer; gtk_cell_layout_clear (GTK_CELL_LAYOUT (selector)); renderer = gtk_cell_renderer_pixbuf_new (); g_object_set (renderer, "follow-state", TRUE, NULL); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (selector), renderer, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (selector), renderer, "gicon", ICON_COL, NULL); renderer = gtk_cell_renderer_progress_new (); g_object_set (renderer, "xpad", 4, "text-xalign", 0.0, NULL); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (selector), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (selector), renderer, "text", NAME_COL, "value", USED_COL, "visible", VISIBLE_PROGRESS_COL, NULL); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "xpad", 4, NULL); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (selector), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (selector), renderer, "markup", NAME_COL, "visible", VISIBLE_TEXT_COL, NULL); }
static void add_columns(GtkWidget *treeview) { GtkCellRenderer *rend; GtkTreeViewColumn *column; /* Done */ column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, "Done"); gtk_tree_view_column_set_resizable(column, FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column); rend = gtk_cell_renderer_toggle_new(); gtk_tree_view_column_pack_start(column, rend, TRUE); gtk_tree_view_column_add_attribute(column, rend, "active", TODO_DONE); /* Description */ column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, "Description"); gtk_tree_view_column_set_resizable(column, FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column); rend = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, rend, TRUE); gtk_tree_view_column_add_attribute(column, rend, "text", TODO_TEXT); /* Progress */ column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, "Progress"); gtk_tree_view_column_set_resizable(column, FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column); rend = gtk_cell_renderer_progress_new(); gtk_tree_view_column_pack_start(column, rend, TRUE); gtk_tree_view_column_add_attribute(column, rend, "value", TODO_PROGRESS); }
static void connection_essids_combo_init (GtkComboBoxEntry *combo) { GtkTreeModel *model; GtkCellRenderer *renderer; model = GTK_TREE_MODEL (gtk_list_store_new (3, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_INT)); gtk_combo_box_set_model (GTK_COMBO_BOX (combo), model); g_object_unref (model); /* add "crypted" renderer */ renderer = gtk_cell_renderer_pixbuf_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, FALSE); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combo), renderer, "pixbuf", 0); gtk_cell_layout_reorder (GTK_CELL_LAYOUT (combo), renderer, 0); /* add "quality" renderer */ renderer = gtk_cell_renderer_progress_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, FALSE); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combo), renderer, "value", 2); /* reuse text cell renderer for the essid */ gtk_combo_box_entry_set_text_column (combo, 1); g_signal_connect (gtk_bin_get_child (GTK_BIN (combo)), "changed", G_CALLBACK (on_dialog_changed), tool); }
static void manager_init (Manager *self) { self->priv = G_TYPE_INSTANCE_GET_PRIVATE((self), MANAGER_TYPE, ManagerPrivate); self->priv->builder = gtk_builder_new (); gtk_builder_add_from_file (self->priv->builder, SHARE_DIR "/ui/main.ui", NULL); self->priv->window = GTK_WIDGET (gtk_builder_get_object (self->priv->builder, "main_window")); self->priv->view = GTK_WIDGET (gtk_builder_get_object (self->priv->builder, "main_view")); self->priv->status = GTK_WIDGET (gtk_builder_get_object (self->priv->builder, "main_status")); self->priv->store = GTK_TREE_MODEL (gtk_list_store_new (1, G_TYPE_OBJECT)); gtk_tree_view_set_model (GTK_TREE_VIEW (self->priv->view), self->priv->store); GtkCellRenderer *renderer; GtkTreeViewColumn *column; renderer = gtk_cell_renderer_progress_new (); column = gtk_tree_view_column_new_with_attributes ("Progress", renderer, NULL); gtk_tree_view_column_set_cell_data_func (column, renderer, (GtkTreeCellDataFunc) progress_column_func, NULL, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->view), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Download", renderer, NULL); gtk_tree_view_column_set_cell_data_func (column, renderer, (GtkTreeCellDataFunc) title_column_func, NULL, NULL); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->view), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("remaining", renderer, NULL); gtk_tree_view_column_set_cell_data_func (column, renderer, (GtkTreeCellDataFunc) time_column_func, NULL, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->view), column); g_signal_connect (self->priv->window, "destroy", G_CALLBACK (manager_stop), NULL); self->priv->icon = gtk_status_icon_new_from_stock (GTK_STOCK_GO_DOWN); gtk_widget_show_all (self->priv->window); self->priv->new_id = 1; self->priv->group = download_group_new ("Primary"); self->priv->conn = dbus_g_bus_get (DBUS_BUS_SESSION, NULL); self->priv->proxy = dbus_g_proxy_new_for_name (self->priv->conn, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS); org_freedesktop_DBus_request_name (self->priv->proxy, MANAGER_DBUS_SERVICE, DBUS_NAME_FLAG_DO_NOT_QUEUE, NULL, NULL); dbus_g_connection_register_g_object (self->priv->conn, MANAGER_DBUS_PATH, G_OBJECT (self)); }
/** * a_background_init: * * Initialize background feature. */ void a_background_init() { /* initialize thread pool */ gint max_threads = 10; /* limit maximum number of threads running at one time */ gint maxt; if ( a_settings_get_integer ( VIK_SETTINGS_BACKGROUND_MAX_THREADS, &maxt ) ) max_threads = maxt; thread_pool = g_thread_pool_new ( (GFunc) thread_helper, NULL, max_threads, FALSE, NULL ); GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkWidget *scrolled_window; g_debug(__FUNCTION__); /* store & treeview */ bgstore = gtk_list_store_new ( N_COLUMNS, G_TYPE_STRING, G_TYPE_DOUBLE, G_TYPE_POINTER ); bgtreeview = gtk_tree_view_new_with_model ( GTK_TREE_MODEL(bgstore) ); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (bgtreeview), TRUE); gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (bgtreeview)), GTK_SELECTION_SINGLE); /* add columns */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ( _("Job"), renderer, "text", TITLE_COLUMN, NULL ); gtk_tree_view_append_column ( GTK_TREE_VIEW(bgtreeview), column ); renderer = gtk_cell_renderer_progress_new (); column = gtk_tree_view_column_new_with_attributes ( _("Progress"), renderer, "value", PROGRESS_COLUMN, NULL ); gtk_tree_view_append_column ( GTK_TREE_VIEW(bgtreeview), column ); /* setup window */ scrolled_window = gtk_scrolled_window_new ( NULL, NULL ); gtk_container_add ( GTK_CONTAINER(scrolled_window), bgtreeview ); gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW(scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC ); bgwindow = gtk_dialog_new_with_buttons ( "", NULL, 0, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_DELETE, 1, GTK_STOCK_CLEAR, 2, NULL ); gtk_dialog_set_default_response ( GTK_DIALOG(bgwindow), GTK_RESPONSE_ACCEPT ); GtkWidget *response_w = NULL; #if GTK_CHECK_VERSION (2, 20, 0) response_w = gtk_dialog_get_widget_for_response ( GTK_DIALOG(bgwindow), GTK_RESPONSE_ACCEPT ); #endif gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(bgwindow))), scrolled_window, TRUE, TRUE, 0 ); gtk_window_set_default_size ( GTK_WINDOW(bgwindow), 400, 400 ); gtk_window_set_title ( GTK_WINDOW(bgwindow), _("Viking Background Jobs") ); if ( response_w ) gtk_widget_grab_focus ( response_w ); /* don't destroy win */ g_signal_connect ( G_OBJECT(bgwindow), "delete-event", G_CALLBACK(gtk_widget_hide_on_delete), NULL ); g_signal_connect ( G_OBJECT(bgwindow), "response", G_CALLBACK(bgwindow_response), 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 GtkTreeViewColumn *new_column(int type, int width, const char *title, ...){ GtkTreeViewColumn *col; GtkCellRenderer *render=NULL; col=gtk_tree_view_column_new(); switch(type){ case 0: render=gtk_cell_renderer_text_new(); #if GTK_MAJOR_VERSION>=3 || GTK_MINOR_VERSION >= 18 gtk_cell_renderer_set_padding(render, 1, 1); gtk_cell_renderer_set_alignment(render, 1, 0.5); #endif break; case 1: render=gtk_cell_renderer_progress_new(); break; case 2: render=gtk_cell_renderer_pixbuf_new(); break; default: error("Invalid\n"); } gtk_tree_view_column_set_title(col, title); gtk_tree_view_column_set_spacing(col, 2); gtk_tree_view_column_set_alignment(col, 1); gtk_tree_view_column_set_resizable(col, TRUE); //gtk_tree_view_column_set_clickable(col, TRUE); //gtk_tree_view_column_set_expand(col,FALSE); if(width>0){//Adjustable columns //Do not set min_width if set resizable. //gtk_tree_view_column_set_min_width(col, width); gtk_tree_view_column_set_expand(col,TRUE); //resizable is not good if expand gtk_tree_view_column_set_resizable(col, FALSE); if(type==0){ g_object_set(G_OBJECT(render),"ellipsize",PANGO_ELLIPSIZE_START,NULL); } }else if(width<0){/*max width*/ gtk_tree_view_column_set_min_width(col,-width/10); gtk_tree_view_column_set_max_width(col,-width); } gtk_tree_view_column_pack_start(col,render,TRUE); va_list ap; va_start(ap, title); const char *att=NULL; while((att=va_arg(ap, const char *))){ gtk_tree_view_column_add_attribute(col, render, att, va_arg(ap,int)); } va_end(ap); return col; }
static GtkWidget * create_batchlist_treeview() { batchlist_treeview = gtk_tree_view_new (); gtk_tree_view_set_reorderable(GTK_TREE_VIEW(batchlist_treeview), FALSE); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (batchlist_treeview), TRUE); GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(batchlist_treeview)); gtk_tree_selection_set_mode (sel, GTK_SELECTION_BROWSE); /* For touch screen, better to use "cursor-changed", instead of "row-activated" */ g_signal_connect (G_OBJECT(batchlist_treeview), "cursor-changed", G_CALLBACK (batchlist_treeview_row_selected), NULL); batchlist_treeview_sw = new_scrolled_window (NULL); gtk_container_add (GTK_CONTAINER (batchlist_treeview_sw), batchlist_treeview); /* add columns to the tree view */ GtkCellRenderer *cell; GtkTreeViewColumn *col; int i; for (i=COL_BL_LEVELS; i<=COL_BL_FAILED_PERCENT; i++) { cell = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new_with_attributes (batchlist_col_names[i], cell, "text", i, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW(batchlist_treeview), col); } /* cancel column */ cell = clickable_cell_renderer_pixbuf_new(); col = gtk_tree_view_column_new_with_attributes("", cell, "pixbuf", COL_BL_CANCEL, NULL); g_signal_connect (G_OBJECT (cell), "clicked", G_CALLBACK (cancel_batch_button_clicked), NULL); gtk_tree_view_append_column (GTK_TREE_VIEW(batchlist_treeview), col); gtk_tree_view_column_set_fixed_width(col, 16); cell = gtk_cell_renderer_progress_new(); col = gtk_tree_view_column_new_with_attributes (batchlist_col_names[COL_BL_DONE_PERCENT], cell, "value", COL_BL_DONE_PERCENT, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW(batchlist_treeview), col); batchlist_store = gtk_list_store_new (COL_BL_COUNT, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_INT, G_TYPE_POINTER); gtk_tree_view_set_model(GTK_TREE_VIEW(batchlist_treeview), GTK_TREE_MODEL(batchlist_store)); return batchlist_treeview_sw; }
static GtkTreeView* nsgtk_download_tree_view_new(GtkBuilder *gladeFile) { GtkTreeView *treeview; GtkCellRenderer *renderer; treeview = GTK_TREE_VIEW(gtk_builder_get_object(gladeFile, "treeDownloads")); /* Progress column */ renderer = gtk_cell_renderer_progress_new(); gtk_tree_view_insert_column_with_attributes (treeview, -1, messages_get("gtkProgress"), renderer, "value", NSGTK_DOWNLOAD_PROGRESS, "pulse", NSGTK_DOWNLOAD_PULSE, "text", NSGTK_DOWNLOAD_STATUS, NULL); /* Information column */ renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "wrap-mode", PANGO_WRAP_WORD_CHAR, "wrap-width", 300, NULL); gtk_tree_view_insert_column_with_attributes (treeview, -1, messages_get("gtkDetails"), renderer, "text", NSGTK_DOWNLOAD_INFO, NULL); gtk_tree_view_column_set_expand(gtk_tree_view_get_column(treeview, NSGTK_DOWNLOAD_INFO), TRUE); /* Time remaining column */ renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes (treeview, -1, messages_get("gtkRemaining"), renderer, "text", NSGTK_DOWNLOAD_REMAINING, NULL); /* Speed column */ renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes (treeview, -1, messages_get("gtkSpeed"), renderer, "text", NSGTK_DOWNLOAD_SPEED, NULL); return treeview; }
static GtkWidget *create_tree(void) { GtkWidget *tree; GtkTreeModel *model; GtkTreeSelection *selection; GtkTreeViewColumn *column; GtkCellRenderer *renderer; tree = gtk_tree_view_new(); gtk_tree_view_set_show_expanders(GTK_TREE_VIEW(tree), FALSE); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), FALSE); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree), TRUE); gtk_tree_view_set_grid_lines(GTK_TREE_VIEW(tree), GTK_TREE_VIEW_GRID_LINES_NONE); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_expand(column, TRUE); gtk_tree_view_column_set_spacing(column, 6); gtk_tree_view_column_set_min_width(column, 250); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_add_attribute(column, renderer, "icon-name", CONNMAN_COLUMN_ICON); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, TRUE); gtk_tree_view_column_set_cell_data_func(column, renderer, service_to_text, NULL, NULL); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_set_cell_data_func(column, renderer, security_to_icon, NULL, NULL); renderer = gtk_cell_renderer_progress_new(); gtk_cell_renderer_set_fixed_size(renderer, 100, -1); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_set_cell_data_func(column, renderer, strength_to_value, NULL, NULL); model = connman_client_get_model(client); gtk_tree_view_set_model(GTK_TREE_VIEW(tree), model); g_object_unref(model); gtk_tree_view_set_search_column(GTK_TREE_VIEW(tree), CONNMAN_COLUMN_NAME); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE); g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(select_callback), tree); g_signal_connect(G_OBJECT(tree), "button-press-event", G_CALLBACK(button_pressed), NULL); g_signal_connect(G_OBJECT(tree), "popup-menu", G_CALLBACK(popup_callback), NULL); g_signal_connect(G_OBJECT(tree), "drag-drop", G_CALLBACK(drag_drop), NULL); g_signal_connect(G_OBJECT(tree), "drag-data-get", G_CALLBACK(drag_data_get), selection); g_signal_connect(G_OBJECT(tree), "drag-data-received", G_CALLBACK(drag_data_received), model); return tree; }
gint main (gint argc, gchar **argv) { GtkWidget *window; GtkWidget *scrolled_window; GtkWidget *tree_view; GtkTreeModel *tree_model; GtkCellRenderer *renderer; GtkTreeViewColumn *column; gtk_init (&argc, &argv); if (g_getenv ("RTL")) gtk_widget_set_default_direction (GTK_TEXT_DIR_RTL); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "GtkTreeView editing sample"); g_signal_connect (window, "destroy", gtk_main_quit, NULL); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER (window), scrolled_window); tree_model = create_model (); tree_view = gtk_tree_view_new_with_model (tree_model); g_signal_connect (tree_view, "button_press_event", G_CALLBACK (button_press_event), NULL); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (tree_view), TRUE); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), TRUE); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, "String"); renderer = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_attributes (column, renderer, "pixbuf", PIXBUF_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_attributes (column, renderer, "text", STRING_COLUMN, "editable", IS_EDITABLE_COLUMN, NULL); g_signal_connect (renderer, "edited", G_CALLBACK (edited), tree_model); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_attributes (column, renderer, "text", STRING_COLUMN, "editable", IS_EDITABLE_COLUMN, NULL); g_signal_connect (renderer, "edited", G_CALLBACK (edited), tree_model); renderer = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_attributes (column, renderer, "pixbuf", PIXBUF_COLUMN, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column); renderer = gtk_cell_renderer_toggle_new (); g_signal_connect (renderer, "toggled", G_CALLBACK (toggled), tree_model); g_object_set (renderer, "xalign", 0.0, NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view), -1, "Editable", renderer, "active", IS_EDITABLE_COLUMN, NULL); renderer = gtk_cell_renderer_progress_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view), -1, "Progress", renderer, "value", PROGRESS_COLUMN, NULL); gtk_container_add (GTK_CONTAINER (scrolled_window), tree_view); gtk_window_set_default_size (GTK_WINDOW (window), 800, 175); gtk_widget_show_all (window); gtk_main (); return 0; }
void fi_gui_init(void) { fi_sources = htable_create(HASH_KEY_SELF, 0); { GtkTreeViewColumn *column; GtkTreeView *tv; tv = GTK_TREE_VIEW(gui_main_window_lookup("treeview_download_aliases")); treeview_download_aliases = tv; store_aliases = gtk_list_store_new(1, G_TYPE_STRING); gtk_tree_view_set_model(tv, GTK_TREE_MODEL(store_aliases)); column = gtk_tree_view_column_new_with_attributes(_("Aliases"), create_text_cell_renderer(0.0), "text", 0, NULL_PTR); configure_column(column); gtk_tree_view_column_set_sort_column_id(column, 0); gtk_tree_view_append_column(tv, column); tree_view_set_fixed_height_mode(tv, TRUE); drag_attach_text(GTK_WIDGET(tv), fi_gui_get_alias); } { static const struct { enum c_src id; const char *title; } tab[] = { { c_src_host, N_("Host"), }, { c_src_country, N_("Country"), }, { c_src_server, N_("Server"), }, { c_src_range, N_("Range"), }, { c_src_progress, N_("Progress"), }, { c_src_status, N_("Status"), }, }; GtkTreeView *tv; unsigned i; STATIC_ASSERT(c_src_num == N_ITEMS(tab)); tv = GTK_TREE_VIEW(gui_main_window_lookup("treeview_download_sources")); treeview_download_sources = tv; store_sources = gtk_list_store_new(1, G_TYPE_POINTER); gtk_tree_view_set_model(tv, GTK_TREE_MODEL(store_sources)); for (i = 0; i < N_ITEMS(tab); i++) { GtkCellRenderer *renderer; renderer = tab[i].id == c_src_progress ? gtk_cell_renderer_progress_new() : NULL; (void) add_column(tv, tab[i].id, _(tab[i].title), 0.0, renderer, render_sources); } gtk_tree_view_set_headers_clickable(tv, FALSE); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(tv), GTK_SELECTION_MULTIPLE); tree_view_restore_widths(tv, PROP_SOURCES_COL_WIDTHS); tree_view_set_fixed_height_mode(tv, TRUE); widget_add_popup_menu(GTK_WIDGET(tv), fi_gui_sources_get_popup_menu); } fi_gui_details_treeview_init(); fi_gui_common_init(); { uint32 page; GtkNotebook *notebook_downloads_info = GTK_NOTEBOOK(gui_main_window_lookup("notebook_downloads_info")); gui_prop_get_guint32_val(PROP_DOWNLOADS_INFO_NOTEBOOK_TAB, &page); if (page >= NUM_DOWNLOADS_INFO_NB_PAGES) page = DOWNLOADS_INFO_NB_PAGE_DETAILS; notebook_downloads_info_current_page = page; gtk_notebook_set_current_page(notebook_downloads_info, page); gui_signal_connect(notebook_downloads_info, "switch-page", on_notebook_downloads_info_switch_page, NULL); } }
void fi_gui_init(void) { fi_sources = g_hash_table_new(NULL, NULL); { GtkTreeViewColumn *column; GtkTreeView *tv; tv = GTK_TREE_VIEW(gui_main_window_lookup("treeview_download_aliases")); treeview_download_aliases = tv; store_aliases = gtk_list_store_new(1, G_TYPE_STRING); gtk_tree_view_set_model(tv, GTK_TREE_MODEL(store_aliases)); column = gtk_tree_view_column_new_with_attributes(_("Aliases"), create_text_cell_renderer(0.0), "text", 0, (void *) 0); configure_column(column); gtk_tree_view_column_set_sort_column_id(column, 0); gtk_tree_view_append_column(tv, column); tree_view_set_fixed_height_mode(tv, TRUE); drag_attach_text(GTK_WIDGET(tv), fi_gui_get_alias); } { static const struct { enum c_src id; const char *title; } tab[] = { { c_src_host, N_("Host"), }, { c_src_country, N_("Country"), }, { c_src_server, N_("Server"), }, { c_src_range, N_("Range"), }, { c_src_progress, N_("Progress"), }, { c_src_status, N_("Status"), }, }; GtkTreeView *tv; unsigned i; STATIC_ASSERT(c_src_num == G_N_ELEMENTS(tab)); tv = GTK_TREE_VIEW(gui_main_window_lookup("treeview_download_sources")); treeview_download_sources = tv; store_sources = gtk_list_store_new(1, G_TYPE_POINTER); gtk_tree_view_set_model(tv, GTK_TREE_MODEL(store_sources)); for (i = 0; i < G_N_ELEMENTS(tab); i++) { GtkCellRenderer *renderer; renderer = tab[i].id == c_src_progress ? gtk_cell_renderer_progress_new() : NULL; add_column(tv, tab[i].id, _(tab[i].title), 0.0, renderer, render_sources); } gtk_tree_view_set_headers_clickable(tv, FALSE); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(tv), GTK_SELECTION_MULTIPLE); tree_view_restore_widths(tv, PROP_SOURCES_COL_WIDTHS); tree_view_set_fixed_height_mode(tv, TRUE); widget_add_popup_menu(GTK_WIDGET(tv), fi_gui_sources_get_popup_menu); } fi_gui_details_treeview_init(); fi_gui_common_init(); }
gint main (gint argc, gchar **argv) { GtkWidget *window; GtkWidget *scrolled_window; GtkWidget *tree_view; GtkWidget *vbox, *hbox, *cntl_vbox; GtkTreeModel *tree_model; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkCellArea *area; CallbackData callback[4]; gtk_init (&argc, &argv); if (g_getenv ("RTL")) gtk_widget_set_default_direction (GTK_TEXT_DIR_RTL); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "GtkTreeView editing sample"); g_signal_connect (window, "destroy", gtk_main_quit, NULL); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_widget_show (vbox); gtk_container_add (GTK_CONTAINER (window), vbox); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (vbox), scrolled_window, TRUE, TRUE, 0); tree_model = create_model (); tree_view = gtk_tree_view_new_with_model (tree_model); g_signal_connect (tree_view, "button_press_event", G_CALLBACK (button_press_event), NULL); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), TRUE); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, "String"); area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column)); renderer = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "icon-name", ICON_NAME_COLUMN, "sensitive", IS_SENSITIVE_COLUMN, NULL); callback[0].area = area; callback[0].renderer = renderer; renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "text", STRING_COLUMN, "editable", IS_EDITABLE_COLUMN, "sensitive", IS_SENSITIVE_COLUMN, NULL); callback[1].area = area; callback[1].renderer = renderer; g_signal_connect (renderer, "edited", G_CALLBACK (edited), tree_model); g_object_set (renderer, "placeholder-text", "Type here", NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "text", STRING_COLUMN, "editable", IS_EDITABLE_COLUMN, "sensitive", IS_SENSITIVE_COLUMN, NULL); callback[2].area = area; callback[2].renderer = renderer; g_signal_connect (renderer, "edited", G_CALLBACK (edited), tree_model); g_object_set (renderer, "placeholder-text", "Type here too", NULL); renderer = gtk_cell_renderer_pixbuf_new (); g_object_set (renderer, "xalign", 0.0, NULL); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "icon-name", LAST_ICON_NAME_COLUMN, "sensitive", IS_SENSITIVE_COLUMN, NULL); callback[3].area = area; callback[3].renderer = renderer; gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column); renderer = gtk_cell_renderer_toggle_new (); g_signal_connect (renderer, "toggled", G_CALLBACK (editable_toggled), tree_model); g_object_set (renderer, "xalign", 0.0, NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view), -1, "Editable", renderer, "active", IS_EDITABLE_COLUMN, NULL); renderer = gtk_cell_renderer_toggle_new (); g_signal_connect (renderer, "toggled", G_CALLBACK (sensitive_toggled), tree_model); g_object_set (renderer, "xalign", 0.0, NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view), -1, "Sensitive", renderer, "active", IS_SENSITIVE_COLUMN, NULL); renderer = gtk_cell_renderer_progress_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view), -1, "Progress", renderer, "value", PROGRESS_COLUMN, NULL); gtk_container_add (GTK_CONTAINER (scrolled_window), tree_view); gtk_window_set_default_size (GTK_WINDOW (window), 800, 250); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_widget_show (hbox); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); /* Alignment controls */ cntl_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); gtk_widget_show (cntl_vbox); gtk_box_pack_start (GTK_BOX (hbox), cntl_vbox, FALSE, FALSE, 0); create_control (cntl_vbox, 1, CNTL_ALIGN, &callback[0]); create_control (cntl_vbox, 2, CNTL_ALIGN, &callback[1]); create_control (cntl_vbox, 3, CNTL_ALIGN, &callback[2]); create_control (cntl_vbox, 4, CNTL_ALIGN, &callback[3]); /* Expand controls */ cntl_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); gtk_widget_show (cntl_vbox); gtk_box_pack_start (GTK_BOX (hbox), cntl_vbox, FALSE, FALSE, 0); create_control (cntl_vbox, 1, CNTL_EXPAND, &callback[0]); create_control (cntl_vbox, 2, CNTL_EXPAND, &callback[1]); create_control (cntl_vbox, 3, CNTL_EXPAND, &callback[2]); create_control (cntl_vbox, 4, CNTL_EXPAND, &callback[3]); /* Fixed controls */ cntl_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); gtk_widget_show (cntl_vbox); gtk_box_pack_start (GTK_BOX (hbox), cntl_vbox, FALSE, FALSE, 0); create_control (cntl_vbox, 1, CNTL_FIXED, &callback[0]); create_control (cntl_vbox, 2, CNTL_FIXED, &callback[1]); create_control (cntl_vbox, 3, CNTL_FIXED, &callback[2]); create_control (cntl_vbox, 4, CNTL_FIXED, &callback[3]); gtk_widget_show_all (window); gtk_main (); return 0; }
gint main (gint argc, gchar **argv) { GtkWidget *window; GtkWidget *scrolled_window; GtkWidget *tree_view; GtkTreeModel *tree_model; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkCellArea *area; gtk_init (&argc, &argv); if (g_getenv ("RTL")) gtk_widget_set_default_direction (GTK_TEXT_DIR_RTL); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "Vertical cells in GtkTreeViewColumn example"); g_signal_connect (window, "destroy", gtk_main_quit, NULL); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER (window), scrolled_window); tree_model = create_model (); tree_view = gtk_tree_view_new_with_model (tree_model); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), FALSE); /* First column */ column = gtk_tree_view_column_new (); renderer = gtk_cell_renderer_pixbuf_new (); g_object_set (renderer, "stock-size", GTK_ICON_SIZE_DIALOG, NULL); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_attributes (column, renderer, "stock-id", ICON_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "scale", 1.2F, "weight", PANGO_WEIGHT_BOLD, NULL); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_attributes (column, renderer, "text", INFO_COLUMN, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column); /* Second (vertical) column */ column = gtk_tree_view_column_new (); area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column)); gtk_orientable_set_orientation (GTK_ORIENTABLE (area), GTK_ORIENTATION_VERTICAL); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, "editable", TRUE, NULL); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_attributes (column, renderer, "text", DESCRIPTION_COLUMN, NULL); renderer = gtk_cell_renderer_progress_new (); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_attributes (column, renderer, "value", PROGRESS_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "scale", 0.6F, "ellipsize", PANGO_ELLIPSIZE_END, NULL); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_attributes (column, renderer, "text", FINE_PRINT_COLUMN, "foreground", FINE_PRINT_COLOR_COLUMN, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column); gtk_tree_view_expand_all (GTK_TREE_VIEW (tree_view)); gtk_container_add (GTK_CONTAINER (scrolled_window), tree_view); gtk_window_set_default_size (GTK_WINDOW (window), 800, 400); gtk_widget_show_all (window); gtk_main (); return 0; }
static VALUE rg_initialize(VALUE self) { RBGTK_INITIALIZE(self, gtk_cell_renderer_progress_new()); return Qnil; }
static void trg_tree_view_add_column_after(TrgTreeView * tv, trg_column_description * desc, gint64 width, GtkTreeViewColumn * after_col) { GtkCellRenderer *renderer; GtkTreeViewColumn *column = NULL; GtkButton *column_button = NULL; switch (desc->type) { case TRG_COLTYPE_TEXT: renderer = desc->customRenderer ? desc->customRenderer : gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(desc->header, renderer, "text", desc-> model_column, NULL); break; case TRG_COLTYPE_SPEED: renderer = trg_cell_renderer_speed_new(); column = gtk_tree_view_column_new_with_attributes(desc->header, renderer, "speed-value", desc-> model_column, NULL); break; case TRG_COLTYPE_EPOCH: renderer = trg_cell_renderer_epoch_new(); column = gtk_tree_view_column_new_with_attributes(desc->header, renderer, "epoch-value", desc-> model_column, NULL); break; case TRG_COLTYPE_ETA: renderer = trg_cell_renderer_eta_new(); column = gtk_tree_view_column_new_with_attributes(desc->header, renderer, "eta-value", desc-> model_column, NULL); break; case TRG_COLTYPE_SIZE: renderer = trg_cell_renderer_size_new(); column = gtk_tree_view_column_new_with_attributes(desc->header, renderer, "size-value", desc-> model_column, NULL); break; case TRG_COLTYPE_PROG: renderer = gtk_cell_renderer_progress_new(); column = gtk_tree_view_column_new_with_attributes(desc->header, renderer, "value", desc-> model_column, NULL); break; case TRG_COLTYPE_RATIO: renderer = trg_cell_renderer_ratio_new(); column = gtk_tree_view_column_new_with_attributes(desc->header, renderer, "ratio-value", desc-> model_column, NULL); break; case TRG_COLTYPE_WANTED: column = gtk_tree_view_column_new(); renderer = trg_cell_renderer_wanted_new(); /*gtk_cell_renderer_set_alignment(GTK_CELL_RENDERER(renderer), 0.5f, 0.0); */ gtk_tree_view_column_set_title(column, desc->header); gtk_tree_view_column_pack_start(column, renderer, TRUE); gtk_tree_view_column_set_attributes(column, renderer, "wanted-value", desc->model_column, NULL); break; case TRG_COLTYPE_ICONTEXT: column = trg_tree_view_icontext_column_new(desc, "icon-name"); break; case TRG_COLTYPE_FILEICONTEXT: column = trg_tree_view_fileicontext_column_new(desc); break; case TRG_COLTYPE_PRIO: renderer = trg_cell_renderer_priority_new(); column = gtk_tree_view_column_new_with_attributes(desc->header, renderer, "priority-value", desc-> model_column, NULL); break; case TRG_COLTYPE_NUMGTZERO: renderer = trg_cell_renderer_numgteqthan_new(1); column = gtk_tree_view_column_new_with_attributes(desc->header, renderer, "value", desc-> model_column, NULL); break; case TRG_COLTYPE_NUMGTEQZERO: renderer = trg_cell_renderer_numgteqthan_new(0); column = gtk_tree_view_column_new_with_attributes(desc->header, renderer, "value", desc-> model_column, NULL); break; default: g_critical("unknown TrgTreeView column"); return; } //gtk_tree_view_column_set_min_width(column, 0); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_reorderable(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, desc->model_column); gtk_tree_view_column_set_expand(column, TRUE); /*gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);*/ if (width > 0) { //gtk_tree_view_column_set_fixed_width(column, width); } g_object_set_data(G_OBJECT(column), GDATA_KEY_COLUMN_DESC, desc); gtk_tree_view_append_column(GTK_TREE_VIEW(tv), column); if (after_col) gtk_tree_view_move_column_after(GTK_TREE_VIEW(tv), column, after_col); column_button = GTK_BUTTON(gtk_tree_view_column_get_button(column)); g_signal_connect(column_button, "button-press-event", G_CALLBACK(col_onButtonPressed), desc); if (desc->out) *(desc->out) = column; desc->flags |= TRG_COLUMN_SHOWING; }
GtkWidget * create_disk_view(ProcData *procdata) { GtkWidget *disk_box; GtkWidget *label; GtkWidget *scrolled; GtkWidget *disk_tree; GtkListStore *model; GtkTreeViewColumn *col; GtkCellRenderer *cell; guint i; const gchar * const titles[] = { N_("Device"), N_("Directory"), N_("Type"), N_("Total"), N_("Free"), N_("Available"), N_("Used") }; disk_box = gtk_vbox_new(FALSE, 6); gtk_container_set_border_width(GTK_CONTAINER(disk_box), 12); label = make_title_label(_("File Systems")); gtk_box_pack_start(GTK_BOX(disk_box), label, FALSE, FALSE, 0); scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN); gtk_box_pack_start(GTK_BOX(disk_box), scrolled, TRUE, TRUE, 0); model = gtk_list_store_new(DISK_N_COLUMNS, /* n columns */ G_TYPE_STRING, /* DISK_DEVICE */ G_TYPE_STRING, /* DISK_DIR */ G_TYPE_STRING, /* DISK_TYPE */ G_TYPE_UINT64, /* DISK_TOTAL */ G_TYPE_UINT64, /* DISK_FREE */ G_TYPE_UINT64, /* DISK_AVAIL */ G_TYPE_UINT64, /* DISK_USED */ GDK_TYPE_PIXBUF, /* DISK_ICON */ G_TYPE_INT /* DISK_USED_PERCENTAGE */ ); disk_tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model)); g_signal_connect(G_OBJECT(disk_tree), "row-activated", G_CALLBACK(open_dir), NULL); procdata->disk_list = disk_tree; gtk_container_add(GTK_CONTAINER(scrolled), disk_tree); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(disk_tree), TRUE); g_object_unref(G_OBJECT(model)); /* icon + device */ col = gtk_tree_view_column_new(); cell = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(col, cell, FALSE); gtk_tree_view_column_set_attributes(col, cell, "pixbuf", DISK_ICON, NULL); cell = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(col, cell, FALSE); gtk_tree_view_column_set_attributes(col, cell, "text", DISK_DEVICE, NULL); gtk_tree_view_column_set_title(col, _(titles[DISK_DEVICE])); gtk_tree_view_column_set_sort_column_id(col, DISK_DEVICE); gtk_tree_view_column_set_reorderable(col, TRUE); gtk_tree_view_column_set_resizable(col, TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(disk_tree), col); /* sizes - used */ for (i = DISK_DIR; i <= DISK_AVAIL; i++) { cell = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new(); gtk_tree_view_column_pack_start(col, cell, TRUE); gtk_tree_view_column_set_title(col, _(titles[i])); gtk_tree_view_column_set_resizable(col, TRUE); gtk_tree_view_column_set_sort_column_id(col, i); gtk_tree_view_column_set_reorderable(col, TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(disk_tree), col); switch (i) { case DISK_TOTAL: case DISK_FREE: case DISK_AVAIL: g_object_set(cell, "xalign", 1.0f, NULL); gtk_tree_view_column_set_cell_data_func(col, cell, &procman::size_cell_data_func, GUINT_TO_POINTER(i), NULL); break; default: gtk_tree_view_column_set_attributes(col, cell, "text", i, NULL); break; } } /* used + percentage */ col = gtk_tree_view_column_new(); cell = gtk_cell_renderer_text_new(); g_object_set(cell, "xalign", 1.0f, NULL); gtk_tree_view_column_pack_start(col, cell, FALSE); gtk_tree_view_column_set_cell_data_func(col, cell, &procman::size_cell_data_func, GUINT_TO_POINTER(DISK_USED), NULL); gtk_tree_view_column_set_title(col, _(titles[DISK_USED])); cell = gtk_cell_renderer_progress_new(); gtk_tree_view_column_pack_start(col, cell, TRUE); gtk_tree_view_column_set_attributes(col, cell, "value", DISK_USED_PERCENTAGE, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(disk_tree), col); gtk_tree_view_column_set_resizable(col, TRUE); gtk_tree_view_column_set_sort_column_id(col, DISK_USED); gtk_tree_view_column_set_reorderable(col, TRUE); /* numeric sort */ gtk_widget_show_all(disk_box); procman_get_tree_state(procdata->client, disk_tree, "/apps/procman/disktreenew"); g_signal_connect (G_OBJECT(disk_tree), "columns-changed", G_CALLBACK(cb_disk_columns_changed), procdata); return disk_box; }
/* main */ int main(int argc, char *argv[]) { GtkWidget *window; GtkWidget *table; GtkWidget *button; GtkCellRenderer *cell; Data data; /* initialition */ gtk_init(&argc, &argv); /* main window */ window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(window), "GtkComboBox"); gtk_widget_set_size_request(window, 640, 320); gtk_window_set_resizable(GTK_WINDOW(window), FALSE); gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); gtk_container_set_border_width(GTK_CONTAINER(window), 10); g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL); /* table */ table = gtk_table_new(4, 3, FALSE); gtk_container_add(GTK_CONTAINER(window), table); /* create combox box */ data.combo = gtk_combo_box_new(); g_signal_connect(data.combo, "changed", G_CALLBACK(cb_changed), &data); gtk_table_attach(GTK_TABLE(table), data.combo, 0, 3, 0, 1, GTK_EXPAND|GTK_FILL, GTK_SHRINK, 0, 0); /* create data store */ data.store = create_model(&data); /* add data store to combo box */ gtk_combo_box_set_model(GTK_COMBO_BOX(data.combo), data.store); g_object_unref(data.store); /* create pixbuf cell renderer */ cell = gtk_cell_renderer_pixbuf_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(data.combo), cell, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(data.combo), cell, "stock-id", PIXBUF_C, "visible", PIXBUF_VIS_C, NULL); /* create text cell renderer */ cell = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(data.combo), cell, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(data.combo), cell, "text", TEXT_C, "visible", TEXT_VIS_C, "foreground", TEXT_COL_C, NULL); /* create progress cell renderer */ cell = gtk_cell_renderer_progress_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(data.combo), cell, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(data.combo), cell, "value", PROGRESS_C, "visible", PROGRESS_VIS_C, NULL); /* create check buttons for controling visibility */ data.vis_pixbuf = gtk_check_button_new_with_label("image visible"); gtk_table_attach(GTK_TABLE(table), data.vis_pixbuf, 0, 1, 1, 2, GTK_EXPAND|GTK_FILL, GTK_SHRINK, 0, 0); data.vis_text = gtk_check_button_new_with_label("text visible"); gtk_table_attach(GTK_TABLE(table), data.vis_text, 1, 2, 1, 2, GTK_EXPAND|GTK_FILL, GTK_SHRINK, 0, 0); data.vis_progress = gtk_check_button_new_with_label("progress visible"); gtk_table_attach(GTK_TABLE(table), data.vis_progress, 2, 3, 1, 2, GTK_EXPAND|GTK_FILL, GTK_SHRINK, 0, 0); /* create entries for modifying values */ data.e_pixbuf = gtk_entry_new(); gtk_table_attach(GTK_TABLE(table), data.e_pixbuf, 0, 1, 2, 3, GTK_EXPAND|GTK_FILL, GTK_SHRINK, 0, 0); data.e_text = gtk_entry_new(); gtk_table_attach(GTK_TABLE(table), data.e_text, 1, 2, 2, 3, GTK_EXPAND|GTK_FILL, GTK_SHRINK, 0, 0); data.e_progress = gtk_spin_button_new_with_range(0, 100, 1); gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(data.e_progress), TRUE); gtk_table_attach(GTK_TABLE(table), data.e_progress, 2, 3, 2, 3, GTK_EXPAND|GTK_FILL, GTK_SHRINK, 0, 0); /* create button for applying changes */ button = gtk_button_new_from_stock(GTK_STOCK_APPLY); g_signal_connect(button, "clicked", G_CALLBACK(cb_clicked), &data); gtk_table_attach(GTK_TABLE(table), button, 0, 3, 3, 4, GTK_EXPAND|GTK_FILL, GTK_SHRINK, 0, 0); /* manually call cb_changed function to set controllers to right state */ cb_changed(GTK_COMBO_BOX(data.combo), &data); gtk_widget_show_all(window); gtk_main(); return 0; }
static void ft_manager_build_ui (EmpathyFTManager *manager) { GtkBuilder *gui; GtkTreeView *view; GtkListStore *liststore; GtkTreeViewColumn *column; GtkCellRenderer *renderer; GtkTreeSelection *selection; gchar *filename; EmpathyFTManagerPriv *priv = GET_PRIV (manager); filename = empathy_file_lookup ("empathy-ft-manager.ui", "src"); gui = tpaw_builder_get_file (filename, "ft_manager_dialog", &priv->window, "ft_list", &priv->treeview, "clear_button", &priv->clear_button, "open_button", &priv->open_button, "abort_button", &priv->abort_button, NULL); g_free (filename); tpaw_builder_connect (gui, manager, "ft_manager_dialog", "destroy", ft_manager_destroy_cb, "ft_manager_dialog", "response", ft_manager_response_cb, "ft_manager_dialog", "delete-event", ft_manager_delete_event_cb, "ft_manager_dialog", "key-press-event", ft_manager_key_press_event_cb, NULL); tpaw_builder_unref_and_keep_widget (gui, priv->window); /* Window geometry. */ empathy_geometry_bind (GTK_WINDOW (priv->window), "ft-manager"); /* Setup the tree view */ view = GTK_TREE_VIEW (priv->treeview); selection = gtk_tree_view_get_selection (view); gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE); g_signal_connect (selection, "changed", G_CALLBACK (ft_manager_selection_changed), manager); g_signal_connect (view, "button-press-event", G_CALLBACK (ft_view_button_press_event_cb), manager); gtk_tree_view_set_headers_visible (view, TRUE); gtk_tree_view_set_enable_search (view, FALSE); /* Setup the model */ liststore = gtk_list_store_new (5, G_TYPE_INT, /* percent */ G_TYPE_ICON, /* icon */ G_TYPE_STRING, /* message */ G_TYPE_STRING, /* remaining */ G_TYPE_OBJECT); /* ft_handler */ gtk_tree_view_set_model (view, GTK_TREE_MODEL (liststore)); priv->model = GTK_TREE_MODEL (liststore); g_object_unref (liststore); /* Progress column */ column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("%")); gtk_tree_view_column_set_sort_column_id (column, COL_PERCENT); gtk_tree_view_insert_column (view, column, -1); renderer = gtk_cell_renderer_progress_new (); g_object_set (renderer, "xalign", 0.5, NULL); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_cell_data_func (column, renderer, ft_manager_progress_cell_data_func, NULL, NULL); /* Icon and filename column*/ column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("File")); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_column_set_sort_column_id (column, COL_MESSAGE); gtk_tree_view_column_set_spacing (column, 3); gtk_tree_view_insert_column (view, column, -1); renderer = gtk_cell_renderer_pixbuf_new (); g_object_set (renderer, "xpad", 3, "stock-size", GTK_ICON_SIZE_DND, NULL); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "gicon", COL_ICON, NULL); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_attributes (column, renderer, "text", COL_MESSAGE, NULL); /* Remaining time column */ column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Remaining")); gtk_tree_view_column_set_sort_column_id (column, COL_REMAINING); gtk_tree_view_insert_column (view, column, -1); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "xalign", 0.5, NULL); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "text", COL_REMAINING, NULL); /* clear button should be sensitive only if there are completed/cancelled * handlers in the store. */ gtk_widget_set_sensitive (priv->clear_button, FALSE); }
void create_disk_view(GsmApplication *app, GtkBuilder *builder) { GtkScrolledWindow *scrolled; GsmTreeView *disk_tree; GtkListStore *model; GtkTreeViewColumn *col; GtkCellRenderer *cell; guint i; init_volume_monitor (app); const gchar * const titles[] = { N_("Device"), N_("Directory"), N_("Type"), N_("Total"), N_("Free"), N_("Available"), N_("Used") }; scrolled = GTK_SCROLLED_WINDOW (gtk_builder_get_object (builder, "disks_scrolled")); model = gtk_list_store_new(DISK_N_COLUMNS, /* n columns */ G_TYPE_STRING, /* DISK_DEVICE */ G_TYPE_STRING, /* DISK_DIR */ G_TYPE_STRING, /* DISK_TYPE */ G_TYPE_UINT64, /* DISK_TOTAL */ G_TYPE_UINT64, /* DISK_FREE */ G_TYPE_UINT64, /* DISK_AVAIL */ G_TYPE_UINT64, /* DISK_USED */ GDK_TYPE_PIXBUF, /* DISK_ICON */ G_TYPE_INT /* DISK_USED_PERCENTAGE */ ); disk_tree = gsm_tree_view_new (g_settings_get_child (app->settings->gobj(), GSM_SETTINGS_CHILD_DISKS), TRUE); gtk_tree_view_set_model (GTK_TREE_VIEW (disk_tree), GTK_TREE_MODEL (model)); g_signal_connect(G_OBJECT(disk_tree), "row-activated", G_CALLBACK(open_dir), NULL); app->disk_list = disk_tree; gtk_container_add(GTK_CONTAINER(scrolled), GTK_WIDGET (disk_tree)); g_object_unref(G_OBJECT(model)); /* icon + device */ col = gtk_tree_view_column_new(); cell = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(col, cell, FALSE); gtk_tree_view_column_set_attributes(col, cell, "pixbuf", DISK_ICON, NULL); cell = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(col, cell, FALSE); gtk_tree_view_column_set_attributes(col, cell, "text", DISK_DEVICE, NULL); gtk_tree_view_column_set_title(col, _(titles[DISK_DEVICE])); gtk_tree_view_column_set_sort_column_id(col, DISK_DEVICE); gtk_tree_view_column_set_reorderable(col, TRUE); gtk_tree_view_column_set_resizable(col, TRUE); gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED); gsm_tree_view_append_and_bind_column (GSM_TREE_VIEW (disk_tree), col); /* sizes - used */ for (i = DISK_DIR; i <= DISK_AVAIL; i++) { cell = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new(); gtk_tree_view_column_pack_start(col, cell, TRUE); gtk_tree_view_column_set_title(col, _(titles[i])); gtk_tree_view_column_set_resizable(col, TRUE); gtk_tree_view_column_set_sort_column_id(col, i); gtk_tree_view_column_set_reorderable(col, TRUE); gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED); gsm_tree_view_append_and_bind_column (GSM_TREE_VIEW (disk_tree), col); switch (i) { case DISK_TOTAL: case DISK_FREE: case DISK_AVAIL: g_object_set(cell, "xalign", 1.0f, NULL); gtk_tree_view_column_set_cell_data_func(col, cell, &procman::size_si_cell_data_func, GUINT_TO_POINTER(i), NULL); break; default: gtk_tree_view_column_set_attributes(col, cell, "text", i, NULL); break; } } /* used + percentage */ col = gtk_tree_view_column_new(); cell = gtk_cell_renderer_text_new(); g_object_set(cell, "xalign", 1.0f, NULL); gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_pack_start(col, cell, FALSE); gtk_tree_view_column_set_cell_data_func(col, cell, &procman::size_si_cell_data_func, GUINT_TO_POINTER(DISK_USED), NULL); gtk_tree_view_column_set_title(col, _(titles[DISK_USED])); cell = gtk_cell_renderer_progress_new(); gtk_cell_renderer_set_padding(cell, 4.0f, 4.0f); gtk_tree_view_column_pack_start(col, cell, TRUE); gtk_tree_view_column_set_attributes(col, cell, "value", DISK_USED_PERCENTAGE, NULL); gtk_tree_view_column_set_resizable(col, TRUE); gtk_tree_view_column_set_sort_column_id(col, DISK_USED); gtk_tree_view_column_set_reorderable(col, TRUE); gsm_tree_view_append_and_bind_column (GSM_TREE_VIEW (disk_tree), col); /* numeric sort */ gsm_tree_view_load_state (GSM_TREE_VIEW (disk_tree)); g_signal_connect (G_OBJECT(disk_tree), "destroy", G_CALLBACK(cb_disk_list_destroying), app); g_signal_connect (G_OBJECT(disk_tree), "columns-changed", G_CALLBACK(cb_disk_columns_changed), app); g_signal_connect (G_OBJECT (model), "sort-column-changed", G_CALLBACK (cb_sort_changed), app); app->settings->signal_changed(GSM_SETTING_SHOW_ALL_FS).connect ([app](const Glib::ustring&) { disks_update (app); disks_reset_timeout (app); }); gtk_widget_show (GTK_WIDGET (disk_tree)); }
static void remmina_ftp_client_init(RemminaFTPClient *client) { RemminaFTPClientPriv *priv; GtkWidget *vpaned; GtkWidget *scrolledwindow; GtkWidget *widget; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkWidget *vbox; priv = g_new0(RemminaFTPClientPriv, 1); client->priv = priv; /* Main container */ gtk_box_set_homogeneous(GTK_BOX(client), FALSE); gtk_box_set_spacing(GTK_BOX(client), 4); /* Toolbar */ remmina_ftp_client_create_toolbar(client); /* The Paned to separate File List and Task List */ #if GTK_VERSION == 3 vpaned = gtk_paned_new(GTK_ORIENTATION_VERTICAL); #elif GTK_VERSION == 2 vpaned = gtk_vpaned_new(); #endif gtk_widget_show(vpaned); gtk_box_pack_start(GTK_BOX(client), vpaned, TRUE, TRUE, 0); priv->vpaned = vpaned; /* Remote */ #if GTK_VERSION == 3 vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); #elif GTK_VERSION == 2 vbox = gtk_vbox_new(FALSE, 0); #endif gtk_widget_show(vbox); gtk_paned_pack1(GTK_PANED(vpaned), vbox, TRUE, FALSE); /* Remote Directory */ widget = gtk_combo_box_text_new_with_entry(); gtk_widget_show(widget); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widget), "/"); gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, TRUE, 0); priv->directory_combo = widget; /* Remote File List */ scrolledwindow = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolledwindow); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_box_pack_start(GTK_BOX(vbox), scrolledwindow, TRUE, TRUE, 0); widget = gtk_tree_view_new(); gtk_widget_show(widget); gtk_container_add(GTK_CONTAINER(scrolledwindow), widget); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(widget)), GTK_SELECTION_MULTIPLE); priv->file_list_view = widget; /* Remote File List - Columns */ column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, _("File Name")); gtk_tree_view_column_set_expand(column, TRUE); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_NAME_SORT); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_filetype_pixbuf, NULL, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_add_attribute(column, renderer, "text", REMMINA_FTP_FILE_COLUMN_NAME); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Size"), renderer, NULL); gtk_tree_view_column_set_alignment(column, 1.0); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_size, NULL, NULL); gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_SIZE); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("User"), renderer, "text", REMMINA_FTP_FILE_COLUMN_USER, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_USER); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Group"), renderer, "text", REMMINA_FTP_FILE_COLUMN_GROUP, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_GROUP); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Permission"), renderer, "text", REMMINA_FTP_FILE_COLUMN_PERMISSION, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_permission, NULL, NULL); gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_PERMISSION); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column); /* Remote File List - Model */ priv->file_list_model = GTK_TREE_MODEL( gtk_list_store_new(REMMINA_FTP_FILE_N_COLUMNS, G_TYPE_INT, G_TYPE_STRING, G_TYPE_FLOAT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING)); priv->file_list_filter = gtk_tree_model_filter_new(priv->file_list_model, NULL); gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(priv->file_list_filter), (GtkTreeModelFilterVisibleFunc) remmina_ftp_client_filter_visible_func, client, NULL); priv->file_list_sort = gtk_tree_model_sort_new_with_model(priv->file_list_filter); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(priv->file_list_sort), REMMINA_FTP_FILE_COLUMN_NAME_SORT, GTK_SORT_ASCENDING); gtk_tree_view_set_model(GTK_TREE_VIEW(priv->file_list_view), priv->file_list_sort); /* Task List */ scrolledwindow = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolledwindow); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_paned_pack2(GTK_PANED(vpaned), scrolledwindow, FALSE, TRUE); widget = gtk_tree_view_new(); gtk_widget_show(widget); gtk_container_add(GTK_CONTAINER(scrolledwindow), widget); g_object_set(widget, "has-tooltip", TRUE, NULL); priv->task_list_view = widget; /* Task List - Columns */ column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, _("File Name")); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_expand(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_TASK_COLUMN_NAME); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_progress_pixbuf, NULL, NULL); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_filetype_pixbuf, NULL, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_add_attribute(column, renderer, "text", REMMINA_FTP_FILE_COLUMN_NAME); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Remote"), renderer, "text", REMMINA_FTP_TASK_COLUMN_REMOTEDIR, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_TASK_COLUMN_REMOTEDIR); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Local"), renderer, "text", REMMINA_FTP_TASK_COLUMN_LOCALDIR, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_TASK_COLUMN_LOCALDIR); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Size"), renderer, NULL); gtk_tree_view_column_set_alignment(column, 1.0); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_size_progress, NULL, NULL); gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_TASK_COLUMN_SIZE); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column); renderer = gtk_cell_renderer_progress_new(); column = gtk_tree_view_column_new_with_attributes(_("Progress"), renderer, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_progress, NULL, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column); renderer = remmina_cell_renderer_pixbuf_new(); column = gtk_tree_view_column_new_with_attributes(NULL, renderer, NULL); g_object_set(G_OBJECT(renderer), "stock-id", "_Cancel", NULL); gtk_tree_view_column_set_resizable(column, FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column); g_signal_connect(G_OBJECT(renderer), "activate", G_CALLBACK(remmina_ftp_client_task_list_cell_on_activate), client); /* Task List - Model */ priv->task_list_model = GTK_TREE_MODEL( gtk_list_store_new(REMMINA_FTP_TASK_N_COLUMNS, G_TYPE_INT, G_TYPE_STRING, G_TYPE_FLOAT, G_TYPE_INT, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_FLOAT, G_TYPE_STRING)); gtk_tree_view_set_model(GTK_TREE_VIEW(priv->task_list_view), priv->task_list_model); /* Setup the internal signals */ g_signal_connect(G_OBJECT(client), "destroy", G_CALLBACK(remmina_ftp_client_destroy), NULL); g_signal_connect(G_OBJECT(gtk_bin_get_child(GTK_BIN(priv->directory_combo))), "activate", G_CALLBACK(remmina_ftp_client_dir_on_activate), client); g_signal_connect(G_OBJECT(priv->directory_combo), "changed", G_CALLBACK(remmina_ftp_client_dir_on_changed), client); g_signal_connect(G_OBJECT(priv->file_list_view), "button-press-event", G_CALLBACK(remmina_ftp_client_file_list_on_button_press), client); g_signal_connect(G_OBJECT(gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->file_list_view))), "changed", G_CALLBACK(remmina_ftp_client_file_selection_on_changed), client); g_signal_connect(G_OBJECT(priv->task_list_view), "query-tooltip", G_CALLBACK(remmina_ftp_client_task_list_on_query_tooltip), client); }
static void serverstats_init(void) { /** Get an allready exposed widgets to grab theme colors from. */ GtkWidget *colw = (GtkWidget *) playlist3_get_category_tree_view(); GtkWidget *label = NULL; GtkWidget *table = NULL; GtkWidget *hbox = NULL; GtkWidget *event = NULL; GtkWidget *serverstats_vbox = gtk_vbox_new(FALSE, 0); GtkWidget *serverstats_event; gchar *markup = NULL; int i = 0; serverstats_sw = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(serverstats_sw), GTK_SHADOW_IN); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(serverstats_sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); serverstats_event = gtk_event_box_new(); gtk_event_box_set_visible_window(GTK_EVENT_BOX(serverstats_event), TRUE); gtk_container_add(GTK_CONTAINER(serverstats_event), serverstats_vbox); { GtkStyleContext *cs = gtk_widget_get_style_context(GTK_WIDGET(serverstats_event)); gtk_style_context_add_class(cs, GTK_STYLE_CLASS_VIEW); } /* wrap in event box to set bg color */ event = gtk_event_box_new(); gtk_event_box_set_visible_window(GTK_EVENT_BOX(event), TRUE); //gtk_widget_set_state(GTK_WIDGET(event), GTK_STATE_SELECTED); { GtkStyleContext *cs = gtk_widget_get_style_context(GTK_WIDGET(serverstats_event)); gtk_style_context_add_class(cs, GTK_STYLE_CLASS_HEADER); } //gtk_widget_modify_bg(serverstats_event, GTK_STATE_NORMAL, &(colw->style->base[GTK_STATE_NORMAL])); g_signal_connect(G_OBJECT(serverstats_vbox), "style-set", G_CALLBACK(serverstats_header_style_changed), serverstats_event); /* set label and padding */ hbox = gtk_hbox_new(FALSE, 6); label = gtk_image_new_from_icon_name("mpd", GTK_ICON_SIZE_DND); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0); label = gtk_label_new(""); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); markup = g_markup_printf_escaped("<span size='xx-large' weight='bold'>%s</span>", _("Server Information")); gtk_label_set_markup(GTK_LABEL(label), markup); g_free(markup); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0); gtk_container_add(GTK_CONTAINER(event), hbox); gtk_container_set_border_width(GTK_CONTAINER(hbox), 6); gtk_box_pack_start(GTK_BOX(serverstats_vbox), event, FALSE, TRUE, 0); gtk_widget_show_all(event); label = gtk_hseparator_new(); gtk_box_pack_start(GTK_BOX(serverstats_vbox), label, FALSE, TRUE, 0); gtk_widget_show(label); /** * Data list */ table = gtk_grid_new();//(SERVERSTATS_NUM_FIELDS + 2, 2, FALSE); gtk_grid_set_column_spacing(GTK_GRID(table), 6); gtk_grid_set_row_spacing(GTK_GRID(table), 6); gtk_container_set_border_width(GTK_CONTAINER(table), 12); /** Database */ label = gtk_label_new(""); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); markup = g_markup_printf_escaped("<span size='x-large' weight='bold'>%s</span>", _("Server")); gtk_label_set_markup(GTK_LABEL(label), markup); g_free(markup); gtk_grid_attach(GTK_GRID(table), label, 0,0,2,1); i = 1; /** Mpd version */ serverstats_add_entry(table, i++, _("Version"), SERVERSTATS_MPD_VERSION); serverstats_add_entry(table, i++, _("Uptime"), SERVERSTATS_MPD_UPTIME); serverstats_add_entry(table, i++, _("Time Playing"), SERVERSTATS_MPD_PLAYTIME); /** Database */ label = gtk_label_new(""); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); markup = g_markup_printf_escaped("<span size='x-large' weight='bold'>%s</span>", _("Database")); gtk_label_set_markup(GTK_LABEL(label), markup); g_free(markup); gtk_grid_attach(GTK_GRID(table), label, 0, i, 2, 1); i++; /** Mpd Playtime */ serverstats_add_entry(table, i++, _("Total Playtime"), SERVERSTATS_MPD_DB_PLAYTIME); /** Mpd Artists*/ serverstats_add_entry(table, i++, _("Number of artists"), SERVERSTATS_MPD_DB_ARTISTS); /** Mpd Albums */ serverstats_add_entry(table, i++, _("Number of albums"), SERVERSTATS_MPD_DB_ALBUMS); /** Mpd Songs */ serverstats_add_entry(table, i++, _("Number of songs"), SERVERSTATS_MPD_DB_SONGS); /** Mpd Songs */ serverstats_add_entry(table, i++, _("URL Handlers"), SERVERSTATS_MPD_URLHANDLERS); /** Mpd Songs */ serverstats_add_entry(table, i++, _("Tag Types"), SERVERSTATS_MPD_TAG_TYPES); /** Stats */ label = gtk_label_new(""); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); markup = g_markup_printf_escaped("<span size='x-large' weight='bold'>%s</span>", _("Tag statistics")); gtk_label_set_markup(GTK_LABEL(label), markup); g_free(markup); gtk_grid_attach(GTK_GRID(table), label, 0, i, 2, 1); i++; gtk_widget_show_all(table); /** * Stats treeview */ { int j; GtkWidget *combo = NULL; GtkWidget *sw = NULL, *cancel; GtkListStore *store; GtkCellRenderer *renderer; GtkWidget *pb = gtk_progress_bar_new(); combo = gtk_combo_box_text_new(); for (j = 0; j < MPD_TAG_NUM_OF_ITEM_TYPES - 1; j++) { if (mpd_server_tag_supported(connection, j)) { gtk_combo_box_text_append(GTK_COMBO_BOX(combo),NULL, mpdTagItemKeys[j]); } } gtk_grid_attach(GTK_GRID(table), combo, 0, i, 2, 1); i++; gtk_widget_show(combo); hbox = gtk_hbox_new(FALSE, 6); cancel = gtk_button_new_from_stock(GTK_STOCK_CANCEL); g_signal_connect(G_OBJECT(cancel), "clicked", G_CALLBACK(cancel_clicked), NULL); gtk_box_pack_start(GTK_BOX(hbox), pb, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hbox), cancel, FALSE, TRUE, 0); gtk_grid_attach(GTK_GRID(table), hbox, 0, i, 2, 1); i++; g_signal_connect(G_OBJECT(combo), "changed", G_CALLBACK(serverstats_combo_changed), pb); sw = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_NEVER, GTK_POLICY_NEVER); gtk_container_set_border_width(GTK_CONTAINER(sw), 6); store = gtk_list_store_new(4, G_TYPE_ULONG, G_TYPE_STRING, G_TYPE_ULONG, G_TYPE_STRING); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), 0, GTK_SORT_DESCENDING); serverstats_tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(serverstats_tree), FALSE); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(serverstats_tree), TRUE); renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, "ellipsize-set", TRUE, "width-chars", 30, NULL); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(serverstats_tree), -1, "", renderer, "text", 1, NULL); renderer = gtk_cell_renderer_progress_new(); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(serverstats_tree), -1, "", renderer, "value", 2, "text", 3, NULL); gtk_tree_view_set_search_column(GTK_TREE_VIEW(serverstats_tree), 1); gtk_container_add(GTK_CONTAINER(sw), serverstats_tree); gtk_grid_attach(GTK_GRID(table), sw, 0, i, 2, 1); i++; gtk_widget_show_all(sw); } /** * Add table */ gtk_box_pack_start(GTK_BOX(serverstats_vbox), table, TRUE, TRUE, 0); /* maintain my own reference to the widget, so it won't get destroyed removing * from view */ gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(serverstats_sw), serverstats_event); gtk_widget_show(serverstats_vbox); gtk_widget_show(serverstats_event); gtk_widget_show(serverstats_sw); g_object_ref_sink(serverstats_sw); }