自学教程：C++ GTK_PROGRESS_BAR函数代码示例

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 voidrejilla_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();}

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 voidsync_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 gbooleanqtcAnimationUpdateInfo(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 voideds_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 gbooleanupdate_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 voidide_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 voiddlg_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 voidprogress_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);//.........这里部分代码省略.........

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);//.........这里部分代码省略.........