static void editor_verbose_window_progress(EditorData *ed, const gchar *text)
{
if (!ed->vd) return;
if (ed->total)
{
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ed->vd->progress), (gdouble)ed->count / ed->total);
}
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ed->vd->progress), (text) ? text : "");
}
void warlock_time_init (void)
{
rt_bar = glade_xml_get_widget (warlock_xml, "roundtime_bar");
time_label = glade_xml_get_widget (warlock_xml, "time_label");
timer = g_timer_new ();
timer_mutex = g_mutex_new ();
timer_cond = g_cond_new ();
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (rt_bar), 0.0);
g_timeout_add(100, update_time, NULL);
}
gboolean update_fn(gpointer data)
{
if (pbar1 && pbar2 && pbar3) {
char buffer[32];
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(pbar1), (float)pdata1 / (float)MAXVAL);
snprintf(buffer, 32, "%02d/%02d", pdata1, MAXVAL);
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(pbar1), buffer);
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(pbar2), (float)pdata2 / (float)MAXVAL);
snprintf(buffer, 32, "%02d/%02d", pdata2, MAXVAL);
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(pbar2), buffer);
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(pbar3), (float)pdata3 / (float)MAXVAL);
snprintf(buffer, 32, "%02d/%02d", pdata3, MAXVAL);
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(pbar3), buffer);
}
return TRUE;
}
static gboolean
onProgressDialogRefresh( gpointer data )
{
char * str = NULL;
MakeMetaUI * ui = data;
const tr_metainfo_builder * b = ui->builder;
GtkDialog * d = GTK_DIALOG( ui->progress_dialog );
GtkProgressBar * p = GTK_PROGRESS_BAR( ui->progress_bar );
const double fraction = b->pieceCount ? ((double)b->pieceIndex / b->pieceCount) : 0;
char * base = g_path_get_basename( b->top );
/* progress label */
if( !b->isDone )
str = g_strdup_printf( _( "Creating \"%s\"" ), base );
else if( b->result == TR_MAKEMETA_OK )
str = g_strdup_printf( _( "Created \"%s\"!" ), base );
else if( b->result == TR_MAKEMETA_URL )
str = g_strdup_printf( _( "Error: invalid announce URL \"%s\"" ), b->errfile );
else if( b->result == TR_MAKEMETA_CANCELLED )
str = g_strdup_printf( _( "Cancelled" ) );
else if( b->result == TR_MAKEMETA_IO_READ )
str = g_strdup_printf( _( "Error reading \"%s\": %s" ), b->errfile, g_strerror( b->my_errno ) );
else if( b->result == TR_MAKEMETA_IO_WRITE )
str = g_strdup_printf( _( "Error writing \"%s\": %s" ), b->errfile, g_strerror( b->my_errno ) );
else
g_assert_not_reached( );
if( str != NULL ) {
gtr_label_set_text( GTK_LABEL( ui->progress_label ), str );
g_free( str );
}
/* progress bar */
if( !b->pieceIndex )
str = g_strdup( "" );
else {
char sizebuf[128];
tr_strlsize( sizebuf, (uint64_t)b->pieceIndex *
(uint64_t)b->pieceSize, sizeof( sizebuf ) );
/* how much data we've scanned through to generate checksums */
str = g_strdup_printf( _( "Scanned %s" ), sizebuf );
}
gtk_progress_bar_set_fraction( p, fraction );
gtk_progress_bar_set_text( p, str );
g_free( str );
/* buttons */
gtk_dialog_set_response_sensitive( d, GTK_RESPONSE_CANCEL, !b->isDone );
gtk_dialog_set_response_sensitive( d, GTK_RESPONSE_CLOSE, b->isDone );
gtk_dialog_set_response_sensitive( d, GTK_RESPONSE_ACCEPT, b->isDone && !b->result );
g_free( base );
return TRUE;
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// update_cal_progress_window
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
void update_cal_progress_window(int count)
{
extern GladeXML *gui;
char text[50];
sprintf(text, "Averaged %d of %d periods", count+1, PERIODS_TO_AVERAGE);
gdk_threads_enter(); // Get GDK lock
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(glade_xml_get_widget(gui, "cal_progress_bar")),((double)(count+1)*1.0/PERIODS_TO_AVERAGE));
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(glade_xml_get_widget(gui, "cal_progress_bar")),text);
gdk_threads_leave(); // Release GDK lock
}
static EditorVerboseData *editor_verbose_window(EditorData *ed, const gchar *text)
{
EditorVerboseData *vd;
GtkWidget *scrolled;
GtkWidget *hbox;
gchar *buf;
vd = g_new0(EditorVerboseData, 1);
vd->gd = file_util_gen_dlg(_("Edit command results"), "editor_results",
NULL, FALSE,
NULL, ed);
buf = g_strdup_printf(_("Output of %s"), text);
generic_dialog_add_message(vd->gd, NULL, buf, NULL);
g_free(buf);
vd->button_stop = generic_dialog_add_button(vd->gd, GTK_STOCK_STOP, NULL,
editor_verbose_window_stop, FALSE);
gtk_widget_set_sensitive(vd->button_stop, FALSE);
vd->button_close = generic_dialog_add_button(vd->gd, GTK_STOCK_CLOSE, NULL,
editor_verbose_window_close, TRUE);
gtk_widget_set_sensitive(vd->button_close, FALSE);
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(vd->gd->vbox), scrolled, TRUE, TRUE, 5);
gtk_widget_show(scrolled);
vd->text = gtk_text_view_new();
gtk_text_view_set_editable(GTK_TEXT_VIEW(vd->text), FALSE);
gtk_widget_set_size_request(vd->text, EDITOR_WINDOW_WIDTH, EDITOR_WINDOW_HEIGHT);
gtk_container_add(GTK_CONTAINER(scrolled), vd->text);
gtk_widget_show(vd->text);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vd->gd->vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
vd->progress = gtk_progress_bar_new();
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(vd->progress), 0.0);
gtk_box_pack_start(GTK_BOX(hbox), vd->progress, TRUE, TRUE, 0);
gtk_widget_show(vd->progress);
vd->spinner = spinner_new(NULL, SPINNER_SPEED);
gtk_box_pack_start(GTK_BOX(hbox), vd->spinner, FALSE, FALSE, 0);
gtk_widget_show(vd->spinner);
gtk_widget_show(vd->gd->dialog);
ed->vd = vd;
return vd;
}
static gboolean fill (gpointer user_data) {
GtkWidget *progress_bar = user_data;
gdouble fraction;
fraction = gtk_progress_bar_get_fraction (GTK_PROGRESS_BAR (progress_bar));
fraction += 0.1;
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progress_bar), fraction);
if (fraction < 1.0) return TRUE;
return FALSE;
}
static void g_file_copy_progress_handler(goffset current_num_bytes,
goffset total_num_bytes, gpointer user_data)
{
GtkProgressBar *progress_bar = GTK_PROGRESS_BAR(user_data);
gchar buf[1024] = { 0 };
g_sprintf(buf, "%ld KB / %ld KB", current_num_bytes / 1024,
total_num_bytes / 1024);
gtk_progress_bar_set_show_text(progress_bar,TRUE);
gtk_progress_bar_set_text(progress_bar, buf);
gtk_progress_bar_set_fraction(progress_bar, (gdouble)current_num_bytes / (gdouble)total_num_bytes);
}
static void
gimp_thumb_box_progress_set_value (GimpProgress *progress,
gdouble percentage)
{
if (gimp_thumb_box_progress_is_active (progress))
{
GimpThumbBox *box = GIMP_THUMB_BOX (progress);
GtkProgressBar *bar = GTK_PROGRESS_BAR (box->progress);
gtk_progress_bar_set_fraction (bar, percentage);
}
}
static void extract_selected_iter(GtkTreeModel *model, GtkTreePath *path,
GtkTreeIter *iter, gpointer d) {
GtkProgressBar *prog=GTK_PROGRESS_BAR(d);
gchar *trk=NULL;
AkaiOsVTrack *vt=NULL;
gtk_tree_model_get(model, iter, 0, &trk, -1);
_DBG(_DBG_GUI,"extracting track: %s\n", trk);
gtk_progress_bar_set_text(prog, trk);
gtk_progress_bar_set_fraction(prog, 0.0);
extract_track(trk, prog);
g_free(trk);
}
/* when receive/send is complete */
static void
receive_done (char *uri, void *data)
{
struct _send_info *info = data;
/* if we've been called to run again - run again */
if (info->type == SEND_SEND && info->state == SEND_ACTIVE && info->again) {
info->again = 0;
mail_send_queue (mail_component_get_folder(NULL, MAIL_COMPONENT_FOLDER_OUTBOX),
info->uri,
FILTER_SOURCE_OUTGOING,
info->cancel,
receive_get_folder, info,
receive_status, info,
receive_done, info);
return;
}
if (info->progress_bar) {
const gchar *text;
gtk_progress_bar_set_fraction(
GTK_PROGRESS_BAR (info->progress_bar), 1.0);
if (info->state == SEND_CANCELLED)
text = _("Canceled.");
else {
text = _("Complete.");
info->state = SEND_COMPLETE;
}
gtk_label_set_text (GTK_LABEL (info->status_label), text);
}
if (info->cancel_button)
gtk_widget_set_sensitive (info->cancel_button, FALSE);
/* remove/free this active download */
d(printf("%s: freeing info %p\n", G_STRFUNC, info));
if (info->type == SEND_SEND)
g_hash_table_steal(info->data->active, SEND_URI_KEY);
else
g_hash_table_steal(info->data->active, info->uri);
info->data->infos = g_list_remove(info->data->infos, info);
if (g_hash_table_size(info->data->active) == 0) {
if (info->data->gd)
gtk_widget_destroy((GtkWidget *)info->data->gd);
free_send_data();
}
free_send_info(info);
}
static void
gimp_progress_bar_end (gpointer user_data)
{
GimpProgressBar *bar = GIMP_PROGRESS_BAR (user_data);
gtk_progress_bar_set_text (GTK_PROGRESS_BAR (bar), " ");
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (bar), 0.0);
if (gtk_widget_is_drawable (GTK_WIDGET (bar)))
while (gtk_events_pending ())
gtk_main_iteration ();
}
static void ap_gtk_timeout_start (APUpdateType type) {
APProgressBar *progress_bar;
progress_bar = g_hash_table_lookup (progress_bars, GINT_TO_POINTER(type));
if (progress_bar->timeout) {
purple_timeout_remove (progress_bar->timeout);
}
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progress_bar->bar), 0);
progress_bar->timeout =
purple_timeout_add (BAH, progress_update, progress_bar);
progress_update (progress_bar);
}
void SetProgressBar(double percent){
gtk_widget_show(progress);
if ((int)(percent*100) >= 0){
char text[20];
sprintf(text,"%d%%",(int)(percent*100));
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progress),percent);
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(progress), text);
if (percent == 1){
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(progress), "Download Complete");
}
}
}
static void report_gui_progress(GtkWidget *pbar, gdouble fraction)
{
char *title = gtk_object_get_data(GTK_OBJECT(pbar), "title");
char text[32];
if ( fraction > 1 )
fraction = 1;
snprintf(text, sizeof(text), "%s: %ld %%", title, lround(fraction*100));
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(pbar), text);
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(pbar), fraction);
}
void
init_preview_image(signal_user_data_t *ud)
{
GtkWidget *widget;
gint width, height;
g_debug("set_preview_button_image ()");
gint title_id, titleindex;
const hb_title_t *title;
live_preview_stop(ud);
title_id = ghb_dict_get_int(ud->settings, "title");
title = ghb_lookup_title(title_id, &titleindex);
if (title == NULL && ud->preview->pix != NULL)
{
g_object_unref(ud->preview->pix);
ud->preview->pix = NULL;
}
widget = GHB_WIDGET (ud->builder, "preview_frame");
ud->preview->frame = ghb_widget_int(widget) - 1;
if (ud->preview->encoded[ud->preview->frame])
{
widget = GHB_WIDGET(ud->builder, "live_progress_box");
gtk_widget_hide (widget);
widget = GHB_WIDGET(ud->builder, "live_preview_progress");
gtk_widget_show (widget);
}
else
{
widget = GHB_WIDGET(ud->builder, "live_preview_progress");
gtk_widget_hide (widget);
widget = GHB_WIDGET(ud->builder, "live_progress_box");
gtk_widget_show (widget);
widget = GHB_WIDGET(ud->builder, "live_encode_progress");
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(widget), "");
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(widget), 0);
}
if (ud->preview->pix != NULL)
g_object_unref(ud->preview->pix);
if (ud->preview->scaled_pix != NULL)
g_object_unref(ud->preview->scaled_pix);
ud->preview->pix = ghb_get_preview_image(title, ud->preview->frame,
ud, &width, &height);
if (ud->preview->pix == NULL)
return;
int pix_width, pix_height;
pix_width = gdk_pixbuf_get_width(ud->preview->pix);
pix_height = gdk_pixbuf_get_height(ud->preview->pix);
preview_set_size(ud, pix_width, pix_height);
}
static void set_calibration_progress(GtkProgressBar *pbar, float fraction)
{
if (gtk_widget_get_visible(GTK_WIDGET(pbar))) {
char ptext[64];
gdk_threads_enter();
snprintf(ptext, sizeof(ptext), "Calibration Progress (%.2f %%)", fraction * 100);
gtk_progress_bar_set_text(pbar, ptext);
gtk_progress_bar_set_fraction(pbar, fraction);
gdk_threads_leave();
}
}
static guint32
progress_start_cb(GWEN_GUI *gwen_gui, uint32_t progressFlags, const char *title,
const char *text, uint64_t total, uint32_t guiid)
{
GncGWENGui *gui = GETDATA_GUI(gwen_gui);
Progress *progress;
g_return_val_if_fail(gui, -1);
ENTER("gui=%p, flags=%d, title=%s, total=%" G_GUINT64_FORMAT, gui,
progressFlags, title ? title : "(null)", (guint64)total);
if (!gui->progresses)
{
/* Top-level progress */
if (progressFlags & GWEN_GUI_PROGRESS_SHOW_PROGRESS)
{
gtk_widget_set_sensitive(gui->top_progress, TRUE);
gtk_progress_bar_set_fraction(
GTK_PROGRESS_BAR(gui->top_progress), 0.0);
gui->max_actions = total;
}
else
{
gtk_widget_set_sensitive(gui->top_progress, FALSE);
gui->max_actions = -1;
}
set_running(gui);
}
/* Put progress onto the stack */
progress = g_new0(Progress, 1);
progress->gui = gui;
progress->title = title ? g_strdup(title) : "";
gui->progresses = g_list_prepend(gui->progresses, progress);
if (progressFlags & GWEN_GUI_PROGRESS_DELAY)
{
/* Show progress later */
progress->source = g_timeout_add(GWEN_GUI_DELAY_SECS * 1000,
(GSourceFunc) show_progress_cb,
progress);
}
else
{
/* Show it now */
progress->source = 0;
show_progress(gui, progress);
}
LEAVE(" ");
return g_list_length(gui->progresses);
}
static void
update_progress (ProgressWidgetData *data)
{
double progress;
progress = nautilus_progress_info_get_progress (data->info);
if (progress < 0) {
gtk_progress_bar_pulse (data->progress_bar);
} else {
gtk_progress_bar_set_fraction (data->progress_bar, progress);
}
}
static void
update_progress (NautilusProgressInfoWidget *self)
{
double progress;
progress = nautilus_progress_info_get_progress (self->priv->info);
if (progress < 0) {
gtk_progress_bar_pulse (GTK_PROGRESS_BAR (self->priv->progress_bar));
} else {
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (self->priv->progress_bar), progress);
}
}
static void _battery_set(Battery * battery, gdouble value, gboolean charging)
{
char buf[256];
snprintf(buf, sizeof(buf), "%.0f%% ", value);
/* XXX only show when necessary? */
if(value >= 0.0 && value <= 100.0)
{
gtk_widget_show(battery->box);
if(battery->progress != NULL)
{
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(
battery->progress),
value / 100.0);
gtk_widget_show(battery->progress);
}
}
else if(battery->progress != NULL)
gtk_widget_hide(battery->progress);
if(value < 0.0)
{
_set_image(battery, BATTERY_LEVEL_UNKNOWN, FALSE);
value = 0.0;
snprintf(buf, sizeof(buf), "%s", _("Unknown"));
}
else if(value <= 1.0)
_set_image(battery, BATTERY_LEVEL_EMPTY, charging);
else if(value <= 10.0)
_set_image(battery, BATTERY_LEVEL_CAUTION, charging);
else if(value <= 20.0)
_set_image(battery, BATTERY_LEVEL_LOW, charging);
else if(value <= 75.0)
_set_image(battery, BATTERY_LEVEL_GOOD, charging);
else if(value <= 100.0)
_set_image(battery, BATTERY_LEVEL_FULL, charging);
else
{
_set_image(battery, BATTERY_LEVEL_ERROR, FALSE);
value = 0.0;
snprintf(buf, sizeof(buf), "%s", _("Error"));
}
if(battery->label != NULL)
gtk_label_set_text(GTK_LABEL(battery->label), buf);
if(battery->progress != NULL)
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(battery->progress),
buf);
#if GTK_CHECK_VERSION(2, 12, 0)
snprintf(buf, sizeof(buf), _("Battery level: %.0f%%%s"), value,
charging ? _(" (charging)") : "");
gtk_widget_set_tooltip_text(battery->box, buf);
#endif
}
/**
* editable: The GTK_ENTRY that changed
* user_data: the progress bar to update
*
* Will update the password quality displayed in the progress bar.
*
**/
static void
on_password_changed (GtkEditable *editable, gpointer user_data)
{
const char *password;
int length, i;
int upper, lower, digit, misc;
gdouble pwstrength;
password = gtk_entry_get_text (GTK_ENTRY (editable));
/*
* This code is based on the Master Password dialog in Firefox
* (pref-masterpass.js)
* Original code triple-licensed under the MPL, GPL, and LGPL
* so is license-compatible with this file
*/
length = strlen (password);
upper = 0;
lower = 0;
digit = 0;
misc = 0;
for ( i = 0; i < length ; i++) {
if (g_ascii_isdigit (password[i]))
digit++;
else if (g_ascii_islower (password[i]))
lower++;
else if (g_ascii_isupper (password[i]))
upper++;
else
misc++;
}
if (length > 5)
length = 5;
if (digit > 3)
digit = 3;
if (upper > 3)
upper = 3;
if (misc > 3)
misc = 3;
pwstrength = ((length*0.1)-0.2) + (digit*0.1) + (misc*0.15) + (upper*0.1);
if (pwstrength < 0.0)
pwstrength = 0.0;
if (pwstrength > 1.0)
pwstrength = 1.0;
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (user_data), pwstrength);
}
void gtkhash_hash_file_report_cb(void *data, goffset file_size,
goffset total_read, GTimer *timer)
{
gdk_threads_enter();
struct page_s *page = data;
gtk_progress_bar_set_fraction(page->progressbar,
(double)total_read /
(double)file_size);
double elapsed = g_timer_elapsed(timer, NULL);
if (elapsed <= 1)
goto out;
// Update progressbar text...
unsigned int s = elapsed / total_read * (file_size - total_read);
#if ((GLIB_MAJOR_VERSION == 2) && (GLIB_MINOR_VERSION < 30))
char *total_read_str = g_format_size_for_display(total_read);
char *file_size_str = g_format_size_for_display(file_size);
char *speed_str = g_format_size_for_display(total_read / elapsed);
#else
char *total_read_str = g_format_size(total_read);
char *file_size_str = g_format_size(file_size);
char *speed_str = g_format_size(total_read / elapsed);
#endif
char *text;
if (s > 60) {
unsigned int m = s / 60;
if (m == 1)
text = g_strdup_printf(_("%s of %s - 1 minute left (%s/sec)"),
total_read_str, file_size_str, speed_str);
else
text = g_strdup_printf(_("%s of %s - %u minutes left (%s/sec)"),
total_read_str, file_size_str, m, speed_str);
} else {
if (s == 1)
text = g_strdup_printf(_("%s of %s - 1 second left (%s/sec)"),
total_read_str, file_size_str, speed_str);
else
text = g_strdup_printf(_("%s of %s - %u seconds left (%s/sec)"),
total_read_str, file_size_str, s, speed_str);
}
gtk_progress_bar_set_text(page->progressbar, text);
g_free(text);
g_free(speed_str);
g_free(file_size_str);
g_free(total_read_str);
out:
gdk_threads_leave();
}
static void remmina_plugin_spice_file_transfer_progress_cb(GObject *task, GParamSpec *param_spec, RemminaProtocolWidget *gp)
{
TRACE_CALL(__func__);
RemminaPluginSpiceXferWidgets *widgets;
RemminaPluginSpiceData *gpdata = GET_PLUGIN_DATA(gp);
widgets = g_hash_table_lookup(gpdata->file_transfers, task);
if (widgets) {
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(widgets->progress),
spice_file_transfer_task_get_progress(SPICE_FILE_TRANSFER_TASK(task)));
}
}
static void
pgd_find_update_progress (PgdFindDemo *demo,
gint scanned)
{
gchar *str;
str = g_strdup_printf ("Searching ... (%d%%)",
MIN (scanned * 100 / demo->n_pages, 100));
gtk_progress_bar_set_text (GTK_PROGRESS_BAR (demo->progress), str);
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (demo->progress),
MIN ((gdouble)scanned / demo->n_pages, 1.0));
g_free (str);
}
static gboolean update_audio_meter(volume_ctx_t *ctx) {
float volume_db=ctx->get_volume(ctx->data);
float frac=(volume_db-UNSIGNIFICANT_VOLUME)/(float)(-UNSIGNIFICANT_VOLUME-3.0);
if (frac<0) frac=0;
if (frac>1.0) frac=1.0;
if (frac<ctx->last_value) {
frac=(frac*SMOOTH)+(ctx->last_value*(1-SMOOTH));
}
ctx->last_value=frac;
//g_message("volume_db=%f, frac=%f",volume_db,frac);
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ctx->widget),frac);
return TRUE;
}
void
cb_compose_images_set_image_progress (CbComposeImages *self,
const char *image_path,
double progress)
{
const Image *image = find_image (self, image_path);
if (image == NULL)
return;
gtk_widget_show (image->progressbar);
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (image->progressbar), progress);
}
void get_convert()
{
gtk_progress_bar_set_show_text(GTK_PROGRESS_BAR(progress_bar), TRUE);
gtk_widget_set_sensitive(button_add, FALSE);
gtk_widget_set_sensitive(button_convert, FALSE);
gtk_widget_set_sensitive(button_stop, TRUE);
gtk_widget_set_sensitive(button_choose_dir, FALSE);
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progress_bar), 0.3);
printf("%s\n", "Convert");
}
void get_stop()
{
gtk_progress_bar_set_show_text(GTK_PROGRESS_BAR(progress_bar), FALSE);
gtk_widget_set_sensitive(button_add, TRUE);
gtk_widget_set_sensitive(button_convert, TRUE);
gtk_widget_set_sensitive(button_stop, FALSE);
gtk_widget_set_sensitive(button_choose_dir, TRUE);
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progress_bar), 0.0);
printf("Stop\n");
}
static void
level_message_cb(PurpleMedia *media, gchar *session_id, gchar *participant,
double level, PidginMedia *gtkmedia)
{
GtkWidget *progress = NULL;
if (participant == NULL)
progress = gtkmedia->priv->send_progress;
else
progress = pidgin_media_get_widget(gtkmedia, session_id, participant);
if (progress)
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progress), level * 5);
}
