{
int indentation_level;
GString *str;
+ GHashTable *named_nodes;
+ gsize named_node_counter;
+ GHashTable *named_textures;
+ gsize named_texture_counter;
} Printer;
static void
-printer_init (Printer *self)
+printer_init_check_texture (Printer *printer,
+ GdkTexture *texture)
+{
+ gpointer name;
+
+ if (!g_hash_table_lookup_extended (printer->named_textures, texture, NULL, &name))
+ g_hash_table_insert (printer->named_textures, texture, NULL);
+ else if (name == NULL)
+ g_hash_table_insert (printer->named_textures, texture, g_strdup (""));
+}
+
+static void
+printer_init_duplicates_for_node (Printer *printer,
+ GskRenderNode *node)
+{
+ gpointer name;
+
+ if (!g_hash_table_lookup_extended (printer->named_nodes, node, NULL, &name))
+ g_hash_table_insert (printer->named_nodes, node, NULL);
+ else if (name == NULL)
+ g_hash_table_insert (printer->named_nodes, node, g_strdup (""));
+
+ switch (gsk_render_node_get_node_type (node))
+ {
+ case GSK_CAIRO_NODE:
+ case GSK_TEXT_NODE:
+ case GSK_COLOR_NODE:
+ case GSK_LINEAR_GRADIENT_NODE:
+ case GSK_REPEATING_LINEAR_GRADIENT_NODE:
+ case GSK_RADIAL_GRADIENT_NODE:
+ case GSK_REPEATING_RADIAL_GRADIENT_NODE:
+ case GSK_CONIC_GRADIENT_NODE:
+ case GSK_BORDER_NODE:
+ case GSK_INSET_SHADOW_NODE:
+ case GSK_OUTSET_SHADOW_NODE:
+ /* no children */
+ break;
+
+ case GSK_TEXTURE_NODE:
+ printer_init_check_texture (printer, gsk_texture_node_get_texture (node));
+ break;
+
+ case GSK_TEXTURE_SCALE_NODE:
+ printer_init_check_texture (printer, gsk_texture_scale_node_get_texture (node));
+ break;
+
+ case GSK_TRANSFORM_NODE:
+ printer_init_duplicates_for_node (printer, gsk_transform_node_get_child (node));
+ break;
+
+ case GSK_OPACITY_NODE:
+ printer_init_duplicates_for_node (printer, gsk_opacity_node_get_child (node));
+ break;
+
+ case GSK_COLOR_MATRIX_NODE:
+ printer_init_duplicates_for_node (printer, gsk_color_matrix_node_get_child (node));
+ break;
+
+ case GSK_BLUR_NODE:
+ printer_init_duplicates_for_node (printer, gsk_blur_node_get_child (node));
+ break;
+
+ case GSK_REPEAT_NODE:
+ printer_init_duplicates_for_node (printer, gsk_repeat_node_get_child (node));
+ break;
+
+ case GSK_CLIP_NODE:
+ printer_init_duplicates_for_node (printer, gsk_clip_node_get_child (node));
+ break;
+
+ case GSK_ROUNDED_CLIP_NODE:
+ printer_init_duplicates_for_node (printer, gsk_rounded_clip_node_get_child (node));
+ break;
+
+ case GSK_SHADOW_NODE:
+ printer_init_duplicates_for_node (printer, gsk_shadow_node_get_child (node));
+ break;
+
+ case GSK_DEBUG_NODE:
+ printer_init_duplicates_for_node (printer, gsk_debug_node_get_child (node));
+ break;
+
+ case GSK_BLEND_NODE:
+ printer_init_duplicates_for_node (printer, gsk_blend_node_get_bottom_child (node));
+ printer_init_duplicates_for_node (printer, gsk_blend_node_get_top_child (node));
+ break;
+
+ case GSK_MASK_NODE:
+ printer_init_duplicates_for_node (printer, gsk_mask_node_get_source (node));
+ printer_init_duplicates_for_node (printer, gsk_mask_node_get_mask (node));
+ break;
+
+ case GSK_CROSS_FADE_NODE:
+ printer_init_duplicates_for_node (printer, gsk_cross_fade_node_get_start_child (node));
+ printer_init_duplicates_for_node (printer, gsk_cross_fade_node_get_end_child (node));
+ break;
+
+ case GSK_GL_SHADER_NODE:
+ {
+ guint i;
+
+ for (i = 0; i < gsk_gl_shader_node_get_n_children (node); i++)
+ {
+ printer_init_duplicates_for_node (printer, gsk_gl_shader_node_get_child (node, i));
+ }
+ }
+ break;
+
+ case GSK_CONTAINER_NODE:
+ {
+ guint i;
+
+ for (i = 0; i < gsk_container_node_get_n_children (node); i++)
+ {
+ printer_init_duplicates_for_node (printer, gsk_container_node_get_child (node, i));
+ }
+ }
+ break;
+
+ default:
+ case GSK_NOT_A_RENDER_NODE:
+ g_assert_not_reached ();
+ break;
+
+ }
+}
+
+static void
+printer_init (Printer *self,
+ GskRenderNode *node)
{
self->indentation_level = 0;
self->str = g_string_new (NULL);
+ self->named_nodes = g_hash_table_new_full (NULL, NULL, NULL, g_free);
+ self->named_node_counter = 0;
+ self->named_textures = g_hash_table_new_full (NULL, NULL, NULL, g_free);
+ self->named_texture_counter = 0;
+
+ printer_init_duplicates_for_node (self, node);
}
#define IDENT_LEVEL 2 /* Spaces per level */
static void
start_node (Printer *self,
+ const char *node_type,
const char *node_name)
{
- g_string_append_printf (self->str, "%s {\n", node_name);
+ g_string_append_printf (self->str, "%s ", node_type);
+ if (node_name)
+ {
+ gtk_css_print_string (self->str, node_name, FALSE);
+ g_string_append_c (self->str, ' ');
+ }
+ g_string_append_printf (self->str, "{\n");
self->indentation_level ++;
}
{
GBytes *bytes;
char *b64;
+ const char *texture_name;
_indent (p);
g_string_append_printf (p->str, "%s: ", param_name);
+ texture_name = g_hash_table_lookup (p->named_textures, texture);
+ if (texture_name == NULL)
+ {
+ /* nothing to do here, texture is unique */
+ }
+ else if (texture_name[0])
+ {
+ /* texture has been named already */
+ gtk_css_print_string (p->str, texture_name, TRUE);
+ g_string_append (p->str, ";\n");
+ return;
+ }
+ else
+ {
+ /* texture needs a name */
+ char *new_name = g_strdup_printf ("texture%zu", ++p->named_texture_counter);
+ gtk_css_print_string (p->str, new_name, TRUE);
+ g_string_append_c (p->str, ' ');
+ g_hash_table_insert (p->named_textures, texture, new_name);
+ }
+
switch (gdk_texture_get_format (texture))
{
case GDK_MEMORY_B8G8R8A8_PREMULTIPLIED:
GskRenderNode *node)
{
char *b64;
+ const char *node_name;
+
+ node_name = g_hash_table_lookup (p->named_nodes, node);
+ if (node_name == NULL)
+ {
+ /* nothing to do here, node is unique */
+ }
+ else if (node_name[0])
+ {
+ /* node has been named already */
+ gtk_css_print_string (p->str, node_name, TRUE);
+ g_string_append (p->str, ";\n");
+ return;
+ }
+ else
+ {
+ /* node needs a name */
+ char *new_name = g_strdup_printf ("node%zu", ++p->named_node_counter);
+ g_hash_table_insert (p->named_nodes, node, new_name);
+ node_name = new_name;
+ }
switch (gsk_render_node_get_node_type (node))
{
{
guint i;
- start_node (p, "container");
+ start_node (p, "container", node_name);
for (i = 0; i < gsk_container_node_get_n_children (node); i ++)
{
GskRenderNode *child = gsk_container_node_get_child (node, i);
case GSK_COLOR_NODE:
{
- start_node (p, "color");
+ start_node (p, "color", node_name);
append_rect_param (p, "bounds", &node->bounds);
append_rgba_param (p, "color", gsk_color_node_get_color (node));
end_node (p);
case GSK_CROSS_FADE_NODE:
{
- start_node (p, "cross-fade");
+ start_node (p, "cross-fade", node_name);
append_float_param (p, "progress", gsk_cross_fade_node_get_progress (node), 0.5f);
append_node_param (p, "start", gsk_cross_fade_node_get_start_child (node));
case GSK_LINEAR_GRADIENT_NODE:
{
if (gsk_render_node_get_node_type (node) == GSK_REPEATING_LINEAR_GRADIENT_NODE)
- start_node (p, "repeating-linear-gradient");
+ start_node (p, "repeating-linear-gradient", node_name);
else
- start_node (p, "linear-gradient");
+ start_node (p, "linear-gradient", node_name);
append_rect_param (p, "bounds", &node->bounds);
append_point_param (p, "start", gsk_linear_gradient_node_get_start (node));
case GSK_RADIAL_GRADIENT_NODE:
{
if (gsk_render_node_get_node_type (node) == GSK_REPEATING_RADIAL_GRADIENT_NODE)
- start_node (p, "repeating-radial-gradient");
+ start_node (p, "repeating-radial-gradient", node_name);
else
- start_node (p, "radial-gradient");
+ start_node (p, "radial-gradient", node_name);
append_rect_param (p, "bounds", &node->bounds);
append_point_param (p, "center", gsk_radial_gradient_node_get_center (node));
case GSK_CONIC_GRADIENT_NODE:
{
- start_node (p, "conic-gradient");
+ start_node (p, "conic-gradient", node_name);
append_rect_param (p, "bounds", &node->bounds);
append_point_param (p, "center", gsk_conic_gradient_node_get_center (node));
case GSK_OPACITY_NODE:
{
- start_node (p, "opacity");
+ start_node (p, "opacity", node_name);
append_float_param (p, "opacity", gsk_opacity_node_get_opacity (node), 0.5f);
append_node_param (p, "child", gsk_opacity_node_get_child (node));
{
const GdkRGBA *color = gsk_outset_shadow_node_get_color (node);
- start_node (p, "outset-shadow");
+ start_node (p, "outset-shadow", node_name);
append_float_param (p, "blur", gsk_outset_shadow_node_get_blur_radius (node), 0.0f);
if (!gdk_rgba_equal (color, &GDK_RGBA("000")))
case GSK_CLIP_NODE:
{
- start_node (p, "clip");
+ start_node (p, "clip", node_name);
append_rect_param (p, "clip", gsk_clip_node_get_clip (node));
append_node_param (p, "child", gsk_clip_node_get_child (node));
case GSK_ROUNDED_CLIP_NODE:
{
- start_node (p, "rounded-clip");
+ start_node (p, "rounded-clip", node_name);
append_rounded_rect_param (p, "clip", gsk_rounded_clip_node_get_clip (node));
append_node_param (p, "child", gsk_rounded_clip_node_get_child (node));
case GSK_TRANSFORM_NODE:
{
GskTransform *transform = gsk_transform_node_get_transform (node);
- start_node (p, "transform");
+ start_node (p, "transform", node_name);
if (gsk_transform_get_category (transform) != GSK_TRANSFORM_CATEGORY_IDENTITY)
append_transform_param (p, "transform", transform);
case GSK_COLOR_MATRIX_NODE:
{
- start_node (p, "color-matrix");
+ start_node (p, "color-matrix", node_name);
if (!graphene_matrix_is_identity (gsk_color_matrix_node_get_color_matrix (node)))
append_matrix_param (p, "matrix", gsk_color_matrix_node_get_color_matrix (node));
const GdkRGBA *colors = gsk_border_node_get_colors (node);
const float *widths = gsk_border_node_get_widths (node);
guint i, n;
- start_node (p, "border");
+ start_node (p, "border", node_name);
if (!gdk_rgba_equal (&colors[3], &colors[1]))
n = 4;
const guint n_shadows = gsk_shadow_node_get_n_shadows (node);
int i;
- start_node (p, "shadow");
+ start_node (p, "shadow", node_name);
_indent (p);
g_string_append (p->str, "shadows: ");
case GSK_INSET_SHADOW_NODE:
{
const GdkRGBA *color = gsk_inset_shadow_node_get_color (node);
- start_node (p, "inset-shadow");
+ start_node (p, "inset-shadow", node_name);
append_float_param (p, "blur", gsk_inset_shadow_node_get_blur_radius (node), 0.0f);
if (!gdk_rgba_equal (color, &GDK_RGBA("000")))
case GSK_TEXTURE_NODE:
{
- start_node (p, "texture");
+ start_node (p, "texture", node_name);
append_rect_param (p, "bounds", &node->bounds);
append_texture_param (p, "texture", gsk_texture_node_get_texture (node));
{
GskScalingFilter filter = gsk_texture_scale_node_get_filter (node);
- start_node (p, "texture-scale");
+ start_node (p, "texture-scale", node_name);
append_rect_param (p, "bounds", &node->bounds);
if (filter != GSK_SCALING_FILTER_LINEAR)
PangoFontDescription *desc;
char *font_name;
- start_node (p, "text");
+ start_node (p, "text", node_name);
if (!gdk_rgba_equal (color, &GDK_RGBA("000000")))
append_rgba_param (p, "color", color);
{
const char *message = gsk_debug_node_get_message (node);
- start_node (p, "debug");
+ start_node (p, "debug", node_name);
/* TODO: We potentially need to escape certain characters in the message */
if (message)
case GSK_BLUR_NODE:
{
- start_node (p, "blur");
+ start_node (p, "blur", node_name);
append_float_param (p, "blur", gsk_blur_node_get_radius (node), 1.0f);
append_node_param (p, "child", gsk_blur_node_get_child (node));
GskGLShader *shader = gsk_gl_shader_node_get_shader (node);
GBytes *args = gsk_gl_shader_node_get_args (node);
- start_node (p, "glshader");
+ start_node (p, "glshader", node_name);
append_rect_param (p, "bounds", &node->bounds);
GskRenderNode *child = gsk_repeat_node_get_child (node);
const graphene_rect_t *child_bounds = gsk_repeat_node_get_child_bounds (node);
- start_node (p, "repeat");
+ start_node (p, "repeat", node_name);
if (!graphene_rect_equal (&node->bounds, &child->bounds))
append_rect_param (p, "bounds", &node->bounds);
{
GskBlendMode mode = gsk_blend_node_get_blend_mode (node);
- start_node (p, "blend");
+ start_node (p, "blend", node_name);
if (mode != GSK_BLEND_MODE_DEFAULT)
{
{
GskMaskMode mode = gsk_mask_node_get_mask_mode (node);
- start_node (p, "mask");
+ start_node (p, "mask", node_name);
if (mode != GSK_MASK_MODE_ALPHA)
{
cairo_surface_t *surface = gsk_cairo_node_get_surface (node);
GByteArray *array;
- start_node (p, "cairo");
+ start_node (p, "cairo", node_name);
append_rect_param (p, "bounds", &node->bounds);
if (surface != NULL)
{
Printer p;
- printer_init (&p);
+ printer_init (&p, node);
if (gsk_render_node_get_node_type (node) == GSK_CONTAINER_NODE)
{
projects / gtk4.git / commitdiff