static GtkTreeViewColumn *
column_dialog_get_prev_visible_column (DialogData *data, GtkTreeViewColumn *column)
{
GList *columns, *l;
GtkTreeViewColumn *prev = NULL;
columns = gtk_tree_view_get_columns (data->edited_tree);
for (l = columns; l; l = l->next) {
if (l->data == column) {
l = l->prev;
break;
}
}
while (l && !gtk_tree_view_column_get_visible (l->data)) {
l = l->prev;
}
if (l) {
prev = l->data;
}
g_list_free (columns);
return prev;
}
static void
egg_column_model_get_value (GtkTreeModel *tree_model,
GtkTreeIter *iter,
gint column,
GValue *value)
{
GtkTreeViewColumn *view_column;
g_return_if_fail (EGG_IS_COLUMN_MODEL (tree_model));
g_return_if_fail (column < N_COLUMNS);
g_return_if_fail (column >= 0);
g_return_if_fail (iter->stamp == EGG_COLUMN_MODEL (tree_model)->stamp);
view_column = GTK_TREE_VIEW_COLUMN (((GList *)iter->user_data)->data);
switch (column)
{
case COLUMN_VISIBLE:
g_value_init (value, G_TYPE_BOOLEAN);
g_value_set_boolean (value, gtk_tree_view_column_get_visible (view_column));
break;
case COLUMN_NAME:
g_value_init (value, G_TYPE_STRING);
g_value_set_string (value, gtk_tree_view_column_get_title (view_column));
break;
case COLUMN_OBJECT:
g_value_init (value, GTK_TYPE_TREE_VIEW_COLUMN);
g_value_set_object (value, view_column);
break;
default:
g_assert_not_reached ();
break;
}
}
bool gTree::columnVisible(int ind)
{
GtkTreeViewColumn *col=gt_tree_view_find_column(GTK_TREE_VIEW(widget),ind);
if (!col) return false;
return gtk_tree_view_column_get_visible(col);
}
static void callback_column_visible(GtkWidget* widget, int column)
{
int counter;
gboolean visible = gtk_tree_view_column_get_visible(GTK_TREE_VIEW_COLUMN(g_MainWindow.column[column]));
gtk_tree_view_column_set_visible(g_MainWindow.column[column], !visible);
config_put_bool(g_MainWindow.column_names[column][1], !visible);
/* Control if emptry header column is visible. */
gtk_tree_view_column_set_visible(g_MainWindow.column[16], FALSE);
for(counter = 0; counter < 16; ++counter)
{
if(gtk_tree_view_column_get_visible(GTK_TREE_VIEW_COLUMN(g_MainWindow.column[counter])))
return;
}
gtk_tree_view_column_set_visible(g_MainWindow.column[16], TRUE);
}
static void
cell_renderer_func(GtkTreeViewColumn *column,
GtkCellRenderer *cell, GtkTreeModel *model, GtkTreeIter *iter,
gpointer udata)
{
static const GValue zero_value;
const struct node_data *data;
const gchar *s, *attr;
GValue value;
if (!gtk_tree_view_column_get_visible(column))
return;
attr = "text";
value = zero_value;
gtk_tree_model_get_value(model, iter, 0, &value);
data = g_value_get_pointer(&value);
switch (GPOINTER_TO_UINT(udata)) {
case c_gnet_user_agent:
s = data->user_agent;
break;
case c_gnet_flags:
s = data->flags;
attr = "markup";
break;
case c_gnet_loc:
s = iso3166_country_name(data->country);
break;
case c_gnet_version:
s = data->version;
break;
case c_gnet_host:
s = data->host;
break;
case c_gnet_connected:
s = short_time(data->connected);
break;
case c_gnet_uptime:
s = data->uptime > 0 ? short_time(data->uptime) : NULL;
break;
case c_gnet_info:
s = data->info;
break;
default:
s = NULL;
}
if (data->fg) {
g_object_set(cell,
attr, s,
"foreground-gdk", data->fg,
"foreground-set", TRUE,
(void *) 0);
} else {
g_object_set(cell, attr, s, (void *) 0);
}
}
static void menu_cardview_context_menu(GtkWidget *treeview, GdkEventButton *event, gpointer userdata)
/* Create a right click context menu */
{
GtkWidget *menu, *menuitem;
GtkTreeViewColumn *column2 = gtk_tree_view_get_column(GTK_TREE_VIEW(treeview),2);
#if GTK_CHECK_VERSION(3,6,0)
GtkWidget *menuitem_child;
#endif
UNUSED(userdata);
menu = gtk_menu_new();
/* Menu Item */
menuitem = gtk_menu_item_new_with_label("Copy");
g_signal_connect(menuitem, "activate",
(GCallback) menu_cardview_copy, treeview);
#if GTK_CHECK_VERSION(3,6,0)
menuitem_child = gtk_bin_get_child (GTK_BIN (menuitem));
gtk_accel_label_set_accel (GTK_ACCEL_LABEL (menuitem_child), GDK_KEY_c, GDK_CONTROL_MASK);
#endif
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
/* Menu Item */
menuitem = gtk_menu_item_new_with_label("Expand all");
g_signal_connect(menuitem, "activate",
(GCallback) menu_cardview_context_menu_expand_all, treeview);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
/* Menu Item */
if (gtk_tree_view_column_get_visible(column2))
{
menuitem = gtk_menu_item_new_with_label("Show interpreted value");
g_signal_connect(menuitem, "activate",
(GCallback) menu_cardview_context_menu_change_value_type, treeview);
}
else
{
menuitem = gtk_menu_item_new_with_label("Show raw value");
g_signal_connect(menuitem, "activate",
(GCallback) menu_cardview_context_menu_change_value_type, treeview);
}
#if GTK_CHECK_VERSION(3,6,0)
menuitem_child = gtk_bin_get_child (GTK_BIN (menuitem));
gtk_accel_label_set_accel (GTK_ACCEL_LABEL (menuitem_child), GDK_KEY_r, GDK_CONTROL_MASK);
#endif
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
gtk_widget_show_all(menu);
gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL,
(event != NULL) ? event->button : 0,
gdk_event_get_time((GdkEvent *)event));
}
gboolean
egg_column_model_get_column_visible (EggColumnModel *model, GtkTreeIter *iter)
{
GtkTreeViewColumn *column;
g_return_val_if_fail (model->stamp == iter->stamp, FALSE);
column = (GtkTreeViewColumn *)((GList *)iter->user_data)->data;
return gtk_tree_view_column_get_visible (column);
}
static void menu_cardview_switch_column(void)
{
GtkTreeViewColumn *column2 = gtk_tree_view_get_column(GTK_TREE_VIEW(CARDVIEW),2);
GtkTreeViewColumn *column3 = gtk_tree_view_get_column(GTK_TREE_VIEW(CARDVIEW),3);
if (gtk_tree_view_column_get_visible(column2))
{
gtk_tree_view_column_set_visible (column2,FALSE);
gtk_tree_view_column_set_visible (column3,TRUE);
}
else
{
gtk_tree_view_column_set_visible (column2,TRUE);
gtk_tree_view_column_set_visible (column3,FALSE);
}
}
static void
get_visible (GtkTreeViewColumn *tree_column,
GtkCellRenderer *cell,
GtkTreeModel *tree_model,
GtkTreeIter *iter,
gpointer data)
{
GtkTreeViewColumn *column;
gtk_tree_model_get (tree_model, iter, 1, &column, -1);
if (column)
{
gtk_cell_renderer_toggle_set_active (GTK_CELL_RENDERER_TOGGLE (cell),
gtk_tree_view_column_get_visible (column));
}
}
static void
bluetooth_chooser_get_property (GObject *object, guint prop_id,
GValue *value, GParamSpec *pspec)
{
BluetoothChooser *self = BLUETOOTH_CHOOSER(object);
BluetoothChooserPrivate *priv = BLUETOOTH_CHOOSER_GET_PRIVATE(self);
switch (prop_id) {
case PROP_DEVICE_SELECTED:
g_value_take_string (value, bluetooth_chooser_get_selected_device (self));
break;
case PROP_SHOW_PAIRING:
g_value_set_boolean (value, priv->show_paired);
break;
case PROP_SHOW_CONNECTED:
g_value_set_boolean (value, priv->show_connected);
break;
case PROP_SHOW_SEARCHING:
g_value_set_boolean (value, priv->show_searching);
break;
case PROP_SHOW_DEVICE_TYPE:
g_value_set_boolean (value, priv->show_device_type);
break;
case PROP_SHOW_DEVICE_TYPE_COLUMN:
g_value_set_boolean (value,
gtk_tree_view_column_get_visible (gtk_tree_view_get_column (GTK_TREE_VIEW (priv->treeview), TREEVIEW_COLUMN_TYPE)));
break;
case PROP_SHOW_DEVICE_CATEGORY:
g_value_set_boolean (value, priv->show_device_category);
break;
case PROP_DEVICE_TYPE_FILTER:
g_value_set_int (value, priv->device_type_filter);
break;
case PROP_DEVICE_CATEGORY_FILTER:
g_value_set_enum (value, priv->device_category_filter);
break;
case PROP_DEVICE_SERVICE_FILTER:
g_value_set_string (value, priv->device_service_filter);
break;
case PROP_INTERNAL_FILTER:
g_value_set_boolean (value, priv->internal_filter);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
break;
}
}
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);
}
static void
cell_renderer_func(GtkTreeViewColumn *column,
GtkCellRenderer *cell, GtkTreeModel *model, GtkTreeIter *iter,
gpointer udata)
{
static const GValue zero_value;
const struct upload_data *data;
const gchar *text = NULL;
gchar buf[64];
GValue value;
if (!gtk_tree_view_column_get_visible(column))
return;
value = zero_value;
gtk_tree_model_get_value(model, iter, 0, &value);
data = g_value_get_pointer(&value);
switch ((enum c_us) GPOINTER_TO_UINT(udata)) {
case c_us_filename:
text = data->filename;
break;
case c_us_size:
text = short_size(data->us->size, show_metric_units());
break;
case c_us_attempts:
text = uint64_to_string(data->us->attempts);
break;
case c_us_complete:
text = uint64_to_string(data->us->attempts);
break;
case c_us_norm:
str_bprintf(buf, sizeof buf, "%1.3f", data->us->norm);
text = buf;
break;
case c_us_rtime:
text = data->us->rtime ? timestamp_to_string(data->us->rtime) : NULL;
break;
case c_us_dtime:
text = data->us->dtime ? timestamp_to_string(data->us->dtime) : NULL;
break;
case c_us_num:
g_assert_not_reached();
}
g_object_set(cell, "text", text, (void *) 0);
}
static void
column_dialog_fill_trees (DialogData *data)
{
GtkListStore *hidden_store;
GtkListStore *visible_store;
GList *columns, *l;
GtkTreeIter iter;
hidden_store = GTK_LIST_STORE (
gtk_tree_view_get_model (GTK_TREE_VIEW (data->hidden_tree)));
visible_store = GTK_LIST_STORE (
gtk_tree_view_get_model (GTK_TREE_VIEW (data->visible_tree)));
gtk_list_store_clear (hidden_store);
gtk_list_store_clear (visible_store);
columns = gtk_tree_view_get_columns (data->edited_tree);
for (l = columns; l; l = l->next) {
GtkTreeViewColumn *column;
column = l->data;
if (g_object_get_data (G_OBJECT (column), "custom")) {
continue;
}
if (gtk_tree_view_column_get_visible (column)) {
gtk_list_store_append (visible_store, &iter);
gtk_list_store_set (visible_store,
&iter,
0, column,
-1);
} else {
gtk_list_store_append (hidden_store, &iter);
gtk_list_store_set (hidden_store,
&iter,
0, column,
-1);
}
}
g_list_free (columns);
}
static void
column_dialog_set_selected_column (DialogData *data,
GtkTreeViewColumn *column)
{
GtkTreeView *tree;
GtkTreeModel *model;
GtkTreeIter iter;
gboolean found;
GtkTreeSelection *selection;
if (gtk_tree_view_column_get_visible (column)) {
tree = GTK_TREE_VIEW (data->visible_tree);
} else {
tree = GTK_TREE_VIEW (data->hidden_tree);
}
model = gtk_tree_view_get_model (tree);
found = FALSE;
if (gtk_tree_model_get_iter_first (model, &iter)) {
GtkTreeViewColumn *tmp;
do {
gtk_tree_model_get (model, &iter,
0, &tmp,
-1);
if (tmp == column) {
found = TRUE;
break;
}
} while (gtk_tree_model_iter_next (model, &iter));
}
if (found) {
selection = gtk_tree_view_get_selection (tree);
gtk_tree_selection_select_iter (selection, &iter);
}
}
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);
}
static void
render_files(GtkTreeViewColumn *column, GtkCellRenderer *cell,
GtkTreeModel *unused_model, GtkTreeIter *iter, void *udata)
{
const struct fileinfo_data *file;
enum c_fi idx;
(void) unused_model;
if (!gtk_tree_view_column_get_visible(column))
return;
file = get_fileinfo_data(iter);
g_return_if_fail(file);
idx = pointer_to_uint(udata);
if (c_fi_progress == idx) {
unsigned value = fi_gui_file_get_progress(file);
g_object_set(cell, "value", value, (void *) 0);
} else {
const char *text = fi_gui_file_column_text(file, idx);
g_object_set(cell, "text", text, (void *) 0);
}
}
static void
render_sources(GtkTreeViewColumn *column, GtkCellRenderer *cell,
GtkTreeModel *unused_model, GtkTreeIter *iter, void *udata)
{
struct download *d;
enum c_src idx;
(void) unused_model;
if (!gtk_tree_view_column_get_visible(column))
return;
d = get_source(iter);
g_return_if_fail(d);
idx = pointer_to_uint(udata);
if (c_src_progress == idx) {
unsigned value = fi_gui_source_get_progress(d);
g_object_set(cell, "value", value, (void *) 0);
} else {
const char *text = fi_gui_source_column_text(d, idx);
g_object_set(cell, "text", text, (void *) 0);
}
}
static GtkWidget *
create_field_page(GtkWidget *tree, const gchar *child_schema, const gchar *text)
{
GtkWidget *vbox;
GtkWidget *scrolled;
GtkWidget *label;
GtkWidget *treeview;
GList *it, *columns;
GtkListStore *model;
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
label = gtk_label_new_with_mnemonic (text);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (vbox), scrolled, TRUE, TRUE, 0);
model = gtk_list_store_new (3, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_POINTER);
treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
gtk_container_add (GTK_CONTAINER (scrolled), treeview);
g_object_unref (G_OBJECT (model));
gtk_label_set_mnemonic_widget (GTK_LABEL (label), treeview);
column = gtk_tree_view_column_new ();
cell = gtk_cell_renderer_toggle_new ();
gtk_tree_view_column_pack_start (column, cell, FALSE);
gtk_tree_view_column_set_attributes (column, cell,
"active", 0,
NULL);
if (g_strcmp0 (child_schema, "proctree") == 0)
g_signal_connect (G_OBJECT (cell), "toggled", G_CALLBACK (proc_field_toggled), model);
else if (g_strcmp0 (child_schema, "disktreenew") == 0)
g_signal_connect (G_OBJECT (cell), "toggled", G_CALLBACK (disk_field_toggled), model);
gtk_tree_view_column_set_clickable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
column = gtk_tree_view_column_new ();
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, cell, FALSE);
gtk_tree_view_column_set_attributes (column, cell,
"text", 1,
NULL);
gtk_tree_view_column_set_title (column, "Not Shown");
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE);
columns = gtk_tree_view_get_columns (GTK_TREE_VIEW (tree));
for(it = columns; it; it = it->next)
{
GtkTreeViewColumn *column = static_cast<GtkTreeViewColumn*>(it->data);
GtkTreeIter iter;
const gchar *title;
gboolean visible;
gint column_id;
title = gtk_tree_view_column_get_title (column);
if (!title)
title = _("Icon");
column_id = gtk_tree_view_column_get_sort_column_id(column);
if ((column_id == COL_CGROUP) && (!cgroups_enabled()))
continue;
if ((column_id == COL_UNIT ||
column_id == COL_SESSION ||
column_id == COL_SEAT ||
column_id == COL_OWNER)
#ifdef HAVE_SYSTEMD
&& !LOGIND_RUNNING()
#endif
)
continue;
visible = gtk_tree_view_column_get_visible (column);
gtk_list_store_append (model, &iter);
gtk_list_store_set (model, &iter, 0, visible, 1, title, 2, column,-1);
}
g_list_free(columns);
return vbox;
}
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);
}
static GtkWidget *
create_field_page(GtkWidget *tree, const char* text)
{
GtkWidget *vbox;
GtkWidget *scrolled;
GtkWidget *label;
GtkWidget *treeview;
GList *it, *columns;
GtkListStore *model;
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
vbox = gtk_vbox_new (FALSE, 6);
label = gtk_label_new_with_mnemonic (text);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (vbox), scrolled, TRUE, TRUE, 0);
model = gtk_list_store_new (3, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_POINTER);
treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
gtk_container_add (GTK_CONTAINER (scrolled), treeview);
g_object_unref (G_OBJECT (model));
gtk_label_set_mnemonic_widget (GTK_LABEL (label), treeview);
column = gtk_tree_view_column_new ();
cell = gtk_cell_renderer_toggle_new ();
gtk_tree_view_column_pack_start (column, cell, FALSE);
gtk_tree_view_column_set_attributes (column, cell,
"active", 0,
NULL);
g_signal_connect (G_OBJECT (cell), "toggled", G_CALLBACK (field_toggled), model);
gtk_tree_view_column_set_clickable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
column = gtk_tree_view_column_new ();
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, cell, FALSE);
gtk_tree_view_column_set_attributes (column, cell,
"text", 1,
NULL);
gtk_tree_view_column_set_title (column, "Not Shown");
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE);
columns = gtk_tree_view_get_columns (GTK_TREE_VIEW (tree));
for(it = columns; it; it = it->next)
{
GtkTreeViewColumn *column = static_cast<GtkTreeViewColumn*>(it->data);
GtkTreeIter iter;
const gchar *title;
gboolean visible;
title = gtk_tree_view_column_get_title (column);
if (!title)
title = _("Icon");
visible = gtk_tree_view_column_get_visible (column);
gtk_list_store_append (model, &iter);
gtk_list_store_set (model, &iter, 0, visible, 1, title, 2, column,-1);
}
g_list_free(columns);
return vbox;
}
static void
task_view_load_columns (PlannerView *view)
{
PlannerTaskViewPriv *priv;
GList *columns, *l;
GtkTreeViewColumn *column;
const gchar *id;
gint i;
priv = PLANNER_TASK_VIEW (view)->priv;
/* Load the columns. */
planner_view_column_load_helper (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");
g_print ("%s\n", id);
if (!id) {
continue;
}
if (strcmp (id, "wbs") == 0 ||
strcmp (id, "name") == 0 ||
strcmp (id, "start") == 0 ||
strcmp (id, "finish") == 0 ||
strcmp (id, "work") == 0 ||
strcmp (id, "duration") == 0 ||
strcmp (id, "duration") == 0 ||
strcmp (id, "slack") == 0 ||
strcmp (id, "cost") == 0 ||
strcmp (id, "complete") == 0 ||
strcmp (id, "assigned-to")) {
gtk_tree_view_column_set_visible (column, TRUE);
} else {
gtk_tree_view_column_set_visible (column, FALSE);
}
}
}
g_list_free (columns);
}
static void
cell_renderer(GtkTreeViewColumn *column, GtkCellRenderer *cell,
GtkTreeModel *model, GtkTreeIter *iter, gpointer udata)
{
const struct result_data *data;
const struct results_set *rs;
const gchar *text;
enum c_sr_columns id;
if (!gtk_tree_view_column_get_visible(column))
return;
text = NULL; /* default to nothing */
id = GPOINTER_TO_UINT(udata);
data = get_result_data(model, iter);
rs = data->record->results_set;
switch (id) {
case c_sr_filename:
text = data->record->utf8_name;
break;
case c_sr_ext:
text = data->record->ext;
break;
case c_sr_mime:
text = mime_type_to_string(mime_type_from_extension(data->record->ext));
break;
case c_sr_vendor:
if (!(ST_LOCAL & rs->status))
text = vendor_code_get_name(rs->vendor);
break;
case c_sr_info:
text = data->record->info;
break;
case c_sr_size:
text = compact_size(data->record->size, show_metric_units());
break;
case c_sr_count:
text = data->children ? uint32_to_string(1 + data->children) : NULL;
break;
case c_sr_loc:
if (ISO3166_INVALID != rs->country)
text = iso3166_country_cc(rs->country);
break;
case c_sr_charset:
if (!(ST_LOCAL & rs->status))
text = data->record->charset;
break;
case c_sr_route:
text = search_gui_get_route(rs);
break;
case c_sr_protocol:
if (!((ST_LOCAL | ST_BROWSE) & rs->status))
text = ST_UDP & rs->status ?
(ST_SR_UDP & rs->status ? N_("UDP (semi-reliable)") : "UDP")
: "TCP";
break;
case c_sr_hops:
if (!((ST_LOCAL | ST_BROWSE) & rs->status))
text = uint32_to_string(rs->hops);
break;
case c_sr_ttl:
if (!((ST_LOCAL | ST_BROWSE) & rs->status))
text = uint32_to_string(rs->ttl);
break;
case c_sr_spam:
if (SR_SPAM & data->record->flags) {
text = "S"; /* Spam */
} else if (ST_SPAM & rs->status) {
text = "maybe"; /* maybe spam */
}
break;
case c_sr_owned:
if (SR_OWNED & data->record->flags) {
text = _("owned");
} else if (SR_PARTIAL & data->record->flags) {
text = _("partial");
} else if (SR_SHARED & data->record->flags) {
text = _("shared");
}
break;
case c_sr_hostile:
if (ST_HOSTILE & rs->status) {
text = "H";
}
break;
case c_sr_sha1:
if (data->record->sha1) {
text = sha1_base32(data->record->sha1);
}
break;
case c_sr_ctime:
if ((time_t) -1 != data->record->create_time) {
text = timestamp_to_string(data->record->create_time);
}
break;
case c_sr_num:
g_assert_not_reached();
break;
}
g_object_set(cell,
"text", text,
"foreground-gdk", gui_color_get(data->color),
"background-gdk", gui_color_get(GUI_COLOR_BACKGROUND),
(void *) 0);
}