AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity
c736deb83b
gtk2/gsk/gskrendernodeparser.c

3050 lines
86 KiB
C
Raw Normal View History

rendernodeparser: Skip root node when it's a container When printing, behave the same way as when parsing: Magically skip a container node if there is one - just like the parser magically creates a container node to hold all the nodes it parses.
2019-05-14 00:49:19 +00:00
/*
* Copyright © 2019 Benjamin Otte
* Timm Bäder
*
* 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.1 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/>.
*
* Authors: Benjamin Otte <otte@gnome.org>
* Timm Bäder <mail@baedert.org>
*/
#include "config.h"
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
#include "gskrendernodeparserprivate.h"
#include "gskroundedrectprivate.h"
#include "gskrendernodeprivate.h"
#include "gsktransformprivate.h"
rendernodeparser: Parse images differently Instead of encoding the raw data, encode the full image to a PNG. And instead of stuffing that encoding into a string, use a full data: url. And then remove the width and height properties, because they're now implicitly included in the data. And then change the parser to match. And because the parser now parses regular urls on top of data: urls, we can now load any random file.
2019-05-09 01:56:25 +00:00
#include "gdk/gdkrgbaprivate.h"
#include "gdk/gdktextureprivate.h"
#include <gtk/css/gtkcss.h>
#include "gtk/css/gtkcssdataurlprivate.h"
rendernodeparser: Allow single values instead of 4 This allows writing: colors: red; instead of colors: red red red red; to draw a red border.
2019-05-13 22:41:49 +00:00
#include "gtk/css/gtkcssparserprivate.h"
css: Move _gtk_css_print_string around Move this to a separate header, since it is not parser functionality, and kill the duplicate gtkcssparserprivate.h header.
2020-10-03 02:28:17 +00:00
#include "gtk/css/gtkcssserializerprivate.h"
rendernodeparser: Parse images differently Instead of encoding the raw data, encode the full image to a PNG. And instead of stuffing that encoding into a string, use a full data: url. And then remove the width and height properties, because they're now implicitly included in the data. And then change the parser to match. And because the parser now parses regular urls on top of data: urls, we can now load any random file.
2019-05-09 01:56:25 +00:00
rendernodeparser: Parse Cairo nodes We also print the script, but we don't parse it yet.
2019-05-25 22:50:13 +00:00
#ifdef CAIRO_HAS_SCRIPT_SURFACE
#include <cairo-script.h>
#endif
rendernodeparser: Parse cairo script Use cairo-script-interpreter to parse the scripts that generate cairo nodes. This requires libcairoscriptinterpreter.so to work properly, but if it isn't found we disable this (unimportant for normal functioning) code and just emits a parser warning. The testsuite requires it however or it will fail. A new test is included that tests all of this.
2019-05-28 03:51:20 +00:00
#ifdef HAVE_CAIRO_SCRIPT_INTERPRETER
#include <cairo-script-interpreter.h>
#endif
rendernodeparser: Parse Cairo nodes We also print the script, but we don't parse it yet.
2019-05-25 22:50:13 +00:00
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
typedef struct _Declaration Declaration;
struct _Declaration
{
const char *name;
gboolean (* parse_func) (GtkCssParser *parser, gpointer result);
rendernodeparser: Introduce clear_func We want to be able to clear the already parsed contents, because we need to do that when somebody parses the same property twice.
2019-05-12 22:47:50 +00:00
void (* clear_func) (gpointer data);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
gpointer result;
};
static gboolean
rendernodeparser: Move EOF test into parse_declarations() This way, we don't have to duplicate code. Plus, we can ensure to clear the erroneously parsed value that should not be used.
2019-05-12 22:59:15 +00:00
parse_rect (GtkCssParser *parser,
gpointer out_rect)
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
{
double numbers[4];
if (!gtk_css_parser_consume_number (parser, &numbers[0]) ||
!gtk_css_parser_consume_number (parser, &numbers[1]) ||
!gtk_css_parser_consume_number (parser, &numbers[2]) ||
!gtk_css_parser_consume_number (parser, &numbers[3]))
return FALSE;
graphene_rect_init (out_rect, numbers[0], numbers[1], numbers[2], numbers[3]);
return TRUE;
}
static gboolean
rendernodeparser: Parse images differently Instead of encoding the raw data, encode the full image to a PNG. And instead of stuffing that encoding into a string, use a full data: url. And then remove the width and height properties, because they're now implicitly included in the data. And then change the parser to match. And because the parser now parses regular urls on top of data: urls, we can now load any random file.
2019-05-09 01:56:25 +00:00
parse_texture (GtkCssParser *parser,
gpointer out_data)
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
{
rendernodeparser: Parse images differently Instead of encoding the raw data, encode the full image to a PNG. And instead of stuffing that encoding into a string, use a full data: url. And then remove the width and height properties, because they're now implicitly included in the data. And then change the parser to match. And because the parser now parses regular urls on top of data: urls, we can now load any random file.
2019-05-09 01:56:25 +00:00
GdkTexture *texture;
GError *error = NULL;
GtkCssLocation start_location;
cssparser: Make gsk_renderer_consume_url() return a string We don't want to return a GFile because GFile can't handle can't deal with data: urls. That makes the code a bit more complicated that doesn't deal with those URLs, but it makes the other code actually work. GtkCssImageUrl also now decodes data urls immediately instead of only at the first load. So don't use data urls if you care about performance.
2019-05-12 13:18:46 +00:00
char *url, *scheme;
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
rendernodeparser: Parse images differently Instead of encoding the raw data, encode the full image to a PNG. And instead of stuffing that encoding into a string, use a full data: url. And then remove the width and height properties, because they're now implicitly included in the data. And then change the parser to match. And because the parser now parses regular urls on top of data: urls, we can now load any random file.
2019-05-09 01:56:25 +00:00
start_location = *gtk_css_parser_get_start_location (parser);
cssparser: Make gsk_renderer_consume_url() return a string We don't want to return a GFile because GFile can't handle can't deal with data: urls. That makes the code a bit more complicated that doesn't deal with those URLs, but it makes the other code actually work. GtkCssImageUrl also now decodes data urls immediately instead of only at the first load. So don't use data urls if you care about performance.
2019-05-12 13:18:46 +00:00
url = gtk_css_parser_consume_url (parser);
if (url == NULL)
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
return FALSE;
cssparser: Make gsk_renderer_consume_url() return a string We don't want to return a GFile because GFile can't handle can't deal with data: urls. That makes the code a bit more complicated that doesn't deal with those URLs, but it makes the other code actually work. GtkCssImageUrl also now decodes data urls immediately instead of only at the first load. So don't use data urls if you care about performance.
2019-05-12 13:18:46 +00:00
scheme = g_uri_parse_scheme (url);
if (scheme && g_ascii_strcasecmp (scheme, "data") == 0)
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
{
rendernodeparser: Parse images differently Instead of encoding the raw data, encode the full image to a PNG. And instead of stuffing that encoding into a string, use a full data: url. And then remove the width and height properties, because they're now implicitly included in the data. And then change the parser to match. And because the parser now parses regular urls on top of data: urls, we can now load any random file.
2019-05-09 01:56:25 +00:00
GInputStream *stream;
GdkPixbuf *pixbuf;
GBytes *bytes;
texture = NULL;
cssparser: Make gsk_renderer_consume_url() return a string We don't want to return a GFile because GFile can't handle can't deal with data: urls. That makes the code a bit more complicated that doesn't deal with those URLs, but it makes the other code actually work. GtkCssImageUrl also now decodes data urls immediately instead of only at the first load. So don't use data urls if you care about performance.
2019-05-12 13:18:46 +00:00
bytes = gtk_css_data_url_parse (url, NULL, &error);
rendernodeparser: Parse images differently Instead of encoding the raw data, encode the full image to a PNG. And instead of stuffing that encoding into a string, use a full data: url. And then remove the width and height properties, because they're now implicitly included in the data. And then change the parser to match. And because the parser now parses regular urls on top of data: urls, we can now load any random file.
2019-05-09 01:56:25 +00:00
if (bytes)
{
stream = g_memory_input_stream_new_from_bytes (bytes);
rendernodeparser: Fix a memory leak when parsing textures
2019-07-21 07:06:29 +00:00
g_bytes_unref (bytes);
rendernodeparser: Parse images differently Instead of encoding the raw data, encode the full image to a PNG. And instead of stuffing that encoding into a string, use a full data: url. And then remove the width and height properties, because they're now implicitly included in the data. And then change the parser to match. And because the parser now parses regular urls on top of data: urls, we can now load any random file.
2019-05-09 01:56:25 +00:00
pixbuf = gdk_pixbuf_new_from_stream (stream, NULL, &error);
g_object_unref (stream);
if (pixbuf != NULL)
{
texture = gdk_texture_new_for_pixbuf (pixbuf);
g_object_unref (pixbuf);
}
}
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
}
rendernodeparser: Parse images differently Instead of encoding the raw data, encode the full image to a PNG. And instead of stuffing that encoding into a string, use a full data: url. And then remove the width and height properties, because they're now implicitly included in the data. And then change the parser to match. And because the parser now parses regular urls on top of data: urls, we can now load any random file.
2019-05-09 01:56:25 +00:00
else
{
cssparser: Make gsk_renderer_consume_url() return a string We don't want to return a GFile because GFile can't handle can't deal with data: urls. That makes the code a bit more complicated that doesn't deal with those URLs, but it makes the other code actually work. GtkCssImageUrl also now decodes data urls immediately instead of only at the first load. So don't use data urls if you care about performance.
2019-05-12 13:18:46 +00:00
GFile *file;
file = gtk_css_parser_resolve_url (parser, url);
rendernodeparser: Handle resolving NULL urls
2019-11-19 08:37:03 +00:00
if (file)
{
texture = gdk_texture_new_from_file (file, &error);
g_object_unref (file);
}
else
{
texture = NULL;
}
rendernodeparser: Parse images differently Instead of encoding the raw data, encode the full image to a PNG. And instead of stuffing that encoding into a string, use a full data: url. And then remove the width and height properties, because they're now implicitly included in the data. And then change the parser to match. And because the parser now parses regular urls on top of data: urls, we can now load any random file.
2019-05-09 01:56:25 +00:00
}
cssparser: Make gsk_renderer_consume_url() return a string We don't want to return a GFile because GFile can't handle can't deal with data: urls. That makes the code a bit more complicated that doesn't deal with those URLs, but it makes the other code actually work. GtkCssImageUrl also now decodes data urls immediately instead of only at the first load. So don't use data urls if you care about performance.
2019-05-12 13:18:46 +00:00
g_free (scheme);
g_free (url);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
rendernodeparser: Parse images differently Instead of encoding the raw data, encode the full image to a PNG. And instead of stuffing that encoding into a string, use a full data: url. And then remove the width and height properties, because they're now implicitly included in the data. And then change the parser to match. And because the parser now parses regular urls on top of data: urls, we can now load any random file.
2019-05-09 01:56:25 +00:00
if (texture == NULL)
{
rendernodeparser: Only report a GError* if we have one
2019-11-19 08:37:26 +00:00
if (error)
{
gtk_css_parser_emit_error (parser,
&start_location,
gtk_css_parser_get_end_location (parser),
error);
g_clear_error (&error);
}
rendernodeparser: Parse images differently Instead of encoding the raw data, encode the full image to a PNG. And instead of stuffing that encoding into a string, use a full data: url. And then remove the width and height properties, because they're now implicitly included in the data. And then change the parser to match. And because the parser now parses regular urls on top of data: urls, we can now load any random file.
2019-05-09 01:56:25 +00:00
return FALSE;
}
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
rendernodeparser: Parse images differently Instead of encoding the raw data, encode the full image to a PNG. And instead of stuffing that encoding into a string, use a full data: url. And then remove the width and height properties, because they're now implicitly included in the data. And then change the parser to match. And because the parser now parses regular urls on top of data: urls, we can now load any random file.
2019-05-09 01:56:25 +00:00
*(GdkTexture **) out_data = texture;
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
return TRUE;
}
rendernodeparser: Introduce clear_func We want to be able to clear the already parsed contents, because we need to do that when somebody parses the same property twice.
2019-05-12 22:47:50 +00:00
static void
clear_texture (gpointer inout_texture)
{
g_clear_object ((GdkTexture **) inout_texture);
}
rendernodeparser: Parse cairo script Use cairo-script-interpreter to parse the scripts that generate cairo nodes. This requires libcairoscriptinterpreter.so to work properly, but if it isn't found we disable this (unimportant for normal functioning) code and just emits a parser warning. The testsuite requires it however or it will fail. A new test is included that tests all of this.
2019-05-28 03:51:20 +00:00
static cairo_surface_t *
csi_hooks_surface_create (void *closure,
cairo_content_t content,
double width,
double height,
long uid)
{
return cairo_surface_create_similar (closure, content, width, height);
}
static const cairo_user_data_key_t csi_hooks_key;
static cairo_t *
csi_hooks_context_create (void *closure,
cairo_surface_t *surface)
{
cairo_t *cr = cairo_create (surface);
cairo_set_user_data (cr,
&csi_hooks_key,
cairo_surface_reference (surface),
(cairo_destroy_func_t) cairo_surface_destroy);
return cr;
}
static void
csi_hooks_context_destroy (void *closure,
void *ptr)
{
cairo_surface_t *surface;
cairo_t *cr;
surface = cairo_get_user_data (ptr, &csi_hooks_key);
cr = cairo_create (closure);
cairo_set_source_surface (cr, surface, 0, 0);
cairo_paint (cr);
cairo_destroy (cr);
}
static gboolean
parse_script (GtkCssParser *parser,
gpointer out_data)
{
#ifdef HAVE_CAIRO_SCRIPT_INTERPRETER
GError *error = NULL;
GBytes *bytes;
GtkCssLocation start_location;
char *url, *scheme;
cairo_script_interpreter_t *csi;
cairo_script_interpreter_hooks_t hooks = {
.surface_create = csi_hooks_surface_create,
.context_create = csi_hooks_context_create,
.context_destroy = csi_hooks_context_destroy,
};
start_location = *gtk_css_parser_get_start_location (parser);
url = gtk_css_parser_consume_url (parser);
if (url == NULL)
return FALSE;
scheme = g_uri_parse_scheme (url);
if (scheme && g_ascii_strcasecmp (scheme, "data") == 0)
{
bytes = gtk_css_data_url_parse (url, NULL, &error);
}
else
{
GFile *file;
file = gtk_css_parser_resolve_url (parser, url);
bytes = g_file_load_bytes (file, NULL, NULL, &error);
g_object_unref (file);
}
g_free (scheme);
g_free (url);
if (bytes == NULL)
{
gtk_css_parser_emit_error (parser,
&start_location,
gtk_css_parser_get_end_location (parser),
error);
g_clear_error (&error);
return FALSE;
}
hooks.closure = cairo_recording_surface_create (CAIRO_CONTENT_COLOR_ALPHA, NULL);
csi = cairo_script_interpreter_create ();
cairo_script_interpreter_install_hooks (csi, &hooks);
cairo_script_interpreter_feed_string (csi, g_bytes_get_data (bytes, NULL), g_bytes_get_size (bytes));
g_bytes_unref (bytes);
if (cairo_surface_status (hooks.closure) != CAIRO_STATUS_SUCCESS)
{
gtk_css_parser_error_value (parser, "Invalid Cairo script: %s", cairo_status_to_string (cairo_surface_status (hooks.closure)));
cairo_script_interpreter_destroy (csi);
return FALSE;
}
if (cairo_script_interpreter_destroy (csi) != CAIRO_STATUS_SUCCESS)
{
gtk_css_parser_error_value (parser, "Invalid Cairo script");
cairo_surface_destroy (hooks.closure);
return FALSE;
}
*(cairo_surface_t **) out_data = hooks.closure;
return TRUE;
#else
gtk_css_parser_warn (parser,
GTK_CSS_PARSER_WARNING_UNIMPLEMENTED,
gtk_css_parser_get_block_location (parser),
gtk_css_parser_get_start_location (parser),
"GTK was compiled with script interpreter support. Using fallback pixel data for Cairo node.");
*(cairo_surface_t **) out_data = NULL;
return TRUE;
#endif
}
static void
clear_surface (gpointer inout_surface)
{
g_clear_pointer ((cairo_surface_t **) inout_surface, cairo_surface_destroy);
}
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
static gboolean
parse_rounded_rect (GtkCssParser *parser,
gpointer out_rect)
{
graphene_rect_t r;
graphene_size_t corners[4];
double d;
guint i;
rendernodeparser: Move EOF test into parse_declarations() This way, we don't have to duplicate code. Plus, we can ensure to clear the erroneously parsed value that should not be used.
2019-05-12 22:59:15 +00:00
if (!parse_rect (parser, &r))
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
return FALSE;
if (!gtk_css_parser_try_delim (parser, '/'))
{
gsk_rounded_rect_init_from_rect (out_rect, &r, 0);
return TRUE;
}
for (i = 0; i < 4; i++)
{
if (!gtk_css_parser_has_number (parser))
break;
if (!gtk_css_parser_consume_number (parser, &d))
return FALSE;
corners[i].width = d;
}
if (i == 0)
{
gtk_css_parser_error_syntax (parser, "Expected a number");
return FALSE;
}
/* The magic (i - 1) >> 1 below makes it take the correct value
* according to spec. Feel free to check the 4 cases
*/
for (; i < 4; i++)
corners[i].width = corners[(i - 1) >> 1].width;
if (gtk_css_parser_try_delim (parser, '/'))
{
gtk_css_parser_consume_token (parser);
for (i = 0; i < 4; i++)
{
if (!gtk_css_parser_has_number (parser))
break;
if (!gtk_css_parser_consume_number (parser, &d))
return FALSE;
corners[i].height = d;
}
if (i == 0)
{
gtk_css_parser_error_syntax (parser, "Expected a number");
return FALSE;
}
for (; i < 4; i++)
corners[i].height = corners[(i - 1) >> 1].height;
}
else
{
for (i = 0; i < 4; i++)
corners[i].height = corners[i].width;
}
gsk_rounded_rect_init (out_rect, &r, &corners[0], &corners[1], &corners[2], &corners[3]);
return TRUE;
}
static gboolean
parse_color (GtkCssParser *parser,
gpointer out_color)
{
rendernodeparser: Move EOF test into parse_declarations() This way, we don't have to duplicate code. Plus, we can ensure to clear the erroneously parsed value that should not be used.
2019-05-12 22:59:15 +00:00
return gdk_rgba_parser_parse (parser, out_color);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
}
static gboolean
parse_double (GtkCssParser *parser,
gpointer out_double)
{
rendernodeparser: Move EOF test into parse_declarations() This way, we don't have to duplicate code. Plus, we can ensure to clear the erroneously parsed value that should not be used.
2019-05-12 22:59:15 +00:00
return gtk_css_parser_consume_number (parser, out_double);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
}
static gboolean
parse_point (GtkCssParser *parser,
gpointer out_point)
{
double x, y;
if (!gtk_css_parser_consume_number (parser, &x) ||
rendernodeparser: Move EOF test into parse_declarations() This way, we don't have to duplicate code. Plus, we can ensure to clear the erroneously parsed value that should not be used.
2019-05-12 22:59:15 +00:00
!gtk_css_parser_consume_number (parser, &y))
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
return FALSE;
graphene_point_init (out_point, x, y);
return TRUE;
}
static gboolean
parse_transform (GtkCssParser *parser,
gpointer out_transform)
{
GskTransform *transform;
rendernodeparser: Move EOF test into parse_declarations() This way, we don't have to duplicate code. Plus, we can ensure to clear the erroneously parsed value that should not be used.
2019-05-12 22:59:15 +00:00
if (!gsk_transform_parser_parse (parser, &transform))
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
{
gsk_transform_unref (transform);
return FALSE;
}
*(GskTransform **) out_transform = transform;
return TRUE;
}
rendernodeparser: Introduce clear_func We want to be able to clear the already parsed contents, because we need to do that when somebody parses the same property twice.
2019-05-12 22:47:50 +00:00
static void
clear_transform (gpointer inout_transform)
{
g_clear_pointer ((GskTransform **) inout_transform, gsk_transform_unref);
}
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
static gboolean
parse_string (GtkCssParser *parser,
gpointer out_string)
{
const GtkCssToken *token;
char *s;
token = gtk_css_parser_get_token (parser);
if (!gtk_css_token_is (token, GTK_CSS_TOKEN_STRING))
return FALSE;
s = g_strdup (token->string.string);
gtk_css_parser_consume_token (parser);
g_free (*(char **) out_string);
*(char **) out_string = s;
return TRUE;
}
rendernodeparser: Introduce clear_func We want to be able to clear the already parsed contents, because we need to do that when somebody parses the same property twice.
2019-05-12 22:47:50 +00:00
static void
clear_string (gpointer inout_string)
{
g_clear_pointer ((char **) inout_string, g_free);
}
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
static gboolean
parse_stops (GtkCssParser *parser,
gpointer out_stops)
{
GArray *stops;
GskColorStop stop;
stops = g_array_new (FALSE, FALSE, sizeof (GskColorStop));
for (;;)
{
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
double dval;
if (!gtk_css_parser_consume_number (parser, &dval))
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
goto error;
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
stop.offset = dval;
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
if (!gdk_rgba_parser_parse (parser, &stop.color))
goto error;
if (stops->len == 0 && stop.offset < 0)
gtk_css_parser_error_value (parser, "Color stop offset must be >= 0");
else if (stops->len > 0 && stop.offset < g_array_index (stops, GskColorStop, stops->len - 1).offset)
gtk_css_parser_error_value (parser, "Color stop offset must be >= previous value");
else if (stop.offset > 1)
gtk_css_parser_error_value (parser, "Color stop offset must be <= 1");
else
g_array_append_val (stops, stop);
if (gtk_css_parser_has_token (parser, GTK_CSS_TOKEN_COMMA))
gtk_css_parser_skip (parser);
else
break;
}
if (stops->len < 2)
{
gtk_css_parser_error_value (parser, "At least 2 color stops need to be specified");
g_array_free (stops, TRUE);
return FALSE;
}
if (*(GArray **) out_stops)
g_array_free (*(GArray **) out_stops, TRUE);
*(GArray **) out_stops = stops;
rendernodeparser: Move EOF test into parse_declarations() This way, we don't have to duplicate code. Plus, we can ensure to clear the erroneously parsed value that should not be used.
2019-05-12 22:59:15 +00:00
return TRUE;
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
error:
g_array_free (stops, TRUE);
return FALSE;
}
rendernodeparser: Introduce clear_func We want to be able to clear the already parsed contents, because we need to do that when somebody parses the same property twice.
2019-05-12 22:47:50 +00:00
static void
clear_stops (gpointer inout_stops)
{
GArray **stops = (GArray **) inout_stops;
if (*stops)
{
g_array_free (*stops, TRUE);
*stops = NULL;
}
}
rendernodeparser: Allow single values instead of 4 This allows writing: colors: red; instead of colors: red red red red; to draw a red border.
2019-05-13 22:41:49 +00:00
static gboolean
parse_float4 (GtkCssParser *parser,
gpointer out_floats)
{
float *floats = (float *) out_floats;
double d[4];
int i;
for (i = 0; i < 4 && !gtk_css_parser_has_token (parser, GTK_CSS_TOKEN_EOF); i ++)
{
if (!gtk_css_parser_consume_number (parser, &d[i]))
return FALSE;
}
if (i == 0)
{
gtk_css_parser_error_syntax (parser, "Expected a color");
return FALSE;
}
for (; i < 4; i++)
{
d[i] = d[(i - 1) >> 1];
}
for (i = 0; i < 4; i++)
{
floats[i] = d[i];
}
return TRUE;
}
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
static gboolean
parse_colors4 (GtkCssParser *parser,
gpointer out_colors)
{
rendernodeparser: Allow single values instead of 4 This allows writing: colors: red; instead of colors: red red red red; to draw a red border.
2019-05-13 22:41:49 +00:00
GdkRGBA colors[4];
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
int i;
rendernodeparser: Allow single values instead of 4 This allows writing: colors: red; instead of colors: red red red red; to draw a red border.
2019-05-13 22:41:49 +00:00
for (i = 0; i < 4 && !gtk_css_parser_has_token (parser, GTK_CSS_TOKEN_EOF); i ++)
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
{
if (!gdk_rgba_parser_parse (parser, &colors[i]))
return FALSE;
}
rendernodeparser: Allow single values instead of 4 This allows writing: colors: red; instead of colors: red red red red; to draw a red border.
2019-05-13 22:41:49 +00:00
if (i == 0)
{
gtk_css_parser_error_syntax (parser, "Expected a color");
return FALSE;
}
for (; i < 4; i++)
{
colors[i] = colors[(i - 1) >> 1];
}
memcpy (out_colors, colors, sizeof (GdkRGBA) * 4);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
rendernodeparser: Move EOF test into parse_declarations() This way, we don't have to duplicate code. Plus, we can ensure to clear the erroneously parsed value that should not be used.
2019-05-12 22:59:15 +00:00
return TRUE;
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
}
static gboolean
parse_shadows (GtkCssParser *parser,
gpointer out_shadows)
{
GArray *shadows = out_shadows;
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
do
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
{
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
GskShadow shadow = { GDK_RGBA("000000"), 0, 0, 0 };
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
double dx = 0, dy = 0, radius = 0;
if (!gdk_rgba_parser_parse (parser, &shadow.color))
gtk_css_parser_error_value (parser, "Expected shadow color");
if (!gtk_css_parser_consume_number (parser, &dx))
gtk_css_parser_error_value (parser, "Expected shadow x offset");
if (!gtk_css_parser_consume_number (parser, &dy))
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
gtk_css_parser_error_value (parser, "Expected shadow y offset");
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
if (gtk_css_parser_has_number (parser))
{
if (!gtk_css_parser_consume_number (parser, &radius))
gtk_css_parser_error_value (parser, "Expected shadow blur radius");
}
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
shadow.dx = dx;
shadow.dy = dy;
shadow.radius = radius;
g_array_append_val (shadows, shadow);
}
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
while (gtk_css_parser_try_token (parser, GTK_CSS_TOKEN_COMMA));
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
rendernodeparser: Move EOF test into parse_declarations() This way, we don't have to duplicate code. Plus, we can ensure to clear the erroneously parsed value that should not be used.
2019-05-12 22:59:15 +00:00
return TRUE;
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
}
rendernodeparser: Introduce clear_func We want to be able to clear the already parsed contents, because we need to do that when somebody parses the same property twice.
2019-05-12 22:47:50 +00:00
static void
clear_shadows (gpointer inout_shadows)
{
g_array_set_size (*(GArray **) inout_shadows, 0);
}
rendernode: Parse and print blend nodes properly
2019-04-27 07:03:51 +00:00
static const struct
{
GskBlendMode mode;
const char *name;
} blend_modes[] = {
{ GSK_BLEND_MODE_DEFAULT, "normal" },
{ GSK_BLEND_MODE_MULTIPLY, "multiply" },
{ GSK_BLEND_MODE_SCREEN, "screen" },
{ GSK_BLEND_MODE_OVERLAY, "overlay" },
{ GSK_BLEND_MODE_DARKEN, "darken" },
{ GSK_BLEND_MODE_LIGHTEN, "lighten" },
{ GSK_BLEND_MODE_COLOR_DODGE, "color-dodge" },
{ GSK_BLEND_MODE_COLOR_BURN, "color-burn" },
{ GSK_BLEND_MODE_HARD_LIGHT, "hard-light" },
{ GSK_BLEND_MODE_SOFT_LIGHT, "soft-light" },
{ GSK_BLEND_MODE_DIFFERENCE, "difference" },
{ GSK_BLEND_MODE_EXCLUSION, "exclusion" },
{ GSK_BLEND_MODE_COLOR, "color" },
{ GSK_BLEND_MODE_HUE, "hue" },
{ GSK_BLEND_MODE_SATURATION, "saturation" },
{ GSK_BLEND_MODE_LUMINOSITY, "luminosity" }
};
static gboolean
parse_blend_mode (GtkCssParser *parser,
gpointer out_mode)
{
guint i;
for (i = 0; i < G_N_ELEMENTS (blend_modes); i++)
{
if (gtk_css_parser_try_ident (parser, blend_modes[i].name))
{
*(GskBlendMode *) out_mode = blend_modes[i].mode;
return TRUE;
}
}
return FALSE;
}
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
static PangoFont *
font_from_string (const char *string)
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
{
PangoFontDescription *desc;
PangoFontMap *font_map;
PangoContext *context;
PangoFont *font;
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
desc = pango_font_description_from_string (string);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
font_map = pango_cairo_font_map_get_default ();
context = pango_font_map_create_context (font_map);
font = pango_font_map_load_font (font_map, context, desc);
pango_font_description_free (desc);
g_object_unref (context);
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
return font;
}
rendernodeparser: Allow parsing strings Instead of only allowing for glyph indexes, allow ASCII characters as replacements. So this glyph sequence glyphs: 65 8, 66 8, 67 8 Can be replaced by glyphs: "ABC" provided that the glyph for "A", "B" and "C" are 65, 66 and 67 respectively and their advance is exactly 8. x offset and y offset must always be 0 and every glyph must start a cluster.
2019-05-19 18:20:09 +00:00
#define MIN_ASCII_GLYPH 32
#define MAX_ASCII_GLYPH 127 /* exclusive */
#define N_ASCII_GLYPHS (MAX_ASCII_GLYPH - MIN_ASCII_GLYPH)
static PangoGlyphString *
create_ascii_glyphs (PangoFont *font)
{
PangoLanguage *language = pango_language_from_string ("en_US"); /* just pick one */
PangoCoverage *coverage;
PangoAnalysis not_a_hack = {
gsk: Stop using deprecated pango api Shape engines are not used anymore.
2019-08-02 03:42:21 +00:00
.shape_engine = NULL, /* unused */
rendernodeparser: Allow parsing strings Instead of only allowing for glyph indexes, allow ASCII characters as replacements. So this glyph sequence glyphs: 65 8, 66 8, 67 8 Can be replaced by glyphs: "ABC" provided that the glyph for "A", "B" and "C" are 65, 66 and 67 respectively and their advance is exactly 8. x offset and y offset must always be 0 and every glyph must start a cluster.
2019-05-19 18:20:09 +00:00
.lang_engine = NULL, /* unused by pango_shape() */
.font = font,
.level = 0,
.gravity = PANGO_GRAVITY_SOUTH,
.flags = 0,
.script = PANGO_SCRIPT_COMMON,
.language = language,
.extra_attrs = NULL
};
PangoGlyphString *result, *glyph_string;
guint i;
coverage = pango_font_get_coverage (font, language);
for (i = MIN_ASCII_GLYPH; i < MAX_ASCII_GLYPH; i++)
{
if (!pango_coverage_get (coverage, i))
break;
}
pango_coverage_unref (coverage);
if (i < MAX_ASCII_GLYPH)
return NULL;
result = pango_glyph_string_new ();
pango_glyph_string_set_size (result, N_ASCII_GLYPHS);
glyph_string = pango_glyph_string_new ();
for (i = MIN_ASCII_GLYPH; i < MAX_ASCII_GLYPH; i++)
{
gsk: Improve glyph serialization The special case for ASCII glyphs is unfortunately not working very well, because of an oversight in pango: When I added subpixel positioning, I made pango_shape() default to not rounding, and make PangoLayout call pango_shape_with_flags() and pass the rounding information down. The upshot is that we need to use the _with_flags variant here and tell it to round position, so it matches what the text node contains.
2020-12-21 18:08:34 +00:00
const char text[2] = { i, 0 };
pango_shape_with_flags (text,
1,
text,
1,
&not_a_hack,
glyph_string,
PANGO_SHAPE_ROUND_POSITIONS);
rendernodeparser: Allow parsing strings Instead of only allowing for glyph indexes, allow ASCII characters as replacements. So this glyph sequence glyphs: 65 8, 66 8, 67 8 Can be replaced by glyphs: "ABC" provided that the glyph for "A", "B" and "C" are 65, 66 and 67 respectively and their advance is exactly 8. x offset and y offset must always be 0 and every glyph must start a cluster.
2019-05-19 18:20:09 +00:00
if (glyph_string->num_glyphs != 1)
{
pango_glyph_string_free (glyph_string);
pango_glyph_string_free (result);
return NULL;
}
result->glyphs[i - MIN_ASCII_GLYPH] = glyph_string->glyphs[0];
}
pango_glyph_string_free (glyph_string);
return result;
}
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
static gboolean
parse_font (GtkCssParser *parser,
gpointer out_font)
{
PangoFont *font;
char *s;
s = gtk_css_parser_consume_string (parser);
if (s == NULL)
return FALSE;
font = font_from_string (s);
if (font == NULL)
{
gtk_css_parser_error_syntax (parser, "This font does not exist.");
return FALSE;
}
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
*((PangoFont**)out_font) = font;
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
g_free (s);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
rendernodeparser: Move EOF test into parse_declarations() This way, we don't have to duplicate code. Plus, we can ensure to clear the erroneously parsed value that should not be used.
2019-05-12 22:59:15 +00:00
return TRUE;
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
}
rendernodeparser: Introduce clear_func We want to be able to clear the already parsed contents, because we need to do that when somebody parses the same property twice.
2019-05-12 22:47:50 +00:00
static void
clear_font (gpointer inout_font)
{
g_clear_object ((PangoFont **) inout_font);
}
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
static gboolean
parse_glyphs (GtkCssParser *parser,
gpointer out_glyphs)
{
PangoGlyphString *glyph_string;
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
glyph_string = pango_glyph_string_new ();
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
do
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
{
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
PangoGlyphInfo gi = { 0, { 0, 0, 0}, { 1 } };
double d, d2;
int i;
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
rendernodeparser: Allow parsing strings Instead of only allowing for glyph indexes, allow ASCII characters as replacements. So this glyph sequence glyphs: 65 8, 66 8, 67 8 Can be replaced by glyphs: "ABC" provided that the glyph for "A", "B" and "C" are 65, 66 and 67 respectively and their advance is exactly 8. x offset and y offset must always be 0 and every glyph must start a cluster.
2019-05-19 18:20:09 +00:00
if (gtk_css_parser_has_token (parser, GTK_CSS_TOKEN_STRING))
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
{
rendernodeparser: Allow parsing strings Instead of only allowing for glyph indexes, allow ASCII characters as replacements. So this glyph sequence glyphs: 65 8, 66 8, 67 8 Can be replaced by glyphs: "ABC" provided that the glyph for "A", "B" and "C" are 65, 66 and 67 respectively and their advance is exactly 8. x offset and y offset must always be 0 and every glyph must start a cluster.
2019-05-19 18:20:09 +00:00
char *s = gtk_css_parser_consume_string (parser);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
rendernodeparser: Allow parsing strings Instead of only allowing for glyph indexes, allow ASCII characters as replacements. So this glyph sequence glyphs: 65 8, 66 8, 67 8 Can be replaced by glyphs: "ABC" provided that the glyph for "A", "B" and "C" are 65, 66 and 67 respectively and their advance is exactly 8. x offset and y offset must always be 0 and every glyph must start a cluster.
2019-05-19 18:20:09 +00:00
for (i = 0; s[i] != 0; i++)
{
if (s[i] < MIN_ASCII_GLYPH || s[i] >= MAX_ASCII_GLYPH)
{
gtk_css_parser_error_value (parser, "Unsupported character %d in string", i);
}
gi.glyph = PANGO_GLYPH_INVALID_INPUT - MAX_ASCII_GLYPH + s[i];
pango_glyph_string_set_size (glyph_string, glyph_string->num_glyphs + 1);
glyph_string->glyphs[glyph_string->num_glyphs - 1] = gi;
}
rendernodeparser: Fix a memory leak when parsing glyphs
2019-07-21 07:06:50 +00:00
g_free (s);
rendernodeparser: Allow parsing strings Instead of only allowing for glyph indexes, allow ASCII characters as replacements. So this glyph sequence glyphs: 65 8, 66 8, 67 8 Can be replaced by glyphs: "ABC" provided that the glyph for "A", "B" and "C" are 65, 66 and 67 respectively and their advance is exactly 8. x offset and y offset must always be 0 and every glyph must start a cluster.
2019-05-19 18:20:09 +00:00
}
else
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
{
rendernodeparser: Allow parsing strings Instead of only allowing for glyph indexes, allow ASCII characters as replacements. So this glyph sequence glyphs: 65 8, 66 8, 67 8 Can be replaced by glyphs: "ABC" provided that the glyph for "A", "B" and "C" are 65, 66 and 67 respectively and their advance is exactly 8. x offset and y offset must always be 0 and every glyph must start a cluster.
2019-05-19 18:20:09 +00:00
if (!gtk_css_parser_consume_integer (parser, &i) ||
!gtk_css_parser_consume_number (parser, &d))
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
{
pango_glyph_string_free (glyph_string);
return FALSE;
}
rendernodeparser: Allow parsing strings Instead of only allowing for glyph indexes, allow ASCII characters as replacements. So this glyph sequence glyphs: 65 8, 66 8, 67 8 Can be replaced by glyphs: "ABC" provided that the glyph for "A", "B" and "C" are 65, 66 and 67 respectively and their advance is exactly 8. x offset and y offset must always be 0 and every glyph must start a cluster.
2019-05-19 18:20:09 +00:00
gi.glyph = i;
gi.geometry.width = (int) (d * PANGO_SCALE);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
rendernodeparser: Allow parsing strings Instead of only allowing for glyph indexes, allow ASCII characters as replacements. So this glyph sequence glyphs: 65 8, 66 8, 67 8 Can be replaced by glyphs: "ABC" provided that the glyph for "A", "B" and "C" are 65, 66 and 67 respectively and their advance is exactly 8. x offset and y offset must always be 0 and every glyph must start a cluster.
2019-05-19 18:20:09 +00:00
if (gtk_css_parser_has_number (parser))
{
if (!gtk_css_parser_consume_number (parser, &d) ||
!gtk_css_parser_consume_number (parser, &d2))
{
pango_glyph_string_free (glyph_string);
return FALSE;
}
gi.geometry.x_offset = (int) (d * PANGO_SCALE);
gi.geometry.y_offset = (int) (d2 * PANGO_SCALE);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
rendernodeparser: Allow parsing strings Instead of only allowing for glyph indexes, allow ASCII characters as replacements. So this glyph sequence glyphs: 65 8, 66 8, 67 8 Can be replaced by glyphs: "ABC" provided that the glyph for "A", "B" and "C" are 65, 66 and 67 respectively and their advance is exactly 8. x offset and y offset must always be 0 and every glyph must start a cluster.
2019-05-19 18:20:09 +00:00
if (gtk_css_parser_try_ident (parser, "same-cluster"))
gi.attr.is_cluster_start = 0;
else
gi.attr.is_cluster_start = 1;
}
pango_glyph_string_set_size (glyph_string, glyph_string->num_glyphs + 1);
glyph_string->glyphs[glyph_string->num_glyphs - 1] = gi;
}
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
}
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
while (gtk_css_parser_try_token (parser, GTK_CSS_TOKEN_COMMA));
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
*((PangoGlyphString **)out_glyphs) = glyph_string;
rendernodeparser: Move EOF test into parse_declarations() This way, we don't have to duplicate code. Plus, we can ensure to clear the erroneously parsed value that should not be used.
2019-05-12 22:59:15 +00:00
return TRUE;
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
}
rendernodeparser: Introduce clear_func We want to be able to clear the already parsed contents, because we need to do that when somebody parses the same property twice.
2019-05-12 22:47:50 +00:00
static void
clear_glyphs (gpointer inout_glyphs)
{
g_clear_pointer ((PangoGlyphString **) inout_glyphs, pango_glyph_string_free);
}
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
static gboolean
parse_node (GtkCssParser *parser, gpointer out_node);
rendernodeparser: Introduce clear_func We want to be able to clear the already parsed contents, because we need to do that when somebody parses the same property twice.
2019-05-12 22:47:50 +00:00
static void
clear_node (gpointer inout_node)
{
g_clear_pointer ((GskRenderNode **) inout_node, gsk_render_node_unref);
}
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
static GskRenderNode *
parse_container_node (GtkCssParser *parser)
{
GPtrArray *nodes;
const GtkCssToken *token;
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 *node;
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
nodes = g_ptr_array_new_with_free_func ((GDestroyNotify) gsk_render_node_unref);
for (token = gtk_css_parser_get_token (parser);
!gtk_css_token_is (token, GTK_CSS_TOKEN_EOF);
token = gtk_css_parser_get_token (parser))
{
node = NULL;
rendernodeparser: fix typo
2019-07-13 09:12:47 +00:00
/* We don't want a semicolon here, but the parse_node function will figure
rendernodeparser: Use parser blocks Instead of trying to do error handling manually, use the semicolon blocks feature provided by GtkCssParser.
2019-05-12 11:14:50 +00:00
* that out itself and return an error if we encounter one.
*/
gtk_css_parser_start_semicolon_block (parser, GTK_CSS_TOKEN_OPEN_CURLY);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
if (parse_node (parser, &node))
rendernodeparser: Use parser blocks Instead of trying to do error handling manually, use the semicolon blocks feature provided by GtkCssParser.
2019-05-12 11:14:50 +00:00
g_ptr_array_add (nodes, node);
gtk_css_parser_end_block (parser);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
}
node = gsk_container_node_new ((GskRenderNode **) nodes->pdata, nodes->len);
g_ptr_array_unref (nodes);
return node;
}
static guint
parse_declarations (GtkCssParser *parser,
const Declaration *declarations,
guint n_declarations)
{
guint parsed = 0;
guint i;
g_assert (n_declarations < 8 * sizeof (guint));
rendernodeparser: Move EOF test into parse_declarations() This way, we don't have to duplicate code. Plus, we can ensure to clear the erroneously parsed value that should not be used.
2019-05-12 22:59:15 +00:00
while (!gtk_css_parser_has_token (parser, GTK_CSS_TOKEN_EOF))
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
{
rendernodeparser: Use parser blocks Instead of trying to do error handling manually, use the semicolon blocks feature provided by GtkCssParser.
2019-05-12 11:14:50 +00:00
gtk_css_parser_start_semicolon_block (parser, GTK_CSS_TOKEN_OPEN_CURLY);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
for (i = 0; i < n_declarations; i++)
{
rendernodeparser: Move EOF test into parse_declarations() This way, we don't have to duplicate code. Plus, we can ensure to clear the erroneously parsed value that should not be used.
2019-05-12 22:59:15 +00:00
if (gtk_css_parser_try_ident (parser, declarations[i].name))
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
{
rendernodeparser: Move EOF test into parse_declarations() This way, we don't have to duplicate code. Plus, we can ensure to clear the erroneously parsed value that should not be used.
2019-05-12 22:59:15 +00:00
if (!gtk_css_parser_try_token (parser, GTK_CSS_TOKEN_COLON))
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
{
gtk_css_parser_error_syntax (parser, "Expected ':' after variable declaration");
}
else
{
if (parsed & (1 << i))
rendernodeparser: Introduce clear_func We want to be able to clear the already parsed contents, because we need to do that when somebody parses the same property twice.
2019-05-12 22:47:50 +00:00
{
gtk_css_parser_warn_syntax (parser, "Variable \"%s\" defined multiple times", declarations[i].name);
rendernodeparser: Move EOF test into parse_declarations() This way, we don't have to duplicate code. Plus, we can ensure to clear the erroneously parsed value that should not be used.
2019-05-12 22:59:15 +00:00
/* Unset, just to be sure */
parsed &= ~(1 << i);
rendernodeparser: Introduce clear_func We want to be able to clear the already parsed contents, because we need to do that when somebody parses the same property twice.
2019-05-12 22:47:50 +00:00
if (declarations[i].clear_func)
declarations[i].clear_func (declarations[i].result);
}
rendernodeparser: Move EOF test into parse_declarations() This way, we don't have to duplicate code. Plus, we can ensure to clear the erroneously parsed value that should not be used.
2019-05-12 22:59:15 +00:00
if (!declarations[i].parse_func (parser, declarations[i].result))
{
/* nothing to do */
}
else if (!gtk_css_parser_has_token (parser, GTK_CSS_TOKEN_EOF))
{
gtk_css_parser_error_syntax (parser, "Expected ';' at end of statement");
if (declarations[i].clear_func)
declarations[i].clear_func (declarations[i].result);
}
else
{
parsed |= (1 << i);
}
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
}
break;
}
}
if (i == n_declarations)
{
rendernodeparser: Move EOF test into parse_declarations() This way, we don't have to duplicate code. Plus, we can ensure to clear the erroneously parsed value that should not be used.
2019-05-12 22:59:15 +00:00
if (gtk_css_parser_has_token (parser, GTK_CSS_TOKEN_IDENT))
gtk_css_parser_error_syntax (parser, "No variable named \"%s\"",
gtk_css_parser_get_token (parser)->string.string);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
else
gtk_css_parser_error_syntax (parser, "Expected a variable name");
}
rendernodeparser: Use parser blocks Instead of trying to do error handling manually, use the semicolon blocks feature provided by GtkCssParser.
2019-05-12 11:14:50 +00:00
gtk_css_parser_end_block (parser);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
}
return parsed;
}
rendernodeparser: Parse Cairo nodes We also print the script, but we don't parse it yet.
2019-05-25 22:50:13 +00:00
static GdkTexture *
create_default_texture (void)
{
static const guint32 pixels[100] = {
0xFFFF00CC, 0xFFFF00CC, 0xFFFF00CC, 0xFFFF00CC, 0xFFFF00CC, 0, 0, 0, 0, 0,
0xFFFF00CC, 0xFFFF00CC, 0xFFFF00CC, 0xFFFF00CC, 0xFFFF00CC, 0, 0, 0, 0, 0,
0xFFFF00CC, 0xFFFF00CC, 0xFFFF00CC, 0xFFFF00CC, 0xFFFF00CC, 0, 0, 0, 0, 0,
0xFFFF00CC, 0xFFFF00CC, 0xFFFF00CC, 0xFFFF00CC, 0xFFFF00CC, 0, 0, 0, 0, 0,
0xFFFF00CC, 0xFFFF00CC, 0xFFFF00CC, 0xFFFF00CC, 0xFFFF00CC, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0xFFFF00CC, 0xFFFF00CC, 0xFFFF00CC, 0xFFFF00CC, 0xFFFF00CC,
0, 0, 0, 0, 0, 0xFFFF00CC, 0xFFFF00CC, 0xFFFF00CC, 0xFFFF00CC, 0xFFFF00CC,
0, 0, 0, 0, 0, 0xFFFF00CC, 0xFFFF00CC, 0xFFFF00CC, 0xFFFF00CC, 0xFFFF00CC,
0, 0, 0, 0, 0, 0xFFFF00CC, 0xFFFF00CC, 0xFFFF00CC, 0xFFFF00CC, 0xFFFF00CC,
0, 0, 0, 0, 0, 0xFFFF00CC, 0xFFFF00CC, 0xFFFF00CC, 0xFFFF00CC, 0xFFFF00CC };
GBytes *bytes;
GdkTexture *texture;
bytes = g_bytes_new_static ((guchar *) pixels, 400);
texture = gdk_memory_texture_new (10, 10, GDK_MEMORY_DEFAULT, bytes, 40);
g_bytes_unref (bytes);
return texture;
}
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
static GskRenderNode *
create_default_render_node (void)
{
return gsk_color_node_new (&GDK_RGBA("FF00CC"), &GRAPHENE_RECT_INIT (0, 0, 50, 50));
}
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
static GskRenderNode *
parse_color_node (GtkCssParser *parser)
{
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
graphene_rect_t bounds = GRAPHENE_RECT_INIT (0, 0, 50, 50);
GdkRGBA color = GDK_RGBA("FF00CC");
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
const Declaration declarations[] = {
rendernodeparser: Introduce clear_func We want to be able to clear the already parsed contents, because we need to do that when somebody parses the same property twice.
2019-05-12 22:47:50 +00:00
{ "bounds", parse_rect, NULL, &bounds },
{ "color", parse_color, NULL, &color },
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
};
parse_declarations (parser, declarations, G_N_ELEMENTS(declarations));
return gsk_color_node_new (&color, &bounds);
}
static GskRenderNode *
rendernodeparser: Handle repeating linear gradients Just handle them like regular gradients, only name them differently.
2019-05-29 03:55:28 +00:00
parse_linear_gradient_node_internal (GtkCssParser *parser,
gboolean repeating)
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
{
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
graphene_rect_t bounds = GRAPHENE_RECT_INIT (0, 0, 50, 50);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
graphene_point_t start = GRAPHENE_POINT_INIT (0, 0);
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
graphene_point_t end = GRAPHENE_POINT_INIT (0, 50);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
GArray *stops = NULL;
const Declaration declarations[] = {
rendernodeparser: Introduce clear_func We want to be able to clear the already parsed contents, because we need to do that when somebody parses the same property twice.
2019-05-12 22:47:50 +00:00
{ "bounds", parse_rect, NULL, &bounds },
{ "start", parse_point, NULL, &start },
{ "end", parse_point, NULL, &end },
{ "stops", parse_stops, clear_stops, &stops },
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
};
GskRenderNode *result;
parse_declarations (parser, declarations, G_N_ELEMENTS(declarations));
if (stops == NULL)
{
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
GskColorStop from = { 0.0, GDK_RGBA("AAFF00") };
GskColorStop to = { 1.0, GDK_RGBA("FF00CC") };
stops = g_array_new (FALSE, FALSE, sizeof (GskColorStop));
g_array_append_val (stops, from);
g_array_append_val (stops, to);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
}
rendernodeparser: Handle repeating linear gradients Just handle them like regular gradients, only name them differently.
2019-05-29 03:55:28 +00:00
if (repeating)
result = gsk_repeating_linear_gradient_node_new (&bounds, &start, &end, (GskColorStop *) stops->data, stops->len);
else
result = gsk_linear_gradient_node_new (&bounds, &start, &end, (GskColorStop *) stops->data, stops->len);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
g_array_free (stops, TRUE);
return result;
}
rendernodeparser: Handle repeating linear gradients Just handle them like regular gradients, only name them differently.
2019-05-29 03:55:28 +00:00
static GskRenderNode *
parse_linear_gradient_node (GtkCssParser *parser)
{
return parse_linear_gradient_node_internal (parser, FALSE);
}
static GskRenderNode *
parse_repeating_linear_gradient_node (GtkCssParser *parser)
{
return parse_linear_gradient_node_internal (parser, TRUE);
}
gsk: Parse radial gradient nodes
2020-09-15 04:20:56 +00:00
static GskRenderNode *
parse_radial_gradient_node_internal (GtkCssParser *parser,
gboolean repeating)
{
graphene_rect_t bounds = GRAPHENE_RECT_INIT (0, 0, 50, 50);
graphene_point_t center = GRAPHENE_POINT_INIT (25, 25);
double hradius = 25.0;
double vradius = 25.0;
radial gradients: Allow 0 start/end values
2020-09-16 03:02:07 +00:00
double start = 0;
gsk: Parse radial gradient nodes
2020-09-15 04:20:56 +00:00
double end = 1.0;
GArray *stops = NULL;
const Declaration declarations[] = {
{ "bounds", parse_rect, NULL, &bounds },
{ "center", parse_point, NULL, &center },
{ "hradius", parse_double, NULL, &hradius },
{ "vradius", parse_double, NULL, &vradius },
{ "start", parse_double, NULL, &start },
{ "end", parse_double, NULL, &end },
{ "stops", parse_stops, clear_stops, &stops },
};
GskRenderNode *result;
parse_declarations (parser, declarations, G_N_ELEMENTS(declarations));
if (stops == NULL)
{
GskColorStop from = { 0.0, GDK_RGBA("AAFF00") };
GskColorStop to = { 1.0, GDK_RGBA("FF00CC") };
stops = g_array_new (FALSE, FALSE, sizeof (GskColorStop));
g_array_append_val (stops, from);
g_array_append_val (stops, to);
}
if (repeating)
result = gsk_repeating_radial_gradient_node_new (&bounds, &center, hradius, vradius, start, end,
(GskColorStop *) stops->data, stops->len);
else
result = gsk_radial_gradient_node_new (&bounds, &center, hradius, vradius, start, end,
(GskColorStop *) stops->data, stops->len);
g_array_free (stops, TRUE);
return result;
}
static GskRenderNode *
parse_radial_gradient_node (GtkCssParser *parser)
{
return parse_radial_gradient_node_internal (parser, FALSE);
}
static GskRenderNode *
parse_repeating_radial_gradient_node (GtkCssParser *parser)
{
return parse_radial_gradient_node_internal (parser, TRUE);
}
gsk: Add GskConicGradientNode
2020-12-02 23:47:54 +00:00
static GskRenderNode *
parse_conic_gradient_node (GtkCssParser *parser)
{
graphene_rect_t bounds = GRAPHENE_RECT_INIT (0, 0, 50, 50);
graphene_point_t center = GRAPHENE_POINT_INIT (25, 25);
double rotation = 0.0;
GArray *stops = NULL;
const Declaration declarations[] = {
{ "bounds", parse_rect, NULL, &bounds },
{ "center", parse_point, NULL, &center },
{ "rotation", parse_double, NULL, &rotation },
{ "stops", parse_stops, clear_stops, &stops },
};
GskRenderNode *result;
parse_declarations (parser, declarations, G_N_ELEMENTS(declarations));
if (stops == NULL)
{
GskColorStop from = { 0.0, GDK_RGBA("AAFF00") };
GskColorStop to = { 1.0, GDK_RGBA("FF00CC") };
stops = g_array_new (FALSE, FALSE, sizeof (GskColorStop));
g_array_append_val (stops, from);
g_array_append_val (stops, to);
}
result = gsk_conic_gradient_node_new (&bounds, &center, rotation,
(GskColorStop *) stops->data, stops->len);
g_array_free (stops, TRUE);
return result;
}
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
static GskRenderNode *
parse_inset_shadow_node (GtkCssParser *parser)
{
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
GskRoundedRect outline = GSK_ROUNDED_RECT_INIT (0, 0, 50, 50);
rgba: Add GDK_RGBA() macro So far it's private, but it's a pretty cute way to use hex colors, so we might conside making it public.
2019-05-14 20:23:15 +00:00
GdkRGBA color = GDK_RGBA("000000");
rendernodeparser: Introduce clear_func We want to be able to clear the already parsed contents, because we need to do that when somebody parses the same property twice.
2019-05-12 22:47:50 +00:00
double dx = 1, dy = 1, blur = 0, spread = 0;
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
const Declaration declarations[] = {
rendernodeparser: Introduce clear_func We want to be able to clear the already parsed contents, because we need to do that when somebody parses the same property twice.
2019-05-12 22:47:50 +00:00
{ "outline", parse_rounded_rect, NULL, &outline },
{ "color", parse_color, NULL, &color },
{ "dx", parse_double, NULL, &dx },
{ "dy", parse_double, NULL, &dy },
{ "spread", parse_double, NULL, &spread },
{ "blur", parse_double, NULL, &blur }
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
};
parse_declarations (parser, declarations, G_N_ELEMENTS(declarations));
return gsk_inset_shadow_node_new (&outline, &color, dx, dy, spread, blur);
}
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
typedef union {
gint32 i;
double v[4];
} UniformValue;
typedef struct {
GskGLShader *shader;
GskShaderArgsBuilder *args;
} ShaderInfo;
static void
clear_shader_info (gpointer data)
{
ShaderInfo *info = data;
g_clear_object (&info->shader);
g_clear_pointer (&info->args, gsk_shader_args_builder_unref);
}
static gboolean
parse_shader (GtkCssParser *parser,
gpointer out_shader_info)
{
ShaderInfo *shader_info = out_shader_info;
char *sourcecode = NULL;
GBytes *bytes;
GskGLShader *shader;
if (!parse_string (parser, &sourcecode))
return FALSE;
bytes = g_bytes_new_take (sourcecode, strlen (sourcecode));
shader = gsk_gl_shader_new_from_bytes (bytes);
g_bytes_unref (bytes);
shader_info->shader = shader;
return TRUE;
}
static gboolean
parse_uniform_value (GtkCssParser *parser,
int idx,
ShaderInfo *shader_info)
{
switch (gsk_gl_shader_get_uniform_type (shader_info->shader, idx))
{
case GSK_GL_UNIFORM_TYPE_FLOAT:
{
double f;
if (!gtk_css_parser_consume_number (parser, &f))
return FALSE;
gsk_shader_args_builder_set_float (shader_info->args, idx, f);
}
break;
case GSK_GL_UNIFORM_TYPE_INT:
{
int i;
if (!gtk_css_parser_consume_integer (parser, &i))
return FALSE;
gsk_shader_args_builder_set_int (shader_info->args, idx, i);
}
break;
case GSK_GL_UNIFORM_TYPE_UINT:
{
int i;
if (!gtk_css_parser_consume_integer (parser, &i) || i < 0)
return FALSE;
gsk_shader_args_builder_set_uint (shader_info->args, idx, i);
}
break;
case GSK_GL_UNIFORM_TYPE_BOOL:
{
int i;
if (!gtk_css_parser_consume_integer (parser, &i) || (i != 0 && i != 1))
return FALSE;
gsk_shader_args_builder_set_bool (shader_info->args, idx, i);
}
break;
case GSK_GL_UNIFORM_TYPE_VEC2:
{
double f0, f1;
graphene_vec2_t v;
if (!gtk_css_parser_consume_number (parser, &f0) ||
!gtk_css_parser_consume_number (parser, &f1))
return FALSE;
graphene_vec2_init (&v, f0, f1);
gsk_shader_args_builder_set_vec2 (shader_info->args, idx, &v);
}
break;
case GSK_GL_UNIFORM_TYPE_VEC3:
{
double f0, f1, f2;
graphene_vec3_t v;
if (!gtk_css_parser_consume_number (parser, &f0) ||
!gtk_css_parser_consume_number (parser, &f1) ||
!gtk_css_parser_consume_number (parser, &f2))
return FALSE;
graphene_vec3_init (&v, f0, f1, f2);
gsk_shader_args_builder_set_vec3 (shader_info->args, idx, &v);
}
break;
case GSK_GL_UNIFORM_TYPE_VEC4:
{
double f0, f1, f2, f3;
graphene_vec4_t v;
if (!gtk_css_parser_consume_number (parser, &f0) ||
!gtk_css_parser_consume_number (parser, &f1) ||
!gtk_css_parser_consume_number (parser, &f2) ||
!gtk_css_parser_consume_number (parser, &f3))
return FALSE;
graphene_vec4_init (&v, f0, f1, f2, f3);
gsk_shader_args_builder_set_vec4 (shader_info->args, idx, &v);
}
break;
case GSK_GL_UNIFORM_TYPE_NONE:
default:
g_assert_not_reached ();
break;
}
if (idx < gsk_gl_shader_get_n_uniforms (shader_info->shader))
{
if (!gtk_css_parser_try_token (parser, GTK_CSS_TOKEN_COMMA))
return FALSE;
}
return TRUE;
}
static gboolean
parse_shader_args (GtkCssParser *parser, gpointer data)
{
ShaderInfo *shader_info = data;
int n_uniforms;
int i;
shader_info->args = gsk_shader_args_builder_new (shader_info->shader, NULL);
n_uniforms = gsk_gl_shader_get_n_uniforms (shader_info->shader);
for (i = 0; i < n_uniforms; i++)
{
if (!parse_uniform_value (parser, i, shader_info))
return FALSE;
}
return TRUE;
}
static GskRenderNode *
parse_glshader_node (GtkCssParser *parser)
{
graphene_rect_t bounds = GRAPHENE_RECT_INIT (0, 0, 50, 50);
GskRenderNode *child[4] = { NULL, };
ShaderInfo shader_info = {
NULL,
NULL,
};
const Declaration declarations[] = {
{ "bounds", parse_rect, NULL, &bounds },
{ "sourcecode", parse_shader, NULL, &shader_info },
{ "args", parse_shader_args, clear_shader_info, &shader_info },
{ "child1", parse_node, clear_node, &child[0] },
{ "child2", parse_node, clear_node, &child[1] },
{ "child3", parse_node, clear_node, &child[2] },
{ "child4", parse_node, clear_node, &child[3] },
};
GskGLShader *shader;
GskRenderNode *node;
GBytes *args = NULL;
int len, i;
parse_declarations (parser, declarations, G_N_ELEMENTS(declarations));
for (len = 0; len < 4; len++)
{
if (child[len] == NULL)
break;
}
shader = shader_info.shader;
args = gsk_shader_args_builder_free_to_args (shader_info.args);
node = gsk_gl_shader_node_new (shader, &bounds, args, child, len);
g_bytes_unref (args);
g_object_unref (shader);
for (i = 0; i < 4; i++)
{
if (child[i])
gsk_render_node_unref (child[i]);
}
return node;
}
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
static GskRenderNode *
parse_border_node (GtkCssParser *parser)
{
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
GskRoundedRect outline = GSK_ROUNDED_RECT_INIT (0, 0, 50, 50);
rendernodeparser: Allow single values instead of 4 This allows writing: colors: red; instead of colors: red red red red; to draw a red border.
2019-05-13 22:41:49 +00:00
float widths[4] = { 1, 1, 1, 1 };
rgba: Add GDK_RGBA() macro So far it's private, but it's a pretty cute way to use hex colors, so we might conside making it public.
2019-05-14 20:23:15 +00:00
GdkRGBA colors[4] = { GDK_RGBA("000"), GDK_RGBA("000"), GDK_RGBA("000"), GDK_RGBA("000") };
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
const Declaration declarations[] = {
rendernodeparser: Introduce clear_func We want to be able to clear the already parsed contents, because we need to do that when somebody parses the same property twice.
2019-05-12 22:47:50 +00:00
{ "outline", parse_rounded_rect, NULL, &outline },
rendernodeparser: Allow single values instead of 4 This allows writing: colors: red; instead of colors: red red red red; to draw a red border.
2019-05-13 22:41:49 +00:00
{ "widths", parse_float4, NULL, &widths },
rendernodeparser: Introduce clear_func We want to be able to clear the already parsed contents, because we need to do that when somebody parses the same property twice.
2019-05-12 22:47:50 +00:00
{ "colors", parse_colors4, NULL, &colors }
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
};
parse_declarations (parser, declarations, G_N_ELEMENTS(declarations));
rendernodeparser: Allow single values instead of 4 This allows writing: colors: red; instead of colors: red red red red; to draw a red border.
2019-05-13 22:41:49 +00:00
return gsk_border_node_new (&outline, widths, colors);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
}
static GskRenderNode *
parse_texture_node (GtkCssParser *parser)
{
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
graphene_rect_t bounds = GRAPHENE_RECT_INIT (0, 0, 50, 50);
rendernodeparser: Parse images differently Instead of encoding the raw data, encode the full image to a PNG. And instead of stuffing that encoding into a string, use a full data: url. And then remove the width and height properties, because they're now implicitly included in the data. And then change the parser to match. And because the parser now parses regular urls on top of data: urls, we can now load any random file.
2019-05-09 01:56:25 +00:00
GdkTexture *texture = NULL;
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
const Declaration declarations[] = {
rendernodeparser: Introduce clear_func We want to be able to clear the already parsed contents, because we need to do that when somebody parses the same property twice.
2019-05-12 22:47:50 +00:00
{ "bounds", parse_rect, NULL, &bounds },
{ "texture", parse_texture, clear_texture, &texture }
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
};
GskRenderNode *node;
parse_declarations (parser, declarations, G_N_ELEMENTS(declarations));
rendernodeparser: Parse images differently Instead of encoding the raw data, encode the full image to a PNG. And instead of stuffing that encoding into a string, use a full data: url. And then remove the width and height properties, because they're now implicitly included in the data. And then change the parser to match. And because the parser now parses regular urls on top of data: urls, we can now load any random file.
2019-05-09 01:56:25 +00:00
if (texture == NULL)
rendernodeparser: Parse Cairo nodes We also print the script, but we don't parse it yet.
2019-05-25 22:50:13 +00:00
texture = create_default_texture ();
rendernodeparser: Parse images differently Instead of encoding the raw data, encode the full image to a PNG. And instead of stuffing that encoding into a string, use a full data: url. And then remove the width and height properties, because they're now implicitly included in the data. And then change the parser to match. And because the parser now parses regular urls on top of data: urls, we can now load any random file.
2019-05-09 01:56:25 +00:00
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
node = gsk_texture_node_new (texture, &bounds);
g_object_unref (texture);
return node;
}
rendernodeparser: Parse Cairo nodes We also print the script, but we don't parse it yet.
2019-05-25 22:50:13 +00:00
static GskRenderNode *
parse_cairo_node (GtkCssParser *parser)
{
graphene_rect_t bounds = GRAPHENE_RECT_INIT (0, 0, 50, 50);
GdkTexture *pixels = NULL;
rendernodeparser: Parse cairo script Use cairo-script-interpreter to parse the scripts that generate cairo nodes. This requires libcairoscriptinterpreter.so to work properly, but if it isn't found we disable this (unimportant for normal functioning) code and just emits a parser warning. The testsuite requires it however or it will fail. A new test is included that tests all of this.
2019-05-28 03:51:20 +00:00
cairo_surface_t *surface = NULL;
rendernodeparser: Parse Cairo nodes We also print the script, but we don't parse it yet.
2019-05-25 22:50:13 +00:00
const Declaration declarations[] = {
{ "bounds", parse_rect, NULL, &bounds },
rendernodeparser: Parse cairo script Use cairo-script-interpreter to parse the scripts that generate cairo nodes. This requires libcairoscriptinterpreter.so to work properly, but if it isn't found we disable this (unimportant for normal functioning) code and just emits a parser warning. The testsuite requires it however or it will fail. A new test is included that tests all of this.
2019-05-28 03:51:20 +00:00
{ "pixels", parse_texture, clear_texture, &pixels },
{ "script", parse_script, clear_surface, &surface }
rendernodeparser: Parse Cairo nodes We also print the script, but we don't parse it yet.
2019-05-25 22:50:13 +00:00
};
GskRenderNode *node;
parse_declarations (parser, declarations, G_N_ELEMENTS(declarations));
node = gsk_cairo_node_new (&bounds);
rendernodeparser: Parse cairo script Use cairo-script-interpreter to parse the scripts that generate cairo nodes. This requires libcairoscriptinterpreter.so to work properly, but if it isn't found we disable this (unimportant for normal functioning) code and just emits a parser warning. The testsuite requires it however or it will fail. A new test is included that tests all of this.
2019-05-28 03:51:20 +00:00
if (surface != NULL)
{
rendernodeparser: Handle empty Cairo nodes Cairo nodes can contain a NULL surface if they have never been drawn to. Make this the default Cairo node.
2019-05-29 03:48:38 +00:00
cairo_t *cr = gsk_cairo_node_get_draw_context (node);
rendernodeparser: Parse cairo script Use cairo-script-interpreter to parse the scripts that generate cairo nodes. This requires libcairoscriptinterpreter.so to work properly, but if it isn't found we disable this (unimportant for normal functioning) code and just emits a parser warning. The testsuite requires it however or it will fail. A new test is included that tests all of this.
2019-05-28 03:51:20 +00:00
cairo_set_source_surface (cr, surface, 0, 0);
cairo_paint (cr);
rendernodeparser: Handle empty Cairo nodes Cairo nodes can contain a NULL surface if they have never been drawn to. Make this the default Cairo node.
2019-05-29 03:48:38 +00:00
cairo_destroy (cr);
rendernodeparser: Parse cairo script Use cairo-script-interpreter to parse the scripts that generate cairo nodes. This requires libcairoscriptinterpreter.so to work properly, but if it isn't found we disable this (unimportant for normal functioning) code and just emits a parser warning. The testsuite requires it however or it will fail. A new test is included that tests all of this.
2019-05-28 03:51:20 +00:00
}
else if (pixels != NULL)
rendernodeparser: Parse Cairo nodes We also print the script, but we don't parse it yet.
2019-05-25 22:50:13 +00:00
{
rendernodeparser: Handle empty Cairo nodes Cairo nodes can contain a NULL surface if they have never been drawn to. Make this the default Cairo node.
2019-05-29 03:48:38 +00:00
cairo_t *cr = gsk_cairo_node_get_draw_context (node);
rendernodeparser: Parse Cairo nodes We also print the script, but we don't parse it yet.
2019-05-25 22:50:13 +00:00
surface = gdk_texture_download_surface (pixels);
cairo_set_source_surface (cr, surface, 0, 0);
cairo_paint (cr);
rendernodeparser: Handle empty Cairo nodes Cairo nodes can contain a NULL surface if they have never been drawn to. Make this the default Cairo node.
2019-05-29 03:48:38 +00:00
cairo_destroy (cr);
rendernodeparser: Parse Cairo nodes We also print the script, but we don't parse it yet.
2019-05-25 22:50:13 +00:00
}
else
{
rendernodeparser: Handle empty Cairo nodes Cairo nodes can contain a NULL surface if they have never been drawn to. Make this the default Cairo node.
2019-05-29 03:48:38 +00:00
/* do nothing */
rendernodeparser: Parse Cairo nodes We also print the script, but we don't parse it yet.
2019-05-25 22:50:13 +00:00
}
g_clear_object (&pixels);
rendernodeparser: Parse cairo script Use cairo-script-interpreter to parse the scripts that generate cairo nodes. This requires libcairoscriptinterpreter.so to work properly, but if it isn't found we disable this (unimportant for normal functioning) code and just emits a parser warning. The testsuite requires it however or it will fail. A new test is included that tests all of this.
2019-05-28 03:51:20 +00:00
g_clear_pointer (&surface, cairo_surface_destroy);
rendernodeparser: Parse Cairo nodes We also print the script, but we don't parse it yet.
2019-05-25 22:50:13 +00:00
return node;
}
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
static GskRenderNode *
parse_outset_shadow_node (GtkCssParser *parser)
{
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
GskRoundedRect outline = GSK_ROUNDED_RECT_INIT (0, 0, 50, 50);
rgba: Add GDK_RGBA() macro So far it's private, but it's a pretty cute way to use hex colors, so we might conside making it public.
2019-05-14 20:23:15 +00:00
GdkRGBA color = GDK_RGBA("000000");
rendernodeparser: Introduce clear_func We want to be able to clear the already parsed contents, because we need to do that when somebody parses the same property twice.
2019-05-12 22:47:50 +00:00
double dx = 1, dy = 1, blur = 0, spread = 0;
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
const Declaration declarations[] = {
rendernodeparser: Introduce clear_func We want to be able to clear the already parsed contents, because we need to do that when somebody parses the same property twice.
2019-05-12 22:47:50 +00:00
{ "outline", parse_rounded_rect, NULL, &outline },
{ "color", parse_color, NULL, &color },
{ "dx", parse_double, NULL, &dx },
{ "dy", parse_double, NULL, &dy },
{ "spread", parse_double, NULL, &spread },
{ "blur", parse_double, NULL, &blur }
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
};
parse_declarations (parser, declarations, G_N_ELEMENTS(declarations));
return gsk_outset_shadow_node_new (&outline, &color, dx, dy, spread, blur);
}
static GskRenderNode *
parse_transform_node (GtkCssParser *parser)
{
GskRenderNode *child = NULL;
GskTransform *transform = NULL;
const Declaration declarations[] = {
rendernodeparser: Introduce clear_func We want to be able to clear the already parsed contents, because we need to do that when somebody parses the same property twice.
2019-05-12 22:47:50 +00:00
{ "transform", parse_transform, clear_transform, &transform },
{ "child", parse_node, clear_node, &child },
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
};
GskRenderNode *result;
parse_declarations (parser, declarations, G_N_ELEMENTS(declarations));
if (child == NULL)
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
child = create_default_render_node ();
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
/* This is very much cheating, isn't it? */
if (transform == NULL)
transform = gsk_transform_new ();
result = gsk_transform_node_new (child, transform);
gsk_render_node_unref (child);
gsk_transform_unref (transform);
return result;
}
static GskRenderNode *
parse_opacity_node (GtkCssParser *parser)
{
GskRenderNode *child = NULL;
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
double opacity = 0.5;
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
const Declaration declarations[] = {
rendernodeparser: Introduce clear_func We want to be able to clear the already parsed contents, because we need to do that when somebody parses the same property twice.
2019-05-12 22:47:50 +00:00
{ "opacity", parse_double, NULL, &opacity },
{ "child", parse_node, clear_node, &child },
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
};
GskRenderNode *result;
parse_declarations (parser, declarations, G_N_ELEMENTS(declarations));
if (child == NULL)
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
child = create_default_render_node ();
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
result = gsk_opacity_node_new (child, opacity);
gsk_render_node_unref (child);
return result;
}
static GskRenderNode *
parse_color_matrix_node (GtkCssParser *parser)
{
GskRenderNode *child = NULL;
graphene_matrix_t matrix;
GskTransform *transform = NULL;
graphene_rect_t offset_rect = GRAPHENE_RECT_INIT (0, 0, 0, 0);
graphene_vec4_t offset;
const Declaration declarations[] = {
rendernodeparser: Introduce clear_func We want to be able to clear the already parsed contents, because we need to do that when somebody parses the same property twice.
2019-05-12 22:47:50 +00:00
{ "matrix", parse_transform, clear_transform, &transform },
{ "offset", parse_rect, NULL, &offset_rect },
{ "child", parse_node, clear_node, &child }
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
};
GskRenderNode *result;
parse_declarations (parser, declarations, G_N_ELEMENTS(declarations));
if (child == NULL)
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
child = create_default_render_node ();
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
graphene_vec4_init (&offset,
offset_rect.origin.x, offset_rect.origin.y,
offset_rect.size.width, offset_rect.size.height);
gsk_transform_to_matrix (transform, &matrix);
result = gsk_color_matrix_node_new (child, &matrix, &offset);
gsk_transform_unref (transform);
gsk_render_node_unref (child);
return result;
}
static GskRenderNode *
parse_cross_fade_node (GtkCssParser *parser)
{
GskRenderNode *start = NULL;
GskRenderNode *end = NULL;
double progress = 0.5;
const Declaration declarations[] = {
rendernodeparser: Introduce clear_func We want to be able to clear the already parsed contents, because we need to do that when somebody parses the same property twice.
2019-05-12 22:47:50 +00:00
{ "progress", parse_double, NULL, &progress },
{ "start", parse_node, clear_node, &start },
{ "end", parse_node, clear_node, &end },
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
};
GskRenderNode *result;
parse_declarations (parser, declarations, G_N_ELEMENTS(declarations));
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
if (start == NULL)
start = gsk_color_node_new (&GDK_RGBA("AAFF00"), &GRAPHENE_RECT_INIT (0, 0, 50, 50));
if (end == NULL)
end = create_default_render_node ();
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
result = gsk_cross_fade_node_new (start, end, progress);
gsk_render_node_unref (start);
gsk_render_node_unref (end);
return result;
}
rendernode: Parse and print blend nodes properly
2019-04-27 07:03:51 +00:00
static GskRenderNode *
parse_blend_node (GtkCssParser *parser)
{
GskRenderNode *bottom = NULL;
GskRenderNode *top = NULL;
GskBlendMode mode = GSK_BLEND_MODE_DEFAULT;
const Declaration declarations[] = {
rendernodeparser: Introduce clear_func We want to be able to clear the already parsed contents, because we need to do that when somebody parses the same property twice.
2019-05-12 22:47:50 +00:00
{ "mode", parse_blend_mode, NULL, &mode },
{ "bottom", parse_node, clear_node, &bottom },
{ "top", parse_node, clear_node, &top },
rendernode: Parse and print blend nodes properly
2019-04-27 07:03:51 +00:00
};
GskRenderNode *result;
parse_declarations (parser, declarations, G_N_ELEMENTS(declarations));
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
if (bottom == NULL)
bottom = gsk_color_node_new (&GDK_RGBA("AAFF00"), &GRAPHENE_RECT_INIT (0, 0, 50, 50));
if (top == NULL)
top = create_default_render_node ();
rendernode: Parse and print blend nodes properly
2019-04-27 07:03:51 +00:00
result = gsk_blend_node_new (bottom, top, mode);
gsk_render_node_unref (bottom);
gsk_render_node_unref (top);
return result;
}
rendernode: Parse repeat nodes
2019-05-08 15:28:50 +00:00
static GskRenderNode *
parse_repeat_node (GtkCssParser *parser)
{
GskRenderNode *child = NULL;
graphene_rect_t bounds = GRAPHENE_RECT_INIT (0, 0, 0, 0);
graphene_rect_t child_bounds = GRAPHENE_RECT_INIT (0, 0, 0, 0);
const Declaration declarations[] = {
rendernodeparser: Introduce clear_func We want to be able to clear the already parsed contents, because we need to do that when somebody parses the same property twice.
2019-05-12 22:47:50 +00:00
{ "child", parse_node, clear_node, &child },
{ "bounds", parse_rect, NULL, &bounds },
{ "child-bounds", parse_rect, NULL, &child_bounds },
rendernode: Parse repeat nodes
2019-05-08 15:28:50 +00:00
};
GskRenderNode *result;
guint parse_result;
parse_result = parse_declarations (parser, declarations, G_N_ELEMENTS(declarations));
if (child == NULL)
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
child = create_default_render_node ();
rendernode: Parse repeat nodes
2019-05-08 15:28:50 +00:00
if (!(parse_result & (1 << 1)))
gsk_render_node_get_bounds (child, &bounds);
if (!(parse_result & (1 << 2)))
gsk_render_node_get_bounds (child, &child_bounds);
result = gsk_repeat_node_new (&bounds, child, &child_bounds);
gsk_render_node_unref (child);
return result;
}
rendernodeparser: Allow parsing strings Instead of only allowing for glyph indexes, allow ASCII characters as replacements. So this glyph sequence glyphs: 65 8, 66 8, 67 8 Can be replaced by glyphs: "ABC" provided that the glyph for "A", "B" and "C" are 65, 66 and 67 respectively and their advance is exactly 8. x offset and y offset must always be 0 and every glyph must start a cluster.
2019-05-19 18:20:09 +00:00
static gboolean
unpack_glyphs (PangoFont *font,
PangoGlyphString *glyphs)
{
PangoGlyphString *ascii = NULL;
guint i;
for (i = 0; i < glyphs->num_glyphs; i++)
{
PangoGlyph glyph = glyphs->glyphs[i].glyph;
if (glyph < PANGO_GLYPH_INVALID_INPUT - MAX_ASCII_GLYPH ||
glyph >= PANGO_GLYPH_INVALID_INPUT)
continue;
glyph = glyph - (PANGO_GLYPH_INVALID_INPUT - MAX_ASCII_GLYPH) - MIN_ASCII_GLYPH;
if (ascii == NULL)
{
ascii = create_ascii_glyphs (font);
if (ascii == NULL)
return FALSE;
}
glyphs->glyphs[i].glyph = ascii->glyphs[glyph].glyph;
glyphs->glyphs[i].geometry.width = ascii->glyphs[glyph].geometry.width;
}
g_clear_pointer (&ascii, pango_glyph_string_free);
return TRUE;
}
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
static GskRenderNode *
parse_text_node (GtkCssParser *parser)
{
PangoFont *font = NULL;
rendernode: Take a graphene_point_t for the offset ... instead of 2 floats.
2019-05-19 02:08:29 +00:00
graphene_point_t offset = GRAPHENE_POINT_INIT (0, 0);
rgba: Add GDK_RGBA() macro So far it's private, but it's a pretty cute way to use hex colors, so we might conside making it public.
2019-05-14 20:23:15 +00:00
GdkRGBA color = GDK_RGBA("000000");
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
PangoGlyphString *glyphs = NULL;
const Declaration declarations[] = {
rendernodeparser: Introduce clear_func We want to be able to clear the already parsed contents, because we need to do that when somebody parses the same property twice.
2019-05-12 22:47:50 +00:00
{ "font", parse_font, clear_font, &font },
rendernode: Take a graphene_point_t for the offset ... instead of 2 floats.
2019-05-19 02:08:29 +00:00
{ "offset", parse_point, NULL, &offset },
rendernodeparser: Introduce clear_func We want to be able to clear the already parsed contents, because we need to do that when somebody parses the same property twice.
2019-05-12 22:47:50 +00:00
{ "color", parse_color, NULL, &color },
{ "glyphs", parse_glyphs, clear_glyphs, &glyphs }
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
};
GskRenderNode *result;
parse_declarations (parser, declarations, G_N_ELEMENTS(declarations));
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
if (font == NULL)
{
font = font_from_string ("Cantarell 11");
g_assert (font);
}
if (!glyphs)
rendernodeparser: Allow parsing strings Instead of only allowing for glyph indexes, allow ASCII characters as replacements. So this glyph sequence glyphs: 65 8, 66 8, 67 8 Can be replaced by glyphs: "ABC" provided that the glyph for "A", "B" and "C" are 65, 66 and 67 respectively and their advance is exactly 8. x offset and y offset must always be 0 and every glyph must start a cluster.
2019-05-19 18:20:09 +00:00
{
const char *text = "Hello";
PangoGlyphInfo gi = { 0, { 0, 0, 0}, { 1 } };
guint i;
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
rendernodeparser: Allow parsing strings Instead of only allowing for glyph indexes, allow ASCII characters as replacements. So this glyph sequence glyphs: 65 8, 66 8, 67 8 Can be replaced by glyphs: "ABC" provided that the glyph for "A", "B" and "C" are 65, 66 and 67 respectively and their advance is exactly 8. x offset and y offset must always be 0 and every glyph must start a cluster.
2019-05-19 18:20:09 +00:00
glyphs = pango_glyph_string_new ();
pango_glyph_string_set_size (glyphs, strlen (text));
for (i = 0; i < strlen (text); i++)
{
gi.glyph = PANGO_GLYPH_INVALID_INPUT - MAX_ASCII_GLYPH + text[i];
glyphs->glyphs[i] = gi;
}
}
if (!unpack_glyphs (font, glyphs))
{
gtk_css_parser_error_value (parser, "Given font cannot decode the glyph text");
result = NULL;
}
else
{
result = gsk_text_node_new (font, glyphs, &color, &offset);
if (result == NULL)
{
gtk_css_parser_error_value (parser, "Glyphs result in empty text");
}
}
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
g_object_unref (font);
pango_glyph_string_free (glyphs);
rendernodeparser: Allow parsing strings Instead of only allowing for glyph indexes, allow ASCII characters as replacements. So this glyph sequence glyphs: 65 8, 66 8, 67 8 Can be replaced by glyphs: "ABC" provided that the glyph for "A", "B" and "C" are 65, 66 and 67 respectively and their advance is exactly 8. x offset and y offset must always be 0 and every glyph must start a cluster.
2019-05-19 18:20:09 +00:00
/* return anything, whatever, just not NULL */
if (result == NULL)
result = create_default_render_node ();
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
return result;
}
static GskRenderNode *
parse_blur_node (GtkCssParser *parser)
{
GskRenderNode *child = NULL;
rendernodeparser: Allow single values instead of 4 This allows writing: colors: red; instead of colors: red red red red; to draw a red border.
2019-05-13 22:41:49 +00:00
double blur_radius = 1.0;
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
const Declaration declarations[] = {
rendernodeparser: Introduce clear_func We want to be able to clear the already parsed contents, because we need to do that when somebody parses the same property twice.
2019-05-12 22:47:50 +00:00
{ "blur", parse_double, NULL, &blur_radius },
{ "child", parse_node, clear_node, &child },
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
};
GskRenderNode *result;
parse_declarations (parser, declarations, G_N_ELEMENTS(declarations));
if (child == NULL)
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
child = create_default_render_node ();
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
result = gsk_blur_node_new (child, blur_radius);
gsk_render_node_unref (child);
return result;
}
static GskRenderNode *
parse_clip_node (GtkCssParser *parser)
{
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
GskRoundedRect clip = GSK_ROUNDED_RECT_INIT (0, 0, 50, 50);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
GskRenderNode *child = NULL;
const Declaration declarations[] = {
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
{ "clip", parse_rounded_rect, NULL, &clip },
rendernodeparser: Introduce clear_func We want to be able to clear the already parsed contents, because we need to do that when somebody parses the same property twice.
2019-05-12 22:47:50 +00:00
{ "child", parse_node, clear_node, &child },
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
};
GskRenderNode *result;
parse_declarations (parser, declarations, G_N_ELEMENTS(declarations));
if (child == NULL)
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
child = create_default_render_node ();
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
if (gsk_rounded_rect_is_rectilinear (&clip))
result = gsk_clip_node_new (child, &clip.bounds);
else
result = gsk_rounded_clip_node_new (child, &clip);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
gsk_render_node_unref (child);
return result;
}
static GskRenderNode *
parse_rounded_clip_node (GtkCssParser *parser)
{
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
GskRoundedRect clip = GSK_ROUNDED_RECT_INIT (0, 0, 50, 50);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
GskRenderNode *child = NULL;
const Declaration declarations[] = {
rendernodeparser: Introduce clear_func We want to be able to clear the already parsed contents, because we need to do that when somebody parses the same property twice.
2019-05-12 22:47:50 +00:00
{ "clip", parse_rounded_rect, NULL, &clip },
{ "child", parse_node, clear_node, &child },
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
};
GskRenderNode *result;
parse_declarations (parser, declarations, G_N_ELEMENTS(declarations));
if (child == NULL)
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
child = create_default_render_node ();
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
result = gsk_rounded_clip_node_new (child, &clip);
gsk_render_node_unref (child);
return result;
}
static GskRenderNode *
parse_shadow_node (GtkCssParser *parser)
{
GskRenderNode *child = NULL;
GArray *shadows = g_array_new (FALSE, TRUE, sizeof (GskShadow));
const Declaration declarations[] = {
rendernodeparser: Introduce clear_func We want to be able to clear the already parsed contents, because we need to do that when somebody parses the same property twice.
2019-05-12 22:47:50 +00:00
{ "child", parse_node, clear_node, &child },
{ "shadows", parse_shadows, clear_shadows, shadows }
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
};
GskRenderNode *result;
parse_declarations (parser, declarations, G_N_ELEMENTS(declarations));
if (child == NULL)
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
child = create_default_render_node ();
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
if (shadows->len == 0)
{
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
GskShadow default_shadow = { GDK_RGBA("000000"), 1, 1, 0 };
g_array_append_val (shadows, default_shadow);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
}
result = gsk_shadow_node_new (child, (GskShadow *)shadows->data, shadows->len);
g_array_free (shadows, TRUE);
gsk_render_node_unref (child);
return result;
}
static GskRenderNode *
parse_debug_node (GtkCssParser *parser)
{
char *message = NULL;
GskRenderNode *child = NULL;
const Declaration declarations[] = {
rendernodeparser: Introduce clear_func We want to be able to clear the already parsed contents, because we need to do that when somebody parses the same property twice.
2019-05-12 22:47:50 +00:00
{ "message", parse_string, clear_string, &message},
{ "child", parse_node, clear_node, &child },
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
};
GskRenderNode *result;
parse_declarations (parser, declarations, G_N_ELEMENTS(declarations));
if (child == NULL)
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
child = create_default_render_node ();
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
result = gsk_debug_node_new (child, message);
gsk_render_node_unref (child);
return result;
}
static gboolean
parse_node (GtkCssParser *parser,
gpointer out_node)
{
static struct {
const char *name;
GskRenderNode * (* func) (GtkCssParser *);
} node_parsers[] = {
rendernodeparser: Handle repeating linear gradients Just handle them like regular gradients, only name them differently.
2019-05-29 03:55:28 +00:00
{ "blend", parse_blend_node },
{ "blur", parse_blur_node },
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
{ "border", parse_border_node },
rendernodeparser: Handle repeating linear gradients Just handle them like regular gradients, only name them differently.
2019-05-29 03:55:28 +00:00
{ "cairo", parse_cairo_node },
{ "clip", parse_clip_node },
{ "color", parse_color_node },
{ "color-matrix", parse_color_matrix_node },
{ "container", parse_container_node },
{ "cross-fade", parse_cross_fade_node },
{ "debug", parse_debug_node },
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
{ "inset-shadow", parse_inset_shadow_node },
rendernodeparser: Handle repeating linear gradients Just handle them like regular gradients, only name them differently.
2019-05-29 03:55:28 +00:00
{ "linear-gradient", parse_linear_gradient_node },
gsk: Parse radial gradient nodes
2020-09-15 04:20:56 +00:00
{ "radial-gradient", parse_radial_gradient_node },
gsk: Add GskConicGradientNode
2020-12-02 23:47:54 +00:00
{ "conic-gradient", parse_conic_gradient_node },
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
{ "opacity", parse_opacity_node },
rendernodeparser: Handle repeating linear gradients Just handle them like regular gradients, only name them differently.
2019-05-29 03:55:28 +00:00
{ "outset-shadow", parse_outset_shadow_node },
{ "repeat", parse_repeat_node },
{ "repeating-linear-gradient", parse_repeating_linear_gradient_node },
gsk: Parse radial gradient nodes
2020-09-15 04:20:56 +00:00
{ "repeating-radial-gradient", parse_repeating_radial_gradient_node },
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
{ "rounded-clip", parse_rounded_clip_node },
{ "shadow", parse_shadow_node },
{ "text", parse_text_node },
rendernodeparser: Handle repeating linear gradients Just handle them like regular gradients, only name them differently.
2019-05-29 03:55:28 +00:00
{ "texture", parse_texture_node },
{ "transform", parse_transform_node },
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
{ "glshader", parse_glshader_node },
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
};
GskRenderNode **node_p = out_node;
guint i;
for (i = 0; i < G_N_ELEMENTS (node_parsers); i++)
{
rendernodeparser: Use parser blocks Instead of trying to do error handling manually, use the semicolon blocks feature provided by GtkCssParser.
2019-05-12 11:14:50 +00:00
if (gtk_css_parser_try_ident (parser, node_parsers[i].name))
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
{
GskRenderNode *node;
rendernodeparser: Use parser blocks Instead of trying to do error handling manually, use the semicolon blocks feature provided by GtkCssParser.
2019-05-12 11:14:50 +00:00
if (!gtk_css_parser_has_token (parser, GTK_CSS_TOKEN_EOF))
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
{
gtk_css_parser_error_syntax (parser, "Expected '{' after node name");
return FALSE;
}
rendernodeparser: Use parser blocks Instead of trying to do error handling manually, use the semicolon blocks feature provided by GtkCssParser.
2019-05-12 11:14:50 +00:00
gtk_css_parser_end_block_prelude (parser);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
node = node_parsers[i].func (parser);
if (node)
{
rendernodeparser: Use parser blocks Instead of trying to do error handling manually, use the semicolon blocks feature provided by GtkCssParser.
2019-05-12 11:14:50 +00:00
if (!gtk_css_parser_has_token (parser, GTK_CSS_TOKEN_EOF))
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
gtk_css_parser_error_syntax (parser, "Expected '}' at end of node definition");
g_clear_pointer (node_p, gsk_render_node_unref);
*node_p = node;
}
return node != NULL;
}
}
rendernodeparser: Use parser blocks Instead of trying to do error handling manually, use the semicolon blocks feature provided by GtkCssParser.
2019-05-12 11:14:50 +00:00
if (gtk_css_parser_has_token (parser, GTK_CSS_TOKEN_IDENT))
gtk_css_parser_error_value (parser, "\"%s\" is not a valid node name",
gtk_css_parser_get_token (parser)->string.string);
else
gtk_css_parser_error_syntax (parser, "Expected a node name");
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
return FALSE;
}
static void
gsk_render_node_parser_error (GtkCssParser *parser,
const GtkCssLocation *start,
const GtkCssLocation *end,
const GError *error,
gpointer user_data)
{
Add error func to node deserialization
2019-04-24 16:30:46 +00:00
struct {
GskParseErrorFunc error_func;
gpointer user_data;
} *error_func_pair = user_data;
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
Add error func to node deserialization
2019-04-24 16:30:46 +00:00
if (error_func_pair->error_func)
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
error_func_pair->error_func ((const GskParseLocation *)start,
(const GskParseLocation *)end,
error,
error_func_pair->user_data);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
}
GskRenderNode *
Add error func to node deserialization
2019-04-24 16:30:46 +00:00
gsk_render_node_deserialize_from_bytes (GBytes *bytes,
GskParseErrorFunc error_func,
gpointer user_data)
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
{
GskRenderNode *root = NULL;
GtkCssParser *parser;
Add error func to node deserialization
2019-04-24 16:30:46 +00:00
struct {
GskParseErrorFunc error_func;
gpointer user_data;
} error_func_pair = { error_func, user_data };
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
parser = gtk_css_parser_new_for_bytes (bytes, NULL, NULL, gsk_render_node_parser_error,
Add error func to node deserialization
2019-04-24 16:30:46 +00:00
&error_func_pair, NULL);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
root = parse_container_node (parser);
if (root && gsk_container_node_get_n_children (root) == 1)
{
GskRenderNode *child = gsk_container_node_get_child (root, 0);
gsk_render_node_ref (child);
gsk_render_node_unref (root);
root = child;
}
gtk_css_parser_unref (parser);
return root;
}
typedef struct
{
int indentation_level;
GString *str;
} Printer;
static void
printer_init (Printer *self)
{
self->indentation_level = 0;
self->str = g_string_new (NULL);
}
#define IDENT_LEVEL 2 /* Spaces per level */
static void
_indent (Printer *self)
{
if (self->indentation_level > 0)
g_string_append_printf (self->str, "%*s", self->indentation_level * IDENT_LEVEL, " ");
}
#undef IDENT_LEVEL
static void
start_node (Printer *self,
const char *node_name)
{
g_string_append_printf (self->str, "%s {\n", node_name);
self->indentation_level ++;
}
static void
end_node (Printer *self)
{
self->indentation_level --;
_indent (self);
g_string_append (self->str, "}\n");
}
static void
string_append_double (GString *string,
double d)
{
char buf[G_ASCII_DTOSTR_BUF_SIZE];
css: Use %f, not %.17f The testusite failures explain why: We don't want to print "1.00000000000000000", but "1".
2019-05-29 12:29:25 +00:00
g_ascii_formatd (buf, G_ASCII_DTOSTR_BUF_SIZE, "%g", d);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
g_string_append (string, buf);
}
static void
append_rect (GString *str,
const graphene_rect_t *r)
{
string_append_double (str, r->origin.x);
g_string_append_c (str, ' ');
string_append_double (str, r->origin.y);
g_string_append_c (str, ' ');
string_append_double (str, r->size.width);
g_string_append_c (str, ' ');
string_append_double (str, r->size.height);
}
static void
append_rounded_rect (GString *str,
const GskRoundedRect *r)
{
append_rect (str, &r->bounds);
if (!gsk_rounded_rect_is_rectilinear (r))
{
gboolean all_the_same = TRUE;
gboolean all_square = TRUE;
float w = r->corner[0].width;
float h = r->corner[0].height;
int i;
for (i = 1; i < 4; i ++)
{
if (r->corner[i].width != w ||
r->corner[i].height != h)
all_the_same = FALSE;
if (r->corner[i].width != r->corner[i].height)
all_square = FALSE;
}
g_string_append (str, " / ");
if (all_the_same)
{
string_append_double (str, w);
}
else if (all_square)
{
string_append_double (str, r->corner[0].width);
g_string_append_c (str, ' ');
string_append_double (str, r->corner[1].width);
g_string_append_c (str, ' ');
string_append_double (str, r->corner[2].width);
g_string_append_c (str, ' ');
string_append_double (str, r->corner[3].width);
}
else
{
for (i = 0; i < 4; i ++)
{
string_append_double (str, r->corner[i].width);
g_string_append_c (str, ' ');
}
g_string_append (str, "/ ");
for (i = 0; i < 3; i ++)
{
string_append_double (str, r->corner[i].height);
g_string_append_c (str, ' ');
}
string_append_double (str, r->corner[3].height);
}
}
}
static void
append_rgba (GString *str,
const GdkRGBA *rgba)
{
char *rgba_str = gdk_rgba_to_string (rgba);
g_string_append (str, rgba_str);
g_free (rgba_str);
}
static void
append_point (GString *str,
const graphene_point_t *p)
{
string_append_double (str, p->x);
g_string_append_c (str, ' ');
string_append_double (str, p->y);
}
static void
append_vec4 (GString *str,
const graphene_vec4_t *v)
{
string_append_double (str, graphene_vec4_get_x (v));
g_string_append_c (str, ' ');
string_append_double (str, graphene_vec4_get_y (v));
g_string_append_c (str, ' ');
string_append_double (str, graphene_vec4_get_z (v));
g_string_append_c (str, ' ');
string_append_double (str, graphene_vec4_get_w (v));
}
static void
append_float_param (Printer *p,
const char *param_name,
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
float value,
float default_value)
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
{
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
/* Don't approximate-compare here, better be topo verbose */
if (value == default_value)
return;
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
_indent (p);
g_string_append_printf (p->str, "%s: ", param_name);
string_append_double (p->str, value);
g_string_append (p->str, ";\n");
}
static void
append_rgba_param (Printer *p,
const char *param_name,
const GdkRGBA *value)
{
_indent (p);
g_string_append_printf (p->str, "%s: ", param_name);
append_rgba (p->str, value);
g_string_append_c (p->str, ';');
g_string_append_c (p->str, '\n');
}
static void
append_rect_param (Printer *p,
const char *param_name,
const graphene_rect_t *value)
{
_indent (p);
g_string_append_printf (p->str, "%s: ", param_name);
append_rect (p->str, value);
g_string_append_c (p->str, ';');
g_string_append_c (p->str, '\n');
}
static void
append_rounded_rect_param (Printer *p,
const char *param_name,
const GskRoundedRect *value)
{
_indent (p);
g_string_append_printf (p->str, "%s: ", param_name);
append_rounded_rect (p->str, value);
g_string_append_c (p->str, ';');
g_string_append_c (p->str, '\n');
}
static void
append_point_param (Printer *p,
const char *param_name,
const graphene_point_t *value)
{
_indent (p);
g_string_append_printf (p->str, "%s: ", param_name);
append_point (p->str, value);
g_string_append_c (p->str, ';');
g_string_append_c (p->str, '\n');
}
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
static void
append_string_param (Printer *p,
const char *param_name,
const char *value)
{
_indent (p);
g_string_append_printf (p->str, "%s: ", param_name);
Allow inserting newlines in css strings Rename _gtk_css_print_string to strip the _ and add an insert_newlines argument to it. Update all callers, and make the render node serializer insert newlines.
2020-10-03 02:31:29 +00:00
gtk_css_print_string (p->str, value, TRUE);
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
g_string_append_c (p->str, ';');
g_string_append_c (p->str, '\n');
}
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
static void
append_vec4_param (Printer *p,
const char *param_name,
const graphene_vec4_t *value)
{
_indent (p);
g_string_append_printf (p->str, "%s: ", param_name);
append_vec4 (p->str, value);
g_string_append_c (p->str, ';');
g_string_append_c (p->str, '\n');
}
static void
append_matrix_param (Printer *p,
const char *param_name,
const graphene_matrix_t *value)
{
GskTransform *transform = NULL;
_indent (p);
g_string_append_printf (p->str, "%s: ", param_name);
transform = gsk_transform_matrix (transform, value);
gsk_transform_print (transform,p->str);
g_string_append_c (p->str, ';');
g_string_append_c (p->str, '\n');
gsk_transform_unref (transform);
}
static void
append_transform_param (Printer *p,
const char *param_name,
GskTransform *transform)
{
_indent (p);
g_string_append_printf (p->str, "%s: ", param_name);
gsk_transform_print (transform, p->str);
g_string_append_c (p->str, ';');
g_string_append_c (p->str, '\n');
}
static void render_node_print (Printer *p,
GskRenderNode *node);
static void
append_node_param (Printer *p,
const char *param_name,
GskRenderNode *node)
{
_indent (p);
g_string_append_printf (p->str, "%s: ", param_name);
render_node_print (p, node);
}
rendernodeparser: Split out a function
2020-12-02 20:48:35 +00:00
static void
append_stops_param (Printer *p,
const char *param_name,
const GskColorStop *stops,
gsize n_stops)
{
gsize i;
_indent (p);
g_string_append (p->str, param_name);
g_string_append (p->str, ": ");
for (i = 0; i < n_stops; i ++)
{
if (i > 0)
g_string_append (p->str, ", ");
string_append_double (p->str, stops[i].offset);
g_string_append_c (p->str, ' ');
append_rgba (p->str, &stops[i].color);
}
g_string_append (p->str, ";\n");
}
rendernodeparser: Parse images differently Instead of encoding the raw data, encode the full image to a PNG. And instead of stuffing that encoding into a string, use a full data: url. And then remove the width and height properties, because they're now implicitly included in the data. And then change the parser to match. And because the parser now parses regular urls on top of data: urls, we can now load any random file.
2019-05-09 01:56:25 +00:00
static cairo_status_t
rendernodeparser: Parse Cairo nodes We also print the script, but we don't parse it yet.
2019-05-25 22:50:13 +00:00
cairo_write_array (void *closure,
const unsigned char *data,
unsigned int length)
rendernodeparser: Parse images differently Instead of encoding the raw data, encode the full image to a PNG. And instead of stuffing that encoding into a string, use a full data: url. And then remove the width and height properties, because they're now implicitly included in the data. And then change the parser to match. And because the parser now parses regular urls on top of data: urls, we can now load any random file.
2019-05-09 01:56:25 +00:00
{
g_byte_array_append (closure, data, length);
return CAIRO_STATUS_SUCCESS;
}
rendernodeparser: Handle Cairo being stupid Cairo writes to finished streams, so we have to make sure to keep the stream around to allow it to do that.
2019-06-03 15:20:59 +00:00
static void
cairo_destroy_array (gpointer array)
{
g_byte_array_free (array, TRUE);
}
gsk: Avoid long lines in serialized nodes When encoding big blobs of data in base64, insert newlines. Base64 allows it, CSS allows it, so not need to make GtkTextView struggle with multi-megabyte lines. Update nodeparser tests to reflect this change.
2020-10-03 13:45:28 +00:00
static void
append_escaping_newlines (GString *str,
const char *string)
{
gsize len;
do {
len = strcspn (string, "\n");
g_string_append_len (str, string, len);
string += len;
g_string_append (str, "\\\n");
string++;
} while (*string);
}
/* like g_base64 encode, but breaks lines
* in CSS-compatible way
*/
static char *
base64_encode_with_linebreaks (const guchar *data,
gsize len)
{
gsize max;
char *out;
int state = 0, outlen;
int save = 0;
g_return_val_if_fail (data != NULL || len == 0, NULL);
/* We can use a smaller limit here, since we know the saved state is 0,
+1 is needed for trailing \0, also check for unlikely integer overflow */
g_return_val_if_fail (len < ((G_MAXSIZE - 1) / 4 - 1) * 3, NULL);
max = (len / 3 + 1) * 4 + 1;
max += 2 * (max / 76);
out = g_malloc (max);
outlen = g_base64_encode_step (data, len, TRUE, out, &state, &save);
outlen += g_base64_encode_close (TRUE, out + outlen, &state, &save);
out[outlen] = '\0';
return out;
}
gsk: Export the glyph serialization privately We want to use the same serialization in the inspector, so export this function.
2020-12-21 18:11:08 +00:00
void
gsk_text_node_serialize_glyphs (GskRenderNode *node,
GString *p)
{
const guint n_glyphs = gsk_text_node_get_num_glyphs (node);
const PangoGlyphInfo *glyphs = gsk_text_node_get_glyphs (node, NULL);
PangoFont *font = gsk_text_node_get_font (node);
GString *str;
guint i, j;
PangoGlyphString *ascii;
ascii = create_ascii_glyphs (font);
str = g_string_new ("");
for (i = 0; i < n_glyphs; i++)
{
if (ascii)
{
for (j = 0; j < ascii->num_glyphs; j++)
{
if (glyphs[i].glyph == ascii->glyphs[j].glyph &&
glyphs[i].geometry.width == ascii->glyphs[j].geometry.width &&
glyphs[i].geometry.x_offset == 0 &&
glyphs[i].geometry.y_offset == 0 &&
glyphs[i].attr.is_cluster_start)
{
g_string_append_c (str, j + MIN_ASCII_GLYPH);
break;
}
else if (glyphs[i].glyph == ascii->glyphs[j].glyph)
{
if (glyphs[i].geometry.width != ascii->glyphs[j].geometry.width)
g_print ("not ascii because of width (%d != %d)\n",
glyphs[i].geometry.width,
ascii->glyphs[j].geometry.width);
if (glyphs[i].geometry.x_offset != 0 ||
glyphs[i].geometry.y_offset != 0)
g_print ("not ascii because of offset\n");
if (!glyphs[i].attr.is_cluster_start)
g_print ("not ascii because of cluster\n");
}
}
if (j != ascii->num_glyphs)
continue;
}
if (str->len)
{
g_string_append_printf (p, "\"%s\", ", str->str);
g_string_set_size (str, 0);
}
g_string_append_printf (p, "%u %g",
glyphs[i].glyph,
(double) glyphs[i].geometry.width / PANGO_SCALE);
if (!glyphs[i].attr.is_cluster_start ||
glyphs[i].geometry.x_offset != 0 ||
glyphs[i].geometry.y_offset != 0)
{
g_string_append_printf (p, " %g %g",
(double) glyphs[i].geometry.x_offset / PANGO_SCALE,
(double) glyphs[i].geometry.y_offset / PANGO_SCALE);
if (!glyphs[i].attr.is_cluster_start)
g_string_append (p, " same-cluster");
}
if (i + 1 < n_glyphs)
g_string_append (p, ", ");
}
if (str->len)
g_string_append_printf (p, "\"%s\"", str->str);
g_string_free (str, TRUE);
if (ascii)
pango_glyph_string_free (ascii);
}
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
static void
render_node_print (Printer *p,
GskRenderNode *node)
{
gsk: Avoid long lines in serialized nodes When encoding big blobs of data in base64, insert newlines. Base64 allows it, CSS allows it, so not need to make GtkTextView struggle with multi-megabyte lines. Update nodeparser tests to reflect this change.
2020-10-03 13:45:28 +00:00
char *b64;
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
switch (gsk_render_node_get_node_type (node))
{
case GSK_CONTAINER_NODE:
{
guint i;
start_node (p, "container");
for (i = 0; i < gsk_container_node_get_n_children (node); i ++)
{
GskRenderNode *child = gsk_container_node_get_child (node, i);
/* Only in container nodes do we want nodes to be indented. */
_indent (p);
render_node_print (p, child);
}
end_node (p);
}
break;
case GSK_COLOR_NODE:
{
start_node (p, "color");
append_rect_param (p, "bounds", &node->bounds);
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
append_rgba_param (p, "color", gsk_color_node_get_color (node));
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
end_node (p);
}
break;
case GSK_CROSS_FADE_NODE:
{
start_node (p, "cross-fade");
rendernodeparser: Print properties alphabetically Because now we have a rule. Also update some tests to the new order.
2019-05-14 01:11:33 +00:00
append_node_param (p, "end", gsk_cross_fade_node_get_end_child (node));
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
append_float_param (p, "progress", gsk_cross_fade_node_get_progress (node), 0.5f);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
append_node_param (p, "start", gsk_cross_fade_node_get_start_child (node));
end_node (p);
}
break;
rendernodeparser: Handle repeating linear gradients Just handle them like regular gradients, only name them differently.
2019-05-29 03:55:28 +00:00
case GSK_REPEATING_LINEAR_GRADIENT_NODE:
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
case GSK_LINEAR_GRADIENT_NODE:
{
rendernodeparser: Handle repeating linear gradients Just handle them like regular gradients, only name them differently.
2019-05-29 03:55:28 +00:00
if (gsk_render_node_get_node_type (node) == GSK_REPEATING_LINEAR_GRADIENT_NODE)
start_node (p, "repeating-linear-gradient");
else
start_node (p, "linear-gradient");
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
append_rect_param (p, "bounds", &node->bounds);
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
append_point_param (p, "end", gsk_linear_gradient_node_get_end (node));
append_point_param (p, "start", gsk_linear_gradient_node_get_start (node));
rendernodeparser: Split out a function
2020-12-02 20:48:35 +00:00
append_stops_param (p, "stops", gsk_linear_gradient_node_get_color_stops (node, NULL),
gsk_linear_gradient_node_get_n_color_stops (node));
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
end_node (p);
}
break;
gsk: Add a radial gradient node Only a fallback implementation for now. Fixes #2262
2020-09-12 02:55:37 +00:00
case GSK_REPEATING_RADIAL_GRADIENT_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");
else
start_node (p, "radial-gradient");
append_rect_param (p, "bounds", &node->bounds);
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
append_point_param (p, "center", gsk_radial_gradient_node_get_center (node));
rendernode: switch to h/vradius
2020-09-12 13:16:17 +00:00
append_float_param (p, "hradius", gsk_radial_gradient_node_get_hradius (node), 0.0f);
append_float_param (p, "vradius", gsk_radial_gradient_node_get_vradius (node), 0.0f);
gsk: Add a radial gradient node Only a fallback implementation for now. Fixes #2262
2020-09-12 02:55:37 +00:00
append_float_param (p, "start", gsk_radial_gradient_node_get_start (node), 0.0f);
append_float_param (p, "end", gsk_radial_gradient_node_get_end (node), 1.0f);
rendernodeparser: Split out a function
2020-12-02 20:48:35 +00:00
append_stops_param (p, "stops", gsk_radial_gradient_node_get_color_stops (node, NULL),
gsk_radial_gradient_node_get_n_color_stops (node));
gsk: Add GskConicGradientNode
2020-12-02 23:47:54 +00:00
end_node (p);
}
break;
case GSK_CONIC_GRADIENT_NODE:
{
start_node (p, "conic-gradient");
append_rect_param (p, "bounds", &node->bounds);
append_point_param (p, "center", gsk_conic_gradient_node_get_center (node));
append_float_param (p, "rotation", gsk_conic_gradient_node_get_rotation (node), 0.0f);
append_stops_param (p, "stops", gsk_conic_gradient_node_get_color_stops (node, NULL),
gsk_conic_gradient_node_get_n_color_stops (node));
gsk: Add a radial gradient node Only a fallback implementation for now. Fixes #2262
2020-09-12 02:55:37 +00:00
end_node (p);
}
break;
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
case GSK_OPACITY_NODE:
{
start_node (p, "opacity");
append_node_param (p, "child", gsk_opacity_node_get_child (node));
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
append_float_param (p, "opacity", gsk_opacity_node_get_opacity (node), 0.5f);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
end_node (p);
}
break;
case GSK_OUTSET_SHADOW_NODE:
{
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
const GdkRGBA *color = gsk_outset_shadow_node_get_color (node);
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
start_node (p, "outset-shadow");
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
append_float_param (p, "blur", gsk_outset_shadow_node_get_blur_radius (node), 0.0f);
if (!gdk_rgba_equal (color, &GDK_RGBA("000")))
append_rgba_param (p, "color", color);
append_float_param (p, "dx", gsk_outset_shadow_node_get_dx (node), 1.0f);
append_float_param (p, "dy", gsk_outset_shadow_node_get_dy (node), 1.0f);
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
append_rounded_rect_param (p, "outline", gsk_outset_shadow_node_get_outline (node));
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
append_float_param (p, "spread", gsk_outset_shadow_node_get_spread (node), 0.0f);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
end_node (p);
}
break;
case GSK_CLIP_NODE:
{
start_node (p, "clip");
append_node_param (p, "child", gsk_clip_node_get_child (node));
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
append_rect_param (p, "clip", gsk_clip_node_get_clip (node));
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
end_node (p);
}
break;
case GSK_ROUNDED_CLIP_NODE:
{
start_node (p, "rounded-clip");
append_node_param (p, "child", gsk_rounded_clip_node_get_child (node));
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
append_rounded_rect_param (p, "clip", gsk_rounded_clip_node_get_clip (node));
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
end_node (p);
}
break;
case GSK_TRANSFORM_NODE:
{
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
GskTransform *transform = gsk_transform_node_get_transform (node);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
start_node (p, "transform");
append_node_param (p, "child", gsk_transform_node_get_child (node));
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
if (gsk_transform_get_category (transform) != GSK_TRANSFORM_CATEGORY_IDENTITY)
append_transform_param (p, "transform", transform);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
end_node (p);
}
break;
case GSK_COLOR_MATRIX_NODE:
{
start_node (p, "color-matrix");
rendernodeparser: Print properties alphabetically Because now we have a rule. Also update some tests to the new order.
2019-05-14 01:11:33 +00:00
append_node_param (p, "child", gsk_color_matrix_node_get_child (node));
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
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));
if (!graphene_vec4_equal (gsk_color_matrix_node_get_color_offset (node), graphene_vec4_zero ()))
append_vec4_param (p, "offset", gsk_color_matrix_node_get_color_offset (node));
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
end_node (p);
}
break;
case GSK_BORDER_NODE:
{
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
const GdkRGBA *colors = gsk_border_node_get_colors (node);
const float *widths = gsk_border_node_get_widths (node);
rendernodeparser: Allow single values instead of 4 This allows writing: colors: red; instead of colors: red red red red; to draw a red border.
2019-05-13 22:41:49 +00:00
guint i, n;
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
start_node (p, "border");
rendernodeparser: Allow single values instead of 4 This allows writing: colors: red; instead of colors: red red red red; to draw a red border.
2019-05-13 22:41:49 +00:00
if (!gdk_rgba_equal (&colors[3], &colors[1]))
n = 4;
else if (!gdk_rgba_equal (&colors[2], &colors[0]))
n = 3;
else if (!gdk_rgba_equal (&colors[1], &colors[0]))
n = 2;
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
else if (!gdk_rgba_equal (&colors[0], &GDK_RGBA("000000")))
rendernodeparser: Allow single values instead of 4 This allows writing: colors: red; instead of colors: red red red red; to draw a red border.
2019-05-13 22:41:49 +00:00
n = 1;
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
else
n = 0;
rendernodeparser: Allow single values instead of 4 This allows writing: colors: red; instead of colors: red red red red; to draw a red border.
2019-05-13 22:41:49 +00:00
if (n > 0)
{
_indent (p);
g_string_append (p->str, "colors: ");
for (i = 0; i < n; i++)
{
if (i > 0)
g_string_append_c (p->str, ' ');
append_rgba (p->str, &colors[i]);
}
g_string_append (p->str, ";\n");
}
rendernodeparser: Print properties alphabetically Because now we have a rule. Also update some tests to the new order.
2019-05-14 01:11:33 +00:00
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
append_rounded_rect_param (p, "outline", gsk_border_node_get_outline (node));
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
rendernodeparser: Allow single values instead of 4 This allows writing: colors: red; instead of colors: red red red red; to draw a red border.
2019-05-13 22:41:49 +00:00
if (widths[3] != widths[1])
n = 4;
else if (widths[2] != widths[0])
n = 3;
else if (widths[1] != widths[0])
n = 2;
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
else if (widths[0] != 1.0)
rendernodeparser: Allow single values instead of 4 This allows writing: colors: red; instead of colors: red red red red; to draw a red border.
2019-05-13 22:41:49 +00:00
n = 1;
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
else
n = 0;
rendernodeparser: Allow single values instead of 4 This allows writing: colors: red; instead of colors: red red red red; to draw a red border.
2019-05-13 22:41:49 +00:00
if (n > 0)
{
_indent (p);
g_string_append (p->str, "widths: ");
for (i = 0; i < n; i++)
{
if (i > 0)
g_string_append_c (p->str, ' ');
string_append_double (p->str, widths[i]);
}
g_string_append (p->str, ";\n");
}
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
end_node (p);
}
break;
case GSK_SHADOW_NODE:
{
const guint n_shadows = gsk_shadow_node_get_n_shadows (node);
int i;
start_node (p, "shadow");
rendernodeparser: Print properties alphabetically Because now we have a rule. Also update some tests to the new order.
2019-05-14 01:11:33 +00:00
append_node_param (p, "child", gsk_shadow_node_get_child (node));
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
_indent (p);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
g_string_append (p->str, "shadows: ");
for (i = 0; i < n_shadows; i ++)
{
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
const GskShadow *s = gsk_shadow_node_get_shadow (node, i);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
char *color;
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
if (i > 0)
g_string_append (p->str, ", ");
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
color = gdk_rgba_to_string (&s->color);
g_string_append (p->str, color);
g_string_append_c (p->str, ' ');
string_append_double (p->str, s->dx);
g_string_append_c (p->str, ' ');
string_append_double (p->str, s->dy);
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
if (s->radius > 0)
{
g_string_append_c (p->str, ' ');
string_append_double (p->str, s->radius);
}
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
g_free (color);
}
g_string_append_c (p->str, ';');
g_string_append_c (p->str, '\n');
end_node (p);
}
break;
case GSK_INSET_SHADOW_NODE:
{
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
const GdkRGBA *color = gsk_inset_shadow_node_get_color (node);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
start_node (p, "inset-shadow");
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
append_float_param (p, "blur", gsk_inset_shadow_node_get_blur_radius (node), 0.0f);
if (!gdk_rgba_equal (color, &GDK_RGBA("000")))
append_rgba_param (p, "color", color);
append_float_param (p, "dx", gsk_inset_shadow_node_get_dx (node), 1.0f);
append_float_param (p, "dy", gsk_inset_shadow_node_get_dy (node), 1.0f);
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
append_rounded_rect_param (p, "outline", gsk_inset_shadow_node_get_outline (node));
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
append_float_param (p, "spread", gsk_inset_shadow_node_get_spread (node), 0.0f);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
end_node (p);
}
break;
case GSK_TEXTURE_NODE:
{
GdkTexture *texture = gsk_texture_node_get_texture (node);
rendernodeparser: Parse images differently Instead of encoding the raw data, encode the full image to a PNG. And instead of stuffing that encoding into a string, use a full data: url. And then remove the width and height properties, because they're now implicitly included in the data. And then change the parser to match. And because the parser now parses regular urls on top of data: urls, we can now load any random file.
2019-05-09 01:56:25 +00:00
cairo_surface_t *surface;
GByteArray *array;
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
start_node (p, "texture");
append_rect_param (p, "bounds", &node->bounds);
rendernodeparser: Parse images differently Instead of encoding the raw data, encode the full image to a PNG. And instead of stuffing that encoding into a string, use a full data: url. And then remove the width and height properties, because they're now implicitly included in the data. And then change the parser to match. And because the parser now parses regular urls on top of data: urls, we can now load any random file.
2019-05-09 01:56:25 +00:00
surface = gdk_texture_download_surface (texture);
array = g_byte_array_new ();
rendernodeparser: Parse Cairo nodes We also print the script, but we don't parse it yet.
2019-05-25 22:50:13 +00:00
cairo_surface_write_to_png_stream (surface, cairo_write_array, array);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
_indent (p);
gsk: Avoid long lines in serialized nodes When encoding big blobs of data in base64, insert newlines. Base64 allows it, CSS allows it, so not need to make GtkTextView struggle with multi-megabyte lines. Update nodeparser tests to reflect this change.
2020-10-03 13:45:28 +00:00
g_string_append (p->str, "texture: url(\"data:image/png;base64,");
b64 = base64_encode_with_linebreaks (array->data, array->len);
append_escaping_newlines (p->str, b64);
g_free (b64);
g_string_append (p->str, "\");\n");
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
end_node (p);
rendernodeparser: Parse images differently Instead of encoding the raw data, encode the full image to a PNG. And instead of stuffing that encoding into a string, use a full data: url. And then remove the width and height properties, because they're now implicitly included in the data. And then change the parser to match. And because the parser now parses regular urls on top of data: urls, we can now load any random file.
2019-05-09 01:56:25 +00:00
g_byte_array_free (array, TRUE);
cairo_surface_destroy (surface);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
}
break;
case GSK_TEXT_NODE:
{
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 = gsk_text_node_get_offset (node);
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
const GdkRGBA *color = gsk_text_node_get_color (node);
PangoFont *font = gsk_text_node_get_font (node);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
PangoFontDescription *desc;
char *font_name;
rendernodeparser: Allow parsing strings Instead of only allowing for glyph indexes, allow ASCII characters as replacements. So this glyph sequence glyphs: 65 8, 66 8, 67 8 Can be replaced by glyphs: "ABC" provided that the glyph for "A", "B" and "C" are 65, 66 and 67 respectively and their advance is exactly 8. x offset and y offset must always be 0 and every glyph must start a cluster.
2019-05-19 18:20:09 +00:00
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
start_node (p, "text");
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
if (!gdk_rgba_equal (color, &GDK_RGBA("000000")))
append_rgba_param (p, "color", color);
rendernodeparser: Print properties alphabetically Because now we have a rule. Also update some tests to the new order.
2019-05-14 01:11:33 +00:00
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
_indent (p);
rendernodeparser: Allow parsing strings Instead of only allowing for glyph indexes, allow ASCII characters as replacements. So this glyph sequence glyphs: 65 8, 66 8, 67 8 Can be replaced by glyphs: "ABC" provided that the glyph for "A", "B" and "C" are 65, 66 and 67 respectively and their advance is exactly 8. x offset and y offset must always be 0 and every glyph must start a cluster.
2019-05-19 18:20:09 +00:00
desc = pango_font_describe (font);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
font_name = pango_font_description_to_string (desc);
g_string_append_printf (p->str, "font: \"%s\";\n", font_name);
g_free (font_name);
pango_font_description_free (desc);
_indent (p);
g_string_append (p->str, "glyphs: ");
rendernodeparser: Allow parsing strings Instead of only allowing for glyph indexes, allow ASCII characters as replacements. So this glyph sequence glyphs: 65 8, 66 8, 67 8 Can be replaced by glyphs: "ABC" provided that the glyph for "A", "B" and "C" are 65, 66 and 67 respectively and their advance is exactly 8. x offset and y offset must always be 0 and every glyph must start a cluster.
2019-05-19 18:20:09 +00:00
gsk: Export the glyph serialization privately We want to use the same serialization in the inspector, so export this function.
2020-12-21 18:11:08 +00:00
gsk_text_node_serialize_glyphs (node, p->str);
rendernodeparser: Allow parsing strings Instead of only allowing for glyph indexes, allow ASCII characters as replacements. So this glyph sequence glyphs: 65 8, 66 8, 67 8 Can be replaced by glyphs: "ABC" provided that the glyph for "A", "B" and "C" are 65, 66 and 67 respectively and their advance is exactly 8. x offset and y offset must always be 0 and every glyph must start a cluster.
2019-05-19 18:20:09 +00:00
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
g_string_append_c (p->str, ';');
g_string_append_c (p->str, '\n');
rendernode: Take a graphene_point_t for the offset ... instead of 2 floats.
2019-05-19 02:08:29 +00:00
if (!graphene_point_equal (offset, graphene_point_zero ()))
append_point_param (p, "offset", offset);
rendernodeparser: Print properties alphabetically Because now we have a rule. Also update some tests to the new order.
2019-05-14 01:11:33 +00:00
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
end_node (p);
}
break;
case GSK_DEBUG_NODE:
{
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
const char *message = gsk_debug_node_get_message (node);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
start_node (p, "debug");
rendernodeparser: Print properties alphabetically Because now we have a rule. Also update some tests to the new order.
2019-05-14 01:11:33 +00:00
append_node_param (p, "child", gsk_debug_node_get_child (node));
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
/* TODO: We potentially need to escape certain characters in the message */
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
if (message)
{
_indent (p);
g_string_append_printf (p->str, "message: \"%s\";\n", message);
}
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
end_node (p);
}
break;
case GSK_BLUR_NODE:
{
start_node (p, "blur");
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
append_float_param (p, "blur", gsk_blur_node_get_radius (node), 1.0f);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
append_node_param (p, "child", gsk_blur_node_get_child (node));
end_node (p);
}
break;
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
case GSK_GL_SHADER_NODE:
{
GskGLShader *shader = gsk_gl_shader_node_get_shader (node);
GBytes *args = gsk_gl_shader_node_get_args (node);
start_node (p, "glshader");
append_rect_param (p, "bounds", &node->bounds);
GBytes *bytes = gsk_gl_shader_get_source (shader);
/* Ensure we are zero-terminated */
char *sourcecode = g_strndup (g_bytes_get_data (bytes, NULL), g_bytes_get_size (bytes));
append_string_param (p, "sourcecode", sourcecode);
g_free (sourcecode);
if (gsk_gl_shader_get_n_uniforms (shader) > 0)
{
GString *data = g_string_new ("");
for (guint i = 0; i < gsk_gl_shader_get_n_uniforms (shader); i++)
{
if (i > 0)
g_string_append (data, ", ");
switch (gsk_gl_shader_get_uniform_type (shader, i))
{
case GSK_GL_UNIFORM_TYPE_NONE:
default:
g_assert_not_reached ();
break;
case GSK_GL_UNIFORM_TYPE_FLOAT:
{
float value = gsk_gl_shader_get_arg_float (shader, args, i);
string_append_double (data, value);
}
break;
case GSK_GL_UNIFORM_TYPE_INT:
{
gint32 value = gsk_gl_shader_get_arg_int (shader, args, i);
g_string_append_printf (data, "%d", value);
}
break;
case GSK_GL_UNIFORM_TYPE_UINT:
{
guint32 value = gsk_gl_shader_get_arg_uint (shader, args, i);
g_string_append_printf (data, "%u", value);
}
break;
case GSK_GL_UNIFORM_TYPE_BOOL:
{
gboolean value = gsk_gl_shader_get_arg_bool (shader, args, i);
g_string_append_printf (data, "%d", value);
}
break;
case GSK_GL_UNIFORM_TYPE_VEC2:
{
graphene_vec2_t value;
gsk_gl_shader_get_arg_vec2 (shader, args, i,
&value);
string_append_double (data, graphene_vec2_get_x (&value));
g_string_append (data, " ");
string_append_double (data, graphene_vec2_get_y (&value));
}
break;
case GSK_GL_UNIFORM_TYPE_VEC3:
{
graphene_vec3_t value;
gsk_gl_shader_get_arg_vec3 (shader, args, i,
&value);
string_append_double (data, graphene_vec3_get_x (&value));
g_string_append (data, " ");
string_append_double (data, graphene_vec3_get_y (&value));
g_string_append (data, " ");
string_append_double (data, graphene_vec3_get_z (&value));
}
break;
case GSK_GL_UNIFORM_TYPE_VEC4:
{
graphene_vec4_t value;
gsk_gl_shader_get_arg_vec4 (shader, args, i,
&value);
string_append_double (data, graphene_vec4_get_x (&value));
g_string_append (data, " ");
string_append_double (data, graphene_vec4_get_y (&value));
g_string_append (data, " ");
string_append_double (data, graphene_vec4_get_z (&value));
g_string_append (data, " ");
string_append_double (data, graphene_vec4_get_w (&value));
}
break;
}
}
_indent (p);
g_string_append_printf (p->str, "args: %s;\n", data->str);
g_string_free (data, TRUE);
}
for (guint i = 0; i < gsk_gl_shader_node_get_n_children (node); i ++)
{
GskRenderNode *child = gsk_gl_shader_node_get_child (node, i);
char *name;
name = g_strdup_printf ("child%d", i + 1);
append_node_param (p, name, child);
g_free (name);
}
end_node (p);
}
break;
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
case GSK_REPEAT_NODE:
{
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
GskRenderNode *child = gsk_repeat_node_get_child (node);
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
const graphene_rect_t *child_bounds = gsk_repeat_node_get_child_bounds (node);
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
start_node (p, "repeat");
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
if (!graphene_rect_equal (&node->bounds, &child->bounds))
append_rect_param (p, "bounds", &node->bounds);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
append_node_param (p, "child", gsk_repeat_node_get_child (node));
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
if (!graphene_rect_equal (child_bounds, &child->bounds))
append_rect_param (p, "child-bounds", child_bounds);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
end_node (p);
}
break;
case GSK_BLEND_NODE:
{
rendernode: Parse and print blend nodes properly
2019-04-27 07:03:51 +00:00
GskBlendMode mode = gsk_blend_node_get_blend_mode (node);
guint i;
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
start_node (p, "blend");
rendernodeparser: Print properties alphabetically Because now we have a rule. Also update some tests to the new order.
2019-05-14 01:11:33 +00:00
append_node_param (p, "bottom", gsk_blend_node_get_bottom_child (node));
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
if (mode != GSK_BLEND_MODE_DEFAULT)
rendernode: Parse and print blend nodes properly
2019-04-27 07:03:51 +00:00
{
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
_indent (p);
for (i = 0; i < G_N_ELEMENTS (blend_modes); i++)
rendernode: Parse and print blend nodes properly
2019-04-27 07:03:51 +00:00
{
rendernodeparser: Update to new rules Update to the docs outlined in #1887. In particular, the changes do: 1. Require no property, have a working default for everything 2. Be clear about what gets printed and how. Tests ahve been adapted to still pass.
2019-05-18 21:06:34 +00:00
if (blend_modes[i].mode == mode)
{
g_string_append_printf (p->str, "mode: %s;\n", blend_modes[i].name);
break;
}
rendernode: Parse and print blend nodes properly
2019-04-27 07:03:51 +00:00
}
}
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
append_node_param (p, "top", gsk_blend_node_get_top_child (node));
end_node (p);
}
break;
case GSK_NOT_A_RENDER_NODE:
g_assert_not_reached ();
break;
case GSK_CAIRO_NODE:
rendernodeparser: Parse Cairo nodes We also print the script, but we don't parse it yet.
2019-05-25 22:50:13 +00:00
{
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 *surface = gsk_cairo_node_get_surface (node);
rendernodeparser: Parse Cairo nodes We also print the script, but we don't parse it yet.
2019-05-25 22:50:13 +00:00
GByteArray *array;
start_node (p, "cairo");
append_rect_param (p, "bounds", &node->bounds);
rendernodeparser: Handle empty Cairo nodes Cairo nodes can contain a NULL surface if they have never been drawn to. Make this the default Cairo node.
2019-05-29 03:48:38 +00:00
if (surface != NULL)
{
array = g_byte_array_new ();
cairo_surface_write_to_png_stream (surface, cairo_write_array, array);
rendernodeparser: Parse Cairo nodes We also print the script, but we don't parse it yet.
2019-05-25 22:50:13 +00:00
rendernodeparser: Handle empty Cairo nodes Cairo nodes can contain a NULL surface if they have never been drawn to. Make this the default Cairo node.
2019-05-29 03:48:38 +00:00
_indent (p);
gsk: Avoid long lines in serialized nodes When encoding big blobs of data in base64, insert newlines. Base64 allows it, CSS allows it, so not need to make GtkTextView struggle with multi-megabyte lines. Update nodeparser tests to reflect this change.
2020-10-03 13:45:28 +00:00
g_string_append (p->str, "pixels: url(\"data:image/png;base64,");
b64 = base64_encode_with_linebreaks (array->data, array->len);
append_escaping_newlines (p->str, b64);
rendernodeparser: Handle empty Cairo nodes Cairo nodes can contain a NULL surface if they have never been drawn to. Make this the default Cairo node.
2019-05-29 03:48:38 +00:00
g_free (b64);
gsk: Avoid long lines in serialized nodes When encoding big blobs of data in base64, insert newlines. Base64 allows it, CSS allows it, so not need to make GtkTextView struggle with multi-megabyte lines. Update nodeparser tests to reflect this change.
2020-10-03 13:45:28 +00:00
g_string_append (p->str, "\");\n");
rendernodeparser: Handle empty Cairo nodes Cairo nodes can contain a NULL surface if they have never been drawn to. Make this the default Cairo node.
2019-05-29 03:48:38 +00:00
g_byte_array_free (array, TRUE);
rendernodeparser: Parse Cairo nodes We also print the script, but we don't parse it yet.
2019-05-25 22:50:13 +00:00
#ifdef CAIRO_HAS_SCRIPT_SURFACE
rendernodeparser: Handle empty Cairo nodes Cairo nodes can contain a NULL surface if they have never been drawn to. Make this the default Cairo node.
2019-05-29 03:48:38 +00:00
if (cairo_surface_get_type (surface) == CAIRO_SURFACE_TYPE_RECORDING)
{
rendernodeparser: Handle Cairo being stupid Cairo writes to finished streams, so we have to make sure to keep the stream around to allow it to do that.
2019-06-03 15:20:59 +00:00
static const cairo_user_data_key_t cairo_is_stupid_key;
rendernodeparser: Handle empty Cairo nodes Cairo nodes can contain a NULL surface if they have never been drawn to. Make this the default Cairo node.
2019-05-29 03:48:38 +00:00
cairo_device_t *script;
rendernodeparser: Parse Cairo nodes We also print the script, but we don't parse it yet.
2019-05-25 22:50:13 +00:00
rendernodeparser: Handle empty Cairo nodes Cairo nodes can contain a NULL surface if they have never been drawn to. Make this the default Cairo node.
2019-05-29 03:48:38 +00:00
array = g_byte_array_new ();
script = cairo_script_create_for_stream (cairo_write_array, array);
rendernodeparser: Parse Cairo nodes We also print the script, but we don't parse it yet.
2019-05-25 22:50:13 +00:00
rendernodeparser: Handle empty Cairo nodes Cairo nodes can contain a NULL surface if they have never been drawn to. Make this the default Cairo node.
2019-05-29 03:48:38 +00:00
if (cairo_script_from_recording_surface (script, surface) == CAIRO_STATUS_SUCCESS)
{
_indent (p);
gsk: Avoid long lines in serialized nodes When encoding big blobs of data in base64, insert newlines. Base64 allows it, CSS allows it, so not need to make GtkTextView struggle with multi-megabyte lines. Update nodeparser tests to reflect this change.
2020-10-03 13:45:28 +00:00
g_string_append (p->str, "script: url(\"data:;base64,");
b64 = base64_encode_with_linebreaks (array->data, array->len);
append_escaping_newlines (p->str, b64);
rendernodeparser: Handle empty Cairo nodes Cairo nodes can contain a NULL surface if they have never been drawn to. Make this the default Cairo node.
2019-05-29 03:48:38 +00:00
g_free (b64);
gsk: Avoid long lines in serialized nodes When encoding big blobs of data in base64, insert newlines. Base64 allows it, CSS allows it, so not need to make GtkTextView struggle with multi-megabyte lines. Update nodeparser tests to reflect this change.
2020-10-03 13:45:28 +00:00
g_string_append (p->str, "\");\n");
rendernodeparser: Handle empty Cairo nodes Cairo nodes can contain a NULL surface if they have never been drawn to. Make this the default Cairo node.
2019-05-29 03:48:38 +00:00
}
rendernodeparser: Parse Cairo nodes We also print the script, but we don't parse it yet.
2019-05-25 22:50:13 +00:00
rendernodeparser: Handle Cairo being stupid Cairo writes to finished streams, so we have to make sure to keep the stream around to allow it to do that.
2019-06-03 15:20:59 +00:00
/* because Cairo is stupid and writes to the device after we finished it,
* we can't just
g_byte_array_free (array, TRUE);
* but have to
*/
g_byte_array_set_size (array, 0);
cairo_device_set_user_data (script, &cairo_is_stupid_key, array, cairo_destroy_array);
cairo_device_destroy (script);
}
rendernodeparser: Parse Cairo nodes We also print the script, but we don't parse it yet.
2019-05-25 22:50:13 +00:00
#endif
rendernodeparser: Handle Cairo being stupid Cairo writes to finished streams, so we have to make sure to keep the stream around to allow it to do that.
2019-06-03 15:20:59 +00:00
}
rendernodeparser: Parse Cairo nodes We also print the script, but we don't parse it yet.
2019-05-25 22:50:13 +00:00
end_node (p);
}
break;
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
default:
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
g_error ("Unhandled node: %s", g_type_name_from_instance ((GTypeInstance *) node));
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
break;
}
}
rendernodeparser: Skip root node when it's a container When printing, behave the same way as when parsing: Magically skip a container node if there is one - just like the parser magically creates a container node to hold all the nodes it parses.
2019-05-14 00:49:19 +00:00
/**
* gsk_render_node_serialize:
* @node: a #GskRenderNode
*
* Serializes the @node for later deserialization via
* gsk_render_node_deserialize(). No guarantees are made about the format
Clean up lots of GTK+ -> GTK Replace most remaining uses of GTK+ in the docs and user-visible strings by GTK. Also remove some leftover "Was added in 3.x" sentences from the docs.
2020-09-12 16:01:04 +00:00
* used other than that the same version of GTK will be able to deserialize
rendernodeparser: Skip root node when it's a container When printing, behave the same way as when parsing: Magically skip a container node if there is one - just like the parser magically creates a container node to hold all the nodes it parses.
2019-05-14 00:49:19 +00:00
* the result of a call to gsk_render_node_serialize() and
* gsk_render_node_deserialize() will correctly reject files it cannot open
Clean up lots of GTK+ -> GTK Replace most remaining uses of GTK+ in the docs and user-visible strings by GTK. Also remove some leftover "Was added in 3.x" sentences from the docs.
2020-09-12 16:01:04 +00:00
* that were created with previous versions of GTK.
rendernodeparser: Skip root node when it's a container When printing, behave the same way as when parsing: Magically skip a container node if there is one - just like the parser magically creates a container node to hold all the nodes it parses.
2019-05-14 00:49:19 +00:00
*
* The intended use of this functions is testing, benchmarking and debugging.
* The format is not meant as a permanent storage format.
*
* Returns: a #GBytes representing the node.
**/
GBytes *
gsk_render_node_serialize (GskRenderNode *node)
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
{
Printer p;
printer_init (&p);
rendernodeparser: Skip root node when it's a container When printing, behave the same way as when parsing: Magically skip a container node if there is one - just like the parser magically creates a container node to hold all the nodes it parses.
2019-05-14 00:49:19 +00:00
if (gsk_render_node_get_node_type (node) == GSK_CONTAINER_NODE)
{
guint i;
for (i = 0; i < gsk_container_node_get_n_children (node); i ++)
{
GskRenderNode *child = gsk_container_node_get_child (node, i);
render_node_print (&p, child);
}
}
else
{
render_node_print (&p, node);
}
return g_string_free_to_bytes (p.str);
Parse render nodes from text files Instead of the previous approach using GVariant, this new approach uses human-readable text files as the serialization format for render nodes. The format is a custom one, but it is inspired by QML and conforms to the CSS syntax. Because of that, we can use the CSS machinery from GTK to parse it, and in particular share code to parse properties that GTK's CSS machinery also supports, such as colors. This commit breaks all existing usages of node files - such as the testsuite and various test tools - they will be fixed in further commits.
2019-03-02 15:55:17 +00:00
}
Reference in New Issue Copy Permalink