debian
/
midori
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
midori/katze/katze-scrolled.c

1151 lines
39 KiB
C
Raw Blame History

/*
Copyright (C) 2007 Henrik Hedberg <hhedberg@innologies.fi>
Copyright (C) 2009 Nadav Wiener <nadavwr@yahoo.com>
Copyright (C) 2009 Christian Dywan <christian@twotoasts.de>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
See the file COPYING for the full license text.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "katze-scrolled.h"
#include "katze-utils.h"
#if !GTK_CHECK_VERSION (2, 14, 0)
#define gtk_adjustment_get_page_size(adj) adj->page_size
#define gtk_adjustment_get_upper(adj) adj->upper
#define gtk_adjustment_get_lower(adj) adj->lower
#define gtk_adjustment_get_value(adj) adj->value
#define gtk_widget_get_window(wdgt) wdgt->window
#endif
#if !GTK_CHECK_VERSION (2, 18, 0)
#define gtk_widget_set_window(wdgt, wndw) wdgt->window = wndw
#define gtk_widget_get_allocation(wdgt, alloc) *alloc = wdgt->allocation
#define gtk_widget_is_drawable GTK_WIDGET_DRAWABLE
#define gtk_widget_get_drawable GTK_WIDGET_VISIBLE
#define gtk_widget_get_visible(wdgt) GTK_WIDGET_VISIBLE (wdgt)
#endif
#if !GTK_CHECK_VERSION (2, 19, 6)
#define gtk_widget_set_realized(wdgt, real) \
if (real) GTK_WIDGET_SET_FLAGS (wdgt, GTK_REALIZED); \
else GTK_WIDGET_UNSET_FLAGS (wdgt, GTK_REALIZED)
#endif
#define DEFAULT_INTERVAL 50
#define DEFAULT_DECELERATION 0.7
#define DEFAULT_DRAGGING_STOPPED_DELAY 100
/**
* SECTION:katze-scrolled
* @short_description: Implements drag scrolling and kinetic scrolling
* @see_also: #GtkScrolledWindow
*
* A scrolled window derived from #GtkScrolledWindow that implements
* drag scrolling and kinetic scrolling. Can be used as a drop-in replacement
* for the existing #GtkScrolledWindow.
*
* If a direct child of the #KatzeScrolled has its own window
* (InputOnly is enough for events), it is automatically activated when added
* as a child. All motion events in that area will be used to scroll.
*
* If some descendant widgets capture button press, button release and/ or
* motion nofity events, the user can not scroll the area by pressing those
* widgets (unless the widget is activated). #GtkButton is a typical example
* of that. Usually that is the desired behaviour.
*
* Any widget can be registered to provide pointer events for the
* #KatzeScrolled by using the
* #katze_scrolled_activate_scrolling function.
*
**/
G_DEFINE_TYPE (KatzeScrolled, katze_scrolled, GTK_TYPE_SCROLLED_WINDOW);
enum
{
PROP_0,
PROP_DRAG_SCROLLING,
PROP_KINETIC_SCROLLING
};
static void
katze_scrolled_set_property (GObject* object,
guint prop_id,
const GValue* value,
GParamSpec* pspec);
static void
katze_scrolled_get_property (GObject* object,
guint prop_id,
GValue* value,
GParamSpec* pspec);
static void
katze_scrolled_dispose (GObject* object);
static void
katze_scrolled_activate_scrolling (KatzeScrolled* scrolled,
GtkWidget* widget);
static void
katze_scrolled_set_drag_scrolling (KatzeScrolled* scrolled,
gboolean drag_scrolling);
struct _KatzeScrolledPrivate
{
/* Settings */
guint interval;
gdouble deceleration;
gboolean drag_scrolling;
gboolean kinetic_scrolling;
guint32 dragging_stopped_delay;
gboolean scrolling_hints;
/* Temporary variables */
gboolean dragged;
gboolean press_received;
GdkWindow* synthetic_crossing_event_window;
/* Disabling twice happening scrolling adjustment */
GtkAdjustment* hadjustment;
GtkWidget* viewport;
/* Motion scrolling */
gint start_x;
gint start_y;
gint previous_x;
gint previous_y;
gint farest_x;
gint farest_y;
guint32 start_time;
guint32 previous_time;
guint32 farest_time;
gboolean going_right;
gboolean going_down;
/* Kinetic scrolling */
guint scrolling_timeout_id;
gdouble horizontal_speed;
gdouble vertical_speed;
gdouble horizontal_deceleration;
gdouble vertical_deceleration;
/* Internal scrollbars */
GdkWindow* vertical_scrollbar_window;
GdkWindow* horizontal_scrollbar_window;
gint vertical_scrollbar_size;
gint horizontal_scrollbar_size;
guint hide_scrollbars_timeout_id;
GdkGC* hilight_gc;
GdkGC* shadow_gc;
};
typedef struct _KatzeScrolledState KatzeScrolledState;
typedef gboolean (*KatzeScrolledEventHandler)(GdkEvent* event,
KatzeScrolledState* state,
gpointer user_data);
typedef struct
{
KatzeScrolledEventHandler event_handler;
gpointer user_data;
} EventHandlerData;
struct _KatzeScrolledState
{
GList* current_event_handler;
};
static GList* event_handlers = NULL;
static void
katze_scrolled_event_handler_func (GdkEvent* event,
gpointer data);
static void
katze_scrolled_event_handler_append (KatzeScrolledEventHandler event_handler,
gpointer user_data)
{
EventHandlerData* data;
data = g_new0 (EventHandlerData, 1);
data->event_handler = event_handler;
data->user_data = user_data;
event_handlers = g_list_append (event_handlers, data);
gdk_event_handler_set ((GdkEventFunc)katze_scrolled_event_handler_func, NULL, NULL);
}
static void
katze_scrolled_event_handler_next (GdkEvent* event,
KatzeScrolledState* state)
{
EventHandlerData* data;
gboolean stop_propagating;
state->current_event_handler = g_list_next (state->current_event_handler);
if (state->current_event_handler)
{
data = (EventHandlerData*)state->current_event_handler->data;
stop_propagating = data->event_handler (event, state, data->user_data);
if (!stop_propagating && state->current_event_handler)
g_critical ("%s: handler returned FALSE without calling %s first",
G_STRFUNC, G_STRFUNC);
}
else
gtk_main_do_event (event);
}
static void
katze_scrolled_event_handler_func (GdkEvent* event,
gpointer user_data)
{
KatzeScrolledState* state;
EventHandlerData* data;
gboolean stop_propagating;
state = g_new0 (KatzeScrolledState, 1);
state->current_event_handler = g_list_first (event_handlers);
if (state->current_event_handler)
{
data = (EventHandlerData*)state->current_event_handler->data;
stop_propagating = data->event_handler (event, state, data->user_data);
if (!stop_propagating && state->current_event_handler)
g_critical ("%s: handler returned FALSE without calling %s first",
G_STRFUNC, "katze_scrolled_event_handler_next");
}
else
gtk_main_do_event (event);
g_free (state);
}
static GdkWindow* current_gdk_window;
static KatzeScrolled* current_scrolled_window;
static GtkWidget* current_widget;
static gboolean synthetized_crossing_event;
static GTree* activated_widgets;
static gint
compare_pointers (gconstpointer a,
gconstpointer b)
{
return a - b;
}
static void
disable_hadjustment (KatzeScrolled* scrolled)
{
KatzeScrolledPrivate* priv = scrolled->priv;
GtkAdjustment* hadjustment;
GtkWidget* viewport;
if ((hadjustment = gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (scrolled)))
&& priv->hadjustment != hadjustment)
{
priv->hadjustment = hadjustment;
priv->viewport = NULL;
viewport = GTK_WIDGET (scrolled);
while (GTK_IS_BIN (viewport))
{
viewport = gtk_bin_get_child (GTK_BIN (viewport));
if (GTK_IS_VIEWPORT (viewport))
{
priv->viewport = viewport;
break;
}
}
}
g_signal_handlers_block_matched (priv->hadjustment, G_SIGNAL_MATCH_DATA,
0, 0, 0, 0, priv->viewport);
}
static void
enable_hadjustment (KatzeScrolled* scrolled)
{
KatzeScrolledPrivate* priv = scrolled->priv;
g_signal_handlers_unblock_matched (priv->hadjustment, G_SIGNAL_MATCH_DATA, 0, 0, 0, 0, priv->viewport);
}
static gboolean
on_expose_event (GtkWidget* widget,
GdkEventExpose* event,
KatzeScrolled* scrolled)
{
KatzeScrolledPrivate* priv = scrolled->priv;
gboolean ret = FALSE;
if (gtk_widget_is_drawable (widget))
{
if (event->window == priv->horizontal_scrollbar_window)
{
if (priv->horizontal_scrollbar_size)
{
gdk_draw_line (event->window, priv->hilight_gc, 0, 0, priv->horizontal_scrollbar_size - 1, 0);
gdk_draw_line (event->window, priv->hilight_gc, 0, 1, 0, 9);
gdk_draw_line (event->window, priv->shadow_gc, priv->horizontal_scrollbar_size - 1, 1, priv->horizontal_scrollbar_size - 1, 9);
gdk_draw_line (event->window, priv->shadow_gc, 0, 9, priv->horizontal_scrollbar_size - 1, 9);
}
ret = TRUE;
}
else if (event->window == priv->vertical_scrollbar_window)
{
if (priv->vertical_scrollbar_size)
{
gdk_draw_line (event->window, priv->hilight_gc, 0, 0, 9, 0);
gdk_draw_line (event->window, priv->hilight_gc, 0, 1, 0, priv->vertical_scrollbar_size - 1);
gdk_draw_line (event->window, priv->shadow_gc, 9, 1, 9, priv->vertical_scrollbar_size - 1);
gdk_draw_line (event->window, priv->shadow_gc, 0, priv->vertical_scrollbar_size - 1, 9, priv->vertical_scrollbar_size - 1);
}
ret = TRUE;
}
}
return ret;
}
static gboolean
adjust_scrollbar (KatzeScrolled* scrolled,
GdkWindow* scrollbar_window,
GtkAdjustment* adjustment,
gint* previous_size,
gboolean horizontal)
{
KatzeScrolledPrivate* priv = scrolled->priv;
GtkWidget* widget = GTK_WIDGET (scrolled);
gdouble page_size, upper, lower, value;
gint x, y;
gint size;
double position;
GtkAllocation allocation;
GtkWidget* window;
page_size = gtk_adjustment_get_page_size (adjustment);
upper = gtk_adjustment_get_upper (adjustment);
lower = gtk_adjustment_get_lower (adjustment);
value = gtk_adjustment_get_value (adjustment);
if (page_size >= upper - lower)
{
*previous_size = 0;
return FALSE;
}
gtk_widget_get_allocation (widget, &allocation);
size = page_size / (upper - lower)
* (horizontal ? allocation.height : allocation.width);
if (size != *previous_size)
{
*previous_size = size;
if (horizontal)
{
gdk_window_resize (scrollbar_window, 10, size);
gdk_window_clear (scrollbar_window);
gdk_draw_line (scrollbar_window, priv->hilight_gc, 0, 0, 9, 0);
gdk_draw_line (scrollbar_window, priv->hilight_gc, 0, 1, 0, size - 1);
gdk_draw_line (scrollbar_window, priv->shadow_gc, 9, 1, 9, size - 1);
gdk_draw_line (scrollbar_window, priv->shadow_gc, 0, size - 1, 9, size - 1);
}
else
{
gdk_window_resize (scrollbar_window, size, 10);
gdk_window_clear (scrollbar_window);
gdk_draw_line (scrollbar_window, priv->hilight_gc, 0, 0, size - 1, 0);
gdk_draw_line (scrollbar_window, priv->hilight_gc, 0, 1, 0, 9);
gdk_draw_line (scrollbar_window, priv->shadow_gc, size - 1, 1, size - 1, 9);
gdk_draw_line (scrollbar_window, priv->shadow_gc, 0, 9, size - 1, 9);
}
}
position = (value - lower) / (upper - lower);
window = gtk_widget_get_toplevel (widget);
if (horizontal)
{
gtk_widget_translate_coordinates (widget, window,
allocation.width - 20, position * allocation.height, &x, &y);
gdk_window_move (scrollbar_window, x, y);
}
else
{
gtk_widget_translate_coordinates (widget, window,
position * allocation.width, allocation.height - 20, &x, &y);
gdk_window_move (scrollbar_window, x, y);
}
return TRUE;
}
static gboolean
hide_scrollbars_timeout (gpointer data)
{
KatzeScrolled* scrolled = KATZE_SCROLLED (data);
KatzeScrolledPrivate* priv = scrolled->priv;
gdk_threads_enter ();
gdk_window_hide (priv->vertical_scrollbar_window);
gdk_window_hide (priv->horizontal_scrollbar_window);
priv->hide_scrollbars_timeout_id = 0;
gdk_threads_leave ();
return FALSE;
}
static gdouble
calculate_timeout_scroll_values (gdouble old_value,
gdouble upper_limit,
gdouble* scrolling_speed_pointer,
gdouble deceleration,
gdouble* other_deceleration,
gdouble normal_deceleration)
{
gdouble new_value = old_value;
if (*scrolling_speed_pointer > deceleration ||
*scrolling_speed_pointer < -deceleration)
{
if (old_value + *scrolling_speed_pointer <= 0.0)
{
new_value = -1.0;
*scrolling_speed_pointer = 0.0;
*other_deceleration = normal_deceleration;
}
else if (old_value + *scrolling_speed_pointer >= upper_limit)
{
new_value = upper_limit;
*scrolling_speed_pointer = 0.0;
*other_deceleration = normal_deceleration;
}
else
new_value = old_value + *scrolling_speed_pointer;
if (*scrolling_speed_pointer > deceleration)
*scrolling_speed_pointer -= deceleration;
else if (*scrolling_speed_pointer < -deceleration)
*scrolling_speed_pointer += deceleration;
}
return new_value;
}
static void
do_timeout_scroll (KatzeScrolled* scrolled)
{
KatzeScrolledPrivate* priv = scrolled->priv;
GtkScrolledWindow* gtk_scrolled = GTK_SCROLLED_WINDOW (scrolled);
GtkAdjustment* hadjustment;
GtkAdjustment* vadjustment;
gdouble hpage_size, hupper, hlower, hvalue, new_hvalue;
gdouble vpage_size, vupper, vlower, vvalue, new_vvalue;
hadjustment = gtk_scrolled_window_get_hadjustment (gtk_scrolled);
hpage_size = gtk_adjustment_get_page_size (hadjustment);
hupper = gtk_adjustment_get_upper (hadjustment);
hlower = gtk_adjustment_get_lower (hadjustment);
hvalue = gtk_adjustment_get_value (hadjustment);
new_hvalue = calculate_timeout_scroll_values (hvalue,
hupper - hpage_size,
&priv->horizontal_speed,
priv->horizontal_deceleration,
&priv->vertical_deceleration,
priv->deceleration);
vadjustment = gtk_scrolled_window_get_vadjustment (gtk_scrolled);
vpage_size = gtk_adjustment_get_page_size (vadjustment);
vupper = gtk_adjustment_get_upper (vadjustment);
vlower = gtk_adjustment_get_lower (vadjustment);
vvalue = gtk_adjustment_get_value (vadjustment);
new_vvalue = calculate_timeout_scroll_values (vvalue,
vupper - vpage_size,
&priv->vertical_speed,
priv->vertical_deceleration,
&priv->horizontal_deceleration,
priv->deceleration);
if (new_vvalue != vvalue)
{
if (new_hvalue != hvalue)
{
disable_hadjustment (scrolled);
gtk_adjustment_set_value (hadjustment, new_hvalue);
enable_hadjustment (scrolled);
}
gtk_adjustment_set_value (vadjustment, new_vvalue);
}
else if (new_hvalue != hvalue)
gtk_adjustment_set_value (hadjustment, new_hvalue);
adjust_scrollbar (scrolled, priv->horizontal_scrollbar_window,
gtk_scrolled_window_get_hadjustment (gtk_scrolled),
&priv->horizontal_scrollbar_size, FALSE);
adjust_scrollbar (scrolled, priv->vertical_scrollbar_window,
gtk_scrolled_window_get_vadjustment (gtk_scrolled),
&priv->vertical_scrollbar_size, TRUE);
}
static gboolean
timeout_scroll (gpointer data)
{
gboolean ret = TRUE;
KatzeScrolled* scrolled = KATZE_SCROLLED (data);
KatzeScrolledPrivate* priv = scrolled->priv;
gdk_threads_enter ();
do_timeout_scroll (scrolled);
if (priv->vertical_speed < priv->deceleration &&
priv->vertical_speed > -priv->deceleration &&
priv->horizontal_speed < priv->deceleration &&
priv->horizontal_speed > -priv->deceleration)
{
priv->scrolling_timeout_id = 0;
if (!priv->hide_scrollbars_timeout_id)
priv->hide_scrollbars_timeout_id = g_timeout_add (500,
hide_scrollbars_timeout, scrolled);
ret = FALSE;
}
gdk_threads_leave ();
return ret;
}
static gdouble
calculate_motion_scroll_values (gdouble old_value,
gdouble upper_limit,
gint current_coordinate,
gint previous_coordinate)
{
gdouble new_value = old_value;
gint movement;
movement = current_coordinate - previous_coordinate;
if (old_value - movement < upper_limit)
new_value = old_value - movement;
else
new_value = upper_limit;
return new_value;
}
static void
do_motion_scroll (KatzeScrolled* scrolled,
GtkWidget* widget,
gint x,
gint y,
guint32 timestamp)
{
KatzeScrolledPrivate* priv = scrolled->priv;
if (priv->dragged || gtk_drag_check_threshold (widget, priv->start_x, priv->start_y, x, y))
{
GtkAdjustment* hadjustment;
GtkAdjustment* vadjustment;
gdouble hpage_size, hupper, hvalue, new_hvalue;
gdouble vpage_size, vupper, vvalue, new_vvalue;
if (timestamp - priv->previous_time > priv->dragging_stopped_delay || !priv->dragged)
{
priv->dragged = TRUE;
priv->going_right = priv->start_x < x;
priv->going_down = priv->start_y < y;
priv->start_x = priv->farest_x = x;
priv->start_y = priv->farest_y = y;
priv->start_time = priv->farest_time = timestamp;
}
else
{
if ((priv->going_right && x > priv->farest_x)
|| (!priv->going_right && x < priv->farest_x))
{
priv->farest_x = x;
priv->farest_time = timestamp;
}
if ((priv->going_down && y > priv->farest_y)
|| (!priv->going_down && y < priv->farest_y))
{
priv->farest_y = y;
priv->farest_time = timestamp;
}
if (gtk_drag_check_threshold (widget, priv->farest_x, priv->farest_y, x, y))
{
priv->start_x = priv->farest_x;
priv->farest_x = x;
priv->start_y = priv->farest_y;
priv->farest_y = y;
priv->start_time = priv->farest_time;
priv->farest_time = timestamp;
priv->going_right = priv->start_x < x;
priv->going_down = priv->start_y < y;
}
}
hadjustment = gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (scrolled));
hpage_size = gtk_adjustment_get_page_size (hadjustment);
hupper = gtk_adjustment_get_upper (hadjustment);
hvalue = gtk_adjustment_get_value (hadjustment);
new_hvalue = calculate_motion_scroll_values (hvalue,
hupper - hpage_size, x, priv->previous_x);
vadjustment = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled));
vpage_size = gtk_adjustment_get_page_size (vadjustment);
vupper = gtk_adjustment_get_upper (vadjustment);
vvalue = gtk_adjustment_get_value (vadjustment);
new_vvalue = calculate_motion_scroll_values (vvalue,
vupper - vpage_size, y, priv->previous_y);
if (new_vvalue != vvalue)
{
if (new_hvalue != hvalue)
{
disable_hadjustment (scrolled);
gtk_adjustment_set_value (hadjustment, new_hvalue);
enable_hadjustment (scrolled);
}
gtk_adjustment_set_value (vadjustment, new_vvalue);
}
else if (new_hvalue != hvalue)
gtk_adjustment_set_value (hadjustment, new_hvalue);
}
priv->previous_y = y;
priv->previous_x = x;
priv->previous_time = timestamp;
adjust_scrollbar (scrolled, priv->horizontal_scrollbar_window,
gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (scrolled)),
&priv->horizontal_scrollbar_size, FALSE);
adjust_scrollbar (scrolled, priv->vertical_scrollbar_window,
gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled)),
&priv->vertical_scrollbar_size, TRUE);
}
static gboolean
button_press_event (GtkWidget* widget,
GdkEventButton* event,
KatzeScrolled* scrolled)
{
KatzeScrolledPrivate* priv = scrolled->priv;
gint x;
gint y;
GdkModifierType mask;
if (!priv->drag_scrolling)
return FALSE;
if (event->button != 1)
return FALSE;
priv->press_received = TRUE;
if (event->time - priv->previous_time < priv->dragging_stopped_delay &&
gtk_drag_check_threshold (widget, priv->previous_x, priv->previous_y, x, y))
{
if (priv->scrolling_timeout_id)
{
g_source_remove (priv->scrolling_timeout_id);
priv->scrolling_timeout_id = 0;
}
gdk_window_get_pointer (gtk_widget_get_window (GTK_WIDGET (scrolled)),
&x, &y, &mask);
/* do_motion_scroll (scrolled, widget, x, y, event->time); */
}
else
{
if (priv->scrolling_timeout_id)
{
g_source_remove (priv->scrolling_timeout_id);
priv->scrolling_timeout_id = 0;
priv->previous_time = 0;
}
else
{
priv->dragged = FALSE;
priv->previous_time = event->time;
}
gdk_window_get_pointer (gtk_widget_get_window (GTK_WIDGET (scrolled)),
&x, &y, &mask);
priv->start_x = priv->previous_x = priv->farest_x = x;
priv->start_y = priv->previous_y = priv->farest_y = y;
priv->start_time = event->time;
}
if (priv->scrolling_hints
&& !gtk_widget_get_visible (gtk_scrolled_window_get_hscrollbar (
GTK_SCROLLED_WINDOW (scrolled)))
&& adjust_scrollbar (scrolled, priv->horizontal_scrollbar_window,
gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (scrolled)),
&priv->horizontal_scrollbar_size, FALSE))
{
gdk_window_raise (priv->horizontal_scrollbar_window);
gdk_window_show (priv->horizontal_scrollbar_window);
}
if (priv->scrolling_hints
&& !gtk_widget_get_visible (gtk_scrolled_window_get_vscrollbar (
GTK_SCROLLED_WINDOW (scrolled)))
&& adjust_scrollbar (scrolled, priv->vertical_scrollbar_window,
gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled)),
&priv->vertical_scrollbar_size, TRUE))
{
gdk_window_raise (priv->vertical_scrollbar_window);
gdk_window_show (priv->vertical_scrollbar_window);
}
if (priv->hide_scrollbars_timeout_id)
{
g_source_remove (priv->hide_scrollbars_timeout_id);
priv->hide_scrollbars_timeout_id = 0;
}
return FALSE;
}
static gboolean
button_release_event (GtkWidget* widget,
GdkEventButton* event,
KatzeScrolled* scrolled)
{
KatzeScrolledPrivate* priv = scrolled->priv;
gint x;
gint y;
GdkModifierType mask;
gdk_window_get_pointer (gtk_widget_get_window (GTK_WIDGET (scrolled)),
&x, &y, &mask);
if (priv->press_received &&
gtk_drag_check_threshold (widget, priv->start_x, priv->start_y, x, y)) {
priv->dragged = TRUE;
}
if (priv->press_received && priv->kinetic_scrolling &&
event->time - priv->previous_time < priv->dragging_stopped_delay) {
priv->vertical_speed = (gdouble)(priv->start_y - y) / (event->time - priv->start_time) * priv->interval;
priv->horizontal_speed = (gdouble)(priv->start_x - x) / (event->time - priv->start_time) * priv->interval;
if (ABS (priv->vertical_speed) > ABS (priv->horizontal_speed)) {
priv->vertical_deceleration = priv->deceleration;
priv->horizontal_deceleration = priv->deceleration * ABS (priv->horizontal_speed / priv->vertical_speed);
} else {
priv->horizontal_deceleration = priv->deceleration;
priv->vertical_deceleration = priv->deceleration * ABS (priv->vertical_speed / priv->horizontal_speed);
}
priv->scrolling_timeout_id = g_timeout_add (priv->interval, timeout_scroll, scrolled);
do_timeout_scroll (scrolled);
}
else if (!priv->hide_scrollbars_timeout_id) {
priv->hide_scrollbars_timeout_id = g_timeout_add (500, hide_scrollbars_timeout, scrolled);
}
priv->previous_x = x;
priv->previous_y = y;
priv->previous_time = event->time;
priv->press_received = FALSE;
return FALSE;
}
static gboolean
motion_notify_event (GtkWidget* widget,
GdkEventMotion* event,
KatzeScrolled* scrolled)
{
KatzeScrolledPrivate* priv = scrolled->priv;
gint x;
gint y;
GdkModifierType mask;
if (priv->press_received)
{
gdk_window_get_pointer (gtk_widget_get_window (GTK_WIDGET (scrolled)),
&x, &y, &mask);
do_motion_scroll (scrolled, widget, x, y, event->time);
}
return FALSE;
}
static gboolean
katze_scrolled_event_handler (GdkEvent* event,
KatzeScrolledState* state,
gpointer user_data)
{
gboolean stop_propagating;
GdkEventCrossing crossing;
stop_propagating = FALSE;
if (event->type == GDK_BUTTON_PRESS)
{
gdk_window_get_user_data (event->button.window, (gpointer)&current_widget);
if ((current_scrolled_window = g_tree_lookup (activated_widgets, current_widget)))
{
current_gdk_window = event->button.window;
stop_propagating = button_press_event (current_widget, &event->button, current_scrolled_window);
}
else
current_gdk_window = NULL;
}
else if (event->any.window == current_gdk_window)
{
if (event->type == GDK_MOTION_NOTIFY)
{
if (current_scrolled_window->priv->dragged)
stop_propagating = motion_notify_event (current_widget, &event->motion, current_scrolled_window);
else
{
stop_propagating = motion_notify_event (current_widget, &event->motion, current_scrolled_window);
if (current_scrolled_window->priv->dragged)
{
crossing.type = GDK_LEAVE_NOTIFY;
crossing.window = event->motion.window;
crossing.send_event = event->motion.send_event;
crossing.subwindow = gtk_widget_get_window (
GTK_WIDGET (current_scrolled_window));
crossing.time = event->motion.time;
crossing.x = event->motion.x;
crossing.y = event->motion.y;
crossing.x_root = event->motion.x_root;
crossing.y_root = event->motion.y_root;
crossing.mode = GDK_CROSSING_GRAB;
crossing.detail = GDK_NOTIFY_ANCESTOR;
crossing.focus = TRUE;
crossing.state = event->motion.state;
gtk_main_do_event ((GdkEvent*)&crossing);
synthetized_crossing_event = TRUE;
}
}
}
else if ((event->type == GDK_ENTER_NOTIFY || event->type == GDK_LEAVE_NOTIFY) &&
synthetized_crossing_event)
stop_propagating = TRUE;
else if (event->type == GDK_BUTTON_RELEASE)
stop_propagating = button_release_event (current_widget, &event->button, current_scrolled_window);
}
if (!stop_propagating)
katze_scrolled_event_handler_next (event, state);
if (event->type == GDK_BUTTON_RELEASE && event->button.window == current_gdk_window)
{
crossing.type = GDK_ENTER_NOTIFY;
crossing.window = event->button.window;
crossing.send_event = event->button.send_event;
crossing.subwindow = gtk_widget_get_window (
GTK_WIDGET (current_scrolled_window));
crossing.time = event->button.time;
crossing.x = event->button.x;
crossing.y = event->button.y;
crossing.x_root = event->button.x_root;
crossing.y_root = event->button.y_root;
crossing.mode = GDK_CROSSING_UNGRAB;
crossing.detail = GDK_NOTIFY_ANCESTOR;
crossing.focus = TRUE;
crossing.state = event->button.state;
gtk_main_do_event ((GdkEvent*)&crossing);
synthetized_crossing_event = FALSE;
}
return stop_propagating;
}
static void
katze_scrolled_add (GtkContainer* container,
GtkWidget* widget)
{
katze_scrolled_activate_scrolling (KATZE_SCROLLED (container), widget);
(*GTK_CONTAINER_CLASS (katze_scrolled_parent_class)->add) (container, widget);
}
static void
katze_scrolled_realize (GtkWidget* widget)
{
KatzeScrolled* scrolled = KATZE_SCROLLED (widget);
KatzeScrolledPrivate* priv = scrolled->priv;
gboolean drag_scrolling;
GtkPolicyType policy;
GdkWindow* window;
GdkWindowAttr attr;
GdkColor color;
(*GTK_WIDGET_CLASS (katze_scrolled_parent_class)->realize) (widget);
drag_scrolling = katze_widget_has_touchscreen_mode (widget);
policy = drag_scrolling ? GTK_POLICY_NEVER : GTK_POLICY_AUTOMATIC;
g_object_set (scrolled, "drag-scrolling", drag_scrolling,
"hscrollbar-policy", policy, "vscrollbar-policy", policy, NULL);
window = g_object_ref (gtk_widget_get_parent_window (widget));
gtk_widget_set_window (widget, window);
attr.height = attr.width = 10;
attr.event_mask = GDK_EXPOSURE_MASK;
attr.wclass = GDK_INPUT_OUTPUT;
attr.window_type = GDK_WINDOW_CHILD;
attr.override_redirect = TRUE;
priv->vertical_scrollbar_window = gdk_window_new (window, &attr, 0);
priv->horizontal_scrollbar_window = gdk_window_new (window, &attr, 0);
gdk_window_set_user_data (priv->vertical_scrollbar_window, widget);
gdk_window_set_user_data (priv->horizontal_scrollbar_window, widget);
g_signal_connect (widget, "expose-event",
G_CALLBACK (on_expose_event), scrolled);
color.red = color.green = color.blue = 0x9999;
gdk_rgb_find_color (gtk_widget_get_colormap (widget), &color);
gdk_window_set_background (priv->vertical_scrollbar_window, &color);
gdk_window_set_background (priv->horizontal_scrollbar_window, &color);
priv->hilight_gc = gdk_gc_new (window);
color.red = color.green = color.blue = 0xcccc;
gdk_gc_set_rgb_fg_color (priv->hilight_gc, &color);
priv->shadow_gc = gdk_gc_new (window);
color.red = color.green = color.blue = 0x6666;
gdk_gc_set_rgb_fg_color (priv->shadow_gc, &color);
gtk_widget_set_realized (widget, TRUE);
}
static void
katze_scrolled_dispose (GObject* object)
{
KatzeScrolled* scrolled = KATZE_SCROLLED (object);
KatzeScrolledPrivate* priv = scrolled->priv;
if (priv->scrolling_timeout_id)
{
g_source_remove (priv->scrolling_timeout_id);
priv->scrolling_timeout_id = 0;
}
if (priv->hide_scrollbars_timeout_id)
{
g_source_remove (priv->hide_scrollbars_timeout_id);
priv->hide_scrollbars_timeout_id = 0;
}
(*G_OBJECT_CLASS (katze_scrolled_parent_class)->dispose) (object);
}
static void
katze_scrolled_class_init (KatzeScrolledClass* class)
{
GObjectClass* gobject_class;
GtkWidgetClass* widget_class;
GtkContainerClass* container_class;
GParamFlags flags = G_PARAM_READWRITE | G_PARAM_CONSTRUCT;
gobject_class = G_OBJECT_CLASS (class);
widget_class = GTK_WIDGET_CLASS (class);
container_class = GTK_CONTAINER_CLASS (class);
gobject_class->set_property = katze_scrolled_set_property;
gobject_class->get_property = katze_scrolled_get_property;
gobject_class->dispose = katze_scrolled_dispose;
widget_class->realize = katze_scrolled_realize;
container_class->add = katze_scrolled_add;
/**
* KatzeScrolled:drag-scrolling:
*
* Whether the widget can be scrolled by dragging its contents.
*
* If "gtk-touchscreen-mode" is enabled, drag scrolling is
* automatically enabled.
*
* Since: 0.2.0
*/
g_object_class_install_property (gobject_class,
PROP_DRAG_SCROLLING,
g_param_spec_boolean (
"drag-scrolling",
"Drag Scrolling",
"Whether the widget can be scrolled by dragging its contents",
FALSE,
flags));
/**
* KatzeScrolled:kinetic-scrolling:
*
* Whether drag scrolling is kinetic, that is releasing the
* pointer keeps the contents scrolling further relative to
* the speed with which they were dragged.
*
* Since: 0.2.0
*/
g_object_class_install_property (gobject_class,
PROP_KINETIC_SCROLLING,
g_param_spec_boolean (
"kinetic-scrolling",
"Kinetic Scrolling",
"Whether drag scrolling is kinetic",
TRUE,
flags));
activated_widgets = g_tree_new ((GCompareFunc)compare_pointers);
current_gdk_window = NULL;
/* Usually touchscreen mode is either always set or it isn't, so it
should be a safe optimization to not setup events if not needed. */
if (katze_widget_has_touchscreen_mode (NULL))
katze_scrolled_event_handler_append (katze_scrolled_event_handler, NULL);
g_type_class_add_private (class, sizeof (KatzeScrolledPrivate));
}
static void
katze_scrolled_init (KatzeScrolled* scrolled)
{
KatzeScrolledPrivate* priv;
scrolled->priv = priv = G_TYPE_INSTANCE_GET_PRIVATE ((scrolled),
KATZE_TYPE_SCROLLED, KatzeScrolledPrivate);
priv->interval = DEFAULT_INTERVAL;
priv->deceleration = DEFAULT_DECELERATION;
priv->drag_scrolling = FALSE;
priv->kinetic_scrolling = TRUE;
priv->dragging_stopped_delay = DEFAULT_DRAGGING_STOPPED_DELAY;
}
static void
katze_scrolled_set_property (GObject* object,
guint prop_id,
const GValue* value,
GParamSpec* pspec)
{
KatzeScrolled* scrolled = KATZE_SCROLLED (object);
switch (prop_id)
{
case PROP_DRAG_SCROLLING:
katze_scrolled_set_drag_scrolling (scrolled, g_value_get_boolean (value));
break;
case PROP_KINETIC_SCROLLING:
scrolled->priv->kinetic_scrolling = g_value_get_boolean (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
katze_scrolled_get_property (GObject* object,
guint prop_id,
GValue* value,
GParamSpec* pspec)
{
KatzeScrolled* scrolled = KATZE_SCROLLED (object);
switch (prop_id)
{
case PROP_DRAG_SCROLLING:
g_value_set_boolean (value, scrolled->priv->drag_scrolling);
break;
case PROP_KINETIC_SCROLLING:
g_value_set_boolean (value, scrolled->priv->kinetic_scrolling);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
/**
* katze_scrolled_new:
* @hadjustment: a horizontal #GtkAdjustment, or %NULL
* @vadjustment: a vertical #GtkAdjustment, or %NULL
*
* Creates a new #KatzeScrolled.
*
* Since: 0.2.0
**/
GtkWidget*
katze_scrolled_new (GtkAdjustment* hadjustment,
GtkAdjustment* vadjustment)
{
if (hadjustment)
g_return_val_if_fail (GTK_IS_ADJUSTMENT (hadjustment), NULL);
if (vadjustment)
g_return_val_if_fail (GTK_IS_ADJUSTMENT (vadjustment), NULL);
return gtk_widget_new (KATZE_TYPE_SCROLLED,
"hadjustment", hadjustment,
"vadjustment", vadjustment, NULL);
}
/**
* katze_scrolled_activate_scrolling:
* @scrolled: a #KatzeScrolled
* @widget: a #GtkWidget of which area is made active event source for
* drag and kinetic scrolling.
*
* Activates the widget so that pointer motion events inside the widget are
* used to scroll the #KatzeScrolled. The widget can be a child of the
* #KatzeScrolled or even a separate widget ("touchpad" style).
*
* The direct child of the #KatzeScrolled (typically #GtkViewport) is
* activated automatically when added. This function has to be used if indirect
* descendant widgets are stopping propagation of the button press and release
* as well as motion events (for example GtkButton is doing so) but scrolling
* should be possible inside their area too.
*
* This function adds #GDK_BUTTON_PRESS_MASK, #GDK_BUTTON_RELEASE_MASK,
* #GDK_POINTER_MOTION_MASK, and #GDK_MOTION_HINT_MAKS into the widgets event mask.
*/
static void
katze_scrolled_activate_scrolling (KatzeScrolled* scrolled,
GtkWidget* widget)
{
gtk_widget_add_events (widget,
GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK
| GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK);
g_tree_insert (activated_widgets, widget, scrolled);
}
static void
katze_scrolled_set_drag_scrolling (KatzeScrolled* scrolled,
gboolean drag_scrolling)
{
KatzeScrolledPrivate* priv = scrolled->priv;
if (priv->drag_scrolling && !drag_scrolling)
{
if (priv->scrolling_timeout_id)
{
g_source_remove (priv->scrolling_timeout_id);
priv->scrolling_timeout_id = 0;
priv->previous_time = 0;
}
gdk_window_hide (priv->vertical_scrollbar_window);
gdk_window_hide (priv->horizontal_scrollbar_window);
if (priv->hide_scrollbars_timeout_id)
{
g_source_remove (priv->hide_scrollbars_timeout_id);
priv->hide_scrollbars_timeout_id = 0;
}
priv->press_received = FALSE;
}
priv->drag_scrolling = drag_scrolling;
}
Reference in New Issue View Git Blame Copy Permalink