void
nemo_icon_dnd_begin_drag (NemoIconContainer *container,
GdkDragAction actions,
int button,
GdkEventMotion *event,
int start_x,
int start_y)
{
NemoIconDndInfo *dnd_info;
g_return_if_fail (NEMO_IS_ICON_CONTAINER (container));
g_return_if_fail (event != NULL);
dnd_info = container->details->dnd_info;
g_return_if_fail (dnd_info != NULL);
/* Notice that the event is in bin_window coordinates, because of
the way the canvas handles events.
*/
dnd_info->drag_info.start_x = start_x -
gtk_adjustment_get_value (gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (container)));
dnd_info->drag_info.start_y = start_y -
gtk_adjustment_get_value (gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (container)));
/* start the drag */
gtk_drag_begin (GTK_WIDGET (container),
dnd_info->drag_info.target_list,
actions,
button,
(GdkEvent *) event);
}
static void
e_canvas_show_area (GnomeCanvas *canvas,
gdouble x1,
gdouble y1,
gdouble x2,
gdouble y2)
{
GtkAdjustment *h, *v;
gint dx = 0, dy = 0;
gdouble page_size;
gdouble lower;
gdouble upper;
gdouble value;
g_return_if_fail (canvas != NULL);
g_return_if_fail (GNOME_IS_CANVAS (canvas));
h = gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (canvas));
page_size = gtk_adjustment_get_page_size (h);
lower = gtk_adjustment_get_lower (h);
upper = gtk_adjustment_get_upper (h);
value = gtk_adjustment_get_value (h);
dx = compute_offset (x1, x2, value, value + page_size);
if (dx)
gtk_adjustment_set_value (h, CLAMP (value + dx, lower, upper - page_size));
v = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (canvas));
page_size = gtk_adjustment_get_page_size (v);
lower = gtk_adjustment_get_lower (v);
upper = gtk_adjustment_get_upper (v);
value = gtk_adjustment_get_value (v);
dy = compute_offset (y1, y2, value, value + page_size);
if (dy)
gtk_adjustment_set_value (v, CLAMP (value + dy, lower, upper - page_size));
}
static void
nemo_icon_container_receive_dropped_icons (NemoIconContainer *container,
GdkDragContext *context,
int x, int y)
{
char *drop_target;
gboolean local_move_only;
double world_x, world_y;
gboolean icon_hit;
GdkDragAction action, real_action;
drop_target = NULL;
if (container->details->dnd_info->drag_info.selection_list == NULL) {
return;
}
real_action = gdk_drag_context_get_selected_action (context);
if (real_action == GDK_ACTION_ASK) {
/* FIXME bugzilla.gnome.org 42485: This belongs in FMDirectoryView, not here. */
/* Check for special case items in selection list */
if (nemo_drag_selection_includes_special_link (container->details->dnd_info->drag_info.selection_list)) {
/* We only want to move the trash */
action = GDK_ACTION_MOVE;
} else {
action = GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_LINK;
}
real_action = nemo_drag_drop_action_ask (GTK_WIDGET (container), action);
}
if (real_action > 0) {
eel_canvas_window_to_world (EEL_CANVAS (container),
x + gtk_adjustment_get_value (gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (container))),
y + gtk_adjustment_get_value (gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (container))),
&world_x, &world_y);
drop_target = nemo_icon_container_find_drop_target (container,
context, x, y, &icon_hit, FALSE);
local_move_only = FALSE;
if (!icon_hit && real_action == GDK_ACTION_MOVE) {
/* we can just move the icon positions if the move ended up in
* the item's parent container
*/
local_move_only = nemo_icon_container_selection_items_local
(container, container->details->dnd_info->drag_info.selection_list);
}
if (local_move_only) {
handle_local_move (container, world_x, world_y);
} else {
handle_nonlocal_move (container, real_action, world_x, world_y, drop_target, icon_hit);
}
}
g_free (drop_target);
nemo_drag_destroy_selection_list (container->details->dnd_info->drag_info.selection_list);
container->details->dnd_info->drag_info.selection_list = NULL;
}
static void
drag_begin_callback (GtkWidget *widget,
GdkDragContext *context,
gpointer data)
{
NemoIconContainer *container;
cairo_surface_t *surface;
double x1, y1, x2, y2, winx, winy;
int x_offset, y_offset;
int start_x, start_y;
container = NEMO_ICON_CONTAINER (widget);
start_x = container->details->dnd_info->drag_info.start_x +
gtk_adjustment_get_value (gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (container)));
start_y = container->details->dnd_info->drag_info.start_y +
gtk_adjustment_get_value (gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (container)));
/* create a pixmap and mask to drag with */
surface = nemo_icon_canvas_item_get_drag_surface (container->details->drag_icon->item);
/* compute the image's offset */
eel_canvas_item_get_bounds (EEL_CANVAS_ITEM (container->details->drag_icon->item),
&x1, &y1, &x2, &y2);
eel_canvas_world_to_window (EEL_CANVAS (container),
x1, y1, &winx, &winy);
x_offset = start_x - winx;
y_offset = start_y - winy;
cairo_surface_set_device_offset (surface, -x_offset, -y_offset);
gtk_drag_set_icon_surface (context, surface);
cairo_surface_destroy (surface);
}
static gboolean
wrap_table_child_focus_in (GtkWidget *widget,
GdkEventFocus *event,
gpointer data)
{
gint x, y;
GtkWidget *container, *viewport = NULL;
container = gtk_widget_get_parent (widget);
if (container)
{
viewport = gtk_widget_get_parent (container);
}
g_assert (container && viewport);
g_assert (GTK_IS_VIEWPORT (viewport));
g_return_val_if_fail (gtk_widget_get_realized (viewport), FALSE);
if (!wrap_table_child_visible_in (widget, viewport))
{
GtkAdjustment *hadj, *vadj;
hadj = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (viewport));
vadj = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (viewport));
gtk_widget_translate_coordinates (widget, container, 0, 0, &x, &y);
gtk_adjustment_set_value (hadj, MIN (x, gtk_adjustment_get_upper(hadj) - gtk_adjustment_get_page_size(hadj)));
gtk_adjustment_set_value (vadj, MIN (y, gtk_adjustment_get_upper(vadj) - gtk_adjustment_get_page_size(vadj)));
}
return FALSE;
}
static void
get_adjustments (SoliPrintPreview *preview,
GtkAdjustment **hadj,
GtkAdjustment **vadj)
{
*hadj = gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (preview->layout));
*vadj = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (preview->layout));
}
static void
canvas_widget_to_world (EelCanvas *canvas,
double widget_x, double widget_y,
double *world_x, double *world_y)
{
eel_canvas_window_to_world (canvas,
widget_x + gtk_adjustment_get_value (gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (canvas))),
widget_y + gtk_adjustment_get_value (gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (canvas))),
world_x, world_y);
}
static void
ide_terminal_page_connect_terminal (IdeTerminalPage *self,
VteTerminal *terminal)
{
GtkAdjustment *vadj;
vadj = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (terminal));
gtk_range_set_adjustment (GTK_RANGE (self->top_scrollbar), vadj);
g_signal_connect_object (terminal,
"focus-in-event",
G_CALLBACK (focus_in_event_cb),
self,
0);
g_signal_connect_object (terminal,
"window-title-changed",
G_CALLBACK (window_title_changed_cb),
self,
0);
if (terminal_has_notification_signal ())
{
g_signal_connect_object (terminal,
"notification-received",
G_CALLBACK (notification_received_cb),
self,
0);
}
}
static void
cainteoir_document_view_get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
CainteoirDocumentViewPrivate *priv = CAINTEOIR_DOCUMENT_VIEW_PRIVATE(object);
GtkScrollable *scroll = GTK_SCROLLABLE(priv->text_view);
switch (prop_id)
{
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
break;
// GtkScrollable interface:
case PROP_HADJUSTMENT:
g_value_set_object(value, gtk_scrollable_get_hadjustment(scroll));
break;
case PROP_VADJUSTMENT:
g_value_set_object(value, gtk_scrollable_get_vadjustment(scroll));
break;
case PROP_HSCROLL_POLICY:
g_value_set_enum(value, gtk_scrollable_get_hscroll_policy(scroll));
break;
case PROP_VSCROLL_POLICY:
g_value_set_enum(value, gtk_scrollable_get_vscroll_policy(scroll));
break;
}
}
/* cleans up the item list, sets up the iter hash when called for the first time */
void
item_list_view_clear (ItemListView *ilv)
{
GtkAdjustment *adj;
GtkTreeStore *itemstore;
itemstore = GTK_TREE_STORE (gtk_tree_view_get_model (ilv->priv->treeview));
/* unselecting all items is important to remove items
whose removal is deferred until unselecting */
gtk_tree_selection_unselect_all (gtk_tree_view_get_selection (ilv->priv->treeview));
adj = gtk_tree_view_get_vadjustment (ilv->priv->treeview);
gtk_adjustment_set_value (adj, 0.0);
#if GTK_API_VERSION >= 3
gtk_scrollable_set_vadjustment (GTK_SCROLLABLE (ilv->priv->treeview), adj);
#else
gtk_tree_view_set_vadjustment (ilv->priv->treeview, adj);
#endif
if (itemstore)
gtk_tree_store_clear (itemstore);
if (ilv->priv->item_id_to_iter)
g_hash_table_destroy (ilv->priv->item_id_to_iter);
ilv->priv->item_id_to_iter = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, g_free);
/* enable batch mode for following item adds */
ilv->priv->batch_mode = TRUE;
ilv->priv->batch_itemstore = item_list_view_create_tree_store ();
}
/* Code stolen from pidgin/gtkimhtml.c */
static gboolean
chat_text_view_scroll_cb (EmpathyChatTextView *view)
{
EmpathyChatTextViewPriv *priv;
GtkAdjustment *adj;
gdouble max_val;
priv = GET_PRIV (view);
adj = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (view));
max_val = gtk_adjustment_get_upper (adj) - gtk_adjustment_get_page_size (adj);
g_return_val_if_fail (priv->scroll_time != NULL, FALSE);
if (g_timer_elapsed (priv->scroll_time, NULL) > MAX_SCROLL_TIME) {
/* time's up. jump to the end and kill the timer */
gtk_adjustment_set_value (adj, max_val);
chat_text_view_scroll_stop (view);
return FALSE;
}
/* scroll by 1/3rd the remaining distance */
gtk_adjustment_set_value (adj, gtk_adjustment_get_value (adj) + ((max_val - gtk_adjustment_get_value (adj)) / 3));
return TRUE;
}
static void
_gtk_text_handle_parent_hierarchy_changed (GtkWidget *widget,
GtkWindow *previous_toplevel,
GtkTextHandle *handle)
{
GtkWidget *toplevel, *scrollable;
GtkTextHandlePrivate *priv;
priv = handle->priv;
toplevel = gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW);
if (previous_toplevel && !toplevel)
{
if (priv->windows[GTK_TEXT_HANDLE_POSITION_SELECTION_START].widget)
{
_gtk_window_remove_popover (GTK_WINDOW (previous_toplevel),
priv->windows[GTK_TEXT_HANDLE_POSITION_SELECTION_START].widget);
g_object_unref (priv->windows[GTK_TEXT_HANDLE_POSITION_SELECTION_START].widget);
priv->windows[GTK_TEXT_HANDLE_POSITION_SELECTION_START].widget = NULL;
}
if (priv->windows[GTK_TEXT_HANDLE_POSITION_SELECTION_END].widget)
{
_gtk_window_remove_popover (GTK_WINDOW (previous_toplevel),
priv->windows[GTK_TEXT_HANDLE_POSITION_SELECTION_END].widget);
g_object_unref (priv->windows[GTK_TEXT_HANDLE_POSITION_SELECTION_END].widget);
priv->windows[GTK_TEXT_HANDLE_POSITION_SELECTION_END].widget = NULL;
}
}
scrollable = gtk_text_handle_lookup_scrollable (handle);
_gtk_text_handle_update_scrollable (handle, GTK_SCROLLABLE (scrollable));
}
static void
gnc_header_set_property (GObject *object,
guint param_id,
const GValue *value,
GParamSpec *pspec)
{
GncHeader *header = GNC_HEADER (object);
GtkLayout *layout = GTK_LAYOUT (header);
gboolean needs_update = FALSE;
gchar *old_name;
switch (param_id)
{
case PROP_SHEET:
header->sheet = GNUCASH_SHEET (g_value_get_object (value));
gtk_scrollable_set_hadjustment (GTK_SCROLLABLE(layout), header->sheet->hadj);
needs_update = TRUE;
break;
case PROP_CURSOR_NAME:
old_name = header->cursor_name;
header->cursor_name = g_value_dup_string (value);
needs_update = !old_name || !header->cursor_name ||
strcmp (old_name, header->cursor_name) != 0;
g_free (old_name);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
break;
}
if ((header->sheet != NULL) && needs_update)
gnc_header_reconfigure (header);
}
static void
_gtk_text_handle_set_parent (GtkTextHandle *handle,
GtkWidget *parent)
{
GtkTextHandlePrivate *priv;
GtkWidget *scrollable = NULL;
priv = handle->priv;
if (priv->parent == parent)
return;
if (priv->parent && priv->hierarchy_changed_id &&
g_signal_handler_is_connected (priv->parent, priv->hierarchy_changed_id))
g_signal_handler_disconnect (priv->parent, priv->hierarchy_changed_id);
priv->parent = parent;
if (parent)
{
priv->hierarchy_changed_id =
g_signal_connect (parent, "hierarchy-changed",
G_CALLBACK (_gtk_text_handle_parent_hierarchy_changed),
handle);
scrollable = gtk_text_handle_lookup_scrollable (handle);
}
_gtk_text_handle_update_scrollable (handle, GTK_SCROLLABLE (scrollable));
}
void nsgtk_layout_set_vadjustment(GtkLayout *layout, GtkAdjustment *adj)
{
#if GTK_CHECK_VERSION(3,0,0)
gtk_scrollable_set_vadjustment(GTK_SCROLLABLE(layout), adj);
#else
gtk_layout_set_vadjustment(layout, adj);
#endif
}
GtkAdjustment *nsgtk_layout_get_hadjustment(GtkLayout *layout)
{
#if GTK_CHECK_VERSION(3,0,0)
return gtk_scrollable_get_hadjustment(GTK_SCROLLABLE(layout));
#else
return gtk_layout_get_hadjustment(layout);
#endif
}
static void
horizontal_policy_changed (GtkComboBox *combo_box,
GtkViewport *viewport)
{
GtkScrollablePolicy policy = gtk_combo_box_get_active (combo_box);
gtk_scrollable_set_hscroll_policy (GTK_SCROLLABLE (viewport), policy);
}
static void
_gtk_text_handle_scrollable_notify (GObject *object,
GParamSpec *pspec,
GtkTextHandle *handle)
{
if (pspec->value_type == GTK_TYPE_ADJUSTMENT)
_gtk_text_handle_set_scrollable (handle, GTK_SCROLLABLE (object));
}
static void
disconnect_view (GtkSourceMap *map)
{
GtkSourceMapPrivate *priv;
GtkAdjustment *vadj;
priv = gtk_source_map_get_instance_private (map);
if (priv->view == NULL)
{
return;
}
disconnect_buffer (map);
if (priv->buffer_binding != NULL)
{
g_object_remove_weak_pointer (G_OBJECT (priv->buffer_binding),
(gpointer *)&priv->buffer_binding);
g_binding_unbind (priv->buffer_binding);
priv->buffer_binding = NULL;
}
if (priv->indent_width_binding != NULL)
{
g_object_remove_weak_pointer (G_OBJECT (priv->indent_width_binding),
(gpointer *)&priv->indent_width_binding);
g_binding_unbind (priv->indent_width_binding);
priv->indent_width_binding = NULL;
}
if (priv->tab_width_binding != NULL)
{
g_object_remove_weak_pointer (G_OBJECT (priv->tab_width_binding),
(gpointer *)&priv->tab_width_binding);
g_binding_unbind (priv->tab_width_binding);
priv->tab_width_binding = NULL;
}
if (priv->view_notify_buffer_handler != 0)
{
g_signal_handler_disconnect (priv->view, priv->view_notify_buffer_handler);
priv->view_notify_buffer_handler = 0;
}
vadj = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (priv->view));
if (vadj != NULL)
{
g_signal_handler_disconnect (vadj, priv->view_vadj_value_changed_handler);
priv->view_vadj_value_changed_handler = 0;
g_signal_handler_disconnect (vadj, priv->view_vadj_notify_upper_handler);
priv->view_vadj_notify_upper_handler = 0;
}
g_object_remove_weak_pointer (G_OBJECT (priv->view), (gpointer *)&priv->view);
priv->view = NULL;
}
static gboolean
scroll_layout (gpointer data)
{
GtkWidget *layout = data;
GtkAdjustment *adj;
adj = gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (layout));
gtk_adjustment_set_value (adj, gtk_adjustment_get_value (adj) + 5.0);
return G_SOURCE_CONTINUE;
}
static GtkAdjustment *
terminal_adjustment(GtkWidget *terminal)
{
#ifdef USE_TEXT_VIEW
return terminal_adjustment_text_view(terminal);
#endif
#ifdef USE_VTE
return gtk_scrollable_get_vadjustment(GTK_SCROLLABLE(terminal));
#endif
g_assert_not_reached();
}
static void
update_child_vadjustment (GtkSourceMap *map)
{
GtkSourceMapPrivate *priv;
GtkAdjustment *vadj;
GtkAdjustment *child_vadj;
gdouble value;
gdouble upper;
gdouble page_size;
gdouble child_upper;
gdouble child_page_size;
gdouble new_value = 0.0;
priv = gtk_source_map_get_instance_private (map);
vadj = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (priv->view));
g_object_get (vadj,
"upper", &upper,
"value", &value,
"page-size", &page_size,
NULL);
child_vadj = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (priv->child_view));
g_object_get (child_vadj,
"upper", &child_upper,
"page-size", &child_page_size,
NULL);
/*
* FIXME:
* Technically we should take into account lower here, but in practice
* it is always 0.0.
*/
if (child_page_size < child_upper)
{
new_value = (value / (upper - page_size)) * (child_upper - child_page_size);
}
gtk_adjustment_set_value (child_vadj, new_value);
}
static void
gb_terminal_view_connect_terminal (GbTerminalView *self,
VteTerminal *terminal)
{
GtkAdjustment *vadj;
GQuark quark;
guint signal_id;
vadj = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (terminal));
if (terminal == self->terminal_top)
gtk_range_set_adjustment (GTK_RANGE (self->top_scrollbar), vadj);
else
gtk_range_set_adjustment (GTK_RANGE (self->bottom_scrollbar), vadj);
g_signal_connect_object (terminal,
"size-allocate",
G_CALLBACK (size_allocate_cb),
self,
0);
g_signal_connect_object (terminal,
"child-exited",
G_CALLBACK (child_exited_cb),
self,
0);
g_signal_connect_object (terminal,
"focus-in-event",
G_CALLBACK (focus_in_event_cb),
self,
0);
g_signal_connect_object (terminal,
"window-title-changed",
G_CALLBACK (window_title_changed_cb),
self,
0);
if (g_signal_parse_name ("notification-received",
VTE_TYPE_TERMINAL,
&signal_id,
&quark,
FALSE))
{
g_signal_connect_object (terminal,
"notification-received",
G_CALLBACK (notification_received_cb),
self,
0);
}
}
static void
test_position (GtkTreeView *tree_view,
GtkTreePath *path,
gboolean use_align,
gdouble row_align)
{
gint pos;
gchar *path_str;
GdkRectangle rect;
GtkTreeModel *model;
gint row_start;
/* Get the location of the path we scrolled to */
gtk_tree_view_get_background_area (GTK_TREE_VIEW (tree_view),
path, NULL, &rect);
row_start = get_row_start_for_index (GTK_TREE_VIEW (tree_view),
gtk_tree_path_get_indices (path)[0]);
/* Ugh */
pos = get_pos_from_path (GTK_TREE_VIEW (tree_view),
path, rect.height,
gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (tree_view)));
/* This is only tested for during test_single() */
model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree_view));
if (gtk_tree_model_iter_n_children (model, NULL) == 1) {
GtkAllocation allocation;
GtkTreePath *tmppath;
/* Test nothing is dangling at the bottom; read
* description for test_single() for more information.
*/
/* FIXME: hardcoded width */
gtk_widget_get_allocation (GTK_WIDGET (tree_view), &allocation);
if (gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (tree_view), 0, allocation.height - 30, &tmppath, NULL, NULL, NULL)) {
g_assert_not_reached ();
gtk_tree_path_free (tmppath);
}
}
path_str = gtk_tree_path_to_string (path);
if (use_align) {
assert_position_with_align (tree_view, pos, rect.y,
row_start, rect.height, row_align);
} else {
assert_position_without_align (tree_view, row_start, rect.height);
}
g_free (path_str);
}
static void
force_scroll_to_top (IdeSourceView *source_view)
{
GtkAdjustment *vadj;
GtkAdjustment *hadj;
gdouble lower;
/*
* FIXME:
*
* See the comment in gb_editor_view__buffer_changed_on_volume()
*/
vadj = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (source_view));
hadj = gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (source_view));
lower = gtk_adjustment_get_lower (vadj);
gtk_adjustment_set_value (vadj, lower);
lower = gtk_adjustment_get_lower (hadj);
gtk_adjustment_set_value (hadj, lower);
}
static void
canvas_rect_world_to_widget (EelCanvas *canvas,
EelDRect *world_rect,
EelIRect *widget_rect)
{
EelDRect window_rect;
GtkAdjustment *hadj, *vadj;
hadj = gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (canvas));
vadj = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (canvas));
eel_canvas_world_to_window (canvas,
world_rect->x0, world_rect->y0,
&window_rect.x0, &window_rect.y0);
eel_canvas_world_to_window (canvas,
world_rect->x1, world_rect->y1,
&window_rect.x1, &window_rect.y1);
widget_rect->x0 = (int) window_rect.x0 - gtk_adjustment_get_value (hadj);
widget_rect->y0 = (int) window_rect.y0 - gtk_adjustment_get_value (vadj);
widget_rect->x1 = (int) window_rect.x1 - gtk_adjustment_get_value (hadj);
widget_rect->y1 = (int) window_rect.y1 - gtk_adjustment_get_value (vadj);
}
gboolean
scroll_viewport (GtkWidget *viewport,
GdkFrameClock *frame_clock,
gpointer user_data)
{
static gint64 start_time;
gint64 now = gdk_frame_clock_get_frame_time (frame_clock);
gdouble elapsed;
GtkAdjustment *hadjustment, *vadjustment;
if (start_time == 0)
start_time = now;
elapsed = (now - start_time) / 1000000.;
hadjustment = gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (viewport));
vadjustment = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (viewport));
set_adjustment_to_fraction (hadjustment, 0.5 + 0.5 * sin (elapsed));
set_adjustment_to_fraction (vadjustment, 0.5 + 0.5 * cos (elapsed));
return TRUE;
}
static void
assert_position_without_align (GtkTreeView *tree_view,
gdouble row_start,
gdouble row_height)
{
GtkAdjustment *vadjustment = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (tree_view));
/* Without align the tree view does as less work as possible,
* so basically we only have to check whether the row
* is visible on the screen.
*/
g_assert (gtk_adjustment_get_value (vadjustment) <= row_start);
g_assert (gtk_adjustment_get_value (vadjustment) + gtk_adjustment_get_page_size (vadjustment) >= row_start + row_height);
}
static void
scroll_new_row_tree (ScrollFixture *fixture,
gconstpointer test_data)
{
GtkTreeModel *model;
GtkAdjustment *vadjustment;
int i;
/* The goal of this test is to append new rows at the end of a tree
* store and immediately scroll to them. If there is a parent
* node with a couple of childs in the "area above" to explore,
* this used to lead to unexpected results due to a bug.
*
* This issue has been reported by Miroslav Rajcic on
* gtk-app-devel-list:
* http://mail.gnome.org/archives/gtk-app-devel-list/2008-December/msg00068.html
*/
gtk_widget_show_all (fixture->window);
gtk_tree_view_expand_all (GTK_TREE_VIEW (fixture->tree_view));
while (gtk_events_pending ())
gtk_main_iteration ();
model = gtk_tree_view_get_model (GTK_TREE_VIEW (fixture->tree_view));
vadjustment = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (fixture->tree_view));
for (i = 0; i < 5; i++) {
GtkTreeIter scroll_iter;
GtkTreePath *scroll_path;
gtk_tree_store_append (GTK_TREE_STORE (model), &scroll_iter,
NULL);
gtk_tree_store_set (GTK_TREE_STORE (model), &scroll_iter,
0, "New node", -1);
scroll_path = gtk_tree_model_get_path (model, &scroll_iter);
gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (fixture->tree_view),
scroll_path, NULL, FALSE, 0.0, 0.0);
gtk_tree_path_free (scroll_path);
while (gtk_events_pending ())
gtk_main_iteration ();
/* Test position, the scroll bar must be at the end */
g_assert (gtk_adjustment_get_value (vadjustment) == gtk_adjustment_get_upper (vadjustment) - gtk_adjustment_get_page_size (vadjustment));
}
}
static gboolean
e_canvas_area_shown (GnomeCanvas *canvas,
gdouble x1,
gdouble y1,
gdouble x2,
gdouble y2)
{
GtkAdjustment *h, *v;
gint dx = 0, dy = 0;
gdouble page_size;
gdouble lower;
gdouble upper;
gdouble value;
g_return_val_if_fail (canvas != NULL, FALSE);
g_return_val_if_fail (GNOME_IS_CANVAS (canvas), FALSE);
h = gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (canvas));
page_size = gtk_adjustment_get_page_size (h);
lower = gtk_adjustment_get_lower (h);
upper = gtk_adjustment_get_upper (h);
value = gtk_adjustment_get_value (h);
dx = compute_offset (x1, x2, value, value + page_size);
if (CLAMP (value + dx, lower, upper - page_size) - value != 0)
return FALSE;
v = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (canvas));
page_size = gtk_adjustment_get_page_size (v);
lower = gtk_adjustment_get_lower (v);
upper = gtk_adjustment_get_upper (v);
value = gtk_adjustment_get_value (v);
dy = compute_offset (y1, y2, value, value + page_size);
if (CLAMP (value + dy, lower, upper - page_size) - value != 0)
return FALSE;
return TRUE;
}
