static void gtk_scale_button_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { GtkScaleButton *button = GTK_SCALE_BUTTON (object); GtkScaleButtonPrivate *priv = button->priv; switch (prop_id) { case PROP_ORIENTATION: g_value_set_enum (value, priv->orientation); break; case PROP_VALUE: g_value_set_double (value, gtk_scale_button_get_value (button)); break; case PROP_SIZE: g_value_set_enum (value, priv->size); break; case PROP_ADJUSTMENT: g_value_set_object (value, gtk_scale_button_get_adjustment (button)); break; case PROP_ICONS: g_value_set_boxed (value, priv->icon_list); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static gboolean gtk_scale_button_scroll (GtkWidget *widget, GdkEventScroll *event) { GtkScaleButton *button; GtkScaleButtonPrivate *priv; GtkAdjustment *adj; gdouble d; button = GTK_SCALE_BUTTON (widget); priv = button->priv; adj = priv->adjustment; if (event->type != GDK_SCROLL) return FALSE; d = gtk_scale_button_get_value (button); if (event->direction == GDK_SCROLL_UP) { d += adj->step_increment; if (d > adj->upper) d = adj->upper; } else { d -= adj->step_increment; if (d < adj->lower) d = adj->lower; } gtk_scale_button_set_value (button, d); return TRUE; }
void tuner_set_squelch() { gchar buffer[5]; g_snprintf(buffer, sizeof(buffer), "Q%ld", lround(gtk_scale_button_get_value(GTK_SCALE_BUTTON(ui.squelch)))); tuner_write(tuner.thread, buffer); tuner.last_set_squelch = g_get_real_time() / 1000; }
void tuner_set_volume() { gchar buffer[5]; conf.volume = lround(gtk_scale_button_get_value(GTK_SCALE_BUTTON(ui.volume))); g_snprintf(buffer, sizeof(buffer), "Y%d", conf.volume); tuner_write(tuner.thread, buffer); tuner.last_set_volume = g_get_real_time() / 1000; }
static void gail_scale_button_get_current_value (AtkValue *obj, GValue *value) { GtkScaleButton *gtk_scale_button; g_return_if_fail (GAIL_IS_SCALE_BUTTON (obj)); gtk_scale_button = GTK_SCALE_BUTTON (GTK_ACCESSIBLE (obj)->widget); g_value_set_double (g_value_init (value, G_TYPE_DOUBLE), gtk_scale_button_get_value (gtk_scale_button)); }
static gboolean cb_query_tooltip (GtkWidget *button, gint x, gint y, gboolean keyboard_mode, GtkTooltip *tooltip, gpointer user_data) { GtkScaleButton *scale_button = GTK_SCALE_BUTTON (button); GtkAdjustment *adjustment; gdouble val; char *str; AtkImage *image; image = ATK_IMAGE (gtk_widget_get_accessible (button)); adjustment = gtk_scale_button_get_adjustment (scale_button); val = gtk_scale_button_get_value (scale_button); if (val < (gtk_adjustment_get_lower (adjustment) + EPSILON)) { str = g_strdup (_("Muted")); } else if (val >= (gtk_adjustment_get_upper (adjustment) - EPSILON)) { str = g_strdup (_("Full Volume")); } else { int percent; percent = (int) (100. * val / (gtk_adjustment_get_upper (adjustment) - gtk_adjustment_get_lower (adjustment)) + .5); /* Translators: this is the percentage of the current volume, * as used in the tooltip, eg. "49 %". * Translate the "%d" to "%Id" if you want to use localised digits, * or otherwise translate the "%d" to "%d". */ str = g_strdup_printf (C_("volume percentage", "%d %%"), percent); } gtk_tooltip_set_text (tooltip, str); atk_image_set_image_description (image, str); g_free (str); return TRUE; }
static void quality_changed(GtkScaleButton *button, G_GNUC_UNUSED gdouble value, CurrentCallView *self) { g_return_if_fail(IS_CURRENT_CALL_VIEW(self)); CurrentCallViewPrivate *priv = CURRENT_CALL_VIEW_GET_PRIVATE(self); /* no need to upate quality if auto quality is enabled */ if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->checkbutton_autoquality))) return; /* only update if the scale button is released, to reduce the number of updates */ if (priv->quality_scale_pressed) return; /* we get the value directly from the widget, in case this function is not * called from the event */ if (priv->call) set_quality(priv->call, FALSE, gtk_scale_button_get_value(button)); }
static gboolean ui_volume_slider_update(gpointer data) { gint volume; if (volume_slider_is_moving || data == NULL) return TRUE; aud_drct_get_volume_main(&volume); if (volume == (gint) gtk_scale_button_get_value(GTK_SCALE_BUTTON(data))) return TRUE; g_signal_handler_block(data, volume_change_handler_id); gtk_scale_button_set_value(GTK_SCALE_BUTTON(data), volume); g_signal_handler_unblock(data, volume_change_handler_id); return TRUE; }
gboolean focus_in_cb( GtkWidget *widget, GdkEventKey *event, gpointer data ) { (void)event; if ( IS_EGE_ADJUSTMENT_ACTION(data) ) { EgeAdjustmentAction* action = EGE_ADJUSTMENT_ACTION( data ); if ( GTK_IS_SPIN_BUTTON(widget) ) { action->private_data->lastVal = gtk_spin_button_get_value( GTK_SPIN_BUTTON(widget) ); #if GTK_CHECK_VERSION(2,12,0) } else if ( GTK_IS_SCALE_BUTTON(widget) ) { action->private_data->lastVal = gtk_scale_button_get_value( GTK_SCALE_BUTTON(widget) ); #endif /* GTK_CHECK_VERSION(2,12,0) */ } else if (GTK_IS_RANGE(widget) ) { action->private_data->lastVal = gtk_range_get_value( GTK_RANGE(widget) ); } action->private_data->transferFocus = TRUE; } return FALSE; /* report event not consumed */ }
static gboolean on_scale_button_query_tooltip (GtkWidget *button, gint x, gint y, gboolean keyboard_mode, GtkTooltip *tooltip, gpointer user_data) { GtkScaleButton *scale_button = GTK_SCALE_BUTTON (button); GtkAdjustment *adjustment; gdouble val; gchar *str; AtkImage *image; image = ATK_IMAGE (gtk_widget_get_accessible (button)); adjustment = gtk_scale_button_get_adjustment (scale_button); val = gtk_scale_button_get_value (scale_button); if (val < (gtk_adjustment_get_lower (adjustment) + EPSILON)) { str = g_strdup (_("Muted")); } else if (val >= (gtk_adjustment_get_upper (adjustment) - EPSILON)) { str = g_strdup (_("Full Volume")); } else { gint percent; percent = (gint) (100. * val / (gtk_adjustment_get_upper (adjustment) - gtk_adjustment_get_lower (adjustment)) + .5); str = g_strdup_printf (C_("volume percentage", "%d %%"), percent); } gtk_tooltip_set_text (tooltip, str); atk_image_set_image_description (image, str); g_free (str); return TRUE; }
static void autoquality_toggled(GtkToggleButton *button, CurrentCallView *self) { g_return_if_fail(IS_CURRENT_CALL_VIEW(self)); CurrentCallViewPrivate *priv = CURRENT_CALL_VIEW_GET_PRIVATE(self); gboolean auto_quality_on = gtk_toggle_button_get_active(button); auto scale = gtk_scale_button_get_scale(GTK_SCALE_BUTTON(priv->scalebutton_quality)); auto plus_button = gtk_scale_button_get_plus_button(GTK_SCALE_BUTTON(priv->scalebutton_quality)); auto minus_button = gtk_scale_button_get_minus_button(GTK_SCALE_BUTTON(priv->scalebutton_quality)); gtk_widget_set_sensitive(GTK_WIDGET(scale), !auto_quality_on); gtk_widget_set_sensitive(plus_button, !auto_quality_on); gtk_widget_set_sensitive(minus_button, !auto_quality_on); double desired_quality = gtk_scale_button_get_value(GTK_SCALE_BUTTON(priv->scalebutton_quality)); if (priv->call) set_quality(priv->call, auto_quality_on, desired_quality); }
static gboolean cb_button_timeout (gpointer user_data) { GtkScaleButton *button; GtkScaleButtonPrivate *priv; GtkAdjustment *adj; gdouble val; gboolean res = TRUE; button = GTK_SCALE_BUTTON (user_data); priv = button->priv; if (priv->click_id == 0) return FALSE; adj = priv->adjustment; val = gtk_scale_button_get_value (button); val += priv->direction; if (val <= adj->lower) { res = FALSE; val = adj->lower; } else if (val > adj->upper) { res = FALSE; val = adj->upper; } gtk_scale_button_set_value (button, val); if (!res) { g_source_remove (priv->click_id); priv->click_id = 0; } return res; }
static void gtk_scale_button_update_icon (GtkScaleButton *button) { GtkScaleButtonPrivate *priv; GtkRange *range; GtkAdjustment *adj; gdouble value; const gchar *name; guint num_icons; priv = button->priv; if (!priv->icon_list || priv->icon_list[0] == '\0') { gtk_image_set_from_stock (GTK_IMAGE (priv->image), GTK_STOCK_MISSING_IMAGE, priv->size); return; } num_icons = g_strv_length (priv->icon_list); /* The 1-icon special case */ if (num_icons == 1) { gtk_image_set_from_icon_name (GTK_IMAGE (priv->image), priv->icon_list[0], priv->size); return; } range = GTK_RANGE (priv->scale); adj = priv->adjustment; value = gtk_scale_button_get_value (button); /* The 2-icons special case */ if (num_icons == 2) { gdouble limit; limit = (adj->upper - adj->lower) / 2 + adj->lower; if (value < limit) name = priv->icon_list[0]; else name = priv->icon_list[1]; gtk_image_set_from_icon_name (GTK_IMAGE (priv->image), name, priv->size); return; } /* With 3 or more icons */ if (value == adj->lower) { name = priv->icon_list[0]; } else if (value == adj->upper) { name = priv->icon_list[1]; } else { gdouble step; guint i; step = (adj->upper - adj->lower) / (num_icons - 2); i = (guint) ((value - adj->lower) / step) + 2; g_assert (i < num_icons); name = priv->icon_list[i]; } gtk_image_set_from_icon_name (GTK_IMAGE (priv->image), name, priv->size); }
gdouble pragha_toolbar_get_volume (PraghaToolbar *toolbar) { return gtk_scale_button_get_value (GTK_SCALE_BUTTON(toolbar->vol_button)); }
/** * Print the current value of a scale button. * @param scale_button scale button to print information about */ void mk_print_GtkScaleButton_info(GtkScaleButton* scale_button) { gdouble value = gtk_scale_button_get_value(scale_button); g_printf("\t%f", value); }
GValue* ghb_widget_value(GtkWidget *widget) { GValue *value = NULL; const gchar *name; GType type; if (widget == NULL) { g_debug("NULL widget\n"); return NULL; } type = G_OBJECT_TYPE(widget); name = ghb_get_setting_key(widget); g_debug("ghb_widget_value widget (%s)\n", name); if (type == GTK_TYPE_ENTRY) { const gchar *str = gtk_entry_get_text(GTK_ENTRY(widget)); value = ghb_string_value_new(str); } else if (type == GTK_TYPE_RADIO_BUTTON) { g_debug("\tradio_button"); gboolean bval; bval = gtk_toggle_button_get_inconsistent(GTK_TOGGLE_BUTTON(widget)); if (bval) { value = ghb_boolean_value_new(FALSE); } else { bval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)); value = ghb_boolean_value_new(bval); } } else if (type == GTK_TYPE_CHECK_BUTTON) { g_debug("\tcheck_button"); gboolean bval; bval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)); value = ghb_boolean_value_new(bval); } else if (type == GTK_TYPE_TOGGLE_TOOL_BUTTON) { g_debug("\ttoggle_tool_button"); gboolean bval; bval = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(widget)); value = ghb_boolean_value_new(bval); } else if (type == GTK_TYPE_TOGGLE_BUTTON) { g_debug("\ttoggle_button"); gboolean bval; bval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)); value = ghb_boolean_value_new(bval); } else if (type == GTK_TYPE_CHECK_MENU_ITEM) { g_debug("\tcheck_menu_item"); gboolean bval; bval = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget)); value = ghb_boolean_value_new(bval); } else if (type == GTK_TYPE_COMBO_BOX) { g_debug("\tcombo_box"); GtkTreeModel *store; GtkTreeIter iter; gchar *shortOpt; store = gtk_combo_box_get_model(GTK_COMBO_BOX(widget)); if (gtk_combo_box_get_active_iter(GTK_COMBO_BOX(widget), &iter)) { gtk_tree_model_get(store, &iter, 2, &shortOpt, -1); value = ghb_string_value_new(shortOpt); g_free(shortOpt); } else if (gtk_combo_box_get_has_entry(GTK_COMBO_BOX(widget))) { const gchar *str; str = gtk_entry_get_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(widget)))); if (str == NULL) str = ""; value = ghb_string_value_new(str); } else { value = ghb_string_value_new(""); } } else if (type == GTK_TYPE_SPIN_BUTTON) { gint ival; ival = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widget)); value = ghb_int64_value_new(ival); } else if (type == GTK_TYPE_SCALE) { gdouble dval; gint digits; digits = gtk_scale_get_digits(GTK_SCALE(widget)); dval = gtk_range_get_value(GTK_RANGE(widget)); if (digits) { value = ghb_double_value_new(dval); } else { value = ghb_int_value_new(dval); } } else if (type == GTK_TYPE_SCALE_BUTTON) { gdouble dval; dval = gtk_scale_button_get_value(GTK_SCALE_BUTTON(widget)); value = ghb_double_value_new(dval); } else if (type == GTK_TYPE_TEXT_VIEW) { GtkTextBuffer *buffer; GtkTextIter start, end; gchar *str; buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(widget)); gtk_text_buffer_get_bounds(buffer, &start, &end); str = gtk_text_buffer_get_text(buffer, &start, &end, FALSE); value = ghb_string_value_new(str); g_free(str); } else if (type == GTK_TYPE_LABEL) { const gchar *str; str = gtk_label_get_text (GTK_LABEL(widget)); value = ghb_string_value_new(str); } else if (type == GTK_TYPE_FILE_CHOOSER_BUTTON) { gchar *str = NULL; str = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER(widget)); if (str == NULL) { str = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(widget)); } value = ghb_string_value_new(str); if (str != NULL) g_free(str); } else { g_debug("Attempt to set unknown widget type: %s\n", name); g_free(value); value = NULL; } return value; }
static gboolean gtk_scale_popup (GtkWidget *widget, GdkEvent *event, guint32 time) { GtkScaleButton *button; GtkScaleButtonPrivate *priv; GtkAdjustment *adj; gint x, y, m, dx, dy, sx, sy, startoff; gdouble v; GdkDisplay *display; GdkScreen *screen; button = GTK_SCALE_BUTTON (widget); priv = button->priv; adj = priv->adjustment; display = gtk_widget_get_display (widget); screen = gtk_widget_get_screen (widget); /* position roughly */ gtk_window_set_screen (GTK_WINDOW (priv->dock), screen); gdk_window_get_origin (widget->window, &x, &y); x += widget->allocation.x; y += widget->allocation.y; if (priv->orientation == GTK_ORIENTATION_VERTICAL) gtk_window_move (GTK_WINDOW (priv->dock), x, y - (SCALE_SIZE / 2)); else gtk_window_move (GTK_WINDOW (priv->dock), x - (SCALE_SIZE / 2), y); gtk_widget_show_all (priv->dock); gdk_window_get_origin (priv->dock->window, &dx, &dy); dx += priv->dock->allocation.x; dy += priv->dock->allocation.y; gdk_window_get_origin (priv->scale->window, &sx, &sy); sx += priv->scale->allocation.x; sy += priv->scale->allocation.y; priv->timeout = TRUE; /* position (needs widget to be shown already) */ v = gtk_scale_button_get_value (button) / (adj->upper - adj->lower); if (priv->orientation == GTK_ORIENTATION_VERTICAL) { startoff = sy - dy; x += (widget->allocation.width - priv->dock->allocation.width) / 2; y -= startoff; y -= GTK_RANGE (priv->scale)->min_slider_size / 2; m = priv->scale->allocation.height - GTK_RANGE (priv->scale)->min_slider_size; y -= m * (1.0 - v); } else { startoff = sx - dx; x -= startoff; y += (widget->allocation.height - priv->dock->allocation.height) / 2; x -= GTK_RANGE (priv->scale)->min_slider_size / 2; m = priv->scale->allocation.width - GTK_RANGE (priv->scale)->min_slider_size; x -= m * v; } /* Make sure the dock stays inside the monitor */ if (event->type == GDK_BUTTON_PRESS) { int monitor; GdkEventButton *button_event = (GdkEventButton *) event; GdkRectangle rect; GtkWidget *d; d = GTK_WIDGET (priv->dock); monitor = gdk_screen_get_monitor_at_point (screen, button_event->x_root, button_event->y_root); gdk_screen_get_monitor_geometry (screen, monitor, &rect); if (priv->orientation == GTK_ORIENTATION_VERTICAL) y += button_event->y; else x += button_event->x; if (y < rect.y) y = rect.y; else if (y + d->allocation.height > rect.height + rect.y) y = rect.y + rect.height - d->allocation.height; if (x < rect.x) x = rect.x; else if (x + d->allocation.width > rect.width + rect.x) x = rect.x + rect.width - d->allocation.width; } gtk_window_move (GTK_WINDOW (priv->dock), x, y); if (event->type == GDK_BUTTON_PRESS) GTK_WIDGET_CLASS (gtk_scale_button_parent_class)->button_press_event (widget, (GdkEventButton *) event); /* grab focus */ gtk_grab_add (priv->dock); if (gdk_pointer_grab (priv->dock->window, TRUE, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK, NULL, NULL, time) != GDK_GRAB_SUCCESS) { gtk_grab_remove (priv->dock); gtk_widget_hide (priv->dock); return FALSE; } if (gdk_keyboard_grab (priv->dock->window, TRUE, time) != GDK_GRAB_SUCCESS) { gdk_display_pointer_ungrab (display, time); gtk_grab_remove (priv->dock); gtk_widget_hide (priv->dock); return FALSE; } gtk_widget_grab_focus (priv->dock); if (event->type == GDK_BUTTON_PRESS) { GdkEventButton *e; GdkEventButton *button_event = (GdkEventButton *) event; /* forward event to the slider */ e = (GdkEventButton *) gdk_event_copy ((GdkEvent *) event); e->window = priv->scale->window; /* position: the X position isn't relevant, halfway will work just fine. * The vertical position should be *exactly* in the middle of the slider * of the scale; if we don't do that correctly, it'll move from its current * position, which means a position change on-click, which is bad. */ if (priv->orientation == GTK_ORIENTATION_VERTICAL) { e->x = priv->scale->allocation.width / 2; m = priv->scale->allocation.height - GTK_RANGE (priv->scale)->min_slider_size; e->y = ((1.0 - v) * m) + GTK_RANGE (priv->scale)->min_slider_size / 2; } else { e->y = priv->scale->allocation.height / 2; m = priv->scale->allocation.width - GTK_RANGE (priv->scale)->min_slider_size; e->x = (v * m) + GTK_RANGE (priv->scale)->min_slider_size / 2; } gtk_widget_event (priv->scale, (GdkEvent *) e); e->window = button_event->window; gdk_event_free ((GdkEvent *) e); } gtk_widget_grab_focus (priv->scale); priv->pop_time = time; return TRUE; }
void control_window_status_update(MpdObj * mi, ChangedStatusType what, GtkWidget *base) { GtkWidget *volume_button, *progress, *play_image; /* Bail out of base == NULL */ if(base == NULL) return; /* Get the different subwidgets from the parent */ volume_button = g_object_get_data(G_OBJECT(base), "vol"); progress = g_object_get_data(G_OBJECT(base), "progress"); play_image = g_object_get_data(G_OBJECT(base), "play_image"); if (what & MPD_CST_STATE) { int state = mpd_player_get_state(mi); switch (state) { case MPD_PLAYER_PLAY: gtk_image_set_from_stock(GTK_IMAGE(play_image), "gtk-media-pause", GTK_ICON_SIZE_BUTTON); break; case MPD_PLAYER_PAUSE: gtk_image_set_from_stock(GTK_IMAGE(play_image), "gtk-media-play", GTK_ICON_SIZE_BUTTON); break; default: gtk_image_set_from_stock(GTK_IMAGE(play_image), "gtk-media-play", GTK_ICON_SIZE_BUTTON); /* Make sure it's reset correctly */ gmpc_progress_set_time(GMPC_PROGRESS(progress), 0, 0); } } if (what & MPD_CST_ELAPSED_TIME) { if (mpd_check_connected(connection)) { int totalTime = mpd_status_get_total_song_time(connection); int elapsedTime = mpd_status_get_elapsed_song_time(connection); gmpc_progress_set_time(GMPC_PROGRESS(progress), totalTime, elapsedTime); } else { gmpc_progress_set_time(GMPC_PROGRESS(progress), 0, 0); } } if (what & MPD_CST_VOLUME) { int volume = gtk_scale_button_get_value(GTK_SCALE_BUTTON(volume_button))*100; int new_volume = mpd_status_get_volume(connection); if (new_volume >= 0 && mpd_server_check_command_allowed(connection, "setvol") == MPD_SERVER_COMMAND_ALLOWED ) { gtk_widget_set_sensitive(volume_button, TRUE); /* don't do anything if nothing is changed */ if (new_volume != volume) { gtk_scale_button_set_value(GTK_SCALE_BUTTON(volume_button), new_volume/100.0); } } else { gtk_widget_set_sensitive(volume_button, FALSE); } } }