brl/gnome-shell
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
524e2ca8e2
gnome-shell/src/st/st-scroll-bar.c
Owen W. Taylor 524e2ca8e2 [StScrollBar] avoid queueing a relayout during allocation 
When an StScrollView is allocated, allocating the child would
cause the adjustment values to change, which would result in
the scrollbars queueing a relayout, which isn't allowed during
allocation.

To avoid this, instead of queueing a relayout when the adjustment
changes:

 - When we have a valid allocation already, just go ahead
   and reallocate the children.
 - Otherwise do nothing immediately and wait until we get allocated

Because the 'needs_allocation' flag in ClutterActor isn't exposed,
this requires some slightly ugly code to shadow that state locally.

https://bugzilla.gnome.org/show_bug.cgi?id=611944
2010-03-11 15:08:48 -05:00

1190 lines
35 KiB
C
Raw Blame History

/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
/*
* st-scroll-bar.c: Scroll bar actor
*
* Copyright 2008 OpenedHand
* Copyright 2009 Intel Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU Lesser General Public License,
* version 2.1, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT ANY
* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for
* more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
*
* Written by: Chris Lord <chris@openedhand.com>
* Port to St by: Robert Staudinger <robsta@openedhand.com>
*
*/
/**
* SECTION:st-scroll-bar
* @short_description: a user interface element to control scrollable areas.
*
* The #StScrollBar allows users to scroll scrollable actors, either by
* the step or page amount, or by manually dragging the handle.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <clutter/clutter.h>
#include "st-scroll-bar.h"
#include "st-bin.h"
#include "st-marshal.h"
#include "st-enum-types.h"
#include "st-private.h"
#include "st-button.h"
G_DEFINE_TYPE (StScrollBar, st_scroll_bar, ST_TYPE_BIN)
#define ST_SCROLL_BAR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), ST_TYPE_SCROLL_BAR, StScrollBarPrivate))
#define PAGING_INITIAL_REPEAT_TIMEOUT 500
#define PAGING_SUBSEQUENT_REPEAT_TIMEOUT 200
struct _StScrollBarPrivate
{
StAdjustment *adjustment;
gulong capture_handler;
gfloat x_origin;
gfloat y_origin;
ClutterActor *bw_stepper;
ClutterActor *fw_stepper;
ClutterActor *trough;
ClutterActor *handle;
gfloat move_x;
gfloat move_y;
/* Trough-click handling. */
enum { NONE, UP, DOWN } paging_direction;
guint paging_source_id;
guint paging_event_no;
gboolean stepper_forward;
guint stepper_source_id;
ClutterAnimation *paging_animation;
guint vertical : 1;
/* We want to keep track of whether we have a currently valid
* allocation or not. This isn't exported from ClutterActor
* so we need to shadow the computations and track it ourselves.
*
* http://bugzilla.openedhand.com/show_bug.cgi?id=2024
*/
guint needs_allocation : 1;
};
enum
{
PROP_0,
PROP_ADJUSTMENT,
PROP_VERTICAL
};
enum
{
SCROLL_START,
SCROLL_STOP,
LAST_SIGNAL
};
static guint signals[LAST_SIGNAL] = { 0, };
static gboolean
handle_button_press_event_cb (ClutterActor *actor,
ClutterButtonEvent *event,
StScrollBar *bar);
static void
st_scroll_bar_get_property (GObject *gobject,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
StScrollBarPrivate *priv = ST_SCROLL_BAR (gobject)->priv;
switch (prop_id)
{
case PROP_ADJUSTMENT:
g_value_set_object (value, priv->adjustment);
break;
case PROP_VERTICAL:
g_value_set_boolean (value, priv->vertical);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
static void
st_scroll_bar_set_property (GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
StScrollBar *bar = ST_SCROLL_BAR (gobject);
switch (prop_id)
{
case PROP_ADJUSTMENT:
st_scroll_bar_set_adjustment (bar, g_value_get_object (value));
break;
case PROP_VERTICAL:
bar->priv->vertical = g_value_get_boolean (value);
if (bar->priv->vertical)
{
clutter_actor_set_name (CLUTTER_ACTOR (bar->priv->bw_stepper),
"up-stepper");
clutter_actor_set_name (CLUTTER_ACTOR (bar->priv->fw_stepper),
"down-stepper");
clutter_actor_set_name (CLUTTER_ACTOR (bar->priv->handle),
"vhandle");
}
else
{
clutter_actor_set_name (CLUTTER_ACTOR (bar->priv->fw_stepper),
"forward-stepper");
clutter_actor_set_name (CLUTTER_ACTOR (bar->priv->bw_stepper),
"backward-stepper");
clutter_actor_set_name (CLUTTER_ACTOR (bar->priv->handle),
"hhandle");
}
clutter_actor_queue_relayout ((ClutterActor*) gobject);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
static void
st_scroll_bar_dispose (GObject *gobject)
{
StScrollBar *bar = ST_SCROLL_BAR (gobject);
StScrollBarPrivate *priv = bar->priv;
if (priv->adjustment)
st_scroll_bar_set_adjustment (bar, NULL);
if (priv->handle)
{
g_signal_handlers_disconnect_by_func (priv->handle,
G_CALLBACK (handle_button_press_event_cb),
bar);
clutter_actor_unparent (priv->handle);
priv->handle = NULL;
}
if (priv->bw_stepper)
{
clutter_actor_unparent (priv->bw_stepper);
priv->bw_stepper = NULL;
}
if (priv->fw_stepper)
{
clutter_actor_unparent (priv->fw_stepper);
priv->fw_stepper = NULL;
}
if (priv->trough)
{
clutter_actor_unparent (priv->trough);
priv->trough = NULL;
}
G_OBJECT_CLASS (st_scroll_bar_parent_class)->dispose (gobject);
}
static void
st_scroll_bar_paint (ClutterActor *actor)
{
StScrollBarPrivate *priv = ST_SCROLL_BAR (actor)->priv;
CLUTTER_ACTOR_CLASS (st_scroll_bar_parent_class)->paint (actor);
clutter_actor_paint (priv->bw_stepper);
clutter_actor_paint (priv->fw_stepper);
clutter_actor_paint (priv->trough);
if (priv->handle && CLUTTER_ACTOR_IS_VISIBLE (priv->handle))
clutter_actor_paint (priv->handle);
}
static void
st_scroll_bar_pick (ClutterActor *actor,
const ClutterColor *pick_color)
{
StScrollBarPrivate *priv = ST_SCROLL_BAR (actor)->priv;
CLUTTER_ACTOR_CLASS (st_scroll_bar_parent_class)->pick (actor, pick_color);
clutter_actor_paint (priv->bw_stepper);
clutter_actor_paint (priv->fw_stepper);
clutter_actor_paint (priv->trough);
if (priv->handle && priv->adjustment)
clutter_actor_paint (priv->handle);
}
static void
st_scroll_bar_map (ClutterActor *actor)
{
StScrollBarPrivate *priv = ST_SCROLL_BAR (actor)->priv;
CLUTTER_ACTOR_CLASS (st_scroll_bar_parent_class)->map (actor);
clutter_actor_map (priv->bw_stepper);
clutter_actor_map (priv->fw_stepper);
clutter_actor_map (priv->trough);
if (priv->handle)
clutter_actor_map (priv->handle);
}
static void
st_scroll_bar_unmap (ClutterActor *actor)
{
StScrollBarPrivate *priv = ST_SCROLL_BAR (actor)->priv;
CLUTTER_ACTOR_CLASS (st_scroll_bar_parent_class)->unmap (actor);
clutter_actor_unmap (priv->bw_stepper);
clutter_actor_unmap (priv->fw_stepper);
clutter_actor_unmap (priv->trough);
if (priv->handle)
clutter_actor_unmap (priv->handle);
}
static void
st_scroll_bar_parent_set (ClutterActor *actor,
ClutterActor *old_parent)
{
StScrollBarPrivate *priv = ST_SCROLL_BAR (actor)->priv;
priv->needs_allocation = TRUE;
if (CLUTTER_ACTOR_CLASS (st_scroll_bar_parent_class)->parent_set)
CLUTTER_ACTOR_CLASS (st_scroll_bar_parent_class)->parent_set (actor, old_parent);
}
static void
st_scroll_bar_queue_relayout (ClutterActor *actor)
{
StScrollBarPrivate *priv = ST_SCROLL_BAR (actor)->priv;
priv->needs_allocation = TRUE;
CLUTTER_ACTOR_CLASS (st_scroll_bar_parent_class)->queue_relayout (actor);
}
static void
scroll_bar_allocate_children (StScrollBar *bar,
const ClutterActorBox *box,
ClutterAllocationFlags flags)
{
StScrollBarPrivate *priv = bar->priv;
StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (bar));
ClutterActorBox content_box, bw_box, fw_box, trough_box;
gfloat bw_stepper_size, fw_stepper_size, min_size, natural_size;
st_theme_node_get_content_box (theme_node, box, &content_box);
if (priv->vertical)
{
gfloat width = content_box.x2 - content_box.x1;
clutter_actor_get_preferred_height (priv->bw_stepper, width,
&min_size, &natural_size);
bw_stepper_size = MAX (min_size, natural_size);
/* Backward stepper */
bw_box.x1 = content_box.x1;
bw_box.y1 = content_box.y1;
bw_box.x2 = content_box.x2;
bw_box.y2 = bw_box.y1 + bw_stepper_size;
clutter_actor_allocate (priv->bw_stepper, &bw_box, flags);
clutter_actor_get_preferred_height (priv->fw_stepper, width,
&min_size, &natural_size);
fw_stepper_size = MAX (min_size, natural_size);
/* Forward stepper */
fw_box.x1 = content_box.x1;
fw_box.y1 = content_box.y2 - fw_stepper_size;
fw_box.x2 = content_box.x2;
fw_box.y2 = content_box.y2;
clutter_actor_allocate (priv->fw_stepper, &fw_box, flags);
/* Trough */
trough_box.x1 = content_box.x1;
trough_box.y1 = content_box.y1 + bw_stepper_size;
trough_box.x2 = content_box.x2;
trough_box.y2 = content_box.y2 - fw_stepper_size;
clutter_actor_allocate (priv->trough, &trough_box, flags);
}
else
{
gfloat height = content_box.y2 - content_box.y1;
clutter_actor_get_preferred_width (priv->bw_stepper, height,
&min_size, &natural_size);
bw_stepper_size = MAX (min_size, natural_size);
/* Backward stepper */
bw_box.x1 = content_box.x1;
bw_box.y1 = content_box.y1;
bw_box.x2 = bw_box.x1 + bw_stepper_size;
bw_box.y2 = content_box.y2;
clutter_actor_allocate (priv->bw_stepper, &bw_box, flags);
clutter_actor_get_preferred_width (priv->fw_stepper, height,
&min_size, &natural_size);
fw_stepper_size = MAX (min_size, natural_size);
/* Forward stepper */
fw_box.x1 = content_box.x2 - fw_stepper_size;
fw_box.y1 = content_box.y1;
fw_box.x2 = content_box.x2;
fw_box.y2 = content_box.y2;
clutter_actor_allocate (priv->fw_stepper, &fw_box, flags);
/* Trough */
trough_box.x1 = content_box.x1 + bw_stepper_size;
trough_box.y1 = content_box.y1;
trough_box.x2 = content_box.x2 - fw_stepper_size;
trough_box.y2 = content_box.y2;
clutter_actor_allocate (priv->trough, &trough_box, flags);
}
if (priv->adjustment)
{
float handle_size, position, avail_size, stepper_size;
gdouble value, lower, upper, page_size, increment, min_size, max_size;
ClutterActorBox handle_box = { 0, };
stepper_size = bw_stepper_size + fw_stepper_size;
st_adjustment_get_values (priv->adjustment,
&value,
&lower,
&upper,
NULL,
NULL,
&page_size);
if ((upper == lower)
|| (page_size >= (upper - lower)))
increment = 1.0;
else
increment = page_size / (upper - lower);
min_size = 32.;
st_theme_node_get_length (theme_node, "min-size", FALSE, &min_size);
max_size = G_MAXINT16;
st_theme_node_get_length (theme_node, "max-size", FALSE, &max_size);
if (upper - lower - page_size <= 0)
position = 0;
else
position = (value - lower) / (upper - lower - page_size);
if (priv->vertical)
{
avail_size = content_box.y2 - content_box.y1 - stepper_size;
handle_size = increment * avail_size;
handle_size = CLAMP (handle_size, min_size, max_size);
handle_box.x1 = content_box.x1;
handle_box.y1 = bw_box.y2 + position * (avail_size - handle_size);
handle_box.x2 = content_box.x2;
handle_box.y2 = handle_box.y1 + handle_size;
}
else
{
avail_size = content_box.x2 - content_box.x1 - stepper_size;
handle_size = increment * avail_size;
handle_size = CLAMP (handle_size, min_size, max_size);
handle_box.x1 = bw_box.x2 + position * (avail_size - handle_size);
handle_box.y1 = content_box.y1;
handle_box.x2 = handle_box.x1 + handle_size;
handle_box.y2 = content_box.y2;
}
/* snap to pixel */
handle_box.x1 = (int) handle_box.x1;
handle_box.y1 = (int) handle_box.y1;
handle_box.x2 = (int) handle_box.x2;
handle_box.y2 = (int) handle_box.y2;
clutter_actor_allocate (priv->handle,
&handle_box,
flags);
}
}
static void
st_scroll_bar_allocate (ClutterActor *actor,
const ClutterActorBox *box,
ClutterAllocationFlags flags)
{
StScrollBar *bar = ST_SCROLL_BAR (actor);
StScrollBarPrivate *priv = bar->priv;
priv->needs_allocation = FALSE;
/* Chain up */
CLUTTER_ACTOR_CLASS (st_scroll_bar_parent_class)->allocate (actor, box, flags);
scroll_bar_allocate_children (bar, box, flags);
}
static void
scroll_bar_update_positions (StScrollBar *bar)
{
StScrollBarPrivate *priv = bar->priv;
ClutterActorBox box;
/* Due to a change in the adjustments, we need to reposition our
* children; since adjustments changes can come from allocation
* changes in the scrolled area, we can't just queue a new relayout -
* we may already be in a relayout cycle. On the other hand, if
* a relayout is already queued, we can't just go ahead and allocate
* our children, since we don't have a valid allocation, and calling
* clutter_actor_get_allocation_box() will trigger an immediate
* stage relayout. So what we do is go ahead and immediately
* allocate our children if we already have a valid allocation, and
* otherwise just wait for the queued relayout.
*/
if (priv->needs_allocation)
return;
clutter_actor_get_allocation_box (CLUTTER_ACTOR (bar), &box);
scroll_bar_allocate_children (bar, &box, CLUTTER_ALLOCATION_NONE);
}
static void
st_scroll_bar_style_changed (StWidget *widget)
{
StScrollBarPrivate *priv = ST_SCROLL_BAR (widget)->priv;
st_widget_style_changed (ST_WIDGET (priv->bw_stepper));
st_widget_style_changed (ST_WIDGET (priv->fw_stepper));
st_widget_style_changed (ST_WIDGET (priv->trough));
st_widget_style_changed (ST_WIDGET (priv->handle));
ST_WIDGET_CLASS (st_scroll_bar_parent_class)->style_changed (widget);
}
static void
bar_reactive_notify_cb (GObject *gobject,
GParamSpec *arg1,
gpointer user_data)
{
StScrollBar *bar = ST_SCROLL_BAR (gobject);
clutter_actor_set_reactive (bar->priv->handle,
clutter_actor_get_reactive (CLUTTER_ACTOR (bar)));
}
static GObject*
st_scroll_bar_constructor (GType type,
guint n_properties,
GObjectConstructParam *properties)
{
GObjectClass *gobject_class;
GObject *obj;
StScrollBar *bar;
StScrollBarPrivate *priv;
gobject_class = G_OBJECT_CLASS (st_scroll_bar_parent_class);
obj = gobject_class->constructor (type, n_properties, properties);
bar = ST_SCROLL_BAR (obj);
priv = ST_SCROLL_BAR_GET_PRIVATE (bar);
g_signal_connect (bar, "notify::reactive",
G_CALLBACK (bar_reactive_notify_cb), NULL);
return obj;
}
static gboolean
st_scroll_bar_scroll_event (ClutterActor *actor,
ClutterScrollEvent *event)
{
StScrollBarPrivate *priv = ST_SCROLL_BAR (actor)->priv;
gdouble lower, step, upper, value;
if (priv->adjustment)
{
g_object_get (priv->adjustment,
"lower", &lower,
"step-increment", &step,
"upper", &upper,
"value", &value,
NULL);
}
else
{
return FALSE;
}
switch (event->direction)
{
case CLUTTER_SCROLL_UP:
case CLUTTER_SCROLL_LEFT:
if (value == lower)
return FALSE;
else
st_adjustment_set_value (priv->adjustment, value - step);
break;
case CLUTTER_SCROLL_DOWN:
case CLUTTER_SCROLL_RIGHT:
if (value == upper)
return FALSE;
else
st_adjustment_set_value (priv->adjustment, value + step);
break;
}
return TRUE;
}
static void
st_scroll_bar_class_init (StScrollBarClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
ClutterActorClass *actor_class = CLUTTER_ACTOR_CLASS (klass);
StWidgetClass *widget_class = ST_WIDGET_CLASS (klass);
GParamSpec *pspec;
g_type_class_add_private (klass, sizeof (StScrollBarPrivate));
object_class->get_property = st_scroll_bar_get_property;
object_class->set_property = st_scroll_bar_set_property;
object_class->dispose = st_scroll_bar_dispose;
object_class->constructor = st_scroll_bar_constructor;
actor_class->parent_set = st_scroll_bar_parent_set;
actor_class->queue_relayout = st_scroll_bar_queue_relayout;
actor_class->allocate = st_scroll_bar_allocate;
actor_class->paint = st_scroll_bar_paint;
actor_class->pick = st_scroll_bar_pick;
actor_class->scroll_event = st_scroll_bar_scroll_event;
actor_class->map = st_scroll_bar_map;
actor_class->unmap = st_scroll_bar_unmap;
widget_class->style_changed = st_scroll_bar_style_changed;
g_object_class_install_property
(object_class,
PROP_ADJUSTMENT,
g_param_spec_object ("adjustment",
"Adjustment",
"The adjustment",
ST_TYPE_ADJUSTMENT,
ST_PARAM_READWRITE));
pspec = g_param_spec_boolean ("vertical",
"Vertical Orientation",
"Vertical Orientation",
FALSE,
ST_PARAM_READWRITE);
g_object_class_install_property (object_class, PROP_VERTICAL, pspec);
signals[SCROLL_START] =
g_signal_new ("scroll-start",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (StScrollBarClass, scroll_start),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals[SCROLL_STOP] =
g_signal_new ("scroll-stop",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (StScrollBarClass, scroll_stop),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
}
static void
move_slider (StScrollBar *bar,
gfloat x,
gfloat y)
{
StScrollBarPrivate *priv = bar->priv;
gdouble position, lower, upper, page_size;
gfloat ux, uy, pos, size;
if (!priv->adjustment)
return;
if (!clutter_actor_transform_stage_point (priv->trough, x, y, &ux, &uy))
return;
if (priv->vertical)
size = clutter_actor_get_height (priv->trough)
- clutter_actor_get_height (priv->handle);
else
size = clutter_actor_get_width (priv->trough)
- clutter_actor_get_width (priv->handle);
if (size == 0)
return;
if (priv->vertical)
pos = uy - priv->y_origin;
else
pos = ux - priv->x_origin;
pos = CLAMP (pos, 0, size);
st_adjustment_get_values (priv->adjustment,
NULL,
&lower,
&upper,
NULL,
NULL,
&page_size);
position = ((pos / size)
* (upper - lower - page_size))
+ lower;
st_adjustment_set_value (priv->adjustment, position);
}
static gboolean
handle_capture_event_cb (ClutterActor *trough,
ClutterEvent *event,
StScrollBar *bar)
{
if (clutter_event_type (event) == CLUTTER_MOTION)
{
move_slider (bar,
((ClutterMotionEvent*) event)->x,
((ClutterMotionEvent*) event)->y);
}
else if (clutter_event_type (event) == CLUTTER_BUTTON_RELEASE
&& ((ClutterButtonEvent*) event)->button == 1)
{
ClutterActor *stage, *target;
stage = clutter_actor_get_stage(bar->priv->trough);
if (bar->priv->capture_handler)
{
g_signal_handler_disconnect (stage, bar->priv->capture_handler);
bar->priv->capture_handler = 0;
}
clutter_set_motion_events_enabled (TRUE);
g_signal_emit (bar, signals[SCROLL_STOP], 0);
/* check if the mouse pointer has left the handle during the drag and
* remove the hover state if it has */
target = clutter_stage_get_actor_at_pos ((ClutterStage*) stage,
CLUTTER_PICK_REACTIVE,
((ClutterButtonEvent*) event)->x,
((ClutterButtonEvent*) event)->y);
if (target != bar->priv->handle)
{
st_widget_set_style_pseudo_class ((StWidget*) bar->priv->handle, NULL);
}
}
return TRUE;
}
static gboolean
handle_button_press_event_cb (ClutterActor *actor,
ClutterButtonEvent *event,
StScrollBar *bar)
{
StScrollBarPrivate *priv = bar->priv;
if (event->button != 1)
return FALSE;
if (!clutter_actor_transform_stage_point (priv->handle,
event->x,
event->y,
&priv->x_origin,
&priv->y_origin))
return FALSE;
/* Account for the scrollbar-trough-handle nesting. */
priv->x_origin += clutter_actor_get_x (priv->trough);
priv->y_origin += clutter_actor_get_y (priv->trough);
/* Turn off picking for motion events */
clutter_set_motion_events_enabled (FALSE);
priv->capture_handler = g_signal_connect_after (
clutter_actor_get_stage (priv->trough),
"captured-event",
G_CALLBACK (handle_capture_event_cb),
bar);
g_signal_emit (bar, signals[SCROLL_START], 0);
return TRUE;
}
static void
animation_completed_cb (ClutterAnimation *animation,
StScrollBarPrivate *priv)
{
g_object_unref (priv->paging_animation);
priv->paging_animation = NULL;
}
static gboolean
trough_paging_cb (StScrollBar *self)
{
gfloat handle_pos, event_pos, tx, ty;
gdouble value;
gdouble page_increment;
gboolean ret;
gulong mode;
ClutterAnimation *a;
GValue v = { 0, };
ClutterTimeline *t;
if (self->priv->paging_event_no == 0)
{
/* Scroll on after initial timeout. */
mode = CLUTTER_EASE_OUT_CUBIC;
ret = FALSE;
self->priv->paging_event_no = 1;
self->priv->paging_source_id = g_timeout_add (
PAGING_INITIAL_REPEAT_TIMEOUT,
(GSourceFunc) trough_paging_cb,
self);
}
else if (self->priv->paging_event_no == 1)
{
/* Scroll on after subsequent timeout. */
ret = FALSE;
mode = CLUTTER_EASE_IN_CUBIC;
self->priv->paging_event_no = 2;
self->priv->paging_source_id = g_timeout_add (
PAGING_SUBSEQUENT_REPEAT_TIMEOUT,
(GSourceFunc) trough_paging_cb,
self);
}
else
{
/* Keep scrolling. */
ret = TRUE;
mode = CLUTTER_LINEAR;
self->priv->paging_event_no++;
}
/* Do the scrolling */
st_adjustment_get_values (self->priv->adjustment,
&value, NULL, NULL,
NULL, &page_increment, NULL);
if (self->priv->vertical)
handle_pos = clutter_actor_get_y (self->priv->handle);
else
handle_pos = clutter_actor_get_x (self->priv->handle);
clutter_actor_transform_stage_point (CLUTTER_ACTOR (self->priv->trough),
self->priv->move_x,
self->priv->move_y,
&tx, &ty);
if (self->priv->vertical)
event_pos = ty;
else
event_pos = tx;
if (event_pos > handle_pos)
{
if (self->priv->paging_direction == NONE)
{
/* Remember direction. */
self->priv->paging_direction = DOWN;
}
if (self->priv->paging_direction == UP)
{
/* Scrolled far enough. */
return FALSE;
}
value += page_increment;
}
else
{
if (self->priv->paging_direction == NONE)
{
/* Remember direction. */
self->priv->paging_direction = UP;
}
if (self->priv->paging_direction == DOWN)
{
/* Scrolled far enough. */
return FALSE;
}
value -= page_increment;
}
if (self->priv->paging_animation)
{
clutter_animation_completed (self->priv->paging_animation);
}
/* FIXME: Creating a new animation for each scroll is probably not the best
* idea, but it's a lot less involved than extenind the current animation */
a = self->priv->paging_animation = g_object_new (CLUTTER_TYPE_ANIMATION,
"object", self->priv->adjustment,
"duration", PAGING_SUBSEQUENT_REPEAT_TIMEOUT,
"mode", mode,
NULL);
g_value_init (&v, G_TYPE_DOUBLE);
g_value_set_double (&v, value);
clutter_animation_bind (self->priv->paging_animation, "value", &v);
t = clutter_animation_get_timeline (self->priv->paging_animation);
g_signal_connect (a, "completed", G_CALLBACK (animation_completed_cb),
self->priv);
clutter_timeline_start (t);
return ret;
}
static gboolean
trough_button_press_event_cb (ClutterActor *actor,
ClutterButtonEvent *event,
StScrollBar *self)
{
g_return_val_if_fail (self, FALSE);
if (event->button != 1)
return FALSE;
if (self->priv->adjustment == NULL)
return FALSE;
self->priv->move_x = event->x;
self->priv->move_y = event->y;
self->priv->paging_direction = NONE;
self->priv->paging_event_no = 0;
trough_paging_cb (self);
return TRUE;
}
static gboolean
trough_button_release_event_cb (ClutterActor *actor,
ClutterButtonEvent *event,
StScrollBar *self)
{
if (event->button != 1)
return FALSE;
if (self->priv->paging_source_id)
{
g_source_remove (self->priv->paging_source_id);
self->priv->paging_source_id = 0;
}
return TRUE;
}
static gboolean
trough_leave_event_cb (ClutterActor *actor,
ClutterEvent *event,
StScrollBar *self)
{
if (self->priv->paging_source_id)
{
g_source_remove (self->priv->paging_source_id);
self->priv->paging_source_id = 0;
return TRUE;
}
return FALSE;
}
static void
stepper_animation_completed_cb (ClutterAnimation *a,
gpointer data)
{
g_object_unref (a);
}
static void
stepper_move_on (StScrollBarPrivate *priv,
gint mode)
{
ClutterAnimation *a;
ClutterTimeline *t;
GValue v = { 0, };
double value, inc;
a = g_object_new (CLUTTER_TYPE_ANIMATION,
"object", priv->adjustment,
"duration", PAGING_SUBSEQUENT_REPEAT_TIMEOUT,
"mode", mode,
NULL);
g_signal_connect (a, "completed", G_CALLBACK (stepper_animation_completed_cb),
NULL);
g_object_get (priv->adjustment,
"step-increment", &inc,
"value", &value,
NULL);
if (priv->stepper_forward)
value = value + inc;
else
value = value - inc;
g_value_init (&v, G_TYPE_DOUBLE);
g_value_set_double (&v, value);
clutter_animation_bind (a, "value", &v);
t = clutter_animation_get_timeline (a);
clutter_timeline_start (t);
}
static gboolean
stepper_button_subsequent_timeout (StScrollBarPrivate *priv)
{
stepper_move_on (priv, CLUTTER_LINEAR);
return TRUE;
}
static gboolean
stepper_button_repeat_timeout (StScrollBarPrivate *priv)
{
priv->stepper_source_id = 0;
stepper_move_on (priv, CLUTTER_EASE_IN_CUBIC);
priv->stepper_source_id = g_timeout_add (PAGING_SUBSEQUENT_REPEAT_TIMEOUT,
(GSourceFunc)
stepper_button_subsequent_timeout,
priv);
return FALSE;
}
static gboolean
stepper_button_press_event_cb (ClutterActor *actor,
ClutterButtonEvent *event,
StScrollBar *bar)
{
StScrollBarPrivate *priv = bar->priv;
if (event->button != 1)
return FALSE;
if (bar->priv->adjustment == NULL)
return FALSE;
bar->priv->stepper_forward = (actor == priv->fw_stepper);
stepper_move_on (priv, CLUTTER_EASE_OUT_CUBIC);
priv->stepper_source_id = g_timeout_add (PAGING_INITIAL_REPEAT_TIMEOUT,
(GSourceFunc)
stepper_button_repeat_timeout,
priv);
return TRUE;
}
static gboolean
stepper_button_release_cb (ClutterActor *actor,
ClutterButtonEvent *event,
StScrollBar *self)
{
if (event->button != 1)
return FALSE;
g_source_remove (self->priv->stepper_source_id);
return FALSE;
}
static void
st_scroll_bar_notify_reactive (StScrollBar *self)
{
StScrollBarPrivate *priv = self->priv;
gboolean reactive = CLUTTER_ACTOR_IS_REACTIVE (self);
clutter_actor_set_reactive (CLUTTER_ACTOR (priv->bw_stepper), reactive);
clutter_actor_set_reactive (CLUTTER_ACTOR (priv->fw_stepper), reactive);
clutter_actor_set_reactive (CLUTTER_ACTOR (priv->trough), reactive);
clutter_actor_set_reactive (CLUTTER_ACTOR (priv->handle), reactive);
}
static void
st_scroll_bar_init (StScrollBar *self)
{
self->priv = ST_SCROLL_BAR_GET_PRIVATE (self);
self->priv->bw_stepper = (ClutterActor *) st_button_new ();
clutter_actor_set_name (CLUTTER_ACTOR (self->priv->bw_stepper),
"backward-stepper");
clutter_actor_set_parent (CLUTTER_ACTOR (self->priv->bw_stepper),
CLUTTER_ACTOR (self));
g_signal_connect (self->priv->bw_stepper, "button-press-event",
G_CALLBACK (stepper_button_press_event_cb), self);
g_signal_connect (self->priv->bw_stepper, "button-release-event",
G_CALLBACK (stepper_button_release_cb), self);
self->priv->fw_stepper = (ClutterActor *) st_button_new ();
clutter_actor_set_name (CLUTTER_ACTOR (self->priv->fw_stepper),
"forward-stepper");
clutter_actor_set_parent (CLUTTER_ACTOR (self->priv->fw_stepper),
CLUTTER_ACTOR (self));
g_signal_connect (self->priv->fw_stepper, "button-press-event",
G_CALLBACK (stepper_button_press_event_cb), self);
g_signal_connect (self->priv->fw_stepper, "button-release-event",
G_CALLBACK (stepper_button_release_cb), self);
self->priv->trough = (ClutterActor *) st_bin_new ();
clutter_actor_set_reactive ((ClutterActor *) self->priv->trough, TRUE);
clutter_actor_set_name (CLUTTER_ACTOR (self->priv->trough), "trough");
clutter_actor_set_parent (CLUTTER_ACTOR (self->priv->trough),
CLUTTER_ACTOR (self));
g_signal_connect (self->priv->trough, "button-press-event",
G_CALLBACK (trough_button_press_event_cb), self);
g_signal_connect (self->priv->trough, "button-release-event",
G_CALLBACK (trough_button_release_event_cb), self);
g_signal_connect (self->priv->trough, "leave-event",
G_CALLBACK (trough_leave_event_cb), self);
self->priv->handle = (ClutterActor *) st_button_new ();
clutter_actor_set_name (CLUTTER_ACTOR (self->priv->handle), "hhandle");
clutter_actor_set_parent (CLUTTER_ACTOR (self->priv->handle),
self->priv->trough);
g_signal_connect (self->priv->handle, "button-press-event",
G_CALLBACK (handle_button_press_event_cb), self);
clutter_actor_set_reactive (CLUTTER_ACTOR (self), TRUE);
g_signal_connect (self, "notify::reactive",
G_CALLBACK (st_scroll_bar_notify_reactive), NULL);
self->priv->needs_allocation = TRUE;
}
StWidget *
st_scroll_bar_new (StAdjustment *adjustment)
{
return g_object_new (ST_TYPE_SCROLL_BAR,
"adjustment", adjustment,
NULL);
}
static void
on_notify_value (GObject *object,
GParamSpec *pspec,
StScrollBar *bar)
{
scroll_bar_update_positions (bar);
}
static void
on_changed (StAdjustment *adjustment,
StScrollBar *bar)
{
scroll_bar_update_positions (bar);
}
void
st_scroll_bar_set_adjustment (StScrollBar *bar,
StAdjustment *adjustment)
{
StScrollBarPrivate *priv;
g_return_if_fail (ST_IS_SCROLL_BAR (bar));
priv = bar->priv;
if (priv->adjustment)
{
g_signal_handlers_disconnect_by_func (priv->adjustment,
on_notify_value,
bar);
g_signal_handlers_disconnect_by_func (priv->adjustment,
on_changed,
bar);
g_object_unref (priv->adjustment);
priv->adjustment = NULL;
}
if (adjustment)
{
priv->adjustment = g_object_ref (adjustment);
g_signal_connect (priv->adjustment, "notify::value",
G_CALLBACK (on_notify_value),
bar);
g_signal_connect (priv->adjustment, "changed",
G_CALLBACK (on_changed),
bar);
clutter_actor_queue_relayout (CLUTTER_ACTOR (bar));
}
}
/**
* st_scroll_bar_get_adjustment:
* @bar: a #StScrollbar
*
* Gets the adjustment object that stores the current position
* of the scrollbar.
*
* Return value: (transfer none): the adjustment
*/
StAdjustment *
st_scroll_bar_get_adjustment (StScrollBar *bar)
{
g_return_val_if_fail (ST_IS_SCROLL_BAR (bar), NULL);
return bar->priv->adjustment;
}
Reference in New Issue View Git Blame Copy Permalink