static gboolean scrolled(GtkWidget *widget, GdkEventScroll *event) { GtkExperimentTranscript *trans = GTK_EXPERIMENT_TRANSCRIPT(widget); GtkAdjustment *adj; gdouble value, real_upper; if (trans->priv->time_adjustment == NULL) return FALSE; adj = GTK_ADJUSTMENT(trans->priv->time_adjustment); value = gtk_adjustment_get_value(adj); real_upper = gtk_adjustment_get_upper(adj) - gtk_adjustment_get_page_size(adj); switch (event->direction) { case GDK_SCROLL_UP: value -= gtk_adjustment_get_step_increment(adj); break; case GDK_SCROLL_DOWN: value += gtk_adjustment_get_step_increment(adj); default: break; } gtk_adjustment_set_value(adj, MIN(value, real_upper)); return TRUE; }
static gboolean _slider_button_press(GtkWidget *widget, GdkEventButton *event) { GtkAllocation allocation; gtk_widget_get_allocation(widget, &allocation); GtkDarktableSlider *slider=DTGTK_SLIDER(widget); if( event->button==3) { /* right mouse button, bring up the in place edit*/ char sv[32]= {0}; slider->is_entry_active=TRUE; gdouble value = gtk_adjustment_get_value(slider->adjustment); sprintf(sv,"%.*f",slider->digits,value); gtk_entry_set_text (GTK_ENTRY(slider->entry),sv); gtk_widget_show (GTK_WIDGET(slider->entry)); gtk_widget_grab_focus (GTK_WIDGET(slider->entry)); gtk_widget_queue_draw (widget); } else if (event->button == 1 && event->type == GDK_BUTTON_PRESS) { /* handle single button press */ if (event->x > (allocation.width - DTGTK_SLIDER_ADJUST_BUTTON_WIDTH - DTGTK_SLIDER_BORDER_WIDTH)) { /* press event in arrow up/down area of slider control*/ float value = gtk_adjustment_get_value(slider->adjustment); if (event->y > (allocation.height/2.0)) value -= gtk_adjustment_get_step_increment(slider->adjustment); else value += gtk_adjustment_get_step_increment(slider->adjustment); if(slider->snapsize) value = slider->snapsize * (((int)value)/slider->snapsize); gtk_adjustment_set_value(slider->adjustment, value); gtk_widget_queue_draw(widget); g_signal_emit_by_name(G_OBJECT(widget),"value-changed"); } else { slider->is_dragging=TRUE; slider->prev_x_root=event->x_root; if( slider->type==DARKTABLE_SLIDER_BAR) slider->is_changed=TRUE; #if 0 // Deprecate g_timeout_add(DTGTK_SLIDER_VALUE_CHANGED_DELAY, _slider_postponed_value_change, widget); #endif } } else if(event->button == 1 && event->type == GDK_2BUTTON_PRESS) { if(event->x < slider->labelwidth && event->y < slider->labelheight) { /* left mouse second click of doubleclick event */ slider->is_dragging=FALSE; // otherwise button_release will overwrite our changes gtk_adjustment_set_value(slider->adjustment, slider->default_value); gtk_widget_queue_draw(widget); g_signal_emit_by_name(G_OBJECT(widget),"value-changed"); } } return TRUE; }
gboolean gtk_vscrollbutton_scroll(GtkVScrollbutton *scrollbutton) { gfloat bound; gfloat new_value; gfloat page_size; gfloat value; gboolean return_val; cm_return_val_if_fail(scrollbutton != NULL, FALSE); cm_return_val_if_fail(GTK_IS_VSCROLLBUTTON(scrollbutton), FALSE); new_value = value = gtk_adjustment_get_value(scrollbutton->adjustment); return_val = TRUE; switch (scrollbutton->scroll_type) { case GTK_SCROLL_STEP_BACKWARD: new_value = value - gtk_adjustment_get_step_increment(scrollbutton->adjustment); bound = gtk_adjustment_get_lower(scrollbutton->adjustment); if (new_value <= bound) { new_value = bound; return_val = FALSE; scrollbutton->timer = 0; } break; case GTK_SCROLL_STEP_FORWARD: new_value = value + gtk_adjustment_get_step_increment(scrollbutton->adjustment); bound = gtk_adjustment_get_upper(scrollbutton->adjustment); page_size = gtk_adjustment_get_page_size(scrollbutton->adjustment); if (new_value >= (bound - page_size)) { new_value = bound - page_size; return_val = FALSE; scrollbutton->timer = 0; } break; default: break; } if (new_value != value) { gtk_adjustment_set_value(scrollbutton->adjustment, new_value); g_signal_emit_by_name(G_OBJECT (scrollbutton->adjustment), "value_changed"); gtk_widget_queue_resize(GTK_WIDGET(scrollbutton)); /* ensure resize */ } return return_val; }
JNIEXPORT jdouble JNICALL Java_org_gnome_gtk_GtkAdjustment_gtk_1adjustment_1get_1step_1increment ( JNIEnv* env, jclass cls, jlong _self ) { gdouble result; jdouble _result; GtkAdjustment* self; // convert parameter self self = (GtkAdjustment*) _self; // call function result = gtk_adjustment_get_step_increment(self); // cleanup parameter self // translate return value to JNI type _result = (jdouble) result; // and finally return _result; }
static void dma_sparse_view_synchronize_iter (DmaSparseView *view, DmaSparseIter *iter) { gdouble dist; gdouble pos; /* Need to change iterator according to adjustment */ pos = gtk_adjustment_get_value (view->priv->vadjustment); dist = pos - (gdouble)dma_sparse_iter_get_address (iter); if (dist != 0) { gdouble page_size = gtk_adjustment_get_page_size (view->priv->vadjustment); if ((dist < 4.0 * page_size) && (dist > -4.0 * page_size)) { gint count = (gint) (dist / gtk_adjustment_get_step_increment (view->priv->vadjustment)); dma_sparse_iter_forward_lines (iter, count); } else { dma_sparse_iter_move_at (iter, pos); dma_sparse_iter_round (iter, FALSE); } gtk_adjustment_set_value (view->priv->vadjustment, (gdouble)dma_sparse_iter_get_address (iter)); } }
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 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_step_increment(GtkAdjustment *adjustment) { #if GTK_CHECK_VERSION(2,14,0) return gtk_adjustment_get_step_increment(adjustment); #else return adjustment->step_increment; #endif }
void scroll(Client *c, const Arg *arg) { gdouble v; GtkAdjustment *a; a = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(c->scroll)); v = gtk_adjustment_get_value(a); v += gtk_adjustment_get_step_increment(a) * arg->i; v = MAX(v, 0.0); v = MIN(v, gtk_adjustment_get_upper(a) - gtk_adjustment_get_page_size(a)); gtk_adjustment_set_value(a, v); }
GtkAdjustment* zathura_adjustment_clone(GtkAdjustment* adjustment) { gdouble value = gtk_adjustment_get_value(adjustment); gdouble lower = gtk_adjustment_get_lower(adjustment); gdouble upper = gtk_adjustment_get_upper(adjustment); gdouble step_increment = gtk_adjustment_get_step_increment(adjustment); gdouble page_increment = gtk_adjustment_get_page_increment(adjustment); gdouble page_size = gtk_adjustment_get_page_size(adjustment); return GTK_ADJUSTMENT(gtk_adjustment_new(value, lower, upper, step_increment, page_increment, page_size)); }
static gboolean _slider_scroll_event(GtkWidget *widget, GdkEventScroll *event) { double inc=gtk_adjustment_get_step_increment(DTGTK_SLIDER(widget)->adjustment); DTGTK_SLIDER(widget)->is_sensibility_key_pressed = (event->state&GDK_CONTROL_MASK)?TRUE:FALSE; inc*= (DTGTK_SLIDER(widget)->is_sensibility_key_pressed==TRUE) ? 1.0 : DTGTK_VALUE_SENSITIVITY; float value = gtk_adjustment_get_value( DTGTK_SLIDER(widget)->adjustment ) + ((event->direction == GDK_SCROLL_UP || event->direction == GDK_SCROLL_RIGHT)?inc:-inc); if(DTGTK_SLIDER(widget)->snapsize) value = DTGTK_SLIDER(widget)->snapsize * (((int)value)/DTGTK_SLIDER(widget)->snapsize); gtk_adjustment_set_value(DTGTK_SLIDER(widget)->adjustment, value); gtk_widget_queue_draw(widget); g_signal_emit_by_name(G_OBJECT(widget),"value-changed"); return TRUE; }
static gboolean slider_decrease_callback(GtkAccelGroup *accel_group, GObject *acceleratable, guint keyval, GdkModifierType modifier, gpointer data) { GtkDarktableSlider *slider=DTGTK_SLIDER(data); float value = gtk_adjustment_get_value(slider->adjustment); value -= gtk_adjustment_get_step_increment(slider->adjustment); if(slider->snapsize) value = slider->snapsize * (((int)value)/slider->snapsize); gtk_adjustment_set_value(slider->adjustment, value); gtk_widget_draw(GTK_WIDGET(slider),NULL); g_signal_emit_by_name(G_OBJECT(slider),"value-changed"); return TRUE; }
static gboolean _slider_motion_notify(GtkWidget *widget, GdkEventMotion *event) { GtkDarktableSlider *slider = DTGTK_SLIDER(widget); slider->is_sensibility_key_pressed = (event->state & GDK_CONTROL_MASK) ? TRUE : FALSE; if(slider->is_dragging == TRUE) { // First get some dimension info GdkRectangle vr; _slider_get_value_area(widget, &vr); if((slider->prev_x_root < (gint)event->x_root)) slider->motion_direction = 1; else if(slider->prev_x_root > (gint)event->x_root) slider->motion_direction = -1; // Adjust rect to match dimensions for bar vr.x += DTGTK_SLIDER_BORDER_WIDTH * 2; vr.width -= (DTGTK_SLIDER_BORDER_WIDTH * 4); gint vmx = event->x - vr.x; if(slider->type == DARKTABLE_SLIDER_VALUE || (slider->type == DARKTABLE_SLIDER_BAR && slider->is_sensibility_key_pressed == TRUE)) { gdouble inc = gtk_adjustment_get_step_increment(slider->adjustment); if(DARKTABLE_SLIDER_VALUE && !slider->is_sensibility_key_pressed) inc *= DTGTK_VALUE_SENSITIVITY; gdouble value = gtk_adjustment_get_value(slider->adjustment) + (((slider->prev_x_root <= (gint)event->x_root) && slider->motion_direction == 1) ? (inc) : -(inc)); if(slider->snapsize) value = slider->snapsize * (((int)value) / slider->snapsize); gtk_adjustment_set_value(slider->adjustment, value); slider->is_changed = TRUE; } else if(slider->type == DARKTABLE_SLIDER_BAR) { if(vmx >= 0 && vmx <= vr.width) { float value = _slider_translate_pos_to_value(slider->adjustment, &vr, vmx); if(slider->snapsize) value = slider->snapsize * (((int)value) / slider->snapsize); gtk_adjustment_set_value(slider->adjustment, value); } } g_signal_emit_by_name(G_OBJECT(widget), "value-changed"); gtk_widget_queue_draw(widget); slider->prev_x_root = event->x_root; } return FALSE; }
gboolean mouse_handle_scroll_event(GtkWidget *widget, GdkEventScroll *event) { // handle zoom events // propagate everything except control modifier if (event->direction == GDK_SCROLL_UP) { if (event->state == 0) { // no modifiers // move up //canvas_move(widget, 0.0, -1*vscroll->step_increment); canvas_move(widget, 0.0, -1*gtk_adjustment_get_step_increment(vscroll)); } else if (event->state == GDK_SHIFT_MASK) { // shift modifier // move left canvas_move(widget, -1*gtk_adjustment_get_step_increment(hscroll), 0.0); } else if (event->state == GDK_CONTROL_MASK) { // ctrl modifier // zoom in zoom_in(widget, true); } } else if (event->direction == GDK_SCROLL_DOWN) { if (event->state == 0) { // move down canvas_move(widget, 0.0, gtk_adjustment_get_step_increment(vscroll)); } else if (event->state == GDK_SHIFT_MASK) { // shift modifier // move right canvas_move(widget, gtk_adjustment_get_step_increment(hscroll), 0.0); } else if (event->state == GDK_CONTROL_MASK) { // ctrl modifier // zoom out zoom_out(widget, true); } } else if (event->direction == GDK_SCROLL_LEFT) { canvas_move(widget, -1*gtk_adjustment_get_step_increment(hscroll), 0.0); } else if (event->direction == GDK_SCROLL_RIGHT) { canvas_move(widget, gtk_adjustment_get_step_increment(hscroll), 0.0); } return TRUE; }
static void on_slider_changed(GtkRange *range, gpointer data) { struct gtk_common_data *mdata = data; GtkAdjustment *adj = gtk_range_get_adjustment(GTK_RANGE(mdata->widget)); struct sol_irange val; val.val = gtk_range_get_value(GTK_RANGE(mdata->widget)); val.min = (int)gtk_adjustment_get_lower(adj); val.max = (int)gtk_adjustment_get_upper(adj); val.step = (int)gtk_adjustment_get_step_increment(adj); sol_flow_send_irange_packet(mdata->node, SOL_FLOW_NODE_TYPE_GTK_SLIDER__OUT__OUT, &val); }
static GtkAdjustment * scaled_adjustment (GtkAdjustment *a, gdouble scale) { GtkAdjustment *as; as = gtk_adjustment_new (gtk_adjustment_get_value (a) * scale, gtk_adjustment_get_lower (a) * scale, gtk_adjustment_get_upper (a) * scale, gtk_adjustment_get_step_increment (a) * scale, gtk_adjustment_get_page_increment (a) * scale, gtk_adjustment_get_page_size (a) * scale); g_signal_connect (a, "value-changed", G_CALLBACK (value_changed), as); g_signal_connect (as, "value-changed", G_CALLBACK (value_changed), a); return as; }
static void scroll_lines (WebKitWebView *web_view, int num_lines) { #ifdef HAVE_WEBKIT2 /* TODO: Scroll API? */ #else GtkScrolledWindow *scrolled_window; GtkAdjustment *vadj; gdouble value; scrolled_window = GTK_SCROLLED_WINDOW (gtk_widget_get_parent (GTK_WIDGET (web_view))); vadj = gtk_scrolled_window_get_vadjustment (scrolled_window); value = gtk_adjustment_get_value (vadj) + (num_lines * gtk_adjustment_get_step_increment (vadj)); gtk_adjustment_set_value (vadj, value); #endif }
double Scrollbar::getWheelDelta(GdkScrollDirection direction) { double delta; GtkRange * range = GTK_RANGE(this->scrollbar); if (GTK_IS_SCROLLBAR(range)) { delta = pow(gtk_adjustment_get_page_size(this->adj), 2.0 / 3.0); } else { delta = gtk_adjustment_get_step_increment(this->adj) * 2; } if (direction == GDK_SCROLL_UP || direction == GDK_SCROLL_LEFT) { delta = -delta; } if (gtk_range_get_inverted(range)) { delta = -delta; } return delta; }
void view_scroll_vertical_cmd_callback (GtkAction *action, gint value, gpointer data) { GimpDisplayShell *shell; gdouble offset; return_if_no_shell (shell, data); offset = action_select_value ((GimpActionSelectType) value, gtk_adjustment_get_value (shell->vsbdata), gtk_adjustment_get_lower (shell->vsbdata), gtk_adjustment_get_upper (shell->vsbdata) - gtk_adjustment_get_page_size (shell->vsbdata), gtk_adjustment_get_lower (shell->vsbdata), 1, gtk_adjustment_get_step_increment (shell->vsbdata), gtk_adjustment_get_page_increment (shell->vsbdata), 0, FALSE); gtk_adjustment_set_value (shell->vsbdata, offset); }
G_MODULE_EXPORT void x264_slider_changed_cb(GtkWidget *widget, signal_user_data_t *ud) { ghb_widget_to_setting(ud->x264_priv, widget); // Lock slider values to multiples of step_increment GtkAdjustment * adj = gtk_range_get_adjustment(GTK_RANGE(widget)); gdouble step = gtk_adjustment_get_step_increment(adj); gdouble val = gtk_range_get_value(GTK_RANGE(widget)); gdouble new_val = ((int)((val + step / 2) / step)) * step; gdouble diff = val - new_val; if ( diff > 0.0001 || diff < -0.0001 ) { gtk_range_set_value(GTK_RANGE(widget), new_val); } else if (!ignore_options_update) { ignore_options_update = TRUE; x264_opt_update(ud, widget); ignore_options_update = FALSE; } ghb_check_dependency(ud, widget, NULL); ghb_clear_presets_selection(ud); }
static gboolean gwy_scroller_scroll_child(GwyScroller *scroller, GtkScrollType scroll, gboolean horizontal) { Scroller *priv = scroller->priv; switch (scroll) { case GTK_SCROLL_STEP_UP: scroll = GTK_SCROLL_STEP_BACKWARD; horizontal = FALSE; break; case GTK_SCROLL_STEP_DOWN: scroll = GTK_SCROLL_STEP_FORWARD; horizontal = FALSE; break; case GTK_SCROLL_STEP_LEFT: scroll = GTK_SCROLL_STEP_BACKWARD; horizontal = TRUE; break; case GTK_SCROLL_STEP_RIGHT: scroll = GTK_SCROLL_STEP_FORWARD; horizontal = TRUE; break; case GTK_SCROLL_PAGE_UP: scroll = GTK_SCROLL_PAGE_BACKWARD; horizontal = FALSE; break; case GTK_SCROLL_PAGE_DOWN: scroll = GTK_SCROLL_PAGE_FORWARD; horizontal = FALSE; break; case GTK_SCROLL_PAGE_LEFT: scroll = GTK_SCROLL_STEP_BACKWARD; horizontal = TRUE; break; case GTK_SCROLL_PAGE_RIGHT: scroll = GTK_SCROLL_STEP_FORWARD; horizontal = TRUE; break; case GTK_SCROLL_STEP_BACKWARD: case GTK_SCROLL_STEP_FORWARD: case GTK_SCROLL_PAGE_BACKWARD: case GTK_SCROLL_PAGE_FORWARD: case GTK_SCROLL_START: case GTK_SCROLL_END: break; default: g_warning("Invalid scroll type %u for GwyScroller::scroll-child", scroll); return FALSE; } GtkAdjustment *adjustment = (horizontal ? priv->hadjustment : priv->vadjustment); gdouble value = gtk_adjustment_get_value(adjustment); switch (scroll) { case GTK_SCROLL_STEP_FORWARD: value += gtk_adjustment_get_step_increment(adjustment); break; case GTK_SCROLL_STEP_BACKWARD: value -= gtk_adjustment_get_step_increment(adjustment); break; case GTK_SCROLL_PAGE_FORWARD: value += gtk_adjustment_get_page_increment(adjustment); break; case GTK_SCROLL_PAGE_BACKWARD: value -= gtk_adjustment_get_page_increment(adjustment); break; case GTK_SCROLL_START: value = gtk_adjustment_get_lower(adjustment); break; case GTK_SCROLL_END: value = gtk_adjustment_get_upper(adjustment); break; default: g_assert_not_reached(); break; } gtk_adjustment_set_value(adjustment, value); return TRUE; }
/** * gimp_scale_entry_set_logarithmic: * @adjustment: a #GtkAdjustment as returned by gimp_scale_entry_new() * @logarithmic: a boolean value to set or reset logarithmic behaviour * of the scale widget * * Sets whether the scale_entry's scale widget will behave in a linear * or logharithmic fashion. Useful when an entry has to attend large * ranges, but smaller selections on that range require a finer * adjustment. * * Since: GIMP 2.2 **/ void gimp_scale_entry_set_logarithmic (GtkObject *adjustment, gboolean logarithmic) { GtkAdjustment *adj; GtkAdjustment *scale_adj; g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment)); adj = GTK_ADJUSTMENT (adjustment); scale_adj = GIMP_SCALE_ENTRY_SCALE_ADJ (adjustment); if (logarithmic == gimp_scale_entry_get_logarithmic (adjustment)) return; if (logarithmic) { gdouble correction; gdouble log_value, log_lower, log_upper; gdouble log_step_increment, log_page_increment; correction = (gtk_adjustment_get_lower (scale_adj) > 0 ? 0 : 0.1 + - gtk_adjustment_get_lower (scale_adj)); log_value = log (gtk_adjustment_get_value (scale_adj) + correction); log_lower = log (gtk_adjustment_get_lower (scale_adj) + correction); log_upper = log (gtk_adjustment_get_upper (scale_adj) + correction); log_step_increment = (log_upper - log_lower) / ((gtk_adjustment_get_upper (scale_adj) - gtk_adjustment_get_lower (scale_adj)) / gtk_adjustment_get_step_increment (scale_adj)); log_page_increment = (log_upper - log_lower) / ((gtk_adjustment_get_upper (scale_adj) - gtk_adjustment_get_lower (scale_adj)) / gtk_adjustment_get_page_increment (scale_adj)); if (scale_adj == adj) { GtkObject *new_adj; new_adj = gtk_adjustment_new (gtk_adjustment_get_value (scale_adj), gtk_adjustment_get_lower (scale_adj), gtk_adjustment_get_upper (scale_adj), gtk_adjustment_get_step_increment (scale_adj), gtk_adjustment_get_page_increment (scale_adj), 0.0); gtk_range_set_adjustment (GTK_RANGE (GIMP_SCALE_ENTRY_SCALE (adj)), GTK_ADJUSTMENT (new_adj)); scale_adj = (GtkAdjustment *) new_adj; } else { g_signal_handlers_disconnect_by_func (adj, gimp_scale_entry_unconstrained_adjustment_callback, scale_adj); g_signal_handlers_disconnect_by_func (scale_adj, gimp_scale_entry_unconstrained_adjustment_callback, adj); } gtk_adjustment_configure (scale_adj, log_value, log_lower, log_upper, log_step_increment, log_page_increment, 0.0); g_signal_connect (scale_adj, "value-changed", G_CALLBACK (gimp_scale_entry_exp_adjustment_callback), adj); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_scale_entry_log_adjustment_callback), scale_adj); g_object_set_data (G_OBJECT (adjustment), "logarithmic", GINT_TO_POINTER (TRUE)); } else { gdouble lower, upper; g_signal_handlers_disconnect_by_func (adj, gimp_scale_entry_log_adjustment_callback, scale_adj); g_signal_handlers_disconnect_by_func (scale_adj, gimp_scale_entry_exp_adjustment_callback, adj); lower = exp (gtk_adjustment_get_lower (scale_adj)); upper = exp (gtk_adjustment_get_upper (scale_adj)); if (gtk_adjustment_get_lower (adj) <= 0.0) { lower += - 0.1 + gtk_adjustment_get_lower (adj); upper += - 0.1 + gtk_adjustment_get_lower (adj); } gtk_adjustment_configure (scale_adj, gtk_adjustment_get_value (adj), lower, upper, gtk_adjustment_get_step_increment (adj), gtk_adjustment_get_page_increment (adj), 0.0); g_signal_connect (scale_adj, "value-changed", G_CALLBACK (gimp_scale_entry_unconstrained_adjustment_callback), adj); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_scale_entry_unconstrained_adjustment_callback), scale_adj); g_object_set_data (G_OBJECT (adjustment), "logarithmic", GINT_TO_POINTER (FALSE)); } }
static gboolean on_auto_scroll(gpointer user_data) { FmDndAutoScroll* as = (FmDndAutoScroll*)user_data; int x, y; GtkAdjustment* va = as->vadj; GtkAdjustment* ha = as->hadj; GtkWidget* widget = as->widget; GtkAllocation allocation; gdk_window_get_device_position (gtk_widget_get_window(widget), gtk_get_current_event_device(), &x, &y, NULL); gtk_widget_get_allocation(widget, &allocation); /* HACK. Sometimes we do not get drag-leave signal. (Why?) This check prevents infinite scrolling. */ if (y < 0 || y > allocation.height || x < 0 || x > allocation.width) { as->timeout = 0; return FALSE; } if(va) { if(y < SCROLL_EDGE_SIZE) /* scroll up */ { gdouble value = gtk_adjustment_get_value(va); gdouble lower = gtk_adjustment_get_lower(va); if(value > lower) { value -= gtk_adjustment_get_step_increment(va); if(value < lower) value = lower; gtk_adjustment_set_value(va, value); } } else if(y > (allocation.height - SCROLL_EDGE_SIZE)) { gdouble value = gtk_adjustment_get_value(va); gdouble upper = gtk_adjustment_get_upper(va) - gtk_adjustment_get_page_size(va); /* scroll down */ if(value < upper) { value += gtk_adjustment_get_step_increment(va); if(value > upper) value = upper; gtk_adjustment_set_value(va, value); } } gtk_adjustment_value_changed(va); } if(ha) { if(x < SCROLL_EDGE_SIZE) /* scroll to left */ { gdouble value = gtk_adjustment_get_value(ha); gdouble lower = gtk_adjustment_get_lower(ha); if(value > lower) { value -= gtk_adjustment_get_step_increment(ha); if(value < lower) value = lower; gtk_adjustment_set_value(ha, value); } } else if(x > (allocation.width - SCROLL_EDGE_SIZE)) { gdouble value = gtk_adjustment_get_value(ha); gdouble upper = gtk_adjustment_get_upper(ha) - gtk_adjustment_get_page_size(ha); /* scroll to right */ if(value < upper) { value += gtk_adjustment_get_step_increment(ha); if(value > upper) value = upper; gtk_adjustment_set_value(ha, value); } } gtk_adjustment_value_changed(ha); } return TRUE; }
int wxSlider::GetLineSize() const { GtkAdjustment* adj = gtk_range_get_adjustment(GTK_RANGE(m_scale)); return int(gtk_adjustment_get_step_increment(adj)); }
static gint moz_gtk_scrollbar_thumb_paint(GtkThemeWidgetType widget, GdkDrawable* drawable, GdkRectangle* rect, GdkRectangle* cliprect, GtkWidgetState* state, GtkTextDirection direction) { GtkStateType state_type = (state->inHover || state->active) ? GTK_STATE_PRELIGHT : GTK_STATE_NORMAL; GtkShadowType shadow_type = GTK_SHADOW_OUT; GtkStyle* style; GtkScrollbar *scrollbar; GtkAdjustment *adj; gboolean activate_slider; ensure_scrollbar_widget(); if (widget == MOZ_GTK_SCROLLBAR_THUMB_HORIZONTAL) scrollbar = GTK_SCROLLBAR(gParts->horizScrollbarWidget); else scrollbar = GTK_SCROLLBAR(gParts->vertScrollbarWidget); gtk_widget_set_direction(GTK_WIDGET(scrollbar), direction); /* Make sure to set the scrollbar range before painting so that everything is drawn properly. At least the bluecurve (and maybe other) themes don't draw the top or bottom black line surrounding the scrollbar if the theme thinks that it's butted up against the scrollbar arrows. Note the increases of the clip rect below. */ /* Changing the cliprect is pretty bogus. This lets themes draw outside the frame, which means we don't invalidate them correctly. See bug 297508. But some themes do seem to need it. So we modify the frame's overflow area to account for what we're doing here; see nsNativeThemeGTK::GetWidgetOverflow. */ adj = gtk_range_get_adjustment(GTK_RANGE(scrollbar)); if (widget == MOZ_GTK_SCROLLBAR_THUMB_HORIZONTAL) { cliprect->x -= 1; cliprect->width += 2; gtk_adjustment_set_page_size(adj, rect->width); } else { cliprect->y -= 1; cliprect->height += 2; gtk_adjustment_set_page_size(adj, rect->height); } #if GTK_CHECK_VERSION(2, 14, 0) gtk_adjustment_configure(adj, state->curpos, 0, state->maxpos, gtk_adjustment_get_step_increment(adj), gtk_adjustment_get_page_increment(adj), gtk_adjustment_get_page_size(adj)); #else adj->lower = 0; adj->value = state->curpos; adj->upper = state->maxpos; gtk_adjustment_changed(adj); #endif style = gtk_widget_get_style(GTK_WIDGET(scrollbar)); gtk_widget_style_get(GTK_WIDGET(scrollbar), "activate-slider", &activate_slider, NULL); if (activate_slider && state->active) { shadow_type = GTK_SHADOW_IN; state_type = GTK_STATE_ACTIVE; } TSOffsetStyleGCs(style, rect->x, rect->y); gtk_paint_slider(style, drawable, state_type, shadow_type, cliprect, GTK_WIDGET(scrollbar), "slider", rect->x, rect->y, rect->width, rect->height, (widget == MOZ_GTK_SCROLLBAR_THUMB_HORIZONTAL) ? GTK_ORIENTATION_HORIZONTAL : GTK_ORIENTATION_VERTICAL); return MOZ_GTK_SUCCESS; }