void linphone_gtk_show_buddy_lookup_window(SipSetupContext *ctx){ GtkListStore *store; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeSelection *select; GtkWidget *w=linphone_gtk_create_window("buddylookup"); GtkWidget *results=linphone_gtk_get_widget(w,"search_results"); GtkProgressBar *pb=GTK_PROGRESS_BAR(linphone_gtk_get_widget(w,"progressbar")); store = gtk_list_store_new(LOOKUP_RESULT_NCOL, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); gtk_tree_view_set_model(GTK_TREE_VIEW(results),GTK_TREE_MODEL(store)); g_object_unref(G_OBJECT(store)); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("Firstname, Lastname"), renderer, "text", LOOKUP_RESULT_NAME, NULL); g_object_set (G_OBJECT(column), "resizable", TRUE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (results), column); column = gtk_tree_view_column_new_with_attributes (_("SIP address"), renderer, "text", LOOKUP_RESULT_SIP_URI, NULL); g_object_set (G_OBJECT(column), "resizable", TRUE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (results), column); select = gtk_tree_view_get_selection (GTK_TREE_VIEW (results)); gtk_tree_selection_set_mode (select, GTK_SELECTION_SINGLE); gtk_tree_view_set_tooltip_column(GTK_TREE_VIEW(results),LOOKUP_RESULT_ADDRESS); g_object_set_data(G_OBJECT(w),"SipSetupContext",ctx); g_object_weak_ref(G_OBJECT(w),(GWeakNotify)linphone_gtk_buddy_lookup_window_destroyed,w); //g_signal_connect_swapped(G_OBJECT(w),"destroy",(GCallback)linphone_gtk_buddy_lookup_window_destroyed,w); gtk_progress_bar_set_fraction(pb,0); gtk_progress_bar_set_text(pb,NULL); gtk_dialog_add_button(GTK_DIALOG(w),GTK_STOCK_CLOSE,GTK_RESPONSE_CLOSE); g_object_set_data(G_OBJECT(w),"last_state",GINT_TO_POINTER(-1)); gtk_widget_show(w); }
static gint watch_thread(gpointer data){ char msg[256]; //LOG(LOG_DEBUG, "IN : watch_thread()"); if(thread_running){ pthread_mutex_lock(&mutex); sprintf(msg, _("%d hit"), hit_count); if(GTK_IS_LABEL(label_match)){ gtk_label_set_text(GTK_LABEL(label_match), msg); gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), search_progress); } pthread_mutex_unlock(&mutex); // LOG(LOG_DEBUG, "OUT : watch_thread() : CONTINUE"); return(1); } gtk_timeout_remove(tag_timeout); show_result_tree(); if(search_result == NULL) push_message(_("No hit.")); else { push_message(""); } // if(ebook_search_method() != SEARCH_METHOD_GREP) select_first_item(); gtk_grab_remove(cancel_dialog); gtk_widget_destroy(cancel_dialog); cancel_dialog=NULL; label_cancel=NULL; pthread_mutex_destroy(&mutex); //LOG(LOG_DEBUG, "OUT : watch_thread()"); return(0); }
static void replay_update_progress_bar(int time_offset) { float fraction = (float)time_offset / time_span; if (fraction > 1.0) { log_debug("fraction=%f", fraction); fraction = 1.0; } if (! direction_forward) fraction = 1.0 - fraction; gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progress_bar), fraction); char buf[32]; time_t tm = replay_start_time + time_offset; struct tm *t = localtime(&tm); int len = sprintf(buf, "%2d%% ", (int)(fraction * 100)); if (len > 0) { strftime(&buf[len], sizeof(buf) - len, "[%b %d, %H:%M:%S]", t); gtk_label_set_text(GTK_LABEL(desc_label), buf); } }
static int progress_bar_timeout_cb (Simulation *s) { gchar *str; double p; g_return_val_if_fail (s != NULL, FALSE); oregano_engine_get_progress (s->engine, &p); if (p >= 1) p = 0; gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (s->progress), p); str = g_strdup_printf (_ ("Progress: <b>%s</b>"), oregano_engine_get_current_operation (s->engine)); gtk_label_set_markup (s->progress_label, str); g_free (str); return TRUE; }
static void append_progress_page(TyonXceleratorCalibrationAssistant *assistant) { TyonXceleratorCalibrationAssistantPrivate *priv = assistant->priv; GtkWidget *vbox; priv->progress_label = GTK_LABEL(gtk_label_new(NULL)); priv->progress_page = gtk_hbox_new(FALSE, 0); priv->positional = TYON_2D_POSITIONAL(tyon_2d_positional_new()); vbox = gtk_vbox_new(FALSE, 0); priv->progress_bar = GTK_PROGRESS_BAR(gtk_progress_bar_new()); gtk_box_pack_start(GTK_BOX(priv->progress_page), GTK_WIDGET(priv->positional), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(priv->progress_page), vbox, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(priv->progress_label), TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(priv->progress_bar), TRUE, FALSE, 0); gtk_assistant_append_page(GTK_ASSISTANT(assistant), priv->progress_page); gtk_assistant_set_page_title(GTK_ASSISTANT(assistant), priv->progress_page, _("Calibration")); gtk_assistant_set_page_type(GTK_ASSISTANT(assistant), priv->progress_page, GTK_ASSISTANT_PAGE_PROGRESS); gtk_assistant_set_page_complete(GTK_ASSISTANT(assistant), priv->progress_page, FALSE); }
static void rejilla_status_dialog_init (RejillaStatusDialog *object) { RejillaStatusDialogPrivate *priv; GtkWidget *main_box; GtkWidget *box; priv = REJILLA_STATUS_DIALOG_PRIVATE (object); gtk_dialog_add_button (GTK_DIALOG (object), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); box = gtk_vbox_new (FALSE, 4); gtk_widget_show (box); main_box = gtk_dialog_get_content_area (GTK_DIALOG (object)); gtk_box_pack_end (GTK_BOX (main_box), box, TRUE, TRUE, 0); priv->progress = gtk_progress_bar_new (); gtk_widget_show (priv->progress); gtk_progress_bar_set_text (GTK_PROGRESS_BAR (priv->progress), " "); gtk_box_pack_start (GTK_BOX (box), priv->progress, TRUE, TRUE, 0); priv->action = gtk_label_new (""); gtk_widget_show (priv->action); gtk_label_set_use_markup (GTK_LABEL (priv->action), TRUE); gtk_misc_set_alignment (GTK_MISC (priv->action), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (box), priv->action, FALSE, TRUE, 0); }
static void _lib_backgroundjobs_progress(dt_lib_module_t *self, const guint *key, double progress) { if(!darktable.control->running) return; gboolean i_own_lock = dt_control_gdk_lock(); dt_lib_backgroundjobs_t *d = (dt_lib_backgroundjobs_t*)self->data; dt_bgjob_t *j = (dt_bgjob_t*)g_hash_table_lookup(d->jobs, key); if(j) { if( j->type == 0 ) { gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(j->progressbar), CLAMP(progress, 0, 1.0)); #ifdef HAVE_UNITY unity_launcher_entry_set_progress( j->darktable_launcher, CLAMP(progress, 0, 1.0)); #endif } } if(i_own_lock) dt_control_gdk_unlock(); }
void interface_set_playing (PlayerState state) { GtkWidget *progress_area; progress_area = interface_get_widget ("alignment_progress"); switch(state) { case STATE_PLAY_LOCAL: interface_set_playimage("gtk-media-pause"); gtk_widget_show (progress_area); break; case STATE_PLAY_STREAM: interface_set_playimage("gtk-media-stop"); gtk_widget_hide (progress_area); break; case STATE_PLAY_NOTHING: interface_set_playimage("gtk-media-play"); interface_set_songinfo ("", ""); gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progress), 0); break; } }
GuBiblio* biblio_init (GtkBuilder* builder) { g_return_val_if_fail (GTK_IS_BUILDER (builder), NULL); GuBiblio* b = g_new0 (GuBiblio, 1); b->progressbar = GTK_PROGRESS_BAR (gtk_builder_get_object (builder, "bibprogressbar")); b->progressmon = GTK_ADJUSTMENT (gtk_builder_get_object (builder, "bibprogressmon")); b->list_biblios = GTK_LIST_STORE (gtk_builder_get_object (builder, "list_biblios")); b->filenm_label = GTK_LABEL (gtk_builder_get_object (builder, "bibfilenm")); b->refnr_label = GTK_LABEL (gtk_builder_get_object (builder, "bibrefnr")); b->list_filter = GTK_ENTRY (gtk_builder_get_object (builder, "biblio_filter")); b->biblio_treeview = GTK_TREE_VIEW (gtk_builder_get_object (builder, "bibtreeview")); b->progressval = 0.0; return b; }
static void _lib_backgroundjobs_progress(dt_lib_module_t *self, const guint *key, double progress) { if(!darktable.control->running) return; dt_lib_backgroundjobs_t *d = (dt_lib_backgroundjobs_t*)self->data; gboolean i_own_lock = dt_control_gdk_lock(); dt_bgjob_t *j = (dt_bgjob_t*)g_hash_table_lookup(d->jobs, key); if(j) { /* check if progress is above 1.0 and destroy bgjob if finished */ /* FIXME: actually we are having some rounding issues, where the */ /* FIXME: last item doesn't bring to total to 1.0 flat */ /* FIXME: so this is why we have the ugly kludge below */ if (progress > 0.999999) { if (GTK_IS_WIDGET(j->widget)) gtk_container_remove( GTK_CONTAINER(d->jobbox), j->widget ); #ifdef HAVE_UNITY unity_launcher_entry_set_progress( j->darktable_launcher, 1.0 ); unity_launcher_entry_set_progress_visible( j->darktable_launcher, FALSE ); #endif /* hide jobbox if theres no jobs left */ if (g_list_length(gtk_container_get_children(GTK_CONTAINER(d->jobbox))) == 0 ) gtk_widget_hide(d->jobbox); } else { if( j->type == 0 ) gtk_progress_bar_set_fraction( GTK_PROGRESS_BAR(j->progressbar), progress ); #ifdef HAVE_UNITY unity_launcher_entry_set_progress( j->darktable_launcher, progress ); #endif } } if(i_own_lock) dt_control_gdk_unlock(); }
static void sequence_play_clicked (void) { GtkTreeSelection *selection; GtkTreePath *path; GtkTreeIter iter; if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (play_button)) == FALSE) { g_print ("stopping.\n"); if (sequence_source_id > 0) g_source_remove (sequence_source_id); gtk_progress_bar_update (GTK_PROGRESS_BAR (progress_bar), 0); sequence_source_id = 0; current_step = NULL; audio_stop (); g_timeout_add (50, audio_stop_timeout, NULL); return; } selection = gtk_tree_view_get_selection (sequence_view); if (!gtk_tree_selection_get_selected (selection, NULL, &iter)) { sequence_first (); selection = gtk_tree_view_get_selection (sequence_view); if (!gtk_tree_selection_get_selected (selection, NULL, &iter)) return; } path = gtk_tree_model_get_path (GTK_TREE_MODEL (sequence_store), &iter); gtk_tree_model_get (GTK_TREE_MODEL (sequence_store), &iter, COLUMN_DATA, ¤t_step, -1); current_step->progress = 0; last_scene = NULL; g_print ("starting...\n"); sequence_source_id = g_timeout_add (10, (GSourceFunc) sequence_tick, NULL); }
int main(int argc, char *argv[]) { GladeXML *xml; GtkWidget *window1; int a=1; gtk_init(&argc, &argv); /* load the interface */ xml = glade_xml_new("test.glade", NULL, NULL); window1 = glade_xml_get_widget(xml, "window"); // treeview = glade_xml_get_widget(xml, "treeview"); // init_list(treeview); GtkWidget *progress_bar = glade_xml_get_widget (xml, "progressbar1"); gtk_progress_bar_pulse (GTK_PROGRESS_BAR (progress_bar)); g_assert(progress_bar); GtkWidget *my_button = glade_xml_get_widget (xml, butt "1"); g_signal_connect (G_OBJECT (my_button), "pressed", G_CALLBACK (button_clicked),&a); g_assert(my_button); gint func_ref = g_timeout_add (100, update_progress_bar, progress_bar); gtk_widget_show (window1); GTimer *wasted_time_tracker = g_timer_new (); GtkWidget *widget = glade_xml_get_widget (xml, "WasteTimeWindow"); g_signal_connect (G_OBJECT (widget), "delete_event", G_CALLBACK (inform_user_of_time_wasted),wasted_time_tracker); /* connect the signals in the interface */ glade_xml_signal_autoconnect(xml); /* start the event loop */ gtk_main(); g_source_remove (func_ref); return 0; }
static void sync_progress_gtk(gpointer data, LJSyncProgress progress, int cur, int max, const char *date) { SyncStatus *status = data; double fraction = 0.0; StatusStage stage; switch (progress) { case LJ_SYNC_PROGRESS_ITEMS: stage = STAGE_ENTRYMETA; break; case LJ_SYNC_PROGRESS_ENTRIES: stage = STAGE_ENTRY; break; } if (stage != status->stage) { status->stage = stage; show_status_stage(status); } if (max > 0) fraction = cur/(double)max; gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(status->progress), fraction); }
extern "C" const char *Init( int *argc, char ***argv ) { // Need to use external library to load this image. Native loader seems broken :/ const gchar *splash_image_path = "Data/splash.png"; GtkWidget *vbox; gtk_disable_setlocale(); if( !gtk_init_check(argc,argv) ) return "Couldn't initialize gtk (cannot open display)"; window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_position( GTK_WINDOW(window), GTK_WIN_POS_CENTER ); gtk_widget_set_size_request(window,468,-1); gtk_window_set_deletable( GTK_WINDOW(window), FALSE ); gtk_window_set_resizable(GTK_WINDOW(window),FALSE); gtk_window_set_role( GTK_WINDOW(window), "sm-startup" ); //gtk_window_set_icon( GTK_WINDOW(window), ); gtk_widget_realize(window); splash = gtk_image_new_from_file(splash_image_path); label = gtk_label_new(NULL); gtk_label_set_justify(GTK_LABEL(label),GTK_JUSTIFY_CENTER); gtk_label_set_ellipsize(GTK_LABEL(label),PANGO_ELLIPSIZE_END); gtk_label_set_line_wrap(GTK_LABEL(label),FALSE); progressBar = gtk_progress_bar_new(); gtk_progress_bar_set_fraction( GTK_PROGRESS_BAR(progressBar), 0.0 ); vbox = gtk_vbox_new(FALSE,0); gtk_container_add(GTK_CONTAINER(window),vbox); gtk_box_pack_start(GTK_BOX(vbox),splash,FALSE,FALSE,0); gtk_box_pack_end(GTK_BOX(vbox),progressBar,FALSE,FALSE,0); gtk_box_pack_end(GTK_BOX(vbox),label,TRUE,TRUE,0); gtk_widget_show_all(window); gtk_main_iteration_do(FALSE); return NULL; }
gboolean progress_timer(gpointer data) { //TOFIX optimize, show only if hidden, hide only if visible if(g_bMsgBox){ //hide progress dialog while waiting soem message box to finish gtk_widget_hide(g_wndProgressDlg); } else { //ensure progress dialog is visible and pulse the progress if(g_wndProgressDlg) gtk_widget_show(g_wndProgressDlg); if(g_progress1){ if(ProgressDlg::m_nTotalSize > 0) //TOFIX what if two loads at te same time ? not static!?? { gtk_progress_set_percentage(GTK_PROGRESS(g_progress1), ((double)ProgressDlg::m_nCurrentSize)/ProgressDlg::m_nTotalSize); } else gtk_progress_bar_pulse(GTK_PROGRESS_BAR(g_progress1)); } } return TRUE; }
/* update the animation information for each widget. This will also queue a redraw * and stop the animation if it is done. */ static gboolean qtcAnimationUpdateInfo(gpointer key, gpointer value, gpointer user_data) { QTC_UNUSED(user_data); AnimationInfo *animation_info = value; GtkWidget *widget = key; if ((widget == NULL) || (animation_info == NULL)) g_assert_not_reached(); /* remove the widget from the hash table if it is not drawable */ if (!gtk_widget_is_drawable(widget)) return TRUE; if (GTK_IS_PROGRESS_BAR(widget)) { gfloat fraction = gtk_progress_bar_get_fraction(GTK_PROGRESS_BAR(widget)); /* stop animation for filled/not filled progress bars */ if (fraction <= 0.0 || fraction >= 1.0) { return TRUE; } } else if (GTK_IS_ENTRY(widget)) { gfloat fraction = gtk_entry_get_progress_fraction(GTK_ENTRY(widget)); /* stop animation for filled/not filled progress bars */ if(fraction <= 0.0 || fraction >= 1.0) { return TRUE; } } force_widget_redraw(widget); /* stop at stop_time */ if(animation_info->stop_time != 0 && g_timer_elapsed(animation_info->timer, NULL) > animation_info->stop_time) return TRUE; return FALSE; }
static void eds_plugin_busy (PlannerPlugin *plugin, gboolean busy) { GdkCursor *cursor; GtkProgressBar *progress = GTK_PROGRESS_BAR (glade_xml_get_widget (plugin->priv->glade, "progressbar")); if (busy) { gint check_time = 1; /* second */ if (plugin->priv->busy) { return; } plugin->priv->pulse = g_timeout_add_seconds (check_time, eds_check_query, plugin); cursor = gdk_cursor_new_for_display (gdk_display_get_default (), GDK_WATCH); gtk_widget_set_sensitive (glade_xml_get_widget (plugin->priv->glade, "search_box"), FALSE); gtk_widget_set_sensitive (glade_xml_get_widget (plugin->priv->glade, "progress"), TRUE); plugin->priv->busy = TRUE; } else { g_source_remove (plugin->priv->pulse); gtk_progress_bar_set_fraction (progress, 0); gtk_widget_set_sensitive (glade_xml_get_widget (plugin->priv->glade, "progress"), FALSE); gtk_widget_set_sensitive (glade_xml_get_widget (plugin->priv->glade, "search_box"), TRUE); cursor = gdk_cursor_new_for_display (gdk_display_get_default (), GDK_LEFT_PTR); plugin->priv->busy = FALSE; } gdk_window_set_cursor (gtk_widget_get_parent_window (glade_xml_get_widget (plugin->priv->glade, "ok_button")), cursor); }
gboolean progress_update_timeout(gpointer data) { UpdaterAppState *app_state; llassert(data != NULL); app_state = (UpdaterAppState *) data; gdk_threads_enter(); if (app_state->activity_mode) { gtk_progress_bar_pulse (GTK_PROGRESS_BAR(app_state->progress_bar)); } else { gtk_progress_set_value(GTK_PROGRESS(app_state->progress_bar), app_state->progress_value); } gdk_threads_leave(); return TRUE; }
/* update the animation information for each widget. This will also queue a redraw * and stop the animation if it is done. */ static gboolean update_animation_info (gpointer key, gpointer value, gpointer user_data) { AnimationInfo *animation_info = value; GtkWidget *widget = key; gdouble elapsed; if ((widget == NULL) || (animation_info == NULL)) g_assert_not_reached (); /* remove the widget from the hash table if it is not drawable */ if (!GTK_WIDGET_DRAWABLE (widget)) return TRUE; if (GTK_IS_PROGRESS_BAR (widget)) { gfloat fraction = gtk_progress_bar_get_fraction (GTK_PROGRESS_BAR (widget)); /* stop animation for filled/not filled progress bars */ if (fraction <= 0.0 || fraction >= 1.0) return TRUE; animation_info->update_delay--; if (animation_info->update_delay <= 0) { animation_info->update_delay = PROGRESSBAR_DELAY; force_widget_redraw (widget); } } else force_widget_redraw (widget); /* stop at stop_time */ if (animation_info->stop_time != 0 && g_timer_elapsed (animation_info->timer, NULL) > animation_info->stop_time) return TRUE; return FALSE; }
static void cache_manager_standard_clean_valid_cb(const gchar *path, gboolean valid, gpointer data) { CleanData *cd = data; if (path) { if (!valid) { DEBUG_1("thumb cleaned: %s", path); unlink_file(path); } cd->count_done++; if (cd->count_total != 0) { gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(cd->progress), (gdouble)cd->count_done / cd->count_total); } } cd->tl = NULL; if (cd->list) { FileData *next_fd; next_fd = cd->list->data; cd->list = g_list_remove(cd->list, next_fd); cd->tl = thumb_loader_std_thumb_file_validate(next_fd->path, cd->days, cache_manager_standard_clean_valid_cb, cd); file_data_unref(next_fd); } else { cache_manager_standard_clean_done(cd); } }
struct utt_dashboard * utt_dashboard_new (struct utt_wubi *utt) { struct utt_dashboard *dash; struct utt_dashboard_priv *priv; GtkWidget *fix, *align; gchar *path; dash = g_new0 (struct utt_dashboard, 1); dash->align = align = gtk_alignment_new (0.5, 0.5, 0, 0); fix = gtk_fixed_new (); gtk_container_add (GTK_CONTAINER (align), fix); gtk_container_set_border_width (GTK_CONTAINER (align), 4); priv = dash->priv = g_new0 (struct utt_dashboard, 1); priv->utt = utt; priv->record = utt->record; path = g_build_filename (PKGDATADIR, "dashboard.png", NULL); if (!g_file_test (path, G_FILE_TEST_EXISTS)) { g_error (G_STRLOC ": %s doesn't exists.", path); } priv->dashboard_image = cairo_image_surface_create_from_png (path); g_free (path); dash->draw = gtk_drawing_area_new (); gtk_widget_set_size_request (dash->draw, cairo_image_surface_get_width (priv->dashboard_image), cairo_image_surface_get_height (priv->dashboard_image)); gtk_container_add (GTK_CONTAINER (fix), dash->draw); dash->progress = gtk_progress_bar_new (); gtk_progress_bar_set_text (GTK_PROGRESS_BAR (dash->progress), "0%"); gtk_widget_set_size_request (dash->progress, 120, -1); gtk_fixed_put (GTK_FIXED (fix), dash->progress, 480, 23); g_signal_connect (dash->draw, "expose-event", G_CALLBACK (on_dashboard_draw_expose), dash); return dash; }
int ui_progress_bar_set_fraction(double fraction) { if (ui_abort == FALSE) { /* If not exist instantiate */ if (!ui_main_data.progressbar && !ui_main_data.progressbar_window) { ui_main_data.progressbar_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); /* Keep progress bar window on top of main window */ gtk_window_set_transient_for (GTK_WINDOW(ui_main_data.progressbar_window), GTK_WINDOW(ui_main_data.window)); /* Set the window at center of main window */ gtk_window_set_position (GTK_WINDOW(ui_main_data.progressbar_window), GTK_WIN_POS_CENTER_ON_PARENT); gtk_window_set_title (GTK_WINDOW(ui_main_data.progressbar_window), "Processing"); gtk_container_set_border_width (GTK_CONTAINER (ui_main_data.progressbar_window), 10); ui_main_data.progressbar = gtk_progress_bar_new (); gtk_container_add (GTK_CONTAINER (ui_main_data.progressbar_window), ui_main_data.progressbar); /* Assign the destroy event */ g_signal_connect(ui_main_data.progressbar_window, "destroy", ui_progressbar_window_destroy, NULL); gtk_widget_show_all (ui_main_data.progressbar_window); gtk_widget_set_sensitive(GTK_WIDGET(ui_main_data.stop_loading), TRUE); } gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(ui_main_data.progressbar), fraction); // ui_gtk_flush_events(); } return RC_OK; }
END_TEST /** * Purpose: Check creation of new banner with progress bar with invalid values * Cases considered: * - Create new progress banner with NULL text. * - Create new progress banner with NULL window. */ START_TEST (test_show_progress_invalid) { gchar * text=NULL; GtkProgressBar * progress_bar = NULL; HildonBanner * hildon_banner = NULL; progress_bar = GTK_PROGRESS_BAR(gtk_progress_bar_new()); /*Test 1: Create progress banner with TEST_STRING as text and basic progress_bar. */ text = TEST_STRING; hildon_banner = HILDON_BANNER(hildon_banner_show_progress(b_window,progress_bar,NULL)); /* NULL text avoid create correct banner. */ fail_if(HILDON_IS_BANNER(hildon_banner), "hildon-banner: hildon_banner_show_progress failed creating banner."); /*Test 2: Create progress banner with TEST_STRING as text, NULL progress_bar and NULL window */ text = TEST_STRING; hildon_banner = HILDON_BANNER(hildon_banner_show_progress(NULL,NULL,text)); fail_if(!HILDON_IS_BANNER(hildon_banner), "hildon-banner: hildon_banner_show_progress failed creating banner."); hildon_banner_set_text(hildon_banner,text); hildon_banner_set_fraction(hildon_banner,0.2); gtk_widget_destroy(GTK_WIDGET(hildon_banner)); }
static void ide_editor_view_actions_reload_buffer (GSimpleAction *action, GVariant *param, gpointer user_data) { IdeEditorView *self = user_data; IdeContext *context; IdeBufferManager *buffer_manager; IdeFile *file; g_autoptr(IdeProgress) progress = NULL; IdeWorkbenchOpenFlags flags; g_assert (IDE_IS_EDITOR_VIEW (self)); context = ide_buffer_get_context (IDE_BUFFER (self->document)); file = ide_buffer_get_file (IDE_BUFFER (self->document)); buffer_manager = ide_context_get_buffer_manager (context); gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (self->progress_bar), 0.0); gtk_widget_show (GTK_WIDGET (self->progress_bar)); flags = WORKBENCH_OPEN_FLAGS_NONE; ide_buffer_manager_load_file_async (buffer_manager, file, TRUE, flags, &progress, NULL, ide_editor_view_actions_reload_buffer_cb, g_object_ref (self)); g_object_bind_property (progress, "fraction", self->progress_bar, "fraction", G_BINDING_SYNC_CREATE); }
static void dlg_stop_detection( struct netselect_dlg * dlg, gboolean select_first) { if(!dlg->detect_timeout_id) return; /* remove timeout source, if active */ g_source_remove(dlg->detect_timeout_id); dlg->detect_timeout_id = 0; /* close any detection qcs_links which left dangling * if we stoped detection in progress */ cleanup_detect_links(dlg); /* put dialog in search mode (disable some controls) */ dlg_search_mode(dlg, FALSE); /* clean progress bar */ gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(dlg->detect_progress), 0.0); if(select_first) { GtkTreeIter iter; /* select the first entry in the list to be active */ if(gtk_tree_model_get_iter_first(GTK_TREE_MODEL(dlg->list), &iter)) { GtkTreePath * path; /* there's at least a single entry in the list, activate the first one */ path = gtk_tree_model_get_path(GTK_TREE_MODEL(dlg->list), &iter); gtk_tree_view_set_cursor(GTK_TREE_VIEW(dlg->tree_w), path, NULL, FALSE); gtk_tree_path_free(path); } } }
/** * operation: The SeahorseOperation to use * message: An optional message to display * fract: The fraction finished * swidget: the SeahorseWidget to get the widgets from * * Progress window update. Similar to operation_progress * **/ static void progress_operation_update (SeahorseOperation *operation, const gchar *message, gdouble fract, SeahorseWidget *swidget) { GtkProgressBar *progress; GtkWidget *w; const gchar *t; w = GTK_WIDGET (seahorse_widget_get_widget (swidget, "operation-details")); g_return_if_fail (w != NULL); t = seahorse_operation_get_message (operation); gtk_label_set_text (GTK_LABEL (w), t ? t : ""); progress = GTK_PROGRESS_BAR (seahorse_widget_get_widget (swidget, "operation-bar")); g_return_if_fail (w != NULL); if (fract >= 0.0) { stop_pulse (progress); gtk_progress_bar_set_fraction (progress, fract); } else { start_pulse (progress); } }
static void refresh_pbar1(void) { gchar buffer[32]; gfloat rate, avg; if (pbar_wnd.pbar1 != NULL) { if(gtk_update.cnt1 > gtk_update.max1) gtk_update.cnt1 = gtk_update.max1; if(gtk_update.max1 != 0) gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(pbar_wnd.pbar1), (gdouble)gtk_update.cnt1 / gtk_update.max1); rate = gtk_update.rate; filter_shift(); avg = filter_compute(rate); g_snprintf(buffer, 32, "Rate: %1.1f Kbytes/s", avg); gtk_label_set_text(GTK_LABEL(pbar_wnd.label_rate), buffer); GTK_REFRESH(); } }
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; }
GtkWidget * pgd_find_create_widget (PopplerDocument *document) { PgdFindDemo *demo; GtkWidget *vbox, *hbox; GtkWidget *button; GtkWidget *swindow; GtkWidget *checkbutton; GtkTreeModel *model; GtkWidget *treeview; GtkCellRenderer *renderer; GtkWidget *hpaned; GtkTreeSelection *selection; demo = g_new0 (PgdFindDemo, 1); demo->doc = g_object_ref (document); demo->n_pages = poppler_document_get_n_pages (document); demo->selected_page = -1; demo->options = POPPLER_FIND_DEFAULT; hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL); gtk_paned_set_position (GTK_PANED (hpaned), 300); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); demo->entry = gtk_entry_new (); gtk_box_pack_start (GTK_BOX (hbox), demo->entry, FALSE, TRUE, 0); gtk_widget_show (demo->entry); demo->progress = gtk_progress_bar_new (); gtk_progress_bar_set_ellipsize (GTK_PROGRESS_BAR (demo->progress), PANGO_ELLIPSIZE_END); gtk_box_pack_start (GTK_BOX (hbox), demo->progress, TRUE, TRUE, 0); gtk_widget_show (demo->progress); button = gtk_button_new_with_label ("Find"); gtk_widget_set_sensitive (button, FALSE); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (pgd_find_button_clicked), (gpointer)demo); g_signal_connect_swapped (G_OBJECT (demo->entry), "changed", G_CALLBACK (pgd_find_button_sensitivity_cb), (gpointer)button); gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 6); gtk_widget_show (hbox); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); checkbutton = gtk_check_button_new_with_label ("Case sensitive"); g_signal_connect (checkbutton, "toggled", G_CALLBACK (pgd_find_case_sensitive_toggled), demo); gtk_box_pack_start (GTK_BOX (hbox), checkbutton, FALSE, FALSE, 0); gtk_widget_show (checkbutton); checkbutton = gtk_check_button_new_with_label ("Backwards"); g_signal_connect (checkbutton, "toggled", G_CALLBACK (pgd_find_backwards_toggled), demo); gtk_box_pack_start (GTK_BOX (hbox), checkbutton, FALSE, FALSE, 0); gtk_widget_show (checkbutton); checkbutton = gtk_check_button_new_with_label ("Whole words only"); g_signal_connect (checkbutton, "toggled", G_CALLBACK (pgd_find_whole_words_toggled), demo); gtk_box_pack_start (GTK_BOX (hbox), checkbutton, FALSE, FALSE, 0); gtk_widget_show (checkbutton); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); swindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); model = pgd_find_create_model (); treeview = gtk_tree_view_new_with_model (model); g_object_unref (model); demo->treeview = treeview; gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview), TRUE); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); g_signal_connect (selection, "changed", G_CALLBACK (pgd_find_selection_changed), demo); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), TITLE_COLUMN, "Matches", renderer, "text", TITLE_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), X1_COLUMN, "X1", renderer, "text", X1_COLUMN, "visible", VISIBLE_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), Y1_COLUMN, "Y1", renderer, "text", Y1_COLUMN, "visible", VISIBLE_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), X2_COLUMN, "X2", renderer, "text", X2_COLUMN, "visible", VISIBLE_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), Y2_COLUMN, "Y2", renderer, "text", Y2_COLUMN, "visible", VISIBLE_COLUMN, NULL); gtk_container_add (GTK_CONTAINER (swindow), treeview); gtk_widget_show (treeview); gtk_paned_add1 (GTK_PANED (hpaned), swindow); gtk_widget_show (swindow); demo->darea = gtk_drawing_area_new (); g_signal_connect (demo->darea, "draw", G_CALLBACK (pgd_find_viewer_drawing_area_draw), demo); swindow = gtk_scrolled_window_new (NULL, NULL); #if GTK_CHECK_VERSION(3, 7, 8) gtk_container_add(GTK_CONTAINER(swindow), demo->darea); #else gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (swindow), demo->darea); #endif gtk_widget_show (demo->darea); gtk_paned_add2 (GTK_PANED (hpaned), swindow); gtk_widget_show (swindow); gtk_box_pack_start (GTK_BOX (vbox), hpaned, TRUE, TRUE, 0); gtk_widget_show (hpaned); g_object_weak_ref (G_OBJECT (vbox), (GWeakNotify)pgd_find_free, (gpointer)demo); return vbox; }
static void insert_numbers(gboolean *cancel) { /* editor */ ScintillaObject *sci = document_get_current()->editor->sci; gint xinsert = sci_point_x_from_position(sci, start_pos); gint xend = sci_point_x_from_position(sci, end_pos); gint *line_pos = g_new(gint, end_line - start_line + 1); gint line, i; /* generator */ gint64 start = start_value; gint64 value; unsigned count = 0; size_t prefix_len = 0; int plus = 0, minus; size_t length, lend; char pad, aax; gchar *buffer; if (xend < xinsert) xinsert = xend; ui_progress_bar_start(_("Counting...")); /* lines shorter than the current selection are skipped */ for (line = start_line, i = 0; line <= end_line; line++, i++) { if (sci_point_x_from_position(sci, scintilla_send_message(sci, SCI_GETLINEENDPOSITION, line, 0)) >= xinsert) { line_pos[i] = sci_get_pos_at_line_sel_start(sci, line) - sci_get_position_from_line(sci, line); count++; } else line_pos[i] = -1; if (cancel && i % 2500 == 0) { update_display(); if (*cancel) { ui_progress_bar_stop(); g_free(line_pos); return; } } } switch (base_value * base_prefix) { case 8 : prefix_len = 1; break; case 16 : prefix_len = 2; break; case 10 : plus++; } value = start + (count - 1) * step_value; minus = start < 0 || value < 0; lend = plus || (pad_zeros ? minus : value < 0); while (value /= base_value) lend++; value = start; length = plus || (pad_zeros ? minus : value < 0); while (value /= base_value) length++; length = prefix_len + (length > lend ? length : lend) + 1; buffer = g_new(gchar, length + 1); buffer[length] = '\0'; pad = pad_zeros ? '0' : ' '; aax = (lower_case ? 'a' : 'A') - 10; gtk_progress_bar_set_text(GTK_PROGRESS_BAR(geany->main_widgets->progressbar), _("Preparing...")); update_display(); sci_start_undo_action(sci); sci_replace_sel(sci, ""); gtk_progress_bar_set_text(GTK_PROGRESS_BAR(geany->main_widgets->progressbar), _("Inserting...")); for (line = start_line, i = 0; line <= end_line; line++, i++) { gchar *beg, *end; gint insert_pos; if (line_pos[i] < 0) continue; beg = buffer; end = buffer + length; value = ABS(start); do { unsigned digit = value % base_value; *--end = digit + (digit < 10 ? '0' : aax); } while (value /= base_value); if (pad_zeros) { if (start < 0) *beg++ = '-'; else if (plus) *beg++ = '+'; else if (minus) *beg++ = ' '; memcpy(beg, "0x", prefix_len); beg += prefix_len; } else { if (start < 0) *--end = '-'; else if (plus) *--end = '+'; end -= prefix_len; memcpy(end, "0x", prefix_len); } memset(beg, pad, end - beg); insert_pos = sci_get_position_from_line(sci, line) + line_pos[i]; sci_insert_text(sci, insert_pos, buffer); start += step_value; if (cancel && i % 1000 == 0) { update_display(); if (*cancel) { scintilla_send_message(sci, SCI_GOTOPOS, insert_pos + length, 0); break; } } } sci_end_undo_action(sci); g_free(buffer); g_free(line_pos); ui_progress_bar_stop(); }