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