/** * gwy_coords_view_create_column_index: * @view: A coords view. * @title: (allow-none): * Column title. Passing %NULL means a column title will be * constructed automatically, containing something like "n". If you * want an empty title pass the empty string. * * Creates a standard column with item index for a coords view. * * Returns: (transfer full): * Newly created tree view column. **/ GtkTreeViewColumn* gwy_coords_view_create_column_index(GwyCoordsView *view, const gchar *title) { g_return_val_if_fail(GWY_IS_COORDS_VIEW(view), NULL); CoordsView *priv = view->priv; GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); gtk_cell_renderer_set_fixed_size(renderer, -1, priv->height); g_object_set(renderer, "foreground-set", TRUE, NULL); GtkTreeViewColumn *column = gtk_tree_view_column_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(column), renderer, TRUE); gtk_tree_view_column_set_cell_data_func(column, renderer, render_index, NULL, NULL); GtkWidget *header = gtk_label_new(NULL); gtk_label_set_justify(GTK_LABEL(header), GTK_JUSTIFY_CENTER); gtk_widget_show(header); gtk_tree_view_column_set_widget(column, header); ColumnInfo *column_info = g_slice_new(ColumnInfo); column_info->column = column; column_info->i = G_MAXUINT; column_info->is_index = TRUE; column_info->title = g_strdup(title ? title : "n"); priv->column_info = g_slist_prepend(priv->column_info, column_info); g_object_weak_ref(G_OBJECT(column), column_gone, view); update_column_title(view, column_info); return column; }
/** * Event triggered when a pop-up menu associated to a column is * triggered and option is selected. Changes the CSV field config for * this column. Title label of column is changed too. * * \param item GtkMenuItem that triggered event. * \param no_menu Position of column that triggered pop up menu. * * \return FALSE */ gboolean csv_import_change_field ( GtkWidget * item, gint no_menu ) { GtkTreeViewColumn * col; GtkWidget * label; gchar * name; gint field; col = g_object_get_data ( G_OBJECT(item), "column" ); field = GPOINTER_TO_INT ( g_object_get_data ( G_OBJECT(item), "field" ) ); gtk_tree_view_column_set_title ( col, _( csv_fields [ no_menu ] . name ) ); if ( no_menu > 0 ) { name = g_strconcat ( "<b><u>", _( csv_fields [ no_menu ] . name ), "</u></b>", NULL ); } else { name = _( csv_fields [ no_menu ] . name ); } label = gtk_label_new ( name ); gtk_label_set_markup ( GTK_LABEL(label), name ); gtk_widget_show ( label ); gtk_tree_view_column_set_widget ( col, label ); csv_fields_config [ field ] = no_menu; csv_import_update_validity_check ( g_object_get_data ( G_OBJECT(col), "assistant" ) ); return FALSE; }
static void panda_clist_build_children (GladeXML *xml, GtkWidget *w, GladeWidgetInfo *info, const char *longname) { GList *tmp; GtkTreeViewColumn *column; gint col = 0; for (tmp = info->children; tmp; tmp = tmp->next) { GtkWidget *child = glade_xml_build_widget (xml, tmp->data, longname); gtk_widget_show(child); column = gtk_tree_view_get_column(GTK_TREE_VIEW(w), col); gtk_tree_view_column_set_widget(column, child); if (GTK_IS_MISC(child)) { gtk_tree_view_column_set_alignment(column, GTK_MISC(child)->xalign); gtk_misc_set_padding(GTK_MISC(child),0,0); } gtk_tree_view_column_set_clickable(column, FALSE); gtk_tree_view_column_set_spacing(column,0); if (!GTK_PANDA_CLIST(w)->show_titles) { gtk_widget_hide(child); } col++; } }
/* Set the title of COLUMN to TITLE and also set TOOLTIP. */ void gpa_set_column_title (GtkTreeViewColumn *column, const char *title, const char *tooltip) { GtkWidget *label; label = gtk_label_new (title); /* We need to show the label before setting the widget. */ gtk_widget_show (label); gtk_tree_view_column_set_widget (column, label); if (tooltip) gpa_add_tooltip (gtk_tree_view_column_get_widget (column), tooltip); }
/** * add_columns: * @treeview: the GtkTreeView to add the column to * * Adds a column to a GtkTreeView. */ static void add_columns (GtkTreeView * treeview) { GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkWidget *img_att; GdkPixbuf *pix; renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_(" Index "), renderer, "text", COL_INDEX, NULL); gtk_tree_view_column_set_alignment (column, (gfloat) 0.5); gtk_tree_view_append_column (treeview, column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_(" Title "), renderer, "text", COL_ID, NULL); gtk_tree_view_column_set_alignment (column, (gfloat) 0.5); gtk_tree_view_append_column (treeview, column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new (); pix = gdk_pixbuf_new_from_xpm_data (clip_xpm); img_att = gtk_image_new_from_pixbuf (pix); gtk_misc_set_alignment (GTK_MISC (img_att), (gfloat) 0.5, (gfloat) 0.0); g_object_unref (G_OBJECT (pix)); gtk_tree_view_column_set_widget (column, img_att); g_object_set (G_OBJECT (renderer), "xalign", (gfloat) 0.5, NULL); /*needed at least in GTK 2.0.6, anyways doing it seems stupid 2 me*/ gtk_widget_show (img_att); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_add_attribute (column, renderer, "text", NUM_ATT); gtk_tree_view_column_set_alignment (column, (gfloat) 0.5); gtk_tree_view_append_column (treeview, column); }
void ListBox::create(Window &parent, unsigned x, unsigned y, unsigned width, unsigned height, const char *text) { listBox->selection = -1; object->widget = gtk_scrolled_window_new(0, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(object->widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(object->widget), GTK_SHADOW_ETCHED_IN); gtk_widget_set_size_request(object->widget, width, height); lstring list; list.split("\t", text); GType *v = (GType*)malloc(list.size() * sizeof(GType)); for(unsigned i = 0; i < list.size(); i++) v[i] = G_TYPE_STRING; listBox->store = gtk_list_store_newv(list.size(), v); free(v); object->subWidget = gtk_tree_view_new_with_model(GTK_TREE_MODEL(listBox->store)); gtk_container_add(GTK_CONTAINER(object->widget), object->subWidget); g_object_unref(G_OBJECT(listBox->store)); //alternate color of each row if there is more than one column gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(object->subWidget), list.size() >= 2); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(object->subWidget), false); for(unsigned i = 0; i < list.size(); i++) { listBox->column[i].renderer = gtk_cell_renderer_text_new(); listBox->column[i].column = gtk_tree_view_column_new_with_attributes( list[i], listBox->column[i].renderer, "text", i, (void*)0 ); listBox->column[i].label = gtk_label_new(list[i]); gtk_tree_view_column_set_widget(GTK_TREE_VIEW_COLUMN(listBox->column[i].column), listBox->column[i].label); gtk_tree_view_append_column(GTK_TREE_VIEW(object->subWidget), listBox->column[i].column); gtk_widget_show(listBox->column[i].label); } g_signal_connect_swapped(G_OBJECT(object->subWidget), "cursor-changed", G_CALLBACK(ListBox_change), (gpointer)this); g_signal_connect_swapped(G_OBJECT(object->subWidget), "row-activated", G_CALLBACK(ListBox_activate), (gpointer)this); if(parent.window->defaultFont) setFont(*parent.window->defaultFont); gtk_fixed_put(GTK_FIXED(parent.object->formContainer), object->widget, x, y); gtk_widget_show(object->subWidget); gtk_widget_show(object->widget); }
/** * Create the model containing CSV file preview. * * \param tree_preview GtkTreeView to associate model to. * \param contents Contents to place into model * * */ GtkTreeModel * csv_import_create_model ( GtkTreeView * tree_preview, gchar * contents, gchar * separator ) { GtkWidget * assistant; GtkTreeStore *model; GtkTreeViewColumn * col; GtkCellRenderer * cell; GType *types; gint size, i; GList *list; size = csv_import_count_columns ( contents, separator ); if ( ! size || ! contents) return NULL; csv_fields_config = csv_import_update_fields_config ( contents, size, separator ); assistant = g_object_get_data ( G_OBJECT(tree_preview), "assistant" ); /* Remove previous columns if any. */ list = gtk_tree_view_get_columns ( GTK_TREE_VIEW ( tree_preview ) ); while ( list ) { gtk_tree_view_remove_column ( tree_preview, list -> data ); list = list -> next; } types = (GType *) g_malloc0 ( ( size + 2 ) * sizeof ( GType * ) ); types[0] = G_TYPE_BOOLEAN; cell = gtk_cell_renderer_toggle_new (); col = gtk_tree_view_column_new_with_attributes ( _("Skip"), cell, "active", 0, NULL); gtk_tree_view_append_column ( tree_preview, col ); g_object_set_data ( G_OBJECT ( col ), "assistant", assistant ); g_signal_connect ( cell, "toggled", G_CALLBACK ( skip_line_toggled ), tree_preview ); for ( i = 0 ; i < size ; i ++ ) { GtkWidget *label; gchar *name; types[i+1] = G_TYPE_STRING; cell = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes ( NULL, cell, "text", i + 1, "strikethrough", 0, NULL); if ( csv_fields_config[i] > 0 ) { name = g_strconcat ( "<b><u>", _( csv_fields [ csv_fields_config[i] ] . name ), "</u></b>", NULL ); } else { name = my_strdup (_( csv_fields [ csv_fields_config[i] ] . name )); } label = gtk_label_new ( NULL ); gtk_label_set_markup ( GTK_LABEL(label), name ); gtk_widget_show ( label ); g_free ( name ); gtk_tree_view_column_set_widget ( col, label ); gtk_tree_view_append_column ( tree_preview, col ); gtk_tree_view_column_set_clickable ( col, TRUE ); g_object_set_data ( G_OBJECT ( col ), "column", col ); g_object_set_data ( G_OBJECT ( col ), "assistant", assistant ); g_signal_connect ( G_OBJECT ( col ), "clicked", G_CALLBACK ( csv_import_header_on_click ), GINT_TO_POINTER ( i + 1 ) ); } model = gtk_tree_store_newv ( size + 1, types ); return (GtkTreeModel *) model; }
GtkWidget *gui_cardview_create_window(GtkAccelGroup *accel_group) { GtkCellRenderer *renderer; GtkWidget *scrolled_window; GtkTreeViewColumn *column; GtkWidget *base_container; GtkWidget *toolbar; GtkWidget *colheader; GtkWidget *colitem; /* Create base window container */ base_container = gtk_box_new(GTK_ORIENTATION_VERTICAL,0); /* Create the toolbar */ TB_CARD_VIEW[0].callback_data = create_analyzer_menu(accel_group); toolbar = gui_toolbar_new(TB_CARD_VIEW); gtk_box_pack_start (GTK_BOX (base_container), toolbar, FALSE, FALSE, 0); /* Create a new scrolled window, with scrollbars only if needed */ scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_box_pack_end (GTK_BOX (base_container), scrolled_window, TRUE, TRUE, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); CARDVIEW = gtk_tree_view_new (); g_signal_connect(CARDVIEW, "button-press-event", (GCallback) menu_cardview_button_press_event, NULL); g_signal_connect(CARDVIEW, "key-press-event", (GCallback) menu_cardview_key_press_event, NULL); gtk_container_add (GTK_CONTAINER (scrolled_window), CARDVIEW); /* --- Column #0 --- */ column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column,"Items"); gtk_tree_view_column_set_resizable(column,TRUE); 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, internal_cell_renderer_icon_cb, NULL, NULL); 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, internal_cell_renderer_markup_cb, NULL, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(CARDVIEW), column); /* --- Column #1 --- */ column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column,"Size"); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_set_cell_data_func(column, renderer, internal_cell_renderer_size_cb, NULL, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(CARDVIEW), column); g_object_set(renderer, "foreground", "blue", NULL); /* --- Column #2 --- */ renderer = custom_cell_renderer_flexi_new(TRUE); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (CARDVIEW), -1, NULL, renderer, "raw-value", CC_VAL, NULL); column = gtk_tree_view_get_column(GTK_TREE_VIEW (CARDVIEW),2); gtk_tree_view_column_set_resizable(column,TRUE); gtk_tree_view_column_set_visible (column,FALSE); gtk_tree_view_column_set_clickable(column,TRUE); g_signal_connect(column,"clicked",(GCallback)menu_cardview_column_activated,NULL); colheader = gtk_box_new(GTK_ORIENTATION_HORIZONTAL,10); gtk_box_pack_start (GTK_BOX (colheader), gtk_label_new("Raw value"), FALSE, FALSE, 0); if ((colitem = gtk_image_new_from_icon_name("gtk-convert",GTK_ICON_SIZE_MENU))) { gtk_box_pack_start (GTK_BOX (colheader), colitem, FALSE, FALSE, 0); } gtk_widget_show_all(colheader); gtk_widget_set_tooltip_text(colheader,"Click to switch to 'interpreted' data."); gtk_tree_view_column_set_widget(column,colheader); /* --- Column #3 --- */ renderer = custom_cell_renderer_flexi_new(FALSE); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (CARDVIEW), -1, NULL, renderer, "raw-value", CC_VAL, "alt_text", CC_ALT, "mime-type", CC_MIME_TYPE, NULL); column = gtk_tree_view_get_column(GTK_TREE_VIEW (CARDVIEW),3); gtk_tree_view_column_set_resizable(column,TRUE); gtk_tree_view_column_set_clickable(column,TRUE); g_signal_connect(column,"clicked",(GCallback)menu_cardview_column_activated,NULL); colheader = gtk_box_new(GTK_ORIENTATION_HORIZONTAL,10); gtk_box_pack_start (GTK_BOX (colheader), gtk_label_new("Interpreted value"), FALSE, FALSE, 0); if ((colitem = gtk_image_new_from_icon_name("gtk-convert",GTK_ICON_SIZE_MENU))) { gtk_box_pack_start (GTK_BOX (colheader), colitem, FALSE, FALSE, 0); } gtk_widget_show_all(colheader); gtk_widget_set_tooltip_text(colheader,"Click to switch to 'raw' data."); gtk_tree_view_column_set_widget(column,colheader); /* add the dat model */ /* CARD_DATA_STORE = */ dyntree_model_new(); gtk_tree_view_set_model(GTK_TREE_VIEW(CARDVIEW),GTK_TREE_MODEL(CARD_DATA_STORE)); g_object_unref(CARD_DATA_STORE); return base_container; }
static void rb_audiocd_source_constructed (GObject *object) { RBAudioCdSourcePrivate *priv; RBAudioCdSource *source; RBEntryView *entry_view; GtkCellRenderer *renderer; GtkTreeViewColumn *extract; GtkWidget *widget; GtkAction *action; RhythmDB *db; RBPlugin *plugin; RBShell *shell; char *ui_file; int toggle_width; RB_CHAIN_GOBJECT_METHOD (rb_audiocd_source_parent_class, constructed, object); source = RB_AUDIOCD_SOURCE (object); priv = AUDIOCD_SOURCE_GET_PRIVATE (source); g_object_set (G_OBJECT (source), "name", "Unknown Audio", NULL); g_object_get (source, "shell", &shell, NULL); priv->action_group = _rb_source_register_action_group (RB_SOURCE (source), "AudioCdActions", NULL, 0, NULL); _rb_action_group_add_source_actions (priv->action_group, G_OBJECT (shell), rb_audiocd_source_actions, G_N_ELEMENTS (rb_audiocd_source_actions)); g_object_unref (shell); action = gtk_action_group_get_action (priv->action_group, "AudioCdCopyTracks"); /* Translators: this is the toolbar button label for Copy to Library action. */ g_object_set (action, "short-label", _("Extract"), NULL); #if !defined(HAVE_SJ_METADATA_GETTER) action = gtk_action_group_get_action (priv->action_group, "AudioCdSourceReloadMetadata"); g_object_set (action, "visible", FALSE, NULL); #endif /* we want audio cds to sort by track# by default */ entry_view = rb_source_get_entry_view (RB_SOURCE (source)); rb_entry_view_set_sorting_order (entry_view, "Track", GTK_SORT_ASCENDING); /* enable in-place editing for titles, artists, and genres */ rb_entry_view_set_column_editable (entry_view, RB_ENTRY_VIEW_COL_TITLE, TRUE); rb_entry_view_set_column_editable (entry_view, RB_ENTRY_VIEW_COL_ARTIST, TRUE); rb_entry_view_set_column_editable (entry_view, RB_ENTRY_VIEW_COL_GENRE, TRUE); /* create the 'extract' column */ renderer = gtk_cell_renderer_toggle_new (); extract = gtk_tree_view_column_new (); gtk_tree_view_column_pack_start (extract, renderer, FALSE); gtk_tree_view_column_set_cell_data_func (extract, renderer, (GtkTreeCellDataFunc) extract_cell_data_func, source, NULL); gtk_tree_view_column_set_clickable (extract, TRUE); widget = gtk_check_button_new (); g_object_set (widget, "active", TRUE, NULL); gtk_widget_show_all (widget); g_signal_connect_object (extract, "clicked", G_CALLBACK (extract_column_clicked_cb), source, 0); gtk_tree_view_column_set_widget (extract, widget); g_signal_connect_object (renderer, "toggled", G_CALLBACK (extract_toggled_cb), source, 0); /* set column width */ gtk_cell_renderer_get_size (renderer, GTK_WIDGET (entry_view), NULL, NULL, NULL, &toggle_width, NULL); gtk_tree_view_column_set_sizing (extract, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_fixed_width (extract, toggle_width + 5); rb_entry_view_insert_column_custom (entry_view, extract, "", "Extract", NULL, NULL, NULL, 1); gtk_widget_set_tooltip_text (gtk_tree_view_column_get_widget (extract), _("Select tracks to be extracted")); /* hide the 'album' column */ gtk_tree_view_column_set_visible (rb_entry_view_get_column (entry_view, RB_ENTRY_VIEW_COL_ALBUM), FALSE); /* handle extra metadata requests for album artist and album artist sortname */ db = get_db_for_source (source); g_signal_connect_object (G_OBJECT (db), "entry-extra-metadata-request::" RHYTHMDB_PROP_ALBUM_ARTIST, G_CALLBACK (album_artist_metadata_request_cb), source, 0); g_signal_connect_object (G_OBJECT (db), "entry-extra-metadata-request::" RHYTHMDB_PROP_ALBUM_ARTIST_SORTNAME, G_CALLBACK (album_artist_sortname_metadata_request_cb), source, 0); g_signal_connect_object (G_OBJECT (db), "entry-extra-metadata-gather", G_CALLBACK (metadata_gather_cb), source, 0); g_object_unref (db); /* set up the album info widgets */ g_object_get (source, "plugin", &plugin, NULL); ui_file = rb_plugin_find_file (plugin, "album-info.ui"); g_object_unref (plugin); if (ui_file == NULL) { g_warning ("couldn't find album-info.ui"); } else { RBAudioCdSourcePrivate *priv; GtkWidget *table; GtkBuilder *builder; #if defined(HAVE_SJ_METADATA_GETTER) && GTK_CHECK_VERSION(2,17,6) GtkWidget *box; char *message; #endif priv = AUDIOCD_SOURCE_GET_PRIVATE (source); builder = rb_builder_load (ui_file, NULL); g_free (ui_file); table = GTK_WIDGET (gtk_builder_get_object (builder, "album_info")); g_assert (table != NULL); #if defined(HAVE_SJ_METADATA_GETTER) && GTK_CHECK_VERSION(2,17,6) /* Info bar for non-Musicbrainz data */ priv->info_bar = gtk_info_bar_new_with_buttons (_("S_ubmit Album"), GTK_RESPONSE_OK, _("Hide"), GTK_RESPONSE_CANCEL, NULL); message = g_strdup_printf ("<b>%s</b>\n%s", _("Could not find this album on MusicBrainz."), _("You can improve the MusicBrainz database by adding this album.")); priv->info_bar_label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (priv->info_bar_label), message); gtk_label_set_justify (GTK_LABEL (priv->info_bar_label), GTK_JUSTIFY_LEFT); g_free (message); box = gtk_info_bar_get_content_area (GTK_INFO_BAR (priv->info_bar)); gtk_container_add (GTK_CONTAINER (box), priv->info_bar_label); gtk_widget_show_all (box); gtk_widget_set_no_show_all (priv->info_bar, TRUE); g_signal_connect (G_OBJECT (priv->info_bar), "response", G_CALLBACK (info_bar_response_cb), source); gtk_table_attach_defaults (GTK_TABLE (table), priv->info_bar, 0, 2, 0, 1); #endif priv->artist_entry = GTK_WIDGET (gtk_builder_get_object (builder, "artist_entry")); priv->artist_sort_entry = GTK_WIDGET (gtk_builder_get_object (builder, "artist_sort_entry")); priv->album_entry = GTK_WIDGET (gtk_builder_get_object (builder, "album_entry")); priv->year_entry = GTK_WIDGET (gtk_builder_get_object (builder, "year_entry")); priv->genre_entry = GTK_WIDGET (gtk_builder_get_object (builder, "genre_entry")); priv->disc_number_entry = GTK_WIDGET (gtk_builder_get_object (builder, "disc_number_entry")); g_signal_connect_object (priv->album_entry, "focus-out-event", G_CALLBACK (update_album_cb), source, 0); g_signal_connect_object (priv->genre_entry, "focus-out-event", G_CALLBACK (update_genre_cb), source, 0); g_signal_connect_object (priv->year_entry, "focus-out-event", G_CALLBACK (update_year_cb), source, 0); g_signal_connect_object (priv->disc_number_entry, "focus-out-event", G_CALLBACK (update_disc_number_cb), source, 0); gtk_box_pack_start (GTK_BOX (priv->box), table, FALSE, FALSE, 0); gtk_box_reorder_child (GTK_BOX (priv->box), table, 0); g_object_unref (builder); } g_object_ref (G_OBJECT (source)); g_thread_create ((GThreadFunc)rb_audiocd_load_songs, source, FALSE, NULL); }
/** * format_page_update_preview * @pagedata: mother struct * * Will simply utilize the preview rendering functions to update * the preview * * returns : nothing **/ static void format_page_update_preview (StfDialogData *pagedata) { RenderData_t *renderdata = pagedata->format.renderdata; unsigned int ui; int i; int col_import_array_len_old, old_part; GStringChunk *lines_chunk; char *msg = NULL; stf_preview_colformats_clear (renderdata); for (ui = 0; ui < pagedata->format.formats->len; ui++) { GOFormat *sf = g_ptr_array_index (pagedata->format.formats, ui); stf_preview_colformats_add (renderdata, sf); } lines_chunk = g_string_chunk_new (100 * 1024); stf_preview_set_lines (renderdata, lines_chunk, stf_parse_general (pagedata->parseoptions, lines_chunk, pagedata->cur, pagedata->cur_end)); col_import_array_len_old = pagedata->format.col_import_array_len; pagedata->format.col_import_array_len = renderdata->colcount; pagedata->format.col_autofit_array = g_renew(gboolean, pagedata->format.col_autofit_array, pagedata->format.col_import_array_len); pagedata->format.col_import_array = g_renew(gboolean, pagedata->format.col_import_array, pagedata->format.col_import_array_len); old_part = (col_import_array_len_old < pagedata->format.col_import_array_len) ? col_import_array_len_old : pagedata->format.col_import_array_len; pagedata->format.col_import_count = 0; for (i = 0; i < old_part; i++) if (pagedata->format.col_import_array[i]) pagedata->format.col_import_count++; for (i = old_part; i < pagedata->format.col_import_array_len; i++) { if (pagedata->format.col_import_count < GNM_MAX_COLS) { pagedata->format.col_import_array[i] = TRUE; pagedata->format.col_import_count++; } else { pagedata->format.col_import_array[i] = FALSE; } pagedata->format.col_autofit_array[i] = TRUE; } format_page_update_column_selection (pagedata); if (old_part < renderdata->colcount) msg = g_strdup_printf (_("A maximum of %d columns can be imported."), GNM_MAX_COLS); for (i = old_part; i < renderdata->colcount; i++) { GtkTreeViewColumn *column = stf_preview_get_column (renderdata, i); GtkWidget *button = gtk_tree_view_column_get_button (column); if (NULL == g_object_get_data (G_OBJECT (column), "checkbox")) { GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5); GtkWidget *check, *check_autofit = gtk_check_button_new_with_label (_("Auto fit")); char * label_text = g_strdup_printf (pagedata->format.col_header, i+1); GOFormat const *gf = go_format_general (); GtkWidget *format_label = gtk_button_new_with_label (go_format_sel_format_classification (gf)); GtkWidget *format_icon = gtk_image_new_from_stock (GTK_STOCK_INFO, GTK_ICON_SIZE_BUTTON); check = gtk_check_button_new_with_label (label_text); g_free (label_text); gtk_button_set_image (GTK_BUTTON (format_label), format_icon); g_object_set (G_OBJECT (stf_preview_get_cell_renderer (pagedata->format.renderdata, i)), "strikethrough", !pagedata->format.col_import_array[i], NULL); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(check), pagedata-> format.col_import_array[i]); label_text = g_strdup_printf (_("If this checkbox is selected, " "column %i will be imported into " "Gnumeric."), i+1); gtk_widget_set_tooltip_text (check, label_text); gtk_widget_set_tooltip_text (check_autofit, _("If this checkbox is selected, " "the width of the column will be adjusted " "to the longest entry.")); g_free (label_text); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(check_autofit), pagedata-> format.col_autofit_array[i]); g_object_set_data (G_OBJECT (check), "pagedata", pagedata); g_object_set_data (G_OBJECT (check_autofit), "pagedata", pagedata); g_object_set_data (G_OBJECT (format_label), "pagedata", pagedata); gtk_box_pack_start (GTK_BOX(vbox), check, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(vbox), format_label, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX(vbox), check_autofit, TRUE, TRUE, 0); gtk_widget_show_all (vbox); gtk_tree_view_column_set_widget (column, vbox); g_object_set_data (G_OBJECT (column), "pagedata", pagedata); g_object_set_data (G_OBJECT (column), "checkbox", check); g_object_set_data (G_OBJECT (column), "checkbox-autofit", check_autofit); g_object_set_data (G_OBJECT (column), "formatlabel", format_label); g_object_set_data (G_OBJECT (button), "pagedata", pagedata); g_object_set_data (G_OBJECT (button), "checkbox", check); g_object_set_data (G_OBJECT (button), "formatlabel", format_label); g_object_set (G_OBJECT (column), "clickable", TRUE, NULL); g_signal_connect (G_OBJECT (check), "toggled", G_CALLBACK (cb_col_check_clicked), GINT_TO_POINTER (i)); g_signal_connect (G_OBJECT (check_autofit), "toggled", G_CALLBACK (cb_col_check_autofit_clicked), GINT_TO_POINTER (i)); g_signal_connect (G_OBJECT (format_label), "clicked", G_CALLBACK (cb_format_clicked), GINT_TO_POINTER (i)); g_signal_connect (G_OBJECT (button), "event", G_CALLBACK (cb_col_event), GINT_TO_POINTER (i)); } } g_free (msg); }
int main (int argc, char *argv[]) { GtkWidget *window1; GtkWidget *vbox1; GtkWidget *scrolledwindow1; GtkWidget *clist1; GtkWidget *button; char **text; char str[256]; int i, j; gtk_set_locale (); gtk_init (&argc, &argv); gtk_panda_init (&argc, &argv); window1 = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_widget_show (window1); vbox1 = gtk_vbox_new (FALSE, 0); #if 0 gtk_widget_ref (vbox1); gtk_object_set_data_full (GTK_OBJECT (window1), "vbox1", vbox1, (GtkDestroyNotify) gtk_widget_unref); #endif gtk_widget_show (vbox1); gtk_container_add (GTK_CONTAINER (window1), vbox1); scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL); gtk_widget_ref (scrolledwindow1); gtk_object_set_data_full ( GTK_OBJECT (window1), "scrolledwindow1", scrolledwindow1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (scrolledwindow1); gtk_box_pack_start (GTK_BOX (vbox1), scrolledwindow1, TRUE, TRUE, 0); #define COLUMNS 3 GtkTreeViewColumn *column; GtkWidget *label1, *label2; label1 = gtk_label_new("label1"); label2 = gtk_label_new("label2"); gtk_widget_show(label1); gtk_widget_show(label2); clist1 = gtk_panda_clist_new (); gtk_panda_clist_set_columns(GTK_PANDA_CLIST(clist1),10); gtk_panda_clist_set_columns(GTK_PANDA_CLIST(clist1),1); gtk_panda_clist_set_columns(GTK_PANDA_CLIST(clist1),5); gtk_panda_clist_set_columns(GTK_PANDA_CLIST(clist1),COLUMNS); column = gtk_tree_view_get_column(GTK_TREE_VIEW(clist1),0); gtk_tree_view_column_set_widget(column, label1); column = gtk_tree_view_get_column(GTK_TREE_VIEW(clist1),1); gtk_tree_view_column_set_widget(column, label2); gtk_widget_show_all (clist1); gtk_panda_clist_set_column_widths(GTK_PANDA_CLIST(clist1), "50,50,50,50,50,50,50,50"); gtk_container_add (GTK_CONTAINER (scrolledwindow1), clist1); #if 1 gtk_panda_clist_set_selection_mode (GTK_PANDA_CLIST (clist1), GTK_SELECTION_MULTIPLE); #else gtk_panda_clist_set_selection_mode (GTK_PANDA_CLIST (clist1), GTK_SELECTION_SINGLE); #endif g_signal_connect (G_OBJECT(clist1), "select_row", G_CALLBACK(select_row), clist1); g_signal_connect (G_OBJECT(clist1), "unselect_row", G_CALLBACK(unselect_row), clist1); gtk_panda_clist_set_rows(GTK_PANDA_CLIST(clist1),50); text = malloc(sizeof(char *)*COLUMNS); for (i=0; i<50; i++) { for (j=0; j<COLUMNS; j++) { sprintf(str, "cel_%d_%d", i, j); text[j] = strdup(str); } gtk_panda_clist_set_row(GTK_PANDA_CLIST(clist1),i,text); } gtk_panda_clist_set_fgcolor(GTK_PANDA_CLIST(clist1),0,"#FF2222"); gtk_panda_clist_set_fgcolor(GTK_PANDA_CLIST(clist1),1,"#2222FF"); gtk_panda_clist_set_bgcolor(GTK_PANDA_CLIST(clist1),0,"#FFEEEE"); gtk_panda_clist_set_bgcolor(GTK_PANDA_CLIST(clist1),1,"#EEEEFF"); button = gtk_button_new_with_label("toggle sensitive"); gtk_box_pack_start (GTK_BOX (vbox1), button, FALSE, FALSE, 0); gtk_widget_show_all(window1); gtk_main (); return 0; }
static void set_columns_type (GtkTreeView *tree_view, ColumnsType type) { GtkTreeViewColumn *col; GtkCellRenderer *rend; GdkPixbuf *pixbuf; GtkWidget *image; GtkAdjustment *adjustment; current_column_type = type; col = gtk_tree_view_get_column (tree_view, 0); while (col) { gtk_tree_view_remove_column (tree_view, col); col = gtk_tree_view_get_column (tree_view, 0); } gtk_tree_view_set_rules_hint (tree_view, FALSE); switch (type) { case COLUMNS_NONE: break; case COLUMNS_LOTS: /* with lots of columns we need to turn on rules */ gtk_tree_view_set_rules_hint (tree_view, TRUE); rend = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes ("Column 1", rend, "text", 1, NULL); setup_column (col); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col); col = gtk_tree_view_column_new(); gtk_tree_view_column_set_title (col, "Column 2"); rend = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (col, rend, FALSE); gtk_tree_view_column_add_attribute (col, rend, "pixbuf", 2); rend = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (col, rend, TRUE); gtk_tree_view_column_add_attribute (col, rend, "text", 0); setup_column (col); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col); gtk_tree_view_set_expander_column (tree_view, col); rend = gtk_cell_renderer_toggle_new (); g_signal_connect (rend, "toggled", G_CALLBACK (toggled_callback), tree_view); col = gtk_tree_view_column_new_with_attributes ("Column 3", rend, "active", BOOL_COLUMN, NULL); setup_column (col); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col); pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **)book_closed_xpm); image = gtk_image_new_from_pixbuf (pixbuf); g_object_unref (pixbuf); gtk_widget_show (image); gtk_tree_view_column_set_widget (col, image); rend = gtk_cell_renderer_toggle_new (); /* you could also set this per-row by tying it to a column * in the model of course. */ g_object_set (rend, "radio", TRUE, NULL); g_signal_connect (rend, "toggled", G_CALLBACK (toggled_callback), tree_view); col = gtk_tree_view_column_new_with_attributes ("Column 4", rend, "active", BOOL_COLUMN, NULL); setup_column (col); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col); rend = gtk_cell_renderer_spin_new (); adjustment = gtk_adjustment_new (0, 0, 10000, 100, 100, 100); g_object_set (rend, "editable", TRUE, NULL); g_object_set (rend, "adjustment", adjustment, NULL); g_signal_connect (rend, "edited", G_CALLBACK (edited_callback), tree_view); col = gtk_tree_view_column_new_with_attributes ("Column 5", rend, "text", 4, NULL); setup_column (col); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col); #if 0 rend = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes ("Column 6", rend, "text", 4, NULL); setup_column (col); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col); rend = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes ("Column 7", rend, "text", 5, NULL); setup_column (col); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col); rend = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes ("Column 8", rend, "text", 6, NULL); setup_column (col); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col); rend = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes ("Column 9", rend, "text", 7, NULL); setup_column (col); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col); rend = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes ("Column 10", rend, "text", 8, NULL); setup_column (col); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col); #endif /* FALL THRU */ case COLUMNS_ONE: rend = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes ("Column 0", rend, "text", 0, NULL); setup_column (col); gtk_tree_view_insert_column (GTK_TREE_VIEW (tree_view), col, 0); default: break; } }
static void create_window (MduShell *shell) { GtkWidget *vbox; GtkWidget *vbox1; GtkWidget *vbox2; GtkWidget *menubar; GtkAccelGroup *accel_group; GtkWidget *hpane; GtkWidget *tree_view_scrolled_window; GtkTreeSelection *select; GtkWidget *label; GtkTreeViewColumn *column; GError *error; error = NULL; if (!add_pool (shell, NULL, NULL, &error)) { g_printerr ("Error creating pool: `%s'\n", error->message); g_error_free (error); g_critical ("Bailing out"); } shell->priv->app_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_resizable (GTK_WINDOW (shell->priv->app_window), TRUE); gtk_window_set_default_size (GTK_WINDOW (shell->priv->app_window), 800, 600); gtk_window_set_title (GTK_WINDOW (shell->priv->app_window), _("Disk Utility")); vbox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (shell->priv->app_window), vbox); shell->priv->ui_manager = create_ui_manager (shell); accel_group = gtk_ui_manager_get_accel_group (shell->priv->ui_manager); gtk_window_add_accel_group (GTK_WINDOW (shell->priv->app_window), accel_group); menubar = gtk_ui_manager_get_widget (shell->priv->ui_manager, "/menubar"); gtk_box_pack_start (GTK_BOX (vbox), menubar, FALSE, FALSE, 0); /* tree view */ tree_view_scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (tree_view_scrolled_window), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (tree_view_scrolled_window), GTK_SHADOW_IN); shell->priv->model = mdu_pool_tree_model_new (shell->priv->pools, NULL, MDU_POOL_TREE_MODEL_FLAGS_NO_VOLUMES); shell->priv->tree_view = mdu_pool_tree_view_new (shell->priv->model, MDU_POOL_TREE_VIEW_FLAGS_NONE); g_object_unref (shell->priv->model); gtk_container_add (GTK_CONTAINER (tree_view_scrolled_window), shell->priv->tree_view); /* --- */ vbox1 = gtk_vbox_new (FALSE, 0); /* --- */ vbox2 = gtk_vbox_new (FALSE, 0); //gtk_container_set_border_width (GTK_CONTAINER (vbox2), 12); gtk_box_pack_start (GTK_BOX (vbox1), vbox2, TRUE, TRUE, 0); /* --- */ shell->priv->sections_vbox = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (shell->priv->sections_vbox), 6); gtk_box_pack_start (GTK_BOX (vbox2), shell->priv->sections_vbox, TRUE, TRUE, 0); /* setup and add horizontal pane */ hpane = gtk_hpaned_new (); label = gtk_label_new (NULL); gtk_label_set_markup_with_mnemonic (GTK_LABEL (label), _("_Storage Devices")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_label_set_mnemonic_widget (GTK_LABEL (label), shell->priv->tree_view); column = gtk_tree_view_get_column (GTK_TREE_VIEW (shell->priv->tree_view), 0); gtk_tree_view_column_set_widget (column, label); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (shell->priv->tree_view), TRUE); gtk_widget_show (label); gtk_paned_add1 (GTK_PANED (hpane), tree_view_scrolled_window); gtk_paned_add2 (GTK_PANED (hpane), vbox1); gtk_widget_set_size_request (shell->priv->tree_view, 260, -1), //gtk_paned_set_position (GTK_PANED (hpane), 260); gtk_box_pack_start (GTK_BOX (vbox), hpane, TRUE, TRUE, 0); select = gtk_tree_view_get_selection (GTK_TREE_VIEW (shell->priv->tree_view)); gtk_tree_selection_set_mode (select, GTK_SELECTION_SINGLE); g_signal_connect (select, "changed", (GCallback) device_tree_changed, shell); /* when starting up, set focus on tree view */ gtk_widget_grab_focus (shell->priv->tree_view); g_signal_connect (shell->priv->app_window, "delete-event", gtk_main_quit, NULL); gtk_widget_show_all (vbox); mdu_pool_tree_view_select_first_presentable (MDU_POOL_TREE_VIEW (shell->priv->tree_view)); }
void pListView::constructor() { gtkWidget = gtk_scrolled_window_new(0, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(gtkWidget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(gtkWidget), GTK_SHADOW_ETCHED_IN); lstring headerText = listView.state.headerText; if(headerText.size() == 0) headerText.append(""); //ListView must have at least one column column.reset(); vector<GType> gtype; for(auto& text : headerText) { GtkColumn cell; cell.label = gtk_label_new(text); cell.column = gtk_tree_view_column_new(); gtk_tree_view_column_set_resizable(cell.column, true); gtk_tree_view_column_set_title(cell.column, ""); if(column.size() == 0) { //first column checkbutton cell.checkbutton = gtk_cell_renderer_toggle_new(); gtk_tree_view_column_pack_start(cell.column, cell.checkbutton, false); gtk_tree_view_column_set_attributes(cell.column, cell.checkbutton, "active", gtype.size(), nullptr); gtype.append(G_TYPE_BOOLEAN); g_signal_connect(cell.checkbutton, "toggled", G_CALLBACK(ListView_toggle), (gpointer)&listView); } cell.icon = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(cell.column, cell.icon, false); gtk_tree_view_column_set_attributes(cell.column, cell.icon, "pixbuf", gtype.size(), nullptr); gtype.append(GDK_TYPE_PIXBUF); cell.text = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(cell.column, cell.text, false); gtk_tree_view_column_set_attributes(cell.column, cell.text, "text", gtype.size(), nullptr); gtype.append(G_TYPE_STRING); column.append(cell); } store = gtk_list_store_newv(gtype.size(), gtype.data()); subWidget = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); gtk_container_add(GTK_CONTAINER(gtkWidget), subWidget); g_object_unref(G_OBJECT(store)); for(auto& cell : column) { gtk_tree_view_column_set_widget(GTK_TREE_VIEW_COLUMN(cell.column), cell.label); gtk_tree_view_append_column(GTK_TREE_VIEW(subWidget), cell.column); gtk_widget_show(cell.label); } gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(subWidget), headerText.size() >= 2); //two or more columns + checkbutton column gtk_tree_view_set_search_column(GTK_TREE_VIEW(subWidget), 2); g_signal_connect(G_OBJECT(subWidget), "cursor-changed", G_CALLBACK(ListView_change), (gpointer)&listView); g_signal_connect(G_OBJECT(subWidget), "row-activated", G_CALLBACK(ListView_activate), (gpointer)&listView); gtk_widget_show(subWidget); setHeaderVisible(listView.state.headerVisible); setCheckable(listView.state.checkable); for(auto& text : listView.state.text) append(text); for(unsigned n = 0; n < listView.state.checked.size(); n++) setChecked(n, listView.state.checked[n]); if(listView.state.selected) setSelection(listView.state.selection); autoSizeColumns(); }
static void populate_dialog (PpPPDSelectionDialog *dialog) { GtkTreeViewColumn *column; GtkCellRenderer *renderer; GtkTreeView *manufacturers_treeview; GtkTreeView *models_treeview; GtkWidget *widget; GtkWidget *header; manufacturers_treeview = (GtkTreeView*) gtk_builder_get_object (dialog->builder, "ppd-selection-manufacturers-treeview"); renderer = gtk_cell_renderer_text_new (); gtk_cell_renderer_set_padding (renderer, 10, 0); /* Translators: Name of column showing printer manufacturers */ column = gtk_tree_view_column_new_with_attributes (_("Manufacturer"), renderer, "text", PPD_MANUFACTURERS_DISPLAY_NAMES_COLUMN, NULL); gtk_tree_view_column_set_expand (column, TRUE); header = gtk_label_new (gtk_tree_view_column_get_title (column)); gtk_widget_set_margin_start (header, 10); gtk_tree_view_column_set_widget (column, header); gtk_widget_show (header); gtk_tree_view_append_column (manufacturers_treeview, column); models_treeview = (GtkTreeView*) gtk_builder_get_object (dialog->builder, "ppd-selection-models-treeview"); renderer = gtk_cell_renderer_text_new (); gtk_cell_renderer_set_padding (renderer, 10, 0); /* Translators: Name of column showing printer drivers */ column = gtk_tree_view_column_new_with_attributes (_("Driver"), renderer, "text", PPD_DISPLAY_NAMES_COLUMN, NULL); gtk_tree_view_column_set_expand (column, TRUE); header = gtk_label_new (gtk_tree_view_column_get_title (column)); gtk_widget_set_margin_start (header, 10); gtk_tree_view_column_set_widget (column, header); gtk_widget_show (header); gtk_tree_view_append_column (models_treeview, column); g_signal_connect (gtk_tree_view_get_selection (models_treeview), "changed", G_CALLBACK (model_selection_changed_cb), dialog); g_signal_connect (gtk_tree_view_get_selection (manufacturers_treeview), "changed", G_CALLBACK (manufacturer_selection_changed_cb), dialog); gtk_widget_show_all (dialog->dialog); if (!dialog->list) { widget = (GtkWidget*) gtk_builder_get_object (dialog->builder, "ppd-spinner"); gtk_widget_show (widget); gtk_spinner_start (GTK_SPINNER (widget)); widget = (GtkWidget*) gtk_builder_get_object (dialog->builder, "progress-label"); gtk_widget_show (widget); } else { fill_ppds_list (dialog); } }
static void gwy_graph_data_update_ncurves(GwyGraphData *graph_data) { GwyGraphDataCurve *curve; GtkTreeView *treeview; GtkTreeViewColumn *column; GtkWidget *table, *label; guint i, ncolumns, ncurves = 0; ncolumns = graph_data->curves->len; gwy_debug("old ncurves: %d", ncolumns); /* Reconnect all signals just to be sure. * GraphModel is a bit cagey when changes in its curves are regarded */ for (i = 0; i < graph_data->curves->len; i++) { curve = &g_array_index(graph_data->curves, GwyGraphDataCurve, i); gwy_signal_handler_disconnect(curve->gcmodel, curve->changed_id); gwy_object_unref(curve->gcmodel); } g_array_set_size(graph_data->curves, 0); if (graph_data->graph_model) { GwyGraphDataCurve newcurve; ncurves = gwy_graph_model_get_n_curves(graph_data->graph_model); for (i = 0; i < ncurves; i++) { newcurve.gcmodel = gwy_graph_model_get_curve(graph_data->graph_model, i); g_object_ref(newcurve.gcmodel); newcurve.changed_id = g_signal_connect_swapped (newcurve.gcmodel, "data-changed", G_CALLBACK(gwy_graph_data_update_nrows), graph_data); g_array_append_val(graph_data->curves, newcurve); } } gwy_debug("ncurves: %d", ncurves); /* Update the number of columns. */ treeview = GTK_TREE_VIEW(graph_data); while (ncolumns > ncurves) { ncolumns--; gwy_debug("removing column %d", ncolumns); column = gtk_tree_view_get_column(treeview, ncolumns); gtk_tree_view_remove_column(treeview, column); } while (ncolumns < ncurves) { GtkRequisition req; GtkWidget *align; gwy_debug("adding column %d", ncolumns); column = gtk_tree_view_column_new(); g_object_set_qdata(G_OBJECT(column), quark_id, GINT_TO_POINTER(ncolumns)); gwy_graph_data_pack_renderer(graph_data, column, 0); gwy_graph_data_pack_renderer(graph_data, column, 1); table = gtk_table_new(2, 2, TRUE); label = gtk_label_new(NULL); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 2, 0, 1); label = gtk_label_new(NULL); gtk_label_set_width_chars(GTK_LABEL(label), COL_WIDTH); gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 1, 2); label = gtk_label_new(NULL); gtk_label_set_width_chars(GTK_LABEL(label), COL_WIDTH); gtk_table_attach_defaults(GTK_TABLE(table), label, 1, 2, 1, 2); gtk_widget_show_all(table); gtk_tree_view_column_set_widget(column, table); gtk_widget_size_request(table, &req); g_object_set(column, "sizing", GTK_TREE_VIEW_COLUMN_FIXED, "fixed-width", req.width, NULL); gtk_tree_view_append_column(treeview, column); align = gtk_widget_get_parent(table); /* XXX: The alignment is Gtk+'s private widget. */ if (align && GTK_IS_ALIGNMENT(align)) { g_signal_connect(align, "notify::xscale", G_CALLBACK(fix_xscale), NULL); fix_xscale(align); } ncolumns++; } if (graph_data->graph_model) gwy_graph_data_update_headers(graph_data); if (graph_data->store) gwy_graph_data_update_nrows(graph_data); }