GtkWidget * gog_barcol_plot_pref (GogBarColPlot *barcol, GOCmdContext *cc) { GtkWidget *w; GtkBuilder *gui = go_gtk_builder_load ("res:go:plot_barcol/gog-barcol-prefs.ui", GETTEXT_PACKAGE, cc); if (gui == NULL) return NULL; w = go_gtk_builder_get_widget (gui, "gap_spinner"); gtk_spin_button_set_value (GTK_SPIN_BUTTON (w), barcol->gap_percentage); g_signal_connect (G_OBJECT (gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (w))), "value_changed", G_CALLBACK (cb_gap_changed), barcol); w = go_gtk_builder_get_widget (gui, "overlap_spinner"); gtk_spin_button_set_value (GTK_SPIN_BUTTON (w), barcol->overlap_percentage); g_signal_connect (G_OBJECT (gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (w))), "value_changed", G_CALLBACK (cb_overlap_changed), barcol); w = go_gtk_builder_get_widget (gui, "before-grid"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), (GOG_PLOT (barcol))->rendering_order == GOG_PLOT_RENDERING_BEFORE_GRID); g_signal_connect (G_OBJECT (w), "toggled", G_CALLBACK (display_before_grid_cb), barcol); w = GTK_WIDGET (g_object_ref (gtk_builder_get_object (gui, "gog-barcol-prefs"))); g_object_unref (gui); return w; }
static void gopt_int_changed(GtkSpinButton *spin, gpointer data) { struct gopt_int *i = (struct gopt_int *) data; struct fio_option *o = &fio_options[i->gopt.opt_index]; GtkAdjustment *adj; int value, delta; gopt_changed(&i->gopt); adj = gtk_spin_button_get_adjustment(spin); value = gtk_adjustment_get_value(adj); delta = value - i->lastval; i->lastval = value; if (o->inv_opt) { struct gopt *b_inv = o->inv_opt->gui_data; struct gopt_int *i_inv = container_of(b_inv, struct gopt_int, gopt); int cur_val; assert(o->type == o->inv_opt->type); cur_val = gtk_spin_button_get_value(GTK_SPIN_BUTTON(i_inv->spin)); cur_val -= delta; g_signal_handler_block(G_OBJECT(i_inv->spin), i_inv->gopt.sig_handler); gtk_spin_button_set_value(GTK_SPIN_BUTTON(i_inv->spin), cur_val); g_signal_handler_unblock(G_OBJECT(i_inv->spin), i_inv->gopt.sig_handler); } }
static void gopt_str_val_spin_wrapped(GtkSpinButton *spin, gpointer data) { struct gopt_str_val *g = (struct gopt_str_val *) data; unsigned int val; GtkAdjustment *adj; gint index; adj = gtk_spin_button_get_adjustment(spin); val = gtk_adjustment_get_value(adj); /* * Can't rely on exact value, as fast changes increment >= 1 */ if (!val) { index = gtk_combo_box_get_active(GTK_COMBO_BOX(g->combo)); if (index + 1 <= g->maxindex) { val = 1; gtk_combo_box_set_active(GTK_COMBO_BOX(g->combo), ++index); } else val = 1023; gtk_spin_button_set_value(spin, val); } else { index = gtk_combo_box_get_active(GTK_COMBO_BOX(g->combo)); if (index) { gtk_combo_box_set_active(GTK_COMBO_BOX(g->combo), --index); gtk_spin_button_set_value(spin, 1023); } else gtk_spin_button_set_value(spin, 0); } }
static gboolean format_hours_combobox (GtkSpinButton *spin, CcDateTimePanel *panel) { CcDateTimePanelPrivate *priv = panel->priv; GtkAdjustment *adjustment; char *text; int hour; gboolean use_ampm; if (priv->clock_format == G_DESKTOP_CLOCK_FORMAT_12H) use_ampm = TRUE; else use_ampm = FALSE; adjustment = gtk_spin_button_get_adjustment (spin); hour = (int)gtk_adjustment_get_value (adjustment); if (use_ampm) text = g_strdup_printf ("%d", hour); else text = g_strdup_printf ("%02d", hour); gtk_entry_set_text (GTK_ENTRY (spin), text); g_free (text); return TRUE; }
static void dwiz_set_radio_opt (GtkWidget *w, dw_opts *opts) { int val = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(w), "action")); if (opts->pdspin != NULL) { if (val == PD_SPECIAL) { GtkAdjustment *adj = gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(opts->pdspin)); gtk_widget_set_sensitive(opts->pdspin, TRUE); val = (int) gtk_adjustment_get_value(adj); if (opts->extra != NULL) { *opts->extra = SPECIAL_TIME_SERIES; } } else { gtk_widget_set_sensitive(opts->pdspin, FALSE); if (opts->extra != NULL) { *opts->extra = TIME_SERIES; } } } #if DWDEBUG fprintf(stderr, "dwiz_set_radio_opt: setting setvar to %d\n", val); if (opts->extra != NULL) { fprintf(stderr, "dwiz_set_radio_opt: extra now = %d\n", *opts->extra); } #endif *opts->setvar = val; }
static void spin_button_save(struct iio_widget *widget, bool is_double) { gdouble freq, min; gdouble scale = widget->priv ? *(gdouble *)widget->priv : 1.0; freq = gtk_spin_button_get_value(GTK_SPIN_BUTTON (widget->widget)); min = gtk_adjustment_get_lower(gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(widget->widget))); if (scale < 0 && min < 0) freq = fabs(freq * scale); else freq *= scale; if (widget->priv_convert_function) freq = ((double (*)(double, bool))widget->priv_convert_function)(freq, false); if (widget->chn) { if (is_double) iio_channel_attr_write_double(widget->chn, widget->attr_name, freq); else iio_channel_attr_write_longlong(widget->chn, widget->attr_name, (long long) freq); } else { if (is_double) iio_device_attr_write_double(widget->dev, widget->attr_name, freq); else iio_device_attr_write_longlong(widget->dev, widget->attr_name, (long long) freq); } }
static void on_mouse_scroll (GtkWidget* widget, GdkEventScroll* evt, volume_t *vol) { if ( ! vol->dlg ) { vol->dlg = create_volume_window(); g_signal_connect( vol->dlg, "delete-event", G_CALLBACK(on_volume_focus), widget ); } else { if (! vol_spin) return; GtkAdjustment *vol_adjustment = gtk_spin_button_get_adjustment (vol_spin); if (! vol_adjustment) return; curr_volume = gtk_adjustment_get_value (vol_adjustment); if (evt->direction == GDK_SCROLL_UP) { curr_volume += 2; } else /*if (evt->direction == GDK_SCROLL_DOWN)*/ { curr_volume -= 2; } update_icon(widget, vol); gtk_adjustment_set_value (vol_adjustment, curr_volume); gtk_spin_button_set_adjustment(vol_spin, vol_adjustment); skip_botton1_event = TRUE; } }
static int cget( Tcl_Interp *interp, SpinButtonParams *para, GnoclOption options[], int idx ) { GtkAdjustment *adjust = gtk_spin_button_get_adjustment( para->spinButton ); Tcl_Obj *obj = NULL; if( idx == variableIdx ) obj = Tcl_NewStringObj( para->variable, -1 ); else if( idx == onValueChangedIdx ) { obj = Tcl_NewStringObj( para->onValueChanged ? para->onValueChanged : "", -1 ); } else if( idx == lowerIdx ) obj = Tcl_NewDoubleObj( adjust->lower ); else if( idx == upperIdx ) obj = Tcl_NewDoubleObj( adjust->upper ); else if( idx == stepIncIdx ) obj = Tcl_NewDoubleObj( adjust->step_increment ); else if( idx == pageIncIdx ) obj = Tcl_NewDoubleObj( adjust->page_increment ); else if( idx == valueIdx ) obj = getObjValue( para->spinButton ); if( obj != NULL ) { Tcl_SetObjResult( interp, obj ); return TCL_OK; } return gnoclCgetNotImplemented( interp, options + idx ); }
void fe_get_int (char *msg, int def, void *callback, void *userdata) { GtkWidget *dialog; GtkWidget *spin; GtkWidget *hbox; GtkWidget *label; GtkAdjustment *adj; dialog = gtk_dialog_new_with_buttons (msg, NULL, 0, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL); gtk_box_set_homogeneous (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), TRUE); gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); g_object_set_data (G_OBJECT (dialog), "cb", callback); g_object_set_data (G_OBJECT (dialog), "ud", userdata); spin = gtk_spin_button_new (NULL, 1, 0); adj = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spin)); gtk_adjustment_set_lower (adj, 0); gtk_adjustment_set_upper (adj, 1024); gtk_adjustment_set_step_increment (adj, 1); gtk_adjustment_changed (adj); gtk_spin_button_set_value (GTK_SPIN_BUTTON (spin), def); gtk_box_pack_end (GTK_BOX (hbox), spin, 0, 0, 0); label = gtk_label_new (msg); gtk_box_pack_end (GTK_BOX (hbox), label, 0, 0, 0); g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (get_number_response), spin); gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), hbox); gtk_widget_show_all (dialog); }
double wxSpinCtrlGTKBase::DoGetValue() const { wxCHECK_MSG( (m_widget != NULL), 0, wxT("invalid spin button") ); // Get value directly from current control text, just as // gtk_spin_button_update() would do. Calling gtk_spin_button_update() causes // a redraw, which causes an idle event, so if GetValue() is called from // a UI update handler, you get a never ending sequence of idle events. It // also forces the text into valid range, which wxMSW GetValue() does not do. static unsigned sig_id; if (sig_id == 0) sig_id = g_signal_lookup("input", GTK_TYPE_SPIN_BUTTON); double value; int handled = 0; g_signal_emit(m_widget, sig_id, 0, &value, &handled); if (!handled) value = g_strtod(gtk_entry_get_text(GTK_ENTRY(m_widget)), NULL); GtkAdjustment* adj = gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(m_widget)); const double lower = gtk_adjustment_get_lower(adj); const double upper = gtk_adjustment_get_upper(adj); if (value < lower) value = lower; else if (value > upper) value = upper; return value; }
static void month_year_changed (GtkWidget *widget, CcDateTimePanel *panel) { CcDateTimePanelPrivate *priv = panel->priv; guint mon, y; guint num_days; GtkAdjustment *adj; GtkSpinButton *day_spin; mon = 1 + gtk_combo_box_get_active (GTK_COMBO_BOX (W ("month-combobox"))); y = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (W ("year-spinbutton"))); /* Check the number of days in that month */ num_days = g_date_get_days_in_month (mon, y); day_spin = GTK_SPIN_BUTTON (W("day-spinbutton")); adj = GTK_ADJUSTMENT (gtk_spin_button_get_adjustment (day_spin)); gtk_adjustment_set_upper (adj, num_days + 1); if (gtk_spin_button_get_value_as_int (day_spin) > num_days) gtk_spin_button_set_value (day_spin, num_days); change_date (panel); }
static void ide_preferences_spin_button_setting_changed (IdePreferencesSpinButton *self, const gchar *key, GSettings *settings) { GtkAdjustment *adj; GVariant *value; g_assert (IDE_IS_PREFERENCES_SPIN_BUTTON (self)); g_assert (key != NULL); g_assert (G_IS_SETTINGS (settings)); if (self->updating) return; self->updating = TRUE; adj = gtk_spin_button_get_adjustment (self->spin_button); value = g_settings_get_value (settings, key); apply_value (adj, value, "value"); g_variant_unref (value); self->updating = FALSE; }
static void gail_spin_button_real_initialize (AtkObject *obj, gpointer data) { GtkAdjustment *adjustment; GailSpinButton *spin_button = GAIL_SPIN_BUTTON (obj); GtkSpinButton *gtk_spin_button; ATK_OBJECT_CLASS (gail_spin_button_parent_class)->initialize (obj, data); gtk_spin_button = GTK_SPIN_BUTTON (data); /* * If a GtkAdjustment already exists for the spin_button, * create the GailAdjustment */ adjustment = gtk_spin_button_get_adjustment (gtk_spin_button); if (adjustment) { spin_button->adjustment = gail_adjustment_new (adjustment); g_signal_connect (adjustment, "value-changed", G_CALLBACK (gail_spin_button_value_changed), obj); } else spin_button->adjustment = NULL; obj->role = ATK_ROLE_SPIN_BUTTON; }
void gtk_utils_convert_to_time_spin_button (GtkSpinButton *spin_button) { GtkAdjustment *adjustment = gtk_spin_button_get_adjustment (spin_button); gdouble upper_limit; gint max_width; g_return_if_fail (adjustment); g_signal_connect (spin_button, "output", G_CALLBACK (time_spin_button_output), NULL); g_signal_connect (spin_button, "input", G_CALLBACK (time_spin_button_input), NULL); if (adjustment->upper > 60.0 * 60.0) { /* One less, since two colons would normally take space of only * one "common" char. Anyway Quarry time upper bounds are not * something one would use. */ for (max_width = 6, upper_limit = adjustment->upper / (60.0 * 60.0); upper_limit >= 10.0; upper_limit /= 10.0) max_width++; } else max_width = 5; gtk_entry_set_width_chars (GTK_ENTRY (spin_button), max_width); }
static void power_of_2_handlers (GtkWidget *w) { GtkSpinButton *spin = GTK_SPIN_BUTTON (w); GtkAdjustment *adj = gtk_spin_button_get_adjustment (spin); g_signal_connect (G_OBJECT (adj), "value_changed", G_CALLBACK (cb_power_of_2), NULL); }
void on_itemCountBtn_value_changed (GtkSpinButton *spinbutton, gpointer user_data) { GtkAdjustment *itemCount; itemCount = gtk_spin_button_get_adjustment (spinbutton); conf_set_int_value (DEFAULT_MAX_ITEMS, gtk_adjustment_get_value (itemCount)); }
/** * gtk_test_slider_get_value: * @widget: valid widget pointer. * * Retrive the literal adjustment value for GtkRange based * widgets and spin buttons. Note that the value returned by * this function is anything between the lower and upper bounds * of the adjustment belonging to @widget, and is not a percentage * as passed in to gtk_test_slider_set_perc(). * * Returns: gtk_adjustment_get_value (adjustment) for an adjustment belonging to @widget. * * Since: 2.14 **/ double gtk_test_slider_get_value (GtkWidget *widget) { GtkAdjustment *adjustment = NULL; if (GTK_IS_RANGE (widget)) adjustment = gtk_range_get_adjustment (GTK_RANGE (widget)); else if (GTK_IS_SPIN_BUTTON (widget)) adjustment = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget)); return adjustment ? gtk_adjustment_get_value (adjustment) : 0; }
// Show leading zeros static gboolean on_output ( GtkSpinButton *spin, gpointer data ) { GtkAdjustment *adjustment = gtk_spin_button_get_adjustment ( spin ); gint value = (gint)gtk_adjustment_get_value ( adjustment ); gchar *text = g_strdup_printf ( "%02d", value ); gtk_entry_set_text ( GTK_ENTRY (spin), text ); g_free ( text ); return TRUE; }
GtkWidget * gog_bubble_plot_pref (GogBubblePlot *bubble, GOCmdContext *cc) { GtkWidget *w; GtkBuilder *gui = go_gtk_builder_load ("res:go:plot_xy/gog-bubble-prefs.ui", GETTEXT_PACKAGE, cc); if (gui == NULL) return NULL; w = go_gtk_builder_get_widget (gui, "area"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), bubble->size_as_area); g_signal_connect (G_OBJECT (w), "toggled", G_CALLBACK (cb_type_changed), bubble); w = go_gtk_builder_get_widget (gui, "diameter"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), !bubble->size_as_area); g_signal_connect (G_OBJECT (w), "toggled", G_CALLBACK (cb_type_changed), bubble); w = go_gtk_builder_get_widget (gui, "vary_style_by_element"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), bubble->base.base.vary_style_by_element); g_signal_connect (G_OBJECT (w), "toggled", G_CALLBACK (cb_style_changed), bubble); w = go_gtk_builder_get_widget (gui, "3d"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), bubble->in_3d); g_signal_connect (G_OBJECT (w), "toggled", G_CALLBACK (cb_3d_changed), bubble); /* TODO Add support for 3D bubbles. Hide the button for now. */ gtk_widget_hide (w); w = go_gtk_builder_get_widget (gui, "scale"); gtk_spin_button_set_value (GTK_SPIN_BUTTON (w), bubble->bubble_scale * 100.); g_signal_connect (G_OBJECT (gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (w))), "value_changed", G_CALLBACK (cb_scale_changed), bubble); w = go_gtk_builder_get_widget (gui, "show_negative_values"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), bubble->show_negatives); g_signal_connect (G_OBJECT (w), "toggled", G_CALLBACK (cb_negatives_changed), bubble); w = GTK_WIDGET (g_object_ref (gtk_builder_get_object (gui, "gog-bubble-prefs"))); g_object_unref (gui); return w; }
void gcal_time_selector_set_time_format (GcalTimeSelector *selector, gboolean format_24h) { g_return_if_fail (GCAL_IS_TIME_SELECTOR (selector)); selector->format_24h = format_24h; gtk_widget_set_visible (selector->period_combo, !format_24h); if (format_24h) { gtk_adjustment_set_lower (gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (selector->hour_spin)), 0.0); gtk_adjustment_set_upper (gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (selector->hour_spin)), 23.0); } else { gtk_adjustment_set_lower (gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (selector->hour_spin)), 1.0); gtk_adjustment_set_upper (gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (selector->hour_spin)), 12.0); } }
static gboolean dialog_format_minutes_combobox (GtkSpinButton *spin, CcNightLightDialog *self) { GtkAdjustment *adjustment; g_autofree gchar *text = NULL; adjustment = gtk_spin_button_get_adjustment (spin); text = g_strdup_printf ("%02.0f", gtk_adjustment_get_value (adjustment)); gtk_entry_set_text (GTK_ENTRY (spin), text); return TRUE; }
static void capplet_set_spin_button_value(CappletData *capp, const char *name, gdouble value) { GtkSpinButton *spin_button = GTK_SPIN_BUTTON(gtk_builder_get_object(capp->builder, name)); capplet_ignore_changes = TRUE; gtk_spin_button_set_value(spin_button, value); gtk_adjustment_set_value(gtk_spin_button_get_adjustment(spin_button), value); capplet_ignore_changes = FALSE; }
/** * gtk_test_slider_set_perc * @widget: valid widget pointer. * @percentage: value between 0 and 100. * * This function will adjust the slider position of all GtkRange * based widgets, such as scrollbars or scales, it'll also adjust * spin buttons. The adjustment value of these widgets is set to * a value between the lower and upper limits, according to the * @percentage argument. * * Since: 2.14 **/ void gtk_test_slider_set_perc (GtkWidget *widget, double percentage) { GtkAdjustment *adjustment = NULL; if (GTK_IS_RANGE (widget)) adjustment = gtk_range_get_adjustment (GTK_RANGE (widget)); else if (GTK_IS_SPIN_BUTTON (widget)) adjustment = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget)); if (adjustment) gtk_adjustment_set_value (adjustment, adjustment->lower + (adjustment->upper - adjustment->lower - adjustment->page_size) * percentage * 0.01); }
// the widget can be one of hshift, vshift, hscale, vscale, rotate // we use the g_bListenChanged flag to ignore when changing stuff ourselves static void OnIncrementChanged( GtkWidget *widget, gpointer data ){ if ( !g_bListenChanged ) { return; } #ifdef DBG_SI Sys_Printf( "OnIncrementChanged\n" ); #endif gfloat val = 0; sscanf( gtk_entry_get_text( GTK_ENTRY( widget ) ), "%g", &val ); // now push it into the appropriate spin button GtkAdjustment * adjust; if ( widget == g_dlgSurface.GetDlgWidget( "hshift_inc" ) ) { l_pIncrement->shift[0] = val; adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( g_dlgSurface.GetDlgWidget( "hshift" ) ) ); adjust->step_increment = l_pIncrement->shift[0]; } else if ( widget == g_dlgSurface.GetDlgWidget( "vshift_inc" ) ) { l_pIncrement->shift[1] = val; adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( g_dlgSurface.GetDlgWidget( "vshift" ) ) ); adjust->step_increment = l_pIncrement->shift[1]; } else if ( widget == g_dlgSurface.GetDlgWidget( "hscale_inc" ) ) { l_pIncrement->scale[0] = val; adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( g_dlgSurface.GetDlgWidget( "hscale" ) ) ); adjust->step_increment = l_pIncrement->scale[0]; } else if ( widget == g_dlgSurface.GetDlgWidget( "vscale_inc" ) ) { l_pIncrement->scale[1] = val; adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( g_dlgSurface.GetDlgWidget( "vscale" ) ) ); adjust->step_increment = l_pIncrement->scale[1]; } else if ( widget == g_dlgSurface.GetDlgWidget( "rotate_inc" ) ) { l_pIncrement->rotate = val; adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( g_dlgSurface.GetDlgWidget( "rotate" ) ) ); adjust->step_increment = l_pIncrement->rotate; } }
static gboolean dialog_format_hours_combobox (GtkSpinButton *spin, CcNightLightDialog *self) { GtkAdjustment *adjustment; g_autofree gchar *text = NULL; adjustment = gtk_spin_button_get_adjustment (spin); if (self->clock_format == G_DESKTOP_CLOCK_FORMAT_12H) text = g_strdup_printf ("%.0f", gtk_adjustment_get_value (adjustment)); else text = g_strdup_printf ("%02.0f", gtk_adjustment_get_value (adjustment)); gtk_entry_set_text (GTK_ENTRY (spin), text); return TRUE; }
EXPORT gboolean link_range_spinners(GtkWidget *widget, gpointer data) { GladeXML *xml = glade_get_widget_tree(widget); GtkAdjustment *adj = NULL; GtkWidget *upper_spin = glade_xml_get_widget(xml,"range_highpoint_spin"); adj = gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(upper_spin)); adj->lower = gtk_spin_button_get_value(GTK_SPIN_BUTTON(widget)); if (adj->value < adj->lower) adj->value = adj->lower; gtk_spin_button_set_adjustment(GTK_SPIN_BUTTON(upper_spin),adj); gtk_spin_button_set_value(GTK_SPIN_BUTTON(upper_spin),adj->value); return FALSE; }
GtkWidget * make_font_selector (void) { GtkWidget *hbox; GtkWidget *util_hbox; GtkWidget *label; GtkWidget *option_menu; GtkWidget *spin_button; GtkAdjustment *adj; hbox = gtk_hbox_new (FALSE, 4); util_hbox = gtk_hbox_new (FALSE, 2); label = gtk_label_new ("Family:"); gtk_box_pack_start (GTK_BOX (util_hbox), label, FALSE, FALSE, 0); option_menu = make_families_menu (); gtk_box_pack_start (GTK_BOX (util_hbox), option_menu, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), util_hbox, FALSE, FALSE, 0); util_hbox = gtk_hbox_new (FALSE, 2); label = gtk_label_new ("Style:"); gtk_box_pack_start (GTK_BOX (util_hbox), label, FALSE, FALSE, 0); option_menu = make_styles_combo (); gtk_box_pack_start (GTK_BOX (util_hbox), option_menu, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), util_hbox, FALSE, FALSE, 0); util_hbox = gtk_hbox_new (FALSE, 2); label = gtk_label_new ("Size:"); gtk_box_pack_start (GTK_BOX (util_hbox), label, FALSE, FALSE, 0); spin_button = gtk_spin_button_new (NULL, 1., 0); gtk_box_pack_start (GTK_BOX (util_hbox), spin_button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), util_hbox, FALSE, FALSE, 0); adj = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spin_button)); adj->value = PANGO_PIXELS (pango_font_description_get_size(font_description)); adj->lower = 0; adj->upper = 1024; adj->step_increment = 1; adj->page_size = 10; gtk_adjustment_changed (adj); gtk_adjustment_value_changed (adj); gtk_signal_connect (GTK_OBJECT (adj), "value_changed", GTK_SIGNAL_FUNC (font_size_changed), NULL); return hbox; }
static GtkWidget *volume_constructor(LXPanel *panel, config_setting_t *settings) { volume_t *vol; GtkWidget *p; GtkAdjustment *vol_adjustment; vol_before_mute = 1; curr_volume = 0; curr_image = NULL; skip_botton1_event = FALSE; ENTER; /* check if OSS mixer device could be open */ mixer_fd = open ("/dev/mixer", O_RDWR, 0); if (mixer_fd < 0) { RET(NULL); } /* try to obtain current volume */ p = create_volume_window(); /* use pointer */ if (! vol_spin) goto _error; vol_adjustment = gtk_spin_button_get_adjustment (vol_spin); if (! vol_adjustment) { _error: gtk_widget_destroy(p); RET(NULL); } curr_volume = gtk_adjustment_get_value (vol_adjustment); vol = g_new0(volume_t, 1); vol->dlg = p; /* it was reused */ p = gtk_event_box_new(); lxpanel_plugin_set_data(p, vol, volume_destructor); vol->panel = panel; gtk_widget_add_events(p, GDK_BUTTON_PRESS_MASK); g_signal_connect(p, "scroll-event", G_CALLBACK(on_mouse_scroll), vol); gtk_widget_set_size_request(p, panel_get_icon_size(panel), panel_get_icon_size(panel)); update_icon(p, vol); gtk_widget_destroy( vol->dlg ); vol->dlg = NULL; /* FIXME: display current level in tooltip. ex: "Volume Control: 80%" */ gtk_widget_set_tooltip_text(p, _("Volume control")); RET(p); }
static void realprop_reset_widget(RealProperty *prop, WIDGET *widget) { GtkAdjustment *adj = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON(widget)); if (prop->common.descr->extra_data) { PropNumData *numdata = prop->common.descr->extra_data; gtk_adjustment_configure (adj, prop->real_data, numdata->min, numdata->max, numdata->step, 10.0 * numdata->step, 0); } else { gtk_adjustment_configure (adj, prop->real_data, G_MINFLOAT, G_MAXFLOAT, 0.1, 1.0, 0); } }
static gboolean unit_spin_button_output(GtkSpinButton *spin) { GtkAdjustment *adj; gchar *text; double value; int digits; adj = gtk_spin_button_get_adjustment (spin); digits = gtk_spin_button_get_digits(spin); value = gtk_adjustment_get_value (adj); text = g_strdup_printf ("%.*lf %s", digits, value, UNIT_SPIN_BUTTON(spin)->unit); gtk_entry_set_text (GTK_ENTRY (spin), text); g_free (text); return TRUE; }