Example #1
0
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;
}
Example #2
0
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);
	}
}
Example #3
0
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;
}
Example #5
0
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;
}
Example #6
0
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);
	}
}
Example #7
0
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;
	}
}
Example #8
0
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 );
}
Example #9
0
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);
}
Example #10
0
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;
}
Example #13
0
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;

}
Example #14
0
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);
}
Example #15
0
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);
}
Example #16
0
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));
}
Example #17
0
/**
 * 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;
}
Example #19
0
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;
}
Example #22
0
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;
}
Example #23
0
/**
 * 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);
}
Example #24
0
// 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;
}
Example #26
0
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;
}
Example #27
0
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;
}
Example #28
0
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);
}
Example #29
0
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);
  }
}
Example #30
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;
}