/**
* 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);
}
