cairo_surface_t *
_cairo_clip_get_image (const cairo_clip_t *clip,
cairo_surface_t *target,
const cairo_rectangle_int_t *extents)
{
cairo_surface_t *surface;
cairo_status_t status;
surface = cairo_surface_create_similar_image (target,
CAIRO_FORMAT_A8,
extents->width,
extents->height);
if (unlikely (surface->status))
return surface;
status = _cairo_surface_paint (surface, CAIRO_OPERATOR_SOURCE,
&_cairo_pattern_white.base, NULL);
if (likely (status == CAIRO_STATUS_SUCCESS))
status = _cairo_clip_combine_with_surface (clip, surface,
extents->x, extents->y);
if (unlikely (status)) {
cairo_surface_destroy (surface);
surface = _cairo_surface_create_in_error (status);
}
return surface;
}
cairo_t *
gsk_cairo_blur_start_drawing (cairo_t *cr,
float radius,
GskBlurFlags blur_flags)
{
cairo_rectangle_int_t clip_rect;
cairo_surface_t *surface;
cairo_t *blur_cr;
gdouble clip_radius;
gdouble x_scale, y_scale;
gboolean blur_x = (blur_flags & GSK_BLUR_X) != 0;
gboolean blur_y = (blur_flags & GSK_BLUR_Y) != 0;
if (!needs_blur (radius))
return cr;
gdk_cairo_get_clip_rectangle (cr, &clip_rect);
clip_radius = gsk_cairo_blur_compute_pixels (radius);
x_scale = y_scale = 1;
cairo_surface_get_device_scale (cairo_get_target (cr), &x_scale, &y_scale);
if (blur_flags & GSK_BLUR_REPEAT)
{
if (!blur_x)
clip_rect.width = 1;
if (!blur_y)
clip_rect.height = 1;
}
/* Create a larger surface to center the blur. */
surface = cairo_surface_create_similar_image (cairo_get_target (cr),
CAIRO_FORMAT_A8,
x_scale * (clip_rect.width + (blur_x ? 2 * clip_radius : 0)),
y_scale * (clip_rect.height + (blur_y ? 2 * clip_radius : 0)));
cairo_surface_set_device_scale (surface, x_scale, y_scale);
cairo_surface_set_device_offset (surface,
x_scale * ((blur_x ? clip_radius : 0) - clip_rect.x),
y_scale * ((blur_y ? clip_radius : 0) - clip_rect.y));
blur_cr = cairo_create (surface);
cairo_set_user_data (blur_cr, &original_cr_key, cairo_reference (cr), (cairo_destroy_func_t) cairo_destroy);
if (cairo_has_current_point (cr))
{
double x, y;
cairo_get_current_point (cr, &x, &y);
cairo_move_to (blur_cr, x, y);
}
return blur_cr;
}
static void
gtk_css_image_surface_draw (GtkCssImage *image,
cairo_t *cr,
double width,
double height)
{
GtkCssImageSurface *surface = GTK_CSS_IMAGE_SURFACE (image);
int image_width, image_height;
image_width = cairo_image_surface_get_width (surface->surface);
image_height = cairo_image_surface_get_height (surface->surface);
if (image_width == 0 || image_height == 0 || width <= 0 || height <= 0)
return;
/* Update cache image if size is different */
if (surface->cache == NULL ||
ABS (width - surface->width) > 0.001 ||
ABS (height - surface->height) > 0.001)
{
double xscale, yscale;
cairo_t *cache;
/* We need the device scale (HiDPI mode) to calculate the proper size in
* pixels for the image surface and set the cache device scale
*/
cairo_surface_get_device_scale (cairo_get_target (cr), &xscale, &yscale);
/* Save original size to preserve precision */
surface->width = width;
surface->height = height;
/* Destroy old cache if any */
g_clear_pointer (&surface->cache, cairo_surface_destroy);
/* Image big enough to contain scaled image with subpixel precision */
surface->cache = cairo_surface_create_similar_image (surface->surface,
CAIRO_FORMAT_ARGB32,
ceil (width*xscale),
ceil (height*yscale));
cairo_surface_set_device_scale (surface->cache, xscale, yscale);
cache = cairo_create (surface->cache);
cairo_rectangle (cache, 0, 0, width, height);
cairo_scale (cache, width / image_width, height / image_height);
cairo_set_source_surface (cache, surface->surface, 0, 0);
cairo_fill (cache);
cairo_destroy (cache);
}
cairo_rectangle (cr, 0, 0, width, height);
cairo_set_source_surface (cr, surface->cache ? surface->cache : surface->surface, 0, 0);
cairo_fill (cr);
}
static cairo_surface_t *
_source_image_create (void *closure,
cairo_format_t format,
int width,
int height,
long uid)
{
struct trace *args = closure;
return cairo_surface_create_similar_image (args->surface,
format, width, height);
}
static int
surface_create_similar_image (lua_State *L) {
cairo_surface_t **oldobj = luaL_checkudata(L, 1, OOCAIRO_MT_NAME_SURFACE);
cairo_format_t format;
int width, height;
SurfaceUserdata *surface;
format = format_from_lua(L, 2);
width = luaL_checkint(L, 3);
luaL_argcheck(L, width >= 0, 3, "image width cannot be negative");
height = luaL_checkint(L, 4);
luaL_argcheck(L, height >= 0, 4, "image height cannot be negative");
surface = create_surface_userdata(L);
surface->surface = cairo_surface_create_similar_image(*oldobj,
format, width, height);
return 1;
}
static cairo_surface_t *
red_acquire (cairo_pattern_t *pattern, void *closure,
cairo_surface_t *target,
const cairo_rectangle_int_t *extents)
{
cairo_surface_t *image;
cairo_t *cr;
image = cairo_surface_create_similar_image (target,
CAIRO_FORMAT_RGB24,
extents->width,
extents->height);
cairo_surface_set_device_offset (image, extents->x, extents->y);
cr = cairo_create (image);
cairo_set_source_rgb (cr, 1, 0, 0);
cairo_paint (cr);
cairo_destroy (cr);
return image;
}
static bool_t to_ninepatch(cairo_surface_t * surface, struct lninepatch_t * patch)
{
cairo_surface_t * cs;
cairo_t * cr;
unsigned char * data;
int width, height;
int stride;
int w, h;
int i;
if(!surface || !patch)
return FALSE;
width = cairo_image_surface_get_width(surface);
height = cairo_image_surface_get_height(surface);
if(width < 3 || height < 3)
return FALSE;
/* Nine patch chunk */
cs = cairo_surface_create_similar_image(surface, CAIRO_FORMAT_ARGB32, width, height);
cr = cairo_create(cs);
cairo_set_source_surface(cr, surface, 0, 0);
cairo_paint(cr);
cairo_destroy(cr);
data = cairo_image_surface_get_data(cs);
stride = cairo_image_surface_get_stride(cs);
/* Nine patch default size */
width = width - 2;
height = height - 2;
patch->width = width;
patch->height = height;
/* Stretch information */
patch->left = 0;
patch->right = 0;
patch->top = 0;
patch->right = 0;
for(i = 0; i < width; i++)
{
if(detect_black_pixel(&data[(i + 1) * 4]))
{
patch->left = i;
break;
}
}
for(i = width - 1; i >= 0; i--)
{
if(detect_black_pixel(&data[(i + 1) * 4]))
{
patch->right = width - 1 - i;
break;
}
}
for(i = 0; i < height; i++)
{
if(detect_black_pixel(&data[stride * (i + 1)]))
{
patch->top = i;
break;
}
}
for(i = height - 1; i >= 0; i--)
{
if(detect_black_pixel(&data[stride * (i + 1)]))
{
patch->bottom = height - 1 - i;
break;
}
}
cairo_surface_destroy(cs);
/* Left top */
w = patch->left;
h = patch->top;
if(w > 0 && h > 0)
{
cs = cairo_surface_create_similar(surface, cairo_surface_get_content(surface), patch->left, patch->top);
cr = cairo_create(cs);
cairo_set_source_surface(cr, surface, -1, -1);
cairo_paint(cr);
cairo_destroy(cr);
patch->lt = cs;
}
else
{
patch->lt = NULL;
}
/* Middle top */
w = width - patch->left - patch->right;
h = patch->top;
if(w > 0 && h > 0)
{
cs = cairo_surface_create_similar(surface, cairo_surface_get_content(surface), w, h);
cr = cairo_create(cs);
cairo_set_source_surface(cr, surface, -patch->left - 1, -1);
cairo_paint(cr);
cairo_destroy(cr);
patch->mt = cs;
}
else
{
patch->mt = NULL;
}
/* Right top */
w = patch->right;
h = patch->top;
if(w > 0 && h > 0)
{
cs = cairo_surface_create_similar(surface, cairo_surface_get_content(surface), w, h);
cr = cairo_create(cs);
cairo_set_source_surface(cr, surface, -(width - patch->right) - 1, -1);
cairo_paint(cr);
cairo_destroy(cr);
patch->rt = cs;
}
else
{
patch->rt = NULL;
}
/* Left Middle */
w = patch->left;
h = height - patch->top - patch->bottom;
if(w > 0 && h > 0)
{
cs = cairo_surface_create_similar(surface, cairo_surface_get_content(surface), w, h);
cr = cairo_create(cs);
cairo_set_source_surface(cr, surface, -1, -patch->top - 1);
cairo_paint(cr);
cairo_destroy(cr);
patch->lm = cs;
}
else
{
patch->lm = NULL;
}
/* Middle Middle */
w = width - patch->left - patch->right;
h = height - patch->top - patch->bottom;
if(w > 0 && h > 0)
{
cs = cairo_surface_create_similar(surface, cairo_surface_get_content(surface), w, h);
cr = cairo_create(cs);
cairo_set_source_surface(cr, surface, -patch->left - 1, -patch->top - 1);
cairo_paint(cr);
cairo_destroy(cr);
patch->mm = cs;
}
else
{
patch->mm = NULL;
}
/* Right middle */
w = patch->right;
h = height - patch->top - patch->bottom;
if(w > 0 && h > 0)
{
cs = cairo_surface_create_similar(surface, cairo_surface_get_content(surface), w, h);
cr = cairo_create(cs);
cairo_set_source_surface(cr, surface, -(width - patch->right) - 1, -patch->top - 1);
cairo_paint(cr);
cairo_destroy(cr);
patch->rm = cs;
}
else
{
patch->rm = NULL;
}
/* Left bottom */
w = patch->left;
h = patch->bottom;
if(w > 0 && h > 0)
{
cs = cairo_surface_create_similar(surface, cairo_surface_get_content(surface), w, h);
cr = cairo_create(cs);
cairo_set_source_surface(cr, surface, -1, -(height - patch->bottom) - 1);
cairo_paint(cr);
cairo_destroy(cr);
patch->lb = cs;
}
else
{
patch->lb = NULL;
}
/* Middle bottom */
w = width - patch->left - patch->right;
h = patch->bottom;
if(w > 0 && h > 0)
{
cs = cairo_surface_create_similar(surface, cairo_surface_get_content(surface), w, h);
cr = cairo_create(cs);
cairo_set_source_surface(cr, surface, -patch->left - 1, -(height - patch->bottom) - 1);
cairo_paint(cr);
cairo_destroy(cr);
patch->mb = cs;
}
else
{
patch->mb = NULL;
}
/* Right bottom */
w = patch->right;
h = patch->bottom;
if(w > 0 && h > 0)
{
cs = cairo_surface_create_similar(surface, cairo_surface_get_content(surface), w, h);
cr = cairo_create(cs);
cairo_set_source_surface(cr, surface, -(width - patch->right) - 1, -(height - patch->bottom) - 1);
cairo_paint(cr);
cairo_destroy(cr);
patch->rb = cs;
}
else
{
patch->rb = NULL;
}
ninepatch_stretch(patch, width, height);
return TRUE;
}
void
gimp_display_shell_render (GimpDisplayShell *shell,
cairo_t *cr,
gint x,
gint y,
gint w,
gint h)
{
GimpImage *image;
GeglBuffer *buffer;
#ifdef USE_NODE_BLIT
GeglNode *node;
#endif
gdouble scale_x = 1.0;
gdouble scale_y = 1.0;
gdouble buffer_scale = 1.0;
gint viewport_offset_x;
gint viewport_offset_y;
gint viewport_width;
gint viewport_height;
gint scaled_x;
gint scaled_y;
gint scaled_width;
gint scaled_height;
cairo_surface_t *xfer;
gint xfer_src_x;
gint xfer_src_y;
gint mask_src_x = 0;
gint mask_src_y = 0;
gint cairo_stride;
guchar *cairo_data;
GeglBuffer *cairo_buffer;
g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
g_return_if_fail (cr != NULL);
g_return_if_fail (w > 0 && h > 0);
image = gimp_display_get_image (shell->display);
buffer = gimp_pickable_get_buffer (GIMP_PICKABLE (image));
#ifdef USE_NODE_BLIT
node = gimp_projectable_get_graph (GIMP_PROJECTABLE (image));
#endif
#ifdef GIMP_DISPLAY_RENDER_ENABLE_SCALING
/* if we had this future API, things would look pretty on hires (retina) */
scale_x = gdk_window_get_scale_factor (gtk_widget_get_window (gtk_widget_get_toplevel (GTK_WIDGET (shell))));
#endif
scale_x = MIN (scale_x, GIMP_DISPLAY_RENDER_MAX_SCALE);
scale_y = scale_x;
if (shell->scale_x > shell->scale_y)
{
scale_y *= (shell->scale_x / shell->scale_y);
buffer_scale = shell->scale_y * scale_y;
}
else if (shell->scale_y > shell->scale_x)
{
scale_x *= (shell->scale_y / shell->scale_x);
buffer_scale = shell->scale_x * scale_x;
}
else
{
buffer_scale = shell->scale_x * scale_x;
}
gimp_display_shell_scroll_get_scaled_viewport (shell,
&viewport_offset_x,
&viewport_offset_y,
&viewport_width,
&viewport_height);
scaled_x = floor ((x + viewport_offset_x) * scale_x);
scaled_y = floor ((y + viewport_offset_y) * scale_y);
scaled_width = ceil (w * scale_x);
scaled_height = ceil (h * scale_y);
if (shell->rotate_transform)
{
xfer = cairo_surface_create_similar_image (cairo_get_target (cr),
CAIRO_FORMAT_ARGB32,
scaled_width,
scaled_height);
cairo_surface_mark_dirty (xfer);
xfer_src_x = 0;
xfer_src_y = 0;
}
else
{
xfer = gimp_display_xfer_get_surface (shell->xfer,
scaled_width,
scaled_height,
&xfer_src_x,
&xfer_src_y);
}
cairo_stride = cairo_image_surface_get_stride (xfer);
cairo_data = cairo_image_surface_get_data (xfer) +
xfer_src_y * cairo_stride + xfer_src_x * 4;
cairo_buffer = gegl_buffer_linear_new_from_data (cairo_data,
babl_format ("cairo-ARGB32"),
GEGL_RECTANGLE (0, 0,
scaled_width,
scaled_height),
cairo_stride,
NULL, NULL);
if (shell->profile_transform ||
gimp_display_shell_has_filter (shell))
{
gboolean can_convert_to_u8;
/* if there is a profile transform or a display filter, we need
* to use temp buffers
*/
can_convert_to_u8 = gimp_display_shell_profile_can_convert_to_u8 (shell);
/* create the filter buffer if we have filters
*/
if ((gimp_display_shell_has_filter (shell) || ! can_convert_to_u8) &&
! shell->filter_buffer)
{
gint w = GIMP_DISPLAY_RENDER_BUF_WIDTH * GIMP_DISPLAY_RENDER_MAX_SCALE;
gint h = GIMP_DISPLAY_RENDER_BUF_HEIGHT * GIMP_DISPLAY_RENDER_MAX_SCALE;
shell->filter_data =
gegl_malloc (w * h * babl_format_get_bytes_per_pixel (shell->filter_format));
shell->filter_stride =
w * babl_format_get_bytes_per_pixel (shell->filter_format);
shell->filter_buffer =
gegl_buffer_linear_new_from_data (shell->filter_data,
shell->filter_format,
GEGL_RECTANGLE (0, 0, w, h),
GEGL_AUTO_ROWSTRIDE,
(GDestroyNotify) gegl_free,
shell->filter_data);
}
if (shell->profile_transform)
{
/* if there is a profile transform, load the projection
* pixels into the profile_buffer
*/
#ifndef USE_NODE_BLIT
gegl_buffer_get (buffer,
GEGL_RECTANGLE (scaled_x, scaled_y,
scaled_width, scaled_height),
buffer_scale,
gimp_projectable_get_format (GIMP_PROJECTABLE (image)),
shell->profile_data, shell->profile_stride,
GEGL_ABYSS_CLAMP);
#else
gegl_node_blit (node,
buffer_scale,
GEGL_RECTANGLE (scaled_x, scaled_y,
scaled_width, scaled_height),
gimp_projectable_get_format (GIMP_PROJECTABLE (image)),
shell->profile_data, shell->profile_stride,
GEGL_BLIT_CACHE);
#endif
if (gimp_display_shell_has_filter (shell) || ! can_convert_to_u8)
{
/* if there are filters, convert the pixels from the
* profile_buffer to the filter_buffer
*/
gimp_display_shell_profile_convert_buffer (shell,
shell->profile_buffer,
GEGL_RECTANGLE (0, 0,
scaled_width,
scaled_height),
shell->filter_buffer,
GEGL_RECTANGLE (0, 0,
scaled_width,
scaled_height));
}
else
{
/* otherwise, convert the profile_buffer directly into
* the cairo_buffer
*/
gimp_display_shell_profile_convert_buffer (shell,
shell->profile_buffer,
GEGL_RECTANGLE (0, 0,
scaled_width,
scaled_height),
cairo_buffer,
GEGL_RECTANGLE (0, 0,
scaled_width,
scaled_height));
}
}
else
{
/* otherwise, load the projection pixels directly into the
* filter_buffer
*/
#ifndef USE_NODE_BLIT
gegl_buffer_get (buffer,
GEGL_RECTANGLE (scaled_x, scaled_y,
scaled_width, scaled_height),
buffer_scale,
shell->filter_format,
shell->filter_data, shell->filter_stride,
GEGL_ABYSS_CLAMP);
#else
gegl_node_blit (node,
buffer_scale,
GEGL_RECTANGLE (scaled_x, scaled_y,
scaled_width, scaled_height),
shell->filter_format,
shell->filter_data, shell->filter_stride,
GEGL_BLIT_CACHE);
#endif
}
if (gimp_display_shell_has_filter (shell))
{
/* convert the filter_buffer in place
*/
gimp_color_display_stack_convert_buffer (shell->filter_stack,
shell->filter_buffer,
GEGL_RECTANGLE (0, 0,
scaled_width,
scaled_height));
}
if (gimp_display_shell_has_filter (shell) || ! can_convert_to_u8)
{
/* finally, copy the filter buffer to the cairo-ARGB32 buffer
*/
gegl_buffer_get (shell->filter_buffer,
GEGL_RECTANGLE (0, 0,
scaled_width,
scaled_height),
1.0,
babl_format ("cairo-ARGB32"),
cairo_data, cairo_stride,
GEGL_ABYSS_CLAMP);
}
}
else
{
/* otherwise we can copy the projection pixels straight to the
* cairo-ARGB32 buffer
*/
#ifndef USE_NODE_BLIT
gegl_buffer_get (buffer,
GEGL_RECTANGLE (scaled_x, scaled_y,
scaled_width, scaled_height),
buffer_scale,
babl_format ("cairo-ARGB32"),
cairo_data, cairo_stride,
GEGL_ABYSS_CLAMP);
#else
gegl_node_blit (node,
buffer_scale,
GEGL_RECTANGLE (scaled_x, scaled_y,
scaled_width, scaled_height),
babl_format ("cairo-ARGB32"),
cairo_data, cairo_stride,
GEGL_BLIT_CACHE);
#endif
}
g_object_unref (cairo_buffer);
if (shell->mask)
{
if (! shell->mask_surface)
{
shell->mask_surface =
cairo_image_surface_create (CAIRO_FORMAT_A8,
GIMP_DISPLAY_RENDER_BUF_WIDTH *
GIMP_DISPLAY_RENDER_MAX_SCALE,
GIMP_DISPLAY_RENDER_BUF_HEIGHT *
GIMP_DISPLAY_RENDER_MAX_SCALE);
}
cairo_surface_mark_dirty (shell->mask_surface);
cairo_stride = cairo_image_surface_get_stride (shell->mask_surface);
cairo_data = cairo_image_surface_get_data (shell->mask_surface) +
mask_src_y * cairo_stride + mask_src_x * 4;
gegl_buffer_get (shell->mask,
GEGL_RECTANGLE (scaled_x - shell->mask_offset_x,
scaled_y - shell->mask_offset_y,
scaled_width, scaled_height),
buffer_scale,
babl_format ("Y u8"),
cairo_data, cairo_stride,
GEGL_ABYSS_NONE);
if (shell->mask_inverted)
{
gint mask_height = scaled_height;
while (mask_height--)
{
gint mask_width = scaled_width;
guchar *d = cairo_data;
while (mask_width--)
{
guchar inv = 255 - *d;
*d++ = inv;
}
cairo_data += cairo_stride;
}
}
}
/* put it to the screen */
cairo_save (cr);
cairo_rectangle (cr, x, y, w, h);
cairo_scale (cr, 1.0 / scale_x, 1.0 / scale_y);
cairo_set_source_surface (cr, xfer,
x * scale_x - xfer_src_x,
y * scale_y - xfer_src_y);
if (shell->rotate_transform)
{
cairo_pattern_t *pattern;
pattern = cairo_get_source (cr);
cairo_pattern_set_extend (pattern, CAIRO_EXTEND_PAD);
cairo_set_line_width (cr, 1.0);
cairo_stroke_preserve (cr);
cairo_surface_destroy (xfer);
}
cairo_clip (cr);
cairo_paint (cr);
if (shell->mask)
{
gimp_cairo_set_source_rgba (cr, &shell->mask_color);
cairo_mask_surface (cr, shell->mask_surface,
(x - mask_src_x) * scale_x,
(y - mask_src_y) * scale_y);
}
cairo_restore (cr);
}
void
gimp_display_shell_render (GimpDisplayShell *shell,
cairo_t *cr,
gint x,
gint y,
gint w,
gint h)
{
GimpImage *image;
GimpProjection *projection;
GeglBuffer *buffer;
gdouble scale_x = 1.0;
gdouble scale_y = 1.0;
gdouble buffer_scale = 1.0;
gint viewport_offset_x;
gint viewport_offset_y;
gint viewport_width;
gint viewport_height;
gint scaled_x;
gint scaled_y;
gint scaled_width;
gint scaled_height;
cairo_surface_t *xfer;
gint xfer_src_x;
gint xfer_src_y;
gint mask_src_x = 0;
gint mask_src_y = 0;
gint stride;
guchar *data;
g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
g_return_if_fail (cr != NULL);
g_return_if_fail (w > 0 && h > 0);
image = gimp_display_get_image (shell->display);
projection = gimp_image_get_projection (image);
buffer = gimp_pickable_get_buffer (GIMP_PICKABLE (projection));
#ifdef GIMP_DISPLAY_RENDER_ENABLE_SCALING
/* if we had this future API, things would look pretty on hires (retina) */
scale_x = gdk_window_get_scale_factor (gtk_widget_get_window (gtk_widget_get_toplevel (GTK_WIDGET (shell))));
#endif
scale_x = MIN (scale_x, GIMP_DISPLAY_RENDER_MAX_SCALE);
scale_y = scale_x;
if (shell->scale_x > shell->scale_y)
{
scale_y *= (shell->scale_x / shell->scale_y);
buffer_scale = shell->scale_y * scale_y;
}
else if (shell->scale_y > shell->scale_x)
{
scale_x *= (shell->scale_y / shell->scale_x);
buffer_scale = shell->scale_x * scale_x;
}
else
{
buffer_scale = shell->scale_x * scale_x;
}
gimp_display_shell_scroll_get_scaled_viewport (shell,
&viewport_offset_x,
&viewport_offset_y,
&viewport_width,
&viewport_height);
scaled_x = floor ((x + viewport_offset_x) * scale_x);
scaled_y = floor ((y + viewport_offset_y) * scale_y);
scaled_width = ceil (w * scale_x);
scaled_height = ceil (h * scale_y);
if (shell->rotate_transform)
{
xfer = cairo_surface_create_similar_image (cairo_get_target (cr),
CAIRO_FORMAT_ARGB32,
scaled_width,
scaled_height);
cairo_surface_mark_dirty (xfer);
xfer_src_x = 0;
xfer_src_y = 0;
}
else
{
xfer = gimp_display_xfer_get_surface (shell->xfer,
scaled_width,
scaled_height,
&xfer_src_x,
&xfer_src_y);
}
stride = cairo_image_surface_get_stride (xfer);
data = cairo_image_surface_get_data (xfer);
data += xfer_src_y * stride + xfer_src_x * 4;
/* apply filters to the rendered projection */
if (shell->filter_stack)
{
const Babl *filter_format = babl_format ("R'G'B'A float");
if (! shell->filter_buffer)
{
gint w = GIMP_DISPLAY_RENDER_BUF_WIDTH * GIMP_DISPLAY_RENDER_MAX_SCALE;
gint h = GIMP_DISPLAY_RENDER_BUF_HEIGHT * GIMP_DISPLAY_RENDER_MAX_SCALE;
shell->filter_data =
gegl_malloc (w * h * babl_format_get_bytes_per_pixel (filter_format));
shell->filter_stride = w * babl_format_get_bytes_per_pixel (filter_format);
shell->filter_buffer =
gegl_buffer_linear_new_from_data (shell->filter_data,
filter_format,
GEGL_RECTANGLE (0, 0, w, h),
GEGL_AUTO_ROWSTRIDE,
(GDestroyNotify) gegl_free,
shell->filter_data);
}
gegl_buffer_get (buffer,
GEGL_RECTANGLE (scaled_x, scaled_y,
scaled_width, scaled_height),
buffer_scale,
filter_format, shell->filter_data,
shell->filter_stride, GEGL_ABYSS_CLAMP);
gimp_color_display_stack_convert_buffer (shell->filter_stack,
shell->filter_buffer,
GEGL_RECTANGLE (0, 0,
scaled_width,
scaled_height));
gegl_buffer_get (shell->filter_buffer,
GEGL_RECTANGLE (0, 0,
scaled_width,
scaled_height),
1.0,
babl_format ("cairo-ARGB32"),
data, stride,
GEGL_ABYSS_CLAMP);
}
else
{
gegl_buffer_get (buffer,
GEGL_RECTANGLE (scaled_x, scaled_y,
scaled_width, scaled_height),
buffer_scale,
babl_format ("cairo-ARGB32"),
data, stride,
GEGL_ABYSS_CLAMP);
}
if (shell->mask)
{
gint mask_height;
if (! shell->mask_surface)
{
shell->mask_surface =
cairo_image_surface_create (CAIRO_FORMAT_A8,
GIMP_DISPLAY_RENDER_BUF_WIDTH *
GIMP_DISPLAY_RENDER_MAX_SCALE,
GIMP_DISPLAY_RENDER_BUF_HEIGHT *
GIMP_DISPLAY_RENDER_MAX_SCALE);
}
cairo_surface_mark_dirty (shell->mask_surface);
stride = cairo_image_surface_get_stride (shell->mask_surface);
data = cairo_image_surface_get_data (shell->mask_surface);
data += mask_src_y * stride + mask_src_x * 4;
gegl_buffer_get (shell->mask,
GEGL_RECTANGLE (scaled_x, scaled_y,
scaled_width, scaled_height),
buffer_scale,
babl_format ("Y u8"),
data, stride,
GEGL_ABYSS_CLAMP);
/* invert the mask so what is *not* the foreground object is masked */
mask_height = scaled_height;
while (mask_height--)
{
gint mask_width = scaled_width;
guchar *d = data;
while (mask_width--)
{
guchar inv = 255 - *d;
*d++ = inv;
}
data += stride;
}
}
/* put it to the screen */
cairo_save (cr);
cairo_rectangle (cr, x, y, w, h);
cairo_scale (cr, 1.0 / scale_x, 1.0 / scale_y);
cairo_set_source_surface (cr, xfer,
x * scale_x - xfer_src_x,
y * scale_y - xfer_src_y);
if (shell->rotate_transform)
{
cairo_pattern_t *pattern;
pattern = cairo_get_source (cr);
cairo_pattern_set_extend (pattern, CAIRO_EXTEND_PAD);
cairo_set_line_width (cr, 1.0);
cairo_stroke_preserve (cr);
cairo_surface_destroy (xfer);
}
cairo_clip (cr);
cairo_paint (cr);
if (shell->mask)
{
gimp_cairo_set_source_rgba (cr, &shell->mask_color);
cairo_mask_surface (cr, shell->mask_surface,
(x - mask_src_x) * scale_x,
(y - mask_src_y) * scale_y);
}
cairo_restore (cr);
}
bool wxGTKCairoDCImpl::DoStretchBlit(int xdest, int ydest, int dstWidth, int dstHeight, wxDC* source, int xsrc, int ysrc, int srcWidth, int srcHeight, wxRasterOperationMode rop, bool useMask, int xsrcMask, int ysrcMask)
{
wxCHECK_MSG(IsOk(), false, "invalid DC");
wxCHECK_MSG(source && source->IsOk(), false, "invalid source DC");
cairo_t* cr = NULL;
if (m_graphicContext)
cr = static_cast<cairo_t*>(m_graphicContext->GetNativeContext());
cairo_t* cr_src = NULL;
wxGraphicsContext* gc_src = source->GetGraphicsContext();
if (gc_src)
cr_src = static_cast<cairo_t*>(gc_src->GetNativeContext());
if (cr == NULL || cr_src == NULL)
return false;
const int xsrc_dev = source->LogicalToDeviceX(xsrc);
const int ysrc_dev = source->LogicalToDeviceY(ysrc);
cairo_surface_t* surfaceSrc = cairo_get_target(cr_src);
cairo_surface_flush(surfaceSrc);
cairo_surface_t* surfaceTmp = NULL;
// If destination (this) and source wxDC refer to the same Cairo context
// it means that we operate on one surface and results of drawing
// can be invalid if destination and source regions overlap.
// In such situation we have to copy source surface to the temporary
// surface and use this copy in the drawing operations.
if ( cr == cr_src )
{
// Check if destination and source regions overlap.
// If necessary, copy source surface to the temporary one.
if (wxRect(xdest, ydest, dstWidth, dstHeight)
.Intersects(wxRect(xsrc, ysrc, srcWidth, srcHeight)))
{
const int w = cairo_image_surface_get_width(surfaceSrc);
const int h = cairo_image_surface_get_height(surfaceSrc);
#if CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1, 12, 0)
if ( cairo_version() >= CAIRO_VERSION_ENCODE(1, 12, 0) )
{
surfaceTmp = cairo_surface_create_similar_image(surfaceSrc,
cairo_image_surface_get_format(surfaceSrc),
w, h);
}
else
#endif // Cairo 1.12
{
surfaceTmp = cairo_surface_create_similar(surfaceSrc,
CAIRO_CONTENT_COLOR_ALPHA,
w, h);
}
cairo_t* crTmp = cairo_create(surfaceTmp);
cairo_set_source_surface(crTmp, surfaceSrc, 0, 0);
cairo_rectangle(crTmp, 0.0, 0.0, w, h);
cairo_set_operator(crTmp, CAIRO_OPERATOR_SOURCE);
cairo_fill(crTmp);
cairo_destroy(crTmp);
cairo_surface_flush(surfaceTmp);
surfaceSrc = surfaceTmp;
}
}
cairo_save(cr);
cairo_translate(cr, xdest, ydest);
cairo_rectangle(cr, 0, 0, dstWidth, dstHeight);
double sx, sy;
source->GetUserScale(&sx, &sy);
cairo_scale(cr, dstWidth / (sx * srcWidth), dstHeight / (sy * srcHeight));
cairo_set_source_surface(cr, surfaceSrc, -xsrc_dev, -ysrc_dev);
const wxRasterOperationMode rop_save = m_logicalFunction;
SetLogicalFunction(rop);
cairo_pattern_set_filter(cairo_get_source(cr), CAIRO_FILTER_NEAREST);
cairo_surface_t* maskSurf = NULL;
if (useMask)
{
const wxBitmap& bitmap = source->GetImpl()->GetSelectedBitmap();
if (bitmap.IsOk())
{
wxMask* mask = bitmap.GetMask();
if (mask)
maskSurf = *mask;
}
}
if (maskSurf)
{
int xsrcMask_dev = xsrc_dev;
int ysrcMask_dev = ysrc_dev;
if (xsrcMask != -1)
xsrcMask_dev = source->LogicalToDeviceX(xsrcMask);
if (ysrcMask != -1)
ysrcMask_dev = source->LogicalToDeviceY(ysrcMask);
cairo_clip(cr);
cairo_mask_surface(cr, maskSurf, -xsrcMask_dev, -ysrcMask_dev);
}
else
{
cairo_fill(cr);
}
cairo_restore(cr);
if ( surfaceTmp )
{
cairo_surface_destroy(surfaceTmp);
}
m_logicalFunction = rop_save;
return true;
}
/**
* gdk_cairo_draw_from_gl:
* @cr: a cairo context
* @window: The window we're rendering for (not necessarily into)
* @source: The GL ID of the source buffer
* @source_type: The type of the @source
* @buffer_scale: The scale-factor that the @source buffer is allocated for
* @x: The source x position in @source to start copying from in GL coordinates
* @y: The source y position in @source to start copying from in GL coordinates
* @width: The width of the region to draw
* @height: The height of the region to draw
*
* This is the main way to draw GL content in GTK+. It takes a render buffer ID
* (@source_type == #GL_RENDERBUFFER) or a texture id (@source_type == #GL_TEXTURE)
* and draws it onto @cr with an OVER operation, respecting the current clip.
* The top left corner of the rectangle specified by @x, @y, @width and @height
* will be drawn at the current (0,0) position of the cairo_t.
*
* This will work for *all* cairo_t, as long as @window is realized, but the
* fallback implementation that reads back the pixels from the buffer may be
* used in the general case. In the case of direct drawing to a window with
* no special effects applied to @cr it will however use a more efficient
* approach.
*
* For #GL_RENDERBUFFER the code will always fall back to software for buffers
* with alpha components, so make sure you use #GL_TEXTURE if using alpha.
*
* Calling this may change the current GL context.
*
* Since: 3.16
*/
void
gdk_cairo_draw_from_gl (cairo_t *cr,
GdkWindow *window,
int source,
int source_type,
int buffer_scale,
int x,
int y,
int width,
int height)
{
GdkGLContext *paint_context;
cairo_surface_t *image;
cairo_matrix_t matrix;
int dx, dy, window_scale;
gboolean trivial_transform;
cairo_surface_t *group_target;
GdkWindow *direct_window, *impl_window;
guint framebuffer;
int alpha_size = 0;
cairo_region_t *clip_region;
GdkGLContextPaintData *paint_data;
impl_window = window->impl_window;
window_scale = gdk_window_get_scale_factor (impl_window);
paint_context = gdk_window_get_paint_gl_context (window, NULL);
if (paint_context == NULL)
{
g_warning ("gdk_cairo_draw_gl_render_buffer failed - no paint context");
return;
}
clip_region = gdk_cairo_region_from_clip (cr);
gdk_gl_context_make_current (paint_context);
paint_data = gdk_gl_context_get_paint_data (paint_context);
if (paint_data->tmp_framebuffer == 0)
glGenFramebuffersEXT (1, &paint_data->tmp_framebuffer);
if (source_type == GL_RENDERBUFFER)
{
glBindRenderbuffer (GL_RENDERBUFFER, source);
glGetRenderbufferParameteriv (GL_RENDERBUFFER, GL_RENDERBUFFER_ALPHA_SIZE, &alpha_size);
}
else if (source_type == GL_TEXTURE)
{
glBindTexture (GL_TEXTURE_2D, source);
glGetTexLevelParameteriv (GL_TEXTURE_2D, 0, GL_TEXTURE_ALPHA_SIZE, &alpha_size);
}
else
{
g_warning ("Unsupported gl source type %d\n", source_type);
return;
}
group_target = cairo_get_group_target (cr);
direct_window = cairo_surface_get_user_data (group_target, &direct_key);
cairo_get_matrix (cr, &matrix);
dx = matrix.x0;
dy = matrix.y0;
/* Trivial == integer-only translation */
trivial_transform =
(double)dx == matrix.x0 && (double)dy == matrix.y0 &&
matrix.xx == 1.0 && matrix.xy == 0.0 &&
matrix.yx == 0.0 && matrix.yy == 1.0;
/* For direct paint of non-alpha renderbuffer, we can
just do a bitblit */
if ((_gdk_gl_flags & GDK_GL_SOFTWARE_DRAW_GL) == 0 &&
source_type == GL_RENDERBUFFER &&
alpha_size == 0 &&
direct_window != NULL &&
direct_window->current_paint.use_gl &&
trivial_transform &&
clip_region != NULL)
{
int unscaled_window_height;
int i;
/* Create a framebuffer with the source renderbuffer and
make it the current target for reads */
framebuffer = paint_data->tmp_framebuffer;
glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, framebuffer);
glFramebufferRenderbufferEXT (GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
GL_RENDERBUFFER_EXT, source);
glBindFramebufferEXT (GL_DRAW_FRAMEBUFFER_EXT, 0);
/* Translate to impl coords */
cairo_region_translate (clip_region, dx, dy);
glEnable (GL_SCISSOR_TEST);
gdk_window_get_unscaled_size (impl_window, NULL, &unscaled_window_height);
glDrawBuffer (GL_BACK);
#define FLIP_Y(_y) (unscaled_window_height - (_y))
for (i = 0; i < cairo_region_num_rectangles (clip_region); i++)
{
cairo_rectangle_int_t clip_rect, dest;
cairo_region_get_rectangle (clip_region, i, &clip_rect);
clip_rect.x *= window_scale;
clip_rect.y *= window_scale;
clip_rect.width *= window_scale;
clip_rect.height *= window_scale;
glScissor (clip_rect.x, FLIP_Y (clip_rect.y + clip_rect.height),
clip_rect.width, clip_rect.height);
dest.x = dx * window_scale;
dest.y = dy * window_scale;
dest.width = width * window_scale / buffer_scale;
dest.height = height * window_scale / buffer_scale;
if (gdk_rectangle_intersect (&clip_rect, &dest, &dest))
{
int clipped_src_x = x + (dest.x - dx * window_scale);
int clipped_src_y = y + (height - dest.height - (dest.y - dy * window_scale));
glBlitFramebufferEXT(clipped_src_x, clipped_src_y,
(clipped_src_x + dest.width), (clipped_src_y + dest.height),
dest.x, FLIP_Y(dest.y + dest.height),
dest.x + dest.width, FLIP_Y(dest.y),
GL_COLOR_BUFFER_BIT, GL_NEAREST);
if (impl_window->current_paint.flushed_region)
{
cairo_rectangle_int_t flushed_rect;
flushed_rect.x = dest.x / window_scale;
flushed_rect.y = dest.y / window_scale;
flushed_rect.width = (dest.x + dest.width + window_scale - 1) / window_scale - flushed_rect.x;
flushed_rect.height = (dest.y + dest.height + window_scale - 1) / window_scale - flushed_rect.y;
cairo_region_union_rectangle (impl_window->current_paint.flushed_region,
&flushed_rect);
cairo_region_subtract_rectangle (impl_window->current_paint.need_blend_region,
&flushed_rect);
}
}
}
glDisable (GL_SCISSOR_TEST);
glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, 0);
#undef FLIP_Y
}
/* For direct paint of alpha or non-alpha textures we can use texturing */
else if ((_gdk_gl_flags & GDK_GL_SOFTWARE_DRAW_GL) == 0 &&
source_type == GL_TEXTURE &&
direct_window != NULL &&
direct_window->current_paint.use_gl &&
trivial_transform &&
clip_region != NULL)
{
int unscaled_window_height;
GLint texture_width;
GLint texture_height;
int i, n_rects, n_quads;
GdkTexturedQuad *quads;
cairo_rectangle_int_t clip_rect;
/* Translate to impl coords */
cairo_region_translate (clip_region, dx, dy);
if (alpha_size != 0)
{
cairo_region_t *opaque_region, *blend_region;
opaque_region = cairo_region_copy (clip_region);
cairo_region_subtract (opaque_region, impl_window->current_paint.flushed_region);
cairo_region_subtract (opaque_region, impl_window->current_paint.need_blend_region);
if (!cairo_region_is_empty (opaque_region))
gdk_gl_texture_from_surface (impl_window->current_paint.surface,
opaque_region);
blend_region = cairo_region_copy (clip_region);
cairo_region_intersect (blend_region, impl_window->current_paint.need_blend_region);
glEnable (GL_BLEND);
if (!cairo_region_is_empty (blend_region))
gdk_gl_texture_from_surface (impl_window->current_paint.surface,
blend_region);
cairo_region_destroy (opaque_region);
cairo_region_destroy (blend_region);
}
glBindTexture (GL_TEXTURE_2D, source);
glGetTexLevelParameteriv (GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &texture_width);
glGetTexLevelParameteriv (GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &texture_height);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glEnable (GL_SCISSOR_TEST);
gdk_window_get_unscaled_size (impl_window, NULL, &unscaled_window_height);
#define FLIP_Y(_y) (unscaled_window_height - (_y))
cairo_region_get_extents (clip_region, &clip_rect);
glScissor (clip_rect.x * window_scale, FLIP_Y ((clip_rect.y + clip_rect.height) * window_scale),
clip_rect.width * window_scale, clip_rect.height * window_scale);
n_quads = 0;
n_rects = cairo_region_num_rectangles (clip_region);
quads = g_new (GdkTexturedQuad, n_rects);
for (i = 0; i < n_rects; i++)
{
cairo_rectangle_int_t dest;
cairo_region_get_rectangle (clip_region, i, &clip_rect);
clip_rect.x *= window_scale;
clip_rect.y *= window_scale;
clip_rect.width *= window_scale;
clip_rect.height *= window_scale;
dest.x = dx * window_scale;
dest.y = dy * window_scale;
dest.width = width * window_scale / buffer_scale;
dest.height = height * window_scale / buffer_scale;
if (gdk_rectangle_intersect (&clip_rect, &dest, &dest))
{
int clipped_src_x = x + (dest.x - dx * window_scale);
int clipped_src_y = y + (height - dest.height - (dest.y - dy * window_scale));
GdkTexturedQuad quad = {
dest.x, FLIP_Y(dest.y),
dest.x + dest.width, FLIP_Y(dest.y + dest.height),
clipped_src_x / (float)texture_width, (clipped_src_y + dest.height) / (float)texture_height,
(clipped_src_x + dest.width) / (float)texture_width, clipped_src_y / (float)texture_height,
};
quads[n_quads++] = quad;
if (impl_window->current_paint.flushed_region)
{
cairo_rectangle_int_t flushed_rect;
flushed_rect.x = dest.x / window_scale;
flushed_rect.y = dest.y / window_scale;
flushed_rect.width = (dest.x + dest.width + window_scale - 1) / window_scale - flushed_rect.x;
flushed_rect.height = (dest.y + dest.height + window_scale - 1) / window_scale - flushed_rect.y;
cairo_region_union_rectangle (impl_window->current_paint.flushed_region,
&flushed_rect);
cairo_region_subtract_rectangle (impl_window->current_paint.need_blend_region,
&flushed_rect);
}
}
}
if (n_quads > 0)
gdk_gl_texture_quads (paint_context, GL_TEXTURE_2D, n_quads, quads);
g_free (quads);
if (alpha_size != 0)
glDisable (GL_BLEND);
#undef FLIP_Y
}
else
{
/* Software fallback */
/* TODO: avoid reading back non-required data due to dest clip */
image = cairo_surface_create_similar_image (cairo_get_target (cr),
(alpha_size == 0) ? CAIRO_FORMAT_RGB24 : CAIRO_FORMAT_ARGB32,
width, height);
cairo_surface_set_device_scale (image, buffer_scale, buffer_scale);
framebuffer = paint_data->tmp_framebuffer;
glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, framebuffer);
if (source_type == GL_RENDERBUFFER)
{
/* Create a framebuffer with the source renderbuffer and
make it the current target for reads */
glFramebufferRenderbufferEXT (GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
GL_RENDERBUFFER_EXT, source);
}
else
{
glFramebufferTexture2DEXT (GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
GL_TEXTURE_2D, source, 0);
}
glPixelStorei (GL_PACK_ALIGNMENT, 4);
glPixelStorei (GL_PACK_ROW_LENGTH, cairo_image_surface_get_stride (image) / 4);
glReadPixels (x, y, width, height, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV,
cairo_image_surface_get_data (image));
glPixelStorei (GL_PACK_ROW_LENGTH, 0);
glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, 0);
cairo_surface_mark_dirty (image);
/* Invert due to opengl having different origin */
cairo_scale (cr, 1, -1);
cairo_translate (cr, 0, -height / buffer_scale);
cairo_set_source_surface (cr, image, 0, 0);
cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
cairo_paint (cr);
cairo_surface_destroy (image);
}
if (clip_region)
cairo_region_destroy (clip_region);
}
