cairo_surface_t *
ink_cairo_surface_create_output(cairo_surface_t *image, cairo_surface_t *bg)
{
cairo_content_t imgt = cairo_surface_get_content(image);
cairo_content_t bgt = cairo_surface_get_content(bg);
cairo_surface_t *out = NULL;
if (bgt == CAIRO_CONTENT_ALPHA && imgt == CAIRO_CONTENT_ALPHA) {
out = ink_cairo_surface_create_identical(bg);
} else {
out = ink_cairo_surface_create_same_size(bg, CAIRO_CONTENT_COLOR_ALPHA);
}
return out;
}
void
Drawing::render(DrawingContext &ct, Geom::IntRect const &area, unsigned flags)
{
if (_root) {
_root->render(ct, area, flags);
}
if (colorMode() == COLORMODE_GRAYSCALE) {
// apply grayscale filter on top of everything
cairo_surface_t *input = ct.rawTarget();
cairo_surface_t *out = ink_cairo_surface_create_identical(input);
ink_cairo_surface_filter(input, out, _grayscale_colormatrix);
Geom::Point origin = ct.targetLogicalBounds().min();
ct.setSource(out, origin[Geom::X], origin[Geom::Y]);
ct.setOperator(CAIRO_OPERATOR_SOURCE);
ct.paint();
ct.setOperator(CAIRO_OPERATOR_OVER);
cairo_surface_destroy(out);
}
}
/**
* Create an exact copy of a surface.
* Creates a surface that has the same type, content type, dimensions and contents
* as the specified surface.
*/
cairo_surface_t *
ink_cairo_surface_copy(cairo_surface_t *s)
{
cairo_surface_t *ns = ink_cairo_surface_create_identical(s);
if (cairo_surface_get_type(s) == CAIRO_SURFACE_TYPE_IMAGE) {
// use memory copy instead of using a Cairo context
cairo_surface_flush(s);
int stride = cairo_image_surface_get_stride(s);
int h = cairo_image_surface_get_height(s);
memcpy(cairo_image_surface_get_data(ns), cairo_image_surface_get_data(s), stride * h);
cairo_surface_mark_dirty(ns);
} else {
// generic implementation
cairo_t *ct = cairo_create(ns);
cairo_set_source_surface(ct, s, 0, 0);
cairo_set_operator(ct, CAIRO_OPERATOR_SOURCE);
cairo_paint(ct);
cairo_destroy(ct);
}
return ns;
}
void FilterTile::render_cairo(FilterSlot &slot)
{
// FIX ME!
static bool tile_warning = false;
if (!tile_warning) {
g_warning("Renderer for feTile has non-optimal implementation, expect slowness and bugs.");
tile_warning = true;
}
// Fixing isn't so easy as the Inkscape renderer breaks the canvas into "rendering" tiles for
// faster rendering. (The "rendering" tiles are not the same as the tiles in this primitive.)
// Only if the the feTile tile source falls inside the current "rendering" tile will the tile
// image be available.
// This input source contains only the "rendering" tile.
cairo_surface_t *in = slot.getcairo(_input);
// For debugging
// static int i = 0;
// ++i;
// std::stringstream filename;
// filename << "dump." << i << ".png";
// cairo_surface_write_to_png( in, filename.str().c_str() );
// This is the feTile source area as determined by the input primitive area (see SVG spec).
Geom::Rect tile_area = slot.get_primitive_area(_input);
if( tile_area.width() == 0.0 || tile_area.height() == 0.0 ) {
slot.set(_output, in);
std::cerr << "FileTile::render_cairo: tile has zero width or height" << std::endl;
} else {
cairo_surface_t *out = ink_cairo_surface_create_identical(in);
// color_interpolation_filters for out same as in.
copy_cairo_surface_ci(in, out);
cairo_t *ct = cairo_create(out);
// The rectangle of the "rendering" tile.
Geom::Rect sa = slot.get_slot_area();
Geom::Affine trans = slot.get_units().get_matrix_user2pb();
// Create feTile tile ----------------
// Get tile area in pixbuf units (tile transformed).
Geom::Rect tt = tile_area * trans;
// Shift between "rendering" tile and feTile tile
Geom::Point shift = sa.min() - tt.min();
// Create feTile tile surface
cairo_surface_t *tile = cairo_surface_create_similar(in, cairo_surface_get_content(in),
tt.width(), tt.height());
cairo_t *ct_tile = cairo_create(tile);
cairo_set_source_surface(ct_tile, in, shift[Geom::X], shift[Geom::Y]);
cairo_paint(ct_tile);
// Paint tiles ------------------
// For debugging
// std::stringstream filename;
// filename << "tile." << i << ".png";
// cairo_surface_write_to_png( tile, filename.str().c_str() );
// Determine number of feTile rows and columns
Geom::Rect pr = filter_primitive_area( slot.get_units() );
int tile_cols = ceil( pr.width() / tile_area.width() );
int tile_rows = ceil( pr.height() / tile_area.height() );
// Do tiling (TO DO: restrict to slot area.)
for( int col=0; col < tile_cols; ++col ) {
for( int row=0; row < tile_rows; ++row ) {
Geom::Point offset( col*tile_area.width(), row*tile_area.height() );
offset *= trans;
offset[Geom::X] -= trans[4];
offset[Geom::Y] -= trans[5];
cairo_set_source_surface(ct, tile, offset[Geom::X], offset[Geom::Y]);
cairo_paint(ct);
}
}
slot.set(_output, out);
// Clean up
cairo_destroy(ct);
cairo_surface_destroy(out);
cairo_destroy(ct_tile);
cairo_surface_destroy(tile);
}
}