gtk2/gtk/gtkviewport.c
Timm Bäder 23a1328fda viewport: Simplify child allocation
allocation->x and allocation->y are always 0
2017-10-31 10:10:53 +01:00

548 lines
17 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* GTK - The GIMP Toolkit
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
*
* 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 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that 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 library. If not, see <http://www.gnu.org/licenses/>.
*/
/*
* Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
* file for a list of people on the GTK+ Team. See the ChangeLog
* files for a list of changes. These files are distributed with
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
#include "config.h"
#include "gtkviewport.h"
#include "gtkadjustment.h"
#include "gtkintl.h"
#include "gtkmarshalers.h"
#include "gtkprivate.h"
#include "gtkrenderbackgroundprivate.h"
#include "gtkscrollable.h"
#include "gtksnapshot.h"
#include "gtkstylecontextprivate.h"
#include "gtktypebuiltins.h"
#include "gtkwidgetprivate.h"
/**
* SECTION:gtkviewport
* @Short_description: An adapter which makes widgets scrollable
* @Title: GtkViewport
* @See_also:#GtkScrolledWindow, #GtkAdjustment
*
* The #GtkViewport widget acts as an adaptor class, implementing
* scrollability for child widgets that lack their own scrolling
* capabilities. Use GtkViewport to scroll child widgets such as
* #GtkGrid, #GtkBox, and so on.
*
* If a widget has native scrolling abilities, such as #GtkTextView,
* #GtkTreeView or #GtkIconView, it can be added to a #GtkScrolledWindow
* with gtk_container_add(). If a widget does not, you must first add the
* widget to a #GtkViewport, then add the viewport to the scrolled window.
* gtk_container_add() does this automatically if a child that does not
* implement #GtkScrollable is added to a #GtkScrolledWindow, so you can
* ignore the presence of the viewport.
*
* The GtkViewport will start scrolling content only if allocated less
* than the child widgets minimum size in a given orientation.
*
* # CSS nodes
*
* GtkViewport has a single CSS node with name viewport.
*/
struct _GtkViewportPrivate
{
GtkAdjustment *hadjustment;
GtkAdjustment *vadjustment;
GtkShadowType shadow_type;
/* GtkScrollablePolicy needs to be checked when
* driving the scrollable adjustment values */
guint hscroll_policy : 1;
guint vscroll_policy : 1;
};
enum {
PROP_0,
PROP_HADJUSTMENT,
PROP_VADJUSTMENT,
PROP_HSCROLL_POLICY,
PROP_VSCROLL_POLICY,
PROP_SHADOW_TYPE
};
static void gtk_viewport_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec);
static void gtk_viewport_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec);
static void gtk_viewport_destroy (GtkWidget *widget);
static void gtk_viewport_snapshot (GtkWidget *widget,
GtkSnapshot *snapshot);
static void gtk_viewport_size_allocate (GtkWidget *widget,
const GtkAllocation *allocation,
int baseline,
GtkAllocation *out_clip);
static void gtk_viewport_adjustment_value_changed (GtkAdjustment *adjustment,
gpointer data);
static void viewport_set_adjustment (GtkViewport *viewport,
GtkOrientation orientation,
GtkAdjustment *adjustment);
G_DEFINE_TYPE_WITH_CODE (GtkViewport, gtk_viewport, GTK_TYPE_BIN,
G_ADD_PRIVATE (GtkViewport)
G_IMPLEMENT_INTERFACE (GTK_TYPE_SCROLLABLE, NULL))
static void
viewport_set_adjustment_values (GtkViewport *viewport,
GtkOrientation orientation)
{
GtkBin *bin = GTK_BIN (viewport);
GtkViewportPrivate *priv = gtk_viewport_get_instance_private (viewport);
GtkAdjustment *adjustment;
GtkScrollablePolicy scroll_policy;
GtkScrollablePolicy other_scroll_policy;
GtkOrientation other_orientation;
GtkWidget *child;
gdouble upper, value;
int viewport_size, other_viewport_size;
int view_width, view_height;
gtk_widget_get_content_size (GTK_WIDGET (viewport), &view_width, &view_height);
if (orientation == GTK_ORIENTATION_HORIZONTAL)
{
adjustment = priv->hadjustment;
other_orientation = GTK_ORIENTATION_VERTICAL;
viewport_size = view_width;
other_viewport_size = view_height;
scroll_policy = priv->hscroll_policy;
other_scroll_policy = priv->vscroll_policy;
}
else /* VERTICAL */
{
adjustment = priv->vadjustment;
other_orientation = GTK_ORIENTATION_HORIZONTAL;
viewport_size = view_height;
other_viewport_size = view_width;
scroll_policy = priv->vscroll_policy;
other_scroll_policy = priv->hscroll_policy;
}
child = gtk_bin_get_child (bin);
if (child && gtk_widget_get_visible (child))
{
int min_size, nat_size;
int scroll_size;
if (other_scroll_policy == GTK_SCROLL_MINIMUM)
gtk_widget_measure (child, other_orientation, -1,
&scroll_size, NULL, NULL, NULL);
else
gtk_widget_measure (child, other_orientation, -1,
NULL, &scroll_size, NULL, NULL);
gtk_widget_measure (child, orientation,
MAX (other_viewport_size, scroll_size),
&min_size, &nat_size, NULL, NULL);
if (scroll_policy == GTK_SCROLL_MINIMUM)
upper = MAX (min_size, viewport_size);
else
upper = MAX (nat_size, viewport_size);
}
else
{
upper = viewport_size;
}
value = gtk_adjustment_get_value (adjustment);
/* We clamp to the left in RTL mode */
if (orientation == GTK_ORIENTATION_HORIZONTAL &&
_gtk_widget_get_direction (GTK_WIDGET (viewport)) == GTK_TEXT_DIR_RTL)
{
gdouble dist = gtk_adjustment_get_upper (adjustment)
- value
- gtk_adjustment_get_page_size (adjustment);
value = upper - dist - viewport_size;
}
gtk_adjustment_configure (adjustment,
value,
0,
upper,
viewport_size * 0.1,
viewport_size * 0.9,
viewport_size);
}
static void
gtk_viewport_measure (GtkWidget *widget,
GtkOrientation orientation,
int for_size,
int *minimum,
int *natural,
int *minimum_baseline,
int *natural_baseline)
{
GtkWidget *child;
*minimum = *natural = 0;
child = gtk_bin_get_child (GTK_BIN (widget));
if (child && gtk_widget_get_visible (child))
gtk_widget_measure (child,
orientation,
for_size,
minimum, natural,
NULL, NULL);
}
static void
gtk_viewport_class_init (GtkViewportClass *class)
{
GObjectClass *gobject_class;
GtkWidgetClass *widget_class;
gobject_class = G_OBJECT_CLASS (class);
widget_class = (GtkWidgetClass*) class;
gobject_class->set_property = gtk_viewport_set_property;
gobject_class->get_property = gtk_viewport_get_property;
widget_class->destroy = gtk_viewport_destroy;
widget_class->snapshot = gtk_viewport_snapshot;
widget_class->size_allocate = gtk_viewport_size_allocate;
widget_class->measure = gtk_viewport_measure;
gtk_widget_class_set_accessible_role (widget_class, ATK_ROLE_VIEWPORT);
/* GtkScrollable implementation */
g_object_class_override_property (gobject_class, PROP_HADJUSTMENT, "hadjustment");
g_object_class_override_property (gobject_class, PROP_VADJUSTMENT, "vadjustment");
g_object_class_override_property (gobject_class, PROP_HSCROLL_POLICY, "hscroll-policy");
g_object_class_override_property (gobject_class, PROP_VSCROLL_POLICY, "vscroll-policy");
g_object_class_install_property (gobject_class,
PROP_SHADOW_TYPE,
g_param_spec_enum ("shadow-type",
P_("Shadow type"),
P_("Determines how the shadowed box around the viewport is drawn"),
GTK_TYPE_SHADOW_TYPE,
GTK_SHADOW_IN,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY));
gtk_widget_class_set_css_name (widget_class, "viewport");
}
static void
gtk_viewport_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GtkViewport *viewport;
viewport = GTK_VIEWPORT (object);
switch (prop_id)
{
case PROP_HADJUSTMENT:
viewport_set_adjustment (viewport, GTK_ORIENTATION_HORIZONTAL, g_value_get_object (value));
break;
case PROP_VADJUSTMENT:
viewport_set_adjustment (viewport, GTK_ORIENTATION_VERTICAL, g_value_get_object (value));
break;
case PROP_HSCROLL_POLICY:
if (viewport->priv->hscroll_policy != g_value_get_enum (value))
{
viewport->priv->hscroll_policy = g_value_get_enum (value);
gtk_widget_queue_resize (GTK_WIDGET (viewport));
g_object_notify_by_pspec (object, pspec);
}
break;
case PROP_VSCROLL_POLICY:
if (viewport->priv->vscroll_policy != g_value_get_enum (value))
{
viewport->priv->vscroll_policy = g_value_get_enum (value);
gtk_widget_queue_resize (GTK_WIDGET (viewport));
g_object_notify_by_pspec (object, pspec);
}
break;
case PROP_SHADOW_TYPE:
gtk_viewport_set_shadow_type (viewport, g_value_get_enum (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gtk_viewport_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GtkViewport *viewport = GTK_VIEWPORT (object);
GtkViewportPrivate *priv = viewport->priv;
switch (prop_id)
{
case PROP_HADJUSTMENT:
g_value_set_object (value, priv->hadjustment);
break;
case PROP_VADJUSTMENT:
g_value_set_object (value, priv->vadjustment);
break;
case PROP_HSCROLL_POLICY:
g_value_set_enum (value, priv->hscroll_policy);
break;
case PROP_VSCROLL_POLICY:
g_value_set_enum (value, priv->vscroll_policy);
break;
case PROP_SHADOW_TYPE:
g_value_set_enum (value, priv->shadow_type);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gtk_viewport_init (GtkViewport *viewport)
{
GtkWidget *widget;
GtkViewportPrivate *priv;
viewport->priv = gtk_viewport_get_instance_private (viewport);
priv = viewport->priv;
widget = GTK_WIDGET (viewport);
gtk_widget_set_has_window (widget, FALSE);
priv->shadow_type = GTK_SHADOW_IN;
priv->hadjustment = NULL;
priv->vadjustment = NULL;
gtk_style_context_add_class (gtk_widget_get_style_context (widget),
GTK_STYLE_CLASS_FRAME);
viewport_set_adjustment (viewport, GTK_ORIENTATION_HORIZONTAL, NULL);
viewport_set_adjustment (viewport, GTK_ORIENTATION_VERTICAL, NULL);
}
/**
* gtk_viewport_new:
* @hadjustment: (allow-none): horizontal adjustment
* @vadjustment: (allow-none): vertical adjustment
*
* Creates a new #GtkViewport with the given adjustments, or with default
* adjustments if none are given.
*
* Returns: a new #GtkViewport
*/
GtkWidget*
gtk_viewport_new (GtkAdjustment *hadjustment,
GtkAdjustment *vadjustment)
{
GtkWidget *viewport;
viewport = g_object_new (GTK_TYPE_VIEWPORT,
"hadjustment", hadjustment,
"vadjustment", vadjustment,
NULL);
return viewport;
}
#define ADJUSTMENT_POINTER(viewport, orientation) \
(((orientation) == GTK_ORIENTATION_HORIZONTAL) ? \
&(viewport)->priv->hadjustment : &(viewport)->priv->vadjustment)
static void
viewport_disconnect_adjustment (GtkViewport *viewport,
GtkOrientation orientation)
{
GtkAdjustment **adjustmentp = ADJUSTMENT_POINTER (viewport, orientation);
if (*adjustmentp)
{
g_signal_handlers_disconnect_by_func (*adjustmentp,
gtk_viewport_adjustment_value_changed,
viewport);
g_object_unref (*adjustmentp);
*adjustmentp = NULL;
}
}
static void
gtk_viewport_destroy (GtkWidget *widget)
{
GtkViewport *viewport = GTK_VIEWPORT (widget);
viewport_disconnect_adjustment (viewport, GTK_ORIENTATION_HORIZONTAL);
viewport_disconnect_adjustment (viewport, GTK_ORIENTATION_VERTICAL);
GTK_WIDGET_CLASS (gtk_viewport_parent_class)->destroy (widget);
}
static void
viewport_set_adjustment (GtkViewport *viewport,
GtkOrientation orientation,
GtkAdjustment *adjustment)
{
GtkAdjustment **adjustmentp = ADJUSTMENT_POINTER (viewport, orientation);
if (adjustment && adjustment == *adjustmentp)
return;
if (!adjustment)
adjustment = gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
viewport_disconnect_adjustment (viewport, orientation);
*adjustmentp = adjustment;
g_object_ref_sink (adjustment);
viewport_set_adjustment_values (viewport, orientation);
g_signal_connect (adjustment, "value-changed",
G_CALLBACK (gtk_viewport_adjustment_value_changed),
viewport);
gtk_viewport_adjustment_value_changed (adjustment, viewport);
}
/**
* gtk_viewport_set_shadow_type:
* @viewport: a #GtkViewport.
* @type: the new shadow type.
*
* Sets the shadow type of the viewport.
**/
void
gtk_viewport_set_shadow_type (GtkViewport *viewport,
GtkShadowType type)
{
GtkViewportPrivate *priv;
GtkWidget *widget;
GtkStyleContext *context;
g_return_if_fail (GTK_IS_VIEWPORT (viewport));
widget = GTK_WIDGET (viewport);
priv = viewport->priv;
if ((GtkShadowType) priv->shadow_type != type)
{
priv->shadow_type = type;
context = gtk_widget_get_style_context (widget);
if (type != GTK_SHADOW_NONE)
gtk_style_context_add_class (context, GTK_STYLE_CLASS_FRAME);
else
gtk_style_context_remove_class (context, GTK_STYLE_CLASS_FRAME);
gtk_widget_queue_resize (widget);
g_object_notify (G_OBJECT (viewport), "shadow-type");
}
}
/**
* gtk_viewport_get_shadow_type:
* @viewport: a #GtkViewport
*
* Gets the shadow type of the #GtkViewport. See
* gtk_viewport_set_shadow_type().
*
* Returns: the shadow type
**/
GtkShadowType
gtk_viewport_get_shadow_type (GtkViewport *viewport)
{
g_return_val_if_fail (GTK_IS_VIEWPORT (viewport), GTK_SHADOW_NONE);
return viewport->priv->shadow_type;
}
static void
gtk_viewport_snapshot (GtkWidget *widget,
GtkSnapshot *snapshot)
{
int width, height;
gtk_widget_get_content_size (widget, &width, &height);
gtk_snapshot_push_clip (snapshot,
&GRAPHENE_RECT_INIT(0, 0, width, height), "Viewport");
GTK_WIDGET_CLASS (gtk_viewport_parent_class)->snapshot (widget, snapshot);
gtk_snapshot_pop (snapshot);
}
static void
gtk_viewport_size_allocate (GtkWidget *widget,
const GtkAllocation *allocation,
int baseline,
GtkAllocation *out_clip)
{
GtkViewport *viewport = GTK_VIEWPORT (widget);
GtkViewportPrivate *priv = viewport->priv;
GtkAdjustment *hadjustment = priv->hadjustment;
GtkAdjustment *vadjustment = priv->vadjustment;
GtkWidget *child;
g_object_freeze_notify (G_OBJECT (hadjustment));
g_object_freeze_notify (G_OBJECT (vadjustment));
viewport_set_adjustment_values (viewport, GTK_ORIENTATION_HORIZONTAL);
viewport_set_adjustment_values (viewport, GTK_ORIENTATION_VERTICAL);
child = gtk_bin_get_child (GTK_BIN (widget));
if (child && gtk_widget_get_visible (child))
{
GtkAllocation child_allocation, child_clip;
child_allocation.x = - gtk_adjustment_get_value (hadjustment);
child_allocation.y = - gtk_adjustment_get_value (vadjustment);
child_allocation.width = gtk_adjustment_get_upper (hadjustment);
child_allocation.height = gtk_adjustment_get_upper (vadjustment);
/* Explicitly ignore the child clip here. */
gtk_widget_size_allocate (child, &child_allocation, -1, &child_clip);
}
g_object_thaw_notify (G_OBJECT (hadjustment));
g_object_thaw_notify (G_OBJECT (vadjustment));
}
static void
gtk_viewport_adjustment_value_changed (GtkAdjustment *adjustment,
gpointer data)
{
gtk_widget_queue_allocate (GTK_WIDGET (data));
}