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