void statusbar_progress_all (gint done, gint total, gint step) { GtkProgressBar *progressbar = GTK_PROGRESS_BAR( mainwindow_get_mainwindow()->progressbar); gchar buf[32]; if (total && done % step == 0) { #ifdef GENERIC_UMPC /* use a more compact format */ const gchar *format = "%d/%d"; #else const gchar *format = "%d / %d"; #endif g_snprintf(buf, sizeof(buf), format, done, total); gtk_progress_bar_set_text(progressbar, buf); gtk_progress_bar_set_fraction(progressbar, (gfloat)done / (gfloat)total); if (!gtk_widget_get_visible(GTK_WIDGET(progressbar))) gtk_widget_show(GTK_WIDGET(progressbar)); } else if (total == 0) { gtk_progress_bar_set_text(progressbar, ""); gtk_progress_bar_set_fraction(progressbar, 0.0); gtk_widget_hide(GTK_WIDGET(progressbar)); } }
static void update_sensitivity (GutachterWidget* self) { GtkProgressBar* progress = GTK_PROGRESS_BAR (PRIV (self)->progress); gtk_widget_set_sensitive (PRIV (self)->notebook, PRIV (self)->suite != NULL); if (PRIV (self)->suite) { if (gutachter_suite_get_status (PRIV (self)->suite) == GUTACHTER_SUITE_INDETERMINED) { gtk_progress_bar_set_fraction (progress, 0.0); } else { gtk_progress_bar_pulse (progress); gtk_progress_bar_set_text (progress, _("Loading Test Paths...")); } } else { gtk_progress_bar_set_fraction (progress, 0.0); gtk_progress_bar_set_text (progress, _("no test selected")); } }
static void gxi_update_progress_bar (const gchar *message, double percentage) { if (!progress_window) { progress_window = gtk_window_new (GTK_WINDOW_POPUP); progress_bar = GTK_PROGRESS_BAR (gtk_progress_bar_new ()); gtk_container_set_border_width (GTK_CONTAINER (progress_window), 12); gtk_container_add (GTK_CONTAINER (progress_window), GTK_WIDGET (progress_bar)); gtk_widget_show (GTK_WIDGET (progress_bar)); } if (percentage < 0) { gtk_progress_bar_set_text (progress_bar, NULL); gtk_progress_bar_set_fraction (progress_bar, 0.0); gtk_widget_hide (progress_window); } else { gtk_progress_bar_set_text (progress_bar, message); if (percentage <= 100) gtk_progress_bar_set_fraction (progress_bar, percentage / 100); else gtk_progress_bar_pulse (progress_bar); gtk_widget_show (progress_window); } }
static gboolean gimmix_timer (void) { gchar time[15]; int new_status; float fraction; mpd_status_update (gmo); new_status = mpd_player_get_state (gmo); if (status == new_status) { if (status == MPD_PLAYER_PLAY || status == MPD_PLAYER_PAUSE) { gimmix_get_progress_status (gmo, &fraction, time); gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), fraction); gtk_progress_bar_set_text (GTK_PROGRESS_BAR(progress), time); /* Update the system tray tooltip progress bar */ if (strncasecmp(cfg_get_key_value(conf, "enable_systray"), "true", 4) == 0) if (strncasecmp(cfg_get_key_value(conf, "enable_notification"), "true", 4) == 0) { gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(tooltip->progressbar), fraction); gtk_progress_bar_set_text (GTK_PROGRESS_BAR(tooltip->progressbar), time); } } return TRUE; } else { status = new_status; return TRUE; } }
void ghb_live_encode_done(signal_user_data_t *ud, gboolean success) { GtkWidget *widget; GtkWidget *prog; ud->preview->live_id = -1; prog = GHB_WIDGET(ud->builder, "live_encode_progress"); if (success && ud->preview->encode_frame == ud->preview->frame) { gtk_progress_bar_set_text(GTK_PROGRESS_BAR(prog), "Done"); gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(prog), 1); ud->preview->encoded[ud->preview->encode_frame] = TRUE; #if defined(_ENABLE_GST) live_preview_start(ud); #endif 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 { gtk_progress_bar_set_text(GTK_PROGRESS_BAR(prog), ""); gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(prog), 0); ud->preview->encoded[ud->preview->encode_frame] = FALSE; } }
/*--------------------------------------------------------------------------*/ static void update_progress_bar (GtkProgressBar *bar, gint bytes, gint total) { gchar *string; if ( total > 0 ) { string = g_strdup_printf ("%.0f%% (%d Bytes of %d Bytes)", 100.0*((gdouble)bytes/(gdouble)total), bytes, total); gtk_progress_bar_set_text (bar, string); gtk_progress_bar_set_fraction (bar, (gdouble)bytes/(gdouble)total); g_free (string); } else { gtk_progress_bar_set_text (bar, ""); gtk_progress_bar_set_fraction (bar, 0.0); } }
static void gimmix_status_changed (MpdObj *mo, ChangedStatusType id) { if (id&MPD_CST_SONGID) { gimmix_set_song_info (); gimmix_update_current_playlist (); } if (id&MPD_CST_STATE) { int state = mpd_player_get_state (gmo); if (state == MPD_PLAYER_PLAY) { gtk_image_set_from_stock (GTK_IMAGE(image_play), "gtk-media-pause", GTK_ICON_SIZE_BUTTON); gtk_tooltips_set_tip (play_button_tooltip, play_button, _("Pause <x or c>"), NULL); gimmix_set_song_info (); } if (state == MPD_PLAYER_PAUSE) { gtk_image_set_from_stock (GTK_IMAGE(image_play), "gtk-media-play", GTK_ICON_SIZE_BUTTON); gtk_tooltips_set_tip (play_button_tooltip, play_button, _("Play <x or c>"), NULL); } if (state == MPD_PLAYER_STOP) { gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 0.0); gtk_progress_bar_set_text (GTK_PROGRESS_BAR(progress), _("Stopped")); if (strncasecmp(cfg_get_key_value(conf, "enable_systray"), "true", 4) == 0) { gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(tooltip->progressbar), 0.0); gtk_progress_bar_set_text (GTK_PROGRESS_BAR(tooltip->progressbar), _("Stopped")); } gimmix_show_ver_info (); gtk_image_set_from_stock (GTK_IMAGE(image_play), "gtk-media-play", GTK_ICON_SIZE_BUTTON); gtk_tooltips_set_tip (play_button_tooltip, play_button, _("Play <x or c>"), NULL); } g_object_ref_sink (play_button_tooltip); gimmix_update_current_playlist (); } if (id&MPD_CST_PLAYLIST) gimmix_update_current_playlist (); if (id&MPD_CST_VOLUME) gimmix_update_volume (); if (id&MPD_CST_RANDOM) gimmix_update_shuffle (); if (id&MPD_CST_REPEAT) gimmix_update_repeat (); return; }
static gboolean watch_extract_thread (gpointer user_data) { ExtractProgress ep; g_static_mutex_lock (&extractProgressM); memcpy (&ep, &extractProgress, sizeof (ExtractProgress)); g_static_mutex_unlock (&extractProgressM); if (ep.status != lastKnownProgress.status) { switch (ep.status) { case STATUS_INIT: break; case STATUS_MKDIR: gtk_progress_bar_set_text (GTK_PROGRESS_BAR (W(progress)), _("Creating folders...")); break; case STATUS_EXTRACT: gtk_progress_bar_set_text (GTK_PROGRESS_BAR (W(progress)), _("0%")); break; case STATUS_DONE: break; default: break; }; } if (ep.current != lastKnownProgress.current || ep.max != lastKnownProgress.max) { if (ep.max == 0) gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (W(progress)), 0.0); else gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (W(progress)), (gdouble) ep.current / (gdouble) ep.max); if (ep.status == STATUS_EXTRACT && ep.file) { char *tmp, *basename; basename = g_path_get_basename (ep.file); tmp = str_to_utf8 (basename, NULL); g_free (basename); basename = g_strdup_printf ("%.1f%%: %s", ((gdouble) ep.current / (gdouble) ep.max) * 100, tmp); g_free (tmp); gtk_progress_bar_set_text (GTK_PROGRESS_BAR (W(progress)), basename); g_free (basename); } } memcpy (&lastKnownProgress, &ep, sizeof (ExtractProgress)); return TRUE; }
static void toggle_show_text(GtkWidget *widget, ProgressData *pdata){ const gchar *text; text = gtk_progress_bar_get_text(GTK_PROGRESS_BAR(pdata->pbar)); if(text && *text){ gtk_progress_bar_set_text(GTK_PROGRESS_BAR(pdata->pbar), ""); } else{ gtk_progress_bar_set_text(GTK_PROGRESS_BAR(pdata->pbar), "some text"); } }
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 progress_update_stop (APProgressBar *progress_bar) { if (progress_bar->timeout) { purple_timeout_remove (progress_bar->timeout); progress_bar->timeout = 0; } gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress_bar->bar), 1.0); if (progress_bar->type == AP_UPDATE_PROFILE) { gtk_progress_bar_set_text (GTK_PROGRESS_BAR (progress_bar->bar), _("waiting for new profile content")); } else if (progress_bar->type == AP_UPDATE_STATUS) { gtk_progress_bar_set_text (GTK_PROGRESS_BAR (progress_bar->bar), _("waiting for new status content")); } }
void gnc_window_show_progress (const char *message, double percentage) { GncWindow *window; GtkWidget *progressbar; window = progress_bar_hack_window; if (window == NULL) return; progressbar = gnc_window_get_progressbar (window); if (progressbar == NULL) { DEBUG( "no progressbar in hack-window" ); return; } gnc_update_splash_screen(message, percentage); if (percentage < 0) { gtk_progress_bar_set_text(GTK_PROGRESS_BAR(progressbar), " "); gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progressbar), 0.0); if (GNC_WINDOW_GET_IFACE(window)->ui_set_sensitive != NULL) GNC_WINDOW_GET_IFACE(window)->ui_set_sensitive(window, TRUE); } else { if (message) gtk_progress_bar_set_text(GTK_PROGRESS_BAR(progressbar), message); if ((percentage == 0) && (GNC_WINDOW_GET_IFACE(window)->ui_set_sensitive != NULL)) GNC_WINDOW_GET_IFACE(window)->ui_set_sensitive(window, FALSE); if (percentage <= 100) { gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progressbar), percentage / 100); } else { gtk_progress_bar_pulse(GTK_PROGRESS_BAR(progressbar)); } } /* make sure new text is up */ while (gtk_events_pending ()) gtk_main_iteration (); }
gboolean download_songs_cb_foreach (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data) { gchar *file; gchar temp[MAXLEN]; int * n = (int *)data; if (abort_pressed) { return 0; } gtk_tree_model_get (model, iter, COLUMN_NAME, &file, -1); if (strncmp(file, PARENTDIR, 2)) { strncpy(remote_item, remote_path, MAXLEN-1); if (strlen(remote_path) != 1) { strncat(remote_item, "\\", MAXLEN-1); } strncat(remote_item, file, MAXLEN-1); strncpy(dest_file, dest_dir, MAXLEN-1); strncat(dest_file, "/", MAXLEN-1); strncat(dest_file, file, MAXLEN-1); gtk_entry_set_text(GTK_ENTRY(aifp_file_entry), file); gtk_editable_set_position(GTK_EDITABLE(aifp_file_entry), -1); gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progressbar_op), (float)(*n + 1) / number_of_songs); if (ifp_is_file (&ifpdev, remote_item) == TRUE) { sprintf(temp, _("%d / %d files"), *n + 1, number_of_songs); gtk_progress_bar_set_text(GTK_PROGRESS_BAR (progressbar_op), temp); ifp_download_file (&ifpdev, remote_item, dest_file, update_progress, NULL); } else { sprintf(temp, _("%d / %d directories"), *n + 1, number_of_songs); gtk_progress_bar_set_text(GTK_PROGRESS_BAR (progressbar_op), temp); ifp_download_dir (&ifpdev, remote_item, dest_file, update_progress, NULL); } aifp_update_info(); g_free(file); (*n)++; } return TRUE; }
static void on_percent(FmFileOpsJob* job, guint percent, FmProgressDisplay* data) { if(data->dlg) { char percent_text[64]; g_snprintf(percent_text, 64, "%d %%", percent); gtk_progress_bar_set_fraction(data->progress, (gdouble)percent/100); gtk_progress_bar_set_text(data->progress, percent_text); gdouble elapsed = g_timer_elapsed(data->timer, NULL); if(elapsed >= 0.5) { gdouble remaining = elapsed * (100 - percent) / percent; if(data->remaining_time) { char time_str[32]; guint secs = (guint)remaining; guint mins = 0; guint hrs = 0; if(secs > 60) { mins = secs / 60; secs %= 60; if(mins > 60) { hrs = mins / 60; mins %= 60; } } g_snprintf(time_str, 32, "%02d:%02d:%02d", hrs, mins, secs); gtk_label_set_text(data->remaining_time, time_str); } } } }
void aifp_update_info(void) { gchar temp[MAXLEN], tmp[MAXLEN]; gfloat space; if (transfer_mode == UPLOAD_MODE) { sprintf(temp, "%d", number_of_songs); sprintf(tmp, _(" (%.1f MB)"), (float)songs_size / (1024*1024)); strncat (temp, tmp, MAXLEN-1); gtk_label_set_text(GTK_LABEL(label_songs), temp); } battery_status = ifp_battery(&ifpdev); gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progressbar_battery), battery_status / 4.0); ifp_model(&ifpdev, temp, sizeof(temp)); capacity = ifp_capacity(&ifpdev); sprintf(tmp, _(" (capacity = %.1f MB)"), (float)capacity / (1024*1024)); strncat (temp, tmp, MAXLEN-1); gtk_label_set_text(GTK_LABEL(label_model), temp); freespace = ifp_freespace(&ifpdev); sprintf(temp, _(" Free space (%.1f MB)"), (float)freespace / (1024*1024)); space = (float)freespace/capacity; gtk_progress_bar_set_text (GTK_PROGRESS_BAR (progressbar_freespace), temp); gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progressbar_freespace), space); }
/* --------------------------------- * p_doProgress * --------------------------------- */ static void p_doProgress(GapMorphShapeContext *msctx) { guchar *progressText; gdouble percentage; if(msctx->doProgress != TRUE) { return; } percentage = (gdouble)msctx->countGeneratedPoints / MAX(1.0, (gdouble)msctx->numShapePoints); progressText = g_strdup_printf(_("generating workpoint:%d (%d)") , (int)msctx->countGeneratedPoints , (int)msctx->numShapePoints ); gtk_progress_bar_set_text(GTK_PROGRESS_BAR(msctx->progressBar), progressText); gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(msctx->progressBar), percentage); g_free(progressText); while (gtk_events_pending ()) { gtk_main_iteration (); } } /* end p_doProgress */
/* ----------------------------------------------- * p_do_master_progress * ----------------------------------------------- */ static void p_do_master_progress(GtkWidget *progressBar , const char *workpointFileName, gdouble framesToProcess, gdouble frameNr) { if(progressBar != NULL) { char *msg; gdouble percentage; percentage = frameNr / MAX(1.0, framesToProcess); msg = gap_base_shorten_filename(NULL /* prefix */ ,workpointFileName /* filenamepart */ ,NULL /* suffix */ ,130 /* l_max_chars */ ); gtk_progress_bar_set_text(GTK_PROGRESS_BAR(progressBar), msg); gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progressBar), percentage); g_free(msg); while (gtk_events_pending ()) { gtk_main_iteration (); } } }
static void stlink_gui_open_file (STlinkGUI *gui) { GtkWidget *dialog; GtkListStore *store; GtkTreeIter iter; dialog = gtk_file_chooser_dialog_new ("Open file", gui->window, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) { gui->filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)); store = GTK_LIST_STORE (gtk_tree_view_get_model (gui->filemem_treeview)); if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter)) { gtk_list_store_clear (store); } stlink_gui_set_sensitivity (gui, FALSE); gtk_notebook_set_current_page (gui->notebook, PAGE_FILEMEM); gtk_widget_show (GTK_WIDGET (gui->progress.bar)); gtk_progress_bar_set_text (gui->progress.bar, "Reading file"); g_thread_new ("file", (GThreadFunc) stlink_gui_populate_filemem_view, gui); } gtk_widget_destroy (dialog); }
G_MODULE_EXPORT void progress_update(gfloat fraction) { static gint last = 0.0; static GtkWidget *pbar = NULL; gchar * tmpbuf = NULL; gint value = 0; if (!pbar) pbar = GTK_WIDGET(gtk_builder_get_object((GtkBuilder *)DATA_GET(global_data,"builder"), "progressbar")); g_return_if_fail(pbar); fraction = fraction > 1.0 ? 1.0:fraction; fraction = fraction < 0.0 ? 0.0:fraction; value = (gint)(fraction*100.0); if (value != last) { tmpbuf = g_strdup_printf("%i%% complete",value); gtk_progress_bar_set_text(GTK_PROGRESS_BAR(pbar),tmpbuf); g_free(tmpbuf); gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(pbar),fraction); } last = value; while (gtk_events_pending()) gtk_main_iteration(); }
/* Fill up the progress bar, 10% every second when the button is clicked. Then, * set the page as complete when the progress bar is filled. */ static void button_clicked (GtkButton *button, GtkAssistant *assistant) { GtkProgressBar *progress; GtkWidget *page; gdouble percent = 0.0; gtk_widget_set_sensitive (GTK_WIDGET (button), FALSE); page = gtk_assistant_get_nth_page (assistant, 3); progress = GTK_PROGRESS_BAR (g_object_get_data (G_OBJECT (page), "pbar")); while (percent <= 100.0) { gchar *message = g_strdup_printf ("%.0f%% Complete", percent); gtk_progress_bar_set_fraction (progress, percent / 100.0); gtk_progress_bar_set_text (progress, message); while (gtk_events_pending ()) gtk_main_iteration (); g_usleep (500000); percent += 5.0; } gtk_assistant_set_page_complete (assistant, page, TRUE); }
/** * gwy_app_wait_set_fraction: * @fraction: The progress of the operation, as a number from 0 to 1. * * Sets the amount of progress the progress bar on the dialog displays. * * Returns: %TRUE if the operation can continue, %FALSE if user cancelled it * meanwhile. **/ gboolean gwy_app_wait_set_fraction(gdouble fraction) { gchar buf[8]; if (silent_waiting) return TRUE; while (gtk_events_pending()) gtk_main_iteration(); if (canceled) return FALSE; g_return_val_if_fail(dialog, FALSE); gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progress), fraction); if (fraction < 0.0 || fraction > 1.0) { g_warning("Fraction outside [0, 1] range"); fraction = CLAMP(fraction, 0.0, 1.0); } g_snprintf(buf, sizeof(buf), "%d %%", (gint)(100*fraction + 0.4)); gtk_progress_bar_set_text(GTK_PROGRESS_BAR(progress), buf); while (gtk_events_pending()) gtk_main_iteration(); return !canceled; }
void ease_dialog_progress_set_label (EaseDialogProgress* self, const char* str) { #line 114 "ease-dialog-progress.vala" g_return_if_fail (self != NULL); #line 116 "ease-dialog-progress.vala" gtk_progress_bar_set_text (self->priv->progress, str); #line 270 "ease-dialog-progress.c" }
static void fill_activated (GtkMenuItem *item, GtkProgressBar *progress) { gtk_progress_bar_set_fraction (progress, 1.0); gtk_progress_bar_set_text (progress, "One Hundred Percent"); }
GtkWidget *widget_progressbar_create( AttributeSet *Attr, tag_attr *attr, gint Type) { GList *element; GtkWidget *widget; gchar *text; #ifdef DEBUG_TRANSITS fprintf(stderr, "%s(): Entering.\n", __func__); #endif /* Thunor: This is all original code moved across when refactoring */ widget = gtk_progress_bar_new(); /* Thunor: This is all original code moved across when refactoring */ if (attributeset_is_avail(Attr, ATTR_LABEL)) { text = attributeset_get_first(&element, Attr, ATTR_LABEL); gtk_progress_bar_set_text(GTK_PROGRESS_BAR(widget), text); } #ifdef DEBUG_TRANSITS fprintf(stderr, "%s(): Exiting.\n", __func__); #endif return widget; }
gboolean vol_update_progress(gpointer data) { volume_t * vol = (volume_t *)data; if (vol->slot) { float fraction = 0.0f; char str_progress[10]; AQUALUNG_MUTEX_LOCK(vol->thread_mutex); if (vol->n_chunks != 0) { fraction = (float)vol->chunks_read / vol->n_chunks; } AQUALUNG_MUTEX_UNLOCK(vol->thread_mutex); if (fraction < 0 || fraction > 1.0f) { fraction = 0.0f; } gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(vol->progress), fraction); snprintf(str_progress, 10, "%.0f%%", fraction * 100.0f); gtk_progress_bar_set_text(GTK_PROGRESS_BAR(vol->progress), str_progress); } return TRUE; }
static gboolean update_stage(gpointer data) { StageUpdate* update = (StageUpdate*) data; gdk_threads_enter(); gtk_progress_bar_set_text(update->dialog->progress, update->info); if (update->ratio >= 0.0) { gtk_progress_bar_set_fraction(update->dialog->progress, update->ratio); } else { gtk_progress_bar_pulse(update->dialog->progress); } gdk_threads_leave(); g_free(update->info); g_free(update); return FALSE; }
static void clear_activated (GtkMenuItem *item, GtkProgressBar *progress) { gtk_progress_bar_set_fraction (progress, 0.0); gtk_progress_bar_set_text (progress, "Reset to Zero"); }
void layer_new_mouse(void) { // Local variables GdkCursor *selection_cursor; // Holds the new temporary selection cursor // If no project is loaded then don't run this function if (NULL == get_current_slide()) { // Make a beep, then return gdk_beep(); return; } // Change the focus of the window to be this widget set_delete_focus(FOCUS_LAYER); // Change the cursor to something suitable selection_cursor = gdk_cursor_new(GDK_CROSSHAIR); gdk_window_set_cursor(get_main_drawing_area()->window, selection_cursor); gdk_cursor_unref(selection_cursor); // Set a toggle so the release button callback will know to do the rest set_new_layer_selected(TYPE_MOUSE_CURSOR); // Update the status bar gtk_progress_bar_set_text(GTK_PROGRESS_BAR(get_status_bar()), _(" Please click the insertion point")); gdk_flush(); }
/* event handler for page 4, most important part of this program, a new guy: progressbar comes */ static void button_clicked( GtkButton *button, GtkAssistant *assistant ) { /* * Fill up the progress bar, 10% every second when the button is clicked. * Then set the page as complete when the progress bar is filled */ /* first, deactive the button */ gtk_widget_set_sensitive( GTK_WIDGET( button ), FALSE ); GtkWidget *current_page = gtk_assistant_get_nth_page( assistant, 3 ); GtkProgressBar *progressbar = GTK_PROGRESS_BAR( g_object_get_data( G_OBJECT(current_page), "pbar" ) ); gdouble percent = 0.f; while ( percent <= 100.f ) { gchar *msg = g_strdup_printf( "%.0f%% Complete", percent ); gtk_progress_bar_set_fraction( progressbar, percent / 100.f ); gtk_progress_bar_set_text( progressbar, msg ); while ( gtk_events_pending() ) { gtk_main_iteration(); } g_usleep( 500000 ); percent += 5.f; } gtk_assistant_set_page_complete( assistant, current_page, TRUE ); }
void sal_gui_progress_set(vm_t *vm) { obj_t *box = (obj_t *)sal_stack_pop(vm->stack); /* progress bar widget */ obj_t *obj = (obj_t *)sal_stack_pop(vm->stack); /* value */ switch(obj->type) { case OBJECT_STRING: /* text */ gtk_progress_bar_set_text( GTK_PROGRESS_BAR(box->data), string_get_value(obj)); break; case OBJECT_FLOAT: { /* 0 - 1 */ float val = float_get_value(obj); if (val<0) val = 0; if (val>1) val = 1; gtk_progress_bar_set_fraction( GTK_PROGRESS_BAR(box->data), (gdouble)val); } break; case OBJECT_INTEGER: { /* 0 - 100 */ int val = integer_get_value(obj); if (val<0) val = 0; if (val>100) val = 100; gtk_progress_bar_set_fraction( GTK_PROGRESS_BAR(box->data), (gdouble)0.01*val); } break; default: fprintf(stderr, "Don't know how to handle this obj (%d).\n", obj->type); } }