void
baobab_treeview_show_allocated_size (GtkWidget *tv,
gboolean show_allocated)
{
gint sort_id;
gint new_sort_id;
GtkSortType order;
GtkTreeViewColumn *size_col;
g_return_if_fail (GTK_IS_TREE_VIEW (tv));
gtk_tree_sortable_get_sort_column_id (GTK_TREE_SORTABLE (baobab.model),
&sort_id, &order);
/* set the sort id for the size column */
size_col = g_object_get_data (G_OBJECT (tv), "baobab_size_col");
new_sort_id = show_allocated ? COL_H_ALLOCSIZE : COL_H_SIZE;
gtk_tree_view_column_set_sort_column_id (size_col, new_sort_id);
/* if we are currently sorted on size or allocated size,
* then trigger a resort (with the same order) */
if (sort_id == COL_H_SIZE || sort_id == COL_H_ALLOCSIZE) {
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (baobab.model),
new_sort_id, order);
}
}
void
itemlist_sort_column_changed_cb (GtkTreeSortable *treesortable, gpointer user_data)
{
gint sortColumn, nodeSort;
GtkSortType sortType;
gboolean sorted, changed;
if (feedlist_get_selected () == NULL)
return;
sorted = gtk_tree_sortable_get_sort_column_id (treesortable, &sortColumn, &sortType);
if (!sorted)
return;
switch (sortColumn) {
case IS_TIME:
default:
nodeSort = NODE_VIEW_SORT_BY_TIME;
break;
case IS_LABEL:
nodeSort = NODE_VIEW_SORT_BY_TITLE;
break;
case IS_STATE:
nodeSort = NODE_VIEW_SORT_BY_STATE;
break;
case IS_PARENT:
case IS_SOURCE:
nodeSort = NODE_VIEW_SORT_BY_PARENT;
break;
}
changed = node_set_sort_column (feedlist_get_selected (), nodeSort, sortType == GTK_SORT_DESCENDING);
if (changed)
feedlist_schedule_save ();
}
/* Called when the column sort is changed */
static void
on_sort_column_changed (GtkTreeSortable *sort,
gpointer user_data)
{
SeahorseKeyManagerStore *self = SEAHORSE_KEY_MANAGER_STORE (user_data);
GtkSortType ord;
gchar* value;
gint column_id;
if (!self->priv->settings)
return;
/* We have a sort so save it */
if (gtk_tree_sortable_get_sort_column_id (GTK_TREE_SORTABLE (self), &column_id, &ord)) {
if (column_id >= 0 && column_id < N_COLS) {
if (columns[column_id].user_data != NULL) {
value = g_strconcat (ord == GTK_SORT_DESCENDING ? "-" : "",
columns[column_id].user_data, NULL);
g_settings_set_string (self->priv->settings, "sort-by", value);
g_free (value);
}
}
/* No sort so save blank */
} else if (self->priv->settings) {
g_settings_set_string (self->priv->settings, "sort-by", "");
}
}
static void column_clicked(GtkTreeViewColumn *column, gpointer user_data)
{
GtkTreeView *tree_view = GTK_TREE_VIEW(user_data);
GtkTreeModel *model;
gint column_id;
gint cur_id;
GtkSortType order;
GtkTreeViewColumn *cur_column;
GtkTreeViewColumn *button;
if (gtk_widget_is_focus(GTK_WIDGET(tree_view)) == FALSE) {
gtk_widget_grab_focus(GTK_WIDGET(tree_view));
}
column_id = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(column), "column_id"));
model = gtk_tree_view_get_model(tree_view);
/* 現在のソート列と同じときは昇順／降順を反転する、違うときはクリックした列で昇順ソートする */
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);
}
void
mtscan_model_disable_sorting(mtscan_model_t *model)
{
if(gtk_tree_sortable_get_sort_column_id(GTK_TREE_SORTABLE(model->store), &model->last_sort_column, &model->last_sort_order))
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(model->store), GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID, model->last_sort_order);
model->disabled_sorting = TRUE;
}
static gint
files_modified_column_sort_func (GtkTreeModel *model,
GtkTreeIter *a,
GtkTreeIter *b,
gpointer user_data)
{
GtkSortType sort_order;
glong modified_a;
glong modified_b;
gboolean is_folder_a;
gboolean is_folder_b;
int result;
gtk_tree_sortable_get_sort_column_id (GTK_TREE_SORTABLE (model), NULL, &sort_order);
gtk_tree_model_get (model, a,
FILE_LIST_COLUMN_MODIFIED_ORDER, &modified_a,
FILE_LIST_COLUMN_IS_FOLDER, &is_folder_a,
-1);
gtk_tree_model_get (model, b,
FILE_LIST_COLUMN_MODIFIED_ORDER, &modified_b,
FILE_LIST_COLUMN_IS_FOLDER, &is_folder_b,
-1);
if (is_folder_a == is_folder_b) {
result = modified_a - modified_b;
}
else {
result = is_folder_a ? -1 : 1;
if (sort_order == GTK_SORT_DESCENDING)
result = -1 * result;
}
return result;
}
/* Sort changed callback */
static void
gnc_split_reg2_sort_changed_cb (GtkTreeSortable *sortable, gpointer user_data)
{
GNCSplitReg2 *gsr = user_data;
GncTreeViewSplitReg *view;
GncTreeModelSplitReg *model;
GtkSortType type;
gint sortcol;
gint sort_depth;
const gchar *state_section;
GKeyFile *state_file = gnc_state_get_current();
gtk_tree_sortable_get_sort_column_id (sortable, &sortcol, &type);
ENTER("sortcol is %d", sortcol);
view = gnc_ledger_display2_get_split_view_register (gsr->ledger);
model = gnc_ledger_display2_get_split_model_register (gsr->ledger);
sort_depth = gnc_tree_view_reg_get_selected_row_depth (view);
if (sort_depth != 0)
model->sort_depth = sort_depth;
model->sort_col = sortcol;
model->sort_direction = type;
/* Save the sort depth state */
state_section = gnc_tree_view_get_state_section (GNC_TREE_VIEW (view));
g_key_file_set_integer (state_file, state_section, "sort_depth", model->sort_depth);
LEAVE("m_sort_col %d, m_sort_direction is %d m_sort_depth is %d", model->sort_col, model->sort_direction, model->sort_depth);
if (sortcol != -1)
gnc_ledger_display2_refresh (gsr->ledger);
}
static gboolean
gsltma_get_sort_column_id(GtkTreeSortable *sortable,
gint *sort_column_id,
GtkSortType *order)
{
return gtk_tree_sortable_get_sort_column_id(GTK_TREE_SORTABLE(GNC_SX_LIST_TREE_MODEL_ADAPTER(sortable)->real),
sort_column_id,
order);
}
static void remmina_main_file_model_on_sort(GtkTreeSortable *sortable, RemminaMain *remminamain)
{
gint columnid;
GtkSortType order;
gtk_tree_sortable_get_sort_column_id(sortable, &columnid, &order);
remmina_pref.main_sort_column_id = columnid;
remmina_pref.main_sort_order = order;
remmina_pref_save();
}
void on_sort_col_changed(GtkTreeSortable* sortable, FmFolderView* fv)
{
int col;
GtkSortType order;
if(gtk_tree_sortable_get_sort_column_id(sortable, &col, &order))
{
fv->sort_by = col;
fv->sort_type = order;
g_signal_emit(fv, signals[SORT_CHANGED], 0);
}
}
/**
* Manage the tri-state sorting status on the column.
*
* @param column the clicked column in the tree-view
* @param ctx the sorting context we are managing
*/
void
column_sort_tristate(GtkTreeViewColumn *column, struct sorting_context *ctx)
{
#if GTK_CHECK_VERSION(2,6,0)
GtkTreeModel *model;
GtkTreeSortable *sortable;
int sort_col;
model = gtk_tree_view_get_model(GTK_TREE_VIEW(column->tree_view));
sortable = GTK_TREE_SORTABLE(model);
gtk_tree_sortable_get_sort_column_id(sortable, &sort_col, NULL);
/* If the user switched to another sort column, reset the sort order */
if (ctx->s_column != sort_col) {
ctx->s_order = SORT_NONE;
}
ctx->s_column = sort_col;
/* Tri-state permutation of the sorting order */
switch (ctx->s_order) {
case SORT_NONE:
case SORT_NO_COL:
ctx->s_order = SORT_ASC;
break;
case SORT_ASC:
ctx->s_order = SORT_DESC;
break;
case SORT_DESC:
ctx->s_order = SORT_NONE;
break;
}
/* Enforce sorting order */
switch (ctx->s_order) {
case SORT_NONE:
ctx->s_column = GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID;
/* FALL THROUGH */
case SORT_DESC:
gtk_tree_sortable_set_sort_column_id(sortable,
ctx->s_column, GTK_SORT_DESCENDING);
break;
case SORT_ASC:
gtk_tree_sortable_set_sort_column_id(sortable,
ctx->s_column, GTK_SORT_ASCENDING);
break;
case SORT_NO_COL:
g_assert_not_reached();
}
#endif /* GTK+ >= 2.6.0 */
}
static gboolean
search_gui_is_sorted(struct search *search)
{
GtkTreeModel *model;
GtkTreeSortable *sortable;
g_return_val_if_fail(search, FALSE);
model = gtk_tree_view_get_model(GTK_TREE_VIEW(search->tree));
sortable = GTK_TREE_SORTABLE(model);
return gtk_tree_sortable_get_sort_column_id(sortable, NULL, NULL);
}
static void trg_tree_view_sort_menu_type_toggled(GtkCheckMenuItem * w,
gpointer data)
{
GtkTreeSortable *model = GTK_TREE_SORTABLE(data);
if (gtk_check_menu_item_get_active(w)) {
gint sortColumn;
gint sortType =
GPOINTER_TO_INT(g_object_get_data(G_OBJECT(w), "sort-type"));
gtk_tree_sortable_get_sort_column_id(model, &sortColumn, NULL);
gtk_tree_sortable_set_sort_column_id(model, sortColumn, sortType);
}
}
static void trg_tree_view_sort_menu_item_toggled(GtkCheckMenuItem * w,
gpointer data)
{
GtkTreeSortable *model = GTK_TREE_SORTABLE(data);
trg_column_description *desc =
(trg_column_description *) g_object_get_data(G_OBJECT(w),
GDATA_KEY_COLUMN_DESC);
if (gtk_check_menu_item_get_active(w)) {
GtkSortType sortType;
gtk_tree_sortable_get_sort_column_id(model, NULL, &sortType);
gtk_tree_sortable_set_sort_column_id(model, desc->model_column,
sortType);
}
}
static gint
files_size_column_sort_func (GtkTreeModel *model,
GtkTreeIter *a,
GtkTreeIter *b,
gpointer user_data)
{
GtkSortType sort_order;
char *key_a;
char *key_b;
gint64 size_a;
gint64 size_b;
gboolean is_folder_a;
gboolean is_folder_b;
int result;
gtk_tree_sortable_get_sort_column_id (GTK_TREE_SORTABLE (model), NULL, &sort_order);
gtk_tree_model_get (model, a,
FILE_LIST_COLUMN_NAME_ORDER, &key_a,
FILE_LIST_COLUMN_SIZE_ORDER, &size_a,
FILE_LIST_COLUMN_IS_FOLDER, &is_folder_a,
-1);
gtk_tree_model_get (model, b,
FILE_LIST_COLUMN_NAME_ORDER, &key_b,
FILE_LIST_COLUMN_SIZE_ORDER, &size_b,
FILE_LIST_COLUMN_IS_FOLDER, &is_folder_b,
-1);
if (is_folder_a == is_folder_b) {
if (is_folder_a) {
result = strcmp (key_a, key_b);
if (sort_order == GTK_SORT_DESCENDING)
result = -1 * result;
}
else
result = size_a - size_b;
}
else {
result = is_folder_a ? -1 : 1;
if (sort_order == GTK_SORT_DESCENDING)
result = -1 * result;
}
g_free (key_a);
g_free (key_b);
return result;
}
/*
* Disable Search Stats sorting.
*/
static void
search_stats_gui_disable_sort(void)
{
#if GTK_CHECK_VERSION(2,6,0)
GtkTreeSortable *sortable;
GtkSortType order;
int column;
sortable = GTK_TREE_SORTABLE(store_search_stats);
if (gtk_tree_sortable_get_sort_column_id(sortable, &column, &order)) {
gtk_tree_sortable_set_sort_column_id(sortable,
GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID,
GTK_SORT_DESCENDING);
}
#endif /* Gtk+ >= 2.6.0 */
}
static void
search_gui_disable_sort(struct search *search)
{
if (search && search->sort) {
#if GTK_CHECK_VERSION(2,6,0)
GtkTreeModel *model;
GtkTreeSortable *sortable;
model = gtk_tree_view_get_model(GTK_TREE_VIEW(search->tree));
sortable = GTK_TREE_SORTABLE(model);
if (gtk_tree_sortable_get_sort_column_id(sortable, NULL, NULL)) {
gtk_tree_sortable_set_sort_column_id(sortable,
GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID, GTK_SORT_DESCENDING);
}
#endif /* Gtk+ >= 2.6.0 */
}
}
static gint
sort_connection_types (GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer user_data)
{
GtkTreeSortable *sortable = user_data;
int order_a, order_b;
GtkSortType order;
gtk_tree_model_get (model, a, COL_ORDER, &order_a, -1);
gtk_tree_model_get (model, b, COL_ORDER, &order_b, -1);
/* The connection types should stay in the same order regardless of whether
* the table is sorted ascending or descending.
*/
gtk_tree_sortable_get_sort_column_id (sortable, NULL, &order);
if (order == GTK_SORT_ASCENDING)
return order_a - order_b;
else
return order_b - order_a;
}
static void
fi_gui_files_sort_save(void)
{
#if GTK_CHECK_VERSION(2,6,0)
if (0 == files_sort_depth++) {
GtkTreeSortable *sortable;
GtkSortType order;
int column;
sortable = GTK_TREE_SORTABLE(store_files);
if (gtk_tree_sortable_get_sort_column_id(sortable, &column, &order)) {
files_sort_column = column;
files_sort_order = order;
gtk_tree_sortable_set_sort_column_id(sortable,
GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID, order);
}
}
#endif /* Gtk+ => 2.6.0 */
}
static void
draw_gtk_tree(void *psp)
{
stats_tree *st = (stats_tree *)psp;
stat_node *child;
int count;
gint sort_column = GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID;
GtkSortType order = GTK_SORT_DESCENDING;
for (count = 0; count<st->num_columns; count++) {
gtk_tree_view_column_set_title(gtk_tree_view_get_column(GTK_TREE_VIEW(st->pr->tree),count),
stats_tree_get_column_name(count));
}
gtk_tree_sortable_get_sort_column_id (GTK_TREE_SORTABLE (st->pr->store), &sort_column, &order);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (st->pr->store),
GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID, GTK_SORT_DESCENDING);
for (child = st->root.children; child; child = child->next ) {
draw_gtk_node(child);
if ( (!(child->st_flags&ST_FLG_DEF_NOEXPAND)) && child->pr->iter && st->pr->store ) {
gtk_tree_view_expand_row(GTK_TREE_VIEW(st->pr->tree),
gtk_tree_model_get_path(GTK_TREE_MODEL(st->pr->store),child->pr->iter),
FALSE);
}
}
if ((sort_column==GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID)||
(sort_column==GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID)) {
sort_column= stats_tree_get_default_sort_col(st)+N_RESERVED_COL;
order= stats_tree_is_default_sort_DESC(st)?GTK_SORT_DESCENDING:GTK_SORT_ASCENDING;
}
/* Only call this once the entire list is drawn - else Gtk seems */
/* to get sorting order wrong (sorting broken when new nodes are */
/* added after setting sort column.) Also for performance. */
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (st->pr->store), sort_column, order);
}
static void
sort_changed (GtkTreeSortable *sort, CryptUIKeyStore *ckstore)
{
gint id;
GtkSortType ord;
const gchar *name = NULL;
gchar *x;
if (!ckstore->priv->sortable)
return;
if (gtk_tree_sortable_get_sort_column_id (sort, &id, &ord)) {
if (id == CRYPTUI_KEY_STORE_NAME)
name = "name";
else if (id == CRYPTUI_KEY_STORE_KEYID)
name = "id";
}
x = g_strconcat (ord == GTK_SORT_DESCENDING ? "-" : "", name ? name : "", NULL);
_cryptui_gconf_set_string (SEAHORSE_RECIPIENTS_SORT_KEY, x);
g_free (x);
}
void trg_tree_view_persist(TrgTreeView * tv, guint flags)
{
JsonObject *props = trg_prefs_get_tree_view_props(tv);
GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(tv));
GList *cols, *li;
JsonArray *widths, *columns;
gint sort_column_id;
GtkSortType sort_type;
if (flags & TRG_TREE_VIEW_PERSIST_SORT) {
gtk_tree_sortable_get_sort_column_id(GTK_TREE_SORTABLE
((flags &
TRG_TREE_VIEW_SORTABLE_PARENT)
?
gtk_tree_model_filter_get_model
(GTK_TREE_MODEL_FILTER
(model)) : model),
&sort_column_id, &sort_type);
if (json_object_has_member(props, TRG_PREFS_KEY_TV_SORT_COL))
json_object_remove_member(props, TRG_PREFS_KEY_TV_SORT_COL);
if (json_object_has_member(props, TRG_PREFS_KEY_TV_SORT_TYPE))
json_object_remove_member(props, TRG_PREFS_KEY_TV_SORT_TYPE);
json_object_set_int_member(props, TRG_PREFS_KEY_TV_SORT_COL,
(gint64) sort_column_id);
json_object_set_int_member(props, TRG_PREFS_KEY_TV_SORT_TYPE,
(gint64) sort_type);
}
if (flags & TRG_TREE_VIEW_PERSIST_LAYOUT) {
cols = gtk_tree_view_get_columns(GTK_TREE_VIEW(tv));
if (json_object_has_member(props, TRG_PREFS_KEY_TV_WIDTHS))
json_object_remove_member(props, TRG_PREFS_KEY_TV_WIDTHS);
widths = json_array_new();
json_object_set_array_member(props, TRG_PREFS_KEY_TV_WIDTHS,
widths);
if (json_object_has_member(props, TRG_PREFS_KEY_TV_COLUMNS))
json_object_remove_member(props, TRG_PREFS_KEY_TV_COLUMNS);
columns = json_array_new();
json_object_set_array_member(props, TRG_PREFS_KEY_TV_COLUMNS,
columns);
for (li = cols; li; li = g_list_next(li)) {
GtkTreeViewColumn *col = (GtkTreeViewColumn *) li->data;
trg_column_description *desc =
g_object_get_data(G_OBJECT(li->data),
GDATA_KEY_COLUMN_DESC);
json_array_add_string_element(columns, desc->id);
json_array_add_int_element(widths,
gtk_tree_view_column_get_width
(col));
}
g_list_free(cols);
}
}
GtkWidget*
listview__new()
{
//the main pane. A treeview with a list of samples.
LibraryView* lv = app->libraryview = g_new0(LibraryView, 1);
lv->scroll = scrolled_window_new();
GtkWidget* view = app->libraryview->widget = gtk_tree_view_new_with_model(GTK_TREE_MODEL(samplecat.store));
gtk_container_add(GTK_CONTAINER(lv->scroll), view);
g_signal_connect(view, "realize", G_CALLBACK(listview__on_realise), NULL);
g_signal_connect(view, "motion-notify-event", (GCallback)listview__on_motion, NULL);
g_signal_connect(view, "drag-data-received", G_CALLBACK(listview__drag_received), NULL); //currently the window traps this before we get here.
g_signal_connect(view, "drag-motion", G_CALLBACK(drag_motion), NULL);
#if 0 // TODO why does this not work?
gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(view), TRUE);
#endif
//set up as dnd source:
gtk_drag_source_set(view, GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
dnd_file_drag_types, dnd_file_drag_types_count,
GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_ASK);
g_signal_connect(G_OBJECT(view), "drag_data_get", G_CALLBACK(listview__dnd_get), NULL);
//icon:
GtkCellRenderer* cell9 = gtk_cell_renderer_pixbuf_new();
GtkTreeViewColumn* col9 /*= app->col_icon*/ = gtk_tree_view_column_new_with_attributes("", cell9, "pixbuf", COL_ICON, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col9);
//g_object_set(cell4, "cell-background", "Orange", "cell-background-set", TRUE, NULL);
g_object_set(G_OBJECT(cell9), "xalign", 0.0, NULL);
gtk_tree_view_column_set_resizable(col9, TRUE);
gtk_tree_view_column_set_min_width(col9, 0);
gtk_tree_view_column_set_cell_data_func(col9, cell9, listview__cell_data_bg, NULL, NULL);
#ifdef SHOW_INDEX
GtkCellRenderer* cell0 = gtk_cell_renderer_text_new();
GtkTreeViewColumn* col0 = gtk_tree_view_column_new_with_attributes("Id", cell0, "text", COL_IDX, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col0);
#endif
GtkCellRenderer* cell1 = lv->cells.name = gtk_cell_renderer_text_new();
GtkTreeViewColumn* col1 = lv->col_name = gtk_tree_view_column_new_with_attributes("Sample Name", cell1, "text", COL_NAME, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col1);
gtk_tree_view_column_set_sort_column_id(col1, COL_NAME);
gtk_tree_view_column_set_reorderable(col1, TRUE);
gtk_tree_view_column_set_min_width(col1, 0);
//gtk_tree_view_column_set_spacing(col1, 10);
//g_object_set(cell1, "ypad", 0, NULL);
gtk_tree_view_column_set_cell_data_func(col1, cell1, (gpointer)listview__cell_data_bg, NULL, NULL);
//gtk_tree_view_column_set_cell_data_func(col1, cell1, (gpointer)cell_bg_lighter, NULL, NULL);
gtk_tree_view_column_set_sizing(col1, GTK_TREE_VIEW_COLUMN_FIXED);
int width = atoi(app->config.column_widths[0]);
if(width > 0) gtk_tree_view_column_set_fixed_width(col1, MAX(width, 30)); //FIXME set range in config section instead.
else gtk_tree_view_column_set_fixed_width(col1, 130);
GtkCellRenderer* cell2 = gtk_cell_renderer_text_new();
GtkTreeViewColumn* col2 = lv->col_path = gtk_tree_view_column_new_with_attributes("Path", cell2, "text", COL_FNAME, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col2);
gtk_tree_view_column_set_sort_column_id(col2, COL_FNAME);
//gtk_tree_view_column_set_resizable(col2, FALSE);
gtk_tree_view_column_set_reorderable(col2, TRUE);
gtk_tree_view_column_set_min_width(col2, 0);
//g_object_set(cell2, "ypad", 0, NULL);
gtk_tree_view_column_set_cell_data_func(col2, cell2, listview__path_cell_data, NULL, NULL);
#ifdef USE_AYYI
//icon that shows when file is in current active song.
GtkCellRenderer* ayyi_renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(col2, ayyi_renderer, FALSE);
gtk_tree_view_column_add_attribute(col2, ayyi_renderer, "pixbuf", COL_AYYI_ICON);
//gtk_tree_view_column_set_cell_data_func(col2, ayyi_renderer, vdtree_color_cb, vdt, NULL);
#endif
gtk_tree_view_column_set_sizing(col2, GTK_TREE_VIEW_COLUMN_FIXED);
width = atoi(app->config.column_widths[1]);
if(width > 0) gtk_tree_view_column_set_fixed_width(col2, MAX(width, 30));
else gtk_tree_view_column_set_fixed_width(col2, 130);
//GtkCellRenderer *cell3 /*= app->cell_tags*/ = gtk_cell_renderer_text_new();
GtkCellRenderer* cell3 = lv->cells.tags = gtk_cell_renderer_hyper_text_new();
GtkTreeViewColumn* column3 = lv->col_tags = gtk_tree_view_column_new_with_attributes("Tags", cell3, "text", COL_KEYWORDS, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), column3);
gtk_tree_view_column_set_sort_column_id(column3, COL_KEYWORDS);
gtk_tree_view_column_set_resizable(column3, TRUE);
gtk_tree_view_column_set_reorderable(column3, TRUE);
gtk_tree_view_column_set_min_width(column3, 0);
g_object_set(cell3, "editable", TRUE, NULL);
g_signal_connect(cell3, "edited", (GCallback)listview__on_keywords_edited, NULL);
gtk_tree_view_column_add_attribute(column3, cell3, "markup", COL_KEYWORDS);
gtk_tree_view_column_set_cell_data_func(column3, cell3, listview__tag_cell_data, NULL, NULL);
GtkCellRenderer* cell4 = gtk_cell_renderer_pixbuf_new();
GtkTreeViewColumn* col4 = lv->col_pixbuf = gtk_tree_view_column_new_with_attributes("Overview", cell4, "pixbuf", COL_OVERVIEW, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col4);
//g_object_set(cell4, "cell-background", "Orange", "cell-background-set", TRUE, NULL);
g_object_set(G_OBJECT(cell4), "xalign", 0.0, NULL);
gtk_tree_view_column_set_resizable(col4, TRUE);
gtk_tree_view_column_set_min_width(col4, 0);
//g_object_set(cell4, "ypad", 0, NULL);
gtk_tree_view_column_set_cell_data_func(col4, cell4, listview__cell_data_bg, NULL, NULL);
GtkCellRenderer* cell5 = gtk_cell_renderer_text_new();
GtkTreeViewColumn* col5 = gtk_tree_view_column_new_with_attributes("Length", cell5, "text", COL_LENGTH, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col5);
gtk_tree_view_column_set_sort_column_id(col5, COL_LEN);
gtk_tree_view_column_set_resizable(col5, TRUE);
gtk_tree_view_column_set_reorderable(col5, TRUE);
gtk_tree_view_column_set_min_width(col5, 0);
g_object_set(G_OBJECT(cell5), "xalign", 1.0, NULL);
//g_object_set(cell5, "ypad", 0, NULL);
gtk_tree_view_column_set_cell_data_func(col5, cell5, listview__cell_data_bg, NULL, NULL);
GtkCellRenderer* cell6 = gtk_cell_renderer_text_new();
GtkTreeViewColumn* col6 = gtk_tree_view_column_new_with_attributes("Srate", cell6, "text", COL_SAMPLERATE, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col6);
gtk_tree_view_column_set_resizable(col6, TRUE);
gtk_tree_view_column_set_reorderable(col6, TRUE);
gtk_tree_view_column_set_min_width(col6, 0);
g_object_set(G_OBJECT(cell6), "xalign", 1.0, NULL);
//g_object_set(cell6, "ypad", 0, NULL);
gtk_tree_view_column_set_cell_data_func(col6, cell6, listview__cell_data_bg, NULL, NULL);
GtkCellRenderer* cell7 = gtk_cell_renderer_text_new();
GtkTreeViewColumn* col7 = gtk_tree_view_column_new_with_attributes("Chs", cell7, "text", COL_CHANNELS, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col7);
gtk_tree_view_column_set_resizable(col7, TRUE);
gtk_tree_view_column_set_reorderable(col7, TRUE);
gtk_tree_view_column_set_min_width(col7, 0);
g_object_set(G_OBJECT(cell7), "xalign", 1.0, NULL);
gtk_tree_view_column_set_cell_data_func(col7, cell7, listview__cell_data_bg, NULL, NULL);
GtkCellRenderer* cell8 = gtk_cell_renderer_text_new();
GtkTreeViewColumn* col8 = gtk_tree_view_column_new_with_attributes("Mimetype", cell8, "text", COL_MIMETYPE, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col8);
gtk_tree_view_column_set_resizable(col8, TRUE);
gtk_tree_view_column_set_reorderable(col8, TRUE);
gtk_tree_view_column_set_min_width(col8, 0);
//g_object_set(G_OBJECT(cell8), "xalign", 1.0, NULL);
gtk_tree_view_column_set_cell_data_func(col8, cell8, listview__cell_data_bg, NULL, NULL);
GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(view), COL_NAME);
g_signal_connect((gpointer)view, "button-press-event", G_CALLBACK(listview__on_row_clicked), NULL);
g_signal_connect((gpointer)view, "cursor-changed", G_CALLBACK(listview__on_cursor_change), NULL);
g_signal_connect(G_OBJECT(samplecat.store), "content-changed", G_CALLBACK(listview__on_store_changed), NULL);
#if 0
void on_unrealize(GtkWidget* widget, gpointer user_data)
{
PF0;
}
g_signal_connect((gpointer)view, "unrealize", G_CALLBACK(on_unrealize), NULL);
#endif
void listview_on_play(GObject* _app, gpointer _)
{
if(app->play.sample->row_ref){
listview__highlight_playing_by_ref(app->play.sample->row_ref);
}
}
g_signal_connect(app, "play-start", (GCallback)listview_on_play, NULL);
void on_sort_order_changed(GtkTreeSortable* sortable, gpointer user_data)
{
gint sort_column_id;
GtkSortType order;
if(gtk_tree_sortable_get_sort_column_id(sortable, &sort_column_id, &order)){
if(sort_column_id == COL_LEN){
int n_rows = ((SamplecatListStore*)samplecat.store)->row_count;
if(n_rows >= LIST_STORE_MAX_ROWS){
dbg(0, "TODO need to requery database ordered by length...");
}
}
}
}
GtkWidget *trg_tree_view_sort_menu(TrgTreeView * tv, const gchar * label)
{
TrgTreeViewPrivate *priv = TRG_TREE_VIEW_GET_PRIVATE(tv);
GtkWidget *item = gtk_menu_item_new_with_mnemonic(label);
GtkTreeModel *treeViewModel =
gtk_tree_view_get_model(GTK_TREE_VIEW(tv));
GtkTreeSortable *sortableModel =
GTK_TREE_SORTABLE(gtk_tree_model_filter_get_model
(GTK_TREE_MODEL_FILTER(treeViewModel)));
GtkWidget *menu = gtk_menu_new();
GtkWidget *b;
GList *li;
gint sort;
GtkSortType sortType;
GSList *group = NULL;
gtk_tree_sortable_get_sort_column_id(sortableModel, &sort, &sortType);
b = gtk_radio_menu_item_new_with_label(group, _("Ascending"));
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(b),
sortType == GTK_SORT_ASCENDING);
g_object_set_data(G_OBJECT(b), "sort-type",
GINT_TO_POINTER(GTK_SORT_ASCENDING));
g_signal_connect(b, "toggled",
G_CALLBACK(trg_tree_view_sort_menu_type_toggled),
sortableModel);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), b);
group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(b));
b = gtk_radio_menu_item_new_with_label(group, _("Descending"));
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(b),
sortType == GTK_SORT_DESCENDING);
g_object_set_data(G_OBJECT(b), "sort-type",
GINT_TO_POINTER(GTK_SORT_DESCENDING));
g_signal_connect(b, "toggled",
G_CALLBACK(trg_tree_view_sort_menu_type_toggled),
sortableModel);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), b);
group = NULL;
gtk_menu_shell_append(GTK_MENU_SHELL(menu),
gtk_separator_menu_item_new());
for (li = priv->columns; li; li = g_list_next(li)) {
trg_column_description *desc = (trg_column_description *) li->data;
if (!(desc->flags & TRG_COLUMN_HIDE_FROM_TOP_MENU)) {
b = gtk_radio_menu_item_new_with_label(group, desc->header);
group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(b));
if (desc->model_column == sort)
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(b),
TRUE);
g_object_set_data(G_OBJECT(b), GDATA_KEY_COLUMN_DESC, desc);
g_signal_connect(b, "toggled",
G_CALLBACK
(trg_tree_view_sort_menu_item_toggled),
sortableModel);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), b);
}
}
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), menu);
return item;
}
/*
* Create a new commodity tree view with (optional) top level root node.
* This view will be based on a model that is common to all view of
* the same set of books, but will have its own private filter on that
* model.
*/
GtkTreeView *
gnc_tree_view_commodity_new (QofBook *book,
const gchar *first_property_name,
...)
{
GncTreeView *view;
GtkTreeModel *model, *f_model, *s_model;
GtkTreeViewColumn *col;
gnc_commodity_table *ct;
va_list var_args;
ENTER(" ");
/* Create/get a pointer to the existing model for this set of books. */
ct = gnc_commodity_table_get_table (book);
model = gnc_tree_model_commodity_new (book, ct);
/* Set up the view private filter on the common model. */
f_model = gtk_tree_model_filter_new (model, NULL);
g_object_unref(G_OBJECT(model));
s_model = gtk_tree_model_sort_new_with_model (f_model);
g_object_unref(G_OBJECT(f_model));
/* Create our view */
view = g_object_new (GNC_TYPE_TREE_VIEW_COMMODITY,
"name", "commodity_tree", NULL);
gtk_tree_view_set_model (GTK_TREE_VIEW (view), s_model);
g_object_unref(G_OBJECT(s_model));
DEBUG("model ref count is %d", G_OBJECT(model)->ref_count);
DEBUG("f_model ref count is %d", G_OBJECT(f_model)->ref_count);
DEBUG("s_model ref count is %d", G_OBJECT(s_model)->ref_count);
/* Set default visibilities */
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(view), FALSE);
col = gnc_tree_view_add_text_column (
view, _("Namespace"), "namespace", NULL, "NASDAQ",
GNC_TREE_MODEL_COMMODITY_COL_NAMESPACE,
GNC_TREE_VIEW_COLUMN_VISIBLE_ALWAYS,
sort_by_commodity_string);
col = gnc_tree_view_add_text_column (
view, _("Symbol"), "symbol", NULL, "ACMEACME",
GNC_TREE_MODEL_COMMODITY_COL_MNEMONIC,
GNC_TREE_MODEL_COMMODITY_COL_VISIBILITY,
sort_by_commodity_string);
g_object_set_data(G_OBJECT(col), DEFAULT_VISIBLE, GINT_TO_POINTER(1));
col = gnc_tree_view_add_text_column (
view, _("Name"), "name", NULL, "Acme Corporation, Inc.",
GNC_TREE_MODEL_COMMODITY_COL_FULLNAME,
GNC_TREE_MODEL_COMMODITY_COL_VISIBILITY,
sort_by_commodity_string);
g_object_set_data(G_OBJECT(col), DEFAULT_VISIBLE, GINT_TO_POINTER(1));
col = gnc_tree_view_add_text_column (
view, _("Print Name"), "printname", NULL,
"ACMEACME (Acme Corporation, Inc.)",
GNC_TREE_MODEL_COMMODITY_COL_PRINTNAME,
GNC_TREE_MODEL_COMMODITY_COL_VISIBILITY,
sort_by_commodity_string);
col = gnc_tree_view_add_text_column (
view, _("Display symbol"), "user_symbol", NULL, "ACME",
GNC_TREE_MODEL_COMMODITY_COL_USER_SYMBOL,
GNC_TREE_MODEL_COMMODITY_COL_VISIBILITY,
sort_by_commodity_string);
g_object_set_data(G_OBJECT(col), DEFAULT_VISIBLE, GINT_TO_POINTER(1));
col = gnc_tree_view_add_text_column (
view, _("Unique Name"), "uniquename", NULL,
"NASDAQ::ACMEACME", GNC_TREE_MODEL_COMMODITY_COL_UNIQUE_NAME,
GNC_TREE_MODEL_COMMODITY_COL_VISIBILITY,
sort_by_commodity_string);
col = gnc_tree_view_add_text_column (
/* Translators: Again replace CUSIP by the name of your
National Securities Identifying Number. */
view, _("ISIN/CUSIP"), "cusip_code", NULL, "QWERTYUIOP",
GNC_TREE_MODEL_COMMODITY_COL_CUSIP,
GNC_TREE_MODEL_COMMODITY_COL_VISIBILITY,
sort_by_commodity_string);
g_object_set_data(G_OBJECT(col), DEFAULT_VISIBLE, GINT_TO_POINTER(1));
col = gnc_tree_view_add_numeric_column (
view, _("Fraction"), "fraction", "10000",
GNC_TREE_MODEL_COMMODITY_COL_FRACTION,
GNC_TREE_VIEW_COLUMN_COLOR_NONE,
GNC_TREE_MODEL_COMMODITY_COL_VISIBILITY,
sort_by_fraction);
g_object_set_data(G_OBJECT(col), DEFAULT_VISIBLE, GINT_TO_POINTER(1));
col = gnc_tree_view_add_toggle_column(
view, _("Get Quotes"),
/* Translators: This string has a context prefix; the translation
must only contain the part after the | character. */
Q_("Column letter for 'Get Quotes'|Q"), "quote_flag",
GNC_TREE_MODEL_COMMODITY_COL_QUOTE_FLAG,
GNC_TREE_MODEL_COMMODITY_COL_VISIBILITY,
sort_by_quote_flag,
NULL);
col = gnc_tree_view_add_text_column (
view, _("Source"), "quote_source", NULL, "yahoo",
GNC_TREE_MODEL_COMMODITY_COL_QUOTE_SOURCE,
GNC_TREE_MODEL_COMMODITY_COL_VISIBILITY,
sort_by_commodity_string);
col = gnc_tree_view_add_text_column (
view, _("Timezone"), "quote_timezone", NULL, "America/New_York",
GNC_TREE_MODEL_COMMODITY_COL_QUOTE_TZ,
GNC_TREE_MODEL_COMMODITY_COL_VISIBILITY,
sort_by_commodity_string);
g_object_set_data(G_OBJECT(col), DEFAULT_VISIBLE, GINT_TO_POINTER(1));
gnc_tree_view_configure_columns(view);
/* Set properties */
va_start (var_args, first_property_name);
g_object_set_valist (G_OBJECT(view), first_property_name, var_args);
va_end (var_args);
/* Sort on the name column by default. This allows for a consistent
* sort if commodities are briefly removed and re-added. */
if (!gtk_tree_sortable_get_sort_column_id(GTK_TREE_SORTABLE(s_model),
NULL, NULL))
{
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(s_model),
GNC_TREE_MODEL_COMMODITY_COL_FULLNAME,
GTK_SORT_ASCENDING);
}
gtk_widget_show(GTK_WIDGET(view));
LEAVE(" %p", view);
return GTK_TREE_VIEW(view);
}
static void
get_folder_content_done_cb (GError *error,
gpointer user_data)
{
LoadData *load_data = user_data;
FrFileSelectorDialog *self = load_data->dialog;
GtkListStore *list_store;
GList *scan;
GtkTreeIter iter;
GDateTime *today;
int sort_column_id;
GtkSortType sort_order;
GHashTable *selected_files;
if (error != NULL) {
if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_MOUNTED)) {
GMountOperation *operation;
operation = gtk_mount_operation_new (GTK_WINDOW (self));
g_file_mount_enclosing_volume (load_data->folder,
G_MOUNT_MOUNT_NONE,
operation,
load_data->cancellable,
folder_mount_enclosing_volume_ready_cb,
load_data);
g_object_unref (operation);
return;
}
if (! g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
_gtk_error_dialog_run (GTK_WINDOW (self), _("Could not load the location"), "%s", error->message);
if (load_data->dialog->priv->current_operation == load_data)
load_data->dialog->priv->current_operation = NULL;
load_data_free (load_data);
return;
}
load_data->files = g_list_reverse (load_data->files);
today = g_date_time_new_now_local ();
gtk_tree_sortable_get_sort_column_id (GTK_TREE_SORTABLE (GET_WIDGET ("files_liststore")), &sort_column_id, &sort_order);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (GET_WIDGET ("files_liststore")), GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID, 0);
selected_files = g_hash_table_new (g_file_hash, (GEqualFunc) g_file_equal);
for (scan = load_data->files_to_select; scan; scan = scan->next)
g_hash_table_insert(selected_files, scan->data, GINT_TO_POINTER (1));
list_store = GTK_LIST_STORE (GET_WIDGET ("files_liststore"));
gtk_list_store_clear (list_store);
for (scan = load_data->files; scan; scan = scan->next) {
FileInfo *file_info = scan->data;
GdkPixbuf *icon_pixbuf;
char *size;
GTimeVal timeval;
GDateTime *datetime;
char *modified;
char *collate_key;
gboolean is_folder;
if (! self->priv->show_hidden && g_file_info_get_is_hidden (file_info->info))
continue;
gtk_list_store_append (list_store, &iter);
icon_pixbuf = gth_icon_cache_get_pixbuf (self->priv->icon_cache, g_file_info_get_icon (file_info->info));
size = g_format_size (g_file_info_get_size (file_info->info));
g_file_info_get_modification_time (file_info->info, &timeval);
datetime = g_date_time_new_from_timeval_local (&timeval);
modified = g_date_time_format (datetime, _g_date_time_same_day (datetime, today) ? "%X" : "%x");
collate_key = g_utf8_collate_key_for_filename (g_file_info_get_display_name (file_info->info), -1);
is_folder = (g_file_info_get_file_type (file_info->info) == G_FILE_TYPE_DIRECTORY);
gtk_list_store_set (list_store, &iter,
FILE_LIST_COLUMN_ICON, icon_pixbuf,
FILE_LIST_COLUMN_NAME, g_file_info_get_display_name (file_info->info),
FILE_LIST_COLUMN_SIZE, (is_folder ? "" : size),
FILE_LIST_COLUMN_MODIFIED, modified,
FILE_LIST_COLUMN_FILE, file_info->file,
FILE_LIST_COLUMN_NAME_ORDER, collate_key,
FILE_LIST_COLUMN_SIZE_ORDER, g_file_info_get_size (file_info->info),
FILE_LIST_COLUMN_MODIFIED_ORDER, timeval.tv_sec,
FILE_LIST_COLUMN_IS_FOLDER, is_folder,
FILE_LIST_COLUMN_IS_SELECTED, (g_hash_table_lookup (selected_files, file_info->file) != NULL),
-1);
g_free (collate_key);
g_free (modified);
g_date_time_unref (datetime);
g_free (size);
_g_object_unref (icon_pixbuf);
}
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (GET_WIDGET ("files_liststore")), sort_column_id, sort_order);
set_current_folder (self, load_data->folder);
if (load_data->dialog->priv->current_operation == load_data)
load_data->dialog->priv->current_operation = NULL;
g_hash_table_unref (selected_files);
g_date_time_unref (today);
load_data_free (load_data);
}
/*
* Create a new price tree view with (optional) top level root node.
* This view will be based on a model that is common to all view of
* the same set of books, but will have its own private filter on that
* model.
*/
GtkTreeView *
gnc_tree_view_price_new (QofBook *book,
const gchar *first_property_name,
...)
{
GncTreeView *view;
GtkTreeModel *model, *f_model, *s_model;
GtkTreeViewColumn *col;
GNCPriceDB *price_db;
va_list var_args;
const gchar *sample_text;
gchar *sample_text2;
ENTER(" ");
/* Create/get a pointer to the existing model for this set of books. */
price_db = gnc_pricedb_get_db(book);
model = gnc_tree_model_price_new (book, price_db);
/* Set up the view private filter on the common model. */
f_model = gtk_tree_model_filter_new (model, NULL);
g_object_unref(G_OBJECT(model));
s_model = gtk_tree_model_sort_new_with_model (f_model);
g_object_unref(G_OBJECT(f_model));
/* Create our view */
view = g_object_new (GNC_TYPE_TREE_VIEW_PRICE,
"name", "price_tree", NULL);
gtk_tree_view_set_model (GTK_TREE_VIEW (view), s_model);
g_object_unref(G_OBJECT(s_model));
DEBUG("model ref count is %d", G_OBJECT(model)->ref_count);
DEBUG("f_model ref count is %d", G_OBJECT(f_model)->ref_count);
DEBUG("s_model ref count is %d", G_OBJECT(s_model)->ref_count);
sample_text = gnc_commodity_get_printname(gnc_default_currency());
sample_text2 = g_strdup_printf("%s%s", sample_text, sample_text);
col = gnc_tree_view_add_text_column (
view, _("Security"), "security", NULL, sample_text2,
GNC_TREE_MODEL_PRICE_COL_COMMODITY,
GNC_TREE_VIEW_COLUMN_VISIBLE_ALWAYS,
sort_by_name);
g_free(sample_text2);
col = gnc_tree_view_add_text_column (
view, _("Currency"), "currency", NULL, sample_text,
GNC_TREE_MODEL_PRICE_COL_CURRENCY,
GNC_TREE_MODEL_PRICE_COL_VISIBILITY,
sort_by_name);
g_object_set_data(G_OBJECT(col), DEFAULT_VISIBLE, GINT_TO_POINTER(1));
col = gnc_tree_view_add_text_column (
view, _("Date"), "date", NULL, "2005-05-20",
GNC_TREE_MODEL_PRICE_COL_DATE,
GNC_TREE_MODEL_PRICE_COL_VISIBILITY,
sort_by_date);
g_object_set_data(G_OBJECT(col), DEFAULT_VISIBLE, GINT_TO_POINTER(1));
col = gnc_tree_view_add_text_column (
view, _("Source"), "source", NULL, "Finance::Quote",
GNC_TREE_MODEL_PRICE_COL_SOURCE,
GNC_TREE_MODEL_PRICE_COL_VISIBILITY,
sort_by_source);
g_object_set_data(G_OBJECT(col), DEFAULT_VISIBLE, GINT_TO_POINTER(1));
col = gnc_tree_view_add_text_column (
view, _("Type"), "type", NULL, "last",
GNC_TREE_MODEL_PRICE_COL_TYPE,
GNC_TREE_MODEL_PRICE_COL_VISIBILITY,
sort_by_type);
g_object_set_data(G_OBJECT(col), DEFAULT_VISIBLE, GINT_TO_POINTER(1));
col = gnc_tree_view_add_numeric_column (
view, _("Price"), "price", "100.00000",
GNC_TREE_MODEL_PRICE_COL_VALUE,
GNC_TREE_VIEW_COLUMN_COLOR_NONE,
GNC_TREE_MODEL_PRICE_COL_VISIBILITY,
sort_by_value);
g_object_set_data(G_OBJECT(col), DEFAULT_VISIBLE, GINT_TO_POINTER(1));
gnc_tree_view_configure_columns(view);
/* Set properties */
va_start (var_args, first_property_name);
g_object_set_valist (G_OBJECT(view), first_property_name, var_args);
va_end (var_args);
/* Sort on the commodity column by default. This allows for a consistent
* sort if commodities are removed and re-added from the model. */
if (!gtk_tree_sortable_get_sort_column_id(GTK_TREE_SORTABLE(s_model),
NULL, NULL))
{
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(s_model),
GNC_TREE_MODEL_PRICE_COL_COMMODITY,
GTK_SORT_ASCENDING);
}
gtk_widget_show(GTK_WIDGET(view));
LEAVE(" %p", view);
return GTK_TREE_VIEW(view);
}
static
void
gsr2_create_table (GNCSplitReg2 *gsr)
{
GncTreeViewSplitReg *view;
GncTreeModelSplitReg *model;
GtkTreeModel *s_model;
GtkWidget *scrolled_window;
GtkTreeViewColumn *col;
GNCLedgerDisplay2Type ledger_type;
GtkWidget *hbox;
gdouble num_of_trans;
gchar *state_section;
GKeyFile *state_file = gnc_state_get_current();
const GncGUID * guid;
Account * account;
account = gnc_ledger_display2_leader (gsr->ledger);
guid = xaccAccountGetGUID (account);
ENTER("create table gsr=%p", gsr);
gnc_ledger_display2_set_user_data (gsr->ledger, (gpointer)gsr);
gnc_ledger_display2_set_handlers (gsr->ledger,
gnc_split_reg2_ld_destroy,
gnc_split_reg2_get_parent);
model = gnc_ledger_display2_get_split_model_register (gsr->ledger);
view = gnc_tree_view_split_reg_new_with_model (model);
g_object_unref (G_OBJECT (model));
/* State_section is used to store per register state: column widths, sort order,... */
ledger_type = gnc_ledger_display2_type (gsr->ledger);
if (ledger_type == LD2_GL && model->type == GENERAL_JOURNAL2)
state_section = g_strdup (STATE_SECTION_GEN_JOURNAL);
else if (ledger_type == LD2_SUBACCOUNT)
{
gchar guidstr[GUID_ENCODING_LENGTH+1];
guid_to_string_buff (guid, guidstr);
state_section = g_strconcat (STATE_SECTION_REG_PREFIX, " ", guidstr, " w/subaccounts", NULL);
}
else
{
gchar guidstr[GUID_ENCODING_LENGTH+1];
guid_to_string_buff (guid, guidstr);
state_section = g_strconcat (STATE_SECTION_REG_PREFIX, " ", guidstr, NULL);
}
g_object_set (G_OBJECT (view), "state-section", state_section,
"show-column-menu", FALSE, NULL);
// Create a hbox for treeview and scrollbar.
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_set_homogeneous (GTK_BOX (hbox), FALSE);
gtk_widget_show (hbox);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_widget_show (scrolled_window);
gtk_box_pack_start (GTK_BOX (gsr), hbox, TRUE, TRUE, 0);
num_of_trans = model->number_of_trans_in_full_tlist - 1;
gsr->scroll_adj = GTK_ADJUSTMENT (gtk_adjustment_new (model->position_of_trans_in_full_tlist, 0.0, num_of_trans + 10, 1.0, 10.0, 10.0));
gsr->scroll_bar = gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL, GTK_ADJUSTMENT (gsr->scroll_adj));
gtk_widget_show (gsr->scroll_bar);
gtk_box_pack_start (GTK_BOX (hbox), gsr->scroll_bar, FALSE, FALSE, 2);
gtk_box_pack_start (GTK_BOX (hbox), scrolled_window, TRUE, TRUE, 0);
gnc_ledger_display2_set_split_view_register (gsr->ledger, view);
/* Synchronize model state with view state
* (needed to properly set up the internal query) */
/* Restore the sort depth from saved state */
model->sort_depth = g_key_file_get_integer (state_file, state_section, "sort_depth", NULL);
g_free(state_section);
s_model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
if (s_model)
{
gint sort_col;
GtkSortType type;
if (gtk_tree_sortable_get_sort_column_id (GTK_TREE_SORTABLE (s_model), &sort_col, &type))
{
model->sort_col = sort_col;
model->sort_direction = type;
}
}
gnc_tree_view_configure_columns (GNC_TREE_VIEW (view));
if (ledger_type == LD2_GL && model->type == GENERAL_JOURNAL2)
gnc_tree_view_set_show_column_menu (GNC_TREE_VIEW (view), TRUE);
else
gnc_tree_view_set_show_column_menu (GNC_TREE_VIEW (view), FALSE);
/* This column gets all the free space */
gnc_tree_view_expand_columns (GNC_TREE_VIEW (view), "descnotes", NULL);
/* This sets the status color column, 4 is the minimum */
col = gnc_tree_view_find_column_by_name (GNC_TREE_VIEW (view), "status");
if (col != NULL)
g_object_set (G_OBJECT(col),
"resizable", FALSE,
"sizing", GTK_TREE_VIEW_COLUMN_FIXED,
"fixed-width", 4,
NULL);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (view), TRUE);
gtk_widget_show (GTK_WIDGET (view));
gtk_container_add (GTK_CONTAINER (scrolled_window), GTK_WIDGET (view));
gtk_widget_show (GTK_WIDGET (gsr));
/* Should this be read only */
gnc_tree_view_split_reg_set_read_only (view, gsr->read_only);
/* This tells the ledger that we have a valid tree view */
gnc_ledger_display2_set_split_view_refresh (gsr->ledger, TRUE);
/* This triggers the update of the summary bar */
g_signal_connect_after (model, "refresh_status_bar",
G_CALLBACK (gsr2_redraw_all_cb), gsr); //this works
// This will keep scrollbar in sync.
g_signal_connect (model, "scroll_sync",
G_CALLBACK (gsr2_scroll_sync_cb), gsr);
/* This triggers the update of the help text */
g_signal_connect (view, "help_signal",
G_CALLBACK (gsr2_emit_help_changed), gsr); // this works
gsr2_scroll_value_changed_cb (GTK_ADJUSTMENT (gsr->scroll_adj), gsr);
/* This triggers the tooltip to change when scrolling */
g_signal_connect (gsr->scroll_adj, "value-changed",
G_CALLBACK (gsr2_scroll_value_changed_cb), gsr); // this works
/* This triggers the model update when mouse button released */
g_signal_connect (gsr->scroll_bar, "button-release-event",
G_CALLBACK (gsr2_scroll_button_event_cb), gsr);
// Connect a call back to update the sort settings.
g_signal_connect (GTK_TREE_SORTABLE (s_model), "sort-column-changed",
G_CALLBACK (gnc_split_reg2_sort_changed_cb), gsr);
LEAVE(" ");
}
