/* settings interface functions (UI -> Core)*/
guint16
guc_listen_port(void)
{
guint32 port;
gnet_prop_get_guint32_val(PROP_LISTEN_PORT, &port);
return port;
}
static void
icon_timer(time_t unused_now)
{
GdkRectangle rect;
guint con_old, up_old, down_old;
(void) unused_now;
/* don't do anything if icon isn't even visible or the
application is closing */
if (!icon_visible_fg || icon_close_fg)
return;
/* this may be useful someday */
if (icon_just_mapped_fg) {
icon_just_mapped_fg = FALSE;
}
/* get current values */
con_old = leaf_cnt + norm_cnt + ultra_cnt;
up_old = up_cnt;
down_old = down_cnt;
gnet_prop_get_guint32_val(PROP_NODE_LEAF_COUNT, &leaf_cnt);
gnet_prop_get_guint32_val(PROP_NODE_NORMAL_COUNT, &norm_cnt);
gnet_prop_get_guint32_val(PROP_NODE_ULTRA_COUNT, &ultra_cnt);
gnet_prop_get_guint32_val(PROP_MAX_CONNECTIONS, &con_max);
gnet_prop_get_guint32_val(PROP_UL_RUNNING, &up_cnt);
gnet_prop_get_guint32_val(PROP_MAX_UPLOADS, &up_max);
gnet_prop_get_guint32_val(PROP_DL_RUNNING_COUNT, &down_cnt);
gnet_prop_get_guint32_val(PROP_MAX_DOWNLOADS, &down_max);
/* if nothing has changed, then don't redraw */
if (con_old == leaf_cnt + norm_cnt + ultra_cnt)
if (up_old == up_cnt && down_old == down_cnt)
return;
/*
* For some reason, gtk_widget_queue_draw(canvas) will
* not work in either GTK 1 or GTK 2, probably an issue
* with the fact that the icon window is an icon. Whatever
* the reason, to get the canvas widget to redraw, it
* has to be done that hard way.
*/
rect.x = rect.y = 0;
rect.width = canvas->allocation.width;
rect.height = canvas->allocation.height;
gdk_window_invalidate_rect(canvas->window, &rect, FALSE);
}
/**
* Queue a bitzi queries from the search context menu
*/
void
on_popup_search_metadata_activate(GtkMenuItem *unused_menuitem,
gpointer unused_udata)
{
GList *node_list;
GSList *data_list;
search_t *search;
guint32 bitzi_debug;
(void) unused_menuitem;
(void) unused_udata;
search = search_gui_get_current_search();
g_assert(search != NULL);
gtk_clist_freeze(GTK_CLIST(search->tree));
node_list = g_list_copy(GTK_CLIST(search->tree)->selection);
data_list = search_cb_collect_ctree_data(GTK_CTREE(search->tree),
node_list, gui_record_sha1_eq);
/* Make sure the column is actually visible. */
{
static const gint min_width = 80;
GtkCList *clist = GTK_CLIST(search->tree);
gtk_clist_set_column_visibility(clist, c_sr_meta, TRUE);
if (clist->column[c_sr_meta].width < min_width)
gtk_clist_set_column_width(clist, c_sr_meta, min_width);
}
/* Queue up our requests */
gnet_prop_get_guint32_val(PROP_BITZI_DEBUG, &bitzi_debug);
if (bitzi_debug > 10)
g_debug("on_popup_search_metadata_activate: %d items, %p",
g_slist_position(data_list, g_slist_last(data_list)) + 1,
cast_to_gconstpointer(data_list));
G_SLIST_FOREACH(data_list, search_gui_queue_bitzi_by_sha1);
gtk_clist_thaw(GTK_CLIST(search->tree));
g_slist_free(data_list);
g_list_free(node_list);
}
/**
* @return whether the entry for the upload `ul' should be removed
* from the UI with respect to the configured behaviour.
*/
gboolean
upload_should_remove(time_t now, const upload_row_data_t *ul)
{
property_t prop = 0;
g_assert(NULL != ul);
switch (ul->status) {
case GTA_UL_COMPLETE:
prop = PROP_AUTOCLEAR_COMPLETED_UPLOADS;
break;
case GTA_UL_CLOSED:
case GTA_UL_ABORTED:
prop = PROP_AUTOCLEAR_FAILED_UPLOADS;
break;
case GTA_UL_PUSH_RECEIVED:
case GTA_UL_SENDING:
case GTA_UL_HEADERS:
case GTA_UL_WAITING:
case GTA_UL_EXPECTING:
case GTA_UL_QUEUED:
case GTA_UL_QUEUE:
case GTA_UL_QUEUE_WAITING:
break;
}
if (0 != prop) {
guint32 val;
time_delta_t grace;
gnet_prop_get_guint32_val(PROP_ENTRY_REMOVAL_TIMEOUT, &val);
grace = val;
if (delta_time(now, ul->last_update) > grace) {
gboolean auto_remove;
gui_prop_get_boolean_val(prop, &auto_remove);
return auto_remove;
}
}
return FALSE;
}
void
bitzi_gui_update(const bitzi_data_t *bitzi_data)
{
guint32 bitzi_debug;
g_assert(bitzi_data != NULL);
gnet_prop_get_guint32_val(PROP_BITZI_DEBUG, &bitzi_debug);
if (bitzi_debug > 10)
g_debug("bitzi_gui_update: data %p, size %s, "
"goodness %f, judgment %d, type %s, details %s",
cast_to_gconstpointer(bitzi_data),
uint64_to_string(bitzi_data->size),
bitzi_data->goodness,
bitzi_data->judgment,
NULL_STRING(bitzi_data->mime_type),
NULL_STRING(bitzi_data->mime_desc));
/* Update the various GUI elements */
search_gui_metadata_update(bitzi_data);
}
/**
* @return a pointer to a static buffer containing a string which
* describes the current status of the upload.
*/
const gchar *
uploads_gui_status_str(const gnet_upload_status_t *u,
const upload_row_data_t *data)
{
static gchar tmpstr[256];
if (u->pos < data->range_start)
return _("No output yet..."); /* Never wrote anything yet */
switch (u->status) {
case GTA_UL_PUSH_RECEIVED:
return _("Got push, connecting back...");
case GTA_UL_COMPLETE:
{
time_delta_t d = delta_time(data->last_update, data->start_date);
filesize_t requested = data->range_end - data->range_start + 1;
size_t rw;
rw = str_bprintf(tmpstr, sizeof(tmpstr),
"%s (%s) %s %s#%u", _("Completed"),
d > 0 ? short_rate(requested / d, show_metric_units())
: _("< 1s"),
d > 0 ? short_time(d) : "",
u->parq_quick ? _("(quick) ") : "",
u->reqnum);
if (u->error_count)
rw += str_bprintf(&tmpstr[rw], sizeof(tmpstr)-rw,
_(" E=%u"), u->error_count);
}
break;
case GTA_UL_SENDING:
{
/* Time Remaining at the current rate, in seconds */
filesize_t tr = (data->range_end + 1 - u->pos) / MAX(1, u->avg_bps);
gdouble p = uploads_gui_progress(u, data);
time_t now = tm_time();
gboolean stalled = delta_time(now, data->last_update) > IO_STALLED;
gchar pbuf[32];
size_t rw;
str_bprintf(pbuf, sizeof pbuf, "%5.02f%% ", p * 100.0);
rw = str_bprintf(tmpstr, sizeof tmpstr, _("%s(%s) TR: %s %s#%u"),
p > 1.0 ? pbuf : "",
stalled ? _("stalled")
: short_rate(u->bps, show_metric_units()),
short_time(tr),
u->parq_quick ? _("(quick) ") : "",
u->reqnum);
if (u->error_count)
rw += str_bprintf(&tmpstr[rw], sizeof(tmpstr)-rw,
_(" E=%u"), u->error_count);
}
break;
case GTA_UL_HEADERS:
return _("Waiting for headers...");
case GTA_UL_EXPECTING:
if (u->error_count)
str_bprintf(tmpstr, sizeof(tmpstr),
_("%s %s#%u E=%u"), _("Waiting for further request..."),
u->parq_quick ? _("(quick) ") : "", u->reqnum, u->error_count);
else
str_bprintf(tmpstr, sizeof(tmpstr),
"%s %s#%u", _("Waiting for further request..."),
u->parq_quick ? _("(quick) ") : "", u->reqnum);
break;
case GTA_UL_WAITING:
return _("Reading follow-up request...");
case GTA_UL_ABORTED:
return _("Transmission aborted");
case GTA_UL_CLOSED:
return _("Transmission complete");
case GTA_UL_QUEUED: /* Actively queued */
{
guint32 max_up, cur_up;
gboolean queued;
guint available = 0;
gchar tbuf[64];
size_t rw;
gnet_prop_get_guint32_val(PROP_MAX_UPLOADS, &max_up);
gnet_prop_get_guint32_val(PROP_UL_RUNNING, &cur_up);
if (cur_up < max_up)
available = max_up - cur_up;
/*
* We'll flag as "Waiting" instead of "Queued" uploads
* that are actively queued and whose position is low
* enough to possibly get scheduled at the next request,
* given the amount of free slots.
* --RAM, 2007-08-21
*/
queued = u->parq_position > available;
if (u->parq_retry > 0) {
str_bprintf(tbuf, sizeof tbuf,
" %s,", short_time(u->parq_retry));
} else {
tbuf[0] = '\0';
}
rw = str_bprintf(tmpstr, sizeof tmpstr,
_("%s [%d] (slot %d/%d)%s %s %s"),
u->parq_frozen ? _("Frozen") :
queued ? _("Queued") : _("Waiting"),
u->parq_queue_no,
u->parq_position,
u->parq_size,
tbuf,
_("lifetime:"),
short_time(u->parq_lifetime));
if (u->error_count)
rw += str_bprintf(&tmpstr[rw], sizeof(tmpstr)-rw,
_(" E=%u"), u->error_count);
}
break;
case GTA_UL_QUEUE:
/*
* PARQ wants to inform a client that action from the client its side
* is wanted. So it is trying to connect back.
* -- JA, 15/04/2003
*/
return _("Sending QUEUE, connecting back...");
case GTA_UL_QUEUE_WAITING:
/*
* PARQ made a connect back because some action from the client is
* wanted. The connection is established and now waiting for some action
* -- JA, 15/04/2003
*/
return _("Sent QUEUE, waiting for headers...");
}
return tmpstr;
}
