int main(int argc, char *argv[]){ /* global variables to be reused */ unsigned int uint = 0; /* Declare all widgets here */ GtkWidget * window; GtkWidget * notebook; GtkWidget * spacer; /* this is a spacer for grid */ GtkWidget * page_volume_label; GtkWidget * page_volume_grid; GtkWidget * page_volume_scale; GtkWidget * page_volume_scale_label; GtkWidget * page_volume_mute_toggle; GtkWidget * page_browser_label; GtkWidget * page_browser_grid; GtkWidget * page_browser_button; //GtkWidget * page_browser_pid_label; gtk_init(&argc, &argv); /* Create a new window. This is the parent window */ window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW (window), "Control Panel"); gtk_window_set_default_size(GTK_WINDOW (window), 200, 300); /* Create spacer */ spacer = gtk_label_new(" "); /* Create a new notebook */ notebook = gtk_notebook_new(); gtk_container_add(GTK_CONTAINER (window), notebook); /* Page VOLUME config */ /* label */ page_volume_label = gtk_label_new("Volume Settings"); /* volume scale */ page_volume_scale = gtk_scale_new_with_range(GTK_ORIENTATION_VERTICAL,0,100,1); gtk_range_set_inverted(GTK_RANGE (page_volume_scale), TRUE); gtk_scale_add_mark(GTK_SCALE (page_volume_scale), 0, GTK_POS_RIGHT, "0"); gtk_scale_add_mark(GTK_SCALE (page_volume_scale), 25, GTK_POS_RIGHT, "25"); gtk_scale_add_mark(GTK_SCALE (page_volume_scale), 50, GTK_POS_RIGHT, "50"); gtk_scale_add_mark(GTK_SCALE (page_volume_scale), 75, GTK_POS_RIGHT, "75"); gtk_scale_add_mark(GTK_SCALE (page_volume_scale), 100, GTK_POS_RIGHT, "100"); gtk_scale_set_draw_value(GTK_SCALE (page_volume_scale), 1); initializeVolumeScale(page_volume_scale); /* scale label, Master */ page_volume_scale_label = gtk_label_new("Master"); /* checkbox for mute option */ page_volume_mute_toggle = gtk_toggle_button_new_with_label("Mute / Unmute"); /* page grid for layout */ page_volume_grid = gtk_grid_new(); gtk_grid_attach(GTK_GRID (page_volume_grid), spacer, 0, 0, 5, 20); gtk_grid_attach(GTK_GRID (page_volume_grid), page_volume_scale_label, 4, 5, 10, 5); gtk_grid_attach(GTK_GRID (page_volume_grid), page_volume_scale, 5, 20, 10, 30); gtk_widget_set_hexpand(page_volume_scale, TRUE); gtk_widget_set_vexpand(page_volume_scale, TRUE); gtk_grid_attach(GTK_GRID (page_volume_grid), page_volume_mute_toggle, 7, 50, 4, 4); /* page */ gtk_notebook_insert_page(GTK_NOTEBOOK (notebook),page_volume_grid,page_volume_label, 0); /* signal listener */ g_signal_connect(page_volume_scale, "value-changed", G_CALLBACK (adjustVolume), page_volume_scale); g_signal_connect(page_volume_mute_toggle, "toggled", G_CALLBACK (muteVolume), page_volume_mute_toggle); /* Page BROWSER config */ /* page label */ page_browser_label = gtk_label_new("Web Browser"); /* page button to open browser */ page_browser_button = gtk_button_new_with_label("Start Firefox"); /* page pid label that shows pid of browsers */ //page_browser_pid_label = gtk_label_new("Test"); /*page grid */ page_browser_grid = gtk_grid_new(); spacer = gtk_label_new(" "); gtk_grid_attach(GTK_GRID (page_browser_grid), spacer, 0, 0, 10, 10); gtk_grid_attach(GTK_GRID (page_browser_grid), page_browser_button, 10, 10, 15, 5); spacer = gtk_label_new(" "); gtk_grid_attach(GTK_GRID (page_browser_grid), spacer, 10, 5, 10, 10); //gtk_grid_attach(GTK_GRID (page_browser_grid), page_browser_pid_label, 20, 50, 10, 5); /*page */ gtk_notebook_insert_page(GTK_NOTEBOOK (notebook), page_browser_grid, page_browser_label, 1); /* listeners */ g_signal_connect(page_browser_button, "released", G_CALLBACK (openFirefox), spacer);//page_browser_pid_label); /* Finally ... */ gtk_widget_show_all(window); gtk_main (); return 0; }
/* returns TRUE if OK was pressed. */ static gboolean georef_layer_dialog ( VikGeorefLayer *vgl, gpointer vp, GtkWindow *w, gboolean have_apply_button ) { GtkWidget *dialog = gtk_dialog_new_with_buttons (_("Layer Properties"), w, GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL ); if ( have_apply_button ) gtk_dialog_add_button ( GTK_DIALOG(dialog), GTK_STOCK_APPLY, GTK_RESPONSE_APPLY ); gtk_dialog_add_button ( GTK_DIALOG(dialog), GTK_STOCK_OK, GTK_RESPONSE_ACCEPT ); /* Default to reject as user really needs to specify map file first */ gtk_dialog_set_default_response ( GTK_DIALOG(dialog), GTK_RESPONSE_REJECT ); GtkWidget *response_w = NULL; #if GTK_CHECK_VERSION (2, 20, 0) response_w = gtk_dialog_get_widget_for_response ( GTK_DIALOG(dialog), GTK_RESPONSE_REJECT ); #endif GtkWidget *table, *wfp_hbox, *wfp_label, *wfp_button, *ce_label, *cn_label, *xlabel, *ylabel, *imagelabel; changeable_widgets cw; GtkBox *dgbox = GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))); table = gtk_table_new ( 4, 2, FALSE ); gtk_box_pack_start ( dgbox, table, TRUE, TRUE, 0 ); wfp_hbox = gtk_hbox_new ( FALSE, 0 ); wfp_label = gtk_label_new ( _("World File Parameters:") ); wfp_button = gtk_button_new_with_label ( _("Load From File...") ); gtk_box_pack_start ( GTK_BOX(wfp_hbox), wfp_label, TRUE, TRUE, 0 ); gtk_box_pack_start ( GTK_BOX(wfp_hbox), wfp_button, FALSE, FALSE, 3 ); ce_label = gtk_label_new ( _("Corner pixel easting:") ); cw.ce_spin = gtk_spin_button_new ( (GtkAdjustment *) gtk_adjustment_new ( 4, -15000000.0, 1500000.0, 1, 5, 0 ), 1, 4 ); gtk_widget_set_tooltip_text ( GTK_WIDGET(cw.ce_spin), _("the UTM \"easting\" value of the upper-left corner pixel of the map") ); cn_label = gtk_label_new ( _("Corner pixel northing:") ); cw.cn_spin = gtk_spin_button_new ( (GtkAdjustment *) gtk_adjustment_new ( 4, -15000000.0, 15000000.0, 1, 5, 0 ), 1, 4 ); gtk_widget_set_tooltip_text ( GTK_WIDGET(cw.cn_spin), _("the UTM \"northing\" value of the upper-left corner pixel of the map") ); xlabel = gtk_label_new ( _("X (easting) scale (mpp): ")); ylabel = gtk_label_new ( _("Y (northing) scale (mpp): ")); cw.x_spin = gtk_spin_button_new ( (GtkAdjustment *) gtk_adjustment_new ( 4, VIK_VIEWPORT_MIN_ZOOM, VIK_VIEWPORT_MAX_ZOOM, 1, 5, 0 ), 1, 8 ); gtk_widget_set_tooltip_text ( GTK_WIDGET(cw.x_spin), _("the scale of the map in the X direction (meters per pixel)") ); cw.y_spin = gtk_spin_button_new ( (GtkAdjustment *) gtk_adjustment_new ( 4, VIK_VIEWPORT_MIN_ZOOM, VIK_VIEWPORT_MAX_ZOOM, 1, 5, 0 ), 1, 8 ); gtk_widget_set_tooltip_text ( GTK_WIDGET(cw.y_spin), _("the scale of the map in the Y direction (meters per pixel)") ); imagelabel = gtk_label_new ( _("Map Image:") ); cw.imageentry = vik_file_entry_new (GTK_FILE_CHOOSER_ACTION_OPEN, VF_FILTER_IMAGE, maybe_read_world_file, &cw); gtk_spin_button_set_value ( GTK_SPIN_BUTTON(cw.ce_spin), vgl->corner.easting ); gtk_spin_button_set_value ( GTK_SPIN_BUTTON(cw.cn_spin), vgl->corner.northing ); gtk_spin_button_set_value ( GTK_SPIN_BUTTON(cw.x_spin), vgl->mpp_easting ); gtk_spin_button_set_value ( GTK_SPIN_BUTTON(cw.y_spin), vgl->mpp_northing ); if ( vgl->image ) vik_file_entry_set_filename ( VIK_FILE_ENTRY(cw.imageentry), vgl->image ); gtk_table_attach_defaults ( GTK_TABLE(table), imagelabel, 0, 1, 0, 1 ); gtk_table_attach_defaults ( GTK_TABLE(table), cw.imageentry, 1, 2, 0, 1 ); gtk_table_attach_defaults ( GTK_TABLE(table), wfp_hbox, 0, 2, 1, 2 ); gtk_table_attach_defaults ( GTK_TABLE(table), xlabel, 0, 1, 2, 3 ); gtk_table_attach_defaults ( GTK_TABLE(table), cw.x_spin, 1, 2, 2, 3 ); gtk_table_attach_defaults ( GTK_TABLE(table), ylabel, 0, 1, 3, 4 ); gtk_table_attach_defaults ( GTK_TABLE(table), cw.y_spin, 1, 2, 3, 4 ); cw.tabs = gtk_notebook_new(); GtkWidget *table_utm = gtk_table_new ( 3, 2, FALSE ); gtk_table_attach_defaults ( GTK_TABLE(table_utm), ce_label, 0, 1, 0, 1 ); gtk_table_attach_defaults ( GTK_TABLE(table_utm), cw.ce_spin, 1, 2, 0, 1 ); gtk_table_attach_defaults ( GTK_TABLE(table_utm), cn_label, 0, 1, 1, 2 ); gtk_table_attach_defaults ( GTK_TABLE(table_utm), cw.cn_spin, 1, 2, 1, 2 ); GtkWidget *utm_hbox = gtk_hbox_new ( FALSE, 0 ); cw.utm_zone_spin = gtk_spin_button_new ((GtkAdjustment*)gtk_adjustment_new( vgl->corner.zone, 1, 60, 1, 5, 0 ), 1, 0 ); gtk_box_pack_start ( GTK_BOX(utm_hbox), gtk_label_new(_("Zone:")), TRUE, TRUE, 0 ); gtk_box_pack_start ( GTK_BOX(utm_hbox), cw.utm_zone_spin, TRUE, TRUE, 0 ); gtk_box_pack_start ( GTK_BOX(utm_hbox), gtk_label_new(_("Letter:")), TRUE, TRUE, 0 ); cw.utm_letter_entry = gtk_entry_new (); gtk_entry_set_max_length ( GTK_ENTRY(cw.utm_letter_entry), 1 ); gtk_entry_set_width_chars ( GTK_ENTRY(cw.utm_letter_entry), 2 ); gchar tmp_letter[2]; tmp_letter[0] = vgl->corner.letter; tmp_letter[1] = '\0'; gtk_entry_set_text ( GTK_ENTRY(cw.utm_letter_entry), tmp_letter ); gtk_box_pack_start ( GTK_BOX(utm_hbox), cw.utm_letter_entry, TRUE, TRUE, 0 ); gtk_table_attach_defaults ( GTK_TABLE(table_utm), utm_hbox, 0, 2, 2, 3 ); // Lat/Lon GtkWidget *table_ll = gtk_table_new ( 5, 2, FALSE ); GtkWidget *lat_tl_label = gtk_label_new ( _("Upper left latitude:") ); cw.lat_tl_spin = gtk_spin_button_new ( (GtkAdjustment *) gtk_adjustment_new (0.0,-90,90.0,0.05,0.1,0), 0.1, 6 ); GtkWidget *lon_tl_label = gtk_label_new ( _("Upper left longitude:") ); cw.lon_tl_spin = gtk_spin_button_new ( (GtkAdjustment *) gtk_adjustment_new (0.0,-180,180.0,0.05,0.1,0), 0.1, 6 ); GtkWidget *lat_br_label = gtk_label_new ( _("Lower right latitude:") ); cw.lat_br_spin = gtk_spin_button_new ( (GtkAdjustment *) gtk_adjustment_new (0.0,-90,90.0,0.05,0.1,0), 0.1, 6 ); GtkWidget *lon_br_label = gtk_label_new ( _("Lower right longitude:") ); cw.lon_br_spin = gtk_spin_button_new ( (GtkAdjustment *) gtk_adjustment_new (0.0,-180.0,180.0,0.05,0.1,0), 0.1, 6 ); gtk_table_attach_defaults ( GTK_TABLE(table_ll), lat_tl_label, 0, 1, 0, 1 ); gtk_table_attach_defaults ( GTK_TABLE(table_ll), cw.lat_tl_spin, 1, 2, 0, 1 ); gtk_table_attach_defaults ( GTK_TABLE(table_ll), lon_tl_label, 0, 1, 1, 2 ); gtk_table_attach_defaults ( GTK_TABLE(table_ll), cw.lon_tl_spin, 1, 2, 1, 2 ); gtk_table_attach_defaults ( GTK_TABLE(table_ll), lat_br_label, 0, 1, 2, 3 ); gtk_table_attach_defaults ( GTK_TABLE(table_ll), cw.lat_br_spin, 1, 2, 2, 3 ); gtk_table_attach_defaults ( GTK_TABLE(table_ll), lon_br_label, 0, 1, 3, 4 ); gtk_table_attach_defaults ( GTK_TABLE(table_ll), cw.lon_br_spin, 1, 2, 3, 4 ); GtkWidget *calc_mpp_button = gtk_button_new_with_label ( _("Calculate MPP values from coordinates") ); gtk_widget_set_tooltip_text ( calc_mpp_button, _("Enter all corner coordinates before calculating the MPP values from the image size") ); gtk_table_attach_defaults ( GTK_TABLE(table_ll), calc_mpp_button, 0, 2, 4, 5 ); VikCoord vc; vik_coord_load_from_utm (&vc, VIK_COORD_LATLON, &(vgl->corner)); gtk_spin_button_set_value ( GTK_SPIN_BUTTON(cw.lat_tl_spin), vc.north_south ); gtk_spin_button_set_value ( GTK_SPIN_BUTTON(cw.lon_tl_spin), vc.east_west ); gtk_spin_button_set_value ( GTK_SPIN_BUTTON(cw.lat_br_spin), vgl->ll_br.lat ); gtk_spin_button_set_value ( GTK_SPIN_BUTTON(cw.lon_br_spin), vgl->ll_br.lon ); gtk_notebook_append_page(GTK_NOTEBOOK(cw.tabs), GTK_WIDGET(table_utm), gtk_label_new(_("UTM"))); gtk_notebook_append_page(GTK_NOTEBOOK(cw.tabs), GTK_WIDGET(table_ll), gtk_label_new(_("Latitude/Longitude"))); gtk_box_pack_start ( dgbox, cw.tabs, TRUE, TRUE, 0 ); GtkWidget *alpha_hbox = gtk_hbox_new ( FALSE, 0 ); // GTK3 => GtkWidget *alpha_scale = gtk_scale_new_with_range ( GTK_ORIENTATION_HORIZONTAL, 0, 255, 1 ); GtkWidget *alpha_scale = gtk_hscale_new_with_range ( 0, 255, 1 ); gtk_scale_set_digits ( GTK_SCALE(alpha_scale), 0 ); gtk_range_set_value ( GTK_RANGE(alpha_scale), vgl->alpha ); gtk_box_pack_start ( GTK_BOX(alpha_hbox), gtk_label_new(_("Alpha:")), TRUE, TRUE, 0 ); gtk_box_pack_start ( GTK_BOX(alpha_hbox), alpha_scale, TRUE, TRUE, 0 ); gtk_box_pack_start ( dgbox, alpha_hbox, TRUE, TRUE, 0 ); vgl->cw = cw; g_signal_connect ( G_OBJECT(vgl->cw.tabs), "switch-page", G_CALLBACK(switch_tab), vgl ); g_signal_connect ( G_OBJECT(calc_mpp_button), "clicked", G_CALLBACK(calculate_mpp_from_coords), vgl ); g_signal_connect_swapped ( G_OBJECT(wfp_button), "clicked", G_CALLBACK(georef_layer_dialog_load), &cw ); if ( response_w ) gtk_widget_grab_focus ( response_w ); gtk_widget_show_all ( dialog ); // Remember setting the notebook page must be done after the widget is visible. gint page_num = 0; if ( a_settings_get_integer ( VIK_SETTINGS_GEOREF_TAB, &page_num ) ) if ( page_num < 0 || page_num > 1 ) page_num = 0; gtk_notebook_set_current_page ( GTK_NOTEBOOK(cw.tabs), page_num ); gboolean answer = FALSE; gint resp = GTK_RESPONSE_APPLY; while ( resp == GTK_RESPONSE_APPLY ) { resp = gtk_dialog_run ( GTK_DIALOG(dialog) ); if ( resp == GTK_RESPONSE_ACCEPT || resp == GTK_RESPONSE_APPLY ) { align_coords ( vgl ); vgl->corner.easting = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(cw.ce_spin) ); vgl->corner.northing = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(cw.cn_spin) ); vgl->corner.zone = gtk_spin_button_get_value_as_int ( GTK_SPIN_BUTTON(cw.utm_zone_spin) ); const gchar *letter = gtk_entry_get_text ( GTK_ENTRY(cw.utm_letter_entry) ); if (*letter) vgl->corner.letter = toupper(*letter); vgl->mpp_easting = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(cw.x_spin) ); vgl->mpp_northing = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(cw.y_spin) ); vgl->ll_br = get_ll_br (vgl); check_br_is_good_or_msg_user ( vgl ); // TODO check if image has changed otherwise no need to regenerate pixbuf if ( !vgl->pixbuf ) { if ( g_strcmp0 (vgl->image, vik_file_entry_get_filename(VIK_FILE_ENTRY(cw.imageentry)) ) != 0 ) { georef_layer_set_image ( vgl, vik_file_entry_get_filename(VIK_FILE_ENTRY(cw.imageentry)) ); georef_layer_load_image ( vgl, VIK_VIEWPORT(vp), FALSE ); } } vgl->alpha = (guint8) gtk_range_get_value ( GTK_RANGE(alpha_scale) ); if ( vgl->pixbuf && vgl->alpha <= 255 ) vgl->pixbuf = ui_pixbuf_set_alpha ( vgl->pixbuf, vgl->alpha ); if ( vgl->scaled && vgl->alpha <= 255 ) vgl->scaled = ui_pixbuf_set_alpha ( vgl->scaled, vgl->alpha ); a_settings_set_integer ( VIK_SETTINGS_GEOREF_TAB, gtk_notebook_get_current_page(GTK_NOTEBOOK(cw.tabs)) ); if ( resp == GTK_RESPONSE_APPLY ) { vik_layer_emit_update ( VIK_LAYER(vgl) ); answer = FALSE; } else answer = TRUE; } } gtk_widget_destroy ( GTK_WIDGET(dialog) ); return answer; }
static void attach_widgets (GtkTextView *text_view) { GtkTextIter iter; GtkTextBuffer *buffer; int i; buffer = gtk_text_view_get_buffer (text_view); gtk_text_buffer_get_start_iter (buffer, &iter); i = 0; while (find_anchor (&iter)) { GtkTextChildAnchor *anchor; GtkWidget *widget; anchor = gtk_text_iter_get_child_anchor (&iter); if (i == 0) { widget = gtk_button_new_with_label ("Click Me"); g_signal_connect (widget, "clicked", G_CALLBACK (easter_egg_callback), NULL); } else if (i == 1) { widget = gtk_combo_box_text_new (); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Option 1"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Option 2"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Option 3"); } else if (i == 2) { widget = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, NULL); gtk_range_set_range (GTK_RANGE (widget), 0, 100); gtk_widget_set_size_request (widget, 70, -1); } else if (i == 3) { gchar *filename = demo_find_file ("floppybuddy.gif", NULL); widget = gtk_image_new_from_file (filename); g_free (filename); } else if (i == 4) { widget = gtk_entry_new (); } else { widget = NULL; /* avoids a compiler warning */ g_assert_not_reached (); } gtk_text_view_add_child_at_anchor (text_view, widget, anchor); gtk_widget_show_all (widget); ++i; } }
static void preset_button_clicked(GtkButton *button, gpointer data) { gint clevel = GPOINTER_TO_INT(data); gtk_range_set_value(GTK_RANGE(feed_slider), clevel >> 16); gtk_range_set_value(GTK_RANGE(fcut_slider), clevel & 0xffff); }
static void update_cursor_size_scale (MateThemeCursorInfo *theme, AppearanceData *data) { #ifdef HAVE_XCURSOR GtkWidget *cursor_size_scale; GtkWidget *cursor_size_label; GtkWidget *cursor_size_small_label; GtkWidget *cursor_size_large_label; gboolean sensitive; gint size, gsettings_size; cursor_size_scale = appearance_capplet_get_widget (data, "cursor_size_scale"); cursor_size_label = appearance_capplet_get_widget (data, "cursor_size_label"); cursor_size_small_label = appearance_capplet_get_widget (data, "cursor_size_small_label"); cursor_size_large_label = appearance_capplet_get_widget (data, "cursor_size_large_label"); sensitive = theme && theme->sizes->len > 1; gtk_widget_set_sensitive (cursor_size_scale, sensitive); gtk_widget_set_sensitive (cursor_size_label, sensitive); gtk_widget_set_sensitive (cursor_size_small_label, sensitive); gtk_widget_set_sensitive (cursor_size_large_label, sensitive); gsettings_size = g_settings_get_int (data->mouse_settings, CURSOR_SIZE_KEY); if (sensitive) { GtkAdjustment *adjustment; gint i, index; GtkRange *range = GTK_RANGE (cursor_size_scale); adjustment = gtk_range_get_adjustment (range); g_object_set (adjustment, "upper", (gdouble) theme->sizes->len - 1, NULL); /* fallback if the gsettings value is bigger than all available sizes; use the largest we have */ index = theme->sizes->len - 1; /* set the slider to the cursor size which matches the gsettings setting best */ for (i = 0; i < theme->sizes->len; i++) { size = g_array_index (theme->sizes, gint, i); if (size == gsettings_size) { index = i; break; } else if (size > gsettings_size) { if (i == 0) { index = 0; } else { gint diff, diff_to_last; diff = size - gsettings_size; diff_to_last = gsettings_size - g_array_index (theme->sizes, gint, i - 1); index = (diff < diff_to_last) ? i : i - 1; } break; } } gtk_range_set_value (range, (gdouble) index); size = g_array_index (theme->sizes, gint, index); } else { if (theme && theme->sizes->len > 0) size = g_array_index (theme->sizes, gint, 0); else size = 18; } if (size != gsettings_size) cursor_size_changed_cb (size, data); #endif }
static void _lib_lighttable_set_zoom(dt_lib_module_t *self, gint zoom) { dt_lib_tool_lighttable_t *d = (dt_lib_tool_lighttable_t *)self->data; gtk_range_set_value(GTK_RANGE(d->zoom), zoom); }
static gboolean reset_scale(GtkWidget *scale, GdkEventButton *event) { if (event->button == 3) gtk_range_set_value(GTK_RANGE(scale), 0.0); return FALSE; }
static gboolean nsgtk_window_draw_event(GtkWidget *widget, cairo_t *cr, gpointer data) { struct gui_window *gw = data; struct gui_window *z; struct rect clip; struct redraw_context ctx = { .interactive = true, .background_images = true, .plot = &nsgtk_plotters }; double x1; double y1; double x2; double y2; assert(gw); assert(gw->bw); for (z = window_list; z && z != gw; z = z->next) continue; assert(z); assert(GTK_WIDGET(gw->layout) == widget); current_widget = (GtkWidget *)gw->layout; current_cr = cr; cairo_clip_extents(cr, &x1, &y1, &x2, &y2); clip.x0 = x1; clip.y0 = y1; clip.x1 = x2; clip.y1 = y2; browser_window_redraw(gw->bw, 0, 0, &clip, &ctx); if (gw->careth != 0) { nsgtk_plot_caret(gw->caretx, gw->carety, gw->careth); } current_widget = NULL; return FALSE; } #else static gboolean nsgtk_window_draw_event(GtkWidget *widget, GdkEventExpose *event, gpointer data) { struct gui_window *gw = data; struct gui_window *z; struct rect clip; struct redraw_context ctx = { .interactive = true, .background_images = true, .plot = &nsgtk_plotters }; assert(gw); assert(gw->bw); for (z = window_list; z && z != gw; z = z->next) continue; assert(z); assert(GTK_WIDGET(gw->layout) == widget); current_widget = (GtkWidget *)gw->layout; current_cr = gdk_cairo_create(nsgtk_layout_get_bin_window(gw->layout)); clip.x0 = event->area.x; clip.y0 = event->area.y; clip.x1 = event->area.x + event->area.width; clip.y1 = event->area.y + event->area.height; browser_window_redraw(gw->bw, 0, 0, &clip, &ctx); if (gw->careth != 0) { nsgtk_plot_caret(gw->caretx, gw->carety, gw->careth); } cairo_destroy(current_cr); current_widget = NULL; return FALSE; } #endif static gboolean nsgtk_window_motion_notify_event(GtkWidget *widget, GdkEventMotion *event, gpointer data) { struct gui_window *g = data; bool shift = event->state & GDK_SHIFT_MASK; bool ctrl = event->state & GDK_CONTROL_MASK; if ((abs(event->x - g->last_x) < 5) && (abs(event->y - g->last_y) < 5)) { /* Mouse hasn't moved far enough from press coordinate for this * to be considered a drag. */ return FALSE; } else { /* This is a drag, ensure it's always treated as such, even if * we drag back over the press location */ g->last_x = INT_MIN; g->last_y = INT_MIN; } if (g->mouse.state & BROWSER_MOUSE_PRESS_1) { /* Start button 1 drag */ browser_window_mouse_click(g->bw, BROWSER_MOUSE_DRAG_1, g->mouse.pressed_x, g->mouse.pressed_y); /* Replace PRESS with HOLDING and declare drag in progress */ g->mouse.state ^= (BROWSER_MOUSE_PRESS_1 | BROWSER_MOUSE_HOLDING_1); g->mouse.state |= BROWSER_MOUSE_DRAG_ON; } else if (g->mouse.state & BROWSER_MOUSE_PRESS_2) { /* Start button 2 drag */ browser_window_mouse_click(g->bw, BROWSER_MOUSE_DRAG_2, g->mouse.pressed_x, g->mouse.pressed_y); /* Replace PRESS with HOLDING and declare drag in progress */ g->mouse.state ^= (BROWSER_MOUSE_PRESS_2 | BROWSER_MOUSE_HOLDING_2); g->mouse.state |= BROWSER_MOUSE_DRAG_ON; } /* Handle modifiers being removed */ if (g->mouse.state & BROWSER_MOUSE_MOD_1 && !shift) g->mouse.state ^= BROWSER_MOUSE_MOD_1; if (g->mouse.state & BROWSER_MOUSE_MOD_2 && !ctrl) g->mouse.state ^= BROWSER_MOUSE_MOD_2; browser_window_mouse_track(g->bw, g->mouse.state, event->x / g->bw->scale, event->y / g->bw->scale); return TRUE; } static gboolean nsgtk_window_button_press_event(GtkWidget *widget, GdkEventButton *event, gpointer data) { struct gui_window *g = data; gtk_widget_grab_focus(GTK_WIDGET(g->layout)); gtk_widget_hide(GTK_WIDGET(nsgtk_scaffolding_history_window( g->scaffold)->window)); g->mouse.pressed_x = event->x / g->bw->scale; g->mouse.pressed_y = event->y / g->bw->scale; switch (event->button) { case 1: /* Left button, usually. Pass to core as BUTTON 1. */ g->mouse.state = BROWSER_MOUSE_PRESS_1; break; case 2: /* Middle button, usually. Pass to core as BUTTON 2 */ g->mouse.state = BROWSER_MOUSE_PRESS_2; break; case 3: /* Right button, usually. Action button, context menu. */ browser_window_remove_caret(g->bw); nsgtk_scaffolding_popup_menu(g->scaffold, g->mouse.pressed_x, g->mouse.pressed_y); return TRUE; default: return FALSE; } /* Handle the modifiers too */ if (event->state & GDK_SHIFT_MASK) g->mouse.state |= BROWSER_MOUSE_MOD_1; if (event->state & GDK_CONTROL_MASK) g->mouse.state |= BROWSER_MOUSE_MOD_2; /* Record where we pressed, for use when determining whether to start * a drag in motion notify events. */ g->last_x = event->x; g->last_y = event->y; browser_window_mouse_click(g->bw, g->mouse.state, g->mouse.pressed_x, g->mouse.pressed_y); return TRUE; } static gboolean nsgtk_window_button_release_event(GtkWidget *widget, GdkEventButton *event, gpointer data) { struct gui_window *g = data; bool shift = event->state & GDK_SHIFT_MASK; bool ctrl = event->state & GDK_CONTROL_MASK; /* If the mouse state is PRESS then we are waiting for a release to emit * a click event, otherwise just reset the state to nothing */ if (g->mouse.state & BROWSER_MOUSE_PRESS_1) g->mouse.state ^= (BROWSER_MOUSE_PRESS_1 | BROWSER_MOUSE_CLICK_1); else if (g->mouse.state & BROWSER_MOUSE_PRESS_2) g->mouse.state ^= (BROWSER_MOUSE_PRESS_2 | BROWSER_MOUSE_CLICK_2); /* Handle modifiers being removed */ if (g->mouse.state & BROWSER_MOUSE_MOD_1 && !shift) g->mouse.state ^= BROWSER_MOUSE_MOD_1; if (g->mouse.state & BROWSER_MOUSE_MOD_2 && !ctrl) g->mouse.state ^= BROWSER_MOUSE_MOD_2; if (g->mouse.state & (BROWSER_MOUSE_CLICK_1|BROWSER_MOUSE_CLICK_2)) { browser_window_mouse_click(g->bw, g->mouse.state, event->x / g->bw->scale, event->y / g->bw->scale); } else { browser_window_mouse_track(g->bw, 0, event->x / g->bw->scale, event->y / g->bw->scale); } g->mouse.state = 0; return TRUE; } static gboolean nsgtk_window_scroll_event(GtkWidget *widget, GdkEventScroll *event, gpointer data) { struct gui_window *g = data; double value; GtkAdjustment *vscroll = nsgtk_layout_get_vadjustment(g->layout); GtkAdjustment *hscroll = nsgtk_layout_get_hadjustment(g->layout); GtkAllocation alloc; LOG(("%d", event->direction)); switch (event->direction) { case GDK_SCROLL_LEFT: if (browser_window_scroll_at_point(g->bw, event->x / g->bw->scale, event->y / g->bw->scale, -100, 0) != true) { /* core did not handle event do horizontal scroll */ value = gtk_adjustment_get_value(hscroll) - (nsgtk_adjustment_get_step_increment(hscroll) *2); if (value < nsgtk_adjustment_get_lower(hscroll)) { value = nsgtk_adjustment_get_lower(hscroll); } gtk_adjustment_set_value(hscroll, value); } break; case GDK_SCROLL_UP: if (browser_window_scroll_at_point(g->bw, event->x / g->bw->scale, event->y / g->bw->scale, 0, -100) != true) { /* core did not handle event change vertical * adjustment. */ value = gtk_adjustment_get_value(vscroll) - (nsgtk_adjustment_get_step_increment(vscroll) * 2); if (value < nsgtk_adjustment_get_lower(vscroll)) { value = nsgtk_adjustment_get_lower(vscroll); } gtk_adjustment_set_value(vscroll, value); } break; case GDK_SCROLL_RIGHT: if (browser_window_scroll_at_point(g->bw, event->x / g->bw->scale, event->y / g->bw->scale, 100, 0) != true) { /* core did not handle event change horizontal * adjustment. */ value = gtk_adjustment_get_value(hscroll) + (nsgtk_adjustment_get_step_increment(hscroll) * 2); /* @todo consider gtk_widget_get_allocated_width() */ nsgtk_widget_get_allocation(GTK_WIDGET(g->layout), &alloc); if (value > nsgtk_adjustment_get_upper(hscroll) - alloc.width) { value = nsgtk_adjustment_get_upper(hscroll) - alloc.width; } gtk_adjustment_set_value(hscroll, value); } break; case GDK_SCROLL_DOWN: if (browser_window_scroll_at_point(g->bw, event->x / g->bw->scale, event->y / g->bw->scale, 0, 100) != true) { /* core did not handle event change vertical * adjustment. */ value = gtk_adjustment_get_value(vscroll) + (nsgtk_adjustment_get_step_increment(vscroll) * 2); /* @todo consider gtk_widget_get_allocated_height */ nsgtk_widget_get_allocation(GTK_WIDGET(g->layout), &alloc); if (value > nsgtk_adjustment_get_upper(vscroll) - alloc.height) { value = nsgtk_adjustment_get_upper(vscroll) - alloc.height; } gtk_adjustment_set_value(vscroll, value); } break; default: break; } return TRUE; } static gboolean nsgtk_window_keypress_event(GtkWidget *widget, GdkEventKey *event, gpointer data) { struct gui_window *g = data; uint32_t nskey = gtk_gui_gdkkey_to_nskey(event); if (browser_window_key_press(g->bw, nskey)) return TRUE; if ((event->state & 0x7) != 0) return TRUE; double value; GtkAdjustment *vscroll = nsgtk_layout_get_vadjustment(g->layout); GtkAdjustment *hscroll = nsgtk_layout_get_hadjustment(g->layout); GtkAllocation alloc; /* @todo consider gtk_widget_get_allocated_width() */ nsgtk_widget_get_allocation(GTK_WIDGET(g->layout), &alloc); switch (event->keyval) { case GDK_KEY(Home): case GDK_KEY(KP_Home): value = nsgtk_adjustment_get_lower(vscroll); gtk_adjustment_set_value(vscroll, value); break; case GDK_KEY(End): case GDK_KEY(KP_End): value = nsgtk_adjustment_get_upper(vscroll) - alloc.height; if (value < nsgtk_adjustment_get_lower(vscroll)) value = nsgtk_adjustment_get_lower(vscroll); gtk_adjustment_set_value(vscroll, value); break; case GDK_KEY(Left): case GDK_KEY(KP_Left): value = gtk_adjustment_get_value(hscroll) - nsgtk_adjustment_get_step_increment(hscroll); if (value < nsgtk_adjustment_get_lower(hscroll)) value = nsgtk_adjustment_get_lower(hscroll); gtk_adjustment_set_value(hscroll, value); break; case GDK_KEY(Up): case GDK_KEY(KP_Up): value = gtk_adjustment_get_value(vscroll) - nsgtk_adjustment_get_step_increment(vscroll); if (value < nsgtk_adjustment_get_lower(vscroll)) value = nsgtk_adjustment_get_lower(vscroll); gtk_adjustment_set_value(vscroll, value); break; case GDK_KEY(Right): case GDK_KEY(KP_Right): value = gtk_adjustment_get_value(hscroll) + nsgtk_adjustment_get_step_increment(hscroll); if (value > nsgtk_adjustment_get_upper(hscroll) - alloc.width) value = nsgtk_adjustment_get_upper(hscroll) - alloc.width; gtk_adjustment_set_value(hscroll, value); break; case GDK_KEY(Down): case GDK_KEY(KP_Down): value = gtk_adjustment_get_value(vscroll) + nsgtk_adjustment_get_step_increment(vscroll); if (value > nsgtk_adjustment_get_upper(vscroll) - alloc.height) value = nsgtk_adjustment_get_upper(vscroll) - alloc.height; gtk_adjustment_set_value(vscroll, value); break; case GDK_KEY(Page_Up): case GDK_KEY(KP_Page_Up): value = gtk_adjustment_get_value(vscroll) - nsgtk_adjustment_get_page_increment(vscroll); if (value < nsgtk_adjustment_get_lower(vscroll)) value = nsgtk_adjustment_get_lower(vscroll); gtk_adjustment_set_value(vscroll, value); break; case GDK_KEY(Page_Down): case GDK_KEY(KP_Page_Down): value = gtk_adjustment_get_value(vscroll) + nsgtk_adjustment_get_page_increment(vscroll); if (value > nsgtk_adjustment_get_upper(vscroll) - alloc.height) value = nsgtk_adjustment_get_upper(vscroll) - alloc.height; gtk_adjustment_set_value(vscroll, value); break; default: break; } return TRUE; } static gboolean nsgtk_window_size_allocate_event(GtkWidget *widget, GtkAllocation *allocation, gpointer data) { struct gui_window *g = data; g->bw->reformat_pending = true; browser_reformat_pending = true; if (g->paned != NULL) { /* Set status bar / scroll bar proportion according to * option_toolbar_status_width */ /* TODO: Probably want to detect when the user adjusts the * status bar width, remember that proportion for the * window, and use that here. */ gtk_paned_set_position(g->paned, (nsoption_int(toolbar_status_width) * allocation->width) / 10000); } return TRUE; } /* Core interface docuemnted in desktop/gui.h to create a gui_window */ struct gui_window *gui_create_browser_window(struct browser_window *bw, struct browser_window *clone, bool new_tab) { struct gui_window *g; /**< what we're creating to return */ g = calloc(1, sizeof(*g)); if (!g) { warn_user("NoMemory", 0); return 0; } LOG(("Creating gui window %p for browser window %p", g, bw)); g->bw = bw; g->paned = NULL; g->mouse.state = 0; g->current_pointer = GUI_POINTER_DEFAULT; if (clone != NULL) { bw->scale = clone->scale; } else { bw->scale = (float) nsoption_int(scale) / 100.0; } g->careth = 0; if (new_tab) { assert(clone != NULL); g->scaffold = clone->window->scaffold; } else { /* Now construct and attach a scaffold */ g->scaffold = nsgtk_new_scaffolding(g); } if (g->scaffold == NULL) { warn_user("NoMemory", 0); free(g); return NULL; } /* Construct our primary elements */ /* top-level document (not a frame) => create a new tab */ GError* error = NULL; GtkBuilder* xml = gtk_builder_new(); if (!gtk_builder_add_from_file(xml, glade_file_location->tabcontents, &error)) { g_warning ("Couldn't load builder file: %s", error->message); g_error_free(error); return 0; } g->layout = GTK_LAYOUT(gtk_builder_get_object(xml, "layout")); g->status_bar = GTK_LABEL(gtk_builder_get_object(xml, "status_bar")); g->paned = GTK_PANED(gtk_builder_get_object(xml, "hpaned1")); /* connect the scrollbars to the layout widget */ nsgtk_layout_set_hadjustment(g->layout, gtk_range_get_adjustment(GTK_RANGE( gtk_builder_get_object(xml, "hscrollbar")))); nsgtk_layout_set_vadjustment(g->layout, gtk_range_get_adjustment(GTK_RANGE( gtk_builder_get_object(xml, "vscrollbar")))); /* add the tab to the scaffold */ bool tempback = true; switch (temp_open_background) { case -1: tempback = !(nsoption_bool(focus_new)); break; case 0: tempback = false; break; case 1: tempback = true; break; } GtkWidget *tab_contents = GTK_WIDGET(gtk_builder_get_object(xml, "tabContents")); g_object_set_data(G_OBJECT(tab_contents), "gui_window", g); nsgtk_tab_add(g, tab_contents, tempback); g_object_unref(xml); /* Attach ourselves to the list (push_top) */ if (window_list) window_list->prev = g; g->next = window_list; g->prev = NULL; window_list = g; /* set the events we're interested in receiving from the browser's * drawing area. */ gtk_widget_add_events(GTK_WIDGET(g->layout), GDK_EXPOSURE_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK | GDK_SCROLL_MASK); nsgtk_widget_set_can_focus(GTK_WIDGET(g->layout), TRUE); /* set the default background colour of the drawing area to white. */ nsgtk_widget_override_background_color(GTK_WIDGET(g->layout), GTK_STATE_NORMAL, 0, 0xffff, 0xffff, 0xffff); nsgtk_connect_draw_event(GTK_WIDGET(g->layout), G_CALLBACK(nsgtk_window_draw_event), g); #define CONNECT(obj, sig, callback, ptr) \ g_signal_connect(G_OBJECT(obj), (sig), G_CALLBACK(callback), (ptr)) CONNECT(g->layout, "motion_notify_event", nsgtk_window_motion_notify_event, g); g->signalhandler[NSGTK_WINDOW_SIGNAL_CLICK] = CONNECT(g->layout, "button_press_event", nsgtk_window_button_press_event, g); CONNECT(g->layout, "button_release_event", nsgtk_window_button_release_event, g); CONNECT(g->layout, "key_press_event", nsgtk_window_keypress_event, g); CONNECT(g->layout, "size_allocate", nsgtk_window_size_allocate_event, g); CONNECT(g->layout, "scroll_event", nsgtk_window_scroll_event, g); return g; } void nsgtk_reflow_all_windows(void) { for (struct gui_window *g = window_list; g; g = g->next) { nsgtk_tab_options_changed( nsgtk_scaffolding_notebook(g->scaffold)); g->bw->reformat_pending = true; } browser_reformat_pending = true; } /** * Process pending reformats */ void nsgtk_window_process_reformats(void) { struct gui_window *g; GtkAllocation alloc; browser_reformat_pending = false; for (g = window_list; g; g = g->next) { if (!g->bw->reformat_pending) continue; g->bw->reformat_pending = false; /* @todo consider gtk_widget_get_allocated_width() */ nsgtk_widget_get_allocation(GTK_WIDGET(g->layout), &alloc); browser_window_reformat(g->bw, false, alloc.width, alloc.height); } } void nsgtk_window_destroy_browser(struct gui_window *g) { browser_window_destroy(g->bw); } void gui_window_destroy(struct gui_window *g) { if (g->prev) g->prev->next = g->next; else window_list = g->next; if (g->next) g->next->prev = g->prev; LOG(("Destroying gui_window %p", g)); assert(g != NULL); assert(g->bw != NULL); LOG((" Scaffolding: %p", g->scaffold)); LOG((" Window name: %s", g->bw->name)); /* tab => remove tab */ gtk_widget_destroy(gtk_widget_get_parent(GTK_WIDGET(g->layout))); } /** * set favicon */ void gui_window_set_icon(struct gui_window *gw, hlcache_handle *icon) { struct bitmap *icon_bitmap = NULL; /* free any existing icon */ if (gw->icon != NULL) { g_object_unref(gw->icon); gw->icon = NULL; } if (icon != NULL) { icon_bitmap = content_get_bitmap(icon); if (icon_bitmap != NULL) { LOG(("Using %p bitmap", icon_bitmap)); gw->icon = nsgdk_pixbuf_get_from_surface(icon_bitmap->surface, 16, 16); } } if (gw->icon == NULL) { LOG(("Using default favicon")); g_object_ref(favicon_pixbuf); gw->icon = favicon_pixbuf; } nsgtk_scaffolding_set_icon(gw); } static void nsgtk_redraw_caret(struct gui_window *g) { int sx, sy; if (g->careth == 0) return; gui_window_get_scroll(g, &sx, &sy); gtk_widget_queue_draw_area(GTK_WIDGET(g->layout), g->caretx - sx, g->carety - sy, 1, g->careth + 1); }
void shoes_native_slot_scroll_top(SHOES_SLOT_OS *slot) { if (slot->vscroll) gtk_range_set_value(GTK_RANGE(slot->vscroll), slot->scrolly); }
static void cc_ua_panel_init_keyboard (CcUaPanel *self) { CcUaPanelPrivate *priv = self->priv; GtkWidget *list; GtkWidget *w; GtkWidget *sw; GtkWidget *dialog; list = WID ("list_typing"); add_section (list, self); add_separators (GTK_LIST_BOX (list)); g_signal_connect_swapped (list, "row-activated", G_CALLBACK (activate_row), self); /* on-screen keyboard */ sw = WID ("screen_keyboard_switch"); g_settings_bind (priv->application_settings, KEY_SCREEN_KEYBOARD_ENABLED, sw, "active", G_SETTINGS_BIND_DEFAULT); /* accessx */ g_signal_connect (priv->kb_settings, "changed", G_CALLBACK (update_accessx_label), self); update_accessx_label (priv->kb_settings, NULL, self); /* enable shortcuts */ sw = WID ("typing_keyboard_toggle_switch"); g_settings_bind (priv->kb_settings, KEY_KEYBOARD_TOGGLE, sw, "active", G_SETTINGS_BIND_DEFAULT); /* sticky keys */ sw = WID ("typing_stickykeys_switch"); g_settings_bind (priv->kb_settings, KEY_STICKYKEYS_ENABLED, sw, "active", G_SETTINGS_BIND_DEFAULT); w = WID ("typing_stickykeys_disable_two_keys_check"); g_settings_bind (priv->kb_settings, KEY_STICKYKEYS_TWO_KEY_OFF, w, "active", G_SETTINGS_BIND_NO_SENSITIVITY); g_object_bind_property (sw, "active", w, "sensitive", G_BINDING_SYNC_CREATE); w = WID ("typing_stickykeys_beep_modifier_check"); g_settings_bind (priv->kb_settings, KEY_STICKYKEYS_MODIFIER_BEEP, w, "active", G_SETTINGS_BIND_NO_SENSITIVITY); g_object_bind_property (sw, "active", w, "sensitive", G_BINDING_SYNC_CREATE); /* slow keys */ sw = WID ("typing_slowkeys_switch"); g_settings_bind (priv->kb_settings, KEY_SLOWKEYS_ENABLED, sw, "active", G_SETTINGS_BIND_DEFAULT); w = WID ("typing_slowkeys_delay_scale"); g_settings_bind (priv->kb_settings, KEY_SLOWKEYS_DELAY, gtk_range_get_adjustment (GTK_RANGE (w)), "value", G_SETTINGS_BIND_DEFAULT); w = WID ("typing_slowkeys_delay_box"); g_object_bind_property (sw, "active", w, "sensitive", G_BINDING_SYNC_CREATE); w = WID ("typing_slowkeys_beep_pressed_check"); g_settings_bind (priv->kb_settings, KEY_SLOWKEYS_BEEP_PRESS, w, "active", G_SETTINGS_BIND_DEFAULT); g_object_bind_property (sw, "active", w, "sensitive", G_BINDING_SYNC_CREATE); w = WID ("typing_slowkeys_beep_accepted_check"); g_settings_bind (priv->kb_settings, KEY_SLOWKEYS_BEEP_ACCEPT, w, "active", G_SETTINGS_BIND_DEFAULT); g_object_bind_property (sw, "active", w, "sensitive", G_BINDING_SYNC_CREATE); w = WID ("typing_slowkeys_beep_rejected_check"); g_settings_bind (priv->kb_settings, KEY_SLOWKEYS_BEEP_REJECT, w, "active", G_SETTINGS_BIND_DEFAULT); g_object_bind_property (sw, "active", w, "sensitive", G_BINDING_SYNC_CREATE); /* bounce keys */ sw = WID ("typing_bouncekeys_switch"); g_settings_bind (priv->kb_settings, KEY_BOUNCEKEYS_ENABLED, sw, "active", G_SETTINGS_BIND_DEFAULT); w = WID ("typing_bouncekeys_delay_scale"); g_settings_bind (priv->kb_settings, KEY_BOUNCEKEYS_DELAY, gtk_range_get_adjustment (GTK_RANGE (w)), "value", G_SETTINGS_BIND_DEFAULT); w = WID ("typing_bouncekeys_delay_box"); g_object_bind_property (sw, "active", w, "sensitive", G_BINDING_SYNC_CREATE); w = WID ("typing_bouncekeys_beep_rejected_check"); g_settings_bind (priv->kb_settings, KEY_BOUNCEKEYS_BEEP_REJECT, w, "active", G_SETTINGS_BIND_NO_SENSITIVITY); g_object_bind_property (sw, "active", w, "sensitive", G_BINDING_SYNC_CREATE); dialog = WID ("typing_dialog"); g_object_set_data (G_OBJECT (WID ("row_accessx")), "dialog", dialog); g_signal_connect_swapped (WID ("typing_done"), "clicked", G_CALLBACK (gtk_widget_hide), dialog); g_signal_connect (dialog, "delete-event", G_CALLBACK (gtk_widget_hide_on_delete), NULL); g_signal_connect (WID ("heading_accessx"), "mnemonic-activate", G_CALLBACK (mnemonic_activate), self); }
static void cc_ua_panel_init_mouse (CcUaPanel *self) { CcUaPanelPrivate *priv = self->priv; GtkWidget *list; GtkWidget *dialog; GtkWidget *sw; GtkWidget *w; list = WID ("list_pointing"); add_section (list, self); add_separators (GTK_LIST_BOX (list)); g_signal_connect_swapped (list, "row-activated", G_CALLBACK (activate_row), self); g_settings_bind (priv->kb_settings, KEY_MOUSEKEYS_ENABLED, WID ("mouse_keys_switch"), "active", G_SETTINGS_BIND_DEFAULT); g_signal_connect (priv->mouse_settings, "changed", G_CALLBACK (update_click_assist_label), self); update_click_assist_label (priv->mouse_settings, NULL, self); /* simulated secondary click */ sw = WID ("pointing_secondary_click_switch"); g_settings_bind (priv->mouse_settings, KEY_SECONDARY_CLICK_ENABLED, sw, "active", G_SETTINGS_BIND_DEFAULT); w = WID ("pointing_secondary_click_delay_scale"); g_settings_bind (priv->mouse_settings, KEY_SECONDARY_CLICK_TIME, gtk_range_get_adjustment (GTK_RANGE (w)), "value", G_SETTINGS_BIND_DEFAULT); w = WID ("pointing_secondary_click_delay_box"); g_object_bind_property (sw, "active", w, "sensitive", G_BINDING_SYNC_CREATE); /* dwell click */ sw = WID ("pointing_hover_click_switch"); g_settings_bind (priv->mouse_settings, KEY_DWELL_CLICK_ENABLED, sw, "active", G_SETTINGS_BIND_DEFAULT); w = WID ("pointing_dwell_delay_scale"); g_settings_bind (priv->mouse_settings, KEY_DWELL_TIME, gtk_range_get_adjustment (GTK_RANGE (w)), "value", G_SETTINGS_BIND_DEFAULT); w = WID ("pointing_dwell_delay_box"); g_object_bind_property (sw, "active", w, "sensitive", G_BINDING_SYNC_CREATE); w = WID ("pointing_dwell_threshold_scale"); g_settings_bind (priv->mouse_settings, KEY_DWELL_THRESHOLD, gtk_range_get_adjustment (GTK_RANGE (w)), "value", G_SETTINGS_BIND_DEFAULT); w = WID ("pointing_dwell_threshold_box"); g_object_bind_property (sw, "active", w, "sensitive", G_BINDING_SYNC_CREATE); dialog = WID ("pointing_dialog"); g_object_set_data (G_OBJECT (WID ("row_click_assist")), "dialog", dialog); g_signal_connect_swapped (WID ("pointing_done"), "clicked", G_CALLBACK (gtk_widget_hide), dialog); g_signal_connect (dialog, "delete-event", G_CALLBACK (gtk_widget_hide_on_delete), NULL); g_signal_connect (WID ("heading_click_assist"), "mnemonic-activate", G_CALLBACK (mnemonic_activate), self); }
void SettingsDialog::load() { XOJ_CHECK_TYPE(SettingsDialog); loadCheckbox("cbSettingXinput", settings->isXinputEnabled()); loadCheckbox("cbIgnorCoreEvents", settings->isIgnoreCoreEvents()); loadCheckbox("cbSettingPresureSensitivity", settings->isPresureSensitivity()); loadCheckbox("cbShowSidebarRight", settings->isSidebarOnRight()); loadCheckbox("cbShowScrollbarLeft", settings->isScrollbarOnLeft()); loadCheckbox("cbAutoloadXoj", settings->isAutloadPdfXoj()); loadCheckbox("cbAutosave", settings->isAutosaveEnabled()); loadCheckbox("cbSettingScrollOutside", settings->isAllowScrollOutsideThePage()); loadCheckbox("cbBigCursor", settings->isShowBigCursor()); GtkWidget * txtDefaultSaveName = get("txtDefaultSaveName"); const char * txt = settings->getDefaultSaveName().c_str(); if (txt == NULL) { txt = ""; } gtk_entry_set_text(GTK_ENTRY(txtDefaultSaveName), txt); GtkWidget * spAutosaveTimeout = get("spAutosaveTimeout"); gtk_spin_button_set_value(GTK_SPIN_BUTTON(spAutosaveTimeout), settings->getAutosaveTimeout()); GtkWidget * slider = get("zoomCallibSlider"); this->setDpi(settings->getDisplayDpi()); gtk_range_set_value(GTK_RANGE(slider), dpi); GtkWidget * colorBorder = get("colorBorder"); GdkColor color = Util::intToGdkColor(settings->getSelectionColor()); gtk_color_button_set_color(GTK_COLOR_BUTTON(colorBorder), &color); bool hideFullscreenMenubar = false; bool hideFullscreenSidebar = false; bool hidePresentationMenubar = false; bool hidePresentationSidebar = false; String hidden = settings->getFullscreenHideElements(); const char * element; StringTokenizer tokenF(hidden, ','); element = tokenF.next(); while (element) { if (!strcmp("mainMenubar", element)) { hideFullscreenMenubar = true; } else if (!strcmp("sidebarContents", element)) { hideFullscreenSidebar = true; } element = tokenF.next(); } hidden = settings->getPresentationHideElements(); StringTokenizer token(hidden, ','); element = token.next(); while (element) { if (!strcmp("mainMenubar", element)) { hidePresentationMenubar = true; } else if (!strcmp("sidebarContents", element)) { hidePresentationSidebar = true; } element = token.next(); } loadCheckbox("cbHideFullscreenMenubar", hideFullscreenMenubar); loadCheckbox("cbHideFullscreenSidebar", hideFullscreenSidebar); loadCheckbox("cbHidePresentationMenubar", hidePresentationMenubar); loadCheckbox("cbHidePresentationSidebar", hidePresentationSidebar); toolboxToggled(); }
static void eog_preferences_dialog_init (EogPreferencesDialog *pref_dlg) { EogPreferencesDialogPrivate *priv; GtkAdjustment *scale_adjustment; pref_dlg->priv = eog_preferences_dialog_get_instance_private (pref_dlg); priv = pref_dlg->priv; gtk_widget_init_template (GTK_WIDGET (pref_dlg)); priv->view_settings = g_settings_new (EOG_CONF_VIEW); priv->fullscreen_settings = g_settings_new (EOG_CONF_FULLSCREEN); g_signal_connect (G_OBJECT (pref_dlg), "response", G_CALLBACK (eog_preferences_response_cb), pref_dlg); g_settings_bind (priv->view_settings, EOG_CONF_VIEW_INTERPOLATE, priv->interpolate_check, "active", G_SETTINGS_BIND_DEFAULT); g_settings_bind (priv->view_settings, EOG_CONF_VIEW_EXTRAPOLATE, priv->extrapolate_check, "active", G_SETTINGS_BIND_DEFAULT); g_settings_bind (priv->view_settings, EOG_CONF_VIEW_AUTOROTATE, priv->autorotate_check, "active", G_SETTINGS_BIND_DEFAULT); g_settings_bind (priv->view_settings, EOG_CONF_VIEW_USE_BG_COLOR, priv->bg_color_check, "active", G_SETTINGS_BIND_DEFAULT); g_settings_bind_with_mapping (priv->view_settings, EOG_CONF_VIEW_BACKGROUND_COLOR, priv->bg_color_button, "rgba", G_SETTINGS_BIND_DEFAULT, pd_string_to_rgba_mapping, pd_rgba_to_string_mapping, NULL, NULL); g_object_set_data (G_OBJECT (priv->color_radio), GCONF_OBJECT_VALUE, GINT_TO_POINTER (EOG_TRANSP_COLOR)); g_signal_connect (G_OBJECT (priv->color_radio), "toggled", G_CALLBACK (pd_transp_radio_toggle_cb), priv->view_settings); g_object_set_data (G_OBJECT (priv->checkpattern_radio), GCONF_OBJECT_VALUE, GINT_TO_POINTER (EOG_TRANSP_CHECKED)); g_signal_connect (G_OBJECT (priv->checkpattern_radio), "toggled", G_CALLBACK (pd_transp_radio_toggle_cb), priv->view_settings); g_object_set_data (G_OBJECT (priv->background_radio), GCONF_OBJECT_VALUE, GINT_TO_POINTER (EOG_TRANSP_BACKGROUND)); g_signal_connect (G_OBJECT (priv->background_radio), "toggled", G_CALLBACK (pd_transp_radio_toggle_cb), priv->view_settings); g_signal_connect (G_OBJECT (priv->seconds_scale), "format-value", G_CALLBACK (pd_seconds_scale_format_value_cb), NULL); switch (g_settings_get_enum (priv->view_settings, EOG_CONF_VIEW_TRANSPARENCY)) { case EOG_TRANSP_COLOR: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->color_radio), TRUE); break; case EOG_TRANSP_CHECKED: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->checkpattern_radio), TRUE); break; default: // Log a warning and use EOG_TRANSP_BACKGROUND as fallback g_warn_if_reached(); case EOG_TRANSP_BACKGROUND: gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->background_radio), TRUE); break; } g_settings_bind_with_mapping (priv->view_settings, EOG_CONF_VIEW_TRANS_COLOR, priv->transp_color_button, "rgba", G_SETTINGS_BIND_DEFAULT, pd_string_to_rgba_mapping, pd_rgba_to_string_mapping, NULL, NULL); g_settings_bind (priv->fullscreen_settings, EOG_CONF_FULLSCREEN_UPSCALE, priv->upscale_check, "active", G_SETTINGS_BIND_DEFAULT); g_settings_bind (priv->fullscreen_settings, EOG_CONF_FULLSCREEN_LOOP, priv->loop_check, "active", G_SETTINGS_BIND_DEFAULT); scale_adjustment = gtk_range_get_adjustment (GTK_RANGE (priv->seconds_scale)); g_settings_bind (priv->fullscreen_settings, EOG_CONF_FULLSCREEN_SECONDS, scale_adjustment, "value", G_SETTINGS_BIND_DEFAULT); gtk_widget_show_all (priv->plugin_manager); }
static void *encode_thr_fn(void *data) { ENCODE_CALLBACK_PARAM_T *param = (ENCODE_CALLBACK_PARAM_T *) data; API_VENC_CHN_E eCh = param->eCh; char *str_profile = (tApiInitParam[eCh].eProfile == API_VENC_HEVC_MAIN_PROFILE) ? "Main" : "Main10"; LOG("%p Channel: %d\n", param, eCh); LOG("Profile: %s\n", str_profile); char *str_level; struct timeval tv1, tv2, res; switch (tApiInitParam[eCh].eLevel) { case API_VENC_HEVC_LEVEL_40: { str_level = "L4.0"; break; } case API_VENC_HEVC_LEVEL_41: { str_level = "L4.1"; break; } case API_VENC_HEVC_LEVEL_50: { str_level = "L5.0"; break; } case API_VENC_HEVC_LEVEL_51: { str_level = "L5.1"; break; } default: { break; } } LOG("Level: %s\n", str_level); char *str_tier = (tApiInitParam[eCh].eTier == API_VENC_HEVC_MAIN_TIER) ? "Main Tier" : "High Tier"; LOG("Tier: %s\n", str_tier); char *str_res = "Unknown"; switch (tApiInitParam[eCh].eResolution) { case API_VENC_RESOLUTION_4096x2160: { str_res = RESOLUTION_DCI_4K_TEXT; tApiInitParam[eCh].tCrop.u32CropLeft = 0; tApiInitParam[eCh].tCrop.u32CropLeft = 0; tApiInitParam[eCh].tCrop.u32CropTop = 0; tApiInitParam[eCh].tCrop.u32CropBottom = 0; break; } case API_VENC_RESOLUTION_3840x2160: { str_res = RESOLUTION_4K_TEXT; tApiInitParam[eCh].tCrop.u32CropLeft = 0; tApiInitParam[eCh].tCrop.u32CropLeft = 0; tApiInitParam[eCh].tCrop.u32CropTop = 0; tApiInitParam[eCh].tCrop.u32CropBottom = 0; break; } case API_VENC_RESOLUTION_1920x1080: { str_res = RESOLUTION_2K_TEXT; tApiInitParam[eCh].tCrop.u32CropLeft = 0; tApiInitParam[eCh].tCrop.u32CropLeft = 0; tApiInitParam[eCh].tCrop.u32CropTop = 0; tApiInitParam[eCh].tCrop.u32CropBottom = 8; break; } case API_VENC_RESOLUTION_1280x720: { str_res = RESOLUTION_HD_TEXT; tApiInitParam[eCh].tCrop.u32CropLeft = 0; tApiInitParam[eCh].tCrop.u32CropLeft = 0; tApiInitParam[eCh].tCrop.u32CropTop = 0; tApiInitParam[eCh].tCrop.u32CropBottom = 0; break; } case API_VENC_RESOLUTION_720x576: { str_res = RESOLUTION_SD_576_TEXT; tApiInitParam[eCh].eAspectRatioIdc = API_VENC_HEVC_ASPECT_RATIO_IDC_4; tApiInitParam[eCh].tCrop.u32CropLeft = 0; tApiInitParam[eCh].tCrop.u32CropLeft = 0; tApiInitParam[eCh].tCrop.u32CropTop = 0; tApiInitParam[eCh].tCrop.u32CropBottom = 0; break; } case API_VENC_RESOLUTION_720x480: { str_res = RESOLUTION_SD_480_TEXT; tApiInitParam[eCh].eAspectRatioIdc = API_VENC_HEVC_ASPECT_RATIO_IDC_5; tApiInitParam[eCh].tCrop.u32CropLeft = 0; tApiInitParam[eCh].tCrop.u32CropLeft = 0; tApiInitParam[eCh].tCrop.u32CropTop = 0; tApiInitParam[eCh].tCrop.u32CropBottom = 0; break; } default: { break; } } LOG("Resolution: %s\n", str_res); char *str_framerate = "Unknown"; switch (tApiInitParam[eCh].eTargetFrameRate) { case API_VENC_FPS_24: { str_framerate = "24p"; break; } case API_VENC_FPS_25: { str_framerate = "25p"; break; } case API_VENC_FPS_29_97: { str_framerate = "29.97p"; break; } case API_VENC_FPS_30: { str_framerate = "30p"; break; } case API_VENC_FPS_50: { str_framerate = "50p"; break; } case API_VENC_FPS_59_94: { str_framerate = "59.94p"; break; } case API_VENC_FPS_60: { str_framerate = "60p"; break; } default: { break; } } LOG("Framerate: %s\n", str_framerate); guint bitrate_val; bitrate_val = gtk_range_get_value(GTK_RANGE(Bitrate[eCh])); LOG("Bitrate %d kbps\n", bitrate_val); tApiInitParam[eCh].u32Bitrate = bitrate_val; char *str_bitdepth = "Unknown"; switch (tApiInitParam[eCh].eBitDepth) { case API_VENC_BIT_DEPTH_8: { str_bitdepth = "8"; break; } case API_VENC_BIT_DEPTH_10: { str_bitdepth = "10"; break; } default: { break; } } LOG("bit depth: %s\n", str_bitdepth); char *str_chroma = (tApiInitParam[eCh].eChromaFmt == API_VENC_CHROMA_FORMAT_420) ? "420" : "422"; LOG("Chroma: %s\n", str_chroma); { GSList *list; GtkToggleButton *button = NULL; API_VENC_IMG_T *pImg = &img[eCh]; list = gtk_radio_button_get_group(GTK_RADIO_BUTTON(PixFmtIntRadioButton[eCh])); while (list) // As long as we didn't reach the end of the group. { button = list->data; // Get one of the buttons in the group. list = list->next; // Next time we're going to check this one. if (gtk_toggle_button_get_active(button)) { break; } } const gchar *val = gtk_button_get_label(GTK_BUTTON(button)); if (strcmp(val, PIXEL_FMT_INTERLEAVE_TEXT) == 0) { switch (tApiInitParam[eCh].eChromaFmt) { case API_VENC_CHROMA_FORMAT_422: { pImg->eFormat = API_VENC_IMAGE_FORMAT_NV16; break; } case API_VENC_CHROMA_FORMAT_420: default: { pImg->eFormat = API_VENC_IMAGE_FORMAT_NV12; break; } } } else if (strcmp(val, PIXEL_FMT_PLANAR_TEXT) == 0) { pImg->eFormat = API_VENC_IMAGE_FORMAT_YUV420; } LOG("%s: %s selected\n", __FUNCTION__, val); } char *str_gop = "Unknown"; switch (tApiInitParam[eCh].eGopType) { case API_VENC_GOP_I: { str_gop = "I"; break; } case API_VENC_GOP_IP: { str_gop = "IP"; break; } case API_VENC_GOP_IB: { str_gop = "IB"; break; } case API_VENC_GOP_IPB: { str_gop = "IPB"; break; } default: { break; } } LOG("GOP: %s\n", str_gop); if (tApiInitParam[eCh].eGopType != API_VENC_GOP_I) { tApiInitParam[eCh].eGopSize = atoi(gtk_entry_get_text(GTK_ENTRY(GopSizeEntry[eCh]))); } LOG("GOP size=%d\n", tApiInitParam[eCh].eGopSize); if (tApiInitParam[eCh].eGopType != API_VENC_GOP_I) { tApiInitParam[eCh].eIDRFrameNum = atoi(gtk_entry_get_text(GTK_ENTRY(IdrIntervalEntry[eCh]))); } LOG("IDR interval=%d\n", tApiInitParam[eCh].eIDRFrameNum); if ((tApiInitParam[eCh].eGopType == API_VENC_GOP_IB) || (tApiInitParam[eCh].eGopType == API_VENC_GOP_IPB)) { guint refnum; refnum = gtk_range_get_value(GTK_RANGE(BNumScale[eCh])); tApiInitParam[eCh].eBFrameNum = (API_VENC_B_FRAME_NUM_E) refnum; LOG("B ref#=%u\n", refnum); } API_VENC_BOARD_E eBoard = API_VENC_BOARD_1; eCh = param->eCh; gettimeofday(&tv1, NULL); if (Api_VENC_Init(eBoard, eCh, &tApiInitParam[eCh])) { sprintf(err_msg, "%s line %d failed!", __FILE__, __LINE__); goto callback_encode_ret; } LOG("HVC_ENC_Init success!\n"); tPopEsArgs[eBoard][eCh].board_num = eBoard; tPopEsArgs[eBoard][eCh].channel = eCh; if (Api_VENC_RegisterCallback ( eBoard, eCh, ui_process_coded_frame, (void *) &tPopEsArgs[eBoard][eCh] )) { sprintf(err_msg, "%s line %d failed!", __FILE__, __LINE__); goto callback_encode_ret; } if (Api_VENC_Start(eBoard, eCh)) { sprintf(err_msg, "%s line %d failed!", __FILE__, __LINE__); goto callback_encode_ret; } LOG("HVC_ENC_Start success!\n"); char es_file_name[FILENAME_MAX]; char timestamp[15]; make_timestamp(timestamp, sizeof(timestamp)); make_output_file_name(timestamp, es_file_name, FILENAME_MAX, FilenameRawYUV[eCh]); fd_r[eCh] = open(FilenameRawYUV[eCh], O_RDONLY); fd_w[eCh] = open(es_file_name, O_WRONLY | O_CREAT, S_IRWXU); // update status bar char msg[256]; sprintf(msg, "Output: %s", es_file_name); context_id = gtk_statusbar_push(GTK_STATUSBAR(statusbar), context_id, msg); uint8_t *vraw_data_buf_p = NULL; uint32_t frame_sz = 0; struct stat file_stat; int remain_frame = 0; fstat(fd_r[eCh], &file_stat); frame_sz = calculate_vraw_enqueue_data_size(&tApiInitParam[eCh]); remain_frame = ((uint64_t) file_stat.st_size / frame_sz); tPopEsArgs[eBoard][eCh].total_frame = remain_frame; tPopEsArgs[eBoard][eCh].poped_frame = 0; vraw_data_buf_p = malloc(frame_sz); API_VENC_IMG_T *pImg = &img[eCh]; while (remain_frame > 0) { read(fd_r[eCh], vraw_data_buf_p, frame_sz); remain_frame--; pImg->pu8Addr = vraw_data_buf_p; pImg->u32Size = frame_sz; pImg->pts = GET_PTS_IN_MS(eCh, tPopEsArgs[eBoard][eCh].total_frame - remain_frame); pImg->bLastFrame = (remain_frame == 0) ? true : false; if (Api_VENC_PushImage(eBoard, eCh, pImg)) { sprintf(err_msg, "Error: %s PushImage failed!\n", __FILE__); goto callback_encode_ret; } } LOG("Encode done...\n"); // try stop while (Api_VENC_Stop(eBoard, eCh)) { usleep(1); } LOG("\n stop complete!\n"); if (Api_VENC_Exit(eBoard, eCh)) { LOG(err_msg, "%s line %d failed!", __FILE__, __LINE__); goto callback_encode_ret; } LOG("\n Encoder exit!\n"); gettimeofday(&tv2, NULL); timersub(&tv2, &tv1, &res); LOG("%lu sec %lu usec\n", res.tv_sec, res.tv_usec); gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progressbar[eCh]), 0.0); close(fd_w[eCh]); callback_encode_ret: LOG("%s\n", err_msg); }
static void photos_print_setup_size_changed (PhotosPrintSetup *self, GtkWidget *w_size_x, GtkWidget *w_size_y, GtkWidget *w_margin_x_1, GtkWidget *w_margin_x_2, GtkWidget *w_margin_y_1, GtkWidget *w_margin_y_2, gdouble page_size_x, gdouble page_size_y, gint change) { PhotosPrintSetupPrivate *priv = self->priv; GeglRectangle bbox; gdouble margin_x_1, margin_x_2; gdouble margin_y_1, margin_y_2; gdouble orig_size_x = -1, orig_size_y = -1, scale; gdouble size_x, size_y; gdouble factor; size_x = gtk_spin_button_get_value (GTK_SPIN_BUTTON (w_size_x)); margin_x_1 = gtk_spin_button_get_value (GTK_SPIN_BUTTON (w_margin_x_1)); margin_y_1 = gtk_spin_button_get_value (GTK_SPIN_BUTTON (w_margin_y_1)); bbox = gegl_node_get_bounding_box (priv->node); factor = get_scale_to_px_factor (self); switch (change) { case CHANGE_HORIZ: orig_size_x = (gdouble) bbox.width / factor; orig_size_y = (gdouble) bbox.height / factor; break; case CHANGE_VERT: orig_size_y = (gdouble) bbox.width / factor; orig_size_x = (gdouble) bbox.height / factor; break; default: g_assert_not_reached (); break; } scale = CLAMP (size_x / orig_size_x, 0, 1); size_y = scale * orig_size_y; margin_x_2 = page_size_x - margin_x_1 - size_x; margin_y_2 = page_size_y - margin_y_1 - size_y; photos_print_preview_set_scale (PHOTOS_PRINT_PREVIEW (priv->preview), scale); switch (change) { case CHANGE_HORIZ: update_image_pos_ranges (self, page_size_x, page_size_y, size_x, size_y); break; case CHANGE_VERT: update_image_pos_ranges (self, page_size_y, page_size_x, size_y, size_x); break; default: g_assert_not_reached (); break; } gtk_range_set_value (GTK_RANGE (priv->scaling), 100*scale); gtk_spin_button_set_value (GTK_SPIN_BUTTON (w_margin_x_2), margin_x_2); gtk_spin_button_set_value (GTK_SPIN_BUTTON (w_size_y), size_y); gtk_spin_button_set_value (GTK_SPIN_BUTTON (w_margin_y_2), margin_y_2); gtk_combo_box_set_active (GTK_COMBO_BOX (priv->center), CENTER_NONE); }
void wxSlider::GTKSetValue(int value) { GTKDisableEvents(); gtk_range_set_value(GTK_RANGE (m_scale), value); GTKEnableEvents(); }
static void photos_print_setup_init (PhotosPrintSetup *self) { GtkWidget *frame; GtkWidget *grid; GtkWidget *label; GtkWidget *hscale; GtkWidget *combobox; PhotosPrintSetupPrivate *priv; #ifdef HAVE__NL_MEASUREMENT_MEASUREMENT gchar *locale_scale = NULL; #endif self->priv = photos_print_setup_get_instance_private (self); priv = self->priv; gtk_container_set_border_width (GTK_CONTAINER (self), 12); gtk_orientable_set_orientation (GTK_ORIENTABLE (self), GTK_ORIENTATION_VERTICAL); gtk_grid_set_column_spacing (GTK_GRID (self), 18); gtk_grid_set_row_spacing (GTK_GRID (self), 18); grid = gtk_grid_new (); gtk_grid_set_row_spacing (GTK_GRID (grid), 6); gtk_grid_set_column_spacing (GTK_GRID (grid), 12); frame = photos_print_setup_wrap_in_frame (_("Position"), grid); gtk_grid_attach (GTK_GRID (self), frame, 0, 0, 1, 1); priv->left = grid_attach_spin_button_with_label (grid, _("_Left:"), 0, 0); priv->right = grid_attach_spin_button_with_label (grid,_("_Right:"), 0, 1); priv->top = grid_attach_spin_button_with_label (grid, _("_Top:"), 2, 0); priv->bottom = grid_attach_spin_button_with_label (grid, _("_Bottom:"), 2, 1); label = gtk_label_new_with_mnemonic (_("C_enter:")); gtk_label_set_xalign (GTK_LABEL (label), 0.0); combobox = gtk_combo_box_text_new (); gtk_combo_box_text_insert_text (GTK_COMBO_BOX_TEXT (combobox), CENTER_NONE, _("None")); gtk_combo_box_text_insert_text (GTK_COMBO_BOX_TEXT (combobox), CENTER_HORIZONTAL, _("Horizontal")); gtk_combo_box_text_insert_text (GTK_COMBO_BOX_TEXT (combobox), CENTER_VERTICAL, _("Vertical")); gtk_combo_box_text_insert_text (GTK_COMBO_BOX_TEXT (combobox), CENTER_BOTH, _("Both")); gtk_combo_box_set_active (GTK_COMBO_BOX (combobox), CENTER_NONE); /* Attach combobox below right margin spinbutton and span until end */ gtk_grid_attach_next_to (GTK_GRID (grid), combobox, priv->right, GTK_POS_BOTTOM, 3, 1); /* Attach the label to the left of the combobox */ gtk_grid_attach_next_to (GTK_GRID (grid), label, combobox, GTK_POS_LEFT, 1, 1); gtk_label_set_mnemonic_widget (GTK_LABEL (label), combobox); priv->center = combobox; g_signal_connect (G_OBJECT (combobox), "changed", G_CALLBACK (on_center_changed), self); grid = gtk_grid_new (); gtk_grid_set_row_spacing (GTK_GRID (grid), 6); gtk_grid_set_column_spacing (GTK_GRID (grid), 12); frame = photos_print_setup_wrap_in_frame (_("Size"), grid); gtk_grid_attach (GTK_GRID (self), frame, 0, 1, 1, 1); priv->width = grid_attach_spin_button_with_label (grid, _("_Width:"), 0, 0); priv->height = grid_attach_spin_button_with_label (grid, _("_Height:"), 2, 0); label = gtk_label_new_with_mnemonic (_("_Scaling:")); hscale = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 1, 100, 1); gtk_scale_set_value_pos (GTK_SCALE (hscale), GTK_POS_RIGHT); gtk_range_set_value (GTK_RANGE (hscale), 100); gtk_grid_attach_next_to (GTK_GRID (grid), hscale, priv->width, GTK_POS_BOTTOM, 3, 1); gtk_grid_attach_next_to (GTK_GRID (grid), label, hscale, GTK_POS_LEFT, 1, 1); gtk_label_set_mnemonic_widget (GTK_LABEL (label), hscale); priv->scaling = hscale; label = gtk_label_new_with_mnemonic (_("_Unit:")); gtk_label_set_xalign (GTK_LABEL (label), 0.0); combobox = gtk_combo_box_text_new (); gtk_combo_box_text_insert_text (GTK_COMBO_BOX_TEXT (combobox), UNIT_MM, _("Millimeters")); gtk_combo_box_text_insert_text (GTK_COMBO_BOX_TEXT (combobox), UNIT_INCH, _("Inches")); #ifdef HAVE__NL_MEASUREMENT_MEASUREMENT locale_scale = nl_langinfo (_NL_MEASUREMENT_MEASUREMENT); if (locale_scale && locale_scale[0] == 2) { gtk_combo_box_set_active (GTK_COMBO_BOX (combobox), UNIT_INCH); photos_print_setup_set_scale_unit (self, GTK_UNIT_INCH); } else #endif { gtk_combo_box_set_active (GTK_COMBO_BOX (combobox), UNIT_MM); photos_print_setup_set_scale_unit (self, GTK_UNIT_MM); } gtk_grid_attach_next_to (GTK_GRID (grid), combobox, hscale, GTK_POS_BOTTOM, 3, 1); gtk_grid_attach_next_to (GTK_GRID (grid), label, combobox, GTK_POS_LEFT, 1, 1); gtk_label_set_mnemonic_widget (GTK_LABEL (label), combobox); priv->unit = combobox; g_signal_connect (G_OBJECT (combobox), "changed", G_CALLBACK (on_unit_changed), self); priv->preview = photos_print_preview_new (); /* FIXME: This shouldn't be set by hand */ gtk_widget_set_size_request (priv->preview, 250, 250); frame = photos_print_setup_wrap_in_frame (_("Preview"), priv->preview); /* The preview widget needs to span the whole grid height */ gtk_grid_attach (GTK_GRID (self), frame, 1, 0, 1, 2); gtk_widget_show_all (GTK_WIDGET (self)); }
int wxSlider::GetMax() const { return int(gtk_range_get_adjustment (GTK_RANGE (m_scale))->upper); }
/* berechnet die eingestellte Ablaufgeschwindigkeit */ gdouble scale_get_speed(GtkWidget *scale_speed) { return pow(10.0, gtk_range_get_value(GTK_RANGE(scale_speed))); }
void wxSlider::SetLineSize( int lineSize ) { GTKDisableEvents(); gtk_range_set_increments(GTK_RANGE (m_scale), lineSize, GetPageSize()); GTKEnableEvents(); }
uint32_t ADM_flyDialogGtk::sliderGet(void) { ADM_assert(_slider); return (uint32_t)gtk_range_get_value (GTK_RANGE(_slider)); }
int wxSlider::GetLineSize() const { return int(gtk_range_get_adjustment (GTK_RANGE (m_scale))->step_increment); }
/* handles PageUp/Down keys */ static int key_action_scroll_page (GtkWidget * wid, GdkEventKey * evt, char *d1, char *d2, struct session *sess) { int value, end; GtkAdjustment *adj; enum scroll_type { PAGE_TOP, PAGE_BOTTOM, PAGE_UP, PAGE_DOWN, LINE_UP, LINE_DOWN }; int type = PAGE_DOWN; if (d1) { if (!g_ascii_strcasecmp (d1, "top")) type = PAGE_TOP; else if (!g_ascii_strcasecmp (d1, "bottom")) type = PAGE_BOTTOM; else if (!g_ascii_strcasecmp (d1, "up")) type = PAGE_UP; else if (!g_ascii_strcasecmp (d1, "down")) type = PAGE_DOWN; else if (!g_ascii_strcasecmp (d1, "+1")) type = LINE_DOWN; else if (!g_ascii_strcasecmp (d1, "-1")) type = LINE_UP; } if (!sess) return 0; adj = gtk_range_get_adjustment (GTK_RANGE (sess->gui->vscrollbar)); end = gtk_adjustment_get_upper (adj) - gtk_adjustment_get_lower (adj) - gtk_adjustment_get_page_size (adj); switch (type) { case PAGE_TOP: value = 0; break; case PAGE_BOTTOM: value = end; break; case PAGE_UP: value = gtk_adjustment_get_value (adj) - (gtk_adjustment_get_page_size (adj) - 1); break; case PAGE_DOWN: value = gtk_adjustment_get_value (adj) + (gtk_adjustment_get_page_size (adj) - 1); break; case LINE_UP: value = gtk_adjustment_get_value (adj) - 1.0; break; case LINE_DOWN: value = gtk_adjustment_get_value (adj) + 1.0; break; } if (value < 0) value = 0; if (value > end) value = end; gtk_adjustment_set_value (adj, value); return 0; }
GdkWindow *wxSlider::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const { return GTK_RANGE(m_scale)->event_window; }
int main (int argc, char *argv[]) { GstElement *bin; GstElement *decodebin, *decconvert; GstElement *capsfilter, *equalizer, *spectrum, *sinkconvert, *sink; GstCaps *caps; GstBus *bus; GtkWidget *appwindow, *vbox, *hbox, *scale; int i, num_bands = NBANDS; GOptionEntry options[] = { {"bands", 'b', 0, G_OPTION_ARG_INT, &num_bands, "Number of bands", NULL}, {NULL} }; GOptionContext *ctx; GError *err = NULL; ctx = g_option_context_new ("- demo of audio equalizer"); g_option_context_add_main_entries (ctx, options, NULL); g_option_context_add_group (ctx, gst_init_get_option_group ()); g_option_context_add_group (ctx, gtk_get_option_group (TRUE)); if (!g_option_context_parse (ctx, &argc, &argv, &err)) { g_print ("Error initializing: %s\n", err->message); g_option_context_free (ctx); g_clear_error (&err); exit (1); } g_option_context_free (ctx); if (argc < 2) { g_print ("Usage: %s <uri to play>\n", argv[0]); g_print (" For optional arguments: --help\n"); exit (-1); } gst_init (&argc, &argv); gtk_init (&argc, &argv); bin = gst_pipeline_new ("bin"); /* Uri decoding */ decodebin = gst_element_factory_make ("uridecodebin", "decoder"); g_object_set (G_OBJECT (decodebin), "uri", argv[1], NULL); /* Force float32 samples */ decconvert = gst_element_factory_make ("audioconvert", "decconvert"); capsfilter = gst_element_factory_make ("capsfilter", "capsfilter"); caps = gst_caps_new_simple ("audio/x-raw", "format", G_TYPE_STRING, "F32LE", NULL); g_object_set (capsfilter, "caps", caps, NULL); equalizer = gst_element_factory_make ("equalizer-nbands", "equalizer"); g_object_set (G_OBJECT (equalizer), "num-bands", num_bands, NULL); spectrum = gst_element_factory_make ("spectrum", "spectrum"); g_object_set (G_OBJECT (spectrum), "bands", spect_bands, "threshold", -80, "post-messages", TRUE, "interval", 500 * GST_MSECOND, NULL); sinkconvert = gst_element_factory_make ("audioconvert", "sinkconvert"); sink = gst_element_factory_make ("autoaudiosink", "sink"); gst_bin_add_many (GST_BIN (bin), decodebin, decconvert, capsfilter, equalizer, spectrum, sinkconvert, sink, NULL); if (!gst_element_link_many (decconvert, capsfilter, equalizer, spectrum, sinkconvert, sink, NULL)) { fprintf (stderr, "can't link elements\n"); exit (1); } /* Handle dynamic pads */ g_signal_connect (G_OBJECT (decodebin), "pad-added", G_CALLBACK (dynamic_link), gst_element_get_static_pad (decconvert, "sink")); bus = gst_element_get_bus (bin); gst_bus_add_watch (bus, message_handler, NULL); gst_object_unref (bus); appwindow = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (appwindow), "Equalizer Demo"); g_signal_connect (G_OBJECT (appwindow), "destroy", G_CALLBACK (on_window_destroy), NULL); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); drawingarea = gtk_drawing_area_new (); gtk_widget_set_size_request (drawingarea, spect_bands, spect_height); g_signal_connect (G_OBJECT (drawingarea), "configure-event", G_CALLBACK (on_configure_event), (gpointer) spectrum); gtk_box_pack_start (GTK_BOX (vbox), drawingarea, TRUE, TRUE, 0); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 20); for (i = 0; i < num_bands; i++) { GObject *band; gdouble freq; gdouble bw; gdouble gain; gchar *label; GtkWidget *frame, *scales_hbox; band = gst_child_proxy_get_child_by_index (GST_CHILD_PROXY (equalizer), i); g_assert (band != NULL); g_object_get (band, "freq", &freq, NULL); g_object_get (band, "bandwidth", &bw, NULL); g_object_get (band, "gain", &gain, NULL); label = g_strdup_printf ("%d Hz", (int) (freq + 0.5)); frame = gtk_frame_new (label); g_free (label); scales_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); /* Create gain scale */ scale = gtk_scale_new_with_range (GTK_ORIENTATION_VERTICAL, -24.0, 12.0, 0.5); gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE); gtk_scale_set_value_pos (GTK_SCALE (scale), GTK_POS_TOP); gtk_range_set_value (GTK_RANGE (scale), gain); gtk_widget_set_size_request (scale, 35, 150); g_signal_connect (G_OBJECT (scale), "value-changed", G_CALLBACK (on_gain_changed), (gpointer) band); gtk_box_pack_start (GTK_BOX (scales_hbox), scale, FALSE, FALSE, 0); /* Create bandwidth scale */ scale = gtk_scale_new_with_range (GTK_ORIENTATION_VERTICAL, 0.0, 20000.0, 5.0); gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE); gtk_scale_set_value_pos (GTK_SCALE (scale), GTK_POS_TOP); gtk_range_set_value (GTK_RANGE (scale), bw); gtk_widget_set_size_request (scale, 45, 150); g_signal_connect (G_OBJECT (scale), "value-changed", G_CALLBACK (on_bandwidth_changed), (gpointer) band); gtk_box_pack_start (GTK_BOX (scales_hbox), scale, TRUE, TRUE, 0); /* Create frequency scale */ scale = gtk_scale_new_with_range (GTK_ORIENTATION_VERTICAL, 20.0, 20000.0, 5.0); gtk_scale_set_draw_value (GTK_SCALE (scale), TRUE); gtk_scale_set_value_pos (GTK_SCALE (scale), GTK_POS_TOP); gtk_range_set_value (GTK_RANGE (scale), freq); gtk_widget_set_size_request (scale, 45, 150); g_signal_connect (G_OBJECT (scale), "value-changed", G_CALLBACK (on_freq_changed), (gpointer) band); gtk_box_pack_start (GTK_BOX (scales_hbox), scale, TRUE, TRUE, 0); gtk_container_add (GTK_CONTAINER (frame), scales_hbox); gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0); } gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0); gtk_container_add (GTK_CONTAINER (appwindow), vbox); gtk_widget_show_all (appwindow); gst_element_set_state (bin, GST_STATE_PLAYING); gtk_main (); gst_element_set_state (bin, GST_STATE_NULL); gst_object_unref (bin); return 0; }
VikLayerParamData a_uibuilder_widget_get_value ( GtkWidget *widget, VikLayerParam *param ) { VikLayerParamData rv; switch ( param->widget_type ) { case VIK_LAYER_WIDGET_COLOR: gtk_color_button_get_color ( GTK_COLOR_BUTTON(widget), &(rv.c) ); break; case VIK_LAYER_WIDGET_CHECKBUTTON: rv.b = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)); break; case VIK_LAYER_WIDGET_COMBOBOX: #ifndef GTK_2_2 if ( param->type == VIK_LAYER_PARAM_UINT ) { rv.i = gtk_combo_box_get_active ( GTK_COMBO_BOX(widget) ); if ( rv.i == -1 ) rv.i = 0; rv.u = rv.i; if ( param->extra_widget_data ) rv.u = ((guint *)param->extra_widget_data)[rv.u]; } if ( param->type == VIK_LAYER_PARAM_STRING) { rv.s = gtk_combo_box_get_active_text ( GTK_COMBO_BOX(widget) ); g_debug("%s: %s", __FUNCTION__, rv.s); } break; #endif case VIK_LAYER_WIDGET_RADIOGROUP: case VIK_LAYER_WIDGET_RADIOGROUP_STATIC: rv.u = vik_radio_group_get_selected(VIK_RADIO_GROUP(widget)); if ( param->extra_widget_data ) rv.u = GPOINTER_TO_UINT ( g_list_nth_data(param->extra_widget_data, rv.u) ); break; case VIK_LAYER_WIDGET_SPINBUTTON: if ( param->type == VIK_LAYER_PARAM_UINT ) rv.u = gtk_spin_button_get_value_as_int ( GTK_SPIN_BUTTON(widget) ); else if ( param->type == VIK_LAYER_PARAM_INT ) rv.i = gtk_spin_button_get_value_as_int ( GTK_SPIN_BUTTON(widget) ); else rv.d = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(widget) ); break; case VIK_LAYER_WIDGET_ENTRY: case VIK_LAYER_WIDGET_PASSWORD: rv.s = gtk_entry_get_text ( GTK_ENTRY(widget) ); break; case VIK_LAYER_WIDGET_FILEENTRY: case VIK_LAYER_WIDGET_FOLDERENTRY: rv.s = vik_file_entry_get_filename ( VIK_FILE_ENTRY(widget) ); break; case VIK_LAYER_WIDGET_FILELIST: rv.sl = vik_file_list_get_files ( VIK_FILE_LIST(widget) ); break; case VIK_LAYER_WIDGET_HSCALE: if ( param->type == VIK_LAYER_PARAM_UINT ) rv.u = (guint32) gtk_range_get_value ( GTK_RANGE(widget) ); else if ( param->type == VIK_LAYER_PARAM_INT ) rv.i = (gint32) gtk_range_get_value ( GTK_RANGE(widget) ); else rv.d = gtk_range_get_value ( GTK_RANGE(widget) ); break; } return rv; }
UIColorDialog* CreateColorDialog(UIDialog* parent) { GtkWidget* window; GtkAdjustment* adjust; // Create dialog. UIColorDialog* dialog = (UIColorDialog*)CreateDialog(sizeof(UIColorDialog), parent); // Create dialog window. #ifdef USE_LIB_GLADE UI_DIALOG(dialog)->window = window = LookupWidget(NULL, "color_dialog"); #else UI_DIALOG(dialog)->window = window = create_color_dialog(); #endif // Cyan scale adjustment. adjust = gtk_range_get_adjustment( GTK_RANGE(LookupWidget(window, "color_dialog_cyan_scale"))); gtk_signal_connect(GTK_OBJECT(adjust), "value_changed", GTK_SIGNAL_FUNC(on_color_dialog_cyan_adjust_value_changed), window); dialog->cyan_balance = CYAN_BALANCE_INIT; dialog->cyan_adjust = adjust; // Magenta scale adjustment. adjust = gtk_range_get_adjustment( GTK_RANGE(LookupWidget(window, "color_dialog_magenta_scale"))); gtk_signal_connect(GTK_OBJECT(adjust), "value_changed", GTK_SIGNAL_FUNC(on_color_dialog_magenta_adjust_value_changed), window); dialog->magenta_balance = MAGENTA_BALANCE_INIT; dialog->magenta_adjust = adjust; // Yellow scale adjustment. adjust = gtk_range_get_adjustment( GTK_RANGE(LookupWidget(window, "color_dialog_yellow_scale"))); gtk_signal_connect(GTK_OBJECT(adjust), "value_changed", GTK_SIGNAL_FUNC(on_color_dialog_yellow_adjust_value_changed), window); dialog->yellow_balance = YELLOW_BALANCE_INIT; dialog->yellow_adjust = adjust; // Black scale adjustment. adjust = gtk_range_get_adjustment( GTK_RANGE(LookupWidget(window, "color_dialog_black_scale"))); gtk_signal_connect(GTK_OBJECT(adjust), "value_changed", GTK_SIGNAL_FUNC(on_color_dialog_black_adjust_value_changed), window); dialog->black_balance = BLACK_BALANCE_INIT; dialog->black_adjust = adjust; // Density scale adjustment. adjust = gtk_range_get_adjustment( GTK_RANGE(LookupWidget(window, "color_dialog_density_scale"))); gtk_signal_connect(GTK_OBJECT(adjust), "value_changed", GTK_SIGNAL_FUNC(on_color_dialog_density_adjust_value_changed), window); dialog->density_balance = DENSITY_BALANCE_INIT; dialog->density_adjust = adjust; // Color correct combo. dialog->color_correct = SetColorCorrectCombo(dialog, COLOR_CORRECT_INIT); // Gamma combo. dialog->default_gamma = dialog->gamma = SetGammaCombo(dialog, GetDefaultGamma(dialog)); dialog->vivid = FALSE; // Show vivid button if supported. if( IsAvailableVivid() ) { gtk_widget_show(LookupWidget(window, "color_dialog_vivid_button")); } return dialog; }
GtkWidget *a_uibuilder_new_widget ( VikLayerParam *param, VikLayerParamData data ) { GtkWidget *rv = NULL; switch ( param->widget_type ) { case VIK_LAYER_WIDGET_COLOR: if ( param->type == VIK_LAYER_PARAM_COLOR ) rv = gtk_color_button_new_with_color ( &(data.c) ); break; case VIK_LAYER_WIDGET_CHECKBUTTON: if ( param->type == VIK_LAYER_PARAM_BOOLEAN ) { //rv = gtk_check_button_new_with_label ( //param->title ); rv = gtk_check_button_new (); if ( data.b ) gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON(rv), TRUE ); } break; case VIK_LAYER_WIDGET_COMBOBOX: #ifndef GTK_2_2 if ( param->type == VIK_LAYER_PARAM_UINT && param->widget_data ) { gchar **pstr = param->widget_data; rv = gtk_combo_box_new_text (); while ( *pstr ) gtk_combo_box_append_text ( GTK_COMBO_BOX ( rv ), *(pstr++) ); if ( param->extra_widget_data ) /* map of alternate uint values for options */ { int i; for ( i = 0; ((const char **)param->widget_data)[i]; i++ ) if ( ((guint *)param->extra_widget_data)[i] == data.u ) { gtk_combo_box_set_active ( GTK_COMBO_BOX(rv), i ); break; } } else gtk_combo_box_set_active ( GTK_COMBO_BOX ( rv ), data.u ); } else if ( param->type == VIK_LAYER_PARAM_STRING && param->widget_data ) { gchar **pstr = param->widget_data; rv = GTK_WIDGET ( gtk_combo_box_entry_new_text () ); if ( data.s ) gtk_combo_box_append_text ( GTK_COMBO_BOX ( rv ), data.s ); while ( *pstr ) gtk_combo_box_append_text ( GTK_COMBO_BOX ( rv ), *(pstr++) ); if ( data.s ) gtk_combo_box_set_active ( GTK_COMBO_BOX ( rv ), 0 ); } break; #endif case VIK_LAYER_WIDGET_RADIOGROUP: /* widget_data and extra_widget_data are GList */ if ( param->type == VIK_LAYER_PARAM_UINT && param->widget_data ) { rv = vik_radio_group_new ( param->widget_data ); if ( param->extra_widget_data ) /* map of alternate uint values for options */ { int i; int nb_elem = g_list_length(param->widget_data); for ( i = 0; i < nb_elem; i++ ) if ( GPOINTER_TO_UINT ( g_list_nth_data(param->extra_widget_data, i) ) == data.u ) { vik_radio_group_set_selected ( VIK_RADIO_GROUP(rv), i ); break; } } else if ( data.u ) /* zero is already default */ vik_radio_group_set_selected ( VIK_RADIO_GROUP(rv), data.u ); } break; case VIK_LAYER_WIDGET_RADIOGROUP_STATIC: if ( param->type == VIK_LAYER_PARAM_UINT && param->widget_data ) { rv = vik_radio_group_new_static ( (const gchar **) param->widget_data ); if ( param->extra_widget_data ) /* map of alternate uint values for options */ { int i; for ( i = 0; ((const char **)param->widget_data)[i]; i++ ) if ( ((guint *)param->extra_widget_data)[i] == data.u ) { vik_radio_group_set_selected ( VIK_RADIO_GROUP(rv), i ); break; } } else if ( data.u ) /* zero is already default */ vik_radio_group_set_selected ( VIK_RADIO_GROUP(rv), data.u ); } break; case VIK_LAYER_WIDGET_SPINBUTTON: if ( (param->type == VIK_LAYER_PARAM_DOUBLE || param->type == VIK_LAYER_PARAM_UINT || param->type == VIK_LAYER_PARAM_INT) && param->widget_data ) { gdouble init_val = (param->type == VIK_LAYER_PARAM_DOUBLE) ? data.d : (param->type == VIK_LAYER_PARAM_UINT ? data.u : data.i); VikLayerParamScale *scale = (VikLayerParamScale *) param->widget_data; rv = gtk_spin_button_new ( GTK_ADJUSTMENT(gtk_adjustment_new( init_val, scale->min, scale->max, scale->step, scale->step, 0 )), scale->step, scale->digits ); } break; case VIK_LAYER_WIDGET_ENTRY: if ( param->type == VIK_LAYER_PARAM_STRING ) { rv = gtk_entry_new (); if (data.s) gtk_entry_set_text ( GTK_ENTRY(rv), data.s ); } break; case VIK_LAYER_WIDGET_PASSWORD: if ( param->type == VIK_LAYER_PARAM_STRING ) { rv = gtk_entry_new (); gtk_entry_set_visibility ( GTK_ENTRY(rv), FALSE ); if (data.s) gtk_entry_set_text ( GTK_ENTRY(rv), data.s ); #if GTK_CHECK_VERSION(2,12,0) gtk_widget_set_tooltip_text ( GTK_WIDGET(rv), _("Take care that this password will be stored clearly in a plain file.") ); #endif } break; case VIK_LAYER_WIDGET_FILEENTRY: if ( param->type == VIK_LAYER_PARAM_STRING ) { rv = vik_file_entry_new (GTK_FILE_CHOOSER_ACTION_OPEN); vik_file_entry_set_filename ( VIK_FILE_ENTRY(rv), data.s ); } break; case VIK_LAYER_WIDGET_FOLDERENTRY: if ( param->type == VIK_LAYER_PARAM_STRING ) { rv = vik_file_entry_new (GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER); vik_file_entry_set_filename ( VIK_FILE_ENTRY(rv), data.s ); } break; case VIK_LAYER_WIDGET_FILELIST: if ( param->type == VIK_LAYER_PARAM_STRING_LIST ) { rv = vik_file_list_new ( _(param->title) ); vik_file_list_set_files ( VIK_FILE_LIST(rv), data.sl ); } break; case VIK_LAYER_WIDGET_HSCALE: if ( (param->type == VIK_LAYER_PARAM_DOUBLE || param->type == VIK_LAYER_PARAM_UINT || param->type == VIK_LAYER_PARAM_INT) && param->widget_data ) { gdouble init_val = (param->type == VIK_LAYER_PARAM_DOUBLE) ? data.d : (param->type == VIK_LAYER_PARAM_UINT ? data.u : data.i); VikLayerParamScale *scale = (VikLayerParamScale *) param->widget_data; rv = gtk_hscale_new_with_range ( scale->min, scale->max, scale->step ); gtk_scale_set_digits ( GTK_SCALE(rv), scale->digits ); gtk_range_set_value ( GTK_RANGE(rv), init_val ); } } return rv; }
bool wxSlider::Create(wxWindow *parent, wxWindowID id, int value, int minValue, int maxValue, const wxPoint& pos, const wxSize& size, long style, const wxValidator& validator, const wxString& name) { m_pos = value; m_scrollEventType = GTK_SCROLL_NONE; if (!PreCreation( parent, pos, size ) || !CreateBase( parent, id, pos, size, style, validator, name )) { wxFAIL_MSG( wxT("wxSlider creation failed") ); return false; } if (style & wxSL_VERTICAL) m_scale = gtk_vscale_new( NULL ); else m_scale = gtk_hscale_new( NULL ); g_object_ref(m_scale); if (style & wxSL_MIN_MAX_LABELS) { gtk_widget_show( m_scale ); if (style & wxSL_VERTICAL) m_widget = gtk_hbox_new(false, 0); else m_widget = gtk_vbox_new(false, 0); g_object_ref(m_widget); gtk_widget_show( m_widget ); gtk_container_add( GTK_CONTAINER(m_widget), m_scale ); GtkWidget *box; if (style & wxSL_VERTICAL) box = gtk_vbox_new(false,0); else box = gtk_hbox_new(false,0); g_object_ref(box); gtk_widget_show(box); gtk_container_add( GTK_CONTAINER(m_widget), box ); m_minLabel = gtk_label_new(NULL); g_object_ref(m_minLabel); gtk_widget_show( m_minLabel ); gtk_container_add( GTK_CONTAINER(box), m_minLabel ); gtk_box_set_child_packing( GTK_BOX(box), m_minLabel, FALSE, FALSE, 0, GTK_PACK_START ); // expanding empty space between the min/max labels GtkWidget *space = gtk_label_new(NULL); g_object_ref(space); gtk_widget_show( space ); gtk_container_add( GTK_CONTAINER(box), space ); gtk_box_set_child_packing( GTK_BOX(box), space, TRUE, FALSE, 0, GTK_PACK_START ); m_maxLabel = gtk_label_new(NULL); g_object_ref(m_maxLabel); gtk_widget_show( m_maxLabel ); gtk_container_add( GTK_CONTAINER(box), m_maxLabel ); gtk_box_set_child_packing( GTK_BOX(box), m_maxLabel, FALSE, FALSE, 0, GTK_PACK_END ); } else { m_widget = m_scale; m_maxLabel = NULL; m_minLabel = NULL; } const bool showValueLabel = (style & wxSL_VALUE_LABEL) != 0; gtk_scale_set_draw_value(GTK_SCALE (m_scale), showValueLabel ); if ( showValueLabel ) { // position the label appropriately: notice that wxSL_DIRECTION flags // specify the position of the ticks, not label, under MSW and so the // label is on the opposite side GtkPositionType posLabel; if ( style & wxSL_VERTICAL ) { if ( style & wxSL_LEFT ) posLabel = GTK_POS_RIGHT; else // if ( style & wxSL_RIGHT ) -- this is also the default posLabel = GTK_POS_LEFT; } else // horizontal slider { if ( style & wxSL_TOP ) posLabel = GTK_POS_BOTTOM; else // if ( style & wxSL_BOTTOM) -- this is again the default posLabel = GTK_POS_TOP; } gtk_scale_set_value_pos( GTK_SCALE(m_scale), posLabel ); } // Keep full precision in position value gtk_scale_set_digits(GTK_SCALE (m_scale), -1); if (style & wxSL_INVERSE) gtk_range_set_inverted( GTK_RANGE(m_scale), TRUE ); g_signal_connect(m_scale, "button_press_event", G_CALLBACK(gtk_button_press_event), this); g_signal_connect(m_scale, "button_release_event", G_CALLBACK(gtk_button_release_event), this); g_signal_connect(m_scale, "move_slider", G_CALLBACK(gtk_move_slider), this); g_signal_connect(m_scale, "format_value", G_CALLBACK(gtk_format_value), NULL); g_signal_connect(m_scale, "value_changed", G_CALLBACK(gtk_value_changed), this); gulong handler_id = g_signal_connect(m_scale, "event_after", G_CALLBACK(gtk_event_after), this); g_signal_handler_block(m_scale, handler_id); SetRange( minValue, maxValue ); // don't call the public SetValue() as it won't do anything unless the // value really changed GTKSetValue( value ); m_parent->DoAddChild( this ); PostCreation(size); return true; }
static gboolean nimf_candidate_start (NimfService *service) { g_debug (G_STRLOC ": %s", G_STRFUNC); NimfCandidate *candidate = NIMF_CANDIDATE (service); if (candidate->active) return TRUE; GtkCellRenderer *renderer; GtkTreeViewColumn *column[N_COLUMNS]; GtkListStore *store; gint fixed_height = 32; gint horizontal_space; gtk_init (NULL, NULL); /* gtk entry */ candidate->entry = gtk_entry_new (); gtk_editable_set_editable (GTK_EDITABLE (candidate->entry), FALSE); gtk_widget_set_no_show_all (candidate->entry, TRUE); g_signal_connect_after (candidate->entry, "draw", G_CALLBACK (on_entry_draw), NULL); /* gtk tree view */ store = gtk_list_store_new (N_COLUMNS, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING); candidate->treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store)); g_object_unref (store); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (candidate->treeview), FALSE); gtk_widget_style_get (candidate->treeview, "horizontal-separator", &horizontal_space, NULL); candidate->cell_height = fixed_height + horizontal_space / 2; gtk_widget_set_size_request (candidate->treeview, (gint) (candidate->cell_height * 10 / 1.6), candidate->cell_height * 10); g_signal_connect (candidate->treeview, "row-activated", (GCallback) on_tree_view_row_activated, candidate); /* column */ renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "height", fixed_height, "font", "Sans 14", NULL); column[INDEX_COLUMN] = gtk_tree_view_column_new_with_attributes ("Index", renderer, "text", INDEX_COLUMN, NULL); column[MAIN_COLUMN] = gtk_tree_view_column_new_with_attributes ("Main", renderer, "text", MAIN_COLUMN, NULL); column[EXTRA_COLUMN] = gtk_tree_view_column_new_with_attributes ("Extra", renderer, "text", EXTRA_COLUMN, NULL); gtk_tree_view_column_set_sizing (column[INDEX_COLUMN], GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_sizing (column[MAIN_COLUMN], GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_sizing (column[EXTRA_COLUMN], GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_append_column (GTK_TREE_VIEW (candidate->treeview), column[INDEX_COLUMN]); gtk_tree_view_append_column (GTK_TREE_VIEW (candidate->treeview), column[MAIN_COLUMN]); gtk_tree_view_append_column (GTK_TREE_VIEW (candidate->treeview), column[EXTRA_COLUMN]); /* scrollbar */ GtkAdjustment *adjustment = gtk_adjustment_new (1.0, 1.0, 2.0, 1.0, 1.0, 1.0); candidate->scrollbar = gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL, adjustment); gtk_range_set_slider_size_fixed (GTK_RANGE (candidate->scrollbar), FALSE); g_signal_connect (candidate->scrollbar, "change-value", G_CALLBACK (on_range_change_value), candidate); GtkCssProvider *provider; GtkStyleContext *style_context; provider = gtk_css_provider_new (); gtk_css_provider_load_from_data (GTK_CSS_PROVIDER (provider), ".scrollbar {" " -GtkScrollbar-has-backward-stepper: true;" " -GtkScrollbar-has-forward-stepper: true;" " -GtkScrollbar-has-secondary-forward-stepper: true;" "}" , -1, NULL); style_context = gtk_widget_get_style_context (candidate->scrollbar); gtk_style_context_add_provider (style_context, GTK_STYLE_PROVIDER (provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); g_object_unref (provider); /* gtk box */ GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); GtkWidget *hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start (GTK_BOX (vbox), candidate->entry, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (hbox), candidate->treeview, TRUE, TRUE, 0); gtk_box_pack_end (GTK_BOX (hbox), candidate->scrollbar, FALSE, TRUE, 0); /* gtk window */ candidate->window = gtk_window_new (GTK_WINDOW_POPUP); gtk_window_set_type_hint (GTK_WINDOW (candidate->window), GDK_WINDOW_TYPE_HINT_POPUP_MENU); gtk_container_set_border_width (GTK_CONTAINER (candidate->window), 1); gtk_container_add (GTK_CONTAINER (candidate->window), vbox); gtk_widget_realize (candidate->window); candidate->active = TRUE; return TRUE; }