gboolean
on_clist_nodes_button_press_event(GtkWidget *unused_widget,
GdkEventButton *event, gpointer unused_udata)
{
gint row;
gint col;
GtkCList *clist_nodes = GTK_CLIST
(gui_main_window_lookup("clist_nodes"));
(void) unused_widget;
(void) unused_udata;
if (event->button != 3)
return FALSE;
update_sensitivity(clist_nodes->selection != NULL);
if (
!gtk_clist_get_selection_info(clist_nodes,
event->x, event->y, &row, &col)
)
return FALSE;
gtk_menu_popup(GTK_MENU(gui_popup_nodes()), NULL, NULL, NULL, NULL,
event->button, event->time);
return TRUE;
}
/**
* Initiates a browse host request to the currently selected host.
*/
void
on_popup_nodes_browse_host_activate(GtkMenuItem *unused_menuitem,
gpointer unused_udata)
{
GtkCList *clist = GTK_CLIST(gui_main_window_lookup("clist_nodes"));
GSList *sl, *node_list;
g_assert(clist != NULL);
(void) unused_menuitem;
(void) unused_udata;
node_list = clist_collect_data(clist, TRUE, NULL);
for (sl = node_list; sl != NULL; sl = g_slist_next(sl)) {
const struct nid *handle = sl->data;
gnet_node_info_t *info = guc_node_get_info(handle);
if (!info)
continue;
if (!info->is_pseudo) {
search_gui_new_browse_host(NULL, info->gnet_addr, info->gnet_port,
&info->gnet_guid, NULL, info->is_g2 ? SOCK_F_G2 : 0);
}
guc_node_free_info(info);
}
}
/**
* Removes all references to the given node handle in the gui.
*/
void
nodes_gui_remove_node(const struct nid *node_id)
{
GtkWidget *clist_nodes;
gint row;
clist_nodes = gui_main_window_lookup("clist_nodes");
/*
* Make sure node is remove from the "changed" hash table so
* we don't try an update.
*/
g_assert(NULL != hs_node_info_changed);
g_assert(NULL != hs_node_flags_changed);
remove_item(hs_node_info_changed, node_id);
remove_item(hs_node_flags_changed, node_id);
row = gtk_clist_find_row_from_data(GTK_CLIST(clist_nodes),
deconstify_gpointer(node_id));
if (row != -1) {
gtk_clist_remove(GTK_CLIST(clist_nodes), row);
nid_unref(node_id);
} else {
g_warning("nodes_gui_remove_node: no matching row found");
}
}
void
search_gui_set_bitzi_metadata_text(const char *text)
{
g_return_if_fail(text);
set_text_buffer(gui_main_window_lookup("text_result_info_bitzi"), text);
}
/**
* Adds the given node to the gui.
*/
void
nodes_gui_add_node(gnet_node_info_t *n)
{
GtkCList *clist_nodes;
const gchar *titles[c_gnet_num];
gchar proto_tmp[32];
gint row;
g_assert(n != NULL);
gm_snprintf(proto_tmp, sizeof proto_tmp, "%d.%d",
n->proto_major, n->proto_minor);
titles[c_gnet_host] = host_addr_port_to_string(n->addr, n->port);
titles[c_gnet_flags] = "...";
titles[c_gnet_user_agent] = n->vendor
? lazy_utf8_to_locale(n->vendor)
: "...";
titles[c_gnet_loc] = iso3166_country_cc(n->country);
titles[c_gnet_version] = proto_tmp;
titles[c_gnet_connected] = "...";
titles[c_gnet_uptime] = "...";
titles[c_gnet_info] = "...";
clist_nodes = GTK_CLIST(gui_main_window_lookup("clist_nodes"));
row = gtk_clist_append(clist_nodes, (gchar **) titles); /* override const */
gtk_clist_set_row_data(clist_nodes, row,
deconstify_gpointer(nid_ref(n->node_id)));
}
void
hcache_gui_update_display(void)
{
hcache_stats_t stats[HCACHE_MAX];
GtkCList *clist;
gint n;
guc_hcache_get_stats(stats);
clist = GTK_CLIST(gui_main_window_lookup("clist_hcache"));
gtk_clist_freeze(clist);
for (n = 0; n < HCACHE_MAX; n ++) {
if (n == HCACHE_NONE)
continue;
gtk_clist_set_text(clist, n,
c_hcs_host_count, guint_to_str(stats[n].host_count));
gtk_clist_set_text(clist, n,
c_hcs_hits, guint_to_str(stats[n].hits));
gtk_clist_set_text(clist, n,
c_hcs_misses, guint_to_str(stats[n].misses));
}
gtk_clist_thaw(clist);
}
/**
* Initialize the nodes controller. Register callbacks in the backend.
*/
G_GNUC_COLD void
nodes_gui_init(void)
{
unsigned i;
GtkCList *clist;
clist = GTK_CLIST(gui_main_window_lookup("clist_nodes"));
gtk_clist_column_titles_passive(clist);
for (i = 0; i < c_gnet_num; i++) {
gtk_clist_set_column_name(clist, i, nodes_gui_column_title(i));
}
clist_restore_visibility(clist, PROP_NODES_COL_VISIBLE);
clist_restore_widths(clist, PROP_NODES_COL_WIDTHS);
widget_add_popup_menu(GTK_WIDGET(clist), nodes_gui_get_popup_menu);
hs_node_info_changed = hset_create_any(nid_hash, nid_hash2, nid_equal);
hs_node_flags_changed = hset_create_any(nid_hash, nid_hash2, nid_equal);
guc_node_add_node_added_listener(nodes_gui_node_added);
guc_node_add_node_removed_listener(nodes_gui_node_removed);
guc_node_add_node_info_changed_listener(nodes_gui_node_info_changed);
guc_node_add_node_flags_changed_listener(nodes_gui_node_flags_changed);
main_gui_add_timer(nodes_gui_timer);
}
void
on_menu_sidebar_visible_activate(GtkMenuItem *menuitem, gpointer unused_udata)
{
(void) unused_udata;
checkmenu_changed(gui, PROP_SIDEBAR_VISIBLE, menuitem);
/*
* Gtk+ 2.x automagically moves the gutter when a child's
* visibility status changes.
*/
#ifdef USE_GTK1
{
GtkPaned *paned;
gboolean sidebar;
gui_prop_get_boolean_val(PROP_SIDEBAR_VISIBLE, &sidebar);
paned = GTK_PANED(gui_main_window_lookup("hpaned_main"));
if (sidebar) {
paned_restore_position(paned, PROP_MAIN_DIVIDER_POS);
} else {
paned_save_position(paned, PROP_MAIN_DIVIDER_POS);
gtk_paned_set_position(paned, 0);
}
}
#endif /* USE_GTK1 */
}
/**
* Initialize the nodes controller. Register callbacks in the backend.
*/
void
nodes_gui_init(void)
{
GtkTreeView *tv;
tv = GTK_TREE_VIEW(gui_main_window_lookup( "treeview_nodes"));
treeview_nodes = tv;
tree_view_restore_widths(tv, PROP_NODES_COL_WIDTHS);
tree_view_restore_visibility(tv, PROP_NODES_COL_VISIBLE);
tree_view_set_fixed_height_mode(tv, TRUE);
nodes_handles = htable_create_any(nid_hash, nid_hash2, nid_equal);
ht_node_info_changed = hset_create_any(nid_hash, nid_hash2, nid_equal);
ht_node_flags_changed = hset_create_any(nid_hash, nid_hash2, nid_equal);
ht_pending_lookups = hset_create_any(nid_hash, nid_hash2, nid_equal);
guc_node_add_node_added_listener(nodes_gui_node_added);
guc_node_add_node_removed_listener(nodes_gui_node_removed);
guc_node_add_node_info_changed_listener(nodes_gui_node_info_changed);
guc_node_add_node_flags_changed_listener(nodes_gui_node_flags_changed);
widget_add_popup_menu(GTK_WIDGET(tv), nodes_gui_get_popup_menu);
gui_signal_connect(tv, "cursor-changed", on_cursor_changed, tv);
gui_signal_connect(tv, "leave-notify-event", on_leave_notify, tv);
tvm_nodes = tree_view_motion_set_callback(tv, update_tooltip, 400);
main_gui_add_timer(nodes_gui_timer);
}
/**
* Initialize the upload statistics GUI.
*
* Initialize the upload statistics GUI. Define the
* GtkTreeModel used to store the information as well
* as rendering and sorting functions to use on the
* cells and columns.
*/
static void
upload_stats_gui_init_intern(gboolean intern)
{
static const struct {
const guint id;
const gchar * const title;
const gfloat align;
const GtkTreeIterCompareFunc func;
} columns[] = {
{ c_us_filename, N_("Filename"), 0.0, upload_stats_gui_cmp_filename },
{ c_us_size, N_("Size"), 1.0, upload_stats_gui_cmp_size },
{ c_us_attempts, N_("Attempts"), 1.0, upload_stats_gui_cmp_attempts },
{ c_us_complete, N_("Complete"), 1.0, upload_stats_gui_cmp_complete },
{ c_us_norm, N_("Normalized"), 1.0, upload_stats_gui_cmp_norm },
{ c_us_rtime, N_("Last Request"), 0.0, upload_stats_gui_cmp_rtime },
{ c_us_dtime, N_("Last Upload"), 0.0, upload_stats_gui_cmp_dtime },
};
static gboolean initialized = FALSE;
GtkTreeModel *model;
guint i;
STATIC_ASSERT(G_N_ELEMENTS(columns) == UPLOAD_STATS_GUI_VISIBLE_COLUMNS);
if (!initialized) {
initialized = TRUE;
ht_uploads = htable_create(HASH_KEY_SELF, 0);
popup_upload_stats = create_popup_upload_stats();
model = GTK_TREE_MODEL(gtk_list_store_new(1, G_TYPE_POINTER));
upload_stats_treeview = GTK_TREE_VIEW(
gui_main_window_lookup("treeview_ul_stats"));
gtk_tree_view_set_model(upload_stats_treeview, model);
g_object_unref(model);
for (i = 0; i < G_N_ELEMENTS(columns); i++) {
add_column(upload_stats_treeview,
columns[i].id,
_(columns[i].title),
columns[i].align,
columns[i].func,
cell_renderer_func);
}
gui_signal_connect(upload_stats_treeview,
"button_press_event", on_button_press_event, NULL);
}
if (!intern) {
/* upload_stats_gui_init_intern() might be called internally before
* settings_gui_init(). If it's called externally it's called from
* main_gui_init() and the GUI properties are intialized. */
tree_view_restore_widths(upload_stats_treeview,
PROP_UL_STATS_COL_WIDTHS);
tree_view_restore_visibility(upload_stats_treeview,
PROP_UL_STATS_COL_VISIBLE);
}
}
void
search_stats_gui_init(void)
{
static GType types[] = {
G_TYPE_STRING,
G_TYPE_ULONG,
G_TYPE_ULONG
};
static const struct {
const int id;
const float align;
const char *title;
} cols[] = {
{ 0, 0.0, N_("Search Term") },
{ 1, 1.0, N_("This Interval") },
{ 2, 1.0, N_("Total") },
};
size_t i;
GtkTreeModel *model;
GtkTreeView *treeview;
STATIC_ASSERT(G_N_ELEMENTS(cols) == G_N_ELEMENTS(types));
treeview_search_stats =
GTK_TREE_VIEW(gui_main_window_lookup("treeview_search_stats"));
label_search_stats_count =
GTK_LABEL(gui_main_window_lookup("label_search_stats_count"));
treeview = treeview_search_stats;
/* set up the treeview to be sorted properly */
model = GTK_TREE_MODEL(gtk_list_store_newv(G_N_ELEMENTS(types), types));
gtk_tree_view_set_model(treeview, model);
store_search_stats = GTK_LIST_STORE(model);
g_object_unref(model);
for (i = 0; i < G_N_ELEMENTS(cols); i++) {
add_column(treeview, cols[i].id, cols[i].align, _(cols[i].title));
}
tree_view_restore_widths(treeview, PROP_SEARCH_STATS_COL_WIDTHS);
tree_view_set_fixed_height_mode(treeview, TRUE);
stat_hash = htable_create(HASH_KEY_STRING, 0);
main_gui_add_timer(search_stats_gui_timer);
}
void
search_stats_gui_shutdown(void)
{
clist_save_widths(
GTK_CLIST(gui_main_window_lookup("clist_search_stats")),
PROP_SEARCH_STATS_COL_WIDTHS);
search_stats_gui_set_type(NO_SEARCH_STATS);
gm_hash_table_destroy_null(&stat_hash);
}
/* Display XML data from the result if any */
static void
search_set_xml_metadata(const record_t *rc)
{
char *indented;
indented = (rc && rc->xml) ? xml_indent(rc->xml) : NULL;
set_text_buffer(gui_main_window_lookup("text_result_info_xml"),
EMPTY_STRING(indented));
HFREE_NULL(indented);
}
static GtkStatusbar *
statusbar_get(void)
{
static GtkStatusbar *sb;
if (!sb) {
sb = GTK_STATUSBAR(gui_main_window_lookup("statusbar"));
}
return sb;
}
static GtkCList *
clist_ul_stats(void)
{
static GtkCList *clist;
if (!clist) {
clist = GTK_CLIST(gui_main_window_lookup("clist_ul_stats"));
}
return clist;
}
static void
add_node(void)
{
GtkEditable *editable = GTK_EDITABLE(gui_main_window_lookup("entry_host"));
gchar *addr;
addr = STRTRACK(gtk_editable_get_chars(editable, 0, -1));
nodes_gui_common_connect_by_name(addr);
G_FREE_NULL(addr);
gtk_entry_set_text(GTK_ENTRY(editable), "");
}
GSList *
search_gui_get_selected_searches(void)
{
GSList *sl = NULL;
GtkTreeView *tv;
tv = GTK_TREE_VIEW(gui_main_window_lookup("tree_view_search"));
gtk_tree_selection_selected_foreach(gtk_tree_view_get_selection(tv),
search_gui_get_selected_searches_helper, &sl);
return sl;
}
/**
* Performs a reverse lookup for all selected nodes.
*/
void
nodes_gui_reverse_lookup_selected(void)
{
GtkTreeView *tv;
GtkTreeSelection *selection;
tv = GTK_TREE_VIEW(gui_main_window_lookup("treeview_nodes"));
selection = gtk_tree_view_get_selection(tv);
gtk_tree_selection_selected_foreach(selection,
nodes_gui_reverse_lookup_selected_helper, NULL);
}
void
on_entry_host_changed(GtkEditable *editable, gpointer unused_udata)
{
gchar *e;
(void) unused_udata;
e = STRTRACK(gtk_editable_get_chars(editable, 0, -1));
g_strstrip(e);
gtk_widget_set_sensitive(gui_main_window_lookup("button_nodes_add"),
e[0] != '\0');
G_FREE_NULL(e);
}
void
on_popup_uploads_config_cols_activate(GtkMenuItem *unused_menuitem,
gpointer unused_udata)
{
GtkWidget *cc;
(void) unused_menuitem;
(void) unused_udata;
cc = gtk_column_chooser_new(gui_main_window_lookup("treeview_uploads"));
gtk_menu_popup(GTK_MENU(cc), NULL, NULL, NULL, NULL, 1, GDK_CURRENT_TIME);
}
static void
remove_selected_nodes(void)
{
GtkCList *clist = GTK_CLIST(gui_main_window_lookup("clist_nodes"));
GSList *node_list;
g_assert(clist != NULL);
node_list = clist_collect_data(clist, TRUE, NULL);
guc_node_remove_nodes_by_id(node_list);
g_slist_free(node_list);
}
void
search_stats_gui_init(void)
{
GtkCList *clist = GTK_CLIST(gui_main_window_lookup("clist_search_stats"));
/* set up the clist to be sorted properly */
gtk_clist_set_sort_column(clist, c_st_total);
gtk_clist_set_sort_type(clist, GTK_SORT_DESCENDING);
clist_restore_widths(clist, PROP_SEARCH_STATS_COL_WIDTHS);
stat_hash = g_hash_table_new(g_str_hash, g_str_equal);
main_gui_add_timer(search_stats_gui_timer);
}
/**
* helper func for stats_display -
* does two things:
*
* - clears out aged / infrequent search terms
* - sticks the rest of the search terms in clist_search_stats
*
*/
static gboolean
stats_hash_to_clist(gpointer key, gpointer value, gpointer unused_udata)
{
gchar *text[3];
gchar period_tmp[32];
gchar total_tmp[32];
struct term_counts *val = value;
(void) unused_udata;
/* update counts */
if (!val->period_cnt)
val->periods++;
else
val->periods = 0;
val->total_cnt += val->period_cnt;
/* try to keep the number of infrequent terms down */
if (
(1.0 * val->total_cnt / (val->periods + 2.0)) * 100 <
GUI_PROPERTY(search_stats_delcoef)
) {
G_FREE_NULL(key);
G_FREE_NULL(val);
return TRUE;
}
stat_count++;
/* update the display */
/* FIXME: make %8.8d %d and set up custom sort function */
gm_snprintf(period_tmp, sizeof period_tmp, "%8.8d", (int) val->period_cnt);
gm_snprintf(total_tmp, sizeof total_tmp, "%8.8d", (int) val->total_cnt);
text[0] = key;
text[1] = period_tmp;
text[2] = total_tmp;
{
GtkWidget *clist_search_stats =
gui_main_window_lookup("clist_search_stats");
gtk_clist_insert(GTK_CLIST(clist_search_stats), 0, text);
}
/* new period begins */
val->period_cnt = 0;
return FALSE;
}
/**
* Update all the nodes at the same time.
*
* @bug
* FIXME: We should remember for every node when it was last
* updated and only refresh every node at most once every
* second. This information should be kept in a struct pointed
* to by the row user_data and should be automatically freed
* when removing the row (see upload stats code).
*/
void
nodes_gui_update_display(time_t now)
{
GtkCList *clist;
GList *l;
gint row = 0;
gnet_node_status_t status;
clist = GTK_CLIST(gui_main_window_lookup("clist_nodes"));
gtk_clist_freeze(clist);
for (l = clist->row_list, row = 0; l; l = l->next, row++) {
const struct nid *node_id = ((GtkCListRow *) l->data)->data;
guc_node_get_status(node_id, &status);
/*
* Update additional info too if it has recorded changes.
*/
if (remove_item(hs_node_info_changed, node_id)) {
gnet_node_info_t info;
guc_node_fill_info(node_id, &info);
nodes_gui_update_node_info(&info, row);
guc_node_clear_info(&info);
}
if (remove_item(hs_node_flags_changed, node_id)) {
gnet_node_flags_t flags;
guc_node_fill_flags(node_id, &flags);
nodes_gui_update_node_flags(node_id, &flags, -1);
}
/*
* Don't update times if we've already disconnected.
*/
if (status.status == GTA_NODE_CONNECTED) {
gtk_clist_set_text(clist, row, c_gnet_connected,
short_uptime(delta_time(now, status.connect_date)));
if (status.up_date)
gtk_clist_set_text(clist, row, c_gnet_uptime,
status.up_date ?
short_uptime(delta_time(now, status.up_date)) : "...");
}
gtk_clist_set_text(clist, row, c_gnet_info,
nodes_gui_common_status_str(&status));
}
gtk_clist_thaw(clist);
}
/**
* Removes all selected nodes from the treeview and disconnects them.
*/
void
nodes_gui_remove_selected(void)
{
GtkTreeView *treeview;
GtkTreeSelection *selection;
GSList *node_list = NULL;
treeview = GTK_TREE_VIEW(gui_main_window_lookup("treeview_nodes"));
selection = gtk_tree_view_get_selection(treeview);
gtk_tree_selection_selected_foreach(selection,
nodes_gui_remove_selected_helper, &node_list);
guc_node_remove_nodes_by_id(node_list);
g_slist_free(node_list);
}
void
on_clist_uploads_select_row(GtkCList *clist, gint unused_row,
gint unused_column, GdkEvent *unused_event, gpointer unused_udata)
{
GtkWidget *button;
(void) unused_row;
(void) unused_column;
(void) unused_event;
(void) unused_udata;
button = gui_main_window_lookup("button_uploads_kill");
gtk_widget_set_sensitive(button, clist->selection != NULL);
}
void
on_button_uploads_kill_clicked(GtkButton *unused_button, gpointer unused_udata)
{
GtkTreeView *treeview;
GtkTreeSelection *selection;
(void) unused_button;
(void) unused_udata;
treeview = GTK_TREE_VIEW(gui_main_window_lookup("treeview_uploads"));
selection = gtk_tree_view_get_selection(treeview);
gtk_tree_selection_selected_foreach(selection, uploads_func_helper,
cast_func_to_pointer(kill_upload));
}
static void
fi_gui_details_treeview_init(void)
{
static const struct {
const char *title;
gfloat xalign;
gboolean editable;
} tab[] = {
{ "ID", 1.0, FALSE },
{ "Item", 1.0, FALSE },
{ "Value", 0.0, TRUE },
};
GtkTreeView *tv;
GtkTreeModel *model;
unsigned i;
tv = GTK_TREE_VIEW(gui_main_window_lookup("treeview_download_details"));
g_return_if_fail(tv);
treeview_download_details = tv;
model = GTK_TREE_MODEL(gtk_list_store_new(G_N_ELEMENTS(tab),
G_TYPE_UINT, G_TYPE_STRING, G_TYPE_STRING));
gtk_tree_view_set_model(tv, model);
g_object_unref(model);
for (i = 0; i < G_N_ELEMENTS(tab); i++) {
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
renderer = create_text_cell_renderer(tab[i].xalign);
g_object_set(G_OBJECT(renderer),
"editable", tab[i].editable,
(void *) 0);
gui_signal_connect(renderer, "edited", on_cell_edited, tv);
column = gtk_tree_view_column_new_with_attributes(tab[i].title,
renderer, "text", i, (void *) 0);
g_object_set(column,
"visible", i > 0 ? TRUE : FALSE,
"min-width", 1,
"resizable", TRUE,
"sizing", 1 == i
? GTK_TREE_VIEW_COLUMN_AUTOSIZE
: GTK_TREE_VIEW_COLUMN_FIXED,
(void *) 0);
gtk_tree_view_append_column(tv, column);
}
drag_attach_text(GTK_WIDGET(tv), download_details_get_text);
}
static void
search_details_treeview_init(void)
{
static const struct {
const gchar *title;
gfloat xalign;
gboolean editable;
} tab[] = {
{ "Item", 1.0, FALSE },
{ "Value", 0.0, TRUE },
};
GtkTreeView *tv;
GtkTreeModel *model;
guint i;
tv = GTK_TREE_VIEW(gui_main_window_lookup("treeview_search_details"));
g_return_if_fail(tv);
model = GTK_TREE_MODEL(
gtk_list_store_new(N_ITEMS(tab),
G_TYPE_STRING, G_TYPE_STRING));
gtk_tree_view_set_model(tv, model);
g_object_unref(model);
for (i = 0; i < N_ITEMS(tab); i++) {
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
renderer = create_cell_renderer(tab[i].xalign);
g_object_set(G_OBJECT(renderer),
"editable", tab[i].editable,
NULL_PTR);
column = gtk_tree_view_column_new_with_attributes(tab[i].title,
renderer, "text", i, NULL_PTR);
g_object_set(column,
"min-width", 1,
"resizable", TRUE,
"sizing", (0 == i)
? GTK_TREE_VIEW_COLUMN_AUTOSIZE
: GTK_TREE_VIEW_COLUMN_FIXED,
NULL_PTR);
gtk_tree_view_append_column(tv, column);
}
gui_signal_connect(tv,
"key-press-event", on_search_details_key_press_event, NULL);
drag_attach_text(GTK_WIDGET(tv), search_gui_details_get_text);
}
/**
* Set or clear (when rc == NULL) the information about the record.
*/
static void
search_gui_refresh_details(const record_t *rc)
{
if (NULL == clist_search_details) {
static const gchar name[] = "clist_search_details";
clist_search_details = GTK_CLIST(gui_main_window_lookup(name));
gtk_clist_set_column_auto_resize(clist_search_details, 0, TRUE);
}
g_return_if_fail(clist_search_details);
gtk_clist_freeze(clist_search_details);
search_gui_set_details(rc);
gtk_clist_thaw(clist_search_details);
search_set_xml_metadata(rc);
}
