自学教程：C++ GTK_SCROLLABLE函数代码示例

voidnemo_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 voide_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 voidnemo_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 voiddrag_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 gbooleanwrap_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 voidget_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 voidcanvas_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 voidide_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 voidcainteoir_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 */voiditem_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 gbooleanchat_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 voidgnc_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 voidhorizontal_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 voiddisconnect_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 gbooleanscroll_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 voidupdate_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 voidgb_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 voidtest_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 voidforce_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 voidcanvas_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);}

gbooleanscroll_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 voidassert_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 voidscroll_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 gbooleane_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;}