AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity
824c730362
gtk2/gtk/gtkstack.c

2574 lines
83 KiB
C
Raw Normal View History

Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
/*
* Copyright (c) 2013 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 <alexl@redhat.com>
*
*/
#include "config.h"
#include <gtk/gtk.h>
#include "gtkstack.h"
#include "gtkprivate.h"
#include "gtkintl.h"
stack: port to progress tracker
2016-03-01 06:24:39 +00:00
#include "gtkprogresstrackerprivate.h"
stack: Use getter for gtk-enable-animations
2016-05-01 04:39:55 +00:00
#include "gtksettingsprivate.h"
Use GtkSnapshot getters We can avoid direct struct access and gtksnapshotprivate.h everywhere.
2018-03-11 05:29:46 +00:00
#include "gtksnapshot.h"
stack: Convert to gadgets
2015-12-09 04:03:38 +00:00
#include "gtkwidgetprivate.h"
stack: Provide a selection model Make GtkStack expose a selection model for its pages. The model can be used to track changes to the pages, and to change what child is visible.
2019-02-10 23:22:54 +00:00
#include "gtksingleselection.h"
#include "gtklistlistmodelprivate.h"
Add GtkStackAccessible Show only the currently visible child to a11y.
2016-05-29 11:51:02 +00:00
#include "a11y/gtkstackaccessible.h"
#include "a11y/gtkstackaccessibleprivate.h"
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
#include <math.h>
#include <string.h>
Add docs for GtkStack
2013-04-21 14:14:46 +00:00
/**
* SECTION:gtkstack
* @Short_description: A stacking container
* @Title: GtkStack
* @See_also: #GtkNotebook, #GtkStackSwitcher
*
* The GtkStack widget is a container which only shows
* one of its children at a time. In contrast to GtkNotebook,
GtkStack: improve docs
2013-04-25 02:07:09 +00:00
* GtkStack does not provide a means for users to change the
* visible child. Instead, the #GtkStackSwitcher widget can be
* used with GtkStack to provide this functionality.
Add docs for GtkStack
2013-04-21 14:14:46 +00:00
*
* Transitions between pages can be animated as slides or
* fades. This can be controlled with gtk_stack_set_transition_type().
docs: don't use signal syntax for properties
2014-01-22 01:58:13 +00:00
* These animations respect the #GtkSettings:gtk-enable-animations
Add docs for GtkStack
2013-04-21 14:14:46 +00:00
* setting.
*
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
* GtkStack maintains a #GtkStackPage object for each added
* child, which holds additional per-child properties. You
* obtain the #GtkStackPage for a child with gtk_stack_get_page().
stack: Set an element name And it is...stack.
2015-11-04 04:19:28 +00:00
*
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
* # GtkStack as GtkBuildable
*
* To set child-specific properties in a .ui file, create GtkStackPage
* objects explictly, and set the child widget as a property on it:
* |[
* <object class="GtkStack" id="stack">
* <child>
* <object class="GtkStackPage">
* <property name="name">page1</property>
* <property name="title">In the beginning…</property>
* <property name="child">
* <object class="GtkLabel">
* <property name="label">It was dark</property>
* </object>
* </property>
* </object>
* </child>
* ]|
*
stack: Set an element name And it is...stack.
2015-11-04 04:19:28 +00:00
* # CSS nodes
*
* GtkStack has a single CSS node named stack.
Add docs for GtkStack
2013-04-21 14:14:46 +00:00
*/
/**
* GtkStackTransitionType:
* @GTK_STACK_TRANSITION_TYPE_NONE: No transition
* @GTK_STACK_TRANSITION_TYPE_CROSSFADE: A cross-fade
GtkStack: add vertical slide transitions We allow transitions that slide up or down.
2013-04-22 00:17:40 +00:00
* @GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT: Slide from left to right
* @GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT: Slide from right to left
* @GTK_STACK_TRANSITION_TYPE_SLIDE_UP: Slide from bottom up
* @GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN: Slide from top down
GtkStack: Add position-dependent slide transitions These go left/right or up/down depending on the relative order of the children being switched between.
2013-06-13 18:33:42 +00:00
* @GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT: Slide from left or right according to the children order
* @GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN: Slide from top down or bottom up according to the order
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
* @GTK_STACK_TRANSITION_TYPE_OVER_UP: Cover the old page by sliding up
* @GTK_STACK_TRANSITION_TYPE_OVER_DOWN: Cover the old page by sliding down
* @GTK_STACK_TRANSITION_TYPE_OVER_LEFT: Cover the old page by sliding to the left
* @GTK_STACK_TRANSITION_TYPE_OVER_RIGHT: Cover the old page by sliding to the right
* @GTK_STACK_TRANSITION_TYPE_UNDER_UP: Uncover the new page by sliding up
* @GTK_STACK_TRANSITION_TYPE_UNDER_DOWN: Uncover the new page by sliding down
* @GTK_STACK_TRANSITION_TYPE_UNDER_LEFT: Uncover the new page by sliding to the left
* @GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT: Uncover the new page by sliding to the right
* @GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN: Cover the old page sliding up or uncover the new page sliding down, according to order
* @GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP: Cover the old page sliding down or uncover the new page sliding up, according to order
* @GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT: Cover the old page sliding left or uncover the new page sliding right, according to order
* @GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT: Cover the old page sliding right or uncover the new page sliding left, according to order
stack: Add a cube spin transition Add a transition to GtkStack that pretends pages are the sides or a cube, and switch them by rotating the cube. Use this transition in widget-factory.
2019-03-05 19:44:45 +00:00
* @GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT: Pretend the pages are sides of a cube and rotate that cube to the left
* @GTK_STACK_TRANSITION_TYPE_ROTATE_RIGHT: Pretend the pages are sides of a cube and rotate that cube to the right
* @GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT_RIGHT: Pretend the pages are sides of a cube and rotate that cube to the left or right according to the children order
Add docs for GtkStack
2013-04-21 14:14:46 +00:00
*
* These enumeration values describe the possible transitions
* between pages in a #GtkStack widget.
GtkStack: Add more transition types This adds new 'over' and 'under' transitions which work by moving the new page over the previous one, or moving the previous page off to reveal the new one. We also add an over/under combination that is going to be used in GtkAboutDialog. https://bugzilla.gnome.org/show_bug.cgi?id=707187
2013-08-31 16:00:47 +00:00
*
* New values may be added to this enumeration over time.
Add docs for GtkStack
2013-04-21 14:14:46 +00:00
*/
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
/* TODO:
* filter events out events to the last_child widget during transitions
*/
stack: Make final
2019-05-28 22:35:07 +00:00
struct _GtkStack {
GtkContainer parent_instance;
};
typedef struct _GtkStackClass GtkStackClass;
struct _GtkStackClass {
GtkContainerClass parent_class;
};
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
typedef struct {
GList *children;
GtkStackPage *visible_child;
gboolean hhomogeneous;
gboolean vhomogeneous;
GtkStackTransitionType transition_type;
guint transition_duration;
GtkStackPage *last_visible_child;
GskRenderNode *last_visible_node;
GtkAllocation last_visible_surface_allocation;
guint tick_id;
GtkProgressTracker tracker;
gboolean first_frame_skipped;
gint last_visible_widget_width;
gint last_visible_widget_height;
gboolean interpolate_size;
GtkStackTransitionType active_transition_type;
stack: Provide a selection model Make GtkStack expose a selection model for its pages. The model can be used to track changes to the pages, and to change what child is visible.
2019-02-10 23:22:54 +00:00
GtkSelectionModel *pages;
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
} GtkStackPrivate;
static void gtk_stack_buildable_interface_init (GtkBuildableIface *iface);
G_DEFINE_TYPE_WITH_CODE (GtkStack, gtk_stack, GTK_TYPE_CONTAINER,
G_ADD_PRIVATE (GtkStack)
G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
gtk_stack_buildable_interface_init))
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
enum {
PROP_0,
GtkStack: split homogeneous Split homogeneous into separate hhomogeneous and vhomogeneous properties. vhomogeneous is what we want for popover menus.
2014-10-26 18:59:21 +00:00
PROP_HHOMOGENEOUS,
PROP_VHOMOGENEOUS,
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
PROP_VISIBLE_CHILD,
PROP_VISIBLE_CHILD_NAME,
PROP_TRANSITION_DURATION,
stack: Use g_object_class_install_properties() https://bugzilla.gnome.org/show_bug.cgi?id=711611
2013-11-05 10:11:35 +00:00
PROP_TRANSITION_TYPE,
GtkStack: add transition-running property This is useful to know when the transition is done we can remove the child from the stack. https://bugzilla.gnome.org/show_bug.cgi?id=711494
2013-11-11 21:38:35 +00:00
PROP_TRANSITION_RUNNING,
GtkStack: Add interpolate-size property And use it to determine whether we should actually interpolate between stack sizes or not.
2015-07-19 15:39:41 +00:00
PROP_INTERPOLATE_SIZE,
stack: Add a pages property This makes the list model available in the inspector.
2019-02-13 19:14:54 +00:00
PROP_PAGES,
stack: Use g_object_class_install_properties() https://bugzilla.gnome.org/show_bug.cgi?id=711611
2013-11-05 10:11:35 +00:00
LAST_PROP
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
};
enum
{
CHILD_PROP_0,
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
CHILD_PROP_CHILD,
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
CHILD_PROP_NAME,
CHILD_PROP_TITLE,
CHILD_PROP_ICON_NAME,
stack: Convert to gtk_container_child_notify_by_pspec
2015-09-07 22:53:25 +00:00
CHILD_PROP_NEEDS_ATTENTION,
stack: Add a GtkStackPage::visible property This will let GtkStackSwitcher track visibility without having to interact with the widgets directly.
2019-02-10 23:13:03 +00:00
CHILD_PROP_VISIBLE,
stack: Add a :use-underline property Add GtkStackPage:use-underline, and use it when constructing labels in the stack switcher.
2020-04-30 23:17:34 +00:00
CHILD_PROP_USE_UNDERLINE,
stack: Convert to gtk_container_child_notify_by_pspec
2015-09-07 22:53:25 +00:00
LAST_CHILD_PROP
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
};
stack: Add GtkStackPage:visible accessors
2020-02-18 08:27:42 +00:00
struct _GtkStackPage
{
GObject parent_instance;
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
GtkWidget *widget;
stack: Add GtkStackPage:visible accessors
2020-02-18 08:27:42 +00:00
char *name;
char *title;
char *icon_name;
GtkStack: Improve focus handling Add notebook-like focus handling: Keep track of the last focused descendent of each page, and focus it again when switching back to the page. If there is no last focused child, we move the focus into the page as if the user had hit Tab.
2014-12-11 03:32:45 +00:00
GtkWidget *last_focus;
stack: Add a :use-underline property Add GtkStackPage:use-underline, and use it when constructing labels in the stack switcher.
2020-04-30 23:17:34 +00:00
guint needs_attention : 1;
guint visible : 1;
guint use_underline : 1;
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
};
stack: Make final
2019-05-28 22:35:07 +00:00
typedef struct _GtkStackPageClass GtkStackPageClass;
stack: Add GtkStackPage:visible accessors
2020-02-18 08:27:42 +00:00
struct _GtkStackPageClass
{
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
GObjectClass parent_class;
};
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
static GParamSpec *stack_props[LAST_PROP] = { NULL, };
static GParamSpec *stack_child_props[LAST_CHILD_PROP] = { NULL, };
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
G_DEFINE_TYPE (GtkStackPage, gtk_stack_page, G_TYPE_OBJECT)
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
static void
gtk_stack_page_init (GtkStackPage *page)
{
stack: Add a GtkStackPage::visible property This will let GtkStackSwitcher track visibility without having to interact with the widgets directly.
2019-02-10 23:13:03 +00:00
page->visible = TRUE;
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
}
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
static void
gtk_stack_page_finalize (GObject *object)
{
GtkStackPage *page = GTK_STACK_PAGE (object);
Add a way to specify transition types on the fly Add a gtk_stack_set_visible_child_full that takes a transition type.
2013-04-21 18:22:35 +00:00
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
g_clear_object (&page->widget);
g_free (page->name);
g_free (page->title);
g_free (page->icon_name);
GtkStack: Save last visible widget size When interpolating the stack size, we compute the current size by using the prefered/minimum current size and the last size. We can't use the last_visible_surface_allocation because that is not available until the first _draw call and it doesn't include the child's margins.
2015-05-24 14:55:34 +00:00
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
if (page->last_focus)
g_object_remove_weak_pointer (G_OBJECT (page->last_focus),
(gpointer *)&page->last_focus);
GtkStack: Add interpolate-size property And use it to determine whether we should actually interpolate between stack sizes or not.
2015-07-19 15:39:41 +00:00
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
G_OBJECT_CLASS (gtk_stack_page_parent_class)->finalize (object);
}
Avoid spurious operations on destroy When the stack is destroyed we do not want to waste time running animations and notifying listeners about which is our current visible child. This is not only an optimization, but it is important for the stack switcher widgets: since they are in another branch of the hieratchy we do not want to get notifications while the stack is being destroyed. Based on a patch by Paolo Borelli https://bugzilla.gnome.org/show_bug.cgi?id=724506
2014-02-16 21:22:59 +00:00
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
static void
gtk_stack_page_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
GtkStackPage *info = GTK_STACK_PAGE (object);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
switch (property_id)
{
case CHILD_PROP_CHILD:
g_value_set_object (value, info->widget);
break;
case CHILD_PROP_NAME:
g_value_set_string (value, info->name);
break;
case CHILD_PROP_TITLE:
g_value_set_string (value, info->title);
break;
case CHILD_PROP_ICON_NAME:
g_value_set_string (value, info->icon_name);
break;
case CHILD_PROP_NEEDS_ATTENTION:
g_value_set_boolean (value, info->needs_attention);
break;
stack: Add a GtkStackPage::visible property This will let GtkStackSwitcher track visibility without having to interact with the widgets directly.
2019-02-10 23:13:03 +00:00
case CHILD_PROP_VISIBLE:
stack: Add GtkStackPage:visible accessors
2020-02-18 08:27:42 +00:00
g_value_set_boolean (value, gtk_stack_page_get_visible (info));
stack: Add a GtkStackPage::visible property This will let GtkStackSwitcher track visibility without having to interact with the widgets directly.
2019-02-10 23:13:03 +00:00
break;
stack: Add a :use-underline property Add GtkStackPage:use-underline, and use it when constructing labels in the stack switcher.
2020-04-30 23:17:34 +00:00
case CHILD_PROP_USE_UNDERLINE:
g_value_set_boolean (value, info->use_underline);
break;
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
gtk_stack_page_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
GtkStackPage *info = GTK_STACK_PAGE (object);
GtkWidget *stack = NULL;
GtkStackPrivate *priv = NULL;
gchar *name;
GList *l;
if (info->widget)
{
stack = gtk_widget_get_parent (info->widget);
if (stack)
priv = gtk_stack_get_instance_private (GTK_STACK (stack));
}
switch (property_id)
{
case CHILD_PROP_CHILD:
g_set_object (&info->widget, g_value_get_object (value));
break;
case CHILD_PROP_NAME:
name = g_value_dup_string (value);
for (l = priv ? priv->children : NULL; l != NULL; l = l->next)
{
GtkStackPage *info2 = l->data;
if (info == info2)
continue;
if (g_strcmp0 (info2->name, name) == 0)
{
g_warning ("Duplicate child name in GtkStack: %s", name);
break;
}
}
g_free (info->name);
info->name = name;
g_object_notify_by_pspec (object, pspec);
if (priv && priv->visible_child == info)
g_object_notify_by_pspec (G_OBJECT (stack),
stack_props[PROP_VISIBLE_CHILD_NAME]);
break;
case CHILD_PROP_TITLE:
g_free (info->title);
info->title = g_value_dup_string (value);
g_object_notify_by_pspec (object, pspec);
break;
case CHILD_PROP_ICON_NAME:
g_free (info->icon_name);
info->icon_name = g_value_dup_string (value);
g_object_notify_by_pspec (object, pspec);
break;
case CHILD_PROP_NEEDS_ATTENTION:
stack: Fix up property notification This was showing up in testsuite failures.
2019-02-08 14:03:45 +00:00
if (info->needs_attention != g_value_get_boolean (value))
{
info->needs_attention = g_value_get_boolean (value);
g_object_notify_by_pspec (object, pspec);
}
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
break;
stack: Add a GtkStackPage::visible property This will let GtkStackSwitcher track visibility without having to interact with the widgets directly.
2019-02-10 23:13:03 +00:00
case CHILD_PROP_VISIBLE:
stack: Add GtkStackPage:visible accessors
2020-02-18 08:27:42 +00:00
gtk_stack_page_set_visible (info, g_value_get_boolean (value));
stack: Add a GtkStackPage::visible property This will let GtkStackSwitcher track visibility without having to interact with the widgets directly.
2019-02-10 23:13:03 +00:00
break;
stack: Add a :use-underline property Add GtkStackPage:use-underline, and use it when constructing labels in the stack switcher.
2020-04-30 23:17:34 +00:00
case CHILD_PROP_USE_UNDERLINE:
if (info->use_underline != g_value_get_boolean (value))
{
info->use_underline = g_value_get_boolean (value);
g_object_notify_by_pspec (object, pspec);
}
break;
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
gtk_stack_page_class_init (GtkStackPageClass *class)
{
GObjectClass *object_class = G_OBJECT_CLASS (class);
object_class->finalize = gtk_stack_page_finalize;
object_class->get_property = gtk_stack_page_get_property;
object_class->set_property = gtk_stack_page_set_property;
stack_child_props[CHILD_PROP_CHILD] =
g_param_spec_object ("child",
P_("Child"),
P_("The child of the page"),
GTK_TYPE_WIDGET,
GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
stack_child_props[CHILD_PROP_NAME] =
g_param_spec_string ("name",
P_("Name"),
P_("The name of the child page"),
NULL,
GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
stack_child_props[CHILD_PROP_TITLE] =
g_param_spec_string ("title",
P_("Title"),
P_("The title of the child page"),
NULL,
GTK_PARAM_READWRITE);
stack_child_props[CHILD_PROP_ICON_NAME] =
g_param_spec_string ("icon-name",
P_("Icon name"),
P_("The icon name of the child page"),
NULL,
GTK_PARAM_READWRITE);
/**
* GtkStack:needs-attention:
*
* Sets a flag specifying whether the child requires the user attention.
* This is used by the #GtkStackSwitcher to change the appearance of the
* corresponding button when a page needs attention and it is not the
* current one.
*/
stack_child_props[CHILD_PROP_NEEDS_ATTENTION] =
g_param_spec_boolean ("needs-attention",
P_("Needs Attention"),
P_("Whether this page needs attention"),
FALSE,
stack: Fix up property notification This was showing up in testsuite failures.
2019-02-08 14:03:45 +00:00
GTK_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY);
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
stack: Add a GtkStackPage::visible property This will let GtkStackSwitcher track visibility without having to interact with the widgets directly.
2019-02-10 23:13:03 +00:00
stack_child_props[CHILD_PROP_VISIBLE] =
g_param_spec_boolean ("visible",
P_("Visible"),
P_("Whether this page is visible"),
TRUE,
GTK_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY);
stack: Add a :use-underline property Add GtkStackPage:use-underline, and use it when constructing labels in the stack switcher.
2020-04-30 23:17:34 +00:00
stack_child_props[CHILD_PROP_USE_UNDERLINE] =
g_param_spec_boolean ("use-underline",
P_("Use underline"),
P_("If set, an underline in the title indicates the next character should be used for the mnemonic accelerator key"),
FALSE,
GTK_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY);
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
g_object_class_install_properties (object_class, LAST_CHILD_PROP, stack_child_props);
}
stack: Use g_object_class_install_properties() https://bugzilla.gnome.org/show_bug.cgi?id=711611
2013-11-05 10:11:35 +00:00
stack: Provide a selection model Make GtkStack expose a selection model for its pages. The model can be used to track changes to the pages, and to change what child is visible.
2019-02-10 23:22:54 +00:00
#define GTK_TYPE_STACK_PAGES (gtk_stack_pages_get_type ())
G_DECLARE_FINAL_TYPE (GtkStackPages, gtk_stack_pages, GTK, STACK_PAGES, GObject)
struct _GtkStackPages
{
GObject parent_instance;
GtkStack *stack;
};
struct _GtkStackPagesClass
{
GObjectClass parent_class;
};
static GType
gtk_stack_pages_get_item_type (GListModel *model)
{
return GTK_TYPE_STACK_PAGE;
}
static guint
gtk_stack_pages_get_n_items (GListModel *model)
{
GtkStackPages *pages = GTK_STACK_PAGES (model);
GtkStackPrivate *priv = gtk_stack_get_instance_private (pages->stack);
return g_list_length (priv->children);
}
static gpointer
gtk_stack_pages_get_item (GListModel *model,
guint position)
{
GtkStackPages *pages = GTK_STACK_PAGES (model);
GtkStackPrivate *priv = gtk_stack_get_instance_private (pages->stack);
GtkStackPage *page;
page = g_list_nth_data (priv->children, position);
return g_object_ref (page);
}
static void
gtk_stack_pages_list_model_init (GListModelInterface *iface)
{
iface->get_item_type = gtk_stack_pages_get_item_type;
iface->get_n_items = gtk_stack_pages_get_n_items;
iface->get_item = gtk_stack_pages_get_item;
}
static gboolean
gtk_stack_pages_is_selected (GtkSelectionModel *model,
guint position)
{
GtkStackPages *pages = GTK_STACK_PAGES (model);
GtkStackPrivate *priv = gtk_stack_get_instance_private (pages->stack);
GtkStackPage *page;
stack: Avoid some ugly unrefs Instead of using the list model api that forces us to drop the ref, just work with the list we have.
2019-02-13 13:40:13 +00:00
page = g_list_nth_data (priv->children, position);
stack: Provide a selection model Make GtkStack expose a selection model for its pages. The model can be used to track changes to the pages, and to change what child is visible.
2019-02-10 23:22:54 +00:00
return page == priv->visible_child;
}
static void set_visible_child (GtkStack *stack,
GtkStackPage *child_info,
GtkStackTransitionType transition_type,
guint transition_duration);
static gboolean
gtk_stack_pages_select_item (GtkSelectionModel *model,
guint position,
gboolean exclusive)
{
GtkStackPages *pages = GTK_STACK_PAGES (model);
GtkStackPrivate *priv = gtk_stack_get_instance_private (pages->stack);
GtkStackPage *page;
stack: Avoid some ugly unrefs Instead of using the list model api that forces us to drop the ref, just work with the list we have.
2019-02-13 13:40:13 +00:00
page = g_list_nth_data (priv->children, position);
stack: Provide a selection model Make GtkStack expose a selection model for its pages. The model can be used to track changes to the pages, and to change what child is visible.
2019-02-10 23:22:54 +00:00
set_visible_child (pages->stack, page, priv->transition_type, priv->transition_duration);
return TRUE;
}
static void
gtk_stack_pages_selection_model_init (GtkSelectionModelInterface *iface)
{
iface->is_selected = gtk_stack_pages_is_selected;
iface->select_item = gtk_stack_pages_select_item;
}
G_DEFINE_TYPE_WITH_CODE (GtkStackPages, gtk_stack_pages, G_TYPE_OBJECT,
G_IMPLEMENT_INTERFACE (G_TYPE_LIST_MODEL, gtk_stack_pages_list_model_init)
G_IMPLEMENT_INTERFACE (GTK_TYPE_SELECTION_MODEL, gtk_stack_pages_selection_model_init))
static void
gtk_stack_pages_init (GtkStackPages *pages)
{
}
static void
gtk_stack_pages_class_init (GtkStackPagesClass *class)
{
}
static GtkStackPages *
gtk_stack_pages_new (GtkStack *stack)
{
GtkStackPages *pages;
pages = g_object_new (GTK_TYPE_STACK_PAGES, NULL);
pages->stack = stack;
return pages;
}
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
static void gtk_stack_add (GtkContainer *widget,
GtkWidget *child);
static void gtk_stack_remove (GtkContainer *widget,
GtkWidget *child);
static void gtk_stack_forall (GtkContainer *container,
GtkCallback callback,
gpointer callback_data);
static void gtk_stack_compute_expand (GtkWidget *widget,
gboolean *hexpand,
gboolean *vexpand);
widget: Don't pass a position to ->size_allocate The values have been 0/0 for a long time now, so just drop the GtkAllocation argument and replace it with width and height.
2018-08-16 04:53:03 +00:00
static void gtk_stack_size_allocate (GtkWidget *widget,
int width,
int height,
int baseline);
stack: Implement snapshot() This uses the new push()/pop() mechanism to its fullest extent when implementing transitions. It's fun to inspect the results in the inspector. Crossfades don't work yet, they continue using a Cairo fallback. A side effect of the stack conversion is that widget-factory now uses snapshots for a lot more things.
2016-12-13 08:45:09 +00:00
static void gtk_stack_snapshot (GtkWidget *widget,
GtkSnapshot *snapshot);
stack: Remove gadget
2017-05-05 15:18:15 +00:00
static void gtk_stack_measure (GtkWidget *widget,
widget: Use ::measure vfunc to measure size Add a new ::measure vfunc similar to GtkCssGadget's that widget implementations have to override instead of the old get_preferred_width, get_preferred_height, get_preferred_width_for_height, get_preferred_height_for_width and get_preferred_height_and_baseline_for_width.
2016-10-22 14:06:14 +00:00
GtkOrientation orientation,
int for_size,
int *minimum,
int *natural,
int *minimum_baseline,
int *natural_baseline);
stack: Provide a selection model Make GtkStack expose a selection model for its pages. The model can be used to track changes to the pages, and to change what child is visible.
2019-02-10 23:22:54 +00:00
static void gtk_stack_dispose (GObject *obj);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
static void gtk_stack_finalize (GObject *obj);
static void gtk_stack_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec);
static void gtk_stack_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static void gtk_stack_unschedule_ticks (GtkStack *stack);
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
static void gtk_stack_add_page (GtkStack *stack,
GtkStackPage *page);
static void
gtk_stack_buildable_add_child (GtkBuildable *buildable,
GtkBuilder *builder,
GObject *child,
const char *type)
{
if (GTK_IS_STACK_PAGE (child))
gtk_stack_add_page (GTK_STACK (buildable), GTK_STACK_PAGE (child));
else if (GTK_IS_WIDGET (child))
gtk_container_add (GTK_CONTAINER (buildable), GTK_WIDGET (child));
else
g_warning ("Can't add a child of type '%s' to '%s'", G_OBJECT_TYPE_NAME (child), G_OBJECT_TYPE_NAME (buildable));
}
static void
gtk_stack_buildable_interface_init (GtkBuildableIface *iface)
{
iface->add_child = gtk_stack_buildable_add_child;
}
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
stack: Provide a selection model Make GtkStack expose a selection model for its pages. The model can be used to track changes to the pages, and to change what child is visible.
2019-02-10 23:22:54 +00:00
static void stack_remove (GtkStack *stack,
GtkWidget *child,
gboolean in_dispose);
static void
remove_child (GtkWidget *child, gpointer user_data)
{
stack_remove (GTK_STACK (user_data), child, TRUE);
}
static void
gtk_stack_dispose (GObject *obj)
{
GtkStack *stack = GTK_STACK (obj);
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
if (priv->pages)
g_list_model_items_changed (G_LIST_MODEL (priv->pages), 0, g_list_length (priv->children), 0);
stack: Fix a crash We need to remove the weak pointer, as the stack switcher can keep the list model alive beyond the stack. This was observed to cause crashes: ==16870== Invalid write of size 8 ==16870== at 0x5168A4E: g_nullify_pointer (gutils.c:2284) ==16870== by 0x522C500: weak_refs_notify (gobject.c:2791) ==16870== by 0x50FE7BC: g_data_set_internal (gdataset.c:407) ==16870== by 0x50FECA7: g_datalist_id_set_data_full (gdataset.c:670) ==16870== by 0x5227EB4: g_object_real_dispose (gobject.c:1056) ==16870== by 0x522D295: g_object_unref (gobject.c:3309) ==16870== by 0x4AF849F: unset_stack (gtkstackswitcher.c:428) ==16870== by 0x4AF892E: gtk_stack_switcher_dispose (gtkstackswitcher.c:527)
2019-02-14 17:24:22 +00:00
stack: Provide a selection model Make GtkStack expose a selection model for its pages. The model can be used to track changes to the pages, and to change what child is visible.
2019-02-10 23:22:54 +00:00
gtk_container_foreach (GTK_CONTAINER (obj), remove_child, obj);
G_OBJECT_CLASS (gtk_stack_parent_class)->dispose (obj);
}
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
static void
gtk_stack_finalize (GObject *obj)
{
GtkStack *stack = GTK_STACK (obj);
stack: Use new private model, remove priv pointer
2013-07-02 11:43:20 +00:00
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
stack: Fix a crash We need to remove the weak pointer, as the stack switcher can keep the list model alive beyond the stack. This was observed to cause crashes: ==16870== Invalid write of size 8 ==16870== at 0x5168A4E: g_nullify_pointer (gutils.c:2284) ==16870== by 0x522C500: weak_refs_notify (gobject.c:2791) ==16870== by 0x50FE7BC: g_data_set_internal (gdataset.c:407) ==16870== by 0x50FECA7: g_datalist_id_set_data_full (gdataset.c:670) ==16870== by 0x5227EB4: g_object_real_dispose (gobject.c:1056) ==16870== by 0x522D295: g_object_unref (gobject.c:3309) ==16870== by 0x4AF849F: unset_stack (gtkstackswitcher.c:428) ==16870== by 0x4AF892E: gtk_stack_switcher_dispose (gtkstackswitcher.c:527)
2019-02-14 17:24:22 +00:00
if (priv->pages)
g_object_remove_weak_pointer (G_OBJECT (priv->pages), (gpointer *)&priv->pages);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
gtk_stack_unschedule_ticks (stack);
stack: Implement snapshot() This uses the new push()/pop() mechanism to its fullest extent when implementing transitions. It's fun to inspect the results in the inspector. Crossfades don't work yet, they continue using a Cairo fallback. A side effect of the stack conversion is that widget-factory now uses snapshots for a lot more things.
2016-12-13 08:45:09 +00:00
g_clear_pointer (&priv->last_visible_node, gsk_render_node_unref);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
G_OBJECT_CLASS (gtk_stack_parent_class)->finalize (obj);
}
static void
gtk_stack_get_property (GObject *object,
GtkStack: split homogeneous Split homogeneous into separate hhomogeneous and vhomogeneous properties. vhomogeneous is what we want for popover menus.
2014-10-26 18:59:21 +00:00
guint property_id,
GValue *value,
GParamSpec *pspec)
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
{
GtkStack *stack = GTK_STACK (object);
switch (property_id)
{
GtkStack: split homogeneous Split homogeneous into separate hhomogeneous and vhomogeneous properties. vhomogeneous is what we want for popover menus.
2014-10-26 18:59:21 +00:00
case PROP_HHOMOGENEOUS:
g_value_set_boolean (value, gtk_stack_get_hhomogeneous (stack));
break;
case PROP_VHOMOGENEOUS:
g_value_set_boolean (value, gtk_stack_get_vhomogeneous (stack));
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
break;
case PROP_VISIBLE_CHILD:
stack: Fix crash on g_object_get("visible-child") priv->visible_child is not a GtkWidget but a custom struct holding the widget. So use the getter instead.
2013-11-25 01:39:13 +00:00
g_value_set_object (value, gtk_stack_get_visible_child (stack));
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
break;
case PROP_VISIBLE_CHILD_NAME:
g_value_set_string (value, gtk_stack_get_visible_child_name (stack));
break;
case PROP_TRANSITION_DURATION:
Make transition-duration unsigned The code doesn't deal with negative durations, so better don't allow them.
2013-04-22 01:31:29 +00:00
g_value_set_uint (value, gtk_stack_get_transition_duration (stack));
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
break;
case PROP_TRANSITION_TYPE:
Change transition-type property type This is an enum, so declare the property as such.
2013-04-22 01:16:46 +00:00
g_value_set_enum (value, gtk_stack_get_transition_type (stack));
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
break;
GtkStack: add transition-running property This is useful to know when the transition is done we can remove the child from the stack. https://bugzilla.gnome.org/show_bug.cgi?id=711494
2013-11-11 21:38:35 +00:00
case PROP_TRANSITION_RUNNING:
g_value_set_boolean (value, gtk_stack_get_transition_running (stack));
break;
GtkStack: Add interpolate-size property And use it to determine whether we should actually interpolate between stack sizes or not.
2015-07-19 15:39:41 +00:00
case PROP_INTERPOLATE_SIZE:
g_value_set_boolean (value, gtk_stack_get_interpolate_size (stack));
break;
stack: Add a pages property This makes the list model available in the inspector.
2019-02-13 19:14:54 +00:00
case PROP_PAGES:
g_value_set_object (value, gtk_stack_get_pages (stack));
break;
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
gtk_stack_set_property (GObject *object,
GtkStack: split homogeneous Split homogeneous into separate hhomogeneous and vhomogeneous properties. vhomogeneous is what we want for popover menus.
2014-10-26 18:59:21 +00:00
guint property_id,
const GValue *value,
GParamSpec *pspec)
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
{
GtkStack *stack = GTK_STACK (object);
switch (property_id)
{
GtkStack: split homogeneous Split homogeneous into separate hhomogeneous and vhomogeneous properties. vhomogeneous is what we want for popover menus.
2014-10-26 18:59:21 +00:00
case PROP_HHOMOGENEOUS:
gtk_stack_set_hhomogeneous (stack, g_value_get_boolean (value));
break;
case PROP_VHOMOGENEOUS:
gtk_stack_set_vhomogeneous (stack, g_value_get_boolean (value));
break;
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
case PROP_VISIBLE_CHILD:
gtk_stack_set_visible_child (stack, g_value_get_object (value));
break;
case PROP_VISIBLE_CHILD_NAME:
gtk_stack_set_visible_child_name (stack, g_value_get_string (value));
break;
case PROP_TRANSITION_DURATION:
Make transition-duration unsigned The code doesn't deal with negative durations, so better don't allow them.
2013-04-22 01:31:29 +00:00
gtk_stack_set_transition_duration (stack, g_value_get_uint (value));
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
break;
case PROP_TRANSITION_TYPE:
Change transition-type property type This is an enum, so declare the property as such.
2013-04-22 01:16:46 +00:00
gtk_stack_set_transition_type (stack, g_value_get_enum (value));
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
break;
GtkStack: Add interpolate-size property And use it to determine whether we should actually interpolate between stack sizes or not.
2015-07-19 15:39:41 +00:00
case PROP_INTERPOLATE_SIZE:
gtk_stack_set_interpolate_size (stack, g_value_get_boolean (value));
break;
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
gtk_stack_class_init (GtkStackClass *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_stack_get_property;
object_class->set_property = gtk_stack_set_property;
stack: Provide a selection model Make GtkStack expose a selection model for its pages. The model can be used to track changes to the pages, and to change what child is visible.
2019-02-10 23:22:54 +00:00
object_class->dispose = gtk_stack_dispose;
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
object_class->finalize = gtk_stack_finalize;
widget_class->size_allocate = gtk_stack_size_allocate;
stack: Implement snapshot() This uses the new push()/pop() mechanism to its fullest extent when implementing transitions. It's fun to inspect the results in the inspector. Crossfades don't work yet, they continue using a Cairo fallback. A side effect of the stack conversion is that widget-factory now uses snapshots for a lot more things.
2016-12-13 08:45:09 +00:00
widget_class->snapshot = gtk_stack_snapshot;
stack: Remove gadget
2017-05-05 15:18:15 +00:00
widget_class->measure = gtk_stack_measure;
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
widget_class->compute_expand = gtk_stack_compute_expand;
container_class->add = gtk_stack_add;
container_class->remove = gtk_stack_remove;
container_class->forall = gtk_stack_forall;
GtkStack: split homogeneous Split homogeneous into separate hhomogeneous and vhomogeneous properties. vhomogeneous is what we want for popover menus.
2014-10-26 18:59:21 +00:00
/**
* GtkStack:hhomogeneous:
*
* %TRUE if the stack allocates the same width for all children.
*/
stack_props[PROP_HHOMOGENEOUS] =
g_param_spec_boolean ("hhomogeneous", P_("Horizontally homogeneous"), P_("Horizontally homogeneous sizing"),
TRUE,
gtkstack: allow templates to override all properties Currently GtkStack has some G_PARAM_CONSTRUCT properties. That means, the properties are set with its default value after the initializacion of the object. When using GtkBuilder to build objects, GtkBuilder creates them and after that sets the properties found on the xml definition. However, this is not true for templates because the template is initialized in the init() function of the actual object, and after that, the construct properties will be set. This is a problem when someone wants to use templates with GtkStack and set those properties, since they will be set on the tempalt initialization and set again to its default values afterwards. To fix this, make those properties not G_PARAM_CONSTRUCT. https://bugzilla.gnome.org/show_bug.cgi?id=758086
2015-11-11 12:51:02 +00:00
GTK_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY);
GtkStack: split homogeneous Split homogeneous into separate hhomogeneous and vhomogeneous properties. vhomogeneous is what we want for popover menus.
2014-10-26 18:59:21 +00:00
/**
* GtkStack:vhomogeneous:
*
* %TRUE if the stack allocates the same height for all children.
*/
stack_props[PROP_VHOMOGENEOUS] =
g_param_spec_boolean ("vhomogeneous", P_("Vertically homogeneous"), P_("Vertically homogeneous sizing"),
GtkStack: Use G_PARAM_EXPLICIT_NOTIFY
2014-06-07 03:30:44 +00:00
TRUE,
gtkstack: allow templates to override all properties Currently GtkStack has some G_PARAM_CONSTRUCT properties. That means, the properties are set with its default value after the initializacion of the object. When using GtkBuilder to build objects, GtkBuilder creates them and after that sets the properties found on the xml definition. However, this is not true for templates because the template is initialized in the init() function of the actual object, and after that, the construct properties will be set. This is a problem when someone wants to use templates with GtkStack and set those properties, since they will be set on the tempalt initialization and set again to its default values afterwards. To fix this, make those properties not G_PARAM_CONSTRUCT. https://bugzilla.gnome.org/show_bug.cgi?id=758086
2015-11-11 12:51:02 +00:00
GTK_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY);
GtkStack: Use G_PARAM_EXPLICIT_NOTIFY
2014-06-07 03:30:44 +00:00
stack_props[PROP_VISIBLE_CHILD] =
g_param_spec_object ("visible-child", P_("Visible child"), P_("The widget currently visible in the stack"),
GTK_TYPE_WIDGET,
GTK_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY);
stack_props[PROP_VISIBLE_CHILD_NAME] =
g_param_spec_string ("visible-child-name", P_("Name of visible child"), P_("The name of the widget currently visible in the stack"),
NULL,
GTK_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY);
stack_props[PROP_TRANSITION_DURATION] =
g_param_spec_uint ("transition-duration", P_("Transition duration"), P_("The animation duration, in milliseconds"),
0, G_MAXUINT, 200,
gtkstack: allow templates to override all properties Currently GtkStack has some G_PARAM_CONSTRUCT properties. That means, the properties are set with its default value after the initializacion of the object. When using GtkBuilder to build objects, GtkBuilder creates them and after that sets the properties found on the xml definition. However, this is not true for templates because the template is initialized in the init() function of the actual object, and after that, the construct properties will be set. This is a problem when someone wants to use templates with GtkStack and set those properties, since they will be set on the tempalt initialization and set again to its default values afterwards. To fix this, make those properties not G_PARAM_CONSTRUCT. https://bugzilla.gnome.org/show_bug.cgi?id=758086
2015-11-11 12:51:02 +00:00
GTK_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY);
GtkStack: Use G_PARAM_EXPLICIT_NOTIFY
2014-06-07 03:30:44 +00:00
stack_props[PROP_TRANSITION_TYPE] =
g_param_spec_enum ("transition-type", P_("Transition type"), P_("The type of animation used to transition"),
GTK_TYPE_STACK_TRANSITION_TYPE, GTK_STACK_TRANSITION_TYPE_NONE,
gtkstack: allow templates to override all properties Currently GtkStack has some G_PARAM_CONSTRUCT properties. That means, the properties are set with its default value after the initializacion of the object. When using GtkBuilder to build objects, GtkBuilder creates them and after that sets the properties found on the xml definition. However, this is not true for templates because the template is initialized in the init() function of the actual object, and after that, the construct properties will be set. This is a problem when someone wants to use templates with GtkStack and set those properties, since they will be set on the tempalt initialization and set again to its default values afterwards. To fix this, make those properties not G_PARAM_CONSTRUCT. https://bugzilla.gnome.org/show_bug.cgi?id=758086
2015-11-11 12:51:02 +00:00
GTK_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY);
GtkStack: Use G_PARAM_EXPLICIT_NOTIFY
2014-06-07 03:30:44 +00:00
stack_props[PROP_TRANSITION_RUNNING] =
g_param_spec_boolean ("transition-running", P_("Transition running"), P_("Whether or not the transition is currently running"),
FALSE,
GTK_PARAM_READABLE);
GtkStack: Add interpolate-size property And use it to determine whether we should actually interpolate between stack sizes or not.
2015-07-19 15:39:41 +00:00
stack_props[PROP_INTERPOLATE_SIZE] =
g_param_spec_boolean ("interpolate-size", P_("Interpolate size"), P_("Whether or not the size should smoothly change when changing between differently sized children"),
FALSE,
Avoid excessive property notification for GtkStack::interpolate-size make check checks this for writable properties, and fails now that we've made this property writable.
2015-11-09 14:27:40 +00:00
GTK_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY);
GtkStack: Add interpolate-size property And use it to determine whether we should actually interpolate between stack sizes or not.
2015-07-19 15:39:41 +00:00
stack: Add a pages property This makes the list model available in the inspector.
2019-02-13 19:14:54 +00:00
stack_props[PROP_PAGES] =
g_param_spec_object ("pages", P_("Pages"), P_("A selection model with the stacks pages"),
GTK_TYPE_SELECTION_MODEL,
GTK_PARAM_READABLE);
stack: Use g_object_class_install_properties() https://bugzilla.gnome.org/show_bug.cgi?id=711611
2013-11-05 10:11:35 +00:00
g_object_class_install_properties (object_class, LAST_PROP, stack_props);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
stack: Set an element name And it is...stack.
2015-11-04 04:19:28 +00:00
Add GtkStackAccessible Show only the currently visible child to a11y.
2016-05-29 11:51:02 +00:00
gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_STACK_ACCESSIBLE);
gtk: Intern css names This avoids a bunch of strdups at startup.
2017-11-18 03:49:57 +00:00
gtk_widget_class_set_css_name (widget_class, I_("stack"));
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
}
Add docs for GtkStack
2013-04-21 14:14:46 +00:00
/**
* gtk_stack_new:
*
* Creates a new #GtkStack container.
*
* Returns: a new #GtkStack
*/
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
GtkWidget *
gtk_stack_new (void)
{
return g_object_new (GTK_TYPE_STACK, NULL);
}
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
static GtkStackPage *
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
find_child_info_for_widget (GtkStack *stack,
GtkWidget *child)
{
stack: Use new private model, remove priv pointer
2013-07-02 11:43:20 +00:00
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
GtkStackPage *info;
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
GList *l;
for (l = priv->children; l != NULL; l = l->next)
{
info = l->data;
if (info->widget == child)
return info;
}
return NULL;
}
stack: More readability when adding transitions This small refactor makes the code more readable when adding more transition types that have left, right, up, and down variations. It adds inline boolean functions to tell information about transition types (avoiding long if clauses) and changes long chains of "else if (transition_type == ...)" into switch statements. Both are only likely to get longer as more transition types are added. https://bugzilla.gnome.org/show_bug.cgi?id=726676
2014-03-19 00:49:46 +00:00
static inline gboolean
is_left_transition (GtkStackTransitionType transition_type)
{
return (transition_type == GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT ||
transition_type == GTK_STACK_TRANSITION_TYPE_OVER_LEFT);
}
static inline gboolean
is_right_transition (GtkStackTransitionType transition_type)
{
return (transition_type == GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT ||
transition_type == GTK_STACK_TRANSITION_TYPE_OVER_RIGHT);
}
static inline gboolean
is_up_transition (GtkStackTransitionType transition_type)
{
return (transition_type == GTK_STACK_TRANSITION_TYPE_SLIDE_UP ||
transition_type == GTK_STACK_TRANSITION_TYPE_OVER_UP);
}
static inline gboolean
is_down_transition (GtkStackTransitionType transition_type)
{
return (transition_type == GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN ||
transition_type == GTK_STACK_TRANSITION_TYPE_OVER_DOWN);
}
/* Transitions that cause the bin window to move */
static inline gboolean
is_window_moving_transition (GtkStackTransitionType transition_type)
{
return (transition_type == GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT ||
transition_type == GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT ||
transition_type == GTK_STACK_TRANSITION_TYPE_SLIDE_UP ||
transition_type == GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN ||
transition_type == GTK_STACK_TRANSITION_TYPE_OVER_UP ||
transition_type == GTK_STACK_TRANSITION_TYPE_OVER_DOWN ||
transition_type == GTK_STACK_TRANSITION_TYPE_OVER_LEFT ||
transition_type == GTK_STACK_TRANSITION_TYPE_OVER_RIGHT);
}
/* Transitions that change direction depending on the relative order of the
old and new child */
static inline gboolean
is_direction_dependent_transition (GtkStackTransitionType transition_type)
{
return (transition_type == GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT ||
transition_type == GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN ||
stack: Add counterparts of OVER_UP_DOWN transition The GtkStackTransitionType enum now has OVER_DOWN_UP, OVER_LEFT_RIGHT, and OVER_RIGHT_LEFT values to complement OVER_UP_DOWN. https://bugzilla.gnome.org/show_bug.cgi?id=726676
2014-03-19 03:42:59 +00:00
transition_type == GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN ||
transition_type == GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP ||
transition_type == GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT ||
stack: Add a cube spin transition Add a transition to GtkStack that pretends pages are the sides or a cube, and switch them by rotating the cube. Use this transition in widget-factory.
2019-03-05 19:44:45 +00:00
transition_type == GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT ||
transition_type == GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT_RIGHT);
stack: More readability when adding transitions This small refactor makes the code more readable when adding more transition types that have left, right, up, and down variations. It adds inline boolean functions to tell information about transition types (avoiding long if clauses) and changes long chains of "else if (transition_type == ...)" into switch statements. Both are only likely to get longer as more transition types are added. https://bugzilla.gnome.org/show_bug.cgi?id=726676
2014-03-19 00:49:46 +00:00
}
/* Returns simple transition type for a direction dependent transition, given
whether the new child (the one being switched to) is first in the stacking order
(added earlier). */
static inline GtkStackTransitionType
get_simple_transition_type (gboolean new_child_first,
GtkStackTransitionType transition_type)
{
switch (transition_type)
{
case GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT:
return new_child_first ? GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT : GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT;
stack: Add a cube spin transition Add a transition to GtkStack that pretends pages are the sides or a cube, and switch them by rotating the cube. Use this transition in widget-factory.
2019-03-05 19:44:45 +00:00
case GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT_RIGHT:
return new_child_first ? GTK_STACK_TRANSITION_TYPE_ROTATE_RIGHT : GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT;
stack: More readability when adding transitions This small refactor makes the code more readable when adding more transition types that have left, right, up, and down variations. It adds inline boolean functions to tell information about transition types (avoiding long if clauses) and changes long chains of "else if (transition_type == ...)" into switch statements. Both are only likely to get longer as more transition types are added. https://bugzilla.gnome.org/show_bug.cgi?id=726676
2014-03-19 00:49:46 +00:00
case GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN:
return new_child_first ? GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN : GTK_STACK_TRANSITION_TYPE_SLIDE_UP;
case GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN:
return new_child_first ? GTK_STACK_TRANSITION_TYPE_UNDER_DOWN : GTK_STACK_TRANSITION_TYPE_OVER_UP;
stack: Add counterparts of OVER_UP_DOWN transition The GtkStackTransitionType enum now has OVER_DOWN_UP, OVER_LEFT_RIGHT, and OVER_RIGHT_LEFT values to complement OVER_UP_DOWN. https://bugzilla.gnome.org/show_bug.cgi?id=726676
2014-03-19 03:42:59 +00:00
case GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP:
return new_child_first ? GTK_STACK_TRANSITION_TYPE_UNDER_UP : GTK_STACK_TRANSITION_TYPE_OVER_DOWN;
case GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT:
return new_child_first ? GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT : GTK_STACK_TRANSITION_TYPE_OVER_LEFT;
case GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT:
return new_child_first ? GTK_STACK_TRANSITION_TYPE_UNDER_LEFT : GTK_STACK_TRANSITION_TYPE_OVER_RIGHT;
build: Enable -Wswitch-enum and -Wswitch-default This patch makes that work using 1 of 2 options: 1. Add all missing enums to the switch statement or 2. Cast the switch argument to a uint to avoid having to do that (mostly for GdkEventType). I even found a bug while doing that: clearing a GtkImage with a surface did not notify thae surface property. The reason for enabling this flag even though it is tedious at times is that it is very useful when adding values to an enum, because it makes GTK immediately warn about all the switch statements where this enum is relevant. And I expect changes to enums to be frequent during the GTK4 development cycle.
2017-10-06 19:19:42 +00:00
case GTK_STACK_TRANSITION_TYPE_SLIDE_UP:
case GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN:
case GTK_STACK_TRANSITION_TYPE_OVER_UP:
case GTK_STACK_TRANSITION_TYPE_OVER_DOWN:
case GTK_STACK_TRANSITION_TYPE_UNDER_UP:
case GTK_STACK_TRANSITION_TYPE_UNDER_DOWN:
case GTK_STACK_TRANSITION_TYPE_NONE:
case GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT:
case GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT:
case GTK_STACK_TRANSITION_TYPE_OVER_LEFT:
case GTK_STACK_TRANSITION_TYPE_OVER_RIGHT:
case GTK_STACK_TRANSITION_TYPE_UNDER_LEFT:
case GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT:
case GTK_STACK_TRANSITION_TYPE_CROSSFADE:
stack: Add a cube spin transition Add a transition to GtkStack that pretends pages are the sides or a cube, and switch them by rotating the cube. Use this transition in widget-factory.
2019-03-05 19:44:45 +00:00
case GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT:
case GTK_STACK_TRANSITION_TYPE_ROTATE_RIGHT:
build: Enable -Wswitch-enum and -Wswitch-default This patch makes that work using 1 of 2 options: 1. Add all missing enums to the switch statement or 2. Cast the switch argument to a uint to avoid having to do that (mostly for GdkEventType). I even found a bug while doing that: clearing a GtkImage with a surface did not notify thae surface property. The reason for enabling this flag even though it is tedious at times is that it is very useful when adding values to an enum, because it makes GTK immediately warn about all the switch statements where this enum is relevant. And I expect changes to enums to be frequent during the GTK4 development cycle.
2017-10-06 19:19:42 +00:00
default:
return transition_type;
stack: More readability when adding transitions This small refactor makes the code more readable when adding more transition types that have left, right, up, and down variations. It adds inline boolean functions to tell information about transition types (avoiding long if clauses) and changes long chains of "else if (transition_type == ...)" into switch statements. Both are only likely to get longer as more transition types are added. https://bugzilla.gnome.org/show_bug.cgi?id=726676
2014-03-19 00:49:46 +00:00
}
}
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
static gint
stack: Remove bin_window
2017-06-04 15:30:40 +00:00
get_bin_window_x (GtkStack *stack)
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
{
stack: Use new private model, remove priv pointer
2013-07-02 11:43:20 +00:00
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
Remove all gtk_widget_get_content_size usages And remove the function itself. Make everything use gtk_widget_get_width and gtk_widget_get_height instead.
2017-12-06 06:56:12 +00:00
int width;
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
int x = 0;
Remove all gtk_widget_get_content_size usages And remove the function itself. Make everything use gtk_widget_get_width and gtk_widget_get_height instead.
2017-12-06 06:56:12 +00:00
width = gtk_widget_get_width (GTK_WIDGET (stack));
stack: Remove bin_window
2017-06-04 15:30:40 +00:00
stack: port to progress tracker
2016-03-01 06:24:39 +00:00
if (gtk_progress_tracker_get_state (&priv->tracker) != GTK_PROGRESS_STATE_AFTER)
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
{
stack: More readability when adding transitions This small refactor makes the code more readable when adding more transition types that have left, right, up, and down variations. It adds inline boolean functions to tell information about transition types (avoiding long if clauses) and changes long chains of "else if (transition_type == ...)" into switch statements. Both are only likely to get longer as more transition types are added. https://bugzilla.gnome.org/show_bug.cgi?id=726676
2014-03-19 00:49:46 +00:00
if (is_left_transition (priv->active_transition_type))
Replace a few get_content_allocation calls with get_content_size The position of the content allocation is almost never relevant since it's 0/0 for measure, size_allocate and snapshot.
2017-06-18 13:45:42 +00:00
x = width * (1 - gtk_progress_tracker_get_ease_out_cubic (&priv->tracker, FALSE));
stack: More readability when adding transitions This small refactor makes the code more readable when adding more transition types that have left, right, up, and down variations. It adds inline boolean functions to tell information about transition types (avoiding long if clauses) and changes long chains of "else if (transition_type == ...)" into switch statements. Both are only likely to get longer as more transition types are added. https://bugzilla.gnome.org/show_bug.cgi?id=726676
2014-03-19 00:49:46 +00:00
if (is_right_transition (priv->active_transition_type))
Replace a few get_content_allocation calls with get_content_size The position of the content allocation is almost never relevant since it's 0/0 for measure, size_allocate and snapshot.
2017-06-18 13:45:42 +00:00
x = -width * (1 - gtk_progress_tracker_get_ease_out_cubic (&priv->tracker, FALSE));
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
}
stack: Remove bin_window
2017-06-04 15:30:40 +00:00
return x;
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
}
GtkStack: add vertical slide transitions We allow transitions that slide up or down.
2013-04-22 00:17:40 +00:00
static gint
stack: Remove bin_window
2017-06-04 15:30:40 +00:00
get_bin_window_y (GtkStack *stack)
GtkStack: add vertical slide transitions We allow transitions that slide up or down.
2013-04-22 00:17:40 +00:00
{
stack: Use new private model, remove priv pointer
2013-07-02 11:43:20 +00:00
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
Remove all gtk_widget_get_content_size usages And remove the function itself. Make everything use gtk_widget_get_width and gtk_widget_get_height instead.
2017-12-06 06:56:12 +00:00
int height;
GtkStack: add vertical slide transitions We allow transitions that slide up or down.
2013-04-22 00:17:40 +00:00
int y = 0;
Remove all gtk_widget_get_content_size usages And remove the function itself. Make everything use gtk_widget_get_width and gtk_widget_get_height instead.
2017-12-06 06:56:12 +00:00
height = gtk_widget_get_height (GTK_WIDGET (stack));
stack: Remove bin_window
2017-06-04 15:30:40 +00:00
stack: port to progress tracker
2016-03-01 06:24:39 +00:00
if (gtk_progress_tracker_get_state (&priv->tracker) != GTK_PROGRESS_STATE_AFTER)
GtkStack: add vertical slide transitions We allow transitions that slide up or down.
2013-04-22 00:17:40 +00:00
{
stack: More readability when adding transitions This small refactor makes the code more readable when adding more transition types that have left, right, up, and down variations. It adds inline boolean functions to tell information about transition types (avoiding long if clauses) and changes long chains of "else if (transition_type == ...)" into switch statements. Both are only likely to get longer as more transition types are added. https://bugzilla.gnome.org/show_bug.cgi?id=726676
2014-03-19 00:49:46 +00:00
if (is_up_transition (priv->active_transition_type))
Replace a few get_content_allocation calls with get_content_size The position of the content allocation is almost never relevant since it's 0/0 for measure, size_allocate and snapshot.
2017-06-18 13:45:42 +00:00
y = height * (1 - gtk_progress_tracker_get_ease_out_cubic (&priv->tracker, FALSE));
stack: More readability when adding transitions This small refactor makes the code more readable when adding more transition types that have left, right, up, and down variations. It adds inline boolean functions to tell information about transition types (avoiding long if clauses) and changes long chains of "else if (transition_type == ...)" into switch statements. Both are only likely to get longer as more transition types are added. https://bugzilla.gnome.org/show_bug.cgi?id=726676
2014-03-19 00:49:46 +00:00
if (is_down_transition(priv->active_transition_type))
Replace a few get_content_allocation calls with get_content_size The position of the content allocation is almost never relevant since it's 0/0 for measure, size_allocate and snapshot.
2017-06-18 13:45:42 +00:00
y = -height * (1 - gtk_progress_tracker_get_ease_out_cubic (&priv->tracker, FALSE));
GtkStack: add vertical slide transitions We allow transitions that slide up or down.
2013-04-22 00:17:40 +00:00
}
stack: Remove bin_window
2017-06-04 15:30:40 +00:00
return y;
GtkStack: add vertical slide transitions We allow transitions that slide up or down.
2013-04-22 00:17:40 +00:00
}
stack: port to progress tracker
2016-03-01 06:24:39 +00:00
static void
gtk_stack_progress_updated (GtkStack *stack)
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
{
stack: Use new private model, remove priv pointer
2013-07-02 11:43:20 +00:00
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
GtkStack: Interpolate between size changes
2015-05-24 19:27:33 +00:00
if (!priv->vhomogeneous || !priv->hhomogeneous)
gtk_widget_queue_resize (GTK_WIDGET (stack));
stack: Remove bin_window
2017-06-04 15:30:40 +00:00
else if (is_window_moving_transition (priv->active_transition_type))
gtk_widget_queue_allocate (GTK_WIDGET (stack));
stack: Don't queue an unnecessary redraw Both queue_allocate and queue_resize already queue a draw.
2018-12-23 07:23:03 +00:00
else
gtk_widget_queue_draw (GTK_WIDGET (stack));
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
stack: port to progress tracker
2016-03-01 06:24:39 +00:00
if (gtk_progress_tracker_get_state (&priv->tracker) == GTK_PROGRESS_STATE_AFTER)
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
{
stack: Implement snapshot() This uses the new push()/pop() mechanism to its fullest extent when implementing transitions. It's fun to inspect the results in the inspector. Crossfades don't work yet, they continue using a Cairo fallback. A side effect of the stack conversion is that widget-factory now uses snapshots for a lot more things.
2016-12-13 08:45:09 +00:00
g_clear_pointer (&priv->last_visible_node, gsk_render_node_unref);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
GtkStack: Keep the last_visible_child around during transitions We need it later.
2015-05-24 19:15:44 +00:00
if (priv->last_visible_child != NULL)
{
gtk_widget_set_child_visible (priv->last_visible_child->widget, FALSE);
priv->last_visible_child = NULL;
}
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
}
}
static gboolean
widgets: Remove (GtkTickCallback) casts Instead, make the functions conform to the prototype, so that casting isn't needed.
2014-04-16 13:36:22 +00:00
gtk_stack_transition_cb (GtkWidget *widget,
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
GdkFrameClock *frame_clock,
gpointer user_data)
{
widgets: Remove (GtkTickCallback) casts Instead, make the functions conform to the prototype, so that casting isn't needed.
2014-04-16 13:36:22 +00:00
GtkStack *stack = GTK_STACK (widget);
stack: Use new private model, remove priv pointer
2013-07-02 11:43:20 +00:00
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
stack: skip first frame for animations Not the ideal solution for this problem, but in practice leads to much better performance on lower end hardware. Stack does a double draw on the first frame of its animation, of both the old contents (into a cairo surface) and the new contents. Homogeneous stacks only need to reallocate contents on the first frame. On lower powered hardware where our frames will be a good deal slower than the refresh rate anyway, we can assure a smother experience by waiting a frame to start tweening where frame duration will be more consistent.
2016-03-02 01:19:50 +00:00
if (priv->first_frame_skipped)
gtk_progress_tracker_advance_frame (&priv->tracker,
gdk_frame_clock_get_frame_time (frame_clock));
else
priv->first_frame_skipped = TRUE;
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
/* Finish animation early if not mapped anymore */
GtkStack: Remove useless cast
2015-05-24 19:08:00 +00:00
if (!gtk_widget_get_mapped (widget))
stack: port to progress tracker
2016-03-01 06:24:39 +00:00
gtk_progress_tracker_finish (&priv->tracker);
gtk_stack_progress_updated (GTK_STACK (widget));
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
stack: port to progress tracker
2016-03-01 06:24:39 +00:00
if (gtk_progress_tracker_get_state (&priv->tracker) == GTK_PROGRESS_STATE_AFTER)
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
{
priv->tick_id = 0;
GtkStack: add transition-running property This is useful to know when the transition is done we can remove the child from the stack. https://bugzilla.gnome.org/show_bug.cgi?id=711494
2013-11-11 21:38:35 +00:00
g_object_notify_by_pspec (G_OBJECT (stack), stack_props[PROP_TRANSITION_RUNNING]);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
return FALSE;
}
return TRUE;
}
static void
gtk_stack_schedule_ticks (GtkStack *stack)
{
stack: Use new private model, remove priv pointer
2013-07-02 11:43:20 +00:00
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
if (priv->tick_id == 0)
{
priv->tick_id =
widgets: Remove (GtkTickCallback) casts Instead, make the functions conform to the prototype, so that casting isn't needed.
2014-04-16 13:36:22 +00:00
gtk_widget_add_tick_callback (GTK_WIDGET (stack), gtk_stack_transition_cb, stack, NULL);
GtkStack: add transition-running property This is useful to know when the transition is done we can remove the child from the stack. https://bugzilla.gnome.org/show_bug.cgi?id=711494
2013-11-11 21:38:35 +00:00
g_object_notify_by_pspec (G_OBJECT (stack), stack_props[PROP_TRANSITION_RUNNING]);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
}
}
static void
gtk_stack_unschedule_ticks (GtkStack *stack)
{
stack: Use new private model, remove priv pointer
2013-07-02 11:43:20 +00:00
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
if (priv->tick_id != 0)
{
gtk_widget_remove_tick_callback (GTK_WIDGET (stack), priv->tick_id);
priv->tick_id = 0;
GtkStack: add transition-running property This is useful to know when the transition is done we can remove the child from the stack. https://bugzilla.gnome.org/show_bug.cgi?id=711494
2013-11-11 21:38:35 +00:00
g_object_notify_by_pspec (G_OBJECT (stack), stack_props[PROP_TRANSITION_RUNNING]);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
}
}
GtkStack: rtl flipping for animation We switch slide-right and slight-left when in rtl.
2013-04-21 23:53:57 +00:00
static GtkStackTransitionType
effective_transition_type (GtkStack *stack,
GtkStackTransitionType transition_type)
{
Avoid some more type checks for internal calls
2017-01-11 14:27:51 +00:00
if (_gtk_widget_get_direction (GTK_WIDGET (stack)) == GTK_TEXT_DIR_RTL)
GtkStack: rtl flipping for animation We switch slide-right and slight-left when in rtl.
2013-04-21 23:53:57 +00:00
{
stack: More readability when adding transitions This small refactor makes the code more readable when adding more transition types that have left, right, up, and down variations. It adds inline boolean functions to tell information about transition types (avoiding long if clauses) and changes long chains of "else if (transition_type == ...)" into switch statements. Both are only likely to get longer as more transition types are added. https://bugzilla.gnome.org/show_bug.cgi?id=726676
2014-03-19 00:49:46 +00:00
switch (transition_type)
{
case GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT:
return GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT;
case GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT:
return GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT;
stack: Add a cube spin transition Add a transition to GtkStack that pretends pages are the sides or a cube, and switch them by rotating the cube. Use this transition in widget-factory.
2019-03-05 19:44:45 +00:00
case GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT:
return GTK_STACK_TRANSITION_TYPE_ROTATE_RIGHT;
case GTK_STACK_TRANSITION_TYPE_ROTATE_RIGHT:
return GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT;
stack: More readability when adding transitions This small refactor makes the code more readable when adding more transition types that have left, right, up, and down variations. It adds inline boolean functions to tell information about transition types (avoiding long if clauses) and changes long chains of "else if (transition_type == ...)" into switch statements. Both are only likely to get longer as more transition types are added. https://bugzilla.gnome.org/show_bug.cgi?id=726676
2014-03-19 00:49:46 +00:00
case GTK_STACK_TRANSITION_TYPE_OVER_LEFT:
return GTK_STACK_TRANSITION_TYPE_OVER_RIGHT;
case GTK_STACK_TRANSITION_TYPE_OVER_RIGHT:
return GTK_STACK_TRANSITION_TYPE_OVER_LEFT;
case GTK_STACK_TRANSITION_TYPE_UNDER_LEFT:
return GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT;
case GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT:
return GTK_STACK_TRANSITION_TYPE_UNDER_LEFT;
build: Enable -Wswitch-enum and -Wswitch-default This patch makes that work using 1 of 2 options: 1. Add all missing enums to the switch statement or 2. Cast the switch argument to a uint to avoid having to do that (mostly for GdkEventType). I even found a bug while doing that: clearing a GtkImage with a surface did not notify thae surface property. The reason for enabling this flag even though it is tedious at times is that it is very useful when adding values to an enum, because it makes GTK immediately warn about all the switch statements where this enum is relevant. And I expect changes to enums to be frequent during the GTK4 development cycle.
2017-10-06 19:19:42 +00:00
case GTK_STACK_TRANSITION_TYPE_SLIDE_UP:
case GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN:
case GTK_STACK_TRANSITION_TYPE_OVER_UP:
case GTK_STACK_TRANSITION_TYPE_OVER_DOWN:
case GTK_STACK_TRANSITION_TYPE_UNDER_UP:
case GTK_STACK_TRANSITION_TYPE_UNDER_DOWN:
case GTK_STACK_TRANSITION_TYPE_NONE:
case GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT:
case GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN:
case GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN:
case GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP:
case GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT:
case GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT:
case GTK_STACK_TRANSITION_TYPE_CROSSFADE:
stack: Add a cube spin transition Add a transition to GtkStack that pretends pages are the sides or a cube, and switch them by rotating the cube. Use this transition in widget-factory.
2019-03-05 19:44:45 +00:00
case GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT_RIGHT:
build: Enable -Wswitch-enum and -Wswitch-default This patch makes that work using 1 of 2 options: 1. Add all missing enums to the switch statement or 2. Cast the switch argument to a uint to avoid having to do that (mostly for GdkEventType). I even found a bug while doing that: clearing a GtkImage with a surface did not notify thae surface property. The reason for enabling this flag even though it is tedious at times is that it is very useful when adding values to an enum, because it makes GTK immediately warn about all the switch statements where this enum is relevant. And I expect changes to enums to be frequent during the GTK4 development cycle.
2017-10-06 19:19:42 +00:00
default:
return transition_type;
stack: More readability when adding transitions This small refactor makes the code more readable when adding more transition types that have left, right, up, and down variations. It adds inline boolean functions to tell information about transition types (avoiding long if clauses) and changes long chains of "else if (transition_type == ...)" into switch statements. Both are only likely to get longer as more transition types are added. https://bugzilla.gnome.org/show_bug.cgi?id=726676
2014-03-19 00:49:46 +00:00
}
GtkStack: rtl flipping for animation We switch slide-right and slight-left when in rtl.
2013-04-21 23:53:57 +00:00
}
build: Enable -Wswitch-enum and -Wswitch-default This patch makes that work using 1 of 2 options: 1. Add all missing enums to the switch statement or 2. Cast the switch argument to a uint to avoid having to do that (mostly for GdkEventType). I even found a bug while doing that: clearing a GtkImage with a surface did not notify thae surface property. The reason for enabling this flag even though it is tedious at times is that it is very useful when adding values to an enum, because it makes GTK immediately warn about all the switch statements where this enum is relevant. And I expect changes to enums to be frequent during the GTK4 development cycle.
2017-10-06 19:19:42 +00:00
else
{
return transition_type;
}
GtkStack: rtl flipping for animation We switch slide-right and slight-left when in rtl.
2013-04-21 23:53:57 +00:00
}
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
static void
Add a way to specify transition types on the fly Add a gtk_stack_set_visible_child_full that takes a transition type.
2013-04-21 18:22:35 +00:00
gtk_stack_start_transition (GtkStack *stack,
GtkStackTransitionType transition_type,
guint transition_duration)
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
{
stack: Use new private model, remove priv pointer
2013-07-02 11:43:20 +00:00
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
GtkWidget *widget = GTK_WIDGET (stack);
if (gtk_widget_get_mapped (widget) &&
stack: Use getter for gtk-enable-animations
2016-05-01 04:39:55 +00:00
gtk_settings_get_enable_animations (gtk_widget_get_settings (widget)) &&
Add a way to specify transition types on the fly Add a gtk_stack_set_visible_child_full that takes a transition type.
2013-04-21 18:22:35 +00:00
transition_type != GTK_STACK_TRANSITION_TYPE_NONE &&
transition_duration != 0 &&
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
priv->last_visible_child != NULL)
{
GtkStack: rtl flipping for animation We switch slide-right and slight-left when in rtl.
2013-04-21 23:53:57 +00:00
priv->active_transition_type = effective_transition_type (stack, transition_type);
stack: skip first frame for animations Not the ideal solution for this problem, but in practice leads to much better performance on lower end hardware. Stack does a double draw on the first frame of its animation, of both the old contents (into a cairo surface) and the new contents. Homogeneous stacks only need to reallocate contents on the first frame. On lower powered hardware where our frames will be a good deal slower than the refresh rate anyway, we can assure a smother experience by waiting a frame to start tweening where frame duration will be more consistent.
2016-03-02 01:19:50 +00:00
priv->first_frame_skipped = FALSE;
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
gtk_stack_schedule_ticks (stack);
stack: port to progress tracker
2016-03-01 06:24:39 +00:00
gtk_progress_tracker_start (&priv->tracker,
priv->transition_duration * 1000,
0,
1.0);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
}
else
{
gtk_stack_unschedule_ticks (stack);
Add a way to specify transition types on the fly Add a gtk_stack_set_visible_child_full that takes a transition type.
2013-04-21 18:22:35 +00:00
priv->active_transition_type = GTK_STACK_TRANSITION_TYPE_NONE;
stack: port to progress tracker
2016-03-01 06:24:39 +00:00
gtk_progress_tracker_finish (&priv->tracker);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
}
stack: always update window position at transition start Sometimes on wayland we're seeing a frame draw before the first tick callback, where the window position has not yet been updated. With this change, the window is properly positioned as soon as gtk_stack_start_transition returns. https://bugzilla.gnome.org/show_bug.cgi?id=766405
2016-05-13 07:22:20 +00:00
gtk_stack_progress_updated (GTK_STACK (widget));
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
}
static void
Add a way to specify transition types on the fly Add a gtk_stack_set_visible_child_full that takes a transition type.
2013-04-21 18:22:35 +00:00
set_visible_child (GtkStack *stack,
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
GtkStackPage *child_info,
Add a way to specify transition types on the fly Add a gtk_stack_set_visible_child_full that takes a transition type.
2013-04-21 18:22:35 +00:00
GtkStackTransitionType transition_type,
guint transition_duration)
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
{
stack: Use new private model, remove priv pointer
2013-07-02 11:43:20 +00:00
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
GtkStackPage *info;
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
GtkWidget *widget = GTK_WIDGET (stack);
GList *l;
GtkStack: Improve focus handling Add notebook-like focus handling: Keep track of the last focused descendent of each page, and focus it again when switching back to the page. If there is no last focused child, we move the focus into the page as if the user had hit Tab.
2014-12-11 03:32:45 +00:00
GtkWidget *focus;
gboolean contains_focus = FALSE;
stack: Don't emit bad ::selection-changed signals We have to be careful to not pass bad numbers to this signal, which was happening in cases where we have on old or new selected item.
2019-02-13 14:01:07 +00:00
guint old_pos = GTK_INVALID_LIST_POSITION;
guint new_pos = GTK_INVALID_LIST_POSITION;
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
Avoid spurious operations on destroy When the stack is destroyed we do not want to waste time running animations and notifying listeners about which is our current visible child. This is not only an optimization, but it is important for the stack switcher widgets: since they are in another branch of the hieratchy we do not want to get notifications while the stack is being destroyed. Based on a patch by Paolo Borelli https://bugzilla.gnome.org/show_bug.cgi?id=724506
2014-02-16 21:22:59 +00:00
/* if we are being destroyed, do not bother with transitions
GtkStack: Avoid some unnecessary complication We already have an in-destruction flag, so use it.
2015-06-23 10:44:31 +00:00
* and notifications
*/
if (gtk_widget_in_destruction (widget))
Avoid spurious operations on destroy When the stack is destroyed we do not want to waste time running animations and notifying listeners about which is our current visible child. This is not only an optimization, but it is important for the stack switcher widgets: since they are in another branch of the hieratchy we do not want to get notifications while the stack is being destroyed. Based on a patch by Paolo Borelli https://bugzilla.gnome.org/show_bug.cgi?id=724506
2014-02-16 21:22:59 +00:00
return;
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
/* If none, pick first visible */
if (child_info == NULL)
{
for (l = priv->children; l != NULL; l = l->next)
{
info = l->data;
if (gtk_widget_get_visible (info->widget))
{
child_info = info;
break;
}
}
}
if (child_info == priv->visible_child)
return;
stack: Provide a selection model Make GtkStack expose a selection model for its pages. The model can be used to track changes to the pages, and to change what child is visible.
2019-02-10 23:22:54 +00:00
if (priv->pages)
{
guint position;
for (l = priv->children, position = 0; l != NULL; l = l->next, position++)
{
info = l->data;
if (info == priv->visible_child)
old_pos = position;
else if (info == child_info)
new_pos = position;
}
}
Port widgets to the root focus API
2019-03-02 13:49:00 +00:00
if (gtk_widget_get_root (widget))
focus = gtk_root_get_focus (gtk_widget_get_root (widget));
else
focus = NULL;
if (focus &&
priv->visible_child &&
priv->visible_child->widget &&
gtk_widget_is_ancestor (focus, priv->visible_child->widget))
GtkStack: Improve focus handling Add notebook-like focus handling: Keep track of the last focused descendent of each page, and focus it again when switching back to the page. If there is no last focused child, we move the focus into the page as if the user had hit Tab.
2014-12-11 03:32:45 +00:00
{
Port widgets to the root focus API
2019-03-02 13:49:00 +00:00
contains_focus = TRUE;
if (priv->visible_child->last_focus)
g_object_remove_weak_pointer (G_OBJECT (priv->visible_child->last_focus),
(gpointer *)&priv->visible_child->last_focus);
priv->visible_child->last_focus = focus;
g_object_add_weak_pointer (G_OBJECT (priv->visible_child->last_focus),
(gpointer *)&priv->visible_child->last_focus);
GtkStack: Improve focus handling Add notebook-like focus handling: Keep track of the last focused descendent of each page, and focus it again when switching back to the page. If there is no last focused child, we move the focus into the page as if the user had hit Tab.
2014-12-11 03:32:45 +00:00
}
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
if (priv->last_visible_child)
gtk_widget_set_child_visible (priv->last_visible_child->widget, FALSE);
priv->last_visible_child = NULL;
stack: Implement snapshot() This uses the new push()/pop() mechanism to its fullest extent when implementing transitions. It's fun to inspect the results in the inspector. Crossfades don't work yet, they continue using a Cairo fallback. A side effect of the stack conversion is that widget-factory now uses snapshots for a lot more things.
2016-12-13 08:45:09 +00:00
g_clear_pointer (&priv->last_visible_node, gsk_render_node_unref);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
if (priv->visible_child && priv->visible_child->widget)
{
if (gtk_widget_is_visible (widget))
GtkStack: Save last visible widget size When interpolating the stack size, we compute the current size by using the prefered/minimum current size and the last size. We can't use the last_visible_surface_allocation because that is not available until the first _draw call and it doesn't include the child's margins.
2015-05-24 14:55:34 +00:00
{
priv->last_visible_child = priv->visible_child;
widget: Remove gtk_widget_get_allocated_size() Use gtk_widget_get_allocated_width/height in the only user (GtkStack), even though that isn't 100% correct.
2019-02-19 07:09:57 +00:00
priv->last_visible_widget_width = gtk_widget_get_allocated_width (priv->last_visible_child->widget);
priv->last_visible_widget_height = gtk_widget_get_allocated_height (priv->last_visible_child->widget);
GtkStack: Save last visible widget size When interpolating the stack size, we compute the current size by using the prefered/minimum current size and the last size. We can't use the last_visible_surface_allocation because that is not available until the first _draw call and it doesn't include the child's margins.
2015-05-24 14:55:34 +00:00
}
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
else
GtkStack: Save last visible widget size When interpolating the stack size, we compute the current size by using the prefered/minimum current size and the last size. We can't use the last_visible_surface_allocation because that is not available until the first _draw call and it doesn't include the child's margins.
2015-05-24 14:55:34 +00:00
{
gtk_widget_set_child_visible (priv->visible_child->widget, FALSE);
}
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
}
Add GtkStackAccessible Show only the currently visible child to a11y.
2016-05-29 11:51:02 +00:00
gtk_stack_accessible_update_visible_child (stack,
priv->visible_child ? priv->visible_child->widget : NULL,
child_info ? child_info->widget : NULL);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
priv->visible_child = child_info;
if (child_info)
GtkStack: Improve focus handling Add notebook-like focus handling: Keep track of the last focused descendent of each page, and focus it again when switching back to the page. If there is no last focused child, we move the focus into the page as if the user had hit Tab.
2014-12-11 03:32:45 +00:00
{
gtk_widget_set_child_visible (child_info->widget, TRUE);
if (contains_focus)
{
if (child_info->last_focus)
gtk_widget_grab_focus (child_info->last_focus);
else
gtk_widget_child_focus (child_info->widget, GTK_DIR_TAB_FORWARD);
}
}
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
GtkStack: Add position-dependent slide transitions These go left/right or up/down depending on the relative order of the children being switched between.
2013-06-13 18:33:42 +00:00
if ((child_info == NULL || priv->last_visible_child == NULL) &&
stack: More readability when adding transitions This small refactor makes the code more readable when adding more transition types that have left, right, up, and down variations. It adds inline boolean functions to tell information about transition types (avoiding long if clauses) and changes long chains of "else if (transition_type == ...)" into switch statements. Both are only likely to get longer as more transition types are added. https://bugzilla.gnome.org/show_bug.cgi?id=726676
2014-03-19 00:49:46 +00:00
is_direction_dependent_transition (transition_type))
GtkStack: Add position-dependent slide transitions These go left/right or up/down depending on the relative order of the children being switched between.
2013-06-13 18:33:42 +00:00
{
transition_type = GTK_STACK_TRANSITION_TYPE_NONE;
}
stack: More readability when adding transitions This small refactor makes the code more readable when adding more transition types that have left, right, up, and down variations. It adds inline boolean functions to tell information about transition types (avoiding long if clauses) and changes long chains of "else if (transition_type == ...)" into switch statements. Both are only likely to get longer as more transition types are added. https://bugzilla.gnome.org/show_bug.cgi?id=726676
2014-03-19 00:49:46 +00:00
else if (is_direction_dependent_transition (transition_type))
GtkStack: Add position-dependent slide transitions These go left/right or up/down depending on the relative order of the children being switched between.
2013-06-13 18:33:42 +00:00
{
gboolean i_first = FALSE;
GtkStack: Remove some clumsy use of GList API No need for g_list_next(), and don't open-code g_list_index().
2014-11-10 23:45:58 +00:00
for (l = priv->children; l != NULL; l = l->next)
GtkStack: Add position-dependent slide transitions These go left/right or up/down depending on the relative order of the children being switched between.
2013-06-13 18:33:42 +00:00
{
if (child_info == l->data)
{
i_first = TRUE;
break;
}
if (priv->last_visible_child == l->data)
break;
}
stack: More readability when adding transitions This small refactor makes the code more readable when adding more transition types that have left, right, up, and down variations. It adds inline boolean functions to tell information about transition types (avoiding long if clauses) and changes long chains of "else if (transition_type == ...)" into switch statements. Both are only likely to get longer as more transition types are added. https://bugzilla.gnome.org/show_bug.cgi?id=726676
2014-03-19 00:49:46 +00:00
transition_type = get_simple_transition_type (i_first, transition_type);
GtkStack: Add position-dependent slide transitions These go left/right or up/down depending on the relative order of the children being switched between.
2013-06-13 18:33:42 +00:00
}
stack: Queue a resize/allocate when switching children We only allocate a size to the currently visible child, so we obviously need to rerun allocation when the visible child changes. In the case where the stack is not homogenous, we also need to queue a resize because our size request just changed.
2015-11-04 18:11:14 +00:00
if (priv->hhomogeneous && priv->vhomogeneous)
gtk_widget_queue_allocate (widget);
else
gtk_widget_queue_resize (widget);
stack: Use g_object_notify_by_pspec() https://bugzilla.gnome.org/show_bug.cgi?id=711611
2013-11-05 10:18:37 +00:00
g_object_notify_by_pspec (G_OBJECT (stack), stack_props[PROP_VISIBLE_CHILD]);
g_object_notify_by_pspec (G_OBJECT (stack),
stack_props[PROP_VISIBLE_CHILD_NAME]);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
stack: Provide a selection model Make GtkStack expose a selection model for its pages. The model can be used to track changes to the pages, and to change what child is visible.
2019-02-10 23:22:54 +00:00
if (priv->pages)
stack: Don't emit bad ::selection-changed signals We have to be careful to not pass bad numbers to this signal, which was happening in cases where we have on old or new selected item.
2019-02-13 14:01:07 +00:00
{
if (old_pos == GTK_INVALID_LIST_POSITION && new_pos == GTK_INVALID_LIST_POSITION)
; /* nothing to do */
else if (old_pos == GTK_INVALID_LIST_POSITION)
gtk_selection_model_selection_changed (priv->pages, new_pos, 1);
else if (new_pos == GTK_INVALID_LIST_POSITION)
gtk_selection_model_selection_changed (priv->pages, old_pos, 1);
else
gtk_selection_model_selection_changed (priv->pages,
MIN (old_pos, new_pos),
MAX (old_pos, new_pos) - MIN (old_pos, new_pos) + 1);
}
stack: Provide a selection model Make GtkStack expose a selection model for its pages. The model can be used to track changes to the pages, and to change what child is visible.
2019-02-10 23:22:54 +00:00
Add a way to specify transition types on the fly Add a gtk_stack_set_visible_child_full that takes a transition type.
2013-04-21 18:22:35 +00:00
gtk_stack_start_transition (stack, transition_type, transition_duration);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
}
static void
stack_child_visibility_notify_cb (GObject *obj,
GParamSpec *pspec,
gpointer user_data)
{
GtkStack *stack = GTK_STACK (user_data);
stack: Use new private model, remove priv pointer
2013-07-02 11:43:20 +00:00
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
GtkWidget *child = GTK_WIDGET (obj);
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
GtkStackPage *child_info;
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
child_info = find_child_info_for_widget (stack, child);
stack: Make static analyzer happy
2020-03-06 04:56:29 +00:00
g_return_if_fail (child_info != NULL);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
if (priv->visible_child == NULL &&
gtk_widget_get_visible (child))
Add a way to specify transition types on the fly Add a gtk_stack_set_visible_child_full that takes a transition type.
2013-04-21 18:22:35 +00:00
set_visible_child (stack, child_info, priv->transition_type, priv->transition_duration);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
else if (priv->visible_child == child_info &&
!gtk_widget_get_visible (child))
Add a way to specify transition types on the fly Add a gtk_stack_set_visible_child_full that takes a transition type.
2013-04-21 18:22:35 +00:00
set_visible_child (stack, NULL, priv->transition_type, priv->transition_duration);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
if (child_info == priv->last_visible_child)
{
gtk_widget_set_child_visible (priv->last_visible_child->widget, FALSE);
priv->last_visible_child = NULL;
}
}
stack: return the stack page when adding a child, to ease setting props
2019-11-04 02:05:03 +00:00
static GtkStackPage *
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
gtk_stack_add_internal (GtkStack *stack,
GtkWidget *child,
const char *name,
const char *title);
Add docs for GtkStack
2013-04-21 14:14:46 +00:00
/**
* gtk_stack_add_titled:
* @stack: a #GtkStack
* @child: the widget to add
* @name: the name for @child
* @title: a human-readable title for @child
*
* Adds a child to @stack.
* The child is identified by the @name. The @title
* will be used by #GtkStackSwitcher to represent
* @child in a tab bar, so it should be short.
stack: return the stack page when adding a child, to ease setting props
2019-11-04 02:05:03 +00:00
*
* Returns: (transfer none): the #GtkStackPage for @child
Add docs for GtkStack
2013-04-21 14:14:46 +00:00
*/
stack: return the stack page when adding a child, to ease setting props
2019-11-04 02:05:03 +00:00
GtkStackPage *
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
gtk_stack_add_titled (GtkStack *stack,
GtkWidget *child,
const gchar *name,
const gchar *title)
{
stack: return the stack page when adding a child, to ease setting props
2019-11-04 02:05:03 +00:00
g_return_val_if_fail (GTK_IS_STACK (stack), NULL);
g_return_val_if_fail (GTK_IS_WIDGET (child), NULL);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
stack: return the stack page when adding a child, to ease setting props
2019-11-04 02:05:03 +00:00
return gtk_stack_add_internal (stack, child, name, title);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
}
Add docs for GtkStack
2013-04-21 14:14:46 +00:00
/**
* gtk_stack_add_named:
* @stack: a #GtkStack
* @child: the widget to add
* @name: the name for @child
*
* Adds a child to @stack.
* The child is identified by the @name.
stack: return the stack page when adding a child, to ease setting props
2019-11-04 02:05:03 +00:00
*
* Returns: (transfer none): the #GtkStackPage for @child
Add docs for GtkStack
2013-04-21 14:14:46 +00:00
*/
stack: return the stack page when adding a child, to ease setting props
2019-11-04 02:05:03 +00:00
GtkStackPage *
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
gtk_stack_add_named (GtkStack *stack,
GtkWidget *child,
const gchar *name)
{
stack: return the stack page when adding a child, to ease setting props
2019-11-04 02:05:03 +00:00
g_return_val_if_fail (GTK_IS_STACK (stack), NULL);
g_return_val_if_fail (GTK_IS_WIDGET (child), NULL);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
stack: return the stack page when adding a child, to ease setting props
2019-11-04 02:05:03 +00:00
return gtk_stack_add_internal (stack, child, name, NULL);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
}
static void
gtk_stack_add (GtkContainer *container,
GtkStack: Misc indentation fixes
2015-05-24 19:12:34 +00:00
GtkWidget *child)
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
{
GtkStack *stack = GTK_STACK (container);
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
gtk_stack_add_internal (stack, child, NULL, NULL);
}
stack: return the stack page when adding a child, to ease setting props
2019-11-04 02:05:03 +00:00
static GtkStackPage *
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
gtk_stack_add_internal (GtkStack *stack,
GtkWidget *child,
const char *name,
const char *title)
{
GtkStackPage *child_info;
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
stack: return the stack page when adding a child, to ease setting props
2019-11-04 02:05:03 +00:00
g_return_val_if_fail (child != NULL, NULL);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
child_info = g_object_new (GTK_TYPE_STACK_PAGE, NULL);
child_info->widget = g_object_ref (child);
child_info->name = g_strdup (name);
child_info->title = g_strdup (title);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
child_info->icon_name = NULL;
Add a needs-attention child property to GtkStack The child property is watched by the StackSwicther which in turns sets a needs-attention css class on the corresponding button, so that the theme can for instance show a throbbing animation if one of the hidden pages needs the user attention. https://bugzilla.gnome.org/show_bug.cgi?id=707153
2013-08-30 20:32:42 +00:00
child_info->needs_attention = FALSE;
GtkStack: Improve focus handling Add notebook-like focus handling: Keep track of the last focused descendent of each page, and focus it again when switching back to the page. If there is no last focused child, we move the focus into the page as if the user had hit Tab.
2014-12-11 03:32:45 +00:00
child_info->last_focus = NULL;
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
gtk_stack_add_page (stack, child_info);
g_object_unref (child_info);
stack: return the stack page when adding a child, to ease setting props
2019-11-04 02:05:03 +00:00
return child_info;
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
}
static void
gtk_stack_add_page (GtkStack *stack,
GtkStackPage *child_info)
{
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
GList *l;
g_return_if_fail (child_info->widget != NULL);
for (l = priv->children; l != NULL; l = l->next)
{
GtkStackPage *info = l->data;
if (info->name &&
g_strcmp0 (info->name, child_info->name) == 0)
{
g_warning ("While adding page: duplicate child name in GtkStack: %s", child_info->name);
break;
}
}
priv->children = g_list_append (priv->children, g_object_ref (child_info));
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
gtk_widget_set_child_visible (child_info->widget, FALSE);
gtk_widget_set_parent (child_info->widget, GTK_WIDGET (stack));
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
stack: Provide a selection model Make GtkStack expose a selection model for its pages. The model can be used to track changes to the pages, and to change what child is visible.
2019-02-10 23:22:54 +00:00
if (priv->pages)
g_list_model_items_changed (G_LIST_MODEL (priv->pages), g_list_length (priv->children) - 1, 0, 1);
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
g_signal_connect (child_info->widget, "notify::visible",
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
G_CALLBACK (stack_child_visibility_notify_cb), stack);
if (priv->visible_child == NULL &&
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
gtk_widget_get_visible (child_info->widget))
Add a way to specify transition types on the fly Add a gtk_stack_set_visible_child_full that takes a transition type.
2013-04-21 18:22:35 +00:00
set_visible_child (stack, child_info, priv->transition_type, priv->transition_duration);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
GtkStack: split homogeneous Split homogeneous into separate hhomogeneous and vhomogeneous properties. vhomogeneous is what we want for popover menus.
2014-10-26 18:59:21 +00:00
if (priv->hhomogeneous || priv->vhomogeneous || priv->visible_child == child_info)
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
gtk_widget_queue_resize (GTK_WIDGET (stack));
}
static void
stack: Provide a selection model Make GtkStack expose a selection model for its pages. The model can be used to track changes to the pages, and to change what child is visible.
2019-02-10 23:22:54 +00:00
stack_remove (GtkStack *stack,
GtkWidget *child,
gboolean in_dispose)
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
{
stack: Use new private model, remove priv pointer
2013-07-02 11:43:20 +00:00
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
GtkStackPage *child_info;
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
gboolean was_visible;
child_info = find_child_info_for_widget (stack, child);
if (child_info == NULL)
return;
priv->children = g_list_remove (priv->children, child_info);
stack: Provide a selection model Make GtkStack expose a selection model for its pages. The model can be used to track changes to the pages, and to change what child is visible.
2019-02-10 23:22:54 +00:00
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
g_signal_handlers_disconnect_by_func (child,
stack_child_visibility_notify_cb,
stack);
was_visible = gtk_widget_get_visible (child);
stack: Don't leak a reference The page holds a reference to the widget, so can't just clear this pointer.
2019-02-13 13:42:58 +00:00
g_clear_object (&child_info->widget);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
if (priv->visible_child == child_info)
stack: Provide a selection model Make GtkStack expose a selection model for its pages. The model can be used to track changes to the pages, and to change what child is visible.
2019-02-10 23:22:54 +00:00
{
if (in_dispose)
priv->visible_child = NULL;
else
set_visible_child (stack, NULL, priv->transition_type, priv->transition_duration);
}
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
if (priv->last_visible_child == child_info)
priv->last_visible_child = NULL;
gtk_widget_unparent (child);
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
g_object_unref (child_info);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
stack: Provide a selection model Make GtkStack expose a selection model for its pages. The model can be used to track changes to the pages, and to change what child is visible.
2019-02-10 23:22:54 +00:00
if (!in_dispose &&
(priv->hhomogeneous || priv->vhomogeneous) &&
was_visible)
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
gtk_widget_queue_resize (GTK_WIDGET (stack));
}
stack: Provide a selection model Make GtkStack expose a selection model for its pages. The model can be used to track changes to the pages, and to change what child is visible.
2019-02-10 23:22:54 +00:00
static void
gtk_stack_remove (GtkContainer *container,
GtkWidget *child)
{
GtkStackPrivate *priv = gtk_stack_get_instance_private (GTK_STACK (container));
GList *l;
guint position;
for (l = priv->children, position = 0; l; l = l->next, position++)
{
GtkStackPage *page = l->data;
if (page->widget == child)
break;
}
stack_remove (GTK_STACK (container), child, FALSE);
if (priv->pages)
g_list_model_items_changed (G_LIST_MODEL (priv->pages), position, 1, 0);
}
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
/**
* gtk_stack_get_page:
* @stack: a #GtkStack
* @child: a child of @stack
*
* Returns the #GtkStackPage object for @child.
*
* Returns: (transfer none): the #GtkStackPage for @child
*/
GtkStackPage *
gtk_stack_get_page (GtkStack *stack,
GtkWidget *child)
{
return find_child_info_for_widget (stack, child);
}
GtkStack: add gtk_stack_get_child_by_name() This new method allows getting a widget from a GtkStack when we know its name, and will also return NULL if there is no widget going by that name. Usage example would be to check if a child with a given name exists before calling gtk_stack_set_visible_child_name(). https://bugzilla.gnome.org/show_bug.cgi?id=722588
2014-01-20 08:32:37 +00:00
/**
* gtk_stack_get_child_by_name:
* @stack: a #GtkStack
* @name: the name of the child to find
*
* Finds the child of the #GtkStack with the name given as
* the argument. Returns %NULL if there is no child with this
* name.
*
GtkStack: Add some missing nullable annotations
2015-11-24 08:44:08 +00:00
* Returns: (transfer none) (nullable): the requested child of the #GtkStack
GtkStack: add gtk_stack_get_child_by_name() This new method allows getting a widget from a GtkStack when we know its name, and will also return NULL if there is no widget going by that name. Usage example would be to check if a child with a given name exists before calling gtk_stack_set_visible_child_name(). https://bugzilla.gnome.org/show_bug.cgi?id=722588
2014-01-20 08:32:37 +00:00
*/
GtkWidget *
gtk_stack_get_child_by_name (GtkStack *stack,
const gchar *name)
{
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
GtkStackPage *info;
GtkStack: add gtk_stack_get_child_by_name() This new method allows getting a widget from a GtkStack when we know its name, and will also return NULL if there is no widget going by that name. Usage example would be to check if a child with a given name exists before calling gtk_stack_set_visible_child_name(). https://bugzilla.gnome.org/show_bug.cgi?id=722588
2014-01-20 08:32:37 +00:00
GList *l;
g_return_val_if_fail (GTK_IS_STACK (stack), NULL);
g_return_val_if_fail (name != NULL, NULL);
for (l = priv->children; l != NULL; l = l->next)
{
info = l->data;
if (info->name && strcmp (info->name, name) == 0)
return info->widget;
}
return NULL;
}
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
/**
* gtk_stack_page_get_child:
* @page: a #GtkStackPage
*
* Returns the stack child to which @page belongs.
*
* Returns: (transfer none): the child to which @page belongs
*/
GtkWidget *
gtk_stack_page_get_child (GtkStackPage *page)
{
return page->widget;
}
GtkStack: split homogeneous Split homogeneous into separate hhomogeneous and vhomogeneous properties. vhomogeneous is what we want for popover menus.
2014-10-26 18:59:21 +00:00
/**
* gtk_stack_set_hhomogeneous:
* @stack: a #GtkStack
* @hhomogeneous: %TRUE to make @stack horizontally homogeneous
*
* Sets the #GtkStack to be horizontally homogeneous or not.
* If it is homogeneous, the #GtkStack will request the same
* width for all its children. If it isn't, the stack
* may change width when a different child becomes visible.
*/
void
gtk_stack_set_hhomogeneous (GtkStack *stack,
gboolean hhomogeneous)
{
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
g_return_if_fail (GTK_IS_STACK (stack));
hhomogeneous = !!hhomogeneous;
if (priv->hhomogeneous == hhomogeneous)
return;
GtkStack: Keep the last_visible_child around during transitions We need it later.
2015-05-24 19:15:44 +00:00
GtkStack: split homogeneous Split homogeneous into separate hhomogeneous and vhomogeneous properties. vhomogeneous is what we want for popover menus.
2014-10-26 18:59:21 +00:00
priv->hhomogeneous = hhomogeneous;
if (gtk_widget_get_visible (GTK_WIDGET(stack)))
gtk_widget_queue_resize (GTK_WIDGET (stack));
g_object_notify_by_pspec (G_OBJECT (stack), stack_props[PROP_HHOMOGENEOUS]);
}
/**
* gtk_stack_get_hhomogeneous:
* @stack: a #GtkStack
*
* Gets whether @stack is horizontally homogeneous.
* See gtk_stack_set_hhomogeneous().
*
* Returns: whether @stack is horizontally homogeneous.
*/
gboolean
gtk_stack_get_hhomogeneous (GtkStack *stack)
{
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
g_return_val_if_fail (GTK_IS_STACK (stack), FALSE);
return priv->hhomogeneous;
}
/**
* gtk_stack_set_vhomogeneous:
* @stack: a #GtkStack
* @vhomogeneous: %TRUE to make @stack vertically homogeneous
*
* Sets the #GtkStack to be vertically homogeneous or not.
* If it is homogeneous, the #GtkStack will request the same
* height for all its children. If it isn't, the stack
* may change height when a different child becomes visible.
*/
void
gtk_stack_set_vhomogeneous (GtkStack *stack,
gboolean vhomogeneous)
{
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
g_return_if_fail (GTK_IS_STACK (stack));
vhomogeneous = !!vhomogeneous;
if (priv->vhomogeneous == vhomogeneous)
return;
GtkStack: Keep the last_visible_child around during transitions We need it later.
2015-05-24 19:15:44 +00:00
GtkStack: split homogeneous Split homogeneous into separate hhomogeneous and vhomogeneous properties. vhomogeneous is what we want for popover menus.
2014-10-26 18:59:21 +00:00
priv->vhomogeneous = vhomogeneous;
if (gtk_widget_get_visible (GTK_WIDGET(stack)))
gtk_widget_queue_resize (GTK_WIDGET (stack));
g_object_notify_by_pspec (G_OBJECT (stack), stack_props[PROP_VHOMOGENEOUS]);
}
/**
* gtk_stack_get_vhomogeneous:
* @stack: a #GtkStack
*
* Gets whether @stack is vertically homogeneous.
* See gtk_stack_set_vhomogeneous().
*
* Returns: whether @stack is vertically homogeneous.
*/
gboolean
gtk_stack_get_vhomogeneous (GtkStack *stack)
{
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
g_return_val_if_fail (GTK_IS_STACK (stack), FALSE);
return priv->vhomogeneous;
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
}
Add docs for GtkStack
2013-04-21 14:14:46 +00:00
/**
* gtk_stack_get_transition_duration:
* @stack: a #GtkStack
*
Typo fix in GtkStack docs
2013-04-22 14:24:20 +00:00
* Returns the amount of time (in milliseconds) that
Add docs for GtkStack
2013-04-21 14:14:46 +00:00
* transitions between pages in @stack will take.
*
* Returns: the transition duration
*/
Make transition-duration unsigned The code doesn't deal with negative durations, so better don't allow them.
2013-04-22 01:31:29 +00:00
guint
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
gtk_stack_get_transition_duration (GtkStack *stack)
{
stack: Use new private model, remove priv pointer
2013-07-02 11:43:20 +00:00
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
g_return_val_if_fail (GTK_IS_STACK (stack), 0);
stack: Use new private model, remove priv pointer
2013-07-02 11:43:20 +00:00
return priv->transition_duration;
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
}
Add docs for GtkStack
2013-04-21 14:14:46 +00:00
/**
* gtk_stack_set_transition_duration:
* @stack: a #GtkStack
GtkStack: shorten a few parameter names Looks better in the docs.
2013-04-22 03:13:16 +00:00
* @duration: the new duration, in milliseconds
Add docs for GtkStack
2013-04-21 14:14:46 +00:00
*
* Sets the duration that transitions between pages in @stack
* will take.
*/
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
void
gtk_stack_set_transition_duration (GtkStack *stack,
GtkStack: shorten a few parameter names Looks better in the docs.
2013-04-22 03:13:16 +00:00
guint duration)
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
{
stack: Use new private model, remove priv pointer
2013-07-02 11:43:20 +00:00
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
g_return_if_fail (GTK_IS_STACK (stack));
GtkStack: Avoid a few redundant notify emissions A few of the property setters were missing the standard checks.
2014-06-07 03:35:53 +00:00
if (priv->transition_duration == duration)
return;
stack: Use new private model, remove priv pointer
2013-07-02 11:43:20 +00:00
priv->transition_duration = duration;
stack: Use g_object_notify_by_pspec() https://bugzilla.gnome.org/show_bug.cgi?id=711611
2013-11-05 10:18:37 +00:00
g_object_notify_by_pspec (G_OBJECT (stack),
stack_props[PROP_TRANSITION_DURATION]);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
}
Add docs for GtkStack
2013-04-21 14:14:46 +00:00
/**
* gtk_stack_get_transition_type:
* @stack: a #GtkStack
*
* Gets the type of animation that will be used
* for transitions between pages in @stack.
*
docs: use Returns: consistently Instead of Return value:
2014-02-19 23:49:43 +00:00
* Returns: the current transition type of @stack
Add docs for GtkStack
2013-04-21 14:14:46 +00:00
*/
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
GtkStackTransitionType
gtk_stack_get_transition_type (GtkStack *stack)
{
stack: Use new private model, remove priv pointer
2013-07-02 11:43:20 +00:00
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
g_return_val_if_fail (GTK_IS_STACK (stack), GTK_STACK_TRANSITION_TYPE_NONE);
stack: Use new private model, remove priv pointer
2013-07-02 11:43:20 +00:00
return priv->transition_type;
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
}
Add docs for GtkStack
2013-04-21 14:14:46 +00:00
/**
* gtk_stack_set_transition_type:
* @stack: a #GtkStack
GtkStack: shorten a few parameter names Looks better in the docs.
2013-04-22 03:13:16 +00:00
* @transition: the new transition type
Add docs for GtkStack
2013-04-21 14:14:46 +00:00
*
* Sets the type of animation that will be used for
* transitions between pages in @stack. Available
* types include various kinds of fades and slides.
*
* The transition type can be changed without problems
* at runtime, so it is possible to change the animation
* based on the page that is about to become current.
*/
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
void
Add docs for GtkStack
2013-04-21 14:14:46 +00:00
gtk_stack_set_transition_type (GtkStack *stack,
GtkStack: shorten a few parameter names Looks better in the docs.
2013-04-22 03:13:16 +00:00
GtkStackTransitionType transition)
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
{
stack: Use new private model, remove priv pointer
2013-07-02 11:43:20 +00:00
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
g_return_if_fail (GTK_IS_STACK (stack));
GtkStack: Avoid a few redundant notify emissions A few of the property setters were missing the standard checks.
2014-06-07 03:35:53 +00:00
if (priv->transition_type == transition)
return;
stack: Use new private model, remove priv pointer
2013-07-02 11:43:20 +00:00
priv->transition_type = transition;
stack: Use g_object_notify_by_pspec() https://bugzilla.gnome.org/show_bug.cgi?id=711611
2013-11-05 10:18:37 +00:00
g_object_notify_by_pspec (G_OBJECT (stack),
stack_props[PROP_TRANSITION_TYPE]);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
}
GtkStack: add transition-running property This is useful to know when the transition is done we can remove the child from the stack. https://bugzilla.gnome.org/show_bug.cgi?id=711494
2013-11-11 21:38:35 +00:00
/**
* gtk_stack_get_transition_running:
* @stack: a #GtkStack
*
* Returns whether the @stack is currently in a transition from one page to
* another.
*
docs: use Returns: consistently Instead of Return value:
2014-02-19 23:49:43 +00:00
* Returns: %TRUE if the transition is currently running, %FALSE otherwise.
GtkStack: add transition-running property This is useful to know when the transition is done we can remove the child from the stack. https://bugzilla.gnome.org/show_bug.cgi?id=711494
2013-11-11 21:38:35 +00:00
*/
gboolean
gtk_stack_get_transition_running (GtkStack *stack)
{
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
g_return_val_if_fail (GTK_IS_STACK (stack), FALSE);
return (priv->tick_id != 0);
}
GtkStack: Add interpolate-size property And use it to determine whether we should actually interpolate between stack sizes or not.
2015-07-19 15:39:41 +00:00
/**
* gtk_stack_set_interpolate_size:
* @stack: A #GtkStack
Fix a doc comment typo
2015-08-09 21:31:36 +00:00
* @interpolate_size: the new value
GtkStack: Add interpolate-size property And use it to determine whether we should actually interpolate between stack sizes or not.
2015-07-19 15:39:41 +00:00
*
* Sets whether or not @stack will interpolate its size when
Various documentation fixes Always have Since: annotations at the very bottom, use the correct ClassName::signal-name/ClassName:property-name syntax, fix a few typos in type names, wrong function names, non-existing type names, etc.
2016-02-08 21:49:01 +00:00
* changing the visible child. If the #GtkStack:interpolate-size
Complete docs for gtk_stack_get_interpolate_size
2015-12-15 14:48:16 +00:00
* property is set to %TRUE, @stack will interpolate its size between
* the current one and the one it'll take after changing the
* visible child, according to the set transition duration.
GtkStack: Add interpolate-size property And use it to determine whether we should actually interpolate between stack sizes or not.
2015-07-19 15:39:41 +00:00
*/
void
gtk_stack_set_interpolate_size (GtkStack *stack,
gboolean interpolate_size)
{
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
g_return_if_fail (GTK_IS_STACK (stack));
interpolate_size = !!interpolate_size;
if (priv->interpolate_size == interpolate_size)
return;
priv->interpolate_size = interpolate_size;
g_object_notify_by_pspec (G_OBJECT (stack),
stack_props[PROP_INTERPOLATE_SIZE]);
}
/**
* gtk_stack_get_interpolate_size:
* @stack: A #GtkStack
*
Complete docs for gtk_stack_get_interpolate_size
2015-12-15 14:48:16 +00:00
* Returns wether the #GtkStack is set up to interpolate between
Fixed typo childen->children
2016-01-19 11:52:58 +00:00
* the sizes of children on page switch.
Complete docs for gtk_stack_get_interpolate_size
2015-12-15 14:48:16 +00:00
*
* Returns: %TRUE if child sizes are interpolated
GtkStack: Add interpolate-size property And use it to determine whether we should actually interpolate between stack sizes or not.
2015-07-19 15:39:41 +00:00
*/
gboolean
gtk_stack_get_interpolate_size (GtkStack *stack)
{
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
Fix return value error in gtk_stack_get_interpolate_size
2015-07-20 13:55:40 +00:00
g_return_val_if_fail (GTK_IS_STACK (stack), FALSE);
GtkStack: Add interpolate-size property And use it to determine whether we should actually interpolate between stack sizes or not.
2015-07-19 15:39:41 +00:00
return priv->interpolate_size;
}
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
/**
* gtk_stack_get_visible_child:
* @stack: a #GtkStack
*
Add docs for GtkStack
2013-04-21 14:14:46 +00:00
* Gets the currently visible child of @stack, or %NULL if
* there are no visible children.
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
*
GtkStack: Add some missing nullable annotations
2015-11-24 08:44:08 +00:00
* Returns: (transfer none) (nullable): the visible child of the #GtkStack
Add docs for GtkStack
2013-04-21 14:14:46 +00:00
*/
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
GtkWidget *
gtk_stack_get_visible_child (GtkStack *stack)
{
stack: Use new private model, remove priv pointer
2013-07-02 11:43:20 +00:00
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
g_return_val_if_fail (GTK_IS_STACK (stack), NULL);
stack: Use new private model, remove priv pointer
2013-07-02 11:43:20 +00:00
return priv->visible_child ? priv->visible_child->widget : NULL;
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
}
Add docs for GtkStack
2013-04-21 14:14:46 +00:00
/**
* gtk_stack_get_visible_child_name:
* @stack: a #GtkStack
*
* Returns the name of the currently visible child of @stack, or
* %NULL if there is no visible child.
*
GtkStack: Add some missing nullable annotations
2015-11-24 08:44:08 +00:00
* Returns: (transfer none) (nullable): the name of the visible child of the #GtkStack
Add docs for GtkStack
2013-04-21 14:14:46 +00:00
*/
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
const gchar *
gtk_stack_get_visible_child_name (GtkStack *stack)
{
stack: Use new private model, remove priv pointer
2013-07-02 11:43:20 +00:00
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
g_return_val_if_fail (GTK_IS_STACK (stack), NULL);
stack: Use new private model, remove priv pointer
2013-07-02 11:43:20 +00:00
if (priv->visible_child)
return priv->visible_child->name;
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
return NULL;
}
Add docs for GtkStack
2013-04-21 14:14:46 +00:00
/**
* gtk_stack_set_visible_child:
* @stack: a #GtkStack
* @child: a child of @stack
*
* Makes @child the visible child of @stack.
*
* If @child is different from the currently
* visible child, the transition between the
* two will be animated with the current
* transition type of @stack.
*
Improve GtkStack documentation As has been pointed out in https://bugzilla.gnome.org/show_bug.cgi?id=725711 it is a little confusing that we have the concept of a visible child and of the child being visible itself.
2014-03-07 03:50:40 +00:00
* Note that the @child widget has to be visible itself
* (see gtk_widget_show()) in order to become the visible
* child of @stack.
Add docs for GtkStack
2013-04-21 14:14:46 +00:00
*/
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
void
gtk_stack_set_visible_child (GtkStack *stack,
GtkWidget *child)
{
stack: Use new private model, remove priv pointer
2013-07-02 11:43:20 +00:00
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
GtkStackPage *child_info;
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
g_return_if_fail (GTK_IS_STACK (stack));
g_return_if_fail (GTK_IS_WIDGET (child));
child_info = find_child_info_for_widget (stack, child);
if (child_info == NULL)
stack: Warn when setting a visible child which is not in the stack https://bugzilla.gnome.org/show_bug.cgi?id=709613
2013-10-07 12:46:16 +00:00
{
g_warning ("Given child of type '%s' not found in GtkStack",
G_OBJECT_TYPE_NAME (child));
return;
}
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
if (gtk_widget_get_visible (child_info->widget))
Add a way to specify transition types on the fly Add a gtk_stack_set_visible_child_full that takes a transition type.
2013-04-21 18:22:35 +00:00
set_visible_child (stack, child_info,
stack: Use new private model, remove priv pointer
2013-07-02 11:43:20 +00:00
priv->transition_type,
priv->transition_duration);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
}
Add docs for GtkStack
2013-04-21 14:14:46 +00:00
/**
* gtk_stack_set_visible_child_name:
* @stack: a #GtkStack
* @name: the name of the child to make visible
*
* Makes the child with the given name visible.
*
* If @child is different from the currently
* visible child, the transition between the
* two will be animated with the current
* transition type of @stack.
*
Improve GtkStack documentation As has been pointed out in https://bugzilla.gnome.org/show_bug.cgi?id=725711 it is a little confusing that we have the concept of a visible child and of the child being visible itself.
2014-03-07 03:50:40 +00:00
* Note that the child widget has to be visible itself
* (see gtk_widget_show()) in order to become the visible
* child of @stack.
Add docs for GtkStack
2013-04-21 14:14:46 +00:00
*/
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
void
gtk_stack_set_visible_child_name (GtkStack *stack,
const gchar *name)
Add a way to specify transition types on the fly Add a gtk_stack_set_visible_child_full that takes a transition type.
2013-04-21 18:22:35 +00:00
{
stack: Use new private model, remove priv pointer
2013-07-02 11:43:20 +00:00
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
stack: protect set_visible_child_name from NULL stack Return with error if gtk_stack_set_visible_child_name is called with NULL parameter (cherry picked from commit 2ee5aee4a9f01cce3dda7dff877070b62c3e2880)
2018-04-19 01:58:57 +00:00
g_return_if_fail (GTK_IS_STACK (stack));
stack: Use new private model, remove priv pointer
2013-07-02 11:43:20 +00:00
gtk_stack_set_visible_child_full (stack, name, priv->transition_type);
Add a way to specify transition types on the fly Add a gtk_stack_set_visible_child_full that takes a transition type.
2013-04-21 18:22:35 +00:00
}
/**
stack: fix a typo in docs
2013-04-22 15:19:54 +00:00
* gtk_stack_set_visible_child_full:
Add a way to specify transition types on the fly Add a gtk_stack_set_visible_child_full that takes a transition type.
2013-04-21 18:22:35 +00:00
* @stack: a #GtkStack
* @name: the name of the child to make visible
GtkStack: shorten a few parameter names Looks better in the docs.
2013-04-22 03:13:16 +00:00
* @transition: the transition type to use
Add a way to specify transition types on the fly Add a gtk_stack_set_visible_child_full that takes a transition type.
2013-04-21 18:22:35 +00:00
*
* Makes the child with the given name visible.
*
Improve GtkStack documentation As has been pointed out in https://bugzilla.gnome.org/show_bug.cgi?id=725711 it is a little confusing that we have the concept of a visible child and of the child being visible itself.
2014-03-07 03:50:40 +00:00
* Note that the child widget has to be visible itself
* (see gtk_widget_show()) in order to become the visible
* child of @stack.
Add a way to specify transition types on the fly Add a gtk_stack_set_visible_child_full that takes a transition type.
2013-04-21 18:22:35 +00:00
*/
void
gtk_stack_set_visible_child_full (GtkStack *stack,
const gchar *name,
GtkStack: shorten a few parameter names Looks better in the docs.
2013-04-22 03:13:16 +00:00
GtkStackTransitionType transition)
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
{
stack: Use new private model, remove priv pointer
2013-07-02 11:43:20 +00:00
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
GtkStackPage *child_info, *info;
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
GList *l;
g_return_if_fail (GTK_IS_STACK (stack));
GtkStack: silently ignore visible-child-name set to NULL This can happen when loading empty stacks in glade.
2014-11-25 05:14:47 +00:00
if (name == NULL)
return;
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
child_info = NULL;
for (l = priv->children; l != NULL; l = l->next)
{
info = l->data;
if (info->name != NULL &&
strcmp (info->name, name) == 0)
{
child_info = info;
break;
}
}
stack: Warn when setting a visible child which is not in the stack https://bugzilla.gnome.org/show_bug.cgi?id=709613
2013-10-07 12:46:16 +00:00
if (child_info == NULL)
{
g_warning ("Child name '%s' not found in GtkStack", name);
return;
}
if (gtk_widget_get_visible (child_info->widget))
GtkStack: shorten a few parameter names Looks better in the docs.
2013-04-22 03:13:16 +00:00
set_visible_child (stack, child_info, transition, priv->transition_duration);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
}
static void
gtk_stack_forall (GtkContainer *container,
GtkCallback callback,
gpointer callback_data)
{
GtkStack *stack = GTK_STACK (container);
stack: Use new private model, remove priv pointer
2013-07-02 11:43:20 +00:00
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
GtkStackPage *child_info;
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
GList *l;
l = priv->children;
while (l)
{
child_info = l->data;
l = l->next;
(* callback) (child_info->widget, callback_data);
}
}
static void
gtk_stack_compute_expand (GtkWidget *widget,
gboolean *hexpand_p,
gboolean *vexpand_p)
{
GtkStack *stack = GTK_STACK (widget);
stack: Use new private model, remove priv pointer
2013-07-02 11:43:20 +00:00
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
gboolean hexpand, vexpand;
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
GtkStackPage *child_info;
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
GtkWidget *child;
GList *l;
hexpand = FALSE;
vexpand = FALSE;
for (l = priv->children; l != NULL; l = l->next)
{
child_info = l->data;
child = child_info->widget;
if (!hexpand &&
gtk_widget_compute_expand (child, GTK_ORIENTATION_HORIZONTAL))
hexpand = TRUE;
if (!vexpand &&
gtk_widget_compute_expand (child, GTK_ORIENTATION_VERTICAL))
vexpand = TRUE;
if (hexpand && vexpand)
break;
}
*hexpand_p = hexpand;
*vexpand_p = vexpand;
}
static void
stack: Implement snapshot() This uses the new push()/pop() mechanism to its fullest extent when implementing transitions. It's fun to inspect the results in the inspector. Crossfades don't work yet, they continue using a Cairo fallback. A side effect of the stack conversion is that widget-factory now uses snapshots for a lot more things.
2016-12-13 08:45:09 +00:00
gtk_stack_snapshot_crossfade (GtkWidget *widget,
GtkSnapshot *snapshot)
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
{
GtkStack *stack = GTK_STACK (widget);
stack: Use new private model, remove priv pointer
2013-07-02 11:43:20 +00:00
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
stack: port to progress tracker
2016-03-01 06:24:39 +00:00
gdouble progress = gtk_progress_tracker_get_progress (&priv->tracker, FALSE);
stack: Implement snapshot() This uses the new push()/pop() mechanism to its fullest extent when implementing transitions. It's fun to inspect the results in the inspector. Crossfades don't work yet, they continue using a Cairo fallback. A side effect of the stack conversion is that widget-factory now uses snapshots for a lot more things.
2016-12-13 08:45:09 +00:00
snapshot: Redo debug messages Instead of every snapshot function having debug messages, have an explicit gtk_snapshot_push_debug() function that appends a debug node.
2018-04-24 01:17:23 +00:00
gtk_snapshot_push_cross_fade (snapshot, progress);
stack: Use normal opacity groups rather than weird ones in GtkWidget Since we now do all drawing propagation on the cairo_t (rather than exposing multiple independent times on the GdkWindows) we no longer need the opacity 0.999 hack.
2013-07-04 11:30:51 +00:00
stack: Implement snapshot() This uses the new push()/pop() mechanism to its fullest extent when implementing transitions. It's fun to inspect the results in the inspector. Crossfades don't work yet, they continue using a Cairo fallback. A side effect of the stack conversion is that widget-factory now uses snapshots for a lot more things.
2016-12-13 08:45:09 +00:00
if (priv->last_visible_node)
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
{
stack: Use new snapshot transforms
2019-02-21 04:34:12 +00:00
gtk_snapshot_save (snapshot);
gtk_snapshot_translate (snapshot, &GRAPHENE_POINT_INIT (
priv->last_visible_surface_allocation.x,
priv->last_visible_surface_allocation.y));
gsk: Add cross-fade node And implement stack crossfades with it.
2016-12-17 06:44:10 +00:00
gtk_snapshot_append_node (snapshot, priv->last_visible_node);
stack: Use new snapshot transforms
2019-02-21 04:34:12 +00:00
gtk_snapshot_restore (snapshot);
gsk: Add cross-fade node And implement stack crossfades with it.
2016-12-17 06:44:10 +00:00
}
snapshot: Redo pop() API gtk_snapshot_pop() => removed gtk_snapshot_pop_and_append() => gtk_snapshot_pop() So now there is no way to get a rendernode out of the snapshotting API until you gtk_snapshot_finish().
2017-01-12 23:39:59 +00:00
gtk_snapshot_pop (snapshot);
gsk: Add cross-fade node And implement stack crossfades with it.
2016-12-17 06:44:10 +00:00
Add gtk_snapshot_push_cross_fade() ... and use it. The function is a bit awkward because it requires 2 calls to gtk_snapshot_pop(), but once you accept that, it's very convenient to use, as can be seen by the 2 implementations.
2017-01-12 21:00:38 +00:00
gtk_widget_snapshot_child (widget,
priv->visible_child->widget,
snapshot);
snapshot: Redo pop() API gtk_snapshot_pop() => removed gtk_snapshot_pop_and_append() => gtk_snapshot_pop() So now there is no way to get a rendernode out of the snapshotting API until you gtk_snapshot_finish().
2017-01-12 23:39:59 +00:00
gtk_snapshot_pop (snapshot);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
}
GtkStack: Add more transition types This adds new 'over' and 'under' transitions which work by moving the new page over the previous one, or moving the previous page off to reveal the new one. We also add an over/under combination that is going to be used in GtkAboutDialog. https://bugzilla.gnome.org/show_bug.cgi?id=707187
2013-08-31 16:00:47 +00:00
static void
stack: Implement snapshot() This uses the new push()/pop() mechanism to its fullest extent when implementing transitions. It's fun to inspect the results in the inspector. Crossfades don't work yet, they continue using a Cairo fallback. A side effect of the stack conversion is that widget-factory now uses snapshots for a lot more things.
2016-12-13 08:45:09 +00:00
gtk_stack_snapshot_under (GtkWidget *widget,
GtkSnapshot *snapshot)
GtkStack: Add more transition types This adds new 'over' and 'under' transitions which work by moving the new page over the previous one, or moving the previous page off to reveal the new one. We also add an over/under combination that is going to be used in GtkAboutDialog. https://bugzilla.gnome.org/show_bug.cgi?id=707187
2013-08-31 16:00:47 +00:00
{
GtkStack *stack = GTK_STACK (widget);
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
Fix a few allocation coordinates & sizes
2017-06-28 06:19:35 +00:00
int widget_width, widget_height;
GtkStack: Add more transition types This adds new 'over' and 'under' transitions which work by moving the new page over the previous one, or moving the previous page off to reveal the new one. We also add an over/under combination that is going to be used in GtkAboutDialog. https://bugzilla.gnome.org/show_bug.cgi?id=707187
2013-08-31 16:00:47 +00:00
gint x, y, width, height, pos_x, pos_y;
Fix a few allocation coordinates & sizes
2017-06-28 06:19:35 +00:00
GtkStack: Add more transition types This adds new 'over' and 'under' transitions which work by moving the new page over the previous one, or moving the previous page off to reveal the new one. We also add an over/under combination that is going to be used in GtkAboutDialog. https://bugzilla.gnome.org/show_bug.cgi?id=707187
2013-08-31 16:00:47 +00:00
x = y = 0;
Remove all gtk_widget_get_content_size usages And remove the function itself. Make everything use gtk_widget_get_width and gtk_widget_get_height instead.
2017-12-06 06:56:12 +00:00
width = widget_width = gtk_widget_get_width (widget);
height = widget_height = gtk_widget_get_height (widget);
stack: Fix under transitions make sure we initialize both width and height with proper values.
2017-07-01 17:15:01 +00:00
GtkStack: Add more transition types This adds new 'over' and 'under' transitions which work by moving the new page over the previous one, or moving the previous page off to reveal the new one. We also add an over/under combination that is going to be used in GtkAboutDialog. https://bugzilla.gnome.org/show_bug.cgi?id=707187
2013-08-31 16:00:47 +00:00
pos_x = pos_y = 0;
build: Enable -Wswitch-enum and -Wswitch-default This patch makes that work using 1 of 2 options: 1. Add all missing enums to the switch statement or 2. Cast the switch argument to a uint to avoid having to do that (mostly for GdkEventType). I even found a bug while doing that: clearing a GtkImage with a surface did not notify thae surface property. The reason for enabling this flag even though it is tedious at times is that it is very useful when adding values to an enum, because it makes GTK immediately warn about all the switch statements where this enum is relevant. And I expect changes to enums to be frequent during the GTK4 development cycle.
2017-10-06 19:19:42 +00:00
switch ((guint) priv->active_transition_type)
GtkStack: Add more transition types This adds new 'over' and 'under' transitions which work by moving the new page over the previous one, or moving the previous page off to reveal the new one. We also add an over/under combination that is going to be used in GtkAboutDialog. https://bugzilla.gnome.org/show_bug.cgi?id=707187
2013-08-31 16:00:47 +00:00
{
case GTK_STACK_TRANSITION_TYPE_UNDER_DOWN:
y = 0;
Fix a few allocation coordinates & sizes
2017-06-28 06:19:35 +00:00
height = widget_height * (gtk_progress_tracker_get_ease_out_cubic (&priv->tracker, FALSE));
GtkStack: Add more transition types This adds new 'over' and 'under' transitions which work by moving the new page over the previous one, or moving the previous page off to reveal the new one. We also add an over/under combination that is going to be used in GtkAboutDialog. https://bugzilla.gnome.org/show_bug.cgi?id=707187
2013-08-31 16:00:47 +00:00
pos_y = height;
break;
case GTK_STACK_TRANSITION_TYPE_UNDER_UP:
Fix a few allocation coordinates & sizes
2017-06-28 06:19:35 +00:00
y = widget_height * (1 - gtk_progress_tracker_get_ease_out_cubic (&priv->tracker, FALSE));
height = widget_height - y;
pos_y = y - widget_height;
GtkStack: Add more transition types This adds new 'over' and 'under' transitions which work by moving the new page over the previous one, or moving the previous page off to reveal the new one. We also add an over/under combination that is going to be used in GtkAboutDialog. https://bugzilla.gnome.org/show_bug.cgi?id=707187
2013-08-31 16:00:47 +00:00
break;
case GTK_STACK_TRANSITION_TYPE_UNDER_LEFT:
Fix a few allocation coordinates & sizes
2017-06-28 06:19:35 +00:00
x = widget_width * (1 - gtk_progress_tracker_get_ease_out_cubic (&priv->tracker, FALSE));
width = widget_width - x;
pos_x = x - widget_width;
GtkStack: Add more transition types This adds new 'over' and 'under' transitions which work by moving the new page over the previous one, or moving the previous page off to reveal the new one. We also add an over/under combination that is going to be used in GtkAboutDialog. https://bugzilla.gnome.org/show_bug.cgi?id=707187
2013-08-31 16:00:47 +00:00
break;
case GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT:
x = 0;
Fix a few allocation coordinates & sizes
2017-06-28 06:19:35 +00:00
width = widget_width * (gtk_progress_tracker_get_ease_out_cubic (&priv->tracker, FALSE));
GtkStack: Add more transition types This adds new 'over' and 'under' transitions which work by moving the new page over the previous one, or moving the previous page off to reveal the new one. We also add an over/under combination that is going to be used in GtkAboutDialog. https://bugzilla.gnome.org/show_bug.cgi?id=707187
2013-08-31 16:00:47 +00:00
pos_x = width;
break;
default:
g_assert_not_reached ();
}
snapshot: Redo debug messages Instead of every snapshot function having debug messages, have an explicit gtk_snapshot_push_debug() function that appends a debug node.
2018-04-24 01:17:23 +00:00
gtk_snapshot_push_clip (snapshot, &GRAPHENE_RECT_INIT(x, y, width, height));
GtkStack: Add more transition types This adds new 'over' and 'under' transitions which work by moving the new page over the previous one, or moving the previous page off to reveal the new one. We also add an over/under combination that is going to be used in GtkAboutDialog. https://bugzilla.gnome.org/show_bug.cgi?id=707187
2013-08-31 16:00:47 +00:00
Remove gtk_container_snapshot_child Replace it with the already existing gtk_widget_snapshot_child.
2017-01-07 16:02:20 +00:00
gtk_widget_snapshot_child (widget,
priv->visible_child->widget,
snapshot);
GtkStack: Add more transition types This adds new 'over' and 'under' transitions which work by moving the new page over the previous one, or moving the previous page off to reveal the new one. We also add an over/under combination that is going to be used in GtkAboutDialog. https://bugzilla.gnome.org/show_bug.cgi?id=707187
2013-08-31 16:00:47 +00:00
snapshot: Redo pop() API gtk_snapshot_pop() => removed gtk_snapshot_pop_and_append() => gtk_snapshot_pop() So now there is no way to get a rendernode out of the snapshotting API until you gtk_snapshot_finish().
2017-01-12 23:39:59 +00:00
gtk_snapshot_pop (snapshot);
GtkStack: Add more transition types This adds new 'over' and 'under' transitions which work by moving the new page over the previous one, or moving the previous page off to reveal the new one. We also add an over/under combination that is going to be used in GtkAboutDialog. https://bugzilla.gnome.org/show_bug.cgi?id=707187
2013-08-31 16:00:47 +00:00
stack: Implement snapshot() This uses the new push()/pop() mechanism to its fullest extent when implementing transitions. It's fun to inspect the results in the inspector. Crossfades don't work yet, they continue using a Cairo fallback. A side effect of the stack conversion is that widget-factory now uses snapshots for a lot more things.
2016-12-13 08:45:09 +00:00
if (priv->last_visible_node)
GtkStack: Add more transition types This adds new 'over' and 'under' transitions which work by moving the new page over the previous one, or moving the previous page off to reveal the new one. We also add an over/under combination that is going to be used in GtkAboutDialog. https://bugzilla.gnome.org/show_bug.cgi?id=707187
2013-08-31 16:00:47 +00:00
{
stack: Use new snapshot transforms
2019-02-21 04:34:12 +00:00
gtk_snapshot_save (snapshot);
gtk_snapshot_translate (snapshot, &GRAPHENE_POINT_INIT (pos_x, pos_y));
stack: Implement snapshot() This uses the new push()/pop() mechanism to its fullest extent when implementing transitions. It's fun to inspect the results in the inspector. Crossfades don't work yet, they continue using a Cairo fallback. A side effect of the stack conversion is that widget-factory now uses snapshots for a lot more things.
2016-12-13 08:45:09 +00:00
gtk_snapshot_append_node (snapshot, priv->last_visible_node);
stack: Use new snapshot transforms
2019-02-21 04:34:12 +00:00
gtk_snapshot_restore (snapshot);
GtkStack: Add more transition types This adds new 'over' and 'under' transitions which work by moving the new page over the previous one, or moving the previous page off to reveal the new one. We also add an over/under combination that is going to be used in GtkAboutDialog. https://bugzilla.gnome.org/show_bug.cgi?id=707187
2013-08-31 16:00:47 +00:00
}
}
stack: Add a cube spin transition Add a transition to GtkStack that pretends pages are the sides or a cube, and switch them by rotating the cube. Use this transition in widget-factory.
2019-03-05 19:44:45 +00:00
static void
gtk_stack_snapshot_cube (GtkWidget *widget,
GtkSnapshot *snapshot)
{
GtkStack *stack = GTK_STACK (widget);
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
double progress = gtk_progress_tracker_get_progress (&priv->tracker, FALSE);
if (priv->active_transition_type == GTK_STACK_TRANSITION_TYPE_ROTATE_RIGHT)
progress = 1 - progress;
if (priv->last_visible_node && progress > 0.5)
{
gtk_snapshot_save (snapshot);
gtk_snapshot_translate_3d (snapshot, &GRAPHENE_POINT3D_INIT (
gtk_widget_get_width (widget) / 2.f,
gtk_widget_get_height (widget) / 2.f,
0));
gtk_snapshot_perspective (snapshot, 2 * gtk_widget_get_width (widget) / 1.f);
gtk_snapshot_translate_3d (snapshot, &GRAPHENE_POINT3D_INIT (
0, 0,
- gtk_widget_get_width (widget) / 2.f));
gtk_snapshot_rotate_3d (snapshot, -90 * progress, graphene_vec3_y_axis());
gtk_snapshot_translate_3d (snapshot, &GRAPHENE_POINT3D_INIT (
- gtk_widget_get_width (widget) / 2.f,
- gtk_widget_get_height (widget) / 2.f,
gtk_widget_get_width (widget) / 2.f));
gtk_snapshot_translate (snapshot, &GRAPHENE_POINT_INIT (
priv->last_visible_surface_allocation.x,
priv->last_visible_surface_allocation.y));
if (priv->active_transition_type == GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT)
gtk_snapshot_append_node (snapshot, priv->last_visible_node);
else
gtk_widget_snapshot_child (widget, priv->visible_child->widget, snapshot);
gtk_snapshot_restore (snapshot);
}
gtk_snapshot_save (snapshot);
gtk_snapshot_translate_3d (snapshot, &GRAPHENE_POINT3D_INIT (
gtk_widget_get_width (widget) / 2.f,
gtk_widget_get_height (widget) / 2.f,
0));
gtk_snapshot_perspective (snapshot, 2 * gtk_widget_get_width (widget) / 1.f);
gtk_snapshot_translate_3d (snapshot, &GRAPHENE_POINT3D_INIT (
0, 0,
- gtk_widget_get_width (widget) / 2.f));
gtk_snapshot_rotate_3d (snapshot, 90 * (1.0 - progress), graphene_vec3_y_axis());
gtk_snapshot_translate_3d (snapshot, &GRAPHENE_POINT3D_INIT (
- gtk_widget_get_width (widget) / 2.f,
- gtk_widget_get_height (widget) / 2.f,
gtk_widget_get_width (widget) / 2.f));
gtk_snapshot_translate (snapshot, &GRAPHENE_POINT_INIT (
priv->last_visible_surface_allocation.x,
priv->last_visible_surface_allocation.y));
if (priv->active_transition_type == GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT)
gtk_widget_snapshot_child (widget, priv->visible_child->widget, snapshot);
else
gtk_snapshot_append_node (snapshot, priv->last_visible_node);
gtk_snapshot_restore (snapshot);
if (priv->last_visible_node && progress <= 0.5)
{
gtk_snapshot_save (snapshot);
gtk_snapshot_translate_3d (snapshot, &GRAPHENE_POINT3D_INIT (
gtk_widget_get_width (widget) / 2.f,
gtk_widget_get_height (widget) / 2.f,
0));
gtk_snapshot_perspective (snapshot, 2 * gtk_widget_get_width (widget) / 1.f);
gtk_snapshot_translate_3d (snapshot, &GRAPHENE_POINT3D_INIT (
0, 0,
- gtk_widget_get_width (widget) / 2.f));
gtk_snapshot_rotate_3d (snapshot, -90 * progress, graphene_vec3_y_axis());
gtk_snapshot_translate_3d (snapshot, &GRAPHENE_POINT3D_INIT (
- gtk_widget_get_width (widget) / 2.f,
- gtk_widget_get_height (widget) / 2.f,
gtk_widget_get_width (widget) / 2.f));
gtk_snapshot_translate (snapshot, &GRAPHENE_POINT_INIT (
priv->last_visible_surface_allocation.x,
priv->last_visible_surface_allocation.y));
if (priv->active_transition_type == GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT)
gtk_snapshot_append_node (snapshot, priv->last_visible_node);
else
gtk_widget_snapshot_child (widget, priv->visible_child->widget, snapshot);
gtk_snapshot_restore (snapshot);
}
}
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
static void
stack: Implement snapshot() This uses the new push()/pop() mechanism to its fullest extent when implementing transitions. It's fun to inspect the results in the inspector. Crossfades don't work yet, they continue using a Cairo fallback. A side effect of the stack conversion is that widget-factory now uses snapshots for a lot more things.
2016-12-13 08:45:09 +00:00
gtk_stack_snapshot_slide (GtkWidget *widget,
GtkSnapshot *snapshot)
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
{
GtkStack *stack = GTK_STACK (widget);
stack: Use new private model, remove priv pointer
2013-07-02 11:43:20 +00:00
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
stack: Implement snapshot() This uses the new push()/pop() mechanism to its fullest extent when implementing transitions. It's fun to inspect the results in the inspector. Crossfades don't work yet, they continue using a Cairo fallback. A side effect of the stack conversion is that widget-factory now uses snapshots for a lot more things.
2016-12-13 08:45:09 +00:00
if (priv->last_visible_node)
stack: Scope some variables so that the code is clearer ... that the allocation magic here is for the transition of the last visible child that's sliding out.
2013-11-01 05:49:29 +00:00
{
int x, y;
Fix a few allocation coordinates & sizes
2017-06-28 06:19:35 +00:00
int width, height;
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
Remove all gtk_widget_get_content_size usages And remove the function itself. Make everything use gtk_widget_get_width and gtk_widget_get_height instead.
2017-12-06 06:56:12 +00:00
width = gtk_widget_get_width (widget);
height = gtk_widget_get_height (widget);
GtkStack: add vertical slide transitions We allow transitions that slide up or down.
2013-04-22 00:17:40 +00:00
stack: Remove bin_window
2017-06-04 15:30:40 +00:00
x = get_bin_window_x (stack);
y = get_bin_window_y (stack);
GtkStack: add vertical slide transitions We allow transitions that slide up or down.
2013-04-22 00:17:40 +00:00
build: Enable -Wswitch-enum and -Wswitch-default This patch makes that work using 1 of 2 options: 1. Add all missing enums to the switch statement or 2. Cast the switch argument to a uint to avoid having to do that (mostly for GdkEventType). I even found a bug while doing that: clearing a GtkImage with a surface did not notify thae surface property. The reason for enabling this flag even though it is tedious at times is that it is very useful when adding values to an enum, because it makes GTK immediately warn about all the switch statements where this enum is relevant. And I expect changes to enums to be frequent during the GTK4 development cycle.
2017-10-06 19:19:42 +00:00
switch ((guint) priv->active_transition_type)
stack: Scope some variables so that the code is clearer ... that the allocation magic here is for the transition of the last visible child that's sliding out.
2013-11-01 05:49:29 +00:00
{
case GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT:
Fix a few allocation coordinates & sizes
2017-06-28 06:19:35 +00:00
x -= width;
stack: Scope some variables so that the code is clearer ... that the allocation magic here is for the transition of the last visible child that's sliding out.
2013-11-01 05:49:29 +00:00
break;
case GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT:
Fix a few allocation coordinates & sizes
2017-06-28 06:19:35 +00:00
x += width;
stack: Scope some variables so that the code is clearer ... that the allocation magic here is for the transition of the last visible child that's sliding out.
2013-11-01 05:49:29 +00:00
break;
case GTK_STACK_TRANSITION_TYPE_SLIDE_UP:
Fix a few allocation coordinates & sizes
2017-06-28 06:19:35 +00:00
y -= height;
stack: Scope some variables so that the code is clearer ... that the allocation magic here is for the transition of the last visible child that's sliding out.
2013-11-01 05:49:29 +00:00
break;
case GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN:
Fix a few allocation coordinates & sizes
2017-06-28 06:19:35 +00:00
y += height;
stack: Scope some variables so that the code is clearer ... that the allocation magic here is for the transition of the last visible child that's sliding out.
2013-11-01 05:49:29 +00:00
break;
case GTK_STACK_TRANSITION_TYPE_OVER_UP:
case GTK_STACK_TRANSITION_TYPE_OVER_DOWN:
y = 0;
break;
case GTK_STACK_TRANSITION_TYPE_OVER_LEFT:
case GTK_STACK_TRANSITION_TYPE_OVER_RIGHT:
x = 0;
break;
default:
g_assert_not_reached ();
break;
}
stack: Fix the slide animation if the child has a non-zero allocation position This can happen if the child has a margin, for instance.
2013-11-01 05:51:27 +00:00
gtkstack: fix null pointer dereference The gtk_stack_snapshot_slide() function dereferences the last_visible_child pointer without proper != NULL ckeck. This might result in NULL pointer dereference and crash if last_visible_child is invalid. Add a != NULL check before dereferencing the pointer.
2018-09-26 20:59:59 +00:00
if (priv->last_visible_child != NULL)
{
if (gtk_widget_get_valign (priv->last_visible_child->widget) == GTK_ALIGN_END &&
priv->last_visible_widget_height > height)
y -= priv->last_visible_widget_height - height;
else if (gtk_widget_get_valign (priv->last_visible_child->widget) == GTK_ALIGN_CENTER)
y -= (priv->last_visible_widget_height - height) / 2;
}
GtkStack: Interpolate between size changes
2015-05-24 19:27:33 +00:00
stack: Use new snapshot transforms
2019-02-21 04:34:12 +00:00
gtk_snapshot_save (snapshot);
gtk_snapshot_translate (snapshot, &GRAPHENE_POINT_INIT (x, y));
stack: Implement snapshot() This uses the new push()/pop() mechanism to its fullest extent when implementing transitions. It's fun to inspect the results in the inspector. Crossfades don't work yet, they continue using a Cairo fallback. A side effect of the stack conversion is that widget-factory now uses snapshots for a lot more things.
2016-12-13 08:45:09 +00:00
gtk_snapshot_append_node (snapshot, priv->last_visible_node);
stack: Use new snapshot transforms
2019-02-21 04:34:12 +00:00
gtk_snapshot_restore (snapshot);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
}
Remove gtk_container_snapshot_child Replace it with the already existing gtk_widget_snapshot_child.
2017-01-07 16:02:20 +00:00
gtk_widget_snapshot_child (widget,
priv->visible_child->widget,
snapshot);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
}
stack: Implement snapshot() This uses the new push()/pop() mechanism to its fullest extent when implementing transitions. It's fun to inspect the results in the inspector. Crossfades don't work yet, they continue using a Cairo fallback. A side effect of the stack conversion is that widget-factory now uses snapshots for a lot more things.
2016-12-13 08:45:09 +00:00
static void
gtk_stack_snapshot (GtkWidget *widget,
GtkSnapshot *snapshot)
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
{
GtkStack *stack = GTK_STACK (widget);
stack: Use new private model, remove priv pointer
2013-07-02 11:43:20 +00:00
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
stack: Convert to gadgets
2015-12-09 04:03:38 +00:00
GtkStack: Fix drawing of sliding We were not drawing the view window, so the old widget was clipped for the sliding transitions.
2013-06-13 18:50:41 +00:00
if (priv->visible_child)
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
{
stack: port to progress tracker
2016-03-01 06:24:39 +00:00
if (gtk_progress_tracker_get_state (&priv->tracker) != GTK_PROGRESS_STATE_AFTER)
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
{
stack: Implement snapshot() This uses the new push()/pop() mechanism to its fullest extent when implementing transitions. It's fun to inspect the results in the inspector. Crossfades don't work yet, they continue using a Cairo fallback. A side effect of the stack conversion is that widget-factory now uses snapshots for a lot more things.
2016-12-13 08:45:09 +00:00
if (priv->last_visible_node == NULL &&
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
priv->last_visible_child != NULL)
{
Stop using stack-allocated snapshots Use the new/free api instead of init/finish for GtkSnapshot.
2018-03-11 02:14:09 +00:00
GtkSnapshot *last_visible_snapshot;
stack: Build stored render node with custom Snapshot object This is in preparation for API changes in GtkSnapshot.
2017-01-12 21:49:53 +00:00
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
gtk_widget_get_allocation (priv->last_visible_child->widget,
&priv->last_visible_surface_allocation);
snapshot: Redo debug messages Instead of every snapshot function having debug messages, have an explicit gtk_snapshot_push_debug() function that appends a debug node.
2018-04-24 01:17:23 +00:00
last_visible_snapshot = gtk_snapshot_new ();
Stop using stack-allocated snapshots Use the new/free api instead of init/finish for GtkSnapshot.
2018-03-11 02:14:09 +00:00
gtk_widget_snapshot (priv->last_visible_child->widget, last_visible_snapshot);
priv->last_visible_node = gtk_snapshot_free_to_node (last_visible_snapshot);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
}
stack: Implement snapshot() This uses the new push()/pop() mechanism to its fullest extent when implementing transitions. It's fun to inspect the results in the inspector. Crossfades don't work yet, they continue using a Cairo fallback. A side effect of the stack conversion is that widget-factory now uses snapshots for a lot more things.
2016-12-13 08:45:09 +00:00
gtk_snapshot_push_clip (snapshot,
&GRAPHENE_RECT_INIT(
0, 0,
Remove all gtk_widget_get_content_size usages And remove the function itself. Make everything use gtk_widget_get_width and gtk_widget_get_height instead.
2017-12-06 06:56:12 +00:00
gtk_widget_get_width (widget),
gtk_widget_get_height (widget)
snapshot: Redo debug messages Instead of every snapshot function having debug messages, have an explicit gtk_snapshot_push_debug() function that appends a debug node.
2018-04-24 01:17:23 +00:00
));
stack: Clip animation drawing We use cairo_paint() when doing that and we don't want to overdraw the content area.
2016-01-21 00:44:47 +00:00
Add a way to specify transition types on the fly Add a gtk_stack_set_visible_child_full that takes a transition type.
2013-04-21 18:22:35 +00:00
switch (priv->active_transition_type)
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
{
case GTK_STACK_TRANSITION_TYPE_CROSSFADE:
stack: Implement snapshot() This uses the new push()/pop() mechanism to its fullest extent when implementing transitions. It's fun to inspect the results in the inspector. Crossfades don't work yet, they continue using a Cairo fallback. A side effect of the stack conversion is that widget-factory now uses snapshots for a lot more things.
2016-12-13 08:45:09 +00:00
gtk_stack_snapshot_crossfade (widget, snapshot);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
break;
case GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT:
case GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT:
GtkStack: add vertical slide transitions We allow transitions that slide up or down.
2013-04-22 00:17:40 +00:00
case GTK_STACK_TRANSITION_TYPE_SLIDE_UP:
case GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN:
GtkStack: Add more transition types This adds new 'over' and 'under' transitions which work by moving the new page over the previous one, or moving the previous page off to reveal the new one. We also add an over/under combination that is going to be used in GtkAboutDialog. https://bugzilla.gnome.org/show_bug.cgi?id=707187
2013-08-31 16:00:47 +00:00
case GTK_STACK_TRANSITION_TYPE_OVER_UP:
case GTK_STACK_TRANSITION_TYPE_OVER_DOWN:
case GTK_STACK_TRANSITION_TYPE_OVER_LEFT:
case GTK_STACK_TRANSITION_TYPE_OVER_RIGHT:
stack: Implement snapshot() This uses the new push()/pop() mechanism to its fullest extent when implementing transitions. It's fun to inspect the results in the inspector. Crossfades don't work yet, they continue using a Cairo fallback. A side effect of the stack conversion is that widget-factory now uses snapshots for a lot more things.
2016-12-13 08:45:09 +00:00
gtk_stack_snapshot_slide (widget, snapshot);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
break;
GtkStack: Add more transition types This adds new 'over' and 'under' transitions which work by moving the new page over the previous one, or moving the previous page off to reveal the new one. We also add an over/under combination that is going to be used in GtkAboutDialog. https://bugzilla.gnome.org/show_bug.cgi?id=707187
2013-08-31 16:00:47 +00:00
case GTK_STACK_TRANSITION_TYPE_UNDER_UP:
case GTK_STACK_TRANSITION_TYPE_UNDER_DOWN:
case GTK_STACK_TRANSITION_TYPE_UNDER_LEFT:
case GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT:
stack: Implement snapshot() This uses the new push()/pop() mechanism to its fullest extent when implementing transitions. It's fun to inspect the results in the inspector. Crossfades don't work yet, they continue using a Cairo fallback. A side effect of the stack conversion is that widget-factory now uses snapshots for a lot more things.
2016-12-13 08:45:09 +00:00
gtk_stack_snapshot_under (widget, snapshot);
GtkStack: Add more transition types This adds new 'over' and 'under' transitions which work by moving the new page over the previous one, or moving the previous page off to reveal the new one. We also add an over/under combination that is going to be used in GtkAboutDialog. https://bugzilla.gnome.org/show_bug.cgi?id=707187
2013-08-31 16:00:47 +00:00
break;
stack: Add a cube spin transition Add a transition to GtkStack that pretends pages are the sides or a cube, and switch them by rotating the cube. Use this transition in widget-factory.
2019-03-05 19:44:45 +00:00
case GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT:
case GTK_STACK_TRANSITION_TYPE_ROTATE_RIGHT:
gtk_stack_snapshot_cube (widget, snapshot);
break;
build: Enable -Wswitch-enum and -Wswitch-default This patch makes that work using 1 of 2 options: 1. Add all missing enums to the switch statement or 2. Cast the switch argument to a uint to avoid having to do that (mostly for GdkEventType). I even found a bug while doing that: clearing a GtkImage with a surface did not notify thae surface property. The reason for enabling this flag even though it is tedious at times is that it is very useful when adding values to an enum, because it makes GTK immediately warn about all the switch statements where this enum is relevant. And I expect changes to enums to be frequent during the GTK4 development cycle.
2017-10-06 19:19:42 +00:00
case GTK_STACK_TRANSITION_TYPE_NONE:
case GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT:
case GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN:
case GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN:
case GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP:
case GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT:
case GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT:
stack: Add a cube spin transition Add a transition to GtkStack that pretends pages are the sides or a cube, and switch them by rotating the cube. Use this transition in widget-factory.
2019-03-05 19:44:45 +00:00
case GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT_RIGHT:
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
default:
g_assert_not_reached ();
}
snapshot: Redo pop() API gtk_snapshot_pop() => removed gtk_snapshot_pop_and_append() => gtk_snapshot_pop() So now there is no way to get a rendernode out of the snapshotting API until you gtk_snapshot_finish().
2017-01-12 23:39:59 +00:00
gtk_snapshot_pop (snapshot);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
}
API: Remove gtk_cairo_should_draw_window() The answer is: Yes.
2016-11-22 18:31:03 +00:00
else
Remove gtk_container_snapshot_child Replace it with the already existing gtk_widget_snapshot_child.
2017-01-07 16:02:20 +00:00
gtk_widget_snapshot_child (widget,
priv->visible_child->widget,
snapshot);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
}
}
static void
widget: Don't pass a position to ->size_allocate The values have been 0/0 for a long time now, so just drop the GtkAllocation argument and replace it with width and height.
2018-08-16 04:53:03 +00:00
gtk_stack_size_allocate (GtkWidget *widget,
int width,
int height,
int baseline)
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
{
GtkStack *stack = GTK_STACK (widget);
stack: Use new private model, remove priv pointer
2013-07-02 11:43:20 +00:00
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
stack: Convert to gadgets
2015-12-09 04:03:38 +00:00
GtkAllocation child_allocation;
stack: Remove bin_window
2017-06-04 15:30:40 +00:00
child_allocation.x = get_bin_window_x (stack);
child_allocation.y = get_bin_window_y (stack);
GtkStack: Interpolate between size changes
2015-05-24 19:27:33 +00:00
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
if (priv->last_visible_child)
stack: query preferred size for last_visible_child When animating, we might be changing the size allocation of the previous stack child. However, we were not querying the size in the process meaning you would often see warnings about allocating the size without knowing what it should be. This simply adds an innocuous size request, since responding to last_child sizing requests is not all that critical in the transition. https://bugzilla.gnome.org/show_bug.cgi?id=763900
2016-03-19 02:27:31 +00:00
{
int min, nat;
stack: Use gtk_widget_measure
2016-11-12 17:58:18 +00:00
gtk_widget_measure (priv->last_visible_child->widget, GTK_ORIENTATION_HORIZONTAL,
-1,
&min, &nat, NULL, NULL);
widget: Don't pass a position to ->size_allocate The values have been 0/0 for a long time now, so just drop the GtkAllocation argument and replace it with width and height.
2018-08-16 04:53:03 +00:00
child_allocation.width = MAX (min, width);
stack: Use gtk_widget_measure
2016-11-12 17:58:18 +00:00
gtk_widget_measure (priv->last_visible_child->widget, GTK_ORIENTATION_VERTICAL,
child_allocation.width,
&min, &nat, NULL, NULL);
widget: Don't pass a position to ->size_allocate The values have been 0/0 for a long time now, so just drop the GtkAllocation argument and replace it with width and height.
2018-08-16 04:53:03 +00:00
child_allocation.height = MAX (min, height);
stack: Don't underallocate the last_child
2016-02-26 20:58:36 +00:00
widget: Remove clip from size-allocate vfunc As the clip is no longer needed, get rid of it.
2018-03-31 19:02:28 +00:00
gtk_widget_size_allocate (priv->last_visible_child->widget, &child_allocation, -1);
stack: Redraw last_visible_surface if child allocation changes So the widget is properly aligned.
2016-10-28 10:51:03 +00:00
if (!gdk_rectangle_equal (&priv->last_visible_surface_allocation,
&child_allocation))
{
stack: Implement snapshot() This uses the new push()/pop() mechanism to its fullest extent when implementing transitions. It's fun to inspect the results in the inspector. Crossfades don't work yet, they continue using a Cairo fallback. A side effect of the stack conversion is that widget-factory now uses snapshots for a lot more things.
2016-12-13 08:45:09 +00:00
g_clear_pointer (&priv->last_visible_node, gsk_render_node_unref);
stack: Redraw last_visible_surface if child allocation changes So the widget is properly aligned.
2016-10-28 10:51:03 +00:00
}
stack: query preferred size for last_visible_child When animating, we might be changing the size allocation of the previous stack child. However, we were not querying the size in the process meaning you would often see warnings about allocating the size without knowing what it should be. This simply adds an innocuous size request, since responding to last_child sizing requests is not all that critical in the transition. https://bugzilla.gnome.org/show_bug.cgi?id=763900
2016-03-19 02:27:31 +00:00
}
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
widget: Don't pass a position to ->size_allocate The values have been 0/0 for a long time now, so just drop the GtkAllocation argument and replace it with width and height.
2018-08-16 04:53:03 +00:00
child_allocation.width = width;
child_allocation.height = height;
stack: Don't underallocate the last_child
2016-02-26 20:58:36 +00:00
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
if (priv->visible_child)
GtkStack: Interpolate between size changes
2015-05-24 19:27:33 +00:00
{
stack: Don't underallocate child in interpolate-size case In that case, we can't just rely on the stack allocation being big enough. Especially, the child can actually be bigger than the current stack allocation, so take that into account when positioning it.
2016-10-28 10:56:36 +00:00
int min_width;
int min_height;
GtkStack: Don't mix code and declarations
2015-05-30 13:43:56 +00:00
stack: Don't underallocate child in interpolate-size case In that case, we can't just rely on the stack allocation being big enough. Especially, the child can actually be bigger than the current stack allocation, so take that into account when positioning it.
2016-10-28 10:56:36 +00:00
gtk_widget_measure (priv->visible_child->widget, GTK_ORIENTATION_HORIZONTAL,
widget: Don't pass a position to ->size_allocate The values have been 0/0 for a long time now, so just drop the GtkAllocation argument and replace it with width and height.
2018-08-16 04:53:03 +00:00
height, &min_width, NULL, NULL, NULL);
stack: Don't underallocate child in interpolate-size case In that case, we can't just rely on the stack allocation being big enough. Especially, the child can actually be bigger than the current stack allocation, so take that into account when positioning it.
2016-10-28 10:56:36 +00:00
child_allocation.width = MAX (child_allocation.width, min_width);
gtk_widget_measure (priv->visible_child->widget, GTK_ORIENTATION_VERTICAL,
child_allocation.width, &min_height, NULL, NULL, NULL);
child_allocation.height = MAX (child_allocation.height, min_height);
widget: Don't pass a position to ->size_allocate The values have been 0/0 for a long time now, so just drop the GtkAllocation argument and replace it with width and height.
2018-08-16 04:53:03 +00:00
if (child_allocation.width > width)
GtkStack: Add interpolate-size property And use it to determine whether we should actually interpolate between stack sizes or not.
2015-07-19 15:39:41 +00:00
{
stack: Don't underallocate child in interpolate-size case In that case, we can't just rely on the stack allocation being big enough. Especially, the child can actually be bigger than the current stack allocation, so take that into account when positioning it.
2016-10-28 10:56:36 +00:00
GtkAlign halign = gtk_widget_get_halign (priv->visible_child->widget);
if (halign == GTK_ALIGN_CENTER || halign == GTK_ALIGN_FILL)
widget: Don't pass a position to ->size_allocate The values have been 0/0 for a long time now, so just drop the GtkAllocation argument and replace it with width and height.
2018-08-16 04:53:03 +00:00
child_allocation.x = (width - child_allocation.width) / 2;
stack: Don't underallocate child in interpolate-size case In that case, we can't just rely on the stack allocation being big enough. Especially, the child can actually be bigger than the current stack allocation, so take that into account when positioning it.
2016-10-28 10:56:36 +00:00
else if (halign == GTK_ALIGN_END)
widget: Don't pass a position to ->size_allocate The values have been 0/0 for a long time now, so just drop the GtkAllocation argument and replace it with width and height.
2018-08-16 04:53:03 +00:00
child_allocation.x = (width - child_allocation.width);
stack: Don't underallocate child in interpolate-size case In that case, we can't just rely on the stack allocation being big enough. Especially, the child can actually be bigger than the current stack allocation, so take that into account when positioning it.
2016-10-28 10:56:36 +00:00
}
widget: Don't pass a position to ->size_allocate The values have been 0/0 for a long time now, so just drop the GtkAllocation argument and replace it with width and height.
2018-08-16 04:53:03 +00:00
if (child_allocation.height > height)
stack: Don't underallocate child in interpolate-size case In that case, we can't just rely on the stack allocation being big enough. Especially, the child can actually be bigger than the current stack allocation, so take that into account when positioning it.
2016-10-28 10:56:36 +00:00
{
GtkAlign valign = gtk_widget_get_valign (priv->visible_child->widget);
if (valign == GTK_ALIGN_CENTER || valign == GTK_ALIGN_FILL)
widget: Don't pass a position to ->size_allocate The values have been 0/0 for a long time now, so just drop the GtkAllocation argument and replace it with width and height.
2018-08-16 04:53:03 +00:00
child_allocation.y = (height - child_allocation.height) / 2;
stack: Don't underallocate child in interpolate-size case In that case, we can't just rely on the stack allocation being big enough. Especially, the child can actually be bigger than the current stack allocation, so take that into account when positioning it.
2016-10-28 10:56:36 +00:00
else if (valign == GTK_ALIGN_END)
widget: Don't pass a position to ->size_allocate The values have been 0/0 for a long time now, so just drop the GtkAllocation argument and replace it with width and height.
2018-08-16 04:53:03 +00:00
child_allocation.y = (height - child_allocation.height);
GtkStack: Add interpolate-size property And use it to determine whether we should actually interpolate between stack sizes or not.
2015-07-19 15:39:41 +00:00
}
stack: Remove some code duplication
2016-02-26 20:58:22 +00:00
widget: Remove clip from size-allocate vfunc As the clip is no longer needed, get rid of it.
2018-03-31 19:02:28 +00:00
gtk_widget_size_allocate (priv->visible_child->widget, &child_allocation, -1);
GtkStack: Interpolate between size changes
2015-05-24 19:27:33 +00:00
}
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
}
stack: Convert to gadgets
2015-12-09 04:03:38 +00:00
#define LERP(a, b, t) ((a) + (((b) - (a)) * (1.0 - (t))))
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
static void
stack: Remove gadget
2017-05-05 15:18:15 +00:00
gtk_stack_measure (GtkWidget *widget,
stack: Convert to gadgets
2015-12-09 04:03:38 +00:00
GtkOrientation orientation,
int for_size,
int *minimum,
int *natural,
int *minimum_baseline,
stack: Remove gadget
2017-05-05 15:18:15 +00:00
int *natural_baseline)
stack: Convert to gadgets
2015-12-09 04:03:38 +00:00
{
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
GtkStack *stack = GTK_STACK (widget);
stack: Use new private model, remove priv pointer
2013-07-02 11:43:20 +00:00
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
stack: Convert child properties to a child meta object Create a GtkStackPage public object which holds the former child properties of GtkStack. Adjust all callers.
2019-02-06 17:54:18 +00:00
GtkStackPage *child_info;
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
GtkWidget *child;
gint child_min, child_nat;
GList *l;
stack: Convert to gadgets
2015-12-09 04:03:38 +00:00
*minimum = 0;
*natural = 0;
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
for (l = priv->children; l != NULL; l = l->next)
{
child_info = l->data;
child = child_info->widget;
stack: Convert to gadgets
2015-12-09 04:03:38 +00:00
if (((orientation == GTK_ORIENTATION_VERTICAL && !priv->vhomogeneous) ||
(orientation == GTK_ORIENTATION_HORIZONTAL && !priv->hhomogeneous)) &&
GtkStack: Keep the last_visible_child around during transitions We need it later.
2015-05-24 19:15:44 +00:00
priv->visible_child != child_info)
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
continue;
stack: Convert to gadgets
2015-12-09 04:03:38 +00:00
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
if (gtk_widget_get_visible (child))
{
stack: Use measure() to measure child widget Simpler code this way \o/
2016-10-27 07:38:45 +00:00
gtk_widget_measure (child, orientation, for_size, &child_min, &child_nat, NULL, NULL);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
stack: Convert to gadgets
2015-12-09 04:03:38 +00:00
*minimum = MAX (*minimum, child_min);
*natural = MAX (*natural, child_nat);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
}
}
stack: Convert to gadgets
2015-12-09 04:03:38 +00:00
if (priv->last_visible_child != NULL)
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
{
stack: Convert to gadgets
2015-12-09 04:03:38 +00:00
if (orientation == GTK_ORIENTATION_VERTICAL && !priv->vhomogeneous)
{
stack: port to progress tracker
2016-03-01 06:24:39 +00:00
gdouble t = priv->interpolate_size ? gtk_progress_tracker_get_ease_out_cubic (&priv->tracker, FALSE) : 1.0;
stack: Convert to gadgets
2015-12-09 04:03:38 +00:00
*minimum = LERP (*minimum, priv->last_visible_widget_height, t);
*natural = LERP (*natural, priv->last_visible_widget_height, t);
}
if (orientation == GTK_ORIENTATION_HORIZONTAL && !priv->hhomogeneous)
{
stack: port to progress tracker
2016-03-01 06:24:39 +00:00
gdouble t = priv->interpolate_size ? gtk_progress_tracker_get_ease_out_cubic (&priv->tracker, FALSE) : 1.0;
stack: Convert to gadgets
2015-12-09 04:03:38 +00:00
*minimum = LERP (*minimum, priv->last_visible_widget_width, t);
*natural = LERP (*natural, priv->last_visible_widget_width, t);
}
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
}
}
static void
stack: Convert to gadgets
2015-12-09 04:03:38 +00:00
gtk_stack_init (GtkStack *stack)
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
{
stack: Use new private model, remove priv pointer
2013-07-02 11:43:20 +00:00
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
stack: Convert to gadgets
2015-12-09 04:03:38 +00:00
priv->vhomogeneous = TRUE;
priv->hhomogeneous = TRUE;
priv->transition_duration = 200;
priv->transition_type = GTK_STACK_TRANSITION_TYPE_NONE;
Add GtkStack Add separate GtkStack and GtkStackSwitcher widgets that are an alternative to GtkNotebook. Additionally, GtkStack supports animated transitions when changing pages. These widgets were initially developed in libgd.
2013-04-21 11:51:14 +00:00
}
stack: Provide a selection model Make GtkStack expose a selection model for its pages. The model can be used to track changes to the pages, and to change what child is visible.
2019-02-10 23:22:54 +00:00
/**
* gtk_stack_get_pages:
* @stack: a #GtkStack
*
* Returns a #GListModel that contains the pages of the stack,
* and can be used to keep and up-to-date view. The model also
* implements #GtkSelectionModel and can be used to track and
* modify the visible page..
*
* Returns: (transfer full): a #GtkSelectionModel for the stack's children
*/
GtkSelectionModel *
gtk_stack_get_pages (GtkStack *stack)
{
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
g_return_val_if_fail (GTK_IS_STACK (stack), NULL);
if (priv->pages)
return g_object_ref (priv->pages);
priv->pages = GTK_SELECTION_MODEL (gtk_stack_pages_new (stack));
g_object_add_weak_pointer (G_OBJECT (priv->pages), (gpointer *)&priv->pages);
return priv->pages;
}
stack: Add GtkStackPage:visible accessors
2020-02-18 08:27:42 +00:00
/**
* gtk_stack_page_get_visible:
* @page: a #GtkStackPage
*
* Returns whether @page is visible in its #GtkStack.
* This is independent from the #GtkWidget:visible value of its
* #GtkWidget.
*/
gboolean
gtk_stack_page_get_visible (GtkStackPage *page)
{
g_return_val_if_fail (GTK_IS_STACK_PAGE (page), FALSE);
return page->visible;
}
/**
* gtk_stack_page_set_visible:
* @page: a #GtkStackPage
* @visible: The new property value
*
* Sets the new value of the #GtkStackPage:visible property
* to @visible.
*/
void
gtk_stack_page_set_visible (GtkStackPage *page,
gboolean visible)
{
g_return_if_fail (GTK_IS_STACK_PAGE (page));
visible = !!visible;
if (visible != page->visible)
{
page->visible = visible;
g_object_notify_by_pspec (G_OBJECT (page), stack_child_props[CHILD_PROP_VISIBLE]);
}
}
Reference in New Issue Copy Permalink