static void gbp_git_buffer_change_monitor_queue_update (GbpGitBufferChangeMonitor *self, gboolean fast) { guint delay; g_assert (GBP_IS_GIT_BUFFER_CHANGE_MONITOR (self)); fast = !!fast; /* Re-use existing source if this is slow */ if (fast == SLOW && self->queued_source) return; delay = g_delay[fast]; g_clear_handle_id (&self->queued_source, g_source_remove); self->queued_source = gdk_threads_add_timeout_full (G_PRIORITY_HIGH, delay, (GSourceFunc) queued_update_source_cb, g_object_ref (self), g_object_unref); }
static void gtk_tooltip_start_delay (GdkDisplay *display) { guint timeout; GtkTooltip *tooltip; tooltip = g_object_get_data (G_OBJECT (display), "gdk-display-current-tooltip"); if (!tooltip || GTK_TOOLTIP_VISIBLE (tooltip)) return; if (tooltip->timeout_id) g_source_remove (tooltip->timeout_id); if (tooltip->browse_mode_enabled) timeout = BROWSE_TIMEOUT; else timeout = HOVER_TIMEOUT; tooltip->timeout_id = gdk_threads_add_timeout_full (0, timeout, tooltip_popup_timeout, g_object_ref (display), g_object_unref); }
void gimp_draw_tool_resume (GimpDrawTool *draw_tool) { g_return_if_fail (GIMP_IS_DRAW_TOOL (draw_tool)); g_return_if_fail (draw_tool->paused_count > 0); draw_tool->paused_count--; if (draw_tool->paused_count == 0) { #ifdef USE_TIMEOUT /* Don't install the timeout if the draw tool isn't active, so * suspend()/resume() can always be called, and have no side * effect on an inactive tool. See bug #687851. */ if (gimp_draw_tool_is_active (draw_tool) && ! draw_tool->draw_timeout) { draw_tool->draw_timeout = gdk_threads_add_timeout_full (G_PRIORITY_HIGH_IDLE, DRAW_TIMEOUT, (GSourceFunc) gimp_draw_tool_draw_timeout, draw_tool, NULL); } #endif /* call draw() anyway, it will do nothing if the timeout is * running, but will additionally check the drawing times to * ensure the minimum framerate */ gimp_draw_tool_draw (draw_tool); } }
static gboolean byzanz_recorder_snapshot (ByzanzRecorder *recorder) { cairo_surface_t *surface; cairo_region_t *invalid; GTimeVal tv; if (!recorder->recording) return FALSE; if (recorder->next_image_source != 0) return FALSE; invalid = byzanz_recorder_get_invalid_region (recorder); if (cairo_region_is_empty (invalid)) { cairo_region_destroy (invalid); return FALSE; } surface = byzanz_recorder_create_snapshot (recorder, invalid); g_get_current_time (&tv); cairo_region_translate (invalid, -recorder->area.x, -recorder->area.y); g_signal_emit (recorder, signals[IMAGE], 0, surface, invalid, &tv); cairo_surface_destroy (surface); cairo_region_destroy (invalid); recorder->next_image_source = gdk_threads_add_timeout_full (G_PRIORITY_HIGH_IDLE, BYZANZ_RECORDER_FRAME_RATE_MS, byzanz_recorder_next_image, recorder, NULL); return TRUE; }
static void gtk_tooltip_start_delay (GdkDisplay *display) { guint timeout; GtkTooltip *tooltip; GtkSettings *settings; tooltip = g_object_get_data (G_OBJECT (display), "gdk-display-current-tooltip"); if (!tooltip || GTK_TOOLTIP_VISIBLE (tooltip)) return; if (tooltip->timeout_id) g_source_remove (tooltip->timeout_id); settings = gtk_widget_get_settings (GTK_WIDGET (tooltip->window)); if (tooltip->browse_mode_enabled) g_object_get (settings, "gtk-tooltip-browse-timeout", &timeout, NULL); else g_object_get (settings, "gtk-tooltip-timeout", &timeout, NULL); tooltip->timeout_id = gdk_threads_add_timeout_full (0, timeout, tooltip_popup_timeout, g_object_ref (display), g_object_unref); }
static gboolean test_set_filename (GtkFileChooserAction action, gboolean focus_button, SetFilenameFn set_filename_fn,const CompareFilenameFn compare_filename_fn, gpointer data) { GtkWidget *chooser; struct test_set_filename_closure closure; gboolean retval; chooser = gtk_file_chooser_dialog_new ("hello", NULL, action, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); closure.chooser = chooser; closure.accept_button = gtk_dialog_add_button (GTK_DIALOG (chooser), GTK_STOCK_OK, GTK_RESPONSE_ACCEPT); closure.focus_button = focus_button; gtk_dialog_set_default_response (GTK_DIALOG (chooser), GTK_RESPONSE_ACCEPT); (* set_filename_fn) (GTK_FILE_CHOOSER (chooser), data); gdk_threads_add_timeout_full (G_MAXINT, SLEEP_DURATION, set_filename_timeout_cb, &closure, NULL); gtk_dialog_run (GTK_DIALOG (chooser)); retval = (* compare_filename_fn) (GTK_FILE_CHOOSER (chooser), data); gtk_widget_destroy (chooser); return retval; }
/** * gdk_threads_add_timeout: (skip) * @interval: the time between calls to the function, in milliseconds * (1/1000ths of a second) * @function: function to call * @data: data to pass to @function * * A wrapper for the common usage of gdk_threads_add_timeout_full() * assigning the default priority, #G_PRIORITY_DEFAULT. * * See gdk_threads_add_timeout_full(). * * Returns: the ID (greater than 0) of the event source. * * Since: 2.12 */ guint gdk_threads_add_timeout (guint interval, GSourceFunc function, gpointer data) { return gdk_threads_add_timeout_full (G_PRIORITY_DEFAULT, interval, function, data, NULL); }
/* * Class: com_sun_glass_ui_gtk_GtkTimer * Method: _start * Signature: (Ljava/lang/Runnable;I)J */ JNIEXPORT jlong JNICALL Java_com_sun_glass_ui_gtk_GtkTimer__1start (JNIEnv * env, jobject obj, jobject runnable, jint period) { RunnableContext* context = (RunnableContext*) malloc(sizeof(RunnableContext)); context->runnable = env->NewGlobalRef(runnable); context->flag = 0; gdk_threads_add_timeout_full(G_PRIORITY_HIGH_IDLE, period, call_runnable_in_timer, context, NULL); return PTR_TO_JLONG(context); }
/* * Signature the prototype of a (*hide) callback, meeting the requirements of * the third parameter to g_signal_connect() for signal 'hide'. */ static void window_hide_handler ( GtkWidget* widget, gpointer user_data ) { if (DEBUG_MEMORY_MANAGEMENT) { g_printerr("mem: hide caught for\t\t%s\n", bindings_java_memory_pointerToString(widget)); } gdk_threads_add_timeout_full(G_PRIORITY_LOW, 100, window_hide_deref, widget, NULL); }
static void hildon_app_menu_map (GtkWidget *widget) { HildonAppMenuPrivate *priv = HILDON_APP_MENU_GET_PRIVATE(widget); GTK_WIDGET_CLASS (hildon_app_menu_parent_class)->map (widget); if (priv->find_intruder_idle_id == 0) priv->find_intruder_idle_id = gdk_threads_add_timeout_full ( G_PRIORITY_DEFAULT_IDLE, 100, hildon_app_menu_find_intruder, g_object_ref (widget), g_object_unref); }
static void gtk_tooltip_hide_tooltip (GtkTooltip *tooltip) { if (!tooltip) return; if (tooltip->timeout_id) { g_source_remove (tooltip->timeout_id); tooltip->timeout_id = 0; } if (!GTK_TOOLTIP_VISIBLE (tooltip)) return; tooltip->tooltip_widget = NULL; if (!tooltip->keyboard_mode_enabled) { guint timeout; GtkSettings *settings; settings = gtk_widget_get_settings (GTK_WIDGET (tooltip->window)); g_object_get (settings, "gtk-tooltip-browse-mode-timeout", &timeout, NULL); /* The tooltip is gone, after (by default, should be configurable) 500ms * we want to turn off browse mode */ if (!tooltip->browse_mode_timeout_id) tooltip->browse_mode_timeout_id = gdk_threads_add_timeout_full (0, timeout, tooltip_browse_mode_expired, g_object_ref (tooltip), g_object_unref); } else { if (tooltip->browse_mode_timeout_id) { g_source_remove (tooltip->browse_mode_timeout_id); tooltip->browse_mode_timeout_id = 0; } } if (tooltip->current_window) { gtk_widget_hide (GTK_WIDGET (tooltip->current_window)); tooltip->current_window = NULL; } }
static void sleep_in_main_loop (double fraction) { /* process all pending idles and events */ while (g_main_context_pending (NULL)) g_main_context_iteration (NULL, FALSE); /* sleeping probably isn't strictly necessary here */ gdk_threads_add_timeout_full (G_MAXINT, fraction * SLEEP_DURATION, sleep_timeout_cb, NULL, NULL); gtk_main (); /* process any pending idles or events that arrived during sleep */ while (g_main_context_pending (NULL)) g_main_context_iteration (NULL, FALSE); }
static void maybe_start_idle (GdkFrameClockIdle *clock_idle) { GdkFrameClockIdlePrivate *priv = clock_idle->priv; if (RUN_FLUSH_IDLE (priv) || RUN_PAINT_IDLE (priv)) { guint min_interval = 0; if (priv->min_next_frame_time != 0) { gint64 now = compute_frame_time (clock_idle); gint64 min_interval_us = MAX (priv->min_next_frame_time, now) - now; min_interval = (min_interval_us + 500) / 1000; } if (priv->flush_idle_id == 0 && RUN_FLUSH_IDLE (priv)) { priv->flush_idle_id = gdk_threads_add_timeout_full (GDK_PRIORITY_EVENTS + 1, min_interval, gdk_frame_clock_flush_idle, g_object_ref (clock_idle), (GDestroyNotify) g_object_unref); g_source_set_name_by_id (priv->flush_idle_id, "[gtk+] gdk_frame_clock_flush_idle"); } if (!priv->in_paint_idle && priv->paint_idle_id == 0 && RUN_PAINT_IDLE (priv)) { priv->paint_idle_id = gdk_threads_add_timeout_full (GDK_PRIORITY_REDRAW, min_interval, gdk_frame_clock_paint_idle, g_object_ref (clock_idle), (GDestroyNotify) g_object_unref); g_source_set_name_by_id (priv->paint_idle_id, "[gtk+] gdk_frame_clock_paint_idle"); } } }
static void gtk_tooltip_hide_tooltip (GtkTooltip *tooltip) { if (!tooltip) return; if (tooltip->timeout_id) { g_source_remove (tooltip->timeout_id); tooltip->timeout_id = 0; } if (!GTK_TOOLTIP_VISIBLE (tooltip)) return; tooltip->tooltip_widget = NULL; if (!tooltip->keyboard_mode_enabled) { guint timeout = BROWSE_DISABLE_TIMEOUT; /* The tooltip is gone, after (by default, should be configurable) 500ms * we want to turn off browse mode */ if (!tooltip->browse_mode_timeout_id) { tooltip->browse_mode_timeout_id = gdk_threads_add_timeout_full (0, timeout, tooltip_browse_mode_expired, g_object_ref (tooltip), g_object_unref); g_source_set_name_by_id (tooltip->browse_mode_timeout_id, "[gtk+] tooltip_browse_mode_expired"); } } else { if (tooltip->browse_mode_timeout_id) { g_source_remove (tooltip->browse_mode_timeout_id); tooltip->browse_mode_timeout_id = 0; } } if (tooltip->current_window) { gtk_widget_hide (GTK_WIDGET (tooltip->current_window)); tooltip->current_window = NULL; } }
void gimp_draw_tool_resume (GimpDrawTool *draw_tool) { g_return_if_fail (GIMP_IS_DRAW_TOOL (draw_tool)); g_return_if_fail (draw_tool->paused_count > 0); draw_tool->paused_count--; #ifdef USE_TIMEOUT if (draw_tool->paused_count == 0 && ! draw_tool->draw_timeout) draw_tool->draw_timeout = gdk_threads_add_timeout_full (G_PRIORITY_HIGH_IDLE, DRAW_TIMEOUT, (GSourceFunc) gimp_draw_tool_draw_timeout, draw_tool, NULL); #else gimp_draw_tool_draw (draw_tool); #endif }
static void gimp_n_point_deformation_tool_start (GimpNPointDeformationTool *npd_tool, GimpDisplay *display) { GimpTool *tool = GIMP_TOOL (npd_tool); GimpNPointDeformationOptions *npd_options; GimpImage *image; GeglBuffer *source_buffer; GeglBuffer *preview_buffer; NPDModel *model; npd_options = GIMP_N_POINT_DEFORMATION_TOOL_GET_OPTIONS (npd_tool); gimp_tool_control (tool, GIMP_TOOL_ACTION_HALT, display); image = gimp_display_get_image (display); tool->display = display; tool->drawable = gimp_image_get_active_drawable (image); npd_tool->active = TRUE; /* create GEGL graph */ source_buffer = gimp_drawable_get_buffer (tool->drawable); preview_buffer = gegl_buffer_new (gegl_buffer_get_extent (source_buffer), babl_format ("cairo-ARGB32")); npd_tool->graph = gegl_node_new (); npd_tool->source = gegl_node_new_child (npd_tool->graph, "operation", "gegl:buffer-source", "buffer", source_buffer, NULL); npd_tool->npd_node = gegl_node_new_child (npd_tool->graph, "operation", "gegl:npd", NULL); npd_tool->sink = gegl_node_new_child (npd_tool->graph, "operation", "gegl:write-buffer", "buffer", preview_buffer, NULL); gegl_node_link_many (npd_tool->source, npd_tool->npd_node, npd_tool->sink, NULL); /* initialize some options */ g_object_set (G_OBJECT (npd_options), "mesh-visible", TRUE, NULL); gimp_n_point_deformation_options_set_sensitivity (npd_options, TRUE); /* compute and get model */ gegl_node_process (npd_tool->npd_node); gegl_node_get (npd_tool->npd_node, "model", &model, NULL); npd_tool->model = model; npd_tool->preview_buffer = preview_buffer; npd_tool->selected_cp = NULL; npd_tool->hovering_cp = NULL; npd_tool->selected_cps = NULL; npd_tool->rubber_band = FALSE; npd_tool->lattice_points = g_new (GimpVector2, 5 * model->hidden_model->num_of_bones); gimp_item_get_offset (GIMP_ITEM (tool->drawable), &npd_tool->offset_x, &npd_tool->offset_y); gimp_npd_debug (("offset: %f %f\n", npd_tool->offset_x, npd_tool->offset_y)); gimp_draw_tool_start (GIMP_DRAW_TOOL (npd_tool), display); gimp_n_point_deformation_tool_perform_deformation (npd_tool); /* hide original image */ gimp_item_set_visible (GIMP_ITEM (tool->drawable), FALSE, FALSE); gimp_image_flush (image); /* create and start a deformation thread */ npd_tool->deform_thread = g_thread_new ("deform thread", (GThreadFunc) gimp_n_point_deformation_tool_deform_thread_func, npd_tool); /* create and start canvas update timeout */ npd_tool->draw_timeout_id = gdk_threads_add_timeout_full (G_PRIORITY_DEFAULT_IDLE, GIMP_NPD_DRAW_INTERVAL, (GSourceFunc) gimp_n_point_deformation_tool_canvas_update_timeout, npd_tool, NULL); }
gint init(void* arg) { gint x; gint y; DISCOVERED* d; char *res; char wisdom_directory[1024]; char wisdom_file[1024]; fprintf(stderr,"init\n"); audio_get_cards(0); audio_get_cards(1); cursor_arrow=gdk_cursor_new(GDK_ARROW); cursor_watch=gdk_cursor_new(GDK_WATCH); GdkWindow *gdk_splash_window = gtk_widget_get_window(splash_window); gdk_window_set_cursor(gdk_splash_window,cursor_watch); init_radio(); // check if wisdom file exists res=getcwd(wisdom_directory, sizeof(wisdom_directory)); strcpy(&wisdom_directory[strlen(wisdom_directory)],"/"); strcpy(wisdom_file,wisdom_directory); strcpy(&wisdom_file[strlen(wisdom_file)],"wdspWisdom"); splash_status("Checking FFTW Wisdom file ..."); if(access(wisdom_file,F_OK)<0) { int rc=sem_init(&wisdom_sem, 0, 0); rc=pthread_create(&wisdom_thread_id, NULL, wisdom_thread, (void *)wisdom_directory); while(sem_trywait(&wisdom_sem)<0) { splash_status(wisdom_get_status()); while (gtk_events_pending ()) gtk_main_iteration (); usleep(100000); // 100ms } } while(!start) { gdk_window_set_cursor(gdk_splash_window,cursor_watch); selected_device=0; devices=0; splash_status("Old Protocol ... Discovering Devices"); old_discovery(); splash_status("New Protocol ... Discovering Devices"); new_discovery(); #ifdef LIMESDR splash_status("LimeSDR ... Discovering Devices"); lime_discovery(); #endif splash_status("Discovery"); if(devices==0) { gdk_window_set_cursor(gdk_splash_window,cursor_arrow); fprintf(stderr,"No devices found!\n"); GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT; discovery_dialog = gtk_message_dialog_new (GTK_WINDOW(splash_window), flags, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK_CANCEL, "No devices found! Retry Discovery?"); gtk_widget_override_font(discovery_dialog, pango_font_description_from_string("FreeMono 18")); gint result=gtk_dialog_run (GTK_DIALOG (discovery_dialog)); gtk_widget_destroy(discovery_dialog); if(result==GTK_RESPONSE_CANCEL) { _exit(0); } } else { fprintf(stderr,"%s: found %d devices.\n", (char *)arg, devices); gdk_window_set_cursor(gdk_splash_window,cursor_arrow); GtkDialogFlags flags=GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT; discovery_dialog = gtk_dialog_new_with_buttons ("Discovered", GTK_WINDOW(splash_window), flags, #ifdef GPIO "Configure GPIO", GTK_RESPONSE_YES, #endif "Discover", GTK_RESPONSE_REJECT, "Exit", GTK_RESPONSE_CLOSE, NULL); gtk_widget_override_font(discovery_dialog, pango_font_description_from_string("FreeMono 18")); GtkWidget *content; content=gtk_dialog_get_content_area(GTK_DIALOG(discovery_dialog)); GtkWidget *grid=gtk_grid_new(); gtk_grid_set_row_homogeneous(GTK_GRID(grid),TRUE); gtk_grid_set_column_homogeneous(GTK_GRID(grid),TRUE); gtk_grid_set_row_spacing (GTK_GRID(grid),10); int i; char version[16]; char text[128]; for(i=0;i<devices;i++) { d=&discovered[i]; fprintf(stderr,"%p protocol=%d name=%s\n",d,d->protocol,d->name); if(d->protocol==ORIGINAL_PROTOCOL) { sprintf(version,"%d.%d", d->software_version/10, d->software_version%10); } else { sprintf(version,"%d.%d.%d", d->software_version/100, (d->software_version%100)/10, d->software_version%10); } switch(d->protocol) { case ORIGINAL_PROTOCOL: case NEW_PROTOCOL: sprintf(text,"%s (%s %s) %s (%02X:%02X:%02X:%02X:%02X:%02X) on %s\n", d->name, d->protocol==ORIGINAL_PROTOCOL?"old":"new", version, inet_ntoa(d->info.network.address.sin_addr), d->info.network.mac_address[0], d->info.network.mac_address[1], d->info.network.mac_address[2], d->info.network.mac_address[3], d->info.network.mac_address[4], d->info.network.mac_address[5], d->info.network.interface_name); break; #ifdef LIMESDR case LIMESDR_PROTOCOL: /* sprintf(text,"%s (%s %s)\n", d->name, "lime", version); */ sprintf(text,"%s\n", d->name); break; #endif } GtkWidget *label=gtk_label_new(text); gtk_widget_override_font(label, pango_font_description_from_string("FreeMono 12")); gtk_widget_show(label); gtk_grid_attach(GTK_GRID(grid),label,0,i,3,1); GtkWidget *start_button=gtk_button_new_with_label("Start"); gtk_widget_override_font(start_button, pango_font_description_from_string("FreeMono 18")); gtk_widget_show(start_button); gtk_grid_attach(GTK_GRID(grid),start_button,3,i,1,1); g_signal_connect(start_button,"pressed",G_CALLBACK(start_cb),(gpointer)d); // if not available then cannot start it if(d->status!=STATE_AVAILABLE) { gtk_button_set_label(GTK_BUTTON(start_button),"In Use"); gtk_widget_set_sensitive(start_button, FALSE); } // if not on the same subnet then cannot start it if((d->info.network.interface_address.sin_addr.s_addr&d->info.network.interface_netmask.sin_addr.s_addr) != (d->info.network.address.sin_addr.s_addr&d->info.network.interface_netmask.sin_addr.s_addr)) { gtk_button_set_label(GTK_BUTTON(start_button),"Subnet!"); gtk_widget_set_sensitive(start_button, FALSE); } } gtk_container_add (GTK_CONTAINER (content), grid); gtk_widget_show_all(discovery_dialog); gint result=gtk_dialog_run(GTK_DIALOG(discovery_dialog)); if(result==GTK_RESPONSE_CLOSE) { _exit(0); } if(!start) { gtk_widget_destroy(discovery_dialog); } #ifdef GPIO if(result==GTK_RESPONSE_YES) { configure_gpio(splash_window); } #endif } } gdk_window_set_cursor(gdk_splash_window,cursor_watch); splash_status("Initializing wdsp ..."); fprintf(stderr,"selected radio=%p device=%d\n",radio,radio->device); protocol=radio->protocol; device=radio->device; switch(radio->protocol) { case ORIGINAL_PROTOCOL: case NEW_PROTOCOL: sprintf(property_path,"%02X-%02X-%02X-%02X-%02X-%02X.props", radio->info.network.mac_address[0], radio->info.network.mac_address[1], radio->info.network.mac_address[2], radio->info.network.mac_address[3], radio->info.network.mac_address[4], radio->info.network.mac_address[5]); break; #ifdef LIMESDR case LIMESDR_PROTOCOL: sprintf(property_path,"limesdr.props"); break; #endif } radioRestoreState(); fprintf(stderr,"malloc samples\n"); if(radio->protocol==NEW_PROTOCOL) { samples=malloc(display_width*sizeof(float)*2*4); // 192 -> 48 } else { samples=malloc(display_width*sizeof(float)*2); } //splash_status("Initializing wdsp ..."); fprintf(stderr,"wdsp_init\n"); wdsp_init(0,display_width,radio->protocol); switch(radio->protocol) { case ORIGINAL_PROTOCOL: splash_status("Initializing old protocol ..."); fprintf(stderr,"old_protocol_init\n"); old_protocol_init(0,display_width); break; case NEW_PROTOCOL: splash_status("Initializing new protocol ..."); fprintf(stderr,"new_protocol_init\n"); new_protocol_init(0,display_width); break; #ifdef LIMESDR case LIMESDR_PROTOCOL: splash_status("Initializing lime protocol ..."); lime_protocol_init(0,display_width); break; #endif } fprintf(stderr,"gpio_init\n"); splash_status("Initializing GPIO ..."); #ifdef GPIO if(gpio_init()<0) { } #endif window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "pihpsdr"); gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_CENTER_ALWAYS); gtk_window_set_resizable(GTK_WINDOW(window), FALSE); g_signal_connect (window, "delete-event", G_CALLBACK (main_delete), NULL); fixed=gtk_fixed_new(); gtk_container_add(GTK_CONTAINER(window), fixed); y=0; fprintf(stderr,"vfo_height=%d\n",VFO_HEIGHT); vfo = vfo_init(VFO_WIDTH,VFO_HEIGHT,window); gtk_fixed_put(GTK_FIXED(fixed),vfo,0,0); rit_control = rit_init(RIT_WIDTH,MENU_HEIGHT,window); gtk_fixed_put(GTK_FIXED(fixed),rit_control,VFO_WIDTH,y); fprintf(stderr,"menu_height=%d\n",MENU_HEIGHT); //menu = menu_init(MENU_WIDTH,MENU_HEIGHT,window); menu = new_menu_init(MENU_WIDTH-RIT_WIDTH,MENU_HEIGHT,window); gtk_fixed_put(GTK_FIXED(fixed),menu,VFO_WIDTH+((MENU_WIDTH/3)*2),y); fprintf(stderr,"meter_height=%d\n",METER_HEIGHT); meter = meter_init(METER_WIDTH,METER_HEIGHT,window); gtk_fixed_put(GTK_FIXED(fixed),meter,VFO_WIDTH+MENU_WIDTH,y); y+=VFO_HEIGHT; if(display_panadapter) { int height=PANADAPTER_HEIGHT; if(!display_waterfall) { height+=WATERFALL_HEIGHT; if(!display_sliders) { height+=SLIDERS_HEIGHT; } if(!display_toolbar) { height+=TOOLBAR_HEIGHT; } } else { if(!display_sliders) { height+=SLIDERS_HEIGHT/2; } } fprintf(stderr,"panadapter_height=%d\n",height); panadapter = panadapter_init(display_width,height); gtk_fixed_put(GTK_FIXED(fixed),panadapter,0,VFO_HEIGHT); y+=height; } if(display_waterfall) { int height=WATERFALL_HEIGHT; if(!display_panadapter) { height+=PANADAPTER_HEIGHT; } if(!display_sliders) { if(display_panadapter) { height+=SLIDERS_HEIGHT/2; } else { height+=SLIDERS_HEIGHT; } } if(!display_toolbar) { height+=TOOLBAR_HEIGHT; } fprintf(stderr,"waterfall_height=%d\n",height); waterfall = waterfall_init(display_width,height); gtk_fixed_put(GTK_FIXED(fixed),waterfall,0,y); y+=height; } #ifdef PSK int psk_height=PSK_WATERFALL_HEIGHT; if(!display_sliders) { psk_height+=SLIDERS_HEIGHT/2; } if(!display_toolbar) { psk_height+=TOOLBAR_HEIGHT/2; } psk_waterfall = psk_waterfall_init(display_width,psk_height); gtk_fixed_put(GTK_FIXED(fixed),psk_waterfall,0,VFO_HEIGHT); psk = init_psk(); gtk_fixed_put(GTK_FIXED(fixed),psk,0,VFO_HEIGHT+psk_height); #endif if(display_sliders) { fprintf(stderr,"sliders_height=%d\n",SLIDERS_HEIGHT); sliders = sliders_init(display_width,SLIDERS_HEIGHT,window); gtk_fixed_put(GTK_FIXED(fixed),sliders,0,y); y+=SLIDERS_HEIGHT; } if(display_toolbar) { fprintf(stderr,"toolbar_height=%d\n",TOOLBAR_HEIGHT); toolbar = toolbar_init(display_width,TOOLBAR_HEIGHT,window); gtk_fixed_put(GTK_FIXED(fixed),toolbar,0,y); y+=TOOLBAR_HEIGHT; } splash_close(); gtk_widget_show_all (window); if(full_screen) { gtk_window_fullscreen(GTK_WINDOW(window)); } GdkWindow *gdk_window = gtk_widget_get_window(window); gdk_window_set_cursor(gdk_window,cursor_arrow); // start the receiver SetChannelState(CHANNEL_RX0,1,1); //update_timer_id=gdk_threads_add_timeout(1000/updates_per_second, update, NULL); update_timer_id=gdk_threads_add_timeout_full(G_PRIORITY_HIGH_IDLE,1000/updates_per_second, update, NULL, NULL); // save every 30 seconds save_timer_id=gdk_threads_add_timeout(30000, save_cb, NULL); if(protocol!=NEW_PROTOCOL) { setFrequency(getFrequency()); } #ifdef PSK if(mode==modePSK) { show_psk(); } else { show_waterfall(); } #endif g_idle_add(vfo_update,(gpointer)NULL); return 0; }
/* http://bugzilla.gnome.org/show_bug.cgi?id=347883 */ static gboolean test_confirm_overwrite_for_path (const char *path, gboolean append_extension) { gboolean passed; struct confirm_overwrite_closure closure; char *filename; passed = TRUE; closure.extension = NULL; closure.confirm_overwrite_signal_emitted = 0; closure.chooser = gtk_file_chooser_dialog_new ("hello", NULL, GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); closure.accept_button = gtk_dialog_add_button (GTK_DIALOG (closure.chooser), GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT); gtk_dialog_set_default_response (GTK_DIALOG (closure.chooser), GTK_RESPONSE_ACCEPT); gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (closure.chooser), TRUE); g_signal_connect (closure.chooser, "confirm-overwrite", G_CALLBACK (confirm_overwrite_cb), &closure); if (append_extension) { char *extension; filename = g_path_get_dirname (path); gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (closure.chooser), filename); g_free (filename); filename = g_path_get_basename (path); extension = strchr (filename, '.'); if (extension) { closure.extension = g_strdup (extension); *extension = '\0'; } gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (closure.chooser), filename); g_free (filename); g_signal_connect (closure.chooser, "response", G_CALLBACK (overwrite_response_cb), &closure); } else { gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (closure.chooser), path); } gdk_threads_add_timeout_full (G_MAXINT, SLEEP_DURATION, confirm_overwrite_timeout_cb, &closure, NULL); gtk_dialog_run (GTK_DIALOG (closure.chooser)); filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (closure.chooser)); passed = passed && filename && (strcmp (filename, path) == 0); g_free (filename); gtk_widget_destroy (closure.chooser); passed = passed && (1 == closure.confirm_overwrite_signal_emitted); log_test (passed, "Confirm overwrite for %s", path); return passed; }