From 5a362c6759c366728cfe827300b65acb13c51252 Mon Sep 17 00:00:00 2001 From: Matthias Clasen Date: Fri, 17 Apr 2020 15:43:18 -0400 Subject: [PATCH 1/4] nodeeditor: Don't set has-focus That is now a readonly property. Set focus-widget on the toplevel instead. --- demos/node-editor/node-editor-window.ui | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/demos/node-editor/node-editor-window.ui b/demos/node-editor/node-editor-window.ui index f30532f731..3707c9e2b6 100644 --- a/demos/node-editor/node-editor-window.ui +++ b/demos/node-editor/node-editor-window.ui @@ -83,6 +83,7 @@ GTK Node Editor 1024 768 + text_view GTK Node Editor @@ -139,7 +140,6 @@ word 1 - 1 6 6 6 From b5d17d2f9b958f95538bffed396ebec028db82fc Mon Sep 17 00:00:00 2001 From: Matthias Clasen Date: Fri, 17 Apr 2020 16:13:01 -0400 Subject: [PATCH 2/4] Adwaita: Add focus to expander We were not drawing a focus indication at all for expanders. Bring it back. Also, make the color plane focus snug. Fixes: https://gitlab.gnome.org/GNOME/gtk/-/issues/1899 --- gtk/theme/Adwaita/_common.scss | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/gtk/theme/Adwaita/_common.scss b/gtk/theme/Adwaita/_common.scss index 9820a92416..8f8b9a0243 100644 --- a/gtk/theme/Adwaita/_common.scss +++ b/gtk/theme/Adwaita/_common.scss @@ -42,7 +42,9 @@ dnd { * Outlines * ********/ +expander-widget:focus:focus-visible, :focus-visible link, +plane:focus-visible, label:focus-visible:not(.link), row:focus-visible, flowboxchild:focus-visible { @@ -58,7 +60,6 @@ flowboxchild:focus-visible { } // Widgets that draw their focus indicator outset and not inset -plane:focus-visible, scale:focus-visible > trough { outline-color: $focus_border_color; outline-style: solid; From 19dbbf6fa5518122099e90a5be04cbb540900cc6 Mon Sep 17 00:00:00 2001 From: Matthias Clasen Date: Fri, 17 Apr 2020 17:37:52 -0400 Subject: [PATCH 3/4] aspectframe: Modernize Make GtkAspectFrame not derive from GtkFrame anymore, since frames now always draw, well, a frame. Also, add proper setters for the properties of GtkAspectFrame. Update our sole user. Fixes: https://gitlab.gnome.org/GNOME/gtk/-/issues/2627 --- demos/gtk-demo/sliding_puzzle.c | 5 +- docs/reference/gtk/gtk4-sections.txt | 10 +- gtk/gtkaspectframe.c | 370 +++++++++++++++++---------- gtk/gtkaspectframe.h | 38 ++- 4 files changed, 272 insertions(+), 151 deletions(-) diff --git a/demos/gtk-demo/sliding_puzzle.c b/demos/gtk-demo/sliding_puzzle.c index d95cc14126..2c8abf8ac7 100644 --- a/demos/gtk-demo/sliding_puzzle.c +++ b/demos/gtk-demo/sliding_puzzle.c @@ -279,7 +279,8 @@ start_puzzle (GdkPaintable *paintable) aspect_ratio = gdk_paintable_get_intrinsic_aspect_ratio (paintable); if (aspect_ratio == 0.0) aspect_ratio = 1.0; - gtk_aspect_frame_set (GTK_ASPECT_FRAME (frame), 0.5, 0.5, aspect_ratio, FALSE); + gtk_aspect_frame_set_ratio (GTK_ASPECT_FRAME (frame), aspect_ratio); + gtk_aspect_frame_set_obey_child (GTK_ASPECT_FRAME (frame), FALSE); /* Add shortcuts so people can use the arrow * keys to move the puzzle */ @@ -466,7 +467,7 @@ do_sliding_puzzle (GtkWidget *do_widget) g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window); - frame = gtk_aspect_frame_new (NULL, 0.5, 0.5, (float) gdk_paintable_get_intrinsic_aspect_ratio (puzzle), FALSE); + frame = gtk_aspect_frame_new (0.5, 0.5, (float) gdk_paintable_get_intrinsic_aspect_ratio (puzzle), FALSE); gtk_container_add (GTK_CONTAINER (window), frame); start_puzzle (puzzle); diff --git a/docs/reference/gtk/gtk4-sections.txt b/docs/reference/gtk/gtk4-sections.txt index 2849e99251..3664f08650 100644 --- a/docs/reference/gtk/gtk4-sections.txt +++ b/docs/reference/gtk/gtk4-sections.txt @@ -187,7 +187,14 @@ gtk_assistant_get_type GtkAspectFrame GtkAspectFrame gtk_aspect_frame_new -gtk_aspect_frame_set +gtk_aspect_frame_set_xalign +gtk_aspect_frame_get_xalign +gtk_aspect_frame_set_yalign +gtk_aspect_frame_get_yalign +gtk_aspect_frame_set_ratio +gtk_aspect_frame_get_ratio +gtk_aspect_frame_set_obey_child +gtk_aspect_frame_get_obey_child GTK_ASPECT_FRAME GTK_IS_ASPECT_FRAME @@ -196,7 +203,6 @@ GTK_ASPECT_FRAME_CLASS GTK_IS_ASPECT_FRAME_CLASS GTK_ASPECT_FRAME_GET_CLASS -GtkAspectFramePrivate gtk_aspect_frame_get_type diff --git a/gtk/gtkaspectframe.c b/gtk/gtkaspectframe.c index 1f56f242f1..248bcd1127 100644 --- a/gtk/gtkaspectframe.c +++ b/gtk/gtkaspectframe.c @@ -48,6 +48,7 @@ #include "config.h" #include "gtkaspectframe.h" +#include "gtkbin.h" #include "gtksizerequest.h" @@ -59,23 +60,19 @@ typedef struct _GtkAspectFrameClass GtkAspectFrameClass; struct _GtkAspectFrame { - GtkFrame parent_instance; + GtkBin parent_instance; + + gboolean obey_child; + float xalign; + float yalign; + float ratio; }; struct _GtkAspectFrameClass { - GtkFrameClass parent_class; + GtkBinClass parent_class; }; -typedef struct -{ - gboolean obey_child; - gfloat xalign; - gfloat yalign; - gfloat ratio; -} GtkAspectFramePrivate; - - enum { PROP_0, PROP_XALIGN, @@ -92,27 +89,26 @@ static void gtk_aspect_frame_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec); -static void gtk_aspect_frame_compute_child_allocation (GtkFrame *frame, - GtkAllocation *child_allocation); +static void gtk_aspect_frame_size_allocate (GtkWidget *widget, + int width, + int height, + int baseline); #define MAX_RATIO 10000.0 #define MIN_RATIO 0.0001 -G_DEFINE_TYPE_WITH_PRIVATE (GtkAspectFrame, gtk_aspect_frame, GTK_TYPE_FRAME) +G_DEFINE_TYPE (GtkAspectFrame, gtk_aspect_frame, GTK_TYPE_BIN) static void gtk_aspect_frame_class_init (GtkAspectFrameClass *class) { - GObjectClass *gobject_class; - GtkFrameClass *frame_class; - - gobject_class = (GObjectClass*) class; - frame_class = (GtkFrameClass*) class; + GObjectClass *gobject_class = G_OBJECT_CLASS (class); + GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class); gobject_class->set_property = gtk_aspect_frame_set_property; gobject_class->get_property = gtk_aspect_frame_get_property; - frame_class->compute_child_allocation = gtk_aspect_frame_compute_child_allocation; + widget_class->size_allocate = gtk_aspect_frame_size_allocate; g_object_class_install_property (gobject_class, PROP_XALIGN, @@ -143,18 +139,16 @@ gtk_aspect_frame_class_init (GtkAspectFrameClass *class) TRUE, GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY)); - gtk_widget_class_set_css_name (GTK_WIDGET_CLASS (class), I_("frame")); + gtk_widget_class_set_css_name (GTK_WIDGET_CLASS (class), I_("aspectframe")); } static void -gtk_aspect_frame_init (GtkAspectFrame *aspect_frame) +gtk_aspect_frame_init (GtkAspectFrame *self) { - GtkAspectFramePrivate *priv = gtk_aspect_frame_get_instance_private (aspect_frame); - - priv->xalign = 0.5; - priv->yalign = 0.5; - priv->ratio = 1.0; - priv->obey_child = TRUE; + self->xalign = 0.5; + self->yalign = 0.5; + self->ratio = 1.0; + self->obey_child = TRUE; } static void @@ -163,39 +157,22 @@ gtk_aspect_frame_set_property (GObject *object, const GValue *value, GParamSpec *pspec) { - GtkAspectFrame *aspect_frame = GTK_ASPECT_FRAME (object); - GtkAspectFramePrivate *priv = gtk_aspect_frame_get_instance_private (aspect_frame); + GtkAspectFrame *self = GTK_ASPECT_FRAME (object); switch (prop_id) { /* g_object_notify is handled by the _frame_set function */ case PROP_XALIGN: - gtk_aspect_frame_set (aspect_frame, - g_value_get_float (value), - priv->yalign, - priv->ratio, - priv->obey_child); + gtk_aspect_frame_set_xalign (self, g_value_get_float (value)); break; case PROP_YALIGN: - gtk_aspect_frame_set (aspect_frame, - priv->xalign, - g_value_get_float (value), - priv->ratio, - priv->obey_child); + gtk_aspect_frame_set_yalign (self, g_value_get_float (value)); break; case PROP_RATIO: - gtk_aspect_frame_set (aspect_frame, - priv->xalign, - priv->yalign, - g_value_get_float (value), - priv->obey_child); + gtk_aspect_frame_set_ratio (self, g_value_get_float (value)); break; case PROP_OBEY_CHILD: - gtk_aspect_frame_set (aspect_frame, - priv->xalign, - priv->yalign, - priv->ratio, - g_value_get_boolean (value)); + gtk_aspect_frame_set_obey_child (self, g_value_get_boolean (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); @@ -209,22 +186,21 @@ gtk_aspect_frame_get_property (GObject *object, GValue *value, GParamSpec *pspec) { - GtkAspectFrame *aspect_frame = GTK_ASPECT_FRAME (object); - GtkAspectFramePrivate *priv = gtk_aspect_frame_get_instance_private (aspect_frame); + GtkAspectFrame *self = GTK_ASPECT_FRAME (object); switch (prop_id) { case PROP_XALIGN: - g_value_set_float (value, priv->xalign); + g_value_set_float (value, self->xalign); break; case PROP_YALIGN: - g_value_set_float (value, priv->yalign); + g_value_set_float (value, self->yalign); break; case PROP_RATIO: - g_value_set_float (value, priv->ratio); + g_value_set_float (value, self->ratio); break; case PROP_OBEY_CHILD: - g_value_set_boolean (value, priv->obey_child); + g_value_set_boolean (value, self->obey_child); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); @@ -234,7 +210,6 @@ gtk_aspect_frame_get_property (GObject *object, /** * gtk_aspect_frame_new: - * @label: (allow-none): Label text. * @xalign: Horizontal alignment of the child within the allocation of * the #GtkAspectFrame. This ranges from 0.0 (left aligned) * to 1.0 (right aligned) @@ -249,100 +224,206 @@ gtk_aspect_frame_get_property (GObject *object, * * Returns: the new #GtkAspectFrame. */ -GtkWidget* -gtk_aspect_frame_new (const gchar *label, - gfloat xalign, - gfloat yalign, - gfloat ratio, - gboolean obey_child) +GtkWidget * +gtk_aspect_frame_new (float xalign, + float yalign, + float ratio, + gboolean obey_child) { - GtkAspectFrame *aspect_frame; - GtkAspectFramePrivate *priv; + GtkAspectFrame *self; - aspect_frame = g_object_new (GTK_TYPE_ASPECT_FRAME, NULL); - priv = gtk_aspect_frame_get_instance_private (aspect_frame); + self = g_object_new (GTK_TYPE_ASPECT_FRAME, NULL); - priv->xalign = CLAMP (xalign, 0.0, 1.0); - priv->yalign = CLAMP (yalign, 0.0, 1.0); - priv->ratio = CLAMP (ratio, MIN_RATIO, MAX_RATIO); - priv->obey_child = obey_child != FALSE; + self->xalign = CLAMP (xalign, 0.0, 1.0); + self->yalign = CLAMP (yalign, 0.0, 1.0); + self->ratio = CLAMP (ratio, MIN_RATIO, MAX_RATIO); + self->obey_child = obey_child != FALSE; - gtk_frame_set_label (GTK_FRAME(aspect_frame), label); - - return GTK_WIDGET (aspect_frame); + return GTK_WIDGET (self); } /** - * gtk_aspect_frame_set: - * @aspect_frame: a #GtkAspectFrame - * @xalign: Horizontal alignment of the child within the allocation of - * the #GtkAspectFrame. This ranges from 0.0 (left aligned) - * to 1.0 (right aligned) - * @yalign: Vertical alignment of the child within the allocation of - * the #GtkAspectFrame. This ranges from 0.0 (top aligned) - * to 1.0 (bottom aligned) - * @ratio: The desired aspect ratio. - * @obey_child: If %TRUE, @ratio is ignored, and the aspect - * ratio is taken from the requistion of the child. + * gtk_aspect_frame_set_xalign: + * @self: a #GtkAspectFrame + * @xalign: horizontal alignment, from 0.0 (left aligned) to 1.0 (right aligned) * - * Set parameters for an existing #GtkAspectFrame. + * Sets the horizontal alignment of the child within the allocation + * of the #GtkAspectFrame. */ void -gtk_aspect_frame_set (GtkAspectFrame *aspect_frame, - gfloat xalign, - gfloat yalign, - gfloat ratio, - gboolean obey_child) +gtk_aspect_frame_set_xalign (GtkAspectFrame *self, + float xalign) { - GtkAspectFramePrivate *priv = gtk_aspect_frame_get_instance_private (aspect_frame); - - g_return_if_fail (GTK_IS_ASPECT_FRAME (aspect_frame)); + g_return_if_fail (GTK_IS_ASPECT_FRAME (self)); xalign = CLAMP (xalign, 0.0, 1.0); + + if (self->xalign == xalign) + return; + + self->xalign = xalign; + + g_object_notify (G_OBJECT (self), "xalign"); + gtk_widget_queue_resize (GTK_WIDGET (self)); +} + +/** + * gtk_aspect_frame_get_xalign: + * @self: a #GtkAspectFrame + * + * Returns the horizontal alignment of the child within the + * allocation of the #GtkAspectFrame. + * + * Returns: the horizontal alignment + */ +float +gtk_aspect_frame_get_xalign (GtkAspectFrame *self) +{ + g_return_val_if_fail (GTK_IS_ASPECT_FRAME (self), 0.5); + + return self->xalign; +} + +/** + * gtk_aspect_frame_set_yalign: + * @self: a #GtkAspectFrame + * @yalign: horizontal alignment, from 0.0 (top aligned) to 1.0 (bottom aligned) + * + * Sets the vertical alignment of the child within the allocation + * of the #GtkAspectFrame. + */ +void +gtk_aspect_frame_set_yalign (GtkAspectFrame *self, + float yalign) +{ + g_return_if_fail (GTK_IS_ASPECT_FRAME (self)); + yalign = CLAMP (yalign, 0.0, 1.0); + + if (self->yalign == yalign) + return; + + self->yalign = yalign; + + g_object_notify (G_OBJECT (self), "yalign"); + gtk_widget_queue_resize (GTK_WIDGET (self)); +} + +/** + * gtk_aspect_frame_get_yalign: + * @self: a #GtkAspectFrame + * + * Returns the vertical alignment of the child within the + * allocation of the #GtkAspectFrame. + * + * Returns: the vertical alignment + */ +float +gtk_aspect_frame_get_yalign (GtkAspectFrame *self) +{ + g_return_val_if_fail (GTK_IS_ASPECT_FRAME (self), 0.5); + + return self->xalign; +} + +/** + * gtk_aspect_frame_set_ratio: + * @self: a #GtkAspectFrame + * @ratio: aspect ratio of the child + * + * Sets the desired aspect ratio of the child. + */ +void +gtk_aspect_frame_set_ratio (GtkAspectFrame *self, + float ratio) +{ + g_return_if_fail (GTK_IS_ASPECT_FRAME (self)); + ratio = CLAMP (ratio, MIN_RATIO, MAX_RATIO); - obey_child = obey_child != FALSE; - - if (priv->xalign != xalign - || priv->yalign != yalign - || priv->ratio != ratio - || priv->obey_child != obey_child) - { - g_object_freeze_notify (G_OBJECT (aspect_frame)); - if (priv->xalign != xalign) - { - priv->xalign = xalign; - g_object_notify (G_OBJECT (aspect_frame), "xalign"); - } - if (priv->yalign != yalign) - { - priv->yalign = yalign; - g_object_notify (G_OBJECT (aspect_frame), "yalign"); - } - if (priv->ratio != ratio) - { - priv->ratio = ratio; - g_object_notify (G_OBJECT (aspect_frame), "ratio"); - } - if (priv->obey_child != obey_child) - { - priv->obey_child = obey_child; - g_object_notify (G_OBJECT (aspect_frame), "obey-child"); - } - g_object_thaw_notify (G_OBJECT (aspect_frame)); + if (self->ratio == ratio) + return; - gtk_widget_queue_resize (GTK_WIDGET (aspect_frame)); - } + self->ratio = ratio; + + g_object_notify (G_OBJECT (self), "ratio"); + gtk_widget_queue_resize (GTK_WIDGET (self)); +} + +/** + * gtk_aspect_frame_get_ratio: + * @self: a #GtkAspectFrame + * + * Returns the desired aspect ratio of the child. + * + * Returns: the desired aspect ratio + */ +float +gtk_aspect_frame_get_ratio (GtkAspectFrame *self) +{ + g_return_val_if_fail (GTK_IS_ASPECT_FRAME (self), 1.0); + + return self->ratio; +} + +/** + * gtk_aspect_frame_set_obey_child: + * @self: a #GtkAspectFrame + * @obey_child: If %TRUE, @ratio is ignored, and the aspect + * ratio is taken from the requistion of the child. + * + * Sets whether the aspect ratio of the childs size + * request should override the set aspect ratio of + * the #GtkAspectFrame. + */ +void +gtk_aspect_frame_set_obey_child (GtkAspectFrame *self, + gboolean obey_child) +{ + g_return_if_fail (GTK_IS_ASPECT_FRAME (self)); + + if (self->obey_child == obey_child) + return; + + self->obey_child = obey_child; + + g_object_notify (G_OBJECT (self), "obey-child"); + gtk_widget_queue_resize (GTK_WIDGET (self)); + +} + +/** + * gtk_aspect_frame_get_obey_child: + * @self: a #GtkAspectFrame + * + * Returns whether the childs size request should override + * the set aspect ratio of the #GtkAspectFrame. + * + * Returns: whether to obey the childs size request + */ +gboolean +gtk_aspect_frame_get_obey_child (GtkAspectFrame *self) +{ + g_return_val_if_fail (GTK_IS_ASPECT_FRAME (self), TRUE); + + return self->obey_child; } static void -gtk_aspect_frame_compute_child_allocation (GtkFrame *frame, - GtkAllocation *child_allocation) +get_full_allocation (GtkAspectFrame *self, + GtkAllocation *child_allocation) { - GtkAspectFrame *aspect_frame = GTK_ASPECT_FRAME (frame); - GtkAspectFramePrivate *priv = gtk_aspect_frame_get_instance_private (aspect_frame); - GtkBin *bin = GTK_BIN (frame); + child_allocation->x = 0; + child_allocation->y = 0; + child_allocation->width = gtk_widget_get_width (GTK_WIDGET (self)); + child_allocation->height = gtk_widget_get_height (GTK_WIDGET (self)); +} + +static void +compute_child_allocation (GtkAspectFrame *self, + GtkAllocation *child_allocation) +{ + GtkBin *bin = GTK_BIN (self); GtkWidget *child; gdouble ratio; @@ -351,7 +432,7 @@ gtk_aspect_frame_compute_child_allocation (GtkFrame *frame, { GtkAllocation full_allocation; - if (priv->obey_child) + if (self->obey_child) { GtkRequisition child_requisition; @@ -369,9 +450,9 @@ gtk_aspect_frame_compute_child_allocation (GtkFrame *frame, ratio = 1.0; } else - ratio = priv->ratio; + ratio = self->ratio; - GTK_FRAME_CLASS (gtk_aspect_frame_parent_class)->compute_child_allocation (frame, &full_allocation); + get_full_allocation (self, &full_allocation); if (ratio * full_allocation.height > full_allocation.width) { @@ -384,9 +465,26 @@ gtk_aspect_frame_compute_child_allocation (GtkFrame *frame, child_allocation->height = full_allocation.height; } - child_allocation->x = full_allocation.x + priv->xalign * (full_allocation.width - child_allocation->width); - child_allocation->y = full_allocation.y + priv->yalign * (full_allocation.height - child_allocation->height); + child_allocation->x = full_allocation.x + self->xalign * (full_allocation.width - child_allocation->width); + child_allocation->y = full_allocation.y + self->yalign * (full_allocation.height - child_allocation->height); } else - GTK_FRAME_CLASS (gtk_aspect_frame_parent_class)->compute_child_allocation (frame, child_allocation); + get_full_allocation (self, child_allocation); +} + +static void +gtk_aspect_frame_size_allocate (GtkWidget *widget, + int width, + int height, + int baseline) +{ + GtkAspectFrame *self = GTK_ASPECT_FRAME (widget); + GtkWidget *child; + GtkAllocation new_allocation; + + compute_child_allocation (self, &new_allocation); + + child = gtk_bin_get_child (GTK_BIN (widget)); + if (child && gtk_widget_get_visible (child)) + gtk_widget_size_allocate (child, &new_allocation, -1); } diff --git a/gtk/gtkaspectframe.h b/gtk/gtkaspectframe.h index 10e028bc56..e6e834bca1 100644 --- a/gtk/gtkaspectframe.h +++ b/gtk/gtkaspectframe.h @@ -30,7 +30,7 @@ #error "Only can be included directly." #endif -#include +#include G_BEGIN_DECLS @@ -44,18 +44,34 @@ typedef struct _GtkAspectFrame GtkAspectFrame; GDK_AVAILABLE_IN_ALL GType gtk_aspect_frame_get_type (void) G_GNUC_CONST; GDK_AVAILABLE_IN_ALL -GtkWidget* gtk_aspect_frame_new (const gchar *label, - gfloat xalign, - gfloat yalign, - gfloat ratio, - gboolean obey_child); -GDK_AVAILABLE_IN_ALL -void gtk_aspect_frame_set (GtkAspectFrame *aspect_frame, - gfloat xalign, - gfloat yalign, - gfloat ratio, +GtkWidget* gtk_aspect_frame_new (float xalign, + float yalign, + float ratio, gboolean obey_child); +GDK_AVAILABLE_IN_ALL +void gtk_aspect_frame_set_xalign (GtkAspectFrame *self, + float xalign); +GDK_AVAILABLE_IN_ALL +float gtk_aspect_frame_get_xalign (GtkAspectFrame *self); + +GDK_AVAILABLE_IN_ALL +void gtk_aspect_frame_set_yalign (GtkAspectFrame *self, + float yalign); +GDK_AVAILABLE_IN_ALL +float gtk_aspect_frame_get_yalign (GtkAspectFrame *self); + +GDK_AVAILABLE_IN_ALL +void gtk_aspect_frame_set_ratio (GtkAspectFrame *self, + float ratio); +GDK_AVAILABLE_IN_ALL +float gtk_aspect_frame_get_ratio (GtkAspectFrame *self); + +GDK_AVAILABLE_IN_ALL +void gtk_aspect_frame_set_obey_child (GtkAspectFrame *self, + gboolean obey_child); +GDK_AVAILABLE_IN_ALL +gboolean gtk_aspect_frame_get_obey_child (GtkAspectFrame *self); G_END_DECLS From 49f2012d2439f7d032b84b7a16b5390badd6842b Mon Sep 17 00:00:00 2001 From: Matthias Clasen Date: Fri, 17 Apr 2020 17:50:18 -0400 Subject: [PATCH 4/4] migration docs: Updates Mention shadow type, relief, aspect frame. --- docs/reference/gtk/migrating-3to4.xml | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/docs/reference/gtk/migrating-3to4.xml b/docs/reference/gtk/migrating-3to4.xml index 65bd1a1443..a7867f2e17 100644 --- a/docs/reference/gtk/migrating-3to4.xml +++ b/docs/reference/gtk/migrating-3to4.xml @@ -563,6 +563,12 @@ and always use the context's current state. Update all callers to omit the state argument. + + The most commonly used GtkStyleContext API, gtk_style_context_add_class(), + has been moved to GtkWidget as gtk_widget_add_css_class(), as have the + corresponding gtk_style_context_remove_class() and + gtk_style_context_has_class() APIs. +
@@ -587,6 +593,17 @@
+
+ Stop using GtkShadowType and GtkRelief properties + + The shadow-type properties in GtkScrolledWindow, GtkViewport, + and GtkFrame, as well as the relief properties in GtkButton + and its subclasses have been removed. GtkScrolledWindow, GtkButton + and GtkMenuButton have instead gained a boolean has-frame + property. + +
+
Adapt to GtkWidget's size request changes @@ -1037,6 +1054,15 @@
+
+ GtkAspectFrame is no longer a frame + + GtkAspectFrame is no longer derived from GtkFrame and does not + place a label and frame around its child anymore. It still lets + you control the aspect ratio of its child. + +
+
Stop using custom tooltip windows