AuroraMiddleware/gtk
1
0
Fork 1
mirror of https://gitlab.gnome.org/GNOME/gtk.git synced 2024-11-14 12:41:07 +00:00
Code Issues Projects Releases Wiki Activity
341860eb4d
gtk/gsk/gskrendernode.c

842 lines
24 KiB
C
Raw Normal View History

Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
/* GSK - The GTK Scene Kit
*
* Copyright 2016 Endless
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
/**
rendernode: Add GValue functions for render nodes This is needed as GskRenderNode is its own fundamental type and has its own GValue infrastructure. And I want to put render nodes into the clipboard which uses GValues.
2021-08-19 21:36:16 +00:00
* GskRenderNode: (ref-func gsk_render_node_ref) (unref-func gsk_render_node_unref) (set-value-func gsk_value_set_render_node) (get-value-func gsk_value_get_render_node)
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
*
rendernode: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:57 +00:00
* `GskRenderNode` is the basic block in a scene graph to be
docs: Improve docs for gskrendernode.c
2022-01-05 11:43:06 +00:00
* rendered using [class@Gsk.Renderer].
docs: Add more GSK documentation
2016-07-03 23:23:19 +00:00
*
* Each node has a parent, except the top-level node; each node may have
* children nodes.
*
* Each node has an associated drawing surface, which has the size of
rendernode: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:57 +00:00
* the rectangle set when creating it.
docs: Add more GSK documentation
2016-07-03 23:23:19 +00:00
*
* Render nodes are meant to be transient; once they have been associated
rendernode: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:57 +00:00
* to a [class@Gsk.Renderer] it's safe to release any reference you have on
* them. All [class@Gsk.RenderNode]s are immutable, you can only specify their
* properties during construction.
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
*/
#include "config.h"
#include "gskrendernodeprivate.h"
#include "gskdebugprivate.h"
gsk: Use GskRenderer.create_cairo_surface() GskRenderNode should ask the renderer for a Cairo surface when creating a drawing context.
2016-10-31 16:28:09 +00:00
#include "gskrendererprivate.h"
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
#include "gskrendernodeparserprivate.h"
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
cairo: Add colorstate to GskRenderNode::draw and use it This adds the following: - ccs argument to GskRenderNode::draw This is the compositing color state to use when drawing. - make implementations use the CCS argument FIXME: Some implementations are missing - gsk_render_node_draw_with_color_state() Draws a node with any color state, by switching to its compositing color state, drawing in that color state and then converting to the desired color state. This does draw the result OVER the previous contents in the passed in color state, so this function should be called with the target being empty. - gsk_render_node_draw_ccs() This needs to be passed a css and then draws with that ccs. The main use for this is chaining up in rendernode draw() implementations. - split out shared Cairo functions into gdkcairoprivate.h gskrendernode.c and gskrendernodeimpl.c need the same functions. Plus, there's various code in GDK that wants to use it, so put it in gdk/ not in gsk/ gsk_render_node_draw() now calls gsk_render_node_draw_with_color_state() with GDK_COLOR_STATE_SRGB.
2024-07-02 05:02:09 +00:00
#include "gdk/gdkcairoprivate.h"
#include "gdk/gdkcolorstateprivate.h"
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
#include <graphene-gobject.h>
rendernode: Use ceilf() on the size of the cairo surface Bounds sizes are floats, so round up to the next integer so we end up with enough space to draw.
2016-11-01 02:40:01 +00:00
#include <math.h>
gsk: Turn GskRenderNode into a pure GTypeInstance Using GObject as the base type for a transient tree may prove to be too intensive, especially when creating a lot of node instances. Since we don't need properties or signals, and we don't need complex destruction semantics, we can use GTypeInstance directly as the base type for GskRenderNode.
2016-06-29 18:05:33 +00:00
#include <gobject/gvaluecollector.h>
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
gskrendernode: Document serialization error quark
2024-05-25 16:44:54 +00:00
/**
* gsk_serialization_error_quark:
*
* Registers an error quark for [class@Gsk.RenderNode] errors.
*
* Returns: the error quark
**/
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
G_DEFINE_QUARK (gsk-serialization-error-quark, gsk_serialization_error)
#define GSK_RENDER_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GSK_TYPE_RENDER_NODE, GskRenderNodeClass))
gsk: Add fundamental type annotations for GskRenderNode We need to annotate the GskRenderNode so that the introspection machinery can find the functions for managing reference counting and GValues.
2016-07-04 13:07:24 +00:00
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
static void
value_render_node_init (GValue *value)
{
value->data[0].v_pointer = NULL;
}
gsk: Collect opacity information Collect information about whether to use offscreens for opacity during node construction, so we don't need to walk the tree repeatedly, later.
2022-04-05 18:55:36 +00:00
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
static void
value_render_node_free_value (GValue *value)
{
if (value->data[0].v_pointer != NULL)
gsk_render_node_unref (value->data[0].v_pointer);
}
gsk: Collect opacity information Collect information about whether to use offscreens for opacity during node construction, so we don't need to walk the tree repeatedly, later.
2022-04-05 18:55:36 +00:00
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
static void
value_render_node_copy_value (const GValue *src,
GValue *dst)
{
if (src->data[0].v_pointer != NULL)
dst->data[0].v_pointer = gsk_render_node_ref (src->data[0].v_pointer);
else
dst->data[0].v_pointer = NULL;
}
gsk: Collect opacity information Collect information about whether to use offscreens for opacity during node construction, so we don't need to walk the tree repeatedly, later.
2022-04-05 18:55:36 +00:00
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
static gpointer
value_render_node_peek_pointer (const GValue *value)
{
return value->data[0].v_pointer;
}
gsk: Turn GskRenderNode into a pure GTypeInstance Using GObject as the base type for a transient tree may prove to be too intensive, especially when creating a lot of node instances. Since we don't need properties or signals, and we don't need complex destruction semantics, we can use GTypeInstance directly as the base type for GskRenderNode.
2016-06-29 18:05:33 +00:00
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
static char *
value_render_node_collect_value (GValue *value,
guint n_collect_values,
GTypeCValue *collect_values,
guint collect_flags)
{
GskRenderNode *node = collect_values[0].v_pointer;
if (node == NULL)
{
value->data[0].v_pointer = NULL;
return NULL;
}
if (node->parent_instance.g_class == NULL)
return g_strconcat ("invalid unclassed GskRenderNode pointer for "
"value type '",
G_VALUE_TYPE_NAME (value),
"'",
NULL);
value->data[0].v_pointer = gsk_render_node_ref (node);
return NULL;
}
Replace "gchar" with "char"
2020-07-24 18:40:36 +00:00
static char *
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
value_render_node_lcopy_value (const GValue *value,
guint n_collect_values,
GTypeCValue *collect_values,
guint collect_flags)
{
GskRenderNode **node_p = collect_values[0].v_pointer;
if (node_p == NULL)
return g_strconcat ("value location for '",
G_VALUE_TYPE_NAME (value),
"' passed as NULL",
NULL);
if (value->data[0].v_pointer == NULL)
*node_p = NULL;
else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)
*node_p = value->data[0].v_pointer;
else
*node_p = gsk_render_node_ref (value->data[0].v_pointer);
return NULL;
}
gsk: Add docs and error handling to serialization API
2016-12-23 07:03:36 +00:00
gsk: Turn GskRenderNode into a pure GTypeInstance Using GObject as the base type for a transient tree may prove to be too intensive, especially when creating a lot of node instances. Since we don't need properties or signals, and we don't need complex destruction semantics, we can use GTypeInstance directly as the base type for GskRenderNode.
2016-06-29 18:05:33 +00:00
static void
gsk_render_node_finalize (GskRenderNode *self)
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
{
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
g_type_free_instance ((GTypeInstance *) self);
}
gsk: Add GskRenderNodeClass.finalize()
2016-12-11 03:18:25 +00:00
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
static gboolean
gsk_render_node_real_can_diff (const GskRenderNode *node1,
const GskRenderNode *node2)
{
rendernode: Get rid of GskRenderNodeTypeInfo Instead, use class_init functions.
2023-04-03 14:39:52 +00:00
return TRUE;
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
}
static void
gsk_render_node_real_diff (GskRenderNode *node1,
GskRenderNode *node2,
Rework diffing one more time Pass the surface along. We need it to identify the inspector case in gsk_subsurface_node_diff.
2024-02-11 20:53:37 +00:00
GskDiffData *data)
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
{
Rework diffing one more time Pass the surface along. We need it to identify the inspector case in gsk_subsurface_node_diff.
2024-02-11 20:53:37 +00:00
gsk_render_node_diff_impossible (node1, node2, data);
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
}
gsk: Add gsk_render_node_get_opaque_rect() Gets a rectangle inside the rendernode that is opaque. This function only adds the API. So far, no implementation exists.
2023-04-03 12:52:00 +00:00
static gboolean
gsk_render_node_real_get_opaque_rect (GskRenderNode *node,
graphene_rect_t *out_opaque)
{
return FALSE;
}
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
static void
gsk_render_node_class_init (GskRenderNodeClass *klass)
{
klass->node_type = GSK_NOT_A_RENDER_NODE;
klass->finalize = gsk_render_node_finalize;
klass->can_diff = gsk_render_node_real_can_diff;
klass->diff = gsk_render_node_real_diff;
gsk: Add gsk_render_node_get_opaque_rect() Gets a rectangle inside the rendernode that is opaque. This function only adds the API. So far, no implementation exists.
2023-04-03 12:52:00 +00:00
klass->get_opaque_rect = gsk_render_node_real_get_opaque_rect;
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
}
static void
gsk_render_node_init (GskRenderNode *self)
{
g_atomic_ref_count_init (&self->ref_count);
rendernode: Return the right depth for colors This makes sure we return U8_SRGB for GdkRGBA colors with linear compositing.
2024-06-28 16:13:39 +00:00
self->preferred_depth = GDK_N_DEPTHS; /* illegal value */
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
}
GType
gsk_render_node_get_type (void)
{
types: fix various use of volatile in type registration The use of volatile was incorrect in GLib and has been that way for a long time. Recently however that has changed, and this makes GTK follow suit to avoid using volatile in the type registration. See also: https://gitlab.gnome.org/GNOME/glib/-/merge_requests/1719 Combined with the above merge request for GLib, this fixes a large number of compilation warnings when using Clang.
2020-11-19 03:58:09 +00:00
static gsize render_node_type__volatile;
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
if (g_once_init_enter (&render_node_type__volatile))
{
static const GTypeFundamentalInfo finfo = {
(G_TYPE_FLAG_CLASSED |
G_TYPE_FLAG_INSTANTIATABLE |
G_TYPE_FLAG_DERIVABLE |
G_TYPE_FLAG_DEEP_DERIVABLE),
};
static const GTypeValueTable value_table = {
value_render_node_init,
value_render_node_free_value,
value_render_node_copy_value,
value_render_node_peek_pointer,
"p",
value_render_node_collect_value,
"p",
value_render_node_lcopy_value,
};
const GTypeInfo node_info = {
/* Class */
sizeof (GskRenderNodeClass),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) NULL,
(GClassInitFunc) gsk_render_node_class_init,
(GClassFinalizeFunc) NULL,
NULL,
/* Instance */
sizeof (GskRenderNode),
0,
(GInstanceInitFunc) gsk_render_node_init,
/* GValue */
&value_table,
};
GType render_node_type =
g_type_register_fundamental (g_type_fundamental_next (),
g_intern_static_string ("GskRenderNode"),
&node_info, &finfo,
G_TYPE_FLAG_ABSTRACT);
g_once_init_leave (&render_node_type__volatile, render_node_type);
}
return render_node_type__volatile;
}
/*< private >
* gsk_render_node_type_register_static:
* @node_name: the name of the node
* @node_info: type information of the node
*
rendernode: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:57 +00:00
* Registers a new `GskRenderNode` type for the given @node_name using
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
* the type information in @node_info.
*
* Returns: the newly registered GType
*/
GType
rendernode: Get rid of GskRenderNodeTypeInfo Instead, use class_init functions.
2023-04-03 14:39:52 +00:00
gsk_render_node_type_register_static (const char *node_name,
gsize instance_size,
GClassInitFunc class_init)
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
{
GTypeInfo info;
info.class_size = sizeof (GskRenderNodeClass);
info.base_init = NULL;
info.base_finalize = NULL;
rendernode: Get rid of GskRenderNodeTypeInfo Instead, use class_init functions.
2023-04-03 14:39:52 +00:00
info.class_init = class_init;
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
info.class_finalize = NULL;
rendernode: Get rid of GskRenderNodeTypeInfo Instead, use class_init functions.
2023-04-03 14:39:52 +00:00
info.instance_size = instance_size;
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
info.n_preallocs = 0;
rendernode: Remove instance_init() function It's not used.
2023-04-03 13:00:29 +00:00
info.instance_init = NULL;
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
info.value_table = NULL;
return g_type_register_static (GSK_TYPE_RENDER_NODE, node_name, &info, 0);
}
/*< private >
* gsk_render_node_alloc:
rendernode: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:57 +00:00
* @node_type: the `GskRenderNode`Type to instantiate
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
*
rendernode: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:57 +00:00
* Instantiates a new `GskRenderNode` for the given @node_type.
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
*
rendernode: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:57 +00:00
* Returns: (transfer full) (type GskRenderNode): the newly created `GskRenderNode`
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
*/
gpointer
gsk_render_node_alloc (GskRenderNodeType node_type)
{
g_return_val_if_fail (node_type > GSK_NOT_A_RENDER_NODE, NULL);
g_return_val_if_fail (node_type < GSK_RENDER_NODE_TYPE_N_TYPES, NULL);
g_assert (gsk_render_node_types[node_type] != G_TYPE_INVALID);
return g_type_create_instance (gsk_render_node_types[node_type]);
gsk: Turn GskRenderNode into a pure GTypeInstance Using GObject as the base type for a transient tree may prove to be too intensive, especially when creating a lot of node instances. Since we don't need properties or signals, and we don't need complex destruction semantics, we can use GTypeInstance directly as the base type for GskRenderNode.
2016-06-29 18:05:33 +00:00
}
/**
* gsk_render_node_ref:
rendernode: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:57 +00:00
* @node: a `GskRenderNode`
gsk: Turn GskRenderNode into a pure GTypeInstance Using GObject as the base type for a transient tree may prove to be too intensive, especially when creating a lot of node instances. Since we don't need properties or signals, and we don't need complex destruction semantics, we can use GTypeInstance directly as the base type for GskRenderNode.
2016-06-29 18:05:33 +00:00
*
rendernode: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:57 +00:00
* Acquires a reference on the given `GskRenderNode`.
gsk: Turn GskRenderNode into a pure GTypeInstance Using GObject as the base type for a transient tree may prove to be too intensive, especially when creating a lot of node instances. Since we don't need properties or signals, and we don't need complex destruction semantics, we can use GTypeInstance directly as the base type for GskRenderNode.
2016-06-29 18:05:33 +00:00
*
rendernode: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:57 +00:00
* Returns: (transfer full): the `GskRenderNode` with an additional reference
gsk: Turn GskRenderNode into a pure GTypeInstance Using GObject as the base type for a transient tree may prove to be too intensive, especially when creating a lot of node instances. Since we don't need properties or signals, and we don't need complex destruction semantics, we can use GTypeInstance directly as the base type for GskRenderNode.
2016-06-29 18:05:33 +00:00
*/
GskRenderNode *
gsk: remove excessive type checking within GSK Anything that includes gskrendernodeprivate.h will get an alternate form of ref/unref for render nodes which does not need to do type checking on the parameter. We can expect that things are correct within GTK itself and this saves excessive amounts of TypeNode conformities checking.
2023-09-27 01:28:11 +00:00
(gsk_render_node_ref) (GskRenderNode *node)
gsk: Turn GskRenderNode into a pure GTypeInstance Using GObject as the base type for a transient tree may prove to be too intensive, especially when creating a lot of node instances. Since we don't need properties or signals, and we don't need complex destruction semantics, we can use GTypeInstance directly as the base type for GskRenderNode.
2016-06-29 18:05:33 +00:00
{
g_return_val_if_fail (GSK_IS_RENDER_NODE (node), NULL);
gsk: remove excessive type checking within GSK Anything that includes gskrendernodeprivate.h will get an alternate form of ref/unref for render nodes which does not need to do type checking on the parameter. We can expect that things are correct within GTK itself and this saves excessive amounts of TypeNode conformities checking.
2023-09-27 01:28:11 +00:00
return _gsk_render_node_ref (node);
}
gsk: Turn GskRenderNode into a pure GTypeInstance Using GObject as the base type for a transient tree may prove to be too intensive, especially when creating a lot of node instances. Since we don't need properties or signals, and we don't need complex destruction semantics, we can use GTypeInstance directly as the base type for GskRenderNode.
2016-06-29 18:05:33 +00:00
gsk: remove excessive type checking within GSK Anything that includes gskrendernodeprivate.h will get an alternate form of ref/unref for render nodes which does not need to do type checking on the parameter. We can expect that things are correct within GTK itself and this saves excessive amounts of TypeNode conformities checking.
2023-09-27 01:28:11 +00:00
void
_gsk_render_node_unref (GskRenderNode *node)
{
if G_UNLIKELY (g_atomic_ref_count_dec (&node->ref_count))
GSK_RENDER_NODE_GET_CLASS (node)->finalize (node);
gsk: Turn GskRenderNode into a pure GTypeInstance Using GObject as the base type for a transient tree may prove to be too intensive, especially when creating a lot of node instances. Since we don't need properties or signals, and we don't need complex destruction semantics, we can use GTypeInstance directly as the base type for GskRenderNode.
2016-06-29 18:05:33 +00:00
}
gsk: remove excessive type checking within GSK Anything that includes gskrendernodeprivate.h will get an alternate form of ref/unref for render nodes which does not need to do type checking on the parameter. We can expect that things are correct within GTK itself and this saves excessive amounts of TypeNode conformities checking.
2023-09-27 01:28:11 +00:00
gsk: Turn GskRenderNode into a pure GTypeInstance Using GObject as the base type for a transient tree may prove to be too intensive, especially when creating a lot of node instances. Since we don't need properties or signals, and we don't need complex destruction semantics, we can use GTypeInstance directly as the base type for GskRenderNode.
2016-06-29 18:05:33 +00:00
/**
* gsk_render_node_unref:
rendernode: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:57 +00:00
* @node: (transfer full): a `GskRenderNode`
gsk: Turn GskRenderNode into a pure GTypeInstance Using GObject as the base type for a transient tree may prove to be too intensive, especially when creating a lot of node instances. Since we don't need properties or signals, and we don't need complex destruction semantics, we can use GTypeInstance directly as the base type for GskRenderNode.
2016-06-29 18:05:33 +00:00
*
rendernode: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:57 +00:00
* Releases a reference on the given `GskRenderNode`.
gsk: Turn GskRenderNode into a pure GTypeInstance Using GObject as the base type for a transient tree may prove to be too intensive, especially when creating a lot of node instances. Since we don't need properties or signals, and we don't need complex destruction semantics, we can use GTypeInstance directly as the base type for GskRenderNode.
2016-06-29 18:05:33 +00:00
*
* If the reference was the last, the resources associated to the @node are
* freed.
*/
void
gsk: remove excessive type checking within GSK Anything that includes gskrendernodeprivate.h will get an alternate form of ref/unref for render nodes which does not need to do type checking on the parameter. We can expect that things are correct within GTK itself and this saves excessive amounts of TypeNode conformities checking.
2023-09-27 01:28:11 +00:00
(gsk_render_node_unref) (GskRenderNode *node)
gsk: Turn GskRenderNode into a pure GTypeInstance Using GObject as the base type for a transient tree may prove to be too intensive, especially when creating a lot of node instances. Since we don't need properties or signals, and we don't need complex destruction semantics, we can use GTypeInstance directly as the base type for GskRenderNode.
2016-06-29 18:05:33 +00:00
{
g_return_if_fail (GSK_IS_RENDER_NODE (node));
gsk: remove excessive type checking within GSK Anything that includes gskrendernodeprivate.h will get an alternate form of ref/unref for render nodes which does not need to do type checking on the parameter. We can expect that things are correct within GTK itself and this saves excessive amounts of TypeNode conformities checking.
2023-09-27 01:28:11 +00:00
_gsk_render_node_unref (node);
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
}
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
gsk: Add GskRenderNodeType For now, this is unused.
2016-12-10 20:42:01 +00:00
/**
* gsk_render_node_get_node_type:
rendernode: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:57 +00:00
* @node: a `GskRenderNode`
gsk: Add GskRenderNodeType For now, this is unused.
2016-12-10 20:42:01 +00:00
*
* Returns the type of the @node.
*
rendernode: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:57 +00:00
* Returns: the type of the `GskRenderNode`
gsk: Add GskRenderNodeType For now, this is unused.
2016-12-10 20:42:01 +00:00
*/
GskRenderNodeType
gsk: make gsk_render_node_get_node_type() use const There isn't any state to modify in the type so we can use const here. Doing so allows some of the renderer code to use const across a number of functions so that repeated calls are elided if inlined.
2021-02-04 04:53:23 +00:00
gsk_render_node_get_node_type (const GskRenderNode *node)
gsk: Add GskRenderNodeType For now, this is unused.
2016-12-10 20:42:01 +00:00
{
g_return_val_if_fail (GSK_IS_RENDER_NODE (node), GSK_NOT_A_RENDER_NODE);
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
return GSK_RENDER_NODE_GET_CLASS (node)->node_type;
gsk: Add GskRenderNodeType For now, this is unused.
2016-12-10 20:42:01 +00:00
}
Add pure and const annotations to various functions
2020-01-24 12:17:09 +00:00
G_GNUC_PURE static inline
render node: Optimize type checks The GSK_IS_RENDER_NODE macro is a bit silly, and not worth having in g_return_if_fail checks in trivial getters.
2019-06-01 21:25:55 +00:00
GskRenderNodeType
Add pure and const annotations to various functions
2020-01-24 12:17:09 +00:00
_gsk_render_node_get_node_type (const GskRenderNode *node)
render node: Optimize type checks The GSK_IS_RENDER_NODE macro is a bit silly, and not worth having in g_return_if_fail checks in trivial getters.
2019-06-01 21:25:55 +00:00
{
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
return GSK_RENDER_NODE_GET_CLASS (node)->node_type;
render node: Optimize type checks The GSK_IS_RENDER_NODE macro is a bit silly, and not worth having in g_return_if_fail checks in trivial getters.
2019-06-01 21:25:55 +00:00
}
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
/**
* gsk_render_node_get_bounds:
rendernode: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:57 +00:00
* @node: a `GskRenderNode`
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
* @bounds: (out caller-allocates): return location for the boundaries
*
rendernode: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:57 +00:00
* Retrieves the boundaries of the @node.
*
* The node will not draw outside of its boundaries.
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
*/
void
gsk_render_node_get_bounds (GskRenderNode *node,
graphene_rect_t *bounds)
{
g_return_if_fail (GSK_IS_RENDER_NODE (node));
g_return_if_fail (bounds != NULL);
gsk: Add bounds member to RenderNode Instead of constantly recalculating this (especially recursively for parents!) we do it only on construction, because everything is immutable anyway. Also, most nodes had a bounds already and can use the new parent member instead. We also do direct access to the node bounds rather than calling gsk_render_node_get_bounds in various places, which means we do less copying.
2016-12-21 10:21:38 +00:00
graphene_rect_init_from_rect (bounds, &node->bounds);
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
}
gsk: Add gsk_render_node_draw() Draws a node to a given cairo_t. This is mostly intended for fallback usage.
2016-12-13 02:05:15 +00:00
void
cairo: Add colorstate to GskRenderNode::draw and use it This adds the following: - ccs argument to GskRenderNode::draw This is the compositing color state to use when drawing. - make implementations use the CCS argument FIXME: Some implementations are missing - gsk_render_node_draw_with_color_state() Draws a node with any color state, by switching to its compositing color state, drawing in that color state and then converting to the desired color state. This does draw the result OVER the previous contents in the passed in color state, so this function should be called with the target being empty. - gsk_render_node_draw_ccs() This needs to be passed a css and then draws with that ccs. The main use for this is chaining up in rendernode draw() implementations. - split out shared Cairo functions into gdkcairoprivate.h gskrendernode.c and gskrendernodeimpl.c need the same functions. Plus, there's various code in GDK that wants to use it, so put it in gdk/ not in gsk/ gsk_render_node_draw() now calls gsk_render_node_draw_with_color_state() with GDK_COLOR_STATE_SRGB.
2024-07-02 05:02:09 +00:00
gsk_render_node_draw_ccs (GskRenderNode *node,
cairo_t *cr,
GdkColorState *ccs)
gsk: Add gsk_render_node_draw() Draws a node to a given cairo_t. This is mostly intended for fallback usage.
2016-12-13 02:05:15 +00:00
{
cairo: Add colorstate to GskRenderNode::draw and use it This adds the following: - ccs argument to GskRenderNode::draw This is the compositing color state to use when drawing. - make implementations use the CCS argument FIXME: Some implementations are missing - gsk_render_node_draw_with_color_state() Draws a node with any color state, by switching to its compositing color state, drawing in that color state and then converting to the desired color state. This does draw the result OVER the previous contents in the passed in color state, so this function should be called with the target being empty. - gsk_render_node_draw_ccs() This needs to be passed a css and then draws with that ccs. The main use for this is chaining up in rendernode draw() implementations. - split out shared Cairo functions into gdkcairoprivate.h gskrendernode.c and gskrendernodeimpl.c need the same functions. Plus, there's various code in GDK that wants to use it, so put it in gdk/ not in gsk/ gsk_render_node_draw() now calls gsk_render_node_draw_with_color_state() with GDK_COLOR_STATE_SRGB.
2024-07-02 05:02:09 +00:00
/* Check that the calling function did pass a correct color state */
g_assert (ccs == gdk_color_state_get_rendering_color_state (ccs));
gsk: Add gsk_render_node_draw() Draws a node to a given cairo_t. This is mostly intended for fallback usage.
2016-12-13 02:05:15 +00:00
cairo_save (cr);
cairo: Add colorstate to GskRenderNode::draw and use it This adds the following: - ccs argument to GskRenderNode::draw This is the compositing color state to use when drawing. - make implementations use the CCS argument FIXME: Some implementations are missing - gsk_render_node_draw_with_color_state() Draws a node with any color state, by switching to its compositing color state, drawing in that color state and then converting to the desired color state. This does draw the result OVER the previous contents in the passed in color state, so this function should be called with the target being empty. - gsk_render_node_draw_ccs() This needs to be passed a css and then draws with that ccs. The main use for this is chaining up in rendernode draw() implementations. - split out shared Cairo functions into gdkcairoprivate.h gskrendernode.c and gskrendernodeimpl.c need the same functions. Plus, there's various code in GDK that wants to use it, so put it in gdk/ not in gsk/ gsk_render_node_draw() now calls gsk_render_node_draw_with_color_state() with GDK_COLOR_STATE_SRGB.
2024-07-02 05:02:09 +00:00
GSK_RENDER_NODE_GET_CLASS (node)->draw (node, cr, ccs);
gsk: Add gsk_render_node_draw() Draws a node to a given cairo_t. This is mostly intended for fallback usage.
2016-12-13 02:05:15 +00:00
gsk: Reorganize env vars Get rid of GSK_RENDERING_MODE and add the flags to GSK_DEBUG, following the same pattern we use in gdk now.
2018-01-14 20:11:33 +00:00
if (GSK_DEBUG_CHECK (GEOMETRY))
gsk: Add gsk_render_node_draw() Draws a node to a given cairo_t. This is mostly intended for fallback usage.
2016-12-13 02:05:15 +00:00
{
cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
gsk: Add bounds member to RenderNode Instead of constantly recalculating this (especially recursively for parents!) we do it only on construction, because everything is immutable anyway. Also, most nodes had a bounds already and can use the new parent member instead. We also do direct access to the node bounds rather than calling gsk_render_node_get_bounds in various places, which means we do less copying.
2016-12-21 10:21:38 +00:00
cairo_rectangle (cr, node->bounds.origin.x - 1, node->bounds.origin.y - 1,
node->bounds.size.width + 2, node->bounds.size.height + 2);
gsk: Add gsk_render_node_draw() Draws a node to a given cairo_t. This is mostly intended for fallback usage.
2016-12-13 02:05:15 +00:00
cairo_set_line_width (cr, 2);
cairo_set_source_rgba (cr, 0, 0, 0, 0.5);
cairo_stroke (cr);
}
cairo_restore (cr);
gsk: Warn on cairo errors during gsk_render_node_draw() It's the same warning we use inside GTK for when stuff weirdly goes wrong.
2016-12-23 04:56:17 +00:00
if (cairo_status (cr))
{
rendernode: Remove gsk_render_node_set_name() And of course, gsk_render_node_get_name() is gone, too. The replacement is of course debug nodes. As a side effect, GskRenderNode is now *really* immutable.
2018-04-24 01:46:44 +00:00
g_warning ("drawing failure for render node %s: %s",
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
g_type_name_from_instance ((GTypeInstance *) node),
gsk: Warn on cairo errors during gsk_render_node_draw() It's the same warning we use inside GTK for when stuff weirdly goes wrong.
2016-12-23 04:56:17 +00:00
cairo_status_to_string (cairo_status (cr)));
}
gsk: Add gsk_render_node_draw() Draws a node to a given cairo_t. This is mostly intended for fallback usage.
2016-12-13 02:05:15 +00:00
}
cairo: Add colorstate to GskRenderNode::draw and use it This adds the following: - ccs argument to GskRenderNode::draw This is the compositing color state to use when drawing. - make implementations use the CCS argument FIXME: Some implementations are missing - gsk_render_node_draw_with_color_state() Draws a node with any color state, by switching to its compositing color state, drawing in that color state and then converting to the desired color state. This does draw the result OVER the previous contents in the passed in color state, so this function should be called with the target being empty. - gsk_render_node_draw_ccs() This needs to be passed a css and then draws with that ccs. The main use for this is chaining up in rendernode draw() implementations. - split out shared Cairo functions into gdkcairoprivate.h gskrendernode.c and gskrendernodeimpl.c need the same functions. Plus, there's various code in GDK that wants to use it, so put it in gdk/ not in gsk/ gsk_render_node_draw() now calls gsk_render_node_draw_with_color_state() with GDK_COLOR_STATE_SRGB.
2024-07-02 05:02:09 +00:00
void
gsk_render_node_draw_with_color_state (GskRenderNode *node,
cairo_t *cr,
GdkColorState *color_state)
{
GdkColorState *ccs;
ccs = gdk_color_state_get_rendering_color_state (color_state);
if (gdk_color_state_equal (color_state, ccs))
{
gsk_render_node_draw_ccs (node, cr, ccs);
}
else
{
cairo_save (cr);
gdk_cairo_rect (cr, &node->bounds);
cairo_clip (cr);
cairo_push_group (cr);
gsk_render_node_draw_ccs (node, cr, ccs);
gdk_cairo_surface_convert_color_state (cairo_get_group_target (cr),
ccs,
color_state);
cairo_pop_group_to_source (cr);
cairo_paint (cr);
cairo_restore (cr);
}
}
/**
* gsk_render_node_draw:
* @node: a `GskRenderNode`
* @cr: cairo context to draw to
*
* Draw the contents of @node to the given cairo context.
*
* Typically, you'll use this function to implement fallback rendering
* of `GskRenderNode`s on an intermediate Cairo context, instead of using
* the drawing context associated to a [class@Gdk.Surface]'s rendering buffer.
*
* For advanced nodes that cannot be supported using Cairo, in particular
* for nodes doing 3D operations, this function may fail.
**/
void
gsk_render_node_draw (GskRenderNode *node,
cairo_t *cr)
{
g_return_if_fail (GSK_IS_RENDER_NODE (node));
g_return_if_fail (cr != NULL);
g_return_if_fail (cairo_status (cr) == CAIRO_STATUS_SUCCESS);
gsk_render_node_draw_with_color_state (node, cr, GDK_COLOR_STATE_SRGB);
}
gsk: Repurpose GSK_DEBUG=cairo Use it to overlay an error pattern over all Cairo drawing done by renderers. This has 2 purposes: 1. It allows detecting fallbacks in GPU renderers. 2. Application code can use it to detect where it is using Cairo drawing. As such, it is meant to trigger both with cairo nodes as well as when renderers fallback for regular nodes. The old use of the debug flag - which were 2 not very useful print statements - was removed.
2023-12-26 03:53:09 +00:00
/*
Fix a typo
2023-12-27 02:54:48 +00:00
* gsk_render_node_draw_fallback:
gsk: Repurpose GSK_DEBUG=cairo Use it to overlay an error pattern over all Cairo drawing done by renderers. This has 2 purposes: 1. It allows detecting fallbacks in GPU renderers. 2. Application code can use it to detect where it is using Cairo drawing. As such, it is meant to trigger both with cairo nodes as well as when renderers fallback for regular nodes. The old use of the debug flag - which were 2 not very useful print statements - was removed.
2023-12-26 03:53:09 +00:00
* @node: a `GskRenderNode`
* @cr: cairo context to draw to
*
* Like gsk_render_node_draw(), but will overlay an error pattern if
* GSK_DEBUG=cairo is enabled.
*
* This has 2 purposes:
* 1. It allows detecting fallbacks in GPU renderers.
* 2. Application code can use it to detect where it is using Cairo
* drawing.
Fix a typo
2023-12-27 02:54:48 +00:00
*
gsk: Repurpose GSK_DEBUG=cairo Use it to overlay an error pattern over all Cairo drawing done by renderers. This has 2 purposes: 1. It allows detecting fallbacks in GPU renderers. 2. Application code can use it to detect where it is using Cairo drawing. As such, it is meant to trigger both with cairo nodes as well as when renderers fallback for regular nodes. The old use of the debug flag - which were 2 not very useful print statements - was removed.
2023-12-26 03:53:09 +00:00
* So use this function whenever either of those cases should be detected.
Fix a typo
2023-12-27 02:54:48 +00:00
*/
gsk: Repurpose GSK_DEBUG=cairo Use it to overlay an error pattern over all Cairo drawing done by renderers. This has 2 purposes: 1. It allows detecting fallbacks in GPU renderers. 2. Application code can use it to detect where it is using Cairo drawing. As such, it is meant to trigger both with cairo nodes as well as when renderers fallback for regular nodes. The old use of the debug flag - which were 2 not very useful print statements - was removed.
2023-12-26 03:53:09 +00:00
void
gsk_render_node_draw_fallback (GskRenderNode *node,
cairo_t *cr)
{
gsk_render_node_draw (node, cr);
if (GSK_DEBUG_CHECK (CAIRO))
{
/* pink, black
* black, pink
*/
rendernode: Use different hilights When hilighting Cairo nodes, use a different hilight color than when hilighting other nodes. This allows differentiating application use of Cairo (via nodes) from renderer use of Cairo (via fallback).
2023-12-26 16:15:26 +00:00
static const guint32 fallback_pixels[] = { 0xFFFF00CC, 0xFF000000,
0xFF000000, 0xFFFF00CC };
static const guint32 cairo_pixels[] = { 0xFF9900FF, 0xFF000000,
0xFF000000, 0xFF9900FF };
const guint32 *pixels;
gsk: Repurpose GSK_DEBUG=cairo Use it to overlay an error pattern over all Cairo drawing done by renderers. This has 2 purposes: 1. It allows detecting fallbacks in GPU renderers. 2. Application code can use it to detect where it is using Cairo drawing. As such, it is meant to trigger both with cairo nodes as well as when renderers fallback for regular nodes. The old use of the debug flag - which were 2 not very useful print statements - was removed.
2023-12-26 03:53:09 +00:00
cairo_surface_t *surface;
cairo_save (cr);
rendernode: Use different hilights When hilighting Cairo nodes, use a different hilight color than when hilighting other nodes. This allows differentiating application use of Cairo (via nodes) from renderer use of Cairo (via fallback).
2023-12-26 16:15:26 +00:00
if (GSK_RENDER_NODE_TYPE (node) == GSK_CAIRO_NODE)
pixels = cairo_pixels;
else
pixels = fallback_pixels;
gsk: Repurpose GSK_DEBUG=cairo Use it to overlay an error pattern over all Cairo drawing done by renderers. This has 2 purposes: 1. It allows detecting fallbacks in GPU renderers. 2. Application code can use it to detect where it is using Cairo drawing. As such, it is meant to trigger both with cairo nodes as well as when renderers fallback for regular nodes. The old use of the debug flag - which were 2 not very useful print statements - was removed.
2023-12-26 03:53:09 +00:00
surface = cairo_image_surface_create_for_data ((guchar *) pixels,
CAIRO_FORMAT_ARGB32,
2, 2,
2 * 4);
cairo_scale (cr, 10, 10);
cairo_set_source_surface (cr, surface, 0, 0);
cairo_pattern_set_filter (cairo_get_source (cr), CAIRO_FILTER_NEAREST);
cairo_pattern_set_extend (cairo_get_source (cr), CAIRO_EXTEND_REPEAT);
cairo_paint_with_alpha (cr, 0.6);
cairo_surface_destroy (surface);
cairo_restore (cr);
}
}
rendernode: Add gsk_render_node_diff() ... and gsk_render_node_can_diff(). Those are vfuncs to compute a region containing all the pixels that differ between the two nodes. This is just the plumbing that chains into node classes. No node implements it yet.
2018-03-20 00:37:05 +00:00
/*
* gsk_render_node_can_diff:
rendernode: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:57 +00:00
* @node1: a `GskRenderNode`
* @node2: the `GskRenderNode` to compare with
rendernode: Add gsk_render_node_diff() ... and gsk_render_node_can_diff(). Those are vfuncs to compute a region containing all the pixels that differ between the two nodes. This is just the plumbing that chains into node classes. No node implements it yet.
2018-03-20 00:37:05 +00:00
*
Trivial
2019-05-25 21:52:15 +00:00
* Checks if two render nodes can be expected to be compared via
rendernode: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:57 +00:00
* gsk_render_node_diff().
*
* The node diffing algorithm uses this function to match up similar
* nodes to compare when trying to minimize the resulting region.
rendernode: Add gsk_render_node_diff() ... and gsk_render_node_can_diff(). Those are vfuncs to compute a region containing all the pixels that differ between the two nodes. This is just the plumbing that chains into node classes. No node implements it yet.
2018-03-20 00:37:05 +00:00
*
* Nodes of different type always return %FALSE here.
*
* Returns: %TRUE if @node1 and @node2 can be expected to be compared
**/
gboolean
Add pure and const annotations to various functions
2020-01-24 12:17:09 +00:00
gsk_render_node_can_diff (const GskRenderNode *node1,
const GskRenderNode *node2)
rendernode: Add gsk_render_node_diff() ... and gsk_render_node_can_diff(). Those are vfuncs to compute a region containing all the pixels that differ between the two nodes. This is just the plumbing that chains into node classes. No node implements it yet.
2018-03-20 00:37:05 +00:00
{
if (node1 == node2)
return TRUE;
gsk: Make rendernode diffing smarter Allow comparing container nodes to any other node, by pretending the other node is a single child container (if it isn't one already). This fixes a glitch where we redraw the full entry text when the blinking cursor goes to opacity 0, since GskSnapshot then optimizes away first the opacity node, and then the single-child container.
2021-03-28 14:18:23 +00:00
if (_gsk_render_node_get_node_type (node1) == _gsk_render_node_get_node_type (node2))
return GSK_RENDER_NODE_GET_CLASS (node1)->can_diff (node1, node2);
rendernode: Add gsk_render_node_diff() ... and gsk_render_node_can_diff(). Those are vfuncs to compute a region containing all the pixels that differ between the two nodes. This is just the plumbing that chains into node classes. No node implements it yet.
2018-03-20 00:37:05 +00:00
gsk: Make rendernode diffing smarter Allow comparing container nodes to any other node, by pretending the other node is a single child container (if it isn't one already). This fixes a glitch where we redraw the full entry text when the blinking cursor goes to opacity 0, since GskSnapshot then optimizes away first the opacity node, and then the single-child container.
2021-03-28 14:18:23 +00:00
if (_gsk_render_node_get_node_type (node1) == GSK_CONTAINER_NODE ||
_gsk_render_node_get_node_type (node2) == GSK_CONTAINER_NODE)
return TRUE;
return FALSE;
rendernode: Add gsk_render_node_diff() ... and gsk_render_node_can_diff(). Those are vfuncs to compute a region containing all the pixels that differ between the two nodes. This is just the plumbing that chains into node classes. No node implements it yet.
2018-03-20 00:37:05 +00:00
}
static void
rectangle_init_from_graphene (cairo_rectangle_int_t *cairo,
const graphene_rect_t *graphene)
{
cairo->x = floorf (graphene->origin.x);
cairo->y = floorf (graphene->origin.y);
cairo->width = ceilf (graphene->origin.x + graphene->size.width) - cairo->x;
cairo->height = ceilf (graphene->origin.y + graphene->size.height) - cairo->y;
}
void
gsk_render_node_diff_impossible (GskRenderNode *node1,
GskRenderNode *node2,
Rework diffing one more time Pass the surface along. We need it to identify the inspector case in gsk_subsurface_node_diff.
2024-02-11 20:53:37 +00:00
GskDiffData *data)
rendernode: Add gsk_render_node_diff() ... and gsk_render_node_can_diff(). Those are vfuncs to compute a region containing all the pixels that differ between the two nodes. This is just the plumbing that chains into node classes. No node implements it yet.
2018-03-20 00:37:05 +00:00
{
cairo_rectangle_int_t rect;
rectangle_init_from_graphene (&rect, &node1->bounds);
Rework diffing one more time Pass the surface along. We need it to identify the inspector case in gsk_subsurface_node_diff.
2024-02-11 20:53:37 +00:00
cairo_region_union_rectangle (data->region, &rect);
rendernode: Add gsk_render_node_diff() ... and gsk_render_node_can_diff(). Those are vfuncs to compute a region containing all the pixels that differ between the two nodes. This is just the plumbing that chains into node classes. No node implements it yet.
2018-03-20 00:37:05 +00:00
rectangle_init_from_graphene (&rect, &node2->bounds);
Rework diffing one more time Pass the surface along. We need it to identify the inspector case in gsk_subsurface_node_diff.
2024-02-11 20:53:37 +00:00
cairo_region_union_rectangle (data->region, &rect);
rendernode: Add gsk_render_node_diff() ... and gsk_render_node_can_diff(). Those are vfuncs to compute a region containing all the pixels that differ between the two nodes. This is just the plumbing that chains into node classes. No node implements it yet.
2018-03-20 00:37:05 +00:00
}
/**
* gsk_render_node_diff:
rendernode: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:57 +00:00
* @node1: a `GskRenderNode`
* @node2: the `GskRenderNode` to compare with
Rework diffing one more time Pass the surface along. We need it to identify the inspector case in gsk_subsurface_node_diff.
2024-02-11 20:53:37 +00:00
* @data: the diff data to use
rendernode: Add gsk_render_node_diff() ... and gsk_render_node_can_diff(). Those are vfuncs to compute a region containing all the pixels that differ between the two nodes. This is just the plumbing that chains into node classes. No node implements it yet.
2018-03-20 00:37:05 +00:00
*
* Compares @node1 and @node2 trying to compute the minimal region of changes.
rendernode: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:57 +00:00
*
rendernode: Add gsk_render_node_diff() ... and gsk_render_node_can_diff(). Those are vfuncs to compute a region containing all the pixels that differ between the two nodes. This is just the plumbing that chains into node classes. No node implements it yet.
2018-03-20 00:37:05 +00:00
* In the worst case, this is the union of the bounds of @node1 and @node2.
*
* This function is used to compute the area that needs to be redrawn when
* the previous contents were drawn by @node1 and the new contents should
* correspond to @node2. As such, it is important that this comparison is
* faster than the time it takes to actually do the redraw.
*
* Note that the passed in @region may already contain previous results from
* previous node comparisons, so this function call will only add to it.
gsk: Add a subsurface mode to node diffing Add an extra argument to pass offload info to the diffing code. This is then used for diffing subsurface nodes differently, depending on their offloading status.
2023-10-31 23:07:23 +00:00
*/
rendernode: Add gsk_render_node_diff() ... and gsk_render_node_can_diff(). Those are vfuncs to compute a region containing all the pixels that differ between the two nodes. This is just the plumbing that chains into node classes. No node implements it yet.
2018-03-20 00:37:05 +00:00
void
gsk_render_node_diff (GskRenderNode *node1,
GskRenderNode *node2,
Rework diffing one more time Pass the surface along. We need it to identify the inspector case in gsk_subsurface_node_diff.
2024-02-11 20:53:37 +00:00
GskDiffData *data)
rendernode: Add gsk_render_node_diff() ... and gsk_render_node_can_diff(). Those are vfuncs to compute a region containing all the pixels that differ between the two nodes. This is just the plumbing that chains into node classes. No node implements it yet.
2018-03-20 00:37:05 +00:00
{
if (node1 == node2)
return;
gsk: Make rendernode diffing smarter Allow comparing container nodes to any other node, by pretending the other node is a single child container (if it isn't one already). This fixes a glitch where we redraw the full entry text when the blinking cursor goes to opacity 0, since GskSnapshot then optimizes away first the opacity node, and then the single-child container.
2021-03-28 14:18:23 +00:00
if (_gsk_render_node_get_node_type (node1) == _gsk_render_node_get_node_type (node2))
gsk: Add a subsurface mode to node diffing Add an extra argument to pass offload info to the diffing code. This is then used for diffing subsurface nodes differently, depending on their offloading status.
2023-10-31 23:07:23 +00:00
{
Rework diffing one more time Pass the surface along. We need it to identify the inspector case in gsk_subsurface_node_diff.
2024-02-11 20:53:37 +00:00
GSK_RENDER_NODE_GET_CLASS (node1)->diff (node1, node2, data);
gsk: Add a subsurface mode to node diffing Add an extra argument to pass offload info to the diffing code. This is then used for diffing subsurface nodes differently, depending on their offloading status.
2023-10-31 23:07:23 +00:00
}
GSK: Fix builds against latest stable GLib with MSVC GLib-2.68.x now considers warning C4098 ('void' function returning a value) as an error, so avoid doing that.
2021-04-16 03:33:00 +00:00
else if (_gsk_render_node_get_node_type (node1) == GSK_CONTAINER_NODE)
gsk: Add a subsurface mode to node diffing Add an extra argument to pass offload info to the diffing code. This is then used for diffing subsurface nodes differently, depending on their offloading status.
2023-10-31 23:07:23 +00:00
{
Rework diffing one more time Pass the surface along. We need it to identify the inspector case in gsk_subsurface_node_diff.
2024-02-11 20:53:37 +00:00
gsk_container_node_diff_with (node1, node2, data);
gsk: Add a subsurface mode to node diffing Add an extra argument to pass offload info to the diffing code. This is then used for diffing subsurface nodes differently, depending on their offloading status.
2023-10-31 23:07:23 +00:00
}
GSK: Fix builds against latest stable GLib with MSVC GLib-2.68.x now considers warning C4098 ('void' function returning a value) as an error, so avoid doing that.
2021-04-16 03:33:00 +00:00
else if (_gsk_render_node_get_node_type (node2) == GSK_CONTAINER_NODE)
gsk: Add a subsurface mode to node diffing Add an extra argument to pass offload info to the diffing code. This is then used for diffing subsurface nodes differently, depending on their offloading status.
2023-10-31 23:07:23 +00:00
{
Rework diffing one more time Pass the surface along. We need it to identify the inspector case in gsk_subsurface_node_diff.
2024-02-11 20:53:37 +00:00
gsk_container_node_diff_with (node2, node1, data);
gsk: Add a subsurface mode to node diffing Add an extra argument to pass offload info to the diffing code. This is then used for diffing subsurface nodes differently, depending on their offloading status.
2023-10-31 23:07:23 +00:00
}
GSK: Fix builds against latest stable GLib with MSVC GLib-2.68.x now considers warning C4098 ('void' function returning a value) as an error, so avoid doing that.
2021-04-16 03:33:00 +00:00
else
gsk: Add a subsurface mode to node diffing Add an extra argument to pass offload info to the diffing code. This is then used for diffing subsurface nodes differently, depending on their offloading status.
2023-10-31 23:07:23 +00:00
{
Rework diffing one more time Pass the surface along. We need it to identify the inspector case in gsk_subsurface_node_diff.
2024-02-11 20:53:37 +00:00
gsk_render_node_diff_impossible (node1, node2, data);
gsk: Add a subsurface mode to node diffing Add an extra argument to pass offload info to the diffing code. This is then used for diffing subsurface nodes differently, depending on their offloading status.
2023-10-31 23:07:23 +00:00
}
rendernode: Add gsk_render_node_diff() ... and gsk_render_node_can_diff(). Those are vfuncs to compute a region containing all the pixels that differ between the two nodes. This is just the plumbing that chains into node classes. No node implements it yet.
2018-03-20 00:37:05 +00:00
}
gsk: Add gsk_render_node_get_opaque_rect() Gets a rectangle inside the rendernode that is opaque. This function only adds the API. So far, no implementation exists.
2023-04-03 12:52:00 +00:00
/**
* gsk_render_node_get_opaque_rect:
* @self: a `GskRenderNode`
* @out_opaque: (out):
*
* Gets an opaque rectangle inside the node that GTK can determine to
* be fully opaque.
*
* There is no guarantee that this is indeed the largest opaque rectangle or
* that regions outside the rectangle are not opaque. This function is a best
* effort with that goal.
*
* The rectangle will be fully contained in the bounds of the node.
*
* Returns: %TRUE if part or all of the rendernode is opaque, %FALSE if no
* opaque region could be found.
*
* Since: 4.16
**/
gboolean
gsk_render_node_get_opaque_rect (GskRenderNode *self,
graphene_rect_t *out_opaque)
{
g_return_val_if_fail (GSK_IS_RENDER_NODE (self), FALSE);
g_return_val_if_fail (out_opaque != NULL, FALSE);
rendernode: Add fully-opaque flag Allows rendernodes to advertise themselves as fully opaque. This is used as a fast path for get_opaque_rect().
2024-07-07 16:24:53 +00:00
if (self->fully_opaque)
{
*out_opaque = self->bounds;
return TRUE;
}
gsk: Add gsk_render_node_get_opaque_rect() Gets a rectangle inside the rendernode that is opaque. This function only adds the API. So far, no implementation exists.
2023-04-03 12:52:00 +00:00
return GSK_RENDER_NODE_GET_CLASS (self)->get_opaque_rect (self, out_opaque);
}
gsk: Add gsk_render_node_write_to_file() For when you're in a debugger and need to have a closer look at this node...
2016-12-23 04:58:07 +00:00
/**
* gsk_render_node_write_to_file:
rendernode: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:57 +00:00
* @node: a `GskRenderNode`
Add type annotations for filename arguments Add missing "(type filename)" annotations for string arguments that are filenames. Fixes: #633
2021-06-12 15:12:06 +00:00
* @filename: (type filename): the file to save it to.
gsk: Add gsk_render_node_write_to_file() For when you're in a debugger and need to have a closer look at this node...
2016-12-23 04:58:07 +00:00
* @error: Return location for a potential error
*
docs: Improve docs for gskrendernode.c
2022-01-05 11:43:06 +00:00
* This function is equivalent to calling [method@Gsk.RenderNode.serialize]
* followed by [func@GLib.file_set_contents].
rendernode: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:57 +00:00
*
* See those two functions for details on the arguments.
gsk: Add gsk_render_node_write_to_file() For when you're in a debugger and need to have a closer look at this node...
2016-12-23 04:58:07 +00:00
*
* It is mostly intended for use inside a debugger to quickly dump a render
* node to a file for later inspection.
*
* Returns: %TRUE if saving was successful
**/
gboolean
gsk_render_node_write_to_file (GskRenderNode *node,
const char *filename,
GError **error)
{
GBytes *bytes;
gboolean result;
g_return_val_if_fail (GSK_IS_RENDER_NODE (node), FALSE);
g_return_val_if_fail (filename != NULL, FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
bytes = gsk_render_node_serialize (node);
result = g_file_set_contents (filename,
g_bytes_get_data (bytes, NULL),
g_bytes_get_size (bytes),
error);
gsk: Fix memory leak in gsk_render_node_write_to_file()
2016-12-23 12:08:43 +00:00
g_bytes_unref (bytes);
gsk: Add gsk_render_node_write_to_file() For when you're in a debugger and need to have a closer look at this node...
2016-12-23 04:58:07 +00:00
return result;
}
gsk: Add docs and error handling to serialization API
2016-12-23 07:03:36 +00:00
/**
* gsk_render_node_deserialize:
* @bytes: the bytes containing the data
Use the appropriate annotations for a callback closure The (closure) annotation with an parameter is meant to be used on the callback argument, and point to the user data argument.
2024-07-03 16:21:04 +00:00
* @error_func: (nullable) (scope call) (closure user_data): Callback on parsing errors
* @user_data: user_data for @error_func
gsk: Add docs and error handling to serialization API
2016-12-23 07:03:36 +00:00
*
docs: Improve docs for gskrendernode.c
2022-01-05 11:43:06 +00:00
* Loads data previously created via [method@Gsk.RenderNode.serialize].
gsk: Add docs and error handling to serialization API
2016-12-23 07:03:36 +00:00
*
rendernode: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:57 +00:00
* For a discussion of the supported format, see that function.
*
Documentation fixes Mostly fixing up indentation of continuation lines, and other small cleanups.
2021-05-18 21:05:26 +00:00
* Returns: (nullable) (transfer full): a new `GskRenderNode`
rendernode: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:57 +00:00
*/
gsk: Add gsk_render_node_serialize/deserialize() This does a conversion to/from GBytes and is intended for writing tests. It's really crude but it works. And that probably means Alex will (ab)use it for broadway.
2016-12-21 04:43:14 +00:00
GskRenderNode *
Add error func to node deserialization
2019-04-24 16:30:46 +00:00
gsk_render_node_deserialize (GBytes *bytes,
GskParseErrorFunc error_func,
gpointer user_data)
gsk: Add gsk_render_node_serialize/deserialize() This does a conversion to/from GBytes and is intended for writing tests. It's really crude but it works. And that probably means Alex will (ab)use it for broadway.
2016-12-21 04:43:14 +00:00
{
GskRenderNode *node = NULL;
Add error func to node deserialization
2019-04-24 16:30:46 +00:00
node = gsk_render_node_deserialize_from_bytes (bytes, error_func, user_data);
gsk: Add gsk_render_node_serialize/deserialize() This does a conversion to/from GBytes and is intended for writing tests. It's really crude but it works. And that probably means Alex will (ab)use it for broadway.
2016-12-21 04:43:14 +00:00
return node;
}
rendernode: Add GValue functions for render nodes This is needed as GskRenderNode is its own fundamental type and has its own GValue infrastructure. And I want to put render nodes into the clipboard which uses GValues.
2021-08-19 21:36:16 +00:00
/**
* gsk_value_set_render_node:
docs: Improve docs for gskrendernode.c
2022-01-05 11:43:06 +00:00
* @value: a [struct@GObject.Value] initialized with type `GSK_TYPE_RENDER_NODE`
rendernode: Add GValue functions for render nodes This is needed as GskRenderNode is its own fundamental type and has its own GValue infrastructure. And I want to put render nodes into the clipboard which uses GValues.
2021-08-19 21:36:16 +00:00
* @node: a `GskRenderNode`
*
* Stores the given `GskRenderNode` inside `value`.
*
docs: Improve docs for gskrendernode.c
2022-01-05 11:43:06 +00:00
* The [struct@GObject.Value] will acquire a reference to the `node`.
g-i: add missing since 4.6 annotations
2021-10-21 13:56:15 +00:00
*
* Since: 4.6
rendernode: Add GValue functions for render nodes This is needed as GskRenderNode is its own fundamental type and has its own GValue infrastructure. And I want to put render nodes into the clipboard which uses GValues.
2021-08-19 21:36:16 +00:00
*/
void
gsk_value_set_render_node (GValue *value,
GskRenderNode *node)
{
GskRenderNode *old_node;
g_return_if_fail (G_VALUE_HOLDS (value, GSK_TYPE_RENDER_NODE));
old_node = value->data[0].v_pointer;
if (node != NULL)
{
g_return_if_fail (GSK_IS_RENDER_NODE (node));
value->data[0].v_pointer = gsk_render_node_ref (node);
}
else
{
value->data[0].v_pointer = NULL;
}
if (old_node != NULL)
gsk_render_node_unref (old_node);
}
/**
* gsk_value_take_render_node:
docs: Improve docs for gskrendernode.c
2022-01-05 11:43:06 +00:00
* @value: a [struct@GObject.Value] initialized with type `GSK_TYPE_RENDER_NODE`
rendernode: Add GValue functions for render nodes This is needed as GskRenderNode is its own fundamental type and has its own GValue infrastructure. And I want to put render nodes into the clipboard which uses GValues.
2021-08-19 21:36:16 +00:00
* @node: (transfer full) (nullable): a `GskRenderNode`
*
* Stores the given `GskRenderNode` inside `value`.
*
* This function transfers the ownership of the `node` to the `GValue`.
g-i: add missing since 4.6 annotations
2021-10-21 13:56:15 +00:00
*
* Since: 4.6
rendernode: Add GValue functions for render nodes This is needed as GskRenderNode is its own fundamental type and has its own GValue infrastructure. And I want to put render nodes into the clipboard which uses GValues.
2021-08-19 21:36:16 +00:00
*/
void
gsk_value_take_render_node (GValue *value,
GskRenderNode *node)
{
GskRenderNode *old_node;
g_return_if_fail (G_VALUE_HOLDS (value, GSK_TYPE_RENDER_NODE));
old_node = value->data[0].v_pointer;
if (node != NULL)
{
g_return_if_fail (GSK_IS_RENDER_NODE (node));
value->data[0].v_pointer = node;
}
else
{
value->data[0].v_pointer = NULL;
}
if (old_node != NULL)
gsk_render_node_unref (old_node);
}
/**
* gsk_value_get_render_node:
* @value: a `GValue` initialized with type `GSK_TYPE_RENDER_NODE`
*
* Retrieves the `GskRenderNode` stored inside the given `value`.
*
* Returns: (transfer none) (nullable): a `GskRenderNode`
g-i: add missing since 4.6 annotations
2021-10-21 13:56:15 +00:00
*
* Since: 4.6
rendernode: Add GValue functions for render nodes This is needed as GskRenderNode is its own fundamental type and has its own GValue infrastructure. And I want to put render nodes into the clipboard which uses GValues.
2021-08-19 21:36:16 +00:00
*/
GskRenderNode *
gsk_value_get_render_node (const GValue *value)
{
g_return_val_if_fail (G_VALUE_HOLDS (value, GSK_TYPE_RENDER_NODE), NULL);
return value->data[0].v_pointer;
}
/**
* gsk_value_dup_render_node:
docs: Improve docs for gskrendernode.c
2022-01-05 11:43:06 +00:00
* @value: a [struct@GObject.Value] initialized with type `GSK_TYPE_RENDER_NODE`
rendernode: Add GValue functions for render nodes This is needed as GskRenderNode is its own fundamental type and has its own GValue infrastructure. And I want to put render nodes into the clipboard which uses GValues.
2021-08-19 21:36:16 +00:00
*
* Retrieves the `GskRenderNode` stored inside the given `value`, and acquires
* a reference to it.
*
* Returns: (transfer full) (nullable): a `GskRenderNode`
g-i: add missing since 4.6 annotations
2021-10-21 13:56:15 +00:00
*
* Since: 4.6
rendernode: Add GValue functions for render nodes This is needed as GskRenderNode is its own fundamental type and has its own GValue infrastructure. And I want to put render nodes into the clipboard which uses GValues.
2021-08-19 21:36:16 +00:00
*/
GskRenderNode *
gsk_value_dup_render_node (const GValue *value)
{
g_return_val_if_fail (G_VALUE_HOLDS (value, GSK_TYPE_RENDER_NODE), NULL);
if (value->data[0].v_pointer == NULL)
return NULL;
return gsk_render_node_ref (value->data[0].v_pointer);
}
rendernode: Change to gsk_render_node_get_preferred_depth() Instead of just tracking preferred_high_depth(), track the actual depth we'd like to have.
2023-06-15 18:27:13 +00:00
GdkMemoryDepth
gsk_render_node_get_preferred_depth (const GskRenderNode *node)
gsk: Add high depth rendernode api Add private api to find out if the content of a render node should be considered 'deep'. The information is collected at creation time, so there is no tree-walking involved when we are using this information in the renderer. Currently, this comes down to whether there are any texture nodes with high depth textures in the subtree. In the future, we may want to allow marking gradient nodes in this way as well.
2021-10-01 20:23:12 +00:00
{
rendernode: Change to gsk_render_node_get_preferred_depth() Instead of just tracking preferred_high_depth(), track the actual depth we'd like to have.
2023-06-15 18:27:13 +00:00
return node->preferred_depth;
gsk: Add high depth rendernode api Add private api to find out if the content of a render node should be considered 'deep'. The information is collected at creation time, so there is no tree-walking involved when we are using this information in the renderer. Currently, this comes down to whether there are any texture nodes with high depth textures in the subtree. In the future, we may want to allow marking gradient nodes in this way as well.
2021-10-01 20:23:12 +00:00
}
gsk: Collect opacity information Collect information about whether to use offscreens for opacity during node construction, so we don't need to walk the tree repeatedly, later.
2022-04-05 18:55:36 +00:00
/* Whether we need an offscreen to handle opacity correctly for this node.
* We don't if there is only one drawing node inside (could be child
* node, or grandchild, or...).
*
* For containers with multiple children, we can avoid the offscreen if
* the children are known not to overlap.
*/
gboolean
gsk_render_node_use_offscreen_for_opacity (const GskRenderNode *node)
{
return node->offscreen_for_opacity;
}
Reference in New Issue Copy Permalink