forked from AuroraMiddleware/gtk
599 lines
17 KiB
C
599 lines
17 KiB
C
/* Copyright (C) 2016 Red Hat, Inc.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <gdk/gdk.h>
|
|
#include "gdkpixbufutilsprivate.h"
|
|
|
|
static GdkPixbuf *
|
|
load_from_stream (GdkPixbufLoader *loader,
|
|
GInputStream *stream,
|
|
GCancellable *cancellable,
|
|
GError **error)
|
|
{
|
|
GdkPixbuf *pixbuf;
|
|
gssize n_read;
|
|
guchar buffer[65536];
|
|
gboolean res;
|
|
|
|
res = TRUE;
|
|
while (1)
|
|
{
|
|
n_read = g_input_stream_read (stream, buffer, sizeof (buffer), cancellable, error);
|
|
if (n_read < 0)
|
|
{
|
|
res = FALSE;
|
|
error = NULL; /* Ignore further errors */
|
|
break;
|
|
}
|
|
|
|
if (n_read == 0)
|
|
break;
|
|
|
|
if (!gdk_pixbuf_loader_write (loader, buffer, n_read, error))
|
|
{
|
|
res = FALSE;
|
|
error = NULL;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!gdk_pixbuf_loader_close (loader, error))
|
|
{
|
|
res = FALSE;
|
|
error = NULL;
|
|
}
|
|
|
|
pixbuf = NULL;
|
|
|
|
if (res)
|
|
{
|
|
pixbuf = gdk_pixbuf_loader_get_pixbuf (loader);
|
|
if (pixbuf)
|
|
g_object_ref (pixbuf);
|
|
}
|
|
|
|
return pixbuf;
|
|
}
|
|
|
|
static void
|
|
size_prepared_cb (GdkPixbufLoader *loader,
|
|
gint width,
|
|
gint height,
|
|
gpointer data)
|
|
{
|
|
gdouble *scale = data;
|
|
|
|
width = MAX (*scale * width, 1);
|
|
height = MAX (*scale * height, 1);
|
|
|
|
gdk_pixbuf_loader_set_size (loader, width, height);
|
|
}
|
|
|
|
/* Like gdk_pixbuf_new_from_stream_at_scale, but
|
|
* load the image at its original size times the
|
|
* given scale.
|
|
*/
|
|
GdkPixbuf *
|
|
_gdk_pixbuf_new_from_stream_scaled (GInputStream *stream,
|
|
const char *format,
|
|
gdouble scale,
|
|
GCancellable *cancellable,
|
|
GError **error)
|
|
{
|
|
GdkPixbufLoader *loader;
|
|
GdkPixbuf *pixbuf;
|
|
|
|
if (format)
|
|
{
|
|
loader = gdk_pixbuf_loader_new_with_type (format, error);
|
|
if (!loader)
|
|
return NULL;
|
|
}
|
|
else
|
|
loader = gdk_pixbuf_loader_new ();
|
|
|
|
if (scale != 0)
|
|
g_signal_connect (loader, "size-prepared",
|
|
G_CALLBACK (size_prepared_cb), &scale);
|
|
|
|
pixbuf = load_from_stream (loader, stream, cancellable, error);
|
|
|
|
g_object_unref (loader);
|
|
|
|
return pixbuf;
|
|
}
|
|
|
|
static void
|
|
size_prepared_cb2 (GdkPixbufLoader *loader,
|
|
gint width,
|
|
gint height,
|
|
gpointer data)
|
|
{
|
|
int *scales = data;
|
|
|
|
gdk_pixbuf_loader_set_size (loader, scales[0], scales[1]);
|
|
}
|
|
|
|
GdkPixbuf *
|
|
_gdk_pixbuf_new_from_stream_at_scale (GInputStream *stream,
|
|
const char *format,
|
|
int width,
|
|
int height,
|
|
gboolean aspect,
|
|
GCancellable *cancellable,
|
|
GError **error)
|
|
{
|
|
GdkPixbufLoader *loader;
|
|
GdkPixbuf *pixbuf;
|
|
int scales[2];
|
|
|
|
if (format)
|
|
{
|
|
loader = gdk_pixbuf_loader_new_with_type (format, error);
|
|
if (!loader)
|
|
return NULL;
|
|
}
|
|
else
|
|
loader = gdk_pixbuf_loader_new ();
|
|
|
|
scales[0] = width;
|
|
scales[1] = height;
|
|
g_signal_connect (loader, "size-prepared",
|
|
G_CALLBACK (size_prepared_cb2), scales);
|
|
|
|
pixbuf = load_from_stream (loader, stream, cancellable, error);
|
|
|
|
g_object_unref (loader);
|
|
|
|
return pixbuf;
|
|
}
|
|
|
|
GdkPixbuf *
|
|
_gdk_pixbuf_new_from_stream (GInputStream *stream,
|
|
const char *format,
|
|
GCancellable *cancellable,
|
|
GError **error)
|
|
{
|
|
return _gdk_pixbuf_new_from_stream_scaled (stream, format, 0, cancellable, error);
|
|
}
|
|
|
|
/* Like gdk_pixbuf_new_from_resource_at_scale, but
|
|
* load the image at its original size times the
|
|
* given scale.
|
|
*/
|
|
GdkPixbuf *
|
|
_gdk_pixbuf_new_from_resource_scaled (const char *resource_path,
|
|
const char *format,
|
|
double scale,
|
|
GError **error)
|
|
{
|
|
GInputStream *stream;
|
|
GdkPixbuf *pixbuf;
|
|
|
|
stream = g_resources_open_stream (resource_path, 0, error);
|
|
if (stream == NULL)
|
|
return NULL;
|
|
|
|
pixbuf = _gdk_pixbuf_new_from_stream_scaled (stream, format, scale, NULL, error);
|
|
g_object_unref (stream);
|
|
|
|
return pixbuf;
|
|
}
|
|
|
|
GdkPixbuf *
|
|
_gdk_pixbuf_new_from_resource (const char *resource_path,
|
|
const char *format,
|
|
GError **error)
|
|
{
|
|
return _gdk_pixbuf_new_from_resource_scaled (resource_path, format, 0, error);
|
|
}
|
|
|
|
GdkPixbuf *
|
|
_gdk_pixbuf_new_from_resource_at_scale (const char *resource_path,
|
|
const char *format,
|
|
int width,
|
|
int height,
|
|
gboolean preserve_aspect,
|
|
GError **error)
|
|
{
|
|
GInputStream *stream;
|
|
GdkPixbuf *pixbuf;
|
|
|
|
stream = g_resources_open_stream (resource_path, 0, error);
|
|
if (stream == NULL)
|
|
return NULL;
|
|
|
|
pixbuf = _gdk_pixbuf_new_from_stream_at_scale (stream, format, width, height, preserve_aspect, NULL, error);
|
|
g_object_unref (stream);
|
|
|
|
return pixbuf;
|
|
|
|
}
|
|
|
|
static GdkPixbuf *
|
|
load_symbolic_svg (const char *escaped_file_data,
|
|
int width,
|
|
int height,
|
|
double scale,
|
|
int icon_width,
|
|
int icon_height,
|
|
const char *fg_string,
|
|
const char *success_color_string,
|
|
const char *warning_color_string,
|
|
const char *error_color_string,
|
|
GError **error)
|
|
{
|
|
GInputStream *stream;
|
|
GdkPixbuf *pixbuf;
|
|
gchar *data;
|
|
gchar *svg_width, *svg_height;
|
|
|
|
if (width == 0)
|
|
width = icon_width * scale;
|
|
if (height == 0)
|
|
height = icon_height * scale;
|
|
|
|
svg_width = g_strdup_printf ("%d", icon_width);
|
|
svg_height = g_strdup_printf ("%d", icon_height);
|
|
|
|
data = g_strconcat ("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n"
|
|
"<svg version=\"1.1\"\n"
|
|
" xmlns=\"http://www.w3.org/2000/svg\"\n"
|
|
" xmlns:xi=\"http://www.w3.org/2001/XInclude\"\n"
|
|
" width=\"", svg_width, "\"\n"
|
|
" height=\"", svg_height, "\">\n"
|
|
" <style type=\"text/css\">\n"
|
|
" rect,circle,path {\n"
|
|
" fill: ", fg_string," !important;\n"
|
|
" }\n"
|
|
" .warning {\n"
|
|
" fill: ", warning_color_string, " !important;\n"
|
|
" }\n"
|
|
" .error {\n"
|
|
" fill: ", error_color_string ," !important;\n"
|
|
" }\n"
|
|
" .success {\n"
|
|
" fill: ", success_color_string, " !important;\n"
|
|
" }\n"
|
|
" </style>\n"
|
|
" <xi:include href=\"data:text/xml;base64,", escaped_file_data, "\"/>\n"
|
|
"</svg>",
|
|
NULL);
|
|
g_free (svg_width);
|
|
g_free (svg_height);
|
|
|
|
stream = g_memory_input_stream_new_from_data (data, -1, g_free);
|
|
pixbuf = gdk_pixbuf_new_from_stream_at_scale (stream, width, height, TRUE, NULL, error);
|
|
g_object_unref (stream);
|
|
|
|
return pixbuf;
|
|
}
|
|
|
|
static void
|
|
rgba_to_pixel (const GdkRGBA *rgba,
|
|
guint8 pixel[4])
|
|
{
|
|
pixel[0] = rgba->red * 255;
|
|
pixel[1] = rgba->green * 255;
|
|
pixel[2] = rgba->blue * 255;
|
|
pixel[3] = 255;
|
|
}
|
|
|
|
GdkPixbuf *
|
|
gtk_color_symbolic_pixbuf (GdkPixbuf *symbolic,
|
|
const GdkRGBA *fg_color,
|
|
const GdkRGBA *success_color,
|
|
const GdkRGBA *warning_color,
|
|
const GdkRGBA *error_color)
|
|
{
|
|
int width, height, x, y, src_stride, dst_stride;
|
|
guchar *src_data, *dst_data;
|
|
guchar *src_row, *dst_row;
|
|
int alpha;
|
|
GdkPixbuf *colored;
|
|
guint8 fg_pixel[4], success_pixel[4], warning_pixel[4], error_pixel[4];
|
|
|
|
alpha = fg_color->alpha * 255;
|
|
|
|
rgba_to_pixel (fg_color, fg_pixel);
|
|
rgba_to_pixel (success_color, success_pixel);
|
|
rgba_to_pixel (warning_color, warning_pixel);
|
|
rgba_to_pixel (error_color, error_pixel);
|
|
|
|
width = gdk_pixbuf_get_width (symbolic);
|
|
height = gdk_pixbuf_get_height (symbolic);
|
|
|
|
colored = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, width, height);
|
|
|
|
src_stride = gdk_pixbuf_get_rowstride (symbolic);
|
|
src_data = gdk_pixbuf_get_pixels (symbolic);
|
|
|
|
dst_data = gdk_pixbuf_get_pixels (colored);
|
|
dst_stride = gdk_pixbuf_get_rowstride (colored);
|
|
for (y = 0; y < height; y++)
|
|
{
|
|
src_row = src_data + src_stride * y;
|
|
dst_row = dst_data + dst_stride * y;
|
|
for (x = 0; x < width; x++)
|
|
{
|
|
guint r, g, b, a;
|
|
int c1, c2, c3, c4;
|
|
|
|
a = src_row[3];
|
|
dst_row[3] = a * alpha / 255;
|
|
|
|
if (a == 0)
|
|
{
|
|
dst_row[0] = 0;
|
|
dst_row[1] = 0;
|
|
dst_row[2] = 0;
|
|
}
|
|
else
|
|
{
|
|
c2 = src_row[0];
|
|
c3 = src_row[1];
|
|
c4 = src_row[2];
|
|
|
|
if (c2 == 0 && c3 == 0 && c4 == 0)
|
|
{
|
|
dst_row[0] = fg_pixel[0];
|
|
dst_row[1] = fg_pixel[1];
|
|
dst_row[2] = fg_pixel[2];
|
|
}
|
|
else
|
|
{
|
|
c1 = 255 - c2 - c3 - c4;
|
|
|
|
r = fg_pixel[0] * c1 + success_pixel[0] * c2 + warning_pixel[0] * c3 + error_pixel[0] * c4;
|
|
g = fg_pixel[1] * c1 + success_pixel[1] * c2 + warning_pixel[1] * c3 + error_pixel[1] * c4;
|
|
b = fg_pixel[2] * c1 + success_pixel[2] * c2 + warning_pixel[2] * c3 + error_pixel[2] * c4;
|
|
|
|
dst_row[0] = r / 255;
|
|
dst_row[1] = g / 255;
|
|
dst_row[2] = b / 255;
|
|
}
|
|
}
|
|
|
|
src_row += 4;
|
|
dst_row += 4;
|
|
}
|
|
}
|
|
|
|
return colored;
|
|
}
|
|
|
|
static void
|
|
extract_plane (GdkPixbuf *src,
|
|
GdkPixbuf *dst,
|
|
int from_plane,
|
|
int to_plane)
|
|
{
|
|
guchar *src_data, *dst_data;
|
|
int width, height, src_stride, dst_stride;
|
|
guchar *src_row, *dst_row;
|
|
int x, y;
|
|
|
|
width = gdk_pixbuf_get_width (src);
|
|
height = gdk_pixbuf_get_height (src);
|
|
|
|
g_assert (width <= gdk_pixbuf_get_width (dst));
|
|
g_assert (height <= gdk_pixbuf_get_height (dst));
|
|
|
|
src_stride = gdk_pixbuf_get_rowstride (src);
|
|
src_data = gdk_pixbuf_get_pixels (src);
|
|
|
|
dst_data = gdk_pixbuf_get_pixels (dst);
|
|
dst_stride = gdk_pixbuf_get_rowstride (dst);
|
|
|
|
for (y = 0; y < height; y++)
|
|
{
|
|
src_row = src_data + src_stride * y;
|
|
dst_row = dst_data + dst_stride * y;
|
|
for (x = 0; x < width; x++)
|
|
{
|
|
dst_row[to_plane] = src_row[from_plane];
|
|
src_row += 4;
|
|
dst_row += 4;
|
|
}
|
|
}
|
|
}
|
|
|
|
GdkPixbuf *
|
|
gtk_make_symbolic_pixbuf_from_data (const char *file_data,
|
|
gsize file_len,
|
|
int width,
|
|
int height,
|
|
double scale,
|
|
GError **error)
|
|
|
|
{
|
|
const char *r_string = "rgb(255,0,0)";
|
|
const char *g_string = "rgb(0,255,0)";
|
|
GdkPixbuf *loaded;
|
|
GdkPixbuf *pixbuf = NULL;
|
|
int plane;
|
|
int icon_width, icon_height;
|
|
char *escaped_file_data;
|
|
|
|
/* Fetch size from the original icon */
|
|
{
|
|
GInputStream *stream = g_memory_input_stream_new_from_data (file_data, file_len, NULL);
|
|
GdkPixbuf *reference = gdk_pixbuf_new_from_stream (stream, NULL, error);
|
|
|
|
g_object_unref (stream);
|
|
|
|
if (!reference)
|
|
return NULL;
|
|
|
|
icon_width = gdk_pixbuf_get_width (reference);
|
|
icon_height = gdk_pixbuf_get_height (reference);
|
|
g_object_unref (reference);
|
|
}
|
|
|
|
escaped_file_data = g_base64_encode ((guchar *) file_data, file_len);
|
|
|
|
for (plane = 0; plane < 3; plane++)
|
|
{
|
|
/* Here we render the svg with all colors solid, this should
|
|
* always make the alpha channel the same and it should match
|
|
* the final alpha channel for all possible renderings. We
|
|
* Just use it as-is for final alpha.
|
|
*
|
|
* For the 3 non-fg colors, we render once each with that
|
|
* color as red, and every other color as green. The resulting
|
|
* red will describe the amount of that color is in the
|
|
* opaque part of the color. We store these as the rgb
|
|
* channels, with the color of the fg being implicitly
|
|
* the "rest", as all color fractions should add up to 1.
|
|
*/
|
|
loaded = load_symbolic_svg (escaped_file_data, width, height, scale,
|
|
icon_width,
|
|
icon_height,
|
|
g_string,
|
|
plane == 0 ? r_string : g_string,
|
|
plane == 1 ? r_string : g_string,
|
|
plane == 2 ? r_string : g_string,
|
|
error);
|
|
if (loaded == NULL)
|
|
return NULL;
|
|
|
|
if (pixbuf == NULL)
|
|
{
|
|
pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8,
|
|
gdk_pixbuf_get_width (loaded),
|
|
gdk_pixbuf_get_height (loaded));
|
|
gdk_pixbuf_fill (pixbuf, 0);
|
|
}
|
|
|
|
if (plane == 0)
|
|
extract_plane (loaded, pixbuf, 3, 3);
|
|
|
|
extract_plane (loaded, pixbuf, 0, plane);
|
|
|
|
g_object_unref (loaded);
|
|
}
|
|
|
|
g_free (escaped_file_data);
|
|
|
|
return pixbuf;
|
|
}
|
|
|
|
GdkPixbuf *
|
|
gtk_make_symbolic_pixbuf_from_resource (const char *path,
|
|
int width,
|
|
int height,
|
|
double scale,
|
|
GError **error)
|
|
{
|
|
GBytes *bytes;
|
|
const char *data;
|
|
gsize size;
|
|
GdkPixbuf *pixbuf;
|
|
|
|
bytes = g_resources_lookup_data (path, G_RESOURCE_LOOKUP_FLAGS_NONE, error);
|
|
if (bytes == NULL)
|
|
return NULL;
|
|
|
|
data = g_bytes_get_data (bytes, &size);
|
|
|
|
pixbuf = gtk_make_symbolic_pixbuf_from_data (data, size, width, height, scale, error);
|
|
|
|
g_bytes_unref (bytes);
|
|
|
|
return pixbuf;
|
|
}
|
|
|
|
GdkPixbuf *
|
|
gtk_make_symbolic_pixbuf_from_path (const char *path,
|
|
int width,
|
|
int height,
|
|
double scale,
|
|
GError **error)
|
|
{
|
|
char *data;
|
|
gsize size;
|
|
GdkPixbuf *pixbuf;
|
|
|
|
if (!g_file_get_contents (path, &data, &size, error))
|
|
return NULL;
|
|
|
|
pixbuf = gtk_make_symbolic_pixbuf_from_data (data, size, width, height, scale, error);
|
|
|
|
g_free (data);
|
|
|
|
return pixbuf;
|
|
}
|
|
|
|
GdkPixbuf *
|
|
gtk_make_symbolic_pixbuf_from_file (GFile *file,
|
|
int width,
|
|
int height,
|
|
double scale,
|
|
GError **error)
|
|
{
|
|
char *data;
|
|
gsize size;
|
|
GdkPixbuf *pixbuf;
|
|
|
|
if (!g_file_load_contents (file, NULL, &data, &size, NULL, error))
|
|
return NULL;
|
|
|
|
pixbuf = gtk_make_symbolic_pixbuf_from_data (data, size, width, height, scale, error);
|
|
|
|
g_free (data);
|
|
|
|
return pixbuf;
|
|
}
|
|
|
|
GdkTexture *
|
|
gtk_make_symbolic_texture_from_resource (const char *path,
|
|
int width,
|
|
int height,
|
|
double scale,
|
|
GError **error)
|
|
{
|
|
GdkPixbuf *pixbuf;
|
|
GdkTexture *texture = NULL;
|
|
|
|
pixbuf = gtk_make_symbolic_pixbuf_from_resource (path, width, height, scale, error);
|
|
if (pixbuf)
|
|
{
|
|
texture = gdk_texture_new_for_pixbuf (pixbuf);
|
|
g_object_unref (pixbuf);
|
|
}
|
|
|
|
return texture;
|
|
}
|
|
|
|
GdkTexture *
|
|
gtk_make_symbolic_texture_from_file (GFile *file,
|
|
int width,
|
|
int height,
|
|
double scale,
|
|
GError **error)
|
|
{
|
|
GdkPixbuf *pixbuf;
|
|
GdkTexture *texture;
|
|
|
|
pixbuf = gtk_make_symbolic_pixbuf_from_file (file, width, height, scale, error);
|
|
texture = gdk_texture_new_for_pixbuf (pixbuf);
|
|
g_object_unref (pixbuf);
|
|
|
|
return texture;
|
|
}
|