static void
ephy_push_scroller_scroll_pixels (EphyEmbed *embed, int scroll_x, int scroll_y)
{
GtkAdjustment *adj;
gdouble value;
gdouble new_value;
gdouble page_size;
gdouble upper;
gdouble lower;
GtkWidget *sw;
sw = gtk_widget_get_parent (GTK_WIDGET (ephy_embed_get_web_view (embed)));
g_return_if_fail (GTK_IS_SCROLLED_WINDOW (sw));
adj = gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (sw));
upper = gtk_adjustment_get_upper (adj);
lower = gtk_adjustment_get_lower (adj);
value = gtk_adjustment_get_value (adj);
page_size = gtk_adjustment_get_page_size (adj);
new_value = CLAMP (value - scroll_x, lower, upper - page_size);
gtk_adjustment_set_value (adj, new_value);
adj = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (sw));
upper = gtk_adjustment_get_upper (adj);
lower = gtk_adjustment_get_lower (adj);
value = gtk_adjustment_get_value (adj);
page_size = gtk_adjustment_get_page_size (adj);
new_value = CLAMP (value - scroll_y, lower, upper - page_size);
gtk_adjustment_set_value (adj, new_value);
}
static gboolean
bytes_view_scroll(GtkWidget *widget, GdkEventScroll *event)
{
BytesView *bv = BYTES_VIEW(widget);
gdouble new_value;
if (event->direction == GDK_SCROLL_UP) { /* mouse wheel pageUp */
bytes_view_ensure_vadj(bv);
new_value = gtk_adjustment_get_value(bv->vadj) - (gtk_adjustment_get_page_increment(bv->vadj) / 10);
if (new_value < gtk_adjustment_get_lower(bv->vadj))
new_value = gtk_adjustment_get_lower(bv->vadj);
gtk_adjustment_set_value(bv->vadj, new_value);
} else if (event->direction == GDK_SCROLL_DOWN) { /* mouse wheel pageDn */
bytes_view_ensure_vadj(bv);
new_value = gtk_adjustment_get_value(bv->vadj) + (gtk_adjustment_get_page_increment(bv->vadj) / 10);
if (new_value > (gtk_adjustment_get_upper(bv->vadj) - gtk_adjustment_get_page_size(bv->vadj)))
new_value = gtk_adjustment_get_upper(bv->vadj) - gtk_adjustment_get_page_size(bv->vadj);
gtk_adjustment_set_value(bv->vadj, new_value);
}
return FALSE;
}
static void
e_canvas_show_area (GnomeCanvas *canvas,
gdouble x1,
gdouble y1,
gdouble x2,
gdouble y2)
{
GtkAdjustment *h, *v;
gint dx = 0, dy = 0;
gdouble page_size;
gdouble lower;
gdouble upper;
gdouble value;
g_return_if_fail (canvas != NULL);
g_return_if_fail (GNOME_IS_CANVAS (canvas));
h = gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (canvas));
page_size = gtk_adjustment_get_page_size (h);
lower = gtk_adjustment_get_lower (h);
upper = gtk_adjustment_get_upper (h);
value = gtk_adjustment_get_value (h);
dx = compute_offset (x1, x2, value, value + page_size);
if (dx)
gtk_adjustment_set_value (h, CLAMP (value + dx, lower, upper - page_size));
v = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (canvas));
page_size = gtk_adjustment_get_page_size (v);
lower = gtk_adjustment_get_lower (v);
upper = gtk_adjustment_get_upper (v);
value = gtk_adjustment_get_value (v);
dy = compute_offset (y1, y2, value, value + page_size);
if (dy)
gtk_adjustment_set_value (v, CLAMP (value + dy, lower, upper - page_size));
}
static gboolean
cb_timeout (gpointer data)
{
MateVolumeAppletDock *dock = data;
GtkAdjustment *adj;
gfloat volume;
gboolean res = TRUE;
if (!dock->timeout)
return FALSE;
adj = gtk_range_get_adjustment (dock->scale);
volume = gtk_range_get_value (dock->scale);
volume += dock->direction * gtk_adjustment_get_step_increment (adj);
if (volume <= gtk_adjustment_get_lower (adj)) {
volume = gtk_adjustment_get_lower (adj);
res = FALSE;
} else if (volume >= gtk_adjustment_get_upper (adj)) {
volume = gtk_adjustment_get_upper (adj);
res = FALSE;
}
gtk_range_set_value (dock->scale, volume);
if (!res)
dock->timeout = 0;
return res;
}
static void
carrick_list_drag_motion (GtkWidget *widget,
GdkDragContext *context,
gint x,
gint y,
guint time,
CarrickList *list)
{
CarrickListPrivate *priv = list->priv;
int list_x, list_y;
int new_speed;
gtk_widget_translate_coordinates (widget, GTK_WIDGET (list),
x, y,
&list_x, &list_y);
if (gtk_adjustment_get_value (priv->adjustment) >
gtk_adjustment_get_lower (priv->adjustment) &&
list_y < FAST_SCROLL_BUFFER)
{
new_speed = -12;
}
else if (gtk_adjustment_get_value (priv->adjustment) >
gtk_adjustment_get_lower (priv->adjustment) &&
list_y < SCROLL_BUFFER)
{
new_speed = -5;
}
else if (gtk_adjustment_get_value (priv->adjustment) <
gtk_adjustment_get_upper (priv->adjustment) &&
GTK_WIDGET (list)->allocation.height - list_y < FAST_SCROLL_BUFFER)
{
new_speed = 12;
}
else if (gtk_adjustment_get_value (priv->adjustment) <
gtk_adjustment_get_upper (priv->adjustment) &&
GTK_WIDGET (list)->allocation.height - list_y < SCROLL_BUFFER)
{
new_speed = 5;
}
else
{
new_speed = 0;
}
if (new_speed != priv->scroll_speed)
{
priv->scroll_speed = new_speed;
if (priv->scroll_speed != 0)
{
if (priv->scroll_timeout_id > 0)
{
g_source_remove (priv->scroll_timeout_id);
}
priv->scroll_timeout_id = g_timeout_add
(40, (GSourceFunc) carrick_list_scroll, list);
}
}
}
gdouble _slider_translate_pos_to_value(GtkAdjustment *adj, GdkRectangle *value_area, gint x)
{
double value = 0;
double normrange = gtk_adjustment_get_upper(adj) - gtk_adjustment_get_lower(adj);
gint barwidth = value_area->width;
if(x > 0) value = (((double)x / (double)barwidth) * normrange);
value += gtk_adjustment_get_lower(adj);
return value;
}
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;
}
/*
* scroll vertical 20
* scroll vertical 20%
* scroll vertical -40
* scroll vertical 20!
* scroll vertical begin
* scroll vertical end
* scroll horizontal 10
* scroll horizontal -500
* scroll horizontal begin
* scroll horizontal end
*/
void
scroll_cmd(WebKitWebView* page, GArray *argv, GString *result) {
(void) page; (void) result;
gchar *direction = g_array_index(argv, gchar*, 0);
gchar *argv1 = g_array_index(argv, gchar*, 1);
GtkAdjustment *bar = NULL;
if (g_strcmp0(direction, "horizontal") == 0)
bar = uzbl.gui.bar_h;
else if (g_strcmp0(direction, "vertical") == 0)
bar = uzbl.gui.bar_v;
else {
if(uzbl.state.verbose)
puts("Unrecognized scroll format");
return;
}
if (g_strcmp0(argv1, "begin") == 0)
gtk_adjustment_set_value(bar, gtk_adjustment_get_lower(bar));
else if (g_strcmp0(argv1, "end") == 0)
gtk_adjustment_set_value (bar, gtk_adjustment_get_upper(bar) -
gtk_adjustment_get_page_size(bar));
else
scroll(bar, argv1);
}
static void
gnucash_register_update_hadjustment (GtkAdjustment *adj,
GnucashRegister *reg)
{
g_return_if_fail (reg != NULL);
g_return_if_fail (GNUCASH_IS_REGISTER(reg));
if (gtk_adjustment_get_upper (adj) - gtk_adjustment_get_lower (adj)
> gtk_adjustment_get_page_size (adj))
{
if (!reg->hscrollbar_visible)
{
gtk_widget_show(reg->hscrollbar);
reg->hscrollbar_visible = TRUE;
}
}
else
{
if (reg->hscrollbar_visible)
{
gtk_widget_hide(reg->hscrollbar);
reg->hscrollbar_visible = FALSE;
// When sheet first loaded and the scrollbar is hidden, the space left
// is not always automaticly taken up by the sheet so queue a resize
// when all is idle
g_idle_add ((GSourceFunc) gnucash_register_sheet_resize, reg);
}
}
}
static void
show_input_sources_for_locale (GtkWidget *chooser,
LocaleInfo *info)
{
CcInputChooserPrivate *priv = GET_PRIVATE (chooser);
set_fixed_size (chooser);
remove_all_children (GTK_CONTAINER (priv->list));
if (!info->back_row)
{
info->back_row = g_object_ref_sink (back_row_new (info->name));
g_object_set_data (G_OBJECT (info->back_row), "back", GINT_TO_POINTER (TRUE));
g_object_set_data (G_OBJECT (info->back_row), "locale-info", info);
}
gtk_container_add (GTK_CONTAINER (priv->list), GTK_WIDGET (info->back_row));
add_input_source_rows_for_locale (chooser, info);
gtk_widget_show_all (priv->list);
gtk_adjustment_set_value (priv->adjustment,
gtk_adjustment_get_lower (priv->adjustment));
gtk_list_box_set_header_func (GTK_LIST_BOX (priv->list), cc_list_box_update_header_func, NULL, NULL);
gtk_list_box_invalidate_filter (GTK_LIST_BOX (priv->list));
gtk_list_box_set_selection_mode (GTK_LIST_BOX (priv->list), GTK_SELECTION_SINGLE);
gtk_list_box_set_activate_on_single_click (GTK_LIST_BOX (priv->list), FALSE);
gtk_list_box_unselect_all (GTK_LIST_BOX (priv->list));
if (gtk_widget_is_visible (priv->filter_entry) &&
!gtk_widget_is_focus (priv->filter_entry))
gtk_widget_grab_focus (priv->filter_entry);
}
JNIEXPORT jdouble JNICALL
Java_org_gnome_gtk_GtkAdjustment_gtk_1adjustment_1get_1lower
(
JNIEnv* env,
jclass cls,
jlong _self
)
{
gdouble result;
jdouble _result;
GtkAdjustment* self;
// convert parameter self
self = (GtkAdjustment*) _self;
// call function
result = gtk_adjustment_get_lower(self);
// cleanup parameter self
// translate return value to JNI type
_result = (jdouble) result;
// and finally
return _result;
}
static void
show_filter_widgets (GtkWidget *chooser)
{
CcInputChooserPrivate *priv = GET_PRIVATE (chooser);
LocaleInfo *info;
GHashTableIter iter;
remove_all_children (GTK_CONTAINER (priv->list));
g_hash_table_iter_init (&iter, priv->locales);
while (g_hash_table_iter_next (&iter, NULL, (gpointer *) &info))
add_input_source_widgets_for_locale (chooser, info);
gtk_widget_show_all (priv->list);
gtk_adjustment_set_value (priv->adjustment,
gtk_adjustment_get_lower (priv->adjustment));
gtk_list_box_set_header_func (GTK_LIST_BOX (priv->list),
update_header_func_filter, NULL, NULL);
gtk_list_box_set_selection_mode (GTK_LIST_BOX (priv->list), GTK_SELECTION_SINGLE);
gtk_list_box_set_placeholder (GTK_LIST_BOX (priv->list), priv->no_results);
if (gtk_widget_is_visible (priv->filter_entry))
gtk_widget_grab_focus (priv->filter_entry);
}
void Scrollbar::setValue(int value) {
XOJ_CHECK_TYPE(Scrollbar);
if (value < gtk_adjustment_get_lower(this->adj)) {
value = gtk_adjustment_get_lower(this->adj);
}
if (value > getMax() - getPageSize()) {
value = getMax() - getPageSize();
}
gtk_adjustment_set_value(this->adj, value);
this->value = value;
gtk_widget_set_visible(this->getWidget(), this->getPageSize() < this->getMax());
}
static gboolean
carrick_list_scroll (CarrickList *list)
{
CarrickListPrivate *priv = list->priv;
gdouble val, page_size;
gboolean at_end;
val = gtk_adjustment_get_value (priv->adjustment);
page_size = gtk_adjustment_get_page_size (priv->adjustment);
if (priv->scroll_speed < 0)
{
at_end = val <= gtk_adjustment_get_lower (priv->adjustment);
}
else
{
at_end = val + page_size >= gtk_adjustment_get_upper (priv->adjustment);
}
if (!priv->drag_window ||
priv->scroll_speed == 0 ||
at_end)
{
priv->scroll_timeout_id = 0;
return FALSE;
}
gtk_adjustment_set_value (priv->adjustment,
val + priv->scroll_speed);
return TRUE;
}
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 gboolean
gwy_scroller_scroll_event(GtkWidget *widget,
GdkEventScroll *event)
{
Scroller *priv = GWY_SCROLLER(widget)->priv;
GtkOrientation orientation;
GtkAdjustment *adj;
if (event->direction == GDK_SCROLL_UP
|| event->direction == GDK_SCROLL_DOWN) {
adj = priv->vadjustment;
orientation = GTK_ORIENTATION_VERTICAL;
}
else {
adj = priv->hadjustment;
orientation = GTK_ORIENTATION_HORIZONTAL;
}
gdouble delta = gwy_scroll_wheel_delta(adj, event, orientation);
gdouble value = gtk_adjustment_get_value(adj),
lower = gtk_adjustment_get_lower(adj),
upper = gtk_adjustment_get_upper(adj),
page_size = gtk_adjustment_get_page_size(adj);
// Try to mimic scrollbars. Or, if scrollbars are present elsewhere and
// also connected, be consisten with them.
value = CLAMP(value + delta, lower, upper - page_size);
gtk_adjustment_set_value(adj, value);
return TRUE;
}
/**
* gs_shell_overview_switch_to:
**/
void
gs_shell_overview_switch_to (GsShellOverview *self, gboolean scroll_up)
{
GsShellOverviewPrivate *priv = gs_shell_overview_get_instance_private (self);
GtkWidget *widget;
GtkAdjustment *adj;
if (gs_shell_get_mode (priv->shell) != GS_SHELL_MODE_OVERVIEW) {
g_warning ("Called switch_to(overview) when in mode %s",
gs_shell_get_mode_string (priv->shell));
return;
}
widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "buttonbox_main"));
gtk_widget_show (widget);
widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "search_bar"));
gtk_widget_show (widget);
widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "entry_search"));
gtk_entry_set_text (GTK_ENTRY (widget), "");
if (scroll_up) {
adj = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (priv->scrolledwindow_overview));
gtk_adjustment_set_value (adj, gtk_adjustment_get_lower (adj));
}
gs_grab_focus_when_mapped (priv->scrolledwindow_overview);
if (priv->cache_valid || priv->refresh_count > 0)
return;
gs_shell_overview_load (self);
}
static gboolean
on_range_change_value (GtkRange *range,
GtkScrollType scroll,
gdouble value,
NimfCandidate *candidate)
{
g_debug (G_STRLOC ": %s", G_STRFUNC);
NimfEngine *engine = nimf_service_ic_get_engine (candidate->target);
g_return_val_if_fail (candidate->target && NIMF_IS_ENGINE (engine), FALSE);
NimfEngineClass *engine_class;
GtkAdjustment *adjustment;
gdouble lower, upper;
adjustment = gtk_range_get_adjustment (range);
lower = gtk_adjustment_get_lower (adjustment);
upper = gtk_adjustment_get_upper (adjustment);
if (value < lower)
value = lower;
if (value > upper - 1)
value = upper - 1;
engine_class = NIMF_ENGINE_GET_CLASS (engine);
if (engine_class->candidate_scrolled)
engine_class->candidate_scrolled (engine, candidate->target, value);
return FALSE;
}
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
dma_chunk_view_move_cursor (GtkTextView *text_view,
GtkMovementStep step,
gint count,
gboolean extend_selection)
{
DmaChunkView *view = DMA_CHUNK_VIEW (text_view);
GtkTextMark *mark;
GtkTextBuffer *buffer;
GtkTextIter cur;
gint line;
gdouble value, step_increment;
switch (step)
{
case GTK_MOVEMENT_LOGICAL_POSITIONS:
case GTK_MOVEMENT_VISUAL_POSITIONS:
case GTK_MOVEMENT_WORDS:
case GTK_MOVEMENT_DISPLAY_LINE_ENDS:
case GTK_MOVEMENT_HORIZONTAL_PAGES:
break;
case GTK_MOVEMENT_DISPLAY_LINES:
case GTK_MOVEMENT_PARAGRAPHS:
case GTK_MOVEMENT_PARAGRAPH_ENDS:
buffer = gtk_text_view_get_buffer (text_view);
mark = gtk_text_buffer_get_insert (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &cur, mark);
line = gtk_text_iter_get_line (&cur);
step_increment = gtk_adjustment_get_step_increment (view->vadjustment);
if ((count < 0) && (line == 0))
{
value += count * step_increment;
set_adjustment_clamped (view->vadjustment, value);
return;
}
else if ((count > 0) && (line == gtk_text_buffer_get_line_count(buffer) - 1))
{
value += count * step_increment;
set_adjustment_clamped (view->vadjustment, value);
return;
}
break;
case GTK_MOVEMENT_PAGES:
value += count * gtk_adjustment_get_page_increment (view->vadjustment);
set_adjustment_clamped (view->vadjustment, value);
return;
case GTK_MOVEMENT_BUFFER_ENDS:
set_adjustment_clamped (view->vadjustment,
count < 0 ? gtk_adjustment_get_lower (view->vadjustment) : gtk_adjustment_get_upper (view->vadjustment));
return;
default:
break;
}
GTK_TEXT_VIEW_CLASS (parent_class)->move_cursor (text_view,
step, count,
extend_selection);
}
gdouble nsgtk_adjustment_get_lower(GtkAdjustment *adjustment)
{
#if GTK_CHECK_VERSION(2,14,0)
return gtk_adjustment_get_lower(adjustment);
#else
return adjustment->lower;
#endif
}
/**
* 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,
gtk_adjustment_get_lower (adjustment)
+ (gtk_adjustment_get_upper (adjustment)
- gtk_adjustment_get_lower (adjustment)
- gtk_adjustment_get_page_size (adjustment))
* percentage * 0.01);
}
static void
start_cb (GtkMenuItem *item, GtkWidget *scrollbar)
{
GtkAdjustment *adj;
adj = gtk_range_get_adjustment (GTK_RANGE (scrollbar));
gtk_adjustment_set_value (adj, gtk_adjustment_get_lower (adj));
}
/* The standard gtk_adjustment_set_value ignores page size, which
* disagrees with the logic used by scroll bars, for example.
*/
void
eel_gtk_adjustment_set_value (GtkAdjustment *adjustment,
float value)
{
float upper_page_start, clamped_value;
g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
upper_page_start = MAX (gtk_adjustment_get_upper (adjustment) -
gtk_adjustment_get_page_size (adjustment),
gtk_adjustment_get_lower (adjustment));
clamped_value = CLAMP (value, gtk_adjustment_get_lower (adjustment), upper_page_start);
if (clamped_value != gtk_adjustment_get_value (adjustment))
{
gtk_adjustment_set_value (adjustment, clamped_value);
gtk_adjustment_value_changed (adjustment);
}
}
static void
gimp_prop_table_new_seed_clicked (GtkButton *button,
GtkAdjustment *adj)
{
guint32 value = g_random_int_range (gtk_adjustment_get_lower (adj),
gtk_adjustment_get_upper (adj));
gtk_adjustment_set_value (adj, value);
}
void
zathura_adjustment_set_value(GtkAdjustment* adjustment, gdouble value)
{
gtk_adjustment_set_value(adjustment,
MAX(gtk_adjustment_get_lower(adjustment),
MIN(gtk_adjustment_get_upper(adjustment) -
gtk_adjustment_get_page_size(adjustment),
value)));
}
gdouble
zathura_adjustment_get_ratio(GtkAdjustment* adjustment)
{
gdouble lower = gtk_adjustment_get_lower(adjustment);
gdouble upper = gtk_adjustment_get_upper(adjustment);
gdouble page_size = gtk_adjustment_get_page_size(adjustment);
gdouble value = gtk_adjustment_get_value(adjustment);
return (value - lower + page_size / 2.0) / (upper - lower);
}
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
gimp_scale_entry_exp_adjustment_callback (GtkAdjustment *adjustment,
GtkAdjustment *other_adj)
{
gdouble value;
g_signal_handlers_block_by_func (other_adj,
gimp_scale_entry_log_adjustment_callback,
adjustment);
value = exp (gtk_adjustment_get_value (adjustment));
if (gtk_adjustment_get_lower (other_adj) <= 0.0)
value += gtk_adjustment_get_lower (other_adj) - 0.1;
gtk_adjustment_set_value (other_adj, value);
g_signal_handlers_unblock_by_func (other_adj,
gimp_scale_entry_log_adjustment_callback,
adjustment);
}
void
carrick_list_clear_state (CarrickList *list)
{
CarrickListPrivate *priv = list->priv;
gtk_container_foreach (GTK_CONTAINER (priv->box),
(GtkCallback) _set_item_inactive,
NULL);
gtk_adjustment_set_value (priv->adjustment,
gtk_adjustment_get_lower (priv->adjustment));
}
