static void
add_view_columns (GtkTreeView *treeview)
{
gint col_offset;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeModel *model = gtk_tree_view_get_model (treeview);
/* Property Name */
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "xalign", 0.0, NULL);
col_offset =
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
-1, _("Property"),
renderer,
"text",
COL_XMP_NAME,
"weight",
COL_XMP_WEIGHT,
"weight-set",
COL_XMP_WEIGHT_SET,
NULL);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), col_offset - 1);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
/* Icon */
renderer = gtk_cell_renderer_pixbuf_new ();
col_offset =
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
-1, "",
renderer,
"pixbuf",
COL_XMP_EDIT_ICON,
"visible",
COL_XMP_VISIBLE,
NULL);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), col_offset - 1);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
/* Value */
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "xalign", 0.0, NULL);
g_signal_connect (renderer, "edited",
G_CALLBACK (tree_value_edited),
model);
col_offset =
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
-1, C_("metadata-value", "Value"),
renderer,
"text",
COL_XMP_VALUE,
"editable",
COL_XMP_EDITABLE,
"visible",
COL_XMP_VISIBLE,
NULL);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), col_offset - 1);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
}
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++;
}
}
static void create_treeview(GtkWidget *treeview, GtkWidget *treeview_sw, char *col_names[],
int col_names_count)
{
GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
gtk_tree_selection_set_mode (sel, GTK_SELECTION_NONE);
/* fixed with and height improve performance */
gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(treeview), TRUE);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview), TRUE);
gtk_tree_view_set_reorderable(GTK_TREE_VIEW (treeview), FALSE);
gtk_container_add (GTK_CONTAINER (treeview_sw), treeview);
/* add columns to the tree view */
GtkCellRenderer *renderer;
GtkTreeViewColumn *col;
/* hack! minimal screen width - scroll bar width - separators and borders */
int width = 430 / col_names_count;
int i;
for (i=0; i<col_names_count; i++) {
renderer = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new_with_attributes (col_names[i], renderer, "text", i, NULL);
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_fixed_width(col, width);
gtk_tree_view_column_set_clickable(col, FALSE);
gtk_tree_view_column_set_cell_data_func (col, renderer, svinfo_treeview_func_text, NULL, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), col);
}
}
static GtkTreeViewColumn *
create_user_view_column(int id,const char *title, GCallback callback){
GtkTreeViewColumn *col;
GtkCellRenderer *renderer;
if ( (id<0) || (id>=MAX_VIEW_ID) || (!title) )
return NULL;
/* --- Column #1 --- */
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, title);
renderer = gtk_cell_renderer_text_new();
/* pack cell renderer into tree view column */
gtk_tree_view_column_pack_start(col, renderer, TRUE);
/* connect 'text' property of the cell renderer to
* model column that contains the first name */
gtk_tree_view_column_add_attribute(col, renderer, "text", id);
gtk_tree_view_column_set_resizable (col,TRUE);
gtk_tree_view_column_set_clickable(col,TRUE);
gtk_tree_view_column_set_reorderable(col, TRUE);
g_signal_connect ((gpointer) col, "clicked",
G_CALLBACK (callback),
NULL);
HOOKUP_ID(col,id);
return col;
}
static void
spell_dialog_model_populate_columns (TwituxSpellDialog *dialog)
{
GtkTreeModel *model;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
guint col_offset;
model = gtk_tree_view_get_model (GTK_TREE_VIEW (dialog->treeview_words));
renderer = gtk_cell_renderer_text_new ();
col_offset = gtk_tree_view_insert_column_with_attributes (
GTK_TREE_VIEW (dialog->treeview_words),
-1, _("Word"),
renderer,
"text", COL_SPELL_WORD,
NULL);
g_object_set_data (G_OBJECT (renderer),
"column", GINT_TO_POINTER (COL_SPELL_WORD));
column = gtk_tree_view_get_column (GTK_TREE_VIEW (dialog->treeview_words), col_offset - 1);
gtk_tree_view_column_set_sort_column_id (column, COL_SPELL_WORD);
gtk_tree_view_column_set_resizable (column, FALSE);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
}
static GtkWidget*
rw_preferences_dialog_create_categories_tree (COption *parent)
{
GtkWidget *sw;
GtkTreeModel *model;
GtkWidget *treeview;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
gint col_offset;
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_widget_set_size_request (sw, 160, 240);
model = rw_preferences_dialog_create_categories_tree_model ();
treeview = gtk_tree_view_new_with_model (model);
parent->categories_tree = treeview;
parent->categories_tree_model = model;
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
gtk_tree_selection_set_mode (selection,
GTK_SELECTION_SINGLE);
/* add column for category */
renderer = gtk_cell_renderer_text_new ();
g_object_set (G_OBJECT (renderer), "xalign", 0.0, NULL);
col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
-1, _("Categories"),
renderer, "text",
CATEGORY_COLUMN,
NULL);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), col_offset - 1);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), FALSE);
g_signal_connect (selection, "changed",
G_CALLBACK (rw_preferences_dialog_categories_tree_selection_cb),
parent);
gtk_container_add (GTK_CONTAINER (sw), treeview);
g_signal_connect (G_OBJECT (treeview), "realize",
G_CALLBACK (rw_preferences_dialog_categories_tree_realize),
parent);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE);
return sw;
}
static void
vinagre_bookmarks_tree_init (VinagreBookmarksTree *tree)
{
GtkCellRenderer *cell;
GtkWidget *scroll;
GtkTreeSelection *selection;
GtkTreeStore *model;
GtkTreeViewColumn *main_column;
tree->priv = G_TYPE_INSTANCE_GET_PRIVATE (tree, VINAGRE_TYPE_BOOKMARKS_TREE, VinagreBookmarksTreePrivate);
gtk_orientable_set_orientation (GTK_ORIENTABLE (tree), GTK_ORIENTATION_VERTICAL);
/* Create the scrolled window */
scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scroll),
GTK_SHADOW_ETCHED_OUT);
gtk_widget_set_size_request (scroll, 150, 100);
gtk_box_pack_start (GTK_BOX (tree), scroll, TRUE, TRUE, 0);
/* Create the model */
model = gtk_tree_store_new (NUM_COLS,
GDK_TYPE_PIXBUF,
G_TYPE_STRING,
VINAGRE_TYPE_BOOKMARKS_ENTRY);
tree->priv->tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree->priv->tree), FALSE);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree->priv->tree));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
g_object_unref (model);
main_column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_clickable (main_column, FALSE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree->priv->tree), main_column);
/* Set up the pixbuf column */
cell = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (main_column, cell, FALSE);
gtk_tree_view_column_add_attribute (main_column, cell, "pixbuf", IMAGE_COL);
/* Set up the name column */
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (main_column, cell, TRUE);
gtk_tree_view_column_add_attribute (main_column, cell, "text", NAME_COL);
g_signal_connect (tree->priv->tree,
"row-activated",
G_CALLBACK (vinagre_bookmarks_tree_row_activated_cb),
tree);
vinagre_bookmarks_tree_update_list (tree);
gtk_container_add (GTK_CONTAINER(scroll), tree->priv->tree);
gtk_widget_show (tree->priv->tree);
}
static void
setup_column (GtkTreeViewColumn *col)
{
gtk_tree_view_column_set_clickable (col, TRUE);
g_signal_connect (col,
"clicked",
G_CALLBACK (col_clicked_cb),
NULL);
}
GtkTreeViewColumn *add_vector_to_dialog (vector_table_options_D *dialog, VectorTable *pvt, int idx)
{
GList *llItr = NULL, *llCols = NULL ;
GtkTreeViewColumn *col = NULL ;
GtkCellRenderer *cr = NULL ;
int idxCol = (-1 == idx ? idx : idx + 2) ;
int idxVector = (-1 == idx ? pvt->vectors->icUsed - 1 : idx) ;
char *psz = NULL ;
int Nix, new_idx = -1 ;
if (idx >= 0)
{
// Move to the first vector column
if (NULL != (llCols = llItr = gtk_tree_view_get_columns (GTK_TREE_VIEW (dialog->tv))))
{
if (NULL != (llItr = llItr->next))
llItr = llItr->next ;
// Increment the indices for all vector columns following the new one.
for (Nix = 0 ; llItr != NULL ; llItr = llItr->next, Nix++)
if (Nix >= idx)
if (NULL != (cr = g_object_get_data (G_OBJECT (llItr->data), "cr")))
{
g_object_set_data (G_OBJECT (cr), "idxVector",
(gpointer)(new_idx = (int)g_object_get_data (G_OBJECT (cr), "idxVector") + 1)) ;
gtk_tree_view_column_set_title (GTK_TREE_VIEW_COLUMN (llItr->data), psz = g_strdup_printf ("%d", new_idx)) ;
g_free (psz) ;
}
g_list_free (llCols) ;
}
}
gtk_tree_view_insert_column (GTK_TREE_VIEW (dialog->tv), col = gtk_tree_view_column_new (), idxCol) ;
gtk_tree_view_column_set_title (col, psz = g_strdup_printf ("%d", idxVector)) ;
g_free (psz) ;
gtk_tree_view_column_pack_start (col, cr = qcad_cell_renderer_vt_new (), FALSE) ;
g_object_set (G_OBJECT (cr),
"cell-background-gdk", &((gtk_widget_get_style (dialog->tv))->base[3]),
"cell-background-set", FALSE,
"editable", TRUE, NULL) ;
gtk_tree_view_column_add_attribute (col, cr, "row-type", BUS_LAYOUT_MODEL_COLUMN_TYPE) ;
gtk_tree_view_column_add_attribute (col, cr, "sensitive", VECTOR_TABLE_MODEL_COLUMN_ACTIVE) ;
gtk_tree_view_column_set_clickable (col, TRUE) ;
g_object_set_data (G_OBJECT (cr), "idxVector", (gpointer)idxVector) ;
g_object_set_data (G_OBJECT (cr), "pvt", pvt) ;
gtk_tree_view_column_set_cell_data_func (col, cr, vector_data_func, pvt, NULL) ;
g_object_set_data (G_OBJECT (col), "cr", cr) ;
g_object_set_data (G_OBJECT (cr), "col", col) ;
g_signal_connect (G_OBJECT (col), "clicked", (GCallback)vector_column_clicked, dialog) ;
g_signal_connect (G_OBJECT (cr), "clicked", (GCallback)vector_column_clicked, dialog) ;
g_signal_connect (G_OBJECT (cr), "edited", (GCallback)vector_value_edited, dialog->tv) ;
g_signal_connect (G_OBJECT (cr), "editing-started", (GCallback)vector_value_editing_started, dialog) ;
return col ;
}
static void
preferences_languages_setup (EmpathyPreferences *preferences)
{
EmpathyPreferencesPriv *priv = GET_PRIV (preferences);
GtkTreeView *view;
GtkListStore *store;
GtkTreeSelection *selection;
GtkTreeModel *model;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
guint col_offset;
view = GTK_TREE_VIEW (priv->treeview_spell_checker);
store = gtk_list_store_new (COL_LANG_COUNT,
G_TYPE_BOOLEAN, /* enabled */
G_TYPE_STRING, /* code */
G_TYPE_STRING); /* name */
gtk_tree_view_set_model (view, GTK_TREE_MODEL (store));
selection = gtk_tree_view_get_selection (view);
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
model = GTK_TREE_MODEL (store);
renderer = gtk_cell_renderer_toggle_new ();
g_signal_connect (renderer, "toggled",
G_CALLBACK (preferences_languages_cell_toggled_cb),
preferences);
column = gtk_tree_view_column_new_with_attributes (NULL, renderer,
"active", COL_LANG_ENABLED,
NULL);
gtk_tree_view_append_column (view, column);
renderer = gtk_cell_renderer_text_new ();
col_offset = gtk_tree_view_insert_column_with_attributes (view,
-1, _("Language"),
renderer,
"text", COL_LANG_NAME,
NULL);
g_object_set_data (G_OBJECT (renderer),
"column", GINT_TO_POINTER (COL_LANG_NAME));
column = gtk_tree_view_get_column (view, col_offset - 1);
gtk_tree_view_column_set_sort_column_id (column, COL_LANG_NAME);
gtk_tree_view_column_set_resizable (column, FALSE);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
g_object_unref (store);
}
GtkWidget *PluginManageDlg::create_plugin_list()
{
GtkWidget *sw;
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
plugin_tree_model = gtk_tree_store_new(7, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_BOOLEAN);
init_tree_model(plugin_tree_model);
treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL(plugin_tree_model));
g_object_unref (G_OBJECT (plugin_tree_model));
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview), TRUE);
g_signal_connect (G_OBJECT (treeview), "button_press_event", G_CALLBACK (on_treeview_button_press), this);
GtkTreeSelection *selection;
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
g_signal_connect (selection, "changed", G_CALLBACK (on_plugin_treeview_selection_changed), this);
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
renderer = gtk_cell_renderer_toggle_new ();
g_signal_connect (renderer, "toggled", G_CALLBACK (on_plugin_enable_toggled), this);
column = gtk_tree_view_column_new_with_attributes (_("Enable"), renderer, "visible", 0, "active", 1, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column);
gtk_tree_view_column_set_expand(GTK_TREE_VIEW_COLUMN (column), FALSE);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), FALSE);
renderer = gtk_cell_renderer_text_new ();
g_object_set (G_OBJECT (renderer), "xalign", 0.0, NULL);
column = gtk_tree_view_column_new_with_attributes (_("Plug-in Name"), renderer, "markup", 2, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column);
gtk_tree_view_column_set_expand(GTK_TREE_VIEW_COLUMN (column), TRUE);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), FALSE);
GtkTargetEntry gte[] = {{(gchar *)"STARDICT_PLUGINMANAGE", GTK_TARGET_SAME_APP, 0}};
gtk_tree_view_enable_model_drag_source(GTK_TREE_VIEW(treeview), GDK_BUTTON1_MASK, gte, 1, GDK_ACTION_COPY);
gtk_tree_view_enable_model_drag_dest(GTK_TREE_VIEW(treeview), gte, 1, (GdkDragAction)(GDK_ACTION_COPY | GDK_ACTION_MOVE));
g_signal_connect(G_OBJECT(treeview), "drag-data-received", G_CALLBACK(drag_data_received_cb), this);
g_signal_connect(G_OBJECT(treeview), "drag-data-get", G_CALLBACK(drag_data_get_cb), this);
gtk_tree_view_expand_all(GTK_TREE_VIEW (treeview));
gtk_container_add (GTK_CONTAINER (sw), treeview);
return sw;
}
static GtkWidget *hview_get_tree_window(void)
{
GtkWidget *window;
GtkCellRenderer *renderer;
GtkTreeViewColumn *col;
GtkTreeSelection *selection;
window = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_widget_set_size_request(GTK_WIDGET(window),
HVIEW_TREE_WINDOW_WIDTH,
HVIEW_TREE_WINDOW_HEIGHT);
tree_view = gtk_tree_view_new();
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(tree_view),
-1,
HVIEW_DOMAIN_COLUMN_TITLE,
renderer,
"text", 0, NULL);
col = gtk_tree_view_get_column(GTK_TREE_VIEW(tree_view), 0);
gtk_tree_view_column_set_clickable(col, TRUE);
g_signal_connect(G_OBJECT(col), "clicked",
G_CALLBACK(hview_tree_column_activated_call), NULL);
g_signal_connect(G_OBJECT(tree_view), "row-activated",
G_CALLBACK(hview_tree_row_activated_call), NULL);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
g_signal_connect(G_OBJECT(selection), "changed",
G_CALLBACK(hview_tree_row_selected_call), NULL);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(window),
tree_view);
return window;
}
GtkTreeView* ReceiverWindow::create_and_fill_store()
{
GtkTreeView* store = GTK_TREE_VIEW(gtk_tree_view_new());
int i=0;
GtkTreeViewColumn* column;
GtkCellRenderer *renderer;
for (;i<sizeof(titles)/sizeof(titles[0]); i++)
{
if (i<2)
{
//не очень понятный код для создания редактируемой ячейки с изменяемым размером и подсоединения сигнала его изменения к celled_signal
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer,"editable", TRUE, NULL);
g_signal_connect (renderer, "edited", G_CALLBACK (celled_signal), model);
g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (i));
int col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (store), -1, titles[i], renderer, "text", i, NULL);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (store), col_offset - 1);
gtk_tree_view_column_set_resizable(column, 1);
}
else
{
//не очень понятный код для создания ячейки с выбором одного из двух и изменяемым размером и подсоединения сигнала его изменения к receiver_toggle_signal
renderer = gtk_cell_renderer_toggle_new ();
g_object_set (renderer, "xalign", 0.0, NULL);
g_object_set_data (G_OBJECT (renderer), "column", (gint *)i);
g_signal_connect (renderer, "toggled", G_CALLBACK (receiver_toggle_signal), model);
int col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (store), -1, titles[i], renderer, "active", i, NULL);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (store), col_offset - 1);
gtk_tree_view_column_set_resizable(column, 1);
gtk_tree_view_column_set_fixed_width (column, 50);
gtk_tree_view_column_set_clickable (column, TRUE);
}
}
gtk_tree_view_set_model(store, GTK_TREE_MODEL(model));
return store;
}
void wxCheckListBox::DoCreateCheckList()
{
//Create the checklist in our treeview and set up events for it
GtkCellRenderer* renderer =
gtk_cell_renderer_toggle_new();
GtkTreeViewColumn* column =
gtk_tree_view_column_new_with_attributes( "", renderer,
"active", 0,
NULL );
gtk_tree_view_column_set_fixed_width(column, 22);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_clickable(column, TRUE);
g_signal_connect (renderer, "toggled",
G_CALLBACK (gtk_checklist_toggled),
this);
gtk_tree_view_append_column(m_treeview, column);
}
void
list_store_set_sort_all(GtkWidget *tview)
{
GList *list, *ptr;
int i;
GtkTreeViewColumn *column;
list = gtk_tree_view_get_columns(GTK_TREE_VIEW(tview));
if (list == NULL)
return;
for (ptr = list, i = 0; ptr; ptr = ptr->next, i++) {
column = GTK_TREE_VIEW_COLUMN(ptr->data);
gtk_tree_view_column_set_sort_column_id(column, i);
gtk_tree_view_column_set_clickable(column, TRUE);
}
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tview), TRUE);
g_list_free(list);
}
void create_column(void *view, int type,
char *title, int width)
{
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
debug("create_column()");
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(title, renderer,
"text", type,
NULL);
gtk_tree_view_column_set_title(column, title);
gtk_tree_view_column_set_visible(column, TRUE);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_min_width(column, width);
gtk_tree_view_column_set_alignment(column, 0.5);
gtk_tree_view_column_set_clickable(column, TRUE);
gtk_tree_view_column_set_reorderable(column, TRUE);
gtk_tree_view_column_set_sort_order(column, 0);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);
}
static void
preferences_sound_setup (EmpathyPreferences *preferences)
{
EmpathyPreferencesPriv *priv = GET_PRIV (preferences);
GtkTreeView *view;
GtkListStore *store;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
view = GTK_TREE_VIEW (priv->treeview_sounds);
store = gtk_list_store_new (COL_SOUND_COUNT,
G_TYPE_BOOLEAN, /* enabled */
G_TYPE_STRING, /* name */
G_TYPE_STRING); /* key */
gtk_tree_view_set_model (view, GTK_TREE_MODEL (store));
renderer = gtk_cell_renderer_toggle_new ();
g_signal_connect (renderer, "toggled",
G_CALLBACK (preferences_sound_cell_toggled_cb),
preferences);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_add_attribute (column, renderer,
"active", COL_SOUND_ENABLED);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_add_attribute (column, renderer,
"text", COL_SOUND_NAME);
gtk_tree_view_append_column (view, column);
gtk_tree_view_column_set_resizable (column, FALSE);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
g_object_unref (store);
}
static void
contact_widget_model_populate_columns (EmpathyContactWidget *information)
{
GtkTreeView *view;
GtkTreeModel *model;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
guint col_offset;
view = GTK_TREE_VIEW (information->treeview_groups);
model = gtk_tree_view_get_model (view);
renderer = gtk_cell_renderer_toggle_new ();
g_signal_connect (renderer, "toggled",
G_CALLBACK (contact_widget_cell_toggled), information);
column = gtk_tree_view_column_new_with_attributes (_("Select"), renderer,
"active", COL_ENABLED, NULL);
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_fixed_width (column, 50);
gtk_tree_view_append_column (view, column);
renderer = gtk_cell_renderer_text_new ();
col_offset = gtk_tree_view_insert_column_with_attributes (view,
-1, _("Group"),
renderer,
"text", COL_NAME,
/* "editable", COL_EDITABLE, */
NULL);
g_object_set_data (G_OBJECT (renderer),
"column", GINT_TO_POINTER (COL_NAME));
column = gtk_tree_view_get_column (view, col_offset - 1);
gtk_tree_view_column_set_sort_column_id (column, COL_NAME);
gtk_tree_view_column_set_resizable (column,FALSE);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
}
void
list_store_set_sort_column(GtkWidget *tview, int col)
{
GList *list, *ptr;
list = gtk_tree_view_get_columns(GTK_TREE_VIEW(tview));
if (list == NULL)
return;
ptr = g_list_nth(list, col);
if (ptr) {
GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(ptr->data);
gtk_tree_view_column_set_sort_column_id(column, col);
gtk_tree_view_column_set_clickable(column, TRUE);
}
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tview), TRUE);
g_list_free(list);
}
static void fx_many_create_all_column(FxMany* fxmany)
{
GtkCellRenderer* renderer;
GtkTreeViewColumn *col , *col1;
GtkWidget* tree = fxmany->tree;
renderer = gtk_cell_renderer_toggle_new();
g_signal_connect(renderer , "toggled" , G_CALLBACK(fx_many_item_toggled) , fxmany);
col = gtk_tree_view_column_new();
gtk_tree_view_column_pack_start(col , renderer , TRUE);
gtk_tree_view_column_add_attribute(col, renderer, "active", S_CHECK_COL);
gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (col)
, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (col), 40);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (col), TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree) , col);
renderer = gtk_cell_renderer_pixbuf_new();
GtkTreeViewColumn* col0 = gtk_tree_view_column_new();
gtk_tree_view_column_pack_start(col0, renderer , FALSE);
gtk_tree_view_column_add_attribute(col0, renderer, "pixbuf", S_PIXBUF_COL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), col0);
renderer = gtk_cell_renderer_text_new();
col1 = gtk_tree_view_column_new();
gtk_tree_view_column_pack_start(col1, renderer , FALSE);
gtk_tree_view_column_set_cell_data_func(col1
, renderer
, fx_many_text_cell_data_func
, NULL
, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), col1);
gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (col)
, GTK_TREE_VIEW_COLUMN_FIXED);
}
void create_text_real_tree_view(struct chara_real_clist *cr_clist, GtkTreeView *cr_tree_view,
GtkCellRenderer *renderer_text, GtkCellRenderer *renderer_spin)
{
/* GtkTreeModel *child_model = GTK_TREE_MODEL(user_data);*/
GtkTreeModel *model;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
GtkListStore *child_model;
GtkAdjustment *adjust;
int i;
/* Construct empty list storage */
child_model = gtk_list_store_new(4, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_DOUBLE);
g_object_set_data(G_OBJECT(child_model), "selection_list", NULL);
/* ソート用のモデルを作成してツリービューにセットする */
model = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(child_model));
gtk_tree_view_set_model(GTK_TREE_VIEW(cr_tree_view), model);
/* First raw */
column = gtk_tree_view_column_new();
gtk_tree_view_append_column(cr_tree_view, column);
gtk_tree_view_column_set_title(column, "Index");
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_attributes(column, renderer, "text", COLUMN_FIELD_INDEX, NULL);
g_object_set(renderer, "width", (gint)60, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_clickable(column, TRUE);
g_object_set_data(G_OBJECT(column), "column_id", GINT_TO_POINTER(COLUMN_FIELD_INDEX));
g_signal_connect(G_OBJECT(column), "clicked",
G_CALLBACK(column_clicked), cr_tree_view);
/* Second row */
column = gtk_tree_view_column_new();
gtk_tree_view_append_column(cr_tree_view, column);
gtk_tree_view_column_set_title(column, cr_clist->c1_name);
g_object_set(G_OBJECT(renderer_text), "editable", TRUE, NULL);
gtk_tree_view_column_pack_start(column, renderer_text, TRUE);
gtk_tree_view_column_set_attributes(column, renderer_text, "text", COLUMN_FIELD_NAME, NULL);
g_object_set(renderer_text, "width", (gint)150, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_clickable(column, TRUE);
g_object_set_data(G_OBJECT(column), "column_id", GINT_TO_POINTER(COLUMN_FIELD_NAME));
g_signal_connect(G_OBJECT(column), "clicked",
G_CALLBACK(column_clicked), cr_tree_view);
/* Third row */
column = gtk_tree_view_column_new();
gtk_tree_view_append_column(cr_tree_view, column);
gtk_tree_view_column_set_title(column, cr_clist->r1_name);
adjust = gtk_adjustment_new(2.5, -1.0e30, 1.0e30, 0.1,
100, 21474836);
g_object_set(G_OBJECT(renderer_spin),
"adjustment", adjust,
"climb-rate", 0.5,
"digits", 3,
"editable", TRUE,
"width", (gint)150, NULL);
gtk_tree_view_column_pack_start(column, renderer_spin, TRUE);
gtk_tree_view_column_set_attributes(column, renderer_spin, "text", COLUMN_FIELD_VALUE, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_clickable(column, TRUE);
g_object_set_data(G_OBJECT(column), "column_id", GINT_TO_POINTER(COLUMN_FIELD_VALUE));
g_signal_connect(G_OBJECT(column), "clicked",
G_CALLBACK(column_clicked), cr_tree_view);
/* 選択モード */
selection = gtk_tree_view_get_selection(cr_tree_view);
gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
/* sort */
column = gtk_tree_view_get_column(cr_tree_view, COLUMN_FIELD_INDEX);
gtk_tree_view_column_set_sort_order(column, GTK_SORT_ASCENDING);
gtk_tree_view_column_set_sort_indicator(column, TRUE);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(model), COLUMN_FIELD_INDEX, GTK_SORT_ASCENDING);
}
void library_view_init(library_view_t* view)
{
// library view.
GObject* object = gtk_builder_get_object(view->builder,"view_library");
g_object_set_data(object, "library_view_t", (gpointer) view);
// playlists (initially not viewed)
//GtkWidget* scw_playlists = GTK_WIDGET(gtk_builder_get_object(view->builder,"scw_playlists"));
//gtk_widget_hide(scw_playlists);
// library list
GtkTreeView* tview = GTK_TREE_VIEW(gtk_builder_get_object(view->builder, "tv_library"));
view->tview = tview;
GtkTreeViewColumn *col;
GtkCellRenderer* renderer;
renderer = gtk_cell_renderer_text_new();
view->cols = (GtkTreeViewColumn**) mc_malloc(sizeof(GtkTreeViewColumn*) * PLAYLIST_MODEL_N_COLUMNS);
playlist_column_enum e;
for(e = PLAYLIST_MODEL_COL_NR; e < PLAYLIST_MODEL_N_COLUMNS; ++e) {
col = gtk_tree_view_column_new_with_attributes(i18n_column_name(e), renderer, "text", e, NULL);
gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
char path [500];
sprintf(path, "library.column.%s.width", column_id(e));
int width = el_config_get_int(btb_config(view->btb), path, 100);
if (width < 10) { width = 100; }
g_object_set_data(G_OBJECT(col), "column_id", (gpointer) column_id(e));
gtk_tree_view_column_set_fixed_width(col, width);
gtk_tree_view_column_set_reorderable(col, TRUE);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_set_clickable(col, TRUE);
g_signal_connect(col, "clicked", (GCallback) library_view_library_col_sort, view);
g_signal_connect (col, "notify::width", G_CALLBACK (library_view_col_width_set), view);
view->cols[e] = col;
g_object_ref(view->cols[e]);
gtk_tree_view_append_column(tview, col);
}
gtk_tree_view_set_model(tview, GTK_TREE_MODEL(playlist_model_gtk_model(view->playlist_model)));
// Aspect lists
int width;
// Genres
tview = GTK_TREE_VIEW(gtk_builder_get_object(view->builder, "tv_genre_aspect"));
col = gtk_tree_view_column_new_with_attributes(_("Genre"), renderer, "text", 0, NULL);
gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
//width = el_config_get_int(btb_config(view->btb), "library.aspects.column_width", 200);
//gtk_tree_view_column_set_fixed_width(col, width);
gtk_tree_view_append_column(tview, col);
gtk_tree_view_set_model(tview, string_model_gtk_model(view->genre_model));
// Artists
tview = GTK_TREE_VIEW(gtk_builder_get_object(view->builder, "tv_artist_aspect"));
col = gtk_tree_view_column_new_with_attributes(_("Artists"), renderer, "text", 0, NULL);
gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
//width = el_config_get_int(btb_config(view->btb), "library.aspects.column_width", 200);
//gtk_tree_view_column_set_fixed_width(col, width);
gtk_tree_view_append_column(tview, col);
gtk_tree_view_set_model(tview, string_model_gtk_model(view->artist_model));
// Albums
tview = GTK_TREE_VIEW(gtk_builder_get_object(view->builder, "tv_album_aspect"));
col = gtk_tree_view_column_new_with_attributes(_("Artists"), renderer, "text", 0, NULL);
gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
//width = el_config_get_int(btb_config(view->btb), "library.aspects.column_width", 200);
//gtk_tree_view_column_set_fixed_width(col, width);
gtk_tree_view_append_column(tview, col);
gtk_tree_view_set_model(tview, string_model_gtk_model(view->album_model));
// Activate genres
library_view_aspect_page(view, GENRE_ASPECT);
GtkToggleToolButton* g_btn = GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(view->builder, "tbtn_genres"));
gtk_toggle_tool_button_set_active(g_btn, TRUE);
// playback scale, song info
GtkScale* sc_playback = GTK_SCALE(gtk_builder_get_object(view->builder, "sc_library_playback"));
gtk_range_set_range(GTK_RANGE(sc_playback), 0.0, 100.0);
{
char ss[300];
sprintf(ss,"<span size=\"x-small\"><i><b> </b></i></span>");
GtkLabel* lbl = GTK_LABEL(gtk_builder_get_object(view->builder, "lbl_song_info"));
gtk_label_set_markup(lbl, ss);
}
// Set logo
{
char *path = backtobasics_logo(view->btb);
file_info_t* info = file_info_new(path);
mc_free(path);
if (file_info_is_file(info)) {
GError *err = NULL;
GdkPixbuf* pb = gdk_pixbuf_new_from_file_at_scale(file_info_path(info),
view->img_w, view->img_h,
TRUE,
&err
);
GtkImage* img = GTK_IMAGE(gtk_builder_get_object(view->builder, "img_art"));
gtk_widget_set_size_request(GTK_WIDGET(img), view->img_w, view->img_h);
if (pb != NULL) {
gtk_image_set_from_pixbuf(img, pb);
g_object_unref(pb);
} else {
log_error3("error loading image art: %d, %s", err->code, err->message);
//g_free(err);
}
}
file_info_destroy(info);
}
// Playlists
tview = GTK_TREE_VIEW(gtk_builder_get_object(view->builder, "tv_playlists"));
col = gtk_tree_view_column_new_with_attributes(_("Playlist"), renderer, "text", 0, NULL);
gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
width = el_config_get_int(btb_config(view->btb), "library.playlists.column_width", 200);
gtk_tree_view_column_set_fixed_width(col, width);
gtk_tree_view_append_column(tview, col);
gtk_tree_view_set_model(tview, playlists_model_gtk_model(view->playlists_model));
// Lyric view
view->lyric_view = WEBKIT_WEB_VIEW(webkit_web_view_new());
view->lbl_lyric_track = GTK_LABEL(gtk_builder_get_object(view->builder, "lbl_lyric_track"));
GtkScrolledWindow* scw_lyric = GTK_SCROLLED_WINDOW(gtk_builder_get_object(view->builder, "scw_lyric"));
gtk_container_add(GTK_CONTAINER(scw_lyric), GTK_WIDGET(view->lyric_view));
// visibility of columns
{
const char* names[] = {
"chk_col_nr", "chk_col_title", "chk_col_artist", "chk_col_composer",
"chk_col_piece", "chk_col_album", "chk_col_albumartist", "chk_col_genre",
"chk_col_year", "chk_col_length", NULL
};
const playlist_column_enum es[] = {
PLAYLIST_MODEL_COL_NR, PLAYLIST_MODEL_COL_TITLE, PLAYLIST_MODEL_COL_ARTIST,
PLAYLIST_MODEL_COL_COMPOSER, PLAYLIST_MODEL_COL_PIECE,
PLAYLIST_MODEL_COL_ALBUM_TITLE, PLAYLIST_MODEL_COL_ALBUM_ARTIST,
PLAYLIST_MODEL_COL_GENRE, PLAYLIST_MODEL_COL_YEAR, PLAYLIST_MODEL_COL_LENGTH,
PLAYLIST_MODEL_N_COLUMNS
};
int i;
for(i = 0;names[i] != NULL; ++i) {
GtkCheckMenuItem* item = GTK_CHECK_MENU_ITEM(gtk_builder_get_object(view->builder, names[i]));
gtk_widget_set_name(GTK_WIDGET(item), names[i]);
char cfgitem[100];
sprintf(cfgitem, "library.cols.%s", names[i]);
int yes = el_config_get_int(btb_config(view->btb), cfgitem, 1);
gtk_check_menu_item_set_active(item, yes);
gtk_tree_view_column_set_visible(view->cols[es[i]], yes);
}
}
// Start timeout every 250 ms
g_timeout_add(250, (GSourceFunc) library_view_update_info, view);
}
static void report_gui_list_clicked(report_gui_t *rg)
{
report_gui_list_t *rgl = &(rg->list);
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
int i;
if ( rgl->window == NULL ) {
rgl->window = create_report_list_window();
/* Create list display widget */
rgl->view = GTK_TREE_VIEW(lookup_widget(rgl->window, "report_list_view"));
rgl->model = gtk_list_store_new(REPORT_LIST_NCOLS,
/* Node Name */ G_TYPE_STRING,
/* Verdict */ GDK_TYPE_PIXBUF,
/* Verdict Value */ G_TYPE_INT,
/* Def. Crit. */ G_TYPE_STRING,
/* Def. Crit. Color */ G_TYPE_STRING,
/* Def. Crit. Value */ G_TYPE_INT,
/* Criticity */ G_TYPE_STRING,
/* Crit. Color */ G_TYPE_STRING,
/* Criticity Value */ G_TYPE_INT,
/* Key */ G_TYPE_ULONG);
rgl->model_sort = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(rgl->model));
gtk_tree_view_set_model(rgl->view, rgl->model_sort);
/* Setup tree selection handler */
report_gui_list_select_clear(rgl);
selection = gtk_tree_view_get_selection(rgl->view);
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
gtk_tree_selection_set_select_function(selection,
(GtkTreeSelectionFunc) report_gui_list_select, &(rg->list),
NULL);
/* Column #0: Test Case name */
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(rgl->view, -1, "Test Case", renderer,
"text", REPORT_LIST_COL_NAME,
NULL);
column = gtk_tree_view_get_column(rgl->view, 0);
gtk_tree_view_column_set_clickable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, REPORT_LIST_SORT_NAME);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_expand(column, TRUE);
/* Column #1: Default criticity */
renderer = gtk_cell_renderer_text_new();
gtk_object_set(GTK_OBJECT(renderer), "scale", 0.7, NULL);
gtk_tree_view_insert_column_with_attributes(rgl->view, -1, "Def. Criticity", renderer,
"text", REPORT_LIST_COL_CRITICITY_DEFAULT,
"foreground", REPORT_LIST_COL_CRITICITY_DEFAULT_COLOR,
NULL);
column = gtk_tree_view_get_column(rgl->view, 1);
gtk_tree_view_column_set_clickable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, REPORT_LIST_SORT_CRITICITY);
gtk_tree_view_column_set_resizable(column, FALSE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
/* Column #2: Verdict and Criticity */
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, "Verdict");
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", REPORT_LIST_COL_VERDICT);
renderer = gtk_cell_renderer_text_new();
gtk_object_set(GTK_OBJECT(renderer), "scale", 0.7, NULL);
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_add_attribute(column, renderer, "text", REPORT_LIST_COL_CRITICITY);
gtk_tree_view_column_add_attribute(column, renderer, "foreground", REPORT_LIST_COL_CRITICITY_COLOR);
gtk_tree_view_column_set_clickable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, REPORT_LIST_SORT_VERDICT);
gtk_tree_view_column_set_resizable(column, FALSE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_append_column(rgl->view, column);
/* Setup list sort functions */
for (i = 0; i < REPORT_LIST_NSORTS; i++)
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(rgl->model_sort), i,
(GtkTreeIterCompareFunc) report_gui_list_sort, GINT_TO_POINTER(i),
NULL);
/* Setup spot buttons */
rgl->spot_tree = lookup_widget(rgl->window, "report_list_tree");
gtk_widget_set_sensitive(rgl->spot_tree, 0);
gtk_signal_connect_object(GTK_OBJECT(rgl->spot_tree),
"clicked", (GtkSignalFunc) report_gui_list_tree_clicked, rg);
rgl->spot_log = lookup_widget(rgl->window, "report_list_log");
gtk_widget_set_sensitive(rgl->spot_log, 0);
gtk_signal_connect_object(GTK_OBJECT(rgl->spot_log),
"clicked", (GtkSignalFunc) report_gui_list_log_clicked, rg);
/* Setup termination events */
gtk_signal_connect_object(GTK_OBJECT(rgl->window), "destroy",
(GtkSignalFunc) report_gui_list_destroyed, rg);
gtk_signal_connect_object(GTK_OBJECT(lookup_widget(rgl->window, "report_list_close")),
"clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(rgl->window));
/* Feed the list */
report_gui_list_feed(rg);
gtk_widget_show(rgl->window);
gtk_tree_selection_unselect_all(selection);
}
else {
gtk_window_present(GTK_WINDOW(rgl->window));
}
}
SteadyflowFileListController* steadyflow_file_list_controller_construct (GType object_type, GtkTreeView* tree) {
SteadyflowFileListController * self = NULL;
GtkTreeView* _tmp0_;
GtkTreeView* _tmp1_;
GtkTreeView* _tmp2_;
GtkTreeSelection* _tmp3_ = NULL;
GTimer* _tmp4_;
GTimer* _tmp5_;
GtkTreeViewColumn* _tmp6_;
GtkTreeViewColumn* _tmp7_;
GtkTreeViewColumn* column;
GtkTreeViewColumn* _tmp8_;
GtkTreeViewColumn* _tmp9_;
SteadyflowUIDownloadCellRenderer* _tmp10_;
GtkCellRenderer* _tmp11_;
GtkCellRenderer* renderer;
GtkTreeViewColumn* _tmp12_;
GtkCellRenderer* _tmp13_;
GtkTreeViewColumn* _tmp14_;
GtkCellRenderer* _tmp15_;
GType* _tmp16_ = NULL;
GType* _tmp17_;
gint _tmp17__length1;
GtkListStore* _tmp18_;
GtkTreeView* _tmp19_;
GtkListStore* _tmp20_;
GtkTreeView* _tmp21_;
GtkTreeViewColumn* _tmp22_;
SteadyflowCoreIDownloadService* _tmp37_;
SteadyflowCoreIDownloadService* _tmp38_;
SteadyflowCoreIDownloadService* _tmp39_;
SteadyflowCoreIDownloadService* _tmp40_;
GtkTreeView* _tmp41_;
GtkTreeSelection* _tmp42_ = NULL;
g_return_val_if_fail (tree != NULL, NULL);
self = (SteadyflowFileListController*) g_object_new (object_type, NULL);
_tmp0_ = tree;
_tmp1_ = _g_object_ref0 (_tmp0_);
_g_object_unref0 (self->priv->tree);
self->priv->tree = _tmp1_;
_tmp2_ = tree;
_tmp3_ = gtk_tree_view_get_selection (_tmp2_);
gtk_tree_selection_set_mode (_tmp3_, GTK_SELECTION_MULTIPLE);
_tmp4_ = g_timer_new ();
_g_timer_destroy0 (self->priv->redraw_timer);
self->priv->redraw_timer = _tmp4_;
_tmp5_ = self->priv->redraw_timer;
g_timer_start (_tmp5_);
_tmp6_ = gtk_tree_view_column_new ();
_tmp7_ = g_object_ref_sink (_tmp6_);
column = _tmp7_;
_tmp8_ = column;
gtk_tree_view_column_set_expand (_tmp8_, TRUE);
_tmp9_ = column;
gtk_tree_view_column_set_clickable (_tmp9_, FALSE);
_tmp10_ = steadyflow_ui_download_cell_renderer_new ();
_tmp11_ = (GtkCellRenderer*) g_object_ref_sink (_tmp10_);
renderer = _tmp11_;
_tmp12_ = column;
_tmp13_ = renderer;
gtk_cell_layout_pack_start ((GtkCellLayout*) _tmp12_, _tmp13_, TRUE);
_tmp14_ = column;
_tmp15_ = renderer;
gtk_cell_layout_set_cell_data_func ((GtkCellLayout*) _tmp14_, _tmp15_, _steadyflow_file_list_controller_set_cell_data_gtk_cell_layout_data_func, g_object_ref (self), g_object_unref);
_tmp16_ = g_new0 (GType, 1);
_tmp16_[0] = STEADYFLOW_CORE_TYPE_IDOWNLOAD_FILE;
_tmp17_ = _tmp16_;
_tmp17__length1 = 1;
_tmp18_ = gtk_list_store_newv (1, _tmp17_);
_g_object_unref0 (self->priv->model);
self->priv->model = _tmp18_;
_tmp17_ = (g_free (_tmp17_), NULL);
_tmp19_ = tree;
_tmp20_ = self->priv->model;
gtk_tree_view_set_model (_tmp19_, (GtkTreeModel*) _tmp20_);
_tmp21_ = tree;
_tmp22_ = column;
gtk_tree_view_append_column (_tmp21_, _tmp22_);
{
SteadyflowCoreIDownloadService* _tmp23_;
SteadyflowCoreIDownloadService* _tmp24_;
GeeList* _tmp25_;
GeeList* _tmp26_;
GeeList* _file_list;
GeeList* _tmp27_;
gint _tmp28_;
gint _tmp29_;
gint _file_size;
gint _file_index;
_tmp23_ = steadyflow_services_get_download ();
_tmp24_ = _tmp23_;
_tmp25_ = steadyflow_core_idownload_service_get_files (_tmp24_);
_tmp26_ = _tmp25_;
_file_list = _tmp26_;
_tmp27_ = _file_list;
_tmp28_ = gee_collection_get_size ((GeeCollection*) _tmp27_);
_tmp29_ = _tmp28_;
_file_size = _tmp29_;
_file_index = -1;
while (TRUE) {
gint _tmp30_;
gint _tmp31_;
gint _tmp32_;
GeeList* _tmp33_;
gint _tmp34_;
gpointer _tmp35_ = NULL;
SteadyflowCoreIDownloadFile* file;
SteadyflowCoreIDownloadFile* _tmp36_;
_tmp30_ = _file_index;
_file_index = _tmp30_ + 1;
_tmp31_ = _file_index;
_tmp32_ = _file_size;
if (!(_tmp31_ < _tmp32_)) {
break;
}
_tmp33_ = _file_list;
_tmp34_ = _file_index;
_tmp35_ = gee_list_get (_tmp33_, _tmp34_);
file = (SteadyflowCoreIDownloadFile*) _tmp35_;
_tmp36_ = file;
steadyflow_file_list_controller_connect_file_signals (self, _tmp36_);
_g_object_unref0 (file);
}
_g_object_unref0 (_file_list);
}
steadyflow_file_list_controller_update_model (self);
_tmp37_ = steadyflow_services_get_download ();
_tmp38_ = _tmp37_;
g_signal_connect_object (_tmp38_, "file-added", (GCallback) ___lambda26__steadyflow_core_idownload_service_file_added, self, 0);
_tmp39_ = steadyflow_services_get_download ();
_tmp40_ = _tmp39_;
g_signal_connect_object (_tmp40_, "file-removed", (GCallback) ___lambda27__steadyflow_core_idownload_service_file_removed, self, 0);
_tmp41_ = tree;
_tmp42_ = gtk_tree_view_get_selection (_tmp41_);
g_signal_connect_object (_tmp42_, "changed", (GCallback) ___lambda28__gtk_tree_selection_changed, self, 0);
_g_object_unref0 (renderer);
_g_object_unref0 (column);
return self;
}
/**
* 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;
}
static void
log_window_find_setup (EmpathyLogWindow *window)
{
GtkTreeView *view;
GtkTreeModel *model;
GtkTreeSelection *selection;
GtkTreeSortable *sortable;
GtkTreeViewColumn *column;
GtkListStore *store;
GtkCellRenderer *cell;
gint offset;
view = GTK_TREE_VIEW (window->treeview_find);
selection = gtk_tree_view_get_selection (view);
/* New store */
store = gtk_list_store_new (COL_FIND_COUNT,
G_TYPE_STRING, /* account icon name */
G_TYPE_STRING, /* account name */
EMPATHY_TYPE_ACCOUNT, /* account */
G_TYPE_STRING, /* chat name */
G_TYPE_STRING, /* chat id */
G_TYPE_BOOLEAN, /* is chatroom */
G_TYPE_STRING, /* date */
G_TYPE_STRING); /* date_readable */
model = GTK_TREE_MODEL (store);
sortable = GTK_TREE_SORTABLE (store);
gtk_tree_view_set_model (view, model);
/* New column */
column = gtk_tree_view_column_new ();
cell = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, cell, FALSE);
gtk_tree_view_column_add_attribute (column, cell,
"icon-name",
COL_FIND_ACCOUNT_ICON);
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, cell, TRUE);
gtk_tree_view_column_add_attribute (column, cell,
"text",
COL_FIND_ACCOUNT_NAME);
gtk_tree_view_column_set_title (column, _("Account"));
gtk_tree_view_append_column (view, column);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_clickable (column, TRUE);
cell = gtk_cell_renderer_text_new ();
offset = gtk_tree_view_insert_column_with_attributes (view, -1, _("Conversation"),
cell, "text", COL_FIND_CHAT_NAME,
NULL);
column = gtk_tree_view_get_column (view, offset - 1);
gtk_tree_view_column_set_sort_column_id (column, COL_FIND_CHAT_NAME);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_clickable (column, TRUE);
cell = gtk_cell_renderer_text_new ();
offset = gtk_tree_view_insert_column_with_attributes (view, -1, _("Date"),
cell, "text", COL_FIND_DATE_READABLE,
NULL);
column = gtk_tree_view_get_column (view, offset - 1);
gtk_tree_view_column_set_sort_column_id (column, COL_FIND_DATE);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_clickable (column, TRUE);
/* Set up treeview properties */
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
gtk_tree_sortable_set_sort_column_id (sortable,
COL_FIND_DATE,
GTK_SORT_ASCENDING);
/* Set up signals */
g_signal_connect (selection, "changed",
G_CALLBACK (log_window_find_changed_cb),
window);
g_object_unref (store);
}
/* 現在のソート列と同じときは昇順／降順を反転する、違うときはクリックした列で昇順ソートする
if (gtk_tree_sortable_get_sort_column_id(GTK_TREE_SORTABLE(model), &cur_id, &order) == TRUE) {
if (cur_id == column_id) {
order = (order == GTK_SORT_ASCENDING) ? GTK_SORT_DESCENDING : GTK_SORT_ASCENDING;
} else {
order = GTK_SORT_ASCENDING;
}
cur_column = gtk_tree_view_get_column(tree_view, cur_id);
gtk_tree_view_column_set_sort_indicator(cur_column, FALSE);
} else {
order = GTK_SORT_ASCENDING;
}
gtk_tree_view_column_set_sort_order(column, order);
gtk_tree_view_column_set_sort_indicator(column, TRUE);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(model), column_id, order);
}
*/
static void create_tree_view_window(GtkButton *button, gpointer user_data)
{
static gint window_id = 0;
GtkTreeModel *child_model = GTK_TREE_MODEL(user_data);
GtkTreeModel *model;
GtkWidget *tree_view;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
/* Set data to treeview */
tree_view = gtk_tree_view_new();
model = gtk_tree_model_sort_new_with_model(child_model);
gtk_tree_view_set_model(GTK_TREE_VIEW(tree_view), model);
/* first raw */
column = gtk_tree_view_column_new();
gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), column);
gtk_tree_view_column_set_title(column, "Field name");
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_attributes(column, renderer, "text", FIELD_NAME_COLUMN, NULL);
g_object_set(renderer, "width", (gint)150, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_clickable(column, FALSE);
g_object_set_data(G_OBJECT(column), "column_id", GINT_TO_POINTER(FIELD_NAME_COLUMN));
/* g_signal_connect(G_OBJECT(column), "clicked", G_CALLBACK(column_clicked), tree_view);*/
/* second row */
column = gtk_tree_view_column_new();
gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), column);
gtk_tree_view_column_set_title(column, "Field output");
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_attributes(column, renderer, "text", VIZ_SWITCH_COLUMN, NULL);
g_object_set(renderer, "width", (gint)150, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_clickable(column, FALSE);
g_object_set_data(G_OBJECT(column), "column_id", GINT_TO_POINTER(VIZ_SWITCH_COLUMN));
/* g_signal_connect(G_OBJECT(column), "clicked", G_CALLBACK(column_clicked), tree_view); */
/* third row */
column = gtk_tree_view_column_new();
gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), column);
gtk_tree_view_column_set_title(column, "Monitor output");
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_attributes(column, renderer, "text", MONITOR_SW_COLUMN, NULL);
g_object_set(renderer, "width", (gint)150, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_clickable(column, FALSE);
g_object_set_data(G_OBJECT(column), "column_id", GINT_TO_POINTER(MONITOR_SW_COLUMN));
/* g_signal_connect(G_OBJECT(column), "clicked", G_CALLBACK(column_clicked), tree_view); */
/* Selection mode */
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
/* Cheange background color */
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree_view), TRUE);
/* Sort
column = gtk_tree_view_get_column(GTK_TREE_VIEW(tree_view), FIELD_NAME_COLUMN);
gtk_tree_view_column_set_sort_order(column, GTK_SORT_ASCENDING);
gtk_tree_view_column_set_sort_indicator(column, TRUE);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(model), FIELD_NAME_COLUMN, GTK_SORT_ASCENDING);
*/
/*initialize data */
init_field_model_data(&mhd_ctl->model_ctl->fld_ctl->field_list, tree_view);
/* Make new window*/
create_window(tree_view, ++window_id);
}
GtkWidget * scratch_tab_create()
{
GtkWidget *vbox = gtk_vbox_new(FALSE, 5);
/* file list treeview */
filelist_treeview = gtk_tree_view_new ();
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (filelist_treeview), TRUE);
gtk_tree_view_set_reorderable(GTK_TREE_VIEW (filelist_treeview), FALSE);
GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(filelist_treeview));
gtk_tree_selection_set_mode (sel, GTK_SELECTION_SINGLE);
g_signal_connect (G_OBJECT(filelist_treeview), "cursor-changed",
G_CALLBACK (filelist_treeview_row_selected), NULL);
filelist_treeview_sw = new_scrolled_window (NULL);
gtk_container_add (GTK_CONTAINER (filelist_treeview_sw), filelist_treeview);
/* add columns to the tree view */
GtkCellRenderer *renderer;
GtkTreeViewColumn *col;
int i;
int col_count = sizeof (filelist_treeview_col_names) / sizeof (char *);
for (i=0; i<col_count; i++) {
renderer = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new_with_attributes (filelist_treeview_col_names[i],
renderer, "text", i, NULL);
if (i == 0) {
gtk_tree_view_column_set_clickable(col, TRUE);
gtk_tree_view_column_set_sort_order(col, GTK_SORT_DESCENDING);
gtk_tree_view_column_set_sort_column_id(col, 0);
gtk_tree_view_column_set_sort_indicator(col, TRUE);
} else {
gtk_tree_view_column_set_clickable(col, FALSE);
}
gtk_tree_view_append_column (GTK_TREE_VIEW(filelist_treeview), col);
}
filelist_store = gtk_list_store_new (col_count, G_TYPE_STRING, G_TYPE_STRING);
GtkTreeSortable *sortable = GTK_TREE_SORTABLE(filelist_store);
gtk_tree_sortable_set_sort_column_id(sortable, 0, GTK_SORT_DESCENDING);
gtk_tree_view_set_model(GTK_TREE_VIEW(filelist_treeview), GTK_TREE_MODEL(filelist_store));
GtkWidget *hbox = gtk_hbox_new(TRUE, 5);
GtkWidget *scratch_button = gtk_button_new_with_label("Scratch on map");
g_signal_connect (G_OBJECT (scratch_button), "clicked",
G_CALLBACK (scratch_button_clicked), NULL);
view_button = gtk_button_new_with_label("View");
g_signal_connect (G_OBJECT(view_button), "clicked",
G_CALLBACK (view_button_clicked), NULL);
delete_button = gtk_button_new_with_label("Delete");
g_signal_connect (G_OBJECT(delete_button), "clicked",
G_CALLBACK (delete_button_clicked), NULL);
gtk_container_add(GTK_CONTAINER(hbox), view_button);
gtk_container_add(GTK_CONTAINER(hbox), delete_button);
gtk_container_add(GTK_CONTAINER(hbox), scratch_button);
gtk_box_pack_start(GTK_BOX(vbox), filelist_treeview_sw, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 5);
/* populate files into filelist treeview */
GtkTreeIter iter;
struct dirent *ep;
char buf[256];
char *file_path = NULL;
int len, ext_len = strlen(SCREENSHOT_FILE_EXT);
char *fname;
struct stat st;
DIR *dp = opendir (g_context.screenshot_dir);
if (dp == NULL) {
if (stat(buf, &st) == 0)
warn_dialog("unable to list screenshot files");
} else {
while ((ep = readdir (dp))) {
fname = ep->d_name;
len = strlen(fname);
if (ep->d_type == DT_REG && len > ext_len &&
(strncmp(&fname[len-ext_len], SCREENSHOT_FILE_EXT, ext_len) == 0)) {
gtk_list_store_prepend (filelist_store, &iter);
file_path = get_full_path(buf, sizeof(buf), fname);
add_file_to_list(&iter, file_path, fname);
}
}
closedir (dp);
}
notebook = gtk_notebook_new();
gtk_notebook_set_scrollable(GTK_NOTEBOOK(notebook), FALSE);
gtk_notebook_set_show_border(GTK_NOTEBOOK(notebook), FALSE);
GtkWidget *label;
label = gtk_label_new("screen shot list");
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), vbox, label);
GtkWidget *image_box = gtk_vbox_new(FALSE, 0);
screenshot_label = gtk_label_new("");
screenshot_image = gtk_image_new();
gtk_box_pack_start(GTK_BOX(image_box), screenshot_label, FALSE, FALSE, 0);
GtkWidget *sw = new_scrolled_window (screenshot_image);
/* stretch */
gtk_box_pack_start(GTK_BOX(image_box), sw, TRUE, TRUE, 0);
label = gtk_label_new("view screen shot");
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), image_box, label);
return notebook;
}
GtkWidget *
CChoosebook::create_tree()
{
GtkWidget *sw;
GtkTreeStore *model;
GtkTreeIter iter;
gchar *filename;
model = gtk_tree_store_new (3,GDK_TYPE_PIXBUF,G_TYPE_STRING,G_TYPE_STRING);
filename = g_build_filename(g_pReciteWord->userpath, "hardbooks", NULL);
gtk_tree_store_append (model, &iter, NULL);
gtk_tree_store_set (model, &iter, 0,Skin->choosebook.dir.p[0],1, _("hardbooks"),2,filename, -1);
create_tree_model(filename,model, &iter);
g_free(filename);
filename = g_build_filename(g_pReciteWord->userpath, "books", NULL);
gtk_tree_store_append (model, &iter, NULL);
gtk_tree_store_set (model, &iter, 0,Skin->choosebook.dir.p[0],1, _("my books"),2,filename, -1);
create_tree_model(filename,model, &iter);
g_free(filename);
gtk_tree_store_append (model, &iter, NULL);
filename = g_build_filename(reciteword_data_dir, "books", NULL);
gtk_tree_store_set (model, &iter,
0,Skin->choosebook.dir.p[0],1, _("books"),2, filename,
-1);
create_tree_model(filename,model, &iter);
g_free(filename);
tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (tree_view), TRUE);
g_object_unref (model);
/*GtkTreeViewColumn *column;
GtkCellRenderer *cell_renderer;
column = gtk_tree_view_column_new ();
cell_renderer = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column,
cell_renderer,
FALSE);
cell_renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column,
cell_renderer,
TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view),
column);*/
GtkCellRenderer *renderer_image;
GtkCellRenderer *renderer_text;
GtkTreeViewColumn *column;
renderer_image = gtk_cell_renderer_pixbuf_new();
renderer_text = gtk_cell_renderer_text_new ();
//g_object_set (G_OBJECT (renderer), "xalign", 0.0, NULL);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column,_("Directories"));
gtk_tree_view_column_pack_start(column,renderer_image,FALSE);
gtk_tree_view_column_add_attribute(column,
renderer_image,
"pixbuf",0);
gtk_tree_view_column_pack_end(column,renderer_text,TRUE);
gtk_tree_view_column_add_attribute(column,
renderer_text,
"text",1);
gtk_tree_view_insert_column(GTK_TREE_VIEW(tree_view),column,-1);
/* col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view),
-1, "Folder",
renderer, "text",
0,
NULL);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (tree_view), col_offset - 1);*/
//gtk_tree_view_column_set_visible(GTK_TREE_VIEW_COLUMN (column), FALSE);
gtk_tree_view_column_set_clickable (column, TRUE);
GtkTreeSelection *selection;
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
gtk_tree_view_expand_all(GTK_TREE_VIEW(tree_view));
//gtk_tree_selection_set_select_function(selection,tree_selection_func,this,NULL);
g_signal_connect (G_OBJECT (selection),
"changed",
G_CALLBACK (on_choosebook_tree_selection_changed),
this);
/*g_signal_connect (G_OBJECT (tree_view),
"button_press_event",
G_CALLBACK (on_choosebook_tree_button_press),
this);*/
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_size_request(sw,Skin->choosebook.book_tree.w,Skin->choosebook.book_tree.h);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (sw), tree_view);
gtk_widget_show(tree_view);
return sw;
}
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;
}
