/** Hide expanders in the given GtkTreeView.
*
* @todo
* This should be replaced by a gtk_tree_view_set_show_expanders when
* we switch to GTK+ 2.12.
*
* @param view the given GtkTreeView
*/
static void hide_expanders(GtkTreeView * view)
{
GtkTreeViewColumn * column;
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_visible(column, FALSE);
gtk_tree_view_insert_column(view, column, -1 /* at the end */);
gtk_tree_view_set_expander_column(view, column);
}
void list_update(void)
{
for (int i = 0; i < HASH_FUNCS_N; i++) {
GtkTreeViewColumn *col = gtk_tree_view_get_column(gui.treeview,
COL_HASH + i);
bool active = hash.funcs[i].enabled;
gtk_tree_view_column_set_visible(col, active);
}
}
static void
cb_sort_header_check(SortFlowState *state)
{
state->header = gtk_toggle_button_get_active (
GTK_TOGGLE_BUTTON (state->cell_sort_header_check));
gtk_tree_view_column_set_visible (state->header_column, state->header);
set_button_sensitivity (state);
}
void on_show_name1_activate(GtkMenuItem * menuitem, gpointer user_data)
{
GtkTreeViewColumn *col;
show_name = GTK_CHECK_MENU_ITEM(menuitem)->active;
col = gtk_tree_view_get_column(GTK_TREE_VIEW(tree2_w), COL_NAME);
if (col)
gtk_tree_view_column_set_visible(col, show_name);
}
static GtkWidget *
create_tree_view(int n, n_list_store *list, int tree)
{
GType *tarray;
GtkTreeModel *lstore;
GtkWidget *tview;
GtkTreeViewColumn *col;
GtkTreeSelection *sel;
int i;
if (n < 1 || list == NULL)
return NULL;
tarray = g_malloc(sizeof(*tarray) * n);
if (tarray == NULL)
return NULL;
for (i = 0; i < n; i++) {
if (list[i].type == G_TYPE_DOUBLE || list[i].type == G_TYPE_ENUM || list[i].type == G_TYPE_PARAM) {
tarray[i] = G_TYPE_STRING;
} else {
tarray[i] = list[i].type;
}
list[i].edited_id = 0;
}
if (tree) {
lstore = GTK_TREE_MODEL(gtk_tree_store_newv(n, tarray));
} else {
lstore = GTK_TREE_MODEL(gtk_list_store_newv(n, tarray));
}
g_free(tarray);
tview = gtk_tree_view_new_with_model(lstore);
#if ! GTK_CHECK_VERSION(3, 14, 0)
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tview), TRUE);
#endif
gtk_tree_view_set_rubber_banding(GTK_TREE_VIEW(tview), TRUE);
gtk_tree_view_set_grid_lines(GTK_TREE_VIEW(tview), GTK_TREE_VIEW_GRID_LINES_VERTICAL);
sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(tview));
gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE);
for (i = 0; i < n; i++) {
if (list[i].visible) {
col = create_column(list, i);
gtk_tree_view_column_set_visible(col, list[i].visible);
gtk_tree_view_append_column(GTK_TREE_VIEW(tview), col);
}
}
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tview), n > 1);
return tview;
}
void gtkhash_properties_list_refilter(struct page_s *page)
{
GtkTreeModelFilter *filter = gtkhash_properties_list_get_filter(page);
gtk_tree_model_filter_refilter(filter);
bool active = gtk_check_menu_item_get_active(page->menuitem_show_funcs);
GtkTreeViewColumn *col = gtk_tree_view_get_column(page->treeview, 0);
gtk_tree_view_column_set_visible(col, active);
gtk_tree_view_columns_autosize(page->treeview);
}
void
gtkam_list_show_thumbnails (GtkamList *list)
{
g_return_if_fail (GTKAM_IS_LIST (list));
list->priv->thumbnails = TRUE;
gtk_tree_view_column_set_visible (list->priv->col_previews, TRUE);
gtk_tree_model_foreach (GTK_TREE_MODEL (list->priv->store),
show_thumbnails_foreach_func, list);
g_idle_add (get_thumbnail_idle, list);
}
static void
refresh_log (GitLogPane *self)
{
Git *plugin;
GtkTreeViewColumn *graph_column;
GitLogCommand *log_command;
plugin = ANJUTA_PLUGIN_GIT (anjuta_dock_pane_get_plugin (ANJUTA_DOCK_PANE (self)));
graph_column = GTK_TREE_VIEW_COLUMN (gtk_builder_get_object (self->priv->builder,
"graph_column"));
/* We don't support filters for now */
log_command = git_log_command_new (plugin->project_root_directory,
self->priv->selected_branch,
self->priv->path,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL);
/* Hide the graph column if we're looking at the log of a path. The graph
* won't be correct in this case. */
if (self->priv->path)
gtk_tree_view_column_set_visible (graph_column, FALSE);
else
gtk_tree_view_column_set_visible (graph_column, TRUE);
g_signal_connect (G_OBJECT (log_command), "command-finished",
G_CALLBACK (on_log_command_finished),
self);
gtk_list_store_clear (self->priv->log_model);
/* Show the loading spinner */
git_log_pane_set_view_mode (self, LOG_VIEW_LOADING);
anjuta_command_start (ANJUTA_COMMAND (log_command));
}
void list_update(void)
{
bool enabled = false;
for (int i = 0; i < HASH_FUNCS_N; i++) {
if (!hash.funcs[i].supported)
continue;
if (hash.funcs[i].enabled)
enabled = true;
GtkTreeViewColumn *col = gtk_tree_view_get_column(gui.treeview,
list_priv.hash_cols[i]);
gtk_tree_view_column_set_visible(col, hash.funcs[i].enabled);
}
GtkTreeViewColumn *col = gtk_tree_view_get_column(gui.treeview, COL_STATUS);
gtk_tree_view_column_set_visible(col, list_priv.show_status);
gtk_widget_set_sensitive(GTK_WIDGET(gui.toolbutton_clear), list.rows);
gtk_widget_set_sensitive(GTK_WIDGET(gui.menuitem_treeview_clear), list.rows);
gtk_widget_set_sensitive(GTK_WIDGET(gui.button_hash), list.rows && enabled);
}
void
gimp_path_editor_set_writable_path (GimpPathEditor *editor,
const gchar *path)
{
GtkTreeModel *model;
GtkTreeIter iter;
gboolean iter_valid;
GList *path_list;
gboolean writable_changed = FALSE;
g_return_if_fail (GIMP_IS_PATH_EDITOR (editor));
gtk_tree_view_column_set_visible (editor->writable_column, TRUE);
path_list = gimp_path_parse (path, 16, TRUE, NULL);
model = GTK_TREE_MODEL (editor->dir_list);
for (iter_valid = gtk_tree_model_get_iter_first (model, &iter);
iter_valid;
iter_valid = gtk_tree_model_iter_next (model, &iter))
{
gchar *dir;
gboolean dir_writable;
gboolean new_writable = FALSE;
gtk_tree_model_get (model, &iter,
COLUMN_DIRECTORY, &dir,
COLUMN_WRITABLE, &dir_writable,
-1);
if (g_list_find_custom (path_list, dir, (GCompareFunc) strcmp))
new_writable = TRUE;
g_free (dir);
if (dir_writable != new_writable)
{
gtk_list_store_set (editor->dir_list, &iter,
COLUMN_WRITABLE, new_writable,
-1);
writable_changed = TRUE;
}
}
gimp_path_free (path_list);
if (writable_changed)
g_signal_emit (editor, gimp_path_editor_signals[WRITABLE_CHANGED], 0);
}
gTree::gTree()
{
onRemove = NULL;
datakey = g_hash_table_new((GHashFunc)g_str_hash,(GEqualFunc)gTree_equal);
store = gtk_tree_store_new(2, G_TYPE_STRING, G_TYPE_POINTER);
widget = NULL;
//_editable = false;
_resizable = false;
_auto_resize = false;
//_edited_row = NULL;
_sorted = false;
_ascending = true;
_sort_column = 0;
_init_sort = false;
_sort_dirty = false;
_expander = false;
_no_click = 0;
#if 0
if (view)
{
#if GTK_CHECK_VERSION(2, 12, 0)
gtk_tree_view_set_show_expanders(GTK_TREE_VIEW(widget), false);
#else
GtkTreeViewColumn *column = gtk_tree_view_column_new();
//gtk_tree_view_column_pack_start(column,rgraph,false);
//gtk_tree_view_column_pack_start(column,rtext,true);
//gtk_tree_view_column_set_cell_data_func(column,rgraph,(GtkTreeCellDataFunc)tree_cell_graph,(gpointer)this,NULL);
//gtk_tree_view_column_set_cell_data_func(column,rtext,(GtkTreeCellDataFunc)tree_cell_text,(gpointer)this,NULL);
gtk_tree_view_column_set_visible(column, false);
gtk_tree_view_append_column(GTK_TREE_VIEW(widget), column);
gtk_tree_view_set_expander_column(GTK_TREE_VIEW(widget), column);
#endif
rgraph = gtk_cell_renderer_pixbuf_new();
g_object_ref_sink(rgraph);
rtext = gtk_cell_renderer_text_new();
g_object_ref_sink(rtext);
g_signal_connect(G_OBJECT(rtext), "edited", G_CALLBACK(cb_tree_edited), (gpointer)this);
g_signal_connect(G_OBJECT(rtext), "editing-started", G_CALLBACK(cb_tree_started), (gpointer)this);
g_signal_connect(G_OBJECT(rtext), "editing-canceled", G_CALLBACK(cb_tree_canceled), (gpointer)this);
//addColumn();
setAutoResize(true);
}
#endif
}
void
item_list_view_update (ItemListView *ilv, gboolean hasEnclosures)
{
/* we depend on the fact that the third column is the enclosure icon column!!! */
gtk_tree_view_column_set_visible (gtk_tree_view_get_column (ilv->priv->treeview, 1), hasEnclosures);
if (ilv->priv->batch_mode) {
item_list_view_set_tree_store (ilv, ilv->priv->batch_itemstore);
ilv->priv->batch_mode = FALSE;
} else {
/* Nothing to do in non-batch mode as items were added
and updated one-by-one in ui_itemlist_add_item() */
}
}
void
egg_column_model_set_column_visible (EggColumnModel *model, GtkTreeIter *iter, gboolean visible)
{
GtkTreeViewColumn *column;
GtkTreePath *path;
path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), iter);
column = (GtkTreeViewColumn *)((GList *)iter->user_data)->data;
gtk_tree_view_column_set_visible (column, visible);
gtk_tree_model_row_changed (GTK_TREE_MODEL (model), path, iter);
gtk_tree_path_free (path);
}
static void
usage_view_load_columns (PlannerUsageView *view)
{
PlannerUsageViewPriv *priv;
GList *columns, *l;
GtkTreeViewColumn *column;
const gchar *id;
gint i;
priv = view->priv;
/* Load the columns. */
planner_view_column_load_helper (PLANNER_VIEW (view),
GTK_TREE_VIEW (priv->tree));
/* Make things a bit more robust by setting defaults if we don't get any
* visible columns. Should be done through a schema instead (but we'll
* keep this since a lot of people get bad installations when installing
* themselves).
*/
columns = gtk_tree_view_get_columns (GTK_TREE_VIEW (priv->tree));
i = 0;
for (l = columns; l; l = l->next) {
if (gtk_tree_view_column_get_visible (l->data)) {
i++;
}
}
if (i == 0) {
for (l = columns; l; l = l->next) {
column = l->data;
if (g_object_get_data (G_OBJECT (column), "custom")) {
continue;
}
id = g_object_get_data (G_OBJECT (column), "id");
if (!id) {
continue;
}
gtk_tree_view_column_set_visible (column, TRUE);
}
}
g_list_free (columns);
}
GtkWidget *create_view()
{
GtkTreeViewColumn *col;
GtkCellRenderer *renderer;
GtkWidget *view;
g_store = gtk_list_store_new(NB_COL, G_TYPE_STRING, G_TYPE_STRING, GDK_TYPE_PIXBUF);
view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(g_store));
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(view), TRUE);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE);
g_object_unref(g_store); // destroy store automatically with view
renderer = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new();
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_add_attribute(col, renderer, "text", COL_THEME_FILE);
gtk_tree_view_column_set_visible(col, FALSE);
gtk_tree_view_append_column(GTK_TREE_VIEW(view),col);
renderer = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new();
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_add_attribute(col, renderer, "text", COL_THEME_NAME);
gtk_tree_view_append_column(GTK_TREE_VIEW(view),col);
g_width_list = 200;
g_height_list = 30;
g_renderer = gtk_cell_renderer_pixbuf_new();
g_object_set(g_renderer, "xalign", 0.0, NULL);
gtk_cell_renderer_set_fixed_size(g_renderer, g_width_list, g_height_list);
// specific to gtk-2.18 or higher
//gtk_cell_renderer_set_padding(g_renderer, 5, 5);
col = gtk_tree_view_column_new();
gtk_tree_view_column_pack_start(col, g_renderer, TRUE);
gtk_tree_view_column_add_attribute(col, g_renderer, "pixbuf", COL_SNAPSHOT);
gtk_tree_view_append_column(GTK_TREE_VIEW(view),col);
GtkTreeSortable *sortable;
sortable = GTK_TREE_SORTABLE(g_store);
gtk_tree_sortable_set_sort_column_id(sortable, COL_THEME_FILE, GTK_SORT_ASCENDING);
gtk_tree_sortable_set_sort_func(sortable, COL_THEME_FILE, theme_name_compare, NULL, NULL);
return view;
}
static void
render_column(HybridInfo *info)
{
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
/* expander columns */
column = gtk_tree_view_column_new();
gtk_tree_view_append_column(GTK_TREE_VIEW(info->treeview), column);
gtk_tree_view_column_set_visible(column, FALSE);
gtk_tree_view_set_expander_column(GTK_TREE_VIEW(info->treeview), column);
/* main column */
column = gtk_tree_view_column_new ();
gtk_tree_view_append_column(GTK_TREE_VIEW(info->treeview), column);
gtk_tree_view_columns_autosize(GTK_TREE_VIEW(info->treeview));
/* name */
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer,
"markup", HYBRID_INFO_NAME_COLUMN,
NULL);
g_object_set(renderer, "wrap-mode", PANGO_WRAP_CHAR, NULL);
g_object_set(renderer, "wrap-width",120, NULL);
/* value */
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer,
"markup", HYBRID_INFO_VALUE_COLUMN,
"visible", HYBRID_INFO_VALUE_COLUMN_VISIBLE,
NULL);
g_object_set(renderer, "wrap-mode", PANGO_WRAP_CHAR, NULL);
g_object_set(renderer, "wrap-width",250, NULL);
/* pixbuf */
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer,
"pixbuf", HYBRID_INFO_PIXBUF_COLUMN,
"visible", HYBRID_INFO_PIXBUF_COLUMN_VISIBLE,
NULL);
}
/*
* treeview:
*/
static void
_gtk_user_list_dialog_update_tree_columns(GtkWidget *widget)
{
GtkUserListDialogPrivate *priv;
GtkTreeView *tree;
GtkTreeViewColumn *column;
g_assert(GTK_IS_DELETABLE_DIALOG(widget));
priv = GTK_USER_LIST_DIALOG(widget)->priv;
tree = GTK_TREE_VIEW(priv->tree);
column = gtk_tree_view_get_column(tree, 0);
gtk_tree_view_column_set_visible(column, priv->checkbox_column_visible);
gtk_tree_view_column_set_title(column, priv->checkbox_column_title);
column = gtk_tree_view_get_column(tree, 1);
gtk_tree_view_column_set_title(column, priv->username_column_title);
}
GtkTreeViewColumn *tree_view_column(GtkWidget *tree_view, int index, const char *title,
data_func_t data_func, unsigned int flags)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *col;
double xalign = 0.0; /* left as default */
PangoAlignment align;
gboolean visible;
align = (flags & ALIGN_LEFT) ? PANGO_ALIGN_LEFT :
(flags & ALIGN_RIGHT) ? PANGO_ALIGN_RIGHT :
PANGO_ALIGN_CENTER;
visible = !(flags & INVISIBLE);
renderer = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, title);
if (!(flags & UNSORTABLE))
gtk_tree_view_column_set_sort_column_id(col, index);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_pack_start(col, renderer, TRUE);
if (data_func)
gtk_tree_view_column_set_cell_data_func(col, renderer, data_func, (void *)(long)index, NULL);
else
gtk_tree_view_column_add_attribute(col, renderer, "text", index);
gtk_object_set(GTK_OBJECT(renderer), "alignment", align, NULL);
switch (align) {
case PANGO_ALIGN_LEFT:
xalign = 0.0;
break;
case PANGO_ALIGN_CENTER:
xalign = 0.5;
break;
case PANGO_ALIGN_RIGHT:
xalign = 1.0;
break;
}
gtk_cell_renderer_set_alignment(GTK_CELL_RENDERER(renderer), xalign, 0.5);
gtk_tree_view_column_set_visible(col, visible);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), col);
return col;
}
/**
* fill the form and set the correct buttons as active/passive
*
* \param account_number
*
* \return FALSE
* */
gboolean gsb_form_config_update_form_config ( gint account_number )
{
gint row;
gint column;
gint current_element_number;
/* fill the store */
gsb_form_config_fill_store (account_number);
/* show/hide the necessary columns in the tree view */
for ( column=0 ; column<MAX_WIDTH ; column++ )
gtk_tree_view_column_set_visible ( gtk_tree_view_get_column ( GTK_TREE_VIEW ( form_config_tree_view ),
column ),
column<gsb_data_form_get_nb_columns (account_number ));
/* active/unactive the buttons, begin on the fourth element number because the
* date, debit and credit are obligatory */
current_element_number = 4;
for ( row=0 ; row<3 ; row++ )
for ( column=0 ; column<6 ; column++ )
{
if ( column + row*6 < TRANSACTION_FORM_WIDGET_NB - 3 &&
form_config_buttons[column + row*6] )
{
g_signal_handlers_block_by_func ( G_OBJECT ( form_config_buttons[column + row*6] ),
G_CALLBACK ( gsb_form_config_toggle_element_button ),
NULL );
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON ( form_config_buttons[column + row*6] ),
gsb_data_form_look_for_value ( account_number,
current_element_number,
NULL, NULL ));
g_signal_handlers_unblock_by_func ( G_OBJECT ( form_config_buttons[column + row*6] ),
G_CALLBACK ( gsb_form_config_toggle_element_button ),
NULL );
}
current_element_number++;
}
return FALSE;
}
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 setup_tree_view (GtkWidget *treeview, Data *p)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
guint i = NUMBER;
while (i != COLUMNS)
{
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (properties[i].name, renderer, "text", i, NULL);
gtk_tree_view_column_set_resizable (column, properties[i].resizable);
gtk_tree_view_column_set_visible (column, properties[i].visible);
gtk_tree_view_column_set_reorderable (column, properties[i].reorderable);
gtk_tree_view_column_set_sort_indicator (column, properties[i].sort_indicator);
if (properties[i].reorderable)
gtk_tree_view_column_set_sort_column_id (column, i);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
i++;
}
}
static void
set_visible (GtkCellRendererToggle *cell,
gchar *path_str,
gpointer data)
{
GtkTreeView *tree_view = (GtkTreeView *) data;
GtkTreeViewColumn *column;
GtkTreeModel *model;
GtkTreeIter iter;
GtkTreePath *path = gtk_tree_path_new_from_string (path_str);
model = gtk_tree_view_get_model (tree_view);
gtk_tree_model_get_iter (model, &iter, path);
gtk_tree_model_get (model, &iter, 1, &column, -1);
if (column)
{
gtk_tree_view_column_set_visible (column, ! gtk_tree_view_column_get_visible (column));
gtk_tree_model_row_changed (model, path, &iter);
}
gtk_tree_path_free (path);
}
void create_a_column(const char *name, int num, bool visible)
{
for (int i = 0; i < 2; i++) {
GtkCellRenderer *renderer;
GtkTreeViewColumn *col;
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, name);
/* pack tree view column into tree view */
gtk_tree_view_append_column(view[i], col);
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", num);
gtk_tree_view_column_set_visible(col, visible);
}
}
static void
field_toggled (GtkCellRendererToggle *cell, gchar *path_str, gpointer data)
{
GtkTreeModel *model = static_cast<GtkTreeModel*>(data);
GtkTreePath *path = gtk_tree_path_new_from_string (path_str);
GtkTreeIter iter;
GtkTreeViewColumn *column;
gboolean toggled;
if (!path)
return;
gtk_tree_model_get_iter (model, &iter, path);
gtk_tree_model_get (model, &iter, 2, &column, -1);
toggled = gtk_cell_renderer_toggle_get_active (cell);
gtk_list_store_set (GTK_LIST_STORE (model), &iter, 0, !toggled, -1);
gtk_tree_view_column_set_visible (column, !toggled);
gtk_tree_path_free (path);
}
void library_view_col_visible(GtkCheckMenuItem* item, GObject* lview)
{
library_view_t* view = (library_view_t*) g_object_get_data(lview, "library_view_t");
if (view->column_layout_changing) {
return;
}
//long long hash = playlist_player_get_hash(backtobasics_player(view->btb));
long long hash = playlist_model_tracks_hash(view->playlist_model);
log_debug2("set column layout for hash %lld", hash);
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;
const char* name = gtk_widget_get_name(GTK_WIDGET(item));
for(i = 0; names[i] != NULL && strcmp(name, names[i]) != 0;++i);
if (names[i] != NULL) {
char cfgitem[200];
sprintf(cfgitem,"library.cols.hash_%lld.%s", hash, names[i]);
int active = gtk_check_menu_item_get_active(item);
el_config_set_int(btb_config(view->btb), cfgitem, active);
int ei = es[i];
gtk_tree_view_column_set_visible(view->cols[ei], gtk_check_menu_item_get_active(item));
}
}
static void add_columns(GtkTreeView *treeview)
{
GtkCellRenderer *rend;
GtkTreeViewColumn *column;
GtkTreeViewColumn *text_column;
/**< Column */
GtkCellRenderer *text_rend;
column = gtk_tree_view_column_new();
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
// auv gtk_tree_view_column_set_visible(column, FALSE);
gtk_tree_view_column_set_visible(column, TRUE);
gtk_tree_view_set_expander_column(GTK_TREE_VIEW(treeview), column);
rend = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, rend, FALSE);
gtk_tree_view_column_set_attributes(column, rend,
"pixbuf", STATUS_ICON_COLUMN, "visible", STATUS_ICON_VISIBLE_COLUMN, NULL);
g_object_set(rend, "xalign", 0.0, "xpad", 6, "ypad", 0, NULL);
text_rend = rend = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, rend, TRUE);
gtk_tree_view_column_set_attributes(column, rend, "markup", TITLE_COLUMN, NULL);
#if GTK_CHECK_VERSION(2,6,0)
// g_signal_connect(G_OBJECT(rend), "editing-started", G_CALLBACK(gtk_blist_renderer_editing_started_cb), NULL);
#endif
g_object_set(rend, "ypad", 0, "yalign", 0.5, NULL);
g_object_set(rend, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
rend = gtk_cell_renderer_pixbuf_new();
g_object_set(rend, "xalign", 1.0, "ypad", 0, NULL);
gtk_tree_view_column_pack_start(column, rend, FALSE);
gtk_tree_view_column_set_attributes(column, rend, "pixbuf",
RATE_ICON_COLUMN, "visible", RATE_ICON_VISIBLE_COLUMN, NULL);
}
void view_column_set_visible(const char *name, gboolean visible)
{
gtk_tree_view_column_set_visible(get_column(name), visible);
}
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 setup_view(GtkWidget* view)
{
GtkListStore* store = gtk_list_store_new (23,
G_TYPE_STRING, /* 0 Country */
G_TYPE_STRING, /* 1 Good Name */
GDK_TYPE_PIXBUF, /* 2 NULL for Status handle / empty */
G_TYPE_STRING, /* 3 User Comments */
G_TYPE_STRING, /* 4 File Name */
G_TYPE_STRING, /* 5 MD5 Hash */
G_TYPE_STRING, /* 6 CRC1 */
G_TYPE_STRING, /* 7 CRC2 */
G_TYPE_STRING, /* 8 Internal Name */
G_TYPE_STRING, /* 9 Save Type */
G_TYPE_STRING, /* 10 Players */
G_TYPE_STRING, /* 11 Size */
G_TYPE_STRING, /* 12 Compression */
G_TYPE_STRING, /* 13 Image Type */
G_TYPE_STRING, /* 14 CIC Chip */
G_TYPE_STRING, /* 15 Rumble */
GDK_TYPE_PIXBUF, /* 16-20 Pixbufs for Status stars. */
GDK_TYPE_PIXBUF,
GDK_TYPE_PIXBUF,
GDK_TYPE_PIXBUF,
GDK_TYPE_PIXBUF,
GDK_TYPE_PIXBUF, /* 21 Flag */
G_TYPE_POINTER, /* 22 RCS Entry */
-1);
GtkCellRenderer* renderer;
GtkTreeViewColumn* column;
GtkWidget* item;
char buffer[128];
int i;
unsigned char visible;
/* Create country flag / string dual rendered cell. */
renderer = gtk_cell_renderer_pixbuf_new();
g_MainWindow.column[0] = gtk_tree_view_column_new();
column = g_MainWindow.column[0];
gtk_tree_view_column_set_title(column, g_MainWindow.column_names[0][0]);
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", 21);
g_object_set(renderer, "xpad", 5, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_add_attribute(column, renderer, "text", 0);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_reorderable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, 0);
gtk_tree_view_insert_column(GTK_TREE_VIEW (view), column, 0);
g_signal_connect(column->button, "button-press-event", G_CALLBACK(callback_header_clicked), column);
renderer = gtk_cell_renderer_text_new();
g_MainWindow.column[1] = gtk_tree_view_column_new_with_attributes(g_MainWindow.column_names[1][0], renderer, "text", 1, NULL);
column = g_MainWindow.column[1];
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_reorderable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, 1);
gtk_tree_view_insert_column(GTK_TREE_VIEW (view), column, 1);
g_signal_connect(column->button, "button-press-event", G_CALLBACK(callback_header_clicked), column);
/* Status stars. */
g_MainWindow.column[2] = gtk_tree_view_column_new();
column = g_MainWindow.column[2];
gtk_tree_view_column_set_title(column, g_MainWindow.column_names[2][0]);
renderer = gtk_cell_renderer_pixbuf_new();
g_object_set(renderer, "xpad", 2, NULL);
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", 2);
for(i = 0; i < 5; ++i)
{
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", 16+i);
}
renderer = gtk_cell_renderer_pixbuf_new();
g_object_set(renderer, "xpad", 2, NULL);
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", 2);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_reorderable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, 2);
gtk_tree_view_insert_column(GTK_TREE_VIEW (view), column, 2);
g_signal_connect(column->button, "button-press-event", G_CALLBACK(callback_header_clicked), column);
for(i = 3; i < 16; ++i)
{
renderer = gtk_cell_renderer_text_new();
g_MainWindow.column[i] = gtk_tree_view_column_new_with_attributes(g_MainWindow.column_names[i][0], renderer, "text", i, NULL);
column = g_MainWindow.column[i];
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_reorderable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, i);
gtk_tree_view_insert_column(GTK_TREE_VIEW (view), column, i);
g_signal_connect(column->button, "button-press-event", G_CALLBACK(callback_header_clicked), column);
}
renderer = gtk_cell_renderer_text_new ();
g_MainWindow.column[16] = gtk_tree_view_column_new();
column = g_MainWindow.column[16];
gtk_tree_view_column_set_visible(column, FALSE);
gtk_tree_view_insert_column(GTK_TREE_VIEW(view), column, 2);
g_signal_connect(column->button, "button-press-event", G_CALLBACK(callback_header_clicked), column);
gtk_tree_view_set_model(GTK_TREE_VIEW(view), GTK_TREE_MODEL(store));
g_MainWindow.romHeaderMenu = gtk_menu_new();
/* Toggle column visibility from config file, make menu. */
for(i = 0; i < 16; ++i)
{
snprintf(buffer, sizeof(buffer), " %s", g_MainWindow.column_names[i][0]);
item = gtk_check_menu_item_new_with_mnemonic(buffer);
if((visible=config_get_bool(g_MainWindow.column_names[i][1], 2))==2)
{
visible = (i<5) ? TRUE: FALSE;
config_put_bool(g_MainWindow.column_names[i][1], visible);
}
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), visible);
gtk_tree_view_column_set_visible(g_MainWindow.column[i], visible);
gtk_menu_shell_append(GTK_MENU_SHELL(g_MainWindow.romHeaderMenu), item);
g_signal_connect(item, "activate", G_CALLBACK(callback_column_visible), GUINT_TO_POINTER(i));
}
gtk_tree_view_column_set_visible(g_MainWindow.column[16], FALSE);
for(i = 0; i < 16; ++i)
{
if(gtk_tree_view_column_get_visible(GTK_TREE_VIEW_COLUMN(g_MainWindow.column[i])))
return;
}
gtk_tree_view_column_set_visible(g_MainWindow.column[16], TRUE);
}
/*
* init breaks tree view and return it if succesfull
* arguments:
* cb - callback to call on treeview double click
*/
gboolean bptree_init(move_to_line_cb cb)
{
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
/* save double click callback */
on_break_clicked = cb;
/* crete hash table for file nodes */
files = g_hash_table_new_full(
g_str_hash,
g_str_equal,
(GDestroyNotify)g_free,
(GDestroyNotify)gtk_tree_row_reference_free
);
/* create tree view */
store = gtk_tree_store_new (
N_COLUMNS,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_INT,
G_TYPE_INT,
G_TYPE_BOOLEAN,
G_TYPE_STRING);
model = GTK_TREE_MODEL(store);
tree = gtk_tree_view_new_with_model (model);
g_object_unref(store);
/* set tree view properties */
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), 1);
gtk_widget_set_has_tooltip(GTK_WIDGET(tree), TRUE);
/* multiple selection */
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
/* connect signals */
g_signal_connect(G_OBJECT(tree), "key-press-event", G_CALLBACK (on_key_pressed), NULL);
g_signal_connect(G_OBJECT(tree), "row-activated", G_CALLBACK (on_row_double_click), NULL);
g_signal_connect(G_OBJECT(tree), "query-tooltip", G_CALLBACK (on_query_tooltip), NULL);
/* creating columns */
/* icon, file */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new();
gtk_tree_view_column_pack_end(column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, on_render_filename, NULL, NULL);
/* enable for file */
renderer = cell_renderer_toggle_new ();
g_signal_connect (G_OBJECT(renderer), "toggled", G_CALLBACK(on_enable_for_file), NULL);
gtk_tree_view_column_pack_end(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer, "active", ENABLED, NULL);
gtk_tree_view_column_set_cell_data_func(column, renderer, on_render_enable_for_file, NULL, NULL);
/* enable breakpoint */
renderer = cell_renderer_break_icon_new ();
g_signal_connect (G_OBJECT(renderer), "clicked", G_CALLBACK(on_enable_break), NULL);
g_object_set(renderer, "pixbuf_enabled", (gpointer)break_pixbuf, NULL);
g_object_set(renderer, "pixbuf_disabled", (gpointer)break_disabled_pixbuf, NULL);
g_object_set(renderer, "pixbuf_conditional", (gpointer)break_condition_pixbuf, NULL);
g_object_set(renderer, "pixbuf_file", (gpointer)break_pixbuf, NULL);
gtk_tree_view_column_pack_end(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer, "enabled", ENABLED, "condition", CONDITION, "hitscount", HITSCOUNT, NULL);
gtk_tree_view_column_set_cell_data_func(column, renderer, on_render_enable_break, NULL, NULL);
gtk_tree_view_column_set_title(column, _("Location"));
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* condition */
condition_renderer = gtk_cell_renderer_text_new ();
g_object_set (condition_renderer, "editable", TRUE, NULL);
g_object_set (condition_renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
g_signal_connect (G_OBJECT (condition_renderer), "edited", G_CALLBACK (on_condition_changed), NULL);
column = gtk_tree_view_column_new_with_attributes (_("Condition"), condition_renderer, "text", CONDITION, NULL);
gtk_tree_view_column_set_cell_data_func(column, condition_renderer, on_render, NULL, NULL);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* hits count */
hcount_renderer = gtk_cell_renderer_spin_new ();
g_object_set (hcount_renderer,
"adjustment", gtk_adjustment_new (0.0, 0.0, 100000.0, 1.0, 2.0, 2.0),
"digits", 0, NULL);
g_signal_connect (G_OBJECT (hcount_renderer), "edited", G_CALLBACK (on_hitscount_changed), NULL);
column = gtk_tree_view_column_new_with_attributes (_("Hit count"), hcount_renderer, "text", HITSCOUNT, NULL);
gtk_tree_view_column_set_cell_data_func(column, hcount_renderer, on_render, (gpointer)TRUE, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* line */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Line"), renderer, "text", LINE, NULL);
gtk_tree_view_column_set_visible(column, FALSE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
/* Last invisible column */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("", renderer, "text", LAST_VISIBLE, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
tab_breaks = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (tab_breaks);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (tab_breaks), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (tab_breaks), GTK_SHADOW_NONE);
gtk_container_add (GTK_CONTAINER (tab_breaks), tree);
return TRUE;
}
