/*
* 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;
}
