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);
}
}
}