AuroraMiddleware/gtk
1
0
Fork 1
mirror of https://gitlab.gnome.org/GNOME/gtk.git synced 2024-12-26 05:31:07 +00:00
Code Issues Projects Releases Wiki Activity
ea28dc8cff
gtk/gsk/gskrendernode.h

636 lines
36 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/>.
*/
Convert headers to #pragma once The conversion was done by guard2one.
2023-03-31 19:11:10 +00:00
#pragma once
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
Use a single compilation symbol We use a compilation symbol in our build to allow the inclusion of specific headers while building GTK, to avoid the need to include only the global header. Each namespace has its own compilation symbol because we used to have different libraries, and strict symbol visibility between libraries; now that we have a single library, and we can use private symbols across namespaces while building GTK, we should have a single compilation symbol, and simplify the build rules.
2019-11-27 13:33:43 +00:00
#if !defined (__GSK_H_INSIDE__) && !defined (GTK_COMPILATION)
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
#error "Only <gsk/gsk.h> can be included directly."
#endif
gsk: Add support for rounded clip rectangles Also add support to GtkSnapshot, so people can push rounded clips.
2016-12-13 20:59:28 +00:00
#include <gsk/gskroundedrect.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 <gsk/gsktypes.h>
Add GskGLShaderNode and GskGLShader A GskGLShader is an abstraction of a GLSL fragment shader that can produce pixel values given inputs: * N (currently max 4) textures * Current arguments for the shader uniform Uniform types are: float,(u)int,bool,vec234) There is also a builder for the uniform arguments which are passed around as immutable GBytes in the built form. A GskGLShaderNode is a render node that renders a GskGLShader inside a specified rectangular bounds. It renders its child nodes as textures and passes those as texture arguments to the shader. You also pass it a uniform arguments object.
2020-09-18 15:46:57 +00:00
#include <gsk/gskglshader.h>
Add error func to node deserialization
2019-04-24 16:30:46 +00:00
#include <gtk/css/gtkcss.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
G_BEGIN_DECLS
#define GSK_TYPE_RENDER_NODE (gsk_render_node_get_type ())
rendernode: Implement proper GSK_IS_RENDERNODE() Use G_TYPE_CHECK_INSTANCE_TYPE() instead of just checking for != NULL. After all, this is a GTypeInstance. Also fixes some gcc complaints when checking node == NULL || GSK_IS_RENDERNODE (node) which gcc was convinced would be always true.
2023-07-10 04:23:45 +00:00
#define GSK_IS_RENDER_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GSK_TYPE_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
gsk: Add docs and error handling to serialization API
2016-12-23 07:03:36 +00:00
#define GSK_SERIALIZATION_ERROR (gsk_serialization_error_quark ())
gsk: Implement linear gradient render nodes
2016-12-15 04:42:31 +00:00
typedef struct _GskColorStop GskColorStop;
gsk: Add GskShadowNode ... and make the icon rendering code use it. This requires moving even more shadow renering code into GSK, but so be it. At least the "shadows not implemented" warning is now gone!
2016-12-18 23:45:35 +00:00
typedef struct _GskShadow GskShadow;
gsk: Implement linear gradient render nodes
2016-12-15 04:42:31 +00:00
docs: Annotate structure types used by GskRenderNodes
2020-12-01 14:01:02 +00:00
/**
* GskColorStop:
* @offset: the offset of the color stop
* @color: the color at the given offset
*
* A color stop in a gradient node.
*/
gsk: Implement linear gradient render nodes
2016-12-15 04:42:31 +00:00
struct _GskColorStop
{
gsk: Make GskColorStop.offset a float Doesn't make sense for this to be double if everything else is float. Also makes it possible to 'easily' pass this to the GPU.
2019-12-17 17:10:38 +00:00
float offset;
gsk: Implement linear gradient render nodes
2016-12-15 04:42:31 +00:00
GdkRGBA color;
};
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
docs: Annotate structure types used by GskRenderNodes
2020-12-01 14:01:02 +00:00
/**
* GskShadow:
* @color: the color of the shadow
* @dx: the horizontal offset of the shadow
* @dy: the vertical offset of the shadow
* @radius: the radius of the shadow
*
* The shadow parameters in a shadow node.
*/
gsk: Add GskShadowNode ... and make the icon rendering code use it. This requires moving even more shadow renering code into GSK, but so be it. At least the "shadows not implemented" warning is now gone!
2016-12-18 23:45:35 +00:00
struct _GskShadow
{
GdkRGBA color;
float dx;
float dy;
float radius;
};
gsk: Avoid using gtk css types in public api Using GtkCssSection in public headers here may be ok from the C perspective, since it all ends up in the same library anyway. But it causes circular dependency problems for our gir files that are still split by namespace. To avoid this problem, copy the GtkCssLocation struct struct as GskParseLocation, and pass take two of them instead of a GtkCssSection in the error callback. Update all users. Fixes: #2454
2020-11-17 03:21:27 +00:00
typedef struct _GskParseLocation GskParseLocation;
docs: Annotate structure types used by GskRenderNodes
2020-12-01 14:01:02 +00:00
/**
* GskParseLocation:
* @bytes: the offset of the location in the parse buffer, as bytes
* @chars: the offset of the location in the parse buffer, as characters
* @lines: the line of the location in the parse buffer
* @line_bytes: the position in the line, as bytes
* @line_chars: the position in the line, as characters
*
* A location in a parse buffer.
*/
gsk: Avoid using gtk css types in public api Using GtkCssSection in public headers here may be ok from the C perspective, since it all ends up in the same library anyway. But it causes circular dependency problems for our gir files that are still split by namespace. To avoid this problem, copy the GtkCssLocation struct struct as GskParseLocation, and pass take two of them instead of a GtkCssSection in the error callback. Update all users. Fixes: #2454
2020-11-17 03:21:27 +00:00
struct _GskParseLocation
{
gsize bytes;
gsize chars;
gsize lines;
gsize line_bytes;
gsize line_chars;
};
gsk: Small documentation additions
2020-02-09 00:36:25 +00:00
/**
* GskParseErrorFunc:
gsk: Avoid using gtk css types in public api Using GtkCssSection in public headers here may be ok from the C perspective, since it all ends up in the same library anyway. But it causes circular dependency problems for our gir files that are still split by namespace. To avoid this problem, copy the GtkCssLocation struct struct as GskParseLocation, and pass take two of them instead of a GtkCssSection in the error callback. Update all users. Fixes: #2454
2020-11-17 03:21:27 +00:00
* @start: start of the error location
* @end: end of the error location
* @error: the error
gsk: Small documentation additions
2020-02-09 00:36:25 +00:00
* @user_data: user data
*
docs: Improve gsk docs Convert link formats, add summaries, and make a few missing things show up in the docs.
2021-02-20 06:09:55 +00:00
* Type of callback that is called when an error occurs
* during node deserialization.
gsk: Small documentation additions
2020-02-09 00:36:25 +00:00
*/
gsk: Avoid using gtk css types in public api Using GtkCssSection in public headers here may be ok from the C perspective, since it all ends up in the same library anyway. But it causes circular dependency problems for our gir files that are still split by namespace. To avoid this problem, copy the GtkCssLocation struct struct as GskParseLocation, and pass take two of them instead of a GtkCssSection in the error callback. Update all users. Fixes: #2454
2020-11-17 03:21:27 +00:00
typedef void (* GskParseErrorFunc) (const GskParseLocation *start,
const GskParseLocation *end,
const GError *error,
gpointer user_data);
Add error func to node deserialization
2019-04-24 16:30:46 +00:00
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: Add docs and error handling to serialization API
2016-12-23 07:03:36 +00:00
GType gsk_render_node_get_type (void) G_GNUC_CONST;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: Add docs and error handling to serialization API
2016-12-23 07:03:36 +00:00
GQuark gsk_serialization_error_quark (void);
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
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
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_render_node_ref (GskRenderNode *node);
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
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
void gsk_render_node_unref (GskRenderNode *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
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
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
GskRenderNodeType 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
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
Make render node getter public Keeping these private does not really buy us anything.
2017-10-20 06:06:20 +00:00
void gsk_render_node_get_bounds (GskRenderNode *node,
graphene_rect_t *bounds);
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
GDK_AVAILABLE_IN_4_16
gboolean gsk_render_node_get_opaque_rect (GskRenderNode *self,
graphene_rect_t *out_opaque);
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
Make render node getter public Keeping these private does not really buy us anything.
2017-10-20 06:06:20 +00:00
void gsk_render_node_draw (GskRenderNode *node,
cairo_t *cr);
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
Make render node getter public Keeping these private does not really buy us anything.
2017-10-20 06:06:20 +00:00
GBytes * gsk_render_node_serialize (GskRenderNode *node);
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
Make render node getter public Keeping these private does not really buy us anything.
2017-10-20 06:06:20 +00:00
gboolean gsk_render_node_write_to_file (GskRenderNode *node,
const char *filename,
GError **error);
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
Add error func to node deserialization
2019-04-24 16:30:46 +00:00
GskRenderNode * gsk_render_node_deserialize (GBytes *bytes,
GskParseErrorFunc error_func,
gpointer user_data);
Make render node getter public Keeping these private does not really buy us anything.
2017-10-20 06:06:20 +00:00
Add get_type() functions for GskRenderNode subclasses The introspection scanner tries to match a type name with a get_type() function, in order to correctly identify a type as a class. If the function is not available, we have two choices: - add some special case inside the introspection scanner, similar to how GParamSpec subclasses are handled in GObject - add a simple get_type() function The latter is the simplest approach, and we don't need to change that much, since we still register all render nodes at once.
2020-04-08 14:34:11 +00:00
#define GSK_TYPE_DEBUG_NODE (gsk_debug_node_get_type())
#define GSK_TYPE_COLOR_NODE (gsk_color_node_get_type())
#define GSK_TYPE_TEXTURE_NODE (gsk_texture_node_get_type())
gsk: Introduce GskTextureScaleNode
2023-02-08 03:52:06 +00:00
#define GSK_TYPE_TEXTURE_SCALE_NODE (gsk_texture_scale_node_get_type())
Add get_type() functions for GskRenderNode subclasses The introspection scanner tries to match a type name with a get_type() function, in order to correctly identify a type as a class. If the function is not available, we have two choices: - add some special case inside the introspection scanner, similar to how GParamSpec subclasses are handled in GObject - add a simple get_type() function The latter is the simplest approach, and we don't need to change that much, since we still register all render nodes at once.
2020-04-08 14:34:11 +00:00
#define GSK_TYPE_LINEAR_GRADIENT_NODE (gsk_linear_gradient_node_get_type())
#define GSK_TYPE_REPEATING_LINEAR_GRADIENT_NODE (gsk_repeating_linear_gradient_node_get_type())
gsk: Add a radial gradient node Only a fallback implementation for now. Fixes #2262
2020-09-12 02:55:37 +00:00
#define GSK_TYPE_RADIAL_GRADIENT_NODE (gsk_radial_gradient_node_get_type())
#define GSK_TYPE_REPEATING_RADIAL_GRADIENT_NODE (gsk_repeating_radial_gradient_node_get_type())
gsk: Add GskConicGradientNode
2020-12-02 23:47:54 +00:00
#define GSK_TYPE_CONIC_GRADIENT_NODE (gsk_conic_gradient_node_get_type())
Add get_type() functions for GskRenderNode subclasses The introspection scanner tries to match a type name with a get_type() function, in order to correctly identify a type as a class. If the function is not available, we have two choices: - add some special case inside the introspection scanner, similar to how GParamSpec subclasses are handled in GObject - add a simple get_type() function The latter is the simplest approach, and we don't need to change that much, since we still register all render nodes at once.
2020-04-08 14:34:11 +00:00
#define GSK_TYPE_BORDER_NODE (gsk_border_node_get_type())
#define GSK_TYPE_INSET_SHADOW_NODE (gsk_inset_shadow_node_get_type())
#define GSK_TYPE_OUTSET_SHADOW_NODE (gsk_outset_shadow_node_get_type())
#define GSK_TYPE_CAIRO_NODE (gsk_cairo_node_get_type())
#define GSK_TYPE_CONTAINER_NODE (gsk_container_node_get_type())
#define GSK_TYPE_TRANSFORM_NODE (gsk_transform_node_get_type())
#define GSK_TYPE_OPACITY_NODE (gsk_opacity_node_get_type())
#define GSK_TYPE_COLOR_MATRIX_NODE (gsk_color_matrix_node_get_type())
#define GSK_TYPE_REPEAT_NODE (gsk_repeat_node_get_type())
#define GSK_TYPE_CLIP_NODE (gsk_clip_node_get_type())
#define GSK_TYPE_ROUNDED_CLIP_NODE (gsk_rounded_clip_node_get_type())
gsk: Add GskFillNode Take a rendernode as source and a GskPath and fill the region inside the path with the source, just like cairo_fill() would.
2020-11-10 23:44:32 +00:00
#define GSK_TYPE_FILL_NODE (gsk_fill_node_get_type())
gsk: Add GskStrokeNode Take a rendernode as source and a GskPath and GskStroke, and fill the area that is covered when stroking the path with the given stroke parameters, like cairo_stroke() would.
2020-11-11 06:36:04 +00:00
#define GSK_TYPE_STROKE_NODE (gsk_stroke_node_get_type())
Add get_type() functions for GskRenderNode subclasses The introspection scanner tries to match a type name with a get_type() function, in order to correctly identify a type as a class. If the function is not available, we have two choices: - add some special case inside the introspection scanner, similar to how GParamSpec subclasses are handled in GObject - add a simple get_type() function The latter is the simplest approach, and we don't need to change that much, since we still register all render nodes at once.
2020-04-08 14:34:11 +00:00
#define GSK_TYPE_SHADOW_NODE (gsk_shadow_node_get_type())
#define GSK_TYPE_BLEND_NODE (gsk_blend_node_get_type())
#define GSK_TYPE_CROSS_FADE_NODE (gsk_cross_fade_node_get_type())
#define GSK_TYPE_TEXT_NODE (gsk_text_node_get_type())
#define GSK_TYPE_BLUR_NODE (gsk_blur_node_get_type())
gsk: Introduce mask nodes Add GskMaskNode, and support it in the render node parser, in the inspector and in GtkSnapshot. The rendering is just fallback for now. Based on old work by Timm Bäder.
2023-02-11 13:59:06 +00:00
#define GSK_TYPE_MASK_NODE (gsk_mask_node_get_type())
Add GskGLShaderNode and GskGLShader A GskGLShader is an abstraction of a GLSL fragment shader that can produce pixel values given inputs: * N (currently max 4) textures * Current arguments for the shader uniform Uniform types are: float,(u)int,bool,vec234) There is also a builder for the uniform arguments which are passed around as immutable GBytes in the built form. A GskGLShaderNode is a render node that renders a GskGLShader inside a specified rectangular bounds. It renders its child nodes as textures and passes those as texture arguments to the shader. You also pass it a uniform arguments object.
2020-09-18 15:46:57 +00:00
#define GSK_TYPE_GL_SHADER_NODE (gsk_gl_shader_node_get_type())
gsk: Add subsurface nodes Also show them in the inspector recorder, with some information.
2023-10-29 15:48:16 +00:00
#define GSK_TYPE_SUBSURFACE_NODE (gsk_subsurface_node_get_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
typedef struct _GskDebugNode GskDebugNode;
typedef struct _GskColorNode GskColorNode;
typedef struct _GskTextureNode GskTextureNode;
gsk: Introduce GskTextureScaleNode
2023-02-08 03:52:06 +00:00
typedef struct _GskTextureScaleNode GskTextureScaleNode;
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
typedef struct _GskLinearGradientNode GskLinearGradientNode;
typedef struct _GskRepeatingLinearGradientNode GskRepeatingLinearGradientNode;
gsk: Add a radial gradient node Only a fallback implementation for now. Fixes #2262
2020-09-12 02:55:37 +00:00
typedef struct _GskRadialGradientNode GskRadialGradientNode;
typedef struct _GskRepeatingRadialGradientNode GskRepeatingRadialGradientNode;
gsk: Add GskConicGradientNode
2020-12-02 23:47:54 +00:00
typedef struct _GskConicGradientNode GskConicGradientNode;
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
typedef struct _GskBorderNode GskBorderNode;
typedef struct _GskInsetShadowNode GskInsetShadowNode;
typedef struct _GskOutsetShadowNode GskOutsetShadowNode;
typedef struct _GskCairoNode GskCairoNode;
typedef struct _GskContainerNode GskContainerNode;
typedef struct _GskTransformNode GskTransformNode;
typedef struct _GskOpacityNode GskOpacityNode;
typedef struct _GskColorMatrixNode GskColorMatrixNode;
typedef struct _GskRepeatNode GskRepeatNode;
typedef struct _GskClipNode GskClipNode;
typedef struct _GskRoundedClipNode GskRoundedClipNode;
gsk: Add GskFillNode Take a rendernode as source and a GskPath and fill the region inside the path with the source, just like cairo_fill() would.
2020-11-10 23:44:32 +00:00
typedef struct _GskFillNode GskFillNode;
gsk: Add GskStrokeNode Take a rendernode as source and a GskPath and GskStroke, and fill the area that is covered when stroking the path with the given stroke parameters, like cairo_stroke() would.
2020-11-11 06:36:04 +00:00
typedef struct _GskStrokeNode GskStrokeNode;
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
typedef struct _GskShadowNode GskShadowNode;
typedef struct _GskBlendNode GskBlendNode;
typedef struct _GskCrossFadeNode GskCrossFadeNode;
typedef struct _GskTextNode GskTextNode;
typedef struct _GskBlurNode GskBlurNode;
gsk: Introduce mask nodes Add GskMaskNode, and support it in the render node parser, in the inspector and in GtkSnapshot. The rendering is just fallback for now. Based on old work by Timm Bäder.
2023-02-11 13:59:06 +00:00
typedef struct _GskMaskNode GskMaskNode;
gsk: Deprecate GskGLShader and the rendernode The new renderers don't support them due to the required complexity of integrating them with Vulkan and the assumptions those nodes make about the renderer (the GL renderer exports its internal APIs into the GLShader). There haven't been any complaints that I'm aware of since 4.14 was released where the default renderer does not support the nodes, so usage in public seems to be close to nonexistant. The 2 uses I know of were workarounds about missing features in GTK that have stopped since GTK now supports them: 1. GStreamer used in to do premultiplication when the old GL renderer did not do so in hardware but on the CPU. 2. Adwaita used it for masking before the mask node wa added in 4.10.
2024-07-04 16:12:16 +00:00
typedef struct _GskGLShaderNode GskGLShaderNode GDK_DEPRECATED_TYPE_IN_4_16_FOR(GtkGLArea);
gsk: Add subsurface nodes Also show them in the inspector recorder, with some information.
2023-10-29 15:48:16 +00:00
typedef struct _GskSubsurfaceNode GskSubsurfaceNode;
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
Add get_type() functions for GskRenderNode subclasses The introspection scanner tries to match a type name with a get_type() function, in order to correctly identify a type as a class. If the function is not available, we have two choices: - add some special case inside the introspection scanner, similar to how GParamSpec subclasses are handled in GObject - add a simple get_type() function The latter is the simplest approach, and we don't need to change that much, since we still register all render nodes at once.
2020-04-08 14:34:11 +00:00
GDK_AVAILABLE_IN_ALL
GType gsk_debug_node_get_type (void) G_GNUC_CONST;
gsk: Add GskDebugNode
2018-04-23 22:41:48 +00:00
GDK_AVAILABLE_IN_ALL
GskRenderNode * gsk_debug_node_new (GskRenderNode *child,
char *message);
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
GskRenderNode * gsk_debug_node_get_child (const GskRenderNode *node) G_GNUC_PURE;
gsk: Add GskDebugNode
2018-04-23 22:41:48 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
const char * gsk_debug_node_get_message (const GskRenderNode *node) G_GNUC_PURE;
gsk: Add GskDebugNode
2018-04-23 22:41:48 +00:00
Add get_type() functions for GskRenderNode subclasses The introspection scanner tries to match a type name with a get_type() function, in order to correctly identify a type as a class. If the function is not available, we have two choices: - add some special case inside the introspection scanner, similar to how GParamSpec subclasses are handled in GObject - add a simple get_type() function The latter is the simplest approach, and we don't need to change that much, since we still register all render nodes at once.
2020-04-08 14:34:11 +00:00
GDK_AVAILABLE_IN_ALL
GType gsk_color_node_get_type (void) G_GNUC_CONST;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: Add gsk_color_node_new()
2016-12-13 02:35:56 +00:00
GskRenderNode * gsk_color_node_new (const GdkRGBA *rgba,
const graphene_rect_t *bounds);
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
const GdkRGBA * gsk_color_node_get_color (const GskRenderNode *node) G_GNUC_PURE;
gsk: Add gsk_color_node_new()
2016-12-13 02:35:56 +00:00
Add get_type() functions for GskRenderNode subclasses The introspection scanner tries to match a type name with a get_type() function, in order to correctly identify a type as a class. If the function is not available, we have two choices: - add some special case inside the introspection scanner, similar to how GParamSpec subclasses are handled in GObject - add a simple get_type() function The latter is the simplest approach, and we don't need to change that much, since we still register all render nodes at once.
2020-04-08 14:34:11 +00:00
GDK_AVAILABLE_IN_ALL
GType gsk_texture_node_get_type (void) G_GNUC_CONST;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
Partially revert GskTexture → GdkTexture rename Excessive use of sed when moving GskTexture to GDK; the GskTextureNode should still live under the GSK namespace.
2017-11-04 15:03:03 +00:00
GskRenderNode * gsk_texture_node_new (GdkTexture *texture,
gsk: Add gsk_texture_node_new() Start the transition into the different node types.
2016-12-10 21:52:22 +00:00
const graphene_rect_t *bounds);
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
GdkTexture * gsk_texture_node_get_texture (const GskRenderNode *node) G_GNUC_PURE;
gsk: Add gsk_texture_node_new() Start the transition into the different node types.
2016-12-10 21:52:22 +00:00
gsk: Introduce GskTextureScaleNode
2023-02-08 03:52:06 +00:00
GDK_AVAILABLE_IN_4_10
GType gsk_texture_scale_node_get_type (void) G_GNUC_CONST;
GDK_AVAILABLE_IN_4_10
GskRenderNode * gsk_texture_scale_node_new (GdkTexture *texture,
const graphene_rect_t *bounds,
GskScalingFilter filter);
GDK_AVAILABLE_IN_4_10
GdkTexture * gsk_texture_scale_node_get_texture (const GskRenderNode *node) G_GNUC_PURE;
GDK_AVAILABLE_IN_4_10
GskScalingFilter gsk_texture_scale_node_get_filter (const GskRenderNode *node) G_GNUC_PURE;
Add get_type() functions for GskRenderNode subclasses The introspection scanner tries to match a type name with a get_type() function, in order to correctly identify a type as a class. If the function is not available, we have two choices: - add some special case inside the introspection scanner, similar to how GParamSpec subclasses are handled in GObject - add a simple get_type() function The latter is the simplest approach, and we don't need to change that much, since we still register all render nodes at once.
2020-04-08 14:34:11 +00:00
GDK_AVAILABLE_IN_ALL
GType gsk_linear_gradient_node_get_type (void) G_GNUC_CONST;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
Make render node getter public Keeping these private does not really buy us anything.
2017-10-20 06:06:20 +00:00
GskRenderNode * gsk_linear_gradient_node_new (const graphene_rect_t *bounds,
const graphene_point_t *start,
const graphene_point_t *end,
const GskColorStop *color_stops,
gsize n_color_stops);
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
const graphene_point_t * gsk_linear_gradient_node_get_start (const GskRenderNode *node) G_GNUC_PURE;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
const graphene_point_t * gsk_linear_gradient_node_get_end (const GskRenderNode *node) G_GNUC_PURE;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
gsize gsk_linear_gradient_node_get_n_color_stops (const GskRenderNode *node) G_GNUC_PURE;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters const This also removes the return if fail macros from these as a good portion of them didn't have them anyway. I think it's fair to say that access to these incorrectly is a programmer error. It significantly reduces the amount of code generated into generally a movss,ret.
2021-02-03 22:49:42 +00:00
const GskColorStop * gsk_linear_gradient_node_get_color_stops (const GskRenderNode *node,
rendernode: Don't mark impure functions as pure Functions with out arguments can never be pure, because they write to a pointer. But pure functions must have no side effects.
2023-12-25 04:18:37 +00:00
gsize *n_stops);
Make render node getter public Keeping these private does not really buy us anything.
2017-10-20 06:06:20 +00:00
Add get_type() functions for GskRenderNode subclasses The introspection scanner tries to match a type name with a get_type() function, in order to correctly identify a type as a class. If the function is not available, we have two choices: - add some special case inside the introspection scanner, similar to how GParamSpec subclasses are handled in GObject - add a simple get_type() function The latter is the simplest approach, and we don't need to change that much, since we still register all render nodes at once.
2020-04-08 14:34:11 +00:00
GDK_AVAILABLE_IN_ALL
GType gsk_repeating_linear_gradient_node_get_type (void) G_GNUC_CONST;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
Make render node getter public Keeping these private does not really buy us anything.
2017-10-20 06:06:20 +00:00
GskRenderNode * gsk_repeating_linear_gradient_node_new (const graphene_rect_t *bounds,
const graphene_point_t *start,
const graphene_point_t *end,
const GskColorStop *color_stops,
gsize n_color_stops);
gsk: Implement linear gradient render nodes
2016-12-15 04:42:31 +00:00
gsk: Add GskConicGradientNode
2020-12-02 23:47:54 +00:00
GDK_AVAILABLE_IN_ALL
GType gsk_conic_gradient_node_get_type (void) G_GNUC_CONST;
GDK_AVAILABLE_IN_ALL
GskRenderNode * gsk_conic_gradient_node_new (const graphene_rect_t *bounds,
const graphene_point_t *center,
float rotation,
const GskColorStop *color_stops,
gsize n_color_stops);
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
const graphene_point_t * gsk_conic_gradient_node_get_center (const GskRenderNode *node) G_GNUC_PURE;
gsk: Add GskConicGradientNode
2020-12-02 23:47:54 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
float gsk_conic_gradient_node_get_rotation (const GskRenderNode *node) G_GNUC_PURE;
g-i: add missing since annotations for 4.2
2021-03-07 15:51:38 +00:00
GDK_AVAILABLE_IN_4_2
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
float gsk_conic_gradient_node_get_angle (const GskRenderNode *node) G_GNUC_PURE;
gskrendernode: Cache angle in conic gradients
2021-01-26 15:15:12 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
gsize gsk_conic_gradient_node_get_n_color_stops (const GskRenderNode *node) G_GNUC_PURE;
gsk: Add GskConicGradientNode
2020-12-02 23:47:54 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters const This also removes the return if fail macros from these as a good portion of them didn't have them anyway. I think it's fair to say that access to these incorrectly is a programmer error. It significantly reduces the amount of code generated into generally a movss,ret.
2021-02-03 22:49:42 +00:00
const GskColorStop * gsk_conic_gradient_node_get_color_stops (const GskRenderNode *node,
rendernode: Don't mark impure functions as pure Functions with out arguments can never be pure, because they write to a pointer. But pure functions must have no side effects.
2023-12-25 04:18:37 +00:00
gsize *n_stops);
gsk: Add GskConicGradientNode
2020-12-02 23:47:54 +00:00
gsk: Add a radial gradient node Only a fallback implementation for now. Fixes #2262
2020-09-12 02:55:37 +00:00
GDK_AVAILABLE_IN_ALL
GType gsk_radial_gradient_node_get_type (void) G_GNUC_CONST;
GDK_AVAILABLE_IN_ALL
GskRenderNode * gsk_radial_gradient_node_new (const graphene_rect_t *bounds,
const graphene_point_t *center,
rendernode: switch to h/vradius
2020-09-12 13:16:17 +00:00
float hradius,
float vradius,
gsk: Add a radial gradient node Only a fallback implementation for now. Fixes #2262
2020-09-12 02:55:37 +00:00
float start,
float end,
const GskColorStop *color_stops,
gsize n_color_stops);
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
gsize gsk_radial_gradient_node_get_n_color_stops (const GskRenderNode *node) G_GNUC_PURE;
gsk: Add a radial gradient node Only a fallback implementation for now. Fixes #2262
2020-09-12 02:55:37 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters const This also removes the return if fail macros from these as a good portion of them didn't have them anyway. I think it's fair to say that access to these incorrectly is a programmer error. It significantly reduces the amount of code generated into generally a movss,ret.
2021-02-03 22:49:42 +00:00
const GskColorStop * gsk_radial_gradient_node_get_color_stops (const GskRenderNode *node,
rendernode: Don't mark impure functions as pure Functions with out arguments can never be pure, because they write to a pointer. But pure functions must have no side effects.
2023-12-25 04:18:37 +00:00
gsize *n_stops);
gsk: Add a radial gradient node Only a fallback implementation for now. Fixes #2262
2020-09-12 02:55:37 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
const graphene_point_t *gsk_radial_gradient_node_get_center (const GskRenderNode *node) G_GNUC_PURE;
gsk: Add a radial gradient node Only a fallback implementation for now. Fixes #2262
2020-09-12 02:55:37 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
float gsk_radial_gradient_node_get_hradius (const GskRenderNode *node) G_GNUC_PURE;
gsk: Add a radial gradient node Only a fallback implementation for now. Fixes #2262
2020-09-12 02:55:37 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
float gsk_radial_gradient_node_get_vradius (const GskRenderNode *node) G_GNUC_PURE;
gsk: Add a radial gradient node Only a fallback implementation for now. Fixes #2262
2020-09-12 02:55:37 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
float gsk_radial_gradient_node_get_start (const GskRenderNode *node) G_GNUC_PURE;
gsk: Add a radial gradient node Only a fallback implementation for now. Fixes #2262
2020-09-12 02:55:37 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
float gsk_radial_gradient_node_get_end (const GskRenderNode *node) G_GNUC_PURE;
gsk: Add a radial gradient node Only a fallback implementation for now. Fixes #2262
2020-09-12 02:55:37 +00:00
GDK_AVAILABLE_IN_ALL
GType gsk_repeating_radial_gradient_node_get_type (void) G_GNUC_CONST;
GDK_AVAILABLE_IN_ALL
GskRenderNode * gsk_repeating_radial_gradient_node_new (const graphene_rect_t *bounds,
const graphene_point_t *center,
rendernode: switch to h/vradius
2020-09-12 13:16:17 +00:00
float hradius,
float vradius,
gsk: Add a radial gradient node Only a fallback implementation for now. Fixes #2262
2020-09-12 02:55:37 +00:00
float start,
float end,
const GskColorStop *color_stops,
gsize n_color_stops);
Add get_type() functions for GskRenderNode subclasses The introspection scanner tries to match a type name with a get_type() function, in order to correctly identify a type as a class. If the function is not available, we have two choices: - add some special case inside the introspection scanner, similar to how GParamSpec subclasses are handled in GObject - add a simple get_type() function The latter is the simplest approach, and we don't need to change that much, since we still register all render nodes at once.
2020-04-08 14:34:11 +00:00
GDK_AVAILABLE_IN_ALL
GType gsk_border_node_get_type (void) G_GNUC_CONST;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: Add GskBorderNode The node draws a solid CSS border, which can be used to cover everything but dashed and dotted borders (double, groove, inset, ...). For different border styles, we overlay multiple nodes and set their colors to transparent for sides with non-matching styles.
2016-12-18 17:14:53 +00:00
GskRenderNode * gsk_border_node_new (const GskRoundedRect *outline,
const float border_width[4],
const GdkRGBA border_color[4]);
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
const GskRoundedRect * gsk_border_node_get_outline (const GskRenderNode *node) G_GNUC_PURE;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
const float * gsk_border_node_get_widths (const GskRenderNode *node) G_GNUC_PURE;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
const GdkRGBA * gsk_border_node_get_colors (const GskRenderNode *node) G_GNUC_PURE;
Make render node getter public Keeping these private does not really buy us anything.
2017-10-20 06:06:20 +00:00
Add get_type() functions for GskRenderNode subclasses The introspection scanner tries to match a type name with a get_type() function, in order to correctly identify a type as a class. If the function is not available, we have two choices: - add some special case inside the introspection scanner, similar to how GParamSpec subclasses are handled in GObject - add a simple get_type() function The latter is the simplest approach, and we don't need to change that much, since we still register all render nodes at once.
2020-04-08 14:34:11 +00:00
GDK_AVAILABLE_IN_ALL
GType gsk_inset_shadow_node_get_type (void) G_GNUC_CONST;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: Add GskInsetShadowNode And again lots of shadow code gets copied to GSK. But we're now almost at a stage where widget-factory does not use cairo nodes anymore.
2016-12-19 04:13:42 +00:00
GskRenderNode * gsk_inset_shadow_node_new (const GskRoundedRect *outline,
const GdkRGBA *color,
float dx,
float dy,
float spread,
float blur_radius);
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
const GskRoundedRect * gsk_inset_shadow_node_get_outline (const GskRenderNode *node) G_GNUC_PURE;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
const GdkRGBA * gsk_inset_shadow_node_get_color (const GskRenderNode *node) G_GNUC_PURE;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
float gsk_inset_shadow_node_get_dx (const GskRenderNode *node) G_GNUC_PURE;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
float gsk_inset_shadow_node_get_dy (const GskRenderNode *node) G_GNUC_PURE;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
float gsk_inset_shadow_node_get_spread (const GskRenderNode *node) G_GNUC_PURE;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
float gsk_inset_shadow_node_get_blur_radius (const GskRenderNode *node) G_GNUC_PURE;
Make render node getter public Keeping these private does not really buy us anything.
2017-10-20 06:06:20 +00:00
Add get_type() functions for GskRenderNode subclasses The introspection scanner tries to match a type name with a get_type() function, in order to correctly identify a type as a class. If the function is not available, we have two choices: - add some special case inside the introspection scanner, similar to how GParamSpec subclasses are handled in GObject - add a simple get_type() function The latter is the simplest approach, and we don't need to change that much, since we still register all render nodes at once.
2020-04-08 14:34:11 +00:00
GDK_AVAILABLE_IN_ALL
GType gsk_outset_shadow_node_get_type (void) G_GNUC_CONST;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: Add GskOutsetShadowNode
2016-12-19 14:39:43 +00:00
GskRenderNode * gsk_outset_shadow_node_new (const GskRoundedRect *outline,
const GdkRGBA *color,
float dx,
float dy,
float spread,
float blur_radius);
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
const GskRoundedRect * gsk_outset_shadow_node_get_outline (const GskRenderNode *node) G_GNUC_PURE;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
const GdkRGBA * gsk_outset_shadow_node_get_color (const GskRenderNode *node) G_GNUC_PURE;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
float gsk_outset_shadow_node_get_dx (const GskRenderNode *node) G_GNUC_PURE;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
float gsk_outset_shadow_node_get_dy (const GskRenderNode *node) G_GNUC_PURE;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
float gsk_outset_shadow_node_get_spread (const GskRenderNode *node) G_GNUC_PURE;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
float gsk_outset_shadow_node_get_blur_radius (const GskRenderNode *node) G_GNUC_PURE;
gsk: Add GskInsetShadowNode And again lots of shadow code gets copied to GSK. But we're now almost at a stage where widget-factory does not use cairo nodes anymore.
2016-12-19 04:13:42 +00:00
Add get_type() functions for GskRenderNode subclasses The introspection scanner tries to match a type name with a get_type() function, in order to correctly identify a type as a class. If the function is not available, we have two choices: - add some special case inside the introspection scanner, similar to how GParamSpec subclasses are handled in GObject - add a simple get_type() function The latter is the simplest approach, and we don't need to change that much, since we still register all render nodes at once.
2020-04-08 14:34:11 +00:00
GDK_AVAILABLE_IN_ALL
GType gsk_cairo_node_get_type (void) G_GNUC_CONST;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: Add gsk_cairo_node_new() Split off Cairo drawn content nodes and require you to allocate them using this new function.
2016-12-11 00:23:02 +00:00
GskRenderNode * gsk_cairo_node_new (const graphene_rect_t *bounds);
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
rendernode: Remove renderer argument It's not needed to create Cairo nodes anymore.
2018-03-24 20:33:08 +00:00
cairo_t * gsk_cairo_node_get_draw_context (GskRenderNode *node);
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
rendernode: Rename all gsk_render_node_peek_*() functions Those are getters, they should be gsk_render_node_get_*() functions.
2020-11-16 23:59:36 +00:00
cairo_surface_t * gsk_cairo_node_get_surface (GskRenderNode *node);
gsk: Add gsk_cairo_node_new() Split off Cairo drawn content nodes and require you to allocate them using this new function.
2016-12-11 00:23:02 +00:00
Add get_type() functions for GskRenderNode subclasses The introspection scanner tries to match a type name with a get_type() function, in order to correctly identify a type as a class. If the function is not available, we have two choices: - add some special case inside the introspection scanner, similar to how GParamSpec subclasses are handled in GObject - add a simple get_type() function The latter is the simplest approach, and we don't need to change that much, since we still register all render nodes at once.
2020-04-08 14:34:11 +00:00
GDK_AVAILABLE_IN_ALL
GType gsk_container_node_get_type (void) G_GNUC_CONST;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
snapshot: Change how gtk_snapshot_push/pop works Instead of appending a container node and adding the nodes to it as they come in, we now collect the nodes until gtk_snapshot_pop() is called and then hand them out in a container node. The caller of gtk_snapshot_push() is then responsible for doing whatever he wants with the created node. Another addigion is the keep_coordinates flag to gtk_snapshot_push() which allows callers to keep the current offset and clip region or discard it. Discarding is useful when doing transforms, keeping it is useful when inserting effect nodes (like the ones I'm about to add).
2016-12-13 01:33:15 +00:00
GskRenderNode * gsk_container_node_new (GskRenderNode **children,
guint n_children);
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
guint gsk_container_node_get_n_children (const GskRenderNode *node) G_GNUC_PURE;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters const This also removes the return if fail macros from these as a good portion of them didn't have them anyway. I think it's fair to say that access to these incorrectly is a programmer error. It significantly reduces the amount of code generated into generally a movss,ret.
2021-02-03 22:49:42 +00:00
GskRenderNode * gsk_container_node_get_child (const GskRenderNode *node,
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
guint idx) G_GNUC_PURE;
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
Add get_type() functions for GskRenderNode subclasses The introspection scanner tries to match a type name with a get_type() function, in order to correctly identify a type as a class. If the function is not available, we have two choices: - add some special case inside the introspection scanner, similar to how GParamSpec subclasses are handled in GObject - add a simple get_type() function The latter is the simplest approach, and we don't need to change that much, since we still register all render nodes at once.
2020-04-08 14:34:11 +00:00
GDK_AVAILABLE_IN_ALL
GType gsk_transform_node_get_type (void) G_GNUC_CONST;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: gsk_render_node_set_transform() => GskTransformNode Instead of having a setter for the transform, have a GskTransformNode. Most of the oprations that GTK does do not require a transform, so it doesn't make sense to have it as a primary attribute. Also, changing the transform requires updating the uniforms of the GL renderer, so we're happy if we can avoid that.
2016-12-12 23:11:06 +00:00
GskRenderNode * gsk_transform_node_new (GskRenderNode *child,
rendernode: Make the transform node take a GskTransform This is an attempt to push GskTransform deeper into the stack.
2019-03-01 05:35:55 +00:00
GskTransform *transform);
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
GskRenderNode * gsk_transform_node_get_child (const GskRenderNode *node) G_GNUC_PURE;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
GskTransform * gsk_transform_node_get_transform (const GskRenderNode *node) G_GNUC_PURE;
gsk: gsk_render_node_set_transform() => GskTransformNode Instead of having a setter for the transform, have a GskTransformNode. Most of the oprations that GTK does do not require a transform, so it doesn't make sense to have it as a primary attribute. Also, changing the transform requires updating the uniforms of the GL renderer, so we're happy if we can avoid that.
2016-12-12 23:11:06 +00:00
Add get_type() functions for GskRenderNode subclasses The introspection scanner tries to match a type name with a get_type() function, in order to correctly identify a type as a class. If the function is not available, we have two choices: - add some special case inside the introspection scanner, similar to how GParamSpec subclasses are handled in GObject - add a simple get_type() function The latter is the simplest approach, and we don't need to change that much, since we still register all render nodes at once.
2020-04-08 14:34:11 +00:00
GDK_AVAILABLE_IN_ALL
GType gsk_opacity_node_get_type (void) G_GNUC_CONST;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: Replace gsk_render_node_set_opacity() ... with gsk_opacity_node_new(). Also implement support for opacity in gtk_widget_snapshot() using this new node.
2016-12-13 04:49:57 +00:00
GskRenderNode * gsk_opacity_node_new (GskRenderNode *child,
rendernodes: Use floats for everything
2019-12-18 08:48:25 +00:00
float opacity);
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
GskRenderNode * gsk_opacity_node_get_child (const GskRenderNode *node) G_GNUC_PURE;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
float gsk_opacity_node_get_opacity (const GskRenderNode *node) G_GNUC_PURE;
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
Add get_type() functions for GskRenderNode subclasses The introspection scanner tries to match a type name with a get_type() function, in order to correctly identify a type as a class. If the function is not available, we have two choices: - add some special case inside the introspection scanner, similar to how GParamSpec subclasses are handled in GObject - add a simple get_type() function The latter is the simplest approach, and we don't need to change that much, since we still register all render nodes at once.
2020-04-08 14:34:11 +00:00
GDK_AVAILABLE_IN_ALL
GType gsk_color_matrix_node_get_type (void) G_GNUC_CONST;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: Add GskColorMatrixNode This node essentially implements the feColorMatrix SVG filter. I got the idea yesterday after looking at the opacity implementation. It can be used for opacity (not sure if we want to) and to implement a bunch of the CSS filters.
2016-12-31 00:13:19 +00:00
GskRenderNode * gsk_color_matrix_node_new (GskRenderNode *child,
const graphene_matrix_t *color_matrix,
const graphene_vec4_t *color_offset);
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
GskRenderNode * gsk_color_matrix_node_get_child (const GskRenderNode *node) G_GNUC_PURE;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
Make render node getter public Keeping these private does not really buy us anything.
2017-10-20 06:06:20 +00:00
const graphene_matrix_t *
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
gsk_color_matrix_node_get_color_matrix (const GskRenderNode *node) G_GNUC_PURE;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
const graphene_vec4_t * gsk_color_matrix_node_get_color_offset (const GskRenderNode *node) G_GNUC_PURE;
gsk: Add GskColorMatrixNode This node essentially implements the feColorMatrix SVG filter. I got the idea yesterday after looking at the opacity implementation. It can be used for opacity (not sure if we want to) and to implement a bunch of the CSS filters.
2016-12-31 00:13:19 +00:00
Add get_type() functions for GskRenderNode subclasses The introspection scanner tries to match a type name with a get_type() function, in order to correctly identify a type as a class. If the function is not available, we have two choices: - add some special case inside the introspection scanner, similar to how GParamSpec subclasses are handled in GObject - add a simple get_type() function The latter is the simplest approach, and we don't need to change that much, since we still register all render nodes at once.
2020-04-08 14:34:11 +00:00
GDK_AVAILABLE_IN_ALL
GType gsk_repeat_node_get_type (void) G_GNUC_CONST;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: Add GskRepeatNode Also add gtk_snapshot_push_repeat() and use that to draw backgrounds. With that change, CSS background snapshots are created without Cairo nodes.
2017-01-01 18:52:18 +00:00
GskRenderNode * gsk_repeat_node_new (const graphene_rect_t *bounds,
GskRenderNode *child,
const graphene_rect_t *child_bounds);
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
GskRenderNode * gsk_repeat_node_get_child (const GskRenderNode *node) G_GNUC_PURE;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
const graphene_rect_t * gsk_repeat_node_get_child_bounds (const GskRenderNode *node) G_GNUC_PURE;
gsk: Add GskRepeatNode Also add gtk_snapshot_push_repeat() and use that to draw backgrounds. With that change, CSS background snapshots are created without Cairo nodes.
2017-01-01 18:52:18 +00:00
Add get_type() functions for GskRenderNode subclasses The introspection scanner tries to match a type name with a get_type() function, in order to correctly identify a type as a class. If the function is not available, we have two choices: - add some special case inside the introspection scanner, similar to how GParamSpec subclasses are handled in GObject - add a simple get_type() function The latter is the simplest approach, and we don't need to change that much, since we still register all render nodes at once.
2020-04-08 14:34:11 +00:00
GDK_AVAILABLE_IN_ALL
GType gsk_clip_node_get_type (void) G_GNUC_CONST;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: Add gsk_clip_node_new() The node is a simple clipping node: It does a rectangular clip of its contents.
2016-12-13 08:37:51 +00:00
GskRenderNode * gsk_clip_node_new (GskRenderNode *child,
const graphene_rect_t *clip);
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
GskRenderNode * gsk_clip_node_get_child (const GskRenderNode *node) G_GNUC_PURE;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
const graphene_rect_t * gsk_clip_node_get_clip (const GskRenderNode *node) G_GNUC_PURE;
Make render node getter public Keeping these private does not really buy us anything.
2017-10-20 06:06:20 +00:00
Add get_type() functions for GskRenderNode subclasses The introspection scanner tries to match a type name with a get_type() function, in order to correctly identify a type as a class. If the function is not available, we have two choices: - add some special case inside the introspection scanner, similar to how GParamSpec subclasses are handled in GObject - add a simple get_type() function The latter is the simplest approach, and we don't need to change that much, since we still register all render nodes at once.
2020-04-08 14:34:11 +00:00
GDK_AVAILABLE_IN_ALL
GType gsk_rounded_clip_node_get_type (void) G_GNUC_CONST;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: Add support for rounded clip rectangles Also add support to GtkSnapshot, so people can push rounded clips.
2016-12-13 20:59:28 +00:00
GskRenderNode * gsk_rounded_clip_node_new (GskRenderNode *child,
const GskRoundedRect *clip);
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
GskRenderNode * gsk_rounded_clip_node_get_child (const GskRenderNode *node) G_GNUC_PURE;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
const GskRoundedRect * gsk_rounded_clip_node_get_clip (const GskRenderNode *node) G_GNUC_PURE;
gsk: Add support for rounded clip rectangles Also add support to GtkSnapshot, so people can push rounded clips.
2016-12-13 20:59:28 +00:00
gsk: Add GskFillNode Take a rendernode as source and a GskPath and fill the region inside the path with the source, just like cairo_fill() would.
2020-11-10 23:44:32 +00:00
GDK_AVAILABLE_IN_4_14
GType gsk_fill_node_get_type (void) G_GNUC_CONST;
GDK_AVAILABLE_IN_4_14
GskRenderNode * gsk_fill_node_new (GskRenderNode *child,
GskPath *path,
GskFillRule fill_rule);
GDK_AVAILABLE_IN_4_14
GskRenderNode * gsk_fill_node_get_child (const GskRenderNode *node);
GDK_AVAILABLE_IN_4_14
GskPath * gsk_fill_node_get_path (const GskRenderNode *node);
GDK_AVAILABLE_IN_4_14
GskFillRule gsk_fill_node_get_fill_rule (const GskRenderNode *node);
gsk: Add GskStrokeNode Take a rendernode as source and a GskPath and GskStroke, and fill the area that is covered when stroking the path with the given stroke parameters, like cairo_stroke() would.
2020-11-11 06:36:04 +00:00
GDK_AVAILABLE_IN_4_14
GType gsk_stroke_node_get_type (void) G_GNUC_CONST;
GDK_AVAILABLE_IN_4_14
GskRenderNode * gsk_stroke_node_new (GskRenderNode *child,
GskPath *path,
const GskStroke *stroke);
GDK_AVAILABLE_IN_4_14
GskRenderNode * gsk_stroke_node_get_child (const GskRenderNode *node);
GDK_AVAILABLE_IN_4_14
GskPath * gsk_stroke_node_get_path (const GskRenderNode *node);
GDK_AVAILABLE_IN_4_14
const GskStroke * gsk_stroke_node_get_stroke (const GskRenderNode *node);
Add get_type() functions for GskRenderNode subclasses The introspection scanner tries to match a type name with a get_type() function, in order to correctly identify a type as a class. If the function is not available, we have two choices: - add some special case inside the introspection scanner, similar to how GParamSpec subclasses are handled in GObject - add a simple get_type() function The latter is the simplest approach, and we don't need to change that much, since we still register all render nodes at once.
2020-04-08 14:34:11 +00:00
GDK_AVAILABLE_IN_ALL
GType gsk_shadow_node_get_type (void) G_GNUC_CONST;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: Add GskShadowNode ... and make the icon rendering code use it. This requires moving even more shadow renering code into GSK, but so be it. At least the "shadows not implemented" warning is now gone!
2016-12-18 23:45:35 +00:00
GskRenderNode * gsk_shadow_node_new (GskRenderNode *child,
const GskShadow *shadows,
gsize n_shadows);
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
GskRenderNode * gsk_shadow_node_get_child (const GskRenderNode *node) G_GNUC_PURE;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters const This also removes the return if fail macros from these as a good portion of them didn't have them anyway. I think it's fair to say that access to these incorrectly is a programmer error. It significantly reduces the amount of code generated into generally a movss,ret.
2021-02-03 22:49:42 +00:00
const GskShadow * gsk_shadow_node_get_shadow (const GskRenderNode *node,
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
gsize i) G_GNUC_PURE;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
gsize gsk_shadow_node_get_n_shadows (const GskRenderNode *node) G_GNUC_PURE;
gsk: Add GskShadowNode ... and make the icon rendering code use it. This requires moving even more shadow renering code into GSK, but so be it. At least the "shadows not implemented" warning is now gone!
2016-12-18 23:45:35 +00:00
Add get_type() functions for GskRenderNode subclasses The introspection scanner tries to match a type name with a get_type() function, in order to correctly identify a type as a class. If the function is not available, we have two choices: - add some special case inside the introspection scanner, similar to how GParamSpec subclasses are handled in GObject - add a simple get_type() function The latter is the simplest approach, and we don't need to change that much, since we still register all render nodes at once.
2020-04-08 14:34:11 +00:00
GDK_AVAILABLE_IN_ALL
GType gsk_blend_node_get_type (void) G_GNUC_CONST;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: Add blend nodes Implement blend mode support in GTK background compositing with it.
2016-12-15 03:24:37 +00:00
GskRenderNode * gsk_blend_node_new (GskRenderNode *bottom,
GskRenderNode *top,
GskBlendMode blend_mode);
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
GskRenderNode * gsk_blend_node_get_bottom_child (const GskRenderNode *node) G_GNUC_PURE;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
GskRenderNode * gsk_blend_node_get_top_child (const GskRenderNode *node) G_GNUC_PURE;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
GskBlendMode gsk_blend_node_get_blend_mode (const GskRenderNode *node) G_GNUC_PURE;
gsk: Add gsk_texture_node_new() Start the transition into the different node types.
2016-12-10 21:52:22 +00:00
Add get_type() functions for GskRenderNode subclasses The introspection scanner tries to match a type name with a get_type() function, in order to correctly identify a type as a class. If the function is not available, we have two choices: - add some special case inside the introspection scanner, similar to how GParamSpec subclasses are handled in GObject - add a simple get_type() function The latter is the simplest approach, and we don't need to change that much, since we still register all render nodes at once.
2020-04-08 14:34:11 +00:00
GDK_AVAILABLE_IN_ALL
GType gsk_cross_fade_node_get_type (void) G_GNUC_CONST;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: Add cross-fade node And implement stack crossfades with it.
2016-12-17 06:44:10 +00:00
GskRenderNode * gsk_cross_fade_node_new (GskRenderNode *start,
GskRenderNode *end,
rendernodes: Use floats for everything
2019-12-18 08:48:25 +00:00
float progress);
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
GskRenderNode * gsk_cross_fade_node_get_start_child (const GskRenderNode *node) G_GNUC_PURE;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
GskRenderNode * gsk_cross_fade_node_get_end_child (const GskRenderNode *node) G_GNUC_PURE;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
float gsk_cross_fade_node_get_progress (const GskRenderNode *node) G_GNUC_PURE;
gsk: Add cross-fade node And implement stack crossfades with it.
2016-12-17 06:44:10 +00:00
Add get_type() functions for GskRenderNode subclasses The introspection scanner tries to match a type name with a get_type() function, in order to correctly identify a type as a class. If the function is not available, we have two choices: - add some special case inside the introspection scanner, similar to how GParamSpec subclasses are handled in GObject - add a simple get_type() function The latter is the simplest approach, and we don't need to change that much, since we still register all render nodes at once.
2020-04-08 14:34:11 +00:00
GDK_AVAILABLE_IN_ALL
GType gsk_text_node_get_type (void) G_GNUC_CONST;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
Make render node getter public Keeping these private does not really buy us anything.
2017-10-20 06:06:20 +00:00
GskRenderNode * gsk_text_node_new (PangoFont *font,
PangoGlyphString *glyphs,
const GdkRGBA *color,
rendernode: Take a graphene_point_t for the offset ... instead of 2 floats.
2019-05-19 02:08:29 +00:00
const graphene_point_t *offset);
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
PangoFont * gsk_text_node_get_font (const GskRenderNode *node) G_GNUC_PURE;
g-i: add missing since annotations
2021-11-13 16:33:15 +00:00
GDK_AVAILABLE_IN_4_2
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
gboolean gsk_text_node_has_color_glyphs (const GskRenderNode *node) G_GNUC_PURE;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
guint gsk_text_node_get_num_glyphs (const GskRenderNode *node) G_GNUC_PURE;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters const This also removes the return if fail macros from these as a good portion of them didn't have them anyway. I think it's fair to say that access to these incorrectly is a programmer error. It significantly reduces the amount of code generated into generally a movss,ret.
2021-02-03 22:49:42 +00:00
const PangoGlyphInfo *gsk_text_node_get_glyphs (const GskRenderNode *node,
rendernode: Don't mark impure functions as pure Functions with out arguments can never be pure, because they write to a pointer. But pure functions must have no side effects.
2023-12-25 04:18:37 +00:00
guint *n_glyphs);
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
const GdkRGBA * gsk_text_node_get_color (const GskRenderNode *node) G_GNUC_PURE;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
const graphene_point_t *gsk_text_node_get_offset (const GskRenderNode *node) G_GNUC_PURE;
Add a render node for text This is just a wrapper around a PangoGlyphString + PangoFont. Basically, the arguments that are passed to pango_renderer_draw_glyphs.
2017-08-29 21:28:10 +00:00
Add get_type() functions for GskRenderNode subclasses The introspection scanner tries to match a type name with a get_type() function, in order to correctly identify a type as a class. If the function is not available, we have two choices: - add some special case inside the introspection scanner, similar to how GParamSpec subclasses are handled in GObject - add a simple get_type() function The latter is the simplest approach, and we don't need to change that much, since we still register all render nodes at once.
2020-04-08 14:34:11 +00:00
GDK_AVAILABLE_IN_ALL
GType gsk_blur_node_get_type (void) G_GNUC_CONST;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
Make render node getter public Keeping these private does not really buy us anything.
2017-10-20 06:06:20 +00:00
GskRenderNode * gsk_blur_node_new (GskRenderNode *child,
rendernodes: Use floats for everything
2019-12-18 08:48:25 +00:00
float radius);
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
GskRenderNode * gsk_blur_node_get_child (const GskRenderNode *node) G_GNUC_PURE;
The big versioning cleanup Remove all the old 2.x and 3.x version annotations. GTK+ 4 is a new start, and from the perspective of a GTK+ 4 developer all these APIs have been around since the beginning.
2018-02-05 19:13:20 +00:00
GDK_AVAILABLE_IN_ALL
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
float gsk_blur_node_get_radius (const GskRenderNode *node) G_GNUC_PURE;
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
gsk: Introduce mask nodes Add GskMaskNode, and support it in the render node parser, in the inspector and in GtkSnapshot. The rendering is just fallback for now. Based on old work by Timm Bäder.
2023-02-11 13:59:06 +00:00
GDK_AVAILABLE_IN_4_10
GType gsk_mask_node_get_type (void) G_GNUC_CONST;
GDK_AVAILABLE_IN_4_10
GskRenderNode * gsk_mask_node_new (GskRenderNode *source,
Make mask nodes more versatile Add a GskMaskMode enumeration and implement it in the GL and cairo renderers.
2023-02-14 18:44:39 +00:00
GskRenderNode *mask,
GskMaskMode mask_mode);
gsk: Introduce mask nodes Add GskMaskNode, and support it in the render node parser, in the inspector and in GtkSnapshot. The rendering is just fallback for now. Based on old work by Timm Bäder.
2023-02-11 13:59:06 +00:00
GDK_AVAILABLE_IN_4_10
GskRenderNode * gsk_mask_node_get_source (const GskRenderNode *node);
GDK_AVAILABLE_IN_4_10
GskRenderNode * gsk_mask_node_get_mask (const GskRenderNode *node);
Make mask nodes more versatile Add a GskMaskMode enumeration and implement it in the GL and cairo renderers.
2023-02-14 18:44:39 +00:00
GDK_AVAILABLE_IN_4_10
GskMaskMode gsk_mask_node_get_mask_mode (const GskRenderNode *node);
gsk: Introduce mask nodes Add GskMaskNode, and support it in the render node parser, in the inspector and in GtkSnapshot. The rendering is just fallback for now. Based on old work by Timm Bäder.
2023-02-11 13:59:06 +00:00
gsk: Deprecate GskGLShader and the rendernode The new renderers don't support them due to the required complexity of integrating them with Vulkan and the assumptions those nodes make about the renderer (the GL renderer exports its internal APIs into the GLShader). There haven't been any complaints that I'm aware of since 4.14 was released where the default renderer does not support the nodes, so usage in public seems to be close to nonexistant. The 2 uses I know of were workarounds about missing features in GTK that have stopped since GTK now supports them: 1. GStreamer used in to do premultiplication when the old GL renderer did not do so in hardware but on the CPU. 2. Adwaita used it for masking before the mask node wa added in 4.10.
2024-07-04 16:12:16 +00:00
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
GDK_DEPRECATED_IN_4_16_FOR(GtkGLArea)
gsk: Introduce mask nodes Add GskMaskNode, and support it in the render node parser, in the inspector and in GtkSnapshot. The rendering is just fallback for now. Based on old work by Timm Bäder.
2023-02-11 13:59:06 +00:00
GType gsk_gl_shader_node_get_type (void) G_GNUC_CONST;
gsk: Deprecate GskGLShader and the rendernode The new renderers don't support them due to the required complexity of integrating them with Vulkan and the assumptions those nodes make about the renderer (the GL renderer exports its internal APIs into the GLShader). There haven't been any complaints that I'm aware of since 4.14 was released where the default renderer does not support the nodes, so usage in public seems to be close to nonexistant. The 2 uses I know of were workarounds about missing features in GTK that have stopped since GTK now supports them: 1. GStreamer used in to do premultiplication when the old GL renderer did not do so in hardware but on the CPU. 2. Adwaita used it for masking before the mask node wa added in 4.10.
2024-07-04 16:12:16 +00:00
GDK_DEPRECATED_IN_4_16_FOR(GtkGLArea)
Add GskGLShaderNode and GskGLShader A GskGLShader is an abstraction of a GLSL fragment shader that can produce pixel values given inputs: * N (currently max 4) textures * Current arguments for the shader uniform Uniform types are: float,(u)int,bool,vec234) There is also a builder for the uniform arguments which are passed around as immutable GBytes in the built form. A GskGLShaderNode is a render node that renders a GskGLShader inside a specified rectangular bounds. It renders its child nodes as textures and passes those as texture arguments to the shader. You also pass it a uniform arguments object.
2020-09-18 15:46:57 +00:00
GskRenderNode * gsk_gl_shader_node_new (GskGLShader *shader,
const graphene_rect_t *bounds,
GBytes *args,
GskRenderNode **children,
guint n_children);
gsk: Deprecate GskGLShader and the rendernode The new renderers don't support them due to the required complexity of integrating them with Vulkan and the assumptions those nodes make about the renderer (the GL renderer exports its internal APIs into the GLShader). There haven't been any complaints that I'm aware of since 4.14 was released where the default renderer does not support the nodes, so usage in public seems to be close to nonexistant. The 2 uses I know of were workarounds about missing features in GTK that have stopped since GTK now supports them: 1. GStreamer used in to do premultiplication when the old GL renderer did not do so in hardware but on the CPU. 2. Adwaita used it for masking before the mask node wa added in 4.10.
2024-07-04 16:12:16 +00:00
GDK_DEPRECATED_IN_4_16_FOR(GtkGLArea)
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
guint gsk_gl_shader_node_get_n_children (const GskRenderNode *node) G_GNUC_PURE;
gsk: Deprecate GskGLShader and the rendernode The new renderers don't support them due to the required complexity of integrating them with Vulkan and the assumptions those nodes make about the renderer (the GL renderer exports its internal APIs into the GLShader). There haven't been any complaints that I'm aware of since 4.14 was released where the default renderer does not support the nodes, so usage in public seems to be close to nonexistant. The 2 uses I know of were workarounds about missing features in GTK that have stopped since GTK now supports them: 1. GStreamer used in to do premultiplication when the old GL renderer did not do so in hardware but on the CPU. 2. Adwaita used it for masking before the mask node wa added in 4.10.
2024-07-04 16:12:16 +00:00
GDK_DEPRECATED_IN_4_16_FOR(GtkGLArea)
gsk: make render node getters const This also removes the return if fail macros from these as a good portion of them didn't have them anyway. I think it's fair to say that access to these incorrectly is a programmer error. It significantly reduces the amount of code generated into generally a movss,ret.
2021-02-03 22:49:42 +00:00
GskRenderNode * gsk_gl_shader_node_get_child (const GskRenderNode *node,
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
guint idx) G_GNUC_PURE;
gsk: Deprecate GskGLShader and the rendernode The new renderers don't support them due to the required complexity of integrating them with Vulkan and the assumptions those nodes make about the renderer (the GL renderer exports its internal APIs into the GLShader). There haven't been any complaints that I'm aware of since 4.14 was released where the default renderer does not support the nodes, so usage in public seems to be close to nonexistant. The 2 uses I know of were workarounds about missing features in GTK that have stopped since GTK now supports them: 1. GStreamer used in to do premultiplication when the old GL renderer did not do so in hardware but on the CPU. 2. Adwaita used it for masking before the mask node wa added in 4.10.
2024-07-04 16:12:16 +00:00
GDK_DEPRECATED_IN_4_16_FOR(GtkGLArea)
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
GBytes * gsk_gl_shader_node_get_args (const GskRenderNode *node) G_GNUC_PURE;
gsk: Deprecate GskGLShader and the rendernode The new renderers don't support them due to the required complexity of integrating them with Vulkan and the assumptions those nodes make about the renderer (the GL renderer exports its internal APIs into the GLShader). There haven't been any complaints that I'm aware of since 4.14 was released where the default renderer does not support the nodes, so usage in public seems to be close to nonexistant. The 2 uses I know of were workarounds about missing features in GTK that have stopped since GTK now supports them: 1. GStreamer used in to do premultiplication when the old GL renderer did not do so in hardware but on the CPU. 2. Adwaita used it for masking before the mask node wa added in 4.10.
2024-07-04 16:12:16 +00:00
GDK_DEPRECATED_IN_4_16_FOR(GtkGLArea)
gsk: make render node getters pure These do not do modify anything so they can be marked as pure to potentially ellide calls. Since they do dereference, I do not believe we can make them const although that is unclear since we could technically just return a pointer + offset. Therefore it *might* be possible to also make these G_GNUC_CONST.
2021-02-03 23:00:28 +00:00
GskGLShader * gsk_gl_shader_node_get_shader (const GskRenderNode *node) G_GNUC_PURE;
Add GskGLShaderNode and GskGLShader A GskGLShader is an abstraction of a GLSL fragment shader that can produce pixel values given inputs: * N (currently max 4) textures * Current arguments for the shader uniform Uniform types are: float,(u)int,bool,vec234) There is also a builder for the uniform arguments which are passed around as immutable GBytes in the built form. A GskGLShaderNode is a render node that renders a GskGLShader inside a specified rectangular bounds. It renders its child nodes as textures and passes those as texture arguments to the shader. You also pass it a uniform arguments object.
2020-09-18 15:46:57 +00:00
gsk: Deprecate GskGLShader and the rendernode The new renderers don't support them due to the required complexity of integrating them with Vulkan and the assumptions those nodes make about the renderer (the GL renderer exports its internal APIs into the GLShader). There haven't been any complaints that I'm aware of since 4.14 was released where the default renderer does not support the nodes, so usage in public seems to be close to nonexistant. The 2 uses I know of were workarounds about missing features in GTK that have stopped since GTK now supports them: 1. GStreamer used in to do premultiplication when the old GL renderer did not do so in hardware but on the CPU. 2. Adwaita used it for masking before the mask node wa added in 4.10.
2024-07-04 16:12:16 +00:00
G_GNUC_END_IGNORE_DEPRECATIONS
gsk: Add subsurface nodes Also show them in the inspector recorder, with some information.
2023-10-29 15:48:16 +00:00
GDK_AVAILABLE_IN_4_14
GType gsk_subsurface_node_get_type (void) G_GNUC_CONST;
GDK_AVAILABLE_IN_4_14
GskRenderNode * gsk_subsurface_node_new (GskRenderNode *child,
gpointer subsurface);
GDK_AVAILABLE_IN_4_14
GskRenderNode * gsk_subsurface_node_get_child (const GskRenderNode *node) G_GNUC_PURE;
GDK_AVAILABLE_IN_4_14
gpointer gsk_subsurface_node_get_subsurface (const GskRenderNode *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_HOLDS_RENDER_NODE:
* @value: a `GValue`
*
* Evaluates to %TRUE if @value was initialized with %GSK_TYPE_RENDER_NODE.
*/
#define GSK_VALUE_HOLDS_RENDER_NODE(value) (G_VALUE_HOLDS ((value), GSK_TYPE_RENDER_NODE))
GDK_AVAILABLE_IN_4_4
void gsk_value_set_render_node (GValue *value,
GskRenderNode *node);
GDK_AVAILABLE_IN_4_4
void gsk_value_take_render_node (GValue *value,
GskRenderNode *node);
GDK_AVAILABLE_IN_4_4
GskRenderNode * gsk_value_get_render_node (const GValue *value);
GDK_AVAILABLE_IN_4_4
GskRenderNode * gsk_value_dup_render_node (const GValue *value);
gsk: Dissolve gsk-autocleanup.h Move the autocleanup declarations into their respective headers.
2022-09-23 23:40:42 +00:00
G_DEFINE_AUTOPTR_CLEANUP_FUNC(GskRenderNode, gsk_render_node_unref)
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
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
G_END_DECLS
Reference in New Issue Copy Permalink