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