jean
/
Learning_GTK4_tree
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Learning_GTK4_tree/gtk/gtksnapshot.c

2875 lines
89 KiB
C
Raw Permalink Blame History

/* GTK - The GIMP Toolkit
* Copyright (C) 2016 Benjamin Otte <otte@gnome.org>
*
* 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/>.
*/
#include "config.h"
#include "gtksnapshot.h"
#include "gtksnapshotprivate.h"
#include "gtkcsscolorvalueprivate.h"
#include "gtkcssshadowvalueprivate.h"
#include "gtkdebug.h"
#include "gtkrendernodepaintableprivate.h"
#include "gsktransformprivate.h"
#include "gdk/gdkrgbaprivate.h"
#include "gsk/gskrendernodeprivate.h"
#include "gsk/gskroundedrectprivate.h"
#include "gsk/gskstrokeprivate.h"
#include "gtk/gskpangoprivate.h"
#define GDK_ARRAY_NAME gtk_snapshot_nodes
#define GDK_ARRAY_TYPE_NAME GtkSnapshotNodes
#define GDK_ARRAY_ELEMENT_TYPE GskRenderNode *
#define GDK_ARRAY_FREE_FUNC gsk_render_node_unref
#include "gdk/gdkarrayimpl.c"
/**
* GtkSnapshot:
*
* `GtkSnapshot` assists in creating [class@Gsk.RenderNode]s for widgets.
*
* It functions in a similar way to a cairo context, and maintains a stack
* of render nodes and their associated transformations.
*
* The node at the top of the stack is the one that `gtk_snapshot_append_…()`
* functions operate on. Use the `gtk_snapshot_push_…()` functions and
* [method@Snapshot.pop] to change the current node.
*
* The typical way to obtain a `GtkSnapshot` object is as an argument to
* the [vfunc@Gtk.Widget.snapshot] vfunc. If you need to create your own
* `GtkSnapshot`, use [ctor@Gtk.Snapshot.new].
*/
typedef struct _GtkSnapshotState GtkSnapshotState;
typedef GskRenderNode * (* GtkSnapshotCollectFunc) (GtkSnapshot *snapshot,
GtkSnapshotState *state,
GskRenderNode **nodes,
guint n_nodes);
typedef void (* GtkSnapshotClearFunc) (GtkSnapshotState *state);
struct _GtkSnapshotState {
guint start_node_index;
guint n_nodes;
GskTransform * transform;
GtkSnapshotCollectFunc collect_func;
GtkSnapshotClearFunc clear_func;
union {
struct {
double opacity;
} opacity;
struct {
double radius;
} blur;
struct {
graphene_matrix_t matrix;
graphene_vec4_t offset;
} color_matrix;
struct {
graphene_rect_t bounds;
graphene_rect_t child_bounds;
} repeat;
struct {
graphene_rect_t bounds;
} clip;
struct {
GskGLShader *shader;
GBytes *args;
graphene_rect_t bounds;
GskRenderNode **nodes;
GskRenderNode *internal_nodes[4];
} glshader;
struct {
graphene_rect_t bounds;
int node_idx;
int n_children;
} glshader_texture;
struct {
GskRoundedRect bounds;
} rounded_clip;
struct {
GskPath *path;
GskFillRule fill_rule;
} fill;
struct {
GskPath *path;
GskStroke stroke;
} stroke;
struct {
gsize n_shadows;
GskShadow *shadows;
GskShadow a_shadow; /* Used if n_shadows == 1 */
} shadow;
struct {
GskBlendMode blend_mode;
GskRenderNode *bottom_node;
} blend;
struct {
double progress;
GskRenderNode *start_node;
} cross_fade;
struct {
char *message;
} debug;
struct {
GskMaskMode mask_mode;
GskRenderNode *mask_node;
} mask;
struct {
GdkSubsurface *subsurface;
} subsurface;
} data;
};
static void gtk_snapshot_state_clear (GtkSnapshotState *state);
#define GDK_ARRAY_NAME gtk_snapshot_states
#define GDK_ARRAY_TYPE_NAME GtkSnapshotStates
#define GDK_ARRAY_ELEMENT_TYPE GtkSnapshotState
#define GDK_ARRAY_FREE_FUNC gtk_snapshot_state_clear
#define GDK_ARRAY_BY_VALUE 1
#define GDK_ARRAY_PREALLOC 16
#define GDK_ARRAY_NO_MEMSET 1
#include "gdk/gdkarrayimpl.c"
/* This is a nasty little hack. We typedef GtkSnapshot to the fake object GdkSnapshot
* so that we don't need to typecast between them.
* After all, the GdkSnapshot only exist so poor language bindings don't trip. Hardcore
* C code can just blatantly ignore such layering violations with a typedef.
*/
struct _GdkSnapshot {
GObject parent_instance; /* it's really GdkSnapshot, but don't tell anyone! */
GtkSnapshotStates state_stack;
GtkSnapshotNodes nodes;
};
struct _GtkSnapshotClass {
GObjectClass parent_class; /* it's really GdkSnapshotClass, but don't tell anyone! */
};
G_DEFINE_TYPE (GtkSnapshot, gtk_snapshot, GDK_TYPE_SNAPSHOT)
static void
gtk_snapshot_dispose (GObject *object)
{
GtkSnapshot *snapshot = GTK_SNAPSHOT (object);
if (!gtk_snapshot_states_is_empty (&snapshot->state_stack))
{
GskRenderNode *node = gtk_snapshot_to_node (snapshot);
g_clear_pointer (&node, gsk_render_node_unref);
}
g_assert (gtk_snapshot_states_is_empty (&snapshot->state_stack));
g_assert (gtk_snapshot_nodes_is_empty (&snapshot->nodes));
G_OBJECT_CLASS (gtk_snapshot_parent_class)->dispose (object);
}
static void
gtk_snapshot_class_init (GtkSnapshotClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
gobject_class->dispose = gtk_snapshot_dispose;
}
static GskRenderNode *
gtk_snapshot_collect_default (GtkSnapshot *snapshot,
GtkSnapshotState *state,
GskRenderNode **nodes,
guint n_nodes)
{
GskRenderNode *node;
if (n_nodes == 0)
{
node = NULL;
}
else if (n_nodes == 1)
{
node = gsk_render_node_ref (nodes[0]);
}
else
{
node = gsk_container_node_new (nodes, n_nodes);
}
return node;
}
static GtkSnapshotState *
gtk_snapshot_push_state (GtkSnapshot *snapshot,
GskTransform *transform,
GtkSnapshotCollectFunc collect_func,
GtkSnapshotClearFunc clear_func)
{
const gsize n_states = gtk_snapshot_states_get_size (&snapshot->state_stack);
GtkSnapshotState *state;
gtk_snapshot_states_set_size (&snapshot->state_stack, n_states + 1);
state = gtk_snapshot_states_get (&snapshot->state_stack, n_states);
state->transform = gsk_transform_ref (transform);
state->collect_func = collect_func;
state->clear_func = clear_func;
state->start_node_index = gtk_snapshot_nodes_get_size (&snapshot->nodes);
state->n_nodes = 0;
return state;
}
static GtkSnapshotState *
gtk_snapshot_get_current_state (const GtkSnapshot *snapshot)
{
gsize size = gtk_snapshot_states_get_size (&snapshot->state_stack);
g_assert (size > 0);
return gtk_snapshot_states_get (&snapshot->state_stack, size - 1);
}
static GtkSnapshotState *
gtk_snapshot_get_previous_state (const GtkSnapshot *snapshot)
{
gsize size = gtk_snapshot_states_get_size (&snapshot->state_stack);
g_assert (size > 1);
return gtk_snapshot_states_get (&snapshot->state_stack, size - 2);
}
/* n == 0 => current, n == 1, previous, etc */
static GtkSnapshotState *
gtk_snapshot_get_nth_previous_state (const GtkSnapshot *snapshot,
int n)
{
gsize size = gtk_snapshot_states_get_size (&snapshot->state_stack);
g_assert (size > n);
return gtk_snapshot_states_get (&snapshot->state_stack, size - (1 + n));
}
static void
gtk_snapshot_state_clear (GtkSnapshotState *state)
{
if (state->clear_func)
state->clear_func (state);
gsk_transform_unref (state->transform);
}
static void
gtk_snapshot_init (GtkSnapshot *self)
{
gtk_snapshot_states_init (&self->state_stack);
gtk_snapshot_nodes_init (&self->nodes);
gtk_snapshot_push_state (self,
NULL,
gtk_snapshot_collect_default,
NULL);
}
/**
* gtk_snapshot_new:
*
* Creates a new `GtkSnapshot`.
*
* Returns: a newly-allocated `GtkSnapshot`
*/
GtkSnapshot *
gtk_snapshot_new (void)
{
return g_object_new (GTK_TYPE_SNAPSHOT, NULL);
}
/**
* gtk_snapshot_free_to_node: (skip)
* @snapshot: (transfer full): a `GtkSnapshot`
*
* Returns the node that was constructed by @snapshot
* and frees @snapshot.
*
* See also [method@Gtk.Snapshot.to_node].
*
* Returns: (transfer full) (nullable): a newly-created [class@Gsk.RenderNode]
*/
GskRenderNode *
gtk_snapshot_free_to_node (GtkSnapshot *snapshot)
{
GskRenderNode *result;
result = gtk_snapshot_to_node (snapshot);
g_object_unref (snapshot);
return result;
}
/**
* gtk_snapshot_free_to_paintable: (skip)
* @snapshot: (transfer full): a `GtkSnapshot`
* @size: (nullable): The size of the resulting paintable
* or %NULL to use the bounds of the snapshot
*
* Returns a paintable for the node that was
* constructed by @snapshot and frees @snapshot.
*
* Returns: (transfer full) (nullable): a newly-created [iface@Gdk.Paintable]
*/
GdkPaintable *
gtk_snapshot_free_to_paintable (GtkSnapshot *snapshot,
const graphene_size_t *size)
{
GdkPaintable *result;
result = gtk_snapshot_to_paintable (snapshot, size);
g_object_unref (snapshot);
return result;
}
static GskRenderNode *
gtk_snapshot_collect_autopush_transform (GtkSnapshot *snapshot,
GtkSnapshotState *state,
GskRenderNode **nodes,
guint n_nodes)
{
GskRenderNode *node, *transform_node;
GtkSnapshotState *previous_state;
previous_state = gtk_snapshot_get_previous_state (snapshot);
node = gtk_snapshot_collect_default (snapshot, state, nodes, n_nodes);
if (node == NULL)
return NULL;
transform_node = gsk_transform_node_new (node, previous_state->transform);
gsk_render_node_unref (node);
return transform_node;
}
static void
gtk_snapshot_autopush_transform (GtkSnapshot *snapshot)
{
gtk_snapshot_push_state (snapshot,
NULL,
gtk_snapshot_collect_autopush_transform,
NULL);
}
static gboolean
gtk_snapshot_state_should_autopop (const GtkSnapshotState *state)
{
return state->collect_func == gtk_snapshot_collect_autopush_transform;
}
static GskRenderNode *
gtk_snapshot_collect_debug (GtkSnapshot *snapshot,
GtkSnapshotState *state,
GskRenderNode **nodes,
guint n_nodes)
{
GskRenderNode *node, *debug_node;
node = gtk_snapshot_collect_default (snapshot, state, nodes, n_nodes);
if (node == NULL)
return NULL;
debug_node = gsk_debug_node_new (node, state->data.debug.message);
state->data.debug.message = NULL;
gsk_render_node_unref (node);
return debug_node;
}
static void
gtk_snapshot_clear_debug (GtkSnapshotState *state)
{
g_clear_pointer (&state->data.debug.message, g_free);
}
/**
* gtk_snapshot_push_debug:
* @snapshot: a `GtkSnapshot`
* @message: a printf-style format string
* @...: arguments for @message
*
* Inserts a debug node with a message.
*
* Debug nodes don't affect the rendering at all, but can be
* helpful in identifying parts of a render node tree dump,
* for example in the GTK inspector.
*/
void
gtk_snapshot_push_debug (GtkSnapshot *snapshot,
const char *message,
...)
{
GtkSnapshotState *current_state = gtk_snapshot_get_current_state (snapshot);
if (GTK_DEBUG_CHECK (SNAPSHOT))
{
va_list args;
GtkSnapshotState *state;
state = gtk_snapshot_push_state (snapshot,
current_state->transform,
gtk_snapshot_collect_debug,
gtk_snapshot_clear_debug);
va_start (args, message);
state->data.debug.message = g_strdup_vprintf (message, args);
va_end (args);
}
else
{
gtk_snapshot_push_state (snapshot,
current_state->transform,
gtk_snapshot_collect_default,
NULL);
}
}
static GskRenderNode *
gtk_snapshot_collect_opacity (GtkSnapshot *snapshot,
GtkSnapshotState *state,
GskRenderNode **nodes,
guint n_nodes)
{
GskRenderNode *node, *opacity_node;
node = gtk_snapshot_collect_default (snapshot, state, nodes, n_nodes);
if (node == NULL)
return NULL;
if (state->data.opacity.opacity == 1.0)
{
opacity_node = node;
}
else if (state->data.opacity.opacity == 0.0)
{
GdkRGBA color = GDK_RGBA ("00000000");
graphene_rect_t bounds;
gsk_render_node_get_bounds (node, &bounds);
opacity_node = gsk_color_node_new (&color, &bounds);
gsk_render_node_unref (node);
}
else
{
opacity_node = gsk_opacity_node_new (node, state->data.opacity.opacity);
gsk_render_node_unref (node);
}
return opacity_node;
}
/**
* gtk_snapshot_push_opacity:
* @snapshot: a `GtkSnapshot`
* @opacity: the opacity to use
*
* Modifies the opacity of an image.
*
* The image is recorded until the next call to [method@Gtk.Snapshot.pop].
*/
void
gtk_snapshot_push_opacity (GtkSnapshot *snapshot,
double opacity)
{
GtkSnapshotState *current_state = gtk_snapshot_get_current_state (snapshot);
GtkSnapshotState *state;
state = gtk_snapshot_push_state (snapshot,
current_state->transform,
gtk_snapshot_collect_opacity,
NULL);
state->data.opacity.opacity = CLAMP (opacity, 0.0, 1.0);
}
static GskRenderNode *
gtk_snapshot_collect_blur (GtkSnapshot *snapshot,
GtkSnapshotState *state,
GskRenderNode **nodes,
guint n_nodes)
{
GskRenderNode *node, *blur_node;
double radius;
node = gtk_snapshot_collect_default (snapshot, state, nodes, n_nodes);
if (node == NULL)
return NULL;
radius = state->data.blur.radius;
if (radius == 0.0)
return node;
if (radius < 0)
return node;
blur_node = gsk_blur_node_new (node, radius);
gsk_render_node_unref (node);
return blur_node;
}
/**
* gtk_snapshot_push_blur:
* @snapshot: a `GtkSnapshot`
* @radius: the blur radius to use. Must be positive
*
* Blurs an image.
*
* The image is recorded until the next call to [method@Gtk.Snapshot.pop].
*/
void
gtk_snapshot_push_blur (GtkSnapshot *snapshot,
double radius)
{
const GtkSnapshotState *current_state = gtk_snapshot_get_current_state (snapshot);
GtkSnapshotState *state;
state = gtk_snapshot_push_state (snapshot,
current_state->transform,
gtk_snapshot_collect_blur,
NULL);
state->data.blur.radius = radius;
}
static GskRenderNode *
merge_color_matrix_nodes (const graphene_matrix_t *matrix2,
const graphene_vec4_t *offset2,
GskRenderNode *child)
{
const graphene_matrix_t *matrix1 = gsk_color_matrix_node_get_color_matrix (child);
const graphene_vec4_t *offset1 = gsk_color_matrix_node_get_color_offset (child);
graphene_matrix_t matrix;
graphene_vec4_t offset;
GskRenderNode *result;
g_assert (gsk_render_node_get_node_type (child) == GSK_COLOR_MATRIX_NODE);
/* color matrix node: color = trans(mat) * p + offset; for a pixel p.
* color = trans(mat2) * (trans(mat1) * p + offset1) + offset2
* = trans(mat2) * trans(mat1) * p + trans(mat2) * offset1 + offset2
* = trans(mat1 * mat2) * p + (trans(mat2) * offset1 + offset2)
* Which this code does.
* mat1 and offset1 come from @child.
*/
graphene_matrix_transform_vec4 (matrix2, offset1, &offset);
graphene_vec4_add (&offset, offset2, &offset);
graphene_matrix_multiply (matrix1, matrix2, &matrix);
result = gsk_color_matrix_node_new (gsk_color_matrix_node_get_child (child),
&matrix, &offset);
return result;
}
static GskRenderNode *
gtk_snapshot_collect_color_matrix (GtkSnapshot *snapshot,
GtkSnapshotState *state,
GskRenderNode **nodes,
guint n_nodes)
{
GskRenderNode *node, *result;
node = gtk_snapshot_collect_default (snapshot, state, nodes, n_nodes);
if (node == NULL)
return NULL;
if (gsk_render_node_get_node_type (node) == GSK_COLOR_MATRIX_NODE)
{
result = merge_color_matrix_nodes (&state->data.color_matrix.matrix,
&state->data.color_matrix.offset,
node);
gsk_render_node_unref (node);
}
else if (gsk_render_node_get_node_type (node) == GSK_TRANSFORM_NODE)
{
GskRenderNode *transform_child = gsk_transform_node_get_child (node);
GskRenderNode *color_matrix;
if (gsk_render_node_get_node_type (transform_child) == GSK_COLOR_MATRIX_NODE)
{
color_matrix = merge_color_matrix_nodes (&state->data.color_matrix.matrix,
&state->data.color_matrix.offset,
transform_child);
}
else
{
color_matrix = gsk_color_matrix_node_new (transform_child,
&state->data.color_matrix.matrix,
&state->data.color_matrix.offset);
}
result = gsk_transform_node_new (color_matrix,
gsk_transform_node_get_transform (node));
gsk_render_node_unref (color_matrix);
gsk_render_node_unref (node);
node = NULL;
}
else
{
result = gsk_color_matrix_node_new (node,
&state->data.color_matrix.matrix,
&state->data.color_matrix.offset);
gsk_render_node_unref (node);
}
return result;
}
/**
* gtk_snapshot_push_color_matrix:
* @snapshot: a `GtkSnapshot`
* @color_matrix: the color matrix to use
* @color_offset: the color offset to use
*
* Modifies the colors of an image by applying an affine transformation
* in RGB space.
*
* In particular, the colors will be transformed by applying
*
* pixel = transpose(color_matrix) * pixel + color_offset
*
* for every pixel. The transformation operates on unpremultiplied
* colors, with color components ordered R, G, B, A.
*
* The image is recorded until the next call to [method@Gtk.Snapshot.pop].
*/
void
gtk_snapshot_push_color_matrix (GtkSnapshot *snapshot,
const graphene_matrix_t *color_matrix,
const graphene_vec4_t *color_offset)
{
const GtkSnapshotState *current_state = gtk_snapshot_get_current_state (snapshot);
GtkSnapshotState *state;
state = gtk_snapshot_push_state (snapshot,
current_state->transform,
gtk_snapshot_collect_color_matrix,
NULL);
graphene_matrix_init_from_matrix (&state->data.color_matrix.matrix, color_matrix);
graphene_vec4_init_from_vec4 (&state->data.color_matrix.offset, color_offset);
}
static GskRenderNode *
gtk_snapshot_collect_repeat (GtkSnapshot *snapshot,
GtkSnapshotState *state,
GskRenderNode **nodes,
guint n_nodes)
{
GskRenderNode *node, *repeat_node;
const graphene_rect_t *bounds = &state->data.repeat.bounds;
const graphene_rect_t *child_bounds = &state->data.repeat.child_bounds;
node = gtk_snapshot_collect_default (snapshot, state, nodes, n_nodes);
if (node == NULL)
return NULL;
if (gsk_render_node_get_node_type (node) == GSK_COLOR_NODE &&
graphene_rect_equal (child_bounds, &node->bounds))
{
/* Repeating a color node entirely is pretty easy by just increasing
* the size of the color node. */
GskRenderNode *color_node = gsk_color_node_new (gsk_color_node_get_color (node), bounds);
gsk_render_node_unref (node);
return color_node;
}
repeat_node = gsk_repeat_node_new (bounds,
node,
child_bounds->size.width > 0 ? child_bounds : NULL);
gsk_render_node_unref (node);
return repeat_node;
}
static GskRenderNode *
gtk_snapshot_collect_discard_repeat (GtkSnapshot *snapshot,
GtkSnapshotState *state,
GskRenderNode **nodes,
guint n_nodes)
{
/* Drop the node and return nothing. */
return NULL;
}
static void
gtk_graphene_rect_scale_affine (const graphene_rect_t *rect,
float scale_x,
float scale_y,
float dx,
float dy,
graphene_rect_t *res)
{
res->origin.x = scale_x * rect->origin.x + dx;
res->origin.y = scale_y * rect->origin.y + dy;
res->size.width = scale_x * rect->size.width;
res->size.height = scale_y * rect->size.height;
if (scale_x < 0 || scale_y < 0)
graphene_rect_normalize (res);
}
static void
gtk_snapshot_ensure_affine (GtkSnapshot *snapshot,
float *scale_x,
float *scale_y,
float *dx,
float *dy)
{
const GtkSnapshotState *state = gtk_snapshot_get_current_state (snapshot);
if (gsk_transform_get_category (state->transform) < GSK_TRANSFORM_CATEGORY_2D_AFFINE)
{
gtk_snapshot_autopush_transform (snapshot);
state = gtk_snapshot_get_current_state (snapshot);
gsk_transform_to_affine (state->transform, scale_x, scale_y, dx, dy);
}
else if (gsk_transform_get_category (state->transform) == GSK_TRANSFORM_CATEGORY_2D_AFFINE)
{
gsk_transform_to_affine (state->transform, scale_x, scale_y, dx, dy);
if (*scale_x < 0.0 || *scale_y < 0.0)
{
gtk_snapshot_autopush_transform (snapshot);
state = gtk_snapshot_get_current_state (snapshot);
gsk_transform_to_affine (state->transform, scale_x, scale_y, dx, dy);
}
}
else
{
gsk_transform_to_affine (state->transform, scale_x, scale_y, dx, dy);
}
}
static void
gtk_snapshot_ensure_translate (GtkSnapshot *snapshot,
float *dx,
float *dy)
{
const GtkSnapshotState *state = gtk_snapshot_get_current_state (snapshot);
if (gsk_transform_get_category (state->transform) < GSK_TRANSFORM_CATEGORY_2D_TRANSLATE)
{
gtk_snapshot_autopush_transform (snapshot);
state = gtk_snapshot_get_current_state (snapshot);
}
gsk_transform_to_translate (state->transform, dx, dy);
}
static void
gtk_snapshot_ensure_identity (GtkSnapshot *snapshot)
{
const GtkSnapshotState *state = gtk_snapshot_get_current_state (snapshot);
if (gsk_transform_get_category (state->transform) < GSK_TRANSFORM_CATEGORY_IDENTITY)
gtk_snapshot_autopush_transform (snapshot);
}
/**
* gtk_snapshot_push_repeat:
* @snapshot: a `GtkSnapshot`
* @bounds: the bounds within which to repeat
* @child_bounds: (nullable): the bounds of the child or %NULL
* to use the full size of the collected child node
*
* Creates a node that repeats the child node.
*
* The child is recorded until the next call to [method@Gtk.Snapshot.pop].
*/
void
gtk_snapshot_push_repeat (GtkSnapshot *snapshot,
const graphene_rect_t *bounds,
const graphene_rect_t *child_bounds)
{
GtkSnapshotState *state;
gboolean empty_child_bounds = FALSE;
graphene_rect_t real_child_bounds = { { 0 } };
float scale_x, scale_y, dx, dy;
gtk_snapshot_ensure_affine (snapshot, &scale_x, &scale_y, &dx, &dy);
if (child_bounds)
{
gtk_graphene_rect_scale_affine (child_bounds, scale_x, scale_y, dx, dy, &real_child_bounds);
if (real_child_bounds.size.width <= 0 || real_child_bounds.size.height <= 0)
empty_child_bounds = TRUE;
}
state = gtk_snapshot_push_state (snapshot,
gtk_snapshot_get_current_state (snapshot)->transform,
empty_child_bounds
? gtk_snapshot_collect_discard_repeat
: gtk_snapshot_collect_repeat,
NULL);
gtk_graphene_rect_scale_affine (bounds, scale_x, scale_y, dx, dy, &state->data.repeat.bounds);
state->data.repeat.child_bounds = real_child_bounds;
}
static GskRenderNode *
gtk_snapshot_collect_clip (GtkSnapshot *snapshot,
GtkSnapshotState *state,
GskRenderNode **nodes,
guint n_nodes)
{
GskRenderNode *node, *clip_node;
node = gtk_snapshot_collect_default (snapshot, state, nodes, n_nodes);
if (node == NULL)
return NULL;
/* Check if the child node will even be clipped */
if (graphene_rect_contains_rect (&state->data.clip.bounds, &node->bounds))
return node;
if (state->data.clip.bounds.size.width == 0 ||
state->data.clip.bounds.size.height == 0)
return NULL;
clip_node = gsk_clip_node_new (node, &state->data.clip.bounds);
gsk_render_node_unref (node);
return clip_node;
}
/**
* gtk_snapshot_push_clip:
* @snapshot: a `GtkSnapshot`
* @bounds: the rectangle to clip to
*
* Clips an image to a rectangle.
*
* The image is recorded until the next call to [method@Gtk.Snapshot.pop].
*/
void
gtk_snapshot_push_clip (GtkSnapshot *snapshot,
const graphene_rect_t *bounds)
{
GtkSnapshotState *state;
float scale_x, scale_y, dx, dy;
gtk_snapshot_ensure_affine (snapshot, &scale_x, &scale_y, &dx, &dy);
state = gtk_snapshot_push_state (snapshot,
gtk_snapshot_get_current_state (snapshot)->transform,
gtk_snapshot_collect_clip,
NULL);
gtk_graphene_rect_scale_affine (bounds, scale_x, scale_y, dx, dy, &state->data.clip.bounds);
}
static GskRenderNode *
gtk_snapshot_collect_gl_shader (GtkSnapshot *snapshot,
GtkSnapshotState *state,
GskRenderNode **collected_nodes,
guint n_collected_nodes)
{
GskRenderNode *shader_node = NULL;
GskRenderNode **nodes;
int n_children;
n_children = gsk_gl_shader_get_n_textures (state->data.glshader.shader);
shader_node = NULL;
if (n_collected_nodes != 0)
g_warning ("Unexpected children when popping gl shader.");
if (state->data.glshader.nodes)
nodes = state->data.glshader.nodes;
else
nodes = &state->data.glshader.internal_nodes[0];
if (state->data.glshader.bounds.size.width != 0 &&
state->data.glshader.bounds.size.height != 0)
shader_node = gsk_gl_shader_node_new (state->data.glshader.shader,
&state->data.glshader.bounds,
state->data.glshader.args,
nodes, n_children);
return shader_node;
}
static void
gtk_snapshot_clear_gl_shader (GtkSnapshotState *state)
{
GskRenderNode **nodes;
guint i, n_children;
n_children = gsk_gl_shader_get_n_textures (state->data.glshader.shader);
if (state->data.glshader.nodes)
nodes = state->data.glshader.nodes;
else
nodes = &state->data.glshader.internal_nodes[0];
g_object_unref (state->data.glshader.shader);
g_bytes_unref (state->data.glshader.args);
for (i = 0; i < n_children; i++)
gsk_render_node_unref (nodes[i]);
g_free (state->data.glshader.nodes);
}
static GskRenderNode *
gtk_snapshot_collect_gl_shader_texture (GtkSnapshot *snapshot,
GtkSnapshotState *state,
GskRenderNode **nodes,
guint n_nodes)
{
GskRenderNode *child_node;
GdkRGBA transparent = { 0, 0, 0, 0 };
int n_children, node_idx;
GtkSnapshotState *glshader_state;
GskRenderNode **out_nodes;
child_node = gtk_snapshot_collect_default (snapshot, state, nodes, n_nodes);
if (child_node == NULL)
child_node = gsk_color_node_new (&transparent, &state->data.glshader_texture.bounds);
n_children = state->data.glshader_texture.n_children;
node_idx = state->data.glshader_texture.node_idx;
glshader_state = gtk_snapshot_get_nth_previous_state (snapshot, n_children - node_idx);
g_assert (glshader_state->collect_func == gtk_snapshot_collect_gl_shader);
if (glshader_state->data.glshader.nodes)
out_nodes = glshader_state->data.glshader.nodes;
else
out_nodes = &glshader_state->data.glshader.internal_nodes[0];
out_nodes[node_idx] = child_node;
return NULL;
}
/**
* gtk_snapshot_push_gl_shader:
* @snapshot: a `GtkSnapshot`
* @shader: The code to run
* @bounds: the rectangle to render into
* @take_args: (transfer full): Data block with arguments for the shader.
*
* Push a [class@Gsk.GLShaderNode].
*
* The node uses the given [class@Gsk.GLShader] and uniform values
* Additionally this takes a list of @n_children other nodes
* which will be passed to the [class@Gsk.GLShaderNode].
*
* The @take_args argument is a block of data to use for uniform
* arguments, as per types and offsets defined by the @shader.
* Normally this is generated by [method@Gsk.GLShader.format_args]
* or [struct@Gsk.ShaderArgsBuilder].
*
* The snapshotter takes ownership of @take_args, so the caller should
* not free it after this.
*
* If the renderer doesn't support GL shaders, or if there is any
* problem when compiling the shader, then the node will draw pink.
* You should use [method@Gsk.GLShader.compile] to ensure the @shader
* will work for the renderer before using it.
*
* If the shader requires textures (see [method@Gsk.GLShader.get_n_textures]),
* then it is expected that you call [method@Gtk.Snapshot.gl_shader_pop_texture]
* the number of times that are required. Each of these calls will generate
* a node that is added as a child to the `GskGLShaderNode`, which in turn
* will render these offscreen and pass as a texture to the shader.
*
* Once all textures (if any) are pop:ed, you must call the regular
* [method@Gtk.Snapshot.pop].
*
* If you want to use pre-existing textures as input to the shader rather
* than rendering new ones, use [method@Gtk.Snapshot.append_texture] to
* push a texture node. These will be used directly rather than being
* re-rendered.
*
* For details on how to write shaders, see [class@Gsk.GLShader].
*/
void
gtk_snapshot_push_gl_shader (GtkSnapshot *snapshot,
GskGLShader *shader,
const graphene_rect_t *bounds,
GBytes *take_args)
{
GtkSnapshotState *state;
float scale_x, scale_y, dx, dy;
graphene_rect_t transformed_bounds;
int n_children = gsk_gl_shader_get_n_textures (shader);
gtk_snapshot_ensure_affine (snapshot, &scale_x, &scale_y, &dx, &dy);
state = gtk_snapshot_push_state (snapshot,
gtk_snapshot_get_current_state (snapshot)->transform,
gtk_snapshot_collect_gl_shader,
gtk_snapshot_clear_gl_shader);
gtk_graphene_rect_scale_affine (bounds, scale_x, scale_y, dx, dy, &transformed_bounds);
state->data.glshader.bounds = transformed_bounds;
state->data.glshader.shader = g_object_ref (shader);
state->data.glshader.args = take_args; /* Takes ownership */
if (n_children <= G_N_ELEMENTS (state->data.glshader.internal_nodes))
state->data.glshader.nodes = NULL;
else
state->data.glshader.nodes = g_new (GskRenderNode *, n_children);
for (int i = 0; i < n_children; i++)
{
state = gtk_snapshot_push_state (snapshot,
gtk_snapshot_get_current_state (snapshot)->transform,
gtk_snapshot_collect_gl_shader_texture,
NULL);
state->data.glshader_texture.bounds = transformed_bounds;
state->data.glshader_texture.node_idx = n_children - 1 - i;/* We pop in reverse order */
state->data.glshader_texture.n_children = n_children;
}
}
static GskRenderNode *
gtk_snapshot_collect_rounded_clip (GtkSnapshot *snapshot,
GtkSnapshotState *state,
GskRenderNode **nodes,
guint n_nodes)
{
GskRenderNode *node, *clip_node;
node = gtk_snapshot_collect_default (snapshot, state, nodes, n_nodes);
if (node == NULL)
return NULL;
/* If the given radius is 0 in all corners, we can just create a normal clip node */
if (gsk_rounded_rect_is_rectilinear (&state->data.rounded_clip.bounds))
{
/* ... and do the same optimization */
if (graphene_rect_contains_rect (&state->data.rounded_clip.bounds.bounds, &node->bounds))
return node;
clip_node = gsk_clip_node_new (node, &state->data.rounded_clip.bounds.bounds);
}
else
{
if (gsk_rounded_rect_contains_rect (&state->data.rounded_clip.bounds, &node->bounds))
return node;
clip_node = gsk_rounded_clip_node_new (node, &state->data.rounded_clip.bounds);
}
if (clip_node->bounds.size.width == 0 ||
clip_node->bounds.size.height == 0)
{
gsk_render_node_unref (node);
gsk_render_node_unref (clip_node);
return NULL;
}
gsk_render_node_unref (node);
return clip_node;
}
/**
* gtk_snapshot_push_rounded_clip:
* @snapshot: a `GtkSnapshot`
* @bounds: the rounded rectangle to clip to
*
* Clips an image to a rounded rectangle.
*
* The image is recorded until the next call to [method@Gtk.Snapshot.pop].
*/
void
gtk_snapshot_push_rounded_clip (GtkSnapshot *snapshot,
const GskRoundedRect *bounds)
{
GtkSnapshotState *state;
float scale_x, scale_y, dx, dy;
gtk_snapshot_ensure_affine (snapshot, &scale_x, &scale_y, &dx, &dy);
state = gtk_snapshot_push_state (snapshot,
gtk_snapshot_get_current_state (snapshot)->transform,
gtk_snapshot_collect_rounded_clip,
NULL);
gsk_rounded_rect_scale_affine (&state->data.rounded_clip.bounds, bounds, scale_x, scale_y, dx, dy);
}
static GskRenderNode *
gtk_snapshot_collect_fill (GtkSnapshot *snapshot,
GtkSnapshotState *state,
GskRenderNode **nodes,
guint n_nodes)
{
GskRenderNode *node, *fill_node;
node = gtk_snapshot_collect_default (snapshot, state, nodes, n_nodes);
if (node == NULL)
return NULL;
fill_node = gsk_fill_node_new (node,
state->data.fill.path,
state->data.fill.fill_rule);
if (fill_node->bounds.size.width == 0 ||
fill_node->bounds.size.height == 0)
{
gsk_render_node_unref (node);
gsk_render_node_unref (fill_node);
return NULL;
}
gsk_render_node_unref (node);
return fill_node;
}
static void
gtk_snapshot_clear_fill (GtkSnapshotState *state)
{
gsk_path_unref (state->data.fill.path);
}
/**
* gtk_snapshot_push_fill:
* @snapshot: a `GtkSnapshot`
* @path: The path describing the area to fill
* @fill_rule: The fill rule to use
*
* Fills the area given by @path and @fill_rule with an image and discards everything
* outside of it.
*
* The image is recorded until the next call to [method@Gtk.Snapshot.pop].
*
* If you want to fill the path with a color, [method@Gtk.Snapshot.append_fill]
* may be more convenient.
*
* Since: 4.14
*/
void
gtk_snapshot_push_fill (GtkSnapshot *snapshot,
GskPath *path,
GskFillRule fill_rule)
{
GtkSnapshotState *state;
gtk_snapshot_ensure_identity (snapshot);
state = gtk_snapshot_push_state (snapshot,
gtk_snapshot_get_current_state (snapshot)->transform,
gtk_snapshot_collect_fill,
gtk_snapshot_clear_fill);
state->data.fill.path = gsk_path_ref (path);
state->data.fill.fill_rule = fill_rule;
}
/**
* gtk_snapshot_append_fill:
* @snapshot: a `GtkSnapshot`
* @path: The path describing the area to fill
* @fill_rule: The fill rule to use
* @color: the color to fill the path with
*
* A convenience method to fill a path with a color.
*
* See [method@Gtk.Snapshot.push_fill] if you need
* to fill a path with more complex content than
* a color.
*
* Since: 4.14
*/
void
gtk_snapshot_append_fill (GtkSnapshot *snapshot,
GskPath *path,
GskFillRule fill_rule,
const GdkRGBA *color)
{
graphene_rect_t bounds;
gsk_path_get_bounds (path, &bounds);
gtk_snapshot_push_fill (snapshot, path, fill_rule);
gtk_snapshot_append_color (snapshot, color, &bounds);
gtk_snapshot_pop (snapshot);
}
static GskRenderNode *
gtk_snapshot_collect_stroke (GtkSnapshot *snapshot,
GtkSnapshotState *state,
GskRenderNode **nodes,
guint n_nodes)
{
GskRenderNode *node, *stroke_node;
node = gtk_snapshot_collect_default (snapshot, state, nodes, n_nodes);
if (node == NULL)
return NULL;
stroke_node = gsk_stroke_node_new (node,
state->data.stroke.path,
&state->data.stroke.stroke);
if (stroke_node->bounds.size.width == 0 ||
stroke_node->bounds.size.height == 0)
{
gsk_render_node_unref (node);
gsk_render_node_unref (stroke_node);
return NULL;
}
gsk_render_node_unref (node);
return stroke_node;
}
static void
gtk_snapshot_clear_stroke (GtkSnapshotState *state)
{
gsk_path_unref (state->data.stroke.path);
gsk_stroke_clear (&state->data.stroke.stroke);
}
/**
* gtk_snapshot_push_stroke:
* @snapshot: a #GtkSnapshot
* @path: The path to stroke
* @stroke: The stroke attributes
*
* Strokes the given @path with the attributes given by @stroke and
* an image.
*
* The image is recorded until the next call to [method@Gtk.Snapshot.pop].
*
* Note that the strokes are subject to the same transformation as
* everything else, so uneven scaling will cause horizontal and vertical
* strokes to have different widths.
*
* If you want to stroke the path with a color, [method@Gtk.Snapshot.append_stroke]
* may be more convenient.
*
* Since: 4.14
*/
void
gtk_snapshot_push_stroke (GtkSnapshot *snapshot,
GskPath *path,
const GskStroke *stroke)
{
GtkSnapshotState *state;
gtk_snapshot_ensure_identity (snapshot);
state = gtk_snapshot_push_state (snapshot,
gtk_snapshot_get_current_state (snapshot)->transform,
gtk_snapshot_collect_stroke,
gtk_snapshot_clear_stroke);
state->data.stroke.path = gsk_path_ref (path);
gsk_stroke_init_copy (&state->data.stroke.stroke, stroke);
}
static GskRenderNode *
gtk_snapshot_collect_shadow (GtkSnapshot *snapshot,
GtkSnapshotState *state,
GskRenderNode **nodes,
guint n_nodes)
{
GskRenderNode *node, *shadow_node;
node = gtk_snapshot_collect_default (snapshot, state, nodes, n_nodes);
if (node == NULL)
return NULL;
shadow_node = gsk_shadow_node_new (node,
state->data.shadow.shadows != NULL ?
state->data.shadow.shadows :
&state->data.shadow.a_shadow,
state->data.shadow.n_shadows);
gsk_render_node_unref (node);
return shadow_node;
}
/**
* gtk_snapshot_append_stroke:
* @snapshot: a `GtkSnapshot`
* @path: The path describing the area to fill
* @stroke: The stroke attributes
* @color: the color to fill the path with
*
* A convenience method to stroke a path with a color.
*
* See [method@Gtk.Snapshot.push_stroke] if you need
* to stroke a path with more complex content than
* a color.
*
* Since: 4.14
*/
void
gtk_snapshot_append_stroke (GtkSnapshot *snapshot,
GskPath *path,
const GskStroke *stroke,
const GdkRGBA *color)
{
graphene_rect_t bounds;
gsk_path_get_stroke_bounds (path, stroke, &bounds);
gtk_snapshot_push_stroke (snapshot, path, stroke);
gtk_snapshot_append_color (snapshot, color, &bounds);
gtk_snapshot_pop (snapshot);
}
static void
gtk_snapshot_clear_shadow (GtkSnapshotState *state)
{
g_free (state->data.shadow.shadows);
}
/**
* gtk_snapshot_push_shadow:
* @snapshot: a `GtkSnapshot`
* @shadow: (array length=n_shadows): the first shadow specification
* @n_shadows: number of shadow specifications
*
* Applies a shadow to an image.
*
* The image is recorded until the next call to [method@Gtk.Snapshot.pop].
*/
void
gtk_snapshot_push_shadow (GtkSnapshot *snapshot,
const GskShadow *shadow,
gsize n_shadows)
{
const GtkSnapshotState *current_state = gtk_snapshot_get_current_state (snapshot);
GtkSnapshotState *state;
state = gtk_snapshot_push_state (snapshot,
current_state->transform,
gtk_snapshot_collect_shadow,
gtk_snapshot_clear_shadow);
state->data.shadow.n_shadows = n_shadows;
if (n_shadows == 1)
{
state->data.shadow.shadows = NULL;
memcpy (&state->data.shadow.a_shadow, shadow, sizeof (GskShadow));
}
else
{
state->data.shadow.shadows = g_malloc (sizeof (GskShadow) * n_shadows);
memcpy (state->data.shadow.shadows, shadow, sizeof (GskShadow) * n_shadows);
}
}
static GskRenderNode *
gtk_snapshot_collect_blend_top (GtkSnapshot *snapshot,
GtkSnapshotState *state,
GskRenderNode **nodes,
guint n_nodes)
{
GskRenderNode *bottom_node, *top_node, *blend_node;
GdkRGBA transparent = { 0, 0, 0, 0 };
top_node = gtk_snapshot_collect_default (snapshot, state, nodes, n_nodes);
bottom_node = state->data.blend.bottom_node != NULL
? gsk_render_node_ref (state->data.blend.bottom_node)
: NULL;
g_assert (top_node != NULL || bottom_node != NULL);
/* XXX: Is this necessary? Do we need a NULL node? */
if (top_node == NULL)
top_node = gsk_color_node_new (&transparent, &bottom_node->bounds);
if (bottom_node == NULL)
bottom_node = gsk_color_node_new (&transparent, &top_node->bounds);
blend_node = gsk_blend_node_new (bottom_node, top_node, state->data.blend.blend_mode);
gsk_render_node_unref (top_node);
gsk_render_node_unref (bottom_node);
return blend_node;
}
static void
gtk_snapshot_clear_blend_top (GtkSnapshotState *state)
{
g_clear_pointer (&(state->data.blend.bottom_node), gsk_render_node_unref);
}
static GskRenderNode *
gtk_snapshot_collect_blend_bottom (GtkSnapshot *snapshot,
GtkSnapshotState *state,
GskRenderNode **nodes,
guint n_nodes)
{
GtkSnapshotState *prev_state = gtk_snapshot_get_previous_state (snapshot);
g_assert (prev_state->collect_func == gtk_snapshot_collect_blend_top);
prev_state->data.blend.bottom_node = gtk_snapshot_collect_default (snapshot, state, nodes, n_nodes);
return NULL;
}
/**
* gtk_snapshot_push_blend:
* @snapshot: a `GtkSnapshot`
* @blend_mode: blend mode to use
*
* Blends together two images with the given blend mode.
*
* Until the first call to [method@Gtk.Snapshot.pop], the
* bottom image for the blend operation will be recorded.
* After that call, the top image to be blended will be
* recorded until the second call to [method@Gtk.Snapshot.pop].
*
* Calling this function requires two subsequent calls
* to [method@Gtk.Snapshot.pop].
*/
void
gtk_snapshot_push_blend (GtkSnapshot *snapshot,
GskBlendMode blend_mode)
{
GtkSnapshotState *current_state = gtk_snapshot_get_current_state (snapshot);
GtkSnapshotState *top_state;
top_state = gtk_snapshot_push_state (snapshot,
current_state->transform,
gtk_snapshot_collect_blend_top,
gtk_snapshot_clear_blend_top);
top_state->data.blend.blend_mode = blend_mode;
gtk_snapshot_push_state (snapshot,
top_state->transform,
gtk_snapshot_collect_blend_bottom,
NULL);
}
static GskRenderNode *
gtk_snapshot_collect_mask_source (GtkSnapshot *snapshot,
GtkSnapshotState *state,
GskRenderNode **nodes,
guint n_nodes)
{
GskRenderNode *source_child, *mask_child, *mask_node;
mask_child = gsk_render_node_ref (state->data.mask.mask_node);
source_child = gtk_snapshot_collect_default (snapshot, state, nodes, n_nodes);
if (source_child == NULL || mask_child == NULL)
return NULL;
mask_node = gsk_mask_node_new (source_child, mask_child, state->data.mask.mask_mode);
gsk_render_node_unref (source_child);
gsk_render_node_unref (mask_child);
return mask_node;
}
static void
gtk_snapshot_clear_mask_source (GtkSnapshotState *state)
{
g_clear_pointer (&(state->data.mask.mask_node), gsk_render_node_unref);
}
static GskRenderNode *
gtk_snapshot_collect_mask_mask (GtkSnapshot *snapshot,
GtkSnapshotState *state,
GskRenderNode **nodes,
guint n_nodes)
{
GtkSnapshotState *prev_state = gtk_snapshot_get_previous_state (snapshot);
g_assert (prev_state->collect_func == gtk_snapshot_collect_mask_source);
prev_state->data.mask.mask_node = gtk_snapshot_collect_default (snapshot, state, nodes, n_nodes);
return NULL;
}
/**
* gtk_snapshot_push_mask:
* @snapshot: a #GtkSnapshot
* @mask_mode: mask mode to use
*
* Until the first call to [method@Gtk.Snapshot.pop], the
* mask image for the mask operation will be recorded.
*
* After that call, the source image will be recorded until
* the second call to [method@Gtk.Snapshot.pop].
*
* Calling this function requires 2 subsequent calls to gtk_snapshot_pop().
*
* Since: 4.10
*/
void
gtk_snapshot_push_mask (GtkSnapshot *snapshot,
GskMaskMode mask_mode)
{
GtkSnapshotState *current_state = gtk_snapshot_get_current_state (snapshot);
GtkSnapshotState *source_state;
source_state = gtk_snapshot_push_state (snapshot,
current_state->transform,
gtk_snapshot_collect_mask_source,
gtk_snapshot_clear_mask_source);
source_state->data.mask.mask_mode = mask_mode;
gtk_snapshot_push_state (snapshot,
source_state->transform,
gtk_snapshot_collect_mask_mask,
NULL);
}
static GskRenderNode *
gtk_snapshot_collect_cross_fade_end (GtkSnapshot *snapshot,
GtkSnapshotState *state,
GskRenderNode **nodes,
guint n_nodes)
{
GskRenderNode *start_node, *end_node, *node;
end_node = gtk_snapshot_collect_default (snapshot, state, nodes, n_nodes);
start_node = state->data.cross_fade.start_node;
state->data.cross_fade.start_node = NULL;
if (state->data.cross_fade.progress <= 0.0)
{
node = start_node;
if (end_node)
gsk_render_node_unref (end_node);
}
else if (state->data.cross_fade.progress >= 1.0)
{
node = end_node;
if (start_node)
gsk_render_node_unref (start_node);
}
else if (start_node && end_node)
{
node = gsk_cross_fade_node_new (start_node, end_node, state->data.cross_fade.progress);
gsk_render_node_unref (start_node);
gsk_render_node_unref (end_node);
}
else if (start_node)
{
node = gsk_opacity_node_new (start_node, 1.0 - state->data.cross_fade.progress);
gsk_render_node_unref (start_node);
}
else if (end_node)
{
node = gsk_opacity_node_new (end_node, state->data.cross_fade.progress);
gsk_render_node_unref (end_node);
}
else
{
node = NULL;
}
return node;
}
static void
gtk_snapshot_clear_cross_fade_end (GtkSnapshotState *state)
{
g_clear_pointer (&state->data.cross_fade.start_node, gsk_render_node_unref);
}
static GskRenderNode *
gtk_snapshot_collect_cross_fade_start (GtkSnapshot *snapshot,
GtkSnapshotState *state,
GskRenderNode **nodes,
guint n_nodes)
{
GtkSnapshotState *prev_state = gtk_snapshot_get_previous_state (snapshot);
g_assert (prev_state->collect_func == gtk_snapshot_collect_cross_fade_end);
prev_state->data.cross_fade.start_node = gtk_snapshot_collect_default (snapshot, state, nodes, n_nodes);
return NULL;
}
/**
* gtk_snapshot_push_cross_fade:
* @snapshot: a `GtkSnapshot`
* @progress: progress between 0.0 and 1.0
*
* Snapshots a cross-fade operation between two images with the
* given @progress.
*
* Until the first call to [method@Gtk.Snapshot.pop], the start image
* will be snapshot. After that call, the end image will be recorded
* until the second call to [method@Gtk.Snapshot.pop].
*
* Calling this function requires two subsequent calls
* to [method@Gtk.Snapshot.pop].
*/
void
gtk_snapshot_push_cross_fade (GtkSnapshot *snapshot,
double progress)
{
const GtkSnapshotState *current_state = gtk_snapshot_get_current_state (snapshot);
GtkSnapshotState *end_state;
end_state = gtk_snapshot_push_state (snapshot,
current_state->transform,
gtk_snapshot_collect_cross_fade_end,
gtk_snapshot_clear_cross_fade_end);
end_state->data.cross_fade.progress = progress;
gtk_snapshot_push_state (snapshot,
end_state->transform,
gtk_snapshot_collect_cross_fade_start,
NULL);
}
static GskRenderNode *
gtk_snapshot_pop_one (GtkSnapshot *snapshot)
{
GtkSnapshotState *state;
guint state_index;
GskRenderNode *node;
if (gtk_snapshot_states_is_empty (&snapshot->state_stack))
{
g_warning ("Too many gtk_snapshot_pop() calls.");
return NULL;
}
state = gtk_snapshot_get_current_state (snapshot);
state_index = gtk_snapshot_states_get_size (&snapshot->state_stack) - 1;
if (state->collect_func)
{
node = state->collect_func (snapshot,
state,
(GskRenderNode **) gtk_snapshot_nodes_index (&snapshot->nodes, state->start_node_index),
state->n_nodes);
/* The collect func may not modify the state stack... */
g_assert (state_index == gtk_snapshot_states_get_size (&snapshot->state_stack) - 1);
/* Remove all the state's nodes from the list of nodes */
g_assert (state->start_node_index + state->n_nodes == gtk_snapshot_nodes_get_size (&snapshot->nodes));
gtk_snapshot_nodes_splice (&snapshot->nodes, state->start_node_index, state->n_nodes, FALSE, NULL, 0);
}
else
{
GtkSnapshotState *previous_state;
node = NULL;
/* move the nodes to the parent */
previous_state = gtk_snapshot_get_previous_state (snapshot);
previous_state->n_nodes += state->n_nodes;
g_assert (previous_state->start_node_index + previous_state->n_nodes == gtk_snapshot_nodes_get_size (&snapshot->nodes));
}
gtk_snapshot_states_splice (&snapshot->state_stack, state_index, 1, FALSE, NULL, 0);
return node;
}
static void
gtk_snapshot_append_node_internal (GtkSnapshot *snapshot,
GskRenderNode *node)
{
GtkSnapshotState *current_state;
current_state = gtk_snapshot_get_current_state (snapshot);
if (current_state)
{
gtk_snapshot_nodes_append (&snapshot->nodes, node);
current_state->n_nodes ++;
}
else
{
g_critical ("Tried appending a node to an already finished snapshot.");
}
}
static GskRenderNode *
gtk_snapshot_pop_internal (GtkSnapshot *snapshot,
gboolean is_texture_pop)
{
GtkSnapshotState *state;
GskRenderNode *node;
guint forgotten_restores = 0;
for (state = gtk_snapshot_get_current_state (snapshot);
gtk_snapshot_state_should_autopop (state) ||
state->collect_func == NULL;
state = gtk_snapshot_get_current_state (snapshot))
{
if (state->collect_func == NULL)
forgotten_restores++;
node = gtk_snapshot_pop_one (snapshot);
if (node)
gtk_snapshot_append_node_internal (snapshot, node);
}
if (forgotten_restores)
{
g_warning ("Too many gtk_snapshot_save() calls. %u saves remaining.", forgotten_restores);
}
if (is_texture_pop && (state->collect_func != gtk_snapshot_collect_gl_shader_texture))
{
g_critical ("Unexpected call to gtk_snapshot_gl_shader_pop_texture().");
return NULL;
}
else if (!is_texture_pop && (state->collect_func == gtk_snapshot_collect_gl_shader_texture))
{
g_critical ("Expected a call to gtk_snapshot_gl_shader_pop_texture().");
return NULL;
}
return gtk_snapshot_pop_one (snapshot);
}
/**
* gtk_snapshot_push_collect:
*
* Private.
*
* Pushes state so a later pop_collect call can collect all nodes
* appended until that point.
*/
void
gtk_snapshot_push_collect (GtkSnapshot *snapshot)
{
gtk_snapshot_push_state (snapshot,
NULL,
gtk_snapshot_collect_default,
NULL);
}
GskRenderNode *
gtk_snapshot_pop_collect (GtkSnapshot *snapshot)
{
GskRenderNode *result = gtk_snapshot_pop_internal (snapshot, FALSE);
return result;
}
/**
* gtk_snapshot_to_node:
* @snapshot: a `GtkSnapshot`
*
* Returns the render node that was constructed
* by @snapshot.
*
* Note that this function may return %NULL if nothing has been
* added to the snapshot or if its content does not produce pixels
* to be rendered.
*
* After calling this function, it is no longer possible to
* add more nodes to @snapshot. The only function that should
* be called after this is [method@GObject.Object.unref].
*
* Returns: (transfer full) (nullable): the constructed `GskRenderNode` or
* %NULL if there are no nodes to render.
*/
GskRenderNode *
gtk_snapshot_to_node (GtkSnapshot *snapshot)
{
GskRenderNode *result;
result = gtk_snapshot_pop_internal (snapshot, FALSE);
/* We should have exactly our initial state */
if (!gtk_snapshot_states_is_empty (&snapshot->state_stack))
{
g_warning ("Too many gtk_snapshot_push() calls. %zu states remaining.",
gtk_snapshot_states_get_size (&snapshot->state_stack));
}
gtk_snapshot_states_clear (&snapshot->state_stack);
gtk_snapshot_nodes_clear (&snapshot->nodes);
return result;
}
/**
* gtk_snapshot_to_paintable:
* @snapshot: a `GtkSnapshot`
* @size: (nullable): The size of the resulting paintable
* or %NULL to use the bounds of the snapshot
*
* Returns a paintable encapsulating the render node
* that was constructed by @snapshot.
*
* After calling this function, it is no longer possible to
* add more nodes to @snapshot. The only function that should
* be called after this is [method@GObject.Object.unref].
*
* Returns: (transfer full) (nullable): a new `GdkPaintable`
*/
GdkPaintable *
gtk_snapshot_to_paintable (GtkSnapshot *snapshot,
const graphene_size_t *size)
{
GskRenderNode *node;
GdkPaintable *paintable;
graphene_rect_t bounds;
node = gtk_snapshot_to_node (snapshot);
if (size)
{
graphene_size_init_from_size (&bounds.size, size);
}
else if (node)
{
gsk_render_node_get_bounds (node, &bounds);
bounds.size.width += bounds.origin.x;
bounds.size.height += bounds.origin.y;
}
else
{
bounds.size.width = 0;
bounds.size.height = 0;
}
bounds.origin.x = 0;
bounds.origin.y = 0;
paintable = gtk_render_node_paintable_new (node, &bounds);
g_clear_pointer (&node, gsk_render_node_unref);
return paintable;
}
/**
* gtk_snapshot_pop:
* @snapshot: a `GtkSnapshot`
*
* Removes the top element from the stack of render nodes,
* and appends it to the node underneath it.
*/
void
gtk_snapshot_pop (GtkSnapshot *snapshot)
{
GskRenderNode *node;
node = gtk_snapshot_pop_internal (snapshot, FALSE);
if (node)
gtk_snapshot_append_node_internal (snapshot, node);
}
/**
* gtk_snapshot_gl_shader_pop_texture:
* @snapshot: a `GtkSnapshot`
*
* Removes the top element from the stack of render nodes and
* adds it to the nearest [class@Gsk.GLShaderNode] below it.
*
* This must be called the same number of times as the number
* of textures is needed for the shader in
* [method@Gtk.Snapshot.push_gl_shader].
*/
void
gtk_snapshot_gl_shader_pop_texture (GtkSnapshot *snapshot)
{
G_GNUC_UNUSED GskRenderNode *node;
node = gtk_snapshot_pop_internal (snapshot, TRUE);
g_assert (node == NULL);
}
/**
* gtk_snapshot_save:
* @snapshot: a `GtkSnapshot`
*
* Makes a copy of the current state of @snapshot and saves it
* on an internal stack.
*
* When [method@Gtk.Snapshot.restore] is called, @snapshot will
* be restored to the saved state. Multiple calls to
* [method@Snapshot.save] and [class@Snapshot.restore] can be nested;
* each call to `gtk_snapshot_restore()` restores the state from
* the matching paired `gtk_snapshot_save()`.
*
* It is necessary to clear all saved states with corresponding
* calls to `gtk_snapshot_restore()`.
*/
void
gtk_snapshot_save (GtkSnapshot *snapshot)
{
g_return_if_fail (GTK_IS_SNAPSHOT (snapshot));
gtk_snapshot_push_state (snapshot,
gtk_snapshot_get_current_state (snapshot)->transform,
NULL,
NULL);
}
/**
* gtk_snapshot_restore:
* @snapshot: a `GtkSnapshot`
*
* Restores @snapshot to the state saved by a preceding call to
* [method@Snapshot.save] and removes that state from the stack of
* saved states.
*/
void
gtk_snapshot_restore (GtkSnapshot *snapshot)
{
GtkSnapshotState *state;
GskRenderNode *node;
for (state = gtk_snapshot_get_current_state (snapshot);
gtk_snapshot_state_should_autopop (state);
state = gtk_snapshot_get_current_state (snapshot))
{
node = gtk_snapshot_pop_one (snapshot);
if (node)
gtk_snapshot_append_node_internal (snapshot, node);
}
if (state->collect_func != NULL)
{
g_warning ("Too many gtk_snapshot_restore() calls.");
return;
}
node = gtk_snapshot_pop_one (snapshot);
g_assert (node == NULL);
}
/**
* gtk_snapshot_transform:
* @snapshot: a `GtkSnapshot`
* @transform: (nullable): the transform to apply
*
* Transforms @snapshot's coordinate system with the given @transform.
*/
void
gtk_snapshot_transform (GtkSnapshot *snapshot,
GskTransform *transform)
{
GtkSnapshotState *state;
g_return_if_fail (GTK_IS_SNAPSHOT (snapshot));
state = gtk_snapshot_get_current_state (snapshot);
state->transform = gsk_transform_transform (state->transform, transform);
}
/**
* gtk_snapshot_transform_matrix:
* @snapshot: a `GtkSnapshot`
* @matrix: the matrix to multiply the transform with
*
* Transforms @snapshot's coordinate system with the given @matrix.
*/
void
gtk_snapshot_transform_matrix (GtkSnapshot *snapshot,
const graphene_matrix_t *matrix)
{
GtkSnapshotState *state;
g_return_if_fail (GTK_IS_SNAPSHOT (snapshot));
g_return_if_fail (matrix != NULL);
state = gtk_snapshot_get_current_state (snapshot);
state->transform = gsk_transform_matrix (state->transform, matrix);
}
/**
* gtk_snapshot_translate:
* @snapshot: a `GtkSnapshot`
* @point: the point to translate the snapshot by
*
* Translates @snapshot's coordinate system by @point in 2-dimensional space.
*/
void
gtk_snapshot_translate (GtkSnapshot *snapshot,
const graphene_point_t *point)
{
GtkSnapshotState *state;
g_return_if_fail (GTK_IS_SNAPSHOT (snapshot));
g_return_if_fail (point != NULL);
state = gtk_snapshot_get_current_state (snapshot);
state->transform = gsk_transform_translate (state->transform, point);
}
/**
* gtk_snapshot_translate_3d:
* @snapshot: a `GtkSnapshot`
* @point: the point to translate the snapshot by
*
* Translates @snapshot's coordinate system by @point.
*/
void
gtk_snapshot_translate_3d (GtkSnapshot *snapshot,
const graphene_point3d_t *point)
{
GtkSnapshotState *state;
g_return_if_fail (GTK_IS_SNAPSHOT (snapshot));
g_return_if_fail (point != NULL);
state = gtk_snapshot_get_current_state (snapshot);
state->transform = gsk_transform_translate_3d (state->transform, point);
}
/**
* gtk_snapshot_rotate:
* @snapshot: a `GtkSnapshot`
* @angle: the rotation angle, in degrees (clockwise)
*
* Rotates @@snapshot's coordinate system by @angle degrees in 2D space -
* or in 3D speak, rotates around the Z axis. The rotation happens around
* the origin point of (0, 0) in the @snapshot's current coordinate system.
*
* To rotate around axes other than the Z axis, use [method@Gsk.Transform.rotate_3d].
*/
void
gtk_snapshot_rotate (GtkSnapshot *snapshot,
float angle)
{
GtkSnapshotState *state;
g_return_if_fail (GTK_IS_SNAPSHOT (snapshot));
state = gtk_snapshot_get_current_state (snapshot);
state->transform = gsk_transform_rotate (state->transform, angle);
}
/**
* gtk_snapshot_rotate_3d:
* @snapshot: a `GtkSnapshot`
* @angle: the rotation angle, in degrees (clockwise)
* @axis: The rotation axis
*
* Rotates @snapshot's coordinate system by @angle degrees around @axis.
*
* For a rotation in 2D space, use [method@Gsk.Transform.rotate].
*/
void
gtk_snapshot_rotate_3d (GtkSnapshot *snapshot,
float angle,
const graphene_vec3_t *axis)
{
GtkSnapshotState *state;
g_return_if_fail (GTK_IS_SNAPSHOT (snapshot));
g_return_if_fail (axis != NULL);
state = gtk_snapshot_get_current_state (snapshot);
state->transform = gsk_transform_rotate_3d (state->transform, angle, axis);
}
/**
* gtk_snapshot_scale:
* @snapshot: a `GtkSnapshot`
* @factor_x: scaling factor on the X axis
* @factor_y: scaling factor on the Y axis
*
* Scales @snapshot's coordinate system in 2-dimensional space by
* the given factors.
*
* Use [method@Gtk.Snapshot.scale_3d] to scale in all 3 dimensions.
*/
void
gtk_snapshot_scale (GtkSnapshot *snapshot,
float factor_x,
float factor_y)
{
GtkSnapshotState *state;
g_return_if_fail (GTK_IS_SNAPSHOT (snapshot));
state = gtk_snapshot_get_current_state (snapshot);
state->transform = gsk_transform_scale (state->transform, factor_x, factor_y);
}
/**
* gtk_snapshot_scale_3d:
* @snapshot: a `GtkSnapshot`
* @factor_x: scaling factor on the X axis
* @factor_y: scaling factor on the Y axis
* @factor_z: scaling factor on the Z axis
*
* Scales @snapshot's coordinate system by the given factors.
*/
void
gtk_snapshot_scale_3d (GtkSnapshot *snapshot,
float factor_x,
float factor_y,
float factor_z)
{
GtkSnapshotState *state;
g_return_if_fail (GTK_IS_SNAPSHOT (snapshot));
state = gtk_snapshot_get_current_state (snapshot);
state->transform = gsk_transform_scale_3d (state->transform, factor_x, factor_y, factor_z);
}
/**
* gtk_snapshot_perspective:
* @snapshot: a `GtkSnapshot`
* @depth: distance of the z=0 plane
*
* Applies a perspective projection transform.
*
* See [method@Gsk.Transform.perspective] for a discussion on the details.
*/
void
gtk_snapshot_perspective (GtkSnapshot *snapshot,
float depth)
{
GtkSnapshotState *state;
g_return_if_fail (GTK_IS_SNAPSHOT (snapshot));
state = gtk_snapshot_get_current_state (snapshot);
state->transform = gsk_transform_perspective (state->transform, depth);
}
/**
* gtk_snapshot_append_node:
* @snapshot: a `GtkSnapshot`
* @node: a `GskRenderNode`
*
* Appends @node to the current render node of @snapshot,
* without changing the current node.
*
* If @snapshot does not have a current node yet, @node
* will become the initial node.
*/
void
gtk_snapshot_append_node (GtkSnapshot *snapshot,
GskRenderNode *node)
{
g_return_if_fail (snapshot != NULL);
g_return_if_fail (GSK_IS_RENDER_NODE (node));
gtk_snapshot_ensure_identity (snapshot);
gtk_snapshot_append_node_internal (snapshot, gsk_render_node_ref (node));
}
/**
* gtk_snapshot_append_cairo:
* @snapshot: a `GtkSnapshot`
* @bounds: the bounds for the new node
*
* Creates a new [class@Gsk.CairoNode] and appends it to the current
* render node of @snapshot, without changing the current node.
*
* Returns: a `cairo_t` suitable for drawing the contents of
* the newly created render node
*/
cairo_t *
gtk_snapshot_append_cairo (GtkSnapshot *snapshot,
const graphene_rect_t *bounds)
{
GskRenderNode *node;
graphene_rect_t real_bounds;
float scale_x, scale_y, dx, dy;
cairo_t *cr;
g_return_val_if_fail (snapshot != NULL, NULL);
g_return_val_if_fail (bounds != NULL, NULL);
gtk_snapshot_ensure_affine (snapshot, &scale_x, &scale_y, &dx, &dy);
gtk_graphene_rect_scale_affine (bounds, scale_x, scale_y, dx, dy, &real_bounds);
node = gsk_cairo_node_new (&real_bounds);
gtk_snapshot_append_node_internal (snapshot, node);
cr = gsk_cairo_node_get_draw_context (node);
cairo_scale (cr, scale_x, scale_y);
cairo_translate (cr, dx, dy);
return cr;
}
/**
* gtk_snapshot_append_texture:
* @snapshot: a `GtkSnapshot`
* @texture: the texture to render
* @bounds: the bounds for the new node
*
* Creates a new render node drawing the @texture
* into the given @bounds and appends it to the
* current render node of @snapshot.
*
* If the texture needs to be scaled to fill @bounds,
* linear filtering is used. See [method@Gtk.Snapshot.append_scaled_texture]
* if you need other filtering, such as nearest-neighbour.
*/
void
gtk_snapshot_append_texture (GtkSnapshot *snapshot,
GdkTexture *texture,
const graphene_rect_t *bounds)
{
GskRenderNode *node;
graphene_rect_t real_bounds;
float scale_x, scale_y, dx, dy;
g_return_if_fail (snapshot != NULL);
g_return_if_fail (GDK_IS_TEXTURE (texture));
g_return_if_fail (bounds != NULL);
gtk_snapshot_ensure_affine (snapshot, &scale_x, &scale_y, &dx, &dy);
gtk_graphene_rect_scale_affine (bounds, scale_x, scale_y, dx, dy, &real_bounds);
node = gsk_texture_node_new (texture, &real_bounds);
gtk_snapshot_append_node_internal (snapshot, node);
}
/**
* gtk_snapshot_append_scaled_texture:
* @snapshot: a `GtkSnapshot`
* @texture: the texture to render
* @filter: the filter to use
* @bounds: the bounds for the new node
*
* Creates a new render node drawing the @texture
* into the given @bounds and appends it to the
* current render node of @snapshot.
*
* In contrast to [method@Gtk.Snapshot.append_texture],
* this function provides control about how the filter
* that is used when scaling.
*
* Since: 4.10
*/
void
gtk_snapshot_append_scaled_texture (GtkSnapshot *snapshot,
GdkTexture *texture,
GskScalingFilter filter,
const graphene_rect_t *bounds)
{
GskRenderNode *node;
g_return_if_fail (snapshot != NULL);
g_return_if_fail (GDK_IS_TEXTURE (texture));
g_return_if_fail (bounds != NULL);
gtk_snapshot_ensure_identity (snapshot);
node = gsk_texture_scale_node_new (texture, bounds, filter);
gtk_snapshot_append_node_internal (snapshot, node);
}
/**
* gtk_snapshot_append_color:
* @snapshot: a `GtkSnapshot`
* @color: the color to draw
* @bounds: the bounds for the new node
*
* Creates a new render node drawing the @color into the
* given @bounds and appends it to the current render node
* of @snapshot.
*
* You should try to avoid calling this function if
* @color is transparent.
*/
void
gtk_snapshot_append_color (GtkSnapshot *snapshot,
const GdkRGBA *color,
const graphene_rect_t *bounds)
{
GskRenderNode *node;
graphene_rect_t real_bounds;
float scale_x, scale_y, dx, dy;
g_return_if_fail (snapshot != NULL);
g_return_if_fail (color != NULL);
g_return_if_fail (bounds != NULL);
gtk_snapshot_ensure_affine (snapshot, &scale_x, &scale_y, &dx, &dy);
gtk_graphene_rect_scale_affine (bounds, scale_x, scale_y, dx, dy, &real_bounds);
node = gsk_color_node_new (color, &real_bounds);
gtk_snapshot_append_node_internal (snapshot, node);
}
void
gtk_snapshot_append_text (GtkSnapshot *snapshot,
PangoFont *font,
PangoGlyphString *glyphs,
const GdkRGBA *color,
float x,
float y)
{
GskRenderNode *node;
float dx, dy;
gtk_snapshot_ensure_translate (snapshot, &dx, &dy);
node = gsk_text_node_new (font,
glyphs,
color,
&GRAPHENE_POINT_INIT (x + dx, y + dy));
if (node == NULL)
return;
gtk_snapshot_append_node_internal (snapshot, node);
}
/**
* gtk_snapshot_append_linear_gradient:
* @snapshot: a `GtkSnapshot`
* @bounds: the rectangle to render the linear gradient into
* @start_point: the point at which the linear gradient will begin
* @end_point: the point at which the linear gradient will finish
* @stops: (array length=n_stops): the color stops defining the gradient
* @n_stops: the number of elements in @stops
*
* Appends a linear gradient node with the given stops to @snapshot.
*/
void
gtk_snapshot_append_linear_gradient (GtkSnapshot *snapshot,
const graphene_rect_t *bounds,
const graphene_point_t *start_point,
const graphene_point_t *end_point,
const GskColorStop *stops,
gsize n_stops)
{
GskRenderNode *node;
graphene_rect_t real_bounds;
float scale_x, scale_y, dx, dy;
const GdkRGBA *first_color;
gboolean need_gradient = FALSE;
g_return_if_fail (snapshot != NULL);
g_return_if_fail (start_point != NULL);
g_return_if_fail (end_point != NULL);
g_return_if_fail (stops != NULL);
g_return_if_fail (n_stops > 1);
gtk_snapshot_ensure_affine (snapshot, &scale_x, &scale_y, &dx, &dy);
gtk_graphene_rect_scale_affine (bounds, scale_x, scale_y, dx, dy, &real_bounds);
first_color = &stops[0].color;
for (gsize i = 0; i < n_stops; i ++)
{
if (!gdk_rgba_equal (first_color, &stops[i].color))
{
need_gradient = TRUE;
break;
}
}
if (need_gradient)
{
graphene_point_t real_start_point, real_end_point;
real_start_point.x = scale_x * start_point->x + dx;
real_start_point.y = scale_y * start_point->y + dy;
real_end_point.x = scale_x * end_point->x + dx;
real_end_point.y = scale_y * end_point->y + dy;
node = gsk_linear_gradient_node_new (&real_bounds,
&real_start_point,
&real_end_point,
stops,
n_stops);
}
else
{
node = gsk_color_node_new (first_color, &real_bounds);
}
gtk_snapshot_append_node_internal (snapshot, node);
}
/**
* gtk_snapshot_append_repeating_linear_gradient:
* @snapshot: a `GtkSnapshot`
* @bounds: the rectangle to render the linear gradient into
* @start_point: the point at which the linear gradient will begin
* @end_point: the point at which the linear gradient will finish
* @stops: (array length=n_stops): the color stops defining the gradient
* @n_stops: the number of elements in @stops
*
* Appends a repeating linear gradient node with the given stops to @snapshot.
*/
void
gtk_snapshot_append_repeating_linear_gradient (GtkSnapshot *snapshot,
const graphene_rect_t *bounds,
const graphene_point_t *start_point,
const graphene_point_t *end_point,
const GskColorStop *stops,
gsize n_stops)
{
GskRenderNode *node;
graphene_rect_t real_bounds;
float scale_x, scale_y, dx, dy;
gboolean need_gradient = FALSE;
const GdkRGBA *first_color;
g_return_if_fail (snapshot != NULL);
g_return_if_fail (start_point != NULL);
g_return_if_fail (end_point != NULL);
g_return_if_fail (stops != NULL);
g_return_if_fail (n_stops > 1);
gtk_snapshot_ensure_affine (snapshot, &scale_x, &scale_y, &dx, &dy);
gtk_graphene_rect_scale_affine (bounds, scale_x, scale_y, dx, dy, &real_bounds);
first_color = &stops[0].color;
for (gsize i = 0; i < n_stops; i ++)
{
if (!gdk_rgba_equal (first_color, &stops[i].color))
{
need_gradient = TRUE;
break;
}
}
if (need_gradient)
{
graphene_point_t real_start_point, real_end_point;
real_start_point.x = scale_x * start_point->x + dx;
real_start_point.y = scale_y * start_point->y + dy;
real_end_point.x = scale_x * end_point->x + dx;
real_end_point.y = scale_y * end_point->y + dy;
node = gsk_repeating_linear_gradient_node_new (&real_bounds,
&real_start_point,
&real_end_point,
stops,
n_stops);
}
else
{
node = gsk_color_node_new (first_color, &real_bounds);
}
gtk_snapshot_append_node_internal (snapshot, node);
}
/**
* gtk_snapshot_append_conic_gradient:
* @snapshot: a `GtkSnapshot`
* @bounds: the rectangle to render the gradient into
* @center: the center point of the conic gradient
* @rotation: the clockwise rotation in degrees of the starting angle.
* 0 means the starting angle is the top.
* @stops: (array length=n_stops): the color stops defining the gradient
* @n_stops: the number of elements in @stops
*
* Appends a conic gradient node with the given stops to @snapshot.
*/
void
gtk_snapshot_append_conic_gradient (GtkSnapshot *snapshot,
const graphene_rect_t *bounds,
const graphene_point_t *center,
float rotation,
const GskColorStop *stops,
gsize n_stops)
{
GskRenderNode *node;
graphene_rect_t real_bounds;
float dx, dy;
const GdkRGBA *first_color;
gboolean need_gradient = FALSE;
int i;
g_return_if_fail (snapshot != NULL);
g_return_if_fail (center != NULL);
g_return_if_fail (stops != NULL);
g_return_if_fail (n_stops > 1);
gtk_snapshot_ensure_translate (snapshot, &dx, &dy);
graphene_rect_offset_r (bounds, dx, dy, &real_bounds);
first_color = &stops[0].color;
for (i = 0; i < n_stops; i ++)
{
if (!gdk_rgba_equal (first_color, &stops[i].color))
{
need_gradient = TRUE;
break;
}
}
if (need_gradient)
node = gsk_conic_gradient_node_new (&real_bounds,
&GRAPHENE_POINT_INIT(
center->x + dx,
center->y + dy
),
rotation,
stops,
n_stops);
else
node = gsk_color_node_new (first_color, &real_bounds);
gtk_snapshot_append_node_internal (snapshot, node);
}
/**
* gtk_snapshot_append_radial_gradient:
* @snapshot: a `GtkSnapshot`
* @bounds: the rectangle to render the readial gradient into
* @center: the center point for the radial gradient
* @hradius: the horizontal radius
* @vradius: the vertical radius
* @start: the start position (on the horizontal axis)
* @end: the end position (on the horizontal axis)
* @stops: (array length=n_stops): the color stops defining the gradient
* @n_stops: the number of elements in @stops
*
* Appends a radial gradient node with the given stops to @snapshot.
*/
void
gtk_snapshot_append_radial_gradient (GtkSnapshot *snapshot,
const graphene_rect_t *bounds,
const graphene_point_t *center,
float hradius,
float vradius,
float start,
float end,
const GskColorStop *stops,
gsize n_stops)
{
GskRenderNode *node;
graphene_rect_t real_bounds;
float scale_x, scale_y, dx, dy;
gboolean need_gradient = FALSE;
const GdkRGBA *first_color;
g_return_if_fail (snapshot != NULL);
g_return_if_fail (center != NULL);
g_return_if_fail (stops != NULL);
g_return_if_fail (n_stops > 1);
gtk_snapshot_ensure_affine (snapshot, &scale_x, &scale_y, &dx, &dy);
gtk_graphene_rect_scale_affine (bounds, scale_x, scale_y, dx, dy, &real_bounds);
first_color = &stops[0].color;
for (gsize i = 0; i < n_stops; i ++)
{
if (!gdk_rgba_equal (first_color, &stops[i].color))
{
need_gradient = TRUE;
break;
}
}
if (need_gradient)
{
graphene_point_t real_center;
real_center.x = scale_x * center->x + dx;
real_center.y = scale_y * center->y + dy;
node = gsk_radial_gradient_node_new (&real_bounds,
&real_center,
hradius * scale_x,
vradius * scale_y,
start,
end,
stops,
n_stops);
}
else
{
node = gsk_color_node_new (first_color, &real_bounds);
}
gtk_snapshot_append_node_internal (snapshot, node);
}
/**
* gtk_snapshot_append_repeating_radial_gradient:
* @snapshot: a `GtkSnapshot`
* @bounds: the rectangle to render the readial gradient into
* @center: the center point for the radial gradient
* @hradius: the horizontal radius
* @vradius: the vertical radius
* @start: the start position (on the horizontal axis)
* @end: the end position (on the horizontal axis)
* @stops: (array length=n_stops): the color stops defining the gradient
* @n_stops: the number of elements in @stops
*
* Appends a repeating radial gradient node with the given stops to @snapshot.
*/
void
gtk_snapshot_append_repeating_radial_gradient (GtkSnapshot *snapshot,
const graphene_rect_t *bounds,
const graphene_point_t *center,
float hradius,
float vradius,
float start,
float end,
const GskColorStop *stops,
gsize n_stops)
{
GskRenderNode *node;
graphene_rect_t real_bounds;
float scale_x, scale_y, dx, dy;
gboolean need_gradient = FALSE;
const GdkRGBA *first_color;
g_return_if_fail (snapshot != NULL);
g_return_if_fail (center != NULL);
g_return_if_fail (stops != NULL);
g_return_if_fail (n_stops > 1);
gtk_snapshot_ensure_affine (snapshot, &scale_x, &scale_y, &dx, &dy);
gtk_graphene_rect_scale_affine (bounds, scale_x, scale_y, dx, dy, &real_bounds);
first_color = &stops[0].color;
for (gsize i = 0; i < n_stops; i ++)
{
if (!gdk_rgba_equal (first_color, &stops[i].color))
{
need_gradient = TRUE;
break;
}
}
if (need_gradient)
{
graphene_point_t real_center;
real_center.x = scale_x * center->x + dx;
real_center.y = scale_y * center->y + dy;
node = gsk_repeating_radial_gradient_node_new (&real_bounds,
&real_center,
hradius * scale_x,
vradius * scale_y,
start,
end,
stops,
n_stops);
}
else
{
node = gsk_color_node_new (first_color, &real_bounds);
}
gtk_snapshot_append_node_internal (snapshot, node);
}
/**
* gtk_snapshot_append_border:
* @snapshot: a `GtkSnapshot`
* @outline: the outline of the border
* @border_width: (array fixed-size=4): the stroke width of the border on
* the top, right, bottom and left side respectively.
* @border_color: (array fixed-size=4): the color used on the top, right,
* bottom and left side.
*
* Appends a stroked border rectangle inside the given @outline.
*
* The four sides of the border can have different widths and colors.
*/
void
gtk_snapshot_append_border (GtkSnapshot *snapshot,
const GskRoundedRect *outline,
const float border_width[4],
const GdkRGBA border_color[4])
{
GskRenderNode *node;
GskRoundedRect real_outline;
float scale_x, scale_y, dx, dy;
g_return_if_fail (snapshot != NULL);
g_return_if_fail (outline != NULL);
g_return_if_fail (border_width != NULL);
g_return_if_fail (border_color != NULL);
gtk_snapshot_ensure_affine (snapshot, &scale_x, &scale_y, &dx, &dy);
gsk_rounded_rect_scale_affine (&real_outline, outline, scale_x, scale_y, dx, dy);
node = gsk_border_node_new (&real_outline,
(float[4]) {
border_width[0] * scale_y,
border_width[1] * scale_x,
border_width[2] * scale_y,
border_width[3] * scale_x,
},
border_color);
gtk_snapshot_append_node_internal (snapshot, node);
}
/**
* gtk_snapshot_append_inset_shadow:
* @snapshot: a `GtkSnapshot`
* @outline: outline of the region surrounded by shadow
* @color: color of the shadow
* @dx: horizontal offset of shadow
* @dy: vertical offset of shadow
* @spread: how far the shadow spreads towards the inside
* @blur_radius: how much blur to apply to the shadow
*
* Appends an inset shadow into the box given by @outline.
*/
void
gtk_snapshot_append_inset_shadow (GtkSnapshot *snapshot,
const GskRoundedRect *outline,
const GdkRGBA *color,
float dx,
float dy,
float spread,
float blur_radius)
{
GskRenderNode *node;
GskRoundedRect real_outline;
float scale_x, scale_y, x, y;
g_return_if_fail (snapshot != NULL);
g_return_if_fail (outline != NULL);
g_return_if_fail (color != NULL);
gtk_snapshot_ensure_affine (snapshot, &scale_x, &scale_y, &x, &y);
gsk_rounded_rect_scale_affine (&real_outline, outline, scale_x, scale_y, x, y);
node = gsk_inset_shadow_node_new (&real_outline,
color,
scale_x * dx,
scale_y * dy,
spread,
blur_radius);
gtk_snapshot_append_node_internal (snapshot, node);
}
/**
* gtk_snapshot_append_outset_shadow:
* @snapshot: a `GtkSnapshot`
* @outline: outline of the region surrounded by shadow
* @color: color of the shadow
* @dx: horizontal offset of shadow
* @dy: vertical offset of shadow
* @spread: how far the shadow spreads towards the outside
* @blur_radius: how much blur to apply to the shadow
*
* Appends an outset shadow node around the box given by @outline.
*/
void
gtk_snapshot_append_outset_shadow (GtkSnapshot *snapshot,
const GskRoundedRect *outline,
const GdkRGBA *color,
float dx,
float dy,
float spread,
float blur_radius)
{
GskRenderNode *node;
GskRoundedRect real_outline;
float scale_x, scale_y, x, y;
g_return_if_fail (snapshot != NULL);
g_return_if_fail (outline != NULL);
g_return_if_fail (color != NULL);
gtk_snapshot_ensure_affine (snapshot, &scale_x, &scale_y, &x, &y);
gsk_rounded_rect_scale_affine (&real_outline, outline, scale_x, scale_y, x, y);
node = gsk_outset_shadow_node_new (&real_outline,
color,
scale_x * dx,
scale_y * dy,
spread,
blur_radius);
gtk_snapshot_append_node_internal (snapshot, node);
}
static GskRenderNode *
gtk_snapshot_collect_subsurface (GtkSnapshot *snapshot,
GtkSnapshotState *state,
GskRenderNode **nodes,
guint n_nodes)
{
GskRenderNode *node, *subsurface_node;
node = gtk_snapshot_collect_default (snapshot, state, nodes, n_nodes);
if (node == NULL)
return NULL;
subsurface_node = gsk_subsurface_node_new (node, state->data.subsurface.subsurface);
gsk_render_node_unref (node);
return subsurface_node;
}
static void
gtk_snapshot_clear_subsurface (GtkSnapshotState *state)
{
g_object_unref (state->data.subsurface.subsurface);
}
void
gtk_snapshot_push_subsurface (GtkSnapshot *snapshot,
GdkSubsurface *subsurface)
{
const GtkSnapshotState *current_state = gtk_snapshot_get_current_state (snapshot);
GtkSnapshotState *state;
state = gtk_snapshot_push_state (snapshot,
current_state->transform,
gtk_snapshot_collect_subsurface,
gtk_snapshot_clear_subsurface);
state->data.subsurface.subsurface = g_object_ref (subsurface);
}
Reference in New Issue View Git Blame Copy Permalink