/* * process an UI update notification */ static void gtkui_update(int target) { switch (target) { case UI_UPDATE_HOSTLIST: gtk_idle_add((GtkFunction)gtkui_refresh_host_list,NULL); break; case UI_UPDATE_PLUGINLIST: gtk_idle_add((GtkFunction)gtkui_refresh_plugin_list, NULL); break; } }
static void selection_changed(WireItem *item, gboolean select, gpointer user_data) { g_object_ref(G_OBJECT(item)); if (select) { gtk_idle_add ((gpointer) select_idle_callback, item); gnome_canvas_item_show (GNOME_CANVAS_ITEM (item->priv->resize1)); gnome_canvas_item_show (GNOME_CANVAS_ITEM (item->priv->resize2)); } else { gtk_idle_add ((gpointer) deselect_idle_callback, item); gnome_canvas_item_hide (GNOME_CANVAS_ITEM (item->priv->resize1)); gnome_canvas_item_hide (GNOME_CANVAS_ITEM (item->priv->resize2)); } }
PRIVATE void clock_handler(AClock *clock, AClockReason reason) { Data *data = clock->gen->data; switch (reason) { case CLOCK_DISABLE: if (data->open) { gtk_idle_remove(data->idle_tag); close_audiofd(data->hwo); data->open = FALSE; } break; case CLOCK_ENABLE: if (!data->open) { data->open = open_audiofd(&data->hwo); if (data->open) data->idle_tag = gtk_idle_add(idle_handler, NULL); } break; default: g_message("Unreachable code reached (win_output)... reason = %d", reason); break; } }
/* * Scrolls the viewport, so that the region [x, y, width, height] (world * coordinates) is seen, according to hpos and vpos. * * The actual scrolling is done in an idle function. */ void Dw_gtk_viewport_scroll_to (GtkDwViewport *viewport, DwHPosition hpos, DwVPosition vpos, gint32 x, gint32 y, gint32 width, gint32 height) { viewport->anchor_pos.hpos = hpos; viewport->anchor_pos.vpos = vpos; viewport->anchor_pos.x = x; viewport->anchor_pos.y = y; viewport->anchor_pos.width = width; viewport->anchor_pos.height = height; DBG_OBJ_SET_NUM (viewport, "anchor_pos.hpos", viewport->anchor_pos.hpos); DBG_OBJ_SET_NUM (viewport, "anchor_pos.vpos", viewport->anchor_pos.vpos); DBG_OBJ_SET_NUM (viewport, "anchor_pos.x", viewport->anchor_pos.x); DBG_OBJ_SET_NUM (viewport, "anchor_pos.y", viewport->anchor_pos.y); DBG_OBJ_SET_NUM (viewport, "anchor_pos.width", viewport->anchor_pos.width); DBG_OBJ_SET_NUM (viewport, "anchor_pos.height", viewport->anchor_pos.height); if (viewport->anchor_idle_id == 0) viewport->anchor_idle_id = gtk_idle_add (Dw_gtk_viewport_update_anchor_idle, (gpointer)viewport); }
int main(int argc, char *argv[]) { getcwd(cwd, 999); arg0 = argv[0]; arg1 = argc ? argv[1] : NULL; /* LOAD FILES AND STUFF HERE */ init_work(argc ? argv[1] : NULL); init_ui(); #ifdef USE_JOYSTICK printf("Initializing joystick...\n"); signal(SIGVTALRM,joy_alarm); joy_fd = open ("/dev/input/js0", O_RDONLY | O_NONBLOCK); #endif idle_id = gtk_idle_add (iterate, NULL); system("xset s noblank"); system("xset s off"); system("xset -dpms"); /* -------------------------------------- */ gtk_main(); gdk_flush (); /* -------------------------------------- */ system("xset +dpms"); system("xset s on"); system("xset s blank"); flynn_exit(0); }
/************************************************************************** Called when a region is marked dirty, this function queues a flush event to be handled later by GTK. The flush may end up being done by freeciv before then, in which case it will be a wasted call. **************************************************************************/ static void queue_flush(void) { if (!is_flush_queued) { gtk_idle_add(unqueue_flush, NULL); is_flush_queued = TRUE; } }
static void tray_clicked_callback (GtkStatusIcon* status, guint button, guint activate_time, cam * cam){ // FIXME: change to switch if (button == 1) { if (GTK_WIDGET_VISIBLE (glade_xml_get_widget (cam->xml, "main_window"))) { cam->hidden = TRUE; gtk_idle_remove (cam->idle_id); gtk_widget_hide (glade_xml_get_widget (cam->xml, "main_window")); } else { cam->idle_id = gtk_idle_add ((GSourceFunc) pt2Function, (gpointer) cam); gtk_widget_show (glade_xml_get_widget (cam->xml, "main_window")); cam->hidden = FALSE; } } else if (button == 3) { //gw = MyApp->GetMainWindow (); //gnomemeeting_component_view (NULL, (gpointer) gw->ldap_window); } }
/* sorry for complexity (cm->done_list), but need it to remove empty dirs */ void cache_maintain_home (CacheType type, gint clear) { CMData *cm; GList *dlist = NULL; gchar *base; const gchar *msg; if (type == CACHE_THUMBS) base = g_strconcat (home_dir (), "/", PORNVIEW_RC_DIR_THUMBS, NULL); else base = g_strconcat (home_dir (), "/", PORNVIEW_RC_DIR_COMMENTS, NULL); if (!path_list (base, NULL, &dlist)) { g_free (base); return; } dlist = g_list_append (dlist, base); cm = g_new0 (CMData, 1); cm->list = dlist; cm->done_list = NULL; cm->clear = clear; cm->type = type; if (clear) { if (type == CACHE_THUMBS) msg = _("Clearing thumbnails..."); else msg = _("Clearing comments..."); } else { if (type == CACHE_THUMBS) msg = _("Purging old thumbnails..."); else msg = _("Purging old comments..."); } if (type == CACHE_THUMBS) cm->gd = generic_dialog_new (_("Purge thumbnails"), msg, "PornView", "purge_thumbnails", TRUE, cb_cache_maintain_home_cancel, cm); else cm->gd = generic_dialog_new (_("Purge comments"), msg, "PornView", "purge_comments", TRUE, cb_cache_maintain_home_cancel, cm); gtk_window_set_position (GTK_WINDOW (cm->gd->dialog), GTK_WIN_POS_CENTER); gtk_widget_set_usize (cm->gd->dialog, PURGE_DIALOG_WIDTH, -1); cm->entry = gtk_entry_new (); gtk_widget_set_sensitive (cm->entry, FALSE); gtk_box_pack_start (GTK_BOX (cm->gd->vbox), cm->entry, FALSE, FALSE, 5); gtk_widget_show (cm->entry); gtk_widget_show (cm->gd->dialog); cm->idle_id = gtk_idle_add (cb_cache_maintain_home, cm); }
int main (int argc, char *argv[]) { struct s_interface *main_interface = (struct s_interface *) malloc(sizeof(struct s_interface)); char *current_pointer, *next_pointer, csv_file[d_string_buffer_size], default_calibration[d_string_buffer_size], buffer[d_string_buffer_size] = {'\0'}; int index = 0, ladder, local_selection[d_calibrations_ladders]; size_t length; f_memory_init(); if (argc >= 2) { if ((current_pointer = strstr(argv[1], d_compare_postfix))) { length = f_string_strlen(argv[1]); while ((current_pointer < (length+argv[1])) && (!isdigit(*current_pointer))) current_pointer++; while ((current_pointer < (length+argv[1])) && (isdigit(*current_pointer))) { buffer[index++] = *current_pointer; current_pointer++; } } environment.selected_trb = atoi(buffer); snprintf(default_calibration, d_string_buffer_size, "%s%02d", d_compare_default, environment.selected_trb); if (argc >= 3) strncpy(default_calibration, argv[2], d_string_buffer_size); for (ladder = 0; ladder < d_calibrations_ladders; ++ladder) local_selection[ladder] = d_false; if (f_analyze_calibration(&environment, argv[1], default_calibration)) { snprintf(csv_file, d_string_buffer_size, "%s.csv", argv[1]); f_analyze_values(&environment); f_analyze_values_write(&environment, stdout); gtk_init(&argc, &argv); if (f_compare_initialize(main_interface, "UI/UI_main.glade")) { if (argc == 4) { current_pointer = argv[3]; while ((next_pointer = strchr(current_pointer, ','))) { ladder = atoi(current_pointer); local_selection[ladder] = d_true; p_compare_loop_toggle(main_interface, ladder, d_true); current_pointer = (next_pointer+1); } if (f_string_strlen(current_pointer) > 0) { ladder = atoi(current_pointer); local_selection[ladder] = d_true; p_compare_loop_toggle(main_interface, ladder, d_true); } } else for (ladder = 0; ladder < d_calibrations_ladders; ++ladder) { local_selection[ladder] = d_true; p_compare_loop_toggle(main_interface, ladder, d_true); } f_analyze_export(&environment, csv_file, local_selection); gtk_idle_add((GSourceFunc)f_compare_loop, main_interface); gtk_main(); } } else fprintf(stderr, "one of these directories doesn't contains calibration files\n"); } else fprintf(stderr, "usage:\n%s <calibration> {reference calibration} {list of masked ladders CSV}\n", argv[0]); f_memory_destroy(); return 0; }
static void sample_display_idle_draw (SampleDisplay *s) { if(!s->idle_handler) { s->idle_handler = gtk_idle_add((GtkFunction)sample_display_idle_draw_function, (gpointer)s); g_assert(s->idle_handler != 0); } }
static gint hc_list_click_cb(GtkCList *list, GdkEventButton *be, history_calendar_dlg *hcdlg) { /* if they double click, show the history item window */ if (be->button == 1 && be->type == GDK_2BUTTON_PRESS) { gtk_idle_add(hc_list_click_idle_cb, hcdlg); } return 0; }
/* * Start the resizing idle. This function is called by * p_Dw_widget_queue_resize, after the appropriate attributes have been set in * the widgets, where necessary. */ void Dw_gtk_viewport_queue_resize (GtkDwViewport *viewport) { /* Resizing always overrides drawing. */ viewport->draw_resize_action = DW_GTK_VIEWPORT_RESIZE; viewport->num_draw_areas = 0; if (viewport->draw_resize_idle_id == 0) viewport->draw_resize_idle_id = gtk_idle_add (Dw_gtk_viewport_draw_resize_idle, (gpointer)viewport); }
/* * Bootstrap our UI, get our buffers, etc. */ int main( int argc, char* argv[] ) { extern int nes_psg_quality; /* FIXME: cheap hack, copied from nes_psg.h */ translation_buffer_16 = NULL; vid_pre_xlat = NULL; timeslice = NULL; timeslice_data = NULL; nes_psg_quality = 2; image_1 = image_2 = NULL; video_buffer_1 = video_buffer_2 = NULL; /* Get Gtk up and running. */ gtk_init( &argc, &argv ); nes_gtk_window = gtk_window_new( GTK_WINDOW_TOPLEVEL ); gtk_window_set_title( GTK_WINDOW( nes_gtk_window ), "DarcNES" ); gtk_widget_set_usize( nes_gtk_window, 256, 240 ); gtk_signal_connect( GTK_OBJECT( nes_gtk_window ), "destroy", GTK_SIGNAL_FUNC( destroy ), NULL ); gtk_signal_connect( GTK_OBJECT( nes_gtk_window ), "key_press_event", GTK_SIGNAL_FUNC( key_press ), NULL ); gtk_signal_connect( GTK_OBJECT( nes_gtk_window ), "key_release_event", GTK_SIGNAL_FUNC( key_release ), NULL ); gtk_widget_set_events( nes_gtk_window, GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK ); gtk_widget_show( nes_gtk_window ); visual = gdk_window_get_visual( nes_gtk_window->window ); gc = gdk_gc_new( nes_gtk_window->window ); color_map = gdk_window_get_colormap( nes_gtk_window->window ); if( argc > 1 ) { int system_type; rom_file romfile; strncpy( rom_name, argv[1], 127 ); romfile = read_romimage(rom_name); system_type = guess_system(romfile); activate_system(system_type, romfile); } else { show_open_dialog( NULL, NULL ); } /* Using GTK_PRIORITY_HIGH causes Gtk events to not occur. */ gtk_idle_add( (GtkFunction) emulate_timeslice, NULL ); gtk_main( ); return 0; }
int GTK_system_loop(void) { guint idle_id; idle_id = gtk_idle_add((GtkFunction) gtk_idle_handler, 0L); gtk_main(); gtk_idle_remove(idle_id); return v9t9_return == em_Dying; }
int main (int argc, char** argv) { if (!matecomponent_ui_init (argv[0], VERSION, &argc, argv)) g_error ("Could not initialize libmatecomponentui!\n"); gtk_idle_add ((GtkFunction) create_app, NULL); matecomponent_main (); return 0; }
/* * Queue an area for drawing. This function is called by * p_Dw_widget_queue_draw_area. x and y are passed in world coordinates. */ void Dw_gtk_viewport_queue_draw (GtkDwViewport *viewport, gint32 x, gint32 y, gint32 width, gint32 height) { DwRectangle area; int i; if (viewport->draw_resize_idle_id == 0) { viewport->draw_resize_action = DW_GTK_VIEWPORT_DRAW; viewport->draw_resize_idle_id = gtk_idle_add (Dw_gtk_viewport_draw_resize_idle, (gpointer)viewport); } else if (viewport->draw_resize_action == DW_GTK_VIEWPORT_RESIZE) /* Drawing is always overridden by resizing. */ return; area.x = x; area.y = y; area.width = width; area.height = height; /* First, try to keep the list as clean as possible. Check whether other * rectangles interfer with this one in some way. */ /* An idea for optimization: The list could be sorted, and so the part of * the list we have to consider here, may be reduced, the start may be * found via linear search. However, this probably makes balanced binary * trees necessary, since moving elements within the array may be quite * time-consuming. */ _MSG(" num_draw_areas = %d\n", viewport->num_draw_areas); for (i = 0; i < viewport->num_draw_areas; i++) { if (p_Dw_rectangle_is_subset (&area, &viewport->draw_areas[i])) /* First case: area is a subset of an already queued rectangle * -> nothing to do. */ return; else if (p_Dw_rectangle_is_subset (&viewport->draw_areas[i], &area)) { /* Second case: area is a subset of an already queued rectangle * -> replace the other one with area. */ viewport->draw_areas[i] = area; return; } /* Maybe some more tests: if both areas may exactly be combined to a * rectangle? Very unlikely case ... */ } /* No interference: add the new area to the list. */ viewport->num_draw_areas++; a_List_add (viewport->draw_areas, viewport->num_draw_areas, viewport->num_draw_areas_max); viewport->draw_areas[viewport->num_draw_areas - 1] = area; }
static void gimv_image_loader_load_end (GimvImageLoader *loader) { g_return_if_fail (GIMV_IS_IMAGE_LOADER (loader)); g_return_if_fail (loader->priv); if (!loader->priv->next_info) return; loader->info = loader->priv->next_info; loader->priv->next_info = NULL; gtk_idle_add (idle_gimv_image_loader_load, loader); }
void gv_manager_set_busy( GvManager *manager, int busy_flag ) { if( !manager->busy_flag == !busy_flag ) return; if( !manager->busy_flag ) gtk_idle_add( gv_manager_idle_handler, NULL ); manager->busy_flag = busy_flag; gtk_signal_emit(GTK_OBJECT(manager), manager_signals[BUSY_CHANGED]); }
/* Register an idle function. */ gint c_gtk_idle_add (EIF_PROC func, EIF_OBJ object, callback_data **p) { callback_data *cbd; eif_freeze (object); cbd = (callback_data *)g_malloc (sizeof (callback_data)); /* Return the pointer of the allocated block to Eiffel, so it can be deallocated later */ *p = cbd; cbd->rtn = func; cbd->obj = eif_access (object); return (gtk_idle_add (c_gtk_function, cbd)); }
void addIdleCB(GtkWidget *w, State *data) { if(data->id) { gtk_idle_remove(data->id); data->id = 0; #if TO_STDERR fprintf(stderr, "Removing idle\n");fflush(stderr); #endif } else { #if TO_STDERR data->id = gtk_idle_add(idleFun, (gpointer) data); #endif } }
int main(int argc, char *argv[]) { GtkWidget *window = NULL; GtkWidget *vbox; GtkWidget *drawing_area = NULL; player_init(argc, argv); gtk_init(&argc, &argv); window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(window), "PlayerCam"); vbox = gtk_vbox_new(FALSE, 0); gtk_container_add (GTK_CONTAINER(window), vbox); gtk_widget_show(vbox); drawing_area = gtk_drawing_area_new(); gtk_widget_set_size_request(GTK_WIDGET (drawing_area), g_width, g_height); gtk_box_pack_start(GTK_BOX (vbox), drawing_area, TRUE, TRUE, 0); gtk_widget_show(drawing_area); gtk_widget_show_all(window); gtk_widget_add_events(GTK_WIDGET(drawing_area), GDK_BUTTON_PRESS_MASK); g_signal_connect(G_OBJECT (window), "delete_event", G_CALLBACK (delete_event), NULL); g_signal_connect(G_OBJECT (window), "destroy", G_CALLBACK (destroy), NULL); g_signal_connect(GTK_OBJECT(drawing_area), "size-allocate", G_CALLBACK(resize), NULL); g_signal_connect(GTK_OBJECT(drawing_area), "event", G_CALLBACK(click), NULL); g_pixbuf = gdk_pixbuf_new_from_data(g_img, GDK_COLORSPACE_RGB, FALSE, 8, g_width, g_height, g_width * 3, NULL, NULL); gtk_idle_add(render_camera, drawing_area); gtk_main(); player_quit(); return 0; }
static gint script_fu_console_scroll_end (gpointer data) { /* The Text widget in 1.0.1 doesn't like being scrolled before * it is size-allocated, so we wait for it */ if ((cint.console->allocation.width > 1) && (cint.console->allocation.height > 1)) { cint.vadj->value = cint.vadj->upper - cint.vadj->page_size; gtk_signal_emit_by_name (GTK_OBJECT (cint.vadj), "changed"); } else gtk_idle_add (script_fu_console_scroll_end, NULL); return FALSE; }
int main (int argc, char *argv[]) { g_thread_init (NULL); gtk_init (&argc, &argv); document.grf = (Grf *) 0; mainWin.init (); memset (&extractProgress, 0, sizeof (ExtractProgress)); g_static_mutex_init (&extractProgressM); if (argv[1]) gtk_idle_add (idle_open, argv[1]); gtk_widget_realize (W(main)); gtk_widget_show (W(main)); gtk_main (); return 0; }
gboolean display_update_request_screen_refresh(int level, int waveform) { ST_LOGPRINTF("[%d] entry level %d currentlevel %d", counter++, level, g_currentLevel); if (level >= g_currentLevel) { if (waveform != 0) { ST_LOGPRINTF("Special waveform request"); level += waveform << 16; } gtk_idle_add(display_update_during_idle_handling, (gpointer) level); g_currentLevel = level + 1; } return TRUE; }
//------------------------------------------------------------------------- // // Run // //------------------------------------------------------------------------- NS_IMETHODIMP nsAppShell::Run() { if (!mEventQueue) Spinup(); if (!mEventQueue) return NS_ERROR_NOT_INITIALIZED; #ifdef NS_TRACE_MALLOC gtk_idle_add(tm_flush_logfiles, nsnull); #endif // kick up gtk_main. this won't return until gtk_main_quit is called gtk_main(); Spindown(); return NS_OK; }
GtkWidget * c2_network_traffic_new (C2Application *application) { C2NetworkTraffic *nt; nt = gtk_type_new (c2_network_traffic_get_type ()); gtk_widget_set_usize (GTK_WIDGET (nt), DRAWABLE_WIDTH+2, DRAWABLE_HEIGHT+2); gtk_drawing_area_size (GTK_DRAWING_AREA (nt), DRAWABLE_WIDTH+2, DRAWABLE_HEIGHT+2); gtk_signal_connect (GTK_OBJECT (nt), "expose_event", GTK_SIGNAL_FUNC (expose_event), nt); gtk_signal_connect (GTK_OBJECT (nt), "configure_event", GTK_SIGNAL_FUNC (configure_event), nt); nt->application = application; gtk_idle_add ((GtkFunction) idle_timeout, nt); nt->timeout_id = gtk_timeout_add (1000, (GtkFunction) timeout, nt); return GTK_WIDGET (nt); }
CLIP_DLLEXPORT int clip_GTK_INIT(ClipMachine * cm) { int n, i; char *par[20], **apar; gtk_set_locale(); memset(par, 0, sizeof(par)); n = _clip_parinfo(cm, 0); par[0] = ""; for (i=1; i<=n; i++) par[i] = _clip_parc(cm, i); apar = (char **)∥ //gtk_init(0, NULL); n++; gtk_init(&n, &apar); // gtk_set_locale(); // gtk_init(0, NULL); #ifdef USE_TASKS gtk_idle_add(__idle_task_yield,NULL); #endif _clip_retl(cm, 1); return 0; }
void fontsel_set_font_by_name (GtkWidget *fontsel, gchar *family_name, gchar *style_name) { GTree *family = NULL; GtkCList *clist; gint row; StyleSelect *style_select; g_return_if_fail (fontsel != NULL); if (family_name) { family = g_tree_lookup (families, family_name); } if (family) { clist = g_object_get_data (G_OBJECT (fontsel), "family_list"); row = gtk_clist_find_row_from_data (GTK_CLIST (clist), family); gtk_clist_select_row (GTK_CLIST (clist), row, 0); if ( !(gtk_clist_row_is_visible (clist, row) & GTK_VISIBILITY_FULL)) gtk_clist_moveto (clist, row, 0, 0.0, 0.0); if (style_name) { style_select = g_new (StyleSelect, 1); style_select->fontsel = fontsel; style_select->family = family; style_select->style_name = style_name; gtk_idle_add ((GtkFunction)fontsel_set_style_by_name, style_select); } } }
GTKVideo::~GTKVideo() { gst_pipeline_.reset(); g_idle_remove_by_data(this); if (nullptr != title_) g_free(title_); // destroy child widgets too if (main_window_ != nullptr && GTK_IS_WIDGET(main_window_)) { std::unique_lock<std::mutex> lock(window_destruction_mutex_); // g_idle_add_full (G_PRIORITY_DEFAULT_IDLE, // destroy_window, // this, // window_destroyed); gtk_idle_add(destroy_window, this); window_destruction_cond_.wait(lock); } if (blank_cursor_ != nullptr) gdk_cursor_destroy(blank_cursor_); // instances_counter_ --; // if (instances_counter_ == 0) // { // g_debug ("GTKVideo::~GTKVideo invoking gtk_main_quit"); // gtk_main_quit (); // } }
static gint gtk_combo_entry_focus_out (GtkEntry * entry, GdkEventFocus * event, GtkCombo * combo) { if (combo->value_in_list && !gtk_combo_find (combo)) { /* gdk_beep(); *//* this can be annoying */ if (combo->ok_if_empty && !strcmp (gtk_entry_get_text (entry), "")) return FALSE; #ifdef TEST printf ("INVALID ENTRY: `%s'\n", gtk_entry_get_text (entry)); #endif gtk_grab_add (GTK_WIDGET (combo)); /* this is needed because if we call gtk_widget_grab_focus() it isn't guaranteed it's the *last* call before the main-loop, so the focus can be lost anyway... the signal_emit_stop doesn't seem to work either... */ gtk_idle_add ((GtkFunction) gtk_combo_focus_idle, combo); /*gtk_signal_emit_stop_by_name (GTK_OBJECT (entry), "focus_out_event"); */ return TRUE; } return FALSE; }