From: Matthias Clasen Date: Mon, 10 Oct 2022 03:30:06 +0000 (-0400) Subject: stylecontext: Deprecate most apis X-Git-Tag: archive/raspbian/4.12.3+ds-1+rpi1~1^2^2^2~22^2~9^2~181^2~6 X-Git-Url: https://dgit.raspbian.org/?a=commitdiff_plain;h=ee8c2a235fafb7fe8d2abadb7a406130367332b4;p=gtk4.git stylecontext: Deprecate most apis The notable exception here are the global provider apis, which are needed in some form and don't have a replacement yet. Move them to gtkstyleprovider.[hc], so we can wholly deprecated gtkstylecontext.[hc]. --- diff --git a/gtk/deprecated/gtkstylecontext.c b/gtk/deprecated/gtkstylecontext.c new file mode 100644 index 0000000000..72e30e2822 --- /dev/null +++ b/gtk/deprecated/gtkstylecontext.c @@ -0,0 +1,982 @@ +/* GTK - The GIMP Toolkit + * Copyright (C) 2010 Carlos Garnacho + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. If not, see . + */ + +#include "config.h" + +#include "gtkstylecontextprivate.h" + +#include + +#include "gtkcsscolorvalueprivate.h" +#include "gtkcssnumbervalueprivate.h" +#include "gtkcsstransientnodeprivate.h" +#include "gtkdebug.h" +#include "gtkprivate.h" +#include "gtksettings.h" +#include "gtksettingsprivate.h" +#include "deprecated/gtkrender.h" + + +/** + * GtkStyleContext: + * + * `GtkStyleContext` stores styling information affecting a widget. + * + * In order to construct the final style information, `GtkStyleContext` + * queries information from all attached `GtkStyleProviders`. Style + * providers can be either attached explicitly to the context through + * [method@Gtk.StyleContext.add_provider], or to the display through + * [func@Gtk.StyleContext.add_provider_for_display]. The resulting + * style is a combination of all providers’ information in priority order. + * + * For GTK widgets, any `GtkStyleContext` returned by + * [method@Gtk.Widget.get_style_context] will already have a `GdkDisplay` + * and RTL/LTR information set. The style context will also be updated + * automatically if any of these settings change on the widget. + * + * # Style Classes + * + * Widgets can add style classes to their context, which can be used to associate + * different styles by class. The documentation for individual widgets lists + * which style classes it uses itself, and which style classes may be added by + * applications to affect their appearance. + * + * # Custom styling in UI libraries and applications + * + * If you are developing a library with custom widgets that render differently + * than standard components, you may need to add a `GtkStyleProvider` yourself + * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority, either a + * `GtkCssProvider` or a custom object implementing the `GtkStyleProvider` + * interface. This way themes may still attempt to style your UI elements in + * a different way if needed so. + * + * If you are using custom styling on an applications, you probably want then + * to make your style information prevail to the theme’s, so you must use + * a `GtkStyleProvider` with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION + * priority, keep in mind that the user settings in + * `XDG_CONFIG_HOME/gtk-4.0/gtk.css` will + * still take precedence over your changes, as it uses the + * %GTK_STYLE_PROVIDER_PRIORITY_USER priority. + */ + +#define CURSOR_ASPECT_RATIO (0.04) + +struct _GtkStyleContextPrivate +{ + GdkDisplay *display; + + guint cascade_changed_id; + GtkStyleCascade *cascade; + GtkCssNode *cssnode; + GSList *saved_nodes; +}; +typedef struct _GtkStyleContextPrivate GtkStyleContextPrivate; + +enum { + PROP_0, + PROP_DISPLAY, + LAST_PROP +}; + +static GParamSpec *properties[LAST_PROP] = { NULL, }; + +static void gtk_style_context_finalize (GObject *object); + +static void gtk_style_context_impl_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec); +static void gtk_style_context_impl_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec); + +static GtkCssNode * gtk_style_context_get_root (GtkStyleContext *context); + +G_DEFINE_TYPE_WITH_PRIVATE (GtkStyleContext, gtk_style_context, G_TYPE_OBJECT) + +static void +gtk_style_context_class_init (GtkStyleContextClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + object_class->finalize = gtk_style_context_finalize; + object_class->set_property = gtk_style_context_impl_set_property; + object_class->get_property = gtk_style_context_impl_get_property; + + properties[PROP_DISPLAY] = + g_param_spec_object ("display", NULL, NULL, + GDK_TYPE_DISPLAY, + GTK_PARAM_READWRITE); + + g_object_class_install_properties (object_class, LAST_PROP, properties); +} + +static void +gtk_style_context_pop_style_node (GtkStyleContext *context) +{ + GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); + + g_return_if_fail (priv->saved_nodes != NULL); + + if (GTK_IS_CSS_TRANSIENT_NODE (priv->cssnode)) + gtk_css_node_set_parent (priv->cssnode, NULL); + g_object_unref (priv->cssnode); + priv->cssnode = priv->saved_nodes->data; + priv->saved_nodes = g_slist_remove (priv->saved_nodes, priv->cssnode); +} + +static void +gtk_style_context_cascade_changed (GtkStyleCascade *cascade, + GtkStyleContext *context) +{ + gtk_css_node_invalidate_style_provider (gtk_style_context_get_root (context)); +} + +static void +gtk_style_context_set_cascade (GtkStyleContext *context, + GtkStyleCascade *cascade) +{ + GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); + + if (priv->cascade == cascade) + return; + + if (priv->cascade) + { + g_signal_handler_disconnect (priv->cascade, priv->cascade_changed_id); + priv->cascade_changed_id = 0; + g_object_unref (priv->cascade); + } + + if (cascade) + { + g_object_ref (cascade); + priv->cascade_changed_id = g_signal_connect (cascade, + "gtk-private-changed", + G_CALLBACK (gtk_style_context_cascade_changed), + context); + } + + priv->cascade = cascade; + + if (cascade && priv->cssnode != NULL) + gtk_style_context_cascade_changed (cascade, context); +} + +static void +gtk_style_context_init (GtkStyleContext *context) +{ + GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); + + priv->display = gdk_display_get_default (); + + if (priv->display == NULL) + g_error ("Can't create a GtkStyleContext without a display connection"); + + gtk_style_context_set_cascade (context, + _gtk_settings_get_style_cascade (gtk_settings_get_for_display (priv->display), 1)); +} + +static void +gtk_style_context_finalize (GObject *object) +{ + GtkStyleContext *context = GTK_STYLE_CONTEXT (object); + GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); + + while (priv->saved_nodes) + gtk_style_context_pop_style_node (context); + + gtk_style_context_set_cascade (context, NULL); + + if (priv->cssnode) + g_object_unref (priv->cssnode); + + G_OBJECT_CLASS (gtk_style_context_parent_class)->finalize (object); +} + +static void +gtk_style_context_impl_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + GtkStyleContext *context = GTK_STYLE_CONTEXT (object); + + switch (prop_id) + { + case PROP_DISPLAY: +G_GNUC_BEGIN_IGNORE_DEPRECATIONS + gtk_style_context_set_display (context, g_value_get_object (value)); +G_GNUC_END_IGNORE_DEPRECATIONS + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gtk_style_context_impl_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + GtkStyleContext *context = GTK_STYLE_CONTEXT (object); + GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); + + switch (prop_id) + { + case PROP_DISPLAY: + g_value_set_object (value, priv->display); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +/* returns TRUE if someone called gtk_style_context_save() but hasn’t + * called gtk_style_context_restore() yet. + * In those situations we don’t invalidate the context when somebody + * changes state/classes. + */ +static gboolean +gtk_style_context_is_saved (GtkStyleContext *context) +{ + GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); + + return priv->saved_nodes != NULL; +} + +static GtkCssNode * +gtk_style_context_get_root (GtkStyleContext *context) +{ + GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); + + if (priv->saved_nodes != NULL) + return g_slist_last (priv->saved_nodes)->data; + else + return priv->cssnode; +} + +GtkStyleProvider * +gtk_style_context_get_style_provider (GtkStyleContext *context) +{ + GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); + + return GTK_STYLE_PROVIDER (priv->cascade); +} + +static gboolean +gtk_style_context_has_custom_cascade (GtkStyleContext *context) +{ + GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); + GtkSettings *settings = gtk_settings_get_for_display (priv->display); + + return priv->cascade != _gtk_settings_get_style_cascade (settings, _gtk_style_cascade_get_scale (priv->cascade)); +} + +GtkCssStyle * +gtk_style_context_lookup_style (GtkStyleContext *context) +{ + GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); + + /* Code will recreate style if it was changed */ + return gtk_css_node_get_style (priv->cssnode); +} + +GtkCssNode* +gtk_style_context_get_node (GtkStyleContext *context) +{ + GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); + + return priv->cssnode; +} + +GtkStyleContext * +gtk_style_context_new_for_node (GtkCssNode *node) +{ + GtkStyleContext *context; + GtkStyleContextPrivate *priv; + + g_return_val_if_fail (GTK_IS_CSS_NODE (node), NULL); + + context = g_object_new (GTK_TYPE_STYLE_CONTEXT, NULL); + priv = gtk_style_context_get_instance_private (context); + priv->cssnode = g_object_ref (node); + + return context; +} + +/** + * gtk_style_context_add_provider: + * @context: a `GtkStyleContext` + * @provider: a `GtkStyleProvider` + * @priority: the priority of the style provider. The lower + * it is, the earlier it will be used in the style construction. + * Typically this will be in the range between + * %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK and + * %GTK_STYLE_PROVIDER_PRIORITY_USER + * + * Adds a style provider to @context, to be used in style construction. + * + * Note that a style provider added by this function only affects + * the style of the widget to which @context belongs. If you want + * to affect the style of all widgets, use + * [func@Gtk.StyleContext.add_provider_for_display]. + * + * Note: If both priorities are the same, a `GtkStyleProvider` + * added through this function takes precedence over another added + * through [func@Gtk.StyleContext.add_provider_for_display]. + * + * Deprecated: 4.10: Use style classes instead + */ +void +gtk_style_context_add_provider (GtkStyleContext *context, + GtkStyleProvider *provider, + guint priority) +{ + GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); + + g_return_if_fail (GTK_IS_STYLE_CONTEXT (context)); + g_return_if_fail (GTK_IS_STYLE_PROVIDER (provider)); + + if (!gtk_style_context_has_custom_cascade (context)) + { + GtkStyleCascade *new_cascade; + + new_cascade = _gtk_style_cascade_new (); + _gtk_style_cascade_set_scale (new_cascade, _gtk_style_cascade_get_scale (priv->cascade)); + _gtk_style_cascade_set_parent (new_cascade, + _gtk_settings_get_style_cascade (gtk_settings_get_for_display (priv->display), 1)); + _gtk_style_cascade_add_provider (new_cascade, provider, priority); + gtk_style_context_set_cascade (context, new_cascade); + g_object_unref (new_cascade); + } + else + { + _gtk_style_cascade_add_provider (priv->cascade, provider, priority); + } +} + +/** + * gtk_style_context_remove_provider: + * @context: a `GtkStyleContext` + * @provider: a `GtkStyleProvider` + * + * Removes @provider from the style providers list in @context. + * + * Deprecated: 4.10 + */ +void +gtk_style_context_remove_provider (GtkStyleContext *context, + GtkStyleProvider *provider) +{ + GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); + + g_return_if_fail (GTK_IS_STYLE_CONTEXT (context)); + g_return_if_fail (GTK_IS_STYLE_PROVIDER (provider)); + + if (!gtk_style_context_has_custom_cascade (context)) + return; + + _gtk_style_cascade_remove_provider (priv->cascade, provider); +} + +/** + * gtk_style_context_set_state: + * @context: a `GtkStyleContext` + * @flags: state to represent + * + * Sets the state to be used for style matching. + * + * Deprecated: 4.10: You should not use this api + */ +void +gtk_style_context_set_state (GtkStyleContext *context, + GtkStateFlags flags) +{ + GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); + + g_return_if_fail (GTK_IS_STYLE_CONTEXT (context)); + + gtk_css_node_set_state (priv->cssnode, flags); +} + +/** + * gtk_style_context_get_state: + * @context: a `GtkStyleContext` + * + * Returns the state used for style matching. + * + * This method should only be used to retrieve the `GtkStateFlags` + * to pass to `GtkStyleContext` methods, like + * [method@Gtk.StyleContext.get_padding]. + * If you need to retrieve the current state of a `GtkWidget`, use + * [method@Gtk.Widget.get_state_flags]. + * + * Returns: the state flags + * + * Deprecated: 4.10: Use [method@Gtk.Widget.get_state_flags] instead + **/ +GtkStateFlags +gtk_style_context_get_state (GtkStyleContext *context) +{ + GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); + + g_return_val_if_fail (GTK_IS_STYLE_CONTEXT (context), 0); + + return gtk_css_node_get_state (priv->cssnode); +} + +/** + * gtk_style_context_set_scale: + * @context: a `GtkStyleContext` + * @scale: scale + * + * Sets the scale to use when getting image assets for the style. + * + * Deprecated: 4.10: You should not use this api + **/ +void +gtk_style_context_set_scale (GtkStyleContext *context, + int scale) +{ + GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); + + g_return_if_fail (GTK_IS_STYLE_CONTEXT (context)); + + if (scale == _gtk_style_cascade_get_scale (priv->cascade)) + return; + + if (gtk_style_context_has_custom_cascade (context)) + { + _gtk_style_cascade_set_scale (priv->cascade, scale); + } + else + { + GtkStyleCascade *new_cascade; + + new_cascade = _gtk_settings_get_style_cascade (gtk_settings_get_for_display (priv->display), + scale); + gtk_style_context_set_cascade (context, new_cascade); + } +} + +/** + * gtk_style_context_get_scale: + * @context: a `GtkStyleContext` + * + * Returns the scale used for assets. + * + * Returns: the scale + * + * Deprecated 4.10: Use [method@Gtk.Widget.get_scale_factor] instead + **/ +int +gtk_style_context_get_scale (GtkStyleContext *context) +{ + GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); + + g_return_val_if_fail (GTK_IS_STYLE_CONTEXT (context), 0); + + return _gtk_style_cascade_get_scale (priv->cascade); +} + +/* + * gtk_style_context_save_to_node: + * @context: a `GtkStyleContext` + * @node: the node to save to + * + * Saves the @context state to a node. + * + * This allows temporary modifications done through + * [method@Gtk.StyleContext.add_class], + * [method@Gtk.StyleContext.remove_class], + * [method@Gtk.StyleContext.set_state] etc. + * + * Rendering using [func@Gtk.render_background] or similar + * functions are done using the given @node. + * + * To undo, call [method@Gtk.StyleContext.restore]. + * The matching call to [method@Gtk.StyleContext.restore] + * must be done before GTK returns to the main loop. + */ +void +gtk_style_context_save_to_node (GtkStyleContext *context, + GtkCssNode *node) +{ + GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); + + g_return_if_fail (GTK_IS_STYLE_CONTEXT (context)); + g_return_if_fail (GTK_IS_CSS_NODE (node)); + + priv->saved_nodes = g_slist_prepend (priv->saved_nodes, priv->cssnode); + priv->cssnode = g_object_ref (node); +} + +/** + * gtk_style_context_save: + * @context: a `GtkStyleContext` + * + * Saves the @context state. + * + * This allows temporary modifications done through + * [method@Gtk.StyleContext.add_class], + * [method@Gtk.StyleContext.remove_class], + * [method@Gtk.StyleContext.set_state] to be quickly + * reverted in one go through [method@Gtk.StyleContext.restore]. + * + * The matching call to [method@Gtk.StyleContext.restore] + * must be done before GTK returns to the main loop. + * + * Deprecated: 4.10: This API will be removed in GTK 5 + **/ +void +gtk_style_context_save (GtkStyleContext *context) +{ + GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); + GtkCssNode *cssnode; + + g_return_if_fail (GTK_IS_STYLE_CONTEXT (context)); + + + /* Make sure we have the style existing. It is the + * parent of the new saved node after all. + */ + if (!gtk_style_context_is_saved (context)) + gtk_style_context_lookup_style (context); + + cssnode = gtk_css_transient_node_new (priv->cssnode); + gtk_css_node_set_parent (cssnode, gtk_style_context_get_root (context)); + gtk_style_context_save_to_node (context, cssnode); + + g_object_unref (cssnode); +} + +/** + * gtk_style_context_restore: + * @context: a `GtkStyleContext` + * + * Restores @context state to a previous stage. + * + * See [method@Gtk.StyleContext.save]. + * + * Deprecated: 4.10: This API will be removed in GTK 5 + **/ +void +gtk_style_context_restore (GtkStyleContext *context) +{ + GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); + + g_return_if_fail (GTK_IS_STYLE_CONTEXT (context)); + + if (priv->saved_nodes == NULL) + { + g_warning ("Unpaired gtk_style_context_restore() call"); + return; + } + + gtk_style_context_pop_style_node (context); +} + +/** + * gtk_style_context_add_class: + * @context: a `GtkStyleContext` + * @class_name: class name to use in styling + * + * Adds a style class to @context, so later uses of the + * style context will make use of this new class for styling. + * + * In the CSS file format, a `GtkEntry` defining a “search” + * class, would be matched by: + * + * ```css + * entry.search { ... } + * ``` + * + * While any widget defining a “search” class would be + * matched by: + * ```css + * .search { ... } + * ``` + * Deprecated: 4.10: Use [method@Gtk.Widget.add_css_class] instead + */ +void +gtk_style_context_add_class (GtkStyleContext *context, + const char *class_name) +{ + GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); + GQuark class_quark; + + g_return_if_fail (GTK_IS_STYLE_CONTEXT (context)); + g_return_if_fail (class_name != NULL); + + class_quark = g_quark_from_string (class_name); + + gtk_css_node_add_class (priv->cssnode, class_quark); +} + +/** + * gtk_style_context_remove_class: + * @context: a `GtkStyleContext` + * @class_name: class name to remove + * + * Removes @class_name from @context. + * + * Deprecated: 4.10: Use [method@Gtk.Widget.remove_css_class] instead + */ +void +gtk_style_context_remove_class (GtkStyleContext *context, + const char *class_name) +{ + GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); + GQuark class_quark; + + g_return_if_fail (GTK_IS_STYLE_CONTEXT (context)); + g_return_if_fail (class_name != NULL); + + class_quark = g_quark_try_string (class_name); + if (!class_quark) + return; + + gtk_css_node_remove_class (priv->cssnode, class_quark); +} + +/** + * gtk_style_context_has_class: + * @context: a `GtkStyleContext` + * @class_name: a class name + * + * Returns %TRUE if @context currently has defined the + * given class name. + * + * Returns: %TRUE if @context has @class_name defined + * + * Deprecated: 4.10: Use [method@Gtk.Widget.has_css_class] instead + **/ +gboolean +gtk_style_context_has_class (GtkStyleContext *context, + const char *class_name) +{ + GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); + GQuark class_quark; + + g_return_val_if_fail (GTK_IS_STYLE_CONTEXT (context), FALSE); + g_return_val_if_fail (class_name != NULL, FALSE); + + class_quark = g_quark_try_string (class_name); + if (!class_quark) + return FALSE; + + return gtk_css_node_has_class (priv->cssnode, class_quark); +} + +GtkCssValue * +_gtk_style_context_peek_property (GtkStyleContext *context, + guint property_id) +{ + GtkCssStyle *values = gtk_style_context_lookup_style (context); + + return gtk_css_style_get_value (values, property_id); +} + +/** + * gtk_style_context_set_display: + * @context: a `GtkStyleContext` + * @display: a `GdkDisplay` + * + * Attaches @context to the given display. + * + * The display is used to add style information from “global” + * style providers, such as the display's `GtkSettings` instance. + * + * If you are using a `GtkStyleContext` returned from + * [method@Gtk.Widget.get_style_context], you do not need to + * call this yourself. + * + * Deprecated: 4.10: You should not use this api + */ +void +gtk_style_context_set_display (GtkStyleContext *context, + GdkDisplay *display) +{ + GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); + GtkStyleCascade *display_cascade; + + g_return_if_fail (GTK_IS_STYLE_CONTEXT (context)); + g_return_if_fail (GDK_IS_DISPLAY (display)); + + if (priv->display == display) + return; + + if (gtk_style_context_has_custom_cascade (context)) + { + display_cascade = _gtk_settings_get_style_cascade (gtk_settings_get_for_display (display), 1); + _gtk_style_cascade_set_parent (priv->cascade, display_cascade); + } + else + { + display_cascade = _gtk_settings_get_style_cascade (gtk_settings_get_for_display (display), + _gtk_style_cascade_get_scale (priv->cascade)); + gtk_style_context_set_cascade (context, display_cascade); + } + + priv->display = display; + + g_object_notify_by_pspec (G_OBJECT (context), properties[PROP_DISPLAY]); +} + +/** + * gtk_style_context_get_display: + * @context: a `GtkStyleContext` + * + * Returns the `GdkDisplay` to which @context is attached. + * + * Returns: (transfer none): a `GdkDisplay`. + * + * Deprecated: 4.10: Use [method@Gtk.Widget.get_display] instead + */ +GdkDisplay * +gtk_style_context_get_display (GtkStyleContext *context) +{ + GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); + + g_return_val_if_fail (GTK_IS_STYLE_CONTEXT (context), NULL); + + return priv->display; +} + +static gboolean +gtk_style_context_resolve_color (GtkStyleContext *context, + GtkCssValue *color, + GdkRGBA *result) +{ + GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); + GtkCssValue *val; + + g_return_val_if_fail (GTK_IS_STYLE_CONTEXT (context), FALSE); + g_return_val_if_fail (color != NULL, FALSE); + g_return_val_if_fail (result != NULL, FALSE); + + val = _gtk_css_color_value_resolve (color, + GTK_STYLE_PROVIDER (priv->cascade), + _gtk_style_context_peek_property (context, GTK_CSS_PROPERTY_COLOR), + NULL); + if (val == NULL) + return FALSE; + + *result = *gtk_css_color_value_get_rgba (val); + _gtk_css_value_unref (val); + return TRUE; +} + +/** + * gtk_style_context_lookup_color: + * @context: a `GtkStyleContext` + * @color_name: color name to lookup + * @color: (out): Return location for the looked up color + * + * Looks up and resolves a color name in the @context color map. + * + * Returns: %TRUE if @color_name was found and resolved, %FALSE otherwise + * + * Deprecated: 4.10: This api will be removed in GTK 5 + */ +gboolean +gtk_style_context_lookup_color (GtkStyleContext *context, + const char *color_name, + GdkRGBA *color) +{ + GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); + GtkCssValue *value; + + g_return_val_if_fail (GTK_IS_STYLE_CONTEXT (context), FALSE); + g_return_val_if_fail (color_name != NULL, FALSE); + g_return_val_if_fail (color != NULL, FALSE); + + value = gtk_style_provider_get_color (GTK_STYLE_PROVIDER (priv->cascade), color_name); + if (value == NULL) + return FALSE; + + return gtk_style_context_resolve_color (context, value, color); +} + +/** + * gtk_style_context_get_color: + * @context: a `GtkStyleContext` + * @color: (out): return value for the foreground color + * + * Gets the foreground color for a given state. + * + * Deprecated: 4.10: This api will be removed in GTK 5 + */ +void +gtk_style_context_get_color (GtkStyleContext *context, + GdkRGBA *color) +{ + g_return_if_fail (color != NULL); + g_return_if_fail (GTK_IS_STYLE_CONTEXT (context)); + + *color = *gtk_css_color_value_get_rgba (_gtk_style_context_peek_property (context, GTK_CSS_PROPERTY_COLOR)); +} + +/** + * gtk_style_context_get_border: + * @context: a `GtkStyleContext` + * @border: (out): return value for the border settings + * + * Gets the border for a given state as a `GtkBorder`. + * + * Deprecated: 4.10: This api will be removed in GTK 5 + */ +void +gtk_style_context_get_border (GtkStyleContext *context, + GtkBorder *border) +{ + GtkCssStyle *style; + + g_return_if_fail (border != NULL); + g_return_if_fail (GTK_IS_STYLE_CONTEXT (context)); + + style = gtk_style_context_lookup_style (context); + + border->top = round (_gtk_css_number_value_get (style->border->border_top_width, 100)); + border->right = round (_gtk_css_number_value_get (style->border->border_right_width, 100)); + border->bottom = round (_gtk_css_number_value_get (style->border->border_bottom_width, 100)); + border->left = round (_gtk_css_number_value_get (style->border->border_left_width, 100)); +} + +/** + * gtk_style_context_get_padding: + * @context: a `GtkStyleContext` + * @padding: (out): return value for the padding settings + * + * Gets the padding for a given state as a `GtkBorder`. + * + * Deprecated: 4.10: This api will be removed in GTK 5 + */ +void +gtk_style_context_get_padding (GtkStyleContext *context, + GtkBorder *padding) +{ + GtkCssStyle *style; + + g_return_if_fail (padding != NULL); + g_return_if_fail (GTK_IS_STYLE_CONTEXT (context)); + + style = gtk_style_context_lookup_style (context); + + padding->top = round (_gtk_css_number_value_get (style->size->padding_top, 100)); + padding->right = round (_gtk_css_number_value_get (style->size->padding_right, 100)); + padding->bottom = round (_gtk_css_number_value_get (style->size->padding_bottom, 100)); + padding->left = round (_gtk_css_number_value_get (style->size->padding_left, 100)); +} + +/** + * gtk_style_context_get_margin: + * @context: a `GtkStyleContext` + * @margin: (out): return value for the margin settings + * + * Gets the margin for a given state as a `GtkBorder`. + * + * Deprecated: 4.10: This api will be removed in GTK 5 + */ +void +gtk_style_context_get_margin (GtkStyleContext *context, + GtkBorder *margin) +{ + GtkCssStyle *style; + + g_return_if_fail (margin != NULL); + g_return_if_fail (GTK_IS_STYLE_CONTEXT (context)); + + style = gtk_style_context_lookup_style (context); + + margin->top = round (_gtk_css_number_value_get (style->size->margin_top, 100)); + margin->right = round (_gtk_css_number_value_get (style->size->margin_right, 100)); + margin->bottom = round (_gtk_css_number_value_get (style->size->margin_bottom, 100)); + margin->left = round (_gtk_css_number_value_get (style->size->margin_left, 100)); +} + +void +_gtk_style_context_get_cursor_color (GtkStyleContext *context, + GdkRGBA *primary_color, + GdkRGBA *secondary_color) +{ + GtkCssStyle *style; + + style = gtk_style_context_lookup_style (context); + + if (primary_color) + *primary_color = *gtk_css_color_value_get_rgba (style->font->caret_color ? style->font->caret_color : style->core->color); + + if (secondary_color) + *secondary_color = *gtk_css_color_value_get_rgba (style->font->secondary_caret_color ? style->font->secondary_caret_color : style->core->color); +} + +/** + * GtkStyleContextPrintFlags: + * @GTK_STYLE_CONTEXT_PRINT_NONE: Default value. + * @GTK_STYLE_CONTEXT_PRINT_RECURSE: Print the entire tree of + * CSS nodes starting at the style context's node + * @GTK_STYLE_CONTEXT_PRINT_SHOW_STYLE: Show the values of the + * CSS properties for each node + * @GTK_STYLE_CONTEXT_PRINT_SHOW_CHANGE: Show information about + * what changes affect the styles + * + * Flags that modify the behavior of gtk_style_context_to_string(). + * + * New values may be added to this enumeration. + */ + +/** + * gtk_style_context_to_string: + * @context: a `GtkStyleContext` + * @flags: Flags that determine what to print + * + * Converts the style context into a string representation. + * + * The string representation always includes information about + * the name, state, id, visibility and style classes of the CSS + * node that is backing @context. Depending on the flags, more + * information may be included. + * + * This function is intended for testing and debugging of the + * CSS implementation in GTK. There are no guarantees about + * the format of the returned string, it may change. + * + * Returns: a newly allocated string representing @context + * + * Deprecated: 4.10: This api will be removed in GTK 5 + */ +char * +gtk_style_context_to_string (GtkStyleContext *context, + GtkStyleContextPrintFlags flags) +{ + GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); + GString *string; + + g_return_val_if_fail (GTK_IS_STYLE_CONTEXT (context), NULL); + + string = g_string_new (""); + + gtk_css_node_print (priv->cssnode, flags, string, 0); + + return g_string_free (string, FALSE); +} diff --git a/gtk/deprecated/gtkstylecontext.h b/gtk/deprecated/gtkstylecontext.h new file mode 100644 index 0000000000..b1e9244034 --- /dev/null +++ b/gtk/deprecated/gtkstylecontext.h @@ -0,0 +1,140 @@ +/* GTK - The GIMP Toolkit + * Copyright (C) 2010 Carlos Garnacho + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. If not, see . + */ + +#ifndef __GTK_STYLE_CONTEXT_H__ +#define __GTK_STYLE_CONTEXT_H__ + +#if !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION) +#error "Only can be included directly." +#endif + +#include + +#include +#include +#include + +G_BEGIN_DECLS + +#define GTK_TYPE_STYLE_CONTEXT (gtk_style_context_get_type ()) +#define GTK_STYLE_CONTEXT(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_STYLE_CONTEXT, GtkStyleContext)) +#define GTK_STYLE_CONTEXT_CLASS(c) (G_TYPE_CHECK_CLASS_CAST ((c), GTK_TYPE_STYLE_CONTEXT, GtkStyleContextClass)) +#define GTK_IS_STYLE_CONTEXT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_STYLE_CONTEXT)) +#define GTK_IS_STYLE_CONTEXT_CLASS(c) (G_TYPE_CHECK_CLASS_TYPE ((c), GTK_TYPE_STYLE_CONTEXT)) +#define GTK_STYLE_CONTEXT_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_STYLE_CONTEXT, GtkStyleContextClass)) + +typedef struct _GtkStyleContextClass GtkStyleContextClass; + +struct _GtkStyleContext +{ + GObject parent_object; +}; + +struct _GtkStyleContextClass +{ + GObjectClass parent_class; + + void (* changed) (GtkStyleContext *context); + + /* Padding for future expansion */ + void (*_gtk_reserved1) (void); + void (*_gtk_reserved2) (void); + void (*_gtk_reserved3) (void); + void (*_gtk_reserved4) (void); +}; + + +GDK_AVAILABLE_IN_ALL +GType gtk_style_context_get_type (void) G_GNUC_CONST; + +GDK_DEPRECATED_IN_4_10 +void gtk_style_context_add_provider (GtkStyleContext *context, + GtkStyleProvider *provider, + guint priority); + +GDK_DEPRECATED_IN_4_10 +void gtk_style_context_remove_provider (GtkStyleContext *context, + GtkStyleProvider *provider); + +GDK_DEPRECATED_IN_4_10 +void gtk_style_context_save (GtkStyleContext *context); +GDK_DEPRECATED_IN_4_10 +void gtk_style_context_restore (GtkStyleContext *context); + +GDK_DEPRECATED_IN_4_10 +void gtk_style_context_set_state (GtkStyleContext *context, + GtkStateFlags flags); +GDK_DEPRECATED_IN_4_10 +GtkStateFlags gtk_style_context_get_state (GtkStyleContext *context); + +GDK_DEPRECATED_IN_4_10 +void gtk_style_context_set_scale (GtkStyleContext *context, + int scale); +GDK_DEPRECATED_IN_4_10 +int gtk_style_context_get_scale (GtkStyleContext *context); + +GDK_DEPRECATED_IN_4_10 +void gtk_style_context_add_class (GtkStyleContext *context, + const char *class_name); +GDK_DEPRECATED_IN_4_10 +void gtk_style_context_remove_class (GtkStyleContext *context, + const char *class_name); +GDK_DEPRECATED_IN_4_10 +gboolean gtk_style_context_has_class (GtkStyleContext *context, + const char *class_name); + +GDK_DEPRECATED_IN_4_10 +void gtk_style_context_set_display (GtkStyleContext *context, + GdkDisplay *display); +GDK_DEPRECATED_IN_4_10 +GdkDisplay *gtk_style_context_get_display (GtkStyleContext *context); + +GDK_DEPRECATED_IN_4_10 +gboolean gtk_style_context_lookup_color (GtkStyleContext *context, + const char *color_name, + GdkRGBA *color); + +/* Some helper functions to retrieve most common properties */ +GDK_DEPRECATED_IN_4_10 +void gtk_style_context_get_color (GtkStyleContext *context, + GdkRGBA *color); +GDK_DEPRECATED_IN_4_10 +void gtk_style_context_get_border (GtkStyleContext *context, + GtkBorder *border); +GDK_DEPRECATED_IN_4_10 +void gtk_style_context_get_padding (GtkStyleContext *context, + GtkBorder *padding); +GDK_DEPRECATED_IN_4_10 +void gtk_style_context_get_margin (GtkStyleContext *context, + GtkBorder *margin); + +typedef enum { + GTK_STYLE_CONTEXT_PRINT_NONE = 0, + GTK_STYLE_CONTEXT_PRINT_RECURSE = 1 << 0, + GTK_STYLE_CONTEXT_PRINT_SHOW_STYLE = 1 << 1, + GTK_STYLE_CONTEXT_PRINT_SHOW_CHANGE = 1 << 2 +} GtkStyleContextPrintFlags; + +GDK_DEPRECATED_IN_4_10 +char * gtk_style_context_to_string (GtkStyleContext *context, + GtkStyleContextPrintFlags flags); + +G_DEFINE_AUTOPTR_CLEANUP_FUNC(GtkStyleContext, g_object_unref) + +G_END_DECLS + +#endif /* __GTK_STYLE_CONTEXT_H__ */ diff --git a/gtk/deprecated/gtkstylecontextprivate.h b/gtk/deprecated/gtkstylecontextprivate.h new file mode 100644 index 0000000000..4cab724b20 --- /dev/null +++ b/gtk/deprecated/gtkstylecontextprivate.h @@ -0,0 +1,47 @@ +/* GTK - The GIMP Toolkit + * Copyright (C) 2010 Carlos Garnacho + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library. If not, see . + */ + +#ifndef __GTK_STYLE_CONTEXT_PRIVATE_H__ +#define __GTK_STYLE_CONTEXT_PRIVATE_H__ + +#include "gtkstylecontext.h" + +#include "gtkcssnodeprivate.h" +#include "gtkstyleproviderprivate.h" +#include "gtkcssvalueprivate.h" + +G_BEGIN_DECLS + +GtkStyleContext *gtk_style_context_new_for_node (GtkCssNode *node); + +GtkCssNode *gtk_style_context_get_node (GtkStyleContext *context); +GtkStyleProvider * + gtk_style_context_get_style_provider (GtkStyleContext *context); + +void gtk_style_context_save_to_node (GtkStyleContext *context, + GtkCssNode *node); + +GtkCssStyle * gtk_style_context_lookup_style (GtkStyleContext *context); +GtkCssValue * _gtk_style_context_peek_property (GtkStyleContext *context, + guint property_id); +void _gtk_style_context_get_cursor_color (GtkStyleContext *context, + GdkRGBA *primary_color, + GdkRGBA *secondary_color); + +G_END_DECLS + +#endif /* __GTK_STYLE_CONTEXT_PRIVATE_H__ */ diff --git a/gtk/deprecated/meson.build b/gtk/deprecated/meson.build index f6f90dd64b..cd5b182170 100644 --- a/gtk/deprecated/meson.build +++ b/gtk/deprecated/meson.build @@ -25,6 +25,7 @@ gtk_deprecated_sources = [ 'deprecated/gtkiconview.c', 'deprecated/gtkliststore.c', 'deprecated/gtkrender.c', + 'deprecated/gtkstylecontext.c', 'deprecated/gtktreedatalist.c', 'deprecated/gtktreednd.c', 'deprecated/gtktreemodel.c', @@ -65,6 +66,7 @@ gtk_deprecated_headers = [ 'deprecated/gtkiconview.h', 'deprecated/gtkliststore.h', 'deprecated/gtkrender.h', + 'deprecated/gtkstylecontext.h', 'deprecated/gtktreednd.h', 'deprecated/gtktreemodel.h', 'deprecated/gtktreemodelfilter.h', diff --git a/gtk/gtk.h b/gtk/gtk.h index 0bbc5455c4..cf139b5dda 100644 --- a/gtk/gtk.h +++ b/gtk/gtk.h @@ -247,7 +247,7 @@ #include #include #include -#include +#include #include #include #include diff --git a/gtk/gtkcsscolorvalue.c b/gtk/gtkcsscolorvalue.c index 5430489401..4b0b4adfe4 100644 --- a/gtk/gtkcsscolorvalue.c +++ b/gtk/gtkcsscolorvalue.c @@ -22,6 +22,8 @@ #include "gtkcssstylepropertyprivate.h" #include "gtkprivate.h" #include "gtkstylepropertyprivate.h" +#include "gtkcssstyleprivate.h" +#include "gtkstyleproviderprivate.h" #include "gdk/gdkhslaprivate.h" #include "gdk/gdkrgbaprivate.h" diff --git a/gtk/gtkcsskeyframes.c b/gtk/gtkcsskeyframes.c index 33d71ef067..89c4b0b409 100644 --- a/gtk/gtkcsskeyframes.c +++ b/gtk/gtkcsskeyframes.c @@ -19,6 +19,7 @@ #include "gtkcsskeyframesprivate.h" +#include "gtkcssstyleprivate.h" #include "gtkcssarrayvalueprivate.h" #include "gtkcssshorthandpropertyprivate.h" #include "gtkcssstylepropertyprivate.h" diff --git a/gtk/gtkcssnodeprivate.h b/gtk/gtkcssnodeprivate.h index e696ec49bc..c713a87df6 100644 --- a/gtk/gtkcssnodeprivate.h +++ b/gtk/gtkcssnodeprivate.h @@ -24,7 +24,7 @@ #include "gtkcssstylechangeprivate.h" #include "gtkbitmaskprivate.h" #include "gtkcsstypesprivate.h" -#include "gtkstylecontext.h" +#include "deprecated/gtkstylecontext.h" #include "gtklistlistmodelprivate.h" G_BEGIN_DECLS diff --git a/gtk/gtkcssselector.c b/gtk/gtkcssselector.c index 158110c2d1..207d83ac7d 100644 --- a/gtk/gtkcssselector.c +++ b/gtk/gtkcssselector.c @@ -18,12 +18,12 @@ #include "config.h" #include "gtkcssselectorprivate.h" +#include "gtkcssnodeprivate.h" #include #include #include "gtkcssprovider.h" -#include "gtkstylecontextprivate.h" #include #if defined(_MSC_VER) && _MSC_VER >= 1500 diff --git a/gtk/gtkcsstypes.c b/gtk/gtkcsstypes.c index fcbb47ca8d..a4de027420 100644 --- a/gtk/gtkcsstypes.c +++ b/gtk/gtkcsstypes.c @@ -20,7 +20,6 @@ #include "gtkcsstypesprivate.h" #include "gtkcssnumbervalueprivate.h" -#include "gtkstylecontextprivate.h" void gtk_css_change_print (GtkCssChange change, diff --git a/gtk/gtkcsswidgetnode.c b/gtk/gtkcsswidgetnode.c index fcc7682832..c63e367bb5 100644 --- a/gtk/gtkcsswidgetnode.c +++ b/gtk/gtkcsswidgetnode.c @@ -22,7 +22,7 @@ #include "gtkcssanimatedstyleprivate.h" #include "gtkprivate.h" #include "gtksettingsprivate.h" -#include "gtkstylecontextprivate.h" +#include "deprecated/gtkstylecontextprivate.h" #include "gtkwidgetprivate.h" #include "gtkwindowprivate.h" diff --git a/gtk/gtkicontheme.c b/gtk/gtkicontheme.c index 2c66e54ea8..c585d7bef8 100644 --- a/gtk/gtkicontheme.c +++ b/gtk/gtkicontheme.c @@ -48,7 +48,6 @@ #include "gtkprivate.h" #include "gtksettingsprivate.h" #include "gtksnapshot.h" -#include "gtkstylecontextprivate.h" #include "gtkstyleproviderprivate.h" #include "gtksymbolicpaintable.h" #include "gtkwidgetprivate.h" diff --git a/gtk/gtkimcontextime.c b/gtk/gtkimcontextime.c index e341925733..33a69f45c5 100644 --- a/gtk/gtkimcontextime.c +++ b/gtk/gtkimcontextime.c @@ -36,7 +36,7 @@ #include "gdk/gdkkeysyms.h" #include "gdk/win32/gdkwin32.h" #include "gtk/gtkimmodule.h" -#include "gtk/gtkstylecontextprivate.h" +#include "gtk/deprecated/gtkstylecontextprivate.h" #include "gtk/gtkcssstyleprivate.h" /* avoid warning */ diff --git a/gtk/gtknotebook.c b/gtk/gtknotebook.c index 7e75048ce8..7593a1fe63 100644 --- a/gtk/gtknotebook.c +++ b/gtk/gtknotebook.c @@ -45,7 +45,6 @@ #include "gtkpopovermenuprivate.h" #include "gtkorientable.h" #include "gtksizerequest.h" -#include "gtkstylecontextprivate.h" #include "gtkprivate.h" #include "gtkstack.h" #include "gtktypebuiltins.h" diff --git a/gtk/gtkpopovercontent.c b/gtk/gtkpopovercontent.c index 49b0e4a330..06ca8d38eb 100644 --- a/gtk/gtkpopovercontent.c +++ b/gtk/gtkpopovercontent.c @@ -21,8 +21,8 @@ #include "config.h" #include "gtkpopovercontentprivate.h" -#include "gtkstylecontextprivate.h" +#include "gtkcssstylechangeprivate.h" #include "gtkwidgetprivate.h" #include "gtkprivate.h" diff --git a/gtk/gtksettings.c b/gtk/gtksettings.c index d6b97a882e..6215455323 100644 --- a/gtk/gtksettings.c +++ b/gtk/gtksettings.c @@ -23,7 +23,7 @@ #include "gtkcssproviderprivate.h" #include "gtkprivate.h" #include "gtkscrolledwindow.h" -#include "gtkstylecontextprivate.h" +#include "deprecated/gtkstylecontextprivate.h" #include "gtkstyleproviderprivate.h" #include "gtktypebuiltins.h" #include "gtkversion.h" diff --git a/gtk/gtksnapshot.c b/gtk/gtksnapshot.c index 90cbbb8833..7c17a60728 100644 --- a/gtk/gtksnapshot.c +++ b/gtk/gtksnapshot.c @@ -24,7 +24,6 @@ #include "gtkcssshadowvalueprivate.h" #include "gtkdebug.h" #include "gtkrendernodepaintableprivate.h" -#include "gtkstylecontextprivate.h" #include "gsktransformprivate.h" #include "gdk/gdkrgbaprivate.h" diff --git a/gtk/gtkstylecontext.c b/gtk/gtkstylecontext.c deleted file mode 100644 index 18c90bf0d9..0000000000 --- a/gtk/gtkstylecontext.c +++ /dev/null @@ -1,999 +0,0 @@ -/* GTK - The GIMP Toolkit - * Copyright (C) 2010 Carlos Garnacho - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - */ - -#include "config.h" - -#include "gtkstylecontextprivate.h" - -#include - -#include "gtkcsscolorvalueprivate.h" -#include "gtkcssnumbervalueprivate.h" -#include "gtkcsstransientnodeprivate.h" -#include "gtkdebug.h" -#include "gtkprivate.h" -#include "gtksettings.h" -#include "gtksettingsprivate.h" -#include "deprecated/gtkrender.h" - - -/** - * GtkStyleContext: - * - * `GtkStyleContext` stores styling information affecting a widget. - * - * In order to construct the final style information, `GtkStyleContext` - * queries information from all attached `GtkStyleProviders`. Style - * providers can be either attached explicitly to the context through - * [method@Gtk.StyleContext.add_provider], or to the display through - * [func@Gtk.StyleContext.add_provider_for_display]. The resulting - * style is a combination of all providers’ information in priority order. - * - * For GTK widgets, any `GtkStyleContext` returned by - * [method@Gtk.Widget.get_style_context] will already have a `GdkDisplay` - * and RTL/LTR information set. The style context will also be updated - * automatically if any of these settings change on the widget. - * - * # Style Classes - * - * Widgets can add style classes to their context, which can be used to associate - * different styles by class. The documentation for individual widgets lists - * which style classes it uses itself, and which style classes may be added by - * applications to affect their appearance. - * - * # Custom styling in UI libraries and applications - * - * If you are developing a library with custom widgets that render differently - * than standard components, you may need to add a `GtkStyleProvider` yourself - * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority, either a - * `GtkCssProvider` or a custom object implementing the `GtkStyleProvider` - * interface. This way themes may still attempt to style your UI elements in - * a different way if needed so. - * - * If you are using custom styling on an applications, you probably want then - * to make your style information prevail to the theme’s, so you must use - * a `GtkStyleProvider` with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION - * priority, keep in mind that the user settings in - * `XDG_CONFIG_HOME/gtk-4.0/gtk.css` will - * still take precedence over your changes, as it uses the - * %GTK_STYLE_PROVIDER_PRIORITY_USER priority. - */ - -#define CURSOR_ASPECT_RATIO (0.04) - -struct _GtkStyleContextPrivate -{ - GdkDisplay *display; - - guint cascade_changed_id; - GtkStyleCascade *cascade; - GtkCssNode *cssnode; - GSList *saved_nodes; -}; -typedef struct _GtkStyleContextPrivate GtkStyleContextPrivate; - -enum { - PROP_0, - PROP_DISPLAY, - LAST_PROP -}; - -static GParamSpec *properties[LAST_PROP] = { NULL, }; - -static void gtk_style_context_finalize (GObject *object); - -static void gtk_style_context_impl_set_property (GObject *object, - guint prop_id, - const GValue *value, - GParamSpec *pspec); -static void gtk_style_context_impl_get_property (GObject *object, - guint prop_id, - GValue *value, - GParamSpec *pspec); - -static GtkCssNode * gtk_style_context_get_root (GtkStyleContext *context); - -G_DEFINE_TYPE_WITH_PRIVATE (GtkStyleContext, gtk_style_context, G_TYPE_OBJECT) - -static void -gtk_style_context_class_init (GtkStyleContextClass *klass) -{ - GObjectClass *object_class = G_OBJECT_CLASS (klass); - - object_class->finalize = gtk_style_context_finalize; - object_class->set_property = gtk_style_context_impl_set_property; - object_class->get_property = gtk_style_context_impl_get_property; - - properties[PROP_DISPLAY] = - g_param_spec_object ("display", NULL, NULL, - GDK_TYPE_DISPLAY, - GTK_PARAM_READWRITE); - - g_object_class_install_properties (object_class, LAST_PROP, properties); -} - -static void -gtk_style_context_pop_style_node (GtkStyleContext *context) -{ - GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); - - g_return_if_fail (priv->saved_nodes != NULL); - - if (GTK_IS_CSS_TRANSIENT_NODE (priv->cssnode)) - gtk_css_node_set_parent (priv->cssnode, NULL); - g_object_unref (priv->cssnode); - priv->cssnode = priv->saved_nodes->data; - priv->saved_nodes = g_slist_remove (priv->saved_nodes, priv->cssnode); -} - -static void -gtk_style_context_cascade_changed (GtkStyleCascade *cascade, - GtkStyleContext *context) -{ - gtk_css_node_invalidate_style_provider (gtk_style_context_get_root (context)); -} - -static void -gtk_style_context_set_cascade (GtkStyleContext *context, - GtkStyleCascade *cascade) -{ - GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); - - if (priv->cascade == cascade) - return; - - if (priv->cascade) - { - g_signal_handler_disconnect (priv->cascade, priv->cascade_changed_id); - priv->cascade_changed_id = 0; - g_object_unref (priv->cascade); - } - - if (cascade) - { - g_object_ref (cascade); - priv->cascade_changed_id = g_signal_connect (cascade, - "gtk-private-changed", - G_CALLBACK (gtk_style_context_cascade_changed), - context); - } - - priv->cascade = cascade; - - if (cascade && priv->cssnode != NULL) - gtk_style_context_cascade_changed (cascade, context); -} - -static void -gtk_style_context_init (GtkStyleContext *context) -{ - GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); - - priv->display = gdk_display_get_default (); - - if (priv->display == NULL) - g_error ("Can't create a GtkStyleContext without a display connection"); - - gtk_style_context_set_cascade (context, - _gtk_settings_get_style_cascade (gtk_settings_get_for_display (priv->display), 1)); -} - -static void -gtk_style_context_finalize (GObject *object) -{ - GtkStyleContext *context = GTK_STYLE_CONTEXT (object); - GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); - - while (priv->saved_nodes) - gtk_style_context_pop_style_node (context); - - gtk_style_context_set_cascade (context, NULL); - - if (priv->cssnode) - g_object_unref (priv->cssnode); - - G_OBJECT_CLASS (gtk_style_context_parent_class)->finalize (object); -} - -static void -gtk_style_context_impl_set_property (GObject *object, - guint prop_id, - const GValue *value, - GParamSpec *pspec) -{ - GtkStyleContext *context = GTK_STYLE_CONTEXT (object); - - switch (prop_id) - { - case PROP_DISPLAY: - gtk_style_context_set_display (context, g_value_get_object (value)); - break; - default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); - break; - } -} - -static void -gtk_style_context_impl_get_property (GObject *object, - guint prop_id, - GValue *value, - GParamSpec *pspec) -{ - GtkStyleContext *context = GTK_STYLE_CONTEXT (object); - GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); - - switch (prop_id) - { - case PROP_DISPLAY: - g_value_set_object (value, priv->display); - break; - default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); - break; - } -} - -/* returns TRUE if someone called gtk_style_context_save() but hasn’t - * called gtk_style_context_restore() yet. - * In those situations we don’t invalidate the context when somebody - * changes state/classes. - */ -static gboolean -gtk_style_context_is_saved (GtkStyleContext *context) -{ - GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); - - return priv->saved_nodes != NULL; -} - -static GtkCssNode * -gtk_style_context_get_root (GtkStyleContext *context) -{ - GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); - - if (priv->saved_nodes != NULL) - return g_slist_last (priv->saved_nodes)->data; - else - return priv->cssnode; -} - -GtkStyleProvider * -gtk_style_context_get_style_provider (GtkStyleContext *context) -{ - GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); - - return GTK_STYLE_PROVIDER (priv->cascade); -} - -static gboolean -gtk_style_context_has_custom_cascade (GtkStyleContext *context) -{ - GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); - GtkSettings *settings = gtk_settings_get_for_display (priv->display); - - return priv->cascade != _gtk_settings_get_style_cascade (settings, _gtk_style_cascade_get_scale (priv->cascade)); -} - -GtkCssStyle * -gtk_style_context_lookup_style (GtkStyleContext *context) -{ - GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); - - /* Code will recreate style if it was changed */ - return gtk_css_node_get_style (priv->cssnode); -} - -GtkCssNode* -gtk_style_context_get_node (GtkStyleContext *context) -{ - GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); - - return priv->cssnode; -} - -GtkStyleContext * -gtk_style_context_new_for_node (GtkCssNode *node) -{ - GtkStyleContext *context; - GtkStyleContextPrivate *priv; - - g_return_val_if_fail (GTK_IS_CSS_NODE (node), NULL); - - context = g_object_new (GTK_TYPE_STYLE_CONTEXT, NULL); - priv = gtk_style_context_get_instance_private (context); - priv->cssnode = g_object_ref (node); - - return context; -} - -/** - * gtk_style_context_add_provider: - * @context: a `GtkStyleContext` - * @provider: a `GtkStyleProvider` - * @priority: the priority of the style provider. The lower - * it is, the earlier it will be used in the style construction. - * Typically this will be in the range between - * %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK and - * %GTK_STYLE_PROVIDER_PRIORITY_USER - * - * Adds a style provider to @context, to be used in style construction. - * - * Note that a style provider added by this function only affects - * the style of the widget to which @context belongs. If you want - * to affect the style of all widgets, use - * [func@Gtk.StyleContext.add_provider_for_display]. - * - * Note: If both priorities are the same, a `GtkStyleProvider` - * added through this function takes precedence over another added - * through [func@Gtk.StyleContext.add_provider_for_display]. - */ -void -gtk_style_context_add_provider (GtkStyleContext *context, - GtkStyleProvider *provider, - guint priority) -{ - GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); - - g_return_if_fail (GTK_IS_STYLE_CONTEXT (context)); - g_return_if_fail (GTK_IS_STYLE_PROVIDER (provider)); - - if (!gtk_style_context_has_custom_cascade (context)) - { - GtkStyleCascade *new_cascade; - - new_cascade = _gtk_style_cascade_new (); - _gtk_style_cascade_set_scale (new_cascade, _gtk_style_cascade_get_scale (priv->cascade)); - _gtk_style_cascade_set_parent (new_cascade, - _gtk_settings_get_style_cascade (gtk_settings_get_for_display (priv->display), 1)); - _gtk_style_cascade_add_provider (new_cascade, provider, priority); - gtk_style_context_set_cascade (context, new_cascade); - g_object_unref (new_cascade); - } - else - { - _gtk_style_cascade_add_provider (priv->cascade, provider, priority); - } -} - -/** - * gtk_style_context_remove_provider: - * @context: a `GtkStyleContext` - * @provider: a `GtkStyleProvider` - * - * Removes @provider from the style providers list in @context. - */ -void -gtk_style_context_remove_provider (GtkStyleContext *context, - GtkStyleProvider *provider) -{ - GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); - - g_return_if_fail (GTK_IS_STYLE_CONTEXT (context)); - g_return_if_fail (GTK_IS_STYLE_PROVIDER (provider)); - - if (!gtk_style_context_has_custom_cascade (context)) - return; - - _gtk_style_cascade_remove_provider (priv->cascade, provider); -} - -/** - * gtk_style_context_add_provider_for_display: - * @display: a `GdkDisplay` - * @provider: a `GtkStyleProvider` - * @priority: the priority of the style provider. The lower - * it is, the earlier it will be used in the style construction. - * Typically this will be in the range between - * %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK and - * %GTK_STYLE_PROVIDER_PRIORITY_USER - * - * Adds a global style provider to @display, which will be used - * in style construction for all `GtkStyleContexts` under @display. - * - * GTK uses this to make styling information from `GtkSettings` - * available. - * - * Note: If both priorities are the same, A `GtkStyleProvider` - * added through [method@Gtk.StyleContext.add_provider] takes - * precedence over another added through this function. - **/ -void -gtk_style_context_add_provider_for_display (GdkDisplay *display, - GtkStyleProvider *provider, - guint priority) -{ - GtkStyleCascade *cascade; - - g_return_if_fail (GDK_IS_DISPLAY (display)); - g_return_if_fail (GTK_IS_STYLE_PROVIDER (provider)); - g_return_if_fail (!GTK_IS_SETTINGS (provider) || _gtk_settings_get_display (GTK_SETTINGS (provider)) == display); - - cascade = _gtk_settings_get_style_cascade (gtk_settings_get_for_display (display), 1); - _gtk_style_cascade_add_provider (cascade, provider, priority); -} - -/** - * gtk_style_context_remove_provider_for_display: - * @display: a `GdkDisplay` - * @provider: a `GtkStyleProvider` - * - * Removes @provider from the global style providers list in @display. - */ -void -gtk_style_context_remove_provider_for_display (GdkDisplay *display, - GtkStyleProvider *provider) -{ - GtkStyleCascade *cascade; - - g_return_if_fail (GDK_IS_DISPLAY (display)); - g_return_if_fail (GTK_IS_STYLE_PROVIDER (provider)); - g_return_if_fail (!GTK_IS_SETTINGS (provider)); - - cascade = _gtk_settings_get_style_cascade (gtk_settings_get_for_display (display), 1); - _gtk_style_cascade_remove_provider (cascade, provider); -} - -/** - * gtk_style_context_set_state: - * @context: a `GtkStyleContext` - * @flags: state to represent - * - * Sets the state to be used for style matching. - */ -void -gtk_style_context_set_state (GtkStyleContext *context, - GtkStateFlags flags) -{ - GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); - - g_return_if_fail (GTK_IS_STYLE_CONTEXT (context)); - - gtk_css_node_set_state (priv->cssnode, flags); -} - -/** - * gtk_style_context_get_state: - * @context: a `GtkStyleContext` - * - * Returns the state used for style matching. - * - * This method should only be used to retrieve the `GtkStateFlags` - * to pass to `GtkStyleContext` methods, like - * [method@Gtk.StyleContext.get_padding]. - * If you need to retrieve the current state of a `GtkWidget`, use - * [method@Gtk.Widget.get_state_flags]. - * - * Returns: the state flags - **/ -GtkStateFlags -gtk_style_context_get_state (GtkStyleContext *context) -{ - GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); - - g_return_val_if_fail (GTK_IS_STYLE_CONTEXT (context), 0); - - return gtk_css_node_get_state (priv->cssnode); -} - -/** - * gtk_style_context_set_scale: - * @context: a `GtkStyleContext` - * @scale: scale - * - * Sets the scale to use when getting image assets for the style. - **/ -void -gtk_style_context_set_scale (GtkStyleContext *context, - int scale) -{ - GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); - - g_return_if_fail (GTK_IS_STYLE_CONTEXT (context)); - - if (scale == _gtk_style_cascade_get_scale (priv->cascade)) - return; - - if (gtk_style_context_has_custom_cascade (context)) - { - _gtk_style_cascade_set_scale (priv->cascade, scale); - } - else - { - GtkStyleCascade *new_cascade; - - new_cascade = _gtk_settings_get_style_cascade (gtk_settings_get_for_display (priv->display), - scale); - gtk_style_context_set_cascade (context, new_cascade); - } -} - -/** - * gtk_style_context_get_scale: - * @context: a `GtkStyleContext` - * - * Returns the scale used for assets. - * - * Returns: the scale - **/ -int -gtk_style_context_get_scale (GtkStyleContext *context) -{ - GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); - - g_return_val_if_fail (GTK_IS_STYLE_CONTEXT (context), 0); - - return _gtk_style_cascade_get_scale (priv->cascade); -} - -/* - * gtk_style_context_save_to_node: - * @context: a `GtkStyleContext` - * @node: the node to save to - * - * Saves the @context state to a node. - * - * This allows temporary modifications done through - * [method@Gtk.StyleContext.add_class], - * [method@Gtk.StyleContext.remove_class], - * [method@Gtk.StyleContext.set_state] etc. - * - * Rendering using [func@Gtk.render_background] or similar - * functions are done using the given @node. - * - * To undo, call [method@Gtk.StyleContext.restore]. - * The matching call to [method@Gtk.StyleContext.restore] - * must be done before GTK returns to the main loop. - */ -void -gtk_style_context_save_to_node (GtkStyleContext *context, - GtkCssNode *node) -{ - GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); - - g_return_if_fail (GTK_IS_STYLE_CONTEXT (context)); - g_return_if_fail (GTK_IS_CSS_NODE (node)); - - priv->saved_nodes = g_slist_prepend (priv->saved_nodes, priv->cssnode); - priv->cssnode = g_object_ref (node); -} - -/** - * gtk_style_context_save: - * @context: a `GtkStyleContext` - * - * Saves the @context state. - * - * This allows temporary modifications done through - * [method@Gtk.StyleContext.add_class], - * [method@Gtk.StyleContext.remove_class], - * [method@Gtk.StyleContext.set_state] to be quickly - * reverted in one go through [method@Gtk.StyleContext.restore]. - * - * The matching call to [method@Gtk.StyleContext.restore] - * must be done before GTK returns to the main loop. - **/ -void -gtk_style_context_save (GtkStyleContext *context) -{ - GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); - GtkCssNode *cssnode; - - g_return_if_fail (GTK_IS_STYLE_CONTEXT (context)); - - - /* Make sure we have the style existing. It is the - * parent of the new saved node after all. - */ - if (!gtk_style_context_is_saved (context)) - gtk_style_context_lookup_style (context); - - cssnode = gtk_css_transient_node_new (priv->cssnode); - gtk_css_node_set_parent (cssnode, gtk_style_context_get_root (context)); - gtk_style_context_save_to_node (context, cssnode); - - g_object_unref (cssnode); -} - -/** - * gtk_style_context_restore: - * @context: a `GtkStyleContext` - * - * Restores @context state to a previous stage. - * - * See [method@Gtk.StyleContext.save]. - **/ -void -gtk_style_context_restore (GtkStyleContext *context) -{ - GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); - - g_return_if_fail (GTK_IS_STYLE_CONTEXT (context)); - - if (priv->saved_nodes == NULL) - { - g_warning ("Unpaired gtk_style_context_restore() call"); - return; - } - - gtk_style_context_pop_style_node (context); -} - -/** - * gtk_style_context_add_class: - * @context: a `GtkStyleContext` - * @class_name: class name to use in styling - * - * Adds a style class to @context, so later uses of the - * style context will make use of this new class for styling. - * - * In the CSS file format, a `GtkEntry` defining a “search” - * class, would be matched by: - * - * ```css - * entry.search { ... } - * ``` - * - * While any widget defining a “search” class would be - * matched by: - * ```css - * .search { ... } - * ``` - */ -void -gtk_style_context_add_class (GtkStyleContext *context, - const char *class_name) -{ - GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); - GQuark class_quark; - - g_return_if_fail (GTK_IS_STYLE_CONTEXT (context)); - g_return_if_fail (class_name != NULL); - - class_quark = g_quark_from_string (class_name); - - gtk_css_node_add_class (priv->cssnode, class_quark); -} - -/** - * gtk_style_context_remove_class: - * @context: a `GtkStyleContext` - * @class_name: class name to remove - * - * Removes @class_name from @context. - */ -void -gtk_style_context_remove_class (GtkStyleContext *context, - const char *class_name) -{ - GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); - GQuark class_quark; - - g_return_if_fail (GTK_IS_STYLE_CONTEXT (context)); - g_return_if_fail (class_name != NULL); - - class_quark = g_quark_try_string (class_name); - if (!class_quark) - return; - - gtk_css_node_remove_class (priv->cssnode, class_quark); -} - -/** - * gtk_style_context_has_class: - * @context: a `GtkStyleContext` - * @class_name: a class name - * - * Returns %TRUE if @context currently has defined the - * given class name. - * - * Returns: %TRUE if @context has @class_name defined - **/ -gboolean -gtk_style_context_has_class (GtkStyleContext *context, - const char *class_name) -{ - GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); - GQuark class_quark; - - g_return_val_if_fail (GTK_IS_STYLE_CONTEXT (context), FALSE); - g_return_val_if_fail (class_name != NULL, FALSE); - - class_quark = g_quark_try_string (class_name); - if (!class_quark) - return FALSE; - - return gtk_css_node_has_class (priv->cssnode, class_quark); -} - -GtkCssValue * -_gtk_style_context_peek_property (GtkStyleContext *context, - guint property_id) -{ - GtkCssStyle *values = gtk_style_context_lookup_style (context); - - return gtk_css_style_get_value (values, property_id); -} - -/** - * gtk_style_context_set_display: - * @context: a `GtkStyleContext` - * @display: a `GdkDisplay` - * - * Attaches @context to the given display. - * - * The display is used to add style information from “global” - * style providers, such as the display's `GtkSettings` instance. - * - * If you are using a `GtkStyleContext` returned from - * [method@Gtk.Widget.get_style_context], you do not need to - * call this yourself. - */ -void -gtk_style_context_set_display (GtkStyleContext *context, - GdkDisplay *display) -{ - GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); - GtkStyleCascade *display_cascade; - - g_return_if_fail (GTK_IS_STYLE_CONTEXT (context)); - g_return_if_fail (GDK_IS_DISPLAY (display)); - - if (priv->display == display) - return; - - if (gtk_style_context_has_custom_cascade (context)) - { - display_cascade = _gtk_settings_get_style_cascade (gtk_settings_get_for_display (display), 1); - _gtk_style_cascade_set_parent (priv->cascade, display_cascade); - } - else - { - display_cascade = _gtk_settings_get_style_cascade (gtk_settings_get_for_display (display), - _gtk_style_cascade_get_scale (priv->cascade)); - gtk_style_context_set_cascade (context, display_cascade); - } - - priv->display = display; - - g_object_notify_by_pspec (G_OBJECT (context), properties[PROP_DISPLAY]); -} - -/** - * gtk_style_context_get_display: - * @context: a `GtkStyleContext` - * - * Returns the `GdkDisplay` to which @context is attached. - * - * Returns: (transfer none): a `GdkDisplay`. - */ -GdkDisplay * -gtk_style_context_get_display (GtkStyleContext *context) -{ - GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); - - g_return_val_if_fail (GTK_IS_STYLE_CONTEXT (context), NULL); - - return priv->display; -} - -static gboolean -gtk_style_context_resolve_color (GtkStyleContext *context, - GtkCssValue *color, - GdkRGBA *result) -{ - GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); - GtkCssValue *val; - - g_return_val_if_fail (GTK_IS_STYLE_CONTEXT (context), FALSE); - g_return_val_if_fail (color != NULL, FALSE); - g_return_val_if_fail (result != NULL, FALSE); - - val = _gtk_css_color_value_resolve (color, - GTK_STYLE_PROVIDER (priv->cascade), - _gtk_style_context_peek_property (context, GTK_CSS_PROPERTY_COLOR), - NULL); - if (val == NULL) - return FALSE; - - *result = *gtk_css_color_value_get_rgba (val); - _gtk_css_value_unref (val); - return TRUE; -} - -/** - * gtk_style_context_lookup_color: - * @context: a `GtkStyleContext` - * @color_name: color name to lookup - * @color: (out): Return location for the looked up color - * - * Looks up and resolves a color name in the @context color map. - * - * Returns: %TRUE if @color_name was found and resolved, %FALSE otherwise - */ -gboolean -gtk_style_context_lookup_color (GtkStyleContext *context, - const char *color_name, - GdkRGBA *color) -{ - GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); - GtkCssValue *value; - - g_return_val_if_fail (GTK_IS_STYLE_CONTEXT (context), FALSE); - g_return_val_if_fail (color_name != NULL, FALSE); - g_return_val_if_fail (color != NULL, FALSE); - - value = gtk_style_provider_get_color (GTK_STYLE_PROVIDER (priv->cascade), color_name); - if (value == NULL) - return FALSE; - - return gtk_style_context_resolve_color (context, value, color); -} - -/** - * gtk_style_context_get_color: - * @context: a `GtkStyleContext` - * @color: (out): return value for the foreground color - * - * Gets the foreground color for a given state. - */ -void -gtk_style_context_get_color (GtkStyleContext *context, - GdkRGBA *color) -{ - g_return_if_fail (color != NULL); - g_return_if_fail (GTK_IS_STYLE_CONTEXT (context)); - - *color = *gtk_css_color_value_get_rgba (_gtk_style_context_peek_property (context, GTK_CSS_PROPERTY_COLOR)); -} - -/** - * gtk_style_context_get_border: - * @context: a `GtkStyleContext` - * @border: (out): return value for the border settings - * - * Gets the border for a given state as a `GtkBorder`. - */ -void -gtk_style_context_get_border (GtkStyleContext *context, - GtkBorder *border) -{ - GtkCssStyle *style; - - g_return_if_fail (border != NULL); - g_return_if_fail (GTK_IS_STYLE_CONTEXT (context)); - - style = gtk_style_context_lookup_style (context); - - border->top = round (_gtk_css_number_value_get (style->border->border_top_width, 100)); - border->right = round (_gtk_css_number_value_get (style->border->border_right_width, 100)); - border->bottom = round (_gtk_css_number_value_get (style->border->border_bottom_width, 100)); - border->left = round (_gtk_css_number_value_get (style->border->border_left_width, 100)); -} - -/** - * gtk_style_context_get_padding: - * @context: a `GtkStyleContext` - * @padding: (out): return value for the padding settings - * - * Gets the padding for a given state as a `GtkBorder`. - */ -void -gtk_style_context_get_padding (GtkStyleContext *context, - GtkBorder *padding) -{ - GtkCssStyle *style; - - g_return_if_fail (padding != NULL); - g_return_if_fail (GTK_IS_STYLE_CONTEXT (context)); - - style = gtk_style_context_lookup_style (context); - - padding->top = round (_gtk_css_number_value_get (style->size->padding_top, 100)); - padding->right = round (_gtk_css_number_value_get (style->size->padding_right, 100)); - padding->bottom = round (_gtk_css_number_value_get (style->size->padding_bottom, 100)); - padding->left = round (_gtk_css_number_value_get (style->size->padding_left, 100)); -} - -/** - * gtk_style_context_get_margin: - * @context: a `GtkStyleContext` - * @margin: (out): return value for the margin settings - * - * Gets the margin for a given state as a `GtkBorder`. - */ -void -gtk_style_context_get_margin (GtkStyleContext *context, - GtkBorder *margin) -{ - GtkCssStyle *style; - - g_return_if_fail (margin != NULL); - g_return_if_fail (GTK_IS_STYLE_CONTEXT (context)); - - style = gtk_style_context_lookup_style (context); - - margin->top = round (_gtk_css_number_value_get (style->size->margin_top, 100)); - margin->right = round (_gtk_css_number_value_get (style->size->margin_right, 100)); - margin->bottom = round (_gtk_css_number_value_get (style->size->margin_bottom, 100)); - margin->left = round (_gtk_css_number_value_get (style->size->margin_left, 100)); -} - -void -_gtk_style_context_get_cursor_color (GtkStyleContext *context, - GdkRGBA *primary_color, - GdkRGBA *secondary_color) -{ - GtkCssStyle *style; - - style = gtk_style_context_lookup_style (context); - - if (primary_color) - *primary_color = *gtk_css_color_value_get_rgba (style->font->caret_color ? style->font->caret_color : style->core->color); - - if (secondary_color) - *secondary_color = *gtk_css_color_value_get_rgba (style->font->secondary_caret_color ? style->font->secondary_caret_color : style->core->color); -} - -/** - * GtkStyleContextPrintFlags: - * @GTK_STYLE_CONTEXT_PRINT_NONE: Default value. - * @GTK_STYLE_CONTEXT_PRINT_RECURSE: Print the entire tree of - * CSS nodes starting at the style context's node - * @GTK_STYLE_CONTEXT_PRINT_SHOW_STYLE: Show the values of the - * CSS properties for each node - * @GTK_STYLE_CONTEXT_PRINT_SHOW_CHANGE: Show information about - * what changes affect the styles - * - * Flags that modify the behavior of gtk_style_context_to_string(). - * - * New values may be added to this enumeration. - */ - -/** - * gtk_style_context_to_string: - * @context: a `GtkStyleContext` - * @flags: Flags that determine what to print - * - * Converts the style context into a string representation. - * - * The string representation always includes information about - * the name, state, id, visibility and style classes of the CSS - * node that is backing @context. Depending on the flags, more - * information may be included. - * - * This function is intended for testing and debugging of the - * CSS implementation in GTK. There are no guarantees about - * the format of the returned string, it may change. - * - * Returns: a newly allocated string representing @context - */ -char * -gtk_style_context_to_string (GtkStyleContext *context, - GtkStyleContextPrintFlags flags) -{ - GtkStyleContextPrivate *priv = gtk_style_context_get_instance_private (context); - GString *string; - - g_return_val_if_fail (GTK_IS_STYLE_CONTEXT (context), NULL); - - string = g_string_new (""); - - gtk_css_node_print (priv->cssnode, flags, string, 0); - - return g_string_free (string, FALSE); -} diff --git a/gtk/gtkstylecontext.h b/gtk/gtkstylecontext.h deleted file mode 100644 index 21462ef501..0000000000 --- a/gtk/gtkstylecontext.h +++ /dev/null @@ -1,148 +0,0 @@ -/* GTK - The GIMP Toolkit - * Copyright (C) 2010 Carlos Garnacho - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - */ - -#ifndef __GTK_STYLE_CONTEXT_H__ -#define __GTK_STYLE_CONTEXT_H__ - -#if !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION) -#error "Only can be included directly." -#endif - -#include - -#include -#include -#include - -G_BEGIN_DECLS - -#define GTK_TYPE_STYLE_CONTEXT (gtk_style_context_get_type ()) -#define GTK_STYLE_CONTEXT(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_STYLE_CONTEXT, GtkStyleContext)) -#define GTK_STYLE_CONTEXT_CLASS(c) (G_TYPE_CHECK_CLASS_CAST ((c), GTK_TYPE_STYLE_CONTEXT, GtkStyleContextClass)) -#define GTK_IS_STYLE_CONTEXT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_STYLE_CONTEXT)) -#define GTK_IS_STYLE_CONTEXT_CLASS(c) (G_TYPE_CHECK_CLASS_TYPE ((c), GTK_TYPE_STYLE_CONTEXT)) -#define GTK_STYLE_CONTEXT_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_STYLE_CONTEXT, GtkStyleContextClass)) - -typedef struct _GtkStyleContextClass GtkStyleContextClass; - -struct _GtkStyleContext -{ - GObject parent_object; -}; - -struct _GtkStyleContextClass -{ - GObjectClass parent_class; - - void (* changed) (GtkStyleContext *context); - - /* Padding for future expansion */ - void (*_gtk_reserved1) (void); - void (*_gtk_reserved2) (void); - void (*_gtk_reserved3) (void); - void (*_gtk_reserved4) (void); -}; - - -GDK_AVAILABLE_IN_ALL -GType gtk_style_context_get_type (void) G_GNUC_CONST; - -GDK_AVAILABLE_IN_ALL -void gtk_style_context_add_provider_for_display (GdkDisplay *display, - GtkStyleProvider *provider, - guint priority); -GDK_AVAILABLE_IN_ALL -void gtk_style_context_remove_provider_for_display (GdkDisplay *display, - GtkStyleProvider *provider); - -GDK_AVAILABLE_IN_ALL -void gtk_style_context_add_provider (GtkStyleContext *context, - GtkStyleProvider *provider, - guint priority); - -GDK_AVAILABLE_IN_ALL -void gtk_style_context_remove_provider (GtkStyleContext *context, - GtkStyleProvider *provider); - -GDK_AVAILABLE_IN_ALL -void gtk_style_context_save (GtkStyleContext *context); -GDK_AVAILABLE_IN_ALL -void gtk_style_context_restore (GtkStyleContext *context); - -GDK_AVAILABLE_IN_ALL -void gtk_style_context_set_state (GtkStyleContext *context, - GtkStateFlags flags); -GDK_AVAILABLE_IN_ALL -GtkStateFlags gtk_style_context_get_state (GtkStyleContext *context); - -GDK_AVAILABLE_IN_ALL -void gtk_style_context_set_scale (GtkStyleContext *context, - int scale); -GDK_AVAILABLE_IN_ALL -int gtk_style_context_get_scale (GtkStyleContext *context); - -GDK_AVAILABLE_IN_ALL -void gtk_style_context_add_class (GtkStyleContext *context, - const char *class_name); -GDK_AVAILABLE_IN_ALL -void gtk_style_context_remove_class (GtkStyleContext *context, - const char *class_name); -GDK_AVAILABLE_IN_ALL -gboolean gtk_style_context_has_class (GtkStyleContext *context, - const char *class_name); - -GDK_AVAILABLE_IN_ALL -void gtk_style_context_set_display (GtkStyleContext *context, - GdkDisplay *display); -GDK_AVAILABLE_IN_ALL -GdkDisplay *gtk_style_context_get_display (GtkStyleContext *context); - -GDK_AVAILABLE_IN_ALL -gboolean gtk_style_context_lookup_color (GtkStyleContext *context, - const char *color_name, - GdkRGBA *color); - -/* Some helper functions to retrieve most common properties */ -GDK_AVAILABLE_IN_ALL -void gtk_style_context_get_color (GtkStyleContext *context, - GdkRGBA *color); -GDK_AVAILABLE_IN_ALL -void gtk_style_context_get_border (GtkStyleContext *context, - GtkBorder *border); -GDK_AVAILABLE_IN_ALL -void gtk_style_context_get_padding (GtkStyleContext *context, - GtkBorder *padding); -GDK_AVAILABLE_IN_ALL -void gtk_style_context_get_margin (GtkStyleContext *context, - GtkBorder *margin); - -typedef enum { - GTK_STYLE_CONTEXT_PRINT_NONE = 0, - GTK_STYLE_CONTEXT_PRINT_RECURSE = 1 << 0, - GTK_STYLE_CONTEXT_PRINT_SHOW_STYLE = 1 << 1, - GTK_STYLE_CONTEXT_PRINT_SHOW_CHANGE = 1 << 2 -} GtkStyleContextPrintFlags; - -GDK_AVAILABLE_IN_ALL -char * gtk_style_context_to_string (GtkStyleContext *context, - GtkStyleContextPrintFlags flags); - -G_DEFINE_AUTOPTR_CLEANUP_FUNC(GtkStyleContext, g_object_unref) - -G_END_DECLS - -#endif /* __GTK_STYLE_CONTEXT_H__ */ diff --git a/gtk/gtkstylecontextprivate.h b/gtk/gtkstylecontextprivate.h deleted file mode 100644 index 4cab724b20..0000000000 --- a/gtk/gtkstylecontextprivate.h +++ /dev/null @@ -1,47 +0,0 @@ -/* GTK - The GIMP Toolkit - * Copyright (C) 2010 Carlos Garnacho - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - */ - -#ifndef __GTK_STYLE_CONTEXT_PRIVATE_H__ -#define __GTK_STYLE_CONTEXT_PRIVATE_H__ - -#include "gtkstylecontext.h" - -#include "gtkcssnodeprivate.h" -#include "gtkstyleproviderprivate.h" -#include "gtkcssvalueprivate.h" - -G_BEGIN_DECLS - -GtkStyleContext *gtk_style_context_new_for_node (GtkCssNode *node); - -GtkCssNode *gtk_style_context_get_node (GtkStyleContext *context); -GtkStyleProvider * - gtk_style_context_get_style_provider (GtkStyleContext *context); - -void gtk_style_context_save_to_node (GtkStyleContext *context, - GtkCssNode *node); - -GtkCssStyle * gtk_style_context_lookup_style (GtkStyleContext *context); -GtkCssValue * _gtk_style_context_peek_property (GtkStyleContext *context, - guint property_id); -void _gtk_style_context_get_cursor_color (GtkStyleContext *context, - GdkRGBA *primary_color, - GdkRGBA *secondary_color); - -G_END_DECLS - -#endif /* __GTK_STYLE_CONTEXT_PRIVATE_H__ */ diff --git a/gtk/gtkstylepropertyprivate.h b/gtk/gtkstylepropertyprivate.h index b57331dd84..7bd0e7f247 100644 --- a/gtk/gtkstylepropertyprivate.h +++ b/gtk/gtkstylepropertyprivate.h @@ -21,7 +21,6 @@ #include #include "gtk/css/gtkcsstokenizerprivate.h" #include "gtk/css/gtkcssparserprivate.h" -#include "gtkstylecontextprivate.h" #include "gtkcssvalueprivate.h" G_BEGIN_DECLS diff --git a/gtk/gtkstyleprovider.c b/gtk/gtkstyleprovider.c index 19dca70d2a..d7c8af8687 100644 --- a/gtk/gtkstyleprovider.c +++ b/gtk/gtkstyleprovider.c @@ -17,6 +17,7 @@ #include "config.h" +#include "gtksettingsprivate.h" #include "gtkstyleproviderprivate.h" #include "gtkprivate.h" @@ -168,3 +169,65 @@ gtk_style_provider_emit_error (GtkStyleProvider *provider, if (iface->emit_error) iface->emit_error (provider, section, error); } + + +/* These apis are misnamed, and the rest of GtkStyleContext is deprecated, + * so put them here for now + */ + +/** + * gtk_style_context_add_provider_for_display: + * @display: a `GdkDisplay` + * @provider: a `GtkStyleProvider` + * @priority: the priority of the style provider. The lower + * it is, the earlier it will be used in the style construction. + * Typically this will be in the range between + * %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK and + * %GTK_STYLE_PROVIDER_PRIORITY_USER + * + * Adds a global style provider to @display, which will be used + * in style construction for all `GtkStyleContexts` under @display. + * + * GTK uses this to make styling information from `GtkSettings` + * available. + * + * Note: If both priorities are the same, A `GtkStyleProvider` + * added through [method@Gtk.StyleContext.add_provider] takes + * precedence over another added through this function. + */ +void +gtk_style_context_add_provider_for_display (GdkDisplay *display, + GtkStyleProvider *provider, + guint priority) +{ + GtkStyleCascade *cascade; + + g_return_if_fail (GDK_IS_DISPLAY (display)); + g_return_if_fail (GTK_IS_STYLE_PROVIDER (provider)); + g_return_if_fail (!GTK_IS_SETTINGS (provider) || _gtk_settings_get_display (GTK_SETTINGS (provider)) == display); + + cascade = _gtk_settings_get_style_cascade (gtk_settings_get_for_display (display), 1); + _gtk_style_cascade_add_provider (cascade, provider, priority); +} + +/** + * gtk_style_context_remove_provider_for_display: + * @display: a `GdkDisplay` + * @provider: a `GtkStyleProvider` + * + * Removes @provider from the global style providers list in @display. + */ +void +gtk_style_context_remove_provider_for_display (GdkDisplay *display, + GtkStyleProvider *provider) +{ + GtkStyleCascade *cascade; + + g_return_if_fail (GDK_IS_DISPLAY (display)); + g_return_if_fail (GTK_IS_STYLE_PROVIDER (provider)); + g_return_if_fail (!GTK_IS_SETTINGS (provider)); + + cascade = _gtk_settings_get_style_cascade (gtk_settings_get_for_display (display), 1); + _gtk_style_cascade_remove_provider (cascade, provider); +} + diff --git a/gtk/gtkstyleprovider.h b/gtk/gtkstyleprovider.h index 3d696606a8..86de970da8 100644 --- a/gtk/gtkstyleprovider.h +++ b/gtk/gtkstyleprovider.h @@ -90,6 +90,15 @@ GType gtk_style_provider_get_type (void) G_GNUC_CONST; G_DEFINE_AUTOPTR_CLEANUP_FUNC(GtkStyleProvider, g_object_unref) +GDK_AVAILABLE_IN_ALL +void gtk_style_context_add_provider_for_display (GdkDisplay *display, + GtkStyleProvider *provider, + guint priority); +GDK_AVAILABLE_IN_ALL +void gtk_style_context_remove_provider_for_display (GdkDisplay *display, + GtkStyleProvider *provider); + + G_END_DECLS #endif /* __GTK_STYLE_PROVIDER_H__ */ diff --git a/gtk/gtkstyleproviderprivate.h b/gtk/gtkstyleproviderprivate.h index 5ee16e3d00..f2652113b2 100644 --- a/gtk/gtkstyleproviderprivate.h +++ b/gtk/gtkstyleproviderprivate.h @@ -19,6 +19,7 @@ #define __GTK_STYLE_PROVIDER_PRIVATE_H__ #include +#include #include "gtk/gtkcountingbloomfilterprivate.h" #include "gtk/gtkcsskeyframesprivate.h" #include "gtk/gtkcsslookupprivate.h" diff --git a/gtk/gtktextutil.c b/gtk/gtktextutil.c index 095d333d9b..a7cc04da61 100644 --- a/gtk/gtktextutil.c +++ b/gtk/gtktextutil.c @@ -28,7 +28,6 @@ #include "gtktextutilprivate.h" #include "gtkcsscolorvalueprivate.h" -#include "gtkstylecontextprivate.h" #include "gtktextbuffer.h" #include "gtktextlayoutprivate.h" #include "gtkwidgetprivate.h" diff --git a/gtk/gtkwidget.c b/gtk/gtkwidget.c index 8ef948c304..1aa14bf06b 100644 --- a/gtk/gtkwidget.c +++ b/gtk/gtkwidget.c @@ -65,7 +65,7 @@ #include "gtkshortcuttrigger.h" #include "gtksizegroup-private.h" #include "gtksnapshotprivate.h" -#include "gtkstylecontextprivate.h" +#include "deprecated/gtkstylecontextprivate.h" #include "gtktooltipprivate.h" #include "gsktransformprivate.h" #include "gtktypebuiltins.h" @@ -2442,8 +2442,10 @@ gtk_widget_root (GtkWidget *widget) priv->root = priv->parent->priv->root; } +G_GNUC_BEGIN_IGNORE_DEPRECATIONS if (priv->context) gtk_style_context_set_display (priv->context, gtk_root_get_display (priv->root)); +G_GNUC_END_IGNORE_DEPRECATIONS if (priv->surface_transform_data) add_parent_surface_transform_changed_listener (widget); @@ -2479,8 +2481,10 @@ gtk_widget_unroot (GtkWidget *widget) GTK_WIDGET_GET_CLASS (widget)->unroot (widget); +G_GNUC_BEGIN_IGNORE_DEPRECATIONS if (priv->context) gtk_style_context_set_display (priv->context, gdk_display_get_default ()); +G_GNUC_END_IGNORE_DEPRECATIONS if (priv->layout_manager) gtk_layout_manager_set_root (priv->layout_manager, NULL); @@ -3410,10 +3414,12 @@ gtk_widget_realize (GtkWidget *widget) g_signal_emit (widget, widget_signals[REALIZE], 0); +G_GNUC_BEGIN_IGNORE_DEPRECATIONS if (priv->context) gtk_style_context_set_scale (priv->context, gtk_widget_get_scale_factor (widget)); else gtk_widget_get_style_context (widget); +G_GNUC_END_IGNORE_DEPRECATIONS gtk_widget_pop_verify_invariants (widget); } @@ -6737,8 +6743,10 @@ _gtk_widget_scale_changed (GtkWidget *widget) g_return_if_fail (GTK_IS_WIDGET (widget)); +G_GNUC_BEGIN_IGNORE_DEPRECATIONS if (priv->context) gtk_style_context_set_scale (priv->context, gtk_widget_get_scale_factor (widget)); +G_GNUC_END_IGNORE_DEPRECATIONS g_object_notify_by_pspec (G_OBJECT (widget), widget_props[PROP_SCALE_FACTOR]); @@ -10712,6 +10720,8 @@ _gtk_widget_peek_style_context (GtkWidget *widget) * for the lifetime of @widget. * * Returns: (transfer none): the widgets `GtkStyleContext` + * + * Deprecated: 4.10: Style contexts will be removed in GTK 5 */ GtkStyleContext * gtk_widget_get_style_context (GtkWidget *widget) @@ -10726,11 +10736,13 @@ gtk_widget_get_style_context (GtkWidget *widget) priv->context = gtk_style_context_new_for_node (priv->cssnode); +G_GNUC_BEGIN_IGNORE_DEPRECATIONS gtk_style_context_set_scale (priv->context, gtk_widget_get_scale_factor (widget)); display = _gtk_widget_get_display (widget); if (display) gtk_style_context_set_display (priv->context, display); +G_GNUC_END_IGNORE_DEPRECATIONS } return priv->context; diff --git a/gtk/gtkwidget.h b/gtk/gtkwidget.h index 8720017bad..5374160dcf 100644 --- a/gtk/gtkwidget.h +++ b/gtk/gtkwidget.h @@ -706,7 +706,7 @@ void gtk_requisition_free (GtkRequisition *requisition); GDK_AVAILABLE_IN_ALL gboolean gtk_widget_in_destruction (GtkWidget *widget); -GDK_AVAILABLE_IN_ALL +GDK_DEPRECATED_IN_4_10 GtkStyleContext * gtk_widget_get_style_context (GtkWidget *widget); GDK_AVAILABLE_IN_ALL diff --git a/gtk/gtkwidgetprivate.h b/gtk/gtkwidgetprivate.h index e1e336e6e6..d902e7117f 100644 --- a/gtk/gtkwidgetprivate.h +++ b/gtk/gtkwidgetprivate.h @@ -446,15 +446,6 @@ _gtk_widget_get_display (GtkWidget *widget) return gtk_root_get_display (root); } -static inline GtkStyleContext * -_gtk_widget_get_style_context (GtkWidget *widget) -{ - if (G_LIKELY (widget->priv->context)) - return widget->priv->context; - - return gtk_widget_get_style_context (widget); -} - static inline gpointer _gtk_widget_peek_request_cache (GtkWidget *widget) { diff --git a/gtk/inspector/css-editor.c b/gtk/inspector/css-editor.c index 8047545b62..b1dc9bf701 100644 --- a/gtk/inspector/css-editor.c +++ b/gtk/inspector/css-editor.c @@ -28,7 +28,6 @@ #include "gtkcssprovider.h" #include "gtkstyleprovider.h" -#include "gtkstylecontext.h" #include "gtktextview.h" #include "gtkmessagedialog.h" #include "gtkfilechooserdialog.h" diff --git a/gtk/inspector/graphrenderer.c b/gtk/inspector/graphrenderer.c index 6ade21e5b2..595f82213e 100644 --- a/gtk/inspector/graphrenderer.c +++ b/gtk/inspector/graphrenderer.c @@ -22,7 +22,7 @@ #include "graphdata.h" #include "gtksnapshot.h" -#include "gtkstylecontext.h" +#include "deprecated/gtkstylecontext.h" enum { PROP_0, @@ -155,8 +155,10 @@ graph_renderer_snapshot (GtkWidget *widget, diff = maximum - minimum; +G_GNUC_BEGIN_IGNORE_DEPRECATIONS context = gtk_widget_get_style_context (widget); gtk_style_context_get_color (context, &color); +G_GNUC_END_IGNORE_DEPRECATIONS cr = gtk_snapshot_append_cairo (snapshot, &GRAPHENE_RECT_INIT ( diff --git a/gtk/inspector/window.c b/gtk/inspector/window.c index 1364f34d3f..8c55db19a0 100644 --- a/gtk/inspector/window.c +++ b/gtk/inspector/window.c @@ -63,7 +63,6 @@ #include "gtkrevealer.h" #include "gtklayoutmanager.h" #include "gtkcssprovider.h" -#include "gtkstylecontext.h" #include "gtkwidgetprivate.h" diff --git a/gtk/meson.build b/gtk/meson.build index 4286d14e31..4e7325ad57 100644 --- a/gtk/meson.build +++ b/gtk/meson.build @@ -362,7 +362,6 @@ gtk_public_sources = files([ 'gtkstringfilter.c', 'gtkstringlist.c', 'gtkstringsorter.c', - 'gtkstylecontext.c', 'gtkstyleprovider.c', 'gtkswitch.c', 'gtksymbolicpaintable.c', @@ -602,7 +601,6 @@ gtk_public_headers = files([ 'gtkstringfilter.h', 'gtkstringlist.h', 'gtkstringsorter.h', - 'gtkstylecontext.h', 'gtkstyleprovider.h', 'gtkswitch.h', 'gtksymbolicpaintable.h',