/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /* * Copyright 2013, 2015 Red Hat, Inc. * * This program 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 program 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 program; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * * Author: Alexander Larsson * Carlos Soriano */ #include "config.h" #include "gtkrevealer.h" #include #include "gtktypebuiltins.h" #include "gtkprivate.h" #include "gtkintl.h" #include "fallback-c89.c" /** * SECTION:gtkrevealer * @Short_description: Hide and show with animation * @Title: GtkRevealer * @See_also: #GtkExpander * * The GtkRevealer widget is a container which animates * the transition of its child from invisible to visible. * * The style of transition can be controlled with * gtk_revealer_set_transition_type(). * * These animations respect the #GtkSettings:gtk-enable-animations * setting. * * The GtkRevealer widget was added in GTK+ 3.10. */ /** * GtkRevealerTransitionType: * @GTK_REVEALER_TRANSITION_TYPE_NONE: No transition * @GTK_REVEALER_TRANSITION_TYPE_CROSSFADE: Fade in * @GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT: Slide in from the left * @GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT: Slide in from the right * @GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP: Slide in from the bottom * @GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN: Slide in from the top * * These enumeration values describe the possible transitions * when the child of a #GtkRevealer widget is shown or hidden. */ enum { PROP_0, PROP_TRANSITION_TYPE, PROP_TRANSITION_DURATION, PROP_REVEAL_CHILD, PROP_CHILD_REVEALED, LAST_PROP }; typedef struct { GtkRevealerTransitionType transition_type; guint transition_duration; GdkWindow* bin_window; GdkWindow* view_window; gdouble current_pos; gdouble source_pos; gdouble target_pos; guint tick_id; gint64 start_time; gint64 end_time; } GtkRevealerPrivate; static GParamSpec *props[LAST_PROP] = { NULL, }; static void gtk_revealer_real_realize (GtkWidget *widget); static void gtk_revealer_real_unrealize (GtkWidget *widget); static void gtk_revealer_real_add (GtkContainer *widget, GtkWidget *child); static void gtk_revealer_real_size_allocate (GtkWidget *widget, GtkAllocation *allocation); static void gtk_revealer_real_map (GtkWidget *widget); static void gtk_revealer_real_unmap (GtkWidget *widget); static gboolean gtk_revealer_real_draw (GtkWidget *widget, cairo_t *cr); static void gtk_revealer_real_get_preferred_height (GtkWidget *widget, gint *minimum_height, gint *natural_height); static void gtk_revealer_real_get_preferred_height_for_width (GtkWidget *widget, gint width, gint *minimum_height, gint *natural_height); static void gtk_revealer_real_get_preferred_width (GtkWidget *widget, gint *minimum_width, gint *natural_width); static void gtk_revealer_real_get_preferred_width_for_height (GtkWidget *widget, gint height, gint *minimum_width, gint *natural_width); G_DEFINE_TYPE_WITH_PRIVATE (GtkRevealer, gtk_revealer, GTK_TYPE_BIN) static void gtk_revealer_get_padding (GtkRevealer *revealer, GtkBorder *padding) { GtkWidget *widget = GTK_WIDGET (revealer); GtkStyleContext *context; GtkStateFlags state; context = gtk_widget_get_style_context (widget); state = gtk_style_context_get_state (context); gtk_style_context_get_padding (context, state, padding); } static void gtk_revealer_init (GtkRevealer *revealer) { GtkRevealerPrivate *priv = gtk_revealer_get_instance_private (revealer); priv->transition_type = GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN; priv->transition_duration = 250; priv->current_pos = 0.0; priv->target_pos = 0.0; gtk_widget_set_has_window ((GtkWidget*) revealer, TRUE); gtk_widget_set_redraw_on_allocate ((GtkWidget*) revealer, FALSE); } static void gtk_revealer_finalize (GObject *obj) { GtkRevealer *revealer = GTK_REVEALER (obj); GtkRevealerPrivate *priv = gtk_revealer_get_instance_private (revealer); if (priv->tick_id != 0) gtk_widget_remove_tick_callback (GTK_WIDGET (revealer), priv->tick_id); priv->tick_id = 0; G_OBJECT_CLASS (gtk_revealer_parent_class)->finalize (obj); } static void gtk_revealer_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { GtkRevealer *revealer = GTK_REVEALER (object); switch (property_id) { case PROP_TRANSITION_TYPE: g_value_set_enum (value, gtk_revealer_get_transition_type (revealer)); break; case PROP_TRANSITION_DURATION: g_value_set_uint (value, gtk_revealer_get_transition_duration (revealer)); break; case PROP_REVEAL_CHILD: g_value_set_boolean (value, gtk_revealer_get_reveal_child (revealer)); break; case PROP_CHILD_REVEALED: g_value_set_boolean (value, gtk_revealer_get_child_revealed (revealer)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } } static void gtk_revealer_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { GtkRevealer *revealer = GTK_REVEALER (object); switch (property_id) { case PROP_TRANSITION_TYPE: gtk_revealer_set_transition_type (revealer, g_value_get_enum (value)); break; case PROP_TRANSITION_DURATION: gtk_revealer_set_transition_duration (revealer, g_value_get_uint (value)); break; case PROP_REVEAL_CHILD: gtk_revealer_set_reveal_child (revealer, g_value_get_boolean (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } } static void gtk_revealer_class_init (GtkRevealerClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); GtkWidgetClass *widget_class = GTK_WIDGET_CLASS(klass); GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass); object_class->get_property = gtk_revealer_get_property; object_class->set_property = gtk_revealer_set_property; object_class->finalize = gtk_revealer_finalize; widget_class->realize = gtk_revealer_real_realize; widget_class->unrealize = gtk_revealer_real_unrealize; widget_class->size_allocate = gtk_revealer_real_size_allocate; widget_class->map = gtk_revealer_real_map; widget_class->unmap = gtk_revealer_real_unmap; widget_class->draw = gtk_revealer_real_draw; widget_class->get_preferred_height = gtk_revealer_real_get_preferred_height; widget_class->get_preferred_height_for_width = gtk_revealer_real_get_preferred_height_for_width; widget_class->get_preferred_width = gtk_revealer_real_get_preferred_width; widget_class->get_preferred_width_for_height = gtk_revealer_real_get_preferred_width_for_height; container_class->add = gtk_revealer_real_add; props[PROP_TRANSITION_TYPE] = g_param_spec_enum ("transition-type", P_("Transition type"), P_("The type of animation used to transition"), GTK_TYPE_REVEALER_TRANSITION_TYPE, GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN, GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_EXPLICIT_NOTIFY); props[PROP_TRANSITION_DURATION] = g_param_spec_uint ("transition-duration", P_("Transition duration"), P_("The animation duration, in milliseconds"), 0, G_MAXUINT, 250, GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_EXPLICIT_NOTIFY); props[PROP_REVEAL_CHILD] = g_param_spec_boolean ("reveal-child", P_("Reveal Child"), P_("Whether the container should reveal the child"), FALSE, GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_EXPLICIT_NOTIFY); props[PROP_CHILD_REVEALED] = g_param_spec_boolean ("child-revealed", P_("Child Revealed"), P_("Whether the child is revealed and the animation target reached"), FALSE, G_PARAM_READABLE); g_object_class_install_properties (object_class, LAST_PROP, props); } /** * gtk_revealer_new: * * Creates a new #GtkRevealer. * * Returns: a newly created #GtkRevealer * * Since: 3.10 */ GtkWidget * gtk_revealer_new (void) { return g_object_new (GTK_TYPE_REVEALER, NULL); } static GtkRevealerTransitionType effective_transition (GtkRevealer *revealer) { GtkRevealerPrivate *priv = gtk_revealer_get_instance_private (revealer); gboolean animations_enabled; g_object_get (gtk_widget_get_settings (GTK_WIDGET (revealer)), "gtk-enable-animations", &animations_enabled, NULL); if (!animations_enabled) return GTK_REVEALER_TRANSITION_TYPE_NONE; if (gtk_widget_get_direction (GTK_WIDGET (revealer)) == GTK_TEXT_DIR_RTL) { if (priv->transition_type == GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT) return GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT; else if (priv->transition_type == GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT) return GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT; } return priv->transition_type; } static void gtk_revealer_get_child_allocation (GtkRevealer *revealer, GtkAllocation *allocation, GtkAllocation *child_allocation) { GtkWidget *child; GtkRevealerTransitionType transition; GtkBorder padding; gint vertical_padding, horizontal_padding; g_return_if_fail (revealer != NULL); g_return_if_fail (allocation != NULL); /* See explanation on gtk_revealer_real_size_allocate */ gtk_revealer_get_padding (revealer, &padding); vertical_padding = padding.top + padding.bottom; horizontal_padding = padding.left + padding.right; child_allocation->x = 0; child_allocation->y = 0; child_allocation->width = 0; child_allocation->height = 0; child = gtk_bin_get_child (GTK_BIN (revealer)); if (child != NULL && gtk_widget_get_visible (child)) { transition = effective_transition (revealer); if (transition == GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT || transition == GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT) gtk_widget_get_preferred_width_for_height (child, MAX (0, allocation->height - vertical_padding), NULL, &child_allocation->width); else gtk_widget_get_preferred_height_for_width (child, MAX (0, allocation->width - horizontal_padding), NULL, &child_allocation->height); } child_allocation->width = MAX (child_allocation->width, allocation->width - horizontal_padding); child_allocation->height = MAX (child_allocation->height, allocation->height - vertical_padding); } static void gtk_revealer_real_realize (GtkWidget *widget) { GtkRevealer *revealer = GTK_REVEALER (widget); GtkRevealerPrivate *priv = gtk_revealer_get_instance_private (revealer); GtkAllocation allocation; GdkWindowAttr attributes = { 0 }; GdkWindowAttributesType attributes_mask; GtkAllocation child_allocation; GtkWidget *child; GtkRevealerTransitionType transition; GtkBorder padding; gtk_widget_set_realized (widget, TRUE); gtk_widget_get_allocation (widget, &allocation); attributes.x = allocation.x; attributes.y = allocation.y; attributes.width = allocation.width; attributes.height = allocation.height; attributes.window_type = GDK_WINDOW_CHILD; attributes.wclass = GDK_INPUT_OUTPUT; attributes.visual = gtk_widget_get_visual (widget); attributes.event_mask = gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK; attributes_mask = (GDK_WA_X | GDK_WA_Y) | GDK_WA_VISUAL; priv->view_window = gdk_window_new (gtk_widget_get_parent_window ((GtkWidget*) revealer), &attributes, attributes_mask); gtk_widget_set_window (widget, priv->view_window); gtk_widget_register_window (widget, priv->view_window); gtk_revealer_get_child_allocation (revealer, &allocation, &child_allocation); gtk_revealer_get_padding (revealer, &padding); attributes.x = 0; attributes.y = 0; attributes.width = child_allocation.width; attributes.height = child_allocation.height; /* See explanation on gtk_revealer_real_size_allocate */ transition = effective_transition (revealer); if (transition == GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN) { attributes.y = allocation.height - child_allocation.height - padding.bottom; attributes.x = padding.left; } else if (transition == GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT) { attributes.y = padding.top; attributes.x = allocation.width - child_allocation.width - padding.right; } else { attributes.y = padding.top; attributes.x = padding.left; } priv->bin_window = gdk_window_new (priv->view_window, &attributes, attributes_mask); gtk_widget_register_window (widget, priv->bin_window); child = gtk_bin_get_child (GTK_BIN (revealer)); if (child != NULL) gtk_widget_set_parent_window (child, priv->bin_window); gdk_window_show (priv->bin_window); } static void gtk_revealer_real_unrealize (GtkWidget *widget) { GtkRevealer *revealer = GTK_REVEALER (widget); GtkRevealerPrivate *priv = gtk_revealer_get_instance_private (revealer); gtk_widget_unregister_window (widget, priv->bin_window); gdk_window_destroy (priv->bin_window); priv->view_window = NULL; GTK_WIDGET_CLASS (gtk_revealer_parent_class)->unrealize (widget); } static void gtk_revealer_real_add (GtkContainer *container, GtkWidget *child) { GtkRevealer *revealer = GTK_REVEALER (container); GtkRevealerPrivate *priv = gtk_revealer_get_instance_private (revealer); g_return_if_fail (child != NULL); gtk_widget_set_parent_window (child, priv->bin_window); gtk_widget_set_child_visible (child, priv->current_pos != 0.0); GTK_CONTAINER_CLASS (gtk_revealer_parent_class)->add (container, child); } static void gtk_revealer_real_size_allocate (GtkWidget *widget, GtkAllocation *allocation) { GtkRevealer *revealer = GTK_REVEALER (widget); GtkRevealerPrivate *priv = gtk_revealer_get_instance_private (revealer); GtkAllocation child_allocation; GtkWidget *child; gboolean window_visible; int bin_x, bin_y; GtkRevealerTransitionType transition; GtkBorder padding; g_return_if_fail (allocation != NULL); gtk_widget_set_allocation (widget, allocation); gtk_revealer_get_child_allocation (revealer, allocation, &child_allocation); child = gtk_bin_get_child (GTK_BIN (revealer)); if (child != NULL && gtk_widget_get_visible (child)) gtk_widget_size_allocate (child, &child_allocation); if (gtk_widget_get_realized (widget)) { if (gtk_widget_get_mapped (widget)) { window_visible = allocation->width > 0 && allocation->height > 0; if (!window_visible && gdk_window_is_visible (priv->view_window)) gdk_window_hide (priv->view_window); if (window_visible && !gdk_window_is_visible (priv->view_window)) gdk_window_show (priv->view_window); } /* The view window will follow the revealer allocation, which is modified * along the animation */ gdk_window_move_resize (priv->view_window, allocation->x, allocation->y, allocation->width, allocation->height); gtk_revealer_get_padding (revealer, &padding); bin_x = 0; bin_y = 0; transition = effective_transition (revealer); /* The child allocation is fixed (it is not modified by the animation), * and it's origin is relative to the bin_window. * The bin_window has the same allocation as the child, and then the bin_window * deals with the relative positioning with respect to the revealer taking * into account the paddings of the revealer. * * For most of transitions, the bin_window moves along with the revealer, * as its allocation changes. * However for GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN * we need to first move the bin_window upwards and then slide it down in * the revealer. * Otherwise the child would appear as static and the revealer will allocate * following the animation, clipping the child. * To calculate the correct y position for this case: * allocation->height - child_allocation.height is the relative position * towards the revealer taking into account the animation progress with * both vertical paddings added, therefore we need to substract the part * that we don't want to take into account for the y position, which * in this case is the bottom padding. * * The same special treatment is needed for GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT. */ if (transition == GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN) { bin_y = allocation->height - child_allocation.height - padding.bottom; bin_x = padding.left; } else if (transition == GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT) { bin_y = padding.top; bin_x = allocation->width - child_allocation.width - padding.right; } else { bin_x = padding.left; bin_y = padding.top; } gdk_window_move_resize (priv->bin_window, bin_x, bin_y, child_allocation.width, child_allocation.height); } } static void gtk_revealer_set_position (GtkRevealer *revealer, gdouble pos) { GtkRevealerPrivate *priv = gtk_revealer_get_instance_private (revealer); gboolean new_visible; GtkWidget *child; GtkRevealerTransitionType transition; priv->current_pos = pos; /* We check target_pos here too, because we want to ensure we set * child_visible immediately when starting a reveal operation * otherwise the child widgets will not be properly realized * after the reveal returns. */ new_visible = priv->current_pos != 0.0 || priv->target_pos != 0.0; child = gtk_bin_get_child (GTK_BIN (revealer)); if (child != NULL && new_visible != gtk_widget_get_child_visible (child)) gtk_widget_set_child_visible (child, new_visible); transition = effective_transition (revealer); if (transition == GTK_REVEALER_TRANSITION_TYPE_CROSSFADE) { gtk_widget_set_opacity (GTK_WIDGET (revealer), priv->current_pos); gtk_widget_queue_draw (GTK_WIDGET (revealer)); } else { gtk_widget_queue_resize (GTK_WIDGET (revealer)); } if (priv->current_pos == priv->target_pos) g_object_notify_by_pspec (G_OBJECT (revealer), props[PROP_CHILD_REVEALED]); } /* From clutter-easing.c, based on Robert Penner's * infamous easing equations, MIT license. */ static double ease_out_cubic (double t) { double p = t - 1; return p * p * p + 1; } static void gtk_revealer_animate_step (GtkRevealer *revealer, gint64 now) { GtkRevealerPrivate *priv = gtk_revealer_get_instance_private (revealer); gdouble t; if (now < priv->end_time) t = (now - priv->start_time) / (gdouble) (priv->end_time - priv->start_time); else t = 1.0; t = ease_out_cubic (t); gtk_revealer_set_position (revealer, priv->source_pos + (t * (priv->target_pos - priv->source_pos))); } static gboolean gtk_revealer_animate_cb (GtkWidget *widget, GdkFrameClock *frame_clock, gpointer user_data) { GtkRevealer *revealer = GTK_REVEALER (widget); GtkRevealerPrivate *priv = gtk_revealer_get_instance_private (revealer); gint64 now; now = gdk_frame_clock_get_frame_time (frame_clock); gtk_revealer_animate_step (revealer, now); if (priv->current_pos == priv->target_pos) { priv->tick_id = 0; return FALSE; } return TRUE; } static void gtk_revealer_start_animation (GtkRevealer *revealer, gdouble target) { GtkRevealerPrivate *priv = gtk_revealer_get_instance_private (revealer); GtkWidget *widget = GTK_WIDGET (revealer); GtkRevealerTransitionType transition; if (priv->target_pos == target) return; priv->target_pos = target; g_object_notify_by_pspec (G_OBJECT (revealer), props[PROP_REVEAL_CHILD]); transition = effective_transition (revealer); if (gtk_widget_get_mapped (widget) && priv->transition_duration != 0 && transition != GTK_REVEALER_TRANSITION_TYPE_NONE) { priv->source_pos = priv->current_pos; priv->start_time = gdk_frame_clock_get_frame_time (gtk_widget_get_frame_clock (widget)); priv->end_time = priv->start_time + (priv->transition_duration * 1000); if (priv->tick_id == 0) priv->tick_id = gtk_widget_add_tick_callback (widget, gtk_revealer_animate_cb, revealer, NULL); gtk_revealer_animate_step (revealer, priv->start_time); } else { gtk_revealer_set_position (revealer, target); } } static void gtk_revealer_stop_animation (GtkRevealer *revealer) { GtkRevealerPrivate *priv = gtk_revealer_get_instance_private (revealer); priv->current_pos = priv->target_pos; if (priv->tick_id != 0) { gtk_widget_remove_tick_callback (GTK_WIDGET (revealer), priv->tick_id); priv->tick_id = 0; } } static void gtk_revealer_real_map (GtkWidget *widget) { GtkRevealer *revealer = GTK_REVEALER (widget); GtkRevealerPrivate *priv = gtk_revealer_get_instance_private (revealer); GtkAllocation allocation; if (!gtk_widget_get_mapped (widget)) { gtk_widget_get_allocation (widget, &allocation); if (allocation.width > 0 && allocation.height > 0) gdk_window_show (priv->view_window); gtk_revealer_start_animation (revealer, priv->target_pos); } GTK_WIDGET_CLASS (gtk_revealer_parent_class)->map (widget); } static void gtk_revealer_real_unmap (GtkWidget *widget) { GtkRevealer *revealer = GTK_REVEALER (widget); GTK_WIDGET_CLASS (gtk_revealer_parent_class)->unmap (widget); gtk_revealer_stop_animation (revealer); } static gboolean gtk_revealer_real_draw (GtkWidget *widget, cairo_t *cr) { GtkRevealer *revealer = GTK_REVEALER (widget); GtkRevealerPrivate *priv = gtk_revealer_get_instance_private (revealer); if (gtk_cairo_should_draw_window (cr, priv->bin_window)) GTK_WIDGET_CLASS (gtk_revealer_parent_class)->draw (widget, cr); return TRUE; } /** * gtk_revealer_set_reveal_child: * @revealer: a #GtkRevealer * @reveal_child: %TRUE to reveal the child * * Tells the #GtkRevealer to reveal or conceal its child. * * The transition will be animated with the current * transition type of @revealer. * * Since: 3.10 */ void gtk_revealer_set_reveal_child (GtkRevealer *revealer, gboolean reveal_child) { g_return_if_fail (GTK_IS_REVEALER (revealer)); if (reveal_child) gtk_revealer_start_animation (revealer, 1.0); else gtk_revealer_start_animation (revealer, 0.0); } /** * gtk_revealer_get_reveal_child: * @revealer: a #GtkRevealer * * Returns whether the child is currently * revealed. See gtk_revealer_set_reveal_child(). * * This function returns %TRUE as soon as the transition * is to the revealed state is started. To learn whether * the child is fully revealed (ie the transition is completed), * use gtk_revealer_get_child_revealed(). * * Returns: %TRUE if the child is revealed. * * Since: 3.10 */ gboolean gtk_revealer_get_reveal_child (GtkRevealer *revealer) { GtkRevealerPrivate *priv = gtk_revealer_get_instance_private (revealer); g_return_val_if_fail (GTK_IS_REVEALER (revealer), FALSE); return priv->target_pos != 0.0; } /** * gtk_revealer_get_child_revealed: * @revealer: a #GtkRevealer * * Returns whether the child is fully revealed, ie wether * the transition to the revealed state is completed. * * Returns: %TRUE if the child is fully revealed * * Since: 3.10 */ gboolean gtk_revealer_get_child_revealed (GtkRevealer *revealer) { GtkRevealerPrivate *priv = gtk_revealer_get_instance_private (revealer); gboolean animation_finished = (priv->target_pos == priv->current_pos); gboolean reveal_child = gtk_revealer_get_reveal_child (revealer); if (animation_finished) return reveal_child; else return !reveal_child; } /* These all report only the natural size, ignoring the minimal size, * because its not really possible to allocate the right size during * animation if the child size can change (without the child * re-arranging itself during the animation). */ static void set_height_with_paddings (GtkRevealer *revealer, gint preferred_minimum_height, gint preferred_natural_height, gint *minimum_height_out, gint *natural_height_out) { GtkRevealerPrivate *priv = gtk_revealer_get_instance_private (revealer); gint minimum_height; gint natural_height; GtkRevealerTransitionType transition; GtkBorder padding; gint vertical_padding; gtk_revealer_get_padding (revealer, &padding); vertical_padding = padding.top + padding.bottom; minimum_height = preferred_minimum_height + vertical_padding; natural_height = preferred_natural_height + vertical_padding; transition = effective_transition (revealer); if (transition == GTK_REVEALER_TRANSITION_TYPE_NONE || transition == GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP || transition == GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN) { /* Padding are included in the animation */ minimum_height = round (minimum_height * priv->current_pos); natural_height = round (natural_height * priv->current_pos); } *minimum_height_out = MIN (minimum_height, natural_height); *natural_height_out = natural_height; } static void gtk_revealer_real_get_preferred_height (GtkWidget *widget, gint *minimum_height_out, gint *natural_height_out) { GtkRevealer *revealer = GTK_REVEALER (widget); gint minimum_height; gint natural_height; GTK_WIDGET_CLASS (gtk_revealer_parent_class)->get_preferred_height (widget, &minimum_height, &natural_height); set_height_with_paddings (revealer, minimum_height, natural_height, minimum_height_out, natural_height_out); } static void gtk_revealer_real_get_preferred_height_for_width (GtkWidget *widget, gint width, gint *minimum_height_out, gint *natural_height_out) { GtkRevealer *revealer = GTK_REVEALER (widget); gint minimum_height; gint natural_height; GTK_WIDGET_CLASS (gtk_revealer_parent_class)->get_preferred_height_for_width (widget, width, &minimum_height, &natural_height); set_height_with_paddings (revealer, minimum_height, natural_height, minimum_height_out, natural_height_out); } static void set_width_with_paddings (GtkRevealer *revealer, gint preferred_minimum_width, gint preferred_natural_width, gint *minimum_width_out, gint *natural_width_out) { GtkRevealerPrivate *priv = gtk_revealer_get_instance_private (revealer); gint minimum_width; gint natural_width; GtkRevealerTransitionType transition; GtkBorder padding; gint horizontal_padding; gtk_revealer_get_padding (revealer, &padding); horizontal_padding = padding.left + padding.right; minimum_width = preferred_minimum_width + horizontal_padding; natural_width = preferred_natural_width + horizontal_padding; transition = effective_transition (revealer); if (transition == GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT || transition == GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT) { /* Paddings are included in the animation */ minimum_width = round (minimum_width * priv->current_pos); natural_width = round (natural_width * priv->current_pos); } *minimum_width_out = MIN (minimum_width, natural_width); *natural_width_out = natural_width; } static void gtk_revealer_real_get_preferred_width (GtkWidget *widget, gint *minimum_width_out, gint *natural_width_out) { GtkRevealer *revealer = GTK_REVEALER (widget); gint minimum_width; gint natural_width; GTK_WIDGET_CLASS (gtk_revealer_parent_class)->get_preferred_width (widget, &minimum_width, &natural_width); set_width_with_paddings (revealer, minimum_width, natural_width, minimum_width_out, natural_width_out); } static void gtk_revealer_real_get_preferred_width_for_height (GtkWidget *widget, gint height, gint *minimum_width_out, gint *natural_width_out) { GtkRevealer *revealer = GTK_REVEALER (widget); gint minimum_width; gint natural_width; GTK_WIDGET_CLASS (gtk_revealer_parent_class)->get_preferred_width_for_height (widget, height, &minimum_width, &natural_width); set_width_with_paddings (revealer, minimum_width, natural_width, minimum_width_out, natural_width_out); } /** * gtk_revealer_get_transition_duration: * @revealer: a #GtkRevealer * * Returns the amount of time (in milliseconds) that * transitions will take. * * Returns: the transition duration * * Since: 3.10 */ guint gtk_revealer_get_transition_duration (GtkRevealer *revealer) { GtkRevealerPrivate *priv = gtk_revealer_get_instance_private (revealer); g_return_val_if_fail (GTK_IS_REVEALER (revealer), 0); return priv->transition_duration; } /** * gtk_revealer_set_transition_duration: * @revealer: a #GtkRevealer * @duration: the new duration, in milliseconds * * Sets the duration that transitions will take. * * Since: 3.10 */ void gtk_revealer_set_transition_duration (GtkRevealer *revealer, guint value) { GtkRevealerPrivate *priv = gtk_revealer_get_instance_private (revealer); g_return_if_fail (GTK_IS_REVEALER (revealer)); if (priv->transition_duration == value) return; priv->transition_duration = value; g_object_notify_by_pspec (G_OBJECT (revealer), props[PROP_TRANSITION_DURATION]); } /** * gtk_revealer_get_transition_type: * @revealer: a #GtkRevealer * * Gets the type of animation that will be used * for transitions in @revealer. * * Returns: the current transition type of @revealer * * Since: 3.10 */ GtkRevealerTransitionType gtk_revealer_get_transition_type (GtkRevealer *revealer) { GtkRevealerPrivate *priv = gtk_revealer_get_instance_private (revealer); g_return_val_if_fail (GTK_IS_REVEALER (revealer), GTK_REVEALER_TRANSITION_TYPE_NONE); return priv->transition_type; } /** * gtk_revealer_set_transition_type: * @revealer: a #GtkRevealer * @transition: the new transition type * * Sets the type of animation that will be used for * transitions in @revealer. Available types include * various kinds of fades and slides. * * Since: 3.10 */ void gtk_revealer_set_transition_type (GtkRevealer *revealer, GtkRevealerTransitionType transition) { GtkRevealerPrivate *priv = gtk_revealer_get_instance_private (revealer); g_return_if_fail (GTK_IS_REVEALER (revealer)); if (priv->transition_type == transition) return; priv->transition_type = transition; gtk_widget_queue_resize (GTK_WIDGET (revealer)); g_object_notify_by_pspec (G_OBJECT (revealer), props[PROP_TRANSITION_TYPE]); }